~mdw / ssr / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Initial revision
[ssr] / StraySrc / Libraries / Core / s / flex
1 ;
2 ; flex.s
3 ;
4 ; Flexible memory handling (MDW)
5 ;
6 ; © 1994-1998 Straylight
7 ;
8
9 ;----- Licensing note -------------------------------------------------------
10 ;
11 ; This file is part of Straylight's flex.
12 ;
13 ; Flex 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 ; Flex 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 Flex. If not, write to the Free Software Foundation,
25 ; 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
26
27 ;----- New unified version --------------------------------------------------
28 ;
29 ; I'm finally fed up of maintaining four different versions of this code.
30 ; From now on, there is only this one.
31 ;
32 ; Lots of options are supported:
33 ;
34 ; OPT_APCS Generate an APCS-compatible version
35 ; OPT_SAPPHIRE Generate a Sapphire-compatible version
36 ; OPT_STEEL Apply some STEEL-specific eccentricities
37 ; OPT_STANDALONE Build a standalone assembler version (default)
38 ; OPT_DUMP Generate flex_dump code
39 ; OPT_DYNAREA Generate dynamic-area handling code
40 ; OPT_STACK Generate relocation stack handling code
41 ; OPT_DLL Generate absolute address relocation for DLL code
42 ; OPT_ATEXIT Register cleanup function with `atexit' for DLL code
43 ;
44 ; [mdw]
45
46 ;----- Set up some options --------------------------------------------------
47
48 MACRO
49 DCLOPT $var
50 [ :DEF:$var
51 $var SETL {TRUE}
52 |
53 GBLL $var
54 $var SETL {FALSE}
55 ]
56 MEND
57
58 DCLOPT OPT_APCS
59 DCLOPT OPT_SAPPHIRE
60 DCLOPT OPT_STEEL
61 DCLOPT OPT_STANDALONE
62 DCLOPT OPT_DUMP
63 DCLOPT OPT_DYNAREA
64 DCLOPT OPT_STACK
65 DCLOPT OPT_DLL
66 DCLOPT OPT_ATEXIT
67
68 [ :LNOT:OPT_APCS:LAND::LNOT:OPT_SAPPHIRE:LAND::LNOT:OPT_STANDALONE
69 GBLL OPT_STANDALONE
70 OPT_STANDALONE SETL {TRUE}
71 ]
72
73 ;----- Standard stuff -------------------------------------------------------
74
75 GET libs:header
76 GET libs:swis
77
78 ;----- External dependencies ------------------------------------------------
79
80 [ OPT_SAPPHIRE
81 GET sapphire:fastMove
82 GET sapphire:event
83 GET sapphire:except
84 GET sapphire:libOpts
85 GET sapphire:roVersion
86 GET sapphire:sapphire
87 |
88 IMPORT fastMove
89 ]
90
91 [ OPT_DLL:LAND:OPT_APCS
92 IMPORT atexit
93 ]
94
95 ;----- Workspace macros -----------------------------------------------------
96
97 [ OPT_APCS
98
99 MACRO
100 $label WSPACE $addr,$reg
101 LCLS r
102 [ "$reg"=""
103 r SETS "R12"
104 |
105 r SETS "$reg"
106 ]
107 ALIGN
108 $label
109 LDR $r,$addr
110 [ OPT_DLL
111 LDR R14,[R10,#-536]
112 ADD $r,R14,$r
113 ]
114 MEND
115
116 ]
117
118 ;----- Main code ------------------------------------------------------------
119
120 [ OPT_SAPPHIRE
121 AREA |Sapphire$$Code|,CODE,READONLY
122 ]
123 [ OPT_APCS
124 AREA |C$$Code|,CODE,READONLY
125 ]
126 [ OPT_STANDALONE
127 AREA |Straylight$$Code|,CODE,READONLY
128 ]
129
130 ; --- flex__setslot ---
131 ;
132 ; On entry: R0 == limit address of slot required, or -1 to read
133 ;
134 ; On exit: R0 == actual address (after update)
135 ; R1 == limit requested (R0 on entry)
136 ;
137 ; Use: Sets the application's WimpSlot to a given value. The value
138 ; is given as an address, rather than as a size, which is
139 ; the more normal way of doing things.
140 ;
141 ; Since updated to cope with dynamic areas.
142
143 flex__setslot ROUT
144
145 STMFD R13!,{R2-R6,R14} ;Save some registers
146 LDR R14,flex__flags ;Load interesting flags
147 [ OPT_DYNAREA
148 TST R14,#fFlag__dynArea ;Using a dynamic area?
149 BNE %50flex__setslot ;Yes -- do different things
150 ]
151
152 ; --- Change the WimpSlot ---
153 ;
154 ; Be careful -- we may be sharing memory space with another
155 ; application!
156
157 MOV R5,R0 ;Look after my argument
158 MOV R0,#14 ;Read app space value
159 MOV R1,#0 ;Read, rather than write
160 SWI XOS_ChangeEnvironment ;Read the value
161 MOV R3,R1 ;Keep hold of app space size
162
163 MOV R0,#0 ;Now read memory limit
164 MOV R1,#0 ;Read again, not write
165 SWI XOS_ChangeEnvironment ;Read memory limit
166 MOV R6,R1 ;Look after memory limit
167
168 CMP R6,R3 ;How does this shape up?
169 MOVLT R1,R3 ;If too low, extend mem limit
170 SWILT XOS_ChangeEnvironment ;Set memory limit
171
172 CMP R5,#-1 ;Does he want to read it?
173 MOVEQ R0,R5 ;Yes -- do that then
174 SUBNE R0,R5,#&8000 ;Otherwise work out slot size
175 MOV R1,#-1 ;Not interested in next slot
176 SWI XWimp_SlotSize ;Change the WimpSlot value
177 MOV R4,R0 ;Look after updated value
178
179 CMP R6,R3 ;If we changed the mem limit
180 MOVLT R1,R6 ;Put it back the way it was
181 MOVLT R0,#0 ;Setting memory limit
182 SWILT XOS_ChangeEnvironment ;Restore memory limit
183
184 ADD R0,R4,#&8000 ;New value of WimpSlot
185 MOV R1,R5 ;Return requested size too
186 LDMFD R13!,{R2-R6,PC}^ ;Return to caller
187
188 ; --- Change a dynamic area size ---
189
190 [ OPT_DYNAREA
191
192 50flex__setslot MOV R2,R0 ;Look after address requested
193 LDR R3,flex__end ;Find the end address
194 SUBS R1,R2,R3 ;Work out the difference
195 LDR R0,flex__dynArea ;Load dynamic area handle
196 SWI XOS_ChangeDynamicArea ;Try and change the size
197 ADDGT R0,R3,R1 ;Get new limit address
198 SUBLE R0,R3,R1 ;Irritatingly positive...
199 MOV R1,R2 ;And the caller's request
200 LDMFD R13!,{R2-R6,PC}^ ;Return to caller
201
202 ]
203
204 LTORG
205
206 ; --- flex__fixup ---
207 ;
208 ; On entry: --
209 ;
210 ; On exit: --
211 ;
212 ; Use: Goes off and fixes up all the anchors currently pointing at
213 ; blocks in the heap
214
215 flex__fixup ROUT
216
217 STMFD R13!,{R0-R3,R14} ;Save some registers
218
219 ; --- Set up for the fixup loop ---
220
221 LDR R1,flex__base ;Find the base of the heap
222 LDR R2,flex__free ;Find end of the blocks
223
224 ; --- Now go through and fix things up ---
225
226 00flex__fixup CMP R1,R2 ;Have we reached the end yet?
227 LDMGEFD R13!,{R0-R3,PC}^ ;Return to caller if so
228 LDR R3,[R1,#flex__bkanchor] ;Find the pointer to anchor
229 CMP R3,#0 ;Is the block currently free?
230 ADDNE R14,R1,#flex__ohead ;No -- bump aver the overhead
231 STRNE R14,[R3] ;And store in the anchor
232 LDR R3,[R1,#flex__size] ;Find the block's size
233 ADD R3,R3,#flex__ohead+7 ;Add on the extra overhead
234 BIC R3,R3,#7 ;And word align the size
235 ADD R1,R1,R3 ;Bump along to the next block
236 B %00flex__fixup ;And fix that one up too
237
238 LTORG
239
240 ; --- flex__compact ---
241 ;
242 ; On entry: --
243 ;
244 ; On exit: --
245 ;
246 ; Use: Try to compact the heap by one iteration
247 ;
248 ; We troll through the blocks to find a free one and haul
249 ; everything down a bit
250
251 flex__compact ROUT
252
253 STMFD R13!,{R0-R6,R14} ;Save some registers
254
255 ; --- Set up for a loop through the data ---
256
257 LDR R5,flex__base ;Find the beginning of flex
258 LDR R1,flex__free ;Find the end too
259
260 ; --- Find a free block ---
261
262 00flex__compact CMP R5,R1 ;Are we at the end yet?
263 BGE %10flex__compact ;Yes -- the heap is compact
264
265 LDR R2,[R5,#flex__bkanchor] ;Get the block's anchor addr
266 CMP R2,#0 ;Is the block free?
267 LDR R2,[R5,#flex__size] ;Get the block size
268 ADD R2,R2,#flex__ohead+7 ;Add on the overhead bytes
269 BIC R2,R2,#7 ;And word align the size
270 ADDNE R5,R5,R2 ;No -- move on to next one
271 BNE %00flex__compact ;And go round for another one
272
273 ; --- We've found a free block ---
274
275 01flex__compact ADD R6,R5,R2 ;Point to the next block
276 CMP R6,R1 ;Is that the end of the heap?
277 BGE %05flex__compact ;Yes -- reduce the free ptr
278
279 ; --- Check for two free blocks together ---
280
281 LDR R0,[R6,#flex__bkanchor] ;Does this have an anchor?
282 CMP R0,#0 ;Check if it's free
283 BNE %02flex__compact ;No -- start swapping blocks
284
285 ; --- Join two adjacent free blocks together ---
286
287 LDR R0,[R6,#flex__size] ;Yes -- get its size
288 ADD R2,R0,R2 ;Concatenate the two blocks
289 ADD R2,R2,#flex__ohead+7 ;Add on the overhead bytes
290 BIC R2,R2,#7 ;And word align the size
291 B %01flex__compact ;And check again...
292
293 ; --- There's a block to bring down ---
294
295 02flex__compact LDR R4,[R6,#flex__size] ;Get size of block to move
296 ADD R4,R4,#flex__ohead+7 ;Add the flex overhead
297 BIC R4,R4,#7 ;And word align the size
298 MOVS R2,R4 ;This is the size to move
299 MOV R0,R5 ;Where to move it to
300 MOV R1,R6 ;Where it is right now
301 BLNE fastMove ;Copy it down PDQ
302 [ OPT_STACK
303 BLNE flex__reloc ;Deal with the relocation
304 ]
305 ADD R0,R5,R4 ;Point after block we moved
306 MOV R1,#0 ;Block doesn't have an anchor
307 STR R1,[R0,#flex__bkanchor] ;Store that away for later
308 SUB R1,R6,R5 ;Find the difference here
309 SUB R1,R1,#flex__ohead ;Don't count this size here
310 STR R1,[R0,#flex__size] ;Store the old size in free
311
312 ; --- We need to fix up the block we moved ---
313
314 LDR R0,[R5,#flex__bkanchor] ;Get the anchor pointer
315 ADD R1,R5,#flex__ohead ;Point to the real data
316 STR R1,[R0] ;Store client's new anchor
317
318 ; --- That's it -- return to caller ---
319
320 LDMFD R13!,{R0-R6,PC}^ ;Return to caller
321
322 ; --- Merge the last block with the free area ---
323
324 05flex__compact STR R5,flex__free ;This is the new free area
325 LDR R0,flex__chunk ;Get the machine page size
326 SUB R0,R0,#1 ;Turn into a bitmask
327 ADD R5,R5,R0 ;Align this to page boundary
328 BIC R0,R5,R0 ;And finish off the align
329 LDR R1,flex__end ;Find the end of the heap
330 CMP R0,R1 ;Are these different?
331 BLNE flex__setslot ;Yes -- free some memory
332 STRNE R0,flex__end ;Store the end away
333
334 ; --- That's it -- return ---
335
336 LDMFD R13!,{R0-R6,PC}^ ;Return to caller
337
338 ; --- There wasn't anything to do -- we're compacted ---
339
340 10flex__compact LDR R0,flex__flags
341 ORR R0,R0,#fFlag__compact ;We are now compacted
342 STR R0,flex__flags
343 LDMFD R13!,{R0-R6,PC}^ ;Return to caller
344
345 LTORG
346
347 ; --- flex_reduce ---
348 ;
349 ; On entry: --
350 ;
351 ; On exit: --
352 ;
353 ; Use: Compacts the flex heap by one iteration.
354
355 EXPORT flex_reduce
356 flex_reduce ROUT
357
358 STMFD R13!,{R0,R12,R14} ;Stack some registers
359 WSPACE flex__wSpace ;Find my workspace
360
361 ; --- Check if it's compacted ---
362
363 LDR R0,flex__flags ;Get my nice flags word
364 TST R0,#fFlag__compact ;Is the heap compacted?
365 BLEQ flex__compact ;No -- compact it a bit
366 LDMFD R13!,{R0,R12,PC}^ ;Return to caller now
367
368 LTORG
369
370 ; --- flex_compact ---
371 ;
372 ; On entry: --
373 ;
374 ; On exit: --
375 ;
376 ; Use: Completely compacts the flex heap.
377
378 EXPORT flex_compact
379 flex_compact ROUT
380
381 STMFD R13!,{R0,R12,R14} ;Save some registers
382 WSPACE flex__wSpace ;Find my workspace
383
384 ; --- Compaction loop ---
385
386 00flex_compact LDR R0,flex__flags ;Get my nice flags word
387 TST R0,#fFlag__compact ;Is the heap compacted?
388 BLEQ flex__compact ;No -- compact another stage
389 BEQ %00flex_compact ;And go round again
390
391 ; --- The end -- return ---
392
393 LDMFD R13!,{R0,R12,PC}^ ;Return to caller
394
395 LTORG
396
397 ; --- flex_free ---
398 ;
399 ; On entry: R0 == pointer to the flex anchor
400 ;
401 ; On exit: --
402 ;
403 ; Use: Frees a flex block allocated by flex_alloc.
404
405 EXPORT flex_free
406 flex_free ROUT
407
408 STMFD R13!,{R0,R12,R14} ;Save some registers
409 WSPACE flex__wSpace
410
411 ; --- Mark the block as being free ---
412
413 LDR R14,[R0] ;Get pointer to actual block
414 MOV R0,#0
415 STR R0,[R14,#flex__bkanchor-flex__ohead]
416
417 ; --- Update the flags -- not compacted any more ---
418
419 LDR R0,flex__flags ;Get my nice flags word
420 BIC R0,R0,#fFlag__compact ;We are no longer compacted
421 STR R0,flex__flags ;Store it back
422
423 LDMFD R13!,{R0,R12,PC}^ ;Return to caller
424
425 LTORG
426
427 ; --- flex_alloc ---
428 ;
429 ; On entry: R0 == pointer to a flex anchor
430 ; R1 == desired size of flex block
431 ;
432 ; On exit: Sapphire: CS if no memory could be allocated, CC otherwise
433 ; APCS: R0 zero if no memory, nonzero otherwise
434 ;
435 ; Use: Allocates a block in the shifting heap.
436
437 EXPORT flex_alloc
438 flex_alloc ROUT
439
440 [ OPT_APCS
441 STMFD R13!,{R4,R5,R12,R14} ;Save some registers
442 |
443 STMFD R13!,{R0-R5,R12,R14} ;Save some registers
444 ]
445
446 WSPACE flex__wSpace
447
448 ; --- Round up the size etc. ---
449
450 MOV R4,R0 ;Keep the anchor pointer
451 MOV R3,R1 ;Keep the actual size wanted
452 ADD R5,R1,#flex__ohead+7 ;Add on overhead for flex
453 BIC R5,R5,#7 ;And word-align the size
454
455 ; --- See if there's enough space ---
456
457 00flex_alloc LDR R0,flex__free ;Get the free pointer
458 LDR R2,flex__end ;And the end of the block
459 SUB R1,R2,R0 ;How much room is left
460 CMP R1,R5 ;Enough for the new block
461 BGE %10flex_alloc ;Set up the block
462
463 ; --- Not enough room in block - try to get some more ---
464
465 ADD R0,R0,R5 ;Find the new slot limit
466 BL flex__setslot ;Set up the new slot
467 CMP R0,R1 ;Did we get enough
468 STRGE R0,flex__end ;Yes -- remember the new end
469 LDRGE R0,flex__free ;Find the free area again
470 BGE %10flex_alloc ;And allocate the memory
471
472 ; --- Can we compact the heap? ---
473
474 LDR R0,flex__end ;Get the old heap extent
475 BL flex__setslot ;Put the slot back again
476 LDR R0,flex__flags ;Get my current flags
477 TST R0,#fFlag__compact ;Is the heap compact?
478 BLEQ flex_compact ;No -- really compact it
479 BEQ %00flex_alloc ;And give it another go
480
481 ; --- We couldn't get enough memory at all ---
482
483 [ OPT_APCS
484 MOV R0,#0
485 LDMFD R13!,{R4,R5,R12,PC}^ ;Restore registers
486 |
487 LDMFD R13!,{R0-R5,R12,R14} ;Restore registers
488 ORRS PC,R14,#C_flag ;Set C flag to indicate fail
489 ]
490
491 ; --- Set up the block pointed to by R0
492
493 10flex_alloc STR R4,[R0,#flex__bkanchor] ;Set up the back anchor
494 STR R3,[R0,#flex__size] ;Remember size of this block
495 ADD R1,R0,#flex__ohead ;Point to real data block
496 STR R1,[R4] ;Let user know where block is
497 ADD R1,R0,R5 ;Get the new free pointer
498 STR R1,flex__free ;Store the new free ptr
499
500 ; --- Return to the user ---
501
502 [ OPT_APCS
503 MOV R0,#-1
504 LDMFD R13!,{R4,R5,R12,PC}^
505 |
506 LDMFD R13!,{R0-R5,R12,R14}
507 BICS PC,R14,#C_flag
508 ]
509
510 LTORG
511
512 ; --- flex_size ---
513 ;
514 ; On entry: R0 == pointer to flex anchor
515 ;
516 ; On exit: R0 == size of allocated block
517 ;
518 ; Use: Reads the size of a flex block.
519
520 EXPORT flex_size
521 flex_size ROUT
522
523 LDR R0,[R0] ;Get the flex block
524 LDR R0,[R0,#flex__size-flex__ohead]
525 MOVS PC,R14
526
527 LTORG
528
529 ; --- flex_extend ---
530 ;
531 ; On entry: R0 == pointer to flex anchor
532 ; R1 == new size of block to set
533 ;
534 ; On exit: CS if it failed due to lack of memory, CC otherwise
535 ;
536 ; Use: Alters the size of a block to the given value.
537
538 EXPORT flex_extend
539 flex_extend ROUT
540
541 STMFD R13!,{R1,R2,R14}
542
543 ; --- Be *very* careful to preserve the flags... ---
544
545 MOV R2,R1
546 LDR R1,[R0]
547 LDR R1,[R1,#flex__size-flex__ohead]
548 SUB R2,R2,R1
549 BL flex_midExtend
550
551 ; --- Note ---
552 ;
553 ; We preserved the flags above, and midExtend should do
554 ; its bit to help, so we can just return with the flags
555 ; set by midExtend. Easy, no?
556
557 LDMFD R13!,{R1,R2,PC}
558
559 LTORG
560
561 ; --- flex_midExtend ---
562 ;
563 ; On entry: R0 == pointer to a flex anchor
564 ; R1 == `at' -- position in block to extend from
565 ; R2 == `by' -- how many bytes to extend (may be -ve)
566 ;
567 ; On exit: Sapphire: CS if not enough memory, CC otherwise
568 ; APCS: R0 zero if not enough memory, nonzero otherwise
569 ;
570 ; Use: Either creates a gap in a block (by>0) or deletes bytes
571 ; from a block. This is always done in such a way that the
572 ; byte originally at offset `at' is now at offset `at'+`by'.
573
574 EXPORT flex_midExtend
575 EXPORT flex_midextend
576 flex_midExtend ROUT
577 flex_midextend
578
579 ; --- A bit of clever setting up ---
580
581 [ OPT_APCS
582 TEQ R2,#0 ;Move by zero bytes?
583 MOVEQ R0,#-1 ;Yes, it worked
584 MOVEQS PC,R14 ;And return
585 STMFD R13!,{R12,R14} ;Otherwise save registers
586 |
587 BIC R14,R14,#C_flag ;Clear C now
588 STMFD R13!,{R12,R14} ;Save R14 on the stack
589 TEQ R2,#0 ;Move by zero bytes?
590 LDMEQFD R13!,{R12,PC}^ ;Yes -- don't bother then
591 ]
592
593 ; --- Save some more registers and find workspace ---
594
595 WSPACE flex__wSpace
596
597 ; --- Find out what we have to do depending on `by' ---
598
599 CMP R2,#0 ;Is it +ve or -ve?
600 BGT %50flex_midExtend ;If we must extend, do that
601
602 ; --- We reduce the block size -- easy ---
603
604 [ OPT_APCS
605 STMFD R13!,{R4}
606 |
607 STMFD R13!,{R0-R4} ;Save some more registers
608 ]
609 MOV R3,R2 ;Keep the size safe
610 MOV R14,R1 ;Keep `at' safe too
611
612 LDR R4,[R0] ;Get the actual block ptr
613 ADD R1,R4,R14 ;Copy from `at'
614 ADD R0,R1,R2 ;Copy to `at'-|`by'|
615 LDR R2,[R4,#flex__size-flex__ohead]
616 SUBS R2,R2,R14 ;Size of block - `at'
617 BLNE fastMove ;Copy the area down
618 [ OPT_STACK
619 BLNE flex__reloc ;And relocate the stack
620 ]
621
622 ; --- Find the new actual and logical sizes ---
623
624 SUB R4,R4,#flex__ohead ;Point to my actual data
625 LDR R0,[R4,#flex__size] ;Get the size of the block
626 ADD R1,R0,R3 ;Find new adjusted size
627 STR R1,[R4,#flex__size] ;This is new logical size
628 ADD R0,R0,#flex__ohead+7 ;Add the overhead to both...
629 ADD R1,R1,#flex__ohead+7 ;... of these sizes and...
630 BIC R0,R0,#7 ;... align to heap...
631 BIC R1,R1,#7 ;... granularity nicely
632
633 ; --- If these are different, insert a free block ---
634
635 SUBS R0,R0,R1 ;Is there space for free blk?
636 BLE %00flex_midExtend ;No -- just wrap up nicely
637
638 ; --- Insert the free block here ---
639
640 ADD R2,R4,R1 ;Find the free block
641 SUB R0,R0,#flex__ohead ;Subtract the overhead
642 STR R0,[R2,#flex__size] ;And store `logical' size
643 MOV R0,#0 ;This block has no owner
644 STR R0,[R2,#flex__bkanchor] ;So store a null anchor
645
646 ; --- There's a free block -- enable compaction ---
647
648 LDR R1,flex__flags ;Load my current flags
649 BIC R1,R1,#fFlag__compact ;We're not compact any more
650 STR R1,flex__flags ;Store the flags back again
651
652 ; --- Return to caller ---
653
654 00flex_midExtend
655 [ OPT_APCS
656 MOV R0,#-1
657 LDMFD R13!,{R4,R12,PC}^
658 |
659 LDMFD R13!,{R0-R4,R12,PC}^ ;Smile, smile, smile
660 ]
661
662 ; --- Work out how much extra space we need ---
663
664 50flex_midExtend
665 [ OPT_APCS
666 STMFD R13!,{R4-R9}
667 |
668 STMFD R13!,{R0-R9} ;Save yet more registers
669 ]
670
671 ; --- Take copies of the arguments ---
672
673 MOV R4,R0
674 MOV R5,R1
675 MOV R6,R2
676
677 LDR R7,[R4] ;Find the actual flex block
678 SUB R7,R7,#flex__ohead ;Point to my data
679 LDR R3,[R7,#flex__size] ;Find the size of the block
680
681 ADD R2,R3,#7 ;Don't add in overhead
682 BIC R2,R2,#7 ;How much space in this block
683 SUB R1,R2,R3 ;R1 == dead space at the end
684 SUBS R1,R6,R1 ;R1 == extra space needed
685
686 ; --- Can we do it within the block? ---
687
688 ADDLE R3,R3,R6 ;Increase the size
689 STRLE R3,[R7,#flex__size] ;And store
690 BLE %70flex_midExtend ;Yes -- just shuffle it about
691
692 ; --- We need to find R1 more bytes from somewhere ---
693 ;
694 ; Our strategy here is fairly simple, really (although we
695 ; could refine it a lot, I suppose).
696 ;
697 ; 1. Find as many free blocks at the end of the midExtend
698 ; block as possible, join them all together and see if
699 ; that will do.
700 ;
701 ; 2. If not, we just flex_alloc a block of the right size
702 ; and shift everything skywards.
703
704 ; --- This calls for some serious register allocation ---
705 ;
706 ; R1 == the amount of extra we need (round up to size)
707 ; R2 == pointer to blocks for loop
708 ;
709 ; R4 == address of anchor of midExtend block
710 ; R5 == point at which we need to extend it
711 ; R6 == how much we extend it by
712 ; R7 == pointer to the actual block
713 ; R8 == pointer to next block after midExtend one
714 ; R9 == the size we've accumulated so far
715
716 ; --- Start the loop (I want to get off) ---
717
718 ADD R1,R1,#7 ;Align the size to multiple
719 BIC R1,R1,#7
720 MOV R9,#0 ;We haven't found any yet
721 ADD R8,R7,R2 ;Point almost to next block
722 ADD R8,R8,#flex__ohead ;Point to it properly
723 MOV R2,R8 ;Start the loop here
724
725 LDR R3,flex__free ;Find the free area start
726
727 ; --- Find free blocks now ---
728
729 55flex_midExtend
730 CMP R2,R3 ;Are we at the end yet?
731 BGE %65flex_midExtend ;Oh, well -- we're stuffed
732 LDR R14,[R2,#flex__bkanchor] ;Is this block free?
733 CMP R14,#0 ;Quick check McCheck
734 BNE %65flex_midExtend ;Oh, well -- we're stuffed
735 LDR R14,[R2,#flex__size] ;Get the block's size
736 ADD R14,R14,#flex__ohead+7 ;Add on the overhead area
737 BIC R14,R14,#7 ;And align to doubleword
738 ADD R9,R9,R14 ;Accumulate the block size
739 CMP R9,R1 ;Have we got enough yet?
740 BGE %60flex_midExtend ;That's it -- we've got it
741 ADD R2,R2,R14 ;Move onto the next block
742 B %55flex_midExtend ;And check the next one
743
744 ; --- We got enough free blocks to save us ---
745
746 60flex_midExtend
747 LDR R0,[R7,#flex__size] ;Get the current size of this
748 ADD R0,R0,R6 ;Add on the extended size
749 STR R0,[R7,#flex__size] ;And put it back again
750 BEQ %70flex_midExtend ;If perfect fit, don't create
751
752 ; --- Create a new free block to use up the space ---
753
754 ADD R0,R8,R1 ;Point to the new free block
755 SUB R2,R9,R1 ;Find out how much is over
756 SUB R2,R2,#flex__ohead ;Don't want to count that
757 STR R2,[R0,#flex__size] ;Store the size away
758 MOV R2,#0 ;This block is not used
759 STR R2,[R0,#flex__bkanchor] ;So don't give it an anchor
760 B %70flex_midExtend ;And do the shuffling about
761
762 ; --- There wasn't enough space there, so allocate more ---
763
764 65flex_midExtend
765 MOV R9,R1 ;Look after the size we want
766 SUB R13,R13,#4 ;Create a flex anchor
767 MOV R0,R13 ;Point to it
768 SUB R1,R1,#flex__ohead ;We'll overwrite the overhead
769 BL flex_alloc ;Allocate some memory
770 [ OPT_APCS
771 CMP R0,#0 ;Did it fail?
772 ADDEQ R13,R13,#1 ;Skip past stacked anchor
773 LDMEQFD R13!,{R4-R9,R12,PC}^
774 |
775 LDMCSFD R13!,{R0-R9,R12,R14} ;If it failed, unstack...
776 ADDCS R13,R13,#1 ;Skip past stacked anchor
777 ORRCSS PC,R14,#C_flag ;... and set carry
778 ]
779 LDR R3,[R13],#4 ;Get pointer to new block
780
781 ; --- A reminder about the registers ---
782 ;
783 ; R0-R2 aren't interesting any more
784 ; R3 points flex__ohead bytes ahead of old flex__free
785 ; R4-R6 are still our arguments
786 ; R7,R8 aren't exciting any more
787 ; R9 is the amount of extra space we wanted
788
789 ; --- Our block may have moved -- recalculate next ptr ---
790
791 LDR R7,[R4] ;Point to the block
792 SUB R7,R7,#flex__ohead ;Point to the overhead area
793 LDR R8,[R7,#flex__size] ;Get the size of the block
794 ADD R8,R8,#flex__ohead+7 ;Bump over the overhead
795 BIC R8,R8,#7 ;And align to multiple of 8
796
797 ; --- Move all the other blocks up a bit ---
798
799 ADD R1,R7,R8 ;Start moving from here
800 ADD R0,R1,R9 ;Move it to here
801 SUB R2,R3,#flex__ohead ;Find the old flex__free
802 SUBS R2,R2,R1 ;Copy the right section up
803 BLNE fastMove
804 [ OPT_STACK
805 BLNE flex__reloc ;And adjust any stacked ptrs
806 ]
807
808 ; --- Adjust the block size and anchors ---
809
810 LDR R14,[R7,#flex__size] ;Get the size of this block
811 ADD R14,R14,R6 ;Add on the extension
812 STR R14,[R7,#flex__size] ;Store it back again
813 BL flex__fixup ;Fix up all the anchors again
814 ; Drop through to block shuffling
815
816 ; --- Create the gap in the flex block ---
817
818 70flex_midExtend
819 LDR R4,[R7,#flex__size] ;Get the size of the block
820 SUB R4,R4,R6 ;Find the old length
821 ADD R1,R7,#flex__ohead ;Point to the real data
822 ADD R1,R1,R5 ;Find the `at' position
823 ADD R0,R1,R6 ;Find the `at'+|`by'| posn
824 SUBS R2,R4,R5 ;Find the length to move
825 BLNE fastMove ;Do the move
826 [ OPT_STACK
827 BLNE flex__reloc ;And adjust any stacked ptrs
828 ]
829
830 [ OPT_APCS
831 MOV R0,#-1
832 LDMFD R13!,{R4-R9,R12,PC}^
833 |
834 LDMFD R13!,{R0-R9,R12,PC}^
835 ]
836
837 LTORG
838
839 ; --- flex_init ---
840 ;
841 ; On entry: R0 == pointer to dynamic area name, or zero
842 ; R1 == maximum allowed size of the area
843 ; (except Sapphire version)
844 ;
845 ; On exit: --
846 ;
847 ; Use: Initialises the flex heap for use.
848
849 EXPORT flex_init
850 EXPORT flex_dinit
851 flex_init ROUT
852
853 [ OPT_STEEL
854 MOV R0,#0
855 MOV R1,#1
856 ]
857
858 flex_dinit STMFD R13!,{R0-R8,R12,R14}
859 WSPACE flex__wSpace
860
861 [ :LNOT:OPT_STANDALONE
862
863 ; --- Prevent multiple initialisation ---
864
865 LDR R14,flex__flags ;Find my flags word
866 TST R14,#fFlag__inited ;Am I initialised yet?
867 LDMNEFD R13!,{R0-R8,R12,PC}^ ;Yes -- return right now
868
869 ]
870
871 [ OPT_DYNAREA
872
873 ; --- If this is Sapphire, find the options block ---
874
875 [ OPT_SAPPHIRE
876
877 BL rov_init ;Work out the RISC OS version
878 BL rov_version ;Get the version
879 CMP R0,#348 ;Is this RISC OS 3.5?
880 BCC %10flex_init ;No -- skip ahead then
881
882 LDR R0,flex__optName ;Get the magic marker word
883 BL libOpts_find ;Try to find the options
884 BCC %10flex_init ;Not there -- skip on then
885 LDR R14,[R0,#0] ;Load the flags out
886 TST R14,#1 ;Is the dynamic area flag on?
887 BEQ %10flex_init ;No -- don't do this then
888
889 ; --- See if we can create a dynamic area ---
890
891 TST R14,#2 ;Specified area size?
892 LDRNE R5,[R0,#4] ;Yes -- load from opts block
893 MOVEQ R5,#16*1024*1024 ;16 meg maximum size
894 LDR R8,sapph_appName ;Find the application name
895
896 |
897
898 ; --- If this is APCS, then use the arguments ---
899
900 CMP R0,#0 ;Is a dynamic area wanted?
901 CMPNE R1,#0 ;Just check for stupidity
902 BEQ %10flex_init ;No -- then skip ahead
903 MOV R8,R0 ;Find the name pointer
904 MOV R5,R1 ;And the size requested
905
906 MOV R0,#129 ;Find the OS version
907 MOV R1,#0 ;Convoluted call for this...
908 MOV R2,#255 ;No idea why
909 SWI OS_Byte ;Call the operating system
910 CMP R1,#&A5 ;Is it late enough?
911 BCC %10flex_init ;No -- ignore the request
912
913 ]
914
915 ; --- Create a dynamic area ---
916
917 MOV R0,#0 ;Create new dynamic area
918 MOV R1,#-1 ;Give me any old number
919 MOV R2,#0 ;Zero size initially
920 MOV R3,#-1 ;Don't care about base addr
921 MOV R4,#(1<<7) ;Don't let user drag the bar
922 MOV R6,#0 ;No dynamic area handler
923 MOV R7,#0 ;I wuz told to do this
924 SWI XOS_DynamicArea ;Try to create the area
925 BVS %10flex_init ;It failed -- use WimpSlot
926
927 ; --- Set up workspace for this ---
928
929 STR R3,flex__base ;Store base of the area
930 STR R3,flex__free ;The first free part
931 STR R3,flex__end ;And the end
932 STR R1,flex__dynArea ;Save dynamic area handle
933
934 MOV R0,#fFlag__compact + fFlag__inited + fFlag__dynArea
935 STR R0,flex__flags ;Store the appropriate flags
936
937 ; --- Add in tidy-up routine to delete the area ---
938
939 [ OPT_SAPPHIRE
940 BL except_init ;We need to clear it up
941 ADR R0,flex__exit ;Point to exit handler
942 MOV R1,R12 ;Pass it my workspace
943 BL except_atExit ;Register the routine
944 ]
945
946 [ OPT_ATEXIT
947 ADR R0,flex_die ;Point to exit handler
948 BL atexit ;And call that
949 ]
950
951 B %20flex_init ;And continue initialisation
952
953 ]
954
955 ; --- Find out the slot size ---
956
957 10flex_init MOV R0,#-1 ;Read current slot size
958 BL flex__setslot ;Do the slot thing
959
960 ; --- Store initial heap information ---
961
962 STR R0,flex__base ;The start of the heap
963 STR R0,flex__free ;The first free part
964 STR R0,flex__end ;And the end
965
966 MOV R0,#fFlag__compact + fFlag__inited
967 ;Empty heaps is compact heaps
968 STR R0,flex__flags
969
970 ; --- Get the page size of the machine ---
971
972 20flex_init SWI OS_ReadMemMapInfo ;Get page size (in R0)
973 STR R0,flex__chunk ;Store for future reference
974
975 ; --- Set up the flex relocation stack ---
976
977 [ OPT_STACK
978 ADR R14,flex__relocStk ;Point to the stack base
979 STR R14,flex__relocSP ;Save this as initial SP
980 ]
981
982 ; --- Register the flex compactor as a postfilter ---
983
984 [ OPT_SAPPHIRE
985 BL event_init ;Initialise event system
986 ADR R0,flex__preFilter ;Point to the prefilter
987 MOV R1,R12 ;Give it my workspace ptr
988 BL event_preFilter ;Add the filter into the list
989 ADR R0,flex__postFilter ;Point to the postfilter
990 MOV R1,R12 ;Give it my workspace ptr
991 BL event_postFilter ;Add the filter into the list
992 ]
993
994 LDMFD R13!,{R0-R8,R12,PC}^
995
996 [ OPT_SAPPHIRE
997 flex__optName DCB "FLEX"
998 ]
999
1000 LTORG
1001
1002 [ OPT_SAPPHIRE
1003 flex__wSpace DCD 0
1004 ]
1005
1006 [ OPT_APCS
1007 flex__wSpace DCD flex__sSpace
1008 ]
1009
1010 ; --- flex__preFilter ---
1011 ;
1012 ; On entry: R0 == WIMP event mask
1013 ; R1 == pointer to event block
1014 ; R2 == time to return, or 0
1015 ; R3 == pointer to poll word if necessary
1016 ;
1017 ; On exit: R0,R2 maybe updated to enable idle events
1018 ;
1019 ; Use: Enables full idle events if the flex heap needs compacting.
1020
1021 [ OPT_SAPPHIRE
1022
1023 flex__preFilter ROUT
1024
1025 STMFD R13!,{R14} ;Save a register
1026 LDR R14,flex__flags ;Find the flags word
1027 TST R14,#fFlag__compact ;Is the heap compacted?
1028 BICEQ R0,R0,#1 ;No -- unmask idle events
1029 MOVEQ R2,#0 ;And return immediately
1030 LDMFD R13!,{PC}^ ;Return to caller
1031
1032 LTORG
1033
1034 ]
1035
1036 ; --- flex__postFilter ---
1037 ;
1038 ; On entry: R0 == WIMP reason code
1039 ; R1 == pointer to event block
1040 ; R2 == time to return or 0
1041 ; R3 == pointer to poll word or nothing really
1042 ;
1043 ; On exit: Everything must be preserved
1044 ;
1045 ; Use: Compacts the flex heap every idle event
1046
1047 [ OPT_SAPPHIRE
1048
1049 flex__postFilter ROUT
1050
1051 CMP R0,#0 ;Is this an idle event?
1052 MOVNES PC,R14 ;No -- then return right now
1053 STMFD R13!,{R0} ;Save a register
1054 LDR R0,flex__flags ;Find the flags word
1055 TST R0,#fFlag__compact ;Is the heap compacted?
1056 LDMFD R13!,{R0} ;Restore the register's value
1057 MOVNES PC,R14 ;Return if it is
1058 B flex__compact ;Go give the heap a nudge
1059
1060 LTORG
1061
1062 ]
1063
1064 [ OPT_APCS
1065
1066 ; --- flex_budge / flex_dont_budge ---
1067 ;
1068 ; On entry: --
1069 ;
1070 ; On exit: --
1071 ;
1072 ; Use: Nothing. Both of these do the same thing.
1073
1074 EXPORT flex_budge
1075 EXPORT flex_dont_budge
1076 flex_budge ROUT
1077 flex_dont_budge MOV R0,#0 ;Refuse the budge
1078 MOVS PC,R14 ;And return
1079
1080 ]
1081
1082 ; --- flex_die / flex__exit ---
1083 ;
1084 ; On entry: --
1085 ;
1086 ; On exit: --
1087 ;
1088 ; Use: Kills the dynamic area which we own.
1089
1090 [ OPT_DYNAREA
1091
1092 [ OPT_SAPPHIRE
1093 flex__exit ROUT
1094 |
1095 EXPORT flex_die
1096 flex_die ROUT
1097 ]
1098
1099
1100 STMFD R13!,{R0,R1,R14} ;Save some registers
1101
1102 ; --- The C library's `atexit' doesn't provide context ---
1103
1104 [ :LNOT:OPT_SAPPHIRE
1105 WSPACE flex__wSpace
1106 ]
1107
1108 ; --- Now free the dynamic area ---
1109
1110 LDR R1,flex__dynArea ;Load the handle
1111 CMP R1,#0 ;Is it defined?
1112 MOVNE R0,#1 ;Yes -- remove it
1113 SWINE OS_DynamicArea ;Do the remove job
1114 MOVNE R0,#0 ;Now clear the handle
1115 STRNE R0,flex__dynArea ;So we don't do it again
1116 LDMFD R13!,{R0,R1,PC}^ ;Finally, return to caller
1117
1118 LTORG
1119
1120 ]
1121
1122 [ OPT_STACK
1123
1124 ; --- flex_stackPtr ---
1125 ;
1126 ; On entry: R0 == 0 to read, or value to set
1127 ;
1128 ; On exit: R0 == old value
1129 ;
1130 ; Use: Either reads or writes the flex stack pointer. This sort
1131 ; of thing is useful in exception handlers etc.
1132
1133 EXPORT flex_stackPtr
1134 flex_stackPtr ROUT
1135
1136 STMFD R13!,{R12,R14} ;Save some registers
1137 WSPACE flex__wSpace ;Find the workspace
1138 LDR R14,flex__relocSP ;Load the current value
1139 CMP R0,#0 ;Does he want to write it?
1140 STRNE R0,flex__relocSP ;Yes -- then write it
1141 MOV R0,R14 ;Return the old value
1142 LDMFD R13!,{R12,PC}^ ;And return to caller
1143
1144 LTORG
1145
1146 ; --- flex_save ---
1147 ;
1148 ; On entry: R0 == value to save, for APCS
1149 ;
1150 ; On exit: --
1151 ;
1152 ; Use: Saves some registers on the flex relocation stack. R13
1153 ; and R14 cannot be saved -- these registers are corrupted
1154 ; during this routine's execution.
1155 ;
1156 ; Values saved on the flex relocation stack are adjusted as
1157 ; flex moves blocks of memory around, so that they still point
1158 ; to the same thing as they did before. Obviously, values
1159 ; which aren't pointers into flex blocks may be corrupted.
1160 ; Values pointing to objects deleted (either free blocks, or
1161 ; areas removed by flex_midExtend) may also be corrupted.
1162 ;
1163 ; Since this routine takes no arguments, some other method has
1164 ; to be used. The method chosen is to follow the call to
1165 ; flex_save with a LDM or STM instruction containing the
1166 ; registers to be saved. This instruction is skipped by the
1167 ; routine, and thus not executed.
1168 ;
1169 ; Note that if you give the LDM or STM the same condition code
1170 ; as the BL preceding it, it will never be executed, since
1171 ; flex_save skips it if the condition is true and it can't be
1172 ; executed if the condition is false.
1173 ;
1174 ; (All the above is only true for the Sapphire version.)
1175
1176 EXPORT flex_save
1177 flex_save ROUT
1178
1179 [ :LNOT:OPT_APCS
1180
1181 ; --- StrongARM friendly version 1st October 1996 [mdw] ---
1182
1183 STMFD R13!,{R10,R11,R12,R14} ;Save some registers away
1184 BIC R10,R14,#&FC000003 ;Clear processor flags
1185 WSPACE flex__wSpace ;Locate flex's workspace
1186 LDR R11,flex__relocSP ;Load the stack pointer
1187 LDR R10,[R10,#0] ;Load the instruction out
1188
1189 ; --- Rather optimised code ---
1190 ;
1191 ; Shift two bits at a time into C and N. Leave early if
1192 ; possible.
1193
1194 TST R10,#&03F
1195 BEQ %f05
1196 MOVS R14,R10,LSL #31
1197 STRMI R0,[R11],#4
1198 STRCS R1,[R11],#4
1199 MOVS R14,R10,LSL #29
1200 STRMI R2,[R11],#4
1201 STRCS R3,[R11],#4
1202 TST R10,#&FF0
1203 BEQ %f05
1204 MOVS R14,R10,LSL #27
1205 STRMI R4,[R11],#4
1206 STRCS R5,[R11],#4
1207 TST R10,#&FC0
1208 BEQ %f00
1209 05 MOVS R14,R10,LSL #25
1210 STRMI R6,[R11],#4
1211 STRCS R7,[R11],#4
1212 MOVS R14,R10,LSL #23
1213 STRMI R8,[R11],#4
1214 STRCS R9,[R11],#4
1215 TST R10,#&C00
1216 BEQ %f00
1217 MOVS R14,R10,LSL #21
1218 LDRMI R14,[R13,#0]
1219 STRMI R14,[R11],#4
1220 LDRCS R14,[R13,#4]
1221 STRCS R14,[R11],#4
1222 00
1223 ; --- Tidy up and return home ---
1224
1225 STR R11,flex__relocSP ;Store new stack ptr
1226 LDMFD R13!,{R10,R11,R12,R14} ;And return to caller
1227 ADDS PC,R14,#4
1228
1229 |
1230
1231 STMFD R13!,{R12,R14} ;Save registers
1232 WSPACE flex__wSpace ;Find my workspace
1233 LDR R14,flex__relocSP ;Load the current pointer
1234 STR R0,[R14],#4 ;Store the value away
1235 STR R14,flex__relocSP ;Store the stack pointer
1236 LDMFD R13!,{R12,PC}^ ;And return to caller
1237
1238 ]
1239
1240 LTORG
1241
1242 ; --- flex_load ---
1243 ;
1244 ; On entry: --
1245 ;
1246 ; On exit: Registers loaded from relocation stack as requested
1247 ;
1248 ; Use: Restores registers saved on flex's relocation stack. See
1249 ; flex_save for calling information and details about the
1250 ; relocation stack.
1251
1252 EXPORT flex_load
1253 flex_load ROUT
1254
1255 [ :LNOT:OPT_APCS
1256
1257 ; --- StrongARM friendly version 1st October 1996 [mdw] ---
1258
1259 STMFD R13!,{R10,R11,R12,R14} ;Save some registers away
1260 BIC R10,R14,#&FC000003 ;Clear processor flags
1261 WSPACE flex__wSpace ;Locate flex's workspace
1262 LDR R11,flex__relocSP ;Load the stack pointer
1263 LDR R10,[R10,#0] ;Load the instruction out
1264
1265 ; --- Rather optimised code ---
1266 ;
1267 ; Shift two bits at a time into C and N. Leave early if
1268 ; possible. Do it backwards, because otherwise it doesn't
1269 ; work.
1270
1271 TST R10,#&FF0
1272 BEQ %f05
1273 MOVS R14,R10,LSL #21
1274 LDRCS R14,[R11,#-4]!
1275 STRCS R14,[R13,#4]
1276 LDRMI R14,[R11,#-4]!
1277 STRMI R14,[R13,#0]
1278 MOVS R14,R10,LSL #23
1279 LDRCS R9,[R11,#-4]!
1280 LDRMI R8,[R11,#-4]!
1281 TST R10,#&0FF
1282 BEQ %f00
1283 MOVS R14,R10,LSL #25
1284 LDRCS R7,[R11,#-4]!
1285 LDRMI R6,[R11,#-4]!
1286 TST R10,#&03F
1287 BEQ %f00
1288 MOVS R14,R10,LSL #27
1289 LDRCS R5,[R11,#-4]!
1290 LDRMI R4,[R11,#-4]!
1291 TST R10,#&00F
1292 BEQ %f00
1293 05 MOVS R14,R10,LSL #29
1294 LDRCS R3,[R11,#-4]!
1295 LDRMI R2,[R11,#-4]!
1296 MOVS R14,R10,LSL #31
1297 LDRCS R1,[R11,#-4]!
1298 LDRMI R0,[R11,#-4]!
1299 00
1300 ; --- Tidy up and return home ---
1301
1302 STR R11,flex__relocSP ;Store new stack ptr
1303 LDMFD R13!,{R10,R11,R12,R14} ;And return to caller
1304 ADDS PC,R14,#4
1305
1306 |
1307
1308 STMFD R13!,{R12,R14} ;Save registers
1309 WSPACE flex__wSpace ;Find my workspace
1310 LDR R14,flex__relocSP ;Load the current pointer
1311 LDR R0,[R14,#-4]! ;Load the value out
1312 STR R14,flex__relocSP ;Store the stack pointer
1313 LDMFD R13!,{R12,PC}^ ;And return to caller
1314
1315 ]
1316
1317 LTORG
1318
1319 ; --- flex__reloc ---
1320 ;
1321 ; On entry: R0 == destination pointer of move
1322 ; R1 == source pointer of move
1323 ; R2 == length of block to move
1324 ;
1325 ; On exit: --
1326 ;
1327 ; Use: Relocates the flex stack after a heap operation which moved
1328 ; memory. The arguments are intentionally the same as those
1329 ; for fastMove, which should be called immediately before this
1330 ; routine.
1331
1332 flex__reloc ROUT
1333
1334 STMFD R13!,{R3,R4,R14} ;Save some registers
1335
1336 ; --- Set up initial values ---
1337
1338 ADR R3,flex__relocStk ;Point to the flex stack base
1339 LDR R4,flex__relocSP ;Load the current stack ptr
1340
1341 ; --- Go through all the stack entries ---
1342
1343 00flex__reloc CMP R3,R4 ;Have we reached the end?
1344 LDMGEFD R13!,{R3,R4,PC}^ ;Yes -- return to caller
1345 LDR R14,[R3],#4 ;Load the saved value
1346 SUB R14,R14,R1 ;Subtract the source base
1347 CMP R14,R2 ;Is value within block?
1348 ADDLO R14,R14,R0 ;Yes -- add the destination
1349 STRLO R14,[R3,#-4] ;Store pointer if it changed
1350 B %00flex__reloc ;And go round for the rest
1351
1352 LTORG
1353
1354 ]
1355
1356 ; --- flex_dump ---
1357
1358 [ OPT_DUMP
1359
1360 EXPORT flex_dump
1361 flex_dump ROUT
1362
1363 STMFD R13!,{R0-R12,R14}
1364 SWI XOS_NewLine
1365 SWI XOS_NewLine
1366 SWI XOS_Write0
1367 SWI XOS_NewLine
1368
1369 LDR R11,=flex__data
1370 LDR R5,[R11,#flex__base]
1371 LDR R6,[R11,#flex__free]
1372 LDR R7,[R11,#flex__end]
1373
1374 SWI XOS_WriteS
1375 DCB "Heap base: ",0
1376 MOV R0,R5
1377 BL writeHex
1378 SWI XOS_WriteS
1379 DCB 13,10,"Heap free area: ",0
1380 MOV R0,R6
1381 BL writeHex
1382 SWI XOS_WriteS
1383 DCB 13,10,"Heap end: ",0
1384 MOV R0,R7
1385 BL writeHex
1386
1387 00 CMP R5,R6
1388 LDMGEFD R13!,{R0-R12,PC}^
1389
1390 SWI XOS_WriteS
1391 DCB 13,10,10,"Block address: ",0
1392 MOV R0,R5
1393 BL writeHex
1394 SWI XOS_WriteS
1395 DCB 13,10," Size: ",0
1396 LDR R0,[R5,#flex__size]
1397 BL writeHex
1398 SWI XOS_WriteS
1399 DCB 13,10," Anchor: ",0
1400 LDR R0,[R5,#flex__bkanchor]
1401 BL writeHex
1402 LDR R0,[R5,#flex__size]
1403 ADD R0,R0,#flex__ohead+7
1404 BIC R0,R0,#7
1405 ADD R5,R5,R0
1406 B %00
1407
1408 writeHex STMFD R13!,{R1,R2,R14}
1409 SUB R1,R13,#256
1410 MOV R2,#256
1411 SWI XOS_ConvertHex8
1412 SWI XOS_Write0
1413 LDMFD R13!,{R1,R2,PC}^
1414
1415 writeDec STMFD R13!,{R1,R2,R14}
1416 SUB R1,R13,#256
1417 MOV R2,#256
1418 SWI XOS_ConvertInteger4
1419 SWI XOS_Write0
1420 LDMFD R13!,{R1,R2,PC}^
1421
1422 LTORG
1423
1424 ]
1425
1426 ;----- Workspace ------------------------------------------------------------
1427
1428 ; --- Flags ---
1429
1430 fFlag__inited EQU (1<<0) ;We are currently running
1431 fFlag__compact EQU (1<<1) ;The heap is compact ATM
1432
1433 [ OPT_DYNAREA
1434 fFlag__dynArea EQU (1<<2) ;Using a dynamic area
1435 ]
1436
1437 ; --- Flex block format ---
1438
1439 ^ 0
1440 flex__bkanchor # 4 ;Back-pointer to flex anchor
1441 flex__size # 4 ;Size of this flex block
1442 flex__ohead # 0 ;The flex overhead on blocks
1443
1444 ; --- Static data ---
1445
1446 [ :LNOT:OPT_STANDALONE
1447
1448 ^ 0,R12
1449 flex__wStart # 0
1450
1451 [ OPT_DYNAREA
1452 GBLL FLEXWS_DYNAREA
1453 ]
1454
1455 [ OPT_STACK
1456 GBLL FLEXWS_STACK
1457 ]
1458
1459 GET libs:sh.flexws
1460
1461 flex__wSize EQU {VAR}-flex__wStart
1462
1463 ]
1464
1465 [ OPT_SAPPHIRE
1466 AREA |Sapphire$$LibData|,CODE,READONLY
1467 DCD flex__wSize
1468 DCD flex__wSpace
1469 DCD 0
1470 DCD flex_init
1471 ]
1472
1473 [ OPT_APCS
1474 AREA |C$$zidata|,DATA,NOINIT
1475 flex__sSpace % flex__wSize
1476 ]
1477
1478 ;----- That's all, folks ----------------------------------------------------
1479
1480 END
The Straylight Source Distribution (obsolete software for RISC OS)