/* ----------------------------------------------------------------------------
- * $Id: InfoTables.h,v 1.27 2002/05/14 08:15:49 matthewc Exp $
*
- * (c) The GHC Team, 1998-1999
+ * (c) The GHC Team, 1998-2002
*
* Info Tables
*
#if 0 && (defined(PAR) || defined(GRAN))
-// CURRENTLY UNUSED
-// ToDo: use this in StgInfoTable (mutually recursive) -- HWL
+/* CURRENTLY UNUSED
+ ToDo: use this in StgInfoTable (mutually recursive) -- HWL */
typedef struct {
StgInfoTable *rbh_infoptr; /* infoptr to the RBH */
# 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
+/*
+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
- -------------------------------------------------------------------------- */
-typedef struct {
- /* empty */
-} StgTickyInfo;
+ There is no ticky-specific stuff in an info table at this time.
+ -------------------------------------------------------------------------- */
/* -----------------------------------------------------------------------------
Debugging info
#else /* !DEBUG_CLOSURE */
-typedef struct {
- /* empty */
-} StgDebugInfo;
+/* There is no DEBUG-specific stuff in an info table at this time. */
#endif /* DEBUG_CLOSURE */
#define ip_IND(ip) ( ipFlags(ip) & _IND)
/* -----------------------------------------------------------------------------
- Info Tables
+ 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.
-------------------------------------------------------------------------- */
-/* 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.
+/*
+ * 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))
+#define BITMAP_SIZE(bitmap) ((bitmap) & BITMAP_SIZE_MASK)
+#define BITMAP_BITS(bitmap) ((bitmap) >> BITMAP_BITS_SHIFT)
+
+/*
+ * A large bitmap.
+ */
typedef struct {
StgWord size;
StgWord bitmap[FLEXIBLE_ARRAY];
} StgLargeBitmap;
+/* -----------------------------------------------------------------------------
+ SRTs (Static Reference Tables)
+
+ 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.
+ -------------------------------------------------------------------------- */
+
+/* An SRT is just an array of closure pointers: */
+typedef StgClosure* StgSRT[];
+
/*
- * 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.
+ * 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;
+/* ----------------------------------------------------------------------------
+ Info Tables
+ ------------------------------------------------------------------------- */
+
+/*
+ * 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 {
-#if SIZEOF_VOID_P == 8
- StgWord32 ptrs; /* number of pointers */
- StgWord32 nptrs; /* number of non-pointers */
+ 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
- StgWord16 ptrs; /* number of pointers */
- StgWord16 nptrs; /* number of non-pointers */
+ StgWord large_bitmap_offset; /* offset from info table to large bitmap structure */
#endif
- } payload;
+
+ StgWord selector_offset; /* used in THUNK_SELECTORs */
- StgWord bitmap; /* bit pattern, 1 = pointer, 0 = non-pointer */
- StgWord selector_offset; /* used in THUNK_SELECTORs */
- StgLargeBitmap* large_bitmap; /* pointer to large bitmap structure */
-
} 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.
- */
-
-typedef StgClosure* StgSRT[];
/*
- * The entry code pointer must be the first word of an info table.
- * See the comment in ghc/rts/Storage.h (Plan C) for details.
+ * The "standard" part of an info table. Every info table has this bit.
*/
typedef struct _StgInfoTable {
+
#ifndef TABLES_NEXT_TO_CODE
- StgFunPtr entry;
+ StgFunPtr entry; /* pointer to the entry code */
#endif
- StgSRT *srt; /* pointer to the SRT table */
+
#if defined(PAR) || defined(GRAN)
struct _StgInfoTable *rbh_infoptr;
#endif
StgProfInfo prof;
#endif
#ifdef TICKY
- StgTickyInfo ticky;
+ /* Ticky-specific stuff would go here. */
#endif
#ifdef DEBUG_CLOSURE
- StgDebugInfo debug;
+ /* Debug-specific stuff would go here. */
#endif
- StgClosureInfo layout; /* closure layout info (pointer-sized) */
-#if SIZEOF_VOID_P == 8
- StgWord32 type; /* } These 2 elements fit into 64 bits */
- StgWord32 srt_len; /* } */
+
+ StgClosureInfo layout; /* closure layout info (one word) */
+
+ StgHalfWord type; /* closure type */
+ StgHalfWord srt_bitmap; /* number of entries in SRT (or constructor tag) */
+
+#ifdef TABLES_NEXT_TO_CODE
+ StgCode code[FLEXIBLE_ARRAY];
+#endif
+} StgInfoTable;
+
+
+/* -----------------------------------------------------------------------------
+ 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.
+ -------------------------------------------------------------------------- */
+
+typedef struct _StgFunInfoExtraRev {
+ StgWord slow_apply_offset; /* apply to args on the stack */
+ StgWord bitmap; /* arg ptr/nonptr bitmap */
+ StgWord 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 */
+ StgWord bitmap; /* arg ptr/nonptr bitmap */
+ StgFun *slow_apply; /* apply to args on the stack */
+} StgFunInfoExtraFwd;
+
+typedef struct {
+#if defined(TABLES_NEXT_TO_CODE)
+ StgFunInfoExtraRev f;
+ StgInfoTable i;
+#else
+ StgInfoTable i;
+ StgFunInfoExtraFwd f;
+#endif
+} StgFunInfoTable;
+
+/* -----------------------------------------------------------------------------
+ Return info tables
+ -------------------------------------------------------------------------- */
+
+/*
+ * When info tables are laid out backwards, we can omit the SRT
+ * pointer iff srt_bitmap is zero.
+ */
+
+typedef struct {
+#if defined(TABLES_NEXT_TO_CODE)
+ StgWord 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
+ -------------------------------------------------------------------------- */
+
+/*
+ * When info tables are laid out backwards, we can omit the SRT
+ * pointer iff srt_bitmap is zero.
+ */
+
+typedef struct _StgThunkInfoTable {
+#if !defined(TABLES_NEXT_TO_CODE)
+ StgInfoTable i;
+#endif
+#if defined(TABLES_NEXT_TO_CODE)
+ StgWord srt_offset; /* offset to the SRT table */
#else
- StgWord type : 16; /* } These 2 elements fit into 32 bits */
- StgWord srt_len : 16; /* } */
+ StgSRT *srt; /* pointer to the SRT table */
#endif
+#if defined(TABLES_NEXT_TO_CODE)
+ StgInfoTable i;
+#endif
+} StgThunkInfoTable;
+
+
+/* -----------------------------------------------------------------------------
+ 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
- StgCode code[FLEXIBLE_ARRAY];
+#define GET_SRT(info) ((StgSRT*) (((StgWord) ((info)+1)) + (info)->srt_offset))
#else
- StgFunPtr vector[FLEXIBLE_ARRAY];
+#define GET_SRT(info) ((info)->srt)
#endif
-} StgInfoTable;
-/* Info tables are read-only, therefore we uniformly declare them with
- * C's const attribute. This isn't just a nice thing to do: it's
- * necessary because the garbage collector has to distinguish between
- * closure pointers and info table pointers when traversing the
- * stack. We distinguish the two by checking whether the pointer is
- * into text-space or not.
+/*
+ * 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
-#if ia64_TARGET_ARCH
-/* We need to give the compiler a gentle hint to put it in text-space */
-#define INFO_TBL_CONST const __attribute__((section (".text")))
+#ifdef TABLES_NEXT_TO_CODE
+#define GET_LARGE_BITMAP(info) ((StgLargeBitmap*) (((StgWord) ((info)+1)) \
+ + (info)->layout.large_bitmap_offset))
#else
-#define INFO_TBL_CONST const
+#define GET_LARGE_BITMAP(info) ((info)->layout.large_bitmap)
#endif
+#ifdef TABLES_NEXT_TO_CODE
+#define GET_FUN_LARGE_BITMAP(info) ((StgLargeBitmap*) (((StgWord) ((info)+1)) \
+ + (info)->f.bitmap))
+#else
+#define GET_FUN_LARGE_BITMAP(info) ((StgLargeBitmap*) ((info)->f.bitmap))
+#endif
+
+
#endif /* INFOTABLES_H */
projects / ghc-hetmet.git / blobdiff