1 /* -----------------------------------------------------------------------------
2 * $Id: Linker.c,v 1.13 2001/01/28 17:14:11 simonmar Exp $
4 * (c) The GHC Team, 2000
8 * ---------------------------------------------------------------------------*/
16 #include "StoragePriv.h"
18 #ifdef HAVE_SYS_TYPES_H
19 #include <sys/types.h>
22 #ifdef HAVE_SYS_STAT_H
30 #ifdef GHCI /* endif is right at end of file */
32 #if defined(linux_TARGET_OS) || defined(solaris2_TARGET_OS) || defined(freebsd_TARGET_OS)
34 #elif defined(cygwin32_TARGET_OS) || defined (mingw32_TARGET_OS)
35 #define OBJFORMAT_PEi386
38 /* A bucket in the symbol hash-table. Primarily, maps symbol names to
39 * absolute addresses. All symbols from a given module are linked
40 * together, so they can be freed at the same time. There's also a
41 * bucket link field for the hash table.
43 typedef struct _SymbolVal {
48 typedef enum { OBJECT_LOADED, OBJECT_RESOLVED } OStatus;
50 /* Indication of section kinds for loaded objects. Needed by
51 the GC for deciding whether or not a pointer on the stack
54 typedef enum { SECTIONKIND_CODE_OR_RODATA,
57 SECTIONKIND_NOINFOAVAIL }
60 typedef struct { void* start; void* end; SectionKind kind; }
63 /* Top-level structure for an object module. One of these is allocated
64 * for each object file in use.
66 typedef struct _ObjectCode {
70 char* formatName; /* eg "ELF32", "DLL", "COFF", etc. */
75 /* ptr to malloc'd lump of memory holding the obj file */
78 /* The section-kind entries for this object module. Dynamically expands. */
82 /* Allow a chain of these things */
83 struct _ObjectCode * next;
87 /* Hash table mapping symbol names to Symbol */
88 /*Str*/HashTable *symhash;
90 /* List of currently loaded objects */
93 #if defined(OBJFORMAT_ELF)
94 static int ocVerifyImage_ELF ( ObjectCode* oc );
95 static int ocGetNames_ELF ( ObjectCode* oc );
96 static int ocResolve_ELF ( ObjectCode* oc );
97 #elif defined(OBJFORMAT_PEi386)
98 static int ocVerifyImage_PEi386 ( ObjectCode* oc );
99 static int ocGetNames_PEi386 ( ObjectCode* oc );
100 static int ocResolve_PEi386 ( ObjectCode* oc );
103 /* -----------------------------------------------------------------------------
104 * Built-in symbols from the RTS
107 #define RTS_SYMBOLS \
109 Sym(stg_gc_enter_1) \
116 Sym(stg_gc_unbx_r1) \
121 SymX(stg_update_PAP) \
122 SymX(stg_ap_2_upd_info) \
123 SymX(stg_ap_3_upd_info) \
124 SymX(stg_ap_4_upd_info) \
125 SymX(stg_ap_5_upd_info) \
126 SymX(stg_ap_6_upd_info) \
127 SymX(stg_ap_7_upd_info) \
128 SymX(stg_ap_8_upd_info) \
129 SymX(stg_sel_0_upd_info) \
130 SymX(stg_sel_1_upd_info) \
131 SymX(stg_sel_2_upd_info) \
132 SymX(stg_sel_3_upd_info) \
133 SymX(stg_sel_4_upd_info) \
134 SymX(stg_sel_5_upd_info) \
135 SymX(stg_sel_6_upd_info) \
136 SymX(stg_sel_7_upd_info) \
137 SymX(stg_sel_8_upd_info) \
138 SymX(stg_sel_9_upd_info) \
139 SymX(stg_sel_10_upd_info) \
140 SymX(stg_sel_11_upd_info) \
141 SymX(stg_sel_12_upd_info) \
142 SymX(stg_upd_frame_info) \
143 SymX(stg_seq_frame_info) \
144 SymX(stg_CAF_BLACKHOLE_info) \
145 SymX(stg_IND_STATIC_info) \
146 SymX(stg_EMPTY_MVAR_info) \
147 SymX(stg_MUT_ARR_PTRS_FROZEN_info) \
148 SymX(stg_WEAK_info) \
149 SymX(stg_CHARLIKE_closure) \
150 SymX(stg_INTLIKE_closure) \
151 SymX(stg_CAF_UNENTERED_entry) \
153 SymX(newBCOzh_fast) \
154 SymX(mkApUpd0zh_fast) \
155 SymX(putMVarzh_fast) \
156 SymX(newMVarzh_fast) \
157 SymX(takeMVarzh_fast) \
158 SymX(tryTakeMVarzh_fast) \
164 SymX(killThreadzh_fast) \
165 SymX(waitReadzh_fast) \
166 SymX(waitWritezh_fast) \
167 SymX(suspendThread) \
169 SymX(stackOverflow) \
170 SymX(int2Integerzh_fast) \
171 SymX(word2Integerzh_fast) \
172 SymX(mkForeignObjzh_fast) \
173 SymX(__encodeDouble) \
174 SymX(decodeDoublezh_fast) \
175 SymX(decodeFloatzh_fast) \
176 SymX(gcdIntegerzh_fast) \
177 SymX(newArrayzh_fast) \
178 SymX(unsafeThawArrayzh_fast) \
179 SymX(newByteArrayzh_fast) \
180 SymX(newMutVarzh_fast) \
181 SymX(quotRemIntegerzh_fast) \
182 SymX(quotIntegerzh_fast) \
183 SymX(remIntegerzh_fast) \
184 SymX(divExactIntegerzh_fast) \
185 SymX(divModIntegerzh_fast) \
186 SymX(timesIntegerzh_fast) \
187 SymX(minusIntegerzh_fast) \
188 SymX(plusIntegerzh_fast) \
189 SymX(andIntegerzh_fast) \
190 SymX(orIntegerzh_fast) \
191 SymX(xorIntegerzh_fast) \
192 SymX(complementIntegerzh_fast) \
193 SymX(mkWeakzh_fast) \
194 SymX(makeStableNamezh_fast) \
195 SymX(finalizzeWeakzh_fast) \
196 SymX(blockAsyncExceptionszh_fast) \
197 SymX(unblockAsyncExceptionszh_fast) \
199 SymX(isDoubleInfinite) \
200 SymX(isDoubleDenormalized) \
201 SymX(isDoubleNegativeZero) \
202 SymX(__encodeFloat) \
204 SymX(isFloatInfinite) \
205 SymX(isFloatDenormalized) \
206 SymX(isFloatNegativeZero) \
207 SymX(__int_encodeFloat) \
208 SymX(__int_encodeDouble) \
209 SymX(__gmpz_cmp_si) \
210 SymX(__gmpz_cmp_ui) \
215 SymX(resetNonBlockingFd) \
217 SymX(stable_ptr_table) \
218 SymX(shutdownHaskellAndExit) \
219 Sym(stg_enterStackTop) \
220 Sym(stg_yield_to_interpreter) \
224 Sym(__init_PrelGHC) \
225 SymX(freeHaskellFunctionPtr) \
228 SymX(NoRunnableThreadsHook) \
229 SymX(StackOverflowHook) \
230 SymX(OutOfHeapHook) \
231 SymX(MallocFailHook) \
232 SymX(PatErrorHdrHook) \
237 #ifndef SUPPORT_LONG_LONGS
238 #define RTS_LONG_LONG_SYMS /* nothing */
240 #define RTS_LONG_LONG_SYMS \
253 SymX(stg_remWord64) \
254 SymX(stg_quotWord64) \
256 SymX(stg_quotInt64) \
257 SymX(stg_negateInt64) \
258 SymX(stg_plusInt64) \
259 SymX(stg_minusInt64) \
260 SymX(stg_timesInt64) \
266 SymX(stg_shiftRL64) \
267 SymX(stg_iShiftL64) \
268 SymX(stg_iShiftRL64) \
269 SymX(stg_iShiftRA64) \
270 SymX(stg_intToInt64) \
271 SymX(stg_int64ToInt) \
272 SymX(stg_int64ToWord64) \
273 SymX(stg_wordToWord64) \
274 SymX(stg_word64ToWord) \
275 SymX(stg_word64ToInt64) \
276 SymX(int64ToIntegerzh_fast) \
277 SymX(word64ToIntegerzh_fast)
278 #endif /* SUPPORT_LONG_LONGS */
280 /* entirely bogus claims about types of these symbols */
281 #define Sym(vvv) extern void (vvv);
282 #define SymX(vvv) /**/
287 #ifdef LEADING_UNDERSCORE
288 #define MAYBE_LEADING_UNDERSCORE_STR(s) ("_" s)
290 #define MAYBE_LEADING_UNDERSCORE_STR(s) (s)
293 #define Sym(vvv) { MAYBE_LEADING_UNDERSCORE_STR(#vvv), \
295 #define SymX(vvv) Sym(vvv)
297 static SymbolVal rtsSyms[] = {
300 { 0, 0 } /* sentinel */
303 /* -----------------------------------------------------------------------------
304 * initialize the object linker
306 static void *dl_prog_handle;
313 symhash = allocStrHashTable();
315 /* populate the symbol table with stuff from the RTS */
316 for (sym = rtsSyms; sym->lbl != NULL; sym++) {
317 insertStrHashTable(symhash, sym->lbl, sym);
320 dl_prog_handle = dlopen(NULL, RTLD_LAZY);
323 /* -----------------------------------------------------------------------------
324 * lookup a symbol in the hash table
327 lookupSymbol( char *lbl )
330 val = lookupStrHashTable(symhash, lbl);
333 return dlsym(dl_prog_handle, lbl);
339 /* -----------------------------------------------------------------------------
340 * Load an obj (populate the global symbol table, but don't resolve yet)
342 * Returns: 1 if ok, 0 on error.
345 loadObj( char *path )
353 /* assert that we haven't already loaded this object */
356 for (o = objects; o; o = o->next)
357 ASSERT(strcmp(o->fileName, path));
361 oc = stgMallocBytes(sizeof(ObjectCode), "loadObj(oc)");
363 # if defined(OBJFORMAT_ELF)
364 oc->formatName = "ELF";
365 # elif defined(OBJFORMAT_PEi386)
366 oc->formatName = "PEi386";
369 barf("loadObj: not implemented on this platform");
373 if (r == -1) { return 0; }
376 oc->fileSize = st.st_size;
377 oc->image = stgMallocBytes( st.st_size, "loadObj(image)" );
381 /* chain it onto the list of objects */
385 /* load the image into memory */
386 f = fopen(path, "rb");
388 barf("loadObj: can't read `%s'", path);
390 n = fread ( oc->image, 1, oc->fileSize, f );
391 if (n != oc->fileSize) {
393 barf("loadObj: error whilst reading `%s'", path);
396 /* verify the in-memory image */
397 # if defined(OBJFORMAT_ELF)
398 r = ocVerifyImage_ELF ( oc );
399 # elif defined(OBJFORMAT_PEi386)
400 r = ocVerifyImage_PEi386 ( oc );
402 barf("loadObj: no verify method");
404 if (!r) { return r; }
406 /* build the symbol list for this image */
407 # if defined(OBJFORMAT_ELF)
408 r = ocGetNames_ELF ( oc );
409 # elif defined(OBJFORMAT_PEi386)
410 r = ocGetNames_PEi386 ( oc );
412 barf("loadObj: no getNames method");
414 if (!r) { return r; }
416 /* loaded, but not resolved yet */
417 oc->status = OBJECT_LOADED;
422 /* -----------------------------------------------------------------------------
423 * resolve all the currently unlinked objects in memory
425 * Returns: 1 if ok, 0 on error.
433 for (oc = objects; oc; oc = oc->next) {
434 if (oc->status != OBJECT_RESOLVED) {
435 # if defined(OBJFORMAT_ELF)
436 r = ocResolve_ELF ( oc );
437 # elif defined(OBJFORMAT_PEi386)
438 r = ocResolve_PEi386 ( oc );
440 barf("link: not implemented on this platform");
442 if (!r) { return r; }
443 oc->status = OBJECT_RESOLVED;
449 /* -----------------------------------------------------------------------------
450 * delete an object from the pool
453 unloadObj( char *path )
457 for (oc = objects; oc; oc = oc->next) {
458 if (!strcmp(oc->fileName,path)) {
460 /* Remove all the mappings for the symbols within this
465 for (s = oc->symbols; s < oc->symbols + oc->n_symbols; s++) {
466 removeStrHashTable(symhash, s->lbl, NULL);
470 /* We're going to leave this in place, in case there are
471 any pointers from the heap into it: */
472 /* free(oc->image); */
480 belch("unloadObj: can't find `%s' to unload", path);
484 /* --------------------------------------------------------------------------
485 * PEi386 specifics (Win32 targets)
486 * ------------------------------------------------------------------------*/
488 /* The information for this linker comes from
489 Microsoft Portable Executable
490 and Common Object File Format Specification
491 revision 5.1 January 1998
492 which SimonM says comes from the MS Developer Network CDs.
496 #if defined(OBJFORMAT_PEi386)
500 typedef unsigned char UChar;
501 typedef unsigned short UInt16;
502 typedef unsigned int UInt32;
509 UInt16 NumberOfSections;
510 UInt32 TimeDateStamp;
511 UInt32 PointerToSymbolTable;
512 UInt32 NumberOfSymbols;
513 UInt16 SizeOfOptionalHeader;
514 UInt16 Characteristics;
518 #define sizeof_COFF_header 20
525 UInt32 VirtualAddress;
526 UInt32 SizeOfRawData;
527 UInt32 PointerToRawData;
528 UInt32 PointerToRelocations;
529 UInt32 PointerToLinenumbers;
530 UInt16 NumberOfRelocations;
531 UInt16 NumberOfLineNumbers;
532 UInt32 Characteristics;
536 #define sizeof_COFF_section 40
543 UInt16 SectionNumber;
546 UChar NumberOfAuxSymbols;
550 #define sizeof_COFF_symbol 18
555 UInt32 VirtualAddress;
556 UInt32 SymbolTableIndex;
561 #define sizeof_COFF_reloc 10
564 /* From PE spec doc, section 3.3.2 */
565 #define IMAGE_FILE_RELOCS_STRIPPED 0x0001
566 #define IMAGE_FILE_EXECUTABLE_IMAGE 0x0002
567 #define IMAGE_FILE_DLL 0x2000
568 #define IMAGE_FILE_SYSTEM 0x1000
569 #define IMAGE_FILE_BYTES_REVERSED_HI 0x8000
570 #define IMAGE_FILE_BYTES_REVERSED_LO 0x0080
571 #define IMAGE_FILE_32BIT_MACHINE 0x0100
573 /* From PE spec doc, section 5.4.2 and 5.4.4 */
574 #define IMAGE_SYM_CLASS_EXTERNAL 2
575 #define IMAGE_SYM_CLASS_STATIC 3
576 #define IMAGE_SYM_UNDEFINED 0
578 /* From PE spec doc, section 4.1 */
579 #define IMAGE_SCN_CNT_CODE 0x00000020
580 #define IMAGE_SCN_CNT_INITIALIZED_DATA 0x00000040
582 /* From PE spec doc, section 5.2.1 */
583 #define IMAGE_REL_I386_DIR32 0x0006
584 #define IMAGE_REL_I386_REL32 0x0014
587 /* We use myindex to calculate array addresses, rather than
588 simply doing the normal subscript thing. That's because
589 some of the above structs have sizes which are not
590 a whole number of words. GCC rounds their sizes up to a
591 whole number of words, which means that the address calcs
592 arising from using normal C indexing or pointer arithmetic
593 are just plain wrong. Sigh.
596 myindex ( int scale, int index, void* base )
599 ((UChar*)base) + scale * index;
604 printName ( UChar* name, UChar* strtab )
606 if (name[0]==0 && name[1]==0 && name[2]==0 && name[3]==0) {
607 UInt32 strtab_offset = * (UInt32*)(name+4);
608 fprintf ( stderr, "%s", strtab + strtab_offset );
611 for (i = 0; i < 8; i++) {
612 if (name[i] == 0) break;
613 fprintf ( stderr, "%c", name[i] );
620 copyName ( UChar* name, UChar* strtab, UChar* dst, int dstSize )
622 if (name[0]==0 && name[1]==0 && name[2]==0 && name[3]==0) {
623 UInt32 strtab_offset = * (UInt32*)(name+4);
624 strncpy ( dst, strtab+strtab_offset, dstSize );
630 if (name[i] == 0) break;
640 cstring_from_COFF_symbol_name ( UChar* name, UChar* strtab )
643 /* If the string is longer than 8 bytes, look in the
644 string table for it -- this will be correctly zero terminated.
646 if (name[0]==0 && name[1]==0 && name[2]==0 && name[3]==0) {
647 UInt32 strtab_offset = * (UInt32*)(name+4);
648 return ((UChar*)strtab) + strtab_offset;
650 /* Otherwise, if shorter than 8 bytes, return the original,
651 which by defn is correctly terminated.
653 if (name[7]==0) return name;
654 /* The annoying case: 8 bytes. Copy into a temporary
655 (which is never freed ...)
659 strncpy(newstr,name,8);
666 /* Just compares the short names (first 8 chars) */
667 static COFF_section *
668 findPEi386SectionCalled ( ObjectCode* oc, char* name )
672 = (COFF_header*)(oc->image);
675 ((UChar*)(oc->image))
676 + sizeof_COFF_header + hdr->SizeOfOptionalHeader
678 for (i = 0; i < hdr->NumberOfSections; i++) {
681 COFF_section* section_i
683 myindex ( sizeof_COFF_section, i, sectab );
684 n1 = (UChar*) &(section_i->Name);
686 if (n1[0]==n2[0] && n1[1]==n2[1] && n1[2]==n2[2] &&
687 n1[3]==n2[3] && n1[4]==n2[4] && n1[5]==n2[5] &&
688 n1[6]==n2[6] && n1[7]==n2[7])
697 zapTrailingAtSign ( UChar* sym )
700 if (sym[0] == 0) return;
702 while (sym[i] != 0) i++;
705 while (j > 0 && isdigit(sym[j])) j--;
706 if (j > 0 && sym[j] == '@' && j != i) sym[j] = 0;
711 ocVerifyImage_PEi386 ( ObjectCode* oc )
715 COFF_section* sectab;
719 hdr = (COFF_header*)(oc->image);
720 sectab = (COFF_section*) (
721 ((UChar*)(oc->image))
722 + sizeof_COFF_header + hdr->SizeOfOptionalHeader
724 symtab = (COFF_symbol*) (
725 ((UChar*)(oc->image))
726 + hdr->PointerToSymbolTable
728 strtab = ((UChar*)(oc->image))
729 + hdr->PointerToSymbolTable
730 + hdr->NumberOfSymbols * sizeof_COFF_symbol;
732 if (hdr->Machine != 0x14c) {
733 oc->errMsg("Not x86 PEi386");
736 if (hdr->SizeOfOptionalHeader != 0) {
737 oc->errMsg("PEi386 with nonempty optional header");
740 if ( /* (hdr->Characteristics & IMAGE_FILE_RELOCS_STRIPPED) || */
741 (hdr->Characteristics & IMAGE_FILE_EXECUTABLE_IMAGE) ||
742 (hdr->Characteristics & IMAGE_FILE_DLL) ||
743 (hdr->Characteristics & IMAGE_FILE_SYSTEM) ) {
744 oc->errMsg("Not a PEi386 object file");
747 if ( (hdr->Characteristics & IMAGE_FILE_BYTES_REVERSED_HI) ||
748 !(hdr->Characteristics & IMAGE_FILE_32BIT_MACHINE) ) {
749 oc->errMsg("Invalid PEi386 word size or endiannness");
753 if (!verb) return TRUE;
754 /* No further verification after this point; only debug printing. */
757 "sectab offset = %d\n", ((UChar*)sectab) - ((UChar*)hdr) );
759 "symtab offset = %d\n", ((UChar*)symtab) - ((UChar*)hdr) );
761 "strtab offset = %d\n", ((UChar*)strtab) - ((UChar*)hdr) );
763 fprintf ( stderr, "\n" );
765 "Machine: 0x%x\n", (UInt32)(hdr->Machine) );
767 "# sections: %d\n", (UInt32)(hdr->NumberOfSections) );
769 "time/date: 0x%x\n", (UInt32)(hdr->TimeDateStamp) );
771 "symtab offset: %d\n", (UInt32)(hdr->PointerToSymbolTable) );
773 "# symbols: %d\n", (UInt32)(hdr->NumberOfSymbols) );
775 "sz of opt hdr: %d\n", (UInt32)(hdr->SizeOfOptionalHeader) );
777 "characteristics: 0x%x\n", (UInt32)(hdr->Characteristics) );
779 fprintf ( stderr, "\n" );
780 fprintf ( stderr, "string table has size 0x%x\n", * (UInt32*)strtab );
781 fprintf ( stderr, "---START of string table---\n");
782 for (i = 4; i < *(UInt32*)strtab; i++) {
784 fprintf ( stderr, "\n"); else
785 fprintf( stderr, "%c", strtab[i] );
787 fprintf ( stderr, "--- END of string table---\n");
789 fprintf ( stderr, "\n" );
790 for (i = 0; i < hdr->NumberOfSections; i++) {
792 COFF_section* sectab_i
794 myindex ( sizeof_COFF_section, i, sectab );
801 printName ( sectab_i->Name, strtab );
810 sectab_i->VirtualSize,
811 sectab_i->VirtualAddress,
812 sectab_i->SizeOfRawData,
813 sectab_i->PointerToRawData,
814 sectab_i->NumberOfRelocations,
815 sectab_i->PointerToRelocations
817 reltab = (COFF_reloc*) (
818 ((UChar*)(oc->image)) + sectab_i->PointerToRelocations
820 for (j = 0; j < sectab_i->NumberOfRelocations; j++) {
822 COFF_reloc* rel = (COFF_reloc*)
823 myindex ( sizeof_COFF_reloc, j, reltab );
825 " type 0x%-4x vaddr 0x%-8x name `",
827 rel->VirtualAddress );
829 myindex ( sizeof_COFF_symbol, rel->SymbolTableIndex, symtab );
830 printName ( sym->Name, strtab );
831 fprintf ( stderr, "'\n" );
833 fprintf ( stderr, "\n" );
837 fprintf ( stderr, "\n" );
840 COFF_symbol* symtab_i;
841 if (i >= hdr->NumberOfSymbols) break;
842 symtab_i = (COFF_symbol*)
843 myindex ( sizeof_COFF_symbol, i, symtab );
849 printName ( symtab_i->Name, strtab );
858 (Int32)(symtab_i->SectionNumber) - 1,
859 (UInt32)symtab_i->Type,
860 (UInt32)symtab_i->StorageClass,
861 (UInt32)symtab_i->NumberOfAuxSymbols
863 i += symtab_i->NumberOfAuxSymbols;
867 fprintf ( stderr, "\n" );
874 ocGetNames_PEi386 ( ObjectCode* oc )
877 COFF_section* sectab;
885 hdr = (COFF_header*)(oc->image);
886 sectab = (COFF_section*) (
887 ((UChar*)(oc->image))
888 + sizeof_COFF_header + hdr->SizeOfOptionalHeader
890 symtab = (COFF_symbol*) (
891 ((UChar*)(oc->image))
892 + hdr->PointerToSymbolTable
894 strtab = ((UChar*)(oc->image))
895 + hdr->PointerToSymbolTable
896 + hdr->NumberOfSymbols * sizeof_COFF_symbol;
898 /* Copy exported symbols into the ObjectCode. */
901 COFF_symbol* symtab_i;
902 if (i >= hdr->NumberOfSymbols) break;
903 symtab_i = (COFF_symbol*)
904 myindex ( sizeof_COFF_symbol, i, symtab );
906 if (symtab_i->StorageClass == IMAGE_SYM_CLASS_EXTERNAL &&
907 symtab_i->SectionNumber != IMAGE_SYM_UNDEFINED) {
909 /* This symbol is global and defined, viz, exported */
910 COFF_section* sectabent;
912 sname = cstring_from_COFF_symbol_name (
913 symtab_i->Name, strtab
916 oc->errMsg("Out of memory when copying PEi386 symbol");
920 /* for IMAGE_SYMCLASS_EXTERNAL
921 && !IMAGE_SYM_UNDEFINED,
922 the address of the symbol is:
923 address of relevant section + offset in section
925 sectabent = (COFF_section*)
926 myindex ( sizeof_COFF_section,
927 symtab_i->SectionNumber-1,
929 addr = ((UChar*)(oc->image))
930 + (sectabent->PointerToRawData
932 /* fprintf ( stderr, "addSymbol %p `%s'\n", addr,sname); */
933 if (!addSymbol(oc,sname,addr)) return FALSE;
935 i += symtab_i->NumberOfAuxSymbols;
939 oc->sections = stgMallocBytes( NumberOfSections * sizeof(Section),
940 "ocGetNamesPEi386" );
942 /* Copy section information into the ObjectCode. */
943 for (i = 0; i < hdr->NumberOfSections; i++) {
949 COFF_section* sectab_i
951 myindex ( sizeof_COFF_section, i, sectab );
952 /* fprintf ( stderr, "section name = %s\n", sectab_i->Name ); */
955 /* I'm sure this is the Right Way to do it. However, the
956 alternative of testing the sectab_i->Name field seems to
959 if (sectab_i->Characteristics & IMAGE_SCN_CNT_CODE ||
960 sectab_i->Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
961 kind = SECTIONKIND_CODE_OR_RODATA;
964 if (0==strcmp(".text",sectab_i->Name))
965 kind = SECTIONKIND_CODE_OR_RODATA;
966 if (0==strcmp(".data",sectab_i->Name) ||
967 0==strcmp(".bss",sectab_i->Name))
968 kind = SECTIONKIND_RWDATA;
970 start = ((UChar*)(oc->image))
971 + sectab_i->PointerToRawData;
973 + sectab_i->SizeOfRawData - 1;
975 if (kind != SECTIONKIND_OTHER) {
976 addSection ( oc, start, end, kind );
978 fprintf ( stderr, "unknown section name = `%s'\n",
980 oc->errMsg("Unknown PEi386 section name");
990 ocResolve_PEi386 ( ObjectCode* oc, int verb )
993 COFF_section* sectab;
1002 char symbol[1000]; // ToDo
1004 hdr = (COFF_header*)(oc->image);
1005 sectab = (COFF_section*) (
1006 ((UChar*)(oc->image))
1007 + sizeof_COFF_header + hdr->SizeOfOptionalHeader
1009 symtab = (COFF_symbol*) (
1010 ((UChar*)(oc->image))
1011 + hdr->PointerToSymbolTable
1013 strtab = ((UChar*)(oc->image))
1014 + hdr->PointerToSymbolTable
1015 + hdr->NumberOfSymbols * sizeof_COFF_symbol;
1017 for (i = 0; i < hdr->NumberOfSections; i++) {
1018 COFF_section* sectab_i
1020 myindex ( sizeof_COFF_section, i, sectab );
1023 ((UChar*)(oc->image)) + sectab_i->PointerToRelocations
1025 for (j = 0; j < sectab_i->NumberOfRelocations; j++) {
1027 COFF_reloc* reltab_j
1029 myindex ( sizeof_COFF_reloc, j, reltab );
1031 /* the location to patch */
1033 ((UChar*)(oc->image))
1034 + (sectab_i->PointerToRawData
1035 + reltab_j->VirtualAddress)
1037 /* the existing contents of pP */
1039 /* the symbol to connect to */
1040 sym = (COFF_symbol*)
1041 myindex ( sizeof_COFF_symbol,
1042 reltab_j->SymbolTableIndex, symtab );
1045 "reloc sec %2d num %3d: type 0x%-4x "
1046 "vaddr 0x%-8x name `",
1048 (UInt32)reltab_j->Type,
1049 reltab_j->VirtualAddress );
1050 printName ( sym->Name, strtab );
1051 fprintf ( stderr, "'\n" );
1054 if (sym->StorageClass == IMAGE_SYM_CLASS_STATIC) {
1055 COFF_section* section_sym
1056 = findPEi386SectionCalled ( oc, sym->Name );
1058 fprintf ( stderr, "bad section = `%s'\n", sym->Name );
1059 oc->errMsg("Can't find abovementioned PEi386 section");
1062 S = ((UInt32)(oc->image))
1063 + (section_sym->PointerToRawData
1066 copyName ( sym->Name, strtab, symbol, 1000 );
1067 zapTrailingAtSign ( symbol );
1068 S = (UInt32) ocLookupSym ( oc, symbol );
1070 S = (UInt32)(oc->clientLookup ( symbol ));
1072 belch("%s: unresolvable reference to `%s'", oc->fileName, symbol);
1077 switch (reltab_j->Type) {
1078 case IMAGE_REL_I386_DIR32:
1081 case IMAGE_REL_I386_REL32:
1082 /* Tricky. We have to insert a displacement at
1083 pP which, when added to the PC for the _next_
1084 insn, gives the address of the target (S).
1085 Problem is to know the address of the next insn
1086 when we only know pP. We assume that this
1087 literal field is always the last in the insn,
1088 so that the address of the next insn is pP+4
1089 -- hence the constant 4.
1090 Also I don't know if A should be added, but so
1091 far it has always been zero.
1094 *pP = S - ((UInt32)pP) - 4;
1098 "unhandled PEi386 relocation type %d\n",
1100 oc->errMsg("unhandled PEi386 relocation type");
1110 #endif /* defined(OBJFORMAT_PEi386) */
1113 /* --------------------------------------------------------------------------
1115 * ------------------------------------------------------------------------*/
1117 #if defined(OBJFORMAT_ELF)
1125 findElfSection ( void* objImage, Elf32_Word sh_type )
1128 char* ehdrC = (char*)objImage;
1129 Elf32_Ehdr* ehdr = ( Elf32_Ehdr*)ehdrC;
1130 Elf32_Shdr* shdr = (Elf32_Shdr*) (ehdrC + ehdr->e_shoff);
1132 for (i = 0; i < ehdr->e_shnum; i++) {
1133 if (shdr[i].sh_type == sh_type &&
1134 i != ehdr->e_shstrndx) {
1135 ptr = ehdrC + shdr[i].sh_offset;
1144 ocVerifyImage_ELF ( ObjectCode* oc )
1148 int i, j, nent, nstrtab, nsymtabs;
1152 char* ehdrC = (char*)(oc->image);
1153 Elf32_Ehdr* ehdr = ( Elf32_Ehdr*)ehdrC;
1155 if (ehdr->e_ident[EI_MAG0] != ELFMAG0 ||
1156 ehdr->e_ident[EI_MAG1] != ELFMAG1 ||
1157 ehdr->e_ident[EI_MAG2] != ELFMAG2 ||
1158 ehdr->e_ident[EI_MAG3] != ELFMAG3) {
1159 belch("ocVerifyImage_ELF: not an ELF header");
1162 IF_DEBUG(linker,belch( "Is an ELF header" ));
1164 if (ehdr->e_ident[EI_CLASS] != ELFCLASS32) {
1165 belch("ocVerifyImage_ELF: not 32 bit ELF" );
1169 IF_DEBUG(linker,belch( "Is 32 bit ELF" ));
1171 if (ehdr->e_ident[EI_DATA] == ELFDATA2LSB) {
1172 IF_DEBUG(linker,belch( "Is little-endian" ));
1174 if (ehdr->e_ident[EI_DATA] == ELFDATA2MSB) {
1175 IF_DEBUG(linker,belch( "Is big-endian" ));
1177 belch("ocVerifyImage_ELF: unknown endiannness");
1181 if (ehdr->e_type != ET_REL) {
1182 belch("ocVerifyImage_ELF: not a relocatable object (.o) file");
1185 IF_DEBUG(linker, belch( "Is a relocatable object (.o) file" ));
1187 IF_DEBUG(linker,belch( "Architecture is " ));
1188 switch (ehdr->e_machine) {
1189 case EM_386: IF_DEBUG(linker,belch( "x86" )); break;
1190 case EM_SPARC: IF_DEBUG(linker,belch( "sparc" )); break;
1191 default: IF_DEBUG(linker,belch( "unknown" ));
1192 belch("ocVerifyImage_ELF: unknown architecture");
1196 IF_DEBUG(linker,belch(
1197 "\nSection header table: start %d, n_entries %d, ent_size %d",
1198 ehdr->e_shoff, ehdr->e_shnum, ehdr->e_shentsize ));
1200 ASSERT (ehdr->e_shentsize == sizeof(Elf32_Shdr));
1202 shdr = (Elf32_Shdr*) (ehdrC + ehdr->e_shoff);
1204 if (ehdr->e_shstrndx == SHN_UNDEF) {
1205 belch("ocVerifyImage_ELF: no section header string table");
1208 IF_DEBUG(linker,belch( "Section header string table is section %d",
1210 sh_strtab = ehdrC + shdr[ehdr->e_shstrndx].sh_offset;
1213 for (i = 0; i < ehdr->e_shnum; i++) {
1214 IF_DEBUG(linker,fprintf(stderr, "%2d: ", i ));
1215 IF_DEBUG(linker,fprintf(stderr, "type=%2d ", shdr[i].sh_type ));
1216 IF_DEBUG(linker,fprintf(stderr, "size=%4d ", shdr[i].sh_size ));
1217 IF_DEBUG(linker,fprintf(stderr, "offs=%4d ", shdr[i].sh_offset ));
1218 IF_DEBUG(linker,fprintf(stderr, " (%p .. %p) ",
1219 ehdrC + shdr[i].sh_offset,
1220 ehdrC + shdr[i].sh_offset + shdr[i].sh_size - 1));
1222 if (shdr[i].sh_type == SHT_REL) {
1223 IF_DEBUG(linker,fprintf(stderr, "Rel " ));
1224 } else if (shdr[i].sh_type == SHT_RELA) {
1225 IF_DEBUG(linker,fprintf(stderr, "RelA " ));
1227 IF_DEBUG(linker,fprintf(stderr," "));
1230 IF_DEBUG(linker,fprintf(stderr, "sname=%s\n", sh_strtab + shdr[i].sh_name ));
1234 IF_DEBUG(linker,belch( "\nString tables" ));
1237 for (i = 0; i < ehdr->e_shnum; i++) {
1238 if (shdr[i].sh_type == SHT_STRTAB &&
1239 i != ehdr->e_shstrndx) {
1240 IF_DEBUG(linker,belch(" section %d is a normal string table", i ));
1241 strtab = ehdrC + shdr[i].sh_offset;
1246 belch("ocVerifyImage_ELF: no string tables, or too many");
1251 IF_DEBUG(linker,belch( "\nSymbol tables" ));
1252 for (i = 0; i < ehdr->e_shnum; i++) {
1253 if (shdr[i].sh_type != SHT_SYMTAB) continue;
1254 IF_DEBUG(linker,belch( "section %d is a symbol table", i ));
1256 stab = (Elf32_Sym*) (ehdrC + shdr[i].sh_offset);
1257 nent = shdr[i].sh_size / sizeof(Elf32_Sym);
1258 IF_DEBUG(linker,belch( " number of entries is apparently %d (%d rem)",
1260 shdr[i].sh_size % sizeof(Elf32_Sym)
1262 if (0 != shdr[i].sh_size % sizeof(Elf32_Sym)) {
1263 belch("ocVerifyImage_ELF: non-integral number of symbol table entries");
1266 for (j = 0; j < nent; j++) {
1267 IF_DEBUG(linker,fprintf(stderr, " %2d ", j ));
1268 IF_DEBUG(linker,fprintf(stderr, " sec=%-5d size=%-3d val=%5p ",
1269 (int)stab[j].st_shndx,
1270 (int)stab[j].st_size,
1271 (char*)stab[j].st_value ));
1273 IF_DEBUG(linker,fprintf(stderr, "type=" ));
1274 switch (ELF32_ST_TYPE(stab[j].st_info)) {
1275 case STT_NOTYPE: IF_DEBUG(linker,fprintf(stderr, "notype " )); break;
1276 case STT_OBJECT: IF_DEBUG(linker,fprintf(stderr, "object " )); break;
1277 case STT_FUNC : IF_DEBUG(linker,fprintf(stderr, "func " )); break;
1278 case STT_SECTION: IF_DEBUG(linker,fprintf(stderr, "section" )); break;
1279 case STT_FILE: IF_DEBUG(linker,fprintf(stderr, "file " )); break;
1280 default: IF_DEBUG(linker,fprintf(stderr, "? " )); break;
1282 IF_DEBUG(linker,fprintf(stderr, " " ));
1284 IF_DEBUG(linker,fprintf(stderr, "bind=" ));
1285 switch (ELF32_ST_BIND(stab[j].st_info)) {
1286 case STB_LOCAL : IF_DEBUG(linker,fprintf(stderr, "local " )); break;
1287 case STB_GLOBAL: IF_DEBUG(linker,fprintf(stderr, "global" )); break;
1288 case STB_WEAK : IF_DEBUG(linker,fprintf(stderr, "weak " )); break;
1289 default: IF_DEBUG(linker,fprintf(stderr, "? " )); break;
1291 IF_DEBUG(linker,fprintf(stderr, " " ));
1293 IF_DEBUG(linker,fprintf(stderr, "name=%s\n", strtab + stab[j].st_name ));
1297 if (nsymtabs == 0) {
1298 belch("ocVerifyImage_ELF: didn't find any symbol tables");
1307 ocGetNames_ELF ( ObjectCode* oc )
1312 char* ehdrC = (char*)(oc->image);
1313 Elf32_Ehdr* ehdr = (Elf32_Ehdr*)ehdrC;
1314 char* strtab = findElfSection ( ehdrC, SHT_STRTAB );
1315 Elf32_Shdr* shdr = (Elf32_Shdr*) (ehdrC + ehdr->e_shoff);
1316 char* sh_strtab = ehdrC + shdr[ehdr->e_shstrndx].sh_offset;
1319 belch("ocGetNames_ELF: no strtab");
1324 oc->sections = stgMallocBytes( ehdr->e_shnum * sizeof(Section),
1326 oc->n_sections = ehdr->e_shnum;
1328 for (i = 0; i < ehdr->e_shnum; i++) {
1330 /* make a section entry for relevant sections */
1331 SectionKind kind = SECTIONKIND_OTHER;
1332 if (!strcmp(".data",sh_strtab+shdr[i].sh_name) ||
1333 !strcmp(".data1",sh_strtab+shdr[i].sh_name))
1334 kind = SECTIONKIND_RWDATA;
1335 if (!strcmp(".text",sh_strtab+shdr[i].sh_name) ||
1336 !strcmp(".rodata",sh_strtab+shdr[i].sh_name) ||
1337 !strcmp(".rodata1",sh_strtab+shdr[i].sh_name))
1338 kind = SECTIONKIND_CODE_OR_RODATA;
1340 /* fill in the section info */
1341 oc->sections[i].start = ehdrC + shdr[i].sh_offset;
1342 oc->sections[i].end = ehdrC + shdr[i].sh_offset + shdr[i].sh_size - 1;
1343 oc->sections[i].kind = kind;
1345 if (shdr[i].sh_type != SHT_SYMTAB) continue;
1347 /* copy stuff into this module's object symbol table */
1348 stab = (Elf32_Sym*) (ehdrC + shdr[i].sh_offset);
1349 nent = shdr[i].sh_size / sizeof(Elf32_Sym);
1350 oc->symbols = malloc(nent * sizeof(SymbolVal));
1351 for (j = 0; j < nent; j++) {
1352 if ( ( ELF32_ST_BIND(stab[j].st_info)==STB_GLOBAL /* ||
1353 ELF32_ST_BIND(stab[j].st_info)==STB_LOCAL */
1355 /* and not an undefined symbol */
1356 && stab[j].st_shndx != SHN_UNDEF
1358 /* and it's a not a section or string table or anything silly */
1359 ( ELF32_ST_TYPE(stab[j].st_info)==STT_FUNC ||
1360 ELF32_ST_TYPE(stab[j].st_info)==STT_OBJECT ||
1361 ELF32_ST_TYPE(stab[j].st_info)==STT_NOTYPE )
1363 char* nm = strtab + stab[j].st_name;
1365 + shdr[ stab[j].st_shndx ].sh_offset
1369 IF_DEBUG(linker,belch( "addOTabName: %10p %s %s",
1370 ad, oc->fileName, nm ));
1371 oc->symbols[j].lbl = nm;
1372 oc->symbols[j].addr = ad;
1373 insertStrHashTable(symhash, nm, &(oc->symbols[j]));
1376 IF_DEBUG(linker,belch( "skipping `%s'", strtab +
1378 oc->symbols[j].lbl = NULL;
1379 oc->symbols[j].addr = NULL;
1389 ocResolve_ELF ( ObjectCode* oc )
1391 char *strtab, *symbol;
1393 Elf32_Sym* stab = NULL;
1394 char* ehdrC = (char*)(oc->image);
1395 Elf32_Ehdr* ehdr = (Elf32_Ehdr*) ehdrC;
1396 Elf32_Shdr* shdr = (Elf32_Shdr*) (ehdrC + ehdr->e_shoff);
1399 /* first find "the" symbol table */
1400 stab = (Elf32_Sym*) findElfSection ( ehdrC, SHT_SYMTAB );
1402 /* also go find the string table */
1403 strtab = findElfSection ( ehdrC, SHT_STRTAB );
1405 if (stab == NULL || strtab == NULL) {
1406 belch("ocResolve_ELF: can't find string or symbol table");
1410 for (i = 0; i < ehdr->e_shnum; i++) {
1411 if (shdr[i].sh_type == SHT_REL ) {
1412 Elf32_Rel* rtab = (Elf32_Rel*) (ehdrC + shdr[i].sh_offset);
1413 int nent = shdr[i].sh_size / sizeof(Elf32_Rel);
1414 int target_shndx = shdr[i].sh_info;
1415 int symtab_shndx = shdr[i].sh_link;
1416 stab = (Elf32_Sym*) (ehdrC + shdr[ symtab_shndx ].sh_offset);
1417 targ = (Elf32_Word*)(ehdrC + shdr[ target_shndx ].sh_offset);
1418 IF_DEBUG(linker,belch( "relocations for section %d using symtab %d",
1419 target_shndx, symtab_shndx ));
1420 for (j = 0; j < nent; j++) {
1421 Elf32_Addr offset = rtab[j].r_offset;
1422 Elf32_Word info = rtab[j].r_info;
1424 Elf32_Addr P = ((Elf32_Addr)targ) + offset;
1425 Elf32_Word* pP = (Elf32_Word*)P;
1429 IF_DEBUG(linker,belch( "Rel entry %3d is raw(%6p %6p) ",
1430 j, (void*)offset, (void*)info ));
1432 IF_DEBUG(linker,belch( " ZERO" ));
1435 /* First see if it is a nameless local symbol. */
1436 if (stab[ ELF32_R_SYM(info)].st_name == 0) {
1437 symbol = "(noname)";
1438 S = (Elf32_Addr)(ehdrC
1439 + shdr[stab[ELF32_R_SYM(info)].st_shndx ].sh_offset
1440 + stab[ELF32_R_SYM(info)].st_value
1443 /* No? Should be in the symbol table then. */
1444 symbol = strtab+stab[ ELF32_R_SYM(info)].st_name;
1445 (void *)S = lookupSymbol( symbol );
1448 barf("ocResolve_ELF: %s: unknown symbol `%s'",
1449 oc->fileName, symbol);
1451 IF_DEBUG(linker,belch( "`%s' resolves to %p", symbol, (void*)S ));
1453 IF_DEBUG(linker,fprintf ( stderr, "Reloc: P = %p S = %p A = %p\n", (void*)P, (void*)S, (void*)A ));
1454 switch (ELF32_R_TYPE(info)) {
1455 case R_386_32: *pP = S + A; break;
1456 case R_386_PC32: *pP = S + A - P; break;
1457 default: fprintf(stderr,
1458 "unhandled ELF relocation type %d",
1459 ELF32_R_TYPE(info));
1460 belch("ocResolve_ELF: unhandled ELF relocation type");
1467 if (shdr[i].sh_type == SHT_RELA) {
1468 belch("ocResolve_ELF: RelA style reloc table -- not yet done");
1479 /* -----------------------------------------------------------------------------
1480 * Look up an address to discover whether it is in text or data space.
1482 * Used by the garbage collector when walking the stack.
1483 * -------------------------------------------------------------------------- */
1485 static __inline__ SectionKind
1486 lookupSection ( void* addr )
1491 for ( oc = objects; oc; oc = oc->next ) {
1492 for (i = 0; i < oc->n_sections; i++) {
1493 if (oc->sections[i].start <= addr
1494 && addr <= oc->sections[i].end)
1495 return oc->sections[i].kind;
1498 return SECTIONKIND_OTHER;
1502 is_dynamically_loaded_code_or_rodata_ptr ( void* p )
1504 SectionKind sk = lookupSection(p);
1505 ASSERT (sk != SECTIONKIND_NOINFOAVAIL);
1506 return (sk == SECTIONKIND_CODE_OR_RODATA);
1511 is_dynamically_loaded_rwdata_ptr ( void* p )
1513 SectionKind sk = lookupSection(p);
1514 ASSERT (sk != SECTIONKIND_NOINFOAVAIL);
1515 return (sk == SECTIONKIND_RWDATA);
1520 is_not_dynamically_loaded_ptr ( void* p )
1522 SectionKind sk = lookupSection(p);
1523 ASSERT (sk != SECTIONKIND_NOINFOAVAIL);
1524 return (sk == SECTIONKIND_OTHER);