Rts.h 8.78 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 41
#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

/* Fix for mingw stat problem (done here so it's early enough) */
42
#ifdef mingw32_HOST_OS
43 44 45
#define __MSVCRT__ 1
#endif

46 47 48 49
/* Needed to get the macro version of errno on some OSs, and also to
   get prototypes for the _r versions of C library functions. */
#define _REENTRANT 1

50 51 52 53
/*
 * We often want to know the size of something in units of an
 * StgWord... (rounded up, of course!)
 */
54 55 56
#define ROUNDUP_BYTES_TO_WDS(n) (((n) + sizeof(W_) - 1) / sizeof(W_))

#define sizeofW(t) ROUNDUP_BYTES_TO_WDS(sizeof(t))
57 58 59 60 61 62 63 64 65 66 67 68 69 70

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

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

#ifndef DEBUG
#define ASSERT(predicate) /* nothing */
#else

71
extern void _assertFail (const char *, unsigned int);
72 73 74 75 76

#define ASSERT(predicate)			\
	if (predicate)				\
	    /*null*/;				\
	else					\
77
	    _assertFail(__FILE__, __LINE__)
78 79 80 81 82 83 84 85 86 87
#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)

88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
#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
104 105 106 107 108 109 110 111 112 113 114
/*
 * 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
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
/*
 * 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);
}

138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
/* -----------------------------------------------------------------------------
   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"

/* Simulated-parallel information */
#include "GranSim.h"

/* Parallel information */
#include "Parallel.h"
172
#include "OSThreads.h"
173 174
#include "SMPClosureOps.h"
#include "SpinLock.h"
175 176

/* GNU mp library */
177 178 179
#if defined(HAVE_FRAMEWORK_GMP)
#include <GMP/gmp.h>
#else
180
#include "gmp.h"
181
#endif
182 183

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

  /* Ticky-ticky counters */
#include "TickyCounters.h"
189 190 191

/* Runtime-system hooks */
#include "Hooks.h"
192
#include "RtsMessages.h"
193

194 195 196 197
/* for StablePtr/getStablePtr/deRefStablePtr */
#include "Storage.h"
#include "Stable.h"

198 199 200 201 202 203 204 205 206 207 208 209 210
#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);

extern void      __decodeDouble (MP_INT *man, I_ *_exp, StgDouble dbl);
extern void      __decodeFloat  (MP_INT *man, I_ *_exp, StgFloat flt);
211
extern void      __decodeDouble_2Int (I_ *man_sign, W_ *man_high, W_ *man_low, I_ *exp, StgDouble dbl);
212
extern void      __decodeFloat_Int (I_ *man, I_ *exp, StgFloat flt);
213 214 215 216 217

#if defined(WANT_DOTNET_SUPPORT)
#include "DNInvoke.h"
#endif

218
/* Initialising the whole adjustor thunk machinery. */
219
extern void initAdjustor(void);
220 221 222

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

223
/* -----------------------------------------------------------------------------
224
   RTS Exit codes
225 226
   -------------------------------------------------------------------------- */

227 228 229 230 231 232 233 234 235 236 237
/* 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
   -------------------------------------------------------------------------- */

238 239 240
/* declarations for runtime flags/values */
#define MAX_RTS_ARGS 32

Simon Marlow's avatar
Simon Marlow committed
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257
#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

258
/* -----------------------------------------------------------------------------
259
   Assertions and Debuggery
260 261
   -------------------------------------------------------------------------- */

262
#define IF_RTSFLAGS(c,s)  if (RtsFlags.c) { s; }
263 264 265 266 267

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

268
#ifdef DEBUG
269 270 271
#if IN_STG_CODE
#define IF_DEBUG(c,s)  if (RtsFlags[0].DebugFlags.c) { s; }
#else
272
#define IF_DEBUG(c,s)  if (RtsFlags.DebugFlags.c) { s; }
273
#endif
274
#else
275
#define IF_DEBUG(c,s)  doNothing()
276 277
#endif

278 279 280 281 282 283
#ifdef DEBUG
#define DEBUG_ONLY(s) s
#else
#define DEBUG_ONLY(s) doNothing()
#endif

284 285
#if defined(GRAN) && defined(DEBUG)
#define IF_GRAN_DEBUG(c,s)  if (RtsFlags.GranFlags.Debug.c) { s; }
286
#else
287 288 289 290 291 292 293
#define IF_GRAN_DEBUG(c,s)  doNothing()
#endif

#if defined(PAR) && defined(DEBUG)
#define IF_PAR_DEBUG(c,s)  if (RtsFlags.ParFlags.Debug.c) { s; }
#else
#define IF_PAR_DEBUG(c,s)  doNothing()
294 295 296
#endif

/* -----------------------------------------------------------------------------
297
   Useful macros and inline functions
298 299
   -------------------------------------------------------------------------- */

sof's avatar
sof committed
300 301 302 303 304
#if defined(__GNUC__)
#define SUPPORTS_TYPEOF
#endif

#if defined(SUPPORTS_TYPEOF)
305 306
#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
307 308 309 310
#else
#define stg_min(a,b) ((a) <= (b) ? (a) : (b))
#define stg_max(a,b) ((a) <= (b) ? (b) : (a))
#endif
311

312 313 314 315 316 317
/* -------------------------------------------------------------------------- */

#ifdef __cplusplus
}
#endif

318 319 320 321 322 323 324 325 326 327 328

/* 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 {
329 330 331 332 333
  /* 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 */
334 335 336 337 338 339 340 341 342
				/* (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;


343
#endif /* RTS_H */