Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Annotation of /sml/trunk/src/runtime/gc/import-heap.c
ViewVC logotype

Annotation of /sml/trunk/src/runtime/gc/import-heap.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 48 - (view) (download) (as text)

1 : monnier 2 /* import-heap.c
2 :     *
3 :     * COPYRIGHT (c) 1992 by AT&T Bell Laboratories.
4 :     *
5 :     * Routines to import an ML heap image.
6 :     */
7 :    
8 :     #include <stdio.h>
9 :     #include <string.h>
10 :     #include "ml-base.h"
11 :     #include "machine-id.h"
12 :     #include "memory.h"
13 :     #include "reg-mask.h"
14 :     #include "cache-flush.h"
15 :     #include "ml-state.h"
16 :     #include "ml-values.h"
17 :     #include "ml-objects.h"
18 :     #include "ml-globals.h"
19 :     #include "card-map.h"
20 :     #include "heap.h"
21 :     #include "ml-heap-image.h"
22 :     #include "c-globals-tbl.h"
23 :     #include "addr-hash.h"
24 :     #include "heap-input.h"
25 :     #include "heap-io.h"
26 :    
27 :     #ifndef SEEK_SET
28 :     # define SEEK_SET 0
29 :     # define SEEK_END 2
30 :     #endif
31 :    
32 :     #ifdef DEBUG
33 :     PVT void PrintRegionMap (bo_region_reloc_t *r)
34 :     {
35 :     bo_reloc_t *dp, *dq;
36 :     int i;
37 :    
38 :     SayDebug ("region @%#x: |", r->firstPage);
39 :     for (i = 0, dq = r->objMap[0]; i < r->nPages; i++) {
40 :     dp = r->objMap[i];
41 :     if (dp != dq) {
42 :     SayDebug ("|");
43 :     dq = dp;
44 :     }
45 :     if (dp == NIL(bo_reloc_t *))
46 :     SayDebug ("_");
47 :     else
48 :     SayDebug ("X");
49 :     }
50 :     SayDebug ("|\n");
51 :    
52 :     } /* end of PrintRegionMap */
53 :     #endif
54 :    
55 :    
56 :     /* local routines */
57 :     PVT void ReadHeap (inbuf_t *bp, ml_heap_hdr_t *hdr, ml_state_t *msp, ml_val_t *externs);
58 :     PVT bigobj_desc_t *AllocBODesc (bigobj_desc_t *, bigobj_hdr_t *, bo_region_reloc_t *);
59 :     PVT void RepairHeap (
60 :     heap_t *, aid_t *, Addr_t [MAX_NUM_GENS][NUM_ARENAS],
61 :     addr_tbl_t *, ml_val_t *);
62 :     PVT ml_val_t RepairWord (
63 :     ml_val_t w, aid_t *oldBIBOP, Addr_t addrOffset[MAX_NUM_GENS][NUM_ARENAS],
64 :     addr_tbl_t *boRegionTbl, ml_val_t *externs);
65 :     PVT int RepairBORef (aid_t *bibop, aid_t id, ml_val_t *ref, ml_val_t oldObj);
66 :     PVT bo_reloc_t *AddrToRelocInfo (aid_t *, addr_tbl_t *, aid_t, Addr_t);
67 :    
68 :     #define READ(bp,obj) HeapIO_ReadBlock(bp, &(obj), sizeof(obj))
69 :    
70 :     #ifdef HACKED_STANDALONE
71 :     PVT long heapStart = -1;
72 :     #endif
73 :    
74 :    
75 :     /* ImportHeapImage:
76 :     */
77 :     ml_state_t *ImportHeapImage (const char *fname, heap_params_t *params)
78 :     {
79 :     int i;
80 :     ml_state_t *msp;
81 :     ml_image_hdr_t imHdr;
82 :     ml_heap_hdr_t heapHdr;
83 :     ml_val_t *externs;
84 :     ml_vproc_image_t image;
85 :     inbuf_t inBuf;
86 :    
87 :     /* Resolve the name of the image. If the file exists use it, otherwise try the
88 :     * pathname with the machine ID as an extension.
89 :     */
90 :     if ((inBuf.file = fopen(fname, "rb")) != NULL) {
91 :     if (! SilentLoad)
92 :     Say("loading %s ", fname);
93 :     }
94 :     else {
95 :     char buf[1024];
96 :    
97 :     if (QualifyImageName(strcpy(buf, fname))
98 :     && ((inBuf.file = fopen(buf, "rb")) != NULL)) {
99 :     if (! SilentLoad)
100 :     Say("loading %s ", buf);
101 :     }
102 :     else
103 :     Die ("unable to open heap image \"%s\"\n", fname);
104 :     }
105 :    
106 :    
107 :     inBuf.needsSwap = FALSE;
108 :     inBuf.buf = NIL(Byte_t *);
109 :     inBuf.nbytes = 0;
110 :    
111 :     #ifdef HACKED_STANDALONE
112 :     /* note that the seek may (will) succeed even if there's nothing there */
113 :     /* for now, we'll be content to just fail on the reads below */
114 :     if (StandAlone) {
115 :     if ((fseek (inBuf.file, -sizeof(long), SEEK_END) != 0)
116 :     || (fread(&heapStart, sizeof(long), 1, inBuf.file) != 1)
117 :     || (fseek (inBuf.file, heapStart, SEEK_SET) != 0)) {
118 :     Die ("unable to seek to internal image in stand-alone at %x\n",
119 :     heapStart);
120 :     }
121 :     }
122 :     #endif
123 :    
124 :     READ(&inBuf, imHdr);
125 :     if (imHdr.byteOrder != ORDER)
126 :     Die ("incorrect byte order in heap image\n");
127 :     if (imHdr.magic != IMAGE_MAGIC)
128 :     Die ("bad magic number (%#x) in heap image\n", imHdr.magic);
129 :     if ((imHdr.kind != EXPORT_HEAP_IMAGE) && (imHdr.kind != EXPORT_FN_IMAGE))
130 :     Die ("bad image kind (%d) in heap image\n", imHdr.kind);
131 :     READ(&inBuf, heapHdr);
132 :    
133 :     /* check for command-line overrides of heap parameters. */
134 :     if (params->allocSz == 0) params->allocSz = heapHdr.allocSzB;
135 :     if (params->numGens < heapHdr.numGens) params->numGens = heapHdr.numGens;
136 :     if (params->cacheGen < 0) params->cacheGen = heapHdr.cacheGen;
137 :    
138 :     msp = AllocMLState (FALSE, params);
139 :    
140 :     /* get the run-time pointers into the heap */
141 :     *PTR_MLtoC(ml_val_t, PervStruct) = heapHdr.pervStruct;
142 :     RunTimeCompUnit = heapHdr.runTimeCompUnit;
143 :     #ifdef ASM_MATH
144 :     MathVec = heapHdr.mathVec;
145 :     #endif
146 :    
147 :     /* read the externals table */
148 :     externs = HeapIO_ReadExterns (&inBuf);
149 :    
150 :     /* read and initialize the ML state info */
151 :     READ(&inBuf, image);
152 :     if (imHdr.kind == EXPORT_HEAP_IMAGE) {
153 :     /* Load the live registers */
154 :     ASSIGN(MLSignalHandler, image.sigHandler);
155 :     msp->ml_liveRegMask = RET_MASK;
156 :     msp->ml_arg = image.stdArg;
157 :     msp->ml_closure = image.stdClos;
158 :     msp->ml_cont = image.stdCont;
159 :     msp->ml_exnCont = image.exnCont;
160 :     msp->ml_pc = image.pc;
161 :     #if (CALLEESAVE > 0)
162 :     for (i = 0; i < CALLEESAVE; i++)
163 :     msp->ml_calleeSave(i) = image.calleeSaves[i];
164 :     #endif
165 :     #if (FLOAT_CALLEESAVE > 0)
166 :     /** LOAD FLOAT CALLEE SAVES **/
167 :     #endif
168 :     /* read the ML heap */
169 :     ReadHeap (&inBuf, &heapHdr, msp, externs);
170 : monnier 8 /* GC message are on by default for interactive images */
171 : monnier 48 /* GCMessages = TRUE; */
172 : monnier 2 }
173 :     else { /* EXPORT_FN_IMAGE */
174 :     ml_val_t funct, cmdName, args;
175 :     /* restore the signal handler */
176 :     ASSIGN(MLSignalHandler, image.sigHandler);
177 :     /* read the ML heap */
178 :     msp->ml_arg = image.stdArg;
179 :     ReadHeap (&inBuf, &heapHdr, msp, externs);
180 :     /* initialize the calling context (taken from ApplyMLFn) */
181 :     funct = msp->ml_arg;
182 :     msp->ml_exnCont = PTR_CtoML(handle_v+1);
183 :     msp->ml_varReg = ML_unit;
184 :     msp->ml_cont = PTR_CtoML(return_c);
185 :     msp->ml_closure = funct;
186 :     msp->ml_pc =
187 :     msp->ml_linkReg = GET_CODE_ADDR(funct);
188 :     /* setup the arguments to the imported function */
189 :     cmdName = ML_CString(msp, MLCmdName);
190 :     args = ML_CStringList (msp, CmdLineArgs);
191 :     REC_ALLOC2(msp, msp->ml_arg, cmdName, args);
192 :     /*
193 :     SayDebug("arg = %#x : [%#x, %#x]\n", msp->ml_arg, REC_SEL(msp->ml_arg, 0), REC_SEL(msp->ml_arg, 1));
194 :     */
195 : monnier 8 /* GC message are off by default for exportFn images */
196 :     GCMessages = FALSE;
197 : monnier 2 }
198 :    
199 :     FREE (externs);
200 :     fclose (inBuf.file);
201 :    
202 :     if (! SilentLoad)
203 :     Say(" done\n");
204 :    
205 :     return msp;
206 :    
207 :     } /* end of ImportHeapImage */
208 :    
209 :     /* ReadHeap:
210 :     */
211 :     PVT void ReadHeap (inbuf_t *bp, ml_heap_hdr_t *hdr, ml_state_t *msp, ml_val_t *externs)
212 :     {
213 :     heap_t *heap = msp->ml_heap;
214 :     heap_arena_hdr_t *arenaHdrs, *p, *q;
215 :     int arenaHdrsSize;
216 :     int i, j, k;
217 :     long prevSzB[NUM_ARENAS], sz;
218 :     bibop_t oldBIBOP;
219 :     Addr_t addrOffset[MAX_NUM_GENS][NUM_ARENAS];
220 :     bo_region_reloc_t *boRelocInfo;
221 :     addr_tbl_t *boRegionTbl;
222 :    
223 :     /* Allocate a BIBOP for the imported heap image's address space. */
224 :     #ifdef TWO_LEVEL_MAP
225 :     # error two level map not supported
226 :     #else
227 :     oldBIBOP = NEW_VEC (aid_t, BIBOP_SZ);
228 :     #endif
229 :    
230 :     /* read in the big-object region descriptors for the old address space */
231 :     {
232 :     int sz;
233 :     bo_region_info_t *boRgnHdr;
234 :     bigobj_region_t *rp;
235 :    
236 :     boRegionTbl = MakeAddrTbl(BIBOP_SHIFT+1, hdr->numBORegions);
237 :     sz = hdr->numBORegions * sizeof(bo_region_info_t);
238 :     boRgnHdr = (bo_region_info_t *) MALLOC (sz);
239 :     HeapIO_ReadBlock (bp, boRgnHdr, sz);
240 :    
241 :     boRelocInfo = NEW_VEC(bo_region_reloc_t, hdr->numBORegions);
242 :     for (i = 0; i < hdr->numBORegions; i++) {
243 :     MarkRegion(oldBIBOP,
244 :     (ml_val_t *)(boRgnHdr[i].baseAddr),
245 :     RND_MEMOBJ_SZB(boRgnHdr[i].sizeB),
246 :     AID_BIGOBJ(1));
247 :     oldBIBOP[BIBOP_ADDR_TO_INDEX(boRgnHdr[i].baseAddr)] = AID_BIGOBJ_HDR(MAX_NUM_GENS);
248 :     boRelocInfo[i].firstPage = boRgnHdr[i].firstPage;
249 :     boRelocInfo[i].nPages =
250 :     (boRgnHdr[i].sizeB - (boRgnHdr[i].firstPage - boRgnHdr[i].baseAddr))
251 :     >> BIGOBJ_PAGE_SHIFT;
252 :     boRelocInfo[i].objMap = NEW_VEC(bo_reloc_t *, boRelocInfo[i].nPages);
253 :     for (j = 0; j < boRelocInfo[i].nPages; j++)
254 :     boRelocInfo[i].objMap[j] = NIL(bo_reloc_t *);
255 :     AddrTblInsert (boRegionTbl, boRgnHdr[i].baseAddr, &(boRelocInfo[i]));
256 :     }
257 :     FREE (boRgnHdr);
258 :     }
259 :    
260 :     /* read the arena headers. */
261 :     arenaHdrsSize = hdr->numGens * NUM_OBJ_KINDS * sizeof(heap_arena_hdr_t);
262 :     arenaHdrs = (heap_arena_hdr_t *) MALLOC (arenaHdrsSize);
263 :     HeapIO_ReadBlock (bp, arenaHdrs, arenaHdrsSize);
264 :    
265 :     for (i = 0; i < NUM_ARENAS; i++)
266 :     prevSzB[i] = heap->allocSzB;
267 :    
268 :     /* allocate the arenas and read in the heap image. */
269 :     for (p = arenaHdrs, i = 0; i < hdr->numGens; i++) {
270 :     gen_t *gen = heap->gen[i];
271 :    
272 :     /* compute the space required for this generation, and mark the oldBIBOP
273 :     * to reflect the old address space.
274 :     */
275 :     for (q = p, j = 0; j < NUM_ARENAS; j++) {
276 :     MarkRegion (oldBIBOP,
277 :     (ml_val_t *)(q->info.o.baseAddr),
278 :     RND_MEMOBJ_SZB(q->info.o.sizeB),
279 :     gen->arena[j]->id);
280 :     sz = q->info.o.sizeB + prevSzB[j];
281 :     if ((j == PAIR_INDX) && (sz > 0))
282 :     sz += 2*WORD_SZB;
283 :     gen->arena[j]->tospSizeB = RND_MEMOBJ_SZB(sz);
284 :     prevSzB[j] = q->info.o.sizeB;
285 :     q++;
286 :     }
287 :    
288 :     /* Allocate space for the generation */
289 :     if (NewGeneration(gen) == FAILURE)
290 :     Die ("unable to allocated space for generation %d\n", i+1);
291 :     if (isACTIVE(gen->arena[ARRAY_INDX]))
292 :     NewDirtyVector (gen);
293 :    
294 :     /* read in the arenas for this generation and initialize the
295 :     * address offset table.
296 :     */
297 :     for (j = 0; j < NUM_ARENAS; j++) {
298 :     arena_t *ap = gen->arena[j];
299 :     long offset;
300 :    
301 :     if (p->info.o.sizeB > 0) {
302 :     addrOffset[i][j] = (Addr_t)(ap->tospBase) - (Addr_t)(p->info.o.baseAddr);
303 :     #ifdef HACKED_STANDALONE
304 :     /* assuming here that ReadHeap is only called from ImportHeapImage
305 :     * and that ImportHeapImage is only called from LoadML on startup.
306 :     * Otherwise, StandAlone needs to be set to FALSE after the intial
307 :     * load; or need extra offset param here, etc.
308 :     */
309 :     offset = (long)(p->offset) + (StandAlone ? heapStart : 0);
310 :     #else
311 :     offset = (long)(p->offset);
312 :     #endif
313 :     if (fseek (bp->file, offset, SEEK_SET) != 0)
314 :     Die("unable to seek on heap image\n");
315 :     HeapIO_ReadBlock(bp, (ap->tospBase), p->info.o.sizeB);
316 :     ap->nextw = (ml_val_t *)((Addr_t)(ap->tospBase) + p->info.o.sizeB);
317 :     ap->oldTop = ap->tospBase;
318 :     }
319 :     else if (isACTIVE(ap)) {
320 :     ap->oldTop = ap->tospBase;
321 :     }
322 :     if (! SilentLoad) {
323 :     Say(".");
324 :     }
325 :     p++;
326 :     }
327 :     /* read in the big-object arenas */
328 :     for (j = 0; j < NUM_BIGOBJ_KINDS; j++) {
329 :     Addr_t totSizeB;
330 :     bigobj_desc_t *freeObj, *bdp;
331 :     bigobj_region_t *freeRegion;
332 :     bigobj_hdr_t *boHdrs;
333 :     int boHdrSizeB, indx;
334 :     bo_region_reloc_t *region;
335 :    
336 :     if (p->info.bo.numBOPages > 0) {
337 :     totSizeB = p->info.bo.numBOPages << BIGOBJ_PAGE_SHIFT;
338 :     freeObj = BO_AllocRegion (heap, totSizeB);
339 :     freeRegion = freeObj->region;
340 :     freeRegion->minGen = i;
341 :     MarkRegion (BIBOP, (ml_val_t *)freeRegion,
342 :     MEMOBJ_SZB(freeRegion->memObj), AID_BIGOBJ(i));
343 :     BIBOP[BIBOP_ADDR_TO_INDEX(freeRegion)] = AID_BIGOBJ_HDR(i);
344 :    
345 :     /* read in the big-object headers */
346 :     boHdrSizeB = p->info.bo.numBigObjs * sizeof(bigobj_hdr_t);
347 :     boHdrs = (bigobj_hdr_t *) MALLOC (boHdrSizeB);
348 :     HeapIO_ReadBlock (bp, boHdrs, boHdrSizeB);
349 :    
350 :     /* read in the big-objects */
351 :     HeapIO_ReadBlock (bp, (void *)(freeObj->obj), totSizeB);
352 :     if (j == CODE_INDX) {
353 :     FlushICache ((void *)(freeObj->obj), totSizeB);
354 :     }
355 :    
356 :     /* setup the big-object descriptors and per-object relocation info */
357 :     for (k = 0; k < p->info.bo.numBigObjs; k++) {
358 :     /* find the region relocation info for the object's region in
359 :     * the exported heap.
360 :     */
361 :     for (indx = BIBOP_ADDR_TO_INDEX(boHdrs[k].baseAddr);
362 :     !BO_IS_HDR(oldBIBOP[indx]);
363 :     indx--)
364 :     continue;
365 :     region = LookupBORegion (boRegionTbl, indx);
366 :     /* allocate the big-object descriptor for the object, and
367 :     * link it into the list of big-objects for its generation.
368 :     */
369 :     bdp = AllocBODesc (freeObj, &(boHdrs[k]), region);
370 :     bdp->next = gen->bigObjs[j];
371 :     gen->bigObjs[j] = bdp;
372 :     ASSERT(bdp->gen == i+1);
373 :    
374 :     if (DumpObjectStrings && (j == CODE_INDX)) {
375 :     /* dump the comment string of the code object */
376 :     char buf[256];
377 : monnier 8 if (BO_GetCodeObjTag(bdp, buf, sizeof(buf)) != NIL(char *))
378 :     SayDebug ("[%6d bytes] %s\n", bdp->sizeB, buf);
379 : monnier 2 }
380 :     }
381 :    
382 :     if (freeObj != bdp) {
383 :     /* there was some extra space left in the region */
384 :     ADD_BODESC(heap->freeBigObjs, freeObj);
385 :     }
386 :    
387 :     FREE (boHdrs);
388 :     }
389 :     if (! SilentLoad) {
390 :     Say(".");
391 :     }
392 :     p++;
393 :     }
394 :     }
395 :    
396 :     RepairHeap (heap, oldBIBOP, addrOffset, boRegionTbl, externs);
397 :    
398 :     /* Adjust the run-time globals that point into the heap */
399 :     *PTR_MLtoC(ml_val_t, PervStruct) = RepairWord (
400 :     *PTR_MLtoC(ml_val_t, PervStruct),
401 :     oldBIBOP, addrOffset, boRegionTbl, externs);
402 :     RunTimeCompUnit = RepairWord (
403 :     RunTimeCompUnit, oldBIBOP, addrOffset, boRegionTbl, externs);
404 :     #ifdef ASM_MATH
405 :     MathVec = RepairWord (MathVec, oldBIBOP, addrOffset, boRegionTbl, externs);
406 :     #endif
407 :    
408 :     /* Adjust the ML registers to the new address space */
409 :     ASSIGN(MLSignalHandler, RepairWord (
410 :     DEREF(MLSignalHandler), oldBIBOP, addrOffset, boRegionTbl, externs));
411 :     for (i = 0; i < NROOTS; i++) {
412 :     msp->ml_roots[i] = RepairWord (
413 :     msp->ml_roots[i], oldBIBOP, addrOffset, boRegionTbl, externs);
414 :     }
415 :    
416 :     /* release storage */
417 :     for (i = 0; i < hdr->numBORegions; i++) {
418 :     bo_reloc_t *p;
419 :     for (p = NIL(bo_reloc_t *), j = 0; j < boRelocInfo[i].nPages; j++) {
420 :     if ((boRelocInfo[i].objMap[j] != NIL(bo_reloc_t *))
421 :     && (boRelocInfo[i].objMap[j] != p)) {
422 :     FREE (boRelocInfo[i].objMap[j]);
423 :     p = boRelocInfo[i].objMap[j];
424 :     }
425 :     }
426 :     }
427 :     FreeAddrTbl (boRegionTbl, FALSE);
428 :     FREE (boRelocInfo);
429 :     FREE (arenaHdrs);
430 :     FREE (oldBIBOP);
431 :    
432 :     /* reset the sweep_nextw pointers */
433 :     for (i = 0; i < heap->numGens; i++) {
434 :     gen_t *gen = heap->gen[i];
435 :     for (j = 0; j < NUM_ARENAS; j++) {
436 :     arena_t *ap = gen->arena[j];
437 :     if (isACTIVE(ap))
438 :     ap->sweep_nextw = ap->nextw;
439 :     }
440 :     }
441 :    
442 :     } /* end of ReadHeap. */
443 :    
444 :     /* AllocBODesc:
445 :     *
446 :     */
447 :     PVT bigobj_desc_t *AllocBODesc (
448 :     bigobj_desc_t *free,
449 :     bigobj_hdr_t *objHdr,
450 :     bo_region_reloc_t *oldRegion)
451 :     {
452 :     bigobj_region_t *region;
453 :     bigobj_desc_t *newObj;
454 :     bo_reloc_t *relocInfo;
455 :     int i, totSzB, firstPage, npages;
456 :    
457 :     totSzB = ROUNDUP(objHdr->sizeB, BIGOBJ_PAGE_SZB);
458 :     npages = (totSzB >> BIGOBJ_PAGE_SHIFT);
459 :     region = free->region;
460 :     if (free->sizeB == totSzB)
461 :     /* allocate the whole free area to the object */
462 :     newObj = free;
463 :     else {
464 :     /* split the free object */
465 :     newObj = NEW_OBJ(bigobj_desc_t);
466 :     newObj->obj = free->obj;
467 :     newObj->region = region;
468 :     free->obj = (Addr_t)(free->obj) + totSzB;
469 :     free->sizeB -= totSzB;
470 :     firstPage = ADDR_TO_BOPAGE(region, newObj->obj);
471 :     for (i = 0; i < npages; i++)
472 :     region->objMap[firstPage+i] = newObj;
473 :     }
474 :    
475 :     newObj->sizeB = objHdr->sizeB;
476 :     newObj->state = BO_YOUNG;
477 :     newObj->gen = objHdr->gen;
478 :     newObj->objc = objHdr->objKind;
479 :     region->nFree -= npages;
480 :    
481 :     /* setup the relocation info */
482 :     relocInfo = NEW_OBJ(bo_reloc_t);
483 :     relocInfo->oldAddr = objHdr->baseAddr;
484 :     relocInfo->newObj = newObj;
485 :     firstPage = ADDR_TO_BOPAGE(oldRegion, objHdr->baseAddr);
486 :     for (i = 0; i < npages; i++)
487 :     oldRegion->objMap[firstPage+i] = relocInfo;
488 :    
489 :     return newObj;
490 :    
491 :     } /* end of AllocBODesc */
492 :    
493 :     /* RepairHeap:
494 :     *
495 :     * Scan the heap, replacing external references with their addresses and
496 :     * adjusting pointers.
497 :     */
498 :     PVT void RepairHeap (
499 :     heap_t *heap,
500 :     aid_t *oldBIBOP,
501 :     Addr_t addrOffset[MAX_NUM_GENS][NUM_ARENAS],
502 :     addr_tbl_t *boRegionTbl,
503 :     ml_val_t *externs)
504 :     {
505 :     int i;
506 :    
507 :     for (i = 0; i < heap->numGens; i++) {
508 :     gen_t *gen = heap->gen[i];
509 :     #ifndef BIT_CARDS
510 :     #define MARK(cm, p, g) MARK_CARD(cm, p, g)
511 :     #else
512 :     #define MARK(cm, p, g) MARK_CARD(cm, p)
513 :     #endif
514 :     #define RepairArena(indx) { \
515 :     arena_t *__ap = gen->arena[(indx)]; \
516 :     ml_val_t *__p, *__q; \
517 :     __p = __ap->tospBase; \
518 :     __q = __ap->nextw; \
519 :     while (__p < __q) { \
520 :     ml_val_t __w = *__p; \
521 :     int __gg, __objc; \
522 :     if (isBOXED(__w)) { \
523 :     Addr_t __obj = PTR_MLtoADDR(__w); \
524 :     aid_t __aid = ADDR_TO_PAGEID(oldBIBOP, __obj); \
525 :     if (IS_BIGOBJ_AID(__aid)) { \
526 :     bo_reloc_t *__dp; \
527 :     __dp = AddrToRelocInfo (oldBIBOP, boRegionTbl, \
528 :     __aid, __obj); \
529 :     *__p = PTR_CtoML((__obj - __dp->oldAddr) \
530 :     + __dp->newObj->obj); \
531 : monnier 8 __gg = __dp->newObj->gen-1; \
532 : monnier 2 } \
533 :     else { \
534 :     __gg = EXTRACT_GEN(__aid)-1; \
535 :     __objc = EXTRACT_OBJC(__aid)-1; \
536 :     *__p = PTR_CtoML(__obj + addrOffset[__gg][__objc]); \
537 :     } \
538 :     if (((indx) == ARRAY_INDX) && (__gg < i)) { \
539 :     MARK(gen->dirty, __p, __gg+1); /** **/ \
540 :     } \
541 :     } \
542 :     else if (isEXTERNTAG(__w)) { \
543 :     *__p = externs[EXTERNID(__w)]; \
544 :     } \
545 :     __p++; \
546 :     } \
547 :     } /* RepairArena */
548 :    
549 :     RepairArena(RECORD_INDX);
550 :     RepairArena(PAIR_INDX);
551 :     RepairArena(ARRAY_INDX);
552 :     }
553 :    
554 :     } /* end of RepairHeap */
555 :    
556 :     /* RepairWord:
557 :     */
558 :     PVT ml_val_t RepairWord (
559 :     ml_val_t w,
560 :     aid_t *oldBIBOP,
561 :     Addr_t addrOffset[MAX_NUM_GENS][NUM_ARENAS],
562 :     addr_tbl_t *boRegionTbl,
563 :     ml_val_t *externs)
564 :     {
565 :     if (isBOXED(w)) {
566 :     Addr_t obj = PTR_MLtoADDR(w);
567 :     aid_t aid = ADDR_TO_PAGEID(oldBIBOP, obj);
568 :     if (IS_BIGOBJ_AID(aid)) {
569 :     bo_reloc_t *dp;
570 :     dp = AddrToRelocInfo (oldBIBOP, boRegionTbl, aid, obj);
571 :     return PTR_CtoML((obj - dp->oldAddr) + dp->newObj->obj);
572 :     }
573 :     else {
574 :     int g = EXTRACT_GEN(aid)-1;
575 :     int objc = EXTRACT_OBJC(aid)-1;
576 :     return PTR_CtoML(PTR_MLtoC(char, w) + addrOffset[g][objc]);
577 :     }
578 :     }
579 :     else if (isEXTERNTAG(w)) {
580 :     return externs[EXTERNID(w)];
581 :     }
582 :     else
583 :     return w;
584 :    
585 :     } /* end of RepairWord */
586 :    
587 :    
588 :     /* AddrToRelocInfo:
589 :     */
590 :     PVT bo_reloc_t *AddrToRelocInfo (
591 :     aid_t *oldBIBOP,
592 :     addr_tbl_t *boRegionTbl,
593 :     aid_t id,
594 :     Addr_t oldObj)
595 :     {
596 :     int indx;
597 :     bo_region_reloc_t *region;
598 :    
599 :     for (indx = BIBOP_ADDR_TO_INDEX(oldObj); !BO_IS_HDR(id); id = oldBIBOP[--indx])
600 :     continue;
601 :    
602 :     /* find the old region descriptor */
603 :     region = LookupBORegion (boRegionTbl, indx);
604 :    
605 :     if (region == NIL(bo_region_reloc_t *))
606 :     Die ("unable to map big-object @ %#x; index = %#x, id = %#x\n",
607 :     oldObj, indx, (unsigned)id);
608 :    
609 :     return ADDR_TO_BODESC(region, oldObj);
610 :    
611 :     } /* end of AddrToRelocInfo */

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0