move the "meat" into the wiki, this file just contains pointers now
[ghc.git] / includes / Constants.h
1 /* ----------------------------------------------------------------------------
2 *
3 * (c) The GHC Team, 1998-2002
4 *
5 * Constants
6 *
7 * NOTE: this information is used by both the compiler and the RTS.
8 * Some of it is tweakable, and some of it must be kept up to date
9 * with various other parts of the system.
10 *
11 * Constants which are derived automatically from other definitions in
12 * the system (eg. structure sizes) are generated into the file
13 * DerivedConstants.h by a C program (mkDerivedConstantsHdr).
14 *
15 * -------------------------------------------------------------------------- */
16
17 #ifndef CONSTANTS_H
18 #define CONSTANTS_H
19
20 /* -----------------------------------------------------------------------------
21 Minimum closure sizes
22
23 This is the minimum number of words in the payload of a
24 heap-allocated closure, so that the closure has enough room to be
25 overwritten with a forwarding pointer during garbage collection.
26 -------------------------------------------------------------------------- */
27
28 #define MIN_PAYLOAD_SIZE 1
29
30 /* -----------------------------------------------------------------------------
31 Constants to do with specialised closure types.
32 -------------------------------------------------------------------------- */
33
34 /* We have some pre-compiled selector thunks defined in rts/StgStdThunks.hc.
35 * This constant defines the highest selectee index that we can replace with a
36 * reference to the pre-compiled code.
37 */
38
39 #define MAX_SPEC_SELECTEE_SIZE 15
40
41 /* Vector-apply thunks. These thunks just push their free variables
42 * on the stack and enter the first one. They're a bit like PAPs, but
43 * don't have a dynamic size. We've pre-compiled a few to save
44 * space.
45 */
46
47 #define MAX_SPEC_AP_SIZE 7
48
49 /* Specialised FUN/THUNK/CONSTR closure types */
50
51 #define MAX_SPEC_THUNK_SIZE 2
52 #define MAX_SPEC_FUN_SIZE 2
53 #define MAX_SPEC_CONSTR_SIZE 2
54
55 /* Range of built-in table of static small int-like and char-like closures.
56 *
57 * NB. This corresponds with the number of actual INTLIKE/CHARLIKE
58 * closures defined in rts/StgMiscClosures.cmm.
59 */
60 #define MAX_INTLIKE 16
61 #define MIN_INTLIKE (-16)
62
63 #define MAX_CHARLIKE 255
64 #define MIN_CHARLIKE 0
65
66 /* -----------------------------------------------------------------------------
67 STG Registers.
68
69 Note that in MachRegs.h we define how many of these registers are
70 *real* machine registers, and not just offsets in the Register Table.
71 -------------------------------------------------------------------------- */
72
73 #define MAX_VANILLA_REG 8
74 #define MAX_FLOAT_REG 4
75 #define MAX_DOUBLE_REG 2
76 #define MAX_LONG_REG 1
77
78 /* -----------------------------------------------------------------------------
79 * Maximum number of constructors in a data type for direct-returns.
80 *
81 * NB. There are various places that assume the value of this
82 * constant, such as the polymorphic return frames for updates
83 * (stg_upd_frame_info) and catch frames (stg_catch_frame_info).
84 * -------------------------------------------------------------------------- */
85
86 #define MAX_VECTORED_RTN 8
87
88 /* -----------------------------------------------------------------------------
89 Semi-Tagging constants
90
91 Old Comments about this stuff:
92
93 Tags for indirection nodes and ``other'' (probably unevaluated) nodes;
94 normal-form values of algebraic data types will have tags 0, 1, ...
95
96 @INFO_IND_TAG@ is different from @INFO_OTHER_TAG@ just so we can count
97 how often we bang into indirection nodes; that's all. (WDP 95/11)
98
99 ToDo: find out if we need any of this.
100 -------------------------------------------------------------------------- */
101
102 #define INFO_OTHER_TAG (-1)
103 #define INFO_IND_TAG (-2)
104 #define INFO_FIRST_TAG 0
105
106 /* -----------------------------------------------------------------------------
107 How much C stack to reserve for local temporaries when in the STG
108 world. Used in StgCRun.c.
109 -------------------------------------------------------------------------- */
110
111 #define RESERVED_C_STACK_BYTES (2048 * SIZEOF_LONG)
112
113 /* -----------------------------------------------------------------------------
114 How much Haskell stack space to reserve for the saving of registers
115 etc. in the case of a stack/heap overflow.
116
117 This must be large enough to accomodate the largest stack frame
118 pushed in one of the heap check fragments in HeapStackCheck.hc
119 (ie. currently the generic heap checks - 3 words for StgRetDyn,
120 18 words for the saved registers, see StgMacros.h).
121
122 In the event of an unboxed tuple or let-no-escape stack/heap check
123 failure, there will be other words on the stack which are covered
124 by the RET_DYN frame. These will have been accounted for by stack
125 checks however, so we don't need to allow for them here.
126 -------------------------------------------------------------------------- */
127
128 #define RESERVED_STACK_WORDS 21
129
130 /* -----------------------------------------------------------------------------
131 Storage manager constants
132 -------------------------------------------------------------------------- */
133
134 /* The size of a block (2^BLOCK_SHIFT bytes) */
135 #define BLOCK_SHIFT 12
136
137 /* The size of a megablock (2^MBLOCK_SHIFT bytes) */
138 #define MBLOCK_SHIFT 20
139
140 /* -----------------------------------------------------------------------------
141 Bitmap/size fields (used in info tables)
142 -------------------------------------------------------------------------- */
143
144 /* In a 32-bit bitmap field, we use 5 bits for the size, and 27 bits
145 * for the bitmap. If the bitmap requires more than 27 bits, then we
146 * store it in a separate array, and leave a pointer in the bitmap
147 * field. On a 64-bit machine, the sizes are extended accordingly.
148 */
149 #if SIZEOF_VOID_P == 4
150 #define BITMAP_SIZE_MASK 0x1f
151 #define BITMAP_BITS_SHIFT 5
152 #elif SIZEOF_VOID_P == 8
153 #define BITMAP_SIZE_MASK 0x3f
154 #define BITMAP_BITS_SHIFT 6
155 #else
156 #error unknown SIZEOF_VOID_P
157 #endif
158
159 /* -----------------------------------------------------------------------------
160 Lag/Drag/Void constants
161 -------------------------------------------------------------------------- */
162
163 /*
164 An LDV word is divided into 3 parts: state bits (LDV_STATE_MASK), creation
165 time bits (LDV_CREATE_MASK), and last use time bits (LDV_LAST_MASK).
166 */
167 #if SIZEOF_VOID_P == 8
168 #define LDV_SHIFT 30
169 #define LDV_STATE_MASK 0x1000000000000000
170 #define LDV_CREATE_MASK 0x0FFFFFFFC0000000
171 #define LDV_LAST_MASK 0x000000003FFFFFFF
172 #define LDV_STATE_CREATE 0x0000000000000000
173 #define LDV_STATE_USE 0x1000000000000000
174 #else
175 #define LDV_SHIFT 15
176 #define LDV_STATE_MASK 0x40000000
177 #define LDV_CREATE_MASK 0x3FFF8000
178 #define LDV_LAST_MASK 0x00007FFF
179 #define LDV_STATE_CREATE 0x00000000
180 #define LDV_STATE_USE 0x40000000
181 #endif /* SIZEOF_VOID_P */
182
183 /* -----------------------------------------------------------------------------
184 TSO related constants
185 -------------------------------------------------------------------------- */
186
187 /*
188 * Constants for the what_next field of a TSO, which indicates how it
189 * is to be run.
190 */
191 #define ThreadRunGHC 1 /* return to address on top of stack */
192 #define ThreadInterpret 2 /* interpret this thread */
193 #define ThreadKilled 3 /* thread has died, don't run it */
194 #define ThreadRelocated 4 /* thread has moved, link points to new locn */
195 #define ThreadComplete 5 /* thread has finished */
196
197 /*
198 * Constants for the why_blocked field of a TSO
199 */
200 #define NotBlocked 0
201 #define BlockedOnMVar 1
202 #define BlockedOnBlackHole 2
203 #define BlockedOnException 3
204 #define BlockedOnRead 4
205 #define BlockedOnWrite 5
206 #define BlockedOnDelay 6
207 #define BlockedOnSTM 7
208
209 /* Win32 only: */
210 #define BlockedOnDoProc 8
211
212 /* Only relevant for PAR: */
213 /* blocked on a remote closure represented by a Global Address: */
214 #define BlockedOnGA 9
215 /* same as above but without sending a Fetch message */
216 #define BlockedOnGA_NoSend 10
217 /* Only relevant for THREADED_RTS: */
218 #define BlockedOnCCall 11
219 #define BlockedOnCCall_NoUnblockExc 12
220 /* same as above but don't unblock async exceptions in resumeThread() */
221
222 /*
223 * These constants are returned to the scheduler by a thread that has
224 * stopped for one reason or another. See typedef StgThreadReturnCode
225 * in TSO.h.
226 */
227 #define HeapOverflow 1 /* might also be StackOverflow */
228 #define StackOverflow 2
229 #define ThreadYielding 3
230 #define ThreadBlocked 4
231 #define ThreadFinished 5
232
233 /*
234 * Flags for the tso->flags field.
235 *
236 * The TSO_DIRTY flag indicates that this TSO's stack should be
237 * scanned during garbage collection. The link field of a TSO is
238 * always scanned, so we don't have to dirty a TSO just for linking
239 * it on a different list.
240 *
241 * TSO_DIRTY is set by
242 * - schedule(), just before running a thread,
243 * - raiseAsync(), because it modifies a thread's stack
244 * - resumeThread(), just before running the thread again
245 * and unset by the garbage collector (only).
246 */
247 #define TSO_DIRTY 1
248
249 /*
250 * TSO_LOCKED is set when a TSO is locked to a particular Capability.
251 */
252 #define TSO_LOCKED 2
253
254 /*
255 * TSO_BLOCKEX: the TSO is blocking exceptions
256 *
257 * TSO_INTERRUPTIBLE: the TSO can be interrupted if it blocks
258 * interruptibly (eg. with BlockedOnMVar).
259 */
260 #define TSO_BLOCKEX 4
261 #define TSO_INTERRUPTIBLE 8
262
263 /* -----------------------------------------------------------------------------
264 RET_DYN stack frames
265 -------------------------------------------------------------------------- */
266
267 /* VERY MAGIC CONSTANTS!
268 * must agree with code in HeapStackCheck.c, stg_gen_chk, and
269 * RESERVED_STACK_WORDS in Constants.h.
270 */
271 #define RET_DYN_BITMAP_SIZE 8
272 #define RET_DYN_NONPTR_REGS_SIZE 10
273
274 /* Sanity check that RESERVED_STACK_WORDS is reasonable. We can't
275 * just derive RESERVED_STACK_WORDS because it's used in Haskell code
276 * too.
277 */
278 #if RESERVED_STACK_WORDS != (3 + RET_DYN_BITMAP_SIZE + RET_DYN_NONPTR_REGS_SIZE)
279 #error RESERVED_STACK_WORDS may be wrong!
280 #endif
281
282 /* -----------------------------------------------------------------------------
283 How often our context-switch timer ticks
284 -------------------------------------------------------------------------- */
285
286 #define TICK_FREQUENCY 50 /* ticks per second */
287
288 #endif /* CONSTANTS_H */