2 % (c) The OBFUSCATION-THROUGH-GRATUITOUS-PREPROCESSOR-ABUSE Project,
3 % Glasgow University, 1990-1994
5 %************************************************************************
7 \section[info-table-macros]{Info-table macros}
9 %************************************************************************
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.
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.
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
33 Info-table reversal is hidden behind the @IREL@ macro.
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.
41 The name used to create labels for the info-table, profiling
44 \item[\tr{entry_code}:]
45 The function which is called when entering the closure.
47 \item[\tr{update_code}:]
48 The function which is called when updating the closure (constructors only).
51 (So much for the Spineless {\em Tagless} G-Machine...) Used for
55 Similar-but-different info to the \tr{tag} stuff; the
56 parallel world needs more elaborate info.
59 The size of the closure (see \tr{SMClosures.lh} for a precise
60 definition of ``size''). Used by the garbage-collector, not the
64 The number of pointers in the closure. Used by the garbage-collector,
65 not the Haskell reducer.
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.
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:
77 The entry code is global.
79 The entry code is local.
83 This identifies the general sort of the closure for profiling purposes.
84 It can have the following values (defined in CostCentre.lh):
92 A partial application.
94 A thunk, or suspension.
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.
110 This is a string used to identify the closure for profiling purposes.
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");
118 %************************************************************************
120 \subsection[info-table-common-up]{The commoned-up info-table world}
122 %************************************************************************
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.
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.
134 Size and pointers fields go away altogether, save for @GEN@ closures
135 where they are tacked on to the end of info-tables.
137 %************************************************************************
139 \subsection[info-table-common]{Bits common to all info-tables}
141 %************************************************************************
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.
147 Multi-slurp protection:
149 #ifndef SMInfoTables_H
150 #define SMInfoTables_H
154 #ifdef __STG_REV_TBLS__
156 # define IREL(offset) (-(offset))
158 /* NB: the ENT_ macro (StgMacros.lh) must also be changed */
160 # define ENTRY_CODE(infoptr) ((F_)(infoptr))
162 #else /* boring non-reversed info tables */
164 # define IREL(offset) (offset)
166 # define ENTRY_CODE(infoptr) (((FP_)(infoptr))[IREL(0)])
168 #endif /* non-fixed size info tables */
172 #define INFO_TAG(infoptr) ((I_) ((P_)(infoptr))[IREL(1)])
173 #define EVAL_TAG(infoptr) (INFO_TAG(infoptr) >= 0)
178 #define INFO_INTERNAL (~0L) /* Should never see this */
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?
189 %************************************************************************
191 \subsection[info-table-rtbl]{Rep tables in an info table}
193 %************************************************************************
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.
200 #if defined(COMPILING_REP_LC) || defined(COMPILING_GHC)
201 # define MAYBE_DECLARE_RTBL(l,s,p)
203 # define MAYBE_DECLARE_RTBL(l,s,p) EXTDATA_RO(MK_REP_REF(l,s,p));
206 #define INFO_RTBL(infoptr) (((PP_)(infoptr))[IREL(2)])
209 %************************************************************************
211 \subsection{Maybe-there-maybe-not fields in an info table}
213 %************************************************************************
215 That's about it for the fixed stuff...entry code, a tag and an RTBL pointer.
218 #define FIXED_INFO_WORDS 3
221 %************************************************************************
223 \subsubsection{Profiling-only fields in an info table}
225 %************************************************************************
227 These macros result in the profiling kind and description string being
228 included only if required.
230 #define PROFILING_INFO_OFFSET (FIXED_INFO_WORDS)
232 #if !defined(PROFILING)
233 # define PROFILING_INFO_WORDS 0
234 # define INCLUDE_PROFILING_INFO(base_name)
235 # define INREGS_PROFILING_INFO
238 # define PROFILING_INFO_WORDS 1
240 # define INCLUDE_PROFILING_INFO(base_name) , (W_)REF_CAT_IDENT(base_name)
241 # define INREGS_PROFILING_INFO ,INFO_UNUSED
243 # define INFO_CAT(infoptr) (((ClCategory *)(infoptr))[IREL(PROFILING_INFO_OFFSET)])
248 %************************************************************************
250 \subsubsection{Non-standard fields in an info table: where they'll be}
252 %************************************************************************
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:
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@).
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.
277 #define UPDATE_INFO_OFFSET (PROFILING_INFO_OFFSET+PROFILING_INFO_WORDS)
280 # define UPDATE_INFO_WORDS 1
281 # define INCLUDE_UPDATE_INFO(upd,live) ,(W_)upd
283 # define UPDATE_INFO_WORDS 2
284 # define INCLUDE_UPDATE_INFO(upd,live) ,(W_)upd,(W_)live
287 #define UPDATE_CODE(infoptr) (((FP_)(infoptr))[IREL(UPDATE_INFO_OFFSET)])
288 #define INFO_LIVENESS(infoptr) (((P_)(infoptr))[IREL(UPDATE_INFO_OFFSET+1)])
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
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
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)])
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.
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
314 #define CONST_STATIC_CLOSURE(infoptr) (((PP_)(infoptr))[IREL(CONST_INFO_OFFSET)])
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).
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
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)])
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.
340 # define RBH_INFO_OFFSET (GEN_INFO_OFFSET+GEN_INFO_WORDS)
342 # define INCLUDE_SPEC_PADDING \
343 INCLUDE_UPDATE_INFO(INFO_UNUSED,INFO_UNUSED) \
344 INCLUDE_GEN_INFO(INFO_UNUSED,INFO_UNUSED)
346 # ifdef RBH_MAGIC_OFFSET
348 # define RBH_INFO_WORDS 0
349 # define INCLUDE_RBH_INFO(infoptr)
351 # define RBH_INFOPTR(infoptr) (((P_)infoptr) - RBH_MAGIC_OFFSET)
352 # define REVERT_INFOPTR(infoptr) (((P_)infoptr) + RBH_MAGIC_OFFSET)
356 # define RBH_INFO_WORDS 1
357 # define INCLUDE_RBH_INFO(infoptr) ,(W_)infoptr
359 # define RBH_INFOPTR(infoptr) (((PP_)(infoptr))[IREL(RBH_INFO_OFFSET)])
360 # define REVERT_INFOPTR(infoptr) (((PP_)(infoptr))[IREL(RBH_INFO_OFFSET)])
365 P_ convertToRBH PROTO((P_ closure));
366 void convertToFetchMe PROTO((P_ closure, globalAddr *ga));
370 %************************************************************************
372 \subsection{Maybe-there-maybe-not fields in a rep table}
374 %************************************************************************
376 %************************************************************************
378 \subsubsection{Type field in a rep table}
380 %************************************************************************
382 The @INFO_TYPE@ field in the rep table tells what sort of animal
386 #define TYPE_INFO_OFFSET 0
387 #define TYPE_INFO_WORDS 1
388 #define INCLUDE_TYPE_INFO(kind) (W_)CAT3(INFO_,kind,_TYPE)
390 #define INFO_TYPE(infoptr) (((P_)(INFO_RTBL(infoptr)))[TYPE_INFO_OFFSET])
393 The least significant 9 bits of the info-type are used as follows:
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 \\
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.
417 #define IP_TAG_BITS 9
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 */
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)
438 #define SHOULD_SPARK(closure) ((INFO_TYPE(INFO_PTR(closure))&_NS) == 0)
441 The other bits in the info-type field simply give a unique bit-pattern
442 to identify the closure type.
445 #define IP_TAG_BIT_MASK ((1L<<IP_TAG_BITS)-1)
447 #define BASE_INFO_TYPE(infoptr) (INFO_TYPE(infoptr) & (~IP_TAG_BIT_MASK)) /* Strips out the tag bits */
449 #define MAKE_BASE_INFO_TYPE(x) ((x) << IP_TAG_BITS)
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))
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)
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)
482 #define INFO_BH_N_TYPE (INFO_BH_TYPE)
483 #define INFO_BH_U_TYPE (INFO_BH_TYPE | _UP)
485 #define INFO_STKO_DYNAMIC_TYPE (INFO_STKO_TYPE | _MU)
486 #define INFO_STKO_STATIC_TYPE (INFO_STKO_TYPE | _ST)
488 #define INFO_FETCHME_TYPE (INFO_FM_TYPE | _MU)
489 #define INFO_FMBQ_TYPE (INFO_FM_TYPE | _MU | _BH)
491 #define MIN_INFO_TYPE 0
492 #define MAX_INFO_TYPE INFO_INTERNAL_TYPE
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@.
502 %************************************************************************
504 \subsubsection{Size/no-of-pointers fields in a rep table}
506 %************************************************************************
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
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])
517 %************************************************************************
519 \subsubsection{Parallel-only fields in a rep table}
521 %************************************************************************
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
527 # define PAR_INFO_OFFSET (SIZE_INFO_OFFSET+SIZE_INFO_WORDS)
529 /* now the bits that are either on or off: */
531 # define PAR_INFO_WORDS 0
532 # define INCLUDE_PAR_INFO
535 %************************************************************************
537 \subsubsection{Copying-only fields in a rep table}
539 %************************************************************************
541 These macros result in the copying garbage collection code being
542 included only if required.
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
551 * use these if you have an unquenchable urge to dig around in
552 * info tables (e.g., runtime/.../StgDebug.lc)
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])
558 #else /* ! _INFO_COPYING */
560 # define COPY_INFO_WORDS 0
561 # define INCLUDE_COPYING_INFO(evac, scav)
563 #endif /* ! _INFO_COPYING */
566 %************************************************************************
568 \subsubsection{Compacting-only fields in a rep table}
570 %************************************************************************
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.
577 #if !defined(_INFO_COMPACTING)
579 # define INCLUDE_COMPACTING_INFO(scanlink,prmark,scanmove,marking)
580 # define SPEC_COMPACTING_INFO(scanlink,prmark,scanmove,marking)
582 #else /* defined(_INFO_COMPACTING) */
584 # include "SMcompact.h" /* Single Space Compacting Code */
585 # include "SMmark.h" /* Pointer Reversal Marking Code Labels */
587 /* For SPEC closures compacting info is variable length -> must come last */
589 # define COMPACTING_INFO_OFFSET (COPY_INFO_OFFSET+COPY_INFO_WORDS)
591 # define INCLUDE_COMPACTING_INFO(scanlink,prmark,scanmove,marking) \
592 ,(W_)scanlink,(W_)prmark \
593 ,(W_)scanmove,(W_)marking
595 # define SPEC_COMPACTING_INFO(scanlink,prmark,scanmove,prreturn) \
596 ,(W_)scanlink,(W_)prmark \
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])
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);
615 #endif /* _INFO_COMPACTING */
618 %************************************************************************
620 \subsection[SPEC_ITBL]{@SPEC_x_ITBL@: @SPEC@ info-tables}
622 %************************************************************************
624 Normal-form and updatable (non-normal-form) variants.
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[] = { \
634 ,(W_) MK_REP_REF(Spec_N,size,ptrs) \
635 INCLUDE_PROFILING_INFO(infolbl) \
636 INCLUDE_UPDATE_INFO(upd_code,liveness) \
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)
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) \
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)) \
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[] = { \
677 ,(W_) MK_REP_REF(Spec_S,size,ptrs) \
678 INCLUDE_PROFILING_INFO(infolbl) \
679 INCLUDE_UPDATE_INFO(upd_code,liveness) \
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)
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) \
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)) \
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) \
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[] = { \
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)) \
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)
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) \
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)) \
770 #define _Scavenge_RBH_2_0 _Scavenge_RBH_2_1
771 #define _Scavenge_RBH_2_2 _Scavenge_RBH_2_1
773 #define _Scavenge_RBH_3_0 _Scavenge_RBH_3_1
774 #define _Scavenge_RBH_3_2 _Scavenge_RBH_3_1
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
786 #define _ScanLink_RBH_2_0 _ScanLink_RBH_2_1
787 #define _ScanLink_RBH_2_2 _ScanLink_RBH_2_1
789 #define _ScanLink_RBH_3_0 _ScanLink_RBH_3_1
790 #define _ScanLink_RBH_3_2 _ScanLink_RBH_3_1
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
802 #define _PRStart_RBH_0 _PRStart_RBH_2
803 #define _PRStart_RBH_1 _PRStart_RBH_2
805 #define _PRIn_RBH_0 _PRIn_RBH_2
806 #define _PRIn_RBH_1 _PRIn_RBH_2
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[] = { \
816 ,(W_) MK_REP_REF(Spec_U,size,ptrs) \
817 INCLUDE_PROFILING_INFO(infolbl) \
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)
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) \
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)) \
855 %************************************************************************
857 \subsection[SELECT_ITBL]{@SELECT_ITBL@: Special @SPEC_U@ info-table for selectors}
859 %************************************************************************
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.
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}.
870 Copying: only the evacuate routine needs to be special.
872 Compacting: only the PRStart (marking) routine needs to be special.
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) \
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[] = { \
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)) \
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[] = { \
908 ,(W_) MK_REP_REF(Select,,select_word_i) \
909 INCLUDE_PROFILING_INFO(infolbl) \
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)
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) \
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), \
943 %************************************************************************
945 \subsection[GEN_ITBL]{@GEN_x_ITBL@: Generic/general? info-tables}
947 %************************************************************************
949 @GEN@ info-table for non-updatable nodes (normal and non-normal forms).
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.
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[] = { \
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) \
969 MAYBE_DECLARE_RTBL(Gen_N,,)
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 */ \
976 INCLUDE_COPYING_INFO(_Evacuate_S,_Scavenge_S_N) \
977 INCLUDE_COMPACTING_INFO(_ScanLink_S_N,_PRStart_N,_ScanMove_S,_PRIn_I) \
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[] = { \
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) \
992 MAYBE_DECLARE_RTBL(Gen_S,,)
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 */ \
999 INCLUDE_COPYING_INFO(_Evacuate_S,_Scavenge_S_N) \
1000 INCLUDE_COMPACTING_INFO(_ScanLink_S_N,_PRStart_N,_ScanMove_S,_PRIn_I) \
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) \
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[] = { \
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)) \
1029 MAYBE_DECLARE_RTBL(Gen_RBH,,)
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! */ \
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) \
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[] = { \
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) \
1055 MAYBE_DECLARE_RTBL(Gen_U,,)
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! */ \
1062 INCLUDE_COPYING_INFO(_Evacuate_S,_Scavenge_S_N) \
1063 INCLUDE_COMPACTING_INFO(_ScanLink_S_N,_PRStart_N,_ScanMove_S,_PRIn_I) \
1068 %************************************************************************
1070 \subsection[DYN_ITBL]{Dynamic-object info tables}
1072 %************************************************************************
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
1078 All @DYN@ closures are @PAP@s, so they are not updatable.
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[] = { \
1088 ,(W_) MK_REP_LBL(Dyn,,) \
1089 INCLUDE_PROFILING_INFO(infolbl) \
1092 MAYBE_DECLARE_RTBL(Dyn,,)
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! */ \
1099 INCLUDE_COPYING_INFO(_Evacuate_Dyn,_Scavenge_Dyn) \
1100 INCLUDE_COMPACTING_INFO(_ScanLink_Dyn,_PRStart_Dyn,_ScanMove_Dyn,_PRIn_I_Dyn) \
1105 %************************************************************************
1107 \subsection[TUPLE_ITBL]{``Tuple'' and ``Data'' info-tables}
1109 %************************************************************************
1111 ``Tuples'' are essentially DYNs with all pointers (no non-pointers).
1112 ``Data things'' are DYNs with all non-pointers.
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[] = { \
1122 ,(W_) MK_REP_REF(Tuple,,) \
1123 INCLUDE_PROFILING_INFO(infolbl) \
1126 MAYBE_DECLARE_RTBL(Tuple,,)
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 */ \
1133 INCLUDE_COPYING_INFO(_Evacuate_Tuple,_Scavenge_Tuple) \
1134 INCLUDE_COMPACTING_INFO(_ScanLink_Tuple,_PRStart_Tuple,_ScanMove_Tuple,_PRIn_I_Tuple) \
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[] = { \
1143 ,(W_) MK_REP_REF(Data,,) \
1144 INCLUDE_PROFILING_INFO(infolbl) \
1147 MAYBE_DECLARE_RTBL(Data,,)
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 */ \
1154 INCLUDE_COPYING_INFO(_Evacuate_Data,_Scavenge_Data) \
1155 INCLUDE_COMPACTING_INFO(_ScanLink_Data,_PRStart_Data,_ScanMove_Data,_PRIn_Error) \
1158 /* Here is the decl for the only DATA info table used! */
1159 #ifndef COMPILING_GHC
1160 EXTDATA_RO(ArrayOfData_info);
1164 %************************************************************************
1166 \subsection[MUTUPLE_ITBL]{Info-table for (im)mutable [array-ish] objects}
1168 %************************************************************************
1170 ToDo: Integrate with PAR stuff (Kevin) !!
1171 If someone bothers to document this I'll see what I can do! KH
1175 #if defined(GC_MUT_REQUIRED)
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[] = { \
1183 ,(W_) MK_REP_REF(MuTuple,,) \
1184 INCLUDE_PROFILING_INFO(infolbl) \
1187 MAYBE_DECLARE_RTBL(MuTuple,,)
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! */ \
1194 INCLUDE_COPYING_INFO(_Evacuate_MuTuple,_Scavenge_MuTuple) \
1195 INCLUDE_COMPACTING_INFO(_ScanLink_MuTuple,_PRStart_MuTuple,_ScanMove_MuTuple,_PRIn_I_MuTuple) \
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[] = { \
1204 ,(W_) MK_REP_REF(ImmuTuple,,) \
1205 INCLUDE_PROFILING_INFO(infolbl) \
1208 MAYBE_DECLARE_RTBL(ImmuTuple,,)
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! */ \
1215 INCLUDE_COPYING_INFO(_Evacuate_MuTuple,_Scavenge_MuTuple) \
1216 INCLUDE_COMPACTING_INFO(_ScanLink_MuTuple,_PRStart_MuTuple,_ScanMove_ImmuTuple,_PRIn_I_MuTuple) \
1219 #else /* ! GC_MUT_REQUIRED --- define as TUPLE closure */
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)
1226 # define MUTUPLE_RTBL()
1227 # define IMMUTUPLE_RTBL()
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);
1239 %************************************************************************
1241 \subsection[STATIC_ITBL]{Info tables for static objects (outside the heap)}
1243 %************************************************************************
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
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[] = { \
1256 ,(W_) MK_REP_REF(Static,,) \
1257 INCLUDE_PROFILING_INFO(infolbl) \
1258 INCLUDE_UPDATE_INFO(upd_code,liveness) \
1259 INCLUDE_STATIC_INFO(size,ptrs) \
1262 MAYBE_DECLARE_RTBL(Static,,)
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! */ \
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) \
1275 %************************************************************************
1277 \subsection[MallocPtr_ITBL]{@MallocPtr_TBL@: @MallocPtr@ info-table}
1279 %************************************************************************
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
1285 I'm assuming @SPEC_N@, so that we don't need to pad out the info table. (JSM)
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[] = { \
1296 ,(W_) MK_REP_REF(MallocPtr,,) \
1297 INCLUDE_PROFILING_INFO(infolbl) \
1300 MAYBE_DECLARE_RTBL(MallocPtr,,)
1302 # define MallocPtr_RTBL() \
1303 const W_ MK_REP_LBL(MallocPtr,,)[] = { \
1304 INCLUDE_TYPE_INFO(INTERNAL) \
1305 INCLUDE_SIZE_INFO(MallocPtr_SIZE, 0L) \
1307 INCLUDE_COPYING_INFO(_Evacuate_MallocPtr,_Scavenge_MallocPtr) \
1308 SPEC_COMPACTING_INFO(_ScanLink_MallocPtr,_PRStart_MallocPtr,_ScanMove_MallocPtr,_PRIn_0) \
1314 %************************************************************************
1316 \subsection[BH_ITBL]{Info tables for ``black holes''}
1318 %************************************************************************
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.
1326 #define BH_ITBL(infolbl,bh_code,kind,localness,entry_localness) \
1327 entry_localness(bh_code); \
1328 localness W_ infolbl[] = { \
1330 ,(W_) INFO_OTHER_TAG \
1331 ,(W_) MK_REP_REF(BH,kind,) \
1332 INCLUDE_PROFILING_INFO(BH) \
1335 MAYBE_DECLARE_RTBL(BH,U,)
1336 MAYBE_DECLARE_RTBL(BH,N,)
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) \
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) \
1350 %************************************************************************
1352 \subsection[IND_ITBL]{Info table for indirections}
1354 %************************************************************************
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).
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[] = { \
1366 ,(W_) INFO_IND_TAG \
1367 ,(W_) MK_REP_REF(Ind,,) \
1368 INCLUDE_PROFILING_INFO(infolbl) \
1371 MAYBE_DECLARE_RTBL(Ind,,)
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! */ \
1378 INCLUDE_COPYING_INFO(_Evacuate_Ind,_Scavenge_Ind) \
1379 INCLUDE_COMPACTING_INFO(_Dummy_Ind_entry,_PRStart_Ind, \
1380 _Dummy_Ind_entry,_Dummy_Ind_entry) \
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.
1391 #if defined(PROFILING) || defined(TICKY_TICKY)
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[] = { \
1398 ,(W_) INFO_IND_TAG \
1399 ,(W_) MK_REP_REF(Perm_Ind,,) \
1400 INCLUDE_PROFILING_INFO(infolbl) \
1403 MAYBE_DECLARE_RTBL(Perm_Ind,,)
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! */ \
1410 INCLUDE_COPYING_INFO(_Evacuate_PI,_Scavenge_PI) \
1411 SPEC_COMPACTING_INFO(_ScanLink_PI,_PRStart_PI, \
1412 _ScanMove_PI,_PRIn_PI) \
1416 # define PERM_IND_RTBL()
1420 %************************************************************************
1422 \subsection[CAF_ITBL]{Info table for updated @CAF@s}
1424 %************************************************************************
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
1434 \subsubsection{Copying Collection}
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!
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.
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.
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
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.
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.
1490 \subsubsection{Compacting Collector}
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.
1503 Problem: Cyclic list of @CAF@s all directly referencing (possibly via
1504 indirections) another @CAF@!
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.
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[] = { \
1526 ,(W_) INFO_IND_TAG \
1527 ,(W_) MK_REP_REF(Caf,,) \
1528 INCLUDE_PROFILING_INFO(infolbl) \
1531 MAYBE_DECLARE_RTBL(Caf,,)
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! */ \
1538 INCLUDE_COPYING_INFO(_Evacuate_Caf,_Scavenge_Caf) \
1539 INCLUDE_COMPACTING_INFO(_Dummy_Caf_entry,_PRStart_Caf, \
1540 _Dummy_Caf_entry,_Dummy_Caf_entry) \
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.
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
1564 This scheme has not been adopted but has been implemented. The code is
1565 commented out with @#if 0@.
1567 %************************************************************************
1569 \subsection[CONST_ITBL]{@CONST_ITBL@}
1571 %************************************************************************
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
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.
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[] = { \
1594 ,(W_) MK_REP_REF(Const,,) \
1595 INCLUDE_PROFILING_INFO(infolbl) \
1596 INCLUDE_UPDATE_INFO(upd_code,liveness) \
1597 INCLUDE_CONST_INFO(closurelbl) \
1600 MAYBE_DECLARE_RTBL(Const,,)
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
1608 #define CONST_Scav _Dummy_Const_entry
1609 #define CONST_Link _Dummy_Const_entry
1610 #define CONST_Move _Dummy_Const_entry
1613 #define CONST_RTBL() \
1614 const W_ MK_REP_LBL(Const,,)[] = { \
1615 INCLUDE_TYPE_INFO(CONST) \
1616 INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) \
1618 INCLUDE_COPYING_INFO(_Evacuate_Const,CONST_Scav) \
1619 INCLUDE_COMPACTING_INFO(CONST_Link,_PRStart_Const, \
1620 CONST_Move,_Dummy_Const_entry) \
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
1631 These closures always consist only of an info pointer; that is, its
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.
1639 %************************************************************************
1641 \subsection[FOOLIKE_ITBL]{``Char-like'' and ``Int-like'' info-tables}
1643 %************************************************************************
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.
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[] = { \
1655 ,(W_) INFO_FIRST_TAG \
1656 ,(W_) MK_REP_REF(CharLike,,) \
1657 INCLUDE_PROFILING_INFO(infolbl) \
1658 INCLUDE_UPDATE_INFO(upd_code,liveness) \
1661 MAYBE_DECLARE_RTBL(CharLike,,)
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
1669 #define CHARLIKE_Scav _Dummy_CharLike_entry
1670 #define CHARLIKE_Link _Dummy_CharLike_entry
1671 #define CHARLIKE_Move _Dummy_CharLike_entry
1674 #define CHARLIKE_RTBL() \
1675 const W_ MK_REP_LBL(CharLike,,)[] = { \
1676 INCLUDE_TYPE_INFO(CHARLIKE) \
1677 INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) \
1679 INCLUDE_COPYING_INFO(_Evacuate_CharLike,CHARLIKE_Scav) \
1680 INCLUDE_COMPACTING_INFO(CHARLIKE_Link,_PRStart_CharLike, \
1681 CHARLIKE_Move,_PRIn_Error) \
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.
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[] = { \
1696 ,(W_) INFO_FIRST_TAG \
1697 ,(W_) MK_REP_REF(IntLike,,) \
1698 INCLUDE_PROFILING_INFO(infolbl) \
1699 INCLUDE_UPDATE_INFO(upd_code,liveness) \
1702 MAYBE_DECLARE_RTBL(IntLike,,)
1704 #define INTLIKE_RTBL() \
1705 const W_ MK_REP_LBL(IntLike,,)[] = { \
1706 INCLUDE_TYPE_INFO(INTLIKE) \
1707 INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) \
1709 INCLUDE_COPYING_INFO(_Evacuate_IntLike,_Scavenge_1_0) \
1710 INCLUDE_COMPACTING_INFO(_ScanLink_1_0,_PRStart_IntLike, \
1711 _ScanMove_1,_PRIn_Error) \
1715 %************************************************************************
1717 \subsection[INREGS_ITBL]{@INREGS_ITBL@s}
1719 %************************************************************************
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
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[] = { \
1734 INREGS_PROFILING_INFO \
1735 INCLUDE_UPDATE_INFO(upd_code,liveness) \
1738 /* Declare the phantom info table vectors (just Bool at the moment) */
1739 #ifndef COMPILING_GHC
1740 EXTDATA_RO(Bool_itblvtbl);
1745 End multi-slurp protection:
1747 #endif /* SMInfoTables_H */