X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fincludes%2FInfoTables.h;h=8fa699a0970c0bcdb3cb40dd8ec304340b0af75c;hb=a0f46309637779ccc141ec531e9b128596a5bba0;hp=5284932c1a8586be1019e7ff7edc892e13a76c3b;hpb=b67f18569f3be1118d7325cde71c8a0bc1508655;p=ghc-hetmet.git diff --git a/ghc/includes/InfoTables.h b/ghc/includes/InfoTables.h index 5284932..8fa699a 100644 --- a/ghc/includes/InfoTables.h +++ b/ghc/includes/InfoTables.h @@ -1,5 +1,4 @@ /* ---------------------------------------------------------------------------- - * $Id: InfoTables.h,v 1.32 2003/11/14 14:28:08 stolz Exp $ * * (c) The GHC Team, 1998-2002 * @@ -25,8 +24,8 @@ typedef struct { #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 */ @@ -71,25 +70,23 @@ typedef struct { # 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 - -------------------------------------------------------------------------- */ -#if defined(SUPPORTS_EMPTY_STRUCTS) -typedef struct { - /* empty */ -} StgTickyInfo; -#endif + There is no ticky-specific stuff in an info table at this time. + -------------------------------------------------------------------------- */ /* ----------------------------------------------------------------------------- Debugging info @@ -103,11 +100,7 @@ typedef struct { #else /* !DEBUG_CLOSURE */ -# if defined(SUPPORTS_EMPTY_STRUCTS) -typedef struct StgDebugInfo { - /* empty */ -} StgDebugInfo; -# endif +/* There is no DEBUG-specific stuff in an info table at this time. */ #endif /* DEBUG_CLOSURE */ @@ -169,21 +162,23 @@ extern StgWord16 closure_flags[]; (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. -------------------------------------------------------------------------- */ -// -// 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. -// +/* + * 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. -// +/* + * A large bitmap. + */ typedef struct { StgWord size; StgWord bitmap[FLEXIBLE_ARRAY]; @@ -198,52 +193,78 @@ typedef struct { garbage-collect CAFs. -------------------------------------------------------------------------- */ -// An SRT is just an array of closure pointers: +/* 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: +/* + * 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; /* ---------------------------------------------------------------------------- + Relative pointers + + Several pointer fields in info tables are expressed as offsets + relative to the info pointer, so that we can generate + position-independent code. + + There is a complication on the x86_64 platform, where pointeres are + 64 bits, but the tools don't support 64-bit relative relocations. + However, the default memory model (small) ensures that all symbols + have values in the lower 2Gb of the address space, so offsets all + fit in 32 bits. Hence we can use 32-bit offset fields. + ------------------------------------------------------------------------- */ + +#if x86_64_TARGET_ARCH +#define OFFSET_FIELD(n) StgHalfInt n; StgHalfWord __pad_##n; +#else +#define OFFSET_FIELD(n) StgInt n; +#endif + +/* ---------------------------------------------------------------------------- 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. -// +/* + * 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 + 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 + StgWord bitmap; /* word-sized bit pattern describing */ + /* a stack frame: see below */ - StgLargeBitmap* large_bitmap; // pointer to large bitmap structure +#ifndef TABLES_NEXT_TO_CODE + StgLargeBitmap* large_bitmap; /* pointer to large bitmap structure */ +#else + OFFSET_FIELD( large_bitmap_offset ); /* offset from info table to large bitmap structure */ +#endif - StgWord selector_offset; // used in THUNK_SELECTORs + StgWord selector_offset; /* used in THUNK_SELECTORs */ } StgClosureInfo; -// -// The "standard" part of an info table. Every info table has this bit. -// +/* + * The "standard" part of an info table. Every info table has this bit. + */ typedef struct _StgInfoTable { #ifndef TABLES_NEXT_TO_CODE - StgFunPtr entry; // pointer to the entry code + StgFunPtr entry; /* pointer to the entry code */ #endif #if defined(PAR) || defined(GRAN) @@ -253,16 +274,16 @@ typedef struct _StgInfoTable { StgProfInfo prof; #endif #ifdef TICKY - MAYBE_EMPTY_STRUCT(StgTickyInfo,ticky) + /* Ticky-specific stuff would go here. */ #endif #ifdef DEBUG_CLOSURE - MAYBE_EMPTY_STRUCT(StgDebugInfo,debug) + /* Debug-specific stuff would go here. */ #endif - StgClosureInfo layout; // closure layout info (one word) + StgClosureInfo layout; /* closure layout info (one word) */ - StgHalfWord type; // closure type - StgHalfWord srt_bitmap; // number of entries in SRT (or constructor tag) + StgHalfWord type; /* closure type */ + StgHalfWord srt_bitmap; /* number of entries in SRT (or constructor tag) */ #ifdef TABLES_NEXT_TO_CODE StgCode code[FLEXIBLE_ARRAY]; @@ -285,21 +306,34 @@ typedef struct _StgInfoTable { bitmap fields have also been omitted. -------------------------------------------------------------------------- */ -typedef struct _StgFunInfoTable { +typedef struct _StgFunInfoExtraRev { + OFFSET_FIELD ( slow_apply_offset ); /* apply to args on the stack */ + union { + StgWord bitmap; + OFFSET_FIELD ( bitmap_offset ); /* arg ptr/nonptr bitmap */ + } b; + OFFSET_FIELD ( 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 */ + union { /* union for compat. with TABLES_NEXT_TO_CODE version */ + StgWord bitmap; /* arg ptr/nonptr bitmap */ + } b; + StgFun *slow_apply; /* apply to args on the stack */ +} StgFunInfoExtraFwd; + +typedef struct { #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 + StgFunInfoExtraRev f; 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 + StgFunInfoExtraFwd f; #endif } StgFunInfoTable; @@ -307,18 +341,18 @@ typedef struct _StgFunInfoTable { Return info tables -------------------------------------------------------------------------- */ -// When info tables are laid out backwards, we can omit the SRT -// pointer iff srt_bitmap is zero. +/* + * 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 +typedef struct { #if defined(TABLES_NEXT_TO_CODE) + OFFSET_FIELD( srt_offset ); /* offset to the SRT table */ StgInfoTable i; -#endif -#if !defined(TABLES_NEXT_TO_CODE) +#else + StgInfoTable i; + StgSRT *srt; /* pointer to the SRT table */ StgFunPtr vector[FLEXIBLE_ARRAY]; #endif } StgRetInfoTable; @@ -327,17 +361,63 @@ typedef struct _StgRetInfoTable { Thunk info tables -------------------------------------------------------------------------- */ -// When info tables are laid out backwards, we can omit the SRT -// pointer iff srt_bitmap is zero. +/* + * 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) + OFFSET_FIELD( srt_offset ); /* offset to the SRT table */ +#else + 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 +#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 + +#ifdef TABLES_NEXT_TO_CODE +#define GET_LARGE_BITMAP(info) ((StgLargeBitmap*) (((StgWord) ((info)+1)) \ + + (info)->layout.large_bitmap_offset)) +#else +#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.b.bitmap_offset)) +#else +#define GET_FUN_LARGE_BITMAP(info) ((StgLargeBitmap*) ((info)->f.b.bitmap)) +#endif + + #endif /* INFOTABLES_H */