X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=rts%2FLinker.c;h=1d955a378f00d4570b00ff3e6ea7847f1dc0054f;hb=91cb5af24ad12cd5574b4cca84ec9fb97668dceb;hp=d7e78860a0d7c7350ace0d8588b3ef39f694e49d;hpb=91a804680cfc5cb3894d996b9c7fb28b50180cdb;p=ghc-hetmet.git diff --git a/rts/Linker.c b/rts/Linker.c index d7e7886..1d955a3 100644 --- a/rts/Linker.c +++ b/rts/Linker.c @@ -553,8 +553,122 @@ typedef struct _RtsSymbolVal { SymI_HasProto(stg_ap_pppppp_ret) #endif +/* Modules compiled with -ticky may mention ticky counters */ +/* This list should marry up with the one in $(TOP)/includes/stg/Ticky.h */ +#define RTS_TICKY_SYMBOLS \ + SymI_NeedsProto(ticky_entry_ctrs) \ + SymI_NeedsProto(top_ct) \ + \ + SymI_HasProto(ENT_VIA_NODE_ctr) \ + SymI_HasProto(ENT_STATIC_THK_ctr) \ + SymI_HasProto(ENT_DYN_THK_ctr) \ + SymI_HasProto(ENT_STATIC_FUN_DIRECT_ctr) \ + SymI_HasProto(ENT_DYN_FUN_DIRECT_ctr) \ + SymI_HasProto(ENT_STATIC_CON_ctr) \ + SymI_HasProto(ENT_DYN_CON_ctr) \ + SymI_HasProto(ENT_STATIC_IND_ctr) \ + SymI_HasProto(ENT_DYN_IND_ctr) \ + SymI_HasProto(ENT_PERM_IND_ctr) \ + SymI_HasProto(ENT_PAP_ctr) \ + SymI_HasProto(ENT_AP_ctr) \ + SymI_HasProto(ENT_AP_STACK_ctr) \ + SymI_HasProto(ENT_BH_ctr) \ + SymI_HasProto(UNKNOWN_CALL_ctr) \ + SymI_HasProto(SLOW_CALL_v_ctr) \ + SymI_HasProto(SLOW_CALL_f_ctr) \ + SymI_HasProto(SLOW_CALL_d_ctr) \ + SymI_HasProto(SLOW_CALL_l_ctr) \ + SymI_HasProto(SLOW_CALL_n_ctr) \ + SymI_HasProto(SLOW_CALL_p_ctr) \ + SymI_HasProto(SLOW_CALL_pv_ctr) \ + SymI_HasProto(SLOW_CALL_pp_ctr) \ + SymI_HasProto(SLOW_CALL_ppv_ctr) \ + SymI_HasProto(SLOW_CALL_ppp_ctr) \ + SymI_HasProto(SLOW_CALL_pppv_ctr) \ + SymI_HasProto(SLOW_CALL_pppp_ctr) \ + SymI_HasProto(SLOW_CALL_ppppp_ctr) \ + SymI_HasProto(SLOW_CALL_pppppp_ctr) \ + SymI_HasProto(SLOW_CALL_OTHER_ctr) \ + SymI_HasProto(ticky_slow_call_unevald) \ + SymI_HasProto(SLOW_CALL_ctr) \ + SymI_HasProto(MULTI_CHUNK_SLOW_CALL_ctr) \ + SymI_HasProto(MULTI_CHUNK_SLOW_CALL_CHUNKS_ctr) \ + SymI_HasProto(KNOWN_CALL_ctr) \ + SymI_HasProto(KNOWN_CALL_TOO_FEW_ARGS_ctr) \ + SymI_HasProto(KNOWN_CALL_EXTRA_ARGS_ctr) \ + SymI_HasProto(SLOW_CALL_FUN_TOO_FEW_ctr) \ + SymI_HasProto(SLOW_CALL_FUN_CORRECT_ctr) \ + SymI_HasProto(SLOW_CALL_FUN_TOO_MANY_ctr) \ + SymI_HasProto(SLOW_CALL_PAP_TOO_FEW_ctr) \ + SymI_HasProto(SLOW_CALL_PAP_CORRECT_ctr) \ + SymI_HasProto(SLOW_CALL_PAP_TOO_MANY_ctr) \ + SymI_HasProto(SLOW_CALL_UNEVALD_ctr) \ + SymI_HasProto(UPDF_OMITTED_ctr) \ + SymI_HasProto(UPDF_PUSHED_ctr) \ + SymI_HasProto(CATCHF_PUSHED_ctr) \ + SymI_HasProto(UPDF_RCC_PUSHED_ctr) \ + SymI_HasProto(UPDF_RCC_OMITTED_ctr) \ + SymI_HasProto(UPD_SQUEEZED_ctr) \ + SymI_HasProto(UPD_CON_IN_NEW_ctr) \ + SymI_HasProto(UPD_CON_IN_PLACE_ctr) \ + SymI_HasProto(UPD_PAP_IN_NEW_ctr) \ + SymI_HasProto(UPD_PAP_IN_PLACE_ctr) \ + SymI_HasProto(ALLOC_HEAP_ctr) \ + SymI_HasProto(ALLOC_HEAP_tot) \ + SymI_HasProto(ALLOC_FUN_ctr) \ + SymI_HasProto(ALLOC_FUN_adm) \ + SymI_HasProto(ALLOC_FUN_gds) \ + SymI_HasProto(ALLOC_FUN_slp) \ + SymI_HasProto(UPD_NEW_IND_ctr) \ + SymI_HasProto(UPD_NEW_PERM_IND_ctr) \ + SymI_HasProto(UPD_OLD_IND_ctr) \ + SymI_HasProto(UPD_OLD_PERM_IND_ctr) \ + SymI_HasProto(UPD_BH_UPDATABLE_ctr) \ + SymI_HasProto(UPD_BH_SINGLE_ENTRY_ctr) \ + SymI_HasProto(UPD_CAF_BH_UPDATABLE_ctr) \ + SymI_HasProto(UPD_CAF_BH_SINGLE_ENTRY_ctr) \ + SymI_HasProto(GC_SEL_ABANDONED_ctr) \ + SymI_HasProto(GC_SEL_MINOR_ctr) \ + SymI_HasProto(GC_SEL_MAJOR_ctr) \ + SymI_HasProto(GC_FAILED_PROMOTION_ctr) \ + SymI_HasProto(ALLOC_UP_THK_ctr) \ + SymI_HasProto(ALLOC_SE_THK_ctr) \ + SymI_HasProto(ALLOC_THK_adm) \ + SymI_HasProto(ALLOC_THK_gds) \ + SymI_HasProto(ALLOC_THK_slp) \ + SymI_HasProto(ALLOC_CON_ctr) \ + SymI_HasProto(ALLOC_CON_adm) \ + SymI_HasProto(ALLOC_CON_gds) \ + SymI_HasProto(ALLOC_CON_slp) \ + SymI_HasProto(ALLOC_TUP_ctr) \ + SymI_HasProto(ALLOC_TUP_adm) \ + SymI_HasProto(ALLOC_TUP_gds) \ + SymI_HasProto(ALLOC_TUP_slp) \ + SymI_HasProto(ALLOC_BH_ctr) \ + SymI_HasProto(ALLOC_BH_adm) \ + SymI_HasProto(ALLOC_BH_gds) \ + SymI_HasProto(ALLOC_BH_slp) \ + SymI_HasProto(ALLOC_PRIM_ctr) \ + SymI_HasProto(ALLOC_PRIM_adm) \ + SymI_HasProto(ALLOC_PRIM_gds) \ + SymI_HasProto(ALLOC_PRIM_slp) \ + SymI_HasProto(ALLOC_PAP_ctr) \ + SymI_HasProto(ALLOC_PAP_adm) \ + SymI_HasProto(ALLOC_PAP_gds) \ + SymI_HasProto(ALLOC_PAP_slp) \ + SymI_HasProto(ALLOC_TSO_ctr) \ + SymI_HasProto(ALLOC_TSO_adm) \ + SymI_HasProto(ALLOC_TSO_gds) \ + SymI_HasProto(ALLOC_TSO_slp) \ + SymI_HasProto(RET_NEW_ctr) \ + SymI_HasProto(RET_OLD_ctr) \ + SymI_HasProto(RET_UNBOXED_TUP_ctr) \ + SymI_HasProto(RET_SEMI_loads_avoided) + + #define RTS_SYMBOLS \ Maybe_Stable_Names \ + RTS_TICKY_SYMBOLS \ SymI_HasProto(StgReturn) \ SymI_HasProto(stg_enter_info) \ SymI_HasProto(stg_gc_void_info) \ @@ -823,6 +937,7 @@ typedef struct _RtsSymbolVal { SymI_HasProto(stopTimer) \ SymI_HasProto(n_capabilities) \ SymI_HasProto(stg_traceCcszh) \ + SymI_HasProto(stg_traceEventzh) \ RTS_USER_SIGNALS_SYMBOLS @@ -842,6 +957,37 @@ typedef struct _RtsSymbolVal { #define RTS_LIBGCC_SYMBOLS #endif +/* NOTE [io-manager-ghci] + + When GHCi loads the base package, it gets another copy of the CAFs + in GHC.Conc that record the IO manager's ThreadId, and the blocking + queues, so we get another IO manager. This is bad enough, but what + is worse is that GHCi by default reverts all CAFs on every :load, + so we'll get *another* IO manager thread (and an associated pipe) + every time the user does :load. Miraculously, this actually + manages to just about work in GHC 6.10 and earlier, but broke when + I tried to fix #1185 (restarting the IO manager after a fork()). + + To work around it and ensure that we only have a single IO manager, + we map the CAFs in the dynamically-loaded GHC.Conc to the + statically-linked GHC.Conc. This is an ugly hack, but it's the + least ugly hack that I could think of (SDM 3/11/2009) +*/ + +#define RTS_GHC_CONC_SYMBOLS \ + SymI_NeedsProto(base_GHCziConc_pendingDelays_closure) \ + SymI_NeedsProto(base_GHCziConc_pendingEvents_closure) \ + SymI_NeedsProto(base_GHCziConc_ioManagerThread_closure) + +#ifdef mingw32_HOST_OS +#define RTS_GHC_CONC_OS_SYMBOLS /* empty */ +#else +#define RTS_GHC_CONC_OS_SYMBOLS \ + SymI_NeedsProto(base_GHCziConc_prodding_closure) \ + SymI_NeedsProto(base_GHCziConc_sync_closure) \ + SymI_NeedsProto(base_GHCziConc_stick_closure) +#endif + #if defined(darwin_HOST_OS) && defined(powerpc_HOST_ARCH) // Symbols that don't have a leading underscore // on Mac OS X. They have to receive special treatment, @@ -870,6 +1016,8 @@ RTS_CYGWIN_ONLY_SYMBOLS RTS_DARWIN_ONLY_SYMBOLS RTS_LIBGCC_SYMBOLS RTS_LIBFFI_SYMBOLS +RTS_GHC_CONC_SYMBOLS +RTS_GHC_CONC_OS_SYMBOLS #undef SymI_NeedsProto #undef SymI_HasProto #undef SymI_HasProto_redirect @@ -905,6 +1053,8 @@ static RtsSymbolVal rtsSyms[] = { RTS_DARWIN_ONLY_SYMBOLS RTS_LIBGCC_SYMBOLS RTS_LIBFFI_SYMBOLS + RTS_GHC_CONC_SYMBOLS + RTS_GHC_CONC_OS_SYMBOLS #if defined(darwin_HOST_OS) && defined(i386_HOST_ARCH) // dyld stub code contains references to this, // but it should never be called because we treat @@ -926,12 +1076,18 @@ static void ghciInsertStrHashTable ( char* obj_name, void *data ) { - if (lookupHashTable(table, (StgWord)key) == NULL) - { +#define GHC_CONC "base_GHCziConc" + + if (lookupHashTable(table, (StgWord)key) == NULL) + { insertStrHashTable(table, (StgWord)key, data); return; - } - debugBelch( + } + if (strncmp(key, GHC_CONC, strlen(GHC_CONC)) == 0) { + /* see NOTE [io-manager-ghci] */ + return; + } + debugBelch( "\n\n" "GHCi runtime linker: fatal error: I found a duplicate definition for symbol\n" " %s\n" @@ -946,8 +1102,8 @@ static void ghciInsertStrHashTable ( char* obj_name, "\n", (char*)key, obj_name - ); - exit(1); + ); + exit(1); } /* ----------------------------------------------------------------------------- * initialize the object linker @@ -4002,7 +4158,8 @@ static int relocateSection( || scat->r_type == PPC_RELOC_HI16_SECTDIFF || scat->r_type == PPC_RELOC_HA16_SECTDIFF) #else - else if(scat->r_type == GENERIC_RELOC_SECTDIFF) + else if(scat->r_type == GENERIC_RELOC_SECTDIFF + || scat->r_type == GENERIC_RELOC_LOCAL_SECTDIFF) #endif { struct scattered_relocation_info *pair = @@ -4065,7 +4222,8 @@ static int relocateSection( || scat->r_type == PPC_RELOC_SECTDIFF) #else if(scat->r_type == GENERIC_RELOC_VANILLA - || scat->r_type == GENERIC_RELOC_SECTDIFF) + || scat->r_type == GENERIC_RELOC_SECTDIFF + || scat->r_type == GENERIC_RELOC_LOCAL_SECTDIFF) #endif { *wordPtr = word;