Archipelago » qemu

/*

 *  Generic Dynamic compiler generator

 *

 *  Copyright (c) 2003 Fabrice Bellard

 *

 *  The COFF object format support was extracted from Kazu's QEMU port

 *  to Win32.

 *

 *  Mach-O Support by Matt Reda and Pierre d'Herbemont

 *

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

/* NOTE: we test CONFIG_WIN32 instead of _WIN32 to enabled cross

   compilation */

#if defined(CONFIG_WIN32)

#define CONFIG_FORMAT_COFF

#elif defined(CONFIG_DARWIN)

#define CONFIG_FORMAT_MACH

#else

#define CONFIG_FORMAT_ELF

#endif

#ifdef CONFIG_FORMAT_ELF

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

#define ELF_CLASS        ELFCLASS64

#define ELF_ARCH        EM_X86_64

#define elf_check_arch(x) ((x) == EM_X86_64)

#define 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

#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

#include "elf.h"

#if ELF_CLASS == ELFCLASS32

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

#define SHT_RELOC SHT_RELA

#else

#define SHT_RELOC SHT_REL

#endif

#define EXE_RELOC ELF_RELOC

#define EXE_SYM ElfW(Sym)

#endif /* CONFIG_FORMAT_ELF */

#ifdef CONFIG_FORMAT_COFF

typedef int32_t host_long;

typedef uint32_t host_ulong;

#include "a.out.h"

#define FILENAMELEN 256

typedef struct coff_sym {

    struct external_syment *st_syment;

    char st_name[FILENAMELEN];

    uint32_t st_value;

    int  st_size;

    uint8_t st_type;

    uint8_t st_shndx;

} coff_Sym;

typedef struct coff_rel {

    struct external_reloc *r_reloc;

    int  r_offset;

    uint8_t r_type;

} coff_Rel;

#define EXE_RELOC struct coff_rel

#define EXE_SYM struct coff_sym

#endif /* CONFIG_FORMAT_COFF */

#ifdef CONFIG_FORMAT_MACH

#include <mach-o/loader.h>

#include <mach-o/nlist.h>

#include <mach-o/reloc.h>

#include <mach-o/ppc/reloc.h>

# define check_mach_header(x) (x.magic == MH_MAGIC)

typedef int32_t host_long;

typedef uint32_t host_ulong;

struct nlist_extended

{

   union {

   char *n_name;

   long  n_strx;

   } n_un;

   unsigned char n_type;

   unsigned char n_sect;

   short st_desc;

   unsigned long st_value;

   unsigned long st_size;

};

#define EXE_RELOC struct relocation_info

#define EXE_SYM struct nlist_extended

#endif /* CONFIG_FORMAT_MACH */

#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 do_swap;

static 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);

}

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

}

void pstrcpy(char *buf, int buf_size, const char *str)

{

    int c;

    char *q = buf;

    if (buf_size <= 0)

        return;

    for(;;) {

        c = *str++;

        if (c == 0 || q >= buf + buf_size - 1)

            break;

        *q++ = c;

    }

    *q = '\0';

}

void swab16s(uint16_t *p)

{

    *p = bswap16(*p);

}

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;

    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;

}

/* executable information */

EXE_SYM *symtab;

int nb_syms;

int text_shndx;

uint8_t *text;

EXE_RELOC *relocs;

int nb_relocs;

#ifdef CONFIG_FORMAT_ELF

/* ELF file info */

struct elf_shdr *shdr;

uint8_t **sdata;

struct elfhdr ehdr;

char *strtab;

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

    swablss(&rel->r_addend);

#endif

}

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;

}

static host_ulong get_rel_offset(EXE_RELOC *rel)

{

    return rel->r_offset;

}

static char *get_rel_sym_name(EXE_RELOC *rel)

{

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

}

static char *get_sym_name(EXE_SYM *sym)

{

    return strtab + sym->st_name;

}

/* load an elf object file */

int load_object(const char *filename)

