Archipelago » qemu

#include <errno.h>

#include <sys/ucontext.h>

#include "qemu.h"

//#define DEBUG_SIGNAL

        if (sigmask & (1 << i))

            target_sigmask |= 1 << (host_to_target_signal(i + 1) - 1);

    }

    d->sig[0] = target_sigmask;

    for(i = 1;i < TARGET_NSIG_WORDS; i++) {

        d->sig[i] = ((unsigned long *)s)[i];

    }

    d->sig[0] = target_sigmask;

    d->sig[1] = sigmask >> 32;

#else

{

    int i;

    unsigned long sigmask;

    target_sigmask = s->sig[0];

    sigmask = 0;

        if (target_sigmask & (1 << i))

            sigmask |= 1 << (target_to_host_signal(i + 1) - 1);

    }

    ((unsigned long *)d)[0] = sigmask;

    for(i = 1;i < TARGET_NSIG_WORDS; i++) {

        ((unsigned long *)d)[i] = s->sig[i];

    }

    ((unsigned long *)d)[0] = sigmask | ((unsigned long)(s->sig[1]) << 32);

#else

#warning target_to_host_sigset

}

void target_to_host_sigset(sigset_t *d, const target_sigset_t *s)

    target_to_host_sigset_internal(d, &s1);

}

                               const sigset_t *sigset)

{

    target_sigset_t d;

}

void target_to_host_old_sigset(sigset_t *sigset,

{

    target_sigset_t d;

    int i;

        tinfo->_sifields._rt._uid = info->si_uid;

        /* XXX: potential problem if 64 bit */

        tinfo->_sifields._rt._sigval.sival_ptr =

    }

}

{

    struct emulated_sigaction *k;

    struct sigqueue *q, **pq;

#if defined(DEBUG_SIGNAL)

    fprintf(stderr, "queue_signal: sig=%d\n",

int do_sigaltstack(const struct target_sigaltstack *uss,

                   struct target_sigaltstack *uoss,

{

    int ret;

    struct target_sigaltstack oss;

};

struct target_xmmreg {

};

struct target_fpstate {

	/* Regular FPU environment */

	struct target_fpreg	_st[8];

	uint16_t	status;

	uint16_t	magic;		/* 0xffff = regular FPU data only */

	/* FXSR FPU environment */

	struct target_fpxreg	_fxsr_st[8];	/* FXSR FPU reg data is ignored */

	struct target_xmmreg	_xmm[8];

};

#define X86_FXSR_MAGIC		0x0000

	uint16_t fs, __fsh;

	uint16_t es, __esh;

	uint16_t ds, __dsh;

	uint16_t cs, __csh;

	uint16_t ss, __ssh;

};

struct target_ucontext {

	target_stack_t	  tuc_stack;

	struct target_sigcontext tuc_mcontext;

	target_sigset_t	  tuc_sigmask;	/* mask last for extensibility */

struct sigframe

{

    int sig;

    struct target_sigcontext sc;

    struct target_fpstate fpstate;

    char retcode[8];

};

struct rt_sigframe

{

    int sig;

    struct target_siginfo info;

    struct target_ucontext uc;

    struct target_fpstate fpstate;

		    	   ? current->exec_domain->signal_invmap[sig]

			   : */sig),

			  &frame->sig);

	err |= copy_siginfo_to_user(&frame->info, info);

	if (err)

		goto give_sigsegv;

#elif defined(TARGET_ARM)

struct target_sigcontext {

};

struct target_ucontext {

    target_stack_t tuc_stack;

    struct target_sigcontext tuc_mcontext;

    target_sigset_t  tuc_sigmask;	/* mask last for extensibility */

struct sigframe

{

    struct target_sigcontext sc;

};

struct rt_sigframe

    void *puc;

    struct target_siginfo info;

    struct target_ucontext uc;

};

#define TARGET_CONFIG_CPU_32 1

#define SWI_THUMB_SIGRETURN	(0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))

#define SWI_THUMB_RT_SIGRETURN	(0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))

	SWI_SYS_SIGRETURN,	SWI_THUMB_SIGRETURN,

	SWI_SYS_RT_SIGRETURN,	SWI_THUMB_RT_SIGRETURN

};

static int

setup_return(CPUState *env, struct emulated_sigaction *ka,

{

	int thumb = 0;

#if defined(TARGET_CONFIG_CPU_32)

#if 0

	/*

	 * Maybe we need to deliver a 32-bit signal to a 26-bit task.

#endif /* TARGET_CONFIG_CPU_32 */

	if (ka->sa.sa_flags & TARGET_SA_RESTORER) {

	} else {

		unsigned int idx = thumb;

		if (__put_user(retcodes[idx], rc))

			return 1;

#if 0

#endif

	}

	env->regs[0] = usig;

	if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))

            return /* 1 */;

	err |= copy_siginfo_to_user(&frame->info, info);

	/* Clear all the bits of the ucontext we don't use.  */

		 * arguments for the signal handler.

		 *   -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06

		 */

	}

        //	return err;

