Archipelago » qemu

/*

 *  Generic Dynamic compiler generator

 * 

 *  Copyright (c) 2003 Fabrice Bellard

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 2 of the License, or

 *  (at your option) any later version.

 *

 *  This program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program; if not, write to the Free Software

 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <stdarg.h>

#include <inttypes.h>

#include <unistd.h>

#include <fcntl.h>

#include "config-host.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

#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

#elif defined(HOST_IA64)

#define ELF_CLASS        ELFCLASS64

#define ELF_ARCH        EM_IA_64

#define elf_check_arch(x) ((x) == EM_IA_64)

#define ELF_USES_RELOCA

#elif defined(HOST_SPARC)

#define ELF_CLASS        ELFCLASS32

#define ELF_ARCH        EM_SPARC

#define elf_check_arch(x) ((x) == EM_SPARC || (x) == EM_SPARC32PLUS)

#define ELF_USES_RELOCA

#elif defined(HOST_SPARC64)

#define ELF_CLASS        ELFCLASS64

#define ELF_ARCH        EM_SPARCV9

#define elf_check_arch(x) ((x) == EM_SPARCV9)

#define ELF_USES_RELOCA

#elif defined(HOST_ARM)

#define ELF_CLASS        ELFCLASS32

#define ELF_ARCH        EM_ARM

#define elf_check_arch(x) ((x) == EM_ARM)

#define ELF_USES_RELOC

#elif defined(HOST_M68K)

#define ELF_CLASS        ELFCLASS32

#define ELF_ARCH        EM_68K

#define elf_check_arch(x) ((x) == EM_68K)

#define ELF_USES_RELOCA

#else

#error unsupported CPU - please update the code

#endif

#include "elf.h"

#if ELF_CLASS == ELFCLASS32

typedef int32_t host_long;

typedef uint32_t host_ulong;

#define swabls(x) swab32s(x)

#else

typedef int64_t host_long;

typedef uint64_t host_ulong;

#define swabls(x) swab64s(x)

#endif

#ifdef ELF_USES_RELOCA

#define SHT_RELOC SHT_RELA

#else

#define SHT_RELOC SHT_REL

#endif

#include "bswap.h"

enum {

    OUT_GEN_OP,

    OUT_CODE,

    OUT_INDEX_OP,

};

/* all dynamically generated functions begin with this code */

#define OP_PREFIX "op_"

int elf_must_swap(struct elfhdr *h)

{

  union {

      uint32_t i;

      uint8_t b[4];

  } swaptest;

  swaptest.i = 1;

  return (h->e_ident[EI_DATA] == ELFDATA2MSB) != 

      (swaptest.b[0] == 0);

}

void swab16s(uint16_t *p)

{

    *p = bswap16(*p);

}

void swab32s(uint32_t *p)

{

    *p = bswap32(*p);

}

void swab64s(uint64_t *p)

{

    *p = bswap64(*p);

}

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 */

    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 */

    swab16s(&h->        e_phnum);                /* Program header table entry count */

    swab16s(&h->        e_shentsize);                /* Section header table entry size */

    swab16s(&h->        e_shnum);                /* Section header table entry count */

    swab16s(&h->        e_shstrndx);                /* Section header string table index */

}

void elf_swap_shdr(struct elf_shdr *h)

{

  swab32s(&h->        sh_name);                /* Section name (string tbl index) */

  swab32s(&h->        sh_type);                /* Section type */

  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 */

  swabls(&h->        sh_addralign);                /* Section alignment */

  swabls(&h->        sh_entsize);                /* Entry size if section holds table */

}

void elf_swap_phdr(struct elf_phdr *h)

{

    swab32s(&h->p_type);                        /* Segment type */

    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 */

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

}

void elf_swap_rel(ELF_RELOC *rel)

{

    swabls(&rel->r_offset);

    swabls(&rel->r_info);

#ifdef ELF_USES_RELOCA

    swabls(&rel->r_addend);

#endif

}

/* ELF file info */

