From baab09fc1b3cb37b31c13920db230b28e7bde4f0 Mon Sep 17 00:00:00 2001 From: Matthew Flatt Date: Mon, 29 Mar 2010 15:06:47 +0000 Subject: [PATCH] drop the uglier half of the Mac OS X thread-local variable hack; thread GC state through mark functions (to avoid overhead of thread-local accesses); fix some procedure-arity bugs and work toward fixing chaperones and some other procedure operations on keyword procedures svn: r18661 --- collects/scheme/private/kw.ss | 88 +- collects/scheme/private/pre-base.ss | 7 +- collects/tests/mzscheme/chaperone.ss | 6 + collects/tests/mzscheme/procs.ss | 11 +- doc/release-notes/mzscheme/HISTORY.txt | 1 + src/mzscheme/gc2/Makefile.in | 2 +- src/mzscheme/gc2/gc2.h | 25 + src/mzscheme/gc2/mem_account.c | 30 +- src/mzscheme/gc2/newgc.c | 148 +- src/mzscheme/gc2/newgc.h | 4 +- src/mzscheme/gc2/var_stack.c | 10 +- src/mzscheme/gc2/weak.c | 48 +- src/mzscheme/include/schthread.h | 4 +- src/mzscheme/src/fun.c | 24 +- src/mzscheme/src/jit.c | 15 +- src/mzscheme/src/mkmark.ss | 10 +- src/mzscheme/src/mzmark.c | 3562 ++++++++++++------------ src/mzscheme/src/mzmarksrc.c | 1302 ++++----- src/mzscheme/src/salloc.c | 50 +- src/mzscheme/src/type.c | 60 +- 20 files changed, 2761 insertions(+), 2646 deletions(-) diff --git a/collects/scheme/private/kw.ss b/collects/scheme/private/kw.ss index 42c9d450ea..09f93893d1 100644 --- a/collects/scheme/private/kw.ss +++ b/collects/scheme/private/kw.ss @@ -18,7 +18,10 @@ keyword-apply procedure-keywords procedure-reduce-keyword-arity - new-prop:procedure) + new-prop:procedure + new:procedure->method + new:procedure-rename + new:chaperone-procedure) ;; ---------------------------------------- @@ -854,8 +857,10 @@ (let loop ([kws kws][req-kws req-kws]) (if (null? req-kws) (null? kws) - (and (eq? (car kws) (car req-kws)) - (loop (cdr kws) (cdr req-kws)))))) + (if (null? kws) + #f + (and (eq? (car kws) (car req-kws)) + (loop (cdr kws) (cdr req-kws))))))) (arity-check-lambda (kws) ;; Required is a subset of allowed @@ -970,8 +975,8 @@ ;; setting procedure arity (define (procedure-reduce-keyword-arity proc arity req-kw allowed-kw) - (let ([plain-proc (procedure-reduce-arity (if (okp? proc) - (okp-ref proc 0) + (let ([plain-proc (procedure-reduce-arity (if (okp? proc) + (okp-ref proc 0) proc) arity)]) (define (sorted? kws) @@ -1022,17 +1027,62 @@ (raise-mismatch-error 'procedure-reduce-keyword-arity "cannot allow keywords not in original allowed set: " old-allowed)))) - (let ([new-arity (let loop ([a arity]) - (cond - [(integer? a) (+ a 2)] - [(arity-at-least? a) - (make-arity-at-least (+ (arity-at-least-value a) 2))] - [else - (map loop a)]))]) - (make-optional-keyword-procedure - (make-keyword-checker req-kw allowed-kw new-arity) - (procedure-reduce-arity (keyword-procedure-proc proc) - new-arity) - req-kw - allowed-kw - plain-proc))))) + (if (null? allowed-kw) + plain-proc + (let* ([inc-arity (lambda (arity delta) + (let loop ([a arity]) + (cond + [(integer? a) (+ a delta)] + [(arity-at-least? a) + (make-arity-at-least (+ (arity-at-least-value a) delta))] + [else + (map loop a)])))] + [new-arity (inc-arity arity 2)] + [kw-checker (make-keyword-checker req-kw allowed-kw new-arity)] + [new-kw-proc (procedure-reduce-arity (keyword-procedure-proc proc) + new-arity)]) + (if (null? req-kw) + ;; All keywords are optional: + ((if (okm? proc) + make-optional-keyword-method + make-optional-keyword-procedure) + kw-checker + new-kw-proc + req-kw + allowed-kw + plain-proc) + ;; Some keywords are required, so "plain" proc is + ;; irrelevant; we build a new one that wraps `missing-kws'. + ((make-required (or (and (named-keyword-procedure? proc) + (keyword-procedure-name proc)) + (object-name proc)) + (procedure-reduce-arity + missing-kw + (inc-arity arity 1)) + (or (okm? proc) + (keyword-method? proc))) + kw-checker + new-kw-proc + req-kw + allowed-kw)))))) + + (define new:procedure->method + (let ([procedure->method + (lambda (proc) + (procedure->method proc))]) + procedure->method)) + + (define new:procedure-rename + (let ([procedure-rename + (lambda (proc name) + (if (not (and (keyword-procedure? proc) + (symbol? name))) + (procedure-rename proc name) + (procedure-rename proc name)))]) + procedure-rename)) + + (define new:chaperone-procedure + (let ([chaperone-procedure + (lambda (proc wrap-proc . props) + (apply chaperone-procedure proc wrap-proc props))]) + chaperone-procedure))) diff --git a/collects/scheme/private/pre-base.ss b/collects/scheme/private/pre-base.ss index a887b38af1..ee2bc2fd32 100644 --- a/collects/scheme/private/pre-base.ss +++ b/collects/scheme/private/pre-base.ss @@ -73,8 +73,13 @@ (rename module-begin #%module-begin) (rename norm:procedure-arity procedure-arity) (rename norm:raise-arity-error raise-arity-error) + (rename new:procedure->method procedure->method) + (rename new:procedure-rename procedure-rename) + (rename new:chaperone-procedure chaperone-procedure) (all-from-except '#%kernel lambda λ #%app #%module-begin apply prop:procedure - procedure-arity raise-arity-error) + procedure-arity raise-arity-error + procedure->method procedure-rename + chaperone-procedure) (all-from "reqprov.ss") (all-from "for.ss") (all-from "kernstruct.ss") diff --git a/collects/tests/mzscheme/chaperone.ss b/collects/tests/mzscheme/chaperone.ss index c2e5c79697..d3e22b0af1 100644 --- a/collects/tests/mzscheme/chaperone.ss +++ b/collects/tests/mzscheme/chaperone.ss @@ -314,6 +314,12 @@ [a2 (if rev? (chaperone-struct a3 a-y (lambda (a v) (set! get v) v)) a2)]) + (test #t a? a1) + (test #t a? a2) + (test #t a? a3) + (test #t procedure? a1) + (test #t procedure? a2) + (test #t procedure? a3) (test '(12 12) a1 12) (test #f values get) (test #f values pre) diff --git a/collects/tests/mzscheme/procs.ss b/collects/tests/mzscheme/procs.ss index 8d4b214ff3..0d2991a598 100644 --- a/collects/tests/mzscheme/procs.ss +++ b/collects/tests/mzscheme/procs.ss @@ -68,7 +68,7 @@ (for-each (lambda (p) (let ([a (cadr p)]) (test a procedure-arity (car p)) - (test-values (list (caddr p) (cadddr p)) + (test-values (list (caddr p) (cadddr p)) (lambda () (procedure-keywords (car p)))) (let ([1-ok? (let loop ([a a]) @@ -78,7 +78,14 @@ (and (list? a) (ormap loop a))))]) (test 1-ok? procedure-arity-includes? (car p) 1) - (let ([allowed (cadddr p)]) + (let ([allowed (cadddr p)] + [required (caddr p)]) + ;; If some keyword is required, make sure that a plain + ;; application fails: + (unless (null? required) + (err/rt-test + (apply (car p) (make-list (procedure-arity (car p)) #\0)))) + ;; Other tests: (if 1-ok? (cond [(equal? allowed '()) diff --git a/doc/release-notes/mzscheme/HISTORY.txt b/doc/release-notes/mzscheme/HISTORY.txt index 4acc8d6f9e..1e0861912c 100644 --- a/doc/release-notes/mzscheme/HISTORY.txt +++ b/doc/release-notes/mzscheme/HISTORY.txt @@ -1,4 +1,5 @@ Version 4.2.5, March 2010 +Added scheme/future, enabled by default on main platforms Changed module to wrap each body expression in a prompt Changed define-cstruct to bind type name for struct-out, etc. diff --git a/src/mzscheme/gc2/Makefile.in b/src/mzscheme/gc2/Makefile.in index 4b85e3be07..16642f4d95 100644 --- a/src/mzscheme/gc2/Makefile.in +++ b/src/mzscheme/gc2/Makefile.in @@ -269,7 +269,7 @@ list.@LTO@: $(XSRCDIR)/list.c $(CC) $(CFLAGS) -c $(XSRCDIR)/list.c -o list.@LTO@ module.@LTO@: $(XSRCDIR)/module.c $(CC) $(CFLAGS) -c $(XSRCDIR)/module.c -o module.@LTO@ -mzrt.@LTO@: $(SRCDIR)/mzrt.c $(SRCDIR)/mzrt.h +mzrt.@LTO@: $(SRCDIR)/mzrt.c $(SRCDIR)/mzrt.h $(XFORMDEP) $(CC) $(CFLAGS) -DMZ_PRECISE_GC -c $(SRCDIR)/mzrt.c -o mzrt.@LTO@ network.@LTO@: $(XSRCDIR)/network.c $(CC) $(CFLAGS) -c $(XSRCDIR)/network.c -o network.@LTO@ diff --git a/src/mzscheme/gc2/gc2.h b/src/mzscheme/gc2/gc2.h index 1d90093f1d..4afc1858a3 100644 --- a/src/mzscheme/gc2/gc2.h +++ b/src/mzscheme/gc2/gc2.h @@ -15,9 +15,14 @@ #ifndef GC2_JUST_MACROS +struct NewGC; + typedef int (*Size_Proc)(void *obj); +typedef int (*Size2_Proc)(void *obj, struct NewGC *); typedef int (*Mark_Proc)(void *obj); +typedef int (*Mark2_Proc)(void *obj, struct NewGC *); typedef int (*Fixup_Proc)(void *obj); +typedef int (*Fixup2_Proc)(void *obj, struct NewGC *); typedef void (*GC_collect_start_callback_Proc)(void); typedef void (*GC_collect_end_callback_Proc)(void); typedef void (*GC_collect_inform_callback_Proc)(int major_gc, long pre_used, long post_used); @@ -288,6 +293,8 @@ GC2_EXTERN void GC_set_variable_stack(void **p); GC2_EXTERN void GC_register_traversers(short tag, Size_Proc size, Mark_Proc mark, Fixup_Proc fixup, int is_constant_size, int is_atomic); +GC2_EXTERN void GC_register_traversers2(short tag, Size2_Proc size, Mark2_Proc mark, Fixup2_Proc fixup, + int is_constant_size, int is_atomic); /* Registers a traversal procedure for a tag. Obviously, a traversal procedure must be installed for each tag before a collection @@ -336,6 +343,8 @@ GC2_EXTERN void *GC_fixup_self(void *p); /* INTERNAL for the current implemenation (used by macros): */ GC2_EXTERN void GC_mark(const void *p); GC2_EXTERN void GC_fixup(void *p); +GC2_EXTERN void GC_mark2(const void *p, struct NewGC *gc); +GC2_EXTERN void GC_fixup2(void *p, struct NewGC *gc); /* Used in the expansion of gcMARK and gcFIXUP. @@ -350,6 +359,16 @@ GC2_EXTERN void GC_fixup_variable_stack(void **var_stack, long delta, void *limit, void *stack_mem); +GC2_EXTERN void GC_mark2_variable_stack(void **var_stack, + long delta, + void *limit, + void *stack_mem, + struct NewGC *gc); +GC2_EXTERN void GC_fixup2_variable_stack(void **var_stack, + long delta, + void *limit, + void *stack_mem, + struct NewGC *gc); /* Can be called by a mark or fixup traversal proc to traverse and update a chunk of (atomically-allocated) memory containing an image @@ -443,11 +462,17 @@ GC2_EXTERN void GC_set_put_external_event_fd(void *fd); # define gcLOG_WORD_SIZE 2 #endif #define gcMARK(x) GC_mark(x) +#define gcMARK2(x, gc) GC_mark2(x, gc) #define gcMARK_TYPED(t, x) gcMARK(x) +#define gcMARK2_TYPED(t, x, gc) gcMARK2(x, gc) #define gcMARK_TYPED_NOW(t, x) gcMARK(x) +#define gcMARK2_TYPED_NOW(t, x, gc) gcMARK(x, gc) #define gcFIXUP_TYPED_NOW(t, x) GC_fixup(&(x)) +#define gcFIXUP2_TYPED_NOW(t, x, gc) GC_fixup2(&(x), gc) #define gcFIXUP_TYPED(t, x) gcFIXUP_TYPED_NOW(void*, x) +#define gcFIXUP2_TYPED(t, x, gc) gcFIXUP2_TYPED_NOW(void*, x, gc) #define gcFIXUP(x) gcFIXUP_TYPED(void*, x) +#define gcFIXUP2(x, gc) gcFIXUP2_TYPED(void*, x, gc) #define gcBYTES_TO_WORDS(x) ((x + (1 << gcLOG_WORD_SIZE) - 1) >> gcLOG_WORD_SIZE) #define gcWORDS_TO_BYTES(x) (x << gcLOG_WORD_SIZE) diff --git a/src/mzscheme/gc2/mem_account.c b/src/mzscheme/gc2/mem_account.c index a77527b93e..f90a46eba3 100644 --- a/src/mzscheme/gc2/mem_account.c +++ b/src/mzscheme/gc2/mem_account.c @@ -43,12 +43,12 @@ inline static void BTC_register_thread(void *t, void *c) inline static void mark_threads(NewGC *gc, int owner) { GC_Thread_Info *work; - Mark_Proc thread_mark = gc->mark_table[btc_redirect_thread]; + Mark2_Proc thread_mark = gc->mark_table[btc_redirect_thread]; for(work = gc->thread_infos; work; work = work->next) if(work->owner == owner) { if (((Scheme_Thread *)work->thread)->running) { - thread_mark(work->thread); + thread_mark(work->thread, gc); if (work->thread == scheme_current_thread) { GC_mark_variable_stack(GC_variable_stack, 0, get_stack_base(gc), NULL); } @@ -275,7 +275,7 @@ inline static void mark_cust_boxes(NewGC *gc, Scheme_Custodian *cur) { Scheme_Object *pr, *prev = NULL, *next; GC_Weak_Box *wb; - Mark_Proc cust_box_mark = gc->mark_table[btc_redirect_cust_box]; + Mark2_Proc cust_box_mark = gc->mark_table[btc_redirect_cust_box]; /* cust boxes is a list of weak boxes to cust boxes */ @@ -284,7 +284,7 @@ inline static void mark_cust_boxes(NewGC *gc, Scheme_Custodian *cur) wb = (GC_Weak_Box *)SCHEME_CAR(pr); next = SCHEME_CDR(pr); if (wb->val) { - cust_box_mark(wb->val); + cust_box_mark(wb->val, gc); prev = pr; } else { if (prev) @@ -298,34 +298,31 @@ inline static void mark_cust_boxes(NewGC *gc, Scheme_Custodian *cur) cur->checked_cust_boxes = cur->num_cust_boxes; } -int BTC_thread_mark(void *p) +int BTC_thread_mark(void *p, struct NewGC *gc) { - NewGC *gc = GC_get_GC(); if (gc->doing_memory_accounting) { return OBJPTR_TO_OBJHEAD(p)->size; } - return gc->mark_table[btc_redirect_thread](p); + return gc->mark_table[btc_redirect_thread](p, gc); } -int BTC_custodian_mark(void *p) +int BTC_custodian_mark(void *p, struct NewGC *gc) { - NewGC *gc = GC_get_GC(); if (gc->doing_memory_accounting) { if(custodian_to_owner_set(gc, p) == gc->current_mark_owner) - return gc->mark_table[btc_redirect_custodian](p); + return gc->mark_table[btc_redirect_custodian](p, gc); else return OBJPTR_TO_OBJHEAD(p)->size; } - return gc->mark_table[btc_redirect_custodian](p); + return gc->mark_table[btc_redirect_custodian](p, gc); } -int BTC_cust_box_mark(void *p) +int BTC_cust_box_mark(void *p, struct NewGC *gc) { - NewGC *gc = GC_get_GC(); if (gc->doing_memory_accounting) { return OBJPTR_TO_OBJHEAD(p)->size; } - return gc->mark_table[btc_redirect_cust_box](p); + return gc->mark_table[btc_redirect_cust_box](p, gc); } static void btc_overmem_abort(NewGC *gc) @@ -338,12 +335,11 @@ static void btc_overmem_abort(NewGC *gc) static void propagate_accounting_marks(NewGC *gc) { void *p; - PageMap pagemap = gc->page_maps; - Mark_Proc *mark_table = gc->mark_table; + Mark2_Proc *mark_table = gc->mark_table; while(pop_ptr(gc, &p) && !gc->kill_propagation_loop) { /* GCDEBUG((DEBUGOUTF, "btc_account: popped off page %p:%p, ptr %p\n", page, page->addr, p)); */ - propagate_marks_worker(pagemap, mark_table, p); + propagate_marks_worker(gc, mark_table, p); } if(gc->kill_propagation_loop) reset_pointer_stack(gc); diff --git a/src/mzscheme/gc2/newgc.c b/src/mzscheme/gc2/newgc.c index 1a3792e2ef..c4479e863a 100644 --- a/src/mzscheme/gc2/newgc.c +++ b/src/mzscheme/gc2/newgc.c @@ -1432,22 +1432,38 @@ static inline void *get_stack_base(NewGC *gc) { #include "stack_comp.c" -#define GC_X_variable_stack GC_mark_variable_stack -#define gcX(a) gcMARK(*a) +#define GC_X_variable_stack GC_mark2_variable_stack +#define gcX2(a, gc) gcMARK2(*a, gc) #define X_source(stk, p) set_backtrace_source((stk ? stk : p), BT_STACK) #include "var_stack.c" #undef GC_X_variable_stack -#undef gcX +#undef gcX2 #undef X_source -#define GC_X_variable_stack GC_fixup_variable_stack -#define gcX(a) gcFIXUP(*a) +#define GC_X_variable_stack GC_fixup2_variable_stack +#define gcX2(a, gc) gcFIXUP2(*a, gc) #define X_source(stk, p) /* */ #include "var_stack.c" #undef GC_X_variable_stack -#undef gcX +#undef gcX2 #undef X_source +void GC_mark_variable_stack(void **var_stack, + long delta, + void *limit, + void *stack_mem) +{ + GC_mark2_variable_stack(var_stack, delta, limit, stack_mem, GC_get_GC()); +} + +void GC_fixup_variable_stack(void **var_stack, + long delta, + void *limit, + void *stack_mem) +{ + GC_fixup2_variable_stack(var_stack, delta, limit, stack_mem, GC_get_GC()); +} + /*****************************************************************************/ /* Routines for root sets */ /*****************************************************************************/ @@ -1499,16 +1515,16 @@ inline static void mark_finalizer_structs(NewGC *gc) for(fnl = GC_resolve(gc->finalizers); fnl; fnl = GC_resolve(fnl->next)) { set_backtrace_source(fnl, BT_FINALIZER); - gcMARK(fnl->data); + gcMARK2(fnl->data, gc); set_backtrace_source(&gc->finalizers, BT_ROOT); - gcMARK(fnl); + gcMARK2(fnl, gc); } for(fnl = gc->run_queue; fnl; fnl = fnl->next) { set_backtrace_source(fnl, BT_FINALIZER); - gcMARK(fnl->data); - gcMARK(fnl->p); + gcMARK2(fnl->data, gc); + gcMARK2(fnl->p, gc); set_backtrace_source(&gc->run_queue, BT_ROOT); - gcMARK(fnl); + gcMARK2(fnl, gc); } } @@ -1517,17 +1533,17 @@ inline static void repair_finalizer_structs(NewGC *gc) Fnl *fnl; /* repair the base parts of the list */ - gcFIXUP(gc->finalizers); gcFIXUP(gc->run_queue); + gcFIXUP2(gc->finalizers, gc); gcFIXUP2(gc->run_queue, gc); /* then repair the stuff inside them */ for(fnl = gc->finalizers; fnl; fnl = fnl->next) { - gcFIXUP(fnl->data); - gcFIXUP(fnl->p); - gcFIXUP(fnl->next); + gcFIXUP2(fnl->data, gc); + gcFIXUP2(fnl->p, gc); + gcFIXUP2(fnl->next, gc); } for(fnl = gc->run_queue; fnl; fnl = fnl->next) { - gcFIXUP(fnl->data); - gcFIXUP(fnl->p); - gcFIXUP(fnl->next); + gcFIXUP2(fnl->data, gc); + gcFIXUP2(fnl->p, gc); + gcFIXUP2(fnl->next, gc); } } @@ -1545,7 +1561,7 @@ inline static void check_finalizers(NewGC *gc, int level) "CFNL: Level %i finalizer %p on %p queued for finalization.\n", work->eager_level, work, work->p)); set_backtrace_source(work, BT_FINALIZER); - gcMARK(work->p); + gcMARK2(work->p, gc); if(prev) prev->next = next; if(!prev) gc->finalizers = next; if(gc->last_in_queue) gc->last_in_queue = gc->last_in_queue->next = work; @@ -1567,7 +1583,7 @@ inline static void check_finalizers(NewGC *gc, int level) inline static void do_ordered_level3(NewGC *gc) { struct finalizer *temp; - Mark_Proc *mark_table = gc->mark_table; + Mark2_Proc *mark_table = gc->mark_table; for(temp = GC_resolve(gc->finalizers); temp; temp = GC_resolve(temp->next)) if(!marked(gc, temp->p)) { @@ -1575,7 +1591,7 @@ inline static void do_ordered_level3(NewGC *gc) "LVL3: %p is not marked. Marking payload (%p)\n", temp, temp->p)); set_backtrace_source(temp, BT_FINALIZER); - if(temp->tagged) mark_table[*(unsigned short*)temp->p](temp->p); + if(temp->tagged) mark_table[*(unsigned short*)temp->p](temp->p, gc); if(!temp->tagged) GC_mark_xtagged(temp->p); } } @@ -1598,7 +1614,7 @@ inline static void mark_weak_finalizer_structs(NewGC *gc) GCDEBUG((DEBUGOUTF, "MARKING WEAK FINALIZERS.\n")); for(work = gc->weak_finalizers; work; work = work->next) { set_backtrace_source(&gc->weak_finalizers, BT_ROOT); - gcMARK(work); + gcMARK2(work, gc); } } @@ -1607,16 +1623,16 @@ inline static void repair_weak_finalizer_structs(NewGC *gc) Weak_Finalizer *work; Weak_Finalizer *prev; - gcFIXUP(gc->weak_finalizers); + gcFIXUP2(gc->weak_finalizers, gc); work = gc->weak_finalizers; prev = NULL; while(work) { - gcFIXUP(work->next); + gcFIXUP2(work->next, gc); if(!marked(gc, work->p)) { if(prev) prev->next = work->next; if(!prev) gc->weak_finalizers = work->next; work = GC_resolve(work->next); } else { - gcFIXUP(work->p); + gcFIXUP2(work->p, gc); prev = work; work = work->next; } @@ -1640,7 +1656,7 @@ inline static void reset_weak_finalizers(NewGC *gc) for(wfnl = GC_resolve(gc->weak_finalizers); wfnl; wfnl = GC_resolve(wfnl->next)) { if(marked(gc, wfnl->p)) { set_backtrace_source(wfnl, BT_WEAKLINK); - gcMARK(wfnl->saved); + gcMARK2(wfnl->saved, gc); } *(void**)(NUM(GC_resolve(wfnl->p)) + wfnl->offset) = wfnl->saved; wfnl->saved = NULL; @@ -1754,7 +1770,7 @@ inline static void reset_pointer_stack(NewGC *gc) gc->mark_stack->top = MARK_STACK_START(gc->mark_stack); } -static inline void propagate_marks_worker(PageMap pagemap, Mark_Proc *mark_table, void *p); +static inline void propagate_marks_worker(NewGC *gc, Mark2_Proc *mark_table, void *p); /*****************************************************************************/ /* MEMORY ACCOUNTING */ @@ -1996,8 +2012,8 @@ static void NewGC_initialize(NewGC *newgc, NewGC *parentgc) { #ifdef MZ_USE_PLACES NewGCMasterInfo_initialize(); #endif - newgc->mark_table = ofm_malloc_zero(NUMBER_OF_TAGS * sizeof (Mark_Proc)); - newgc->fixup_table = ofm_malloc_zero(NUMBER_OF_TAGS * sizeof (Fixup_Proc)); + newgc->mark_table = ofm_malloc_zero(NUMBER_OF_TAGS * sizeof (Mark2_Proc)); + newgc->fixup_table = ofm_malloc_zero(NUMBER_OF_TAGS * sizeof (Fixup2_Proc)); #ifdef NEWGC_BTC_ACCOUNT BTC_initialize_mark_table(newgc); #endif @@ -2053,9 +2069,9 @@ static NewGC *init_type_tags_worker(NewGC *parentgc, int count, int pair, int mu resize_gen0(gc, GEN0_INITIAL_SIZE); if (!parentgc) { - GC_register_traversers(gc->weak_box_tag, size_weak_box, mark_weak_box, fixup_weak_box, 0, 0); - GC_register_traversers(gc->ephemeron_tag, size_ephemeron, mark_ephemeron, fixup_ephemeron, 0, 0); - GC_register_traversers(gc->weak_array_tag, size_weak_array, mark_weak_array, fixup_weak_array, 0, 0); + GC_register_traversers2(gc->weak_box_tag, size_weak_box, mark_weak_box, fixup_weak_box, 0, 0); + GC_register_traversers2(gc->ephemeron_tag, size_ephemeron, mark_ephemeron, fixup_ephemeron, 0, 0); + GC_register_traversers2(gc->weak_array_tag, size_weak_array, mark_weak_array, fixup_weak_array, 0, 0); } initialize_signal_handler(gc); GC_add_roots(&gc->park, (char *)&gc->park + sizeof(gc->park) + 1); @@ -2163,8 +2179,8 @@ void GC_gcollect(void) } static inline int atomic_mark(void *p) { return 0; } -void GC_register_traversers(short tag, Size_Proc size, Mark_Proc mark, - Fixup_Proc fixup, int constant_Size, int atomic) +void GC_register_traversers2(short tag, Size2_Proc size, Mark2_Proc mark, + Fixup2_Proc fixup, int constant_Size, int atomic) { NewGC *gc = GC_get_GC(); @@ -2179,10 +2195,17 @@ void GC_register_traversers(short tag, Size_Proc size, Mark_Proc mark, atomic = 0; #endif - gc->mark_table[mark_tag] = atomic ? (Mark_Proc)PAGE_ATOMIC : mark; + gc->mark_table[mark_tag] = atomic ? (Mark2_Proc)PAGE_ATOMIC : mark; gc->fixup_table[tag] = fixup; } +void GC_register_traversers(short tag, Size_Proc size, Mark_Proc mark, + Fixup_Proc fixup, int constant_Size, int atomic) +{ + GC_register_traversers2(tag, (Size2_Proc)size, (Mark2_Proc)mark, + (Fixup2_Proc)fixup, constant_Size, atomic); +} + long GC_get_memory_use(void *o) { NewGC *gc = GC_get_GC(); @@ -2203,18 +2226,16 @@ long GC_get_memory_use(void *o) we use internally, and it doesn't do nearly as much. */ /* This is the first mark routine. It's a bit complicated. */ -void GC_mark(const void *const_p) +void GC_mark2(const void *const_p, struct NewGC *gc) { mpage *page; void *p = (void*)const_p; - NewGC *gc; if(!p || (NUM(p) & 0x1)) { GCDEBUG((DEBUGOUTF, "Not marking %p (bad ptr)\n", p)); return; } - gc = GC_get_GC(); if(!(page = pagemap_find_page(gc->page_maps, p))) { #ifdef MZ_USE_PLACES if (!MASTERGC || !MASTERGC->major_places_gc || !(page = pagemap_find_page(MASTERGC->page_maps, p))) @@ -2405,9 +2426,14 @@ void GC_mark(const void *const_p) } } +void GC_mark(const void *const_p) +{ + GC_mark2(const_p, GC_get_GC()); +} + /* this is the second mark routine. It's not quite as complicated. */ /* this is what actually does mark propagation */ -static inline void propagate_marks_worker(PageMap pagemap, Mark_Proc *mark_table, void *pp) +static inline void propagate_marks_worker(NewGC *gc, Mark2_Proc *mark_table, void *pp) { void **start, **end; int alloc_type; @@ -2418,7 +2444,7 @@ static inline void propagate_marks_worker(PageMap pagemap, Mark_Proc *mark_table if (IS_BIG_PAGE_PTR(pp)) { mpage *page; p = REMOVE_BIG_PAGE_PTR_TAG(pp); - page = pagemap_find_page(pagemap, p); + page = pagemap_find_page(gc->page_maps, p); #ifdef MZ_USE_PLACES if (!page && MASTERGC && MASTERGC->major_places_gc) { page = pagemap_find_page(MASTERGC->page_maps, p); @@ -2442,12 +2468,12 @@ static inline void propagate_marks_worker(PageMap pagemap, Mark_Proc *mark_table case PAGE_TAGGED: { const unsigned short tag = *(unsigned short*)start; - Mark_Proc markproc; + Mark2_Proc markproc; ASSERT_TAG(tag); markproc = mark_table[tag]; if(((unsigned long) markproc) >= PAGE_TYPES) { GC_ASSERT(markproc); - markproc(start); + markproc(start, gc); } break; } @@ -2455,7 +2481,7 @@ static inline void propagate_marks_worker(PageMap pagemap, Mark_Proc *mark_table break; case PAGE_ARRAY: { - while(start < end) gcMARK(*start++); break; + while(start < end) gcMARK2(*start++, gc); break; } case PAGE_TARRAY: { @@ -2464,7 +2490,7 @@ static inline void propagate_marks_worker(PageMap pagemap, Mark_Proc *mark_table end -= INSET_WORDS; while(start < end) { GC_ASSERT(mark_table[tag]); - start += mark_table[tag](start); + start += mark_table[tag](start, gc); } break; } @@ -2476,12 +2502,11 @@ static inline void propagate_marks_worker(PageMap pagemap, Mark_Proc *mark_table static void propagate_marks(NewGC *gc) { void *p; - PageMap pagemap = gc->page_maps; - Mark_Proc *mark_table = gc->mark_table; + Mark2_Proc *mark_table = gc->mark_table; while(pop_ptr(gc, &p)) { GCDEBUG((DEBUGOUTF, "Popped pointer %p\n", p)); - propagate_marks_worker(pagemap, mark_table, p); + propagate_marks_worker(gc, mark_table, p); } } @@ -2506,16 +2531,14 @@ void *GC_fixup_self(void *p) return p; } -void GC_fixup(void *pp) +void GC_fixup2(void *pp, struct NewGC *gc) { - NewGC *gc; mpage *page; void *p = *(void**)pp; if(!p || (NUM(p) & 0x1)) return; - gc = GC_get_GC(); if((page = pagemap_find_page(gc->page_maps, p))) { objhead *info; @@ -2527,6 +2550,11 @@ void GC_fixup(void *pp) } else GCDEBUG((DEBUGOUTF, "Not repairing %p from %p (no page)\n", p, pp)); } +void GC_fixup(void *pp) +{ + GC_fixup2(pp, GC_get_GC()); +} + /*****************************************************************************/ /* memory stats and traces */ /*****************************************************************************/ @@ -3075,7 +3103,7 @@ static void repair_heap(NewGC *gc) { mpage *page; int i; - Fixup_Proc *fixup_table = gc->fixup_table; + Fixup2_Proc *fixup_table = gc->fixup_table; #ifdef MZ_USE_PLACES int master_has_switched = postmaster_and_master_gc(gc); #endif @@ -3105,11 +3133,11 @@ static void repair_heap(NewGC *gc) page->size_class = 2; /* remove the mark */ switch(page->page_type) { case PAGE_TAGGED: - fixup_table[*(unsigned short*)start](start); + fixup_table[*(unsigned short*)start](start, gc); break; case PAGE_ATOMIC: break; case PAGE_ARRAY: - while(start < end) gcFIXUP(*(start++)); + while(start < end) gcFIXUP2(*(start++), gc); break; case PAGE_XTAGGED: GC_fixup_xtagged(start); @@ -3118,7 +3146,7 @@ static void repair_heap(NewGC *gc) unsigned short tag = *(unsigned short *)start; ASSERT_TAG(tag); end -= INSET_WORDS; - while(start < end) start += fixup_table[tag](start); + while(start < end) start += fixup_table[tag](start, gc); break; } } @@ -3141,7 +3169,7 @@ static void repair_heap(NewGC *gc) unsigned short tag = *(unsigned short *)obj_start; ASSERT_TAG(tag); info->mark = 0; - fixup_table[tag](obj_start); + fixup_table[tag](obj_start, gc); } else { info->dead = 1; } @@ -3164,7 +3192,7 @@ static void repair_heap(NewGC *gc) if(info->mark) { void **tempend = PPTR(info) + info->size; start = OBJHEAD_TO_OBJPTR(start); - while(start < tempend) gcFIXUP(*start++); + while(start < tempend) gcFIXUP2(*start++, gc); info->mark = 0; } else { info->dead = 1; @@ -3183,7 +3211,7 @@ static void repair_heap(NewGC *gc) tag = *(unsigned short*)start; ASSERT_TAG(tag); while(start < tempend) - start += fixup_table[tag](start); + start += fixup_table[tag](start, gc); info->mark = 0; start = PPTR(info) + size; } else { @@ -3226,7 +3254,7 @@ static void repair_heap(NewGC *gc) { void **tempend = PPTR(info) + info->size; start = OBJHEAD_TO_OBJPTR(start); - while(start < tempend) gcFIXUP(*start++); + while(start < tempend) gcFIXUP2(*start++, gc); } break; case PAGE_TAGGED: @@ -3234,7 +3262,7 @@ static void repair_heap(NewGC *gc) void *obj_start = OBJHEAD_TO_OBJPTR(start); unsigned short tag = *(unsigned short *)obj_start; ASSERT_TAG(tag); - fixup_table[tag](obj_start); + fixup_table[tag](obj_start, gc); start += info->size; } break; @@ -3763,7 +3791,7 @@ static void dump_stack_pos(void *a) } # define GC_X_variable_stack GC_do_dump_variable_stack -# define gcX(a) dump_stack_pos(a) +# define gcX2(a, gc) dump_stack_pos(a) # define X_source(stk, p) /* */ # include "var_stack.c" # undef GC_X_variable_stack diff --git a/src/mzscheme/gc2/newgc.h b/src/mzscheme/gc2/newgc.h index f0eebefdfb..6584d82ba2 100644 --- a/src/mzscheme/gc2/newgc.h +++ b/src/mzscheme/gc2/newgc.h @@ -105,8 +105,8 @@ typedef mpage **PageMap; typedef struct NewGC { Gen0 gen0; - Mark_Proc *mark_table; /* the table of mark procs */ - Fixup_Proc *fixup_table; /* the table of repair procs */ + Mark2_Proc *mark_table; /* the table of mark procs */ + Fixup2_Proc *fixup_table; /* the table of repair procs */ PageMap page_maps; /* All non-gen0 pages are held in the following structure. */ struct mpage *gen1_pages[PAGE_TYPES]; diff --git a/src/mzscheme/gc2/var_stack.c b/src/mzscheme/gc2/var_stack.c index 3f5677241a..be7407669d 100644 --- a/src/mzscheme/gc2/var_stack.c +++ b/src/mzscheme/gc2/var_stack.c @@ -1,5 +1,5 @@ -void GC_X_variable_stack(void **var_stack, long delta, void *limit, void *stack_mem) +void GC_X_variable_stack(void **var_stack, long delta, void *limit, void *stack_mem, struct NewGC *gc) { long size, count; void ***p, **a; @@ -36,7 +36,7 @@ void GC_X_variable_stack(void **var_stack, long delta, void *limit, void *stack_ if (SHALLOWER_STACK_ADDRESS(a, limit)) { while (count--) { X_source(stack_mem, a); - gcX(a); + gcX2(a, gc); a++; } } @@ -44,7 +44,7 @@ void GC_X_variable_stack(void **var_stack, long delta, void *limit, void *stack_ a = (void **)((char *)a + delta); if (SHALLOWER_STACK_ADDRESS(a, limit)) { X_source(stack_mem, a); - gcX(a); + gcX2(a, gc); } } p++; @@ -64,13 +64,13 @@ void GC_X_variable_stack(void **var_stack, long delta, void *limit, void *stack_ a = (void **)((char *)a + delta); while (count--) { X_source(stack_mem, a); - gcX(a); + gcX2(a, gc); a++; } } else { a = (void **)((char *)a + delta); X_source(stack_mem, a); - gcX(a); + gcX2(a, gc); } p++; } diff --git a/src/mzscheme/gc2/weak.c b/src/mzscheme/gc2/weak.c index da95fb12a7..1adf2fbaca 100644 --- a/src/mzscheme/gc2/weak.c +++ b/src/mzscheme/gc2/weak.c @@ -25,7 +25,7 @@ /* weak arrays */ /******************************************************************************/ -static int size_weak_array(void *p) +static int size_weak_array(void *p, struct NewGC *gc) { GC_Weak_Array *a = (GC_Weak_Array *)p; @@ -33,12 +33,11 @@ static int size_weak_array(void *p) + ((a->count - 1) * sizeof(void *))); } -static int mark_weak_array(void *p) +static int mark_weak_array(void *p, struct NewGC *gc) { - GCTYPE *gc = GC_get_GC(); GC_Weak_Array *a = (GC_Weak_Array *)p; - gcMARK(a->replace_val); + gcMARK2(a->replace_val, gc); a->next = gc->weak_arrays; gc->weak_arrays = a; @@ -64,18 +63,18 @@ static int mark_weak_array(void *p) + ((a->count - 1) * sizeof(void *))); } -static int fixup_weak_array(void *p) +static int fixup_weak_array(void *p, struct NewGC *gc) { GC_Weak_Array *a = (GC_Weak_Array *)p; int i; void **data; - gcFIXUP(a->replace_val); + gcFIXUP2(a->replace_val, gc); data = a->data; for (i = a->count; i--; ) { if (data[i]) - gcFIXUP(data[i]); + gcFIXUP2(data[i], gc); } return gcBYTES_TO_WORDS(sizeof(GC_Weak_Array) @@ -132,17 +131,16 @@ static void zero_weak_arrays(GCTYPE *gc) /* weak boxes */ /******************************************************************************/ -static int size_weak_box(void *p) +static int size_weak_box(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(GC_Weak_Box)); } -static int mark_weak_box(void *p) +static int mark_weak_box(void *p, struct NewGC *gc) { - GCTYPE *gc = GC_get_GC(); GC_Weak_Box *wb = (GC_Weak_Box *)p; - gcMARK(wb->secondary_erase); + gcMARK2(wb->secondary_erase, gc); if (wb->val) { wb->next = gc->weak_boxes; @@ -152,12 +150,12 @@ static int mark_weak_box(void *p) return gcBYTES_TO_WORDS(sizeof(GC_Weak_Box)); } -static int fixup_weak_box(void *p) +static int fixup_weak_box(void *p, struct NewGC *gc) { GC_Weak_Box *wb = (GC_Weak_Box *)p; - gcFIXUP(wb->secondary_erase); - gcFIXUP(wb->val); + gcFIXUP2(wb->secondary_erase, gc); + gcFIXUP2(wb->val, gc); return gcBYTES_TO_WORDS(sizeof(GC_Weak_Box)); } @@ -213,14 +211,13 @@ static void zero_weak_boxes(GCTYPE *gc) /* ephemeron */ /******************************************************************************/ -static int size_ephemeron(void *p) +static int size_ephemeron(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(GC_Ephemeron)); } -static int mark_ephemeron(void *p) +static int mark_ephemeron(void *p, struct NewGC *gc) { - GCTYPE *gc = GC_get_GC(); GC_Ephemeron *eph = (GC_Ephemeron *)p; if (eph->val) { @@ -232,29 +229,28 @@ static int mark_ephemeron(void *p) } #ifdef NEWGC_BTC_ACCOUNT -static int BTC_ephemeron_mark(void *p) +static int BTC_ephemeron_mark(void *p, struct NewGC *gc) { - GCTYPE *gc = GC_get_GC(); if (gc->doing_memory_accounting) { GC_Ephemeron *eph = (GC_Ephemeron *)p; - gcMARK(eph->key); - gcMARK(eph->val); + gcMARK2(eph->key, gc); + gcMARK2(eph->val, gc); return gcBYTES_TO_WORDS(sizeof(GC_Ephemeron)); } - return mark_ephemeron(p); + return mark_ephemeron(p, gc); } #endif -static int fixup_ephemeron(void *p) +static int fixup_ephemeron(void *p, struct NewGC *gc) { GC_Ephemeron *eph = (GC_Ephemeron *)p; - gcFIXUP(eph->key); - gcFIXUP(eph->val); + gcFIXUP2(eph->key, gc); + gcFIXUP2(eph->val, gc); return gcBYTES_TO_WORDS(sizeof(GC_Ephemeron)); } @@ -294,7 +290,7 @@ static void mark_ready_ephemerons(GCTYPE *gc) for (eph = gc->ephemerons; eph; eph = next) { next = eph->next; if (is_marked(gc, eph->key)) { - gcMARK(eph->val); + gcMARK2(eph->val, gc); gc->num_last_seen_ephemerons++; } else { eph->next = waiting; diff --git a/src/mzscheme/include/schthread.h b/src/mzscheme/include/schthread.h index d87fe867d7..7b9913ba1c 100644 --- a/src/mzscheme/include/schthread.h +++ b/src/mzscheme/include/schthread.h @@ -303,9 +303,9 @@ static inline Thread_Local_Variables *scheme_get_thread_local_variables() { Thread_Local_Variables *x = NULL; # if defined(OS_X) # if defined(__x86_64__) - asm volatile("movq %%gs:0x8E0, %0" : "=r"(x)); + asm volatile("movq %%gs:0x60(,%1,8), %0" : "=r"(x) : "r"(scheme_thread_local_key)); # else - asm volatile("movl %%gs:0x488, %0" : "=r"(x)); + asm volatile("movl %%gs:0x48(,%1,4), %0" : "=r"(x) : "r"(scheme_thread_local_key)); # endif # elif defined(linux) && defined(MZ_USES_SHARED_LIB) # if defined(__x86_64__) diff --git a/src/mzscheme/src/fun.c b/src/mzscheme/src/fun.c index 5bfe3cd351..21d48811fd 100644 --- a/src/mzscheme/src/fun.c +++ b/src/mzscheme/src/fun.c @@ -2898,21 +2898,28 @@ Scheme_Object *scheme_make_arity(mzshort mina, mzshort maxa) } } -static Scheme_Object *clone_arity(Scheme_Object *a) +static Scheme_Object *clone_arity(Scheme_Object *a, int delta) { if (SCHEME_PAIRP(a)) { Scheme_Object *m, *l; m = scheme_copy_list(a); for (l = m; SCHEME_PAIRP(l); l = SCHEME_CDR(l)) { - a = clone_arity(SCHEME_CAR(l)); + a = clone_arity(SCHEME_CAR(l), delta); SCHEME_CAR(l) = a; } return m; } else if (SCHEME_CHAPERONE_STRUCTP(a)) { Scheme_Object *p[1]; - p[0] = scheme_struct_ref(a, 0); + a = scheme_struct_ref(a, 0); + if (delta) + a = scheme_bin_minus(a, scheme_make_integer(delta)); + p[0] = a; return scheme_make_struct_instance(scheme_arity_at_least, 1, p); - } else + } else if (SCHEME_NULLP(a)) + return a; + else if (delta) + return scheme_bin_minus(a, scheme_make_integer(delta)); + else return a; } @@ -2996,10 +3003,13 @@ static Scheme_Object *get_or_check_arity(Scheme_Object *p, long a, Scheme_Object int is_method; if (scheme_reduced_procedure_struct && scheme_is_struct_instance(scheme_reduced_procedure_struct, p)) { - if (a >= 0) + if (a >= 0) { bign = scheme_make_integer(a); + if (drop) + bign = scheme_bin_plus(bign, scheme_make_integer(a)); + } if (a == -1) - return clone_arity(((Scheme_Structure *)p)->slots[1]); + return clone_arity(((Scheme_Structure *)p)->slots[1], drop); else { /* Check arity (or for varargs) */ Scheme_Object *v; @@ -3836,7 +3846,7 @@ static Scheme_Object *procedure_reduce_arity(int argc, Scheme_Object *argv[]) lists that include arity-at-least records. */ orig = get_or_check_arity(argv[0], -1, NULL); - aty = clone_arity(argv[1]); + aty = clone_arity(argv[1], 0); if (!is_subarity(aty, orig)) { scheme_raise_exn(MZEXN_FAIL_CONTRACT, diff --git a/src/mzscheme/src/jit.c b/src/mzscheme/src/jit.c index 197ba2ec47..211d407f0f 100644 --- a/src/mzscheme/src/jit.c +++ b/src/mzscheme/src/jit.c @@ -11351,7 +11351,8 @@ static int do_generate_common(mz_jit_state *jitter, void *_data) for (i = 0; i < 4; i++) { void *code; int kind, for_branch; - jit_insn *ref, *ref2, *refslow, *bref1, *bref2, *bref3, *bref4, *bref5, *bref6, *bref8; + GC_CAN_IGNORE jit_insn *ref, *ref2, *ref3, *refslow, *bref1, *bref2, *refretry; + GC_CAN_IGNORE jit_insn *bref3, *bref4, *bref5, *bref6, *bref8, *ref9; if ((ii == 1) && (i == 1)) continue; /* no multi variant of pred branch */ @@ -11448,11 +11449,21 @@ static int do_generate_common(mz_jit_state *jitter, void *_data) /* Check argument: */ if (kind == 1) { bref1 = jit_bmsi_ul(jit_forward(), JIT_R1, 0x1); + refretry = _jit.x.pc; jit_ldxi_s(JIT_R2, JIT_R1, &((Scheme_Object *)0x0)->type); __START_INNER_TINY__(1); ref2 = jit_beqi_i(jit_forward(), JIT_R2, scheme_structure_type); + ref3 = jit_beqi_i(jit_forward(), JIT_R2, scheme_proc_struct_type); + ref9 = jit_beqi_i(jit_forward(), JIT_R2, scheme_chaperone_type); + __END_INNER_TINY__(1); + bref2 = jit_bnei_i(jit_forward(), JIT_R2, scheme_proc_chaperone_type); + CHECK_LIMIT(); + __START_INNER_TINY__(1); + mz_patch_branch(ref9); + jit_ldxi_p(JIT_R1, JIT_R1, &SCHEME_CHAPERONE_VAL(0x0)); + (void)jit_jmpi(refretry); + mz_patch_branch(ref3); __END_INNER_TINY__(1); - bref2 = jit_bnei_i(jit_forward(), JIT_R2, scheme_proc_struct_type); } else { (void)jit_bmsi_ul(refslow, JIT_R1, 0x1); jit_ldxi_s(JIT_R2, JIT_R1, &((Scheme_Object *)0x0)->type); diff --git a/src/mzscheme/src/mkmark.ss b/src/mzscheme/src/mkmark.ss index 5d0061fce4..84a15d7d56 100644 --- a/src/mzscheme/src/mkmark.ss +++ b/src/mzscheme/src/mkmark.ss @@ -48,28 +48,28 @@ (read-lines re:size)) null)] [size (read-lines re:close)]) - (printf "static int ~a_SIZE(void *p) {~n" name) + (printf "static int ~a_SIZE(void *p, struct NewGC *gc) {~n" name) (print-lines prefix) (printf " return~n") (print-lines size) (printf "}~n~n") - (printf "static int ~a_MARK(void *p) {~n" name) + (printf "static int ~a_MARK(void *p, struct NewGC *gc) {~n" name) (print-lines prefix) (print-lines (map (lambda (s) (regexp-replace* "FIXUP_ONLY[(]([^;]*;)[)]" (regexp-replace* - "FIXUP_TYPED_NOW[(][^,]*," + "FIXUP2_TYPED_NOW[(][^,]*," s - "MARK(") + "MARK2(") "")) mark)) (printf " return~n") (print-lines size) (printf "}~n~n") - (printf "static int ~a_FIXUP(void *p) {~n" name) + (printf "static int ~a_FIXUP(void *p, struct NewGC *gc) {~n" name) (print-lines prefix) (print-lines (map (lambda (s) (regexp-replace* diff --git a/src/mzscheme/src/mzmark.c b/src/mzscheme/src/mzmark.c index 7ec137f48b..1c0210a27d 100644 --- a/src/mzscheme/src/mzmark.c +++ b/src/mzscheme/src/mzmark.c @@ -2,28 +2,28 @@ #ifdef MARKS_FOR_TYPE_C -static int variable_obj_SIZE(void *p) { +static int variable_obj_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_With_Home)); } -static int variable_obj_MARK(void *p) { +static int variable_obj_MARK(void *p, struct NewGC *gc) { Scheme_Bucket *b = (Scheme_Bucket *)p; - gcMARK(b->key); - gcMARK(b->val); - gcMARK(((Scheme_Bucket_With_Home *)b)->home); + gcMARK2(b->key, gc); + gcMARK2(b->val, gc); + gcMARK2(((Scheme_Bucket_With_Home *)b)->home, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_With_Home)); } -static int variable_obj_FIXUP(void *p) { +static int variable_obj_FIXUP(void *p, struct NewGC *gc) { Scheme_Bucket *b = (Scheme_Bucket *)p; - gcFIXUP(b->key); - gcFIXUP(b->val); - gcFIXUP(((Scheme_Bucket_With_Home *)b)->home); + gcFIXUP2(b->key, gc); + gcFIXUP2(b->val, gc); + gcFIXUP2(((Scheme_Bucket_With_Home *)b)->home, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_With_Home)); @@ -33,28 +33,28 @@ static int variable_obj_FIXUP(void *p) { #define variable_obj_IS_CONST_SIZE 1 -static int module_var_SIZE(void *p) { +static int module_var_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Module_Variable)); } -static int module_var_MARK(void *p) { +static int module_var_MARK(void *p, struct NewGC *gc) { Module_Variable *mv = (Module_Variable *)p; - gcMARK(mv->modidx); - gcMARK(mv->sym); - gcMARK(mv->insp); + gcMARK2(mv->modidx, gc); + gcMARK2(mv->sym, gc); + gcMARK2(mv->insp, gc); return gcBYTES_TO_WORDS(sizeof(Module_Variable)); } -static int module_var_FIXUP(void *p) { +static int module_var_FIXUP(void *p, struct NewGC *gc) { Module_Variable *mv = (Module_Variable *)p; - gcFIXUP(mv->modidx); - gcFIXUP(mv->sym); - gcFIXUP(mv->insp); + gcFIXUP2(mv->modidx, gc); + gcFIXUP2(mv->sym, gc); + gcFIXUP2(mv->insp, gc); return gcBYTES_TO_WORDS(sizeof(Module_Variable)); @@ -64,26 +64,26 @@ static int module_var_FIXUP(void *p) { #define module_var_IS_CONST_SIZE 1 -static int bucket_obj_SIZE(void *p) { +static int bucket_obj_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Bucket)); } -static int bucket_obj_MARK(void *p) { +static int bucket_obj_MARK(void *p, struct NewGC *gc) { Scheme_Bucket *b = (Scheme_Bucket *)p; - gcMARK(b->key); - gcMARK(b->val); + gcMARK2(b->key, gc); + gcMARK2(b->val, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Bucket)); } -static int bucket_obj_FIXUP(void *p) { +static int bucket_obj_FIXUP(void *p, struct NewGC *gc) { Scheme_Bucket *b = (Scheme_Bucket *)p; - gcFIXUP(b->key); - gcFIXUP(b->val); + gcFIXUP2(b->key, gc); + gcFIXUP2(b->val, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Bucket)); @@ -93,17 +93,17 @@ static int bucket_obj_FIXUP(void *p) { #define bucket_obj_IS_CONST_SIZE 1 -static int local_obj_SIZE(void *p) { +static int local_obj_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Local)); } -static int local_obj_MARK(void *p) { +static int local_obj_MARK(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Local)); } -static int local_obj_FIXUP(void *p) { +static int local_obj_FIXUP(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Local)); } @@ -112,17 +112,17 @@ static int local_obj_FIXUP(void *p) { #define local_obj_IS_CONST_SIZE 1 -static int toplevel_obj_SIZE(void *p) { +static int toplevel_obj_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Toplevel)); } -static int toplevel_obj_MARK(void *p) { +static int toplevel_obj_MARK(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Toplevel)); } -static int toplevel_obj_FIXUP(void *p) { +static int toplevel_obj_FIXUP(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Toplevel)); } @@ -131,17 +131,17 @@ static int toplevel_obj_FIXUP(void *p) { #define toplevel_obj_IS_CONST_SIZE 1 -static int quotesyntax_obj_SIZE(void *p) { +static int quotesyntax_obj_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Quote_Syntax)); } -static int quotesyntax_obj_MARK(void *p) { +static int quotesyntax_obj_MARK(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Quote_Syntax)); } -static int quotesyntax_obj_FIXUP(void *p) { +static int quotesyntax_obj_FIXUP(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Quote_Syntax)); } @@ -150,25 +150,25 @@ static int quotesyntax_obj_FIXUP(void *p) { #define quotesyntax_obj_IS_CONST_SIZE 1 -static int cpointer_obj_SIZE(void *p) { +static int cpointer_obj_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Cptr)); } -static int cpointer_obj_MARK(void *p) { +static int cpointer_obj_MARK(void *p, struct NewGC *gc) { if (!(SCHEME_CPTR_FLAGS(p) & 0x1)) { - gcMARK(SCHEME_CPTR_VAL(p)); + gcMARK2(SCHEME_CPTR_VAL(p), gc); } - gcMARK(SCHEME_CPTR_TYPE(p)); + gcMARK2(SCHEME_CPTR_TYPE(p), gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Cptr)); } -static int cpointer_obj_FIXUP(void *p) { +static int cpointer_obj_FIXUP(void *p, struct NewGC *gc) { if (!(SCHEME_CPTR_FLAGS(p) & 0x1)) { - gcFIXUP(SCHEME_CPTR_VAL(p)); + gcFIXUP2(SCHEME_CPTR_VAL(p), gc); } - gcFIXUP(SCHEME_CPTR_TYPE(p)); + gcFIXUP2(SCHEME_CPTR_TYPE(p), gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Cptr)); } @@ -177,25 +177,25 @@ static int cpointer_obj_FIXUP(void *p) { #define cpointer_obj_IS_CONST_SIZE 1 -static int offset_cpointer_obj_SIZE(void *p) { +static int offset_cpointer_obj_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Offset_Cptr)); } -static int offset_cpointer_obj_MARK(void *p) { +static int offset_cpointer_obj_MARK(void *p, struct NewGC *gc) { if (!(SCHEME_CPTR_FLAGS(p) & 0x1)) { - gcMARK(SCHEME_CPTR_VAL(p)); + gcMARK2(SCHEME_CPTR_VAL(p), gc); } - gcMARK(SCHEME_CPTR_TYPE(p)); + gcMARK2(SCHEME_CPTR_TYPE(p), gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Offset_Cptr)); } -static int offset_cpointer_obj_FIXUP(void *p) { +static int offset_cpointer_obj_FIXUP(void *p, struct NewGC *gc) { if (!(SCHEME_CPTR_FLAGS(p) & 0x1)) { - gcFIXUP(SCHEME_CPTR_VAL(p)); + gcFIXUP2(SCHEME_CPTR_VAL(p), gc); } - gcFIXUP(SCHEME_CPTR_TYPE(p)); + gcFIXUP2(SCHEME_CPTR_TYPE(p), gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Offset_Cptr)); } @@ -204,21 +204,21 @@ static int offset_cpointer_obj_FIXUP(void *p) { #define offset_cpointer_obj_IS_CONST_SIZE 1 -static int twoptr_obj_SIZE(void *p) { +static int twoptr_obj_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); } -static int twoptr_obj_MARK(void *p) { - gcMARK(SCHEME_PTR1_VAL((Scheme_Object *)p)); - gcMARK(SCHEME_PTR2_VAL((Scheme_Object *)p)); +static int twoptr_obj_MARK(void *p, struct NewGC *gc) { + gcMARK2(SCHEME_PTR1_VAL((Scheme_Object *)p), gc); + gcMARK2(SCHEME_PTR2_VAL((Scheme_Object *)p), gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); } -static int twoptr_obj_FIXUP(void *p) { - gcFIXUP(SCHEME_PTR1_VAL((Scheme_Object *)p)); - gcFIXUP(SCHEME_PTR2_VAL((Scheme_Object *)p)); +static int twoptr_obj_FIXUP(void *p, struct NewGC *gc) { + gcFIXUP2(SCHEME_PTR1_VAL((Scheme_Object *)p), gc); + gcFIXUP2(SCHEME_PTR2_VAL((Scheme_Object *)p), gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); } @@ -227,19 +227,19 @@ static int twoptr_obj_FIXUP(void *p) { #define twoptr_obj_IS_CONST_SIZE 1 -static int iptr_obj_SIZE(void *p) { +static int iptr_obj_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); } -static int iptr_obj_MARK(void *p) { - gcMARK(SCHEME_IPTR_VAL((Scheme_Object *)p)); +static int iptr_obj_MARK(void *p, struct NewGC *gc) { + gcMARK2(SCHEME_IPTR_VAL((Scheme_Object *)p), gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); } -static int iptr_obj_FIXUP(void *p) { - gcFIXUP(SCHEME_IPTR_VAL((Scheme_Object *)p)); +static int iptr_obj_FIXUP(void *p, struct NewGC *gc) { + gcFIXUP2(SCHEME_IPTR_VAL((Scheme_Object *)p), gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); } @@ -248,20 +248,20 @@ static int iptr_obj_FIXUP(void *p) { #define iptr_obj_IS_CONST_SIZE 1 -static int small_object_SIZE(void *p) { +static int small_object_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object)); } -static int small_object_MARK(void *p) { - gcMARK(((Scheme_Small_Object *)p)->u.ptr_value); +static int small_object_MARK(void *p, struct NewGC *gc) { + gcMARK2(((Scheme_Small_Object *)p)->u.ptr_value, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object)); } -static int small_object_FIXUP(void *p) { - gcFIXUP(((Scheme_Small_Object *)p)->u.ptr_value); +static int small_object_FIXUP(void *p, struct NewGC *gc) { + gcFIXUP2(((Scheme_Small_Object *)p)->u.ptr_value, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object)); @@ -271,7 +271,7 @@ static int small_object_FIXUP(void *p) { #define small_object_IS_CONST_SIZE 1 -static int app_rec_SIZE(void *p) { +static int app_rec_SIZE(void *p, struct NewGC *gc) { Scheme_App_Rec *r = (Scheme_App_Rec *)p; return @@ -280,12 +280,12 @@ static int app_rec_SIZE(void *p) { + ((r->num_args + 1) * sizeof(char)))); } -static int app_rec_MARK(void *p) { +static int app_rec_MARK(void *p, struct NewGC *gc) { Scheme_App_Rec *r = (Scheme_App_Rec *)p; int i = r->num_args + 1; while (i--) - gcMARK(r->args[i]); + gcMARK2(r->args[i], gc); return gcBYTES_TO_WORDS((sizeof(Scheme_App_Rec) @@ -293,12 +293,12 @@ static int app_rec_MARK(void *p) { + ((r->num_args + 1) * sizeof(char)))); } -static int app_rec_FIXUP(void *p) { +static int app_rec_FIXUP(void *p, struct NewGC *gc) { Scheme_App_Rec *r = (Scheme_App_Rec *)p; int i = r->num_args + 1; while (i--) - gcFIXUP(r->args[i]); + gcFIXUP2(r->args[i], gc); return gcBYTES_TO_WORDS((sizeof(Scheme_App_Rec) @@ -310,24 +310,24 @@ static int app_rec_FIXUP(void *p) { #define app_rec_IS_CONST_SIZE 0 -static int app2_rec_SIZE(void *p) { +static int app2_rec_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_App2_Rec)); } -static int app2_rec_MARK(void *p) { +static int app2_rec_MARK(void *p, struct NewGC *gc) { Scheme_App2_Rec *r = (Scheme_App2_Rec *)p; - gcMARK(r->rator); - gcMARK(r->rand); + gcMARK2(r->rator, gc); + gcMARK2(r->rand, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_App2_Rec)); } -static int app2_rec_FIXUP(void *p) { +static int app2_rec_FIXUP(void *p, struct NewGC *gc) { Scheme_App2_Rec *r = (Scheme_App2_Rec *)p; - gcFIXUP(r->rator); - gcFIXUP(r->rand); + gcFIXUP2(r->rator, gc); + gcFIXUP2(r->rand, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_App2_Rec)); @@ -337,26 +337,26 @@ static int app2_rec_FIXUP(void *p) { #define app2_rec_IS_CONST_SIZE 1 -static int app3_rec_SIZE(void *p) { +static int app3_rec_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_App3_Rec)); } -static int app3_rec_MARK(void *p) { +static int app3_rec_MARK(void *p, struct NewGC *gc) { Scheme_App3_Rec *r = (Scheme_App3_Rec *)p; - gcMARK(r->rator); - gcMARK(r->rand1); - gcMARK(r->rand2); + gcMARK2(r->rator, gc); + gcMARK2(r->rand1, gc); + gcMARK2(r->rand2, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_App3_Rec)); } -static int app3_rec_FIXUP(void *p) { +static int app3_rec_FIXUP(void *p, struct NewGC *gc) { Scheme_App3_Rec *r = (Scheme_App3_Rec *)p; - gcFIXUP(r->rator); - gcFIXUP(r->rand1); - gcFIXUP(r->rand2); + gcFIXUP2(r->rator, gc); + gcFIXUP2(r->rand1, gc); + gcFIXUP2(r->rand2, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_App3_Rec)); @@ -366,7 +366,7 @@ static int app3_rec_FIXUP(void *p) { #define app3_rec_IS_CONST_SIZE 1 -static int seq_rec_SIZE(void *p) { +static int seq_rec_SIZE(void *p, struct NewGC *gc) { Scheme_Sequence *s = (Scheme_Sequence *)p; return @@ -374,24 +374,24 @@ static int seq_rec_SIZE(void *p) { + ((s->count - 1) * sizeof(Scheme_Object *)))); } -static int seq_rec_MARK(void *p) { +static int seq_rec_MARK(void *p, struct NewGC *gc) { Scheme_Sequence *s = (Scheme_Sequence *)p; int i = s->count; while (i--) - gcMARK(s->array[i]); + gcMARK2(s->array[i], gc); return gcBYTES_TO_WORDS((sizeof(Scheme_Sequence) + ((s->count - 1) * sizeof(Scheme_Object *)))); } -static int seq_rec_FIXUP(void *p) { +static int seq_rec_FIXUP(void *p, struct NewGC *gc) { Scheme_Sequence *s = (Scheme_Sequence *)p; int i = s->count; while (i--) - gcFIXUP(s->array[i]); + gcFIXUP2(s->array[i], gc); return gcBYTES_TO_WORDS((sizeof(Scheme_Sequence) @@ -402,28 +402,28 @@ static int seq_rec_FIXUP(void *p) { #define seq_rec_IS_CONST_SIZE 0 -static int branch_rec_SIZE(void *p) { +static int branch_rec_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Branch_Rec)); } -static int branch_rec_MARK(void *p) { +static int branch_rec_MARK(void *p, struct NewGC *gc) { Scheme_Branch_Rec *b = (Scheme_Branch_Rec *)p; - gcMARK(b->test); - gcMARK(b->tbranch); - gcMARK(b->fbranch); + gcMARK2(b->test, gc); + gcMARK2(b->tbranch, gc); + gcMARK2(b->fbranch, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Branch_Rec)); } -static int branch_rec_FIXUP(void *p) { +static int branch_rec_FIXUP(void *p, struct NewGC *gc) { Scheme_Branch_Rec *b = (Scheme_Branch_Rec *)p; - gcFIXUP(b->test); - gcFIXUP(b->tbranch); - gcFIXUP(b->fbranch); + gcFIXUP2(b->test, gc); + gcFIXUP2(b->tbranch, gc); + gcFIXUP2(b->fbranch, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Branch_Rec)); @@ -433,35 +433,35 @@ static int branch_rec_FIXUP(void *p) { #define branch_rec_IS_CONST_SIZE 1 -static int unclosed_proc_SIZE(void *p) { +static int unclosed_proc_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Closure_Data)); } -static int unclosed_proc_MARK(void *p) { +static int unclosed_proc_MARK(void *p, struct NewGC *gc) { Scheme_Closure_Data *d = (Scheme_Closure_Data *)p; - gcMARK(d->name); - gcMARK(d->code); - gcMARK(d->closure_map); + gcMARK2(d->name, gc); + gcMARK2(d->code, gc); + gcMARK2(d->closure_map, gc); #ifdef MZ_USE_JIT - gcMARK(d->u.native_code); - gcMARK(d->context); + gcMARK2(d->u.native_code, gc); + gcMARK2(d->context, gc); #endif return gcBYTES_TO_WORDS(sizeof(Scheme_Closure_Data)); } -static int unclosed_proc_FIXUP(void *p) { +static int unclosed_proc_FIXUP(void *p, struct NewGC *gc) { Scheme_Closure_Data *d = (Scheme_Closure_Data *)p; - gcFIXUP(d->name); - gcFIXUP(d->code); - gcFIXUP(d->closure_map); + gcFIXUP2(d->name, gc); + gcFIXUP2(d->code, gc); + gcFIXUP2(d->closure_map, gc); #ifdef MZ_USE_JIT - gcFIXUP(d->u.native_code); - gcFIXUP(d->context); + gcFIXUP2(d->u.native_code, gc); + gcFIXUP2(d->context, gc); #endif return @@ -472,26 +472,26 @@ static int unclosed_proc_FIXUP(void *p) { #define unclosed_proc_IS_CONST_SIZE 1 -static int let_value_SIZE(void *p) { +static int let_value_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Let_Value)); } -static int let_value_MARK(void *p) { +static int let_value_MARK(void *p, struct NewGC *gc) { Scheme_Let_Value *l = (Scheme_Let_Value *)p; - gcMARK(l->value); - gcMARK(l->body); + gcMARK2(l->value, gc); + gcMARK2(l->body, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Let_Value)); } -static int let_value_FIXUP(void *p) { +static int let_value_FIXUP(void *p, struct NewGC *gc) { Scheme_Let_Value *l = (Scheme_Let_Value *)p; - gcFIXUP(l->value); - gcFIXUP(l->body); + gcFIXUP2(l->value, gc); + gcFIXUP2(l->body, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Let_Value)); @@ -501,24 +501,24 @@ static int let_value_FIXUP(void *p) { #define let_value_IS_CONST_SIZE 1 -static int let_void_SIZE(void *p) { +static int let_void_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Let_Void)); } -static int let_void_MARK(void *p) { +static int let_void_MARK(void *p, struct NewGC *gc) { Scheme_Let_Void *l = (Scheme_Let_Void *)p; - gcMARK(l->body); + gcMARK2(l->body, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Let_Void)); } -static int let_void_FIXUP(void *p) { +static int let_void_FIXUP(void *p, struct NewGC *gc) { Scheme_Let_Void *l = (Scheme_Let_Void *)p; - gcFIXUP(l->body); + gcFIXUP2(l->body, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Let_Void)); @@ -528,26 +528,26 @@ static int let_void_FIXUP(void *p) { #define let_void_IS_CONST_SIZE 1 -static int letrec_SIZE(void *p) { +static int letrec_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Letrec)); } -static int letrec_MARK(void *p) { +static int letrec_MARK(void *p, struct NewGC *gc) { Scheme_Letrec *l = (Scheme_Letrec *)p; - gcMARK(l->procs); - gcMARK(l->body); + gcMARK2(l->procs, gc); + gcMARK2(l->body, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Letrec)); } -static int letrec_FIXUP(void *p) { +static int letrec_FIXUP(void *p, struct NewGC *gc) { Scheme_Letrec *l = (Scheme_Letrec *)p; - gcFIXUP(l->procs); - gcFIXUP(l->body); + gcFIXUP2(l->procs, gc); + gcFIXUP2(l->body, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Letrec)); @@ -557,26 +557,26 @@ static int letrec_FIXUP(void *p) { #define letrec_IS_CONST_SIZE 1 -static int let_one_SIZE(void *p) { +static int let_one_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Let_One)); } -static int let_one_MARK(void *p) { +static int let_one_MARK(void *p, struct NewGC *gc) { Scheme_Let_One *l = (Scheme_Let_One *)p; - gcMARK(l->value); - gcMARK(l->body); + gcMARK2(l->value, gc); + gcMARK2(l->body, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Let_One)); } -static int let_one_FIXUP(void *p) { +static int let_one_FIXUP(void *p, struct NewGC *gc) { Scheme_Let_One *l = (Scheme_Let_One *)p; - gcFIXUP(l->value); - gcFIXUP(l->body); + gcFIXUP2(l->value, gc); + gcFIXUP2(l->body, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Let_One)); @@ -586,28 +586,28 @@ static int let_one_FIXUP(void *p) { #define let_one_IS_CONST_SIZE 1 -static int with_cont_mark_SIZE(void *p) { +static int with_cont_mark_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_With_Continuation_Mark)); } -static int with_cont_mark_MARK(void *p) { +static int with_cont_mark_MARK(void *p, struct NewGC *gc) { Scheme_With_Continuation_Mark *w = (Scheme_With_Continuation_Mark *)p; - gcMARK(w->key); - gcMARK(w->val); - gcMARK(w->body); + gcMARK2(w->key, gc); + gcMARK2(w->val, gc); + gcMARK2(w->body, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_With_Continuation_Mark)); } -static int with_cont_mark_FIXUP(void *p) { +static int with_cont_mark_FIXUP(void *p, struct NewGC *gc) { Scheme_With_Continuation_Mark *w = (Scheme_With_Continuation_Mark *)p; - gcFIXUP(w->key); - gcFIXUP(w->val); - gcFIXUP(w->body); + gcFIXUP2(w->key, gc); + gcFIXUP2(w->val, gc); + gcFIXUP2(w->body, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_With_Continuation_Mark)); @@ -617,28 +617,28 @@ static int with_cont_mark_FIXUP(void *p) { #define with_cont_mark_IS_CONST_SIZE 1 -static int comp_let_value_SIZE(void *p) { +static int comp_let_value_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Compiled_Let_Value)); } -static int comp_let_value_MARK(void *p) { +static int comp_let_value_MARK(void *p, struct NewGC *gc) { Scheme_Compiled_Let_Value *c = (Scheme_Compiled_Let_Value *)p; - gcMARK(c->flags); - gcMARK(c->value); - gcMARK(c->body); + gcMARK2(c->flags, gc); + gcMARK2(c->value, gc); + gcMARK2(c->body, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Compiled_Let_Value)); } -static int comp_let_value_FIXUP(void *p) { +static int comp_let_value_FIXUP(void *p, struct NewGC *gc) { Scheme_Compiled_Let_Value *c = (Scheme_Compiled_Let_Value *)p; - gcFIXUP(c->flags); - gcFIXUP(c->value); - gcFIXUP(c->body); + gcFIXUP2(c->flags, gc); + gcFIXUP2(c->value, gc); + gcFIXUP2(c->body, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Compiled_Let_Value)); @@ -648,24 +648,24 @@ static int comp_let_value_FIXUP(void *p) { #define comp_let_value_IS_CONST_SIZE 1 -static int let_header_SIZE(void *p) { +static int let_header_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Let_Header)); } -static int let_header_MARK(void *p) { +static int let_header_MARK(void *p, struct NewGC *gc) { Scheme_Let_Header *h = (Scheme_Let_Header *)p; - gcMARK(h->body); + gcMARK2(h->body, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Let_Header)); } -static int let_header_FIXUP(void *p) { +static int let_header_FIXUP(void *p, struct NewGC *gc) { Scheme_Let_Header *h = (Scheme_Let_Header *)p; - gcFIXUP(h->body); + gcFIXUP2(h->body, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Let_Header)); @@ -675,7 +675,7 @@ static int let_header_FIXUP(void *p) { #define let_header_IS_CONST_SIZE 1 -static int prim_proc_SIZE(void *p) { +static int prim_proc_SIZE(void *p, struct NewGC *gc) { Scheme_Primitive_Proc *prim = (Scheme_Primitive_Proc *)p; return @@ -687,18 +687,18 @@ static int prim_proc_SIZE(void *p) { : gcBYTES_TO_WORDS(sizeof(Scheme_Primitive_Proc)))); } -static int prim_proc_MARK(void *p) { +static int prim_proc_MARK(void *p, struct NewGC *gc) { Scheme_Primitive_Proc *prim = (Scheme_Primitive_Proc *)p; - gcMARK(prim->name); + gcMARK2(prim->name, gc); if (prim->mina < 0) { - gcMARK(prim->mu.cases); + gcMARK2(prim->mu.cases, gc); } if (prim->pp.flags & SCHEME_PRIM_IS_CLOSURE) { Scheme_Primitive_Closure *cc = (Scheme_Primitive_Closure *)prim; int i; for (i = cc->count; i--; ) { - gcMARK(cc->val[i]); + gcMARK2(cc->val[i], gc); } } @@ -711,18 +711,18 @@ static int prim_proc_MARK(void *p) { : gcBYTES_TO_WORDS(sizeof(Scheme_Primitive_Proc)))); } -static int prim_proc_FIXUP(void *p) { +static int prim_proc_FIXUP(void *p, struct NewGC *gc) { Scheme_Primitive_Proc *prim = (Scheme_Primitive_Proc *)p; - gcFIXUP(prim->name); + gcFIXUP2(prim->name, gc); if (prim->mina < 0) { - gcFIXUP(prim->mu.cases); + gcFIXUP2(prim->mu.cases, gc); } if (prim->pp.flags & SCHEME_PRIM_IS_CLOSURE) { Scheme_Primitive_Closure *cc = (Scheme_Primitive_Closure *)prim; int i; for (i = cc->count; i--; ) { - gcFIXUP(cc->val[i]); + gcFIXUP2(cc->val[i], gc); } } @@ -739,7 +739,7 @@ static int prim_proc_FIXUP(void *p) { #define prim_proc_IS_CONST_SIZE 0 -static int closed_prim_proc_SIZE(void *p) { +static int closed_prim_proc_SIZE(void *p, struct NewGC *gc) { Scheme_Closed_Primitive_Proc *c = (Scheme_Closed_Primitive_Proc *)p; return @@ -750,13 +750,13 @@ static int closed_prim_proc_SIZE(void *p) { : gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Primitive_Proc)))); } -static int closed_prim_proc_MARK(void *p) { +static int closed_prim_proc_MARK(void *p, struct NewGC *gc) { Scheme_Closed_Primitive_Proc *c = (Scheme_Closed_Primitive_Proc *)p; - gcMARK(c->name); - gcMARK(SCHEME_CLSD_PRIM_DATA(c)); + gcMARK2(c->name, gc); + gcMARK2(SCHEME_CLSD_PRIM_DATA(c), gc); if (c->mina == -2) { - gcMARK(((Scheme_Closed_Case_Primitive_Proc *)c)->cases); + gcMARK2(((Scheme_Closed_Case_Primitive_Proc *)c)->cases, gc); } return @@ -767,13 +767,13 @@ static int closed_prim_proc_MARK(void *p) { : gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Primitive_Proc)))); } -static int closed_prim_proc_FIXUP(void *p) { +static int closed_prim_proc_FIXUP(void *p, struct NewGC *gc) { Scheme_Closed_Primitive_Proc *c = (Scheme_Closed_Primitive_Proc *)p; - gcFIXUP(c->name); - gcFIXUP(SCHEME_CLSD_PRIM_DATA(c)); + gcFIXUP2(c->name, gc); + gcFIXUP2(SCHEME_CLSD_PRIM_DATA(c), gc); if (c->mina == -2) { - gcFIXUP(((Scheme_Closed_Case_Primitive_Proc *)c)->cases); + gcFIXUP2(((Scheme_Closed_Case_Primitive_Proc *)c)->cases, gc); } return @@ -788,7 +788,7 @@ static int closed_prim_proc_FIXUP(void *p) { #define closed_prim_proc_IS_CONST_SIZE 0 -static int scm_closure_SIZE(void *p) { +static int scm_closure_SIZE(void *p, struct NewGC *gc) { Scheme_Closure *c = (Scheme_Closure *)p; int closure_size = (c->code ? ((Scheme_Closure_Data *)GC_resolve(c->code))->closure_size @@ -799,7 +799,7 @@ static int scm_closure_SIZE(void *p) { + (closure_size - 1) * sizeof(Scheme_Object *))); } -static int scm_closure_MARK(void *p) { +static int scm_closure_MARK(void *p, struct NewGC *gc) { Scheme_Closure *c = (Scheme_Closure *)p; int closure_size = (c->code ? ((Scheme_Closure_Data *)GC_resolve(c->code))->closure_size @@ -808,15 +808,15 @@ static int scm_closure_MARK(void *p) { int i = closure_size; while (i--) - gcMARK(c->vals[i]); - gcMARK(c->code); + gcMARK2(c->vals[i], gc); + gcMARK2(c->code, gc); return gcBYTES_TO_WORDS((sizeof(Scheme_Closure) + (closure_size - 1) * sizeof(Scheme_Object *))); } -static int scm_closure_FIXUP(void *p) { +static int scm_closure_FIXUP(void *p, struct NewGC *gc) { Scheme_Closure *c = (Scheme_Closure *)p; int closure_size = (c->code ? ((Scheme_Closure_Data *)GC_resolve(c->code))->closure_size @@ -825,8 +825,8 @@ static int scm_closure_FIXUP(void *p) { int i = closure_size; while (i--) - gcFIXUP(c->vals[i]); - gcFIXUP(c->code); + gcFIXUP2(c->vals[i], gc); + gcFIXUP2(c->code, gc); return gcBYTES_TO_WORDS((sizeof(Scheme_Closure) @@ -837,7 +837,7 @@ static int scm_closure_FIXUP(void *p) { #define scm_closure_IS_CONST_SIZE 0 -static int case_closure_SIZE(void *p) { +static int case_closure_SIZE(void *p, struct NewGC *gc) { Scheme_Case_Lambda *c = (Scheme_Case_Lambda *)p; return @@ -845,16 +845,16 @@ static int case_closure_SIZE(void *p) { + ((c->count - 1) * sizeof(Scheme_Object *)))); } -static int case_closure_MARK(void *p) { +static int case_closure_MARK(void *p, struct NewGC *gc) { Scheme_Case_Lambda *c = (Scheme_Case_Lambda *)p; int i; for (i = c->count; i--; ) - gcMARK(c->array[i]); - gcMARK(c->name); + gcMARK2(c->array[i], gc); + gcMARK2(c->name, gc); #ifdef MZ_USE_JIT - gcMARK(c->native_code); + gcMARK2(c->native_code, gc); #endif return @@ -862,16 +862,16 @@ static int case_closure_MARK(void *p) { + ((c->count - 1) * sizeof(Scheme_Object *)))); } -static int case_closure_FIXUP(void *p) { +static int case_closure_FIXUP(void *p, struct NewGC *gc) { Scheme_Case_Lambda *c = (Scheme_Case_Lambda *)p; int i; for (i = c->count; i--; ) - gcFIXUP(c->array[i]); - gcFIXUP(c->name); + gcFIXUP2(c->array[i], gc); + gcFIXUP2(c->name, gc); #ifdef MZ_USE_JIT - gcFIXUP(c->native_code); + gcFIXUP2(c->native_code, gc); #endif return @@ -883,86 +883,86 @@ static int case_closure_FIXUP(void *p) { #define case_closure_IS_CONST_SIZE 0 -static int cont_proc_SIZE(void *p) { +static int cont_proc_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Cont)); } -static int cont_proc_MARK(void *p) { +static int cont_proc_MARK(void *p, struct NewGC *gc) { Scheme_Cont *c = (Scheme_Cont *)p; - gcMARK(c->dw); - gcMARK(c->prompt_tag); - gcMARK(c->meta_continuation); - gcMARK(c->common_dw); - gcMARK(c->save_overflow); - gcMARK(c->runstack_copied); - gcMARK(c->runstack_owner); - gcMARK(c->cont_mark_stack_copied); - gcMARK(c->cont_mark_stack_owner); - gcMARK(c->init_config); - gcMARK(c->init_break_cell); + gcMARK2(c->dw, gc); + gcMARK2(c->prompt_tag, gc); + gcMARK2(c->meta_continuation, gc); + gcMARK2(c->common_dw, gc); + gcMARK2(c->save_overflow, gc); + gcMARK2(c->runstack_copied, gc); + gcMARK2(c->runstack_owner, gc); + gcMARK2(c->cont_mark_stack_copied, gc); + gcMARK2(c->cont_mark_stack_owner, gc); + gcMARK2(c->init_config, gc); + gcMARK2(c->init_break_cell, gc); #ifdef MZ_USE_JIT - gcMARK(c->native_trace); + gcMARK2(c->native_trace, gc); #endif - MARK_jmpup(&c->buf); - MARK_cjs(&c->cjs); - MARK_stack_state(&c->ss); - gcMARK(c->barrier_prompt); + MARK_jmpup(&c->buf, gc); + MARK_cjs(&c->cjs, gc); + MARK_stack_state(&c->ss, gc); + gcMARK2(c->barrier_prompt, gc); if (!GC_merely_accounting()) { - gcMARK(c->runstack_start); - gcMARK(c->runstack_saved); + gcMARK2(c->runstack_start, gc); + gcMARK2(c->runstack_saved, gc); } - gcMARK(c->prompt_id); - gcMARK(c->prompt_buf); + gcMARK2(c->prompt_id, gc); + gcMARK2(c->prompt_buf, gc); - gcMARK(c->value); - gcMARK(c->resume_to); - gcMARK(c->use_next_cont); - gcMARK(c->extra_marks); - gcMARK(c->shortcut_prompt); + gcMARK2(c->value, gc); + gcMARK2(c->resume_to, gc); + gcMARK2(c->use_next_cont, gc); + gcMARK2(c->extra_marks, gc); + gcMARK2(c->shortcut_prompt, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Cont)); } -static int cont_proc_FIXUP(void *p) { +static int cont_proc_FIXUP(void *p, struct NewGC *gc) { Scheme_Cont *c = (Scheme_Cont *)p; - gcFIXUP(c->dw); - gcFIXUP(c->prompt_tag); - gcFIXUP(c->meta_continuation); - gcFIXUP(c->common_dw); - gcFIXUP(c->save_overflow); - gcFIXUP(c->runstack_copied); - gcFIXUP(c->runstack_owner); - gcFIXUP(c->cont_mark_stack_copied); - gcFIXUP(c->cont_mark_stack_owner); - gcFIXUP(c->init_config); - gcFIXUP(c->init_break_cell); + gcFIXUP2(c->dw, gc); + gcFIXUP2(c->prompt_tag, gc); + gcFIXUP2(c->meta_continuation, gc); + gcFIXUP2(c->common_dw, gc); + gcFIXUP2(c->save_overflow, gc); + gcFIXUP2(c->runstack_copied, gc); + gcFIXUP2(c->runstack_owner, gc); + gcFIXUP2(c->cont_mark_stack_copied, gc); + gcFIXUP2(c->cont_mark_stack_owner, gc); + gcFIXUP2(c->init_config, gc); + gcFIXUP2(c->init_break_cell, gc); #ifdef MZ_USE_JIT - gcFIXUP(c->native_trace); + gcFIXUP2(c->native_trace, gc); #endif - FIXUP_jmpup(&c->buf); - FIXUP_cjs(&c->cjs); - FIXUP_stack_state(&c->ss); - gcFIXUP(c->barrier_prompt); + FIXUP_jmpup(&c->buf, gc); + FIXUP_cjs(&c->cjs, gc); + FIXUP_stack_state(&c->ss, gc); + gcFIXUP2(c->barrier_prompt, gc); if (!GC_merely_accounting()) { - gcFIXUP(c->runstack_start); - gcFIXUP(c->runstack_saved); + gcFIXUP2(c->runstack_start, gc); + gcFIXUP2(c->runstack_saved, gc); } - gcFIXUP(c->prompt_id); - gcFIXUP(c->prompt_buf); + gcFIXUP2(c->prompt_id, gc); + gcFIXUP2(c->prompt_buf, gc); - gcFIXUP(c->value); - gcFIXUP(c->resume_to); - gcFIXUP(c->use_next_cont); - gcFIXUP(c->extra_marks); - gcFIXUP(c->shortcut_prompt); + gcFIXUP2(c->value, gc); + gcFIXUP2(c->resume_to, gc); + gcFIXUP2(c->use_next_cont, gc); + gcFIXUP2(c->extra_marks, gc); + gcFIXUP2(c->shortcut_prompt, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Cont)); @@ -972,32 +972,32 @@ static int cont_proc_FIXUP(void *p) { #define cont_proc_IS_CONST_SIZE 1 -static int meta_cont_proc_SIZE(void *p) { +static int meta_cont_proc_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Meta_Continuation)); } -static int meta_cont_proc_MARK(void *p) { +static int meta_cont_proc_MARK(void *p, struct NewGC *gc) { Scheme_Meta_Continuation *c = (Scheme_Meta_Continuation *)p; - gcMARK(c->prompt_tag); - gcMARK(c->overflow); - gcMARK(c->next); - gcMARK(c->cont_mark_stack_copied); - gcMARK(c->cont); + gcMARK2(c->prompt_tag, gc); + gcMARK2(c->overflow, gc); + gcMARK2(c->next, gc); + gcMARK2(c->cont_mark_stack_copied, gc); + gcMARK2(c->cont, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Meta_Continuation)); } -static int meta_cont_proc_FIXUP(void *p) { +static int meta_cont_proc_FIXUP(void *p, struct NewGC *gc) { Scheme_Meta_Continuation *c = (Scheme_Meta_Continuation *)p; - gcFIXUP(c->prompt_tag); - gcFIXUP(c->overflow); - gcFIXUP(c->next); - gcFIXUP(c->cont_mark_stack_copied); - gcFIXUP(c->cont); + gcFIXUP2(c->prompt_tag, gc); + gcFIXUP2(c->overflow, gc); + gcFIXUP2(c->next, gc); + gcFIXUP2(c->cont_mark_stack_copied, gc); + gcFIXUP2(c->cont, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Meta_Continuation)); @@ -1007,34 +1007,34 @@ static int meta_cont_proc_FIXUP(void *p) { #define meta_cont_proc_IS_CONST_SIZE 1 -static int mark_dyn_wind_SIZE(void *p) { +static int mark_dyn_wind_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind)); } -static int mark_dyn_wind_MARK(void *p) { +static int mark_dyn_wind_MARK(void *p, struct NewGC *gc) { Scheme_Dynamic_Wind *dw = (Scheme_Dynamic_Wind *)p; - gcMARK(dw->id); - gcMARK(dw->data); - gcMARK(dw->prompt_tag); - gcMARK(dw->prev); + gcMARK2(dw->id, gc); + gcMARK2(dw->data, gc); + gcMARK2(dw->prompt_tag, gc); + gcMARK2(dw->prev, gc); - MARK_stack_state(&dw->envss); + MARK_stack_state(&dw->envss, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind)); } -static int mark_dyn_wind_FIXUP(void *p) { +static int mark_dyn_wind_FIXUP(void *p, struct NewGC *gc) { Scheme_Dynamic_Wind *dw = (Scheme_Dynamic_Wind *)p; - gcFIXUP(dw->id); - gcFIXUP(dw->data); - gcFIXUP(dw->prompt_tag); - gcFIXUP(dw->prev); + gcFIXUP2(dw->id, gc); + gcFIXUP2(dw->data, gc); + gcFIXUP2(dw->prompt_tag, gc); + gcFIXUP2(dw->prev, gc); - FIXUP_stack_state(&dw->envss); + FIXUP_stack_state(&dw->envss, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind)); @@ -1044,28 +1044,28 @@ static int mark_dyn_wind_FIXUP(void *p) { #define mark_dyn_wind_IS_CONST_SIZE 1 -static int mark_overflow_SIZE(void *p) { +static int mark_overflow_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Overflow)); } -static int mark_overflow_MARK(void *p) { +static int mark_overflow_MARK(void *p, struct NewGC *gc) { Scheme_Overflow *o = (Scheme_Overflow *)p; - gcMARK(o->prev); - gcMARK(o->jmp); - gcMARK(o->id); + gcMARK2(o->prev, gc); + gcMARK2(o->jmp, gc); + gcMARK2(o->id, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Overflow)); } -static int mark_overflow_FIXUP(void *p) { +static int mark_overflow_FIXUP(void *p, struct NewGC *gc) { Scheme_Overflow *o = (Scheme_Overflow *)p; - gcFIXUP(o->prev); - gcFIXUP(o->jmp); - gcFIXUP(o->id); + gcFIXUP2(o->prev, gc); + gcFIXUP2(o->jmp, gc); + gcFIXUP2(o->id, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Overflow)); @@ -1075,24 +1075,24 @@ static int mark_overflow_FIXUP(void *p) { #define mark_overflow_IS_CONST_SIZE 1 -static int mark_overflow_jmp_SIZE(void *p) { +static int mark_overflow_jmp_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Overflow_Jmp)); } -static int mark_overflow_jmp_MARK(void *p) { +static int mark_overflow_jmp_MARK(void *p, struct NewGC *gc) { Scheme_Overflow_Jmp *o = (Scheme_Overflow_Jmp *)p; - MARK_jmpup(&o->cont); + MARK_jmpup(&o->cont, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Overflow_Jmp)); } -static int mark_overflow_jmp_FIXUP(void *p) { +static int mark_overflow_jmp_FIXUP(void *p, struct NewGC *gc) { Scheme_Overflow_Jmp *o = (Scheme_Overflow_Jmp *)p; - FIXUP_jmpup(&o->cont); + FIXUP_jmpup(&o->cont, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Overflow_Jmp)); @@ -1102,34 +1102,34 @@ static int mark_overflow_jmp_FIXUP(void *p) { #define mark_overflow_jmp_IS_CONST_SIZE 1 -static int escaping_cont_proc_SIZE(void *p) { +static int escaping_cont_proc_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Escaping_Cont)); } -static int escaping_cont_proc_MARK(void *p) { +static int escaping_cont_proc_MARK(void *p, struct NewGC *gc) { Scheme_Escaping_Cont *c = (Scheme_Escaping_Cont *)p; #ifdef MZ_USE_JIT - gcMARK(c->native_trace); + gcMARK2(c->native_trace, gc); #endif - gcMARK(c->barrier_prompt); - MARK_stack_state(&c->envss); + gcMARK2(c->barrier_prompt, gc); + MARK_stack_state(&c->envss, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Escaping_Cont)); } -static int escaping_cont_proc_FIXUP(void *p) { +static int escaping_cont_proc_FIXUP(void *p, struct NewGC *gc) { Scheme_Escaping_Cont *c = (Scheme_Escaping_Cont *)p; #ifdef MZ_USE_JIT - gcFIXUP(c->native_trace); + gcFIXUP2(c->native_trace, gc); #endif - gcFIXUP(c->barrier_prompt); - FIXUP_stack_state(&c->envss); + gcFIXUP2(c->barrier_prompt, gc); + FIXUP_stack_state(&c->envss, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Escaping_Cont)); @@ -1139,17 +1139,17 @@ static int escaping_cont_proc_FIXUP(void *p) { #define escaping_cont_proc_IS_CONST_SIZE 1 -static int char_obj_SIZE(void *p) { +static int char_obj_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object)); } -static int char_obj_MARK(void *p) { +static int char_obj_MARK(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object)); } -static int char_obj_FIXUP(void *p) { +static int char_obj_FIXUP(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object)); } @@ -1158,7 +1158,7 @@ static int char_obj_FIXUP(void *p) { #define char_obj_IS_CONST_SIZE 1 -static int bignum_obj_SIZE(void *p) { +static int bignum_obj_SIZE(void *p, struct NewGC *gc) { Scheme_Bignum *b = (Scheme_Bignum *)p; return @@ -1167,11 +1167,11 @@ static int bignum_obj_SIZE(void *p) { : gcBYTES_TO_WORDS(sizeof(Small_Bignum))); } -static int bignum_obj_MARK(void *p) { +static int bignum_obj_MARK(void *p, struct NewGC *gc) { Scheme_Bignum *b = (Scheme_Bignum *)p; if (!SCHEME_BIGINLINE(b)) { - gcMARK(b->digits); + gcMARK2(b->digits, gc); } else { } @@ -1182,11 +1182,11 @@ static int bignum_obj_MARK(void *p) { : gcBYTES_TO_WORDS(sizeof(Small_Bignum))); } -static int bignum_obj_FIXUP(void *p) { +static int bignum_obj_FIXUP(void *p, struct NewGC *gc) { Scheme_Bignum *b = (Scheme_Bignum *)p; if (!SCHEME_BIGINLINE(b)) { - gcFIXUP(b->digits); + gcFIXUP2(b->digits, gc); } else { b->digits = ((Small_Bignum *)GC_fixup_self(b))->v; } @@ -1201,26 +1201,26 @@ static int bignum_obj_FIXUP(void *p) { #define bignum_obj_IS_CONST_SIZE 0 -static int rational_obj_SIZE(void *p) { +static int rational_obj_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Rational)); } -static int rational_obj_MARK(void *p) { +static int rational_obj_MARK(void *p, struct NewGC *gc) { Scheme_Rational *r = (Scheme_Rational *)p; - gcMARK(r->num); - gcMARK(r->denom); + gcMARK2(r->num, gc); + gcMARK2(r->denom, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Rational)); } -static int rational_obj_FIXUP(void *p) { +static int rational_obj_FIXUP(void *p, struct NewGC *gc) { Scheme_Rational *r = (Scheme_Rational *)p; - gcFIXUP(r->num); - gcFIXUP(r->denom); + gcFIXUP2(r->num, gc); + gcFIXUP2(r->denom, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Rational)); @@ -1230,7 +1230,7 @@ static int rational_obj_FIXUP(void *p) { #define rational_obj_IS_CONST_SIZE 1 -static int float_obj_SIZE(void *p) { +static int float_obj_SIZE(void *p, struct NewGC *gc) { return #ifdef MZ_USE_SINGLE_FLOATS gcBYTES_TO_WORDS(sizeof(Scheme_Float)); @@ -1239,7 +1239,7 @@ static int float_obj_SIZE(void *p) { #endif } -static int float_obj_MARK(void *p) { +static int float_obj_MARK(void *p, struct NewGC *gc) { return #ifdef MZ_USE_SINGLE_FLOATS gcBYTES_TO_WORDS(sizeof(Scheme_Float)); @@ -1248,7 +1248,7 @@ static int float_obj_MARK(void *p) { #endif } -static int float_obj_FIXUP(void *p) { +static int float_obj_FIXUP(void *p, struct NewGC *gc) { return #ifdef MZ_USE_SINGLE_FLOATS gcBYTES_TO_WORDS(sizeof(Scheme_Float)); @@ -1261,17 +1261,17 @@ static int float_obj_FIXUP(void *p) { #define float_obj_IS_CONST_SIZE 0 -static int double_obj_SIZE(void *p) { +static int double_obj_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Double)); } -static int double_obj_MARK(void *p) { +static int double_obj_MARK(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Double)); } -static int double_obj_FIXUP(void *p) { +static int double_obj_FIXUP(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Double)); } @@ -1280,26 +1280,26 @@ static int double_obj_FIXUP(void *p) { #define double_obj_IS_CONST_SIZE 1 -static int complex_obj_SIZE(void *p) { +static int complex_obj_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Complex)); } -static int complex_obj_MARK(void *p) { +static int complex_obj_MARK(void *p, struct NewGC *gc) { Scheme_Complex *c = (Scheme_Complex *)p; - gcMARK(c->r); - gcMARK(c->i); + gcMARK2(c->r, gc); + gcMARK2(c->i, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Complex)); } -static int complex_obj_FIXUP(void *p) { +static int complex_obj_FIXUP(void *p, struct NewGC *gc) { Scheme_Complex *c = (Scheme_Complex *)p; - gcFIXUP(c->r); - gcFIXUP(c->i); + gcFIXUP2(c->r, gc); + gcFIXUP2(c->i, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Complex)); @@ -1309,22 +1309,22 @@ static int complex_obj_FIXUP(void *p) { #define complex_obj_IS_CONST_SIZE 1 -static int string_obj_SIZE(void *p) { +static int string_obj_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); } -static int string_obj_MARK(void *p) { +static int string_obj_MARK(void *p, struct NewGC *gc) { Scheme_Object *o = (Scheme_Object *)p; - gcMARK(SCHEME_CHAR_STR_VAL(o)); + gcMARK2(SCHEME_CHAR_STR_VAL(o), gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); } -static int string_obj_FIXUP(void *p) { +static int string_obj_FIXUP(void *p, struct NewGC *gc) { Scheme_Object *o = (Scheme_Object *)p; - gcFIXUP(SCHEME_CHAR_STR_VAL(o)); + gcFIXUP2(SCHEME_CHAR_STR_VAL(o), gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); @@ -1334,22 +1334,22 @@ static int string_obj_FIXUP(void *p) { #define string_obj_IS_CONST_SIZE 1 -static int bstring_obj_SIZE(void *p) { +static int bstring_obj_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); } -static int bstring_obj_MARK(void *p) { +static int bstring_obj_MARK(void *p, struct NewGC *gc) { Scheme_Object *o = (Scheme_Object *)p; - gcMARK(SCHEME_BYTE_STR_VAL(o)); + gcMARK2(SCHEME_BYTE_STR_VAL(o), gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); } -static int bstring_obj_FIXUP(void *p) { +static int bstring_obj_FIXUP(void *p, struct NewGC *gc) { Scheme_Object *o = (Scheme_Object *)p; - gcFIXUP(SCHEME_BYTE_STR_VAL(o)); + gcFIXUP2(SCHEME_BYTE_STR_VAL(o), gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); @@ -1359,21 +1359,21 @@ static int bstring_obj_FIXUP(void *p) { #define bstring_obj_IS_CONST_SIZE 1 -static int symbol_obj_SIZE(void *p) { +static int symbol_obj_SIZE(void *p, struct NewGC *gc) { Scheme_Symbol *s = (Scheme_Symbol *)p; return gcBYTES_TO_WORDS(sizeof(Scheme_Symbol) + s->len - 3); } -static int symbol_obj_MARK(void *p) { +static int symbol_obj_MARK(void *p, struct NewGC *gc) { Scheme_Symbol *s = (Scheme_Symbol *)p; return gcBYTES_TO_WORDS(sizeof(Scheme_Symbol) + s->len - 3); } -static int symbol_obj_FIXUP(void *p) { +static int symbol_obj_FIXUP(void *p, struct NewGC *gc) { Scheme_Symbol *s = (Scheme_Symbol *)p; return @@ -1384,26 +1384,26 @@ static int symbol_obj_FIXUP(void *p) { #define symbol_obj_IS_CONST_SIZE 0 -static int cons_cell_SIZE(void *p) { +static int cons_cell_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); } -static int cons_cell_MARK(void *p) { +static int cons_cell_MARK(void *p, struct NewGC *gc) { Scheme_Object *o = (Scheme_Object *)p; - gcMARK(SCHEME_CAR(o)); - gcMARK(SCHEME_CDR(o)); + gcMARK2(SCHEME_CAR(o), gc); + gcMARK2(SCHEME_CDR(o), gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); } -static int cons_cell_FIXUP(void *p) { +static int cons_cell_FIXUP(void *p, struct NewGC *gc) { Scheme_Object *o = (Scheme_Object *)p; - gcFIXUP(SCHEME_CAR(o)); - gcFIXUP(SCHEME_CDR(o)); + gcFIXUP2(SCHEME_CAR(o), gc); + gcFIXUP2(SCHEME_CDR(o), gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); @@ -1413,7 +1413,7 @@ static int cons_cell_FIXUP(void *p) { #define cons_cell_IS_CONST_SIZE 1 -static int vector_obj_SIZE(void *p) { +static int vector_obj_SIZE(void *p, struct NewGC *gc) { Scheme_Vector *vec = (Scheme_Vector *)p; return @@ -1421,24 +1421,24 @@ static int vector_obj_SIZE(void *p) { + ((vec->size - 1) * sizeof(Scheme_Object *)))); } -static int vector_obj_MARK(void *p) { +static int vector_obj_MARK(void *p, struct NewGC *gc) { Scheme_Vector *vec = (Scheme_Vector *)p; int i; for (i = vec->size; i--; ) - gcMARK(vec->els[i]); + gcMARK2(vec->els[i], gc); return gcBYTES_TO_WORDS((sizeof(Scheme_Vector) + ((vec->size - 1) * sizeof(Scheme_Object *)))); } -static int vector_obj_FIXUP(void *p) { +static int vector_obj_FIXUP(void *p, struct NewGC *gc) { Scheme_Vector *vec = (Scheme_Vector *)p; int i; for (i = vec->size; i--; ) - gcFIXUP(vec->els[i]); + gcFIXUP2(vec->els[i], gc); return gcBYTES_TO_WORDS((sizeof(Scheme_Vector) @@ -1449,7 +1449,7 @@ static int vector_obj_FIXUP(void *p) { #define vector_obj_IS_CONST_SIZE 0 -static int flvector_obj_SIZE(void *p) { +static int flvector_obj_SIZE(void *p, struct NewGC *gc) { Scheme_Double_Vector *vec = (Scheme_Double_Vector *)p; return @@ -1457,7 +1457,7 @@ static int flvector_obj_SIZE(void *p) { + ((vec->size - 1) * sizeof(double)))); } -static int flvector_obj_MARK(void *p) { +static int flvector_obj_MARK(void *p, struct NewGC *gc) { Scheme_Double_Vector *vec = (Scheme_Double_Vector *)p; return @@ -1465,7 +1465,7 @@ static int flvector_obj_MARK(void *p) { + ((vec->size - 1) * sizeof(double)))); } -static int flvector_obj_FIXUP(void *p) { +static int flvector_obj_FIXUP(void *p, struct NewGC *gc) { Scheme_Double_Vector *vec = (Scheme_Double_Vector *)p; return @@ -1477,56 +1477,56 @@ static int flvector_obj_FIXUP(void *p) { #define flvector_obj_IS_CONST_SIZE 0 -static int input_port_SIZE(void *p) { +static int input_port_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Input_Port)); } -static int input_port_MARK(void *p) { +static int input_port_MARK(void *p, struct NewGC *gc) { Scheme_Input_Port *ip = (Scheme_Input_Port *)p; - gcMARK(ip->sub_type); - gcMARK(ip->port_data); - gcMARK(ip->name); - gcMARK(ip->peeked_read); - gcMARK(ip->peeked_write); - gcMARK(ip->read_handler); - gcMARK(ip->mref); - gcMARK(ip->output_half); - gcMARK(ip->special); - gcMARK(ip->ungotten_special); - gcMARK(ip->progress_evt); - gcMARK(ip->input_lock); - gcMARK(ip->input_giveup); - gcMARK(ip->input_extras); - gcMARK(ip->input_extras_ready); - gcMARK(ip->unless); - gcMARK(ip->unless_cache); + gcMARK2(ip->sub_type, gc); + gcMARK2(ip->port_data, gc); + gcMARK2(ip->name, gc); + gcMARK2(ip->peeked_read, gc); + gcMARK2(ip->peeked_write, gc); + gcMARK2(ip->read_handler, gc); + gcMARK2(ip->mref, gc); + gcMARK2(ip->output_half, gc); + gcMARK2(ip->special, gc); + gcMARK2(ip->ungotten_special, gc); + gcMARK2(ip->progress_evt, gc); + gcMARK2(ip->input_lock, gc); + gcMARK2(ip->input_giveup, gc); + gcMARK2(ip->input_extras, gc); + gcMARK2(ip->input_extras_ready, gc); + gcMARK2(ip->unless, gc); + gcMARK2(ip->unless_cache, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Input_Port)); } -static int input_port_FIXUP(void *p) { +static int input_port_FIXUP(void *p, struct NewGC *gc) { Scheme_Input_Port *ip = (Scheme_Input_Port *)p; - gcFIXUP(ip->sub_type); - gcFIXUP(ip->port_data); - gcFIXUP(ip->name); - gcFIXUP(ip->peeked_read); - gcFIXUP(ip->peeked_write); - gcFIXUP(ip->read_handler); - gcFIXUP(ip->mref); - gcFIXUP(ip->output_half); - gcFIXUP(ip->special); - gcFIXUP(ip->ungotten_special); - gcFIXUP(ip->progress_evt); - gcFIXUP(ip->input_lock); - gcFIXUP(ip->input_giveup); - gcFIXUP(ip->input_extras); - gcFIXUP(ip->input_extras_ready); - gcFIXUP(ip->unless); - gcFIXUP(ip->unless_cache); + gcFIXUP2(ip->sub_type, gc); + gcFIXUP2(ip->port_data, gc); + gcFIXUP2(ip->name, gc); + gcFIXUP2(ip->peeked_read, gc); + gcFIXUP2(ip->peeked_write, gc); + gcFIXUP2(ip->read_handler, gc); + gcFIXUP2(ip->mref, gc); + gcFIXUP2(ip->output_half, gc); + gcFIXUP2(ip->special, gc); + gcFIXUP2(ip->ungotten_special, gc); + gcFIXUP2(ip->progress_evt, gc); + gcFIXUP2(ip->input_lock, gc); + gcFIXUP2(ip->input_giveup, gc); + gcFIXUP2(ip->input_extras, gc); + gcFIXUP2(ip->input_extras_ready, gc); + gcFIXUP2(ip->unless, gc); + gcFIXUP2(ip->unless_cache, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Input_Port)); @@ -1536,38 +1536,38 @@ static int input_port_FIXUP(void *p) { #define input_port_IS_CONST_SIZE 1 -static int output_port_SIZE(void *p) { +static int output_port_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Output_Port)); } -static int output_port_MARK(void *p) { +static int output_port_MARK(void *p, struct NewGC *gc) { Scheme_Output_Port *op = (Scheme_Output_Port *)p; - gcMARK(op->sub_type); - gcMARK(op->port_data); - gcMARK(op->name); - gcMARK(op->display_handler); - gcMARK(op->write_handler); - gcMARK(op->print_handler); - gcMARK(op->mref); - gcMARK(op->input_half); + gcMARK2(op->sub_type, gc); + gcMARK2(op->port_data, gc); + gcMARK2(op->name, gc); + gcMARK2(op->display_handler, gc); + gcMARK2(op->write_handler, gc); + gcMARK2(op->print_handler, gc); + gcMARK2(op->mref, gc); + gcMARK2(op->input_half, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Output_Port)); } -static int output_port_FIXUP(void *p) { +static int output_port_FIXUP(void *p, struct NewGC *gc) { Scheme_Output_Port *op = (Scheme_Output_Port *)p; - gcFIXUP(op->sub_type); - gcFIXUP(op->port_data); - gcFIXUP(op->name); - gcFIXUP(op->display_handler); - gcFIXUP(op->write_handler); - gcFIXUP(op->print_handler); - gcFIXUP(op->mref); - gcFIXUP(op->input_half); + gcFIXUP2(op->sub_type, gc); + gcFIXUP2(op->port_data, gc); + gcFIXUP2(op->name, gc); + gcFIXUP2(op->display_handler, gc); + gcFIXUP2(op->write_handler, gc); + gcFIXUP2(op->print_handler, gc); + gcFIXUP2(op->mref, gc); + gcFIXUP2(op->input_half, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Output_Port)); @@ -1578,17 +1578,17 @@ static int output_port_FIXUP(void *p) { -static int syntax_compiler_SIZE(void *p) { +static int syntax_compiler_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); } -static int syntax_compiler_MARK(void *p) { +static int syntax_compiler_MARK(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); } -static int syntax_compiler_FIXUP(void *p) { +static int syntax_compiler_FIXUP(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); } @@ -1597,231 +1597,231 @@ static int syntax_compiler_FIXUP(void *p) { #define syntax_compiler_IS_CONST_SIZE 1 -static int thread_val_SIZE(void *p) { +static int thread_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Thread)); } -static int thread_val_MARK(void *p) { +static int thread_val_MARK(void *p, struct NewGC *gc) { Scheme_Thread *pr = (Scheme_Thread *)p; - gcMARK(pr->next); - gcMARK(pr->prev); + gcMARK2(pr->next, gc); + gcMARK2(pr->prev, gc); - gcMARK(pr->t_set_parent); - gcMARK(pr->t_set_next); - gcMARK(pr->t_set_prev); + gcMARK2(pr->t_set_parent, gc); + gcMARK2(pr->t_set_next, gc); + gcMARK2(pr->t_set_prev, gc); - MARK_cjs(&pr->cjs); - gcMARK(pr->decompose_mc); + MARK_cjs(&pr->cjs, gc); + gcMARK2(pr->decompose_mc, gc); - gcMARK(pr->cell_values); - gcMARK(pr->init_config); - gcMARK(pr->init_break_cell); + gcMARK2(pr->cell_values, gc); + gcMARK2(pr->init_config, gc); + gcMARK2(pr->init_break_cell, gc); if (!pr->runstack_owner || !GC_merely_accounting() || (*pr->runstack_owner == pr)) { Scheme_Object **rs = pr->runstack_start; - gcMARK( pr->runstack_start); + gcMARK2( pr->runstack_start, gc); if (pr->runstack != pr->runstack_start + (pr->runstack - rs)) pr->runstack = pr->runstack_start + (pr->runstack - rs); - gcMARK(pr->runstack_saved); + gcMARK2(pr->runstack_saved, gc); } - gcMARK(pr->runstack_owner); - gcMARK(pr->runstack_swapped); + gcMARK2(pr->runstack_owner, gc); + gcMARK2(pr->runstack_swapped, gc); pr->spare_runstack = NULL; /* just in case */ - gcMARK(pr->meta_prompt); - gcMARK(pr->meta_continuation); + gcMARK2(pr->meta_prompt, gc); + gcMARK2(pr->meta_continuation, gc); - gcMARK(pr->cont_mark_stack_segments); - gcMARK(pr->cont_mark_stack_owner); - gcMARK(pr->cont_mark_stack_swapped); + gcMARK2(pr->cont_mark_stack_segments, gc); + gcMARK2(pr->cont_mark_stack_owner, gc); + gcMARK2(pr->cont_mark_stack_swapped, gc); - MARK_jmpup(&pr->jmpup_buf); + MARK_jmpup(&pr->jmpup_buf, gc); - gcMARK(pr->dw); + gcMARK2(pr->dw, gc); - gcMARK(pr->nester); - gcMARK(pr->nestee); + gcMARK2(pr->nester, gc); + gcMARK2(pr->nestee, gc); - gcMARK(pr->blocker); - gcMARK(pr->overflow); + gcMARK2(pr->blocker, gc); + gcMARK2(pr->overflow, gc); - gcMARK(pr->return_marks_to); - gcMARK(pr->returned_marks); + gcMARK2(pr->return_marks_to, gc); + gcMARK2(pr->returned_marks, gc); - gcMARK(pr->current_local_env); - gcMARK(pr->current_local_mark); - gcMARK(pr->current_local_name); - gcMARK(pr->current_local_certs); - gcMARK(pr->current_local_modidx); - gcMARK(pr->current_local_menv); - gcMARK(pr->current_local_bindings); + gcMARK2(pr->current_local_env, gc); + gcMARK2(pr->current_local_mark, gc); + gcMARK2(pr->current_local_name, gc); + gcMARK2(pr->current_local_certs, gc); + gcMARK2(pr->current_local_modidx, gc); + gcMARK2(pr->current_local_menv, gc); + gcMARK2(pr->current_local_bindings, gc); - gcMARK(pr->current_mt); + gcMARK2(pr->current_mt, gc); - gcMARK(pr->constant_folding); - gcMARK(pr->reading_delayed); + gcMARK2(pr->constant_folding, gc); + gcMARK2(pr->reading_delayed, gc); - gcMARK(pr->overflow_reply); + gcMARK2(pr->overflow_reply, gc); - gcMARK(pr->values_buffer); + gcMARK2(pr->values_buffer, gc); - gcMARK(pr->tail_buffer); + gcMARK2(pr->tail_buffer, gc); - gcMARK(pr->ku.eval.wait_expr); + gcMARK2(pr->ku.eval.wait_expr, gc); - gcMARK(pr->ku.apply.tail_rator); - gcMARK(pr->ku.apply.tail_rands); + gcMARK2(pr->ku.apply.tail_rator, gc); + gcMARK2(pr->ku.apply.tail_rands, gc); - gcMARK(pr->ku.multiple.array); + gcMARK2(pr->ku.multiple.array, gc); - gcMARK(pr->ku.k.p1); - gcMARK(pr->ku.k.p2); - gcMARK(pr->ku.k.p3); - gcMARK(pr->ku.k.p4); - gcMARK(pr->ku.k.p5); + gcMARK2(pr->ku.k.p1, gc); + gcMARK2(pr->ku.k.p2, gc); + gcMARK2(pr->ku.k.p3, gc); + gcMARK2(pr->ku.k.p4, gc); + gcMARK2(pr->ku.k.p5, gc); - gcMARK(pr->list_stack); + gcMARK2(pr->list_stack, gc); - gcMARK(pr->kill_data); - gcMARK(pr->private_kill_data); - gcMARK(pr->private_kill_next); + gcMARK2(pr->kill_data, gc); + gcMARK2(pr->private_kill_data, gc); + gcMARK2(pr->private_kill_next, gc); - gcMARK(pr->user_tls); - gcMARK(pr->gmp_tls_data); + gcMARK2(pr->user_tls, gc); + gcMARK2(pr->gmp_tls_data, gc); - gcMARK(pr->mr_hop); - gcMARK(pr->mref); - gcMARK(pr->extra_mrefs); + gcMARK2(pr->mr_hop, gc); + gcMARK2(pr->mref, gc); + gcMARK2(pr->extra_mrefs, gc); - gcMARK(pr->name); + gcMARK2(pr->name, gc); - gcMARK(pr->transitive_resumes); + gcMARK2(pr->transitive_resumes, gc); - gcMARK(pr->suspended_box); - gcMARK(pr->resumed_box); - gcMARK(pr->dead_box); - gcMARK(pr->running_box); + gcMARK2(pr->suspended_box, gc); + gcMARK2(pr->resumed_box, gc); + gcMARK2(pr->dead_box, gc); + gcMARK2(pr->running_box, gc); - gcMARK(pr->mbox_first); - gcMARK(pr->mbox_last); - gcMARK(pr->mbox_sema); + gcMARK2(pr->mbox_first, gc); + gcMARK2(pr->mbox_last, gc); + gcMARK2(pr->mbox_sema, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Thread)); } -static int thread_val_FIXUP(void *p) { +static int thread_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Thread *pr = (Scheme_Thread *)p; - gcFIXUP(pr->next); - gcFIXUP(pr->prev); + gcFIXUP2(pr->next, gc); + gcFIXUP2(pr->prev, gc); - gcFIXUP(pr->t_set_parent); - gcFIXUP(pr->t_set_next); - gcFIXUP(pr->t_set_prev); + gcFIXUP2(pr->t_set_parent, gc); + gcFIXUP2(pr->t_set_next, gc); + gcFIXUP2(pr->t_set_prev, gc); - FIXUP_cjs(&pr->cjs); - gcFIXUP(pr->decompose_mc); + FIXUP_cjs(&pr->cjs, gc); + gcFIXUP2(pr->decompose_mc, gc); - gcFIXUP(pr->cell_values); - gcFIXUP(pr->init_config); - gcFIXUP(pr->init_break_cell); + gcFIXUP2(pr->cell_values, gc); + gcFIXUP2(pr->init_config, gc); + gcFIXUP2(pr->init_break_cell, gc); if (!pr->runstack_owner || !GC_merely_accounting() || (*pr->runstack_owner == pr)) { Scheme_Object **rs = pr->runstack_start; - gcFIXUP_TYPED_NOW(Scheme_Object **, pr->runstack_start); + gcFIXUP2_TYPED_NOW(Scheme_Object **, pr->runstack_start, gc); if (pr->runstack != pr->runstack_start + (pr->runstack - rs)) pr->runstack = pr->runstack_start + (pr->runstack - rs); - gcFIXUP(pr->runstack_saved); + gcFIXUP2(pr->runstack_saved, gc); } - gcFIXUP(pr->runstack_owner); - gcFIXUP(pr->runstack_swapped); + gcFIXUP2(pr->runstack_owner, gc); + gcFIXUP2(pr->runstack_swapped, gc); pr->spare_runstack = NULL; /* just in case */ - gcFIXUP(pr->meta_prompt); - gcFIXUP(pr->meta_continuation); + gcFIXUP2(pr->meta_prompt, gc); + gcFIXUP2(pr->meta_continuation, gc); - gcFIXUP(pr->cont_mark_stack_segments); - gcFIXUP(pr->cont_mark_stack_owner); - gcFIXUP(pr->cont_mark_stack_swapped); + gcFIXUP2(pr->cont_mark_stack_segments, gc); + gcFIXUP2(pr->cont_mark_stack_owner, gc); + gcFIXUP2(pr->cont_mark_stack_swapped, gc); - FIXUP_jmpup(&pr->jmpup_buf); + FIXUP_jmpup(&pr->jmpup_buf, gc); - gcFIXUP(pr->dw); + gcFIXUP2(pr->dw, gc); - gcFIXUP(pr->nester); - gcFIXUP(pr->nestee); + gcFIXUP2(pr->nester, gc); + gcFIXUP2(pr->nestee, gc); - gcFIXUP(pr->blocker); - gcFIXUP(pr->overflow); + gcFIXUP2(pr->blocker, gc); + gcFIXUP2(pr->overflow, gc); - gcFIXUP(pr->return_marks_to); - gcFIXUP(pr->returned_marks); + gcFIXUP2(pr->return_marks_to, gc); + gcFIXUP2(pr->returned_marks, gc); - gcFIXUP(pr->current_local_env); - gcFIXUP(pr->current_local_mark); - gcFIXUP(pr->current_local_name); - gcFIXUP(pr->current_local_certs); - gcFIXUP(pr->current_local_modidx); - gcFIXUP(pr->current_local_menv); - gcFIXUP(pr->current_local_bindings); + gcFIXUP2(pr->current_local_env, gc); + gcFIXUP2(pr->current_local_mark, gc); + gcFIXUP2(pr->current_local_name, gc); + gcFIXUP2(pr->current_local_certs, gc); + gcFIXUP2(pr->current_local_modidx, gc); + gcFIXUP2(pr->current_local_menv, gc); + gcFIXUP2(pr->current_local_bindings, gc); - gcFIXUP(pr->current_mt); + gcFIXUP2(pr->current_mt, gc); - gcFIXUP(pr->constant_folding); - gcFIXUP(pr->reading_delayed); + gcFIXUP2(pr->constant_folding, gc); + gcFIXUP2(pr->reading_delayed, gc); - gcFIXUP(pr->overflow_reply); + gcFIXUP2(pr->overflow_reply, gc); - gcFIXUP(pr->values_buffer); + gcFIXUP2(pr->values_buffer, gc); - gcFIXUP(pr->tail_buffer); + gcFIXUP2(pr->tail_buffer, gc); - gcFIXUP(pr->ku.eval.wait_expr); + gcFIXUP2(pr->ku.eval.wait_expr, gc); - gcFIXUP(pr->ku.apply.tail_rator); - gcFIXUP(pr->ku.apply.tail_rands); + gcFIXUP2(pr->ku.apply.tail_rator, gc); + gcFIXUP2(pr->ku.apply.tail_rands, gc); - gcFIXUP(pr->ku.multiple.array); + gcFIXUP2(pr->ku.multiple.array, gc); - gcFIXUP(pr->ku.k.p1); - gcFIXUP(pr->ku.k.p2); - gcFIXUP(pr->ku.k.p3); - gcFIXUP(pr->ku.k.p4); - gcFIXUP(pr->ku.k.p5); + gcFIXUP2(pr->ku.k.p1, gc); + gcFIXUP2(pr->ku.k.p2, gc); + gcFIXUP2(pr->ku.k.p3, gc); + gcFIXUP2(pr->ku.k.p4, gc); + gcFIXUP2(pr->ku.k.p5, gc); - gcFIXUP(pr->list_stack); + gcFIXUP2(pr->list_stack, gc); - gcFIXUP(pr->kill_data); - gcFIXUP(pr->private_kill_data); - gcFIXUP(pr->private_kill_next); + gcFIXUP2(pr->kill_data, gc); + gcFIXUP2(pr->private_kill_data, gc); + gcFIXUP2(pr->private_kill_next, gc); - gcFIXUP(pr->user_tls); - gcFIXUP(pr->gmp_tls_data); + gcFIXUP2(pr->user_tls, gc); + gcFIXUP2(pr->gmp_tls_data, gc); - gcFIXUP(pr->mr_hop); - gcFIXUP(pr->mref); - gcFIXUP(pr->extra_mrefs); + gcFIXUP2(pr->mr_hop, gc); + gcFIXUP2(pr->mref, gc); + gcFIXUP2(pr->extra_mrefs, gc); - gcFIXUP(pr->name); + gcFIXUP2(pr->name, gc); - gcFIXUP(pr->transitive_resumes); + gcFIXUP2(pr->transitive_resumes, gc); - gcFIXUP(pr->suspended_box); - gcFIXUP(pr->resumed_box); - gcFIXUP(pr->dead_box); - gcFIXUP(pr->running_box); + gcFIXUP2(pr->suspended_box, gc); + gcFIXUP2(pr->resumed_box, gc); + gcFIXUP2(pr->dead_box, gc); + gcFIXUP2(pr->running_box, gc); - gcFIXUP(pr->mbox_first); - gcFIXUP(pr->mbox_last); - gcFIXUP(pr->mbox_sema); + gcFIXUP2(pr->mbox_first, gc); + gcFIXUP2(pr->mbox_last, gc); + gcFIXUP2(pr->mbox_sema, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Thread)); } @@ -1830,32 +1830,32 @@ static int thread_val_FIXUP(void *p) { #define thread_val_IS_CONST_SIZE 1 -static int runstack_val_SIZE(void *p) { +static int runstack_val_SIZE(void *p, struct NewGC *gc) { long *s = (long *)p; return s[1]; } -static int runstack_val_MARK(void *p) { +static int runstack_val_MARK(void *p, struct NewGC *gc) { long *s = (long *)p; void **a, **b; a = (void **)s + 4 + s[2]; b = (void **)s + 4 + s[3]; while (a < b) { - gcMARK(*a); + gcMARK2(*a, gc); a++; } return s[1]; } -static int runstack_val_FIXUP(void *p) { +static int runstack_val_FIXUP(void *p, struct NewGC *gc) { long *s = (long *)p; void **a, **b; a = (void **)s + 4 + s[2]; b = (void **)s + 4 + s[3]; while (a < b) { - gcFIXUP(*a); + gcFIXUP2(*a, gc); a++; } @@ -1881,29 +1881,29 @@ static int runstack_val_FIXUP(void *p) { #define runstack_val_IS_CONST_SIZE 0 -static int prompt_val_SIZE(void *p) { +static int prompt_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Prompt)); } -static int prompt_val_MARK(void *p) { +static int prompt_val_MARK(void *p, struct NewGC *gc) { Scheme_Prompt *pr = (Scheme_Prompt *)p; - gcMARK(pr->boundary_overflow_id); + gcMARK2(pr->boundary_overflow_id, gc); if (!GC_merely_accounting()) - gcMARK(pr->runstack_boundary_start); - gcMARK(pr->tag); - gcMARK(pr->id); + gcMARK2(pr->runstack_boundary_start, gc); + gcMARK2(pr->tag, gc); + gcMARK2(pr->id, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Prompt)); } -static int prompt_val_FIXUP(void *p) { +static int prompt_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Prompt *pr = (Scheme_Prompt *)p; - gcFIXUP(pr->boundary_overflow_id); + gcFIXUP2(pr->boundary_overflow_id, gc); if (!GC_merely_accounting()) - gcFIXUP(pr->runstack_boundary_start); - gcFIXUP(pr->tag); - gcFIXUP(pr->id); + gcFIXUP2(pr->runstack_boundary_start, gc); + gcFIXUP2(pr->tag, gc); + gcFIXUP2(pr->id, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Prompt)); } @@ -1912,24 +1912,24 @@ static int prompt_val_FIXUP(void *p) { #define prompt_val_IS_CONST_SIZE 1 -static int cont_mark_set_val_SIZE(void *p) { +static int cont_mark_set_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Set)); } -static int cont_mark_set_val_MARK(void *p) { +static int cont_mark_set_val_MARK(void *p, struct NewGC *gc) { Scheme_Cont_Mark_Set *s = (Scheme_Cont_Mark_Set *)p; - gcMARK(s->chain); - gcMARK(s->native_stack_trace); + gcMARK2(s->chain, gc); + gcMARK2(s->native_stack_trace, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Set)); } -static int cont_mark_set_val_FIXUP(void *p) { +static int cont_mark_set_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Cont_Mark_Set *s = (Scheme_Cont_Mark_Set *)p; - gcFIXUP(s->chain); - gcFIXUP(s->native_stack_trace); + gcFIXUP2(s->chain, gc); + gcFIXUP2(s->native_stack_trace, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Set)); @@ -1939,26 +1939,26 @@ static int cont_mark_set_val_FIXUP(void *p) { #define cont_mark_set_val_IS_CONST_SIZE 1 -static int sema_val_SIZE(void *p) { +static int sema_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Sema)); } -static int sema_val_MARK(void *p) { +static int sema_val_MARK(void *p, struct NewGC *gc) { Scheme_Sema *s = (Scheme_Sema *)p; - gcMARK(s->first); - gcMARK(s->last); + gcMARK2(s->first, gc); + gcMARK2(s->last, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Sema)); } -static int sema_val_FIXUP(void *p) { +static int sema_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Sema *s = (Scheme_Sema *)p; - gcFIXUP(s->first); - gcFIXUP(s->last); + gcFIXUP2(s->first, gc); + gcFIXUP2(s->last, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Sema)); @@ -1968,30 +1968,30 @@ static int sema_val_FIXUP(void *p) { #define sema_val_IS_CONST_SIZE 1 -static int channel_val_SIZE(void *p) { +static int channel_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Channel)); } -static int channel_val_MARK(void *p) { +static int channel_val_MARK(void *p, struct NewGC *gc) { Scheme_Channel *s = (Scheme_Channel *)p; - gcMARK(s->get_first); - gcMARK(s->get_last); - gcMARK(s->put_first); - gcMARK(s->put_last); + gcMARK2(s->get_first, gc); + gcMARK2(s->get_last, gc); + gcMARK2(s->put_first, gc); + gcMARK2(s->put_last, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Channel)); } -static int channel_val_FIXUP(void *p) { +static int channel_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Channel *s = (Scheme_Channel *)p; - gcFIXUP(s->get_first); - gcFIXUP(s->get_last); - gcFIXUP(s->put_first); - gcFIXUP(s->put_last); + gcFIXUP2(s->get_first, gc); + gcFIXUP2(s->get_last, gc); + gcFIXUP2(s->put_first, gc); + gcFIXUP2(s->put_last, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Channel)); @@ -2001,26 +2001,26 @@ static int channel_val_FIXUP(void *p) { #define channel_val_IS_CONST_SIZE 1 -static int channel_put_val_SIZE(void *p) { +static int channel_put_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Put)); } -static int channel_put_val_MARK(void *p) { +static int channel_put_val_MARK(void *p, struct NewGC *gc) { Scheme_Channel_Put *s = (Scheme_Channel_Put *)p; - gcMARK(s->ch); - gcMARK(s->val); + gcMARK2(s->ch, gc); + gcMARK2(s->val, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Put)); } -static int channel_put_val_FIXUP(void *p) { +static int channel_put_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Channel_Put *s = (Scheme_Channel_Put *)p; - gcFIXUP(s->ch); - gcFIXUP(s->val); + gcFIXUP2(s->ch, gc); + gcFIXUP2(s->val, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Put)); @@ -2030,28 +2030,28 @@ static int channel_put_val_FIXUP(void *p) { #define channel_put_val_IS_CONST_SIZE 1 -static int hash_table_val_SIZE(void *p) { +static int hash_table_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Table)); } -static int hash_table_val_MARK(void *p) { +static int hash_table_val_MARK(void *p, struct NewGC *gc) { Scheme_Hash_Table *ht = (Scheme_Hash_Table *)p; - gcMARK(ht->keys); - gcMARK(ht->vals); - gcMARK(ht->mutex); + gcMARK2(ht->keys, gc); + gcMARK2(ht->vals, gc); + gcMARK2(ht->mutex, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Table)); } -static int hash_table_val_FIXUP(void *p) { +static int hash_table_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Hash_Table *ht = (Scheme_Hash_Table *)p; - gcFIXUP(ht->keys); - gcFIXUP(ht->vals); - gcFIXUP(ht->mutex); + gcFIXUP2(ht->keys, gc); + gcFIXUP2(ht->vals, gc); + gcFIXUP2(ht->mutex, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Table)); @@ -2061,26 +2061,26 @@ static int hash_table_val_FIXUP(void *p) { #define hash_table_val_IS_CONST_SIZE 1 -static int bucket_table_val_SIZE(void *p) { +static int bucket_table_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_Table)); } -static int bucket_table_val_MARK(void *p) { +static int bucket_table_val_MARK(void *p, struct NewGC *gc) { Scheme_Bucket_Table *ht = (Scheme_Bucket_Table *)p; - gcMARK(ht->buckets); - gcMARK(ht->mutex); + gcMARK2(ht->buckets, gc); + gcMARK2(ht->mutex, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_Table)); } -static int bucket_table_val_FIXUP(void *p) { +static int bucket_table_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Bucket_Table *ht = (Scheme_Bucket_Table *)p; - gcFIXUP(ht->buckets); - gcFIXUP(ht->mutex); + gcFIXUP2(ht->buckets, gc); + gcFIXUP2(ht->mutex, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_Table)); @@ -2090,83 +2090,83 @@ static int bucket_table_val_FIXUP(void *p) { #define bucket_table_val_IS_CONST_SIZE 1 -static int namespace_val_SIZE(void *p) { +static int namespace_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Env)); } -static int namespace_val_MARK(void *p) { +static int namespace_val_MARK(void *p, struct NewGC *gc) { Scheme_Env *e = (Scheme_Env *)p; - gcMARK(e->module); - gcMARK(e->module_registry); - gcMARK(e->export_registry); - gcMARK(e->insp); + gcMARK2(e->module, gc); + gcMARK2(e->module_registry, gc); + gcMARK2(e->export_registry, gc); + gcMARK2(e->insp, gc); - gcMARK(e->rename_set); - gcMARK(e->temp_marked_names); - gcMARK(e->post_ex_rename_set); + gcMARK2(e->rename_set, gc); + gcMARK2(e->temp_marked_names, gc); + gcMARK2(e->post_ex_rename_set, gc); - gcMARK(e->syntax); - gcMARK(e->exp_env); - gcMARK(e->template_env); - gcMARK(e->label_env); + gcMARK2(e->syntax, gc); + gcMARK2(e->exp_env, gc); + gcMARK2(e->template_env, gc); + gcMARK2(e->label_env, gc); - gcMARK(e->shadowed_syntax); + gcMARK2(e->shadowed_syntax, gc); - gcMARK(e->link_midx); - gcMARK(e->require_names); - gcMARK(e->et_require_names); - gcMARK(e->tt_require_names); - gcMARK(e->dt_require_names); - gcMARK(e->other_require_names); - gcMARK(e->did_starts); - gcMARK(e->available_next[0]); - gcMARK(e->available_next[1]); + gcMARK2(e->link_midx, gc); + gcMARK2(e->require_names, gc); + gcMARK2(e->et_require_names, gc); + gcMARK2(e->tt_require_names, gc); + gcMARK2(e->dt_require_names, gc); + gcMARK2(e->other_require_names, gc); + gcMARK2(e->did_starts, gc); + gcMARK2(e->available_next[0], gc); + gcMARK2(e->available_next[1], gc); - gcMARK(e->toplevel); - gcMARK(e->modchain); + gcMARK2(e->toplevel, gc); + gcMARK2(e->modchain, gc); - gcMARK(e->modvars); + gcMARK2(e->modvars, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Env)); } -static int namespace_val_FIXUP(void *p) { +static int namespace_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Env *e = (Scheme_Env *)p; - gcFIXUP(e->module); - gcFIXUP(e->module_registry); - gcFIXUP(e->export_registry); - gcFIXUP(e->insp); + gcFIXUP2(e->module, gc); + gcFIXUP2(e->module_registry, gc); + gcFIXUP2(e->export_registry, gc); + gcFIXUP2(e->insp, gc); - gcFIXUP(e->rename_set); - gcFIXUP(e->temp_marked_names); - gcFIXUP(e->post_ex_rename_set); + gcFIXUP2(e->rename_set, gc); + gcFIXUP2(e->temp_marked_names, gc); + gcFIXUP2(e->post_ex_rename_set, gc); - gcFIXUP(e->syntax); - gcFIXUP(e->exp_env); - gcFIXUP(e->template_env); - gcFIXUP(e->label_env); + gcFIXUP2(e->syntax, gc); + gcFIXUP2(e->exp_env, gc); + gcFIXUP2(e->template_env, gc); + gcFIXUP2(e->label_env, gc); - gcFIXUP(e->shadowed_syntax); + gcFIXUP2(e->shadowed_syntax, gc); - gcFIXUP(e->link_midx); - gcFIXUP(e->require_names); - gcFIXUP(e->et_require_names); - gcFIXUP(e->tt_require_names); - gcFIXUP(e->dt_require_names); - gcFIXUP(e->other_require_names); - gcFIXUP(e->did_starts); - gcFIXUP(e->available_next[0]); - gcFIXUP(e->available_next[1]); + gcFIXUP2(e->link_midx, gc); + gcFIXUP2(e->require_names, gc); + gcFIXUP2(e->et_require_names, gc); + gcFIXUP2(e->tt_require_names, gc); + gcFIXUP2(e->dt_require_names, gc); + gcFIXUP2(e->other_require_names, gc); + gcFIXUP2(e->did_starts, gc); + gcFIXUP2(e->available_next[0], gc); + gcFIXUP2(e->available_next[1], gc); - gcFIXUP(e->toplevel); - gcFIXUP(e->modchain); + gcFIXUP2(e->toplevel, gc); + gcFIXUP2(e->modchain, gc); - gcFIXUP(e->modvars); + gcFIXUP2(e->modvars, gc); return @@ -2177,17 +2177,17 @@ static int namespace_val_FIXUP(void *p) { #define namespace_val_IS_CONST_SIZE 1 -static int random_state_val_SIZE(void *p) { +static int random_state_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Random_State)); } -static int random_state_val_MARK(void *p) { +static int random_state_val_MARK(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Random_State)); } -static int random_state_val_FIXUP(void *p) { +static int random_state_val_FIXUP(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Random_State)); } @@ -2196,24 +2196,24 @@ static int random_state_val_FIXUP(void *p) { #define random_state_val_IS_CONST_SIZE 1 -static int compilation_top_val_SIZE(void *p) { +static int compilation_top_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Compilation_Top)); } -static int compilation_top_val_MARK(void *p) { +static int compilation_top_val_MARK(void *p, struct NewGC *gc) { Scheme_Compilation_Top *t = (Scheme_Compilation_Top *)p; - gcMARK(t->code); - gcMARK(t->prefix); + gcMARK2(t->code, gc); + gcMARK2(t->prefix, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Compilation_Top)); } -static int compilation_top_val_FIXUP(void *p) { +static int compilation_top_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Compilation_Top *t = (Scheme_Compilation_Top *)p; - gcFIXUP(t->code); - gcFIXUP(t->prefix); + gcFIXUP2(t->code, gc); + gcFIXUP2(t->prefix, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Compilation_Top)); @@ -2223,28 +2223,28 @@ static int compilation_top_val_FIXUP(void *p) { #define compilation_top_val_IS_CONST_SIZE 1 -static int resolve_prefix_val_SIZE(void *p) { +static int resolve_prefix_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Resolve_Prefix)); } -static int resolve_prefix_val_MARK(void *p) { +static int resolve_prefix_val_MARK(void *p, struct NewGC *gc) { Resolve_Prefix *rp = (Resolve_Prefix *)p; - gcMARK(rp->toplevels); - gcMARK(rp->stxes); - gcMARK(rp->delay_info_rpair); - gcMARK(rp->uses_unsafe); + gcMARK2(rp->toplevels, gc); + gcMARK2(rp->stxes, gc); + gcMARK2(rp->delay_info_rpair, gc); + gcMARK2(rp->uses_unsafe, gc); return gcBYTES_TO_WORDS(sizeof(Resolve_Prefix)); } -static int resolve_prefix_val_FIXUP(void *p) { +static int resolve_prefix_val_FIXUP(void *p, struct NewGC *gc) { Resolve_Prefix *rp = (Resolve_Prefix *)p; - gcFIXUP(rp->toplevels); - gcFIXUP(rp->stxes); - gcFIXUP(rp->delay_info_rpair); - gcFIXUP(rp->uses_unsafe); + gcFIXUP2(rp->toplevels, gc); + gcFIXUP2(rp->stxes, gc); + gcFIXUP2(rp->delay_info_rpair, gc); + gcFIXUP2(rp->uses_unsafe, gc); return gcBYTES_TO_WORDS(sizeof(Resolve_Prefix)); @@ -2254,26 +2254,26 @@ static int resolve_prefix_val_FIXUP(void *p) { #define resolve_prefix_val_IS_CONST_SIZE 1 -static int comp_prefix_val_SIZE(void *p) { +static int comp_prefix_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Comp_Prefix)); } -static int comp_prefix_val_MARK(void *p) { +static int comp_prefix_val_MARK(void *p, struct NewGC *gc) { Comp_Prefix *cp = (Comp_Prefix *)p; - gcMARK(cp->toplevels); - gcMARK(cp->stxes); - gcMARK(cp->uses_unsafe); + gcMARK2(cp->toplevels, gc); + gcMARK2(cp->stxes, gc); + gcMARK2(cp->uses_unsafe, gc); return gcBYTES_TO_WORDS(sizeof(Comp_Prefix)); } -static int comp_prefix_val_FIXUP(void *p) { +static int comp_prefix_val_FIXUP(void *p, struct NewGC *gc) { Comp_Prefix *cp = (Comp_Prefix *)p; - gcFIXUP(cp->toplevels); - gcFIXUP(cp->stxes); - gcFIXUP(cp->uses_unsafe); + gcFIXUP2(cp->toplevels, gc); + gcFIXUP2(cp->stxes, gc); + gcFIXUP2(cp->uses_unsafe, gc); return gcBYTES_TO_WORDS(sizeof(Comp_Prefix)); @@ -2283,24 +2283,24 @@ static int comp_prefix_val_FIXUP(void *p) { #define comp_prefix_val_IS_CONST_SIZE 1 -static int svector_val_SIZE(void *p) { +static int svector_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); } -static int svector_val_MARK(void *p) { +static int svector_val_MARK(void *p, struct NewGC *gc) { Scheme_Object *o = (Scheme_Object *)p; - gcMARK(SCHEME_SVEC_VEC(o)); + gcMARK2(SCHEME_SVEC_VEC(o), gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); } -static int svector_val_FIXUP(void *p) { +static int svector_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Object *o = (Scheme_Object *)p; - gcFIXUP(SCHEME_SVEC_VEC(o)); + gcFIXUP2(SCHEME_SVEC_VEC(o), gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); @@ -2310,33 +2310,33 @@ static int svector_val_FIXUP(void *p) { #define svector_val_IS_CONST_SIZE 1 -static int stx_val_SIZE(void *p) { +static int stx_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Stx)); } -static int stx_val_MARK(void *p) { +static int stx_val_MARK(void *p, struct NewGC *gc) { Scheme_Stx *stx = (Scheme_Stx *)p; - gcMARK(stx->val); - gcMARK(stx->srcloc); - gcMARK(stx->wraps); - gcMARK(stx->certs); - gcMARK(stx->props); + gcMARK2(stx->val, gc); + gcMARK2(stx->srcloc, gc); + gcMARK2(stx->wraps, gc); + gcMARK2(stx->certs, gc); + gcMARK2(stx->props, gc); if (!(MZ_OPT_HASH_KEY(&(stx)->iso) & STX_SUBSTX_FLAG)) - gcMARK(stx->u.modinfo_cache); + gcMARK2(stx->u.modinfo_cache, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Stx)); } -static int stx_val_FIXUP(void *p) { +static int stx_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Stx *stx = (Scheme_Stx *)p; - gcFIXUP(stx->val); - gcFIXUP(stx->srcloc); - gcFIXUP(stx->wraps); - gcFIXUP(stx->certs); - gcFIXUP(stx->props); + gcFIXUP2(stx->val, gc); + gcFIXUP2(stx->srcloc, gc); + gcFIXUP2(stx->wraps, gc); + gcFIXUP2(stx->certs, gc); + gcFIXUP2(stx->props, gc); if (!(MZ_OPT_HASH_KEY(&(stx)->iso) & STX_SUBSTX_FLAG)) - gcFIXUP(stx->u.modinfo_cache); + gcFIXUP2(stx->u.modinfo_cache, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Stx)); } @@ -2345,21 +2345,21 @@ static int stx_val_FIXUP(void *p) { #define stx_val_IS_CONST_SIZE 1 -static int stx_off_val_SIZE(void *p) { +static int stx_off_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Offset)); } -static int stx_off_val_MARK(void *p) { +static int stx_off_val_MARK(void *p, struct NewGC *gc) { Scheme_Stx_Offset *o = (Scheme_Stx_Offset *)p; - gcMARK(o->src); + gcMARK2(o->src, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Offset)); } -static int stx_off_val_FIXUP(void *p) { +static int stx_off_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Stx_Offset *o = (Scheme_Stx_Offset *)p; - gcFIXUP(o->src); + gcFIXUP2(o->src, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Offset)); } @@ -2368,99 +2368,99 @@ static int stx_off_val_FIXUP(void *p) { #define stx_off_val_IS_CONST_SIZE 1 -static int module_val_SIZE(void *p) { +static int module_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Module)); } -static int module_val_MARK(void *p) { +static int module_val_MARK(void *p, struct NewGC *gc) { Scheme_Module *m = (Scheme_Module *)p; - gcMARK(m->modname); + gcMARK2(m->modname, gc); - gcMARK(m->et_requires); - gcMARK(m->requires); - gcMARK(m->tt_requires); - gcMARK(m->dt_requires); - gcMARK(m->other_requires); + gcMARK2(m->et_requires, gc); + gcMARK2(m->requires, gc); + gcMARK2(m->tt_requires, gc); + gcMARK2(m->dt_requires, gc); + gcMARK2(m->other_requires, gc); - gcMARK(m->body); - gcMARK(m->et_body); + gcMARK2(m->body, gc); + gcMARK2(m->et_body, gc); - gcMARK(m->me); + gcMARK2(m->me, gc); - gcMARK(m->provide_protects); - gcMARK(m->indirect_provides); + gcMARK2(m->provide_protects, gc); + gcMARK2(m->indirect_provides, gc); - gcMARK(m->indirect_syntax_provides); + gcMARK2(m->indirect_syntax_provides, gc); - gcMARK(m->et_provide_protects); - gcMARK(m->et_indirect_provides); + gcMARK2(m->et_provide_protects, gc); + gcMARK2(m->et_indirect_provides, gc); - gcMARK(m->self_modidx); + gcMARK2(m->self_modidx, gc); - gcMARK(m->accessible); - gcMARK(m->et_accessible); + gcMARK2(m->accessible, gc); + gcMARK2(m->et_accessible, gc); - gcMARK(m->insp); + gcMARK2(m->insp, gc); - gcMARK(m->lang_info); + gcMARK2(m->lang_info, gc); - gcMARK(m->hints); - gcMARK(m->ii_src); + gcMARK2(m->hints, gc); + gcMARK2(m->ii_src, gc); - gcMARK(m->comp_prefix); - gcMARK(m->prefix); - gcMARK(m->dummy); + gcMARK2(m->comp_prefix, gc); + gcMARK2(m->prefix, gc); + gcMARK2(m->dummy, gc); - gcMARK(m->rn_stx); + gcMARK2(m->rn_stx, gc); - gcMARK(m->primitive); + gcMARK2(m->primitive, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Module)); } -static int module_val_FIXUP(void *p) { +static int module_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Module *m = (Scheme_Module *)p; - gcFIXUP(m->modname); + gcFIXUP2(m->modname, gc); - gcFIXUP(m->et_requires); - gcFIXUP(m->requires); - gcFIXUP(m->tt_requires); - gcFIXUP(m->dt_requires); - gcFIXUP(m->other_requires); + gcFIXUP2(m->et_requires, gc); + gcFIXUP2(m->requires, gc); + gcFIXUP2(m->tt_requires, gc); + gcFIXUP2(m->dt_requires, gc); + gcFIXUP2(m->other_requires, gc); - gcFIXUP(m->body); - gcFIXUP(m->et_body); + gcFIXUP2(m->body, gc); + gcFIXUP2(m->et_body, gc); - gcFIXUP(m->me); + gcFIXUP2(m->me, gc); - gcFIXUP(m->provide_protects); - gcFIXUP(m->indirect_provides); + gcFIXUP2(m->provide_protects, gc); + gcFIXUP2(m->indirect_provides, gc); - gcFIXUP(m->indirect_syntax_provides); + gcFIXUP2(m->indirect_syntax_provides, gc); - gcFIXUP(m->et_provide_protects); - gcFIXUP(m->et_indirect_provides); + gcFIXUP2(m->et_provide_protects, gc); + gcFIXUP2(m->et_indirect_provides, gc); - gcFIXUP(m->self_modidx); + gcFIXUP2(m->self_modidx, gc); - gcFIXUP(m->accessible); - gcFIXUP(m->et_accessible); + gcFIXUP2(m->accessible, gc); + gcFIXUP2(m->et_accessible, gc); - gcFIXUP(m->insp); + gcFIXUP2(m->insp, gc); - gcFIXUP(m->lang_info); + gcFIXUP2(m->lang_info, gc); - gcFIXUP(m->hints); - gcFIXUP(m->ii_src); + gcFIXUP2(m->hints, gc); + gcFIXUP2(m->ii_src, gc); - gcFIXUP(m->comp_prefix); - gcFIXUP(m->prefix); - gcFIXUP(m->dummy); + gcFIXUP2(m->comp_prefix, gc); + gcFIXUP2(m->prefix, gc); + gcFIXUP2(m->dummy, gc); - gcFIXUP(m->rn_stx); + gcFIXUP2(m->rn_stx, gc); - gcFIXUP(m->primitive); + gcFIXUP2(m->primitive, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Module)); } @@ -2469,52 +2469,52 @@ static int module_val_FIXUP(void *p) { #define module_val_IS_CONST_SIZE 1 -static int module_phase_exports_val_SIZE(void *p) { +static int module_phase_exports_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Module_Phase_Exports)); } -static int module_phase_exports_val_MARK(void *p) { +static int module_phase_exports_val_MARK(void *p, struct NewGC *gc) { Scheme_Module_Phase_Exports *m = (Scheme_Module_Phase_Exports *)p; - gcMARK(m->phase_index); + gcMARK2(m->phase_index, gc); - gcMARK(m->src_modidx); + gcMARK2(m->src_modidx, gc); - gcMARK(m->provides); - gcMARK(m->provide_srcs); - gcMARK(m->provide_src_names); - gcMARK(m->provide_nominal_srcs); - gcMARK(m->provide_src_phases); - gcMARK(m->provide_insps); + gcMARK2(m->provides, gc); + gcMARK2(m->provide_srcs, gc); + gcMARK2(m->provide_src_names, gc); + gcMARK2(m->provide_nominal_srcs, gc); + gcMARK2(m->provide_src_phases, gc); + gcMARK2(m->provide_insps, gc); - gcMARK(m->kernel_exclusion); - gcMARK(m->kernel_exclusion2); + gcMARK2(m->kernel_exclusion, gc); + gcMARK2(m->kernel_exclusion2, gc); - gcMARK(m->ht); + gcMARK2(m->ht, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Module_Phase_Exports)); } -static int module_phase_exports_val_FIXUP(void *p) { +static int module_phase_exports_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Module_Phase_Exports *m = (Scheme_Module_Phase_Exports *)p; - gcFIXUP(m->phase_index); + gcFIXUP2(m->phase_index, gc); - gcFIXUP(m->src_modidx); + gcFIXUP2(m->src_modidx, gc); - gcFIXUP(m->provides); - gcFIXUP(m->provide_srcs); - gcFIXUP(m->provide_src_names); - gcFIXUP(m->provide_nominal_srcs); - gcFIXUP(m->provide_src_phases); - gcFIXUP(m->provide_insps); + gcFIXUP2(m->provides, gc); + gcFIXUP2(m->provide_srcs, gc); + gcFIXUP2(m->provide_src_names, gc); + gcFIXUP2(m->provide_nominal_srcs, gc); + gcFIXUP2(m->provide_src_phases, gc); + gcFIXUP2(m->provide_insps, gc); - gcFIXUP(m->kernel_exclusion); - gcFIXUP(m->kernel_exclusion2); + gcFIXUP2(m->kernel_exclusion, gc); + gcFIXUP2(m->kernel_exclusion2, gc); - gcFIXUP(m->ht); + gcFIXUP2(m->ht, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Module_Phase_Exports)); @@ -2524,33 +2524,33 @@ static int module_phase_exports_val_FIXUP(void *p) { #define module_phase_exports_val_IS_CONST_SIZE 1 -static int module_exports_val_SIZE(void *p) { +static int module_exports_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Module_Exports)); } -static int module_exports_val_MARK(void *p) { +static int module_exports_val_MARK(void *p, struct NewGC *gc) { Scheme_Module_Exports *m = (Scheme_Module_Exports *)p; - gcMARK(m->rt); - gcMARK(m->et); - gcMARK(m->dt); - gcMARK(m->other_phases); + gcMARK2(m->rt, gc); + gcMARK2(m->et, gc); + gcMARK2(m->dt, gc); + gcMARK2(m->other_phases, gc); - gcMARK(m->src_modidx); + gcMARK2(m->src_modidx, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Module_Exports)); } -static int module_exports_val_FIXUP(void *p) { +static int module_exports_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Module_Exports *m = (Scheme_Module_Exports *)p; - gcFIXUP(m->rt); - gcFIXUP(m->et); - gcFIXUP(m->dt); - gcFIXUP(m->other_phases); + gcFIXUP2(m->rt, gc); + gcFIXUP2(m->et, gc); + gcFIXUP2(m->dt, gc); + gcFIXUP2(m->other_phases, gc); - gcFIXUP(m->src_modidx); + gcFIXUP2(m->src_modidx, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Module_Exports)); } @@ -2559,31 +2559,31 @@ static int module_exports_val_FIXUP(void *p) { #define module_exports_val_IS_CONST_SIZE 1 -static int modidx_val_SIZE(void *p) { +static int modidx_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Modidx)); } -static int modidx_val_MARK(void *p) { +static int modidx_val_MARK(void *p, struct NewGC *gc) { Scheme_Modidx *modidx = (Scheme_Modidx *)p; - gcMARK(modidx->path); - gcMARK(modidx->base); - gcMARK(modidx->resolved); - gcMARK(modidx->shift_cache); - gcMARK(modidx->cache_next); + gcMARK2(modidx->path, gc); + gcMARK2(modidx->base, gc); + gcMARK2(modidx->resolved, gc); + gcMARK2(modidx->shift_cache, gc); + gcMARK2(modidx->cache_next, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Modidx)); } -static int modidx_val_FIXUP(void *p) { +static int modidx_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Modidx *modidx = (Scheme_Modidx *)p; - gcFIXUP(modidx->path); - gcFIXUP(modidx->base); - gcFIXUP(modidx->resolved); - gcFIXUP(modidx->shift_cache); - gcFIXUP(modidx->cache_next); + gcFIXUP2(modidx->path, gc); + gcFIXUP2(modidx->base, gc); + gcFIXUP2(modidx->resolved, gc); + gcFIXUP2(modidx->shift_cache, gc); + gcFIXUP2(modidx->cache_next, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Modidx)); } @@ -2592,29 +2592,29 @@ static int modidx_val_FIXUP(void *p) { #define modidx_val_IS_CONST_SIZE 1 -static int guard_val_SIZE(void *p) { +static int guard_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Security_Guard)); } -static int guard_val_MARK(void *p) { +static int guard_val_MARK(void *p, struct NewGC *gc) { Scheme_Security_Guard *g = (Scheme_Security_Guard *)p; - gcMARK(g->parent); - gcMARK(g->file_proc); - gcMARK(g->network_proc); - gcMARK(g->link_proc); + gcMARK2(g->parent, gc); + gcMARK2(g->file_proc, gc); + gcMARK2(g->network_proc, gc); + gcMARK2(g->link_proc, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Security_Guard)); } -static int guard_val_FIXUP(void *p) { +static int guard_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Security_Guard *g = (Scheme_Security_Guard *)p; - gcFIXUP(g->parent); - gcFIXUP(g->file_proc); - gcFIXUP(g->network_proc); - gcFIXUP(g->link_proc); + gcFIXUP2(g->parent, gc); + gcFIXUP2(g->file_proc, gc); + gcFIXUP2(g->network_proc, gc); + gcFIXUP2(g->link_proc, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Security_Guard)); } @@ -2623,24 +2623,24 @@ static int guard_val_FIXUP(void *p) { #define guard_val_IS_CONST_SIZE 1 -static int buf_holder_SIZE(void *p) { +static int buf_holder_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Jumpup_Buf_Holder)); } -static int buf_holder_MARK(void *p) { +static int buf_holder_MARK(void *p, struct NewGC *gc) { Scheme_Jumpup_Buf_Holder *h = (Scheme_Jumpup_Buf_Holder *)p; - MARK_jmpup(&h->buf); + MARK_jmpup(&h->buf, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Jumpup_Buf_Holder)); } -static int buf_holder_FIXUP(void *p) { +static int buf_holder_FIXUP(void *p, struct NewGC *gc) { Scheme_Jumpup_Buf_Holder *h = (Scheme_Jumpup_Buf_Holder *)p; - FIXUP_jmpup(&h->buf); + FIXUP_jmpup(&h->buf, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Jumpup_Buf_Holder)); @@ -2650,21 +2650,21 @@ static int buf_holder_FIXUP(void *p) { #define buf_holder_IS_CONST_SIZE 1 -static int mark_inspector_SIZE(void *p) { +static int mark_inspector_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Inspector)); } -static int mark_inspector_MARK(void *p) { +static int mark_inspector_MARK(void *p, struct NewGC *gc) { Scheme_Inspector *i = (Scheme_Inspector *)p; - gcMARK(i->superior); + gcMARK2(i->superior, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Inspector)); } -static int mark_inspector_FIXUP(void *p) { +static int mark_inspector_FIXUP(void *p, struct NewGC *gc) { Scheme_Inspector *i = (Scheme_Inspector *)p; - gcFIXUP(i->superior); + gcFIXUP2(i->superior, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Inspector)); } @@ -2673,28 +2673,28 @@ static int mark_inspector_FIXUP(void *p) { #define mark_inspector_IS_CONST_SIZE 1 -static int mark_pipe_SIZE(void *p) { +static int mark_pipe_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Pipe)); } -static int mark_pipe_MARK(void *p) { +static int mark_pipe_MARK(void *p, struct NewGC *gc) { Scheme_Pipe *pp = (Scheme_Pipe *)p; - gcMARK(pp->buf); - gcMARK(pp->wakeup_on_read); - gcMARK(pp->wakeup_on_write); + gcMARK2(pp->buf, gc); + gcMARK2(pp->wakeup_on_read, gc); + gcMARK2(pp->wakeup_on_write, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Pipe)); } -static int mark_pipe_FIXUP(void *p) { +static int mark_pipe_FIXUP(void *p, struct NewGC *gc) { Scheme_Pipe *pp = (Scheme_Pipe *)p; - gcFIXUP(pp->buf); - gcFIXUP(pp->wakeup_on_read); - gcFIXUP(pp->wakeup_on_write); + gcFIXUP2(pp->buf, gc); + gcFIXUP2(pp->wakeup_on_read, gc); + gcFIXUP2(pp->wakeup_on_write, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Pipe)); @@ -2704,27 +2704,27 @@ static int mark_pipe_FIXUP(void *p) { #define mark_pipe_IS_CONST_SIZE 1 -static int mark_logger_SIZE(void *p) { +static int mark_logger_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Logger)); } -static int mark_logger_MARK(void *p) { +static int mark_logger_MARK(void *p, struct NewGC *gc) { Scheme_Logger *l = (Scheme_Logger *)p; - gcMARK(l->name); - gcMARK(l->parent); - gcMARK(l->readers); - gcMARK(l->timestamp); + gcMARK2(l->name, gc); + gcMARK2(l->parent, gc); + gcMARK2(l->readers, gc); + gcMARK2(l->timestamp, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Logger)); } -static int mark_logger_FIXUP(void *p) { +static int mark_logger_FIXUP(void *p, struct NewGC *gc) { Scheme_Logger *l = (Scheme_Logger *)p; - gcFIXUP(l->name); - gcFIXUP(l->parent); - gcFIXUP(l->readers); - gcFIXUP(l->timestamp); + gcFIXUP2(l->name, gc); + gcFIXUP2(l->parent, gc); + gcFIXUP2(l->readers, gc); + gcFIXUP2(l->timestamp, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Logger)); } @@ -2733,25 +2733,25 @@ static int mark_logger_FIXUP(void *p) { #define mark_logger_IS_CONST_SIZE 1 -static int mark_log_reader_SIZE(void *p) { +static int mark_log_reader_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Log_Reader)); } -static int mark_log_reader_MARK(void *p) { +static int mark_log_reader_MARK(void *p, struct NewGC *gc) { Scheme_Log_Reader *lr = (Scheme_Log_Reader *)p; - gcMARK(lr->sema); - gcMARK(lr->head); - gcMARK(lr->tail); + gcMARK2(lr->sema, gc); + gcMARK2(lr->head, gc); + gcMARK2(lr->tail, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Log_Reader)); } -static int mark_log_reader_FIXUP(void *p) { +static int mark_log_reader_FIXUP(void *p, struct NewGC *gc) { Scheme_Log_Reader *lr = (Scheme_Log_Reader *)p; - gcFIXUP(lr->sema); - gcFIXUP(lr->head); - gcFIXUP(lr->tail); + gcFIXUP2(lr->sema, gc); + gcFIXUP2(lr->head, gc); + gcFIXUP2(lr->tail, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Log_Reader)); } @@ -2766,18 +2766,18 @@ static int mark_log_reader_FIXUP(void *p) { #ifdef MARKS_FOR_ENGINE_C -static int engine_val_SIZE(void *p) { +static int engine_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Engine)); } -static int engine_val_MARK(void *p) { +static int engine_val_MARK(void *p, struct NewGC *gc) { Scheme_Engine *en = (Scheme_Engine *)p; return gcBYTES_TO_WORDS(sizeof(Scheme_Engine)); } -static int engine_val_FIXUP(void *p) { +static int engine_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Engine *en = (Scheme_Engine *)p; return gcBYTES_TO_WORDS(sizeof(Scheme_Engine)); @@ -2791,62 +2791,62 @@ static int engine_val_FIXUP(void *p) { #ifdef MARKS_FOR_ENV_C -static int mark_comp_env_SIZE(void *p) { +static int mark_comp_env_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Full_Comp_Env)); } -static int mark_comp_env_MARK(void *p) { +static int mark_comp_env_MARK(void *p, struct NewGC *gc) { Scheme_Full_Comp_Env *e = (Scheme_Full_Comp_Env *)p; - gcMARK(e->base.genv); - gcMARK(e->base.insp); - gcMARK(e->base.prefix); - gcMARK(e->base.next); - gcMARK(e->base.values); - gcMARK(e->base.certs); - gcMARK(e->base.renames); - gcMARK(e->base.uid); - gcMARK(e->base.uids); - gcMARK(e->base.dup_check); - gcMARK(e->base.intdef_name); - gcMARK(e->base.in_modidx); - gcMARK(e->base.skip_table); + gcMARK2(e->base.genv, gc); + gcMARK2(e->base.insp, gc); + gcMARK2(e->base.prefix, gc); + gcMARK2(e->base.next, gc); + gcMARK2(e->base.values, gc); + gcMARK2(e->base.certs, gc); + gcMARK2(e->base.renames, gc); + gcMARK2(e->base.uid, gc); + gcMARK2(e->base.uids, gc); + gcMARK2(e->base.dup_check, gc); + gcMARK2(e->base.intdef_name, gc); + gcMARK2(e->base.in_modidx, gc); + gcMARK2(e->base.skip_table, gc); - gcMARK(e->data.const_names); - gcMARK(e->data.const_vals); - gcMARK(e->data.const_uids); - gcMARK(e->data.sealed); - gcMARK(e->data.use); - gcMARK(e->data.lifts); + gcMARK2(e->data.const_names, gc); + gcMARK2(e->data.const_vals, gc); + gcMARK2(e->data.const_uids, gc); + gcMARK2(e->data.sealed, gc); + gcMARK2(e->data.use, gc); + gcMARK2(e->data.lifts, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Full_Comp_Env)); } -static int mark_comp_env_FIXUP(void *p) { +static int mark_comp_env_FIXUP(void *p, struct NewGC *gc) { Scheme_Full_Comp_Env *e = (Scheme_Full_Comp_Env *)p; - gcFIXUP(e->base.genv); - gcFIXUP(e->base.insp); - gcFIXUP(e->base.prefix); - gcFIXUP(e->base.next); - gcFIXUP(e->base.values); - gcFIXUP(e->base.certs); - gcFIXUP(e->base.renames); - gcFIXUP(e->base.uid); - gcFIXUP(e->base.uids); - gcFIXUP(e->base.dup_check); - gcFIXUP(e->base.intdef_name); - gcFIXUP(e->base.in_modidx); - gcFIXUP(e->base.skip_table); + gcFIXUP2(e->base.genv, gc); + gcFIXUP2(e->base.insp, gc); + gcFIXUP2(e->base.prefix, gc); + gcFIXUP2(e->base.next, gc); + gcFIXUP2(e->base.values, gc); + gcFIXUP2(e->base.certs, gc); + gcFIXUP2(e->base.renames, gc); + gcFIXUP2(e->base.uid, gc); + gcFIXUP2(e->base.uids, gc); + gcFIXUP2(e->base.dup_check, gc); + gcFIXUP2(e->base.intdef_name, gc); + gcFIXUP2(e->base.in_modidx, gc); + gcFIXUP2(e->base.skip_table, gc); - gcFIXUP(e->data.const_names); - gcFIXUP(e->data.const_vals); - gcFIXUP(e->data.const_uids); - gcFIXUP(e->data.sealed); - gcFIXUP(e->data.use); - gcFIXUP(e->data.lifts); + gcFIXUP2(e->data.const_names, gc); + gcFIXUP2(e->data.const_vals, gc); + gcFIXUP2(e->data.const_uids, gc); + gcFIXUP2(e->data.sealed, gc); + gcFIXUP2(e->data.use, gc); + gcFIXUP2(e->data.lifts, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Full_Comp_Env)); @@ -2856,40 +2856,40 @@ static int mark_comp_env_FIXUP(void *p) { #define mark_comp_env_IS_CONST_SIZE 1 -static int mark_resolve_info_SIZE(void *p) { +static int mark_resolve_info_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Resolve_Info)); } -static int mark_resolve_info_MARK(void *p) { +static int mark_resolve_info_MARK(void *p, struct NewGC *gc) { Resolve_Info *i = (Resolve_Info *)p; - gcMARK(i->prefix); - gcMARK(i->stx_map); - gcMARK(i->old_pos); - gcMARK(i->new_pos); - gcMARK(i->old_stx_pos); - gcMARK(i->flags); - gcMARK(i->lifts); - gcMARK(i->lifted); - gcMARK(i->next); + gcMARK2(i->prefix, gc); + gcMARK2(i->stx_map, gc); + gcMARK2(i->old_pos, gc); + gcMARK2(i->new_pos, gc); + gcMARK2(i->old_stx_pos, gc); + gcMARK2(i->flags, gc); + gcMARK2(i->lifts, gc); + gcMARK2(i->lifted, gc); + gcMARK2(i->next, gc); return gcBYTES_TO_WORDS(sizeof(Resolve_Info)); } -static int mark_resolve_info_FIXUP(void *p) { +static int mark_resolve_info_FIXUP(void *p, struct NewGC *gc) { Resolve_Info *i = (Resolve_Info *)p; - gcFIXUP(i->prefix); - gcFIXUP(i->stx_map); - gcFIXUP(i->old_pos); - gcFIXUP(i->new_pos); - gcFIXUP(i->old_stx_pos); - gcFIXUP(i->flags); - gcFIXUP(i->lifts); - gcFIXUP(i->lifted); - gcFIXUP(i->next); + gcFIXUP2(i->prefix, gc); + gcFIXUP2(i->stx_map, gc); + gcFIXUP2(i->old_pos, gc); + gcFIXUP2(i->new_pos, gc); + gcFIXUP2(i->old_stx_pos, gc); + gcFIXUP2(i->flags, gc); + gcFIXUP2(i->lifts, gc); + gcFIXUP2(i->lifted, gc); + gcFIXUP2(i->next, gc); return gcBYTES_TO_WORDS(sizeof(Resolve_Info)); @@ -2899,40 +2899,40 @@ static int mark_resolve_info_FIXUP(void *p) { #define mark_resolve_info_IS_CONST_SIZE 1 -static int mark_optimize_info_SIZE(void *p) { +static int mark_optimize_info_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Optimize_Info)); } -static int mark_optimize_info_MARK(void *p) { +static int mark_optimize_info_MARK(void *p, struct NewGC *gc) { Optimize_Info *i = (Optimize_Info *)p; - gcMARK(i->stat_dists); - gcMARK(i->sd_depths); - gcMARK(i->next); - gcMARK(i->use); - gcMARK(i->consts); - gcMARK(i->top_level_consts); - gcMARK(i->transitive_use); - gcMARK(i->transitive_use_len); - gcMARK(i->context); + gcMARK2(i->stat_dists, gc); + gcMARK2(i->sd_depths, gc); + gcMARK2(i->next, gc); + gcMARK2(i->use, gc); + gcMARK2(i->consts, gc); + gcMARK2(i->top_level_consts, gc); + gcMARK2(i->transitive_use, gc); + gcMARK2(i->transitive_use_len, gc); + gcMARK2(i->context, gc); return gcBYTES_TO_WORDS(sizeof(Optimize_Info)); } -static int mark_optimize_info_FIXUP(void *p) { +static int mark_optimize_info_FIXUP(void *p, struct NewGC *gc) { Optimize_Info *i = (Optimize_Info *)p; - gcFIXUP(i->stat_dists); - gcFIXUP(i->sd_depths); - gcFIXUP(i->next); - gcFIXUP(i->use); - gcFIXUP(i->consts); - gcFIXUP(i->top_level_consts); - gcFIXUP(i->transitive_use); - gcFIXUP(i->transitive_use_len); - gcFIXUP(i->context); + gcFIXUP2(i->stat_dists, gc); + gcFIXUP2(i->sd_depths, gc); + gcFIXUP2(i->next, gc); + gcFIXUP2(i->use, gc); + gcFIXUP2(i->consts, gc); + gcFIXUP2(i->top_level_consts, gc); + gcFIXUP2(i->transitive_use, gc); + gcFIXUP2(i->transitive_use_len, gc); + gcFIXUP2(i->context, gc); return gcBYTES_TO_WORDS(sizeof(Optimize_Info)); @@ -2942,28 +2942,28 @@ static int mark_optimize_info_FIXUP(void *p) { #define mark_optimize_info_IS_CONST_SIZE 1 -static int mark_sfs_info_SIZE(void *p) { +static int mark_sfs_info_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(SFS_Info)); } -static int mark_sfs_info_MARK(void *p) { +static int mark_sfs_info_MARK(void *p, struct NewGC *gc) { SFS_Info *i = (SFS_Info *)p; - gcMARK(i->max_used); - gcMARK(i->max_calls); - gcMARK(i->saved); + gcMARK2(i->max_used, gc); + gcMARK2(i->max_calls, gc); + gcMARK2(i->saved, gc); return gcBYTES_TO_WORDS(sizeof(SFS_Info)); } -static int mark_sfs_info_FIXUP(void *p) { +static int mark_sfs_info_FIXUP(void *p, struct NewGC *gc) { SFS_Info *i = (SFS_Info *)p; - gcFIXUP(i->max_used); - gcFIXUP(i->max_calls); - gcFIXUP(i->saved); + gcFIXUP2(i->max_used, gc); + gcFIXUP2(i->max_calls, gc); + gcFIXUP2(i->saved, gc); return gcBYTES_TO_WORDS(sizeof(SFS_Info)); @@ -2973,25 +2973,25 @@ static int mark_sfs_info_FIXUP(void *p) { #define mark_sfs_info_IS_CONST_SIZE 1 -static int mark_once_used_SIZE(void *p) { +static int mark_once_used_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Once_Used)); } -static int mark_once_used_MARK(void *p) { +static int mark_once_used_MARK(void *p, struct NewGC *gc) { Scheme_Once_Used *o = (Scheme_Once_Used *)p; - gcMARK(o->expr); - gcMARK(o->info); - gcMARK(o->next); + gcMARK2(o->expr, gc); + gcMARK2(o->info, gc); + gcMARK2(o->next, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Once_Used)); } -static int mark_once_used_FIXUP(void *p) { +static int mark_once_used_FIXUP(void *p, struct NewGC *gc) { Scheme_Once_Used *o = (Scheme_Once_Used *)p; - gcFIXUP(o->expr); - gcFIXUP(o->info); - gcFIXUP(o->next); + gcFIXUP2(o->expr, gc); + gcFIXUP2(o->info, gc); + gcFIXUP2(o->next, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Once_Used)); } @@ -3006,28 +3006,28 @@ static int mark_once_used_FIXUP(void *p) { #ifdef MARKS_FOR_EVAL_C -static int mark_comp_info_SIZE(void *p) { +static int mark_comp_info_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Compile_Info)); } -static int mark_comp_info_MARK(void *p) { +static int mark_comp_info_MARK(void *p, struct NewGC *gc) { Scheme_Compile_Info *i = (Scheme_Compile_Info *)p; - gcMARK(i->value_name); - gcMARK(i->certs); - gcMARK(i->observer); + gcMARK2(i->value_name, gc); + gcMARK2(i->certs, gc); + gcMARK2(i->observer, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Compile_Info)); } -static int mark_comp_info_FIXUP(void *p) { +static int mark_comp_info_FIXUP(void *p, struct NewGC *gc) { Scheme_Compile_Info *i = (Scheme_Compile_Info *)p; - gcFIXUP(i->value_name); - gcFIXUP(i->certs); - gcFIXUP(i->observer); + gcFIXUP2(i->value_name, gc); + gcFIXUP2(i->certs, gc); + gcFIXUP2(i->observer, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Compile_Info)); @@ -3037,26 +3037,26 @@ static int mark_comp_info_FIXUP(void *p) { #define mark_comp_info_IS_CONST_SIZE 1 -static int mark_saved_stack_SIZE(void *p) { +static int mark_saved_stack_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Saved_Stack)); } -static int mark_saved_stack_MARK(void *p) { +static int mark_saved_stack_MARK(void *p, struct NewGC *gc) { Scheme_Saved_Stack *saved = (Scheme_Saved_Stack *)p; - gcMARK(saved->prev); - gcMARK(saved->runstack_start); + gcMARK2(saved->prev, gc); + gcMARK2(saved->runstack_start, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Saved_Stack)); } -static int mark_saved_stack_FIXUP(void *p) { +static int mark_saved_stack_FIXUP(void *p, struct NewGC *gc) { Scheme_Saved_Stack *saved = (Scheme_Saved_Stack *)p; - gcFIXUP(saved->prev); - gcFIXUP(saved->runstack_start); + gcFIXUP2(saved->prev, gc); + gcFIXUP2(saved->runstack_start, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Saved_Stack)); @@ -3066,26 +3066,26 @@ static int mark_saved_stack_FIXUP(void *p) { #define mark_saved_stack_IS_CONST_SIZE 1 -static int mark_validate_clearing_SIZE(void *p) { +static int mark_validate_clearing_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Validate_Clearing)); } -static int mark_validate_clearing_MARK(void *p) { +static int mark_validate_clearing_MARK(void *p, struct NewGC *gc) { Validate_Clearing *vc = (Validate_Clearing *)p; - gcMARK(vc->stack); - gcMARK(vc->ncstack); + gcMARK2(vc->stack, gc); + gcMARK2(vc->ncstack, gc); return gcBYTES_TO_WORDS(sizeof(Validate_Clearing)); } -static int mark_validate_clearing_FIXUP(void *p) { +static int mark_validate_clearing_FIXUP(void *p, struct NewGC *gc) { Validate_Clearing *vc = (Validate_Clearing *)p; - gcFIXUP(vc->stack); - gcFIXUP(vc->ncstack); + gcFIXUP2(vc->stack, gc); + gcFIXUP2(vc->ncstack, gc); return gcBYTES_TO_WORDS(sizeof(Validate_Clearing)); @@ -3101,24 +3101,24 @@ static int mark_validate_clearing_FIXUP(void *p) { #ifdef MARKS_FOR_FILE_C -static int mark_reply_item_SIZE(void *p) { +static int mark_reply_item_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(ReplyItem)); } -static int mark_reply_item_MARK(void *p) { +static int mark_reply_item_MARK(void *p, struct NewGC *gc) { ReplyItem *r = (ReplyItem *)p; - gcMARK(r->next); + gcMARK2(r->next, gc); return gcBYTES_TO_WORDS(sizeof(ReplyItem)); } -static int mark_reply_item_FIXUP(void *p) { +static int mark_reply_item_FIXUP(void *p, struct NewGC *gc) { ReplyItem *r = (ReplyItem *)p; - gcFIXUP(r->next); + gcFIXUP2(r->next, gc); return gcBYTES_TO_WORDS(sizeof(ReplyItem)); @@ -3134,28 +3134,28 @@ static int mark_reply_item_FIXUP(void *p) { #ifdef MARKS_FOR_FUN_C -static int mark_closure_info_SIZE(void *p) { +static int mark_closure_info_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Closure_Info)); } -static int mark_closure_info_MARK(void *p) { +static int mark_closure_info_MARK(void *p, struct NewGC *gc) { Closure_Info *i = (Closure_Info *)p; - gcMARK(i->local_flags); - gcMARK(i->base_closure_map); - gcMARK(i->flonum_map); + gcMARK2(i->local_flags, gc); + gcMARK2(i->base_closure_map, gc); + gcMARK2(i->flonum_map, gc); return gcBYTES_TO_WORDS(sizeof(Closure_Info)); } -static int mark_closure_info_FIXUP(void *p) { +static int mark_closure_info_FIXUP(void *p, struct NewGC *gc) { Closure_Info *i = (Closure_Info *)p; - gcFIXUP(i->local_flags); - gcFIXUP(i->base_closure_map); - gcFIXUP(i->flonum_map); + gcFIXUP2(i->local_flags, gc); + gcFIXUP2(i->base_closure_map, gc); + gcFIXUP2(i->flonum_map, gc); return gcBYTES_TO_WORDS(sizeof(Closure_Info)); @@ -3165,26 +3165,26 @@ static int mark_closure_info_FIXUP(void *p) { #define mark_closure_info_IS_CONST_SIZE 1 -static int mark_dyn_wind_cell_SIZE(void *p) { +static int mark_dyn_wind_cell_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind_List)); } -static int mark_dyn_wind_cell_MARK(void *p) { +static int mark_dyn_wind_cell_MARK(void *p, struct NewGC *gc) { Scheme_Dynamic_Wind_List *l = (Scheme_Dynamic_Wind_List *)p; - gcMARK(l->dw); - gcMARK(l->next); + gcMARK2(l->dw, gc); + gcMARK2(l->next, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind_List)); } -static int mark_dyn_wind_cell_FIXUP(void *p) { +static int mark_dyn_wind_cell_FIXUP(void *p, struct NewGC *gc) { Scheme_Dynamic_Wind_List *l = (Scheme_Dynamic_Wind_List *)p; - gcFIXUP(l->dw); - gcFIXUP(l->next); + gcFIXUP2(l->dw, gc); + gcFIXUP2(l->next, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind_List)); @@ -3194,28 +3194,28 @@ static int mark_dyn_wind_cell_FIXUP(void *p) { #define mark_dyn_wind_cell_IS_CONST_SIZE 1 -static int mark_dyn_wind_info_SIZE(void *p) { +static int mark_dyn_wind_info_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Dyn_Wind)); } -static int mark_dyn_wind_info_MARK(void *p) { +static int mark_dyn_wind_info_MARK(void *p, struct NewGC *gc) { Dyn_Wind *d = (Dyn_Wind *)p; - gcMARK(d->pre); - gcMARK(d->act); - gcMARK(d->post); + gcMARK2(d->pre, gc); + gcMARK2(d->act, gc); + gcMARK2(d->post, gc); return gcBYTES_TO_WORDS(sizeof(Dyn_Wind)); } -static int mark_dyn_wind_info_FIXUP(void *p) { +static int mark_dyn_wind_info_FIXUP(void *p, struct NewGC *gc) { Dyn_Wind *d = (Dyn_Wind *)p; - gcFIXUP(d->pre); - gcFIXUP(d->act); - gcFIXUP(d->post); + gcFIXUP2(d->pre, gc); + gcFIXUP2(d->act, gc); + gcFIXUP2(d->post, gc); return gcBYTES_TO_WORDS(sizeof(Dyn_Wind)); @@ -3225,28 +3225,28 @@ static int mark_dyn_wind_info_FIXUP(void *p) { #define mark_dyn_wind_info_IS_CONST_SIZE 1 -static int mark_cont_mark_chain_SIZE(void *p) { +static int mark_cont_mark_chain_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Chain)); } -static int mark_cont_mark_chain_MARK(void *p) { +static int mark_cont_mark_chain_MARK(void *p, struct NewGC *gc) { Scheme_Cont_Mark_Chain *c = (Scheme_Cont_Mark_Chain *)p; - gcMARK(c->key); - gcMARK(c->val); - gcMARK(c->next); + gcMARK2(c->key, gc); + gcMARK2(c->val, gc); + gcMARK2(c->next, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Chain)); } -static int mark_cont_mark_chain_FIXUP(void *p) { +static int mark_cont_mark_chain_FIXUP(void *p, struct NewGC *gc) { Scheme_Cont_Mark_Chain *c = (Scheme_Cont_Mark_Chain *)p; - gcFIXUP(c->key); - gcFIXUP(c->val); - gcFIXUP(c->next); + gcFIXUP2(c->key, gc); + gcFIXUP2(c->val, gc); + gcFIXUP2(c->next, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Chain)); @@ -3262,26 +3262,26 @@ static int mark_cont_mark_chain_FIXUP(void *p) { #ifdef MARKS_FOR_HASH_C -static int hash_tree_val_SIZE(void *p) { +static int hash_tree_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Tree)); } -static int hash_tree_val_MARK(void *p) { +static int hash_tree_val_MARK(void *p, struct NewGC *gc) { Scheme_Hash_Tree *ht = (Scheme_Hash_Tree *)p; - gcMARK(ht->root); - gcMARK(ht->elems_box); + gcMARK2(ht->root, gc); + gcMARK2(ht->elems_box, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Tree)); } -static int hash_tree_val_FIXUP(void *p) { +static int hash_tree_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Hash_Tree *ht = (Scheme_Hash_Tree *)p; - gcFIXUP(ht->root); - gcFIXUP(ht->elems_box); + gcFIXUP2(ht->root, gc); + gcFIXUP2(ht->elems_box, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Tree)); @@ -3291,40 +3291,40 @@ static int hash_tree_val_FIXUP(void *p) { #define hash_tree_val_IS_CONST_SIZE 1 -static int mark_rb_node_SIZE(void *p) { +static int mark_rb_node_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(RBNode)); } -static int mark_rb_node_MARK(void *p) { +static int mark_rb_node_MARK(void *p, struct NewGC *gc) { RBNode *rb = (RBNode *)p; /* Short-circuit on NULL pointers, which are especially likely */ if (rb->left) { - gcMARK(rb->left); + gcMARK2(rb->left, gc); } if (rb->right) { - gcMARK(rb->right); + gcMARK2(rb->right, gc); } - gcMARK(rb->key); - gcMARK(rb->val); + gcMARK2(rb->key, gc); + gcMARK2(rb->val, gc); return gcBYTES_TO_WORDS(sizeof(RBNode)); } -static int mark_rb_node_FIXUP(void *p) { +static int mark_rb_node_FIXUP(void *p, struct NewGC *gc) { RBNode *rb = (RBNode *)p; /* Short-circuit on NULL pointers, which are especially likely */ if (rb->left) { - gcFIXUP(rb->left); + gcFIXUP2(rb->left, gc); } if (rb->right) { - gcFIXUP(rb->right); + gcFIXUP2(rb->right, gc); } - gcFIXUP(rb->key); - gcFIXUP(rb->val); + gcFIXUP2(rb->key, gc); + gcFIXUP2(rb->val, gc); return gcBYTES_TO_WORDS(sizeof(RBNode)); @@ -3340,24 +3340,24 @@ static int mark_rb_node_FIXUP(void *p) { #ifdef MARKS_FOR_PLACES_C -static int place_bi_channel_val_SIZE(void *p) { +static int place_bi_channel_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Place_Bi_Channel)); } -static int place_bi_channel_val_MARK(void *p) { +static int place_bi_channel_val_MARK(void *p, struct NewGC *gc) { Scheme_Place_Bi_Channel *pbc = (Scheme_Place_Bi_Channel *)p; - gcMARK(pbc->sendch); - gcMARK(pbc->recvch); + gcMARK2(pbc->sendch, gc); + gcMARK2(pbc->recvch, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Place_Bi_Channel)); } -static int place_bi_channel_val_FIXUP(void *p) { +static int place_bi_channel_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Place_Bi_Channel *pbc = (Scheme_Place_Bi_Channel *)p; - gcFIXUP(pbc->sendch); - gcFIXUP(pbc->recvch); + gcFIXUP2(pbc->sendch, gc); + gcFIXUP2(pbc->recvch, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Place_Bi_Channel)); @@ -3367,22 +3367,22 @@ static int place_bi_channel_val_FIXUP(void *p) { #define place_bi_channel_val_IS_CONST_SIZE 1 -static int place_val_SIZE(void *p) { +static int place_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Place)); } -static int place_val_MARK(void *p) { +static int place_val_MARK(void *p, struct NewGC *gc) { Scheme_Place *pr = (Scheme_Place *)p; - gcMARK(pr->channel); + gcMARK2(pr->channel, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Place)); } -static int place_val_FIXUP(void *p) { +static int place_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Place *pr = (Scheme_Place *)p; - gcFIXUP(pr->channel); + gcFIXUP2(pr->channel, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Place)); @@ -3392,26 +3392,26 @@ static int place_val_FIXUP(void *p) { #define place_val_IS_CONST_SIZE 1 -static int place_async_channel_val_SIZE(void *p) { +static int place_async_channel_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Place_Async_Channel)); } -static int place_async_channel_val_MARK(void *p) { +static int place_async_channel_val_MARK(void *p, struct NewGC *gc) { Scheme_Place_Async_Channel *pac = (Scheme_Place_Async_Channel *)p; int i; for (i = pac->size; i--; ) - gcMARK(pac->msgs[i]); + gcMARK2(pac->msgs[i], gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Place_Async_Channel)); } -static int place_async_channel_val_FIXUP(void *p) { +static int place_async_channel_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Place_Async_Channel *pac = (Scheme_Place_Async_Channel *)p; int i; for (i = pac->size; i--; ) - gcFIXUP(pac->msgs[i]); + gcFIXUP2(pac->msgs[i], gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Place_Async_Channel)); @@ -3427,34 +3427,34 @@ static int place_async_channel_val_FIXUP(void *p) { #ifdef MARKS_FOR_PORTFUN_C -static int mark_load_handler_data_SIZE(void *p) { +static int mark_load_handler_data_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(LoadHandlerData)); } -static int mark_load_handler_data_MARK(void *p) { +static int mark_load_handler_data_MARK(void *p, struct NewGC *gc) { LoadHandlerData *d = (LoadHandlerData *)p; - gcMARK(d->config); - gcMARK(d->port); - gcMARK(d->p); - gcMARK(d->stxsrc); - gcMARK(d->expected_module); - gcMARK(d->delay_load_info); + gcMARK2(d->config, gc); + gcMARK2(d->port, gc); + gcMARK2(d->p, gc); + gcMARK2(d->stxsrc, gc); + gcMARK2(d->expected_module, gc); + gcMARK2(d->delay_load_info, gc); return gcBYTES_TO_WORDS(sizeof(LoadHandlerData)); } -static int mark_load_handler_data_FIXUP(void *p) { +static int mark_load_handler_data_FIXUP(void *p, struct NewGC *gc) { LoadHandlerData *d = (LoadHandlerData *)p; - gcFIXUP(d->config); - gcFIXUP(d->port); - gcFIXUP(d->p); - gcFIXUP(d->stxsrc); - gcFIXUP(d->expected_module); - gcFIXUP(d->delay_load_info); + gcFIXUP2(d->config, gc); + gcFIXUP2(d->port, gc); + gcFIXUP2(d->p, gc); + gcFIXUP2(d->stxsrc, gc); + gcFIXUP2(d->expected_module, gc); + gcFIXUP2(d->delay_load_info, gc); return gcBYTES_TO_WORDS(sizeof(LoadHandlerData)); @@ -3464,24 +3464,24 @@ static int mark_load_handler_data_FIXUP(void *p) { #define mark_load_handler_data_IS_CONST_SIZE 1 -static int mark_indexed_string_SIZE(void *p) { +static int mark_indexed_string_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Indexed_String)); } -static int mark_indexed_string_MARK(void *p) { +static int mark_indexed_string_MARK(void *p, struct NewGC *gc) { Scheme_Indexed_String *is = (Scheme_Indexed_String *)p; - gcMARK(is->string); + gcMARK2(is->string, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Indexed_String)); } -static int mark_indexed_string_FIXUP(void *p) { +static int mark_indexed_string_FIXUP(void *p, struct NewGC *gc) { Scheme_Indexed_String *is = (Scheme_Indexed_String *)p; - gcFIXUP(is->string); + gcFIXUP2(is->string, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Indexed_String)); @@ -3491,43 +3491,43 @@ static int mark_indexed_string_FIXUP(void *p) { #define mark_indexed_string_IS_CONST_SIZE 1 -static int mark_user_input_SIZE(void *p) { +static int mark_user_input_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(User_Input_Port)); } -static int mark_user_input_MARK(void *p) { +static int mark_user_input_MARK(void *p, struct NewGC *gc) { User_Input_Port *uip = (User_Input_Port *)p; - gcMARK(uip->read_proc); - gcMARK(uip->peek_proc); - gcMARK(uip->progress_evt_proc); - gcMARK(uip->peeked_read_proc); - gcMARK(uip->location_proc); - gcMARK(uip->count_lines_proc); - gcMARK(uip->buffer_mode_proc); - gcMARK(uip->close_proc); - gcMARK(uip->reuse_str); - gcMARK(uip->peeked); - gcMARK(uip->prefix_pipe); + gcMARK2(uip->read_proc, gc); + gcMARK2(uip->peek_proc, gc); + gcMARK2(uip->progress_evt_proc, gc); + gcMARK2(uip->peeked_read_proc, gc); + gcMARK2(uip->location_proc, gc); + gcMARK2(uip->count_lines_proc, gc); + gcMARK2(uip->buffer_mode_proc, gc); + gcMARK2(uip->close_proc, gc); + gcMARK2(uip->reuse_str, gc); + gcMARK2(uip->peeked, gc); + gcMARK2(uip->prefix_pipe, gc); return gcBYTES_TO_WORDS(sizeof(User_Input_Port)); } -static int mark_user_input_FIXUP(void *p) { +static int mark_user_input_FIXUP(void *p, struct NewGC *gc) { User_Input_Port *uip = (User_Input_Port *)p; - gcFIXUP(uip->read_proc); - gcFIXUP(uip->peek_proc); - gcFIXUP(uip->progress_evt_proc); - gcFIXUP(uip->peeked_read_proc); - gcFIXUP(uip->location_proc); - gcFIXUP(uip->count_lines_proc); - gcFIXUP(uip->buffer_mode_proc); - gcFIXUP(uip->close_proc); - gcFIXUP(uip->reuse_str); - gcFIXUP(uip->peeked); - gcFIXUP(uip->prefix_pipe); + gcFIXUP2(uip->read_proc, gc); + gcFIXUP2(uip->peek_proc, gc); + gcFIXUP2(uip->progress_evt_proc, gc); + gcFIXUP2(uip->peeked_read_proc, gc); + gcFIXUP2(uip->location_proc, gc); + gcFIXUP2(uip->count_lines_proc, gc); + gcFIXUP2(uip->buffer_mode_proc, gc); + gcFIXUP2(uip->close_proc, gc); + gcFIXUP2(uip->reuse_str, gc); + gcFIXUP2(uip->peeked, gc); + gcFIXUP2(uip->prefix_pipe, gc); return gcBYTES_TO_WORDS(sizeof(User_Input_Port)); } @@ -3536,41 +3536,41 @@ static int mark_user_input_FIXUP(void *p) { #define mark_user_input_IS_CONST_SIZE 1 -static int mark_user_output_SIZE(void *p) { +static int mark_user_output_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(User_Output_Port)); } -static int mark_user_output_MARK(void *p) { +static int mark_user_output_MARK(void *p, struct NewGC *gc) { User_Output_Port *uop = (User_Output_Port *)p; - gcMARK(uop->evt); - gcMARK(uop->write_evt_proc); - gcMARK(uop->write_proc); - gcMARK(uop->write_special_evt_proc); - gcMARK(uop->write_special_proc); - gcMARK(uop->location_proc); - gcMARK(uop->count_lines_proc); - gcMARK(uop->buffer_mode_proc); - gcMARK(uop->close_proc); - gcMARK(uop->buffer_pipe); + gcMARK2(uop->evt, gc); + gcMARK2(uop->write_evt_proc, gc); + gcMARK2(uop->write_proc, gc); + gcMARK2(uop->write_special_evt_proc, gc); + gcMARK2(uop->write_special_proc, gc); + gcMARK2(uop->location_proc, gc); + gcMARK2(uop->count_lines_proc, gc); + gcMARK2(uop->buffer_mode_proc, gc); + gcMARK2(uop->close_proc, gc); + gcMARK2(uop->buffer_pipe, gc); return gcBYTES_TO_WORDS(sizeof(User_Output_Port)); } -static int mark_user_output_FIXUP(void *p) { +static int mark_user_output_FIXUP(void *p, struct NewGC *gc) { User_Output_Port *uop = (User_Output_Port *)p; - gcFIXUP(uop->evt); - gcFIXUP(uop->write_evt_proc); - gcFIXUP(uop->write_proc); - gcFIXUP(uop->write_special_evt_proc); - gcFIXUP(uop->write_special_proc); - gcFIXUP(uop->location_proc); - gcFIXUP(uop->count_lines_proc); - gcFIXUP(uop->buffer_mode_proc); - gcFIXUP(uop->close_proc); - gcFIXUP(uop->buffer_pipe); + gcFIXUP2(uop->evt, gc); + gcFIXUP2(uop->write_evt_proc, gc); + gcFIXUP2(uop->write_proc, gc); + gcFIXUP2(uop->write_special_evt_proc, gc); + gcFIXUP2(uop->write_special_proc, gc); + gcFIXUP2(uop->location_proc, gc); + gcFIXUP2(uop->count_lines_proc, gc); + gcFIXUP2(uop->buffer_mode_proc, gc); + gcFIXUP2(uop->close_proc, gc); + gcFIXUP2(uop->buffer_pipe, gc); return gcBYTES_TO_WORDS(sizeof(User_Output_Port)); } @@ -3586,24 +3586,24 @@ static int mark_user_output_FIXUP(void *p) { #ifdef MARKS_FOR_PORT_C #ifdef WINDOWS_PROCESSES -static int mark_thread_memory_SIZE(void *p) { +static int mark_thread_memory_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Memory)); } -static int mark_thread_memory_MARK(void *p) { +static int mark_thread_memory_MARK(void *p, struct NewGC *gc) { Scheme_Thread_Memory *tm = (Scheme_Thread_Memory *)p; - gcMARK(tm->prev); - gcMARK(tm->next); + gcMARK2(tm->prev, gc); + gcMARK2(tm->next, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Memory)); } -static int mark_thread_memory_FIXUP(void *p) { +static int mark_thread_memory_FIXUP(void *p, struct NewGC *gc) { Scheme_Thread_Memory *tm = (Scheme_Thread_Memory *)p; - gcFIXUP(tm->prev); - gcFIXUP(tm->next); + gcFIXUP2(tm->prev, gc); + gcFIXUP2(tm->next, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Memory)); @@ -3614,24 +3614,24 @@ static int mark_thread_memory_FIXUP(void *p) { #endif -static int mark_input_file_SIZE(void *p) { +static int mark_input_file_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Input_File)); } -static int mark_input_file_MARK(void *p) { +static int mark_input_file_MARK(void *p, struct NewGC *gc) { Scheme_Input_File *i = (Scheme_Input_File *)p; - gcMARK(i->f); + gcMARK2(i->f, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Input_File)); } -static int mark_input_file_FIXUP(void *p) { +static int mark_input_file_FIXUP(void *p, struct NewGC *gc) { Scheme_Input_File *i = (Scheme_Input_File *)p; - gcFIXUP(i->f); + gcFIXUP2(i->f, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Input_File)); @@ -3641,24 +3641,24 @@ static int mark_input_file_FIXUP(void *p) { #define mark_input_file_IS_CONST_SIZE 1 -static int mark_output_file_SIZE(void *p) { +static int mark_output_file_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Output_File)); } -static int mark_output_file_MARK(void *p) { +static int mark_output_file_MARK(void *p, struct NewGC *gc) { Scheme_Output_File *o = (Scheme_Output_File *)p; - gcMARK(o->f); + gcMARK2(o->f, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Output_File)); } -static int mark_output_file_FIXUP(void *p) { +static int mark_output_file_FIXUP(void *p, struct NewGC *gc) { Scheme_Output_File *o = (Scheme_Output_File *)p; - gcFIXUP(o->f); + gcFIXUP2(o->f, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Output_File)); @@ -3669,26 +3669,26 @@ static int mark_output_file_FIXUP(void *p) { #ifdef MZ_FDS -static int mark_input_fd_SIZE(void *p) { +static int mark_input_fd_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_FD)); } -static int mark_input_fd_MARK(void *p) { +static int mark_input_fd_MARK(void *p, struct NewGC *gc) { Scheme_FD *fd = (Scheme_FD *)p; - gcMARK(fd->buffer); - gcMARK(fd->refcount); + gcMARK2(fd->buffer, gc); + gcMARK2(fd->refcount, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_FD)); } -static int mark_input_fd_FIXUP(void *p) { +static int mark_input_fd_FIXUP(void *p, struct NewGC *gc) { Scheme_FD *fd = (Scheme_FD *)p; - gcFIXUP(fd->buffer); - gcFIXUP(fd->refcount); + gcFIXUP2(fd->buffer, gc); + gcFIXUP2(fd->refcount, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_FD)); @@ -3700,24 +3700,24 @@ static int mark_input_fd_FIXUP(void *p) { #endif #if defined(UNIX_PROCESSES) && !(defined(MZ_USE_PLACES) && defined(MZ_PRECISE_GC)) -static int mark_system_child_SIZE(void *p) { +static int mark_system_child_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(System_Child)); } -static int mark_system_child_MARK(void *p) { +static int mark_system_child_MARK(void *p, struct NewGC *gc) { System_Child *sc = (System_Child *)p; - gcMARK(sc->next); + gcMARK2(sc->next, gc); return gcBYTES_TO_WORDS(sizeof(System_Child)); } -static int mark_system_child_FIXUP(void *p) { +static int mark_system_child_FIXUP(void *p, struct NewGC *gc) { System_Child *sc = (System_Child *)p; - gcFIXUP(sc->next); + gcFIXUP2(sc->next, gc); return gcBYTES_TO_WORDS(sizeof(System_Child)); @@ -3729,26 +3729,26 @@ static int mark_system_child_FIXUP(void *p) { #endif #ifdef USE_OSKIT_CONSOLE -static int mark_oskit_console_input_SIZE(void *p) { +static int mark_oskit_console_input_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(osk_console_input)); } -static int mark_oskit_console_input_MARK(void *p) { +static int mark_oskit_console_input_MARK(void *p, struct NewGC *gc) { osk_console_input *c = (osk_console_input *)p; - gcMARK(c->buffer); - gcMARK(c->next); + gcMARK2(c->buffer, gc); + gcMARK2(c->next, gc); return gcBYTES_TO_WORDS(sizeof(osk_console_input)); } -static int mark_oskit_console_input_FIXUP(void *p) { +static int mark_oskit_console_input_FIXUP(void *p, struct NewGC *gc) { osk_console_input *c = (osk_console_input *)p; - gcFIXUP(c->buffer); - gcFIXUP(c->next); + gcFIXUP2(c->buffer, gc); + gcFIXUP2(c->next, gc); return gcBYTES_TO_WORDS(sizeof(osk_console_input)); @@ -3759,24 +3759,24 @@ static int mark_oskit_console_input_FIXUP(void *p) { #endif -static int mark_subprocess_SIZE(void *p) { +static int mark_subprocess_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Subprocess)); } -static int mark_subprocess_MARK(void *p) { +static int mark_subprocess_MARK(void *p, struct NewGC *gc) { #ifndef WINDOWS_PROCESSES Scheme_Subprocess *sp = (Scheme_Subprocess *)p; - gcMARK(sp->handle); + gcMARK2(sp->handle, gc); #endif return gcBYTES_TO_WORDS(sizeof(Scheme_Subprocess)); } -static int mark_subprocess_FIXUP(void *p) { +static int mark_subprocess_FIXUP(void *p, struct NewGC *gc) { #ifndef WINDOWS_PROCESSES Scheme_Subprocess *sp = (Scheme_Subprocess *)p; - gcFIXUP(sp->handle); + gcFIXUP2(sp->handle, gc); #endif return gcBYTES_TO_WORDS(sizeof(Scheme_Subprocess)); @@ -3786,25 +3786,25 @@ static int mark_subprocess_FIXUP(void *p) { #define mark_subprocess_IS_CONST_SIZE 1 -static int mark_read_write_evt_SIZE(void *p) { +static int mark_read_write_evt_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Read_Write_Evt)); } -static int mark_read_write_evt_MARK(void *p) { +static int mark_read_write_evt_MARK(void *p, struct NewGC *gc) { Scheme_Read_Write_Evt *rww = (Scheme_Read_Write_Evt *)p; - gcMARK(rww->port); - gcMARK(rww->v); - gcMARK(rww->str); + gcMARK2(rww->port, gc); + gcMARK2(rww->v, gc); + gcMARK2(rww->str, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Read_Write_Evt)); } -static int mark_read_write_evt_FIXUP(void *p) { +static int mark_read_write_evt_FIXUP(void *p, struct NewGC *gc) { Scheme_Read_Write_Evt *rww = (Scheme_Read_Write_Evt *)p; - gcFIXUP(rww->port); - gcFIXUP(rww->v); - gcFIXUP(rww->str); + gcFIXUP2(rww->port, gc); + gcFIXUP2(rww->v, gc); + gcFIXUP2(rww->str, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Read_Write_Evt)); } @@ -3819,25 +3819,25 @@ static int mark_read_write_evt_FIXUP(void *p) { #ifdef MARKS_FOR_PRINT_C -static int mark_print_params_SIZE(void *p) { +static int mark_print_params_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(PrintParams)); } -static int mark_print_params_MARK(void *p) { +static int mark_print_params_MARK(void *p, struct NewGC *gc) { PrintParams *pp = (PrintParams *)p; - gcMARK(pp->inspector); - gcMARK(pp->print_port); - gcMARK(pp->print_buffer); + gcMARK2(pp->inspector, gc); + gcMARK2(pp->print_port, gc); + gcMARK2(pp->print_buffer, gc); return gcBYTES_TO_WORDS(sizeof(PrintParams)); } -static int mark_print_params_FIXUP(void *p) { +static int mark_print_params_FIXUP(void *p, struct NewGC *gc) { PrintParams *pp = (PrintParams *)p; - gcFIXUP(pp->inspector); - gcFIXUP(pp->print_port); - gcFIXUP(pp->print_buffer); + gcFIXUP2(pp->inspector, gc); + gcFIXUP2(pp->print_port, gc); + gcFIXUP2(pp->print_buffer, gc); return gcBYTES_TO_WORDS(sizeof(PrintParams)); } @@ -3846,51 +3846,51 @@ static int mark_print_params_FIXUP(void *p) { #define mark_print_params_IS_CONST_SIZE 1 -static int mark_marshal_tables_SIZE(void *p) { +static int mark_marshal_tables_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Marshal_Tables)); } -static int mark_marshal_tables_MARK(void *p) { +static int mark_marshal_tables_MARK(void *p, struct NewGC *gc) { Scheme_Marshal_Tables *mt = (Scheme_Marshal_Tables *)p; - gcMARK(mt->symtab); - gcMARK(mt->rns); - gcMARK(mt->rn_refs); - gcMARK(mt->st_refs); - gcMARK(mt->st_ref_stack); - gcMARK(mt->reverse_map); - gcMARK(mt->same_map); - gcMARK(mt->cert_lists); - gcMARK(mt->shift_map); - gcMARK(mt->top_map); - gcMARK(mt->key_map); - gcMARK(mt->delay_map); - gcMARK(mt->cdata_map); - gcMARK(mt->rn_saved); - gcMARK(mt->shared_offsets); - gcMARK(mt->sorted_keys); + gcMARK2(mt->symtab, gc); + gcMARK2(mt->rns, gc); + gcMARK2(mt->rn_refs, gc); + gcMARK2(mt->st_refs, gc); + gcMARK2(mt->st_ref_stack, gc); + gcMARK2(mt->reverse_map, gc); + gcMARK2(mt->same_map, gc); + gcMARK2(mt->cert_lists, gc); + gcMARK2(mt->shift_map, gc); + gcMARK2(mt->top_map, gc); + gcMARK2(mt->key_map, gc); + gcMARK2(mt->delay_map, gc); + gcMARK2(mt->cdata_map, gc); + gcMARK2(mt->rn_saved, gc); + gcMARK2(mt->shared_offsets, gc); + gcMARK2(mt->sorted_keys, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Marshal_Tables)); } -static int mark_marshal_tables_FIXUP(void *p) { +static int mark_marshal_tables_FIXUP(void *p, struct NewGC *gc) { Scheme_Marshal_Tables *mt = (Scheme_Marshal_Tables *)p; - gcFIXUP(mt->symtab); - gcFIXUP(mt->rns); - gcFIXUP(mt->rn_refs); - gcFIXUP(mt->st_refs); - gcFIXUP(mt->st_ref_stack); - gcFIXUP(mt->reverse_map); - gcFIXUP(mt->same_map); - gcFIXUP(mt->cert_lists); - gcFIXUP(mt->shift_map); - gcFIXUP(mt->top_map); - gcFIXUP(mt->key_map); - gcFIXUP(mt->delay_map); - gcFIXUP(mt->cdata_map); - gcFIXUP(mt->rn_saved); - gcFIXUP(mt->shared_offsets); - gcFIXUP(mt->sorted_keys); + gcFIXUP2(mt->symtab, gc); + gcFIXUP2(mt->rns, gc); + gcFIXUP2(mt->rn_refs, gc); + gcFIXUP2(mt->st_refs, gc); + gcFIXUP2(mt->st_ref_stack, gc); + gcFIXUP2(mt->reverse_map, gc); + gcFIXUP2(mt->same_map, gc); + gcFIXUP2(mt->cert_lists, gc); + gcFIXUP2(mt->shift_map, gc); + gcFIXUP2(mt->top_map, gc); + gcFIXUP2(mt->key_map, gc); + gcFIXUP2(mt->delay_map, gc); + gcFIXUP2(mt->cdata_map, gc); + gcFIXUP2(mt->rn_saved, gc); + gcFIXUP2(mt->shared_offsets, gc); + gcFIXUP2(mt->sorted_keys, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Marshal_Tables)); } @@ -3905,28 +3905,28 @@ static int mark_marshal_tables_FIXUP(void *p) { #ifdef MARKS_FOR_NETWORK_C -static int mark_listener_SIZE(void *p) { +static int mark_listener_SIZE(void *p, struct NewGC *gc) { listener_t *l = (listener_t *)p; return gcBYTES_TO_WORDS(sizeof(listener_t) + ((l->count - 1) * sizeof(tcp_t))); } -static int mark_listener_MARK(void *p) { +static int mark_listener_MARK(void *p, struct NewGC *gc) { listener_t *l = (listener_t *)p; - gcMARK(l->mref); + gcMARK2(l->mref, gc); return gcBYTES_TO_WORDS(sizeof(listener_t) + ((l->count - 1) * sizeof(tcp_t))); } -static int mark_listener_FIXUP(void *p) { +static int mark_listener_FIXUP(void *p, struct NewGC *gc) { listener_t *l = (listener_t *)p; - gcFIXUP(l->mref); + gcFIXUP2(l->mref, gc); return gcBYTES_TO_WORDS(sizeof(listener_t) + ((l->count - 1) * sizeof(tcp_t))); @@ -3937,26 +3937,26 @@ static int mark_listener_FIXUP(void *p) { #ifdef USE_TCP -static int mark_tcp_SIZE(void *p) { +static int mark_tcp_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Tcp)); } -static int mark_tcp_MARK(void *p) { +static int mark_tcp_MARK(void *p, struct NewGC *gc) { Scheme_Tcp *tcp = (Scheme_Tcp *)p; - gcMARK(tcp->b.buffer); - gcMARK(tcp->b.out_buffer); + gcMARK2(tcp->b.buffer, gc); + gcMARK2(tcp->b.out_buffer, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Tcp)); } -static int mark_tcp_FIXUP(void *p) { +static int mark_tcp_FIXUP(void *p, struct NewGC *gc) { Scheme_Tcp *tcp = (Scheme_Tcp *)p; - gcFIXUP(tcp->b.buffer); - gcFIXUP(tcp->b.out_buffer); + gcFIXUP2(tcp->b.buffer, gc); + gcFIXUP2(tcp->b.out_buffer, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Tcp)); @@ -3967,26 +3967,26 @@ static int mark_tcp_FIXUP(void *p) { # ifdef UDP_IS_SUPPORTED -static int mark_udp_SIZE(void *p) { +static int mark_udp_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_UDP)); } -static int mark_udp_MARK(void *p) { +static int mark_udp_MARK(void *p, struct NewGC *gc) { Scheme_UDP *udp = (Scheme_UDP *)p; - gcMARK(udp->previous_from_addr); - gcMARK(udp->mref); + gcMARK2(udp->previous_from_addr, gc); + gcMARK2(udp->mref, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_UDP)); } -static int mark_udp_FIXUP(void *p) { +static int mark_udp_FIXUP(void *p, struct NewGC *gc) { Scheme_UDP *udp = (Scheme_UDP *)p; - gcFIXUP(udp->previous_from_addr); - gcFIXUP(udp->mref); + gcFIXUP2(udp->previous_from_addr, gc); + gcFIXUP2(udp->mref, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_UDP)); @@ -3996,28 +3996,28 @@ static int mark_udp_FIXUP(void *p) { #define mark_udp_IS_CONST_SIZE 1 -static int mark_udp_evt_SIZE(void *p) { +static int mark_udp_evt_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_UDP_Evt)); } -static int mark_udp_evt_MARK(void *p) { +static int mark_udp_evt_MARK(void *p, struct NewGC *gc) { Scheme_UDP_Evt *uw = (Scheme_UDP_Evt *)p; - gcMARK(uw->udp); - gcMARK(uw->str); - gcMARK(uw->dest_addr); + gcMARK2(uw->udp, gc); + gcMARK2(uw->str, gc); + gcMARK2(uw->dest_addr, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_UDP_Evt)); } -static int mark_udp_evt_FIXUP(void *p) { +static int mark_udp_evt_FIXUP(void *p, struct NewGC *gc) { Scheme_UDP_Evt *uw = (Scheme_UDP_Evt *)p; - gcFIXUP(uw->udp); - gcFIXUP(uw->str); - gcFIXUP(uw->dest_addr); + gcFIXUP2(uw->udp, gc); + gcFIXUP2(uw->str, gc); + gcFIXUP2(uw->dest_addr, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_UDP_Evt)); @@ -4035,34 +4035,34 @@ static int mark_udp_evt_FIXUP(void *p) { #ifdef MARKS_FOR_THREAD_C -static int mark_parameterization_SIZE(void *p) { +static int mark_parameterization_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS((sizeof(Scheme_Parameterization) + ((max_configs - 1) * sizeof(Scheme_Object*)))); } -static int mark_parameterization_MARK(void *p) { +static int mark_parameterization_MARK(void *p, struct NewGC *gc) { Scheme_Parameterization *c = (Scheme_Parameterization *)p; int i; for (i = max_configs; i--; ) { - gcMARK(c->prims[i]); + gcMARK2(c->prims[i], gc); } - gcMARK(c->extensions); + gcMARK2(c->extensions, gc); return gcBYTES_TO_WORDS((sizeof(Scheme_Parameterization) + ((max_configs - 1) * sizeof(Scheme_Object*)))); } -static int mark_parameterization_FIXUP(void *p) { +static int mark_parameterization_FIXUP(void *p, struct NewGC *gc) { Scheme_Parameterization *c = (Scheme_Parameterization *)p; int i; for (i = max_configs; i--; ) { - gcFIXUP(c->prims[i]); + gcFIXUP2(c->prims[i], gc); } - gcFIXUP(c->extensions); + gcFIXUP2(c->extensions, gc); return gcBYTES_TO_WORDS((sizeof(Scheme_Parameterization) @@ -4073,25 +4073,25 @@ static int mark_parameterization_FIXUP(void *p) { #define mark_parameterization_IS_CONST_SIZE 0 -static int mark_config_SIZE(void *p) { +static int mark_config_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Config)); } -static int mark_config_MARK(void *p) { +static int mark_config_MARK(void *p, struct NewGC *gc) { Scheme_Config *config = (Scheme_Config *)p; - gcMARK(config->key); - gcMARK(config->cell); - gcMARK(config->next); + gcMARK2(config->key, gc); + gcMARK2(config->cell, gc); + gcMARK2(config->next, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Config)); } -static int mark_config_FIXUP(void *p) { +static int mark_config_FIXUP(void *p, struct NewGC *gc) { Scheme_Config *config = (Scheme_Config *)p; - gcFIXUP(config->key); - gcFIXUP(config->cell); - gcFIXUP(config->next); + gcFIXUP2(config->key, gc); + gcFIXUP2(config->cell, gc); + gcFIXUP2(config->next, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Config)); } @@ -4100,28 +4100,28 @@ static int mark_config_FIXUP(void *p) { #define mark_config_IS_CONST_SIZE 1 -static int mark_will_executor_val_SIZE(void *p) { +static int mark_will_executor_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(WillExecutor)); } -static int mark_will_executor_val_MARK(void *p) { +static int mark_will_executor_val_MARK(void *p, struct NewGC *gc) { WillExecutor *e = (WillExecutor *)p; - gcMARK(e->sema); - gcMARK(e->first); - gcMARK(e->last); + gcMARK2(e->sema, gc); + gcMARK2(e->first, gc); + gcMARK2(e->last, gc); return gcBYTES_TO_WORDS(sizeof(WillExecutor)); } -static int mark_will_executor_val_FIXUP(void *p) { +static int mark_will_executor_val_FIXUP(void *p, struct NewGC *gc) { WillExecutor *e = (WillExecutor *)p; - gcFIXUP(e->sema); - gcFIXUP(e->first); - gcFIXUP(e->last); + gcFIXUP2(e->sema, gc); + gcFIXUP2(e->first, gc); + gcFIXUP2(e->last, gc); return gcBYTES_TO_WORDS(sizeof(WillExecutor)); @@ -4131,48 +4131,48 @@ static int mark_will_executor_val_FIXUP(void *p) { #define mark_will_executor_val_IS_CONST_SIZE 1 -static int mark_custodian_val_SIZE(void *p) { +static int mark_custodian_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Custodian)); } -static int mark_custodian_val_MARK(void *p) { +static int mark_custodian_val_MARK(void *p, struct NewGC *gc) { Scheme_Custodian *m = (Scheme_Custodian *)p; - gcMARK(m->boxes); - gcMARK(m->mrefs); - gcMARK(m->closers); - gcMARK(m->data); + gcMARK2(m->boxes, gc); + gcMARK2(m->mrefs, gc); + gcMARK2(m->closers, gc); + gcMARK2(m->data, gc); - gcMARK(m->parent); - gcMARK(m->sibling); - gcMARK(m->children); + gcMARK2(m->parent, gc); + gcMARK2(m->sibling, gc); + gcMARK2(m->children, gc); - gcMARK(m->global_next); - gcMARK(m->global_prev); + gcMARK2(m->global_next, gc); + gcMARK2(m->global_prev, gc); - gcMARK(m->cust_boxes); + gcMARK2(m->cust_boxes, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Custodian)); } -static int mark_custodian_val_FIXUP(void *p) { +static int mark_custodian_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Custodian *m = (Scheme_Custodian *)p; - gcFIXUP(m->boxes); - gcFIXUP(m->mrefs); - gcFIXUP(m->closers); - gcFIXUP(m->data); + gcFIXUP2(m->boxes, gc); + gcFIXUP2(m->mrefs, gc); + gcFIXUP2(m->closers, gc); + gcFIXUP2(m->data, gc); - gcFIXUP(m->parent); - gcFIXUP(m->sibling); - gcFIXUP(m->children); + gcFIXUP2(m->parent, gc); + gcFIXUP2(m->sibling, gc); + gcFIXUP2(m->children, gc); - gcFIXUP(m->global_next); - gcFIXUP(m->global_prev); + gcFIXUP2(m->global_next, gc); + gcFIXUP2(m->global_prev, gc); - gcFIXUP(m->cust_boxes); + gcFIXUP2(m->cust_boxes, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Custodian)); @@ -4182,31 +4182,31 @@ static int mark_custodian_val_FIXUP(void *p) { #define mark_custodian_val_IS_CONST_SIZE 1 -static int mark_custodian_box_val_SIZE(void *p) { +static int mark_custodian_box_val_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Custodian_Box)); } -static int mark_custodian_box_val_MARK(void *p) { +static int mark_custodian_box_val_MARK(void *p, struct NewGC *gc) { Scheme_Custodian_Box *b = (Scheme_Custodian_Box *)p; int sd = ((Scheme_Custodian *)GC_resolve(b->cust))->shut_down; - gcMARK(b->cust); + gcMARK2(b->cust, gc); if (!sd) { - gcMARK(b->v); + gcMARK2(b->v, gc); } return gcBYTES_TO_WORDS(sizeof(Scheme_Custodian_Box)); } -static int mark_custodian_box_val_FIXUP(void *p) { +static int mark_custodian_box_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Custodian_Box *b = (Scheme_Custodian_Box *)p; int sd = ((Scheme_Custodian *)GC_resolve(b->cust))->shut_down; - gcFIXUP(b->cust); + gcFIXUP2(b->cust, gc); if (!sd) { - gcFIXUP(b->v); + gcFIXUP2(b->v, gc); } return @@ -4217,24 +4217,24 @@ static int mark_custodian_box_val_FIXUP(void *p) { #define mark_custodian_box_val_IS_CONST_SIZE 1 -static int mark_thread_hop_SIZE(void *p) { +static int mark_thread_hop_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Custodian_Hop)); } -static int mark_thread_hop_MARK(void *p) { +static int mark_thread_hop_MARK(void *p, struct NewGC *gc) { Scheme_Thread_Custodian_Hop *hop = (Scheme_Thread_Custodian_Hop *)p; - gcMARK(hop->p); + gcMARK2(hop->p, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Custodian_Hop)); } -static int mark_thread_hop_FIXUP(void *p) { +static int mark_thread_hop_FIXUP(void *p, struct NewGC *gc) { Scheme_Thread_Custodian_Hop *hop = (Scheme_Thread_Custodian_Hop *)p; - gcFIXUP(hop->p); + gcFIXUP2(hop->p, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Custodian_Hop)); @@ -4244,30 +4244,30 @@ static int mark_thread_hop_FIXUP(void *p) { #define mark_thread_hop_IS_CONST_SIZE 1 -static int mark_param_data_SIZE(void *p) { +static int mark_param_data_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(ParamData)); } -static int mark_param_data_MARK(void *p) { +static int mark_param_data_MARK(void *p, struct NewGC *gc) { ParamData *d = (ParamData *)p; - gcMARK(d->key); - gcMARK(d->guard); - gcMARK(d->extract_guard); - gcMARK(d->defcell); + gcMARK2(d->key, gc); + gcMARK2(d->guard, gc); + gcMARK2(d->extract_guard, gc); + gcMARK2(d->defcell, gc); return gcBYTES_TO_WORDS(sizeof(ParamData)); } -static int mark_param_data_FIXUP(void *p) { +static int mark_param_data_FIXUP(void *p, struct NewGC *gc) { ParamData *d = (ParamData *)p; - gcFIXUP(d->key); - gcFIXUP(d->guard); - gcFIXUP(d->extract_guard); - gcFIXUP(d->defcell); + gcFIXUP2(d->key, gc); + gcFIXUP2(d->guard, gc); + gcFIXUP2(d->extract_guard, gc); + gcFIXUP2(d->defcell, gc); return gcBYTES_TO_WORDS(sizeof(ParamData)); @@ -4277,30 +4277,30 @@ static int mark_param_data_FIXUP(void *p) { #define mark_param_data_IS_CONST_SIZE 1 -static int mark_will_SIZE(void *p) { +static int mark_will_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(ActiveWill)); } -static int mark_will_MARK(void *p) { +static int mark_will_MARK(void *p, struct NewGC *gc) { ActiveWill *w = (ActiveWill *)p; - gcMARK(w->o); - gcMARK(w->proc); - gcMARK(w->w); - gcMARK(w->next); + gcMARK2(w->o, gc); + gcMARK2(w->proc, gc); + gcMARK2(w->w, gc); + gcMARK2(w->next, gc); return gcBYTES_TO_WORDS(sizeof(ActiveWill)); } -static int mark_will_FIXUP(void *p) { +static int mark_will_FIXUP(void *p, struct NewGC *gc) { ActiveWill *w = (ActiveWill *)p; - gcFIXUP(w->o); - gcFIXUP(w->proc); - gcFIXUP(w->w); - gcFIXUP(w->next); + gcFIXUP2(w->o, gc); + gcFIXUP2(w->proc, gc); + gcFIXUP2(w->w, gc); + gcFIXUP2(w->next, gc); return gcBYTES_TO_WORDS(sizeof(ActiveWill)); @@ -4310,17 +4310,17 @@ static int mark_will_FIXUP(void *p) { #define mark_will_IS_CONST_SIZE 1 -static int mark_evt_SIZE(void *p) { +static int mark_evt_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Evt)); } -static int mark_evt_MARK(void *p) { +static int mark_evt_MARK(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Evt)); } -static int mark_evt_FIXUP(void *p) { +static int mark_evt_FIXUP(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Evt)); } @@ -4329,34 +4329,34 @@ static int mark_evt_FIXUP(void *p) { #define mark_evt_IS_CONST_SIZE 1 -static int mark_syncing_SIZE(void *p) { +static int mark_syncing_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Syncing)); } -static int mark_syncing_MARK(void *p) { +static int mark_syncing_MARK(void *p, struct NewGC *gc) { Syncing *w = (Syncing *)p; - gcMARK(w->set); - gcMARK(w->wrapss); - gcMARK(w->nackss); - gcMARK(w->reposts); - gcMARK(w->accepts); - gcMARK(w->disable_break); + gcMARK2(w->set, gc); + gcMARK2(w->wrapss, gc); + gcMARK2(w->nackss, gc); + gcMARK2(w->reposts, gc); + gcMARK2(w->accepts, gc); + gcMARK2(w->disable_break, gc); return gcBYTES_TO_WORDS(sizeof(Syncing)); } -static int mark_syncing_FIXUP(void *p) { +static int mark_syncing_FIXUP(void *p, struct NewGC *gc) { Syncing *w = (Syncing *)p; - gcFIXUP(w->set); - gcFIXUP(w->wrapss); - gcFIXUP(w->nackss); - gcFIXUP(w->reposts); - gcFIXUP(w->accepts); - gcFIXUP(w->disable_break); + gcFIXUP2(w->set, gc); + gcFIXUP2(w->wrapss, gc); + gcFIXUP2(w->nackss, gc); + gcFIXUP2(w->reposts, gc); + gcFIXUP2(w->accepts, gc); + gcFIXUP2(w->disable_break, gc); return gcBYTES_TO_WORDS(sizeof(Syncing)); @@ -4366,26 +4366,26 @@ static int mark_syncing_FIXUP(void *p) { #define mark_syncing_IS_CONST_SIZE 1 -static int mark_evt_set_SIZE(void *p) { +static int mark_evt_set_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Evt_Set)); } -static int mark_evt_set_MARK(void *p) { +static int mark_evt_set_MARK(void *p, struct NewGC *gc) { Evt_Set *w = (Evt_Set *)p; - gcMARK(w->ws); - gcMARK(w->argv); + gcMARK2(w->ws, gc); + gcMARK2(w->argv, gc); return gcBYTES_TO_WORDS(sizeof(Evt_Set)); } -static int mark_evt_set_FIXUP(void *p) { +static int mark_evt_set_FIXUP(void *p, struct NewGC *gc) { Evt_Set *w = (Evt_Set *)p; - gcFIXUP(w->ws); - gcFIXUP(w->argv); + gcFIXUP2(w->ws, gc); + gcFIXUP2(w->argv, gc); return gcBYTES_TO_WORDS(sizeof(Evt_Set)); @@ -4395,34 +4395,34 @@ static int mark_evt_set_FIXUP(void *p) { #define mark_evt_set_IS_CONST_SIZE 1 -static int mark_thread_set_SIZE(void *p) { +static int mark_thread_set_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Set)); } -static int mark_thread_set_MARK(void *p) { +static int mark_thread_set_MARK(void *p, struct NewGC *gc) { Scheme_Thread_Set *ts = (Scheme_Thread_Set *)p; - gcMARK(ts->parent); - gcMARK(ts->first); - gcMARK(ts->next); - gcMARK(ts->prev); - gcMARK(ts->search_start); - gcMARK(ts->current); + gcMARK2(ts->parent, gc); + gcMARK2(ts->first, gc); + gcMARK2(ts->next, gc); + gcMARK2(ts->prev, gc); + gcMARK2(ts->search_start, gc); + gcMARK2(ts->current, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Set)); } -static int mark_thread_set_FIXUP(void *p) { +static int mark_thread_set_FIXUP(void *p, struct NewGC *gc) { Scheme_Thread_Set *ts = (Scheme_Thread_Set *)p; - gcFIXUP(ts->parent); - gcFIXUP(ts->first); - gcFIXUP(ts->next); - gcFIXUP(ts->prev); - gcFIXUP(ts->search_start); - gcFIXUP(ts->current); + gcFIXUP2(ts->parent, gc); + gcFIXUP2(ts->first, gc); + gcFIXUP2(ts->next, gc); + gcFIXUP2(ts->prev, gc); + gcFIXUP2(ts->search_start, gc); + gcFIXUP2(ts->current, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Set)); @@ -4432,24 +4432,24 @@ static int mark_thread_set_FIXUP(void *p) { #define mark_thread_set_IS_CONST_SIZE 1 -static int mark_thread_cell_SIZE(void *p) { +static int mark_thread_cell_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Thread_Cell)); } -static int mark_thread_cell_MARK(void *p) { +static int mark_thread_cell_MARK(void *p, struct NewGC *gc) { Thread_Cell *c = (Thread_Cell *)p; - gcMARK(c->def_val); + gcMARK2(c->def_val, gc); return gcBYTES_TO_WORDS(sizeof(Thread_Cell)); } -static int mark_thread_cell_FIXUP(void *p) { +static int mark_thread_cell_FIXUP(void *p, struct NewGC *gc) { Thread_Cell *c = (Thread_Cell *)p; - gcFIXUP(c->def_val); + gcFIXUP2(c->def_val, gc); return gcBYTES_TO_WORDS(sizeof(Thread_Cell)); @@ -4459,30 +4459,30 @@ static int mark_thread_cell_FIXUP(void *p) { #define mark_thread_cell_IS_CONST_SIZE 1 -static int mark_frozen_tramp_SIZE(void *p) { +static int mark_frozen_tramp_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(FrozenTramp)); } -static int mark_frozen_tramp_MARK(void *p) { +static int mark_frozen_tramp_MARK(void *p, struct NewGC *gc) { FrozenTramp *f = (FrozenTramp *)p; - gcMARK(f->do_data); - gcMARK(f->old_param); - gcMARK(f->config); - gcMARK(f->progress_cont); + gcMARK2(f->do_data, gc); + gcMARK2(f->old_param, gc); + gcMARK2(f->config, gc); + gcMARK2(f->progress_cont, gc); return gcBYTES_TO_WORDS(sizeof(FrozenTramp)); } -static int mark_frozen_tramp_FIXUP(void *p) { +static int mark_frozen_tramp_FIXUP(void *p, struct NewGC *gc) { FrozenTramp *f = (FrozenTramp *)p; - gcFIXUP(f->do_data); - gcFIXUP(f->old_param); - gcFIXUP(f->config); - gcFIXUP(f->progress_cont); + gcFIXUP2(f->do_data, gc); + gcFIXUP2(f->old_param, gc); + gcFIXUP2(f->config, gc); + gcFIXUP2(f->progress_cont, gc); return gcBYTES_TO_WORDS(sizeof(FrozenTramp)); @@ -4498,28 +4498,28 @@ static int mark_frozen_tramp_FIXUP(void *p) { #ifdef MARKS_FOR_SALLOC_C -static int mark_finalization_SIZE(void *p) { +static int mark_finalization_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Finalization)); } -static int mark_finalization_MARK(void *p) { +static int mark_finalization_MARK(void *p, struct NewGC *gc) { Finalization *f = (Finalization *)p; - gcMARK(f->data); - gcMARK(f->next); - gcMARK(f->prev); + gcMARK2(f->data, gc); + gcMARK2(f->next, gc); + gcMARK2(f->prev, gc); return gcBYTES_TO_WORDS(sizeof(Finalization)); } -static int mark_finalization_FIXUP(void *p) { +static int mark_finalization_FIXUP(void *p, struct NewGC *gc) { Finalization *f = (Finalization *)p; - gcFIXUP(f->data); - gcFIXUP(f->next); - gcFIXUP(f->prev); + gcFIXUP2(f->data, gc); + gcFIXUP2(f->next, gc); + gcFIXUP2(f->prev, gc); return gcBYTES_TO_WORDS(sizeof(Finalization)); @@ -4529,32 +4529,32 @@ static int mark_finalization_FIXUP(void *p) { #define mark_finalization_IS_CONST_SIZE 1 -static int mark_finalizations_SIZE(void *p) { +static int mark_finalizations_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Finalizations)); } -static int mark_finalizations_MARK(void *p) { +static int mark_finalizations_MARK(void *p, struct NewGC *gc) { Finalizations *f = (Finalizations *)p; - gcMARK(f->scheme_first); - gcMARK(f->scheme_last); - gcMARK(f->prim_first); - gcMARK(f->prim_last); - gcMARK(f->ext_data); + gcMARK2(f->scheme_first, gc); + gcMARK2(f->scheme_last, gc); + gcMARK2(f->prim_first, gc); + gcMARK2(f->prim_last, gc); + gcMARK2(f->ext_data, gc); return gcBYTES_TO_WORDS(sizeof(Finalizations)); } -static int mark_finalizations_FIXUP(void *p) { +static int mark_finalizations_FIXUP(void *p, struct NewGC *gc) { Finalizations *f = (Finalizations *)p; - gcFIXUP(f->scheme_first); - gcFIXUP(f->scheme_last); - gcFIXUP(f->prim_first); - gcFIXUP(f->prim_last); - gcFIXUP(f->ext_data); + gcFIXUP2(f->scheme_first, gc); + gcFIXUP2(f->scheme_last, gc); + gcFIXUP2(f->prim_first, gc); + gcFIXUP2(f->prim_last, gc); + gcFIXUP2(f->ext_data, gc); return gcBYTES_TO_WORDS(sizeof(Finalizations)); @@ -4570,32 +4570,32 @@ static int mark_finalizations_FIXUP(void *p) { #ifdef MARKS_FOR_SEMA_C -static int mark_channel_syncer_SIZE(void *p) { +static int mark_channel_syncer_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Syncer)); } -static int mark_channel_syncer_MARK(void *p) { +static int mark_channel_syncer_MARK(void *p, struct NewGC *gc) { Scheme_Channel_Syncer *w = (Scheme_Channel_Syncer *)p; - gcMARK(w->p); - gcMARK(w->prev); - gcMARK(w->next); - gcMARK(w->syncing); - gcMARK(w->obj); + gcMARK2(w->p, gc); + gcMARK2(w->prev, gc); + gcMARK2(w->next, gc); + gcMARK2(w->syncing, gc); + gcMARK2(w->obj, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Syncer)); } -static int mark_channel_syncer_FIXUP(void *p) { +static int mark_channel_syncer_FIXUP(void *p, struct NewGC *gc) { Scheme_Channel_Syncer *w = (Scheme_Channel_Syncer *)p; - gcFIXUP(w->p); - gcFIXUP(w->prev); - gcFIXUP(w->next); - gcFIXUP(w->syncing); - gcFIXUP(w->obj); + gcFIXUP2(w->p, gc); + gcFIXUP2(w->prev, gc); + gcFIXUP2(w->next, gc); + gcFIXUP2(w->syncing, gc); + gcFIXUP2(w->obj, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Syncer)); @@ -4605,17 +4605,17 @@ static int mark_channel_syncer_FIXUP(void *p) { #define mark_channel_syncer_IS_CONST_SIZE 1 -static int mark_alarm_SIZE(void *p) { +static int mark_alarm_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Alarm)); } -static int mark_alarm_MARK(void *p) { +static int mark_alarm_MARK(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Alarm)); } -static int mark_alarm_FIXUP(void *p) { +static int mark_alarm_FIXUP(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Alarm)); } @@ -4630,7 +4630,7 @@ static int mark_alarm_FIXUP(void *p) { #ifdef MARKS_FOR_STRUCT_C -static int mark_struct_val_SIZE(void *p) { +static int mark_struct_val_SIZE(void *p, struct NewGC *gc) { Scheme_Structure *s = (Scheme_Structure *)p; int num_slots = ((Scheme_Struct_Type *)GC_resolve(s->stype))->num_slots; @@ -4639,32 +4639,32 @@ static int mark_struct_val_SIZE(void *p) { + ((num_slots - 1) * sizeof(Scheme_Object *)))); } -static int mark_struct_val_MARK(void *p) { +static int mark_struct_val_MARK(void *p, struct NewGC *gc) { Scheme_Structure *s = (Scheme_Structure *)p; int num_slots = ((Scheme_Struct_Type *)GC_resolve(s->stype))->num_slots; int i; - gcMARK( s->stype); + gcMARK2( s->stype, gc); for(i = num_slots; i--; ) - gcMARK(s->slots[i]); + gcMARK2(s->slots[i], gc); return gcBYTES_TO_WORDS((sizeof(Scheme_Structure) + ((num_slots - 1) * sizeof(Scheme_Object *)))); } -static int mark_struct_val_FIXUP(void *p) { +static int mark_struct_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Structure *s = (Scheme_Structure *)p; int num_slots = ((Scheme_Struct_Type *)GC_resolve(s->stype))->num_slots; int i; - gcFIXUP_TYPED_NOW(Scheme_Struct_Type *, s->stype); + gcFIXUP2_TYPED_NOW(Scheme_Struct_Type *, s->stype, gc); for(i = num_slots; i--; ) - gcFIXUP(s->slots[i]); + gcFIXUP2(s->slots[i], gc); return gcBYTES_TO_WORDS((sizeof(Scheme_Structure) @@ -4675,7 +4675,7 @@ static int mark_struct_val_FIXUP(void *p) { #define mark_struct_val_IS_CONST_SIZE 0 -static int mark_struct_type_val_SIZE(void *p) { +static int mark_struct_type_val_SIZE(void *p, struct NewGC *gc) { Scheme_Struct_Type *t = (Scheme_Struct_Type *)p; return @@ -4683,46 +4683,46 @@ static int mark_struct_type_val_SIZE(void *p) { + (t->name_pos * sizeof(Scheme_Struct_Type *)))); } -static int mark_struct_type_val_MARK(void *p) { +static int mark_struct_type_val_MARK(void *p, struct NewGC *gc) { Scheme_Struct_Type *t = (Scheme_Struct_Type *)p; int i; for (i = t->name_pos + 1; i--; ) { - gcMARK(t->parent_types[i]); + gcMARK2(t->parent_types[i], gc); } - gcMARK(t->name); - gcMARK(t->inspector); - gcMARK(t->accessor); - gcMARK(t->mutator); - gcMARK(t->prefab_key); - gcMARK(t->uninit_val); - gcMARK(t->props); - gcMARK(t->proc_attr); - gcMARK(t->guard); - gcMARK(t->immutables); + gcMARK2(t->name, gc); + gcMARK2(t->inspector, gc); + gcMARK2(t->accessor, gc); + gcMARK2(t->mutator, gc); + gcMARK2(t->prefab_key, gc); + gcMARK2(t->uninit_val, gc); + gcMARK2(t->props, gc); + gcMARK2(t->proc_attr, gc); + gcMARK2(t->guard, gc); + gcMARK2(t->immutables, gc); return gcBYTES_TO_WORDS((sizeof(Scheme_Struct_Type) + (t->name_pos * sizeof(Scheme_Struct_Type *)))); } -static int mark_struct_type_val_FIXUP(void *p) { +static int mark_struct_type_val_FIXUP(void *p, struct NewGC *gc) { Scheme_Struct_Type *t = (Scheme_Struct_Type *)p; int i; for (i = t->name_pos + 1; i--; ) { - gcFIXUP(t->parent_types[i]); + gcFIXUP2(t->parent_types[i], gc); } - gcFIXUP(t->name); - gcFIXUP(t->inspector); - gcFIXUP(t->accessor); - gcFIXUP(t->mutator); - gcFIXUP(t->prefab_key); - gcFIXUP(t->uninit_val); - gcFIXUP(t->props); - gcFIXUP(t->proc_attr); - gcFIXUP(t->guard); - gcFIXUP(t->immutables); + gcFIXUP2(t->name, gc); + gcFIXUP2(t->inspector, gc); + gcFIXUP2(t->accessor, gc); + gcFIXUP2(t->mutator, gc); + gcFIXUP2(t->prefab_key, gc); + gcFIXUP2(t->uninit_val, gc); + gcFIXUP2(t->props, gc); + gcFIXUP2(t->proc_attr, gc); + gcFIXUP2(t->guard, gc); + gcFIXUP2(t->immutables, gc); return gcBYTES_TO_WORDS((sizeof(Scheme_Struct_Type) @@ -4733,26 +4733,26 @@ static int mark_struct_type_val_FIXUP(void *p) { #define mark_struct_type_val_IS_CONST_SIZE 0 -static int mark_struct_proc_info_SIZE(void *p) { +static int mark_struct_proc_info_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Struct_Proc_Info)); } -static int mark_struct_proc_info_MARK(void *p) { +static int mark_struct_proc_info_MARK(void *p, struct NewGC *gc) { Struct_Proc_Info *i = (Struct_Proc_Info *)p; - gcMARK(i->struct_type); - gcMARK(i->func_name); + gcMARK2(i->struct_type, gc); + gcMARK2(i->func_name, gc); return gcBYTES_TO_WORDS(sizeof(Struct_Proc_Info)); } -static int mark_struct_proc_info_FIXUP(void *p) { +static int mark_struct_proc_info_FIXUP(void *p, struct NewGC *gc) { Struct_Proc_Info *i = (Struct_Proc_Info *)p; - gcFIXUP(i->struct_type); - gcFIXUP(i->func_name); + gcFIXUP2(i->struct_type, gc); + gcFIXUP2(i->func_name, gc); return gcBYTES_TO_WORDS(sizeof(Struct_Proc_Info)); @@ -4762,25 +4762,25 @@ static int mark_struct_proc_info_FIXUP(void *p) { #define mark_struct_proc_info_IS_CONST_SIZE 1 -static int mark_struct_property_SIZE(void *p) { +static int mark_struct_property_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Struct_Property)); } -static int mark_struct_property_MARK(void *p) { +static int mark_struct_property_MARK(void *p, struct NewGC *gc) { Scheme_Struct_Property *i = (Scheme_Struct_Property *)p; - gcMARK(i->name); - gcMARK(i->guard); - gcMARK(i->supers); + gcMARK2(i->name, gc); + gcMARK2(i->guard, gc); + gcMARK2(i->supers, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Struct_Property)); } -static int mark_struct_property_FIXUP(void *p) { +static int mark_struct_property_FIXUP(void *p, struct NewGC *gc) { Scheme_Struct_Property *i = (Scheme_Struct_Property *)p; - gcFIXUP(i->name); - gcFIXUP(i->guard); - gcFIXUP(i->supers); + gcFIXUP2(i->name, gc); + gcFIXUP2(i->guard, gc); + gcFIXUP2(i->supers, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Struct_Property)); } @@ -4789,26 +4789,26 @@ static int mark_struct_property_FIXUP(void *p) { #define mark_struct_property_IS_CONST_SIZE 1 -static int mark_wrapped_evt_SIZE(void *p) { +static int mark_wrapped_evt_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Wrapped_Evt)); } -static int mark_wrapped_evt_MARK(void *p) { +static int mark_wrapped_evt_MARK(void *p, struct NewGC *gc) { Wrapped_Evt *ww = (Wrapped_Evt *)p; - gcMARK(ww->evt); - gcMARK(ww->wrapper); + gcMARK2(ww->evt, gc); + gcMARK2(ww->wrapper, gc); return gcBYTES_TO_WORDS(sizeof(Wrapped_Evt)); } -static int mark_wrapped_evt_FIXUP(void *p) { +static int mark_wrapped_evt_FIXUP(void *p, struct NewGC *gc) { Wrapped_Evt *ww = (Wrapped_Evt *)p; - gcFIXUP(ww->evt); - gcFIXUP(ww->wrapper); + gcFIXUP2(ww->evt, gc); + gcFIXUP2(ww->wrapper, gc); return gcBYTES_TO_WORDS(sizeof(Wrapped_Evt)); @@ -4818,24 +4818,24 @@ static int mark_wrapped_evt_FIXUP(void *p) { #define mark_wrapped_evt_IS_CONST_SIZE 1 -static int mark_nack_guard_evt_SIZE(void *p) { +static int mark_nack_guard_evt_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Nack_Guard_Evt)); } -static int mark_nack_guard_evt_MARK(void *p) { +static int mark_nack_guard_evt_MARK(void *p, struct NewGC *gc) { Nack_Guard_Evt *nw = (Nack_Guard_Evt *)p; - gcMARK(nw->maker); + gcMARK2(nw->maker, gc); return gcBYTES_TO_WORDS(sizeof(Nack_Guard_Evt)); } -static int mark_nack_guard_evt_FIXUP(void *p) { +static int mark_nack_guard_evt_FIXUP(void *p, struct NewGC *gc) { Nack_Guard_Evt *nw = (Nack_Guard_Evt *)p; - gcFIXUP(nw->maker); + gcFIXUP2(nw->maker, gc); return gcBYTES_TO_WORDS(sizeof(Nack_Guard_Evt)); @@ -4845,30 +4845,30 @@ static int mark_nack_guard_evt_FIXUP(void *p) { #define mark_nack_guard_evt_IS_CONST_SIZE 1 -static int mark_chaperone_SIZE(void *p) { +static int mark_chaperone_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Chaperone)); } -static int mark_chaperone_MARK(void *p) { +static int mark_chaperone_MARK(void *p, struct NewGC *gc) { Scheme_Chaperone *px = (Scheme_Chaperone *)p; - gcMARK(px->val); - gcMARK(px->prev); - gcMARK(px->props); - gcMARK(px->redirects); + gcMARK2(px->val, gc); + gcMARK2(px->prev, gc); + gcMARK2(px->props, gc); + gcMARK2(px->redirects, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Chaperone)); } -static int mark_chaperone_FIXUP(void *p) { +static int mark_chaperone_FIXUP(void *p, struct NewGC *gc) { Scheme_Chaperone *px = (Scheme_Chaperone *)p; - gcFIXUP(px->val); - gcFIXUP(px->prev); - gcFIXUP(px->props); - gcFIXUP(px->redirects); + gcFIXUP2(px->val, gc); + gcFIXUP2(px->prev, gc); + gcFIXUP2(px->props, gc); + gcFIXUP2(px->redirects, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Chaperone)); @@ -4890,17 +4890,17 @@ static int mark_chaperone_FIXUP(void *p) { #ifdef MARKS_FOR_READ_C -static int mark_indent_SIZE(void *p) { +static int mark_indent_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Indent)); } -static int mark_indent_MARK(void *p) { +static int mark_indent_MARK(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Indent)); } -static int mark_indent_FIXUP(void *p) { +static int mark_indent_FIXUP(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Indent)); } @@ -4909,41 +4909,41 @@ static int mark_indent_FIXUP(void *p) { #define mark_indent_IS_CONST_SIZE 1 -static int mark_cport_SIZE(void *p) { +static int mark_cport_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(CPort)); } -static int mark_cport_MARK(void *p) { +static int mark_cport_MARK(void *p, struct NewGC *gc) { CPort *cp = (CPort *)p; - gcMARK(cp->start); - gcMARK(cp->orig_port); - gcMARK(cp->ht); - gcMARK(cp->ut); - gcMARK(cp->symtab); - gcMARK(cp->insp); - gcMARK(cp->relto); - gcMARK(cp->magic_sym); - gcMARK(cp->magic_val); - gcMARK(cp->shared_offsets); - gcMARK(cp->delay_info); + gcMARK2(cp->start, gc); + gcMARK2(cp->orig_port, gc); + gcMARK2(cp->ht, gc); + gcMARK2(cp->ut, gc); + gcMARK2(cp->symtab, gc); + gcMARK2(cp->insp, gc); + gcMARK2(cp->relto, gc); + gcMARK2(cp->magic_sym, gc); + gcMARK2(cp->magic_val, gc); + gcMARK2(cp->shared_offsets, gc); + gcMARK2(cp->delay_info, gc); return gcBYTES_TO_WORDS(sizeof(CPort)); } -static int mark_cport_FIXUP(void *p) { +static int mark_cport_FIXUP(void *p, struct NewGC *gc) { CPort *cp = (CPort *)p; - gcFIXUP(cp->start); - gcFIXUP(cp->orig_port); - gcFIXUP(cp->ht); - gcFIXUP(cp->ut); - gcFIXUP(cp->symtab); - gcFIXUP(cp->insp); - gcFIXUP(cp->relto); - gcFIXUP(cp->magic_sym); - gcFIXUP(cp->magic_val); - gcFIXUP(cp->shared_offsets); - gcFIXUP(cp->delay_info); + gcFIXUP2(cp->start, gc); + gcFIXUP2(cp->orig_port, gc); + gcFIXUP2(cp->ht, gc); + gcFIXUP2(cp->ut, gc); + gcFIXUP2(cp->symtab, gc); + gcFIXUP2(cp->insp, gc); + gcFIXUP2(cp->relto, gc); + gcFIXUP2(cp->magic_sym, gc); + gcFIXUP2(cp->magic_val, gc); + gcFIXUP2(cp->shared_offsets, gc); + gcFIXUP2(cp->delay_info, gc); return gcBYTES_TO_WORDS(sizeof(CPort)); } @@ -4952,27 +4952,27 @@ static int mark_cport_FIXUP(void *p) { #define mark_cport_IS_CONST_SIZE 1 -static int mark_readtable_SIZE(void *p) { +static int mark_readtable_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Readtable)); } -static int mark_readtable_MARK(void *p) { +static int mark_readtable_MARK(void *p, struct NewGC *gc) { Readtable *t = (Readtable *)p; - gcMARK(t->mapping); - gcMARK(t->fast_mapping); - gcMARK(t->symbol_parser); - gcMARK(t->names); + gcMARK2(t->mapping, gc); + gcMARK2(t->fast_mapping, gc); + gcMARK2(t->symbol_parser, gc); + gcMARK2(t->names, gc); return gcBYTES_TO_WORDS(sizeof(Readtable)); } -static int mark_readtable_FIXUP(void *p) { +static int mark_readtable_FIXUP(void *p, struct NewGC *gc) { Readtable *t = (Readtable *)p; - gcFIXUP(t->mapping); - gcFIXUP(t->fast_mapping); - gcFIXUP(t->symbol_parser); - gcFIXUP(t->names); + gcFIXUP2(t->mapping, gc); + gcFIXUP2(t->fast_mapping, gc); + gcFIXUP2(t->symbol_parser, gc); + gcFIXUP2(t->names, gc); return gcBYTES_TO_WORDS(sizeof(Readtable)); } @@ -4981,27 +4981,27 @@ static int mark_readtable_FIXUP(void *p) { #define mark_readtable_IS_CONST_SIZE 1 -static int mark_read_params_SIZE(void *p) { +static int mark_read_params_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(ReadParams)); } -static int mark_read_params_MARK(void *p) { +static int mark_read_params_MARK(void *p, struct NewGC *gc) { ReadParams *rp = (ReadParams *)p; - gcMARK(rp->table); - gcMARK(rp->magic_sym); - gcMARK(rp->magic_val); - gcMARK(rp->delay_load_info); + gcMARK2(rp->table, gc); + gcMARK2(rp->magic_sym, gc); + gcMARK2(rp->magic_val, gc); + gcMARK2(rp->delay_load_info, gc); return gcBYTES_TO_WORDS(sizeof(ReadParams)); } -static int mark_read_params_FIXUP(void *p) { +static int mark_read_params_FIXUP(void *p, struct NewGC *gc) { ReadParams *rp = (ReadParams *)p; - gcFIXUP(rp->table); - gcFIXUP(rp->magic_sym); - gcFIXUP(rp->magic_val); - gcFIXUP(rp->delay_load_info); + gcFIXUP2(rp->table, gc); + gcFIXUP2(rp->magic_sym, gc); + gcFIXUP2(rp->magic_val, gc); + gcFIXUP2(rp->delay_load_info, gc); return gcBYTES_TO_WORDS(sizeof(ReadParams)); } @@ -5010,37 +5010,37 @@ static int mark_read_params_FIXUP(void *p) { #define mark_read_params_IS_CONST_SIZE 1 -static int mark_delay_load_SIZE(void *p) { +static int mark_delay_load_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Load_Delay)); } -static int mark_delay_load_MARK(void *p) { +static int mark_delay_load_MARK(void *p, struct NewGC *gc) { Scheme_Load_Delay *ld = (Scheme_Load_Delay *)p; - gcMARK(ld->path); - gcMARK(ld->symtab); - gcMARK(ld->shared_offsets); - gcMARK(ld->insp); - gcMARK(ld->relto); - gcMARK(ld->ut); - gcMARK(ld->current_rp); - gcMARK(ld->cached); - gcMARK(ld->cached_port); + gcMARK2(ld->path, gc); + gcMARK2(ld->symtab, gc); + gcMARK2(ld->shared_offsets, gc); + gcMARK2(ld->insp, gc); + gcMARK2(ld->relto, gc); + gcMARK2(ld->ut, gc); + gcMARK2(ld->current_rp, gc); + gcMARK2(ld->cached, gc); + gcMARK2(ld->cached_port, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Load_Delay)); } -static int mark_delay_load_FIXUP(void *p) { +static int mark_delay_load_FIXUP(void *p, struct NewGC *gc) { Scheme_Load_Delay *ld = (Scheme_Load_Delay *)p; - gcFIXUP(ld->path); - gcFIXUP(ld->symtab); - gcFIXUP(ld->shared_offsets); - gcFIXUP(ld->insp); - gcFIXUP(ld->relto); - gcFIXUP(ld->ut); - gcFIXUP(ld->current_rp); - gcFIXUP(ld->cached); - gcFIXUP(ld->cached_port); + gcFIXUP2(ld->path, gc); + gcFIXUP2(ld->symtab, gc); + gcFIXUP2(ld->shared_offsets, gc); + gcFIXUP2(ld->insp, gc); + gcFIXUP2(ld->relto, gc); + gcFIXUP2(ld->ut, gc); + gcFIXUP2(ld->current_rp, gc); + gcFIXUP2(ld->cached, gc); + gcFIXUP2(ld->cached_port, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Load_Delay)); } @@ -5049,25 +5049,25 @@ static int mark_delay_load_FIXUP(void *p) { #define mark_delay_load_IS_CONST_SIZE 1 -static int mark_unmarshal_tables_SIZE(void *p) { +static int mark_unmarshal_tables_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Unmarshal_Tables)); } -static int mark_unmarshal_tables_MARK(void *p) { +static int mark_unmarshal_tables_MARK(void *p, struct NewGC *gc) { Scheme_Unmarshal_Tables *ut = (Scheme_Unmarshal_Tables *)p; - gcMARK(ut->rns); - gcMARK(ut->rp); - gcMARK(ut->decoded); + gcMARK2(ut->rns, gc); + gcMARK2(ut->rp, gc); + gcMARK2(ut->decoded, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Unmarshal_Tables)); } -static int mark_unmarshal_tables_FIXUP(void *p) { +static int mark_unmarshal_tables_FIXUP(void *p, struct NewGC *gc) { Scheme_Unmarshal_Tables *ut = (Scheme_Unmarshal_Tables *)p; - gcFIXUP(ut->rns); - gcFIXUP(ut->rp); - gcFIXUP(ut->decoded); + gcFIXUP2(ut->rns, gc); + gcFIXUP2(ut->rp, gc); + gcFIXUP2(ut->decoded, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Unmarshal_Tables)); } @@ -5082,24 +5082,24 @@ static int mark_unmarshal_tables_FIXUP(void *p) { #ifdef MARKS_FOR_REGEXP_C -static int mark_regexp_SIZE(void *p) { +static int mark_regexp_SIZE(void *p, struct NewGC *gc) { regexp *r = (regexp *)p; return gcBYTES_TO_WORDS((sizeof(regexp) + r->regsize)); } -static int mark_regexp_MARK(void *p) { +static int mark_regexp_MARK(void *p, struct NewGC *gc) { regexp *r = (regexp *)p; - gcMARK(r->source); - gcMARK(r->regstart); + gcMARK2(r->source, gc); + gcMARK2(r->regstart, gc); return gcBYTES_TO_WORDS((sizeof(regexp) + r->regsize)); } -static int mark_regexp_FIXUP(void *p) { +static int mark_regexp_FIXUP(void *p, struct NewGC *gc) { regexp *r = (regexp *)p; - gcFIXUP(r->source); - gcFIXUP(r->regstart); + gcFIXUP2(r->source, gc); + gcFIXUP2(r->regstart, gc); return gcBYTES_TO_WORDS((sizeof(regexp) + r->regsize)); } @@ -5108,37 +5108,37 @@ static int mark_regexp_FIXUP(void *p) { #define mark_regexp_IS_CONST_SIZE 0 -static int mark_regwork_SIZE(void *p) { +static int mark_regwork_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Regwork)); } -static int mark_regwork_MARK(void *p) { +static int mark_regwork_MARK(void *p, struct NewGC *gc) { Regwork *r = (Regwork *)p; - gcMARK(r->str); - gcMARK(r->instr); - gcMARK(r->port); - gcMARK(r->unless_evt); - gcMARK(r->startp); - gcMARK(r->maybep); - gcMARK(r->endp); - gcMARK(r->counters); - gcMARK(r->peekskip); + gcMARK2(r->str, gc); + gcMARK2(r->instr, gc); + gcMARK2(r->port, gc); + gcMARK2(r->unless_evt, gc); + gcMARK2(r->startp, gc); + gcMARK2(r->maybep, gc); + gcMARK2(r->endp, gc); + gcMARK2(r->counters, gc); + gcMARK2(r->peekskip, gc); return gcBYTES_TO_WORDS(sizeof(Regwork)); } -static int mark_regwork_FIXUP(void *p) { +static int mark_regwork_FIXUP(void *p, struct NewGC *gc) { Regwork *r = (Regwork *)p; - gcFIXUP(r->str); - gcFIXUP(r->instr); - gcFIXUP(r->port); - gcFIXUP(r->unless_evt); - gcFIXUP(r->startp); - gcFIXUP(r->maybep); - gcFIXUP(r->endp); - gcFIXUP(r->counters); - gcFIXUP(r->peekskip); + gcFIXUP2(r->str, gc); + gcFIXUP2(r->instr, gc); + gcFIXUP2(r->port, gc); + gcFIXUP2(r->unless_evt, gc); + gcFIXUP2(r->startp, gc); + gcFIXUP2(r->maybep, gc); + gcFIXUP2(r->endp, gc); + gcFIXUP2(r->counters, gc); + gcFIXUP2(r->peekskip, gc); return gcBYTES_TO_WORDS(sizeof(Regwork)); } @@ -5153,21 +5153,21 @@ static int mark_regwork_FIXUP(void *p) { #ifdef MARKS_FOR_STRING_C -static int mark_string_convert_SIZE(void *p) { +static int mark_string_convert_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Converter)); } -static int mark_string_convert_MARK(void *p) { +static int mark_string_convert_MARK(void *p, struct NewGC *gc) { Scheme_Converter *c = (Scheme_Converter *)p; - gcMARK(c->mref); + gcMARK2(c->mref, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Converter)); } -static int mark_string_convert_FIXUP(void *p) { +static int mark_string_convert_FIXUP(void *p, struct NewGC *gc) { Scheme_Converter *c = (Scheme_Converter *)p; - gcFIXUP(c->mref); + gcFIXUP2(c->mref, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Converter)); } @@ -5182,35 +5182,35 @@ static int mark_string_convert_FIXUP(void *p) { #ifdef MARKS_FOR_STXOBJ_C -static int mark_rename_table_SIZE(void *p) { +static int mark_rename_table_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Module_Renames)); } -static int mark_rename_table_MARK(void *p) { +static int mark_rename_table_MARK(void *p, struct NewGC *gc) { Module_Renames *rn = (Module_Renames *)p; - gcMARK(rn->phase); - gcMARK(rn->ht); - gcMARK(rn->nomarshal_ht); - gcMARK(rn->unmarshal_info); - gcMARK(rn->shared_pes); - gcMARK(rn->set_identity); - gcMARK(rn->marked_names); - gcMARK(rn->free_id_renames); + gcMARK2(rn->phase, gc); + gcMARK2(rn->ht, gc); + gcMARK2(rn->nomarshal_ht, gc); + gcMARK2(rn->unmarshal_info, gc); + gcMARK2(rn->shared_pes, gc); + gcMARK2(rn->set_identity, gc); + gcMARK2(rn->marked_names, gc); + gcMARK2(rn->free_id_renames, gc); return gcBYTES_TO_WORDS(sizeof(Module_Renames)); } -static int mark_rename_table_FIXUP(void *p) { +static int mark_rename_table_FIXUP(void *p, struct NewGC *gc) { Module_Renames *rn = (Module_Renames *)p; - gcFIXUP(rn->phase); - gcFIXUP(rn->ht); - gcFIXUP(rn->nomarshal_ht); - gcFIXUP(rn->unmarshal_info); - gcFIXUP(rn->shared_pes); - gcFIXUP(rn->set_identity); - gcFIXUP(rn->marked_names); - gcFIXUP(rn->free_id_renames); + gcFIXUP2(rn->phase, gc); + gcFIXUP2(rn->ht, gc); + gcFIXUP2(rn->nomarshal_ht, gc); + gcFIXUP2(rn->unmarshal_info, gc); + gcFIXUP2(rn->shared_pes, gc); + gcFIXUP2(rn->set_identity, gc); + gcFIXUP2(rn->marked_names, gc); + gcFIXUP2(rn->free_id_renames, gc); return gcBYTES_TO_WORDS(sizeof(Module_Renames)); } @@ -5219,29 +5219,29 @@ static int mark_rename_table_FIXUP(void *p) { #define mark_rename_table_IS_CONST_SIZE 1 -static int mark_rename_table_set_SIZE(void *p) { +static int mark_rename_table_set_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Module_Renames_Set)); } -static int mark_rename_table_set_MARK(void *p) { +static int mark_rename_table_set_MARK(void *p, struct NewGC *gc) { Module_Renames_Set *rns = (Module_Renames_Set *)p; - gcMARK(rns->et); - gcMARK(rns->rt); - gcMARK(rns->other_phases); - gcMARK(rns->share_marked_names); - gcMARK(rns->set_identity); + gcMARK2(rns->et, gc); + gcMARK2(rns->rt, gc); + gcMARK2(rns->other_phases, gc); + gcMARK2(rns->share_marked_names, gc); + gcMARK2(rns->set_identity, gc); return gcBYTES_TO_WORDS(sizeof(Module_Renames_Set)); } -static int mark_rename_table_set_FIXUP(void *p) { +static int mark_rename_table_set_FIXUP(void *p, struct NewGC *gc) { Module_Renames_Set *rns = (Module_Renames_Set *)p; - gcFIXUP(rns->et); - gcFIXUP(rns->rt); - gcFIXUP(rns->other_phases); - gcFIXUP(rns->share_marked_names); - gcFIXUP(rns->set_identity); + gcFIXUP2(rns->et, gc); + gcFIXUP2(rns->rt, gc); + gcFIXUP2(rns->other_phases, gc); + gcFIXUP2(rns->share_marked_names, gc); + gcFIXUP2(rns->set_identity, gc); return gcBYTES_TO_WORDS(sizeof(Module_Renames_Set)); } @@ -5250,21 +5250,21 @@ static int mark_rename_table_set_FIXUP(void *p) { #define mark_rename_table_set_IS_CONST_SIZE 1 -static int mark_srcloc_SIZE(void *p) { +static int mark_srcloc_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Srcloc)); } -static int mark_srcloc_MARK(void *p) { +static int mark_srcloc_MARK(void *p, struct NewGC *gc) { Scheme_Stx_Srcloc *s = (Scheme_Stx_Srcloc *)p; - gcMARK(s->src); + gcMARK2(s->src, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Srcloc)); } -static int mark_srcloc_FIXUP(void *p) { +static int mark_srcloc_FIXUP(void *p, struct NewGC *gc) { Scheme_Stx_Srcloc *s = (Scheme_Stx_Srcloc *)p; - gcFIXUP(s->src); + gcFIXUP2(s->src, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Srcloc)); } @@ -5273,27 +5273,27 @@ static int mark_srcloc_FIXUP(void *p) { #define mark_srcloc_IS_CONST_SIZE 1 -static int mark_wrapchunk_SIZE(void *p) { +static int mark_wrapchunk_SIZE(void *p, struct NewGC *gc) { Wrap_Chunk *wc = (Wrap_Chunk *)p; return gcBYTES_TO_WORDS(sizeof(Wrap_Chunk) + ((wc->len - 1) * sizeof(Scheme_Object *))); } -static int mark_wrapchunk_MARK(void *p) { +static int mark_wrapchunk_MARK(void *p, struct NewGC *gc) { Wrap_Chunk *wc = (Wrap_Chunk *)p; int i; for (i = wc->len; i--; ) { - gcMARK(wc->a[i]); + gcMARK2(wc->a[i], gc); } return gcBYTES_TO_WORDS(sizeof(Wrap_Chunk) + ((wc->len - 1) * sizeof(Scheme_Object *))); } -static int mark_wrapchunk_FIXUP(void *p) { +static int mark_wrapchunk_FIXUP(void *p, struct NewGC *gc) { Wrap_Chunk *wc = (Wrap_Chunk *)p; int i; for (i = wc->len; i--; ) { - gcFIXUP(wc->a[i]); + gcFIXUP2(wc->a[i], gc); } return gcBYTES_TO_WORDS(sizeof(Wrap_Chunk) + ((wc->len - 1) * sizeof(Scheme_Object *))); @@ -5303,31 +5303,31 @@ static int mark_wrapchunk_FIXUP(void *p) { #define mark_wrapchunk_IS_CONST_SIZE 0 -static int mark_cert_SIZE(void *p) { +static int mark_cert_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Cert)); } -static int mark_cert_MARK(void *p) { +static int mark_cert_MARK(void *p, struct NewGC *gc) { Scheme_Cert *c = (Scheme_Cert *)p; - gcMARK(c->mark); - gcMARK(c->modidx); - gcMARK(c->insp); - gcMARK(c->key); - gcMARK(c->mapped); - gcMARK(c->next); + gcMARK2(c->mark, gc); + gcMARK2(c->modidx, gc); + gcMARK2(c->insp, gc); + gcMARK2(c->key, gc); + gcMARK2(c->mapped, gc); + gcMARK2(c->next, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Cert)); } -static int mark_cert_FIXUP(void *p) { +static int mark_cert_FIXUP(void *p, struct NewGC *gc) { Scheme_Cert *c = (Scheme_Cert *)p; - gcFIXUP(c->mark); - gcFIXUP(c->modidx); - gcFIXUP(c->insp); - gcFIXUP(c->key); - gcFIXUP(c->mapped); - gcFIXUP(c->next); + gcFIXUP2(c->mark, gc); + gcFIXUP2(c->modidx, gc); + gcFIXUP2(c->insp, gc); + gcFIXUP2(c->key, gc); + gcFIXUP2(c->mapped, gc); + gcFIXUP2(c->next, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Cert)); } @@ -5336,29 +5336,29 @@ static int mark_cert_FIXUP(void *p) { #define mark_cert_IS_CONST_SIZE 1 -static int lex_rib_SIZE(void *p) { +static int lex_rib_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Lexical_Rib)); } -static int lex_rib_MARK(void *p) { +static int lex_rib_MARK(void *p, struct NewGC *gc) { Scheme_Lexical_Rib *rib = (Scheme_Lexical_Rib *)p; - gcMARK(rib->rename); - gcMARK(rib->timestamp); - gcMARK(rib->sealed); - gcMARK(rib->mapped_names); - gcMARK(rib->next); + gcMARK2(rib->rename, gc); + gcMARK2(rib->timestamp, gc); + gcMARK2(rib->sealed, gc); + gcMARK2(rib->mapped_names, gc); + gcMARK2(rib->next, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Lexical_Rib)); } -static int lex_rib_FIXUP(void *p) { +static int lex_rib_FIXUP(void *p, struct NewGC *gc) { Scheme_Lexical_Rib *rib = (Scheme_Lexical_Rib *)p; - gcFIXUP(rib->rename); - gcFIXUP(rib->timestamp); - gcFIXUP(rib->sealed); - gcFIXUP(rib->mapped_names); - gcFIXUP(rib->next); + gcFIXUP2(rib->rename, gc); + gcFIXUP2(rib->timestamp, gc); + gcFIXUP2(rib->sealed, gc); + gcFIXUP2(rib->mapped_names, gc); + gcFIXUP2(rib->next, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Lexical_Rib)); } @@ -5367,28 +5367,28 @@ static int lex_rib_FIXUP(void *p) { #define lex_rib_IS_CONST_SIZE 1 -static int mark_free_id_info_SIZE(void *p) { +static int mark_free_id_info_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS((sizeof(Scheme_Vector) + ((8 - 1) * sizeof(Scheme_Object *)))); } -static int mark_free_id_info_MARK(void *p) { +static int mark_free_id_info_MARK(void *p, struct NewGC *gc) { Scheme_Vector *vec = (Scheme_Vector *)p; int i; for (i = 8; i--; ) - gcMARK(vec->els[i]); + gcMARK2(vec->els[i], gc); return gcBYTES_TO_WORDS((sizeof(Scheme_Vector) + ((8 - 1) * sizeof(Scheme_Object *)))); } -static int mark_free_id_info_FIXUP(void *p) { +static int mark_free_id_info_FIXUP(void *p, struct NewGC *gc) { Scheme_Vector *vec = (Scheme_Vector *)p; int i; for (i = 8; i--; ) - gcFIXUP(vec->els[i]); + gcFIXUP2(vec->els[i], gc); return gcBYTES_TO_WORDS((sizeof(Scheme_Vector) @@ -5407,7 +5407,7 @@ static int mark_free_id_info_FIXUP(void *p) { #ifdef MARKS_FOR_JIT_C -static int native_closure_SIZE(void *p) { +static int native_closure_SIZE(void *p, struct NewGC *gc) { Scheme_Native_Closure *c = (Scheme_Native_Closure *)p; int closure_size = ((Scheme_Native_Closure_Data *)GC_resolve(c->code))->closure_size; @@ -5420,7 +5420,7 @@ static int native_closure_SIZE(void *p) { + (closure_size - 1) * sizeof(Scheme_Object *))); } -static int native_closure_MARK(void *p) { +static int native_closure_MARK(void *p, struct NewGC *gc) { Scheme_Native_Closure *c = (Scheme_Native_Closure *)p; int closure_size = ((Scheme_Native_Closure_Data *)GC_resolve(c->code))->closure_size; @@ -5432,16 +5432,16 @@ static int native_closure_MARK(void *p) { { int i = closure_size; while (i--) - gcMARK(c->vals[i]); + gcMARK2(c->vals[i], gc); } - gcMARK(c->code); + gcMARK2(c->code, gc); return gcBYTES_TO_WORDS((sizeof(Scheme_Native_Closure) + (closure_size - 1) * sizeof(Scheme_Object *))); } -static int native_closure_FIXUP(void *p) { +static int native_closure_FIXUP(void *p, struct NewGC *gc) { Scheme_Native_Closure *c = (Scheme_Native_Closure *)p; int closure_size = ((Scheme_Native_Closure_Data *)GC_resolve(c->code))->closure_size; @@ -5453,9 +5453,9 @@ static int native_closure_FIXUP(void *p) { { int i = closure_size; while (i--) - gcFIXUP(c->vals[i]); + gcFIXUP2(c->vals[i], gc); } - gcFIXUP(c->code); + gcFIXUP2(c->code, gc); return gcBYTES_TO_WORDS((sizeof(Scheme_Native_Closure) @@ -5466,23 +5466,23 @@ static int native_closure_FIXUP(void *p) { #define native_closure_IS_CONST_SIZE 0 -static int mark_jit_state_SIZE(void *p) { +static int mark_jit_state_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(mz_jit_state)); } -static int mark_jit_state_MARK(void *p) { +static int mark_jit_state_MARK(void *p, struct NewGC *gc) { mz_jit_state *j = (mz_jit_state *)p; - gcMARK(j->mappings); - gcMARK(j->self_data); + gcMARK2(j->mappings, gc); + gcMARK2(j->self_data, gc); return gcBYTES_TO_WORDS(sizeof(mz_jit_state)); } -static int mark_jit_state_FIXUP(void *p) { +static int mark_jit_state_FIXUP(void *p, struct NewGC *gc) { mz_jit_state *j = (mz_jit_state *)p; - gcFIXUP(j->mappings); - gcFIXUP(j->self_data); + gcFIXUP2(j->mappings, gc); + gcFIXUP2(j->self_data, gc); return gcBYTES_TO_WORDS(sizeof(mz_jit_state)); } @@ -5491,41 +5491,41 @@ static int mark_jit_state_FIXUP(void *p) { #define mark_jit_state_IS_CONST_SIZE 1 -static int native_unclosed_proc_SIZE(void *p) { +static int native_unclosed_proc_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data)); } -static int native_unclosed_proc_MARK(void *p) { +static int native_unclosed_proc_MARK(void *p, struct NewGC *gc) { Scheme_Native_Closure_Data *d = (Scheme_Native_Closure_Data *)p; int i; - gcMARK(d->u2.name); + gcMARK2(d->u2.name, gc); if (d->retained) { for (i = SCHEME_INT_VAL(d->retained[0]); i--; ) { - gcMARK(d->retained[i]); + gcMARK2(d->retained[i], gc); } } if (d->closure_size < 0) { - gcMARK(d->u.arities); + gcMARK2(d->u.arities, gc); } return gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data)); } -static int native_unclosed_proc_FIXUP(void *p) { +static int native_unclosed_proc_FIXUP(void *p, struct NewGC *gc) { Scheme_Native_Closure_Data *d = (Scheme_Native_Closure_Data *)p; int i; - gcFIXUP(d->u2.name); + gcFIXUP2(d->u2.name, gc); if (d->retained) { for (i = SCHEME_INT_VAL(d->retained[0]); i--; ) { - gcFIXUP(d->retained[i]); + gcFIXUP2(d->retained[i], gc); } } if (d->closure_size < 0) { - gcFIXUP(d->u.arities); + gcFIXUP2(d->u.arities, gc); } return @@ -5536,26 +5536,26 @@ static int native_unclosed_proc_FIXUP(void *p) { #define native_unclosed_proc_IS_CONST_SIZE 1 -static int native_unclosed_proc_plus_case_SIZE(void *p) { +static int native_unclosed_proc_plus_case_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data_Plus_Case)); } -static int native_unclosed_proc_plus_case_MARK(void *p) { +static int native_unclosed_proc_plus_case_MARK(void *p, struct NewGC *gc) { Scheme_Native_Closure_Data_Plus_Case *d = (Scheme_Native_Closure_Data_Plus_Case *)p; - native_unclosed_proc_MARK(p); - gcMARK(d->case_lam); + native_unclosed_proc_MARK(p, gc); + gcMARK2(d->case_lam, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data_Plus_Case)); } -static int native_unclosed_proc_plus_case_FIXUP(void *p) { +static int native_unclosed_proc_plus_case_FIXUP(void *p, struct NewGC *gc) { Scheme_Native_Closure_Data_Plus_Case *d = (Scheme_Native_Closure_Data_Plus_Case *)p; - native_unclosed_proc_FIXUP(p); - gcFIXUP(d->case_lam); + native_unclosed_proc_FIXUP(p, gc); + gcFIXUP2(d->case_lam, gc); return gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data_Plus_Case)); @@ -5573,53 +5573,53 @@ static int native_unclosed_proc_plus_case_FIXUP(void *p) { #ifdef MZ_USE_FUTURES -static int future_SIZE(void *p) { +static int future_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(future_t)); } -static int future_MARK(void *p) { +static int future_MARK(void *p, struct NewGC *gc) { future_t *f = (future_t *)p; - gcMARK(f->orig_lambda); - gcMARK(f->arg_s0); - gcMARK(f->arg_S0); - gcMARK(f->arg_b0); - gcMARK(f->arg_n0); - gcMARK(f->arg_s1); - gcMARK(f->arg_S1); - gcMARK(f->arg_s2); - gcMARK(f->arg_S2); - gcMARK(f->retval_s); - gcMARK(f->retval); - gcMARK(f->multiple_array); - gcMARK(f->tail_rator); - gcMARK(f->tail_rands); - gcMARK(f->prev); - gcMARK(f->next); - gcMARK(f->next_waiting_atomic); + gcMARK2(f->orig_lambda, gc); + gcMARK2(f->arg_s0, gc); + gcMARK2(f->arg_S0, gc); + gcMARK2(f->arg_b0, gc); + gcMARK2(f->arg_n0, gc); + gcMARK2(f->arg_s1, gc); + gcMARK2(f->arg_S1, gc); + gcMARK2(f->arg_s2, gc); + gcMARK2(f->arg_S2, gc); + gcMARK2(f->retval_s, gc); + gcMARK2(f->retval, gc); + gcMARK2(f->multiple_array, gc); + gcMARK2(f->tail_rator, gc); + gcMARK2(f->tail_rands, gc); + gcMARK2(f->prev, gc); + gcMARK2(f->next, gc); + gcMARK2(f->next_waiting_atomic, gc); return gcBYTES_TO_WORDS(sizeof(future_t)); } -static int future_FIXUP(void *p) { +static int future_FIXUP(void *p, struct NewGC *gc) { future_t *f = (future_t *)p; - gcFIXUP(f->orig_lambda); - gcFIXUP(f->arg_s0); - gcFIXUP(f->arg_S0); - gcFIXUP(f->arg_b0); - gcFIXUP(f->arg_n0); - gcFIXUP(f->arg_s1); - gcFIXUP(f->arg_S1); - gcFIXUP(f->arg_s2); - gcFIXUP(f->arg_S2); - gcFIXUP(f->retval_s); - gcFIXUP(f->retval); - gcFIXUP(f->multiple_array); - gcFIXUP(f->tail_rator); - gcFIXUP(f->tail_rands); - gcFIXUP(f->prev); - gcFIXUP(f->next); - gcFIXUP(f->next_waiting_atomic); + gcFIXUP2(f->orig_lambda, gc); + gcFIXUP2(f->arg_s0, gc); + gcFIXUP2(f->arg_S0, gc); + gcFIXUP2(f->arg_b0, gc); + gcFIXUP2(f->arg_n0, gc); + gcFIXUP2(f->arg_s1, gc); + gcFIXUP2(f->arg_S1, gc); + gcFIXUP2(f->arg_s2, gc); + gcFIXUP2(f->arg_S2, gc); + gcFIXUP2(f->retval_s, gc); + gcFIXUP2(f->retval, gc); + gcFIXUP2(f->multiple_array, gc); + gcFIXUP2(f->tail_rator, gc); + gcFIXUP2(f->tail_rands, gc); + gcFIXUP2(f->prev, gc); + gcFIXUP2(f->next, gc); + gcFIXUP2(f->next_waiting_atomic, gc); return gcBYTES_TO_WORDS(sizeof(future_t)); } @@ -5630,27 +5630,27 @@ static int future_FIXUP(void *p) { #else -static int sequential_future_SIZE(void *p) { +static int sequential_future_SIZE(void *p, struct NewGC *gc) { return gcBYTES_TO_WORDS(sizeof(future_t)); } -static int sequential_future_MARK(void *p) { +static int sequential_future_MARK(void *p, struct NewGC *gc) { future_t *f = (future_t *)p; - gcMARK(f->orig_lambda); - gcMARK(f->running_sema); - gcMARK(f->retval); - gcMARK(f->multiple_array); + gcMARK2(f->orig_lambda, gc); + gcMARK2(f->running_sema, gc); + gcMARK2(f->retval, gc); + gcMARK2(f->multiple_array, gc); return gcBYTES_TO_WORDS(sizeof(future_t)); } -static int sequential_future_FIXUP(void *p) { +static int sequential_future_FIXUP(void *p, struct NewGC *gc) { future_t *f = (future_t *)p; - gcFIXUP(f->orig_lambda); - gcFIXUP(f->running_sema); - gcFIXUP(f->retval); - gcFIXUP(f->multiple_array); + gcFIXUP2(f->orig_lambda, gc); + gcFIXUP2(f->running_sema, gc); + gcFIXUP2(f->retval, gc); + gcFIXUP2(f->multiple_array, gc); return gcBYTES_TO_WORDS(sizeof(future_t)); } @@ -5665,4 +5665,4 @@ static int sequential_future_FIXUP(void *p) { /**********************************************************************/ -#define GC_REG_TRAV(type, base) GC_register_traversers(type, base ## _SIZE, base ## _MARK, base ## _FIXUP, base ## _IS_CONST_SIZE, base ## _IS_ATOMIC) +#define GC_REG_TRAV(type, base) GC_register_traversers2(type, base ## _SIZE, base ## _MARK, base ## _FIXUP, base ## _IS_CONST_SIZE, base ## _IS_ATOMIC) diff --git a/src/mzscheme/src/mzmarksrc.c b/src/mzscheme/src/mzmarksrc.c index 6541904fa2..e7a2538c15 100644 --- a/src/mzscheme/src/mzmarksrc.c +++ b/src/mzscheme/src/mzmarksrc.c @@ -5,9 +5,9 @@ variable_obj { mark: Scheme_Bucket *b = (Scheme_Bucket *)p; - gcMARK(b->key); - gcMARK(b->val); - gcMARK(((Scheme_Bucket_With_Home *)b)->home); + gcMARK2(b->key, gc); + gcMARK2(b->val, gc); + gcMARK2(((Scheme_Bucket_With_Home *)b)->home, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_With_Home)); @@ -17,9 +17,9 @@ module_var { mark: Module_Variable *mv = (Module_Variable *)p; - gcMARK(mv->modidx); - gcMARK(mv->sym); - gcMARK(mv->insp); + gcMARK2(mv->modidx, gc); + gcMARK2(mv->sym, gc); + gcMARK2(mv->insp, gc); size: gcBYTES_TO_WORDS(sizeof(Module_Variable)); @@ -29,8 +29,8 @@ bucket_obj { mark: Scheme_Bucket *b = (Scheme_Bucket *)p; - gcMARK(b->key); - gcMARK(b->val); + gcMARK2(b->key, gc); + gcMARK2(b->val, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Bucket)); @@ -57,9 +57,9 @@ quotesyntax_obj { cpointer_obj { mark: if (!(SCHEME_CPTR_FLAGS(p) & 0x1)) { - gcMARK(SCHEME_CPTR_VAL(p)); + gcMARK2(SCHEME_CPTR_VAL(p), gc); } - gcMARK(SCHEME_CPTR_TYPE(p)); + gcMARK2(SCHEME_CPTR_TYPE(p), gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Cptr)); } @@ -67,31 +67,31 @@ cpointer_obj { offset_cpointer_obj { mark: if (!(SCHEME_CPTR_FLAGS(p) & 0x1)) { - gcMARK(SCHEME_CPTR_VAL(p)); + gcMARK2(SCHEME_CPTR_VAL(p), gc); } - gcMARK(SCHEME_CPTR_TYPE(p)); + gcMARK2(SCHEME_CPTR_TYPE(p), gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Offset_Cptr)); } twoptr_obj { mark: - gcMARK(SCHEME_PTR1_VAL((Scheme_Object *)p)); - gcMARK(SCHEME_PTR2_VAL((Scheme_Object *)p)); + gcMARK2(SCHEME_PTR1_VAL((Scheme_Object *)p), gc); + gcMARK2(SCHEME_PTR2_VAL((Scheme_Object *)p), gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); } iptr_obj { mark: - gcMARK(SCHEME_IPTR_VAL((Scheme_Object *)p)); + gcMARK2(SCHEME_IPTR_VAL((Scheme_Object *)p), gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); } small_object { mark: - gcMARK(((Scheme_Small_Object *)p)->u.ptr_value); + gcMARK2(((Scheme_Small_Object *)p)->u.ptr_value, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object)); @@ -103,7 +103,7 @@ app_rec { mark: int i = r->num_args + 1; while (i--) - gcMARK(r->args[i]); + gcMARK2(r->args[i], gc); size: gcBYTES_TO_WORDS((sizeof(Scheme_App_Rec) @@ -114,8 +114,8 @@ app_rec { app2_rec { mark: Scheme_App2_Rec *r = (Scheme_App2_Rec *)p; - gcMARK(r->rator); - gcMARK(r->rand); + gcMARK2(r->rator, gc); + gcMARK2(r->rand, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_App2_Rec)); @@ -124,9 +124,9 @@ app2_rec { app3_rec { mark: Scheme_App3_Rec *r = (Scheme_App3_Rec *)p; - gcMARK(r->rator); - gcMARK(r->rand1); - gcMARK(r->rand2); + gcMARK2(r->rator, gc); + gcMARK2(r->rand1, gc); + gcMARK2(r->rand2, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_App3_Rec)); @@ -138,7 +138,7 @@ seq_rec { mark: int i = s->count; while (i--) - gcMARK(s->array[i]); + gcMARK2(s->array[i], gc); size: gcBYTES_TO_WORDS((sizeof(Scheme_Sequence) @@ -149,9 +149,9 @@ branch_rec { mark: Scheme_Branch_Rec *b = (Scheme_Branch_Rec *)p; - gcMARK(b->test); - gcMARK(b->tbranch); - gcMARK(b->fbranch); + gcMARK2(b->test, gc); + gcMARK2(b->tbranch, gc); + gcMARK2(b->fbranch, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Branch_Rec)); @@ -161,12 +161,12 @@ unclosed_proc { mark: Scheme_Closure_Data *d = (Scheme_Closure_Data *)p; - gcMARK(d->name); - gcMARK(d->code); - gcMARK(d->closure_map); + gcMARK2(d->name, gc); + gcMARK2(d->code, gc); + gcMARK2(d->closure_map, gc); #ifdef MZ_USE_JIT - gcMARK(d->u.native_code); - gcMARK(d->context); + gcMARK2(d->u.native_code, gc); + gcMARK2(d->context, gc); #endif size: @@ -177,8 +177,8 @@ let_value { mark: Scheme_Let_Value *l = (Scheme_Let_Value *)p; - gcMARK(l->value); - gcMARK(l->body); + gcMARK2(l->value, gc); + gcMARK2(l->body, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Let_Value)); @@ -188,7 +188,7 @@ let_void { mark: Scheme_Let_Void *l = (Scheme_Let_Void *)p; - gcMARK(l->body); + gcMARK2(l->body, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Let_Void)); @@ -198,8 +198,8 @@ letrec { mark: Scheme_Letrec *l = (Scheme_Letrec *)p; - gcMARK(l->procs); - gcMARK(l->body); + gcMARK2(l->procs, gc); + gcMARK2(l->body, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Letrec)); @@ -209,8 +209,8 @@ let_one { mark: Scheme_Let_One *l = (Scheme_Let_One *)p; - gcMARK(l->value); - gcMARK(l->body); + gcMARK2(l->value, gc); + gcMARK2(l->body, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Let_One)); @@ -220,9 +220,9 @@ with_cont_mark { mark: Scheme_With_Continuation_Mark *w = (Scheme_With_Continuation_Mark *)p; - gcMARK(w->key); - gcMARK(w->val); - gcMARK(w->body); + gcMARK2(w->key, gc); + gcMARK2(w->val, gc); + gcMARK2(w->body, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_With_Continuation_Mark)); @@ -232,9 +232,9 @@ comp_let_value { mark: Scheme_Compiled_Let_Value *c = (Scheme_Compiled_Let_Value *)p; - gcMARK(c->flags); - gcMARK(c->value); - gcMARK(c->body); + gcMARK2(c->flags, gc); + gcMARK2(c->value, gc); + gcMARK2(c->body, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Compiled_Let_Value)); @@ -244,7 +244,7 @@ let_header { mark: Scheme_Let_Header *h = (Scheme_Let_Header *)p; - gcMARK(h->body); + gcMARK2(h->body, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Let_Header)); @@ -254,15 +254,15 @@ prim_proc { Scheme_Primitive_Proc *prim = (Scheme_Primitive_Proc *)p; mark: - gcMARK(prim->name); + gcMARK2(prim->name, gc); if (prim->mina < 0) { - gcMARK(prim->mu.cases); + gcMARK2(prim->mu.cases, gc); } if (prim->pp.flags & SCHEME_PRIM_IS_CLOSURE) { Scheme_Primitive_Closure *cc = (Scheme_Primitive_Closure *)prim; int i; for (i = cc->count; i--; ) { - gcMARK(cc->val[i]); + gcMARK2(cc->val[i], gc); } } @@ -279,10 +279,10 @@ closed_prim_proc { Scheme_Closed_Primitive_Proc *c = (Scheme_Closed_Primitive_Proc *)p; mark: - gcMARK(c->name); - gcMARK(SCHEME_CLSD_PRIM_DATA(c)); + gcMARK2(c->name, gc); + gcMARK2(SCHEME_CLSD_PRIM_DATA(c), gc); if (c->mina == -2) { - gcMARK(((Scheme_Closed_Case_Primitive_Proc *)c)->cases); + gcMARK2(((Scheme_Closed_Case_Primitive_Proc *)c)->cases, gc); } size: @@ -303,8 +303,8 @@ scm_closure { int i = closure_size; while (i--) - gcMARK(c->vals[i]); - gcMARK(c->code); + gcMARK2(c->vals[i], gc); + gcMARK2(c->code, gc); size: gcBYTES_TO_WORDS((sizeof(Scheme_Closure) @@ -318,10 +318,10 @@ case_closure { int i; for (i = c->count; i--; ) - gcMARK(c->array[i]); - gcMARK(c->name); + gcMARK2(c->array[i], gc); + gcMARK2(c->name, gc); #ifdef MZ_USE_JIT - gcMARK(c->native_code); + gcMARK2(c->native_code, gc); #endif size: @@ -333,38 +333,38 @@ cont_proc { mark: Scheme_Cont *c = (Scheme_Cont *)p; - gcMARK(c->dw); - gcMARK(c->prompt_tag); - gcMARK(c->meta_continuation); - gcMARK(c->common_dw); - gcMARK(c->save_overflow); - gcMARK(c->runstack_copied); - gcMARK(c->runstack_owner); - gcMARK(c->cont_mark_stack_copied); - gcMARK(c->cont_mark_stack_owner); - gcMARK(c->init_config); - gcMARK(c->init_break_cell); + gcMARK2(c->dw, gc); + gcMARK2(c->prompt_tag, gc); + gcMARK2(c->meta_continuation, gc); + gcMARK2(c->common_dw, gc); + gcMARK2(c->save_overflow, gc); + gcMARK2(c->runstack_copied, gc); + gcMARK2(c->runstack_owner, gc); + gcMARK2(c->cont_mark_stack_copied, gc); + gcMARK2(c->cont_mark_stack_owner, gc); + gcMARK2(c->init_config, gc); + gcMARK2(c->init_break_cell, gc); #ifdef MZ_USE_JIT - gcMARK(c->native_trace); + gcMARK2(c->native_trace, gc); #endif - MARK_jmpup(&c->buf); - MARK_cjs(&c->cjs); - MARK_stack_state(&c->ss); - gcMARK(c->barrier_prompt); + MARK_jmpup(&c->buf, gc); + MARK_cjs(&c->cjs, gc); + MARK_stack_state(&c->ss, gc); + gcMARK2(c->barrier_prompt, gc); if (!GC_merely_accounting()) { - gcMARK(c->runstack_start); - gcMARK(c->runstack_saved); + gcMARK2(c->runstack_start, gc); + gcMARK2(c->runstack_saved, gc); } - gcMARK(c->prompt_id); - gcMARK(c->prompt_buf); + gcMARK2(c->prompt_id, gc); + gcMARK2(c->prompt_buf, gc); - gcMARK(c->value); - gcMARK(c->resume_to); - gcMARK(c->use_next_cont); - gcMARK(c->extra_marks); - gcMARK(c->shortcut_prompt); + gcMARK2(c->value, gc); + gcMARK2(c->resume_to, gc); + gcMARK2(c->use_next_cont, gc); + gcMARK2(c->extra_marks, gc); + gcMARK2(c->shortcut_prompt, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Cont)); @@ -374,11 +374,11 @@ meta_cont_proc { mark: Scheme_Meta_Continuation *c = (Scheme_Meta_Continuation *)p; - gcMARK(c->prompt_tag); - gcMARK(c->overflow); - gcMARK(c->next); - gcMARK(c->cont_mark_stack_copied); - gcMARK(c->cont); + gcMARK2(c->prompt_tag, gc); + gcMARK2(c->overflow, gc); + gcMARK2(c->next, gc); + gcMARK2(c->cont_mark_stack_copied, gc); + gcMARK2(c->cont, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Meta_Continuation)); @@ -388,12 +388,12 @@ mark_dyn_wind { mark: Scheme_Dynamic_Wind *dw = (Scheme_Dynamic_Wind *)p; - gcMARK(dw->id); - gcMARK(dw->data); - gcMARK(dw->prompt_tag); - gcMARK(dw->prev); + gcMARK2(dw->id, gc); + gcMARK2(dw->data, gc); + gcMARK2(dw->prompt_tag, gc); + gcMARK2(dw->prev, gc); - MARK_stack_state(&dw->envss); + MARK_stack_state(&dw->envss, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind)); @@ -403,9 +403,9 @@ mark_overflow { mark: Scheme_Overflow *o = (Scheme_Overflow *)p; - gcMARK(o->prev); - gcMARK(o->jmp); - gcMARK(o->id); + gcMARK2(o->prev, gc); + gcMARK2(o->jmp, gc); + gcMARK2(o->id, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Overflow)); @@ -415,7 +415,7 @@ mark_overflow_jmp { mark: Scheme_Overflow_Jmp *o = (Scheme_Overflow_Jmp *)p; - MARK_jmpup(&o->cont); + MARK_jmpup(&o->cont, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Overflow_Jmp)); @@ -426,11 +426,11 @@ escaping_cont_proc { Scheme_Escaping_Cont *c = (Scheme_Escaping_Cont *)p; #ifdef MZ_USE_JIT - gcMARK(c->native_trace); + gcMARK2(c->native_trace, gc); #endif - gcMARK(c->barrier_prompt); - MARK_stack_state(&c->envss); + gcMARK2(c->barrier_prompt, gc); + MARK_stack_state(&c->envss, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Escaping_Cont)); @@ -447,7 +447,7 @@ bignum_obj { mark: if (!SCHEME_BIGINLINE(b)) { - gcMARK(b->digits); + gcMARK2(b->digits, gc); } else { FIXUP_ONLY(b->digits = ((Small_Bignum *)GC_fixup_self(b))->v;) } @@ -462,8 +462,8 @@ rational_obj { mark: Scheme_Rational *r = (Scheme_Rational *)p; - gcMARK(r->num); - gcMARK(r->denom); + gcMARK2(r->num, gc); + gcMARK2(r->denom, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Rational)); @@ -489,8 +489,8 @@ complex_obj { mark: Scheme_Complex *c = (Scheme_Complex *)p; - gcMARK(c->r); - gcMARK(c->i); + gcMARK2(c->r, gc); + gcMARK2(c->i, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Complex)); @@ -499,7 +499,7 @@ complex_obj { string_obj { mark: Scheme_Object *o = (Scheme_Object *)p; - gcMARK(SCHEME_CHAR_STR_VAL(o)); + gcMARK2(SCHEME_CHAR_STR_VAL(o), gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); @@ -508,7 +508,7 @@ string_obj { bstring_obj { mark: Scheme_Object *o = (Scheme_Object *)p; - gcMARK(SCHEME_BYTE_STR_VAL(o)); + gcMARK2(SCHEME_BYTE_STR_VAL(o), gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); @@ -526,8 +526,8 @@ cons_cell { mark: Scheme_Object *o = (Scheme_Object *)p; - gcMARK(SCHEME_CAR(o)); - gcMARK(SCHEME_CDR(o)); + gcMARK2(SCHEME_CAR(o), gc); + gcMARK2(SCHEME_CDR(o), gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); @@ -539,7 +539,7 @@ vector_obj { mark: int i; for (i = vec->size; i--; ) - gcMARK(vec->els[i]); + gcMARK2(vec->els[i], gc); size: gcBYTES_TO_WORDS((sizeof(Scheme_Vector) @@ -559,23 +559,23 @@ input_port { mark: Scheme_Input_Port *ip = (Scheme_Input_Port *)p; - gcMARK(ip->sub_type); - gcMARK(ip->port_data); - gcMARK(ip->name); - gcMARK(ip->peeked_read); - gcMARK(ip->peeked_write); - gcMARK(ip->read_handler); - gcMARK(ip->mref); - gcMARK(ip->output_half); - gcMARK(ip->special); - gcMARK(ip->ungotten_special); - gcMARK(ip->progress_evt); - gcMARK(ip->input_lock); - gcMARK(ip->input_giveup); - gcMARK(ip->input_extras); - gcMARK(ip->input_extras_ready); - gcMARK(ip->unless); - gcMARK(ip->unless_cache); + gcMARK2(ip->sub_type, gc); + gcMARK2(ip->port_data, gc); + gcMARK2(ip->name, gc); + gcMARK2(ip->peeked_read, gc); + gcMARK2(ip->peeked_write, gc); + gcMARK2(ip->read_handler, gc); + gcMARK2(ip->mref, gc); + gcMARK2(ip->output_half, gc); + gcMARK2(ip->special, gc); + gcMARK2(ip->ungotten_special, gc); + gcMARK2(ip->progress_evt, gc); + gcMARK2(ip->input_lock, gc); + gcMARK2(ip->input_giveup, gc); + gcMARK2(ip->input_extras, gc); + gcMARK2(ip->input_extras_ready, gc); + gcMARK2(ip->unless, gc); + gcMARK2(ip->unless_cache, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Input_Port)); @@ -585,14 +585,14 @@ output_port { mark: Scheme_Output_Port *op = (Scheme_Output_Port *)p; - gcMARK(op->sub_type); - gcMARK(op->port_data); - gcMARK(op->name); - gcMARK(op->display_handler); - gcMARK(op->write_handler); - gcMARK(op->print_handler); - gcMARK(op->mref); - gcMARK(op->input_half); + gcMARK2(op->sub_type, gc); + gcMARK2(op->port_data, gc); + gcMARK2(op->name, gc); + gcMARK2(op->display_handler, gc); + gcMARK2(op->write_handler, gc); + gcMARK2(op->print_handler, gc); + gcMARK2(op->mref, gc); + gcMARK2(op->input_half, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Output_Port)); @@ -609,111 +609,111 @@ thread_val { mark: Scheme_Thread *pr = (Scheme_Thread *)p; - gcMARK(pr->next); - gcMARK(pr->prev); + gcMARK2(pr->next, gc); + gcMARK2(pr->prev, gc); - gcMARK(pr->t_set_parent); - gcMARK(pr->t_set_next); - gcMARK(pr->t_set_prev); + gcMARK2(pr->t_set_parent, gc); + gcMARK2(pr->t_set_next, gc); + gcMARK2(pr->t_set_prev, gc); - MARK_cjs(&pr->cjs); - gcMARK(pr->decompose_mc); + MARK_cjs(&pr->cjs, gc); + gcMARK2(pr->decompose_mc, gc); - gcMARK(pr->cell_values); - gcMARK(pr->init_config); - gcMARK(pr->init_break_cell); + gcMARK2(pr->cell_values, gc); + gcMARK2(pr->init_config, gc); + gcMARK2(pr->init_break_cell, gc); if (!pr->runstack_owner || !GC_merely_accounting() || (*pr->runstack_owner == pr)) { Scheme_Object **rs = pr->runstack_start; - gcFIXUP_TYPED_NOW(Scheme_Object **, pr->runstack_start); + gcFIXUP2_TYPED_NOW(Scheme_Object **, pr->runstack_start, gc); if (pr->runstack != pr->runstack_start + (pr->runstack - rs)) pr->runstack = pr->runstack_start + (pr->runstack - rs); - gcMARK(pr->runstack_saved); + gcMARK2(pr->runstack_saved, gc); } - gcMARK(pr->runstack_owner); - gcMARK(pr->runstack_swapped); + gcMARK2(pr->runstack_owner, gc); + gcMARK2(pr->runstack_swapped, gc); pr->spare_runstack = NULL; /* just in case */ - gcMARK(pr->meta_prompt); - gcMARK(pr->meta_continuation); + gcMARK2(pr->meta_prompt, gc); + gcMARK2(pr->meta_continuation, gc); - gcMARK(pr->cont_mark_stack_segments); - gcMARK(pr->cont_mark_stack_owner); - gcMARK(pr->cont_mark_stack_swapped); + gcMARK2(pr->cont_mark_stack_segments, gc); + gcMARK2(pr->cont_mark_stack_owner, gc); + gcMARK2(pr->cont_mark_stack_swapped, gc); - MARK_jmpup(&pr->jmpup_buf); + MARK_jmpup(&pr->jmpup_buf, gc); - gcMARK(pr->dw); + gcMARK2(pr->dw, gc); - gcMARK(pr->nester); - gcMARK(pr->nestee); + gcMARK2(pr->nester, gc); + gcMARK2(pr->nestee, gc); - gcMARK(pr->blocker); - gcMARK(pr->overflow); + gcMARK2(pr->blocker, gc); + gcMARK2(pr->overflow, gc); - gcMARK(pr->return_marks_to); - gcMARK(pr->returned_marks); + gcMARK2(pr->return_marks_to, gc); + gcMARK2(pr->returned_marks, gc); - gcMARK(pr->current_local_env); - gcMARK(pr->current_local_mark); - gcMARK(pr->current_local_name); - gcMARK(pr->current_local_certs); - gcMARK(pr->current_local_modidx); - gcMARK(pr->current_local_menv); - gcMARK(pr->current_local_bindings); + gcMARK2(pr->current_local_env, gc); + gcMARK2(pr->current_local_mark, gc); + gcMARK2(pr->current_local_name, gc); + gcMARK2(pr->current_local_certs, gc); + gcMARK2(pr->current_local_modidx, gc); + gcMARK2(pr->current_local_menv, gc); + gcMARK2(pr->current_local_bindings, gc); - gcMARK(pr->current_mt); + gcMARK2(pr->current_mt, gc); - gcMARK(pr->constant_folding); - gcMARK(pr->reading_delayed); + gcMARK2(pr->constant_folding, gc); + gcMARK2(pr->reading_delayed, gc); - gcMARK(pr->overflow_reply); + gcMARK2(pr->overflow_reply, gc); - gcMARK(pr->values_buffer); + gcMARK2(pr->values_buffer, gc); - gcMARK(pr->tail_buffer); + gcMARK2(pr->tail_buffer, gc); - gcMARK(pr->ku.eval.wait_expr); + gcMARK2(pr->ku.eval.wait_expr, gc); - gcMARK(pr->ku.apply.tail_rator); - gcMARK(pr->ku.apply.tail_rands); + gcMARK2(pr->ku.apply.tail_rator, gc); + gcMARK2(pr->ku.apply.tail_rands, gc); - gcMARK(pr->ku.multiple.array); + gcMARK2(pr->ku.multiple.array, gc); - gcMARK(pr->ku.k.p1); - gcMARK(pr->ku.k.p2); - gcMARK(pr->ku.k.p3); - gcMARK(pr->ku.k.p4); - gcMARK(pr->ku.k.p5); + gcMARK2(pr->ku.k.p1, gc); + gcMARK2(pr->ku.k.p2, gc); + gcMARK2(pr->ku.k.p3, gc); + gcMARK2(pr->ku.k.p4, gc); + gcMARK2(pr->ku.k.p5, gc); - gcMARK(pr->list_stack); + gcMARK2(pr->list_stack, gc); - gcMARK(pr->kill_data); - gcMARK(pr->private_kill_data); - gcMARK(pr->private_kill_next); + gcMARK2(pr->kill_data, gc); + gcMARK2(pr->private_kill_data, gc); + gcMARK2(pr->private_kill_next, gc); - gcMARK(pr->user_tls); - gcMARK(pr->gmp_tls_data); + gcMARK2(pr->user_tls, gc); + gcMARK2(pr->gmp_tls_data, gc); - gcMARK(pr->mr_hop); - gcMARK(pr->mref); - gcMARK(pr->extra_mrefs); + gcMARK2(pr->mr_hop, gc); + gcMARK2(pr->mref, gc); + gcMARK2(pr->extra_mrefs, gc); - gcMARK(pr->name); + gcMARK2(pr->name, gc); - gcMARK(pr->transitive_resumes); + gcMARK2(pr->transitive_resumes, gc); - gcMARK(pr->suspended_box); - gcMARK(pr->resumed_box); - gcMARK(pr->dead_box); - gcMARK(pr->running_box); + gcMARK2(pr->suspended_box, gc); + gcMARK2(pr->resumed_box, gc); + gcMARK2(pr->dead_box, gc); + gcMARK2(pr->running_box, gc); - gcMARK(pr->mbox_first); - gcMARK(pr->mbox_last); - gcMARK(pr->mbox_sema); + gcMARK2(pr->mbox_first, gc); + gcMARK2(pr->mbox_last, gc); + gcMARK2(pr->mbox_sema, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Thread)); } @@ -725,7 +725,7 @@ runstack_val { a = (void **)s + 4 + s[2]; b = (void **)s + 4 + s[3]; while (a < b) { - gcMARK(*a); + gcMARK2(*a, gc); a++; } more: @@ -751,11 +751,11 @@ runstack_val { prompt_val { mark: Scheme_Prompt *pr = (Scheme_Prompt *)p; - gcMARK(pr->boundary_overflow_id); + gcMARK2(pr->boundary_overflow_id, gc); if (!GC_merely_accounting()) - gcMARK(pr->runstack_boundary_start); - gcMARK(pr->tag); - gcMARK(pr->id); + gcMARK2(pr->runstack_boundary_start, gc); + gcMARK2(pr->tag, gc); + gcMARK2(pr->id, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Prompt)); } @@ -763,8 +763,8 @@ prompt_val { cont_mark_set_val { mark: Scheme_Cont_Mark_Set *s = (Scheme_Cont_Mark_Set *)p; - gcMARK(s->chain); - gcMARK(s->native_stack_trace); + gcMARK2(s->chain, gc); + gcMARK2(s->native_stack_trace, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Set)); @@ -774,8 +774,8 @@ sema_val { mark: Scheme_Sema *s = (Scheme_Sema *)p; - gcMARK(s->first); - gcMARK(s->last); + gcMARK2(s->first, gc); + gcMARK2(s->last, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Sema)); @@ -785,10 +785,10 @@ channel_val { mark: Scheme_Channel *s = (Scheme_Channel *)p; - gcMARK(s->get_first); - gcMARK(s->get_last); - gcMARK(s->put_first); - gcMARK(s->put_last); + gcMARK2(s->get_first, gc); + gcMARK2(s->get_last, gc); + gcMARK2(s->put_first, gc); + gcMARK2(s->put_last, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Channel)); @@ -798,8 +798,8 @@ channel_put_val { mark: Scheme_Channel_Put *s = (Scheme_Channel_Put *)p; - gcMARK(s->ch); - gcMARK(s->val); + gcMARK2(s->ch, gc); + gcMARK2(s->val, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Put)); @@ -809,9 +809,9 @@ hash_table_val { mark: Scheme_Hash_Table *ht = (Scheme_Hash_Table *)p; - gcMARK(ht->keys); - gcMARK(ht->vals); - gcMARK(ht->mutex); + gcMARK2(ht->keys, gc); + gcMARK2(ht->vals, gc); + gcMARK2(ht->mutex, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Table)); @@ -821,8 +821,8 @@ bucket_table_val { mark: Scheme_Bucket_Table *ht = (Scheme_Bucket_Table *)p; - gcMARK(ht->buckets); - gcMARK(ht->mutex); + gcMARK2(ht->buckets, gc); + gcMARK2(ht->mutex, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_Table)); @@ -832,36 +832,36 @@ namespace_val { mark: Scheme_Env *e = (Scheme_Env *)p; - gcMARK(e->module); - gcMARK(e->module_registry); - gcMARK(e->export_registry); - gcMARK(e->insp); + gcMARK2(e->module, gc); + gcMARK2(e->module_registry, gc); + gcMARK2(e->export_registry, gc); + gcMARK2(e->insp, gc); - gcMARK(e->rename_set); - gcMARK(e->temp_marked_names); - gcMARK(e->post_ex_rename_set); + gcMARK2(e->rename_set, gc); + gcMARK2(e->temp_marked_names, gc); + gcMARK2(e->post_ex_rename_set, gc); - gcMARK(e->syntax); - gcMARK(e->exp_env); - gcMARK(e->template_env); - gcMARK(e->label_env); + gcMARK2(e->syntax, gc); + gcMARK2(e->exp_env, gc); + gcMARK2(e->template_env, gc); + gcMARK2(e->label_env, gc); - gcMARK(e->shadowed_syntax); + gcMARK2(e->shadowed_syntax, gc); - gcMARK(e->link_midx); - gcMARK(e->require_names); - gcMARK(e->et_require_names); - gcMARK(e->tt_require_names); - gcMARK(e->dt_require_names); - gcMARK(e->other_require_names); - gcMARK(e->did_starts); - gcMARK(e->available_next[0]); - gcMARK(e->available_next[1]); + gcMARK2(e->link_midx, gc); + gcMARK2(e->require_names, gc); + gcMARK2(e->et_require_names, gc); + gcMARK2(e->tt_require_names, gc); + gcMARK2(e->dt_require_names, gc); + gcMARK2(e->other_require_names, gc); + gcMARK2(e->did_starts, gc); + gcMARK2(e->available_next[0], gc); + gcMARK2(e->available_next[1], gc); - gcMARK(e->toplevel); - gcMARK(e->modchain); + gcMARK2(e->toplevel, gc); + gcMARK2(e->modchain, gc); - gcMARK(e->modvars); + gcMARK2(e->modvars, gc); size: @@ -877,8 +877,8 @@ random_state_val { compilation_top_val { mark: Scheme_Compilation_Top *t = (Scheme_Compilation_Top *)p; - gcMARK(t->code); - gcMARK(t->prefix); + gcMARK2(t->code, gc); + gcMARK2(t->prefix, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Compilation_Top)); @@ -887,10 +887,10 @@ compilation_top_val { resolve_prefix_val { mark: Resolve_Prefix *rp = (Resolve_Prefix *)p; - gcMARK(rp->toplevels); - gcMARK(rp->stxes); - gcMARK(rp->delay_info_rpair); - gcMARK(rp->uses_unsafe); + gcMARK2(rp->toplevels, gc); + gcMARK2(rp->stxes, gc); + gcMARK2(rp->delay_info_rpair, gc); + gcMARK2(rp->uses_unsafe, gc); size: gcBYTES_TO_WORDS(sizeof(Resolve_Prefix)); @@ -899,9 +899,9 @@ resolve_prefix_val { comp_prefix_val { mark: Comp_Prefix *cp = (Comp_Prefix *)p; - gcMARK(cp->toplevels); - gcMARK(cp->stxes); - gcMARK(cp->uses_unsafe); + gcMARK2(cp->toplevels, gc); + gcMARK2(cp->stxes, gc); + gcMARK2(cp->uses_unsafe, gc); size: gcBYTES_TO_WORDS(sizeof(Comp_Prefix)); @@ -911,7 +911,7 @@ svector_val { mark: Scheme_Object *o = (Scheme_Object *)p; - gcMARK(SCHEME_SVEC_VEC(o)); + gcMARK2(SCHEME_SVEC_VEC(o), gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); @@ -920,13 +920,13 @@ svector_val { stx_val { mark: Scheme_Stx *stx = (Scheme_Stx *)p; - gcMARK(stx->val); - gcMARK(stx->srcloc); - gcMARK(stx->wraps); - gcMARK(stx->certs); - gcMARK(stx->props); + gcMARK2(stx->val, gc); + gcMARK2(stx->srcloc, gc); + gcMARK2(stx->wraps, gc); + gcMARK2(stx->certs, gc); + gcMARK2(stx->props, gc); if (!(MZ_OPT_HASH_KEY(&(stx)->iso) & STX_SUBSTX_FLAG)) - gcMARK(stx->u.modinfo_cache); + gcMARK2(stx->u.modinfo_cache, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Stx)); } @@ -934,7 +934,7 @@ stx_val { stx_off_val { mark: Scheme_Stx_Offset *o = (Scheme_Stx_Offset *)p; - gcMARK(o->src); + gcMARK2(o->src, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Offset)); } @@ -942,46 +942,46 @@ stx_off_val { module_val { mark: Scheme_Module *m = (Scheme_Module *)p; - gcMARK(m->modname); + gcMARK2(m->modname, gc); - gcMARK(m->et_requires); - gcMARK(m->requires); - gcMARK(m->tt_requires); - gcMARK(m->dt_requires); - gcMARK(m->other_requires); + gcMARK2(m->et_requires, gc); + gcMARK2(m->requires, gc); + gcMARK2(m->tt_requires, gc); + gcMARK2(m->dt_requires, gc); + gcMARK2(m->other_requires, gc); - gcMARK(m->body); - gcMARK(m->et_body); + gcMARK2(m->body, gc); + gcMARK2(m->et_body, gc); - gcMARK(m->me); + gcMARK2(m->me, gc); - gcMARK(m->provide_protects); - gcMARK(m->indirect_provides); + gcMARK2(m->provide_protects, gc); + gcMARK2(m->indirect_provides, gc); - gcMARK(m->indirect_syntax_provides); + gcMARK2(m->indirect_syntax_provides, gc); - gcMARK(m->et_provide_protects); - gcMARK(m->et_indirect_provides); + gcMARK2(m->et_provide_protects, gc); + gcMARK2(m->et_indirect_provides, gc); - gcMARK(m->self_modidx); + gcMARK2(m->self_modidx, gc); - gcMARK(m->accessible); - gcMARK(m->et_accessible); + gcMARK2(m->accessible, gc); + gcMARK2(m->et_accessible, gc); - gcMARK(m->insp); + gcMARK2(m->insp, gc); - gcMARK(m->lang_info); + gcMARK2(m->lang_info, gc); - gcMARK(m->hints); - gcMARK(m->ii_src); + gcMARK2(m->hints, gc); + gcMARK2(m->ii_src, gc); - gcMARK(m->comp_prefix); - gcMARK(m->prefix); - gcMARK(m->dummy); + gcMARK2(m->comp_prefix, gc); + gcMARK2(m->prefix, gc); + gcMARK2(m->dummy, gc); - gcMARK(m->rn_stx); + gcMARK2(m->rn_stx, gc); - gcMARK(m->primitive); + gcMARK2(m->primitive, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Module)); } @@ -990,21 +990,21 @@ module_phase_exports_val { mark: Scheme_Module_Phase_Exports *m = (Scheme_Module_Phase_Exports *)p; - gcMARK(m->phase_index); + gcMARK2(m->phase_index, gc); - gcMARK(m->src_modidx); + gcMARK2(m->src_modidx, gc); - gcMARK(m->provides); - gcMARK(m->provide_srcs); - gcMARK(m->provide_src_names); - gcMARK(m->provide_nominal_srcs); - gcMARK(m->provide_src_phases); - gcMARK(m->provide_insps); + gcMARK2(m->provides, gc); + gcMARK2(m->provide_srcs, gc); + gcMARK2(m->provide_src_names, gc); + gcMARK2(m->provide_nominal_srcs, gc); + gcMARK2(m->provide_src_phases, gc); + gcMARK2(m->provide_insps, gc); - gcMARK(m->kernel_exclusion); - gcMARK(m->kernel_exclusion2); + gcMARK2(m->kernel_exclusion, gc); + gcMARK2(m->kernel_exclusion2, gc); - gcMARK(m->ht); + gcMARK2(m->ht, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Module_Phase_Exports)); @@ -1014,12 +1014,12 @@ module_exports_val { mark: Scheme_Module_Exports *m = (Scheme_Module_Exports *)p; - gcMARK(m->rt); - gcMARK(m->et); - gcMARK(m->dt); - gcMARK(m->other_phases); + gcMARK2(m->rt, gc); + gcMARK2(m->et, gc); + gcMARK2(m->dt, gc); + gcMARK2(m->other_phases, gc); - gcMARK(m->src_modidx); + gcMARK2(m->src_modidx, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Module_Exports)); } @@ -1028,11 +1028,11 @@ modidx_val { mark: Scheme_Modidx *modidx = (Scheme_Modidx *)p; - gcMARK(modidx->path); - gcMARK(modidx->base); - gcMARK(modidx->resolved); - gcMARK(modidx->shift_cache); - gcMARK(modidx->cache_next); + gcMARK2(modidx->path, gc); + gcMARK2(modidx->base, gc); + gcMARK2(modidx->resolved, gc); + gcMARK2(modidx->shift_cache, gc); + gcMARK2(modidx->cache_next, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Modidx)); } @@ -1041,10 +1041,10 @@ guard_val { mark: Scheme_Security_Guard *g = (Scheme_Security_Guard *)p; - gcMARK(g->parent); - gcMARK(g->file_proc); - gcMARK(g->network_proc); - gcMARK(g->link_proc); + gcMARK2(g->parent, gc); + gcMARK2(g->file_proc, gc); + gcMARK2(g->network_proc, gc); + gcMARK2(g->link_proc, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Security_Guard)); } @@ -1053,7 +1053,7 @@ buf_holder { mark: Scheme_Jumpup_Buf_Holder *h = (Scheme_Jumpup_Buf_Holder *)p; - MARK_jmpup(&h->buf); + MARK_jmpup(&h->buf, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Jumpup_Buf_Holder)); @@ -1062,7 +1062,7 @@ buf_holder { mark_inspector { mark: Scheme_Inspector *i = (Scheme_Inspector *)p; - gcMARK(i->superior); + gcMARK2(i->superior, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Inspector)); } @@ -1071,9 +1071,9 @@ mark_pipe { mark: Scheme_Pipe *pp = (Scheme_Pipe *)p; - gcMARK(pp->buf); - gcMARK(pp->wakeup_on_read); - gcMARK(pp->wakeup_on_write); + gcMARK2(pp->buf, gc); + gcMARK2(pp->wakeup_on_read, gc); + gcMARK2(pp->wakeup_on_write, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Pipe)); @@ -1082,10 +1082,10 @@ mark_pipe { mark_logger { mark: Scheme_Logger *l = (Scheme_Logger *)p; - gcMARK(l->name); - gcMARK(l->parent); - gcMARK(l->readers); - gcMARK(l->timestamp); + gcMARK2(l->name, gc); + gcMARK2(l->parent, gc); + gcMARK2(l->readers, gc); + gcMARK2(l->timestamp, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Logger)); } @@ -1093,9 +1093,9 @@ mark_logger { mark_log_reader { mark: Scheme_Log_Reader *lr = (Scheme_Log_Reader *)p; - gcMARK(lr->sema); - gcMARK(lr->head); - gcMARK(lr->tail); + gcMARK2(lr->sema, gc); + gcMARK2(lr->head, gc); + gcMARK2(lr->tail, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Log_Reader)); } @@ -1121,26 +1121,26 @@ mark_comp_env { mark: Scheme_Full_Comp_Env *e = (Scheme_Full_Comp_Env *)p; - gcMARK(e->base.genv); - gcMARK(e->base.insp); - gcMARK(e->base.prefix); - gcMARK(e->base.next); - gcMARK(e->base.values); - gcMARK(e->base.certs); - gcMARK(e->base.renames); - gcMARK(e->base.uid); - gcMARK(e->base.uids); - gcMARK(e->base.dup_check); - gcMARK(e->base.intdef_name); - gcMARK(e->base.in_modidx); - gcMARK(e->base.skip_table); + gcMARK2(e->base.genv, gc); + gcMARK2(e->base.insp, gc); + gcMARK2(e->base.prefix, gc); + gcMARK2(e->base.next, gc); + gcMARK2(e->base.values, gc); + gcMARK2(e->base.certs, gc); + gcMARK2(e->base.renames, gc); + gcMARK2(e->base.uid, gc); + gcMARK2(e->base.uids, gc); + gcMARK2(e->base.dup_check, gc); + gcMARK2(e->base.intdef_name, gc); + gcMARK2(e->base.in_modidx, gc); + gcMARK2(e->base.skip_table, gc); - gcMARK(e->data.const_names); - gcMARK(e->data.const_vals); - gcMARK(e->data.const_uids); - gcMARK(e->data.sealed); - gcMARK(e->data.use); - gcMARK(e->data.lifts); + gcMARK2(e->data.const_names, gc); + gcMARK2(e->data.const_vals, gc); + gcMARK2(e->data.const_uids, gc); + gcMARK2(e->data.sealed, gc); + gcMARK2(e->data.use, gc); + gcMARK2(e->data.lifts, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Full_Comp_Env)); @@ -1150,15 +1150,15 @@ mark_resolve_info { mark: Resolve_Info *i = (Resolve_Info *)p; - gcMARK(i->prefix); - gcMARK(i->stx_map); - gcMARK(i->old_pos); - gcMARK(i->new_pos); - gcMARK(i->old_stx_pos); - gcMARK(i->flags); - gcMARK(i->lifts); - gcMARK(i->lifted); - gcMARK(i->next); + gcMARK2(i->prefix, gc); + gcMARK2(i->stx_map, gc); + gcMARK2(i->old_pos, gc); + gcMARK2(i->new_pos, gc); + gcMARK2(i->old_stx_pos, gc); + gcMARK2(i->flags, gc); + gcMARK2(i->lifts, gc); + gcMARK2(i->lifted, gc); + gcMARK2(i->next, gc); size: gcBYTES_TO_WORDS(sizeof(Resolve_Info)); @@ -1168,15 +1168,15 @@ mark_optimize_info { mark: Optimize_Info *i = (Optimize_Info *)p; - gcMARK(i->stat_dists); - gcMARK(i->sd_depths); - gcMARK(i->next); - gcMARK(i->use); - gcMARK(i->consts); - gcMARK(i->top_level_consts); - gcMARK(i->transitive_use); - gcMARK(i->transitive_use_len); - gcMARK(i->context); + gcMARK2(i->stat_dists, gc); + gcMARK2(i->sd_depths, gc); + gcMARK2(i->next, gc); + gcMARK2(i->use, gc); + gcMARK2(i->consts, gc); + gcMARK2(i->top_level_consts, gc); + gcMARK2(i->transitive_use, gc); + gcMARK2(i->transitive_use_len, gc); + gcMARK2(i->context, gc); size: gcBYTES_TO_WORDS(sizeof(Optimize_Info)); @@ -1186,9 +1186,9 @@ mark_sfs_info { mark: SFS_Info *i = (SFS_Info *)p; - gcMARK(i->max_used); - gcMARK(i->max_calls); - gcMARK(i->saved); + gcMARK2(i->max_used, gc); + gcMARK2(i->max_calls, gc); + gcMARK2(i->saved, gc); size: gcBYTES_TO_WORDS(sizeof(SFS_Info)); @@ -1197,9 +1197,9 @@ mark_sfs_info { mark_once_used { mark: Scheme_Once_Used *o = (Scheme_Once_Used *)p; - gcMARK(o->expr); - gcMARK(o->info); - gcMARK(o->next); + gcMARK2(o->expr, gc); + gcMARK2(o->info, gc); + gcMARK2(o->next, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Once_Used)); } @@ -1214,9 +1214,9 @@ mark_comp_info { mark: Scheme_Compile_Info *i = (Scheme_Compile_Info *)p; - gcMARK(i->value_name); - gcMARK(i->certs); - gcMARK(i->observer); + gcMARK2(i->value_name, gc); + gcMARK2(i->certs, gc); + gcMARK2(i->observer, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Compile_Info)); @@ -1226,8 +1226,8 @@ mark_saved_stack { mark: Scheme_Saved_Stack *saved = (Scheme_Saved_Stack *)p; - gcMARK(saved->prev); - gcMARK(saved->runstack_start); + gcMARK2(saved->prev, gc); + gcMARK2(saved->runstack_start, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Saved_Stack)); @@ -1237,8 +1237,8 @@ mark_validate_clearing { mark: Validate_Clearing *vc = (Validate_Clearing *)p; - gcMARK(vc->stack); - gcMARK(vc->ncstack); + gcMARK2(vc->stack, gc); + gcMARK2(vc->ncstack, gc); size: gcBYTES_TO_WORDS(sizeof(Validate_Clearing)); @@ -1254,7 +1254,7 @@ mark_reply_item { mark: ReplyItem *r = (ReplyItem *)p; - gcMARK(r->next); + gcMARK2(r->next, gc); size: gcBYTES_TO_WORDS(sizeof(ReplyItem)); @@ -1270,9 +1270,9 @@ mark_closure_info { mark: Closure_Info *i = (Closure_Info *)p; - gcMARK(i->local_flags); - gcMARK(i->base_closure_map); - gcMARK(i->flonum_map); + gcMARK2(i->local_flags, gc); + gcMARK2(i->base_closure_map, gc); + gcMARK2(i->flonum_map, gc); size: gcBYTES_TO_WORDS(sizeof(Closure_Info)); @@ -1282,8 +1282,8 @@ mark_dyn_wind_cell { mark: Scheme_Dynamic_Wind_List *l = (Scheme_Dynamic_Wind_List *)p; - gcMARK(l->dw); - gcMARK(l->next); + gcMARK2(l->dw, gc); + gcMARK2(l->next, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind_List)); @@ -1293,9 +1293,9 @@ mark_dyn_wind_info { mark: Dyn_Wind *d = (Dyn_Wind *)p; - gcMARK(d->pre); - gcMARK(d->act); - gcMARK(d->post); + gcMARK2(d->pre, gc); + gcMARK2(d->act, gc); + gcMARK2(d->post, gc); size: gcBYTES_TO_WORDS(sizeof(Dyn_Wind)); @@ -1305,9 +1305,9 @@ mark_cont_mark_chain { mark: Scheme_Cont_Mark_Chain *c = (Scheme_Cont_Mark_Chain *)p; - gcMARK(c->key); - gcMARK(c->val); - gcMARK(c->next); + gcMARK2(c->key, gc); + gcMARK2(c->val, gc); + gcMARK2(c->next, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Chain)); @@ -1323,8 +1323,8 @@ hash_tree_val { mark: Scheme_Hash_Tree *ht = (Scheme_Hash_Tree *)p; - gcMARK(ht->root); - gcMARK(ht->elems_box); + gcMARK2(ht->root, gc); + gcMARK2(ht->elems_box, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Tree)); @@ -1336,13 +1336,13 @@ mark_rb_node { /* Short-circuit on NULL pointers, which are especially likely */ if (rb->left) { - gcMARK(rb->left); + gcMARK2(rb->left, gc); } if (rb->right) { - gcMARK(rb->right); + gcMARK2(rb->right, gc); } - gcMARK(rb->key); - gcMARK(rb->val); + gcMARK2(rb->key, gc); + gcMARK2(rb->val, gc); size: gcBYTES_TO_WORDS(sizeof(RBNode)); @@ -1357,8 +1357,8 @@ START places; place_bi_channel_val { mark: Scheme_Place_Bi_Channel *pbc = (Scheme_Place_Bi_Channel *)p; - gcMARK(pbc->sendch); - gcMARK(pbc->recvch); + gcMARK2(pbc->sendch, gc); + gcMARK2(pbc->recvch, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Place_Bi_Channel)); @@ -1367,7 +1367,7 @@ place_bi_channel_val { place_val { mark: Scheme_Place *pr = (Scheme_Place *)p; - gcMARK(pr->channel); + gcMARK2(pr->channel, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Place)); @@ -1378,7 +1378,7 @@ place_async_channel_val { Scheme_Place_Async_Channel *pac = (Scheme_Place_Async_Channel *)p; int i; for (i = pac->size; i--; ) - gcMARK(pac->msgs[i]); + gcMARK2(pac->msgs[i], gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Place_Async_Channel)); @@ -1394,12 +1394,12 @@ mark_load_handler_data { mark: LoadHandlerData *d = (LoadHandlerData *)p; - gcMARK(d->config); - gcMARK(d->port); - gcMARK(d->p); - gcMARK(d->stxsrc); - gcMARK(d->expected_module); - gcMARK(d->delay_load_info); + gcMARK2(d->config, gc); + gcMARK2(d->port, gc); + gcMARK2(d->p, gc); + gcMARK2(d->stxsrc, gc); + gcMARK2(d->expected_module, gc); + gcMARK2(d->delay_load_info, gc); size: gcBYTES_TO_WORDS(sizeof(LoadHandlerData)); @@ -1409,7 +1409,7 @@ mark_indexed_string { mark: Scheme_Indexed_String *is = (Scheme_Indexed_String *)p; - gcMARK(is->string); + gcMARK2(is->string, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Indexed_String)); @@ -1419,17 +1419,17 @@ mark_user_input { mark: User_Input_Port *uip = (User_Input_Port *)p; - gcMARK(uip->read_proc); - gcMARK(uip->peek_proc); - gcMARK(uip->progress_evt_proc); - gcMARK(uip->peeked_read_proc); - gcMARK(uip->location_proc); - gcMARK(uip->count_lines_proc); - gcMARK(uip->buffer_mode_proc); - gcMARK(uip->close_proc); - gcMARK(uip->reuse_str); - gcMARK(uip->peeked); - gcMARK(uip->prefix_pipe); + gcMARK2(uip->read_proc, gc); + gcMARK2(uip->peek_proc, gc); + gcMARK2(uip->progress_evt_proc, gc); + gcMARK2(uip->peeked_read_proc, gc); + gcMARK2(uip->location_proc, gc); + gcMARK2(uip->count_lines_proc, gc); + gcMARK2(uip->buffer_mode_proc, gc); + gcMARK2(uip->close_proc, gc); + gcMARK2(uip->reuse_str, gc); + gcMARK2(uip->peeked, gc); + gcMARK2(uip->prefix_pipe, gc); size: gcBYTES_TO_WORDS(sizeof(User_Input_Port)); } @@ -1438,16 +1438,16 @@ mark_user_output { mark: User_Output_Port *uop = (User_Output_Port *)p; - gcMARK(uop->evt); - gcMARK(uop->write_evt_proc); - gcMARK(uop->write_proc); - gcMARK(uop->write_special_evt_proc); - gcMARK(uop->write_special_proc); - gcMARK(uop->location_proc); - gcMARK(uop->count_lines_proc); - gcMARK(uop->buffer_mode_proc); - gcMARK(uop->close_proc); - gcMARK(uop->buffer_pipe); + gcMARK2(uop->evt, gc); + gcMARK2(uop->write_evt_proc, gc); + gcMARK2(uop->write_proc, gc); + gcMARK2(uop->write_special_evt_proc, gc); + gcMARK2(uop->write_special_proc, gc); + gcMARK2(uop->location_proc, gc); + gcMARK2(uop->count_lines_proc, gc); + gcMARK2(uop->buffer_mode_proc, gc); + gcMARK2(uop->close_proc, gc); + gcMARK2(uop->buffer_pipe, gc); size: gcBYTES_TO_WORDS(sizeof(User_Output_Port)); } @@ -1462,8 +1462,8 @@ START port; mark_thread_memory { mark: Scheme_Thread_Memory *tm = (Scheme_Thread_Memory *)p; - gcMARK(tm->prev); - gcMARK(tm->next); + gcMARK2(tm->prev, gc); + gcMARK2(tm->next, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Memory)); @@ -1474,7 +1474,7 @@ mark_input_file { mark: Scheme_Input_File *i = (Scheme_Input_File *)p; - gcMARK(i->f); + gcMARK2(i->f, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Input_File)); @@ -1484,7 +1484,7 @@ mark_output_file { mark: Scheme_Output_File *o = (Scheme_Output_File *)p; - gcMARK(o->f); + gcMARK2(o->f, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Output_File)); @@ -1495,8 +1495,8 @@ mark_input_fd { mark: Scheme_FD *fd = (Scheme_FD *)p; - gcMARK(fd->buffer); - gcMARK(fd->refcount); + gcMARK2(fd->buffer, gc); + gcMARK2(fd->refcount, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_FD)); @@ -1508,7 +1508,7 @@ mark_system_child { mark: System_Child *sc = (System_Child *)p; - gcMARK(sc->next); + gcMARK2(sc->next, gc); size: gcBYTES_TO_WORDS(sizeof(System_Child)); @@ -1520,8 +1520,8 @@ mark_oskit_console_input { mark: osk_console_input *c = (osk_console_input *)p; - gcMARK(c->buffer); - gcMARK(c->next); + gcMARK2(c->buffer, gc); + gcMARK2(c->next, gc); size: gcBYTES_TO_WORDS(sizeof(osk_console_input)); @@ -1532,7 +1532,7 @@ mark_subprocess { mark: #ifndef WINDOWS_PROCESSES Scheme_Subprocess *sp = (Scheme_Subprocess *)p; - gcMARK(sp->handle); + gcMARK2(sp->handle, gc); #endif size: gcBYTES_TO_WORDS(sizeof(Scheme_Subprocess)); @@ -1541,9 +1541,9 @@ mark_subprocess { mark_read_write_evt { mark: Scheme_Read_Write_Evt *rww = (Scheme_Read_Write_Evt *)p; - gcMARK(rww->port); - gcMARK(rww->v); - gcMARK(rww->str); + gcMARK2(rww->port, gc); + gcMARK2(rww->v, gc); + gcMARK2(rww->str, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Read_Write_Evt)); } @@ -1557,9 +1557,9 @@ START print; mark_print_params { mark: PrintParams *pp = (PrintParams *)p; - gcMARK(pp->inspector); - gcMARK(pp->print_port); - gcMARK(pp->print_buffer); + gcMARK2(pp->inspector, gc); + gcMARK2(pp->print_port, gc); + gcMARK2(pp->print_buffer, gc); size: gcBYTES_TO_WORDS(sizeof(PrintParams)); } @@ -1567,22 +1567,22 @@ mark_print_params { mark_marshal_tables { mark: Scheme_Marshal_Tables *mt = (Scheme_Marshal_Tables *)p; - gcMARK(mt->symtab); - gcMARK(mt->rns); - gcMARK(mt->rn_refs); - gcMARK(mt->st_refs); - gcMARK(mt->st_ref_stack); - gcMARK(mt->reverse_map); - gcMARK(mt->same_map); - gcMARK(mt->cert_lists); - gcMARK(mt->shift_map); - gcMARK(mt->top_map); - gcMARK(mt->key_map); - gcMARK(mt->delay_map); - gcMARK(mt->cdata_map); - gcMARK(mt->rn_saved); - gcMARK(mt->shared_offsets); - gcMARK(mt->sorted_keys); + gcMARK2(mt->symtab, gc); + gcMARK2(mt->rns, gc); + gcMARK2(mt->rn_refs, gc); + gcMARK2(mt->st_refs, gc); + gcMARK2(mt->st_ref_stack, gc); + gcMARK2(mt->reverse_map, gc); + gcMARK2(mt->same_map, gc); + gcMARK2(mt->cert_lists, gc); + gcMARK2(mt->shift_map, gc); + gcMARK2(mt->top_map, gc); + gcMARK2(mt->key_map, gc); + gcMARK2(mt->delay_map, gc); + gcMARK2(mt->cdata_map, gc); + gcMARK2(mt->rn_saved, gc); + gcMARK2(mt->shared_offsets, gc); + gcMARK2(mt->sorted_keys, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Marshal_Tables)); } @@ -1598,7 +1598,7 @@ mark_listener { mark: - gcMARK(l->mref); + gcMARK2(l->mref, gc); size: gcBYTES_TO_WORDS(sizeof(listener_t) + ((l->count - 1) * sizeof(tcp_t))); @@ -1609,8 +1609,8 @@ mark_tcp { mark: Scheme_Tcp *tcp = (Scheme_Tcp *)p; - gcMARK(tcp->b.buffer); - gcMARK(tcp->b.out_buffer); + gcMARK2(tcp->b.buffer, gc); + gcMARK2(tcp->b.out_buffer, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Tcp)); @@ -1621,8 +1621,8 @@ mark_udp { mark: Scheme_UDP *udp = (Scheme_UDP *)p; - gcMARK(udp->previous_from_addr); - gcMARK(udp->mref); + gcMARK2(udp->previous_from_addr, gc); + gcMARK2(udp->mref, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_UDP)); @@ -1632,9 +1632,9 @@ mark_udp_evt { mark: Scheme_UDP_Evt *uw = (Scheme_UDP_Evt *)p; - gcMARK(uw->udp); - gcMARK(uw->str); - gcMARK(uw->dest_addr); + gcMARK2(uw->udp, gc); + gcMARK2(uw->str, gc); + gcMARK2(uw->dest_addr, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_UDP_Evt)); @@ -1654,9 +1654,9 @@ mark_parameterization { int i; for (i = max_configs; i--; ) { - gcMARK(c->prims[i]); + gcMARK2(c->prims[i], gc); } - gcMARK(c->extensions); + gcMARK2(c->extensions, gc); size: gcBYTES_TO_WORDS((sizeof(Scheme_Parameterization) @@ -1666,9 +1666,9 @@ mark_parameterization { mark_config { mark: Scheme_Config *config = (Scheme_Config *)p; - gcMARK(config->key); - gcMARK(config->cell); - gcMARK(config->next); + gcMARK2(config->key, gc); + gcMARK2(config->cell, gc); + gcMARK2(config->next, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Config)); } @@ -1677,9 +1677,9 @@ mark_will_executor_val { mark: WillExecutor *e = (WillExecutor *)p; - gcMARK(e->sema); - gcMARK(e->first); - gcMARK(e->last); + gcMARK2(e->sema, gc); + gcMARK2(e->first, gc); + gcMARK2(e->last, gc); size: gcBYTES_TO_WORDS(sizeof(WillExecutor)); @@ -1689,19 +1689,19 @@ mark_custodian_val { mark: Scheme_Custodian *m = (Scheme_Custodian *)p; - gcMARK(m->boxes); - gcMARK(m->mrefs); - gcMARK(m->closers); - gcMARK(m->data); + gcMARK2(m->boxes, gc); + gcMARK2(m->mrefs, gc); + gcMARK2(m->closers, gc); + gcMARK2(m->data, gc); - gcMARK(m->parent); - gcMARK(m->sibling); - gcMARK(m->children); + gcMARK2(m->parent, gc); + gcMARK2(m->sibling, gc); + gcMARK2(m->children, gc); - gcMARK(m->global_next); - gcMARK(m->global_prev); + gcMARK2(m->global_next, gc); + gcMARK2(m->global_prev, gc); - gcMARK(m->cust_boxes); + gcMARK2(m->cust_boxes, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Custodian)); @@ -1712,9 +1712,9 @@ mark_custodian_box_val { Scheme_Custodian_Box *b = (Scheme_Custodian_Box *)p; int sd = ((Scheme_Custodian *)GC_resolve(b->cust))->shut_down; - gcMARK(b->cust); + gcMARK2(b->cust, gc); if (!sd) { - gcMARK(b->v); + gcMARK2(b->v, gc); } size: @@ -1725,7 +1725,7 @@ mark_thread_hop { mark: Scheme_Thread_Custodian_Hop *hop = (Scheme_Thread_Custodian_Hop *)p; - gcMARK(hop->p); + gcMARK2(hop->p, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Custodian_Hop)); @@ -1735,10 +1735,10 @@ mark_param_data { mark: ParamData *d = (ParamData *)p; - gcMARK(d->key); - gcMARK(d->guard); - gcMARK(d->extract_guard); - gcMARK(d->defcell); + gcMARK2(d->key, gc); + gcMARK2(d->guard, gc); + gcMARK2(d->extract_guard, gc); + gcMARK2(d->defcell, gc); size: gcBYTES_TO_WORDS(sizeof(ParamData)); @@ -1748,10 +1748,10 @@ mark_will { mark: ActiveWill *w = (ActiveWill *)p; - gcMARK(w->o); - gcMARK(w->proc); - gcMARK(w->w); - gcMARK(w->next); + gcMARK2(w->o, gc); + gcMARK2(w->proc, gc); + gcMARK2(w->w, gc); + gcMARK2(w->next, gc); size: gcBYTES_TO_WORDS(sizeof(ActiveWill)); @@ -1767,12 +1767,12 @@ mark_syncing { mark: Syncing *w = (Syncing *)p; - gcMARK(w->set); - gcMARK(w->wrapss); - gcMARK(w->nackss); - gcMARK(w->reposts); - gcMARK(w->accepts); - gcMARK(w->disable_break); + gcMARK2(w->set, gc); + gcMARK2(w->wrapss, gc); + gcMARK2(w->nackss, gc); + gcMARK2(w->reposts, gc); + gcMARK2(w->accepts, gc); + gcMARK2(w->disable_break, gc); size: gcBYTES_TO_WORDS(sizeof(Syncing)); @@ -1782,8 +1782,8 @@ mark_evt_set { mark: Evt_Set *w = (Evt_Set *)p; - gcMARK(w->ws); - gcMARK(w->argv); + gcMARK2(w->ws, gc); + gcMARK2(w->argv, gc); size: gcBYTES_TO_WORDS(sizeof(Evt_Set)); @@ -1793,12 +1793,12 @@ mark_thread_set { mark: Scheme_Thread_Set *ts = (Scheme_Thread_Set *)p; - gcMARK(ts->parent); - gcMARK(ts->first); - gcMARK(ts->next); - gcMARK(ts->prev); - gcMARK(ts->search_start); - gcMARK(ts->current); + gcMARK2(ts->parent, gc); + gcMARK2(ts->first, gc); + gcMARK2(ts->next, gc); + gcMARK2(ts->prev, gc); + gcMARK2(ts->search_start, gc); + gcMARK2(ts->current, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Set)); @@ -1808,7 +1808,7 @@ mark_thread_cell { mark: Thread_Cell *c = (Thread_Cell *)p; - gcMARK(c->def_val); + gcMARK2(c->def_val, gc); size: gcBYTES_TO_WORDS(sizeof(Thread_Cell)); @@ -1818,10 +1818,10 @@ mark_frozen_tramp { mark: FrozenTramp *f = (FrozenTramp *)p; - gcMARK(f->do_data); - gcMARK(f->old_param); - gcMARK(f->config); - gcMARK(f->progress_cont); + gcMARK2(f->do_data, gc); + gcMARK2(f->old_param, gc); + gcMARK2(f->config, gc); + gcMARK2(f->progress_cont, gc); size: gcBYTES_TO_WORDS(sizeof(FrozenTramp)); @@ -1837,9 +1837,9 @@ mark_finalization { mark: Finalization *f = (Finalization *)p; - gcMARK(f->data); - gcMARK(f->next); - gcMARK(f->prev); + gcMARK2(f->data, gc); + gcMARK2(f->next, gc); + gcMARK2(f->prev, gc); size: gcBYTES_TO_WORDS(sizeof(Finalization)); @@ -1849,11 +1849,11 @@ mark_finalizations { mark: Finalizations *f = (Finalizations *)p; - gcMARK(f->scheme_first); - gcMARK(f->scheme_last); - gcMARK(f->prim_first); - gcMARK(f->prim_last); - gcMARK(f->ext_data); + gcMARK2(f->scheme_first, gc); + gcMARK2(f->scheme_last, gc); + gcMARK2(f->prim_first, gc); + gcMARK2(f->prim_last, gc); + gcMARK2(f->ext_data, gc); size: gcBYTES_TO_WORDS(sizeof(Finalizations)); @@ -1869,11 +1869,11 @@ mark_channel_syncer { mark: Scheme_Channel_Syncer *w = (Scheme_Channel_Syncer *)p; - gcMARK(w->p); - gcMARK(w->prev); - gcMARK(w->next); - gcMARK(w->syncing); - gcMARK(w->obj); + gcMARK2(w->p, gc); + gcMARK2(w->prev, gc); + gcMARK2(w->next, gc); + gcMARK2(w->syncing, gc); + gcMARK2(w->obj, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Syncer)); @@ -1898,10 +1898,10 @@ mark_struct_val { mark: int i; - gcFIXUP_TYPED_NOW(Scheme_Struct_Type *, s->stype); + gcFIXUP2_TYPED_NOW(Scheme_Struct_Type *, s->stype, gc); for(i = num_slots; i--; ) - gcMARK(s->slots[i]); + gcMARK2(s->slots[i], gc); size: gcBYTES_TO_WORDS((sizeof(Scheme_Structure) @@ -1914,18 +1914,18 @@ mark_struct_type_val { mark: int i; for (i = t->name_pos + 1; i--; ) { - gcMARK(t->parent_types[i]); + gcMARK2(t->parent_types[i], gc); } - gcMARK(t->name); - gcMARK(t->inspector); - gcMARK(t->accessor); - gcMARK(t->mutator); - gcMARK(t->prefab_key); - gcMARK(t->uninit_val); - gcMARK(t->props); - gcMARK(t->proc_attr); - gcMARK(t->guard); - gcMARK(t->immutables); + gcMARK2(t->name, gc); + gcMARK2(t->inspector, gc); + gcMARK2(t->accessor, gc); + gcMARK2(t->mutator, gc); + gcMARK2(t->prefab_key, gc); + gcMARK2(t->uninit_val, gc); + gcMARK2(t->props, gc); + gcMARK2(t->proc_attr, gc); + gcMARK2(t->guard, gc); + gcMARK2(t->immutables, gc); size: gcBYTES_TO_WORDS((sizeof(Scheme_Struct_Type) @@ -1936,8 +1936,8 @@ mark_struct_proc_info { mark: Struct_Proc_Info *i = (Struct_Proc_Info *)p; - gcMARK(i->struct_type); - gcMARK(i->func_name); + gcMARK2(i->struct_type, gc); + gcMARK2(i->func_name, gc); size: gcBYTES_TO_WORDS(sizeof(Struct_Proc_Info)); @@ -1946,9 +1946,9 @@ mark_struct_proc_info { mark_struct_property { mark: Scheme_Struct_Property *i = (Scheme_Struct_Property *)p; - gcMARK(i->name); - gcMARK(i->guard); - gcMARK(i->supers); + gcMARK2(i->name, gc); + gcMARK2(i->guard, gc); + gcMARK2(i->supers, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Struct_Property)); } @@ -1957,8 +1957,8 @@ mark_wrapped_evt { mark: Wrapped_Evt *ww = (Wrapped_Evt *)p; - gcMARK(ww->evt); - gcMARK(ww->wrapper); + gcMARK2(ww->evt, gc); + gcMARK2(ww->wrapper, gc); size: gcBYTES_TO_WORDS(sizeof(Wrapped_Evt)); @@ -1968,7 +1968,7 @@ mark_nack_guard_evt { mark: Nack_Guard_Evt *nw = (Nack_Guard_Evt *)p; - gcMARK(nw->maker); + gcMARK2(nw->maker, gc); size: gcBYTES_TO_WORDS(sizeof(Nack_Guard_Evt)); @@ -1978,10 +1978,10 @@ mark_chaperone { mark: Scheme_Chaperone *px = (Scheme_Chaperone *)p; - gcMARK(px->val); - gcMARK(px->prev); - gcMARK(px->props); - gcMARK(px->redirects); + gcMARK2(px->val, gc); + gcMARK2(px->prev, gc); + gcMARK2(px->props, gc); + gcMARK2(px->redirects, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Chaperone)); @@ -2008,17 +2008,17 @@ mark_indent { mark_cport { mark: CPort *cp = (CPort *)p; - gcMARK(cp->start); - gcMARK(cp->orig_port); - gcMARK(cp->ht); - gcMARK(cp->ut); - gcMARK(cp->symtab); - gcMARK(cp->insp); - gcMARK(cp->relto); - gcMARK(cp->magic_sym); - gcMARK(cp->magic_val); - gcMARK(cp->shared_offsets); - gcMARK(cp->delay_info); + gcMARK2(cp->start, gc); + gcMARK2(cp->orig_port, gc); + gcMARK2(cp->ht, gc); + gcMARK2(cp->ut, gc); + gcMARK2(cp->symtab, gc); + gcMARK2(cp->insp, gc); + gcMARK2(cp->relto, gc); + gcMARK2(cp->magic_sym, gc); + gcMARK2(cp->magic_val, gc); + gcMARK2(cp->shared_offsets, gc); + gcMARK2(cp->delay_info, gc); size: gcBYTES_TO_WORDS(sizeof(CPort)); } @@ -2026,10 +2026,10 @@ mark_cport { mark_readtable { mark: Readtable *t = (Readtable *)p; - gcMARK(t->mapping); - gcMARK(t->fast_mapping); - gcMARK(t->symbol_parser); - gcMARK(t->names); + gcMARK2(t->mapping, gc); + gcMARK2(t->fast_mapping, gc); + gcMARK2(t->symbol_parser, gc); + gcMARK2(t->names, gc); size: gcBYTES_TO_WORDS(sizeof(Readtable)); } @@ -2037,10 +2037,10 @@ mark_readtable { mark_read_params { mark: ReadParams *rp = (ReadParams *)p; - gcMARK(rp->table); - gcMARK(rp->magic_sym); - gcMARK(rp->magic_val); - gcMARK(rp->delay_load_info); + gcMARK2(rp->table, gc); + gcMARK2(rp->magic_sym, gc); + gcMARK2(rp->magic_val, gc); + gcMARK2(rp->delay_load_info, gc); size: gcBYTES_TO_WORDS(sizeof(ReadParams)); } @@ -2048,15 +2048,15 @@ mark_read_params { mark_delay_load { mark: Scheme_Load_Delay *ld = (Scheme_Load_Delay *)p; - gcMARK(ld->path); - gcMARK(ld->symtab); - gcMARK(ld->shared_offsets); - gcMARK(ld->insp); - gcMARK(ld->relto); - gcMARK(ld->ut); - gcMARK(ld->current_rp); - gcMARK(ld->cached); - gcMARK(ld->cached_port); + gcMARK2(ld->path, gc); + gcMARK2(ld->symtab, gc); + gcMARK2(ld->shared_offsets, gc); + gcMARK2(ld->insp, gc); + gcMARK2(ld->relto, gc); + gcMARK2(ld->ut, gc); + gcMARK2(ld->current_rp, gc); + gcMARK2(ld->cached, gc); + gcMARK2(ld->cached_port, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Load_Delay)); } @@ -2064,9 +2064,9 @@ mark_delay_load { mark_unmarshal_tables { mark: Scheme_Unmarshal_Tables *ut = (Scheme_Unmarshal_Tables *)p; - gcMARK(ut->rns); - gcMARK(ut->rp); - gcMARK(ut->decoded); + gcMARK2(ut->rns, gc); + gcMARK2(ut->rp, gc); + gcMARK2(ut->decoded, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Unmarshal_Tables)); } @@ -2080,8 +2080,8 @@ START regexp; mark_regexp { regexp *r = (regexp *)p; mark: - gcMARK(r->source); - gcMARK(r->regstart); + gcMARK2(r->source, gc); + gcMARK2(r->regstart, gc); size: gcBYTES_TO_WORDS((sizeof(regexp) + r->regsize)); } @@ -2089,15 +2089,15 @@ mark_regexp { mark_regwork { mark: Regwork *r = (Regwork *)p; - gcMARK(r->str); - gcMARK(r->instr); - gcMARK(r->port); - gcMARK(r->unless_evt); - gcMARK(r->startp); - gcMARK(r->maybep); - gcMARK(r->endp); - gcMARK(r->counters); - gcMARK(r->peekskip); + gcMARK2(r->str, gc); + gcMARK2(r->instr, gc); + gcMARK2(r->port, gc); + gcMARK2(r->unless_evt, gc); + gcMARK2(r->startp, gc); + gcMARK2(r->maybep, gc); + gcMARK2(r->endp, gc); + gcMARK2(r->counters, gc); + gcMARK2(r->peekskip, gc); size: gcBYTES_TO_WORDS(sizeof(Regwork)); } @@ -2111,7 +2111,7 @@ START string; mark_string_convert { mark: Scheme_Converter *c = (Scheme_Converter *)p; - gcMARK(c->mref); + gcMARK2(c->mref, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Converter)); } @@ -2125,14 +2125,14 @@ START stxobj; mark_rename_table { mark: Module_Renames *rn = (Module_Renames *)p; - gcMARK(rn->phase); - gcMARK(rn->ht); - gcMARK(rn->nomarshal_ht); - gcMARK(rn->unmarshal_info); - gcMARK(rn->shared_pes); - gcMARK(rn->set_identity); - gcMARK(rn->marked_names); - gcMARK(rn->free_id_renames); + gcMARK2(rn->phase, gc); + gcMARK2(rn->ht, gc); + gcMARK2(rn->nomarshal_ht, gc); + gcMARK2(rn->unmarshal_info, gc); + gcMARK2(rn->shared_pes, gc); + gcMARK2(rn->set_identity, gc); + gcMARK2(rn->marked_names, gc); + gcMARK2(rn->free_id_renames, gc); size: gcBYTES_TO_WORDS(sizeof(Module_Renames)); } @@ -2140,11 +2140,11 @@ mark_rename_table { mark_rename_table_set { mark: Module_Renames_Set *rns = (Module_Renames_Set *)p; - gcMARK(rns->et); - gcMARK(rns->rt); - gcMARK(rns->other_phases); - gcMARK(rns->share_marked_names); - gcMARK(rns->set_identity); + gcMARK2(rns->et, gc); + gcMARK2(rns->rt, gc); + gcMARK2(rns->other_phases, gc); + gcMARK2(rns->share_marked_names, gc); + gcMARK2(rns->set_identity, gc); size: gcBYTES_TO_WORDS(sizeof(Module_Renames_Set)); } @@ -2152,7 +2152,7 @@ mark_rename_table_set { mark_srcloc { mark: Scheme_Stx_Srcloc *s = (Scheme_Stx_Srcloc *)p; - gcMARK(s->src); + gcMARK2(s->src, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Srcloc)); } @@ -2162,7 +2162,7 @@ mark_wrapchunk { mark: int i; for (i = wc->len; i--; ) { - gcMARK(wc->a[i]); + gcMARK2(wc->a[i], gc); } size: gcBYTES_TO_WORDS(sizeof(Wrap_Chunk) + ((wc->len - 1) * sizeof(Scheme_Object *))); @@ -2171,12 +2171,12 @@ mark_wrapchunk { mark_cert { mark: Scheme_Cert *c = (Scheme_Cert *)p; - gcMARK(c->mark); - gcMARK(c->modidx); - gcMARK(c->insp); - gcMARK(c->key); - gcMARK(c->mapped); - gcMARK(c->next); + gcMARK2(c->mark, gc); + gcMARK2(c->modidx, gc); + gcMARK2(c->insp, gc); + gcMARK2(c->key, gc); + gcMARK2(c->mapped, gc); + gcMARK2(c->next, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Cert)); } @@ -2184,11 +2184,11 @@ mark_cert { lex_rib { mark: Scheme_Lexical_Rib *rib = (Scheme_Lexical_Rib *)p; - gcMARK(rib->rename); - gcMARK(rib->timestamp); - gcMARK(rib->sealed); - gcMARK(rib->mapped_names); - gcMARK(rib->next); + gcMARK2(rib->rename, gc); + gcMARK2(rib->timestamp, gc); + gcMARK2(rib->sealed, gc); + gcMARK2(rib->mapped_names, gc); + gcMARK2(rib->next, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Lexical_Rib)); } @@ -2198,7 +2198,7 @@ mark_free_id_info { Scheme_Vector *vec = (Scheme_Vector *)p; int i; for (i = 8; i--; ) - gcMARK(vec->els[i]); + gcMARK2(vec->els[i], gc); size: gcBYTES_TO_WORDS((sizeof(Scheme_Vector) @@ -2226,9 +2226,9 @@ native_closure { { int i = closure_size; while (i--) - gcMARK(c->vals[i]); + gcMARK2(c->vals[i], gc); } - gcMARK(c->code); + gcMARK2(c->code, gc); size: gcBYTES_TO_WORDS((sizeof(Scheme_Native_Closure) @@ -2238,8 +2238,8 @@ native_closure { mark_jit_state { mark: mz_jit_state *j = (mz_jit_state *)p; - gcMARK(j->mappings); - gcMARK(j->self_data); + gcMARK2(j->mappings, gc); + gcMARK2(j->self_data, gc); size: gcBYTES_TO_WORDS(sizeof(mz_jit_state)); } @@ -2249,14 +2249,14 @@ native_unclosed_proc { Scheme_Native_Closure_Data *d = (Scheme_Native_Closure_Data *)p; int i; - gcMARK(d->u2.name); + gcMARK2(d->u2.name, gc); if (d->retained) { for (i = SCHEME_INT_VAL(d->retained[0]); i--; ) { - gcMARK(d->retained[i]); + gcMARK2(d->retained[i], gc); } } if (d->closure_size < 0) { - gcMARK(d->u.arities); + gcMARK2(d->u.arities, gc); } size: @@ -2267,8 +2267,8 @@ native_unclosed_proc_plus_case { mark: Scheme_Native_Closure_Data_Plus_Case *d = (Scheme_Native_Closure_Data_Plus_Case *)p; - native_unclosed_proc_MARK(p); - gcMARK(d->case_lam); + native_unclosed_proc_MARK(p, gc); + gcMARK2(d->case_lam, gc); size: gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data_Plus_Case)); @@ -2285,23 +2285,23 @@ START future; future { mark: future_t *f = (future_t *)p; - gcMARK(f->orig_lambda); - gcMARK(f->arg_s0); - gcMARK(f->arg_S0); - gcMARK(f->arg_b0); - gcMARK(f->arg_n0); - gcMARK(f->arg_s1); - gcMARK(f->arg_S1); - gcMARK(f->arg_s2); - gcMARK(f->arg_S2); - gcMARK(f->retval_s); - gcMARK(f->retval); - gcMARK(f->multiple_array); - gcMARK(f->tail_rator); - gcMARK(f->tail_rands); - gcMARK(f->prev); - gcMARK(f->next); - gcMARK(f->next_waiting_atomic); + gcMARK2(f->orig_lambda, gc); + gcMARK2(f->arg_s0, gc); + gcMARK2(f->arg_S0, gc); + gcMARK2(f->arg_b0, gc); + gcMARK2(f->arg_n0, gc); + gcMARK2(f->arg_s1, gc); + gcMARK2(f->arg_S1, gc); + gcMARK2(f->arg_s2, gc); + gcMARK2(f->arg_S2, gc); + gcMARK2(f->retval_s, gc); + gcMARK2(f->retval, gc); + gcMARK2(f->multiple_array, gc); + gcMARK2(f->tail_rator, gc); + gcMARK2(f->tail_rands, gc); + gcMARK2(f->prev, gc); + gcMARK2(f->next, gc); + gcMARK2(f->next_waiting_atomic, gc); size: gcBYTES_TO_WORDS(sizeof(future_t)); } @@ -2311,10 +2311,10 @@ future { sequential_future { mark: future_t *f = (future_t *)p; - gcMARK(f->orig_lambda); - gcMARK(f->running_sema); - gcMARK(f->retval); - gcMARK(f->multiple_array); + gcMARK2(f->orig_lambda, gc); + gcMARK2(f->running_sema, gc); + gcMARK2(f->retval, gc); + gcMARK2(f->multiple_array, gc); size: gcBYTES_TO_WORDS(sizeof(future_t)); } @@ -2325,4 +2325,4 @@ END future; /**********************************************************************/ -#define GC_REG_TRAV(type, base) GC_register_traversers(type, base ## _SIZE, base ## _MARK, base ## _FIXUP, base ## _IS_CONST_SIZE, base ## _IS_ATOMIC) +#define GC_REG_TRAV(type, base) GC_register_traversers2(type, base ## _SIZE, base ## _MARK, base ## _FIXUP, base ## _IS_CONST_SIZE, base ## _IS_ATOMIC) diff --git a/src/mzscheme/src/salloc.c b/src/mzscheme/src/salloc.c index d48096b199..39733ed410 100644 --- a/src/mzscheme/src/salloc.c +++ b/src/mzscheme/src/salloc.c @@ -210,7 +210,8 @@ void scheme_set_thread_local_variables(Thread_Local_Variables *tlvs) XFORM_SKIP_ } #endif -#if defined(IMPLEMENT_THREAD_LOCAL_VIA_PTHREADS) && defined(INLINE_GETSPECIFIC_ASSEMBLY_CODE) +#if 0 && defined(IMPLEMENT_THREAD_LOCAL_VIA_PTHREADS) && defined(INLINE_GETSPECIFIC_ASSEMBLY_CODE) +/* This code is dsiabled */ static void macosx_get_thread_local_key_for_assembly_code() XFORM_SKIP_PROC { /* Our [highly questionable] strategy for inlining pthread_getspecific() is taken from @@ -265,44 +266,21 @@ Thread_Local_Variables *scheme_external_get_thread_local_variables() XFORM_SKIP_ void scheme_setup_thread_local_key_if_needed() XFORM_SKIP_PROC { #ifdef IMPLEMENT_THREAD_LOCAL_VIA_PTHREADS -# ifdef INLINE_GETSPECIFIC_ASSEMBLY_CODE -# if defined(linux) - scheme_thread_local_key = 0; - if (pthread_key_create(&scheme_thread_local_key, NULL)) { - fprintf(stderr, "pthread key create failed\n"); - abort(); - } - /* - if (scheme_thread_local_key != 0) { - fprintf(stderr, "pthread getspecific inline hack failed scheme_thread_local_key %i\n", scheme_thread_local_key); - abort(); - } - */ - pthread_setspecific(scheme_thread_local_key, (void *)0xaced); - if (scheme_get_thread_local_variables() != (Thread_Local_Variables *)0xaced) { - fprintf(stderr, "pthread getspecific inline hack failed to return set data\n"); - abort(); - } -# else - macosx_get_thread_local_key_for_assembly_code(); -# endif -# else - if (pthread_key_create(&scheme_thread_local_key, NULL)) { - fprintf(stderr, "pthread key create failed\n"); - abort(); - } -# endif + scheme_thread_local_key = 0; + if (pthread_key_create(&scheme_thread_local_key, NULL)) { + fprintf(stderr, "pthread key create failed\n"); + abort(); + } #endif #ifdef IMPLEMENT_THREAD_LOCAL_VIA_WIN_TLS - { - void **base; + { + void **base; - __asm { mov ecx, FS:[0x2C] - mov base, ecx } - scheme_tls_delta -= (unsigned long)base[scheme_tls_index]; - scheme_tls_index *= sizeof(void*); - - } + __asm { mov ecx, FS:[0x2C] + mov base, ecx } + scheme_tls_delta -= (unsigned long)base[scheme_tls_index]; + scheme_tls_index *= sizeof(void*); + } #endif } diff --git a/src/mzscheme/src/type.c b/src/mzscheme/src/type.c index 42bc8f09f7..66f75a63e4 100644 --- a/src/mzscheme/src/type.c +++ b/src/mzscheme/src/type.c @@ -400,19 +400,19 @@ int scheme_num_types(void) START_XFORM_SKIP; -static int bad_trav_SIZE(void *p) +static int bad_trav_SIZE(void *p, struct NewGC *gc) { printf("Shouldn't get here.\n"); exit(1); } -static int bad_trav_MARK(void *p) +static int bad_trav_MARK(void *p, struct NewGC *gc) { printf("Shouldn't get here.\n"); exit(1); } -static int bad_trav_FIXUP(void *p) +static int bad_trav_FIXUP(void *p, struct NewGC *gc) { printf("Shouldn't get here.\n"); exit(1); @@ -421,59 +421,61 @@ static int bad_trav_FIXUP(void *p) #define bad_trav_IS_CONST_SIZE 0 #define bad_trav_IS_ATOMIC 0 -static void MARK_cjs(Scheme_Continuation_Jump_State *cjs) +static void MARK_cjs(Scheme_Continuation_Jump_State *cjs, struct NewGC *gc) { - gcMARK(cjs->jumping_to_continuation); - gcMARK(cjs->val); + gcMARK2(cjs->jumping_to_continuation, gc); + gcMARK2(cjs->val, gc); } -static void FIXUP_cjs(Scheme_Continuation_Jump_State *cjs) +static void FIXUP_cjs(Scheme_Continuation_Jump_State *cjs, struct NewGC *gc) { - gcFIXUP(cjs->jumping_to_continuation); - gcFIXUP(cjs->val); + gcFIXUP2(cjs->jumping_to_continuation, gc); + gcFIXUP2(cjs->val, gc); } -static void MARK_stack_state(Scheme_Stack_State *ss) +static void MARK_stack_state(Scheme_Stack_State *ss, struct NewGC *gc) { } -static void FIXUP_stack_state(Scheme_Stack_State *ss) +static void FIXUP_stack_state(Scheme_Stack_State *ss, struct NewGC *gc) { } -static void MARK_jmpup(Scheme_Jumpup_Buf *buf) +static void MARK_jmpup(Scheme_Jumpup_Buf *buf, struct NewGC *gc) { - gcMARK(buf->stack_copy); - gcMARK(buf->cont); - gcMARK(buf->external_stack); + gcMARK2(buf->stack_copy, gc); + gcMARK2(buf->cont, gc); + gcMARK2(buf->external_stack, gc); /* IMPORTANT: the buf->stack_copy pointer must be the only instance of this stack to be traversed. If you copy a jmpup buffer (as in fun.c), don't let a GC happen until the old copy is zeroed out. */ if (buf->stack_copy) - GC_mark_variable_stack(buf->gc_var_stack, - (long)buf->stack_copy - (long)buf->stack_from, - /* FIXME: stack direction */ - (char *)buf->stack_copy + buf->stack_size, - buf->stack_copy); + GC_mark2_variable_stack(buf->gc_var_stack, + (long)buf->stack_copy - (long)buf->stack_from, + /* FIXME: stack direction */ + (char *)buf->stack_copy + buf->stack_size, + buf->stack_copy, + gc); } -static void FIXUP_jmpup(Scheme_Jumpup_Buf *buf) +static void FIXUP_jmpup(Scheme_Jumpup_Buf *buf, struct NewGC *gc) { void *new_stack; new_stack = GC_resolve(buf->stack_copy); - gcFIXUP_TYPED_NOW(void *, buf->stack_copy); - gcFIXUP(buf->cont); - gcFIXUP(buf->external_stack); + gcFIXUP2_TYPED_NOW(void *, buf->stack_copy, gc); + gcFIXUP2(buf->cont, gc); + gcFIXUP2(buf->external_stack, gc); if (buf->stack_copy) - GC_fixup_variable_stack(buf->gc_var_stack, - (long)new_stack - (long)buf->stack_from, - /* FIXME: stack direction */ - (char *)new_stack + buf->stack_size, - new_stack); + GC_fixup2_variable_stack(buf->gc_var_stack, + (long)new_stack - (long)buf->stack_from, + /* FIXME: stack direction */ + (char *)new_stack + buf->stack_size, + new_stack, + gc); } #define RUNSTACK_ZERO_VAL NULL