Archipelago » qemu

/* This is the Linux kernel elf-loading code, ported into user space */

#include <sys/time.h>

#include <sys/param.h>

#include <stdio.h>

#include <sys/types.h>

#include <fcntl.h>

#include <errno.h>

#include <unistd.h>

#include <sys/mman.h>

#include <sys/resource.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include "qemu.h"

#include "disas.h"

#ifdef _ARCH_PPC64

#undef ARCH_DLINFO

#undef ELF_PLATFORM

#undef ELF_HWCAP

#undef ELF_CLASS

#undef ELF_DATA

#undef ELF_ARCH

#endif

#define ELF_OSABI   ELFOSABI_SYSV

/* from personality.h */

/*

 * Flags for bug emulation.

 *

 * These occupy the top three bytes.

 */

enum {

    ADDR_NO_RANDOMIZE = 0x0040000,      /* disable randomization of VA space */

    FDPIC_FUNCPTRS =    0x0080000,      /* userspace function ptrs point to

                                           descriptors (signal handling) */

    MMAP_PAGE_ZERO =    0x0100000,

    ADDR_COMPAT_LAYOUT = 0x0200000,

    READ_IMPLIES_EXEC = 0x0400000,

    ADDR_LIMIT_32BIT =  0x0800000,

    SHORT_INODE =       0x1000000,

    WHOLE_SECONDS =     0x2000000,

    STICKY_TIMEOUTS =   0x4000000,

    ADDR_LIMIT_3GB =    0x8000000,

};

/*

 * Personality types.

 *

 * These go in the low byte.  Avoid using the top bit, it will

 * conflict with error returns.

 */

enum {

    PER_LINUX =         0x0000,

    PER_LINUX_32BIT =   0x0000 | ADDR_LIMIT_32BIT,

    PER_LINUX_FDPIC =   0x0000 | FDPIC_FUNCPTRS,

    PER_SVR4 =          0x0001 | STICKY_TIMEOUTS | MMAP_PAGE_ZERO,

    PER_SVR3 =          0x0002 | STICKY_TIMEOUTS | SHORT_INODE,

    PER_SCOSVR3 =       0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS | SHORT_INODE,

    PER_OSR5 =          0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS,

    PER_WYSEV386 =      0x0004 | STICKY_TIMEOUTS | SHORT_INODE,

    PER_ISCR4 =         0x0005 | STICKY_TIMEOUTS,

    PER_BSD =           0x0006,

    PER_SUNOS =         0x0006 | STICKY_TIMEOUTS,

    PER_XENIX =         0x0007 | STICKY_TIMEOUTS | SHORT_INODE,

    PER_LINUX32 =       0x0008,

    PER_LINUX32_3GB =   0x0008 | ADDR_LIMIT_3GB,

    PER_IRIX32 =        0x0009 | STICKY_TIMEOUTS,/* IRIX5 32-bit */

    PER_IRIXN32 =       0x000a | STICKY_TIMEOUTS,/* IRIX6 new 32-bit */

    PER_IRIX64 =        0x000b | STICKY_TIMEOUTS,/* IRIX6 64-bit */

    PER_RISCOS =        0x000c,

    PER_SOLARIS =       0x000d | STICKY_TIMEOUTS,

    PER_UW7 =           0x000e | STICKY_TIMEOUTS | MMAP_PAGE_ZERO,

    PER_OSF4 =          0x000f,                  /* OSF/1 v4 */

    PER_HPUX =          0x0010,

    PER_MASK =          0x00ff,

};

/*

 * Return the base personality without flags.

 */

#define personality(pers)       (pers & PER_MASK)

/* this flag is uneffective under linux too, should be deleted */

#ifndef MAP_DENYWRITE

#define MAP_DENYWRITE 0

#endif

/* should probably go in elf.h */

#ifndef ELIBBAD

#define ELIBBAD 80

#endif

#ifdef TARGET_WORDS_BIGENDIAN

#define ELF_DATA        ELFDATA2MSB

#else

#define ELF_DATA        ELFDATA2LSB

#endif

typedef target_ulong    target_elf_greg_t;

#ifdef USE_UID16

typedef uint16_t        target_uid_t;

typedef uint16_t        target_gid_t;

#else

typedef uint32_t        target_uid_t;

typedef uint32_t        target_gid_t;

#endif

typedef int32_t         target_pid_t;

#ifdef TARGET_I386

#define ELF_PLATFORM get_elf_platform()

static const char *get_elf_platform(void)

{

    static char elf_platform[] = "i386";

    int family = (thread_env->cpuid_version >> 8) & 0xff;

    if (family > 6)

        family = 6;

    if (family >= 3)

        elf_platform[1] = '0' + family;

    return elf_platform;

}

#define ELF_HWCAP get_elf_hwcap()

static uint32_t get_elf_hwcap(void)

{

    return thread_env->cpuid_features;

}

#ifdef TARGET_X86_64

#define ELF_START_MMAP 0x2aaaaab000ULL

#define elf_check_arch(x) ( ((x) == ELF_ARCH) )

#define ELF_CLASS      ELFCLASS64

#define ELF_ARCH       EM_X86_64

static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)

{

    regs->rax = 0;

    regs->rsp = infop->start_stack;

    regs->rip = infop->entry;

}

#define ELF_NREG    27

typedef target_elf_greg_t  target_elf_gregset_t[ELF_NREG];

/*

 * Note that ELF_NREG should be 29 as there should be place for

 * TRAPNO and ERR "registers" as well but linux doesn't dump

 * those.

 *

 * See linux kernel: arch/x86/include/asm/elf.h

 */

static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUState *env)

{

    (*regs)[0] = env->regs[15];

    (*regs)[1] = env->regs[14];

    (*regs)[2] = env->regs[13];

    (*regs)[3] = env->regs[12];

    (*regs)[4] = env->regs[R_EBP];

    (*regs)[5] = env->regs[R_EBX];

    (*regs)[6] = env->regs[11];

    (*regs)[7] = env->regs[10];

    (*regs)[8] = env->regs[9];

    (*regs)[9] = env->regs[8];

    (*regs)[10] = env->regs[R_EAX];

    (*regs)[11] = env->regs[R_ECX];

    (*regs)[12] = env->regs[R_EDX];

    (*regs)[13] = env->regs[R_ESI];

    (*regs)[14] = env->regs[R_EDI];

    (*regs)[15] = env->regs[R_EAX]; /* XXX */

    (*regs)[16] = env->eip;

    (*regs)[17] = env->segs[R_CS].selector & 0xffff;

    (*regs)[18] = env->eflags;

    (*regs)[19] = env->regs[R_ESP];

    (*regs)[20] = env->segs[R_SS].selector & 0xffff;

    (*regs)[21] = env->segs[R_FS].selector & 0xffff;

    (*regs)[22] = env->segs[R_GS].selector & 0xffff;

    (*regs)[23] = env->segs[R_DS].selector & 0xffff;

    (*regs)[24] = env->segs[R_ES].selector & 0xffff;

    (*regs)[25] = env->segs[R_FS].selector & 0xffff;

    (*regs)[26] = env->segs[R_GS].selector & 0xffff;

}

