Fold integer-simple.git into ghc.git (re #8545)
[ghc.git] / includes / Stg.h
1 /* -----------------------------------------------------------------------------
2 *
3 * (c) The GHC Team, 1998-2009
4 *
5 * Top-level include file for everything required when compiling .hc
6 * code. NOTE: in .hc files, Stg.h must be included *before* any
7 * other headers, because we define some register variables which must
8 * be done before any inline functions are defined (some system
9 * headers have been known to define the odd inline function).
10 *
11 * We generally try to keep as little visible as possible when
12 * compiling .hc files. So for example the definitions of the
13 * InfoTable structs, closure structs and other RTS types are not
14 * visible here. The compiler knows enough about the representations
15 * of these types to generate code which manipulates them directly
16 * with pointer arithmetic.
17 *
18 * In ordinary C code, do not #include this file directly: #include
19 * "Rts.h" instead.
20 *
21 * To understand the structure of the RTS headers, see the wiki:
22 * http://ghc.haskell.org/trac/ghc/wiki/Commentary/SourceTree/Includes
23 *
24 * ---------------------------------------------------------------------------*/
25
26 #ifndef STG_H
27 #define STG_H
28
29 /*
30 * If we are compiling a .hc file, then we want all the register
31 * variables. This is the what happens if you #include "Stg.h" first:
32 * we assume this is a .hc file, and set IN_STG_CODE==1, which later
33 * causes the register variables to be enabled in stg/Regs.h.
34 *
35 * If instead "Rts.h" is included first, then we are compiling a
36 * vanilla C file. Everything from Stg.h is provided, except that
37 * IN_STG_CODE is not defined, and the register variables will not be
38 * active.
39 */
40 #ifndef IN_STG_CODE
41 # define IN_STG_CODE 1
42
43 // Turn on C99 for .hc code. This gives us the INFINITY and NAN
44 // constants from math.h, which we occasionally need to use in .hc (#1861)
45 # define _ISOC99_SOURCE
46
47 // We need _BSD_SOURCE so that math.h defines things like gamma
48 // on Linux
49 # define _BSD_SOURCE
50 #endif
51
52 #if IN_STG_CODE == 0 || defined(llvm_CC_FLAVOR)
53 // C compilers that use an LLVM back end (clang or llvm-gcc) do not
54 // correctly support global register variables so we make sure that
55 // we do not declare them for these compilers.
56 # define NO_GLOBAL_REG_DECLS /* don't define fixed registers */
57 #endif
58
59 /* Configuration */
60 #include "ghcconfig.h"
61
62 /* The code generator calls the math functions directly in .hc code.
63 NB. after configuration stuff above, because this sets #defines
64 that depend on config info, such as __USE_FILE_OFFSET64 */
65 #include <math.h>
66
67 // On Solaris, we don't get the INFINITY and NAN constants unless we
68 // #define _STDC_C99, and we can't do that unless we also use -std=c99,
69 // because _STDC_C99 causes the headers to use C99 syntax (e.g. restrict).
70 // We aren't ready for -std=c99 yet, so define INFINITY/NAN by hand using
71 // the gcc builtins.
72 #if !defined(INFINITY)
73 #if defined(__GNUC__)
74 #define INFINITY __builtin_inf()
75 #else
76 #error No definition for INFINITY
77 #endif
78 #endif
79
80 #if !defined(NAN)
81 #if defined(__GNUC__)
82 #define NAN __builtin_nan("")
83 #else
84 #error No definition for NAN
85 #endif
86 #endif
87
88 /* -----------------------------------------------------------------------------
89 Useful definitions
90 -------------------------------------------------------------------------- */
91
92 /*
93 * The C backend likes to refer to labels by just mentioning their
94 * names. However, when a symbol is declared as a variable in C, the
95 * C compiler will implicitly dereference it when it occurs in source.
96 * So we must subvert this behaviour for .hc files by declaring
97 * variables as arrays, which eliminates the implicit dereference.
98 */
99 #if IN_STG_CODE
100 #define RTS_VAR(x) (x)[]
101 #define RTS_DEREF(x) (*(x))
102 #else
103 #define RTS_VAR(x) x
104 #define RTS_DEREF(x) x
105 #endif
106
107 /* bit macros
108 */
109 #define BITS_PER_BYTE 8
110 #define BITS_IN(x) (BITS_PER_BYTE * sizeof(x))
111
112 /* Compute offsets of struct fields
113 */
114 #define STG_FIELD_OFFSET(s_type, field) ((StgWord)&(((s_type*)0)->field))
115
116 /*
117 * 'Portable' inlining:
118 * INLINE_HEADER is for inline functions in header files (macros)
119 * STATIC_INLINE is for inline functions in source files
120 * EXTERN_INLINE is for functions that we want to inline sometimes
121 * (we also compile a static version of the function; see Inlines.c)
122 */
123 #if defined(__GNUC__) || defined( __INTEL_COMPILER)
124
125 # define INLINE_HEADER static inline
126 # define INLINE_ME inline
127 # define STATIC_INLINE INLINE_HEADER
128
129 // The special "extern inline" behaviour is now only supported by gcc
130 // when _GNUC_GNU_INLINE__ is defined, and you have to use
131 // __attribute__((gnu_inline)). So when we don't have this, we use
132 // ordinary static inline.
133 //
134 // Apple's gcc defines __GNUC_GNU_INLINE__ without providing
135 // gnu_inline, so we exclude MacOS X and fall through to the safe
136 // version.
137 //
138 #if defined(__GNUC_GNU_INLINE__) && !defined(__APPLE__)
139 # if defined(KEEP_INLINES)
140 # define EXTERN_INLINE inline
141 # else
142 # define EXTERN_INLINE extern inline __attribute__((gnu_inline))
143 # endif
144 #else
145 # if defined(KEEP_INLINES)
146 # define EXTERN_INLINE
147 # else
148 # define EXTERN_INLINE INLINE_HEADER
149 # endif
150 #endif
151
152 #elif defined(_MSC_VER)
153
154 # define INLINE_HEADER __inline static
155 # define INLINE_ME __inline
156 # define STATIC_INLINE INLINE_HEADER
157
158 # if defined(KEEP_INLINES)
159 # define EXTERN_INLINE __inline
160 # else
161 # define EXTERN_INLINE __inline extern
162 # endif
163
164 #else
165
166 # error "Don't know how to inline functions with your C compiler."
167
168 #endif
169
170
171 /*
172 * GCC attributes
173 */
174 #if defined(__GNUC__)
175 #define GNU_ATTRIBUTE(at) __attribute__((at))
176 #else
177 #define GNU_ATTRIBUTE(at)
178 #endif
179
180 #if __GNUC__ >= 3
181 #define GNUC3_ATTRIBUTE(at) __attribute__((at))
182 #else
183 #define GNUC3_ATTRIBUTE(at)
184 #endif
185
186 #if __GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 3
187 #define GNUC_ATTR_HOT __attribute__((hot))
188 #else
189 #define GNUC_ATTR_HOT /* nothing */
190 #endif
191
192 #define STG_UNUSED GNUC3_ATTRIBUTE(__unused__)
193
194 /* -----------------------------------------------------------------------------
195 Global type definitions
196 -------------------------------------------------------------------------- */
197
198 #include "MachDeps.h"
199 #include "stg/Types.h"
200
201 /* -----------------------------------------------------------------------------
202 Shorthand forms
203 -------------------------------------------------------------------------- */
204
205 typedef StgChar C_;
206 typedef StgWord W_;
207 typedef StgWord* P_;
208 typedef StgInt I_;
209 typedef StgWord StgWordArray[];
210 typedef StgFunPtr F_;
211
212 #define EI_(X) extern StgWordArray (X) GNU_ATTRIBUTE(aligned (8))
213 #define II_(X) static StgWordArray (X) GNU_ATTRIBUTE(aligned (8))
214 #define IF_(f) static StgFunPtr GNUC3_ATTRIBUTE(used) f(void)
215 #define FN_(f) StgFunPtr f(void)
216 #define EF_(f) extern StgFunPtr f(void)
217
218 /* -----------------------------------------------------------------------------
219 Tail calls
220 -------------------------------------------------------------------------- */
221
222 #define JMP_(cont) return((StgFunPtr)(cont))
223 #define FB_
224 #define FE_
225
226 /* -----------------------------------------------------------------------------
227 Other Stg stuff...
228 -------------------------------------------------------------------------- */
229
230 #include "stg/DLL.h"
231 #include "stg/RtsMachRegs.h"
232 #include "stg/Regs.h"
233 #include "stg/Ticky.h"
234
235 #if IN_STG_CODE
236 /*
237 * This is included later for RTS sources, after definitions of
238 * StgInfoTable, StgClosure and so on.
239 */
240 #include "stg/MiscClosures.h"
241 #endif
242
243 #include "stg/Prim.h" /* ghc-prim fallbacks */
244 #include "stg/SMP.h" // write_barrier() inline is required
245
246 /* -----------------------------------------------------------------------------
247 Moving Floats and Doubles
248
249 ASSIGN_FLT is for assigning a float to memory (usually the
250 stack/heap). The memory address is guaranteed to be
251 StgWord aligned (currently == sizeof(void *)).
252
253 PK_FLT is for pulling a float out of memory. The memory is
254 guaranteed to be StgWord aligned.
255 -------------------------------------------------------------------------- */
256
257 INLINE_HEADER void ASSIGN_FLT (W_ [], StgFloat);
258 INLINE_HEADER StgFloat PK_FLT (W_ []);
259
260 #if ALIGNMENT_FLOAT <= ALIGNMENT_VOID_P
261
262 INLINE_HEADER void ASSIGN_FLT(W_ p_dest[], StgFloat src) { *(StgFloat *)p_dest = src; }
263 INLINE_HEADER StgFloat PK_FLT (W_ p_src[]) { return *(StgFloat *)p_src; }
264
265 #else /* ALIGNMENT_FLOAT > ALIGNMENT_UNSIGNED_INT */
266
267 INLINE_HEADER void ASSIGN_FLT(W_ p_dest[], StgFloat src)
268 {
269 float_thing y;
270 y.f = src;
271 *p_dest = y.fu;
272 }
273
274 INLINE_HEADER StgFloat PK_FLT(W_ p_src[])
275 {
276 float_thing y;
277 y.fu = *p_src;
278 return(y.f);
279 }
280
281 #endif /* ALIGNMENT_FLOAT > ALIGNMENT_VOID_P */
282
283 #if ALIGNMENT_DOUBLE <= ALIGNMENT_VOID_P
284
285 INLINE_HEADER void ASSIGN_DBL (W_ [], StgDouble);
286 INLINE_HEADER StgDouble PK_DBL (W_ []);
287
288 INLINE_HEADER void ASSIGN_DBL(W_ p_dest[], StgDouble src) { *(StgDouble *)p_dest = src; }
289 INLINE_HEADER StgDouble PK_DBL (W_ p_src[]) { return *(StgDouble *)p_src; }
290
291 #else /* ALIGNMENT_DOUBLE > ALIGNMENT_VOID_P */
292
293 /* Sparc uses two floating point registers to hold a double. We can
294 * write ASSIGN_DBL and PK_DBL by directly accessing the registers
295 * independently - unfortunately this code isn't writable in C, we
296 * have to use inline assembler.
297 */
298 #if sparc_HOST_ARCH
299
300 #define ASSIGN_DBL(dst0,src) \
301 { StgPtr dst = (StgPtr)(dst0); \
302 __asm__("st %2,%0\n\tst %R2,%1" : "=m" (((P_)(dst))[0]), \
303 "=m" (((P_)(dst))[1]) : "f" (src)); \
304 }
305
306 #define PK_DBL(src0) \
307 ( { StgPtr src = (StgPtr)(src0); \
308 register double d; \
309 __asm__("ld %1,%0\n\tld %2,%R0" : "=f" (d) : \
310 "m" (((P_)(src))[0]), "m" (((P_)(src))[1])); d; \
311 } )
312
313 #else /* ! sparc_HOST_ARCH */
314
315 INLINE_HEADER void ASSIGN_DBL (W_ [], StgDouble);
316 INLINE_HEADER StgDouble PK_DBL (W_ []);
317
318 typedef struct
319 { StgWord dhi;
320 StgWord dlo;
321 } unpacked_double;
322
323 typedef union
324 { StgDouble d;
325 unpacked_double du;
326 } double_thing;
327
328 INLINE_HEADER void ASSIGN_DBL(W_ p_dest[], StgDouble src)
329 {
330 double_thing y;
331 y.d = src;
332 p_dest[0] = y.du.dhi;
333 p_dest[1] = y.du.dlo;
334 }
335
336 /* GCC also works with this version, but it generates
337 the same code as the previous one, and is not ANSI
338
339 #define ASSIGN_DBL( p_dest, src ) \
340 *p_dest = ((double_thing) src).du.dhi; \
341 *(p_dest+1) = ((double_thing) src).du.dlo \
342 */
343
344 INLINE_HEADER StgDouble PK_DBL(W_ p_src[])
345 {
346 double_thing y;
347 y.du.dhi = p_src[0];
348 y.du.dlo = p_src[1];
349 return(y.d);
350 }
351
352 #endif /* ! sparc_HOST_ARCH */
353
354 #endif /* ALIGNMENT_DOUBLE > ALIGNMENT_UNSIGNED_INT */
355
356
357 /* -----------------------------------------------------------------------------
358 Moving 64-bit quantities around
359
360 ASSIGN_Word64 assign an StgWord64/StgInt64 to a memory location
361 PK_Word64 load an StgWord64/StgInt64 from a amemory location
362
363 In both cases the memory location might not be 64-bit aligned.
364 -------------------------------------------------------------------------- */
365
366 #if SIZEOF_HSWORD == 4
367
368 typedef struct
369 { StgWord dhi;
370 StgWord dlo;
371 } unpacked_double_word;
372
373 typedef union
374 { StgInt64 i;
375 unpacked_double_word iu;
376 } int64_thing;
377
378 typedef union
379 { StgWord64 w;
380 unpacked_double_word wu;
381 } word64_thing;
382
383 INLINE_HEADER void ASSIGN_Word64(W_ p_dest[], StgWord64 src)
384 {
385 word64_thing y;
386 y.w = src;
387 p_dest[0] = y.wu.dhi;
388 p_dest[1] = y.wu.dlo;
389 }
390
391 INLINE_HEADER StgWord64 PK_Word64(W_ p_src[])
392 {
393 word64_thing y;
394 y.wu.dhi = p_src[0];
395 y.wu.dlo = p_src[1];
396 return(y.w);
397 }
398
399 INLINE_HEADER void ASSIGN_Int64(W_ p_dest[], StgInt64 src)
400 {
401 int64_thing y;
402 y.i = src;
403 p_dest[0] = y.iu.dhi;
404 p_dest[1] = y.iu.dlo;
405 }
406
407 INLINE_HEADER StgInt64 PK_Int64(W_ p_src[])
408 {
409 int64_thing y;
410 y.iu.dhi = p_src[0];
411 y.iu.dlo = p_src[1];
412 return(y.i);
413 }
414
415 #elif SIZEOF_VOID_P == 8
416
417 INLINE_HEADER void ASSIGN_Word64(W_ p_dest[], StgWord64 src)
418 {
419 p_dest[0] = src;
420 }
421
422 INLINE_HEADER StgWord64 PK_Word64(W_ p_src[])
423 {
424 return p_src[0];
425 }
426
427 INLINE_HEADER void ASSIGN_Int64(W_ p_dest[], StgInt64 src)
428 {
429 p_dest[0] = src;
430 }
431
432 INLINE_HEADER StgInt64 PK_Int64(W_ p_src[])
433 {
434 return p_src[0];
435 }
436
437 #endif /* SIZEOF_HSWORD == 4 */
438
439 /* -----------------------------------------------------------------------------
440 Split markers
441 -------------------------------------------------------------------------- */
442
443 #if defined(USE_SPLIT_MARKERS)
444 #if defined(LEADING_UNDERSCORE)
445 #define __STG_SPLIT_MARKER __asm__("\n___stg_split_marker:");
446 #else
447 #define __STG_SPLIT_MARKER __asm__("\n__stg_split_marker:");
448 #endif
449 #else
450 #define __STG_SPLIT_MARKER /* nothing */
451 #endif
452
453 /* -----------------------------------------------------------------------------
454 Write-combining store
455 -------------------------------------------------------------------------- */
456
457 INLINE_HEADER void
458 wcStore (StgPtr p, StgWord w)
459 {
460 #ifdef x86_64_HOST_ARCH
461 __asm__(
462 "movnti\t%1, %0"
463 : "=m" (*p)
464 : "r" (w)
465 );
466 #else
467 *p = w;
468 #endif
469 }
470
471 /* -----------------------------------------------------------------------------
472 Integer multiply with overflow
473 -------------------------------------------------------------------------- */
474
475 /* Multiply with overflow checking.
476 *
477 * This is tricky - the usual sign rules for add/subtract don't apply.
478 *
479 * On 32-bit machines we use gcc's 'long long' types, finding
480 * overflow with some careful bit-twiddling.
481 *
482 * On 64-bit machines where gcc's 'long long' type is also 64-bits,
483 * we use a crude approximation, testing whether either operand is
484 * larger than 32-bits; if neither is, then we go ahead with the
485 * multiplication.
486 *
487 * Return non-zero if there is any possibility that the signed multiply
488 * of a and b might overflow. Return zero only if you are absolutely sure
489 * that it won't overflow. If in doubt, return non-zero.
490 */
491
492 #if SIZEOF_VOID_P == 4
493
494 #ifdef WORDS_BIGENDIAN
495 #define RTS_CARRY_IDX__ 0
496 #define RTS_REM_IDX__ 1
497 #else
498 #define RTS_CARRY_IDX__ 1
499 #define RTS_REM_IDX__ 0
500 #endif
501
502 typedef union {
503 StgInt64 l;
504 StgInt32 i[2];
505 } long_long_u ;
506
507 #define mulIntMayOflo(a,b) \
508 ({ \
509 StgInt32 r, c; \
510 long_long_u z; \
511 z.l = (StgInt64)a * (StgInt64)b; \
512 r = z.i[RTS_REM_IDX__]; \
513 c = z.i[RTS_CARRY_IDX__]; \
514 if (c == 0 || c == -1) { \
515 c = ((StgWord)((a^b) ^ r)) \
516 >> (BITS_IN (I_) - 1); \
517 } \
518 c; \
519 })
520
521 /* Careful: the carry calculation above is extremely delicate. Make sure
522 * you test it thoroughly after changing it.
523 */
524
525 #else
526
527 /* Approximate version when we don't have long arithmetic (on 64-bit archs) */
528
529 /* If we have n-bit words then we have n-1 bits after accounting for the
530 * sign bit, so we can fit the result of multiplying 2 (n-1)/2-bit numbers */
531 #define HALF_POS_INT (((I_)1) << ((BITS_IN (I_) - 1) / 2))
532 #define HALF_NEG_INT (-HALF_POS_INT)
533
534 #define mulIntMayOflo(a,b) \
535 ({ \
536 I_ c; \
537 if ((I_)a <= HALF_NEG_INT || a >= HALF_POS_INT \
538 || (I_)b <= HALF_NEG_INT || b >= HALF_POS_INT) {\
539 c = 1; \
540 } else { \
541 c = 0; \
542 } \
543 c; \
544 })
545 #endif
546
547 #endif /* STG_H */