int do_swap;

struct elf_shdr *shdr;

uint8_t **sdata;

struct elfhdr ehdr;

ElfW(Sym) *symtab;

int nb_syms;

char *strtab;

int text_shndx;

uint16_t get16(uint16_t *p)

{

    uint16_t val;

    val = *p;

    if (do_swap)

        val = bswap16(val);

    return val;

}

uint32_t get32(uint32_t *p)

{

    uint32_t val;

    val = *p;

    if (do_swap)

        val = bswap32(val);

    return val;

}

void put16(uint16_t *p, uint16_t val)

{

    if (do_swap)

        val = bswap16(val);

    *p = val;

}

void put32(uint32_t *p, uint32_t val)

{

    if (do_swap)

        val = bswap32(val);

    *p = val;

}

void __attribute__((noreturn)) __attribute__((format (printf, 1, 2))) error(const char *fmt, ...)

{

    va_list ap;

    va_start(ap, fmt);

    fprintf(stderr, "dyngen: ");

    vfprintf(stderr, fmt, ap);

    fprintf(stderr, "\n");

    va_end(ap);

    exit(1);

}

struct elf_shdr *find_elf_section(struct elf_shdr *shdr, int shnum, const char *shstr, 

                                  const char *name)

{

    int i;

    const char *shname;

    struct elf_shdr *sec;

    for(i = 0; i < shnum; i++) {

        sec = &shdr[i];

        if (!sec->sh_name)

            continue;

        shname = shstr + sec->sh_name;

        if (!strcmp(shname, name))

            return sec;

    }

    return NULL;

}

int find_reloc(int sh_index)

{

    struct elf_shdr *sec;

    int i;

    for(i = 0; i < ehdr.e_shnum; i++) {

        sec = &shdr[i];

        if (sec->sh_type == SHT_RELOC && sec->sh_info == sh_index) 

            return i;

    }

    return 0;

}

void *load_data(int fd, long offset, unsigned int size)

{

    char *data;

    data = malloc(size);

    if (!data)

        return NULL;

    lseek(fd, offset, SEEK_SET);

    if (read(fd, data, size) != size) {

        free(data);

        return NULL;

    }

    return data;

}

int strstart(const char *str, const char *val, const char **ptr)

{

    const char *p, *q;

    p = str;

    q = val;

    while (*q != '\0') {

        if (*p != *q)

            return 0;

        p++;

        q++;

    }

    if (ptr)

        *ptr = p;

    return 1;

}

#ifdef HOST_ARM

int arm_emit_ldr_info(const char *name, unsigned long start_offset,

                      FILE *outfile, uint8_t *p_start, uint8_t *p_end,

                      ELF_RELOC *relocs, int nb_relocs)