#else

#define ELF_START_MMAP 0x80000000

/*

 * This is used to ensure we don't load something for the wrong architecture.

 */

#define elf_check_arch(x) ( ((x) == EM_386) || ((x) == EM_486) )

/*

 * These are used to set parameters in the core dumps.

 */

#define ELF_CLASS       ELFCLASS32

#define ELF_ARCH        EM_386

static inline void init_thread(struct target_pt_regs *regs,

                               struct image_info *infop)

{

    regs->esp = infop->start_stack;

    regs->eip = infop->entry;

    /* SVR4/i386 ABI (pages 3-31, 3-32) says that when the program

       starts %edx contains a pointer to a function which might be

       registered using `atexit'.  This provides a mean for the

       dynamic linker to call DT_FINI functions for shared libraries

       that have been loaded before the code runs.

       A value of 0 tells we have no such handler.  */

    regs->edx = 0;

}

#define ELF_NREG    17

typedef target_elf_greg_t  target_elf_gregset_t[ELF_NREG];

/*

 * Note that ELF_NREG should be 19 as there should be place for

 * TRAPNO and ERR "registers" as well but linux doesn't dump

 * those.

 *

 * See linux kernel: arch/x86/include/asm/elf.h

 */

static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUState *env)

{

    (*regs)[0] = env->regs[R_EBX];

    (*regs)[1] = env->regs[R_ECX];

    (*regs)[2] = env->regs[R_EDX];

    (*regs)[3] = env->regs[R_ESI];

    (*regs)[4] = env->regs[R_EDI];

    (*regs)[5] = env->regs[R_EBP];

    (*regs)[6] = env->regs[R_EAX];

    (*regs)[7] = env->segs[R_DS].selector & 0xffff;

    (*regs)[8] = env->segs[R_ES].selector & 0xffff;

    (*regs)[9] = env->segs[R_FS].selector & 0xffff;

    (*regs)[10] = env->segs[R_GS].selector & 0xffff;

    (*regs)[11] = env->regs[R_EAX]; /* XXX */

    (*regs)[12] = env->eip;

    (*regs)[13] = env->segs[R_CS].selector & 0xffff;

    (*regs)[14] = env->eflags;

    (*regs)[15] = env->regs[R_ESP];

    (*regs)[16] = env->segs[R_SS].selector & 0xffff;

}

#endif

#define USE_ELF_CORE_DUMP

#define ELF_EXEC_PAGESIZE       4096

#endif

#ifdef TARGET_ARM

#define ELF_START_MMAP 0x80000000

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

#define ELF_CLASS       ELFCLASS32

#define ELF_ARCH        EM_ARM

static inline void init_thread(struct target_pt_regs *regs,

                               struct image_info *infop)

{

    abi_long stack = infop->start_stack;

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

    regs->ARM_cpsr = 0x10;

    if (infop->entry & 1)

        regs->ARM_cpsr |= CPSR_T;

    regs->ARM_pc = infop->entry & 0xfffffffe;

    regs->ARM_sp = infop->start_stack;

    /* FIXME - what to for failure of get_user()? */

    get_user_ual(regs->ARM_r2, stack + 8); /* envp */

    get_user_ual(regs->ARM_r1, stack + 4); /* envp */

    /* XXX: it seems that r0 is zeroed after ! */

    regs->ARM_r0 = 0;

    /* For uClinux PIC binaries.  */

    /* XXX: Linux does this only on ARM with no MMU (do we care ?) */

    regs->ARM_r10 = infop->start_data;

}

#define ELF_NREG    18

typedef target_elf_greg_t  target_elf_gregset_t[ELF_NREG];

static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUState *env)

{

    (*regs)[0] = tswapl(env->regs[0]);

    (*regs)[1] = tswapl(env->regs[1]);

    (*regs)[2] = tswapl(env->regs[2]);

    (*regs)[3] = tswapl(env->regs[3]);

    (*regs)[4] = tswapl(env->regs[4]);

    (*regs)[5] = tswapl(env->regs[5]);

    (*regs)[6] = tswapl(env->regs[6]);

    (*regs)[7] = tswapl(env->regs[7]);

    (*regs)[8] = tswapl(env->regs[8]);

    (*regs)[9] = tswapl(env->regs[9]);

    (*regs)[10] = tswapl(env->regs[10]);

    (*regs)[11] = tswapl(env->regs[11]);

    (*regs)[12] = tswapl(env->regs[12]);

    (*regs)[13] = tswapl(env->regs[13]);

    (*regs)[14] = tswapl(env->regs[14]);

    (*regs)[15] = tswapl(env->regs[15]);

    (*regs)[16] = tswapl(cpsr_read((CPUState *)env));

    (*regs)[17] = tswapl(env->regs[0]); /* XXX */

}

#define USE_ELF_CORE_DUMP

#define ELF_EXEC_PAGESIZE       4096

enum

{

    ARM_HWCAP_ARM_SWP       = 1 << 0,

    ARM_HWCAP_ARM_HALF      = 1 << 1,

    ARM_HWCAP_ARM_THUMB     = 1 << 2,

    ARM_HWCAP_ARM_26BIT     = 1 << 3,

    ARM_HWCAP_ARM_FAST_MULT = 1 << 4,

    ARM_HWCAP_ARM_FPA       = 1 << 5,

    ARM_HWCAP_ARM_VFP       = 1 << 6,

    ARM_HWCAP_ARM_EDSP      = 1 << 7,

    ARM_HWCAP_ARM_JAVA      = 1 << 8,

    ARM_HWCAP_ARM_IWMMXT    = 1 << 9,

    ARM_HWCAP_ARM_THUMBEE   = 1 << 10,

