ghc/includes/GhcConstants.lh

   1 %************************************************************************
   2 %*                                                                      *
   3 \section[GhcConstants]{Constants known by C code {\em and} by the compiler (hsc)}
   4 %*                                                                      *
   5 %************************************************************************
   6
   7 Multi-slurp protection (start):
   8 \begin{code}
   9 #ifndef GHCCONSTANTS_H
  10 #define GHCCONSTANTS_H
  11
  12 #ifndef PLATFORM_H
  13 #include "platform.h"
  14 #endif
  15 \end{code}
  16
  17 % BECAUSE THIS FILE IS INCLUDED INTO HASKELL FILES, THERE MUST BE NO C
  18 % COMMENTS IN THE ``CODE'' BITS.
  19
  20 This file defines constants that are common to diverse parts of the
  21 Glasgow Haskell compilation system.  For example, both the compiler
  22 proper and some magic runtime-system bits need to know the minimum
  23 size of an updatable closure.
  24
  25 %************************************************************************
  26 %*                                                                      *
  27 \subsection[updatable-closure-size]{Size of Updatable Closures}
  28 %*                                                                      *
  29 %************************************************************************
  30
  31 We define the minimum size for updatable closures. This must be at
  32 least 2, to allow for cons cells and linked indirections. All updates
  33 will be performed on closures of this size. For non-updatable closures
  34 the minimum size is 1 to allow for a forwarding pointer.
  35
  36 \begin{code}
  37 #define MIN_UPD_SIZE    2
  38 #define MIN_NONUPD_SIZE 1
  39 \end{code}
  40
  41 ToDo: @MIN_STATIC_NONUPD_SIZE@ ???
  42
  43 %************************************************************************
  44 %*                                                                      *
  45 \subsection[double-etc-size]{Sizes of various types}
  46 %*                                                                      *
  47 %************************************************************************
  48
  49 The size of an StgDouble, in StgWords.
  50
  51 \begin{code}
  52 #if alpha_TARGET_ARCH
  53 #define DOUBLE_SIZE     1
  54 #else
  55 #define DOUBLE_SIZE     2
  56 #endif
  57 \end{code}
  58
  59 Sizes of gmp objects, in StgWords
  60
  61 \begin{code}
  62 #define MP_STRUCT_SIZE  3
  63 #define MIN_MP_INT_SIZE 16
  64 \end{code}
  65
  66 %************************************************************************
  67 %*                                                                      *
  68 \subsection[spec-closure-constraints]{What can be declared as a @SPEC@ closure}
  69 %*                                                                      *
  70 %************************************************************************
  71
  72 The following define what closure layouts can be declared as @SPEC@
  73 closures.
  74
  75 \begin{code}
  76 #define MAX_SPEC_ALL_PTRS 12
  77 #define MAX_SPEC_ALL_NONPTRS 5
  78 #define MAX_SPEC_OTHER_SIZE 3
  79 \end{code}
  80
  81 The highest-numbered selectee field that we can do magic on (i.e.,
  82 do the selection at GC time):
  83 \begin{code}
  84 #define MAX_SPEC_SELECTEE_SIZE 12
  85 \end{code}
  86
  87 %************************************************************************
  88 %*                                                                      *
  89 \subsection[stg-reg-counts]{How many STG registers are there}
  90 %*                                                                      *
  91 %************************************************************************
  92
  93 \begin{code}
  94 #define MAX_VANILLA_REG 8
  95 #define MAX_FLOAT_REG 4
  96 #define MAX_DOUBLE_REG 2
  97 \end{code}
  98
  99 %************************************************************************
 100 %*                                                                      *
 101 \subsection[vectored-return]{What number of data type cases can use vectored returns}
 102 %*                                                                      *
 103 %************************************************************************
 104
 105 @MAX_VECTORED_RTN@ defines the largest number of constructors that a
 106 data type can have and still use a vectored return.
 107 \begin{code}
 108 #define MAX_VECTORED_RTN 8
 109 \end{code}
 110
 111 %************************************************************************
 112 %*                                                                      *
 113 \subsection[intlike-range]{Range of int-like closures}
 114 %*                                                                      *
 115 %************************************************************************
 116
 117 Range of built-in table of static small int-like closures.
 118
 119 \begin{code}
 120 #define MAX_INTLIKE             (16)
 121 #define MIN_INTLIKE             (-16)
 122 \end{code}
 123
 124 %************************************************************************
 125 %*                                                                      *
 126 \subsection[string-size]{Maximum size of cost centre and description strings}
 127 %*                                                                      *
 128 %************************************************************************
 129
 130 This is the maximum identifier length that can be used for a cost
 131 centre or description string. It includes the terminating null
 132 character.
 133
 134 WDP 95/07: I think this STRING_SIZE thing is completely redundant.
 135
 136 The printf formats are here, so we are less likely to make overly-long
 137 filenames (with disastrous results).  No more than 128 chars, please!
 138
 139 \begin{code}
 140 #define STRING_SIZE 128
 141
 142 #define STATS_FILENAME_MAXLEN   128
 143
 144 #define TICKY_FILENAME_FMT      "%0.121s.ticky"
 145 #define STAT_FILENAME_FMT       "%0.122s.stat"
 146 #define PROF_FILENAME_FMT       "%0.122s.prof"
 147 #define PROF_FILENAME_FMT_GUM   "%0.118s.%03d.prof"
 148 #define TIME_FILENAME_FMT       "%0.122s.time"
 149 #define TIME_FILENAME_FMT_GUM   "%0.118s.%03d.time"
 150 #define HP_FILENAME_FMT         "%0.124s.hp"
 151 \end{code}
 152
 153 %************************************************************************
 154 %*                                                                      *
 155 \subsection[update-frame-size]{Update frame size}
 156 %*                                                                      *
 157 %************************************************************************
 158
 159 The update frames are described in \tr{SMupdate.lh}. All the compiler
 160 needs to ``know'' is the size of the different frames.
 161
 162 First we define update frame sizes for the compiler. These may vary at
 163 runtime depending what type of code is being generated so we also
 164 define the parts which can be put together.
 165
 166 ****************************************************************
 167 *** NB: These update-frame sizes INCLUDE the return address. ***
 168 ****************************************************************
 169
 170
 171 The update frame sizes when cost centres are not being used are:
 172 \begin{code}
 173 #define NOSCC_STD_UF_SIZE       4
 174 #define NOSCC_CON_UF_SIZE       2
 175 \end{code}
 176
 177 If cost-centres are being used we have to add to the above sizes:
 178 \begin{code}
 179 #define SCC_STD_UF_SIZE         5
 180 #define SCC_CON_UF_SIZE         3
 181 \end{code}
 182
 183 If we are compiling C code the use of cost centres is determined at
 184 compile time so we use conditional macro definitions.
 185 \begin{code}
 186 #if defined(USE_COST_CENTRES)
 187 #define STD_UF_SIZE     SCC_STD_UF_SIZE
 188 #define CON_UF_SIZE     SCC_CON_UF_SIZE
 189 #else
 190 #define STD_UF_SIZE     NOSCC_STD_UF_SIZE
 191 #define CON_UF_SIZE     NOSCC_CON_UF_SIZE
 192 #endif
 193 \end{code}
 194
 195 Sorry. but we can't comment these if's and else's !
 196
 197 Offsets relative to a pointer to the top word (return address) of frame...
 198
 199 Notes: (1)~GC looks at the @UF_RET@ word to determine frame type.  (2)
 200 GC requires that @UF_SUB@ be the same offset in all frames, no matter
 201 what.
 202
 203 \begin{code}
 204 #define UF_RET          0
 205 #define UF_SUB          1
 206 #define UF_SUA          2
 207 #define UF_UPDATEE      3
 208 #define UF_COST_CENTRE  4
 209 \end{code}
 210
 211 %************************************************************************
 212 %*                                                                      *
 213 \subsection[semi-tagging-constants]{Constants for semi-tagging}
 214 %*                                                                      *
 215 %************************************************************************
 216
 217 Tags for indirection nodes and ``other'' (probably unevaluated) nodes;
 218 normal-form values of algebraic data types will have tags 0, 1, ...
 219
 220 \begin{code}
 221 #define INFO_OTHER_TAG          (-1)
 222 #define INFO_IND_TAG            (-1)
 223 #define INFO_FIRST_TAG          0
 224 \end{code}
 225
 226 %************************************************************************
 227 %*                                                                      *
 228 \subsection[liveness-masks]{Liveness masks for calling GC}
 229 %*                                                                      *
 230 %************************************************************************
 231
 232 We often have to tell the RTS (usually: garbage-collector) what STG
 233 registers have ``followable'' pointers in them.  We used to just say
 234 {\em how many} there were; but this doesn't work in a semi-tagged
 235 world---part of the point of semi-tagging is to avoid loading up
 236 registers needlessly; but if you don't load a register and then you
 237 tell the GC that it has followable contents....
 238
 239 So we use a {\em liveness mask} (one word) instead.  This is probably
 240 neater anyway.  The layout is:
 241 \begin{verbatim}
 242 --------------------------
 243 ... | Rn | ... | R2 | R1 |
 244 --------------------------
 245 \end{verbatim}
 246
 247 The \tr{LIVENESS_<reg>} macros are used both in Haskell and C.  The
 248 \tr{IS_LIVE_<reg>} macros (``is this register live according to this
 249 mask?'') are used only in C [obviously].
 250 \begin{code}
 251 #define NO_LIVENESS             0
 252 #define LIVENESS_R1             1
 253 #define LIVENESS_R2             2
 254 #define LIVENESS_R3             4
 255 #define LIVENESS_R4             8
 256 #define LIVENESS_R5             16
 257 #define LIVENESS_R6             32
 258 #define LIVENESS_R7             64
 259 #define LIVENESS_R8             128
 260
 261 #define IS_LIVE_R1(mask)        (((mask) & LIVENESS_R1) != 0)
 262 #define IS_LIVE_R2(mask)        (((mask) & LIVENESS_R2) != 0)
 263 #define IS_LIVE_R3(mask)        (((mask) & LIVENESS_R3) != 0)
 264 #define IS_LIVE_R4(mask)        (((mask) & LIVENESS_R4) != 0)
 265 #define IS_LIVE_R5(mask)        (((mask) & LIVENESS_R5) != 0)
 266 #define IS_LIVE_R6(mask)        (((mask) & LIVENESS_R6) != 0)
 267 #define IS_LIVE_R7(mask)        (((mask) & LIVENESS_R7) != 0)
 268 #define IS_LIVE_R8(mask)        (((mask) & LIVENESS_R8) != 0)
 269 \end{code}
 270
 271 Some extra stuff will probably be needed for ``shift bits off the end
 272 and stop when zero,'' which would be quicker.  Later.
 273
 274 Multi-slurp protection (end-of-file):
 275 \begin{code}
 276 #endif
 277 \end{code}