64 bit support

git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@76 c046a42c-6fe2-441c-8c8c-71466251a162

1 files changed, 124 insertions, 145 deletions

diff --git a/dyngen.c b/dyngen.c
index 52cabcfabc..1eb80328f4 100644
--- a/dyngen.c
+++ b/dyngen.c
@@ -22,25 +22,62 @@
 #include <string.h>
 #include <stdarg.h>
 #include <inttypes.h>
-#include <elf.h>
 #include <unistd.h>
 #include <fcntl.h>
 
-#include "thunk.h"
+#include "config.h"
+
+/* elf format definitions. We use these macros to test the CPU to
+   allow cross compilation (this tool must be ran on the build
+   platform) */
+#if defined(HOST_I386)
+
+#define ELF_CLASS	ELFCLASS32
+#define ELF_ARCH	EM_386
+#define elf_check_arch(x) ( ((x) == EM_386) || ((x) == EM_486) )
+#undef ELF_USES_RELOCA
+
+#elif defined(HOST_PPC)
+
+#define ELF_CLASS	ELFCLASS32
+#define ELF_ARCH	EM_PPC
+#define elf_check_arch(x) ((x) == EM_PPC)
+#define ELF_USES_RELOCA
+
+#elif defined(HOST_S390)
+
+#define ELF_CLASS	ELFCLASS32
+#define ELF_ARCH	EM_S390
+#define elf_check_arch(x) ((x) == EM_S390)
+#define ELF_USES_RELOCA
 
-/* temporary fix to make it compile with old elf headers (XXX: use
-   included elf.h in all cases) */
-#ifndef EM_390
-#define EM_S390		22		/* IBM S390 */
-#define R_390_8		1	       /* Direct 8 bit.	 */
-#define R_390_16	3	       /* Direct 16 bit.  */
-#define R_390_32	4	       /* Direct 32 bit.  */
+#elif defined(HOST_ALPHA)
+
+#define ELF_CLASS	ELFCLASS64
+#define ELF_ARCH	EM_ALPHA
+#define elf_check_arch(x) ((x) == EM_ALPHA)
+#define ELF_USES_RELOCA
+
+#else
+#error unsupported CPU - please update the code
+#endif
+
+#if ELF_CLASS == ELFCLASS32
+typedef int32_t host_long;
+typedef uint32_t host_ulong;
+#else
+typedef int64_t host_long;
+typedef uint64_t host_ulong;
 #endif
 
+#include "elf.h"
+
+#include "thunk.h"
+
 /* all dynamically generated functions begin with this code */
 #define OP_PREFIX "op_"
 
