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.
100 A Foreign object (non-Haskell heap resident).
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_NCG)
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.
339 #if defined(PAR) || defined(GRAN)
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));
367 void convertFromRBH PROTO((P_ closure));
369 void convertToFetchMe PROTO((P_ closure, globalAddr *ga));
375 %************************************************************************
377 \subsection{Maybe-there-maybe-not fields in a rep table}
379 %************************************************************************
381 %************************************************************************
383 \subsubsection{Type field in a rep table}
385 %************************************************************************
387 The @INFO_TYPE@ field in the rep table tells what sort of animal
391 #define TYPE_INFO_OFFSET 0
392 #define TYPE_INFO_WORDS 1
393 #define INCLUDE_TYPE_INFO(kind) (W_)CAT3(INFO_,kind,_TYPE)
395 #define INFO_TYPE(infoptr) (((P_)(INFO_RTBL(infoptr)))[TYPE_INFO_OFFSET])
398 The least significant 9 bits of the info-type are used as follows:
400 \begin{tabular}{||l|l||} \hline
401 Bit & Interpretation \\ \hline
402 0 & 1 $\Rightarrow$ Head normal form \\
403 1 & 1 $\Rightarrow$ Don't spark me (Any HNF will have this set to 1) \\
404 2 & 1 $\Rightarrow$ This is a static closure \\
405 3 & 1 $\Rightarrow$ Has mutable pointer fields \\
406 4 & 1 $\Rightarrow$ May be updated (inconsistent with being a HNF) \\
407 5 & 1 $\Rightarrow$ Is a "primitive" array (a BIG structure) \\
408 6 & 1 $\Rightarrow$ Is a black hole \\
409 7 & 1 $\Rightarrow$ Is an indirection \\
410 8 & 1 $\Rightarrow$ Is a thunk \\
414 Updatable structures (@_UP@) are thunks that may be shared. Primitive
415 arrays (@_BM@ -- Big Mothers) are structures that are always held
416 in-memory (basically extensions of a closure). Because there may be
417 offsets into these arrays, a primitive array cannot be handled as a
418 FetchMe in the parallel system, but must be shipped in its entirety if
419 its parent closure is shipped.
422 #define IP_TAG_BITS 9
424 #define _NF 0x0001 /* Normal form */
425 #define _NS 0x0002 /* Don't spark */
426 #define _ST 0x0004 /* Is static */
427 #define _MU 0x0008 /* Is mutable */
428 #define _UP 0x0010 /* Is updatable (but not mutable) */
429 #define _BM 0x0020 /* Is a "primitive" array */
430 #define _BH 0x0040 /* Is a black hole */
431 #define _IN 0x0080 /* Is an indirection */
432 #define _TH 0x0100 /* Is a thunk */
434 #define IS_NF(infoptr) ((INFO_TYPE(infoptr)&_NF) != 0)
435 #define IS_MUTABLE(infoptr) ((INFO_TYPE(infoptr)&_MU) != 0)
436 #define IS_STATIC(infoptr) ((INFO_TYPE(infoptr)&_ST) != 0)
437 #define IS_UPDATABLE(infoptr) ((INFO_TYPE(infoptr)&_UP) != 0)
438 #define IS_BIG_MOTHER(infoptr) ((INFO_TYPE(infoptr)&_BM) != 0)
439 #define IS_BLACK_HOLE(infoptr) ((INFO_TYPE(infoptr)&_BH) != 0)
440 #define IS_INDIRECTION(infoptr) ((INFO_TYPE(infoptr)&_IN) != 0)
441 #define IS_THUNK(infoptr) ((INFO_TYPE(infoptr)&_TH) != 0)
443 #define SHOULD_SPARK(closure) ((INFO_TYPE(INFO_PTR(closure))&_NS) == 0)
446 The other bits in the info-type field simply give a unique bit-pattern
447 to identify the closure type.
450 #define IP_TAG_BIT_MASK ((1L<<IP_TAG_BITS)-1)
452 #define BASE_INFO_TYPE(infoptr) (INFO_TYPE(infoptr) & (~IP_TAG_BIT_MASK)) /* Strips out the tag bits */
454 #define MAKE_BASE_INFO_TYPE(x) ((x) << IP_TAG_BITS)
456 #define INFO_SPEC_TYPE (MAKE_BASE_INFO_TYPE(1L))
457 #define INFO_GEN_TYPE (MAKE_BASE_INFO_TYPE(2L))
458 #define INFO_DYN_TYPE (MAKE_BASE_INFO_TYPE(3L) | _NF | _NS)
459 #define INFO_TUPLE_TYPE (MAKE_BASE_INFO_TYPE(4L) | _NF | _NS | _BM)
460 #define INFO_DATA_TYPE (MAKE_BASE_INFO_TYPE(5L) | _NF | _NS | _BM)
461 #define INFO_MUTUPLE_TYPE (MAKE_BASE_INFO_TYPE(6L) | _NF | _NS | _MU | _BM)
462 #define INFO_IMMUTUPLE_TYPE (MAKE_BASE_INFO_TYPE(7L) | _NF | _NS | _BM)
463 #define INFO_STATIC_TYPE (MAKE_BASE_INFO_TYPE(8L) | _NS | _ST)
464 #define INFO_CONST_TYPE (MAKE_BASE_INFO_TYPE(9L) | _NF | _NS)
465 #define INFO_CHARLIKE_TYPE (MAKE_BASE_INFO_TYPE(10L) | _NF | _NS)
466 #define INFO_INTLIKE_TYPE (MAKE_BASE_INFO_TYPE(11L) | _NF | _NS)
467 #define INFO_BH_TYPE (MAKE_BASE_INFO_TYPE(12L) | _NS | _BH)
468 #define INFO_BQ_TYPE (MAKE_BASE_INFO_TYPE(13L) | _NS | _MU | _BH)
469 #define INFO_IND_TYPE (MAKE_BASE_INFO_TYPE(14L) | _NS | _IN)
470 #define INFO_CAF_TYPE (MAKE_BASE_INFO_TYPE(15L) | _NF | _NS | _ST | _IN)
471 #define INFO_FM_TYPE (MAKE_BASE_INFO_TYPE(16L))
472 #define INFO_TSO_TYPE (MAKE_BASE_INFO_TYPE(17L) | _MU)
473 #define INFO_STKO_TYPE (MAKE_BASE_INFO_TYPE(18L))
474 #define INFO_SPEC_RBH_TYPE (MAKE_BASE_INFO_TYPE(19L) | _NS | _MU | _BH)
475 #define INFO_GEN_RBH_TYPE (MAKE_BASE_INFO_TYPE(20L) | _NS | _MU | _BH)
476 #define INFO_BF_TYPE (MAKE_BASE_INFO_TYPE(21L) | _NS | _MU | _BH)
477 #define INFO_INTERNAL_TYPE (MAKE_BASE_INFO_TYPE(22L))
479 /* S = single-entry thunk
481 N = head normal form */
483 #define INFO_SPEC_N_TYPE (INFO_SPEC_TYPE | _NF | _NS)
484 #define INFO_SPEC_S_TYPE (INFO_SPEC_TYPE | _TH)
485 #define INFO_SPEC_U_TYPE (INFO_SPEC_TYPE | _UP | _TH)
487 #define INFO_GEN_N_TYPE (INFO_GEN_TYPE | _NF | _NS)
488 #define INFO_GEN_S_TYPE (INFO_GEN_TYPE | _TH)
489 #define INFO_GEN_U_TYPE (INFO_GEN_TYPE | _UP | _TH)
491 #define INFO_BH_N_TYPE (INFO_BH_TYPE)
492 #define INFO_BH_U_TYPE (INFO_BH_TYPE | _UP)
494 #define INFO_STKO_DYNAMIC_TYPE (INFO_STKO_TYPE | _MU)
495 #define INFO_STKO_STATIC_TYPE (INFO_STKO_TYPE | _ST)
497 #define INFO_FETCHME_TYPE (INFO_FM_TYPE | _MU)
498 #define INFO_FMBQ_TYPE (INFO_FM_TYPE | _MU | _BH)
500 #define MIN_INFO_TYPE 0
501 #define MAX_INFO_TYPE INFO_INTERNAL_TYPE
507 An indirection either points to HNF (post update); or is result of
508 overwriting a FetchMe, in which case the thing fetched is either
509 under evaluation (BH), or by now an HNF. Thus, indirections get @_NS@.
511 %************************************************************************
513 \subsubsection{Size/no-of-pointers fields in a rep table}
515 %************************************************************************
518 #define SIZE_INFO_OFFSET (TYPE_INFO_OFFSET+TYPE_INFO_WORDS)
519 #define SIZE_INFO_WORDS 2
520 #define INCLUDE_SIZE_INFO(size,ptrs) ,(W_)size, (W_)ptrs
522 #define INFO_SIZE(infoptr) ((I_)((FP_)(INFO_RTBL(infoptr)))[SIZE_INFO_OFFSET])
523 #define INFO_NoPTRS(infoptr) ((I_)((FP_)(INFO_RTBL(infoptr)))[SIZE_INFO_OFFSET+1])
526 %************************************************************************
528 \subsubsection{Parallel-only fields in a rep table}
530 %************************************************************************
532 There is now nothing that is specific to the parallel world (GUM), but
533 this could change so don't go deleting this little lot! KH
536 # define PAR_INFO_OFFSET (SIZE_INFO_OFFSET+SIZE_INFO_WORDS)
538 /* now the bits that are either on or off: */
540 # define PAR_INFO_WORDS 0
541 # define INCLUDE_PAR_INFO
544 %************************************************************************
546 \subsubsection{Copying-only fields in a rep table}
548 %************************************************************************
550 These macros result in the copying garbage collection code being
551 included only if required.
553 #if defined(_INFO_COPYING)
554 # include "SMcopying.h" /* Copying Code Labels */
555 # define COPY_INFO_OFFSET (PAR_INFO_OFFSET+PAR_INFO_WORDS)
556 # define COPY_INFO_WORDS 2
557 # define INCLUDE_COPYING_INFO(evac, scav) ,(W_)evac,(W_)scav
560 * use these if you have an unquenchable urge to dig around in
561 * info tables (e.g., runtime/.../StgDebug.lc)
564 # define INFO_EVAC_2S(infoptr) (((FP_)(INFO_RTBL(infoptr)))[COPY_INFO_OFFSET])
565 # define INFO_SCAV_2S(infoptr) (((FP_)(INFO_RTBL(infoptr)))[COPY_INFO_OFFSET + 1])
567 #else /* ! _INFO_COPYING */
569 # define COPY_INFO_WORDS 0
570 # define INCLUDE_COPYING_INFO(evac, scav)
572 #endif /* ! _INFO_COPYING */
575 %************************************************************************
577 \subsubsection{Compacting-only fields in a rep table}
579 %************************************************************************
581 These macros result in the compacting garbage collection code being
582 included only if required. This includes the variable length
583 specialised marking code.
586 #if !defined(_INFO_COMPACTING)
588 # define INCLUDE_COMPACTING_INFO(scanlink,prmark,scanmove,marking)
589 # define SPEC_COMPACTING_INFO(scanlink,prmark,scanmove,marking)
591 #else /* defined(_INFO_COMPACTING) */
593 # include "SMcompact.h" /* Single Space Compacting Code */
594 # include "SMmark.h" /* Pointer Reversal Marking Code Labels */
596 /* For SPEC closures compacting info is variable length -> must come last */
598 # define COMPACTING_INFO_OFFSET (COPY_INFO_OFFSET+COPY_INFO_WORDS)
600 # define INCLUDE_COMPACTING_INFO(scanlink,prmark,scanmove,marking) \
601 ,(W_)scanlink,(W_)prmark \
602 ,(W_)scanmove,(W_)marking
604 # define SPEC_COMPACTING_INFO(scanlink,prmark,scanmove,prreturn) \
605 ,(W_)scanlink,(W_)prmark \
610 # define INFO_SCAN_LINK_1S(infoptr) (((FP_)(INFO_RTBL(infoptr)))[COMPACTING_INFO_OFFSET])
611 # define INFO_MARK_1S(infoptr) (((FP_)(INFO_RTBL(infoptr)))[COMPACTING_INFO_OFFSET+1])
612 # define INFO_SCAN_MOVE_1S(infoptr) (((FP_)(INFO_RTBL(infoptr)))[COMPACTING_INFO_OFFSET+2])
613 # define INFO_MARKED_1S(infoptr) (((FP_)(INFO_RTBL(infoptr)))[COMPACTING_INFO_OFFSET+3])
614 # define INFO_MARKING_1S(infoptr) (((FP_)(INFO_RTBL(infoptr)))[COMPACTING_INFO_OFFSET+4])
616 #ifndef COMPILING_NCG
617 extern F_ _Dummy_Static_entry(STG_NO_ARGS);
618 extern F_ _Dummy_Ind_entry(STG_NO_ARGS);
619 extern F_ _Dummy_Caf_entry(STG_NO_ARGS);
620 extern F_ _Dummy_Const_entry(STG_NO_ARGS);
621 extern F_ _Dummy_CharLike_entry(STG_NO_ARGS);
624 #endif /* _INFO_COMPACTING */
627 %************************************************************************
629 \subsection[SPEC_ITBL]{@SPEC_x_ITBL@: @SPEC@ info-tables}
631 %************************************************************************
633 Normal-form and updatable (non-normal-form) variants.
637 #define SPEC_N_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) \
638 CAT_DECLARE(infolbl,kind,descr,type) \
639 entry_localness(entry_code); \
640 localness W_ infolbl[] = { \
643 ,(W_) MK_REP_REF(Spec_N,size,ptrs) \
644 INCLUDE_PROFILING_INFO(infolbl) \
645 INCLUDE_UPDATE_INFO(upd_code,liveness) \
648 MAYBE_DECLARE_RTBL(Spec_N,1,0)
649 MAYBE_DECLARE_RTBL(Spec_N,1,1)
650 MAYBE_DECLARE_RTBL(Spec_N,2,0)
651 MAYBE_DECLARE_RTBL(Spec_N,2,1)
652 MAYBE_DECLARE_RTBL(Spec_N,2,2)
653 MAYBE_DECLARE_RTBL(Spec_N,3,0)
654 MAYBE_DECLARE_RTBL(Spec_N,3,1)
655 MAYBE_DECLARE_RTBL(Spec_N,3,2)
656 MAYBE_DECLARE_RTBL(Spec_N,3,3)
657 MAYBE_DECLARE_RTBL(Spec_N,4,0)
658 MAYBE_DECLARE_RTBL(Spec_N,4,4)
659 MAYBE_DECLARE_RTBL(Spec_N,5,0)
660 MAYBE_DECLARE_RTBL(Spec_N,5,5)
661 MAYBE_DECLARE_RTBL(Spec_N,6,6)
662 MAYBE_DECLARE_RTBL(Spec_N,7,7)
663 MAYBE_DECLARE_RTBL(Spec_N,8,8)
664 MAYBE_DECLARE_RTBL(Spec_N,9,9)
665 MAYBE_DECLARE_RTBL(Spec_N,10,10)
666 MAYBE_DECLARE_RTBL(Spec_N,11,11)
667 MAYBE_DECLARE_RTBL(Spec_N,12,12)
669 #define SPEC_N_RTBL(size,ptrs) \
670 const W_ MK_REP_LBL(Spec_N,size,ptrs)[] = { \
671 INCLUDE_TYPE_INFO(SPEC_N) \
672 INCLUDE_SIZE_INFO(size,ptrs) \
674 INCLUDE_COPYING_INFO(CAT2(_Evacuate_,size),CAT4(_Scavenge_,size,_,ptrs)) \
675 SPEC_COMPACTING_INFO(CAT4(_ScanLink_,size,_,ptrs), \
676 CAT2(_PRStart_,ptrs), \
677 CAT2(_ScanMove_,size),CAT2(_PRIn_,ptrs)) \
680 #define SPEC_S_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) \
681 CAT_DECLARE(infolbl,kind,descr,type) \
682 entry_localness(entry_code); \
683 localness W_ infolbl[] = { \
686 ,(W_) MK_REP_REF(Spec_S,size,ptrs) \
687 INCLUDE_PROFILING_INFO(infolbl) \
688 INCLUDE_UPDATE_INFO(upd_code,liveness) \
691 MAYBE_DECLARE_RTBL(Spec_S,1,0)
692 MAYBE_DECLARE_RTBL(Spec_S,1,1)
693 MAYBE_DECLARE_RTBL(Spec_S,2,0)
694 MAYBE_DECLARE_RTBL(Spec_S,2,1)
695 MAYBE_DECLARE_RTBL(Spec_S,2,2)
696 MAYBE_DECLARE_RTBL(Spec_S,3,0)
697 MAYBE_DECLARE_RTBL(Spec_S,3,1)
698 MAYBE_DECLARE_RTBL(Spec_S,3,2)
699 MAYBE_DECLARE_RTBL(Spec_S,3,3)
700 MAYBE_DECLARE_RTBL(Spec_S,4,0)
701 MAYBE_DECLARE_RTBL(Spec_S,4,4)
702 MAYBE_DECLARE_RTBL(Spec_S,5,0)
703 MAYBE_DECLARE_RTBL(Spec_S,5,5)
704 MAYBE_DECLARE_RTBL(Spec_S,6,6)
705 MAYBE_DECLARE_RTBL(Spec_S,7,7)
706 MAYBE_DECLARE_RTBL(Spec_S,8,8)
707 MAYBE_DECLARE_RTBL(Spec_S,9,9)
708 MAYBE_DECLARE_RTBL(Spec_S,10,10)
709 MAYBE_DECLARE_RTBL(Spec_S,11,11)
710 MAYBE_DECLARE_RTBL(Spec_S,12,12)
712 #define SPEC_S_RTBL(size,ptrs) \
713 const W_ MK_REP_LBL(Spec_S,size,ptrs)[] = { \
714 INCLUDE_TYPE_INFO(SPEC_S) \
715 INCLUDE_SIZE_INFO(size,ptrs) \
717 INCLUDE_COPYING_INFO(CAT2(_Evacuate_,size),CAT4(_Scavenge_,size,_,ptrs)) \
718 SPEC_COMPACTING_INFO(CAT4(_ScanLink_,size,_,ptrs), \
719 CAT2(_PRStart_,ptrs), \
720 CAT2(_ScanMove_,size),CAT2(_PRIn_,ptrs)) \
723 #if defined(PAR) || defined(GRAN)
724 # define SPEC_U_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) \
725 entry_localness(CAT2(RBH_,entry_code)); \
726 localness W_ infolbl[]; \
727 localness W_ CAT2(RBH_,infolbl)[] = { \
728 (W_) CAT2(RBH_,entry_code) \
729 ,(W_) INFO_OTHER_TAG \
730 ,(W_) MK_REP_REF(Spec_RBH,size,ptrs) \
731 INCLUDE_PROFILING_INFO(RBH) \
732 INCLUDE_SPEC_PADDING \
733 INCLUDE_RBH_INFO(infolbl) \
735 STGFUN(CAT2(RBH_,entry_code)) { JMP_(RBH_entry); }\
736 CAT_DECLARE(infolbl,kind,descr,type) \
737 entry_localness(entry_code); \
738 localness W_ infolbl[] = { \
741 ,(W_) MK_REP_REF(Spec_U,size,ptrs) \
742 INCLUDE_PROFILING_INFO(infolbl) \
743 INCLUDE_SPEC_PADDING \
744 INCLUDE_RBH_INFO(CAT2(RBH_,infolbl)) \
747 MAYBE_DECLARE_RTBL(Spec_RBH,1,0)
748 MAYBE_DECLARE_RTBL(Spec_RBH,1,1)
749 MAYBE_DECLARE_RTBL(Spec_RBH,2,0)
750 MAYBE_DECLARE_RTBL(Spec_RBH,2,1)
751 MAYBE_DECLARE_RTBL(Spec_RBH,2,2)
752 MAYBE_DECLARE_RTBL(Spec_RBH,3,0)
753 MAYBE_DECLARE_RTBL(Spec_RBH,3,1)
754 MAYBE_DECLARE_RTBL(Spec_RBH,3,2)
755 MAYBE_DECLARE_RTBL(Spec_RBH,3,3)
756 MAYBE_DECLARE_RTBL(Spec_RBH,4,0)
757 MAYBE_DECLARE_RTBL(Spec_RBH,4,4)
758 MAYBE_DECLARE_RTBL(Spec_RBH,5,0)
759 MAYBE_DECLARE_RTBL(Spec_RBH,5,5)
760 MAYBE_DECLARE_RTBL(Spec_RBH,6,6)
761 MAYBE_DECLARE_RTBL(Spec_RBH,7,7)
762 MAYBE_DECLARE_RTBL(Spec_RBH,8,8)
763 MAYBE_DECLARE_RTBL(Spec_RBH,9,9)
764 MAYBE_DECLARE_RTBL(Spec_RBH,10,10)
765 MAYBE_DECLARE_RTBL(Spec_RBH,11,11)
766 MAYBE_DECLARE_RTBL(Spec_RBH,12,12)
768 #define SPEC_RBH_RTBL(size,ptrs) \
769 const W_ MK_REP_LBL(Spec_RBH,size,ptrs)[] = { \
770 INCLUDE_TYPE_INFO(SPEC_RBH) \
771 INCLUDE_SIZE_INFO(size,ptrs) \
773 INCLUDE_COPYING_INFO(CAT2(_Evacuate_RBH_,size),CAT4(_Scavenge_RBH_,size,_,ptrs)) \
774 SPEC_COMPACTING_INFO(CAT4(_ScanLink_RBH_,size,_,ptrs), \
775 CAT2(_PRStart_RBH_,ptrs), \
776 CAT2(_ScanMove_RBH_,size),CAT2(_PRIn_RBH_,ptrs)) \
779 #define _Scavenge_RBH_2_0 _Scavenge_RBH_2_1
780 #define _Scavenge_RBH_2_2 _Scavenge_RBH_2_1
782 #define _Scavenge_RBH_3_0 _Scavenge_RBH_3_1
783 #define _Scavenge_RBH_3_2 _Scavenge_RBH_3_1
785 #define _Scavenge_RBH_4_0 _Scavenge_RBH_4_1
786 #define _Scavenge_RBH_5_0 _Scavenge_RBH_5_1
787 #define _Scavenge_RBH_6_0 _Scavenge_RBH_6_1
788 #define _Scavenge_RBH_7_0 _Scavenge_RBH_7_1
789 #define _Scavenge_RBH_8_0 _Scavenge_RBH_8_1
790 #define _Scavenge_RBH_9_0 _Scavenge_RBH_9_1
791 #define _Scavenge_RBH_10_0 _Scavenge_RBH_10_1
792 #define _Scavenge_RBH_11_0 _Scavenge_RBH_11_1
793 #define _Scavenge_RBH_12_0 _Scavenge_RBH_12_1
795 #define _ScanLink_RBH_2_0 _ScanLink_RBH_2_1
796 #define _ScanLink_RBH_2_2 _ScanLink_RBH_2_1
798 #define _ScanLink_RBH_3_0 _ScanLink_RBH_3_1
799 #define _ScanLink_RBH_3_2 _ScanLink_RBH_3_1
801 #define _ScanLink_RBH_4_0 _ScanLink_RBH_4_1
802 #define _ScanLink_RBH_5_0 _ScanLink_RBH_5_1
803 #define _ScanLink_RBH_6_0 _ScanLink_RBH_6_1
804 #define _ScanLink_RBH_7_0 _ScanLink_RBH_7_1
805 #define _ScanLink_RBH_8_0 _ScanLink_RBH_8_1
806 #define _ScanLink_RBH_9_0 _ScanLink_RBH_9_1
807 #define _ScanLink_RBH_10_0 _ScanLink_RBH_10_1
808 #define _ScanLink_RBH_11_0 _ScanLink_RBH_11_1
809 #define _ScanLink_RBH_12_0 _ScanLink_RBH_12_1
811 #define _PRStart_RBH_0 _PRStart_RBH_2
812 #define _PRStart_RBH_1 _PRStart_RBH_2
814 #define _PRIn_RBH_0 _PRIn_RBH_2
815 #define _PRIn_RBH_1 _PRIn_RBH_2
819 # define SPEC_U_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) \
820 CAT_DECLARE(infolbl,kind,descr,type) \
821 entry_localness(entry_code); \
822 localness W_ infolbl[] = { \
825 ,(W_) MK_REP_REF(Spec_U,size,ptrs) \
826 INCLUDE_PROFILING_INFO(infolbl) \
830 MAYBE_DECLARE_RTBL(Spec_U,1,0)
831 MAYBE_DECLARE_RTBL(Spec_U,1,1)
832 MAYBE_DECLARE_RTBL(Spec_U,2,0)
833 MAYBE_DECLARE_RTBL(Spec_U,2,1)
834 MAYBE_DECLARE_RTBL(Spec_U,2,2)
835 MAYBE_DECLARE_RTBL(Spec_U,3,0)
836 MAYBE_DECLARE_RTBL(Spec_U,3,1)
837 MAYBE_DECLARE_RTBL(Spec_U,3,2)
838 MAYBE_DECLARE_RTBL(Spec_U,3,3)
839 MAYBE_DECLARE_RTBL(Spec_U,4,0)
840 MAYBE_DECLARE_RTBL(Spec_U,4,4)
841 MAYBE_DECLARE_RTBL(Spec_U,5,0)
842 MAYBE_DECLARE_RTBL(Spec_U,5,5)
843 MAYBE_DECLARE_RTBL(Spec_U,6,6)
844 MAYBE_DECLARE_RTBL(Spec_U,7,7)
845 MAYBE_DECLARE_RTBL(Spec_U,8,8)
846 MAYBE_DECLARE_RTBL(Spec_U,9,9)
847 MAYBE_DECLARE_RTBL(Spec_U,10,10)
848 MAYBE_DECLARE_RTBL(Spec_U,11,11)
849 MAYBE_DECLARE_RTBL(Spec_U,12,12)
851 #define SPEC_U_RTBL(size,ptrs) \
852 const W_ MK_REP_LBL(Spec_U,size,ptrs)[] = { \
853 INCLUDE_TYPE_INFO(SPEC_U) \
854 INCLUDE_SIZE_INFO(size,ptrs) \
856 INCLUDE_COPYING_INFO(CAT2(_Evacuate_,size),CAT4(_Scavenge_,size,_,ptrs)) \
857 SPEC_COMPACTING_INFO(CAT4(_ScanLink_,size,_,ptrs), \
858 CAT2(_PRStart_,ptrs), \
859 CAT2(_ScanMove_,size),CAT2(_PRIn_,ptrs)) \
864 %************************************************************************
866 \subsection[SELECT_ITBL]{@SELECT_ITBL@: Special @SPEC_U@ info-table for selectors}
868 %************************************************************************
870 These are different only in having slightly-magic GC code. The idea
871 is: it is a @MIN_UPD_SIZE@ (==2) thunk with one pointer, which, when
872 entered, will select word $i$ from its pointee.
874 When garbage-collecting such a closure, we ``peek'' at the pointee's
875 tag (in its info table). If it is evaluated, then we go ahead and do
876 the selection---which is {\em just like an indirection}. If it is not
877 evaluated, we carry on {\em exactly as if it is a size-2/1-ptr thunk}.
879 Copying: only the evacuate routine needs to be special.
881 Compacting: only the PRStart (marking) routine needs to be special.
885 #if defined(PAR) || defined(GRAN)
886 # define SELECT_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,select_word_i,kind,descr,type) \
887 entry_localness(CAT2(RBH_,entry_code)); \
888 localness W_ infolbl[]; \
889 localness W_ CAT2(RBH_,infolbl)[] = { \
890 (W_) CAT2(RBH_,entry_code) \
891 ,(W_) INFO_OTHER_TAG \
892 ,(W_) MK_REP_REF(Spec_RBH,size,ptrs) \
893 INCLUDE_PROFILING_INFO(RBH) \
894 INCLUDE_SPEC_PADDING \
895 INCLUDE_RBH_INFO(infolbl) \
897 STGFUN(CAT2(RBH_,entry_code)) { JMP_(RBH_entry); }\
898 CAT_DECLARE(infolbl,kind,descr,type) \
899 entry_localness(entry_code); \
900 localness W_ infolbl[] = { \
903 ,(W_) MK_REP_REF(Select,,select_word_i) \
904 INCLUDE_PROFILING_INFO(infolbl) \
905 INCLUDE_SPEC_PADDING \
906 INCLUDE_RBH_INFO(CAT2(RBH_,infolbl)) \
911 # define SELECT_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,select_word_i,kind,descr,type) \
912 CAT_DECLARE(infolbl,kind,descr,type) \
913 entry_localness(entry_code); \
914 localness W_ infolbl[] = { \
917 ,(W_) MK_REP_REF(Select,,select_word_i) \
918 INCLUDE_PROFILING_INFO(infolbl) \
923 MAYBE_DECLARE_RTBL(Select,,0)
924 MAYBE_DECLARE_RTBL(Select,,1)
925 MAYBE_DECLARE_RTBL(Select,,2)
926 MAYBE_DECLARE_RTBL(Select,,3)
927 MAYBE_DECLARE_RTBL(Select,,4)
928 MAYBE_DECLARE_RTBL(Select,,5)
929 MAYBE_DECLARE_RTBL(Select,,6)
930 MAYBE_DECLARE_RTBL(Select,,7)
931 MAYBE_DECLARE_RTBL(Select,,8)
932 MAYBE_DECLARE_RTBL(Select,,9)
933 MAYBE_DECLARE_RTBL(Select,,10)
934 MAYBE_DECLARE_RTBL(Select,,11)
935 MAYBE_DECLARE_RTBL(Select,,12)
937 #define SELECT_RTBL(size,ptrs,select_word_i) \
938 const W_ MK_REP_LBL(Select,,select_word_i)[] = { \
939 INCLUDE_TYPE_INFO(SPEC_U) \
940 INCLUDE_SIZE_INFO(size,ptrs) \
942 INCLUDE_COPYING_INFO(CAT2(_EvacuateSelector_,select_word_i), \
943 CAT4(_Scavenge_,size,_,ptrs)) \
944 SPEC_COMPACTING_INFO(CAT4(_ScanLink_,size,_,ptrs), \
945 CAT2(_PRStartSelector_,select_word_i), \
946 CAT2(_ScanMove_,size), \
952 %************************************************************************
954 \subsection[GEN_ITBL]{@GEN_x_ITBL@: Generic/general? info-tables}
956 %************************************************************************
958 @GEN@ info-table for non-updatable nodes (normal and non-normal forms).
960 Size/no-of-ptrs are known at compile time, but we don't have GC
961 routines wired in for those specific sizes. Hence the size/no-of-ptrs
962 is stored in the info-table.
966 #define GEN_N_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) \
967 CAT_DECLARE(infolbl,kind,descr,type) \
968 entry_localness(entry_code); \
969 localness W_ infolbl[] = { \
972 ,(W_) MK_REP_REF(Gen_N,,) \
973 INCLUDE_PROFILING_INFO(infolbl) \
974 INCLUDE_UPDATE_INFO(upd_code,liveness) \
975 INCLUDE_GEN_INFO(size,ptrs) \
978 MAYBE_DECLARE_RTBL(Gen_N,,)
980 #define GEN_N_RTBL() \
981 const W_ MK_REP_LBL(Gen_N,,)[] = { \
982 INCLUDE_TYPE_INFO(GEN_N) \
983 INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) /* NB: in info table */ \
985 INCLUDE_COPYING_INFO(_Evacuate_S,_Scavenge_S_N) \
986 INCLUDE_COMPACTING_INFO(_ScanLink_S_N,_PRStart_N,_ScanMove_S,_PRIn_I) \
989 #define GEN_S_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) \
990 CAT_DECLARE(infolbl,kind,descr,type) \
991 entry_localness(entry_code); \
992 localness W_ infolbl[] = { \
995 ,(W_) MK_REP_REF(Gen_S,,) \
996 INCLUDE_PROFILING_INFO(infolbl) \
997 INCLUDE_UPDATE_INFO(upd_code,liveness) \
998 INCLUDE_GEN_INFO(size,ptrs) \
1001 MAYBE_DECLARE_RTBL(Gen_S,,)
1003 #define GEN_S_RTBL() \
1004 const W_ MK_REP_LBL(Gen_S,,)[] = { \
1005 INCLUDE_TYPE_INFO(GEN_S) \
1006 INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) /* NB: in info table */ \
1008 INCLUDE_COPYING_INFO(_Evacuate_S,_Scavenge_S_N) \
1009 INCLUDE_COMPACTING_INFO(_ScanLink_S_N,_PRStart_N,_ScanMove_S,_PRIn_I) \
1012 #if defined(PAR) || defined(GRAN)
1013 # define GEN_U_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) \
1014 entry_localness(CAT2(RBH_,entry_code)); \
1015 localness W_ infolbl[]; \
1016 localness W_ CAT2(RBH_,infolbl)[] = { \
1017 (W_) CAT2(RBH_,entry_code) \
1018 ,(W_) INFO_OTHER_TAG \
1019 ,(W_) MK_REP_REF(Gen_RBH,,) \
1020 INCLUDE_PROFILING_INFO(RBH) \
1021 INCLUDE_UPDATE_INFO(INFO_UNUSED,INFO_UNUSED) \
1022 INCLUDE_GEN_INFO(size,ptrs) \
1023 INCLUDE_RBH_INFO(infolbl) \
1025 STGFUN(CAT2(RBH_,entry_code)) { JMP_(RBH_entry); }\
1026 CAT_DECLARE(infolbl,kind,descr,type) \
1027 entry_localness(entry_code); \
1028 localness W_ infolbl[] = { \
1031 ,(W_) MK_REP_REF(Gen_U,,) \
1032 INCLUDE_PROFILING_INFO(infolbl) \
1033 INCLUDE_UPDATE_INFO(INFO_UNUSED,INFO_UNUSED) \
1034 INCLUDE_GEN_INFO(size,ptrs) \
1035 INCLUDE_RBH_INFO(CAT2(RBH_,infolbl)) \
1038 MAYBE_DECLARE_RTBL(Gen_RBH,,)
1040 # define GEN_RBH_RTBL() \
1041 const W_ MK_REP_LBL(Gen_RBH,,)[] = { \
1042 INCLUDE_TYPE_INFO(GEN_RBH) \
1043 INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) /* NB: no size/no-ptrs! */ \
1045 INCLUDE_COPYING_INFO(_Evacuate_RBH_S,_Scavenge_RBH_N) \
1046 INCLUDE_COMPACTING_INFO(_ScanLink_RBH_N,_PRStart_RBH_N,_ScanMove_RBH_S,_PRIn_RBH_I) \
1051 # define GEN_U_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) \
1052 CAT_DECLARE(infolbl,kind,descr,type) \
1053 entry_localness(entry_code); \
1054 localness W_ infolbl[] = { \
1057 ,(W_) MK_REP_REF(Gen_U,,) \
1058 INCLUDE_PROFILING_INFO(infolbl) \
1059 INCLUDE_UPDATE_INFO(INFO_UNUSED,INFO_UNUSED) \
1060 INCLUDE_GEN_INFO(size,ptrs) \
1064 MAYBE_DECLARE_RTBL(Gen_U,,)
1066 #define GEN_U_RTBL() \
1067 const W_ MK_REP_LBL(Gen_U,,)[] = { \
1068 INCLUDE_TYPE_INFO(GEN_U) \
1069 INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) /* NB: no size/no-ptrs! */ \
1071 INCLUDE_COPYING_INFO(_Evacuate_S,_Scavenge_S_N) \
1072 INCLUDE_COMPACTING_INFO(_ScanLink_S_N,_PRStart_N,_ScanMove_S,_PRIn_I) \
1077 %************************************************************************
1079 \subsection[DYN_ITBL]{Dynamic-object info tables}
1081 %************************************************************************
1083 For these, the size/no-of-pointers is not known until runtime. E.g.,
1084 arrays. Those fields are, therefore, in the closure itself, and not
1087 All @DYN@ closures are @PAP@s, so they are not updatable.
1091 #define DYN_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) /*size,ptrs unused*/ \
1092 CAT_DECLARE(infolbl,kind,descr,type) \
1093 entry_localness(entry_code); \
1094 localness W_ infolbl[] = { \
1097 ,(W_) MK_REP_LBL(Dyn,,) \
1098 INCLUDE_PROFILING_INFO(infolbl) \
1101 MAYBE_DECLARE_RTBL(Dyn,,)
1103 #define DYN_RTBL() \
1104 const W_ MK_REP_LBL(Dyn,,)[] = { \
1105 INCLUDE_TYPE_INFO(DYN) \
1106 INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) /* in closure! */ \
1108 INCLUDE_COPYING_INFO(_Evacuate_Dyn,_Scavenge_Dyn) \
1109 INCLUDE_COMPACTING_INFO(_ScanLink_Dyn,_PRStart_Dyn,_ScanMove_Dyn,_PRIn_I_Dyn) \
1114 %************************************************************************
1116 \subsection[TUPLE_ITBL]{``Tuple'' and ``Data'' info-tables}
1118 %************************************************************************
1120 ``Tuples'' are essentially DYNs with all pointers (no non-pointers).
1121 ``Data things'' are DYNs with all non-pointers.
1125 #define TUPLE_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) /*size,ptrs unused*/ \
1126 CAT_DECLARE(infolbl,kind,descr,type) \
1127 entry_localness(entry_code); \
1128 localness W_ infolbl[] = { \
1131 ,(W_) MK_REP_REF(Tuple,,) \
1132 INCLUDE_PROFILING_INFO(infolbl) \
1135 MAYBE_DECLARE_RTBL(Tuple,,)
1137 #define TUPLE_RTBL() \
1138 const W_ MK_REP_LBL(Tuple,,)[] = { \
1139 INCLUDE_TYPE_INFO(TUPLE) \
1140 INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) /* NB: in closure */ \
1142 INCLUDE_COPYING_INFO(_Evacuate_Tuple,_Scavenge_Tuple) \
1143 INCLUDE_COMPACTING_INFO(_ScanLink_Tuple,_PRStart_Tuple,_ScanMove_Tuple,_PRIn_I_Tuple) \
1146 #define DATA_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) /*size,ptrs unused*/ \
1147 CAT_DECLARE(infolbl,kind,descr,type) \
1148 entry_localness(entry_code); \
1149 localness W_ infolbl[] = { \
1152 ,(W_) MK_REP_REF(Data,,) \
1153 INCLUDE_PROFILING_INFO(infolbl) \
1156 MAYBE_DECLARE_RTBL(Data,,)
1158 #define DATA_RTBL() \
1159 const W_ MK_REP_LBL(Data,,)[] = { \
1160 INCLUDE_TYPE_INFO(DATA) \
1161 INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) /* NB: in closure */ \
1163 INCLUDE_COPYING_INFO(_Evacuate_Data,_Scavenge_Data) \
1164 INCLUDE_COMPACTING_INFO(_ScanLink_Data,_PRStart_Data,_ScanMove_Data,_PRIn_Error) \
1167 /* Here is the decl for the only DATA info table used! */
1168 #ifndef COMPILING_NCG
1169 EXTDATA_RO(ArrayOfData_info);
1173 %************************************************************************
1175 \subsection[MUTUPLE_ITBL]{Info-table for (im)mutable [array-ish] objects}
1177 %************************************************************************
1179 ToDo: Integrate with PAR stuff (Kevin) !!
1180 If someone bothers to document this I'll see what I can do! KH
1184 #if defined(GC_MUT_REQUIRED)
1186 # define MUTUPLE_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) /*size,ptrs unused*/ \
1187 CAT_DECLARE(infolbl,kind,descr,type) \
1188 entry_localness(entry_code); \
1189 localness W_ infolbl[] = { \
1192 ,(W_) MK_REP_REF(MuTuple,,) \
1193 INCLUDE_PROFILING_INFO(infolbl) \
1196 MAYBE_DECLARE_RTBL(MuTuple,,)
1198 # define MUTUPLE_RTBL() \
1199 const W_ MK_REP_LBL(MuTuple,,)[] = { \
1200 INCLUDE_TYPE_INFO(MUTUPLE) \
1201 INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) /* NB: in closure! */ \
1203 INCLUDE_COPYING_INFO(_Evacuate_MuTuple,_Scavenge_MuTuple) \
1204 INCLUDE_COMPACTING_INFO(_ScanLink_MuTuple,_PRStart_MuTuple,_ScanMove_MuTuple,_PRIn_I_MuTuple) \
1207 # define IMMUTUPLE_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) /*size,ptrs unused*/ \
1208 CAT_DECLARE(infolbl,kind,descr,type) \
1209 entry_localness(entry_code); \
1210 localness W_ infolbl[] = { \
1213 ,(W_) MK_REP_REF(ImmuTuple,,) \
1214 INCLUDE_PROFILING_INFO(infolbl) \
1217 MAYBE_DECLARE_RTBL(ImmuTuple,,)
1219 # define IMMUTUPLE_RTBL() \
1220 const W_ MK_REP_LBL(ImmuTuple,,)[] = { \
1221 INCLUDE_TYPE_INFO(IMMUTUPLE) \
1222 INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) /* NB: in closure! */ \
1224 INCLUDE_COPYING_INFO(_Evacuate_MuTuple,_Scavenge_MuTuple) \
1225 INCLUDE_COMPACTING_INFO(_ScanLink_MuTuple,_PRStart_MuTuple,_ScanMove_ImmuTuple,_PRIn_I_MuTuple) \
1228 #else /* ! GC_MUT_REQUIRED --- define as TUPLE closure */
1230 # define MUTUPLE_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) \
1231 TUPLE_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type)
1232 # define IMMUTUPLE_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) \
1233 TUPLE_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type)
1235 # define MUTUPLE_RTBL()
1236 # define IMMUTUPLE_RTBL()
1239 /* Here are the decls for the only MUTUPLE info tables used. */
1240 #ifndef COMPILING_NCG
1241 EXTDATA_RO(ArrayOfPtrs_info);
1242 EXTDATA_RO(ImMutArrayOfPtrs_info);
1243 EXTDATA_RO(EmptySVar_info);
1244 EXTDATA_RO(FullSVar_info);
1248 %************************************************************************
1250 \subsection[STATIC_ITBL]{Info tables for static objects (outside the heap)}
1252 %************************************************************************
1254 Size and ptrs fields are used by interpretive code, such as @ghci@,
1255 the parallel Pack code (@Pack.lc@) and possibly to-be-written debug
1259 #define STATIC_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) \
1260 CAT_DECLARE(infolbl,kind,descr,type) \
1261 entry_localness(entry_code); \
1262 localness W_ infolbl[] = { \
1265 ,(W_) MK_REP_REF(Static,,) \
1266 INCLUDE_PROFILING_INFO(infolbl) \
1267 INCLUDE_UPDATE_INFO(upd_code,liveness) \
1268 INCLUDE_STATIC_INFO(size,ptrs) \
1271 MAYBE_DECLARE_RTBL(Static,,)
1273 #define STATIC_RTBL() \
1274 const W_ MK_REP_LBL(Static,,)[] = { \
1275 INCLUDE_TYPE_INFO(STATIC) \
1276 INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) /* NB: in info table! */ \
1278 INCLUDE_COPYING_INFO(_Evacuate_Static,_Dummy_Static_entry) \
1279 INCLUDE_COMPACTING_INFO(_Dummy_Static_entry,_PRStart_Static, \
1280 _Dummy_Static_entry,_Dummy_Static_entry) \
1284 %************************************************************************
1286 \subsection[ForeignObj_ITBL]{@ForeignObj_TBL@: @ForeignObj@ info-table}
1288 %************************************************************************
1290 The following table is a bit like that for @SPEC@ with 0 pointers and
1291 a small number of non-ptrs. However, the garbage collection routines
1294 I'm assuming @SPEC_N@, so that we don't need to pad out the info table. (JSM)
1299 # define ForeignObj_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) /*size,ptrs unused*/ \
1300 CAT_DECLARE(infolbl,kind,descr,type) \
1301 entry_localness(entry_code); \
1302 localness W_ infolbl[] = { \
1305 ,(W_) MK_REP_REF(ForeignObj,,) \
1306 INCLUDE_PROFILING_INFO(infolbl) \
1309 MAYBE_DECLARE_RTBL(ForeignObj,,)
1311 # define ForeignObj_RTBL() \
1312 const W_ MK_REP_LBL(ForeignObj,,)[] = { \
1313 INCLUDE_TYPE_INFO(INTERNAL) \
1314 INCLUDE_SIZE_INFO(ForeignObj_SIZE, 0L) \
1316 INCLUDE_COPYING_INFO(_Evacuate_ForeignObj,_Scavenge_ForeignObj) \
1317 SPEC_COMPACTING_INFO(_ScanLink_ForeignObj,_PRStart_ForeignObj,_ScanMove_ForeignObj,_PRIn_0) \
1323 %************************************************************************
1325 \subsection[BH_ITBL]{Info tables for ``black holes''}
1327 %************************************************************************
1329 Special info-table for black holes. It is possible to describe these
1330 using @SPEC@ closures but this requires explicit use of the value of
1331 @MIN_UPD_SIZE@. For now we have a special macro and code.
1335 #define BH_ITBL(infolbl,bh_code,kind,localness,entry_localness) \
1336 entry_localness(bh_code); \
1337 localness W_ infolbl[] = { \
1339 ,(W_) INFO_OTHER_TAG \
1340 ,(W_) MK_REP_REF(BH,kind,) \
1341 INCLUDE_PROFILING_INFO(BH) \
1344 MAYBE_DECLARE_RTBL(BH,U,)
1345 MAYBE_DECLARE_RTBL(BH,N,)
1347 #define BH_RTBL(kind) \
1348 const W_ MK_REP_LBL(BH,kind,)[] = { \
1349 INCLUDE_TYPE_INFO(BH) \
1350 INCLUDE_SIZE_INFO(CAT3(BH_,kind,_SIZE),0L) \
1352 INCLUDE_COPYING_INFO(CAT2(_Evacuate_BH_,kind),CAT2(_Scavenge_BH_,kind)) \
1353 INCLUDE_COMPACTING_INFO(CAT2(_ScanLink_BH_,kind),_PRStart_BH, \
1354 CAT2(_ScanMove_BH_,kind),_PRIn_Error) \
1359 %************************************************************************
1361 \subsection[IND_ITBL]{Info table for indirections}
1363 %************************************************************************
1365 An indirection simply extracts the pointer from the
1366 @IND_CLOSURE_PTR(closure)@ field. The garbage collection routines will
1367 short out the indirection (normally).
1370 #define IND_ITBL(infolbl,ind_code,localness,entry_localness) \
1371 CAT_DECLARE(infolbl,INTERNAL_KIND,"IND","IND") \
1372 entry_localness(ind_code); \
1373 localness W_ infolbl[] = { \
1375 ,(W_) INFO_IND_TAG \
1376 ,(W_) MK_REP_REF(Ind,,) \
1377 INCLUDE_PROFILING_INFO(infolbl) \
1380 MAYBE_DECLARE_RTBL(Ind,,)
1382 #define IND_RTBL() \
1383 const W_ MK_REP_LBL(Ind,,)[] = { \
1384 INCLUDE_TYPE_INFO(IND) \
1385 INCLUDE_SIZE_INFO(MIN_UPD_SIZE,INFO_UNUSED) /* #ptrs not here! */ \
1387 INCLUDE_COPYING_INFO(_Evacuate_Ind,_Scavenge_Ind) \
1388 INCLUDE_COMPACTING_INFO(_Dummy_Ind_entry,_PRStart_Ind, \
1389 _Dummy_Ind_entry,_Dummy_Ind_entry) \
1394 Lexical-scoped profiling (now more-or-less the default... 94/06)
1395 requires a special permanent indirection for PAP closures. These
1396 look exactly like regular indirections, but they are not short-circuited
1397 on garbage collection.
1400 #if defined(PROFILING) || defined(TICKY_TICKY)
1402 # define PERM_IND_ITBL(infolbl,ind_code,localness,entry_localness) \
1403 entry_localness(ind_code); \
1404 CAT_DECLARE(infolbl,INTERNAL_KIND,"IND","IND") \
1405 localness W_ infolbl[] = { \
1407 ,(W_) INFO_IND_TAG \
1408 ,(W_) MK_REP_REF(Perm_Ind,,) \
1409 INCLUDE_PROFILING_INFO(infolbl) \
1412 MAYBE_DECLARE_RTBL(Perm_Ind,,)
1414 # define PERM_IND_RTBL() \
1415 const W_ MK_REP_LBL(Perm_Ind,,)[] = { \
1416 INCLUDE_TYPE_INFO(IND) \
1417 INCLUDE_SIZE_INFO(MIN_UPD_SIZE,INFO_UNUSED) /* #ptrs not here! */ \
1419 INCLUDE_COPYING_INFO(_Evacuate_PI,_Scavenge_PI) \
1420 SPEC_COMPACTING_INFO(_ScanLink_PI,_PRStart_PI, \
1421 _ScanMove_PI,_PRIn_PI) \
1425 # define PERM_IND_RTBL()
1429 %************************************************************************
1431 \subsection[CAF_ITBL]{Info table for updated @CAF@s}
1433 %************************************************************************
1435 Garbage collection of @CAF@s is tricky. We have to cope with explicit
1436 collection from the @CAFlist@ as well as potential references from the
1437 stack and heap which will cause the @CAF@ evacuation code to be
1438 called. They are treated like indirections which are shorted out.
1439 However they must also be updated to point to the new location of the
1440 new closure as the @CAF@ may still be used by references which
1443 \subsubsection{Copying Collection}
1445 A first scheme might use evacuation code which evacuates the reference
1446 and updates the indirection. This is no good as subsequent evacuations
1447 will result in an already evacuated closure being evacuated. This will
1448 leave a forward reference in to-space!
1450 An alternative scheme evacuates the @CAFlist@ first. The closures
1451 referenced are evacuated and the @CAF@ indirection updated to point to
1452 the evacuated closure. The @CAF@ evacuation code simply returns the
1453 updated indirection pointer --- the pointer to the evacuated closure.
1454 Unfortunately the closure the @CAF@ references may be a static
1455 closure, in fact, it may be another @CAF@. This will cause the second
1456 @CAF@'s evacuation code to be called before the @CAF@ has been
1457 evacuated, returning an unevacuated pointer.
1459 Another scheme leaves updating the @CAF@ indirections to the end of
1460 the garbage collection. All the references are evacuated and
1461 scavenged as usual (including the @CAFlist@). Once collection is
1462 complete the @CAFlist@ is traversed updating the @CAF@ references with
1463 the result of evacuating the referenced closure again. This will
1464 immediately return as it must be a forward reference, a static
1465 closure, or a @CAF@ which will indirect by evacuating its reference.
1467 The crux of the problem is that the @CAF@ evacuation code needs to
1468 know if its reference has already been evacuated and updated. If not,
1469 then the reference can be evacuated, updated and returned safely
1470 (possibly evacuating another @CAF@). If it has, then the updated
1471 reference can be returned. This can be done using two @CAF@
1472 info-tables. At the start of a collection the @CAFlist@ is traversed
1473 and set to an internal {\em evacuate and update} info-table. During
1474 collection, evacution of such a @CAF@ also results in the info-table
1475 being reset back to the standard @CAF@ info-table. Thus subsequent
1476 evacuations will simply return the updated reference. On completion of
1477 the collection all @CAF@s will have {\em return reference} info-tables
1480 This is the scheme we adopt. A @CAF@ indirection has evacuation code
1481 which returns the evacuated and updated reference. During garbage
1482 collection, all the @CAF@s are overwritten with an internal @CAF@ info
1483 table which has evacuation code which performs this evacuate and
1484 update and restores the original @CAF@ code. At some point during the
1485 collection we must ensure that all the @CAF@s are indeed evacuated.
1487 The only potential problem with this scheme is a cyclic list of @CAF@s
1488 all directly referencing (possibly via indirections) another @CAF@!
1489 Evacuation of the first @CAF@ will fail in an infinite loop of @CAF@
1490 evacuations. This is solved by ensuring that the @CAF@ info-table is
1491 updated to a {\em return reference} info-table before performing the
1492 evacuate and update. If this {\em return reference} evacuation code is
1493 called before the actual evacuation is complete it must be because
1494 such a cycle of references exists. Returning the still unevacuated
1495 reference is OK --- all the @CAF@s will now reference the same
1496 @CAF@ which will reference itself! Construction of such a structure
1497 indicates the program must be in an infinite loop.
1499 \subsubsection{Compacting Collector}
1501 When shorting out a @CAF@, its reference must be marked. A first
1502 attempt might explicitly mark the @CAF@s, updating the reference with
1503 the marked reference (possibly short circuting indirections). The
1504 actual @CAF@ marking code can indicate that they have already been
1505 marked (though this might not have actually been done yet) and return
1506 the indirection pointer so it is shorted out. Unfortunately the @CAF@
1507 reference might point to an indirection which will be subsequently
1508 shorted out. Rather than returning the @CAF@ reference we treat the
1509 @CAF@ as an indirection, calling the mark code of the reference, which
1510 will return the appropriately shorted reference.
1512 Problem: Cyclic list of @CAF@s all directly referencing (possibly via
1513 indirections) another @CAF@!
1515 Before compacting, the locations of the @CAF@ references are
1516 explicitly linked to the closures they reference (if they reference
1517 heap allocated closures) so that the compacting process will update
1518 them to the closure's new location. Unfortunately these locations'
1519 @CAF@ indirections are static. This causes premature termination
1520 since the test to find the info pointer at the end of the location
1521 list will match more than one value. This can be solved by using an
1522 auxiliary dynamic array (on the top of the A stack). One location for
1523 each @CAF@ indirection is linked to the closure that the @CAF@
1524 references. Once collection is complete this array is traversed and
1525 the corresponding @CAF@ is then updated with the updated pointer from
1526 the auxiliary array.
1530 #define CAF_ITBL(infolbl,ind_code,localness,entry_localness) \
1531 CAT_DECLARE(infolbl,INTERNAL_KIND,"CAF","CAF") \
1532 entry_localness(ind_code); \
1533 localness W_ infolbl[] = { \
1535 ,(W_) INFO_IND_TAG \
1536 ,(W_) MK_REP_REF(Caf,,) \
1537 INCLUDE_PROFILING_INFO(infolbl) \
1540 MAYBE_DECLARE_RTBL(Caf,,)
1542 #define CAF_RTBL() \
1543 const W_ MK_REP_LBL(Caf,,)[] = { \
1544 INCLUDE_TYPE_INFO(CAF) \
1545 INCLUDE_SIZE_INFO(MIN_UPD_SIZE,INFO_UNUSED) /* #ptrs not here! */ \
1547 INCLUDE_COPYING_INFO(_Evacuate_Caf,_Scavenge_Caf) \
1548 INCLUDE_COMPACTING_INFO(_Dummy_Caf_entry,_PRStart_Caf, \
1549 _Dummy_Caf_entry,_Dummy_Caf_entry) \
1554 It is possible to use an alternative marking scheme, using a similar
1555 idea to the copying solution. This scheme avoids the need to update
1556 the @CAF@ references explicitly. We introduce an auxillary {\em mark
1557 and update} @CAF@ info-table which is used to update all @CAF@s at the
1558 start of a collection. The new code marks the @CAF@ reference,
1559 updating it with the returned reference. The returned reference is
1560 itself returned so the @CAF@ is shorted out. The code also modifies the
1561 @CAF@ info-table to be a {\em return reference}. Subsequent attempts to
1562 mark the @CAF@ simply return the updated reference.
1564 A cyclic @CAF@ reference will result in an attempt to mark the @CAF@
1565 before the marking has been completed and the reference updated. We
1566 cannot start marking the @CAF@ as it is already being marked. Nor can
1567 we return the reference as it has not yet been updated. Neither can we
1568 treat the CAF as an indirection since the @CAF@ reference has been
1569 obscured by the pointer reversal stack. All we can do is return the
1570 @CAF@ itself. This will result in some @CAF@ references not being
1573 This scheme has not been adopted but has been implemented. The code is
1574 commented out with @#if 0@.
1576 %************************************************************************
1578 \subsection[CONST_ITBL]{@CONST_ITBL@}
1580 %************************************************************************
1582 This declares an info table for @CONST@ closures (size 0). It is the
1583 info table for a dynamicaly-allocated closure which will redirect
1584 references to the corresponding static closure @<infolbl>_closure@
1585 during garbage collection. A pointer to the static closure is kept in
1586 the info table. (It is assumed that this closure is declared
1589 Why do such @CONST@ objects ever exist? Why don't we just use the
1590 static object in the first place? @CONST@ objects are used only for
1591 updating existing objects. We could use an indirection, but that
1592 risks costing extra run-time indirections until the next GC shorts it
1593 out. So we update with a @CONST@, and the next GC gets rid of it.
1596 #define CONST_ITBL(infolbl,closurelbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) /*size,ptrs unused*/ \
1597 CAT_DECLARE(infolbl,kind,descr,type) \
1598 entry_localness(entry_code); \
1599 EXTDATA(closurelbl); \
1600 localness W_ infolbl[] = { \
1603 ,(W_) MK_REP_REF(Const,,) \
1604 INCLUDE_PROFILING_INFO(infolbl) \
1605 INCLUDE_UPDATE_INFO(upd_code,liveness) \
1606 INCLUDE_CONST_INFO(closurelbl) \
1609 MAYBE_DECLARE_RTBL(Const,,)
1612 /* we need real routines if we may not be commoning up */
1613 #define CONST_Scav _Scavenge_0_0
1614 #define CONST_Link _ScanLink_0_0
1615 #define CONST_Move _ScanMove_0
1617 #define CONST_Scav _Dummy_Const_entry
1618 #define CONST_Link _Dummy_Const_entry
1619 #define CONST_Move _Dummy_Const_entry
1622 #define CONST_RTBL() \
1623 const W_ MK_REP_LBL(Const,,)[] = { \
1624 INCLUDE_TYPE_INFO(CONST) \
1625 INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) \
1627 INCLUDE_COPYING_INFO(_Evacuate_Const,CONST_Scav) \
1628 INCLUDE_COMPACTING_INFO(CONST_Link,_PRStart_Const, \
1629 CONST_Move,_Dummy_Const_entry) \
1633 This builds an info-table which will have pointers to the closure
1634 replaced with @closure_lbl@ during garbage collection. @closure_lbl@
1635 must be the label of a static closure, whose entry code has identical
1636 behaviour to that in the corresponding @CONST_ITBL@. Usually
1637 the info pointer of this closure will be the very one defined by this
1640 These closures always consist only of an info pointer; that is, its
1643 A copying collection implements this with evacuation code which
1644 returns @closure_lbl@, without actually evacuating the object at all.
1645 A compacting collector uses marking code which returns
1646 @closure_lbl@, without marking the closure.
1648 %************************************************************************
1650 \subsection[FOOLIKE_ITBL]{``Char-like'' and ``Int-like'' info-tables}
1652 %************************************************************************
1654 Char-like: This builds an info-table which, when GC happens, will have
1655 pointers to the closure replaced with the appropriate element of the
1656 @CHARLIKE_closures@ array.
1659 #define CHARLIKE_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) /*tag,size,ptrs unused*/ \
1660 CAT_DECLARE(infolbl,kind,descr,type) \
1661 entry_localness(entry_code); \
1662 localness W_ infolbl[] = { \
1664 ,(W_) INFO_FIRST_TAG \
1665 ,(W_) MK_REP_REF(CharLike,,) \
1666 INCLUDE_PROFILING_INFO(infolbl) \
1667 INCLUDE_UPDATE_INFO(upd_code,liveness) \
1670 MAYBE_DECLARE_RTBL(CharLike,,)
1673 /* we need real routines if we may not be commoning up */
1674 #define CHARLIKE_Scav _Scavenge_1_0
1675 #define CHARLIKE_Link _ScanLink_1_0
1676 #define CHARLIKE_Move _ScanMove_1
1678 #define CHARLIKE_Scav _Dummy_CharLike_entry
1679 #define CHARLIKE_Link _Dummy_CharLike_entry
1680 #define CHARLIKE_Move _Dummy_CharLike_entry
1683 #define CHARLIKE_RTBL() \
1684 const W_ MK_REP_LBL(CharLike,,)[] = { \
1685 INCLUDE_TYPE_INFO(CHARLIKE) \
1686 INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) \
1688 INCLUDE_COPYING_INFO(_Evacuate_CharLike,CHARLIKE_Scav) \
1689 INCLUDE_COMPACTING_INFO(CHARLIKE_Link,_PRStart_CharLike, \
1690 CHARLIKE_Move,_PRIn_Error) \
1694 Int-like: this builds the info-table required for intlike closures.
1695 The normal heap-allocated info-table for fixed-size integers (size
1696 @1@); it is used for updates too. At GC, this is redirected to a
1697 static intlike closure if one is available.
1700 #define INTLIKE_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) /*tag,size,ptrs unused*/ \
1701 CAT_DECLARE(infolbl,kind,descr,type) \
1702 entry_localness(entry_code); \
1703 localness W_ infolbl[] = { \
1705 ,(W_) INFO_FIRST_TAG \
1706 ,(W_) MK_REP_REF(IntLike,,) \
1707 INCLUDE_PROFILING_INFO(infolbl) \
1708 INCLUDE_UPDATE_INFO(upd_code,liveness) \
1711 MAYBE_DECLARE_RTBL(IntLike,,)
1713 #define INTLIKE_RTBL() \
1714 const W_ MK_REP_LBL(IntLike,,)[] = { \
1715 INCLUDE_TYPE_INFO(INTLIKE) \
1716 INCLUDE_SIZE_INFO(INFO_UNUSED,INFO_UNUSED) \
1718 INCLUDE_COPYING_INFO(_Evacuate_IntLike,_Scavenge_1_0) \
1719 INCLUDE_COMPACTING_INFO(_ScanLink_1_0,_PRStart_IntLike, \
1720 _ScanMove_1,_PRIn_Error) \
1724 %************************************************************************
1726 \subsection[INREGS_ITBL]{@INREGS_ITBL@s}
1728 %************************************************************************
1730 The emaciated info table for a phantom closure that lives only in regs.
1731 We don't need any GC information, because these closures never make it into
1732 the heap (not with this info table, anyway). Similarly, we don't need an
1733 entry address, because these closures are never entered...they only exist
1738 #define INREGS_ITBL(infolbl,entry_code,upd_code,liveness,tag,size,ptrs,localness,entry_localness,kind,descr,type) /*mostly unused*/ \
1739 localness W_ infolbl[] = { \
1743 INREGS_PROFILING_INFO \
1744 INCLUDE_UPDATE_INFO(upd_code,liveness) \
1747 /* Declare the phantom info table vectors (just Bool at the moment) */
1748 #ifndef COMPILING_NCG
1749 #ifndef aix_TARGET_OS /* AIX gives link errors with this as a const (RO assembler section) */
1750 EXTDATA_RO(PrelBase_Bool_itblvtbl);
1752 extern W_ PrelBase_Bool_itblvtbl[];
1758 End multi-slurp protection:
1760 #endif /* SMInfoTables_H */