rts/StgMiscClosures.cmm

   1 /* ----------------------------------------------------------------------------
   2  *
   3  * (c) The GHC Team, 1998-2004
   4  *
   5  * Entry code for various built-in closure types.
   6  *
   7  * This file is written in a subset of C--, extended with various
   8  * features specific to GHC.  It is compiled by GHC directly.  For the
   9  * syntax of .cmm files, see the parser in ghc/compiler/cmm/CmmParse.y.
  10  *
  11  * --------------------------------------------------------------------------*/
  12
  13 #include "Cmm.h"
  14
  15 import pthread_mutex_lock;
  16 import ghczmprim_GHCziTypes_Czh_static_info;
  17 import ghczmprim_GHCziTypes_Izh_static_info;
  18 import EnterCriticalSection;
  19 import LeaveCriticalSection;
  20
  21 /* ----------------------------------------------------------------------------
  22    Support for the bytecode interpreter.
  23    ------------------------------------------------------------------------- */
  24
  25 /* 9 bits of return code for constructors created by the interpreter. */
  26 stg_interp_constr_entry
  27 {
  28     /* R1 points at the constructor */
  29     jump %ENTRY_CODE(Sp(0));
  30 }
  31
  32 /* Some info tables to be used when compiled code returns a value to
  33    the interpreter, i.e. the interpreter pushes one of these onto the
  34    stack before entering a value.  What the code does is to
  35    impedance-match the compiled return convention (in R1p/R1n/F1/D1 etc) to
  36    the interpreter's convention (returned value is on top of stack),
  37    and then cause the scheduler to enter the interpreter.
  38
  39    On entry, the stack (growing down) looks like this:
  40
  41       ptr to BCO holding return continuation
  42       ptr to one of these info tables.
  43
  44    The info table code, both direct and vectored, must:
  45       * push R1/F1/D1 on the stack, and its tag if necessary
  46       * push the BCO (so it's now on the stack twice)
  47       * Yield, ie, go to the scheduler.
  48
  49    Scheduler examines the t.o.s, discovers it is a BCO, and proceeds
  50    directly to the bytecode interpreter.  That pops the top element
  51    (the BCO, containing the return continuation), and interprets it.
  52    Net result: return continuation gets interpreted, with the
  53    following stack:
  54
  55       ptr to this BCO
  56       ptr to the info table just jumped thru
  57       return value
  58
  59    which is just what we want -- the "standard" return layout for the
  60    interpreter.  Hurrah!
  61
  62    Don't ask me how unboxed tuple returns are supposed to work.  We
  63    haven't got a good story about that yet.
  64 */
  65
  66 INFO_TABLE_RET( stg_ctoi_R1p, RET_BCO)
  67 {
  68     Sp_adj(-2);
  69     Sp(1) = R1;
  70     Sp(0) = stg_enter_info;
  71     jump stg_yield_to_interpreter;
  72 }
  73
  74 /*
  75  * When the returned value is a pointer, but unlifted, in R1 ...
  76  */
  77 INFO_TABLE_RET( stg_ctoi_R1unpt, RET_BCO )
  78 {
  79     Sp_adj(-2);
  80     Sp(1) = R1;
  81     Sp(0) = stg_gc_unpt_r1_info;
  82     jump stg_yield_to_interpreter;
  83 }
  84
  85 /*
  86  * When the returned value is a non-pointer in R1 ...
  87  */
  88 INFO_TABLE_RET( stg_ctoi_R1n, RET_BCO )
  89 {
  90     Sp_adj(-2);
  91     Sp(1) = R1;
  92     Sp(0) = stg_gc_unbx_r1_info;
  93     jump stg_yield_to_interpreter;
  94 }
  95
  96 /*
  97  * When the returned value is in F1
  98  */
  99 INFO_TABLE_RET( stg_ctoi_F1, RET_BCO )
 100 {
 101     Sp_adj(-2);
 102     F_[Sp + WDS(1)] = F1;
 103     Sp(0) = stg_gc_f1_info;
 104     jump stg_yield_to_interpreter;
 105 }
 106
 107 /*
 108  * When the returned value is in D1
 109  */
 110 INFO_TABLE_RET( stg_ctoi_D1, RET_BCO )
 111 {
 112     Sp_adj(-1) - SIZEOF_DOUBLE;
 113     D_[Sp + WDS(1)] = D1;
 114     Sp(0) = stg_gc_d1_info;
 115     jump stg_yield_to_interpreter;
 116 }
 117
 118 /*
 119  * When the returned value is in L1
 120  */
 121 INFO_TABLE_RET( stg_ctoi_L1, RET_BCO )
 122 {
 123     Sp_adj(-1) - 8;
 124     L_[Sp + WDS(1)] = L1;
 125     Sp(0) = stg_gc_l1_info;
 126     jump stg_yield_to_interpreter;
 127 }
 128
 129 /*
 130  * When the returned value is a void
 131  */
 132 INFO_TABLE_RET( stg_ctoi_V, RET_BCO )
 133 {
 134     Sp_adj(-1);
 135     Sp(0) = stg_gc_void_info;
 136     jump stg_yield_to_interpreter;
 137 }
 138
 139 /*
 140  * Dummy info table pushed on the top of the stack when the interpreter
 141  * should apply the BCO on the stack to its arguments, also on the
 142  * stack.
 143  */
 144 INFO_TABLE_RET( stg_apply_interp, RET_BCO )
 145 {
 146     /* Just in case we end up in here... (we shouldn't) */
 147     jump stg_yield_to_interpreter;
 148 }
 149
 150 /* ----------------------------------------------------------------------------
 151    Entry code for a BCO
 152    ------------------------------------------------------------------------- */
 153
 154 INFO_TABLE_FUN( stg_BCO, 4, 0, BCO, "BCO", "BCO", ARG_BCO )
 155 {
 156   /* entering a BCO means "apply it", same as a function */
 157   Sp_adj(-2);
 158   Sp(1) = R1;
 159   Sp(0) = stg_apply_interp_info;
 160   jump stg_yield_to_interpreter;
 161 }
 162
 163 /* ----------------------------------------------------------------------------
 164    Info tables for indirections.
 165
 166    SPECIALISED INDIRECTIONS: we have a specialised indirection for direct returns,
 167    so that we can avoid entering
 168    the object when we know it points directly to a value.  The update
 169    code (Updates.cmm) updates objects with the appropriate kind of
 170    indirection.  We only do this for young-gen indirections.
 171    ------------------------------------------------------------------------- */
 172
 173 INFO_TABLE(stg_IND,1,0,IND,"IND","IND")
 174 {
 175     TICK_ENT_DYN_IND(); /* tick */
 176     R1 = UNTAG(StgInd_indirectee(R1));
 177     TICK_ENT_VIA_NODE();
 178     jump %GET_ENTRY(R1);
 179 }
 180
 181 INFO_TABLE(stg_IND_direct,1,0,IND,"IND","IND")
 182 {
 183     TICK_ENT_DYN_IND(); /* tick */
 184     R1 = StgInd_indirectee(R1);
 185     TICK_ENT_VIA_NODE();
 186     jump %ENTRY_CODE(Sp(0));
 187 }
 188
 189 INFO_TABLE(stg_IND_STATIC,1,0,IND_STATIC,"IND_STATIC","IND_STATIC")
 190 {
 191     TICK_ENT_STATIC_IND();      /* tick */
 192     R1 = UNTAG(StgInd_indirectee(R1));
 193     TICK_ENT_VIA_NODE();
 194     jump %GET_ENTRY(R1);
 195 }
 196
 197 INFO_TABLE(stg_IND_PERM,1,0,IND_PERM,"IND_PERM","IND_PERM")
 198 {
 199     /* Don't add INDs to granularity cost */
 200
 201     /* Don't: TICK_ENT_STATIC_IND(Node); for ticky-ticky; this ind is
 202        here only to help profiling */
 203
 204 #if defined(TICKY_TICKY) && !defined(PROFILING)
 205     /* TICKY_TICKY && !PROFILING means PERM_IND *replaces* an IND, rather than
 206        being extra  */
 207     TICK_ENT_PERM_IND();
 208 #endif
 209
 210     LDV_ENTER(R1);
 211
 212     /* Enter PAP cost centre */
 213     ENTER_CCS_PAP_CL(R1);
 214
 215     /* For ticky-ticky, change the perm_ind to a normal ind on first
 216      * entry, so the number of ent_perm_inds is the number of *thunks*
 217      * entered again, not the number of subsequent entries.
 218      *
 219      * Since this screws up cost centres, we die if profiling and
 220      * ticky_ticky are on at the same time.  KSW 1999-01.
 221      */
 222 #ifdef TICKY_TICKY
 223 #  ifdef PROFILING
 224 #    error Profiling and ticky-ticky do not mix at present!
 225 #  endif  /* PROFILING */
 226     StgHeader_info(R1) = stg_IND_info;
 227 #endif /* TICKY_TICKY */
 228
 229     R1 = UNTAG(StgInd_indirectee(R1));
 230
 231 #if defined(TICKY_TICKY) && !defined(PROFILING)
 232     TICK_ENT_VIA_NODE();
 233 #endif
 234
 235     jump %GET_ENTRY(R1);
 236 }
 237
 238 /* ----------------------------------------------------------------------------
 239    Black holes.
 240
 241    Entering a black hole normally causes a cyclic data dependency, but
 242    in the concurrent world, black holes are synchronization points,
 243    and they are turned into blocking queues when there are threads
 244    waiting for the evaluation of the closure to finish.
 245    ------------------------------------------------------------------------- */
 246
 247 INFO_TABLE(stg_BLACKHOLE,1,0,BLACKHOLE,"BLACKHOLE","BLACKHOLE")
 248 {
 249     W_ r, p, info, bq, msg, owner, bd;
 250
 251     TICK_ENT_DYN_IND(); /* tick */
 252
 253 retry:
 254     p = StgInd_indirectee(R1);
 255     if (GETTAG(p) != 0) {
 256         R1 = p;
 257         jump %ENTRY_CODE(Sp(0));
 258     }
 259
 260     info = StgHeader_info(p);
 261     if (info == stg_IND_info) {
 262         // This could happen, if e.g. we got a BLOCKING_QUEUE that has
 263         // just been replaced with an IND by another thread in
 264         // wakeBlockingQueue().
 265         goto retry;
 266     }
 267
 268     if (info == stg_TSO_info ||
 269         info == stg_BLOCKING_QUEUE_CLEAN_info ||
 270         info == stg_BLOCKING_QUEUE_DIRTY_info)
 271     {
 272         ("ptr" msg) = foreign "C" allocate(MyCapability() "ptr",
 273                                            BYTES_TO_WDS(SIZEOF_MessageBlackHole)) [R1];
 274
 275         SET_HDR(msg, stg_MSG_BLACKHOLE_info, CCS_SYSTEM);
 276         MessageBlackHole_tso(msg) = CurrentTSO;
 277         MessageBlackHole_bh(msg) = R1;
 278
 279         (r) = foreign "C" messageBlackHole(MyCapability() "ptr", msg "ptr") [R1];
 280
 281         if (r == 0) {
 282             goto retry;
 283         } else {
 284             StgTSO_why_blocked(CurrentTSO) = BlockedOnBlackHole::I16;
 285             StgTSO_block_info(CurrentTSO) = msg;
 286             jump stg_block_blackhole;
 287         }
 288     }
 289     else
 290     {
 291         R1 = p;
 292         ENTER();
 293     }
 294 }
 295
 296 INFO_TABLE(__stg_EAGER_BLACKHOLE,1,0,BLACKHOLE,"BLACKHOLE","BLACKHOLE")
 297 {
 298     jump ENTRY_LBL(stg_BLACKHOLE);
 299 }
 300
 301 // CAF_BLACKHOLE is allocated when entering a CAF.  The reason it is
 302 // distinct from BLACKHOLE is so that we can tell the difference
 303 // between an update frame on the stack that points to a CAF under
 304 // evaluation, and one that points to a closure that is under
 305 // evaluation by another thread (a BLACKHOLE).  See threadPaused().
 306 //
 307 INFO_TABLE(stg_CAF_BLACKHOLE,1,0,BLACKHOLE,"BLACKHOLE","BLACKHOLE")
 308 {
 309     jump ENTRY_LBL(stg_BLACKHOLE);
 310 }
 311
 312 INFO_TABLE(stg_BLOCKING_QUEUE_CLEAN,4,0,BLOCKING_QUEUE,"BLOCKING_QUEUE","BLOCKING_QUEUE")
 313 { foreign "C" barf("BLOCKING_QUEUE_CLEAN object entered!") never returns; }
 314
 315
 316 INFO_TABLE(stg_BLOCKING_QUEUE_DIRTY,4,0,BLOCKING_QUEUE,"BLOCKING_QUEUE","BLOCKING_QUEUE")
 317 { foreign "C" barf("BLOCKING_QUEUE_DIRTY object entered!") never returns; }
 318
 319
 320 /* ----------------------------------------------------------------------------
 321    Whiteholes are used for the "locked" state of a closure (see lockClosure())
 322    ------------------------------------------------------------------------- */
 323
 324 INFO_TABLE(stg_WHITEHOLE, 0,0, WHITEHOLE, "WHITEHOLE", "WHITEHOLE")
 325 {
 326 #if defined(THREADED_RTS)
 327     W_ info, i;
 328
 329     i = 0;
 330 loop:
 331     // spin until the WHITEHOLE is updated
 332     info = StgHeader_info(R1);
 333     if (info == stg_WHITEHOLE_info) {
 334         i = i + 1;
 335         if (i == SPIN_COUNT) {
 336             i = 0;
 337             foreign "C" yieldThread() [R1];
 338         }
 339         goto loop;
 340     }
 341     jump %ENTRY_CODE(info);
 342 #else
 343     foreign "C" barf("WHITEHOLE object entered!") never returns;
 344 #endif
 345 }
 346
 347 /* ----------------------------------------------------------------------------
 348    Some static info tables for things that don't get entered, and
 349    therefore don't need entry code (i.e. boxed but unpointed objects)
 350    NON_ENTERABLE_ENTRY_CODE now defined at the beginning of the file
 351    ------------------------------------------------------------------------- */
 352
 353 INFO_TABLE(stg_TSO, 0,0,TSO, "TSO", "TSO")
 354 { foreign "C" barf("TSO object entered!") never returns; }
 355
 356 /* ----------------------------------------------------------------------------
 357    Weak pointers
 358
 359    Live weak pointers have a special closure type.  Dead ones are just
 360    nullary constructors (although they live on the heap - we overwrite
 361    live weak pointers with dead ones).
 362    ------------------------------------------------------------------------- */
 363
 364 INFO_TABLE(stg_WEAK,1,4,WEAK,"WEAK","WEAK")
 365 { foreign "C" barf("WEAK object entered!") never returns; }
 366
 367 /*
 368  * It's important when turning an existing WEAK into a DEAD_WEAK
 369  * (which is what finalizeWeak# does) that we don't lose the link
 370  * field and break the linked list of weak pointers.  Hence, we give
 371  * DEAD_WEAK 5 non-pointer fields.
 372  */
 373 INFO_TABLE_CONSTR(stg_DEAD_WEAK,0,5,0,CONSTR,"DEAD_WEAK","DEAD_WEAK")
 374 { foreign "C" barf("DEAD_WEAK object entered!") never returns; }
 375
 376 /* ----------------------------------------------------------------------------
 377    NO_FINALIZER
 378
 379    This is a static nullary constructor (like []) that we use to mark an empty
 380    finalizer in a weak pointer object.
 381    ------------------------------------------------------------------------- */
 382
 383 INFO_TABLE_CONSTR(stg_NO_FINALIZER,0,0,0,CONSTR_NOCAF_STATIC,"NO_FINALIZER","NO_FINALIZER")
 384 { foreign "C" barf("NO_FINALIZER object entered!") never returns; }
 385
 386 CLOSURE(stg_NO_FINALIZER_closure,stg_NO_FINALIZER);
 387
 388 /* ----------------------------------------------------------------------------
 389    Stable Names are unlifted too.
 390    ------------------------------------------------------------------------- */
 391
 392 INFO_TABLE(stg_STABLE_NAME,0,1,PRIM,"STABLE_NAME","STABLE_NAME")
 393 { foreign "C" barf("STABLE_NAME object entered!") never returns; }
 394
 395 /* ----------------------------------------------------------------------------
 396    MVars
 397
 398    There are two kinds of these: full and empty.  We need an info table
 399    and entry code for each type.
 400    ------------------------------------------------------------------------- */
 401
 402 INFO_TABLE(stg_MVAR_CLEAN,3,0,MVAR_CLEAN,"MVAR","MVAR")
 403 { foreign "C" barf("MVAR object entered!") never returns; }
 404
 405 INFO_TABLE(stg_MVAR_DIRTY,3,0,MVAR_DIRTY,"MVAR","MVAR")
 406 { foreign "C" barf("MVAR object entered!") never returns; }
 407
 408 /* -----------------------------------------------------------------------------
 409    STM
 410    -------------------------------------------------------------------------- */
 411
 412 INFO_TABLE(stg_TVAR, 2, 1, MUT_PRIM, "TVAR", "TVAR")
 413 { foreign "C" barf("TVAR object entered!") never returns; }
 414
 415 INFO_TABLE(stg_TVAR_WATCH_QUEUE, 3, 0, MUT_PRIM, "TVAR_WATCH_QUEUE", "TVAR_WATCH_QUEUE")
 416 { foreign "C" barf("TVAR_WATCH_QUEUE object entered!") never returns; }
 417
 418 INFO_TABLE(stg_ATOMIC_INVARIANT, 2, 1, MUT_PRIM, "ATOMIC_INVARIANT", "ATOMIC_INVARIANT")
 419 { foreign "C" barf("ATOMIC_INVARIANT object entered!") never returns; }
 420
 421 INFO_TABLE(stg_INVARIANT_CHECK_QUEUE, 3, 0, MUT_PRIM, "INVARIANT_CHECK_QUEUE", "INVARIANT_CHECK_QUEUE")
 422 { foreign "C" barf("INVARIANT_CHECK_QUEUE object entered!") never returns; }
 423
 424 INFO_TABLE(stg_TREC_CHUNK, 0, 0, TREC_CHUNK, "TREC_CHUNK", "TREC_CHUNK")
 425 { foreign "C" barf("TREC_CHUNK object entered!") never returns; }
 426
 427 INFO_TABLE(stg_TREC_HEADER, 3, 1, MUT_PRIM, "TREC_HEADER", "TREC_HEADER")
 428 { foreign "C" barf("TREC_HEADER object entered!") never returns; }
 429
 430 INFO_TABLE_CONSTR(stg_END_STM_WATCH_QUEUE,0,0,0,CONSTR_NOCAF_STATIC,"END_STM_WATCH_QUEUE","END_STM_WATCH_QUEUE")
 431 { foreign "C" barf("END_STM_WATCH_QUEUE object entered!") never returns; }
 432
 433 INFO_TABLE_CONSTR(stg_END_INVARIANT_CHECK_QUEUE,0,0,0,CONSTR_NOCAF_STATIC,"END_INVARIANT_CHECK_QUEUE","END_INVARIANT_CHECK_QUEUE")
 434 { foreign "C" barf("END_INVARIANT_CHECK_QUEUE object entered!") never returns; }
 435
 436 INFO_TABLE_CONSTR(stg_END_STM_CHUNK_LIST,0,0,0,CONSTR_NOCAF_STATIC,"END_STM_CHUNK_LIST","END_STM_CHUNK_LIST")
 437 { foreign "C" barf("END_STM_CHUNK_LIST object entered!") never returns; }
 438
 439 INFO_TABLE_CONSTR(stg_NO_TREC,0,0,0,CONSTR_NOCAF_STATIC,"NO_TREC","NO_TREC")
 440 { foreign "C" barf("NO_TREC object entered!") never returns; }
 441
 442 CLOSURE(stg_END_STM_WATCH_QUEUE_closure,stg_END_STM_WATCH_QUEUE);
 443
 444 CLOSURE(stg_END_INVARIANT_CHECK_QUEUE_closure,stg_END_INVARIANT_CHECK_QUEUE);
 445
 446 CLOSURE(stg_END_STM_CHUNK_LIST_closure,stg_END_STM_CHUNK_LIST);
 447
 448 CLOSURE(stg_NO_TREC_closure,stg_NO_TREC);
 449
 450 /* ----------------------------------------------------------------------------
 451    Messages
 452    ------------------------------------------------------------------------- */
 453
 454 // PRIM rather than CONSTR, because PRIM objects cannot be duplicated by the GC.
 455
 456 INFO_TABLE_CONSTR(stg_MSG_TRY_WAKEUP,2,0,0,PRIM,"MSG_TRY_WAKEUP","MSG_TRY_WAKEUP")
 457 { foreign "C" barf("MSG_TRY_WAKEUP object entered!") never returns; }
 458
 459 INFO_TABLE_CONSTR(stg_MSG_THROWTO,4,0,0,PRIM,"MSG_THROWTO","MSG_THROWTO")
 460 { foreign "C" barf("MSG_THROWTO object entered!") never returns; }
 461
 462 INFO_TABLE_CONSTR(stg_MSG_BLACKHOLE,3,0,0,PRIM,"MSG_BLACKHOLE","MSG_BLACKHOLE")
 463 { foreign "C" barf("MSG_BLACKHOLE object entered!") never returns; }
 464
 465 // used to overwrite a MSG_THROWTO when the message has been used/revoked
 466 INFO_TABLE_CONSTR(stg_MSG_NULL,1,0,0,PRIM,"MSG_NULL","MSG_NULL")
 467 { foreign "C" barf("MSG_NULL object entered!") never returns; }
 468
 469 /* ----------------------------------------------------------------------------
 470    END_TSO_QUEUE
 471
 472    This is a static nullary constructor (like []) that we use to mark the
 473    end of a linked TSO queue.
 474    ------------------------------------------------------------------------- */
 475
 476 INFO_TABLE_CONSTR(stg_END_TSO_QUEUE,0,0,0,CONSTR_NOCAF_STATIC,"END_TSO_QUEUE","END_TSO_QUEUE")
 477 { foreign "C" barf("END_TSO_QUEUE object entered!") never returns; }
 478
 479 CLOSURE(stg_END_TSO_QUEUE_closure,stg_END_TSO_QUEUE);
 480
 481 /* ----------------------------------------------------------------------------
 482    Arrays
 483
 484    These come in two basic flavours: arrays of data (StgArrWords) and arrays of
 485    pointers (StgArrPtrs).  They all have a similar layout:
 486
 487         ___________________________
 488         | Info | No. of | data....
 489         |  Ptr | Words  |
 490         ---------------------------
 491
 492    These are *unpointed* objects: i.e. they cannot be entered.
 493
 494    ------------------------------------------------------------------------- */
 495
 496 INFO_TABLE(stg_ARR_WORDS, 0, 0, ARR_WORDS, "ARR_WORDS", "ARR_WORDS")
 497 { foreign "C" barf("ARR_WORDS object entered!") never returns; }
 498
 499 INFO_TABLE(stg_MUT_ARR_PTRS_CLEAN, 0, 0, MUT_ARR_PTRS_CLEAN, "MUT_ARR_PTRS_CLEAN", "MUT_ARR_PTRS_CLEAN")
 500 { foreign "C" barf("MUT_ARR_PTRS_CLEAN object entered!") never returns; }
 501
 502 INFO_TABLE(stg_MUT_ARR_PTRS_DIRTY, 0, 0, MUT_ARR_PTRS_DIRTY, "MUT_ARR_PTRS_DIRTY", "MUT_ARR_PTRS_DIRTY")
 503 { foreign "C" barf("MUT_ARR_PTRS_DIRTY object entered!") never returns; }
 504
 505 INFO_TABLE(stg_MUT_ARR_PTRS_FROZEN, 0, 0, MUT_ARR_PTRS_FROZEN, "MUT_ARR_PTRS_FROZEN", "MUT_ARR_PTRS_FROZEN")
 506 { foreign "C" barf("MUT_ARR_PTRS_FROZEN object entered!") never returns; }
 507
 508 INFO_TABLE(stg_MUT_ARR_PTRS_FROZEN0, 0, 0, MUT_ARR_PTRS_FROZEN0, "MUT_ARR_PTRS_FROZEN0", "MUT_ARR_PTRS_FROZEN0")
 509 { foreign "C" barf("MUT_ARR_PTRS_FROZEN0 object entered!") never returns; }
 510
 511 /* ----------------------------------------------------------------------------
 512    Mutable Variables
 513    ------------------------------------------------------------------------- */
 514
 515 INFO_TABLE(stg_MUT_VAR_CLEAN, 1, 0, MUT_VAR_CLEAN, "MUT_VAR_CLEAN", "MUT_VAR_CLEAN")
 516 { foreign "C" barf("MUT_VAR_CLEAN object entered!") never returns; }
 517 INFO_TABLE(stg_MUT_VAR_DIRTY, 1, 0, MUT_VAR_DIRTY, "MUT_VAR_DIRTY", "MUT_VAR_DIRTY")
 518 { foreign "C" barf("MUT_VAR_DIRTY object entered!") never returns; }
 519
 520 /* ----------------------------------------------------------------------------
 521    Dummy return closure
 522
 523    Entering this closure will just return to the address on the top of the
 524    stack.  Useful for getting a thread in a canonical form where we can
 525    just enter the top stack word to start the thread.  (see deleteThread)
 526  * ------------------------------------------------------------------------- */
 527
 528 INFO_TABLE( stg_dummy_ret, 0, 0, CONSTR_NOCAF_STATIC, "DUMMY_RET", "DUMMY_RET")
 529 {
 530   jump %ENTRY_CODE(Sp(0));
 531 }
 532 CLOSURE(stg_dummy_ret_closure,stg_dummy_ret);
 533
 534 /* ----------------------------------------------------------------------------
 535    MVAR_TSO_QUEUE
 536    ------------------------------------------------------------------------- */
 537
 538 INFO_TABLE_CONSTR(stg_MVAR_TSO_QUEUE,2,0,0,PRIM,"MVAR_TSO_QUEUE","MVAR_TSO_QUEUE")
 539 { foreign "C" barf("MVAR_TSO_QUEUE object entered!") never returns; }
 540
 541 /* ----------------------------------------------------------------------------
 542    CHARLIKE and INTLIKE closures.
 543
 544    These are static representations of Chars and small Ints, so that
 545    we can remove dynamic Chars and Ints during garbage collection and
 546    replace them with references to the static objects.
 547    ------------------------------------------------------------------------- */
 548
 549 #if defined(__PIC__) && defined(mingw32_HOST_OS)
 550 /*
 551  * When sticking the RTS in a Windows DLL, we delay populating the
 552  * Charlike and Intlike tables until load-time, which is only
 553  * when we've got the real addresses to the C# and I# closures.
 554  *
 555  *      -- this is currently broken BL 2009/11/14.
 556  *         we don't rewrite to static closures at all with Windows DLLs.
 557  */
 558 // #warning Is this correct? _imp is a pointer!
 559 #define Char_hash_static_info _imp__ghczmprim_GHCziTypes_Czh_static_info
 560 #define Int_hash_static_info _imp__ghczmprim_GHCziTypes_Izh_static_info
 561 #else
 562 #define Char_hash_static_info ghczmprim_GHCziTypes_Czh_static_info
 563 #define Int_hash_static_info ghczmprim_GHCziTypes_Izh_static_info
 564 #endif
 565
 566
 567 #define CHARLIKE_HDR(n)  CLOSURE(Char_hash_static_info, n)
 568 #define INTLIKE_HDR(n)   CLOSURE(Int_hash_static_info, n)
 569
 570 /* put these in the *data* section, since the garbage collector relies
 571  * on the fact that static closures live in the data section.
 572  */
 573
 574 /* end the name with _closure, to convince the mangler this is a closure */
 575
 576 #if !(defined(__PIC__) && defined(mingw32_HOST_OS))
 577 section "data" {
 578  stg_CHARLIKE_closure:
 579     CHARLIKE_HDR(0)
 580     CHARLIKE_HDR(1)
 581     CHARLIKE_HDR(2)
 582     CHARLIKE_HDR(3)
 583     CHARLIKE_HDR(4)
 584     CHARLIKE_HDR(5)
 585     CHARLIKE_HDR(6)
 586     CHARLIKE_HDR(7)
 587     CHARLIKE_HDR(8)
 588     CHARLIKE_HDR(9)
 589     CHARLIKE_HDR(10)
 590     CHARLIKE_HDR(11)
 591     CHARLIKE_HDR(12)
 592     CHARLIKE_HDR(13)
 593     CHARLIKE_HDR(14)
 594     CHARLIKE_HDR(15)
 595     CHARLIKE_HDR(16)
 596     CHARLIKE_HDR(17)
 597     CHARLIKE_HDR(18)
 598     CHARLIKE_HDR(19)
 599     CHARLIKE_HDR(20)
 600     CHARLIKE_HDR(21)
 601     CHARLIKE_HDR(22)
 602     CHARLIKE_HDR(23)
 603     CHARLIKE_HDR(24)
 604     CHARLIKE_HDR(25)
 605     CHARLIKE_HDR(26)
 606     CHARLIKE_HDR(27)
 607     CHARLIKE_HDR(28)
 608     CHARLIKE_HDR(29)
 609     CHARLIKE_HDR(30)
 610     CHARLIKE_HDR(31)
 611     CHARLIKE_HDR(32)
 612     CHARLIKE_HDR(33)
 613     CHARLIKE_HDR(34)
 614     CHARLIKE_HDR(35)
 615     CHARLIKE_HDR(36)
 616     CHARLIKE_HDR(37)
 617     CHARLIKE_HDR(38)
 618     CHARLIKE_HDR(39)
 619     CHARLIKE_HDR(40)
 620     CHARLIKE_HDR(41)
 621     CHARLIKE_HDR(42)
 622     CHARLIKE_HDR(43)
 623     CHARLIKE_HDR(44)
 624     CHARLIKE_HDR(45)
 625     CHARLIKE_HDR(46)
 626     CHARLIKE_HDR(47)
 627     CHARLIKE_HDR(48)
 628     CHARLIKE_HDR(49)
 629     CHARLIKE_HDR(50)
 630     CHARLIKE_HDR(51)
 631     CHARLIKE_HDR(52)
 632     CHARLIKE_HDR(53)
 633     CHARLIKE_HDR(54)
 634     CHARLIKE_HDR(55)
 635     CHARLIKE_HDR(56)
 636     CHARLIKE_HDR(57)
 637     CHARLIKE_HDR(58)
 638     CHARLIKE_HDR(59)
 639     CHARLIKE_HDR(60)
 640     CHARLIKE_HDR(61)
 641     CHARLIKE_HDR(62)
 642     CHARLIKE_HDR(63)
 643     CHARLIKE_HDR(64)
 644     CHARLIKE_HDR(65)
 645     CHARLIKE_HDR(66)
 646     CHARLIKE_HDR(67)
 647     CHARLIKE_HDR(68)
 648     CHARLIKE_HDR(69)
 649     CHARLIKE_HDR(70)
 650     CHARLIKE_HDR(71)
 651     CHARLIKE_HDR(72)
 652     CHARLIKE_HDR(73)
 653     CHARLIKE_HDR(74)
 654     CHARLIKE_HDR(75)
 655     CHARLIKE_HDR(76)
 656     CHARLIKE_HDR(77)
 657     CHARLIKE_HDR(78)
 658     CHARLIKE_HDR(79)
 659     CHARLIKE_HDR(80)
 660     CHARLIKE_HDR(81)
 661     CHARLIKE_HDR(82)
 662     CHARLIKE_HDR(83)
 663     CHARLIKE_HDR(84)
 664     CHARLIKE_HDR(85)
 665     CHARLIKE_HDR(86)
 666     CHARLIKE_HDR(87)
 667     CHARLIKE_HDR(88)
 668     CHARLIKE_HDR(89)
 669     CHARLIKE_HDR(90)
 670     CHARLIKE_HDR(91)
 671     CHARLIKE_HDR(92)
 672     CHARLIKE_HDR(93)
 673     CHARLIKE_HDR(94)
 674     CHARLIKE_HDR(95)
 675     CHARLIKE_HDR(96)
 676     CHARLIKE_HDR(97)
 677     CHARLIKE_HDR(98)
 678     CHARLIKE_HDR(99)
 679     CHARLIKE_HDR(100)
 680     CHARLIKE_HDR(101)
 681     CHARLIKE_HDR(102)
 682     CHARLIKE_HDR(103)
 683     CHARLIKE_HDR(104)
 684     CHARLIKE_HDR(105)
 685     CHARLIKE_HDR(106)
 686     CHARLIKE_HDR(107)
 687     CHARLIKE_HDR(108)
 688     CHARLIKE_HDR(109)
 689     CHARLIKE_HDR(110)
 690     CHARLIKE_HDR(111)
 691     CHARLIKE_HDR(112)
 692     CHARLIKE_HDR(113)
 693     CHARLIKE_HDR(114)
 694     CHARLIKE_HDR(115)
 695     CHARLIKE_HDR(116)
 696     CHARLIKE_HDR(117)
 697     CHARLIKE_HDR(118)
 698     CHARLIKE_HDR(119)
 699     CHARLIKE_HDR(120)
 700     CHARLIKE_HDR(121)
 701     CHARLIKE_HDR(122)
 702     CHARLIKE_HDR(123)
 703     CHARLIKE_HDR(124)
 704     CHARLIKE_HDR(125)
 705     CHARLIKE_HDR(126)
 706     CHARLIKE_HDR(127)
 707     CHARLIKE_HDR(128)
 708     CHARLIKE_HDR(129)
 709     CHARLIKE_HDR(130)
 710     CHARLIKE_HDR(131)
 711     CHARLIKE_HDR(132)
 712     CHARLIKE_HDR(133)
 713     CHARLIKE_HDR(134)
 714     CHARLIKE_HDR(135)
 715     CHARLIKE_HDR(136)
 716     CHARLIKE_HDR(137)
 717     CHARLIKE_HDR(138)
 718     CHARLIKE_HDR(139)
 719     CHARLIKE_HDR(140)
 720     CHARLIKE_HDR(141)
 721     CHARLIKE_HDR(142)
 722     CHARLIKE_HDR(143)
 723     CHARLIKE_HDR(144)
 724     CHARLIKE_HDR(145)
 725     CHARLIKE_HDR(146)
 726     CHARLIKE_HDR(147)
 727     CHARLIKE_HDR(148)
 728     CHARLIKE_HDR(149)
 729     CHARLIKE_HDR(150)
 730     CHARLIKE_HDR(151)
 731     CHARLIKE_HDR(152)
 732     CHARLIKE_HDR(153)
 733     CHARLIKE_HDR(154)
 734     CHARLIKE_HDR(155)
 735     CHARLIKE_HDR(156)
 736     CHARLIKE_HDR(157)
 737     CHARLIKE_HDR(158)
 738     CHARLIKE_HDR(159)
 739     CHARLIKE_HDR(160)
 740     CHARLIKE_HDR(161)
 741     CHARLIKE_HDR(162)
 742     CHARLIKE_HDR(163)
 743     CHARLIKE_HDR(164)
 744     CHARLIKE_HDR(165)
 745     CHARLIKE_HDR(166)
 746     CHARLIKE_HDR(167)
 747     CHARLIKE_HDR(168)
 748     CHARLIKE_HDR(169)
 749     CHARLIKE_HDR(170)
 750     CHARLIKE_HDR(171)
 751     CHARLIKE_HDR(172)
 752     CHARLIKE_HDR(173)
 753     CHARLIKE_HDR(174)
 754     CHARLIKE_HDR(175)
 755     CHARLIKE_HDR(176)
 756     CHARLIKE_HDR(177)
 757     CHARLIKE_HDR(178)
 758     CHARLIKE_HDR(179)
 759     CHARLIKE_HDR(180)
 760     CHARLIKE_HDR(181)
 761     CHARLIKE_HDR(182)
 762     CHARLIKE_HDR(183)
 763     CHARLIKE_HDR(184)
 764     CHARLIKE_HDR(185)
 765     CHARLIKE_HDR(186)
 766     CHARLIKE_HDR(187)
 767     CHARLIKE_HDR(188)
 768     CHARLIKE_HDR(189)
 769     CHARLIKE_HDR(190)
 770     CHARLIKE_HDR(191)
 771     CHARLIKE_HDR(192)
 772     CHARLIKE_HDR(193)
 773     CHARLIKE_HDR(194)
 774     CHARLIKE_HDR(195)
 775     CHARLIKE_HDR(196)
 776     CHARLIKE_HDR(197)
 777     CHARLIKE_HDR(198)
 778     CHARLIKE_HDR(199)
 779     CHARLIKE_HDR(200)
 780     CHARLIKE_HDR(201)
 781     CHARLIKE_HDR(202)
 782     CHARLIKE_HDR(203)
 783     CHARLIKE_HDR(204)
 784     CHARLIKE_HDR(205)
 785     CHARLIKE_HDR(206)
 786     CHARLIKE_HDR(207)
 787     CHARLIKE_HDR(208)
 788     CHARLIKE_HDR(209)
 789     CHARLIKE_HDR(210)
 790     CHARLIKE_HDR(211)
 791     CHARLIKE_HDR(212)
 792     CHARLIKE_HDR(213)
 793     CHARLIKE_HDR(214)
 794     CHARLIKE_HDR(215)
 795     CHARLIKE_HDR(216)
 796     CHARLIKE_HDR(217)
 797     CHARLIKE_HDR(218)
 798     CHARLIKE_HDR(219)
 799     CHARLIKE_HDR(220)
 800     CHARLIKE_HDR(221)
 801     CHARLIKE_HDR(222)
 802     CHARLIKE_HDR(223)
 803     CHARLIKE_HDR(224)
 804     CHARLIKE_HDR(225)
 805     CHARLIKE_HDR(226)
 806     CHARLIKE_HDR(227)
 807     CHARLIKE_HDR(228)
 808     CHARLIKE_HDR(229)
 809     CHARLIKE_HDR(230)
 810     CHARLIKE_HDR(231)
 811     CHARLIKE_HDR(232)
 812     CHARLIKE_HDR(233)
 813     CHARLIKE_HDR(234)
 814     CHARLIKE_HDR(235)
 815     CHARLIKE_HDR(236)
 816     CHARLIKE_HDR(237)
 817     CHARLIKE_HDR(238)
 818     CHARLIKE_HDR(239)
 819     CHARLIKE_HDR(240)
 820     CHARLIKE_HDR(241)
 821     CHARLIKE_HDR(242)
 822     CHARLIKE_HDR(243)
 823     CHARLIKE_HDR(244)
 824     CHARLIKE_HDR(245)
 825     CHARLIKE_HDR(246)
 826     CHARLIKE_HDR(247)
 827     CHARLIKE_HDR(248)
 828     CHARLIKE_HDR(249)
 829     CHARLIKE_HDR(250)
 830     CHARLIKE_HDR(251)
 831     CHARLIKE_HDR(252)
 832     CHARLIKE_HDR(253)
 833     CHARLIKE_HDR(254)
 834     CHARLIKE_HDR(255)
 835 }
 836
 837 section "data" {
 838  stg_INTLIKE_closure:
 839     INTLIKE_HDR(-16)    /* MIN_INTLIKE == -16 */
 840     INTLIKE_HDR(-15)
 841     INTLIKE_HDR(-14)
 842     INTLIKE_HDR(-13)
 843     INTLIKE_HDR(-12)
 844     INTLIKE_HDR(-11)
 845     INTLIKE_HDR(-10)
 846     INTLIKE_HDR(-9)
 847     INTLIKE_HDR(-8)
 848     INTLIKE_HDR(-7)
 849     INTLIKE_HDR(-6)
 850     INTLIKE_HDR(-5)
 851     INTLIKE_HDR(-4)
 852     INTLIKE_HDR(-3)
 853     INTLIKE_HDR(-2)
 854     INTLIKE_HDR(-1)
 855     INTLIKE_HDR(0)
 856     INTLIKE_HDR(1)
 857     INTLIKE_HDR(2)
 858     INTLIKE_HDR(3)
 859     INTLIKE_HDR(4)
 860     INTLIKE_HDR(5)
 861     INTLIKE_HDR(6)
 862     INTLIKE_HDR(7)
 863     INTLIKE_HDR(8)
 864     INTLIKE_HDR(9)
 865     INTLIKE_HDR(10)
 866     INTLIKE_HDR(11)
 867     INTLIKE_HDR(12)
 868     INTLIKE_HDR(13)
 869     INTLIKE_HDR(14)
 870     INTLIKE_HDR(15)
 871     INTLIKE_HDR(16)     /* MAX_INTLIKE == 16 */
 872 }
 873
 874 #endif // !(defined(__PIC__) && defined(mingw32_HOST_OS))