{

    uint8_t *p;

    uint32_t insn;

    int offset, min_offset, pc_offset, data_size;

    uint8_t data_allocated[1024];

    unsigned int data_index;

    memset(data_allocated, 0, sizeof(data_allocated));

    p = p_start;

    min_offset = p_end - p_start;

    while (p < p_start + min_offset) {

        insn = get32((uint32_t *)p);

        if ((insn & 0x0d5f0000) == 0x051f0000) {

            /* ldr reg, [pc, #im] */

            offset = insn & 0xfff;

            if (!(insn & 0x00800000))

                        offset = -offset;

            if ((offset & 3) !=0)

                error("%s:%04x: ldr pc offset must be 32 bit aligned", 

                      name, start_offset + p - p_start);

            pc_offset = p - p_start + offset + 8;

            if (pc_offset <= (p - p_start) || 

                pc_offset >= (p_end - p_start))

                error("%s:%04x: ldr 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) {

                /* ldr position */

                fprintf(outfile, "    arm_ldr_ptr->ptr = gen_code_ptr + %d;\n", 

                        p - p_start);

                /* ldr data index */

                data_index = ((p_end - p_start) - pc_offset - 4) >> 2;

                fprintf(outfile, "    arm_ldr_ptr->data_ptr = arm_data_ptr + %d;\n", 

                        data_index);

                fprintf(outfile, "    arm_ldr_ptr++;\n");

                if (data_index >= sizeof(data_allocated))

                    error("%s: too many data", name);

                if (!data_allocated[data_index]) {

                    ELF_RELOC *rel;

                    int i, addend, type;

                    const char *sym_name, *p;

                    char relname[1024];

                    data_allocated[data_index] = 1;

                    /* data value */

                    addend = get32((uint32_t *)(p_start + pc_offset));

                    relname[0] = '\0';

                    for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {

                        if (rel->r_offset == (pc_offset + start_offset)) {

                            sym_name = strtab + symtab[ELFW(R_SYM)(rel->r_info)].st_name;

                            /* the compiler leave some unnecessary references to the code */

                            if (strstart(sym_name, "__op_param", &p)) {

                                snprintf(relname, sizeof(relname), "param%s", p);

                            } else {

                                snprintf(relname, sizeof(relname), "(long)(&%s)", sym_name);

                            }

                            type = ELF32_R_TYPE(rel->r_info);

                            if (type != R_ARM_ABS32)

                                error("%s: unsupported data relocation", name);

                            break;

                        }

                    }

                    fprintf(outfile, "    arm_data_ptr[%d] = 0x%x",

                            data_index, addend);

                    if (relname[0] != '\0')

                        fprintf(outfile, " + %s", relname);

                    fprintf(outfile, ";\n");

                }

            }

        }

        p += 4;

    }

    data_size = (p_end - p_start) - min_offset;

    if (data_size > 0 && outfile) {

        fprintf(outfile, "    arm_data_ptr += %d;\n", data_size >> 2);

    }

    /* the last instruction must be a mov pc, lr */

    if (p == p_start)

        goto arm_ret_error;

    p -= 4;

    insn = get32((uint32_t *)p);

    if ((insn & 0xffff0000) != 0xe91b0000) {

    arm_ret_error:

        if (!outfile)

            printf("%s: invalid epilog\n", name);

    }

    return p - p_start;            

}

#endif

#define MAX_ARGS 3

/* generate op code */

void gen_code(const char *name, host_ulong offset, host_ulong size, 

              FILE *outfile, uint8_t *text, ELF_RELOC *relocs, int nb_relocs,

              int gen_switch)