{

    int fd;

    struct elf_shdr *sec, *symtab_sec, *strtab_sec, *text_sec;

    int i, j;

    ElfW(Sym) *sym;

    char *shstr;

    ELF_RELOC *rel;

    fd = open(filename, O_RDONLY);

    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");

    /* Check ELF identification.  */

    if (ehdr.e_ident[EI_MAG0] != ELFMAG0

     || ehdr.e_ident[EI_MAG1] != ELFMAG1

     || ehdr.e_ident[EI_MAG2] != ELFMAG2

     || ehdr.e_ident[EI_MAG3] != ELFMAG3

     || ehdr.e_ident[EI_VERSION] != EV_CURRENT) {

        error("bad ELF header");

    }

    do_swap = elf_must_swap(&ehdr);

    if (do_swap)

        elf_swap_ehdr(&ehdr);

    if (ehdr.e_ident[EI_CLASS] != ELF_CLASS)

        error("Unsupported ELF class");

    if (ehdr.e_type != ET_REL)

        error("ELF object file expected");

    if (ehdr.e_version != EV_CURRENT)

        error("Invalid ELF version");

    if (!elf_check_arch(ehdr.e_machine))

        error("Unsupported CPU (e_machine=%d)", ehdr.e_machine);

    /* read section headers */

    shdr = load_data(fd, ehdr.e_shoff, ehdr.e_shnum * sizeof(struct elf_shdr));

    if (do_swap) {

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

            elf_swap_shdr(&shdr[i]);

        }

    }

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

            sdata[i] = load_data(fd, sec->sh_offset, sec->sh_size);

    }

    sec = &shdr[ehdr.e_shstrndx];

    shstr = (char *)sdata[ehdr.e_shstrndx];

    /* swap relocations */

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

        sec = &shdr[i];

        if (sec->sh_type == SHT_RELOC) {

            nb_relocs = sec->sh_size / sec->sh_entsize;

            if (do_swap) {

                for(j = 0, rel = (ELF_RELOC *)sdata[i]; j < nb_relocs; j++, rel++)

                    elf_swap_rel(rel);

            }

        }

    }

    /* text section */

    text_sec = find_elf_section(shdr, ehdr.e_shnum, shstr, ".text");

    if (!text_sec)

        error("could not find .text section");

    text_shndx = text_sec - shdr;

    text = sdata[text_shndx];

    /* find text relocations, if any */

    relocs = NULL;

    nb_relocs = 0;

    i = find_reloc(text_shndx);

    if (i != 0) {

        relocs = (ELF_RELOC *)sdata[i];

        nb_relocs = shdr[i].sh_size / shdr[i].sh_entsize;

    }

    symtab_sec = find_elf_section(shdr, ehdr.e_shnum, shstr, ".symtab");

    if (!symtab_sec)

        error("could not find .symtab section");

    strtab_sec = &shdr[symtab_sec->sh_link];

    symtab = (ElfW(Sym) *)sdata[symtab_sec - shdr];

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

            swab32s(&sym->st_name);

            swabls(&sym->st_value);

            swabls(&sym->st_size);

            swab16s(&sym->st_shndx);

        }

    }

    close(fd);

    return 0;

}

#endif /* CONFIG_FORMAT_ELF */

#ifdef CONFIG_FORMAT_COFF

/* COFF file info */

struct external_scnhdr *shdr;

uint8_t **sdata;

struct external_filehdr fhdr;

struct external_syment *coff_symtab;

char *strtab;

int coff_text_shndx, coff_data_shndx;

int data_shndx;

#define STRTAB_SIZE 4

#define DIR32   0x06

#define DISP32  0x14

#define T_FUNCTION  0x20

#define C_EXTERNAL  2

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

            c = ext_sym->e.e_name[i];

            if (c == '\0')

                break;

            *q++ = c;

        }

        *q = '\0';

    } else {

        pstrcpy(sym->st_name, sizeof(sym->st_name), strtab + ext_sym->e.e.e_offset);

    }

    /* now convert the name to a C name (suppress the leading '_') */

    if (sym->st_name[0] == '_') {

        len = strlen(sym->st_name);

        memmove(sym->st_name, sym->st_name + 1, len - 1);

        sym->st_name[len - 1] = '\0';

    }

}

char *name_for_dotdata(struct coff_rel *rel)

{

        int i;

        struct coff_sym *sym;

        uint32_t text_data;

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

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

                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;

                }

        }

        return NULL;

}

static char *get_sym_name(EXE_SYM *sym)

{

    return sym->st_name;

}

static char *get_rel_sym_name(EXE_RELOC *rel)

{

    char *name;

    name = get_sym_name(symtab + *(uint32_t *)(rel->r_reloc->r_symndx));

    if (!strcmp(name, ".data"))

        name = name_for_dotdata(rel);

    if (name[0] == '.')

        return NULL;

    return name;

}

static host_ulong get_rel_offset(EXE_RELOC *rel)

{

    return rel->r_offset;

}

struct external_scnhdr *find_coff_section(struct external_scnhdr *shdr, int shnum, const char *name)

{

    int i;

    const char *shname;

    struct external_scnhdr *sec;

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

        sec = &shdr[i];

        if (!sec->s_name)

            continue;

        shname = sec->s_name;

        if (!strcmp(shname, name))

            return sec;

    }

    return NULL;

}

/* load a coff object file */

int load_object(const char *filename)

