]> git.proxmox.com Git - mirror_qemu.git/blobdiff - dyngen.c
find -type f | xargs sed -i 's/[\t ]*$//g' # Yes, again. Note the star in the regex.
[mirror_qemu.git] / dyngen.c
index 2d93283d67d30b0bf619d3fe0ff5d657b2982086..f136e02c265a5acec2494c39ce7102df23ad18db 100644 (file)
--- a/dyngen.c
+++ b/dyngen.c
@@ -1,6 +1,6 @@
 /*
  *  Generic Dynamic compiler generator
- * 
+ *
  *  Copyright (c) 2003 Fabrice Bellard
  *
  *  The COFF object format support was extracted from Kazu's QEMU port
 #define elf_check_arch(x) ((x) == EM_68K)
 #define ELF_USES_RELOCA
 
+#elif defined(HOST_MIPS)
+
+#define ELF_CLASS      ELFCLASS32
+#define ELF_ARCH       EM_MIPS
+#define elf_check_arch(x) ((x) == EM_MIPS)
+#define ELF_USES_RELOC
+
+#elif defined(HOST_MIPS64)
+
+/* Assume n32 ABI here, which is ELF32. */
+#define ELF_CLASS      ELFCLASS32
+#define ELF_ARCH       EM_MIPS
+#define elf_check_arch(x) ((x) == EM_MIPS)
+#define ELF_USES_RELOCA
+
 #else
 #error unsupported CPU - please update the code
 #endif
 typedef int32_t host_long;
 typedef uint32_t host_ulong;
 #define swabls(x) swab32s(x)
+#define swablss(x) swab32ss(x)
 #else
 typedef int64_t host_long;
 typedef uint64_t host_ulong;
 #define swabls(x) swab64s(x)
+#define swablss(x) swab64ss(x)
 #endif
 
 #ifdef ELF_USES_RELOCA
@@ -146,11 +163,11 @@ typedef uint64_t host_ulong;
 
 #ifdef CONFIG_FORMAT_COFF
 
-#include "a.out.h"
-
 typedef int32_t host_long;
 typedef uint32_t host_ulong;
 
+#include "a.out.h"
+
 #define FILENAMELEN 256
 
 typedef struct coff_sym {
@@ -187,11 +204,11 @@ typedef uint32_t host_ulong;
 struct nlist_extended
 {
    union {
-   char *n_name; 
-   long  n_strx; 
+   char *n_name;
+   long  n_strx;
    } n_un;
-   unsigned char n_type; 
-   unsigned char n_sect; 
+   unsigned char n_type;
+   unsigned char n_sect;
    short st_desc;
    unsigned long st_value;
    unsigned long st_size;
@@ -284,11 +301,21 @@ void swab32s(uint32_t *p)
     *p = bswap32(*p);
 }
 
+void swab32ss(int32_t *p)
+{
+    *p = bswap32(*p);
+}
+
 void swab64s(uint64_t *p)
 {
     *p = bswap64(*p);
 }
 
+void swab64ss(int64_t *p)
+{
+    *p = bswap64(*p);
+}
+
 uint16_t get16(uint16_t *p)
 {
     uint16_t val;
@@ -345,10 +372,10 @@ int elf_must_swap(struct elfhdr *h)
   } swaptest;
 
   swaptest.i = 1;
-  return (h->e_ident[EI_DATA] == ELFDATA2MSB) != 
+  return (h->e_ident[EI_DATA] == ELFDATA2MSB) !=
       (swaptest.b[0] == 0);
 }
-  
+
 void elf_swap_ehdr(struct elfhdr *h)
 {
     swab16s(&h->e_type);                       /* Object file type */
@@ -397,11 +424,11 @@ void elf_swap_rel(ELF_RELOC *rel)
     swabls(&rel->r_offset);
     swabls(&rel->r_info);
 #ifdef ELF_USES_RELOCA
-    swabls(&rel->r_addend);
+    swablss(&rel->r_addend);
 #endif
 }
 
