ghc/rts/StgMiscClosures.hc

   1 /* -----------------------------------------------------------------------------
   2  * $Id: StgMiscClosures.hc,v 1.57 2001/01/10 17:21:18 sewardj Exp $
   3  *
   4  * (c) The GHC Team, 1998-2000
   5  *
   6  * Entry code for various built-in closure types.
   7  *
   8  * ---------------------------------------------------------------------------*/
   9
  10 #include "Rts.h"
  11 #include "RtsUtils.h"
  12 #include "RtsFlags.h"
  13 #include "StgMiscClosures.h"
  14 #include "HeapStackCheck.h"   /* for stg_gen_yield */
  15 #include "Storage.h"
  16 #include "StoragePriv.h"
  17 #include "Profiling.h"
  18 #include "Prelude.h"
  19 #include "Schedule.h"
  20 #include "SMP.h"
  21 #if defined(GRAN) || defined(PAR)
  22 # include "GranSimRts.h"      /* for DumpRawGranEvent */
  23 # include "StgRun.h"    /* for StgReturn and register saving */
  24 #endif
  25
  26 #ifdef HAVE_STDIO_H
  27 #include <stdio.h>
  28 #endif
  29
  30 /* ToDo: make the printing of panics more win32-friendly, i.e.,
  31  *       pop up some lovely message boxes (as well).
  32  */
  33 #define DUMP_ERRMSG(msg) STGCALL2(fprintf,stderr,msg)
  34
  35 /*
  36   Template for the entry code of non-enterable closures.
  37 */
  38
  39 #define NON_ENTERABLE_ENTRY_CODE(type)                                  \
  40 STGFUN(stg_##type##_entry)                                                      \
  41 {                                                                       \
  42   FB_                                                                   \
  43     DUMP_ERRMSG(#type " object entered!\n");                            \
  44     STGCALL1(shutdownHaskellAndExit, EXIT_FAILURE);                     \
  45     return NULL;                                                        \
  46   FE_                                                                   \
  47 }
  48
  49
  50 /* -----------------------------------------------------------------------------
  51    Support for the bytecode interpreter.
  52    -------------------------------------------------------------------------- */
  53
  54 #ifdef GHCI
  55
  56 /* 9 bits of return code for constructors created by the interpreter. */
  57 FN_(stg_interp_constr_entry)
  58 {
  59   /* R1 points at the constructor */
  60   FB_
  61     STGCALL2(fprintf,stderr,"stg_interp_constr_entry (direct return)!\n");
  62     /* Pointless, since SET_TAG doesn't do anything */
  63     SET_TAG( GET_TAG(GET_INFO(R1.cl)));
  64     JMP_(ENTRY_CODE((P_)(*Sp)));
  65   FE_
  66 }
  67
  68 FN_(stg_interp_constr1_entry) { FB_ JMP_(RET_VEC((P_)(*Sp),0)); FE_ }
  69 FN_(stg_interp_constr2_entry) { FB_ JMP_(RET_VEC((P_)(*Sp),1)); FE_ }
  70 FN_(stg_interp_constr3_entry) { FB_ JMP_(RET_VEC((P_)(*Sp),2)); FE_ }
  71 FN_(stg_interp_constr4_entry) { FB_ JMP_(RET_VEC((P_)(*Sp),3)); FE_ }
  72 FN_(stg_interp_constr5_entry) { FB_ JMP_(RET_VEC((P_)(*Sp),4)); FE_ }
  73 FN_(stg_interp_constr6_entry) { FB_ JMP_(RET_VEC((P_)(*Sp),5)); FE_ }
  74 FN_(stg_interp_constr7_entry) { FB_ JMP_(RET_VEC((P_)(*Sp),6)); FE_ }
  75 FN_(stg_interp_constr8_entry) { FB_ JMP_(RET_VEC((P_)(*Sp),7)); FE_ }
  76
  77 /* Some info tables to be used when compiled code returns a value to
  78    the interpreter, i.e. the interpreter pushes one of these onto the
  79    stack before entering a value.  What the code does is to
  80    impedance-match the compiled return convention (in R1/F1/D1 etc) to
  81    the interpreter's convention (returned value is on top of stack),
  82    and then cause the scheduler to enter the interpreter.
  83
  84    On entry, the stack (growing down) looks like this:
  85
  86       ptr to BCO holding return continuation
  87       ptr to one of these info tables.
  88
  89    The info table code, both direct and vectored, must:
  90       * push R1/F1/D1 on the stack
  91       * push the BCO (so it's now on the stack twice)
  92       * Yield, ie, go to the scheduler.
  93
  94    Scheduler examines the t.o.s, discovers it is a BCO, and proceeds
  95    directly to the bytecode interpreter.  That pops the top element
  96    (the BCO, containing the return continuation), and interprets it.
  97    Net result: return continuation gets interpreted, with the
  98    following stack:
  99
 100       ptr to this BCO
 101       ptr to the info table just jumped thru
 102       return value
 103
 104    which is just what we want -- the "standard" return layout for the
 105    interpreter.  Hurrah!
 106
 107    Don't ask me how unboxed tuple returns are supposed to work.  We
 108    haven't got a good story about that yet.
 109 */
 110
 111 /* When the returned value is in R1 ... */
 112 #define STG_CtoI_RET_R1_Template(label)         \
 113    IFN_(label)                          \
 114    {                                    \
 115       StgPtr bco;                       \
 116       FB_                               \
 117       bco = ((StgPtr*)Sp)[1];           \
 118       Sp -= 1;                          \
 119       ((StgPtr*)Sp)[0] = R1.p;          \
 120       Sp -= 1;                          \
 121       ((StgPtr*)Sp)[0] = bco;           \
 122       JMP_(stg_yield_to_interpreter);   \
 123       FE_                               \
 124    }
 125
 126 STG_CtoI_RET_R1_Template(stg_ctoi_ret_R1_entry);
 127 STG_CtoI_RET_R1_Template(stg_ctoi_ret_R1_0_entry);
 128 STG_CtoI_RET_R1_Template(stg_ctoi_ret_R1_1_entry);
 129 STG_CtoI_RET_R1_Template(stg_ctoi_ret_R1_2_entry);
 130 STG_CtoI_RET_R1_Template(stg_ctoi_ret_R1_3_entry);
 131 STG_CtoI_RET_R1_Template(stg_ctoi_ret_R1_4_entry);
 132 STG_CtoI_RET_R1_Template(stg_ctoi_ret_R1_5_entry);
 133 STG_CtoI_RET_R1_Template(stg_ctoi_ret_R1_6_entry);
 134 STG_CtoI_RET_R1_Template(stg_ctoi_ret_R1_7_entry);
 135
 136 VEC_POLY_INFO_TABLE(stg_ctoi_ret_R1,0, NULL/*srt*/, 0/*srt_off*/, 0/*srt_len*/, RET_BCO,, EF_);
 137
 138 /* When the returned value is in F1 ... */
 139 #define STG_CtoI_RET_F1_Template(label)         \
 140    IFN_(label)                          \
 141    {                                    \
 142       StgPtr bco;                       \
 143       FB_                               \
 144       bco = ((StgPtr*)Sp)[1];           \
 145       Sp -= sizeofW(StgFloat);          \
 146       ASSIGN_FLT((W_*)Sp, F1);          \
 147       Sp -= 1;                          \
 148       ((StgPtr*)Sp)[0] = bco;           \
 149       JMP_(stg_yield_to_interpreter);   \
 150       FE_                               \
 151    }
 152
 153 STG_CtoI_RET_F1_Template(stg_ctoi_ret_F1_entry);
 154 STG_CtoI_RET_F1_Template(stg_ctoi_ret_F1_0_entry);
 155 STG_CtoI_RET_F1_Template(stg_ctoi_ret_F1_1_entry);
 156 STG_CtoI_RET_F1_Template(stg_ctoi_ret_F1_2_entry);
 157 STG_CtoI_RET_F1_Template(stg_ctoi_ret_F1_3_entry);
 158 STG_CtoI_RET_F1_Template(stg_ctoi_ret_F1_4_entry);
 159 STG_CtoI_RET_F1_Template(stg_ctoi_ret_F1_5_entry);
 160 STG_CtoI_RET_F1_Template(stg_ctoi_ret_F1_6_entry);
 161 STG_CtoI_RET_F1_Template(stg_ctoi_ret_F1_7_entry);
 162
 163 VEC_POLY_INFO_TABLE(stg_ctoi_ret_F1,0, NULL/*srt*/, 0/*srt_off*/, 0/*srt_len*/, RET_BCO,, EF_);
 164
 165
 166 /* When the returned value is in D1 ... */
 167 #define STG_CtoI_RET_D1_Template(label)         \
 168    IFN_(label)                          \
 169    {                                    \
 170       StgPtr bco;                       \
 171       FB_                               \
 172       bco = ((StgPtr*)Sp)[1];           \
 173       Sp -= sizeofW(StgDouble);         \
 174       ASSIGN_DBL((W_*)Sp, D1);          \
 175       Sp -= 1;                          \
 176       ((StgPtr*)Sp)[0] = bco;           \
 177       JMP_(stg_yield_to_interpreter);   \
 178       FE_                               \
 179    }
 180
 181 STG_CtoI_RET_D1_Template(stg_ctoi_ret_D1_entry);
 182 STG_CtoI_RET_D1_Template(stg_ctoi_ret_D1_0_entry);
 183 STG_CtoI_RET_D1_Template(stg_ctoi_ret_D1_1_entry);
 184 STG_CtoI_RET_D1_Template(stg_ctoi_ret_D1_2_entry);
 185 STG_CtoI_RET_D1_Template(stg_ctoi_ret_D1_3_entry);
 186 STG_CtoI_RET_D1_Template(stg_ctoi_ret_D1_4_entry);
 187 STG_CtoI_RET_D1_Template(stg_ctoi_ret_D1_5_entry);
 188 STG_CtoI_RET_D1_Template(stg_ctoi_ret_D1_6_entry);
 189 STG_CtoI_RET_D1_Template(stg_ctoi_ret_D1_7_entry);
 190
 191 VEC_POLY_INFO_TABLE(stg_ctoi_ret_D1,0, NULL/*srt*/, 0/*srt_off*/, 0/*srt_len*/, RET_BCO,, EF_);
 192
 193
 194 /* The other way round: when the interpreter returns a value to
 195    compiled code.  The stack looks like this:
 196
 197       return info table (pushed by compiled code)
 198       return value (pushed by interpreter)
 199
 200    If the value is ptr-rep'd, the interpreter simply returns to the
 201    scheduler, instructing it to ThreadEnterGHC.
 202
 203    Otherwise (unboxed return value), we replace the top stack word,
 204    which must be the tag, with stg_gc_unbx_r1_info (or f1_info or d1_info),
 205    and return to the scheduler, instructing it to ThreadRunGHC.
 206
 207    No supporting code needed!
 208 */
 209
 210
 211 /* Entering a BCO.  Heave it on the stack and defer to the
 212    scheduler. */
 213 INFO_TABLE(stg_BCO_info,stg_BCO_entry,4,0,BCO,,EF_,"BCO","BCO");
 214 STGFUN(stg_BCO_entry) {
 215   FB_
 216     Sp -= 1;
 217     Sp[0] = R1.w;
 218     JMP_(stg_yield_to_interpreter);
 219   FE_
 220 }
 221
 222 #endif /* GHCI */
 223
 224
 225 /* -----------------------------------------------------------------------------
 226    Entry code for an indirection.
 227    -------------------------------------------------------------------------- */
 228
 229 INFO_TABLE(stg_IND_info,stg_IND_entry,1,0,IND,,EF_,0,0);
 230 STGFUN(stg_IND_entry)
 231 {
 232     FB_
 233     TICK_ENT_IND(Node); /* tick */
 234
 235     R1.p = (P_) ((StgInd*)R1.p)->indirectee;
 236     TICK_ENT_VIA_NODE();
 237     JMP_(ENTRY_CODE(*R1.p));
 238     FE_
 239 }
 240
 241 INFO_TABLE(stg_IND_STATIC_info,stg_IND_STATIC_entry,1,0,IND_STATIC,,EF_,0,0);
 242 STGFUN(stg_IND_STATIC_entry)
 243 {
 244     FB_
 245     TICK_ENT_IND(Node); /* tick */
 246     R1.p = (P_) ((StgIndStatic*)R1.p)->indirectee;
 247     TICK_ENT_VIA_NODE();
 248     JMP_(ENTRY_CODE(*R1.p));
 249     FE_
 250 }
 251
 252 INFO_TABLE(stg_IND_PERM_info,stg_IND_PERM_entry,1,1,IND_PERM,,EF_,"IND_PERM","IND_PERM");
 253 STGFUN(stg_IND_PERM_entry)
 254 {
 255     FB_
 256     /* Don't add INDs to granularity cost */
 257     /* Dont: TICK_ENT_IND(Node); for ticky-ticky; this ind is here only to help profiling */
 258
 259 #if defined(TICKY_TICKY) && !defined(PROFILING)
 260     /* TICKY_TICKY && !PROFILING means PERM_IND *replaces* an IND, rather than being extra  */
 261     TICK_ENT_PERM_IND(R1.p); /* tick */
 262 #endif
 263
 264     /* Enter PAP cost centre -- lexical scoping only */
 265     ENTER_CCS_PAP_CL(R1.cl);
 266
 267     /* For ticky-ticky, change the perm_ind to a normal ind on first
 268      * entry, so the number of ent_perm_inds is the number of *thunks*
 269      * entered again, not the number of subsequent entries.
 270      *
 271      * Since this screws up cost centres, we die if profiling and
 272      * ticky_ticky are on at the same time.  KSW 1999-01.
 273      */
 274
 275 #ifdef TICKY_TICKY
 276 #  ifdef PROFILING
 277 #    error Profiling and ticky-ticky do not mix at present!
 278 #  endif  /* PROFILING */
 279     SET_INFO((StgInd*)R1.p,&IND_info);
 280 #endif /* TICKY_TICKY */
 281
 282     R1.p = (P_) ((StgInd*)R1.p)->indirectee;
 283
 284     /* Dont: TICK_ENT_VIA_NODE(); for ticky-ticky; as above */
 285
 286 #if defined(TICKY_TICKY) && !defined(PROFILING)
 287     TICK_ENT_VIA_NODE();
 288 #endif
 289
 290     JMP_(ENTRY_CODE(*R1.p));
 291     FE_
 292 }
 293
 294 INFO_TABLE(stg_IND_OLDGEN_info,stg_IND_OLDGEN_entry,1,1,IND_OLDGEN,,EF_,0,0);
 295 STGFUN(stg_IND_OLDGEN_entry)
 296 {
 297     FB_
 298     TICK_ENT_IND(Node); /* tick */
 299
 300     R1.p = (P_) ((StgInd*)R1.p)->indirectee;
 301     TICK_ENT_VIA_NODE();
 302     JMP_(ENTRY_CODE(*R1.p));
 303     FE_
 304 }
 305
 306 INFO_TABLE(stg_IND_OLDGEN_PERM_info,stg_IND_OLDGEN_PERM_entry,1,1,IND_OLDGEN_PERM,,EF_,0,0);
 307 STGFUN(stg_IND_OLDGEN_PERM_entry)
 308 {
 309     FB_
 310     /* Dont: TICK_ENT_IND(Node); for ticky-ticky; this ind is here only to help profiling */
 311
 312 #if defined(TICKY_TICKY) && !defined(PROFILING)
 313     /* TICKY_TICKY && !PROFILING means PERM_IND *replaces* an IND, rather than being extra  */
 314     TICK_ENT_PERM_IND(R1.p); /* tick */
 315 #endif
 316
 317     /* Enter PAP cost centre -- lexical scoping only */
 318     ENTER_CCS_PAP_CL(R1.cl);
 319
 320     /* see comment in IND_PERM */
 321 #ifdef TICKY_TICKY
 322 #  ifdef PROFILING
 323 #    error Profiling and ticky-ticky do not mix at present!
 324 #  endif  /* PROFILING */
 325     SET_INFO((StgInd*)R1.p,&IND_OLDGEN_info);
 326 #endif /* TICKY_TICKY */
 327
 328     R1.p = (P_) ((StgInd*)R1.p)->indirectee;
 329     TICK_ENT_VIA_NODE();
 330     JMP_(ENTRY_CODE(*R1.p));
 331     FE_
 332 }
 333
 334 /* -----------------------------------------------------------------------------
 335    Entry code for CAFs
 336
 337    This code assumes R1 is in a register for now.
 338    -------------------------------------------------------------------------- */
 339
 340 INFO_TABLE(stg_CAF_UNENTERED_info,stg_CAF_UNENTERED_entry,1,3,CAF_UNENTERED,,EF_,0,0);
 341 STGFUN(stg_CAF_UNENTERED_entry)
 342 {
 343     FB_
 344     /* ToDo: implement directly in GHC */
 345     Sp -= 1;
 346     Sp[0] = R1.w;
 347     JMP_(stg_yield_to_interpreter);
 348     FE_
 349 }
 350
 351 /* 0,4 is entirely bogus; _do not_ rely on this info */
 352 INFO_TABLE(stg_CAF_ENTERED_info,stg_CAF_ENTERED_entry,0,4,CAF_ENTERED,,EF_,0,0);
 353 STGFUN(stg_CAF_ENTERED_entry)
 354 {
 355     FB_
 356     R1.p = (P_) ((StgCAF*)R1.p)->value; /* just a fancy indirection */
 357     TICK_ENT_VIA_NODE();
 358     JMP_(GET_ENTRY(R1.cl));
 359     FE_
 360 }
 361
 362 /* -----------------------------------------------------------------------------
 363    Entry code for a black hole.
 364
 365    Entering a black hole normally causes a cyclic data dependency, but
 366    in the concurrent world, black holes are synchronization points,
 367    and they are turned into blocking queues when there are threads
 368    waiting for the evaluation of the closure to finish.
 369    -------------------------------------------------------------------------- */
 370
 371 /* Note: a BLACKHOLE and BLACKHOLE_BQ must be big enough to be
 372  * overwritten with an indirection/evacuee/catch.  Thus we claim it
 373  * has 1 non-pointer word of payload (in addition to the pointer word
 374  * for the blocking queue in a BQ), which should be big enough for an
 375  * old-generation indirection.
 376  */
 377
 378 INFO_TABLE(stg_BLACKHOLE_info, stg_BLACKHOLE_entry,0,2,BLACKHOLE,,EF_,"BLACKHOLE","BLACKHOLE");
 379 STGFUN(stg_BLACKHOLE_entry)
 380 {
 381   FB_
 382 #if defined(GRAN)
 383     /* Before overwriting TSO_LINK */
 384     STGCALL3(GranSimBlock,CurrentTSO,CurrentProc,(StgClosure *)R1.p /*Node*/);
 385 #endif
 386
 387 #ifdef SMP
 388     {
 389       bdescr *bd = Bdescr(R1.p);
 390       if (bd->back != (bdescr *)BaseReg) {
 391         if (bd->gen->no >= 1 || bd->step->no >= 1) {
 392           CMPXCHG(R1.cl->header.info, &BLACKHOLE_info, &WHITEHOLE_info);
 393         } else {
 394           EXTFUN_RTS(stg_gc_enter_1_hponly);
 395           JMP_(stg_gc_enter_1_hponly);
 396         }
 397       }
 398     }
 399 #endif
 400     TICK_ENT_BH();
 401
 402     /* Put ourselves on the blocking queue for this black hole */
 403 #if defined(GRAN) || defined(PAR)
 404     /* in fact, only difference is the type of the end-of-queue marker! */
 405     CurrentTSO->link = END_BQ_QUEUE;
 406     ((StgBlockingQueue *)R1.p)->blocking_queue = (StgBlockingQueueElement *)CurrentTSO;
 407 #else
 408     CurrentTSO->link = END_TSO_QUEUE;
 409     ((StgBlockingQueue *)R1.p)->blocking_queue = CurrentTSO;
 410 #endif
 411     /* jot down why and on what closure we are blocked */
 412     CurrentTSO->why_blocked = BlockedOnBlackHole;
 413     CurrentTSO->block_info.closure = R1.cl;
 414     /* closure is mutable since something has just been added to its BQ */
 415     recordMutable((StgMutClosure *)R1.cl);
 416     /* Change the BLACKHOLE into a BLACKHOLE_BQ */
 417     ((StgBlockingQueue *)R1.p)->header.info = &stg_BLACKHOLE_BQ_info;
 418
 419     /* PAR: dumping of event now done in blockThread -- HWL */
 420
 421     /* stg_gen_block is too heavyweight, use a specialised one */
 422     BLOCK_NP(1);
 423
 424   FE_
 425 }
 426
 427 INFO_TABLE(stg_BLACKHOLE_BQ_info, stg_BLACKHOLE_BQ_entry,1,1,BLACKHOLE_BQ,,EF_,"BLACKHOLE","BLACKHOLE");
 428 STGFUN(stg_BLACKHOLE_BQ_entry)
 429 {
 430   FB_
 431 #if defined(GRAN)
 432     /* Before overwriting TSO_LINK */
 433     STGCALL3(GranSimBlock,CurrentTSO,CurrentProc,(StgClosure *)R1.p /*Node*/);
 434 #endif
 435
 436 #ifdef SMP
 437     {
 438       bdescr *bd = Bdescr(R1.p);
 439       if (bd->back != (bdescr *)BaseReg) {
 440         if (bd->gen->no >= 1 || bd->step->no >= 1) {
 441           CMPXCHG(R1.cl->header.info, &BLACKHOLE_info, &WHITEHOLE_info);
 442         } else {
 443           EXTFUN_RTS(stg_gc_enter_1_hponly);
 444           JMP_(stg_gc_enter_1_hponly);
 445         }
 446       }
 447     }
 448 #endif
 449
 450     TICK_ENT_BH();
 451
 452     /* Put ourselves on the blocking queue for this black hole */
 453     CurrentTSO->link = ((StgBlockingQueue *)R1.p)->blocking_queue;
 454     ((StgBlockingQueue *)R1.p)->blocking_queue = CurrentTSO;
 455     /* jot down why and on what closure we are blocked */
 456     CurrentTSO->why_blocked = BlockedOnBlackHole;
 457     CurrentTSO->block_info.closure = R1.cl;
 458 #ifdef SMP
 459     ((StgBlockingQueue *)R1.p)->header.info = &stg_BLACKHOLE_BQ_info;
 460 #endif
 461
 462     /* PAR: dumping of event now done in blockThread -- HWL */
 463
 464     /* stg_gen_block is too heavyweight, use a specialised one */
 465     BLOCK_NP(1);
 466   FE_
 467 }
 468
 469 /*
 470    Revertible black holes are needed in the parallel world, to handle
 471    negative acknowledgements of messages containing updatable closures.
 472    The idea is that when the original message is transmitted, the closure
 473    is turned into a revertible black hole...an object which acts like a
 474    black hole when local threads try to enter it, but which can be reverted
 475    back to the original closure if necessary.
 476
 477    It's actually a lot like a blocking queue (BQ) entry, because revertible
 478    black holes are initially set up with an empty blocking queue.
 479 */
 480
 481 #if defined(PAR) || defined(GRAN)
 482
 483 INFO_TABLE(stg_RBH_info, stg_RBH_entry,1,1,RBH,,EF_,0,0);
 484 STGFUN(stg_RBH_entry)
 485 {
 486   FB_
 487 # if defined(GRAN)
 488     /* mainly statistics gathering for GranSim simulation */
 489     STGCALL3(GranSimBlock,CurrentTSO,CurrentProc,(StgClosure *)R1.p /*Node*/);
 490 # endif
 491
 492     /* exactly the same as a BLACKHOLE_BQ_entry -- HWL */
 493     /* Put ourselves on the blocking queue for this black hole */
 494     CurrentTSO->link = ((StgBlockingQueue *)R1.p)->blocking_queue;
 495     ((StgBlockingQueue *)R1.p)->blocking_queue = CurrentTSO;
 496     /* jot down why and on what closure we are blocked */
 497     CurrentTSO->why_blocked = BlockedOnBlackHole;
 498     CurrentTSO->block_info.closure = R1.cl;
 499
 500     /* PAR: dumping of event now done in blockThread -- HWL */
 501
 502     /* stg_gen_block is too heavyweight, use a specialised one */
 503     BLOCK_NP(1);
 504   FE_
 505 }
 506
 507 INFO_TABLE(stg_RBH_Save_0_info, stg_RBH_Save_0_entry,0,2,CONSTR,,EF_,0,0);
 508 NON_ENTERABLE_ENTRY_CODE(RBH_Save_0);
 509
 510 INFO_TABLE(stg_RBH_Save_1_info, stg_RBH_Save_1_entry,1,1,CONSTR,,EF_,0,0);
 511 NON_ENTERABLE_ENTRY_CODE(RBH_Save_1);
 512
 513 INFO_TABLE(stg_RBH_Save_2_info, stg_RBH_Save_2_entry,2,0,CONSTR,,EF_,0,0);
 514 NON_ENTERABLE_ENTRY_CODE(RBH_Save_2);
 515 #endif /* defined(PAR) || defined(GRAN) */
 516
 517 /* identical to BLACKHOLEs except for the infotag */
 518 INFO_TABLE(stg_CAF_BLACKHOLE_info, stg_CAF_BLACKHOLE_entry,0,2,CAF_BLACKHOLE,,EF_,"CAF_BLACKHOLE","CAF_BLACKHOLE");
 519 STGFUN(stg_CAF_BLACKHOLE_entry)
 520 {
 521   FB_
 522 #if defined(GRAN)
 523     /* mainly statistics gathering for GranSim simulation */
 524     STGCALL3(GranSimBlock,CurrentTSO,CurrentProc,(StgClosure *)R1.p /*Node*/);
 525 #endif
 526
 527 #ifdef SMP
 528     {
 529       bdescr *bd = Bdescr(R1.p);
 530       if (bd->back != (bdescr *)BaseReg) {
 531         if (bd->gen->no >= 1 || bd->step->no >= 1) {
 532           CMPXCHG(R1.cl->header.info, &CAF_BLACKHOLE_info, &WHITEHOLE_info);
 533         } else {
 534           EXTFUN_RTS(stg_gc_enter_1_hponly);
 535           JMP_(stg_gc_enter_1_hponly);
 536         }
 537       }
 538     }
 539 #endif
 540
 541     TICK_ENT_BH();
 542
 543     /* Put ourselves on the blocking queue for this black hole */
 544 #if defined(GRAN) || defined(PAR)
 545     /* in fact, only difference is the type of the end-of-queue marker! */
 546     CurrentTSO->link = END_BQ_QUEUE;
 547     ((StgBlockingQueue *)R1.p)->blocking_queue = (StgBlockingQueueElement *)CurrentTSO;
 548 #else
 549     CurrentTSO->link = END_TSO_QUEUE;
 550     ((StgBlockingQueue *)R1.p)->blocking_queue = CurrentTSO;
 551 #endif
 552     /* jot down why and on what closure we are blocked */
 553     CurrentTSO->why_blocked = BlockedOnBlackHole;
 554     CurrentTSO->block_info.closure = R1.cl;
 555     /* closure is mutable since something has just been added to its BQ */
 556     recordMutable((StgMutClosure *)R1.cl);
 557     /* Change the CAF_BLACKHOLE into a BLACKHOLE_BQ */
 558     ((StgBlockingQueue *)R1.p)->header.info = &stg_BLACKHOLE_BQ_info;
 559
 560     /* PAR: dumping of event now done in blockThread -- HWL */
 561
 562     /* stg_gen_block is too heavyweight, use a specialised one */
 563     BLOCK_NP(1);
 564   FE_
 565 }
 566
 567 #ifdef TICKY_TICKY
 568 INFO_TABLE(stg_SE_BLACKHOLE_info, stg_SE_BLACKHOLE_entry,0,2,SE_BLACKHOLE,,EF_,0,0);
 569 STGFUN(stg_SE_BLACKHOLE_entry)
 570 {
 571   FB_
 572     STGCALL3(fprintf,stderr,"SE_BLACKHOLE at %p entered!\n",R1.p);
 573     STGCALL1(shutdownHaskellAndExit,EXIT_FAILURE);
 574   FE_
 575 }
 576
 577 INFO_TABLE(SE_CAF_BLACKHOLE_info, SE_CAF_BLACKHOLE_entry,0,2,SE_CAF_BLACKHOLE,,EF_,0,0);
 578 STGFUN(stg_SE_CAF_BLACKHOLE_entry)
 579 {
 580   FB_
 581     STGCALL3(fprintf,stderr,"SE_CAF_BLACKHOLE at %p entered!\n",R1.p);
 582     STGCALL1(shutdownHaskellAndExit,EXIT_FAILURE);
 583   FE_
 584 }
 585 #endif
 586
 587 #ifdef SMP
 588 INFO_TABLE(stg_WHITEHOLE_info, stg_WHITEHOLE_entry,0,2,CONSTR_NOCAF_STATIC,,EF_,0,0);
 589 STGFUN(stg_WHITEHOLE_entry)
 590 {
 591   FB_
 592      JMP_(GET_ENTRY(R1.cl));
 593   FE_
 594 }
 595 #endif
 596
 597 /* -----------------------------------------------------------------------------
 598    Some static info tables for things that don't get entered, and
 599    therefore don't need entry code (i.e. boxed but unpointed objects)
 600    NON_ENTERABLE_ENTRY_CODE now defined at the beginning of the file
 601    -------------------------------------------------------------------------- */
 602
 603 INFO_TABLE(stg_TSO_info, stg_TSO_entry, 0,0,TSO,,EF_,"TSO","TSO");
 604 NON_ENTERABLE_ENTRY_CODE(TSO);
 605
 606 /* -----------------------------------------------------------------------------
 607    Evacuees are left behind by the garbage collector.  Any attempt to enter
 608    one is a real bug.
 609    -------------------------------------------------------------------------- */
 610
 611 INFO_TABLE(stg_EVACUATED_info,stg_EVACUATED_entry,1,0,EVACUATED,,EF_,0,0);
 612 NON_ENTERABLE_ENTRY_CODE(EVACUATED);
 613
 614 /* -----------------------------------------------------------------------------
 615    Weak pointers
 616
 617    Live weak pointers have a special closure type.  Dead ones are just
 618    nullary constructors (although they live on the heap - we overwrite
 619    live weak pointers with dead ones).
 620    -------------------------------------------------------------------------- */
 621
 622 INFO_TABLE(stg_WEAK_info,stg_WEAK_entry,0,4,WEAK,,EF_,"WEAK","WEAK");
 623 NON_ENTERABLE_ENTRY_CODE(WEAK);
 624
 625 INFO_TABLE_CONSTR(stg_DEAD_WEAK_info,stg_DEAD_WEAK_entry,0,1,0,CONSTR,,EF_,"DEAD_WEAK","DEAD_WEAK");
 626 NON_ENTERABLE_ENTRY_CODE(DEAD_WEAK);
 627
 628 /* -----------------------------------------------------------------------------
 629    NO_FINALIZER
 630
 631    This is a static nullary constructor (like []) that we use to mark an empty
 632    finalizer in a weak pointer object.
 633    -------------------------------------------------------------------------- */
 634
 635 INFO_TABLE_CONSTR(stg_NO_FINALIZER_info,stg_NO_FINALIZER_entry,0,0,0,CONSTR_NOCAF_STATIC,,EF_,0,0);
 636 NON_ENTERABLE_ENTRY_CODE(NO_FINALIZER);
 637
 638 SET_STATIC_HDR(stg_NO_FINALIZER_closure,stg_NO_FINALIZER_info,0/*CC*/,,EI_)
 639 , /*payload*/{} };
 640
 641 /* -----------------------------------------------------------------------------
 642    Foreign Objects are unlifted and therefore never entered.
 643    -------------------------------------------------------------------------- */
 644
 645 INFO_TABLE(stg_FOREIGN_info,stg_FOREIGN_entry,0,1,FOREIGN,,EF_,"FOREIGN","FOREIGN");
 646 NON_ENTERABLE_ENTRY_CODE(FOREIGN);
 647
 648 /* -----------------------------------------------------------------------------
 649    Stable Names are unlifted too.
 650    -------------------------------------------------------------------------- */
 651
 652 INFO_TABLE(stg_STABLE_NAME_info,stg_STABLE_NAME_entry,0,1,STABLE_NAME,,EF_,"STABLE_NAME","STABLE_NAME");
 653 NON_ENTERABLE_ENTRY_CODE(STABLE_NAME);
 654
 655 /* -----------------------------------------------------------------------------
 656    MVars
 657
 658    There are two kinds of these: full and empty.  We need an info table
 659    and entry code for each type.
 660    -------------------------------------------------------------------------- */
 661
 662 INFO_TABLE(stg_FULL_MVAR_info,stg_FULL_MVAR_entry,4,0,MVAR,,EF_,"MVAR","MVAR");
 663 NON_ENTERABLE_ENTRY_CODE(FULL_MVAR);
 664
 665 INFO_TABLE(stg_EMPTY_MVAR_info,stg_EMPTY_MVAR_entry,4,0,MVAR,,EF_,"MVAR","MVAR");
 666 NON_ENTERABLE_ENTRY_CODE(EMPTY_MVAR);
 667
 668 /* -----------------------------------------------------------------------------
 669    END_TSO_QUEUE
 670
 671    This is a static nullary constructor (like []) that we use to mark the
 672    end of a linked TSO queue.
 673    -------------------------------------------------------------------------- */
 674
 675 INFO_TABLE_CONSTR(stg_END_TSO_QUEUE_info,stg_END_TSO_QUEUE_entry,0,0,0,CONSTR_NOCAF_STATIC,,EF_,0,0);
 676 NON_ENTERABLE_ENTRY_CODE(END_TSO_QUEUE);
 677
 678 SET_STATIC_HDR(stg_END_TSO_QUEUE_closure,stg_END_TSO_QUEUE_info,0/*CC*/,,EI_)
 679 , /*payload*/{} };
 680
 681 /* -----------------------------------------------------------------------------
 682    Mutable lists
 683
 684    Mutable lists (used by the garbage collector) consist of a chain of
 685    StgMutClosures connected through their mut_link fields, ending in
 686    an END_MUT_LIST closure.
 687    -------------------------------------------------------------------------- */
 688
 689 INFO_TABLE_CONSTR(stg_END_MUT_LIST_info,stg_END_MUT_LIST_entry,0,0,0,CONSTR_NOCAF_STATIC,,EF_,0,0);
 690 NON_ENTERABLE_ENTRY_CODE(END_MUT_LIST);
 691
 692 SET_STATIC_HDR(stg_END_MUT_LIST_closure,stg_END_MUT_LIST_info,0/*CC*/,,EI_)
 693 , /*payload*/{} };
 694
 695 INFO_TABLE(stg_MUT_CONS_info, stg_MUT_CONS_entry, 1, 1, MUT_VAR, , EF_, 0, 0);
 696 NON_ENTERABLE_ENTRY_CODE(MUT_CONS);
 697
 698 /* -----------------------------------------------------------------------------
 699    Exception lists
 700    -------------------------------------------------------------------------- */
 701
 702 INFO_TABLE_CONSTR(stg_END_EXCEPTION_LIST_info,stg_END_EXCEPTION_LIST_entry,0,0,0,CONSTR_NOCAF_STATIC,,EF_,0,0);
 703 NON_ENTERABLE_ENTRY_CODE(END_EXCEPTION_LIST);
 704
 705 SET_STATIC_HDR(stg_END_EXCEPTION_LIST_closure,stg_END_EXCEPTION_LIST_info,0/*CC*/,,EI_)
 706 , /*payload*/{} };
 707
 708 INFO_TABLE(stg_EXCEPTION_CONS_info, stg_EXCEPTION_CONS_entry, 1, 1, CONSTR, , EF_, 0, 0);
 709 NON_ENTERABLE_ENTRY_CODE(EXCEPTION_CONS);
 710
 711 /* -----------------------------------------------------------------------------
 712    Arrays
 713
 714    These come in two basic flavours: arrays of data (StgArrWords) and arrays of
 715    pointers (StgArrPtrs).  They all have a similar layout:
 716
 717         ___________________________
 718         | Info | No. of | data....
 719         |  Ptr | Words  |
 720         ---------------------------
 721
 722    These are *unpointed* objects: i.e. they cannot be entered.
 723
 724    -------------------------------------------------------------------------- */
 725
 726 #define ArrayInfo(type)                                 \
 727 INFO_TABLE(stg_##type##_info, stg_##type##_entry, 0, 0, type, , EF_,"" # type "","" # type "");
 728
 729 ArrayInfo(ARR_WORDS);
 730 NON_ENTERABLE_ENTRY_CODE(ARR_WORDS);
 731 ArrayInfo(MUT_ARR_PTRS);
 732 NON_ENTERABLE_ENTRY_CODE(MUT_ARR_PTRS);
 733 ArrayInfo(MUT_ARR_PTRS_FROZEN);
 734 NON_ENTERABLE_ENTRY_CODE(MUT_ARR_PTRS_FROZEN);
 735
 736 #undef ArrayInfo
 737
 738 /* -----------------------------------------------------------------------------
 739    Mutable Variables
 740    -------------------------------------------------------------------------- */
 741
 742 INFO_TABLE(stg_MUT_VAR_info, stg_MUT_VAR_entry, 1, 1, MUT_VAR, , EF_, "MUT_VAR", "MUT_VAR");
 743 NON_ENTERABLE_ENTRY_CODE(MUT_VAR);
 744
 745 /* -----------------------------------------------------------------------------
 746    Standard Error Entry.
 747
 748    This is used for filling in vector-table entries that can never happen,
 749    for instance.
 750    -------------------------------------------------------------------------- */
 751 /* No longer used; we use NULL, because a) it never happens, right? and b)
 752    Windows doesn't like DLL entry points being used as static initialisers
 753 STGFUN(stg_error_entry)                                                 \
 754 {                                                                       \
 755   FB_                                                                   \
 756     DUMP_ERRMSG("fatal: stg_error_entry");                              \
 757     STGCALL1(shutdownHaskellAndExit, EXIT_FAILURE);                     \
 758     return NULL;                                                        \
 759   FE_                                                                   \
 760 }
 761 */
 762 /* -----------------------------------------------------------------------------
 763    Dummy return closure
 764
 765    Entering this closure will just return to the address on the top of the
 766    stack.  Useful for getting a thread in a canonical form where we can
 767    just enter the top stack word to start the thread.  (see deleteThread)
 768  * -------------------------------------------------------------------------- */
 769
 770 INFO_TABLE(stg_dummy_ret_info, stg_dummy_ret_entry, 0, 0, CONSTR_NOCAF_STATIC, , EF_, 0, 0);
 771 STGFUN(stg_dummy_ret_entry)
 772 {
 773   W_ ret_addr;
 774   FB_
 775   ret_addr = Sp[0];
 776   Sp++;
 777   JMP_(ENTRY_CODE(ret_addr));
 778   FE_
 779 }
 780 SET_STATIC_HDR(stg_dummy_ret_closure,stg_dummy_ret_info,CCS_DONT_CARE,,EI_)
 781 , /*payload*/{} };
 782
 783 /* -----------------------------------------------------------------------------
 784     Strict IO application - performing an IO action and entering its result.
 785
 786     rts_evalIO() lets you perform Haskell IO actions from outside of Haskell-land,
 787     returning back to you their result. Want this result to be evaluated to WHNF
 788     by that time, so that we can easily get at the int/char/whatever using the
 789     various get{Ty} functions provided by the RTS API.
 790
 791     forceIO takes care of this, performing the IO action and entering the
 792     results that comes back.
 793
 794  * -------------------------------------------------------------------------- */
 795
 796 #ifdef REG_R1
 797 INFO_TABLE_SRT_BITMAP(stg_forceIO_ret_info,stg_forceIO_ret_entry,0,0,0,0,RET_SMALL,,EF_,0,0);
 798 STGFUN(stg_forceIO_ret_entry)
 799 {
 800   FB_
 801   Sp++;
 802   Sp -= sizeofW(StgSeqFrame);
 803   PUSH_SEQ_FRAME(Sp);
 804   JMP_(GET_ENTRY(R1.cl));
 805 }
 806 #else
 807 INFO_TABLE_SRT_BITMAP(stg_forceIO_ret_info,stg_forceIO_ret_entry,0,0,0,0,RET_SMALL,,EF_,0,0);
 808 STGFUN(forceIO_ret_entry)
 809 {
 810   StgClosure *rval;
 811   FB_
 812   rval = (StgClosure *)Sp[0];
 813   Sp += 2;
 814   Sp -= sizeofW(StgSeqFrame);
 815   PUSH_SEQ_FRAME(Sp);
 816   R1.cl = rval;
 817   JMP_(GET_ENTRY(R1.cl));
 818 }
 819 #endif
 820
 821 INFO_TABLE(stg_forceIO_info,stg_forceIO_entry,1,0,FUN_STATIC,,EF_,0,0);
 822 FN_(stg_forceIO_entry)
 823 {
 824   FB_
 825   /* Sp[0] contains the IO action we want to perform */
 826   R1.p  = (P_)Sp[0];
 827   /* Replace it with the return continuation that enters the result. */
 828   Sp[0] = (W_)&stg_forceIO_ret_info;
 829   Sp--;
 830   /* Push the RealWorld# tag and enter */
 831   Sp[0] =(W_)REALWORLD_TAG;
 832   JMP_(GET_ENTRY(R1.cl));
 833   FE_
 834 }
 835 SET_STATIC_HDR(stg_forceIO_closure,stg_forceIO_info,CCS_DONT_CARE,,EI_)
 836 , /*payload*/{} };
 837
 838
 839 /* -----------------------------------------------------------------------------
 840    CHARLIKE and INTLIKE closures.
 841
 842    These are static representations of Chars and small Ints, so that
 843    we can remove dynamic Chars and Ints during garbage collection and
 844    replace them with references to the static objects.
 845    -------------------------------------------------------------------------- */
 846
 847 #if defined(INTERPRETER) || defined(ENABLE_WIN32_DLL_SUPPORT)
 848 /*
 849  * When sticking the RTS in a DLL, we delay populating the
 850  * Charlike and Intlike tables until load-time, which is only
 851  * when we've got the real addresses to the C# and I# closures.
 852  *
 853  */
 854 static INFO_TBL_CONST StgInfoTable czh_static_info;
 855 static INFO_TBL_CONST StgInfoTable izh_static_info;
 856 #define Char_hash_static_info czh_static_info
 857 #define Int_hash_static_info izh_static_info
 858 #else
 859 #define Char_hash_static_info PrelBase_Czh_static_info
 860 #define Int_hash_static_info PrelBase_Izh_static_info
 861 #endif
 862
 863 #define CHARLIKE_HDR(n)                                         \
 864         {                                                       \
 865           STATIC_HDR(Char_hash_static_info, /* C# */            \
 866                          CCS_DONT_CARE),                        \
 867           data : n                                              \
 868         }
 869
 870 #define INTLIKE_HDR(n)                                          \
 871         {                                                       \
 872           STATIC_HDR(Int_hash_static_info,  /* I# */            \
 873                          CCS_DONT_CARE),                        \
 874           data : n                                              \
 875         }
 876
 877 /* put these in the *data* section, since the garbage collector relies
 878  * on the fact that static closures live in the data section.
 879  */
 880
 881 /* end the name with _closure, to convince the mangler this is a closure */
 882
 883 StgIntCharlikeClosure stg_CHARLIKE_closure[] = {
 884     CHARLIKE_HDR(0),
 885     CHARLIKE_HDR(1),
 886     CHARLIKE_HDR(2),
 887     CHARLIKE_HDR(3),
 888     CHARLIKE_HDR(4),
 889     CHARLIKE_HDR(5),
 890     CHARLIKE_HDR(6),
 891     CHARLIKE_HDR(7),
 892     CHARLIKE_HDR(8),
 893     CHARLIKE_HDR(9),
 894     CHARLIKE_HDR(10),
 895     CHARLIKE_HDR(11),
 896     CHARLIKE_HDR(12),
 897     CHARLIKE_HDR(13),
 898     CHARLIKE_HDR(14),
 899     CHARLIKE_HDR(15),
 900     CHARLIKE_HDR(16),
 901     CHARLIKE_HDR(17),
 902     CHARLIKE_HDR(18),
 903     CHARLIKE_HDR(19),
 904     CHARLIKE_HDR(20),
 905     CHARLIKE_HDR(21),
 906     CHARLIKE_HDR(22),
 907     CHARLIKE_HDR(23),
 908     CHARLIKE_HDR(24),
 909     CHARLIKE_HDR(25),
 910     CHARLIKE_HDR(26),
 911     CHARLIKE_HDR(27),
 912     CHARLIKE_HDR(28),
 913     CHARLIKE_HDR(29),
 914     CHARLIKE_HDR(30),
 915     CHARLIKE_HDR(31),
 916     CHARLIKE_HDR(32),
 917     CHARLIKE_HDR(33),
 918     CHARLIKE_HDR(34),
 919     CHARLIKE_HDR(35),
 920     CHARLIKE_HDR(36),
 921     CHARLIKE_HDR(37),
 922     CHARLIKE_HDR(38),
 923     CHARLIKE_HDR(39),
 924     CHARLIKE_HDR(40),
 925     CHARLIKE_HDR(41),
 926     CHARLIKE_HDR(42),
 927     CHARLIKE_HDR(43),
 928     CHARLIKE_HDR(44),
 929     CHARLIKE_HDR(45),
 930     CHARLIKE_HDR(46),
 931     CHARLIKE_HDR(47),
 932     CHARLIKE_HDR(48),
 933     CHARLIKE_HDR(49),
 934     CHARLIKE_HDR(50),
 935     CHARLIKE_HDR(51),
 936     CHARLIKE_HDR(52),
 937     CHARLIKE_HDR(53),
 938     CHARLIKE_HDR(54),
 939     CHARLIKE_HDR(55),
 940     CHARLIKE_HDR(56),
 941     CHARLIKE_HDR(57),
 942     CHARLIKE_HDR(58),
 943     CHARLIKE_HDR(59),
 944     CHARLIKE_HDR(60),
 945     CHARLIKE_HDR(61),
 946     CHARLIKE_HDR(62),
 947     CHARLIKE_HDR(63),
 948     CHARLIKE_HDR(64),
 949     CHARLIKE_HDR(65),
 950     CHARLIKE_HDR(66),
 951     CHARLIKE_HDR(67),
 952     CHARLIKE_HDR(68),
 953     CHARLIKE_HDR(69),
 954     CHARLIKE_HDR(70),
 955     CHARLIKE_HDR(71),
 956     CHARLIKE_HDR(72),
 957     CHARLIKE_HDR(73),
 958     CHARLIKE_HDR(74),
 959     CHARLIKE_HDR(75),
 960     CHARLIKE_HDR(76),
 961     CHARLIKE_HDR(77),
 962     CHARLIKE_HDR(78),
 963     CHARLIKE_HDR(79),
 964     CHARLIKE_HDR(80),
 965     CHARLIKE_HDR(81),
 966     CHARLIKE_HDR(82),
 967     CHARLIKE_HDR(83),
 968     CHARLIKE_HDR(84),
 969     CHARLIKE_HDR(85),
 970     CHARLIKE_HDR(86),
 971     CHARLIKE_HDR(87),
 972     CHARLIKE_HDR(88),
 973     CHARLIKE_HDR(89),
 974     CHARLIKE_HDR(90),
 975     CHARLIKE_HDR(91),
 976     CHARLIKE_HDR(92),
 977     CHARLIKE_HDR(93),
 978     CHARLIKE_HDR(94),
 979     CHARLIKE_HDR(95),
 980     CHARLIKE_HDR(96),
 981     CHARLIKE_HDR(97),
 982     CHARLIKE_HDR(98),
 983     CHARLIKE_HDR(99),
 984     CHARLIKE_HDR(100),
 985     CHARLIKE_HDR(101),
 986     CHARLIKE_HDR(102),
 987     CHARLIKE_HDR(103),
 988     CHARLIKE_HDR(104),
 989     CHARLIKE_HDR(105),
 990     CHARLIKE_HDR(106),
 991     CHARLIKE_HDR(107),
 992     CHARLIKE_HDR(108),
 993     CHARLIKE_HDR(109),
 994     CHARLIKE_HDR(110),
 995     CHARLIKE_HDR(111),
 996     CHARLIKE_HDR(112),
 997     CHARLIKE_HDR(113),
 998     CHARLIKE_HDR(114),
 999     CHARLIKE_HDR(115),
1000     CHARLIKE_HDR(116),
1001     CHARLIKE_HDR(117),
1002     CHARLIKE_HDR(118),
1003     CHARLIKE_HDR(119),
1004     CHARLIKE_HDR(120),
1005     CHARLIKE_HDR(121),
1006     CHARLIKE_HDR(122),
1007     CHARLIKE_HDR(123),
1008     CHARLIKE_HDR(124),
1009     CHARLIKE_HDR(125),
1010     CHARLIKE_HDR(126),
1011     CHARLIKE_HDR(127),
1012     CHARLIKE_HDR(128),
1013     CHARLIKE_HDR(129),
1014     CHARLIKE_HDR(130),
1015     CHARLIKE_HDR(131),
1016     CHARLIKE_HDR(132),
1017     CHARLIKE_HDR(133),
1018     CHARLIKE_HDR(134),
1019     CHARLIKE_HDR(135),
1020     CHARLIKE_HDR(136),
1021     CHARLIKE_HDR(137),
1022     CHARLIKE_HDR(138),
1023     CHARLIKE_HDR(139),
1024     CHARLIKE_HDR(140),
1025     CHARLIKE_HDR(141),
1026     CHARLIKE_HDR(142),
1027     CHARLIKE_HDR(143),
1028     CHARLIKE_HDR(144),
1029     CHARLIKE_HDR(145),
1030     CHARLIKE_HDR(146),
1031     CHARLIKE_HDR(147),
1032     CHARLIKE_HDR(148),
1033     CHARLIKE_HDR(149),
1034     CHARLIKE_HDR(150),
1035     CHARLIKE_HDR(151),
1036     CHARLIKE_HDR(152),
1037     CHARLIKE_HDR(153),
1038     CHARLIKE_HDR(154),
1039     CHARLIKE_HDR(155),
1040     CHARLIKE_HDR(156),
1041     CHARLIKE_HDR(157),
1042     CHARLIKE_HDR(158),
1043     CHARLIKE_HDR(159),
1044     CHARLIKE_HDR(160),
1045     CHARLIKE_HDR(161),
1046     CHARLIKE_HDR(162),
1047     CHARLIKE_HDR(163),
1048     CHARLIKE_HDR(164),
1049     CHARLIKE_HDR(165),
1050     CHARLIKE_HDR(166),
1051     CHARLIKE_HDR(167),
1052     CHARLIKE_HDR(168),
1053     CHARLIKE_HDR(169),
1054     CHARLIKE_HDR(170),
1055     CHARLIKE_HDR(171),
1056     CHARLIKE_HDR(172),
1057     CHARLIKE_HDR(173),
1058     CHARLIKE_HDR(174),
1059     CHARLIKE_HDR(175),
1060     CHARLIKE_HDR(176),
1061     CHARLIKE_HDR(177),
1062     CHARLIKE_HDR(178),
1063     CHARLIKE_HDR(179),
1064     CHARLIKE_HDR(180),
1065     CHARLIKE_HDR(181),
1066     CHARLIKE_HDR(182),
1067     CHARLIKE_HDR(183),
1068     CHARLIKE_HDR(184),
1069     CHARLIKE_HDR(185),
1070     CHARLIKE_HDR(186),
1071     CHARLIKE_HDR(187),
1072     CHARLIKE_HDR(188),
1073     CHARLIKE_HDR(189),
1074     CHARLIKE_HDR(190),
1075     CHARLIKE_HDR(191),
1076     CHARLIKE_HDR(192),
1077     CHARLIKE_HDR(193),
1078     CHARLIKE_HDR(194),
1079     CHARLIKE_HDR(195),
1080     CHARLIKE_HDR(196),
1081     CHARLIKE_HDR(197),
1082     CHARLIKE_HDR(198),
1083     CHARLIKE_HDR(199),
1084     CHARLIKE_HDR(200),
1085     CHARLIKE_HDR(201),
1086     CHARLIKE_HDR(202),
1087     CHARLIKE_HDR(203),
1088     CHARLIKE_HDR(204),
1089     CHARLIKE_HDR(205),
1090     CHARLIKE_HDR(206),
1091     CHARLIKE_HDR(207),
1092     CHARLIKE_HDR(208),
1093     CHARLIKE_HDR(209),
1094     CHARLIKE_HDR(210),
1095     CHARLIKE_HDR(211),
1096     CHARLIKE_HDR(212),
1097     CHARLIKE_HDR(213),
1098     CHARLIKE_HDR(214),
1099     CHARLIKE_HDR(215),
1100     CHARLIKE_HDR(216),
1101     CHARLIKE_HDR(217),
1102     CHARLIKE_HDR(218),
1103     CHARLIKE_HDR(219),
1104     CHARLIKE_HDR(220),
1105     CHARLIKE_HDR(221),
1106     CHARLIKE_HDR(222),
1107     CHARLIKE_HDR(223),
1108     CHARLIKE_HDR(224),
1109     CHARLIKE_HDR(225),
1110     CHARLIKE_HDR(226),
1111     CHARLIKE_HDR(227),
1112     CHARLIKE_HDR(228),
1113     CHARLIKE_HDR(229),
1114     CHARLIKE_HDR(230),
1115     CHARLIKE_HDR(231),
1116     CHARLIKE_HDR(232),
1117     CHARLIKE_HDR(233),
1118     CHARLIKE_HDR(234),
1119     CHARLIKE_HDR(235),
1120     CHARLIKE_HDR(236),
1121     CHARLIKE_HDR(237),
1122     CHARLIKE_HDR(238),
1123     CHARLIKE_HDR(239),
1124     CHARLIKE_HDR(240),
1125     CHARLIKE_HDR(241),
1126     CHARLIKE_HDR(242),
1127     CHARLIKE_HDR(243),
1128     CHARLIKE_HDR(244),
1129     CHARLIKE_HDR(245),
1130     CHARLIKE_HDR(246),
1131     CHARLIKE_HDR(247),
1132     CHARLIKE_HDR(248),
1133     CHARLIKE_HDR(249),
1134     CHARLIKE_HDR(250),
1135     CHARLIKE_HDR(251),
1136     CHARLIKE_HDR(252),
1137     CHARLIKE_HDR(253),
1138     CHARLIKE_HDR(254),
1139     CHARLIKE_HDR(255)
1140 };
1141
1142 StgIntCharlikeClosure stg_INTLIKE_closure[] = {
1143     INTLIKE_HDR(-16),   /* MIN_INTLIKE == -16 */
1144     INTLIKE_HDR(-15),
1145     INTLIKE_HDR(-14),
1146     INTLIKE_HDR(-13),
1147     INTLIKE_HDR(-12),
1148     INTLIKE_HDR(-11),
1149     INTLIKE_HDR(-10),
1150     INTLIKE_HDR(-9),
1151     INTLIKE_HDR(-8),
1152     INTLIKE_HDR(-7),
1153     INTLIKE_HDR(-6),
1154     INTLIKE_HDR(-5),
1155     INTLIKE_HDR(-4),
1156     INTLIKE_HDR(-3),
1157     INTLIKE_HDR(-2),
1158     INTLIKE_HDR(-1),
1159     INTLIKE_HDR(0),
1160     INTLIKE_HDR(1),
1161     INTLIKE_HDR(2),
1162     INTLIKE_HDR(3),
1163     INTLIKE_HDR(4),
1164     INTLIKE_HDR(5),
1165     INTLIKE_HDR(6),
1166     INTLIKE_HDR(7),
1167     INTLIKE_HDR(8),
1168     INTLIKE_HDR(9),
1169     INTLIKE_HDR(10),
1170     INTLIKE_HDR(11),
1171     INTLIKE_HDR(12),
1172     INTLIKE_HDR(13),
1173     INTLIKE_HDR(14),
1174     INTLIKE_HDR(15),
1175     INTLIKE_HDR(16)     /* MAX_INTLIKE == 16 */
1176 };