-int elf_must_swap(Elf32_Ehdr *h)
+int elf_must_swap(struct elfhdr *h)
 {
   union {
       uint32_t i;
@@ -62,19 +99,25 @@ void swab32s(uint32_t *p)
     *p = bswap32(*p);
 }
 
-void swab64s(uint32_t *p)
+void swab64s(uint64_t *p)
 {
     *p = bswap64(*p);
 }
 
-void elf_swap_ehdr(Elf32_Ehdr *h)
+#if ELF_CLASS == ELFCLASS32
+#define swabls(x) swab32s(x)
+#else
+#define swabls(x) swab64s(x)
+#endif
+
+void elf_swap_ehdr(struct elfhdr *h)
 {
     swab16s(&h->e_type);			/* Object file type */
     swab16s(&h->	e_machine);		/* Architecture */
     swab32s(&h->	e_version);		/* Object file version */
-    swab32s(&h->	e_entry);		/* Entry point virtual address */
-    swab32s(&h->	e_phoff);		/* Program header table file offset */
-    swab32s(&h->	e_shoff);		/* Section header table file offset */
+    swabls(&h->	e_entry);		/* Entry point virtual address */
+    swabls(&h->	e_phoff);		/* Program header table file offset */
+    swabls(&h->	e_shoff);		/* Section header table file offset */
     swab32s(&h->	e_flags);		/* Processor-specific flags */
     swab16s(&h->	e_ehsize);		/* ELF header size in bytes */
     swab16s(&h->	e_phentsize);		/* Program header table entry size */
@@ -84,34 +127,33 @@ void elf_swap_ehdr(Elf32_Ehdr *h)
     swab16s(&h->	e_shstrndx);		/* Section header string table index */
 }
 
-void elf_swap_shdr(Elf32_Shdr *h)
+void elf_swap_shdr(struct elf_shdr *h)
 {
   swab32s(&h->	sh_name);		/* Section name (string tbl index) */
   swab32s(&h->	sh_type);		/* Section type */
-  swab32s(&h->	sh_flags);		/* Section flags */
-  swab32s(&h->	sh_addr);		/* Section virtual addr at execution */
-  swab32s(&h->	sh_offset);		/* Section file offset */
-  swab32s(&h->	sh_size);		/* Section size in bytes */
+  swabls(&h->	sh_flags);		/* Section flags */
+  swabls(&h->	sh_addr);		/* Section virtual addr at execution */
+  swabls(&h->	sh_offset);		/* Section file offset */
+  swabls(&h->	sh_size);		/* Section size in bytes */
   swab32s(&h->	sh_link);		/* Link to another section */
   swab32s(&h->	sh_info);		/* Additional section information */
-  swab32s(&h->	sh_addralign);		/* Section alignment */
-  swab32s(&h->	sh_entsize);		/* Entry size if section holds table */
+  swabls(&h->	sh_addralign);		/* Section alignment */
+  swabls(&h->	sh_entsize);		/* Entry size if section holds table */
 }
 
-void elf_swap_phdr(Elf32_Phdr *h)
+void elf_swap_phdr(struct elf_phdr *h)
 {
     swab32s(&h->p_type);			/* Segment type */
-    swab32s(&h->p_offset);		/* Segment file offset */
-    swab32s(&h->p_vaddr);		/* Segment virtual address */
-    swab32s(&h->p_paddr);		/* Segment physical address */
-    swab32s(&h->p_filesz);		/* Segment size in file */
-    swab32s(&h->p_memsz);		/* Segment size in memory */
+    swabls(&h->p_offset);		/* Segment file offset */
+    swabls(&h->p_vaddr);		/* Segment virtual address */
+    swabls(&h->p_paddr);		/* Segment physical address */
+    swabls(&h->p_filesz);		/* Segment size in file */
+    swabls(&h->p_memsz);		/* Segment size in memory */
     swab32s(&h->p_flags);		/* Segment flags */
-    swab32s(&h->p_align);		/* Segment alignment */
+    swabls(&h->p_align);		/* Segment alignment */
 }
 
 int do_swap;
-int e_machine;
 
 uint16_t get16(uint16_t *p)
 {
@@ -157,12 +199,12 @@ void __attribute__((noreturn)) error(const char *fmt, ...)
 }
 
 
-Elf32_Shdr *find_elf_section(Elf32_Shdr *shdr, int shnum, const char *shstr, 
-                             const char *name)
+struct elf_shdr *find_elf_section(struct elf_shdr *shdr, int shnum, const char *shstr, 
+                                  const char *name)
 {
     int i;
     const char *shname;
-    Elf32_Shdr *sec;
+    struct elf_shdr *sec;
 
     for(i = 0; i < shnum; i++) {
         sec = &shdr[i];
@@ -209,20 +251,21 @@ int strstart(const char *str, const char *val, const char **ptr)
 #define MAX_ARGS 3
 
 /* generate op code */
-void gen_code(const char *name, unsigned long offset, unsigned long size, 
-              FILE *outfile, uint8_t *text, void *relocs, int nb_relocs, int reloc_sh_type,
-              Elf32_Sym *symtab, char *strtab, int gen_switch)
+void gen_code(const char *name, host_ulong offset, host_ulong size, 
+              FILE *outfile, uint8_t *text, ELF_RELOC *relocs, int nb_relocs, int reloc_sh_type,
+              ElfW(Sym) *symtab, char *strtab, int gen_switch)
 {
     int copy_size = 0;
     uint8_t *p_start, *p_end;
-    int nb_args, i;
+    int nb_args, i, n;
     uint8_t args_present[MAX_ARGS];
     const char *sym_name, *p;
+    ELF_RELOC *rel;
 
     /* compute exact size excluding return instruction */
     p_start = text + offset;
     p_end = p_start + size;
-    switch(e_machine) {
+    switch(ELF_ARCH) {
     case EM_386:
         {
             uint8_t *p;
@@ -256,40 +299,20 @@ void gen_code(const char *name, unsigned long offset, unsigned long size,
 	    copy_size = p - p_start;
 	}
         break;
-    default:
-        error("unsupported CPU (%d)", e_machine);
     }
 
     /* compute the number of arguments by looking at the relocations */
     for(i = 0;i < MAX_ARGS; i++)
         args_present[i] = 0;
 
-    if (reloc_sh_type == SHT_REL) {
-        Elf32_Rel *rel;
-        int n;
-        for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
-            if (rel->r_offset >= offset && rel->r_offset < offset + copy_size) {
-                sym_name = strtab + symtab[ELF32_R_SYM(rel->r_info)].st_name;
-                if (strstart(sym_name, "__op_param", &p)) {
-                    n = strtoul(p, NULL, 10);
-                    if (n >= MAX_ARGS)
-                        error("too many arguments in %s", name);
-                    args_present[n - 1] = 1;
-                }
-            }
-        }
-    } else {
-        Elf32_Rela *rel;
-        int n;
-        for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
-            if (rel->r_offset >= offset && rel->r_offset < offset + copy_size) {
-                sym_name = strtab + symtab[ELF32_R_SYM(rel->r_info)].st_name;
-                if (strstart(sym_name, "__op_param", &p)) {
-                    n = strtoul(p, NULL, 10);
-                    if (n >= MAX_ARGS)
-                        error("too many arguments in %s", name);
-                    args_present[n - 1] = 1;
-                }
+    for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
+        if (rel->r_offset >= offset && rel->r_offset < offset + copy_size) {
+            sym_name = strtab + symtab[ELFW(R_SYM)(rel->r_info)].st_name;
+            if (strstart(sym_name, "__op_param", &p)) {
+                n = strtoul(p, NULL, 10);
+                if (n >= MAX_ARGS)
+                    error("too many arguments in %s", name);
+                args_present[n - 1] = 1;
             }
         }
     }
@@ -319,24 +342,11 @@ void gen_code(const char *name, unsigned long offset, unsigned long size,
         }
         fprintf(outfile, "    extern void %s();\n", name);
 
-        if (reloc_sh_type == SHT_REL) {
-            Elf32_Rel *rel;
-            for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
-                if (rel->r_offset >= offset && rel->r_offset < offset + copy_size) {
-                    sym_name = strtab + symtab[ELF32_R_SYM(rel->r_info)].st_name;
-                    if (!strstart(sym_name, "__op_param", &p)) {
-                        fprintf(outfile, "extern char %s;\n", sym_name);
-                    }
-                }
-            }
-        } else {
-            Elf32_Rela *rel;
-            for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
-                if (rel->r_offset >= offset && rel->r_offset < offset + copy_size) {
-                    sym_name = strtab + symtab[ELF32_R_SYM(rel->r_info)].st_name;
-                    if (!strstart(sym_name, "__op_param", &p)) {
-                        fprintf(outfile, "extern char %s;\n", sym_name);
-                    }
+        for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
+            if (rel->r_offset >= offset && rel->r_offset < offset + copy_size) {
+                sym_name = strtab + symtab[ELF32_R_SYM(rel->r_info)].st_name;
+                if (!strstart(sym_name, "__op_param", &p)) {
+                    fprintf(outfile, "extern char %s;\n", sym_name);
                 }
             }
         }
@@ -347,13 +357,11 @@ void gen_code(const char *name, unsigned long offset, unsigned long size,
         }
 
         /* patch relocations */
-        switch(e_machine) {
-        case EM_386:
+#if defined(HOST_I386)
             {
-                Elf32_Rel *rel;
                 char name[256];
                 int type;
-                long addend;
+                int addend;
                 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
                 if (rel->r_offset >= offset && rel->r_offset < offset + copy_size) {
                     sym_name = strtab + symtab[ELF32_R_SYM(rel->r_info)].st_name;
@@ -366,11 +374,11 @@ void gen_code(const char *name, unsigned long offset, unsigned long size,
                     addend = get32((uint32_t *)(text + rel->r_offset));
                     switch(type) {
                     case R_386_32:
-                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %ld) = %s + %ld;\n", 
+                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", 
                                 rel->r_offset - offset, name, addend);
                         break;
                     case R_386_PC32:
-                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %ld) = %s - (long)(gen_code_ptr + %ld) + %ld;\n", 
+                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %d) + %d;\n", 
                                 rel->r_offset - offset, name, rel->r_offset - offset, addend);
                         break;
                     default:
@@ -379,13 +387,11 @@ void gen_code(const char *name, unsigned long offset, unsigned long size,
                 }
                 }
             }
-            break;
-        case EM_PPC:
+#elif defined(HOST_PPC)
             {
-                Elf32_Rela *rel;
                 char name[256];
                 int type;
-                long addend;
+                int addend;
                 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
                     if (rel->r_offset >= offset && rel->r_offset < offset + copy_size) {
                         sym_name = strtab + symtab[ELF32_R_SYM(rel->r_info)].st_name;
@@ -398,24 +404,24 @@ void gen_code(const char *name, unsigned long offset, unsigned long size,
                         addend = rel->r_addend;
                         switch(type) {
                         case R_PPC_ADDR32:
-                            fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %ld) = %s + %ld;\n", 
+                            fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", 
                                     rel->r_offset - offset, name, addend);
                             break;
                         case R_PPC_ADDR16_LO:
-                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %ld) = (%s + %ld);\n", 
+                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = (%s + %d);\n", 
                                     rel->r_offset - offset, name, addend);
                             break;
                         case R_PPC_ADDR16_HI:
-                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %ld) = (%s + %ld) >> 16;\n", 
+                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = (%s + %d) >> 16;\n", 
                                     rel->r_offset - offset, name, addend);
                             break;
                         case R_PPC_ADDR16_HA:
-                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %ld) = (%s + %ld + 0x8000) >> 16;\n", 
+                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = (%s + %d + 0x8000) >> 16;\n", 
                                     rel->r_offset - offset, name, addend);
                             break;
                         case R_PPC_REL24:
                             /* warning: must be at 32 MB distancy */
