2 * Generic Dynamic compiler generator
4 * Copyright (c) 2003 Fabrice Bellard
6 * The COFF object format support was extracted from Kazu's QEMU port
9 * Mach-O Support by Matt Reda and Pierre d'Herbemont
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.
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.
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.
33 #include "config-host.h"
35 /* NOTE: we test CONFIG_WIN32 instead of _WIN32 to enabled cross
37 #if defined(CONFIG_WIN32)
38 #define CONFIG_FORMAT_COFF
39 #elif defined(CONFIG_DARWIN)
40 #define CONFIG_FORMAT_MACH
42 #define CONFIG_FORMAT_ELF
45 #ifdef CONFIG_FORMAT_ELF
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
50 #if defined(HOST_I386)
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
57 #elif defined(HOST_X86_64)
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
64 #elif defined(HOST_PPC)
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
71 #elif defined(HOST_S390)
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
78 #elif defined(HOST_ALPHA)
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
85 #elif defined(HOST_IA64)
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
92 #elif defined(HOST_SPARC)
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
99 #elif defined(HOST_SPARC64)
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
106 #elif defined(HOST_ARM)
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
113 #elif defined(HOST_M68K)
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
120 #elif defined(HOST_MIPS)
122 #define ELF_CLASS ELFCLASS32
123 #define ELF_ARCH EM_MIPS
124 #define elf_check_arch(x) ((x) == EM_MIPS)
125 #define ELF_USES_RELOC
127 #elif defined(HOST_MIPS64)
129 /* Assume n32 ABI here, which is ELF32. */
130 #define ELF_CLASS ELFCLASS32
131 #define ELF_ARCH EM_MIPS
132 #define elf_check_arch(x) ((x) == EM_MIPS)
133 #define ELF_USES_RELOCA
136 #error unsupported CPU - please update the code
141 #if ELF_CLASS == ELFCLASS32
142 typedef int32_t host_long
;
143 typedef uint32_t host_ulong
;
144 #define swabls(x) swab32s(x)
145 #define swablss(x) swab32ss(x)
147 typedef int64_t host_long
;
148 typedef uint64_t host_ulong
;
149 #define swabls(x) swab64s(x)
150 #define swablss(x) swab64ss(x)
153 #ifdef ELF_USES_RELOCA
154 #define SHT_RELOC SHT_RELA
156 #define SHT_RELOC SHT_REL
159 #define EXE_RELOC ELF_RELOC
160 #define EXE_SYM ElfW(Sym)
162 #endif /* CONFIG_FORMAT_ELF */
164 #ifdef CONFIG_FORMAT_COFF
166 typedef int32_t host_long
;
167 typedef uint32_t host_ulong
;
171 #define FILENAMELEN 256
173 typedef struct coff_sym
{
174 struct external_syment
*st_syment
;
175 char st_name
[FILENAMELEN
];
182 typedef struct coff_rel
{
183 struct external_reloc
*r_reloc
;
188 #define EXE_RELOC struct coff_rel
189 #define EXE_SYM struct coff_sym
191 #endif /* CONFIG_FORMAT_COFF */
193 #ifdef CONFIG_FORMAT_MACH
195 #include <mach-o/loader.h>
196 #include <mach-o/nlist.h>
197 #include <mach-o/reloc.h>
198 #include <mach-o/ppc/reloc.h>
200 # define check_mach_header(x) (x.magic == MH_MAGIC)
201 typedef int32_t host_long
;
202 typedef uint32_t host_ulong
;
204 struct nlist_extended
210 unsigned char n_type
;
211 unsigned char n_sect
;
213 unsigned long st_value
;
214 unsigned long st_size
;
217 #define EXE_RELOC struct relocation_info
218 #define EXE_SYM struct nlist_extended
220 #endif /* CONFIG_FORMAT_MACH */
230 /* all dynamically generated functions begin with this code */
231 #define OP_PREFIX "op_"
235 void __attribute__((noreturn
)) __attribute__((format (printf
, 1, 2))) error(const char *fmt
, ...)
239 fprintf(stderr
, "dyngen: ");
240 vfprintf(stderr
, fmt
, ap
);
241 fprintf(stderr
, "\n");
246 void *load_data(int fd
, long offset
, unsigned int size
)
253 lseek(fd
, offset
, SEEK_SET
);
254 if (read(fd
, data
, size
) != size
) {
261 int strstart(const char *str
, const char *val
, const char **ptr
)
277 void pstrcpy(char *buf
, int buf_size
, const char *str
)
287 if (c
== 0 || q
>= buf
+ buf_size
- 1)
294 void swab16s(uint16_t *p
)
299 void swab32s(uint32_t *p
)
304 void swab32ss(int32_t *p
)
309 void swab64s(uint64_t *p
)
314 void swab64ss(int64_t *p
)
319 uint16_t get16(uint16_t *p
)
328 uint32_t get32(uint32_t *p
)
337 void put16(uint16_t *p
, uint16_t val
)
344 void put32(uint32_t *p
, uint32_t val
)
351 /* executable information */
359 #ifdef CONFIG_FORMAT_ELF
362 struct elf_shdr
*shdr
;
367 int elf_must_swap(struct elfhdr
*h
)
375 return (h
->e_ident
[EI_DATA
] == ELFDATA2MSB
) !=
376 (swaptest
.b
[0] == 0);
379 void elf_swap_ehdr(struct elfhdr
*h
)
381 swab16s(&h
->e_type
); /* Object file type */
382 swab16s(&h
-> e_machine
); /* Architecture */
383 swab32s(&h
-> e_version
); /* Object file version */
384 swabls(&h
-> e_entry
); /* Entry point virtual address */
385 swabls(&h
-> e_phoff
); /* Program header table file offset */
386 swabls(&h
-> e_shoff
); /* Section header table file offset */
387 swab32s(&h
-> e_flags
); /* Processor-specific flags */
388 swab16s(&h
-> e_ehsize
); /* ELF header size in bytes */
389 swab16s(&h
-> e_phentsize
); /* Program header table entry size */
390 swab16s(&h
-> e_phnum
); /* Program header table entry count */
391 swab16s(&h
-> e_shentsize
); /* Section header table entry size */
392 swab16s(&h
-> e_shnum
); /* Section header table entry count */
393 swab16s(&h
-> e_shstrndx
); /* Section header string table index */
396 void elf_swap_shdr(struct elf_shdr
*h
)
398 swab32s(&h
-> sh_name
); /* Section name (string tbl index) */
399 swab32s(&h
-> sh_type
); /* Section type */
400 swabls(&h
-> sh_flags
); /* Section flags */
401 swabls(&h
-> sh_addr
); /* Section virtual addr at execution */
402 swabls(&h
-> sh_offset
); /* Section file offset */
403 swabls(&h
-> sh_size
); /* Section size in bytes */
404 swab32s(&h
-> sh_link
); /* Link to another section */
405 swab32s(&h
-> sh_info
); /* Additional section information */
406 swabls(&h
-> sh_addralign
); /* Section alignment */
407 swabls(&h
-> sh_entsize
); /* Entry size if section holds table */
410 void elf_swap_phdr(struct elf_phdr
*h
)
412 swab32s(&h
->p_type
); /* Segment type */
413 swabls(&h
->p_offset
); /* Segment file offset */
414 swabls(&h
->p_vaddr
); /* Segment virtual address */
415 swabls(&h
->p_paddr
); /* Segment physical address */
416 swabls(&h
->p_filesz
); /* Segment size in file */
417 swabls(&h
->p_memsz
); /* Segment size in memory */
418 swab32s(&h
->p_flags
); /* Segment flags */
419 swabls(&h
->p_align
); /* Segment alignment */
422 void elf_swap_rel(ELF_RELOC
*rel
)
424 swabls(&rel
->r_offset
);
425 swabls(&rel
->r_info
);
426 #ifdef ELF_USES_RELOCA
427 swablss(&rel
->r_addend
);
431 struct elf_shdr
*find_elf_section(struct elf_shdr
*shdr
, int shnum
, const char *shstr
,
436 struct elf_shdr
*sec
;
438 for(i
= 0; i
< shnum
; i
++) {
442 shname
= shstr
+ sec
->sh_name
;
443 if (!strcmp(shname
, name
))
449 int find_reloc(int sh_index
)
451 struct elf_shdr
*sec
;
454 for(i
= 0; i
< ehdr
.e_shnum
; i
++) {
456 if (sec
->sh_type
== SHT_RELOC
&& sec
->sh_info
== sh_index
)
462 static host_ulong
get_rel_offset(EXE_RELOC
*rel
)
464 return rel
->r_offset
;
467 static char *get_rel_sym_name(EXE_RELOC
*rel
)
469 return strtab
+ symtab
[ELFW(R_SYM
)(rel
->r_info
)].st_name
;
472 static char *get_sym_name(EXE_SYM
*sym
)
474 return strtab
+ sym
->st_name
;
477 /* load an elf object file */
478 int load_object(const char *filename
)
481 struct elf_shdr
*sec
, *symtab_sec
, *strtab_sec
, *text_sec
;
487 fd
= open(filename
, O_RDONLY
);
489 error("can't open file '%s'", filename
);
491 /* Read ELF header. */
492 if (read(fd
, &ehdr
, sizeof (ehdr
)) != sizeof (ehdr
))
493 error("unable to read file header");
495 /* Check ELF identification. */
496 if (ehdr
.e_ident
[EI_MAG0
] != ELFMAG0
497 || ehdr
.e_ident
[EI_MAG1
] != ELFMAG1
498 || ehdr
.e_ident
[EI_MAG2
] != ELFMAG2
499 || ehdr
.e_ident
[EI_MAG3
] != ELFMAG3
500 || ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) {
501 error("bad ELF header");
504 do_swap
= elf_must_swap(&ehdr
);
506 elf_swap_ehdr(&ehdr
);
507 if (ehdr
.e_ident
[EI_CLASS
] != ELF_CLASS
)
508 error("Unsupported ELF class");
509 if (ehdr
.e_type
!= ET_REL
)
510 error("ELF object file expected");
511 if (ehdr
.e_version
!= EV_CURRENT
)
512 error("Invalid ELF version");
513 if (!elf_check_arch(ehdr
.e_machine
))
514 error("Unsupported CPU (e_machine=%d)", ehdr
.e_machine
);
516 /* read section headers */
517 shdr
= load_data(fd
, ehdr
.e_shoff
, ehdr
.e_shnum
* sizeof(struct elf_shdr
));
519 for(i
= 0; i
< ehdr
.e_shnum
; i
++) {
520 elf_swap_shdr(&shdr
[i
]);
524 /* read all section data */
525 sdata
= malloc(sizeof(void *) * ehdr
.e_shnum
);
526 memset(sdata
, 0, sizeof(void *) * ehdr
.e_shnum
);
528 for(i
= 0;i
< ehdr
.e_shnum
; i
++) {
530 if (sec
->sh_type
!= SHT_NOBITS
)
531 sdata
[i
] = load_data(fd
, sec
->sh_offset
, sec
->sh_size
);
534 sec
= &shdr
[ehdr
.e_shstrndx
];
535 shstr
= (char *)sdata
[ehdr
.e_shstrndx
];
537 /* swap relocations */
538 for(i
= 0; i
< ehdr
.e_shnum
; i
++) {
540 if (sec
->sh_type
== SHT_RELOC
) {
541 nb_relocs
= sec
->sh_size
/ sec
->sh_entsize
;
543 for(j
= 0, rel
= (ELF_RELOC
*)sdata
[i
]; j
< nb_relocs
; j
++, rel
++)
550 text_sec
= find_elf_section(shdr
, ehdr
.e_shnum
, shstr
, ".text");
552 error("could not find .text section");
553 text_shndx
= text_sec
- shdr
;
554 text
= sdata
[text_shndx
];
556 /* find text relocations, if any */
559 i
= find_reloc(text_shndx
);
561 relocs
= (ELF_RELOC
*)sdata
[i
];
562 nb_relocs
= shdr
[i
].sh_size
/ shdr
[i
].sh_entsize
;
565 symtab_sec
= find_elf_section(shdr
, ehdr
.e_shnum
, shstr
, ".symtab");
567 error("could not find .symtab section");
568 strtab_sec
= &shdr
[symtab_sec
->sh_link
];
570 symtab
= (ElfW(Sym
) *)sdata
[symtab_sec
- shdr
];
571 strtab
= (char *)sdata
[symtab_sec
->sh_link
];
573 nb_syms
= symtab_sec
->sh_size
/ sizeof(ElfW(Sym
));
575 for(i
= 0, sym
= symtab
; i
< nb_syms
; i
++, sym
++) {
576 swab32s(&sym
->st_name
);
577 swabls(&sym
->st_value
);
578 swabls(&sym
->st_size
);
579 swab16s(&sym
->st_shndx
);
586 #endif /* CONFIG_FORMAT_ELF */
588 #ifdef CONFIG_FORMAT_COFF
591 struct external_scnhdr
*shdr
;
593 struct external_filehdr fhdr
;
594 struct external_syment
*coff_symtab
;
596 int coff_text_shndx
, coff_data_shndx
;
600 #define STRTAB_SIZE 4
605 #define T_FUNCTION 0x20
608 void sym_ent_name(struct external_syment
*ext_sym
, EXE_SYM
*sym
)
613 if (ext_sym
->e
.e
.e_zeroes
!= 0) {
615 for(i
= 0; i
< 8; i
++) {
616 c
= ext_sym
->e
.e_name
[i
];
623 pstrcpy(sym
->st_name
, sizeof(sym
->st_name
), strtab
+ ext_sym
->e
.e
.e_offset
);
626 /* now convert the name to a C name (suppress the leading '_') */
627 if (sym
->st_name
[0] == '_') {
628 len
= strlen(sym
->st_name
);
629 memmove(sym
->st_name
, sym
->st_name
+ 1, len
- 1);
630 sym
->st_name
[len
- 1] = '\0';
634 char *name_for_dotdata(struct coff_rel
*rel
)
637 struct coff_sym
*sym
;
640 text_data
= *(uint32_t *)(text
+ rel
->r_offset
);
642 for (i
= 0, sym
= symtab
; i
< nb_syms
; i
++, sym
++) {
643 if (sym
->st_syment
->e_scnum
== data_shndx
&&
644 text_data
>= sym
->st_value
&&
645 text_data
< sym
->st_value
+ sym
->st_size
) {
654 static char *get_sym_name(EXE_SYM
*sym
)
659 static char *get_rel_sym_name(EXE_RELOC
*rel
)
662 name
= get_sym_name(symtab
+ *(uint32_t *)(rel
->r_reloc
->r_symndx
));
663 if (!strcmp(name
, ".data"))
664 name
= name_for_dotdata(rel
);
670 static host_ulong
get_rel_offset(EXE_RELOC
*rel
)
672 return rel
->r_offset
;
675 struct external_scnhdr
*find_coff_section(struct external_scnhdr
*shdr
, int shnum
, const char *name
)
679 struct external_scnhdr
*sec
;
681 for(i
= 0; i
< shnum
; i
++) {
685 shname
= sec
->s_name
;
686 if (!strcmp(shname
, name
))
692 /* load a coff object file */
693 int load_object(const char *filename
)
696 struct external_scnhdr
*sec
, *text_sec
, *data_sec
;
698 struct external_syment
*ext_sym
;
699 struct external_reloc
*coff_relocs
;
700 struct external_reloc
*ext_rel
;
705 fd
= open(filename
, O_RDONLY
711 error("can't open file '%s'", filename
);
713 /* Read COFF header. */
714 if (read(fd
, &fhdr
, sizeof (fhdr
)) != sizeof (fhdr
))
715 error("unable to read file header");
717 /* Check COFF identification. */
718 if (fhdr
.f_magic
!= I386MAGIC
) {
719 error("bad COFF header");
723 /* read section headers */
724 shdr
= load_data(fd
, sizeof(struct external_filehdr
) + fhdr
.f_opthdr
, fhdr
.f_nscns
* sizeof(struct external_scnhdr
));
726 /* read all section data */
727 sdata
= malloc(sizeof(void *) * fhdr
.f_nscns
);
728 memset(sdata
, 0, sizeof(void *) * fhdr
.f_nscns
);
731 for(i
= 0;i
< fhdr
.f_nscns
; i
++) {
733 if (!strstart(sec
->s_name
, ".bss", &p
))
734 sdata
[i
] = load_data(fd
, sec
->s_scnptr
, sec
->s_size
);
739 text_sec
= find_coff_section(shdr
, fhdr
.f_nscns
, ".text");
741 error("could not find .text section");
742 coff_text_shndx
= text_sec
- shdr
;
743 text
= sdata
[coff_text_shndx
];
746 data_sec
= find_coff_section(shdr
, fhdr
.f_nscns
, ".data");
748 error("could not find .data section");
749 coff_data_shndx
= data_sec
- shdr
;
751 coff_symtab
= load_data(fd
, fhdr
.f_symptr
, fhdr
.f_nsyms
*SYMESZ
);
752 for (i
= 0, ext_sym
= coff_symtab
; i
< nb_syms
; i
++, ext_sym
++) {
754 printf(" %02x", ((uint8_t *)ext_sym
->e
.e_name
)[i
]);
759 n_strtab
= load_data(fd
, (fhdr
.f_symptr
+ fhdr
.f_nsyms
*SYMESZ
), STRTAB_SIZE
);
760 strtab
= load_data(fd
, (fhdr
.f_symptr
+ fhdr
.f_nsyms
*SYMESZ
), *n_strtab
);
762 nb_syms
= fhdr
.f_nsyms
;
764 for (i
= 0, ext_sym
= coff_symtab
; i
< nb_syms
; i
++, ext_sym
++) {
765 if (strstart(ext_sym
->e
.e_name
, ".text", NULL
))
766 text_shndx
= ext_sym
->e_scnum
;
767 if (strstart(ext_sym
->e
.e_name
, ".data", NULL
))
768 data_shndx
= ext_sym
->e_scnum
;
771 /* set coff symbol */
772 symtab
= malloc(sizeof(struct coff_sym
) * nb_syms
);
775 for (i
= 0, ext_sym
= coff_symtab
, sym
= symtab
; i
< nb_syms
; i
++, ext_sym
++, sym
++) {
776 memset(sym
, 0, sizeof(*sym
));
777 sym
->st_syment
= ext_sym
;
778 sym_ent_name(ext_sym
, sym
);
779 sym
->st_value
= ext_sym
->e_value
;
781 aux_size
= *(int8_t *)ext_sym
->e_numaux
;
782 if (ext_sym
->e_scnum
== text_shndx
&& ext_sym
->e_type
== T_FUNCTION
) {
783 for (j
= aux_size
+ 1; j
< nb_syms
- i
; j
++) {
784 if ((ext_sym
+ j
)->e_scnum
== text_shndx
&&
785 (ext_sym
+ j
)->e_type
== T_FUNCTION
){
786 sym
->st_size
= (ext_sym
+ j
)->e_value
- ext_sym
->e_value
;
788 } else if (j
== nb_syms
- i
- 1) {
789 sec
= &shdr
[coff_text_shndx
];
790 sym
->st_size
= sec
->s_size
- ext_sym
->e_value
;
794 } else if (ext_sym
->e_scnum
== data_shndx
&& *(uint8_t *)ext_sym
->e_sclass
== C_EXTERNAL
) {
795 for (j
= aux_size
+ 1; j
< nb_syms
- i
; j
++) {
796 if ((ext_sym
+ j
)->e_scnum
== data_shndx
) {
797 sym
->st_size
= (ext_sym
+ j
)->e_value
- ext_sym
->e_value
;
799 } else if (j
== nb_syms
- i
- 1) {
800 sec
= &shdr
[coff_data_shndx
];
801 sym
->st_size
= sec
->s_size
- ext_sym
->e_value
;
809 sym
->st_type
= ext_sym
->e_type
;
810 sym
->st_shndx
= ext_sym
->e_scnum
;
814 /* find text relocations, if any */
815 sec
= &shdr
[coff_text_shndx
];
816 coff_relocs
= load_data(fd
, sec
->s_relptr
, sec
->s_nreloc
*RELSZ
);
817 nb_relocs
= sec
->s_nreloc
;
819 /* set coff relocation */
820 relocs
= malloc(sizeof(struct coff_rel
) * nb_relocs
);
821 for (i
= 0, ext_rel
= coff_relocs
, rel
= relocs
; i
< nb_relocs
;
822 i
++, ext_rel
++, rel
++) {
823 memset(rel
, 0, sizeof(*rel
));
824 rel
->r_reloc
= ext_rel
;
825 rel
->r_offset
= *(uint32_t *)ext_rel
->r_vaddr
;
826 rel
->r_type
= *(uint16_t *)ext_rel
->r_type
;
831 #endif /* CONFIG_FORMAT_COFF */
833 #ifdef CONFIG_FORMAT_MACH
836 struct mach_header mach_hdr
;
839 struct segment_command
*segment
= 0;
840 struct dysymtab_command
*dysymtabcmd
= 0;
841 struct symtab_command
*symtabcmd
= 0;
844 struct section
*section_hdr
;
845 struct section
*text_sec_hdr
;
849 struct relocation_info
*relocs
;
853 struct nlist
*symtab_std
;
856 /* indirect symbols */
859 /* Utility functions */
861 static inline char *find_str_by_index(int index
)
866 /* Used by dyngen common code */
867 static char *get_sym_name(EXE_SYM
*sym
)
869 char *name
= find_str_by_index(sym
->n_un
.n_strx
);
871 if ( sym
->n_type
& N_STAB
) /* Debug symbols are ignored */
882 /* find a section index given its segname, sectname */
883 static int find_mach_sec_index(struct section
*section_hdr
, int shnum
, const char *segname
,
884 const char *sectname
)
887 struct section
*sec
= section_hdr
;
889 for(i
= 0; i
< shnum
; i
++, sec
++) {
890 if (!sec
->segname
|| !sec
->sectname
)
892 if (!strcmp(sec
->sectname
, sectname
) && !strcmp(sec
->segname
, segname
))
898 /* find a section header given its segname, sectname */
899 struct section
*find_mach_sec_hdr(struct section
*section_hdr
, int shnum
, const char *segname
,
900 const char *sectname
)
902 int index
= find_mach_sec_index(section_hdr
, shnum
, segname
, sectname
);
905 return section_hdr
+index
;
909 static inline void fetch_next_pair_value(struct relocation_info
* rel
, unsigned int *value
)
911 struct scattered_relocation_info
* scarel
;
913 if(R_SCATTERED
& rel
->r_address
) {
914 scarel
= (struct scattered_relocation_info
*)rel
;
915 if(scarel
->r_type
!= PPC_RELOC_PAIR
)
916 error("fetch_next_pair_value: looking for a pair which was not found (1)");
917 *value
= scarel
->r_value
;
919 if(rel
->r_type
!= PPC_RELOC_PAIR
)
920 error("fetch_next_pair_value: looking for a pair which was not found (2)");
921 *value
= rel
->r_address
;
925 /* find a sym name given its value, in a section number */
926 static const char * find_sym_with_value_and_sec_number( int value
, int sectnum
, int * offset
)
930 for( i
= 0 ; i
< nb_syms
; i
++ )
932 if( !(symtab
[i
].n_type
& N_STAB
) && (symtab
[i
].n_type
& N_SECT
) &&
933 (symtab
[i
].n_sect
== sectnum
) && (symtab
[i
].st_value
<= value
) )
935 if( (ret
<0) || (symtab
[i
].st_value
>= symtab
[ret
].st_value
) )
943 *offset
= value
- symtab
[ret
].st_value
;
944 return get_sym_name(&symtab
[ret
]);
949 * Find symbol name given a (virtual) address, and a section which is of type
950 * S_NON_LAZY_SYMBOL_POINTERS or S_LAZY_SYMBOL_POINTERS or S_SYMBOL_STUBS
952 static const char * find_reloc_name_in_sec_ptr(int address
, struct section
* sec_hdr
)
954 unsigned int tocindex
, symindex
, size
;
955 const char *name
= 0;
958 if(!( address
>= sec_hdr
->addr
&& address
< (sec_hdr
->addr
+ sec_hdr
->size
) ) )
961 if( sec_hdr
->flags
& S_SYMBOL_STUBS
){
962 size
= sec_hdr
->reserved2
;
967 else if( sec_hdr
->flags
& S_LAZY_SYMBOL_POINTERS
||
968 sec_hdr
->flags
& S_NON_LAZY_SYMBOL_POINTERS
)
969 size
= sizeof(unsigned long);
973 /* Compute our index in toc */
974 tocindex
= (address
- sec_hdr
->addr
)/size
;
975 symindex
= tocdylib
[sec_hdr
->reserved1
+ tocindex
];
977 name
= get_sym_name(&symtab
[symindex
]);
982 static const char * find_reloc_name_given_its_address(int address
)
985 for(i
= 0; i
< segment
->nsects
; i
++)
987 const char * name
= find_reloc_name_in_sec_ptr(address
, §ion_hdr
[i
]);
994 static const char * get_reloc_name(EXE_RELOC
* rel
, int * sslide
)
997 struct scattered_relocation_info
* sca_rel
= (struct scattered_relocation_info
*)rel
;
998 int sectnum
= rel
->r_symbolnum
;
1002 /* init the slide value */
1005 if(R_SCATTERED
& rel
->r_address
)
1006 return (char *)find_reloc_name_given_its_address(sca_rel
->r_value
);
1010 /* ignore debug sym */
1011 if ( symtab
[rel
->r_symbolnum
].n_type
& N_STAB
)
1013 return get_sym_name(&symtab
[rel
->r_symbolnum
]);
1016 /* Intruction contains an offset to the symbols pointed to, in the rel->r_symbolnum section */
1017 sectoffset
= *(uint32_t *)(text
+ rel
->r_address
) & 0xffff;
1019 if(sectnum
==0xffffff)
1023 if(sectnum
> segment
->nsects
)
1024 error("sectnum > segment->nsects");
1028 case PPC_RELOC_LO16
: fetch_next_pair_value(rel
+1, &other_half
); sectoffset
|= (other_half
<< 16);
1030 case PPC_RELOC_HI16
: fetch_next_pair_value(rel
+1, &other_half
); sectoffset
= (sectoffset
<< 16) | (uint16_t)(other_half
& 0xffff);
1032 case PPC_RELOC_HA16
: fetch_next_pair_value(rel
+1, &other_half
); sectoffset
= (sectoffset
<< 16) + (int16_t)(other_half
& 0xffff);
1034 case PPC_RELOC_BR24
:
1035 sectoffset
= ( *(uint32_t *)(text
+ rel
->r_address
) & 0x03fffffc );
1036 if (sectoffset
& 0x02000000) sectoffset
|= 0xfc000000;
1039 error("switch(rel->type) not found");
1043 sectoffset
+= rel
->r_address
;
1045 if (rel
->r_type
== PPC_RELOC_BR24
)
1046 name
= (char *)find_reloc_name_in_sec_ptr((int)sectoffset
, §ion_hdr
[sectnum
-1]);
1048 /* search it in the full symbol list, if not found */
1050 name
= (char *)find_sym_with_value_and_sec_number(sectoffset
, sectnum
, sslide
);
1055 /* Used by dyngen common code */
1056 static const char * get_rel_sym_name(EXE_RELOC
* rel
)
1059 return get_reloc_name( rel
, &sslide
);
1062 /* Used by dyngen common code */
1063 static host_ulong
get_rel_offset(EXE_RELOC
*rel
)
1065 struct scattered_relocation_info
* sca_rel
= (struct scattered_relocation_info
*)rel
;
1066 if(R_SCATTERED
& rel
->r_address
)
1067 return sca_rel
->r_address
;
1069 return rel
->r_address
;
1072 /* load a mach-o object file */
1073 int load_object(const char *filename
)
1076 unsigned int offset_to_segment
= 0;
1077 unsigned int offset_to_dysymtab
= 0;
1078 unsigned int offset_to_symtab
= 0;
1079 struct load_command lc
;
1082 struct nlist
*syment
;
1084 fd
= open(filename
, O_RDONLY
);
1086 error("can't open file '%s'", filename
);
1088 /* Read Mach header. */
1089 if (read(fd
, &mach_hdr
, sizeof (mach_hdr
)) != sizeof (mach_hdr
))
1090 error("unable to read file header");
1092 /* Check Mach identification. */
1093 if (!check_mach_header(mach_hdr
)) {
1094 error("bad Mach header");
1097 if (mach_hdr
.cputype
!= CPU_TYPE_POWERPC
)
1098 error("Unsupported CPU");
1100 if (mach_hdr
.filetype
!= MH_OBJECT
)
1101 error("Unsupported Mach Object");
1103 /* read segment headers */
1104 for(i
=0, j
=sizeof(mach_hdr
); i
<mach_hdr
.ncmds
; i
++)
1106 if(read(fd
, &lc
, sizeof(struct load_command
)) != sizeof(struct load_command
))
1107 error("unable to read load_command");
1108 if(lc
.cmd
== LC_SEGMENT
)
1110 offset_to_segment
= j
;
1111 lseek(fd
, offset_to_segment
, SEEK_SET
);
1112 segment
= malloc(sizeof(struct segment_command
));
1113 if(read(fd
, segment
, sizeof(struct segment_command
)) != sizeof(struct segment_command
))
1114 error("unable to read LC_SEGMENT");
1116 if(lc
.cmd
== LC_DYSYMTAB
)
1118 offset_to_dysymtab
= j
;
1119 lseek(fd
, offset_to_dysymtab
, SEEK_SET
);
1120 dysymtabcmd
= malloc(sizeof(struct dysymtab_command
));
1121 if(read(fd
, dysymtabcmd
, sizeof(struct dysymtab_command
)) != sizeof(struct dysymtab_command
))
1122 error("unable to read LC_DYSYMTAB");
1124 if(lc
.cmd
== LC_SYMTAB
)
1126 offset_to_symtab
= j
;
1127 lseek(fd
, offset_to_symtab
, SEEK_SET
);
1128 symtabcmd
= malloc(sizeof(struct symtab_command
));
1129 if(read(fd
, symtabcmd
, sizeof(struct symtab_command
)) != sizeof(struct symtab_command
))
1130 error("unable to read LC_SYMTAB");
1134 lseek(fd
, j
, SEEK_SET
);
1138 error("unable to find LC_SEGMENT");
1140 /* read section headers */
1141 section_hdr
= load_data(fd
, offset_to_segment
+ sizeof(struct segment_command
), segment
->nsects
* sizeof(struct section
));
1143 /* read all section data */
1144 sdata
= (uint8_t **)malloc(sizeof(void *) * segment
->nsects
);
1145 memset(sdata
, 0, sizeof(void *) * segment
->nsects
);
1147 /* Load the data in section data */
1148 for(i
= 0; i
< segment
->nsects
; i
++) {
1149 sdata
[i
] = load_data(fd
, section_hdr
[i
].offset
, section_hdr
[i
].size
);
1153 text_sec_hdr
= find_mach_sec_hdr(section_hdr
, segment
->nsects
, SEG_TEXT
, SECT_TEXT
);
1154 i
= find_mach_sec_index(section_hdr
, segment
->nsects
, SEG_TEXT
, SECT_TEXT
);
1155 if (i
== -1 || !text_sec_hdr
)
1156 error("could not find __TEXT,__text section");
1159 /* Make sure dysym was loaded */
1160 if(!(int)dysymtabcmd
)
1161 error("could not find __DYSYMTAB segment");
1163 /* read the table of content of the indirect sym */
1164 tocdylib
= load_data( fd
, dysymtabcmd
->indirectsymoff
, dysymtabcmd
->nindirectsyms
* sizeof(uint32_t) );
1166 /* Make sure symtab was loaded */
1168 error("could not find __SYMTAB segment");
1169 nb_syms
= symtabcmd
->nsyms
;
1171 symtab_std
= load_data(fd
, symtabcmd
->symoff
, symtabcmd
->nsyms
* sizeof(struct nlist
));
1172 strtab
= load_data(fd
, symtabcmd
->stroff
, symtabcmd
->strsize
);
1174 symtab
= malloc(sizeof(EXE_SYM
) * nb_syms
);
1176 /* Now transform the symtab, to an extended version, with the sym size, and the C name */
1177 for(i
= 0, sym
= symtab
, syment
= symtab_std
; i
< nb_syms
; i
++, sym
++, syment
++) {
1178 struct nlist
*sym_follow
, *sym_next
= 0;
1180 memset(sym
, 0, sizeof(*sym
));
1182 if ( syment
->n_type
& N_STAB
) /* Debug symbols are skipped */
1185 memcpy(sym
, syment
, sizeof(*syment
));
1187 /* Find the following symbol in order to get the current symbol size */
1188 for(j
= 0, sym_follow
= symtab_std
; j
< nb_syms
; j
++, sym_follow
++) {
1189 if ( sym_follow
->n_sect
!= 1 || sym_follow
->n_type
& N_STAB
|| !(sym_follow
->n_value
> sym
->st_value
))
1192 sym_next
= sym_follow
;
1195 if(!(sym_next
->n_value
> sym_follow
->n_value
))
1197 sym_next
= sym_follow
;
1200 sym
->st_size
= sym_next
->n_value
- sym
->st_value
;
1202 sym
->st_size
= text_sec_hdr
->size
- sym
->st_value
;
1206 relocs
= load_data(fd
, text_sec_hdr
->reloff
, text_sec_hdr
->nreloc
* sizeof(struct relocation_info
));
1207 nb_relocs
= text_sec_hdr
->nreloc
;
1213 #endif /* CONFIG_FORMAT_MACH */
1215 void get_reloc_expr(char *name
, int name_size
, const char *sym_name
)
1219 if (strstart(sym_name
, "__op_param", &p
)) {
1220 snprintf(name
, name_size
, "param%s", p
);
1221 } else if (strstart(sym_name
, "__op_gen_label", &p
)) {
1222 snprintf(name
, name_size
, "gen_labels[param%s]", p
);
1225 if (sym_name
[0] == '.')
1226 snprintf(name
, name_size
,
1227 "(long)(&__dot_%s)",
1231 snprintf(name
, name_size
, "(long)(&%s)", sym_name
);
1237 #define PLT_ENTRY_SIZE 16 /* 1 bundle containing "brl" */
1240 struct plt_entry
*next
;
1242 unsigned long addend
;
1246 get_plt_index (const char *name
, unsigned long addend
)
1248 struct plt_entry
*plt
, *prev
= NULL
;
1251 /* see if we already have an entry for this target: */
1252 for (plt
= plt_list
; plt
; ++index
, prev
= plt
, plt
= plt
->next
)
1253 if (strcmp(plt
->name
, name
) == 0 && plt
->addend
== addend
)
1256 /* nope; create a new PLT entry: */
1258 plt
= malloc(sizeof(*plt
));
1263 memset(plt
, 0, sizeof(*plt
));
1264 plt
->name
= strdup(name
);
1265 plt
->addend
= addend
;
1267 /* append to plt-list: */
1279 int arm_emit_ldr_info(const char *name
, unsigned long start_offset
,
1280 FILE *outfile
, uint8_t *p_start
, uint8_t *p_end
,
1281 ELF_RELOC
*relocs
, int nb_relocs
)
1285 int offset
, min_offset
, pc_offset
, data_size
, spare
, max_pool
;
1286 uint8_t data_allocated
[1024];
1287 unsigned int data_index
;
1290 memset(data_allocated
, 0, sizeof(data_allocated
));
1293 min_offset
= p_end
- p_start
;
1295 while (p
< p_start
+ min_offset
) {
1296 insn
= get32((uint32_t *)p
);
1297 /* TODO: Armv5e ldrd. */
1298 /* TODO: VFP load. */
1299 if ((insn
& 0x0d5f0000) == 0x051f0000) {
1300 /* ldr reg, [pc, #im] */
1301 offset
= insn
& 0xfff;
1302 if (!(insn
& 0x00800000))
1306 } else if ((insn
& 0x0e5f0f00) == 0x0c1f0100) {
1308 offset
= (insn
& 0xff) << 2;
1309 if (!(insn
& 0x00800000))
1313 } else if ((insn
& 0x0fff0000) == 0x028f0000) {
1314 /* Some gcc load a doubleword immediate with
1316 ldmia regN, {regN, regM}
1317 Hope and pray the compiler never generates somethin like
1318 add reg, pc, #imm1; ldr reg, [reg, #-imm2]; */
1321 r
= (insn
& 0xf00) >> 7;
1322 offset
= ((insn
& 0xff) >> r
) | ((insn
& 0xff) << (32 - r
));
1330 /* PC-relative load needs fixing up. */
1331 if (spare
> max_pool
- offset
)
1332 spare
= max_pool
- offset
;
1333 if ((offset
& 3) !=0)
1334 error("%s:%04x: pc offset must be 32 bit aligned",
1335 name
, start_offset
+ p
- p_start
);
1337 error("%s:%04x: Embedded literal value",
1338 name
, start_offset
+ p
- p_start
);
1339 pc_offset
= p
- p_start
+ offset
+ 8;
1340 if (pc_offset
<= (p
- p_start
) ||
1341 pc_offset
>= (p_end
- p_start
))
1342 error("%s:%04x: pc offset must point inside the function code",
1343 name
, start_offset
+ p
- p_start
);
1344 if (pc_offset
< min_offset
)
1345 min_offset
= pc_offset
;
1347 /* The intruction position */
1348 fprintf(outfile
, " arm_ldr_ptr->ptr = gen_code_ptr + %d;\n",
1350 /* The position of the constant pool data. */
1351 data_index
= ((p_end
- p_start
) - pc_offset
) >> 2;
1352 fprintf(outfile
, " arm_ldr_ptr->data_ptr = arm_data_ptr - %d;\n",
1354 fprintf(outfile
, " arm_ldr_ptr->type = %d;\n", type
);
1355 fprintf(outfile
, " arm_ldr_ptr++;\n");
1361 /* Copy and relocate the constant pool data. */
1362 data_size
= (p_end
- p_start
) - min_offset
;
1363 if (data_size
> 0 && outfile
) {
1364 spare
+= min_offset
;
1365 fprintf(outfile
, " arm_data_ptr -= %d;\n", data_size
>> 2);
1366 fprintf(outfile
, " arm_pool_ptr -= %d;\n", data_size
);
1367 fprintf(outfile
, " if (arm_pool_ptr > gen_code_ptr + %d)\n"
1368 " arm_pool_ptr = gen_code_ptr + %d;\n",
1372 for (pc_offset
= min_offset
;
1373 pc_offset
< p_end
- p_start
;
1377 int i
, addend
, type
;
1378 const char *sym_name
;
1382 addend
= get32((uint32_t *)(p_start
+ pc_offset
));
1384 for(i
= 0, rel
= relocs
;i
< nb_relocs
; i
++, rel
++) {
1385 if (rel
->r_offset
== (pc_offset
+ start_offset
)) {
1386 sym_name
= get_rel_sym_name(rel
);
1387 /* the compiler leave some unnecessary references to the code */
1388 get_reloc_expr(relname
, sizeof(relname
), sym_name
);
1389 type
= ELF32_R_TYPE(rel
->r_info
);
1390 if (type
!= R_ARM_ABS32
)
1391 error("%s: unsupported data relocation", name
);
1395 fprintf(outfile
, " arm_data_ptr[%d] = 0x%x",
1396 data_index
, addend
);
1397 if (relname
[0] != '\0')
1398 fprintf(outfile
, " + %s", relname
);
1399 fprintf(outfile
, ";\n");
1408 insn
= get32((uint32_t *)p
);
1409 /* The last instruction must be an ldm instruction. There are several
1410 forms generated by gcc:
1411 ldmib sp, {..., pc} (implies a sp adjustment of +4)
1413 ldmea fp, {..., pc} */
1414 if ((insn
& 0xffff8000) == 0xe99d8000) {
1417 " *(uint32_t *)(gen_code_ptr + %d) = 0xe28dd004;\n",
1421 } else if ((insn
& 0xffff8000) != 0xe89d8000
1422 && (insn
& 0xffff8000) != 0xe91b8000) {
1425 printf("%s: invalid epilog\n", name
);
1434 /* generate op code */
1435 void gen_code(const char *name
, host_ulong offset
, host_ulong size
,
1436 FILE *outfile
, int gen_switch
)
1439 uint8_t *p_start
, *p_end
;
1440 host_ulong start_offset
;
1442 uint8_t args_present
[MAX_ARGS
];
1443 const char *sym_name
, *p
;
1446 /* Compute exact size excluding prologue and epilogue instructions.
1447 * Increment start_offset to skip epilogue instructions, then compute
1448 * copy_size the indicate the size of the remaining instructions (in
1451 p_start
= text
+ offset
;
1452 p_end
= p_start
+ size
;
1453 start_offset
= offset
;
1454 #if defined(HOST_I386) || defined(HOST_X86_64)
1455 #ifdef CONFIG_FORMAT_COFF
1460 error("empty code for %s", name
);
1461 while (*p
!= 0xc3) {
1464 error("ret or jmp expected at the end of %s", name
);
1466 copy_size
= p
- p_start
;
1471 len
= p_end
- p_start
;
1473 error("empty code for %s", name
);
1474 if (p_end
[-1] == 0xc3) {
1477 error("ret or jmp expected at the end of %s", name
);
1482 #elif defined(HOST_PPC)
1485 p
= (void *)(p_end
- 4);
1487 error("empty code for %s", name
);
1488 if (get32((uint32_t *)p
) != 0x4e800020)
1489 error("blr expected at the end of %s", name
);
1490 copy_size
= p
- p_start
;
1492 #elif defined(HOST_S390)
1495 p
= (void *)(p_end
- 2);
1497 error("empty code for %s", name
);
1498 if (get16((uint16_t *)p
) != 0x07fe && get16((uint16_t *)p
) != 0x07f4)
1499 error("br %%r14 expected at the end of %s", name
);
1500 copy_size
= p
- p_start
;
1502 #elif defined(HOST_ALPHA)
1507 /* XXX: check why it occurs */
1509 error("empty code for %s", name
);
1511 if (get32((uint32_t *)p
) != 0x6bfa8001)
1512 error("ret expected at the end of %s", name
);
1513 copy_size
= p
- p_start
;
1515 #elif defined(HOST_IA64)
1518 p
= (void *)(p_end
- 4);
1520 error("empty code for %s", name
);
1521 /* br.ret.sptk.many b0;; */
1523 if (get32((uint32_t *)p
) != 0x00840008)
1524 error("br.ret.sptk.many b0;; expected at the end of %s", name
);
1525 copy_size
= p_end
- p_start
;
1527 #elif defined(HOST_SPARC)
1529 #define INSN_SAVE 0x9de3a000
1530 #define INSN_RET 0x81c7e008
1531 #define INSN_RETL 0x81c3e008
1532 #define INSN_RESTORE 0x81e80000
1533 #define INSN_RETURN 0x81cfe008
1534 #define INSN_NOP 0x01000000
1535 #define INSN_ADD_SP 0x9c03a000 // add %sp, nn, %sp
1536 #define INSN_SUB_SP 0x9c23a000 // sub %sp, nn, %sp
1538 uint32_t start_insn
, end_insn1
, end_insn2
;
1540 p
= (void *)(p_end
- 8);
1542 error("empty code for %s", name
);
1543 start_insn
= get32((uint32_t *)(p_start
+ 0x0));
1544 end_insn1
= get32((uint32_t *)(p
+ 0x0));
1545 end_insn2
= get32((uint32_t *)(p
+ 0x4));
1546 if (((start_insn
& ~0x1fff) == INSN_SAVE
) ||
1547 (start_insn
& ~0x1fff) == INSN_ADD_SP
) {
1549 start_offset
+= 0x4;
1550 if (end_insn1
== INSN_RET
&& end_insn2
== INSN_RESTORE
)
1551 /* SPARC v7: ret; restore; */ ;
1552 else if (end_insn1
== INSN_RETURN
&& end_insn2
== INSN_NOP
)
1553 /* SPARC v9: return; nop; */ ;
1554 else if (end_insn1
== INSN_RETL
&& (end_insn2
& ~0x1fff) == INSN_SUB_SP
)
1555 /* SPARC v7: retl; sub %sp, nn, %sp; */ ;
1558 error("ret; restore; not found at end of %s", name
);
1559 } else if (end_insn1
== INSN_RETL
&& end_insn2
== INSN_NOP
) {
1562 error("No save at the beginning of %s", name
);
1565 /* Skip a preceeding nop, if present. */
1567 skip_insn
= get32((uint32_t *)(p
- 0x4));
1568 if (skip_insn
== INSN_NOP
)
1572 copy_size
= p
- p_start
;
1574 #elif defined(HOST_SPARC64)
1576 #define INSN_SAVE 0x9de3a000
1577 #define INSN_RET 0x81c7e008
1578 #define INSN_RETL 0x81c3e008
1579 #define INSN_RESTORE 0x81e80000
1580 #define INSN_RETURN 0x81cfe008
1581 #define INSN_NOP 0x01000000
1582 #define INSN_ADD_SP 0x9c03a000 // add %sp, nn, %sp
1583 #define INSN_SUB_SP 0x9c23a000 // sub %sp, nn, %sp
1585 uint32_t start_insn
, end_insn1
, end_insn2
, skip_insn
;
1587 p
= (void *)(p_end
- 8);
1589 /* XXX: check why it occurs */
1591 error("empty code for %s", name
);
1593 start_insn
= get32((uint32_t *)(p_start
+ 0x0));
1594 end_insn1
= get32((uint32_t *)(p
+ 0x0));
1595 end_insn2
= get32((uint32_t *)(p
+ 0x4));
1596 if (((start_insn
& ~0x1fff) == INSN_SAVE
) ||
1597 (start_insn
& ~0x1fff) == INSN_ADD_SP
) {
1599 start_offset
+= 0x4;
1600 if (end_insn1
== INSN_RET
&& end_insn2
== INSN_RESTORE
)
1601 /* SPARC v7: ret; restore; */ ;
1602 else if (end_insn1
== INSN_RETURN
&& end_insn2
== INSN_NOP
)
1603 /* SPARC v9: return; nop; */ ;
1604 else if (end_insn1
== INSN_RETL
&& (end_insn2
& ~0x1fff) == INSN_SUB_SP
)
1605 /* SPARC v7: retl; sub %sp, nn, %sp; */ ;
1608 error("ret; restore; not found at end of %s", name
);
1609 } else if (end_insn1
== INSN_RETL
&& end_insn2
== INSN_NOP
) {
1612 error("No save at the beginning of %s", name
);
1615 /* Skip a preceeding nop, if present. */
1617 skip_insn
= get32((uint32_t *)(p
- 0x4));
1618 if (skip_insn
== 0x01000000)
1622 copy_size
= p
- p_start
;
1624 #elif defined(HOST_ARM)
1628 if ((p_end
- p_start
) <= 16)
1629 error("%s: function too small", name
);
1630 if (get32((uint32_t *)p_start
) != 0xe1a0c00d ||
1631 (get32((uint32_t *)(p_start
+ 4)) & 0xffff0000) != 0xe92d0000 ||
1632 get32((uint32_t *)(p_start
+ 8)) != 0xe24cb004)
1633 error("%s: invalid prolog", name
);
1636 insn
= get32((uint32_t *)p_start
);
1637 if ((insn
& 0xffffff00) == 0xe24dd000) {
1638 /* Stack adjustment. Assume op uses the frame pointer. */
1642 copy_size
= arm_emit_ldr_info(name
, start_offset
, NULL
, p_start
, p_end
,
1645 #elif defined(HOST_M68K)
1648 p
= (void *)(p_end
- 2);
1650 error("empty code for %s", name
);
1651 // remove NOP's, probably added for alignment
1652 while ((get16((uint16_t *)p
) == 0x4e71) &&
1655 if (get16((uint16_t *)p
) != 0x4e75)
1656 error("rts expected at the end of %s", name
);
1657 copy_size
= p
- p_start
;
1659 #elif defined(HOST_MIPS) || defined(HOST_MIPS64)
1661 #define INSN_RETURN 0x03e00008
1662 #define INSN_NOP 0x00000000
1666 if (p
< (p_start
+ 0x8)) {
1667 error("empty code for %s", name
);
1669 uint32_t end_insn1
, end_insn2
;
1672 end_insn1
= get32((uint32_t *)(p
+ 0x0));
1673 end_insn2
= get32((uint32_t *)(p
+ 0x4));
1674 if (end_insn1
!= INSN_RETURN
&& end_insn2
!= INSN_NOP
)
1675 error("jr ra not found at end of %s", name
);
1677 copy_size
= p
- p_start
;
1680 #error unsupported CPU
1683 /* compute the number of arguments by looking at the relocations */
1684 for(i
= 0;i
< MAX_ARGS
; i
++)
1685 args_present
[i
] = 0;
1687 for(i
= 0, rel
= relocs
;i
< nb_relocs
; i
++, rel
++) {
1688 host_ulong offset
= get_rel_offset(rel
);
1689 if (offset
>= start_offset
&&
1690 offset
< start_offset
+ (p_end
- p_start
)) {
1691 sym_name
= get_rel_sym_name(rel
);
1694 if (strstart(sym_name
, "__op_param", &p
) ||
1695 strstart(sym_name
, "__op_gen_label", &p
)) {
1696 n
= strtoul(p
, NULL
, 10);
1698 error("too many arguments in %s", name
);
1699 args_present
[n
- 1] = 1;
1705 while (nb_args
< MAX_ARGS
&& args_present
[nb_args
])
1707 for(i
= nb_args
; i
< MAX_ARGS
; i
++) {
1708 if (args_present
[i
])
1709 error("inconsistent argument numbering in %s", name
);
1712 if (gen_switch
== 2) {
1713 fprintf(outfile
, "DEF(%s, %d, %d)\n", name
+ 3, nb_args
, copy_size
);
1714 } else if (gen_switch
== 1) {
1717 fprintf(outfile
, "case INDEX_%s: {\n", name
);
1719 fprintf(outfile
, " long ");
1720 for(i
= 0; i
< nb_args
; i
++) {
1722 fprintf(outfile
, ", ");
1723 fprintf(outfile
, "param%d", i
+ 1);
1725 fprintf(outfile
, ";\n");
1727 #if defined(HOST_IA64)
1728 fprintf(outfile
, " extern char %s;\n", name
);
1730 fprintf(outfile
, " extern void %s();\n", name
);
1733 for(i
= 0, rel
= relocs
;i
< nb_relocs
; i
++, rel
++) {
1734 host_ulong offset
= get_rel_offset(rel
);
1735 if (offset
>= start_offset
&&
1736 offset
< start_offset
+ (p_end
- p_start
)) {
1737 sym_name
= get_rel_sym_name(rel
);
1741 !strstart(sym_name
, "__op_param", NULL
) &&
1742 !strstart(sym_name
, "__op_jmp", NULL
) &&
1743 !strstart(sym_name
, "__op_gen_label", NULL
)) {
1744 #if defined(HOST_SPARC)
1745 if (sym_name
[0] == '.') {
1747 "extern char __dot_%s __asm__(\"%s\");\n",
1748 sym_name
+1, sym_name
);
1752 #if defined(__APPLE__)
1753 /* Set __attribute((unused)) on darwin because we
1754 want to avoid warning when we don't use the symbol. */
1755 fprintf(outfile
, " extern char %s __attribute__((unused));\n", sym_name
);
1756 #elif defined(HOST_IA64)
1757 if (ELF64_R_TYPE(rel
->r_info
) != R_IA64_PCREL21B
)
1759 * PCREL21 br.call targets generally
1760 * are out of range and need to go
1761 * through an "import stub".
1763 fprintf(outfile
, " extern char %s;\n",
1766 fprintf(outfile
, "extern char %s;\n", sym_name
);
1772 fprintf(outfile
, " memcpy(gen_code_ptr, (void *)((char *)&%s+%d), %d);\n",
1773 name
, (int)(start_offset
- offset
), copy_size
);
1775 /* emit code offset information */
1778 const char *sym_name
, *p
;
1782 for(i
= 0, sym
= symtab
; i
< nb_syms
; i
++, sym
++) {
1783 sym_name
= get_sym_name(sym
);
1784 if (strstart(sym_name
, "__op_label", &p
)) {
1786 unsigned long offset
;
1788 /* test if the variable refers to a label inside
1789 the code we are generating */
1790 #ifdef CONFIG_FORMAT_COFF
1791 if (sym
->st_shndx
== text_shndx
) {
1792 ptr
= sdata
[coff_text_shndx
];
1793 } else if (sym
->st_shndx
== data_shndx
) {
1794 ptr
= sdata
[coff_data_shndx
];
1798 #elif defined(CONFIG_FORMAT_MACH)
1801 ptr
= sdata
[sym
->n_sect
-1];
1803 ptr
= sdata
[sym
->st_shndx
];
1806 error("__op_labelN in invalid section");
1807 offset
= sym
->st_value
;
1808 #ifdef CONFIG_FORMAT_MACH
1809 offset
-= section_hdr
[sym
->n_sect
-1].addr
;
1811 val
= *(host_ulong
*)(ptr
+ offset
);
1812 #ifdef ELF_USES_RELOCA
1814 int reloc_shndx
, nb_relocs1
, j
;
1816 /* try to find a matching relocation */
1817 reloc_shndx
= find_reloc(sym
->st_shndx
);
1819 nb_relocs1
= shdr
[reloc_shndx
].sh_size
/
1820 shdr
[reloc_shndx
].sh_entsize
;
1821 rel
= (ELF_RELOC
*)sdata
[reloc_shndx
];
1822 for(j
= 0; j
< nb_relocs1
; j
++) {
1823 if (rel
->r_offset
== offset
) {
1824 val
= rel
->r_addend
;
1832 if (val
>= start_offset
&& val
<= start_offset
+ copy_size
) {
1833 n
= strtol(p
, NULL
, 10);
1834 fprintf(outfile
, " label_offsets[%d] = %ld + (gen_code_ptr - gen_code_buf);\n", n
, (long)(val
- start_offset
));
1840 /* load parameters in variables */
1841 for(i
= 0; i
< nb_args
; i
++) {
1842 fprintf(outfile
, " param%d = *opparam_ptr++;\n", i
+ 1);
1845 /* patch relocations */
1846 #if defined(HOST_I386)
1852 for(i
= 0, rel
= relocs
;i
< nb_relocs
; i
++, rel
++) {
1853 if (rel
->r_offset
>= start_offset
&&
1854 rel
->r_offset
< start_offset
+ copy_size
) {
1855 sym_name
= get_rel_sym_name(rel
);
1858 reloc_offset
= rel
->r_offset
- start_offset
;
1859 if (strstart(sym_name
, "__op_jmp", &p
)) {
1861 n
= strtol(p
, NULL
, 10);
1862 /* __op_jmp relocations are done at
1863 runtime to do translated block
1864 chaining: the offset of the instruction
1865 needs to be stored */
1866 fprintf(outfile
, " jmp_offsets[%d] = %d + (gen_code_ptr - gen_code_buf);\n",
1871 get_reloc_expr(relname
, sizeof(relname
), sym_name
);
1872 addend
= get32((uint32_t *)(text
+ rel
->r_offset
));
1873 #ifdef CONFIG_FORMAT_ELF
1874 type
= ELF32_R_TYPE(rel
->r_info
);
1877 fprintf(outfile
, " *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",
1878 reloc_offset
, relname
, addend
);
1881 fprintf(outfile
, " *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %d) + %d;\n",
1882 reloc_offset
, relname
, reloc_offset
, addend
);
1885 error("unsupported i386 relocation (%d)", type
);
1887 #elif defined(CONFIG_FORMAT_COFF)
1892 temp_name
= get_sym_name(symtab
+ *(uint32_t *)(rel
->r_reloc
->r_symndx
));
1893 if (!strcmp(temp_name
, ".data")) {
1894 for (j
= 0, sym
= symtab
; j
< nb_syms
; j
++, sym
++) {
1895 if (strstart(sym
->st_name
, sym_name
, NULL
)) {
1896 addend
-= sym
->st_value
;
1904 fprintf(outfile
, " *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",
1905 reloc_offset
, relname
, addend
);
1908 fprintf(outfile
, " *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %d) + %d -4;\n",
1909 reloc_offset
, relname
, reloc_offset
, addend
);
1912 error("unsupported i386 relocation (%d)", type
);
1915 #error unsupport object format
1920 #elif defined(HOST_X86_64)
1926 for(i
= 0, rel
= relocs
;i
< nb_relocs
; i
++, rel
++) {
1927 if (rel
->r_offset
>= start_offset
&&
1928 rel
->r_offset
< start_offset
+ copy_size
) {
1929 sym_name
= strtab
+ symtab
[ELFW(R_SYM
)(rel
->r_info
)].st_name
;
1930 get_reloc_expr(relname
, sizeof(relname
), sym_name
);
1931 type
= ELF32_R_TYPE(rel
->r_info
);
1932 addend
= rel
->r_addend
;
1933 reloc_offset
= rel
->r_offset
- start_offset
;
1936 fprintf(outfile
, " *(uint32_t *)(gen_code_ptr + %d) = (uint32_t)%s + %d;\n",
1937 reloc_offset
, relname
, addend
);
1940 fprintf(outfile
, " *(uint32_t *)(gen_code_ptr + %d) = (int32_t)%s + %d;\n",
1941 reloc_offset
, relname
, addend
);
1944 fprintf(outfile
, " *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %d) + %d;\n",
1945 reloc_offset
, relname
, reloc_offset
, addend
);
1948 error("unsupported X86_64 relocation (%d)", type
);
1953 #elif defined(HOST_PPC)
1955 #ifdef CONFIG_FORMAT_ELF
1960 for(i
= 0, rel
= relocs
;i
< nb_relocs
; i
++, rel
++) {
1961 if (rel
->r_offset
>= start_offset
&&
1962 rel
->r_offset
< start_offset
+ copy_size
) {
1963 sym_name
= strtab
+ symtab
[ELFW(R_SYM
)(rel
->r_info
)].st_name
;
1964 reloc_offset
= rel
->r_offset
- start_offset
;
1965 if (strstart(sym_name
, "__op_jmp", &p
)) {
1967 n
= strtol(p
, NULL
, 10);
1968 /* __op_jmp relocations are done at
1969 runtime to do translated block
1970 chaining: the offset of the instruction
1971 needs to be stored */
1972 fprintf(outfile
, " jmp_offsets[%d] = %d + (gen_code_ptr - gen_code_buf);\n",
1977 get_reloc_expr(relname
, sizeof(relname
), sym_name
);
1978 type
= ELF32_R_TYPE(rel
->r_info
);
1979 addend
= rel
->r_addend
;
1982 fprintf(outfile
, " *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",
1983 reloc_offset
, relname
, addend
);
1985 case R_PPC_ADDR16_LO
:
1986 fprintf(outfile
, " *(uint16_t *)(gen_code_ptr + %d) = (%s + %d);\n",
1987 reloc_offset
, relname
, addend
);
1989 case R_PPC_ADDR16_HI
:
1990 fprintf(outfile
, " *(uint16_t *)(gen_code_ptr + %d) = (%s + %d) >> 16;\n",
1991 reloc_offset
, relname
, addend
);
1993 case R_PPC_ADDR16_HA
:
1994 fprintf(outfile
, " *(uint16_t *)(gen_code_ptr + %d) = (%s + %d + 0x8000) >> 16;\n",
1995 reloc_offset
, relname
, addend
);
1998 /* warning: must be at 32 MB distancy */
1999 fprintf(outfile
, " *(uint32_t *)(gen_code_ptr + %d) = (*(uint32_t *)(gen_code_ptr + %d) & ~0x03fffffc) | ((%s - (long)(gen_code_ptr + %d) + %d) & 0x03fffffc);\n",
2000 reloc_offset
, reloc_offset
, relname
, reloc_offset
, addend
);
2003 error("unsupported powerpc relocation (%d)", type
);
2007 #elif defined(CONFIG_FORMAT_MACH)
2008 struct scattered_relocation_info
*scarel
;
2009 struct relocation_info
* rel
;
2010 char final_sym_name
[256];
2011 const char *sym_name
;
2016 for(i
= 0, rel
= relocs
; i
< nb_relocs
; i
++, rel
++) {
2017 unsigned int offset
, length
, value
= 0;
2018 unsigned int type
, pcrel
, isym
= 0;
2019 unsigned int usesym
= 0;
2021 if(R_SCATTERED
& rel
->r_address
) {
2022 scarel
= (struct scattered_relocation_info
*)rel
;
2023 offset
= (unsigned int)scarel
->r_address
;
2024 length
= scarel
->r_length
;
2025 pcrel
= scarel
->r_pcrel
;
2026 type
= scarel
->r_type
;
2027 value
= scarel
->r_value
;
2029 value
= isym
= rel
->r_symbolnum
;
2030 usesym
= (rel
->r_extern
);
2031 offset
= rel
->r_address
;
2032 length
= rel
->r_length
;
2033 pcrel
= rel
->r_pcrel
;
2037 slide
= offset
- start_offset
;
2039 if (!(offset
>= start_offset
&& offset
< start_offset
+ size
))
2040 continue; /* not in our range */
2042 sym_name
= get_reloc_name(rel
, &sslide
);
2044 if(usesym
&& symtab
[isym
].n_type
& N_STAB
)
2045 continue; /* don't handle STAB (debug sym) */
2047 if (sym_name
&& strstart(sym_name
, "__op_jmp", &p
)) {
2049 n
= strtol(p
, NULL
, 10);
2050 fprintf(outfile
, " jmp_offsets[%d] = %d + (gen_code_ptr - gen_code_buf);\n",
2052 continue; /* Nothing more to do */
2057 fprintf(outfile
, "/* #warning relocation not handled in %s (value 0x%x, %s, offset 0x%x, length 0x%x, %s, type 0x%x) */\n",
2058 relname
, value
, usesym
? "use sym" : "don't use sym", offset
, length
, pcrel
? "pcrel":"", type
);
2059 continue; /* dunno how to handle without final_sym_name */
2062 get_reloc_expr(final_sym_name
, sizeof(final_sym_name
),
2065 case PPC_RELOC_BR24
:
2066 if (!strstart(sym_name
,"__op_gen_label",&p
)) {
2067 fprintf(outfile
, "{\n");
2068 fprintf(outfile
, " uint32_t imm = *(uint32_t *)(gen_code_ptr + %d) & 0x3fffffc;\n", slide
);
2069 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",
2070 slide
, slide
, relname
, sslide
);
2071 fprintf(outfile
, "}\n");
2073 fprintf(outfile
, " *(uint32_t *)(gen_code_ptr + %d) = (*(uint32_t *)(gen_code_ptr + %d) & ~0x03fffffc) | (((long)%s - (long)gen_code_ptr - %d) & 0x03fffffc);\n",
2074 slide
, slide
, final_sym_name
, slide
);
2077 case PPC_RELOC_HI16
:
2078 fprintf(outfile
, " *(uint16_t *)(gen_code_ptr + %d + 2) = (%s + %d) >> 16;\n",
2079 slide
, final_sym_name
, sslide
);
2081 case PPC_RELOC_LO16
:
2082 fprintf(outfile
, " *(uint16_t *)(gen_code_ptr + %d + 2) = (%s + %d);\n",
2083 slide
, final_sym_name
, sslide
);
2085 case PPC_RELOC_HA16
:
2086 fprintf(outfile
, " *(uint16_t *)(gen_code_ptr + %d + 2) = (%s + %d + 0x8000) >> 16;\n",
2087 slide
, final_sym_name
, sslide
);
2090 error("unsupported powerpc relocation (%d)", type
);
2094 #error unsupport object format
2097 #elif defined(HOST_S390)
2103 for(i
= 0, rel
= relocs
;i
< nb_relocs
; i
++, rel
++) {
2104 if (rel
->r_offset
>= start_offset
&&
2105 rel
->r_offset
< start_offset
+ copy_size
) {
2106 sym_name
= strtab
+ symtab
[ELFW(R_SYM
)(rel
->r_info
)].st_name
;
2107 get_reloc_expr(relname
, sizeof(relname
), sym_name
);
2108 type
= ELF32_R_TYPE(rel
->r_info
);
2109 addend
= rel
->r_addend
;
2110 reloc_offset
= rel
->r_offset
- start_offset
;
2113 fprintf(outfile
, " *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",
2114 reloc_offset
, relname
, addend
);
2117 fprintf(outfile
, " *(uint16_t *)(gen_code_ptr + %d) = %s + %d;\n",
2118 reloc_offset
, relname
, addend
);
2121 fprintf(outfile
, " *(uint8_t *)(gen_code_ptr + %d) = %s + %d;\n",
2122 reloc_offset
, relname
, addend
);
2125 error("unsupported s390 relocation (%d)", type
);
2130 #elif defined(HOST_ALPHA)
2132 for (i
= 0, rel
= relocs
; i
< nb_relocs
; i
++, rel
++) {
2133 if (rel
->r_offset
>= start_offset
&& rel
->r_offset
< start_offset
+ copy_size
) {
2137 type
= ELF64_R_TYPE(rel
->r_info
);
2138 sym_name
= strtab
+ symtab
[ELF64_R_SYM(rel
->r_info
)].st_name
;
2139 reloc_offset
= rel
->r_offset
- start_offset
;
2141 case R_ALPHA_GPDISP
:
2142 /* The gp is just 32 bit, and never changes, so it's easiest to emit it
2143 as an immediate instead of constructing it from the pv or ra. */
2144 fprintf(outfile
, " immediate_ldah(gen_code_ptr + %ld, gp);\n",
2146 fprintf(outfile
, " immediate_lda(gen_code_ptr + %ld, gp);\n",
2147 reloc_offset
+ (int)rel
->r_addend
);
2149 case R_ALPHA_LITUSE
:
2150 /* jsr to literal hint. Could be used to optimize to bsr. Ignore for
2151 now, since some called functions (libc) need pv to be set up. */
2154 /* Branch target prediction hint. Ignore for now. Should be already
2155 correct for in-function jumps. */
2157 case R_ALPHA_LITERAL
:
2158 /* Load a literal from the GOT relative to the gp. Since there's only a
2159 single gp, nothing is to be done. */
2161 case R_ALPHA_GPRELHIGH
:
2162 /* Handle fake relocations against __op_param symbol. Need to emit the
2163 high part of the immediate value instead. Other symbols need no
2164 special treatment. */
2165 if (strstart(sym_name
, "__op_param", &p
))
2166 fprintf(outfile
, " immediate_ldah(gen_code_ptr + %ld, param%s);\n",
2169 case R_ALPHA_GPRELLOW
:
2170 if (strstart(sym_name
, "__op_param", &p
))
2171 fprintf(outfile
, " immediate_lda(gen_code_ptr + %ld, param%s);\n",
2175 /* PC-relative jump. Tweak offset to skip the two instructions that try to
2176 set up the gp from the pv. */
2177 fprintf(outfile
, " fix_bsr(gen_code_ptr + %ld, (uint8_t *) &%s - (gen_code_ptr + %ld + 4) + 8);\n",
2178 reloc_offset
, sym_name
, reloc_offset
);
2181 error("unsupported Alpha relocation (%d)", type
);
2186 #elif defined(HOST_IA64)
2188 unsigned long sym_idx
;
2194 for(i
= 0, rel
= relocs
;i
< nb_relocs
; i
++, rel
++) {
2195 sym_idx
= ELF64_R_SYM(rel
->r_info
);
2196 if (rel
->r_offset
< start_offset
2197 || rel
->r_offset
>= start_offset
+ copy_size
)
2199 sym_name
= (strtab
+ symtab
[sym_idx
].st_name
);
2200 code_offset
= rel
->r_offset
- start_offset
;
2201 if (strstart(sym_name
, "__op_jmp", &p
)) {
2203 n
= strtol(p
, NULL
, 10);
2204 /* __op_jmp relocations are done at
2205 runtime to do translated block
2206 chaining: the offset of the instruction
2207 needs to be stored */
2208 fprintf(outfile
, " jmp_offsets[%d] ="
2209 "%ld + (gen_code_ptr - gen_code_buf);\n",
2213 get_reloc_expr(relname
, sizeof(relname
), sym_name
);
2214 type
= ELF64_R_TYPE(rel
->r_info
);
2215 addend
= rel
->r_addend
;
2219 " ia64_imm64(gen_code_ptr + %ld, "
2221 code_offset
, relname
, addend
);
2223 case R_IA64_LTOFF22X
:
2224 case R_IA64_LTOFF22
:
2225 fprintf(outfile
, " IA64_LTOFF(gen_code_ptr + %ld,"
2226 " %s + %ld, %d);\n",
2227 code_offset
, relname
, addend
,
2228 (type
== R_IA64_LTOFF22X
));
2232 " ia64_ldxmov(gen_code_ptr + %ld,"
2233 " %s + %ld);\n", code_offset
, relname
, addend
);
2236 case R_IA64_PCREL21B
:
2237 if (strstart(sym_name
, "__op_gen_label", NULL
)) {
2239 " ia64_imm21b(gen_code_ptr + %ld,"
2240 " (long) (%s + %ld -\n\t\t"
2241 "((long) gen_code_ptr + %ld)) >> 4);\n",
2242 code_offset
, relname
, addend
,
2243 code_offset
& ~0xfUL
);
2246 " IA64_PLT(gen_code_ptr + %ld, "
2247 "%d);\t/* %s + %ld */\n",
2249 get_plt_index(sym_name
, addend
),
2254 error("unsupported ia64 relocation (0x%x)",
2258 fprintf(outfile
, " ia64_nop_b(gen_code_ptr + %d);\n",
2259 copy_size
- 16 + 2);
2261 #elif defined(HOST_SPARC)
2267 for(i
= 0, rel
= relocs
;i
< nb_relocs
; i
++, rel
++) {
2268 if (rel
->r_offset
>= start_offset
&&
2269 rel
->r_offset
< start_offset
+ copy_size
) {
2270 sym_name
= strtab
+ symtab
[ELF32_R_SYM(rel
->r_info
)].st_name
;
2271 get_reloc_expr(relname
, sizeof(relname
), sym_name
);
2272 type
= ELF32_R_TYPE(rel
->r_info
);
2273 addend
= rel
->r_addend
;
2274 reloc_offset
= rel
->r_offset
- start_offset
;
2277 fprintf(outfile
, " *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",
2278 reloc_offset
, relname
, addend
);
2282 " *(uint32_t *)(gen_code_ptr + %d) = "
2283 "((*(uint32_t *)(gen_code_ptr + %d)) "
2285 " | (((%s + %d) >> 10) & 0x3fffff);\n",
2286 reloc_offset
, reloc_offset
, relname
, addend
);
2290 " *(uint32_t *)(gen_code_ptr + %d) = "
2291 "((*(uint32_t *)(gen_code_ptr + %d)) "
2293 " | ((%s + %d) & 0x3ff);\n",
2294 reloc_offset
, reloc_offset
, relname
, addend
);
2296 case R_SPARC_WDISP30
:
2298 " *(uint32_t *)(gen_code_ptr + %d) = "
2299 "((*(uint32_t *)(gen_code_ptr + %d)) "
2301 " | ((((%s + %d) - (long)(gen_code_ptr + %d))>>2) "
2302 " & 0x3fffffff);\n",
2303 reloc_offset
, reloc_offset
, relname
, addend
,
2306 case R_SPARC_WDISP22
:
2308 " *(uint32_t *)(gen_code_ptr + %d) = "
2309 "((*(uint32_t *)(gen_code_ptr + %d)) "
2311 " | ((((%s + %d) - (long)(gen_code_ptr + %d))>>2) "
2313 rel
->r_offset
- start_offset
,
2314 rel
->r_offset
- start_offset
,
2316 rel
->r_offset
- start_offset
);
2319 error("unsupported sparc relocation (%d)", type
);
2324 #elif defined(HOST_SPARC64)
2330 for(i
= 0, rel
= relocs
;i
< nb_relocs
; i
++, rel
++) {
2331 if (rel
->r_offset
>= start_offset
&&
2332 rel
->r_offset
< start_offset
+ copy_size
) {
2333 sym_name
= strtab
+ symtab
[ELF64_R_SYM(rel
->r_info
)].st_name
;
2334 get_reloc_expr(relname
, sizeof(relname
), sym_name
);
2335 type
= ELF32_R_TYPE(rel
->r_info
);
2336 addend
= rel
->r_addend
;
2337 reloc_offset
= rel
->r_offset
- start_offset
;
2340 fprintf(outfile
, " *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",
2341 reloc_offset
, relname
, addend
);
2345 " *(uint32_t *)(gen_code_ptr + %d) = "
2346 "((*(uint32_t *)(gen_code_ptr + %d)) "
2348 " | (((%s + %d) >> 10) & 0x3fffff);\n",
2349 reloc_offset
, reloc_offset
, relname
, addend
);
2353 " *(uint32_t *)(gen_code_ptr + %d) = "
2354 "((*(uint32_t *)(gen_code_ptr + %d)) "
2356 " | ((%s + %d) & 0x3ff);\n",
2357 reloc_offset
, reloc_offset
, relname
, addend
);
2360 addend
+= ELF64_R_TYPE_DATA (rel
->r_info
);
2362 " *(uint32_t *)(gen_code_ptr + %d) = "
2363 "((*(uint32_t *)(gen_code_ptr + %d)) "
2365 " | ((%s + %d) & 0x3ff);\n",
2366 reloc_offset
, reloc_offset
, relname
, addend
);
2368 case R_SPARC_WDISP30
:
2370 " *(uint32_t *)(gen_code_ptr + %d) = "
2371 "((*(uint32_t *)(gen_code_ptr + %d)) "
2373 " | ((((%s + %d) - (long)(gen_code_ptr + %d))>>2) "
2374 " & 0x3fffffff);\n",
2375 reloc_offset
, reloc_offset
, relname
, addend
,
2378 case R_SPARC_WDISP22
:
2380 " *(uint32_t *)(gen_code_ptr + %d) = "
2381 "((*(uint32_t *)(gen_code_ptr + %d)) "
2383 " | ((((%s + %d) - (long)(gen_code_ptr + %d))>>2) "
2385 reloc_offset
, reloc_offset
, relname
, addend
,
2390 " *(uint32_t *)(gen_code_ptr + %d) = "
2391 "((*(uint32_t *)(gen_code_ptr + %d)) "
2393 " | (((%s + %d) >> 42) & 0x00000000);\n",
2394 reloc_offset
, reloc_offset
, relname
, addend
);
2399 " *(uint32_t *)(gen_code_ptr + %d) = "
2400 "((*(uint32_t *)(gen_code_ptr + %d)) "
2402 " | (((%s + %d) >> 10) & 0x00000000);\n",
2403 reloc_offset
, reloc_offset
, relname
, addend
);
2408 " *(uint32_t *)(gen_code_ptr + %d) = "
2409 "((*(uint32_t *)(gen_code_ptr + %d)) "
2411 " | ((((%s + %d) >> 32 & 0x3ff)) & 0x00000000);\n",
2412 reloc_offset
, reloc_offset
, relname
, addend
);
2416 error("unsupported sparc64 relocation (%d) for symbol %s", type
, relname
);
2421 #elif defined(HOST_ARM)
2429 insn
= get32((uint32_t *)(p_start
+ 4));
2430 /* If prologue ends in sub sp, sp, #const then assume
2431 op has a stack frame and needs the frame pointer. */
2432 if ((insn
& 0xffffff00) == 0xe24dd000) {
2435 opcode
= 0xe28db000; /* add fp, sp, #0. */
2437 /* ??? Need to undo the extra stack adjustment at the end of the op.
2438 For now just leave the stack misaligned and hope it doesn't break anything
2440 if ((insn
& 4) != 0) {
2441 /* Preserve doubleword stack alignment. */
2443 " *(uint32_t *)(gen_code_ptr + 4)= 0x%x;\n",
2448 insn
= get32((uint32_t *)(p_start
- 4));
2449 /* Calculate the size of the saved registers,
2451 for (i
= 0; i
< 15; i
++) {
2452 if (insn
& (1 << i
))
2456 " *(uint32_t *)gen_code_ptr = 0x%x;\n", opcode
);
2458 arm_emit_ldr_info(relname
, start_offset
, outfile
, p_start
, p_end
,
2461 for(i
= 0, rel
= relocs
;i
< nb_relocs
; i
++, rel
++) {
2462 if (rel
->r_offset
>= start_offset
&&
2463 rel
->r_offset
< start_offset
+ copy_size
) {
2464 sym_name
= strtab
+ symtab
[ELFW(R_SYM
)(rel
->r_info
)].st_name
;
2465 /* the compiler leave some unnecessary references to the code */
2466 if (sym_name
[0] == '\0')
2468 get_reloc_expr(relname
, sizeof(relname
), sym_name
);
2469 type
= ELF32_R_TYPE(rel
->r_info
);
2470 addend
= get32((uint32_t *)(text
+ rel
->r_offset
));
2471 reloc_offset
= rel
->r_offset
- start_offset
;
2474 fprintf(outfile
, " *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",
2475 reloc_offset
, relname
, addend
);
2480 fprintf(outfile
, " arm_reloc_pc24((uint32_t *)(gen_code_ptr + %d), 0x%x, %s);\n",
2481 reloc_offset
, addend
, relname
);
2484 error("unsupported arm relocation (%d)", type
);
2489 #elif defined(HOST_M68K)
2496 for(i
= 0, rel
= relocs
;i
< nb_relocs
; i
++, rel
++) {
2497 if (rel
->r_offset
>= start_offset
&&
2498 rel
->r_offset
< start_offset
+ copy_size
) {
2499 sym
= &(symtab
[ELFW(R_SYM
)(rel
->r_info
)]);
2500 sym_name
= strtab
+ symtab
[ELFW(R_SYM
)(rel
->r_info
)].st_name
;
2501 get_reloc_expr(relname
, sizeof(relname
), sym_name
);
2502 type
= ELF32_R_TYPE(rel
->r_info
);
2503 addend
= get32((uint32_t *)(text
+ rel
->r_offset
)) + rel
->r_addend
;
2504 reloc_offset
= rel
->r_offset
- start_offset
;
2507 fprintf(outfile
, " /* R_68K_32 RELOC, offset %x */\n", rel
->r_offset
) ;
2508 fprintf(outfile
, " *(uint32_t *)(gen_code_ptr + %d) = %s + %#x;\n",
2509 reloc_offset
, relname
, addend
);
2512 fprintf(outfile
, " /* R_68K_PC32 RELOC, offset %x */\n", rel
->r_offset
);
2513 fprintf(outfile
, " *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %#x) + %#x;\n",
2514 reloc_offset
, relname
, reloc_offset
, /*sym->st_value+*/ addend
);
2517 error("unsupported m68k relocation (%d)", type
);
2522 #elif defined(HOST_MIPS) || defined(HOST_MIPS64)
2524 for (i
= 0, rel
= relocs
; i
< nb_relocs
; i
++, rel
++) {
2525 if (rel
->r_offset
>= start_offset
&& rel
->r_offset
< start_offset
+ copy_size
) {
2531 sym_name
= strtab
+ symtab
[ELF32_R_SYM(rel
->r_info
)].st_name
;
2532 /* the compiler leave some unnecessary references to the code */
2533 if (sym_name
[0] == '\0')
2535 get_reloc_expr(relname
, sizeof(relname
), sym_name
);
2536 type
= ELF32_R_TYPE(rel
->r_info
);
2537 addend
= get32((uint32_t *)(text
+ rel
->r_offset
));
2538 reloc_offset
= rel
->r_offset
- start_offset
;
2541 fprintf(outfile
, " /* R_MIPS_26 RELOC, offset 0x%x, name %s */\n",
2542 rel
->r_offset
, sym_name
);
2544 " *(uint32_t *)(gen_code_ptr + 0x%x) = "
2545 "(0x%x & ~0x3fffff) "
2546 "| ((0x%x + ((%s - (*(uint32_t *)(gen_code_ptr + 0x%x))) >> 2)) "
2548 reloc_offset
, addend
, addend
, relname
, reloc_offset
);
2551 fprintf(outfile
, " /* R_MIPS_HI16 RELOC, offset 0x%x, name %s */\n",
2552 rel
->r_offset
, sym_name
);
2554 " *(uint32_t *)(gen_code_ptr + 0x%x) = "
2555 "((*(uint32_t *)(gen_code_ptr + 0x%x)) "
2557 " | (((%s - 0x8000) >> 16) & 0xffff);\n",
2558 reloc_offset
, reloc_offset
, relname
);
2561 fprintf(outfile
, " /* R_MIPS_LO16 RELOC, offset 0x%x, name %s */\n",
2562 rel
->r_offset
, sym_name
);
2564 " *(uint32_t *)(gen_code_ptr + 0x%x) = "
2565 "((*(uint32_t *)(gen_code_ptr + 0x%x)) "
2567 " | (%s & 0xffff);\n",
2568 reloc_offset
, reloc_offset
, relname
);
2571 fprintf(outfile
, " /* R_MIPS_PC16 RELOC, offset 0x%x, name %s */\n",
2572 rel
->r_offset
, sym_name
);
2574 " *(uint32_t *)(gen_code_ptr + 0x%x) = "
2576 "| ((0x%x + ((%s - (*(uint32_t *)(gen_code_ptr + 0x%x))) >> 2)) "
2578 reloc_offset
, addend
, addend
, relname
, reloc_offset
);
2582 fprintf(outfile
, " /* R_MIPS_GOT16 RELOC, offset 0x%x, name %s */\n",
2583 rel
->r_offset
, sym_name
);
2585 " *(uint32_t *)(gen_code_ptr + 0x%x) = "
2586 "((*(uint32_t *)(gen_code_ptr + 0x%x)) "
2588 " | (((%s - 0x8000) >> 16) & 0xffff);\n",
2589 reloc_offset
, reloc_offset
, relname
);
2592 error("unsupported MIPS relocation (%d)", type
);
2598 #error unsupported CPU
2600 fprintf(outfile
, " gen_code_ptr += %d;\n", copy_size
);
2601 fprintf(outfile
, "}\n");
2602 fprintf(outfile
, "break;\n\n");
2604 fprintf(outfile
, "static inline void gen_%s(", name
);
2606 fprintf(outfile
, "void");
2608 for(i
= 0; i
< nb_args
; i
++) {
2610 fprintf(outfile
, ", ");
2611 fprintf(outfile
, "long param%d", i
+ 1);
2614 fprintf(outfile
, ")\n");
2615 fprintf(outfile
, "{\n");
2616 for(i
= 0; i
< nb_args
; i
++) {
2617 fprintf(outfile
, " *gen_opparam_ptr++ = param%d;\n", i
+ 1);
2619 fprintf(outfile
, " *gen_opc_ptr++ = INDEX_%s;\n", name
);
2620 fprintf(outfile
, "}\n\n");
2624 int gen_file(FILE *outfile
, int out_type
)
2629 if (out_type
== OUT_INDEX_OP
) {
2630 fprintf(outfile
, "DEF(end, 0, 0)\n");
2631 fprintf(outfile
, "DEF(nop, 0, 0)\n");
2632 fprintf(outfile
, "DEF(nop1, 1, 0)\n");
2633 fprintf(outfile
, "DEF(nop2, 2, 0)\n");
2634 fprintf(outfile
, "DEF(nop3, 3, 0)\n");
2635 for(i
= 0, sym
= symtab
; i
< nb_syms
; i
++, sym
++) {
2637 name
= get_sym_name(sym
);
2638 if (strstart(name
, OP_PREFIX
, NULL
)) {
2639 gen_code(name
, sym
->st_value
, sym
->st_size
, outfile
, 2);
2642 } else if (out_type
== OUT_GEN_OP
) {
2643 /* generate gen_xxx functions */
2644 fprintf(outfile
, "#include \"dyngen-op.h\"\n");
2645 for(i
= 0, sym
= symtab
; i
< nb_syms
; i
++, sym
++) {
2647 name
= get_sym_name(sym
);
2648 if (strstart(name
, OP_PREFIX
, NULL
)) {
2649 #if defined(CONFIG_FORMAT_ELF) || defined(CONFIG_FORMAT_COFF)
2650 if (sym
->st_shndx
!= text_shndx
)
2651 error("invalid section for opcode (0x%x)", sym
->st_shndx
);
2653 gen_code(name
, sym
->st_value
, sym
->st_size
, outfile
, 0);
2658 /* generate big code generation switch */
2661 /* We need to know the size of all the ops so we can figure out when
2662 to emit constant pools. This must be consistent with opc.h. */
2664 "static const uint32_t arm_opc_size[] = {\n"
2669 " 0,\n"); /* nop3 */
2670 for(i
= 0, sym
= symtab
; i
< nb_syms
; i
++, sym
++) {
2672 name
= get_sym_name(sym
);
2673 if (strstart(name
, OP_PREFIX
, NULL
)) {
2674 fprintf(outfile
, " %d,\n", sym
->st_size
);
2682 "int dyngen_code(uint8_t *gen_code_buf,\n"
2683 " uint16_t *label_offsets, uint16_t *jmp_offsets,\n"
2684 " const uint16_t *opc_buf, const uint32_t *opparam_buf, const long *gen_labels)\n"
2686 " uint8_t *gen_code_ptr;\n"
2687 " const uint16_t *opc_ptr;\n"
2688 " const uint32_t *opparam_ptr;\n");
2691 /* Arm is tricky because it uses constant pools for loading immediate values.
2692 We assume (and require) each function is code followed by a constant pool.
2693 All the ops are small so this should be ok. For each op we figure
2694 out how much "spare" range we have in the load instructions. This allows
2695 us to insert subsequent ops in between the op and the constant pool,
2696 eliminating the neeed to jump around the pool.
2698 We currently generate:
2700 [ For this example we assume merging would move op1_pool out of range.
2701 In practice we should be able to combine many ops before the offset
2702 limits are reached. ]
2713 Ideally we'd put op1_pool before op2_pool, but that requires two passes.
2716 " uint8_t *last_gen_code_ptr = gen_code_buf;\n"
2717 " LDREntry *arm_ldr_ptr = arm_ldr_table;\n"
2718 " uint32_t *arm_data_ptr = arm_data_table + ARM_LDR_TABLE_SIZE;\n"
2719 /* Initialise the parmissible pool offset to an arbitary large value. */
2720 " uint8_t *arm_pool_ptr = gen_code_buf + 0x1000000;\n");
2724 long addend
, not_first
= 0;
2725 unsigned long sym_idx
;
2726 int index
, max_index
;
2727 const char *sym_name
;
2731 for (i
= 0, rel
= relocs
;i
< nb_relocs
; i
++, rel
++) {
2732 sym_idx
= ELF64_R_SYM(rel
->r_info
);
2733 sym_name
= (strtab
+ symtab
[sym_idx
].st_name
);
2734 if (strstart(sym_name
, "__op_gen_label", NULL
))
2736 if (ELF64_R_TYPE(rel
->r_info
) != R_IA64_PCREL21B
)
2739 addend
= rel
->r_addend
;
2740 index
= get_plt_index(sym_name
, addend
);
2741 if (index
<= max_index
)
2744 fprintf(outfile
, " extern void %s(void);\n", sym_name
);
2748 " struct ia64_fixup *plt_fixes = NULL, "
2749 "*ltoff_fixes = NULL;\n"
2750 " static long plt_target[] = {\n\t");
2753 for (i
= 0, rel
= relocs
;i
< nb_relocs
; i
++, rel
++) {
2754 sym_idx
= ELF64_R_SYM(rel
->r_info
);
2755 sym_name
= (strtab
+ symtab
[sym_idx
].st_name
);
2756 if (strstart(sym_name
, "__op_gen_label", NULL
))
2758 if (ELF64_R_TYPE(rel
->r_info
) != R_IA64_PCREL21B
)
2761 addend
= rel
->r_addend
;
2762 index
= get_plt_index(sym_name
, addend
);
2763 if (index
<= max_index
)
2768 fprintf(outfile
, ",\n\t");
2771 fprintf(outfile
, "(long) &%s + %ld", sym_name
, addend
);
2773 fprintf(outfile
, "(long) &%s", sym_name
);
2775 fprintf(outfile
, "\n };\n"
2776 " unsigned int plt_offset[%u] = { 0 };\n", max_index
+ 1);
2782 " gen_code_ptr = gen_code_buf;\n"
2783 " opc_ptr = opc_buf;\n"
2784 " opparam_ptr = opparam_buf;\n");
2786 /* Generate prologue, if needed. */
2792 /* Generate constant pool if needed */
2794 " if (gen_code_ptr + arm_opc_size[*opc_ptr] >= arm_pool_ptr) {\n"
2795 " gen_code_ptr = arm_flush_ldr(gen_code_ptr, arm_ldr_table, "
2796 "arm_ldr_ptr, arm_data_ptr, arm_data_table + ARM_LDR_TABLE_SIZE, 1);\n"
2797 " last_gen_code_ptr = gen_code_ptr;\n"
2798 " arm_ldr_ptr = arm_ldr_table;\n"
2799 " arm_data_ptr = arm_data_table + ARM_LDR_TABLE_SIZE;\n"
2800 " arm_pool_ptr = gen_code_ptr + 0x1000000;\n"
2805 " switch(*opc_ptr++) {\n");
2807 for(i
= 0, sym
= symtab
; i
< nb_syms
; i
++, sym
++) {
2809 name
= get_sym_name(sym
);
2810 if (strstart(name
, OP_PREFIX
, NULL
)) {
2812 printf("%4d: %s pos=0x%08x len=%d\n",
2813 i
, name
, sym
->st_value
, sym
->st_size
);
2815 #if defined(CONFIG_FORMAT_ELF) || defined(CONFIG_FORMAT_COFF)
2816 if (sym
->st_shndx
!= text_shndx
)
2817 error("invalid section for opcode (0x%x)", sym
->st_shndx
);
2819 gen_code(name
, sym
->st_value
, sym
->st_size
, outfile
, 1);
2824 " case INDEX_op_nop:\n"
2826 " case INDEX_op_nop1:\n"
2829 " case INDEX_op_nop2:\n"
2830 " opparam_ptr += 2;\n"
2832 " case INDEX_op_nop3:\n"
2833 " opparam_ptr += 3;\n"
2847 " extern char code_gen_buffer[];\n"
2848 " ia64_apply_fixes(&gen_code_ptr, ltoff_fixes, "
2849 "(uint64_t) code_gen_buffer + 2*(1<<20), plt_fixes,\n\t\t\t"
2850 "sizeof(plt_target)/sizeof(plt_target[0]),\n\t\t\t"
2851 "plt_target, plt_offset);\n }\n");
2854 /* generate some code patching */
2857 "if (arm_data_ptr != arm_data_table + ARM_LDR_TABLE_SIZE)\n"
2858 " gen_code_ptr = arm_flush_ldr(gen_code_ptr, arm_ldr_table, "
2859 "arm_ldr_ptr, arm_data_ptr, arm_data_table + ARM_LDR_TABLE_SIZE, 0);\n");
2861 /* flush instruction cache */
2862 fprintf(outfile
, "flush_icache_range((unsigned long)gen_code_buf, (unsigned long)gen_code_ptr);\n");
2864 fprintf(outfile
, "return gen_code_ptr - gen_code_buf;\n");
2865 fprintf(outfile
, "}\n\n");
2874 printf("dyngen (c) 2003 Fabrice Bellard\n"
2875 "usage: dyngen [-o outfile] [-c] objfile\n"
2876 "Generate a dynamic code generator from an object file\n"
2877 "-c output enum of operations\n"
2878 "-g output gen_op_xx() functions\n"
2883 int main(int argc
, char **argv
)
2886 const char *filename
, *outfilename
;
2889 outfilename
= "out.c";
2890 out_type
= OUT_CODE
;
2892 c
= getopt(argc
, argv
, "ho:cg");
2900 outfilename
= optarg
;
2903 out_type
= OUT_INDEX_OP
;
2906 out_type
= OUT_GEN_OP
;
2912 filename
= argv
[optind
];
2913 outfile
= fopen(outfilename
, "w");
2915 error("could not open '%s'", outfilename
);
2917 load_object(filename
);
2918 gen_file(outfile
, out_type
);