-struct elf_shdr *find_elf_section(struct elf_shdr *shdr, int shnum, const char *shstr, 
+struct elf_shdr *find_elf_section(struct elf_shdr *shdr, int shnum, const char *shstr,
                                   const char *name)
 {
     int i;
@@ -426,7 +453,7 @@ int find_reloc(int sh_index)
 
     for(i = 0; i < ehdr.e_shnum; i++) {
         sec = &shdr[i];
-        if (sec->sh_type == SHT_RELOC && sec->sh_info == sh_index) 
+        if (sec->sh_type == SHT_RELOC && sec->sh_info == sh_index)
             return i;
     }
     return 0;
@@ -456,11 +483,11 @@ int load_object(const char *filename)
     ElfW(Sym) *sym;
     char *shstr;
     ELF_RELOC *rel;
-    
+
     fd = open(filename, O_RDONLY);
-    if (fd < 0) 
+    if (fd < 0)
         error("can't open file '%s'", filename);
-    
+
     /* Read ELF header.  */
     if (read(fd, &ehdr, sizeof (ehdr)) != sizeof (ehdr))
         error("unable to read file header");
@@ -497,7 +524,7 @@ int load_object(const char *filename)
     /* read all section data */
     sdata = malloc(sizeof(void *) * ehdr.e_shnum);
     memset(sdata, 0, sizeof(void *) * ehdr.e_shnum);
-    
+
     for(i = 0;i < ehdr.e_shnum; i++) {
         sec = &shdr[i];
         if (sec->sh_type != SHT_NOBITS)
@@ -505,7 +532,7 @@ int load_object(const char *filename)
     }
 
     sec = &shdr[ehdr.e_shstrndx];
-    shstr = sdata[ehdr.e_shstrndx];
+    shstr = (char *)sdata[ehdr.e_shstrndx];
 
     /* swap relocations */
     for(i = 0; i < ehdr.e_shnum; i++) {
@@ -541,8 +568,8 @@ int load_object(const char *filename)
     strtab_sec = &shdr[symtab_sec->sh_link];
 
     symtab = (ElfW(Sym) *)sdata[symtab_sec - shdr];
-    strtab = sdata[symtab_sec->sh_link];
-    
+    strtab = (char *)sdata[symtab_sec->sh_link];
+
     nb_syms = symtab_sec->sh_size / sizeof(ElfW(Sym));
     if (do_swap) {
         for(i = 0, sym = symtab; i < nb_syms; i++, sym++) {
@@ -582,7 +609,7 @@ void sym_ent_name(struct external_syment *ext_sym, EXE_SYM *sym)
 {
     char *q;
     int c, i, len;
-    
+
     if (ext_sym->e.e.e_zeroes != 0) {
         q = sym->st_name;
         for(i = 0; i < 8; i++) {
@@ -616,7 +643,7 @@ char *name_for_dotdata(struct coff_rel *rel)
                if (sym->st_syment->e_scnum == data_shndx &&
                     text_data >= sym->st_value &&
                     text_data < sym->st_value + sym->st_size) {
-                    
+
                     return sym->st_name;
 
                }
@@ -674,15 +701,15 @@ int load_object(const char *filename)
     uint32_t *n_strtab;
     EXE_SYM *sym;
     EXE_RELOC *rel;
-       
-    fd = open(filename, O_RDONLY 
+
+    fd = open(filename, O_RDONLY
 #ifdef _WIN32
               | O_BINARY
 #endif
               );
-    if (fd < 0) 
+    if (fd < 0)
         error("can't open file '%s'", filename);
-    
+
     /* Read COFF header.  */
     if (read(fd, &fhdr, sizeof (fhdr)) != sizeof (fhdr))
         error("unable to read file header");
@@ -695,11 +722,11 @@ int load_object(const char *filename)
 
     /* read section headers */
     shdr = load_data(fd, sizeof(struct external_filehdr) + fhdr.f_opthdr, fhdr.f_nscns * sizeof(struct external_scnhdr));
-       
+
     /* read all section data */
     sdata = malloc(sizeof(void *) * fhdr.f_nscns);
     memset(sdata, 0, sizeof(void *) * fhdr.f_nscns);
-    
+
     const char *p;
     for(i = 0;i < fhdr.f_nscns; i++) {
         sec = &shdr[i];
@@ -720,7 +747,7 @@ int load_object(const char *filename)
     if (!data_sec)
         error("could not find .data section");
     coff_data_shndx = data_sec - shdr;
-    
+
     coff_symtab = load_data(fd, fhdr.f_symptr, fhdr.f_nsyms*SYMESZ);
     for (i = 0, ext_sym = coff_symtab; i < nb_syms; i++, ext_sym++) {
         for(i=0;i<8;i++)
@@ -730,8 +757,8 @@ int load_object(const char *filename)
 
 
     n_strtab = load_data(fd, (fhdr.f_symptr + fhdr.f_nsyms*SYMESZ), STRTAB_SIZE);
-    strtab = load_data(fd, (fhdr.f_symptr + fhdr.f_nsyms*SYMESZ), *n_strtab); 
-    
+    strtab = load_data(fd, (fhdr.f_symptr + fhdr.f_nsyms*SYMESZ), *n_strtab);
+
     nb_syms = fhdr.f_nsyms;
 
     for (i = 0, ext_sym = coff_symtab; i < nb_syms; i++, ext_sym++) {
@@ -778,12 +805,12 @@ int load_object(const char *filename)
                } else {
                        sym->st_size = 0;
                }
-               
+
                sym->st_type = ext_sym->e_type;
                sym->st_shndx = ext_sym->e_scnum;
        }
 
-               
+
     /* find text relocations, if any */
     sec = &shdr[coff_text_shndx];
     coff_relocs = load_data(fd, sec->s_relptr, sec->s_nreloc*RELSZ);
@@ -791,7 +818,7 @@ int load_object(const char *filename)
 
     /* set coff relocation */
     relocs = malloc(sizeof(struct coff_rel) * nb_relocs);
-    for (i = 0, ext_rel = coff_relocs, rel = relocs; i < nb_relocs; 
+    for (i = 0, ext_rel = coff_relocs, rel = relocs; i < nb_relocs;
          i++, ext_rel++, rel++) {
         memset(rel, 0, sizeof(*rel));
         rel->r_reloc = ext_rel;
@@ -820,7 +847,7 @@ uint8_t     **sdata;
 
 /* relocs */
 struct relocation_info *relocs;
-       
+
 /* symbols */
 EXE_SYM                        *symtab;
 struct nlist   *symtab_std;
@@ -840,10 +867,10 @@ static inline char *find_str_by_index(int index)
 static char *get_sym_name(EXE_SYM *sym)
 {
        char *name = find_str_by_index(sym->n_un.n_strx);
-       
+
        if ( sym->n_type & N_STAB ) /* Debug symbols are ignored */
                return "debug";
-                       
+
        if(!name)
                return name;
        if(name[0]=='_')
@@ -853,7 +880,7 @@ static char *get_sym_name(EXE_SYM *sym)
 }
 
 /* find a section index given its segname, sectname */
-static int find_mach_sec_index(struct section *section_hdr, int shnum, const char *segname, 
+static int find_mach_sec_index(struct section *section_hdr, int shnum, const char *segname,
                                   const char *sectname)
 {
     int i;
@@ -869,7 +896,7 @@ static int find_mach_sec_index(struct section *section_hdr, int shnum, const cha
 }
 
 /* find a section header given its segname, sectname */
-struct section *find_mach_sec_hdr(struct section *section_hdr, int shnum, const char *segname, 
+struct section *find_mach_sec_hdr(struct section *section_hdr, int shnum, const char *segname,
                                   const char *sectname)
 {
     int index = find_mach_sec_index(section_hdr, shnum, segname, sectname);
@@ -882,7 +909,7 @@ struct section *find_mach_sec_hdr(struct section *section_hdr, int shnum, const
 static inline void fetch_next_pair_value(struct relocation_info * rel, unsigned int *value)
 {
     struct scattered_relocation_info * scarel;
-       
+
     if(R_SCATTERED & rel->r_address) {
         scarel = (struct scattered_relocation_info*)rel;
         if(scarel->r_type != PPC_RELOC_PAIR)
@@ -899,7 +926,7 @@ static inline void fetch_next_pair_value(struct relocation_info * rel, unsigned
 static const char * find_sym_with_value_and_sec_number( int value, int sectnum, int * offset )
 {
        int i, ret = -1;
-       
+
        for( i = 0 ; i < nb_syms; i++ )
        {
            if( !(symtab[i].n_type & N_STAB) && (symtab[i].n_type & N_SECT) &&
@@ -918,35 +945,35 @@ static const char * find_sym_with_value_and_sec_number( int value, int sectnum,
        }
 }
 
-/* 
- *  Find symbol name given a (virtual) address, and a section which is of type 
+/*
+ *  Find symbol name given a (virtual) address, and a section which is of type
  *  S_NON_LAZY_SYMBOL_POINTERS or S_LAZY_SYMBOL_POINTERS or S_SYMBOL_STUBS
  */
 static const char * find_reloc_name_in_sec_ptr(int address, struct section * sec_hdr)
 {
     unsigned int tocindex, symindex, size;
     const char *name = 0;
-    
+
     /* Sanity check */
     if(!( address >= sec_hdr->addr && address < (sec_hdr->addr + sec_hdr->size) ) )
         return (char*)0;
-               
+
        if( sec_hdr->flags & S_SYMBOL_STUBS ){
                size = sec_hdr->reserved2;
                if(size == 0)
                    error("size = 0");
-               
+
        }
        else if( sec_hdr->flags & S_LAZY_SYMBOL_POINTERS ||
                    sec_hdr->flags & S_NON_LAZY_SYMBOL_POINTERS)
                size = sizeof(unsigned long);
        else
                return 0;
-               
+
     /* Compute our index in toc */
        tocindex = (address - sec_hdr->addr)/size;
        symindex = tocdylib[sec_hdr->reserved1 + tocindex];
-       
+
        name = get_sym_name(&symtab[symindex]);
 
     return name;
@@ -971,24 +998,24 @@ static const char * get_reloc_name(EXE_RELOC * rel, int * sslide)
        int sectnum = rel->r_symbolnum;
        int sectoffset;
        int other_half=0;
-       
+
        /* init the slide value */
        *sslide = 0;
-       
+
        if(R_SCATTERED & rel->r_address)
                return (char *)find_reloc_name_given_its_address(sca_rel->r_value);
 
        if(rel->r_extern)
        {
                /* ignore debug sym */
-               if ( symtab[rel->r_symbolnum].n_type & N_STAB ) 
+               if ( symtab[rel->r_symbolnum].n_type & N_STAB )
                        return 0;
                return get_sym_name(&symtab[rel->r_symbolnum]);
        }
 
        /* Intruction contains an offset to the symbols pointed to, in the rel->r_symbolnum section */
        sectoffset = *(uint32_t *)(text + rel->r_address) & 0xffff;
-                       
+
        if(sectnum==0xffffff)
                return 0;
 
@@ -1014,14 +1041,14 @@ static const char * get_reloc_name(EXE_RELOC * rel, int * sslide)
 
        if(rel->r_pcrel)
                sectoffset += rel->r_address;
-                       
+
        if (rel->r_type == PPC_RELOC_BR24)
                name = (char *)find_reloc_name_in_sec_ptr((int)sectoffset, &section_hdr[sectnum-1]);
 
        /* search it in the full symbol list, if not found */
        if(!name)
                name = (char *)find_sym_with_value_and_sec_number(sectoffset, sectnum, sslide);
-       
+
        return name;
 }
 
@@ -1053,11 +1080,11 @@ int load_object(const char *filename)
     unsigned int i, j;
        EXE_SYM *sym;
        struct nlist *syment;
-    
+
        fd = open(filename, O_RDONLY);
-    if (fd < 0) 
+    if (fd < 0)
         error("can't open file '%s'", filename);
-               
+
     /* Read Mach header.  */
     if (read(fd, &mach_hdr, sizeof (mach_hdr)) != sizeof (mach_hdr))
         error("unable to read file header");
@@ -1066,13 +1093,13 @@ int load_object(const char *filename)
     if (!check_mach_header(mach_hdr)) {
         error("bad Mach header");
     }
-    
+
     if (mach_hdr.cputype != CPU_TYPE_POWERPC)
         error("Unsupported CPU");
-        
+
     if (mach_hdr.filetype != MH_OBJECT)
         error("Unsupported Mach Object");
-    
+
     /* read segment headers */
     for(i=0, j=sizeof(mach_hdr); i<mach_hdr.ncmds ; i++)
     {
@@ -1116,26 +1143,26 @@ int load_object(const char *filename)
     /* read all section data */
     sdata = (uint8_t **)malloc(sizeof(void *) * segment->nsects);
     memset(sdata, 0, sizeof(void *) * segment->nsects);
-    
+
        /* Load the data in section data */
        for(i = 0; i < segment->nsects; i++) {
         sdata[i] = load_data(fd, section_hdr[i].offset, section_hdr[i].size);
     }
-       
+
     /* text section */
        text_sec_hdr = find_mach_sec_hdr(section_hdr, segment->nsects, SEG_TEXT, SECT_TEXT);
        i = find_mach_sec_index(section_hdr, segment->nsects, SEG_TEXT, SECT_TEXT);
        if (i == -1 || !text_sec_hdr)
         error("could not find __TEXT,__text section");
     text = sdata[i];
-       
+
     /* Make sure dysym was loaded */
     if(!(int)dysymtabcmd)
         error("could not find __DYSYMTAB segment");
-    
+
     /* read the table of content of the indirect sym */
     tocdylib = load_data( fd, dysymtabcmd->indirectsymoff, dysymtabcmd->nindirectsyms * sizeof(uint32_t) );
-    
+
     /* Make sure symtab was loaded  */
     if(!(int)symtabcmd)
         error("could not find __SYMTAB segment");
@@ -1143,20 +1170,20 @@ int load_object(const char *filename)
 
     symtab_std = load_data(fd, symtabcmd->symoff, symtabcmd->nsyms * sizeof(struct nlist));
     strtab = load_data(fd, symtabcmd->stroff, symtabcmd->strsize);
-       
+
        symtab = malloc(sizeof(EXE_SYM) * nb_syms);
-       
+
        /* Now transform the symtab, to an extended version, with the sym size, and the C name */
        for(i = 0, sym = symtab, syment = symtab_std; i < nb_syms; i++, sym++, syment++) {
         struct nlist *sym_follow, *sym_next = 0;
         unsigned int j;
                memset(sym, 0, sizeof(*sym));
-               
+
                if ( syment->n_type & N_STAB ) /* Debug symbols are skipped */
             continue;
-                       
+
                memcpy(sym, syment, sizeof(*syment));
-                       
+
                /* Find the following symbol in order to get the current symbol size */
         for(j = 0, sym_follow = symtab_std; j < nb_syms; j++, sym_follow++) {
             if ( sym_follow->n_sect != 1 || sym_follow->n_type & N_STAB || !(sym_follow->n_value > sym->st_value))
@@ -1174,7 +1201,7 @@ int load_object(const char *filename)
                else
             sym->st_size = text_sec_hdr->size - sym->st_value;
        }
-       
+
     /* Find Reloc */
     relocs = load_data(fd, text_sec_hdr->reloff, text_sec_hdr->nreloc * sizeof(struct relocation_info));
     nb_relocs = text_sec_hdr->nreloc;
@@ -1259,9 +1286,9 @@ int arm_emit_ldr_info(const char *name, unsigned long start_offset,
     uint8_t data_allocated[1024];
     unsigned int data_index;
     int type;
-    
+
     memset(data_allocated, 0, sizeof(data_allocated));
-    
+
     p = p_start;
     min_offset = p_end - p_start;
     spare = 0x7fffffff;
@@ -1304,25 +1331,25 @@ int arm_emit_ldr_info(const char *name, unsigned long start_offset,
             if (spare > max_pool - offset)
                 spare = max_pool - offset;
             if ((offset & 3) !=0)
-                error("%s:%04x: pc offset must be 32 bit aligned", 
+                error("%s:%04x: pc offset must be 32 bit aligned",
                       name, start_offset + p - p_start);
             if (offset < 0)
                 error("%s:%04x: Embedded literal value",
                       name, start_offset + p - p_start);
             pc_offset = p - p_start + offset + 8;
-            if (pc_offset <= (p - p_start) || 
+            if (pc_offset <= (p - p_start) ||
                 pc_offset >= (p_end - p_start))
-                error("%s:%04x: pc offset must point inside the function code", 
+                error("%s:%04x: pc offset must point inside the function code",
                       name, start_offset + p - p_start);
             if (pc_offset < min_offset)
                 min_offset = pc_offset;
             if (outfile) {
                 /* The intruction position */
-                fprintf(outfile, "    arm_ldr_ptr->ptr = gen_code_ptr + %d;\n", 
+                fprintf(outfile, "    arm_ldr_ptr->ptr = gen_code_ptr + %d;\n",
                         p - p_start);
                 /* The position of the constant pool data.  */
                 data_index = ((p_end - p_start) - pc_offset) >> 2;
-                fprintf(outfile, "    arm_ldr_ptr->data_ptr = arm_data_ptr - %d;\n", 
+                fprintf(outfile, "    arm_ldr_ptr->data_ptr = arm_data_ptr - %d;\n",
                         data_index);
                 fprintf(outfile, "    arm_ldr_ptr->type = %d;\n", type);
                 fprintf(outfile, "    arm_ldr_ptr++;\n");
@@ -1405,7 +1432,7 @@ int arm_emit_ldr_info(const char *name, unsigned long start_offset,
 #define MAX_ARGS 3
 
 /* generate op code */
-void gen_code(const char *name, host_ulong offset, host_ulong size, 
+void gen_code(const char *name, host_ulong offset, host_ulong size,
               FILE *outfile, int gen_switch)
 {
     int copy_size = 0;
@@ -1451,7 +1478,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
         }
         copy_size = len;
     }
-#endif    
+#endif
 #elif defined(HOST_PPC)
     {
         uint8_t *p;
@@ -1483,7 +1510,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
 #endif
         if (get32((uint32_t *)p) != 0x6bfa8001)
             error("ret expected at the end of %s", name);
-        copy_size = p - p_start;           
+        copy_size = p - p_start;
     }
 #elif defined(HOST_IA64)
     {
@@ -1584,14 +1611,14 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
         } else {
             error("No save at the beginning of %s", name);
         }
-        
+
         /* Skip a preceeding nop, if present.  */
         if (p > p_start) {
             skip_insn = get32((uint32_t *)(p - 0x4));
             if (skip_insn == 0x01000000)
                 p -= 4;
         }
-        
+
         copy_size = p - p_start;
     }
 #elif defined(HOST_ARM)
@@ -1612,7 +1639,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
             p_start -= 4;
             start_offset -= 4;
         }
-        copy_size = arm_emit_ldr_info(name, start_offset, NULL, p_start, p_end, 
+        copy_size = arm_emit_ldr_info(name, start_offset, NULL, p_start, p_end,
                                       relocs, nb_relocs);
     }
 #elif defined(HOST_M68K)
@@ -1623,12 +1650,32 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
             error("empty code for %s", name);
         // remove NOP's, probably added for alignment
         while ((get16((uint16_t *)p) == 0x4e71) &&
-               (p>p_start)) 
+               (p>p_start))
             p -= 2;
         if (get16((uint16_t *)p) != 0x4e75)
             error("rts expected at the end of %s", name);
         copy_size = p - p_start;
     }
+#elif defined(HOST_MIPS) || defined(HOST_MIPS64)
+    {
+#define INSN_RETURN     0x03e00008
+#define INSN_NOP        0x00000000
+
+        uint8_t *p = p_end;
+
+        if (p < (p_start + 0x8)) {
+            error("empty code for %s", name);
+        } else {
+            uint32_t end_insn1, end_insn2;
+
+            p -= 0x8;
+            end_insn1 = get32((uint32_t *)(p + 0x0));
+            end_insn2 = get32((uint32_t *)(p + 0x4));
+            if (end_insn1 != INSN_RETURN && end_insn2 != INSN_NOP)
+                error("jr ra not found at end of %s", name);
+        }
+        copy_size = p - p_start;
+    }
 #else
 #error unsupported CPU
 #endif
@@ -1653,7 +1700,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
             }
         }
     }
-    
+
     nb_args = 0;
     while (nb_args < MAX_ARGS && args_present[nb_args])
         nb_args++;
@@ -1690,7 +1737,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                 sym_name = get_rel_sym_name(rel);
                 if(!sym_name)
                     continue;
-                if (*sym_name && 
+                if (*sym_name &&
                     !strstart(sym_name, "__op_param", NULL) &&
                     !strstart(sym_name, "__op_jmp", NULL) &&
                     !strstart(sym_name, "__op_gen_label", NULL)) {
@@ -1703,8 +1750,9 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                    }
 #endif
 #if defined(__APPLE__)
-/* set __attribute((unused)) on darwin because we wan't to avoid warning when we don't use the symbol */
-                    fprintf(outfile, "extern char %s __attribute__((unused));\n", sym_name);
+                    /* Set __attribute((unused)) on darwin because we
+                       want to avoid warning when we don't use the symbol.  */
+                    fprintf(outfile, "    extern char %s __attribute__((unused));\n", sym_name);
 #elif defined(HOST_IA64)
                        if (ELF64_R_TYPE(rel->r_info) != R_IA64_PCREL21B)
                                /*
@@ -1728,7 +1776,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
         {
             EXE_SYM *sym;
             const char *sym_name, *p;
-            unsigned long val;
+            host_ulong val;
             int n;
 
             for(i = 0, sym = symtab; i < nb_syms; i++, sym++) {
@@ -1736,7 +1784,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                 if (strstart(sym_name, "__op_label", &p)) {
                     uint8_t *ptr;
                     unsigned long offset;
-                    
+
                     /* test if the variable refers to a label inside
                        the code we are generating */
 #ifdef CONFIG_FORMAT_COFF
@@ -1760,7 +1808,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
 #ifdef CONFIG_FORMAT_MACH
                     offset -= section_hdr[sym->n_sect-1].addr;
 #endif
-                    val = *(unsigned long *)(ptr + offset);
+                    val = *(host_ulong *)(ptr + offset);
 #ifdef ELF_USES_RELOCA
                     {
                         int reloc_shndx, nb_relocs1, j;
@@ -1768,7 +1816,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                         /* try to find a matching relocation */
                         reloc_shndx = find_reloc(sym->st_shndx);
                         if (reloc_shndx) {
-                            nb_relocs1 = shdr[reloc_shndx].sh_size / 
+                            nb_relocs1 = shdr[reloc_shndx].sh_size /
                                 shdr[reloc_shndx].sh_entsize;
                             rel = (ELF_RELOC *)sdata[reloc_shndx];
                             for(j = 0; j < nb_relocs1; j++) {
@@ -1780,7 +1828,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                             }
                         }
                     }
-#endif                    
+#endif
                     if (val >= start_offset && val <= start_offset + copy_size) {
                         n = strtol(p, NULL, 10);
                         fprintf(outfile, "    label_offsets[%d] = %ld + (gen_code_ptr - gen_code_buf);\n", n, (long)(val - start_offset));
@@ -1789,7 +1837,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
             }
         }
 
-        /* load parameres in variables */
+        /* load parameters in variables */
         for(i = 0; i < nb_args; i++) {
             fprintf(outfile, "    param%d = *opparam_ptr++;\n", i + 1);
         }
@@ -1797,7 +1845,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
         /* patch relocations */
 #if defined(HOST_I386)
             {
-                char name[256];
+                char relname[256];
                 int type;
                 int addend;
                 int reloc_offset;
@@ -1820,18 +1868,18 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                         continue;
                     }
 
-                    get_reloc_expr(name, sizeof(name), sym_name);
+                    get_reloc_expr(relname, sizeof(relname), sym_name);
                     addend = get32((uint32_t *)(text + rel->r_offset));
 #ifdef CONFIG_FORMAT_ELF
                     type = ELF32_R_TYPE(rel->r_info);
                     switch(type) {
                     case R_386_32:
-                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", 
-                                reloc_offset, name, addend);
+                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",
+                                reloc_offset, relname, addend);
                         break;
                     case R_386_PC32:
-                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %d) + %d;\n", 
-                                reloc_offset, name, reloc_offset, addend);
+                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %d) + %d;\n",
+                                reloc_offset, relname, reloc_offset, addend);
                         break;
                     default:
                         error("unsupported i386 relocation (%d)", type);
@@ -1853,12 +1901,12 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                     type = rel->r_type;
                     switch(type) {
                     case DIR32:
-                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", 
-                                reloc_offset, name, addend);
+                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",
+                                reloc_offset, relname, addend);
                         break;
                     case DISP32:
-                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %d) + %d -4;\n", 
-                                reloc_offset, name, reloc_offset, addend);
+                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %d) + %d -4;\n",
+                                reloc_offset, relname, reloc_offset, addend);
                         break;
                     default:
                         error("unsupported i386 relocation (%d)", type);
@@ -1871,7 +1919,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
             }
 #elif defined(HOST_X86_64)
             {
-                char name[256];
+                char relname[256];
                 int type;
                 int addend;
                 int reloc_offset;
@@ -1879,22 +1927,22 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                 if (rel->r_offset >= start_offset &&
                    rel->r_offset < start_offset + copy_size) {
                     sym_name = strtab + symtab[ELFW(R_SYM)(rel->r_info)].st_name;
-                    get_reloc_expr(name, sizeof(name), sym_name);
+                    get_reloc_expr(relname, sizeof(relname), sym_name);
                     type = ELF32_R_TYPE(rel->r_info);
                     addend = rel->r_addend;
                     reloc_offset = rel->r_offset - start_offset;
                     switch(type) {
                     case R_X86_64_32:
-                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = (uint32_t)%s + %d;\n", 
-                                reloc_offset, name, addend);
+                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = (uint32_t)%s + %d;\n",
+                                reloc_offset, relname, addend);
                         break;
                     case R_X86_64_32S:
-                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = (int32_t)%s + %d;\n", 
-                                reloc_offset, name, addend);
+                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = (int32_t)%s + %d;\n",
+                                reloc_offset, relname, addend);
                         break;
                     case R_X86_64_PC32:
-                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %d) + %d;\n", 
-                                reloc_offset, name, reloc_offset, addend);
+                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %d) + %d;\n",
+                                reloc_offset, relname, reloc_offset, addend);
                         break;
                     default:
                         error("unsupported X86_64 relocation (%d)", type);
@@ -1905,7 +1953,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
 #elif defined(HOST_PPC)
             {
 #ifdef CONFIG_FORMAT_ELF
-                char name[256];
+                char relname[256];
                 int type;
                 int addend;
                 int reloc_offset;
@@ -1925,31 +1973,31 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                                     n, reloc_offset);
                             continue;
                         }
-                        
-                        get_reloc_expr(name, sizeof(name), sym_name);
+
+                        get_reloc_expr(relname, sizeof(relname), sym_name);
                         type = ELF32_R_TYPE(rel->r_info);
                         addend = rel->r_addend;
                         switch(type) {
                         case R_PPC_ADDR32:
-                            fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", 
-                                    reloc_offset, name, addend);
+                            fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",
+                                    reloc_offset, relname, addend);
                             break;
                         case R_PPC_ADDR16_LO:
-                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = (%s + %d);\n", 
-                                    reloc_offset, name, addend);
+                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = (%s + %d);\n",
+                                    reloc_offset, relname, addend);
                             break;
                         case R_PPC_ADDR16_HI:
-                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = (%s + %d) >> 16;\n", 
-                                    reloc_offset, name, addend);
+                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = (%s + %d) >> 16;\n",
+                                    reloc_offset, relname, addend);
                             break;
                         case R_PPC_ADDR16_HA:
-                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = (%s + %d + 0x8000) >> 16;\n", 
-                                    reloc_offset, name, addend);
+                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = (%s + %d + 0x8000) >> 16;\n",
+                                    reloc_offset, relname, addend);
                             break;
                         case R_PPC_REL24:
                             /* warning: must be at 32 MB distancy */
-                            fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = (*(uint32_t *)(gen_code_ptr + %d) & ~0x03fffffc) | ((%s - (long)(gen_code_ptr + %d) + %d) & 0x03fffffc);\n", 
-                                    reloc_offset, reloc_offset, name, reloc_offset, addend);
+                            fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = (*(uint32_t *)(gen_code_ptr + %d) & ~0x03fffffc) | ((%s - (long)(gen_code_ptr + %d) + %d) & 0x03fffffc);\n",
+                                    reloc_offset, reloc_offset, relname, reloc_offset, addend);
                             break;
                         default:
                             error("unsupported powerpc relocation (%d)", type);
