ghc/includes/SMInfoTables.lh

   1 %
   2 % (c) The OBFUSCATION-THROUGH-GRATUITOUS-PREPROCESSOR-ABUSE Project,
   3 %     Glasgow University, 1990-1994
   4 %
   5 %************************************************************************
   6 %*                                                                      *
   7 \section[info-table-macros]{Info-table macros}
   8 %*                                                                      *
   9 %************************************************************************
  10
  11 We define {\em info tables} here.  First, all the different pieces of
  12 an info table (entry code, evac code, etc.); then all the different
  13 kinds of info tables (SPEC, DYN, etc).  NB: some of the parallel-only
  14 kinds are defined in \tr{Parallel.lh}, not here.
  15
  16 An info-table contains several fields. The first field is
  17 the label of the closure's {\em standard-entry code}. This is used by
  18 the reducer to ``evaluate'' the closure. The remaining fields are used
  19 by the garbage collector and other parts of the runtime
  20 system. Info-tables are declared using the C macros defined below.
  21 The details of the contents are determined by the storage manager and
  22 are not of interest outside it.
  23
  24 Info tables may either be {\em reversed} or not.  Reversed is normal
  25 and preferred, but it requires ``assembler mangling'' of the C
  26 compiler output.  (The native-code generator does reversed info-tables
  27 automagically.) With reversed info tables, (a)~the words are reversed
  28 [obviously], (b)~the info-table's C label addresses the word {\em just
  29 after} the info table (where its associated entry code ``happens to be''),
  30 and (c)~the entry-code word in the info table is omitted (it's
  31 vestigial).
  32
  33 Info-table reversal is hidden behind the @IREL@ macro.
  34
  35 The following fields are used when defining particular info-tables.
  36 Some sorts of info-table (e.g. @FETCHME_ITBL@) don't need all these
  37 fields to be specified.
  38
  39 \begin{description}
  40 \item[@infolbl@]
  41 The name used to create labels for the info-table, profiling
  42 information, etc.
  43
  44 \item[\tr{entry_code}:]
  45 The function which is called when entering the closure.
  46
  47 \item[\tr{update_code}:]
  48 The function which is called when updating the closure (constructors only).
  49
  50 \item[\tr{tag}:]
  51 (So much for the Spineless {\em Tagless} G-Machine...)  Used for
  52 semi-tagging checks.
  53
  54 \item[\tr{type}:]
  55 Similar-but-different info to the \tr{tag} stuff; the
  56 parallel world needs more elaborate info.
  57
  58 \item[\tr{size}:]
  59 The size of the closure (see \tr{SMClosures.lh} for a precise
  60 definition of ``size'').  Used by the garbage-collector, not the
  61 Haskell reducer.
  62
  63 \item[\tr{ptrs}:]
  64 The number of pointers in the closure.  Used by the garbage-collector,
  65 not the Haskell reducer.
  66
  67 \item[@localness@]
  68 Whether the info-table is local to this module or not.
  69 The field is set to @static@ if the info-table is
  70 local, and is empty otherwise.
  71
  72 \item[@entry_localness@]
  73 Whether the @entry_code@ routine is local to this module or not.
  74 This field can have the following values:
  75   \begin{description}
  76   \item [@EXTFUN@]
  77   The entry code is global.
  78   \item [@INTFUN@]
  79   The entry code is local.
  80   \end{description}
  81
  82 \item[@kind@]
  83 This identifies the general sort of the closure for profiling purposes.
  84 It can have the following values (defined in CostCentre.lh):
  85
  86   \begin{description}
  87   \item[@CON_K@]
  88   A constructor.
  89   \item[@FN_K@]
  90   A literal function.
  91   \item[@PAP_K@]
  92   A partial application.
  93   \item[@THK_K@]
  94   A thunk, or suspension.
  95   \item[@BH_K@]
  96   A black hole.
  97   \item[@ARR_K@]
  98   An array.
  99   \item[@MP_K@]
 100   A Malloc Pointer.
 101   \item[@SPT_K@]
 102   The Stable Pointer table.  (There should only be one of these but it
 103   represents a form of weak space leak since it can't shrink to meet
 104   non-demand so it may be worth watching separately? ADR)
 105   \item[@INTERNAL_KIND@]
 106   Something internal to the runtime system.
 107   \end{description}
 108
 109 \item[@descr@]
 110 This is a string used to identify the closure for profiling purposes.
 111 \end{description}
 112
 113 So, for example:
 114 \begin{pseudocode}
 115 SPEC_N_ITBL(RBH_Save_0_info,RBH_Save_0_entry,UpdErr,0,INFO_OTHER_TAG,2,0,,IF_,INTERNAL_KIND,"RBH-SAVE","RBH_Save_0");
 116 \end{pseudocode}
 117
 118 %************************************************************************
 119 %*                                                                      *
 120 \subsection[info-table-common-up]{The commoned-up info-table world}
 121 %*                                                                      *
 122 %************************************************************************
 123
 124 Since lots of info-tables share the same information (which doesn't
 125 change at run time) needlessly, we gather this common information
 126 together into a rep-table.
 127
 128 Conditionally present data (concerning the parallel world, and also
 129 information for the collectors) are gathered into unique rep-tables,
 130 which are pointed to from info-tables.  This saves several words for
 131 each closure we build, at the cost of making garbage collection and
 132 fetching of data from info-tables a little more hairy.
 133
 134 Size and pointers fields go away altogether, save for @GEN@ closures
 135 where they are tacked on to the end of info-tables.
 136
 137 %************************************************************************
 138 %*                                                                      *
 139 \subsection[info-table-common]{Bits common to all info-tables}
 140 %*                                                                      *
 141 %************************************************************************
 142
 143 The entry code for a closure, its type, its ``size'', and the number
 144 of pointer-words it contains are the same in every info table.  For
 145 the parallel system, two flush code-entries are also standard.
 146
 147 Multi-slurp protection:
 148 \begin{code}
 149 #ifndef SMInfoTables_H
 150 #define SMInfoTables_H
 151 \end{code}
 152
 153 \begin{code}
 154 #ifdef __STG_REV_TBLS__
 155
 156 # define IREL(offset)   (-(offset))
 157
 158 /* NB: the ENT_ macro (StgMacros.lh) must also be changed */
 159
 160 # define ENTRY_CODE(infoptr)     ((F_)(infoptr))
 161
 162 #else /* boring non-reversed info tables */
 163
 164 # define IREL(offset)   (offset)
 165
 166 # define ENTRY_CODE(infoptr)     (((FP_)(infoptr))[IREL(0)])
 167
 168 #endif /* non-fixed size info tables */
 169 \end{code}
 170
 171 \begin{code}
 172 #define INFO_TAG(infoptr)       ((I_) ((P_)(infoptr))[IREL(1)])
 173 #define EVAL_TAG(infoptr)       (INFO_TAG(infoptr) >= 0)
 174 \end{code}
 175
 176 \begin{code}
 177
 178 #define INFO_INTERNAL           (~0L)   /* Should never see this */
 179
 180 #define INFO_UNUSED             (~0L)
 181 /* We'd like to see this go away in code pointer fields, with specialized code
 182    to print out an appropriate error message instead.
 183    WDP 94/11: At least make it an Obviously Weird Value?
 184  */
 185
 186 \end{code}
 187
 188
 189 %************************************************************************
 190 %*                                                                      *
 191 \subsection[info-table-rtbl]{Rep tables in an info table}
 192 %*                                                                      *
 193 %************************************************************************
 194
 195 Common information is pointed to by the rep table pointer.  We want to
 196 use extern declarations almost everywhere except for the single module
 197 (\tr{Rep.lc}) in which the rep tables are declared locally.
 198
 199 \begin{code}
 200 #if defined(COMPILING_REP_LC) || defined(COMPILING_GHC)
 201 # define MAYBE_DECLARE_RTBL(l,s,p)
 202 #else
 203 # define MAYBE_DECLARE_RTBL(l,s,p)      EXTDATA_RO(MK_REP_REF(l,s,p));
 204 #endif
 205
 206 #define INFO_RTBL(infoptr)      (((PP_)(infoptr))[IREL(2)])
 207 \end{code}
 208
 209 %************************************************************************
 210 %*                                                                      *
 211 \subsection{Maybe-there-maybe-not fields in an info table}
 212 %*                                                                      *
 213 %************************************************************************
 214
 215 That's about it for the fixed stuff...entry code, a tag and an RTBL pointer.
 216
 217 \begin{code}
 218 #define FIXED_INFO_WORDS                3
 219 \end{code}
 220
 221 %************************************************************************
 222 %*                                                                      *
 223 \subsubsection{Profiling-only fields in an info table}
 224 %*                                                                      *
 225 %************************************************************************
 226
 227 These macros result in the profiling kind and description string being
 228 included only if required.
 229 \begin{code}
 230 #define PROFILING_INFO_OFFSET  (FIXED_INFO_WORDS)
 231
 232 #if !defined(PROFILING)
 233 # define PROFILING_INFO_WORDS   0
 234 # define INCLUDE_PROFILING_INFO(base_name)
 235 # define INREGS_PROFILING_INFO
 236
 237 #else
 238 # define PROFILING_INFO_WORDS   1
 239
 240 # define INCLUDE_PROFILING_INFO(base_name) , (W_)REF_CAT_IDENT(base_name)
 241 # define INREGS_PROFILING_INFO  ,INFO_UNUSED
 242
 243 # define INFO_CAT(infoptr)  (((ClCategory *)(infoptr))[IREL(PROFILING_INFO_OFFSET)])
 244
 245 #endif
 246 \end{code}
 247
 248 %************************************************************************
 249 %*                                                                      *
 250 \subsubsection{Non-standard fields in an info table: where they'll be}
 251 %*                                                                      *
 252 %************************************************************************
 253
 254 The @UPDATE_CODE@ field is a pointer to the update code for a constructor.
 255 I believe that constructors are always of the following types:
 256
 257 \begin{itemize}
 258 \item @CHARLIKE@
 259 \item @CONST@
 260 \item @GEN_N@
 261 \item @INTLIKE@
 262 \item @SPEC_N@
 263 \item @STATIC@
 264 \end{itemize}
 265
 266 Info tables for these types have non-standard update code fields.  In addition,
 267 because @GEN@ closures have further non-standard fields (size, ptrs), the
 268 info tables for @GEN_U@ closures also have a non-standard update code field
 269 (which is filled in with @StdErrorCode@).
 270
 271 When we're in the parallel world, we also have to know which registers are
 272 live when we're returning a constructor in registers, so we have a second
 273 word for that as well.
 274
 275 \begin{code}
 276
 277 #define UPDATE_INFO_OFFSET  (PROFILING_INFO_OFFSET+PROFILING_INFO_WORDS)
 278
 279 #ifndef PAR
 280 # define UPDATE_INFO_WORDS    1
 281 # define INCLUDE_UPDATE_INFO(upd,live)  ,(W_)upd
 282 #else
 283 # define UPDATE_INFO_WORDS    2
 284 # define INCLUDE_UPDATE_INFO(upd,live)  ,(W_)upd,(W_)live
 285 #endif
 286
 287 #define UPDATE_CODE(infoptr)    (((FP_)(infoptr))[IREL(UPDATE_INFO_OFFSET)])
 288 #define INFO_LIVENESS(infoptr)  (((P_)(infoptr))[IREL(UPDATE_INFO_OFFSET+1)])
 289 \end{code}
 290
 291 @GEN@ closures have the size and number of pointers in the info table
 292 rather than the rep table.  These non-standard fields follow the update
 293 code field (which is only required for @GEN_N@ closures, but which we
 294 include in @GEN_U@ closures just to keep this other stuff at a consistent
 295 offset).
 296
 297 \begin{code}
 298 #define GEN_INFO_OFFSET     (UPDATE_INFO_OFFSET+UPDATE_INFO_WORDS)
 299 #define GEN_INFO_WORDS    2
 300 #define INCLUDE_GEN_INFO(size,ptrs)     ,(W_)size,(W_)ptrs
 301
 302 #define GEN_INFO_SIZE(infoptr)   ((I_)((P_)(infoptr))[IREL(GEN_INFO_OFFSET)])
 303 #define GEN_INFO_NoPTRS(infoptr) ((I_)((P_)(infoptr))[IREL(GEN_INFO_OFFSET+1)])
 304 \end{code}
 305
 306 @CONST@ closures have a pointer to a static version of the closure in their
 307 info tables.  This non-standard field follows their update code field.
 308
 309 \begin{code}
 310 #define CONST_INFO_OFFSET           (UPDATE_INFO_OFFSET+UPDATE_INFO_WORDS)
 311 #define CONST_INFO_WORDS    1
 312 #define INCLUDE_CONST_INFO(closure)     ,(W_)closure
 313
 314 #define CONST_STATIC_CLOSURE(infoptr)   (((PP_)(infoptr))[IREL(CONST_INFO_OFFSET)])
 315 \end{code}
 316
 317 @STATIC@ closures are like @GEN@ closures in that they also have the
 318 size and number of pointers in the info table rather than the rep
 319 table.  Again, these non-standard fields follow the update code field
 320 (which I believe is not actually needed for STATIC closures).
 321
 322 \begin{code}
 323 #define STATIC_INFO_OFFSET          (UPDATE_INFO_OFFSET+UPDATE_INFO_WORDS)
 324 #define STATIC_INFO_WORDS    2
 325 #define INCLUDE_STATIC_INFO(size,ptrs)  ,(W_)size,(W_)ptrs
 326
 327 #define STATIC_INFO_SIZE(infoptr)   ((I_)((P_)(infoptr))[IREL(STATIC_INFO_OFFSET)])
 328 #define STATIC_INFO_NoPTRS(infoptr) ((I_)((P_)(infoptr))[IREL(STATIC_INFO_OFFSET+1)])
 329 \end{code}
 330
 331 In the parallel system, all updatable closures have corresponding
 332 revertible black holes.  When we are assembly-mangling, we guarantee that
 333 the revertible black hole code precedes the normal entry code, so that
 334 the RBH info table resides at a fixed offset from the normal info table.
 335 Otherwise, we add the RBH info table pointer to the end of the normal
 336 info table and vice versa.
 337
 338 \begin{code}
 339 #ifdef PAR
 340 # define RBH_INFO_OFFSET            (GEN_INFO_OFFSET+GEN_INFO_WORDS)
 341
 342 # define INCLUDE_SPEC_PADDING                           \
 343         INCLUDE_UPDATE_INFO(INFO_UNUSED,INFO_UNUSED)    \
 344         INCLUDE_GEN_INFO(INFO_UNUSED,INFO_UNUSED)
 345
 346 # ifdef RBH_MAGIC_OFFSET
 347
 348 #  define RBH_INFO_WORDS    0
 349 #  define INCLUDE_RBH_INFO(infoptr)
 350
 351 #  define RBH_INFOPTR(infoptr)      (((P_)infoptr) - RBH_MAGIC_OFFSET)
 352 #  define REVERT_INFOPTR(infoptr)   (((P_)infoptr) + RBH_MAGIC_OFFSET)
 353
 354 # else
 355
 356 #  define RBH_INFO_WORDS    1
 357 #  define INCLUDE_RBH_INFO(infoptr) ,(W_)infoptr
 358
 359 #  define RBH_INFOPTR(infoptr)      (((PP_)(infoptr))[IREL(RBH_INFO_OFFSET)])
 360 #  define REVERT_INFOPTR(infoptr)   (((PP_)(infoptr))[IREL(RBH_INFO_OFFSET)])
 361
 362 # endif
 363
 364 EXTFUN(RBH_entry);
 365 P_ convertToRBH PROTO((P_ closure));
 366 void convertToFetchMe PROTO((P_ closure, globalAddr *ga));
 367 #endif
 368 \end{code}
 369
 370 %************************************************************************
 371 %*                                                                      *
 372 \subsection{Maybe-there-maybe-not fields in a rep table}
 373 %*                                                                      *
 374 %************************************************************************
 375
 376 %************************************************************************
 377 %*                                                                      *
 378 \subsubsection{Type field in a rep table}
 379 %*                                                                      *
 380 %************************************************************************
 381
 382 The @INFO_TYPE@ field in the rep table tells what sort of animal
 383 the closure is.
 384
 385 \begin{code}
 386 #define TYPE_INFO_OFFSET  0
 387 #define TYPE_INFO_WORDS    1
 388 #define INCLUDE_TYPE_INFO(kind) (W_)CAT3(INFO_,kind,_TYPE)
 389
 390 #define INFO_TYPE(infoptr)      (((P_)(INFO_RTBL(infoptr)))[TYPE_INFO_OFFSET])
 391 \end{code}
 392
 393 The least significant 9 bits of the info-type are used as follows:
 394
 395 \begin{tabular}{||l|l||}                                                   \hline
 396 Bit & Interpretation                                                    \\ \hline
 397 0   & 1 $\Rightarrow$ Head normal form                                  \\
 398 1   & 1 $\Rightarrow$ Don't spark me  (Any HNF will have this set to 1) \\
 399 2   & 1 $\Rightarrow$ This is a static closure                          \\
 400 3   & 1 $\Rightarrow$ Has mutable pointer fields \\
 401 4   & 1 $\Rightarrow$ May be updated (inconsistent with being a HNF) \\
 402 5   & 1 $\Rightarrow$ Is a "primitive" array (a BIG structure) \\
 403 6   & 1 $\Rightarrow$ Is a black hole                                   \\
 404 7   & 1 $\Rightarrow$ Is an indirection                                 \\
 405 8   & 1 $\Rightarrow$ Is a thunk                                        \\
 406 \hline
 407 \end{tabular}
 408
 409 Updatable structures (@_UP@) are thunks that may be shared.  Primitive
 410 arrays (@_BM@ -- Big Mothers) are structures that are always held
 411 in-memory (basically extensions of a closure).  Because there may be
 412 offsets into these arrays, a primitive array cannot be handled as a
 413 FetchMe in the parallel system, but must be shipped in its entirety if
 414 its parent closure is shipped.
 415
 416 \begin{code}
 417 #define IP_TAG_BITS             9
 418
 419 #define _NF                     0x0001  /* Normal form  */
 420 #define _NS                     0x0002  /* Don't spark  */
 421 #define _ST                     0x0004  /* Is static    */
 422 #define _MU                     0x0008  /* Is mutable   */
 423 #define _UP                     0x0010  /* Is updatable (but not mutable) */
 424 #define _BM                     0x0020  /* Is a "primitive" array */
 425 #define _BH                     0x0040  /* Is a black hole */
 426 #define _IN                     0x0080  /* Is an indirection */
 427 #define _TH                     0x0100  /* Is a thunk */
 428
 429 #define IS_NF(infoptr)          ((INFO_TYPE(infoptr)&_NF) != 0)
 430 #define IS_MUTABLE(infoptr)     ((INFO_TYPE(infoptr)&_MU) != 0)
 431 #define IS_STATIC(infoptr)      ((INFO_TYPE(infoptr)&_ST) != 0)
 432 #define IS_UPDATABLE(infoptr)   ((INFO_TYPE(infoptr)&_UP) != 0)
 433 #define IS_BIG_MOTHER(infoptr)  ((INFO_TYPE(infoptr)&_BM) != 0)
 434 #define IS_BLACK_HOLE(infoptr)  ((INFO_TYPE(infoptr)&_BH) != 0)
 435 #define IS_INDIRECTION(infoptr) ((INFO_TYPE(infoptr)&_IN) != 0)
 436 #define IS_THUNK(infoptr)       ((INFO_TYPE(infoptr)&_TH) != 0)
 437
 438 #define SHOULD_SPARK(closure)   ((INFO_TYPE(INFO_PTR(closure))&_NS) == 0)
 439 \end{code}
 440
 441 The other bits in the info-type field simply give a unique bit-pattern
 442 to identify the closure type.
 443
 444 \begin{code}
 445 #define IP_TAG_BIT_MASK         ((1L<<IP_TAG_BITS)-1)
 446
 447 #define BASE_INFO_TYPE(infoptr) (INFO_TYPE(infoptr) & (~IP_TAG_BIT_MASK)) /* Strips out the tag bits */
 448
 449 #define MAKE_BASE_INFO_TYPE(x)  ((x) << IP_TAG_BITS)
 450
 451 #define INFO_SPEC_TYPE          (MAKE_BASE_INFO_TYPE(1L))
 452 #define INFO_GEN_TYPE           (MAKE_BASE_INFO_TYPE(2L))
 453 #define INFO_DYN_TYPE           (MAKE_BASE_INFO_TYPE(3L) | _NF | _NS)
 454 #define INFO_TUPLE_TYPE         (MAKE_BASE_INFO_TYPE(4L) | _NF | _NS | _BM)
 455 #define INFO_DATA_TYPE          (MAKE_BASE_INFO_TYPE(5L) | _NF | _NS | _BM)
 456 #define INFO_MUTUPLE_TYPE       (MAKE_BASE_INFO_TYPE(6L) | _NF | _NS | _MU | _BM)
 457 #define INFO_IMMUTUPLE_TYPE     (MAKE_BASE_INFO_TYPE(7L) | _NF | _NS | _BM)
 458 #define INFO_STATIC_TYPE        (MAKE_BASE_INFO_TYPE(8L) | _NS | _ST)
 459 #define INFO_CONST_TYPE         (MAKE_BASE_INFO_TYPE(9L) | _NF | _NS)
 460 #define INFO_CHARLIKE_TYPE      (MAKE_BASE_INFO_TYPE(10L) | _NF | _NS)
 461 #define INFO_INTLIKE_TYPE       (MAKE_BASE_INFO_TYPE(11L) | _NF | _NS)
 462 #define INFO_BH_TYPE            (MAKE_BASE_INFO_TYPE(12L) | _NS | _BH)
 463 #define INFO_BQ_TYPE            (MAKE_BASE_INFO_TYPE(13L) | _NS | _MU | _BH)
 464 #define INFO_IND_TYPE           (MAKE_BASE_INFO_TYPE(14L) | _NS | _IN)
 465 #define INFO_CAF_TYPE           (MAKE_BASE_INFO_TYPE(15L) | _NF | _NS | _ST | _IN)
 466 #define INFO_FM_TYPE            (MAKE_BASE_INFO_TYPE(16L))
 467 #define INFO_TSO_TYPE           (MAKE_BASE_INFO_TYPE(17L) | _MU)
 468 #define INFO_STKO_TYPE          (MAKE_BASE_INFO_TYPE(18L))
 469 #define INFO_SPEC_RBH_TYPE      (MAKE_BASE_INFO_TYPE(19L) | _NS | _MU | _BH)
 470 #define INFO_GEN_RBH_TYPE       (MAKE_BASE_INFO_TYPE(20L) | _NS | _MU | _BH)
 471 #define INFO_BF_TYPE            (MAKE_BASE_INFO_TYPE(21L) | _NS | _MU | _BH)
 472 #define INFO_INTERNAL_TYPE      (MAKE_BASE_INFO_TYPE(22L))
 473
 474 #define INFO_SPEC_N_TYPE        (INFO_SPEC_TYPE | _NF | _NS)
 475 #define INFO_SPEC_S_TYPE        (INFO_SPEC_TYPE | _TH)
 476 #define INFO_SPEC_U_TYPE        (INFO_SPEC_TYPE | _UP | _TH)
 477
 478 #define INFO_GEN_N_TYPE         (INFO_GEN_TYPE | _NF | _NS)
 479 #define INFO_GEN_S_TYPE         (INFO_GEN_TYPE | _TH)
 480 #define INFO_GEN_U_TYPE         (INFO_GEN_TYPE | _UP | _TH)
 481
 482 #define INFO_BH_N_TYPE          (INFO_BH_TYPE)
 483 #define INFO_BH_U_TYPE          (INFO_BH_TYPE | _UP)
 484
 485 #define INFO_STKO_DYNAMIC_TYPE  (INFO_STKO_TYPE | _MU)
 486 #define INFO_STKO_STATIC_TYPE   (INFO_STKO_TYPE | _ST)
 487
 488 #define INFO_FETCHME_TYPE       (INFO_FM_TYPE | _MU)
 489 #define INFO_FMBQ_TYPE          (INFO_FM_TYPE | _MU | _BH)
 490
 491 #define MIN_INFO_TYPE           0
 492 #define MAX_INFO_TYPE           INFO_INTERNAL_TYPE
 493
 494 \end{code}
 495
 496 Notes:
 497
 498 An indirection either points to HNF (post update); or is result of
 499 overwriting a FetchMe, in which case the thing fetched is either
 500 under evaluation (BH), or by now an HNF.  Thus, indirections get @_NS@.
 501
 502 %************************************************************************
 503 %*                                                                      *
 504 \subsubsection{Size/no-of-pointers fields in a rep table}
 505 %*                                                                      *
 506 %************************************************************************
 507
 508 \begin{code}
 509 #define SIZE_INFO_OFFSET  (TYPE_INFO_OFFSET+TYPE_INFO_WORDS)
 510 #define SIZE_INFO_WORDS   2
 511 #define INCLUDE_SIZE_INFO(size,ptrs) ,(W_)size, (W_)ptrs
 512
 513 #define INFO_SIZE(infoptr)   ((I_)((FP_)(INFO_RTBL(infoptr)))[SIZE_INFO_OFFSET])
 514 #define INFO_NoPTRS(infoptr) ((I_)((FP_)(INFO_RTBL(infoptr)))[SIZE_INFO_OFFSET+1])
 515 \end{code}
 516
 517 %************************************************************************
 518 %*                                                                      *
 519 \subsubsection{Parallel-only fields in a rep table}
 520 %*                                                                      *
 521 %************************************************************************
 522
 523 There is now nothing that is specific to the parallel world (GUM), but
 524 this could change so don't go deleting this little lot!  KH
 525
 526 \begin{code}
 527 # define PAR_INFO_OFFSET                (SIZE_INFO_OFFSET+SIZE_INFO_WORDS)
 528
 529 /* now the bits that are either on or off: */
 530
 531 # define PAR_INFO_WORDS         0
 532 # define INCLUDE_PAR_INFO
 533 \end{code}
 534
 535 %************************************************************************
 536 %*                                                                      *
 537 \subsubsection{Copying-only fields in a rep table}
 538 %*                                                                      *
 539 %************************************************************************
 540
 541 These macros result in the copying garbage collection code being
 542 included only if required.
 543 \begin{code}
 544 #if defined(_INFO_COPYING)
 545 # include "SMcopying.h" /* Copying Code Labels */
 546 # define COPY_INFO_OFFSET  (PAR_INFO_OFFSET+PAR_INFO_WORDS)
 547 # define COPY_INFO_WORDS 2
 548 # define INCLUDE_COPYING_INFO(evac, scav) ,(W_)evac,(W_)scav
 549
 550 /*
 551  * use these if you have an unquenchable urge to dig around in
 552  *  info tables (e.g., runtime/.../StgDebug.lc)
 553  */
 554
 555 # define INFO_EVAC_2S(infoptr)  (((FP_)(INFO_RTBL(infoptr)))[COPY_INFO_OFFSET])
 556 # define INFO_SCAV_2S(infoptr)  (((FP_)(INFO_RTBL(infoptr)))[COPY_INFO_OFFSET + 1])
 557
 558 #else  /* ! _INFO_COPYING */
 559
 560 # define COPY_INFO_WORDS 0
 561 # define INCLUDE_COPYING_INFO(evac, scav)
 562
 563 #endif /* ! _INFO_COPYING */
 564 \end{code}
 565
 566 %************************************************************************
 567 %*                                                                      *
 568 \subsubsection{Compacting-only fields in a rep table}
 569 %*                                                                      *
 570 %************************************************************************
 571
 572 These macros result in the compacting garbage collection code being
 573 included only if required. This includes the variable length
 574 specialised marking code.
 575
 576 \begin{code}
 577 #if !defined(_INFO_COMPACTING)
 578
 579 # define INCLUDE_COMPACTING_INFO(scanlink,prmark,scanmove,marking)
 580 # define SPEC_COMPACTING_INFO(scanlink,prmark,scanmove,marking)
 581
 582 #else /* defined(_INFO_COMPACTING) */
 583
 584 # include "SMcompact.h"         /* Single Space Compacting Code */
 585 # include "SMmark.h"            /* Pointer Reversal Marking Code Labels */
 586
 587 /* For SPEC closures compacting info is variable length -> must come last */
 588
 589 # define COMPACTING_INFO_OFFSET  (COPY_INFO_OFFSET+COPY_INFO_WORDS)
 590
 591 # define INCLUDE_COMPACTING_INFO(scanlink,prmark,scanmove,marking) \
 592         ,(W_)scanlink,(W_)prmark \
 593         ,(W_)scanmove,(W_)marking
 594
 595 # define SPEC_COMPACTING_INFO(scanlink,prmark,scanmove,prreturn) \
 596         ,(W_)scanlink,(W_)prmark \
 597         ,(W_)scanmove, \
 598          (W_)prreturn
 599
 600
 601 # define INFO_SCAN_LINK_1S(infoptr)     (((FP_)(INFO_RTBL(infoptr)))[COMPACTING_INFO_OFFSET])
 602 # define INFO_MARK_1S(infoptr)          (((FP_)(INFO_RTBL(infoptr)))[COMPACTING_INFO_OFFSET+1])
 603 # define INFO_SCAN_MOVE_1S(infoptr)     (((FP_)(INFO_RTBL(infoptr)))[COMPACTING_INFO_OFFSET+2])
 604 # define INFO_MARKED_1S(infoptr)        (((FP_)(INFO_RTBL(infoptr)))[COMPACTING_INFO_OFFSET+3])
 605 # define INFO_MARKING_1S(infoptr)       (((FP_)(INFO_RTBL(infoptr)))[COMPACTING_INFO_OFFSET+4])
 606
 607 #ifndef COMPILING_GHC
 608 extern F_ _Dummy_Static_entry(STG_NO_ARGS);
 609 extern F_ _Dummy_Ind_entry(STG_NO_ARGS);
 610 extern F_ _Dummy_Caf_entry(STG_NO_ARGS);
 611 extern F_ _Dummy_Const_entry(STG_NO_ARGS);
 612 extern F_ _Dummy_CharLike_entry(STG_NO_ARGS);
 613 #endif
 614
 615 #endif /* _INFO_COMPACTING */
 616 \end{code}
 617
 618 %************************************************************************
 619 %*                                                                      *
 620 \subsection[SPEC_ITBL]{@SPEC_x_ITBL@: @SPEC@ info-tables}
 621 %*                                                                      *
 622 %************************************************************************
 623
 624 Normal-form and updatable (non-normal-form) variants.
 625
 626 \begin{code}
 627
 628 #define SPEC_N_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) \
 629     CAT_DECLARE(infolbl,kind,descr,type)        \
 630     entry_localness(entry_code);                \
 631     localness W_ infolbl[] = {                  \
 632         (W_) entry_code                         \
 633         ,(W_) tag                               \
 634         ,(W_) MK_REP_REF(Spec_N,size,ptrs)      \
 635         INCLUDE_PROFILING_INFO(infolbl)         \
 636         INCLUDE_UPDATE_INFO(upd_code,liveness)  \
 637         }
 638
 639 MAYBE_DECLARE_RTBL(Spec_N,1,0)
 640 MAYBE_DECLARE_RTBL(Spec_N,1,1)
 641 MAYBE_DECLARE_RTBL(Spec_N,2,0)
 642 MAYBE_DECLARE_RTBL(Spec_N,2,1)
 643 MAYBE_DECLARE_RTBL(Spec_N,2,2)
 644 MAYBE_DECLARE_RTBL(Spec_N,3,0)
 645 MAYBE_DECLARE_RTBL(Spec_N,3,1)
 646 MAYBE_DECLARE_RTBL(Spec_N,3,2)
 647 MAYBE_DECLARE_RTBL(Spec_N,3,3)
 648 MAYBE_DECLARE_RTBL(Spec_N,4,0)
 649 MAYBE_DECLARE_RTBL(Spec_N,4,4)
 650 MAYBE_DECLARE_RTBL(Spec_N,5,0)
 651 MAYBE_DECLARE_RTBL(Spec_N,5,5)
 652 MAYBE_DECLARE_RTBL(Spec_N,6,6)
 653 MAYBE_DECLARE_RTBL(Spec_N,7,7)
 654 MAYBE_DECLARE_RTBL(Spec_N,8,8)
 655 MAYBE_DECLARE_RTBL(Spec_N,9,9)
 656 MAYBE_DECLARE_RTBL(Spec_N,10,10)
 657 MAYBE_DECLARE_RTBL(Spec_N,11,11)
 658 MAYBE_DECLARE_RTBL(Spec_N,12,12)
 659
 660 #define SPEC_N_RTBL(size,ptrs)                                                  \
 661     const W_ MK_REP_LBL(Spec_N,size,ptrs)[] = {                                 \
 662         INCLUDE_TYPE_INFO(SPEC_N)                                               \
 663         INCLUDE_SIZE_INFO(size,ptrs)                                            \
 664         INCLUDE_PAR_INFO                                                        \
 665         INCLUDE_COPYING_INFO(CAT2(_Evacuate_,size),CAT4(_Scavenge_,size,_,ptrs)) \
 666         SPEC_COMPACTING_INFO(CAT4(_ScanLink_,size,_,ptrs),                      \
 667                              CAT2(_PRStart_,ptrs),                              \
 668                              CAT2(_ScanMove_,size),CAT2(_PRIn_,ptrs))           \
 669         }
 670
 671 #define SPEC_S_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) \
 672     CAT_DECLARE(infolbl,kind,descr,type)        \
 673     entry_localness(entry_code);                \
 674     localness W_ infolbl[] = {                  \
 675         (W_) entry_code                         \
 676         ,(W_) tag                               \
 677         ,(W_) MK_REP_REF(Spec_S,size,ptrs)      \
 678         INCLUDE_PROFILING_INFO(infolbl)         \
 679         INCLUDE_UPDATE_INFO(upd_code,liveness)  \
 680         }
 681
 682 MAYBE_DECLARE_RTBL(Spec_S,1,0)
 683 MAYBE_DECLARE_RTBL(Spec_S,1,1)
 684 MAYBE_DECLARE_RTBL(Spec_S,2,0)
 685 MAYBE_DECLARE_RTBL(Spec_S,2,1)
 686 MAYBE_DECLARE_RTBL(Spec_S,2,2)
 687 MAYBE_DECLARE_RTBL(Spec_S,3,0)
 688 MAYBE_DECLARE_RTBL(Spec_S,3,1)
 689 MAYBE_DECLARE_RTBL(Spec_S,3,2)
 690 MAYBE_DECLARE_RTBL(Spec_S,3,3)
 691 MAYBE_DECLARE_RTBL(Spec_S,4,0)
 692 MAYBE_DECLARE_RTBL(Spec_S,4,4)
 693 MAYBE_DECLARE_RTBL(Spec_S,5,0)
 694 MAYBE_DECLARE_RTBL(Spec_S,5,5)
 695 MAYBE_DECLARE_RTBL(Spec_S,6,6)
 696 MAYBE_DECLARE_RTBL(Spec_S,7,7)
 697 MAYBE_DECLARE_RTBL(Spec_S,8,8)
 698 MAYBE_DECLARE_RTBL(Spec_S,9,9)
 699 MAYBE_DECLARE_RTBL(Spec_S,10,10)
 700 MAYBE_DECLARE_RTBL(Spec_S,11,11)
 701 MAYBE_DECLARE_RTBL(Spec_S,12,12)
 702
 703 #define SPEC_S_RTBL(size,ptrs)                                                  \
 704     const W_ MK_REP_LBL(Spec_S,size,ptrs)[] = {                                 \
 705         INCLUDE_TYPE_INFO(SPEC_S)                                               \
 706         INCLUDE_SIZE_INFO(size,ptrs)                                            \
 707         INCLUDE_PAR_INFO                                                        \
 708         INCLUDE_COPYING_INFO(CAT2(_Evacuate_,size),CAT4(_Scavenge_,size,_,ptrs)) \
 709         SPEC_COMPACTING_INFO(CAT4(_ScanLink_,size,_,ptrs),                      \
 710                              CAT2(_PRStart_,ptrs),                              \
 711                              CAT2(_ScanMove_,size),CAT2(_PRIn_,ptrs))           \
 712         }
 713
 714 #ifdef PAR
 715 # define SPEC_U_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) \
 716     entry_localness(CAT2(RBH_,entry_code));     \
 717     localness W_ infolbl[];                     \
 718      localness W_ CAT2(RBH_,infolbl)[] = {      \
 719         (W_) CAT2(RBH_,entry_code)              \
 720         ,(W_) INFO_OTHER_TAG                    \
 721         ,(W_) MK_REP_REF(Spec_RBH,size,ptrs)    \
 722         INCLUDE_PROFILING_INFO(RBH)             \
 723         INCLUDE_SPEC_PADDING                    \
 724         INCLUDE_RBH_INFO(infolbl)               \
 725         };                                      \
 726     STGFUN(CAT2(RBH_,entry_code)) { JMP_(RBH_entry); }\
 727     CAT_DECLARE(infolbl,kind,descr,type)        \
 728     entry_localness(entry_code);                \
 729     localness W_ infolbl[] = {                  \
 730         (W_) entry_code                         \
 731         ,(W_) tag                               \
 732         ,(W_) MK_REP_REF(Spec_U,size,ptrs)      \
 733         INCLUDE_PROFILING_INFO(infolbl)         \
 734         INCLUDE_SPEC_PADDING                    \
 735         INCLUDE_RBH_INFO(CAT2(RBH_,infolbl))    \
 736         }
 737
 738 MAYBE_DECLARE_RTBL(Spec_RBH,1,0)
 739 MAYBE_DECLARE_RTBL(Spec_RBH,1,1)
 740 MAYBE_DECLARE_RTBL(Spec_RBH,2,0)
 741 MAYBE_DECLARE_RTBL(Spec_RBH,2,1)
 742 MAYBE_DECLARE_RTBL(Spec_RBH,2,2)
 743 MAYBE_DECLARE_RTBL(Spec_RBH,3,0)
 744 MAYBE_DECLARE_RTBL(Spec_RBH,3,1)
 745 MAYBE_DECLARE_RTBL(Spec_RBH,3,2)
 746 MAYBE_DECLARE_RTBL(Spec_RBH,3,3)
 747 MAYBE_DECLARE_RTBL(Spec_RBH,4,0)
 748 MAYBE_DECLARE_RTBL(Spec_RBH,4,4)
 749 MAYBE_DECLARE_RTBL(Spec_RBH,5,0)
 750 MAYBE_DECLARE_RTBL(Spec_RBH,5,5)
 751 MAYBE_DECLARE_RTBL(Spec_RBH,6,6)
 752 MAYBE_DECLARE_RTBL(Spec_RBH,7,7)
 753 MAYBE_DECLARE_RTBL(Spec_RBH,8,8)
 754 MAYBE_DECLARE_RTBL(Spec_RBH,9,9)
 755 MAYBE_DECLARE_RTBL(Spec_RBH,10,10)
 756 MAYBE_DECLARE_RTBL(Spec_RBH,11,11)
 757 MAYBE_DECLARE_RTBL(Spec_RBH,12,12)
 758
 759 #define SPEC_RBH_RTBL(size,ptrs)                                                \
 760     const W_ MK_REP_LBL(Spec_RBH,size,ptrs)[] = {                               \
 761         INCLUDE_TYPE_INFO(SPEC_RBH)                                             \
 762         INCLUDE_SIZE_INFO(size,ptrs)                                            \
 763         INCLUDE_PAR_INFO                                                        \
 764         INCLUDE_COPYING_INFO(CAT2(_Evacuate_RBH_,size),CAT4(_Scavenge_RBH_,size,_,ptrs)) \
 765         SPEC_COMPACTING_INFO(CAT4(_ScanLink_RBH_,size,_,ptrs),                  \
 766                              CAT2(_PRStart_RBH_,ptrs),                          \
 767                              CAT2(_ScanMove_RBH_,size),CAT2(_PRIn_RBH_,ptrs))   \
 768         }
 769
 770 #define _Scavenge_RBH_2_0   _Scavenge_RBH_2_1
 771 #define _Scavenge_RBH_2_2   _Scavenge_RBH_2_1
 772
 773 #define _Scavenge_RBH_3_0   _Scavenge_RBH_3_1
 774 #define _Scavenge_RBH_3_2   _Scavenge_RBH_3_1
 775
 776 #define _Scavenge_RBH_4_0   _Scavenge_RBH_4_1
 777 #define _Scavenge_RBH_5_0   _Scavenge_RBH_5_1
 778 #define _Scavenge_RBH_6_0   _Scavenge_RBH_6_1
 779 #define _Scavenge_RBH_7_0   _Scavenge_RBH_7_1
 780 #define _Scavenge_RBH_8_0   _Scavenge_RBH_8_1
 781 #define _Scavenge_RBH_9_0   _Scavenge_RBH_9_1
 782 #define _Scavenge_RBH_10_0   _Scavenge_RBH_10_1
 783 #define _Scavenge_RBH_11_0   _Scavenge_RBH_11_1
 784 #define _Scavenge_RBH_12_0   _Scavenge_RBH_12_1
 785
 786 #define _ScanLink_RBH_2_0   _ScanLink_RBH_2_1
 787 #define _ScanLink_RBH_2_2   _ScanLink_RBH_2_1
 788
 789 #define _ScanLink_RBH_3_0   _ScanLink_RBH_3_1
 790 #define _ScanLink_RBH_3_2   _ScanLink_RBH_3_1
 791
 792 #define _ScanLink_RBH_4_0   _ScanLink_RBH_4_1
 793 #define _ScanLink_RBH_5_0   _ScanLink_RBH_5_1
 794 #define _ScanLink_RBH_6_0   _ScanLink_RBH_6_1
 795 #define _ScanLink_RBH_7_0   _ScanLink_RBH_7_1
 796 #define _ScanLink_RBH_8_0   _ScanLink_RBH_8_1
 797 #define _ScanLink_RBH_9_0   _ScanLink_RBH_9_1
 798 #define _ScanLink_RBH_10_0   _ScanLink_RBH_10_1
 799 #define _ScanLink_RBH_11_0   _ScanLink_RBH_11_1
 800 #define _ScanLink_RBH_12_0   _ScanLink_RBH_12_1
 801
 802 #define _PRStart_RBH_0  _PRStart_RBH_2
 803 #define _PRStart_RBH_1  _PRStart_RBH_2
 804
 805 #define _PRIn_RBH_0     _PRIn_RBH_2
 806 #define _PRIn_RBH_1     _PRIn_RBH_2
 807
 808 #else
 809
 810 # define SPEC_U_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) \
 811     CAT_DECLARE(infolbl,kind,descr,type)        \
 812     entry_localness(entry_code);                \
 813     localness W_ infolbl[] = {                  \
 814         (W_) entry_code                         \
 815         ,(W_) tag                               \
 816         ,(W_) MK_REP_REF(Spec_U,size,ptrs)      \
 817         INCLUDE_PROFILING_INFO(infolbl)         \
 818         }
 819 #endif
 820
 821 MAYBE_DECLARE_RTBL(Spec_U,1,0)
 822 MAYBE_DECLARE_RTBL(Spec_U,1,1)
 823 MAYBE_DECLARE_RTBL(Spec_U,2,0)
 824 MAYBE_DECLARE_RTBL(Spec_U,2,1)
 825 MAYBE_DECLARE_RTBL(Spec_U,2,2)
 826 MAYBE_DECLARE_RTBL(Spec_U,3,0)
 827 MAYBE_DECLARE_RTBL(Spec_U,3,1)
 828 MAYBE_DECLARE_RTBL(Spec_U,3,2)
 829 MAYBE_DECLARE_RTBL(Spec_U,3,3)
 830 MAYBE_DECLARE_RTBL(Spec_U,4,0)
 831 MAYBE_DECLARE_RTBL(Spec_U,4,4)
 832 MAYBE_DECLARE_RTBL(Spec_U,5,0)
 833 MAYBE_DECLARE_RTBL(Spec_U,5,5)
 834 MAYBE_DECLARE_RTBL(Spec_U,6,6)
 835 MAYBE_DECLARE_RTBL(Spec_U,7,7)
 836 MAYBE_DECLARE_RTBL(Spec_U,8,8)
 837 MAYBE_DECLARE_RTBL(Spec_U,9,9)
 838 MAYBE_DECLARE_RTBL(Spec_U,10,10)
 839 MAYBE_DECLARE_RTBL(Spec_U,11,11)
 840 MAYBE_DECLARE_RTBL(Spec_U,12,12)
 841
 842 #define SPEC_U_RTBL(size,ptrs)                                                  \
 843     const W_ MK_REP_LBL(Spec_U,size,ptrs)[] = {                                 \
 844         INCLUDE_TYPE_INFO(SPEC_U)                                               \
 845         INCLUDE_SIZE_INFO(size,ptrs)                                            \
 846         INCLUDE_PAR_INFO                                                        \
 847         INCLUDE_COPYING_INFO(CAT2(_Evacuate_,size),CAT4(_Scavenge_,size,_,ptrs)) \
 848         SPEC_COMPACTING_INFO(CAT4(_ScanLink_,size,_,ptrs),                      \
 849                              CAT2(_PRStart_,ptrs),                              \
 850                              CAT2(_ScanMove_,size),CAT2(_PRIn_,ptrs))           \
 851         }
 852
 853 \end{code}
 854
 855 %************************************************************************
 856 %*                                                                      *
 857 \subsection[SELECT_ITBL]{@SELECT_ITBL@: Special @SPEC_U@ info-table for selectors}
 858 %*                                                                      *
 859 %************************************************************************
 860
 861 These are different only in having slightly-magic GC code.  The idea
 862 is: it is a @MIN_UPD_SIZE@ (==2) thunk with one pointer, which, when
 863 entered, will select word $i$ from its pointee.
 864
 865 When garbage-collecting such a closure, we ``peek'' at the pointee's
 866 tag (in its info table).  If it is evaluated, then we go ahead and do
 867 the selection---which is {\em just like an indirection}.  If it is not
 868 evaluated, we carry on {\em exactly as if it is a size-2/1-ptr thunk}.
 869
 870 Copying: only the evacuate routine needs to be special.
 871
 872 Compacting: only the PRStart (marking) routine needs to be special.
 873
 874 \begin{code}
 875
 876 #ifdef PAR
 877 # define SELECT_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,select_word_i,kind,descr,type) \
 878     entry_localness(CAT2(RBH_,entry_code));     \
 879     localness W_ infolbl[];                     \
 880     localness W_ CAT2(RBH_,infolbl)[] = {       \
 881         (W_) CAT2(RBH_,entry_code)              \
 882         ,(W_) INFO_OTHER_TAG                    \
 883         ,(W_) MK_REP_REF(Spec_RBH,size,ptrs)    \
 884         INCLUDE_PROFILING_INFO(RBH)             \
 885         INCLUDE_SPEC_PADDING                    \
 886         INCLUDE_RBH_INFO(infolbl)               \
 887         };                                      \
 888     STGFUN(CAT2(RBH_,entry_code)) { JMP_(RBH_entry); }\
 889     CAT_DECLARE(infolbl,kind,descr,type)        \
 890     entry_localness(entry_code);                \
 891     localness W_ infolbl[] = {                  \
 892         (W_) entry_code                         \
 893         ,(W_) tag                               \
 894         ,(W_) MK_REP_REF(Select,,select_word_i) \
 895         INCLUDE_PROFILING_INFO(infolbl)         \
 896         INCLUDE_SPEC_PADDING                    \
 897         INCLUDE_RBH_INFO(CAT2(RBH_,infolbl))    \
 898         }                                       \
 899
 900 #else
 901
 902 # define SELECT_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,select_word_i,kind,descr,type) \
 903     CAT_DECLARE(infolbl,kind,descr,type)        \
 904     entry_localness(entry_code);                \
 905     localness W_ infolbl[] = {                  \
 906         (W_) entry_code                         \
 907         ,(W_) tag                               \
 908         ,(W_) MK_REP_REF(Select,,select_word_i) \
 909         INCLUDE_PROFILING_INFO(infolbl)         \
 910         }
 911
 912 #endif
 913
 914 MAYBE_DECLARE_RTBL(Select,,0)
 915 MAYBE_DECLARE_RTBL(Select,,1)
 916 MAYBE_DECLARE_RTBL(Select,,2)
 917 MAYBE_DECLARE_RTBL(Select,,3)
 918 MAYBE_DECLARE_RTBL(Select,,4)
 919 MAYBE_DECLARE_RTBL(Select,,5)
 920 MAYBE_DECLARE_RTBL(Select,,6)
 921 MAYBE_DECLARE_RTBL(Select,,7)
 922 MAYBE_DECLARE_RTBL(Select,,8)
 923 MAYBE_DECLARE_RTBL(Select,,9)
 924 MAYBE_DECLARE_RTBL(Select,,10)
 925 MAYBE_DECLARE_RTBL(Select,,11)
 926 MAYBE_DECLARE_RTBL(Select,,12)
 927
 928 #define SELECT_RTBL(size,ptrs,select_word_i)                                    \
 929     const W_ MK_REP_LBL(Select,,select_word_i)[] = {                            \
 930         INCLUDE_TYPE_INFO(SPEC_U)                                               \
 931         INCLUDE_SIZE_INFO(size,ptrs)                                            \
 932         INCLUDE_PAR_INFO                                                        \
 933         INCLUDE_COPYING_INFO(CAT2(_EvacuateSelector_,select_word_i),            \
 934                              CAT4(_Scavenge_,size,_,ptrs))                      \
 935         SPEC_COMPACTING_INFO(CAT4(_ScanLink_,size,_,ptrs),                      \
 936                              CAT2(_PRStartSelector_,select_word_i),             \
 937                              CAT2(_ScanMove_,size),                             \
 938                              CAT2(_PRIn_,ptrs))                                 \
 939         }
 940
 941 \end{code}
 942
 943 %************************************************************************
 944 %*                                                                      *
 945 \subsection[GEN_ITBL]{@GEN_x_ITBL@: Generic/general? info-tables}
 946 %*                                                                      *
 947 %************************************************************************
 948
 949 @GEN@ info-table for non-updatable nodes (normal and non-normal forms).
 950
 951 Size/no-of-ptrs are known at compile time, but we don't have GC
 952 routines wired in for those specific sizes.  Hence the size/no-of-ptrs
 953 is stored in the info-table.
 954
 955 \begin{code}
 956
 957 #define GEN_N_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) \
 958     CAT_DECLARE(infolbl,kind,descr,type)        \
 959     entry_localness(entry_code);                \
 960     localness W_ infolbl[] = {                  \
 961         (W_) entry_code                         \
 962         ,(W_) tag                               \
 963         ,(W_) MK_REP_REF(Gen_N,,)               \
 964         INCLUDE_PROFILING_INFO(infolbl)         \
 965         INCLUDE_UPDATE_INFO(upd_code,liveness)  \
 966         INCLUDE_GEN_INFO(size,ptrs)             \
 967         }
 968
 969 MAYBE_DECLARE_RTBL(Gen_N,,)
 970
 971 #define GEN_N_RTBL()                                                            \
 972     const W_ MK_REP_LBL(Gen_N,,)[] = {                                          \
 973         INCLUDE_TYPE_INFO(GEN_N)                                                \
 974         INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) /* NB: in info table */      \
 975         INCLUDE_PAR_INFO                                                        \
 976         INCLUDE_COPYING_INFO(_Evacuate_S,_Scavenge_S_N)                         \
 977         INCLUDE_COMPACTING_INFO(_ScanLink_S_N,_PRStart_N,_ScanMove_S,_PRIn_I)   \
 978         }
 979
 980 #define GEN_S_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) \
 981     CAT_DECLARE(infolbl,kind,descr,type)        \
 982     entry_localness(entry_code);                \
 983     localness W_ infolbl[] = {                  \
 984         (W_) entry_code                         \
 985         ,(W_) tag                               \
 986         ,(W_) MK_REP_REF(Gen_S,,)               \
 987         INCLUDE_PROFILING_INFO(infolbl)         \
 988         INCLUDE_UPDATE_INFO(upd_code,liveness)  \
 989         INCLUDE_GEN_INFO(size,ptrs)             \
 990         }
 991
 992 MAYBE_DECLARE_RTBL(Gen_S,,)
 993
 994 #define GEN_S_RTBL()                                                            \
 995     const W_ MK_REP_LBL(Gen_S,,)[] = {                                          \
 996         INCLUDE_TYPE_INFO(GEN_S)                                                \
 997         INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) /* NB: in info table */      \
 998         INCLUDE_PAR_INFO                                                        \
 999         INCLUDE_COPYING_INFO(_Evacuate_S,_Scavenge_S_N)                         \
