ghc/rts/StgMiscClosures.hc

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