-                            fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %ld) = (*(uint32_t *)(gen_code_ptr + %ld) & ~0x03fffffc) | ((%s - (long)(gen_code_ptr + %ld) + %ld) & 0x03fffffc);\n", 
+                            fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = (*(uint32_t *)(gen_code_ptr + %d) & ~0x03fffffc) | ((%s - (long)(gen_code_ptr + %d) + %d) & 0x03fffffc);\n", 
                                     rel->r_offset - offset, rel->r_offset - offset, name, rel->r_offset - offset, addend);
                             break;
                         default:
@@ -424,13 +430,11 @@ void gen_code(const char *name, unsigned long offset, unsigned long size,
                     }
                 }
             }
-            break;
-        case EM_S390:
+#elif defined(HOST_S390)
             {
-                Elf32_Rela *rel;
                 char name[256];
                 int type;
-                long addend;
+                int addend;
                 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
                     if (rel->r_offset >= offset && rel->r_offset < offset + copy_size) {
                         sym_name = strtab + symtab[ELF32_R_SYM(rel->r_info)].st_name;
@@ -443,15 +447,15 @@ void gen_code(const char *name, unsigned long offset, unsigned long size,
                         addend = rel->r_addend;
                         switch(type) {
                         case R_390_32:
-                            fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %ld) = %s + %ld;\n", 
+                            fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", 
                                     rel->r_offset - offset, name, addend);
                             break;
                         case R_390_16:
-                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %ld) = %s + %ld;\n", 
+                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = %s + %d;\n", 
                                     rel->r_offset - offset, name, addend);
                             break;
                         case R_390_8:
