/* ----------------------------------------------------------------------------
- * $Id: InfoTables.h,v 1.4 1999/01/15 17:57:03 simonm Exp $
*
+ * (c) The GHC Team, 1998-2002
+ *
* Info Tables
*
* -------------------------------------------------------------------------- */
Profiling info
-------------------------------------------------------------------------- */
-#ifdef PROFILING
-
-#define PROF_INFO_WORDS n
-
typedef struct {
- /* nothing yet */
+ char *closure_type;
+ char *closure_desc;
} StgProfInfo;
-#else /* !PROFILING */
-
-#define PROF_INFO_WORDS 0
-
-typedef struct {
- /* empty */
-} StgProfInfo;
-
-#endif /* PROFILING */
-
/* -----------------------------------------------------------------------------
Parallelism info
-------------------------------------------------------------------------- */
-#ifdef PAR
+#if 0 && (defined(PAR) || defined(GRAN))
-#define PAR_INFO_WORDS 0
+/* CURRENTLY UNUSED
+ ToDo: use this in StgInfoTable (mutually recursive) -- HWL */
typedef struct {
- /* empty */
+ StgInfoTable *rbh_infoptr; /* infoptr to the RBH */
} StgParInfo;
-#else /* !PAR */
+#endif /* 0 */
-#define PAR_INFO_WORDS 0
+/*
+ Copied from ghc-0.29; ToDo: check this code -- HWL
-typedef struct {
- /* empty */
-} StgParInfo;
+ In the parallel system, all updatable closures have corresponding
+ revertible black holes. When we are assembly-mangling, we guarantee
+ that the revertible black hole code precedes the normal entry code, so
+ that the RBH info table resides at a fixed offset from the normal info
+ table. Otherwise, we add the RBH info table pointer to the end of the
+ normal info table and vice versa.
+
+ Currently has to use a !RBH_MAGIC_OFFSET setting.
+ Still todo: init of par.infoptr field in all infotables!!
+*/
+
+#if defined(PAR) || defined(GRAN)
+
+# ifdef RBH_MAGIC_OFFSET
+
+# error magic offset not yet implemented
+
+# define RBH_INFO_WORDS 0
+# define INCLUDE_RBH_INFO(infoptr)
+
+# define RBH_INFOPTR(infoptr) (((P_)infoptr) - RBH_MAGIC_OFFSET)
+# define REVERT_INFOPTR(infoptr) (((P_)infoptr) + RBH_MAGIC_OFFSET)
+
+# else
+
+# define RBH_INFO_WORDS 1
+# define INCLUDE_RBH_INFO(info) rbh_infoptr : &(info)
+
+# define RBH_INFOPTR(infoptr) (((StgInfoTable *)(infoptr))->rbh_infoptr)
+# define REVERT_INFOPTR(infoptr) (((StgInfoTable *)(infoptr))->rbh_infoptr)
+
+# endif
+
+/* see ParallelRts.h */
+/*
+EXTFUN(RBH_entry);
+StgClosure *convertToRBH(StgClosure *closure);
+#if defined(GRAN)
+void convertFromRBH(StgClosure *closure);
+#elif defined(PAR)
+void convertToFetchMe(StgPtr closure, globalAddr *ga);
+#endif
+*/
+
+#endif
+
+/* -----------------------------------------------------------------------------
+ Ticky info
-#endif /* PAR */
+ There is no ticky-specific stuff in an info table at this time.
+ -------------------------------------------------------------------------- */
/* -----------------------------------------------------------------------------
Debugging info
#ifdef DEBUG_CLOSURE
-#define DEBUG_INFO_WORDS n
-
typedef struct {
... whatever ...
} StgDebugInfo;
#else /* !DEBUG_CLOSURE */
-#define DEBUG_INFO_WORDS 0
-
-typedef struct {
- /* empty */
-} StgDebugInfo;
+/* There is no DEBUG-specific stuff in an info table at this time. */
#endif /* DEBUG_CLOSURE */
/* -----------------------------------------------------------------------------
- Closure Types
+ Closure flags
+ -------------------------------------------------------------------------- */
+
+/* The type flags provide quick access to certain properties of a closure. */
- If you add or delete any closure types, don't forget to update
- ClosureTypes.h for the native code generator. This is a temporary
- measure (I hope).
+#define _HNF (1<<0) /* head normal form? */
+#define _BTM (1<<1) /* bitmap-style layout? */
+#define _NS (1<<2) /* non-sparkable */
+#define _STA (1<<3) /* static? */
+#define _THU (1<<4) /* thunk? */
+#define _MUT (1<<5) /* mutable? */
+#define _UPT (1<<6) /* unpointed? */
+#define _SRT (1<<7) /* has an SRT? */
+#define _IND (1<<8) /* is an indirection? */
+
+#define isSTATIC(flags) ((flags) &_STA)
+#define isMUTABLE(flags) ((flags) &_MUT)
+#define isBITMAP(flags) ((flags) &_BTM)
+#define isTHUNK(flags) ((flags) &_THU)
+#define isUNPOINTED(flags) ((flags) &_UPT)
+#define hasSRT(flags) ((flags) &_SRT)
+
+extern StgWord16 closure_flags[];
+
+#define closureFlags(c) (closure_flags[get_itbl(c)->type])
+
+#define closure_HNF(c) ( closureFlags(c) & _HNF)
+#define closure_BITMAP(c) ( closureFlags(c) & _BTM)
+#define closure_NON_SPARK(c) ( (closureFlags(c) & _NS))
+#define closure_SHOULD_SPARK(c) (!(closureFlags(c) & _NS))
+#define closure_STATIC(c) ( closureFlags(c) & _STA)
+#define closure_THUNK(c) ( closureFlags(c) & _THU)
+#define closure_MUTABLE(c) ( closureFlags(c) & _MUT)
+#define closure_UNPOINTED(c) ( closureFlags(c) & _UPT)
+#define closure_SRT(c) ( closureFlags(c) & _SRT)
+#define closure_IND(c) ( closureFlags(c) & _IND)
+
+/* same as above but for info-ptr rather than closure */
+#define ipFlags(ip) (closure_flags[ip->type])
+
+#define ip_HNF(ip) ( ipFlags(ip) & _HNF)
+#define ip_BITMAP(ip) ( ipFlags(ip) & _BTM)
+#define ip_SHOULD_SPARK(ip) (!(ipFlags(ip) & _NS))
+#define ip_STATIC(ip) ( ipFlags(ip) & _STA)
+#define ip_THUNK(ip) ( ipFlags(ip) & _THU)
+#define ip_MUTABLE(ip) ( ipFlags(ip) & _MUT)
+#define ip_UNPOINTED(ip) ( ipFlags(ip) & _UPT)
+#define ip_SRT(ip) ( ipFlags(ip) & _SRT)
+#define ip_IND(ip) ( ipFlags(ip) & _IND)
+
+/* -----------------------------------------------------------------------------
+ Bitmaps
+
+ These are used to describe the pointerhood of a sequence of words
+ (usually on the stack) to the garbage collector. The two primary
+ uses are for stack frames, and functions (where we need to describe
+ the layout of a PAP to the GC).
+
+ In these bitmaps: 0 == ptr, 1 == non-ptr.
-------------------------------------------------------------------------- */
-typedef enum {
+/*
+ * Small bitmaps: for a small bitmap, we store the size and bitmap in
+ * the same word, using the following macros. If the bitmap doesn't
+ * fit in a single word, we use a pointer to an StgLargeBitmap below.
+ */
+#define MK_SMALL_BITMAP(size,bits) (((bits)<<BITMAP_BITS_SHIFT) | (size))
- INVALID_OBJECT /* Object tag 0 raises an internal error */
- , CONSTR
- /* CONSTR_p_np */
- , CONSTR_INTLIKE
- , CONSTR_CHARLIKE
- , CONSTR_STATIC
- , CONSTR_NOCAF_STATIC
+#define BITMAP_SIZE(bitmap) ((bitmap) & BITMAP_SIZE_MASK)
+#define BITMAP_BITS(bitmap) ((bitmap) >> BITMAP_BITS_SHIFT)
- , FUN
- , FUN_STATIC
+/*
+ * A large bitmap.
+ */
+typedef struct {
+ StgWord size;
+ StgWord bitmap[FLEXIBLE_ARRAY];
+} StgLargeBitmap;
- , THUNK
- /* THUNK_p_np */
- , THUNK_STATIC
- , THUNK_SELECTOR
+/* -----------------------------------------------------------------------------
+ SRTs (Static Reference Tables)
- , BCO
- , AP_UPD
+ These tables are used to keep track of the static objects referred
+ to by the code for a closure or stack frame, so that we can follow
+ static data references from code and thus accurately
+ garbage-collect CAFs.
+ -------------------------------------------------------------------------- */
- , PAP /* should be called AP_NUPD */
+/* An SRT is just an array of closure pointers: */
+typedef StgClosure* StgSRT[];
- , IND
- , IND_OLDGEN
- , IND_PERM
- , IND_OLDGEN_PERM
- , IND_STATIC
+/*
+ * Each info table refers to some subset of the closure pointers in an
+ * SRT. It does this using a pair of an StgSRT pointer and a
+ * half-word bitmap. If the half-word bitmap isn't large enough, then
+ * we fall back to a large SRT, including an unbounded bitmap. If the
+ * half-word bitmap is set to all ones (0xffff), then the StgSRT
+ * pointer instead points to an StgLargeSRT:
+ */
+typedef struct StgLargeSRT_ {
+ StgSRT *srt;
+ StgLargeBitmap l;
+} StgLargeSRT;
- , CAF_UNENTERED
- , CAF_ENTERED
- , CAF_BLACKHOLE
+/* ----------------------------------------------------------------------------
+ Relative pointers
+
+ Several pointer fields in info tables are expressed as offsets
+ relative to the info pointer, so that we can generate
+ position-independent code.
+
+ There is a complication on the x86_64 platform, where pointeres are
+ 64 bits, but the tools don't support 64-bit relative relocations.
+ However, the default memory model (small) ensures that all symbols
+ have values in the lower 2Gb of the address space, so offsets all
+ fit in 32 bits. Hence we can use 32-bit offset fields.
+ ------------------------------------------------------------------------- */
+
+#if x86_64_TARGET_ARCH
+#define OFFSET_FIELD(n) StgHalfInt n; StgHalfWord __pad_##n;
+#else
+#define OFFSET_FIELD(n) StgInt n;
+#endif
- , RET_BCO
- , RET_SMALL
- , RET_VEC_SMALL
- , RET_BIG
- , RET_VEC_BIG
- , RET_DYN
- , UPDATE_FRAME
- , CATCH_FRAME
- , STOP_FRAME
- , SEQ_FRAME
+/* ----------------------------------------------------------------------------
+ Info Tables
+ ------------------------------------------------------------------------- */
- , BLACKHOLE
- , BLACKHOLE_BQ
+/*
+ * Stuff describing the closure layout. Well, actually, it might
+ * contain the selector index for a THUNK_SELECTOR. This union is one
+ * word long.
+ */
+typedef union {
+ struct { /* Heap closure payload layout: */
+ StgHalfWord ptrs; /* number of pointers */
+ StgHalfWord nptrs; /* number of non-pointers */
+ } payload;
+
+ StgWord bitmap; /* word-sized bit pattern describing */
+ /* a stack frame: see below */
+
+#ifndef TABLES_NEXT_TO_CODE
+ StgLargeBitmap* large_bitmap; /* pointer to large bitmap structure */
+#else
+ OFFSET_FIELD( large_bitmap_offset ); /* offset from info table to large bitmap structure */
+#endif
+
+ StgWord selector_offset; /* used in THUNK_SELECTORs */
- , MVAR
+} StgClosureInfo;
- , ARR_WORDS
- , MUT_ARR_WORDS
- , MUT_ARR_PTRS
- , MUT_ARR_PTRS_FROZEN
+/*
+ * The "standard" part of an info table. Every info table has this bit.
+ */
+typedef struct _StgInfoTable {
- , MUT_VAR
+#ifndef TABLES_NEXT_TO_CODE
+ StgFunPtr entry; /* pointer to the entry code */
+#endif
- , WEAK
- , FOREIGN
+#if defined(PAR) || defined(GRAN)
+ struct _StgInfoTable *rbh_infoptr;
+#endif
+#ifdef PROFILING
+ StgProfInfo prof;
+#endif
+#ifdef TICKY
+ /* Ticky-specific stuff would go here. */
+#endif
+#ifdef DEBUG_CLOSURE
+ /* Debug-specific stuff would go here. */
+#endif
- , TSO
+ StgClosureInfo layout; /* closure layout info (one word) */
- , BLOCKED_FETCH
- , FETCH_ME
+ StgHalfWord type; /* closure type */
+ StgHalfWord srt_bitmap; /* number of entries in SRT (or constructor tag) */
- , EVACUATED
+#ifdef TABLES_NEXT_TO_CODE
+ StgCode code[FLEXIBLE_ARRAY];
+#endif
+} StgInfoTable;
- , N_CLOSURE_TYPES /* number of distinct closure types */
-} StgClosureType;
+/* -----------------------------------------------------------------------------
+ Function info tables
+
+ This is the general form of function info tables. The compiler
+ will omit some of the fields in common cases:
+
+ - If fun_type is not ARG_GEN or ARG_GEN_BIG, then the slow_apply
+ and bitmap fields may be left out (they are at the end, so omitting
+ them doesn't affect the layout).
+
+ - If srt_bitmap (in the std info table part) is zero, then the srt
+ field may be omitted. This only applies if the slow_apply and
+ bitmap fields have also been omitted.
+ -------------------------------------------------------------------------- */
-/* The type flags provide quick access to certain properties of a closure. */
+typedef struct _StgFunInfoExtraRev {
+ OFFSET_FIELD ( slow_apply_offset ); /* apply to args on the stack */
+ union {
+ StgWord bitmap;
+ OFFSET_FIELD ( bitmap_offset ); /* arg ptr/nonptr bitmap */
+ } b;
+ OFFSET_FIELD ( srt_offset ); /* pointer to the SRT table */
+ StgHalfWord fun_type; /* function type */
+ StgHalfWord arity; /* function arity */
+} StgFunInfoExtraRev;
+
+typedef struct _StgFunInfoExtraFwd {
+ StgHalfWord fun_type; /* function type */
+ StgHalfWord arity; /* function arity */
+ StgSRT *srt; /* pointer to the SRT table */
+ union { /* union for compat. with TABLES_NEXT_TO_CODE version */
+ StgWord bitmap; /* arg ptr/nonptr bitmap */
+ } b;
+ StgFun *slow_apply; /* apply to args on the stack */
+} StgFunInfoExtraFwd;
-#define _HNF (1<<0) /* head normal form? */
-#define _BTM (1<<1) /* bitmap-style layout? */
-#define _NS (1<<2) /* non-sparkable */
-#define _STA (1<<3) /* static? */
-#define _THU (1<<4) /* thunk? */
-#define _MUT (1<<5) /* mutable? */
-#define _UPT (1<<6) /* unpointed? */
-#define _SRT (1<<7) /* has an SRT? */
-
-#define isSTATIC(flags) ((flags)&_STA)
-#define isMUTABLE(flags) ((flags) &_MUT)
-
-#define closure_STATIC(closure) ( get_itbl(closure)->flags & _STA)
-#define closure_SHOULD_SPARK(closure) (!(get_itbl(closure)->flags & _NS))
-#define closure_MUTABLE(closure) ( get_itbl(closure)->flags & _MUT)
-#define closure_UNPOINTED(closure) ( get_itbl(closure)->flags & _UPT)
-
-/* HNF BTM NS STA THU MUT UPT SRT */
-
-#define FLAGS_CONSTR (_HNF| _NS )
-#define FLAGS_CONSTR_STATIC (_HNF| _NS|_STA )
-#define FLAGS_CONSTR_NOCAF_STATIC (_HNF| _NS|_STA )
-#define FLAGS_FUN (_HNF| _NS| _SRT )
-#define FLAGS_FUN_STATIC (_HNF| _NS|_STA| _SRT )
-#define FLAGS_THUNK ( _BTM| _THU| _SRT )
-#define FLAGS_THUNK_STATIC ( _BTM| _STA|_THU| _SRT )
-#define FLAGS_THUNK_SELECTOR ( _BTM| _THU| _SRT )
-#define FLAGS_BCO (_HNF| _NS )
-#define FLAGS_CAF_UNENTERED 0 /* Do we still use these? */
-#define FLAGS_CAF_ENTERED 0
-#define FLAGS_CAF_BLACKHOLE ( _BTM|_NS| _UPT )
-#define FLAGS_AP_UPD ( _BTM| _THU )
-#define FLAGS_PAP (_HNF| _NS )
-#define FLAGS_IND 0
-#define FLAGS_IND_OLDGEN 0
-#define FLAGS_IND_PERM 0
-#define FLAGS_IND_OLDGEN_PERM 0
-#define FLAGS_IND_STATIC ( _STA )
-#define FLAGS_EVACUATED 0
-#define FLAGS_ARR_WORDS (_HNF| _NS| _UPT )
-#define FLAGS_MUT_ARR_WORDS (_HNF| _NS| _MUT|_UPT )
-#define FLAGS_MUT_ARR_PTRS (_HNF| _NS| _MUT|_UPT )
-#define FLAGS_MUT_ARR_PTRS_FROZEN (_HNF| _NS| _MUT|_UPT )
-#define FLAGS_MUT_VAR (_HNF| _NS| _MUT|_UPT )
-#define FLAGS_FOREIGN (_HNF| _NS| _UPT )
-#define FLAGS_WEAK (_HNF| _NS| _UPT )
-#define FLAGS_BLACKHOLE ( _NS| _UPT )
-#define FLAGS_BLACKHOLE_BQ ( _NS| _UPT )
-#define FLAGS_MVAR (_HNF| _NS| _MUT|_UPT )
-#define FLAGS_FETCH_ME (_HNF| _NS )
-#define FLAGS_TSO (_HNF| _NS| _MUT|_UPT )
-#define FLAGS_RET_BCO ( _BTM )
-#define FLAGS_RET_SMALL ( _BTM| _SRT)
-#define FLAGS_RET_VEC_SMALL ( _BTM| _SRT)
-#define FLAGS_RET_BIG ( _SRT)
-#define FLAGS_RET_VEC_BIG ( _SRT)
-#define FLAGS_RET_DYN ( _SRT)
-#define FLAGS_CATCH_FRAME ( _BTM )
-#define FLAGS_STOP_FRAME ( _BTM )
-#define FLAGS_SEQ_FRAME ( _BTM )
-#define FLAGS_UPDATE_FRAME ( _BTM )
+typedef struct {
+#if defined(TABLES_NEXT_TO_CODE)
+ StgFunInfoExtraRev f;
+ StgInfoTable i;
+#else
+ StgInfoTable i;
+ StgFunInfoExtraFwd f;
+#endif
+} StgFunInfoTable;
/* -----------------------------------------------------------------------------
- Info Tables
+ Return info tables
-------------------------------------------------------------------------- */
-/* A large bitmap. Small 32-bit ones live in the info table, but sometimes
- * 32 bits isn't enough and we have to generate a larger one. (sizes
- * differ for 64-bit machines.
+/*
+ * When info tables are laid out backwards, we can omit the SRT
+ * pointer iff srt_bitmap is zero.
*/
typedef struct {
- StgWord size;
- StgWord bitmap[0];
-} StgLargeBitmap;
+#if defined(TABLES_NEXT_TO_CODE)
+ OFFSET_FIELD( srt_offset ); /* offset to the SRT table */
+ StgInfoTable i;
+#else
+ StgInfoTable i;
+ StgSRT *srt; /* pointer to the SRT table */
+ StgFunPtr vector[FLEXIBLE_ARRAY];
+#endif
+} StgRetInfoTable;
+
+/* -----------------------------------------------------------------------------
+ Thunk info tables
+ -------------------------------------------------------------------------- */
/*
- * Stuff describing the closure layout. Well, actually, it might
- * contain the selector index for a THUNK_SELECTOR. If we're on a
- * 64-bit architecture then we can enlarge some of these fields, since
- * the union contains a pointer field.
+ * When info tables are laid out backwards, we can omit the SRT
+ * pointer iff srt_bitmap is zero.
*/
-typedef union {
+typedef struct _StgThunkInfoTable {
+#if !defined(TABLES_NEXT_TO_CODE)
+ StgInfoTable i;
+#endif
+#if defined(TABLES_NEXT_TO_CODE)
+ OFFSET_FIELD( srt_offset ); /* offset to the SRT table */
+#else
+ StgSRT *srt; /* pointer to the SRT table */
+#endif
+#if defined(TABLES_NEXT_TO_CODE)
+ StgInfoTable i;
+#endif
+} StgThunkInfoTable;
- StgWord bitmap; /* bit pattern, 1 = pointer, 0 = non-pointer */
- StgWord selector_offset; /* used in THUNK_SELECTORs */
- StgLargeBitmap* large_bitmap; /* pointer to large bitmap structure */
-#if SIZEOF_VOID_P == 8
- struct {
- StgNat32 ptrs; /* number of pointers */
- StgNat32 nptrs; /* number of non-pointers */
- } payload;
+/* -----------------------------------------------------------------------------
+ Accessor macros for fields that might be offsets (C version)
+ -------------------------------------------------------------------------- */
+
+/*
+ * GET_SRT(info)
+ * info must be a Stg[Ret|Thunk]InfoTable* (an info table that has a SRT)
+ */
+#ifdef TABLES_NEXT_TO_CODE
+#define GET_SRT(info) ((StgSRT*) (((StgWord) ((info)+1)) + (info)->srt_offset))
#else
- struct {
- StgNat16 ptrs; /* number of pointers */
- StgNat16 nptrs; /* number of non-pointers */
- } payload;
+#define GET_SRT(info) ((info)->srt)
#endif
-
-} StgClosureInfo;
/*
- * Info tables. All info tables are the same type, to simplify code
- * generation. However, the mangler removes any unused SRT fields
- * from the asm to save space (convention: if srt_len is zero, or the
- * type is a CONSTR_ type, then the SRT field isn't present.
+ * GET_FUN_SRT(info)
+ * info must be a StgFunInfoTable*
*/
+#ifdef TABLES_NEXT_TO_CODE
+#define GET_FUN_SRT(info) ((StgSRT*) (((StgWord) ((info)+1)) + (info)->f.srt_offset))
+#else
+#define GET_FUN_SRT(info) ((info)->f.srt)
+#endif
-typedef StgClosure* StgSRT[];
-
-typedef struct _StgInfoTable {
- StgSRT *srt; /* pointer to the SRT table */
- StgParInfo par;
- StgProfInfo prof;
- StgDebugInfo debug;
- StgClosureInfo layout; /* closure layout info (pointer-sized) */
-#if SIZEOF_VOID_P == 8
- StgNat16 flags; /* } */
- StgClosureType type : 16; /* } These 4 elements fit into 64 bits */
- StgNat32 srt_len; /* } */
+#ifdef TABLES_NEXT_TO_CODE
+#define GET_LARGE_BITMAP(info) ((StgLargeBitmap*) (((StgWord) ((info)+1)) \
+ + (info)->layout.large_bitmap_offset))
#else
- StgNat8 flags; /* } */
- StgClosureType type : 8; /* } These 4 elements fit into 32 bits */
- StgNat16 srt_len; /* } */
+#define GET_LARGE_BITMAP(info) ((info)->layout.large_bitmap)
#endif
-#if USE_MINIINTERPRETER
- StgFunPtr (*vector)[];
- StgFunPtr entry;
+
+#ifdef TABLES_NEXT_TO_CODE
+#define GET_FUN_LARGE_BITMAP(info) ((StgLargeBitmap*) (((StgWord) ((info)+1)) \
+ + (info)->f.b.bitmap_offset))
#else
- StgCode code[0];
+#define GET_FUN_LARGE_BITMAP(info) ((StgLargeBitmap*) ((info)->f.b.bitmap))
#endif
-} StgInfoTable;
+
#endif /* INFOTABLES_H */