1 /* -----------------------------------------------------------------------------
2 * $Id: Linker.c,v 1.25 2001/02/12 13:30:15 sewardj Exp $
4 * (c) The GHC Team, 2000
8 * ---------------------------------------------------------------------------*/
15 #include "LinkerInternals.h"
17 #include "StoragePriv.h"
19 #ifdef HAVE_SYS_TYPES_H
20 #include <sys/types.h>
23 #ifdef HAVE_SYS_STAT_H
31 #if defined(linux_TARGET_OS) || defined(solaris2_TARGET_OS) || defined(freebsd_TARGET_OS)
33 #elif defined(cygwin32_TARGET_OS) || defined (mingw32_TARGET_OS)
34 #define OBJFORMAT_PEi386
37 /* Hash table mapping symbol names to Symbol */
38 /*Str*/HashTable *symhash;
40 #if defined(OBJFORMAT_ELF)
41 static int ocVerifyImage_ELF ( ObjectCode* oc );
42 static int ocGetNames_ELF ( ObjectCode* oc );
43 static int ocResolve_ELF ( ObjectCode* oc );
44 #elif defined(OBJFORMAT_PEi386)
45 static int ocVerifyImage_PEi386 ( ObjectCode* oc );
46 static int ocGetNames_PEi386 ( ObjectCode* oc );
47 static int ocResolve_PEi386 ( ObjectCode* oc );
50 /* -----------------------------------------------------------------------------
51 * Built-in symbols from the RTS
68 SymX(stg_update_PAP) \
69 SymX(stg_ap_2_upd_info) \
70 SymX(stg_ap_3_upd_info) \
71 SymX(stg_ap_4_upd_info) \
72 SymX(stg_ap_5_upd_info) \
73 SymX(stg_ap_6_upd_info) \
74 SymX(stg_ap_7_upd_info) \
75 SymX(stg_ap_8_upd_info) \
76 SymX(stg_sel_0_upd_info) \
77 SymX(stg_sel_1_upd_info) \
78 SymX(stg_sel_2_upd_info) \
79 SymX(stg_sel_3_upd_info) \
80 SymX(stg_sel_4_upd_info) \
81 SymX(stg_sel_5_upd_info) \
82 SymX(stg_sel_6_upd_info) \
83 SymX(stg_sel_7_upd_info) \
84 SymX(stg_sel_8_upd_info) \
85 SymX(stg_sel_9_upd_info) \
86 SymX(stg_sel_10_upd_info) \
87 SymX(stg_sel_11_upd_info) \
88 SymX(stg_sel_12_upd_info) \
89 SymX(stg_sel_13_upd_info) \
90 SymX(stg_sel_14_upd_info) \
91 SymX(stg_sel_15_upd_info) \
92 SymX(stg_upd_frame_info) \
93 SymX(stg_seq_frame_info) \
94 SymX(stg_CAF_BLACKHOLE_info) \
95 SymX(stg_IND_STATIC_info) \
96 SymX(stg_EMPTY_MVAR_info) \
97 SymX(stg_MUT_ARR_PTRS_FROZEN_info) \
99 SymX(stg_CHARLIKE_closure) \
100 SymX(stg_INTLIKE_closure) \
102 SymX(newBCOzh_fast) \
103 SymX(mkApUpd0zh_fast) \
104 SymX(putMVarzh_fast) \
105 SymX(newMVarzh_fast) \
106 SymX(takeMVarzh_fast) \
107 SymX(tryTakeMVarzh_fast) \
113 SymX(killThreadzh_fast) \
114 SymX(waitReadzh_fast) \
115 SymX(waitWritezh_fast) \
116 SymX(suspendThread) \
118 SymX(stackOverflow) \
119 SymX(int2Integerzh_fast) \
120 SymX(word2Integerzh_fast) \
121 SymX(mkForeignObjzh_fast) \
122 SymX(__encodeDouble) \
123 SymX(decodeDoublezh_fast) \
124 SymX(decodeFloatzh_fast) \
125 SymX(gcdIntegerzh_fast) \
126 SymX(newArrayzh_fast) \
127 SymX(unsafeThawArrayzh_fast) \
128 SymX(newByteArrayzh_fast) \
129 SymX(newMutVarzh_fast) \
130 SymX(quotRemIntegerzh_fast) \
131 SymX(quotIntegerzh_fast) \
132 SymX(remIntegerzh_fast) \
133 SymX(divExactIntegerzh_fast) \
134 SymX(divModIntegerzh_fast) \
135 SymX(timesIntegerzh_fast) \
136 SymX(minusIntegerzh_fast) \
137 SymX(plusIntegerzh_fast) \
138 SymX(andIntegerzh_fast) \
139 SymX(orIntegerzh_fast) \
140 SymX(xorIntegerzh_fast) \
141 SymX(complementIntegerzh_fast) \
142 SymX(mkWeakzh_fast) \
143 SymX(makeStableNamezh_fast) \
144 SymX(finalizzeWeakzh_fast) \
145 SymX(blockAsyncExceptionszh_fast) \
146 SymX(unblockAsyncExceptionszh_fast) \
148 SymX(isDoubleInfinite) \
149 SymX(isDoubleDenormalized) \
150 SymX(isDoubleNegativeZero) \
151 SymX(__encodeFloat) \
153 SymX(isFloatInfinite) \
154 SymX(isFloatDenormalized) \
155 SymX(isFloatNegativeZero) \
156 SymX(__int_encodeFloat) \
157 SymX(__int_encodeDouble) \
158 SymX(__gmpz_cmp_si) \
159 SymX(__gmpz_cmp_ui) \
164 SymX(resetNonBlockingFd) \
166 SymX(stable_ptr_table) \
167 SymX(shutdownHaskellAndExit) \
168 Sym(stg_enterStackTop) \
169 Sym(stg_yield_to_interpreter) \
173 Sym(__init_PrelGHC) \
174 SymX(freeHaskellFunctionPtr) \
177 SymX(NoRunnableThreadsHook) \
178 SymX(StackOverflowHook) \
179 SymX(OutOfHeapHook) \
180 SymX(MallocFailHook) \
181 SymX(PatErrorHdrHook) \
184 SymX(PostTraceHook) \
185 SymX(stg_sig_install) \
187 SymX(createAdjustor) \
189 SymX(rts_mkStablePtr) \
192 SymX(rts_checkSchedStatus) \
195 #ifndef SUPPORT_LONG_LONGS
196 #define RTS_LONG_LONG_SYMS /* nothing */
198 #define RTS_LONG_LONG_SYMS \
211 SymX(stg_remWord64) \
212 SymX(stg_quotWord64) \
214 SymX(stg_quotInt64) \
215 SymX(stg_negateInt64) \
216 SymX(stg_plusInt64) \
217 SymX(stg_minusInt64) \
218 SymX(stg_timesInt64) \
224 SymX(stg_shiftRL64) \
225 SymX(stg_iShiftL64) \
226 SymX(stg_iShiftRL64) \
227 SymX(stg_iShiftRA64) \
228 SymX(stg_intToInt64) \
229 SymX(stg_int64ToInt) \
230 SymX(stg_int64ToWord64) \
231 SymX(stg_wordToWord64) \
232 SymX(stg_word64ToWord) \
233 SymX(stg_word64ToInt64) \
234 SymX(int64ToIntegerzh_fast) \
235 SymX(word64ToIntegerzh_fast)
236 #endif /* SUPPORT_LONG_LONGS */
238 /* entirely bogus claims about types of these symbols */
239 #define Sym(vvv) extern void (vvv);
240 #define SymX(vvv) /**/
245 #ifdef LEADING_UNDERSCORE
246 #define MAYBE_LEADING_UNDERSCORE_STR(s) ("_" s)
248 #define MAYBE_LEADING_UNDERSCORE_STR(s) (s)
251 #define Sym(vvv) { MAYBE_LEADING_UNDERSCORE_STR(#vvv), \
253 #define SymX(vvv) Sym(vvv)
255 static SymbolVal rtsSyms[] = {
258 { 0, 0 } /* sentinel */
261 /* -----------------------------------------------------------------------------
262 * initialize the object linker
264 static void *dl_prog_handle;
271 symhash = allocStrHashTable();
273 /* populate the symbol table with stuff from the RTS */
274 for (sym = rtsSyms; sym->lbl != NULL; sym++) {
275 insertStrHashTable(symhash, sym->lbl, sym);
278 dl_prog_handle = dlopen(NULL, RTLD_LAZY);
281 /* -----------------------------------------------------------------------------
282 * lookup a symbol in the hash table
285 lookupSymbol( char *lbl )
288 ASSERT(symhash != NULL);
289 val = lookupStrHashTable(symhash, lbl);
292 return dlsym(dl_prog_handle, lbl);
300 lookupLocalSymbol( ObjectCode* oc, char *lbl )
303 val = lookupStrHashTable(oc->lochash, lbl);
313 /* -----------------------------------------------------------------------------
314 * Load an obj (populate the global symbol table, but don't resolve yet)
316 * Returns: 1 if ok, 0 on error.
319 loadObj( char *path )
327 /* assert that we haven't already loaded this object */
330 for (o = objects; o; o = o->next)
331 ASSERT(strcmp(o->fileName, path));
335 oc = stgMallocBytes(sizeof(ObjectCode), "loadObj(oc)");
337 # if defined(OBJFORMAT_ELF)
338 oc->formatName = "ELF";
339 # elif defined(OBJFORMAT_PEi386)
340 oc->formatName = "PEi386";
343 barf("loadObj: not implemented on this platform");
347 if (r == -1) { return 0; }
349 /* sigh, strdup() isn't a POSIX function, so do it the long way */
350 oc->fileName = stgMallocBytes( strlen(path)+1, "loadObj" );
351 strcpy(oc->fileName, path);
353 oc->fileSize = st.st_size;
354 oc->image = stgMallocBytes( st.st_size, "loadObj(image)" );
357 oc->lochash = allocStrHashTable();
359 /* chain it onto the list of objects */
363 /* load the image into memory */
364 f = fopen(path, "rb");
366 barf("loadObj: can't read `%s'", path);
368 n = fread ( oc->image, 1, oc->fileSize, f );
369 if (n != oc->fileSize) {
371 barf("loadObj: error whilst reading `%s'", path);
374 /* verify the in-memory image */
375 # if defined(OBJFORMAT_ELF)
376 r = ocVerifyImage_ELF ( oc );
377 # elif defined(OBJFORMAT_PEi386)
378 r = ocVerifyImage_PEi386 ( oc );
380 barf("loadObj: no verify method");
382 if (!r) { return r; }
384 /* build the symbol list for this image */
385 # if defined(OBJFORMAT_ELF)
386 r = ocGetNames_ELF ( oc );
387 # elif defined(OBJFORMAT_PEi386)
388 r = ocGetNames_PEi386 ( oc );
390 barf("loadObj: no getNames method");
392 if (!r) { return r; }
394 /* loaded, but not resolved yet */
395 oc->status = OBJECT_LOADED;
400 /* -----------------------------------------------------------------------------
401 * resolve all the currently unlinked objects in memory
403 * Returns: 1 if ok, 0 on error.
411 for (oc = objects; oc; oc = oc->next) {
412 if (oc->status != OBJECT_RESOLVED) {
413 # if defined(OBJFORMAT_ELF)
414 r = ocResolve_ELF ( oc );
415 # elif defined(OBJFORMAT_PEi386)
416 r = ocResolve_PEi386 ( oc );
418 barf("link: not implemented on this platform");
420 if (!r) { return r; }
421 oc->status = OBJECT_RESOLVED;
427 /* -----------------------------------------------------------------------------
428 * delete an object from the pool
431 unloadObj( char *path )
433 ObjectCode *oc, *prev;
435 ASSERT(symhash != NULL);
436 ASSERT(objects != NULL);
439 for (oc = objects; oc; prev = oc, oc = oc->next) {
440 if (!strcmp(oc->fileName,path)) {
442 /* Remove all the mappings for the symbols within this
447 for (s = oc->symbols; s < oc->symbols + oc->n_symbols; s++) {
448 if (s->lbl != NULL) {
449 removeStrHashTable(symhash, s->lbl, NULL);
457 prev->next = oc->next;
460 /* We're going to leave this in place, in case there are
461 any pointers from the heap into it: */
462 /* free(oc->image); */
466 freeHashTable(oc->lochash, NULL);
472 belch("unloadObj: can't find `%s' to unload", path);
476 /* --------------------------------------------------------------------------
477 * PEi386 specifics (Win32 targets)
478 * ------------------------------------------------------------------------*/
480 /* The information for this linker comes from
481 Microsoft Portable Executable
482 and Common Object File Format Specification
483 revision 5.1 January 1998
484 which SimonM says comes from the MS Developer Network CDs.
488 #if defined(OBJFORMAT_PEi386)
492 typedef unsigned char UChar;
493 typedef unsigned short UInt16;
494 typedef unsigned int UInt32;
501 UInt16 NumberOfSections;
502 UInt32 TimeDateStamp;
503 UInt32 PointerToSymbolTable;
504 UInt32 NumberOfSymbols;
505 UInt16 SizeOfOptionalHeader;
506 UInt16 Characteristics;
510 #define sizeof_COFF_header 20
517 UInt32 VirtualAddress;
518 UInt32 SizeOfRawData;
519 UInt32 PointerToRawData;
520 UInt32 PointerToRelocations;
521 UInt32 PointerToLinenumbers;
522 UInt16 NumberOfRelocations;
523 UInt16 NumberOfLineNumbers;
524 UInt32 Characteristics;
528 #define sizeof_COFF_section 40
535 UInt16 SectionNumber;
538 UChar NumberOfAuxSymbols;
542 #define sizeof_COFF_symbol 18
547 UInt32 VirtualAddress;
548 UInt32 SymbolTableIndex;
553 #define sizeof_COFF_reloc 10
556 /* From PE spec doc, section 3.3.2 */
557 #define IMAGE_FILE_RELOCS_STRIPPED 0x0001
558 #define IMAGE_FILE_EXECUTABLE_IMAGE 0x0002
559 #define IMAGE_FILE_DLL 0x2000
560 #define IMAGE_FILE_SYSTEM 0x1000
561 #define IMAGE_FILE_BYTES_REVERSED_HI 0x8000
562 #define IMAGE_FILE_BYTES_REVERSED_LO 0x0080
563 #define IMAGE_FILE_32BIT_MACHINE 0x0100
565 /* From PE spec doc, section 5.4.2 and 5.4.4 */
566 #define IMAGE_SYM_CLASS_EXTERNAL 2
567 #define IMAGE_SYM_CLASS_STATIC 3
568 #define IMAGE_SYM_UNDEFINED 0
570 /* From PE spec doc, section 4.1 */
571 #define IMAGE_SCN_CNT_CODE 0x00000020
572 #define IMAGE_SCN_CNT_INITIALIZED_DATA 0x00000040
574 /* From PE spec doc, section 5.2.1 */
575 #define IMAGE_REL_I386_DIR32 0x0006
576 #define IMAGE_REL_I386_REL32 0x0014
579 /* We use myindex to calculate array addresses, rather than
580 simply doing the normal subscript thing. That's because
581 some of the above structs have sizes which are not
582 a whole number of words. GCC rounds their sizes up to a
583 whole number of words, which means that the address calcs
584 arising from using normal C indexing or pointer arithmetic
585 are just plain wrong. Sigh.
588 myindex ( int scale, int index, void* base )
591 ((UChar*)base) + scale * index;
596 printName ( UChar* name, UChar* strtab )
598 if (name[0]==0 && name[1]==0 && name[2]==0 && name[3]==0) {
599 UInt32 strtab_offset = * (UInt32*)(name+4);
600 fprintf ( stderr, "%s", strtab + strtab_offset );
603 for (i = 0; i < 8; i++) {
604 if (name[i] == 0) break;
605 fprintf ( stderr, "%c", name[i] );
612 copyName ( UChar* name, UChar* strtab, UChar* dst, int dstSize )
614 if (name[0]==0 && name[1]==0 && name[2]==0 && name[3]==0) {
615 UInt32 strtab_offset = * (UInt32*)(name+4);
616 strncpy ( dst, strtab+strtab_offset, dstSize );
622 if (name[i] == 0) break;
632 cstring_from_COFF_symbol_name ( UChar* name, UChar* strtab )
635 /* If the string is longer than 8 bytes, look in the
636 string table for it -- this will be correctly zero terminated.
638 if (name[0]==0 && name[1]==0 && name[2]==0 && name[3]==0) {
639 UInt32 strtab_offset = * (UInt32*)(name+4);
640 return ((UChar*)strtab) + strtab_offset;
642 /* Otherwise, if shorter than 8 bytes, return the original,
643 which by defn is correctly terminated.
645 if (name[7]==0) return name;
646 /* The annoying case: 8 bytes. Copy into a temporary
647 (which is never freed ...)
651 strncpy(newstr,name,8);
658 /* Just compares the short names (first 8 chars) */
659 static COFF_section *
660 findPEi386SectionCalled ( ObjectCode* oc, char* name )
664 = (COFF_header*)(oc->image);
667 ((UChar*)(oc->image))
668 + sizeof_COFF_header + hdr->SizeOfOptionalHeader
670 for (i = 0; i < hdr->NumberOfSections; i++) {
673 COFF_section* section_i
675 myindex ( sizeof_COFF_section, i, sectab );
676 n1 = (UChar*) &(section_i->Name);
678 if (n1[0]==n2[0] && n1[1]==n2[1] && n1[2]==n2[2] &&
679 n1[3]==n2[3] && n1[4]==n2[4] && n1[5]==n2[5] &&
680 n1[6]==n2[6] && n1[7]==n2[7])
689 zapTrailingAtSign ( UChar* sym )
692 if (sym[0] == 0) return;
694 while (sym[i] != 0) i++;
697 while (j > 0 && isdigit(sym[j])) j--;
698 if (j > 0 && sym[j] == '@' && j != i) sym[j] = 0;
703 ocVerifyImage_PEi386 ( ObjectCode* oc )
707 COFF_section* sectab;
711 hdr = (COFF_header*)(oc->image);
712 sectab = (COFF_section*) (
713 ((UChar*)(oc->image))
714 + sizeof_COFF_header + hdr->SizeOfOptionalHeader
716 symtab = (COFF_symbol*) (
717 ((UChar*)(oc->image))
718 + hdr->PointerToSymbolTable
720 strtab = ((UChar*)(oc->image))
721 + hdr->PointerToSymbolTable
722 + hdr->NumberOfSymbols * sizeof_COFF_symbol;
724 if (hdr->Machine != 0x14c) {
725 oc->errMsg("Not x86 PEi386");
728 if (hdr->SizeOfOptionalHeader != 0) {
729 oc->errMsg("PEi386 with nonempty optional header");
732 if ( /* (hdr->Characteristics & IMAGE_FILE_RELOCS_STRIPPED) || */
733 (hdr->Characteristics & IMAGE_FILE_EXECUTABLE_IMAGE) ||
734 (hdr->Characteristics & IMAGE_FILE_DLL) ||
735 (hdr->Characteristics & IMAGE_FILE_SYSTEM) ) {
736 oc->errMsg("Not a PEi386 object file");
739 if ( (hdr->Characteristics & IMAGE_FILE_BYTES_REVERSED_HI) ||
740 !(hdr->Characteristics & IMAGE_FILE_32BIT_MACHINE) ) {
741 oc->errMsg("Invalid PEi386 word size or endiannness");
745 if (!verb) return TRUE;
746 /* No further verification after this point; only debug printing. */
749 "sectab offset = %d\n", ((UChar*)sectab) - ((UChar*)hdr) );
751 "symtab offset = %d\n", ((UChar*)symtab) - ((UChar*)hdr) );
753 "strtab offset = %d\n", ((UChar*)strtab) - ((UChar*)hdr) );
755 fprintf ( stderr, "\n" );
757 "Machine: 0x%x\n", (UInt32)(hdr->Machine) );
759 "# sections: %d\n", (UInt32)(hdr->NumberOfSections) );
761 "time/date: 0x%x\n", (UInt32)(hdr->TimeDateStamp) );
763 "symtab offset: %d\n", (UInt32)(hdr->PointerToSymbolTable) );
765 "# symbols: %d\n", (UInt32)(hdr->NumberOfSymbols) );
767 "sz of opt hdr: %d\n", (UInt32)(hdr->SizeOfOptionalHeader) );
769 "characteristics: 0x%x\n", (UInt32)(hdr->Characteristics) );
771 fprintf ( stderr, "\n" );
772 fprintf ( stderr, "string table has size 0x%x\n", * (UInt32*)strtab );
773 fprintf ( stderr, "---START of string table---\n");
774 for (i = 4; i < *(UInt32*)strtab; i++) {
776 fprintf ( stderr, "\n"); else
777 fprintf( stderr, "%c", strtab[i] );
779 fprintf ( stderr, "--- END of string table---\n");
781 fprintf ( stderr, "\n" );
782 for (i = 0; i < hdr->NumberOfSections; i++) {
784 COFF_section* sectab_i
786 myindex ( sizeof_COFF_section, i, sectab );
793 printName ( sectab_i->Name, strtab );
802 sectab_i->VirtualSize,
803 sectab_i->VirtualAddress,
804 sectab_i->SizeOfRawData,
805 sectab_i->PointerToRawData,
806 sectab_i->NumberOfRelocations,
807 sectab_i->PointerToRelocations
809 reltab = (COFF_reloc*) (
810 ((UChar*)(oc->image)) + sectab_i->PointerToRelocations
812 for (j = 0; j < sectab_i->NumberOfRelocations; j++) {
814 COFF_reloc* rel = (COFF_reloc*)
815 myindex ( sizeof_COFF_reloc, j, reltab );
817 " type 0x%-4x vaddr 0x%-8x name `",
819 rel->VirtualAddress );
821 myindex ( sizeof_COFF_symbol, rel->SymbolTableIndex, symtab );
822 printName ( sym->Name, strtab );
823 fprintf ( stderr, "'\n" );
825 fprintf ( stderr, "\n" );
829 fprintf ( stderr, "\n" );
832 COFF_symbol* symtab_i;
833 if (i >= hdr->NumberOfSymbols) break;
834 symtab_i = (COFF_symbol*)
835 myindex ( sizeof_COFF_symbol, i, symtab );
841 printName ( symtab_i->Name, strtab );
850 (Int32)(symtab_i->SectionNumber) - 1,
851 (UInt32)symtab_i->Type,
852 (UInt32)symtab_i->StorageClass,
853 (UInt32)symtab_i->NumberOfAuxSymbols
855 i += symtab_i->NumberOfAuxSymbols;
859 fprintf ( stderr, "\n" );
866 ocGetNames_PEi386 ( ObjectCode* oc )
869 COFF_section* sectab;
877 hdr = (COFF_header*)(oc->image);
878 sectab = (COFF_section*) (
879 ((UChar*)(oc->image))
880 + sizeof_COFF_header + hdr->SizeOfOptionalHeader
882 symtab = (COFF_symbol*) (
883 ((UChar*)(oc->image))
884 + hdr->PointerToSymbolTable
886 strtab = ((UChar*)(oc->image))
887 + hdr->PointerToSymbolTable
888 + hdr->NumberOfSymbols * sizeof_COFF_symbol;
890 /* Copy exported symbols into the ObjectCode. */
893 COFF_symbol* symtab_i;
894 if (i >= hdr->NumberOfSymbols) break;
895 symtab_i = (COFF_symbol*)
896 myindex ( sizeof_COFF_symbol, i, symtab );
898 if (symtab_i->StorageClass == IMAGE_SYM_CLASS_EXTERNAL &&
899 symtab_i->SectionNumber != IMAGE_SYM_UNDEFINED) {
901 /* This symbol is global and defined, viz, exported */
902 COFF_section* sectabent;
904 sname = cstring_from_COFF_symbol_name (
905 symtab_i->Name, strtab
908 oc->errMsg("Out of memory when copying PEi386 symbol");
912 /* for IMAGE_SYMCLASS_EXTERNAL
913 && !IMAGE_SYM_UNDEFINED,
914 the address of the symbol is:
915 address of relevant section + offset in section
917 sectabent = (COFF_section*)
918 myindex ( sizeof_COFF_section,
919 symtab_i->SectionNumber-1,
921 addr = ((UChar*)(oc->image))
922 + (sectabent->PointerToRawData
924 /* fprintf ( stderr, "addSymbol %p `%s'\n", addr,sname); */
925 if (!addSymbol(oc,sname,addr)) return FALSE;
927 i += symtab_i->NumberOfAuxSymbols;
931 oc->sections = stgMallocBytes( NumberOfSections * sizeof(Section),
932 "ocGetNamesPEi386" );
934 /* Copy section information into the ObjectCode. */
935 for (i = 0; i < hdr->NumberOfSections; i++) {
941 COFF_section* sectab_i
943 myindex ( sizeof_COFF_section, i, sectab );
944 /* fprintf ( stderr, "section name = %s\n", sectab_i->Name ); */
947 /* I'm sure this is the Right Way to do it. However, the
948 alternative of testing the sectab_i->Name field seems to
951 if (sectab_i->Characteristics & IMAGE_SCN_CNT_CODE ||
952 sectab_i->Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
953 kind = SECTIONKIND_CODE_OR_RODATA;
956 if (0==strcmp(".text",sectab_i->Name))
957 kind = SECTIONKIND_CODE_OR_RODATA;
958 if (0==strcmp(".data",sectab_i->Name) ||
959 0==strcmp(".bss",sectab_i->Name))
960 kind = SECTIONKIND_RWDATA;
962 start = ((UChar*)(oc->image))
963 + sectab_i->PointerToRawData;
965 + sectab_i->SizeOfRawData - 1;
967 if (kind != SECTIONKIND_OTHER) {
968 addSection ( oc, start, end, kind );
970 fprintf ( stderr, "unknown section name = `%s'\n",
972 oc->errMsg("Unknown PEi386 section name");
982 ocResolve_PEi386 ( ObjectCode* oc, int verb )
985 COFF_section* sectab;
994 char symbol[1000]; // ToDo
996 hdr = (COFF_header*)(oc->image);
997 sectab = (COFF_section*) (
998 ((UChar*)(oc->image))
999 + sizeof_COFF_header + hdr->SizeOfOptionalHeader
1001 symtab = (COFF_symbol*) (
1002 ((UChar*)(oc->image))
1003 + hdr->PointerToSymbolTable
1005 strtab = ((UChar*)(oc->image))
1006 + hdr->PointerToSymbolTable
1007 + hdr->NumberOfSymbols * sizeof_COFF_symbol;
1009 for (i = 0; i < hdr->NumberOfSections; i++) {
1010 COFF_section* sectab_i
1012 myindex ( sizeof_COFF_section, i, sectab );
1015 ((UChar*)(oc->image)) + sectab_i->PointerToRelocations
1017 for (j = 0; j < sectab_i->NumberOfRelocations; j++) {
1019 COFF_reloc* reltab_j
1021 myindex ( sizeof_COFF_reloc, j, reltab );
1023 /* the location to patch */
1025 ((UChar*)(oc->image))
1026 + (sectab_i->PointerToRawData
1027 + reltab_j->VirtualAddress)
1029 /* the existing contents of pP */
1031 /* the symbol to connect to */
1032 sym = (COFF_symbol*)
1033 myindex ( sizeof_COFF_symbol,
1034 reltab_j->SymbolTableIndex, symtab );
1037 "reloc sec %2d num %3d: type 0x%-4x "
1038 "vaddr 0x%-8x name `",
1040 (UInt32)reltab_j->Type,
1041 reltab_j->VirtualAddress );
1042 printName ( sym->Name, strtab );
1043 fprintf ( stderr, "'\n" );
1046 if (sym->StorageClass == IMAGE_SYM_CLASS_STATIC) {
1047 COFF_section* section_sym
1048 = findPEi386SectionCalled ( oc, sym->Name );
1050 fprintf ( stderr, "bad section = `%s'\n", sym->Name );
1051 oc->errMsg("Can't find abovementioned PEi386 section");
1054 S = ((UInt32)(oc->image))
1055 + (section_sym->PointerToRawData
1058 copyName ( sym->Name, strtab, symbol, 1000 );
1059 zapTrailingAtSign ( symbol );
1060 S = (UInt32) ocLookupSym ( oc, symbol );
1062 S = (UInt32)(oc->clientLookup ( symbol ));
1064 belch("%s: unresolvable reference to `%s'", oc->fileName, symbol);
1069 switch (reltab_j->Type) {
1070 case IMAGE_REL_I386_DIR32:
1073 case IMAGE_REL_I386_REL32:
1074 /* Tricky. We have to insert a displacement at
1075 pP which, when added to the PC for the _next_
1076 insn, gives the address of the target (S).
1077 Problem is to know the address of the next insn
1078 when we only know pP. We assume that this
1079 literal field is always the last in the insn,
1080 so that the address of the next insn is pP+4
1081 -- hence the constant 4.
1082 Also I don't know if A should be added, but so
1083 far it has always been zero.
1086 *pP = S - ((UInt32)pP) - 4;
1090 "unhandled PEi386 relocation type %d\n",
1092 oc->errMsg("unhandled PEi386 relocation type");
1102 #endif /* defined(OBJFORMAT_PEi386) */
1105 /* --------------------------------------------------------------------------
1107 * ------------------------------------------------------------------------*/
1109 #if defined(OBJFORMAT_ELF)
1114 #if defined(sparc_TARGET_ARCH)
1115 # define ELF_TARGET_SPARC /* Used inside <elf.h> */
1121 findElfSection ( void* objImage, Elf32_Word sh_type )
1124 char* ehdrC = (char*)objImage;
1125 Elf32_Ehdr* ehdr = ( Elf32_Ehdr*)ehdrC;
1126 Elf32_Shdr* shdr = (Elf32_Shdr*) (ehdrC + ehdr->e_shoff);
1128 for (i = 0; i < ehdr->e_shnum; i++) {
1129 if (shdr[i].sh_type == sh_type &&
1130 i != ehdr->e_shstrndx) {
1131 ptr = ehdrC + shdr[i].sh_offset;
1140 ocVerifyImage_ELF ( ObjectCode* oc )
1144 int i, j, nent, nstrtab, nsymtabs;
1148 char* ehdrC = (char*)(oc->image);
1149 Elf32_Ehdr* ehdr = ( Elf32_Ehdr*)ehdrC;
1151 if (ehdr->e_ident[EI_MAG0] != ELFMAG0 ||
1152 ehdr->e_ident[EI_MAG1] != ELFMAG1 ||
1153 ehdr->e_ident[EI_MAG2] != ELFMAG2 ||
1154 ehdr->e_ident[EI_MAG3] != ELFMAG3) {
1155 belch("ocVerifyImage_ELF: not an ELF header");
1158 IF_DEBUG(linker,belch( "Is an ELF header" ));
1160 if (ehdr->e_ident[EI_CLASS] != ELFCLASS32) {
1161 belch("ocVerifyImage_ELF: not 32 bit ELF" );
1165 IF_DEBUG(linker,belch( "Is 32 bit ELF" ));
1167 if (ehdr->e_ident[EI_DATA] == ELFDATA2LSB) {
1168 IF_DEBUG(linker,belch( "Is little-endian" ));
1170 if (ehdr->e_ident[EI_DATA] == ELFDATA2MSB) {
1171 IF_DEBUG(linker,belch( "Is big-endian" ));
1173 belch("ocVerifyImage_ELF: unknown endiannness");
1177 if (ehdr->e_type != ET_REL) {
1178 belch("ocVerifyImage_ELF: not a relocatable object (.o) file");
1181 IF_DEBUG(linker, belch( "Is a relocatable object (.o) file" ));
1183 IF_DEBUG(linker,belch( "Architecture is " ));
1184 switch (ehdr->e_machine) {
1185 case EM_386: IF_DEBUG(linker,belch( "x86" )); break;
1186 case EM_SPARC: IF_DEBUG(linker,belch( "sparc" )); break;
1187 default: IF_DEBUG(linker,belch( "unknown" ));
1188 belch("ocVerifyImage_ELF: unknown architecture");
1192 IF_DEBUG(linker,belch(
1193 "\nSection header table: start %d, n_entries %d, ent_size %d",
1194 ehdr->e_shoff, ehdr->e_shnum, ehdr->e_shentsize ));
1196 ASSERT (ehdr->e_shentsize == sizeof(Elf32_Shdr));
1198 shdr = (Elf32_Shdr*) (ehdrC + ehdr->e_shoff);
1200 if (ehdr->e_shstrndx == SHN_UNDEF) {
1201 belch("ocVerifyImage_ELF: no section header string table");
1204 IF_DEBUG(linker,belch( "Section header string table is section %d",
1206 sh_strtab = ehdrC + shdr[ehdr->e_shstrndx].sh_offset;
1209 for (i = 0; i < ehdr->e_shnum; i++) {
1210 IF_DEBUG(linker,fprintf(stderr, "%2d: ", i ));
1211 IF_DEBUG(linker,fprintf(stderr, "type=%2d ", (int)shdr[i].sh_type ));
1212 IF_DEBUG(linker,fprintf(stderr, "size=%4d ", (int)shdr[i].sh_size ));
1213 IF_DEBUG(linker,fprintf(stderr, "offs=%4d ", (int)shdr[i].sh_offset ));
1214 IF_DEBUG(linker,fprintf(stderr, " (%p .. %p) ",
1215 ehdrC + shdr[i].sh_offset,
1216 ehdrC + shdr[i].sh_offset + shdr[i].sh_size - 1));
1218 if (shdr[i].sh_type == SHT_REL) {
1219 IF_DEBUG(linker,fprintf(stderr, "Rel " ));
1220 } else if (shdr[i].sh_type == SHT_RELA) {
1221 IF_DEBUG(linker,fprintf(stderr, "RelA " ));
1223 IF_DEBUG(linker,fprintf(stderr," "));
1226 IF_DEBUG(linker,fprintf(stderr, "sname=%s\n", sh_strtab + shdr[i].sh_name ));
1230 IF_DEBUG(linker,belch( "\nString tables" ));
1233 for (i = 0; i < ehdr->e_shnum; i++) {
1234 if (shdr[i].sh_type == SHT_STRTAB &&
1235 i != ehdr->e_shstrndx) {
1236 IF_DEBUG(linker,belch(" section %d is a normal string table", i ));
1237 strtab = ehdrC + shdr[i].sh_offset;
1242 belch("ocVerifyImage_ELF: no string tables, or too many");
1247 IF_DEBUG(linker,belch( "\nSymbol tables" ));
1248 for (i = 0; i < ehdr->e_shnum; i++) {
1249 if (shdr[i].sh_type != SHT_SYMTAB) continue;
1250 IF_DEBUG(linker,belch( "section %d is a symbol table", i ));
1252 stab = (Elf32_Sym*) (ehdrC + shdr[i].sh_offset);
1253 nent = shdr[i].sh_size / sizeof(Elf32_Sym);
1254 IF_DEBUG(linker,belch( " number of entries is apparently %d (%d rem)",
1256 shdr[i].sh_size % sizeof(Elf32_Sym)
1258 if (0 != shdr[i].sh_size % sizeof(Elf32_Sym)) {
1259 belch("ocVerifyImage_ELF: non-integral number of symbol table entries");
1262 for (j = 0; j < nent; j++) {
1263 IF_DEBUG(linker,fprintf(stderr, " %2d ", j ));
1264 IF_DEBUG(linker,fprintf(stderr, " sec=%-5d size=%-3d val=%5p ",
1265 (int)stab[j].st_shndx,
1266 (int)stab[j].st_size,
1267 (char*)stab[j].st_value ));
1269 IF_DEBUG(linker,fprintf(stderr, "type=" ));
1270 switch (ELF32_ST_TYPE(stab[j].st_info)) {
1271 case STT_NOTYPE: IF_DEBUG(linker,fprintf(stderr, "notype " )); break;
1272 case STT_OBJECT: IF_DEBUG(linker,fprintf(stderr, "object " )); break;
1273 case STT_FUNC : IF_DEBUG(linker,fprintf(stderr, "func " )); break;
1274 case STT_SECTION: IF_DEBUG(linker,fprintf(stderr, "section" )); break;
1275 case STT_FILE: IF_DEBUG(linker,fprintf(stderr, "file " )); break;
1276 default: IF_DEBUG(linker,fprintf(stderr, "? " )); break;
1278 IF_DEBUG(linker,fprintf(stderr, " " ));
1280 IF_DEBUG(linker,fprintf(stderr, "bind=" ));
1281 switch (ELF32_ST_BIND(stab[j].st_info)) {
1282 case STB_LOCAL : IF_DEBUG(linker,fprintf(stderr, "local " )); break;
1283 case STB_GLOBAL: IF_DEBUG(linker,fprintf(stderr, "global" )); break;
1284 case STB_WEAK : IF_DEBUG(linker,fprintf(stderr, "weak " )); break;
1285 default: IF_DEBUG(linker,fprintf(stderr, "? " )); break;
1287 IF_DEBUG(linker,fprintf(stderr, " " ));
1289 IF_DEBUG(linker,fprintf(stderr, "name=%s\n", strtab + stab[j].st_name ));
1293 if (nsymtabs == 0) {
1294 belch("ocVerifyImage_ELF: didn't find any symbol tables");
1303 ocGetNames_ELF ( ObjectCode* oc )
1308 char* ehdrC = (char*)(oc->image);
1309 Elf32_Ehdr* ehdr = (Elf32_Ehdr*)ehdrC;
1310 char* strtab = findElfSection ( ehdrC, SHT_STRTAB );
1311 Elf32_Shdr* shdr = (Elf32_Shdr*) (ehdrC + ehdr->e_shoff);
1312 char* sh_strtab = ehdrC + shdr[ehdr->e_shstrndx].sh_offset;
1314 ASSERT(symhash != NULL);
1317 belch("ocGetNames_ELF: no strtab");
1322 oc->sections = stgMallocBytes( ehdr->e_shnum * sizeof(Section),
1324 oc->n_sections = ehdr->e_shnum;
1326 for (i = 0; i < ehdr->e_shnum; i++) {
1328 /* make a section entry for relevant sections */
1329 SectionKind kind = SECTIONKIND_OTHER;
1330 if (!strcmp(".data",sh_strtab+shdr[i].sh_name) ||
1331 !strcmp(".data1",sh_strtab+shdr[i].sh_name))
1332 kind = SECTIONKIND_RWDATA;
1333 if (!strcmp(".text",sh_strtab+shdr[i].sh_name) ||
1334 !strcmp(".rodata",sh_strtab+shdr[i].sh_name) ||
1335 !strcmp(".rodata1",sh_strtab+shdr[i].sh_name))
1336 kind = SECTIONKIND_CODE_OR_RODATA;
1338 /* fill in the section info */
1339 oc->sections[i].start = ehdrC + shdr[i].sh_offset;
1340 oc->sections[i].end = ehdrC + shdr[i].sh_offset + shdr[i].sh_size - 1;
1341 oc->sections[i].kind = kind;
1343 if (shdr[i].sh_type != SHT_SYMTAB) continue;
1345 /* copy stuff into this module's object symbol table */
1346 stab = (Elf32_Sym*) (ehdrC + shdr[i].sh_offset);
1347 nent = shdr[i].sh_size / sizeof(Elf32_Sym);
1348 oc->symbols = malloc(nent * sizeof(SymbolVal));
1349 oc->n_symbols = nent;
1350 for (j = 0; j < nent; j++) {
1351 if ( ( ELF32_ST_BIND(stab[j].st_info)==STB_GLOBAL
1352 || ELF32_ST_BIND(stab[j].st_info)==STB_LOCAL
1354 /* and not an undefined symbol */
1355 && stab[j].st_shndx != SHN_UNDEF
1356 /* and not in a "special section" */
1357 && stab[j].st_shndx < SHN_LORESERVE
1359 /* and it's a not a section or string table or anything silly */
1360 ( ELF32_ST_TYPE(stab[j].st_info)==STT_FUNC ||
1361 ELF32_ST_TYPE(stab[j].st_info)==STT_OBJECT ||
1362 ELF32_ST_TYPE(stab[j].st_info)==STT_NOTYPE
1365 char* nm = strtab + stab[j].st_name;
1367 + shdr[ stab[j].st_shndx ].sh_offset
1371 oc->symbols[j].lbl = nm;
1372 oc->symbols[j].addr = ad;
1373 if (ELF32_ST_BIND(stab[j].st_info)==STB_LOCAL) {
1374 IF_DEBUG(linker,belch( "addOTabName(LOCL): %10p %s %s",
1375 ad, oc->fileName, nm ));
1376 insertStrHashTable(oc->lochash, nm, &(oc->symbols[j]));
1378 IF_DEBUG(linker,belch( "addOTabName(GLOB): %10p %s %s",
1379 ad, oc->fileName, nm ));
1380 insertStrHashTable(symhash, nm, &(oc->symbols[j]));
1384 IF_DEBUG(linker,belch( "skipping `%s'",
1385 strtab + stab[j].st_name ));
1388 "skipping bind = %d, type = %d, shndx = %d `%s'\n",
1389 (int)ELF32_ST_BIND(stab[j].st_info),
1390 (int)ELF32_ST_TYPE(stab[j].st_info),
1391 (int)stab[j].st_shndx,
1392 strtab + stab[j].st_name
1395 oc->symbols[j].lbl = NULL;
1396 oc->symbols[j].addr = NULL;
1405 /* Do ELF relocations which lack an explicit addend. All x86-linux
1406 relocations appear to be of this form. */
1407 static int do_Elf32_Rel_relocations ( ObjectCode* oc, char* ehdrC,
1408 Elf32_Shdr* shdr, int shnum,
1409 Elf32_Sym* stab, char* strtab )
1414 Elf32_Rel* rtab = (Elf32_Rel*) (ehdrC + shdr[shnum].sh_offset);
1415 int nent = shdr[shnum].sh_size / sizeof(Elf32_Rel);
1416 int target_shndx = shdr[shnum].sh_info;
1417 int symtab_shndx = shdr[shnum].sh_link;
1418 stab = (Elf32_Sym*) (ehdrC + shdr[ symtab_shndx ].sh_offset);
1419 targ = (Elf32_Word*)(ehdrC + shdr[ target_shndx ].sh_offset);
1420 IF_DEBUG(linker,belch( "relocations for section %d using symtab %d",
1421 target_shndx, symtab_shndx ));
1422 for (j = 0; j < nent; j++) {
1423 Elf32_Addr offset = rtab[j].r_offset;
1424 Elf32_Word info = rtab[j].r_info;
1426 Elf32_Addr P = ((Elf32_Addr)targ) + offset;
1427 Elf32_Word* pP = (Elf32_Word*)P;
1431 IF_DEBUG(linker,belch( "Rel entry %3d is raw(%6p %6p)",
1432 j, (void*)offset, (void*)info ));
1434 IF_DEBUG(linker,belch( " ZERO" ));
1437 /* First see if it is a nameless local symbol. */
1438 if (stab[ ELF32_R_SYM(info)].st_name == 0) {
1439 symbol = "(noname)";
1441 (ehdrC + shdr[stab[ELF32_R_SYM(info)].st_shndx ].sh_offset
1442 + stab[ELF32_R_SYM(info)].st_value);
1444 /* No? Should be in a symbol table then; first try the
1446 symbol = strtab+stab[ ELF32_R_SYM(info)].st_name;
1447 (void*)S = lookupLocalSymbol( oc, symbol );
1448 if ((void*)S == NULL)
1449 (void*)S = lookupSymbol( symbol );
1452 barf("do_Elf32_Rel_relocations: %s: unknown symbol `%s'",
1453 oc->fileName, symbol);
1455 IF_DEBUG(linker,belch( "`%s' resolves to %p", symbol, (void*)S ));
1457 IF_DEBUG(linker,belch( "Reloc: P = %p S = %p A = %p",
1458 (void*)P, (void*)S, (void*)A ));
1459 switch (ELF32_R_TYPE(info)) {
1460 #ifdef i386_TARGET_ARCH
1461 case R_386_32: *pP = S + A; break;
1462 case R_386_PC32: *pP = S + A - P; break;
1465 barf("do_Elf32_Rel_relocations: unhandled ELF relocation(Rel) type %d\n", ELF32_R_TYPE(info));
1474 /* Do ELF relocations for which explicit addends are supplied.
1475 sparc-solaris relocations appear to be of this form. */
1476 static int do_Elf32_Rela_relocations ( ObjectCode* oc, char* ehdrC,
1477 Elf32_Shdr* shdr, int shnum,
1478 Elf32_Sym* stab, char* strtab )
1483 Elf32_Rela* rtab = (Elf32_Rela*) (ehdrC + shdr[shnum].sh_offset);
1484 int nent = shdr[shnum].sh_size / sizeof(Elf32_Rela);
1485 int target_shndx = shdr[shnum].sh_info;
1486 int symtab_shndx = shdr[shnum].sh_link;
1487 stab = (Elf32_Sym*) (ehdrC + shdr[ symtab_shndx ].sh_offset);
1488 targ = (Elf32_Word*)(ehdrC + shdr[ target_shndx ].sh_offset);
1489 IF_DEBUG(linker,belch( "relocations for section %d using symtab %d",
1490 target_shndx, symtab_shndx ));
1491 for (j = 0; j < nent; j++) {
1492 Elf32_Addr offset = rtab[j].r_offset;
1493 Elf32_Word info = rtab[j].r_info;
1494 Elf32_Sword addend = rtab[j].r_addend;
1496 Elf32_Addr P = ((Elf32_Addr)targ) + offset;
1497 Elf32_Addr A = addend;
1499 # if defined(sparc_TARGET_ARCH)
1500 /* This #ifdef only serves to avoid unused-var warnings. */
1501 Elf32_Word* pP = (Elf32_Word*)P;
1505 IF_DEBUG(linker,belch( "Rel entry %3d is raw(%6p %6p %6p) ",
1506 j, (void*)offset, (void*)info,
1509 IF_DEBUG(linker,belch( " ZERO" ));
1512 /* First see if it is a nameless local symbol. */
1513 if (stab[ ELF32_R_SYM(info)].st_name == 0) {
1514 symbol = "(noname)";
1516 (ehdrC + shdr[stab[ELF32_R_SYM(info)].st_shndx ].sh_offset
1517 + stab[ELF32_R_SYM(info)].st_value);
1519 /* No? Should be in a symbol table then; first try the
1521 symbol = strtab+stab[ ELF32_R_SYM(info)].st_name;
1522 (void*)S = lookupLocalSymbol( oc, symbol );
1523 if ((void*)S == NULL)
1524 (void*)S = lookupSymbol( symbol );
1527 barf("ocResolve_ELF: %s: unknown symbol `%s'",
1528 oc->fileName, symbol);
1531 fprintf ( stderr, "S %p A %p S+A %p S+A-P %p\n",S,A,S+A,S+A-P);
1534 IF_DEBUG(linker,belch( "`%s' resolves to %p", symbol, (void*)S ));
1536 IF_DEBUG(linker,fprintf ( stderr, "Reloc: P = %p S = %p A = %p\n",
1537 (void*)P, (void*)S, (void*)A ));
1538 switch (ELF32_R_TYPE(info)) {
1539 # if defined(sparc_TARGET_ARCH)
1540 case R_SPARC_WDISP30:
1541 w1 = *pP & 0xC0000000;
1542 w2 = (Elf32_Word)((S + A - P) >> 2);
1543 ASSERT((w2 & 0xC0000000) == 0);
1548 w1 = *pP & 0xFFC00000;
1549 w2 = (Elf32_Word)((S + A) >> 10);
1550 ASSERT((w2 & 0xFFC00000) == 0);
1556 w2 = (Elf32_Word)((S + A) & 0x3FF);
1557 ASSERT((w2 & ~0x3FF) == 0);
1562 w2 = (Elf32_Word)(S + A);
1567 fprintf(stderr, "unhandled ELF relocation(RelA) type %d\n",
1568 ELF32_R_TYPE(info));
1569 barf("do_Elf32_Rela_relocations: unhandled ELF relocation type");
1579 ocResolve_ELF ( ObjectCode* oc )
1583 Elf32_Sym* stab = NULL;
1584 char* ehdrC = (char*)(oc->image);
1585 Elf32_Ehdr* ehdr = (Elf32_Ehdr*) ehdrC;
1586 Elf32_Shdr* shdr = (Elf32_Shdr*) (ehdrC + ehdr->e_shoff);
1588 /* first find "the" symbol table */
1589 stab = (Elf32_Sym*) findElfSection ( ehdrC, SHT_SYMTAB );
1591 /* also go find the string table */
1592 strtab = findElfSection ( ehdrC, SHT_STRTAB );
1594 if (stab == NULL || strtab == NULL) {
1595 belch("ocResolve_ELF: can't find string or symbol table");
1599 /* Process the relocation sections. */
1600 for (shnum = 0; shnum < ehdr->e_shnum; shnum++) {
1601 if (shdr[shnum].sh_type == SHT_REL ) {
1602 ok = do_Elf32_Rel_relocations ( oc, ehdrC, shdr,
1603 shnum, stab, strtab );
1607 if (shdr[shnum].sh_type == SHT_RELA) {
1608 ok = do_Elf32_Rela_relocations ( oc, ehdrC, shdr,
1609 shnum, stab, strtab );