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