    ARM_HWCAP_ARM_NEON      = 1 << 11,

    ARM_HWCAP_ARM_VFPv3     = 1 << 12,

    ARM_HWCAP_ARM_VFPv3D16  = 1 << 13,

};

#define ELF_HWCAP (ARM_HWCAP_ARM_SWP | ARM_HWCAP_ARM_HALF               \

                   | ARM_HWCAP_ARM_THUMB | ARM_HWCAP_ARM_FAST_MULT      \

                   | ARM_HWCAP_ARM_FPA | ARM_HWCAP_ARM_VFP              \

                   | ARM_HWCAP_ARM_NEON | ARM_HWCAP_ARM_VFPv3 )

#endif

#ifdef TARGET_SPARC

#ifdef TARGET_SPARC64

#define ELF_START_MMAP 0x80000000

#ifndef TARGET_ABI32

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

#else

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

#endif

#define ELF_CLASS   ELFCLASS64

#define ELF_ARCH    EM_SPARCV9

#define STACK_BIAS              2047

static inline void init_thread(struct target_pt_regs *regs,

                               struct image_info *infop)

{

#ifndef TARGET_ABI32

    regs->tstate = 0;

#endif

    regs->pc = infop->entry;

    regs->npc = regs->pc + 4;

    regs->y = 0;

#ifdef TARGET_ABI32

    regs->u_regs[14] = infop->start_stack - 16 * 4;

#else

    if (personality(infop->personality) == PER_LINUX32)

        regs->u_regs[14] = infop->start_stack - 16 * 4;

    else

        regs->u_regs[14] = infop->start_stack - 16 * 8 - STACK_BIAS;

#endif

}

#else

#define ELF_START_MMAP 0x80000000

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

#define ELF_CLASS   ELFCLASS32

#define ELF_ARCH    EM_SPARC

static inline void init_thread(struct target_pt_regs *regs,

                               struct image_info *infop)

{

    regs->psr = 0;

    regs->pc = infop->entry;

    regs->npc = regs->pc + 4;

    regs->y = 0;

    regs->u_regs[14] = infop->start_stack - 16 * 4;

}

#endif

#endif

#ifdef TARGET_PPC

#define ELF_START_MMAP 0x80000000

#if defined(TARGET_PPC64) && !defined(TARGET_ABI32)

#define elf_check_arch(x) ( (x) == EM_PPC64 )

#define ELF_CLASS       ELFCLASS64

#else

#define elf_check_arch(x) ( (x) == EM_PPC )

#define ELF_CLASS       ELFCLASS32

#endif

#define ELF_ARCH        EM_PPC

/* Feature masks for the Aux Vector Hardware Capabilities (AT_HWCAP).

   See arch/powerpc/include/asm/cputable.h.  */

enum {

    QEMU_PPC_FEATURE_32 = 0x80000000,

    QEMU_PPC_FEATURE_64 = 0x40000000,

    QEMU_PPC_FEATURE_601_INSTR = 0x20000000,

    QEMU_PPC_FEATURE_HAS_ALTIVEC = 0x10000000,

    QEMU_PPC_FEATURE_HAS_FPU = 0x08000000,

    QEMU_PPC_FEATURE_HAS_MMU = 0x04000000,

    QEMU_PPC_FEATURE_HAS_4xxMAC = 0x02000000,

    QEMU_PPC_FEATURE_UNIFIED_CACHE = 0x01000000,

    QEMU_PPC_FEATURE_HAS_SPE = 0x00800000,

    QEMU_PPC_FEATURE_HAS_EFP_SINGLE = 0x00400000,

    QEMU_PPC_FEATURE_HAS_EFP_DOUBLE = 0x00200000,

    QEMU_PPC_FEATURE_NO_TB = 0x00100000,

    QEMU_PPC_FEATURE_POWER4 = 0x00080000,

    QEMU_PPC_FEATURE_POWER5 = 0x00040000,

    QEMU_PPC_FEATURE_POWER5_PLUS = 0x00020000,

    QEMU_PPC_FEATURE_CELL = 0x00010000,

    QEMU_PPC_FEATURE_BOOKE = 0x00008000,

    QEMU_PPC_FEATURE_SMT = 0x00004000,

    QEMU_PPC_FEATURE_ICACHE_SNOOP = 0x00002000,

    QEMU_PPC_FEATURE_ARCH_2_05 = 0x00001000,

    QEMU_PPC_FEATURE_PA6T = 0x00000800,

    QEMU_PPC_FEATURE_HAS_DFP = 0x00000400,

    QEMU_PPC_FEATURE_POWER6_EXT = 0x00000200,

    QEMU_PPC_FEATURE_ARCH_2_06 = 0x00000100,

    QEMU_PPC_FEATURE_HAS_VSX = 0x00000080,

    QEMU_PPC_FEATURE_PSERIES_PERFMON_COMPAT = 0x00000040,

    QEMU_PPC_FEATURE_TRUE_LE = 0x00000002,

    QEMU_PPC_FEATURE_PPC_LE = 0x00000001,

};

#define ELF_HWCAP get_elf_hwcap()

static uint32_t get_elf_hwcap(void)

{

    CPUState *e = thread_env;

    uint32_t features = 0;

    /* We don't have to be terribly complete here; the high points are

       Altivec/FP/SPE support.  Anything else is just a bonus.  */

#define GET_FEATURE(flag, feature)                                      \

    do {if (e->insns_flags & flag) features |= feature; } while(0)

    GET_FEATURE(PPC_64B, QEMU_PPC_FEATURE_64);

    GET_FEATURE(PPC_FLOAT, QEMU_PPC_FEATURE_HAS_FPU);

    GET_FEATURE(PPC_ALTIVEC, QEMU_PPC_FEATURE_HAS_ALTIVEC);

    GET_FEATURE(PPC_SPE, QEMU_PPC_FEATURE_HAS_SPE);

    GET_FEATURE(PPC_SPE_SINGLE, QEMU_PPC_FEATURE_HAS_EFP_SINGLE);

    GET_FEATURE(PPC_SPE_DOUBLE, QEMU_PPC_FEATURE_HAS_EFP_DOUBLE);

    GET_FEATURE(PPC_BOOKE, QEMU_PPC_FEATURE_BOOKE);

    GET_FEATURE(PPC_405_MAC, QEMU_PPC_FEATURE_HAS_4xxMAC);

#undef GET_FEATURE

    return features;

}