@@ -1957,98 +2005,97 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                     }
                 }
 #elif defined(CONFIG_FORMAT_MACH)
-                               struct scattered_relocation_info *scarel;
-                               struct relocation_info * rel;
-                               char final_sym_name[256];
-                               const char *sym_name;
-                               const char *p;
-                               int slide, sslide;
-                               int i;
-       
-                               for(i = 0, rel = relocs; i < nb_relocs; i++, rel++) {
-                                       unsigned int offset, length, value = 0;
-                                       unsigned int type, pcrel, isym = 0;
-                                       unsigned int usesym = 0;
-                               
-                                       if(R_SCATTERED & rel->r_address) {
-                                               scarel = (struct scattered_relocation_info*)rel;
-                                               offset = (unsigned int)scarel->r_address;
-                                               length = scarel->r_length;
-                                               pcrel = scarel->r_pcrel;
-                                               type = scarel->r_type;
-                                               value = scarel->r_value;
-                                       } else {
-                                               value = isym = rel->r_symbolnum;
-                                               usesym = (rel->r_extern);
-                                               offset = rel->r_address;
-                                               length = rel->r_length;
-                                               pcrel = rel->r_pcrel;
-                                               type = rel->r_type;
-                                       }
-                               
-                                       slide = offset - start_offset;
-               
-                                       if (!(offset >= start_offset && offset < start_offset + size)) 
-                                               continue;  /* not in our range */
-
-                                       sym_name = get_reloc_name(rel, &sslide);
-                                       
-                                       if(usesym && symtab[isym].n_type & N_STAB)
-                                               continue; /* don't handle STAB (debug sym) */
-                                       
-                                       if (sym_name && strstart(sym_name, "__op_jmp", &p)) {
-                                               int n;
-                                               n = strtol(p, NULL, 10);
-                                               fprintf(outfile, "    jmp_offsets[%d] = %d + (gen_code_ptr - gen_code_buf);\n",
-                                                       n, slide);
-                                               continue; /* Nothing more to do */
-                                       }
-                                       
-                                       if(!sym_name)
-                                       {
-                                               fprintf(outfile, "/* #warning relocation not handled in %s (value 0x%x, %s, offset 0x%x, length 0x%x, %s, type 0x%x) */\n",
-                                                          name, value, usesym ? "use sym" : "don't use sym", offset, length, pcrel ? "pcrel":"", type);
-                                               continue; /* dunno how to handle without final_sym_name */
-                                       }
-                                                                                                          
-                                        get_reloc_expr(final_sym_name, sizeof(final_sym_name), 
-                                                       sym_name);
-                                       switch(type) {
-                                       case PPC_RELOC_BR24:
-                                           if (!strstart(sym_name,"__op_gen_label",&p)) {
-                                               fprintf(outfile, "{\n");
-                                               fprintf(outfile, "    uint32_t imm = *(uint32_t *)(gen_code_ptr + %d) & 0x3fffffc;\n", slide);
-                                               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", 
-                                                                                       slide, slide, name, sslide );
-                                               fprintf(outfile, "}\n");
-                                       } else {
-                                                       fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = (*(uint32_t *)(gen_code_ptr + %d) & ~0x03fffffc) | (((long)%s - (long)gen_code_ptr - %d) & 0x03fffffc);\n",
-                                                                                       slide, slide, final_sym_name, slide);
-                                       }
-                                               break;
-                                       case PPC_RELOC_HI16:
-                                               fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d + 2) = (%s + %d) >> 16;\n", 
-                                                       slide, final_sym_name, sslide);
-                                               break;
-                                       case PPC_RELOC_LO16:
-                                               fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d + 2) = (%s + %d);\n", 
-                                       slide, final_sym_name, sslide);
+                struct scattered_relocation_info *scarel;
+                struct relocation_info * rel;
+                char final_sym_name[256];
+                const char *sym_name;
+                const char *p;
+                int slide, sslide;
+                int i;
+
+                for(i = 0, rel = relocs; i < nb_relocs; i++, rel++) {
+                    unsigned int offset, length, value = 0;
+                    unsigned int type, pcrel, isym = 0;
+                    unsigned int usesym = 0;
+
+                    if(R_SCATTERED & rel->r_address) {
+                        scarel = (struct scattered_relocation_info*)rel;
+                        offset = (unsigned int)scarel->r_address;
+                        length = scarel->r_length;
+                        pcrel = scarel->r_pcrel;
+                        type = scarel->r_type;
+                        value = scarel->r_value;
+                    } else {
+                        value = isym = rel->r_symbolnum;
+                        usesym = (rel->r_extern);
+                        offset = rel->r_address;
+                        length = rel->r_length;
+                        pcrel = rel->r_pcrel;
+                        type = rel->r_type;
+                    }
+
+                    slide = offset - start_offset;
+
+                    if (!(offset >= start_offset && offset < start_offset + size))
+                        continue;  /* not in our range */
+
+                        sym_name = get_reloc_name(rel, &sslide);
+
+                        if(usesym && symtab[isym].n_type & N_STAB)
+                            continue; /* don't handle STAB (debug sym) */
+
+                        if (sym_name && strstart(sym_name, "__op_jmp", &p)) {
+                            int n;
+                            n = strtol(p, NULL, 10);
+                            fprintf(outfile, "    jmp_offsets[%d] = %d + (gen_code_ptr - gen_code_buf);\n",
+                                    n, slide);
+                            continue; /* Nothing more to do */
+                        }
+
+                        if(!sym_name) {
+                            fprintf(outfile, "/* #warning relocation not handled in %s (value 0x%x, %s, offset 0x%x, length 0x%x, %s, type 0x%x) */\n",
+                                    name, value, usesym ? "use sym" : "don't use sym", offset, length, pcrel ? "pcrel":"", type);
+                            continue; /* dunno how to handle without final_sym_name */
+                        }
+
+                        get_reloc_expr(final_sym_name, sizeof(final_sym_name),
+                                       sym_name);
+                        switch(type) {
+                        case PPC_RELOC_BR24:
+                            if (!strstart(sym_name,"__op_gen_label",&p)) {
+                                fprintf(outfile, "{\n");
+                                fprintf(outfile, "    uint32_t imm = *(uint32_t *)(gen_code_ptr + %d) & 0x3fffffc;\n", slide);
+                                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",
+                                        slide, slide, name, sslide);
+                                fprintf(outfile, "}\n");
+                            } else {
+                                fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = (*(uint32_t *)(gen_code_ptr + %d) & ~0x03fffffc) | (((long)%s - (long)gen_code_ptr - %d) & 0x03fffffc);\n",
+                                        slide, slide, final_sym_name, slide);
+                            }
                             break;
