Stg.h 16.4 KB
Newer Older
1
/* -----------------------------------------------------------------------------
2
 *
3
 * (c) The GHC Team, 1998-2009
4
 *
5
6
7
8
9
 * Top-level include file for everything required when compiling .hc
 * code.  NOTE: in .hc files, Stg.h must be included *before* any
 * other headers, because we define some register variables which must
 * be done before any inline functions are defined (some system
 * headers have been known to define the odd inline function).
10
 *
11
12
13
14
15
16
17
 * We generally try to keep as little visible as possible when
 * compiling .hc files.  So for example the definitions of the
 * InfoTable structs, closure structs and other RTS types are not
 * visible here.  The compiler knows enough about the representations
 * of these types to generate code which manipulates them directly
 * with pointer arithmetic.
 *
18
19
20
21
 * In ordinary C code, do not #include this file directly: #include
 * "Rts.h" instead.
 *
 * 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
27
28
 * ---------------------------------------------------------------------------*/

#ifndef STG_H
#define STG_H

Simon Marlow's avatar
Simon Marlow committed
29
30
31
32
33
34
35
36
37
38
/*
 * If we are compiling a .hc file, then we want all the register
 * variables.  This is the what happens if you #include "Stg.h" first:
 * we assume this is a .hc file, and set IN_STG_CODE==1, which later
 * causes the register variables to be enabled in stg/Regs.h.
 *
 * If instead "Rts.h" is included first, then we are compiling a
 * vanilla C file.  Everything from Stg.h is provided, except that
 * IN_STG_CODE is not defined, and the register variables will not be
 * active.
39
 */
40
41
#ifndef IN_STG_CODE
# define IN_STG_CODE 1
Ian Lynagh's avatar
Ian Lynagh committed
42

43
44
// Turn on C99 for .hc code.  This gives us the INFINITY and NAN
// constants from math.h, which we occasionally need to use in .hc (#1861)
Ian Lynagh's avatar
Ian Lynagh committed
45
# define _ISOC99_SOURCE
Ian Lynagh's avatar
Ian Lynagh committed
46
47
48
49

// We need _BSD_SOURCE so that math.h defines things like gamma
// on Linux
# define _BSD_SOURCE
50
51
#endif

52
53
54
55
#if IN_STG_CODE == 0 || defined(llvm_CC_FLAVOR)
// C compilers that use an LLVM back end (clang or llvm-gcc) do not
// correctly support global register variables so we make sure that
// we do not declare them for these compilers.
56
# define NO_GLOBAL_REG_DECLS	/* don't define fixed registers */
57
58
#endif

59
/* Configuration */
60
#include "ghcconfig.h"
sof's avatar
sof committed
61

62
63
64
65
66
/* The code generator calls the math functions directly in .hc code.
   NB. after configuration stuff above, because this sets #defines
   that depend on config info, such as __USE_FILE_OFFSET64 */
#include <math.h>

67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
// On Solaris, we don't get the INFINITY and NAN constants unless we
// #define _STDC_C99, and we can't do that unless we also use -std=c99,
// because _STDC_C99 causes the headers to use C99 syntax (e.g. restrict).
// We aren't ready for -std=c99 yet, so define INFINITY/NAN by hand using
// the gcc builtins.
#if !defined(INFINITY)
#if defined(__GNUC__)
#define INFINITY __builtin_inf()
#else
#error No definition for INFINITY
#endif
#endif

#if !defined(NAN)
#if defined(__GNUC__)
#define NAN __builtin_nan("")
#else
#error No definition for NAN
#endif
#endif

88
89
90
/* -----------------------------------------------------------------------------
   Useful definitions
   -------------------------------------------------------------------------- */
91

92
/*
Simon Marlow's avatar
Simon Marlow committed
93
 * The C backend likes to refer to labels by just mentioning their
Ian Lynagh's avatar
Ian Lynagh committed
94
 * names.  However, when a symbol is declared as a variable in C, the
95
96
97
 * C compiler will implicitly dereference it when it occurs in source.
 * So we must subvert this behaviour for .hc files by declaring
 * variables as arrays, which eliminates the implicit dereference.
98
 */
