ghc/includes/Closures.h

   1 /* ----------------------------------------------------------------------------
   2  * $Id: Closures.h,v 1.26 2001/02/11 17:51:08 simonmar Exp $
   3  *
   4  * (c) The GHC Team, 1998-1999
   5  *
   6  * Closures
   7  *
   8  * -------------------------------------------------------------------------- */
   9
  10 #ifndef CLOSURES_H
  11 #define CLOSURES_H
  12
  13 /*
  14  * The Layout of a closure header depends on which kind of system we're
  15  * compiling for: profiling, parallel, ticky, etc.
  16  */
  17
  18 /* -----------------------------------------------------------------------------
  19    The profiling header
  20    -------------------------------------------------------------------------- */
  21
  22 #ifdef PROFILING
  23
  24 typedef struct {
  25    CostCentreStack *ccs;
  26 } StgProfHeader;
  27
  28 #else /* !PROFILING */
  29
  30 typedef struct {
  31         /* empty */
  32 } StgProfHeader;
  33
  34 #endif /* PROFILING */
  35
  36 /* -----------------------------------------------------------------------------
  37    The parallel header
  38    -------------------------------------------------------------------------- */
  39
  40 #ifdef PAR
  41
  42 typedef struct {
  43   /* StgWord ga; */  /* nope! global addresses are managed via a hash table */
  44 } StgParHeader;
  45
  46 #else /* !PAR */
  47
  48 typedef struct {
  49   /* empty */
  50 } StgParHeader;
  51
  52 #endif /* PAR */
  53
  54 /* -----------------------------------------------------------------------------
  55    The GranSim header
  56    -------------------------------------------------------------------------- */
  57
  58 #if defined(GRAN)
  59
  60 typedef struct {
  61   StgWord procs; /* bitmask indicating on which PEs this closure resides */
  62 } StgGranHeader;
  63
  64 #else /* !GRAN */
  65
  66 typedef struct {
  67   /* empty */
  68 } StgGranHeader;
  69
  70 #endif /* GRAN */
  71
  72 /* -----------------------------------------------------------------------------
  73    The ticky-ticky header
  74
  75    Comment from old Ticky.h:
  76
  77    This is used to record if a closure has been updated but not yet
  78    entered. It is set when the closure is updated and cleared when
  79    subsequently entered.
  80
  81    NB: It is {\em not} an ``entry count'', it is an
  82    ``entries-after-update count.''
  83
  84    The commoning up of @CONST@, @CHARLIKE@ and @INTLIKE@ closures is
  85    turned off(?) if this is required. This has only been done for 2s
  86    collection.  It is done using a nasty hack which defines the
  87    @_Evacuate@ and @_Scavenge@ code for @CONST@, @CHARLIKE@ and @INTLIKE@
  88    info tables to be @_Evacuate_1@ and @_Scavenge_1_0@.
  89    -------------------------------------------------------------------------- */
  90
  91 #ifdef TICKY_TICKY
  92
  93 typedef struct {
  94   /* old: W_ updated; */
  95 } StgTickyHeader;
  96
  97 #else /* !TICKY_TICKY */
  98
  99 typedef struct {
 100         /* empty */
 101 } StgTickyHeader;
 102
 103 #endif /* TICKY_TICKY */
 104
 105 /* -----------------------------------------------------------------------------
 106    The full fixed-size closure header
 107
 108    The size of the fixed header is the sum of the optional parts plus a single
 109    word for the entry code pointer.
 110    -------------------------------------------------------------------------- */
 111
 112 typedef struct {
 113         const struct _StgInfoTable* info;
 114 #ifdef PROFILING
 115         StgProfHeader         prof;
 116 #endif
 117 #ifdef PAR
 118         StgParHeader          par;
 119 #endif
 120 #ifdef GRAN
 121         StgGranHeader         gran;
 122 #endif
 123 #ifdef TICKY_TICKY
 124         StgTickyHeader        ticky;
 125 #endif
 126 } StgHeader;
 127
 128 #define FIXED_HS (sizeof(StgHeader))
 129
 130 /* -----------------------------------------------------------------------------
 131    Closure Types
 132
 133    For any given closure type (defined in InfoTables.h), there is a
 134    corresponding structure defined below.  The name of the structure
 135    is obtained by concatenating the closure type with '_closure'
 136    -------------------------------------------------------------------------- */
 137
 138 /* All closures follow the generic format */
 139
 140 struct StgClosure_ {
 141     StgHeader   header;
 142     struct StgClosure_ *payload[0];
 143 };
 144
 145 /* What a stroke of luck - all our mutable closures follow the same
 146  * basic layout, with the mutable link field as the second field after
 147  * the header.  This means the following structure is the supertype of
 148  * mutable closures.
 149  */
 150
 151 typedef struct StgMutClosure_ {
 152     StgHeader   header;
 153     StgWord     padding;
 154     struct StgMutClosure_ *mut_link;
 155     struct StgClosure_ *payload[0];
 156 } StgMutClosure;
 157
 158 typedef struct {
 159     StgHeader   header;
 160     StgClosure *selectee;
 161 } StgSelector;
 162
 163 typedef struct {
 164     StgHeader   header;
 165     StgWord     n_args;
 166     StgClosure *fun;
 167     StgClosure *payload[0];
 168 } StgPAP;
 169
 170 typedef struct {
 171     StgHeader   header;
 172     StgWord     n_args;
 173     StgClosure *fun;
 174     StgClosure *payload[0];
 175 } StgAP_UPD;
 176
 177 typedef struct {
 178     StgHeader   header;
 179     StgClosure *indirectee;
 180 } StgInd;
 181
 182 typedef struct {
 183     StgHeader   header;
 184     StgClosure *indirectee;
 185     StgMutClosure *mut_link;
 186 } StgIndOldGen;
 187
 188 typedef struct {
 189     StgHeader     header;
 190     StgClosure   *indirectee;
 191     StgClosure   *static_link;
 192     struct _StgInfoTable *saved_info;
 193 } StgIndStatic;
 194
 195 typedef struct {
 196     StgHeader  header;
 197     StgWord    words;
 198     StgWord    payload[0];
 199 } StgArrWords;
 200
 201 typedef struct {
 202     StgHeader   header;
 203     StgWord     ptrs;
 204     StgMutClosure *mut_link;    /* mutable list */
 205     StgClosure *payload[0];
 206 } StgMutArrPtrs;
 207
 208 typedef struct {
 209     StgHeader   header;
 210     StgClosure *var;
 211     StgMutClosure *mut_link;
 212 } StgMutVar;
 213
 214 typedef struct {
 215     StgHeader      header;
 216     StgArrWords   *instrs;      /* a pointer to an ArrWords */
 217     StgArrWords   *literals;    /* a pointer to an ArrWords */
 218     StgMutArrPtrs *ptrs;        /* a pointer to a MutArrPtrs */
 219     StgArrWords   *itbls;       /* a pointer to an ArrWords */
 220 } StgBCO;
 221
 222 /*
 223    A collective typedef for all linkable stack frames i.e.
 224      StgUpdateFrame, StgSeqFrame, StgCatchFrame
 225 */
 226 typedef struct _StgFrame {
 227     StgHeader  header;
 228     struct _StgFrame *link;
 229 } StgFrame;
 230
 231 typedef struct _StgUpdateFrame {
 232     StgHeader  header;
 233     struct _StgUpdateFrame *link;
 234     StgClosure *updatee;
 235 } StgUpdateFrame;
 236
 237 typedef struct {
 238     StgHeader  header;
 239     struct _StgUpdateFrame *link;
 240 } StgSeqFrame;
 241
 242 typedef struct {
 243     StgHeader  header;
 244     struct _StgUpdateFrame *link;
 245     StgInt      exceptions_blocked;
 246     StgClosure *handler;
 247 } StgCatchFrame;
 248
 249 typedef struct {
 250     StgHeader  header;
 251 } StgStopFrame;
 252
 253 typedef struct {
 254     StgHeader   header;
 255     StgClosure *evacuee;
 256 } StgEvacuated;
 257
 258 typedef struct {
 259   StgHeader header;
 260   StgWord data;
 261 } StgIntCharlikeClosure;
 262
 263 /* statically allocated */
 264 typedef struct {
 265   StgHeader  header;
 266 } StgRetry;
 267
 268 typedef struct _StgForeignObj {
 269   StgHeader      header;
 270   StgAddr        data;          /* pointer to data in non-haskell-land */
 271 } StgForeignObj;
 272
 273 typedef struct _StgStableName {
 274   StgHeader      header;
 275   StgWord        sn;
 276 } StgStableName;
 277
 278 typedef struct _StgWeak {       /* Weak v */
 279   StgHeader header;
 280   StgClosure *key;
 281   StgClosure *value;            /* v */
 282   StgClosure *finalizer;
 283   struct _StgWeak *link;
 284 } StgWeak;
 285
 286 typedef struct _StgDeadWeak {   /* Weak v */
 287   StgHeader header;
 288   struct _StgWeak *link;
 289 } StgDeadWeak;
 290
 291 /* Dynamic stack frames - these have a liveness mask in the object
 292  * itself, rather than in the info table.  Useful for generic heap
 293  * check code.
 294  */
 295
 296 typedef struct {
 297   const struct _StgInfoTable* info;
 298   StgWord        liveness;
 299   StgWord        ret_addr;
 300   StgWord        payload[0];
 301 } StgRetDyn;
 302
 303 /* Concurrent communication objects */
 304
 305 typedef struct {
 306   StgHeader       header;
 307   struct StgTSO_ *head;
 308   StgMutClosure  *mut_link;
 309   struct StgTSO_ *tail;
 310   StgClosure*     value;
 311 } StgMVar;
 312
 313 #if defined(PAR) || defined(GRAN)
 314 /*
 315   StgBlockingQueueElement is a ``collective type'' representing the types
 316   of closures that can be found on a blocking queue: StgTSO, StgRBHSave,
 317   StgBlockedFetch.  (StgRBHSave can only appear at the end of a blocking
 318   queue).  Logically, this is a union type, but defining another struct
 319   with a common layout is easier to handle in the code (same as for
 320   StgMutClosures).
 321   Note that in the standard setup only StgTSOs can be on a blocking queue.
 322   This is one of the main reasons for slightly different code in files
 323   such as Schedule.c.
 324 */
 325 typedef struct StgBlockingQueueElement_ {
 326   StgHeader                         header;
 327   struct StgBlockingQueueElement_  *link;      /* next elem in BQ */
 328   StgMutClosure                    *mut_link;  /* next elem in mutable list */
 329   struct StgClosure_               *payload[0];/* contents of the closure */
 330 } StgBlockingQueueElement;
 331
 332 /* only difference to std code is type of the elem in the BQ */
 333 typedef struct StgBlockingQueue_ {
 334   StgHeader                 header;
 335   struct StgBlockingQueueElement_ *blocking_queue; /* start of the BQ */
 336   StgMutClosure            *mut_link;              /* next elem in mutable list */
 337 } StgBlockingQueue;
 338
 339 /* this closure is hanging at the end of a blocking queue in (see RBH.c) */
 340 typedef struct StgRBHSave_ {
 341   StgHeader    header;
 342   StgClosure  *payload[0];     /* 2 words ripped out of the guts of the */
 343 } StgRBHSave;                  /*  closure holding the blocking queue */
 344
 345 typedef struct StgRBH_ {
 346   StgHeader                         header;
 347   struct StgBlockingQueueElement_  *blocking_queue; /* start of the BQ */
 348   StgMutClosure                    *mut_link;       /* next elem in mutable list */
 349 } StgRBH;
 350
 351 #else
 352
 353 typedef struct StgBlockingQueue_ {
 354   StgHeader          header;
 355   struct StgTSO_    *blocking_queue;
 356   StgMutClosure     *mut_link;
 357 } StgBlockingQueue;
 358
 359 #endif
 360
 361 #if defined(PAR)
 362 /* global indirections aka FETCH_ME closures */
 363 typedef struct StgFetchMe_ {
 364   StgHeader              header;
 365   globalAddr            *ga;        /* ptr to unique id for a closure */
 366   StgMutClosure         *mut_link;  /* next elem in mutable list */
 367 } StgFetchMe;
 368
 369 /* same contents as an ordinary StgBlockingQueue */
 370 typedef struct StgFetchMeBlockingQueue_ {
 371   StgHeader                          header;
 372   struct StgBlockingQueueElement_   *blocking_queue; /* start of the BQ */
 373   StgMutClosure                     *mut_link;       /* next elem in mutable list */
 374 } StgFetchMeBlockingQueue;
 375
 376 /* This is an entry in a blocking queue. It indicates a fetch request from a
 377    TSO on another PE demanding the value of this closur. Note that a
 378    StgBlockedFetch can only occur in a BQ. Once the node is evaluated and
 379    updated with the result, the result will be sent back (the PE is encoded
 380    in the globalAddr) and the StgBlockedFetch closure will be nuked.
 381 */
 382 typedef struct StgBlockedFetch_ {
 383   StgHeader                         header;
 384   struct StgBlockingQueueElement_  *link;     /* next elem in the BQ */
 385   StgMutClosure                    *mut_link; /* next elem in mutable list */
 386   StgClosure                       *node;     /* node to fetch */
 387   globalAddr                        ga;       /* where to send the result to */
 388 } StgBlockedFetch;                            /* NB: not just a ptr to a GA */
 389 #endif
 390
 391 #endif /* CLOSURES_H */