ghc/includes/InfoTables.h

   1 /* ----------------------------------------------------------------------------
   2  * $Id: InfoTables.h,v 1.29 2003/05/14 09:14:02 simonmar Exp $
   3  *
   4  * (c) The GHC Team, 1998-2002
   5  *
   6  * Info Tables
   7  *
   8  * -------------------------------------------------------------------------- */
   9
  10 #ifndef INFOTABLES_H
  11 #define INFOTABLES_H
  12
  13 /* -----------------------------------------------------------------------------
  14    Profiling info
  15    -------------------------------------------------------------------------- */
  16
  17 typedef struct {
  18     char *closure_type;
  19     char *closure_desc;
  20 } StgProfInfo;
  21
  22 /* -----------------------------------------------------------------------------
  23    Parallelism info
  24    -------------------------------------------------------------------------- */
  25
  26 #if 0 && (defined(PAR) || defined(GRAN))
  27
  28 // CURRENTLY UNUSED
  29 // ToDo: use this in StgInfoTable (mutually recursive) -- HWL
  30
  31 typedef struct {
  32   StgInfoTable *rbh_infoptr;     /* infoptr to the RBH  */
  33 } StgParInfo;
  34
  35 #endif /* 0 */
  36
  37 /*
  38    Copied from ghc-0.29; ToDo: check this code -- HWL
  39
  40    In the parallel system, all updatable closures have corresponding
  41    revertible black holes.  When we are assembly-mangling, we guarantee
  42    that the revertible black hole code precedes the normal entry code, so
  43    that the RBH info table resides at a fixed offset from the normal info
  44    table.  Otherwise, we add the RBH info table pointer to the end of the
  45    normal info table and vice versa.
  46
  47    Currently has to use a !RBH_MAGIC_OFFSET setting.
  48    Still todo: init of par.infoptr field in all infotables!!
  49 */
  50
  51 #if defined(PAR) || defined(GRAN)
  52
  53 # ifdef RBH_MAGIC_OFFSET
  54
  55 #  error magic offset not yet implemented
  56
  57 #  define RBH_INFO_WORDS    0
  58 #  define INCLUDE_RBH_INFO(infoptr)
  59
  60 #  define RBH_INFOPTR(infoptr)      (((P_)infoptr) - RBH_MAGIC_OFFSET)
  61 #  define REVERT_INFOPTR(infoptr)   (((P_)infoptr) + RBH_MAGIC_OFFSET)
  62
  63 # else
  64
  65 #  define RBH_INFO_WORDS    1
  66 #  define INCLUDE_RBH_INFO(info)    rbh_infoptr : &(info)
  67
  68 #  define RBH_INFOPTR(infoptr)      (((StgInfoTable *)(infoptr))->rbh_infoptr)
  69 #  define REVERT_INFOPTR(infoptr)   (((StgInfoTable *)(infoptr))->rbh_infoptr)
  70
  71 # endif
  72
  73 /* see ParallelRts.h */
  74 // EXTFUN(RBH_entry);
  75 //StgClosure *convertToRBH(StgClosure *closure);
  76 //#if defined(GRAN)
  77 //void convertFromRBH(StgClosure *closure);
  78 //#elif defined(PAR)
  79 //void convertToFetchMe(StgPtr closure, globalAddr *ga);
  80 //#endif
  81
  82 #endif
  83
  84 /* -----------------------------------------------------------------------------
  85    Ticky info
  86    -------------------------------------------------------------------------- */
  87
  88 typedef struct {
  89     /* empty */
  90 } StgTickyInfo;
  91
  92 /* -----------------------------------------------------------------------------
  93    Debugging info
  94    -------------------------------------------------------------------------- */
  95
  96 #ifdef DEBUG_CLOSURE
  97
  98 typedef struct {
  99         ... whatever ...
 100 } StgDebugInfo;
 101
 102 #else /* !DEBUG_CLOSURE */
 103
 104 typedef struct {
 105         /* empty */
 106 } StgDebugInfo;
 107
 108 #endif /* DEBUG_CLOSURE */
 109
 110 /* -----------------------------------------------------------------------------
 111    Closure flags
 112    -------------------------------------------------------------------------- */
 113
 114 /* The type flags provide quick access to certain properties of a closure. */
 115
 116 #define _HNF (1<<0)  /* head normal form?    */
 117 #define _BTM (1<<1)  /* bitmap-style layout? */
 118 #define _NS  (1<<2)  /* non-sparkable        */
 119 #define _STA (1<<3)  /* static?              */
 120 #define _THU (1<<4)  /* thunk?               */
 121 #define _MUT (1<<5)  /* mutable?             */
 122 #define _UPT (1<<6)  /* unpointed?           */
 123 #define _SRT (1<<7)  /* has an SRT?          */
 124 #define _IND (1<<8)  /* is an indirection?   */
 125
 126 #define isSTATIC(flags)    ((flags) &_STA)
 127 #define isMUTABLE(flags)   ((flags) &_MUT)
 128 #define isBITMAP(flags)    ((flags) &_BTM)
 129 #define isTHUNK(flags)     ((flags) &_THU)
 130 #define isUNPOINTED(flags) ((flags) &_UPT)
 131 #define hasSRT(flags)      ((flags) &_SRT)
 132
 133 extern StgWord16 closure_flags[];
 134
 135 #define closureFlags(c)         (closure_flags[get_itbl(c)->type])
 136
 137 #define closure_HNF(c)          (  closureFlags(c) & _HNF)
 138 #define closure_BITMAP(c)       (  closureFlags(c) & _BTM)
 139 #define closure_NON_SPARK(c)    ( (closureFlags(c) & _NS))
 140 #define closure_SHOULD_SPARK(c) (!(closureFlags(c) & _NS))
 141 #define closure_STATIC(c)       (  closureFlags(c) & _STA)
 142 #define closure_THUNK(c)        (  closureFlags(c) & _THU)
 143 #define closure_MUTABLE(c)      (  closureFlags(c) & _MUT)
 144 #define closure_UNPOINTED(c)    (  closureFlags(c) & _UPT)
 145 #define closure_SRT(c)          (  closureFlags(c) & _SRT)
 146 #define closure_IND(c)          (  closureFlags(c) & _IND)
 147
 148 /* same as above but for info-ptr rather than closure */
 149 #define ipFlags(ip)             (closure_flags[ip->type])
 150
 151 #define ip_HNF(ip)               (  ipFlags(ip) & _HNF)
 152 #define ip_BITMAP(ip)            (  ipFlags(ip) & _BTM)
 153 #define ip_SHOULD_SPARK(ip)      (!(ipFlags(ip) & _NS))
 154 #define ip_STATIC(ip)            (  ipFlags(ip) & _STA)
 155 #define ip_THUNK(ip)             (  ipFlags(ip) & _THU)
 156 #define ip_MUTABLE(ip)           (  ipFlags(ip) & _MUT)
 157 #define ip_UNPOINTED(ip)         (  ipFlags(ip) & _UPT)
 158 #define ip_SRT(ip)               (  ipFlags(ip) & _SRT)
 159 #define ip_IND(ip)               (  ipFlags(ip) & _IND)
 160
 161 /* -----------------------------------------------------------------------------
 162    Bitmaps
 163
 164    These are used to describe the pointerhood of a sequence of words
 165    (usually on the stack) to the garbage collector.  The two primary
 166    uses are for stack frames, and functions (where we need to describe
 167    the layout of a PAP to the GC).
 168    -------------------------------------------------------------------------- */
 169
 170 //
 171 // Small bitmaps:  for a small bitmap, we store the size and bitmap in
 172 // the same word, using the following macros.  If the bitmap doesn't
 173 // fit in a single word, we use a pointer to an StgLargeBitmap below.
 174 //
 175 #define MK_SMALL_BITMAP(size,bits) (((bits)<<BITMAP_BITS_SHIFT) | (size))
 176
 177 #define BITMAP_SIZE(bitmap) ((bitmap) & BITMAP_SIZE_MASK)
 178 #define BITMAP_BITS(bitmap) ((bitmap) >> BITMAP_BITS_SHIFT)
 179
 180 //
 181 // A large bitmap.
 182 //
 183 typedef struct {
 184   StgWord size;
 185   StgWord bitmap[FLEXIBLE_ARRAY];
 186 } StgLargeBitmap;
 187
 188 /* -----------------------------------------------------------------------------
 189    SRTs  (Static Reference Tables)
 190
 191    These tables are used to keep track of the static objects referred
 192    to by the code for a closure or stack frame, so that we can follow
 193    static data references from code and thus accurately
 194    garbage-collect CAFs.
 195    -------------------------------------------------------------------------- */
 196
 197 // An SRT is just an array of closure pointers:
 198 typedef StgClosure* StgSRT[];
 199
 200 // Each info table refers to some subset of the closure pointers in an
 201 // SRT.  It does this using a pair of an StgSRT pointer and a
 202 // half-word bitmap.  If the half-word bitmap isn't large enough, then
 203 // we fall back to a large SRT, including an unbounded bitmap.  If the
 204 // half-word bitmap is set to all ones (0xffff), then the StgSRT
 205 // pointer instead points to an StgLargeSRT:
 206 typedef struct StgLargeSRT_ {
 207     StgSRT *srt;
 208     StgLargeBitmap l;
 209 } StgLargeSRT;
 210
 211 /* ----------------------------------------------------------------------------
 212    Info Tables
 213    ------------------------------------------------------------------------- */
 214
 215 //
 216 // Stuff describing the closure layout.  Well, actually, it might
 217 // contain the selector index for a THUNK_SELECTOR.  This union is one
 218 // word long.
 219 //
 220 typedef union {
 221     struct {                    // Heap closure payload layout:
 222         StgHalfWord ptrs;       // number of pointers
 223         StgHalfWord nptrs;      // number of non-pointers
 224     } payload;
 225
 226     StgWord bitmap;               // word-sized bit pattern describing
 227                                   //  a stack frame: see below
 228
 229     StgLargeBitmap* large_bitmap; // pointer to large bitmap structure
 230
 231     StgWord selector_offset;      // used in THUNK_SELECTORs
 232
 233 } StgClosureInfo;
 234
 235
 236 //
 237 // The "standard" part of an info table.  Every info table has this bit.
 238 //
 239 typedef struct _StgInfoTable {
 240
 241 #ifndef TABLES_NEXT_TO_CODE
 242     StgFunPtr       entry;      // pointer to the entry code
 243 #endif
 244
 245 #if defined(PAR) || defined(GRAN)
 246     struct _StgInfoTable    *rbh_infoptr;
 247 #endif
 248 #ifdef PROFILING
 249     StgProfInfo     prof;
 250 #endif
 251 #ifdef TICKY
 252     StgTickyInfo    ticky;
 253 #endif
 254 #ifdef DEBUG_CLOSURE
 255     StgDebugInfo    debug;
 256 #endif
 257
 258     StgClosureInfo  layout;     // closure layout info (one word)
 259
 260     StgHalfWord     type;       // closure type
 261     StgHalfWord     srt_bitmap;    // number of entries in SRT (or constructor tag)
 262
 263 #ifdef TABLES_NEXT_TO_CODE
 264     StgCode         code[FLEXIBLE_ARRAY];
 265 #endif
 266 } StgInfoTable;
 267
 268
 269 /* -----------------------------------------------------------------------------
 270    Function info tables
 271
 272    This is the general form of function info tables.  The compiler
 273    will omit some of the fields in common cases:
 274
 275    -  If fun_type is not ARG_GEN or ARG_GEN_BIG, then the slow_apply
 276       and bitmap fields may be left out (they are at the end, so omitting
 277       them doesn't affect the layout).
 278
 279    -  If srt_bitmap (in the std info table part) is zero, then the srt
 280       field may be omitted.  This only applies if the slow_apply and
 281       bitmap fields have also been omitted.
 282    -------------------------------------------------------------------------- */
 283
 284 typedef struct _StgFunInfoTable {
 285 #if defined(TABLES_NEXT_TO_CODE)
 286     StgFun         *slow_apply; // apply to args on the stack
 287     StgWord        bitmap;      // arg ptr/nonptr bitmap
 288     StgSRT         *srt;        // pointer to the SRT table
 289     StgHalfWord    fun_type;    // function type
 290     StgHalfWord    arity;       // function arity
 291     StgInfoTable i;
 292 #else
 293     StgInfoTable i;
 294     StgHalfWord    fun_type;    // function type
 295     StgHalfWord    arity;       // function arity
 296     StgSRT         *srt;        // pointer to the SRT table
 297     StgWord        bitmap;      // arg ptr/nonptr bitmap
 298     StgFun         *slow_apply; // apply to args on the stack
 299 #endif
 300 } StgFunInfoTable;
 301
 302 /* -----------------------------------------------------------------------------
 303    Return info tables
 304    -------------------------------------------------------------------------- */
 305
 306 // When info tables are laid out backwards, we can omit the SRT
 307 // pointer iff srt_bitmap is zero.
 308
 309 typedef struct _StgRetInfoTable {
 310 #if !defined(TABLES_NEXT_TO_CODE)
 311     StgInfoTable i;
 312 #endif
 313     StgSRT         *srt;        // pointer to the SRT table
 314 #if defined(TABLES_NEXT_TO_CODE)
 315     StgInfoTable i;
 316 #endif
 317 #if !defined(TABLES_NEXT_TO_CODE)
 318     StgFunPtr vector[FLEXIBLE_ARRAY];
 319 #endif
 320 } StgRetInfoTable;
 321
 322 /* -----------------------------------------------------------------------------
 323    Thunk info tables
 324    -------------------------------------------------------------------------- */
 325
 326 // When info tables are laid out backwards, we can omit the SRT
 327 // pointer iff srt_bitmap is zero.
 328
 329 typedef struct _StgThunkInfoTable {
 330 #if !defined(TABLES_NEXT_TO_CODE)
 331     StgInfoTable i;
 332 #endif
 333     StgSRT         *srt;        // pointer to the SRT table
 334 #if defined(TABLES_NEXT_TO_CODE)
 335     StgInfoTable i;
 336 #endif
 337 } StgThunkInfoTable;
 338
 339 #endif /* INFOTABLES_H */