?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove OpenBIOS ESP patch. Merged upstream.
[qemu/mini2440.git] / dyngen.c
blob2d93283d67d30b0bf619d3fe0ff5d657b2982086
1 /*
2 * Generic Dynamic compiler generator
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * The COFF object format support was extracted from Kazu's QEMU port
7 * to Win32.
8 *
9 * Mach-O Support by Matt Reda and Pierre d'Herbemont
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 */
25 #include <stdlib.h>
26 #include <stdio.h>
27 #include <string.h>
28 #include <stdarg.h>
29 #include <inttypes.h>
30 #include <unistd.h>
31 #include <fcntl.h>
32
33 #include "config-host.h"
34
35 /* NOTE: we test CONFIG_WIN32 instead of _WIN32 to enabled cross
36 compilation */
37 #if defined(CONFIG_WIN32)
38 #define CONFIG_FORMAT_COFF
39 #elif defined(CONFIG_DARWIN)
40 #define CONFIG_FORMAT_MACH
41 #else
42 #define CONFIG_FORMAT_ELF
43 #endif
44
45 #ifdef CONFIG_FORMAT_ELF
46
47 /* elf format definitions. We use these macros to test the CPU to
48 allow cross compilation (this tool must be ran on the build
49 platform) */
50 #if defined(HOST_I386)
51
52 #define ELF_CLASS ELFCLASS32
53 #define ELF_ARCH EM_386
54 #define elf_check_arch(x) ( ((x) == EM_386) || ((x) == EM_486) )
55 #undef ELF_USES_RELOCA
56
57 #elif defined(HOST_X86_64)
58
59 #define ELF_CLASS ELFCLASS64
60 #define ELF_ARCH EM_X86_64
61 #define elf_check_arch(x) ((x) == EM_X86_64)
62 #define ELF_USES_RELOCA
63
64 #elif defined(HOST_PPC)
65
66 #define ELF_CLASS ELFCLASS32
67 #define ELF_ARCH EM_PPC
68 #define elf_check_arch(x) ((x) == EM_PPC)
69 #define ELF_USES_RELOCA
70
71 #elif defined(HOST_S390)
72
73 #define ELF_CLASS ELFCLASS32
74 #define ELF_ARCH EM_S390
75 #define elf_check_arch(x) ((x) == EM_S390)
76 #define ELF_USES_RELOCA
77
78 #elif defined(HOST_ALPHA)
79
80 #define ELF_CLASS ELFCLASS64
81 #define ELF_ARCH EM_ALPHA
82 #define elf_check_arch(x) ((x) == EM_ALPHA)
83 #define ELF_USES_RELOCA
84
85 #elif defined(HOST_IA64)
86
87 #define ELF_CLASS ELFCLASS64
88 #define ELF_ARCH EM_IA_64
89 #define elf_check_arch(x) ((x) == EM_IA_64)
90 #define ELF_USES_RELOCA
91
92 #elif defined(HOST_SPARC)
93
94 #define ELF_CLASS ELFCLASS32
95 #define ELF_ARCH EM_SPARC
96 #define elf_check_arch(x) ((x) == EM_SPARC || (x) == EM_SPARC32PLUS)
97 #define ELF_USES_RELOCA
98
99 #elif defined(HOST_SPARC64)
100
101 #define ELF_CLASS ELFCLASS64
102 #define ELF_ARCH EM_SPARCV9
103 #define elf_check_arch(x) ((x) == EM_SPARCV9)
104 #define ELF_USES_RELOCA
105
106 #elif defined(HOST_ARM)
107
108 #define ELF_CLASS ELFCLASS32
109 #define ELF_ARCH EM_ARM
110 #define elf_check_arch(x) ((x) == EM_ARM)
111 #define ELF_USES_RELOC
112
113 #elif defined(HOST_M68K)
114
115 #define ELF_CLASS ELFCLASS32
116 #define ELF_ARCH EM_68K
117 #define elf_check_arch(x) ((x) == EM_68K)
118 #define ELF_USES_RELOCA
119
120 #else
121 #error unsupported CPU - please update the code
122 #endif
123
124 #include "elf.h"
125
126 #if ELF_CLASS == ELFCLASS32
127 typedef int32_t host_long;
128 typedef uint32_t host_ulong;
129 #define swabls(x) swab32s(x)
130 #else
131 typedef int64_t host_long;
132 typedef uint64_t host_ulong;
133 #define swabls(x) swab64s(x)
134 #endif
135
136 #ifdef ELF_USES_RELOCA
137 #define SHT_RELOC SHT_RELA
138 #else
139 #define SHT_RELOC SHT_REL
140 #endif
141
142 #define EXE_RELOC ELF_RELOC
143 #define EXE_SYM ElfW(Sym)
144
145 #endif /* CONFIG_FORMAT_ELF */
146
147 #ifdef CONFIG_FORMAT_COFF
148
149 #include "a.out.h"
150
151 typedef int32_t host_long;
152 typedef uint32_t host_ulong;
153
154 #define FILENAMELEN 256
155
156 typedef struct coff_sym {
157 struct external_syment *st_syment;
158 char st_name[FILENAMELEN];
159 uint32_t st_value;
160 int st_size;
161 uint8_t st_type;
162 uint8_t st_shndx;
163 } coff_Sym;
164
165 typedef struct coff_rel {
166 struct external_reloc *r_reloc;
167 int r_offset;
168 uint8_t r_type;
169 } coff_Rel;
170
171 #define EXE_RELOC struct coff_rel
172 #define EXE_SYM struct coff_sym
173
174 #endif /* CONFIG_FORMAT_COFF */
175
176 #ifdef CONFIG_FORMAT_MACH
177
178 #include <mach-o/loader.h>
179 #include <mach-o/nlist.h>
180 #include <mach-o/reloc.h>
181 #include <mach-o/ppc/reloc.h>
182
183 # define check_mach_header(x) (x.magic == MH_MAGIC)
184 typedef int32_t host_long;
185 typedef uint32_t host_ulong;
186
187 struct nlist_extended
188 {
189 union {
190 char *n_name;
191 long n_strx;
192 } n_un;
193 unsigned char n_type;
194 unsigned char n_sect;
195 short st_desc;
196 unsigned long st_value;
197 unsigned long st_size;
198 };
199
200 #define EXE_RELOC struct relocation_info
201 #define EXE_SYM struct nlist_extended
202
203 #endif /* CONFIG_FORMAT_MACH */
204
205 #include "bswap.h"
206
207 enum {
208 OUT_GEN_OP,
209 OUT_CODE,
210 OUT_INDEX_OP,
211 };
212
213 /* all dynamically generated functions begin with this code */
214 #define OP_PREFIX "op_"
215
216 int do_swap;
217
218 void __attribute__((noreturn)) __attribute__((format (printf, 1, 2))) error(const char *fmt, ...)
219 {
220 va_list ap;
221 va_start(ap, fmt);
222 fprintf(stderr, "dyngen: ");
223 vfprintf(stderr, fmt, ap);
224 fprintf(stderr, "\n");
225 va_end(ap);
226 exit(1);
227 }
228
229 void *load_data(int fd, long offset, unsigned int size)
230 {
231 char *data;
232
233 data = malloc(size);
234 if (!data)
235 return NULL;
236 lseek(fd, offset, SEEK_SET);
237 if (read(fd, data, size) != size) {
238 free(data);
239 return NULL;
240 }
241 return data;
242 }
243
244 int strstart(const char *str, const char *val, const char **ptr)
245 {
246 const char *p, *q;
247 p = str;
248 q = val;
249 while (*q != '\0') {
250 if (*p != *q)
251 return 0;
252 p++;
253 q++;
254 }
255 if (ptr)
256 *ptr = p;
257 return 1;
258 }
259
260 void pstrcpy(char *buf, int buf_size, const char *str)
261 {
262 int c;
263 char *q = buf;
264
265 if (buf_size <= 0)
266 return;
267
268 for(;;) {
269 c = *str++;
270 if (c == 0 || q >= buf + buf_size - 1)
271 break;
272 *q++ = c;
273 }
274 *q = '\0';
275 }
276
277 void swab16s(uint16_t *p)
278 {
279 *p = bswap16(*p);
280 }
281
282 void swab32s(uint32_t *p)
283 {
284 *p = bswap32(*p);
285 }
286
287 void swab64s(uint64_t *p)
288 {
289 *p = bswap64(*p);
290 }
291
292 uint16_t get16(uint16_t *p)
293 {
294 uint16_t val;
295 val = *p;
296 if (do_swap)
297 val = bswap16(val);
298 return val;
299 }
300
301 uint32_t get32(uint32_t *p)
302 {
303 uint32_t val;
304 val = *p;
305 if (do_swap)
306 val = bswap32(val);
307 return val;
308 }
309
310 void put16(uint16_t *p, uint16_t val)
311 {
312 if (do_swap)
313 val = bswap16(val);
314 *p = val;
315 }
316
317 void put32(uint32_t *p, uint32_t val)
318 {
319 if (do_swap)
320 val = bswap32(val);
321 *p = val;
322 }
323
324 /* executable information */
325 EXE_SYM *symtab;
326 int nb_syms;
327 int text_shndx;
328 uint8_t *text;
329 EXE_RELOC *relocs;
330 int nb_relocs;
331
332 #ifdef CONFIG_FORMAT_ELF
333
334 /* ELF file info */
335 struct elf_shdr *shdr;
336 uint8_t **sdata;
337 struct elfhdr ehdr;
338 char *strtab;
339
340 int elf_must_swap(struct elfhdr *h)
341 {
342 union {
343 uint32_t i;
344 uint8_t b[4];
345 } swaptest;
346
347 swaptest.i = 1;
348 return (h->e_ident[EI_DATA] == ELFDATA2MSB) !=
349 (swaptest.b[0] == 0);
350 }
351
352 void elf_swap_ehdr(struct elfhdr *h)
353 {
354 swab16s(&h->e_type); /* Object file type */
355 swab16s(&h-> e_machine); /* Architecture */
356 swab32s(&h-> e_version); /* Object file version */
357 swabls(&h-> e_entry); /* Entry point virtual address */
358 swabls(&h-> e_phoff); /* Program header table file offset */
359 swabls(&h-> e_shoff); /* Section header table file offset */
360 swab32s(&h-> e_flags); /* Processor-specific flags */
361 swab16s(&h-> e_ehsize); /* ELF header size in bytes */
362 swab16s(&h-> e_phentsize); /* Program header table entry size */
363 swab16s(&h-> e_phnum); /* Program header table entry count */
364 swab16s(&h-> e_shentsize); /* Section header table entry size */
365 swab16s(&h-> e_shnum); /* Section header table entry count */
366 swab16s(&h-> e_shstrndx); /* Section header string table index */
367 }
368
369 void elf_swap_shdr(struct elf_shdr *h)
370 {
371 swab32s(&h-> sh_name); /* Section name (string tbl index) */
372 swab32s(&h-> sh_type); /* Section type */
373 swabls(&h-> sh_flags); /* Section flags */
374 swabls(&h-> sh_addr); /* Section virtual addr at execution */
375 swabls(&h-> sh_offset); /* Section file offset */
376 swabls(&h-> sh_size); /* Section size in bytes */
377 swab32s(&h-> sh_link); /* Link to another section */
378 swab32s(&h-> sh_info); /* Additional section information */
379 swabls(&h-> sh_addralign); /* Section alignment */
380 swabls(&h-> sh_entsize); /* Entry size if section holds table */
381 }
382
383 void elf_swap_phdr(struct elf_phdr *h)
384 {
385 swab32s(&h->p_type); /* Segment type */
386 swabls(&h->p_offset); /* Segment file offset */
387 swabls(&h->p_vaddr); /* Segment virtual address */
388 swabls(&h->p_paddr); /* Segment physical address */
389 swabls(&h->p_filesz); /* Segment size in file */
390 swabls(&h->p_memsz); /* Segment size in memory */
391 swab32s(&h->p_flags); /* Segment flags */
392 swabls(&h->p_align); /* Segment alignment */
393 }
394
395 void elf_swap_rel(ELF_RELOC *rel)
396 {
397 swabls(&rel->r_offset);
398 swabls(&rel->r_info);
399 #ifdef ELF_USES_RELOCA
400 swabls(&rel->r_addend);
401 #endif
402 }
403
404 struct elf_shdr *find_elf_section(struct elf_shdr *shdr, int shnum, const char *shstr,
405 const char *name)
406 {
407 int i;
408 const char *shname;
409 struct elf_shdr *sec;
410
411 for(i = 0; i < shnum; i++) {
412 sec = &shdr[i];
413 if (!sec->sh_name)
414 continue;
415 shname = shstr + sec->sh_name;
416 if (!strcmp(shname, name))
417 return sec;
418 }
419 return NULL;
420 }
421
422 int find_reloc(int sh_index)
423 {
424 struct elf_shdr *sec;
425 int i;
426
427 for(i = 0; i < ehdr.e_shnum; i++) {
428 sec = &shdr[i];
429 if (sec->sh_type == SHT_RELOC && sec->sh_info == sh_index)
430 return i;
431 }
432 return 0;
433 }
434
435 static host_ulong get_rel_offset(EXE_RELOC *rel)
436 {
437 return rel->r_offset;
438 }
439
440 static char *get_rel_sym_name(EXE_RELOC *rel)
441 {
442 return strtab + symtab[ELFW(R_SYM)(rel->r_info)].st_name;
443 }
444
445 static char *get_sym_name(EXE_SYM *sym)
446 {
447 return strtab + sym->st_name;
448 }
449
450 /* load an elf object file */
451 int load_object(const char *filename)
452 {
453 int fd;
454 struct elf_shdr *sec, *symtab_sec, *strtab_sec, *text_sec;
455 int i, j;
456 ElfW(Sym) *sym;
457 char *shstr;
458 ELF_RELOC *rel;
459
460 fd = open(filename, O_RDONLY);
461 if (fd < 0)
462 error("can't open file '%s'", filename);
463
464 /* Read ELF header. */
465 if (read(fd, &ehdr, sizeof (ehdr)) != sizeof (ehdr))
466 error("unable to read file header");
467
468 /* Check ELF identification. */
469 if (ehdr.e_ident[EI_MAG0] != ELFMAG0
470 || ehdr.e_ident[EI_MAG1] != ELFMAG1
471 || ehdr.e_ident[EI_MAG2] != ELFMAG2
472 || ehdr.e_ident[EI_MAG3] != ELFMAG3
473 || ehdr.e_ident[EI_VERSION] != EV_CURRENT) {
474 error("bad ELF header");
475 }
476
477 do_swap = elf_must_swap(&ehdr);
478 if (do_swap)
479 elf_swap_ehdr(&ehdr);
480 if (ehdr.e_ident[EI_CLASS] != ELF_CLASS)
481 error("Unsupported ELF class");
482 if (ehdr.e_type != ET_REL)
483 error("ELF object file expected");
484 if (ehdr.e_version != EV_CURRENT)
485 error("Invalid ELF version");
486 if (!elf_check_arch(ehdr.e_machine))
487 error("Unsupported CPU (e_machine=%d)", ehdr.e_machine);
488
489 /* read section headers */
490 shdr = load_data(fd, ehdr.e_shoff, ehdr.e_shnum * sizeof(struct elf_shdr));
491 if (do_swap) {
492 for(i = 0; i < ehdr.e_shnum; i++) {
493 elf_swap_shdr(&shdr[i]);
494 }
495 }
496
497 /* read all section data */
498 sdata = malloc(sizeof(void *) * ehdr.e_shnum);
499 memset(sdata, 0, sizeof(void *) * ehdr.e_shnum);
500
501 for(i = 0;i < ehdr.e_shnum; i++) {
502 sec = &shdr[i];
503 if (sec->sh_type != SHT_NOBITS)
504 sdata[i] = load_data(fd, sec->sh_offset, sec->sh_size);
505 }
506
507 sec = &shdr[ehdr.e_shstrndx];
508 shstr = sdata[ehdr.e_shstrndx];
509
510 /* swap relocations */
511 for(i = 0; i < ehdr.e_shnum; i++) {
512 sec = &shdr[i];
513 if (sec->sh_type == SHT_RELOC) {
514 nb_relocs = sec->sh_size / sec->sh_entsize;
515 if (do_swap) {
516 for(j = 0, rel = (ELF_RELOC *)sdata[i]; j < nb_relocs; j++, rel++)
517 elf_swap_rel(rel);
518 }
519 }
520 }
521 /* text section */
522
523 text_sec = find_elf_section(shdr, ehdr.e_shnum, shstr, ".text");
524 if (!text_sec)
525 error("could not find .text section");
526 text_shndx = text_sec - shdr;
527 text = sdata[text_shndx];
528
529 /* find text relocations, if any */
530 relocs = NULL;
531 nb_relocs = 0;
532 i = find_reloc(text_shndx);
533 if (i != 0) {
534 relocs = (ELF_RELOC *)sdata[i];
535 nb_relocs = shdr[i].sh_size / shdr[i].sh_entsize;
536 }
537
538 symtab_sec = find_elf_section(shdr, ehdr.e_shnum, shstr, ".symtab");
539 if (!symtab_sec)
540 error("could not find .symtab section");
541 strtab_sec = &shdr[symtab_sec->sh_link];
542
543 symtab = (ElfW(Sym) *)sdata[symtab_sec - shdr];
544 strtab = sdata[symtab_sec->sh_link];
545
546 nb_syms = symtab_sec->sh_size / sizeof(ElfW(Sym));
547 if (do_swap) {
548 for(i = 0, sym = symtab; i < nb_syms; i++, sym++) {
549 swab32s(&sym->st_name);
550 swabls(&sym->st_value);
551 swabls(&sym->st_size);
552 swab16s(&sym->st_shndx);
553 }
554 }
555 close(fd);
556 return 0;
557 }
558
559 #endif /* CONFIG_FORMAT_ELF */
560
561 #ifdef CONFIG_FORMAT_COFF
562
563 /* COFF file info */
564 struct external_scnhdr *shdr;
565 uint8_t **sdata;
566 struct external_filehdr fhdr;
567 struct external_syment *coff_symtab;
568 char *strtab;
569 int coff_text_shndx, coff_data_shndx;
570
571 int data_shndx;
572
573 #define STRTAB_SIZE 4
574
575 #define DIR32 0x06
576 #define DISP32 0x14
577
578 #define T_FUNCTION 0x20
579 #define C_EXTERNAL 2
580
581 void sym_ent_name(struct external_syment *ext_sym, EXE_SYM *sym)
582 {
583 char *q;
584 int c, i, len;
585
586 if (ext_sym->e.e.e_zeroes != 0) {
587 q = sym->st_name;
588 for(i = 0; i < 8; i++) {
589 c = ext_sym->e.e_name[i];
590 if (c == '\0')
591 break;
592 *q++ = c;
593 }
594 *q = '\0';
595 } else {
596 pstrcpy(sym->st_name, sizeof(sym->st_name), strtab + ext_sym->e.e.e_offset);
597 }
598
599 /* now convert the name to a C name (suppress the leading '_') */
600 if (sym->st_name[0] == '_') {
601 len = strlen(sym->st_name);
602 memmove(sym->st_name, sym->st_name + 1, len - 1);
603 sym->st_name[len - 1] = '\0';
604 }
605 }
606
607 char *name_for_dotdata(struct coff_rel *rel)
608 {
609 int i;
610 struct coff_sym *sym;
611 uint32_t text_data;
612
613 text_data = *(uint32_t *)(text + rel->r_offset);
614
615 for (i = 0, sym = symtab; i < nb_syms; i++, sym++) {
616 if (sym->st_syment->e_scnum == data_shndx &&
617 text_data >= sym->st_value &&
618 text_data < sym->st_value + sym->st_size) {
619
620 return sym->st_name;
621
622 }
623 }
624 return NULL;
625 }
626
627 static char *get_sym_name(EXE_SYM *sym)
628 {
629 return sym->st_name;
630 }
631
632 static char *get_rel_sym_name(EXE_RELOC *rel)
633 {
634 char *name;
635 name = get_sym_name(symtab + *(uint32_t *)(rel->r_reloc->r_symndx));
636 if (!strcmp(name, ".data"))
637 name = name_for_dotdata(rel);
638 if (name[0] == '.')
639 return NULL;
640 return name;
641 }
642
643 static host_ulong get_rel_offset(EXE_RELOC *rel)
644 {
645 return rel->r_offset;
646 }
647
648 struct external_scnhdr *find_coff_section(struct external_scnhdr *shdr, int shnum, const char *name)
649 {
650 int i;
651 const char *shname;
652 struct external_scnhdr *sec;
653
654 for(i = 0; i < shnum; i++) {
655 sec = &shdr[i];
656 if (!sec->s_name)
657 continue;
658 shname = sec->s_name;
659 if (!strcmp(shname, name))
660 return sec;
661 }
662 return NULL;
663 }
664
665 /* load a coff object file */
666 int load_object(const char *filename)
667 {
668 int fd;
669 struct external_scnhdr *sec, *text_sec, *data_sec;
670 int i;
671 struct external_syment *ext_sym;
672 struct external_reloc *coff_relocs;
673 struct external_reloc *ext_rel;
674 uint32_t *n_strtab;
675 EXE_SYM *sym;
676 EXE_RELOC *rel;
677
678 fd = open(filename, O_RDONLY
679 #ifdef _WIN32
680 | O_BINARY
681 #endif
682 );
683 if (fd < 0)
684 error("can't open file '%s'", filename);
685
686 /* Read COFF header. */
687 if (read(fd, &fhdr, sizeof (fhdr)) != sizeof (fhdr))
688 error("unable to read file header");
689
690 /* Check COFF identification. */
691 if (fhdr.f_magic != I386MAGIC) {
692 error("bad COFF header");
693 }
694 do_swap = 0;
695
696 /* read section headers */
697 shdr = load_data(fd, sizeof(struct external_filehdr) + fhdr.f_opthdr, fhdr.f_nscns * sizeof(struct external_scnhdr));
698
699 /* read all section data */
700 sdata = malloc(sizeof(void *) * fhdr.f_nscns);
701 memset(sdata, 0, sizeof(void *) * fhdr.f_nscns);
702
703 const char *p;
704 for(i = 0;i < fhdr.f_nscns; i++) {
705 sec = &shdr[i];
706 if (!strstart(sec->s_name, ".bss", &p))
707 sdata[i] = load_data(fd, sec->s_scnptr, sec->s_size);
708 }
709
710
711 /* text section */
712 text_sec = find_coff_section(shdr, fhdr.f_nscns, ".text");
713 if (!text_sec)
714 error("could not find .text section");
715 coff_text_shndx = text_sec - shdr;
716 text = sdata[coff_text_shndx];
717
718 /* data section */
719 data_sec = find_coff_section(shdr, fhdr.f_nscns, ".data");
720 if (!data_sec)
721 error("could not find .data section");
722 coff_data_shndx = data_sec - shdr;
723
724 coff_symtab = load_data(fd, fhdr.f_symptr, fhdr.f_nsyms*SYMESZ);
725 for (i = 0, ext_sym = coff_symtab; i < nb_syms; i++, ext_sym++) {
726 for(i=0;i<8;i++)
727 printf(" %02x", ((uint8_t *)ext_sym->e.e_name)[i]);
728 printf("\n");
729 }
730
731
732 n_strtab = load_data(fd, (fhdr.f_symptr + fhdr.f_nsyms*SYMESZ), STRTAB_SIZE);
733 strtab = load_data(fd, (fhdr.f_symptr + fhdr.f_nsyms*SYMESZ), *n_strtab);
734
735 nb_syms = fhdr.f_nsyms;
736
737 for (i = 0, ext_sym = coff_symtab; i < nb_syms; i++, ext_sym++) {
738 if (strstart(ext_sym->e.e_name, ".text", NULL))
739 text_shndx = ext_sym->e_scnum;
740 if (strstart(ext_sym->e.e_name, ".data", NULL))
741 data_shndx = ext_sym->e_scnum;
742 }
743
744 /* set coff symbol */
745 symtab = malloc(sizeof(struct coff_sym) * nb_syms);
746
747 int aux_size, j;
748 for (i = 0, ext_sym = coff_symtab, sym = symtab; i < nb_syms; i++, ext_sym++, sym++) {
749 memset(sym, 0, sizeof(*sym));
750 sym->st_syment = ext_sym;
751 sym_ent_name(ext_sym, sym);
752 sym->st_value = ext_sym->e_value;
753
754 aux_size = *(int8_t *)ext_sym->e_numaux;
755 if (ext_sym->e_scnum == text_shndx && ext_sym->e_type == T_FUNCTION) {
756 for (j = aux_size + 1; j < nb_syms - i; j++) {
757 if ((ext_sym + j)->e_scnum == text_shndx &&
758 (ext_sym + j)->e_type == T_FUNCTION ){
759 sym->st_size = (ext_sym + j)->e_value - ext_sym->e_value;
760 break;
761 } else if (j == nb_syms - i - 1) {
762 sec = &shdr[coff_text_shndx];
763 sym->st_size = sec->s_size - ext_sym->e_value;
764 break;
765 }
766 }
767 } else if (ext_sym->e_scnum == data_shndx && *(uint8_t *)ext_sym->e_sclass == C_EXTERNAL) {
768 for (j = aux_size + 1; j < nb_syms - i; j++) {
769 if ((ext_sym + j)->e_scnum == data_shndx) {
770 sym->st_size = (ext_sym + j)->e_value - ext_sym->e_value;
771 break;
772 } else if (j == nb_syms - i - 1) {
773 sec = &shdr[coff_data_shndx];
774 sym->st_size = sec->s_size - ext_sym->e_value;
775 break;
776 }
777 }
778 } else {
779 sym->st_size = 0;
780 }
781
782 sym->st_type = ext_sym->e_type;
783 sym->st_shndx = ext_sym->e_scnum;
784 }
785
786
787 /* find text relocations, if any */
788 sec = &shdr[coff_text_shndx];
789 coff_relocs = load_data(fd, sec->s_relptr, sec->s_nreloc*RELSZ);
790 nb_relocs = sec->s_nreloc;
791
792 /* set coff relocation */
793 relocs = malloc(sizeof(struct coff_rel) * nb_relocs);
794 for (i = 0, ext_rel = coff_relocs, rel = relocs; i < nb_relocs;
795 i++, ext_rel++, rel++) {
796 memset(rel, 0, sizeof(*rel));
797 rel->r_reloc = ext_rel;
798 rel->r_offset = *(uint32_t *)ext_rel->r_vaddr;
799 rel->r_type = *(uint16_t *)ext_rel->r_type;
800 }
801 return 0;
802 }
803
804 #endif /* CONFIG_FORMAT_COFF */
805
806 #ifdef CONFIG_FORMAT_MACH
807
808 /* File Header */
809 struct mach_header mach_hdr;
810
811 /* commands */
812 struct segment_command *segment = 0;
813 struct dysymtab_command *dysymtabcmd = 0;
814 struct symtab_command *symtabcmd = 0;
815
816 /* section */
817 struct section *section_hdr;
818 struct section *text_sec_hdr;
819 uint8_t **sdata;
820
821 /* relocs */
822 struct relocation_info *relocs;
823
824 /* symbols */
825 EXE_SYM *symtab;
826 struct nlist *symtab_std;
827 char *strtab;
828
829 /* indirect symbols */
830 uint32_t *tocdylib;
831
832 /* Utility functions */
833
834 static inline char *find_str_by_index(int index)
835 {
836 return strtab+index;
837 }
838
839 /* Used by dyngen common code */
840 static char *get_sym_name(EXE_SYM *sym)
841 {
842 char *name = find_str_by_index(sym->n_un.n_strx);
843
844 if ( sym->n_type & N_STAB ) /* Debug symbols are ignored */
845 return "debug";
846
847 if(!name)
848 return name;
849 if(name[0]=='_')
850 return name + 1;
851 else
852 return name;
853 }
854
855 /* find a section index given its segname, sectname */
856 static int find_mach_sec_index(struct section *section_hdr, int shnum, const char *segname,
857 const char *sectname)
858 {
859 int i;
860 struct section *sec = section_hdr;
861
862 for(i = 0; i < shnum; i++, sec++) {
863 if (!sec->segname || !sec->sectname)
864 continue;
865 if (!strcmp(sec->sectname, sectname) && !strcmp(sec->segname, segname))
866 return i;
867 }
868 return -1;
869 }
870
871 /* find a section header given its segname, sectname */
872 struct section *find_mach_sec_hdr(struct section *section_hdr, int shnum, const char *segname,
873 const char *sectname)
874 {
875 int index = find_mach_sec_index(section_hdr, shnum, segname, sectname);
876 if(index == -1)
877 return NULL;
878 return section_hdr+index;
879 }
880
881
882 static inline void fetch_next_pair_value(struct relocation_info * rel, unsigned int *value)
883 {
884 struct scattered_relocation_info * scarel;
885
886 if(R_SCATTERED & rel->r_address) {
887 scarel = (struct scattered_relocation_info*)rel;
888 if(scarel->r_type != PPC_RELOC_PAIR)
889 error("fetch_next_pair_value: looking for a pair which was not found (1)");
890 *value = scarel->r_value;
891 } else {
892 if(rel->r_type != PPC_RELOC_PAIR)
893 error("fetch_next_pair_value: looking for a pair which was not found (2)");
894 *value = rel->r_address;
895 }
896 }
897
898 /* find a sym name given its value, in a section number */
899 static const char * find_sym_with_value_and_sec_number( int value, int sectnum, int * offset )
900 {
901 int i, ret = -1;
902
903 for( i = 0 ; i < nb_syms; i++ )
904 {
905 if( !(symtab[i].n_type & N_STAB) && (symtab[i].n_type & N_SECT) &&
906 (symtab[i].n_sect == sectnum) && (symtab[i].st_value <= value) )
907 {
908 if( (ret<0) || (symtab[i].st_value >= symtab[ret].st_value) )
909 ret = i;
910 }
911 }
912 if( ret < 0 ) {
913 *offset = 0;
914 return 0;
915 } else {
916 *offset = value - symtab[ret].st_value;
917 return get_sym_name(&symtab[ret]);
918 }
919 }
920
921 /*
922 * Find symbol name given a (virtual) address, and a section which is of type
923 * S_NON_LAZY_SYMBOL_POINTERS or S_LAZY_SYMBOL_POINTERS or S_SYMBOL_STUBS
924 */
925 static const char * find_reloc_name_in_sec_ptr(int address, struct section * sec_hdr)
926 {
927 unsigned int tocindex, symindex, size;
928 const char *name = 0;
929
930 /* Sanity check */
931 if(!( address >= sec_hdr->addr && address < (sec_hdr->addr + sec_hdr->size) ) )
932 return (char*)0;
933
934 if( sec_hdr->flags & S_SYMBOL_STUBS ){
935 size = sec_hdr->reserved2;
936 if(size == 0)
937 error("size = 0");
938
939 }
940 else if( sec_hdr->flags & S_LAZY_SYMBOL_POINTERS ||
941 sec_hdr->flags & S_NON_LAZY_SYMBOL_POINTERS)
942 size = sizeof(unsigned long);
943 else
944 return 0;
945
946 /* Compute our index in toc */
947 tocindex = (address - sec_hdr->addr)/size;
948 symindex = tocdylib[sec_hdr->reserved1 + tocindex];
949
950 name = get_sym_name(&symtab[symindex]);
951
952 return name;
953 }
954
955 static const char * find_reloc_name_given_its_address(int address)
956 {
957 unsigned int i;
958 for(i = 0; i < segment->nsects ; i++)
959 {
960 const char * name = find_reloc_name_in_sec_ptr(address, &section_hdr[i]);
961 if((long)name != -1)
962 return name;
963 }
964 return 0;
965 }
966
967 static const char * get_reloc_name(EXE_RELOC * rel, int * sslide)
968 {
969 char * name = 0;
970 struct scattered_relocation_info * sca_rel = (struct scattered_relocation_info*)rel;
971 int sectnum = rel->r_symbolnum;
972 int sectoffset;
973 int other_half=0;
974
975 /* init the slide value */
976 *sslide = 0;
977
978 if(R_SCATTERED & rel->r_address)
979 return (char *)find_reloc_name_given_its_address(sca_rel->r_value);
980
981 if(rel->r_extern)
982 {
983 /* ignore debug sym */
984 if ( symtab[rel->r_symbolnum].n_type & N_STAB )
985 return 0;
986 return get_sym_name(&symtab[rel->r_symbolnum]);
987 }
988
989 /* Intruction contains an offset to the symbols pointed to, in the rel->r_symbolnum section */
990 sectoffset = *(uint32_t *)(text + rel->r_address) & 0xffff;
991
992 if(sectnum==0xffffff)
993 return 0;
994
995 /* Sanity Check */
996 if(sectnum > segment->nsects)
997 error("sectnum > segment->nsects");
998
999 switch(rel->r_type)
1000 {
1001 case PPC_RELOC_LO16: fetch_next_pair_value(rel+1, &other_half); sectoffset |= (other_half << 16);
1002 break;
1003 case PPC_RELOC_HI16: fetch_next_pair_value(rel+1, &other_half); sectoffset = (sectoffset << 16) | (uint16_t)(other_half & 0xffff);
1004 break;
1005 case PPC_RELOC_HA16: fetch_next_pair_value(rel+1, &other_half); sectoffset = (sectoffset << 16) + (int16_t)(other_half & 0xffff);
1006 break;
1007 case PPC_RELOC_BR24:
1008 sectoffset = ( *(uint32_t *)(text + rel->r_address) & 0x03fffffc );
1009 if (sectoffset & 0x02000000) sectoffset |= 0xfc000000;
1010 break;
1011 default:
1012 error("switch(rel->type) not found");
1013 }
1014
1015 if(rel->r_pcrel)
1016 sectoffset += rel->r_address;
1017
1018 if (rel->r_type == PPC_RELOC_BR24)
1019 name = (char *)find_reloc_name_in_sec_ptr((int)sectoffset, &section_hdr[sectnum-1]);
1020
1021 /* search it in the full symbol list, if not found */
1022 if(!name)
1023 name = (char *)find_sym_with_value_and_sec_number(sectoffset, sectnum, sslide);
1024
1025 return name;
1026 }
1027
1028 /* Used by dyngen common code */
1029 static const char * get_rel_sym_name(EXE_RELOC * rel)
1030 {
1031 int sslide;
1032 return get_reloc_name( rel, &sslide);
1033 }
1034
1035 /* Used by dyngen common code */
1036 static host_ulong get_rel_offset(EXE_RELOC *rel)
1037 {
1038 struct scattered_relocation_info * sca_rel = (struct scattered_relocation_info*)rel;
1039 if(R_SCATTERED & rel->r_address)
1040 return sca_rel->r_address;
1041 else
1042 return rel->r_address;
1043 }
1044
1045 /* load a mach-o object file */
1046 int load_object(const char *filename)
1047 {
1048 int fd;
1049 unsigned int offset_to_segment = 0;
1050 unsigned int offset_to_dysymtab = 0;
1051 unsigned int offset_to_symtab = 0;
1052 struct load_command lc;
1053 unsigned int i, j;
1054 EXE_SYM *sym;
1055 struct nlist *syment;
1056
1057 fd = open(filename, O_RDONLY);
1058 if (fd < 0)
1059 error("can't open file '%s'", filename);
1060
1061 /* Read Mach header. */
1062 if (read(fd, &mach_hdr, sizeof (mach_hdr)) != sizeof (mach_hdr))
1063 error("unable to read file header");
1064
1065 /* Check Mach identification. */
1066 if (!check_mach_header(mach_hdr)) {
1067 error("bad Mach header");
1068 }
1069
1070 if (mach_hdr.cputype != CPU_TYPE_POWERPC)
1071 error("Unsupported CPU");
1072
1073 if (mach_hdr.filetype != MH_OBJECT)
1074 error("Unsupported Mach Object");
1075
1076 /* read segment headers */
1077 for(i=0, j=sizeof(mach_hdr); i<mach_hdr.ncmds ; i++)
1078 {
1079 if(read(fd, &lc, sizeof(struct load_command)) != sizeof(struct load_command))
1080 error("unable to read load_command");
1081 if(lc.cmd == LC_SEGMENT)
1082 {
1083 offset_to_segment = j;
1084 lseek(fd, offset_to_segment, SEEK_SET);
1085 segment = malloc(sizeof(struct segment_command));
1086 if(read(fd, segment, sizeof(struct segment_command)) != sizeof(struct segment_command))
1087 error("unable to read LC_SEGMENT");
1088 }
1089 if(lc.cmd == LC_DYSYMTAB)
1090 {
1091 offset_to_dysymtab = j;
1092 lseek(fd, offset_to_dysymtab, SEEK_SET);
1093 dysymtabcmd = malloc(sizeof(struct dysymtab_command));
1094 if(read(fd, dysymtabcmd, sizeof(struct dysymtab_command)) != sizeof(struct dysymtab_command))
1095 error("unable to read LC_DYSYMTAB");
1096 }
1097 if(lc.cmd == LC_SYMTAB)
1098 {
1099 offset_to_symtab = j;
1100 lseek(fd, offset_to_symtab, SEEK_SET);
1101 symtabcmd = malloc(sizeof(struct symtab_command));
1102 if(read(fd, symtabcmd, sizeof(struct symtab_command)) != sizeof(struct symtab_command))
1103 error("unable to read LC_SYMTAB");
1104 }
1105 j+=lc.cmdsize;
1106
1107 lseek(fd, j, SEEK_SET);
1108 }
1109
1110 if(!segment)
1111 error("unable to find LC_SEGMENT");
1112
1113 /* read section headers */
1114 section_hdr = load_data(fd, offset_to_segment + sizeof(struct segment_command), segment->nsects * sizeof(struct section));
1115
1116 /* read all section data */
1117 sdata = (uint8_t **)malloc(sizeof(void *) * segment->nsects);
1118 memset(sdata, 0, sizeof(void *) * segment->nsects);
1119
1120 /* Load the data in section data */
1121 for(i = 0; i < segment->nsects; i++) {
1122 sdata[i] = load_data(fd, section_hdr[i].offset, section_hdr[i].size);
1123 }
1124
1125 /* text section */
1126 text_sec_hdr = find_mach_sec_hdr(section_hdr, segment->nsects, SEG_TEXT, SECT_TEXT);
1127 i = find_mach_sec_index(section_hdr, segment->nsects, SEG_TEXT, SECT_TEXT);
1128 if (i == -1 || !text_sec_hdr)
1129 error("could not find __TEXT,__text section");
1130 text = sdata[i];
1131
1132 /* Make sure dysym was loaded */
1133 if(!(int)dysymtabcmd)
1134 error("could not find __DYSYMTAB segment");
1135
1136 /* read the table of content of the indirect sym */
1137 tocdylib = load_data( fd, dysymtabcmd->indirectsymoff, dysymtabcmd->nindirectsyms * sizeof(uint32_t) );
1138
1139 /* Make sure symtab was loaded */
1140 if(!(int)symtabcmd)
1141 error("could not find __SYMTAB segment");
1142 nb_syms = symtabcmd->nsyms;
1143
1144 symtab_std = load_data(fd, symtabcmd->symoff, symtabcmd->nsyms * sizeof(struct nlist));
1145 strtab = load_data(fd, symtabcmd->stroff, symtabcmd->strsize);
1146
1147 symtab = malloc(sizeof(EXE_SYM) * nb_syms);
1148
1149 /* Now transform the symtab, to an extended version, with the sym size, and the C name */
1150 for(i = 0, sym = symtab, syment = symtab_std; i < nb_syms; i++, sym++, syment++) {
1151 struct nlist *sym_follow, *sym_next = 0;
1152 unsigned int j;
1153 memset(sym, 0, sizeof(*sym));
1154
1155 if ( syment->n_type & N_STAB ) /* Debug symbols are skipped */
1156 continue;
1157
1158 memcpy(sym, syment, sizeof(*syment));
1159
1160 /* Find the following symbol in order to get the current symbol size */
1161 for(j = 0, sym_follow = symtab_std; j < nb_syms; j++, sym_follow++) {
1162 if ( sym_follow->n_sect != 1 || sym_follow->n_type & N_STAB || !(sym_follow->n_value > sym->st_value))
1163 continue;
1164 if(!sym_next) {
1165 sym_next = sym_follow;
1166 continue;
1167 }
1168 if(!(sym_next->n_value > sym_follow->n_value))
1169 continue;
1170 sym_next = sym_follow;
1171 }
1172 if(sym_next)
1173 sym->st_size = sym_next->n_value - sym->st_value;
1174 else
1175 sym->st_size = text_sec_hdr->size - sym->st_value;
1176 }
1177
1178 /* Find Reloc */
1179 relocs = load_data(fd, text_sec_hdr->reloff, text_sec_hdr->nreloc * sizeof(struct relocation_info));
1180 nb_relocs = text_sec_hdr->nreloc;
1181
1182 close(fd);
1183 return 0;
1184 }
1185
1186 #endif /* CONFIG_FORMAT_MACH */
1187
1188 void get_reloc_expr(char *name, int name_size, const char *sym_name)
1189 {
1190 const char *p;
1191
1192 if (strstart(sym_name, "__op_param", &p)) {
1193 snprintf(name, name_size, "param%s", p);
1194 } else if (strstart(sym_name, "__op_gen_label", &p)) {
1195 snprintf(name, name_size, "gen_labels[param%s]", p);
1196 } else {
1197 #ifdef HOST_SPARC
1198 if (sym_name[0] == '.')
1199 snprintf(name, name_size,
1200 "(long)(&__dot_%s)",
1201 sym_name + 1);
1202 else
1203 #endif
1204 snprintf(name, name_size, "(long)(&%s)", sym_name);
1205 }
1206 }
1207
1208 #ifdef HOST_IA64
1209
1210 #define PLT_ENTRY_SIZE 16 /* 1 bundle containing "brl" */
1211
1212 struct plt_entry {
1213 struct plt_entry *next;
1214 const char *name;
1215 unsigned long addend;
1216 } *plt_list;
1217
1218 static int
1219 get_plt_index (const char *name, unsigned long addend)
1220 {
1221 struct plt_entry *plt, *prev= NULL;
1222 int index = 0;
1223
1224 /* see if we already have an entry for this target: */
1225 for (plt = plt_list; plt; ++index, prev = plt, plt = plt->next)
1226 if (strcmp(plt->name, name) == 0 && plt->addend == addend)
1227 return index;
1228
1229 /* nope; create a new PLT entry: */
1230
1231 plt = malloc(sizeof(*plt));
1232 if (!plt) {
1233 perror("malloc");
1234 exit(1);
1235 }
1236 memset(plt, 0, sizeof(*plt));
1237 plt->name = strdup(name);
1238 plt->addend = addend;
1239
1240 /* append to plt-list: */
1241 if (prev)
1242 prev->next = plt;
1243 else
1244 plt_list = plt;
1245 return index;
1246 }
1247
1248 #endif
1249
1250 #ifdef HOST_ARM
1251
1252 int arm_emit_ldr_info(const char *name, unsigned long start_offset,
1253 FILE *outfile, uint8_t *p_start, uint8_t *p_end,
1254 ELF_RELOC *relocs, int nb_relocs)
1255 {
1256 uint8_t *p;
1257 uint32_t insn;
1258 int offset, min_offset, pc_offset, data_size, spare, max_pool;
1259 uint8_t data_allocated[1024];
1260 unsigned int data_index;
1261 int type;
1262
1263 memset(data_allocated, 0, sizeof(data_allocated));
1264
1265 p = p_start;
1266 min_offset = p_end - p_start;
1267 spare = 0x7fffffff;
1268 while (p < p_start + min_offset) {
1269 insn = get32((uint32_t *)p);
1270 /* TODO: Armv5e ldrd. */
1271 /* TODO: VFP load. */
1272 if ((insn & 0x0d5f0000) == 0x051f0000) {
1273 /* ldr reg, [pc, #im] */
1274 offset = insn & 0xfff;
1275 if (!(insn & 0x00800000))
1276 offset = -offset;
1277 max_pool = 4096;
1278 type = 0;
1279 } else if ((insn & 0x0e5f0f00) == 0x0c1f0100) {
1280 /* FPA ldf. */
1281 offset = (insn & 0xff) << 2;
1282 if (!(insn & 0x00800000))
1283 offset = -offset;
1284 max_pool = 1024;
1285 type = 1;
1286 } else if ((insn & 0x0fff0000) == 0x028f0000) {
1287 /* Some gcc load a doubleword immediate with
1288 add regN, pc, #imm
1289 ldmia regN, {regN, regM}
1290 Hope and pray the compiler never generates somethin like
1291 add reg, pc, #imm1; ldr reg, [reg, #-imm2]; */
1292 int r;
1293
1294 r = (insn & 0xf00) >> 7;
1295 offset = ((insn & 0xff) >> r) | ((insn & 0xff) << (32 - r));
1296 max_pool = 1024;
1297 type = 2;
1298 } else {
1299 max_pool = 0;
1300 type = -1;
1301 }
1302 if (type >= 0) {
1303 /* PC-relative load needs fixing up. */
1304 if (spare > max_pool - offset)
1305 spare = max_pool - offset;
1306 if ((offset & 3) !=0)
1307 error("%s:%04x: pc offset must be 32 bit aligned",
1308 name, start_offset + p - p_start);
1309 if (offset < 0)
1310 error("%s:%04x: Embedded literal value",
1311 name, start_offset + p - p_start);
1312 pc_offset = p - p_start + offset + 8;
1313 if (pc_offset <= (p - p_start) ||
1314 pc_offset >= (p_end - p_start))
1315 error("%s:%04x: pc offset must point inside the function code",
1316 name, start_offset + p - p_start);
1317 if (pc_offset < min_offset)
1318 min_offset = pc_offset;
1319 if (outfile) {
1320 /* The intruction position */
1321 fprintf(outfile, " arm_ldr_ptr->ptr = gen_code_ptr + %d;\n",
1322 p - p_start);
1323 /* The position of the constant pool data. */
1324 data_index = ((p_end - p_start) - pc_offset) >> 2;
1325 fprintf(outfile, " arm_ldr_ptr->data_ptr = arm_data_ptr - %d;\n",
1326 data_index);
1327 fprintf(outfile, " arm_ldr_ptr->type = %d;\n", type);
1328 fprintf(outfile, " arm_ldr_ptr++;\n");
1329 }
1330 }
1331 p += 4;
1332 }
1333
1334 /* Copy and relocate the constant pool data. */
1335 data_size = (p_end - p_start) - min_offset;
1336 if (data_size > 0 && outfile) {
1337 spare += min_offset;
1338 fprintf(outfile, " arm_data_ptr -= %d;\n", data_size >> 2);
1339 fprintf(outfile, " arm_pool_ptr -= %d;\n", data_size);
1340 fprintf(outfile, " if (arm_pool_ptr > gen_code_ptr + %d)\n"
1341 " arm_pool_ptr = gen_code_ptr + %d;\n",
1342 spare, spare);
1343
1344 data_index = 0;
1345 for (pc_offset = min_offset;
1346 pc_offset < p_end - p_start;
1347 pc_offset += 4) {
1348
1349 ELF_RELOC *rel;
1350 int i, addend, type;
1351 const char *sym_name;
1352 char relname[1024];
1353
1354 /* data value */
1355 addend = get32((uint32_t *)(p_start + pc_offset));
1356 relname[0] = '\0';
1357 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
1358 if (rel->r_offset == (pc_offset + start_offset)) {
1359 sym_name = get_rel_sym_name(rel);
1360 /* the compiler leave some unnecessary references to the code */
1361 get_reloc_expr(relname, sizeof(relname), sym_name);
1362 type = ELF32_R_TYPE(rel->r_info);
1363 if (type != R_ARM_ABS32)
1364 error("%s: unsupported data relocation", name);
1365 break;
1366 }
1367 }
1368 fprintf(outfile, " arm_data_ptr[%d] = 0x%x",
1369 data_index, addend);
1370 if (relname[0] != '\0')
1371 fprintf(outfile, " + %s", relname);
1372 fprintf(outfile, ";\n");
1373
1374 data_index++;
1375 }
1376 }
1377
1378 if (p == p_start)
1379 goto arm_ret_error;
1380 p -= 4;
1381 insn = get32((uint32_t *)p);
1382 /* The last instruction must be an ldm instruction. There are several
1383 forms generated by gcc:
1384 ldmib sp, {..., pc} (implies a sp adjustment of +4)
1385 ldmia sp, {..., pc}
1386 ldmea fp, {..., pc} */
1387 if ((insn & 0xffff8000) == 0xe99d8000) {
1388 if (outfile) {
1389 fprintf(outfile,
1390 " *(uint32_t *)(gen_code_ptr + %d) = 0xe28dd004;\n",
1391 p - p_start);
1392 }
1393 p += 4;
1394 } else if ((insn & 0xffff8000) != 0xe89d8000
1395 && (insn & 0xffff8000) != 0xe91b8000) {
1396 arm_ret_error:
1397 if (!outfile)
1398 printf("%s: invalid epilog\n", name);
1399 }
1400 return p - p_start;
1401 }
1402 #endif
1403
1404
1405 #define MAX_ARGS 3
1406
1407 /* generate op code */
1408 void gen_code(const char *name, host_ulong offset, host_ulong size,
1409 FILE *outfile, int gen_switch)
1410 {
1411 int copy_size = 0;
1412 uint8_t *p_start, *p_end;
1413 host_ulong start_offset;
1414 int nb_args, i, n;
1415 uint8_t args_present[MAX_ARGS];
1416 const char *sym_name, *p;
1417 EXE_RELOC *rel;
1418
1419 /* Compute exact size excluding prologue and epilogue instructions.
1420 * Increment start_offset to skip epilogue instructions, then compute
1421 * copy_size the indicate the size of the remaining instructions (in
1422 * bytes).
1423 */
1424 p_start = text + offset;
1425 p_end = p_start + size;
1426 start_offset = offset;
1427 #if defined(HOST_I386) || defined(HOST_X86_64)
1428 #ifdef CONFIG_FORMAT_COFF
1429 {
1430 uint8_t *p;
1431 p = p_end - 1;
1432 if (p == p_start)
1433 error("empty code for %s", name);
1434 while (*p != 0xc3) {
1435 p--;
1436 if (p <= p_start)
1437 error("ret or jmp expected at the end of %s", name);
1438 }
1439 copy_size = p - p_start;
1440 }
1441 #else
1442 {
1443 int len;
1444 len = p_end - p_start;
1445 if (len == 0)
1446 error("empty code for %s", name);
1447 if (p_end[-1] == 0xc3) {
1448 len--;
1449 } else {
1450 error("ret or jmp expected at the end of %s", name);
1451 }
1452 copy_size = len;
1453 }
1454 #endif
1455 #elif defined(HOST_PPC)
1456 {
1457 uint8_t *p;
1458 p = (void *)(p_end - 4);
1459 if (p == p_start)
1460 error("empty code for %s", name);
1461 if (get32((uint32_t *)p) != 0x4e800020)
1462 error("blr expected at the end of %s", name);
1463 copy_size = p - p_start;
1464 }
1465 #elif defined(HOST_S390)
1466 {
1467 uint8_t *p;
1468 p = (void *)(p_end - 2);
1469 if (p == p_start)
1470 error("empty code for %s", name);
1471 if (get16((uint16_t *)p) != 0x07fe && get16((uint16_t *)p) != 0x07f4)
1472 error("br %%r14 expected at the end of %s", name);
1473 copy_size = p - p_start;
1474 }
1475 #elif defined(HOST_ALPHA)
1476 {
1477 uint8_t *p;
1478 p = p_end - 4;
1479 #if 0
1480 /* XXX: check why it occurs */
1481 if (p == p_start)
1482 error("empty code for %s", name);
1483 #endif
1484 if (get32((uint32_t *)p) != 0x6bfa8001)
1485 error("ret expected at the end of %s", name);
1486 copy_size = p - p_start;
1487 }
1488 #elif defined(HOST_IA64)
1489 {
1490 uint8_t *p;
1491 p = (void *)(p_end - 4);
1492 if (p == p_start)
1493 error("empty code for %s", name);
1494 /* br.ret.sptk.many b0;; */
1495 /* 08 00 84 00 */
1496 if (get32((uint32_t *)p) != 0x00840008)
1497 error("br.ret.sptk.many b0;; expected at the end of %s", name);
1498 copy_size = p_end - p_start;
1499 }
1500 #elif defined(HOST_SPARC)
1501 {
1502 #define INSN_SAVE 0x9de3a000
1503 #define INSN_RET 0x81c7e008
1504 #define INSN_RETL 0x81c3e008
1505 #define INSN_RESTORE 0x81e80000
1506 #define INSN_RETURN 0x81cfe008
1507 #define INSN_NOP 0x01000000
1508 #define INSN_ADD_SP 0x9c03a000 // add %sp, nn, %sp
1509 #define INSN_SUB_SP 0x9c23a000 // sub %sp, nn, %sp
1510
1511 uint32_t start_insn, end_insn1, end_insn2;
1512 uint8_t *p;
1513 p = (void *)(p_end - 8);
1514 if (p <= p_start)
1515 error("empty code for %s", name);
1516 start_insn = get32((uint32_t *)(p_start + 0x0));
1517 end_insn1 = get32((uint32_t *)(p + 0x0));
1518 end_insn2 = get32((uint32_t *)(p + 0x4));
1519 if (((start_insn & ~0x1fff) == INSN_SAVE) ||
1520 (start_insn & ~0x1fff) == INSN_ADD_SP) {
1521 p_start += 0x4;
1522 start_offset += 0x4;
1523 if (end_insn1 == INSN_RET && end_insn2 == INSN_RESTORE)
1524 /* SPARC v7: ret; restore; */ ;
1525 else if (end_insn1 == INSN_RETURN && end_insn2 == INSN_NOP)
1526 /* SPARC v9: return; nop; */ ;
1527 else if (end_insn1 == INSN_RETL && (end_insn2 & ~0x1fff) == INSN_SUB_SP)
1528 /* SPARC v7: retl; sub %sp, nn, %sp; */ ;
1529 else
1530
1531 error("ret; restore; not found at end of %s", name);
1532 } else if (end_insn1 == INSN_RETL && end_insn2 == INSN_NOP) {
1533 ;
1534 } else {
1535 error("No save at the beginning of %s", name);
1536 }
1537 #if 0
1538 /* Skip a preceeding nop, if present. */
1539 if (p > p_start) {
1540 skip_insn = get32((uint32_t *)(p - 0x4));
1541 if (skip_insn == INSN_NOP)
1542 p -= 4;
1543 }
1544 #endif
1545 copy_size = p - p_start;
1546 }
1547 #elif defined(HOST_SPARC64)
1548 {
1549 #define INSN_SAVE 0x9de3a000
1550 #define INSN_RET 0x81c7e008
1551 #define INSN_RETL 0x81c3e008
1552 #define INSN_RESTORE 0x81e80000
1553 #define INSN_RETURN 0x81cfe008
1554 #define INSN_NOP 0x01000000
1555 #define INSN_ADD_SP 0x9c03a000 // add %sp, nn, %sp
1556 #define INSN_SUB_SP 0x9c23a000 // sub %sp, nn, %sp
1557
1558 uint32_t start_insn, end_insn1, end_insn2, skip_insn;
1559 uint8_t *p;
1560 p = (void *)(p_end - 8);
1561 #if 0
1562 /* XXX: check why it occurs */
1563 if (p <= p_start)
1564 error("empty code for %s", name);
1565 #endif
1566 start_insn = get32((uint32_t *)(p_start + 0x0));
1567 end_insn1 = get32((uint32_t *)(p + 0x0));
1568 end_insn2 = get32((uint32_t *)(p + 0x4));
1569 if (((start_insn & ~0x1fff) == INSN_SAVE) ||
1570 (start_insn & ~0x1fff) == INSN_ADD_SP) {
1571 p_start += 0x4;
1572 start_offset += 0x4;
1573 if (end_insn1 == INSN_RET && end_insn2 == INSN_RESTORE)
1574 /* SPARC v7: ret; restore; */ ;
1575 else if (end_insn1 == INSN_RETURN && end_insn2 == INSN_NOP)
1576 /* SPARC v9: return; nop; */ ;
1577 else if (end_insn1 == INSN_RETL && (end_insn2 & ~0x1fff) == INSN_SUB_SP)
1578 /* SPARC v7: retl; sub %sp, nn, %sp; */ ;
1579 else
1580
1581 error("ret; restore; not found at end of %s", name);
1582 } else if (end_insn1 == INSN_RETL && end_insn2 == INSN_NOP) {
1583 ;
1584 } else {
1585 error("No save at the beginning of %s", name);
1586 }
1587
1588 /* Skip a preceeding nop, if present. */
1589 if (p > p_start) {
1590 skip_insn = get32((uint32_t *)(p - 0x4));
1591 if (skip_insn == 0x01000000)
1592 p -= 4;
1593 }
1594
1595 copy_size = p - p_start;
1596 }
1597 #elif defined(HOST_ARM)
1598 {
1599 uint32_t insn;
1600
1601 if ((p_end - p_start) <= 16)
1602 error("%s: function too small", name);
1603 if (get32((uint32_t *)p_start) != 0xe1a0c00d ||
1604 (get32((uint32_t *)(p_start + 4)) & 0xffff0000) != 0xe92d0000 ||
1605 get32((uint32_t *)(p_start + 8)) != 0xe24cb004)
1606 error("%s: invalid prolog", name);
1607 p_start += 12;
1608 start_offset += 12;
1609 insn = get32((uint32_t *)p_start);
1610 if ((insn & 0xffffff00) == 0xe24dd000) {
1611 /* Stack adjustment. Assume op uses the frame pointer. */
1612 p_start -= 4;
1613 start_offset -= 4;
1614 }
1615 copy_size = arm_emit_ldr_info(name, start_offset, NULL, p_start, p_end,
1616 relocs, nb_relocs);
1617 }
1618 #elif defined(HOST_M68K)
1619 {
1620 uint8_t *p;
1621 p = (void *)(p_end - 2);
1622 if (p == p_start)
1623 error("empty code for %s", name);
1624 // remove NOP's, probably added for alignment
1625 while ((get16((uint16_t *)p) == 0x4e71) &&
1626 (p>p_start))
1627 p -= 2;
1628 if (get16((uint16_t *)p) != 0x4e75)
1629 error("rts expected at the end of %s", name);
1630 copy_size = p - p_start;
1631 }
1632 #else
1633 #error unsupported CPU
1634 #endif
1635
1636 /* compute the number of arguments by looking at the relocations */
1637 for(i = 0;i < MAX_ARGS; i++)
1638 args_present[i] = 0;
1639
1640 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
1641 host_ulong offset = get_rel_offset(rel);
1642 if (offset >= start_offset &&
1643 offset < start_offset + (p_end - p_start)) {
1644 sym_name = get_rel_sym_name(rel);
1645 if(!sym_name)
1646 continue;
1647 if (strstart(sym_name, "__op_param", &p) ||
1648 strstart(sym_name, "__op_gen_label", &p)) {
1649 n = strtoul(p, NULL, 10);
1650 if (n > MAX_ARGS)
1651 error("too many arguments in %s", name);
1652 args_present[n - 1] = 1;
1653 }
1654 }
1655 }
1656
1657 nb_args = 0;
1658 while (nb_args < MAX_ARGS && args_present[nb_args])
1659 nb_args++;
1660 for(i = nb_args; i < MAX_ARGS; i++) {
1661 if (args_present[i])
1662 error("inconsistent argument numbering in %s", name);
1663 }
1664
1665 if (gen_switch == 2) {
1666 fprintf(outfile, "DEF(%s, %d, %d)\n", name + 3, nb_args, copy_size);
1667 } else if (gen_switch == 1) {
1668
1669 /* output C code */
1670 fprintf(outfile, "case INDEX_%s: {\n", name);
1671 if (nb_args > 0) {
1672 fprintf(outfile, " long ");
1673 for(i = 0; i < nb_args; i++) {
1674 if (i != 0)
1675 fprintf(outfile, ", ");
1676 fprintf(outfile, "param%d", i + 1);
1677 }
1678 fprintf(outfile, ";\n");
1679 }
1680 #if defined(HOST_IA64)
1681 fprintf(outfile, " extern char %s;\n", name);
1682 #else
1683 fprintf(outfile, " extern void %s();\n", name);
1684 #endif
1685
1686 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
1687 host_ulong offset = get_rel_offset(rel);
1688 if (offset >= start_offset &&
1689 offset < start_offset + (p_end - p_start)) {
1690 sym_name = get_rel_sym_name(rel);
1691 if(!sym_name)
1692 continue;
1693 if (*sym_name &&
1694 !strstart(sym_name, "__op_param", NULL) &&
1695 !strstart(sym_name, "__op_jmp", NULL) &&
1696 !strstart(sym_name, "__op_gen_label", NULL)) {
1697 #if defined(HOST_SPARC)
1698 if (sym_name[0] == '.') {
1699 fprintf(outfile,
1700 "extern char __dot_%s __asm__(\"%s\");\n",
1701 sym_name+1, sym_name);
1702 continue;
1703 }
1704 #endif
1705 #if defined(__APPLE__)
1706 /* set __attribute((unused)) on darwin because we wan't to avoid warning when we don't use the symbol */
1707 fprintf(outfile, "extern char %s __attribute__((unused));\n", sym_name);
1708 #elif defined(HOST_IA64)
1709 if (ELF64_R_TYPE(rel->r_info) != R_IA64_PCREL21B)
1710 /*
1711 * PCREL21 br.call targets generally
1712 * are out of range and need to go
1713 * through an "import stub".
1714 */
1715 fprintf(outfile, " extern char %s;\n",
1716 sym_name);
1717 #else
1718 fprintf(outfile, "extern char %s;\n", sym_name);
1719 #endif
1720 }
1721 }
1722 }
1723
1724 fprintf(outfile, " memcpy(gen_code_ptr, (void *)((char *)&%s+%d), %d);\n",
1725 name, (int)(start_offset - offset), copy_size);
1726
1727 /* emit code offset information */
1728 {
1729 EXE_SYM *sym;
1730 const char *sym_name, *p;
1731 unsigned long val;
1732 int n;
1733
1734 for(i = 0, sym = symtab; i < nb_syms; i++, sym++) {
1735 sym_name = get_sym_name(sym);
1736 if (strstart(sym_name, "__op_label", &p)) {
1737 uint8_t *ptr;
1738 unsigned long offset;
1739
1740 /* test if the variable refers to a label inside
1741 the code we are generating */
1742 #ifdef CONFIG_FORMAT_COFF
1743 if (sym->st_shndx == text_shndx) {
1744 ptr = sdata[coff_text_shndx];
1745 } else if (sym->st_shndx == data_shndx) {
1746 ptr = sdata[coff_data_shndx];
1747 } else {
1748 ptr = NULL;
1749 }
1750 #elif defined(CONFIG_FORMAT_MACH)
1751 if(!sym->n_sect)
1752 continue;
1753 ptr = sdata[sym->n_sect-1];
1754 #else
1755 ptr = sdata[sym->st_shndx];
1756 #endif
1757 if (!ptr)
1758 error("__op_labelN in invalid section");
1759 offset = sym->st_value;
1760 #ifdef CONFIG_FORMAT_MACH
1761 offset -= section_hdr[sym->n_sect-1].addr;
1762 #endif
1763 val = *(unsigned long *)(ptr + offset);
1764 #ifdef ELF_USES_RELOCA
1765 {
1766 int reloc_shndx, nb_relocs1, j;
1767
1768 /* try to find a matching relocation */
1769 reloc_shndx = find_reloc(sym->st_shndx);
1770 if (reloc_shndx) {
1771 nb_relocs1 = shdr[reloc_shndx].sh_size /
1772 shdr[reloc_shndx].sh_entsize;
1773 rel = (ELF_RELOC *)sdata[reloc_shndx];
1774 for(j = 0; j < nb_relocs1; j++) {
1775 if (rel->r_offset == offset) {
1776 val = rel->r_addend;
1777 break;
1778 }
1779 rel++;
1780 }
1781 }
1782 }
1783 #endif
1784 if (val >= start_offset && val <= start_offset + copy_size) {
1785 n = strtol(p, NULL, 10);
1786 fprintf(outfile, " label_offsets[%d] = %ld + (gen_code_ptr - gen_code_buf);\n", n, (long)(val - start_offset));
1787 }
1788 }
1789 }
1790 }
1791
1792 /* load parameres in variables */
1793 for(i = 0; i < nb_args; i++) {
1794 fprintf(outfile, " param%d = *opparam_ptr++;\n", i + 1);
1795 }
1796
1797 /* patch relocations */
1798 #if defined(HOST_I386)
1799 {
1800 char name[256];
1801 int type;
1802 int addend;
1803 int reloc_offset;
1804 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
1805 if (rel->r_offset >= start_offset &&
1806 rel->r_offset < start_offset + copy_size) {
1807 sym_name = get_rel_sym_name(rel);
1808 if (!sym_name)
1809 continue;
1810 reloc_offset = rel->r_offset - start_offset;
1811 if (strstart(sym_name, "__op_jmp", &p)) {
1812 int n;
1813 n = strtol(p, NULL, 10);
1814 /* __op_jmp relocations are done at
1815 runtime to do translated block
1816 chaining: the offset of the instruction
1817 needs to be stored */
1818 fprintf(outfile, " jmp_offsets[%d] = %d + (gen_code_ptr - gen_code_buf);\n",
1819 n, reloc_offset);
1820 continue;
1821 }
1822
1823 get_reloc_expr(name, sizeof(name), sym_name);
1824 addend = get32((uint32_t *)(text + rel->r_offset));
1825 #ifdef CONFIG_FORMAT_ELF
1826 type = ELF32_R_TYPE(rel->r_info);
1827 switch(type) {
1828 case R_386_32:
1829 fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",
1830 reloc_offset, name, addend);
1831 break;
1832 case R_386_PC32:
1833 fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %d) + %d;\n",
1834 reloc_offset, name, reloc_offset, addend);
1835 break;
1836 default:
1837 error("unsupported i386 relocation (%d)", type);
1838 }
1839 #elif defined(CONFIG_FORMAT_COFF)
1840 {
1841 char *temp_name;
1842 int j;
1843 EXE_SYM *sym;
1844 temp_name = get_sym_name(symtab + *(uint32_t *)(rel->r_reloc->r_symndx));
1845 if (!strcmp(temp_name, ".data")) {
1846 for (j = 0, sym = symtab; j < nb_syms; j++, sym++) {
1847 if (strstart(sym->st_name, sym_name, NULL)) {
1848 addend -= sym->st_value;
1849 }
1850 }
1851 }
1852 }
1853 type = rel->r_type;
1854 switch(type) {
1855 case DIR32:
1856 fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",
1857 reloc_offset, name, addend);
1858 break;
1859 case DISP32:
1860 fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %d) + %d -4;\n",
1861 reloc_offset, name, reloc_offset, addend);
1862 break;
1863 default:
1864 error("unsupported i386 relocation (%d)", type);
1865 }
1866 #else
1867 #error unsupport object format
1868 #endif
1869 }
1870 }
1871 }
1872 #elif defined(HOST_X86_64)
1873 {
1874 char name[256];
1875 int type;
1876 int addend;
1877 int reloc_offset;
1878 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
1879 if (rel->r_offset >= start_offset &&
1880 rel->r_offset < start_offset + copy_size) {
1881 sym_name = strtab + symtab[ELFW(R_SYM)(rel->r_info)].st_name;
1882 get_reloc_expr(name, sizeof(name), sym_name);
1883 type = ELF32_R_TYPE(rel->r_info);
1884 addend = rel->r_addend;
1885 reloc_offset = rel->r_offset - start_offset;
1886 switch(type) {
1887 case R_X86_64_32:
1888 fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = (uint32_t)%s + %d;\n",
1889 reloc_offset, name, addend);
1890 break;
1891 case R_X86_64_32S:
1892 fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = (int32_t)%s + %d;\n",
1893 reloc_offset, name, addend);
1894 break;
1895 case R_X86_64_PC32:
1896 fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %d) + %d;\n",
1897 reloc_offset, name, reloc_offset, addend);
1898 break;
1899 default:
1900 error("unsupported X86_64 relocation (%d)", type);
1901 }
1902 }
1903 }
1904 }
1905 #elif defined(HOST_PPC)
1906 {
1907 #ifdef CONFIG_FORMAT_ELF
1908 char name[256];
1909 int type;
1910 int addend;
1911 int reloc_offset;
1912 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
1913 if (rel->r_offset >= start_offset &&
1914 rel->r_offset < start_offset + copy_size) {
1915 sym_name = strtab + symtab[ELFW(R_SYM)(rel->r_info)].st_name;
1916 reloc_offset = rel->r_offset - start_offset;
1917 if (strstart(sym_name, "__op_jmp", &p)) {
1918 int n;
1919 n = strtol(p, NULL, 10);
1920 /* __op_jmp relocations are done at
1921 runtime to do translated block
1922 chaining: the offset of the instruction
1923 needs to be stored */
1924 fprintf(outfile, " jmp_offsets[%d] = %d + (gen_code_ptr - gen_code_buf);\n",
1925 n, reloc_offset);
1926 continue;
1927 }
1928
1929 get_reloc_expr(name, sizeof(name), sym_name);
1930 type = ELF32_R_TYPE(rel->r_info);
1931 addend = rel->r_addend;
1932 switch(type) {
1933 case R_PPC_ADDR32:
1934 fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",
1935 reloc_offset, name, addend);
1936 break;
1937 case R_PPC_ADDR16_LO:
1938 fprintf(outfile, " *(uint16_t *)(gen_code_ptr + %d) = (%s + %d);\n",
1939 reloc_offset, name, addend);
1940 break;
1941 case R_PPC_ADDR16_HI:
1942 fprintf(outfile, " *(uint16_t *)(gen_code_ptr + %d) = (%s + %d) >> 16;\n",
1943 reloc_offset, name, addend);
1944 break;
1945 case R_PPC_ADDR16_HA:
1946 fprintf(outfile, " *(uint16_t *)(gen_code_ptr + %d) = (%s + %d + 0x8000) >> 16;\n",
1947 reloc_offset, name, addend);
1948 break;
1949 case R_PPC_REL24:
1950 /* warning: must be at 32 MB distancy */
1951 fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = (*(uint32_t *)(gen_code_ptr + %d) & ~0x03fffffc) | ((%s - (long)(gen_code_ptr + %d) + %d) & 0x03fffffc);\n",
1952 reloc_offset, reloc_offset, name, reloc_offset, addend);
1953 break;
1954 default:
1955 error("unsupported powerpc relocation (%d)", type);
1956 }
1957 }
1958 }
1959 #elif defined(CONFIG_FORMAT_MACH)
1960 struct scattered_relocation_info *scarel;
1961 struct relocation_info * rel;
1962 char final_sym_name[256];
1963 const char *sym_name;
1964 const char *p;
1965 int slide, sslide;
1966 int i;
1967
1968 for(i = 0, rel = relocs; i < nb_relocs; i++, rel++) {
1969 unsigned int offset, length, value = 0;
1970 unsigned int type, pcrel, isym = 0;
1971 unsigned int usesym = 0;
1972
1973 if(R_SCATTERED & rel->r_address) {
1974 scarel = (struct scattered_relocation_info*)rel;
1975 offset = (unsigned int)scarel->r_address;
1976 length = scarel->r_length;
1977 pcrel = scarel->r_pcrel;
1978 type = scarel->r_type;
1979 value = scarel->r_value;
1980 } else {
1981 value = isym = rel->r_symbolnum;
1982 usesym = (rel->r_extern);
1983 offset = rel->r_address;
1984 length = rel->r_length;
1985 pcrel = rel->r_pcrel;
1986 type = rel->r_type;
1987 }
1988
1989 slide = offset - start_offset;
1990
1991 if (!(offset >= start_offset && offset < start_offset + size))
1992 continue; /* not in our range */
1993
1994 sym_name = get_reloc_name(rel, &sslide);
1995
1996 if(usesym && symtab[isym].n_type & N_STAB)
1997 continue; /* don't handle STAB (debug sym) */
1998
1999 if (sym_name && strstart(sym_name, "__op_jmp", &p)) {
2000 int n;
2001 n = strtol(p, NULL, 10);
2002 fprintf(outfile, " jmp_offsets[%d] = %d + (gen_code_ptr - gen_code_buf);\n",
2003 n, slide);
2004 continue; /* Nothing more to do */
2005 }
2006
2007 if(!sym_name)
2008 {
2009 fprintf(outfile, "/* #warning relocation not handled in %s (value 0x%x, %s, offset 0x%x, length 0x%x, %s, type 0x%x) */\n",
2010 name, value, usesym ? "use sym" : "don't use sym", offset, length, pcrel ? "pcrel":"", type);
2011 continue; /* dunno how to handle without final_sym_name */
2012 }
2013
2014 get_reloc_expr(final_sym_name, sizeof(final_sym_name),
2015 sym_name);
2016 switch(type) {
2017 case PPC_RELOC_BR24:
2018 if (!strstart(sym_name,"__op_gen_label",&p)) {
2019 fprintf(outfile, "{\n");
2020 fprintf(outfile, " uint32_t imm = *(uint32_t *)(gen_code_ptr + %d) & 0x3fffffc;\n", slide);
2021 fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = (*(uint32_t *)(gen_code_ptr + %d) & ~0x03fffffc) | ((imm + ((long)%s - (long)gen_code_ptr) + %d) & 0x03fffffc);\n",
2022 slide, slide, name, sslide );
2023 fprintf(outfile, "}\n");
2024 } else {
2025 fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = (*(uint32_t *)(gen_code_ptr + %d) & ~0x03fffffc) | (((long)%s - (long)gen_code_ptr - %d) & 0x03fffffc);\n",
2026 slide, slide, final_sym_name, slide);
2027 }
2028 break;
2029 case PPC_RELOC_HI16:
2030 fprintf(outfile, " *(uint16_t *)(gen_code_ptr + %d + 2) = (%s + %d) >> 16;\n",
2031 slide, final_sym_name, sslide);
2032 break;
2033 case PPC_RELOC_LO16:
2034 fprintf(outfile, " *(uint16_t *)(gen_code_ptr + %d + 2) = (%s + %d);\n",
2035 slide, final_sym_name, sslide);
2036 break;
2037 case PPC_RELOC_HA16:
2038 fprintf(outfile, " *(uint16_t *)(gen_code_ptr + %d + 2) = (%s + %d + 0x8000) >> 16;\n",
2039 slide, final_sym_name, sslide);
2040 break;
2041 default:
2042 error("unsupported powerpc relocation (%d)", type);
2043 }
2044 }
2045 #else
2046 #error unsupport object format
2047 #endif
2048 }
2049 #elif defined(HOST_S390)
2050 {
2051 char name[256];
2052 int type;
2053 int addend;
2054 int reloc_offset;
2055 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
2056 if (rel->r_offset >= start_offset &&
2057 rel->r_offset < start_offset + copy_size) {
2058 sym_name = strtab + symtab[ELFW(R_SYM)(rel->r_info)].st_name;
2059 get_reloc_expr(name, sizeof(name), sym_name);
2060 type = ELF32_R_TYPE(rel->r_info);
2061 addend = rel->r_addend;
2062 reloc_offset = rel->r_offset - start_offset;
2063 switch(type) {
2064 case R_390_32:
2065 fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",
2066 reloc_offset, name, addend);
2067 break;
2068 case R_390_16:
2069 fprintf(outfile, " *(uint16_t *)(gen_code_ptr + %d) = %s + %d;\n",
2070 reloc_offset, name, addend);
2071 break;
2072 case R_390_8:
2073 fprintf(outfile, " *(uint8_t *)(gen_code_ptr + %d) = %s + %d;\n",
2074 reloc_offset, name, addend);
2075 break;
2076 default:
2077 error("unsupported s390 relocation (%d)", type);
2078 }
2079 }
2080 }
2081 }
2082 #elif defined(HOST_ALPHA)
2083 {
2084 for (i = 0, rel = relocs; i < nb_relocs; i++, rel++) {
2085 if (rel->r_offset >= start_offset && rel->r_offset < start_offset + copy_size) {
2086 int type;
2087 long reloc_offset;
2088
2089 type = ELF64_R_TYPE(rel->r_info);
2090 sym_name = strtab + symtab[ELF64_R_SYM(rel->r_info)].st_name;
2091 reloc_offset = rel->r_offset - start_offset;
2092 switch (type) {
2093 case R_ALPHA_GPDISP:
2094 /* The gp is just 32 bit, and never changes, so it's easiest to emit it
2095 as an immediate instead of constructing it from the pv or ra. */
2096 fprintf(outfile, " immediate_ldah(gen_code_ptr + %ld, gp);\n",
2097 reloc_offset);
2098 fprintf(outfile, " immediate_lda(gen_code_ptr + %ld, gp);\n",
2099 reloc_offset + (int)rel->r_addend);
2100 break;
2101 case R_ALPHA_LITUSE:
2102 /* jsr to literal hint. Could be used to optimize to bsr. Ignore for
2103 now, since some called functions (libc) need pv to be set up. */
2104 break;
2105 case R_ALPHA_HINT:
2106 /* Branch target prediction hint. Ignore for now. Should be already
2107 correct for in-function jumps. */
2108 break;
2109 case R_ALPHA_LITERAL:
2110 /* Load a literal from the GOT relative to the gp. Since there's only a
2111 single gp, nothing is to be done. */
2112 break;
2113 case R_ALPHA_GPRELHIGH:
2114 /* Handle fake relocations against __op_param symbol. Need to emit the
2115 high part of the immediate value instead. Other symbols need no
2116 special treatment. */
2117 if (strstart(sym_name, "__op_param", &p))
2118 fprintf(outfile, " immediate_ldah(gen_code_ptr + %ld, param%s);\n",
2119 reloc_offset, p);
2120 break;
2121 case R_ALPHA_GPRELLOW:
2122 if (strstart(sym_name, "__op_param", &p))
2123 fprintf(outfile, " immediate_lda(gen_code_ptr + %ld, param%s);\n",
2124 reloc_offset, p);
2125 break;
2126 case R_ALPHA_BRSGP:
2127 /* PC-relative jump. Tweak offset to skip the two instructions that try to
2128 set up the gp from the pv. */
2129 fprintf(outfile, " fix_bsr(gen_code_ptr + %ld, (uint8_t *) &%s - (gen_code_ptr + %ld + 4) + 8);\n",
2130 reloc_offset, sym_name, reloc_offset);
2131 break;
2132 default:
2133 error("unsupported Alpha relocation (%d)", type);
2134 }
2135 }
2136 }
2137 }
2138 #elif defined(HOST_IA64)
2139 {
2140 unsigned long sym_idx;
2141 long code_offset;
2142 char name[256];
2143 int type;
2144 long addend;
2145
2146 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
2147 sym_idx = ELF64_R_SYM(rel->r_info);
2148 if (rel->r_offset < start_offset
2149 || rel->r_offset >= start_offset + copy_size)
2150 continue;
2151 sym_name = (strtab + symtab[sym_idx].st_name);
2152 code_offset = rel->r_offset - start_offset;
2153 if (strstart(sym_name, "__op_jmp", &p)) {
2154 int n;
2155 n = strtol(p, NULL, 10);
2156 /* __op_jmp relocations are done at
2157 runtime to do translated block
2158 chaining: the offset of the instruction
2159 needs to be stored */
2160 fprintf(outfile, " jmp_offsets[%d] ="
2161 "%ld + (gen_code_ptr - gen_code_buf);\n",
2162 n, code_offset);
2163 continue;
2164 }
2165 get_reloc_expr(name, sizeof(name), sym_name);
2166 type = ELF64_R_TYPE(rel->r_info);
2167 addend = rel->r_addend;
2168 switch(type) {
2169 case R_IA64_IMM64:
2170 fprintf(outfile,
2171 " ia64_imm64(gen_code_ptr + %ld, "
2172 "%s + %ld);\n",
2173 code_offset, name, addend);
2174 break;
2175 case R_IA64_LTOFF22X:
2176 case R_IA64_LTOFF22:
2177 fprintf(outfile, " IA64_LTOFF(gen_code_ptr + %ld,"
2178 " %s + %ld, %d);\n",
2179 code_offset, name, addend,
2180 (type == R_IA64_LTOFF22X));
2181 break;
2182 case R_IA64_LDXMOV:
2183 fprintf(outfile,
2184 " ia64_ldxmov(gen_code_ptr + %ld,"
2185 " %s + %ld);\n", code_offset, name, addend);
2186 break;
2187
2188 case R_IA64_PCREL21B:
2189 if (strstart(sym_name, "__op_gen_label", NULL)) {
2190 fprintf(outfile,
2191 " ia64_imm21b(gen_code_ptr + %ld,"
2192 " (long) (%s + %ld -\n\t\t"
2193 "((long) gen_code_ptr + %ld)) >> 4);\n",
2194 code_offset, name, addend,
2195 code_offset & ~0xfUL);
2196 } else {
2197 fprintf(outfile,
2198 " IA64_PLT(gen_code_ptr + %ld, "
2199 "%d);\t/* %s + %ld */\n",
2200 code_offset,
2201 get_plt_index(sym_name, addend),
2202 sym_name, addend);
2203 }
2204 break;
2205 default:
2206 error("unsupported ia64 relocation (0x%x)",
2207 type);
2208 }
2209 }
2210 fprintf(outfile, " ia64_nop_b(gen_code_ptr + %d);\n",
2211 copy_size - 16 + 2);
2212 }
2213 #elif defined(HOST_SPARC)
2214 {
2215 char name[256];
2216 int type;
2217 int addend;
2218 int reloc_offset;
2219 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
2220 if (rel->r_offset >= start_offset &&
2221 rel->r_offset < start_offset + copy_size) {
2222 sym_name = strtab + symtab[ELF32_R_SYM(rel->r_info)].st_name;
2223 get_reloc_expr(name, sizeof(name), sym_name);
2224 type = ELF32_R_TYPE(rel->r_info);
2225 addend = rel->r_addend;
2226 reloc_offset = rel->r_offset - start_offset;
2227 switch(type) {
2228 case R_SPARC_32:
2229 fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",
2230 reloc_offset, name, addend);
2231 break;
2232 case R_SPARC_HI22:
2233 fprintf(outfile,
2234 " *(uint32_t *)(gen_code_ptr + %d) = "
2235 "((*(uint32_t *)(gen_code_ptr + %d)) "
2236 " & ~0x3fffff) "
2237 " | (((%s + %d) >> 10) & 0x3fffff);\n",
2238 reloc_offset, reloc_offset, name, addend);
2239 break;
2240 case R_SPARC_LO10:
2241 fprintf(outfile,
2242 " *(uint32_t *)(gen_code_ptr + %d) = "
2243 "((*(uint32_t *)(gen_code_ptr + %d)) "
2244 " & ~0x3ff) "
2245 " | ((%s + %d) & 0x3ff);\n",
2246 reloc_offset, reloc_offset, name, addend);
2247 break;
2248 case R_SPARC_WDISP30:
2249 fprintf(outfile,
2250 " *(uint32_t *)(gen_code_ptr + %d) = "
2251 "((*(uint32_t *)(gen_code_ptr + %d)) "
2252 " & ~0x3fffffff) "
2253 " | ((((%s + %d) - (long)(gen_code_ptr + %d))>>2) "
2254 " & 0x3fffffff);\n",
2255 reloc_offset, reloc_offset, name, addend,
2256 reloc_offset);
2257 break;
2258 case R_SPARC_WDISP22:
2259 fprintf(outfile,
2260 " *(uint32_t *)(gen_code_ptr + %d) = "
2261 "((*(uint32_t *)(gen_code_ptr + %d)) "
2262 " & ~0x3fffff) "
2263 " | ((((%s + %d) - (long)(gen_code_ptr + %d))>>2) "
2264 " & 0x3fffff);\n",
2265 rel->r_offset - start_offset,
2266 rel->r_offset - start_offset,
2267 name, addend,
2268 rel->r_offset - start_offset);
2269 break;
2270 default:
2271 error("unsupported sparc relocation (%d)", type);
2272 }
2273 }
2274 }
2275 }
2276 #elif defined(HOST_SPARC64)
2277 {
2278 char name[256];
2279 int type;
2280 int addend;
2281 int reloc_offset;
2282 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
2283 if (rel->r_offset >= start_offset &&
2284 rel->r_offset < start_offset + copy_size) {
2285 sym_name = strtab + symtab[ELF64_R_SYM(rel->r_info)].st_name;
2286 get_reloc_expr(name, sizeof(name), sym_name);
2287 type = ELF32_R_TYPE(rel->r_info);
2288 addend = rel->r_addend;
2289 reloc_offset = rel->r_offset - start_offset;
2290 switch(type) {
2291 case R_SPARC_32:
2292 fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",
2293 reloc_offset, name, addend);
2294 break;
2295 case R_SPARC_HI22:
2296 fprintf(outfile,
2297 " *(uint32_t *)(gen_code_ptr + %d) = "
2298 "((*(uint32_t *)(gen_code_ptr + %d)) "
2299 " & ~0x3fffff) "
2300 " | (((%s + %d) >> 10) & 0x3fffff);\n",
2301 reloc_offset, reloc_offset, name, addend);
2302 break;
2303 case R_SPARC_LO10:
2304 fprintf(outfile,
2305 " *(uint32_t *)(gen_code_ptr + %d) = "
2306 "((*(uint32_t *)(gen_code_ptr + %d)) "
2307 " & ~0x3ff) "
2308 " | ((%s + %d) & 0x3ff);\n",
2309 reloc_offset, reloc_offset, name, addend);
2310 break;
2311 case R_SPARC_OLO10:
2312 addend += ELF64_R_TYPE_DATA (rel->r_info);
2313 fprintf(outfile,
2314 " *(uint32_t *)(gen_code_ptr + %d) = "
2315 "((*(uint32_t *)(gen_code_ptr + %d)) "
2316 " & ~0x3ff) "
2317 " | ((%s + %d) & 0x3ff);\n",
2318 reloc_offset, reloc_offset, name, addend);
2319 break;
2320 case R_SPARC_WDISP30:
2321 fprintf(outfile,
2322 " *(uint32_t *)(gen_code_ptr + %d) = "
2323 "((*(uint32_t *)(gen_code_ptr + %d)) "
2324 " & ~0x3fffffff) "
2325 " | ((((%s + %d) - (long)(gen_code_ptr + %d))>>2) "
2326 " & 0x3fffffff);\n",
2327 reloc_offset, reloc_offset, name, addend,
2328 reloc_offset);
2329 break;
2330 case R_SPARC_WDISP22:
2331 fprintf(outfile,
2332 " *(uint32_t *)(gen_code_ptr + %d) = "
2333 "((*(uint32_t *)(gen_code_ptr + %d)) "
2334 " & ~0x3fffff) "
2335 " | ((((%s + %d) - (long)(gen_code_ptr + %d))>>2) "
2336 " & 0x3fffff);\n",
2337 reloc_offset, reloc_offset, name, addend,
2338 reloc_offset);
2339 break;
2340 default:
2341 error("unsupported sparc64 relocation (%d) for symbol %s", type, name);
2342 }
2343 }
2344 }
2345 }
2346 #elif defined(HOST_ARM)
2347 {
2348 char name[256];
2349 int type;
2350 int addend;
2351 int reloc_offset;
2352 uint32_t insn;
2353
2354 insn = get32((uint32_t *)(p_start + 4));
2355 /* If prologue ends in sub sp, sp, #const then assume
2356 op has a stack frame and needs the frame pointer. */
2357 if ((insn & 0xffffff00) == 0xe24dd000) {
2358 int i;
2359 uint32_t opcode;
2360 opcode = 0xe28db000; /* add fp, sp, #0. */
2361 #if 0
2362 /* ??? Need to undo the extra stack adjustment at the end of the op.
2363 For now just leave the stack misaligned and hope it doesn't break anything
2364 too important. */
2365 if ((insn & 4) != 0) {
2366 /* Preserve doubleword stack alignment. */
2367 fprintf(outfile,
2368 " *(uint32_t *)(gen_code_ptr + 4)= 0x%x;\n",
2369 insn + 4);
2370 opcode -= 4;
2371 }
2372 #endif
2373 insn = get32((uint32_t *)(p_start - 4));
2374 /* Calculate the size of the saved registers,
2375 excluding pc. */
2376 for (i = 0; i < 15; i++) {
2377 if (insn & (1 << i))
2378 opcode += 4;
2379 }
2380 fprintf(outfile,
2381 " *(uint32_t *)gen_code_ptr = 0x%x;\n", opcode);
2382 }
2383 arm_emit_ldr_info(name, start_offset, outfile, p_start, p_end,
2384 relocs, nb_relocs);
2385
2386 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
2387 if (rel->r_offset >= start_offset &&
2388 rel->r_offset < start_offset + copy_size) {
2389 sym_name = strtab + symtab[ELFW(R_SYM)(rel->r_info)].st_name;
2390 /* the compiler leave some unnecessary references to the code */
2391 if (sym_name[0] == '\0')
2392 continue;
2393 get_reloc_expr(name, sizeof(name), sym_name);
2394 type = ELF32_R_TYPE(rel->r_info);
2395 addend = get32((uint32_t *)(text + rel->r_offset));
2396 reloc_offset = rel->r_offset - start_offset;
2397 switch(type) {
2398 case R_ARM_ABS32:
2399 fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",
2400 reloc_offset, name, addend);
2401 break;
2402 case R_ARM_PC24:
2403 case R_ARM_JUMP24:
2404 case R_ARM_CALL:
2405 fprintf(outfile, " arm_reloc_pc24((uint32_t *)(gen_code_ptr + %d), 0x%x, %s);\n",
2406 reloc_offset, addend, name);
2407 break;
2408 default:
2409 error("unsupported arm relocation (%d)", type);
2410 }
2411 }
2412 }
2413 }
2414 #elif defined(HOST_M68K)
2415 {
2416 char name[256];
2417 int type;
2418 int addend;
2419 int reloc_offset;
2420 Elf32_Sym *sym;
2421 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
2422 if (rel->r_offset >= start_offset &&
2423 rel->r_offset < start_offset + copy_size) {
2424 sym = &(symtab[ELFW(R_SYM)(rel->r_info)]);
2425 sym_name = strtab + symtab[ELFW(R_SYM)(rel->r_info)].st_name;
2426 get_reloc_expr(name, sizeof(name), sym_name);
2427 type = ELF32_R_TYPE(rel->r_info);
2428 addend = get32((uint32_t *)(text + rel->r_offset)) + rel->r_addend;
2429 reloc_offset = rel->r_offset - start_offset;
2430 switch(type) {
2431 case R_68K_32:
2432 fprintf(outfile, " /* R_68K_32 RELOC, offset %x */\n", rel->r_offset) ;
2433 fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = %s + %#x;\n",
2434 reloc_offset, name, addend );
2435 break;
2436 case R_68K_PC32:
2437 fprintf(outfile, " /* R_68K_PC32 RELOC, offset %x */\n", rel->r_offset);
2438 fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %#x) + %#x;\n",
2439 reloc_offset, name, reloc_offset, /*sym->st_value+*/ addend);
2440 break;
2441 default:
2442 error("unsupported m68k relocation (%d)", type);
2443 }
2444 }
2445 }
2446 }
2447 #else
2448 #error unsupported CPU
2449 #endif
2450 fprintf(outfile, " gen_code_ptr += %d;\n", copy_size);
2451 fprintf(outfile, "}\n");
2452 fprintf(outfile, "break;\n\n");
2453 } else {
2454 fprintf(outfile, "static inline void gen_%s(", name);
2455 if (nb_args == 0) {
2456 fprintf(outfile, "void");
2457 } else {
2458 for(i = 0; i < nb_args; i++) {
2459 if (i != 0)
2460 fprintf(outfile, ", ");
2461 fprintf(outfile, "long param%d", i + 1);
2462 }
2463 }
2464 fprintf(outfile, ")\n");
2465 fprintf(outfile, "{\n");
2466 for(i = 0; i < nb_args; i++) {
2467 fprintf(outfile, " *gen_opparam_ptr++ = param%d;\n", i + 1);
2468 }
2469 fprintf(outfile, " *gen_opc_ptr++ = INDEX_%s;\n", name);
2470 fprintf(outfile, "}\n\n");
2471 }
2472 }
2473
2474 int gen_file(FILE *outfile, int out_type)
2475 {
2476 int i;
2477 EXE_SYM *sym;
2478
2479 if (out_type == OUT_INDEX_OP) {
2480 fprintf(outfile, "DEF(end, 0, 0)\n");
2481 fprintf(outfile, "DEF(nop, 0, 0)\n");
2482 fprintf(outfile, "DEF(nop1, 1, 0)\n");
2483 fprintf(outfile, "DEF(nop2, 2, 0)\n");
2484 fprintf(outfile, "DEF(nop3, 3, 0)\n");
2485 for(i = 0, sym = symtab; i < nb_syms; i++, sym++) {
2486 const char *name;
2487 name = get_sym_name(sym);
2488 if (strstart(name, OP_PREFIX, NULL)) {
2489 gen_code(name, sym->st_value, sym->st_size, outfile, 2);
2490 }
2491 }
2492 } else if (out_type == OUT_GEN_OP) {
2493 /* generate gen_xxx functions */
2494 fprintf(outfile, "#include \"dyngen-op.h\"\n");
2495 for(i = 0, sym = symtab; i < nb_syms; i++, sym++) {
2496 const char *name;
2497 name = get_sym_name(sym);
2498 if (strstart(name, OP_PREFIX, NULL)) {
2499 #if defined(CONFIG_FORMAT_ELF) || defined(CONFIG_FORMAT_COFF)
2500 if (sym->st_shndx != text_shndx)
2501 error("invalid section for opcode (0x%x)", sym->st_shndx);
2502 #endif
2503 gen_code(name, sym->st_value, sym->st_size, outfile, 0);
2504 }
2505 }
2506
2507 } else {
2508 /* generate big code generation switch */
2509
2510 #ifdef HOST_ARM
2511 /* We need to know the size of all the ops so we can figure out when
2512 to emit constant pools. This must be consistent with opc.h. */
2513 fprintf(outfile,
2514 "static const uint32_t arm_opc_size[] = {\n"
2515 " 0,\n" /* end */
2516 " 0,\n" /* nop */
2517 " 0,\n" /* nop1 */
2518 " 0,\n" /* nop2 */
2519 " 0,\n"); /* nop3 */
2520 for(i = 0, sym = symtab; i < nb_syms; i++, sym++) {
2521 const char *name;
2522 name = get_sym_name(sym);
2523 if (strstart(name, OP_PREFIX, NULL)) {
2524 fprintf(outfile, " %d,\n", sym->st_size);
2525 }
2526 }
2527 fprintf(outfile,
2528 "};\n");
2529 #endif
2530
2531 fprintf(outfile,
2532 "int dyngen_code(uint8_t *gen_code_buf,\n"
2533 " uint16_t *label_offsets, uint16_t *jmp_offsets,\n"
2534 " const uint16_t *opc_buf, const uint32_t *opparam_buf, const long *gen_labels)\n"
2535 "{\n"
2536 " uint8_t *gen_code_ptr;\n"
2537 " const uint16_t *opc_ptr;\n"
2538 " const uint32_t *opparam_ptr;\n");
2539
2540 #ifdef HOST_ARM
2541 /* Arm is tricky because it uses constant pools for loading immediate values.
2542 We assume (and require) each function is code followed by a constant pool.
2543 All the ops are small so this should be ok. For each op we figure
2544 out how much "spare" range we have in the load instructions. This allows
2545 us to insert subsequent ops in between the op and the constant pool,
2546 eliminating the neeed to jump around the pool.
2547
2548 We currently generate:
2549
2550 [ For this example we assume merging would move op1_pool out of range.
2551 In practice we should be able to combine many ops before the offset
2552 limits are reached. ]
2553 op1_code;
2554 op2_code;
2555 goto op3;
2556 op2_pool;
2557 op1_pool;
2558 op3:
2559 op3_code;
2560 ret;
2561 op3_pool;
2562
2563 Ideally we'd put op1_pool before op2_pool, but that requires two passes.
2564 */
2565 fprintf(outfile,
2566 " uint8_t *last_gen_code_ptr = gen_code_buf;\n"
2567 " LDREntry *arm_ldr_ptr = arm_ldr_table;\n"
2568 " uint32_t *arm_data_ptr = arm_data_table + ARM_LDR_TABLE_SIZE;\n"
2569 /* Initialise the parmissible pool offset to an arbitary large value. */
2570 " uint8_t *arm_pool_ptr = gen_code_buf + 0x1000000;\n");
2571 #endif
2572 #ifdef HOST_IA64
2573 {
2574 long addend, not_first = 0;
2575 unsigned long sym_idx;
2576 int index, max_index;
2577 const char *sym_name;
2578 EXE_RELOC *rel;
2579
2580 max_index = -1;
2581 for (i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
2582 sym_idx = ELF64_R_SYM(rel->r_info);
2583 sym_name = (strtab + symtab[sym_idx].st_name);
2584 if (strstart(sym_name, "__op_gen_label", NULL))
2585 continue;
2586 if (ELF64_R_TYPE(rel->r_info) != R_IA64_PCREL21B)
2587 continue;
2588
2589 addend = rel->r_addend;
2590 index = get_plt_index(sym_name, addend);
2591 if (index <= max_index)
2592 continue;
2593 max_index = index;
2594 fprintf(outfile, " extern void %s(void);\n", sym_name);
2595 }
2596
2597 fprintf(outfile,
2598 " struct ia64_fixup *plt_fixes = NULL, "
2599 "*ltoff_fixes = NULL;\n"
2600 " static long plt_target[] = {\n\t");
2601
2602 max_index = -1;
2603 for (i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
2604 sym_idx = ELF64_R_SYM(rel->r_info);
2605 sym_name = (strtab + symtab[sym_idx].st_name);
2606 if (strstart(sym_name, "__op_gen_label", NULL))
2607 continue;
2608 if (ELF64_R_TYPE(rel->r_info) != R_IA64_PCREL21B)
2609 continue;
2610
2611 addend = rel->r_addend;
2612 index = get_plt_index(sym_name, addend);
2613 if (index <= max_index)
2614 continue;
2615 max_index = index;
2616
2617 if (not_first)
2618 fprintf(outfile, ",\n\t");
2619 not_first = 1;
2620 if (addend)
2621 fprintf(outfile, "(long) &%s + %ld", sym_name, addend);
2622 else
2623 fprintf(outfile, "(long) &%s", sym_name);
2624 }
2625 fprintf(outfile, "\n };\n"
2626 " unsigned int plt_offset[%u] = { 0 };\n", max_index + 1);
2627 }
2628 #endif
2629
2630 fprintf(outfile,
2631 "\n"
2632 " gen_code_ptr = gen_code_buf;\n"
2633 " opc_ptr = opc_buf;\n"
2634 " opparam_ptr = opparam_buf;\n");
2635
2636 /* Generate prologue, if needed. */
2637
2638 fprintf(outfile,
2639 " for(;;) {\n");
2640
2641 #ifdef HOST_ARM
2642 /* Generate constant pool if needed */
2643 fprintf(outfile,
2644 " if (gen_code_ptr + arm_opc_size[*opc_ptr] >= arm_pool_ptr) {\n"
2645 " gen_code_ptr = arm_flush_ldr(gen_code_ptr, arm_ldr_table, "
2646 "arm_ldr_ptr, arm_data_ptr, arm_data_table + ARM_LDR_TABLE_SIZE, 1);\n"
2647 " last_gen_code_ptr = gen_code_ptr;\n"
2648 " arm_ldr_ptr = arm_ldr_table;\n"
2649 " arm_data_ptr = arm_data_table + ARM_LDR_TABLE_SIZE;\n"
2650 " arm_pool_ptr = gen_code_ptr + 0x1000000;\n"
2651 " }\n");
2652 #endif
2653
2654 fprintf(outfile,
2655 " switch(*opc_ptr++) {\n");
2656
2657 for(i = 0, sym = symtab; i < nb_syms; i++, sym++) {
2658 const char *name;
2659 name = get_sym_name(sym);
2660 if (strstart(name, OP_PREFIX, NULL)) {
2661 #if 0
2662 printf("%4d: %s pos=0x%08x len=%d\n",
2663 i, name, sym->st_value, sym->st_size);
2664 #endif
2665 #if defined(CONFIG_FORMAT_ELF) || defined(CONFIG_FORMAT_COFF)
2666 if (sym->st_shndx != text_shndx)
2667 error("invalid section for opcode (0x%x)", sym->st_shndx);
2668 #endif
2669 gen_code(name, sym->st_value, sym->st_size, outfile, 1);
2670 }
2671 }
2672
2673 fprintf(outfile,
2674 " case INDEX_op_nop:\n"
2675 " break;\n"
2676 " case INDEX_op_nop1:\n"
2677 " opparam_ptr++;\n"
2678 " break;\n"
2679 " case INDEX_op_nop2:\n"
2680 " opparam_ptr += 2;\n"
2681 " break;\n"
2682 " case INDEX_op_nop3:\n"
2683 " opparam_ptr += 3;\n"
2684 " break;\n"
2685 " default:\n"
2686 " goto the_end;\n"
2687 " }\n");
2688
2689
2690 fprintf(outfile,
2691 " }\n"
2692 " the_end:\n"
2693 );
2694 #ifdef HOST_IA64
2695 fprintf(outfile,
2696 " {\n"
2697 " extern char code_gen_buffer[];\n"
2698 " ia64_apply_fixes(&gen_code_ptr, ltoff_fixes, "
2699 "(uint64_t) code_gen_buffer + 2*(1<<20), plt_fixes,\n\t\t\t"
2700 "sizeof(plt_target)/sizeof(plt_target[0]),\n\t\t\t"
2701 "plt_target, plt_offset);\n }\n");
2702 #endif
2703
2704 /* generate some code patching */
2705 #ifdef HOST_ARM
2706 fprintf(outfile,
2707 "if (arm_data_ptr != arm_data_table + ARM_LDR_TABLE_SIZE)\n"
2708 " gen_code_ptr = arm_flush_ldr(gen_code_ptr, arm_ldr_table, "
2709 "arm_ldr_ptr, arm_data_ptr, arm_data_table + ARM_LDR_TABLE_SIZE, 0);\n");
2710 #endif
2711 /* flush instruction cache */
2712 fprintf(outfile, "flush_icache_range((unsigned long)gen_code_buf, (unsigned long)gen_code_ptr);\n");
2713
2714 fprintf(outfile, "return gen_code_ptr - gen_code_buf;\n");
2715 fprintf(outfile, "}\n\n");
2716
2717 }
2718
2719 return 0;
2720 }
2721
2722 void usage(void)
2723 {
2724 printf("dyngen (c) 2003 Fabrice Bellard\n"
2725 "usage: dyngen [-o outfile] [-c] objfile\n"
2726 "Generate a dynamic code generator from an object file\n"
2727 "-c output enum of operations\n"
2728 "-g output gen_op_xx() functions\n"
2729 );
2730 exit(1);
2731 }
2732
2733 int main(int argc, char **argv)
2734 {
2735 int c, out_type;
2736 const char *filename, *outfilename;
2737 FILE *outfile;
2738
2739 outfilename = "out.c";
2740 out_type = OUT_CODE;
2741 for(;;) {
2742 c = getopt(argc, argv, "ho:cg");
2743 if (c == -1)
2744 break;
2745 switch(c) {
2746 case 'h':
2747 usage();
2748 break;
2749 case 'o':
2750 outfilename = optarg;
2751 break;
2752 case 'c':
2753 out_type = OUT_INDEX_OP;
2754 break;
2755 case 'g':
2756 out_type = OUT_GEN_OP;
2757 break;
2758 }
2759 }
2760 if (optind >= argc)
2761 usage();
2762 filename = argv[optind];
2763 outfile = fopen(outfilename, "w");
2764 if (!outfile)
2765 error("could not open '%s'", outfilename);
2766
2767 load_object(filename);
2768 gen_file(outfile, out_type);
2769 fclose(outfile);
2770 return 0;
2771 }
Samsung s3c2440 and arm920t support for the mini2440 dev board