/*

 * The requirements here are:

 * - keep the final alignment of sp (sp & 0xf)

 * - make sure the 32-bit value at the first 16 byte aligned position of

 *   AUXV is greater than 16 for glibc compatibility.

 *   AT_IGNOREPPC is used for that.

 * - for compatibility with glibc ARCH_DLINFO must always be defined on PPC,

 *   even if DLINFO_ARCH_ITEMS goes to zero or is undefined.

 */

#define DLINFO_ARCH_ITEMS       5

#define ARCH_DLINFO                                     \

    do {                                                \

        NEW_AUX_ENT(AT_DCACHEBSIZE, 0x20);              \

        NEW_AUX_ENT(AT_ICACHEBSIZE, 0x20);              \

        NEW_AUX_ENT(AT_UCACHEBSIZE, 0);                 \

        /*                                              \

         * Now handle glibc compatibility.              \

         */                                             \

        NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC);        \

        NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC);        \

    } while (0)

static inline void init_thread(struct target_pt_regs *_regs, struct image_info *infop)

{

    _regs->gpr[1] = infop->start_stack;

#if defined(TARGET_PPC64) && !defined(TARGET_ABI32)

    _regs->gpr[2] = ldq_raw(infop->entry + 8) + infop->load_addr;

    infop->entry = ldq_raw(infop->entry) + infop->load_addr;

#endif

    _regs->nip = infop->entry;

}

/* See linux kernel: arch/powerpc/include/asm/elf.h.  */

#define ELF_NREG 48

typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];

static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUState *env)

{

    int i;

    target_ulong ccr = 0;

    for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {

        (*regs)[i] = tswapl(env->gpr[i]);

    }

    (*regs)[32] = tswapl(env->nip);

    (*regs)[33] = tswapl(env->msr);

    (*regs)[35] = tswapl(env->ctr);

    (*regs)[36] = tswapl(env->lr);

    (*regs)[37] = tswapl(env->xer);

    for (i = 0; i < ARRAY_SIZE(env->crf); i++) {

        ccr |= env->crf[i] << (32 - ((i + 1) * 4));

    }

    (*regs)[38] = tswapl(ccr);

}

#define USE_ELF_CORE_DUMP

#define ELF_EXEC_PAGESIZE       4096

#endif

#ifdef TARGET_MIPS

#define ELF_START_MMAP 0x80000000

#define elf_check_arch(x) ( (x) == EM_MIPS )

#ifdef TARGET_MIPS64

#define ELF_CLASS   ELFCLASS64

#else

#define ELF_CLASS   ELFCLASS32

#endif

#define ELF_ARCH    EM_MIPS

static inline void init_thread(struct target_pt_regs *regs,

                               struct image_info *infop)

{

    regs->cp0_status = 2 << CP0St_KSU;

    regs->cp0_epc = infop->entry;

    regs->regs[29] = infop->start_stack;

}

/* See linux kernel: arch/mips/include/asm/elf.h.  */

#define ELF_NREG 45

typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];

/* See linux kernel: arch/mips/include/asm/reg.h.  */

enum {

#ifdef TARGET_MIPS64

    TARGET_EF_R0 = 0,

#else

    TARGET_EF_R0 = 6,

#endif

    TARGET_EF_R26 = TARGET_EF_R0 + 26,

    TARGET_EF_R27 = TARGET_EF_R0 + 27,

    TARGET_EF_LO = TARGET_EF_R0 + 32,

    TARGET_EF_HI = TARGET_EF_R0 + 33,

    TARGET_EF_CP0_EPC = TARGET_EF_R0 + 34,

    TARGET_EF_CP0_BADVADDR = TARGET_EF_R0 + 35,

    TARGET_EF_CP0_STATUS = TARGET_EF_R0 + 36,

    TARGET_EF_CP0_CAUSE = TARGET_EF_R0 + 37

};

/* See linux kernel: arch/mips/kernel/process.c:elf_dump_regs.  */

static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUState *env)

{

    int i;

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

        (*regs)[i] = 0;

    }

    (*regs)[TARGET_EF_R0] = 0;

    for (i = 1; i < ARRAY_SIZE(env->active_tc.gpr); i++) {

        (*regs)[TARGET_EF_R0 + i] = tswapl(env->active_tc.gpr[i]);

    }

    (*regs)[TARGET_EF_R26] = 0;

    (*regs)[TARGET_EF_R27] = 0;

    (*regs)[TARGET_EF_LO] = tswapl(env->active_tc.LO[0]);

    (*regs)[TARGET_EF_HI] = tswapl(env->active_tc.HI[0]);

    (*regs)[TARGET_EF_CP0_EPC] = tswapl(env->active_tc.PC);

    (*regs)[TARGET_EF_CP0_BADVADDR] = tswapl(env->CP0_BadVAddr);

    (*regs)[TARGET_EF_CP0_STATUS] = tswapl(env->CP0_Status);

    (*regs)[TARGET_EF_CP0_CAUSE] = tswapl(env->CP0_Cause);

}

#define USE_ELF_CORE_DUMP

#define ELF_EXEC_PAGESIZE        4096

#endif /* TARGET_MIPS */

#ifdef TARGET_MICROBLAZE

#define ELF_START_MMAP 0x80000000

#define elf_check_arch(x) ( (x) == EM_MICROBLAZE || (x) == EM_MICROBLAZE_OLD)

#define ELF_CLASS   ELFCLASS32

#define ELF_ARCH    EM_MICROBLAZE

static inline void init_thread(struct target_pt_regs *regs,

                               struct image_info *infop)

{

    regs->pc = infop->entry;

    regs->r1 = infop->start_stack;

}

#define ELF_EXEC_PAGESIZE        4096

#define USE_ELF_CORE_DUMP

#define ELF_NREG 38

typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];

/* See linux kernel: arch/mips/kernel/process.c:elf_dump_regs.  */

static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUState *env)

{

    int i, pos = 0;

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

        (*regs)[pos++] = tswapl(env->regs[i]);

    }

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

        (*regs)[pos++] = tswapl(env->sregs[i]);

    }

}

#endif /* TARGET_MICROBLAZE */

#ifdef TARGET_SH4

#define ELF_START_MMAP 0x80000000

#define elf_check_arch(x) ( (x) == EM_SH )

#define ELF_CLASS ELFCLASS32

