ghc/rts/StgMiscClosures.hc

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