?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Handle x86 CET prefixes (32 bit only). Pertains to #379525.
[valgrind.git] / VEX / unused / linker.c
blob78c290375f8f78cb858c29dfcfff6da4c568e867
1
2 #include <stdlib.h>
3 #include <stdio.h>
4 #include <assert.h>
5 #include <sys/types.h>
6 #include <sys/stat.h>
7 #include <unistd.h>
8 #include <elf.h>
9 #include <fcntl.h>
10 #include <string.h>
11 #include <malloc.h>
12
13
14 #define IF_DEBUG(x,y) /* */
15 static int debug_linker = 0;
16
17 #define i386_TARGET_ARCH
18 // #define arm_TARGET_ARCH
19
20 #if !defined(i386_TARGET_ARCH) && !defined(arm_TARGET_ARCH)
21 # error "Must #define i386_TARGET_ARCH or arm_TARGET_ARCH"
22 #endif
23
24
25 ///////////////////////////////////////////////////////////////////
26 ///////////////////////////////////////////////////////////////////
27 ///////////////////////////////////////////////////////////////////
28 //
29 // TYPES
30
31 #define FALSE 0
32 #define TRUE 1
33
34 typedef enum { OBJECT_LOADED, OBJECT_RESOLVED } OStatus;
35
36
37 #define N_FIXUP_PAGES 1
38
39
40 /* Indication of section kinds for loaded objects. Needed by
41 the GC for deciding whether or not a pointer on the stack
42 is a code pointer.
43 */
44 typedef
45 enum { SECTIONKIND_CODE_OR_RODATA,
46 SECTIONKIND_RWDATA,
47 SECTIONKIND_OTHER,
48 SECTIONKIND_NOINFOAVAIL }
49 SectionKind;
50
51 typedef
52 struct _Section {
53 void* start;
54 void* end;
55 SectionKind kind;
56 struct _Section* next;
57 }
58 Section;
59
60 typedef
61 struct _ProddableBlock {
62 void* start;
63 int size;
64 struct _ProddableBlock* next;
65 }
66 ProddableBlock;
67
68 /* Top-level structure for an object module. One of these is allocated
69 * for each object file in use.
70 */
71 typedef struct _ObjectCode {
72 OStatus status;
73 char* fileName;
74 int fileSize;
75 char* formatName; /* eg "ELF32", "DLL", "COFF", etc. */
76
77 /* An array containing ptrs to all the symbol names copied from
78 this object into the global symbol hash table. This is so that
79 we know which parts of the latter mapping to nuke when this
80 object is removed from the system. */
81 char** symbols;
82 int n_symbols;
83
84 /* ptr to malloc'd lump of memory holding the obj file */
85 void* image;
86
87 /* Fixup area for long-distance jumps. */
88 char* fixup;
89 int fixup_used;
90 int fixup_size;
91
92 /* The section-kind entries for this object module. Linked
93 list. */
94 Section* sections;
95
96 /* A private hash table for local symbols. */
97 /* HashTable* */ void* lochash;
98
99 /* Allow a chain of these things */
100 struct _ObjectCode * next;
101
102 /* SANITY CHECK ONLY: a list of the only memory regions which may
103 safely be prodded during relocation. Any attempt to prod
104 outside one of these is an error in the linker. */
105 ProddableBlock* proddables;
106
107 } ObjectCode;
108
109 /*
110 * Define a set of types which can be used for both ELF32 and ELF64
111 */
112
113 #ifdef ELF_64BIT
114 #define ELFCLASS ELFCLASS64
115 #define Elf_Addr Elf64_Addr
116 #define Elf_Word Elf64_Word
117 #define Elf_Sword Elf64_Sword
118 #define Elf_Ehdr Elf64_Ehdr
119 #define Elf_Phdr Elf64_Phdr
120 #define Elf_Shdr Elf64_Shdr
121 #define Elf_Sym Elf64_Sym
122 #define Elf_Rel Elf64_Rel
123 #define Elf_Rela Elf64_Rela
124 #define ELF_ST_TYPE ELF64_ST_TYPE
125 #define ELF_ST_BIND ELF64_ST_BIND
126 #define ELF_R_TYPE ELF64_R_TYPE
127 #define ELF_R_SYM ELF64_R_SYM
128 #else
129 #define ELFCLASS ELFCLASS32
130 #define Elf_Addr Elf32_Addr
131 #define Elf_Word Elf32_Word
132 #define Elf_Sword Elf32_Sword
133 #define Elf_Ehdr Elf32_Ehdr
134 #define Elf_Phdr Elf32_Phdr
135 #define Elf_Shdr Elf32_Shdr
136 #define Elf_Sym Elf32_Sym
137 #define Elf_Rel Elf32_Rel
138 #define Elf_Rela Elf32_Rela
139 #ifndef ELF_ST_TYPE
140 #define ELF_ST_TYPE ELF32_ST_TYPE
141 #endif
142 #ifndef ELF_ST_BIND
143 #define ELF_ST_BIND ELF32_ST_BIND
144 #endif
145 #ifndef ELF_R_TYPE
146 #define ELF_R_TYPE ELF32_R_TYPE
147 #endif
148 #ifndef ELF_R_SYM
149 #define ELF_R_SYM ELF32_R_SYM
150 #endif
151 #endif
152
153
154
155
156 ///////////////////////////////////////////////////////////////////
157 ///////////////////////////////////////////////////////////////////
158 ///////////////////////////////////////////////////////////////////
159 //
160 // PARANOIA
161
162 /* -----------------------------------------------------------------------
163 * Sanity checking. For each ObjectCode, maintain a list of address ranges
164 * which may be prodded during relocation, and abort if we try and write
165 * outside any of these.
166 */
167 static void addProddableBlock ( ObjectCode* oc, void* start, int size )
168 {
169 ProddableBlock* pb
170 = malloc(sizeof(ProddableBlock));
171 if (debug_linker)
172 fprintf(stderr, "aPB oc=%p %p %d (%p .. %p)\n", oc, start, size,
173 start, ((char*)start)+size-1 );
174 assert(size > 0);
175 pb->start = start;
176 pb->size = size;
177 pb->next = oc->proddables;
178 oc->proddables = pb;
179 }
180
181 static 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
207 typedef
208 struct { char* mp_name; void* mp_addr; }
209 Maplet;
210
211 typedef
212 struct {
213 int sm_size;
214 int sm_used;
215 Maplet* maplets;
216 }
217 StringMap;
218
219 static 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
228 static void delete_StringMap ( StringMap* sm )
229 {
230 assert(sm->maplets != NULL);
231 free(sm->maplets);
232 sm->maplets = NULL;
233 free(sm);
234 }
235
236 static 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
251 static 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
260 static 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
268 static 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
284 StringMap* global_symbol_table = NULL;
285 ObjectCode* global_object_list = NULL;
286
287 static 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 */
305 static
306 void * 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
326 static char *
327 findElfSection ( 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
352 static
353 char* 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
375 static
376 void* 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
383 static
384 void 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
395 static
396 void 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. */
418 static int
419 do_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. */
544 static int
545 do_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
707 static int
708 ocResolve_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
766 static int
767 ocVerifyImage_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
950 static int
951 ocGetNames_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 */
1155 static
1156 int 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 */
1267 static
1268 int 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 */
1293 void* 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
1314 int 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
1347 typedef unsigned int Word;
1348
1349 /* Stack for the simulation */
1350 Word* sim_stack;
1351
1352 /* Stop when we get a jump to here. */
1353 char* stop_at;
1354
1355
1356 /* ARM state */
1357 /* r0 .. r15, flags */
1358 Word 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
1371 static
1372 void 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 */
1392 void 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
Instrumentation framework for detecting many memory management and threading bugs, and profile your programs in detail.