#define ELF_ARCH  EM_SH

static inline void init_thread(struct target_pt_regs *regs,

                               struct image_info *infop)

{

    /* Check other registers XXXXX */

    regs->pc = infop->entry;

    regs->regs[15] = infop->start_stack;

}

/* See linux kernel: arch/sh/include/asm/elf.h.  */

#define ELF_NREG 23

typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];

/* See linux kernel: arch/sh/include/asm/ptrace.h.  */

enum {

    TARGET_REG_PC = 16,

    TARGET_REG_PR = 17,

    TARGET_REG_SR = 18,

    TARGET_REG_GBR = 19,

    TARGET_REG_MACH = 20,

    TARGET_REG_MACL = 21,

    TARGET_REG_SYSCALL = 22

};

static inline void elf_core_copy_regs(target_elf_gregset_t *regs,

                                      const CPUState *env)

{

    int i;

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

        (*regs[i]) = tswapl(env->gregs[i]);

    }

    (*regs)[TARGET_REG_PC] = tswapl(env->pc);

    (*regs)[TARGET_REG_PR] = tswapl(env->pr);

    (*regs)[TARGET_REG_SR] = tswapl(env->sr);

    (*regs)[TARGET_REG_GBR] = tswapl(env->gbr);

    (*regs)[TARGET_REG_MACH] = tswapl(env->mach);

    (*regs)[TARGET_REG_MACL] = tswapl(env->macl);

    (*regs)[TARGET_REG_SYSCALL] = 0; /* FIXME */

}

#define USE_ELF_CORE_DUMP

#define ELF_EXEC_PAGESIZE        4096

#endif

#ifdef TARGET_CRIS

#define ELF_START_MMAP 0x80000000

#define elf_check_arch(x) ( (x) == EM_CRIS )

#define ELF_CLASS ELFCLASS32

#define ELF_ARCH  EM_CRIS

static inline void init_thread(struct target_pt_regs *regs,

                               struct image_info *infop)

{

    regs->erp = infop->entry;

}

#define ELF_EXEC_PAGESIZE        8192

#endif

#ifdef TARGET_M68K

#define ELF_START_MMAP 0x80000000

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

#define ELF_CLASS       ELFCLASS32

#define ELF_ARCH        EM_68K

/* ??? Does this need to do anything?

   #define ELF_PLAT_INIT(_r) */

static inline void init_thread(struct target_pt_regs *regs,

                               struct image_info *infop)

{

    regs->usp = infop->start_stack;

    regs->sr = 0;

    regs->pc = infop->entry;

}

/* See linux kernel: arch/m68k/include/asm/elf.h.  */

#define ELF_NREG 20

typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];

static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUState *env)

{

    (*regs)[0] = tswapl(env->dregs[1]);

    (*regs)[1] = tswapl(env->dregs[2]);

    (*regs)[2] = tswapl(env->dregs[3]);

    (*regs)[3] = tswapl(env->dregs[4]);

    (*regs)[4] = tswapl(env->dregs[5]);

    (*regs)[5] = tswapl(env->dregs[6]);

    (*regs)[6] = tswapl(env->dregs[7]);

    (*regs)[7] = tswapl(env->aregs[0]);

    (*regs)[8] = tswapl(env->aregs[1]);

    (*regs)[9] = tswapl(env->aregs[2]);

    (*regs)[10] = tswapl(env->aregs[3]);

    (*regs)[11] = tswapl(env->aregs[4]);

    (*regs)[12] = tswapl(env->aregs[5]);

    (*regs)[13] = tswapl(env->aregs[6]);

    (*regs)[14] = tswapl(env->dregs[0]);

    (*regs)[15] = tswapl(env->aregs[7]);

    (*regs)[16] = tswapl(env->dregs[0]); /* FIXME: orig_d0 */

    (*regs)[17] = tswapl(env->sr);

    (*regs)[18] = tswapl(env->pc);

    (*regs)[19] = 0;  /* FIXME: regs->format | regs->vector */

}

#define USE_ELF_CORE_DUMP

#define ELF_EXEC_PAGESIZE       8192

#endif

#ifdef TARGET_ALPHA

#define ELF_START_MMAP (0x30000000000ULL)

#define elf_check_arch(x) ( (x) == ELF_ARCH )

#define ELF_CLASS      ELFCLASS64

#define ELF_ARCH       EM_ALPHA

static inline void init_thread(struct target_pt_regs *regs,

                               struct image_info *infop)

{

    regs->pc = infop->entry;

    regs->ps = 8;

    regs->usp = infop->start_stack;

}

#define ELF_EXEC_PAGESIZE        8192

#endif /* TARGET_ALPHA */

#ifndef ELF_PLATFORM

#define ELF_PLATFORM (NULL)

#endif

#ifndef ELF_HWCAP

#define ELF_HWCAP 0

#endif

#ifdef TARGET_ABI32

#undef ELF_CLASS

#define ELF_CLASS ELFCLASS32

#undef bswaptls

#define bswaptls(ptr) bswap32s(ptr)

#endif

#include "elf.h"

struct exec

{

    unsigned int a_info;   /* Use macros N_MAGIC, etc for access */

    unsigned int a_text;   /* length of text, in bytes */

    unsigned int a_data;   /* length of data, in bytes */

    unsigned int a_bss;    /* length of uninitialized data area, in bytes */

    unsigned int a_syms;   /* length of symbol table data in file, in bytes */

    unsigned int a_entry;  /* start address */

    unsigned int a_trsize; /* length of relocation info for text, in bytes */

    unsigned int a_drsize; /* length of relocation info for data, in bytes */

};

#define N_MAGIC(exec) ((exec).a_info & 0xffff)

#define OMAGIC 0407

#define NMAGIC 0410

#define ZMAGIC 0413

#define QMAGIC 0314

/* Necessary parameters */

#define TARGET_ELF_EXEC_PAGESIZE TARGET_PAGE_SIZE

#define TARGET_ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(TARGET_ELF_EXEC_PAGESIZE-1))

#define TARGET_ELF_PAGEOFFSET(_v) ((_v) & (TARGET_ELF_EXEC_PAGESIZE-1))

#define DLINFO_ITEMS 12

static inline void memcpy_fromfs(void * to, const void * from, unsigned long n)

{

    memcpy(to, from, n);

}

#ifdef BSWAP_NEEDED

static void bswap_ehdr(struct elfhdr *ehdr)