99
100
101
#if IN_STG_CODE
#define RTS_VAR(x) (x)[]
#define RTS_DEREF(x) (*(x))
102
#else
103
104
#define RTS_VAR(x) x
#define RTS_DEREF(x) x
105
106
#endif

107
/* bit macros
sof's avatar
sof committed
108
 */
109
110
#define BITS_PER_BYTE 8
#define BITS_IN(x) (BITS_PER_BYTE * sizeof(x))
sof's avatar
sof committed
111

112
113
/* Compute offsets of struct fields
 */
Ian Lynagh's avatar
Ian Lynagh committed
114
#define STG_FIELD_OFFSET(s_type, field) ((StgWord)&(((s_type*)0)->field))
115

sof's avatar
sof committed
116
/*
117
 * 'Portable' inlining:
Simon Marlow's avatar
Simon Marlow committed
118
 * INLINE_HEADER is for inline functions in header files (macros)
119
 * STATIC_INLINE is for inline functions in source files
dterei's avatar
dterei committed
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)
sof's avatar
sof committed
122
 */
123
#if defined(__GNUC__) || defined( __INTEL_COMPILER)
Simon Marlow's avatar
Simon Marlow committed
124

sof's avatar
sof committed
125
126
127
# define INLINE_HEADER static inline
# define INLINE_ME inline
# define STATIC_INLINE INLINE_HEADER
Simon Marlow's avatar
Simon Marlow committed
128

129
130
131
132
133
// The special "extern inline" behaviour is now only supported by gcc
// when _GNUC_GNU_INLINE__ is defined, and you have to use
// __attribute__((gnu_inline)).  So when we don't have this, we use
// ordinary static inline.
//
134
135
136
137
138
// Apple's gcc defines __GNUC_GNU_INLINE__ without providing
// gnu_inline, so we exclude MacOS X and fall through to the safe
// version.
//
#if defined(__GNUC_GNU_INLINE__) && !defined(__APPLE__)
139
140
141
142
143
144
145
146
147
148
149
150
#  if defined(KEEP_INLINES)
#    define EXTERN_INLINE inline
#  else
#    define EXTERN_INLINE extern inline __attribute__((gnu_inline))
#  endif
#else
#  if defined(KEEP_INLINES)
#    define EXTERN_INLINE
#  else
#    define EXTERN_INLINE INLINE_HEADER
#  endif
#endif
Simon Marlow's avatar
Simon Marlow committed
151

sof's avatar
sof committed
152
#elif defined(_MSC_VER)
Simon Marlow's avatar
Simon Marlow committed
153

sof's avatar
sof committed
154
155
156
# define INLINE_HEADER __inline static
# define INLINE_ME __inline
# define STATIC_INLINE INLINE_HEADER
Simon Marlow's avatar
Simon Marlow committed
157
158
159
160
161
162
163

# if defined(KEEP_INLINES)
#  define EXTERN_INLINE __inline
# else
#  define EXTERN_INLINE __inline extern
# endif

sof's avatar
sof committed
164
#else
Simon Marlow's avatar
Simon Marlow committed
165

sof's avatar
sof committed
166
# error "Don't know how to inline functions with your C compiler."
Simon Marlow's avatar
Simon Marlow committed
167

sof's avatar
sof committed
168
169
#endif

Simon Marlow's avatar
Simon Marlow committed
170

171
172
173
174
175
176
177
178
179
/*
 * GCC attributes
 */
#if defined(__GNUC__)
#define GNU_ATTRIBUTE(at) __attribute__((at))
#else
#define GNU_ATTRIBUTE(at)
#endif

dterei's avatar
dterei committed
180
#if __GNUC__ >= 3
181
182
183
184
185
#define GNUC3_ATTRIBUTE(at) __attribute__((at))
#else
#define GNUC3_ATTRIBUTE(at)
#endif

