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

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