{

    int fd;

    struct external_scnhdr *sec, *text_sec, *data_sec;

    int i;

    struct external_syment *ext_sym;

    struct external_reloc *coff_relocs;

    struct external_reloc *ext_rel;

    uint32_t *n_strtab;

    EXE_SYM *sym;

    EXE_RELOC *rel;

    const char *p;

    int aux_size, j;

    fd = open(filename, O_RDONLY

#ifdef _WIN32

              | O_BINARY

#endif

              );

    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");

    /* Check COFF identification.  */

    if (fhdr.f_magic != I386MAGIC) {

        error("bad COFF header");

    }

    do_swap = 0;

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

    for(i = 0;i < fhdr.f_nscns; i++) {

        sec = &shdr[i];

        if (!strstart(sec->s_name,  ".bss", &p))

            sdata[i] = load_data(fd, sec->s_scnptr, sec->s_size);

    }

    /* text section */

    text_sec = find_coff_section(shdr, fhdr.f_nscns, ".text");

    if (!text_sec)

        error("could not find .text section");

    coff_text_shndx = text_sec - shdr;

    text = sdata[coff_text_shndx];

    /* data section */

    data_sec = find_coff_section(shdr, fhdr.f_nscns, ".data");

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

            printf(" %02x", ((uint8_t *)ext_sym->e.e_name)[i]);

        printf("\n");

    }

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

    nb_syms = fhdr.f_nsyms;

    for (i = 0, ext_sym = coff_symtab; i < nb_syms; i++, ext_sym++) {

      if (strstart(ext_sym->e.e_name, ".text", NULL))

                  text_shndx = ext_sym->e_scnum;

          if (strstart(ext_sym->e.e_name, ".data", NULL))

                  data_shndx = ext_sym->e_scnum;

    }

        /* set coff symbol */

        symtab = malloc(sizeof(struct coff_sym) * nb_syms);

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

                memset(sym, 0, sizeof(*sym));

                sym->st_syment = ext_sym;

                sym_ent_name(ext_sym, sym);

                sym->st_value = ext_sym->e_value;

                aux_size = *(int8_t *)ext_sym->e_numaux;

                if (ext_sym->e_scnum == text_shndx && ext_sym->e_type == T_FUNCTION) {

                        for (j = aux_size + 1; j < nb_syms - i; j++) {

                                if ((ext_sym + j)->e_scnum == text_shndx &&

                                        (ext_sym + j)->e_type == T_FUNCTION ){

                                        sym->st_size = (ext_sym + j)->e_value - ext_sym->e_value;

                                        break;

                                } else if (j == nb_syms - i - 1) {

                                        sec = &shdr[coff_text_shndx];

                                        sym->st_size = sec->s_size - ext_sym->e_value;

                                        break;

                                }

                        }

                } else if (ext_sym->e_scnum == data_shndx && *(uint8_t *)ext_sym->e_sclass == C_EXTERNAL) {

                        for (j = aux_size + 1; j < nb_syms - i; j++) {

                                if ((ext_sym + j)->e_scnum == data_shndx) {

                                        sym->st_size = (ext_sym + j)->e_value - ext_sym->e_value;

                                        break;

                                } else if (j == nb_syms - i - 1) {

                                        sec = &shdr[coff_data_shndx];

                                        sym->st_size = sec->s_size - ext_sym->e_value;

                                        break;

                                }

                        }

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

    nb_relocs = sec->s_nreloc;

    /* set coff relocation */

    relocs = malloc(sizeof(struct coff_rel) * 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;

        rel->r_offset = *(uint32_t *)ext_rel->r_vaddr;

        rel->r_type = *(uint16_t *)ext_rel->r_type;

    }

    return 0;

}

#endif /* CONFIG_FORMAT_COFF */

#ifdef CONFIG_FORMAT_MACH

/* File Header */

struct mach_header         mach_hdr;

/* commands */

struct segment_command         *segment = 0;

struct dysymtab_command *dysymtabcmd = 0;

struct symtab_command         *symtabcmd = 0;

/* section */

struct section         *section_hdr;

struct section *text_sec_hdr;

uint8_t         **sdata;

/* relocs */

struct relocation_info *relocs;

/* symbols */

EXE_SYM                        *symtab;

struct nlist         *symtab_std;

char                        *strtab;

/* indirect symbols */

uint32_t         *tocdylib;

/* Utility functions */

static inline char *find_str_by_index(int index)

{

    return strtab+index;

}

/* Used by dyngen common code */

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]=='_')

                return name + 1;

        else

                return name;

}

/* find a section index given its segname, sectname */

static int find_mach_sec_index(struct section *section_hdr, int shnum, const char *segname,

                                  const char *sectname)

{

    int i;

    struct section *sec = section_hdr;

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

        if (!sec->segname || !sec->sectname)

            continue;

        if (!strcmp(sec->sectname, sectname) && !strcmp(sec->segname, segname))

            return i;

    }

    return -1;