{

    int copy_size = 0;

    uint8_t *p_start, *p_end;

    host_ulong start_offset;

    int nb_args, i, n;

    uint8_t args_present[MAX_ARGS];

    const char *sym_name, *p;

    ELF_RELOC *rel;

    /* Compute exact size excluding prologue and epilogue instructions.

     * Increment start_offset to skip epilogue instructions, then compute

     * copy_size the indicate the size of the remaining instructions (in

     * bytes).

     */

    p_start = text + offset;

    p_end = p_start + size;

    start_offset = offset;

    switch(ELF_ARCH) {

    case EM_386:

        {

            int len;

            len = p_end - p_start;

            if (len == 0)

                error("empty code for %s", name);

            if (p_end[-1] == 0xc3) {

                len--;

            } else {

                error("ret or jmp expected at the end of %s", name);

            }

            copy_size = len;

        }

        break;

    case EM_PPC:

        {

            uint8_t *p;

            p = (void *)(p_end - 4);

            if (p == p_start)

                error("empty code for %s", name);

            if (get32((uint32_t *)p) != 0x4e800020)

                error("blr expected at the end of %s", name);

            copy_size = p - p_start;

        }

        break;

    case EM_S390:

        {

            uint8_t *p;

            p = (void *)(p_end - 2);

            if (p == p_start)

                error("empty code for %s", name);

            if (get16((uint16_t *)p) != 0x07fe && get16((uint16_t *)p) != 0x07f4)

                error("br %%r14 expected at the end of %s", name);

            copy_size = p - p_start;

        }

        break;

    case EM_ALPHA:

        {

            uint8_t *p;

            p = p_end - 4;

            if (p == p_start)

                error("empty code for %s", name);

            if (get32((uint32_t *)p) != 0x6bfa8001)

                error("ret expected at the end of %s", name);

            copy_size = p - p_start;            

        }

        break;

    case EM_IA_64:

        {

            uint8_t *p;

            p = (void *)(p_end - 4);

            if (p == p_start)

                error("empty code for %s", name);

            /* br.ret.sptk.many b0;; */

            /* 08 00 84 00 */

            if (get32((uint32_t *)p) != 0x00840008)

                error("br.ret.sptk.many b0;; expected at the end of %s", name);

            copy_size = p - p_start;

        }

        break;

    case EM_SPARC:

    case EM_SPARC32PLUS:

        {

            uint32_t start_insn, end_insn1, end_insn2;

            uint8_t *p;

            p = (void *)(p_end - 8);

            if (p <= p_start)

                error("empty code for %s", name);

            start_insn = get32((uint32_t *)(p_start + 0x0));

            end_insn1 = get32((uint32_t *)(p + 0x0));

            end_insn2 = get32((uint32_t *)(p + 0x4));

            if ((start_insn & ~0x1fff) == 0x9de3a000) {

                p_start += 0x4;

                start_offset += 0x4;

                if ((int)(start_insn | ~0x1fff) < -128)

                    error("Found bogus save at the start of %s", name);

                if (end_insn1 != 0x81c7e008 || end_insn2 != 0x81e80000)

                    error("ret; restore; not found at end of %s", name);

            } else {

                error("No save at the beginning of %s", name);

            }

#if 0

            /* Skip a preceeding nop, if present.  */

            if (p > p_start) {

                skip_insn = get32((uint32_t *)(p - 0x4));

                if (skip_insn == 0x01000000)

                    p -= 4;

            }

#endif

            copy_size = p - p_start;

        }

        break;

    case EM_SPARCV9:

        {

            uint32_t start_insn, end_insn1, end_insn2, skip_insn;

            uint8_t *p;

            p = (void *)(p_end - 8);

            if (p <= p_start)

                error("empty code for %s", name);

            start_insn = get32((uint32_t *)(p_start + 0x0));

            end_insn1 = get32((uint32_t *)(p + 0x0));

            end_insn2 = get32((uint32_t *)(p + 0x4));

            if ((start_insn & ~0x1fff) == 0x9de3a000) {

                p_start += 0x4;

                start_offset += 0x4;

                if ((int)(start_insn | ~0x1fff) < -256)

                    error("Found bogus save at the start of %s", name);

                if (end_insn1 != 0x81c7e008 || end_insn2 != 0x81e80000)

                    error("ret; restore; not found at end of %s", name);

            } 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;

        }

        break;

#ifdef HOST_ARM

    case EM_ARM:

        if ((p_end - p_start) <= 16)

            error("%s: function too small", name);

        if (get32((uint32_t *)p_start) != 0xe1a0c00d ||

            (get32((uint32_t *)(p_start + 4)) & 0xffff0000) != 0xe92d0000 ||

            get32((uint32_t *)(p_start + 8)) != 0xe24cb004)

            error("%s: invalid prolog", name);

        p_start += 12;

        start_offset += 12;

        copy_size = arm_emit_ldr_info(name, start_offset, NULL, p_start, p_end, 

                                      relocs, nb_relocs);

        break;

#endif

    case EM_68K:

        {

            uint8_t *p;

            p = (void *)(p_end - 2);

            if (p == p_start)

                error("empty code for %s", name);

            // remove NOP's, probably added for alignment

            while ((get16((uint16_t *)p) == 0x4e71) &&

                   (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;

        }

        break;

    default:

        error("unknown ELF architecture");

    }

    /* compute the number of arguments by looking at the relocations */

    for(i = 0;i < MAX_ARGS; i++)

        args_present[i] = 0;

    for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {

        if (rel->r_offset >= start_offset &&

            rel->r_offset < start_offset + (p_end - p_start)) {

            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;

            }

        }

    }

    nb_args = 0;

    while (nb_args < MAX_ARGS && args_present[nb_args])

        nb_args++;

    for(i = nb_args; i < MAX_ARGS; i++) {

        if (args_present[i])

            error("inconsistent argument numbering in %s", name);

    }

    if (gen_switch == 2) {

        fprintf(outfile, "DEF(%s, %d, %d)\n", name + 3, nb_args, copy_size);

    } else if (gen_switch == 1) {

        /* output C code */

        fprintf(outfile, "case INDEX_%s: {\n", name);

        if (nb_args > 0) {

            fprintf(outfile, "    long ");

            for(i = 0; i < nb_args; i++) {

                if (i != 0)

                    fprintf(outfile, ", ");

                fprintf(outfile, "param%d", i + 1);

            }

            fprintf(outfile, ";\n");

        }

        fprintf(outfile, "    extern void %s();\n", name);

        for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {

            if (rel->r_offset >= start_offset &&

                rel->r_offset < start_offset + (p_end - p_start)) {

                sym_name = strtab + symtab[ELFW(R_SYM)(rel->r_info)].st_name;

                if (*sym_name && 

                    !strstart(sym_name, "__op_param", NULL) &&

                    !strstart(sym_name, "__op_jmp", NULL)) {

#if defined(HOST_SPARC)

                    if (sym_name[0] == '.') {

                        fprintf(outfile,

                                "extern char __dot_%s __asm__(\"%s\");\n",

                                sym_name+1, sym_name);

                        continue;

                    }

#endif

                    fprintf(outfile, "extern char %s;\n", sym_name);

                }

            }

        }

        fprintf(outfile, "    memcpy(gen_code_ptr, (void *)((char *)&%s+%d), %d);\n", name, start_offset - offset, copy_size);

        /* emit code offset information */

        {

            ElfW(Sym) *sym;

            const char *sym_name, *p;

            unsigned long val;

            int n;

            for(i = 0, sym = symtab; i < nb_syms; i++, sym++) {

                sym_name = strtab + sym->st_name;

                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 */

                    ptr = sdata[sym->st_shndx];

                    if (!ptr)

                        error("__op_labelN in invalid section");

                    offset = sym->st_value;

                    val = *(unsigned long *)(ptr + offset);

#ifdef ELF_USES_RELOCA

                    {

                        int reloc_shndx, nb_relocs1, j;

                        /* try to find a matching relocation */

                        reloc_shndx = find_reloc(sym->st_shndx);

                        if (reloc_shndx) {

                            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++) {

                                if (rel->r_offset == offset) {

                                    val = rel->r_addend;

                                    break;

                                }

                                rel++;

                            }

                        }

                    }

#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, val - start_offset);

                    }

                }

            }

        }

        /* load parameres in variables */

        for(i = 0; i < nb_args; i++) {

            fprintf(outfile, "    param%d = *opparam_ptr++;\n", i + 1);

        }

        /* patch relocations */

