X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=rts%2FLinker.c;h=1d955a378f00d4570b00ff3e6ea7847f1dc0054f;hb=3501ac6af749ada0afcaf84f112ab2e4bf9120b9;hp=0e5630dde70cbf1a0e0815bfb26bec6b45c4dd25;hpb=086827c0811f1327c86b540111dfb62f378c96e9;p=ghc-hetmet.git diff --git a/rts/Linker.c b/rts/Linker.c index 0e5630d..1d955a3 100644 --- a/rts/Linker.c +++ b/rts/Linker.c @@ -224,10 +224,10 @@ typedef struct _RtsSymbolVal { void *addr; } RtsSymbolVal; -#define Maybe_Stable_Names SymI_HasProto(mkWeakzh_fast) \ - SymI_HasProto(mkWeakForeignEnvzh_fast) \ - SymI_HasProto(makeStableNamezh_fast) \ - SymI_HasProto(finalizzeWeakzh_fast) +#define Maybe_Stable_Names SymI_HasProto(stg_mkWeakzh) \ + SymI_HasProto(stg_mkWeakForeignEnvzh) \ + SymI_HasProto(stg_makeStableNamezh) \ + SymI_HasProto(stg_finalizzeWeakzh) #if !defined (mingw32_HOST_OS) #define RTS_POSIX_ONLY_SYMBOLS \ @@ -356,9 +356,9 @@ typedef struct _RtsSymbolVal { /* These are statically linked from the mingw libraries into the ghc executable, so we have to employ this hack. */ #define RTS_MINGW_ONLY_SYMBOLS \ - SymI_HasProto(asyncReadzh_fast) \ - SymI_HasProto(asyncWritezh_fast) \ - SymI_HasProto(asyncDoProczh_fast) \ + SymI_HasProto(stg_asyncReadzh) \ + SymI_HasProto(stg_asyncWritezh) \ + SymI_HasProto(stg_asyncDoProczh) \ SymI_HasProto(memset) \ SymI_HasProto(inet_ntoa) \ SymI_HasProto(inet_addr) \ @@ -423,6 +423,10 @@ typedef struct _RtsSymbolVal { SymI_HasProto(expf) \ SymI_HasProto(logf) \ SymI_HasProto(sqrtf) \ + SymI_HasProto(erf) \ + SymI_HasProto(erfc) \ + SymI_HasProto(erff) \ + SymI_HasProto(erfcf) \ SymI_HasProto(memcpy) \ SymI_HasProto(rts_InstallConsoleEvent) \ SymI_HasProto(rts_ConsoleHandlerDone) \ @@ -501,8 +505,8 @@ typedef struct _RtsSymbolVal { #if !defined(mingw32_HOST_OS) #define RTS_USER_SIGNALS_SYMBOLS \ SymI_HasProto(setIOManagerPipe) \ - SymI_NeedsProto(blockUserSignals) \ - SymI_NeedsProto(unblockUserSignals) + SymI_HasProto(blockUserSignals) \ + SymI_HasProto(unblockUserSignals) #else #define RTS_USER_SIGNALS_SYMBOLS \ SymI_HasProto(sendIOManagerEvent) \ @@ -549,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) \ @@ -591,29 +709,29 @@ typedef struct _RtsSymbolVal { SymI_HasProto(__2Int_encodeDouble) \ SymI_HasProto(__int_encodeFloat) \ SymI_HasProto(__word_encodeFloat) \ - SymI_HasProto(atomicallyzh_fast) \ + SymI_HasProto(stg_atomicallyzh) \ SymI_HasProto(barf) \ SymI_HasProto(debugBelch) \ SymI_HasProto(errorBelch) \ SymI_HasProto(sysErrorBelch) \ - SymI_HasProto(asyncExceptionsBlockedzh_fast) \ - SymI_HasProto(blockAsyncExceptionszh_fast) \ - SymI_HasProto(catchzh_fast) \ - SymI_HasProto(catchRetryzh_fast) \ - SymI_HasProto(catchSTMzh_fast) \ - SymI_HasProto(checkzh_fast) \ + SymI_HasProto(stg_asyncExceptionsBlockedzh) \ + SymI_HasProto(stg_blockAsyncExceptionszh) \ + SymI_HasProto(stg_catchzh) \ + SymI_HasProto(stg_catchRetryzh) \ + SymI_HasProto(stg_catchSTMzh) \ + SymI_HasProto(stg_checkzh) \ SymI_HasProto(closure_flags) \ SymI_HasProto(cmp_thread) \ SymI_HasProto(createAdjustor) \ - SymI_HasProto(decodeDoublezu2Intzh_fast) \ - SymI_HasProto(decodeFloatzuIntzh_fast) \ + SymI_HasProto(stg_decodeDoublezu2Intzh) \ + SymI_HasProto(stg_decodeFloatzuIntzh) \ SymI_HasProto(defaultsHook) \ - SymI_HasProto(delayzh_fast) \ - SymI_HasProto(deRefWeakzh_fast) \ - SymI_HasProto(deRefStablePtrzh_fast) \ + SymI_HasProto(stg_delayzh) \ + SymI_HasProto(stg_deRefWeakzh) \ + SymI_HasProto(stg_deRefStablePtrzh) \ SymI_HasProto(dirty_MUT_VAR) \ - SymI_HasProto(forkzh_fast) \ - SymI_HasProto(forkOnzh_fast) \ + SymI_HasProto(stg_forkzh) \ + SymI_HasProto(stg_forkOnzh) \ SymI_HasProto(forkProcess) \ SymI_HasProto(forkOS_createThread) \ SymI_HasProto(freeHaskellFunctionPtr) \ @@ -634,44 +752,44 @@ typedef struct _RtsSymbolVal { SymI_HasProto(hs_hpc_rootModule) \ SymI_HasProto(hs_hpc_module) \ SymI_HasProto(initLinker) \ - SymI_HasProto(unpackClosurezh_fast) \ - SymI_HasProto(getApStackValzh_fast) \ - SymI_HasProto(getSparkzh_fast) \ - SymI_HasProto(isCurrentThreadBoundzh_fast) \ - SymI_HasProto(isEmptyMVarzh_fast) \ - SymI_HasProto(killThreadzh_fast) \ + SymI_HasProto(stg_unpackClosurezh) \ + SymI_HasProto(stg_getApStackValzh) \ + SymI_HasProto(stg_getSparkzh) \ + SymI_HasProto(stg_isCurrentThreadBoundzh) \ + SymI_HasProto(stg_isEmptyMVarzh) \ + SymI_HasProto(stg_killThreadzh) \ SymI_HasProto(loadObj) \ SymI_HasProto(insertStableSymbol) \ SymI_HasProto(insertSymbol) \ SymI_HasProto(lookupSymbol) \ - SymI_HasProto(makeStablePtrzh_fast) \ - SymI_HasProto(mkApUpd0zh_fast) \ - SymI_HasProto(myThreadIdzh_fast) \ - SymI_HasProto(labelThreadzh_fast) \ - SymI_HasProto(newArrayzh_fast) \ - SymI_HasProto(newBCOzh_fast) \ - SymI_HasProto(newByteArrayzh_fast) \ + SymI_HasProto(stg_makeStablePtrzh) \ + SymI_HasProto(stg_mkApUpd0zh) \ + SymI_HasProto(stg_myThreadIdzh) \ + SymI_HasProto(stg_labelThreadzh) \ + SymI_HasProto(stg_newArrayzh) \ + SymI_HasProto(stg_newBCOzh) \ + SymI_HasProto(stg_newByteArrayzh) \ SymI_HasProto_redirect(newCAF, newDynCAF) \ - SymI_HasProto(newMVarzh_fast) \ - SymI_HasProto(newMutVarzh_fast) \ - SymI_HasProto(newTVarzh_fast) \ - SymI_HasProto(noDuplicatezh_fast) \ - SymI_HasProto(atomicModifyMutVarzh_fast) \ - SymI_HasProto(newPinnedByteArrayzh_fast) \ - SymI_HasProto(newAlignedPinnedByteArrayzh_fast) \ + SymI_HasProto(stg_newMVarzh) \ + SymI_HasProto(stg_newMutVarzh) \ + SymI_HasProto(stg_newTVarzh) \ + SymI_HasProto(stg_noDuplicatezh) \ + SymI_HasProto(stg_atomicModifyMutVarzh) \ + SymI_HasProto(stg_newPinnedByteArrayzh) \ + SymI_HasProto(stg_newAlignedPinnedByteArrayzh) \ SymI_HasProto(newSpark) \ SymI_HasProto(performGC) \ SymI_HasProto(performMajorGC) \ SymI_HasProto(prog_argc) \ SymI_HasProto(prog_argv) \ - SymI_HasProto(putMVarzh_fast) \ - SymI_HasProto(raisezh_fast) \ - SymI_HasProto(raiseIOzh_fast) \ - SymI_HasProto(readTVarzh_fast) \ - SymI_HasProto(readTVarIOzh_fast) \ + SymI_HasProto(stg_putMVarzh) \ + SymI_HasProto(stg_raisezh) \ + SymI_HasProto(stg_raiseIOzh) \ + SymI_HasProto(stg_readTVarzh) \ + SymI_HasProto(stg_readTVarIOzh) \ SymI_HasProto(resumeThread) \ SymI_HasProto(resolveObjs) \ - SymI_HasProto(retryzh_fast) \ + SymI_HasProto(stg_retryzh) \ SymI_HasProto(rts_apply) \ SymI_HasProto(rts_checkSchedStatus) \ SymI_HasProto(rts_eval) \ @@ -793,17 +911,17 @@ typedef struct _RtsSymbolVal { SymI_HasProto(stg_sel_9_upd_info) \ SymI_HasProto(stg_upd_frame_info) \ SymI_HasProto(suspendThread) \ - SymI_HasProto(takeMVarzh_fast) \ - SymI_HasProto(threadStatuszh_fast) \ - SymI_HasProto(tryPutMVarzh_fast) \ - SymI_HasProto(tryTakeMVarzh_fast) \ - SymI_HasProto(unblockAsyncExceptionszh_fast) \ + SymI_HasProto(stg_takeMVarzh) \ + SymI_HasProto(stg_threadStatuszh) \ + SymI_HasProto(stg_tryPutMVarzh) \ + SymI_HasProto(stg_tryTakeMVarzh) \ + SymI_HasProto(stg_unblockAsyncExceptionszh) \ SymI_HasProto(unloadObj) \ - SymI_HasProto(unsafeThawArrayzh_fast) \ - SymI_HasProto(waitReadzh_fast) \ - SymI_HasProto(waitWritezh_fast) \ - SymI_HasProto(writeTVarzh_fast) \ - SymI_HasProto(yieldzh_fast) \ + SymI_HasProto(stg_unsafeThawArrayzh) \ + SymI_HasProto(stg_waitReadzh) \ + SymI_HasProto(stg_waitWritezh) \ + SymI_HasProto(stg_writeTVarzh) \ + SymI_HasProto(stg_yieldzh) \ SymI_NeedsProto(stg_interp_constr_entry) \ SymI_HasProto(alloc_blocks) \ SymI_HasProto(alloc_blocks_lim) \ @@ -818,7 +936,8 @@ typedef struct _RtsSymbolVal { SymI_NeedsProto(rts_stop_on_exception) \ SymI_HasProto(stopTimer) \ SymI_HasProto(n_capabilities) \ - SymI_HasProto(traceCcszh_fast) \ + SymI_HasProto(stg_traceCcszh) \ + SymI_HasProto(stg_traceEventzh) \ RTS_USER_SIGNALS_SYMBOLS @@ -834,18 +953,41 @@ typedef struct _RtsSymbolVal { SymI_NeedsProto(__ashrdi3) \ SymI_NeedsProto(__lshrdi3) \ SymI_NeedsProto(__eprintf) -#elif defined(ia64_HOST_ARCH) -#define RTS_LIBGCC_SYMBOLS \ - SymI_NeedsProto(__divdi3) \ - SymI_NeedsProto(__udivdi3) \ - SymI_NeedsProto(__moddi3) \ - SymI_NeedsProto(__umoddi3) \ - SymI_NeedsProto(__divsf3) \ - SymI_NeedsProto(__divdf3) #else #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, @@ -874,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 @@ -909,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 @@ -930,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" @@ -950,8 +1102,8 @@ static void ghciInsertStrHashTable ( char* obj_name, "\n", (char*)key, obj_name - ); - exit(1); + ); + exit(1); } /* ----------------------------------------------------------------------------- * initialize the object linker @@ -1254,10 +1406,6 @@ void ghci_enquire ( char* addr ) } #endif -#ifdef ia64_HOST_ARCH -static unsigned int PLTSize(void); -#endif - #ifdef USE_MMAP #define ROUND_UP(x,size) ((x + size - 1) & ~(size - 1)) @@ -1413,28 +1561,7 @@ loadObj( char *path ) if (fd == -1) barf("loadObj: can't open `%s'", path); -#ifdef ia64_HOST_ARCH - /* The PLT needs to be right before the object */ - { - int pagesize, n; - pagesize = getpagesize(); - n = ROUND_UP(PLTSize(), pagesize); - oc->plt = mmap(NULL, n, PROT_EXEC|PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0); - if (oc->plt == MAP_FAILED) - barf("loadObj: can't allocate PLT"); - - oc->pltIndex = 0; - map_addr = oc->plt + n; - - n = ROUND_UP(oc->fileSize, pagesize); - oc->image = mmap(map_addr, n, PROT_EXEC|PROT_READ|PROT_WRITE, - MAP_PRIVATE|TRY_MAP_32BIT, fd, 0); - if (oc->image == MAP_FAILED) - barf("loadObj: can't map `%s'", path); - } -#else oc->image = mmapForLinker(oc->fileSize, 0, fd); -#endif close(fd); @@ -2684,12 +2811,6 @@ ocResolve_PEi386 ( ObjectCode* oc ) #elif defined(x86_64_HOST_ARCH) # define ELF_TARGET_X64_64 # define ELF_64BIT -#elif defined (ia64_HOST_ARCH) -# define ELF_TARGET_IA64 /* Used inside */ -# define ELF_64BIT -# define ELF_FUNCTION_DESC /* calling convention uses function descriptors */ -# define ELF_NEED_GOT /* needs Global Offset Table */ -# define ELF_NEED_PLT /* needs Procedure Linkage Tables */ #endif #if !defined(openbsd_HOST_OS) @@ -2819,30 +2940,6 @@ copyFunctionDesc(Elf_Addr target) #endif #ifdef ELF_NEED_PLT -#ifdef ia64_HOST_ARCH -static void ia64_reloc_gprel22(Elf_Addr target, Elf_Addr value); -static void ia64_reloc_pcrel21(Elf_Addr target, Elf_Addr value, ObjectCode *oc); - -static unsigned char plt_code[] = -{ - /* taken from binutils bfd/elfxx-ia64.c */ - 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */ - 0x00, 0x41, 0x3c, 0x30, 0x28, 0xc0, /* ld8 r16=[r15],8 */ - 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */ - 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */ - 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */ - 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */ -}; - -/* If we can't get to the function descriptor via gp, take a local copy of it */ -#define PLT_RELOC(code, target) { \ - Elf64_Sxword rel_value = target - gp_val; \ - if ((rel_value > 0x1fffff) || (rel_value < -0x1fffff)) \ - ia64_reloc_gprel22((Elf_Addr)code, copyFunctionDesc(target)); \ - else \ - ia64_reloc_gprel22((Elf_Addr)code, target); \ - } -#endif typedef struct { unsigned char code[sizeof(plt_code)]; @@ -2900,25 +2997,6 @@ findElfSection ( void* objImage, Elf_Word sh_type ) return ptr; } -#if defined(ia64_HOST_ARCH) -static Elf_Addr -findElfSegment ( void* objImage, Elf_Addr vaddr ) -{ - char* ehdrC = (char*)objImage; - Elf_Ehdr* ehdr = (Elf_Ehdr*)ehdrC; - Elf_Phdr* phdr = (Elf_Phdr*)(ehdrC + ehdr->e_phoff); - Elf_Addr segaddr = 0; - int i; - - for (i = 0; i < ehdr->e_phnum; i++) { - segaddr = phdr[i].p_vaddr; - if ((vaddr >= segaddr) && (vaddr < segaddr + phdr[i].p_memsz)) - break; - } - return segaddr; -} -#endif - static int ocVerifyImage_ELF ( ObjectCode* oc ) { @@ -3412,9 +3490,6 @@ do_Elf_Rela_relocations ( ObjectCode* oc, char* ehdrC, # if defined(sparc_HOST_ARCH) Elf_Word* pP = (Elf_Word*)P; Elf_Word w1, w2; -# elif defined(ia64_HOST_ARCH) - Elf64_Xword *pP = (Elf64_Xword *)P; - Elf_Addr addr; # elif defined(powerpc_HOST_ARCH) Elf_Sword delta; # endif @@ -3515,34 +3590,6 @@ do_Elf_Rela_relocations ( ObjectCode* oc, char* ehdrC, w2 = (Elf_Word)value; *pP = w2; break; -# elif defined(ia64_HOST_ARCH) - case R_IA64_DIR64LSB: - case R_IA64_FPTR64LSB: - *pP = value; - break; - case R_IA64_PCREL64LSB: - *pP = value - P; - break; - case R_IA64_SEGREL64LSB: - addr = findElfSegment(ehdrC, value); - *pP = value - addr; - break; - case R_IA64_GPREL22: - ia64_reloc_gprel22(P, value); - break; - case R_IA64_LTOFF22: - case R_IA64_LTOFF22X: - case R_IA64_LTOFF_FPTR22: - addr = allocateGOTEntry(value); - ia64_reloc_gprel22(P, addr); - break; - case R_IA64_PCREL21B: - ia64_reloc_pcrel21(P, S, oc); - break; - case R_IA64_LDXMOV: - /* This goes with R_IA64_LTOFF22X and points to the load to - * convert into a move. We don't implement relaxation. */ - break; # elif defined(powerpc_HOST_ARCH) case R_PPC_ADDR16_LO: *(Elf32_Half*) P = value; @@ -3718,98 +3765,6 @@ ocResolve_ELF ( ObjectCode* oc ) } /* - * IA64 specifics - * Instructions are 41 bits long, packed into 128 bit bundles with a 5-bit template - * at the front. The following utility functions pack and unpack instructions, and - * take care of the most common relocations. - */ - -#ifdef ia64_HOST_ARCH - -static Elf64_Xword -ia64_extract_instruction(Elf64_Xword *target) -{ - Elf64_Xword w1, w2; - int slot = (Elf_Addr)target & 3; - target = (Elf_Addr)target & ~3; - - w1 = *target; - w2 = *(target+1); - - switch (slot) - { - case 0: - return ((w1 >> 5) & 0x1ffffffffff); - case 1: - return (w1 >> 46) | ((w2 & 0x7fffff) << 18); - case 2: - return (w2 >> 23); - default: - barf("ia64_extract_instruction: invalid slot %p", target); - } -} - -static void -ia64_deposit_instruction(Elf64_Xword *target, Elf64_Xword value) -{ - int slot = (Elf_Addr)target & 3; - target = (Elf_Addr)target & ~3; - - switch (slot) - { - case 0: - *target |= value << 5; - break; - case 1: - *target |= value << 46; - *(target+1) |= value >> 18; - break; - case 2: - *(target+1) |= value << 23; - break; - } -} - -static void -ia64_reloc_gprel22(Elf_Addr target, Elf_Addr value) -{ - Elf64_Xword instruction; - Elf64_Sxword rel_value; - - rel_value = value - gp_val; - if ((rel_value > 0x1fffff) || (rel_value < -0x1fffff)) - barf("GP-relative data out of range (address = 0x%lx, gp = 0x%lx)", value, gp_val); - - instruction = ia64_extract_instruction((Elf64_Xword *)target); - instruction |= (((rel_value >> 0) & 0x07f) << 13) /* imm7b */ - | (((rel_value >> 7) & 0x1ff) << 27) /* imm9d */ - | (((rel_value >> 16) & 0x01f) << 22) /* imm5c */ - | ((Elf64_Xword)(rel_value < 0) << 36); /* s */ - ia64_deposit_instruction((Elf64_Xword *)target, instruction); -} - -static void -ia64_reloc_pcrel21(Elf_Addr target, Elf_Addr value, ObjectCode *oc) -{ - Elf64_Xword instruction; - Elf64_Sxword rel_value; - Elf_Addr entry; - - entry = allocatePLTEntry(value, oc); - - rel_value = (entry >> 4) - (target >> 4); - if ((rel_value > 0xfffff) || (rel_value < -0xfffff)) - barf("PLT entry too far away (entry = 0x%lx, target = 0x%lx)", entry, target); - - instruction = ia64_extract_instruction((Elf64_Xword *)target); - instruction |= ((rel_value & 0xfffff) << 13) /* imm20b */ - | ((Elf64_Xword)(rel_value < 0) << 36); /* s */ - ia64_deposit_instruction((Elf64_Xword *)target, instruction); -} - -#endif /* ia64 */ - -/* * PowerPC & X86_64 ELF specifics */ @@ -4203,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 = @@ -4266,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;