-                            fprintf(outfile, "    *(uint8_t *)(gen_code_ptr + %ld) = %s + %ld;\n", 
+                            fprintf(outfile, "    *(uint8_t *)(gen_code_ptr + %d) = %s + %d;\n", 
                                     rel->r_offset - offset, name, addend);
                             break;
                         default:
@@ -460,10 +464,9 @@ void gen_code(const char *name, unsigned long offset, unsigned long size,
                     }
                 }
             }
-            break;
-        default:
-            error("unsupported CPU for relocations (%d)", e_machine);
-        }
+#else
+#error unsupported CPU
+#endif
         fprintf(outfile, "    gen_code_ptr += %d;\n", copy_size);
         fprintf(outfile, "}\n");
         fprintf(outfile, "break;\n\n");
@@ -492,11 +495,10 @@ void gen_code(const char *name, unsigned long offset, unsigned long size,
 int load_elf(const char *filename, FILE *outfile, int do_print_enum)
 {
     int fd;
-    Elf32_Ehdr ehdr;
-    Elf32_Shdr *sec, *shdr, *symtab_sec, *strtab_sec, *text_sec;
+    struct elfhdr ehdr;
+    struct elf_shdr *sec, *shdr, *symtab_sec, *strtab_sec, *text_sec;
     int i, j, nb_syms;
-    Elf32_Sym *symtab, *sym;
-    const char *cpu_name;
+    ElfW(Sym) *symtab, *sym;
     char *shstr, *strtab;
     uint8_t *text;
     void *relocs;
@@ -515,7 +517,6 @@ int load_elf(const char *filename, FILE *outfile, int do_print_enum)
      || ehdr.e_ident[EI_MAG1] != ELFMAG1
      || ehdr.e_ident[EI_MAG2] != ELFMAG2
      || ehdr.e_ident[EI_MAG3] != ELFMAG3
-     || ehdr.e_ident[EI_CLASS] != ELFCLASS32
      || ehdr.e_ident[EI_VERSION] != EV_CURRENT) {
         error("bad ELF header");
     }
@@ -523,14 +524,17 @@ int load_elf(const char *filename, FILE *outfile, int do_print_enum)
     do_swap = elf_must_swap(&ehdr);
     if (do_swap)
         elf_swap_ehdr(&ehdr);
+    if (ehdr.e_ident[EI_CLASS] != ELF_CLASS)
+        error("Unsupported ELF class");
     if (ehdr.e_type != ET_REL)
         error("ELF object file expected");
     if (ehdr.e_version != EV_CURRENT)
         error("Invalid ELF version");
-    e_machine = ehdr.e_machine;
+    if (!elf_check_arch(ehdr.e_machine))
+        error("Unsupported CPU (e_machine=%d)", ehdr.e_machine);
 
     /* read section headers */
-    shdr = load_data(fd, ehdr.e_shoff, ehdr.e_shnum * sizeof(Elf32_Shdr));
+    shdr = load_data(fd, ehdr.e_shoff, ehdr.e_shnum * sizeof(struct elf_shdr));
     if (do_swap) {
         for(i = 0; i < ehdr.e_shnum; i++) {
             elf_swap_shdr(&shdr[i]);
@@ -590,35 +594,12 @@ int load_elf(const char *filename, FILE *outfile, int do_print_enum)
     if (do_swap) {
         for(i = 0, sym = symtab; i < nb_syms; i++, sym++) {
             swab32s(&sym->st_name);
-            swab32s(&sym->st_value);
-            swab32s(&sym->st_size);
+            swabls(&sym->st_value);
+            swabls(&sym->st_size);
             swab16s(&sym->st_shndx);
         }
     }
 
-    switch(e_machine) {
-    case EM_386:
-        cpu_name = "i386";
-        break;
-    case EM_PPC:
-        cpu_name = "ppc";
-        break;
-    case EM_MIPS:
-        cpu_name = "mips";
-        break;
-    case EM_ARM:
-        cpu_name = "arm";
-        break;
-    case EM_SPARC:
-        cpu_name = "sparc";
-        break;
-    case EM_S390:
-        cpu_name = "s390";
-        break;
-    default:
-        error("unsupported CPU (e_machine=%d)", e_machine);
-    }
-
     if (do_print_enum) {
         fprintf(outfile, "DEF(end, 0)\n");
         for(i = 0, sym = symtab; i < nb_syms; i++, sym++) {
@@ -669,7 +650,7 @@ fprintf(outfile,
 );
 
 /* generate a return */ 
-    switch(e_machine) {
+    switch(ELF_ARCH) {
     case EM_386:
         fprintf(outfile, "*gen_code_ptr++ = 0xc3; /* ret */\n");
         break;
@@ -679,8 +660,6 @@ fprintf(outfile,
     case EM_S390:
         fprintf(outfile, "*((uint16_t *)gen_code_ptr)++ = 0x07fe; /* br %%r14 */\n");
         break;
-    default:
-        error("no return generation for cpu '%s'", cpu_name);
     }
     
     fprintf(outfile, "return gen_code_ptr -  gen_code_buf;\n");