Archipelago » qemu

endif

ifdef CONFIG_LINUX_USER

VPATH+=:$(SRC_PATH)/linux-user

endif

BASE_CFLAGS=

BASE_LDFLAGS=

    TARGET_ARCH2=mips64el

  endif

endif

QEMU_USER=qemu-$(TARGET_ARCH2)

# system emulator name

ifdef CONFIG_SOFTMMU

    fi

# the following are Linux specific

    if [ "$linux_user" = "yes" ] ; then

    fi

# the following are Darwin specific

    if [ "$darwin_user" = "yes" ] ; then

[ "$target_cpu" = "armeb" ] && target_bigendian=yes

[ "$target_cpu" = "sparc" ] && target_bigendian=yes

[ "$target_cpu" = "sparc64" ] && target_bigendian=yes

[ "$target_cpu" = "ppc" ] && target_bigendian=yes

[ "$target_cpu" = "ppcemb" ] && target_bigendian=yes

[ "$target_cpu" = "ppc64" ] && target_bigendian=yes

  echo "#define TARGET_SPARC 1" >> $config_h

  echo "#define TARGET_SPARC64 1" >> $config_h

  elfload32="yes"

elif test "$target_cpu" = "ppc" ; then

  echo "TARGET_ARCH=ppc" >> $config_mak

  echo "#define TARGET_ARCH \"ppc\"" >> $config_h

  echo "#define CONFIG_DARWIN_USER 1" >> $config_h

fi

  echo "CONFIG_SOFTFLOAT=yes" >> $config_mak

  echo "#define CONFIG_SOFTFLOAT 1" >> $config_h

fi

#define __USER_DS	(1)

struct target_pt_regs {

/* JRP - These are the values provided to a0-a2 by PALcode */

/* These are saved by PAL-code: */

/* Those is needed by qemu to temporary store the user stack pointer */

};

#define UNAME_MACHINE "alpha"

/* this struct defines a stack used during syscall handling */

typedef struct target_sigaltstack {

} target_stack_t;

#define TARGET_MINSIGSTKSZ	4096

#define TARGET_SIGSTKSZ		16384

{

    return state->ir[IR_SP];

}

   stack during a system call. */

struct target_pt_regs {

};

#define ARM_cpsr	uregs[16]

/* this struct defines a stack used during syscall handling */

typedef struct target_sigaltstack {

} target_stack_t;

#define TARGET_MINSIGSTKSZ	2048

#define TARGET_SIGSTKSZ		8192

{

   return state->regs[13];

}

/* this struct defines a stack used during syscall handling */

typedef struct target_sigaltstack {

} target_stack_t;

#define TARGET_MINSIGSTKSZ    2048

#define TARGET_SIGSTKSZ       8192

{

    return state->regs[14];

}

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

