X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fincludes%2FInfoTables.h;h=498f6b835b74a5593f7c7d9864718b153d393632;hb=020b0f8ad6a202787727c93cdc1a804b93a6c39c;hp=3f1cd51f603918df0f45093b5b76a0188d090a68;hpb=612755bd52b4d422de179f4c0ca30b8afea336c1;p=ghc-hetmet.git diff --git a/ghc/includes/InfoTables.h b/ghc/includes/InfoTables.h index 3f1cd51..498f6b8 100644 --- a/ghc/includes/InfoTables.h +++ b/ghc/includes/InfoTables.h @@ -1,6 +1,8 @@ /* ---------------------------------------------------------------------------- - * $Id: InfoTables.h,v 1.8 1999/02/05 12:41:32 sof Exp $ + * $Id: InfoTables.h,v 1.19 2000/04/05 15:27:59 simonmar Exp $ * + * (c) The GHC Team, 1998-1999 + * * Info Tables * * -------------------------------------------------------------------------- */ @@ -14,16 +16,13 @@ #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; @@ -34,139 +33,87 @@ typedef struct { 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 */ -#define PAR_INFO_WORDS 0 - typedef struct { /* empty */ } StgParInfo; #endif /* PAR */ -/* ----------------------------------------------------------------------------- - 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; - -#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). - -------------------------------------------------------------------------- */ - -typedef enum { - - INVALID_OBJECT /* Object tag 0 raises an internal error */ +/* + Copied from ghc-0.29; ToDo: check this code -- HWL - , 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 + 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. - , FUN - , FUN_1_0 - , FUN_0_1 - , FUN_2_0 - , FUN_1_1 - , FUN_0_2 - , FUN_STATIC + Currently has to use a !RBH_MAGIC_OFFSET setting. + Still todo: init of par.infoptr field in all infotables!! +*/ - , THUNK - , THUNK_1_0 - , THUNK_0_1 - , THUNK_2_0 - , THUNK_1_1 - , THUNK_0_2 - , THUNK_STATIC - , THUNK_SELECTOR +#if defined(PAR) || defined(GRAN) - , BCO - , AP_UPD +# ifdef RBH_MAGIC_OFFSET - , PAP /* should be called AP_NUPD */ +# error magic offset not yet implemented - , IND - , IND_OLDGEN - , IND_PERM - , IND_OLDGEN_PERM - , IND_STATIC +# define RBH_INFO_WORDS 0 +# define INCLUDE_RBH_INFO(infoptr) - , CAF_UNENTERED - , CAF_ENTERED - , CAF_BLACKHOLE +# define RBH_INFOPTR(infoptr) (((P_)infoptr) - RBH_MAGIC_OFFSET) +# define REVERT_INFOPTR(infoptr) (((P_)infoptr) + RBH_MAGIC_OFFSET) - , RET_BCO - , RET_SMALL - , RET_VEC_SMALL - , RET_BIG - , RET_VEC_BIG - , RET_DYN - , UPDATE_FRAME - , CATCH_FRAME - , STOP_FRAME - , SEQ_FRAME +# else - , BLACKHOLE - , BLACKHOLE_BQ +# define RBH_INFO_WORDS 1 +# define INCLUDE_RBH_INFO(info) rbh_infoptr : &(info) - , MVAR +# define RBH_INFOPTR(infoptr) (((StgInfoTable *)(infoptr))->rbh_infoptr) +# define REVERT_INFOPTR(infoptr) (((StgInfoTable *)(infoptr))->rbh_infoptr) - , ARR_WORDS - , MUT_ARR_WORDS +# endif - , MUT_ARR_PTRS - , MUT_ARR_PTRS_FROZEN +/* 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 - , MUT_VAR +#endif - , WEAK - , FOREIGN - , STABLE_NAME +/* ----------------------------------------------------------------------------- + Debugging info + -------------------------------------------------------------------------- */ - , TSO +#ifdef DEBUG_CLOSURE - , BLOCKED_FETCH - , FETCH_ME +typedef struct { + ... whatever ... +} StgDebugInfo; - , EVACUATED +#else /* !DEBUG_CLOSURE */ - , N_CLOSURE_TYPES /* number of distinct closure types */ +typedef struct { + /* empty */ +} StgDebugInfo; -} StgClosureType; +#endif /* DEBUG_CLOSURE */ /* The type flags provide quick access to certain properties of a closure. */ @@ -179,74 +126,38 @@ typedef enum { #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_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_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 ) +#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) + +/* 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) /* ----------------------------------------------------------------------------- Info Tables @@ -270,22 +181,19 @@ typedef struct { */ 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; 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; -#else - struct { - StgNat16 ptrs; /* number of pointers */ - StgNat16 nptrs; /* number of non-pointers */ - } payload; -#endif } StgClosureInfo; @@ -300,8 +208,8 @@ typedef StgClosure* StgSRT[]; typedef struct _StgInfoTable { StgSRT *srt; /* pointer to the SRT table */ -#ifdef PAR - StgParInfo par; +#if defined(PAR) || defined(GRAN) + struct _StgInfoTable *rbh_infoptr; #endif #ifdef PROFILING StgProfInfo prof; @@ -311,20 +219,28 @@ typedef struct _StgInfoTable { #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; /* } */ + StgWord32 type; /* } These 2 elements fit into 64 bits */ + StgWord32 srt_len; /* } */ #else - StgNat8 flags; /* } */ - StgClosureType type : 8; /* } These 4 elements fit into 32 bits */ - StgNat16 srt_len; /* } */ + StgWord type : 16; /* } These 2 elements fit into 32 bits */ + StgWord srt_len : 16; /* } */ #endif -#if USE_MINIINTERPRETER - StgFunPtr (*vector)[]; - StgFunPtr entry; -#else +#ifdef TABLES_NEXT_TO_CODE StgCode code[0]; +#else + StgFunPtr entry; + StgFunPtr vector[0]; #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 + #endif /* INFOTABLES_H */