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