diff options
Diffstat (limited to 'includes')
29 files changed, 434 insertions, 214 deletions
diff --git a/includes/Cmm.h b/includes/Cmm.h index 57d78ccaa5..7334eab8c1 100644 --- a/includes/Cmm.h +++ b/includes/Cmm.h @@ -161,9 +161,11 @@ /* TO_W_(n) converts n to W_ type from a smaller type */ #if SIZEOF_W == 4 +#define TO_I64(x) %sx64(x) #define TO_W_(x) %sx32(x) #define HALF_W_(x) %lobits16(x) #elif SIZEOF_W == 8 +#define TO_I64(x) (x) #define TO_W_(x) %sx64(x) #define HALF_W_(x) %lobits32(x) #endif @@ -209,7 +211,7 @@ if (predicate) { \ /*null*/; \ } else { \ - foreign "C" _assertFail(NULL, __LINE__) never returns; \ + foreign "C" _assertFail(__FILE__, __LINE__) never returns; \ } #else #define ASSERT(p) /* nothing */ @@ -615,10 +617,11 @@ #define mutArrPtrsCardWords(n) ROUNDUP_BYTES_TO_WDS(mutArrPtrCardUp(n)) #if defined(PROFILING) || (!defined(THREADED_RTS) && defined(DEBUG)) +#define OVERWRITING_CLOSURE_SIZE(c, size) foreign "C" overwritingClosureSize(c "ptr", size) #define OVERWRITING_CLOSURE(c) foreign "C" overwritingClosure(c "ptr") -#define OVERWRITING_CLOSURE_OFS(c,n) \ - foreign "C" overwritingClosureOfs(c "ptr", n) +#define OVERWRITING_CLOSURE_OFS(c,n) foreign "C" overwritingClosureOfs(c "ptr", n) #else +#define OVERWRITING_CLOSURE_SIZE(c, size) /* nothing */ #define OVERWRITING_CLOSURE(c) /* nothing */ #define OVERWRITING_CLOSURE_OFS(c,n) /* nothing */ #endif @@ -797,7 +800,6 @@ #define NO_TREC stg_NO_TREC_closure #define END_TSO_QUEUE stg_END_TSO_QUEUE_closure #define STM_AWOKEN stg_STM_AWOKEN_closure -#define END_INVARIANT_CHECK_QUEUE stg_END_INVARIANT_CHECK_QUEUE_closure #define recordMutableCap(p, gen) \ W_ __bd; \ diff --git a/includes/HsFFI.h b/includes/HsFFI.h index dea365cb65..84976474f5 100644 --- a/includes/HsFFI.h +++ b/includes/HsFFI.h @@ -101,8 +101,26 @@ extern void hs_thread_done (void); extern void hs_perform_gc (void); +// Lock the stable pointer table. The table must be unlocked +// again before calling any Haskell functions, even if those +// functions do not manipulate stable pointers. The Haskell +// garbage collector will not be able to run until this lock +// is released! It is also forbidden to call hs_free_fun_ptr +// or any stable pointer-related FFI functions other than +// hs_free_stable_ptr_unsafe while the table is locked. +extern void hs_lock_stable_ptr_table (void); + +// A deprecated synonym. extern void hs_lock_stable_tables (void); + +// Unlock the stable pointer table. +extern void hs_unlock_stable_ptr_table (void); + +// A deprecated synonym. extern void hs_unlock_stable_tables (void); + +// Free a stable pointer assuming that the stable pointer +// table is already locked. extern void hs_free_stable_ptr_unsafe (HsStablePtr sp); extern void hs_free_stable_ptr (HsStablePtr sp); diff --git a/includes/Rts.h b/includes/Rts.h index aca24e4f28..eb11536c19 100644 --- a/includes/Rts.h +++ b/includes/Rts.h @@ -175,6 +175,7 @@ void _assertFail(const char *filename, unsigned int linenum) #include "rts/storage/FunTypes.h" #include "rts/storage/InfoTables.h" #include "rts/storage/Closures.h" +#include "rts/storage/Heap.h" #include "rts/storage/ClosureTypes.h" #include "rts/storage/TSO.h" #include "stg/MiscClosures.h" /* InfoTables, closures etc. defined in the RTS */ @@ -197,11 +198,13 @@ void _assertFail(const char *filename, unsigned int linenum) #include "rts/Linker.h" #include "rts/Ticky.h" #include "rts/Timer.h" -#include "rts/Stable.h" +#include "rts/StablePtr.h" +#include "rts/StableName.h" #include "rts/TTY.h" #include "rts/Utils.h" #include "rts/PrimFloat.h" #include "rts/Main.h" +#include "rts/Profiling.h" #include "rts/StaticPtrTable.h" #include "rts/Libdw.h" #include "rts/LibdwPool.h" @@ -211,12 +214,6 @@ 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; -#if defined(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 reportStackOverflow(StgTSO* tso); void reportHeapOverflow(void); diff --git a/includes/RtsAPI.h b/includes/RtsAPI.h index 1ed5fb06f0..79c4d8ef53 100644 --- a/includes/RtsAPI.h +++ b/includes/RtsAPI.h @@ -53,6 +53,8 @@ typedef struct CapabilityPublic_ { typedef enum { RtsOptsNone, // +RTS causes an error + RtsOptsIgnore, // Ignore command line arguments + RtsOptsIgnoreAll, // Ignore command line and Environment arguments RtsOptsSafeOnly, // safe RTS options allowed; others cause an error RtsOptsAll // all RTS options allowed } RtsOptsEnabledEnum; @@ -100,6 +102,10 @@ typedef struct { // Called for every GC void (* gcDoneHook) (const struct GCDetails_ *stats); + + // Called when GC sync takes too long (+RTS --long-gc-sync=<time>) + void (* longGCSync) (uint32_t this_cap, Time time_ns); + void (* longGCSyncEnd) (Time time_ns); } RtsConfig; // Clients should start with defaultRtsConfig and then customise it. @@ -121,7 +127,9 @@ typedef struct GCDetails_ { uint32_t threads; // Number of bytes allocated since the previous GC uint64_t allocated_bytes; - // Total amount of live data in the heap (incliudes large + compact data) + // Total amount of live data in the heap (incliudes large + compact data). + // Updated after every GC. Data in uncollected generations (in minor GCs) + // are considered live. uint64_t live_bytes; // Total amount of live data in large objects uint64_t large_objects_bytes; @@ -159,7 +167,8 @@ typedef struct _RTSStats { uint32_t major_gcs; // Total bytes allocated uint64_t allocated_bytes; - // Maximum live data (including large objects + compact regions) + // Maximum live data (including large objects + compact regions) in the + // heap. Updated after a major GC. uint64_t max_live_bytes; // Maximum live data in large objects uint64_t max_large_objects_bytes; @@ -178,7 +187,7 @@ typedef struct _RTSStats { uint64_t par_copied_bytes; // Sum of par_max_copied_bytes across all parallel GCs uint64_t cumulative_par_max_copied_bytes; - // Sum of par_balanced_copied_byes across all parallel GCs. + // Sum of par_balanced_copied_byes across all parallel GCs. uint64_t cumulative_par_balanced_copied_bytes; // ----------------------------------- @@ -186,6 +195,10 @@ typedef struct _RTSStats { // (we use signed values here because due to inaccuracies in timers // the values can occasionally go slightly negative) + // Total CPU time used by the init phase + Time init_cpu_ns; + // Total elapsed time used by the init phase + Time init_elapsed_ns; // Total CPU time used by the mutator Time mutator_cpu_ns; // Total elapsed time used by the mutator @@ -204,6 +217,30 @@ typedef struct _RTSStats { GCDetails gc; + // ----------------------------------- + // Internal Counters + + // The number of times a GC thread spun on its 'gc_spin' lock. + // Will be zero if the rts was not built with PROF_SPIN + uint64_t gc_spin_spin; + // The number of times a GC thread yielded on its 'gc_spin' lock. + // Will be zero if the rts was not built with PROF_SPIN + uint64_t gc_spin_yield; + // The number of times a GC thread spun on its 'mut_spin' lock. + // Will be zero if the rts was not built with PROF_SPIN + uint64_t mut_spin_spin; + // The number of times a GC thread yielded on its 'mut_spin' lock. + // Will be zero if the rts was not built with PROF_SPIN + uint64_t mut_spin_yield; + // The number of times a GC thread has checked for work across all parallel + // GCs + uint64_t any_work; + // The number of times a GC thread has checked for work and found none + // across all parallel GCs + uint64_t no_work; + // The number of times a GC thread has iterated it's outer loop across all + // parallel GCs + uint64_t scav_find_work; } RTSStats; void getRTSStats (RTSStats *s); diff --git a/includes/Stg.h b/includes/Stg.h index f377e50d98..19069d8c1a 100644 --- a/includes/Stg.h +++ b/includes/Stg.h @@ -196,7 +196,7 @@ #define GNUC3_ATTRIBUTE(at) #endif -#if __GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 3 +#if !defined(DEBUG) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #define GNUC_ATTR_HOT __attribute__((hot)) #else #define GNUC_ATTR_HOT /* nothing */ @@ -204,6 +204,16 @@ #define STG_UNUSED GNUC3_ATTRIBUTE(__unused__) +/* Prevent functions from being optimized. + See Note [Windows Stack allocations] */ +#if defined(__clang__) +#define STG_NO_OPTIMIZE __attribute__((optnone)) +#elif defined(__GNUC__) || defined(__GNUG__) +#define STG_NO_OPTIMIZE __attribute__((optimize("O0"))) +#else +#define STG_NO_OPTIMIZE /* nothing */ +#endif + /* ----------------------------------------------------------------------------- Global type definitions -------------------------------------------------------------------------- */ diff --git a/includes/rts/Bytecodes.h b/includes/rts/Bytecodes.h index 6ca74bf36e..e5d55f694f 100644 --- a/includes/rts/Bytecodes.h +++ b/includes/rts/Bytecodes.h @@ -27,58 +27,70 @@ #define bci_PUSH_L 2 #define bci_PUSH_LL 3 #define bci_PUSH_LLL 4 -#define bci_PUSH_G 5 -#define bci_PUSH_ALTS 6 -#define bci_PUSH_ALTS_P 7 -#define bci_PUSH_ALTS_N 8 -#define bci_PUSH_ALTS_F 9 -#define bci_PUSH_ALTS_D 10 -#define bci_PUSH_ALTS_L 11 -#define bci_PUSH_ALTS_V 12 -#define bci_PUSH_UBX 13 -#define bci_PUSH_APPLY_N 14 -#define bci_PUSH_APPLY_F 15 -#define bci_PUSH_APPLY_D 16 -#define bci_PUSH_APPLY_L 17 -#define bci_PUSH_APPLY_V 18 -#define bci_PUSH_APPLY_P 19 -#define bci_PUSH_APPLY_PP 20 -#define bci_PUSH_APPLY_PPP 21 -#define bci_PUSH_APPLY_PPPP 22 -#define bci_PUSH_APPLY_PPPPP 23 -#define bci_PUSH_APPLY_PPPPPP 24 -/* #define bci_PUSH_APPLY_PPPPPPP 25 */ -#define bci_SLIDE 26 -#define bci_ALLOC_AP 27 -#define bci_ALLOC_AP_NOUPD 28 -#define bci_ALLOC_PAP 29 -#define bci_MKAP 30 -#define bci_MKPAP 31 -#define bci_UNPACK 32 -#define bci_PACK 33 -#define bci_TESTLT_I 34 -#define bci_TESTEQ_I 35 -#define bci_TESTLT_F 36 -#define bci_TESTEQ_F 37 -#define bci_TESTLT_D 38 -#define bci_TESTEQ_D 39 -#define bci_TESTLT_P 40 -#define bci_TESTEQ_P 41 -#define bci_CASEFAIL 42 -#define bci_JMP 43 -#define bci_CCALL 44 -#define bci_SWIZZLE 45 -#define bci_ENTER 46 -#define bci_RETURN 47 -#define bci_RETURN_P 48 -#define bci_RETURN_N 49 -#define bci_RETURN_F 50 -#define bci_RETURN_D 51 -#define bci_RETURN_L 52 -#define bci_RETURN_V 53 -#define bci_BRK_FUN 54 -#define bci_TESTLT_W 55 -#define bci_TESTEQ_W 56 +#define bci_PUSH8 5 +#define bci_PUSH16 6 +#define bci_PUSH32 7 +#define bci_PUSH8_W 8 +#define bci_PUSH16_W 9 +#define bci_PUSH32_W 10 +#define bci_PUSH_G 11 +#define bci_PUSH_ALTS 12 +#define bci_PUSH_ALTS_P 13 +#define bci_PUSH_ALTS_N 14 +#define bci_PUSH_ALTS_F 15 +#define bci_PUSH_ALTS_D 16 +#define bci_PUSH_ALTS_L 17 +#define bci_PUSH_ALTS_V 18 +#define bci_PUSH_PAD8 19 +#define bci_PUSH_PAD16 20 +#define bci_PUSH_PAD32 21 +#define bci_PUSH_UBX8 22 +#define bci_PUSH_UBX16 23 +#define bci_PUSH_UBX32 24 +#define bci_PUSH_UBX 25 +#define bci_PUSH_APPLY_N 26 +#define bci_PUSH_APPLY_F 27 +#define bci_PUSH_APPLY_D 28 +#define bci_PUSH_APPLY_L 29 +#define bci_PUSH_APPLY_V 30 +#define bci_PUSH_APPLY_P 31 +#define bci_PUSH_APPLY_PP 32 +#define bci_PUSH_APPLY_PPP 33 +#define bci_PUSH_APPLY_PPPP 34 +#define bci_PUSH_APPLY_PPPPP 35 +#define bci_PUSH_APPLY_PPPPPP 36 +/* #define bci_PUSH_APPLY_PPPPPPP 37 */ +#define bci_SLIDE 38 +#define bci_ALLOC_AP 39 +#define bci_ALLOC_AP_NOUPD 40 +#define bci_ALLOC_PAP 41 +#define bci_MKAP 42 +#define bci_MKPAP 43 +#define bci_UNPACK 44 +#define bci_PACK 45 +#define bci_TESTLT_I 46 +#define bci_TESTEQ_I 47 +#define bci_TESTLT_F 48 +#define bci_TESTEQ_F 49 +#define bci_TESTLT_D 50 +#define bci_TESTEQ_D 51 +#define bci_TESTLT_P 52 +#define bci_TESTEQ_P 53 +#define bci_CASEFAIL 54 +#define bci_JMP 55 +#define bci_CCALL 56 +#define bci_SWIZZLE 57 +#define bci_ENTER 58 +#define bci_RETURN 59 +#define bci_RETURN_P 60 +#define bci_RETURN_N 61 +#define bci_RETURN_F 62 +#define bci_RETURN_D 63 +#define bci_RETURN_L 64 +#define bci_RETURN_V 65 +#define bci_BRK_FUN 66 +#define bci_TESTLT_W 67 +#define bci_TESTEQ_W 68 /* If you need to go past 255 then you will run into the flags */ /* If you need to go below 0x0100 then you will run into the instructions */ diff --git a/includes/rts/Constants.h b/includes/rts/Constants.h index 27097bf45b..2f0ee5b10d 100644 --- a/includes/rts/Constants.h +++ b/includes/rts/Constants.h @@ -113,16 +113,33 @@ /* ----------------------------------------------------------------------------- How large is the stack frame saved by StgRun? world. Used in StgCRun.c. + + The size has to be enough to save the registers (see StgCRun) + plus padding if the result is not 16 byte aligned. + See the Note [Stack Alignment on X86] in StgCRun.c for details. + -------------------------------------------------------------------------- */ #if defined(x86_64_HOST_ARCH) # if defined(mingw32_HOST_OS) -/* 8 larger than necessary to make the alignment right*/ -# define STG_RUN_STACK_FRAME_SIZE 80 +# define STG_RUN_STACK_FRAME_SIZE 144 # else # define STG_RUN_STACK_FRAME_SIZE 48 # endif #endif +/* ----------------------------------------------------------------------------- + StgRun related labels shared between StgCRun.c and StgStartup.cmm. + -------------------------------------------------------------------------- */ + +#if defined(LEADING_UNDERSCORE) +#define STG_RUN "_StgRun" +#define STG_RUN_JMP _StgRunJmp +#define STG_RETURN "_StgReturn" +#else +#define STG_RUN "StgRun" +#define STG_RUN_JMP StgRunJmp +#define STG_RETURN "StgReturn" +#endif /* ----------------------------------------------------------------------------- How much Haskell stack space to reserve for the saving of registers diff --git a/includes/rts/EventLogFormat.h b/includes/rts/EventLogFormat.h index f839be04a1..63303c93b7 100644 --- a/includes/rts/EventLogFormat.h +++ b/includes/rts/EventLogFormat.h @@ -178,12 +178,15 @@ #define EVENT_HEAP_PROF_SAMPLE_BEGIN 162 #define EVENT_HEAP_PROF_SAMPLE_COST_CENTRE 163 #define EVENT_HEAP_PROF_SAMPLE_STRING 164 + +#define EVENT_USER_BINARY_MSG 181 + /* * The highest event code +1 that ghc itself emits. Note that some event * ranges higher than this are reserved but not currently emitted by ghc. * This must match the size of the EventDesc[] array in EventLog.c */ -#define NUM_GHC_EVENT_TAGS 165 +#define NUM_GHC_EVENT_TAGS 182 #if 0 /* DEPRECATED EVENTS: */ /* we don't actually need to record the thread, it's implicit */ @@ -231,6 +234,19 @@ #define CAPSET_TYPE_OSPROCESS 2 /* caps belong to the same OS process */ #define CAPSET_TYPE_CLOCKDOMAIN 3 /* caps share a local clock/time */ +/* + * Heap profile breakdown types. See EVENT_HEAP_PROF_BEGIN. + */ +typedef enum { + HEAP_PROF_BREAKDOWN_COST_CENTRE = 0x1, + HEAP_PROF_BREAKDOWN_MODULE, + HEAP_PROF_BREAKDOWN_CLOSURE_DESCR, + HEAP_PROF_BREAKDOWN_TYPE_DESCR, + HEAP_PROF_BREAKDOWN_RETAINER, + HEAP_PROF_BREAKDOWN_BIOGRAPHY, + HEAP_PROF_BREAKDOWN_CLOSURE_TYPE +} HeapProfBreakdown; + #if !defined(EVENTLOG_CONSTANTS_ONLY) typedef StgWord16 EventTypeNum; @@ -244,4 +260,5 @@ typedef StgWord16 EventCapsetType; /* types for EVENT_CAPSET_CREATE */ typedef StgWord64 EventTaskId; /* for EVENT_TASK_* */ typedef StgWord64 EventKernelThreadId; /* for EVENT_TASK_CREATE */ +#define EVENT_PAYLOAD_SIZE_MAX STG_WORD16_MAX #endif diff --git a/includes/rts/Flags.h b/includes/rts/Flags.h index 6700f9d95f..6487947749 100644 --- a/includes/rts/Flags.h +++ b/includes/rts/Flags.h @@ -65,6 +65,8 @@ typedef struct _GC_FLAGS { Time idleGCDelayTime; /* units: TIME_RESOLUTION */ bool doIdleGC; + Time longGCSync; /* units: TIME_RESOLUTION */ + StgWord heapBase; /* address to ask the OS for memory */ StgWord allocLimitGrace; /* units: *blocks* @@ -189,7 +191,11 @@ typedef struct _CONCURRENT_FLAGS { typedef struct _MISC_FLAGS { Time tickInterval; /* units: TIME_RESOLUTION */ bool install_signal_handlers; + bool install_seh_handlers; + bool generate_dump_file; + bool generate_stack_trace; bool machineReadable; + bool internalCounters; /* See Note [Internal Counter Stats] */ StgWord linkerMemBase; /* address to ask the OS for memory * for the linker, NULL ==> off */ } MISC_FLAGS; @@ -263,7 +269,6 @@ extern RTS_FLAGS RtsFlags; #define STATS_FILENAME_MAXLEN 128 #define GR_FILENAME_FMT "%0.124s.gr" -#define GR_FILENAME_FMT_GUM "%0.120s.%03d.%s" #define HP_FILENAME_FMT "%0.124s.hp" #define LIFE_FILENAME_FMT "%0.122s.life" #define PROF_FILENAME_FMT "%0.122s.prof" diff --git a/includes/rts/Libdw.h b/includes/rts/Libdw.h index 391847552e..d7bd55d06e 100644 --- a/includes/rts/Libdw.h +++ b/includes/rts/Libdw.h @@ -8,6 +8,9 @@ #pragma once +// for FILE +#include <stdio.h> + // Chunk capacity // This is rather arbitrary #define BACKTRACE_CHUNK_SZ 256 @@ -89,3 +92,6 @@ Backtrace *libdwGetBacktrace(LibdwSession *session); /* Lookup Location information for the given address. * Returns 0 if successful, 1 if address could not be found. */ int libdwLookupLocation(LibdwSession *session, Location *loc, StgPtr pc); + +/* Pretty-print a backtrace to the given FILE */ +void libdwPrintBacktrace(LibdwSession *session, FILE *file, Backtrace *bt); diff --git a/includes/rts/Linker.h b/includes/rts/Linker.h index 793195b3ab..298dc6a366 100644 --- a/includes/rts/Linker.h +++ b/includes/rts/Linker.h @@ -47,6 +47,20 @@ HsInt insertSymbol(pathchar* obj_name, char* key, void* data); /* lookup a symbol in the hash table */ void *lookupSymbol( char *lbl ); +/* See Linker.c Note [runtime-linker-phases] */ +typedef enum { + OBJECT_LOADED, + OBJECT_NEEDED, + OBJECT_RESOLVED, + OBJECT_UNLOADED, + OBJECT_DONT_RESOLVE, + OBJECT_NOT_LOADED /* The object was either never loaded or has been + fully unloaded */ +} OStatus; + +/* check object load status */ +OStatus getObjectLoadStatus( pathchar *path ); + /* delete an object from the pool */ HsInt unloadObj( pathchar *path ); diff --git a/includes/rts/Messages.h b/includes/rts/Messages.h index 2a6a84b821..c3199b23d9 100644 --- a/includes/rts/Messages.h +++ b/includes/rts/Messages.h @@ -40,7 +40,8 @@ * expected to return. */ void barf(const char *s, ...) - GNUC3_ATTRIBUTE(__noreturn__); + GNUC3_ATTRIBUTE(__noreturn__) + GNUC3_ATTRIBUTE(format(PRINTF, 1, 2)); void vbarf(const char *s, va_list ap) GNUC3_ATTRIBUTE(__noreturn__); diff --git a/includes/rts/OSThreads.h b/includes/rts/OSThreads.h index abb3120088..d2c4a6a54e 100644 --- a/includes/rts/OSThreads.h +++ b/includes/rts/OSThreads.h @@ -166,7 +166,7 @@ extern OSThreadId osThreadId ( void ); extern void shutdownThread ( void ) GNUC3_ATTRIBUTE(__noreturn__); extern void yieldThread ( void ); -typedef void OSThreadProcAttr OSThreadProc(void *); +typedef void* OSThreadProcAttr OSThreadProc(void *); extern int createOSThread ( OSThreadId* tid, char *name, OSThreadProc *startProc, void *param); diff --git a/includes/rts/Profiling.h b/includes/rts/Profiling.h new file mode 100644 index 0000000000..f1dafb78f5 --- /dev/null +++ b/includes/rts/Profiling.h @@ -0,0 +1,17 @@ +/* ----------------------------------------------------------------------------- + * + * (c) The GHC Team, 2017-2018 + * + * Cost-centre profiling API + * + * Do not #include this file directly: #include "Rts.h" instead. + * + * To understand the structure of the RTS headers, see the wiki: + * http://ghc.haskell.org/trac/ghc/wiki/Commentary/SourceTree/Includes + * + * -------------------------------------------------------------------------- */ + +#pragma once + +void registerCcList(CostCentre **cc_list); +void registerCcsList(CostCentreStack **cc_list); diff --git a/includes/rts/SpinLock.h b/includes/rts/SpinLock.h index 6530a3a2f0..1dca02f795 100644 --- a/includes/rts/SpinLock.h +++ b/includes/rts/SpinLock.h @@ -27,7 +27,8 @@ typedef struct SpinLock_ { StgWord lock; - StgWord64 spin; // DEBUG version counts how much it spins + StgWord64 spin; // incremented every time we spin in ACQUIRE_SPIN_LOCK + StgWord64 yield; // incremented every time we yield in ACQUIRE_SPIN_LOCK } SpinLock; #else typedef StgWord SpinLock; @@ -49,6 +50,7 @@ INLINE_HEADER void ACQUIRE_SPIN_LOCK(SpinLock * p) p->spin++; busy_wait_nop(); } + p->yield++; yieldThread(); } while (1); } @@ -66,6 +68,7 @@ INLINE_HEADER void initSpinLock(SpinLock * p) write_barrier(); p->lock = 1; p->spin = 0; + p->yield = 0; } #else diff --git a/includes/rts/StableName.h b/includes/rts/StableName.h new file mode 100644 index 0000000000..d43ffcb2f6 --- /dev/null +++ b/includes/rts/StableName.h @@ -0,0 +1,32 @@ +/* ----------------------------------------------------------------------------- + * + * (c) The GHC Team, 1998-2009 + * + * Stable Names + * + * Do not #include this file directly: #include "Rts.h" instead. + * + * To understand the structure of the RTS headers, see the wiki: + * http://ghc.haskell.org/trac/ghc/wiki/Commentary/SourceTree/Includes + * + * ---------------------------------------------------------------------------*/ + +#pragma once + +/* ----------------------------------------------------------------------------- + PRIVATE from here. + -------------------------------------------------------------------------- */ + +typedef struct { + StgPtr addr; // Haskell object when entry is in use, next free + // entry (NULL when this is the last free entry) + // otherwise. May be NULL temporarily during GC (when + // pointee dies). + + StgPtr old; // Old Haskell object, used during GC + + StgClosure *sn_obj; // The StableName object, or NULL when the entry is + // free +} snEntry; + +extern DLL_IMPORT_RTS snEntry *stable_name_table; diff --git a/includes/rts/Stable.h b/includes/rts/StablePtr.h index 75fcf4f7eb..0d3642fbfe 100644 --- a/includes/rts/Stable.h +++ b/includes/rts/StablePtr.h @@ -21,16 +21,11 @@ StgStablePtr getStablePtr (StgPtr p); -------------------------------------------------------------------------- */ typedef struct { - StgPtr addr; /* Haskell object, free list, or NULL */ - StgPtr old; /* old Haskell object, used during GC */ - StgClosure *sn_obj; /* the StableName object (or NULL) */ -} snEntry; - -typedef struct { - StgPtr addr; + StgPtr addr; // Haskell object when entry is in use, next free + // entry (NULL when this is the last free entry) + // otherwise. } spEntry; -extern DLL_IMPORT_RTS snEntry *stable_name_table; extern DLL_IMPORT_RTS spEntry *stable_ptr_table; EXTERN_INLINE diff --git a/includes/rts/Threads.h b/includes/rts/Threads.h index fceacdc75d..f72f5ed121 100644 --- a/includes/rts/Threads.h +++ b/includes/rts/Threads.h @@ -43,8 +43,6 @@ StgRegTable * resumeThread (void *); // int cmp_thread (StgPtr tso1, StgPtr tso2); int rts_getThreadId (StgPtr tso); -HsInt64 rts_getThreadAllocationCounter (StgPtr tso); -void rts_setThreadAllocationCounter (StgPtr tso, HsInt64 i); void rts_enableThreadAllocationLimit (StgPtr tso); void rts_disableThreadAllocationLimit (StgPtr tso); diff --git a/includes/rts/Time.h b/includes/rts/Time.h index 5fa166e125..12c6d2767d 100644 --- a/includes/rts/Time.h +++ b/includes/rts/Time.h @@ -21,8 +21,10 @@ typedef int64_t Time; #if TIME_RESOLUTION == 1000000000 // I'm being lazy, but it's awkward to define fully general versions of these +#define TimeToMS(t) ((t) / 1000000) #define TimeToUS(t) ((t) / 1000) #define TimeToNS(t) (t) +#define MSToTime(t) ((Time)(t) * 1000000) #define USToTime(t) ((Time)(t) * 1000) #define NSToTime(t) ((Time)(t)) #else @@ -38,3 +40,5 @@ INLINE_HEADER Time fsecondsToTime (double t) { return (Time)(t * TIME_RESOLUTION); } + +Time getProcessElapsedTime (void); diff --git a/includes/rts/storage/Block.h b/includes/rts/storage/Block.h index c1d251856a..ecd6bf5dd8 100644 --- a/includes/rts/storage/Block.h +++ b/includes/rts/storage/Block.h @@ -143,8 +143,6 @@ typedef struct bdescr_ { #define BF_PINNED 4 /* Block is to be marked, not copied */ #define BF_MARKED 8 -/* Block is free, and on the free list (TODO: is this used?) */ -#define BF_FREE 16 /* Block is executable */ #define BF_EXEC 32 /* Block contains only a small amount of live data */ @@ -340,13 +338,4 @@ round_to_mblocks(StgWord words) return words; } -INLINE_HEADER StgWord -round_up_to_mblocks(StgWord words) -{ - words += FIRST_BLOCK_OFF/sizeof(W_); - words = ((words / MBLOCK_SIZE_W) + 1) * MBLOCK_SIZE_W; - words -= FIRST_BLOCK_OFF/sizeof(W_); - return words; -} - #endif /* !CMINUSMINUS */ diff --git a/includes/rts/storage/ClosureMacros.h b/includes/rts/storage/ClosureMacros.h index be1569ba8e..e52059e790 100644 --- a/includes/rts/storage/ClosureMacros.h +++ b/includes/rts/storage/ClosureMacros.h @@ -109,7 +109,7 @@ INLINE_HEADER const StgConInfoTable *get_con_itbl(const StgClosure *c) INLINE_HEADER StgHalfWord GET_TAG(const StgClosure *con) { - return get_itbl(con)->srt_bitmap; + return get_itbl(con)->srt; } /* ----------------------------------------------------------------------------- @@ -172,7 +172,6 @@ INLINE_HEADER StgHalfWord GET_TAG(const StgClosure *con) -------------------------------------------------------------------------- */ /* These are hard-coded. */ -#define FUN_STATIC_LINK(p) (&(p)->payload[0]) #define THUNK_STATIC_LINK(p) (&(p)->payload[1]) #define IND_STATIC_LINK(p) (&(p)->payload[1]) @@ -182,8 +181,6 @@ STATIC_LINK(const StgInfoTable *info, StgClosure *p) switch (info->type) { case THUNK_STATIC: return THUNK_STATIC_LINK(p); - case FUN_STATIC: - return FUN_STATIC_LINK(p); case IND_STATIC: return IND_STATIC_LINK(p); default: @@ -404,13 +401,13 @@ closure_sizeW_ (const StgClosure *p, const StgInfoTable *info) return arr_words_sizeW((StgArrBytes *)p); case MUT_ARR_PTRS_CLEAN: case MUT_ARR_PTRS_DIRTY: - case MUT_ARR_PTRS_FROZEN: - case MUT_ARR_PTRS_FROZEN0: + case MUT_ARR_PTRS_FROZEN_CLEAN: + case MUT_ARR_PTRS_FROZEN_DIRTY: return mut_arr_ptrs_sizeW((StgMutArrPtrs*)p); case SMALL_MUT_ARR_PTRS_CLEAN: case SMALL_MUT_ARR_PTRS_DIRTY: - case SMALL_MUT_ARR_PTRS_FROZEN: - case SMALL_MUT_ARR_PTRS_FROZEN0: + case SMALL_MUT_ARR_PTRS_FROZEN_CLEAN: + case SMALL_MUT_ARR_PTRS_FROZEN_DIRTY: return small_mut_arr_ptrs_sizeW((StgSmallMutArrPtrs*)p); case TSO: return sizeofW(StgTSO); @@ -533,8 +530,7 @@ INLINE_HEADER StgWord8 *mutArrPtrsCard (StgMutArrPtrs *a, W_ n) #if ZERO_SLOP_FOR_LDV_PROF || ZERO_SLOP_FOR_SANITY_CHECK #define OVERWRITING_CLOSURE(c) overwritingClosure(c) -#define OVERWRITING_CLOSURE_OFS(c,n) \ - overwritingClosureOfs(c,n) +#define OVERWRITING_CLOSURE_OFS(c,n) overwritingClosureOfs(c,n) #else #define OVERWRITING_CLOSURE(c) /* nothing */ #define OVERWRITING_CLOSURE_OFS(c,n) /* nothing */ @@ -544,28 +540,32 @@ INLINE_HEADER StgWord8 *mutArrPtrsCard (StgMutArrPtrs *a, W_ n) void LDV_recordDead (const StgClosure *c, uint32_t size); #endif -EXTERN_INLINE void overwritingClosure (StgClosure *p); -EXTERN_INLINE void overwritingClosure (StgClosure *p) +EXTERN_INLINE void overwritingClosure_ (StgClosure *p, + uint32_t offset /* in words */, + uint32_t size /* closure size, in words */); +EXTERN_INLINE void overwritingClosure_ (StgClosure *p, uint32_t offset, uint32_t size) { - uint32_t size, i; - #if ZERO_SLOP_FOR_LDV_PROF && !ZERO_SLOP_FOR_SANITY_CHECK // see Note [zeroing slop], also #8402 if (era <= 0) return; #endif - size = closure_sizeW(p); - // For LDV profiling, we need to record the closure as dead #if defined(PROFILING) LDV_recordDead(p, size); #endif - for (i = 0; i < size - sizeofW(StgThunkHeader); i++) { - ((StgThunk *)(p))->payload[i] = 0; + for (uint32_t i = offset; i < size; i++) { + ((StgWord *)p)[i] = 0; } } +EXTERN_INLINE void overwritingClosure (StgClosure *p); +EXTERN_INLINE void overwritingClosure (StgClosure *p) +{ + overwritingClosure_(p, sizeofW(StgThunkHeader), closure_sizeW(p)); +} + // Version of 'overwritingClosure' which overwrites only a suffix of a // closure. The offset is expressed in words relative to 'p' and shall // be less than or equal to closure_sizeW(p), and usually at least as @@ -576,22 +576,12 @@ EXTERN_INLINE void overwritingClosure (StgClosure *p) EXTERN_INLINE void overwritingClosureOfs (StgClosure *p, uint32_t offset); EXTERN_INLINE void overwritingClosureOfs (StgClosure *p, uint32_t offset) { - uint32_t size, i; - -#if ZERO_SLOP_FOR_LDV_PROF && !ZERO_SLOP_FOR_SANITY_CHECK - // see Note [zeroing slop], also #8402 - if (era <= 0) return; -#endif - - size = closure_sizeW(p); - - ASSERT(offset <= size); - - // For LDV profiling, we need to record the closure as dead -#if defined(PROFILING) - LDV_recordDead(p, size); -#endif + overwritingClosure_(p, offset, closure_sizeW(p)); +} - for (i = offset; i < size; i++) - ((StgWord *)p)[i] = 0; +// Version of 'overwritingClosure' which takes closure size as argument. +EXTERN_INLINE void overwritingClosureSize (StgClosure *p, uint32_t size /* in words */); +EXTERN_INLINE void overwritingClosureSize (StgClosure *p, uint32_t size) +{ + overwritingClosure_(p, sizeofW(StgThunkHeader), size); } diff --git a/includes/rts/storage/ClosureTypes.h b/includes/rts/storage/ClosureTypes.h index 68cc919257..85dc1a0ce4 100644 --- a/includes/rts/storage/ClosureTypes.h +++ b/includes/rts/storage/ClosureTypes.h @@ -1,5 +1,5 @@ /* ---------------------------------------------------------------------------- - * + * * (c) The GHC Team, 1998-2005 * * Closure Type Constants: out here because the native code generator @@ -9,11 +9,13 @@ #pragma once -/* +/* * WARNING WARNING WARNING * - * If you add or delete any closure types, don't forget to update - * the closure flags table in rts/ClosureFlags.c. + * If you add or delete any closure types, don't forget to update the following, + * - the closure flags table in rts/ClosureFlags.c + * - isRetainer in rts/RetainerProfile.c + * - the closure_type_names list in rts/Printer.c */ /* Object tag 0 raises an internal error */ @@ -62,8 +64,8 @@ #define ARR_WORDS 42 #define MUT_ARR_PTRS_CLEAN 43 #define MUT_ARR_PTRS_DIRTY 44 -#define MUT_ARR_PTRS_FROZEN0 45 -#define MUT_ARR_PTRS_FROZEN 46 +#define MUT_ARR_PTRS_FROZEN_DIRTY 45 +#define MUT_ARR_PTRS_FROZEN_CLEAN 46 #define MUT_VAR_CLEAN 47 #define MUT_VAR_DIRTY 48 #define WEAK 49 @@ -78,7 +80,7 @@ #define WHITEHOLE 58 #define SMALL_MUT_ARR_PTRS_CLEAN 59 #define SMALL_MUT_ARR_PTRS_DIRTY 60 -#define SMALL_MUT_ARR_PTRS_FROZEN0 61 -#define SMALL_MUT_ARR_PTRS_FROZEN 62 +#define SMALL_MUT_ARR_PTRS_FROZEN_DIRTY 61 +#define SMALL_MUT_ARR_PTRS_FROZEN_CLEAN 62 #define COMPACT_NFDATA 63 #define N_CLOSURE_TYPES 64 diff --git a/includes/rts/storage/Closures.h b/includes/rts/storage/Closures.h index af89507f97..15231e01f0 100644 --- a/includes/rts/storage/Closures.h +++ b/includes/rts/storage/Closures.h @@ -122,8 +122,10 @@ typedef struct { typedef struct { StgHeader header; StgClosure *indirectee; - StgClosure *static_link; + StgClosure *static_link; // See Note [CAF lists] const StgInfoTable *saved_info; + // `saved_info` also used for the link field for `debug_caf_list`, + // see `newCAF` and Note [CAF lists] in rts/sm/Storage.h. } StgIndStatic; typedef struct StgBlockingQueue_ { @@ -306,7 +308,7 @@ typedef struct StgTRecHeader_ StgTRecHeader; typedef struct StgTVarWatchQueue_ { StgHeader header; - StgClosure *closure; // StgTSO or StgAtomicInvariant + StgClosure *closure; // StgTSO struct StgTVarWatchQueue_ *next_queue_entry; struct StgTVarWatchQueue_ *prev_queue_entry; } StgTVarWatchQueue; @@ -318,13 +320,6 @@ typedef struct { StgInt volatile num_updates; } StgTVar; -typedef struct { - StgHeader header; - StgClosure *code; - StgTRecHeader *last_execution; - StgWord lock; -} StgAtomicInvariant; - /* new_value == expected_value for read-only accesses */ /* new_value is a StgTVarWatchQueue entry when trec in state TREC_WAITING */ typedef struct { @@ -353,25 +348,16 @@ typedef enum { TREC_WAITING, /* Transaction currently waiting */ } TRecState; -typedef struct StgInvariantCheckQueue_ { - StgHeader header; - StgAtomicInvariant *invariant; - StgTRecHeader *my_execution; - struct StgInvariantCheckQueue_ *next_queue_entry; -} StgInvariantCheckQueue; - struct StgTRecHeader_ { StgHeader header; struct StgTRecHeader_ *enclosing_trec; StgTRecChunk *current_chunk; - StgInvariantCheckQueue *invariants_to_check; TRecState state; }; typedef struct { StgHeader header; StgClosure *code; - StgTVarWatchQueue *next_invariant_to_check; StgClosure *result; } StgAtomicallyFrame; diff --git a/includes/rts/storage/GC.h b/includes/rts/storage/GC.h index 387bd260d3..1571975852 100644 --- a/includes/rts/storage/GC.h +++ b/includes/rts/storage/GC.h @@ -109,7 +109,12 @@ typedef struct generation_ { memcount n_compact_blocks_in_import; // no. of blocks used by compacts // being imported - memcount max_blocks; // max blocks + // Max blocks to allocate in this generation before collecting it. Collect + // this generation when + // + // n_blocks + n_large_blocks + n_compact_blocks > max_blocks + // + memcount max_blocks; StgTSO * threads; // threads in this gen // linked via global_link @@ -120,7 +125,7 @@ typedef struct generation_ { // stats information uint32_t collections; uint32_t par_collections; - uint32_t failed_promotions; + uint32_t failed_promotions; // Currently unused // ------------------------------------ // Fields below are used during GC only @@ -184,8 +189,9 @@ extern generation * oldest_gen; -------------------------------------------------------------------------- */ -StgPtr allocate ( Capability *cap, W_ n ); -StgPtr allocatePinned ( Capability *cap, W_ n ); +StgPtr allocate ( Capability *cap, W_ n ); +StgPtr allocateMightFail ( Capability *cap, W_ n ); +StgPtr allocatePinned ( Capability *cap, W_ n ); /* memory allocator for executable memory */ typedef void* AdjustorWritable; diff --git a/includes/rts/storage/Heap.h b/includes/rts/storage/Heap.h new file mode 100644 index 0000000000..2e908279bf --- /dev/null +++ b/includes/rts/storage/Heap.h @@ -0,0 +1,18 @@ +/* ----------------------------------------------------------------------------- + * + * (c) The University of Glasgow 2006-2017 + * + * Introspection into GHC's heap representation + * + * ---------------------------------------------------------------------------*/ + +#pragma once + +#include "rts/storage/Closures.h" + +StgMutArrPtrs *heap_view_closurePtrs(Capability *cap, StgClosure *closure); + +void heap_view_closure_ptrs_in_pap_payload(StgClosure *ptrs[], StgWord *nptrs + , StgClosure *fun, StgClosure **payload, StgWord size); + +StgWord heap_view_closureSize(StgClosure *closure); diff --git a/includes/rts/storage/InfoTables.h b/includes/rts/storage/InfoTables.h index c621e5e749..db50d1613b 100644 --- a/includes/rts/storage/InfoTables.h +++ b/includes/rts/storage/InfoTables.h @@ -124,31 +124,6 @@ typedef struct { StgWord bitmap[]; } StgLargeBitmap; -/* ----------------------------------------------------------------------------- - SRTs (Static Reference Tables) - - These tables are used to keep track of the static objects referred - to by the code for a closure or stack frame, so that we can follow - static data references from code and thus accurately - garbage-collect CAFs. - -------------------------------------------------------------------------- */ - -/* An SRT is just an array of closure pointers: */ -typedef StgClosure* StgSRT[]; - -/* - * Each info table refers to some subset of the closure pointers in an - * SRT. It does this using a pair of an StgSRT pointer and a - * half-word bitmap. If the half-word bitmap isn't large enough, then - * we fall back to a large SRT, including an unbounded bitmap. If the - * half-word bitmap is set to all ones (0xffff), then the StgSRT - * pointer instead points to an StgLargeSRT: - */ -typedef struct StgLargeSRT_ { - StgSRT *srt; - StgLargeBitmap l; -} StgLargeSRT; - /* ---------------------------------------------------------------------------- Info Tables ------------------------------------------------------------------------- */ @@ -178,6 +153,24 @@ typedef union { } StgClosureInfo; +#if defined(x86_64_TARGET_ARCH) && defined(TABLES_NEXT_TO_CODE) +// On x86_64 we can fit a pointer offset in half a word, so put the SRT offset +// in the info->srt field directly. +// +// See the section "Referring to an SRT from the info table" in +// Note [SRTs] in CmmBuildInfoTables.hs +#define USE_INLINE_SRT_FIELD +#endif + +#if defined(USE_INLINE_SRT_FIELD) +// offset to the SRT / closure, or zero if there's no SRT +typedef StgHalfInt StgSRTField; +#else +// non-zero if there is an SRT, the offset is in the optional srt field. +typedef StgHalfWord StgSRTField; +#endif + + /* * The "standard" part of an info table. Every info table has this bit. */ @@ -194,11 +187,14 @@ typedef struct StgInfoTable_ { StgClosureInfo layout; /* closure layout info (one word) */ StgHalfWord type; /* closure type */ - StgHalfWord srt_bitmap; + StgSRTField srt; /* In a CONSTR: - the constructor tag In a FUN/THUNK - - a bitmap of SRT entries + - if USE_INLINE_SRT_FIELD + - offset to the SRT (or zero if no SRT) + - otherwise + - non-zero if there is an SRT, offset is in srt_offset */ #if defined(TABLES_NEXT_TO_CODE) @@ -217,7 +213,7 @@ typedef struct StgInfoTable_ { and bitmap fields may be left out (they are at the end, so omitting them doesn't affect the layout). - - If srt_bitmap (in the std info table part) is zero, then the srt + - If has_srt (in the std info table part) is zero, then the srt field needn't be set. This only applies if the slow_apply and bitmap fields have also been omitted. -------------------------------------------------------------------------- */ @@ -239,7 +235,9 @@ typedef struct StgFunInfoExtraRev_ { StgWord bitmap; OFFSET_FIELD(bitmap_offset); /* arg ptr/nonptr bitmap */ } b; - OFFSET_FIELD(srt_offset); /* pointer to the SRT table */ +#if !defined(USE_INLINE_SRT_FIELD) + OFFSET_FIELD(srt_offset); /* pointer to the SRT closure */ +#endif StgHalfWord fun_type; /* function type */ StgHalfWord arity; /* function arity */ } StgFunInfoExtraRev; @@ -247,7 +245,7 @@ typedef struct StgFunInfoExtraRev_ { typedef struct StgFunInfoExtraFwd_ { StgHalfWord fun_type; /* function type */ StgHalfWord arity; /* function arity */ - StgSRT *srt; /* pointer to the SRT table */ + StgClosure *srt; /* pointer to the SRT closure */ union { /* union for compat. with TABLES_NEXT_TO_CODE version */ StgWord bitmap; /* arg ptr/nonptr bitmap */ } b; @@ -273,16 +271,18 @@ extern const StgWord stg_arg_bitmaps[]; /* * When info tables are laid out backwards, we can omit the SRT - * pointer iff srt_bitmap is zero. + * pointer iff has_srt is zero. */ typedef struct { #if defined(TABLES_NEXT_TO_CODE) - OFFSET_FIELD(srt_offset); /* offset to the SRT table */ +#if !defined(USE_INLINE_SRT_FIELD) + OFFSET_FIELD(srt_offset); /* offset to the SRT closure */ +#endif StgInfoTable i; #else StgInfoTable i; - StgSRT *srt; /* pointer to the SRT table */ + StgClosure *srt; /* pointer to the SRT closure */ #endif } StgRetInfoTable; @@ -292,20 +292,18 @@ typedef struct { /* * When info tables are laid out backwards, we can omit the SRT - * pointer iff srt_bitmap is zero. + * pointer iff has_srt is zero. */ typedef struct StgThunkInfoTable_ { -#if !defined(TABLES_NEXT_TO_CODE) - StgInfoTable i; -#endif #if defined(TABLES_NEXT_TO_CODE) - OFFSET_FIELD(srt_offset); /* offset to the SRT table */ -#else - StgSRT *srt; /* pointer to the SRT table */ +#if !defined(USE_INLINE_SRT_FIELD) + OFFSET_FIELD(srt_offset); /* offset to the SRT closure */ #endif -#if defined(TABLES_NEXT_TO_CODE) StgInfoTable i; +#else + StgInfoTable i; + StgClosure *srt; /* pointer to the SRT closure */ #endif } StgThunkInfoTable; @@ -340,8 +338,14 @@ typedef struct StgConInfoTable_ { * info must be a Stg[Ret|Thunk]InfoTable* (an info table that has a SRT) */ #if defined(TABLES_NEXT_TO_CODE) -#define GET_SRT(info) ((StgSRT*) (((StgWord) ((info)+1)) + (info)->srt_offset)) +#if defined(x86_64_TARGET_ARCH) +#define GET_SRT(info) \ + ((StgClosure*) (((StgWord) ((info)+1)) + (info)->i.srt)) #else +#define GET_SRT(info) \ + ((StgClosure*) (((StgWord) ((info)+1)) + (info)->srt_offset)) +#endif +#else // !TABLES_NEXT_TO_CODE #define GET_SRT(info) ((info)->srt) #endif @@ -361,7 +365,13 @@ typedef struct StgConInfoTable_ { * info must be a StgFunInfoTable* */ #if defined(TABLES_NEXT_TO_CODE) -#define GET_FUN_SRT(info) ((StgSRT*) (((StgWord) ((info)+1)) + (info)->f.srt_offset)) +#if defined(x86_64_TARGET_ARCH) +#define GET_FUN_SRT(info) \ + ((StgClosure*) (((StgWord) ((info)+1)) + (info)->i.srt)) +#else +#define GET_FUN_SRT(info) \ + ((StgClosure*) (((StgWord) ((info)+1)) + (info)->f.srt_offset)) +#endif #else #define GET_FUN_SRT(info) ((info)->f.srt) #endif diff --git a/includes/stg/MiscClosures.h b/includes/stg/MiscClosures.h index 76cfbd6c8c..c13b5ff052 100644 --- a/includes/stg/MiscClosures.h +++ b/includes/stg/MiscClosures.h @@ -116,12 +116,12 @@ RTS_ENTRY(stg_ARR_WORDS); RTS_ENTRY(stg_MUT_ARR_WORDS); RTS_ENTRY(stg_MUT_ARR_PTRS_CLEAN); RTS_ENTRY(stg_MUT_ARR_PTRS_DIRTY); -RTS_ENTRY(stg_MUT_ARR_PTRS_FROZEN); -RTS_ENTRY(stg_MUT_ARR_PTRS_FROZEN0); +RTS_ENTRY(stg_MUT_ARR_PTRS_FROZEN_CLEAN); +RTS_ENTRY(stg_MUT_ARR_PTRS_FROZEN_DIRTY); RTS_ENTRY(stg_SMALL_MUT_ARR_PTRS_CLEAN); RTS_ENTRY(stg_SMALL_MUT_ARR_PTRS_DIRTY); -RTS_ENTRY(stg_SMALL_MUT_ARR_PTRS_FROZEN); -RTS_ENTRY(stg_SMALL_MUT_ARR_PTRS_FROZEN0); +RTS_ENTRY(stg_SMALL_MUT_ARR_PTRS_FROZEN_CLEAN); +RTS_ENTRY(stg_SMALL_MUT_ARR_PTRS_FROZEN_DIRTY); RTS_ENTRY(stg_MUT_VAR_CLEAN); RTS_ENTRY(stg_MUT_VAR_DIRTY); RTS_ENTRY(stg_END_TSO_QUEUE); @@ -143,16 +143,29 @@ RTS_ENTRY(stg_raise); RTS_ENTRY(stg_raise_ret); RTS_ENTRY(stg_atomically); RTS_ENTRY(stg_TVAR_WATCH_QUEUE); -RTS_ENTRY(stg_INVARIANT_CHECK_QUEUE); -RTS_ENTRY(stg_ATOMIC_INVARIANT); RTS_ENTRY(stg_TREC_CHUNK); RTS_ENTRY(stg_TREC_HEADER); RTS_ENTRY(stg_END_STM_WATCH_QUEUE); -RTS_ENTRY(stg_END_INVARIANT_CHECK_QUEUE); RTS_ENTRY(stg_END_STM_CHUNK_LIST); RTS_ENTRY(stg_NO_TREC); RTS_ENTRY(stg_COMPACT_NFDATA_CLEAN); RTS_ENTRY(stg_COMPACT_NFDATA_DIRTY); +RTS_ENTRY(stg_SRT_1); +RTS_ENTRY(stg_SRT_2); +RTS_ENTRY(stg_SRT_3); +RTS_ENTRY(stg_SRT_4); +RTS_ENTRY(stg_SRT_5); +RTS_ENTRY(stg_SRT_6); +RTS_ENTRY(stg_SRT_7); +RTS_ENTRY(stg_SRT_8); +RTS_ENTRY(stg_SRT_9); +RTS_ENTRY(stg_SRT_10); +RTS_ENTRY(stg_SRT_11); +RTS_ENTRY(stg_SRT_12); +RTS_ENTRY(stg_SRT_13); +RTS_ENTRY(stg_SRT_14); +RTS_ENTRY(stg_SRT_15); +RTS_ENTRY(stg_SRT_16); /* closures */ @@ -163,7 +176,6 @@ RTS_CLOSURE(stg_dummy_ret_closure); RTS_CLOSURE(stg_forceIO_closure); RTS_CLOSURE(stg_END_STM_WATCH_QUEUE_closure); -RTS_CLOSURE(stg_END_INVARIANT_CHECK_QUEUE_closure); RTS_CLOSURE(stg_END_STM_CHUNK_LIST_closure); RTS_CLOSURE(stg_NO_TREC_closure); @@ -378,7 +390,8 @@ RTS_FUN_DECL(stg_copySmallMutableArrayzh); RTS_FUN_DECL(stg_casSmallArrayzh); RTS_FUN_DECL(stg_newMutVarzh); -RTS_FUN_DECL(stg_atomicModifyMutVarzh); +RTS_FUN_DECL(stg_atomicModifyMutVar2zh); +RTS_FUN_DECL(stg_atomicModifyMutVarzuzh); RTS_FUN_DECL(stg_casMutVarzh); RTS_FUN_DECL(stg_isEmptyMVarzh); @@ -455,7 +468,6 @@ RTS_FUN_DECL(stg_newTVarzh); RTS_FUN_DECL(stg_readTVarzh); RTS_FUN_DECL(stg_readTVarIOzh); RTS_FUN_DECL(stg_writeTVarzh); -RTS_FUN_DECL(stg_checkzh); RTS_FUN_DECL(stg_unpackClosurezh); RTS_FUN_DECL(stg_getApStackValzh); @@ -467,7 +479,11 @@ RTS_FUN_DECL(stg_noDuplicatezh); RTS_FUN_DECL(stg_traceCcszh); RTS_FUN_DECL(stg_clearCCSzh); RTS_FUN_DECL(stg_traceEventzh); +RTS_FUN_DECL(stg_traceBinaryEventzh); RTS_FUN_DECL(stg_traceMarkerzh); +RTS_FUN_DECL(stg_getThreadAllocationCounterzh); +RTS_FUN_DECL(stg_setThreadAllocationCounterzh); + /* Other misc stuff */ // See wiki:Commentary/Compiler/Backends/PprC#Prototypes @@ -498,8 +514,10 @@ extern StgWord RTS_VAR(atomic_modify_mutvar_mutex); // RtsFlags extern StgWord RTS_VAR(RtsFlags); // bogus type -// Stable.c +// StablePtr.c extern StgWord RTS_VAR(stable_ptr_table); + +// StableName.c extern StgWord RTS_VAR(stable_name_table); // Profiling.c diff --git a/includes/stg/Prim.h b/includes/stg/Prim.h index fa3a3ec91f..a18e02caeb 100644 --- a/includes/stg/Prim.h +++ b/includes/stg/Prim.h @@ -58,6 +58,18 @@ StgWord64 hs_bswap64(StgWord64 x); /* TODO: longlong.c */ +/* libraries/ghc-prim/cbits/pdep.c */ +StgWord64 hs_pdep64(StgWord64 src, StgWord64 mask); +StgWord hs_pdep32(StgWord src, StgWord mask); +StgWord hs_pdep16(StgWord src, StgWord mask); +StgWord hs_pdep8(StgWord src, StgWord mask); + +/* libraries/ghc-prim/cbits/pext.c */ +StgWord64 hs_pext64(StgWord64 src, StgWord64 mask); +StgWord hs_pext32(StgWord src, StgWord mask); +StgWord hs_pext16(StgWord src, StgWord mask); +StgWord hs_pext8(StgWord src, StgWord mask); + /* libraries/ghc-prim/cbits/popcnt.c */ StgWord hs_popcnt8(StgWord x); StgWord hs_popcnt16(StgWord x); diff --git a/includes/stg/Types.h b/includes/stg/Types.h index af6a51791c..91ad446993 100644 --- a/includes/stg/Types.h +++ b/includes/stg/Types.h @@ -68,6 +68,8 @@ typedef uint8_t StgWord8; #define STG_INT8_MAX INT8_MAX #define STG_WORD8_MAX UINT8_MAX +#define FMT_Word8 PRIu8 + typedef int16_t StgInt16; typedef uint16_t StgWord16; @@ -75,6 +77,8 @@ typedef uint16_t StgWord16; #define STG_INT16_MAX INT16_MAX #define STG_WORD16_MAX UINT16_MAX +#define FMT_Word16 PRIu16 + typedef int32_t StgInt32; typedef uint32_t StgWord32; |