#if defined(HOST_I386)

            {

                char name[256];

                int type;

                int addend;

                for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {

                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;

                    if (strstart(sym_name, "__op_param", &p)) {

                        snprintf(name, sizeof(name), "param%s", p);

                    } else {

                        snprintf(name, sizeof(name), "(long)(&%s)", sym_name);

                    }

                    type = ELF32_R_TYPE(rel->r_info);

                    addend = get32((uint32_t *)(text + rel->r_offset));

                    switch(type) {

                    case R_386_32:

                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", 

                                rel->r_offset - start_offset, name, addend);

                        break;

                    case R_386_PC32:

                        fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s - (long)(gen_code_ptr + %d) + %d;\n", 

                                rel->r_offset - start_offset, name, rel->r_offset - start_offset, addend);

                        break;

                    default:

                        error("unsupported i386 relocation (%d)", type);

                    }

                }

                }

            }

#elif defined(HOST_PPC)

            {

                char name[256];

                int type;

                int addend;

                for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {

                    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;

                        if (strstart(sym_name, "__op_jmp", &p)) {

                            int n;

                            n = strtol(p, NULL, 10);

                            /* __op_jmp relocations are done at

                               runtime to do translated block

                               chaining: the offset of the instruction

                               needs to be stored */

                            fprintf(outfile, "    jmp_offsets[%d] = %d + (gen_code_ptr - gen_code_buf);\n",

                                    n, rel->r_offset - start_offset);

                            continue;

                        }

                        if (strstart(sym_name, "__op_param", &p)) {

                            snprintf(name, sizeof(name), "param%s", p);

                        } else {

                            snprintf(name, sizeof(name), "(long)(&%s)", 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", 

                                    rel->r_offset - start_offset, name, addend);

                            break;

                        case R_PPC_ADDR16_LO:

                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = (%s + %d);\n", 

                                    rel->r_offset - start_offset, name, addend);

                            break;

                        case R_PPC_ADDR16_HI:

                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = (%s + %d) >> 16;\n", 

                                    rel->r_offset - start_offset, name, addend);

                            break;

                        case R_PPC_ADDR16_HA:

                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = (%s + %d + 0x8000) >> 16;\n", 

                                    rel->r_offset - start_offset, name, 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", 

                                    rel->r_offset - start_offset, rel->r_offset - start_offset, name, rel->r_offset - start_offset, addend);

                            break;

                        default:

                            error("unsupported powerpc relocation (%d)", type);

                        }

                    }

                }

            }

