1 2 START type; 3 4 variable_obj { 5 mark: 6 Scheme_Bucket *b = (Scheme_Bucket *)p; 7 8 gcMARK2(b->key, gc); 9 gcMARK2(b->val, gc); 10 gcMARK2(((Scheme_Bucket_With_Home *)b)->home_link, gc); 11 12 size: 13 gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_With_Home)); 14 } 15 16 bucket_obj { 17 mark: 18 Scheme_Bucket *b = (Scheme_Bucket *)p; 19 20 gcMARK2(b->key, gc); 21 gcMARK2(b->val, gc); 22 23 size: 24 gcBYTES_TO_WORDS(sizeof(Scheme_Bucket)); 25 } 26 27 local_obj { 28 mark: 29 size: 30 gcBYTES_TO_WORDS(sizeof(Scheme_Local)); 31 } 32 33 toplevel_obj { 34 mark: 35 size: 36 gcBYTES_TO_WORDS(sizeof(Scheme_Toplevel)); 37 } 38 39 static_toplevel_obj { 40 mark: 41 gcMARK2(SCHEME_STATIC_TOPLEVEL_PREFIX(p), gc); 42 size: 43 gcBYTES_TO_WORDS(sizeof(Scheme_Toplevel)); 44 } 45 46 cpointer_obj { 47 mark: 48 if (!(SCHEME_CPTR_FLAGS(p) & 0x1)) { 49 gcMARK2(SCHEME_CPTR_VAL(p), gc); 50 } 51 gcMARK2(SCHEME_CPTR_TYPE(p), gc); 52 size: 53 (SCHEME_CPTR_HAS_OFFSET(p) 54 ? gcBYTES_TO_WORDS(sizeof(Scheme_Offset_Cptr)) 55 : gcBYTES_TO_WORDS(sizeof(Scheme_Cptr))); 56 } 57 58 twoptr_obj { 59 mark: 60 gcMARK2(SCHEME_PTR1_VAL((Scheme_Object *)p), gc); 61 gcMARK2(SCHEME_PTR2_VAL((Scheme_Object *)p), gc); 62 size: 63 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 64 } 65 66 iptr_obj { 67 mark: 68 gcMARK2(SCHEME_IPTR_VAL((Scheme_Object *)p), gc); 69 size: 70 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 71 } 72 73 small_object { 74 mark: 75 gcMARK2(((Scheme_Small_Object *)p)->u.ptr_value, gc); 76 77 size: 78 gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object)); 79 } 80 81 small_atomic_obj { 82 mark: 83 size: 84 gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object)); 85 } 86 87 app_rec { 88 Scheme_App_Rec *r = (Scheme_App_Rec *)p; 89 90 mark: 91 int i = r->num_args + 1; 92 while (i--) 93 gcMARK2(r->args[i], gc); 94 95 size: 96 gcBYTES_TO_WORDS((sizeof(Scheme_App_Rec) 97 + ((r->num_args + 1 - mzFLEX_DELTA) * sizeof(Scheme_Object *)) 98 + ((r->num_args + 1) * sizeof(char)))); 99 } 100 101 app2_rec { 102 mark: 103 Scheme_App2_Rec *r = (Scheme_App2_Rec *)p; 104 gcMARK2(r->rator, gc); 105 gcMARK2(r->rand, gc); 106 107 size: 108 gcBYTES_TO_WORDS(sizeof(Scheme_App2_Rec)); 109 } 110 111 app3_rec { 112 mark: 113 Scheme_App3_Rec *r = (Scheme_App3_Rec *)p; 114 gcMARK2(r->rator, gc); 115 gcMARK2(r->rand1, gc); 116 gcMARK2(r->rand2, gc); 117 118 size: 119 gcBYTES_TO_WORDS(sizeof(Scheme_App3_Rec)); 120 } 121 122 seq_rec { 123 Scheme_Sequence *s = (Scheme_Sequence *)p; 124 125 mark: 126 int i = s->count; 127 while (i--) 128 gcMARK2(s->array[i], gc); 129 130 size: 131 gcBYTES_TO_WORDS((sizeof(Scheme_Sequence) 132 + ((s->count - mzFLEX_DELTA) * sizeof(Scheme_Object *)))); 133 } 134 135 branch_rec { 136 mark: 137 Scheme_Branch_Rec *b = (Scheme_Branch_Rec *)p; 138 139 gcMARK2(b->test, gc); 140 gcMARK2(b->tbranch, gc); 141 gcMARK2(b->fbranch, gc); 142 143 size: 144 gcBYTES_TO_WORDS(sizeof(Scheme_Branch_Rec)); 145 } 146 147 unclosed_proc { 148 mark: 149 Scheme_Lambda *d = (Scheme_Lambda *)p; 150 151 gcMARK2(d->name, gc); 152 gcMARK2(d->body, gc); 153 gcMARK2(d->closure_map, gc); /* covers `ir_info` */ 154 gcMARK2(d->tl_map, gc); 155 #ifdef MZ_USE_JIT 156 gcMARK2(d->u.native_code, gc); 157 gcMARK2(d->context, gc); 158 #endif 159 160 size: 161 gcBYTES_TO_WORDS(sizeof(Scheme_Lambda)); 162 } 163 164 let_value { 165 mark: 166 Scheme_Let_Value *l = (Scheme_Let_Value *)p; 167 168 gcMARK2(l->value, gc); 169 gcMARK2(l->body, gc); 170 171 size: 172 gcBYTES_TO_WORDS(sizeof(Scheme_Let_Value)); 173 } 174 175 let_void { 176 mark: 177 Scheme_Let_Void *l = (Scheme_Let_Void *)p; 178 179 gcMARK2(l->body, gc); 180 181 size: 182 gcBYTES_TO_WORDS(sizeof(Scheme_Let_Void)); 183 } 184 185 letrec { 186 mark: 187 Scheme_Letrec *l = (Scheme_Letrec *)p; 188 189 gcMARK2(l->procs, gc); 190 gcMARK2(l->body, gc); 191 192 size: 193 gcBYTES_TO_WORDS(sizeof(Scheme_Letrec)); 194 } 195 196 let_one { 197 mark: 198 Scheme_Let_One *l = (Scheme_Let_One *)p; 199 200 gcMARK2(l->value, gc); 201 gcMARK2(l->body, gc); 202 203 size: 204 gcBYTES_TO_WORDS(sizeof(Scheme_Let_One)); 205 } 206 207 with_cont_mark { 208 mark: 209 Scheme_With_Continuation_Mark *w = (Scheme_With_Continuation_Mark *)p; 210 211 gcMARK2(w->key, gc); 212 gcMARK2(w->val, gc); 213 gcMARK2(w->body, gc); 214 215 size: 216 gcBYTES_TO_WORDS(sizeof(Scheme_With_Continuation_Mark)); 217 } 218 219 ir_local { 220 mark: 221 Scheme_IR_Local *var = (Scheme_IR_Local *)p; 222 223 gcMARK2(var->name, gc); 224 switch (var->mode) { 225 case SCHEME_VAR_MODE_COMPILE: 226 gcMARK2(var->compile.use_box, gc); 227 break; 228 case SCHEME_VAR_MODE_LETREC_CHECK: 229 gcMARK2(var->letrec_check.frame, gc); 230 break; 231 case SCHEME_VAR_MODE_OPTIMIZE: 232 gcMARK2(var->optimize.known_val, gc); 233 gcMARK2(var->optimize.transitive_uses, gc); 234 break; 235 case SCHEME_VAR_MODE_RESOLVE: 236 gcMARK2(var->resolve.lifted, gc); 237 break; 238 default: 239 break; 240 } 241 242 size: 243 gcBYTES_TO_WORDS(sizeof(Scheme_IR_Local)); 244 } 245 246 ir_toplevel { 247 mark: 248 size: 249 gcBYTES_TO_WORDS(sizeof(Scheme_IR_Toplevel)); 250 } 251 252 ir_let_value { 253 mark: 254 Scheme_IR_Let_Value *c = (Scheme_IR_Let_Value *)p; 255 256 gcMARK2(c->value, gc); 257 gcMARK2(c->body, gc); 258 gcMARK2(c->vars, gc); 259 260 size: 261 gcBYTES_TO_WORDS(sizeof(Scheme_IR_Let_Value)); 262 } 263 264 let_header { 265 mark: 266 Scheme_IR_Let_Header *h = (Scheme_IR_Let_Header *)p; 267 268 gcMARK2(h->body, gc); 269 270 size: 271 gcBYTES_TO_WORDS(sizeof(Scheme_IR_Let_Header)); 272 } 273 274 set_bang { 275 mark: 276 Scheme_Set_Bang *b = (Scheme_Set_Bang *)p; 277 278 gcMARK2(b->var, gc); 279 gcMARK2(b->val, gc); 280 281 size: 282 gcBYTES_TO_WORDS(sizeof(Scheme_Set_Bang)); 283 } 284 285 prim_proc { 286 Scheme_Primitive_Proc *prim = (Scheme_Primitive_Proc *)p; 287 288 mark: 289 gcMARK2(prim->name, gc); 290 if (prim->mina < 0) { 291 gcMARK2(prim->mu.cases, gc); 292 } 293 if (prim->pp.flags & SCHEME_PRIM_IS_CLOSURE) { 294 Scheme_Primitive_Closure *cc = (Scheme_Primitive_Closure *)prim; 295 int i; 296 for (i = cc->count; i--; ) { 297 gcMARK2(cc->val[i], gc); 298 } 299 } 300 301 size: 302 ((prim->pp.flags & SCHEME_PRIM_IS_CLOSURE) 303 ? (gcBYTES_TO_WORDS(sizeof(Scheme_Primitive_Closure)) 304 + ((Scheme_Primitive_Closure *)prim)->count - mzFLEX_DELTA) 305 : ((prim->pp.flags & SCHEME_PRIM_IS_MULTI_RESULT) 306 ? gcBYTES_TO_WORDS(sizeof(Scheme_Prim_W_Result_Arity)) 307 : gcBYTES_TO_WORDS(sizeof(Scheme_Primitive_Proc)))); 308 } 309 310 closed_prim_proc { 311 Scheme_Closed_Primitive_Proc *c = (Scheme_Closed_Primitive_Proc *)p; 312 313 mark: 314 gcMARK2(c->name, gc); 315 gcMARK2(SCHEME_CLSD_PRIM_DATA(c), gc); 316 if (c->mina == -2) { 317 gcMARK2(((Scheme_Closed_Case_Primitive_Proc *)c)->cases, gc); 318 } 319 320 size: 321 ((c->pp.flags & SCHEME_PRIM_IS_MULTI_RESULT) 322 ? gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Prim_W_Result_Arity)) 323 : ((c->mina == -2) 324 ? gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Case_Primitive_Proc)) 325 : gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Primitive_Proc)))); 326 } 327 328 scm_closure { 329 Scheme_Closure *c = (Scheme_Closure *)p; 330 int closure_size = (c->code 331 ? ((Scheme_Lambda *)GC_resolve2(c->code, gc))->closure_size 332 : 0); 333 334 mark: 335 336 int i = closure_size; 337 START_MARK_ONLY; 338 # define CLOSURE_DATA_TYPE Scheme_Lambda 339 # include "mzclpf_decl.inc" 340 END_MARK_ONLY; 341 342 gcMARK2(c->code, gc); 343 344 START_MARK_ONLY; 345 # include "mzclpf_pre.inc" 346 END_MARK_ONLY; 347 348 while (i--) 349 gcMARK2(c->vals[i], gc); 350 351 START_MARK_ONLY; 352 # include "mzclpf_post.inc" 353 # undef CLOSURE_DATA_TYPE 354 END_MARK_ONLY; 355 356 size: 357 gcBYTES_TO_WORDS((sizeof(Scheme_Closure) 358 + (closure_size - mzFLEX_DELTA) * sizeof(Scheme_Object *))); 359 } 360 361 case_closure { 362 Scheme_Case_Lambda *c = (Scheme_Case_Lambda *)p; 363 364 mark: 365 int i; 366 367 for (i = c->count; i--; ) 368 gcMARK2(c->array[i], gc); 369 gcMARK2(c->name, gc); 370 #ifdef MZ_USE_JIT 371 gcMARK2(c->native_code, gc); 372 #endif 373 374 size: 375 gcBYTES_TO_WORDS((sizeof(Scheme_Case_Lambda) 376 + ((c->count - mzFLEX_DELTA) * sizeof(Scheme_Object *)))); 377 } 378 379 cont_proc { 380 mark: 381 Scheme_Cont *c = (Scheme_Cont *)p; 382 383 gcMARK2(c->dw, gc); 384 gcMARK2(c->prompt_tag, gc); 385 gcMARK2(c->meta_continuation, gc); 386 gcMARK2(c->meta_continuation_src, gc); 387 gcMARK2(c->common_dw, gc); 388 gcMARK2(c->save_overflow, gc); 389 gcMARK2(c->runstack_copied, gc); 390 gcMARK2(c->runstack_owner, gc); 391 gcMARK2(c->cont_mark_stack_copied, gc); 392 gcMARK2(c->cont_mark_stack_owner, gc); 393 gcMARK2(c->init_config, gc); 394 gcMARK2(c->init_break_cell, gc); 395 #ifdef MZ_USE_JIT 396 gcMARK2(c->native_trace, gc); 397 #endif 398 399 gcMARK2(c->buf_ptr, gc); 400 MARK_cjs(&c->cjs, gc); 401 MARK_stack_state(&c->ss, gc); 402 gcMARK2(c->barrier_prompt, gc); 403 if (!GC_merely_accounting()) { 404 gcMARK2(c->runstack_start, gc); 405 gcMARK2(c->runstack_saved, gc); 406 } 407 408 gcMARK2(c->prompt_id, gc); 409 gcMARK2(c->prompt_buf, gc); 410 411 gcMARK2(c->escape_cont, gc); 412 413 gcMARK2(c->value, gc); 414 gcMARK2(c->resume_to, gc); 415 gcMARK2(c->use_next_cont, gc); 416 gcMARK2(c->extra_marks, gc); 417 gcMARK2(c->shortcut_prompt, gc); 418 419 size: 420 gcBYTES_TO_WORDS(sizeof(Scheme_Cont)); 421 } 422 423 cont_jmp_proc { 424 mark: 425 Scheme_Cont_Jmp *c = (Scheme_Cont_Jmp *)p; 426 427 MARK_jmpup(&c->buf, gc); 428 429 size: 430 gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Jmp)); 431 } 432 433 meta_cont_proc { 434 mark: 435 Scheme_Meta_Continuation *c = (Scheme_Meta_Continuation *)p; 436 437 gcMARK2(c->prompt_tag, gc); 438 gcMARK2(c->overflow, gc); 439 gcMARK2(c->next, gc); 440 gcMARK2(c->cont_mark_stack_copied, gc); 441 gcMARK2(c->cont, gc); 442 443 size: 444 gcBYTES_TO_WORDS(sizeof(Scheme_Meta_Continuation)); 445 } 446 447 mark_dyn_wind { 448 mark: 449 Scheme_Dynamic_Wind *dw = (Scheme_Dynamic_Wind *)p; 450 451 gcMARK2(dw->id, gc); 452 gcMARK2(dw->data, gc); 453 gcMARK2(dw->prompt_tag, gc); 454 gcMARK2(dw->prev, gc); 455 456 MARK_stack_state(&dw->envss, gc); 457 458 size: 459 gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind)); 460 } 461 462 mark_overflow { 463 mark: 464 Scheme_Overflow *o = (Scheme_Overflow *)p; 465 466 gcMARK2(o->prev, gc); 467 gcMARK2(o->jmp, gc); 468 gcMARK2(o->id, gc); 469 470 size: 471 gcBYTES_TO_WORDS(sizeof(Scheme_Overflow)); 472 } 473 474 mark_overflow_jmp { 475 mark: 476 Scheme_Overflow_Jmp *o = (Scheme_Overflow_Jmp *)p; 477 478 MARK_jmpup(&o->cont, gc); 479 480 size: 481 gcBYTES_TO_WORDS(sizeof(Scheme_Overflow_Jmp)); 482 } 483 484 escaping_cont_proc { 485 mark: 486 Scheme_Escaping_Cont *c = (Scheme_Escaping_Cont *)p; 487 488 #ifdef MZ_USE_JIT 489 gcMARK2(c->native_trace, gc); 490 #endif 491 492 gcMARK2(c->barrier_prompt, gc); 493 MARK_stack_state(&c->envss, gc); 494 495 size: 496 gcBYTES_TO_WORDS(sizeof(Scheme_Escaping_Cont)); 497 } 498 499 bignum_obj { 500 Scheme_Bignum *b = (Scheme_Bignum *)p; 501 502 mark: 503 if (!SCHEME_BIGINLINE(b)) { 504 gcMARK2(b->digits, gc); 505 } else { 506 b->digits = ((Small_Bignum *)GC_fixup_self(b))->v; 507 } 508 509 size: 510 ((!SCHEME_BIGINLINE(b)) 511 ? gcBYTES_TO_WORDS(sizeof(Scheme_Bignum)) 512 : gcBYTES_TO_WORDS(sizeof(Small_Bignum))); 513 } 514 515 rational_obj { 516 mark: 517 Scheme_Rational *r = (Scheme_Rational *)p; 518 519 gcMARK2(r->num, gc); 520 gcMARK2(r->denom, gc); 521 522 size: 523 gcBYTES_TO_WORDS(sizeof(Scheme_Rational)); 524 } 525 526 float_obj { 527 mark: 528 size: 529 #ifdef MZ_USE_SINGLE_FLOATS 530 gcBYTES_TO_WORDS(sizeof(Scheme_Float)); 531 #else 532 0; 533 #endif 534 } 535 536 double_obj { 537 mark: 538 size: 539 gcBYTES_TO_WORDS(sizeof(Scheme_Double)); 540 } 541 542 #ifdef MZ_LONG_DOUBLE 543 long_double_obj { 544 mark: 545 size: 546 gcBYTES_TO_WORDS(sizeof(Scheme_Long_Double)); 547 } 548 #else 549 long_double_obj { 550 mark: 551 Scheme_Long_Double *ld = (Scheme_Long_Double *)p; 552 gcMARK2(ld->printed_form, gc); 553 size: 554 gcBYTES_TO_WORDS(sizeof(Scheme_Long_Double)); 555 } 556 #endif 557 558 complex_obj { 559 mark: 560 Scheme_Complex *c = (Scheme_Complex *)p; 561 562 gcMARK2(c->r, gc); 563 gcMARK2(c->i, gc); 564 565 size: 566 gcBYTES_TO_WORDS(sizeof(Scheme_Complex)); 567 } 568 569 string_obj { 570 mark: 571 Scheme_Object *o = (Scheme_Object *)p; 572 gcMARK2(SCHEME_CHAR_STR_VAL(o), gc); 573 574 size: 575 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 576 } 577 578 bstring_obj { 579 mark: 580 Scheme_Object *o = (Scheme_Object *)p; 581 gcMARK2(SCHEME_BYTE_STR_VAL(o), gc); 582 583 size: 584 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 585 } 586 587 symbol_obj { 588 mark: 589 size: 590 gcBYTES_TO_WORDS(sizeof(Scheme_Symbol) + ((Scheme_Symbol *)p)->len + 1 - mzFLEX4_DELTA); 591 } 592 593 cons_cell { 594 mark: 595 Scheme_Object *o = (Scheme_Object *)p; 596 597 gcMARK2(SCHEME_CAR(o), gc); 598 gcMARK2(SCHEME_CDR(o), gc); 599 600 size: 601 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 602 } 603 604 vector_obj { 605 Scheme_Vector *vec = (Scheme_Vector *)p; 606 607 mark: 608 int i; 609 for (i = vec->size; i--; ) 610 gcMARK2(vec->els[i], gc); 611 612 size: 613 gcBYTES_TO_WORDS((sizeof(Scheme_Vector) 614 + ((vec->size - mzFLEX_DELTA) * sizeof(Scheme_Object *)))); 615 } 616 617 fxvector_obj { 618 mark: 619 size: 620 gcBYTES_TO_WORDS((sizeof(Scheme_Vector) 621 + ((((Scheme_Vector *)p)->size - mzFLEX_DELTA) * sizeof(Scheme_Object *)))); 622 } 623 624 flvector_obj { 625 mark: 626 size: 627 gcBYTES_TO_WORDS((sizeof(Scheme_Double_Vector) 628 + ((((Scheme_Double_Vector *)p)->size - mzFLEX_DELTA) * sizeof(double)))); 629 } 630 631 #ifdef MZ_LONG_DOUBLE 632 extflvector_obj { 633 mark: 634 size: 635 gcBYTES_TO_WORDS((sizeof(Scheme_Long_Double_Vector) 636 + ((((Scheme_Long_Double_Vector *)p)->size - mzFLEX_DELTA) * sizeof(long double)))); 637 } 638 #endif 639 640 input_port { 641 mark: 642 Scheme_Input_Port *ip = (Scheme_Input_Port *)p; 643 644 gcMARK2(ip->p.position_redirect, gc); 645 gcMARK2(ip->sub_type, gc); 646 gcMARK2(ip->port_data, gc); 647 gcMARK2(ip->name, gc); 648 gcMARK2(ip->peeked_read, gc); 649 gcMARK2(ip->peeked_write, gc); 650 gcMARK2(ip->read_handler, gc); 651 gcMARK2(ip->closed_evt, gc); 652 gcMARK2(ip->mref, gc); 653 gcMARK2(ip->output_half, gc); 654 gcMARK2(ip->special, gc); 655 gcMARK2(ip->ungotten_special, gc); 656 gcMARK2(ip->progress_evt, gc); 657 gcMARK2(ip->input_lock, gc); 658 gcMARK2(ip->input_giveup, gc); 659 gcMARK2(ip->input_extras, gc); 660 gcMARK2(ip->input_extras_ready, gc); 661 gcMARK2(ip->unless, gc); 662 gcMARK2(ip->unless_cache, gc); 663 #ifdef WINDOWS_FILE_HANDLES 664 gcMARK2(ip->bufwidths, gc); 665 #endif 666 667 size: 668 gcBYTES_TO_WORDS(sizeof(Scheme_Input_Port)); 669 } 670 671 output_port { 672 mark: 673 Scheme_Output_Port *op = (Scheme_Output_Port *)p; 674 675 gcMARK2(op->p.position_redirect, gc); 676 gcMARK2(op->sub_type, gc); 677 gcMARK2(op->port_data, gc); 678 gcMARK2(op->name, gc); 679 gcMARK2(op->display_handler, gc); 680 gcMARK2(op->write_handler, gc); 681 gcMARK2(op->print_handler, gc); 682 gcMARK2(op->closed_evt, gc); 683 gcMARK2(op->mref, gc); 684 gcMARK2(op->input_half, gc); 685 686 size: 687 gcBYTES_TO_WORDS(sizeof(Scheme_Output_Port)); 688 } 689 690 thread_val { 691 mark: 692 Scheme_Thread *pr = (Scheme_Thread *)p; 693 694 gcMARK2(pr->next, gc); 695 gcMARK2(pr->prev, gc); 696 697 gcMARK2(pr->t_set_parent, gc); 698 gcMARK2(pr->t_set_next, gc); 699 gcMARK2(pr->t_set_prev, gc); 700 701 MARK_cjs(&pr->cjs, gc); 702 gcMARK2(pr->decompose_mc, gc); 703 704 gcMARK2(pr->cell_values, gc); 705 gcMARK2(pr->init_config, gc); 706 gcMARK2(pr->init_break_cell, gc); 707 708 if (!pr->runstack_owner 709 || !GC_merely_accounting() 710 || (*pr->runstack_owner == pr)) { 711 Scheme_Object **rs = pr->runstack_start; 712 gcFIXUP2_TYPED_NOW(Scheme_Object **, pr->runstack_start, gc); 713 if (pr->runstack != pr->runstack_start + (pr->runstack - rs)) 714 pr->runstack = pr->runstack_start + (pr->runstack - rs); 715 716 gcMARK2(pr->runstack_saved, gc); 717 } 718 gcMARK2(pr->runstack_owner, gc); 719 gcMARK2(pr->runstack_swapped, gc); 720 pr->spare_runstack = NULL; /* just in case */ 721 722 gcMARK2(pr->meta_prompt, gc); 723 gcMARK2(pr->meta_continuation, gc); 724 gcMARK2(pr->acting_barrier_prompt, gc); 725 726 gcMARK2(pr->cont_mark_stack_segments, gc); 727 gcMARK2(pr->cont_mark_stack_owner, gc); 728 gcMARK2(pr->cont_mark_stack_swapped, gc); 729 730 MARK_jmpup(&pr->jmpup_buf, gc); 731 732 gcMARK2(pr->dw, gc); 733 734 gcMARK2(pr->nester, gc); 735 gcMARK2(pr->nestee, gc); 736 737 gcMARK2(pr->current_ft, gc); 738 739 gcMARK2(pr->blocker, gc); 740 gcMARK2(pr->overflow, gc); 741 742 gcMARK2(pr->return_marks_to, gc); 743 gcMARK2(pr->returned_marks, gc); 744 745 gcMARK2(pr->current_mt, gc); 746 747 gcMARK2(pr->constant_folding, gc); 748 gcMARK2(pr->reading_delayed, gc); 749 750 gcMARK2(pr->overflow_reply, gc); 751 752 gcMARK2(pr->values_buffer, gc); 753 754 gcMARK2(pr->tail_buffer, gc); 755 756 gcMARK2(pr->ku.eval.wait_expr, gc); 757 758 gcMARK2(pr->ku.apply.tail_rator, gc); 759 gcMARK2(pr->ku.apply.tail_rands, gc); 760 761 gcMARK2(pr->ku.multiple.array, gc); 762 763 gcMARK2(pr->ku.k.p1, gc); 764 gcMARK2(pr->ku.k.p2, gc); 765 gcMARK2(pr->ku.k.p3, gc); 766 gcMARK2(pr->ku.k.p4, gc); 767 gcMARK2(pr->ku.k.p5, gc); 768 769 gcMARK2(pr->self_for_proc_chaperone, gc); 770 771 gcMARK2(pr->kill_data, gc); 772 gcMARK2(pr->private_kill_data, gc); 773 gcMARK2(pr->private_kill_next, gc); 774 775 gcMARK2(pr->user_tls, gc); 776 gcMARK2(pr->gmp_tls_data, gc); 777 778 gcMARK2(pr->mr_hop, gc); 779 gcMARK2(pr->mref, gc); 780 gcMARK2(pr->extra_mrefs, gc); 781 782 gcMARK2(pr->name, gc); 783 784 gcMARK2(pr->transitive_resumes, gc); 785 786 gcMARK2(pr->suspended_box, gc); 787 gcMARK2(pr->resumed_box, gc); 788 gcMARK2(pr->dead_box, gc); 789 gcMARK2(pr->running_box, gc); 790 gcMARK2(pr->sync_box, gc); 791 792 gcMARK2(pr->mbox_first, gc); 793 gcMARK2(pr->mbox_last, gc); 794 gcMARK2(pr->mbox_sema, gc); 795 796 /* Follow msg_chain for an in-flight message like in place_async_channel_val */ 797 { 798 Scheme_Object *cpr = pr->place_channel_msg_chain_in_flight; 799 while (cpr) { 800 gcMARK2(SCHEME_CAR(cpr), gc); 801 cpr = SCHEME_CDR(cpr); 802 } 803 } 804 805 size: 806 gcBYTES_TO_WORDS(sizeof(Scheme_Thread)); 807 } 808 809 runstack_val { 810 intptr_t *s = (intptr_t *)p; 811 mark: 812 void **a, **b; 813 a = (void **)s + RUNSTACK_HEADER_FIELDS + s[2]; 814 b = (void **)s + RUNSTACK_HEADER_FIELDS + s[3]; 815 while (a < b) { 816 gcMARK2(*a, gc); 817 a++; 818 } 819 820 START_MARK_ONLY; 821 /* Zero out the part that we didn't mark, in case it becomes 822 live later. */ 823 a = (void **)s + RUNSTACK_HEADER_FIELDS; 824 b = (void **)s + RUNSTACK_HEADER_FIELDS + s[2]; 825 while (a < b) { 826 *a = RUNSTACK_ZERO_VAL; 827 a++; 828 } 829 a = (void **)s + RUNSTACK_HEADER_FIELDS + s[3]; 830 b = (void **)s + RUNSTACK_HEADER_FIELDS + (s[1] - RUNSTACK_HEADER_FIELDS); 831 while (a < b) { 832 *a = RUNSTACK_ZERO_VAL; 833 a++; 834 } 835 END_MARK_ONLY; 836 837 size: 838 s[1]; 839 } 840 841 prompt_val { 842 mark: 843 Scheme_Prompt *pr = (Scheme_Prompt *)p; 844 gcMARK2(pr->boundary_overflow_id, gc); 845 if (!GC_merely_accounting()) { 846 if (pr->is_barrier) 847 gcMARK2(pr->u.runstack_boundary_start_ref, gc); 848 else 849 gcMARK2(pr->u.runstack_boundary_start, gc); 850 } 851 gcMARK2(pr->tag, gc); 852 gcMARK2(pr->id, gc); 853 size: 854 gcBYTES_TO_WORDS(sizeof(Scheme_Prompt)); 855 } 856 857 cont_mark_set_val { 858 mark: 859 Scheme_Cont_Mark_Set *s = (Scheme_Cont_Mark_Set *)p; 860 gcMARK2(s->chain, gc); 861 gcMARK2(s->native_stack_trace, gc); 862 863 size: 864 gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Set)); 865 } 866 867 sema_val { 868 mark: 869 Scheme_Sema *s = (Scheme_Sema *)p; 870 871 gcMARK2(s->first, gc); 872 gcMARK2(s->last, gc); 873 874 size: 875 gcBYTES_TO_WORDS(sizeof(Scheme_Sema)); 876 } 877 878 channel_val { 879 mark: 880 Scheme_Channel *s = (Scheme_Channel *)p; 881 882 gcMARK2(s->get_first, gc); 883 gcMARK2(s->get_last, gc); 884 gcMARK2(s->put_first, gc); 885 gcMARK2(s->put_last, gc); 886 887 size: 888 gcBYTES_TO_WORDS(sizeof(Scheme_Channel)); 889 } 890 891 channel_put_val { 892 mark: 893 Scheme_Channel_Put *s = (Scheme_Channel_Put *)p; 894 895 gcMARK2(s->ch, gc); 896 gcMARK2(s->val, gc); 897 898 size: 899 gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Put)); 900 } 901 902 hash_table_val { 903 mark: 904 Scheme_Hash_Table *ht = (Scheme_Hash_Table *)p; 905 906 gcMARK2(ht->keys, gc); 907 gcMARK2(ht->vals, gc); 908 gcMARK2(ht->mutex, gc); 909 910 size: 911 gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Table)); 912 } 913 914 bucket_table_val { 915 mark: 916 Scheme_Bucket_Table *ht = (Scheme_Bucket_Table *)p; 917 918 gcMARK2(ht->buckets, gc); 919 gcMARK2(ht->mutex, gc); 920 921 size: 922 gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_Table)); 923 } 924 925 env_val { 926 mark: 927 Scheme_Env *e = (Scheme_Env *)p; 928 929 gcMARK2(e->namespace, gc); 930 gcMARK2(e->instance, gc); 931 gcMARK2(e->protected, gc); 932 size: 933 gcBYTES_TO_WORDS(sizeof(Scheme_Env)); 934 } 935 936 startup_env_val { 937 mark: 938 Scheme_Startup_Env *e = (Scheme_Startup_Env *)p; 939 940 gcMARK2(e->current_table, gc); 941 gcMARK2(e->primitive_tables, gc); 942 gcMARK2(e->all_primitives_table, gc); 943 gcMARK2(e->primitive_ids_table, gc); 944 size: 945 gcBYTES_TO_WORDS(sizeof(Scheme_Startup_Env)); 946 } 947 948 random_state_val { 949 mark: 950 size: 951 gcBYTES_TO_WORDS(sizeof(Scheme_Random_State)); 952 } 953 954 prefix_val { 955 Scheme_Prefix *pf = (Scheme_Prefix *)p; 956 mark: 957 int i; 958 for (i = pf->num_slots; i--; ) 959 gcMARK2(pf->a[i], gc); 960 size: 961 gcBYTES_TO_WORDS((sizeof(Scheme_Prefix) 962 + ((pf->num_slots-mzFLEX_DELTA) * sizeof(Scheme_Object *)) 963 + ((((pf->num_slots + 31) / 32) 964 * sizeof(int)))); 965 } 966 967 svector_val { 968 mark: 969 Scheme_Object *o = (Scheme_Object *)p; 970 971 gcMARK2(SCHEME_SVEC_VEC(o), gc); 972 973 size: 974 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 975 } 976 977 stx_val { 978 mark: 979 Scheme_Stx *stx = (Scheme_Stx *)p; 980 gcMARK2(stx->val, gc); 981 gcMARK2(stx->srcloc, gc); 982 gcMARK2(stx->props, gc); 983 size: 984 gcBYTES_TO_WORDS(sizeof(Scheme_Stx)); 985 } 986 987 linklet_val { 988 mark: 989 Scheme_Linklet *l = (Scheme_Linklet *)p; 990 991 gcMARK2(l->name, gc); 992 gcMARK2(l->importss, gc); 993 gcMARK2(l->import_shapes, gc); 994 gcMARK2(l->defns, gc); 995 gcMARK2(l->source_names, gc); 996 gcMARK2(l->bodies, gc); 997 gcMARK2(l->constants, gc); 998 gcMARK2(l->static_prefix, gc); 999 gcMARK2(l->native_lambdas, gc); 1000 size: 1001 gcBYTES_TO_WORDS(sizeof(Scheme_Linklet)); 1002 } 1003 1004 instance_val { 1005 mark: 1006 Scheme_Instance *i = (Scheme_Instance *)p; 1007 1008 gcMARK2(i->variables.a, gc); 1009 gcMARK2(i->weak_self_link, gc); 1010 gcMARK2(i->source_names, gc); 1011 gcMARK2(i->name, gc); 1012 gcMARK2(i->data, gc); 1013 size: 1014 gcBYTES_TO_WORDS(sizeof(Scheme_Instance)); 1015 } 1016 1017 guard_val { 1018 mark: 1019 Scheme_Security_Guard *g = (Scheme_Security_Guard *)p; 1020 1021 gcMARK2(g->parent, gc); 1022 gcMARK2(g->file_proc, gc); 1023 gcMARK2(g->network_proc, gc); 1024 gcMARK2(g->link_proc, gc); 1025 size: 1026 gcBYTES_TO_WORDS(sizeof(Scheme_Security_Guard)); 1027 } 1028 1029 buf_holder { 1030 mark: 1031 Scheme_Jumpup_Buf_Holder *h = (Scheme_Jumpup_Buf_Holder *)p; 1032 1033 MARK_jmpup(&h->buf, gc); 1034 1035 size: 1036 gcBYTES_TO_WORDS(sizeof(Scheme_Jumpup_Buf_Holder)); 1037 } 1038 1039 mark_inspector { 1040 mark: 1041 Scheme_Inspector *i = (Scheme_Inspector *)p; 1042 gcMARK2(i->superior, gc); 1043 size: 1044 gcBYTES_TO_WORDS(sizeof(Scheme_Inspector)); 1045 } 1046 1047 mark_pipe { 1048 mark: 1049 Scheme_Pipe *pp = (Scheme_Pipe *)p; 1050 1051 gcMARK2(pp->buf, gc); 1052 gcMARK2(pp->wakeup_on_read, gc); 1053 gcMARK2(pp->wakeup_on_write, gc); 1054 1055 size: 1056 gcBYTES_TO_WORDS(sizeof(Scheme_Pipe)); 1057 } 1058 1059 mark_logger { 1060 mark: 1061 Scheme_Logger *l = (Scheme_Logger *)p; 1062 gcMARK2(l->name, gc); 1063 gcMARK2(l->parent, gc); 1064 gcMARK2(l->want_name_level_cache, gc); 1065 gcMARK2(l->root_timestamp, gc); 1066 gcMARK2(l->syslog_level, gc); 1067 gcMARK2(l->stderr_level, gc); 1068 gcMARK2(l->stdout_level, gc); 1069 gcMARK2(l->propagate_level, gc); 1070 gcMARK2(l->readers, gc); 1071 size: 1072 gcBYTES_TO_WORDS(sizeof(Scheme_Logger)); 1073 } 1074 1075 mark_log_reader { 1076 mark: 1077 Scheme_Log_Reader *lr = (Scheme_Log_Reader *)p; 1078 gcMARK2(lr->level, gc); 1079 gcMARK2(lr->sema, gc); 1080 gcMARK2(lr->head, gc); 1081 gcMARK2(lr->tail, gc); 1082 size: 1083 gcBYTES_TO_WORDS(sizeof(Scheme_Log_Reader)); 1084 } 1085 1086 struct_proc_shape { 1087 mark: 1088 Scheme_Struct_Proc_Shape *s = (Scheme_Struct_Proc_Shape *)p; 1089 gcMARK2(s->identity, gc); 1090 size: 1091 gcBYTES_TO_WORDS(sizeof(Scheme_Struct_Proc_Shape)); 1092 } 1093 1094 END type; 1095 1096 /**********************************************************************/ 1097 1098 START env; 1099 1100 END env; 1101 1102 /**********************************************************************/ 1103 1104 START linklet; 1105 1106 END linklet; 1107 1108 /**********************************************************************/ 1109 1110 START compenv; 1111 1112 mark_comp_env { 1113 mark: 1114 Scheme_Comp_Env *e = (Scheme_Comp_Env *)p; 1115 1116 gcMARK2(e->vars, gc); 1117 gcMARK2(e->value_name, gc); 1118 gcMARK2(e->linklet, gc); 1119 1120 size: 1121 gcBYTES_TO_WORDS(sizeof(Scheme_Comp_Env)); 1122 } 1123 1124 END compenv; 1125 1126 /**********************************************************************/ 1127 1128 START resolve; 1129 1130 mark_resolve_info { 1131 mark: 1132 Resolve_Info *i = (Resolve_Info *)p; 1133 1134 gcMARK2(i->linklet, gc); 1135 gcMARK2(i->tl_map, gc); 1136 gcMARK2(i->redirects, gc); 1137 gcMARK2(i->lifts, gc); 1138 gcMARK2(i->top, gc); 1139 gcMARK2(i->next, gc); 1140 gcMARK2(i->toplevel_starts, gc); 1141 gcMARK2(i->toplevel_deltas, gc); 1142 gcMARK2(i->toplevel_defns, gc); 1143 gcMARK2(i->static_mode, gc); 1144 1145 size: 1146 gcBYTES_TO_WORDS(sizeof(Resolve_Info)); 1147 } 1148 1149 mark_unresolve_info { 1150 mark: 1151 Unresolve_Info *i = (Unresolve_Info *)p; 1152 1153 gcMARK2(i->vars, gc); 1154 gcMARK2(i->linklet, gc); 1155 gcMARK2(i->linklet_key, gc); 1156 gcMARK2(i->opt_info, gc); 1157 gcMARK2(i->closures, gc); 1158 gcMARK2(i->toplevels, gc); 1159 gcMARK2(i->definitions, gc); 1160 gcMARK2(i->ref_lifts, gc); 1161 1162 size: 1163 gcBYTES_TO_WORDS(sizeof(Unresolve_Info)); 1164 } 1165 1166 END resolve; 1167 1168 /**********************************************************************/ 1169 1170 START sfs; 1171 1172 mark_sfs_info { 1173 mark: 1174 SFS_Info *i = (SFS_Info *)p; 1175 1176 gcMARK2(i->max_used, gc); 1177 gcMARK2(i->max_calls, gc); 1178 gcMARK2(i->saved, gc); 1179 1180 size: 1181 gcBYTES_TO_WORDS(sizeof(SFS_Info)); 1182 } 1183 1184 END sfs; 1185 1186 /**********************************************************************/ 1187 1188 START letrec_check; 1189 1190 mark_letrec_check_frame { 1191 mark: 1192 Letrec_Check_Frame *frame = (Letrec_Check_Frame *)p; 1193 1194 gcMARK2(frame->def, gc); 1195 gcMARK2(frame->next, gc); 1196 gcMARK2(frame->ref, gc); 1197 gcMARK2(frame->deferred_chain, gc); 1198 1199 size: 1200 gcBYTES_TO_WORDS(sizeof(Letrec_Check_Frame)); 1201 } 1202 1203 mark_scheme_deferred_expr { 1204 mark: 1205 Scheme_Deferred_Expr *clos = (Scheme_Deferred_Expr *)p; 1206 1207 gcMARK2(clos->expr, gc); 1208 gcMARK2(clos->frame, gc); 1209 gcMARK2(clos->chain_next, gc); 1210 1211 size: 1212 gcBYTES_TO_WORDS(sizeof(Scheme_Deferred_Expr)); 1213 } 1214 1215 END letrec_check; 1216 1217 /**********************************************************************/ 1218 1219 START optimize; 1220 1221 mark_optimize_info { 1222 mark: 1223 Optimize_Info *i = (Optimize_Info *)p; 1224 1225 gcMARK2(i->next, gc); 1226 gcMARK2(i->linklet, gc); 1227 gcMARK2(i->cross, gc); 1228 gcMARK2(i->imports_used, gc); 1229 gcMARK2(i->top_level_consts, gc); 1230 gcMARK2(i->transitive_use_var, gc); 1231 gcMARK2(i->context, gc); 1232 gcMARK2(i->logger, gc); 1233 gcMARK2(i->types, gc); 1234 gcMARK2(i->uses, gc); 1235 1236 size: 1237 gcBYTES_TO_WORDS(sizeof(Optimize_Info)); 1238 } 1239 1240 mark_once_used { 1241 mark: 1242 Scheme_Once_Used *o = (Scheme_Once_Used *)p; 1243 gcMARK2(o->expr, gc); 1244 gcMARK2(o->var, gc); 1245 size: 1246 gcBYTES_TO_WORDS(sizeof(Scheme_Once_Used)); 1247 } 1248 1249 END optimize; 1250 1251 /**********************************************************************/ 1252 1253 START eval; 1254 1255 mark_saved_stack { 1256 mark: 1257 Scheme_Saved_Stack *saved = (Scheme_Saved_Stack *)p; 1258 1259 gcMARK2(saved->prev, gc); 1260 gcMARK2(saved->runstack_start, gc); 1261 1262 size: 1263 gcBYTES_TO_WORDS(sizeof(Scheme_Saved_Stack)); 1264 } 1265 1266 END eval; 1267 1268 /**********************************************************************/ 1269 1270 START validate; 1271 1272 mark_validate_clearing { 1273 mark: 1274 Validate_Clearing *vc = (Validate_Clearing *)p; 1275 1276 gcMARK2(vc->stack, gc); 1277 gcMARK2(vc->ncstack, gc); 1278 1279 size: 1280 gcBYTES_TO_WORDS(sizeof(Validate_Clearing)); 1281 } 1282 1283 END validate; 1284 1285 /**********************************************************************/ 1286 1287 START fun; 1288 1289 mark_dyn_wind_cell { 1290 mark: 1291 Scheme_Dynamic_Wind_List *l = (Scheme_Dynamic_Wind_List *)p; 1292 1293 gcMARK2(l->dw, gc); 1294 gcMARK2(l->next, gc); 1295 1296 size: 1297 gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind_List)); 1298 } 1299 1300 mark_dyn_wind_info { 1301 mark: 1302 Dyn_Wind *d = (Dyn_Wind *)p; 1303 1304 gcMARK2(d->pre, gc); 1305 gcMARK2(d->act, gc); 1306 gcMARK2(d->post, gc); 1307 1308 size: 1309 gcBYTES_TO_WORDS(sizeof(Dyn_Wind)); 1310 } 1311 1312 mark_cont_mark_chain { 1313 mark: 1314 Scheme_Cont_Mark_Chain *c = (Scheme_Cont_Mark_Chain *)p; 1315 1316 gcMARK2(c->key, gc); 1317 gcMARK2(c->val, gc); 1318 gcMARK2(c->next, gc); 1319 1320 size: 1321 gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Chain)); 1322 } 1323 1324 #ifdef MZ_USE_JIT 1325 1326 mark_lightweight_cont { 1327 mark: 1328 Scheme_Lightweight_Continuation *lw = (Scheme_Lightweight_Continuation *)p; 1329 1330 gcMARK2(lw->saved_lwc, gc); 1331 gcMARK2(lw->stack_slice, gc); 1332 gcMARK2(lw->runstack_slice, gc); 1333 gcMARK2(lw->cont_mark_stack_slice, gc); 1334 1335 size: 1336 gcBYTES_TO_WORDS(sizeof(Scheme_Lightweight_Continuation)); 1337 } 1338 1339 #endif 1340 1341 END fun; 1342 1343 /**********************************************************************/ 1344 1345 START hash; 1346 1347 hash_tree_val { 1348 Scheme_Hash_Tree *ht = (Scheme_Hash_Tree *)p; 1349 int popcount = hamt_popcount(ht->bitmap); 1350 mark: 1351 int i; 1352 for (i = ((SCHEME_HASHTR_FLAGS(ht) & HASHTR_HAS_VAL) ? 2 : 1) * popcount; i--; ) { 1353 gcMARK2(ht->els[i], gc); 1354 } 1355 1356 size: 1357 gcBYTES_TO_WORDS(HASH_TREE_RECORD_SIZE(SCHEME_HASHTR_KIND(ht), popcount)); 1358 } 1359 1360 END hash; 1361 1362 /**********************************************************************/ 1363 1364 START place; 1365 1366 place_bi_channel_val { 1367 mark: 1368 Scheme_Place_Bi_Channel *pbc = (Scheme_Place_Bi_Channel *)p; 1369 gcMARK2(pbc->link, gc); 1370 1371 size: 1372 gcBYTES_TO_WORDS(sizeof(Scheme_Place_Bi_Channel)); 1373 } 1374 1375 place_object_val { 1376 mark: 1377 size: 1378 gcBYTES_TO_WORDS(sizeof(Scheme_Place_Object)); 1379 } 1380 1381 place_val { 1382 mark: 1383 Scheme_Place *pr = (Scheme_Place *)p; 1384 gcMARK2(pr->channel, gc); 1385 gcMARK2(pr->mref, gc); 1386 gcMARK2(pr->pumper_threads, gc); 1387 gcMARK2(pr->place_obj, gc); 1388 gcMARK2(pr->prev, gc); 1389 gcMARK2(pr->next, gc); 1390 1391 size: 1392 gcBYTES_TO_WORDS(sizeof(Scheme_Place)); 1393 } 1394 1395 place_async_channel_val { 1396 mark: 1397 Scheme_Place_Async_Channel *pac = (Scheme_Place_Async_Channel *)p; 1398 Scheme_Object *pr; 1399 int i, j, sz; 1400 gcMARK2(pac->msgs, gc); 1401 gcMARK2(pac->msg_memory, gc); 1402 gcMARK2(pac->msg_chains, gc); 1403 gcMARK2(pac->wakeup_signal, gc); 1404 1405 /* mark master-allocated objects within each messages; the 1406 raw pairs that form the list are embedded in each message block */ 1407 j = pac->out; 1408 sz = pac->size; 1409 for (i = pac->count; i--; ) { 1410 pr = pac->msg_chains[j]; 1411 while (pr) { 1412 gcMARK2(SCHEME_CAR(pr), gc); 1413 pr = SCHEME_CDR(pr); 1414 } 1415 j = ((j + 1) % sz); 1416 } 1417 1418 size: 1419 gcBYTES_TO_WORDS(sizeof(Scheme_Place_Async_Channel)); 1420 } 1421 1422 serialized_file_fd_val { 1423 mark: 1424 Scheme_Serialized_File_FD *ffd = (Scheme_Serialized_File_FD *) p; 1425 gcMARK2(ffd->name, gc); 1426 1427 size: 1428 gcBYTES_TO_WORDS(sizeof(Scheme_Serialized_File_FD)); 1429 } 1430 1431 serialized_socket_fd_val { 1432 mark: 1433 Scheme_Serialized_Socket_FD *sfd = (Scheme_Serialized_Socket_FD *) p; 1434 gcMARK2(sfd->name, gc); 1435 1436 size: 1437 gcBYTES_TO_WORDS(sizeof(Scheme_Serialized_Socket_FD)); 1438 } 1439 1440 END place; 1441 1442 /**********************************************************************/ 1443 1444 START portfun; 1445 1446 mark_indexed_string { 1447 mark: 1448 Scheme_Indexed_String *is = (Scheme_Indexed_String *)p; 1449 1450 gcMARK2(is->string, gc); 1451 1452 size: 1453 gcBYTES_TO_WORDS(sizeof(Scheme_Indexed_String)); 1454 } 1455 1456 mark_user_input { 1457 mark: 1458 User_Input_Port *uip = (User_Input_Port *)p; 1459 1460 gcMARK2(uip->read_proc, gc); 1461 gcMARK2(uip->peek_proc, gc); 1462 gcMARK2(uip->progress_evt_proc, gc); 1463 gcMARK2(uip->peeked_read_proc, gc); 1464 gcMARK2(uip->location_proc, gc); 1465 gcMARK2(uip->count_lines_proc, gc); 1466 gcMARK2(uip->buffer_mode_proc, gc); 1467 gcMARK2(uip->close_proc, gc); 1468 gcMARK2(uip->reuse_str, gc); 1469 gcMARK2(uip->peeked, gc); 1470 gcMARK2(uip->prefix_pipe, gc); 1471 size: 1472 gcBYTES_TO_WORDS(sizeof(User_Input_Port)); 1473 } 1474 1475 mark_user_output { 1476 mark: 1477 User_Output_Port *uop = (User_Output_Port *)p; 1478 1479 gcMARK2(uop->evt, gc); 1480 gcMARK2(uop->write_evt_proc, gc); 1481 gcMARK2(uop->write_proc, gc); 1482 gcMARK2(uop->write_special_evt_proc, gc); 1483 gcMARK2(uop->write_special_proc, gc); 1484 gcMARK2(uop->location_proc, gc); 1485 gcMARK2(uop->count_lines_proc, gc); 1486 gcMARK2(uop->buffer_mode_proc, gc); 1487 gcMARK2(uop->close_proc, gc); 1488 gcMARK2(uop->buffer_pipe, gc); 1489 size: 1490 gcBYTES_TO_WORDS(sizeof(User_Output_Port)); 1491 } 1492 1493 END portfun; 1494 1495 /**********************************************************************/ 1496 1497 START port; 1498 1499 mark_input_file { 1500 mark: 1501 Scheme_Input_File *i = (Scheme_Input_File *)p; 1502 1503 gcMARK2(i->f, gc); 1504 1505 size: 1506 gcBYTES_TO_WORDS(sizeof(Scheme_Input_File)); 1507 } 1508 1509 mark_output_file { 1510 mark: 1511 Scheme_Output_File *o = (Scheme_Output_File *)p; 1512 1513 gcMARK2(o->f, gc); 1514 1515 size: 1516 gcBYTES_TO_WORDS(sizeof(Scheme_Output_File)); 1517 } 1518 1519 mark_input_fd { 1520 mark: 1521 Scheme_FD *fd = (Scheme_FD *)p; 1522 1523 gcMARK2(fd->buffer, gc); 1524 /* fd->refcount is malloc()ed */ 1525 gcMARK2(fd->flush_handle, gc); 1526 gcMARK2(fd->bufwidths, gc); 1527 1528 size: 1529 gcBYTES_TO_WORDS(sizeof(Scheme_FD)); 1530 } 1531 1532 mark_subprocess { 1533 mark: 1534 Scheme_Subprocess *sp = (Scheme_Subprocess *)p; 1535 gcMARK2(sp->mref, gc); 1536 size: 1537 gcBYTES_TO_WORDS(sizeof(Scheme_Subprocess)); 1538 } 1539 1540 mark_read_write_evt { 1541 mark: 1542 Scheme_Read_Write_Evt *rww = (Scheme_Read_Write_Evt *)p; 1543 gcMARK2(rww->port, gc); 1544 gcMARK2(rww->v, gc); 1545 gcMARK2(rww->str, gc); 1546 size: 1547 gcBYTES_TO_WORDS(sizeof(Scheme_Read_Write_Evt)); 1548 } 1549 1550 mark_filesystem_change_evt { 1551 mark: 1552 Scheme_Filesystem_Change_Evt *fc = (Scheme_Filesystem_Change_Evt *)p; 1553 gcMARK2(fc->mref, gc); 1554 size: 1555 gcBYTES_TO_WORDS(sizeof(Scheme_Filesystem_Change_Evt)); 1556 } 1557 1558 END port; 1559 1560 /**********************************************************************/ 1561 1562 START print; 1563 1564 mark_print_params { 1565 mark: 1566 PrintParams *pp = (PrintParams *)p; 1567 gcMARK2(pp->inspector, gc); 1568 gcMARK2(pp->print_port, gc); 1569 gcMARK2(pp->print_buffer, gc); 1570 gcMARK2(pp->depth_delta, gc); 1571 gcMARK2(pp->uq_ht, gc); 1572 size: 1573 gcBYTES_TO_WORDS(sizeof(PrintParams)); 1574 } 1575 1576 mark_marshal_tables { 1577 mark: 1578 Scheme_Marshal_Tables *mt = (Scheme_Marshal_Tables *)p; 1579 gcMARK2(mt->symtab, gc); 1580 gcMARK2(mt->st_refs, gc); 1581 gcMARK2(mt->st_ref_stack, gc); 1582 gcMARK2(mt->intern_map, gc); 1583 gcMARK2(mt->key_map, gc); 1584 gcMARK2(mt->delay_map, gc); 1585 gcMARK2(mt->cdata_map, gc); 1586 gcMARK2(mt->shared_offsets, gc); 1587 gcMARK2(mt->path_cache, gc); 1588 gcMARK2(mt->sorted_keys, gc); 1589 size: 1590 gcBYTES_TO_WORDS(sizeof(Scheme_Marshal_Tables)); 1591 } 1592 1593 END print; 1594 1595 /**********************************************************************/ 1596 1597 START network; 1598 1599 mark_listener { 1600 listener_t *l = (listener_t *)p; 1601 1602 mark: 1603 1604 gcMARK2(l->mref, gc); 1605 1606 size: 1607 gcBYTES_TO_WORDS(sizeof(listener_t) + ((l->count - mzFLEX_DELTA) * sizeof(tcp_t))); 1608 } 1609 1610 mark_tcp { 1611 mark: 1612 Scheme_Tcp *tcp = (Scheme_Tcp *)p; 1613 1614 gcMARK2(tcp->b.buffer, gc); 1615 gcMARK2(tcp->b.out_buffer, gc); 1616 1617 size: 1618 gcBYTES_TO_WORDS(sizeof(Scheme_Tcp)); 1619 } 1620 1621 mark_udp { 1622 mark: 1623 Scheme_UDP *udp = (Scheme_UDP *)p; 1624 1625 gcMARK2(udp->previous_from_addr, gc); 1626 gcMARK2(udp->mref, gc); 1627 1628 size: 1629 gcBYTES_TO_WORDS(sizeof(Scheme_UDP)); 1630 } 1631 1632 mark_udp_evt { 1633 mark: 1634 Scheme_UDP_Evt *uw = (Scheme_UDP_Evt *)p; 1635 1636 gcMARK2(uw->udp, gc); 1637 gcMARK2(uw->str, gc); 1638 1639 size: 1640 gcBYTES_TO_WORDS(sizeof(Scheme_UDP_Evt)); 1641 } 1642 1643 END network; 1644 1645 /**********************************************************************/ 1646 1647 START thread; 1648 1649 mark_parameterization { 1650 mark: 1651 Scheme_Parameterization *c = (Scheme_Parameterization *)p; 1652 int i; 1653 1654 for (i = max_configs; i--; ) { 1655 gcMARK2(c->prims[i], gc); 1656 } 1657 gcMARK2(c->extensions, gc); 1658 1659 size: 1660 gcBYTES_TO_WORDS((sizeof(Scheme_Parameterization) 1661 + ((max_configs - mzFLEX_DELTA) * sizeof(Scheme_Object*)))); 1662 } 1663 1664 mark_config { 1665 mark: 1666 Scheme_Config *config = (Scheme_Config *)p; 1667 gcMARK2(config->ht, gc); 1668 gcMARK2(config->root, gc); 1669 size: 1670 gcBYTES_TO_WORDS(sizeof(Scheme_Config)); 1671 } 1672 1673 mark_will_executor_val { 1674 mark: 1675 WillExecutor *e = (WillExecutor *)p; 1676 1677 gcMARK2(e->sema, gc); 1678 gcMARK2(e->first, gc); 1679 gcMARK2(e->last, gc); 1680 1681 size: 1682 gcBYTES_TO_WORDS(sizeof(WillExecutor)); 1683 } 1684 1685 mark_custodian_val { 1686 mark: 1687 Scheme_Custodian *m = (Scheme_Custodian *)p; 1688 1689 gcMARK2(m->boxes, gc); 1690 gcMARK2(m->mrefs, gc); 1691 gcMARK2(m->closers, gc); 1692 gcMARK2(m->data, gc); 1693 gcMARK2(m->data_ptr, gc); 1694 gcMARK2(m->post_callbacks, gc); 1695 1696 gcMARK2(m->parent, gc); 1697 gcMARK2(m->sibling, gc); 1698 gcMARK2(m->children, gc); 1699 1700 gcMARK2(m->global_next, gc); 1701 gcMARK2(m->global_prev, gc); 1702 1703 gcMARK2(m->cust_boxes, gc); 1704 1705 size: 1706 gcBYTES_TO_WORDS(sizeof(Scheme_Custodian)); 1707 } 1708 1709 mark_custodian_box_val { 1710 mark: 1711 Scheme_Custodian_Box *b = (Scheme_Custodian_Box *)p; 1712 int sd = ((Scheme_Custodian *)GC_resolve2(b->cust, gc))->shut_down; 1713 1714 gcMARK2(b->cust, gc); 1715 if (!sd) { 1716 gcMARK2(b->v, gc); 1717 } 1718 1719 size: 1720 gcBYTES_TO_WORDS(sizeof(Scheme_Custodian_Box)); 1721 } 1722 1723 mark_thread_hop { 1724 mark: 1725 Scheme_Thread_Custodian_Hop *hop = (Scheme_Thread_Custodian_Hop *)p; 1726 1727 gcMARK2(hop->p, gc); 1728 1729 size: 1730 gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Custodian_Hop)); 1731 } 1732 1733 mark_param_data { 1734 mark: 1735 ParamData *d = (ParamData *)p; 1736 1737 gcMARK2(d->key, gc); 1738 gcMARK2(d->guard, gc); 1739 gcMARK2(d->extract_guard, gc); 1740 gcMARK2(d->defcell, gc); 1741 1742 size: 1743 gcBYTES_TO_WORDS(sizeof(ParamData)); 1744 } 1745 1746 mark_will { 1747 mark: 1748 ActiveWill *w = (ActiveWill *)p; 1749 1750 gcMARK2(w->o, gc); 1751 gcMARK2(w->proc, gc); 1752 gcMARK2(w->w, gc); 1753 gcMARK2(w->next, gc); 1754 1755 size: 1756 gcBYTES_TO_WORDS(sizeof(ActiveWill)); 1757 } 1758 1759 mark_evt { 1760 mark: 1761 size: 1762 gcBYTES_TO_WORDS(sizeof(Evt)); 1763 } 1764 1765 mark_syncing { 1766 mark: 1767 Syncing *w = (Syncing *)p; 1768 1769 gcMARK2(w->set, gc); 1770 gcMARK2(w->wrapss, gc); 1771 gcMARK2(w->nackss, gc); 1772 gcMARK2(w->reposts, gc); 1773 gcMARK2(w->accepts, gc); 1774 gcMARK2(w->disable_break, gc); 1775 gcMARK2(w->thread, gc); 1776 1777 size: 1778 gcBYTES_TO_WORDS(sizeof(Syncing)); 1779 } 1780 1781 mark_evt_set { 1782 mark: 1783 Evt_Set *w = (Evt_Set *)p; 1784 1785 gcMARK2(w->ws, gc); 1786 gcMARK2(w->argv, gc); 1787 1788 size: 1789 gcBYTES_TO_WORDS(sizeof(Evt_Set)); 1790 } 1791 1792 mark_thread_set { 1793 mark: 1794 Scheme_Thread_Set *ts = (Scheme_Thread_Set *)p; 1795 1796 gcMARK2(ts->parent, gc); 1797 gcMARK2(ts->first, gc); 1798 gcMARK2(ts->next, gc); 1799 gcMARK2(ts->prev, gc); 1800 gcMARK2(ts->search_start, gc); 1801 gcMARK2(ts->current, gc); 1802 1803 size: 1804 gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Set)); 1805 } 1806 1807 mark_thread_cell { 1808 mark: 1809 Thread_Cell *c = (Thread_Cell *)p; 1810 1811 gcMARK2(c->def_val, gc); 1812 1813 size: 1814 gcBYTES_TO_WORDS(sizeof(Thread_Cell)); 1815 } 1816 1817 mark_plumber { 1818 mark: 1819 Scheme_Plumber *pl = (Scheme_Plumber *)p; 1820 1821 gcMARK2(pl->handles, gc); 1822 gcMARK2(pl->weak_handles, gc); 1823 1824 size: 1825 gcBYTES_TO_WORDS(sizeof(Scheme_Plumber)); 1826 } 1827 1828 END thread; 1829 1830 /**********************************************************************/ 1831 1832 START salloc; 1833 1834 mark_finalization { 1835 mark: 1836 Finalization *f = (Finalization *)p; 1837 1838 gcMARK2(f->data, gc); 1839 gcMARK2(f->next, gc); 1840 gcMARK2(f->prev, gc); 1841 1842 size: 1843 gcBYTES_TO_WORDS(sizeof(Finalization)); 1844 } 1845 1846 mark_finalizations { 1847 mark: 1848 Finalizations *f = (Finalizations *)p; 1849 1850 gcMARK2(f->scheme_first, gc); 1851 gcMARK2(f->scheme_last, gc); 1852 gcMARK2(f->prim_first, gc); 1853 gcMARK2(f->prim_last, gc); 1854 gcMARK2(f->ext_data, gc); 1855 1856 size: 1857 gcBYTES_TO_WORDS(sizeof(Finalizations)); 1858 } 1859 1860 END salloc; 1861 1862 /**********************************************************************/ 1863 1864 START sema; 1865 1866 mark_channel_syncer { 1867 mark: 1868 Scheme_Channel_Syncer *w = (Scheme_Channel_Syncer *)p; 1869 1870 gcMARK2(w->p, gc); 1871 gcMARK2(w->prev, gc); 1872 gcMARK2(w->next, gc); 1873 gcMARK2(w->syncing, gc); 1874 gcMARK2(w->obj, gc); 1875 1876 size: 1877 gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Syncer)); 1878 } 1879 1880 mark_alarm { 1881 mark: 1882 size: 1883 gcBYTES_TO_WORDS(sizeof(Scheme_Alarm)); 1884 } 1885 1886 END sema; 1887 1888 /**********************************************************************/ 1889 1890 START struct; 1891 1892 #ifdef MZ_USE_PLACES 1893 mark_serialized_struct_val { 1894 Scheme_Serialized_Structure *s = (Scheme_Serialized_Structure *)p; 1895 int num_slots = s->num_slots; 1896 1897 mark: 1898 int i; 1899 1900 gcMARK2(s->prefab_key, gc); 1901 1902 for(i = num_slots; i--; ) 1903 gcMARK2(s->slots[i], gc); 1904 1905 size: 1906 gcBYTES_TO_WORDS((sizeof(Scheme_Serialized_Structure) 1907 + ((num_slots - mzFLEX_DELTA) * sizeof(Scheme_Object *)))); 1908 } 1909 #endif 1910 1911 mark_struct_val { 1912 Scheme_Structure *s = (Scheme_Structure *)p; 1913 int num_slots = ((Scheme_Struct_Type *)GC_resolve2(s->stype, gc))->num_slots; 1914 1915 mark: 1916 int i; 1917 1918 gcFIXUP2_TYPED_NOW(Scheme_Struct_Type *, s->stype, gc); 1919 1920 for(i = num_slots; i--; ) 1921 gcMARK2(s->slots[i], gc); 1922 1923 size: 1924 gcBYTES_TO_WORDS((sizeof(Scheme_Structure) 1925 + ((num_slots - mzFLEX_DELTA) * sizeof(Scheme_Object *)))); 1926 } 1927 1928 mark_struct_type_val { 1929 Scheme_Struct_Type *t = (Scheme_Struct_Type *)p; 1930 1931 mark: 1932 int i; 1933 for (i = t->name_pos + 1; i--; ) { 1934 gcMARK2(t->parent_types[i], gc); 1935 } 1936 gcMARK2(t->name, gc); 1937 gcMARK2(t->inspector, gc); 1938 gcMARK2(t->accessor, gc); 1939 gcMARK2(t->mutator, gc); 1940 gcMARK2(t->prefab_key, gc); 1941 gcMARK2(t->uninit_val, gc); 1942 gcMARK2(t->props, gc); 1943 gcMARK2(t->proc_attr, gc); 1944 gcMARK2(t->guard, gc); 1945 gcMARK2(t->immutables, gc); 1946 1947 size: 1948 gcBYTES_TO_WORDS((sizeof(Scheme_Struct_Type) 1949 + ((t->name_pos + 1 - mzFLEX_DELTA) 1950 * sizeof(Scheme_Struct_Type *)))); 1951 } 1952 1953 mark_struct_property { 1954 mark: 1955 Scheme_Struct_Property *i = (Scheme_Struct_Property *)p; 1956 gcMARK2(i->name, gc); 1957 gcMARK2(i->guard, gc); 1958 gcMARK2(i->supers, gc); 1959 size: 1960 gcBYTES_TO_WORDS(sizeof(Scheme_Struct_Property)); 1961 } 1962 1963 mark_wrapped_evt { 1964 mark: 1965 Wrapped_Evt *ww = (Wrapped_Evt *)p; 1966 1967 gcMARK2(ww->evt, gc); 1968 gcMARK2(ww->wrapper, gc); 1969 1970 size: 1971 gcBYTES_TO_WORDS(sizeof(Wrapped_Evt)); 1972 } 1973 1974 mark_nack_guard_evt { 1975 mark: 1976 Nack_Guard_Evt *nw = (Nack_Guard_Evt *)p; 1977 1978 gcMARK2(nw->maker, gc); 1979 1980 size: 1981 gcBYTES_TO_WORDS(sizeof(Nack_Guard_Evt)); 1982 } 1983 1984 mark_active_replace_evt { 1985 mark: 1986 Active_Replace_Evt *a = (Active_Replace_Evt *)p; 1987 1988 gcMARK2(a->syncing, gc); 1989 gcMARK2(a->wrapper, gc); 1990 gcMARK2(a->orig, gc); 1991 1992 size: 1993 gcBYTES_TO_WORDS(sizeof(Active_Replace_Evt)); 1994 } 1995 1996 mark_chaperone { 1997 mark: 1998 Scheme_Chaperone *px = (Scheme_Chaperone *)p; 1999 2000 gcMARK2(px->val, gc); 2001 gcMARK2(px->prev, gc); 2002 gcMARK2(px->props, gc); 2003 gcMARK2(px->redirects, gc); 2004 2005 size: 2006 gcBYTES_TO_WORDS(sizeof(Scheme_Chaperone)); 2007 } 2008 2009 END struct; 2010 2011 /**********************************************************************/ 2012 2013 START compile; 2014 2015 mark_ir_lambda_info { 2016 mark: 2017 Scheme_IR_Lambda_Info *i = (Scheme_IR_Lambda_Info *)p; 2018 2019 gcMARK2(i->base_closure, gc); 2020 gcMARK2(i->vars, gc); 2021 gcMARK2(i->arg_types, gc); 2022 gcMARK2(i->arg_type_contributors, gc); 2023 2024 size: 2025 gcBYTES_TO_WORDS(sizeof(Scheme_IR_Lambda_Info)); 2026 } 2027 2028 END compile; 2029 2030 /**********************************************************************/ 2031 2032 START read; 2033 2034 mark_indent { 2035 mark: 2036 size: 2037 gcBYTES_TO_WORDS(sizeof(Scheme_Indent)); 2038 } 2039 2040 mark_cport { 2041 mark: 2042 CPort *cp = (CPort *)p; 2043 gcMARK2(cp->start, gc); 2044 gcMARK2(cp->orig_port, gc); 2045 gcMARK2(cp->ht, gc); 2046 gcMARK2(cp->ut, gc); 2047 gcMARK2(cp->symtab, gc); 2048 gcMARK2(cp->symtab_entries, gc); 2049 gcMARK2(cp->relto, gc); 2050 gcMARK2(cp->shared_offsets, gc); 2051 gcMARK2(cp->delay_info, gc); 2052 gcMARK2(cp->symtab_refs, gc); 2053 size: 2054 gcBYTES_TO_WORDS(sizeof(CPort)); 2055 } 2056 2057 mark_read_params { 2058 mark: 2059 ReadParams *rp = (ReadParams *)p; 2060 gcMARK2(rp->delay_load_info, gc); 2061 gcMARK2(rp->read_relative_path, gc); 2062 gcMARK2(rp->graph_ht, gc); 2063 size: 2064 gcBYTES_TO_WORDS(sizeof(ReadParams)); 2065 } 2066 2067 mark_delay_load { 2068 mark: 2069 Scheme_Load_Delay *ld = (Scheme_Load_Delay *)p; 2070 gcMARK2(ld->path, gc); 2071 gcMARK2(ld->symtab, gc); 2072 gcMARK2(ld->symtab_entries, gc); 2073 gcMARK2(ld->shared_offsets, gc); 2074 gcMARK2(ld->relto, gc); 2075 gcMARK2(ld->ut, gc); 2076 gcMARK2(ld->current_rp, gc); 2077 gcMARK2(ld->cached, gc); 2078 gcMARK2(ld->cached_port, gc); 2079 size: 2080 gcBYTES_TO_WORDS(sizeof(Scheme_Load_Delay)); 2081 } 2082 2083 mark_unmarshal_tables { 2084 mark: 2085 Scheme_Unmarshal_Tables *ut = (Scheme_Unmarshal_Tables *)p; 2086 gcMARK2(ut->rp, gc); 2087 gcMARK2(ut->decoded, gc); 2088 size: 2089 gcBYTES_TO_WORDS(sizeof(Scheme_Unmarshal_Tables)); 2090 } 2091 2092 END read; 2093 2094 /**********************************************************************/ 2095 2096 START regexp; 2097 2098 mark_regexp { 2099 regexp *r = (regexp *)p; 2100 mark: 2101 gcMARK2(r->source, gc); 2102 gcMARK2(r->regstart, gc); 2103 size: 2104 gcBYTES_TO_WORDS((sizeof(regexp) + r->regsize)); 2105 } 2106 2107 mark_regwork { 2108 mark: 2109 Regwork *r = (Regwork *)p; 2110 gcMARK2(r->str, gc); 2111 gcMARK2(r->instr, gc); 2112 gcMARK2(r->port, gc); 2113 gcMARK2(r->unless_evt, gc); 2114 gcMARK2(r->startp, gc); 2115 gcMARK2(r->maybep, gc); 2116 gcMARK2(r->endp, gc); 2117 gcMARK2(r->counters, gc); 2118 gcMARK2(r->peekskip, gc); 2119 gcMARK2(r->prefix, gc); 2120 gcMARK2(r->lazy_string, gc); 2121 gcMARK2(r->rewind_stack, gc); 2122 size: 2123 gcBYTES_TO_WORDS(sizeof(Regwork)); 2124 } 2125 2126 mark_lazy_string { 2127 mark: 2128 rx_lazy_str_t *ls = (rx_lazy_str_t *)p; 2129 gcMARK2(ls->s, gc); 2130 gcMARK2(ls->chars, gc); 2131 size: 2132 gcBYTES_TO_WORDS(sizeof(rx_lazy_str_t)); 2133 } 2134 2135 END regexp; 2136 2137 /**********************************************************************/ 2138 2139 START string; 2140 2141 mark_string_convert { 2142 mark: 2143 Scheme_Converter *c = (Scheme_Converter *)p; 2144 gcMARK2(c->mref, gc); 2145 size: 2146 gcBYTES_TO_WORDS(sizeof(Scheme_Converter)); 2147 } 2148 2149 END string; 2150 2151 /**********************************************************************/ 2152 2153 START syntax; 2154 2155 mark_srcloc { 2156 mark: 2157 Scheme_Stx_Srcloc *s = (Scheme_Stx_Srcloc *)p; 2158 gcMARK2(s->src, gc); 2159 size: 2160 gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Srcloc)); 2161 } 2162 2163 END syntax; 2164 2165 /**********************************************************************/ 2166 2167 START jit; 2168 2169 native_closure { 2170 Scheme_Native_Closure *c = (Scheme_Native_Closure *)p; 2171 int closure_size = ((Scheme_Native_Lambda *)GC_resolve2(c->code, gc))->closure_size; 2172 2173 if (closure_size < 0) { 2174 closure_size = -(closure_size + 1); 2175 } 2176 2177 mark: 2178 { 2179 int i = closure_size; 2180 START_MARK_ONLY; 2181 # define CLOSURE_DATA_TYPE Scheme_Native_Lambda 2182 # include "mzclpf_decl.inc" 2183 END_MARK_ONLY; 2184 2185 gcMARK2(c->code, gc); 2186 2187 START_MARK_ONLY; 2188 # include "mzclpf_pre.inc" 2189 END_MARK_ONLY; 2190 2191 while (i--) 2192 gcMARK2(c->vals[i], gc); 2193 2194 START_MARK_ONLY; 2195 # include "mzclpf_post.inc" 2196 # undef CLOSURE_DATA_TYPE 2197 END_MARK_ONLY; 2198 } 2199 2200 size: 2201 gcBYTES_TO_WORDS((sizeof(Scheme_Native_Closure) 2202 + (closure_size - mzFLEX_DELTA) * sizeof(Scheme_Object *))); 2203 } 2204 2205 mark_jit_state { 2206 mark: 2207 mz_jit_state *j = (mz_jit_state *)p; 2208 gcMARK2(j->mappings, gc); 2209 gcMARK2(j->self_lam, gc); 2210 gcMARK2(j->example_argv, gc); 2211 gcMARK2(j->nc, gc); 2212 gcMARK2(j->retaining_data, gc); 2213 gcMARK2(j->patch_depth, gc); 2214 2215 size: 2216 gcBYTES_TO_WORDS(sizeof(mz_jit_state)); 2217 } 2218 2219 native_unclosed_proc { 2220 mark: 2221 Scheme_Native_Lambda *d = (Scheme_Native_Lambda *)p; 2222 int i; 2223 2224 gcMARK2(d->u2.name, gc); 2225 if (d->retained) { 2226 for (i = SCHEME_INT_VAL(d->retained[0]); i--; ) { 2227 gcMARK2(d->retained[i], gc); 2228 } 2229 } 2230 if (d->closure_size < 0) { 2231 gcMARK2(d->u.arities, gc); 2232 } 2233 gcMARK2(d->tl_map, gc); 2234 gcMARK2(d->eq_key, gc); 2235 2236 size: 2237 gcBYTES_TO_WORDS(sizeof(Scheme_Native_Lambda)); 2238 } 2239 2240 native_unclosed_proc_plus_case { 2241 mark: 2242 Scheme_Native_Lambda_Plus_Case *d = (Scheme_Native_Lambda_Plus_Case *)p; 2243 2244 native_unclosed_proc_MARK(p, gc); 2245 gcMARK2(d->case_lam, gc); 2246 2247 size: 2248 gcBYTES_TO_WORDS(sizeof(Scheme_Native_Lambda_Plus_Case)); 2249 } 2250 2251 END jit; 2252 2253 /**********************************************************************/ 2254 2255 START future; 2256 2257 #ifdef MZ_USE_FUTURES 2258 2259 future { 2260 mark: 2261 future_t *f = (future_t *)p; 2262 gcMARK2(f->orig_lambda, gc); 2263 gcMARK2(f->cust, gc); 2264 gcMARK2(f->arg_s0, gc); 2265 gcMARK2(f->arg_t0, gc); 2266 gcMARK2(f->arg_S0, gc); 2267 gcMARK2(f->arg_b0, gc); 2268 gcMARK2(f->arg_n0, gc); 2269 gcMARK2(f->arg_s1, gc); 2270 gcMARK2(f->arg_t1, gc); 2271 gcMARK2(f->arg_S1, gc); 2272 gcMARK2(f->arg_s2, gc); 2273 gcMARK2(f->arg_S2, gc); 2274 gcMARK2(f->arg_S4, gc); 2275 gcMARK2(f->retval_s, gc); 2276 gcMARK2(f->retval, gc); 2277 gcMARK2(f->multiple_array, gc); 2278 gcMARK2(f->tail_rator, gc); 2279 gcMARK2(f->tail_rands, gc); 2280 gcMARK2(f->prev, gc); 2281 gcMARK2(f->next, gc); 2282 gcMARK2(f->next_waiting_atomic, gc); 2283 gcMARK2(f->next_waiting_lwc, gc); 2284 gcMARK2(f->next_waiting_touch, gc); 2285 gcMARK2(f->suspended_lw, gc); 2286 gcMARK2(f->suspended_lw_stack, gc); 2287 gcMARK2(f->prev_in_fsema_queue, gc); 2288 gcMARK2(f->next_in_fsema_queue, gc); 2289 gcMARK2(f->touching, gc); 2290 size: 2291 gcBYTES_TO_WORDS(sizeof(future_t)); 2292 } 2293 2294 fsemaphore { 2295 mark: 2296 fsemaphore_t *s = (fsemaphore_t*)p; 2297 gcMARK2(s->queue_front, gc); 2298 gcMARK2(s->queue_end, gc); 2299 size: 2300 gcBYTES_TO_WORDS(sizeof(fsemaphore_t)); 2301 } 2302 2303 #else 2304 2305 sequential_future { 2306 mark: 2307 future_t *f = (future_t *)p; 2308 gcMARK2(f->orig_lambda, gc); 2309 gcMARK2(f->running_sema, gc); 2310 gcMARK2(f->retval, gc); 2311 gcMARK2(f->multiple_array, gc); 2312 size: 2313 gcBYTES_TO_WORDS(sizeof(future_t)); 2314 } 2315 2316 sequential_fsemaphore { 2317 mark: 2318 fsemaphore_t *s = (fsemaphore_t*)p; 2319 gcMARK2(s->sema, gc); 2320 size: 2321 gcBYTES_TO_WORDS(sizeof(fsemaphore_t)); 2322 } 2323 2324 #endif 2325 2326 2327 2328 END future; 2329 2330 /**********************************************************************/ 2331