RTS: Fix & refactor "portable inline" macros
[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
51 // On AIX we need _BSD defined, otherwise <math.h> includes <stdlib.h>
52 # if defined(_AIX)
53 # define _BSD 1
54 # endif
55
56 // '_BSD_SOURCE' is deprecated since glibc-2.20
57 // in favour of '_DEFAULT_SOURCE'
58 # define _DEFAULT_SOURCE
59 #endif
60
61 #if IN_STG_CODE == 0 || defined(llvm_CC_FLAVOR)
62 // C compilers that use an LLVM back end (clang or llvm-gcc) do not
63 // correctly support global register variables so we make sure that
64 // we do not declare them for these compilers.
65 # define NO_GLOBAL_REG_DECLS /* don't define fixed registers */
66 #endif
67
68 /* Configuration */
69 #include "ghcconfig.h"
70
71 /* The code generator calls the math functions directly in .hc code.
72 NB. after configuration stuff above, because this sets #defines
73 that depend on config info, such as __USE_FILE_OFFSET64 */
74 #include <math.h>
75
76 // On Solaris, we don't get the INFINITY and NAN constants unless we
77 // #define _STDC_C99, and we can't do that unless we also use -std=c99,
78 // because _STDC_C99 causes the headers to use C99 syntax (e.g. restrict).
79 // We aren't ready for -std=c99 yet, so define INFINITY/NAN by hand using
80 // the gcc builtins.
81 #if !defined(INFINITY)
82 #if defined(__GNUC__)
83 #define INFINITY __builtin_inf()
84 #else
85 #error No definition for INFINITY
86 #endif
87 #endif
88
89 #if !defined(NAN)
90 #if defined(__GNUC__)
91 #define NAN __builtin_nan("")
92 #else
93 #error No definition for NAN
94 #endif
95 #endif
96
97 /* -----------------------------------------------------------------------------
98 Useful definitions
99 -------------------------------------------------------------------------- */
100
101 /*
102 * The C backend likes to refer to labels by just mentioning their
103 * names. However, when a symbol is declared as a variable in C, the
104 * C compiler will implicitly dereference it when it occurs in source.
105 * So we must subvert this behaviour for .hc files by declaring
106 * variables as arrays, which eliminates the implicit dereference.
107 */
108 #if IN_STG_CODE
109 #define RTS_VAR(x) (x)[]
110 #define RTS_DEREF(x) (*(x))
111 #else
112 #define RTS_VAR(x) x
113 #define RTS_DEREF(x) x
114 #endif
115
116 /* bit macros
117 */
118 #define BITS_PER_BYTE 8
119 #define BITS_IN(x) (BITS_PER_BYTE * sizeof(x))
120
121 /* Compute offsets of struct fields
122 */
123 #define STG_FIELD_OFFSET(s_type, field) ((StgWord)&(((s_type*)0)->field))
124
125 /*
126 * 'Portable' inlining:
127 * INLINE_HEADER is for inline functions in header files (macros)
128 * STATIC_INLINE is for inline functions in source files
129 * EXTERN_INLINE is for functions that we want to inline sometimes
130 * (we also compile a static version of the function; see Inlines.c)
131 */
132
133 // We generally assume C99 semantics albeit these two definitions work fine even
134 // when gnu90 semantics are active (i.e. when __GNUC_GNU_INLINE__ is defined or
135 // when a GCC older than 4.2 is used)
136 //
137 // The problem, however, is with 'extern inline' whose semantics significantly
138 // differs between gnu90 and C99
139 #define INLINE_HEADER static inline
140 #define INLINE_ME inline
141 #define STATIC_INLINE static inline
142
143 // Figure out whether `__attributes__((gnu_inline))` is needed
144 // to force gnu90-style 'external inline' semantics.
145 #if defined(FORCE_GNU_INLINE)
146 // disable auto-detection since HAVE_GNU_INLINE has been defined externally
147 #elif __GNUC_GNU_INLINE__ && __GNUC__ == 4 && __GNUC_MINOR__ == 2
148 // GCC 4.2.x didn't properly support C99 inline semantics (GCC 4.3 was the first
149 // release to properly support C99 inline semantics), and therefore warned when
150 // using 'extern inline' while in C99 mode unless `__attributes__((gnu_inline))`
151 // was explicitly set.
152 # define FORCE_GNU_INLINE 1
153 #endif
154
155 #if FORCE_GNU_INLINE
156 // Force compiler into gnu90 semantics
157 # if defined(KEEP_INLINES)
158 # define EXTERN_INLINE inline __attribute__((gnu_inline))
159 # else
160 # define EXTERN_INLINE extern inline __attribute__((gnu_inline))
161 # endif
162 #elif __GNUC_GNU_INLINE__
163 // we're currently in gnu90 inline mode by default and
164 // __attribute__((gnu_inline)) may not be supported, so better leave it off
165 # if defined(KEEP_INLINES)
166 # define EXTERN_INLINE inline
167 # else
168 # define EXTERN_INLINE extern inline
169 # endif
170 #else
171 // Assume C99 semantics (yes, this curiously results in swapped definitions!)
172 // This is the preferred branch, and at some point we may drop support for
173 // compilers not supporting C99 semantics altogether.
174 # if defined(KEEP_INLINES)
175 # define EXTERN_INLINE extern inline
176 # else
177 # define EXTERN_INLINE inline
178 # endif
179 #endif
180
181
182 /*
183 * GCC attributes
184 */
185 #if defined(__GNUC__)
186 #define GNU_ATTRIBUTE(at) __attribute__((at))
187 #else
188 #define GNU_ATTRIBUTE(at)
189 #endif
190
191 #if __GNUC__ >= 3
192 #define GNUC3_ATTRIBUTE(at) __attribute__((at))
193 #else
194 #define GNUC3_ATTRIBUTE(at)
195 #endif
196
197 #if __GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 3
198 #define GNUC_ATTR_HOT __attribute__((hot))
199 #else
200 #define GNUC_ATTR_HOT /* nothing */
201 #endif
202
203 #define STG_UNUSED GNUC3_ATTRIBUTE(__unused__)
204
205 /* -----------------------------------------------------------------------------
206 Global type definitions
207 -------------------------------------------------------------------------- */
208
209 #include "MachDeps.h"
210 #include "stg/Types.h"
211
212 /* -----------------------------------------------------------------------------
213 Shorthand forms
214 -------------------------------------------------------------------------- */
215
216 typedef StgChar C_;
217 typedef StgWord W_;
218 typedef StgWord* P_;
219 typedef StgInt I_;
220 typedef StgWord StgWordArray[];
221 typedef StgFunPtr F_;
222
223 #define EI_(X) extern StgWordArray (X) GNU_ATTRIBUTE(aligned (8))
224 #define II_(X) static StgWordArray (X) GNU_ATTRIBUTE(aligned (8))
225 #define IF_(f) static StgFunPtr GNUC3_ATTRIBUTE(used) f(void)
226 #define FN_(f) StgFunPtr f(void)
227 #define EF_(f) StgFunPtr f(void) /* External Cmm functions */
228 #define EFF_(f) void f() /* See Note [External function prototypes] */
229
230 /* Note [External function prototypes] See Trac #8965, #11395
231 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
232 In generated C code we need to distinct between two types
233 of external symbols:
234 1. Cmm functions declared by 'EF_' macro (External Functions)
235 2. C functions declared by 'EFF_' macro (External Foreign Functions)
236
237 Cmm functions are simple as they are internal to GHC.
238
239 C functions are trickier:
240
241 The external-function macro EFF_(F) used to be defined as
242 extern StgFunPtr f(void)
243 i.e a function of zero arguments. On most platforms this doesn't
244 matter very much: calls to these functions put the parameters in the
245 usual places anyway, and (with the exception of varargs) things just
246 work.
247
248 However, the ELFv2 ABI on ppc64 optimises stack allocation
249 (http://gcc.gnu.org/ml/gcc-patches/2013-11/msg01149.html): a call to a
250 function that has a prototype, is not varargs, and receives all parameters
251 in registers rather than on the stack does not require the caller to
252 allocate an argument save area. The incorrect prototypes cause GCC to
253 believe that all functions declared this way can be called without an
254 argument save area, but if the callee has sufficiently many arguments then
255 it will expect that area to be present, and will thus corrupt the caller's
256 stack. This happens in particular with calls to runInteractiveProcess in
257 libraries/process/cbits/runProcess.c, and led to Trac #8965.
258
259 The simplest fix appears to be to declare these external functions with an
260 unspecified argument list rather than a void argument list. This is no
261 worse for platforms that don't care either way, and allows a successful
262 bootstrap of GHC 7.8 on little-endian Linux ppc64 (which uses the ELFv2
263 ABI).
264
265 Another case is m68k ABI where 'void*' return type is returned by 'a0'
266 register while 'long' return type is returned by 'd0'. Thus we trick
267 external prototype return neither of these types to workaround #11395.
268 */
269
270
271 /* -----------------------------------------------------------------------------
272 Tail calls
273 -------------------------------------------------------------------------- */
274
275 #define JMP_(cont) return((StgFunPtr)(cont))
276
277 /* -----------------------------------------------------------------------------
278 Other Stg stuff...
279 -------------------------------------------------------------------------- */
280
281 #include "stg/DLL.h"
282 #include "stg/RtsMachRegs.h"
283 #include "stg/Regs.h"
284 #include "stg/Ticky.h"
285
286 #if IN_STG_CODE
287 /*
288 * This is included later for RTS sources, after definitions of
289 * StgInfoTable, StgClosure and so on.
290 */
291 #include "stg/MiscClosures.h"
292 #endif
293
294 #include "stg/Prim.h" /* ghc-prim fallbacks */
295 #include "stg/SMP.h" // write_barrier() inline is required
296
297 /* -----------------------------------------------------------------------------
298 Moving Floats and Doubles
299
300 ASSIGN_FLT is for assigning a float to memory (usually the
301 stack/heap). The memory address is guaranteed to be
302 StgWord aligned (currently == sizeof(void *)).
303
304 PK_FLT is for pulling a float out of memory. The memory is
305 guaranteed to be StgWord aligned.
306 -------------------------------------------------------------------------- */
307
308 INLINE_HEADER void ASSIGN_FLT (W_ [], StgFloat);
309 INLINE_HEADER StgFloat PK_FLT (W_ []);
310
311 #if ALIGNMENT_FLOAT <= ALIGNMENT_VOID_P
312
313 INLINE_HEADER void ASSIGN_FLT(W_ p_dest[], StgFloat src) { *(StgFloat *)p_dest = src; }
314 INLINE_HEADER StgFloat PK_FLT (W_ p_src[]) { return *(StgFloat *)p_src; }
315
316 #else /* ALIGNMENT_FLOAT > ALIGNMENT_UNSIGNED_INT */
317
318 INLINE_HEADER void ASSIGN_FLT(W_ p_dest[], StgFloat src)
319 {
320 float_thing y;
321 y.f = src;
322 *p_dest = y.fu;
323 }
324
325 INLINE_HEADER StgFloat PK_FLT(W_ p_src[])
326 {
327 float_thing y;
328 y.fu = *p_src;
329 return(y.f);
330 }
331
332 #endif /* ALIGNMENT_FLOAT > ALIGNMENT_VOID_P */
333
334 #if ALIGNMENT_DOUBLE <= ALIGNMENT_VOID_P
335
336 INLINE_HEADER void ASSIGN_DBL (W_ [], StgDouble);
337 INLINE_HEADER StgDouble PK_DBL (W_ []);
338
339 INLINE_HEADER void ASSIGN_DBL(W_ p_dest[], StgDouble src) { *(StgDouble *)p_dest = src; }
340 INLINE_HEADER StgDouble PK_DBL (W_ p_src[]) { return *(StgDouble *)p_src; }
341
342 #else /* ALIGNMENT_DOUBLE > ALIGNMENT_VOID_P */
343
344 /* Sparc uses two floating point registers to hold a double. We can
345 * write ASSIGN_DBL and PK_DBL by directly accessing the registers
346 * independently - unfortunately this code isn't writable in C, we
347 * have to use inline assembler.
348 */
349 #if sparc_HOST_ARCH
350
351 #define ASSIGN_DBL(dst0,src) \
352 { StgPtr dst = (StgPtr)(dst0); \
353 __asm__("st %2,%0\n\tst %R2,%1" : "=m" (((P_)(dst))[0]), \
354 "=m" (((P_)(dst))[1]) : "f" (src)); \
355 }
356
357 #define PK_DBL(src0) \
358 ( { StgPtr src = (StgPtr)(src0); \
359 register double d; \
360 __asm__("ld %1,%0\n\tld %2,%R0" : "=f" (d) : \
361 "m" (((P_)(src))[0]), "m" (((P_)(src))[1])); d; \
362 } )
363
364 #else /* ! sparc_HOST_ARCH */
365
366 INLINE_HEADER void ASSIGN_DBL (W_ [], StgDouble);
367 INLINE_HEADER StgDouble PK_DBL (W_ []);
368
369 typedef struct
370 { StgWord dhi;
371 StgWord dlo;
372 } unpacked_double;
373
374 typedef union
375 { StgDouble d;
376 unpacked_double du;
377 } double_thing;
378
379 INLINE_HEADER void ASSIGN_DBL(W_ p_dest[], StgDouble src)
380 {
381 double_thing y;
382 y.d = src;
383 p_dest[0] = y.du.dhi;
384 p_dest[1] = y.du.dlo;
385 }
386
387 /* GCC also works with this version, but it generates
388 the same code as the previous one, and is not ANSI
389
390 #define ASSIGN_DBL( p_dest, src ) \
391 *p_dest = ((double_thing) src).du.dhi; \
392 *(p_dest+1) = ((double_thing) src).du.dlo \
393 */
394
395 INLINE_HEADER StgDouble PK_DBL(W_ p_src[])
396 {
397 double_thing y;
398 y.du.dhi = p_src[0];
399 y.du.dlo = p_src[1];
400 return(y.d);
401 }
402
403 #endif /* ! sparc_HOST_ARCH */
404
405 #endif /* ALIGNMENT_DOUBLE > ALIGNMENT_UNSIGNED_INT */
406
407
408 /* -----------------------------------------------------------------------------
409 Moving 64-bit quantities around
410
411 ASSIGN_Word64 assign an StgWord64/StgInt64 to a memory location
412 PK_Word64 load an StgWord64/StgInt64 from a amemory location
413
414 In both cases the memory location might not be 64-bit aligned.
415 -------------------------------------------------------------------------- */
416
417 #if SIZEOF_HSWORD == 4
418
419 typedef struct
420 { StgWord dhi;
421 StgWord dlo;
422 } unpacked_double_word;
423
424 typedef union
425 { StgInt64 i;
426 unpacked_double_word iu;
427 } int64_thing;
428
429 typedef union
430 { StgWord64 w;
431 unpacked_double_word wu;
432 } word64_thing;
433
434 INLINE_HEADER void ASSIGN_Word64(W_ p_dest[], StgWord64 src)
435 {
436 word64_thing y;
437 y.w = src;
438 p_dest[0] = y.wu.dhi;
439 p_dest[1] = y.wu.dlo;
440 }
441
442 INLINE_HEADER StgWord64 PK_Word64(W_ p_src[])
443 {
444 word64_thing y;
445 y.wu.dhi = p_src[0];
446 y.wu.dlo = p_src[1];
447 return(y.w);
448 }
449
450 INLINE_HEADER void ASSIGN_Int64(W_ p_dest[], StgInt64 src)
451 {
452 int64_thing y;
453 y.i = src;
454 p_dest[0] = y.iu.dhi;
455 p_dest[1] = y.iu.dlo;
456 }
457
458 INLINE_HEADER StgInt64 PK_Int64(W_ p_src[])
459 {
460 int64_thing y;
461 y.iu.dhi = p_src[0];
462 y.iu.dlo = p_src[1];
463 return(y.i);
464 }
465
466 #elif SIZEOF_VOID_P == 8
467
468 INLINE_HEADER void ASSIGN_Word64(W_ p_dest[], StgWord64 src)
469 {
470 p_dest[0] = src;
471 }
472
473 INLINE_HEADER StgWord64 PK_Word64(W_ p_src[])
474 {
475 return p_src[0];
476 }
477
478 INLINE_HEADER void ASSIGN_Int64(W_ p_dest[], StgInt64 src)
479 {
480 p_dest[0] = src;
481 }
482
483 INLINE_HEADER StgInt64 PK_Int64(W_ p_src[])
484 {
485 return p_src[0];
486 }
487
488 #endif /* SIZEOF_HSWORD == 4 */
489
490 /* -----------------------------------------------------------------------------
491 Split markers
492 -------------------------------------------------------------------------- */
493
494 #if defined(USE_SPLIT_MARKERS)
495 #if defined(LEADING_UNDERSCORE)
496 #define __STG_SPLIT_MARKER __asm__("\n___stg_split_marker:");
497 #else
498 #define __STG_SPLIT_MARKER __asm__("\n__stg_split_marker:");
499 #endif
500 #else
501 #define __STG_SPLIT_MARKER /* nothing */
502 #endif
503
504 /* -----------------------------------------------------------------------------
505 Integer multiply with overflow
506 -------------------------------------------------------------------------- */
507
508 /* Multiply with overflow checking.
509 *
510 * This is tricky - the usual sign rules for add/subtract don't apply.
511 *
512 * On 32-bit machines we use gcc's 'long long' types, finding
513 * overflow with some careful bit-twiddling.
514 *
515 * On 64-bit machines where gcc's 'long long' type is also 64-bits,
516 * we use a crude approximation, testing whether either operand is
517 * larger than 32-bits; if neither is, then we go ahead with the
518 * multiplication.
519 *
520 * Return non-zero if there is any possibility that the signed multiply
521 * of a and b might overflow. Return zero only if you are absolutely sure
522 * that it won't overflow. If in doubt, return non-zero.
523 */
524
525 #if SIZEOF_VOID_P == 4
526
527 #ifdef WORDS_BIGENDIAN
528 #define RTS_CARRY_IDX__ 0
529 #define RTS_REM_IDX__ 1
530 #else
531 #define RTS_CARRY_IDX__ 1
532 #define RTS_REM_IDX__ 0
533 #endif
534
535 typedef union {
536 StgInt64 l;
537 StgInt32 i[2];
538 } long_long_u ;
539
540 #define mulIntMayOflo(a,b) \
541 ({ \
542 StgInt32 r, c; \
543 long_long_u z; \
544 z.l = (StgInt64)a * (StgInt64)b; \
545 r = z.i[RTS_REM_IDX__]; \
546 c = z.i[RTS_CARRY_IDX__]; \
547 if (c == 0 || c == -1) { \
548 c = ((StgWord)((a^b) ^ r)) \
549 >> (BITS_IN (I_) - 1); \
550 } \
551 c; \
552 })
553
554 /* Careful: the carry calculation above is extremely delicate. Make sure
555 * you test it thoroughly after changing it.
556 */
557
558 #else
559
560 /* Approximate version when we don't have long arithmetic (on 64-bit archs) */
561
562 /* If we have n-bit words then we have n-1 bits after accounting for the
563 * sign bit, so we can fit the result of multiplying 2 (n-1)/2-bit numbers */
564 #define HALF_POS_INT (((I_)1) << ((BITS_IN (I_) - 1) / 2))
565 #define HALF_NEG_INT (-HALF_POS_INT)
566
567 #define mulIntMayOflo(a,b) \
568 ({ \
569 I_ c; \
570 if ((I_)a <= HALF_NEG_INT || a >= HALF_POS_INT \
571 || (I_)b <= HALF_NEG_INT || b >= HALF_POS_INT) {\
572 c = 1; \
573 } else { \
574 c = 0; \
575 } \
576 c; \
577 })
578 #endif
579
580 #endif /* STG_H */