Simon Marlow's avatar
Simon Marlow committed
186
187
188
189
190
191
#if __GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 3
#define GNUC_ATTR_HOT __attribute__((hot))
#else
#define GNUC_ATTR_HOT /* nothing */
#endif

192
193
#define STG_UNUSED    GNUC3_ATTRIBUTE(__unused__)

194
/* -----------------------------------------------------------------------------
195
   Global type definitions
196
197
   -------------------------------------------------------------------------- */

198
#include "MachDeps.h"
Simon Marlow's avatar
Simon Marlow committed
199
#include "stg/Types.h"
200

201
202
203
204
/* -----------------------------------------------------------------------------
   Shorthand forms
   -------------------------------------------------------------------------- */

dterei's avatar
dterei committed
205
206
207
208
typedef StgChar      C_;
typedef StgWord      W_;
typedef StgWord*  P_;
typedef StgInt    I_;
209
typedef StgWord StgWordArray[];
210
typedef StgFunPtr       F_;
Simon Marlow's avatar
Simon Marlow committed
211

212
213
#define EI_(X)          extern StgWordArray (X) GNU_ATTRIBUTE(aligned (8))
#define II_(X)          static StgWordArray (X) GNU_ATTRIBUTE(aligned (8))
dterei's avatar
dterei committed
214
215
#define IF_(f)    static StgFunPtr GNUC3_ATTRIBUTE(used) f(void)
#define FN_(f)    StgFunPtr f(void)
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
#define EF_(f)    extern StgFunPtr f()   /* See Note [External function prototypes] */

/* Note [External function prototypes]  See Trac #8965
   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The external-function macro EF_(F) used to be defined as
    extern StgFunPtr f(void)
i.e a function of zero arguments.  On most platforms this doesn't
matter very much: calls to these functions put the parameters in the
usual places anyway, and (with the exception of varargs) things just
work.

However, the ELFv2 ABI on ppc64 optimises stack allocation
(http://gcc.gnu.org/ml/gcc-patches/2013-11/msg01149.html): a call to a
function that has a prototype, is not varargs, and receives all parameters
in registers rather than on the stack does not require the caller to
allocate an argument save area.  The incorrect prototypes cause GCC to
believe that all functions declared this way can be called without an
argument save area, but if the callee has sufficiently many arguments then
it will expect that area to be present, and will thus corrupt the caller's
stack.  This happens in particular with calls to runInteractiveProcess in
libraries/process/cbits/runProcess.c, and led to Trac #8965.

The simplest fix appears to be to declare these external functions with an
unspecified argument list rather than a void argument list.  This is no
worse for platforms that don't care either way, and allows a successful
bootstrap of GHC 7.8 on little-endian Linux ppc64 (which uses the ELFv2
ABI).
*/

245

246
247
248
/* -----------------------------------------------------------------------------
   Tail calls
   -------------------------------------------------------------------------- */
249

Simon Marlow's avatar
Simon Marlow committed
250
251
252
#define JMP_(cont) return((StgFunPtr)(cont))
#define FB_
#define FE_
253

254
255
256
257
/* -----------------------------------------------------------------------------
   Other Stg stuff...
   -------------------------------------------------------------------------- */

Simon Marlow's avatar
Simon Marlow committed
258
#include "stg/DLL.h"
259
#include "stg/RtsMachRegs.h"
Simon Marlow's avatar
Simon Marlow committed
260
261
#include "stg/Regs.h"
#include "stg/Ticky.h"
Ian Lynagh's avatar
Ian Lynagh committed
262

263
264
265
#if IN_STG_CODE
/*
 * This is included later for RTS sources, after definitions of
dterei's avatar
dterei committed
266
 * StgInfoTable, StgClosure and so on.
267
 */
Simon Marlow's avatar
Simon Marlow committed
268
#include "stg/MiscClosures.h"
269
270
#endif

271
#include "stg/Prim.h" /* ghc-prim fallbacks */
dterei's avatar
dterei committed
272
#include "stg/SMP.h" // write_barrier() inline is required
273

