~mdw / ssr / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Initial revision
[ssr] / StraySrc / SDLS / DLLManager / s / dll
1 ;
2 ; dll.s
3 ;
4 ; Handling of DLL data structures
5 ;
6 ; © 1994-1998 Straylight
7 ;
8
9 ;----- Licensing note -------------------------------------------------------
10 ;
11 ; This file is part of Straylight's Dynamic Linking System (SDLS)
12 ;
13 ; SDLS is free software; you can redistribute it and/or modify
14 ; it under the terms of the GNU General Public License as published by
15 ; the Free Software Foundation; either version 2, or (at your option)
16 ; any later version.
17 ;
18 ; SDLS is distributed in the hope that it will be useful,
19 ; but WITHOUT ANY WARRANTY; without even the implied warranty of
20 ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 ; GNU General Public License for more details.
22 ;
23 ; You should have received a copy of the GNU General Public License
24 ; along with SDLS. If not, write to the Free Software Foundation,
25 ; 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
26
27 ;----- Standard header ------------------------------------------------------
28
29 GET libs:header
30 GET libs:swis
31
32 GET libs:stream
33
34 ;----- External dependencies ------------------------------------------------
35
36 GET sh.wSpace
37 GET sh.dllblock
38 GET sh.linkblock
39
40 GET sh.misc
41 GET sh.app
42
43 GET sh.messages
44
45 ;----- External routines ----------------------------------------------------
46
47 AREA |DLLM$$Code|,CODE,READONLY
48
49 GBLL debug
50 debug SETL {FALSE}
51
52 ; --- dll_find ---
53 ;
54 ; On entry: R0 == name of DLL to find
55 ; R1 == minimum version number of DLL
56 ; On exit: R0 == pointer to DLL block, or error
57
58 EXPORT dll_find
59 dll_find ROUT
60
61 STMFD R13!,{R1-R4,R14} ;Preserve registers
62
63 MOV R4,R1 ;Keep hold of version number
64 MOV R1,R0 ;Keep pointer to string
65 LDR R3,dll__list ;Find the list
66
67 00dll_find CMP R3,#0 ;Is this the end of the line?
68 BEQ %40dll_find ;Yes -- give an error
69 LDR R0,[R3,#dl_name] ;Find the name string
70 MOV R2,#0 ;Caseless compare
71 BL misc_strcmp ;Compare the strings
72 LDRNE R3,[R3,#dl_next] ;If no match, move on...
73 BNE %00dll_find ;... and try again
74
75 ; --- We found a name match ---
76
77 LDR R0,[R3,#dl_version] ;Get version of DLL
78 CMP R0,R4 ;Check against version here
79 LDRLT R3,[R3,#dl_next] ;If too low, move on...
80 BLT %00dll_find ;... and try again
81
82 ; --- The name checked out -- return ---
83
84 MOV R0,R3 ;Point to DLL (give handle)
85 LDMFD R13!,{R1-R4,PC}^ ;And return to caller
86
87 ; --- It wasn't there. Return an error ---
88
89 40dll_find MOV R0,R4 ;Get version number
90 BL dll_convertVersion ;Convert it to a string
91 MOV R2,R0 ;Keep pointer to the string
92 ADRL R0,msg_errDLLNotFound ;Couldn't find DLL name
93 BL misc_error ;... create an error message
94 LDMFD R13!,{R1-R4,R14} ;... restore registers
95 ORRS PC,R14,#V_flag ;... and return an error
96
97 LTORG
98
99 ; --- dll_ensure ---
100 ;
101 ; On entry: R0 == pointer to name to load
102 ; R1 == version number of DLL
103 ; On exit: R0 == DLL handle
104
105 EXPORT dll_ensure
106 dll_ensure ROUT
107
108 STMFD R13!,{R1-R5,R9-R11,R14} ;Stash registers somewhere
109
110 ; --- Find the name, and see if it's in memory ---
111
112 MOV R10,R1 ;Save the version number
113 BL dll__createName ;Set up the name
114 CMP R0,#0 ;Was it in memory?
115 LDMNEFD R13!,{R1-R5,R9-R11,PC} ;If so, we should be happy
116 MOV R9,R2 ;Keep pointer to leafname
117
118 ; --- Find the size of the DLL and allocate memory ---
119
120 01dll_ensure MOV R0,#17 ;Read catalogue information
121 SWI XOS_File ;Read the information
122 LDMVSFD R13!,{R1-R5,R9-R11,PC} ;If it failed, return now
123 CMP R0,#1 ;Check that the file was OK
124 BNE %08dll_ensure ;If not, complain properly
125 ADD R3,R4,#dl_extra ;Size of memory to get
126 MOV R0,#6 ;Allocate memory from RMA
127 SWI XOS_Module ;Allocate it
128 LDMVSFD R13!,{R1-R5,R9-R11,PC} ;If no memory, return error
129
130 ; --- Load the DLL into the block ---
131
132 MOV R0,R2 ;Pointer to the block to use
133 MOV R11,R0 ;Keep hold of DLL handle
134 BL dll__load ;Load the DLL into the block
135 BVS %10dll_ensure ;If it failed, return error
136
137 ; --- Check the DLL's version number ---
138
139 LDR R1,[R11,#dl_version] ;Load the DLL's version
140 CMP R1,R10 ;Compare against version
141 BLT %09dll_ensure ;If too old, give an error
142
143 ; --- Link the new DLL into the list ---
144 ;
145 ; This also marks the DLL as being shared, since the shared
146 ; marker is dl_next not being -1.
147
148 LDR R2,dll__list ;Point to list head
149 STR R11,dll__list ;Store the next one
150 MOV R0,#0 ;Ready to zero bits
151 STR R0,[R11,#dl_prev] ;No previous DLL yet
152 STR R2,[R11,#dl_next] ;Fix up next link
153 CMP R2,#0 ;Is there another block?
154 STRNE R11,[R2,#dl_prev] ;If so, fix up prev link
155
156 ; --- Fix up other bits of data ---
157
158 MOV R0,#dl_tentative ;Set DLL's `tentative' bit
159 STR R0,[R11,#dl_clients] ;No clients registered yet
160
161 ; --- Start up any required DLLs ---
162
163 LDR R1,[R11,#dl_dllLimit] ;Find limit of DLL block
164 LDR R0,[R11,#dl_dllBase] ;Find base of same
165 BL app_sfromtbl ;Load any other required DLLs
166
167 ; --- Now return the DLL handle ---
168
169 MOVVC R0,R11 ;Get the DLL handle
170 LDMFD R13!,{R1-R5,R9-R11,PC} ;Return
171
172 ; --- Say that the file wasn't found ---
173
174 08dll_ensure ADRL R0,msg_errFileNotFound ;Point to error skeleton
175 BL misc_error ;Create the message
176 B %10dll_ensure ;Return to an error
177
178 ; --- Create an error about old version ---
179
180 09dll_ensure MOV R0,R10 ;Get the required version
181 BL dll_convertVersion ;Convert to a string
182 MOV R2,R0 ;Make that fillin 2
183 MOV R1,R9 ;Point to DLL name string
184 ADRL R0,msg_errDLLTooOld ;Point to error skeleton
185 BL misc_error ;Set up the error block
186
187 ; --- Free up memory and return an error ---
188
189 10dll_ensure MOV R1,R0 ;Keep hold of the error
190 MOV R0,#7 ;Free the block I allocated
191 MOV R2,R11 ;Point to the DLL block
192 SWI XOS_Module ;Do the free operation
193 MOV R0,R1 ;Put the error pointer back
194 LDMFD R13!,{R1-R5,R9-R11,R14} ;Retreive registers
195 ORRS PC,R14,#V_flag ;Return with an error
196
197 LTORG
198
199 ; --- dll_check ---
200 ;
201 ; On entry: R0 == pointer to name to load <SPACE> version number
202 ; On exit: --
203
204 ; --- The format string for the command line ---
205
206 dll__checkfmt DCB "/a/g,"
207 DCB "/a/g",0
208 ALIGN
209
210 EXPORT dll_check
211 dll_check ROUT
212
213 STMFD R13!,{R1-R5,R9-R11,R14} ;Stack cunning registers
214
215 ; --- Allocate a nice buffer ---
216
217 MOV R10,R0 ;Keep pointer to cmd string
218 MOV R0,#6 ;Allocate some memory
219 MOV R3,#256 ;The size of said memory
220 SWI XOS_Module ;Get it
221 LDMVSFD R13!,{R1-R5,R9-R11,PC} ;Return if we can't have it
222 MOV R11,R2 ;Save the pointer
223
224 ; --- Parse up the command string ---
225
226 ADR R0,dll__checkfmt ;Point to format string
227 MOV R1,R10 ;Point to command string
228 MOV R2,R11 ;Point to my nice buffer
229 MOV R3,#256 ;And do the business
230 SWI XOS_ReadArgs ;Get the OS to parse it up
231 BVS %90dll_check ;If it failed, return
232
233 ; --- Read the version number ---
234
235 LDR R5,[R11,#4] ;Get info about version strng
236 LDRB R4,[R5,#0] ;Get LSB of its length
237 LDRB R3,[R5,#1] ;Get MSB of its length
238 ORR R4,R4,R3,LSL #8 ;Turn this into a length
239
240 MOV R3,#10 ;We're multiplying a lot
241 MOV R10,#0 ;The version as we know it
242 MOV R2,#0 ;Decimal part of version
243 ADD R5,R5,#2 ;Point to the real string
244
245 CMP R4,#0 ;Is there a string there?
246 BEQ %70dll_check ;No -- that's an error
247 00dll_check LDRB R0,[R5],#1 ;Get a character
248 CMP R0,#'.' ;Is it a decimal point?
249 BEQ %01dll_check ;Yes -- next bit please
250 BL %80dll_check ;Convert it to a number
251 MLA R10,R3,R10,R0 ;Add the digit on
252 SUBS R4,R4,#1 ;Decrement length count
253 BNE %00dll_check ;Get another digit if I can
254 B %03dll_check ;Now check for the DLL...
255
256 01dll_check CMP R4,#1 ;Is the string empty now?
257 BEQ %03dll_check ;Yes -- get on with it
258 LDRB R0,[R5] ;Get the next digit
259 BL %80dll_check ;Convert it to a number
260 MUL R2,R3,R0 ;And put it nicely away
261 CMP R4,#2 ;Is there only one char?
262 BEQ %03dll_check ;Yes -- we've done it now
263 LDRB R0,[R5,#1] ;Get the remaining digit
264 BL %80dll_check ;Convert it to a number
265 ADD R2,R2,R0 ;And put it in
266 CMP R4,#3 ;Make sure that's all
267 BNE %70dll_check ;If not, complain
268
269 03dll_check MOV R3,#100 ;Now join the two together
270 MLA R10,R3,R10,R2 ;Now we have a version!
271
272 ; --- Now mangle the name to something usable ---
273
274 LDR R0,[R11,#0] ;Point to name info
275 LDRB R4,[R0,#0] ;Get LSB of name length
276 LDRB R3,[R0,#1] ;Get MSB of name length
277 ORR R4,R4,R3,LSL #8 ;Convert to a real length
278 ADD R0,R0,#2 ;Point to the actual name
279 MOV R1,#0 ;Zero-terminate it
280 STRB R1,[R0,R4] ;Store that in right place
281
282 ; --- Find out a good name to use ---
283
284 MOV R1,R10 ;Get the version number
285 BL dll__createName ;Turn this into a filename
286 CMP R0,#0 ;Was it in memory?
287 BEQ %10dll_check ;No -- continue onwards
288 MOV R0,#7 ;Free that buffer
289 MOV R2,R11 ;Point to it
290 SWI XOS_Module ;Free it for real now
291 LDMFD R13!,{R1-R5,R9-R11,PC}^ ;Return to caller
292
293 ; --- Free the OS_ReadArgs buffer now ---
294
295 10dll_check MOV R9,R2 ;Keep pointer to leafname
296 MOV R0,#7 ;Free that buffer
297 MOV R2,R11 ;Point to it
298 SWI XOS_Module ;Free it for real now
299 ADD R11,R1,#200 ;Keep a pointer to misc_buf
300
301 ; --- Open a file for the DLL ---
302
303 MOV R0,#&4F ;Open, with errors, no path
304 SWI XOS_Find ;Find the file
305 BVS %90dll_check ;If it failed, give error
306 MOV R5,R0 ;Look after the handle
307
308 ; --- Now load a bit of the file ---
309
310 MOV R2,R11 ;Point to the misc_buf
311 MOV R1,R5 ;Get the file handle
312 MOV R3,#20 ;Get the first twenty bytes
313 MOV R4,#0 ;Read from the beginning
314 MOV R0,#3 ;Read bytes from file
315 SWI XOS_GBPB ;Quick, now, do it
316
317 ; --- Close the file ---
318
319 MOV R0,#0 ;Close the file
320 MOV R1,R5 ;Get the file handle
321 SWI XOS_Find ;Close the file
322
323 ; --- Now check the fields in the block ---
324
325 LDR R0,[R11,#dl_magic-dl_extra] ;Get the magic DLL word
326 LDR R1,=dl_MAGIC ;Get the real version
327 CMP R0,R1 ;Check it's kosher
328 BNE %91dll_check ;If not, make an error
329
330 LDR R0,[R11,#dl_bversion-dl_extra] ;Get format version
331 LDR R1,=dl_VERSION ;Get the one we're on now
332 CMP R0,R1 ;Compare the versions
333 BGT %92dll_check ;If too late, complain
334
335 LDR R0,[R11,#dl_version-dl_extra] ;Get DLL version
336 CMP R0,R10 ;Cmp with caller's version
337 BLT %93dll_check ;If too late, complain
338
339 LDMFD R13!,{R1-R5,R9-R11,PC}^ ;Return, job well done
340
341 ; --- Get a digit, and convert ---
342
343 80dll_check CMP R0,#'0' ;Is it less than 0?
344 BLT %70dll_check ;Yes -- that's an error
345 CMP R0,#'9' ;Is it greater than 9?
346 BGT %70dll_check ;Yes -- that's an error
347 SUB R0,R0,#'0' ;Convert to a digit
348 MOVS PC,R14 ;Return to caller
349
350 ; --- Make an error about a mangled version ---
351
352 70dll_check ADRL R0,msg_errBadVersion ;Point to error message
353 B %90dll_check ;Free memory and return error
354
355 ; --- Tidy up after an error and return ---
356
357 90dll_check MOV R9,R0 ;Look after error pointer
358 MOV R0,#7 ;Free that buffer
359 MOV R2,R11 ;Point to it
360 SWI XOS_Module ;Free it for real now
361 MOV R0,R9 ;Point to the error
362 LDMFD R13!,{R1-R5,R9-R11,R14} ;Unstack all the registers
363 ORRS PC,R14,#V_flag ;And return the error
364
365 ; --- A file wasn't a real DLL ---
366
367 91dll_check ADRL R0,msg_errNotADLL ;Point to error
368 MOV R1,R9 ;Point to leafname
369 BL misc_error
370 LDMFD R13!,{R1-R5,R9-R11,R14} ;Unstack all the registers
371 ORRS PC,R14,#V_flag ;And return the error
372
373 ; --- A file had a silly version number ---
374
375 92dll_check ADRL R0,msg_errTooNew ;Point to error
376 MOV R1,R9 ;Point to leafname
377 BL misc_error
378 LDMFD R13!,{R1-R5,R9-R11,R14} ;Unstack all the registers
379 ORRS PC,R14,#V_flag ;And return the error
380
381 ; --- A file was too old for the caller ---
382
383 93dll_check MOV R0,R10 ;Get version number wanted
384 BL dll_convertVersion ;Convert to printable form
385 MOV R2,R0 ;That's fillin number 2
386 ADRL R0,msg_errDLLTooOld ;Point to error
387 MOV R1,R9 ;Point to leafname
388 BL misc_error
389 LDMFD R13!,{R1-R5,R9-R11,R14} ;Unstack all the registers
390 ORRS PC,R14,#V_flag ;And return the error
391
392 LTORG
393
394 ; --- dll_load ---
395 ;
396 ; On entry: R0 == DLL handle (block to load into)
397 ; R1 == filename of DLL
398 ; On exit: --
399
400 EXPORT dll_load
401 dll_load ROUT
402
403 STMFD R13!,{R1,R10,R11,R14} ;Keep link register safe
404
405 ; --- Load the DLL into the block
406
407 MOV R11,R0 ;Keep DLL pointer safe
408 BL dll__load ;Load the DLL
409 LDMVSFD R13!,{R1,R10,R11,PC} ;Return if there's an error
410
411 ; --- If it's late enough, fit it up to the application ---
412
413 LDR R10,[R11,#dl_bversion] ;Get the format version
414 CMP R10,#100 ;Is it the old version?
415
416 LDRGT R1,[R11,#dl_appStubs] ;Find the app stubs table
417 CMPGT R1,R11 ;Is this pointer sensible?
418 BLE %90dll_load ;Yes -- skip this bit
419 LDR R0,[R11,#dl_appStubNames] ;Find the names table
420 CMP R0,R0 ;Clear V flag
421 BL app_fix ;Yes -- fix up the table
422 LDMVSFD R13!,{R1,R10,R11,PC} ;Return if there's an error
423
424 ; --- Load any required shared DLLs ---
425
426 90dll_load LDR R1,[R11,#dl_dllLimit] ;Find limit of DLL block
427 LDR R0,[R11,#dl_dllBase] ;Find base of same
428 BL app_fromtable ;Load any other required DLLs
429 LDMFD R13!,{R1,R10,R11,PC} ;Return to caller
430
431 LTORG
432
433 ; --- dll_appEntry ---
434 ;
435 ; On entry: R0 == pointer to application's entry table
436 ; R1 == pointer to application's name table
437 ; R2 == pointer to entry point name
438 ; On exit: R0 == pointer to entry point (if present)
439
440 EXPORT dll_appEntry
441 dll_appEntry ROUT
442
443 STMFD R13!,{R1-R5,R14} ;Stack registers
444
445 MOV R3,R2 ;Keep pointer to entry point
446
447 ; --- Main matching loop ---
448
449 00dll_appEntry LDRB R4,[R1],#1 ;Get first byte of next name
450 CMP R4,#0 ;Is it a null byte?
451 BEQ %41dll_appEntry ;Yes -- couldn't find entry
452 CMP R4,#1 ;Is it a dummy entry?
453 BEQ %10dll_appEntry ;Yes -- don't check it then
454 01dll_appEntry LDRB R5,[R3],#1 ;Get byte from name too
455 CMP R4,R5 ;Do they match?
456 BNE %02dll_appEntry ;No -- find the next name
457 CMP R4,#0 ;Is this the end?
458 LDRNEB R4,[R1],#1 ;No -- get another name byte
459 BNE %01dll_appEntry ;And go round again
460
461 ; --- We found it ---
462
463 LDR R0,[R0,#0] ;Get the actual entry address
464 LDMFD R13!,{R1-R5,PC}^ ;Return to caller happy
465
466 ; --- Move on to next name in the table ---
467
468 02dll_appEntry CMP R4,#0 ;Is this the end of the name?
469 LDRNEB R4,[R1],#1 ;No -- get another byte
470 BNE %02dll_appEntry ;And go round again
471
472 10dll_appEntry ADD R0,R0,#4 ;Move on to next entry ptr
473 MOV R3,R2 ;Point to start of entry name
474 B %00dll_appEntry ;And try that one out
475
476 ; --- Entry point could not be found ---
477
478 41dll_appEntry MOV R1,R2 ;Point to entry point name
479 ADRL R0,msg_errAppEntry ;Point to error message
480 BL misc_error ;Create the error message
481 LDMFD R13!,{R1-R5,R14} ;Find saved registers
482 ORRS PC,R14,#V_flag ;Return the error to caller
483
484 ALIGN
485
486 ; --- dll_findEntry ---
487 ;
488 ; On entry: R0 == pointer to DLL
489 ; R1 == pointer to entry point name
490 ; On exit: R0 == pointer to entry point
491
492 EXPORT dll_findEntry
493 dll_findEntry ROUT
494
495 STMFD R13!,{R1-R7,R14} ;Stack registers
496
497 ; --- Set up for main loop ---
498
499 LDR R7,[R0,#dl_entries] ;Find number of entry points
500 LDR R3,[R0,#dl_enames] ;Point to start of name table
501 LDR R4,[R0,#dl_eveneer] ;No entry points found yet
502 TST R7,#dl_noNames ;No names?
503 BNE %42dll_findEntry ;Then deal with this
504 BICS R2,R7,#&FF000000 ;Clear entry type flags
505 BEQ %40dll_findEntry ;No entry points -- weird
506
507 ; --- Find whether this name matches ---
508
509 00dll_findEntry MOV R5,R1 ;Point to string to match
510 LDRB R14,[R3,#0] ;Load first byte from name
511 CMP R14,#1 ;Is this a dummy entry?
512 ADDEQ R3,R3,#1 ;Yes -- skip past the byte
513 BEQ %10dll_findEntry ;Yes -- don't check the name
514
515 01dll_findEntry LDRB R6,[R5],#1 ;Read byte from pattern
516 LDRB R14,[R3],#1 ;Read byte from target
517 CMP R6,R14 ;Do they match?
518 BNE %02dll_findEntry ;No -- try another string
519 CMP R6,#0 ;Is this the string end?
520 BNE %01dll_findEntry ;No -- try another char
521
522 ; --- We found the entry point ---
523
524 TST R7,#dl_shortEntries ;Are these APCS veneers?
525 MOVEQ R0,R4 ;Yes -- point to veneer base
526 LDRNE R0,[R4,#0] ;No -- return base address
527 LDMFD R13!,{R1-R7,PC}^ ;Return to caller
528
529 ; --- No luck -- try another entry point ---
530
531 02dll_findEntry CMP R14,#0 ;Is this the end of the name?
532 LDRNEB R14,[R3],#1 ;No -- get another character
533 BNE %02dll_findEntry ;And try again
534
535 10dll_findEntry SUBS R2,R2,#1 ;Decrement entry point count
536 BEQ %41dll_findEntry ;If we ran out, that's it
537
538 TST R7,#dl_shortEntries ;Are these APCS veneers?
539 ADDEQ R4,R4,#16 ;Yes -- move to next veneer
540 ADDNE R4,R4,#4 ;No -- move to next word
541 B %00dll_findEntry ;And try again
542
543 ; --- DLL has no entry points ---
544
545 40dll_findEntry LDR R1,[R0,#dl_name] ;Point to DLL name
546 ADRL R0,msg_errNoEntry ;Point to error message
547 BL misc_error ;Create the error message
548 LDMFD R13!,{R1-R7,R14} ;Find saved registers
549 ORRS PC,R14,#V_flag ;Return the error to caller
550
551 ; --- Entry point could not be found ---
552
553 41dll_findEntry MOV R2,R1 ;Point to entry point name
554 LDR R1,[R0,#dl_name] ;Point to DLL name
555 ADRL R0,msg_errDLLEntry ;Point to error message
556 BL misc_error ;Create the error message
557 LDMFD R13!,{R1-R7,R14} ;Find saved registers
558 ORRS PC,R14,#V_flag ;Return the error to caller
559
560 ; --- DLL has no named entry points ---
561
562 42dll_findEntry LDR R1,[R0,#dl_name] ;Point to DLL name
563 ADRL R0,msg_errNoNames ;Point to error message
564 BL misc_error ;Create the error message
565 LDMFD R13!,{R1-R7,R14} ;Find saved registers
566 ORRS PC,R14,#V_flag ;Return the error to caller
567
568 LTORG
569
570 ; --- dll_showInfo ---
571 ;
572 ; On entry: R0 == pointer to argument string
573 ; On exit: --
574
575 EXPORT dll_showInfo
576 dll_showInfo ROUT
577
578 STMFD R13!,{R1-R4,R14} ;Stack some registers
579
580 ; --- Parse some arguments ---
581
582 MOV R1,R0 ;Point to the command tail
583 ADR R0,dll_sinfoDef ;Point to definition string
584 ADR R2,misc__sharedBuf ;Point to scratch buffer
585 MOV R3,#256 ;Size of my buffer
586 SWI XOS_ReadArgs ;Read the command line
587 LDMVSFD R13!,{R1-R4,PC} ;Return if it didn't work
588
589 MOV R4,#0 ;Clear some flags
590 LDR R14,[R2,#0] ;Load the `full' flag
591 CMP R14,#0 ;Is it clear?
592 ORRNE R4,R4,#1 ;No -- set the flag then
593
594 LDR R0,[R2,#4] ;Load the string pointer
595 CMP R0,#0 ;Is it there?
596 ADREQL R0,synt_DLLInfo - 4 ;No -- point to syntax string
597 LDMEQFD R13!,{R1-R4,R14} ;Restore registers
598 ORREQS PC,R14,#V_flag ;And return to caller
599
600 ; --- Find the DLL ---
601
602 MOV R2,R0 ;Keep hold of the pointer
603 MOV R1,#0 ;Don't care about version
604 BL dll_find ;Find the DLL pointer
605 BVS %10dll_showInfo ;Give an error if not found
606
607 ; --- Show the info :-) ---
608
609 MOV R3,R0 ;Keep pointer to DLL block
610 ADRL R0,msg_dinfoName
611 SWI XOS_Write0
612 LDR R0,[R3,#dl_name] ;Point to the DLL's name
613 SWI XOS_Write0
614 SWI XOS_NewLine
615
616 ADRL R0,msg_dinfoAuthor
617 SWI XOS_Write0
618 LDR R0,[R3,#dl_copyright] ;Point to the DLL's author
619 SWI XOS_Write0
620 SWI XOS_NewLine
621
622 ADRL R0,msg_dinfoVersion
623 SWI XOS_Write0
624 LDR R0,[R3,#dl_version] ;Point to the DLL's version
625 BL dll_convertVersion ;Convert the version number
626 SWI XOS_Write0
627 SWI XOS_NewLine
628
629 ADRL R0,msg_dinfoReferences
630 SWI XOS_Write0
631 LDR R0,[R3,#dl_clients] ;Get client count
632 BIC R0,R0,#dl_tentative ;Clear tentative bit if any
633 SUB R13,R13,#12 ;Give some space for string
634 MOV R1,R13 ;Point to this space
635 MOV R2,#12 ;Size of the buffer
636 SWI XOS_ConvertInteger4 ;Convert it to a string
637 SWI XOS_Write0
638 ADD R13,R13,#12 ;Reclaim workspace
639 SWI XOS_NewLine
640
641 TST R4,#1 ;Do we want to print this?
642 BEQ %02dll_showInfo ;No -- don't then
643
644 ADRL R0,msg_dinfoEntries
645 SWI XOS_Write0
646
647 ; --- Write out entry point names ---
648
649 LDR R2,[R3,#dl_entries] ;Get number of entry points
650 TST R2,#dl_noNames ;No name table?
651 BNE %08dll_showInfo ;No -- tell user
652 BICS R2,R2,#&FF000000 ;Clear type bits
653 BEQ %09dll_showInfo ;No entries -- spooky
654
655 LDR R1,[R3,#dl_enames] ;Point to first entry name
656 00dll_showInfo SWI XOS_WriteI+' ' ;Indent the list a bit
657 SWI XOS_WriteI+' '
658
659 01dll_showInfo LDRB R0,[R1],#1 ;Get a name byte
660 CMP R0,#1 ;Is it a dummy entry?
661 SWIHI XOS_WriteC ;No -- write it out
662 BHS %01dll_showInfo ;And go round for the next
663
664 SWI XOS_NewLine ;Start a new line
665 SUBS R2,R2,#1 ;Done another one
666 BGT %00dll_showInfo ;If more to do, continue
667
668 ; --- Return to caller ---
669
670 02dll_showInfo LDMFD R13!,{R1-R4,PC}^ ;Return with registers nice
671
672 ; --- Entry point table suppressed ---
673
674 08dll_showInfo ADRL R0,msg_dinfoHidden ;Point to the string
675 SWI XOS_Write0 ;Display that on the screen
676 B %02dll_showInfo ;And return to caller
677
678 ; --- No entry points -- freaky ---
679
680 09dll_showInfo ADRL R0,msg_dinfoNone ;Point to the string
681 SWI XOS_Write0 ;Display that on the screen
682 B %02dll_showInfo ;Resume information
683
684 ; --- Couldn't find the DLL ---
685
686 10dll_showInfo MOV R1,R2 ;Point to DLL name
687 ADRL R0,msg_errDLLNotInMem ;Point to the error
688 BL misc_error ;Create error message fully
689 LDMFD R13!,{R1-R4,R14} ;Unstack all registers
690 ORRS PC,R14,#V_flag ;Return to caller with error
691
692 dll_sinfoDef DCB "full/s,",0
693
694 LTORG
695
696 ; --- dll_writeTitle ---
697 ;
698 ; On entry: --
699 ; On exit: --
700
701 EXPORT dll_writeTitle
702 dll_writeTitle ROUT
703
704 STMFD R13!,{R14} ;Stack link register for this
705 ADRL R0,msg_dllHeader ;Point to the header line
706 SWI XOS_Write0 ;Display it nicely
707 LDMFD R13!,{PC}^ ;Return to caller
708
709 LTORG
710
711 ; --- dll_writeInfo ---
712 ;
713 ; On entry: R0 == pointer to a DLL block
714 ; On exit: --
715
716 EXPORT dll_writeInfo
717 dll_writeInfo ROUT
718
719 STMFD R13!,{R1-R3,R14} ;Stack some registers
720 MOV R2,R0 ;Keep hold of pointer
721 MOV R1,#17 ;Length of DLL name
722 LDR R0,[R2,#dl_name] ;Point to the name
723
724 MOV R3,#0 ;Length so far
725 00 LDRB R14,[R0,R3] ;Load a byte
726 CMP R14,#0 ;At the end?
727 ADDNE R3,R3,#1 ;No -- inc length
728 BNE %b00 ;And keep on looping
729
730 CMP R3,#16 ;Is this to long?
731 BL dll_field ;Display the name
732 SWIGT OS_NewLine ;Too long -- print a newline
733 MOVGT R1,#17 ;Print 21 spaces
734 ADRGT R0,dll__nullStr ;Point to the string
735 BLGT dll_field ;And do that thing
736 LDR R0,[R2,#dl_version] ;Load the version
737 BL dll_convertVersion ;Convert it to a string
738 MOV R1,#10 ;Length of version field
739 BL dll_field ;Display it on the screen
740 LDR R0,[R2,#dl_copyright] ;Point to copyright string
741 SWI XOS_Write0 ;Display on the screen
742 SWI XOS_NewLine ;Follow with a newline
743 LDR R2,[R2,#dl_next] ;Point to next one along
744 LDMFD R13!,{R1-R3,PC}^ ;Return to caller
745
746 dll__nullStr DCB 0
747
748 LTORG
749
750 ; --- dll_list ---
751 ;
752 ; On entry: --
753 ; On exit: --
754
755 EXPORT dll_list
756 dll_list ROUT
757
758 STMFD R13!,{R1,R2,R14}
759
760 ; --- Set up for a loop through the list ---
761
762 LDR R2,dll__list ;Point to list
763 CMP R2,#0 ;Check that it's non-null
764 BEQ %01dll_list ;If so, give special message
765
766 ; --- Do a bit of screen set-up ---
767
768 BL dll_writeTitle ;Display the title line
769
770 ; --- Main loop ---
771
772 00dll_list MOV R0,R2 ;Point to DLL block
773 BL dll_writeInfo ;Display info about it
774 LDR R2,[R2,#dl_next] ;Point to next one along
775 CMP R2,#0 ;Is there another one?
776 BNE %00dll_list ;Yes -- display its stuff
777 LDMFD R13!,{R1,R2,PC}^
778
779 01dll_list ADRL R0,msg_noDLLs ;Point to the message
780 SWI XOS_Write0 ;Display that on the screen
781 LDMFD R13!,{R1,R2,PC}^
782
783 LTORG
784
785 ; --- dll_convertVersion ---
786 ;
787 ; On entry: R0 == version number
788 ; On exit: R0 == pointer to version string
789
790 EXPORT dll_convertVersion
791 dll_convertVersion ROUT
792
793 STMFD R13!,{R1-R3,R14} ;Preserve registers
794 MOV R1,#100 ;Divisor
795 BL dll__divide ;Find major and minor version
796 LDMVSFD R13!,{R1-R3,PC} ;Return if there's an error
797 MOV R3,R1 ;Keep minor version
798 ADR R1,misc__sharedBuf ;Point to buffer
799 MOV R2,#16 ;Give it a sensible size
800 SWI XOS_ConvertCardinal3 ;This is excessive, but...
801 LDMVSFD R13!,{R1-R3,PC} ;Return if there's an error
802 MOV R0,#'.' ;To be written to buffer
803 STRB R0,[R1],#1 ;Write the decimal separator
804 SUB R2,R2,#1 ;Another byte used in buffer
805 MOV R0,R3 ;Get minor version number
806 SWI XOS_ConvertCardinal1 ;Can't be more than 100
807 LDMVSFD R13!,{R1-R3,PC} ;Return if there's an error
808 LDRB R2,[R0,#1] ;Get second character
809 CMP R2,#0 ;Is there one?
810 BNE %00dll_convertVersion ;Yes -- skip ahead a bit
811 STRB R2,[R0,#2] ;Leave exactly 2 digits
812 LDRB R2,[R0,#0] ;Get first character
813 STRB R2,[R0,#1] ;Store in second position
814 MOV R2,#'0' ;And write a leading 0
815 STRB R2,[R0,#0] ;In first position
816 00dll_convertVersion
817 ADR R0,misc__sharedBuf ;Point to buffer
818 LDMFD R13!,{R1-R3,PC}^ ;Return to caller nicely
819
820 LTORG
821
822 ; --- dll_field ---
823 ;
824 ; On entry: R0 == pointer to string
825 ; R1 == length of field
826
827 EXPORT dll_field
828 dll_field ROUT
829
830 STMFD R13!,{R1,R2,R14} ;Stash registers
831 MOV R2,R0 ;Keep hold of string ptr
832 00dll_field LDRB R0,[R2],#1 ;Get a string byte
833 CMP R0,#0 ;Check the byte
834 BEQ %01dll_field ;If end, write pad chars
835 SWI XOS_WriteC ;Write the character
836 SUB R1,R1,#1 ;Decrement counter thing
837 B %00dll_field ;If allowed, get the next one
838
839 01dll_field SUBS R1,R1,#1 ;Decrement counter thing
840 LDMLEFD R13!,{R1,R2,PC}^ ;Return if done
841 02dll_field SWI XOS_WriteI+' ' ;Write a space
842 SUBS R1,R1,#1 ;Decrement counter thing
843 BGT %02dll_field ;If allowed, write another
844 LDMFD R13!,{R1,R2,PC}^ ;Return happy :-)
845
846 LTORG
847
848 ; --- dll_compare ---
849 ;
850 ; On entry: R0 == pointer to DLL
851 ; R1 == pointer to name string
852 ; R2 == required version number
853 ; On exit: R0 == 1 for a match, or 0 for no match
854
855 EXPORT dll_compare
856 dll_compare ROUT
857
858 STMFD R13!,{R1,R2,R14} ;Keep registers safe
859 LDR R14,[R0,#dl_version] ;Find the version number
860 CMP R2,R14 ;How does it shape up?
861 BGT %00dll_compare ;If too low, return 0
862 MOV R2,#0 ;Case insensitive bitty
863 LDR R0,[R0,#dl_name] ;Point to DLL's name string
864 BL misc_strcmp ;Compare the strings
865 MOVEQ R0,#1 ;If there's a match, return 1
866 LDMEQFD R13!,{R1,R2,PC}^ ;Return to caller
867 00dll_compare MOV R0,#0 ;No match here
868 LDMFD R13!,{R1,R2,PC}^ ;Return to caller
869
870 LTORG
871
872 ; --- dll_tentative ---
873 ;
874 ; On entry: R0 == pointer to DLL
875 ; On exit: --
876
877 EXPORT dll_tentative
878 dll_tentative ROUT
879
880 STMFD R13!,{R14} ;Store return address
881 LDR R14,[R0,#dl_clients] ;Find the magic counter
882 ORR R14,R14,#dl_tentative ;Set the `tentative' bit
883 STR R14,[R0,#dl_clients] ;And store back again
884 LDMFD R13!,{PC}^ ;Return to caller
885
886 LTORG
887
888 ; --- dll_confirm ---
889 ;
890 ; On entry: --
891 ; On exit: --
892
893 EXPORT dll_confirm
894 dll_confirm ROUT
895
896 STMFD R13!,{R14} ;Store return address
897 LDR R0,dll__list ;Find list base address
898 CMP R0,#0 ;Are there any entries
899 LDMEQFD R13!,{PC}^ ;Return to caller if not
900 00dll_confirm LDR R14,[R0,#dl_clients] ;Find the magic counter
901 TST R14,#dl_tentative ;Is it a tentative one?
902 BICNE R14,R14,#dl_tentative ;Yes -- clear `tentative' bit
903 ADDNE R14,R14,#1 ;Increment the counter
904 STRNE R14,[R0,#dl_clients] ;And store back again
905 LDR R0,[R0,#dl_next] ;Find next DLL in the chain
906 CMP R0,#0 ;Is this the end yet?
907 BNE %00dll_confirm ;Go round again if not
908 LDMFD R13!,{PC}^ ;Return to caller
909
910 LTORG
911
912 ; --- dll_retrace ---
913 ;
914 ; On entry: --
915 ; On exit: --
916
917 EXPORT dll_retrace
918 dll_retrace ROUT
919
920 STMFD R13!,{R1,R14} ;Keep registers safe
921 LDR R0,dll__list ;Find list base address
922 CMP R0,#0 ;Are there any more entries
923 LDMEQFD R13!,{R1,PC}^ ;Return to caller if not
924 00dll_retrace LDR R1,[R0,#dl_next] ;Find the next block along
925 LDR R14,[R0,#dl_clients] ;Load the magic counter
926 BICS R14,R14,#dl_tentative ;Clear the `tentative' bit
927 STR R14,[R0,#dl_clients] ;Store back in structure
928 BLEQ dll__free ;Free the block if no count
929 MOVS R0,R1 ;Point to next block along
930 BNE %00dll_retrace ;If any more to do, do more
931 LDMFD R13!,{R1,PC}^ ;Return to caller
932
933 LTORG
934
935 ; --- dll_freeAll ---
936 ;
937 ; On entry: --
938 ; On exit: --
939
940 EXPORT dll_freeAll
941 dll_freeAll ROUT
942
943 STMFD R13!,{R1,R2,R14} ;Preserve registers nicely
944 MOV R0,#7 ;Freeing memory now
945 LDR R2,dll__list ;Point to first entry
946 CMP R2,#0 ;Is there anything to do?
947 LDMEQFD R13!,{R1,R2,PC}^ ;No -- just leave now
948
949 00dll_freeAll LDR R1,[R2,#dl_next] ;Get next pointer in list
950 SWI XOS_Module ;Free the block
951 MOVS R2,R1 ;Point to the next entry
952 BNE %00dll_freeAll ;If any more to do, do them
953
954 STR R2,dll__list ;Store 0 back into list head
955 01dll_freeAll LDMFD R13!,{R1,R2,PC}^ ;Return to caller
956
957 LTORG
958
959 ; --- dll_dec ---
960 ;
961 ; On entry: R0 == pointer to DLL to decrement
962 ; On exit: --
963
964 EXPORT dll_dec
965 dll_dec ROUT
966
967 STMFD R13!,{R14} ;Preserve link register
968 LDR R14,[R0,#dl_next] ;Find whether it's shared
969 CMP R14,#-1 ;Just check to make sure
970 BEQ %00dll_dec ;If not, give an error
971 LDR R14,[R0,#dl_clients] ;Load the DLL count
972 SUBS R14,R14,#1 ;Chop one off the counter
973 STRNE R14,[R0,#dl_clients] ;Store the count back
974 LDMNEFD R13!,{PC}^ ;Return to caller
975 LDMFD R13!,{R14} ;Pull back return address
976 B dll__free ;Free the DLL -- no clients
977
978 00dll_dec LDR R1,[R0,#dl_name] ;Point to the DLL's name
979 ADRL R0,msg_errNotShared ;Point to error message
980 BL misc_error ;Turn into a real error
981 LDMFD R13!,{R1,R14} ;Pull back return address
982 ORRS PC,R14,#V_flag ;Return the error
983
984 LTORG
985
986 ; --- dll_instvars ---
987 ;
988 ; On entry: R0 == pointer to DLL
989 ; R1 == pointer to data
990 ; On exit: --
991
992 EXPORT dll_instvars
993 dll_instvars ROUT
994
995 STMFD R13!,{R1-R6,R14} ;Stack registers
996
997 ; --- Store pointer if needs be ---
998
999 MOV R3,R0 ;Look after this pointer
1000 LDR R2,[R3,#dl_instBase] ;Find start of data block
1001 SUB R4,R1,R2 ;Calculate relocation
1002 LDR R14,[R3,#dl_next] ;Is there a next pointer?
1003 CMP R14,#-1 ;Is the DLL shared?
1004 BNE %00dll_instvars ;Yes -- don't store reloc
1005 STR R4,[R3,#dl_wspace] ;Store in special offset
1006
1007 ; --- Copy the data across ---
1008
1009 00dll_instvars LDR R0,[R3,#dl_bversion] ;Get the format version
1010 CMP R0,#100 ;Is it too old for this?
1011 BLE %90dll_instvars ;Yes -- skip ahead then
1012
1013 LDR R5,[R3,#dl_zinitBase] ;Get zero-init base address
1014 LDR R6,[R3,#dl_zinitLimit] ;Get zero-init limit address
1015
1016 MOV R0,R1 ;Move destination pointer
1017 MOV R1,R2 ;Find start of data block
1018 CMP R5,R6 ;Is there a zinit area?
1019 MOVLT R2,R5 ;Yes -- use zinit base addr
1020 LDRGE R2,[R3,#dl_instLimit] ;No -- use data end address
1021 SUB R2,R2,R1 ;Convert pointer to length
1022 BL misc_memcpy ;Copy the data across
1023
1024 ; --- If the format supports it, do zero-initing ---
1025
1026 CMP R5,R6 ;Are these sensible?
1027 ADDLT R0,R5,R4 ;Yes -- add relocation
1028 ADDLT R1,R6,R4
1029 BLLT misc_zinit ;And zero-init the area
1030
1031 B %99dll_instvars
1032
1033 ; --- Copy the whole lot across ---
1034
1035 90dll_instvars MOV R0,R1 ;Move destination pointer
1036 MOV R1,R2 ;Find start of data block
1037 LDR R2,[R3,#dl_instLimit] ;Find end of data block
1038 SUB R2,R2,R1 ;Convert pointer to length
1039 BL misc_memcpy ;Copy the data across
1040
1041 99dll_instvars LDMFD R13!,{R1-R6,PC}^ ;Return to caller
1042
1043 LTORG
1044
1045 ; --- dll_findWorkspace ---
1046 ;
1047 ; On entry: R0 == DLL handle
1048 ; On exit: R0 == pointer to workspace for the DLL
1049 ;
1050 ; So that the caller can free it when they kill the DLL
1051
1052 EXPORT dll_findWorkspace
1053 dll_findWorkspace ROUT
1054
1055 STMFD R13!,{R14} ;Stack link register
1056 LDR R14,[R0,#dl_instBase] ;Find workspace base address
1057 LDR R0,[R0,#dl_wspace] ;Find the relocation
1058 ADD R0,R0,R14 ;Relocate the address
1059 LDMFD R13!,{PC}^ ;Return to the caller
1060
1061 LTORG
1062
1063 ; --- dll_convreloc ---
1064 ;
1065 ; On entry: R0 == pointer to DLL
1066 ; R1 == pointer to data block
1067 ; On exit: R0 == relocation offset to use
1068
1069 EXPORT dll_convreloc
1070 dll_convreloc ROUT
1071
1072 STMFD R13!,{R14} ;Keep link register
1073 LDR R14,[R0,#dl_instBase] ;Find base of static data
1074 SUB R0,R1,R14 ;Convert to a relocation
1075 LDMFD R13!,{PC}^ ;Return to caller
1076
1077 LTORG
1078
1079 ; --- dll_info ---
1080 ;
1081 ; On entry: R0 == pointer to DLL
1082 ; On exit: R0 preserved
1083 ; R1 == pointer to DLL name
1084 ; R2 == version number
1085 ; R3 == pointer to copyright string
1086 ; R4 == size of instance variables
1087
1088 EXPORT dll_info
1089 dll_info ROUT
1090
1091 LDR R3,[R0,#dl_instBase] ;Find base of variables
1092 LDR R4,[R0,#dl_instLimit] ;Find limit of variables
1093 SUB R4,R4,R3 ;Turn this into length
1094 LDR R1,[R0,#dl_name] ;Point to DLL's name
1095 LDR R2,[R0,#dl_version] ;Load version number
1096 LDR R3,[R0,#dl_copyright] ;Point to copyright string
1097 MOVS PC,R14 ;Return to caller
1098
1099 LTORG
1100
1101 ; --- dll_datasize ---
1102 ;
1103 ; On entry: R0 == pointer to DLL
1104 ; On exit: R0 == number of bytes to allocate
1105
1106 EXPORT dll_datasize
1107 dll_datasize ROUT
1108
1109 STMFD R13!,{R14} ;Keep link register
1110 LDR R14,[R0,#dl_instBase] ;Find base of area
1111 LDR R0,[R0,#dl_instLimit] ;Find end of area
1112 SUB R0,R0,R14 ;Convert to length
1113 LDMFD R13!,{PC}^ ;Return to caller
1114
1115 LTORG
1116
1117 ;----- Private routines -----------------------------------------------------
1118
1119 ; --- dll__createName ---
1120 ;
1121 ; On entry: R0 == pointer to name to load
1122 ; R1 == version number to check for
1123 ; On exit: R0 == DLL handle if found in memory, or 0
1124 ; R1 == pointer to filename of DLL to use
1125 ; R2 == pointer to leafname of DLL if not in memory
1126
1127 dll__createName ROUT
1128
1129 STMFD R13!,{R9-R11,R14} ;Stash registers somewhere
1130
1131 ; --- Start off by putting `DLL:' in the buffer ---
1132 ;
1133 ; We may not need it, but at least it's there if we do.
1134
1135 MOV R11,R0 ;Remember this name pointer
1136 MOV R10,R1 ;And remember the version
1137 LDR R14,dll__pathPrefix ;Load the path prefix
1138 ADR R0,misc__sharedBuf+8 ;Point to shared buffer
1139 STR R14,[R0],#4 ;And store that away
1140
1141 ; --- Now set up for our search ---
1142
1143 ADR R9,misc__sharedBuf+8 ;Filename assumed to be leaf
1144 MOV R2,R0 ;Assume DLL name is leaf
1145
1146 ; --- The first character is special ---
1147
1148 LDRB R14,[R11],#1 ;Load the next byte out
1149 CMP R14,#'[' ;Is this a new-style leaf?
1150 BEQ %20dll__createName ;Yes -- skip to copy rest
1151
1152 ; --- Now enter the main loop ---
1153
1154 00 CMP R14,#'[' ;Found new-style name delim?
1155 ADREQ R9,misc__sharedBuf+8+4 ;Yes -- ignore `DLL:' bit
1156 MOVEQ R2,R0 ;DLL name starts here
1157 BEQ %20dll__createName ;Yes -- skip to copy rest
1158
1159 STRB R14,[R0],#1 ;Store character in output
1160 CMP R14,#'.' ;Found a path separator?
1161 ADREQ R9,misc__sharedBuf+8+4 ;Yes -- ignore `DLL:' bit
1162 MOVEQ R2,R0 ;DLL name is here or later
1163 CMP R14,#&21 ;Is this the end of it all?
1164 LDRCSB R14,[R11],#1 ;No -- get the next byte
1165 BCS %b00 ;And keep on looping
1166
1167 MOV R14,#0 ;Terminate the string
1168 STRB R14,[R0,#-1] ;Stuff that over old term
1169 B %50dll__createName ;Now go and find the DLL
1170
1171 ; --- Mess about with new-style names ---
1172
1173 20 LDRB R14,[R11],#1 ;Load another byte out
1174 CMP R14,#&21 ;Dropped off the end?
1175 MOVCC R14,#']' ;Yes -- pretend it was right
1176 CMP R14,#']' ;Finished yet?
1177 MOVEQ R14,#0 ;Yes -- zero terminate
1178 STRB R14,[R0],#1 ;Store in the buffer
1179 BNE %20dll__createName ;And keep looping
1180
1181 ; --- We've found all the names now ---
1182
1183 50 MOV R0,R2 ;Point to the DLL leaf
1184 MOV R1,R10 ;Find the version number
1185 BL dll_find ;Try to find the dll
1186 LDMVCFD R13!,{R9-R11,PC} ;It was OK -- return then
1187
1188 MOV R0,#0 ;Couldn't find the DLL
1189 MOV R1,R9 ;Point to the filename
1190 LDMFD R13!,{R9-R11,PC}^ ;Restore registers
1191
1192 dll__pathPrefix DCB "dll:",0 ;Path variable to search
1193 ALIGN
1194
1195 LTORG
1196
1197 ; --- dll__free ---
1198 ;
1199 ; On entry: R0 == DLL handle to release
1200 ; On exit: --
1201
1202 dll__free ROUT
1203
1204 STMFD R13!,{R1,R2,R14} ;Keep registers safe
1205
1206 ; --- Mangle the list nicely ---
1207
1208 LDR R1,[R0,#dl_next] ;Get pointer to next DLL
1209 LDR R2,[R0,#dl_prev] ;And pointer to previous one
1210 CMP R1,#0 ;Is there a next one?
1211 STRNE R2,[R1,#dl_prev] ;Yes -- fix up previous ptr
1212 CMP R2,#0 ;Is there a previous one?
1213 ADREQ R2,dll__list ;No -- point to list head
1214 STR R1,[R2,#dl_next] ;Fix up the pointer
1215
1216 ; --- Free the block ---
1217
1218 MOV R2,R0 ;Point to the block
1219 MOV R0,#7 ;Magic number to free it
1220 SWI XOS_Module ;Free it now
1221 LDMFD R13!,{R1,R2,PC} ;Return to caller
1222
1223 LTORG
1224
1225 ; --- dll__load ---
1226 ;
1227 ; On entry: R0 == pointer to block to load
1228 ; R1 == pointer to filename
1229 ; On exit: --
1230
1231 dll__load ROUT
1232
1233 STMFD R13!,{R1-R5,R9-R11,R14}
1234 MOV R10,R0 ;Keep pointer to block safe
1235 MOV R9,R1 ;And look after the filename
1236
1237 ; --- Load the DLL into the buffer ---
1238
1239 MOV R0,#16 ;Load a file into memory
1240 MOV R3,#(1<<31) ;Resync code areas when done
1241 ADD R2,R10,#dl_extra ;Leave space for extra info
1242 SWI XOS_File ;Try to load the file
1243 LDMVSFD R13!,{R1-R5,R9-R11,PC} ;Return the error if any
1244
1245 ; --- Check that it really is a DLL ---
1246
1247 LDR R0,=dl_MAGIC ;Find the magic DLL number
1248 LDR R1,[R10,#dl_magic] ;Get the version from DLL
1249 CMP R0,R1 ;Check they're the same
1250 BNE %40dll__load ;If not, give an error
1251
1252 LDR R0,=dl_VERSION ;Get known version number
1253 LDR R1,[R10,#dl_bversion] ;Get DLL's version number
1254 CMP R0,R1 ;How do they match up?
1255 BLT %41dll__load ;If too new, complain
1256
1257 ; --- Relocate the image ---
1258
1259 MOV R14,PC ;Set up return address
1260 ADD PC,R10,#dl_relocate ;Perform the relocation
1261
1262 ; --- Fill in the C library stubs ---
1263
1264 LDR R0,[R10,#dl_stubs] ;Get pointer to stubs table
1265 CMP R0,R10 ;If it isn't invalid
1266 BLS %10dll__load ;... don't skip ahead
1267 BL misc_copyStubs ;Copy the clib branch table
1268 LDMVSFD R13!,{R1-R5,R9-R11,PC} ;Return the error if any
1269
1270 ; --- Mark the DLL as being non-shared ---
1271 ;
1272 ; Here we also clear the data relocation for non-shared DLLs
1273 ; since they don't need to be multiply instantiated. We *do*
1274 ; allow extension DLLs to be multiply instantiated, though.
1275 ; Clearing the relocation also has the side effect of
1276 ; clearing a *shared* DLL's client counter.
1277
1278 10dll__load MOV R0,#-1 ;Non-shared is indicated...
1279 STR R0,[R10,#dl_next] ;... by dl_next being -1
1280 MOV R0,#0 ;Also, clear relocation
1281 STR R0,[R10,#dl_wspace] ;(also clears client count)
1282
1283 ; --- That's it, then ---
1284
1285 LDMFD R13!,{R1-R5,R9-R11,PC}^ ;Return to caller
1286
1287 ; --- Give an error about a bad DLL image ---
1288
1289 40dll__load ADRL R0,msg_errNotADLL ;Point to error message
1290 B %49dll__load ;Go to error generation bit
1291
1292 ; --- Give an error about an unrecognised format version ---
1293
1294 41dll__load ADRL R0,msg_errTooNew ;Point to error message
1295 B %49dll__load ;Go to error generation bit
1296
1297 ; --- Create an error and leave ---
1298
1299 49dll__load MOV R1,R9 ;Point to the filename
1300 BL misc_error ;Fill in the error message
1301 LDMFD R13!,{R1-R5,R9-R11,R14} ;Restore registers
1302 ORRS PC,R14,#V_flag ;And return an error
1303
1304 LTORG
1305
1306 ; --- dll__divide ---
1307 ;
1308 ; On entry: R0 == dividend
1309 ; R1 == divisor
1310 ; On exit: R0 == quotient
1311 ; R1 == remainder
1312 ;
1313 ; This routine is mostly uncommented, 'cos I copied from Acorn's Assembler
1314 ; documentation, and it should be accurate. It's not exactly optimised,
1315 ; but it should hold up to the sort of treatment I'm going to be giving it
1316 ; (very delicate and occasional use).
1317
1318 dll__divide ROUT
1319
1320 STMFD R13!,{R2,R3,R14}
1321 CMP R1,#0 ;Check for stupidity
1322 BEQ %10dll__divide ;If stupid, give an error
1323
1324 MOV R3,R1
1325 CMP R3,R0,LSR #1
1326 00dll__divide MOVLS R3,R3,LSL #1
1327 CMP R3,R0,LSR #1
1328 BLS %00dll__divide
1329
1330 MOV R2,#0
1331 01dll__divide CMP R0,R3
1332 SUBCS R0,R0,R3
1333 ADC R2,R2,R2
1334 MOV R3,R3,LSR #1
1335 CMP R3,R1
1336 BCS %01dll__divide
1337
1338 MOV R1,R0 ;Move results into right...
1339 MOV R0,R2 ;... registers
1340 LDMFD R13!,{R2,R3,PC}^
1341
1342 10dll__divide ADRL R0,msg_errDivide ;Point to error message
1343 LDMFD R13!,{R2,R3,R14} ;Retreive registers
1344 ORRS PC,R14,#V_flag ;And returnt the error
1345
1346 LTORG
1347
1348 ;----- That's all folks -----------------------------------------------------
1349
1350 END
The Straylight Source Distribution (obsolete software for RISC OS)