-                                       case PPC_RELOC_HA16:
-                                               fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d + 2) = (%s + %d + 0x8000) >> 16;\n", 
-                                                       slide, final_sym_name, sslide);
-                                               break;
-                               default:
-                                       error("unsupported powerpc relocation (%d)", type);
-                               }
-                       }
+                        case PPC_RELOC_HI16:
+                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d + 2) = (%s + %d) >> 16;\n",
+                                    slide, final_sym_name, sslide);
+                            break;
+                        case PPC_RELOC_LO16:
+                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d + 2) = (%s + %d);\n",
+                                    slide, final_sym_name, sslide);
+                            break;
+                        case PPC_RELOC_HA16:
+                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d + 2) = (%s + %d + 0x8000) >> 16;\n",
+                                    slide, final_sym_name, sslide);
+                            break;
+                        default:
+                            error("unsupported powerpc relocation (%d)", type);
+                    }
+                }
 #else
 #error unsupport object format
 #endif
             }
 #elif defined(HOST_S390)
             {
-                char name[256];
+                char relname[256];
                 int type;
                 int addend;
                 int reloc_offset;
@@ -2056,22 +2103,22 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                     if (rel->r_offset >= start_offset &&
                        rel->r_offset < start_offset + copy_size) {
                         sym_name = strtab + symtab[ELFW(R_SYM)(rel->r_info)].st_name;
-                        get_reloc_expr(name, sizeof(name), sym_name);
+                        get_reloc_expr(relname, sizeof(relname), sym_name);
                         type = ELF32_R_TYPE(rel->r_info);
                         addend = rel->r_addend;
                         reloc_offset = rel->r_offset - start_offset;
                         switch(type) {
                         case R_390_32:
-                            fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", 
-                                    reloc_offset, name, addend);
+                            fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",
+                                    reloc_offset, relname, addend);
                             break;
                         case R_390_16:
-                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = %s + %d;\n", 
-                                    reloc_offset, name, addend);
+                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = %s + %d;\n",
+                                    reloc_offset, relname, addend);
                             break;
                         case R_390_8:
-                            fprintf(outfile, "    *(uint8_t *)(gen_code_ptr + %d) = %s + %d;\n", 
-                                    reloc_offset, name, addend);
+                            fprintf(outfile, "    *(uint8_t *)(gen_code_ptr + %d) = %s + %d;\n",
+                                    reloc_offset, relname, addend);
                             break;
                         default:
                             error("unsupported s390 relocation (%d)", type);
@@ -2139,7 +2186,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
             {
                unsigned long sym_idx;
                long code_offset;
-                char name[256];
+                char relname[256];
                 int type;
                 long addend;
 
@@ -2162,7 +2209,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                                n, code_offset);
                        continue;
                    }
-                   get_reloc_expr(name, sizeof(name), sym_name);
+                   get_reloc_expr(relname, sizeof(relname), sym_name);
                    type = ELF64_R_TYPE(rel->r_info);
                    addend = rel->r_addend;
                    switch(type) {
@@ -2170,19 +2217,19 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                          fprintf(outfile,
                                  "    ia64_imm64(gen_code_ptr + %ld, "
                                  "%s + %ld);\n",
-                                 code_offset, name, addend);
+                                 code_offset, relname, addend);
                          break;
                      case R_IA64_LTOFF22X:
                      case R_IA64_LTOFF22:
                          fprintf(outfile, "    IA64_LTOFF(gen_code_ptr + %ld,"
                                  " %s + %ld, %d);\n",
-                                 code_offset, name, addend,
+                                 code_offset, relname, addend,
                                  (type == R_IA64_LTOFF22X));
                          break;
                      case R_IA64_LDXMOV:
                          fprintf(outfile,
                                  "    ia64_ldxmov(gen_code_ptr + %ld,"
-                                 " %s + %ld);\n", code_offset, name, addend);
+                                 " %s + %ld);\n", code_offset, relname, addend);
                          break;
 
                      case R_IA64_PCREL21B:
@@ -2191,7 +2238,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                                      "    ia64_imm21b(gen_code_ptr + %ld,"
                                      " (long) (%s + %ld -\n\t\t"
                                      "((long) gen_code_ptr + %ld)) >> 4);\n",
-                                     code_offset, name, addend,
+                                     code_offset, relname, addend,
                                      code_offset & ~0xfUL);
                          } else {
                              fprintf(outfile,
@@ -2212,7 +2259,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
             }
 #elif defined(HOST_SPARC)
             {
-                char name[256];
+                char relname[256];
                 int type;
                 int addend;
                 int reloc_offset;
@@ -2220,14 +2267,14 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                     if (rel->r_offset >= start_offset &&
                        rel->r_offset < start_offset + copy_size) {
                         sym_name = strtab + symtab[ELF32_R_SYM(rel->r_info)].st_name;
-                        get_reloc_expr(name, sizeof(name), sym_name);
+                        get_reloc_expr(relname, sizeof(relname), sym_name);
                         type = ELF32_R_TYPE(rel->r_info);
                         addend = rel->r_addend;
                         reloc_offset = rel->r_offset - start_offset;
                         switch(type) {
                         case R_SPARC_32:
-                            fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", 
-                                    reloc_offset, name, addend);
+                            fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",
+                                    reloc_offset, relname, addend);
                            break;
                        case R_SPARC_HI22:
                             fprintf(outfile,
@@ -2235,7 +2282,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                                    "((*(uint32_t *)(gen_code_ptr + %d)) "
                                    " & ~0x3fffff) "
                                    " | (((%s + %d) >> 10) & 0x3fffff);\n",
-                                    reloc_offset, reloc_offset, name, addend);
+                                    reloc_offset, reloc_offset, relname, addend);
                            break;
                        case R_SPARC_LO10:
                             fprintf(outfile,
@@ -2243,7 +2290,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                                    "((*(uint32_t *)(gen_code_ptr + %d)) "
                                    " & ~0x3ff) "
                                    " | ((%s + %d) & 0x3ff);\n",
-                                    reloc_offset, reloc_offset, name, addend);
+                                    reloc_offset, reloc_offset, relname, addend);
                            break;
                        case R_SPARC_WDISP30:
                            fprintf(outfile,
@@ -2252,7 +2299,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                                    " & ~0x3fffffff) "
                                    " | ((((%s + %d) - (long)(gen_code_ptr + %d))>>2) "
                                    "    & 0x3fffffff);\n",
-                                   reloc_offset, reloc_offset, name, addend,
+                                   reloc_offset, reloc_offset, relname, addend,
                                    reloc_offset);
                            break;
                         case R_SPARC_WDISP22:
