X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=rts%2FStgMiscClosures.cmm;h=b4a037d5d6dfe50bac06a1e1a03412956a79b0bb;hp=e092e3fdc09eb0044022f97bbd91e9329eff4890;hb=e5c3b478b3cd1707cf122833822f44b2ac09b8e9;hpb=d31dfb32ea936c22628b508c28a36c12e631430a diff --git a/rts/StgMiscClosures.cmm b/rts/StgMiscClosures.cmm index e092e3f..b4a037d 100644 --- a/rts/StgMiscClosures.cmm +++ b/rts/StgMiscClosures.cmm @@ -12,6 +12,29 @@ #include "Cmm.h" +import pthread_mutex_lock; +import ghczmprim_GHCziTypes_Czh_static_info; +import ghczmprim_GHCziTypes_Izh_static_info; +import EnterCriticalSection; +import LeaveCriticalSection; + +/* ---------------------------------------------------------------------------- + Stack underflow + ------------------------------------------------------------------------- */ + +INFO_TABLE_RET (stg_stack_underflow_frame, UNDERFLOW_FRAME, P_ unused) +{ + W_ new_tso; + W_ ret_off; + + SAVE_THREAD_STATE(); + ("ptr" ret_off) = foreign "C" threadStackUnderflow(MyCapability(), + CurrentTSO); + LOAD_THREAD_STATE(); + + jump %ENTRY_CODE(Sp(ret_off)); +} + /* ---------------------------------------------------------------------------- Support for the bytecode interpreter. ------------------------------------------------------------------------- */ @@ -167,7 +190,7 @@ INFO_TABLE_FUN( stg_BCO, 4, 0, BCO, "BCO", "BCO", ARG_BCO ) INFO_TABLE(stg_IND,1,0,IND,"IND","IND") { TICK_ENT_DYN_IND(); /* tick */ - R1 = StgInd_indirectee(R1); + R1 = UNTAG(StgInd_indirectee(R1)); TICK_ENT_VIA_NODE(); jump %GET_ENTRY(R1); } @@ -183,7 +206,7 @@ INFO_TABLE(stg_IND_direct,1,0,IND,"IND","IND") INFO_TABLE(stg_IND_STATIC,1,0,IND_STATIC,"IND_STATIC","IND_STATIC") { TICK_ENT_STATIC_IND(); /* tick */ - R1 = StgInd_indirectee(R1); + R1 = UNTAG(StgInd_indirectee(R1)); TICK_ENT_VIA_NODE(); jump %GET_ENTRY(R1); } @@ -220,7 +243,7 @@ INFO_TABLE(stg_IND_PERM,1,0,IND_PERM,"IND_PERM","IND_PERM") StgHeader_info(R1) = stg_IND_info; #endif /* TICKY_TICKY */ - R1 = StgInd_indirectee(R1); + R1 = UNTAG(StgInd_indirectee(R1)); #if defined(TICKY_TICKY) && !defined(PROFILING) TICK_ENT_VIA_NODE(); @@ -229,45 +252,6 @@ INFO_TABLE(stg_IND_PERM,1,0,IND_PERM,"IND_PERM","IND_PERM") jump %GET_ENTRY(R1); } - -INFO_TABLE(stg_IND_OLDGEN,1,0,IND_OLDGEN,"IND_OLDGEN","IND_OLDGEN") -{ - TICK_ENT_STATIC_IND(); /* tick */ - R1 = StgInd_indirectee(R1); - TICK_ENT_VIA_NODE(); - jump %GET_ENTRY(R1); -} - -INFO_TABLE(stg_IND_OLDGEN_PERM,1,0,IND_OLDGEN_PERM,"IND_OLDGEN_PERM","IND_OLDGEN_PERM") -{ - /* Don't: TICK_ENT_STATIC_IND(Node); for ticky-ticky; - this ind is here only to help profiling */ - -#if defined(TICKY_TICKY) && !defined(PROFILING) - /* TICKY_TICKY && !PROFILING means PERM_IND *replaces* an IND, - rather than being extra */ - TICK_ENT_PERM_IND(); /* tick */ -#endif - - LDV_ENTER(R1); - - /* Enter PAP cost centre -- lexical scoping only */ - ENTER_CCS_PAP_CL(R1); - - /* see comment in IND_PERM */ -#ifdef TICKY_TICKY -# ifdef PROFILING -# error Profiling and ticky-ticky do not mix at present! -# endif /* PROFILING */ - StgHeader_info(R1) = stg_IND_OLDGEN_info; -#endif /* TICKY_TICKY */ - - R1 = StgInd_indirectee(R1); - - TICK_ENT_VIA_NODE(); - jump %GET_ENTRY(R1); -} - /* ---------------------------------------------------------------------------- Black holes. @@ -277,124 +261,105 @@ INFO_TABLE(stg_IND_OLDGEN_PERM,1,0,IND_OLDGEN_PERM,"IND_OLDGEN_PERM","IND_OLDGEN waiting for the evaluation of the closure to finish. ------------------------------------------------------------------------- */ -/* Note: a BLACKHOLE must be big enough to be - * overwritten with an indirection/evacuee/catch. Thus we claim it - * has 1 non-pointer word of payload. - */ -INFO_TABLE(stg_BLACKHOLE,0,1,BLACKHOLE,"BLACKHOLE","BLACKHOLE") +INFO_TABLE(stg_BLACKHOLE,1,0,BLACKHOLE,"BLACKHOLE","BLACKHOLE") { -#if defined(GRAN) - /* Before overwriting TSO_LINK */ - STGCALL3(GranSimBlock,CurrentTSO,CurrentProc,(StgClosure *)R1 /*Node*/); -#endif - - TICK_ENT_BH(); - -#ifdef THREADED_RTS - // foreign "C" debugBelch("BLACKHOLE entry\n"); -#endif - - /* Actually this is not necessary because R1 is about to be destroyed. */ - LDV_ENTER(R1); - -#if defined(THREADED_RTS) - foreign "C" ACQUIRE_LOCK(sched_mutex "ptr"); - // released in stg_block_blackhole_finally -#endif - - /* Put ourselves on the blackhole queue */ - StgTSO_link(CurrentTSO) = W_[blackhole_queue]; - W_[blackhole_queue] = CurrentTSO; + W_ r, p, info, bq, msg, owner, bd; - /* jot down why and on what closure we are blocked */ - StgTSO_why_blocked(CurrentTSO) = BlockedOnBlackHole::I16; - StgTSO_block_info(CurrentTSO) = R1; + TICK_ENT_DYN_IND(); /* tick */ - jump stg_block_blackhole; +retry: + p = StgInd_indirectee(R1); + if (GETTAG(p) != 0) { + R1 = p; + jump %ENTRY_CODE(Sp(0)); + } + + info = StgHeader_info(p); + if (info == stg_IND_info) { + // This could happen, if e.g. we got a BLOCKING_QUEUE that has + // just been replaced with an IND by another thread in + // wakeBlockingQueue(). + goto retry; + } + + if (info == stg_TSO_info || + info == stg_BLOCKING_QUEUE_CLEAN_info || + info == stg_BLOCKING_QUEUE_DIRTY_info) + { + ("ptr" msg) = foreign "C" allocate(MyCapability() "ptr", + BYTES_TO_WDS(SIZEOF_MessageBlackHole)) [R1]; + + SET_HDR(msg, stg_MSG_BLACKHOLE_info, CCS_SYSTEM); + MessageBlackHole_tso(msg) = CurrentTSO; + MessageBlackHole_bh(msg) = R1; + + (r) = foreign "C" messageBlackHole(MyCapability() "ptr", msg "ptr") [R1]; + + if (r == 0) { + goto retry; + } else { + StgTSO_why_blocked(CurrentTSO) = BlockedOnBlackHole::I16; + StgTSO_block_info(CurrentTSO) = msg; + jump stg_block_blackhole; + } + } + else + { + R1 = p; + ENTER(); + } } -#if defined(PAR) || defined(GRAN) - -INFO_TABLE(stg_RBH,1,1,RBH,"RBH","RBH") +INFO_TABLE(__stg_EAGER_BLACKHOLE,1,0,BLACKHOLE,"BLACKHOLE","BLACKHOLE") { -# if defined(GRAN) - /* mainly statistics gathering for GranSim simulation */ - STGCALL3(GranSimBlock,CurrentTSO,CurrentProc,(StgClosure *)R1 /*Node*/); -# endif - - /* exactly the same as a BLACKHOLE_BQ_entry -- HWL */ - /* Put ourselves on the blocking queue for this black hole */ - TSO_link(CurrentTSO) = StgBlockingQueue_blocking_queue(R1); - StgBlockingQueue_blocking_queue(R1) = CurrentTSO; - /* jot down why and on what closure we are blocked */ - TSO_why_blocked(CurrentTSO) = BlockedOnBlackHole::I16; - TSO_block_info(CurrentTSO) = R1; - - /* PAR: dumping of event now done in blockThread -- HWL */ - - /* stg_gen_block is too heavyweight, use a specialised one */ - jump stg_block_1; + jump ENTRY_LBL(stg_BLACKHOLE); } -INFO_TABLE(stg_RBH_Save_0,0,2,CONSTR,"RBH_Save_0","RBH_Save_0") -{ foreign "C" barf("RBH_Save_0 object entered!"); } - -INFO_TABLE(stg_RBH_Save_1,1,1,CONSTR,"RBH_Save_1","RBH_Save_1"); -{ foreign "C" barf("RBH_Save_1 object entered!"); } - -INFO_TABLE(stg_RBH_Save_2,2,0,CONSTR,"RBH_Save_2","RBH_Save_2"); -{ foreign "C" barf("RBH_Save_2 object entered!"); } - -#endif /* defined(PAR) || defined(GRAN) */ - -/* identical to BLACKHOLEs except for the infotag */ -INFO_TABLE(stg_CAF_BLACKHOLE,0,1,CAF_BLACKHOLE,"CAF_BLACKHOLE","CAF_BLACKHOLE") +// CAF_BLACKHOLE is allocated when entering a CAF. The reason it is +// distinct from BLACKHOLE is so that we can tell the difference +// between an update frame on the stack that points to a CAF under +// evaluation, and one that points to a closure that is under +// evaluation by another thread (a BLACKHOLE). See threadPaused(). +// +INFO_TABLE(stg_CAF_BLACKHOLE,1,0,BLACKHOLE,"BLACKHOLE","BLACKHOLE") { -#if defined(GRAN) - /* mainly statistics gathering for GranSim simulation */ - STGCALL3(GranSimBlock,CurrentTSO,CurrentProc,(StgClosure *)R1 /*Node*/); -#endif - - TICK_ENT_BH(); - LDV_ENTER(R1); - -#if defined(THREADED_RTS) - // foreign "C" debugBelch("BLACKHOLE entry\n"); -#endif - -#if defined(THREADED_RTS) - foreign "C" ACQUIRE_LOCK(sched_mutex "ptr"); - // released in stg_block_blackhole_finally -#endif - - /* Put ourselves on the blackhole queue */ - StgTSO_link(CurrentTSO) = W_[blackhole_queue]; - W_[blackhole_queue] = CurrentTSO; - - /* jot down why and on what closure we are blocked */ - StgTSO_why_blocked(CurrentTSO) = BlockedOnBlackHole::I16; - StgTSO_block_info(CurrentTSO) = R1; - - jump stg_block_blackhole; + jump ENTRY_LBL(stg_BLACKHOLE); } -#ifdef EAGER_BLACKHOLING -INFO_TABLE(stg_SE_BLACKHOLE,0,1,SE_BLACKHOLE,"SE_BLACKHOLE","SE_BLACKHOLE") -{ foreign "C" barf("SE_BLACKHOLE object entered!"); } +INFO_TABLE(stg_BLOCKING_QUEUE_CLEAN,4,0,BLOCKING_QUEUE,"BLOCKING_QUEUE","BLOCKING_QUEUE") +{ foreign "C" barf("BLOCKING_QUEUE_CLEAN object entered!") never returns; } + -INFO_TABLE(stg_SE_CAF_BLACKHOLE,0,1,SE_CAF_BLACKHOLE,"SE_CAF_BLACKHOLE","SE_CAF_BLACKHOLE") -{ foreign "C" barf("SE_CAF_BLACKHOLE object entered!"); } -#endif +INFO_TABLE(stg_BLOCKING_QUEUE_DIRTY,4,0,BLOCKING_QUEUE,"BLOCKING_QUEUE","BLOCKING_QUEUE") +{ foreign "C" barf("BLOCKING_QUEUE_DIRTY object entered!") never returns; } + /* ---------------------------------------------------------------------------- Whiteholes are used for the "locked" state of a closure (see lockClosure()) - - The closure type is BLAKCHOLE, just because we need a valid closure type - for sanity checking. ------------------------------------------------------------------------- */ -INFO_TABLE(stg_WHITEHOLE, 0,0, BLACKHOLE, "WHITEHOLE", "WHITEHOLE") -{ foreign "C" barf("WHITEHOLE object entered!"); } +INFO_TABLE(stg_WHITEHOLE, 0,0, WHITEHOLE, "WHITEHOLE", "WHITEHOLE") +{ +#if defined(THREADED_RTS) + W_ info, i; + + i = 0; +loop: + // spin until the WHITEHOLE is updated + info = StgHeader_info(R1); + if (info == stg_WHITEHOLE_info) { + i = i + 1; + if (i == SPIN_COUNT) { + i = 0; + foreign "C" yieldThread() [R1]; + } + goto loop; + } + jump %ENTRY_CODE(info); +#else + foreign "C" barf("WHITEHOLE object entered!") never returns; +#endif +} /* ---------------------------------------------------------------------------- Some static info tables for things that don't get entered, and @@ -403,15 +368,10 @@ INFO_TABLE(stg_WHITEHOLE, 0,0, BLACKHOLE, "WHITEHOLE", "WHITEHOLE") ------------------------------------------------------------------------- */ INFO_TABLE(stg_TSO, 0,0,TSO, "TSO", "TSO") -{ foreign "C" barf("TSO object entered!"); } +{ foreign "C" barf("TSO object entered!") never returns; } -/* ---------------------------------------------------------------------------- - Evacuees are left behind by the garbage collector. Any attempt to enter - one is a real bug. - ------------------------------------------------------------------------- */ - -INFO_TABLE(stg_EVACUATED,1,0,EVACUATED,"EVACUATED","EVACUATED") -{ foreign "C" barf("EVACUATED object entered!"); } +INFO_TABLE(stg_STACK, 0,0, STACK, "STACK", "STACK") +{ foreign "C" barf("STACK object entered!") never returns; } /* ---------------------------------------------------------------------------- Weak pointers @@ -421,17 +381,17 @@ INFO_TABLE(stg_EVACUATED,1,0,EVACUATED,"EVACUATED","EVACUATED") live weak pointers with dead ones). ------------------------------------------------------------------------- */ -INFO_TABLE(stg_WEAK,0,4,WEAK,"WEAK","WEAK") -{ foreign "C" barf("WEAK object entered!"); } +INFO_TABLE(stg_WEAK,1,4,WEAK,"WEAK","WEAK") +{ foreign "C" barf("WEAK object entered!") never returns; } /* * It's important when turning an existing WEAK into a DEAD_WEAK * (which is what finalizeWeak# does) that we don't lose the link * field and break the linked list of weak pointers. Hence, we give - * DEAD_WEAK 4 non-pointer fields, the same as WEAK. + * DEAD_WEAK 5 non-pointer fields. */ -INFO_TABLE_CONSTR(stg_DEAD_WEAK,0,4,0,CONSTR,"DEAD_WEAK","DEAD_WEAK") -{ foreign "C" barf("DEAD_WEAK object entered!"); } +INFO_TABLE_CONSTR(stg_DEAD_WEAK,0,5,0,CONSTR,"DEAD_WEAK","DEAD_WEAK") +{ foreign "C" barf("DEAD_WEAK object entered!") never returns; } /* ---------------------------------------------------------------------------- NO_FINALIZER @@ -441,7 +401,7 @@ INFO_TABLE_CONSTR(stg_DEAD_WEAK,0,4,0,CONSTR,"DEAD_WEAK","DEAD_WEAK") ------------------------------------------------------------------------- */ INFO_TABLE_CONSTR(stg_NO_FINALIZER,0,0,0,CONSTR_NOCAF_STATIC,"NO_FINALIZER","NO_FINALIZER") -{ foreign "C" barf("NO_FINALIZER object entered!"); } +{ foreign "C" barf("NO_FINALIZER object entered!") never returns; } CLOSURE(stg_NO_FINALIZER_closure,stg_NO_FINALIZER); @@ -449,8 +409,8 @@ CLOSURE(stg_NO_FINALIZER_closure,stg_NO_FINALIZER); Stable Names are unlifted too. ------------------------------------------------------------------------- */ -INFO_TABLE(stg_STABLE_NAME,0,1,STABLE_NAME,"STABLE_NAME","STABLE_NAME") -{ foreign "C" barf("STABLE_NAME object entered!"); } +INFO_TABLE(stg_STABLE_NAME,0,1,PRIM,"STABLE_NAME","STABLE_NAME") +{ foreign "C" barf("STABLE_NAME object entered!") never returns; } /* ---------------------------------------------------------------------------- MVars @@ -459,45 +419,45 @@ INFO_TABLE(stg_STABLE_NAME,0,1,STABLE_NAME,"STABLE_NAME","STABLE_NAME") and entry code for each type. ------------------------------------------------------------------------- */ -INFO_TABLE(stg_FULL_MVAR,3,0,MVAR,"MVAR","MVAR") -{ foreign "C" barf("FULL_MVAR object entered!"); } +INFO_TABLE(stg_MVAR_CLEAN,3,0,MVAR_CLEAN,"MVAR","MVAR") +{ foreign "C" barf("MVAR object entered!") never returns; } -INFO_TABLE(stg_EMPTY_MVAR,3,0,MVAR,"MVAR","MVAR") -{ foreign "C" barf("EMPTY_MVAR object entered!"); } +INFO_TABLE(stg_MVAR_DIRTY,3,0,MVAR_DIRTY,"MVAR","MVAR") +{ foreign "C" barf("MVAR object entered!") never returns; } /* ----------------------------------------------------------------------------- STM -------------------------------------------------------------------------- */ -INFO_TABLE(stg_TVAR, 0, 0, TVAR, "TVAR", "TVAR") -{ foreign "C" barf("TVAR object entered!"); } +INFO_TABLE(stg_TVAR, 2, 1, MUT_PRIM, "TVAR", "TVAR") +{ foreign "C" barf("TVAR object entered!") never returns; } -INFO_TABLE(stg_TVAR_WATCH_QUEUE, 0, 0, TVAR_WATCH_QUEUE, "TVAR_WATCH_QUEUE", "TVAR_WATCH_QUEUE") -{ foreign "C" barf("TVAR_WATCH_QUEUE object entered!"); } +INFO_TABLE(stg_TVAR_WATCH_QUEUE, 3, 0, MUT_PRIM, "TVAR_WATCH_QUEUE", "TVAR_WATCH_QUEUE") +{ foreign "C" barf("TVAR_WATCH_QUEUE object entered!") never returns; } -INFO_TABLE(stg_ATOMIC_INVARIANT, 0, 0, ATOMIC_INVARIANT, "ATOMIC_INVARIANT", "ATOMIC_INVARIANT") -{ foreign "C" barf("ATOMIC_INVARIANT object entered!"); } +INFO_TABLE(stg_ATOMIC_INVARIANT, 2, 1, MUT_PRIM, "ATOMIC_INVARIANT", "ATOMIC_INVARIANT") +{ foreign "C" barf("ATOMIC_INVARIANT object entered!") never returns; } -INFO_TABLE(stg_INVARIANT_CHECK_QUEUE, 0, 0, INVARIANT_CHECK_QUEUE, "INVARIANT_CHECK_QUEUE", "INVARIANT_CHECK_QUEUE") -{ foreign "C" barf("INVARIANT_CHECK_QUEUE object entered!"); } +INFO_TABLE(stg_INVARIANT_CHECK_QUEUE, 3, 0, MUT_PRIM, "INVARIANT_CHECK_QUEUE", "INVARIANT_CHECK_QUEUE") +{ foreign "C" barf("INVARIANT_CHECK_QUEUE object entered!") never returns; } INFO_TABLE(stg_TREC_CHUNK, 0, 0, TREC_CHUNK, "TREC_CHUNK", "TREC_CHUNK") -{ foreign "C" barf("TREC_CHUNK object entered!"); } +{ foreign "C" barf("TREC_CHUNK object entered!") never returns; } -INFO_TABLE(stg_TREC_HEADER, 0, 0, TREC_HEADER, "TREC_HEADER", "TREC_HEADER") -{ foreign "C" barf("TREC_HEADER object entered!"); } +INFO_TABLE(stg_TREC_HEADER, 3, 1, MUT_PRIM, "TREC_HEADER", "TREC_HEADER") +{ foreign "C" barf("TREC_HEADER object entered!") never returns; } INFO_TABLE_CONSTR(stg_END_STM_WATCH_QUEUE,0,0,0,CONSTR_NOCAF_STATIC,"END_STM_WATCH_QUEUE","END_STM_WATCH_QUEUE") -{ foreign "C" barf("END_STM_WATCH_QUEUE object entered!"); } +{ foreign "C" barf("END_STM_WATCH_QUEUE object entered!") never returns; } INFO_TABLE_CONSTR(stg_END_INVARIANT_CHECK_QUEUE,0,0,0,CONSTR_NOCAF_STATIC,"END_INVARIANT_CHECK_QUEUE","END_INVARIANT_CHECK_QUEUE") -{ foreign "C" barf("END_INVARIANT_CHECK_QUEUE object entered!"); } +{ foreign "C" barf("END_INVARIANT_CHECK_QUEUE object entered!") never returns; } INFO_TABLE_CONSTR(stg_END_STM_CHUNK_LIST,0,0,0,CONSTR_NOCAF_STATIC,"END_STM_CHUNK_LIST","END_STM_CHUNK_LIST") -{ foreign "C" barf("END_STM_CHUNK_LIST object entered!"); } +{ foreign "C" barf("END_STM_CHUNK_LIST object entered!") never returns; } INFO_TABLE_CONSTR(stg_NO_TREC,0,0,0,CONSTR_NOCAF_STATIC,"NO_TREC","NO_TREC") -{ foreign "C" barf("NO_TREC object entered!"); } +{ foreign "C" barf("NO_TREC object entered!") never returns; } CLOSURE(stg_END_STM_WATCH_QUEUE_closure,stg_END_STM_WATCH_QUEUE); @@ -508,6 +468,25 @@ CLOSURE(stg_END_STM_CHUNK_LIST_closure,stg_END_STM_CHUNK_LIST); CLOSURE(stg_NO_TREC_closure,stg_NO_TREC); /* ---------------------------------------------------------------------------- + Messages + ------------------------------------------------------------------------- */ + +// PRIM rather than CONSTR, because PRIM objects cannot be duplicated by the GC. + +INFO_TABLE_CONSTR(stg_MSG_TRY_WAKEUP,2,0,0,PRIM,"MSG_TRY_WAKEUP","MSG_TRY_WAKEUP") +{ foreign "C" barf("MSG_TRY_WAKEUP object entered!") never returns; } + +INFO_TABLE_CONSTR(stg_MSG_THROWTO,4,0,0,PRIM,"MSG_THROWTO","MSG_THROWTO") +{ foreign "C" barf("MSG_THROWTO object entered!") never returns; } + +INFO_TABLE_CONSTR(stg_MSG_BLACKHOLE,3,0,0,PRIM,"MSG_BLACKHOLE","MSG_BLACKHOLE") +{ foreign "C" barf("MSG_BLACKHOLE object entered!") never returns; } + +// used to overwrite a MSG_THROWTO when the message has been used/revoked +INFO_TABLE_CONSTR(stg_MSG_NULL,1,0,0,PRIM,"MSG_NULL","MSG_NULL") +{ foreign "C" barf("MSG_NULL object entered!") never returns; } + +/* ---------------------------------------------------------------------------- END_TSO_QUEUE This is a static nullary constructor (like []) that we use to mark the @@ -515,23 +494,11 @@ CLOSURE(stg_NO_TREC_closure,stg_NO_TREC); ------------------------------------------------------------------------- */ INFO_TABLE_CONSTR(stg_END_TSO_QUEUE,0,0,0,CONSTR_NOCAF_STATIC,"END_TSO_QUEUE","END_TSO_QUEUE") -{ foreign "C" barf("END_TSO_QUEUE object entered!"); } +{ foreign "C" barf("END_TSO_QUEUE object entered!") never returns; } CLOSURE(stg_END_TSO_QUEUE_closure,stg_END_TSO_QUEUE); /* ---------------------------------------------------------------------------- - Exception lists - ------------------------------------------------------------------------- */ - -INFO_TABLE_CONSTR(stg_END_EXCEPTION_LIST,0,0,0,CONSTR_NOCAF_STATIC,"END_EXCEPTION_LIST","END_EXCEPTION_LIST") -{ foreign "C" barf("END_EXCEPTION_LIST object entered!"); } - -CLOSURE(stg_END_EXCEPTION_LIST_closure,stg_END_EXCEPTION_LIST); - -INFO_TABLE(stg_EXCEPTION_CONS,1,1,CONSTR,"EXCEPTION_CONS","EXCEPTION_CONS") -{ foreign "C" barf("EXCEPTION_CONS object entered!"); } - -/* ---------------------------------------------------------------------------- Arrays These come in two basic flavours: arrays of data (StgArrWords) and arrays of @@ -547,28 +514,28 @@ INFO_TABLE(stg_EXCEPTION_CONS,1,1,CONSTR,"EXCEPTION_CONS","EXCEPTION_CONS") ------------------------------------------------------------------------- */ INFO_TABLE(stg_ARR_WORDS, 0, 0, ARR_WORDS, "ARR_WORDS", "ARR_WORDS") -{ foreign "C" barf("ARR_WORDS object entered!"); } +{ foreign "C" barf("ARR_WORDS object entered!") never returns; } INFO_TABLE(stg_MUT_ARR_PTRS_CLEAN, 0, 0, MUT_ARR_PTRS_CLEAN, "MUT_ARR_PTRS_CLEAN", "MUT_ARR_PTRS_CLEAN") -{ foreign "C" barf("MUT_ARR_PTRS_CLEAN object entered!"); } +{ foreign "C" barf("MUT_ARR_PTRS_CLEAN object entered!") never returns; } INFO_TABLE(stg_MUT_ARR_PTRS_DIRTY, 0, 0, MUT_ARR_PTRS_DIRTY, "MUT_ARR_PTRS_DIRTY", "MUT_ARR_PTRS_DIRTY") -{ foreign "C" barf("MUT_ARR_PTRS_DIRTY object entered!"); } +{ foreign "C" barf("MUT_ARR_PTRS_DIRTY object entered!") never returns; } INFO_TABLE(stg_MUT_ARR_PTRS_FROZEN, 0, 0, MUT_ARR_PTRS_FROZEN, "MUT_ARR_PTRS_FROZEN", "MUT_ARR_PTRS_FROZEN") -{ foreign "C" barf("MUT_ARR_PTRS_FROZEN object entered!"); } +{ foreign "C" barf("MUT_ARR_PTRS_FROZEN object entered!") never returns; } INFO_TABLE(stg_MUT_ARR_PTRS_FROZEN0, 0, 0, MUT_ARR_PTRS_FROZEN0, "MUT_ARR_PTRS_FROZEN0", "MUT_ARR_PTRS_FROZEN0") -{ foreign "C" barf("MUT_ARR_PTRS_FROZEN0 object entered!"); } +{ foreign "C" barf("MUT_ARR_PTRS_FROZEN0 object entered!") never returns; } /* ---------------------------------------------------------------------------- Mutable Variables ------------------------------------------------------------------------- */ INFO_TABLE(stg_MUT_VAR_CLEAN, 1, 0, MUT_VAR_CLEAN, "MUT_VAR_CLEAN", "MUT_VAR_CLEAN") -{ foreign "C" barf("MUT_VAR_CLEAN object entered!"); } +{ foreign "C" barf("MUT_VAR_CLEAN object entered!") never returns; } INFO_TABLE(stg_MUT_VAR_DIRTY, 1, 0, MUT_VAR_DIRTY, "MUT_VAR_DIRTY", "MUT_VAR_DIRTY") -{ foreign "C" barf("MUT_VAR_DIRTY object entered!"); } +{ foreign "C" barf("MUT_VAR_DIRTY object entered!") never returns; } /* ---------------------------------------------------------------------------- Dummy return closure @@ -585,6 +552,13 @@ INFO_TABLE( stg_dummy_ret, 0, 0, CONSTR_NOCAF_STATIC, "DUMMY_RET", "DUMMY_RET") CLOSURE(stg_dummy_ret_closure,stg_dummy_ret); /* ---------------------------------------------------------------------------- + MVAR_TSO_QUEUE + ------------------------------------------------------------------------- */ + +INFO_TABLE_CONSTR(stg_MVAR_TSO_QUEUE,2,0,0,PRIM,"MVAR_TSO_QUEUE","MVAR_TSO_QUEUE") +{ foreign "C" barf("MVAR_TSO_QUEUE object entered!") never returns; } + +/* ---------------------------------------------------------------------------- CHARLIKE and INTLIKE closures. These are static representations of Chars and small Ints, so that @@ -592,20 +566,21 @@ CLOSURE(stg_dummy_ret_closure,stg_dummy_ret); replace them with references to the static objects. ------------------------------------------------------------------------- */ -#if defined(ENABLE_WIN32_DLL_SUPPORT) +#if defined(__PIC__) && defined(mingw32_HOST_OS) /* - * When sticking the RTS in a DLL, we delay populating the + * When sticking the RTS in a Windows DLL, we delay populating the * Charlike and Intlike tables until load-time, which is only * when we've got the real addresses to the C# and I# closures. - * + * + * -- this is currently broken BL 2009/11/14. + * we don't rewrite to static closures at all with Windows DLLs. */ -static INFO_TBL_CONST StgInfoTable czh_static_info; -static INFO_TBL_CONST StgInfoTable izh_static_info; -#define Char_hash_static_info czh_static_info -#define Int_hash_static_info izh_static_info +// #warning Is this correct? _imp is a pointer! +#define Char_hash_static_info _imp__ghczmprim_GHCziTypes_Czh_static_info +#define Int_hash_static_info _imp__ghczmprim_GHCziTypes_Izh_static_info #else -#define Char_hash_static_info base_GHCziBase_Czh_static -#define Int_hash_static_info base_GHCziBase_Izh_static +#define Char_hash_static_info ghczmprim_GHCziTypes_Czh_static_info +#define Int_hash_static_info ghczmprim_GHCziTypes_Izh_static_info #endif @@ -618,6 +593,7 @@ static INFO_TBL_CONST StgInfoTable izh_static_info; /* end the name with _closure, to convince the mangler this is a closure */ +#if !(defined(__PIC__) && defined(mingw32_HOST_OS)) section "data" { stg_CHARLIKE_closure: CHARLIKE_HDR(0) @@ -914,3 +890,5 @@ section "data" { INTLIKE_HDR(15) INTLIKE_HDR(16) /* MAX_INTLIKE == 16 */ } + +#endif // !(defined(__PIC__) && defined(mingw32_HOST_OS))