ghc/rts/StgMiscClosures.hc

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