~mdw / ssr / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Initial revision
[ssr] / StraySrc / Dynamite / dynamite / s / dynHeap
1 ;
2 ; dynHeap.s
3 ;
4 ; New heap management for Dynamite
5 ;
6 ; © 1994-1998 Straylight
7 ;
8 ;----- Licensing note -------------------------------------------------------
9 ;
10 ; This file is part of Straylight's Dynamite
11 ;
12 ; Dynamite is free software; you can redistribute it and/or modify
13 ; it under the terms of the GNU General Public License as published by
14 ; the Free Software Foundation; either version 2, or (at your option)
15 ; any later version.
16 ;
17 ; Dynamite is distributed in the hope that it will be useful,
18 ; but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 ; GNU General Public License for more details.
21 ;
22 ; You should have received a copy of the GNU General Public License
23 ; along with Dynamite. If not, write to the Free Software Foundation,
24 ; 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25
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 libs:sh.fastMove
37
38 GET sh.dynArea
39 GET sh.dynTask
40 GET sh.wSpace
41
42 GET sh.messages
43
44 ;----- Macros ---------------------------------------------------------------
45
46 MACRO
47 $label DIR $reg
48 $label LDR $reg,dyn_machine ;Get the machine type
49 CMP $reg,#&A5 ;Is it a RISC PC?
50 MEND
51
52 ;----- Main code ------------------------------------------------------------
53
54 AREA |Dynamite$$Code|,CODE,READONLY
55
56 ; --- dh_alloc ---
57 ;
58 ; On entry: R0 == pointer to anchor
59 ; R1 == size to allocate in bytes
60 ; R2 == ID value to store
61 ;
62 ; On exit: R0 and R1 preserved
63 ; R2 == address of block allocated
64 ;
65 ; Use: Allocates a block from the Dynamite heap.
66
67 EXPORT dh_alloc
68 dh_alloc ROUT
69
70 STMFD R13!,{R0,R1,R3,R14} ;Save some registers
71 MOV R3,R0 ;Keep anchor pointer
72 ADD R0,R1,#blk__oHead+15 ;Put size in R0...
73 BIC R0,R0,#15 ;...after mangling suitably
74 BL dh__ensure ;Ensure the memory's there
75 BVS %90dh_alloc ;If not there, return error
76 STR R1,[R0,#blk__size] ;Save the size in there
77 STR R3,[R0,#blk__anchor] ;And the anchor address
78 STR R2,[R0,#blk__id] ;Oh, and the ID value
79 ADD R2,R0,#blk__oHead ;Return correct address
80 STR R2,[R3,#0] ;And save address in anchor
81 LDMFD R13!,{R0,R1,R3,PC}^ ;And return to caller
82
83 90dh_alloc ADD R13,R13,#4 ;Don't restore R0 on exit
84 LDMFD R13!,{R1,R3,R14} ;Unstack some registers
85 ORRS PC,R14,#V_flag ;And return the error
86
87 LTORG
88
89 ; --- dh_free ---
90 ;
91 ; On entry: R0 == pointer to anchor of block to free
92 ;
93 ; On exit: --
94 ;
95 ; Use: Frees a Dynamite block.
96
97 EXPORT dh_free
98 dh_free ROUT
99
100 STMFD R13!,{R1,R14} ;Save some registers
101 BL dh__checkAnchor ;Make sure the anchor's OK
102 MOVVC R14,#0 ;If so, clear block's anchor
103 STRVC R14,[R1,#blk__anchor] ;Zero the anchor (R14==0 !!)
104 BLVC dh__unCompact ;Say the heap is uncompact
105 LDMFD R13!,{R1,PC} ;Return to caller
106
107 LTORG
108
109 ; --- dh_freeWithID ---
110 ;
111 ; On entry: R0 == ID of all blocks to free
112 ;
113 ; On exit: --
114 ;
115 ; Use: Frees all allocated blocks with a given ID number.
116
117 EXPORT dh_freeWithID
118 dh_freeWithID ROUT
119
120 CMP R0,#0 ;Is he trying to free ID 0?
121 ADREQL R0,msg_errBadFreeAll ;Yes -- that's an error
122 ORREQS PC,R14,#V_flag ;So return it to him
123
124 ; --- Do the freeing job ---
125 ;
126 ; We just tonk a 0 anchor over all blocks with a matching ID.
127
128 STMFD R13!,{R0-R4,R14} ;Save some registers
129 LDR R2,dyn_heapSize ;Load the current heap size
130 DIR R14 ;Is it RISC PC?
131 LDRGE R1,dyn_areaBase ;Yes -- load the area base
132 RSBLT R1,R2,#&01800000 ;No -- find the base anyway
133 ADD R2,R2,R1 ;Find the heap end address
134 MOV R3,#0 ;Haven't freed anything yet
135
136 00dh_freeWithID CMP R1,R2 ;Have we reached the end?
137 BGE %10dh_freeWithID ;Yes -- return then
138 LDR R14,[R1,#blk__id] ;Get the block's ID
139 SUBS R14,R14,R0 ;Is it a match? (=> R14==0)
140 STREQ R14,[R1,#blk__anchor] ;Yes -- blank out the anchor
141 MOVEQ R3,#1 ;And remember we done this
142 LDR R14,[R1,#blk__size] ;Load this block's size
143 ADD R14,R14,#blk__oHead+15 ;Add on the overhead size
144 BIC R14,R14,#15 ;And align to granularity
145 ADD R1,R1,R14 ;Move on to next block
146 B %00dh_freeWithID ;And go round again
147
148 ; --- We finished -- tidy up and return ---
149
150 10dh_freeWithID CMP R3,#0 ;Did we free anything?
151 BLNE dh__unCompact ;Yes -- then heap isn't tidy
152 LDMFD R13!,{R0-R4,PC}^ ;And return to caller
153
154 LTORG
155
156 ; --- dh_blockInfo ---
157 ;
158 ; On entry: R0 == address of block anchor
159 ;
160 ; On exit: R0 preserved
161 ; R1 == address of block
162 ; R2 == size of block
163 ; R3 == block ID
164 ;
165 ; Use: Returns information about a Dynamite block
166
167 EXPORT dh_blockInfo
168 dh_blockInfo ROUT
169
170 STMFD R13!,{R14} ;Save the link register
171 BL dh__checkAnchor ;Make sure anchor is kosher
172 LDMVCIB R1,{R2,R3} ;Yes -- load size and ID
173 ADDVC R1,R1,#blk__oHead ;Point to the block
174 LDMFD R13!,{PC} ;And return to caller
175
176 LTORG
177
178 ; --- dh_changeID ---
179 ;
180 ; On entry: R0 == address of anchor block, or 0 for all
181 ; R1 == new ID
182 ; R2 == old ID (if R0 == 0)
183 ;
184 ; On exit: --
185 ;
186 ; Use: This call is use to change the ID of either an individual
187 ; block (R0 == address of anchor), or the ID of all the
188 ; blocks with the ID passed in R2 (if R0 == 0).
189
190 EXPORT dh_changeID
191 dh_changeID ROUT
192
193 STMFD R13!,{R0-R3,R14} ;Stack some registers
194 CMP R0,#0 ;Just one block to change?
195 BEQ %50dh_changeID ;No -- jump ahead
196
197 ; --- Change the ID of a specific block ---
198
199 MOV R2,R1 ;Preserve the new ID
200 BL dh__checkAnchor ;Check the anchor
201 BVS %99dh_changeID ;It's garbish -- return error
202 STR R2,[R1,#blk__id] ;Store the new id
203 B %98dh_changeID ;And return to caller
204
205 ; --- Change the ID of all blocks with ID R2 ---
206
207 50dh_changeID LDR R3,dyn_heapSize ;Load the current heap size
208 DIR R14 ;Is it RISC PC?
209 LDRGE R0,dyn_areaBase ;Yes -- load the area base
210 RSBLT R0,R3,#&01800000 ;No -- find the base anyway
211 ADD R3,R3,R0 ;Find the heap end address
212
213 60dh_changeID CMP R0,R3 ;Have we reached the end?
214 BGE %98dh_changeID ;Yes -- return then
215 LDR R14,[R0,#blk__id] ;Get the id of this block
216 CMP R14,R2 ;Do we want to change it?
217 STREQ R1,[R0,#blk__id] ;Yes -- make it so then
218 LDR R14,[R0,#blk__size] ;Get the block size
219 ADD R14,R14,#blk__oHead+15 ;Add on the block size
220 BIC R14,R14,#15 ;And word align
221 ADD R0,R0,R14 ;Point to the next block
222 B %60dh_changeID ;Keep on looking for blocks
223
224 98dh_changeID LDMFD R13!,{R0-R3,PC}^ ;Return to caller
225
226 99dh_changeID ADD R13,R13,#4 ;Don't unstack R0
227 LDMFD R13!,{R1-R3,R14} ;Get back registers
228 ORRS PC,R14,#V_flag ;Return with error
229
230 LTORG
231
232 ; --- dh__checkAnchor ---
233 ;
234 ; On entry: R0 == address of anchor to check
235 ;
236 ; On exit: R1 == address of block descriptor
237 ;
238 ; Use: Ensures that a given anchor is valid.
239
240 dh__checkAnchor ROUT
241
242 STMFD R13!,{R14} ;Save some registers
243 LDR R1,[R0,#0] ;Load the block address
244 SUB R1,R1,#blk__oHead ;Point to our information
245 LDR R14,[R1,#blk__anchor] ;Load the block's anchor
246 CMP R0,R14 ;Do they match up?
247 ADRNEL R0,msg_errBadAnchor ;No -- point to error message
248 LDMFD R13!,{R14} ;Restore registers
249 BICEQS PC,R14,#V_flag ;Anchor OK -- clear V on exit
250 ORRNES PC,R14,#V_flag ;Anchor duff -- return error
251
252 LTORG
253
254 ; --- dh__ensure ---
255 ;
256 ; On entry: R0 == number of bytes required (multiple of 16)
257 ;
258 ; On exit: R0 == pointer to base of area allocated
259 ;
260 ; Use: Ensures that there are R0 bytes available in the heap. If
261 ; there aren't R0 bytes available, it goes out of its way to
262 ; ensure that there *are* by getting more. If there still
263 ; isn't enough, it compacts the heap and tries some more.
264
265 dh__ensure ROUT
266
267 STMFD R13!,{R1-R5,R14} ;Save some registers
268 MOV R1,R0 ;Keep the size I want
269
270 ; --- Try to find some space among the free blocks ---
271
272 LDR R3,dyn_heapSize ;Load the current heap size
273 DIR R14 ;Is it RISC PC?
274 LDRGE R2,dyn_areaBase ;Yes -- load the area base
275 RSBLT R2,R3,#&01800000 ;No -- find the base anyway
276 ADD R3,R3,R2 ;Find the heap end address
277 MOV R5,#0 ;No bytes found yet
278
279 00dh__ensure CMP R2,R3 ;Is there more to go?
280 BGE %05dh__ensure ;No -- then extend the heap
281
282 LDR R0,[R2,#blk__size] ;Load this block's size
283 ADD R0,R0,#blk__oHead+15 ;Add on the overhead size
284 BIC R0,R0,#15 ;And align to granularity
285 LDR R14,[R2,#blk__anchor] ;Is the block free?
286 ADD R2,R2,R0 ;Bump on block pointer
287 CMP R14,#0 ;If so, anchor==0
288 MOVNE R5,#0 ;If not, clear free size
289 BNE %00dh__ensure ;And loop round again
290
291 ; --- Found a free block ---
292
293 CMP R5,#0 ;Is there a free block size?
294 SUBEQ R4,R2,R0 ;No -- this is the start then
295 ADD R5,R5,R0 ;Add on the size of this blk
296 SUBS R14,R5,R1 ;Is this big enough?
297 BLT %00dh__ensure ;No -- keep on round
298
299 ; --- Found a big enough space ---
300
301 BEQ %03dh__ensure ;If no leftover, skip on
302 ADD R3,R4,R1 ;Point to bit left over
303 MOV R0,#0 ;This block is free
304 SUB R2,R14,#blk__oHead ;Subtract info overhead
305 STMIA R3,{R0,R2} ;Save this in the block
306
307 ; --- Return address of this memory ---
308
309 03dh__ensure MOV R0,R4 ;Point to the free block
310 LDMFD R13!,{R1-R5,R14} ;Unstack registers
311 BICS PC,R14,#V_flag ;And clear error indicator
312
313 ; --- Main size ensuring loop ---
314
315 05dh__ensure LDR R14,dyn_areaSize ;Get the dynamic area size
316 LDR R2,dyn_heapSize ;And the size we're using
317 SUB R3,R14,R2 ;How much do we have?
318 SUBS R3,R1,R3 ;And is it enough?
319 BLE %10dh__ensure ;Yes -- skip onwards
320
321 ; --- Try to get some more pages ---
322
323 LDR R14,dyn_pageSize ;Load machine page size
324 SUB R14,R14,#1 ;Subtract one -- round up
325 ADD R3,R3,R14 ;Add it on for rounding
326 LDR R4,dyn_log2PageSize ;Load the page size log
327 MOV R0,R3,LSR R4 ;How many do I need?
328 BL da_addPages ;Get some more
329 BVC %10dh__ensure ;It worked -- skip onwards
330
331 ; --- Hmm... -- try compacting the heap ---
332
333 BL dh_compact ;Try to compact the heap
334 BCC %05dh__ensure ;If it did, try again
335
336 ADRL R0,msg_errNoMem ;Point to the error
337 LDMFD R13!,{R1-R5,R14} ;Restore the registers
338 ORRS PC,R14,#V_flag ;And return to caller
339
340 ; --- Extend the heap and return the base address ---
341
342 10dh__ensure ADD R14,R2,R1 ;Work out the new heap size
343 STR R14,dyn_heapSize ;Save this away for later
344 DIR R0 ;Get the heap's direcection
345 LDRGE R0,dyn_areaBase ;Yes -- load the area base
346 ADDGE R0,R0,R2 ;And add the old heap size
347 RSBLT R0,R14,#&01800000 ;Otherwise find the heap base
348 LDMFD R13!,{R1-R5,R14} ;Unstack registers
349 BICS PC,R14,#V_flag ;And clear error indicator
350
351 LTORG
352
353 ; --- dh_reduce ---
354 ;
355 ; On entry: --
356 ;
357 ; On exit: CS if there was nothing we could do
358 ;
359 ; Use: Tries to shunt the free space in the heap off the end and
360 ; back into the operating system's free pool. It does it a
361 ; little bit and then stops, rather like those workmen on the
362 ; M40.
363
364 EXPORT dh_reduce
365 dh_reduce ROUT
366
367 STMFD R13!,{R14} ;Save some registers
368 LDR R14,dyn_hpFlags ;Load the heap's flags
369 TST R14,#hpFlag_tidy ;Is the heap tidy?
370 LDREQ R14,dyn_lockCount ;No -- then load lock count
371 CMPEQ R14,#0 ;Is the heap locked?
372 BNE %91dh_reduce ;Yes -- then return CS now
373
374 ; --- Do search for free blocks ---
375
376 STMFD R13!,{R0-R9} ;Save some more registers
377 LDR R1,dyn_heapSize ;Load the current heap size
378 DIR R14 ;Is it RISC PC?
379 LDRGE R5,dyn_areaBase ;Yes -- load the area base
380 RSBLT R5,R1,#&01800000 ;No -- find the base anyway
381 ADD R1,R1,R5 ;Find the heap end address
382 MOV R9,R5 ;Remember heap base address
383
384 ; --- Find a free block ---
385
386 MOV R7,#0 ;No previous block
387 00dh_reduce CMP R5,R1 ;Are we at the end yet?
388 BGE %04dh_reduce ;Yes -- jump ahead a little
389
390 LDR R2,[R5,#blk__anchor] ;Get the block's anchor addr
391 CMP R2,#0 ;Is the block free?
392 LDR R2,[R5,#blk__size] ;Get the block size
393 ADD R2,R2,#blk__oHead+15 ;Add on the overhead bytes
394 BIC R2,R2,#15 ;And word align the size
395 MOVNE R7,R5 ;No -- remember where it is
396 ADDNE R5,R5,R2 ;...move on to next one
397 BNE %00dh_reduce ;...go round for another one
398
399 ; --- We've found a free block ---
400
401 01dh_reduce ADD R6,R5,R2 ;Point to the next block
402 CMP R6,R1 ;Is that the end of the heap?
403 MOVGE R8,R7 ;Yes -- set up prev pointer
404 SUBGE R2,R2,#blk__oHead ;...take off overhead
405 STRGE R2,[R5,#blk__size] ;...store overall block size
406 BGE %04dh_reduce ;...and jump ahead a little
407
408 ; --- Check for two free blocks together ---
409
410 LDR R0,[R6,#blk__anchor] ;Does this have an anchor?
411 CMP R0,#0 ;Check if it's free
412 SUBNE R2,R2,#blk__oHead ;Not -- take off overhead
413 STRNE R2,[R5,#blk__size] ;...store overall block size
414 BNE %02dh_reduce ;...jump ahead a little
415
416 ; --- Join two adjacent free blocks together ---
417
418 LDR R0,[R6,#blk__size] ;Yes -- get its size
419 ADD R2,R0,R2 ;Concatenate the two blocks
420 ADD R2,R2,#blk__oHead+15 ;Add on the overhead bytes
421 BIC R2,R2,#15 ;And word align the size
422 B %01dh_reduce ;And check again...
423
424 ; --- We may be searching for the last block ---
425
426 02dh_reduce
427 DIR R14 ;Get the heap direction
428 MOVLT R5,R6 ;Down -- point to next block
429 MOVLT R8,R7 ;...remember last block pos.
430 BLT %00dh_reduce ;...and keep on searching
431
432 ; --- There's a block to bring down ---
433
434 LDR R4,[R6,#blk__size] ;Get size of block to move
435 ADD R4,R4,#blk__oHead+15 ;Add the flex overhead
436 BIC R4,R4,#15 ;And word align the size
437 MOVS R2,R4 ;This is the size to move
438 MOV R0,R5 ;Where to move it to
439 MOV R1,R6 ;Where it is right now
440 BLNE dh__move ;Copy it down PDQ
441 ADD R0,R5,R4 ;Point after block we moved
442 MOV R1,#0 ;Block doesn't have an anchor
443 STR R1,[R0,#blk__anchor] ;Store that away for later
444 SUB R1,R6,R5 ;Find the difference here
445 SUB R1,R1,#blk__oHead ;Don't count this size here
446 STR R1,[R0,#blk__size] ;Store the old size in free
447
448 ; --- We need to fix up the block we moved ---
449
450 LDR R0,[R5,#blk__anchor] ;Get the anchor pointer
451 ADD R1,R5,#blk__oHead ;Point to the real data
452 STR R1,[R0] ;Store client's new anchor
453
454 ; --- That's it -- return to caller ---
455
456 B %10dh_reduce ;Return to caller
457
458 ; --- We've reached the end of the heap ---
459 ;
460 ; Now things get a little more complicated:
461 ;
462 ; If the heap goes upwards, then there may be a free block
463 ; on the end that we can free (R5 < R1), otherwise the heap
464 ; is compacted.
465 ;
466 ; If the heap goes downwards, then R8 points to the block
467 ; immediately before the last free one. If R8 is 0, then
468 ; either the heap is compacted (the first block is not free)
469 ; or there is only on free block, and it's at the lower
470 ; end of the heap.
471
472 04dh_reduce
473 DIR R14 ;Get the heap direction
474 BGE %05dh_reduce ;Upwards -- jump ahead
475
476 CMP R8,#0 ;Was there a previous block?
477 BNE %07dh_reduce ;Yes -- compact heap then
478
479 LDR R14,[R9,#blk__anchor] ;Get previous block anchor
480 CMP R14,#0 ;Is the first block free?
481 BNE %90dh_reduce ;No -- the heap is compacted
482
483 LDR R14,[R9,#blk__size] ;Get the size of the free blk
484 ADD R14,R14,#blk__oHead+15 ;Add on the overhead
485 BIC R14,R14,#15 ;And correctly align
486 ADD R7,R9,R14 ;Point past the free block
487
488 LDR R0,dyn_areaSize ;Get the area size
489 RSB R14,R0,#&01800000 ;Find the base address
490 SUB R5,R7,R14 ;Get size of unsused area
491 SUB R14,R0,R5 ;Get the area size left
492 STR R14,dyn_heapSize ;Store it away nicely
493 LDR R14,dyn_log2PageSize ;Get the log page size
494 MOVS R0,R5,LSR R14 ;How many pages can we free?
495 BLNE da_removePages ;More than 0 -- free them
496 B %20dh_reduce ;Return to caller
497
498 ; --- Merge the last block with the free area ---
499
500 05dh_reduce CMP R5,R1 ;Had we reached the end?
501 BGE %90dh_reduce ;Yes -- heaps compact then
502
503 SUB R14,R5,R9 ;Get the used area size
504 STR R14,dyn_heapSize ;And store it away
505 LDR R0,dyn_pageSize ;Get the machine page size
506 SUB R0,R0,#1 ;Turn into a bitmask
507 ADD R5,R5,R0 ;Align this to page boundary
508 BIC R0,R5,R0 ;And finish off the align
509 LDR R1,dyn_areaSize ;Get the dyn area size
510 ADD R1,R1,R9 ;Point to end of area
511 SUBS R0,R1,R0 ;Are these different?
512 BEQ %10dh_reduce ;No -- return
513 LDR R14,dyn_log2PageSize ;Get the log page size
514 MOVS R0,R0,LSR R14 ;How many pages can we free?
515 BLNE da_removePages ;More than 0 -- free them
516 B %20dh_reduce ;Return to caller
517
518 ; --- Move a block in a downwards heap ---
519
520 07dh_reduce LDR R2,[R8,#blk__size] ;Get size of block to move
521 ADD R2,R2,#blk__oHead+15 ;Add the flex overhead
522 BIC R2,R2,#15 ;And word align the size
523 ADD R0,R8,R2 ;Point to the free block
524 LDR R4,[R0,#blk__size] ;Load out it's size
525 ADD R14,R4,#blk__oHead+15 ;Add the flex overhead
526 BIC R14,R14,#15 ;And word align the size
527 ADD R0,R0,R14 ;Point to the end of the blk
528 SUB R0,R0,R2 ;Copy the block to here
529 MOV R1,R8 ;Where it is right now
530 BLNE dh__move ;Copy it down PDQ
531 MOV R1,#0 ;Block doesn't have an anchor
532 STR R1,[R8,#blk__anchor] ;Store that away for later
533 STR R4,[R8,#blk__size] ;Store the old size in free
534
535 ; --- We need to fix up the block we moved ---
536
537 LDR R14,[R0,#blk__anchor] ;Get the anchor pointer
538 ADD R0,R0,#blk__oHead ;Point to the real data
539 STR R0,[R14] ;Store client's new anchor
540
541 ; --- That's it -- return ---
542
543 10dh_reduce LDMFD R13!,{R0-R9,R14} ;Load back registers
544 BICS PC,R14,#C_flag ;Return with C clear
545
546 ; --- There wasn't anything to do -- we're compacted ---
547
548 20dh_reduce LDR R0,dyn_hpFlags ;Load my flags
549 ORR R0,R0,#hpFlag_tidy ;We're compacted
550 STR R0,dyn_hpFlags ;Store back the flags
551 LDMFD R13!,{R0-R9,R14} ;Load back registers
552 BICS PC,R14,#C_flag ;Return with C clear
553
554 ; --- Nothing could be done ---
555
556 90dh_reduce LDMFD R13!,{R0-R9} ;Load back registers
557 91dh_reduce LDMFD R13!,{R14} ;And the link too
558 ORRS PC,R14,#C_flag ;Return with C set
559
560 LTORG
561
562 ; --- dh_compact ---
563 ;
564 ; On entry: --
565 ;
566 ; On exit: --
567 ;
568 ; Use: Does a full compaction of the heap.
569
570 EXPORT dh_compact
571 dh_compact ROUT
572
573 STMFD R13!,{R14} ;Stack the link register
574 BL dh_reduce ;Try to reduce the heap
575 LDMCSFD R13!,{PC} ;If it couldn't, return CS
576 00dh_compact BL dh_reduce ;Try to reduce the heap
577 BCC %00dh_compact ;Did something -- try again
578 LDMFD R13!,{R14} ;Return to caller...
579 BICS PC,R14,#C_flag ;... saying we did something
580
581 LTORG
582
583 ; --- dh__unCompact ---
584 ;
585 ; On entry: --
586 ;
587 ; On exit: --
588 ;
589 ; Use: Marks the heap as being uncompact.
590
591 dh__unCompact ROUT
592
593 STMFD R13!,{R14} ;Stack the link register
594 LDR R14,dyn_hpFlags ;Load the flags word
595 TST R14,#hpFlag_tidy ;Is the tidy bit on?
596 BICNE R14,R14,#hpFlag_tidy ;Clear the 'is tidy' bit
597 STRNE R14,dyn_hpFlags ;Store back the flags
598 BLNE dt_message ;Yes -- prod compactor
599 LDMFD R13!,{PC}^ ;Return to caller
600
601 LTORG
602
603 ; --- dh_lock ---
604 ;
605 ; On entry: --
606 ;
607 ; On exit: R10 corrupted (SWIs don't care about this)
608 ;
609 ; Use: Locks the heap, so that compaction entirely fails to happen.
610
611 EXPORT dh_lock
612 dh_lock ROUT
613
614 LDR R10,dyn_lockCount ;Load the old lock count
615 ADD R10,R10,#1 ;Bump the counter a little
616 STR R10,dyn_lockCount ;Store the counter back
617 MOVS PC,R14 ;And return to caller
618
619 LTORG
620
621 ; --- dh_unlock ---
622 ;
623 ; On entry: --
624 ;
625 ; On exit: R10 corrupted (SWIs don't care about this)
626 ;
627 ; Use: Unlocks the heap, so that compaction can happen again, maybe.
628
629 EXPORT dh_unlock
630 dh_unlock ROUT
631
632 LDR R10,dyn_lockCount ;Load the old lock count
633 SUBS R10,R10,#1 ;Knock the counter down
634 STRGE R10,dyn_lockCount ;Store the counter back
635 BEQ dt_message ;If now enabled, signal task
636 MOVS PC,R14 ;And return to caller
637
638 LTORG
639
640 ; --- dh_save ---
641 ;
642 ; On entry: R0 == mask of registers to save
643 ;
644 ; On exit: R10, R11 corrupted
645 ;
646 ; Use: Saves a load of registers on the Dynamite relocation stack.
647 ; The mask in R0 contains a bit set for each register to save:
648 ; bit 3 set means save R3 etc. Since this is a SWI, only
649 ; R1-R9 can be saved on the stack.
650
651 EXPORT dh_save
652 dh_save ROUT
653
654 ; --- StrongARM friendly version 1st October 1996 [mdw] ---
655
656 LDR R10,dyn_stackPtr ;Load the stack pointer
657
658 TST R0,#&03F
659 BEQ %f05
660 MOVS R11,R0,LSL #31
661 STRCS R1,[R10],#4
662 TST R0,#&3FC
663 BEQ %f00
664 MOVS R11,R0,LSL #29
665 STRMI R2,[R10],#4
666 STRCS R3,[R10],#4
667 TST R0,#&3F0
668 BEQ %f00
669 MOVS R11,R0,LSL #27
670 STRMI R4,[R10],#4
671 STRCS R5,[R10],#4
672 TST R0,#&3C0
673 BEQ %f00
674 05 MOVS R11,R0,LSL #25
675 STRMI R6,[R10],#4
676 STRCS R7,[R10],#4
677 MOVS R11,R0,LSL #23
678 STRMI R8,[R10],#4
679 STRCS R9,[R10],#4
680 00
681 STR R10,dyn_stackPtr ;Save stack pointer back
682 MOVS PC,R14 ;And return to caller
683
684 LTORG
685
686 ; --- dh_load ---
687 ;
688 ; On entry: R0 == mask of registers to load
689 ;
690 ; On exit: R10, R11 corrupted
691 ;
692 ; Use: Loads a load of registers on the Dynamite relocation stack.
693 ; The mask in R0 contains a bit set for each register to load:
694 ; bit 3 set means load R3 etc. Since this is a SWI, only
695 ; R1-R9 can be read from the stack.
696
697 EXPORT dh_load
698 dh_load ROUT
699
700 ; --- StrongARM friendly version 1st October 1996 [mdw] ---
701
702 LDR R10,dyn_stackPtr ;Load the stack pointer
703
704 TST R0,#&3F0
705 BEQ %f05
706 MOVS R11,R0,LSL #23
707 LDRCS R9,[R10,#-4]!
708 LDRMI R8,[R10,#-4]!
709 TST R0,#&0FF
710 BEQ %f00
711 MOVS R11,R0,LSL #25
712 LDRCS R7,[R10,#-4]!
713 LDRMI R6,[R10,#-4]!
714 TST R0,#&03F
715 BEQ %f00
716 MOVS R11,R0,LSL #27
717 LDRCS R5,[R10,#-4]!
718 LDRMI R4,[R10,#-4]!
719 TST R0,#&00F
720 BEQ %f00
721 05 MOVS R11,R0,LSL #29
722 LDRCS R3,[R10,#-4]!
723 LDRMI R2,[R10,#-4]!
724 MOVS R11,R0,LSL #31
725 LDRCS R1,[R10,#4]!
726 00
727 STR R10,dyn_stackPtr ;Save stack pointer back
728 MOVS PC,R14 ;And return to caller
729
730 LTORG
731
732 ; --- dh_extend ---
733 ;
734 ; On entry: R0 == address of block anchor
735 ; R1 == new size for block
736 ;
737 ; On exit: R0 preserved
738 ; R1 == address of block, may have moved
739 ;
740 ; Use: Changes the size of a block.
741
742 EXPORT dh_extend
743 dh_extend ROUT
744
745 STMFD R13!,{R2,R14} ;Save some registers
746 MOV R2,R1 ;Keep the size safe a while
747 BL dh__checkAnchor ;Make sure anchor's kosher
748 LDRVC R1,[R1,#blk__size] ;Load the size word nicely
749 SUBVC R2,R2,R1 ;Get the `by' value I need
750 BLVC dh_midExtend ;Do the messing about
751 LDMFD R13!,{R2,PC} ;Return to caller
752
753 LTORG
754
755 ; --- dh_midExtend ---
756 ;
757 ; On entry: R0 == address of block anchor
758 ; R1 == byte offset from block start
759 ; R2 == number of bytes to insert
760 ;
761 ; On exit: R0 preserved
762 ; R1 == address of block, may have moved
763 ;
764 ; Use: Inserts or removes bytes at a given offset into a Dynamite
765 ; heap block.
766
767 EXPORT dh_midExtend
768 dh_midExtend ROUT
769
770 STMFD R13!,{R0,R2-R9,R14} ;Save some registers
771 MOV R5,R0 ;Keep the anchor address
772 MOV R6,R1 ;And the byte offset
773 MOV R7,R2 ;And the size to insert
774
775 ; --- To start with, some sanity checks ---
776
777 BL dh__checkAnchor ;Make sure anchor is OK
778 BVS %90dh_midExtend ;If not, return error
779 CMP R7,#0 ;Are we growing the block?
780 ADDLT R14,R6,R7 ;No -- get lowest byte access
781 MOVGE R14,R6 ;Yes -- similarly
782 CMP R14,#0 ;Is this off the end?
783 ADRLTL R0,msg_errBadMid ;Yes -- point to error
784 BLT %90dh_midExtend ;And return to caller
785 LDR R4,[R1,#blk__size] ;Get the block's size
786 CMP R6,R4 ;Are we going too far here?
787 ADRGTL R0,msg_errBadMid ;Yes -- point to error
788 BGT %90dh_midExtend ;And return to caller
789
790 ; --- Now do the correct extend job ---
791
792 CMP R7,#0 ;Are we growing the block?
793 BEQ %85dh_midExtend ;Not changing -- return
794 BLT %50dh_midExtend ;Shrinking -- skip to do that
795
796 ; --- Make a block bigger ---
797 ;
798 ; We do this in 3 stages:
799 ;
800 ; * Get the amount of dead space at the end of the block, and
801 ; see if this is enough.
802 ;
803 ; * If not, gather together the free blocks immediately
804 ; following the block and add this to the dead space.
805 ;
806 ; * If we still don't have enough, we ensure a block of the
807 ; required size (plus block descriptor) and copy the data
808 ; into there.
809 ;
810 ; Registers will be used as follows:
811 ;
812 ; R5-R7 are original arguments
813 ; R4 == current size of block
814 ; R3 == size of area we have found
815 ; R2 == base address of extension area
816 ; R1 == base address of block
817
818 ADD R2,R1,R4 ;Find the end of the block
819 ADD R3,R4,#blk__oHead+15 ;Align block size to gran.
820 BIC R0,R3,#15 ;To get dead space too
821 SUB R3,R0,#blk__oHead ;But don't have the overhead
822 SUB R3,R3,R4 ;Get size of the dead space
823 CMP R3,R7 ;Is there enough for us?
824 BGE %30dh_midExtend ;Yes -- use it then
825
826 ; --- Now we must gather free blocks together nicely ---
827
828 STMFD R13!,{R8-R10} ;Save some more registers
829 ADD R8,R1,R0 ;Find start of next block
830 DIR R14 ;Which way is the heap going?
831 LDRGE R14,dyn_areaBase ;Upwards -- get base address
832 LDRGE R10,dyn_heapSize ;And the heap's size
833 ADDGE R10,R14,R10 ;To get the top of the heap
834 MOVLT R10,#&01800000 ;Downwards -- get heap top
835
836 05dh_midExtend CMP R8,R10 ;Are we there yet?
837 BGE %10dh_midExtend ;Yes -- stop there then
838 LDR R14,[R8,#blk__anchor] ;Get the block's anchor
839 CMP R14,#0 ;Is it a free block?
840 BNE %10dh_midExtend ;No -- stop here then
841 LDR R9,[R8,#blk__size] ;Get the block's size
842 ADD R9,R9,#blk__oHead+15 ;Add information overhead
843 BIC R9,R9,#15 ;And align size nicely
844 ADD R8,R8,R9 ;Move on to next block
845 ADD R3,R3,R9 ;And increase available space
846 CMP R3,R7 ;Do we have enough yet?
847 BLT %05dh_midExtend ;No -- go round again
848
849 LDMFD R13!,{R8-R10} ;Restore the stack pointer
850 B %30dh_midExtend ;And do the extend op
851
852 ; --- Not enough space in free blocks ---
853 ;
854 ; We dh__ensure enough space in the heap, and copy the whole
855 ; lot.
856
857 10dh_midExtend LDMFD R13!,{R8-R10} ;Restore the stack pointer
858 ADD R0,R4,R7 ;Get the required size
859 ADD R0,R0,#blk__oHead+15 ;Add information overhead
860 BIC R0,R0,#15 ;And align size nicely
861 BL dh__ensure ;Make the space available
862 BVS %90dh_midExtend ;If it failed, return error
863 LDR R1,[R5,#0] ;Reload anchor -- may move
864 SUB R1,R1,#blk__oHead ;And find real block base
865 ADD R2,R4,#blk__oHead ;Add on the info overhead
866 BL dh__move ;Copy the data over
867 ADD R14,R0,#blk__oHead ;Point to the usable area
868 STR R14,[R5,#0] ;Save client's new anchor
869 MOV R14,#0 ;Get a zero word
870 STR R14,[R1,#blk__anchor] ;To mark old block as free
871 BL dh__unCompact ;The heap is not compact now
872
873 ; --- Set up registers for the resize op ---
874
875 MOV R1,R0 ;Point at the new block base
876 ADD R2,R1,R4 ;Find area to extend from
877 MOV R3,R7 ;And the size we have found
878
879 ; --- Perform the block resize ---
880
881 30dh_midExtend ADD R14,R4,R7 ;Get the new block size
882 STR R14,[R1,#blk__size] ;And save it away
883 ADD R3,R3,R4 ;Get the total area size
884 ADD R14,R14,#blk__oHead+15 ;Add overhead to new size
885 BIC R14,R14,#15 ;And align nicely
886
887 ; --- Increase the heap size if we need to ---
888
889 ADD R0,R1,R14 ;Find the end of the area
890 LDR R9,dyn_heapSize ;Load the current heap size
891 DIR R8 ;Is it RISC PC?
892 LDRGE R8,dyn_areaBase ;Yes -- load the area base
893 RSBLT R8,R9,#&01800000 ;No -- find the base anyway
894 ADD R9,R9,R8 ;Find the heap end address
895 CMP R0,R9 ;Is end too high?
896 SUBGT R0,R0,R8 ;Yes -- get the heap size
897 STRGT R0,dyn_heapSize ;...and store it back again
898
899 ADD R3,R3,#blk__oHead+15 ;Do the same for the whole...
900 BIC R3,R3,#15 ;... area size
901 SUBS R3,R3,R14 ;Get the space left at end
902 BLE %35dh_midExtend ;Perfect fit -- skip on
903
904 ; --- Insert a free block here ---
905
906 ADD R0,R1,R14 ;Find the end of the area
907 MOV R2,#0 ;No anchor -- it's free
908 SUB R3,R3,#blk__oHead ;Subtract overhead size
909 STMIA R0,{R2,R3} ;Save in descriptor block
910
911 ; --- Now split the block as required ---
912
913 35dh_midExtend ADD R1,R1,#blk__oHead ;Point at usable part of blk
914 ADD R1,R1,R6 ;Find the split offset
915 ADD R0,R1,R7 ;Find where to move to
916 SUBS R2,R4,R6 ;How much we have to move
917 BLNE dh__move ;Do the split op
918 B %85dh_midExtend ;And return happily to caller
919
920 ; --- We have to reduce a block ---
921
922 50dh_midExtend ADD R14,R4,R7 ;Get the new size
923 STR R14,[R1,#blk__size] ;This is the new size
924 ADD R1,R1,#blk__oHead ;Point at usable part of blk
925 ADD R1,R1,R6 ;Find the split offset
926 ADD R0,R1,R7 ;Find where to move to
927 SUBS R2,R4,R6 ;How much we have to move
928 BLNE dh__move ;Do the split op
929
930 ; --- Now update the size and insert free block ---
931
932 ADD R3,R4,R7 ;Find the new size
933 ADD R4,R4,#blk__oHead+15 ;Add overhead to new size
934 BIC R4,R4,#15 ;And align nicely
935 ADD R3,R3,#blk__oHead+15 ;Do the same for the whole...
936 BIC R3,R3,#15 ;... area size
937 SUBS R14,R4,R3 ;Get the space left at end
938 BEQ %85dh_midExtend ;Perfect fit -- skip onwards
939
940 ; --- Insert a free block here ---
941
942 LDR R1,[R5,#0] ;Load the block address
943 SUB R1,R1,#blk__oHead ;Point to the block descr.
944 ADD R0,R1,R3 ;Find the end of the area
945 MOV R2,#0 ;No anchor -- it's free
946 SUB R3,R14,#blk__oHead ;Subtract overhead size
947 STMIA R0,{R2,R3} ;Save in descriptor block
948 BL dh__unCompact ;The heap is not compact now
949
950 ; --- Now everything is great ---
951
952 85dh_midExtend LDR R1,[R5,#0] ;Load the block address
953 LDMFD R13!,{R0,R2-R9,R14} ;Unstack registers
954 BICS PC,R14,#V_flag ;And return to caller
955
956 ; --- We failed miserably ---
957
958 90dh_midExtend ADD R13,R13,#4 ;Don't restore R0 on exit
959 LDMFD R13!,{R2-R9,R14} ;Unstack registers
960 ORRS PC,R14,#V_flag ;And return to caller
961
962 LTORG
963
964 ; --- dh__move ---
965 ;
966 ; On entry: R0 == destination of movement
967 ; R1 == base of block to move
968 ; R2 == size of block to move
969 ;
970 ; On exit: --
971 ;
972 ; Use: Shunts memory around in the heap, relocating everything that
973 ; needs relocation.
974
975 dh__move ROUT
976
977 STMFD R13!,{R3,R4,R14} ;Save some registers
978 BL fastMove ;Do the memory movement
979
980 ; --- Now relocate entries on the stack ---
981
982 10dh__move LDR R4,dyn_stackPtr ;Find the stack pointer now
983 ADR R3,dyn_stack ;Point to the stack base
984 15dh__move CMP R3,R4 ;Have we finished yet?
985 BGE %20dh__move ;Yes -- return then
986 LDR R14,[R3],#4 ;Load next entry from stack
987 SUB R14,R14,R1 ;Subtract source address
988 CMP R14,R2 ;Is it in the block?
989 ADDLO R14,R14,R0 ;Yes -- relocate
990 STRLO R14,[R3,#-4] ;And store back in stack
991 B %15dh__move ;And carry on relocating
992
993 20dh__move LDMFD R13!,{R3,R4,PC}^ ;Return to caller
994
995 LTORG
996
997 ; --- dh_checkHeap ---
998 ;
999 ; On entry: --
1000 ;
1001 ; On exit: May return an error
1002 ;
1003 ; Use: Checks the current internal format of the heap to make
1004 ; sure that it hasn't been corrupted in any way.
1005 ; If the integrity check fails then an error is returned.
1006
1007 EXPORT dh_checkHeap
1008 dh_checkHeap ROUT
1009
1010 STMFD R13!,{R0-R7,R14} ;Save some registers
1011
1012 ; --- Start going throught the blocks ---
1013
1014 LDR R6,dyn_heapSize ;Load the current heap size
1015 DIR R14 ;Is it RISC PC?
1016 LDRGE R5,dyn_areaBase ;Yes -- load the area base
1017 RSBLT R5,R6,#&01800000 ;No -- find the base anyway
1018 ADD R6,R6,R5 ;Find the heap end address
1019 MOV R9,R5 ;Remember heap base address
1020
1021 ; --- Find a block ---
1022
1023 MOV R7,R5 ;Previous block
1024 00dh_checkHeap CMP R5,R6 ;Are we at the end yet?
1025 ADRGTL R0,msg_errBadHeap2 ;Oops -- must have a bad len
1026 BGT %90dh_checkHeap ;Gone past -- oops
1027 BEQ %50dh_checkHeap ;Yes -- jump ahead a little
1028
1029 MOV R0,R5 ;Get the base of area to chk
1030 ADD R1,R0,#blk__oHead ;Get the overhead size
1031 SWI OS_ValidateAddress ;Make sure this is kosher
1032 ADRCSL R0,msg_errBadHeap2 ;No -- must have a bad len
1033 BCS %90dh_checkHeap ;If not, moan at client
1034 LDR R2,[R5,#blk__anchor] ;Get the block's anchor addr
1035 CMP R2,#0 ;Is the block free?
1036 BEQ %10dh_checkHeap ;Yes -- jump ahead
1037
1038 ; --- Make sure the anchor checks OK ---
1039
1040 MOV R7,R5 ;This block could be wrong
1041 MOV R0,R2 ;Get the base of area to chk
1042 ADD R1,R0,#4 ;Just check one word
1043 SWI OS_ValidateAddress ;Make sure this is kosher
1044 ADRCSL R0,msg_errBadHeap3 ;Address must be dead then
1045 BCS %90dh_checkHeap ;If not, moan at client
1046
1047 LDR R0,[R2,#0] ;Load the anchors value
1048 ADD R14,R5,#blk__oHead ;This is what R0 should be
1049 CMP R0,R14 ;Do they match?
1050 ADRNEL R0,msg_errBadHeap1 ;No -- point to the error
1051 BNE %90dh_checkHeap ;And return it joyfully
1052
1053 ; --- Go round for more then ---
1054
1055 10dh_checkHeap LDR R3,[R5,#blk__size] ;Get the block size
1056 ADD R3,R3,#blk__oHead+15 ;Add on the overhead bytes
1057 BIC R3,R3,#15 ;And word align the size
1058 ADD R5,R5,R3 ;Yes -- move on to next one
1059 B %00dh_checkHeap ;...go round for another one
1060
1061 50dh_checkHeap LDMFD R13!,{R0-R7,R14} ;Load registers back
1062 BICS PC,R14,#V_flag ;Return without error
1063
1064 90dh_checkHeap ADD R13,R13,#4
1065 STR R7,[R0,#0] ;Store as the error number!
1066 LDMFD R13!,{R1-R7,R14} ;Load registers back
1067 ORRS PC,R14,#V_flag ;Return with error
1068
1069 LTORG
1070
1071 ; --- dh_changeAnchor ---
1072 ;
1073 ; On entry: R0 == pointer to anchor for block
1074 ; R1 == address of new anchor
1075 ;
1076 ; On exit: --
1077 ;
1078 ; Use: Adjusts a block's anchor, in case it moves.
1079
1080 EXPORT dh_changeAnchor
1081 dh_changeAnchor ROUT
1082
1083 STMFD R13!,{R2,R14} ;Save a register
1084 MOV R2,R1 ;Remember this value
1085 BL dh__checkAnchor ;Make sure the anchor's OK
1086 STRVC R2,[R1,#blk__anchor] ;Save the new anchor pointer
1087 ADDVC R14,R1,#blk__oHead ;Skip onto the actual data
1088 STRVC R14,[R2,#0] ;And set the new anchor up
1089 LDMFD R13!,{R2,PC} ;Return to caller
1090
1091 LTORG
1092
1093 ; --- dh_dump ---
1094 ;
1095 ; On entry: --
1096 ;
1097 ; On exit: --
1098 ;
1099 ; Use: Outputs a textual description of the dynamite heap, giving
1100 ; details of each block within it.
1101
1102 dh__preDump LDR R12,[R12]
1103
1104 EXPORT dh_dump
1105 dh_dump ROUT
1106
1107 STMFD R13!,{R0-R4,R14} ;Stack some registers
1108
1109 LDR R4,dyn_heapSize ;Get the current heap size
1110 DIR R14 ;Which direction does it go?
1111 LDRGE R2,dyn_areaBase ;Up -- find the base then
1112 RSBLT R2,R4,#&1800000 ;Down -- start below the RMA
1113 ADD R3,R2,R4 ;Find the heap limit address
1114
1115 ; --- Display information about the heap in general ---
1116
1117 ADRL R0,msg_dumpHpBase ;Find the message
1118 MOV R1,R2 ;Get the heap base address
1119 BL dh__writeHex ;And display it
1120
1121 MOV R1,R4 ;Get the heap size
1122 ADRL R0,msg_dumpHpSize ;Find the message
1123 BL dh__writeHex ;And display it
1124
1125 LDR R1,dyn_areaSize ;Get the dynamic area size
1126 ADRL R0,msg_dumpHpArSz ;Find the message
1127 BL dh__writeHex ;And display it
1128
1129 ; --- Now start on the loop ---
1130
1131 00 CMP R2,R3 ;Have we finished yet?
1132 LDMCSFD R13!,{R0-R4,PC}^ ;Yes -- then return
1133
1134 SWI OS_NewLine ;Start a new line here
1135
1136 ADRL R0,msg_dumpBlkAddr ;Point to the message
1137 ADD R1,R2,#blk__oHead ;Point to the current block
1138 BL dh__writeHex ;Display it
1139
1140 ADRL R0,msg_dumpBlkSize ;Point at the message
1141 MOV R0,R0 ;No-op to prevent objasm bug!
1142 LDR R1,[R2,#blk__size] ;Get the block's size
1143 BL dh__writeHex ;Display it
1144
1145 LDR R1,[R2,#blk__id] ;Load the magic ID
1146 ADRL R0,msg_dumpBlkId ;Point at the message
1147 BL dh__writeHex ;Display it nicely
1148
1149 LDR R1,[R2,#blk__anchor] ;Find the anchor address
1150 CMP R1,#0 ;Is the block free?
1151 ADREQL R0,msg_dumpBlkFree ;Yes -- point to the message
1152 SWIEQ XOS_Write0 ;And display it on screen
1153 ADRNEL R0,msg_dumpBlkAnch ;Otherwise show anchor addr
1154 BLNE dh__writeHex ;And move on to next block
1155
1156 LDR R14,[R2,#blk__size] ;Load the block size again
1157 ADD R14,R14,#blk__oHead+15 ;Add overhead and align
1158 BIC R14,R14,#15 ;To find the next block
1159 ADD R2,R2,R14 ;Move onto the next block
1160 B %b00 ;And skip back into the loop
1161
1162 dh__writeHex STMFD R13!,{R2,R14} ;Save some registers
1163 SWI XOS_Write0 ;Display the string
1164 SUB R13,R13,#12 ;Make a small buffer
1165 MOV R0,R1 ;Get the number to display
1166 MOV R1,R13 ;Point to the buffer
1167 MOV R2,#12 ;The buffer size, sir
1168 SWI XOS_ConvertHex8 ;Convert it into ASCII
1169 SWI XOS_Write0 ;Display that too
1170 SWI XOS_NewLine ;Move on to a new line
1171 ADD R13,R13,#12 ;Restore the stack pointer
1172 LDMFD R13!,{R2,PC}^ ;And return to caller
1173
1174 LTORG
1175
1176 ;----- * Commands -----------------------------------------------------------
1177
1178 AREA |Dynamite$$Commands|,CODE,READONLY
1179
1180 DCB "Dynamite_HeapDump",0
1181 DCD dh__preDump
1182 DCD 0
1183 DCD synt_heapDump
1184 DCD help_heapDump
1185
1186 ;----- Data structures ------------------------------------------------------
1187
1188 ; --- Block descriptors ---
1189
1190 ^ 0
1191 blk__anchor # 4 ;Address of block's anchor
1192 blk__size # 4 ;Block's size, as allocated
1193 blk__id # 4 ;Client's magic ID number
1194 blk__oHead # 0 ;Overhead on allocated blocks
1195
1196 ;----- That's all, folks ----------------------------------------------------
1197
1198 END
The Straylight Source Distribution (obsolete software for RISC OS)