ghc/rts/StgMiscClosures.hc

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