1 /* -----------------------------------------------------------------------------
2 * $Id: Linker.c,v 1.126 2003/08/18 09:27:54 dons 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>
76 /* Hash table mapping symbol names to Symbol */
77 static /*Str*/HashTable *symhash;
79 /* List of currently loaded objects */
80 ObjectCode *objects = NULL; /* initially empty */
82 #if defined(OBJFORMAT_ELF)
83 static int ocVerifyImage_ELF ( ObjectCode* oc );
84 static int ocGetNames_ELF ( ObjectCode* oc );
85 static int ocResolve_ELF ( ObjectCode* oc );
86 #elif defined(OBJFORMAT_PEi386)
87 static int ocVerifyImage_PEi386 ( ObjectCode* oc );
88 static int ocGetNames_PEi386 ( ObjectCode* oc );
89 static int ocResolve_PEi386 ( ObjectCode* oc );
90 #elif defined(OBJFORMAT_MACHO)
91 static int ocVerifyImage_MachO ( ObjectCode* oc );
92 static int ocGetNames_MachO ( ObjectCode* oc );
93 static int ocResolve_MachO ( ObjectCode* oc );
95 static void machoInitSymbolsWithoutUnderscore( void );
98 /* -----------------------------------------------------------------------------
99 * Built-in symbols from the RTS
102 typedef struct _RtsSymbolVal {
109 #define Maybe_ForeignObj SymX(mkForeignObjzh_fast)
111 #define Maybe_Stable_Names SymX(mkWeakzh_fast) \
112 SymX(makeStableNamezh_fast) \
113 SymX(finalizzeWeakzh_fast)
115 /* These are not available in GUM!!! -- HWL */
116 #define Maybe_ForeignObj
117 #define Maybe_Stable_Names
120 #if !defined (mingw32_TARGET_OS)
121 #define RTS_POSIX_ONLY_SYMBOLS \
122 SymX(stg_sig_install) \
126 #if defined (cygwin32_TARGET_OS)
127 #define RTS_MINGW_ONLY_SYMBOLS /**/
128 /* Don't have the ability to read import libs / archives, so
129 * we have to stupidly list a lot of what libcygwin.a
132 #define RTS_CYGWIN_ONLY_SYMBOLS \
210 #elif !defined(mingw32_TARGET_OS)
211 #define RTS_MINGW_ONLY_SYMBOLS /**/
212 #define RTS_CYGWIN_ONLY_SYMBOLS /**/
213 #else /* defined(mingw32_TARGET_OS) */
214 #define RTS_POSIX_ONLY_SYMBOLS /**/
215 #define RTS_CYGWIN_ONLY_SYMBOLS /**/
217 /* Extra syms gen'ed by mingw-2's gcc-3.2: */
219 #define RTS_MINGW_EXTRA_SYMS \
220 Sym(_imp____mb_cur_max) \
223 #define RTS_MINGW_EXTRA_SYMS
226 /* These are statically linked from the mingw libraries into the ghc
227 executable, so we have to employ this hack. */
228 #define RTS_MINGW_ONLY_SYMBOLS \
229 SymX(asyncReadzh_fast) \
230 SymX(asyncWritezh_fast) \
242 SymX(getservbyname) \
243 SymX(getservbyport) \
244 SymX(getprotobynumber) \
245 SymX(getprotobyname) \
246 SymX(gethostbyname) \
247 SymX(gethostbyaddr) \
282 Sym(_imp___timezone) \
290 RTS_MINGW_EXTRA_SYMS \
295 # define MAIN_CAP_SYM SymX(MainCapability)
297 # define MAIN_CAP_SYM
300 #define RTS_SYMBOLS \
304 SymX(stg_enter_info) \
305 SymX(stg_enter_ret) \
306 SymX(stg_gc_void_info) \
307 SymX(__stg_gc_enter_1) \
308 SymX(stg_gc_noregs) \
309 SymX(stg_gc_unpt_r1_info) \
310 SymX(stg_gc_unpt_r1) \
311 SymX(stg_gc_unbx_r1_info) \
312 SymX(stg_gc_unbx_r1) \
313 SymX(stg_gc_f1_info) \
315 SymX(stg_gc_d1_info) \
317 SymX(stg_gc_l1_info) \
320 SymX(stg_gc_fun_info) \
321 SymX(stg_gc_fun_ret) \
323 SymX(stg_gc_gen_info) \
324 SymX(stg_gc_gen_hp) \
326 SymX(stg_gen_yield) \
327 SymX(stg_yield_noregs) \
328 SymX(stg_yield_to_interpreter) \
329 SymX(stg_gen_block) \
330 SymX(stg_block_noregs) \
332 SymX(stg_block_takemvar) \
333 SymX(stg_block_putmvar) \
334 SymX(stg_seq_frame_info) \
337 SymX(MallocFailHook) \
339 SymX(OutOfHeapHook) \
340 SymX(PatErrorHdrHook) \
341 SymX(PostTraceHook) \
343 SymX(StackOverflowHook) \
344 SymX(__encodeDouble) \
345 SymX(__encodeFloat) \
348 SymX(__gmpz_cmp_si) \
349 SymX(__gmpz_cmp_ui) \
350 SymX(__gmpz_get_si) \
351 SymX(__gmpz_get_ui) \
352 SymX(__int_encodeDouble) \
353 SymX(__int_encodeFloat) \
354 SymX(andIntegerzh_fast) \
355 SymX(blockAsyncExceptionszh_fast) \
358 SymX(complementIntegerzh_fast) \
359 SymX(cmpIntegerzh_fast) \
360 SymX(cmpIntegerIntzh_fast) \
361 SymX(createAdjustor) \
362 SymX(decodeDoublezh_fast) \
363 SymX(decodeFloatzh_fast) \
366 SymX(deRefWeakzh_fast) \
367 SymX(deRefStablePtrzh_fast) \
368 SymX(divExactIntegerzh_fast) \
369 SymX(divModIntegerzh_fast) \
371 SymX(forkProcesszh_fast) \
372 SymX(freeHaskellFunctionPtr) \
373 SymX(freeStablePtr) \
374 SymX(gcdIntegerzh_fast) \
375 SymX(gcdIntegerIntzh_fast) \
376 SymX(gcdIntzh_fast) \
379 SymX(int2Integerzh_fast) \
380 SymX(integer2Intzh_fast) \
381 SymX(integer2Wordzh_fast) \
382 SymX(isDoubleDenormalized) \
383 SymX(isDoubleInfinite) \
385 SymX(isDoubleNegativeZero) \
386 SymX(isEmptyMVarzh_fast) \
387 SymX(isFloatDenormalized) \
388 SymX(isFloatInfinite) \
390 SymX(isFloatNegativeZero) \
391 SymX(killThreadzh_fast) \
392 SymX(makeStablePtrzh_fast) \
393 SymX(minusIntegerzh_fast) \
394 SymX(mkApUpd0zh_fast) \
395 SymX(myThreadIdzh_fast) \
396 SymX(labelThreadzh_fast) \
397 SymX(newArrayzh_fast) \
398 SymX(newBCOzh_fast) \
399 SymX(newByteArrayzh_fast) \
400 SymX_redirect(newCAF, newDynCAF) \
401 SymX(newMVarzh_fast) \
402 SymX(newMutVarzh_fast) \
403 SymX(atomicModifyMutVarzh_fast) \
404 SymX(newPinnedByteArrayzh_fast) \
405 SymX(orIntegerzh_fast) \
407 SymX(plusIntegerzh_fast) \
410 SymX(putMVarzh_fast) \
411 SymX(quotIntegerzh_fast) \
412 SymX(quotRemIntegerzh_fast) \
414 SymX(raiseIOzh_fast) \
415 SymX(remIntegerzh_fast) \
416 SymX(resetNonBlockingFd) \
419 SymX(rts_checkSchedStatus) \
422 SymX(rts_evalLazyIO) \
426 SymX(rts_getDouble) \
431 SymX(rts_getFunPtr) \
432 SymX(rts_getStablePtr) \
433 SymX(rts_getThreadId) \
435 SymX(rts_getWord32) \
448 SymX(rts_mkStablePtr) \
458 SymX(startupHaskell) \
459 SymX(shutdownHaskell) \
460 SymX(shutdownHaskellAndExit) \
461 SymX(stable_ptr_table) \
462 SymX(stackOverflow) \
463 SymX(stg_CAF_BLACKHOLE_info) \
464 SymX(stg_BLACKHOLE_BQ_info) \
465 SymX(awakenBlockedQueue) \
466 SymX(stg_CHARLIKE_closure) \
467 SymX(stg_EMPTY_MVAR_info) \
468 SymX(stg_IND_STATIC_info) \
469 SymX(stg_INTLIKE_closure) \
470 SymX(stg_MUT_ARR_PTRS_FROZEN_info) \
471 SymX(stg_WEAK_info) \
472 SymX(stg_ap_v_info) \
473 SymX(stg_ap_f_info) \
474 SymX(stg_ap_d_info) \
475 SymX(stg_ap_l_info) \
476 SymX(stg_ap_n_info) \
477 SymX(stg_ap_p_info) \
478 SymX(stg_ap_pv_info) \
479 SymX(stg_ap_pp_info) \
480 SymX(stg_ap_ppv_info) \
481 SymX(stg_ap_ppp_info) \
482 SymX(stg_ap_pppp_info) \
483 SymX(stg_ap_ppppp_info) \
484 SymX(stg_ap_pppppp_info) \
485 SymX(stg_ap_ppppppp_info) \
493 SymX(stg_ap_pv_ret) \
494 SymX(stg_ap_pp_ret) \
495 SymX(stg_ap_ppv_ret) \
496 SymX(stg_ap_ppp_ret) \
497 SymX(stg_ap_pppp_ret) \
498 SymX(stg_ap_ppppp_ret) \
499 SymX(stg_ap_pppppp_ret) \
500 SymX(stg_ap_ppppppp_ret) \
501 SymX(stg_ap_1_upd_info) \
502 SymX(stg_ap_2_upd_info) \
503 SymX(stg_ap_3_upd_info) \
504 SymX(stg_ap_4_upd_info) \
505 SymX(stg_ap_5_upd_info) \
506 SymX(stg_ap_6_upd_info) \
507 SymX(stg_ap_7_upd_info) \
508 SymX(stg_ap_8_upd_info) \
510 SymX(stg_sel_0_upd_info) \
511 SymX(stg_sel_10_upd_info) \
512 SymX(stg_sel_11_upd_info) \
513 SymX(stg_sel_12_upd_info) \
514 SymX(stg_sel_13_upd_info) \
515 SymX(stg_sel_14_upd_info) \
516 SymX(stg_sel_15_upd_info) \
517 SymX(stg_sel_1_upd_info) \
518 SymX(stg_sel_2_upd_info) \
519 SymX(stg_sel_3_upd_info) \
520 SymX(stg_sel_4_upd_info) \
521 SymX(stg_sel_5_upd_info) \
522 SymX(stg_sel_6_upd_info) \
523 SymX(stg_sel_7_upd_info) \
524 SymX(stg_sel_8_upd_info) \
525 SymX(stg_sel_9_upd_info) \
526 SymX(stg_upd_frame_info) \
527 SymX(suspendThread) \
528 SymX(takeMVarzh_fast) \
529 SymX(timesIntegerzh_fast) \
530 SymX(tryPutMVarzh_fast) \
531 SymX(tryTakeMVarzh_fast) \
532 SymX(unblockAsyncExceptionszh_fast) \
533 SymX(unsafeThawArrayzh_fast) \
534 SymX(waitReadzh_fast) \
535 SymX(waitWritezh_fast) \
536 SymX(word2Integerzh_fast) \
537 SymX(xorIntegerzh_fast) \
540 #ifdef SUPPORT_LONG_LONGS
541 #define RTS_LONG_LONG_SYMS \
542 SymX(int64ToIntegerzh_fast) \
543 SymX(word64ToIntegerzh_fast)
545 #define RTS_LONG_LONG_SYMS /* nothing */
548 // 64-bit support functions in libgcc.a
549 #if defined(__GNUC__) && SIZEOF_VOID_P <= 4
550 #define RTS_LIBGCC_SYMBOLS \
559 #elif defined(ia64_TARGET_ARCH)
560 #define RTS_LIBGCC_SYMBOLS \
568 #define RTS_LIBGCC_SYMBOLS
571 #ifdef darwin_TARGET_OS
572 // Symbols that don't have a leading underscore
573 // on Mac OS X. They have to receive special treatment,
574 // see machoInitSymbolsWithoutUnderscore()
575 #define RTS_MACHO_NOUNDERLINE_SYMBOLS \
580 /* entirely bogus claims about types of these symbols */
581 #define Sym(vvv) extern void vvv(void);
582 #define SymX(vvv) /**/
583 #define SymX_redirect(vvv,xxx) /**/
586 RTS_POSIX_ONLY_SYMBOLS
587 RTS_MINGW_ONLY_SYMBOLS
588 RTS_CYGWIN_ONLY_SYMBOLS
594 #ifdef LEADING_UNDERSCORE
595 #define MAYBE_LEADING_UNDERSCORE_STR(s) ("_" s)
597 #define MAYBE_LEADING_UNDERSCORE_STR(s) (s)
600 #define Sym(vvv) { MAYBE_LEADING_UNDERSCORE_STR(#vvv), \
602 #define SymX(vvv) Sym(vvv)
604 // SymX_redirect allows us to redirect references to one symbol to
605 // another symbol. See newCAF/newDynCAF for an example.
606 #define SymX_redirect(vvv,xxx) \
607 { MAYBE_LEADING_UNDERSCORE_STR(#vvv), \
610 static RtsSymbolVal rtsSyms[] = {
613 RTS_POSIX_ONLY_SYMBOLS
614 RTS_MINGW_ONLY_SYMBOLS
615 RTS_CYGWIN_ONLY_SYMBOLS
617 { 0, 0 } /* sentinel */
620 /* -----------------------------------------------------------------------------
621 * Insert symbols into hash tables, checking for duplicates.
623 static void ghciInsertStrHashTable ( char* obj_name,
629 if (lookupHashTable(table, (StgWord)key) == NULL)
631 insertStrHashTable(table, (StgWord)key, data);
636 "GHCi runtime linker: fatal error: I found a duplicate definition for symbol\n"
638 "whilst processing object file\n"
640 "This could be caused by:\n"
641 " * Loading two different object files which export the same symbol\n"
642 " * Specifying the same object file twice on the GHCi command line\n"
643 " * An incorrect `package.conf' entry, causing some object to be\n"
645 "GHCi cannot safely continue in this situation. Exiting now. Sorry.\n"
654 /* -----------------------------------------------------------------------------
655 * initialize the object linker
659 static int linker_init_done = 0 ;
661 #if defined(OBJFORMAT_ELF) || defined(OBJFORMAT_MACHO)
662 static void *dl_prog_handle;
670 /* Make initLinker idempotent, so we can call it
671 before evey relevant operation; that means we
672 don't need to initialise the linker separately */
673 if (linker_init_done == 1) { return; } else {
674 linker_init_done = 1;
677 symhash = allocStrHashTable();
679 /* populate the symbol table with stuff from the RTS */
680 for (sym = rtsSyms; sym->lbl != NULL; sym++) {
681 ghciInsertStrHashTable("(GHCi built-in symbols)",
682 symhash, sym->lbl, sym->addr);
684 # if defined(OBJFORMAT_MACHO)
685 machoInitSymbolsWithoutUnderscore();
688 # if defined(OBJFORMAT_ELF) || defined(OBJFORMAT_MACHO)
689 dl_prog_handle = dlopen(NULL, RTLD_LAZY);
693 /* -----------------------------------------------------------------------------
694 * Loading DLL or .so dynamic libraries
695 * -----------------------------------------------------------------------------
697 * Add a DLL from which symbols may be found. In the ELF case, just
698 * do RTLD_GLOBAL-style add, so no further messing around needs to
699 * happen in order that symbols in the loaded .so are findable --
700 * lookupSymbol() will subsequently see them by dlsym on the program's
701 * dl-handle. Returns NULL if success, otherwise ptr to an err msg.
703 * In the PEi386 case, open the DLLs and put handles to them in a
704 * linked list. When looking for a symbol, try all handles in the
705 * list. This means that we need to load even DLLs that are guaranteed
706 * to be in the ghc.exe image already, just so we can get a handle
707 * to give to loadSymbol, so that we can find the symbols. For such
708 * libraries, the LoadLibrary call should be a no-op except for returning
713 #if defined(OBJFORMAT_PEi386)
714 /* A record for storing handles into DLLs. */
719 struct _OpenedDLL* next;
724 /* A list thereof. */
725 static OpenedDLL* opened_dlls = NULL;
729 addDLL( char *dll_name )
731 # if defined(OBJFORMAT_ELF) || defined(OBJFORMAT_MACHO)
732 /* ------------------- ELF DLL loader ------------------- */
738 #if !defined(openbsd_TARGET_OS)
739 hdl= dlopen(dll_name, RTLD_NOW | RTLD_GLOBAL);
741 hdl= dlopen(dll_name, RTLD_LAZY);
744 /* dlopen failed; return a ptr to the error msg. */
746 if (errmsg == NULL) errmsg = "addDLL: unknown error";
753 # elif defined(OBJFORMAT_PEi386)
754 /* ------------------- Win32 DLL loader ------------------- */
762 /* fprintf(stderr, "\naddDLL; dll_name = `%s'\n", dll_name); */
764 /* See if we've already got it, and ignore if so. */
765 for (o_dll = opened_dlls; o_dll != NULL; o_dll = o_dll->next) {
766 if (0 == strcmp(o_dll->name, dll_name))
770 /* The file name has no suffix (yet) so that we can try
771 both foo.dll and foo.drv
773 The documentation for LoadLibrary says:
774 If no file name extension is specified in the lpFileName
775 parameter, the default library extension .dll is
776 appended. However, the file name string can include a trailing
777 point character (.) to indicate that the module name has no
780 buf = stgMallocBytes(strlen(dll_name) + 10, "addDLL");
781 sprintf(buf, "%s.DLL", dll_name);
782 instance = LoadLibrary(buf);
783 if (instance == NULL) {
784 sprintf(buf, "%s.DRV", dll_name); // KAA: allow loading of drivers (like winspool.drv)
785 instance = LoadLibrary(buf);
786 if (instance == NULL) {
789 /* LoadLibrary failed; return a ptr to the error msg. */
790 return "addDLL: unknown error";
795 /* Add this DLL to the list of DLLs in which to search for symbols. */
796 o_dll = stgMallocBytes( sizeof(OpenedDLL), "addDLL" );
797 o_dll->name = stgMallocBytes(1+strlen(dll_name), "addDLL");
798 strcpy(o_dll->name, dll_name);
799 o_dll->instance = instance;
800 o_dll->next = opened_dlls;
805 barf("addDLL: not implemented on this platform");
809 /* -----------------------------------------------------------------------------
810 * lookup a symbol in the hash table
813 lookupSymbol( char *lbl )
817 ASSERT(symhash != NULL);
818 val = lookupStrHashTable(symhash, lbl);
821 # if defined(OBJFORMAT_ELF) || defined(OBJFORMAT_MACHO)
822 return dlsym(dl_prog_handle, lbl);
823 # elif defined(OBJFORMAT_PEi386)
826 for (o_dll = opened_dlls; o_dll != NULL; o_dll = o_dll->next) {
827 /* fprintf(stderr, "look in %s for %s\n", o_dll->name, lbl); */
829 /* HACK: if the name has an initial underscore, try stripping
830 it off & look that up first. I've yet to verify whether there's
831 a Rule that governs whether an initial '_' *should always* be
832 stripped off when mapping from import lib name to the DLL name.
834 sym = GetProcAddress(o_dll->instance, (lbl+1));
836 /*fprintf(stderr, "found %s in %s\n", lbl+1,o_dll->name); fflush(stderr);*/
840 sym = GetProcAddress(o_dll->instance, lbl);
842 /*fprintf(stderr, "found %s in %s\n", lbl,o_dll->name); fflush(stderr);*/
857 __attribute((unused))
859 lookupLocalSymbol( ObjectCode* oc, char *lbl )
863 val = lookupStrHashTable(oc->lochash, lbl);
873 /* -----------------------------------------------------------------------------
874 * Debugging aid: look in GHCi's object symbol tables for symbols
875 * within DELTA bytes of the specified address, and show their names.
878 void ghci_enquire ( char* addr );
880 void ghci_enquire ( char* addr )
885 const int DELTA = 64;
890 for (oc = objects; oc; oc = oc->next) {
891 for (i = 0; i < oc->n_symbols; i++) {
892 sym = oc->symbols[i];
893 if (sym == NULL) continue;
894 // fprintf(stderr, "enquire %p %p\n", sym, oc->lochash);
896 if (oc->lochash != NULL) {
897 a = lookupStrHashTable(oc->lochash, sym);
900 a = lookupStrHashTable(symhash, sym);
903 // fprintf(stderr, "ghci_enquire: can't find %s\n", sym);
905 else if (addr-DELTA <= a && a <= addr+DELTA) {
906 fprintf(stderr, "%p + %3d == `%s'\n", addr, a - addr, sym);
913 #ifdef ia64_TARGET_ARCH
914 static unsigned int PLTSize(void);
917 /* -----------------------------------------------------------------------------
918 * Load an obj (populate the global symbol table, but don't resolve yet)
920 * Returns: 1 if ok, 0 on error.
923 loadObj( char *path )
937 /* fprintf(stderr, "loadObj %s\n", path ); */
939 /* Check that we haven't already loaded this object. Don't give up
940 at this stage; ocGetNames_* will barf later. */
944 for (o = objects; o; o = o->next) {
945 if (0 == strcmp(o->fileName, path))
951 "GHCi runtime linker: warning: looks like you're trying to load the\n"
952 "same object file twice:\n"
954 "GHCi will continue, but a duplicate-symbol error may shortly follow.\n"
960 oc = stgMallocBytes(sizeof(ObjectCode), "loadObj(oc)");
962 # if defined(OBJFORMAT_ELF)
963 oc->formatName = "ELF";
964 # elif defined(OBJFORMAT_PEi386)
965 oc->formatName = "PEi386";
966 # elif defined(OBJFORMAT_MACHO)
967 oc->formatName = "Mach-O";
970 barf("loadObj: not implemented on this platform");
974 if (r == -1) { return 0; }
976 /* sigh, strdup() isn't a POSIX function, so do it the long way */
977 oc->fileName = stgMallocBytes( strlen(path)+1, "loadObj" );
978 strcpy(oc->fileName, path);
980 oc->fileSize = st.st_size;
983 oc->lochash = allocStrHashTable();
984 oc->proddables = NULL;
986 /* chain it onto the list of objects */
991 #define ROUND_UP(x,size) ((x + size - 1) & ~(size - 1))
993 /* On many architectures malloc'd memory isn't executable, so we need to use mmap. */
995 fd = open(path, O_RDONLY);
997 barf("loadObj: can't open `%s'", path);
999 pagesize = getpagesize();
1001 #ifdef ia64_TARGET_ARCH
1002 /* The PLT needs to be right before the object */
1003 n = ROUND_UP(PLTSize(), pagesize);
1004 oc->plt = mmap(NULL, n, PROT_EXEC|PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
1005 if (oc->plt == MAP_FAILED)
1006 barf("loadObj: can't allocate PLT");
1009 map_addr = oc->plt + n;
1012 n = ROUND_UP(oc->fileSize, pagesize);
1013 oc->image = mmap(map_addr, n, PROT_EXEC|PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
1014 if (oc->image == MAP_FAILED)
1015 barf("loadObj: can't map `%s'", path);
1019 #else /* !USE_MMAP */
1021 oc->image = stgMallocBytes(oc->fileSize, "loadObj(image)");
1023 /* load the image into memory */
1024 f = fopen(path, "rb");
1026 barf("loadObj: can't read `%s'", path);
1028 n = fread ( oc->image, 1, oc->fileSize, f );
1029 if (n != oc->fileSize)
1030 barf("loadObj: error whilst reading `%s'", path);
1034 #endif /* USE_MMAP */
1036 /* verify the in-memory image */
1037 # if defined(OBJFORMAT_ELF)
1038 r = ocVerifyImage_ELF ( oc );
1039 # elif defined(OBJFORMAT_PEi386)
1040 r = ocVerifyImage_PEi386 ( oc );
1041 # elif defined(OBJFORMAT_MACHO)
1042 r = ocVerifyImage_MachO ( oc );
1044 barf("loadObj: no verify method");
1046 if (!r) { return r; }
1048 /* build the symbol list for this image */
1049 # if defined(OBJFORMAT_ELF)
1050 r = ocGetNames_ELF ( oc );
1051 # elif defined(OBJFORMAT_PEi386)
1052 r = ocGetNames_PEi386 ( oc );
1053 # elif defined(OBJFORMAT_MACHO)
1054 r = ocGetNames_MachO ( oc );
1056 barf("loadObj: no getNames method");
1058 if (!r) { return r; }
1060 /* loaded, but not resolved yet */
1061 oc->status = OBJECT_LOADED;
1066 /* -----------------------------------------------------------------------------
1067 * resolve all the currently unlinked objects in memory
1069 * Returns: 1 if ok, 0 on error.
1079 for (oc = objects; oc; oc = oc->next) {
1080 if (oc->status != OBJECT_RESOLVED) {
1081 # if defined(OBJFORMAT_ELF)
1082 r = ocResolve_ELF ( oc );
1083 # elif defined(OBJFORMAT_PEi386)
1084 r = ocResolve_PEi386 ( oc );
1085 # elif defined(OBJFORMAT_MACHO)
1086 r = ocResolve_MachO ( oc );
1088 barf("resolveObjs: not implemented on this platform");
1090 if (!r) { return r; }
1091 oc->status = OBJECT_RESOLVED;
1097 /* -----------------------------------------------------------------------------
1098 * delete an object from the pool
1101 unloadObj( char *path )
1103 ObjectCode *oc, *prev;
1105 ASSERT(symhash != NULL);
1106 ASSERT(objects != NULL);
1111 for (oc = objects; oc; prev = oc, oc = oc->next) {
1112 if (!strcmp(oc->fileName,path)) {
1114 /* Remove all the mappings for the symbols within this
1119 for (i = 0; i < oc->n_symbols; i++) {
1120 if (oc->symbols[i] != NULL) {
1121 removeStrHashTable(symhash, oc->symbols[i], NULL);
1129 prev->next = oc->next;
1132 /* We're going to leave this in place, in case there are
1133 any pointers from the heap into it: */
1134 /* stgFree(oc->image); */
1135 stgFree(oc->fileName);
1136 stgFree(oc->symbols);
1137 stgFree(oc->sections);
1138 /* The local hash table should have been freed at the end
1139 of the ocResolve_ call on it. */
1140 ASSERT(oc->lochash == NULL);
1146 belch("unloadObj: can't find `%s' to unload", path);
1150 /* -----------------------------------------------------------------------------
1151 * Sanity checking. For each ObjectCode, maintain a list of address ranges
1152 * which may be prodded during relocation, and abort if we try and write
1153 * outside any of these.
1155 static void addProddableBlock ( ObjectCode* oc, void* start, int size )
1158 = stgMallocBytes(sizeof(ProddableBlock), "addProddableBlock");
1159 /* fprintf(stderr, "aPB %p %p %d\n", oc, start, size); */
1163 pb->next = oc->proddables;
1164 oc->proddables = pb;
1167 static void checkProddableBlock ( ObjectCode* oc, void* addr )
1170 for (pb = oc->proddables; pb != NULL; pb = pb->next) {
1171 char* s = (char*)(pb->start);
1172 char* e = s + pb->size - 1;
1173 char* a = (char*)addr;
1174 /* Assumes that the biggest fixup involves a 4-byte write. This
1175 probably needs to be changed to 8 (ie, +7) on 64-bit
1177 if (a >= s && (a+3) <= e) return;
1179 barf("checkProddableBlock: invalid fixup in runtime linker");
1182 /* -----------------------------------------------------------------------------
1183 * Section management.
1185 static void addSection ( ObjectCode* oc, SectionKind kind,
1186 void* start, void* end )
1188 Section* s = stgMallocBytes(sizeof(Section), "addSection");
1192 s->next = oc->sections;
1195 fprintf(stderr, "addSection: %p-%p (size %d), kind %d\n",
1196 start, ((char*)end)-1, end - start + 1, kind );
1202 /* --------------------------------------------------------------------------
1203 * PEi386 specifics (Win32 targets)
1204 * ------------------------------------------------------------------------*/
1206 /* The information for this linker comes from
1207 Microsoft Portable Executable
1208 and Common Object File Format Specification
1209 revision 5.1 January 1998
1210 which SimonM says comes from the MS Developer Network CDs.
1212 It can be found there (on older CDs), but can also be found
1215 http://www.microsoft.com/hwdev/hardware/PECOFF.asp
1217 (this is Rev 6.0 from February 1999).
1219 Things move, so if that fails, try searching for it via
1221 http://www.google.com/search?q=PE+COFF+specification
1223 The ultimate reference for the PE format is the Winnt.h
1224 header file that comes with the Platform SDKs; as always,
1225 implementations will drift wrt their documentation.
1227 A good background article on the PE format is Matt Pietrek's
1228 March 1994 article in Microsoft System Journal (MSJ)
1229 (Vol.9, No. 3): "Peering Inside the PE: A Tour of the
1230 Win32 Portable Executable File Format." The info in there
1231 has recently been updated in a two part article in
1232 MSDN magazine, issues Feb and March 2002,
1233 "Inside Windows: An In-Depth Look into the Win32 Portable
1234 Executable File Format"
1236 John Levine's book "Linkers and Loaders" contains useful
1241 #if defined(OBJFORMAT_PEi386)
1245 typedef unsigned char UChar;
1246 typedef unsigned short UInt16;
1247 typedef unsigned int UInt32;
1254 UInt16 NumberOfSections;
1255 UInt32 TimeDateStamp;
1256 UInt32 PointerToSymbolTable;
1257 UInt32 NumberOfSymbols;
1258 UInt16 SizeOfOptionalHeader;
1259 UInt16 Characteristics;
1263 #define sizeof_COFF_header 20
1270 UInt32 VirtualAddress;
1271 UInt32 SizeOfRawData;
1272 UInt32 PointerToRawData;
1273 UInt32 PointerToRelocations;
1274 UInt32 PointerToLinenumbers;
1275 UInt16 NumberOfRelocations;
1276 UInt16 NumberOfLineNumbers;
1277 UInt32 Characteristics;
1281 #define sizeof_COFF_section 40
1288 UInt16 SectionNumber;
1291 UChar NumberOfAuxSymbols;
1295 #define sizeof_COFF_symbol 18
1300 UInt32 VirtualAddress;
1301 UInt32 SymbolTableIndex;
1306 #define sizeof_COFF_reloc 10
1309 /* From PE spec doc, section 3.3.2 */
1310 /* Note use of MYIMAGE_* since IMAGE_* are already defined in
1311 windows.h -- for the same purpose, but I want to know what I'm
1313 #define MYIMAGE_FILE_RELOCS_STRIPPED 0x0001
1314 #define MYIMAGE_FILE_EXECUTABLE_IMAGE 0x0002
1315 #define MYIMAGE_FILE_DLL 0x2000
1316 #define MYIMAGE_FILE_SYSTEM 0x1000
1317 #define MYIMAGE_FILE_BYTES_REVERSED_HI 0x8000
1318 #define MYIMAGE_FILE_BYTES_REVERSED_LO 0x0080
1319 #define MYIMAGE_FILE_32BIT_MACHINE 0x0100
1321 /* From PE spec doc, section 5.4.2 and 5.4.4 */
1322 #define MYIMAGE_SYM_CLASS_EXTERNAL 2
1323 #define MYIMAGE_SYM_CLASS_STATIC 3
1324 #define MYIMAGE_SYM_UNDEFINED 0
1326 /* From PE spec doc, section 4.1 */
1327 #define MYIMAGE_SCN_CNT_CODE 0x00000020
1328 #define MYIMAGE_SCN_CNT_INITIALIZED_DATA 0x00000040
1329 #define MYIMAGE_SCN_LNK_NRELOC_OVFL 0x01000000
1331 /* From PE spec doc, section 5.2.1 */
1332 #define MYIMAGE_REL_I386_DIR32 0x0006
1333 #define MYIMAGE_REL_I386_REL32 0x0014
1336 /* We use myindex to calculate array addresses, rather than
1337 simply doing the normal subscript thing. That's because
1338 some of the above structs have sizes which are not
1339 a whole number of words. GCC rounds their sizes up to a
1340 whole number of words, which means that the address calcs
1341 arising from using normal C indexing or pointer arithmetic
1342 are just plain wrong. Sigh.
1345 myindex ( int scale, void* base, int index )
1348 ((UChar*)base) + scale * index;
1353 printName ( UChar* name, UChar* strtab )
1355 if (name[0]==0 && name[1]==0 && name[2]==0 && name[3]==0) {
1356 UInt32 strtab_offset = * (UInt32*)(name+4);
1357 fprintf ( stderr, "%s", strtab + strtab_offset );
1360 for (i = 0; i < 8; i++) {
1361 if (name[i] == 0) break;
1362 fprintf ( stderr, "%c", name[i] );
1369 copyName ( UChar* name, UChar* strtab, UChar* dst, int dstSize )
1371 if (name[0]==0 && name[1]==0 && name[2]==0 && name[3]==0) {
1372 UInt32 strtab_offset = * (UInt32*)(name+4);
1373 strncpy ( dst, strtab+strtab_offset, dstSize );
1379 if (name[i] == 0) break;
1389 cstring_from_COFF_symbol_name ( UChar* name, UChar* strtab )
1392 /* If the string is longer than 8 bytes, look in the
1393 string table for it -- this will be correctly zero terminated.
1395 if (name[0]==0 && name[1]==0 && name[2]==0 && name[3]==0) {
1396 UInt32 strtab_offset = * (UInt32*)(name+4);
1397 return ((UChar*)strtab) + strtab_offset;
1399 /* Otherwise, if shorter than 8 bytes, return the original,
1400 which by defn is correctly terminated.
1402 if (name[7]==0) return name;
1403 /* The annoying case: 8 bytes. Copy into a temporary
1404 (which is never freed ...)
1406 newstr = stgMallocBytes(9, "cstring_from_COFF_symbol_name");
1408 strncpy(newstr,name,8);
1414 /* Just compares the short names (first 8 chars) */
1415 static COFF_section *
1416 findPEi386SectionCalled ( ObjectCode* oc, char* name )
1420 = (COFF_header*)(oc->image);
1421 COFF_section* sectab
1423 ((UChar*)(oc->image))
1424 + sizeof_COFF_header + hdr->SizeOfOptionalHeader
1426 for (i = 0; i < hdr->NumberOfSections; i++) {
1429 COFF_section* section_i
1431 myindex ( sizeof_COFF_section, sectab, i );
1432 n1 = (UChar*) &(section_i->Name);
1434 if (n1[0]==n2[0] && n1[1]==n2[1] && n1[2]==n2[2] &&
1435 n1[3]==n2[3] && n1[4]==n2[4] && n1[5]==n2[5] &&
1436 n1[6]==n2[6] && n1[7]==n2[7])
1445 zapTrailingAtSign ( UChar* sym )
1447 # define my_isdigit(c) ((c) >= '0' && (c) <= '9')
1449 if (sym[0] == 0) return;
1451 while (sym[i] != 0) i++;
1454 while (j > 0 && my_isdigit(sym[j])) j--;
1455 if (j > 0 && sym[j] == '@' && j != i) sym[j] = 0;
1461 ocVerifyImage_PEi386 ( ObjectCode* oc )
1466 COFF_section* sectab;
1467 COFF_symbol* symtab;
1469 /* fprintf(stderr, "\nLOADING %s\n", oc->fileName); */
1470 hdr = (COFF_header*)(oc->image);
1471 sectab = (COFF_section*) (
1472 ((UChar*)(oc->image))
1473 + sizeof_COFF_header + hdr->SizeOfOptionalHeader
1475 symtab = (COFF_symbol*) (
1476 ((UChar*)(oc->image))
1477 + hdr->PointerToSymbolTable
1479 strtab = ((UChar*)symtab)
1480 + hdr->NumberOfSymbols * sizeof_COFF_symbol;
1482 if (hdr->Machine != 0x14c) {
1483 belch("Not x86 PEi386");
1486 if (hdr->SizeOfOptionalHeader != 0) {
1487 belch("PEi386 with nonempty optional header");
1490 if ( /* (hdr->Characteristics & MYIMAGE_FILE_RELOCS_STRIPPED) || */
1491 (hdr->Characteristics & MYIMAGE_FILE_EXECUTABLE_IMAGE) ||
1492 (hdr->Characteristics & MYIMAGE_FILE_DLL) ||
1493 (hdr->Characteristics & MYIMAGE_FILE_SYSTEM) ) {
1494 belch("Not a PEi386 object file");
1497 if ( (hdr->Characteristics & MYIMAGE_FILE_BYTES_REVERSED_HI)
1498 /* || !(hdr->Characteristics & MYIMAGE_FILE_32BIT_MACHINE) */ ) {
1499 belch("Invalid PEi386 word size or endiannness: %d",
1500 (int)(hdr->Characteristics));
1503 /* If the string table size is way crazy, this might indicate that
1504 there are more than 64k relocations, despite claims to the
1505 contrary. Hence this test. */
1506 /* fprintf(stderr, "strtab size %d\n", * (UInt32*)strtab); */
1508 if ( (*(UInt32*)strtab) > 600000 ) {
1509 /* Note that 600k has no special significance other than being
1510 big enough to handle the almost-2MB-sized lumps that
1511 constitute HSwin32*.o. */
1512 belch("PEi386 object has suspiciously large string table; > 64k relocs?");
1517 /* No further verification after this point; only debug printing. */
1519 IF_DEBUG(linker, i=1);
1520 if (i == 0) return 1;
1523 "sectab offset = %d\n", ((UChar*)sectab) - ((UChar*)hdr) );
1525 "symtab offset = %d\n", ((UChar*)symtab) - ((UChar*)hdr) );
1527 "strtab offset = %d\n", ((UChar*)strtab) - ((UChar*)hdr) );
1529 fprintf ( stderr, "\n" );
1531 "Machine: 0x%x\n", (UInt32)(hdr->Machine) );
1533 "# sections: %d\n", (UInt32)(hdr->NumberOfSections) );
1535 "time/date: 0x%x\n", (UInt32)(hdr->TimeDateStamp) );
1537 "symtab offset: %d\n", (UInt32)(hdr->PointerToSymbolTable) );
1539 "# symbols: %d\n", (UInt32)(hdr->NumberOfSymbols) );
1541 "sz of opt hdr: %d\n", (UInt32)(hdr->SizeOfOptionalHeader) );
1543 "characteristics: 0x%x\n", (UInt32)(hdr->Characteristics) );
1545 /* Print the section table. */
1546 fprintf ( stderr, "\n" );
1547 for (i = 0; i < hdr->NumberOfSections; i++) {
1549 COFF_section* sectab_i
1551 myindex ( sizeof_COFF_section, sectab, i );
1558 printName ( sectab_i->Name, strtab );
1568 sectab_i->VirtualSize,
1569 sectab_i->VirtualAddress,
1570 sectab_i->SizeOfRawData,
1571 sectab_i->PointerToRawData,
1572 sectab_i->NumberOfRelocations,
1573 sectab_i->PointerToRelocations,
1574 sectab_i->PointerToRawData
1576 reltab = (COFF_reloc*) (
1577 ((UChar*)(oc->image)) + sectab_i->PointerToRelocations
1580 if ( sectab_i->Characteristics & MYIMAGE_SCN_LNK_NRELOC_OVFL ) {
1581 /* If the relocation field (a short) has overflowed, the
1582 * real count can be found in the first reloc entry.
1584 * See Section 4.1 (last para) of the PE spec (rev6.0).
1586 COFF_reloc* rel = (COFF_reloc*)
1587 myindex ( sizeof_COFF_reloc, reltab, 0 );
1588 noRelocs = rel->VirtualAddress;
1591 noRelocs = sectab_i->NumberOfRelocations;
1595 for (; j < noRelocs; j++) {
1597 COFF_reloc* rel = (COFF_reloc*)
1598 myindex ( sizeof_COFF_reloc, reltab, j );
1600 " type 0x%-4x vaddr 0x%-8x name `",
1602 rel->VirtualAddress );
1603 sym = (COFF_symbol*)
1604 myindex ( sizeof_COFF_symbol, symtab, rel->SymbolTableIndex );
1605 /* Hmm..mysterious looking offset - what's it for? SOF */
1606 printName ( sym->Name, strtab -10 );
1607 fprintf ( stderr, "'\n" );
1610 fprintf ( stderr, "\n" );
1612 fprintf ( stderr, "\n" );
1613 fprintf ( stderr, "string table has size 0x%x\n", * (UInt32*)strtab );
1614 fprintf ( stderr, "---START of string table---\n");
1615 for (i = 4; i < *(Int32*)strtab; i++) {
1617 fprintf ( stderr, "\n"); else
1618 fprintf( stderr, "%c", strtab[i] );
1620 fprintf ( stderr, "--- END of string table---\n");
1622 fprintf ( stderr, "\n" );
1625 COFF_symbol* symtab_i;
1626 if (i >= (Int32)(hdr->NumberOfSymbols)) break;
1627 symtab_i = (COFF_symbol*)
1628 myindex ( sizeof_COFF_symbol, symtab, i );
1634 printName ( symtab_i->Name, strtab );
1643 (Int32)(symtab_i->SectionNumber),
1644 (UInt32)symtab_i->Type,
1645 (UInt32)symtab_i->StorageClass,
1646 (UInt32)symtab_i->NumberOfAuxSymbols
1648 i += symtab_i->NumberOfAuxSymbols;
1652 fprintf ( stderr, "\n" );
1658 ocGetNames_PEi386 ( ObjectCode* oc )
1661 COFF_section* sectab;
1662 COFF_symbol* symtab;
1669 hdr = (COFF_header*)(oc->image);
1670 sectab = (COFF_section*) (
1671 ((UChar*)(oc->image))
1672 + sizeof_COFF_header + hdr->SizeOfOptionalHeader
1674 symtab = (COFF_symbol*) (
1675 ((UChar*)(oc->image))
1676 + hdr->PointerToSymbolTable
1678 strtab = ((UChar*)(oc->image))
1679 + hdr->PointerToSymbolTable
1680 + hdr->NumberOfSymbols * sizeof_COFF_symbol;
1682 /* Allocate space for any (local, anonymous) .bss sections. */
1684 for (i = 0; i < hdr->NumberOfSections; i++) {
1686 COFF_section* sectab_i
1688 myindex ( sizeof_COFF_section, sectab, i );
1689 if (0 != strcmp(sectab_i->Name, ".bss")) continue;
1690 if (sectab_i->VirtualSize == 0) continue;
1691 /* This is a non-empty .bss section. Allocate zeroed space for
1692 it, and set its PointerToRawData field such that oc->image +
1693 PointerToRawData == addr_of_zeroed_space. */
1694 zspace = stgCallocBytes(1, sectab_i->VirtualSize,
1695 "ocGetNames_PEi386(anonymous bss)");
1696 sectab_i->PointerToRawData = ((UChar*)zspace) - ((UChar*)(oc->image));
1697 addProddableBlock(oc, zspace, sectab_i->VirtualSize);
1698 /* fprintf(stderr, "BSS anon section at 0x%x\n", zspace); */
1701 /* Copy section information into the ObjectCode. */
1703 for (i = 0; i < hdr->NumberOfSections; i++) {
1709 = SECTIONKIND_OTHER;
1710 COFF_section* sectab_i
1712 myindex ( sizeof_COFF_section, sectab, i );
1713 IF_DEBUG(linker, belch("section name = %s\n", sectab_i->Name ));
1716 /* I'm sure this is the Right Way to do it. However, the
1717 alternative of testing the sectab_i->Name field seems to
1718 work ok with Cygwin.
1720 if (sectab_i->Characteristics & MYIMAGE_SCN_CNT_CODE ||
1721 sectab_i->Characteristics & MYIMAGE_SCN_CNT_INITIALIZED_DATA)
1722 kind = SECTIONKIND_CODE_OR_RODATA;
1725 if (0==strcmp(".text",sectab_i->Name) ||
1726 0==strcmp(".rodata",sectab_i->Name))
1727 kind = SECTIONKIND_CODE_OR_RODATA;
1728 if (0==strcmp(".data",sectab_i->Name) ||
1729 0==strcmp(".bss",sectab_i->Name))
1730 kind = SECTIONKIND_RWDATA;
1732 ASSERT(sectab_i->SizeOfRawData == 0 || sectab_i->VirtualSize == 0);
1733 sz = sectab_i->SizeOfRawData;
1734 if (sz < sectab_i->VirtualSize) sz = sectab_i->VirtualSize;
1736 start = ((UChar*)(oc->image)) + sectab_i->PointerToRawData;
1737 end = start + sz - 1;
1739 if (kind == SECTIONKIND_OTHER
1740 /* Ignore sections called which contain stabs debugging
1742 && 0 != strcmp(".stab", sectab_i->Name)
1743 && 0 != strcmp(".stabstr", sectab_i->Name)
1745 belch("Unknown PEi386 section name `%s'", sectab_i->Name);
1749 if (kind != SECTIONKIND_OTHER && end >= start) {
1750 addSection(oc, kind, start, end);
1751 addProddableBlock(oc, start, end - start + 1);
1755 /* Copy exported symbols into the ObjectCode. */
1757 oc->n_symbols = hdr->NumberOfSymbols;
1758 oc->symbols = stgMallocBytes(oc->n_symbols * sizeof(char*),
1759 "ocGetNames_PEi386(oc->symbols)");
1760 /* Call me paranoid; I don't care. */
1761 for (i = 0; i < oc->n_symbols; i++)
1762 oc->symbols[i] = NULL;
1766 COFF_symbol* symtab_i;
1767 if (i >= (Int32)(hdr->NumberOfSymbols)) break;
1768 symtab_i = (COFF_symbol*)
1769 myindex ( sizeof_COFF_symbol, symtab, i );
1773 if (symtab_i->StorageClass == MYIMAGE_SYM_CLASS_EXTERNAL
1774 && symtab_i->SectionNumber != MYIMAGE_SYM_UNDEFINED) {
1775 /* This symbol is global and defined, viz, exported */
1776 /* for MYIMAGE_SYMCLASS_EXTERNAL
1777 && !MYIMAGE_SYM_UNDEFINED,
1778 the address of the symbol is:
1779 address of relevant section + offset in section
1781 COFF_section* sectabent
1782 = (COFF_section*) myindex ( sizeof_COFF_section,
1784 symtab_i->SectionNumber-1 );
1785 addr = ((UChar*)(oc->image))
1786 + (sectabent->PointerToRawData
1790 if (symtab_i->SectionNumber == MYIMAGE_SYM_UNDEFINED
1791 && symtab_i->Value > 0) {
1792 /* This symbol isn't in any section at all, ie, global bss.
1793 Allocate zeroed space for it. */
1794 addr = stgCallocBytes(1, symtab_i->Value,
1795 "ocGetNames_PEi386(non-anonymous bss)");
1796 addSection(oc, SECTIONKIND_RWDATA, addr,
1797 ((UChar*)addr) + symtab_i->Value - 1);
1798 addProddableBlock(oc, addr, symtab_i->Value);
1799 /* fprintf(stderr, "BSS section at 0x%x\n", addr); */
1802 if (addr != NULL ) {
1803 sname = cstring_from_COFF_symbol_name ( symtab_i->Name, strtab );
1804 /* fprintf(stderr,"addSymbol %p `%s \n", addr,sname); */
1805 IF_DEBUG(linker, belch("addSymbol %p `%s'\n", addr,sname);)
1806 ASSERT(i >= 0 && i < oc->n_symbols);
1807 /* cstring_from_COFF_symbol_name always succeeds. */
1808 oc->symbols[i] = sname;
1809 ghciInsertStrHashTable(oc->fileName, symhash, sname, addr);
1813 "IGNORING symbol %d\n"
1817 printName ( symtab_i->Name, strtab );
1826 (Int32)(symtab_i->SectionNumber),
1827 (UInt32)symtab_i->Type,
1828 (UInt32)symtab_i->StorageClass,
1829 (UInt32)symtab_i->NumberOfAuxSymbols
1834 i += symtab_i->NumberOfAuxSymbols;
1843 ocResolve_PEi386 ( ObjectCode* oc )
1846 COFF_section* sectab;
1847 COFF_symbol* symtab;
1857 /* ToDo: should be variable-sized? But is at least safe in the
1858 sense of buffer-overrun-proof. */
1860 /* fprintf(stderr, "resolving for %s\n", oc->fileName); */
1862 hdr = (COFF_header*)(oc->image);
1863 sectab = (COFF_section*) (
1864 ((UChar*)(oc->image))
1865 + sizeof_COFF_header + hdr->SizeOfOptionalHeader
1867 symtab = (COFF_symbol*) (
1868 ((UChar*)(oc->image))
1869 + hdr->PointerToSymbolTable
1871 strtab = ((UChar*)(oc->image))
1872 + hdr->PointerToSymbolTable
1873 + hdr->NumberOfSymbols * sizeof_COFF_symbol;
1875 for (i = 0; i < hdr->NumberOfSections; i++) {
1876 COFF_section* sectab_i
1878 myindex ( sizeof_COFF_section, sectab, i );
1881 ((UChar*)(oc->image)) + sectab_i->PointerToRelocations
1884 /* Ignore sections called which contain stabs debugging
1886 if (0 == strcmp(".stab", sectab_i->Name)
1887 || 0 == strcmp(".stabstr", sectab_i->Name))
1890 if ( sectab_i->Characteristics & MYIMAGE_SCN_LNK_NRELOC_OVFL ) {
1891 /* If the relocation field (a short) has overflowed, the
1892 * real count can be found in the first reloc entry.
1894 * See Section 4.1 (last para) of the PE spec (rev6.0).
1896 COFF_reloc* rel = (COFF_reloc*)
1897 myindex ( sizeof_COFF_reloc, reltab, 0 );
1898 noRelocs = rel->VirtualAddress;
1899 fprintf(stderr, "Overflown relocs: %u\n", noRelocs);
1902 noRelocs = sectab_i->NumberOfRelocations;
1907 for (; j < noRelocs; j++) {
1909 COFF_reloc* reltab_j
1911 myindex ( sizeof_COFF_reloc, reltab, j );
1913 /* the location to patch */
1915 ((UChar*)(oc->image))
1916 + (sectab_i->PointerToRawData
1917 + reltab_j->VirtualAddress
1918 - sectab_i->VirtualAddress )
1920 /* the existing contents of pP */
1922 /* the symbol to connect to */
1923 sym = (COFF_symbol*)
1924 myindex ( sizeof_COFF_symbol,
1925 symtab, reltab_j->SymbolTableIndex );
1928 "reloc sec %2d num %3d: type 0x%-4x "
1929 "vaddr 0x%-8x name `",
1931 (UInt32)reltab_j->Type,
1932 reltab_j->VirtualAddress );
1933 printName ( sym->Name, strtab );
1934 fprintf ( stderr, "'\n" ));
1936 if (sym->StorageClass == MYIMAGE_SYM_CLASS_STATIC) {
1937 COFF_section* section_sym
1938 = findPEi386SectionCalled ( oc, sym->Name );
1940 belch("%s: can't find section `%s'", oc->fileName, sym->Name);
1943 S = ((UInt32)(oc->image))
1944 + (section_sym->PointerToRawData
1947 copyName ( sym->Name, strtab, symbol, 1000-1 );
1948 (void*)S = lookupLocalSymbol( oc, symbol );
1949 if ((void*)S != NULL) goto foundit;
1950 (void*)S = lookupSymbol( symbol );
1951 if ((void*)S != NULL) goto foundit;
1952 zapTrailingAtSign ( symbol );
1953 (void*)S = lookupLocalSymbol( oc, symbol );
1954 if ((void*)S != NULL) goto foundit;
1955 (void*)S = lookupSymbol( symbol );
1956 if ((void*)S != NULL) goto foundit;
1957 /* Newline first because the interactive linker has printed "linking..." */
1958 belch("\n%s: unknown symbol `%s'", oc->fileName, symbol);
1962 checkProddableBlock(oc, pP);
1963 switch (reltab_j->Type) {
1964 case MYIMAGE_REL_I386_DIR32:
1967 case MYIMAGE_REL_I386_REL32:
1968 /* Tricky. We have to insert a displacement at
1969 pP which, when added to the PC for the _next_
1970 insn, gives the address of the target (S).
1971 Problem is to know the address of the next insn
1972 when we only know pP. We assume that this
1973 literal field is always the last in the insn,
1974 so that the address of the next insn is pP+4
1975 -- hence the constant 4.
1976 Also I don't know if A should be added, but so
1977 far it has always been zero.
1980 *pP = S - ((UInt32)pP) - 4;
1983 belch("%s: unhandled PEi386 relocation type %d",
1984 oc->fileName, reltab_j->Type);
1991 IF_DEBUG(linker, belch("completed %s", oc->fileName));
1995 #endif /* defined(OBJFORMAT_PEi386) */
1998 /* --------------------------------------------------------------------------
2000 * ------------------------------------------------------------------------*/
2002 #if defined(OBJFORMAT_ELF)
2007 #if defined(sparc_TARGET_ARCH)
2008 # define ELF_TARGET_SPARC /* Used inside <elf.h> */
2009 #elif defined(i386_TARGET_ARCH)
2010 # define ELF_TARGET_386 /* Used inside <elf.h> */
2011 #elif defined (ia64_TARGET_ARCH)
2012 # define ELF_TARGET_IA64 /* Used inside <elf.h> */
2014 # define ELF_FUNCTION_DESC /* calling convention uses function descriptors */
2015 # define ELF_NEED_GOT /* needs Global Offset Table */
2016 # define ELF_NEED_PLT /* needs Procedure Linkage Tables */
2019 #if !defined(openbsd_TARGET_OS)
2022 /* openbsd elf has things in different places, with diff names */
2023 #include <elf_abi.h>
2024 #include <machine/reloc.h>
2025 #define R_386_32 RELOC_32
2026 #define R_386_PC32 RELOC_PC32
2030 * Define a set of types which can be used for both ELF32 and ELF64
2034 #define ELFCLASS ELFCLASS64
2035 #define Elf_Addr Elf64_Addr
2036 #define Elf_Word Elf64_Word
2037 #define Elf_Sword Elf64_Sword
2038 #define Elf_Ehdr Elf64_Ehdr
2039 #define Elf_Phdr Elf64_Phdr
2040 #define Elf_Shdr Elf64_Shdr
2041 #define Elf_Sym Elf64_Sym
2042 #define Elf_Rel Elf64_Rel
2043 #define Elf_Rela Elf64_Rela
2044 #define ELF_ST_TYPE ELF64_ST_TYPE
2045 #define ELF_ST_BIND ELF64_ST_BIND
2046 #define ELF_R_TYPE ELF64_R_TYPE
2047 #define ELF_R_SYM ELF64_R_SYM
2049 #define ELFCLASS ELFCLASS32
2050 #define Elf_Addr Elf32_Addr
2051 #define Elf_Word Elf32_Word
2052 #define Elf_Sword Elf32_Sword
2053 #define Elf_Ehdr Elf32_Ehdr
2054 #define Elf_Phdr Elf32_Phdr
2055 #define Elf_Shdr Elf32_Shdr
2056 #define Elf_Sym Elf32_Sym
2057 #define Elf_Rel Elf32_Rel
2058 #define Elf_Rela Elf32_Rela
2060 #define ELF_ST_TYPE ELF32_ST_TYPE
2063 #define ELF_ST_BIND ELF32_ST_BIND
2066 #define ELF_R_TYPE ELF32_R_TYPE
2069 #define ELF_R_SYM ELF32_R_SYM
2075 * Functions to allocate entries in dynamic sections. Currently we simply
2076 * preallocate a large number, and we don't check if a entry for the given
2077 * target already exists (a linear search is too slow). Ideally these
2078 * entries would be associated with symbols.
2081 /* These sizes sufficient to load HSbase + HShaskell98 + a few modules */
2082 #define GOT_SIZE 0x20000
2083 #define FUNCTION_TABLE_SIZE 0x10000
2084 #define PLT_SIZE 0x08000
2087 static Elf_Addr got[GOT_SIZE];
2088 static unsigned int gotIndex;
2089 static Elf_Addr gp_val = (Elf_Addr)got;
2092 allocateGOTEntry(Elf_Addr target)
2096 if (gotIndex >= GOT_SIZE)
2097 barf("Global offset table overflow");
2099 entry = &got[gotIndex++];
2101 return (Elf_Addr)entry;
2105 #ifdef ELF_FUNCTION_DESC
2111 static FunctionDesc functionTable[FUNCTION_TABLE_SIZE];
2112 static unsigned int functionTableIndex;
2115 allocateFunctionDesc(Elf_Addr target)
2117 FunctionDesc *entry;
2119 if (functionTableIndex >= FUNCTION_TABLE_SIZE)
2120 barf("Function table overflow");
2122 entry = &functionTable[functionTableIndex++];
2124 entry->gp = (Elf_Addr)gp_val;
2125 return (Elf_Addr)entry;
2129 copyFunctionDesc(Elf_Addr target)
2131 FunctionDesc *olddesc = (FunctionDesc *)target;
2132 FunctionDesc *newdesc;
2134 newdesc = (FunctionDesc *)allocateFunctionDesc(olddesc->ip);
2135 newdesc->gp = olddesc->gp;
2136 return (Elf_Addr)newdesc;
2141 #ifdef ia64_TARGET_ARCH
2142 static void ia64_reloc_gprel22(Elf_Addr target, Elf_Addr value);
2143 static void ia64_reloc_pcrel21(Elf_Addr target, Elf_Addr value, ObjectCode *oc);
2145 static unsigned char plt_code[] =
2147 /* taken from binutils bfd/elfxx-ia64.c */
2148 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
2149 0x00, 0x41, 0x3c, 0x30, 0x28, 0xc0, /* ld8 r16=[r15],8 */
2150 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
2151 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
2152 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
2153 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
2156 /* If we can't get to the function descriptor via gp, take a local copy of it */
2157 #define PLT_RELOC(code, target) { \
2158 Elf64_Sxword rel_value = target - gp_val; \
2159 if ((rel_value > 0x1fffff) || (rel_value < -0x1fffff)) \
2160 ia64_reloc_gprel22((Elf_Addr)code, copyFunctionDesc(target)); \
2162 ia64_reloc_gprel22((Elf_Addr)code, target); \
2167 unsigned char code[sizeof(plt_code)];
2171 allocatePLTEntry(Elf_Addr target, ObjectCode *oc)
2173 PLTEntry *plt = (PLTEntry *)oc->plt;
2176 if (oc->pltIndex >= PLT_SIZE)
2177 barf("Procedure table overflow");
2179 entry = &plt[oc->pltIndex++];
2180 memcpy(entry->code, plt_code, sizeof(entry->code));
2181 PLT_RELOC(entry->code, target);
2182 return (Elf_Addr)entry;
2188 return (PLT_SIZE * sizeof(PLTEntry));
2194 * Generic ELF functions
2198 findElfSection ( void* objImage, Elf_Word sh_type )
2200 char* ehdrC = (char*)objImage;
2201 Elf_Ehdr* ehdr = (Elf_Ehdr*)ehdrC;
2202 Elf_Shdr* shdr = (Elf_Shdr*)(ehdrC + ehdr->e_shoff);
2203 char* sh_strtab = ehdrC + shdr[ehdr->e_shstrndx].sh_offset;
2207 for (i = 0; i < ehdr->e_shnum; i++) {
2208 if (shdr[i].sh_type == sh_type
2209 /* Ignore the section header's string table. */
2210 && i != ehdr->e_shstrndx
2211 /* Ignore string tables named .stabstr, as they contain
2213 && 0 != memcmp(".stabstr", sh_strtab + shdr[i].sh_name, 8)
2215 ptr = ehdrC + shdr[i].sh_offset;
2222 #if defined(ia64_TARGET_ARCH)
2224 findElfSegment ( void* objImage, Elf_Addr vaddr )
2226 char* ehdrC = (char*)objImage;
2227 Elf_Ehdr* ehdr = (Elf_Ehdr*)ehdrC;
2228 Elf_Phdr* phdr = (Elf_Phdr*)(ehdrC + ehdr->e_phoff);
2229 Elf_Addr segaddr = 0;
2232 for (i = 0; i < ehdr->e_phnum; i++) {
2233 segaddr = phdr[i].p_vaddr;
2234 if ((vaddr >= segaddr) && (vaddr < segaddr + phdr[i].p_memsz))
2242 ocVerifyImage_ELF ( ObjectCode* oc )
2246 int i, j, nent, nstrtab, nsymtabs;
2250 char* ehdrC = (char*)(oc->image);
2251 Elf_Ehdr* ehdr = (Elf_Ehdr*)ehdrC;
2253 if (ehdr->e_ident[EI_MAG0] != ELFMAG0 ||
2254 ehdr->e_ident[EI_MAG1] != ELFMAG1 ||
2255 ehdr->e_ident[EI_MAG2] != ELFMAG2 ||
2256 ehdr->e_ident[EI_MAG3] != ELFMAG3) {
2257 belch("%s: not an ELF object", oc->fileName);
2261 if (ehdr->e_ident[EI_CLASS] != ELFCLASS) {
2262 belch("%s: unsupported ELF format", oc->fileName);
2266 if (ehdr->e_ident[EI_DATA] == ELFDATA2LSB) {
2267 IF_DEBUG(linker,belch( "Is little-endian" ));
2269 if (ehdr->e_ident[EI_DATA] == ELFDATA2MSB) {
2270 IF_DEBUG(linker,belch( "Is big-endian" ));
2272 belch("%s: unknown endiannness", oc->fileName);
2276 if (ehdr->e_type != ET_REL) {
2277 belch("%s: not a relocatable object (.o) file", oc->fileName);
2280 IF_DEBUG(linker, belch( "Is a relocatable object (.o) file" ));
2282 IF_DEBUG(linker,belch( "Architecture is " ));
2283 switch (ehdr->e_machine) {
2284 case EM_386: IF_DEBUG(linker,belch( "x86" )); break;
2285 case EM_SPARC: IF_DEBUG(linker,belch( "sparc" )); break;
2287 case EM_IA_64: IF_DEBUG(linker,belch( "ia64" )); break;
2289 default: IF_DEBUG(linker,belch( "unknown" ));
2290 belch("%s: unknown architecture", oc->fileName);
2294 IF_DEBUG(linker,belch(
2295 "\nSection header table: start %d, n_entries %d, ent_size %d",
2296 ehdr->e_shoff, ehdr->e_shnum, ehdr->e_shentsize ));
2298 ASSERT (ehdr->e_shentsize == sizeof(Elf_Shdr));
2300 shdr = (Elf_Shdr*) (ehdrC + ehdr->e_shoff);
2302 if (ehdr->e_shstrndx == SHN_UNDEF) {
2303 belch("%s: no section header string table", oc->fileName);
2306 IF_DEBUG(linker,belch( "Section header string table is section %d",
2308 sh_strtab = ehdrC + shdr[ehdr->e_shstrndx].sh_offset;
2311 for (i = 0; i < ehdr->e_shnum; i++) {
2312 IF_DEBUG(linker,fprintf(stderr, "%2d: ", i ));
2313 IF_DEBUG(linker,fprintf(stderr, "type=%2d ", (int)shdr[i].sh_type ));
2314 IF_DEBUG(linker,fprintf(stderr, "size=%4d ", (int)shdr[i].sh_size ));
2315 IF_DEBUG(linker,fprintf(stderr, "offs=%4d ", (int)shdr[i].sh_offset ));
2316 IF_DEBUG(linker,fprintf(stderr, " (%p .. %p) ",
2317 ehdrC + shdr[i].sh_offset,
2318 ehdrC + shdr[i].sh_offset + shdr[i].sh_size - 1));
2320 if (shdr[i].sh_type == SHT_REL) {
2321 IF_DEBUG(linker,fprintf(stderr, "Rel " ));
2322 } else if (shdr[i].sh_type == SHT_RELA) {
2323 IF_DEBUG(linker,fprintf(stderr, "RelA " ));
2325 IF_DEBUG(linker,fprintf(stderr," "));
2328 IF_DEBUG(linker,fprintf(stderr, "sname=%s\n", sh_strtab + shdr[i].sh_name ));
2332 IF_DEBUG(linker,belch( "\nString tables" ));
2335 for (i = 0; i < ehdr->e_shnum; i++) {
2336 if (shdr[i].sh_type == SHT_STRTAB
2337 /* Ignore the section header's string table. */
2338 && i != ehdr->e_shstrndx
2339 /* Ignore string tables named .stabstr, as they contain
2341 && 0 != memcmp(".stabstr", sh_strtab + shdr[i].sh_name, 8)
2343 IF_DEBUG(linker,belch(" section %d is a normal string table", i ));
2344 strtab = ehdrC + shdr[i].sh_offset;
2349 belch("%s: no string tables, or too many", oc->fileName);
2354 IF_DEBUG(linker,belch( "\nSymbol tables" ));
2355 for (i = 0; i < ehdr->e_shnum; i++) {
2356 if (shdr[i].sh_type != SHT_SYMTAB) continue;
2357 IF_DEBUG(linker,belch( "section %d is a symbol table", i ));
2359 stab = (Elf_Sym*) (ehdrC + shdr[i].sh_offset);
2360 nent = shdr[i].sh_size / sizeof(Elf_Sym);
2361 IF_DEBUG(linker,belch( " number of entries is apparently %d (%d rem)",
2363 shdr[i].sh_size % sizeof(Elf_Sym)
2365 if (0 != shdr[i].sh_size % sizeof(Elf_Sym)) {
2366 belch("%s: non-integral number of symbol table entries", oc->fileName);
2369 for (j = 0; j < nent; j++) {
2370 IF_DEBUG(linker,fprintf(stderr, " %2d ", j ));
2371 IF_DEBUG(linker,fprintf(stderr, " sec=%-5d size=%-3d val=%5p ",
2372 (int)stab[j].st_shndx,
2373 (int)stab[j].st_size,
2374 (char*)stab[j].st_value ));
2376 IF_DEBUG(linker,fprintf(stderr, "type=" ));
2377 switch (ELF_ST_TYPE(stab[j].st_info)) {
2378 case STT_NOTYPE: IF_DEBUG(linker,fprintf(stderr, "notype " )); break;
2379 case STT_OBJECT: IF_DEBUG(linker,fprintf(stderr, "object " )); break;
2380 case STT_FUNC : IF_DEBUG(linker,fprintf(stderr, "func " )); break;
2381 case STT_SECTION: IF_DEBUG(linker,fprintf(stderr, "section" )); break;
2382 case STT_FILE: IF_DEBUG(linker,fprintf(stderr, "file " )); break;
2383 default: IF_DEBUG(linker,fprintf(stderr, "? " )); break;
2385 IF_DEBUG(linker,fprintf(stderr, " " ));
2387 IF_DEBUG(linker,fprintf(stderr, "bind=" ));
2388 switch (ELF_ST_BIND(stab[j].st_info)) {
2389 case STB_LOCAL : IF_DEBUG(linker,fprintf(stderr, "local " )); break;
2390 case STB_GLOBAL: IF_DEBUG(linker,fprintf(stderr, "global" )); break;
2391 case STB_WEAK : IF_DEBUG(linker,fprintf(stderr, "weak " )); break;
2392 default: IF_DEBUG(linker,fprintf(stderr, "? " )); break;
2394 IF_DEBUG(linker,fprintf(stderr, " " ));
2396 IF_DEBUG(linker,fprintf(stderr, "name=%s\n", strtab + stab[j].st_name ));
2400 if (nsymtabs == 0) {
2401 belch("%s: didn't find any symbol tables", oc->fileName);
2410 ocGetNames_ELF ( ObjectCode* oc )
2415 char* ehdrC = (char*)(oc->image);
2416 Elf_Ehdr* ehdr = (Elf_Ehdr*)ehdrC;
2417 char* strtab = findElfSection ( ehdrC, SHT_STRTAB );
2418 Elf_Shdr* shdr = (Elf_Shdr*) (ehdrC + ehdr->e_shoff);
2420 ASSERT(symhash != NULL);
2423 belch("%s: no strtab", oc->fileName);
2428 for (i = 0; i < ehdr->e_shnum; i++) {
2429 /* Figure out what kind of section it is. Logic derived from
2430 Figure 1.14 ("Special Sections") of the ELF document
2431 ("Portable Formats Specification, Version 1.1"). */
2432 Elf_Shdr hdr = shdr[i];
2433 SectionKind kind = SECTIONKIND_OTHER;
2436 if (hdr.sh_type == SHT_PROGBITS
2437 && (hdr.sh_flags & SHF_ALLOC) && (hdr.sh_flags & SHF_EXECINSTR)) {
2438 /* .text-style section */
2439 kind = SECTIONKIND_CODE_OR_RODATA;
2442 if (hdr.sh_type == SHT_PROGBITS
2443 && (hdr.sh_flags & SHF_ALLOC) && (hdr.sh_flags & SHF_WRITE)) {
2444 /* .data-style section */
2445 kind = SECTIONKIND_RWDATA;
2448 if (hdr.sh_type == SHT_PROGBITS
2449 && (hdr.sh_flags & SHF_ALLOC) && !(hdr.sh_flags & SHF_WRITE)) {
2450 /* .rodata-style section */
2451 kind = SECTIONKIND_CODE_OR_RODATA;
2454 if (hdr.sh_type == SHT_NOBITS
2455 && (hdr.sh_flags & SHF_ALLOC) && (hdr.sh_flags & SHF_WRITE)) {
2456 /* .bss-style section */
2457 kind = SECTIONKIND_RWDATA;
2461 if (is_bss && shdr[i].sh_size > 0) {
2462 /* This is a non-empty .bss section. Allocate zeroed space for
2463 it, and set its .sh_offset field such that
2464 ehdrC + .sh_offset == addr_of_zeroed_space. */
2465 char* zspace = stgCallocBytes(1, shdr[i].sh_size,
2466 "ocGetNames_ELF(BSS)");
2467 shdr[i].sh_offset = ((char*)zspace) - ((char*)ehdrC);
2469 fprintf(stderr, "BSS section at 0x%x, size %d\n",
2470 zspace, shdr[i].sh_size);
2474 /* fill in the section info */
2475 if (kind != SECTIONKIND_OTHER && shdr[i].sh_size > 0) {
2476 addProddableBlock(oc, ehdrC + shdr[i].sh_offset, shdr[i].sh_size);
2477 addSection(oc, kind, ehdrC + shdr[i].sh_offset,
2478 ehdrC + shdr[i].sh_offset + shdr[i].sh_size - 1);
2481 if (shdr[i].sh_type != SHT_SYMTAB) continue;
2483 /* copy stuff into this module's object symbol table */
2484 stab = (Elf_Sym*) (ehdrC + shdr[i].sh_offset);
2485 nent = shdr[i].sh_size / sizeof(Elf_Sym);
2487 oc->n_symbols = nent;
2488 oc->symbols = stgMallocBytes(oc->n_symbols * sizeof(char*),
2489 "ocGetNames_ELF(oc->symbols)");
2491 for (j = 0; j < nent; j++) {
2493 char isLocal = FALSE; /* avoids uninit-var warning */
2495 char* nm = strtab + stab[j].st_name;
2496 int secno = stab[j].st_shndx;
2498 /* Figure out if we want to add it; if so, set ad to its
2499 address. Otherwise leave ad == NULL. */
2501 if (secno == SHN_COMMON) {
2503 ad = stgCallocBytes(1, stab[j].st_size, "ocGetNames_ELF(COMMON)");
2505 fprintf(stderr, "COMMON symbol, size %d name %s\n",
2506 stab[j].st_size, nm);
2508 /* Pointless to do addProddableBlock() for this area,
2509 since the linker should never poke around in it. */
2512 if ( ( ELF_ST_BIND(stab[j].st_info)==STB_GLOBAL
2513 || ELF_ST_BIND(stab[j].st_info)==STB_LOCAL
2515 /* and not an undefined symbol */
2516 && stab[j].st_shndx != SHN_UNDEF
2517 /* and not in a "special section" */
2518 && stab[j].st_shndx < SHN_LORESERVE
2520 /* and it's a not a section or string table or anything silly */
2521 ( ELF_ST_TYPE(stab[j].st_info)==STT_FUNC ||
2522 ELF_ST_TYPE(stab[j].st_info)==STT_OBJECT ||
2523 ELF_ST_TYPE(stab[j].st_info)==STT_NOTYPE
2526 /* Section 0 is the undefined section, hence > and not >=. */
2527 ASSERT(secno > 0 && secno < ehdr->e_shnum);
2529 if (shdr[secno].sh_type == SHT_NOBITS) {
2530 fprintf(stderr, " BSS symbol, size %d off %d name %s\n",
2531 stab[j].st_size, stab[j].st_value, nm);
2534 ad = ehdrC + shdr[ secno ].sh_offset + stab[j].st_value;
2535 if (ELF_ST_BIND(stab[j].st_info)==STB_LOCAL) {
2538 #ifdef ELF_FUNCTION_DESC
2539 /* dlsym() and the initialisation table both give us function
2540 * descriptors, so to be consistent we store function descriptors
2541 * in the symbol table */
2542 if (ELF_ST_TYPE(stab[j].st_info) == STT_FUNC)
2543 ad = (char *)allocateFunctionDesc((Elf_Addr)ad);
2545 IF_DEBUG(linker,belch( "addOTabName(GLOB): %10p %s %s",
2546 ad, oc->fileName, nm ));
2551 /* And the decision is ... */
2555 oc->symbols[j] = nm;
2558 /* Ignore entirely. */
2560 ghciInsertStrHashTable(oc->fileName, symhash, nm, ad);
2564 IF_DEBUG(linker,belch( "skipping `%s'",
2565 strtab + stab[j].st_name ));
2568 "skipping bind = %d, type = %d, shndx = %d `%s'\n",
2569 (int)ELF_ST_BIND(stab[j].st_info),
2570 (int)ELF_ST_TYPE(stab[j].st_info),
2571 (int)stab[j].st_shndx,
2572 strtab + stab[j].st_name
2575 oc->symbols[j] = NULL;
2584 /* Do ELF relocations which lack an explicit addend. All x86-linux
2585 relocations appear to be of this form. */
2587 do_Elf_Rel_relocations ( ObjectCode* oc, char* ehdrC,
2588 Elf_Shdr* shdr, int shnum,
2589 Elf_Sym* stab, char* strtab )
2594 Elf_Rel* rtab = (Elf_Rel*) (ehdrC + shdr[shnum].sh_offset);
2595 int nent = shdr[shnum].sh_size / sizeof(Elf_Rel);
2596 int target_shndx = shdr[shnum].sh_info;
2597 int symtab_shndx = shdr[shnum].sh_link;
2599 stab = (Elf_Sym*) (ehdrC + shdr[ symtab_shndx ].sh_offset);
2600 targ = (Elf_Word*)(ehdrC + shdr[ target_shndx ].sh_offset);
2601 IF_DEBUG(linker,belch( "relocations for section %d using symtab %d",
2602 target_shndx, symtab_shndx ));
2604 for (j = 0; j < nent; j++) {
2605 Elf_Addr offset = rtab[j].r_offset;
2606 Elf_Addr info = rtab[j].r_info;
2608 Elf_Addr P = ((Elf_Addr)targ) + offset;
2609 Elf_Word* pP = (Elf_Word*)P;
2614 IF_DEBUG(linker,belch( "Rel entry %3d is raw(%6p %6p)",
2615 j, (void*)offset, (void*)info ));
2617 IF_DEBUG(linker,belch( " ZERO" ));
2620 Elf_Sym sym = stab[ELF_R_SYM(info)];
2621 /* First see if it is a local symbol. */
2622 if (ELF_ST_BIND(sym.st_info) == STB_LOCAL) {
2623 /* Yes, so we can get the address directly from the ELF symbol
2625 symbol = sym.st_name==0 ? "(noname)" : strtab+sym.st_name;
2627 (ehdrC + shdr[ sym.st_shndx ].sh_offset
2628 + stab[ELF_R_SYM(info)].st_value);
2631 /* No, so look up the name in our global table. */
2632 symbol = strtab + sym.st_name;
2633 (void*)S = lookupSymbol( symbol );
2636 belch("%s: unknown symbol `%s'", oc->fileName, symbol);
2639 IF_DEBUG(linker,belch( "`%s' resolves to %p", symbol, (void*)S ));
2642 IF_DEBUG(linker,belch( "Reloc: P = %p S = %p A = %p",
2643 (void*)P, (void*)S, (void*)A ));
2644 checkProddableBlock ( oc, pP );
2648 switch (ELF_R_TYPE(info)) {
2649 # ifdef i386_TARGET_ARCH
2650 case R_386_32: *pP = value; break;
2651 case R_386_PC32: *pP = value - P; break;
2654 belch("%s: unhandled ELF relocation(Rel) type %d\n",
2655 oc->fileName, ELF_R_TYPE(info));
2663 /* Do ELF relocations for which explicit addends are supplied.
2664 sparc-solaris relocations appear to be of this form. */
2666 do_Elf_Rela_relocations ( ObjectCode* oc, char* ehdrC,
2667 Elf_Shdr* shdr, int shnum,
2668 Elf_Sym* stab, char* strtab )
2673 Elf_Rela* rtab = (Elf_Rela*) (ehdrC + shdr[shnum].sh_offset);
2674 int nent = shdr[shnum].sh_size / sizeof(Elf_Rela);
2675 int target_shndx = shdr[shnum].sh_info;
2676 int symtab_shndx = shdr[shnum].sh_link;
2678 stab = (Elf_Sym*) (ehdrC + shdr[ symtab_shndx ].sh_offset);
2679 targ = (Elf_Addr) (ehdrC + shdr[ target_shndx ].sh_offset);
2680 IF_DEBUG(linker,belch( "relocations for section %d using symtab %d",
2681 target_shndx, symtab_shndx ));
2683 for (j = 0; j < nent; j++) {
2684 #if defined(DEBUG) || defined(sparc_TARGET_ARCH) || defined(ia64_TARGET_ARCH)
2685 /* This #ifdef only serves to avoid unused-var warnings. */
2686 Elf_Addr offset = rtab[j].r_offset;
2687 Elf_Addr P = targ + offset;
2689 Elf_Addr info = rtab[j].r_info;
2690 Elf_Addr A = rtab[j].r_addend;
2693 # if defined(sparc_TARGET_ARCH)
2694 Elf_Word* pP = (Elf_Word*)P;
2696 # elif defined(ia64_TARGET_ARCH)
2697 Elf64_Xword *pP = (Elf64_Xword *)P;
2701 IF_DEBUG(linker,belch( "Rel entry %3d is raw(%6p %6p %6p) ",
2702 j, (void*)offset, (void*)info,
2705 IF_DEBUG(linker,belch( " ZERO" ));
2708 Elf_Sym sym = stab[ELF_R_SYM(info)];
2709 /* First see if it is a local symbol. */
2710 if (ELF_ST_BIND(sym.st_info) == STB_LOCAL) {
2711 /* Yes, so we can get the address directly from the ELF symbol
2713 symbol = sym.st_name==0 ? "(noname)" : strtab+sym.st_name;
2715 (ehdrC + shdr[ sym.st_shndx ].sh_offset
2716 + stab[ELF_R_SYM(info)].st_value);
2717 #ifdef ELF_FUNCTION_DESC
2718 /* Make a function descriptor for this function */
2719 if (S && ELF_ST_TYPE(sym.st_info) == STT_FUNC) {
2720 S = allocateFunctionDesc(S + A);
2725 /* No, so look up the name in our global table. */
2726 symbol = strtab + sym.st_name;
2727 (void*)S = lookupSymbol( symbol );
2729 #ifdef ELF_FUNCTION_DESC
2730 /* If a function, already a function descriptor - we would
2731 have to copy it to add an offset. */
2732 if (S && (ELF_ST_TYPE(sym.st_info) == STT_FUNC) && (A != 0))
2733 belch("%s: function %s with addend %p", oc->fileName, symbol, (void *)A);
2737 belch("%s: unknown symbol `%s'", oc->fileName, symbol);
2740 IF_DEBUG(linker,belch( "`%s' resolves to %p", symbol, (void*)S ));
2743 IF_DEBUG(linker,fprintf ( stderr, "Reloc: P = %p S = %p A = %p\n",
2744 (void*)P, (void*)S, (void*)A ));
2745 /* checkProddableBlock ( oc, (void*)P ); */
2749 switch (ELF_R_TYPE(info)) {
2750 # if defined(sparc_TARGET_ARCH)
2751 case R_SPARC_WDISP30:
2752 w1 = *pP & 0xC0000000;
2753 w2 = (Elf_Word)((value - P) >> 2);
2754 ASSERT((w2 & 0xC0000000) == 0);
2759 w1 = *pP & 0xFFC00000;
2760 w2 = (Elf_Word)(value >> 10);
2761 ASSERT((w2 & 0xFFC00000) == 0);
2767 w2 = (Elf_Word)(value & 0x3FF);
2768 ASSERT((w2 & ~0x3FF) == 0);
2772 /* According to the Sun documentation:
2774 This relocation type resembles R_SPARC_32, except it refers to an
2775 unaligned word. That is, the word to be relocated must be treated
2776 as four separate bytes with arbitrary alignment, not as a word
2777 aligned according to the architecture requirements.
2779 (JRS: which means that freeloading on the R_SPARC_32 case
2780 is probably wrong, but hey ...)
2784 w2 = (Elf_Word)value;
2787 # elif defined(ia64_TARGET_ARCH)
2788 case R_IA64_DIR64LSB:
2789 case R_IA64_FPTR64LSB:
2792 case R_IA64_PCREL64LSB:
2795 case R_IA64_SEGREL64LSB:
2796 addr = findElfSegment(ehdrC, value);
2799 case R_IA64_GPREL22:
2800 ia64_reloc_gprel22(P, value);
2802 case R_IA64_LTOFF22:
2803 case R_IA64_LTOFF22X:
2804 case R_IA64_LTOFF_FPTR22:
2805 addr = allocateGOTEntry(value);
2806 ia64_reloc_gprel22(P, addr);
2808 case R_IA64_PCREL21B:
2809 ia64_reloc_pcrel21(P, S, oc);
2812 /* This goes with R_IA64_LTOFF22X and points to the load to
2813 * convert into a move. We don't implement relaxation. */
2817 belch("%s: unhandled ELF relocation(RelA) type %d\n",
2818 oc->fileName, ELF_R_TYPE(info));
2827 ocResolve_ELF ( ObjectCode* oc )
2831 Elf_Sym* stab = NULL;
2832 char* ehdrC = (char*)(oc->image);
2833 Elf_Ehdr* ehdr = (Elf_Ehdr*) ehdrC;
2834 Elf_Shdr* shdr = (Elf_Shdr*) (ehdrC + ehdr->e_shoff);
2835 char* sh_strtab = ehdrC + shdr[ehdr->e_shstrndx].sh_offset;
2837 /* first find "the" symbol table */
2838 stab = (Elf_Sym*) findElfSection ( ehdrC, SHT_SYMTAB );
2840 /* also go find the string table */
2841 strtab = findElfSection ( ehdrC, SHT_STRTAB );
2843 if (stab == NULL || strtab == NULL) {
2844 belch("%s: can't find string or symbol table", oc->fileName);
2848 /* Process the relocation sections. */
2849 for (shnum = 0; shnum < ehdr->e_shnum; shnum++) {
2851 /* Skip sections called ".rel.stab". These appear to contain
2852 relocation entries that, when done, make the stabs debugging
2853 info point at the right places. We ain't interested in all
2855 if (0 == memcmp(".rel.stab", sh_strtab + shdr[shnum].sh_name, 9))
2858 if (shdr[shnum].sh_type == SHT_REL ) {
2859 ok = do_Elf_Rel_relocations ( oc, ehdrC, shdr,
2860 shnum, stab, strtab );
2864 if (shdr[shnum].sh_type == SHT_RELA) {
2865 ok = do_Elf_Rela_relocations ( oc, ehdrC, shdr,
2866 shnum, stab, strtab );
2871 /* Free the local symbol table; we won't need it again. */
2872 freeHashTable(oc->lochash, NULL);
2880 * Instructions are 41 bits long, packed into 128 bit bundles with a 5-bit template
2881 * at the front. The following utility functions pack and unpack instructions, and
2882 * take care of the most common relocations.
2885 #ifdef ia64_TARGET_ARCH
2888 ia64_extract_instruction(Elf64_Xword *target)
2891 int slot = (Elf_Addr)target & 3;
2892 (Elf_Addr)target &= ~3;
2900 return ((w1 >> 5) & 0x1ffffffffff);
2902 return (w1 >> 46) | ((w2 & 0x7fffff) << 18);
2906 barf("ia64_extract_instruction: invalid slot %p", target);
2911 ia64_deposit_instruction(Elf64_Xword *target, Elf64_Xword value)
2913 int slot = (Elf_Addr)target & 3;
2914 (Elf_Addr)target &= ~3;
2919 *target |= value << 5;
2922 *target |= value << 46;
2923 *(target+1) |= value >> 18;
2926 *(target+1) |= value << 23;
2932 ia64_reloc_gprel22(Elf_Addr target, Elf_Addr value)
2934 Elf64_Xword instruction;
2935 Elf64_Sxword rel_value;
2937 rel_value = value - gp_val;
2938 if ((rel_value > 0x1fffff) || (rel_value < -0x1fffff))
2939 barf("GP-relative data out of range (address = 0x%lx, gp = 0x%lx)", value, gp_val);
2941 instruction = ia64_extract_instruction((Elf64_Xword *)target);
2942 instruction |= (((rel_value >> 0) & 0x07f) << 13) /* imm7b */
2943 | (((rel_value >> 7) & 0x1ff) << 27) /* imm9d */
2944 | (((rel_value >> 16) & 0x01f) << 22) /* imm5c */
2945 | ((Elf64_Xword)(rel_value < 0) << 36); /* s */
2946 ia64_deposit_instruction((Elf64_Xword *)target, instruction);
2950 ia64_reloc_pcrel21(Elf_Addr target, Elf_Addr value, ObjectCode *oc)
2952 Elf64_Xword instruction;
2953 Elf64_Sxword rel_value;
2956 entry = allocatePLTEntry(value, oc);
2958 rel_value = (entry >> 4) - (target >> 4);
2959 if ((rel_value > 0xfffff) || (rel_value < -0xfffff))
2960 barf("PLT entry too far away (entry = 0x%lx, target = 0x%lx)", entry, target);
2962 instruction = ia64_extract_instruction((Elf64_Xword *)target);
2963 instruction |= ((rel_value & 0xfffff) << 13) /* imm20b */
2964 | ((Elf64_Xword)(rel_value < 0) << 36); /* s */
2965 ia64_deposit_instruction((Elf64_Xword *)target, instruction);
2972 /* --------------------------------------------------------------------------
2974 * ------------------------------------------------------------------------*/
2976 #if defined(OBJFORMAT_MACHO)
2979 Initial support for MachO linking on Darwin/MacOS X on PowerPC chips
2980 by Wolfgang Thaller (wolfgang.thaller@gmx.net)
2982 I hereby formally apologize for the hackish nature of this code.
2983 Things that need to be done:
2984 *) get common symbols and .bss sections to work properly.
2985 Haskell modules seem to work, but C modules can cause problems
2986 *) implement ocVerifyImage_MachO
2987 *) add more sanity checks. The current code just has to segfault if there's a
2991 static int ocVerifyImage_MachO(ObjectCode* oc)
2993 // FIXME: do some verifying here
2997 static int resolveImports(
3000 struct symtab_command *symLC,
3001 struct section *sect, // ptr to lazy or non-lazy symbol pointer section
3002 unsigned long *indirectSyms,
3003 struct nlist *nlist)
3007 for(i=0;i*4<sect->size;i++)
3009 // according to otool, reserved1 contains the first index into the indirect symbol table
3010 struct nlist *symbol = &nlist[indirectSyms[sect->reserved1+i]];
3011 char *nm = image + symLC->stroff + symbol->n_un.n_strx;
3014 if((symbol->n_type & N_TYPE) == N_UNDF
3015 && (symbol->n_type & N_EXT) && (symbol->n_value != 0))
3016 addr = (void*) (symbol->n_value);
3017 else if((addr = lookupLocalSymbol(oc,nm)) != NULL)
3020 addr = lookupSymbol(nm);
3023 belch("\n%s: unknown symbol `%s'", oc->fileName, nm);
3027 ((void**)(image + sect->offset))[i] = addr;
3033 static int relocateSection(char *image,
3034 struct symtab_command *symLC, struct nlist *nlist,
3035 struct section* sections, struct section *sect)
3037 struct relocation_info *relocs;
3040 if(!strcmp(sect->sectname,"__la_symbol_ptr"))
3042 else if(!strcmp(sect->sectname,"__nl_symbol_ptr"))
3046 relocs = (struct relocation_info*) (image + sect->reloff);
3050 if(relocs[i].r_address & R_SCATTERED)
3052 struct scattered_relocation_info *scat =
3053 (struct scattered_relocation_info*) &relocs[i];
3057 if(scat->r_length == 2 && scat->r_type == GENERIC_RELOC_VANILLA)
3059 unsigned long* word = (unsigned long*) (image + sect->offset + scat->r_address);
3061 *word = scat->r_value + sect->offset + ((long) image);
3065 continue; // FIXME: I hope it's OK to ignore all the others.
3069 struct relocation_info *reloc = &relocs[i];
3070 if(reloc->r_pcrel && !reloc->r_extern)
3073 if(reloc->r_length == 2)
3075 unsigned long word = 0;
3077 unsigned long* wordPtr = (unsigned long*) (image + sect->offset + reloc->r_address);
3079 if(reloc->r_type == GENERIC_RELOC_VANILLA)
3083 else if(reloc->r_type == PPC_RELOC_LO16)
3085 word = ((unsigned short*) wordPtr)[1];
3086 word |= ((unsigned long) relocs[i+1].r_address & 0xFFFF) << 16;
3088 else if(reloc->r_type == PPC_RELOC_HI16)
3090 word = ((unsigned short*) wordPtr)[1] << 16;
3091 word |= ((unsigned long) relocs[i+1].r_address & 0xFFFF);
3093 else if(reloc->r_type == PPC_RELOC_HA16)
3095 word = ((unsigned short*) wordPtr)[1] << 16;
3096 word += ((short)relocs[i+1].r_address & (short)0xFFFF);
3098 else if(reloc->r_type == PPC_RELOC_BR24)
3101 word = (word & 0x03FFFFFC) | (word & 0x02000000) ? 0xFC000000 : 0;
3105 if(!reloc->r_extern)
3108 sections[reloc->r_symbolnum-1].offset
3109 - sections[reloc->r_symbolnum-1].addr
3116 struct nlist *symbol = &nlist[reloc->r_symbolnum];
3117 char *nm = image + symLC->stroff + symbol->n_un.n_strx;
3118 word = (unsigned long) (lookupSymbol(nm));
3121 belch("\nunknown symbol `%s'", nm);
3126 word -= ((long)image) + sect->offset + reloc->r_address;
3129 if(reloc->r_type == GENERIC_RELOC_VANILLA)
3134 else if(reloc->r_type == PPC_RELOC_LO16)
3136 ((unsigned short*) wordPtr)[1] = word & 0xFFFF;
3139 else if(reloc->r_type == PPC_RELOC_HI16)
3141 ((unsigned short*) wordPtr)[1] = (word >> 16) & 0xFFFF;
3144 else if(reloc->r_type == PPC_RELOC_HA16)
3146 ((unsigned short*) wordPtr)[1] = ((word >> 16) & 0xFFFF)
3147 + ((word & (1<<15)) ? 1 : 0);
3150 else if(reloc->r_type == PPC_RELOC_BR24)
3152 *wordPtr = (*wordPtr & 0xFC000003) | (word & 0x03FFFFFC);
3156 barf("\nunknown relocation %d",reloc->r_type);
3163 static int ocGetNames_MachO(ObjectCode* oc)
3165 char *image = (char*) oc->image;
3166 struct mach_header *header = (struct mach_header*) image;
3167 struct load_command *lc = (struct load_command*) (image + sizeof(struct mach_header));
3168 unsigned i,curSymbol;
3169 struct segment_command *segLC = NULL;
3170 struct section *sections, *la_ptrs = NULL, *nl_ptrs = NULL;
3171 struct symtab_command *symLC = NULL;
3172 struct dysymtab_command *dsymLC = NULL;
3173 struct nlist *nlist;
3174 unsigned long commonSize = 0;
3175 char *commonStorage = NULL;
3176 unsigned long commonCounter;
3178 for(i=0;i<header->ncmds;i++)
3180 if(lc->cmd == LC_SEGMENT)
3181 segLC = (struct segment_command*) lc;
3182 else if(lc->cmd == LC_SYMTAB)
3183 symLC = (struct symtab_command*) lc;
3184 else if(lc->cmd == LC_DYSYMTAB)
3185 dsymLC = (struct dysymtab_command*) lc;
3186 lc = (struct load_command *) ( ((char*)lc) + lc->cmdsize );
3189 sections = (struct section*) (segLC+1);
3190 nlist = (struct nlist*) (image + symLC->symoff);
3192 for(i=0;i<segLC->nsects;i++)
3194 if(!strcmp(sections[i].sectname,"__la_symbol_ptr"))
3195 la_ptrs = §ions[i];
3196 else if(!strcmp(sections[i].sectname,"__nl_symbol_ptr"))
3197 nl_ptrs = §ions[i];
3199 // for now, only add __text and __const to the sections table
3200 else if(!strcmp(sections[i].sectname,"__text"))
3201 addSection(oc, SECTIONKIND_CODE_OR_RODATA,
3202 (void*) (image + sections[i].offset),
3203 (void*) (image + sections[i].offset + sections[i].size));
3204 else if(!strcmp(sections[i].sectname,"__const"))
3205 addSection(oc, SECTIONKIND_RWDATA,
3206 (void*) (image + sections[i].offset),
3207 (void*) (image + sections[i].offset + sections[i].size));
3208 else if(!strcmp(sections[i].sectname,"__data"))
3209 addSection(oc, SECTIONKIND_RWDATA,
3210 (void*) (image + sections[i].offset),
3211 (void*) (image + sections[i].offset + sections[i].size));
3214 // count external symbols defined here
3216 for(i=dsymLC->iextdefsym;i<dsymLC->iextdefsym+dsymLC->nextdefsym;i++)
3218 if((nlist[i].n_type & N_TYPE) == N_SECT)
3221 for(i=0;i<symLC->nsyms;i++)
3223 if((nlist[i].n_type & N_TYPE) == N_UNDF
3224 && (nlist[i].n_type & N_EXT) && (nlist[i].n_value != 0))
3226 commonSize += nlist[i].n_value;
3230 oc->symbols = stgMallocBytes(oc->n_symbols * sizeof(char*),
3231 "ocGetNames_MachO(oc->symbols)");
3233 // insert symbols into hash table
3234 for(i=dsymLC->iextdefsym,curSymbol=0;i<dsymLC->iextdefsym+dsymLC->nextdefsym;i++)
3236 if((nlist[i].n_type & N_TYPE) == N_SECT)
3238 char *nm = image + symLC->stroff + nlist[i].n_un.n_strx;
3239 ghciInsertStrHashTable(oc->fileName, symhash, nm, image +
3240 sections[nlist[i].n_sect-1].offset
3241 - sections[nlist[i].n_sect-1].addr
3242 + nlist[i].n_value);
3243 oc->symbols[curSymbol++] = nm;
3247 // insert local symbols into lochash
3248 for(i=dsymLC->ilocalsym;i<dsymLC->ilocalsym+dsymLC->nlocalsym;i++)
3250 if((nlist[i].n_type & N_TYPE) == N_SECT)
3252 char *nm = image + symLC->stroff + nlist[i].n_un.n_strx;
3253 ghciInsertStrHashTable(oc->fileName, oc->lochash, nm, image +
3254 sections[nlist[i].n_sect-1].offset
3255 - sections[nlist[i].n_sect-1].addr
3256 + nlist[i].n_value);
3261 commonStorage = stgCallocBytes(1,commonSize,"ocGetNames_MachO(common symbols)");
3262 commonCounter = (unsigned long)commonStorage;
3263 for(i=0;i<symLC->nsyms;i++)
3265 if((nlist[i].n_type & N_TYPE) == N_UNDF
3266 && (nlist[i].n_type & N_EXT) && (nlist[i].n_value != 0))
3268 char *nm = image + symLC->stroff + nlist[i].n_un.n_strx;
3269 unsigned long sz = nlist[i].n_value;
3271 nlist[i].n_value = commonCounter;
3273 ghciInsertStrHashTable(oc->fileName, symhash, nm, (void*)commonCounter);
3274 oc->symbols[curSymbol++] = nm;
3276 commonCounter += sz;
3282 static int ocResolve_MachO(ObjectCode* oc)
3284 char *image = (char*) oc->image;
3285 struct mach_header *header = (struct mach_header*) image;
3286 struct load_command *lc = (struct load_command*) (image + sizeof(struct mach_header));
3288 struct segment_command *segLC = NULL;
3289 struct section *sections, *la_ptrs = NULL, *nl_ptrs = NULL;
3290 struct symtab_command *symLC = NULL;
3291 struct dysymtab_command *dsymLC = NULL;
3292 struct nlist *nlist;
3293 unsigned long *indirectSyms;
3295 for(i=0;i<header->ncmds;i++)
3297 if(lc->cmd == LC_SEGMENT)
3298 segLC = (struct segment_command*) lc;
3299 else if(lc->cmd == LC_SYMTAB)
3300 symLC = (struct symtab_command*) lc;
3301 else if(lc->cmd == LC_DYSYMTAB)
3302 dsymLC = (struct dysymtab_command*) lc;
3303 lc = (struct load_command *) ( ((char*)lc) + lc->cmdsize );
3306 sections = (struct section*) (segLC+1);
3307 nlist = (struct nlist*) (image + symLC->symoff);
3309 for(i=0;i<segLC->nsects;i++)
3311 if(!strcmp(sections[i].sectname,"__la_symbol_ptr"))
3312 la_ptrs = §ions[i];
3313 else if(!strcmp(sections[i].sectname,"__nl_symbol_ptr"))
3314 nl_ptrs = §ions[i];
3317 indirectSyms = (unsigned long*) (image + dsymLC->indirectsymoff);
3320 if(!resolveImports(oc,image,symLC,la_ptrs,indirectSyms,nlist))
3323 if(!resolveImports(oc,image,symLC,nl_ptrs,indirectSyms,nlist))
3326 for(i=0;i<segLC->nsects;i++)
3328 if(!relocateSection(image,symLC,nlist,sections,§ions[i]))
3332 /* Free the local symbol table; we won't need it again. */
3333 freeHashTable(oc->lochash, NULL);
3339 * The Mach-O object format uses leading underscores. But not everywhere.
3340 * There is a small number of runtime support functions defined in
3341 * libcc_dynamic.a whose name does not have a leading underscore.
3342 * As a consequence, we can't get their address from C code.
3343 * We have to use inline assembler just to take the address of a function.
3347 static void machoInitSymbolsWithoutUnderscore()
3353 __asm__ ("lis %0,hi16(" #x ")\n\tori %0,%0,lo16(" #x ")" : "=r" (p)); \
3354 ghciInsertStrHashTable("(GHCi built-in symbols)", symhash, #x, p);
3356 RTS_MACHO_NOUNDERLINE_SYMBOLS