?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bug 497723 - forgot to restore callgrind output cleanup
[valgrind.git] / VEX / switchback / linker.c
blob8a4ed35a371b11a6835b6a5ec5415fd97f9b07dc
1 /*
2 13 Dec '05
3 Linker no longer used - apart from mymalloc().
4 Instead, simply compile and link switchback.c with test_xxx.c, e.g.:
5 ./> (cd .. && make EXTRA_CFLAGS="-m64" libvex_ppc64_linux.a) && gcc -m64 -Wall -O -g -o switchback switchback.c linker.c ../libvex_ppc64_linux.a test_bzip2.c
6 */
7
8
9 #include <stdlib.h>
10 #include <stdio.h>
11 #include <assert.h>
12 #include <sys/types.h>
13 #include <sys/stat.h>
14 #include <unistd.h>
15 #include <elf.h>
16 #include <fcntl.h>
17 #include <string.h>
18 //#include <malloc.h>
19
20 #include "linker.h"
21
22 #include "../pub/libvex_basictypes.h"
23
24 #if 0
25 #define IF_DEBUG(x,y) /* */
26 static int debug_linker = 0;
27 #endif
28
29
30 #if defined(__x86_64__)
31 # define x86_64_TARGET_ARCH
32 #elif defined(__i386__)
33 # define i386_TARGET_ARCH
34 #elif defined (__powerpc__)
35 # define ppc32_TARGET_ARCH
36 #elif defined(__aarch64__)
37 # define arm64_TARGET_ARCH
38 #else
39 # error "Unknown arch"
40 #endif
41
42
43 #if 0
44 #define CALLOC_MAX 10000000
45 static HChar calloc_area[CALLOC_MAX];
46 static UInt calloc_used = 0;
47 static void* calloc_below2G ( Int n, Int m )
48 {
49 void* p;
50 int i;
51 while ((calloc_used % 16) > 0) calloc_used++;
52 assert(calloc_used + n*m < CALLOC_MAX);
53 p = &calloc_area[calloc_used];
54 for (i = 0; i < n*m; i++)
55 calloc_area[calloc_used+i] = 0;
56 calloc_used += n*m;
57 return p;
58 }
59 #endif
60
61 #define MYMALLOC_MAX 50*1000*1000
62 static HChar mymalloc_area[MYMALLOC_MAX];
63 static UInt mymalloc_used = 0;
64 void* mymalloc ( Int n )
65 {
66 void* p;
67 #if defined(__powerpc64__) || defined(__aarch64__)
68 while ((ULong)(mymalloc_area+mymalloc_used) & 0xFFF)
69 #else
70 while ((UInt)(mymalloc_area+mymalloc_used) & 0xFFF)
71 #endif
72 mymalloc_used++;
73 assert(mymalloc_used+n < MYMALLOC_MAX);
74 p = (void*)(&mymalloc_area[mymalloc_used]);
75 mymalloc_used += n;
76 // printf("mymalloc(%d) = %p\n", n, p);
77 return p;
78 }
79
80 void myfree ( void* p )
81 {
82 }
83
84
85
86
87
88
89
90 #if 0
91 ///////////////////////////////////////////////////////////////////
92 ///////////////////////////////////////////////////////////////////
93 ///////////////////////////////////////////////////////////////////
94 //
95 // TYPES
96
97 #define FALSE 0
98 #define TRUE 1
99
100 typedef enum { OBJECT_LOADED, OBJECT_RESOLVED } OStatus;
101
102
103 #define N_FIXUP_PAGES 1
104
105
106 /* Indication of section kinds for loaded objects. Needed by
107 the GC for deciding whether or not a pointer on the stack
108 is a code pointer.
109 */
110 typedef
111 enum { SECTIONKIND_CODE_OR_RODATA,
112 SECTIONKIND_RWDATA,
113 SECTIONKIND_OTHER,
114 SECTIONKIND_NOINFOAVAIL }
115 SectionKind;
116
117 typedef
118 struct _Section {
119 void* start;
120 void* end;
121 SectionKind kind;
122 struct _Section* next;
123 }
124 Section;
125
126 typedef
127 struct _ProddableBlock {
128 void* start;
129 int size;
130 struct _ProddableBlock* next;
131 }
132 ProddableBlock;
133
134 /* Top-level structure for an object module. One of these is allocated
135 * for each object file in use.
136 */
137 typedef struct _ObjectCode {
138 OStatus status;
139 char* fileName;
140 int fileSize;
141 char* formatName; /* eg "ELF32", "DLL", "COFF", etc. */
142
143 /* An array containing ptrs to all the symbol names copied from
144 this object into the global symbol hash table. This is so that
145 we know which parts of the latter mapping to nuke when this
146 object is removed from the system. */
147 char** symbols;
148 int n_symbols;
149
150 /* ptr to malloc'd lump of memory holding the obj file */
151 void* image;
152
153 /* Fixup area for long-distance jumps. */
154 char* fixup;
155 int fixup_used;
156 int fixup_size;
157
158 /* The section-kind entries for this object module. Linked
159 list. */
160 Section* sections;
161
162 /* A private hash table for local symbols. */
163 /* HashTable* */ void* lochash;
164
165 /* Allow a chain of these things */
166 struct _ObjectCode * next;
167
168 /* SANITY CHECK ONLY: a list of the only memory regions which may
169 safely be prodded during relocation. Any attempt to prod
170 outside one of these is an error in the linker. */
171 ProddableBlock* proddables;
172
173 } ObjectCode;
174
175 /*
176 * Define a set of types which can be used for both ELF32 and ELF64
177 */
178
179 #if VEX_HOST_WORDSIZE == 8
180 #define ELFCLASS ELFCLASS64
181 #define Elf_Addr Elf64_Addr
182 #define Elf_Word Elf64_Word
183 #define Elf_Sword Elf64_Sword
184 #define Elf_Ehdr Elf64_Ehdr
185 #define Elf_Phdr Elf64_Phdr
186 #define Elf_Shdr Elf64_Shdr
187 #define Elf_Sym Elf64_Sym
188 #define Elf_Rel Elf64_Rel
189 #define Elf_Rela Elf64_Rela
190 #define ELF_ST_TYPE ELF64_ST_TYPE
191 #define ELF_ST_BIND ELF64_ST_BIND
192 #define ELF_R_TYPE ELF64_R_TYPE
193 #define ELF_R_SYM ELF64_R_SYM
194 #else
195 #define ELFCLASS ELFCLASS32
196 #define Elf_Addr Elf32_Addr
197 #define Elf_Word Elf32_Word
198 #define Elf_Sword Elf32_Sword
199 #define Elf_Ehdr Elf32_Ehdr
200 #define Elf_Phdr Elf32_Phdr
201 #define Elf_Shdr Elf32_Shdr
202 #define Elf_Sym Elf32_Sym
203 #define Elf_Rel Elf32_Rel
204 #define Elf_Rela Elf32_Rela
205 #ifndef ELF_ST_TYPE
206 #define ELF_ST_TYPE ELF32_ST_TYPE
207 #endif
208 #ifndef ELF_ST_BIND
209 #define ELF_ST_BIND ELF32_ST_BIND
210 #endif
211 #ifndef ELF_R_TYPE
212 #define ELF_R_TYPE ELF32_R_TYPE
213 #endif
214 #ifndef ELF_R_SYM
215 #define ELF_R_SYM ELF32_R_SYM
216 #endif
217 #endif
218
219
220
221
222 ///////////////////////////////////////////////////////////////////
223 ///////////////////////////////////////////////////////////////////
224 ///////////////////////////////////////////////////////////////////
225 //
226 // PARANOIA
227
228 /* -----------------------------------------------------------------------
229 * Sanity checking. For each ObjectCode, maintain a list of address ranges
230 * which may be prodded during relocation, and abort if we try and write
231 * outside any of these.
232 */
233 static void addProddableBlock ( ObjectCode* oc, void* start, int size )
234 {
235 ProddableBlock* pb
236 = mymalloc(sizeof(ProddableBlock));
237 if (debug_linker)
238 fprintf(stderr, "aPB oc=%p %p %d (%p .. %p)\n", oc, start, size,
239 start, ((char*)start)+size-1 );
240 assert(size > 0);
241 pb->start = start;
242 pb->size = size;
243 pb->next = oc->proddables;
244 oc->proddables = pb;
245 }
246
247 static void checkProddableBlock ( ObjectCode* oc, void* addr )
248 {
249 ProddableBlock* pb;
250 for (pb = oc->proddables; pb != NULL; pb = pb->next) {
251 char* s = (char*)(pb->start);
252 char* e = s + pb->size - 1;
253 char* a = (char*)addr;
254 /* Assumes that the biggest fixup involves a 4-byte write. This
255 probably needs to be changed to 8 (ie, +7) on 64-bit
256 plats. */
257 if (a >= s && (a+3) <= e) return;
258 }
259 fprintf(stderr,
260 "checkProddableBlock: invalid fixup %p in runtime linker\n",
261 addr);
262 exit(1);
263 }
264
265
266
267 ///////////////////////////////////////////////////////////////////
268 ///////////////////////////////////////////////////////////////////
269 ///////////////////////////////////////////////////////////////////
270 //
271 // String->Addr mappings
272
273 typedef
274 struct { char* mp_name; void* mp_addr; }
275 Maplet;
276
277 typedef
278 struct {
279 int sm_size;
280 int sm_used;
281 Maplet* maplets;
282 }
283 StringMap;
284
285 static StringMap* new_StringMap ( void )
286 {
287 StringMap* sm = mymalloc(sizeof(StringMap));
288 sm->sm_size = 10;
289 sm->sm_used = 0;
290 sm->maplets = mymalloc(10 * sizeof(Maplet));
291 return sm;
292 }
293
294 static void delete_StringMap ( StringMap* sm )
295 {
296 assert(sm->maplets != NULL);
297 myfree(sm->maplets);
298 sm->maplets = NULL;
299 myfree(sm);
300 }
301
302 static void ensure_StringMap ( StringMap* sm )
303 {
304 int i;
305 Maplet* mp2;
306 assert(sm->maplets != NULL);
307 if (sm->sm_used < sm->sm_size)
308 return;
309 sm->sm_size *= 2;
310 mp2 = mymalloc(sm->sm_size * sizeof(Maplet));
311 for (i = 0; i < sm->sm_used; i++)
312 mp2[i] = sm->maplets[i];
313 myfree(sm->maplets);
314 sm->maplets = mp2;
315 }
316
317 static void* search_StringMap ( StringMap* sm, char* name )
318 {
319 int i;
320 for (i = 0; i < sm->sm_used; i++)
321 if (0 == strcmp(name, sm->maplets[i].mp_name))
322 return sm->maplets[i].mp_addr;
323 return NULL;
324 }
325
326 static void addto_StringMap ( StringMap* sm, char* name, void* addr )
327 {
328 ensure_StringMap(sm);
329 sm->maplets[sm->sm_used].mp_name = name;
330 sm->maplets[sm->sm_used].mp_addr = addr;
331 sm->sm_used++;
332 }
333
334 static void paranoid_addto_StringMap ( StringMap* sm, char* name, void* addr )
335 {
336 if (0)
337 fprintf(stderr, "paranoid_addto_StringMap(%s,%p)\n", name, addr);
338 if (search_StringMap(sm,name) != NULL) {
339 fprintf(stderr, "duplicate: paranoid_addto_StringMap(%s,%p)\n", name, addr);
340 exit(1);
341 }
342 addto_StringMap(sm,name,addr);
343 }
344
345
346 ///////////////////////////////////////////////////////////////////
347 ///////////////////////////////////////////////////////////////////
348 ///////////////////////////////////////////////////////////////////
349 //
350 // Top-level linker control.
351
352 StringMap* global_symbol_table = NULL;
353 ObjectCode* global_object_list = NULL;
354
355 static void initLinker ( void )
356 {
357 if (global_symbol_table != NULL)
358 return;
359 global_symbol_table = new_StringMap();
360 }
361
362
363
364 ///////////////////////////////////////////////////////////////////
365 ///////////////////////////////////////////////////////////////////
366 ///////////////////////////////////////////////////////////////////
367 //
368 // SYMBOL TABLE(s)
369
370 /* -----------------------------------------------------------------
371 * lookup a symbol in the global symbol table
372 */
373 static
374 void * lookupSymbol( char *lbl )
375 {
376 void *val;
377 initLinker() ;
378 assert(global_symbol_table != NULL);
379 val = search_StringMap(global_symbol_table, lbl);
380 return val;
381 }
382
383
384 ///////////////////////////////////////////////////////////////////
385 ///////////////////////////////////////////////////////////////////
386 ///////////////////////////////////////////////////////////////////
387 //
388 // HELPERS
389
390 /*
391 * Generic ELF functions
392 */
393
394 static char *
395 findElfSection ( void* objImage, Elf_Word sh_type )
396 {
397 char* ehdrC = (char*)objImage;
398 Elf_Ehdr* ehdr = (Elf_Ehdr*)ehdrC;
399 Elf_Shdr* shdr = (Elf_Shdr*)(ehdrC + ehdr->e_shoff);
400 char* sh_strtab = ehdrC + shdr[ehdr->e_shstrndx].sh_offset;
401 char* ptr = NULL;
402 int i;
403
404 for (i = 0; i < ehdr->e_shnum; i++) {
405 if (shdr[i].sh_type == sh_type
406 /* Ignore the section header's string table. */
407 && i != ehdr->e_shstrndx
408 /* Ignore string tables named .stabstr, as they contain
409 debugging info. */
410 && 0 != memcmp(".stabstr", sh_strtab + shdr[i].sh_name, 8)
411 ) {
412 ptr = ehdrC + shdr[i].sh_offset;
413 break;
414 }
415 }
416 return ptr;
417 }
418
419 #ifdef arm_TARGET_ARCH
420 static
421 char* alloc_fixup_bytes ( ObjectCode* oc, int nbytes )
422 {
423 char* res;
424 assert(nbytes % 4 == 0);
425 assert(nbytes > 0);
426 res = &(oc->fixup[oc->fixup_used]);
427 oc->fixup_used += nbytes;
428 if (oc->fixup_used >= oc->fixup_size) {
429 fprintf(stderr, "fixup area too small for %s\n", oc->fileName);
430 exit(1);
431 }
432 return res;
433 }
434 #endif
435
436
437 ///////////////////////////////////////////////////////////////////
438 ///////////////////////////////////////////////////////////////////
439 ///////////////////////////////////////////////////////////////////
440 //
441 // RESOLVE
442
443 static
444 void* lookup_magic_hacks ( char* sym )
445 {
446 if (0==strcmp(sym, "printf")) return (void*)(&printf);
447 return NULL;
448 }
449
450 #ifdef arm_TARGET_ARCH
451 static
452 void arm_notify_new_code ( char* start, int length )
453 {
454 __asm __volatile ("mov r1, %0\n\t"
455 "mov r2, %1\n\t"
456 "mov r3, %2\n\t"
457 "swi 0x9f0002\n\t"
458 :
459 : "ir" (start), "ir" (length), "ir" (0) );
460 }
461
462
463 static
464 void gen_armle_goto ( char* fixup, char* dstP )
465 {
466 Elf_Word w = (Elf_Word)dstP;
467 /*
468 2 .text
469 3 0000 04F01FE5 ldr pc, value
470 4 0004 44332211 value: .word 0x11223344
471 */
472 fprintf(stderr,"at %p generating jump to %p\n", fixup, dstP );
473 fixup[0] = 0x04; fixup[1] = 0xF0; fixup[2] = 0x1F; fixup[3] = 0xE5;
474 fixup[4] = w & 0xFF; w >>= 8;
475 fixup[5] = w & 0xFF; w >>= 8;
476 fixup[6] = w & 0xFF; w >>= 8;
477 fixup[7] = w & 0xFF; w >>= 8;
478 arm_notify_new_code(fixup, 8);
479 }
480 #endif /* arm_TARGET_ARCH */
481
482
483 #ifdef ppc32_TARGET_ARCH
484 static void invalidate_icache(void *ptr, int nbytes)
485 {
486 unsigned long startaddr = (unsigned long) ptr;
487 unsigned long endaddr = startaddr + nbytes;
488 unsigned long addr;
489 unsigned long cls = 16; //VG_(cache_line_size);
490
491 startaddr &= ~(cls - 1);
492 for (addr = startaddr; addr < endaddr; addr += cls)
493 asm volatile("dcbst 0,%0" : : "r" (addr));
494 asm volatile("sync");
495 for (addr = startaddr; addr < endaddr; addr += cls)
496 asm volatile("icbi 0,%0" : : "r" (addr));
497 asm volatile("sync; isync");
498 }
499
500 static UInt compute_ppc_HA ( UInt x ) {
501 return 0xFFFF & ( (x >> 16) + ((x & 0x8000) ? 1 : 0) );
502 }
503 static UInt compute_ppc_LO ( UInt x ) {
504 return 0xFFFF & x;
505 }
506 static UInt compute_ppc_HI ( UInt x ) {
507 return 0xFFFF & (x >> 16);
508 }
509 #endif /* ppc32_TARGET_ARCH */
510
511
512 /* Do ELF relocations which lack an explicit addend. All x86-linux
513 relocations appear to be of this form. */
514 static int
515 do_Elf_Rel_relocations ( ObjectCode* oc, char* ehdrC,
516 Elf_Shdr* shdr, int shnum,
517 Elf_Sym* stab, char* strtab )
518 {
519 int j;
520 char *symbol = NULL;
521 Elf_Word* targ;
522 Elf_Rel* rtab = (Elf_Rel*) (ehdrC + shdr[shnum].sh_offset);
523 int nent = shdr[shnum].sh_size / sizeof(Elf_Rel);
524 int target_shndx = shdr[shnum].sh_info;
525 int symtab_shndx = shdr[shnum].sh_link;
526
527 stab = (Elf_Sym*) (ehdrC + shdr[ symtab_shndx ].sh_offset);
528 targ = (Elf_Word*)(ehdrC + shdr[ target_shndx ].sh_offset);
529 IF_DEBUG(linker,belch( "relocations for section %d using symtab %d",
530 target_shndx, symtab_shndx ));
531
532 for (j = 0; j < nent; j++) {
533 Elf_Addr offset = rtab[j].r_offset;
534 Elf_Addr info = rtab[j].r_info;
535
536 Elf_Addr P = ((Elf_Addr)targ) + offset;
537 Elf_Word* pP = (Elf_Word*)P;
538 Elf_Addr A = *pP;
539 Elf_Addr S;
540 Elf_Addr value;
541
542 IF_DEBUG(linker,belch( "Rel entry %3d is raw(%6p %6p)",
543 j, (void*)offset, (void*)info ));
544 if (!info) {
545 IF_DEBUG(linker,belch( " ZERO" ));
546 S = 0;
547 } else {
548 Elf_Sym sym = stab[ELF_R_SYM(info)];
549 /* First see if it is a local symbol. */
550 if (ELF_ST_BIND(sym.st_info) == STB_LOCAL) {
551 /* Yes, so we can get the address directly from the ELF symbol
552 table. */
553 symbol = sym.st_name==0 ? "(noname)" : strtab+sym.st_name;
554 S = (Elf_Addr)
555 (ehdrC + shdr[ sym.st_shndx ].sh_offset
556 + stab[ELF_R_SYM(info)].st_value);
557
558 } else {
559 /* No, so look up the name in our global table. */
560 symbol = strtab + sym.st_name;
561 S = (Elf_Addr)lookupSymbol( symbol );
562 }
563 if (!S) {
564 S = (Elf_Addr)lookup_magic_hacks(symbol);
565 }
566 if (!S) {
567 fprintf(stderr,"%s: unknown symbol `%s'\n",
568 oc->fileName, symbol);
569 return 0;
570 }
571 if (debug_linker>1)
572 fprintf(stderr, "\n`%s' resolves to %p\n", symbol, (void*)S );
573 }
574
575 if (debug_linker>1)
576 fprintf(stderr, "Reloc: P = %p S = %p A = %p\n",
577 (void*)P, (void*)S, (void*)A );
578 checkProddableBlock ( oc, pP );
579
580 value = S + A;
581
582 switch (ELF_R_TYPE(info)) {
583 # ifdef i386_TARGET_ARCH
584 case R_386_32: *pP = value; break;
585 case R_386_PC32: *pP = value - P; break;
586 # endif
587 # ifdef arm_TARGET_ARCH
588 case R_ARM_PC24: {
589 Elf_Word w, delta, deltaTop8;
590 /* Generate a jump sequence into the fixup area
591 and branch to that instead. */
592 char* fixup = alloc_fixup_bytes(oc, 8);
593 /* First of all, figure out where we're really trying to
594 jump to. */
595 // compensate for pc+8 bias
596 Elf_Word real_dst = (A & 0x00FFFFFF) + 2;
597 // sign-extend 24-to-32 of real_dst
598 if (real_dst & 0x00800000)
599 real_dst |= 0xFF000000;
600 else
601 real_dst &= 0x00FFFFFF;
602
603 real_dst <<= 2;
604 real_dst += S;
605
606 gen_armle_goto(fixup, (char*)real_dst);
607
608 /* Delta is in bytes .. */
609 delta = (((Elf_Word)fixup) - ((Elf_Word)pP) - 8);
610 deltaTop8 = (delta >> 24) & 0xFF;
611 if (deltaTop8 != 0 && deltaTop8 != 0xFF) {
612 fprintf(stderr,"R_ARM_PC24: out of range delta 0x%x for %s\n",
613 delta, symbol);
614 exit(1);
615 }
616 delta >>= 2;
617 w = *pP;
618 w &= 0xFF000000;
619 w |= (0x00FFFFFF & delta );
620 *pP = w;
621 break;
622 }
623 case R_ARM_ABS32:
624 *pP = value;
625 break;
626 # endif
627 default:
628 fprintf(stderr,
629 "%s: unhandled ELF relocation(Rel) type %d\n\n",
630 oc->fileName, (Int)ELF_R_TYPE(info));
631 return 0;
632 }
633
634 }
635 return 1;
636 }
637
638 /* Do ELF relocations for which explicit addends are supplied.
639 sparc-solaris relocations appear to be of this form. */
640 static int
641 do_Elf_Rela_relocations ( ObjectCode* oc, char* ehdrC,
642 Elf_Shdr* shdr, int shnum,
643 Elf_Sym* stab, char* strtab )
644 {
645 int j;
646 char *symbol;
647 Elf_Addr targ;
648 Elf_Rela* rtab = (Elf_Rela*) (ehdrC + shdr[shnum].sh_offset);
649 int nent = shdr[shnum].sh_size / sizeof(Elf_Rela);
650 int target_shndx = shdr[shnum].sh_info;
651 int symtab_shndx = shdr[shnum].sh_link;
652
653 stab = (Elf_Sym*) (ehdrC + shdr[ symtab_shndx ].sh_offset);
654 targ = (Elf_Addr) (ehdrC + shdr[ target_shndx ].sh_offset);
655 IF_DEBUG(linker,belch( "relocations for section %d using symtab %d",
656 target_shndx, symtab_shndx ));
657
658 for (j = 0; j < nent; j++) {
659 #if defined(DEBUG) || defined(sparc_TARGET_ARCH) \
660 || defined(ia64_TARGET_ARCH) \
661 || defined(x86_64_TARGET_ARCH) \
662 || defined(ppc32_TARGET_ARCH)
663 /* This #ifdef only serves to avoid unused-var warnings. */
664 Elf_Addr offset = rtab[j].r_offset;
665 Elf_Addr P = targ + offset;
666 #endif
667 Elf_Addr info = rtab[j].r_info;
668 Elf_Addr A = rtab[j].r_addend;
669 Elf_Addr S =0;
670 Elf_Addr value;
671 # if defined(sparc_TARGET_ARCH)
672 Elf_Word* pP = (Elf_Word*)P;
673 Elf_Word w1, w2;
674 # endif
675 # if defined(ia64_TARGET_ARCH)
676 Elf64_Xword *pP = (Elf64_Xword *)P;
677 Elf_Addr addr;
678 # endif
679 # if defined(x86_64_TARGET_ARCH)
680 ULong* pP = (ULong*)P;
681 # endif
682 # if defined(ppc32_TARGET_ARCH)
683 Int sI, sI2;
684 Elf_Word* pP = (Elf_Word*)P;
685 # endif
686
687 IF_DEBUG(linker,belch( "Rel entry %3d is raw(%6p %6p %6p) ",
688 j, (void*)offset, (void*)info,
689 (void*)A ));
690 if (!info) {
691 IF_DEBUG(linker,belch( " ZERO" ));
692 S = 0;
693 } else {
694 Elf_Sym sym = stab[ELF_R_SYM(info)];
695 /* First see if it is a local symbol. */
696 if (ELF_ST_BIND(sym.st_info) == STB_LOCAL) {
697 /* Yes, so we can get the address directly from the ELF symbol
698 table. */
699 symbol = sym.st_name==0 ? "(noname)" : strtab+sym.st_name;
700 S = (Elf_Addr)
701 (ehdrC + shdr[ sym.st_shndx ].sh_offset
702 + stab[ELF_R_SYM(info)].st_value);
703 #ifdef ELF_FUNCTION_DESC
704 /* Make a function descriptor for this function */
705 if (S && ELF_ST_TYPE(sym.st_info) == STT_FUNC) {
706 S = allocateFunctionDesc(S + A);
707 A = 0;
708 }
709 #endif
710 } else {
711 /* No, so look up the name in our global table. */
712 symbol = strtab + sym.st_name;
713 S = (Elf_Addr)lookupSymbol( symbol );
714
715 #ifdef ELF_FUNCTION_DESC
716 /* If a function, already a function descriptor - we would
717 have to copy it to add an offset. */
718 if (S && (ELF_ST_TYPE(sym.st_info) == STT_FUNC) && (A != 0))
719 belch("%s: function %s with addend %p", oc->fileName, symbol, (void *)A);
720 #endif
721 }
722 if (!S) {
723 fprintf(stderr,"%s: unknown symbol `%s'\n", oc->fileName, symbol);
724 return 0;
725 }
726 if (0)
727 fprintf(stderr, "`%s' resolves to %p\n", symbol, (void*)S );
728 }
729
730 #if 0
731 fprintf ( stderr, "Reloc: offset = %p P = %p S = %p A = %p\n",
732 (void*)offset, (void*)P, (void*)S, (void*)A );
733 #endif
734
735 /* checkProddableBlock ( oc, (void*)P ); */
736
737 value = S + A;
738
739 switch (ELF_R_TYPE(info)) {
740 # if defined(sparc_TARGET_ARCH)
741 case R_SPARC_WDISP30:
742 w1 = *pP & 0xC0000000;
743 w2 = (Elf_Word)((value - P) >> 2);
744 ASSERT((w2 & 0xC0000000) == 0);
745 w1 |= w2;
746 *pP = w1;
747 break;
748 case R_SPARC_HI22:
749 w1 = *pP & 0xFFC00000;
750 w2 = (Elf_Word)(value >> 10);
751 ASSERT((w2 & 0xFFC00000) == 0);
752 w1 |= w2;
753 *pP = w1;
754 break;
755 case R_SPARC_LO10:
756 w1 = *pP & ~0x3FF;
757 w2 = (Elf_Word)(value & 0x3FF);
758 ASSERT((w2 & ~0x3FF) == 0);
759 w1 |= w2;
760 *pP = w1;
761 break;
762 /* According to the Sun documentation:
763 R_SPARC_UA32
764 This relocation type resembles R_SPARC_32, except it refers to an
765 unaligned word. That is, the word to be relocated must be treated
766 as four separate bytes with arbitrary alignment, not as a word
767 aligned according to the architecture requirements.
768
769 (JRS: which means that freeloading on the R_SPARC_32 case
770 is probably wrong, but hey ...)
771 */
772 case R_SPARC_UA32:
773 case R_SPARC_32:
774 w2 = (Elf_Word)value;
775 *pP = w2;
776 break;
777 # endif
778 # if defined(ia64_TARGET_ARCH)
779 case R_IA64_DIR64LSB:
780 case R_IA64_FPTR64LSB:
781 *pP = value;
782 break;
783 case R_IA64_PCREL64LSB:
784 *pP = value - P;
785 break;
786 case R_IA64_SEGREL64LSB:
787 addr = findElfSegment(ehdrC, value);
788 *pP = value - addr;
789 break;
790 case R_IA64_GPREL22:
791 ia64_reloc_gprel22(P, value);
792 break;
793 case R_IA64_LTOFF22:
794 case R_IA64_LTOFF22X:
795 case R_IA64_LTOFF_FPTR22:
796 addr = allocateGOTEntry(value);
797 ia64_reloc_gprel22(P, addr);
798 break;
799 case R_IA64_PCREL21B:
800 ia64_reloc_pcrel21(P, S, oc);
801 break;
802 case R_IA64_LDXMOV:
803 /* This goes with R_IA64_LTOFF22X and points to the load to
804 convert into a move. We don't implement relaxation. */
805 break;
806 # endif
807 # if defined(x86_64_TARGET_ARCH)
808 case R_X86_64_64: /* 1 *//* Direct 64 bit */
809 *((ULong*)pP) = (ULong)(S + A);
810 break;
811 case R_X86_64_PC32: /* 2 *//* PC relative 32 bit signed */
812 *((UInt*)pP) = (UInt)(S + A - P);
813 break;
814 case R_X86_64_32: /* 10 *//* Direct 32 bit zero extended */
815 *((UInt*)pP) = (UInt)(S + A);
816 break;
817 case R_X86_64_32S: /* 11 *//* Direct 32 bit sign extended */
818 *((UInt*)pP) = (UInt)(S + A);
819 break;
820 # endif
821 # if defined(ppc32_TARGET_ARCH)
822 case R_PPC_ADDR32: /* 1 *//* 32bit absolute address */
823 *((UInt*)pP) = S+A;
824 invalidate_icache(pP,4);
825 break;
826 case R_PPC_ADDR16_LO: /* 4 *//* lower 16bit of absolute address */
827 *((UInt*)pP) &= 0x0000FFFF;
828 *((UInt*)pP) |= 0xFFFF0000 & (compute_ppc_LO(S+A) << 16);
829 invalidate_icache(pP,4);
830 break;
831 case R_PPC_ADDR16_HA: /* 6 *//* adjusted high 16bit */
832 *((UInt*)pP) &= 0x0000FFFF;
833 *((UInt*)pP) |= 0xFFFF0000 & (compute_ppc_HA(S+A) << 16);
834 invalidate_icache(pP,4);
835 break;
836 case R_PPC_REL24: /* 10 *//* PC relative 26 bit */
837 sI = S+A-P;
838 sI >>= 2;
839 /* the top 9 bits of sI must be the same (all 0s or
840 all 1s) for this to be valid; else we have to fail. */
841 sI2 = sI >> 23; /* 23 == 32 - 9 */
842 if (sI2 != 0 && sI2 != 0xFFFFFFFF) {
843 fprintf(stderr, "%s: R_PPC_REL24 relocation failed\n", oc->fileName );
844 return 0;
845 }
846 *((UInt*)pP) &= ~(0x00FFFFFF << 2);
847 *((UInt*)pP) |= (0xFFFFFF & sI) << 2;
848 invalidate_icache(pP,4);
849 break;
850 case R_PPC_REL32: /* 26 */
851 *((UInt*)pP) = S+A-P;
852 invalidate_icache(pP,4);
853 break;
854 # endif
855 default:
856 fprintf(stderr,
857 "%s: unhandled ELF relocation(RelA) type %d\n",
858 oc->fileName, (Int)ELF_R_TYPE(info));
859 return 0;
860 }
861
862 }
863 return 1;
864 }
865
866
867 static int
868 ocResolve_ELF ( ObjectCode* oc )
869 {
870 char *strtab;
871 int shnum, ok;
872 Elf_Sym* stab = NULL;
873 char* ehdrC = (char*)(oc->image);
874 Elf_Ehdr* ehdr = (Elf_Ehdr*) ehdrC;
875 Elf_Shdr* shdr = (Elf_Shdr*) (ehdrC + ehdr->e_shoff);
876 char* sh_strtab = ehdrC + shdr[ehdr->e_shstrndx].sh_offset;
877
878 /* first find "the" symbol table */
879 stab = (Elf_Sym*) findElfSection ( ehdrC, SHT_SYMTAB );
880
881 /* also go find the string table */
882 strtab = findElfSection ( ehdrC, SHT_STRTAB );
883
884 if (stab == NULL || strtab == NULL) {
885 fprintf(stderr,"%s: can't find string or symbol table\n", oc->fileName);
886 return 0;
887 }
888
889 /* Process the relocation sections. */
890 for (shnum = 0; shnum < ehdr->e_shnum; shnum++) {
891
892 /* Skip sections called ".rel.stab". These appear to contain
893 relocation entries that, when done, make the stabs debugging
894 info point at the right places. We ain't interested in all
895 dat jazz, mun. */
896 if (0 == memcmp(".rel.stab", sh_strtab + shdr[shnum].sh_name, 9))
897 continue;
898
899 if (shdr[shnum].sh_type == SHT_REL ) {
900 ok = do_Elf_Rel_relocations ( oc, ehdrC, shdr,
901 shnum, stab, strtab );
902 if (!ok) return ok;
903 }
904 else
905 if (shdr[shnum].sh_type == SHT_RELA) {
906 ok = do_Elf_Rela_relocations ( oc, ehdrC, shdr,
907 shnum, stab, strtab );
908 if (!ok) return ok;
909 }
910 }
911
912 /* Free the local symbol table; we won't need it again. */
913 delete_StringMap(oc->lochash);
914 oc->lochash = NULL;
915
916 return 1;
917 }
918
919
920 ///////////////////////////////////////////////////////////////////
921 ///////////////////////////////////////////////////////////////////
922 ///////////////////////////////////////////////////////////////////
923 //
924 // VERIFY
925
926 static int
927 ocVerifyImage_ELF ( ObjectCode* oc )
928 {
929 Elf_Shdr* shdr;
930 Elf_Sym* stab;
931 int i, j, nent, nstrtab, nsymtabs;
932 char* sh_strtab;
933 char* strtab;
934
935 char* ehdrC = (char*)(oc->image);
936 Elf_Ehdr* ehdr = (Elf_Ehdr*)ehdrC;
937
938 if (ehdr->e_ident[EI_MAG0] != ELFMAG0 ||
939 ehdr->e_ident[EI_MAG1] != ELFMAG1 ||
940 ehdr->e_ident[EI_MAG2] != ELFMAG2 ||
941 ehdr->e_ident[EI_MAG3] != ELFMAG3) {
942 fprintf(stderr,"%s: not an ELF object\n", oc->fileName);
943 return 0;
944 }
945
946 if (ehdr->e_ident[EI_CLASS] != ELFCLASS) {
947 fprintf(stderr,"%s: unsupported ELF format\n", oc->fileName);
948 return 0;
949 }
950
951 if (ehdr->e_ident[EI_DATA] == ELFDATA2LSB) {
952 if (debug_linker)
953 fprintf(stderr, "Is little-endian\n" );
954 } else
955 if (ehdr->e_ident[EI_DATA] == ELFDATA2MSB) {
956 if (debug_linker)
957 fprintf(stderr, "Is big-endian\n" );
958 } else {
959 fprintf(stderr,"%s: unknown endiannness\n", oc->fileName);
960 return 0;
961 }
962
963 if (ehdr->e_type != ET_REL) {
964 fprintf(stderr,"%s: not a relocatable object (.o) file\n", oc->fileName);
965 return 0;
966 }
967 if (debug_linker)
968 fprintf(stderr, "Is a relocatable object (.o) file\n" );
969
970 if (debug_linker)
971 fprintf(stderr, "Architecture is " );
972 switch (ehdr->e_machine) {
973 case EM_386: if (debug_linker) fprintf(stderr, "x86\n" ); break;
974 case EM_SPARC: if (debug_linker) fprintf(stderr, "sparc\n" ); break;
975 case EM_ARM: if (debug_linker) fprintf(stderr, "arm\n" ); break;
976 #ifdef EM_IA_64
977 case EM_IA_64: if (debug_linker) fprintf(stderr, "ia64\n" ); break;
978 #endif
979 case EM_X86_64: if (debug_linker) fprintf(stderr, "x86_64\n" ); break;
980 case EM_PPC: if (debug_linker) fprintf(stderr, "ppc\n" ); break;
981 default: if (debug_linker) fprintf(stderr, "unknown\n" );
982 fprintf(stderr,"%s: unknown architecture\n", oc->fileName);
983 return 0;
984 }
985
986 if (debug_linker>1) fprintf(stderr,
987 "\nSection header table: start %lld, n_entries %d, ent_size %d\n",
988 (Long)ehdr->e_shoff,
989 ehdr->e_shnum, ehdr->e_shentsize );
990
991 assert (ehdr->e_shentsize == sizeof(Elf_Shdr));
992
993 shdr = (Elf_Shdr*) (ehdrC + ehdr->e_shoff);
994
995 if (ehdr->e_shstrndx == SHN_UNDEF) {
996 fprintf(stderr,"%s: no section header string table\n", oc->fileName);
997 return 0;
998 } else {
999 if (debug_linker>1)
1000 fprintf(stderr, "Section header string table is section %d\n",
1001 ehdr->e_shstrndx);
1002 sh_strtab = ehdrC + shdr[ehdr->e_shstrndx].sh_offset;
1003 }
1004
1005 for (i = 0; i < ehdr->e_shnum; i++) {
1006 if (debug_linker>1) fprintf(stderr, "%2d: ", i );
1007 if (debug_linker>1) fprintf(stderr, "type=%2d ", (int)shdr[i].sh_type );
1008 if (debug_linker>1) fprintf(stderr, "size=%4d ", (int)shdr[i].sh_size );
1009 if (debug_linker>1) fprintf(stderr, "offs=%4d ", (int)shdr[i].sh_offset );
1010 if (debug_linker>1) fprintf(stderr, " (%p .. %p) ",
1011 ehdrC + shdr[i].sh_offset,
1012 ehdrC + shdr[i].sh_offset + shdr[i].sh_size - 1);
1013
1014 if (shdr[i].sh_type == SHT_REL) {
1015 if (debug_linker>1) fprintf(stderr, "Rel " );
1016 } else if (shdr[i].sh_type == SHT_RELA) {
1017 if (debug_linker>1) fprintf(stderr, "RelA " );
1018 } else {
1019 if (debug_linker>1) fprintf(stderr," ");
1020 }
1021 if (sh_strtab) {
1022 if (debug_linker>1) fprintf(stderr, "sname=%s\n",
1023 sh_strtab + shdr[i].sh_name );
1024 }
1025 }
1026
1027 if (debug_linker>1) fprintf(stderr, "\nString tables\n" );
1028 strtab = NULL;
1029 nstrtab = 0;
1030 for (i = 0; i < ehdr->e_shnum; i++) {
1031 if (shdr[i].sh_type == SHT_STRTAB
1032 /* Ignore the section header's string table. */
1033 && i != ehdr->e_shstrndx
1034 /* Ignore string tables named .stabstr, as they contain
1035 debugging info. */
1036 && 0 != memcmp(".stabstr", sh_strtab + shdr[i].sh_name, 8)
1037 ) {
1038 if (debug_linker>1)
1039 fprintf(stderr," section %d is a normal string table\n", i );
1040 strtab = ehdrC + shdr[i].sh_offset;
1041 nstrtab++;
1042 }
1043 }
1044 if (nstrtab != 1) {
1045 fprintf(stderr,"%s: no string tables, or too many\n", oc->fileName);
1046 return 0;
1047 }
1048
1049 nsymtabs = 0;
1050 if (debug_linker>1) fprintf(stderr, "\nSymbol tables\n" );
1051 for (i = 0; i < ehdr->e_shnum; i++) {
1052 if (shdr[i].sh_type != SHT_SYMTAB) continue;
1053 if (debug_linker>1) fprintf(stderr, "section %d is a symbol table\n", i );
1054 nsymtabs++;
1055 stab = (Elf_Sym*) (ehdrC + shdr[i].sh_offset);
1056 nent = shdr[i].sh_size / sizeof(Elf_Sym);
1057 if (debug_linker>1) fprintf(stderr,
1058 " number of entries is apparently %d (%lld rem)\n",
1059 nent,
1060 (Long)(shdr[i].sh_size % sizeof(Elf_Sym))
1061 );
1062 if (0 != shdr[i].sh_size % sizeof(Elf_Sym)) {
1063 fprintf(stderr,"%s: non-integral number of symbol table entries\n",
1064 oc->fileName);
1065 return 0;
1066 }
1067 for (j = 0; j < nent; j++) {
1068 if (debug_linker>1) fprintf(stderr, " %2d ", j );
1069 if (debug_linker>1) fprintf(stderr, " sec=%-5d size=%-3d val=%5p ",
1070 (int)stab[j].st_shndx,
1071 (int)stab[j].st_size,
1072 (char*)stab[j].st_value );
1073
1074 if (debug_linker>1) fprintf(stderr, "type=" );
1075 switch (ELF_ST_TYPE(stab[j].st_info)) {
1076 case STT_NOTYPE: if (debug_linker>1) fprintf(stderr, "notype " ); break;
1077 case STT_OBJECT: if (debug_linker>1) fprintf(stderr, "object " ); break;
1078 case STT_FUNC : if (debug_linker>1) fprintf(stderr, "func " ); break;
1079 case STT_SECTION: if (debug_linker>1) fprintf(stderr, "section" ); break;
1080 case STT_FILE: if (debug_linker>1) fprintf(stderr, "file " ); break;
1081 default: if (debug_linker>1) fprintf(stderr, "? " ); break;
1082 }
1083 if (debug_linker>1) fprintf(stderr, " " );
1084
1085 if (debug_linker>1) fprintf(stderr, "bind=" );
1086 switch (ELF_ST_BIND(stab[j].st_info)) {
1087 case STB_LOCAL : if (debug_linker>1) fprintf(stderr, "local " ); break;
1088 case STB_GLOBAL: if (debug_linker>1) fprintf(stderr, "global" ); break;
1089 case STB_WEAK : if (debug_linker>1) fprintf(stderr, "weak " ); break;
1090 default: if (debug_linker>1) fprintf(stderr, "? " ); break;
1091 }
1092 if (debug_linker>1) fprintf(stderr, " " );
1093
1094 if (debug_linker>1) fprintf(stderr, "name=%s\n", strtab + stab[j].st_name );
1095 }
1096 }
1097
1098 if (nsymtabs == 0) {
1099 fprintf(stderr,"%s: didn't find any symbol tables\n", oc->fileName);
1100 return 0;
1101 }
1102
1103 return 1;
1104 }
1105
1106
1107 ///////////////////////////////////////////////////////////////////
1108 ///////////////////////////////////////////////////////////////////
1109 ///////////////////////////////////////////////////////////////////
1110 //
1111 // GETNAMES
1112
1113 static int
1114 ocGetNames_ELF ( ObjectCode* oc )
1115 {
1116 int i, j, k, nent;
1117 Elf_Sym* stab;
1118
1119 char* ehdrC = (char*)(oc->image);
1120 Elf_Ehdr* ehdr = (Elf_Ehdr*)ehdrC;
1121 char* strtab = findElfSection ( ehdrC, SHT_STRTAB );
1122 Elf_Shdr* shdr = (Elf_Shdr*) (ehdrC + ehdr->e_shoff);
1123
1124 char* sh_strtab = ehdrC + shdr[ehdr->e_shstrndx].sh_offset;
1125 char* sec_name;
1126
1127 assert(global_symbol_table != NULL);
1128
1129 if (!strtab) {
1130 fprintf(stderr,"%s: no strtab\n", oc->fileName);
1131 return 0;
1132 }
1133
1134 k = 0;
1135 for (i = 0; i < ehdr->e_shnum; i++) {
1136 /* Figure out what kind of section it is. Logic derived from
1137 Figure 1.14 ("Special Sections") of the ELF document
1138 ("Portable Formats Specification, Version 1.1"). */
1139 Elf_Shdr hdr = shdr[i];
1140 SectionKind kind = SECTIONKIND_OTHER;
1141 int is_bss = FALSE;
1142
1143 if (hdr.sh_type == SHT_PROGBITS
1144 && (hdr.sh_flags & SHF_ALLOC) && (hdr.sh_flags & SHF_EXECINSTR)) {
1145 /* .text-style section */
1146 kind = SECTIONKIND_CODE_OR_RODATA;
1147 }
1148 else
1149 if (hdr.sh_type == SHT_PROGBITS
1150 && (hdr.sh_flags & SHF_ALLOC) && (hdr.sh_flags & SHF_WRITE)) {
1151 /* .data-style section */
1152 kind = SECTIONKIND_RWDATA;
1153 }
1154 else
1155 if (hdr.sh_type == SHT_PROGBITS
1156 && (hdr.sh_flags & SHF_ALLOC) && !(hdr.sh_flags & SHF_WRITE)) {
1157 /* .rodata-style section */
1158 kind = SECTIONKIND_CODE_OR_RODATA;
1159 }
1160 else
1161 if (hdr.sh_type == SHT_NOBITS
1162 && (hdr.sh_flags & SHF_ALLOC) && (hdr.sh_flags & SHF_WRITE)) {
1163 /* .bss-style section */
1164 kind = SECTIONKIND_RWDATA;
1165 is_bss = TRUE;
1166 }
1167
1168 if (is_bss && shdr[i].sh_size > 0) {
1169 /* This is a non-empty .bss section. Allocate zeroed space for
1170 it, and set its .sh_offset field such that
1171 ehdrC + .sh_offset == addr_of_zeroed_space. */
1172 char* zspace = calloc(1, shdr[i].sh_size);
1173 shdr[i].sh_offset = ((char*)zspace) - ((char*)ehdrC);
1174 if (1)
1175 fprintf(stderr, "BSS section at %p, size %lld\n",
1176 zspace, (Long)shdr[i].sh_size);
1177 }
1178
1179 /* When loading objects compiled with -g, it seems there are
1180 relocations in various debug-info sections. So we'd better
1181 tell addProddableBlock to allow those bits to be prodded. */
1182 //fprintf(stderr, "ZZZZZZZZZZ %s\n", sh_strtab + hdr.sh_name);
1183 sec_name = sh_strtab + shdr[i].sh_name;
1184 if (kind == SECTIONKIND_OTHER
1185 && (0 == strcmp(".debug_info", sec_name)
1186 || 0 == strcmp(".debug_line", sec_name)
1187 || 0 == strcmp(".debug_pubnames", sec_name)
1188 || 0 == strcmp(".debug_aranges", sec_name)
1189 || 0 == strcmp(".debug_frame", sec_name))) {
1190 kind = SECTIONKIND_CODE_OR_RODATA;
1191 }
1192
1193 /* fill in the section info */
1194 if (kind != SECTIONKIND_OTHER && shdr[i].sh_size > 0) {
1195 addProddableBlock(oc, ehdrC + shdr[i].sh_offset, shdr[i].sh_size);
1196 //addSection(oc, kind, ehdrC + shdr[i].sh_offset,
1197 // ehdrC + shdr[i].sh_offset + shdr[i].sh_size - 1);
1198 }
1199
1200 if (shdr[i].sh_type != SHT_SYMTAB) continue;
1201
1202 /* copy stuff into this module's object symbol table */
1203 stab = (Elf_Sym*) (ehdrC + shdr[i].sh_offset);
1204 nent = shdr[i].sh_size / sizeof(Elf_Sym);
1205
1206 oc->n_symbols = nent;
1207 oc->symbols = mymalloc(oc->n_symbols * sizeof(char*));
1208
1209 for (j = 0; j < nent; j++) {
1210
1211 char isLocal = FALSE; /* avoids uninit-var warning */
1212 char* ad = NULL;
1213 char* nm = strtab + stab[j].st_name;
1214 int secno = stab[j].st_shndx;
1215
1216 /* Figure out if we want to add it; if so, set ad to its
1217 address. Otherwise leave ad == NULL. */
1218
1219 if (secno == SHN_COMMON) {
1220 isLocal = FALSE;
1221 # if defined(__x86_64__)
1222 ad = calloc_below2G(1, stab[j].st_size);
1223 # else
1224 ad = calloc(1, stab[j].st_size);
1225 # endif
1226 // assert( (Addr)ad < 0xF0000000ULL );
1227
1228 if (0)
1229 fprintf(stderr, "COMMON symbol, size %lld name %s allocd %p\n",
1230 (Long)stab[j].st_size, nm, ad);
1231 /* Pointless to do addProddableBlock() for this area,
1232 since the linker should never poke around in it. */
1233 }
1234 else
1235 if ( ( ELF_ST_BIND(stab[j].st_info)==STB_GLOBAL
1236 || ELF_ST_BIND(stab[j].st_info)==STB_LOCAL
1237 )
1238 /* and not an undefined symbol */
1239 && stab[j].st_shndx != SHN_UNDEF
1240 /* and not in a "special section" */
1241 && stab[j].st_shndx < SHN_LORESERVE
1242 &&
1243 /* and it's a not a section or string table or anything silly */
1244 ( ELF_ST_TYPE(stab[j].st_info)==STT_FUNC ||
1245 ELF_ST_TYPE(stab[j].st_info)==STT_OBJECT ||
1246 ELF_ST_TYPE(stab[j].st_info)==STT_NOTYPE
1247 )
1248 ) {
1249 /* Section 0 is the undefined section, hence > and not >=. */
1250 assert(secno > 0 && secno < ehdr->e_shnum);
1251 /*
1252 if (shdr[secno].sh_type == SHT_NOBITS) {
1253 fprintf(stderr, " BSS symbol, size %d off %d name %s\n",
1254 stab[j].st_size, stab[j].st_value, nm);
1255 }
1256 */
1257 ad = ehdrC + shdr[ secno ].sh_offset + stab[j].st_value;
1258 if (ELF_ST_BIND(stab[j].st_info)==STB_LOCAL) {
1259 isLocal = TRUE;
1260 } else {
1261 #ifdef ELF_FUNCTION_DESC
1262 /* dlsym() and the initialisation table both give us function
1263 * descriptors, so to be consistent we store function descriptors
1264 * in the symbol table */
1265 if (ELF_ST_TYPE(stab[j].st_info) == STT_FUNC)
1266 ad = (char *)allocateFunctionDesc((Elf_Addr)ad);
1267 #endif
1268 if (0|| debug_linker)
1269 fprintf(stderr, "addOTabName(GLOB): %10p %s %s\n",
1270 ad, oc->fileName, nm );
1271 isLocal = FALSE;
1272 }
1273 }
1274
1275 /* And the decision is ... */
1276
1277 if (ad != NULL) {
1278 assert(nm != NULL);
1279 oc->symbols[j] = nm;
1280 /* Acquire! */
1281 if (isLocal) {
1282 /* Ignore entirely. */
1283 } else {
1284 //ghciInsertStrHashTable(oc->fileName, global_symbol_table, nm, ad);
1285 paranoid_addto_StringMap(global_symbol_table, nm, ad);
1286 }
1287 } else {
1288 /* Skip. */
1289 if (debug_linker>1) fprintf(stderr, "skipping `%s'\n",
1290 strtab + stab[j].st_name );
1291 /*
1292 fprintf(stderr,
1293 "skipping bind = %d, type = %d, shndx = %d `%s'\n",
1294 (int)ELF_ST_BIND(stab[j].st_info),
1295 (int)ELF_ST_TYPE(stab[j].st_info),
1296 (int)stab[j].st_shndx,
1297 strtab + stab[j].st_name
1298 );
1299 */
1300 oc->symbols[j] = NULL;
1301 }
1302
1303 }
1304 }
1305
1306 return 1;
1307 }
1308
1309
1310 ///////////////////////////////////////////////////////////////////
1311 ///////////////////////////////////////////////////////////////////
1312 ///////////////////////////////////////////////////////////////////
1313 //
1314 // TOP-LEVEL CONTROL OF THE LINKER
1315
1316
1317 /* ---------------------------------------------------------------------
1318 * Load an obj (populate the global symbol table, but don't resolve yet)
1319 *
1320 * Returns: 1 if ok, 0 on error.
1321 */
1322 static
1323 int loadObj( char *path )
1324 {
1325 ObjectCode* oc;
1326 struct stat st;
1327 int r;
1328 int fd, pagesize;
1329 char* p;
1330
1331 initLinker();
1332
1333 fprintf(stderr, "==== loadObj %s ====\n", path );
1334
1335 /* Check that we haven't already loaded this object. */
1336 {
1337 ObjectCode *o;
1338 int is_dup = 0;
1339 for (o = global_object_list; o; o = o->next) {
1340 if (0 == strcmp(o->fileName, path))
1341 is_dup = 1;
1342 }
1343 if (is_dup) {
1344 fprintf(stderr,
1345 "\n\n"
1346 "GHCi runtime linker: warning: looks like you're trying to load the\n"
1347 "same object file twice:\n"
1348 " %s\n"
1349 , path);
1350 exit(1);
1351 }
1352 }
1353
1354 oc = mymalloc(sizeof(ObjectCode));
1355
1356 oc->formatName = "ELF";
1357
1358 r = stat(path, &st);
1359 if (r == -1) { return 0; }
1360
1361 /* sigh, strdup() isn't a POSIX function, so do it the long way */
1362 oc->fileName = mymalloc( strlen(path)+1 );
1363 strcpy(oc->fileName, path);
1364
1365 oc->fileSize = st.st_size;
1366 oc->symbols = NULL;
1367 oc->sections = NULL;
1368 oc->lochash = new_StringMap();
1369 oc->proddables = NULL;
1370 oc->fixup = NULL;
1371 oc->fixup_used = 0;
1372 oc->fixup_size = 0;
1373
1374 /* chain it onto the list of objects */
1375 oc->next = global_object_list;
1376 global_object_list = oc;
1377
1378 fd = open(path, O_RDONLY);
1379 if (fd == -1) {
1380 fprintf(stderr,"loadObj: can't open `%s'\n", path);
1381 exit(1);
1382 }
1383
1384 /* Allocate a 1-page area just prior to the image, so we can put
1385 fixup code fragments there. Used for doing R_ARM_PC24
1386 relocations for jump distances > 64M. */
1387
1388 pagesize = getpagesize();
1389 // p = memalign(pagesize, N_FIXUP_PAGES * pagesize
1390 // + oc->fileSize);
1391 p = mymalloc(N_FIXUP_PAGES * pagesize + oc->fileSize);
1392 if (0) fprintf(stderr,"XXXX p = %p\n", p);
1393 if (p == NULL) {
1394 fprintf(stderr,"loadObj: failed to allocate space for `%s'\n", path);
1395 exit(1);
1396 }
1397
1398 oc->fixup = p;
1399 oc->fixup_size = N_FIXUP_PAGES * pagesize;
1400 oc->fixup_used = 0;
1401 oc->image = &(p[ oc->fixup_size ]);
1402
1403 r = read(fd, oc->image, oc->fileSize);
1404 if (r != oc->fileSize) {
1405 fprintf(stderr,"loadObj: failed to read `%s'\n", path);
1406 exit(1);
1407 }
1408
1409 fprintf(stderr, "loaded %s at %p (fixup = %p)\n",
1410 oc->fileName, oc->image, oc->fixup );
1411
1412 close(fd);
1413
1414 /* verify the in-memory image */
1415 r = ocVerifyImage_ELF ( oc );
1416 if (!r) { return r; }
1417
1418 /* build the symbol list for this image */
1419 r = ocGetNames_ELF ( oc );
1420 if (!r) { return r; }
1421
1422 /* loaded, but not resolved yet */
1423 oc->status = OBJECT_LOADED;
1424
1425 #ifdef ppc32_TARGET_ARCH
1426 invalidate_icache(oc->image, oc->fileSize);
1427 #endif
1428
1429 return 1;
1430 }
1431
1432
1433
1434 /* ---------------------------------------------------------------------------
1435 * resolve all the currently unlinked objects in memory
1436 *
1437 * Returns: 1 if ok, 0 on error.
1438 */
1439 static
1440 int resolveObjs( void )
1441 {
1442 ObjectCode *oc;
1443 int r;
1444
1445 initLinker();
1446
1447 for (oc = global_object_list; oc; oc = oc->next) {
1448 if (oc->status != OBJECT_RESOLVED) {
1449 r = ocResolve_ELF ( oc );
1450 if (!r) { return r; }
1451 oc->status = OBJECT_RESOLVED;
1452 }
1453 }
1454 return 1;
1455 }
1456
1457
1458 /* ---------------------------------------------------------------------------
1459 * Top-level linker.
1460 */
1461
1462 /* Load and link a bunch of .o's, and return the address of
1463 'entry'. Or NULL if something borks.
1464 */
1465 void* linker_top_level_LINK ( int n_object_names, char** object_names )
1466 {
1467 int r, i;
1468 void* mainp;
1469
1470 initLinker();
1471 for (i = 0; i < n_object_names; i++) {
1472 //fprintf(stderr, "linkloop %d %s\n", i, object_names[i] );
1473 r = loadObj( object_names[i] );
1474 if (r != 1) return NULL;
1475 }
1476 r = resolveObjs();
1477 if (r != 1) return NULL;
1478 mainp = search_StringMap ( global_symbol_table, "entry" );
1479 if (mainp == NULL) return NULL;
1480 printf("switchback: Linker: success!\n");
1481 return mainp;
1482 }
1483
1484
1485 #endif
Instrumentation framework for detecting many memory management and threading bugs, and profile your programs in detail.