Stg.h 15 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
216
#define IF_(f)    static StgFunPtr GNUC3_ATTRIBUTE(used) f(void)
#define FN_(f)    StgFunPtr f(void)
#define EF_(f)    extern StgFunPtr f(void)
217

218
219
220
/* -----------------------------------------------------------------------------
   Tail calls
   -------------------------------------------------------------------------- */
221

Simon Marlow's avatar
Simon Marlow committed
222
223
224
#define JMP_(cont) return((StgFunPtr)(cont))
#define FB_
#define FE_
225

226
227
228
229
/* -----------------------------------------------------------------------------
   Other Stg stuff...
   -------------------------------------------------------------------------- */

Simon Marlow's avatar
Simon Marlow committed
230
#include "stg/DLL.h"
231
#include "stg/RtsMachRegs.h"
Simon Marlow's avatar
Simon Marlow committed
232
233
#include "stg/Regs.h"
#include "stg/Ticky.h"
Ian Lynagh's avatar
Ian Lynagh committed
234

235
236
237
#if IN_STG_CODE
/*
 * This is included later for RTS sources, after definitions of
dterei's avatar
dterei committed
238
 * StgInfoTable, StgClosure and so on.
239
 */
Simon Marlow's avatar
Simon Marlow committed
240
#include "stg/MiscClosures.h"
241
242
#endif

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

246
/* -----------------------------------------------------------------------------
247
248
249
250
   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
251
         StgWord aligned (currently == sizeof(void *)).
252
253
254

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

dterei's avatar
dterei committed
257
INLINE_HEADER void     ASSIGN_FLT (W_ [], StgFloat);
258
INLINE_HEADER StgFloat    PK_FLT     (W_ []);
259

Ian Lynagh's avatar
Ian Lynagh committed
260
#if ALIGNMENT_FLOAT <= ALIGNMENT_VOID_P
261

262
263
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; }
264

265
#else  /* ALIGNMENT_FLOAT > ALIGNMENT_UNSIGNED_INT */
266

267
268
269
270
271
272
INLINE_HEADER void ASSIGN_FLT(W_ p_dest[], StgFloat src)
{
    float_thing y;
    y.f = src;
    *p_dest = y.fu;
}
273

274
275
276
277
278
279
280
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
281
#endif /* ALIGNMENT_FLOAT > ALIGNMENT_VOID_P */
282

Ian Lynagh's avatar
Ian Lynagh committed
283
#if ALIGNMENT_DOUBLE <= ALIGNMENT_VOID_P
284

dterei's avatar
dterei committed
285
INLINE_HEADER void     ASSIGN_DBL (W_ [], StgDouble);
286
INLINE_HEADER StgDouble   PK_DBL     (W_ []);
287

288
289
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
290

Ian Lynagh's avatar
Ian Lynagh committed
291
#else /* ALIGNMENT_DOUBLE > ALIGNMENT_VOID_P */
292
293
294
295
296

/* 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.
297
 */
298
#if sparc_HOST_ARCH
299
300
301
302

#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
303
   "=m" (((P_)(dst))[1]) : "f" (src)); \
304
305
306
307
308
309
    }

#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
310
   "m" (((P_)(src))[0]), "m" (((P_)(src))[1])); d; \
311
312
    } )

313
#else /* ! sparc_HOST_ARCH */
314

dterei's avatar
dterei committed
315
INLINE_HEADER void     ASSIGN_DBL (W_ [], StgDouble);
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
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
340
341
   *p_dest = ((double_thing) src).du.dhi; \
   *(p_dest+1) = ((double_thing) src).du.dlo \
342
*/
343

344
345
346
347
348
349
350
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);
}
351

352
#endif /* ! sparc_HOST_ARCH */
353

354
#endif /* ALIGNMENT_DOUBLE > ALIGNMENT_UNSIGNED_INT */
355
356


357
358
359
360
361
362
363
364
365
/* -----------------------------------------------------------------------------
   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
366
#if SIZEOF_HSWORD == 4
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418

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
419
   p_dest[0] = src;
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
}

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
437
#endif /* SIZEOF_HSWORD == 4 */
438
439
440
441

/* -----------------------------------------------------------------------------
   Split markers
   -------------------------------------------------------------------------- */
442

443
444
445
446
447
448
449
450
451
452
#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

453
454
455
456
457
458
459
/* -----------------------------------------------------------------------------
   Write-combining store
   -------------------------------------------------------------------------- */

INLINE_HEADER void
wcStore (StgPtr p, StgWord w)
{
dterei's avatar
dterei committed
460
#ifdef x86_64_HOST_ARCH
461
    __asm__(
dterei's avatar
dterei committed
462
463
464
465
   "movnti\t%1, %0"
   : "=m" (*p)
   : "r" (w)
   );
466
467
468
469
470
#else
      *p = w;
#endif
}

471
472
473
/* -----------------------------------------------------------------------------
   Integer multiply with overflow
   -------------------------------------------------------------------------- */
474

475
476
/* Multiply with overflow checking.
 *
dterei's avatar
dterei committed
477
 * This is tricky - the usual sign rules for add/subtract don't apply.
478
479
480
481
482
483
484
485
486
487
488
489
490
 *
 * 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.
 */
491

492
#if SIZEOF_VOID_P == 4
493

494
495
496
497
498
499
#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
500
501
#endif

502
503
504
505
506
typedef union {
    StgInt64 l;
    StgInt32 i[2];
} long_long_u ;

dterei's avatar
dterei committed
507
#define mulIntMayOflo(a,b)       \
508
({                                              \
dterei's avatar
dterei committed
509
510
511
512
513
514
515
516
517
  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);        \
  }                  \
518
519
520
521
522
523
524
525
526
  c;                                            \
})

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

#else

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

529
530
531
/* 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))
532
#define HALF_NEG_INT  (-HALF_POS_INT)
533

dterei's avatar
dterei committed
534
#define mulIntMayOflo(a,b)       \
535
({                                              \
dterei's avatar
dterei committed
536
  I_ c;              \
537
538
  if ((I_)a <= HALF_NEG_INT || a >= HALF_POS_INT    \
      || (I_)b <= HALF_NEG_INT || b >= HALF_POS_INT) {\
dterei's avatar
dterei committed
539
540
541
542
    c = 1;              \
  } else {              \
    c = 0;              \
  }                  \
543
544
545
  c;                                            \
})
#endif
sof's avatar
sof committed
546

547
#endif /* STG_H */