Enable pthread_getspecific() tls for LLVM compiler
[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://hackage.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. Howevver, 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 This needs to be up near the top as the register line on alpha needs
222 to be before all procedures (inline & out-of-line).
223 -------------------------------------------------------------------------- */
224
225 #include "stg/TailCalls.h"
226
227 /* -----------------------------------------------------------------------------
228 Other Stg stuff...
229 -------------------------------------------------------------------------- */
230
231 #include "stg/ArchSpecific.h" /* required by MachRegs.h and SMP.h */
232
233 #include "stg/DLL.h"
234 #include "stg/MachRegs.h"
235 #include "stg/Regs.h"
236 #include "stg/Ticky.h"
237
238 #if IN_STG_CODE
239 /*
240 * This is included later for RTS sources, after definitions of
241 * StgInfoTable, StgClosure and so on.
242 */
243 #include "stg/MiscClosures.h"
244 #endif
245
246 #include "stg/SMP.h" // write_barrier() inline is required
247
248 /* -----------------------------------------------------------------------------
249 Moving Floats and Doubles
250
251 ASSIGN_FLT is for assigning a float to memory (usually the
252 stack/heap). The memory address is guaranteed to be
253 StgWord aligned (currently == sizeof(void *)).
254
255 PK_FLT is for pulling a float out of memory. The memory is
256 guaranteed to be StgWord aligned.
257 -------------------------------------------------------------------------- */
258
259 INLINE_HEADER void ASSIGN_FLT (W_ [], StgFloat);
260 INLINE_HEADER StgFloat PK_FLT (W_ []);
261
262 #if ALIGNMENT_FLOAT <= ALIGNMENT_LONG
263
264 INLINE_HEADER void ASSIGN_FLT(W_ p_dest[], StgFloat src) { *(StgFloat *)p_dest = src; }
265 INLINE_HEADER StgFloat PK_FLT (W_ p_src[]) { return *(StgFloat *)p_src; }
266
267 #else /* ALIGNMENT_FLOAT > ALIGNMENT_UNSIGNED_INT */
268
269 INLINE_HEADER void ASSIGN_FLT(W_ p_dest[], StgFloat src)
270 {
271 float_thing y;
272 y.f = src;
273 *p_dest = y.fu;
274 }
275
276 INLINE_HEADER StgFloat PK_FLT(W_ p_src[])
277 {
278 float_thing y;
279 y.fu = *p_src;
280 return(y.f);
281 }
282
283 #endif /* ALIGNMENT_FLOAT > ALIGNMENT_LONG */
284
285 #if ALIGNMENT_DOUBLE <= ALIGNMENT_LONG
286
287 INLINE_HEADER void ASSIGN_DBL (W_ [], StgDouble);
288 INLINE_HEADER StgDouble PK_DBL (W_ []);
289
290 INLINE_HEADER void ASSIGN_DBL(W_ p_dest[], StgDouble src) { *(StgDouble *)p_dest = src; }
291 INLINE_HEADER StgDouble PK_DBL (W_ p_src[]) { return *(StgDouble *)p_src; }
292
293 #else /* ALIGNMENT_DOUBLE > ALIGNMENT_LONG */
294
295 /* Sparc uses two floating point registers to hold a double. We can
296 * write ASSIGN_DBL and PK_DBL by directly accessing the registers
297 * independently - unfortunately this code isn't writable in C, we
298 * have to use inline assembler.
299 */
300 #if sparc_HOST_ARCH
301
302 #define ASSIGN_DBL(dst0,src) \
303 { StgPtr dst = (StgPtr)(dst0); \
304 __asm__("st %2,%0\n\tst %R2,%1" : "=m" (((P_)(dst))[0]), \
305 "=m" (((P_)(dst))[1]) : "f" (src)); \
306 }
307
308 #define PK_DBL(src0) \
309 ( { StgPtr src = (StgPtr)(src0); \
310 register double d; \
311 __asm__("ld %1,%0\n\tld %2,%R0" : "=f" (d) : \
312 "m" (((P_)(src))[0]), "m" (((P_)(src))[1])); d; \
313 } )
314
315 #else /* ! sparc_HOST_ARCH */
316
317 INLINE_HEADER void ASSIGN_DBL (W_ [], StgDouble);
318 INLINE_HEADER StgDouble PK_DBL (W_ []);
319
320 typedef struct
321 { StgWord dhi;
322 StgWord dlo;
323 } unpacked_double;
324
325 typedef union
326 { StgDouble d;
327 unpacked_double du;
328 } double_thing;
329
330 INLINE_HEADER void ASSIGN_DBL(W_ p_dest[], StgDouble src)
331 {
332 double_thing y;
333 y.d = src;
334 p_dest[0] = y.du.dhi;
335 p_dest[1] = y.du.dlo;
336 }
337
338 /* GCC also works with this version, but it generates
339 the same code as the previous one, and is not ANSI
340
341 #define ASSIGN_DBL( p_dest, src ) \
342 *p_dest = ((double_thing) src).du.dhi; \
343 *(p_dest+1) = ((double_thing) src).du.dlo \
344 */
345
346 INLINE_HEADER StgDouble PK_DBL(W_ p_src[])
347 {
348 double_thing y;
349 y.du.dhi = p_src[0];
350 y.du.dlo = p_src[1];
351 return(y.d);
352 }
353
354 #endif /* ! sparc_HOST_ARCH */
355
356 #endif /* ALIGNMENT_DOUBLE > ALIGNMENT_UNSIGNED_INT */
357
358
359 /* -----------------------------------------------------------------------------
360 Moving 64-bit quantities around
361
362 ASSIGN_Word64 assign an StgWord64/StgInt64 to a memory location
363 PK_Word64 load an StgWord64/StgInt64 from a amemory location
364
365 In both cases the memory location might not be 64-bit aligned.
366 -------------------------------------------------------------------------- */
367
368 #if SIZEOF_HSWORD == 4
369
370 typedef struct
371 { StgWord dhi;
372 StgWord dlo;
373 } unpacked_double_word;
374
375 typedef union
376 { StgInt64 i;
377 unpacked_double_word iu;
378 } int64_thing;
379
380 typedef union
381 { StgWord64 w;
382 unpacked_double_word wu;
383 } word64_thing;
384
385 INLINE_HEADER void ASSIGN_Word64(W_ p_dest[], StgWord64 src)
386 {
387 word64_thing y;
388 y.w = src;
389 p_dest[0] = y.wu.dhi;
390 p_dest[1] = y.wu.dlo;
391 }
392
393 INLINE_HEADER StgWord64 PK_Word64(W_ p_src[])
394 {
395 word64_thing y;
396 y.wu.dhi = p_src[0];
397 y.wu.dlo = p_src[1];
398 return(y.w);
399 }
400
401 INLINE_HEADER void ASSIGN_Int64(W_ p_dest[], StgInt64 src)
402 {
403 int64_thing y;
404 y.i = src;
405 p_dest[0] = y.iu.dhi;
406 p_dest[1] = y.iu.dlo;
407 }
408
409 INLINE_HEADER StgInt64 PK_Int64(W_ p_src[])
410 {
411 int64_thing y;
412 y.iu.dhi = p_src[0];
413 y.iu.dlo = p_src[1];
414 return(y.i);
415 }
416
417 #elif SIZEOF_VOID_P == 8
418
419 INLINE_HEADER void ASSIGN_Word64(W_ p_dest[], StgWord64 src)
420 {
421 p_dest[0] = src;
422 }
423
424 INLINE_HEADER StgWord64 PK_Word64(W_ p_src[])
425 {
426 return p_src[0];
427 }
428
429 INLINE_HEADER void ASSIGN_Int64(W_ p_dest[], StgInt64 src)
430 {
431 p_dest[0] = src;
432 }
433
434 INLINE_HEADER StgInt64 PK_Int64(W_ p_src[])
435 {
436 return p_src[0];
437 }
438
439 #endif /* SIZEOF_HSWORD == 4 */
440
441 /* -----------------------------------------------------------------------------
442 Split markers
443 -------------------------------------------------------------------------- */
444
445 #if defined(USE_SPLIT_MARKERS)
446 #if defined(LEADING_UNDERSCORE)
447 #define __STG_SPLIT_MARKER __asm__("\n___stg_split_marker:");
448 #else
449 #define __STG_SPLIT_MARKER __asm__("\n__stg_split_marker:");
450 #endif
451 #else
452 #define __STG_SPLIT_MARKER /* nothing */
453 #endif
454
455 /* -----------------------------------------------------------------------------
456 Write-combining store
457 -------------------------------------------------------------------------- */
458
459 INLINE_HEADER void
460 wcStore (StgPtr p, StgWord w)
461 {
462 #ifdef x86_64_HOST_ARCH
463 __asm__(
464 "movnti\t%1, %0"
465 : "=m" (*p)
466 : "r" (w)
467 );
468 #else
469 *p = w;
470 #endif
471 }
472
473 /* -----------------------------------------------------------------------------
474 Integer multiply with overflow
475 -------------------------------------------------------------------------- */
476
477 /* Multiply with overflow checking.
478 *
479 * This is tricky - the usual sign rules for add/subtract don't apply.
480 *
481 * On 32-bit machines we use gcc's 'long long' types, finding
482 * overflow with some careful bit-twiddling.
483 *
484 * On 64-bit machines where gcc's 'long long' type is also 64-bits,
485 * we use a crude approximation, testing whether either operand is
486 * larger than 32-bits; if neither is, then we go ahead with the
487 * multiplication.
488 *
489 * Return non-zero if there is any possibility that the signed multiply
490 * of a and b might overflow. Return zero only if you are absolutely sure
491 * that it won't overflow. If in doubt, return non-zero.
492 */
493
494 #if SIZEOF_VOID_P == 4
495
496 #ifdef WORDS_BIGENDIAN
497 #define RTS_CARRY_IDX__ 0
498 #define RTS_REM_IDX__ 1
499 #else
500 #define RTS_CARRY_IDX__ 1
501 #define RTS_REM_IDX__ 0
502 #endif
503
504 typedef union {
505 StgInt64 l;
506 StgInt32 i[2];
507 } long_long_u ;
508
509 #define mulIntMayOflo(a,b) \
510 ({ \
511 StgInt32 r, c; \
512 long_long_u z; \
513 z.l = (StgInt64)a * (StgInt64)b; \
514 r = z.i[RTS_REM_IDX__]; \
515 c = z.i[RTS_CARRY_IDX__]; \
516 if (c == 0 || c == -1) { \
517 c = ((StgWord)((a^b) ^ r)) \
518 >> (BITS_IN (I_) - 1); \
519 } \
520 c; \
521 })
522
523 /* Careful: the carry calculation above is extremely delicate. Make sure
524 * you test it thoroughly after changing it.
525 */
526
527 #else
528
529 /* Approximate version when we don't have long arithmetic (on 64-bit archs) */
530
531 /* If we have n-bit words then we have n-1 bits after accounting for the
532 * sign bit, so we can fit the result of multiplying 2 (n-1)/2-bit numbers */
533 #define HALF_POS_INT (((I_)1) << ((BITS_IN (I_) - 1) / 2))
534 #define HALF_NEG_INT (-HALF_POS_INT)
535
536 #define mulIntMayOflo(a,b) \
537 ({ \
538 I_ c; \
539 if ((I_)a <= HALF_NEG_INT || a >= HALF_POS_INT \
540 || (I_)b <= HALF_NEG_INT || b >= HALF_POS_INT) {\
541 c = 1; \
542 } else { \
543 c = 0; \
544 } \
545 c; \
546 })
547 #endif
548
549 #endif /* STG_H */