{

    bswap16s(&ehdr->e_type);            /* Object file type */

    bswap16s(&ehdr->e_machine);         /* Architecture */

    bswap32s(&ehdr->e_version);         /* Object file version */

    bswaptls(&ehdr->e_entry);           /* Entry point virtual address */

    bswaptls(&ehdr->e_phoff);           /* Program header table file offset */

    bswaptls(&ehdr->e_shoff);           /* Section header table file offset */

    bswap32s(&ehdr->e_flags);           /* Processor-specific flags */

    bswap16s(&ehdr->e_ehsize);          /* ELF header size in bytes */

    bswap16s(&ehdr->e_phentsize);       /* Program header table entry size */

    bswap16s(&ehdr->e_phnum);           /* Program header table entry count */

    bswap16s(&ehdr->e_shentsize);       /* Section header table entry size */

    bswap16s(&ehdr->e_shnum);           /* Section header table entry count */

    bswap16s(&ehdr->e_shstrndx);        /* Section header string table index */

}

static void bswap_phdr(struct elf_phdr *phdr, int phnum)

{

    int i;

    for (i = 0; i < phnum; ++i, ++phdr) {

        bswap32s(&phdr->p_type);        /* Segment type */

        bswap32s(&phdr->p_flags);       /* Segment flags */

        bswaptls(&phdr->p_offset);      /* Segment file offset */

        bswaptls(&phdr->p_vaddr);       /* Segment virtual address */

        bswaptls(&phdr->p_paddr);       /* Segment physical address */

        bswaptls(&phdr->p_filesz);      /* Segment size in file */

        bswaptls(&phdr->p_memsz);       /* Segment size in memory */

        bswaptls(&phdr->p_align);       /* Segment alignment */

    }

}

static void bswap_shdr(struct elf_shdr *shdr, int shnum)

{

    int i;

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

        bswap32s(&shdr->sh_name);

        bswap32s(&shdr->sh_type);

        bswaptls(&shdr->sh_flags);

        bswaptls(&shdr->sh_addr);

        bswaptls(&shdr->sh_offset);

        bswaptls(&shdr->sh_size);

        bswap32s(&shdr->sh_link);

        bswap32s(&shdr->sh_info);

        bswaptls(&shdr->sh_addralign);

        bswaptls(&shdr->sh_entsize);

    }

}

static void bswap_sym(struct elf_sym *sym)

{

    bswap32s(&sym->st_name);

    bswaptls(&sym->st_value);

    bswaptls(&sym->st_size);

    bswap16s(&sym->st_shndx);

}

#else

static inline void bswap_ehdr(struct elfhdr *ehdr) { }

static inline void bswap_phdr(struct elf_phdr *phdr, int phnum) { }

static inline void bswap_shdr(struct elf_shdr *shdr, int shnum) { }

static inline void bswap_sym(struct elf_sym *sym) { }

#endif

#ifdef USE_ELF_CORE_DUMP

static int elf_core_dump(int, const CPUState *);

#endif /* USE_ELF_CORE_DUMP */

static void load_symbols(struct elfhdr *hdr, int fd, abi_ulong load_bias);

/* Verify the portions of EHDR within E_IDENT for the target.

   This can be performed before bswapping the entire header.  */

static bool elf_check_ident(struct elfhdr *ehdr)

{

    return (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_CLASS] == ELF_CLASS

            && ehdr->e_ident[EI_DATA] == ELF_DATA

            && ehdr->e_ident[EI_VERSION] == EV_CURRENT);

}

/* Verify the portions of EHDR outside of E_IDENT for the target.

   This has to wait until after bswapping the header.  */

static bool elf_check_ehdr(struct elfhdr *ehdr)

{

    return (elf_check_arch(ehdr->e_machine)

            && ehdr->e_ehsize == sizeof(struct elfhdr)

            && ehdr->e_phentsize == sizeof(struct elf_phdr)

            && ehdr->e_shentsize == sizeof(struct elf_shdr)

            && (ehdr->e_type == ET_EXEC || ehdr->e_type == ET_DYN));

}

/*

 * 'copy_elf_strings()' copies argument/envelope strings from user

 * memory to free pages in kernel mem. These are in a format ready

 * to be put directly into the top of new user memory.

 *

 */

static abi_ulong copy_elf_strings(int argc,char ** argv, void **page,

                                  abi_ulong p)

{

    char *tmp, *tmp1, *pag = NULL;

    int len, offset = 0;

    if (!p) {

        return 0;       /* bullet-proofing */

    }

    while (argc-- > 0) {

        tmp = argv[argc];

        if (!tmp) {

            fprintf(stderr, "VFS: argc is wrong");

            exit(-1);

        }

        tmp1 = tmp;

        while (*tmp++);

        len = tmp - tmp1;

        if (p < len) {  /* this shouldn't happen - 128kB */

            return 0;

        }

        while (len) {

            --p; --tmp; --len;

            if (--offset < 0) {

                offset = p % TARGET_PAGE_SIZE;

                pag = (char *)page[p/TARGET_PAGE_SIZE];

                if (!pag) {

                    pag = (char *)malloc(TARGET_PAGE_SIZE);

                    memset(pag, 0, TARGET_PAGE_SIZE);

                    page[p/TARGET_PAGE_SIZE] = pag;

                    if (!pag)

                        return 0;

                }

            }

            if (len == 0 || offset == 0) {

                *(pag + offset) = *tmp;

            }

            else {

                int bytes_to_copy = (len > offset) ? offset : len;

                tmp -= bytes_to_copy;

                p -= bytes_to_copy;

                offset -= bytes_to_copy;

                len -= bytes_to_copy;

                memcpy_fromfs(pag + offset, tmp, bytes_to_copy + 1);

            }

        }

    }

    return p;

}

static abi_ulong setup_arg_pages(abi_ulong p, struct linux_binprm *bprm,

                                 struct image_info *info)

{

    abi_ulong stack_base, size, error, guard;

    int i;

    /* Create enough stack to hold everything.  If we don't use

       it for args, we'll use it for something else.  */

    size = guest_stack_size;

    if (size < MAX_ARG_PAGES*TARGET_PAGE_SIZE) {

        size = MAX_ARG_PAGES*TARGET_PAGE_SIZE;

    }

    guard = TARGET_PAGE_SIZE;

    if (guard < qemu_real_host_page_size) {

        guard = qemu_real_host_page_size;

    }

