Fix signature of atomic builtins
[ghc.git] / includes / Rts.h
index 6c039f8..e6e36f8 100644 (file)
@@ -1,8 +1,12 @@
 /* -----------------------------------------------------------------------------
  *
- * (c) The GHC Team, 1998-2004
+ * (c) The GHC Team, 1998-2009
  *
- * Top-level include file for the RTS itself
+ * RTS external APIs.  This file declares everything that the GHC RTS
+ * exposes externally.
+ *
+ * To understand the structure of the RTS headers, see the wiki:
+ *   http://ghc.haskell.org/trac/ghc/wiki/Commentary/SourceTree/Includes
  *
  * ---------------------------------------------------------------------------*/
 
 extern "C" {
 #endif
 
+/* We include windows.h very early, as on Win64 the CONTEXT type has
+   fields "R8", "R9" and "R10", which goes bad if we've already
+   #define'd those names for our own purposes (in stg/Regs.h) */
+#if defined(HAVE_WINDOWS_H)
+#include <windows.h>
+#endif
+
 #ifndef IN_STG_CODE
 #define IN_STG_CODE 0
 #endif
 #include "Stg.h"
 
-// ToDo: move RtsExternal stuff elsewhere
-#include "RtsExternal.h"
+#include "HsFFI.h"
+#include "RtsAPI.h"
 
 // Turn off inlining when debugging - it obfuscates things
 #ifdef DEBUG
@@ -27,7 +38,7 @@ extern "C" {
 # define STATIC_INLINE static
 #endif
 
-#include "RtsTypes.h"
+#include "rts/Types.h"
 
 #if __GNUC__ >= 3
 /* Assume that a flexible array member at the end of a struct
@@ -44,6 +55,21 @@ extern "C" {
 #define ATTRIBUTE_ALIGNED(n) /*nothing*/
 #endif
 
+// Symbols that are extern, but private to the RTS, are declared
+// with visibility "hidden" to hide them outside the RTS shared
+// library.
+#if defined(HAS_VISIBILITY_HIDDEN)
+#define RTS_PRIVATE  GNUC3_ATTRIBUTE(visibility("hidden"))
+#else
+#define RTS_PRIVATE  /* disabled: RTS_PRIVATE */
+#endif
+
+#if __GNUC__ >= 4
+#define RTS_UNLIKELY(p) __builtin_expect((p),0)
+#else
+#define RTS_UNLIKELY(p) p
+#endif
+
 /* Fix for mingw stat problem (done here so it's early enough) */
 #ifdef mingw32_HOST_OS
 #define __MSVCRT__ 1
@@ -51,7 +77,9 @@ extern "C" {
 
 /* Needed to get the macro version of errno on some OSs, and also to
    get prototypes for the _r versions of C library functions. */
+#ifndef _REENTRANT
 #define _REENTRANT 1
+#endif
 
 /*
  * We often want to know the size of something in units of an
@@ -61,29 +89,37 @@ extern "C" {
 
 #define sizeofW(t) ROUNDUP_BYTES_TO_WDS(sizeof(t))
 
-/* 
- * It's nice to be able to grep for casts
- */
-#define stgCast(ty,e) ((ty)(e))
-
 /* -----------------------------------------------------------------------------
    Assertions and Debuggery
+
+   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
    -------------------------------------------------------------------------- */
 
+void _assertFail(const char *filename, unsigned int linenum)
+   GNUC3_ATTRIBUTE(__noreturn__);
+
+#define CHECK(predicate)                        \
+        if (predicate)                          \
+            /*null*/;                           \
+        else                                    \
+            _assertFail(__FILE__, __LINE__)
+
+#define CHECKM(predicate, msg, ...)             \
+        if (predicate)                          \
+            /*null*/;                           \
+        else                                    \
+            barf(msg, ##__VA_ARGS__)
+
 #ifndef DEBUG
 #define ASSERT(predicate) /* nothing */
+#define ASSERTM(predicate,msg,...) /* nothing */
 #else
-
-extern void _assertFail (const char *, unsigned int);
-
-#define ASSERT(predicate)                      \
-       if (predicate)                          \
-           /*null*/;                           \
-       else                                    \
-           _assertFail(__FILE__, __LINE__)
+#define ASSERT(predicate) CHECK(predicate)
+#define ASSERTM(predicate,msg,...) CHECKM(predicate,msg,##__VA_ARGS__)
 #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.
@@ -107,115 +143,130 @@ extern void _assertFail (const char *, unsigned int);
 #define USED_IF_NOT_THREADS
 #endif
 
-/*
- * 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
+#define FMT_SizeT    "zu"
+#define FMT_HexSizeT "zx"
 
-/*
- * Macros for untagging and retagging closure pointers
- * For more information look at the comments in Cmm.h
- */
+/* -----------------------------------------------------------------------------
+   Time values in the RTS
+   -------------------------------------------------------------------------- */
 
-static inline StgWord
-GET_CLOSURE_TAG(StgClosure * p)
-{
-    return (StgWord)p & TAG_MASK;
-}
+// For most time values in the RTS we use a fixed resolution of nanoseconds,
+// normalising the time we get from platform-dependent APIs to this
+// resolution.
+#define TIME_RESOLUTION 1000000000
+typedef StgInt64 Time;
 
-static inline StgClosure *
-UNTAG_CLOSURE(StgClosure * p)
-{
-    return (StgClosure*)((StgWord)p & ~TAG_MASK);
-}
+#define TIME_MAX HS_INT64_MAX
+
+#if TIME_RESOLUTION == 1000000000
+// I'm being lazy, but it's awkward to define fully general versions of these
+#define TimeToUS(t)      ((t) / 1000)
+#define TimeToNS(t)      (t)
+#define USToTime(t)      ((Time)(t) * 1000)
+#define NSToTime(t)      ((Time)(t))
+#else
+#error Fix TimeToNS(), TimeToUS() etc.
+#endif
+
+#define SecondsToTime(t) ((Time)(t) * TIME_RESOLUTION)
+#define TimeToSeconds(t) ((t) / TIME_RESOLUTION)
 
-static inline StgClosure *
-TAG_CLOSURE(StgWord tag,StgClosure * p)
+// Use instead of SecondsToTime() when we have a floating-point
+// seconds value, to avoid truncating it.
+INLINE_HEADER Time fsecondsToTime (double t)
 {
-    return (StgClosure*)((StgWord)p | tag);
+    return (Time)(t * TIME_RESOLUTION);
 }
 
 /* -----------------------------------------------------------------------------
    Include everything STG-ish
    -------------------------------------------------------------------------- */
 
-/* System headers: stdlib.h is eeded so that we can use NULL.  It must
+/* System headers: stdlib.h is needed 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"
+#include "rts/Config.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"
+/* Global constraints */
+#include "rts/Constants.h"
 
-/* Info tables, closures & code fragments defined in the RTS */
-#include "StgMiscClosures.h"
+/* Profiling information */
+#include "rts/prof/CCS.h"
+#include "rts/prof/LDV.h"
 
 /* Parallel information */
-#include "OSThreads.h"
-#include "SMPClosureOps.h"
-#include "SpinLock.h"
-
-/* GNU mp library */
-#if defined(HAVE_FRAMEWORK_GMP)
-#include <GMP/gmp.h>
-#else
-#include "gmp.h"
-#endif
-
-/* Macros for STG/C code */
-#include "Block.h"
-#include "ClosureMacros.h"
-
-/* Runtime-system hooks */
-#include "Hooks.h"
-#include "RtsMessages.h"
+#include "rts/OSThreads.h"
+#include "rts/SpinLock.h"
 
-/* for StablePtr/getStablePtr/deRefStablePtr */
-#include "Storage.h"
-#include "Stable.h"
+#include "rts/Messages.h"
+#include "rts/Threads.h"
 
-#include "ieee-flpt.h"
-
-#include "Signals.h"
+/* Storage format definitions */
+#include "rts/storage/FunTypes.h"
+#include "rts/storage/InfoTables.h"
+#include "rts/storage/Closures.h"
+#include "rts/storage/ClosureTypes.h"
+#include "rts/storage/TSO.h"
+#include "stg/MiscClosures.h" /* InfoTables, closures etc. defined in the RTS */
+#include "rts/storage/SMPClosureOps.h"
+#include "rts/storage/Block.h"
+#include "rts/storage/ClosureMacros.h"
+#include "rts/storage/MBlock.h"
+#include "rts/storage/GC.h"
+
+/* Other RTS external APIs */
+#include "rts/Parallel.h"
+#include "rts/Signals.h"
+#include "rts/BlockSignals.h"
+#include "rts/Hpc.h"
+#include "rts/Flags.h"
+#include "rts/Adjustor.h"
+#include "rts/FileLock.h"
+#include "rts/GetTime.h"
+#include "rts/Globals.h"
+#include "rts/IOManager.h"
+#include "rts/Linker.h"
+#include "rts/Ticky.h"
+#include "rts/Timer.h"
+#include "rts/Stable.h"
+#include "rts/TTY.h"
+#include "rts/Utils.h"
+#include "rts/PrimFloat.h"
+#include "rts/Main.h"
+#include "rts/StaticPtrTable.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 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);
+#ifdef mingw32_HOST_OS
+// We need these two from Haskell too
+void getWin32ProgArgv(int *argc, wchar_t **argv[]);
+void setWin32ProgArgv(int argc, wchar_t *argv[]);
+#endif
+
+void stackOverflow(StgTSO* tso);
 
-extern void      __decodeDouble_2Int (I_ *man_sign, W_ *man_high, W_ *man_low, I_ *exp, StgDouble dbl);
-extern void      __decodeFloat_Int (I_ *man, I_ *exp, StgFloat flt);
+void stg_exit(int n) GNU_ATTRIBUTE(__noreturn__);
 
-#if defined(WANT_DOTNET_SUPPORT)
-#include "DNInvoke.h"
+#ifndef mingw32_HOST_OS
+int stg_sig_install (int, int, void *);
 #endif
 
-/* Initialising the whole adjustor thunk machinery. */
-extern void initAdjustor(void);
+/* -----------------------------------------------------------------------------
+   Ways
+   -------------------------------------------------------------------------- */
+
+// Returns non-zero if the RTS is a profiling version
+int rts_isProfiled(void);
 
-extern void stg_exit(int n) GNU_ATTRIBUTE(__noreturn__);
+// Returns non-zero if the RTS is a dynamically-linked version
+int rts_isDynamic(void);
 
 /* -----------------------------------------------------------------------------
    RTS Exit codes
@@ -232,20 +283,12 @@ extern void stg_exit(int n) GNU_ATTRIBUTE(__noreturn__);
    Miscellaneous garbage
    -------------------------------------------------------------------------- */
 
-/* declarations for runtime flags/values */
-#define MAX_RTS_ARGS 32
-
 #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)
@@ -258,10 +301,6 @@ TICK_VAR(2)
 
 #define IF_RTSFLAGS(c,s)  if (RtsFlags.c) { s; }
 
-/* -----------------------------------------------------------------------------
-   Assertions and Debuggery
-   -------------------------------------------------------------------------- */
-
 #ifdef DEBUG
 #if IN_STG_CODE
 #define IF_DEBUG(c,s)  if (RtsFlags[0].DebugFlags.c) { s; }
@@ -278,6 +317,12 @@ TICK_VAR(2)
 #define DEBUG_ONLY(s) doNothing()
 #endif
 
+#ifdef DEBUG
+#define DEBUG_IS_ON   1
+#else
+#define DEBUG_IS_ON   0
+#endif
+
 /* -----------------------------------------------------------------------------
    Useful macros and inline functions
    -------------------------------------------------------------------------- */
@@ -300,29 +345,4 @@ TICK_VAR(2)
 }
 #endif
 
-
-/* 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 {
-  /* 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 */
-                               /* (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;
-
-
 #endif /* RTS_H */