64 bit support

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

diff --git a/dyngen.c b/dyngen.c
index 52cabcfabcba564b5a9a9686a42b19d4cc3241b0..1eb80328f45e2b6aea34460df896a147c005b7ce 100644 (file)
--- a/dyngen.c
+++ b/dyngen.c
@@ -22,25 +22,62 @@
 #include <string.h>
 #include <stdarg.h>
 #include <inttypes.h>
 #include <string.h>
 #include <stdarg.h>
 #include <inttypes.h>

-#include <elf.h>

 #include <unistd.h>
 #include <fcntl.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
 
 #endif
 

+#include "elf.h"
+
+#include "thunk.h"
+

 /* all dynamically generated functions begin with this code */
 #define OP_PREFIX "op_"
 
 /* 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;
 {
   union {
       uint32_t i;


@@ -62,19 +99,25 @@ void swab32s(uint32_t *p)
     *p = bswap32(*p);
 }
 
     *p = bswap32(*p);
 }
 

-void swab64s(uint32_t *p)
+void swab64s(uint64_t *p)

 {
     *p = bswap64(*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 */
 {
     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 */
     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 */
 }
 
     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_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_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_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_flags);              /* Segment flags */

-    swab32s(&h->p_align);              /* Segment alignment */
+    swabls(&h->p_align);               /* Segment alignment */

 }
 
 int do_swap;
 }
 
 int do_swap;

-int e_machine;

 
 uint16_t get16(uint16_t *p)
 {
 
 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;
 {
     int i;
     const char *shname;

-    Elf32_Shdr *sec;
+    struct elf_shdr *sec;

 
     for(i = 0; i < shnum; i++) {
         sec = &shdr[i];
 
     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 */
 #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 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;
     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;
 
     /* 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;
     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;
            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;
 
     }
 
     /* 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);
 
         }
         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 */
         }
 
         /* patch relocations */

-        switch(e_machine) {
-        case EM_386:
+#if defined(HOST_I386)

             {
             {

-                Elf32_Rel *rel;

                 char name[256];
                 int type;
                 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;
                 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:
                     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:
                                 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:
                                 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;
                 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;
                 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:
                         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:
                                     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:
                                     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:
                                     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 */
                                     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:
                                     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;
                 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;
                 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:
                         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:
                                     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:
                                     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:
                                     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");
         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;
 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;
     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;
     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_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");
     }
      || 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);
     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");
     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 */
 
     /* 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]);
     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);
     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);
         }
     }
 
             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++) {
     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 */ 
 );
 
 /* generate a return */ 

-    switch(e_machine) {
+    switch(ELF_ARCH) {

     case EM_386:
         fprintf(outfile, "*gen_code_ptr++ = 0xc3; /* ret */\n");
         break;
     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;
     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");
     }
     
     fprintf(outfile, "return gen_code_ptr -  gen_code_buf;\n");