Rts.h 8.36 KB
Newer Older
1
/* -----------------------------------------------------------------------------
2
 *
3
 * (c) The GHC Team, 1998-2004
4 5 6 7 8 9 10 11
 *
 * Top-level include file for the RTS itself
 *
 * ---------------------------------------------------------------------------*/

#ifndef RTS_H
#define RTS_H

12 13 14 15
#ifdef __cplusplus
extern "C" {
#endif

16
#ifndef IN_STG_CODE
17
#define IN_STG_CODE 0
18 19 20
#endif
#include "Stg.h"

21 22 23
// ToDo: move RtsExternal stuff elsewhere
#include "RtsExternal.h"

24 25 26 27 28 29
// Turn off inlining when debugging - it obfuscates things
#ifdef DEBUG
# undef  STATIC_INLINE
# define STATIC_INLINE static
#endif

30 31 32 33 34 35 36 37 38 39 40
#include "RtsTypes.h"

#if __GNUC__ >= 3
/* Assume that a flexible array member at the end of a struct
 * can be defined thus: T arr[]; */
#define FLEXIBLE_ARRAY
#else
/* Assume that it must be defined thus: T arr[0]; */
#define FLEXIBLE_ARRAY 0
#endif

41 42 43 44 45 46
#if __GNUC__ >= 3
#define ATTRIBUTE_ALIGNED(n) __attribute__((aligned(n)))
#else
#define ATTRIBUTE_ALIGNED(n) /*nothing*/
#endif

47
/* Fix for mingw stat problem (done here so it's early enough) */
48
#ifdef mingw32_HOST_OS
49 50 51
#define __MSVCRT__ 1
#endif

52 53
/* Needed to get the macro version of errno on some OSs, and also to
   get prototypes for the _r versions of C library functions. */
54
#ifndef _REENTRANT
55
#define _REENTRANT 1
56
#endif
57

58 59 60 61
/*
 * We often want to know the size of something in units of an
 * StgWord... (rounded up, of course!)
 */
62 63 64
#define ROUNDUP_BYTES_TO_WDS(n) (((n) + sizeof(W_) - 1) / sizeof(W_))

#define sizeofW(t) ROUNDUP_BYTES_TO_WDS(sizeof(t))
65 66 67 68 69 70 71 72 73

/* 
 * It's nice to be able to grep for casts
 */
#define stgCast(ty,e) ((ty)(e))

/* -----------------------------------------------------------------------------
   Assertions and Debuggery

74 75 76
   CHECK(p)   evaluates p and terminates with an error if p is false
   ASSERT(p)  like CHECK(p) if DEBUG is on, otherwise a no-op
   -------------------------------------------------------------------------- */
77

78
extern void _assertFail (const char *, unsigned int);
79

80
#define CHECK(predicate)			\
81 82 83
	if (predicate)				\
	    /*null*/;				\
	else					\
84
	    _assertFail(__FILE__, __LINE__)
85 86 87 88 89

#ifndef DEBUG
#define ASSERT(predicate) /* nothing */
#else
#define ASSERT(predicate) CHECK(predicate)
90 91 92 93 94 95 96 97 98 99
#endif /* DEBUG */

/* 
 * Use this on the RHS of macros which expand to nothing
 * to make sure that the macro can be used in a context which
 * demands a non-empty statement.
 */

#define doNothing() do { } while (0)

100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
#ifdef DEBUG
#define USED_IF_DEBUG
#define USED_IF_NOT_DEBUG STG_UNUSED
#else
#define USED_IF_DEBUG STG_UNUSED
#define USED_IF_NOT_DEBUG
#endif

#ifdef THREADED_RTS
#define USED_IF_THREADS
#define USED_IF_NOT_THREADS STG_UNUSED
#else
#define USED_IF_THREADS STG_UNUSED
#define USED_IF_NOT_THREADS
#endif

Simon Marlow's avatar
Simon Marlow committed
116 117 118 119 120 121 122 123 124 125 126
/*
 * Getting printf formats right for platform-dependent typedefs
 */
#if SIZEOF_LONG == 8
#define FMT_Word64 "lu"
#define FMT_Int64  "ld"
#else
#define FMT_Word64 "llu"
#define FMT_Int64  "lld"
#endif

Simon Marlow's avatar
Simon Marlow committed
127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
/*
 * Macros for untagging and retagging closure pointers
 * For more information look at the comments in Cmm.h
 */

static inline StgWord
GET_CLOSURE_TAG(StgClosure * p)
{
    return (StgWord)p & TAG_MASK;
}

static inline StgClosure *
UNTAG_CLOSURE(StgClosure * p)
{
    return (StgClosure*)((StgWord)p & ~TAG_MASK);
}

static inline StgClosure *
TAG_CLOSURE(StgWord tag,StgClosure * p)
{
    return (StgClosure*)((StgWord)p | tag);
}

150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179
/* -----------------------------------------------------------------------------
   Include everything STG-ish
   -------------------------------------------------------------------------- */

/* System headers: stdlib.h is eeded so that we can use NULL.  It must
 * come after MachRegs.h, because stdlib.h might define some inline
 * functions which may only be defined after register variables have
 * been declared.
 */
#include <stdlib.h>

/* Global constaints */
#include "Constants.h"

/* Profiling information */
#include "StgProf.h"
#include "StgLdvProf.h"

/* Storage format definitions */
#include "StgFun.h"
#include "Closures.h"
#include "Liveness.h"
#include "ClosureTypes.h"
#include "InfoTables.h"
#include "TSO.h"

/* Info tables, closures & code fragments defined in the RTS */
#include "StgMiscClosures.h"

/* Parallel information */
180
#include "OSThreads.h"
181 182
#include "SMPClosureOps.h"
#include "SpinLock.h"
183 184

/* Macros for STG/C code */
185
#include "Block.h"
186
#include "ClosureMacros.h"
187

188 189
/* Runtime-system hooks */
#include "Hooks.h"
190
#include "RtsMessages.h"
191

192 193 194 195
/* for StablePtr/getStablePtr/deRefStablePtr */
#include "Storage.h"
#include "Stable.h"

196 197 198 199 200 201 202 203 204 205 206
#include "ieee-flpt.h"

#include "Signals.h"

/* Misc stuff without a home */
DLL_IMPORT_RTS extern char **prog_argv;	/* so we can get at these from Haskell */
DLL_IMPORT_RTS extern int    prog_argc;
DLL_IMPORT_RTS extern char  *prog_name;

extern void stackOverflow(void);

207
extern void      __decodeDouble_2Int (I_ *man_sign, W_ *man_high, W_ *man_low, I_ *exp, StgDouble dbl);
208
extern void      __decodeFloat_Int (I_ *man, I_ *exp, StgFloat flt);
209

210
/* Initialising the whole adjustor thunk machinery. */
211
extern void initAdjustor(void);
212 213 214

extern void stg_exit(int n) GNU_ATTRIBUTE(__noreturn__);

215
/* -----------------------------------------------------------------------------
216
   RTS Exit codes
217 218
   -------------------------------------------------------------------------- */

219 220 221 222 223 224 225 226 227 228 229
/* 255 is allegedly used by dynamic linkers to report linking failure */
#define EXIT_INTERNAL_ERROR 254
#define EXIT_DEADLOCK       253
#define EXIT_INTERRUPTED    252
#define EXIT_HEAPOVERFLOW   251
#define EXIT_KILLED         250

/* -----------------------------------------------------------------------------
   Miscellaneous garbage
   -------------------------------------------------------------------------- */

230 231 232
/* declarations for runtime flags/values */
#define MAX_RTS_ARGS 32

Simon Marlow's avatar
Simon Marlow committed
233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249
#ifdef DEBUG
#define TICK_VAR(arity) \
  extern StgInt SLOW_CALLS_##arity; \
  extern StgInt RIGHT_ARITY_##arity; \
  extern StgInt TAGGED_PTR_##arity;

#define TICK_VAR_INI(arity) \
  StgInt SLOW_CALLS_##arity = 1; \
  StgInt RIGHT_ARITY_##arity = 1; \
  StgInt TAGGED_PTR_##arity = 0;

extern StgInt TOTAL_CALLS;

TICK_VAR(1)
TICK_VAR(2)
#endif

250
/* -----------------------------------------------------------------------------
251
   Assertions and Debuggery
252 253
   -------------------------------------------------------------------------- */

254
#define IF_RTSFLAGS(c,s)  if (RtsFlags.c) { s; }
255 256 257 258 259

/* -----------------------------------------------------------------------------
   Assertions and Debuggery
   -------------------------------------------------------------------------- */

260
#ifdef DEBUG
261 262 263
#if IN_STG_CODE
#define IF_DEBUG(c,s)  if (RtsFlags[0].DebugFlags.c) { s; }
#else
264
#define IF_DEBUG(c,s)  if (RtsFlags.DebugFlags.c) { s; }
265
#endif
266
#else
267
#define IF_DEBUG(c,s)  doNothing()
268 269
#endif

270 271 272 273 274 275
#ifdef DEBUG
#define DEBUG_ONLY(s) s
#else
#define DEBUG_ONLY(s) doNothing()
#endif

276
/* -----------------------------------------------------------------------------
277
   Useful macros and inline functions
278 279
   -------------------------------------------------------------------------- */

sof's avatar
sof committed
280 281 282 283 284
#if defined(__GNUC__)
#define SUPPORTS_TYPEOF
#endif

#if defined(SUPPORTS_TYPEOF)
285 286
#define stg_min(a,b) ({typeof(a) _a = (a), _b = (b); _a <= _b ? _a : _b; })
#define stg_max(a,b) ({typeof(a) _a = (a), _b = (b); _a <= _b ? _b : _a; })
sof's avatar
sof committed
287 288 289 290
#else
#define stg_min(a,b) ((a) <= (b) ? (a) : (b))
#define stg_max(a,b) ((a) <= (b) ? (b) : (a))
#endif
291

292 293 294 295 296 297
/* -------------------------------------------------------------------------- */

#ifdef __cplusplus
}
#endif

298 299 300 301 302 303 304 305 306 307 308

/* krc: I put this here because I don't think
   it needs to be visible externally.
   It used to be in StgTicky.h, but I got rid
   of that. */

/* -----------------------------------------------------------------------------
   The StgEntCounter type - needed regardless of TICKY_TICKY
   -------------------------------------------------------------------------- */

typedef struct _StgEntCounter {
309 310 311 312 313
  /* Using StgWord for everything, becuase both the C and asm code
     generators make trouble if you try to pack things tighter */
    StgWord	registeredp;	/* 0 == no, 1 == yes */
    StgInt	arity;		/* arity (static info) */
    StgInt	stk_args;	/* # of args off stack */
314 315 316 317 318 319 320 321 322
				/* (rest of args are in registers) */
    char   	*str;		/* name of the thing */
    char   	*arg_kinds;	/* info about the args types */
    StgInt	entry_count;	/* Trips to fast entry code */
    StgInt      allocs;         /* number of allocations by this fun */
    struct _StgEntCounter *link;/* link to chain them all together */
} StgEntCounter;


323
#endif /* RTS_H */