bellard | 7d13299 | 2003-03-06 23:23:54 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Generic Dynamic compiler generator |
| 3 | * |
| 4 | * Copyright (c) 2003 Fabrice Bellard |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License as published by |
| 8 | * the Free Software Foundation; either version 2 of the License, or |
| 9 | * (at your option) any later version. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 | * GNU General Public License for more details. |
| 15 | * |
| 16 | * You should have received a copy of the GNU General Public License |
| 17 | * along with this program; if not, write to the Free Software |
| 18 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
| 19 | */ |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 20 | #include <stdlib.h> |
| 21 | #include <stdio.h> |
bellard | 04369ff | 2003-03-20 22:33:23 +0000 | [diff] [blame] | 22 | #include <string.h> |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 23 | #include <stdarg.h> |
| 24 | #include <inttypes.h> |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 25 | #include <unistd.h> |
| 26 | #include <fcntl.h> |
| 27 | |
bellard | abcd5da | 2003-08-10 21:38:48 +0000 | [diff] [blame] | 28 | #include "config-host.h" |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 29 | |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 30 | /* elf format definitions. We use these macros to test the CPU to |
| 31 | allow cross compilation (this tool must be ran on the build |
| 32 | platform) */ |
| 33 | #if defined(HOST_I386) |
| 34 | |
| 35 | #define ELF_CLASS ELFCLASS32 |
| 36 | #define ELF_ARCH EM_386 |
| 37 | #define elf_check_arch(x) ( ((x) == EM_386) || ((x) == EM_486) ) |
| 38 | #undef ELF_USES_RELOCA |
| 39 | |
| 40 | #elif defined(HOST_PPC) |
| 41 | |
| 42 | #define ELF_CLASS ELFCLASS32 |
| 43 | #define ELF_ARCH EM_PPC |
| 44 | #define elf_check_arch(x) ((x) == EM_PPC) |
| 45 | #define ELF_USES_RELOCA |
| 46 | |
| 47 | #elif defined(HOST_S390) |
| 48 | |
| 49 | #define ELF_CLASS ELFCLASS32 |
| 50 | #define ELF_ARCH EM_S390 |
| 51 | #define elf_check_arch(x) ((x) == EM_S390) |
| 52 | #define ELF_USES_RELOCA |
| 53 | |
| 54 | #elif defined(HOST_ALPHA) |
| 55 | |
| 56 | #define ELF_CLASS ELFCLASS64 |
| 57 | #define ELF_ARCH EM_ALPHA |
| 58 | #define elf_check_arch(x) ((x) == EM_ALPHA) |
| 59 | #define ELF_USES_RELOCA |
| 60 | |
bellard | efdea7b | 2003-04-29 21:12:28 +0000 | [diff] [blame] | 61 | #elif defined(HOST_IA64) |
| 62 | |
| 63 | #define ELF_CLASS ELFCLASS64 |
| 64 | #define ELF_ARCH EM_IA_64 |
| 65 | #define elf_check_arch(x) ((x) == EM_IA_64) |
| 66 | #define ELF_USES_RELOCA |
| 67 | |
bellard | d014c98 | 2003-04-29 21:26:53 +0000 | [diff] [blame] | 68 | #elif defined(HOST_SPARC) |
| 69 | |
| 70 | #define ELF_CLASS ELFCLASS32 |
| 71 | #define ELF_ARCH EM_SPARC |
| 72 | #define elf_check_arch(x) ((x) == EM_SPARC || (x) == EM_SPARC32PLUS) |
| 73 | #define ELF_USES_RELOCA |
| 74 | |
| 75 | #elif defined(HOST_SPARC64) |
| 76 | |
| 77 | #define ELF_CLASS ELFCLASS64 |
| 78 | #define ELF_ARCH EM_SPARCV9 |
| 79 | #define elf_check_arch(x) ((x) == EM_SPARCV9) |
| 80 | #define ELF_USES_RELOCA |
| 81 | |
bellard | ff1f20a | 2003-06-09 15:34:19 +0000 | [diff] [blame] | 82 | #elif defined(HOST_ARM) |
| 83 | |
| 84 | #define ELF_CLASS ELFCLASS32 |
| 85 | #define ELF_ARCH EM_ARM |
| 86 | #define elf_check_arch(x) ((x) == EM_ARM) |
| 87 | #define ELF_USES_RELOC |
| 88 | |
bellard | 38e584a | 2003-08-10 22:14:22 +0000 | [diff] [blame] | 89 | #elif defined(HOST_M68K) |
| 90 | |
| 91 | #define ELF_CLASS ELFCLASS32 |
| 92 | #define ELF_ARCH EM_68K |
| 93 | #define elf_check_arch(x) ((x) == EM_68K) |
| 94 | #define ELF_USES_RELOCA |
| 95 | |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 96 | #else |
| 97 | #error unsupported CPU - please update the code |
bellard | fb3e584 | 2003-03-29 17:32:36 +0000 | [diff] [blame] | 98 | #endif |
| 99 | |
bellard | efdea7b | 2003-04-29 21:12:28 +0000 | [diff] [blame] | 100 | #include "elf.h" |
| 101 | |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 102 | #if ELF_CLASS == ELFCLASS32 |
| 103 | typedef int32_t host_long; |
| 104 | typedef uint32_t host_ulong; |
bellard | efdea7b | 2003-04-29 21:12:28 +0000 | [diff] [blame] | 105 | #define swabls(x) swab32s(x) |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 106 | #else |
| 107 | typedef int64_t host_long; |
| 108 | typedef uint64_t host_ulong; |
bellard | efdea7b | 2003-04-29 21:12:28 +0000 | [diff] [blame] | 109 | #define swabls(x) swab64s(x) |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 110 | #endif |
| 111 | |
bellard | fe31975 | 2003-06-05 00:56:05 +0000 | [diff] [blame] | 112 | #ifdef ELF_USES_RELOCA |
| 113 | #define SHT_RELOC SHT_RELA |
| 114 | #else |
| 115 | #define SHT_RELOC SHT_REL |
| 116 | #endif |
| 117 | |
bellard | abcd5da | 2003-08-10 21:38:48 +0000 | [diff] [blame] | 118 | #include "bswap.h" |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 119 | |
bellard | d219f7e | 2003-06-15 19:44:49 +0000 | [diff] [blame] | 120 | enum { |
| 121 | OUT_GEN_OP, |
| 122 | OUT_CODE, |
| 123 | OUT_INDEX_OP, |
| 124 | }; |
| 125 | |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 126 | /* all dynamically generated functions begin with this code */ |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 127 | #define OP_PREFIX "op_" |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 128 | |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 129 | int elf_must_swap(struct elfhdr *h) |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 130 | { |
| 131 | union { |
| 132 | uint32_t i; |
| 133 | uint8_t b[4]; |
| 134 | } swaptest; |
| 135 | |
| 136 | swaptest.i = 1; |
| 137 | return (h->e_ident[EI_DATA] == ELFDATA2MSB) != |
| 138 | (swaptest.b[0] == 0); |
| 139 | } |
| 140 | |
| 141 | void swab16s(uint16_t *p) |
| 142 | { |
| 143 | *p = bswap16(*p); |
| 144 | } |
| 145 | |
| 146 | void swab32s(uint32_t *p) |
| 147 | { |
| 148 | *p = bswap32(*p); |
| 149 | } |
| 150 | |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 151 | void swab64s(uint64_t *p) |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 152 | { |
| 153 | *p = bswap64(*p); |
| 154 | } |
| 155 | |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 156 | void elf_swap_ehdr(struct elfhdr *h) |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 157 | { |
| 158 | swab16s(&h->e_type); /* Object file type */ |
| 159 | swab16s(&h-> e_machine); /* Architecture */ |
| 160 | swab32s(&h-> e_version); /* Object file version */ |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 161 | swabls(&h-> e_entry); /* Entry point virtual address */ |
| 162 | swabls(&h-> e_phoff); /* Program header table file offset */ |
| 163 | swabls(&h-> e_shoff); /* Section header table file offset */ |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 164 | swab32s(&h-> e_flags); /* Processor-specific flags */ |
| 165 | swab16s(&h-> e_ehsize); /* ELF header size in bytes */ |
| 166 | swab16s(&h-> e_phentsize); /* Program header table entry size */ |
| 167 | swab16s(&h-> e_phnum); /* Program header table entry count */ |
| 168 | swab16s(&h-> e_shentsize); /* Section header table entry size */ |
| 169 | swab16s(&h-> e_shnum); /* Section header table entry count */ |
| 170 | swab16s(&h-> e_shstrndx); /* Section header string table index */ |
| 171 | } |
| 172 | |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 173 | void elf_swap_shdr(struct elf_shdr *h) |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 174 | { |
| 175 | swab32s(&h-> sh_name); /* Section name (string tbl index) */ |
| 176 | swab32s(&h-> sh_type); /* Section type */ |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 177 | swabls(&h-> sh_flags); /* Section flags */ |
| 178 | swabls(&h-> sh_addr); /* Section virtual addr at execution */ |
| 179 | swabls(&h-> sh_offset); /* Section file offset */ |
| 180 | swabls(&h-> sh_size); /* Section size in bytes */ |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 181 | swab32s(&h-> sh_link); /* Link to another section */ |
| 182 | swab32s(&h-> sh_info); /* Additional section information */ |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 183 | swabls(&h-> sh_addralign); /* Section alignment */ |
| 184 | swabls(&h-> sh_entsize); /* Entry size if section holds table */ |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 185 | } |
| 186 | |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 187 | void elf_swap_phdr(struct elf_phdr *h) |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 188 | { |
| 189 | swab32s(&h->p_type); /* Segment type */ |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 190 | swabls(&h->p_offset); /* Segment file offset */ |
| 191 | swabls(&h->p_vaddr); /* Segment virtual address */ |
| 192 | swabls(&h->p_paddr); /* Segment physical address */ |
| 193 | swabls(&h->p_filesz); /* Segment size in file */ |
| 194 | swabls(&h->p_memsz); /* Segment size in memory */ |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 195 | swab32s(&h->p_flags); /* Segment flags */ |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 196 | swabls(&h->p_align); /* Segment alignment */ |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 197 | } |
| 198 | |
bellard | fe31975 | 2003-06-05 00:56:05 +0000 | [diff] [blame] | 199 | void elf_swap_rel(ELF_RELOC *rel) |
| 200 | { |
| 201 | swabls(&rel->r_offset); |
| 202 | swabls(&rel->r_info); |
| 203 | #ifdef ELF_USES_RELOCA |
| 204 | swabls(&rel->r_addend); |
| 205 | #endif |
| 206 | } |
| 207 | |
bellard | d4e8164 | 2003-05-25 16:46:15 +0000 | [diff] [blame] | 208 | /* ELF file info */ |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 209 | int do_swap; |
bellard | d4e8164 | 2003-05-25 16:46:15 +0000 | [diff] [blame] | 210 | struct elf_shdr *shdr; |
bellard | fe31975 | 2003-06-05 00:56:05 +0000 | [diff] [blame] | 211 | uint8_t **sdata; |
bellard | d4e8164 | 2003-05-25 16:46:15 +0000 | [diff] [blame] | 212 | struct elfhdr ehdr; |
| 213 | ElfW(Sym) *symtab; |
| 214 | int nb_syms; |
| 215 | char *strtab; |
bellard | fe31975 | 2003-06-05 00:56:05 +0000 | [diff] [blame] | 216 | int text_shndx; |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 217 | |
| 218 | uint16_t get16(uint16_t *p) |
| 219 | { |
| 220 | uint16_t val; |
| 221 | val = *p; |
| 222 | if (do_swap) |
| 223 | val = bswap16(val); |
| 224 | return val; |
| 225 | } |
| 226 | |
| 227 | uint32_t get32(uint32_t *p) |
| 228 | { |
| 229 | uint32_t val; |
| 230 | val = *p; |
| 231 | if (do_swap) |
| 232 | val = bswap32(val); |
| 233 | return val; |
| 234 | } |
| 235 | |
| 236 | void put16(uint16_t *p, uint16_t val) |
| 237 | { |
| 238 | if (do_swap) |
| 239 | val = bswap16(val); |
| 240 | *p = val; |
| 241 | } |
| 242 | |
| 243 | void put32(uint32_t *p, uint32_t val) |
| 244 | { |
| 245 | if (do_swap) |
| 246 | val = bswap32(val); |
| 247 | *p = val; |
| 248 | } |
| 249 | |
bellard | efdea7b | 2003-04-29 21:12:28 +0000 | [diff] [blame] | 250 | void __attribute__((noreturn)) __attribute__((format (printf, 1, 2))) error(const char *fmt, ...) |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 251 | { |
| 252 | va_list ap; |
| 253 | va_start(ap, fmt); |
| 254 | fprintf(stderr, "dyngen: "); |
| 255 | vfprintf(stderr, fmt, ap); |
| 256 | fprintf(stderr, "\n"); |
| 257 | va_end(ap); |
| 258 | exit(1); |
| 259 | } |
| 260 | |
| 261 | |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 262 | struct elf_shdr *find_elf_section(struct elf_shdr *shdr, int shnum, const char *shstr, |
| 263 | const char *name) |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 264 | { |
| 265 | int i; |
| 266 | const char *shname; |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 267 | struct elf_shdr *sec; |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 268 | |
| 269 | for(i = 0; i < shnum; i++) { |
| 270 | sec = &shdr[i]; |
| 271 | if (!sec->sh_name) |
| 272 | continue; |
| 273 | shname = shstr + sec->sh_name; |
| 274 | if (!strcmp(shname, name)) |
| 275 | return sec; |
| 276 | } |
| 277 | return NULL; |
| 278 | } |
| 279 | |
bellard | fe31975 | 2003-06-05 00:56:05 +0000 | [diff] [blame] | 280 | int find_reloc(int sh_index) |
| 281 | { |
| 282 | struct elf_shdr *sec; |
| 283 | int i; |
| 284 | |
| 285 | for(i = 0; i < ehdr.e_shnum; i++) { |
| 286 | sec = &shdr[i]; |
| 287 | if (sec->sh_type == SHT_RELOC && sec->sh_info == sh_index) |
| 288 | return i; |
| 289 | } |
| 290 | return 0; |
| 291 | } |
| 292 | |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 293 | void *load_data(int fd, long offset, unsigned int size) |
| 294 | { |
| 295 | char *data; |
| 296 | |
| 297 | data = malloc(size); |
| 298 | if (!data) |
| 299 | return NULL; |
| 300 | lseek(fd, offset, SEEK_SET); |
| 301 | if (read(fd, data, size) != size) { |
| 302 | free(data); |
| 303 | return NULL; |
| 304 | } |
| 305 | return data; |
| 306 | } |
| 307 | |
| 308 | int strstart(const char *str, const char *val, const char **ptr) |
| 309 | { |
| 310 | const char *p, *q; |
| 311 | p = str; |
| 312 | q = val; |
| 313 | while (*q != '\0') { |
| 314 | if (*p != *q) |
| 315 | return 0; |
| 316 | p++; |
| 317 | q++; |
| 318 | } |
| 319 | if (ptr) |
| 320 | *ptr = p; |
| 321 | return 1; |
| 322 | } |
| 323 | |
bellard | ff1f20a | 2003-06-09 15:34:19 +0000 | [diff] [blame] | 324 | #ifdef HOST_ARM |
| 325 | |
| 326 | int arm_emit_ldr_info(const char *name, unsigned long start_offset, |
| 327 | FILE *outfile, uint8_t *p_start, uint8_t *p_end, |
| 328 | ELF_RELOC *relocs, int nb_relocs) |
| 329 | { |
| 330 | uint8_t *p; |
| 331 | uint32_t insn; |
| 332 | int offset, min_offset, pc_offset, data_size; |
| 333 | uint8_t data_allocated[1024]; |
| 334 | unsigned int data_index; |
| 335 | |
| 336 | memset(data_allocated, 0, sizeof(data_allocated)); |
| 337 | |
| 338 | p = p_start; |
| 339 | min_offset = p_end - p_start; |
| 340 | while (p < p_start + min_offset) { |
| 341 | insn = get32((uint32_t *)p); |
| 342 | if ((insn & 0x0d5f0000) == 0x051f0000) { |
| 343 | /* ldr reg, [pc, #im] */ |
| 344 | offset = insn & 0xfff; |
| 345 | if (!(insn & 0x00800000)) |
| 346 | offset = -offset; |
| 347 | if ((offset & 3) !=0) |
| 348 | error("%s:%04x: ldr pc offset must be 32 bit aligned", |
| 349 | name, start_offset + p - p_start); |
| 350 | pc_offset = p - p_start + offset + 8; |
| 351 | if (pc_offset <= (p - p_start) || |
| 352 | pc_offset >= (p_end - p_start)) |
| 353 | error("%s:%04x: ldr pc offset must point inside the function code", |
| 354 | name, start_offset + p - p_start); |
| 355 | if (pc_offset < min_offset) |
| 356 | min_offset = pc_offset; |
| 357 | if (outfile) { |
| 358 | /* ldr position */ |
| 359 | fprintf(outfile, " arm_ldr_ptr->ptr = gen_code_ptr + %d;\n", |
| 360 | p - p_start); |
| 361 | /* ldr data index */ |
| 362 | data_index = ((p_end - p_start) - pc_offset - 4) >> 2; |
| 363 | fprintf(outfile, " arm_ldr_ptr->data_ptr = arm_data_ptr + %d;\n", |
| 364 | data_index); |
| 365 | fprintf(outfile, " arm_ldr_ptr++;\n"); |
| 366 | if (data_index >= sizeof(data_allocated)) |
| 367 | error("%s: too many data", name); |
| 368 | if (!data_allocated[data_index]) { |
| 369 | ELF_RELOC *rel; |
| 370 | int i, addend, type; |
| 371 | const char *sym_name, *p; |
| 372 | char relname[1024]; |
| 373 | |
| 374 | data_allocated[data_index] = 1; |
| 375 | |
| 376 | /* data value */ |
| 377 | addend = get32((uint32_t *)(p_start + pc_offset)); |
| 378 | relname[0] = '\0'; |
| 379 | for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) { |
| 380 | if (rel->r_offset == (pc_offset + start_offset)) { |
| 381 | sym_name = strtab + symtab[ELFW(R_SYM)(rel->r_info)].st_name; |
| 382 | /* the compiler leave some unnecessary references to the code */ |
| 383 | if (strstart(sym_name, "__op_param", &p)) { |
| 384 | snprintf(relname, sizeof(relname), "param%s", p); |
| 385 | } else { |
| 386 | snprintf(relname, sizeof(relname), "(long)(&%s)", sym_name); |
| 387 | } |
| 388 | type = ELF32_R_TYPE(rel->r_info); |
| 389 | if (type != R_ARM_ABS32) |
| 390 | error("%s: unsupported data relocation", name); |
| 391 | break; |
| 392 | } |
| 393 | } |
| 394 | fprintf(outfile, " arm_data_ptr[%d] = 0x%x", |
| 395 | data_index, addend); |
| 396 | if (relname[0] != '\0') |
| 397 | fprintf(outfile, " + %s", relname); |
| 398 | fprintf(outfile, ";\n"); |
| 399 | } |
| 400 | } |
| 401 | } |
| 402 | p += 4; |
| 403 | } |
| 404 | data_size = (p_end - p_start) - min_offset; |
| 405 | if (data_size > 0 && outfile) { |
| 406 | fprintf(outfile, " arm_data_ptr += %d;\n", data_size >> 2); |
| 407 | } |
| 408 | |
| 409 | /* the last instruction must be a mov pc, lr */ |
| 410 | if (p == p_start) |
| 411 | goto arm_ret_error; |
| 412 | p -= 4; |
| 413 | insn = get32((uint32_t *)p); |
| 414 | if ((insn & 0xffff0000) != 0xe91b0000) { |
| 415 | arm_ret_error: |
| 416 | if (!outfile) |
| 417 | printf("%s: invalid epilog\n", name); |
| 418 | } |
| 419 | return p - p_start; |
| 420 | } |
| 421 | #endif |
| 422 | |
| 423 | |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 424 | #define MAX_ARGS 3 |
| 425 | |
| 426 | /* generate op code */ |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 427 | void gen_code(const char *name, host_ulong offset, host_ulong size, |
bellard | fe31975 | 2003-06-05 00:56:05 +0000 | [diff] [blame] | 428 | FILE *outfile, uint8_t *text, ELF_RELOC *relocs, int nb_relocs, |
bellard | d4e8164 | 2003-05-25 16:46:15 +0000 | [diff] [blame] | 429 | int gen_switch) |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 430 | { |
| 431 | int copy_size = 0; |
| 432 | uint8_t *p_start, *p_end; |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 433 | host_ulong start_offset; |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 434 | int nb_args, i, n; |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 435 | uint8_t args_present[MAX_ARGS]; |
| 436 | const char *sym_name, *p; |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 437 | ELF_RELOC *rel; |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 438 | |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 439 | /* Compute exact size excluding prologue and epilogue instructions. |
| 440 | * Increment start_offset to skip epilogue instructions, then compute |
| 441 | * copy_size the indicate the size of the remaining instructions (in |
| 442 | * bytes). |
| 443 | */ |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 444 | p_start = text + offset; |
| 445 | p_end = p_start + size; |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 446 | start_offset = offset; |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 447 | switch(ELF_ARCH) { |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 448 | case EM_386: |
| 449 | { |
bellard | d4e8164 | 2003-05-25 16:46:15 +0000 | [diff] [blame] | 450 | int len; |
| 451 | len = p_end - p_start; |
| 452 | if (len == 0) |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 453 | error("empty code for %s", name); |
bellard | d4e8164 | 2003-05-25 16:46:15 +0000 | [diff] [blame] | 454 | if (p_end[-1] == 0xc3) { |
| 455 | len--; |
| 456 | } else { |
| 457 | error("ret or jmp expected at the end of %s", name); |
| 458 | } |
| 459 | copy_size = len; |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 460 | } |
| 461 | break; |
| 462 | case EM_PPC: |
| 463 | { |
| 464 | uint8_t *p; |
| 465 | p = (void *)(p_end - 4); |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 466 | if (p == p_start) |
| 467 | error("empty code for %s", name); |
bellard | 04369ff | 2003-03-20 22:33:23 +0000 | [diff] [blame] | 468 | if (get32((uint32_t *)p) != 0x4e800020) |
| 469 | error("blr expected at the end of %s", name); |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 470 | copy_size = p - p_start; |
| 471 | } |
| 472 | break; |
bellard | fb3e584 | 2003-03-29 17:32:36 +0000 | [diff] [blame] | 473 | case EM_S390: |
| 474 | { |
| 475 | uint8_t *p; |
| 476 | p = (void *)(p_end - 2); |
| 477 | if (p == p_start) |
| 478 | error("empty code for %s", name); |
| 479 | if (get16((uint16_t *)p) != 0x07fe && get16((uint16_t *)p) != 0x07f4) |
bellard | efdea7b | 2003-04-29 21:12:28 +0000 | [diff] [blame] | 480 | error("br %%r14 expected at the end of %s", name); |
bellard | fb3e584 | 2003-03-29 17:32:36 +0000 | [diff] [blame] | 481 | copy_size = p - p_start; |
| 482 | } |
| 483 | break; |
bellard | efdea7b | 2003-04-29 21:12:28 +0000 | [diff] [blame] | 484 | case EM_ALPHA: |
| 485 | { |
| 486 | uint8_t *p; |
| 487 | p = p_end - 4; |
| 488 | if (p == p_start) |
| 489 | error("empty code for %s", name); |
| 490 | if (get32((uint32_t *)p) != 0x6bfa8001) |
| 491 | error("ret expected at the end of %s", name); |
| 492 | copy_size = p - p_start; |
| 493 | } |
| 494 | break; |
| 495 | case EM_IA_64: |
| 496 | { |
| 497 | uint8_t *p; |
| 498 | p = (void *)(p_end - 4); |
| 499 | if (p == p_start) |
| 500 | error("empty code for %s", name); |
| 501 | /* br.ret.sptk.many b0;; */ |
| 502 | /* 08 00 84 00 */ |
| 503 | if (get32((uint32_t *)p) != 0x00840008) |
| 504 | error("br.ret.sptk.many b0;; expected at the end of %s", name); |
| 505 | copy_size = p - p_start; |
| 506 | } |
| 507 | break; |
bellard | d014c98 | 2003-04-29 21:26:53 +0000 | [diff] [blame] | 508 | case EM_SPARC: |
| 509 | case EM_SPARC32PLUS: |
| 510 | { |
bellard | ff1f20a | 2003-06-09 15:34:19 +0000 | [diff] [blame] | 511 | uint32_t start_insn, end_insn1, end_insn2; |
bellard | d014c98 | 2003-04-29 21:26:53 +0000 | [diff] [blame] | 512 | uint8_t *p; |
| 513 | p = (void *)(p_end - 8); |
| 514 | if (p <= p_start) |
| 515 | error("empty code for %s", name); |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 516 | start_insn = get32((uint32_t *)(p_start + 0x0)); |
| 517 | end_insn1 = get32((uint32_t *)(p + 0x0)); |
| 518 | end_insn2 = get32((uint32_t *)(p + 0x4)); |
| 519 | if ((start_insn & ~0x1fff) == 0x9de3a000) { |
| 520 | p_start += 0x4; |
| 521 | start_offset += 0x4; |
| 522 | if ((int)(start_insn | ~0x1fff) < -128) |
| 523 | error("Found bogus save at the start of %s", name); |
| 524 | if (end_insn1 != 0x81c7e008 || end_insn2 != 0x81e80000) |
| 525 | error("ret; restore; not found at end of %s", name); |
| 526 | } else { |
| 527 | error("No save at the beginning of %s", name); |
| 528 | } |
bellard | ff1f20a | 2003-06-09 15:34:19 +0000 | [diff] [blame] | 529 | #if 0 |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 530 | /* Skip a preceeding nop, if present. */ |
| 531 | if (p > p_start) { |
| 532 | skip_insn = get32((uint32_t *)(p - 0x4)); |
| 533 | if (skip_insn == 0x01000000) |
| 534 | p -= 4; |
| 535 | } |
bellard | ff1f20a | 2003-06-09 15:34:19 +0000 | [diff] [blame] | 536 | #endif |
bellard | d014c98 | 2003-04-29 21:26:53 +0000 | [diff] [blame] | 537 | copy_size = p - p_start; |
| 538 | } |
| 539 | break; |
| 540 | case EM_SPARCV9: |
| 541 | { |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 542 | uint32_t start_insn, end_insn1, end_insn2, skip_insn; |
bellard | d014c98 | 2003-04-29 21:26:53 +0000 | [diff] [blame] | 543 | uint8_t *p; |
| 544 | p = (void *)(p_end - 8); |
| 545 | if (p <= p_start) |
| 546 | error("empty code for %s", name); |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 547 | start_insn = get32((uint32_t *)(p_start + 0x0)); |
| 548 | end_insn1 = get32((uint32_t *)(p + 0x0)); |
| 549 | end_insn2 = get32((uint32_t *)(p + 0x4)); |
| 550 | if ((start_insn & ~0x1fff) == 0x9de3a000) { |
| 551 | p_start += 0x4; |
| 552 | start_offset += 0x4; |
| 553 | if ((int)(start_insn | ~0x1fff) < -256) |
| 554 | error("Found bogus save at the start of %s", name); |
| 555 | if (end_insn1 != 0x81c7e008 || end_insn2 != 0x81e80000) |
| 556 | error("ret; restore; not found at end of %s", name); |
| 557 | } else { |
| 558 | error("No save at the beginning of %s", name); |
| 559 | } |
| 560 | |
| 561 | /* Skip a preceeding nop, if present. */ |
| 562 | if (p > p_start) { |
| 563 | skip_insn = get32((uint32_t *)(p - 0x4)); |
| 564 | if (skip_insn == 0x01000000) |
| 565 | p -= 4; |
| 566 | } |
| 567 | |
bellard | d014c98 | 2003-04-29 21:26:53 +0000 | [diff] [blame] | 568 | copy_size = p - p_start; |
| 569 | } |
| 570 | break; |
bellard | ff1f20a | 2003-06-09 15:34:19 +0000 | [diff] [blame] | 571 | #ifdef HOST_ARM |
| 572 | case EM_ARM: |
| 573 | if ((p_end - p_start) <= 16) |
| 574 | error("%s: function too small", name); |
| 575 | if (get32((uint32_t *)p_start) != 0xe1a0c00d || |
| 576 | (get32((uint32_t *)(p_start + 4)) & 0xffff0000) != 0xe92d0000 || |
| 577 | get32((uint32_t *)(p_start + 8)) != 0xe24cb004) |
| 578 | error("%s: invalid prolog", name); |
| 579 | p_start += 12; |
| 580 | start_offset += 12; |
| 581 | copy_size = arm_emit_ldr_info(name, start_offset, NULL, p_start, p_end, |
| 582 | relocs, nb_relocs); |
| 583 | break; |
| 584 | #endif |
bellard | 38e584a | 2003-08-10 22:14:22 +0000 | [diff] [blame] | 585 | case EM_68K: |
| 586 | { |
| 587 | uint8_t *p; |
| 588 | p = (void *)(p_end - 2); |
| 589 | if (p == p_start) |
| 590 | error("empty code for %s", name); |
| 591 | // remove NOP's, probably added for alignment |
| 592 | while ((get16((uint16_t *)p) == 0x4e71) && |
| 593 | (p>p_start)) |
| 594 | p -= 2; |
| 595 | if (get16((uint16_t *)p) != 0x4e75) |
| 596 | error("rts expected at the end of %s", name); |
| 597 | copy_size = p - p_start; |
| 598 | } |
| 599 | break; |
bellard | efdea7b | 2003-04-29 21:12:28 +0000 | [diff] [blame] | 600 | default: |
| 601 | error("unknown ELF architecture"); |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 602 | } |
| 603 | |
| 604 | /* compute the number of arguments by looking at the relocations */ |
| 605 | for(i = 0;i < MAX_ARGS; i++) |
| 606 | args_present[i] = 0; |
| 607 | |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 608 | for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) { |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 609 | if (rel->r_offset >= start_offset && |
bellard | ff1f20a | 2003-06-09 15:34:19 +0000 | [diff] [blame] | 610 | rel->r_offset < start_offset + (p_end - p_start)) { |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 611 | sym_name = strtab + symtab[ELFW(R_SYM)(rel->r_info)].st_name; |
| 612 | if (strstart(sym_name, "__op_param", &p)) { |
| 613 | n = strtoul(p, NULL, 10); |
bellard | d4e8164 | 2003-05-25 16:46:15 +0000 | [diff] [blame] | 614 | if (n > MAX_ARGS) |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 615 | error("too many arguments in %s", name); |
| 616 | args_present[n - 1] = 1; |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 617 | } |
| 618 | } |
| 619 | } |
| 620 | |
| 621 | nb_args = 0; |
| 622 | while (nb_args < MAX_ARGS && args_present[nb_args]) |
| 623 | nb_args++; |
| 624 | for(i = nb_args; i < MAX_ARGS; i++) { |
| 625 | if (args_present[i]) |
| 626 | error("inconsistent argument numbering in %s", name); |
| 627 | } |
| 628 | |
bellard | 0ea00c9 | 2003-03-29 16:47:34 +0000 | [diff] [blame] | 629 | if (gen_switch == 2) { |
bellard | a513fe1 | 2003-05-27 23:29:48 +0000 | [diff] [blame] | 630 | fprintf(outfile, "DEF(%s, %d, %d)\n", name + 3, nb_args, copy_size); |
bellard | 0ea00c9 | 2003-03-29 16:47:34 +0000 | [diff] [blame] | 631 | } else if (gen_switch == 1) { |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 632 | |
| 633 | /* output C code */ |
| 634 | fprintf(outfile, "case INDEX_%s: {\n", name); |
| 635 | if (nb_args > 0) { |
| 636 | fprintf(outfile, " long "); |
| 637 | for(i = 0; i < nb_args; i++) { |
| 638 | if (i != 0) |
| 639 | fprintf(outfile, ", "); |
| 640 | fprintf(outfile, "param%d", i + 1); |
| 641 | } |
| 642 | fprintf(outfile, ";\n"); |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 643 | } |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 644 | fprintf(outfile, " extern void %s();\n", name); |
| 645 | |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 646 | for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) { |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 647 | if (rel->r_offset >= start_offset && |
bellard | ff1f20a | 2003-06-09 15:34:19 +0000 | [diff] [blame] | 648 | rel->r_offset < start_offset + (p_end - p_start)) { |
bellard | efdea7b | 2003-04-29 21:12:28 +0000 | [diff] [blame] | 649 | sym_name = strtab + symtab[ELFW(R_SYM)(rel->r_info)].st_name; |
bellard | d4e8164 | 2003-05-25 16:46:15 +0000 | [diff] [blame] | 650 | if (*sym_name && |
| 651 | !strstart(sym_name, "__op_param", NULL) && |
| 652 | !strstart(sym_name, "__op_jmp", NULL)) { |
bellard | d014c98 | 2003-04-29 21:26:53 +0000 | [diff] [blame] | 653 | #if defined(HOST_SPARC) |
| 654 | if (sym_name[0] == '.') { |
| 655 | fprintf(outfile, |
| 656 | "extern char __dot_%s __asm__(\"%s\");\n", |
| 657 | sym_name+1, sym_name); |
| 658 | continue; |
| 659 | } |
| 660 | #endif |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 661 | fprintf(outfile, "extern char %s;\n", sym_name); |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 662 | } |
| 663 | } |
| 664 | } |
| 665 | |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 666 | fprintf(outfile, " memcpy(gen_code_ptr, (void *)((char *)&%s+%d), %d);\n", name, start_offset - offset, copy_size); |
bellard | d4e8164 | 2003-05-25 16:46:15 +0000 | [diff] [blame] | 667 | |
| 668 | /* emit code offset information */ |
| 669 | { |
| 670 | ElfW(Sym) *sym; |
| 671 | const char *sym_name, *p; |
bellard | abcd5da | 2003-08-10 21:38:48 +0000 | [diff] [blame] | 672 | unsigned long val; |
bellard | d4e8164 | 2003-05-25 16:46:15 +0000 | [diff] [blame] | 673 | int n; |
| 674 | |
| 675 | for(i = 0, sym = symtab; i < nb_syms; i++, sym++) { |
| 676 | sym_name = strtab + sym->st_name; |
| 677 | if (strstart(sym_name, "__op_label", &p)) { |
bellard | c1e42a1 | 2003-05-29 20:05:18 +0000 | [diff] [blame] | 678 | uint8_t *ptr; |
bellard | fe31975 | 2003-06-05 00:56:05 +0000 | [diff] [blame] | 679 | unsigned long offset; |
| 680 | |
bellard | d4e8164 | 2003-05-25 16:46:15 +0000 | [diff] [blame] | 681 | /* test if the variable refers to a label inside |
| 682 | the code we are generating */ |
bellard | fe31975 | 2003-06-05 00:56:05 +0000 | [diff] [blame] | 683 | ptr = sdata[sym->st_shndx]; |
| 684 | if (!ptr) |
| 685 | error("__op_labelN in invalid section"); |
| 686 | offset = sym->st_value; |
bellard | abcd5da | 2003-08-10 21:38:48 +0000 | [diff] [blame] | 687 | val = *(unsigned long *)(ptr + offset); |
bellard | fe31975 | 2003-06-05 00:56:05 +0000 | [diff] [blame] | 688 | #ifdef ELF_USES_RELOCA |
| 689 | { |
| 690 | int reloc_shndx, nb_relocs1, j; |
| 691 | |
| 692 | /* try to find a matching relocation */ |
| 693 | reloc_shndx = find_reloc(sym->st_shndx); |
| 694 | if (reloc_shndx) { |
| 695 | nb_relocs1 = shdr[reloc_shndx].sh_size / |
| 696 | shdr[reloc_shndx].sh_entsize; |
| 697 | rel = (ELF_RELOC *)sdata[reloc_shndx]; |
| 698 | for(j = 0; j < nb_relocs1; j++) { |
| 699 | if (rel->r_offset == offset) { |
bellard | 039de85 | 2003-06-15 22:50:44 +0000 | [diff] [blame] | 700 | val = rel->r_addend; |
bellard | fe31975 | 2003-06-05 00:56:05 +0000 | [diff] [blame] | 701 | break; |
| 702 | } |
| 703 | rel++; |
| 704 | } |
| 705 | } |
| 706 | } |
| 707 | #endif |
bellard | fe31975 | 2003-06-05 00:56:05 +0000 | [diff] [blame] | 708 | |
bellard | d4e8164 | 2003-05-25 16:46:15 +0000 | [diff] [blame] | 709 | if (val >= start_offset && val < start_offset + copy_size) { |
| 710 | n = strtol(p, NULL, 10); |
bellard | abcd5da | 2003-08-10 21:38:48 +0000 | [diff] [blame] | 711 | fprintf(outfile, " label_offsets[%d] = %ld + (gen_code_ptr - gen_code_buf);\n", n, val - start_offset); |
bellard | d4e8164 | 2003-05-25 16:46:15 +0000 | [diff] [blame] | 712 | } |
| 713 | } |
| 714 | } |
| 715 | } |
| 716 | |
| 717 | /* load parameres in variables */ |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 718 | for(i = 0; i < nb_args; i++) { |
| 719 | fprintf(outfile, " param%d = *opparam_ptr++;\n", i + 1); |
| 720 | } |
| 721 | |
| 722 | /* patch relocations */ |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 723 | #if defined(HOST_I386) |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 724 | { |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 725 | char name[256]; |
| 726 | int type; |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 727 | int addend; |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 728 | for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) { |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 729 | if (rel->r_offset >= start_offset && |
| 730 | rel->r_offset < start_offset + copy_size) { |
bellard | efdea7b | 2003-04-29 21:12:28 +0000 | [diff] [blame] | 731 | sym_name = strtab + symtab[ELFW(R_SYM)(rel->r_info)].st_name; |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 732 | if (strstart(sym_name, "__op_param", &p)) { |
| 733 | snprintf(name, sizeof(name), "param%s", p); |
| 734 | } else { |
| 735 | snprintf(name, sizeof(name), "(long)(&%s)", sym_name); |
| 736 | } |
| 737 | type = ELF32_R_TYPE(rel->r_info); |
| 738 | addend = get32((uint32_t *)(text + rel->r_offset)); |
| 739 | switch(type) { |
| 740 | case R_386_32: |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 741 | fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 742 | rel->r_offset - start_offset, name, addend); |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 743 | break; |
| 744 | case R_386_PC32: |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 745 | fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %d) + %d;\n", |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 746 | rel->r_offset - start_offset, name, rel->r_offset - start_offset, addend); |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 747 | break; |
| 748 | default: |
| 749 | error("unsupported i386 relocation (%d)", type); |
| 750 | } |
| 751 | } |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 752 | } |
| 753 | } |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 754 | #elif defined(HOST_PPC) |
bellard | 04369ff | 2003-03-20 22:33:23 +0000 | [diff] [blame] | 755 | { |
bellard | 04369ff | 2003-03-20 22:33:23 +0000 | [diff] [blame] | 756 | char name[256]; |
| 757 | int type; |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 758 | int addend; |
bellard | 04369ff | 2003-03-20 22:33:23 +0000 | [diff] [blame] | 759 | for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) { |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 760 | if (rel->r_offset >= start_offset && |
| 761 | rel->r_offset < start_offset + copy_size) { |
bellard | efdea7b | 2003-04-29 21:12:28 +0000 | [diff] [blame] | 762 | sym_name = strtab + symtab[ELFW(R_SYM)(rel->r_info)].st_name; |
bellard | d4e8164 | 2003-05-25 16:46:15 +0000 | [diff] [blame] | 763 | if (strstart(sym_name, "__op_jmp", &p)) { |
| 764 | int n; |
| 765 | n = strtol(p, NULL, 10); |
| 766 | /* __op_jmp relocations are done at |
| 767 | runtime to do translated block |
| 768 | chaining: the offset of the instruction |
| 769 | needs to be stored */ |
| 770 | fprintf(outfile, " jmp_offsets[%d] = %d + (gen_code_ptr - gen_code_buf);\n", |
| 771 | n, rel->r_offset - start_offset); |
| 772 | continue; |
| 773 | } |
| 774 | |
bellard | 04369ff | 2003-03-20 22:33:23 +0000 | [diff] [blame] | 775 | if (strstart(sym_name, "__op_param", &p)) { |
| 776 | snprintf(name, sizeof(name), "param%s", p); |
| 777 | } else { |
| 778 | snprintf(name, sizeof(name), "(long)(&%s)", sym_name); |
| 779 | } |
| 780 | type = ELF32_R_TYPE(rel->r_info); |
| 781 | addend = rel->r_addend; |
| 782 | switch(type) { |
| 783 | case R_PPC_ADDR32: |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 784 | fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 785 | rel->r_offset - start_offset, name, addend); |
bellard | 04369ff | 2003-03-20 22:33:23 +0000 | [diff] [blame] | 786 | break; |
| 787 | case R_PPC_ADDR16_LO: |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 788 | fprintf(outfile, " *(uint16_t *)(gen_code_ptr + %d) = (%s + %d);\n", |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 789 | rel->r_offset - start_offset, name, addend); |
bellard | 04369ff | 2003-03-20 22:33:23 +0000 | [diff] [blame] | 790 | break; |
| 791 | case R_PPC_ADDR16_HI: |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 792 | fprintf(outfile, " *(uint16_t *)(gen_code_ptr + %d) = (%s + %d) >> 16;\n", |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 793 | rel->r_offset - start_offset, name, addend); |
bellard | 04369ff | 2003-03-20 22:33:23 +0000 | [diff] [blame] | 794 | break; |
| 795 | case R_PPC_ADDR16_HA: |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 796 | fprintf(outfile, " *(uint16_t *)(gen_code_ptr + %d) = (%s + %d + 0x8000) >> 16;\n", |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 797 | rel->r_offset - start_offset, name, addend); |
bellard | 04369ff | 2003-03-20 22:33:23 +0000 | [diff] [blame] | 798 | break; |
| 799 | case R_PPC_REL24: |
| 800 | /* warning: must be at 32 MB distancy */ |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 801 | fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = (*(uint32_t *)(gen_code_ptr + %d) & ~0x03fffffc) | ((%s - (long)(gen_code_ptr + %d) + %d) & 0x03fffffc);\n", |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 802 | rel->r_offset - start_offset, rel->r_offset - start_offset, name, rel->r_offset - start_offset, addend); |
bellard | 04369ff | 2003-03-20 22:33:23 +0000 | [diff] [blame] | 803 | break; |
| 804 | default: |
| 805 | error("unsupported powerpc relocation (%d)", type); |
| 806 | } |
| 807 | } |
| 808 | } |
| 809 | } |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 810 | #elif defined(HOST_S390) |
bellard | fb3e584 | 2003-03-29 17:32:36 +0000 | [diff] [blame] | 811 | { |
bellard | fb3e584 | 2003-03-29 17:32:36 +0000 | [diff] [blame] | 812 | char name[256]; |
| 813 | int type; |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 814 | int addend; |
bellard | fb3e584 | 2003-03-29 17:32:36 +0000 | [diff] [blame] | 815 | for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) { |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 816 | if (rel->r_offset >= start_offset && |
| 817 | rel->r_offset < start_offset + copy_size) { |
bellard | efdea7b | 2003-04-29 21:12:28 +0000 | [diff] [blame] | 818 | sym_name = strtab + symtab[ELFW(R_SYM)(rel->r_info)].st_name; |
bellard | fb3e584 | 2003-03-29 17:32:36 +0000 | [diff] [blame] | 819 | if (strstart(sym_name, "__op_param", &p)) { |
| 820 | snprintf(name, sizeof(name), "param%s", p); |
| 821 | } else { |
| 822 | snprintf(name, sizeof(name), "(long)(&%s)", sym_name); |
| 823 | } |
| 824 | type = ELF32_R_TYPE(rel->r_info); |
| 825 | addend = rel->r_addend; |
| 826 | switch(type) { |
| 827 | case R_390_32: |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 828 | fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 829 | rel->r_offset - start_offset, name, addend); |
bellard | fb3e584 | 2003-03-29 17:32:36 +0000 | [diff] [blame] | 830 | break; |
| 831 | case R_390_16: |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 832 | fprintf(outfile, " *(uint16_t *)(gen_code_ptr + %d) = %s + %d;\n", |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 833 | rel->r_offset - start_offset, name, addend); |
bellard | fb3e584 | 2003-03-29 17:32:36 +0000 | [diff] [blame] | 834 | break; |
| 835 | case R_390_8: |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 836 | fprintf(outfile, " *(uint8_t *)(gen_code_ptr + %d) = %s + %d;\n", |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 837 | rel->r_offset - start_offset, name, addend); |
bellard | fb3e584 | 2003-03-29 17:32:36 +0000 | [diff] [blame] | 838 | break; |
| 839 | default: |
| 840 | error("unsupported s390 relocation (%d)", type); |
| 841 | } |
| 842 | } |
| 843 | } |
| 844 | } |
bellard | efdea7b | 2003-04-29 21:12:28 +0000 | [diff] [blame] | 845 | #elif defined(HOST_ALPHA) |
| 846 | { |
| 847 | for (i = 0, rel = relocs; i < nb_relocs; i++, rel++) { |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 848 | if (rel->r_offset >= start_offset && rel->r_offset < start_offset + copy_size) { |
bellard | efdea7b | 2003-04-29 21:12:28 +0000 | [diff] [blame] | 849 | int type; |
bellard | 74c9511 | 2003-05-11 12:27:31 +0000 | [diff] [blame] | 850 | |
bellard | efdea7b | 2003-04-29 21:12:28 +0000 | [diff] [blame] | 851 | type = ELF64_R_TYPE(rel->r_info); |
bellard | 74c9511 | 2003-05-11 12:27:31 +0000 | [diff] [blame] | 852 | sym_name = strtab + symtab[ELF64_R_SYM(rel->r_info)].st_name; |
bellard | efdea7b | 2003-04-29 21:12:28 +0000 | [diff] [blame] | 853 | switch (type) { |
| 854 | case R_ALPHA_GPDISP: |
bellard | 74c9511 | 2003-05-11 12:27:31 +0000 | [diff] [blame] | 855 | /* The gp is just 32 bit, and never changes, so it's easiest to emit it |
| 856 | as an immediate instead of constructing it from the pv or ra. */ |
| 857 | fprintf(outfile, " immediate_ldah(gen_code_ptr + %ld, gp);\n", |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 858 | rel->r_offset - start_offset); |
bellard | 74c9511 | 2003-05-11 12:27:31 +0000 | [diff] [blame] | 859 | fprintf(outfile, " immediate_lda(gen_code_ptr + %ld, gp);\n", |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 860 | rel->r_offset - start_offset + rel->r_addend); |
bellard | efdea7b | 2003-04-29 21:12:28 +0000 | [diff] [blame] | 861 | break; |
| 862 | case R_ALPHA_LITUSE: |
| 863 | /* jsr to literal hint. Could be used to optimize to bsr. Ignore for |
| 864 | now, since some called functions (libc) need pv to be set up. */ |
| 865 | break; |
| 866 | case R_ALPHA_HINT: |
| 867 | /* Branch target prediction hint. Ignore for now. Should be already |
| 868 | correct for in-function jumps. */ |
| 869 | break; |
| 870 | case R_ALPHA_LITERAL: |
bellard | 74c9511 | 2003-05-11 12:27:31 +0000 | [diff] [blame] | 871 | /* Load a literal from the GOT relative to the gp. Since there's only a |
| 872 | single gp, nothing is to be done. */ |
| 873 | break; |
| 874 | case R_ALPHA_GPRELHIGH: |
| 875 | /* Handle fake relocations against __op_param symbol. Need to emit the |
| 876 | high part of the immediate value instead. Other symbols need no |
| 877 | special treatment. */ |
| 878 | if (strstart(sym_name, "__op_param", &p)) |
| 879 | fprintf(outfile, " immediate_ldah(gen_code_ptr + %ld, param%s);\n", |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 880 | rel->r_offset - start_offset, p); |
bellard | 74c9511 | 2003-05-11 12:27:31 +0000 | [diff] [blame] | 881 | break; |
| 882 | case R_ALPHA_GPRELLOW: |
| 883 | if (strstart(sym_name, "__op_param", &p)) |
| 884 | fprintf(outfile, " immediate_lda(gen_code_ptr + %ld, param%s);\n", |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 885 | rel->r_offset - start_offset, p); |
bellard | 74c9511 | 2003-05-11 12:27:31 +0000 | [diff] [blame] | 886 | break; |
| 887 | case R_ALPHA_BRSGP: |
| 888 | /* PC-relative jump. Tweak offset to skip the two instructions that try to |
| 889 | set up the gp from the pv. */ |
bellard | 2f87c60 | 2003-06-02 20:38:09 +0000 | [diff] [blame] | 890 | fprintf(outfile, " fix_bsr(gen_code_ptr + %ld, (uint8_t *) &%s - (gen_code_ptr + %ld + 4) + 8);\n", |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 891 | rel->r_offset - start_offset, sym_name, rel->r_offset - start_offset); |
bellard | efdea7b | 2003-04-29 21:12:28 +0000 | [diff] [blame] | 892 | break; |
| 893 | default: |
| 894 | error("unsupported Alpha relocation (%d)", type); |
| 895 | } |
| 896 | } |
| 897 | } |
| 898 | } |
| 899 | #elif defined(HOST_IA64) |
| 900 | { |
| 901 | char name[256]; |
| 902 | int type; |
| 903 | int addend; |
| 904 | for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) { |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 905 | if (rel->r_offset >= start_offset && rel->r_offset < start_offset + copy_size) { |
bellard | efdea7b | 2003-04-29 21:12:28 +0000 | [diff] [blame] | 906 | sym_name = strtab + symtab[ELF64_R_SYM(rel->r_info)].st_name; |
| 907 | if (strstart(sym_name, "__op_param", &p)) { |
| 908 | snprintf(name, sizeof(name), "param%s", p); |
| 909 | } else { |
| 910 | snprintf(name, sizeof(name), "(long)(&%s)", sym_name); |
| 911 | } |
| 912 | type = ELF64_R_TYPE(rel->r_info); |
| 913 | addend = rel->r_addend; |
| 914 | switch(type) { |
| 915 | case R_IA64_LTOFF22: |
| 916 | error("must implemnt R_IA64_LTOFF22 relocation"); |
| 917 | case R_IA64_PCREL21B: |
| 918 | error("must implemnt R_IA64_PCREL21B relocation"); |
| 919 | default: |
| 920 | error("unsupported ia64 relocation (%d)", type); |
| 921 | } |
| 922 | } |
| 923 | } |
| 924 | } |
bellard | d014c98 | 2003-04-29 21:26:53 +0000 | [diff] [blame] | 925 | #elif defined(HOST_SPARC) |
| 926 | { |
| 927 | char name[256]; |
| 928 | int type; |
| 929 | int addend; |
| 930 | for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) { |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 931 | if (rel->r_offset >= start_offset && |
| 932 | rel->r_offset < start_offset + copy_size) { |
bellard | d014c98 | 2003-04-29 21:26:53 +0000 | [diff] [blame] | 933 | sym_name = strtab + symtab[ELF32_R_SYM(rel->r_info)].st_name; |
| 934 | if (strstart(sym_name, "__op_param", &p)) { |
| 935 | snprintf(name, sizeof(name), "param%s", p); |
| 936 | } else { |
| 937 | if (sym_name[0] == '.') |
| 938 | snprintf(name, sizeof(name), |
| 939 | "(long)(&__dot_%s)", |
| 940 | sym_name + 1); |
| 941 | else |
| 942 | snprintf(name, sizeof(name), |
| 943 | "(long)(&%s)", sym_name); |
| 944 | } |
| 945 | type = ELF32_R_TYPE(rel->r_info); |
| 946 | addend = rel->r_addend; |
| 947 | switch(type) { |
| 948 | case R_SPARC_32: |
| 949 | fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 950 | rel->r_offset - start_offset, name, addend); |
bellard | d014c98 | 2003-04-29 21:26:53 +0000 | [diff] [blame] | 951 | break; |
| 952 | case R_SPARC_HI22: |
| 953 | fprintf(outfile, |
| 954 | " *(uint32_t *)(gen_code_ptr + %d) = " |
| 955 | "((*(uint32_t *)(gen_code_ptr + %d)) " |
| 956 | " & ~0x3fffff) " |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 957 | " | (((%s + %d) >> 10) & 0x3fffff);\n", |
| 958 | rel->r_offset - start_offset, |
| 959 | rel->r_offset - start_offset, |
bellard | d014c98 | 2003-04-29 21:26:53 +0000 | [diff] [blame] | 960 | name, addend); |
| 961 | break; |
| 962 | case R_SPARC_LO10: |
| 963 | fprintf(outfile, |
| 964 | " *(uint32_t *)(gen_code_ptr + %d) = " |
| 965 | "((*(uint32_t *)(gen_code_ptr + %d)) " |
| 966 | " & ~0x3ff) " |
| 967 | " | ((%s + %d) & 0x3ff);\n", |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 968 | rel->r_offset - start_offset, |
| 969 | rel->r_offset - start_offset, |
bellard | d014c98 | 2003-04-29 21:26:53 +0000 | [diff] [blame] | 970 | name, addend); |
| 971 | break; |
| 972 | case R_SPARC_WDISP30: |
| 973 | fprintf(outfile, |
| 974 | " *(uint32_t *)(gen_code_ptr + %d) = " |
| 975 | "((*(uint32_t *)(gen_code_ptr + %d)) " |
| 976 | " & ~0x3fffffff) " |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 977 | " | ((((%s + %d) - (long)(gen_code_ptr + %d))>>2) " |
bellard | d014c98 | 2003-04-29 21:26:53 +0000 | [diff] [blame] | 978 | " & 0x3fffffff);\n", |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 979 | rel->r_offset - start_offset, |
| 980 | rel->r_offset - start_offset, |
| 981 | name, addend, |
| 982 | rel->r_offset - start_offset); |
bellard | d014c98 | 2003-04-29 21:26:53 +0000 | [diff] [blame] | 983 | break; |
| 984 | default: |
| 985 | error("unsupported sparc relocation (%d)", type); |
| 986 | } |
| 987 | } |
| 988 | } |
| 989 | } |
| 990 | #elif defined(HOST_SPARC64) |
| 991 | { |
| 992 | char name[256]; |
| 993 | int type; |
| 994 | int addend; |
| 995 | for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) { |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 996 | if (rel->r_offset >= start_offset && |
| 997 | rel->r_offset < start_offset + copy_size) { |
bellard | d014c98 | 2003-04-29 21:26:53 +0000 | [diff] [blame] | 998 | sym_name = strtab + symtab[ELF64_R_SYM(rel->r_info)].st_name; |
| 999 | if (strstart(sym_name, "__op_param", &p)) { |
| 1000 | snprintf(name, sizeof(name), "param%s", p); |
| 1001 | } else { |
| 1002 | snprintf(name, sizeof(name), "(long)(&%s)", sym_name); |
| 1003 | } |
| 1004 | type = ELF64_R_TYPE(rel->r_info); |
| 1005 | addend = rel->r_addend; |
| 1006 | switch(type) { |
| 1007 | case R_SPARC_32: |
| 1008 | fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 1009 | rel->r_offset - start_offset, name, addend); |
bellard | d014c98 | 2003-04-29 21:26:53 +0000 | [diff] [blame] | 1010 | break; |
| 1011 | case R_SPARC_HI22: |
| 1012 | fprintf(outfile, |
| 1013 | " *(uint32_t *)(gen_code_ptr + %d) = " |
| 1014 | "((*(uint32_t *)(gen_code_ptr + %d)) " |
| 1015 | " & ~0x3fffff) " |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 1016 | " | (((%s + %d) >> 10) & 0x3fffff);\n", |
| 1017 | rel->r_offset - start_offset, |
| 1018 | rel->r_offset - start_offset, |
bellard | d014c98 | 2003-04-29 21:26:53 +0000 | [diff] [blame] | 1019 | name, addend); |
| 1020 | break; |
| 1021 | case R_SPARC_LO10: |
| 1022 | fprintf(outfile, |
| 1023 | " *(uint32_t *)(gen_code_ptr + %d) = " |
| 1024 | "((*(uint32_t *)(gen_code_ptr + %d)) " |
| 1025 | " & ~0x3ff) " |
| 1026 | " | ((%s + %d) & 0x3ff);\n", |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 1027 | rel->r_offset - start_offset, |
| 1028 | rel->r_offset - start_offset, |
bellard | d014c98 | 2003-04-29 21:26:53 +0000 | [diff] [blame] | 1029 | name, addend); |
| 1030 | break; |
| 1031 | case R_SPARC_WDISP30: |
| 1032 | fprintf(outfile, |
| 1033 | " *(uint32_t *)(gen_code_ptr + %d) = " |
| 1034 | "((*(uint32_t *)(gen_code_ptr + %d)) " |
| 1035 | " & ~0x3fffffff) " |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 1036 | " | ((((%s + %d) - (long)(gen_code_ptr + %d))>>2) " |
bellard | d014c98 | 2003-04-29 21:26:53 +0000 | [diff] [blame] | 1037 | " & 0x3fffffff);\n", |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 1038 | rel->r_offset - start_offset, |
| 1039 | rel->r_offset - start_offset, |
| 1040 | name, addend, |
| 1041 | rel->r_offset - start_offset); |
bellard | d014c98 | 2003-04-29 21:26:53 +0000 | [diff] [blame] | 1042 | break; |
| 1043 | default: |
| 1044 | error("unsupported sparc64 relocation (%d)", type); |
| 1045 | } |
| 1046 | } |
| 1047 | } |
| 1048 | } |
bellard | ff1f20a | 2003-06-09 15:34:19 +0000 | [diff] [blame] | 1049 | #elif defined(HOST_ARM) |
| 1050 | { |
| 1051 | char name[256]; |
| 1052 | int type; |
| 1053 | int addend; |
| 1054 | |
| 1055 | arm_emit_ldr_info(name, start_offset, outfile, p_start, p_end, |
| 1056 | relocs, nb_relocs); |
| 1057 | |
| 1058 | for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) { |
| 1059 | if (rel->r_offset >= start_offset && |
| 1060 | rel->r_offset < start_offset + copy_size) { |
| 1061 | sym_name = strtab + symtab[ELFW(R_SYM)(rel->r_info)].st_name; |
| 1062 | /* the compiler leave some unnecessary references to the code */ |
| 1063 | if (sym_name[0] == '\0') |
| 1064 | continue; |
| 1065 | if (strstart(sym_name, "__op_param", &p)) { |
| 1066 | snprintf(name, sizeof(name), "param%s", p); |
| 1067 | } else { |
| 1068 | snprintf(name, sizeof(name), "(long)(&%s)", sym_name); |
| 1069 | } |
| 1070 | type = ELF32_R_TYPE(rel->r_info); |
| 1071 | addend = get32((uint32_t *)(text + rel->r_offset)); |
| 1072 | switch(type) { |
| 1073 | case R_ARM_ABS32: |
| 1074 | fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", |
| 1075 | rel->r_offset - start_offset, name, addend); |
| 1076 | break; |
| 1077 | case R_ARM_PC24: |
| 1078 | fprintf(outfile, " arm_reloc_pc24((uint32_t *)(gen_code_ptr + %d), 0x%x, %s);\n", |
| 1079 | rel->r_offset - start_offset, addend, name); |
| 1080 | break; |
| 1081 | default: |
| 1082 | error("unsupported arm relocation (%d)", type); |
| 1083 | } |
| 1084 | } |
| 1085 | } |
| 1086 | } |
bellard | 38e584a | 2003-08-10 22:14:22 +0000 | [diff] [blame] | 1087 | #elif defined(HOST_M68K) |
| 1088 | { |
| 1089 | char name[256]; |
| 1090 | int type; |
| 1091 | int addend; |
| 1092 | Elf32_Sym *sym; |
| 1093 | for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) { |
| 1094 | if (rel->r_offset >= start_offset && |
| 1095 | rel->r_offset < start_offset + copy_size) { |
| 1096 | sym = &(symtab[ELFW(R_SYM)(rel->r_info)]); |
| 1097 | sym_name = strtab + symtab[ELFW(R_SYM)(rel->r_info)].st_name; |
| 1098 | if (strstart(sym_name, "__op_param", &p)) { |
| 1099 | snprintf(name, sizeof(name), "param%s", p); |
| 1100 | } else { |
| 1101 | snprintf(name, sizeof(name), "(long)(&%s)", sym_name); |
| 1102 | } |
| 1103 | type = ELF32_R_TYPE(rel->r_info); |
| 1104 | addend = get32((uint32_t *)(text + rel->r_offset)) + rel->r_addend; |
| 1105 | switch(type) { |
| 1106 | case R_68K_32: |
| 1107 | fprintf(outfile, " /* R_68K_32 RELOC, offset %x */\n", rel->r_offset) ; |
| 1108 | fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = %s + %#x;\n", |
| 1109 | rel->r_offset - start_offset, name, addend ); |
| 1110 | break; |
| 1111 | case R_68K_PC32: |
| 1112 | fprintf(outfile, " /* R_68K_PC32 RELOC, offset %x */\n", rel->r_offset); |
| 1113 | fprintf(outfile, " *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %#x) + %#x;\n", |
| 1114 | rel->r_offset - start_offset, name, rel->r_offset - start_offset, /*sym->st_value+*/ addend); |
| 1115 | break; |
| 1116 | default: |
| 1117 | error("unsupported m68k relocation (%d)", type); |
| 1118 | } |
| 1119 | } |
| 1120 | } |
| 1121 | } |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 1122 | #else |
| 1123 | #error unsupported CPU |
| 1124 | #endif |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 1125 | fprintf(outfile, " gen_code_ptr += %d;\n", copy_size); |
| 1126 | fprintf(outfile, "}\n"); |
| 1127 | fprintf(outfile, "break;\n\n"); |
| 1128 | } else { |
| 1129 | fprintf(outfile, "static inline void gen_%s(", name); |
| 1130 | if (nb_args == 0) { |
| 1131 | fprintf(outfile, "void"); |
| 1132 | } else { |
| 1133 | for(i = 0; i < nb_args; i++) { |
| 1134 | if (i != 0) |
| 1135 | fprintf(outfile, ", "); |
| 1136 | fprintf(outfile, "long param%d", i + 1); |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1137 | } |
| 1138 | } |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 1139 | fprintf(outfile, ")\n"); |
| 1140 | fprintf(outfile, "{\n"); |
| 1141 | for(i = 0; i < nb_args; i++) { |
| 1142 | fprintf(outfile, " *gen_opparam_ptr++ = param%d;\n", i + 1); |
| 1143 | } |
| 1144 | fprintf(outfile, " *gen_opc_ptr++ = INDEX_%s;\n", name); |
| 1145 | fprintf(outfile, "}\n\n"); |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1146 | } |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1147 | } |
| 1148 | |
| 1149 | /* load an elf object file */ |
bellard | d219f7e | 2003-06-15 19:44:49 +0000 | [diff] [blame] | 1150 | int load_elf(const char *filename, FILE *outfile, int out_type) |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1151 | { |
| 1152 | int fd; |
bellard | d4e8164 | 2003-05-25 16:46:15 +0000 | [diff] [blame] | 1153 | struct elf_shdr *sec, *symtab_sec, *strtab_sec, *text_sec; |
| 1154 | int i, j; |
| 1155 | ElfW(Sym) *sym; |
bellard | c1e42a1 | 2003-05-29 20:05:18 +0000 | [diff] [blame] | 1156 | char *shstr; |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1157 | uint8_t *text; |
bellard | fe31975 | 2003-06-05 00:56:05 +0000 | [diff] [blame] | 1158 | ELF_RELOC *relocs; |
| 1159 | int nb_relocs; |
| 1160 | ELF_RELOC *rel; |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1161 | |
| 1162 | fd = open(filename, O_RDONLY); |
| 1163 | if (fd < 0) |
| 1164 | error("can't open file '%s'", filename); |
| 1165 | |
| 1166 | /* Read ELF header. */ |
| 1167 | if (read(fd, &ehdr, sizeof (ehdr)) != sizeof (ehdr)) |
| 1168 | error("unable to read file header"); |
| 1169 | |
| 1170 | /* Check ELF identification. */ |
| 1171 | if (ehdr.e_ident[EI_MAG0] != ELFMAG0 |
| 1172 | || ehdr.e_ident[EI_MAG1] != ELFMAG1 |
| 1173 | || ehdr.e_ident[EI_MAG2] != ELFMAG2 |
| 1174 | || ehdr.e_ident[EI_MAG3] != ELFMAG3 |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1175 | || ehdr.e_ident[EI_VERSION] != EV_CURRENT) { |
| 1176 | error("bad ELF header"); |
| 1177 | } |
| 1178 | |
| 1179 | do_swap = elf_must_swap(&ehdr); |
| 1180 | if (do_swap) |
| 1181 | elf_swap_ehdr(&ehdr); |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 1182 | if (ehdr.e_ident[EI_CLASS] != ELF_CLASS) |
| 1183 | error("Unsupported ELF class"); |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1184 | if (ehdr.e_type != ET_REL) |
| 1185 | error("ELF object file expected"); |
| 1186 | if (ehdr.e_version != EV_CURRENT) |
| 1187 | error("Invalid ELF version"); |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 1188 | if (!elf_check_arch(ehdr.e_machine)) |
| 1189 | error("Unsupported CPU (e_machine=%d)", ehdr.e_machine); |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1190 | |
| 1191 | /* read section headers */ |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 1192 | shdr = load_data(fd, ehdr.e_shoff, ehdr.e_shnum * sizeof(struct elf_shdr)); |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1193 | if (do_swap) { |
| 1194 | for(i = 0; i < ehdr.e_shnum; i++) { |
| 1195 | elf_swap_shdr(&shdr[i]); |
| 1196 | } |
| 1197 | } |
| 1198 | |
bellard | fe31975 | 2003-06-05 00:56:05 +0000 | [diff] [blame] | 1199 | /* read all section data */ |
| 1200 | sdata = malloc(sizeof(void *) * ehdr.e_shnum); |
| 1201 | memset(sdata, 0, sizeof(void *) * ehdr.e_shnum); |
| 1202 | |
| 1203 | for(i = 0;i < ehdr.e_shnum; i++) { |
| 1204 | sec = &shdr[i]; |
| 1205 | if (sec->sh_type != SHT_NOBITS) |
| 1206 | sdata[i] = load_data(fd, sec->sh_offset, sec->sh_size); |
| 1207 | } |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1208 | |
bellard | fe31975 | 2003-06-05 00:56:05 +0000 | [diff] [blame] | 1209 | sec = &shdr[ehdr.e_shstrndx]; |
| 1210 | shstr = sdata[ehdr.e_shstrndx]; |
| 1211 | |
| 1212 | /* swap relocations */ |
| 1213 | for(i = 0; i < ehdr.e_shnum; i++) { |
| 1214 | sec = &shdr[i]; |
| 1215 | if (sec->sh_type == SHT_RELOC) { |
| 1216 | nb_relocs = sec->sh_size / sec->sh_entsize; |
| 1217 | if (do_swap) { |
| 1218 | for(j = 0, rel = (ELF_RELOC *)sdata[i]; j < nb_relocs; j++, rel++) |
| 1219 | elf_swap_rel(rel); |
| 1220 | } |
| 1221 | } |
| 1222 | } |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1223 | /* text section */ |
| 1224 | |
| 1225 | text_sec = find_elf_section(shdr, ehdr.e_shnum, shstr, ".text"); |
| 1226 | if (!text_sec) |
| 1227 | error("could not find .text section"); |
bellard | fe31975 | 2003-06-05 00:56:05 +0000 | [diff] [blame] | 1228 | text_shndx = text_sec - shdr; |
| 1229 | text = sdata[text_shndx]; |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1230 | |
| 1231 | /* find text relocations, if any */ |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1232 | relocs = NULL; |
bellard | fe31975 | 2003-06-05 00:56:05 +0000 | [diff] [blame] | 1233 | nb_relocs = 0; |
| 1234 | i = find_reloc(text_shndx); |
| 1235 | if (i != 0) { |
| 1236 | relocs = (ELF_RELOC *)sdata[i]; |
| 1237 | nb_relocs = shdr[i].sh_size / shdr[i].sh_entsize; |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1238 | } |
| 1239 | |
| 1240 | symtab_sec = find_elf_section(shdr, ehdr.e_shnum, shstr, ".symtab"); |
| 1241 | if (!symtab_sec) |
| 1242 | error("could not find .symtab section"); |
| 1243 | strtab_sec = &shdr[symtab_sec->sh_link]; |
| 1244 | |
bellard | fe31975 | 2003-06-05 00:56:05 +0000 | [diff] [blame] | 1245 | symtab = (ElfW(Sym) *)sdata[symtab_sec - shdr]; |
| 1246 | strtab = sdata[symtab_sec->sh_link]; |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1247 | |
bellard | efdea7b | 2003-04-29 21:12:28 +0000 | [diff] [blame] | 1248 | nb_syms = symtab_sec->sh_size / sizeof(ElfW(Sym)); |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1249 | if (do_swap) { |
| 1250 | for(i = 0, sym = symtab; i < nb_syms; i++, sym++) { |
| 1251 | swab32s(&sym->st_name); |
bellard | ce11fed | 2003-04-07 21:32:22 +0000 | [diff] [blame] | 1252 | swabls(&sym->st_value); |
| 1253 | swabls(&sym->st_size); |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1254 | swab16s(&sym->st_shndx); |
| 1255 | } |
| 1256 | } |
| 1257 | |
bellard | d219f7e | 2003-06-15 19:44:49 +0000 | [diff] [blame] | 1258 | if (out_type == OUT_INDEX_OP) { |
bellard | a513fe1 | 2003-05-27 23:29:48 +0000 | [diff] [blame] | 1259 | fprintf(outfile, "DEF(end, 0, 0)\n"); |
bellard | e477b8b | 2003-06-30 23:36:57 +0000 | [diff] [blame] | 1260 | fprintf(outfile, "DEF(nop, 0, 0)\n"); |
| 1261 | fprintf(outfile, "DEF(nop1, 1, 0)\n"); |
| 1262 | fprintf(outfile, "DEF(nop2, 2, 0)\n"); |
| 1263 | fprintf(outfile, "DEF(nop3, 3, 0)\n"); |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 1264 | for(i = 0, sym = symtab; i < nb_syms; i++, sym++) { |
| 1265 | const char *name, *p; |
| 1266 | name = strtab + sym->st_name; |
| 1267 | if (strstart(name, OP_PREFIX, &p)) { |
bellard | 0ea00c9 | 2003-03-29 16:47:34 +0000 | [diff] [blame] | 1268 | gen_code(name, sym->st_value, sym->st_size, outfile, |
bellard | fe31975 | 2003-06-05 00:56:05 +0000 | [diff] [blame] | 1269 | text, relocs, nb_relocs, 2); |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 1270 | } |
| 1271 | } |
bellard | d219f7e | 2003-06-15 19:44:49 +0000 | [diff] [blame] | 1272 | } else if (out_type == OUT_GEN_OP) { |
| 1273 | /* generate gen_xxx functions */ |
| 1274 | |
| 1275 | for(i = 0, sym = symtab; i < nb_syms; i++, sym++) { |
| 1276 | const char *name; |
| 1277 | name = strtab + sym->st_name; |
| 1278 | if (strstart(name, OP_PREFIX, NULL)) { |
| 1279 | if (sym->st_shndx != (text_sec - shdr)) |
| 1280 | error("invalid section for opcode (0x%x)", sym->st_shndx); |
| 1281 | gen_code(name, sym->st_value, sym->st_size, outfile, |
| 1282 | text, relocs, nb_relocs, 0); |
| 1283 | } |
| 1284 | } |
| 1285 | |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 1286 | } else { |
| 1287 | /* generate big code generation switch */ |
| 1288 | fprintf(outfile, |
| 1289 | "int dyngen_code(uint8_t *gen_code_buf,\n" |
bellard | d4e8164 | 2003-05-25 16:46:15 +0000 | [diff] [blame] | 1290 | " uint16_t *label_offsets, uint16_t *jmp_offsets,\n" |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 1291 | " const uint16_t *opc_buf, const uint32_t *opparam_buf)\n" |
| 1292 | "{\n" |
| 1293 | " uint8_t *gen_code_ptr;\n" |
| 1294 | " const uint16_t *opc_ptr;\n" |
bellard | ff1f20a | 2003-06-09 15:34:19 +0000 | [diff] [blame] | 1295 | " const uint32_t *opparam_ptr;\n"); |
| 1296 | |
| 1297 | #ifdef HOST_ARM |
| 1298 | fprintf(outfile, |
| 1299 | " uint8_t *last_gen_code_ptr = gen_code_buf;\n" |
| 1300 | " LDREntry *arm_ldr_ptr = arm_ldr_table;\n" |
| 1301 | " uint32_t *arm_data_ptr = arm_data_table;\n"); |
| 1302 | #endif |
| 1303 | |
| 1304 | fprintf(outfile, |
| 1305 | "\n" |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 1306 | " gen_code_ptr = gen_code_buf;\n" |
| 1307 | " opc_ptr = opc_buf;\n" |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 1308 | " opparam_ptr = opparam_buf;\n"); |
| 1309 | |
| 1310 | /* Generate prologue, if needed. */ |
bellard | ae22853 | 2003-05-13 18:59:59 +0000 | [diff] [blame] | 1311 | |
| 1312 | fprintf(outfile, |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 1313 | " for(;;) {\n" |
| 1314 | " switch(*opc_ptr++) {\n" |
| 1315 | ); |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1316 | |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 1317 | for(i = 0, sym = symtab; i < nb_syms; i++, sym++) { |
| 1318 | const char *name; |
| 1319 | name = strtab + sym->st_name; |
| 1320 | if (strstart(name, OP_PREFIX, NULL)) { |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1321 | #if 0 |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 1322 | printf("%4d: %s pos=0x%08x len=%d\n", |
| 1323 | i, name, sym->st_value, sym->st_size); |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1324 | #endif |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 1325 | if (sym->st_shndx != (text_sec - shdr)) |
| 1326 | error("invalid section for opcode (0x%x)", sym->st_shndx); |
| 1327 | gen_code(name, sym->st_value, sym->st_size, outfile, |
bellard | fe31975 | 2003-06-05 00:56:05 +0000 | [diff] [blame] | 1328 | text, relocs, nb_relocs, 1); |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 1329 | } |
| 1330 | } |
| 1331 | |
| 1332 | fprintf(outfile, |
bellard | 8ef9a8e | 2003-06-30 10:04:47 +0000 | [diff] [blame] | 1333 | " case INDEX_op_nop:\n" |
| 1334 | " break;\n" |
| 1335 | " case INDEX_op_nop1:\n" |
| 1336 | " opparam_ptr++;\n" |
| 1337 | " break;\n" |
| 1338 | " case INDEX_op_nop2:\n" |
| 1339 | " opparam_ptr += 2;\n" |
| 1340 | " break;\n" |
| 1341 | " case INDEX_op_nop3:\n" |
| 1342 | " opparam_ptr += 3;\n" |
| 1343 | " break;\n" |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 1344 | " default:\n" |
| 1345 | " goto the_end;\n" |
bellard | ff1f20a | 2003-06-09 15:34:19 +0000 | [diff] [blame] | 1346 | " }\n"); |
| 1347 | |
| 1348 | #ifdef HOST_ARM |
| 1349 | /* generate constant table if needed */ |
| 1350 | fprintf(outfile, |
| 1351 | " if ((gen_code_ptr - last_gen_code_ptr) >= (MAX_FRAG_SIZE - MAX_OP_SIZE)) {\n" |
| 1352 | " gen_code_ptr = arm_flush_ldr(gen_code_ptr, arm_ldr_table, arm_ldr_ptr, arm_data_table, arm_data_ptr, 1);\n" |
| 1353 | " last_gen_code_ptr = gen_code_ptr;\n" |
| 1354 | " arm_ldr_ptr = arm_ldr_table;\n" |
| 1355 | " arm_data_ptr = arm_data_table;\n" |
| 1356 | " }\n"); |
| 1357 | #endif |
| 1358 | |
| 1359 | |
| 1360 | fprintf(outfile, |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 1361 | " }\n" |
| 1362 | " the_end:\n" |
| 1363 | ); |
| 1364 | |
bellard | 9621339 | 2003-07-11 15:17:41 +0000 | [diff] [blame] | 1365 | /* generate some code patching */ |
| 1366 | #ifdef HOST_ARM |
| 1367 | fprintf(outfile, "gen_code_ptr = arm_flush_ldr(gen_code_ptr, arm_ldr_table, arm_ldr_ptr, arm_data_table, arm_data_ptr, 0);\n"); |
| 1368 | #endif |
bellard | d219f7e | 2003-06-15 19:44:49 +0000 | [diff] [blame] | 1369 | /* flush instruction cache */ |
| 1370 | fprintf(outfile, "flush_icache_range((unsigned long)gen_code_buf, (unsigned long)gen_code_ptr);\n"); |
| 1371 | |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 1372 | fprintf(outfile, "return gen_code_ptr - gen_code_buf;\n"); |
| 1373 | fprintf(outfile, "}\n\n"); |
| 1374 | |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1375 | } |
| 1376 | |
| 1377 | close(fd); |
| 1378 | return 0; |
| 1379 | } |
| 1380 | |
| 1381 | void usage(void) |
| 1382 | { |
| 1383 | printf("dyngen (c) 2003 Fabrice Bellard\n" |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 1384 | "usage: dyngen [-o outfile] [-c] objfile\n" |
| 1385 | "Generate a dynamic code generator from an object file\n" |
| 1386 | "-c output enum of operations\n" |
bellard | d219f7e | 2003-06-15 19:44:49 +0000 | [diff] [blame] | 1387 | "-g output gen_op_xx() functions\n" |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 1388 | ); |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1389 | exit(1); |
| 1390 | } |
| 1391 | |
| 1392 | int main(int argc, char **argv) |
| 1393 | { |
bellard | d219f7e | 2003-06-15 19:44:49 +0000 | [diff] [blame] | 1394 | int c, out_type; |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1395 | const char *filename, *outfilename; |
| 1396 | FILE *outfile; |
| 1397 | |
| 1398 | outfilename = "out.c"; |
bellard | d219f7e | 2003-06-15 19:44:49 +0000 | [diff] [blame] | 1399 | out_type = OUT_CODE; |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1400 | for(;;) { |
bellard | d219f7e | 2003-06-15 19:44:49 +0000 | [diff] [blame] | 1401 | c = getopt(argc, argv, "ho:cg"); |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1402 | if (c == -1) |
| 1403 | break; |
| 1404 | switch(c) { |
| 1405 | case 'h': |
| 1406 | usage(); |
| 1407 | break; |
| 1408 | case 'o': |
| 1409 | outfilename = optarg; |
| 1410 | break; |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 1411 | case 'c': |
bellard | d219f7e | 2003-06-15 19:44:49 +0000 | [diff] [blame] | 1412 | out_type = OUT_INDEX_OP; |
| 1413 | break; |
| 1414 | case 'g': |
| 1415 | out_type = OUT_GEN_OP; |
bellard | dc99065 | 2003-03-19 00:00:28 +0000 | [diff] [blame] | 1416 | break; |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1417 | } |
| 1418 | } |
| 1419 | if (optind >= argc) |
| 1420 | usage(); |
| 1421 | filename = argv[optind]; |
| 1422 | outfile = fopen(outfilename, "w"); |
| 1423 | if (!outfile) |
| 1424 | error("could not open '%s'", outfilename); |
bellard | d219f7e | 2003-06-15 19:44:49 +0000 | [diff] [blame] | 1425 | load_elf(filename, outfile, out_type); |
bellard | 367e86e | 2003-03-01 17:13:26 +0000 | [diff] [blame] | 1426 | fclose(outfile); |
| 1427 | return 0; |
| 1428 | } |