@@ -2264,7 +2311,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                                     "    & 0x3fffff);\n",
                                     rel->r_offset - start_offset,
                                     rel->r_offset - start_offset,
-                                    name, addend,
+                                    relname, addend,
                                     rel->r_offset - start_offset);
                             break;
                         default:
@@ -2275,7 +2322,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
             }
 #elif defined(HOST_SPARC64)
             {
-                char name[256];
+                char relname[256];
                 int type;
                 int addend;
                 int reloc_offset;
@@ -2283,14 +2330,14 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                     if (rel->r_offset >= start_offset &&
                        rel->r_offset < start_offset + copy_size) {
                         sym_name = strtab + symtab[ELF64_R_SYM(rel->r_info)].st_name;
-                        get_reloc_expr(name, sizeof(name), sym_name);
+                        get_reloc_expr(relname, sizeof(relname), sym_name);
                         type = ELF32_R_TYPE(rel->r_info);
                         addend = rel->r_addend;
                         reloc_offset = rel->r_offset - start_offset;
                         switch(type) {
                         case R_SPARC_32:
                             fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",
-                                    reloc_offset, name, addend);
+                                    reloc_offset, relname, addend);
                            break;
                        case R_SPARC_HI22:
                             fprintf(outfile,
@@ -2298,7 +2345,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                                    "((*(uint32_t *)(gen_code_ptr + %d)) "
                                    " & ~0x3fffff) "
                                    " | (((%s + %d) >> 10) & 0x3fffff);\n",
-                                    reloc_offset, reloc_offset, name, addend);
+                                    reloc_offset, reloc_offset, relname, addend);
                            break;
                        case R_SPARC_LO10:
                             fprintf(outfile,
@@ -2306,7 +2353,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                                    "((*(uint32_t *)(gen_code_ptr + %d)) "
                                    " & ~0x3ff) "
                                    " | ((%s + %d) & 0x3ff);\n",
-                                    reloc_offset, reloc_offset, name, addend);
+                                    reloc_offset, reloc_offset, relname, addend);
                            break;
                         case R_SPARC_OLO10:
                             addend += ELF64_R_TYPE_DATA (rel->r_info);
@@ -2315,7 +2362,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                                    "((*(uint32_t *)(gen_code_ptr + %d)) "
                                    " & ~0x3ff) "
                                    " | ((%s + %d) & 0x3ff);\n",
-                                    reloc_offset, reloc_offset, name, addend);
+                                    reloc_offset, reloc_offset, relname, addend);
                            break;
                        case R_SPARC_WDISP30:
                            fprintf(outfile,
@@ -2324,7 +2371,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                                    " & ~0x3fffffff) "
                                    " | ((((%s + %d) - (long)(gen_code_ptr + %d))>>2) "
                                    "    & 0x3fffffff);\n",
-                                   reloc_offset, reloc_offset, name, addend,
+                                   reloc_offset, reloc_offset, relname, addend,
                                    reloc_offset);
                            break;
                         case R_SPARC_WDISP22:
@@ -2334,18 +2381,45 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                                     " & ~0x3fffff) "
                                     " | ((((%s + %d) - (long)(gen_code_ptr + %d))>>2) "
                                     "    & 0x3fffff);\n",
-                                    reloc_offset, reloc_offset, name, addend,
+                                    reloc_offset, reloc_offset, relname, addend,
                                    reloc_offset);
                             break;
+                        case R_SPARC_HH22:
+                            fprintf(outfile,
+                                   "    *(uint32_t *)(gen_code_ptr + %d) = "
+                                   "((*(uint32_t *)(gen_code_ptr + %d)) "
+                                   " & ~0x00000000) "
+                                   " | (((%s + %d) >> 42) & 0x00000000);\n",
+                                    reloc_offset, reloc_offset, relname, addend);
+                             break;
+
+                       case R_SPARC_LM22:
+                            fprintf(outfile,
+                                   "    *(uint32_t *)(gen_code_ptr + %d) = "
+                                   "((*(uint32_t *)(gen_code_ptr + %d)) "
+                                   " & ~0x00000000) "
+                                   " | (((%s + %d) >> 10) & 0x00000000);\n",
+                                    reloc_offset, reloc_offset, relname, addend);
+                           break;
+
+                       case R_SPARC_HM10:
+                            fprintf(outfile,
+                                   "    *(uint32_t *)(gen_code_ptr + %d) = "
+                                   "((*(uint32_t *)(gen_code_ptr + %d)) "
+                                   " & ~0x00000000) "
+                                   " | ((((%s + %d) >> 32 & 0x3ff)) & 0x00000000);\n",
+                                    reloc_offset, reloc_offset, relname, addend);
+                           break;
+
                         default:
-                           error("unsupported sparc64 relocation (%d) for symbol %s", type, name);
+                           error("unsupported sparc64 relocation (%d) for symbol %s", type, relname);
                         }
                     }
                 }
             }
 #elif defined(HOST_ARM)
             {
-                char name[256];
+                char relname[256];
                 int type;
                 int addend;
                 int reloc_offset;
@@ -2380,7 +2454,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                     fprintf(outfile,
                             "    *(uint32_t *)gen_code_ptr = 0x%x;\n", opcode);
                 }
-                arm_emit_ldr_info(name, start_offset, outfile, p_start, p_end,
+                arm_emit_ldr_info(relname, start_offset, outfile, p_start, p_end,
                                   relocs, nb_relocs);
 
                 for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {
@@ -2390,20 +2464,20 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                     /* the compiler leave some unnecessary references to the code */
                     if (sym_name[0] == '\0')
                         continue;
-                    get_reloc_expr(name, sizeof(name), sym_name);
+                    get_reloc_expr(relname, sizeof(relname), sym_name);
                     type = ELF32_R_TYPE(rel->r_info);
                     addend = get32((uint32_t *)(text + rel->r_offset));
                     reloc_offset = rel->r_offset - start_offset;
                     switch(type) {
                     case R_ARM_ABS32:
-                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", 
-                                reloc_offset, name, addend);
+                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n",
+                                reloc_offset, relname, addend);
                         break;
                     case R_ARM_PC24:
                     case R_ARM_JUMP24:
                     case R_ARM_CALL:
-                        fprintf(outfile, "    arm_reloc_pc24((uint32_t *)(gen_code_ptr + %d), 0x%x, %s);\n", 
-                                reloc_offset, addend, name);
+                        fprintf(outfile, "    arm_reloc_pc24((uint32_t *)(gen_code_ptr + %d), 0x%x, %s);\n",
+                                reloc_offset, addend, relname);
                         break;
                     default:
                         error("unsupported arm relocation (%d)", type);
@@ -2413,7 +2487,7 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
             }
 #elif defined(HOST_M68K)
             {
-                char name[256];
+                char relname[256];
                 int type;
                 int addend;
                 int reloc_offset;
@@ -2423,20 +2497,20 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                    rel->r_offset < start_offset + copy_size) {
                    sym = &(symtab[ELFW(R_SYM)(rel->r_info)]);
                     sym_name = strtab + symtab[ELFW(R_SYM)(rel->r_info)].st_name;
-                    get_reloc_expr(name, sizeof(name), sym_name);
+                    get_reloc_expr(relname, sizeof(relname), sym_name);
                     type = ELF32_R_TYPE(rel->r_info);
                     addend = get32((uint32_t *)(text + rel->r_offset)) + rel->r_addend;
                     reloc_offset = rel->r_offset - start_offset;
                     switch(type) {
                     case R_68K_32:
                        fprintf(outfile, "    /* R_68K_32 RELOC, offset %x */\n", rel->r_offset) ;
-                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %#x;\n", 
-                                reloc_offset, name, addend );
+                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %#x;\n",
+                                reloc_offset, relname, addend );
                         break;
                     case R_68K_PC32:
                        fprintf(outfile, "    /* R_68K_PC32 RELOC, offset %x */\n", rel->r_offset);
