Commit 20593d1d authored by sof's avatar sof

[project @ 2003-11-12 17:49:05 by sof]

Tweaks to have RTS (C) sources compile with MSVC. Apart from wibbles
related to the handling of 'inline', changed Schedule.h:POP_RUN_QUEUE()
not to use expression-level statement blocks.
parent a814590c
/* -----------------------------------------------------------------------------
* $Id: BlockAlloc.c,v 1.16 2003/02/18 05:47:53 sof Exp $
* $Id: BlockAlloc.c,v 1.17 2003/11/12 17:49:05 sof Exp $
*
* (c) The GHC Team 1998-2000
*
......@@ -44,7 +44,7 @@ void initBlockAllocator(void)
Allocation
-------------------------------------------------------------------------- */
static inline void
STATIC_INLINE void
initGroup(nat n, bdescr *head)
{
bdescr *bd;
......@@ -194,7 +194,7 @@ allocMegaGroup(nat n)
* pointer to the newly enlarged group p.
*/
static inline bdescr *
STATIC_INLINE bdescr *
coalesce(bdescr *p)
{
bdescr *bd, *q;
......
/* -----------------------------------------------------------------------------
* $Id: BlockAlloc.h,v 1.9 2001/05/03 16:32:55 simonmar Exp $
* $Id: BlockAlloc.h,v 1.10 2003/11/12 17:49:06 sof Exp $
*
* (c) The GHC Team, 1998-1999
*
......@@ -28,7 +28,7 @@ extern void freeChain(bdescr *p);
#define WORDS_PER_MBLOCK (BLOCKS_PER_MBLOCK * BLOCK_SIZE_W)
static inline nat
INLINE_HEADER nat
round_to_mblocks(nat words)
{
if (words > WORDS_PER_MBLOCK) {
......
......@@ -208,7 +208,7 @@ void releaseCapability(Capability* cap
fprintf(stderr,"worker thread (%p): released capability\n",
osThreadId()));
#endif
return;
return;
}
#if defined(RTS_SUPPORTS_THREADS)
......
/* -----------------------------------------------------------------------------
* $Id: Exception.h,v 1.6 2003/07/12 00:11:20 sof Exp $
* $Id: Exception.h,v 1.7 2003/11/12 17:49:07 sof Exp $
*
* (c) The GHC Team, 1998-2000
*
......@@ -14,7 +14,7 @@ extern const StgRetInfoTable stg_unblockAsyncExceptionszh_ret_info;
* indefinitely). Interruptible threads can be sent an exception with
* killThread# even if they have async exceptions blocked.
*/
static __inline__ int
INLINE_HEADER int
interruptible(StgTSO *t)
{
switch (t->why_blocked) {
......
/* -----------------------------------------------------------------------------
* $Id: GC.c,v 1.162 2003/10/24 11:45:40 simonmar Exp $
* $Id: GC.c,v 1.163 2003/11/12 17:49:07 sof Exp $
*
* (c) The GHC Team 1998-2003
*
......@@ -190,31 +190,31 @@ static rtsBool mark_stack_overflowed;
static bdescr *oldgen_scan_bd;
static StgPtr oldgen_scan;
static inline rtsBool
STATIC_INLINE rtsBool
mark_stack_empty(void)
{
return mark_sp == mark_stack;
}
static inline rtsBool
STATIC_INLINE rtsBool
mark_stack_full(void)
{
return mark_sp >= mark_splim;
}
static inline void
STATIC_INLINE void
reset_mark_stack(void)
{
mark_sp = mark_stack;
}
static inline void
STATIC_INLINE void
push_mark_stack(StgPtr p)
{
*mark_sp++ = p;
}
static inline StgPtr
STATIC_INLINE StgPtr
pop_mark_stack(void)
{
return *--mark_sp;
......@@ -1294,6 +1294,7 @@ traverse_weak_ptr_list(void)
default:
barf("traverse_weak_ptr_list");
return rtsTrue;
}
}
......@@ -1413,7 +1414,7 @@ mark_root(StgClosure **root)
*root = evacuate(*root);
}
static __inline__ void
STATIC_INLINE void
upd_evacuee(StgClosure *p, StgClosure *dest)
{
// Source object must be in from-space:
......@@ -1425,7 +1426,7 @@ upd_evacuee(StgClosure *p, StgClosure *dest)
}
static __inline__ StgClosure *
STATIC_INLINE StgClosure *
copy(StgClosure *src, nat size, step *stp)
{
P_ to, from, dest;
......@@ -1531,7 +1532,7 @@ copyPart(StgClosure *src, nat size_to_reserve, nat size_to_copy, step *stp)
-------------------------------------------------------------------------- */
static inline void
STATIC_INLINE void
evacuate_large(StgPtr p)
{
bdescr *bd = Bdescr(p);
......@@ -2215,7 +2216,7 @@ scavenge_large_srt_bitmap( StgLargeSRT *large_srt )
* srt field in the info table. That's ok, because we'll
* never dereference it.
*/
static inline void
STATIC_INLINE void
scavenge_srt (StgClosure **srt, nat srt_bitmap)
{
nat bitmap;
......@@ -2255,7 +2256,7 @@ scavenge_srt (StgClosure **srt, nat srt_bitmap)
}
static inline void
STATIC_INLINE void
scavenge_thunk_srt(const StgInfoTable *info)
{
StgThunkInfoTable *thunk_info;
......@@ -2264,7 +2265,7 @@ scavenge_thunk_srt(const StgInfoTable *info)
scavenge_srt((StgClosure **)thunk_info->srt, thunk_info->i.srt_bitmap);
}
static inline void
STATIC_INLINE void
scavenge_fun_srt(const StgInfoTable *info)
{
StgFunInfoTable *fun_info;
......@@ -2273,7 +2274,7 @@ scavenge_fun_srt(const StgInfoTable *info)
scavenge_srt((StgClosure **)fun_info->srt, fun_info->i.srt_bitmap);
}
static inline void
STATIC_INLINE void
scavenge_ret_srt(const StgInfoTable *info)
{
StgRetInfoTable *ret_info;
......@@ -2315,7 +2316,7 @@ scavengeTSO (StgTSO *tso)
in PAPs.
-------------------------------------------------------------------------- */
static inline StgPtr
STATIC_INLINE StgPtr
scavenge_arg_block (StgFunInfoTable *fun_info, StgClosure **args)
{
StgPtr p;
......@@ -2350,7 +2351,7 @@ scavenge_arg_block (StgFunInfoTable *fun_info, StgClosure **args)
return p;
}
static inline StgPtr
STATIC_INLINE StgPtr
scavenge_PAP (StgPAP *pap)
{
StgPtr p;
......@@ -3673,7 +3674,7 @@ scavenge_large_bitmap( StgPtr p, StgLargeBitmap *large_bitmap, nat size )
}
}
static inline StgPtr
STATIC_INLINE StgPtr
scavenge_small_bitmap (StgPtr p, nat size, StgWord bitmap)
{
while (size > 0) {
......@@ -4221,20 +4222,20 @@ done_traversing:
void *gap_start, *next_gap_start, *gap_end;
nat chunk_size;
next_gap_start = (void *)gap + sizeof(StgUpdateFrame);
next_gap_start = (void *)((unsigned char*)gap + sizeof(StgUpdateFrame));
sp = next_gap_start;
while ((StgPtr)gap > tso->sp) {
// we're working in *bytes* now...
gap_start = next_gap_start;
gap_end = gap_start - gap->gap_size * sizeof(W_);
gap_end = (void*) ((unsigned char*)gap_start - gap->gap_size * sizeof(W_));
gap = gap->next_gap;
next_gap_start = (void *)gap + sizeof(StgUpdateFrame);
next_gap_start = (void *)((unsigned char*)gap + sizeof(StgUpdateFrame));
chunk_size = gap_end - next_gap_start;
sp -= chunk_size;
chunk_size = (unsigned char*)gap_end - (unsigned char*)next_gap_start;
(unsigned char*)sp -= chunk_size;
memmove(sp, next_gap_start, chunk_size);
}
......@@ -4295,7 +4296,7 @@ printMutableList(generation *gen)
fputc('\n', stderr);
}
static inline rtsBool
STATIC_INLINE rtsBool
maybeLarge(StgClosure *closure)
{
StgInfoTable *info = get_itbl(closure);
......
/* -----------------------------------------------------------------------------
* $Id: GCCompact.c,v 1.17 2003/10/22 11:11:59 simonmar Exp $
* $Id: GCCompact.c,v 1.18 2003/11/12 17:49:07 sof Exp $
*
* (c) The GHC Team 2001
*
......@@ -21,9 +21,8 @@
// Turn off inlining when debugging - it obfuscates things
#ifdef DEBUG
#define INLINE
#else
#define INLINE inline
# undef STATIC_INLINE
# define STATIC_INLINE static
#endif
/* -----------------------------------------------------------------------------
......@@ -48,7 +47,7 @@
except for the info pointer.
-------------------------------------------------------------------------- */
static INLINE void
STATIC_INLINE void
thread( StgPtr p )
{
StgPtr q = (StgPtr)*p;
......@@ -71,7 +70,7 @@ thread( StgPtr p )
}
}
static INLINE void
STATIC_INLINE void
unthread( StgPtr p, StgPtr free )
{
StgPtr q = (StgPtr)*p, r;
......@@ -85,7 +84,7 @@ unthread( StgPtr p, StgPtr free )
*p = (StgWord)q;
}
static INLINE StgInfoTable *
STATIC_INLINE StgInfoTable *
get_threaded_info( StgPtr p )
{
StgPtr q = (P_)GET_INFO((StgClosure *)p);
......@@ -100,7 +99,7 @@ get_threaded_info( StgPtr p )
// A word-aligned memmove will be faster for small objects than libc's or gcc's.
// Remember, the two regions *might* overlap, but: to <= from.
static INLINE void
STATIC_INLINE void
move(StgPtr to, StgPtr from, nat size)
{
for(; size > 0; --size) {
......@@ -108,7 +107,7 @@ move(StgPtr to, StgPtr from, nat size)
}
}
static INLINE nat
STATIC_INLINE nat
obj_sizeW( StgClosure *p, StgInfoTable *info )
{
switch (info->type) {
......@@ -184,7 +183,7 @@ thread_static( StgClosure* p )
}
}
static INLINE void
STATIC_INLINE void
thread_large_bitmap( StgPtr p, StgLargeBitmap *large_bitmap, nat size )
{
nat i, b;
......@@ -207,7 +206,7 @@ thread_large_bitmap( StgPtr p, StgLargeBitmap *large_bitmap, nat size )
}
}
static INLINE StgPtr
STATIC_INLINE StgPtr
thread_arg_block (StgFunInfoTable *fun_info, StgClosure **args)
{
StgPtr p;
......@@ -355,7 +354,7 @@ thread_stack(StgPtr p, StgPtr stack_end)
}
}
static INLINE StgPtr
STATIC_INLINE StgPtr
thread_PAP (StgPAP *pap)
{
StgPtr p;
......@@ -399,7 +398,7 @@ thread_PAP (StgPAP *pap)
return p;
}
static INLINE StgPtr
STATIC_INLINE StgPtr
thread_AP_STACK (StgAP_STACK *ap)
{
thread((StgPtr)&ap->fun);
......@@ -480,7 +479,7 @@ update_fwd_large( bdescr *bd )
}
}
static INLINE StgPtr
STATIC_INLINE StgPtr
thread_obj (StgInfoTable *info, StgPtr p)
{
switch (info->type) {
......@@ -610,6 +609,7 @@ thread_obj (StgInfoTable *info, StgPtr p)
default:
barf("update_fwd: unknown/strange object %d", (int)(info->type));
return NULL;
}
}
......
/* -----------------------------------------------------------------------------
* $Id: GCCompact.h,v 1.2 2001/07/30 13:06:18 simonmar Exp $
* $Id: GCCompact.h,v 1.3 2003/11/12 17:49:07 sof Exp $
*
* (c) The GHC Team 1998-1999
*
......@@ -7,7 +7,7 @@
*
* ---------------------------------------------------------------------------*/
static inline void
INLINE_HEADER void
mark(StgPtr p, bdescr *bd)
{
nat offset_within_block = p - bd->start; // in words
......@@ -17,7 +17,7 @@ mark(StgPtr p, bdescr *bd)
*bitmap_word |= bit_mask;
}
static inline void
INLINE_HEADER void
unmark(StgPtr p, bdescr *bd)
{
nat offset_within_block = p - bd->start; // in words
......@@ -27,7 +27,7 @@ unmark(StgPtr p, bdescr *bd)
*bitmap_word &= ~bit_mask;
}
static inline int
INLINE_HEADER int
is_marked(StgPtr p, bdescr *bd)
{
nat offset_within_block = p - bd->start; // in words
......
......@@ -63,13 +63,13 @@
return (retcode);
static inline StgPtr
STATIC_INLINE StgPtr
allocate_UPD (int n_words)
{
return allocate(stg_max(sizeofW(StgHeader)+MIN_UPD_SIZE, n_words));
}
static inline StgPtr
STATIC_INLINE StgPtr
allocate_NONUPD (int n_words)
{
return allocate(stg_max(sizeofW(StgHeader)+MIN_NONUPD_SIZE, n_words));
......@@ -1212,7 +1212,7 @@ run_BCO:
#endif
// And restart the thread again, popping the RET_DYN frame.
cap = (Capability *)((void *)resumeThread(tok,rtsFalse) - sizeof(StgFunTable));
cap = (Capability *)((void *)((unsigned char*)resumeThread(tok,rtsFalse) - sizeof(StgFunTable)));
LOAD_STACK_POINTERS;
Sp += ret_dyn_size;
......
/* -----------------------------------------------------------------------------
* $Id: LdvProfile.c,v 1.5 2003/02/22 04:51:51 sof Exp $
* $Id: LdvProfile.c,v 1.6 2003/11/12 17:49:08 sof Exp $
*
* (c) The GHC Team, 2001
* Author: Sungwoo Park
......@@ -94,7 +94,7 @@ LDV_recordDead_FILL_SLOP_DYNAMIC( StgClosure *p )
* closure. Returns the size of the closure, including the profiling
* header portion, so that the caller can find the next closure.
* ----------------------------------------------------------------------- */
static inline nat
STATIC_INLINE nat
processHeapClosureForDead( StgClosure *c )
{
nat size;
......
/* -----------------------------------------------------------------------------
* $Id: Printer.c,v 1.61 2003/10/16 20:54:12 sof Exp $
* $Id: Printer.c,v 1.62 2003/11/12 17:49:08 sof Exp $
*
* (c) The GHC Team, 1994-2000.
*
......@@ -72,7 +72,7 @@ void printObj( StgClosure *obj )
printClosure(obj);
}
static inline void
STATIC_INLINE void
printStdObjHdr( StgClosure *obj, char* tag )
{
fprintf(stderr,"%s(",tag);
......
/* -----------------------------------------------------------------------------
* $Id: ProfHeap.c,v 1.49 2003/10/24 14:45:38 stolz Exp $
* $Id: ProfHeap.c,v 1.50 2003/11/12 17:49:08 sof Exp $
*
* (c) The GHC Team, 1998-2003
*
......@@ -72,7 +72,7 @@ typedef struct _counter {
struct _counter *next;
} counter;
static inline void
STATIC_INLINE void
initLDVCtr( counter *ctr )
{
ctr->c.ldv.prim = 0;
......@@ -177,7 +177,7 @@ static char *type_names[] = {
* the band to which this closure's heap space is attributed in the
* heap profile.
* ------------------------------------------------------------------------- */
static inline void *
STATIC_INLINE void *
closureIdentity( StgClosure *p )
{
switch (RtsFlags.ProfFlags.doHeapProfile) {
......@@ -215,14 +215,14 @@ closureIdentity( StgClosure *p )
* Profiling type predicates
* ----------------------------------------------------------------------- */
#ifdef PROFILING
static inline rtsBool
STATIC_INLINE rtsBool
doingLDVProfiling( void )
{
return (RtsFlags.ProfFlags.doHeapProfile == HEAP_BY_LDV
|| RtsFlags.ProfFlags.bioSelector != NULL);
}
static inline rtsBool
STATIC_INLINE rtsBool
doingRetainerProfiling( void )
{
return (RtsFlags.ProfFlags.doHeapProfile == HEAP_BY_RETAINER
......@@ -304,7 +304,7 @@ LDV_recordDead( StgClosure *c, nat size )
/* --------------------------------------------------------------------------
* Initialize censuses[era];
* ----------------------------------------------------------------------- */
static inline void
STATIC_INLINE void
initEra(Census *census)
{
census->hash = allocHashTable();
......
/* -----------------------------------------------------------------------------
* $Id: RetainerSet.c,v 1.4 2003/03/25 17:58:49 sof Exp $
* $Id: RetainerSet.c,v 1.5 2003/11/12 17:49:08 sof Exp $
*
* (c) The GHC Team, 2001
* Author: Sungwoo Park
......@@ -52,7 +52,7 @@ RetainerSet rs_MANY = {
/* -----------------------------------------------------------------------------
* calculate the size of a RetainerSet structure
* -------------------------------------------------------------------------- */
static inline size_t
STATIC_INLINE size_t
sizeofRetainerSet( int elems )
{
return (sizeof(RetainerSet) + elems * sizeof(retainer));
......
/* ----------------------------------------------------------------------------
* $Id: RtsAPI.c,v 1.49 2003/10/01 10:49:07 wolfgang Exp $
* $Id: RtsAPI.c,v 1.50 2003/11/12 17:49:08 sof Exp $
*
* (c) The GHC Team, 1998-2001
*
......@@ -76,10 +76,10 @@ rts_mkInt32 (HsInt32 i)
HaskellObj
rts_mkInt64 (HsInt64 i)
{
long long *tmp;
llong *tmp;
StgClosure *p = (StgClosure *)allocate(CONSTR_sizeW(0,2));
SET_HDR(p, I64zh_con_info, CCS_SYSTEM);
tmp = (long long*)&(p->payload[0]);
tmp = (llong*)&(p->payload[0]);
*tmp = (StgInt64)i;
return p;
}
......@@ -126,12 +126,12 @@ rts_mkWord32 (HsWord32 w)
HaskellObj
rts_mkWord64 (HsWord64 w)
{
unsigned long long *tmp;
ullong *tmp;
StgClosure *p = (StgClosure *)allocate(CONSTR_sizeW(0,2));
/* see mk_Int8 comment */
SET_HDR(p, W64zh_con_info, CCS_SYSTEM);
tmp = (unsigned long long*)&(p->payload[0]);
tmp = (ullong*)&(p->payload[0]);
*tmp = (StgWord64)w;
return p;
}
......
/* -----------------------------------------------------------------------------
* $Id: RtsFlags.c,v 1.71 2003/10/31 16:48:45 sof Exp $
* $Id: RtsFlags.c,v 1.72 2003/11/12 17:49:09 sof Exp $
*
* (c) The AQUA Project, Glasgow University, 1994-1997
* (c) The GHC Team, 1998-1999
......@@ -457,7 +457,7 @@ usage_text[] = {
0
};
static inline rtsBool
STATIC_INLINE rtsBool
strequal(const char *a, const char * b)
{
return(strcmp(a, b) == 0);
......
/* -----------------------------------------------------------------------------
* $Id: RtsUtils.h,v 1.18 2003/09/26 12:11:18 panne Exp $
* $Id: RtsUtils.h,v 1.19 2003/11/12 17:49:10 sof Exp $
*
* (c) The GHC Team, 1998-1999
*
......@@ -13,7 +13,7 @@ extern void *stgReallocBytes(void *p, int n, char *msg);
extern void *stgCallocBytes(int n, int m, char *msg);
extern void stgFree(void* p);
extern void barf(char *s, ...) __attribute__((__noreturn__)) ;
extern void barf(char *s, ...) GNU_ATTRIBUTE(__noreturn__);
extern void belch(char *s, ...);
extern void prog_belch(char *s, ...);
......@@ -26,9 +26,6 @@ extern void resetNonBlockingFd(int fd);
extern nat stg_strlen(char *str);
/*Defined in Main.c, but made visible here*/
extern void stg_exit(int n) __attribute__((noreturn));
char *time_str(void);
char *ullong_format_string(ullong, char *, rtsBool);
......
/* ---------------------------------------------------------------------------
* $Id: Schedule.c,v 1.179 2003/10/05 20:18:36 panne Exp $
* $Id: Schedule.c,v 1.180 2003/11/12 17:49:10 sof Exp $
*
* (c) The GHC Team, 1998-2000
*
......@@ -960,7 +960,7 @@ schedule( StgMainThread *mainThread USED_WHEN_RTS_SUPPORTS_THREADS,
/* in a GranSim setup the TSO stays on the run queue */
t = CurrentTSO;
/* Take a thread from the run queue. */
t = POP_RUN_QUEUE(); // take_off_run_queue(t);
POP_RUN_QUEUE(t); // take_off_run_queue(t);
IF_DEBUG(gran,
fprintf(stderr, "GRAN: About to run current thread, which is\n");
......@@ -1067,7 +1067,7 @@ schedule( StgMainThread *mainThread USED_WHEN_RTS_SUPPORTS_THREADS,
ASSERT(run_queue_hd != END_TSO_QUEUE);
/* Take a thread from the run queue, if we have work */
t = POP_RUN_QUEUE(); // take_off_run_queue(END_TSO_QUEUE);
POP_RUN_QUEUE(t); // take_off_run_queue(END_TSO_QUEUE);
IF_DEBUG(sanity,checkTSO(t));
/* ToDo: write something to the log-file
......@@ -1113,7 +1113,7 @@ schedule( StgMainThread *mainThread USED_WHEN_RTS_SUPPORTS_THREADS,
/* grab a thread from the run queue */
ASSERT(run_queue_hd != END_TSO_QUEUE);
t = POP_RUN_QUEUE();
POP_RUN_QUEUE(t);
// Sanity check the thread we're about to run. This can be
// expensive if there is lots of thread switching going on...
IF_DEBUG(sanity,checkTSO(t));
......@@ -1764,7 +1764,7 @@ suspendThread( StgRegTable *reg,
/* assume that *reg is a pointer to the StgRegTable part
* of a Capability.
*/
cap = (Capability *)((void *)reg - sizeof(StgFunTable));
cap = (Capability *)((void *)((unsigned char*)reg - sizeof(StgFunTable)));
ACQUIRE_LOCK(&sched_mutex);
......@@ -2759,7 +2759,7 @@ threadStackOverflow(StgTSO *tso)
if (tso->stack_size >= tso->max_stack_size) {
IF_DEBUG(gc,
belch("@@ threadStackOverflow of TSO %d (%p): stack too large (now %ld; max is %ld",
belch("@@ threadStackOverflow of TSO %d (%p): stack too large (now %ld; max is %ld)",
tso->id, tso, tso->stack_size, tso->max_stack_size);
/* If we're debugging, just print out the top of the stack */
printStackChunk(tso->sp, stg_min(tso->stack+tso->stack_size,
......@@ -2831,12 +2831,12 @@ threadStackOverflow(StgTSO *tso)
------------------------------------------------------------------------ */
#if defined(GRAN)
static inline void
STATIC_INLINE void
unblockCount ( StgBlockingQueueElement *bqe, StgClosure *node )
{
}
#elif defined(PAR)
static inline void
STATIC_INLINE void
unblockCount ( StgBlockingQueueElement *bqe, StgClosure *node )
{
/* write RESUME events to log file and
......@@ -2972,7 +2972,7 @@ unblockOneLocked(StgTSO *tso)
#endif
#if defined(GRAN) || defined(PAR)
inline StgBlockingQueueElement *
INLINE_ME StgBlockingQueueElement *
unblockOne(StgBlockingQueueElement *bqe, StgClosure *node)
{
ACQUIRE_LOCK(&sched_mutex);
......@@ -2981,7 +2981,7 @@ unblockOne(StgBlockingQueueElement *bqe, StgClosure *node)
return bqe;
}
#else
inline StgTSO *
INLINE_ME StgTSO *
unblockOne(StgTSO *tso)
{
ACQUIRE_LOCK(&sched_mutex);
......
/* -----------------------------------------------------------------------------
* $Id: Schedule.h,v 1.41 2003/10/01 10:57:43 wolfgang Exp $
* $Id: Schedule.h,v 1.42 2003/11/12 17:49:11 sof Exp $
*
* (c) The GHC Team 1998-1999
*
......@@ -258,17 +258,17 @@ void labelThread(StgPtr tso, char *label);
/* Pop the first thread off the runnable queue.
*/
#define POP_RUN_QUEUE() \
({ StgTSO *t = run_queue_hd; \
if (t != END_TSO_QUEUE) { \
run_queue_hd = t->link; \
t->link = END_TSO_QUEUE; \
#define POP_RUN_QUEUE(pt) \
do { StgTSO *__tmp_t = run_queue_hd; \
if (__tmp_t != END_TSO_QUEUE) { \
run_queue_hd = __tmp_t->link; \
__tmp_t->link = END_TSO_QUEUE; \
if (run_queue_hd == END_TSO_QUEUE) { \
run_queue_tl = END_TSO_QUEUE; \
} \
} \
t; \
})
pt = __tmp_t; \
} while(0)
/* Add a thread to the end of the blocked queue.
*/
......
/* ---------------------------------------------------------------------------
* $Id: Sparks.c,v 1.6 2003/03/25 17:58:50 sof Exp $
* $Id: Sparks.c,v 1.7 2003/11/12 17:49:11 sof Exp $
*
* (c) The GHC Team, 2000
*
......@@ -526,10 +526,10 @@ activateSpark (rtsEvent *event, rtsSparkQ spark)
Granularity info transformers.
Applied to the GRAN_INFO field of a spark.
*/
static inline nat ID(nat x) { return(x); };
static inline nat INV(nat x) { return(-x); };
static inline nat IGNORE(nat x) { return (0); };
static inline nat RAND(nat x) { return ((random() % MAX_RAND_PRI) + 1); }
STATIC_INLINE nat ID(nat x) { return(x); };
STATIC_INLINE nat INV(nat x) { return(-x); };
STATIC_INLINE nat IGNORE(nat x) { return (0); };
STATIC_INLINE nat RAND(nat x) { return ((random() % MAX_RAND_PRI) + 1); }
/* NB: size_info and par_info are currently unused (what a shame!) -- HWL */
//@cindex newSpark
......
/* -----------------------------------------------------------------------------
* $Id: Stable.c,v 1.26 2003/06/24 13:45:49 stolz Exp $
* $Id: Stable.c,v 1.27 2003/11/12 17:49:11 sof Exp $
*
* (c) The GHC Team, 1998-2002
*
......@@ -117,7 +117,7 @@ static HashTable *addrToStableHash = NULL;
#define INIT_SPT_SIZE 64
static inline void
STATIC_INLINE void
initFreeList(snEntry *table, nat n, snEntry *free)
{
snEntry *p;
......@@ -197,7 +197,7 @@ lookupStableName(StgPtr p)
}
}
static inline void
STATIC_INLINE void
freeStableName(snEntry *sn)
{
ASSERT(sn->sn_obj == NULL);
......
/* -----------------------------------------------------------------------------
* $Id: Storage.h,v 1.52 2003/04/22 16:25:12 simonmar Exp $
* $Id: Storage.h,v 1.53 2003/11/12 17:49:11 sof Exp $
*
* (c) The GHC Team, 1998-2002
*
......@@ -63,7 +63,7 @@ extern StgPtr allocate ( nat n );
extern StgPtr allocatePinned ( nat n );
extern lnat allocated_bytes ( void );