X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fincludes%2FInfoTables.h;h=8677e90908dc8fa80a4c91b434e7192da9a2bca4;hb=8504635323bc4c2d7ade98771a4e281c2d56761c;hp=e7bc9a1db301bd59a24cfede4c068bc7a2641e0a;hpb=a5dc9cdae04f5e0c1f2d13a53bb06c52f0a8c8c9;p=ghc-hetmet.git diff --git a/ghc/includes/InfoTables.h b/ghc/includes/InfoTables.h index e7bc9a1..8677e90 100644 --- a/ghc/includes/InfoTables.h +++ b/ghc/includes/InfoTables.h @@ -1,6 +1,8 @@ /* ---------------------------------------------------------------------------- - * $Id: InfoTables.h,v 1.9 1999/02/05 15:25:02 simonm Exp $ + * $Id: InfoTables.h,v 1.35 2004/11/08 12:26:55 simonmar Exp $ * + * (c) The GHC Team, 1998-2002 + * * Info Tables * * -------------------------------------------------------------------------- */ @@ -12,45 +14,78 @@ 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 @@ -58,270 +93,295 @@ typedef struct { #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 - - 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). + Closure flags -------------------------------------------------------------------------- */ -typedef enum { +/* The type flags provide quick access to certain properties of a closure. */ - INVALID_OBJECT /* Object tag 0 raises an internal error */ +#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) - , CONSTR - , CONSTR_1_0 - , CONSTR_0_1 - , CONSTR_2_0 - , CONSTR_1_1 - , CONSTR_0_2 - , CONSTR_INTLIKE - , CONSTR_CHARLIKE - , CONSTR_STATIC - , CONSTR_NOCAF_STATIC +/* ----------------------------------------------------------------------------- + Bitmaps - , FUN - , FUN_1_0 - , FUN_0_1 - , FUN_2_0 - , FUN_1_1 - , FUN_0_2 - , FUN_STATIC + 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). - , THUNK - , THUNK_1_0 - , THUNK_0_1 - , THUNK_2_0 - , THUNK_1_1 - , THUNK_0_2 - , THUNK_STATIC - , THUNK_SELECTOR + In these bitmaps: 0 == ptr, 1 == non-ptr. + -------------------------------------------------------------------------- */ - , BCO - , AP_UPD +// +// 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) - , IND - , IND_OLDGEN - , IND_PERM - , IND_OLDGEN_PERM - , IND_STATIC +// +// A large bitmap. +// +typedef struct { + StgWord size; + StgWord bitmap[FLEXIBLE_ARRAY]; +} StgLargeBitmap; - , CAF_UNENTERED - , CAF_ENTERED - , CAF_BLACKHOLE +/* ----------------------------------------------------------------------------- + SRTs (Static Reference Tables) - , RET_BCO - , RET_SMALL - , RET_VEC_SMALL - , RET_BIG - , RET_VEC_BIG - , RET_DYN - , UPDATE_FRAME - , CATCH_FRAME - , STOP_FRAME - , SEQ_FRAME + 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. + -------------------------------------------------------------------------- */ - , BLACKHOLE - , BLACKHOLE_BQ +// An SRT is just an array of closure pointers: +typedef StgClosure* StgSRT[]; - , MVAR +// 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; - , ARR_WORDS - , MUT_ARR_PTRS - , MUT_ARR_PTRS_FROZEN +/* ---------------------------------------------------------------------------- + Info Tables + ------------------------------------------------------------------------- */ - , MUT_VAR +// +// 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 + StgWord large_bitmap_offset; // offset from info table to large bitmap structure +#endif + + StgWord selector_offset; // used in THUNK_SELECTORs - , WEAK - , FOREIGN - , STABLE_NAME +} StgClosureInfo; - , TSO - , BLOCKED_FETCH - , FETCH_ME +// +// The "standard" part of an info table. Every info table has this bit. +// +typedef struct _StgInfoTable { - , EVACUATED +#ifndef TABLES_NEXT_TO_CODE + StgFunPtr entry; // pointer to the entry code +#endif - , N_CLOSURE_TYPES /* number of distinct closure types */ +#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 -} StgClosureType; + StgClosureInfo layout; // closure layout info (one word) -/* The type flags provide quick access to certain properties of a closure. */ + 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; -#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_1_0 (_HNF| _NS ) -#define FLAGS_CONSTR_0_1 (_HNF| _NS ) -#define FLAGS_CONSTR_2_0 (_HNF| _NS ) -#define FLAGS_CONSTR_1_1 (_HNF| _NS ) -#define FLAGS_CONSTR_0_2 (_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_1_0 (_HNF| _NS ) -#define FLAGS_FUN_0_1 (_HNF| _NS ) -#define FLAGS_FUN_2_0 (_HNF| _NS ) -#define FLAGS_FUN_1_1 (_HNF| _NS ) -#define FLAGS_FUN_0_2 (_HNF| _NS ) -#define FLAGS_FUN_STATIC (_HNF| _NS|_STA| _SRT ) -#define FLAGS_THUNK ( _BTM| _THU| _SRT ) -#define FLAGS_THUNK_1_0 ( _BTM| _THU| _SRT ) -#define FLAGS_THUNK_0_1 ( _BTM| _THU| _SRT ) -#define FLAGS_THUNK_2_0 ( _BTM| _THU| _SRT ) -#define FLAGS_THUNK_1_1 ( _BTM| _THU| _SRT ) -#define FLAGS_THUNK_0_2 ( _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_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_STABLE_NAME (_HNF| _NS| _UPT ) -#define FLAGS_WEAK (_HNF| _NS| _UPT ) -#define FLAGS_BLACKHOLE ( _NS| _UPT ) -#define FLAGS_BLACKHOLE_BQ ( _NS| _MUT|_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 ) /* ----------------------------------------------------------------------------- - Info Tables + 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. -------------------------------------------------------------------------- */ -/* 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. - */ +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 { - StgWord size; - StgWord bitmap[0]; -} 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. - */ +#if defined(TABLES_NEXT_TO_CODE) + StgFunInfoExtraRev f; + StgInfoTable i; +#else + StgInfoTable i; + StgFunInfoExtraFwd f; +#endif +} StgFunInfoTable; -typedef union { +/* ----------------------------------------------------------------------------- + Return info tables + -------------------------------------------------------------------------- */ - StgWord bitmap; /* bit pattern, 1 = pointer, 0 = non-pointer */ - StgWord selector_offset; /* used in THUNK_SELECTORs */ - StgLargeBitmap* large_bitmap; /* pointer to large bitmap structure */ +// When info tables are laid out backwards, we can omit the SRT +// pointer iff srt_bitmap is zero. -#if SIZEOF_VOID_P == 8 - struct { - StgNat32 ptrs; /* number of pointers */ - StgNat32 nptrs; /* number of non-pointers */ - } payload; +typedef struct { +#if defined(TABLES_NEXT_TO_CODE) + StgWord srt_offset; // offset to the SRT table + StgInfoTable i; #else - struct { - StgNat16 ptrs; /* number of pointers */ - StgNat16 nptrs; /* number of non-pointers */ - } payload; + StgInfoTable i; + StgSRT *srt; // pointer to the SRT table + StgFunPtr vector[FLEXIBLE_ARRAY]; #endif - -} StgClosureInfo; +} StgRetInfoTable; -/* - * 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. - */ +/* ----------------------------------------------------------------------------- + Thunk info tables + -------------------------------------------------------------------------- */ -typedef StgClosure* StgSRT[]; +// When info tables are laid out backwards, we can omit the SRT +// pointer iff srt_bitmap is zero. -typedef struct _StgInfoTable { - StgSRT *srt; /* pointer to the SRT table */ -#ifdef PAR - StgParInfo par; +typedef struct _StgThunkInfoTable { +#if !defined(TABLES_NEXT_TO_CODE) + StgInfoTable i; #endif -#ifdef PROFILING - StgProfInfo prof; +#if defined(TABLES_NEXT_TO_CODE) + StgWord srt_offset; // offset to the SRT table +#else + StgSRT *srt; // pointer to the SRT table #endif -#ifdef DEBUG_CLOSURE - StgDebugInfo debug; +#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 +#define GET_SRT(info) ((StgSRT*) (((StgWord) ((info)+1)) + (info)->srt_offset)) +#else +#define GET_SRT(info) ((info)->srt) +#endif + +// 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 - 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.bitmap)) #else - StgCode code[0]; +#define GET_FUN_LARGE_BITMAP(info) ((StgLargeBitmap*) ((info)->f.bitmap)) #endif -} StgInfoTable; + #endif /* INFOTABLES_H */