274
/* -----------------------------------------------------------------------------
275
276
277
278
   Moving Floats and Doubles

   ASSIGN_FLT is for assigning a float to memory (usually the
              stack/heap).  The memory address is guaranteed to be
dterei's avatar
dterei committed
279
         StgWord aligned (currently == sizeof(void *)).
280
281
282

   PK_FLT     is for pulling a float out of memory.  The memory is
              guaranteed to be StgWord aligned.
283
284
   -------------------------------------------------------------------------- */

dterei's avatar
dterei committed
285
INLINE_HEADER void     ASSIGN_FLT (W_ [], StgFloat);
286
INLINE_HEADER StgFloat    PK_FLT     (W_ []);
287

Ian Lynagh's avatar
Ian Lynagh committed
288
#if ALIGNMENT_FLOAT <= ALIGNMENT_VOID_P
289

290
291
INLINE_HEADER void     ASSIGN_FLT(W_ p_dest[], StgFloat src) { *(StgFloat *)p_dest = src; }
INLINE_HEADER StgFloat PK_FLT    (W_ p_src[])                { return *(StgFloat *)p_src; }
292

293
#else  /* ALIGNMENT_FLOAT > ALIGNMENT_UNSIGNED_INT */
294

295
296
297
298
299
300
INLINE_HEADER void ASSIGN_FLT(W_ p_dest[], StgFloat src)
{
    float_thing y;
    y.f = src;
    *p_dest = y.fu;
}
301

302
303
304
305
306
307
308
INLINE_HEADER StgFloat PK_FLT(W_ p_src[])
{
    float_thing y;
    y.fu = *p_src;
    return(y.f);
}

Ian Lynagh's avatar
Ian Lynagh committed
309
#endif /* ALIGNMENT_FLOAT > ALIGNMENT_VOID_P */
310

Ian Lynagh's avatar
Ian Lynagh committed
311
#if ALIGNMENT_DOUBLE <= ALIGNMENT_VOID_P
312

dterei's avatar
dterei committed
313
INLINE_HEADER void     ASSIGN_DBL (W_ [], StgDouble);
314
INLINE_HEADER StgDouble   PK_DBL     (W_ []);
315

316
317
INLINE_HEADER void      ASSIGN_DBL(W_ p_dest[], StgDouble src) { *(StgDouble *)p_dest = src; }
INLINE_HEADER StgDouble PK_DBL    (W_ p_src[])                 { return *(StgDouble *)p_src; }
sof's avatar
sof committed
318

Ian Lynagh's avatar
Ian Lynagh committed
319
#else /* ALIGNMENT_DOUBLE > ALIGNMENT_VOID_P */
320
321
322
323
324

/* Sparc uses two floating point registers to hold a double.  We can
 * write ASSIGN_DBL and PK_DBL by directly accessing the registers
 * independently - unfortunately this code isn't writable in C, we
 * have to use inline assembler.
325
 */
326
#if sparc_HOST_ARCH
327
328
329
330

#define ASSIGN_DBL(dst0,src) \
    { StgPtr dst = (StgPtr)(dst0); \
      __asm__("st %2,%0\n\tst %R2,%1" : "=m" (((P_)(dst))[0]), \
dterei's avatar
dterei committed
331
   "=m" (((P_)(dst))[1]) : "f" (src)); \
332
333
334
335
336
337
    }

#define PK_DBL(src0) \
    ( { StgPtr src = (StgPtr)(src0); \
        register double d; \
      __asm__("ld %1,%0\n\tld %2,%R0" : "=f" (d) : \
dterei's avatar
dterei committed
338
   "m" (((P_)(src))[0]), "m" (((P_)(src))[1])); d; \
339
340
    } )

341
#else /* ! sparc_HOST_ARCH */
342

dterei's avatar
dterei committed
343
INLINE_HEADER void     ASSIGN_DBL (W_ [], StgDouble);
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
INLINE_HEADER StgDouble   PK_DBL     (W_ []);