-                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %#x) + %#x;\n", 
-                                reloc_offset, name, reloc_offset, /*sym->st_value+*/ addend);
+                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %#x) + %#x;\n",
+                                reloc_offset, relname, reloc_offset, /*sym->st_value+*/ addend);
                         break;
                     default:
                         error("unsupported m68k relocation (%d)", type);
@@ -2444,6 +2518,81 @@ void gen_code(const char *name, host_ulong offset, host_ulong size,
                 }
                 }
             }
+#elif defined(HOST_MIPS) || defined(HOST_MIPS64)
+            {
+                for (i = 0, rel = relocs; i < nb_relocs; i++, rel++) {
+                   if (rel->r_offset >= start_offset && rel->r_offset < start_offset + copy_size) {
+                        char relname[256];
+                        int type;
+                        int addend;
+                        int reloc_offset;
+
+                       sym_name = strtab + symtab[ELF32_R_SYM(rel->r_info)].st_name;
+                        /* the compiler leave some unnecessary references to the code */
+                        if (sym_name[0] == '\0')
+                            continue;
+                        get_reloc_expr(relname, sizeof(relname), sym_name);
+                       type = ELF32_R_TYPE(rel->r_info);
+                        addend = get32((uint32_t *)(text + rel->r_offset));
+                        reloc_offset = rel->r_offset - start_offset;
+                       switch (type) {
+                       case R_MIPS_26:
+                            fprintf(outfile, "    /* R_MIPS_26 RELOC, offset 0x%x, name %s */\n",
+                                   rel->r_offset, sym_name);
+                            fprintf(outfile,
+                                   "    *(uint32_t *)(gen_code_ptr + 0x%x) = "
+                                   "(0x%x & ~0x3fffff) "
+                                   "| ((0x%x + ((%s - (*(uint32_t *)(gen_code_ptr + 0x%x))) >> 2)) "
+                                   "   & 0x3fffff);\n",
+                                    reloc_offset, addend, addend, relname, reloc_offset);
+                           break;
+                       case R_MIPS_HI16:
+                            fprintf(outfile, "    /* R_MIPS_HI16 RELOC, offset 0x%x, name %s */\n",
+                                   rel->r_offset, sym_name);
+                            fprintf(outfile,
+                                   "    *(uint32_t *)(gen_code_ptr + 0x%x) = "
+                                   "((*(uint32_t *)(gen_code_ptr + 0x%x)) "
+                                   " & ~0xffff) "
+                                   " | (((%s - 0x8000) >> 16) & 0xffff);\n",
+                                    reloc_offset, reloc_offset, relname);
+                           break;
+                       case R_MIPS_LO16:
+                            fprintf(outfile, "    /* R_MIPS_LO16 RELOC, offset 0x%x, name %s */\n",
+                                   rel->r_offset, sym_name);
+                            fprintf(outfile,
+                                   "    *(uint32_t *)(gen_code_ptr + 0x%x) = "
+                                   "((*(uint32_t *)(gen_code_ptr + 0x%x)) "
+                                   " & ~0xffff) "
+                                   " | (%s & 0xffff);\n",
+                                    reloc_offset, reloc_offset, relname);
+                           break;
+                       case R_MIPS_PC16:
+                            fprintf(outfile, "    /* R_MIPS_PC16 RELOC, offset 0x%x, name %s */\n",
+                                   rel->r_offset, sym_name);
+                            fprintf(outfile,
+                                   "    *(uint32_t *)(gen_code_ptr + 0x%x) = "
+                                   "(0x%x & ~0xffff) "
+                                   "| ((0x%x + ((%s - (*(uint32_t *)(gen_code_ptr + 0x%x))) >> 2)) "
+                                   "   & 0xffff);\n",
+                                    reloc_offset, addend, addend, relname, reloc_offset);
+                           break;
+                       case R_MIPS_GOT16:
+                       case R_MIPS_CALL16:
+                            fprintf(outfile, "    /* R_MIPS_GOT16 RELOC, offset 0x%x, name %s */\n",
+                                   rel->r_offset, sym_name);
+                            fprintf(outfile,
+                                   "    *(uint32_t *)(gen_code_ptr + 0x%x) = "
+                                   "((*(uint32_t *)(gen_code_ptr + 0x%x)) "
+                                   " & ~0xffff) "
+                                   " | (((%s - 0x8000) >> 16) & 0xffff);\n",
+                                    reloc_offset, reloc_offset, relname);
+                           break;
+                       default:
+                           error("unsupported MIPS relocation (%d)", type);
+                       }
+                   }
+                }
+            }
 #else
 #error unsupported CPU
 #endif
@@ -2503,7 +2652,7 @@ int gen_file(FILE *outfile, int out_type)
                 gen_code(name, sym->st_value, sym->st_size, outfile, 0);
             }
         }
-        
+
     } else {
         /* generate big code generation switch */
 
@@ -2546,7 +2695,7 @@ fprintf(outfile,
    eliminating the neeed to jump around the pool.
 
    We currently generate:
-   
+
    [ For this example we assume merging would move op1_pool out of range.
      In practice we should be able to combine many ops before the offset
      limits are reached. ]
@@ -2633,7 +2782,7 @@ fprintf(outfile,
 "    opc_ptr = opc_buf;\n"
 "    opparam_ptr = opparam_buf;\n");
 
-       /* Generate prologue, if needed. */ 
+       /* Generate prologue, if needed. */
 
 fprintf(outfile,
 "    for(;;) {\n");
@@ -2659,7 +2808,7 @@ fprintf(outfile,
             name = get_sym_name(sym);
             if (strstart(name, OP_PREFIX, NULL)) {
 #if 0
-                printf("%4d: %s pos=0x%08x len=%d\n", 
+                printf("%4d: %s pos=0x%08x len=%d\n",
                        i, name, sym->st_value, sym->st_size);
 #endif
 #if defined(CONFIG_FORMAT_ELF) || defined(CONFIG_FORMAT_COFF)
@@ -2701,7 +2850,7 @@ fprintf(outfile,
            "plt_target, plt_offset);\n    }\n");
 #endif
 
-/* generate some code patching */ 
+/* generate some code patching */
 #ifdef HOST_ARM
 fprintf(outfile,
 "if (arm_data_ptr != arm_data_table + ARM_LDR_TABLE_SIZE)\n"