/* This is what SunOS does, so shall I. */

struct target_sigcontext {

        /* Now comes information regarding the users window set

         * at the time of the signal.

         */

        /* stack ptrs for each regwin buf */

        char *sigc_spbuf[__SUNOS_MAXWIN];

        /* Windows to restore after signal */

        struct {

        } sigc_wbuf[__SUNOS_MAXWIN];

};

/* A Sparc stack frame */

struct sparc_stackf {

        struct sparc_stackf *fp;

        char *structptr;

};

typedef struct {

        struct {

        }               si_regs;

        int             si_mask;

} __siginfo_t;

	struct sparc_stackf	ss;

	__siginfo_t		info;

	qemu_siginfo_fpu_t 	*fpu_save;

	qemu_siginfo_fpu_t	fpu_state;

};

struct target_rt_signal_frame {

	struct sparc_stackf	ss;

	siginfo_t		info;

	sigset_t		mask;

	qemu_siginfo_fpu_t 	*fpu_save;

	unsigned int		insns[2];

}

static int

{

	int err = 0, i;

        uint32_t up_psr, pc, npc;

        target_sigset_t set;

        sigset_t host_set;

        int err, i;

        sf = (struct target_signal_frame *)g2h(env->regwptr[UREG_FP]);

		err |= __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]);

	}

        //if (fpu_save)

        //        err |= restore_fpu_state(env, fpu_save);

#define MC_O7 18

#define MC_NGREG 19

typedef target_mc_greg_t target_mc_gregset_t[MC_NGREG];

struct target_mc_fq {

    uint32_t mcfq_insn;

};

        uint64_t dregs[32];

        //uint128_t qregs[16];

    } mcfpu_fregs;

    struct target_mc_fq *mcfpu_fq;

    unsigned char mcfpu_qcnt;

    unsigned char mcfpu_qentsz;

struct target_ucontext {

    struct target_ucontext *uc_link;

    target_sigset_t uc_sigmask;

    target_mcontext_t uc_mcontext;

};

/* A V9 register window */

struct target_reg_window {

};

#define TARGET_STACK_BIAS 2047

    struct target_ucontext *ucp = (struct target_ucontext *)

        env->regwptr[UREG_I0];

    target_mc_gregset_t *grp;

    unsigned char fenab;

    int err;

    unsigned int i;

    grp  = &ucp->uc_mcontext.mc_gregs;

    err  = get_user(pc, &((*grp)[MC_PC]));

        } else {

            src = &ucp->uc_sigmask;

            dst = &target_set;

                 i++, dst++, src++)

                err |= get_user(dst, src);

            if (err)

        env->regwptr[UREG_I0];

    target_mc_gregset_t *grp;

    target_mcontext_t *mcp;

    int err;

    unsigned int i;

    target_sigset_t target_set;

    sigset_t set;

    host_to_target_sigset_internal(&target_set, &set);

    if (TARGET_NSIG_WORDS == 1)

        err |= put_user(target_set.sig[0],

    else {

        src = &target_set;

        dst = &ucp->uc_sigmask;

             i++, dst++, src++)

            err |= put_user(src, dst);

        if (err)

void process_pending_signals(void *cpu_env)

{

    int sig;

    sigset_t set, old_set;

    target_sigset_t target_old_set;

    struct emulated_sigaction *k;