typedef struct
  { StgWord dhi;
    StgWord dlo;
  } unpacked_double;

typedef union
  { StgDouble d;
    unpacked_double du;
  } double_thing;

INLINE_HEADER void ASSIGN_DBL(W_ p_dest[], StgDouble src)
{
    double_thing y;
    y.d = src;
    p_dest[0] = y.du.dhi;
    p_dest[1] = y.du.dlo;
}

/* GCC also works with this version, but it generates
   the same code as the previous one, and is not ANSI

#define ASSIGN_DBL( p_dest, src ) \
dterei's avatar
dterei committed
368
369
   *p_dest = ((double_thing) src).du.dhi; \
   *(p_dest+1) = ((double_thing) src).du.dlo \
370
*/
371

372
373
374
375
376
377
378
INLINE_HEADER StgDouble PK_DBL(W_ p_src[])
{
    double_thing y;
    y.du.dhi = p_src[0];
    y.du.dlo = p_src[1];
    return(y.d);
}
379

380
#endif /* ! sparc_HOST_ARCH */
381

382
#endif /* ALIGNMENT_DOUBLE > ALIGNMENT_UNSIGNED_INT */
383
384


385
386
387
388
389
390
391
392
393
/* -----------------------------------------------------------------------------
   Moving 64-bit quantities around

   ASSIGN_Word64      assign an StgWord64/StgInt64 to a memory location
   PK_Word64          load an StgWord64/StgInt64 from a amemory location

   In both cases the memory location might not be 64-bit aligned.
   -------------------------------------------------------------------------- */

Simon Marlow's avatar
Simon Marlow committed
394
#if SIZEOF_HSWORD == 4
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446

typedef struct
  { StgWord dhi;
    StgWord dlo;
  } unpacked_double_word;

typedef union
  { StgInt64 i;
    unpacked_double_word iu;
  } int64_thing;

typedef union
  { StgWord64 w;
    unpacked_double_word wu;
  } word64_thing;

INLINE_HEADER void ASSIGN_Word64(W_ p_dest[], StgWord64 src)
{
    word64_thing y;
    y.w = src;
    p_dest[0] = y.wu.dhi;
    p_dest[1] = y.wu.dlo;
}

INLINE_HEADER StgWord64 PK_Word64(W_ p_src[])
{
    word64_thing y;
    y.wu.dhi = p_src[0];
    y.wu.dlo = p_src[1];
    return(y.w);
}

INLINE_HEADER void ASSIGN_Int64(W_ p_dest[], StgInt64 src)
{
    int64_thing y;
    y.i = src;
    p_dest[0] = y.iu.dhi;
    p_dest[1] = y.iu.dlo;
}

INLINE_HEADER StgInt64 PK_Int64(W_ p_src[])
{
    int64_thing y;
    y.iu.dhi = p_src[0];
    y.iu.dlo = p_src[1];
    return(y.i);
}

#elif SIZEOF_VOID_P == 8

INLINE_HEADER void ASSIGN_Word64(W_ p_dest[], StgWord64 src)
{
dterei's avatar
dterei committed
447
   p_dest[0] = src;
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
}

INLINE_HEADER StgWord64 PK_Word64(W_ p_src[])
{
    return p_src[0];
}

INLINE_HEADER void ASSIGN_Int64(W_ p_dest[], StgInt64 src)
{
    p_dest[0] = src;
}

INLINE_HEADER StgInt64 PK_Int64(W_ p_src[])
{
    return p_src[0];
}

Simon Marlow's avatar
Simon Marlow committed
465
#endif /* SIZEOF_HSWORD == 4 */
466
467
468
469

/* -----------------------------------------------------------------------------
   Split markers
   -------------------------------------------------------------------------- */
470

471
472
473
474
475
476
477
478
479
480
#if defined(USE_SPLIT_MARKERS)
#if defined(LEADING_UNDERSCORE)
#define __STG_SPLIT_MARKER __asm__("\n___stg_split_marker:");
#else
#define __STG_SPLIT_MARKER __asm__("\n__stg_split_marker:");
#endif
#else
#define __STG_SPLIT_MARKER /* nothing */
#endif