1000         INCLUDE_COMPACTING_INFO(_ScanLink_S_N,_PRStart_N,_ScanMove_S,_PRIn_I)   \
1001         }
1002
1003 #ifdef PAR
1004 # define GEN_U_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) \
1005     entry_localness(CAT2(RBH_,entry_code));     \
1006     localness W_ infolbl[];                     \
1007     localness W_ CAT2(RBH_,infolbl)[] = {       \
1008         (W_) CAT2(RBH_,entry_code)              \
1009         ,(W_) INFO_OTHER_TAG                    \
1010         ,(W_) MK_REP_REF(Gen_RBH,,)             \
1011         INCLUDE_PROFILING_INFO(RBH)             \
1012         INCLUDE_UPDATE_INFO(INFO_UNUSED,INFO_UNUSED)    \
1013         INCLUDE_GEN_INFO(size,ptrs)             \
1014         INCLUDE_RBH_INFO(infolbl)               \
1015         };                                      \
1016     STGFUN(CAT2(RBH_,entry_code)) { JMP_(RBH_entry); }\
1017     CAT_DECLARE(infolbl,kind,descr,type)        \
1018     entry_localness(entry_code);                \
1019     localness W_ infolbl[] = {                  \
1020         (W_) entry_code                         \
1021         ,(W_) tag                               \
1022         ,(W_) MK_REP_REF(Gen_U,,)               \
1023         INCLUDE_PROFILING_INFO(infolbl)         \
1024         INCLUDE_UPDATE_INFO(INFO_UNUSED,INFO_UNUSED)    \
1025         INCLUDE_GEN_INFO(size,ptrs)             \
1026         INCLUDE_RBH_INFO(CAT2(RBH_,infolbl))    \
1027         }
1028
1029 MAYBE_DECLARE_RTBL(Gen_RBH,,)
1030
1031 # define GEN_RBH_RTBL()                                                         \
1032     const W_ MK_REP_LBL(Gen_RBH,,)[] = {                                        \
1033         INCLUDE_TYPE_INFO(GEN_RBH)                                              \
1034         INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) /* NB: no size/no-ptrs! */   \
1035         INCLUDE_PAR_INFO                                                        \
1036         INCLUDE_COPYING_INFO(_Evacuate_RBH_S,_Scavenge_RBH_N)                   \
1037         INCLUDE_COMPACTING_INFO(_ScanLink_RBH_N,_PRStart_RBH_N,_ScanMove_RBH_S,_PRIn_RBH_I)     \
1038         }
1039
1040 #else
1041
1042 # define GEN_U_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) \
1043     CAT_DECLARE(infolbl,kind,descr,type)        \
1044     entry_localness(entry_code);                \
1045     localness W_ infolbl[] = {                  \
1046         (W_) entry_code                         \
1047         ,(W_) tag                               \
1048         ,(W_) MK_REP_REF(Gen_U,,)               \
1049         INCLUDE_PROFILING_INFO(infolbl)         \
1050         INCLUDE_UPDATE_INFO(INFO_UNUSED,INFO_UNUSED)    \
1051         INCLUDE_GEN_INFO(size,ptrs)             \
1052         }
1053 #endif
1054
1055 MAYBE_DECLARE_RTBL(Gen_U,,)
1056
1057 #define GEN_U_RTBL()                                                            \
1058     const W_ MK_REP_LBL(Gen_U,,)[] = {                                          \
1059         INCLUDE_TYPE_INFO(GEN_U)                                                \
1060         INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) /* NB: no size/no-ptrs! */   \
1061         INCLUDE_PAR_INFO                                                        \
1062         INCLUDE_COPYING_INFO(_Evacuate_S,_Scavenge_S_N)                         \
1063         INCLUDE_COMPACTING_INFO(_ScanLink_S_N,_PRStart_N,_ScanMove_S,_PRIn_I)   \
1064         }
1065
1066 \end{code}
1067
1068 %************************************************************************
1069 %*                                                                      *
1070 \subsection[DYN_ITBL]{Dynamic-object info tables}
1071 %*                                                                      *
1072 %************************************************************************
1073
1074 For these, the size/no-of-pointers is not known until runtime.  E.g.,
1075 arrays.  Those fields are, therefore, in the closure itself, and not
1076 in the info table.
1077
1078 All @DYN@ closures are @PAP@s, so they are not updatable.
1079
1080 \begin{code}
1081
1082 #define DYN_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) /*size,ptrs unused*/ \
1083     CAT_DECLARE(infolbl,kind,descr,type)        \
1084     entry_localness(entry_code);                \
1085     localness W_ infolbl[] = {                  \
1086         (W_) entry_code                         \
1087         ,(W_) tag                               \
1088         ,(W_) MK_REP_LBL(Dyn,,)                 \
1089         INCLUDE_PROFILING_INFO(infolbl)         \
1090         }
1091
1092 MAYBE_DECLARE_RTBL(Dyn,,)
1093
1094 #define DYN_RTBL()                                                      \
1095     const W_ MK_REP_LBL(Dyn,,)[] = {                                    \
1096         INCLUDE_TYPE_INFO(DYN)                                          \
1097         INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) /* in closure! */    \
1098         INCLUDE_PAR_INFO                                                \
1099         INCLUDE_COPYING_INFO(_Evacuate_Dyn,_Scavenge_Dyn)               \
1100         INCLUDE_COMPACTING_INFO(_ScanLink_Dyn,_PRStart_Dyn,_ScanMove_Dyn,_PRIn_I_Dyn) \
1101         }
1102
1103 \end{code}
1104
1105 %************************************************************************
1106 %*                                                                      *
1107 \subsection[TUPLE_ITBL]{``Tuple'' and ``Data'' info-tables}
1108 %*                                                                      *
1109 %************************************************************************
1110
1111 ``Tuples'' are essentially DYNs with all pointers (no non-pointers).
1112 ``Data things'' are DYNs with all non-pointers.
1113
1114 \begin{code}
1115
1116 #define TUPLE_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) /*size,ptrs unused*/ \
1117     CAT_DECLARE(infolbl,kind,descr,type)        \
1118     entry_localness(entry_code);                \
1119     localness W_ infolbl[] = {                  \
1120         (W_) entry_code                         \
1121         ,(W_) tag                               \
1122         ,(W_) MK_REP_REF(Tuple,,)               \
1123         INCLUDE_PROFILING_INFO(infolbl)         \
1124         }
1125
1126 MAYBE_DECLARE_RTBL(Tuple,,)
1127
1128 #define TUPLE_RTBL() \
1129     const W_ MK_REP_LBL(Tuple,,)[] = { \
1130         INCLUDE_TYPE_INFO(TUPLE)                                        \
1131         INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) /* NB: in closure */ \
1132         INCLUDE_PAR_INFO                                                \
1133         INCLUDE_COPYING_INFO(_Evacuate_Tuple,_Scavenge_Tuple) \
1134         INCLUDE_COMPACTING_INFO(_ScanLink_Tuple,_PRStart_Tuple,_ScanMove_Tuple,_PRIn_I_Tuple) \
1135         }
1136
1137 #define DATA_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) /*size,ptrs unused*/ \
1138     CAT_DECLARE(infolbl,kind,descr,type)        \
1139     entry_localness(entry_code);                \
1140     localness W_ infolbl[] = {                  \
1141         (W_) entry_code                         \
1142         ,(W_) tag                               \
1143         ,(W_) MK_REP_REF(Data,,)                \
1144         INCLUDE_PROFILING_INFO(infolbl)         \
1145         }
1146
1147 MAYBE_DECLARE_RTBL(Data,,)
1148
1149 #define DATA_RTBL()                     \
1150     const W_ MK_REP_LBL(Data,,)[] = {   \
1151         INCLUDE_TYPE_INFO(DATA)         \
1152         INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) /* NB: in closure */ \
1153         INCLUDE_PAR_INFO                 \
1154         INCLUDE_COPYING_INFO(_Evacuate_Data,_Scavenge_Data) \
1155         INCLUDE_COMPACTING_INFO(_ScanLink_Data,_PRStart_Data,_ScanMove_Data,_PRIn_Error) \
1156     }
1157
1158 /* Here is the decl for the only DATA info table used! */
1159 #ifndef COMPILING_GHC
1160 EXTDATA_RO(ArrayOfData_info);
1161 #endif
1162 \end{code}
1163
1164 %************************************************************************
1165 %*                                                                      *
1166 \subsection[MUTUPLE_ITBL]{Info-table for (im)mutable [array-ish] objects}
1167 %*                                                                      *
1168 %************************************************************************
1169
1170 ToDo: Integrate with PAR stuff (Kevin) !!
1171 If someone bothers to document this I'll see what I can do! KH
1172
1173 \begin{code}
1174
1175 #if defined(GC_MUT_REQUIRED)
1176
1177 # define MUTUPLE_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) /*size,ptrs unused*/ \
1178     CAT_DECLARE(infolbl,kind,descr,type)        \
1179     entry_localness(entry_code);                \
1180     localness W_ infolbl[] = {                  \
1181         (W_) entry_code                         \
1182         ,(W_) tag                               \
1183         ,(W_) MK_REP_REF(MuTuple,,)             \
1184         INCLUDE_PROFILING_INFO(infolbl)         \
1185         }
1186
1187 MAYBE_DECLARE_RTBL(MuTuple,,)
1188
1189 # define MUTUPLE_RTBL()                         \
1190     const W_ MK_REP_LBL(MuTuple,,)[] = {        \
1191         INCLUDE_TYPE_INFO(MUTUPLE)              \
1192         INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) /* NB: in closure! */ \
1193         INCLUDE_PAR_INFO                         \
1194         INCLUDE_COPYING_INFO(_Evacuate_MuTuple,_Scavenge_MuTuple) \
1195         INCLUDE_COMPACTING_INFO(_ScanLink_MuTuple,_PRStart_MuTuple,_ScanMove_MuTuple,_PRIn_I_MuTuple) \
1196         }
1197
1198 # define IMMUTUPLE_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) /*size,ptrs unused*/ \
1199     CAT_DECLARE(infolbl,kind,descr,type)        \
1200     entry_localness(entry_code);                \
1201     localness W_ infolbl[] = {                  \
1202         (W_) entry_code                         \
1203         ,(W_) tag                               \
1204         ,(W_) MK_REP_REF(ImmuTuple,,)           \
1205         INCLUDE_PROFILING_INFO(infolbl)         \
1206         }
1207
1208 MAYBE_DECLARE_RTBL(ImmuTuple,,)
1209
1210 # define IMMUTUPLE_RTBL() \
1211     const W_ MK_REP_LBL(ImmuTuple,,)[] = {  \
1212         INCLUDE_TYPE_INFO(IMMUTUPLE)        \
1213         INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) /* NB: in closure! */ \
1214         INCLUDE_PAR_INFO                         \
1215         INCLUDE_COPYING_INFO(_Evacuate_MuTuple,_Scavenge_MuTuple) \
1216         INCLUDE_COMPACTING_INFO(_ScanLink_MuTuple,_PRStart_MuTuple,_ScanMove_ImmuTuple,_PRIn_I_MuTuple) \
1217     }
1218
1219 #else   /* ! GC_MUT_REQUIRED --- define as TUPLE closure */
1220
1221 # define MUTUPLE_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) \
1222         TUPLE_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type)
1223 # define IMMUTUPLE_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) \
1224         TUPLE_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type)
1225
1226 # define MUTUPLE_RTBL()
1227 # define IMMUTUPLE_RTBL()
1228 #endif
1229
1230 /* Here are the decls for the only MUTUPLE info tables used. */
1231 #ifndef COMPILING_GHC
1232 EXTDATA_RO(ArrayOfPtrs_info);
1233 EXTDATA_RO(ImMutArrayOfPtrs_info);
1234 EXTDATA_RO(EmptySVar_info);
1235 EXTDATA_RO(FullSVar_info);
1236 #endif
1237 \end{code}
1238
1239 %************************************************************************
1240 %*                                                                      *
1241 \subsection[STATIC_ITBL]{Info tables for static objects (outside the heap)}
1242 %*                                                                      *
1243 %************************************************************************
1244
1245 Size and ptrs fields are used by interpretive code, such as @ghci@,
1246 the parallel Pack code (@Pack.lc@) and possibly to-be-written debug
1247 code.
1248
1249 \begin{code}
1250 #define STATIC_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) \
1251     CAT_DECLARE(infolbl,kind,descr,type)        \
1252     entry_localness(entry_code);                \
1253     localness W_ infolbl[] = {                  \
1254         (W_) entry_code                         \
1255         ,(W_) tag                               \
1256         ,(W_) MK_REP_REF(Static,,)              \
1257         INCLUDE_PROFILING_INFO(infolbl)         \
1258         INCLUDE_UPDATE_INFO(upd_code,liveness)  \
1259         INCLUDE_STATIC_INFO(size,ptrs)          \
1260         }
1261
1262 MAYBE_DECLARE_RTBL(Static,,)
1263
1264 #define STATIC_RTBL() \
1265     const W_ MK_REP_LBL(Static,,)[] = { \
1266         INCLUDE_TYPE_INFO(STATIC)       \
1267         INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) /* NB: in info table! */ \
1268         INCLUDE_PAR_INFO                 \
1269         INCLUDE_COPYING_INFO(_Evacuate_Static,_Dummy_Static_entry) \
1270         INCLUDE_COMPACTING_INFO(_Dummy_Static_entry,_PRStart_Static, \
1271                                 _Dummy_Static_entry,_Dummy_Static_entry) \
1272         }
1273 \end{code}
1274
1275 %************************************************************************
1276 %*                                                                      *
1277 \subsection[MallocPtr_ITBL]{@MallocPtr_TBL@: @MallocPtr@ info-table}
1278 %*                                                                      *
1279 %************************************************************************
1280
1281 The following table is a bit like that for @SPEC@ with 0 pointers and
1282 a small number of non-ptrs.  However, the garbage collection routines
1283 are a bit special.
1284
1285 I'm assuming @SPEC_N@, so that we don't need to pad out the info table. (JSM)
1286
1287 \begin{code}
1288 #if !defined(PAR)
1289
1290 # define MallocPtr_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) /*size,ptrs unused*/ \
1291     CAT_DECLARE(infolbl,kind,descr,type)        \
1292     entry_localness(entry_code);                \
1293     localness W_ infolbl[] = {                  \
1294         (W_) entry_code                         \
1295         ,(W_) tag                               \
1296         ,(W_) MK_REP_REF(MallocPtr,,)           \
1297         INCLUDE_PROFILING_INFO(infolbl)         \
1298     }
1299
1300 MAYBE_DECLARE_RTBL(MallocPtr,,)
1301
1302 # define MallocPtr_RTBL() \
1303     const W_ MK_REP_LBL(MallocPtr,,)[] = { \
1304         INCLUDE_TYPE_INFO(INTERNAL)                             \
1305         INCLUDE_SIZE_INFO(MallocPtr_SIZE, 0L)                   \
1306         INCLUDE_PAR_INFO                                        \
1307         INCLUDE_COPYING_INFO(_Evacuate_MallocPtr,_Scavenge_MallocPtr)   \
1308         SPEC_COMPACTING_INFO(_ScanLink_MallocPtr,_PRStart_MallocPtr,_ScanMove_MallocPtr,_PRIn_0) \
1309         }
1310
1311 #endif /* !PAR */
1312 \end{code}
1313
1314 %************************************************************************
1315 %*                                                                      *
1316 \subsection[BH_ITBL]{Info tables for ``black holes''}
1317 %*                                                                      *
1318 %************************************************************************
1319
1320 Special info-table for black holes. It is possible to describe these
1321 using @SPEC@ closures but this requires explicit use of the value of
1322 @MIN_UPD_SIZE@. For now we have a special macro and code.
1323
1324 \begin{code}
1325
1326 #define BH_ITBL(infolbl,bh_code,kind,localness,entry_localness) \
1327     entry_localness(bh_code);                   \
1328     localness W_ infolbl[] = {                  \
1329         (W_) bh_code                            \
1330         ,(W_) INFO_OTHER_TAG                    \
1331         ,(W_) MK_REP_REF(BH,kind,)              \
1332         INCLUDE_PROFILING_INFO(BH)              \
1333     }
1334
1335 MAYBE_DECLARE_RTBL(BH,U,)
1336 MAYBE_DECLARE_RTBL(BH,N,)
1337
1338 #define BH_RTBL(kind)                                                           \
1339     const W_ MK_REP_LBL(BH,kind,)[] = {                                         \
1340         INCLUDE_TYPE_INFO(BH)                                                   \
1341         INCLUDE_SIZE_INFO(CAT3(BH_,kind,_SIZE),0L)                              \
1342         INCLUDE_PAR_INFO                                                        \
1343         INCLUDE_COPYING_INFO(CAT2(_Evacuate_BH_,kind),CAT2(_Scavenge_BH_,kind)) \
1344         INCLUDE_COMPACTING_INFO(CAT2(_ScanLink_BH_,kind),_PRStart_BH,           \
1345                                 CAT2(_ScanMove_BH_,kind),_PRIn_Error)           \
1346     }
1347
1348 \end{code}
1349
1350 %************************************************************************
1351 %*                                                                      *
1352 \subsection[IND_ITBL]{Info table for indirections}
1353 %*                                                                      *
1354 %************************************************************************
1355
1356 An indirection simply extracts the pointer from the
1357 @IND_CLOSURE_PTR(closure)@ field. The garbage collection routines will
1358 short out the indirection (normally).
1359 \begin{code}
1360
1361 #define IND_ITBL(infolbl,ind_code,localness,entry_localness) \
1362     CAT_DECLARE(infolbl,INTERNAL_KIND,"IND","IND")      \
1363     entry_localness(ind_code);                          \
1364     localness W_ infolbl[] = {                          \
1365         (W_) ind_code                                   \
1366         ,(W_) INFO_IND_TAG                              \
1367         ,(W_) MK_REP_REF(Ind,,)                         \
1368         INCLUDE_PROFILING_INFO(infolbl)                 \
1369         }
1370
1371 MAYBE_DECLARE_RTBL(Ind,,)
1372
1373 #define IND_RTBL()                                                              \
1374     const W_ MK_REP_LBL(Ind,,)[] = {                                            \
1375         INCLUDE_TYPE_INFO(IND)                                                  \
1376         INCLUDE_SIZE_INFO(MIN_UPD_SIZE,INFO_UNUSED) /* #ptrs not here! */       \
1377         INCLUDE_PAR_INFO                                                        \
1378         INCLUDE_COPYING_INFO(_Evacuate_Ind,_Scavenge_Ind)                       \
1379         INCLUDE_COMPACTING_INFO(_Dummy_Ind_entry,_PRStart_Ind,                  \
1380                                 _Dummy_Ind_entry,_Dummy_Ind_entry)              \
1381     }
1382
1383 \end{code}
1384
1385 Lexical-scoped profiling (now more-or-less the default... 94/06)
1386 requires a special permanent indirection for PAP closures.  These
1387 look exactly like regular indirections, but they are not short-circuited
1388 on garbage collection.
1389
1390 \begin{code}
1391 #if defined(PROFILING) || defined(TICKY_TICKY)
1392
1393 # define PERM_IND_ITBL(infolbl,ind_code,localness,entry_localness) \
1394     entry_localness(ind_code);                          \
1395     CAT_DECLARE(infolbl,INTERNAL_KIND,"IND","IND")      \
1396     localness W_ infolbl[] = {                          \
1397         (W_) ind_code                                   \
1398         ,(W_) INFO_IND_TAG                              \
1399         ,(W_) MK_REP_REF(Perm_Ind,,)                    \
1400         INCLUDE_PROFILING_INFO(infolbl)                 \
1401     }
1402
1403 MAYBE_DECLARE_RTBL(Perm_Ind,,)
1404
1405 # define PERM_IND_RTBL()                                                        \
1406     const W_ MK_REP_LBL(Perm_Ind,,)[] = {                                       \
1407         INCLUDE_TYPE_INFO(IND)                                                  \
1408         INCLUDE_SIZE_INFO(MIN_UPD_SIZE,INFO_UNUSED) /* #ptrs not here! */       \
1409         INCLUDE_PAR_INFO                                                        \
1410         INCLUDE_COPYING_INFO(_Evacuate_PI,_Scavenge_PI)                         \
1411         SPEC_COMPACTING_INFO(_ScanLink_PI,_PRStart_PI,                          \
1412                              _ScanMove_PI,_PRIn_PI)                             \
1413         }
1414
1415 #else
1416 # define PERM_IND_RTBL()
1417 #endif
1418 \end{code}
1419
1420 %************************************************************************
1421 %*                                                                      *
1422 \subsection[CAF_ITBL]{Info table for updated @CAF@s}
1423 %*                                                                      *
1424 %************************************************************************
1425
1426 Garbage collection of @CAF@s is tricky.  We have to cope with explicit
1427 collection from the @CAFlist@ as well as potential references from the
1428 stack and heap which will cause the @CAF@ evacuation code to be
1429 called.  They are treated like indirections which are shorted out.
1430 However they must also be updated to point to the new location of the
1431 new closure as the @CAF@ may still be used by references which
1432 reside in the code.
1433
1434 \subsubsection{Copying Collection}
1435
1436 A first scheme might use evacuation code which evacuates the reference
1437 and updates the indirection. This is no good as subsequent evacuations
1438 will result in an already evacuated closure being evacuated. This will
1439 leave a forward reference in to-space!
1440
1441 An alternative scheme evacuates the @CAFlist@ first. The closures
1442 referenced are evacuated and the @CAF@ indirection updated to point to
1443 the evacuated closure. The @CAF@ evacuation code simply returns the
1444 updated indirection pointer --- the pointer to the evacuated closure.
1445 Unfortunately the closure the @CAF@ references may be a static
1446 closure, in fact, it may be another @CAF@. This will cause the second
1447 @CAF@'s evacuation code to be called before the @CAF@ has been
1448 evacuated, returning an unevacuated pointer.
1449
1450 Another scheme leaves updating the @CAF@ indirections to the end of
1451 the garbage collection.  All the references are evacuated and
1452 scavenged as usual (including the @CAFlist@). Once collection is
1453 complete the @CAFlist@ is traversed updating the @CAF@ references with
1454 the result of evacuating the referenced closure again. This will
1455 immediately return as it must be a forward reference, a static
1456 closure, or a @CAF@ which will indirect by evacuating its reference.
1457
1458 The crux of the problem is that the @CAF@ evacuation code needs to
1459 know if its reference has already been evacuated and updated. If not,
1460 then the reference can be evacuated, updated and returned safely
1461 (possibly evacuating another @CAF@). If it has, then the updated
1462 reference can be returned. This can be done using two @CAF@
1463 info-tables. At the start of a collection the @CAFlist@ is traversed
1464 and set to an internal {\em evacuate and update} info-table. During
1465 collection, evacution of such a @CAF@ also results in the info-table
1466 being reset back to the standard @CAF@ info-table. Thus subsequent
1467 evacuations will simply return the updated reference. On completion of
1468 the collection all @CAF@s will have {\em return reference} info-tables
1469 again.
1470
1471 This is the scheme we adopt. A @CAF@ indirection has evacuation code
1472 which returns the evacuated and updated reference. During garbage
1473 collection, all the @CAF@s are overwritten with an internal @CAF@ info
1474 table which has evacuation code which performs this evacuate and
1475 update and restores the original @CAF@ code. At some point during the
1476 collection we must ensure that all the @CAF@s are indeed evacuated.
1477
1478 The only potential problem with this scheme is a cyclic list of @CAF@s
1479 all directly referencing (possibly via indirections) another @CAF@!
1480 Evacuation of the first @CAF@ will fail in an infinite loop of @CAF@
1481 evacuations. This is solved by ensuring that the @CAF@ info-table is
1482 updated to a {\em return reference} info-table before performing the
1483 evacuate and update. If this {\em return reference} evacuation code is
1484 called before the actual evacuation is complete it must be because
1485 such a cycle of references exists. Returning the still unevacuated
1486 reference is OK --- all the @CAF@s will now reference the same
1487 @CAF@ which will reference itself! Construction of such a structure
1488 indicates the program must be in an infinite loop.
1489
1490 \subsubsection{Compacting Collector}
1491
1492 When shorting out a @CAF@, its reference must be marked. A first
1493 attempt might explicitly mark the @CAF@s, updating the reference with
1494 the marked reference (possibly short circuting indirections). The
1495 actual @CAF@ marking code can indicate that they have already been
1496 marked (though this might not have actually been done yet) and return
1497 the indirection pointer so it is shorted out. Unfortunately the @CAF@
1498 reference might point to an indirection which will be subsequently
1499 shorted out. Rather than returning the @CAF@ reference we treat the
1500 @CAF@ as an indirection, calling the mark code of the reference, which
1501 will return the appropriately shorted reference.
1502
1503 Problem: Cyclic list of @CAF@s all directly referencing (possibly via
1504 indirections) another @CAF@!
1505
1506 Before compacting, the locations of the @CAF@ references are
1507 explicitly linked to the closures they reference (if they reference
1508 heap allocated closures) so that the compacting process will update
1509 them to the closure's new location. Unfortunately these locations'
1510 @CAF@ indirections are static.  This causes premature termination
1511 since the test to find the info pointer at the end of the location
1512 list will match more than one value.  This can be solved by using an
1513 auxiliary dynamic array (on the top of the A stack).  One location for
1514 each @CAF@ indirection is linked to the closure that the @CAF@
1515 references. Once collection is complete this array is traversed and
1516 the corresponding @CAF@ is then updated with the updated pointer from
1517 the auxiliary array.
1518
1519 \begin{code}
1520
1521 #define CAF_ITBL(infolbl,ind_code,localness,entry_localness) \
1522     CAT_DECLARE(infolbl,INTERNAL_KIND,"CAF","CAF")      \
1523     entry_localness(ind_code);                          \
1524     localness W_ infolbl[] = {                          \
1525         (W_) ind_code                                   \
1526         ,(W_) INFO_IND_TAG                              \
1527         ,(W_) MK_REP_REF(Caf,,)                         \
1528         INCLUDE_PROFILING_INFO(infolbl)                 \
1529     }
1530
1531 MAYBE_DECLARE_RTBL(Caf,,)
1532
1533 #define CAF_RTBL()                                                              \
1534     const W_ MK_REP_LBL(Caf,,)[] = {                                            \
1535         INCLUDE_TYPE_INFO(CAF)                                                  \
1536         INCLUDE_SIZE_INFO(MIN_UPD_SIZE,INFO_UNUSED) /* #ptrs not here! */       \
1537         INCLUDE_PAR_INFO                                                        \
1538         INCLUDE_COPYING_INFO(_Evacuate_Caf,_Scavenge_Caf)                       \
1539         INCLUDE_COMPACTING_INFO(_Dummy_Caf_entry,_PRStart_Caf,                  \
1540                                 _Dummy_Caf_entry,_Dummy_Caf_entry)              \
1541         }
1542 \end{code}
1543
1544
1545 It is possible to use an alternative marking scheme, using a similar
1546 idea to the copying solution. This scheme avoids the need to update
1547 the @CAF@ references explicitly. We introduce an auxillary {\em mark
1548 and update} @CAF@ info-table which is used to update all @CAF@s at the
1549 start of a collection. The new code marks the @CAF@ reference,
1550 updating it with the returned reference.  The returned reference is
1551 itself returned so the @CAF@ is shorted out.  The code also modifies the
1552 @CAF@ info-table to be a {\em return reference}.  Subsequent attempts to
1553 mark the @CAF@ simply return the updated reference.
1554
1555 A cyclic @CAF@ reference will result in an attempt to mark the @CAF@
1556 before the marking has been completed and the reference updated. We
1557 cannot start marking the @CAF@ as it is already being marked. Nor can
1558 we return the reference as it has not yet been updated. Neither can we
1559 treat the CAF as an indirection since the @CAF@ reference has been
1560 obscured by the pointer reversal stack. All we can do is return the
1561 @CAF@ itself. This will result in some @CAF@ references not being
1562 shorted out.
1563
1564 This scheme has not been adopted but has been implemented. The code is
1565 commented out with @#if 0@.
1566
1567 %************************************************************************
1568 %*                                                                      *
1569 \subsection[CONST_ITBL]{@CONST_ITBL@}
1570 %*                                                                      *
1571 %************************************************************************
1572
1573 This declares an info table for @CONST@ closures (size 0).  It is the
1574 info table for a dynamicaly-allocated closure which will redirect
1575 references to the corresponding static closure @<infolbl>_closure@
1576 during garbage collection.  A pointer to the static closure is kept in
1577 the info table.  (It is assumed that this closure is declared
1578 elsewhere.)
1579
1580 Why do such @CONST@ objects ever exist?  Why don't we just use the
1581 static object in the first place?  @CONST@ objects are used only for
1582 updating existing objects.  We could use an indirection, but that
1583 risks costing extra run-time indirections until the next GC shorts it
1584 out.  So we update with a @CONST@, and the next GC gets rid of it.
1585
1586 \begin{code}
1587 #define CONST_ITBL(infolbl,closurelbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) /*size,ptrs unused*/ \
1588     CAT_DECLARE(infolbl,kind,descr,type)        \
1589     entry_localness(entry_code);                \
1590     EXTDATA(closurelbl);                        \
1591     localness W_ infolbl[] = {                  \
1592         (W_) entry_code                         \
1593         ,(W_) tag                               \
1594         ,(W_) MK_REP_REF(Const,,)               \
1595         INCLUDE_PROFILING_INFO(infolbl)         \
1596         INCLUDE_UPDATE_INFO(upd_code,liveness)  \
1597         INCLUDE_CONST_INFO(closurelbl)          \
1598         }
1599
1600 MAYBE_DECLARE_RTBL(Const,,)
1601
1602 #ifdef TICKY_TICKY
1603     /* we need real routines if we may not be commoning up */
1604 #define CONST_Scav _Scavenge_0_0
1605 #define CONST_Link _ScanLink_0_0
1606 #define CONST_Move _ScanMove_0
1607 #else
1608 #define CONST_Scav _Dummy_Const_entry
1609 #define CONST_Link _Dummy_Const_entry
1610 #define CONST_Move _Dummy_Const_entry
1611 #endif
1612
1613 #define CONST_RTBL()                                            \
1614     const W_ MK_REP_LBL(Const,,)[] = {                          \
1615         INCLUDE_TYPE_INFO(CONST)                                \
1616         INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED)              \
1617         INCLUDE_PAR_INFO                                        \
1618         INCLUDE_COPYING_INFO(_Evacuate_Const,CONST_Scav)        \
1619         INCLUDE_COMPACTING_INFO(CONST_Link,_PRStart_Const,      \
1620                                 CONST_Move,_Dummy_Const_entry)  \
1621     }
1622 \end{code}
1623
1624 This builds an info-table which will have pointers to the closure
1625 replaced with @closure_lbl@ during garbage collection. @closure_lbl@
1626 must be the label of a static closure, whose entry code has identical
1627 behaviour to that in the corresponding @CONST_ITBL@.  Usually
1628 the info pointer of this closure will be the very one defined by this
1629 macro!
1630
1631 These closures always consist only of an info pointer; that is, its
1632 size is zero.
1633
1634 A copying collection implements this with evacuation code which
1635 returns @closure_lbl@, without actually evacuating the object at all.
1636 A compacting collector uses marking code which returns
1637 @closure_lbl@, without marking the closure.
1638
1639 %************************************************************************
1640 %*                                                                      *
1641 \subsection[FOOLIKE_ITBL]{``Char-like'' and ``Int-like'' info-tables}
1642 %*                                                                      *
1643 %************************************************************************
1644
1645 Char-like: This builds an info-table which, when GC happens, will have
1646 pointers to the closure replaced with the appropriate element of the
1647 @CHARLIKE_closures@ array.
1648
1649 \begin{code}
1650 #define CHARLIKE_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) /*tag,size,ptrs unused*/ \
1651     CAT_DECLARE(infolbl,kind,descr,type)        \
1652     entry_localness(entry_code);                \
1653     localness W_ infolbl[] = {                  \
1654         (W_) entry_code                         \
1655         ,(W_) INFO_FIRST_TAG                    \
1656         ,(W_) MK_REP_REF(CharLike,,)            \
1657         INCLUDE_PROFILING_INFO(infolbl)         \
1658         INCLUDE_UPDATE_INFO(upd_code,liveness)  \
1659         }
1660
1661 MAYBE_DECLARE_RTBL(CharLike,,)
1662
1663 #ifdef TICKY_TICKY
1664     /* we need real routines if we may not be commoning up */
1665 #define CHARLIKE_Scav _Scavenge_1_0
1666 #define CHARLIKE_Link _ScanLink_1_0
1667 #define CHARLIKE_Move _ScanMove_1
1668 #else
1669 #define CHARLIKE_Scav _Dummy_CharLike_entry
1670 #define CHARLIKE_Link _Dummy_CharLike_entry
1671 #define CHARLIKE_Move _Dummy_CharLike_entry
1672 #endif
1673
1674 #define CHARLIKE_RTBL()                                                 \
1675     const W_ MK_REP_LBL(CharLike,,)[] = {                               \
1676         INCLUDE_TYPE_INFO(CHARLIKE)                                     \
1677         INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED)                      \
1678         INCLUDE_PAR_INFO                                                \
1679         INCLUDE_COPYING_INFO(_Evacuate_CharLike,CHARLIKE_Scav)          \
1680         INCLUDE_COMPACTING_INFO(CHARLIKE_Link,_PRStart_CharLike,        \
1681                                 CHARLIKE_Move,_PRIn_Error)              \
1682         }
1683 \end{code}
1684
1685 Int-like: this builds the info-table required for intlike closures.
1686 The normal heap-allocated info-table for fixed-size integers (size
1687 @1@); it is used for updates too.  At GC, this is redirected to a
1688 static intlike closure if one is available.
1689
1690 \begin{code}
1691 #define INTLIKE_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) /*tag,size,ptrs unused*/ \
1692     CAT_DECLARE(infolbl,kind,descr,type)        \
1693     entry_localness(entry_code);                \
1694     localness W_ infolbl[] = {                  \
1695         (W_) entry_code                         \
1696         ,(W_) INFO_FIRST_TAG                    \
1697         ,(W_) MK_REP_REF(IntLike,,)             \
1698         INCLUDE_PROFILING_INFO(infolbl)         \
1699         INCLUDE_UPDATE_INFO(upd_code,liveness)  \
1700     }
1701
1702 MAYBE_DECLARE_RTBL(IntLike,,)
1703
1704 #define INTLIKE_RTBL()                                                  \
1705     const W_ MK_REP_LBL(IntLike,,)[] = {                                \
1706         INCLUDE_TYPE_INFO(INTLIKE)                                      \
1707         INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED)                      \
1708         INCLUDE_PAR_INFO                                                \
1709         INCLUDE_COPYING_INFO(_Evacuate_IntLike,_Scavenge_1_0)           \
1710         INCLUDE_COMPACTING_INFO(_ScanLink_1_0,_PRStart_IntLike,         \
1711                                 _ScanMove_1,_PRIn_Error)                \
1712     }
1713 \end{code}
1714
1715 %************************************************************************
1716 %*                                                                      *
1717 \subsection[INREGS_ITBL]{@INREGS_ITBL@s}
1718 %*                                                                      *
1719 %************************************************************************
1720
1721 The emaciated info table for a phantom closure that lives only in regs.
1722 We don't need any GC information, because these closures never make it into
1723 the heap (not with this info table, anyway).  Similarly, we don't need an
1724 entry address, because these closures are never entered...they only exist
1725 during a return.
1726
1727 \begin{code}
1728
1729 #define INREGS_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) /*mostly unused*/ \
1730     localness W_ infolbl[] = {                  \
1731         (W_) INFO_UNUSED                        \
1732         ,(W_) tag                               \
1733         ,(W_) INFO_UNUSED                       \
1734         INREGS_PROFILING_INFO                   \
1735         INCLUDE_UPDATE_INFO(upd_code,liveness)  \
1736     }
1737
1738 /* Declare the phantom info table vectors (just Bool at the moment) */
1739 #ifndef COMPILING_GHC
1740 EXTDATA_RO(Bool_itblvtbl);
1741 #endif
1742
1743 \end{code}
1744
1745 End multi-slurp protection:
1746 \begin{code}
1747 #endif /* SMInfoTables_H */
1748 \end{code}