ghc/rts/StgMiscClosures.hc

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