481
482
483
484
485
486
487
/* -----------------------------------------------------------------------------
   Write-combining store
   -------------------------------------------------------------------------- */

INLINE_HEADER void
wcStore (StgPtr p, StgWord w)
{
dterei's avatar
dterei committed
488
#ifdef x86_64_HOST_ARCH
489
    __asm__(
dterei's avatar
dterei committed
490
491
492
493
   "movnti\t%1, %0"
   : "=m" (*p)
   : "r" (w)
   );
494
495
496
497
498
#else
      *p = w;
#endif
}

499
500
501
/* -----------------------------------------------------------------------------
   Integer multiply with overflow
   -------------------------------------------------------------------------- */
502

503
504
/* Multiply with overflow checking.
 *
dterei's avatar
dterei committed
505
 * This is tricky - the usual sign rules for add/subtract don't apply.
506
507
508
509
510
511
512
513
514
515
516
517
518
 *
 * On 32-bit machines we use gcc's 'long long' types, finding
 * overflow with some careful bit-twiddling.
 *
 * On 64-bit machines where gcc's 'long long' type is also 64-bits,
 * we use a crude approximation, testing whether either operand is
 * larger than 32-bits; if neither is, then we go ahead with the
 * multiplication.
 *
 * Return non-zero if there is any possibility that the signed multiply
 * of a and b might overflow.  Return zero only if you are absolutely sure
 * that it won't overflow.  If in doubt, return non-zero.
 */
519

520
#if SIZEOF_VOID_P == 4
521

522
523
524
525
526
527
#ifdef WORDS_BIGENDIAN
#define RTS_CARRY_IDX__ 0
#define RTS_REM_IDX__  1
#else
#define RTS_CARRY_IDX__ 1
#define RTS_REM_IDX__ 0
sof's avatar
sof committed
528
529
#endif

530
531
532
533
534
typedef union {
    StgInt64 l;
    StgInt32 i[2];
} long_long_u ;

dterei's avatar
dterei committed
535
#define mulIntMayOflo(a,b)       \
536
({                                              \
dterei's avatar
dterei committed
537
538
539
540
541
542
543
544
545
  StgInt32 r, c;           \
  long_long_u z;           \
  z.l = (StgInt64)a * (StgInt64)b;     \
  r = z.i[RTS_REM_IDX__];        \
  c = z.i[RTS_CARRY_IDX__];         \
  if (c == 0 || c == -1) {       \
    c = ((StgWord)((a^b) ^ r))         \
      >> (BITS_IN (I_) - 1);        \
  }                  \
546
547
548
549
550
551
552
553
554
  c;                                            \
})

/* Careful: the carry calculation above is extremely delicate.  Make sure
 * you test it thoroughly after changing it.
 */

#else

555
/* Approximate version when we don't have long arithmetic (on 64-bit archs) */
556

557
558
559
/* If we have n-bit words then we have n-1 bits after accounting for the
 * sign bit, so we can fit the result of multiplying 2 (n-1)/2-bit numbers */
#define HALF_POS_INT  (((I_)1) << ((BITS_IN (I_) - 1) / 2))
560
#define HALF_NEG_INT  (-HALF_POS_INT)
561

dterei's avatar
dterei committed
562
#define mulIntMayOflo(a,b)       \
563
({                                              \
dterei's avatar
dterei committed
564
  I_ c;              \
565
566
  if ((I_)a <= HALF_NEG_INT || a >= HALF_POS_INT    \
      || (I_)b <= HALF_NEG_INT || b >= HALF_POS_INT) {\
dterei's avatar
dterei committed
567
568
569
570
    c = 1;              \
  } else {              \
    c = 0;              \
  }                  \
571
572
573
  c;                                            \
})
#endif
sof's avatar
sof committed
574

575
#endif /* STG_H */