#elif defined(HOST_S390)

            {

                char name[256];

                int type;

                int addend;

                for(i = 0, rel = relocs;i < nb_relocs; i++, rel++) {

                    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;

                        if (strstart(sym_name, "__op_param", &p)) {

                            snprintf(name, sizeof(name), "param%s", p);

                        } else {

                            snprintf(name, sizeof(name), "(long)(&%s)", sym_name);

                        }

                        type = ELF32_R_TYPE(rel->r_info);

                        addend = rel->r_addend;

                        switch(type) {

                        case R_390_32:

                            fprintf(outfile, "    *(uint32_t *)(gen_code_ptr + %d) = %s + %d;\n", 

                                    rel->r_offset - start_offset, name, addend);

                            break;

                        case R_390_16:

                            fprintf(outfile, "    *(uint16_t *)(gen_code_ptr + %d) = %s + %d;\n", 

                                    rel->r_offset - start_offset, name, addend);

                            break;

                        case R_390_8:

                            fprintf(outfile, "    *(uint8_t *)(gen_code_ptr + %d) = %s + %d;\n", 

                                    rel->r_offset - start_offset, name, addend);

                            break;

                        default:

                            error("unsupported s390 relocation (%d)", type);

                        }

                    }

                }

            }

#elif defined(HOST_ALPHA)

            {

                for (i = 0, rel = relocs; i < nb_relocs; i++, rel++) {

                    if (rel->r_offset >= start_offset && rel->r_offset < start_offset + copy_size) {

                        int type;

                        type = ELF64_R_TYPE(rel->r_info);

                        sym_name = strtab + symtab[ELF64_R_SYM(rel->r_info)].st_name;

                        switch (type) {

                        case R_ALPHA_GPDISP:

                            /* The gp is just 32 bit, and never changes, so it's easiest to emit it

                               as an immediate instead of constructing it from the pv or ra.  */

                            fprintf(outfile, "    immediate_ldah(gen_code_ptr + %ld, gp);\n",

                                    rel->r_offset - start_offset);

                            fprintf(outfile, "    immediate_lda(gen_code_ptr + %ld, gp);\n",

                                    rel->r_offset - start_offset + rel->r_addend);

                            break;

                        case R_ALPHA_LITUSE:

                            /* jsr to literal hint. Could be used to optimize to bsr. Ignore for

                               now, since some called functions (libc) need pv to be set up.  */

                            break;

                        case R_ALPHA_HINT:

                            /* Branch target prediction hint. Ignore for now.  Should be already