X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fincludes%2FInfoTables.h;h=1aff7681f75e80955826cbf9a3357e49c0cb72f9;hb=026fa45f1852a836a3bb182a76065da899c163cc;hp=92e957c4af9e868debdf4be1c2ade65d0afa3225;hpb=589b7946b0847a47d1a5493dcec0976c84814312;p=ghc-hetmet.git diff --git a/ghc/includes/InfoTables.h b/ghc/includes/InfoTables.h index 92e957c..1aff768 100644 --- a/ghc/includes/InfoTables.h +++ b/ghc/includes/InfoTables.h @@ -1,5 +1,5 @@ /* ---------------------------------------------------------------------------- - * $Id: InfoTables.h,v 1.15 1999/05/13 17:31:07 simonm Exp $ + * $Id: InfoTables.h,v 1.27 2002/05/14 08:15:49 matthewc Exp $ * * (c) The GHC Team, 1998-1999 * @@ -14,45 +14,80 @@ Profiling info -------------------------------------------------------------------------- */ -#ifdef PROFILING - -#define PROF_INFO_WORDS n - -typedef struct { - /* nothing yet */ -} StgProfInfo; - -#else /* !PROFILING */ - -#define PROF_INFO_WORDS 0 - typedef struct { - /* empty */ + char *closure_type; + char *closure_desc; } 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 */ +typedef struct { + /* empty */ +} StgTickyInfo; /* ----------------------------------------------------------------------------- Debugging info @@ -60,32 +95,33 @@ 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; #endif /* DEBUG_CLOSURE */ +/* ----------------------------------------------------------------------------- + Closure flags + -------------------------------------------------------------------------- */ + /* The type flags provide quick access to certain properties of a closure. */ -#define _HNF (1<<0) /* head normal form? */ +#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 _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) @@ -98,11 +134,29 @@ extern StgWord16 closure_flags[]; #define closureFlags(c) (closure_flags[get_itbl(c)->type]) -#define closure_STATIC(c) ( closureFlags(c) & _STA) +#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) /* ----------------------------------------------------------------------------- Info Tables @@ -115,7 +169,7 @@ extern StgWord16 closure_flags[]; typedef struct { StgWord size; - StgWord bitmap[0]; + StgWord bitmap[FLEXIBLE_ARRAY]; } StgLargeBitmap; /* @@ -126,22 +180,19 @@ typedef struct { */ typedef union { -#if SIZEOF_VOID_P == 8 struct { +#if SIZEOF_VOID_P == 8 StgWord32 ptrs; /* number of pointers */ StgWord32 nptrs; /* number of non-pointers */ - } payload; #else - struct { 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 */ - -#endif } StgClosureInfo; @@ -154,13 +205,23 @@ typedef union { 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. + */ typedef struct _StgInfoTable { +#ifndef TABLES_NEXT_TO_CODE + StgFunPtr entry; +#endif 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; */ + StgProfInfo prof; +#endif +#ifdef TICKY + StgTickyInfo ticky; #endif #ifdef DEBUG_CLOSURE StgDebugInfo debug; @@ -173,11 +234,10 @@ typedef struct _StgInfoTable { StgWord type : 16; /* } These 2 elements fit into 32 bits */ StgWord srt_len : 16; /* } */ #endif -#if USE_MINIINTERPRETER - StgFunPtr entry; - StgFunPtr vector[0]; +#ifdef TABLES_NEXT_TO_CODE + StgCode code[FLEXIBLE_ARRAY]; #else - StgCode code[0]; + StgFunPtr vector[FLEXIBLE_ARRAY]; #endif } StgInfoTable; @@ -188,7 +248,12 @@ typedef struct _StgInfoTable { * stack. We distinguish the two by checking whether the pointer is * into text-space or not. */ - + +#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"))) +#else #define INFO_TBL_CONST const +#endif #endif /* INFOTABLES_H */