1 #include "checkpoint.h"
3 #include "structdefs.h"
9 extern void * curr_heapbase;
10 extern void * curr_heapptr;
11 extern void * curr_heapgcpoint;
12 extern void * curr_heaptop;
14 extern void * to_heapbase;
15 extern void * to_heapptr;
16 extern void * to_heaptop;
19 #define MALLOCSIZE 20*1024
22 struct malloclist *next;
31 struct malloclist * top=NULL;
34 void * cpmalloc(int size) {
35 int endoffset=offset+size;
37 if (top==NULL||endoffset>top->size) {
38 int basesize=MALLOCSIZE;
39 struct malloclist *tmp;
42 tmp=RUNMALLOC(sizeof(struct malloclist)+basesize);
50 return &top->space[tmpoffset];
55 struct malloclist *next=top->next;
61 void checkvalid(void * ptr) {
62 if (ptr>=curr_heapbase&&ptr<=curr_heaptop) {
70 void validitycheck(struct ctable *forward, struct ctable *reverse) {
71 struct RuntimeIterator rit;
72 RuntimeHashiterator(forward, &rit);
73 while(RunhasNext(&rit)) {
74 struct ___Object___ * data=(struct ___Object___*) Runnext(&rit);
76 unsigned int * pointer=pointerarray[type];
79 if (pointer!=0&&((int)pointer)!=1) {
81 for(i=1; i<=size; i++) {
82 int offset=pointer[i];
83 void * ptr=*(void **)(((int) data) + offset);
84 if (ptr!=NULL&&!RuntimeHashcontainskey(reverse, (int) ptr)) {
94 RuntimeHashiterator(reverse, &rit);
95 while(RunhasNext(&rit)) {
96 struct ___Object___ * data=(struct ___Object___*) Runkey(&rit);
98 unsigned int * pointer=NULL;
103 pointer=pointerarray[type];
104 if (pointer!=0&&((int)pointer)!=1) {
106 for(i=1; i<=size; i++) {
107 int offset=pointer[i];
108 void * ptr=*(void **)(((int) data) + offset);
109 if (ptr!=NULL&&!RuntimeHashcontainskey(reverse, (int) ptr)) {
122 void ** makecheckpoint(int numparams, void ** srcpointer, struct ctable * forward, struct ctable * reverse) {
124 void **newarray=cpmalloc(sizeof(void *)*numparams);
126 void **newarray=RUNMALLOC(sizeof(void *)*numparams);
128 struct Queue *todo=createQueue();
131 for(i=0; i<numparams; i++) {
132 void * objptr=srcpointer[i];
134 if ((dst=cSearch(forward, objptr))!=NULL)
137 void * copy=createcopy(objptr);
138 cInsert(forward, objptr, copy);
139 cInsert(reverse, copy, objptr);
140 addNewItem(todo, objptr);
144 while(!isEmpty(todo)) {
145 void * ptr=getItem(todo);
146 int type=((int *)ptr)[0];
149 unsigned int * pointer=NULL;
150 cpy=cSearch(forward, ptr);
152 pointer=pointerarray[type];
155 void *objptr=((struct ___TagDescriptor___*)ptr)->flagptr;
158 if ((dst=cSearch(forward, objptr))==NULL) {
159 void *copy=createcopy(objptr);
160 cInsert(forward, objptr, copy);
161 cInsert(reverse, copy, objptr);
162 addNewItem(todo, objptr);
163 ((struct ___TagDescriptor___*)cpy)->flagptr=copy;
165 ((struct ___TagDescriptor___*) cpy)->flagptr=dst;
171 /* Array of primitives */
173 } else if (((int)pointer)==1) {
174 /* Array of pointers */
175 struct ArrayObject *ao=(struct ArrayObject *) ptr;
176 struct ArrayObject *ao_cpy=(struct ArrayObject *) cpy;
177 int length=ao->___length___;
179 for(i=0; i<length; i++) {
181 void *objptr=((void **)(((char *)&ao->___length___)+sizeof(int)))[i];
183 ((void **)(((char *)&ao_cpy->___length___)+sizeof(int)))[i]=NULL;
184 } else if ((dst=cSearch(forward,objptr))!=NULL)
185 ((void **)(((char *)&ao_cpy->___length___)+sizeof(int)))[i]=dst;
187 void * copy=createcopy(objptr);
188 cInsert(forward, objptr, copy);
189 cInsert(reverse, copy, objptr);
190 addNewItem(todo, objptr);
191 ((void **)(((char *)&ao_cpy->___length___)+sizeof(int)))[i]=copy;
197 for(i=1; i<=size; i++) {
198 int offset=pointer[i];
199 void * objptr=*((void **)(((int)ptr)+offset));
202 *((void **)(((int)cpy)+offset))=NULL;
203 } else if ((dst=cSearch(forward, objptr))!=NULL)
204 *((void **) &(((char *)cpy)[offset]))=dst;
206 void * copy=createcopy(objptr);
207 cInsert(forward, objptr, copy);
208 cInsert(reverse, copy, objptr);
209 addNewItem(todo, objptr);
210 *((void **)(((int)cpy)+offset))=copy;
220 void * createcopy(void * orig) {
224 int type=((int *)orig)[0];
225 if (type<NUMCLASSES) {
226 /* We have a normal object */
227 int size=classsize[type];
229 void *newobj=cpmalloc(size);
231 void *newobj=RUNMALLOC(size);
233 memcpy(newobj, orig, size);
236 /* We have an array */
237 struct ArrayObject *ao=(struct ArrayObject *)orig;
238 int elementsize=classsize[type];
239 int length=ao->___length___;
240 int size=sizeof(struct ArrayObject)+length*elementsize;
242 void *newobj=cpmalloc(size);
244 void *newobj=RUNMALLOC(size);
246 memcpy(newobj, orig, size);
252 void restorecheckpoint(int numparams, void ** original, void ** checkpoint, struct ctable *forward, struct ctable * reverse) {
253 struct Queue *todo=createQueue();
254 struct ctable *visited=cCreate(256, 0.5);
257 for(i=0; i<numparams; i++) {
258 if (checkpoint[i]!=NULL) {
259 addNewItem(todo, checkpoint[i]);
260 cInsert(visited, checkpoint[i], checkpoint[i]);
264 while(!isEmpty(todo)) {
265 void * ptr=(void *) getItem(todo);
266 int type=((int *)ptr)[0];
270 unsigned int *pointer;
272 cpy=cSearch(reverse, ptr);
273 pointer=pointerarray[type];
274 size=classsize[type];
277 void *objptr=((struct ___TagDescriptor___*)ptr)->flagptr;
278 memcpy(cpy, ptr, size);
280 if (cSearch(visited, objptr)==NULL) {
281 cInsert(visited, objptr, objptr);
282 addNewItem(todo, objptr);
284 *((void **) &(((struct ___TagDescriptor___ *)cpy)->flagptr))=cSearch(reverse, objptr);
289 /* Array of primitives */
290 struct ArrayObject *ao=(struct ArrayObject *) ptr;
291 int length=ao->___length___;
292 int cpysize=sizeof(struct ArrayObject)+length*size;
293 memcpy(cpy, ptr, cpysize);
294 } else if ((int)pointer==1) {
295 /* Array of pointers */
296 struct ArrayObject *ao=(struct ArrayObject *) ptr;
297 struct ArrayObject *ao_cpy=(struct ArrayObject *) cpy;
298 int length=ao->___length___;
300 int cpysize=sizeof(struct ArrayObject)+length*size;
301 memcpy(ao_cpy, ao, cpysize);
303 for(i=0; i<length; i++) {
304 void *objptr=((void **)(((char *)&ao->___length___)+sizeof(int)))[i];
306 ((void **)(((char *)&ao_cpy->___length___)+sizeof(int)))[i]=NULL;
308 if (cSearch(visited, objptr)==NULL) {
309 cInsert(visited, objptr, objptr);
310 addNewItem(todo, objptr);
312 *((void **) &((void **)(((char *)&ao_cpy->___length___)+sizeof(int)))[i])=cSearch(reverse, objptr);
316 int numptr=pointer[0];
321 if (hasflags[type]) {
322 flagptr=(void *)(((int *)cpy)[2]);
323 oldflag=(((int *)cpy)[1]);
324 currflag=(((int *)ptr)[1]);
326 memcpy(cpy, ptr, size);
327 for(i=1; i<=numptr; i++) {
328 int offset=pointer[i];
329 void * objptr=*((void **)(((int)ptr)+offset));
331 *((void **)(((int)cpy)+offset))=NULL;
333 if (cSearch(visited, objptr)==NULL) {
334 cInsert(visited, objptr, objptr);
335 addNewItem(todo, objptr);
337 *((void **) &(((char *)cpy)[offset]))=cSearch(reverse, objptr);
340 if (hasflags[type]) {
341 (((void **)cpy)[2])=flagptr;
342 if (currflag!=oldflag) {
343 flagorandinit(cpy, 0, 0xFFFFFFFF);
345 enqueueObject(cpy, NULL,0); //TODO