X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fincludes%2FInfoTables.h;h=5284932c1a8586be1019e7ff7edc892e13a76c3b;hb=b67f18569f3be1118d7325cde71c8a0bc1508655;hp=2e10e87379762f2fea6f88dd65c22ff48ddcff6f;hpb=6ed4dbcc5c63bbd87e053eaf368c3b0612997d36;p=ghc-hetmet.git diff --git a/ghc/includes/InfoTables.h b/ghc/includes/InfoTables.h index 2e10e87..5284932 100644 --- a/ghc/includes/InfoTables.h +++ b/ghc/includes/InfoTables.h @@ -1,7 +1,7 @@ /* ---------------------------------------------------------------------------- - * $Id: InfoTables.h,v 1.24 2001/12/18 19:42:41 sebc Exp $ + * $Id: InfoTables.h,v 1.32 2003/11/14 14:28:08 stolz Exp $ * - * (c) The GHC Team, 1998-1999 + * (c) The GHC Team, 1998-2002 * * Info Tables * @@ -34,11 +34,6 @@ typedef struct { #endif /* 0 */ -typedef struct { - /* empty */ -} StgParInfo; - - /* Copied from ghc-0.29; ToDo: check this code -- HWL @@ -90,9 +85,11 @@ typedef struct { Ticky info -------------------------------------------------------------------------- */ +#if defined(SUPPORTS_EMPTY_STRUCTS) typedef struct { /* empty */ } StgTickyInfo; +#endif /* ----------------------------------------------------------------------------- Debugging info @@ -106,12 +103,18 @@ typedef struct { #else /* !DEBUG_CLOSURE */ -typedef struct { +# if defined(SUPPORTS_EMPTY_STRUCTS) +typedef struct StgDebugInfo { /* empty */ } StgDebugInfo; +# endif #endif /* DEBUG_CLOSURE */ +/* ----------------------------------------------------------------------------- + Closure flags + -------------------------------------------------------------------------- */ + /* The type flags provide quick access to certain properties of a closure. */ #define _HNF (1<<0) /* head normal form? */ @@ -160,61 +163,89 @@ extern StgWord16 closure_flags[]; #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). -------------------------------------------------------------------------- */ -/* 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) +// +// A large bitmap. +// typedef struct { StgWord size; StgWord bitmap[FLEXIBLE_ARRAY]; } StgLargeBitmap; -/* - * 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. - */ +/* ----------------------------------------------------------------------------- + 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[]; + +// 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 */ -#else - StgWord16 ptrs; /* number of pointers */ - StgWord16 nptrs; /* number of non-pointers */ -#endif - } payload; + 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 + + StgLargeBitmap* large_bitmap; // pointer to large bitmap structure + + 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 @@ -222,34 +253,91 @@ typedef struct _StgInfoTable { StgProfInfo prof; #endif #ifdef TICKY - StgTickyInfo ticky; + MAYBE_EMPTY_STRUCT(StgTickyInfo,ticky) #endif #ifdef DEBUG_CLOSURE - StgDebugInfo debug; -#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; /* } */ -#else - StgWord type : 16; /* } These 2 elements fit into 32 bits */ - StgWord srt_len : 16; /* } */ + MAYBE_EMPTY_STRUCT(StgDebugInfo,debug) #endif + + 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]; -#else - StgFunPtr vector[FLEXIBLE_ARRAY]; #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. - */ - -#define INFO_TBL_CONST const + +/* ----------------------------------------------------------------------------- + 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 _StgFunInfoTable { +#if defined(TABLES_NEXT_TO_CODE) + StgFun *slow_apply; // apply to args on the stack + StgWord bitmap; // arg ptr/nonptr bitmap + StgSRT *srt; // pointer to the SRT table + StgHalfWord fun_type; // function type + StgHalfWord arity; // function arity + StgInfoTable i; +#else + StgInfoTable i; + 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 +#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 _StgRetInfoTable { +#if !defined(TABLES_NEXT_TO_CODE) + StgInfoTable i; +#endif + StgSRT *srt; // pointer to the SRT table +#if defined(TABLES_NEXT_TO_CODE) + StgInfoTable i; +#endif +#if !defined(TABLES_NEXT_TO_CODE) + 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 + StgSRT *srt; // pointer to the SRT table +#if defined(TABLES_NEXT_TO_CODE) + StgInfoTable i; +#endif +} StgThunkInfoTable; #endif /* INFOTABLES_H */