ghc/rts/StgMiscClosures.hc

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