    error = target_mmap(0, size + guard, PROT_READ | PROT_WRITE,

                        MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

    if (error == -1) {

        perror("mmap stack");

        exit(-1);

    }

    /* We reserve one extra page at the top of the stack as guard.  */

    target_mprotect(error, guard, PROT_NONE);

    info->stack_limit = error + guard;

    stack_base = info->stack_limit + size - MAX_ARG_PAGES*TARGET_PAGE_SIZE;

    p += stack_base;

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

        if (bprm->page[i]) {

            info->rss++;

            /* FIXME - check return value of memcpy_to_target() for failure */

            memcpy_to_target(stack_base, bprm->page[i], TARGET_PAGE_SIZE);

            free(bprm->page[i]);

        }

        stack_base += TARGET_PAGE_SIZE;

    }

    return p;

}

/* Map and zero the bss.  We need to explicitly zero any fractional pages

   after the data section (i.e. bss).  */

static void zero_bss(abi_ulong elf_bss, abi_ulong last_bss, int prot)

{

    uintptr_t host_start, host_map_start, host_end;

    last_bss = TARGET_PAGE_ALIGN(last_bss);

    /* ??? There is confusion between qemu_real_host_page_size and

       qemu_host_page_size here and elsewhere in target_mmap, which

       may lead to the end of the data section mapping from the file

       not being mapped.  At least there was an explicit test and

       comment for that here, suggesting that "the file size must

       be known".  The comment probably pre-dates the introduction

       of the fstat system call in target_mmap which does in fact

       find out the size.  What isn't clear is if the workaround

       here is still actually needed.  For now, continue with it,

       but merge it with the "normal" mmap that would allocate the bss.  */

    host_start = (uintptr_t) g2h(elf_bss);

    host_end = (uintptr_t) g2h(last_bss);

    host_map_start = (host_start + qemu_real_host_page_size - 1);

    host_map_start &= -qemu_real_host_page_size;

    if (host_map_start < host_end) {

        void *p = mmap((void *)host_map_start, host_end - host_map_start,

                       prot, MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

        if (p == MAP_FAILED) {

            perror("cannot mmap brk");

            exit(-1);

        }

        /* Since we didn't use target_mmap, make sure to record

           the validity of the pages with qemu.  */

        page_set_flags(elf_bss & TARGET_PAGE_MASK, last_bss, prot|PAGE_VALID);

    }

    if (host_start < host_map_start) {

        memset((void *)host_start, 0, host_map_start - host_start);

    }

}

static abi_ulong create_elf_tables(abi_ulong p, int argc, int envc,

                                   struct elfhdr *exec,

                                   struct image_info *info,

                                   struct image_info *interp_info)

{

    abi_ulong sp;

    int size;

    abi_ulong u_platform;

    const char *k_platform;

    const int n = sizeof(elf_addr_t);

    sp = p;

    u_platform = 0;

    k_platform = ELF_PLATFORM;

    if (k_platform) {

        size_t len = strlen(k_platform) + 1;

        sp -= (len + n - 1) & ~(n - 1);

        u_platform = sp;

        /* FIXME - check return value of memcpy_to_target() for failure */

        memcpy_to_target(sp, k_platform, len);

    }

    /*

     * Force 16 byte _final_ alignment here for generality.

     */

    sp = sp &~ (abi_ulong)15;

    size = (DLINFO_ITEMS + 1) * 2;

    if (k_platform)

        size += 2;

#ifdef DLINFO_ARCH_ITEMS

    size += DLINFO_ARCH_ITEMS * 2;

#endif

    size += envc + argc + 2;

    size += 1;  /* argc itself */

    size *= n;

    if (size & 15)

        sp -= 16 - (size & 15);

    /* This is correct because Linux defines

     * elf_addr_t as Elf32_Off / Elf64_Off

     */

#define NEW_AUX_ENT(id, val) do {               \

        sp -= n; put_user_ual(val, sp);         \

        sp -= n; put_user_ual(id, sp);          \

    } while(0)

    NEW_AUX_ENT (AT_NULL, 0);

    /* There must be exactly DLINFO_ITEMS entries here.  */

    NEW_AUX_ENT(AT_PHDR, (abi_ulong)(info->load_addr + exec->e_phoff));

    NEW_AUX_ENT(AT_PHENT, (abi_ulong)(sizeof (struct elf_phdr)));

    NEW_AUX_ENT(AT_PHNUM, (abi_ulong)(exec->e_phnum));

    NEW_AUX_ENT(AT_PAGESZ, (abi_ulong)(TARGET_PAGE_SIZE));

    NEW_AUX_ENT(AT_BASE, (abi_ulong)(interp_info ? interp_info->load_addr : 0));

    NEW_AUX_ENT(AT_FLAGS, (abi_ulong)0);

    NEW_AUX_ENT(AT_ENTRY, info->entry);

    NEW_AUX_ENT(AT_UID, (abi_ulong) getuid());

    NEW_AUX_ENT(AT_EUID, (abi_ulong) geteuid());

    NEW_AUX_ENT(AT_GID, (abi_ulong) getgid());

    NEW_AUX_ENT(AT_EGID, (abi_ulong) getegid());

    NEW_AUX_ENT(AT_HWCAP, (abi_ulong) ELF_HWCAP);

    NEW_AUX_ENT(AT_CLKTCK, (abi_ulong) sysconf(_SC_CLK_TCK));

    if (k_platform)

        NEW_AUX_ENT(AT_PLATFORM, u_platform);

#ifdef ARCH_DLINFO

    /*

     * ARCH_DLINFO must come last so platform specific code can enforce

     * special alignment requirements on the AUXV if necessary (eg. PPC).

     */

    ARCH_DLINFO;

#endif

#undef NEW_AUX_ENT

    info->saved_auxv = sp;

    sp = loader_build_argptr(envc, argc, sp, p, 0);

    return sp;

}

/* Load an ELF image into the address space.

   IMAGE_NAME is the filename of the image, to use in error messages.

   IMAGE_FD is the open file descriptor for the image.

   BPRM_BUF is a copy of the beginning of the file; this of course

   contains the elf file header at offset 0.  It is assumed that this

   buffer is sufficiently aligned to present no problems to the host

   in accessing data at aligned offsets within the buffer.

   On return: INFO values will be filled in, as necessary or available.  */

