1 /* -----------------------------------------------------------------------------
2 * $Id: Linker.c,v 1.137 2003/10/08 10:37:25 wolfgang Exp $
4 * (c) The GHC Team, 2000-2003
8 * ---------------------------------------------------------------------------*/
11 #include "PosixSource.h"
18 #include "LinkerInternals.h"
20 #include "StoragePriv.h"
23 #ifdef HAVE_SYS_TYPES_H
24 #include <sys/types.h>
30 #ifdef HAVE_SYS_STAT_H
34 #if defined(HAVE_FRAMEWORK_HASKELLSUPPORT)
35 #include <HaskellSupport/dlfcn.h>
36 #elif defined(HAVE_DLFCN_H)
40 #if defined(cygwin32_TARGET_OS)
45 #ifdef HAVE_SYS_TIME_H
49 #include <sys/fcntl.h>
50 #include <sys/termios.h>
51 #include <sys/utime.h>
52 #include <sys/utsname.h>
56 #if defined(ia64_TARGET_ARCH)
62 #if defined(linux_TARGET_OS) || defined(solaris2_TARGET_OS) || defined(freebsd_TARGET_OS) || defined(netbsd_TARGET_OS) || defined(openbsd_TARGET_OS)
63 # define OBJFORMAT_ELF
64 #elif defined(cygwin32_TARGET_OS) || defined (mingw32_TARGET_OS)
65 # define OBJFORMAT_PEi386
68 #elif defined(darwin_TARGET_OS)
69 # include <mach-o/ppc/reloc.h>
70 # define OBJFORMAT_MACHO
71 # include <mach-o/loader.h>
72 # include <mach-o/nlist.h>
73 # include <mach-o/reloc.h>
74 # include <mach-o/dyld.h>
77 /* Hash table mapping symbol names to Symbol */
78 static /*Str*/HashTable *symhash;
80 /* List of currently loaded objects */
81 ObjectCode *objects = NULL; /* initially empty */
83 #if defined(OBJFORMAT_ELF)
84 static int ocVerifyImage_ELF ( ObjectCode* oc );
85 static int ocGetNames_ELF ( ObjectCode* oc );
86 static int ocResolve_ELF ( ObjectCode* oc );
87 #elif defined(OBJFORMAT_PEi386)
88 static int ocVerifyImage_PEi386 ( ObjectCode* oc );
89 static int ocGetNames_PEi386 ( ObjectCode* oc );
90 static int ocResolve_PEi386 ( ObjectCode* oc );
91 #elif defined(OBJFORMAT_MACHO)
92 static int ocAllocateJumpIslands_MachO ( ObjectCode* oc );
93 static int ocVerifyImage_MachO ( ObjectCode* oc );
94 static int ocGetNames_MachO ( ObjectCode* oc );
95 static int ocResolve_MachO ( ObjectCode* oc );
97 static void machoInitSymbolsWithoutUnderscore( void );
100 /* -----------------------------------------------------------------------------
101 * Built-in symbols from the RTS
104 typedef struct _RtsSymbolVal {
111 #define Maybe_ForeignObj SymX(mkForeignObjzh_fast)
113 #define Maybe_Stable_Names SymX(mkWeakzh_fast) \
114 SymX(makeStableNamezh_fast) \
115 SymX(finalizzeWeakzh_fast)
117 /* These are not available in GUM!!! -- HWL */
118 #define Maybe_ForeignObj
119 #define Maybe_Stable_Names
122 #if !defined (mingw32_TARGET_OS)
123 #define RTS_POSIX_ONLY_SYMBOLS \
124 SymX(stg_sig_install) \
128 #if defined (cygwin32_TARGET_OS)
129 #define RTS_MINGW_ONLY_SYMBOLS /**/
130 /* Don't have the ability to read import libs / archives, so
131 * we have to stupidly list a lot of what libcygwin.a
134 #define RTS_CYGWIN_ONLY_SYMBOLS \
212 #elif !defined(mingw32_TARGET_OS)
213 #define RTS_MINGW_ONLY_SYMBOLS /**/
214 #define RTS_CYGWIN_ONLY_SYMBOLS /**/
215 #else /* defined(mingw32_TARGET_OS) */
216 #define RTS_POSIX_ONLY_SYMBOLS /**/
217 #define RTS_CYGWIN_ONLY_SYMBOLS /**/
219 /* Extra syms gen'ed by mingw-2's gcc-3.2: */
221 #define RTS_MINGW_EXTRA_SYMS \
222 Sym(_imp____mb_cur_max) \
225 #define RTS_MINGW_EXTRA_SYMS
228 /* These are statically linked from the mingw libraries into the ghc
229 executable, so we have to employ this hack. */
230 #define RTS_MINGW_ONLY_SYMBOLS \
231 SymX(asyncReadzh_fast) \
232 SymX(asyncWritezh_fast) \
244 SymX(getservbyname) \
245 SymX(getservbyport) \
246 SymX(getprotobynumber) \
247 SymX(getprotobyname) \
248 SymX(gethostbyname) \
249 SymX(gethostbyaddr) \
284 Sym(_imp___timezone) \
292 RTS_MINGW_EXTRA_SYMS \
297 # define MAIN_CAP_SYM SymX(MainCapability)
299 # define MAIN_CAP_SYM
302 #define RTS_SYMBOLS \
306 SymX(stg_enter_info) \
307 SymX(stg_enter_ret) \
308 SymX(stg_gc_void_info) \
309 SymX(__stg_gc_enter_1) \
310 SymX(stg_gc_noregs) \
311 SymX(stg_gc_unpt_r1_info) \
312 SymX(stg_gc_unpt_r1) \
313 SymX(stg_gc_unbx_r1_info) \
314 SymX(stg_gc_unbx_r1) \
315 SymX(stg_gc_f1_info) \
317 SymX(stg_gc_d1_info) \
319 SymX(stg_gc_l1_info) \
322 SymX(stg_gc_fun_info) \
323 SymX(stg_gc_fun_ret) \
325 SymX(stg_gc_gen_info) \
326 SymX(stg_gc_gen_hp) \
328 SymX(stg_gen_yield) \
329 SymX(stg_yield_noregs) \
330 SymX(stg_yield_to_interpreter) \
331 SymX(stg_gen_block) \
332 SymX(stg_block_noregs) \
334 SymX(stg_block_takemvar) \
335 SymX(stg_block_putmvar) \
336 SymX(stg_seq_frame_info) \
339 SymX(MallocFailHook) \
341 SymX(OutOfHeapHook) \
342 SymX(PatErrorHdrHook) \
343 SymX(PostTraceHook) \
345 SymX(StackOverflowHook) \
346 SymX(__encodeDouble) \
347 SymX(__encodeFloat) \
350 SymX(__gmpz_cmp_si) \
351 SymX(__gmpz_cmp_ui) \
352 SymX(__gmpz_get_si) \
353 SymX(__gmpz_get_ui) \
354 SymX(__int_encodeDouble) \
355 SymX(__int_encodeFloat) \
356 SymX(andIntegerzh_fast) \
357 SymX(blockAsyncExceptionszh_fast) \
360 SymX(complementIntegerzh_fast) \
361 SymX(cmpIntegerzh_fast) \
362 SymX(cmpIntegerIntzh_fast) \
363 SymX(createAdjustor) \
364 SymX(decodeDoublezh_fast) \
365 SymX(decodeFloatzh_fast) \
368 SymX(deRefWeakzh_fast) \
369 SymX(deRefStablePtrzh_fast) \
370 SymX(divExactIntegerzh_fast) \
371 SymX(divModIntegerzh_fast) \
374 SymX(forkOS_createThread) \
375 SymX(freeHaskellFunctionPtr) \
376 SymX(freeStablePtr) \
377 SymX(gcdIntegerzh_fast) \
378 SymX(gcdIntegerIntzh_fast) \
379 SymX(gcdIntzh_fast) \
383 SymX(int2Integerzh_fast) \
384 SymX(integer2Intzh_fast) \
385 SymX(integer2Wordzh_fast) \
386 SymX(isCurrentThreadBoundzh_fast) \
387 SymX(isDoubleDenormalized) \
388 SymX(isDoubleInfinite) \
390 SymX(isDoubleNegativeZero) \
391 SymX(isEmptyMVarzh_fast) \
392 SymX(isFloatDenormalized) \
393 SymX(isFloatInfinite) \
395 SymX(isFloatNegativeZero) \
396 SymX(killThreadzh_fast) \
397 SymX(makeStablePtrzh_fast) \
398 SymX(minusIntegerzh_fast) \
399 SymX(mkApUpd0zh_fast) \
400 SymX(myThreadIdzh_fast) \
401 SymX(labelThreadzh_fast) \
402 SymX(newArrayzh_fast) \
403 SymX(newBCOzh_fast) \
404 SymX(newByteArrayzh_fast) \
405 SymX_redirect(newCAF, newDynCAF) \
406 SymX(newMVarzh_fast) \
407 SymX(newMutVarzh_fast) \
408 SymX(atomicModifyMutVarzh_fast) \
409 SymX(newPinnedByteArrayzh_fast) \
410 SymX(orIntegerzh_fast) \
412 SymX(plusIntegerzh_fast) \
415 SymX(putMVarzh_fast) \
416 SymX(quotIntegerzh_fast) \
417 SymX(quotRemIntegerzh_fast) \
419 SymX(raiseIOzh_fast) \
420 SymX(remIntegerzh_fast) \
421 SymX(resetNonBlockingFd) \
424 SymX(rts_checkSchedStatus) \
427 SymX(rts_evalLazyIO) \
428 SymX(rts_evalStableIO) \
432 SymX(rts_getDouble) \
437 SymX(rts_getFunPtr) \
438 SymX(rts_getStablePtr) \
439 SymX(rts_getThreadId) \
441 SymX(rts_getWord32) \
454 SymX(rts_mkStablePtr) \
462 SymX(rtsSupportsBoundThreads) \
464 SymX(__hscore_get_saved_termios) \
465 SymX(__hscore_set_saved_termios) \
467 SymX(startupHaskell) \
468 SymX(shutdownHaskell) \
469 SymX(shutdownHaskellAndExit) \
470 SymX(stable_ptr_table) \
471 SymX(stackOverflow) \
472 SymX(stg_CAF_BLACKHOLE_info) \
473 SymX(stg_BLACKHOLE_BQ_info) \
474 SymX(awakenBlockedQueue) \
475 SymX(stg_CHARLIKE_closure) \
476 SymX(stg_EMPTY_MVAR_info) \
477 SymX(stg_IND_STATIC_info) \
478 SymX(stg_INTLIKE_closure) \
479 SymX(stg_MUT_ARR_PTRS_FROZEN_info) \
480 SymX(stg_WEAK_info) \
481 SymX(stg_ap_v_info) \
482 SymX(stg_ap_f_info) \
483 SymX(stg_ap_d_info) \
484 SymX(stg_ap_l_info) \
485 SymX(stg_ap_n_info) \
486 SymX(stg_ap_p_info) \
487 SymX(stg_ap_pv_info) \
488 SymX(stg_ap_pp_info) \
489 SymX(stg_ap_ppv_info) \
490 SymX(stg_ap_ppp_info) \
491 SymX(stg_ap_pppp_info) \
492 SymX(stg_ap_ppppp_info) \
493 SymX(stg_ap_pppppp_info) \
494 SymX(stg_ap_ppppppp_info) \
502 SymX(stg_ap_pv_ret) \
503 SymX(stg_ap_pp_ret) \
504 SymX(stg_ap_ppv_ret) \
505 SymX(stg_ap_ppp_ret) \
506 SymX(stg_ap_pppp_ret) \
507 SymX(stg_ap_ppppp_ret) \
508 SymX(stg_ap_pppppp_ret) \
509 SymX(stg_ap_ppppppp_ret) \
510 SymX(stg_ap_1_upd_info) \
511 SymX(stg_ap_2_upd_info) \
512 SymX(stg_ap_3_upd_info) \
513 SymX(stg_ap_4_upd_info) \
514 SymX(stg_ap_5_upd_info) \
515 SymX(stg_ap_6_upd_info) \
516 SymX(stg_ap_7_upd_info) \
517 SymX(stg_ap_8_upd_info) \
519 SymX(stg_sel_0_upd_info) \
520 SymX(stg_sel_10_upd_info) \
521 SymX(stg_sel_11_upd_info) \
522 SymX(stg_sel_12_upd_info) \
523 SymX(stg_sel_13_upd_info) \
524 SymX(stg_sel_14_upd_info) \
525 SymX(stg_sel_15_upd_info) \
526 SymX(stg_sel_1_upd_info) \
527 SymX(stg_sel_2_upd_info) \
528 SymX(stg_sel_3_upd_info) \
529 SymX(stg_sel_4_upd_info) \
530 SymX(stg_sel_5_upd_info) \
531 SymX(stg_sel_6_upd_info) \
532 SymX(stg_sel_7_upd_info) \
533 SymX(stg_sel_8_upd_info) \
534 SymX(stg_sel_9_upd_info) \
535 SymX(stg_upd_frame_info) \
536 SymX(suspendThread) \
537 SymX(takeMVarzh_fast) \
538 SymX(timesIntegerzh_fast) \
539 SymX(tryPutMVarzh_fast) \
540 SymX(tryTakeMVarzh_fast) \
541 SymX(unblockAsyncExceptionszh_fast) \
542 SymX(unsafeThawArrayzh_fast) \
543 SymX(waitReadzh_fast) \
544 SymX(waitWritezh_fast) \
545 SymX(word2Integerzh_fast) \
546 SymX(xorIntegerzh_fast) \
549 #ifdef SUPPORT_LONG_LONGS
550 #define RTS_LONG_LONG_SYMS \
551 SymX(int64ToIntegerzh_fast) \
552 SymX(word64ToIntegerzh_fast)
554 #define RTS_LONG_LONG_SYMS /* nothing */
557 // 64-bit support functions in libgcc.a
558 #if defined(__GNUC__) && SIZEOF_VOID_P <= 4
559 #define RTS_LIBGCC_SYMBOLS \
568 #elif defined(ia64_TARGET_ARCH)
569 #define RTS_LIBGCC_SYMBOLS \
577 #define RTS_LIBGCC_SYMBOLS
580 #ifdef darwin_TARGET_OS
581 // Symbols that don't have a leading underscore
582 // on Mac OS X. They have to receive special treatment,
583 // see machoInitSymbolsWithoutUnderscore()
584 #define RTS_MACHO_NOUNDERLINE_SYMBOLS \
589 /* entirely bogus claims about types of these symbols */
590 #define Sym(vvv) extern void vvv(void);
591 #define SymX(vvv) /**/
592 #define SymX_redirect(vvv,xxx) /**/
595 RTS_POSIX_ONLY_SYMBOLS
596 RTS_MINGW_ONLY_SYMBOLS
597 RTS_CYGWIN_ONLY_SYMBOLS
603 #ifdef LEADING_UNDERSCORE
604 #define MAYBE_LEADING_UNDERSCORE_STR(s) ("_" s)
606 #define MAYBE_LEADING_UNDERSCORE_STR(s) (s)
609 #define Sym(vvv) { MAYBE_LEADING_UNDERSCORE_STR(#vvv), \
611 #define SymX(vvv) Sym(vvv)
613 // SymX_redirect allows us to redirect references to one symbol to
614 // another symbol. See newCAF/newDynCAF for an example.
615 #define SymX_redirect(vvv,xxx) \
616 { MAYBE_LEADING_UNDERSCORE_STR(#vvv), \
619 static RtsSymbolVal rtsSyms[] = {
622 RTS_POSIX_ONLY_SYMBOLS
623 RTS_MINGW_ONLY_SYMBOLS
624 RTS_CYGWIN_ONLY_SYMBOLS
626 { 0, 0 } /* sentinel */
629 /* -----------------------------------------------------------------------------
630 * Insert symbols into hash tables, checking for duplicates.
632 static void ghciInsertStrHashTable ( char* obj_name,
638 if (lookupHashTable(table, (StgWord)key) == NULL)
640 insertStrHashTable(table, (StgWord)key, data);
645 "GHCi runtime linker: fatal error: I found a duplicate definition for symbol\n"
647 "whilst processing object file\n"
649 "This could be caused by:\n"
650 " * Loading two different object files which export the same symbol\n"
651 " * Specifying the same object file twice on the GHCi command line\n"
652 " * An incorrect `package.conf' entry, causing some object to be\n"
654 "GHCi cannot safely continue in this situation. Exiting now. Sorry.\n"
663 /* -----------------------------------------------------------------------------
664 * initialize the object linker
668 static int linker_init_done = 0 ;
670 #if defined(OBJFORMAT_ELF) || defined(OBJFORMAT_MACHO)
671 static void *dl_prog_handle;
679 /* Make initLinker idempotent, so we can call it
680 before evey relevant operation; that means we
681 don't need to initialise the linker separately */
682 if (linker_init_done == 1) { return; } else {
683 linker_init_done = 1;
686 symhash = allocStrHashTable();
688 /* populate the symbol table with stuff from the RTS */
689 for (sym = rtsSyms; sym->lbl != NULL; sym++) {
690 ghciInsertStrHashTable("(GHCi built-in symbols)",
691 symhash, sym->lbl, sym->addr);
693 # if defined(OBJFORMAT_MACHO)
694 machoInitSymbolsWithoutUnderscore();
697 # if defined(OBJFORMAT_ELF) || defined(OBJFORMAT_MACHO)
698 dl_prog_handle = dlopen(NULL, RTLD_LAZY);
702 /* -----------------------------------------------------------------------------
703 * Loading DLL or .so dynamic libraries
704 * -----------------------------------------------------------------------------
706 * Add a DLL from which symbols may be found. In the ELF case, just
707 * do RTLD_GLOBAL-style add, so no further messing around needs to
708 * happen in order that symbols in the loaded .so are findable --
709 * lookupSymbol() will subsequently see them by dlsym on the program's
710 * dl-handle. Returns NULL if success, otherwise ptr to an err msg.
712 * In the PEi386 case, open the DLLs and put handles to them in a
713 * linked list. When looking for a symbol, try all handles in the
714 * list. This means that we need to load even DLLs that are guaranteed
715 * to be in the ghc.exe image already, just so we can get a handle
716 * to give to loadSymbol, so that we can find the symbols. For such
717 * libraries, the LoadLibrary call should be a no-op except for returning
722 #if defined(OBJFORMAT_PEi386)
723 /* A record for storing handles into DLLs. */
728 struct _OpenedDLL* next;
733 /* A list thereof. */
734 static OpenedDLL* opened_dlls = NULL;
738 addDLL( char *dll_name )
740 # if defined(OBJFORMAT_ELF) || defined(OBJFORMAT_MACHO)
741 /* ------------------- ELF DLL loader ------------------- */
747 #if !defined(openbsd_TARGET_OS)
748 hdl= dlopen(dll_name, RTLD_NOW | RTLD_GLOBAL);
750 hdl= dlopen(dll_name, RTLD_LAZY);
753 /* dlopen failed; return a ptr to the error msg. */
755 if (errmsg == NULL) errmsg = "addDLL: unknown error";
762 # elif defined(OBJFORMAT_PEi386)
763 /* ------------------- Win32 DLL loader ------------------- */
771 /* fprintf(stderr, "\naddDLL; dll_name = `%s'\n", dll_name); */
773 /* See if we've already got it, and ignore if so. */
774 for (o_dll = opened_dlls; o_dll != NULL; o_dll = o_dll->next) {
775 if (0 == strcmp(o_dll->name, dll_name))
779 /* The file name has no suffix (yet) so that we can try
780 both foo.dll and foo.drv
782 The documentation for LoadLibrary says:
783 If no file name extension is specified in the lpFileName
784 parameter, the default library extension .dll is
785 appended. However, the file name string can include a trailing
786 point character (.) to indicate that the module name has no
789 buf = stgMallocBytes(strlen(dll_name) + 10, "addDLL");
790 sprintf(buf, "%s.DLL", dll_name);
791 instance = LoadLibrary(buf);
792 if (instance == NULL) {
793 sprintf(buf, "%s.DRV", dll_name); // KAA: allow loading of drivers (like winspool.drv)
794 instance = LoadLibrary(buf);
795 if (instance == NULL) {
798 /* LoadLibrary failed; return a ptr to the error msg. */
799 return "addDLL: unknown error";
804 /* Add this DLL to the list of DLLs in which to search for symbols. */
805 o_dll = stgMallocBytes( sizeof(OpenedDLL), "addDLL" );
806 o_dll->name = stgMallocBytes(1+strlen(dll_name), "addDLL");
807 strcpy(o_dll->name, dll_name);
808 o_dll->instance = instance;
809 o_dll->next = opened_dlls;
814 barf("addDLL: not implemented on this platform");
818 /* -----------------------------------------------------------------------------
819 * lookup a symbol in the hash table
822 lookupSymbol( char *lbl )
826 ASSERT(symhash != NULL);
827 val = lookupStrHashTable(symhash, lbl);
830 # if defined(OBJFORMAT_ELF)
831 return dlsym(dl_prog_handle, lbl);
832 # elif defined(OBJFORMAT_MACHO)
833 if(NSIsSymbolNameDefined(lbl)) {
834 NSSymbol symbol = NSLookupAndBindSymbol(lbl);
835 return NSAddressOfSymbol(symbol);
839 # elif defined(OBJFORMAT_PEi386)
842 for (o_dll = opened_dlls; o_dll != NULL; o_dll = o_dll->next) {
843 /* fprintf(stderr, "look in %s for %s\n", o_dll->name, lbl); */
845 /* HACK: if the name has an initial underscore, try stripping
846 it off & look that up first. I've yet to verify whether there's
847 a Rule that governs whether an initial '_' *should always* be
848 stripped off when mapping from import lib name to the DLL name.
850 sym = GetProcAddress(o_dll->instance, (lbl+1));
852 /*fprintf(stderr, "found %s in %s\n", lbl+1,o_dll->name); fflush(stderr);*/
856 sym = GetProcAddress(o_dll->instance, lbl);
858 /*fprintf(stderr, "found %s in %s\n", lbl,o_dll->name); fflush(stderr);*/
873 __attribute((unused))
875 lookupLocalSymbol( ObjectCode* oc, char *lbl )
879 val = lookupStrHashTable(oc->lochash, lbl);
889 /* -----------------------------------------------------------------------------
890 * Debugging aid: look in GHCi's object symbol tables for symbols
891 * within DELTA bytes of the specified address, and show their names.
894 void ghci_enquire ( char* addr );
896 void ghci_enquire ( char* addr )
901 const int DELTA = 64;
906 for (oc = objects; oc; oc = oc->next) {
907 for (i = 0; i < oc->n_symbols; i++) {
908 sym = oc->symbols[i];
909 if (sym == NULL) continue;
910 // fprintf(stderr, "enquire %p %p\n", sym, oc->lochash);
912 if (oc->lochash != NULL) {
913 a = lookupStrHashTable(oc->lochash, sym);
916 a = lookupStrHashTable(symhash, sym);
919 // fprintf(stderr, "ghci_enquire: can't find %s\n", sym);
921 else if (addr-DELTA <= a && a <= addr+DELTA) {
922 fprintf(stderr, "%p + %3d == `%s'\n", addr, a - addr, sym);
929 #ifdef ia64_TARGET_ARCH
930 static unsigned int PLTSize(void);
933 /* -----------------------------------------------------------------------------
934 * Load an obj (populate the global symbol table, but don't resolve yet)
936 * Returns: 1 if ok, 0 on error.
939 loadObj( char *path )
953 /* fprintf(stderr, "loadObj %s\n", path ); */
955 /* Check that we haven't already loaded this object. Don't give up
956 at this stage; ocGetNames_* will barf later. */
960 for (o = objects; o; o = o->next) {
961 if (0 == strcmp(o->fileName, path))
967 "GHCi runtime linker: warning: looks like you're trying to load the\n"
968 "same object file twice:\n"
970 "GHCi will continue, but a duplicate-symbol error may shortly follow.\n"
976 oc = stgMallocBytes(sizeof(ObjectCode), "loadObj(oc)");
978 # if defined(OBJFORMAT_ELF)
979 oc->formatName = "ELF";
980 # elif defined(OBJFORMAT_PEi386)
981 oc->formatName = "PEi386";
982 # elif defined(OBJFORMAT_MACHO)
983 oc->formatName = "Mach-O";
986 barf("loadObj: not implemented on this platform");
990 if (r == -1) { return 0; }
992 /* sigh, strdup() isn't a POSIX function, so do it the long way */
993 oc->fileName = stgMallocBytes( strlen(path)+1, "loadObj" );
994 strcpy(oc->fileName, path);
996 oc->fileSize = st.st_size;
999 oc->lochash = allocStrHashTable();
1000 oc->proddables = NULL;
1002 /* chain it onto the list of objects */
1007 #define ROUND_UP(x,size) ((x + size - 1) & ~(size - 1))
1009 /* On many architectures malloc'd memory isn't executable, so we need to use mmap. */
1011 fd = open(path, O_RDONLY);
1013 barf("loadObj: can't open `%s'", path);
1015 pagesize = getpagesize();
1017 #ifdef ia64_TARGET_ARCH
1018 /* The PLT needs to be right before the object */
1019 n = ROUND_UP(PLTSize(), pagesize);
1020 oc->plt = mmap(NULL, n, PROT_EXEC|PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
1021 if (oc->plt == MAP_FAILED)
1022 barf("loadObj: can't allocate PLT");
1025 map_addr = oc->plt + n;
1028 n = ROUND_UP(oc->fileSize, pagesize);
1029 oc->image = mmap(map_addr, n, PROT_EXEC|PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
1030 if (oc->image == MAP_FAILED)
1031 barf("loadObj: can't map `%s'", path);
1035 #else /* !USE_MMAP */
1037 oc->image = stgMallocBytes(oc->fileSize, "loadObj(image)");
1039 /* load the image into memory */
1040 f = fopen(path, "rb");
1042 barf("loadObj: can't read `%s'", path);
1044 n = fread ( oc->image, 1, oc->fileSize, f );
1045 if (n != oc->fileSize)
1046 barf("loadObj: error whilst reading `%s'", path);
1050 #endif /* USE_MMAP */
1052 # if defined(OBJFORMAT_MACHO)
1053 r = ocAllocateJumpIslands_MachO ( oc );
1054 if (!r) { return r; }
1057 /* verify the in-memory image */
1058 # if defined(OBJFORMAT_ELF)
1059 r = ocVerifyImage_ELF ( oc );
1060 # elif defined(OBJFORMAT_PEi386)
1061 r = ocVerifyImage_PEi386 ( oc );
1062 # elif defined(OBJFORMAT_MACHO)
1063 r = ocVerifyImage_MachO ( oc );
1065 barf("loadObj: no verify method");
1067 if (!r) { return r; }
1069 /* build the symbol list for this image */
1070 # if defined(OBJFORMAT_ELF)
1071 r = ocGetNames_ELF ( oc );
1072 # elif defined(OBJFORMAT_PEi386)
1073 r = ocGetNames_PEi386 ( oc );
1074 # elif defined(OBJFORMAT_MACHO)
1075 r = ocGetNames_MachO ( oc );
1077 barf("loadObj: no getNames method");
1079 if (!r) { return r; }
1081 /* loaded, but not resolved yet */
1082 oc->status = OBJECT_LOADED;
1087 /* -----------------------------------------------------------------------------
1088 * resolve all the currently unlinked objects in memory
1090 * Returns: 1 if ok, 0 on error.
1100 for (oc = objects; oc; oc = oc->next) {
1101 if (oc->status != OBJECT_RESOLVED) {
1102 # if defined(OBJFORMAT_ELF)
1103 r = ocResolve_ELF ( oc );
1104 # elif defined(OBJFORMAT_PEi386)
1105 r = ocResolve_PEi386 ( oc );
1106 # elif defined(OBJFORMAT_MACHO)
1107 r = ocResolve_MachO ( oc );
1109 barf("resolveObjs: not implemented on this platform");
1111 if (!r) { return r; }
1112 oc->status = OBJECT_RESOLVED;
1118 /* -----------------------------------------------------------------------------
1119 * delete an object from the pool
1122 unloadObj( char *path )
1124 ObjectCode *oc, *prev;
1126 ASSERT(symhash != NULL);
1127 ASSERT(objects != NULL);
1132 for (oc = objects; oc; prev = oc, oc = oc->next) {
1133 if (!strcmp(oc->fileName,path)) {
1135 /* Remove all the mappings for the symbols within this
1140 for (i = 0; i < oc->n_symbols; i++) {
1141 if (oc->symbols[i] != NULL) {
1142 removeStrHashTable(symhash, oc->symbols[i], NULL);
1150 prev->next = oc->next;
1153 /* We're going to leave this in place, in case there are
1154 any pointers from the heap into it: */
1155 /* stgFree(oc->image); */
1156 stgFree(oc->fileName);
1157 stgFree(oc->symbols);
1158 stgFree(oc->sections);
1159 /* The local hash table should have been freed at the end
1160 of the ocResolve_ call on it. */
1161 ASSERT(oc->lochash == NULL);
1167 belch("unloadObj: can't find `%s' to unload", path);
1171 /* -----------------------------------------------------------------------------
1172 * Sanity checking. For each ObjectCode, maintain a list of address ranges
1173 * which may be prodded during relocation, and abort if we try and write
1174 * outside any of these.
1176 static void addProddableBlock ( ObjectCode* oc, void* start, int size )
1179 = stgMallocBytes(sizeof(ProddableBlock), "addProddableBlock");
1180 /* fprintf(stderr, "aPB %p %p %d\n", oc, start, size); */
1184 pb->next = oc->proddables;
1185 oc->proddables = pb;
1188 static void checkProddableBlock ( ObjectCode* oc, void* addr )
1191 for (pb = oc->proddables; pb != NULL; pb = pb->next) {
1192 char* s = (char*)(pb->start);
1193 char* e = s + pb->size - 1;
1194 char* a = (char*)addr;
1195 /* Assumes that the biggest fixup involves a 4-byte write. This
1196 probably needs to be changed to 8 (ie, +7) on 64-bit
1198 if (a >= s && (a+3) <= e) return;
1200 barf("checkProddableBlock: invalid fixup in runtime linker");
1203 /* -----------------------------------------------------------------------------
1204 * Section management.
1206 static void addSection ( ObjectCode* oc, SectionKind kind,
1207 void* start, void* end )
1209 Section* s = stgMallocBytes(sizeof(Section), "addSection");
1213 s->next = oc->sections;
1216 fprintf(stderr, "addSection: %p-%p (size %d), kind %d\n",
1217 start, ((char*)end)-1, end - start + 1, kind );
1223 /* --------------------------------------------------------------------------
1224 * PEi386 specifics (Win32 targets)
1225 * ------------------------------------------------------------------------*/
1227 /* The information for this linker comes from
1228 Microsoft Portable Executable
1229 and Common Object File Format Specification
1230 revision 5.1 January 1998
1231 which SimonM says comes from the MS Developer Network CDs.
1233 It can be found there (on older CDs), but can also be found
1236 http://www.microsoft.com/hwdev/hardware/PECOFF.asp
1238 (this is Rev 6.0 from February 1999).
1240 Things move, so if that fails, try searching for it via
1242 http://www.google.com/search?q=PE+COFF+specification
1244 The ultimate reference for the PE format is the Winnt.h
1245 header file that comes with the Platform SDKs; as always,
1246 implementations will drift wrt their documentation.
1248 A good background article on the PE format is Matt Pietrek's
1249 March 1994 article in Microsoft System Journal (MSJ)
1250 (Vol.9, No. 3): "Peering Inside the PE: A Tour of the
1251 Win32 Portable Executable File Format." The info in there
1252 has recently been updated in a two part article in
1253 MSDN magazine, issues Feb and March 2002,
1254 "Inside Windows: An In-Depth Look into the Win32 Portable
1255 Executable File Format"
1257 John Levine's book "Linkers and Loaders" contains useful
1262 #if defined(OBJFORMAT_PEi386)
1266 typedef unsigned char UChar;
1267 typedef unsigned short UInt16;
1268 typedef unsigned int UInt32;
1275 UInt16 NumberOfSections;
1276 UInt32 TimeDateStamp;
1277 UInt32 PointerToSymbolTable;
1278 UInt32 NumberOfSymbols;
1279 UInt16 SizeOfOptionalHeader;
1280 UInt16 Characteristics;
1284 #define sizeof_COFF_header 20
1291 UInt32 VirtualAddress;
1292 UInt32 SizeOfRawData;
1293 UInt32 PointerToRawData;
1294 UInt32 PointerToRelocations;
1295 UInt32 PointerToLinenumbers;
1296 UInt16 NumberOfRelocations;
1297 UInt16 NumberOfLineNumbers;
1298 UInt32 Characteristics;
1302 #define sizeof_COFF_section 40
1309 UInt16 SectionNumber;
1312 UChar NumberOfAuxSymbols;
1316 #define sizeof_COFF_symbol 18
1321 UInt32 VirtualAddress;
1322 UInt32 SymbolTableIndex;
1327 #define sizeof_COFF_reloc 10
1330 /* From PE spec doc, section 3.3.2 */
1331 /* Note use of MYIMAGE_* since IMAGE_* are already defined in
1332 windows.h -- for the same purpose, but I want to know what I'm
1334 #define MYIMAGE_FILE_RELOCS_STRIPPED 0x0001
1335 #define MYIMAGE_FILE_EXECUTABLE_IMAGE 0x0002
1336 #define MYIMAGE_FILE_DLL 0x2000
1337 #define MYIMAGE_FILE_SYSTEM 0x1000
1338 #define MYIMAGE_FILE_BYTES_REVERSED_HI 0x8000
1339 #define MYIMAGE_FILE_BYTES_REVERSED_LO 0x0080
1340 #define MYIMAGE_FILE_32BIT_MACHINE 0x0100
1342 /* From PE spec doc, section 5.4.2 and 5.4.4 */
1343 #define MYIMAGE_SYM_CLASS_EXTERNAL 2
1344 #define MYIMAGE_SYM_CLASS_STATIC 3
1345 #define MYIMAGE_SYM_UNDEFINED 0
1347 /* From PE spec doc, section 4.1 */
1348 #define MYIMAGE_SCN_CNT_CODE 0x00000020
1349 #define MYIMAGE_SCN_CNT_INITIALIZED_DATA 0x00000040
1350 #define MYIMAGE_SCN_LNK_NRELOC_OVFL 0x01000000
1352 /* From PE spec doc, section 5.2.1 */
1353 #define MYIMAGE_REL_I386_DIR32 0x0006
1354 #define MYIMAGE_REL_I386_REL32 0x0014
1357 /* We use myindex to calculate array addresses, rather than
1358 simply doing the normal subscript thing. That's because
1359 some of the above structs have sizes which are not
1360 a whole number of words. GCC rounds their sizes up to a
1361 whole number of words, which means that the address calcs
1362 arising from using normal C indexing or pointer arithmetic
1363 are just plain wrong. Sigh.
1366 myindex ( int scale, void* base, int index )
1369 ((UChar*)base) + scale * index;
1374 printName ( UChar* name, UChar* strtab )
1376 if (name[0]==0 && name[1]==0 && name[2]==0 && name[3]==0) {
1377 UInt32 strtab_offset = * (UInt32*)(name+4);
1378 fprintf ( stderr, "%s", strtab + strtab_offset );
1381 for (i = 0; i < 8; i++) {
1382 if (name[i] == 0) break;
1383 fprintf ( stderr, "%c", name[i] );
1390 copyName ( UChar* name, UChar* strtab, UChar* dst, int dstSize )
1392 if (name[0]==0 && name[1]==0 && name[2]==0 && name[3]==0) {
1393 UInt32 strtab_offset = * (UInt32*)(name+4);
1394 strncpy ( dst, strtab+strtab_offset, dstSize );
1400 if (name[i] == 0) break;
1410 cstring_from_COFF_symbol_name ( UChar* name, UChar* strtab )
1413 /* If the string is longer than 8 bytes, look in the
1414 string table for it -- this will be correctly zero terminated.
1416 if (name[0]==0 && name[1]==0 && name[2]==0 && name[3]==0) {
1417 UInt32 strtab_offset = * (UInt32*)(name+4);
1418 return ((UChar*)strtab) + strtab_offset;
1420 /* Otherwise, if shorter than 8 bytes, return the original,
1421 which by defn is correctly terminated.
1423 if (name[7]==0) return name;
1424 /* The annoying case: 8 bytes. Copy into a temporary
1425 (which is never freed ...)
1427 newstr = stgMallocBytes(9, "cstring_from_COFF_symbol_name");
1429 strncpy(newstr,name,8);
1435 /* Just compares the short names (first 8 chars) */
1436 static COFF_section *
1437 findPEi386SectionCalled ( ObjectCode* oc, char* name )
1441 = (COFF_header*)(oc->image);
1442 COFF_section* sectab
1444 ((UChar*)(oc->image))
1445 + sizeof_COFF_header + hdr->SizeOfOptionalHeader
1447 for (i = 0; i < hdr->NumberOfSections; i++) {
1450 COFF_section* section_i
1452 myindex ( sizeof_COFF_section, sectab, i );
1453 n1 = (UChar*) &(section_i->Name);
1455 if (n1[0]==n2[0] && n1[1]==n2[1] && n1[2]==n2[2] &&
1456 n1[3]==n2[3] && n1[4]==n2[4] && n1[5]==n2[5] &&
1457 n1[6]==n2[6] && n1[7]==n2[7])
1466 zapTrailingAtSign ( UChar* sym )
1468 # define my_isdigit(c) ((c) >= '0' && (c) <= '9')
1470 if (sym[0] == 0) return;
1472 while (sym[i] != 0) i++;
1475 while (j > 0 && my_isdigit(sym[j])) j--;
1476 if (j > 0 && sym[j] == '@' && j != i) sym[j] = 0;
1482 ocVerifyImage_PEi386 ( ObjectCode* oc )
1487 COFF_section* sectab;
1488 COFF_symbol* symtab;
1490 /* fprintf(stderr, "\nLOADING %s\n", oc->fileName); */
1491 hdr = (COFF_header*)(oc->image);
1492 sectab = (COFF_section*) (
1493 ((UChar*)(oc->image))
1494 + sizeof_COFF_header + hdr->SizeOfOptionalHeader
1496 symtab = (COFF_symbol*) (
1497 ((UChar*)(oc->image))
1498 + hdr->PointerToSymbolTable
1500 strtab = ((UChar*)symtab)
1501 + hdr->NumberOfSymbols * sizeof_COFF_symbol;
1503 if (hdr->Machine != 0x14c) {
1504 belch("Not x86 PEi386");
1507 if (hdr->SizeOfOptionalHeader != 0) {
1508 belch("PEi386 with nonempty optional header");
1511 if ( /* (hdr->Characteristics & MYIMAGE_FILE_RELOCS_STRIPPED) || */
1512 (hdr->Characteristics & MYIMAGE_FILE_EXECUTABLE_IMAGE) ||
1513 (hdr->Characteristics & MYIMAGE_FILE_DLL) ||
1514 (hdr->Characteristics & MYIMAGE_FILE_SYSTEM) ) {
1515 belch("Not a PEi386 object file");
1518 if ( (hdr->Characteristics & MYIMAGE_FILE_BYTES_REVERSED_HI)
1519 /* || !(hdr->Characteristics & MYIMAGE_FILE_32BIT_MACHINE) */ ) {
1520 belch("Invalid PEi386 word size or endiannness: %d",
1521 (int)(hdr->Characteristics));
1524 /* If the string table size is way crazy, this might indicate that
1525 there are more than 64k relocations, despite claims to the
1526 contrary. Hence this test. */
1527 /* fprintf(stderr, "strtab size %d\n", * (UInt32*)strtab); */
1529 if ( (*(UInt32*)strtab) > 600000 ) {
1530 /* Note that 600k has no special significance other than being
1531 big enough to handle the almost-2MB-sized lumps that
1532 constitute HSwin32*.o. */
1533 belch("PEi386 object has suspiciously large string table; > 64k relocs?");
1538 /* No further verification after this point; only debug printing. */
1540 IF_DEBUG(linker, i=1);
1541 if (i == 0) return 1;
1544 "sectab offset = %d\n", ((UChar*)sectab) - ((UChar*)hdr) );
1546 "symtab offset = %d\n", ((UChar*)symtab) - ((UChar*)hdr) );
1548 "strtab offset = %d\n", ((UChar*)strtab) - ((UChar*)hdr) );
1550 fprintf ( stderr, "\n" );
1552 "Machine: 0x%x\n", (UInt32)(hdr->Machine) );
1554 "# sections: %d\n", (UInt32)(hdr->NumberOfSections) );
1556 "time/date: 0x%x\n", (UInt32)(hdr->TimeDateStamp) );
1558 "symtab offset: %d\n", (UInt32)(hdr->PointerToSymbolTable) );
1560 "# symbols: %d\n", (UInt32)(hdr->NumberOfSymbols) );
1562 "sz of opt hdr: %d\n", (UInt32)(hdr->SizeOfOptionalHeader) );
1564 "characteristics: 0x%x\n", (UInt32)(hdr->Characteristics) );
1566 /* Print the section table. */
1567 fprintf ( stderr, "\n" );
1568 for (i = 0; i < hdr->NumberOfSections; i++) {
1570 COFF_section* sectab_i
1572 myindex ( sizeof_COFF_section, sectab, i );
1579 printName ( sectab_i->Name, strtab );
1589 sectab_i->VirtualSize,
1590 sectab_i->VirtualAddress,
1591 sectab_i->SizeOfRawData,
1592 sectab_i->PointerToRawData,
1593 sectab_i->NumberOfRelocations,
1594 sectab_i->PointerToRelocations,
1595 sectab_i->PointerToRawData
1597 reltab = (COFF_reloc*) (
1598 ((UChar*)(oc->image)) + sectab_i->PointerToRelocations
1601 if ( sectab_i->Characteristics & MYIMAGE_SCN_LNK_NRELOC_OVFL ) {
1602 /* If the relocation field (a short) has overflowed, the
1603 * real count can be found in the first reloc entry.
1605 * See Section 4.1 (last para) of the PE spec (rev6.0).
1607 COFF_reloc* rel = (COFF_reloc*)
1608 myindex ( sizeof_COFF_reloc, reltab, 0 );
1609 noRelocs = rel->VirtualAddress;
1612 noRelocs = sectab_i->NumberOfRelocations;
1616 for (; j < noRelocs; j++) {
1618 COFF_reloc* rel = (COFF_reloc*)
1619 myindex ( sizeof_COFF_reloc, reltab, j );
1621 " type 0x%-4x vaddr 0x%-8x name `",
1623 rel->VirtualAddress );
1624 sym = (COFF_symbol*)
1625 myindex ( sizeof_COFF_symbol, symtab, rel->SymbolTableIndex );
1626 /* Hmm..mysterious looking offset - what's it for? SOF */
1627 printName ( sym->Name, strtab -10 );
1628 fprintf ( stderr, "'\n" );
1631 fprintf ( stderr, "\n" );
1633 fprintf ( stderr, "\n" );
1634 fprintf ( stderr, "string table has size 0x%x\n", * (UInt32*)strtab );
1635 fprintf ( stderr, "---START of string table---\n");
1636 for (i = 4; i < *(Int32*)strtab; i++) {
1638 fprintf ( stderr, "\n"); else
1639 fprintf( stderr, "%c", strtab[i] );
1641 fprintf ( stderr, "--- END of string table---\n");
1643 fprintf ( stderr, "\n" );
1646 COFF_symbol* symtab_i;
1647 if (i >= (Int32)(hdr->NumberOfSymbols)) break;
1648 symtab_i = (COFF_symbol*)
1649 myindex ( sizeof_COFF_symbol, symtab, i );
1655 printName ( symtab_i->Name, strtab );
1664 (Int32)(symtab_i->SectionNumber),
1665 (UInt32)symtab_i->Type,
1666 (UInt32)symtab_i->StorageClass,
1667 (UInt32)symtab_i->NumberOfAuxSymbols
1669 i += symtab_i->NumberOfAuxSymbols;
1673 fprintf ( stderr, "\n" );
1679 ocGetNames_PEi386 ( ObjectCode* oc )
1682 COFF_section* sectab;
1683 COFF_symbol* symtab;
1690 hdr = (COFF_header*)(oc->image);
1691 sectab = (COFF_section*) (
1692 ((UChar*)(oc->image))
1693 + sizeof_COFF_header + hdr->SizeOfOptionalHeader
1695 symtab = (COFF_symbol*) (
1696 ((UChar*)(oc->image))
1697 + hdr->PointerToSymbolTable
1699 strtab = ((UChar*)(oc->image))
1700 + hdr->PointerToSymbolTable
1701 + hdr->NumberOfSymbols * sizeof_COFF_symbol;
1703 /* Allocate space for any (local, anonymous) .bss sections. */
1705 for (i = 0; i < hdr->NumberOfSections; i++) {
1707 COFF_section* sectab_i
1709 myindex ( sizeof_COFF_section, sectab, i );
1710 if (0 != strcmp(sectab_i->Name, ".bss")) continue;
1711 if (sectab_i->VirtualSize == 0) continue;
1712 /* This is a non-empty .bss section. Allocate zeroed space for
1713 it, and set its PointerToRawData field such that oc->image +
1714 PointerToRawData == addr_of_zeroed_space. */
1715 zspace = stgCallocBytes(1, sectab_i->VirtualSize,
1716 "ocGetNames_PEi386(anonymous bss)");
1717 sectab_i->PointerToRawData = ((UChar*)zspace) - ((UChar*)(oc->image));
1718 addProddableBlock(oc, zspace, sectab_i->VirtualSize);
1719 /* fprintf(stderr, "BSS anon section at 0x%x\n", zspace); */
1722 /* Copy section information into the ObjectCode. */
1724 for (i = 0; i < hdr->NumberOfSections; i++) {
1730 = SECTIONKIND_OTHER;
1731 COFF_section* sectab_i
1733 myindex ( sizeof_COFF_section, sectab, i );
1734 IF_DEBUG(linker, belch("section name = %s\n", sectab_i->Name ));
1737 /* I'm sure this is the Right Way to do it. However, the
1738 alternative of testing the sectab_i->Name field seems to
1739 work ok with Cygwin.
1741 if (sectab_i->Characteristics & MYIMAGE_SCN_CNT_CODE ||
1742 sectab_i->Characteristics & MYIMAGE_SCN_CNT_INITIALIZED_DATA)
1743 kind = SECTIONKIND_CODE_OR_RODATA;
1746 if (0==strcmp(".text",sectab_i->Name) ||
1747 0==strcmp(".rodata",sectab_i->Name))
1748 kind = SECTIONKIND_CODE_OR_RODATA;
1749 if (0==strcmp(".data",sectab_i->Name) ||
1750 0==strcmp(".bss",sectab_i->Name))
1751 kind = SECTIONKIND_RWDATA;
1753 ASSERT(sectab_i->SizeOfRawData == 0 || sectab_i->VirtualSize == 0);
1754 sz = sectab_i->SizeOfRawData;
1755 if (sz < sectab_i->VirtualSize) sz = sectab_i->VirtualSize;
1757 start = ((UChar*)(oc->image)) + sectab_i->PointerToRawData;
1758 end = start + sz - 1;
1760 if (kind == SECTIONKIND_OTHER
1761 /* Ignore sections called which contain stabs debugging
1763 && 0 != strcmp(".stab", sectab_i->Name)
1764 && 0 != strcmp(".stabstr", sectab_i->Name)
1766 belch("Unknown PEi386 section name `%s'", sectab_i->Name);
1770 if (kind != SECTIONKIND_OTHER && end >= start) {
1771 addSection(oc, kind, start, end);
1772 addProddableBlock(oc, start, end - start + 1);
1776 /* Copy exported symbols into the ObjectCode. */
1778 oc->n_symbols = hdr->NumberOfSymbols;
1779 oc->symbols = stgMallocBytes(oc->n_symbols * sizeof(char*),
1780 "ocGetNames_PEi386(oc->symbols)");
1781 /* Call me paranoid; I don't care. */
1782 for (i = 0; i < oc->n_symbols; i++)
1783 oc->symbols[i] = NULL;
1787 COFF_symbol* symtab_i;
1788 if (i >= (Int32)(hdr->NumberOfSymbols)) break;
1789 symtab_i = (COFF_symbol*)
1790 myindex ( sizeof_COFF_symbol, symtab, i );
1794 if (symtab_i->StorageClass == MYIMAGE_SYM_CLASS_EXTERNAL
1795 && symtab_i->SectionNumber != MYIMAGE_SYM_UNDEFINED) {
1796 /* This symbol is global and defined, viz, exported */
1797 /* for MYIMAGE_SYMCLASS_EXTERNAL
1798 && !MYIMAGE_SYM_UNDEFINED,
1799 the address of the symbol is:
1800 address of relevant section + offset in section
1802 COFF_section* sectabent
1803 = (COFF_section*) myindex ( sizeof_COFF_section,
1805 symtab_i->SectionNumber-1 );
1806 addr = ((UChar*)(oc->image))
1807 + (sectabent->PointerToRawData
1811 if (symtab_i->SectionNumber == MYIMAGE_SYM_UNDEFINED
1812 && symtab_i->Value > 0) {
1813 /* This symbol isn't in any section at all, ie, global bss.
1814 Allocate zeroed space for it. */
1815 addr = stgCallocBytes(1, symtab_i->Value,
1816 "ocGetNames_PEi386(non-anonymous bss)");
1817 addSection(oc, SECTIONKIND_RWDATA, addr,
1818 ((UChar*)addr) + symtab_i->Value - 1);
1819 addProddableBlock(oc, addr, symtab_i->Value);
1820 /* fprintf(stderr, "BSS section at 0x%x\n", addr); */
1823 if (addr != NULL ) {
1824 sname = cstring_from_COFF_symbol_name ( symtab_i->Name, strtab );
1825 /* fprintf(stderr,"addSymbol %p `%s \n", addr,sname); */
1826 IF_DEBUG(linker, belch("addSymbol %p `%s'\n", addr,sname);)
1827 ASSERT(i >= 0 && i < oc->n_symbols);
1828 /* cstring_from_COFF_symbol_name always succeeds. */
1829 oc->symbols[i] = sname;
1830 ghciInsertStrHashTable(oc->fileName, symhash, sname, addr);
1834 "IGNORING symbol %d\n"
1838 printName ( symtab_i->Name, strtab );
1847 (Int32)(symtab_i->SectionNumber),
1848 (UInt32)symtab_i->Type,
1849 (UInt32)symtab_i->StorageClass,
1850 (UInt32)symtab_i->NumberOfAuxSymbols
1855 i += symtab_i->NumberOfAuxSymbols;
1864 ocResolve_PEi386 ( ObjectCode* oc )
1867 COFF_section* sectab;
1868 COFF_symbol* symtab;
1878 /* ToDo: should be variable-sized? But is at least safe in the
1879 sense of buffer-overrun-proof. */
1881 /* fprintf(stderr, "resolving for %s\n", oc->fileName); */
1883 hdr = (COFF_header*)(oc->image);
1884 sectab = (COFF_section*) (
1885 ((UChar*)(oc->image))
1886 + sizeof_COFF_header + hdr->SizeOfOptionalHeader
1888 symtab = (COFF_symbol*) (
1889 ((UChar*)(oc->image))
1890 + hdr->PointerToSymbolTable
1892 strtab = ((UChar*)(oc->image))
1893 + hdr->PointerToSymbolTable
1894 + hdr->NumberOfSymbols * sizeof_COFF_symbol;
1896 for (i = 0; i < hdr->NumberOfSections; i++) {
1897 COFF_section* sectab_i
1899 myindex ( sizeof_COFF_section, sectab, i );
1902 ((UChar*)(oc->image)) + sectab_i->PointerToRelocations
1905 /* Ignore sections called which contain stabs debugging
1907 if (0 == strcmp(".stab", sectab_i->Name)
1908 || 0 == strcmp(".stabstr", sectab_i->Name))
1911 if ( sectab_i->Characteristics & MYIMAGE_SCN_LNK_NRELOC_OVFL ) {
1912 /* If the relocation field (a short) has overflowed, the
1913 * real count can be found in the first reloc entry.
1915 * See Section 4.1 (last para) of the PE spec (rev6.0).
1917 COFF_reloc* rel = (COFF_reloc*)
1918 myindex ( sizeof_COFF_reloc, reltab, 0 );
1919 noRelocs = rel->VirtualAddress;
1920 fprintf(stderr, "Overflown relocs: %u\n", noRelocs);
1923 noRelocs = sectab_i->NumberOfRelocations;
1928 for (; j < noRelocs; j++) {
1930 COFF_reloc* reltab_j
1932 myindex ( sizeof_COFF_reloc, reltab, j );
1934 /* the location to patch */
1936 ((UChar*)(oc->image))
1937 + (sectab_i->PointerToRawData
1938 + reltab_j->VirtualAddress
1939 - sectab_i->VirtualAddress )
1941 /* the existing contents of pP */
1943 /* the symbol to connect to */
1944 sym = (COFF_symbol*)
1945 myindex ( sizeof_COFF_symbol,
1946 symtab, reltab_j->SymbolTableIndex );
1949 "reloc sec %2d num %3d: type 0x%-4x "
1950 "vaddr 0x%-8x name `",
1952 (UInt32)reltab_j->Type,
1953 reltab_j->VirtualAddress );
1954 printName ( sym->Name, strtab );
1955 fprintf ( stderr, "'\n" ));
1957 if (sym->StorageClass == MYIMAGE_SYM_CLASS_STATIC) {
1958 COFF_section* section_sym
1959 = findPEi386SectionCalled ( oc, sym->Name );
1961 belch("%s: can't find section `%s'", oc->fileName, sym->Name);
1964 S = ((UInt32)(oc->image))
1965 + (section_sym->PointerToRawData
1968 copyName ( sym->Name, strtab, symbol, 1000-1 );
1969 (void*)S = lookupLocalSymbol( oc, symbol );
1970 if ((void*)S != NULL) goto foundit;
1971 (void*)S = lookupSymbol( symbol );
1972 if ((void*)S != NULL) goto foundit;
1973 zapTrailingAtSign ( symbol );
1974 (void*)S = lookupLocalSymbol( oc, symbol );
1975 if ((void*)S != NULL) goto foundit;
1976 (void*)S = lookupSymbol( symbol );
1977 if ((void*)S != NULL) goto foundit;
1978 /* Newline first because the interactive linker has printed "linking..." */
1979 belch("\n%s: unknown symbol `%s'", oc->fileName, symbol);
1983 checkProddableBlock(oc, pP);
1984 switch (reltab_j->Type) {
1985 case MYIMAGE_REL_I386_DIR32:
1988 case MYIMAGE_REL_I386_REL32:
1989 /* Tricky. We have to insert a displacement at
1990 pP which, when added to the PC for the _next_
1991 insn, gives the address of the target (S).
1992 Problem is to know the address of the next insn
1993 when we only know pP. We assume that this
1994 literal field is always the last in the insn,
1995 so that the address of the next insn is pP+4
1996 -- hence the constant 4.
1997 Also I don't know if A should be added, but so
1998 far it has always been zero.
2001 *pP = S - ((UInt32)pP) - 4;
2004 belch("%s: unhandled PEi386 relocation type %d",
2005 oc->fileName, reltab_j->Type);
2012 IF_DEBUG(linker, belch("completed %s", oc->fileName));
2016 #endif /* defined(OBJFORMAT_PEi386) */
2019 /* --------------------------------------------------------------------------
2021 * ------------------------------------------------------------------------*/
2023 #if defined(OBJFORMAT_ELF)
2028 #if defined(sparc_TARGET_ARCH)
2029 # define ELF_TARGET_SPARC /* Used inside <elf.h> */
2030 #elif defined(i386_TARGET_ARCH)
2031 # define ELF_TARGET_386 /* Used inside <elf.h> */
2032 #elif defined(x86_64_TARGET_ARCH)
2033 # define ELF_TARGET_X64_64
2035 #elif defined (ia64_TARGET_ARCH)
2036 # define ELF_TARGET_IA64 /* Used inside <elf.h> */
2038 # define ELF_FUNCTION_DESC /* calling convention uses function descriptors */
2039 # define ELF_NEED_GOT /* needs Global Offset Table */
2040 # define ELF_NEED_PLT /* needs Procedure Linkage Tables */
2043 #if !defined(openbsd_TARGET_OS)
2046 /* openbsd elf has things in different places, with diff names */
2047 #include <elf_abi.h>
2048 #include <machine/reloc.h>
2049 #define R_386_32 RELOC_32
2050 #define R_386_PC32 RELOC_PC32
2054 * Define a set of types which can be used for both ELF32 and ELF64
2058 #define ELFCLASS ELFCLASS64
2059 #define Elf_Addr Elf64_Addr
2060 #define Elf_Word Elf64_Word
2061 #define Elf_Sword Elf64_Sword
2062 #define Elf_Ehdr Elf64_Ehdr
2063 #define Elf_Phdr Elf64_Phdr
2064 #define Elf_Shdr Elf64_Shdr
2065 #define Elf_Sym Elf64_Sym
2066 #define Elf_Rel Elf64_Rel
2067 #define Elf_Rela Elf64_Rela
2068 #define ELF_ST_TYPE ELF64_ST_TYPE
2069 #define ELF_ST_BIND ELF64_ST_BIND
2070 #define ELF_R_TYPE ELF64_R_TYPE
2071 #define ELF_R_SYM ELF64_R_SYM
2073 #define ELFCLASS ELFCLASS32
2074 #define Elf_Addr Elf32_Addr
2075 #define Elf_Word Elf32_Word
2076 #define Elf_Sword Elf32_Sword
2077 #define Elf_Ehdr Elf32_Ehdr
2078 #define Elf_Phdr Elf32_Phdr
2079 #define Elf_Shdr Elf32_Shdr
2080 #define Elf_Sym Elf32_Sym
2081 #define Elf_Rel Elf32_Rel
2082 #define Elf_Rela Elf32_Rela
2084 #define ELF_ST_TYPE ELF32_ST_TYPE
2087 #define ELF_ST_BIND ELF32_ST_BIND
2090 #define ELF_R_TYPE ELF32_R_TYPE
2093 #define ELF_R_SYM ELF32_R_SYM
2099 * Functions to allocate entries in dynamic sections. Currently we simply
2100 * preallocate a large number, and we don't check if a entry for the given
2101 * target already exists (a linear search is too slow). Ideally these
2102 * entries would be associated with symbols.
2105 /* These sizes sufficient to load HSbase + HShaskell98 + a few modules */
2106 #define GOT_SIZE 0x20000
2107 #define FUNCTION_TABLE_SIZE 0x10000
2108 #define PLT_SIZE 0x08000
2111 static Elf_Addr got[GOT_SIZE];
2112 static unsigned int gotIndex;
2113 static Elf_Addr gp_val = (Elf_Addr)got;
2116 allocateGOTEntry(Elf_Addr target)
2120 if (gotIndex >= GOT_SIZE)
2121 barf("Global offset table overflow");
2123 entry = &got[gotIndex++];
2125 return (Elf_Addr)entry;
2129 #ifdef ELF_FUNCTION_DESC
2135 static FunctionDesc functionTable[FUNCTION_TABLE_SIZE];
2136 static unsigned int functionTableIndex;
2139 allocateFunctionDesc(Elf_Addr target)
2141 FunctionDesc *entry;
2143 if (functionTableIndex >= FUNCTION_TABLE_SIZE)
2144 barf("Function table overflow");
2146 entry = &functionTable[functionTableIndex++];
2148 entry->gp = (Elf_Addr)gp_val;
2149 return (Elf_Addr)entry;
2153 copyFunctionDesc(Elf_Addr target)
2155 FunctionDesc *olddesc = (FunctionDesc *)target;
2156 FunctionDesc *newdesc;
2158 newdesc = (FunctionDesc *)allocateFunctionDesc(olddesc->ip);
2159 newdesc->gp = olddesc->gp;
2160 return (Elf_Addr)newdesc;
2165 #ifdef ia64_TARGET_ARCH
2166 static void ia64_reloc_gprel22(Elf_Addr target, Elf_Addr value);
2167 static void ia64_reloc_pcrel21(Elf_Addr target, Elf_Addr value, ObjectCode *oc);
2169 static unsigned char plt_code[] =
2171 /* taken from binutils bfd/elfxx-ia64.c */
2172 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
2173 0x00, 0x41, 0x3c, 0x30, 0x28, 0xc0, /* ld8 r16=[r15],8 */
2174 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
2175 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
2176 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
2177 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
2180 /* If we can't get to the function descriptor via gp, take a local copy of it */
2181 #define PLT_RELOC(code, target) { \
2182 Elf64_Sxword rel_value = target - gp_val; \
2183 if ((rel_value > 0x1fffff) || (rel_value < -0x1fffff)) \
2184 ia64_reloc_gprel22((Elf_Addr)code, copyFunctionDesc(target)); \
2186 ia64_reloc_gprel22((Elf_Addr)code, target); \
2191 unsigned char code[sizeof(plt_code)];
2195 allocatePLTEntry(Elf_Addr target, ObjectCode *oc)
2197 PLTEntry *plt = (PLTEntry *)oc->plt;
2200 if (oc->pltIndex >= PLT_SIZE)
2201 barf("Procedure table overflow");
2203 entry = &plt[oc->pltIndex++];
2204 memcpy(entry->code, plt_code, sizeof(entry->code));
2205 PLT_RELOC(entry->code, target);
2206 return (Elf_Addr)entry;
2212 return (PLT_SIZE * sizeof(PLTEntry));
2218 * Generic ELF functions
2222 findElfSection ( void* objImage, Elf_Word sh_type )
2224 char* ehdrC = (char*)objImage;
2225 Elf_Ehdr* ehdr = (Elf_Ehdr*)ehdrC;
2226 Elf_Shdr* shdr = (Elf_Shdr*)(ehdrC + ehdr->e_shoff);
2227 char* sh_strtab = ehdrC + shdr[ehdr->e_shstrndx].sh_offset;
2231 for (i = 0; i < ehdr->e_shnum; i++) {
2232 if (shdr[i].sh_type == sh_type
2233 /* Ignore the section header's string table. */
2234 && i != ehdr->e_shstrndx
2235 /* Ignore string tables named .stabstr, as they contain
2237 && 0 != memcmp(".stabstr", sh_strtab + shdr[i].sh_name, 8)
2239 ptr = ehdrC + shdr[i].sh_offset;
2246 #if defined(ia64_TARGET_ARCH)
2248 findElfSegment ( void* objImage, Elf_Addr vaddr )
2250 char* ehdrC = (char*)objImage;
2251 Elf_Ehdr* ehdr = (Elf_Ehdr*)ehdrC;
2252 Elf_Phdr* phdr = (Elf_Phdr*)(ehdrC + ehdr->e_phoff);
2253 Elf_Addr segaddr = 0;
2256 for (i = 0; i < ehdr->e_phnum; i++) {
2257 segaddr = phdr[i].p_vaddr;
2258 if ((vaddr >= segaddr) && (vaddr < segaddr + phdr[i].p_memsz))
2266 ocVerifyImage_ELF ( ObjectCode* oc )
2270 int i, j, nent, nstrtab, nsymtabs;
2274 char* ehdrC = (char*)(oc->image);
2275 Elf_Ehdr* ehdr = (Elf_Ehdr*)ehdrC;
2277 if (ehdr->e_ident[EI_MAG0] != ELFMAG0 ||
2278 ehdr->e_ident[EI_MAG1] != ELFMAG1 ||
2279 ehdr->e_ident[EI_MAG2] != ELFMAG2 ||
2280 ehdr->e_ident[EI_MAG3] != ELFMAG3) {
2281 belch("%s: not an ELF object", oc->fileName);
2285 if (ehdr->e_ident[EI_CLASS] != ELFCLASS) {
2286 belch("%s: unsupported ELF format", oc->fileName);
2290 if (ehdr->e_ident[EI_DATA] == ELFDATA2LSB) {
2291 IF_DEBUG(linker,belch( "Is little-endian" ));
2293 if (ehdr->e_ident[EI_DATA] == ELFDATA2MSB) {
2294 IF_DEBUG(linker,belch( "Is big-endian" ));
2296 belch("%s: unknown endiannness", oc->fileName);
2300 if (ehdr->e_type != ET_REL) {
2301 belch("%s: not a relocatable object (.o) file", oc->fileName);
2304 IF_DEBUG(linker, belch( "Is a relocatable object (.o) file" ));
2306 IF_DEBUG(linker,belch( "Architecture is " ));
2307 switch (ehdr->e_machine) {
2308 case EM_386: IF_DEBUG(linker,belch( "x86" )); break;
2309 case EM_SPARC: IF_DEBUG(linker,belch( "sparc" )); break;
2311 case EM_IA_64: IF_DEBUG(linker,belch( "ia64" )); break;
2313 default: IF_DEBUG(linker,belch( "unknown" ));
2314 belch("%s: unknown architecture", oc->fileName);
2318 IF_DEBUG(linker,belch(
2319 "\nSection header table: start %d, n_entries %d, ent_size %d",
2320 ehdr->e_shoff, ehdr->e_shnum, ehdr->e_shentsize ));
2322 ASSERT (ehdr->e_shentsize == sizeof(Elf_Shdr));
2324 shdr = (Elf_Shdr*) (ehdrC + ehdr->e_shoff);
2326 if (ehdr->e_shstrndx == SHN_UNDEF) {
2327 belch("%s: no section header string table", oc->fileName);
2330 IF_DEBUG(linker,belch( "Section header string table is section %d",
2332 sh_strtab = ehdrC + shdr[ehdr->e_shstrndx].sh_offset;
2335 for (i = 0; i < ehdr->e_shnum; i++) {
2336 IF_DEBUG(linker,fprintf(stderr, "%2d: ", i ));
2337 IF_DEBUG(linker,fprintf(stderr, "type=%2d ", (int)shdr[i].sh_type ));
2338 IF_DEBUG(linker,fprintf(stderr, "size=%4d ", (int)shdr[i].sh_size ));
2339 IF_DEBUG(linker,fprintf(stderr, "offs=%4d ", (int)shdr[i].sh_offset ));
2340 IF_DEBUG(linker,fprintf(stderr, " (%p .. %p) ",
2341 ehdrC + shdr[i].sh_offset,
2342 ehdrC + shdr[i].sh_offset + shdr[i].sh_size - 1));
2344 if (shdr[i].sh_type == SHT_REL) {
2345 IF_DEBUG(linker,fprintf(stderr, "Rel " ));
2346 } else if (shdr[i].sh_type == SHT_RELA) {
2347 IF_DEBUG(linker,fprintf(stderr, "RelA " ));
2349 IF_DEBUG(linker,fprintf(stderr," "));
2352 IF_DEBUG(linker,fprintf(stderr, "sname=%s\n", sh_strtab + shdr[i].sh_name ));
2356 IF_DEBUG(linker,belch( "\nString tables" ));
2359 for (i = 0; i < ehdr->e_shnum; i++) {
2360 if (shdr[i].sh_type == SHT_STRTAB
2361 /* Ignore the section header's string table. */
2362 && i != ehdr->e_shstrndx
2363 /* Ignore string tables named .stabstr, as they contain
2365 && 0 != memcmp(".stabstr", sh_strtab + shdr[i].sh_name, 8)
2367 IF_DEBUG(linker,belch(" section %d is a normal string table", i ));
2368 strtab = ehdrC + shdr[i].sh_offset;
2373 belch("%s: no string tables, or too many", oc->fileName);
2378 IF_DEBUG(linker,belch( "\nSymbol tables" ));
2379 for (i = 0; i < ehdr->e_shnum; i++) {
2380 if (shdr[i].sh_type != SHT_SYMTAB) continue;
2381 IF_DEBUG(linker,belch( "section %d is a symbol table", i ));
2383 stab = (Elf_Sym*) (ehdrC + shdr[i].sh_offset);
2384 nent = shdr[i].sh_size / sizeof(Elf_Sym);
2385 IF_DEBUG(linker,belch( " number of entries is apparently %d (%d rem)",
2387 shdr[i].sh_size % sizeof(Elf_Sym)
2389 if (0 != shdr[i].sh_size % sizeof(Elf_Sym)) {
2390 belch("%s: non-integral number of symbol table entries", oc->fileName);
2393 for (j = 0; j < nent; j++) {
2394 IF_DEBUG(linker,fprintf(stderr, " %2d ", j ));
2395 IF_DEBUG(linker,fprintf(stderr, " sec=%-5d size=%-3d val=%5p ",
2396 (int)stab[j].st_shndx,
2397 (int)stab[j].st_size,
2398 (char*)stab[j].st_value ));
2400 IF_DEBUG(linker,fprintf(stderr, "type=" ));
2401 switch (ELF_ST_TYPE(stab[j].st_info)) {
2402 case STT_NOTYPE: IF_DEBUG(linker,fprintf(stderr, "notype " )); break;
2403 case STT_OBJECT: IF_DEBUG(linker,fprintf(stderr, "object " )); break;
2404 case STT_FUNC : IF_DEBUG(linker,fprintf(stderr, "func " )); break;
2405 case STT_SECTION: IF_DEBUG(linker,fprintf(stderr, "section" )); break;
2406 case STT_FILE: IF_DEBUG(linker,fprintf(stderr, "file " )); break;
2407 default: IF_DEBUG(linker,fprintf(stderr, "? " )); break;
2409 IF_DEBUG(linker,fprintf(stderr, " " ));
2411 IF_DEBUG(linker,fprintf(stderr, "bind=" ));
2412 switch (ELF_ST_BIND(stab[j].st_info)) {
2413 case STB_LOCAL : IF_DEBUG(linker,fprintf(stderr, "local " )); break;
2414 case STB_GLOBAL: IF_DEBUG(linker,fprintf(stderr, "global" )); break;
2415 case STB_WEAK : IF_DEBUG(linker,fprintf(stderr, "weak " )); break;
2416 default: IF_DEBUG(linker,fprintf(stderr, "? " )); break;
2418 IF_DEBUG(linker,fprintf(stderr, " " ));
2420 IF_DEBUG(linker,fprintf(stderr, "name=%s\n", strtab + stab[j].st_name ));
2424 if (nsymtabs == 0) {
2425 belch("%s: didn't find any symbol tables", oc->fileName);
2434 ocGetNames_ELF ( ObjectCode* oc )
2439 char* ehdrC = (char*)(oc->image);
2440 Elf_Ehdr* ehdr = (Elf_Ehdr*)ehdrC;
2441 char* strtab = findElfSection ( ehdrC, SHT_STRTAB );
2442 Elf_Shdr* shdr = (Elf_Shdr*) (ehdrC + ehdr->e_shoff);
2444 ASSERT(symhash != NULL);
2447 belch("%s: no strtab", oc->fileName);
2452 for (i = 0; i < ehdr->e_shnum; i++) {
2453 /* Figure out what kind of section it is. Logic derived from
2454 Figure 1.14 ("Special Sections") of the ELF document
2455 ("Portable Formats Specification, Version 1.1"). */
2456 Elf_Shdr hdr = shdr[i];
2457 SectionKind kind = SECTIONKIND_OTHER;
2460 if (hdr.sh_type == SHT_PROGBITS
2461 && (hdr.sh_flags & SHF_ALLOC) && (hdr.sh_flags & SHF_EXECINSTR)) {
2462 /* .text-style section */
2463 kind = SECTIONKIND_CODE_OR_RODATA;
2466 if (hdr.sh_type == SHT_PROGBITS
2467 && (hdr.sh_flags & SHF_ALLOC) && (hdr.sh_flags & SHF_WRITE)) {
2468 /* .data-style section */
2469 kind = SECTIONKIND_RWDATA;
2472 if (hdr.sh_type == SHT_PROGBITS
2473 && (hdr.sh_flags & SHF_ALLOC) && !(hdr.sh_flags & SHF_WRITE)) {
2474 /* .rodata-style section */
2475 kind = SECTIONKIND_CODE_OR_RODATA;
2478 if (hdr.sh_type == SHT_NOBITS
2479 && (hdr.sh_flags & SHF_ALLOC) && (hdr.sh_flags & SHF_WRITE)) {
2480 /* .bss-style section */
2481 kind = SECTIONKIND_RWDATA;
2485 if (is_bss && shdr[i].sh_size > 0) {
2486 /* This is a non-empty .bss section. Allocate zeroed space for
2487 it, and set its .sh_offset field such that
2488 ehdrC + .sh_offset == addr_of_zeroed_space. */
2489 char* zspace = stgCallocBytes(1, shdr[i].sh_size,
2490 "ocGetNames_ELF(BSS)");
2491 shdr[i].sh_offset = ((char*)zspace) - ((char*)ehdrC);
2493 fprintf(stderr, "BSS section at 0x%x, size %d\n",
2494 zspace, shdr[i].sh_size);
2498 /* fill in the section info */
2499 if (kind != SECTIONKIND_OTHER && shdr[i].sh_size > 0) {
2500 addProddableBlock(oc, ehdrC + shdr[i].sh_offset, shdr[i].sh_size);
2501 addSection(oc, kind, ehdrC + shdr[i].sh_offset,
2502 ehdrC + shdr[i].sh_offset + shdr[i].sh_size - 1);
2505 if (shdr[i].sh_type != SHT_SYMTAB) continue;
2507 /* copy stuff into this module's object symbol table */
2508 stab = (Elf_Sym*) (ehdrC + shdr[i].sh_offset);
2509 nent = shdr[i].sh_size / sizeof(Elf_Sym);
2511 oc->n_symbols = nent;
2512 oc->symbols = stgMallocBytes(oc->n_symbols * sizeof(char*),
2513 "ocGetNames_ELF(oc->symbols)");
2515 for (j = 0; j < nent; j++) {
2517 char isLocal = FALSE; /* avoids uninit-var warning */
2519 char* nm = strtab + stab[j].st_name;
2520 int secno = stab[j].st_shndx;
2522 /* Figure out if we want to add it; if so, set ad to its
2523 address. Otherwise leave ad == NULL. */
2525 if (secno == SHN_COMMON) {
2527 ad = stgCallocBytes(1, stab[j].st_size, "ocGetNames_ELF(COMMON)");
2529 fprintf(stderr, "COMMON symbol, size %d name %s\n",
2530 stab[j].st_size, nm);
2532 /* Pointless to do addProddableBlock() for this area,
2533 since the linker should never poke around in it. */
2536 if ( ( ELF_ST_BIND(stab[j].st_info)==STB_GLOBAL
2537 || ELF_ST_BIND(stab[j].st_info)==STB_LOCAL
2539 /* and not an undefined symbol */
2540 && stab[j].st_shndx != SHN_UNDEF
2541 /* and not in a "special section" */
2542 && stab[j].st_shndx < SHN_LORESERVE
2544 /* and it's a not a section or string table or anything silly */
2545 ( ELF_ST_TYPE(stab[j].st_info)==STT_FUNC ||
2546 ELF_ST_TYPE(stab[j].st_info)==STT_OBJECT ||
2547 ELF_ST_TYPE(stab[j].st_info)==STT_NOTYPE
2550 /* Section 0 is the undefined section, hence > and not >=. */
2551 ASSERT(secno > 0 && secno < ehdr->e_shnum);
2553 if (shdr[secno].sh_type == SHT_NOBITS) {
2554 fprintf(stderr, " BSS symbol, size %d off %d name %s\n",
2555 stab[j].st_size, stab[j].st_value, nm);
2558 ad = ehdrC + shdr[ secno ].sh_offset + stab[j].st_value;
2559 if (ELF_ST_BIND(stab[j].st_info)==STB_LOCAL) {
2562 #ifdef ELF_FUNCTION_DESC
2563 /* dlsym() and the initialisation table both give us function
2564 * descriptors, so to be consistent we store function descriptors
2565 * in the symbol table */
2566 if (ELF_ST_TYPE(stab[j].st_info) == STT_FUNC)
2567 ad = (char *)allocateFunctionDesc((Elf_Addr)ad);
2569 IF_DEBUG(linker,belch( "addOTabName(GLOB): %10p %s %s",
2570 ad, oc->fileName, nm ));
2575 /* And the decision is ... */
2579 oc->symbols[j] = nm;
2582 /* Ignore entirely. */
2584 ghciInsertStrHashTable(oc->fileName, symhash, nm, ad);
2588 IF_DEBUG(linker,belch( "skipping `%s'",
2589 strtab + stab[j].st_name ));
2592 "skipping bind = %d, type = %d, shndx = %d `%s'\n",
2593 (int)ELF_ST_BIND(stab[j].st_info),
2594 (int)ELF_ST_TYPE(stab[j].st_info),
2595 (int)stab[j].st_shndx,
2596 strtab + stab[j].st_name
2599 oc->symbols[j] = NULL;
2608 /* Do ELF relocations which lack an explicit addend. All x86-linux
2609 relocations appear to be of this form. */
2611 do_Elf_Rel_relocations ( ObjectCode* oc, char* ehdrC,
2612 Elf_Shdr* shdr, int shnum,
2613 Elf_Sym* stab, char* strtab )
2618 Elf_Rel* rtab = (Elf_Rel*) (ehdrC + shdr[shnum].sh_offset);
2619 int nent = shdr[shnum].sh_size / sizeof(Elf_Rel);
2620 int target_shndx = shdr[shnum].sh_info;
2621 int symtab_shndx = shdr[shnum].sh_link;
2623 stab = (Elf_Sym*) (ehdrC + shdr[ symtab_shndx ].sh_offset);
2624 targ = (Elf_Word*)(ehdrC + shdr[ target_shndx ].sh_offset);
2625 IF_DEBUG(linker,belch( "relocations for section %d using symtab %d",
2626 target_shndx, symtab_shndx ));
2628 for (j = 0; j < nent; j++) {
2629 Elf_Addr offset = rtab[j].r_offset;
2630 Elf_Addr info = rtab[j].r_info;
2632 Elf_Addr P = ((Elf_Addr)targ) + offset;
2633 Elf_Word* pP = (Elf_Word*)P;
2638 IF_DEBUG(linker,belch( "Rel entry %3d is raw(%6p %6p)",
2639 j, (void*)offset, (void*)info ));
2641 IF_DEBUG(linker,belch( " ZERO" ));
2644 Elf_Sym sym = stab[ELF_R_SYM(info)];
2645 /* First see if it is a local symbol. */
2646 if (ELF_ST_BIND(sym.st_info) == STB_LOCAL) {
2647 /* Yes, so we can get the address directly from the ELF symbol
2649 symbol = sym.st_name==0 ? "(noname)" : strtab+sym.st_name;
2651 (ehdrC + shdr[ sym.st_shndx ].sh_offset
2652 + stab[ELF_R_SYM(info)].st_value);
2655 /* No, so look up the name in our global table. */
2656 symbol = strtab + sym.st_name;
2657 (void*)S = lookupSymbol( symbol );
2660 belch("%s: unknown symbol `%s'", oc->fileName, symbol);
2663 IF_DEBUG(linker,belch( "`%s' resolves to %p", symbol, (void*)S ));
2666 IF_DEBUG(linker,belch( "Reloc: P = %p S = %p A = %p",
2667 (void*)P, (void*)S, (void*)A ));
2668 checkProddableBlock ( oc, pP );
2672 switch (ELF_R_TYPE(info)) {
2673 # ifdef i386_TARGET_ARCH
2674 case R_386_32: *pP = value; break;
2675 case R_386_PC32: *pP = value - P; break;
2678 belch("%s: unhandled ELF relocation(Rel) type %d\n",
2679 oc->fileName, ELF_R_TYPE(info));
2687 /* Do ELF relocations for which explicit addends are supplied.
2688 sparc-solaris relocations appear to be of this form. */
2690 do_Elf_Rela_relocations ( ObjectCode* oc, char* ehdrC,
2691 Elf_Shdr* shdr, int shnum,
2692 Elf_Sym* stab, char* strtab )
2697 Elf_Rela* rtab = (Elf_Rela*) (ehdrC + shdr[shnum].sh_offset);
2698 int nent = shdr[shnum].sh_size / sizeof(Elf_Rela);
2699 int target_shndx = shdr[shnum].sh_info;
2700 int symtab_shndx = shdr[shnum].sh_link;
2702 stab = (Elf_Sym*) (ehdrC + shdr[ symtab_shndx ].sh_offset);
2703 targ = (Elf_Addr) (ehdrC + shdr[ target_shndx ].sh_offset);
2704 IF_DEBUG(linker,belch( "relocations for section %d using symtab %d",
2705 target_shndx, symtab_shndx ));
2707 for (j = 0; j < nent; j++) {
2708 #if defined(DEBUG) || defined(sparc_TARGET_ARCH) || defined(ia64_TARGET_ARCH)
2709 /* This #ifdef only serves to avoid unused-var warnings. */
2710 Elf_Addr offset = rtab[j].r_offset;
2711 Elf_Addr P = targ + offset;
2713 Elf_Addr info = rtab[j].r_info;
2714 Elf_Addr A = rtab[j].r_addend;
2717 # if defined(sparc_TARGET_ARCH)
2718 Elf_Word* pP = (Elf_Word*)P;
2720 # elif defined(ia64_TARGET_ARCH)
2721 Elf64_Xword *pP = (Elf64_Xword *)P;
2725 IF_DEBUG(linker,belch( "Rel entry %3d is raw(%6p %6p %6p) ",
2726 j, (void*)offset, (void*)info,
2729 IF_DEBUG(linker,belch( " ZERO" ));
2732 Elf_Sym sym = stab[ELF_R_SYM(info)];
2733 /* First see if it is a local symbol. */
2734 if (ELF_ST_BIND(sym.st_info) == STB_LOCAL) {
2735 /* Yes, so we can get the address directly from the ELF symbol
2737 symbol = sym.st_name==0 ? "(noname)" : strtab+sym.st_name;
2739 (ehdrC + shdr[ sym.st_shndx ].sh_offset
2740 + stab[ELF_R_SYM(info)].st_value);
2741 #ifdef ELF_FUNCTION_DESC
2742 /* Make a function descriptor for this function */
2743 if (S && ELF_ST_TYPE(sym.st_info) == STT_FUNC) {
2744 S = allocateFunctionDesc(S + A);
2749 /* No, so look up the name in our global table. */
2750 symbol = strtab + sym.st_name;
2751 (void*)S = lookupSymbol( symbol );
2753 #ifdef ELF_FUNCTION_DESC
2754 /* If a function, already a function descriptor - we would
2755 have to copy it to add an offset. */
2756 if (S && (ELF_ST_TYPE(sym.st_info) == STT_FUNC) && (A != 0))
2757 belch("%s: function %s with addend %p", oc->fileName, symbol, (void *)A);
2761 belch("%s: unknown symbol `%s'", oc->fileName, symbol);
2764 IF_DEBUG(linker,belch( "`%s' resolves to %p", symbol, (void*)S ));
2767 IF_DEBUG(linker,fprintf ( stderr, "Reloc: P = %p S = %p A = %p\n",
2768 (void*)P, (void*)S, (void*)A ));
2769 /* checkProddableBlock ( oc, (void*)P ); */
2773 switch (ELF_R_TYPE(info)) {
2774 # if defined(sparc_TARGET_ARCH)
2775 case R_SPARC_WDISP30:
2776 w1 = *pP & 0xC0000000;
2777 w2 = (Elf_Word)((value - P) >> 2);
2778 ASSERT((w2 & 0xC0000000) == 0);
2783 w1 = *pP & 0xFFC00000;
2784 w2 = (Elf_Word)(value >> 10);
2785 ASSERT((w2 & 0xFFC00000) == 0);
2791 w2 = (Elf_Word)(value & 0x3FF);
2792 ASSERT((w2 & ~0x3FF) == 0);
2796 /* According to the Sun documentation:
2798 This relocation type resembles R_SPARC_32, except it refers to an
2799 unaligned word. That is, the word to be relocated must be treated
2800 as four separate bytes with arbitrary alignment, not as a word
2801 aligned according to the architecture requirements.
2803 (JRS: which means that freeloading on the R_SPARC_32 case
2804 is probably wrong, but hey ...)
2808 w2 = (Elf_Word)value;
2811 # elif defined(ia64_TARGET_ARCH)
2812 case R_IA64_DIR64LSB:
2813 case R_IA64_FPTR64LSB:
2816 case R_IA64_PCREL64LSB:
2819 case R_IA64_SEGREL64LSB:
2820 addr = findElfSegment(ehdrC, value);
2823 case R_IA64_GPREL22:
2824 ia64_reloc_gprel22(P, value);
2826 case R_IA64_LTOFF22:
2827 case R_IA64_LTOFF22X:
2828 case R_IA64_LTOFF_FPTR22:
2829 addr = allocateGOTEntry(value);
2830 ia64_reloc_gprel22(P, addr);
2832 case R_IA64_PCREL21B:
2833 ia64_reloc_pcrel21(P, S, oc);
2836 /* This goes with R_IA64_LTOFF22X and points to the load to
2837 * convert into a move. We don't implement relaxation. */
2841 belch("%s: unhandled ELF relocation(RelA) type %d\n",
2842 oc->fileName, ELF_R_TYPE(info));
2851 ocResolve_ELF ( ObjectCode* oc )
2855 Elf_Sym* stab = NULL;
2856 char* ehdrC = (char*)(oc->image);
2857 Elf_Ehdr* ehdr = (Elf_Ehdr*) ehdrC;
2858 Elf_Shdr* shdr = (Elf_Shdr*) (ehdrC + ehdr->e_shoff);
2859 char* sh_strtab = ehdrC + shdr[ehdr->e_shstrndx].sh_offset;
2861 /* first find "the" symbol table */
2862 stab = (Elf_Sym*) findElfSection ( ehdrC, SHT_SYMTAB );
2864 /* also go find the string table */
2865 strtab = findElfSection ( ehdrC, SHT_STRTAB );
2867 if (stab == NULL || strtab == NULL) {
2868 belch("%s: can't find string or symbol table", oc->fileName);
2872 /* Process the relocation sections. */
2873 for (shnum = 0; shnum < ehdr->e_shnum; shnum++) {
2875 /* Skip sections called ".rel.stab". These appear to contain
2876 relocation entries that, when done, make the stabs debugging
2877 info point at the right places. We ain't interested in all
2879 if (0 == memcmp(".rel.stab", sh_strtab + shdr[shnum].sh_name, 9))
2882 if (shdr[shnum].sh_type == SHT_REL ) {
2883 ok = do_Elf_Rel_relocations ( oc, ehdrC, shdr,
2884 shnum, stab, strtab );
2888 if (shdr[shnum].sh_type == SHT_RELA) {
2889 ok = do_Elf_Rela_relocations ( oc, ehdrC, shdr,
2890 shnum, stab, strtab );
2895 /* Free the local symbol table; we won't need it again. */
2896 freeHashTable(oc->lochash, NULL);
2904 * Instructions are 41 bits long, packed into 128 bit bundles with a 5-bit template
2905 * at the front. The following utility functions pack and unpack instructions, and
2906 * take care of the most common relocations.
2909 #ifdef ia64_TARGET_ARCH
2912 ia64_extract_instruction(Elf64_Xword *target)
2915 int slot = (Elf_Addr)target & 3;
2916 (Elf_Addr)target &= ~3;
2924 return ((w1 >> 5) & 0x1ffffffffff);
2926 return (w1 >> 46) | ((w2 & 0x7fffff) << 18);
2930 barf("ia64_extract_instruction: invalid slot %p", target);
2935 ia64_deposit_instruction(Elf64_Xword *target, Elf64_Xword value)
2937 int slot = (Elf_Addr)target & 3;
2938 (Elf_Addr)target &= ~3;
2943 *target |= value << 5;
2946 *target |= value << 46;
2947 *(target+1) |= value >> 18;
2950 *(target+1) |= value << 23;
2956 ia64_reloc_gprel22(Elf_Addr target, Elf_Addr value)
2958 Elf64_Xword instruction;
2959 Elf64_Sxword rel_value;
2961 rel_value = value - gp_val;
2962 if ((rel_value > 0x1fffff) || (rel_value < -0x1fffff))
2963 barf("GP-relative data out of range (address = 0x%lx, gp = 0x%lx)", value, gp_val);
2965 instruction = ia64_extract_instruction((Elf64_Xword *)target);
2966 instruction |= (((rel_value >> 0) & 0x07f) << 13) /* imm7b */
2967 | (((rel_value >> 7) & 0x1ff) << 27) /* imm9d */
2968 | (((rel_value >> 16) & 0x01f) << 22) /* imm5c */
2969 | ((Elf64_Xword)(rel_value < 0) << 36); /* s */
2970 ia64_deposit_instruction((Elf64_Xword *)target, instruction);
2974 ia64_reloc_pcrel21(Elf_Addr target, Elf_Addr value, ObjectCode *oc)
2976 Elf64_Xword instruction;
2977 Elf64_Sxword rel_value;
2980 entry = allocatePLTEntry(value, oc);
2982 rel_value = (entry >> 4) - (target >> 4);
2983 if ((rel_value > 0xfffff) || (rel_value < -0xfffff))
2984 barf("PLT entry too far away (entry = 0x%lx, target = 0x%lx)", entry, target);
2986 instruction = ia64_extract_instruction((Elf64_Xword *)target);
2987 instruction |= ((rel_value & 0xfffff) << 13) /* imm20b */
2988 | ((Elf64_Xword)(rel_value < 0) << 36); /* s */
2989 ia64_deposit_instruction((Elf64_Xword *)target, instruction);
2996 /* --------------------------------------------------------------------------
2998 * ------------------------------------------------------------------------*/
3000 #if defined(OBJFORMAT_MACHO)
3003 Initial support for MachO linking on Darwin/MacOS X on PowerPC chips
3004 by Wolfgang Thaller (wolfgang.thaller@gmx.net)
3006 I hereby formally apologize for the hackish nature of this code.
3007 Things that need to be done:
3008 *) handle uninitialized data sections ("__common").
3009 Normal common definitions work, but beware if you pass -fno-common to gcc.
3010 *) implement ocVerifyImage_MachO
3011 *) add still more sanity checks.
3016 ocAllocateJumpIslands_MachO
3018 Allocate additional space at the end of the object file image to make room
3021 PowerPC relative branch instructions have a 24 bit displacement field.
3022 As PPC code is always 4-byte-aligned, this yields a +-32MB range.
3023 If a particular imported symbol is outside this range, we have to redirect
3024 the jump to a short piece of new code that just loads the 32bit absolute
3025 address and jumps there.
3026 This function just allocates space for one 16 byte jump island for every
3027 undefined symbol in the object file. The code for the islands is filled in by
3028 makeJumpIsland below.
3031 static const int islandSize = 16;
3033 static int ocAllocateJumpIslands_MachO(ObjectCode* oc)
3035 char *image = (char*) oc->image;
3036 struct mach_header *header = (struct mach_header*) image;
3037 struct load_command *lc = (struct load_command*) (image + sizeof(struct mach_header));
3040 for(i=0;i<header->ncmds;i++)
3042 if(lc->cmd == LC_DYSYMTAB)
3044 struct dysymtab_command *dsymLC = (struct dysymtab_command*) lc;
3045 unsigned long nundefsym = dsymLC->nundefsym;
3046 oc->island_start_symbol = dsymLC->iundefsym;
3047 oc->n_islands = nundefsym;
3052 #error ocAllocateJumpIslands_MachO doesnt want USE_MMAP to be defined
3054 oc->image = stgReallocBytes(
3055 image, oc->fileSize + islandSize * nundefsym,
3056 "ocAllocateJumpIslands_MachO");
3058 oc->jump_islands = oc->image + oc->fileSize;
3059 memset(oc->jump_islands, 0, islandSize * nundefsym);
3062 break; // there can be only one LC_DSYMTAB
3064 lc = (struct load_command *) ( ((char*)lc) + lc->cmdsize );
3069 static int ocVerifyImage_MachO(ObjectCode* oc)
3071 // FIXME: do some verifying here
3075 static int resolveImports(
3078 struct symtab_command *symLC,
3079 struct section *sect, // ptr to lazy or non-lazy symbol pointer section
3080 unsigned long *indirectSyms,
3081 struct nlist *nlist)
3085 for(i=0;i*4<sect->size;i++)
3087 // according to otool, reserved1 contains the first index into the indirect symbol table
3088 struct nlist *symbol = &nlist[indirectSyms[sect->reserved1+i]];
3089 char *nm = image + symLC->stroff + symbol->n_un.n_strx;
3092 if((symbol->n_type & N_TYPE) == N_UNDF
3093 && (symbol->n_type & N_EXT) && (symbol->n_value != 0))
3094 addr = (void*) (symbol->n_value);
3095 else if((addr = lookupLocalSymbol(oc,nm)) != NULL)
3098 addr = lookupSymbol(nm);
3101 belch("\n%s: unknown symbol `%s'", oc->fileName, nm);
3105 checkProddableBlock(oc,((void**)(image + sect->offset)) + i);
3106 ((void**)(image + sect->offset))[i] = addr;
3112 static void* makeJumpIsland(
3114 unsigned long symbolNumber,
3117 if(symbolNumber < oc->island_start_symbol ||
3118 symbolNumber - oc->island_start_symbol > oc->n_islands)
3120 symbolNumber -= oc->island_start_symbol;
3122 void *island = (void*) ((char*)oc->jump_islands + islandSize * symbolNumber);
3123 unsigned long *p = (unsigned long*) island;
3125 // lis r12, hi16(target)
3126 *p++ = 0x3d800000 | ( ((unsigned long) target) >> 16 );
3127 // ori r12, r12, lo16(target)
3128 *p++ = 0x618c0000 | ( ((unsigned long) target) & 0xFFFF );
3134 return (void*) island;
3137 static int relocateSection(
3140 struct symtab_command *symLC, struct nlist *nlist,
3141 struct section* sections, struct section *sect)
3143 struct relocation_info *relocs;
3146 if(!strcmp(sect->sectname,"__la_symbol_ptr"))
3148 else if(!strcmp(sect->sectname,"__nl_symbol_ptr"))
3152 relocs = (struct relocation_info*) (image + sect->reloff);
3156 if(relocs[i].r_address & R_SCATTERED)
3158 struct scattered_relocation_info *scat =
3159 (struct scattered_relocation_info*) &relocs[i];
3163 if(scat->r_length == 2 && scat->r_type == GENERIC_RELOC_VANILLA)
3165 unsigned long* word = (unsigned long*) (image + sect->offset + scat->r_address);
3167 checkProddableBlock(oc,word);
3168 *word = scat->r_value + sect->offset + ((long) image);
3172 continue; // FIXME: I hope it's OK to ignore all the others.
3176 struct relocation_info *reloc = &relocs[i];
3177 if(reloc->r_pcrel && !reloc->r_extern)
3180 if(reloc->r_length == 2)
3182 unsigned long word = 0;
3183 unsigned long jumpIsland = 0;
3184 long offsetToJumpIsland;
3186 unsigned long* wordPtr = (unsigned long*) (image + sect->offset + reloc->r_address);
3187 checkProddableBlock(oc,wordPtr);
3189 if(reloc->r_type == GENERIC_RELOC_VANILLA)
3193 else if(reloc->r_type == PPC_RELOC_LO16)
3195 word = ((unsigned short*) wordPtr)[1];
3196 word |= ((unsigned long) relocs[i+1].r_address & 0xFFFF) << 16;
3198 else if(reloc->r_type == PPC_RELOC_HI16)
3200 word = ((unsigned short*) wordPtr)[1] << 16;
3201 word |= ((unsigned long) relocs[i+1].r_address & 0xFFFF);
3203 else if(reloc->r_type == PPC_RELOC_HA16)
3205 word = ((unsigned short*) wordPtr)[1] << 16;
3206 word += ((short)relocs[i+1].r_address & (short)0xFFFF);
3208 else if(reloc->r_type == PPC_RELOC_BR24)
3211 word = (word & 0x03FFFFFC) | (word & 0x02000000) ? 0xFC000000 : 0;
3215 if(!reloc->r_extern)
3218 sections[reloc->r_symbolnum-1].offset
3219 - sections[reloc->r_symbolnum-1].addr
3226 struct nlist *symbol = &nlist[reloc->r_symbolnum];
3227 char *nm = image + symLC->stroff + symbol->n_un.n_strx;
3228 word = (unsigned long) (lookupSymbol(nm));
3231 belch("\nunknown symbol `%s'", nm);
3237 jumpIsland = (long) makeJumpIsland(oc,reloc->r_symbolnum,(void*)word);
3238 word -= ((long)image) + sect->offset + reloc->r_address;
3241 offsetToJumpIsland = jumpIsland
3242 - (((long)image) + sect->offset + reloc->r_address);
3247 if(reloc->r_type == GENERIC_RELOC_VANILLA)
3252 else if(reloc->r_type == PPC_RELOC_LO16)
3254 ((unsigned short*) wordPtr)[1] = word & 0xFFFF;
3257 else if(reloc->r_type == PPC_RELOC_HI16)
3259 ((unsigned short*) wordPtr)[1] = (word >> 16) & 0xFFFF;
3262 else if(reloc->r_type == PPC_RELOC_HA16)
3264 ((unsigned short*) wordPtr)[1] = ((word >> 16) & 0xFFFF)
3265 + ((word & (1<<15)) ? 1 : 0);
3268 else if(reloc->r_type == PPC_RELOC_BR24)
3270 if((long)word > (long)0x01FFFFFF || (long)word < (long)0xFFE00000)
3272 // The branch offset is too large.
3273 // Therefore, we try to use a jump island.
3275 barf("unconditional relative branch out of range: "
3276 "no jump island available");
3278 word = offsetToJumpIsland;
3279 if((long)word > (long)0x01FFFFFF || (long)word < (long)0xFFE00000)
3280 barf("unconditional relative branch out of range: "
3281 "jump island out of range");
3283 *wordPtr = (*wordPtr & 0xFC000003) | (word & 0x03FFFFFC);
3287 barf("\nunknown relocation %d",reloc->r_type);
3294 static int ocGetNames_MachO(ObjectCode* oc)
3296 char *image = (char*) oc->image;
3297 struct mach_header *header = (struct mach_header*) image;
3298 struct load_command *lc = (struct load_command*) (image + sizeof(struct mach_header));
3299 unsigned i,curSymbol;
3300 struct segment_command *segLC = NULL;
3301 struct section *sections, *la_ptrs = NULL, *nl_ptrs = NULL;
3302 struct symtab_command *symLC = NULL;
3303 struct dysymtab_command *dsymLC = NULL;
3304 struct nlist *nlist;
3305 unsigned long commonSize = 0;
3306 char *commonStorage = NULL;
3307 unsigned long commonCounter;
3309 for(i=0;i<header->ncmds;i++)
3311 if(lc->cmd == LC_SEGMENT)
3312 segLC = (struct segment_command*) lc;
3313 else if(lc->cmd == LC_SYMTAB)
3314 symLC = (struct symtab_command*) lc;
3315 else if(lc->cmd == LC_DYSYMTAB)
3316 dsymLC = (struct dysymtab_command*) lc;
3317 lc = (struct load_command *) ( ((char*)lc) + lc->cmdsize );
3320 sections = (struct section*) (segLC+1);
3321 nlist = (struct nlist*) (image + symLC->symoff);
3323 for(i=0;i<segLC->nsects;i++)
3325 if(!strcmp(sections[i].sectname,"__la_symbol_ptr"))
3326 la_ptrs = §ions[i];
3327 else if(!strcmp(sections[i].sectname,"__nl_symbol_ptr"))
3328 nl_ptrs = §ions[i];
3330 // for now, only add __text and __const to the sections table
3331 else if(!strcmp(sections[i].sectname,"__text"))
3332 addSection(oc, SECTIONKIND_CODE_OR_RODATA,
3333 (void*) (image + sections[i].offset),
3334 (void*) (image + sections[i].offset + sections[i].size));
3335 else if(!strcmp(sections[i].sectname,"__const"))
3336 addSection(oc, SECTIONKIND_RWDATA,
3337 (void*) (image + sections[i].offset),
3338 (void*) (image + sections[i].offset + sections[i].size));
3339 else if(!strcmp(sections[i].sectname,"__data"))
3340 addSection(oc, SECTIONKIND_RWDATA,
3341 (void*) (image + sections[i].offset),
3342 (void*) (image + sections[i].offset + sections[i].size));
3344 if(sections[i].size > 0) // size 0 segments do exist
3345 addProddableBlock(oc, (void*) (image + sections[i].offset),
3349 // count external symbols defined here
3351 for(i=dsymLC->iextdefsym;i<dsymLC->iextdefsym+dsymLC->nextdefsym;i++)
3353 if((nlist[i].n_type & N_TYPE) == N_SECT)
3356 for(i=0;i<symLC->nsyms;i++)
3358 if((nlist[i].n_type & N_TYPE) == N_UNDF
3359 && (nlist[i].n_type & N_EXT) && (nlist[i].n_value != 0))
3361 commonSize += nlist[i].n_value;
3365 oc->symbols = stgMallocBytes(oc->n_symbols * sizeof(char*),
3366 "ocGetNames_MachO(oc->symbols)");
3368 // insert symbols into hash table
3369 for(i=dsymLC->iextdefsym,curSymbol=0;i<dsymLC->iextdefsym+dsymLC->nextdefsym;i++)
3371 if((nlist[i].n_type & N_TYPE) == N_SECT)
3373 char *nm = image + symLC->stroff + nlist[i].n_un.n_strx;
3374 ghciInsertStrHashTable(oc->fileName, symhash, nm, image +
3375 sections[nlist[i].n_sect-1].offset
3376 - sections[nlist[i].n_sect-1].addr
3377 + nlist[i].n_value);
3378 oc->symbols[curSymbol++] = nm;
3382 // insert local symbols into lochash
3383 for(i=dsymLC->ilocalsym;i<dsymLC->ilocalsym+dsymLC->nlocalsym;i++)
3385 if((nlist[i].n_type & N_TYPE) == N_SECT)
3387 char *nm = image + symLC->stroff + nlist[i].n_un.n_strx;
3388 ghciInsertStrHashTable(oc->fileName, oc->lochash, nm, image +
3389 sections[nlist[i].n_sect-1].offset
3390 - sections[nlist[i].n_sect-1].addr
3391 + nlist[i].n_value);
3396 commonStorage = stgCallocBytes(1,commonSize,"ocGetNames_MachO(common symbols)");
3397 commonCounter = (unsigned long)commonStorage;
3398 for(i=0;i<symLC->nsyms;i++)
3400 if((nlist[i].n_type & N_TYPE) == N_UNDF
3401 && (nlist[i].n_type & N_EXT) && (nlist[i].n_value != 0))
3403 char *nm = image + symLC->stroff + nlist[i].n_un.n_strx;
3404 unsigned long sz = nlist[i].n_value;
3406 nlist[i].n_value = commonCounter;
3408 ghciInsertStrHashTable(oc->fileName, symhash, nm, (void*)commonCounter);
3409 oc->symbols[curSymbol++] = nm;
3411 commonCounter += sz;
3417 static int ocResolve_MachO(ObjectCode* oc)
3419 char *image = (char*) oc->image;
3420 struct mach_header *header = (struct mach_header*) image;
3421 struct load_command *lc = (struct load_command*) (image + sizeof(struct mach_header));
3423 struct segment_command *segLC = NULL;
3424 struct section *sections, *la_ptrs = NULL, *nl_ptrs = NULL;
3425 struct symtab_command *symLC = NULL;
3426 struct dysymtab_command *dsymLC = NULL;
3427 struct nlist *nlist;
3428 unsigned long *indirectSyms;
3430 for(i=0;i<header->ncmds;i++)
3432 if(lc->cmd == LC_SEGMENT)
3433 segLC = (struct segment_command*) lc;
3434 else if(lc->cmd == LC_SYMTAB)
3435 symLC = (struct symtab_command*) lc;
3436 else if(lc->cmd == LC_DYSYMTAB)
3437 dsymLC = (struct dysymtab_command*) lc;
3438 lc = (struct load_command *) ( ((char*)lc) + lc->cmdsize );
3441 sections = (struct section*) (segLC+1);
3442 nlist = (struct nlist*) (image + symLC->symoff);
3444 for(i=0;i<segLC->nsects;i++)
3446 if(!strcmp(sections[i].sectname,"__la_symbol_ptr"))
3447 la_ptrs = §ions[i];
3448 else if(!strcmp(sections[i].sectname,"__nl_symbol_ptr"))
3449 nl_ptrs = §ions[i];
3452 indirectSyms = (unsigned long*) (image + dsymLC->indirectsymoff);
3455 if(!resolveImports(oc,image,symLC,la_ptrs,indirectSyms,nlist))
3458 if(!resolveImports(oc,image,symLC,nl_ptrs,indirectSyms,nlist))
3461 for(i=0;i<segLC->nsects;i++)
3463 if(!relocateSection(oc,image,symLC,nlist,sections,§ions[i]))
3467 /* Free the local symbol table; we won't need it again. */
3468 freeHashTable(oc->lochash, NULL);
3472 Flush the data & instruction caches.
3473 Because the PPC has split data/instruction caches, we have to
3474 do that whenever we modify code at runtime.
3477 int n = (oc->fileSize + islandSize * oc->n_islands) / 4;
3478 unsigned long *p = (unsigned long*)oc->image;
3481 __asm__ volatile ("dcbf 0,%0\n\tsync\n\ticbi 0,%0"
3485 __asm__ volatile ("sync\n\tisync");
3491 * The Mach-O object format uses leading underscores. But not everywhere.
3492 * There is a small number of runtime support functions defined in
3493 * libcc_dynamic.a whose name does not have a leading underscore.
3494 * As a consequence, we can't get their address from C code.
3495 * We have to use inline assembler just to take the address of a function.
3499 static void machoInitSymbolsWithoutUnderscore()
3505 __asm__ ("lis %0,hi16(" #x ")\n\tori %0,%0,lo16(" #x ")" : "=r" (p)); \
3506 ghciInsertStrHashTable("(GHCi built-in symbols)", symhash, #x, p);
3508 RTS_MACHO_NOUNDERLINE_SYMBOLS