1 #include "checkpoint.h"
3 #include "structdefs.h"
8 extern void * curr_heapbase;
9 extern void * curr_heapptr;
10 extern void * curr_heapgcpoint;
11 extern void * curr_heaptop;
13 extern void * to_heapbase;
14 extern void * to_heapptr;
15 extern void * to_heaptop;
18 #define MALLOCSIZE 20*1024
21 struct malloclist *next;
30 struct malloclist * top=NULL;
33 void * cpmalloc(int size) {
34 int endoffset=offset+size;
36 if (top==NULL||endoffset>top->size) {
37 int basesize=MALLOCSIZE;
38 struct malloclist *tmp;
41 tmp=RUNMALLOC(sizeof(struct malloclist)+basesize);
49 return &top->space[tmpoffset];
54 struct malloclist *next=top->next;
60 void checkvalid(void * ptr) {
61 if (ptr>=curr_heapbase&&ptr<=curr_heaptop) {
68 void validitycheck(struct RuntimeHash *forward, struct RuntimeHash *reverse) {
69 struct RuntimeIterator rit;
70 RuntimeHashiterator(forward, &rit);
71 while(RunhasNext(&rit)) {
72 struct ___Object___ * data=(struct ___Object___*) Runnext(&rit);
74 unsigned int * pointer=pointerarray[type];
77 if (pointer!=0&&((int)pointer)!=1) {
79 for(i=1;i<=size;i++) {
80 int offset=pointer[i];
81 void * ptr=*(void **) (((int) data) + offset);
82 if (ptr!=NULL&&!RuntimeHashcontainskey(reverse, (int) ptr)) {
92 RuntimeHashiterator(reverse, &rit);
93 while(RunhasNext(&rit)) {
94 struct ___Object___ * data=(struct ___Object___*) Runkey(&rit);
96 unsigned int * pointer=NULL;
101 pointer=pointerarray[type];
102 if (pointer!=0&&((int)pointer)!=1) {
104 for(i=1;i<=size;i++) {
105 int offset=pointer[i];
106 void * ptr=*(void **) (((int) data) + offset);
107 if (ptr!=NULL&&!RuntimeHashcontainskey(reverse, (int) ptr)) {
120 void ** makecheckpoint(int numparams, void ** srcpointer, struct RuntimeHash * forward, struct RuntimeHash * reverse) {
122 void **newarray=cpmalloc(sizeof(void *)*numparams);
124 void **newarray=RUNMALLOC(sizeof(void *)*numparams);
126 struct RuntimeHash *todo=allocateRuntimeHash(100);
129 for(i=0;i<numparams;i++) {
130 void * objptr=srcpointer[i];
131 if (RuntimeHashcontainskey(forward, (int) objptr))
132 RuntimeHashget(forward,(int) objptr,(int *) &newarray[i]);
134 void * copy=createcopy(objptr);
135 RuntimeHashadd(forward, (int) objptr, (int)copy);
136 RuntimeHashadd(reverse, (int) copy, (int) objptr);
137 RuntimeHashadd(todo, (int) objptr, (int) objptr);
141 while(RuntimeHashcountset(todo)!=0) {
142 void * ptr=(void *) RuntimeHashfirstkey(todo);
143 int type=((int *)ptr)[0];
144 RuntimeHashremove(todo, (int) ptr, (int) ptr);
147 unsigned int * pointer=NULL;
148 RuntimeHashget(forward, (int) ptr, (int *) &cpy);
150 pointer=pointerarray[type];
153 void *objptr=((struct ___TagDescriptor___*)ptr)->flagptr;
155 if (!RuntimeHashcontainskey(forward, (int) objptr)) {
156 void *copy=createcopy(objptr);
157 RuntimeHashadd(forward, (int) objptr, (int) copy);
158 RuntimeHashadd(reverse, (int) copy, (int) objptr);
159 RuntimeHashadd(todo, (int) objptr, (int) objptr);
160 ((struct ___TagDescriptor___*)cpy)->flagptr=copy;
162 RuntimeHashget(forward, (int) objptr, (int *) &(((struct ___TagDescriptor___*) cpy)->flagptr));
168 /* Array of primitives */
170 } else if (((int)pointer)==1) {
171 /* Array of pointers */
172 struct ArrayObject *ao=(struct ArrayObject *) ptr;
173 struct ArrayObject *ao_cpy=(struct ArrayObject *) cpy;
174 int length=ao->___length___;
176 for(i=0;i<length;i++) {
177 void *objptr=((void **)(((char *)& ao->___length___)+sizeof(int)))[i];
179 ((void **)(((char *)& ao_cpy->___length___)+sizeof(int)))[i]=NULL;
180 } else if (RuntimeHashcontainskey(forward, (int) objptr))
181 RuntimeHashget(forward,(int) objptr,(int *) &((void **)(((char *)& ao_cpy->___length___)+sizeof(int)))[i]);
183 void * copy=createcopy(objptr);
184 RuntimeHashadd(forward, (int) objptr, (int)copy);
185 RuntimeHashadd(reverse, (int) copy, (int) objptr);
186 RuntimeHashadd(todo, (int) objptr, (int) objptr);
187 ((void **)(((char *)& ao_cpy->___length___)+sizeof(int)))[i]=copy;
193 for(i=1;i<=size;i++) {
194 int offset=pointer[i];
195 void * objptr=*((void **)(((int)ptr)+offset));
197 *((void **) (((int)cpy)+offset))=NULL;
198 } else if (RuntimeHashcontainskey(forward, (int) objptr))
199 RuntimeHashget(forward, (int) objptr, (int *) &(((char *)cpy)[offset]));
201 void * copy=createcopy(objptr);
202 RuntimeHashadd(forward, (int) objptr, (int) copy);
203 RuntimeHashadd(reverse, (int) copy, (int) objptr);
204 RuntimeHashadd(todo, (int) objptr, (int) objptr);
205 *((void **) (((int)cpy)+offset))=copy;
211 freeRuntimeHash(todo);
215 void * createcopy(void * orig) {
219 int type=((int *)orig)[0];
220 if (type<NUMCLASSES) {
221 /* We have a normal object */
222 int size=classsize[type];
224 void *newobj=cpmalloc(size);
226 void *newobj=RUNMALLOC(size);
228 memcpy(newobj, orig, size);
231 /* We have an array */
232 struct ArrayObject *ao=(struct ArrayObject *)orig;
233 int elementsize=classsize[type];
234 int length=ao->___length___;
235 int size=sizeof(struct ArrayObject)+length*elementsize;
237 void *newobj=cpmalloc(size);
239 void *newobj=RUNMALLOC(size);
241 memcpy(newobj, orig, size);
247 void restorecheckpoint(int numparams, void ** original, void ** checkpoint, struct RuntimeHash *forward, struct RuntimeHash * reverse) {
248 struct RuntimeHash *todo=allocateRuntimeHash(100);
249 struct RuntimeHash *visited=allocateRuntimeHash(100);
252 for(i=0;i<numparams;i++) {
253 if (checkpoint[i]!=NULL) {
254 RuntimeHashadd(todo, (int) checkpoint[i], (int) checkpoint[i]);
255 RuntimeHashadd(visited, (int) checkpoint[i], (int) checkpoint[i]);
259 while(RuntimeHashcountset(todo)!=0) {
260 void * ptr=(void *) RuntimeHashfirstkey(todo);
261 int type=((int *)ptr)[0];
262 RuntimeHashremove(todo, (int) ptr, (int) ptr);
266 unsigned int *pointer;
268 RuntimeHashget(reverse, (int) ptr, (int *) &cpy);
269 pointer=pointerarray[type];
270 size=classsize[type];
273 void *objptr=((struct ___TagDescriptor___*)ptr)->flagptr;
274 memcpy(cpy, ptr, size);
276 if (!RuntimeHashcontainskey(visited, (int) objptr)) {
277 RuntimeHashadd(visited, (int) objptr, (int) objptr);
278 RuntimeHashadd(todo, (int) objptr, (int) objptr);
280 RuntimeHashget(reverse, (int) objptr, (int *) & (((struct ___TagDescriptor___ *)cpy)->flagptr));
285 /* Array of primitives */
286 struct ArrayObject *ao=(struct ArrayObject *) ptr;
287 int length=ao->___length___;
288 int cpysize=sizeof(struct ArrayObject)+length*size;
289 memcpy(cpy, ptr, cpysize);
290 } else if ((int)pointer==1) {
291 /* Array of pointers */
292 struct ArrayObject *ao=(struct ArrayObject *) ptr;
293 struct ArrayObject *ao_cpy=(struct ArrayObject *) cpy;
294 int length=ao->___length___;
296 int cpysize=sizeof(struct ArrayObject)+length*size;
297 memcpy(ao_cpy, ao, cpysize);
299 for(i=0;i<length;i++) {
300 void *objptr=((void **)(((char *)& ao->___length___)+sizeof(int)))[i];
302 ((void **)(((char *)& ao_cpy->___length___)+sizeof(int)))[i]=NULL;
304 if (!RuntimeHashcontainskey(visited, (int) objptr)) {
305 RuntimeHashadd(visited, (int) objptr, (int) objptr);
306 RuntimeHashadd(todo, (int) objptr, (int) objptr);
308 RuntimeHashget(reverse, (int) objptr, (int *) &((void **)(((char *)& ao_cpy->___length___)+sizeof(int)))[i]);
312 int numptr=pointer[0];
317 if (hasflags[type]) {
318 flagptr=(void *) (((int *)cpy)[2]);
319 oldflag=(((int *)cpy)[1]);
320 currflag=(((int *)ptr)[1]);
322 memcpy(cpy, ptr, size);
323 for(i=1;i<=numptr;i++) {
324 int offset=pointer[i];
325 void * objptr=*((void **)(((int)ptr)+offset));
327 *((void **) (((int)cpy)+offset))=NULL;
329 if (!RuntimeHashcontainskey(visited, (int) objptr)) {
330 RuntimeHashadd(visited, (int) objptr, (int) objptr);
331 RuntimeHashadd(todo, (int) objptr, (int) objptr);
333 RuntimeHashget(reverse, (int) objptr, (int *) &(((char *)cpy)[offset]));
336 if (hasflags[type]) {
337 (((void **)cpy)[2])=flagptr;
338 if (currflag!=oldflag) {
339 flagorandinit(cpy, 0, 0xFFFFFFFF);
341 enqueueObject(cpy, NULL,0); //TODO
350 freeRuntimeHash(todo);
351 freeRuntimeHash(visited);