ghc/rts/StgMiscClosures.hc

   1 /* -----------------------------------------------------------------------------
   2  * $Id: StgMiscClosures.hc,v 1.20 1999/04/23 09:47:33 simonm Exp $
   3  *
   4  * (c) The GHC Team, 1998-1999
   5  *
   6  * Entry code for various built-in closure types.
   7  *
   8  * ---------------------------------------------------------------------------*/
   9
  10 #include "Rts.h"
  11 #include "RtsUtils.h"
  12 #include "StgMiscClosures.h"
  13 #include "HeapStackCheck.h"   /* for stg_gen_yield */
  14 #include "Storage.h"
  15 #include "StoragePriv.h"
  16 #include "ProfRts.h"
  17
  18 #ifdef HAVE_STDIO_H
  19 #include <stdio.h>
  20 #endif
  21
  22 /* -----------------------------------------------------------------------------
  23    Entry code for an indirection.
  24
  25    This code assumes R1 is in a register for now.
  26    -------------------------------------------------------------------------- */
  27
  28 INFO_TABLE(IND_info,IND_entry,1,0,IND,const,EF_,0,0);
  29 STGFUN(IND_entry)
  30 {
  31     FB_
  32     TICK_ENT_IND(Node); /* tick */
  33
  34     R1.p = (P_) ((StgInd*)R1.p)->indirectee;
  35     TICK_ENT_VIA_NODE();
  36     JMP_(*R1.p);
  37     FE_
  38 }
  39
  40 INFO_TABLE(IND_STATIC_info,IND_STATIC_entry,1,0,IND_STATIC,const,EF_,0,0);
  41 STGFUN(IND_STATIC_entry)
  42 {
  43     FB_
  44     TICK_ENT_IND(Node); /* tick */
  45
  46     R1.p = (P_) ((StgIndStatic*)R1.p)->indirectee;
  47     TICK_ENT_VIA_NODE();
  48     JMP_(*R1.p);
  49     FE_
  50 }
  51
  52 INFO_TABLE(IND_PERM_info,IND_PERM_entry,1,1,IND_PERM,const,EF_,0,0);
  53 STGFUN(IND_PERM_entry)
  54 {
  55     FB_
  56     /* Don't add INDs to granularity cost */
  57
  58     /* Dont: TICK_ENT_IND(Node); for ticky-ticky; this ind is here only to help profi
  59 ling */
  60
  61     /* Enter PAP cost centre -- lexical scoping only */
  62     ENTER_CCS_PAP_CL(R1.cl);
  63
  64     R1.p = (P_) ((StgInd*)R1.p)->indirectee;
  65
  66     /* Dont: TICK_ENT_VIA_NODE(); for ticky-ticky; as above */
  67
  68     JMP_(*R1.p);
  69     FE_
  70 }
  71
  72 INFO_TABLE(IND_OLDGEN_info,IND_OLDGEN_entry,1,1,IND_OLDGEN,const,EF_,0,0);
  73 STGFUN(IND_OLDGEN_entry)
  74 {
  75     FB_
  76     TICK_ENT_IND(Node); /* tick */
  77
  78     R1.p = (P_) ((StgInd*)R1.p)->indirectee;
  79     TICK_ENT_VIA_NODE();
  80     JMP_(*R1.p);
  81     FE_
  82 }
  83
  84 INFO_TABLE(IND_OLDGEN_PERM_info,IND_OLDGEN_PERM_entry,1,1,IND_OLDGEN_PERM,const,EF_,0,0);
  85 STGFUN(IND_OLDGEN_PERM_entry)
  86 {
  87     FB_
  88     TICK_ENT_IND(Node); /* tick */
  89
  90     /* Dont: TICK_ENT_IND(Node); for ticky-ticky; this ind is here only to help profi
  91 ling */
  92
  93     /* Enter PAP cost centre -- lexical scoping only */
  94     ENTER_CCS_PAP_CL(R1.cl);
  95
  96     R1.p = (P_) ((StgInd*)R1.p)->indirectee;
  97     TICK_ENT_VIA_NODE();
  98     JMP_(*R1.p);
  99     FE_
 100 }
 101
 102 /* -----------------------------------------------------------------------------
 103    Entry code for CAFs
 104
 105    This code assumes R1 is in a register for now.
 106    -------------------------------------------------------------------------- */
 107
 108 INFO_TABLE(CAF_UNENTERED_info,CAF_UNENTERED_entry,1,3,CAF_UNENTERED,const,EF_,0,0);
 109 STGFUN(CAF_UNENTERED_entry)
 110 {
 111     FB_
 112     /* ToDo: implement directly in GHC */
 113     Sp -= 1;
 114     Sp[0] = R1.w;
 115     JMP_(stg_yield_to_Hugs);
 116     FE_
 117 }
 118
 119 /* 0,4 is entirely bogus; _do not_ rely on this info */
 120 INFO_TABLE(CAF_ENTERED_info,CAF_ENTERED_entry,0,4,CAF_ENTERED,const,EF_,0,0);
 121 STGFUN(CAF_ENTERED_entry)
 122 {
 123     FB_
 124     R1.p = (P_) ((StgCAF*)R1.p)->value; /* just a fancy indirection */
 125     TICK_ENT_VIA_NODE();
 126     JMP_(GET_ENTRY(R1.cl));
 127     FE_
 128 }
 129
 130 /* -----------------------------------------------------------------------------
 131    Entry code for a black hole.
 132
 133    Entering a black hole normally causes a cyclic data dependency, but
 134    in the concurrent world, black holes are synchronization points,
 135    and they are turned into blocking queues when there are threads
 136    waiting for the evaluation of the closure to finish.
 137    -------------------------------------------------------------------------- */
 138
 139 /* Note: a black hole must be big enough to be overwritten with an
 140  * indirection/evacuee/catch.  Thus we claim it has 1 non-pointer word of
 141  * payload (in addition to the pointer word for the blocking queue), which
 142  * should be big enough for an old-generation indirection.
 143  */
 144
 145 INFO_TABLE(BLACKHOLE_info, BLACKHOLE_entry,0,2,BLACKHOLE,const,EF_,0,0);
 146 STGFUN(BLACKHOLE_entry)
 147 {
 148   FB_
 149     TICK_ENT_BH();
 150
 151     /* Change the BLACKHOLE into a BLACKHOLE_BQ */
 152     ((StgBlockingQueue *)R1.p)->header.info = &BLACKHOLE_BQ_info;
 153     /* Put ourselves on the blocking queue for this black hole */
 154     CurrentTSO->link = (StgTSO *)&END_TSO_QUEUE_closure;
 155     ((StgBlockingQueue *)R1.p)->blocking_queue = CurrentTSO;
 156     CurrentTSO->blocked_on = R1.cl;
 157     recordMutable((StgMutClosure *)R1.cl);
 158
 159     /* stg_gen_block is too heavyweight, use a specialised one */
 160     BLOCK_NP(1);
 161   FE_
 162 }
 163
 164 INFO_TABLE(BLACKHOLE_BQ_info, BLACKHOLE_BQ_entry,1,1,BLACKHOLE_BQ,const,EF_,0,0);
 165 STGFUN(BLACKHOLE_BQ_entry)
 166 {
 167   FB_
 168     TICK_ENT_BH();
 169
 170     /* Put ourselves on the blocking queue for this black hole */
 171     CurrentTSO->blocked_on = R1.cl;
 172     CurrentTSO->link = ((StgBlockingQueue *)R1.p)->blocking_queue;
 173     ((StgBlockingQueue *)R1.p)->blocking_queue = CurrentTSO;
 174
 175     /* stg_gen_block is too heavyweight, use a specialised one */
 176     BLOCK_NP(1);
 177   FE_
 178 }
 179
 180 /* identical to BLACKHOLEs except for the infotag */
 181 INFO_TABLE(CAF_BLACKHOLE_info, CAF_BLACKHOLE_entry,0,2,CAF_BLACKHOLE,const,EF_,0,0);
 182 STGFUN(CAF_BLACKHOLE_entry)
 183 {
 184   FB_
 185     TICK_ENT_BH();
 186
 187     /* Change the BLACKHOLE into a BLACKHOLE_BQ */
 188     ((StgBlockingQueue *)R1.p)->header.info = &BLACKHOLE_BQ_info;
 189     /* Put ourselves on the blocking queue for this black hole */
 190     CurrentTSO->link = (StgTSO *)&END_TSO_QUEUE_closure;
 191     ((StgBlockingQueue *)R1.p)->blocking_queue = CurrentTSO;
 192     CurrentTSO->blocked_on = R1.cl;
 193     recordMutable((StgMutClosure *)R1.cl);
 194
 195     /* stg_gen_block is too heavyweight, use a specialised one */
 196     BLOCK_NP(1);
 197   FE_
 198 }
 199
 200 /* -----------------------------------------------------------------------------
 201    The code for a BCO returns to the scheduler
 202    -------------------------------------------------------------------------- */
 203 INFO_TABLE(BCO_info,BCO_entry,0,0,BCO,const,EF_,0,0);
 204 EF_(BCO_entry) {
 205   FB_
 206     Sp -= 1;
 207     Sp[0] = R1.w;
 208     JMP_(stg_yield_to_Hugs);
 209   FE_
 210 }
 211
 212 /* -----------------------------------------------------------------------------
 213    Some static info tables for things that don't get entered, and
 214    therefore don't need entry code (i.e. boxed but unpointed objects)
 215    -------------------------------------------------------------------------- */
 216
 217 #define NON_ENTERABLE_ENTRY_CODE(type)                                  \
 218 STGFUN(type##_entry)                                                    \
 219 {                                                                       \
 220   FB_                                                                   \
 221     STGCALL1(fflush,stdout);                                            \
 222     STGCALL2(fprintf,stderr,#type " object entered!\n");                \
 223     STGCALL1(raiseError, errorHandler);                                 \
 224     stg_exit(EXIT_FAILURE); /* not executed */                          \
 225   FE_                                                                   \
 226 }
 227
 228 INFO_TABLE(TSO_info, TSO_entry, 0,0,TSO,const,EF_,0,0);
 229 NON_ENTERABLE_ENTRY_CODE(TSO);
 230
 231 /* -----------------------------------------------------------------------------
 232    Evacuees are left behind by the garbage collector.  Any attempt to enter
 233    one is a real bug.
 234    -------------------------------------------------------------------------- */
 235
 236 INFO_TABLE(EVACUATED_info,EVACUATED_entry,1,0,EVACUATED,const,EF_,0,0);
 237 NON_ENTERABLE_ENTRY_CODE(EVACUATED);
 238
 239 /* -----------------------------------------------------------------------------
 240    Weak pointers
 241
 242    Live weak pointers have a special closure type.  Dead ones are just
 243    nullary constructors (although they live on the heap - we overwrite
 244    live weak pointers with dead ones).
 245    -------------------------------------------------------------------------- */
 246
 247 INFO_TABLE(WEAK_info,WEAK_entry,0,4,WEAK,const,EF_,0,0);
 248 NON_ENTERABLE_ENTRY_CODE(WEAK);
 249
 250 INFO_TABLE_CONSTR(DEAD_WEAK_info,DEAD_WEAK_entry,0,1,0,CONSTR,const,EF_,0,0);
 251 NON_ENTERABLE_ENTRY_CODE(DEAD_WEAK);
 252
 253 /* -----------------------------------------------------------------------------
 254    NO_FINALIZER
 255
 256    This is a static nullary constructor (like []) that we use to mark an empty
 257    finalizer in a weak pointer object.
 258    -------------------------------------------------------------------------- */
 259
 260 INFO_TABLE_CONSTR(NO_FINALIZER_info,NO_FINALIZER_entry,0,0,0,CONSTR_NOCAF_STATIC,const,EF_,0,0);
 261 NON_ENTERABLE_ENTRY_CODE(NO_FINALIZER);
 262
 263 SET_STATIC_HDR(NO_FINALIZER_closure,NO_FINALIZER_info,0/*CC*/,,EI_)
 264 };
 265
 266 /* -----------------------------------------------------------------------------
 267    Foreign Objects are unlifted and therefore never entered.
 268    -------------------------------------------------------------------------- */
 269
 270 INFO_TABLE(FOREIGN_info,FOREIGN_entry,0,1,FOREIGN,const,EF_,0,0);
 271 NON_ENTERABLE_ENTRY_CODE(FOREIGN);
 272
 273 /* -----------------------------------------------------------------------------
 274    Stable Names are unlifted too.
 275    -------------------------------------------------------------------------- */
 276
 277 INFO_TABLE(STABLE_NAME_info,STABLE_NAME_entry,0,1,STABLE_NAME,const,EF_,0,0);
 278 NON_ENTERABLE_ENTRY_CODE(STABLE_NAME);
 279
 280 /* -----------------------------------------------------------------------------
 281    MVars
 282
 283    There are two kinds of these: full and empty.  We need an info table
 284    and entry code for each type.
 285    -------------------------------------------------------------------------- */
 286
 287 INFO_TABLE(FULL_MVAR_info,FULL_MVAR_entry,4,0,MVAR,const,EF_,0,0);
 288 NON_ENTERABLE_ENTRY_CODE(FULL_MVAR);
 289
 290 INFO_TABLE(EMPTY_MVAR_info,EMPTY_MVAR_entry,4,0,MVAR,const,EF_,0,0);
 291 NON_ENTERABLE_ENTRY_CODE(EMPTY_MVAR);
 292
 293 /* -----------------------------------------------------------------------------
 294    END_TSO_QUEUE
 295
 296    This is a static nullary constructor (like []) that we use to mark the
 297    end of a linked TSO queue.
 298    -------------------------------------------------------------------------- */
 299
 300 INFO_TABLE_CONSTR(END_TSO_QUEUE_info,END_TSO_QUEUE_entry,0,0,0,CONSTR_NOCAF_STATIC,const,EF_,0,0);
 301 NON_ENTERABLE_ENTRY_CODE(END_TSO_QUEUE);
 302
 303 SET_STATIC_HDR(END_TSO_QUEUE_closure,END_TSO_QUEUE_info,0/*CC*/,,EI_)
 304 };
 305
 306 /* -----------------------------------------------------------------------------
 307    Mutable lists
 308
 309    Mutable lists (used by the garbage collector) consist of a chain of
 310    StgMutClosures connected through their mut_link fields, ending in
 311    an END_MUT_LIST closure.
 312    -------------------------------------------------------------------------- */
 313
 314 INFO_TABLE_CONSTR(END_MUT_LIST_info,END_MUT_LIST_entry,0,0,0,CONSTR_NOCAF_STATIC,const,EF_,0,0);
 315 NON_ENTERABLE_ENTRY_CODE(END_MUT_LIST);
 316
 317 SET_STATIC_HDR(END_MUT_LIST_closure,END_MUT_LIST_info,0/*CC*/,,EI_)
 318 };
 319
 320 INFO_TABLE(MUT_CONS_info, MUT_CONS_entry, 1, 1, MUT_VAR, const, EF_, 0, 0);
 321 NON_ENTERABLE_ENTRY_CODE(MUT_CONS);
 322
 323 /* -----------------------------------------------------------------------------
 324    Arrays
 325
 326    These come in two basic flavours: arrays of data (StgArrWords) and arrays of
 327    pointers (StgArrPtrs).  They all have a similar layout:
 328
 329         ___________________________
 330         | Info | No. of | data....
 331         |  Ptr | Words  |
 332         ---------------------------
 333
 334    These are *unpointed* objects: i.e. they cannot be entered.
 335
 336    -------------------------------------------------------------------------- */
 337
 338 #define ArrayInfo(type)                                 \
 339 INFO_TABLE(type##_info, type##_entry, 0, 0, type, const, EF_,0,0);
 340
 341 ArrayInfo(ARR_WORDS);
 342 NON_ENTERABLE_ENTRY_CODE(ARR_WORDS);
 343 ArrayInfo(MUT_ARR_PTRS);
 344 NON_ENTERABLE_ENTRY_CODE(MUT_ARR_PTRS);
 345 ArrayInfo(MUT_ARR_PTRS_FROZEN);
 346 NON_ENTERABLE_ENTRY_CODE(MUT_ARR_PTRS_FROZEN);
 347
 348 #undef ArrayInfo
 349
 350 /* -----------------------------------------------------------------------------
 351    Mutable Variables
 352    -------------------------------------------------------------------------- */
 353
 354 INFO_TABLE(MUT_VAR_info, MUT_VAR_entry, 1, 1, MUT_VAR, const, EF_, 0, 0);
 355 NON_ENTERABLE_ENTRY_CODE(MUT_VAR);
 356
 357 /* -----------------------------------------------------------------------------
 358    Standard Error Entry.
 359
 360    This is used for filling in vector-table entries that can never happen,
 361    for instance.
 362    -------------------------------------------------------------------------- */
 363
 364 STGFUN(stg_error_entry)                                                 \
 365 {                                                                       \
 366   FB_                                                                   \
 367     STGCALL1(fflush,stdout);                                            \
 368     STGCALL2(fprintf,stderr,"fatal: stg_error_entry");                  \
 369     STGCALL1(raiseError, errorHandler);                                 \
 370     exit(EXIT_FAILURE); /* not executed */                              \
 371   FE_                                                                   \
 372 }
 373
 374 /* -----------------------------------------------------------------------------
 375    Dummy return closure
 376
 377    Entering this closure will just return to the address on the top of the
 378    stack.  Useful for getting a thread in a canonical form where we can
 379    just enter the top stack word to start the thread.  (see deleteThread)
 380  * -------------------------------------------------------------------------- */
 381
 382 INFO_TABLE(dummy_ret_info, dummy_ret_entry, 0, 0, CONSTR_NOCAF_STATIC, const, EF_, 0, 0);
 383 FN_(dummy_ret_entry)
 384 {
 385   W_ ret_addr;
 386   FB_
 387   ret_addr = Sp[0];
 388   Sp++;
 389   JMP_(ENTRY_CODE(ret_addr));
 390   FE_
 391 }
 392 SET_STATIC_HDR(dummy_ret_closure,dummy_ret_info,CCS_DONTZuCARE,,EI_)
 393 };
 394
 395 /* -----------------------------------------------------------------------------
 396    Standard Infotables (for use in interpreter)
 397    -------------------------------------------------------------------------- */
 398
 399 #ifdef INTERPRETER
 400
 401 STGFUN(Hugs_CONSTR_entry)
 402 {
 403     Sp -= 1;
 404     ((StgPtr*)Sp)[0] = R1.p;
 405     /* vectored: JMP_(RET_VEC(((StgPtr*)Sp)[1],constrTag(?))); */
 406     JMP_(ENTRY_CODE(((StgPtr*)Sp)[1]));
 407 }
 408
 409 #define RET_BCO_ENTRY_TEMPLATE(label)   \
 410    IFN_(label)                          \
 411    {                                    \
 412       FB_                               \
 413       Sp -= 1;                          \
 414       ((StgPtr*)Sp)[0] = R1.p;          \
 415       JMP_(stg_yield_to_Hugs);          \
 416       FE_                               \
 417    }
 418
 419 RET_BCO_ENTRY_TEMPLATE(ret_bco_entry  );
 420 RET_BCO_ENTRY_TEMPLATE(ret_bco_0_entry);
 421 RET_BCO_ENTRY_TEMPLATE(ret_bco_1_entry);
 422 RET_BCO_ENTRY_TEMPLATE(ret_bco_2_entry);
 423 RET_BCO_ENTRY_TEMPLATE(ret_bco_3_entry);
 424 RET_BCO_ENTRY_TEMPLATE(ret_bco_4_entry);
 425 RET_BCO_ENTRY_TEMPLATE(ret_bco_5_entry);
 426 RET_BCO_ENTRY_TEMPLATE(ret_bco_6_entry);
 427 RET_BCO_ENTRY_TEMPLATE(ret_bco_7_entry);
 428
 429 VEC_POLY_INFO_TABLE(ret_bco,0, NULL/*srt*/, 0/*srt_off*/, 0/*srt_len*/, RET_BCO);
 430
 431 #endif /* INTERPRETER */
 432
 433 #ifndef COMPILER
 434
 435 INFO_TABLE_CONSTR(Czh_con_info,Hugs_CONSTR_entry,0,sizeofW(StgChar),0,CONSTR,const,EF_,0,0);
 436 INFO_TABLE_CONSTR(Izh_con_info,Hugs_CONSTR_entry,0,sizeofW(StgInt),0,CONSTR,const,EF_,0,0);
 437 INFO_TABLE_CONSTR(I64zh_con_info,Hugs_CONSTR_entry,0,sizeofW(StgInt64),0,CONSTR,const,EF_,0,0);
 438 INFO_TABLE_CONSTR(Fzh_con_info,Hugs_CONSTR_entry,0,sizeofW(StgFloat),0,CONSTR,const,EF_,0,0);
 439 INFO_TABLE_CONSTR(Dzh_con_info,Hugs_CONSTR_entry,0,sizeofW(StgDouble),0,CONSTR,const,EF_,0,0);
 440 INFO_TABLE_CONSTR(Azh_con_info,Hugs_CONSTR_entry,0,sizeofW(StgAddr),0,CONSTR,const,EF_,0,0);
 441 INFO_TABLE_CONSTR(Wzh_con_info,Hugs_CONSTR_entry,0,sizeofW(StgWord),0,CONSTR,const,EF_,0,0);
 442 INFO_TABLE_CONSTR(StablePtr_con_info,Hugs_CONSTR_entry,0,sizeofW(StgStablePtr),0,CONSTR,const,EF_,0,0);
 443
 444 /* These might seem redundant but {I,C}zh_static_info are used in
 445  * {INT,CHAR}LIKE and the rest are used in RtsAPI.c
 446  */
 447 INFO_TABLE_CONSTR(Czh_static_info,Hugs_CONSTR_entry,0,sizeofW(StgChar),0,CONSTR_NOCAF_STATIC,const,EF_,0,0);
 448 INFO_TABLE_CONSTR(Izh_static_info,Hugs_CONSTR_entry,0,sizeofW(StgInt),0,CONSTR_NOCAF_STATIC,const,EF_,0,0);
 449 INFO_TABLE_CONSTR(I64zh_static_info,Hugs_CONSTR_entry,0,sizeofW(StgInt64),0,CONSTR_NOCAF_STATIC,const,EF_,0,0);
 450 INFO_TABLE_CONSTR(Fzh_static_info,Hugs_CONSTR_entry,0,sizeofW(StgFloat),0,CONSTR_NOCAF_STATIC,const,EF_,0,0);
 451 INFO_TABLE_CONSTR(Dzh_static_info,Hugs_CONSTR_entry,0,sizeofW(StgDouble),0,CONSTR_NOCAF_STATIC,const,EF_,0,0);
 452 INFO_TABLE_CONSTR(Azh_static_info,Hugs_CONSTR_entry,0,sizeofW(StgAddr),0,CONSTR_NOCAF_STATIC,const,EF_,0,0);
 453 INFO_TABLE_CONSTR(Wzh_static_info,Hugs_CONSTR_entry,0,sizeofW(StgWord),0,CONSTR_NOCAF_STATIC,const,EF_,0,0);
 454 INFO_TABLE_CONSTR(StablePtr_static_info,Hugs_CONSTR_entry,0,sizeofW(StgStablePtr),0,CONSTR_NOCAF_STATIC,const,EF_,0,0);
 455
 456 #endif /* !defined(COMPILER) */
 457
 458 /* -----------------------------------------------------------------------------
 459    CHARLIKE and INTLIKE closures.
 460
 461    These are static representations of Chars and small Ints, so that
 462    we can remove dynamic Chars and Ints during garbage collection and
 463    replace them with references to the static objects.
 464    -------------------------------------------------------------------------- */
 465
 466 #ifdef HAVE_WIN32_DLL_SUPPORT
 467 /*
 468  * When sticking the RTS in a DLL, we delay populating the
 469  * Charlike and Intlike tables until load-time, which is only
 470  * when we've got the real addresses to the C# and I# closures.
 471  *
 472  */
 473 static const StgInfoTable czh_static_info;
 474 static const StgInfoTable izh_static_info;
 475 #define Char_hash_static_info czh_static_info
 476 #define Int_hash_static_info izh_static_info
 477 #else
 478 #define Char_hash_static_info Czh_static_info
 479 #define Int_hash_static_info Izh_static_info
 480 #endif
 481
 482 #define CHARLIKE_HDR(n)                                         \
 483         {                                                       \
 484           STATIC_HDR(Char_hash_static_info, /* C# */            \
 485                          CCS_DONTZuCARE),                       \
 486           data : n                                              \
 487         }
 488
 489 #define INTLIKE_HDR(n)                                          \
 490         {                                                       \
 491           STATIC_HDR(Int_hash_static_info,  /* I# */            \
 492                          CCS_DONTZuCARE),                       \
 493           data : n                                              \
 494         }
 495
 496 /* put these in the *data* section, since the garbage collector relies
 497  * on the fact that static closures live in the data section.
 498  */
 499
 500 /* end the name with _closure, to convince the mangler this is a closure */
 501
 502 StgIntCharlikeClosure CHARLIKE_closure[] = {
 503     CHARLIKE_HDR(0),
 504     CHARLIKE_HDR(1),
 505     CHARLIKE_HDR(2),
 506     CHARLIKE_HDR(3),
 507     CHARLIKE_HDR(4),
 508     CHARLIKE_HDR(5),
 509     CHARLIKE_HDR(6),
 510     CHARLIKE_HDR(7),
 511     CHARLIKE_HDR(8),
 512     CHARLIKE_HDR(9),
 513     CHARLIKE_HDR(10),
 514     CHARLIKE_HDR(11),
 515     CHARLIKE_HDR(12),
 516     CHARLIKE_HDR(13),
 517     CHARLIKE_HDR(14),
 518     CHARLIKE_HDR(15),
 519     CHARLIKE_HDR(16),
 520     CHARLIKE_HDR(17),
 521     CHARLIKE_HDR(18),
 522     CHARLIKE_HDR(19),
 523     CHARLIKE_HDR(20),
 524     CHARLIKE_HDR(21),
 525     CHARLIKE_HDR(22),
 526     CHARLIKE_HDR(23),
 527     CHARLIKE_HDR(24),
 528     CHARLIKE_HDR(25),
 529     CHARLIKE_HDR(26),
 530     CHARLIKE_HDR(27),
 531     CHARLIKE_HDR(28),
 532     CHARLIKE_HDR(29),
 533     CHARLIKE_HDR(30),
 534     CHARLIKE_HDR(31),
 535     CHARLIKE_HDR(32),
 536     CHARLIKE_HDR(33),
 537     CHARLIKE_HDR(34),
 538     CHARLIKE_HDR(35),
 539     CHARLIKE_HDR(36),
 540     CHARLIKE_HDR(37),
 541     CHARLIKE_HDR(38),
 542     CHARLIKE_HDR(39),
 543     CHARLIKE_HDR(40),
 544     CHARLIKE_HDR(41),
 545     CHARLIKE_HDR(42),
 546     CHARLIKE_HDR(43),
 547     CHARLIKE_HDR(44),
 548     CHARLIKE_HDR(45),
 549     CHARLIKE_HDR(46),
 550     CHARLIKE_HDR(47),
 551     CHARLIKE_HDR(48),
 552     CHARLIKE_HDR(49),
 553     CHARLIKE_HDR(50),
 554     CHARLIKE_HDR(51),
 555     CHARLIKE_HDR(52),
 556     CHARLIKE_HDR(53),
 557     CHARLIKE_HDR(54),
 558     CHARLIKE_HDR(55),
 559     CHARLIKE_HDR(56),
 560     CHARLIKE_HDR(57),
 561     CHARLIKE_HDR(58),
 562     CHARLIKE_HDR(59),
 563     CHARLIKE_HDR(60),
 564     CHARLIKE_HDR(61),
 565     CHARLIKE_HDR(62),
 566     CHARLIKE_HDR(63),
 567     CHARLIKE_HDR(64),
 568     CHARLIKE_HDR(65),
 569     CHARLIKE_HDR(66),
 570     CHARLIKE_HDR(67),
 571     CHARLIKE_HDR(68),
 572     CHARLIKE_HDR(69),
 573     CHARLIKE_HDR(70),
 574     CHARLIKE_HDR(71),
 575     CHARLIKE_HDR(72),
 576     CHARLIKE_HDR(73),
 577     CHARLIKE_HDR(74),
 578     CHARLIKE_HDR(75),
 579     CHARLIKE_HDR(76),
 580     CHARLIKE_HDR(77),
 581     CHARLIKE_HDR(78),
 582     CHARLIKE_HDR(79),
 583     CHARLIKE_HDR(80),
 584     CHARLIKE_HDR(81),
 585     CHARLIKE_HDR(82),
 586     CHARLIKE_HDR(83),
 587     CHARLIKE_HDR(84),
 588     CHARLIKE_HDR(85),
 589     CHARLIKE_HDR(86),
 590     CHARLIKE_HDR(87),
 591     CHARLIKE_HDR(88),
 592     CHARLIKE_HDR(89),
 593     CHARLIKE_HDR(90),
 594     CHARLIKE_HDR(91),
 595     CHARLIKE_HDR(92),
 596     CHARLIKE_HDR(93),
 597     CHARLIKE_HDR(94),
 598     CHARLIKE_HDR(95),
 599     CHARLIKE_HDR(96),
 600     CHARLIKE_HDR(97),
 601     CHARLIKE_HDR(98),
 602     CHARLIKE_HDR(99),
 603     CHARLIKE_HDR(100),
 604     CHARLIKE_HDR(101),
 605     CHARLIKE_HDR(102),
 606     CHARLIKE_HDR(103),
 607     CHARLIKE_HDR(104),
 608     CHARLIKE_HDR(105),
 609     CHARLIKE_HDR(106),
 610     CHARLIKE_HDR(107),
 611     CHARLIKE_HDR(108),
 612     CHARLIKE_HDR(109),
 613     CHARLIKE_HDR(110),
 614     CHARLIKE_HDR(111),
 615     CHARLIKE_HDR(112),
 616     CHARLIKE_HDR(113),
 617     CHARLIKE_HDR(114),
 618     CHARLIKE_HDR(115),
 619     CHARLIKE_HDR(116),
 620     CHARLIKE_HDR(117),
 621     CHARLIKE_HDR(118),
 622     CHARLIKE_HDR(119),
 623     CHARLIKE_HDR(120),
 624     CHARLIKE_HDR(121),
 625     CHARLIKE_HDR(122),
 626     CHARLIKE_HDR(123),
 627     CHARLIKE_HDR(124),
 628     CHARLIKE_HDR(125),
 629     CHARLIKE_HDR(126),
 630     CHARLIKE_HDR(127),
 631     CHARLIKE_HDR(128),
 632     CHARLIKE_HDR(129),
 633     CHARLIKE_HDR(130),
 634     CHARLIKE_HDR(131),
 635     CHARLIKE_HDR(132),
 636     CHARLIKE_HDR(133),
 637     CHARLIKE_HDR(134),
 638     CHARLIKE_HDR(135),
 639     CHARLIKE_HDR(136),
 640     CHARLIKE_HDR(137),
 641     CHARLIKE_HDR(138),
 642     CHARLIKE_HDR(139),
 643     CHARLIKE_HDR(140),
 644     CHARLIKE_HDR(141),
 645     CHARLIKE_HDR(142),
 646     CHARLIKE_HDR(143),
 647     CHARLIKE_HDR(144),
 648     CHARLIKE_HDR(145),
 649     CHARLIKE_HDR(146),
 650     CHARLIKE_HDR(147),
 651     CHARLIKE_HDR(148),
 652     CHARLIKE_HDR(149),
 653     CHARLIKE_HDR(150),
 654     CHARLIKE_HDR(151),
 655     CHARLIKE_HDR(152),
 656     CHARLIKE_HDR(153),
 657     CHARLIKE_HDR(154),
 658     CHARLIKE_HDR(155),
 659     CHARLIKE_HDR(156),
 660     CHARLIKE_HDR(157),
 661     CHARLIKE_HDR(158),
 662     CHARLIKE_HDR(159),
 663     CHARLIKE_HDR(160),
 664     CHARLIKE_HDR(161),
 665     CHARLIKE_HDR(162),
 666     CHARLIKE_HDR(163),
 667     CHARLIKE_HDR(164),
 668     CHARLIKE_HDR(165),
 669     CHARLIKE_HDR(166),
 670     CHARLIKE_HDR(167),
 671     CHARLIKE_HDR(168),
 672     CHARLIKE_HDR(169),
 673     CHARLIKE_HDR(170),
 674     CHARLIKE_HDR(171),
 675     CHARLIKE_HDR(172),
 676     CHARLIKE_HDR(173),
 677     CHARLIKE_HDR(174),
 678     CHARLIKE_HDR(175),
 679     CHARLIKE_HDR(176),
 680     CHARLIKE_HDR(177),
 681     CHARLIKE_HDR(178),
 682     CHARLIKE_HDR(179),
 683     CHARLIKE_HDR(180),
 684     CHARLIKE_HDR(181),
 685     CHARLIKE_HDR(182),
 686     CHARLIKE_HDR(183),
 687     CHARLIKE_HDR(184),
 688     CHARLIKE_HDR(185),
 689     CHARLIKE_HDR(186),
 690     CHARLIKE_HDR(187),
 691     CHARLIKE_HDR(188),
 692     CHARLIKE_HDR(189),
 693     CHARLIKE_HDR(190),
 694     CHARLIKE_HDR(191),
 695     CHARLIKE_HDR(192),
 696     CHARLIKE_HDR(193),
 697     CHARLIKE_HDR(194),
 698     CHARLIKE_HDR(195),
 699     CHARLIKE_HDR(196),
 700     CHARLIKE_HDR(197),
 701     CHARLIKE_HDR(198),
 702     CHARLIKE_HDR(199),
 703     CHARLIKE_HDR(200),
 704     CHARLIKE_HDR(201),
 705     CHARLIKE_HDR(202),
 706     CHARLIKE_HDR(203),
 707     CHARLIKE_HDR(204),
 708     CHARLIKE_HDR(205),
 709     CHARLIKE_HDR(206),
 710     CHARLIKE_HDR(207),
 711     CHARLIKE_HDR(208),
 712     CHARLIKE_HDR(209),
 713     CHARLIKE_HDR(210),
 714     CHARLIKE_HDR(211),
 715     CHARLIKE_HDR(212),
 716     CHARLIKE_HDR(213),
 717     CHARLIKE_HDR(214),
 718     CHARLIKE_HDR(215),
 719     CHARLIKE_HDR(216),
 720     CHARLIKE_HDR(217),
 721     CHARLIKE_HDR(218),
 722     CHARLIKE_HDR(219),
 723     CHARLIKE_HDR(220),
 724     CHARLIKE_HDR(221),
 725     CHARLIKE_HDR(222),
 726     CHARLIKE_HDR(223),
 727     CHARLIKE_HDR(224),
 728     CHARLIKE_HDR(225),
 729     CHARLIKE_HDR(226),
 730     CHARLIKE_HDR(227),
 731     CHARLIKE_HDR(228),
 732     CHARLIKE_HDR(229),
 733     CHARLIKE_HDR(230),
 734     CHARLIKE_HDR(231),
 735     CHARLIKE_HDR(232),
 736     CHARLIKE_HDR(233),
 737     CHARLIKE_HDR(234),
 738     CHARLIKE_HDR(235),
 739     CHARLIKE_HDR(236),
 740     CHARLIKE_HDR(237),
 741     CHARLIKE_HDR(238),
 742     CHARLIKE_HDR(239),
 743     CHARLIKE_HDR(240),
 744     CHARLIKE_HDR(241),
 745     CHARLIKE_HDR(242),
 746     CHARLIKE_HDR(243),
 747     CHARLIKE_HDR(244),
 748     CHARLIKE_HDR(245),
 749     CHARLIKE_HDR(246),
 750     CHARLIKE_HDR(247),
 751     CHARLIKE_HDR(248),
 752     CHARLIKE_HDR(249),
 753     CHARLIKE_HDR(250),
 754     CHARLIKE_HDR(251),
 755     CHARLIKE_HDR(252),
 756     CHARLIKE_HDR(253),
 757     CHARLIKE_HDR(254),
 758     CHARLIKE_HDR(255)
 759 };
 760
 761 StgIntCharlikeClosure INTLIKE_closure[] = {
 762     INTLIKE_HDR(-16),   /* MIN_INTLIKE == -16 */
 763     INTLIKE_HDR(-15),
 764     INTLIKE_HDR(-14),
 765     INTLIKE_HDR(-13),
 766     INTLIKE_HDR(-12),
 767     INTLIKE_HDR(-11),
 768     INTLIKE_HDR(-10),
 769     INTLIKE_HDR(-9),
 770     INTLIKE_HDR(-8),
 771     INTLIKE_HDR(-7),
 772     INTLIKE_HDR(-6),
 773     INTLIKE_HDR(-5),
 774     INTLIKE_HDR(-4),
 775     INTLIKE_HDR(-3),
 776     INTLIKE_HDR(-2),
 777     INTLIKE_HDR(-1),
 778     INTLIKE_HDR(0),
 779     INTLIKE_HDR(1),
 780     INTLIKE_HDR(2),
 781     INTLIKE_HDR(3),
 782     INTLIKE_HDR(4),
 783     INTLIKE_HDR(5),
 784     INTLIKE_HDR(6),
 785     INTLIKE_HDR(7),
 786     INTLIKE_HDR(8),
 787     INTLIKE_HDR(9),
 788     INTLIKE_HDR(10),
 789     INTLIKE_HDR(11),
 790     INTLIKE_HDR(12),
 791     INTLIKE_HDR(13),
 792     INTLIKE_HDR(14),
 793     INTLIKE_HDR(15),
 794     INTLIKE_HDR(16)     /* MAX_INTLIKE == 16 */
 795 };