Archipelago » qemu

linux_user="no"

darwin_user="no"

bsd_user="no"

build_docs="yes"

uname_release=""

curses="yes"

  ;;

  --enable-bsd-user) bsd_user="yes"

  ;;

  --enable-uname-release=*) uname_release="$optarg"

  ;;

  --sparc_cpu=*)

# If cpu ~= sparc and  sparc_cpu hasn't been defined, plug in the right

# ARCH_CFLAGS/ARCH_LDFLAGS (assume sparc_v8plus for 32-bit and sparc_v9 for 64-bit)

#

case "$cpu" in

    sparc) if test -z "$sparc_cpu" ; then

               ARCH_CFLAGS="-m32 -mcpu=ultrasparc -D__sparc_v8plus__"

    i386)

           ARCH_CFLAGS="-m32"

           ARCH_LDFLAGS="-m32"

           ;;

    x86_64)

           ARCH_CFLAGS="-m64"

           ARCH_LDFLAGS="-m64"

           ;;

esac

if test x"$show_help" = x"yes" ; then

cat << EOF

echo "  --disable-darwin-user    disable all darwin usermode emulation targets"

echo "  --enable-bsd-user        enable all BSD usermode emulation targets"

echo "  --disable-bsd-user       disable all BSD usermode emulation targets"

echo "  --fmod-lib               path to FMOD library"

echo "  --fmod-inc               path to FMOD includes"

echo "  --oss-lib                path to OSS library"

[ ! -z "$uname_release" ] && \

echo "uname -r          $uname_release"

echo "NPTL support      $nptl"

echo "vde support       $vde"

echo "AIO support       $aio"

echo "IO thread         $io_thread"

if test "$target_user_only" = "yes" -a "$elfload32" = "yes"; then

  echo "TARGET_HAS_ELFLOAD32=y" >> $config_mak

fi

if test "$target_bsd_user" = "yes" ; then

  echo "CONFIG_BSD_USER=y" >> $config_mak

fi

/* On some host systems the guest address space is reserved on the host.

 * This allows the guest address space to be offset to a convenient location.

 */

/* All direct uses of g2h and h2g need to go away for usermode softmmu.  */

#define g2h(x) ((void *)((unsigned long)(x) + GUEST_BASE))

    info->mmap = 0;

    elf_entry = (abi_ulong) elf_ex.e_entry;

    /* Do this so that we can load the interpreter, if need be.  We will

       change some of these later */

    info->rss = 0;

char *exec_path;

int singlestep;

static const char *interp_prefix = CONFIG_QEMU_PREFIX;

const char *qemu_uname_release = CONFIG_UNAME_RELEASE;

           "-E var=value      sets/modifies targets environment variable(s)\n"

           "-U var            unsets targets environment variable(s)\n"

           "-0 argv0          forces target process argv[0] to be argv0\n"

           "\n"

           "Debug options:\n"

           "-d options   activate log (logfile=%s)\n"