{

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

    regs->ARM_cpsr = 0x10;

    if (infop->entry & 1)

#define ELF_START_MMAP 0x80000000

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

#define ELF_CLASS   ELFCLASS64

#define ELF_DATA    ELFDATA2MSB

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

{

    regs->tstate = 0;

    regs->pc = infop->entry;

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

    regs->y = 0;

    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;

}

#else

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

{

#ifdef TARGET_PPC64

#endif

    _regs->msr = 1 << MSR_PR; /* Set user mode */

     * execution of PPC BSD programs.

     */

    _regs->gpr[3] = tgetl(pos);

    _regs->gpr[4] = pos;

        tmp = ldl(pos);

    _regs->gpr[5] = pos;

}

#define ELF_HWCAP 0

#endif

#undef ELF_CLASS

#undef bswaptls

#define bswaptls(ptr) bswap32s(ptr)

#endif

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

 *

 */

{

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

    int len, offset = 0;

    return p;

}

{

    int i;

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

    return p;

}

{

	/* page-align the start and end addresses... */

        start = HOST_PAGE_ALIGN(start);

/* We need to explicitly zero any fractional pages after the data

   section (i.e. bss).  This would contain the junk from the file that

   should not be in memory. */

{

	if (elf_bss >= last_bss)

		return;

           patch target_mmap(), but it is more complicated as the file

           size must be known */

        if (qemu_real_host_page_size < qemu_host_page_size) {

            end_addr1 = (elf_bss + qemu_real_host_page_size - 1) &

                ~(qemu_real_host_page_size - 1);

            end_addr = HOST_PAGE_ALIGN(elf_bss);

}

{

        int size;

        const char *k_platform;

        const int n = sizeof(elf_addr_t);

	/*

	 * Force 16 byte _final_ alignment here for generality.

	 */

        size = (DLINFO_ITEMS + 1) * 2;

        if (k_platform)

          size += 2;

        NEW_AUX_ENT (AT_NULL, 0);

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

        NEW_AUX_ENT(AT_ENTRY, load_bias + exec->e_entry);

        if (k_platform)

            NEW_AUX_ENT(AT_PLATFORM, u_platform);

#ifdef ARCH_DLINFO

}

{

	struct elf_phdr *elf_phdata  =  NULL;

	struct elf_phdr *eppnt;

	int load_addr_set = 0;

	int retval;

	int i;

	elf_bss = 0;

	if ((interp_elf_ex->e_type != ET_EXEC &&

             interp_elf_ex->e_type != ET_DYN) ||

	   !elf_check_arch(interp_elf_ex->e_machine)) {

	}

	/* Now read in all of the header information */

	if (sizeof(struct elf_phdr) * interp_elf_ex->e_phnum > TARGET_PAGE_SIZE)

	elf_phdata =  (struct elf_phdr *)

		malloc(sizeof(struct elf_phdr) * interp_elf_ex->e_phnum);

	if (!elf_phdata)

	/*

	 * If the size of this structure has changed, then punt, since

	 */

	if (interp_elf_ex->e_phentsize != sizeof(struct elf_phdr)) {

	    free(elf_phdata);

        }

	retval = lseek(interpreter_fd, interp_elf_ex->e_phoff, SEEK_SET);

	  if (eppnt->p_type == PT_LOAD) {

	    int elf_type = MAP_PRIVATE | MAP_DENYWRITE;

	    int elf_prot = 0;

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

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

	      /* Real error */

	      close(interpreter_fd);

	      free(elf_phdata);

	    }

	    if (!load_addr_set && interp_elf_ex->e_type == ET_DYN) {

	free(elf_phdata);

	*interp_load_addr = load_addr;

}

/* Best attempt to load symbols from this ELF object. */

    struct elfhdr interp_elf_ex;

    struct exec interp_ex;

    int interpreter_fd = -1; /* avoid warning */

    int load_addr_set = 0;

    unsigned int interpreter_type = INTERPRETER_NONE;

    unsigned char ibcs2_interpreter;

    int i;

    struct elf_phdr * elf_ppnt;

    struct elf_phdr *elf_phdata;

    int retval;

    char * elf_interpreter;

    int status;

    char passed_fileno[6];

    ibcs2_interpreter = 0;

    elf_brk = 0;

    elf_interpreter = NULL;

    end_code = 0;

    start_data = 0;

    end_data = 0;

    /* OK, This is the point of no return */

    info->end_data = 0;

    info->end_code = 0;

    info->mmap = 0;

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

       change some of these later */

    for(i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum; i++, elf_ppnt++) {

        int elf_prot = 0;

        int elf_flags = 0;

	if (elf_ppnt->p_type != PT_LOAD)

            continue;

	close(interpreter_fd);

	free(elf_interpreter);

	    printf("Unable to load interpreter\n");

	    free(elf_phdata);

	    exit(-1);

#define load_elf_binary load_elf_binary32

#define do_init_thread do_init_thread32

struct flat_hdr {

	char magic[4];

	/* (It is assumed that data_end through bss_end forms the bss segment.) */

};

#define FLAT_FLAG_RAM    0x0001 /* load program entirely into RAM */

#define UNLOADED_LIB 0x7ff000ff		/* Placeholder for unused library */

struct lib_info {

    short loaded;		/* Has this library been loaded? */

};

 */

/* Push a block of strings onto the guest stack.  */

{

    int len;

    return p;

}

{

    void *buf;

    int ret;

/****************************************************************************/

{

    int id;

#ifdef CONFIG_BINFMT_SHARED_FLAT

#error needs checking

/****************************************************************************/

static int load_flat_file(struct linux_binprm * bprm,

{

    struct flat_hdr * hdr;

    int i, rev, relocs = 0;

    hdr = ((struct flat_hdr *) bprm->buf);		/* exec-header */

    /*

     * calculate the extra space we need to map in

     */

    if (extra < bss_len + stack_len)

        extra = bss_len + stack_len;

    /* Add space for library base pointers.  Make sure this does not

       misalign the  doesn't misalign the data segment.  */

    /*

     * there are a couple of cases here,  the separate code/data

#ifdef CONFIG_BINFMT_ZFLAT

        if (flags & FLAT_FLAG_GZDATA) {

            result = decompress_exec(bprm, fpos, (char *) datapos,

        } else

#endif

        {

            result = target_pread(bprm->fd, datapos,

                                  fpos);

        }

        if (result < 0) {

                                  text_len, 0);

            if (result >= 0) {

                result = target_pread(bprm->fd, datapos,

                    ntohl(hdr->data_start));

            }

        }

    if (flags & FLAT_FLAG_GOTPIC) {

        rp = datapos;

        while (1) {

            addr = tgetl(rp);

            if (addr == -1)

                break;

                    return -ENOEXEC;

                tputl(rp, addr);

            }

        }

    }

     */

    if (rev > OLD_FLAT_VERSION) {

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

            /* Get the address of the pointer to be

               relocated (of course, the address has to be

               relocated first).  */

            addr = flat_get_relocate_addr(relval);

            rp = calc_reloc(addr, libinfo, id, 1);

            if (rp == RELOC_FAILED)

        }

    } else {

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

            old_reloc(&libinfo[0], relval);

        }

    }

                    struct image_info * info)

{

    struct lib_info libinfo[MAX_SHARED_LIBS];

    int res;

    int i, j;

    /* Update data segment pointers for all libraries */

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

        if (libinfo[i].loaded) {

            p = libinfo[i].start_data;

            for (j=0; j<MAX_SHARED_LIBS; j++) {

                p -= 4;

    p = copy_strings(p, bprm->envc, bprm->envp);

    p = copy_strings(p, bprm->argc, bprm->argv);

    /* Align stack.  */

    /* Enforce final stack alignment of 16 bytes.  This is sufficient

       for all current targets, and excess alignment is harmless.  */

    stack_len = bprm->envc + bprm->argc + 2;

    stack_len += 3;	/* argc, arvg, argp */

    if ((sp + stack_len) & 15)

        sp -= 16 - ((sp + stack_len) & 15);

    sp = loader_build_argptr(bprm->envc, bprm->argc, sp, p, 1);

struct target_modify_ldt_ldt_s {

    unsigned int  entry_number;

    unsigned int limit;

    unsigned int flags;

};

/*

 * normal regs, with special meaning for the segment descriptors..

 */

	unsigned short cs, __csh;

	unsigned short ss, __ssh;

/*

 * these are specific to v86 mode:

};

struct target_revectored_struct {

};

struct target_vm86_struct {

	struct target_vm86_regs regs;

	struct target_revectored_struct int_revectored;

	struct target_revectored_struct int21_revectored;

};

#define TARGET_VM86_SCREEN_BITMAP	0x0001

struct target_vm86plus_info_struct {

#define TARGET_force_return_for_pic (1 << 0)

#define TARGET_vm86dbg_active       (1 << 1)  /* for debugger */

#define TARGET_vm86dbg_TFpendig     (1 << 2)  /* for debugger */

struct target_vm86plus_struct {

	struct target_vm86_regs regs;

	struct target_revectored_struct int_revectored;

	struct target_revectored_struct int21_revectored;

	struct target_vm86plus_info_struct vm86plus;

/* this struct defines a stack used during syscall handling */

typedef struct target_sigaltstack {

} target_stack_t;

#define TARGET_MINSIGSTKSZ	2048

#define TARGET_SIGSTKSZ		8192

{

    return state->regs[R_ESP];

}

#define NGROUPS 32

/* ??? This should really be somewhere else.  */

                      unsigned long len)

{

    void *host_ptr;

}

/* Construct the envp and argv tables on the target stack.  */

{

    sp -= (envc + 1) * n;

    envp = sp;

   stack during a system call. */

struct target_pt_regs {

    int16_t stkadj;

    uint16_t sr;

    uint16_t fntvex;

    uint16_t __fill;

};

/* this struct defines a stack used during syscall handling */

typedef struct target_sigaltstack {

} target_stack_t;

void cpu_loop(CPUX86State *env)

{

    int trapnr;

    target_siginfo_t info;

    for(;;) {

#ifdef TARGET_ARM

/* XXX: find a better solution */

{

    if (last < start)

        return;

static inline void save_window_offset(CPUSPARCState *env, int cwp1)

{

    unsigned int i;

    sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];

#if defined(DEBUG_WIN)

#endif

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

        tputl(sp_ptr, env->regbase[get_reg_index(env, cwp1, 8 + i)]);

    }

}

static void restore_window(CPUSPARCState *env)

{

    unsigned int new_wim, i, cwp1;

    new_wim = ((env->wim << 1) | (env->wim >> (NWINDOWS - 1))) &

        ((1LL << NWINDOWS) - 1);

#endif

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

        env->regbase[get_reg_index(env, cwp1, 8 + i)] = tgetl(sp_ptr);

    }

    env->wim = new_wim;

#ifdef TARGET_SPARC64

                              env->regwptr[2], env->regwptr[3],

                              env->regwptr[4], env->regwptr[5]);

            if ((unsigned int)ret >= (unsigned int)(-515)) {

                env->xcc |= PSR_CARRY;

#else

                env->psr |= PSR_CARRY;

#endif

                ret = -ret;

            } else {

                env->xcc &= ~PSR_CARRY;

#else

                env->psr &= ~PSR_CARRY;

            env->npc = env->npc + 4;

            break;

        case 0x83: /* flush windows */

            flush_windows(env);

            /* next instruction */

            env->pc = env->npc;

                ret = -ENOSYS;

            } else {

                int nb_args;

                nb_args = mips_syscall_args[syscall_num];

                sp_reg = env->gpr[29][env->current_tc];

        int i;

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

        }

        env->ipr[IPR_USP] = regs->usp;

        env->ir[30] = regs->usp;

struct target_pt_regs {

	/* Pad bytes for argument save space on the stack. */

	/* Saved main processor registers. */

	/* Saved special registers. */

};

/* Target errno definitions taken from asm-mips/errno.h */

/* this struct defines a stack used during syscall handling */

typedef struct target_sigaltstack {

} target_stack_t;

#define TARGET_MINSIGSTKSZ    2048

#define TARGET_SIGSTKSZ       8192

{

    return state->gpr[29][state->current_tc];

}

struct target_pt_regs {

	/* Saved main processor registers. */

	/* Saved special registers. */

};

/* Target errno definitions taken from asm-mips/errno.h */

/* this struct defines a stack used during syscall handling */

typedef struct target_sigaltstack {

} target_stack_t;

#define TARGET_MINSIGSTKSZ    2048

#define TARGET_SIGSTKSZ       8192

{

    return state->gpr[29][state->current_tc];

}

//#define DEBUG_MMAP

/* NOTE: all the constants are the HOST ones, but addresses are target. */

{

    int prot1, ret;

#ifdef DEBUG_MMAP

}

/* map an incomplete host page */

{

    void *host_start;

    int prot1, prot_new;

}

/* NOTE: all the constants are the HOST ones */

{

    unsigned long host_start;

#if defined(__alpha__) || defined(__sparc__) || defined(__x86_64__) || \

        defined(__ia64) || defined(__mips__)

#elif defined(__CYGWIN__)

    /* Cygwin doesn't have a whole lot of address space.  */

#endif

#ifdef DEBUG_MMAP

             * TARGET_PAGE_SIZE, see exec.c. qemu_real_host_page_size is the

             * hosts real page size.

             */

            unsigned long host_aligned_start;

            host_len = HOST_PAGE_ALIGN(host_len + qemu_host_page_size

    return start;

}

{

    int prot, ret;

#ifdef DEBUG_MMAP

/* XXX: currently, we only handle MAP_ANONYMOUS and not MAP_FIXED

   blocks which have been allocated starting on a host page */

{

    int prot;

    unsigned long host_addr;

    return new_addr;

}

{

    if (start & ~TARGET_PAGE_MASK)

        return -EINVAL;

/* ioctls */

struct target_revectored_struct {

};

/*

/* this struct defines a stack used during syscall handling */

typedef struct target_sigaltstack {

} target_stack_t;

#define TARGET_MINSIGSTKSZ    2048

#define TARGET_SIGSTKSZ       8192

{

    return state->gpr[1];

}

/* ioctls */

struct target_revectored_struct {

};

/*

/* this struct defines a stack used during syscall handling */

typedef struct target_sigaltstack {

} target_stack_t;

#define TARGET_MINSIGSTKSZ    2048

#define TARGET_SIGSTKSZ       8192

{

    return state->gpr[1];

}

#ifndef QEMU_H

#define QEMU_H

#include <signal.h>

#include <string.h>

#include "cpu.h"