static void load_elf_image(const char *image_name, int image_fd,

                           struct image_info *info, char **pinterp_name,

                           char bprm_buf[BPRM_BUF_SIZE])

{

    struct elfhdr *ehdr = (struct elfhdr *)bprm_buf;

    struct elf_phdr *phdr;

    abi_ulong load_addr, load_bias, loaddr, hiaddr, error;

    int i, retval;

    const char *errmsg;

    /* First of all, some simple consistency checks */

    errmsg = "Invalid ELF image for this architecture";

    if (!elf_check_ident(ehdr)) {

        goto exit_errmsg;

    }

    bswap_ehdr(ehdr);

    if (!elf_check_ehdr(ehdr)) {

        goto exit_errmsg;

    }

    i = ehdr->e_phnum * sizeof(struct elf_phdr);

    if (ehdr->e_phoff + i <= BPRM_BUF_SIZE) {

        phdr = (struct elf_phdr *)(bprm_buf + ehdr->e_phoff);

    } else {

        phdr = (struct elf_phdr *) alloca(i);

        retval = pread(image_fd, phdr, i, ehdr->e_phoff);

        if (retval != i) {

            goto exit_read;

        }

    }

    bswap_phdr(phdr, ehdr->e_phnum);

    /* Find the maximum size of the image and allocate an appropriate

       amount of memory to handle that.  */

    loaddr = -1, hiaddr = 0;

    for (i = 0; i < ehdr->e_phnum; ++i) {

        if (phdr[i].p_type == PT_LOAD) {

            abi_ulong a = phdr[i].p_vaddr;

            if (a < loaddr) {

                loaddr = a;

            }

            a += phdr[i].p_memsz;

            if (a > hiaddr) {

                hiaddr = a;

            }

        }

    }

    load_addr = loaddr;

    if (ehdr->e_type == ET_DYN) {

        /* The image indicates that it can be loaded anywhere.  Find a

           location that can hold the memory space required.  If the

           image is pre-linked, LOADDR will be non-zero.  Since we do

           not supply MAP_FIXED here we'll use that address if and

           only if it remains available.  */

        load_addr = target_mmap(loaddr, hiaddr - loaddr, PROT_NONE,

                                MAP_PRIVATE | MAP_ANON | MAP_NORESERVE,

                                -1, 0);

        if (load_addr == -1) {

            goto exit_perror;

        }

    } else if (pinterp_name != NULL) {

        /* This is the main executable.  Make sure that the low

           address does not conflict with MMAP_MIN_ADDR or the

           QEMU application itself.  */

#if defined(CONFIG_USE_GUEST_BASE)

        /*

         * In case where user has not explicitly set the guest_base, we

         * probe here that should we set it automatically.

         */

        if (!have_guest_base && !reserved_va) {

            unsigned long host_start, real_start, host_size;

            /* Round addresses to page boundaries.  */

            loaddr &= qemu_host_page_mask;

            hiaddr = HOST_PAGE_ALIGN(hiaddr);

            if (loaddr < mmap_min_addr) {

                host_start = HOST_PAGE_ALIGN(mmap_min_addr);

            } else {

                host_start = loaddr;

                if (host_start != loaddr) {

                    errmsg = "Address overflow loading ELF binary";

                    goto exit_errmsg;

                }

            }

            host_size = hiaddr - loaddr;

            while (1) {

                /* Do not use mmap_find_vma here because that is limited to the

                   guest address space.  We are going to make the

                   guest address space fit whatever we're given.  */

                real_start = (unsigned long)

                    mmap((void *)host_start, host_size, PROT_NONE,

                         MAP_ANONYMOUS | MAP_PRIVATE | MAP_NORESERVE, -1, 0);

                if (real_start == (unsigned long)-1) {

                    goto exit_perror;

                }

                if (real_start == host_start) {

                    break;

                }

                /* That address didn't work.  Unmap and try a different one.

                   The address the host picked because is typically right at

                   the top of the host address space and leaves the guest with

                   no usable address space.  Resort to a linear search.  We

                   already compensated for mmap_min_addr, so this should not

                   happen often.  Probably means we got unlucky and host

                   address space randomization put a shared library somewhere

                   inconvenient.  */

                munmap((void *)real_start, host_size);

                host_start += qemu_host_page_size;

                if (host_start == loaddr) {

                    /* Theoretically possible if host doesn't have any suitably

                       aligned areas.  Normally the first mmap will fail.  */

                    errmsg = "Unable to find space for application";

                    goto exit_errmsg;

                }

            }

            qemu_log("Relocating guest address space from 0x"

                     TARGET_ABI_FMT_lx " to 0x%lx\n", loaddr, real_start);

            guest_base = real_start - loaddr;

        }

#endif

    }

    load_bias = load_addr - loaddr;

    info->load_bias = load_bias;

    info->load_addr = load_addr;

    info->entry = ehdr->e_entry + load_bias;

    info->start_code = -1;

    info->end_code = 0;

    info->start_data = -1;

    info->end_data = 0;

    info->brk = 0;

    for (i = 0; i < ehdr->e_phnum; i++) {

        struct elf_phdr *eppnt = phdr + i;

        if (eppnt->p_type == PT_LOAD) {

            abi_ulong vaddr, vaddr_po, vaddr_ps, vaddr_ef, vaddr_em;

            int elf_prot = 0;

            if (eppnt->p_flags & PF_R) elf_prot =  PROT_READ;

            if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;

            if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;

            vaddr = load_bias + eppnt->p_vaddr;

            vaddr_po = TARGET_ELF_PAGEOFFSET(vaddr);

            vaddr_ps = TARGET_ELF_PAGESTART(vaddr);

            error = target_mmap(vaddr_ps, eppnt->p_filesz + vaddr_po,

                                elf_prot, MAP_PRIVATE | MAP_FIXED,

                                image_fd, eppnt->p_offset - vaddr_po);

            if (error == -1) {

                goto exit_perror;

            }

            vaddr_ef = vaddr + eppnt->p_filesz;

            vaddr_em = vaddr + eppnt->p_memsz;

            /* If the load segment requests extra zeros (e.g. bss), map it.  */

            if (vaddr_ef < vaddr_em) {

                zero_bss(vaddr_ef, vaddr_em, elf_prot);

            }

            /* Find the full program boundaries.  */

            if (elf_prot & PROT_EXEC) {

                if (vaddr < info->start_code) {

                    info->start_code = vaddr;

                }

                if (vaddr_ef > info->end_code) {