#endif

                exit(1);

            }

        } else if (!strcmp(r, "drop-ld-preload")) {

            (void) envlist_unsetenv(envlist, "LD_PRELOAD");

        } else if (!strcmp(r, "singlestep")) {

    target_environ = envlist_to_environ(envlist, NULL);

    envlist_free(envlist);

    /*

     * Prepare copy of argv vector for target.

     */

    free(target_environ);

    if (qemu_log_enabled()) {

        log_page_dump();

        qemu_log("start_brk   0x" TARGET_ABI_FMT_lx "\n", info->start_brk);

void task_settid(TaskState *);

void stop_all_tasks(void);

extern const char *qemu_uname_release;

/* ??? See if we can avoid exposing so much of the loader internals.  */

/*

@subsection Command line options

@example

@end example

@table @option

Set the x86 stack size in bytes (default=524288)

@item -cpu model

Select CPU model (-cpu ? for list and additional feature selection)

@end table

Debug options:

# endif

    *label_ptr += ((void *) s->code_ptr - (void *) label_ptr - 8) >> 2;

    switch (opc) {

    case 0:

        tcg_out_ld8_12(s, COND_AL, data_reg, addr_reg, 0);

# endif

    *label_ptr += ((void *) s->code_ptr - (void *) label_ptr - 8) >> 2;

    switch (opc) {

    case 0:

        tcg_out_st8_12(s, COND_AL, data_reg, addr_reg, 0);

#define TCG_TARGET_STACK_ALIGN		8

#define TCG_TARGET_CALL_STACK_OFFSET	0

enum {

    /* Note: must be synced with dyngen-exec.h */

    TCG_AREG0 = TCG_REG_R7,

};

#endif

/* XXX: qemu_ld and qemu_st could be modified to clobber only EDX and

   EAX. It will be useful once fixed registers globals are less

   common. */

    switch(opc) {

    case 0:

        /* movzbl */

        break;

    case 0 | 4:

        /* movsbl */

        break;

    case 1:

        /* movzwl */

        if (bswap) {

            /* rolw $8, data_reg */

            tcg_out8(s, 0x66); 

        break;

    case 1 | 4:

        /* movswl */

        if (bswap) {

            /* rolw $8, data_reg */

            tcg_out8(s, 0x66); 

        break;

    case 2:

        /* movl (r0), data_reg */

        if (bswap) {

            /* bswap */

            tcg_out_opc(s, (0xc8 + data_reg) | P_EXT);

            r0 = r1;

        }

        if (!bswap) {

        } else {

            tcg_out_opc(s, (0xc8 + data_reg) | P_EXT);

            /* bswap */

            tcg_out_opc(s, (0xc8 + data_reg2) | P_EXT);

        }

    switch(opc) {

    case 0:

        /* movb */

        break;

    case 1:

        if (bswap) {

        }

        /* movw */

        tcg_out8(s, 0x66);

        break;

    case 2:

        if (bswap) {

            data_reg = r1;

        }

        /* movl */

        break;

    case 3:

        if (bswap) {

            tcg_out_mov(s, r1, data_reg2);

            /* bswap data_reg */

            tcg_out_opc(s, (0xc8 + r1) | P_EXT);

            tcg_out_mov(s, r1, data_reg);

            /* bswap data_reg */

            tcg_out_opc(s, (0xc8 + r1) | P_EXT);

        } else {

        }

        break;

    default:

#define TCG_TARGET_HAS_ext16s_i32

#define TCG_TARGET_HAS_rot_i32

/* Note: must be synced with dyngen-exec.h */

#define TCG_AREG0 TCG_REG_EBP

#define TCG_AREG1 TCG_REG_EBX

#include "qemu-common.h"

#include "cache-utils.h"

/* Note: the long term plan is to reduce the dependancies on the QEMU

   CPU definitions. Currently they are used for qemu_ld/st

#include "tcg-op.h"

#include "elf.h"

static void patch_reloc(uint8_t *code_ptr, int type, 

                        tcg_target_long value, tcg_target_long addend);

                            int opc)

{

    int addr_reg, data_reg, r0, r1, mem_index, s_bits, bswap, rexw;

#if defined(CONFIG_SOFTMMU)

    uint8_t *label1_ptr, *label2_ptr;

#endif

    /* add x(r1), r0 */

    tcg_out_modrm_offset(s, 0x03 | P_REXW, r0, r1, offsetof(CPUTLBEntry, addend) - 

                         offsetof(CPUTLBEntry, addr_read));

#else

#endif    

#ifdef TARGET_WORDS_BIGENDIAN

    switch(opc) {

    case 0:

        /* movzbl */

        break;

    case 0 | 4:

        /* movsbX */

        break;

    case 1:

        /* movzwl */

        if (bswap) {

            /* rolw $8, data_reg */

            tcg_out8(s, 0x66); 

    case 1 | 4:

        if (bswap) {

            /* movzwl */

            /* rolw $8, data_reg */

            tcg_out8(s, 0x66); 

            tcg_out_modrm(s, 0xc1, 0, data_reg);

            tcg_out_modrm(s, 0xbf | P_EXT | rexw, data_reg, data_reg);

        } else {

            /* movswX */

        }

        break;

    case 2:

        /* movl (r0), data_reg */

        if (bswap) {

            /* bswap */

            tcg_out_opc(s, (0xc8 + (data_reg & 7)) | P_EXT, 0, data_reg, 0);

    case 2 | 4:

        if (bswap) {

            /* movl (r0), data_reg */

            /* bswap */

            tcg_out_opc(s, (0xc8 + (data_reg & 7)) | P_EXT, 0, data_reg, 0);

            /* movslq */

            tcg_out_modrm(s, 0x63 | P_REXW, data_reg, data_reg);

        } else {

            /* movslq */

        }

        break;

    case 3:

        /* movq (r0), data_reg */

        if (bswap) {

            /* bswap */

            tcg_out_opc(s, (0xc8 + (data_reg & 7)) | P_EXT | P_REXW, 0, data_reg, 0);

                            int opc)

{

    int addr_reg, data_reg, r0, r1, mem_index, s_bits, bswap, rexw;

#if defined(CONFIG_SOFTMMU)

    uint8_t *label1_ptr, *label2_ptr;

#endif

    /* add x(r1), r0 */

    tcg_out_modrm_offset(s, 0x03 | P_REXW, r0, r1, offsetof(CPUTLBEntry, addend) - 

                         offsetof(CPUTLBEntry, addr_write));

#else

#endif

#ifdef TARGET_WORDS_BIGENDIAN

    switch(opc) {

    case 0:

        /* movb */

        break;

    case 1:

        if (bswap) {

        }

        /* movw */

        tcg_out8(s, 0x66);

        break;

    case 2:

        if (bswap) {

            data_reg = r1;

        }

        /* movl */

        break;

    case 3:

        if (bswap) {

            data_reg = r1;

        }

        /* movq */

        break;

    default:

        tcg_abort();

#define TCG_TARGET_HAS_rot_i32

#define TCG_TARGET_HAS_rot_i64

/* Note: must be synced with dyngen-exec.h */

#define TCG_AREG0 TCG_REG_R14

#define TCG_AREG1 TCG_REG_R15