gwj / at91sam9263 · Commits

Commit 86e840eef78d5c6882cfd2befd8571e6cd98782f

Authored by aurel32
1 parent 955a7dd5

Remove a few dyngen and dyngen related code 

Signed-off-by: Aurelien Jarno <aurelien@aurel32.net>

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