ghc/rts/StgMiscClosures.hc

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