#define RTS_PRIVATE /* disabled: RTS_PRIVATE */
#endif
-#if __GNUC__ > 4
-#define BEGIN_RTS_PRIVATE #pragma GCC visibility push(hidden)
-#define END_RTS_PRIVATE #pragma GCC visibility pop
-#else
-#define BEGIN_RTS_PRIVATE /* disabled: BEGIN_RTS_PRIVATE */
-#define END_RTS_PRIVATE /* disabled: END_RTS_PRIVATE */
-#endif
-
-#if __GNUC__ > 4
+#if __GNUC__ >= 4
#define RTS_UNLIKELY(p) __builtin_expect((p),0)
#else
#define RTS_UNLIKELY(p) p
--- /dev/null
+#if __GNUC__ >= 4
+#pragma GCC visibility push(hidden)
+#endif
#include "Task.h"
#include "Sparks.h"
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
struct Capability_ {
// State required by the STG virtual machine when running Haskell
#endif
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* CAPABILITY_H */
--- /dev/null
+#if __GNUC__ >= 4
+#pragma GCC visibility pop
+#endif
#ifndef FRONTPANEL_H
#define FRONTPANEL_H
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
#ifdef RTS_GTK_FRONTPANEL
#endif /* RTS_GTK_FRONTPANEL */
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* FRONTPANEL_H */
#ifndef GETTIME_H
#define GETTIME_H
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
// We'll use a fixed resolution of usec for now. The machine
// dependent implementation may have a different resolution, but we'll
// Not strictly timing, but related
nat getPageFaults (void);
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* GETTIME_H */
#ifndef HASH_H
#define HASH_H
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
typedef struct hashtable HashTable; /* abstract */
void exitHashTable ( void );
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* HASH_H */
*
* --------------------------------------------------------------------------*/
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
nat messageBlackHole(Capability *cap, MessageBlackHole *msg);
void sendMessage (Capability *from_cap, Capability *to_cap, Message *msg);
#endif
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#ifndef PAPI_H
#define PAPI_H
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
/* Check the error value of a PAPI call, reporting an error, if needed */
extern int papi_error;
void papi_thread_start_gc1_count(int event_set);
void papi_thread_stop_gc1_count(int event_set);
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* PAPI_H */
#ifndef PRINTER_H
#define PRINTER_H
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
extern void printPtr ( StgPtr p );
extern void printObj ( StgClosure *obj );
extern char *what_next_strs[];
#endif
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* PRINTER_H */
#ifndef PROFHEAP_H
#define PROFHEAP_H
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
void heapCensus (void);
nat initHeapProfiling (void);
void LDV_recordDead (StgClosure *c, nat size);
rtsBool strMatchesSelector (char* str, char* sel);
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* PROFHEAP_H */
#include <stdio.h>
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
void initProfiling1 (void);
void freeProfiling1 (void);
#endif
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* PROFILING_H */
#ifndef PROFTIMER_H
#define PROFTIMER_H
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
void initProfTimer ( void );
void handleProfTick ( void );
extern rtsBool performHeapProfile;
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* PROFTIMER_H */
#ifndef CMINUSMINUS
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
void throwToSingleThreaded (Capability *cap,
StgTSO *tso,
}
}
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* CMINUSMINUS */
#include "RetainerSet.h"
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
void initRetainerProfiling ( void );
void endRetainerProfiling ( void );
extern lnat retainerStackBlocks ( void );
#endif
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* PROFILING */
#ifdef PROFILING
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
/*
Type 'retainer' defines the retainer identity.
// the best place to define it.
void printRetainer(FILE *, retainer);
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* PROFILING */
#endif /* RETAINERSET_H */
#if RTS_USER_SIGNALS
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
/*
* Function: initUserSignals()
*/
void markSignalHandlers (evac_fn evac, void *user);
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* RTS_USER_SIGNALS */
#ifndef RTSUTILS_H
#define RTSUTILS_H
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
/* -----------------------------------------------------------------------------
* (Checked) dynamic allocation
int rts_isProfiled(void);
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* RTSUTILS_H */
#define STM_UNIPROC
#endif
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
/*----------------------------------------------------------------------
/*----------------------------------------------------------------------*/
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* STM_H */
#include "Capability.h"
#include "Trace.h"
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
/* initScheduler(), exitScheduler()
* Called from STG : no
#endif /* !IN_STG_CODE */
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* SCHEDULE_H */
#include "WSDeque.h"
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
/* typedef for SparkPool in RtsTypes.h */
#endif // THREADED_RTS
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* SPARKS_H */
#include "sm/GC.h" // for evac_fn below
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
void freeStablePtr ( StgStablePtr sp );
void stablePtrPreGC ( void );
void stablePtrPostGC ( void );
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* STABLE_H */
#include "GetTime.h"
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
void stat_startInit(void);
void stat_endInit(void);
HsInt64 getAllocations (void);
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* STATS_H */
#ifndef STGPRIMFLOAT_H
#define STGPRIMFLOAT_H
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
/* grimy low-level support functions defined in StgPrimFloat.c */
void __decodeDouble_2Int (I_ *man_sign, W_ *man_high, W_ *man_low, I_ *exp, StgDouble dbl);
// __int_encodeDouble and __int_encodeFloat are public, declared in
// includes/rts/PrimFloat.h.
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* STGPRIMFLOAT_H */
#include "GetTime.h"
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
/*
Definition of a Task
#endif
}
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* TASK_H */
#ifndef THREADLABELS_H
#define THREADLABELS_H
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
#if defined(DEBUG)
void initThreadLabelTable (void);
void labelThread (StgPtr tso, char *label);
#endif
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* THREADLABELS_H */
#ifndef THREADS_H
#define THREADS_H
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
#define END_BLOCKED_EXCEPTIONS_QUEUE ((MessageThrowTo*)END_TSO_QUEUE)
void printThreadQueue (StgTSO *t);
#endif
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* THREADS_H */
#ifndef TICKER_H
#define TICKER_H
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
typedef void (*TickProc)(int);
void stopTicker (void);
void exitTicker (rtsBool wait);
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* TICKER_H */
#include "RtsProbes.h"
#endif /* defined(DTRACE) */
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
// -----------------------------------------------------------------------------
// EventLog API
dtraceGcDone((EventCapNo)cap->no);
}
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* TRACE_H */
#define UPDATES_H
#ifndef CMINUSMINUS
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
#endif
/* -----------------------------------------------------------------------------
#endif /* CMINUSMINUS */
#ifndef CMINUSMINUS
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif
#endif /* UPDATES_H */
#include "Capability.h"
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
extern rtsBool running_finalizers;
extern StgWeak * weak_ptr_list;
void scheduleFinalizers(Capability *cap, StgWeak *w);
void markWeakList(void);
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* WEAK_H */
#include "rts/EventLogFormat.h"
#include "Capability.h"
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
#ifdef TRACING
#endif
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* TRACING_H */
# include <signal.h>
#endif
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
rtsBool anyUserHandlers(void);
extern StgInt *signal_handlers;
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* POSIX_SIGNALS_H */
#ifndef BLOCK_ALLOC_H
#define BLOCK_ALLOC_H
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
/* Debugging -------------------------------------------------------------- */
extern lnat n_alloc_blocks; // currently allocated blocks
extern lnat hw_alloc_blocks; // high-water allocated blocks
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* BLOCK_ALLOC_H */
#ifndef SM_COMPACT_H
#define SM_COMPACT_H
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
INLINE_HEADER void
mark(StgPtr p, bdescr *bd)
void compact (StgClosure *static_objects);
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* SM_COMPACT_H */
#ifndef SM_EVAC_H
#define SM_EVAC_H
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
// Use a register argument for evacuate, if available.
// Earlier, the regparm attribute was used whenever __GNUC__ >= 2, but this
extern lnat thunk_selector_depth;
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* SM_EVAC_H */
#ifndef SM_GC_H
#define SM_GC_H
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
void GarbageCollect(rtsBool force_major_gc, nat gc_type, Capability *cap);
#define WORK_UNIT_WORDS 128
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* SM_GC_H */
#include "WSDeque.h"
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
/* -----------------------------------------------------------------------------
General scheme
#endif
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif // SM_GCTHREAD_H
#ifndef SM_GCUTILS_H
#define SM_GCUTILS_H
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
bdescr *allocBlock_sync(void);
void freeChain_sync(bdescr *bd);
*bd->free++ = (StgWord)p;
}
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* SM_GCUTILS_H */
#ifndef SM_MARKSTACK_H
#define SM_MARKSTACk_H
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
INLINE_HEADER void
push_mark_stack(StgPtr p)
return (((W_)mark_sp & BLOCK_MASK) == 0 && mark_stack_bd->link == NULL);
}
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* SM_MARKSTACK_H */
#ifndef SM_MARKWEAK_H
#define SM_MARKWEAK_H
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
extern StgWeak *old_weak_ptr_list;
extern StgTSO *resurrected_threads;
rtsBool traverseWeakPtrList ( void );
void markWeakPtrList ( void );
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* SM_MARKWEAK_H */
#ifndef SM_OSMEM_H
#define SM_OSMEM_H
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
void osMemInit(void);
void *osGetMBlocks(nat n);
lnat getPageSize (void);
void setExecutable (void *p, lnat len, rtsBool exec);
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* SM_OSMEM_H */
#ifdef DEBUG
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
# if defined(PAR)
# define PVM_PE_MASK 0xfffc0000
void checkBQ (StgTSO *bqe, StgClosure *closure);
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* DEBUG */
#ifndef SM_SCAV_H
#define SM_SCAV_H
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
void scavenge_loop (void);
void scavenge_mutable_list (bdescr *bd, generation *gen);
void scavenge_capability_mut_Lists1 (Capability *cap);
#endif
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* SM_SCAV_H */
#include "Capability.h"
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
/* -----------------------------------------------------------------------------
Initialisation / De-initialisation
extern StgClosure * caf_list;
extern StgClosure * revertible_caf_list;
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* SM_STORAGE_H */