Commit 80180eb2 authored by Richard Henderson's avatar Richard Henderson Committed by Laurent Vivier
Browse files

linux-user/sparc: Begin using WREG constants in sparc/signal.c 



This is non-obvious because the UREG constants are in fact wrong.

s/UREG_I/WREG_O/g
s/UREG_O/WREG_I/g
s/UREG_L/WREG_L/g

These substitutions have identical integer values.

Signed-off-by: default avatarRichard Henderson <richard.henderson@linaro.org>
Reviewed-by: default avatarLaurent Vivier <laurent@vivier.eu>
Message-Id: <20191106113318.10226-6-richard.henderson@linaro.org>
Signed-off-by: default avatarLaurent Vivier <laurent@vivier.eu>
parent 083244d3

linux-user/sparc/signal.c

+33 −62
Original line number Diff line number Diff line
@@ -104,19 +104,8 @@ struct target_rt_signal_frame { 
    qemu_siginfo_fpu_t  fpu_state;

};



#define UREG_O0        16

#define UREG_O6        22

#define UREG_I0        0

#define UREG_I1        1

#define UREG_I2        2

#define UREG_I3        3

#define UREG_I4        4

#define UREG_I5        5

#define UREG_I6        6

#define UREG_I7        7

#define UREG_L0        8

#define UREG_FP        UREG_I6

#define UREG_SP        UREG_O6

#define UREG_FP        WREG_O6

#define UREG_SP        WREG_I6



static inline abi_ulong get_sigframe(struct target_sigaction *sa, 

                                     CPUSPARCState *env,
@@ -159,30 +148,12 @@ setup___siginfo(__siginfo_t *si, CPUSPARCState *env, abi_ulong mask) 
        __put_user(env->gregs[i], &si->si_regs.u_regs[i]);

    }

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

        __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]);

        __put_user(env->regwptr[WREG_O0 + i], &si->si_regs.u_regs[i + 8]);

    }

    __put_user(mask, &si->si_mask);

    return err;

}



#if 0

static int

setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/

                 CPUSPARCState *env, unsigned long mask)

{

    int err = 0;



    __put_user(mask, &sc->sigc_mask);

    __put_user(env->regwptr[UREG_SP], &sc->sigc_sp);

    __put_user(env->pc, &sc->sigc_pc);

    __put_user(env->npc, &sc->sigc_npc);

    __put_user(env->psr, &sc->sigc_psr);

    __put_user(env->gregs[1], &sc->sigc_g1);

    __put_user(env->regwptr[UREG_O0], &sc->sigc_o0);



    return err;

}

#endif

#define NF_ALIGNEDSZ  (((sizeof(struct target_signal_frame) + 7) & (~7)))



void setup_frame(int sig, struct target_sigaction *ka,
@@ -221,20 +192,20 @@ void setup_frame(int sig, struct target_sigaction *ka, 
    }



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

        __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]);

        __put_user(env->regwptr[i + WREG_L0], &sf->ss.locals[i]);

    }

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

        __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]);

        __put_user(env->regwptr[i + WREG_O0], &sf->ss.ins[i]);

    }

    if (err)

        goto sigsegv;



    /* 3. signal handler back-trampoline and parameters */

    env->regwptr[UREG_FP] = sf_addr;

    env->regwptr[UREG_I0] = sig;

    env->regwptr[UREG_I1] = sf_addr +

    env->regwptr[WREG_O0] = sig;

    env->regwptr[WREG_O1] = sf_addr +

            offsetof(struct target_signal_frame, info);

    env->regwptr[UREG_I2] = sf_addr +

    env->regwptr[WREG_O2] = sf_addr +

            offsetof(struct target_signal_frame, info);



    /* 4. signal handler */
@@ -242,11 +213,11 @@ void setup_frame(int sig, struct target_sigaction *ka, 
    env->npc = (env->pc + 4);

    /* 5. return to kernel instructions */

    if (ka->ka_restorer) {

        env->regwptr[UREG_I7] = ka->ka_restorer;

        env->regwptr[WREG_O7] = ka->ka_restorer;

    } else {

        uint32_t val32;



        env->regwptr[UREG_I7] = sf_addr +

        env->regwptr[WREG_O7] = sf_addr +

                offsetof(struct target_signal_frame, insns) - 2 * 4;



        /* mov __NR_sigreturn, %g1 */
@@ -316,7 +287,7 @@ long do_sigreturn(CPUSPARCState *env) 
        __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]);

    }

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

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

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

    }



    /* FIXME: implement FPU save/restore:
@@ -433,7 +404,7 @@ void sparc64_set_context(CPUSPARCState *env) 
    abi_ulong fp, i7, w_addr;

    unsigned int i;



    ucp_addr = env->regwptr[UREG_I0];

    ucp_addr = env->regwptr[WREG_O0];

    if (!lock_user_struct(VERIFY_READ, ucp, ucp_addr, 1)) {

        goto do_sigsegv;

    }
@@ -443,7 +414,7 @@ void sparc64_set_context(CPUSPARCState *env) 
    if ((pc | npc) & 3) {

        goto do_sigsegv;

    }

    if (env->regwptr[UREG_I1]) {

    if (env->regwptr[WREG_O1]) {

        target_sigset_t target_set;

        sigset_t set;
@@ -474,19 +445,19 @@ void sparc64_set_context(CPUSPARCState *env) 
    __get_user(env->gregs[5], (&(*grp)[SPARC_MC_G5]));

    __get_user(env->gregs[6], (&(*grp)[SPARC_MC_G6]));

    __get_user(env->gregs[7], (&(*grp)[SPARC_MC_G7]));

    __get_user(env->regwptr[UREG_I0], (&(*grp)[SPARC_MC_O0]));

    __get_user(env->regwptr[UREG_I1], (&(*grp)[SPARC_MC_O1]));

    __get_user(env->regwptr[UREG_I2], (&(*grp)[SPARC_MC_O2]));

    __get_user(env->regwptr[UREG_I3], (&(*grp)[SPARC_MC_O3]));

    __get_user(env->regwptr[UREG_I4], (&(*grp)[SPARC_MC_O4]));

    __get_user(env->regwptr[UREG_I5], (&(*grp)[SPARC_MC_O5]));

    __get_user(env->regwptr[UREG_I6], (&(*grp)[SPARC_MC_O6]));

    __get_user(env->regwptr[UREG_I7], (&(*grp)[SPARC_MC_O7]));

    __get_user(env->regwptr[WREG_O0], (&(*grp)[SPARC_MC_O0]));

    __get_user(env->regwptr[WREG_O1], (&(*grp)[SPARC_MC_O1]));

    __get_user(env->regwptr[WREG_O2], (&(*grp)[SPARC_MC_O2]));

    __get_user(env->regwptr[WREG_O3], (&(*grp)[SPARC_MC_O3]));

    __get_user(env->regwptr[WREG_O4], (&(*grp)[SPARC_MC_O4]));

    __get_user(env->regwptr[WREG_O5], (&(*grp)[SPARC_MC_O5]));

    __get_user(env->regwptr[WREG_O6], (&(*grp)[SPARC_MC_O6]));

    __get_user(env->regwptr[WREG_O7], (&(*grp)[SPARC_MC_O7]));



    __get_user(fp, &(ucp->tuc_mcontext.mc_fp));

    __get_user(i7, &(ucp->tuc_mcontext.mc_i7));



    w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];

    w_addr = TARGET_STACK_BIAS + env->regwptr[WREG_O6];

    if (put_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),

                 abi_ulong) != 0) {

        goto do_sigsegv;
@@ -534,7 +505,7 @@ void sparc64_get_context(CPUSPARCState *env) 
    target_sigset_t target_set;

    sigset_t set;



    ucp_addr = env->regwptr[UREG_I0];

    ucp_addr = env->regwptr[WREG_O0];

    if (!lock_user_struct(VERIFY_WRITE, ucp, ucp_addr, 0)) {

        goto do_sigsegv;

    }
@@ -580,16 +551,16 @@ void sparc64_get_context(CPUSPARCState *env) 
    __put_user(env->gregs[5], &((*grp)[SPARC_MC_G5]));

    __put_user(env->gregs[6], &((*grp)[SPARC_MC_G6]));

    __put_user(env->gregs[7], &((*grp)[SPARC_MC_G7]));

    __put_user(env->regwptr[UREG_I0], &((*grp)[SPARC_MC_O0]));

    __put_user(env->regwptr[UREG_I1], &((*grp)[SPARC_MC_O1]));

    __put_user(env->regwptr[UREG_I2], &((*grp)[SPARC_MC_O2]));

    __put_user(env->regwptr[UREG_I3], &((*grp)[SPARC_MC_O3]));

    __put_user(env->regwptr[UREG_I4], &((*grp)[SPARC_MC_O4]));

    __put_user(env->regwptr[UREG_I5], &((*grp)[SPARC_MC_O5]));

    __put_user(env->regwptr[UREG_I6], &((*grp)[SPARC_MC_O6]));

    __put_user(env->regwptr[UREG_I7], &((*grp)[SPARC_MC_O7]));



    w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];

    __put_user(env->regwptr[WREG_O0], &((*grp)[SPARC_MC_O0]));

    __put_user(env->regwptr[WREG_O1], &((*grp)[SPARC_MC_O1]));

    __put_user(env->regwptr[WREG_O2], &((*grp)[SPARC_MC_O2]));

    __put_user(env->regwptr[WREG_O3], &((*grp)[SPARC_MC_O3]));

    __put_user(env->regwptr[WREG_O4], &((*grp)[SPARC_MC_O4]));

    __put_user(env->regwptr[WREG_O5], &((*grp)[SPARC_MC_O5]));

    __put_user(env->regwptr[WREG_O6], &((*grp)[SPARC_MC_O6]));

    __put_user(env->regwptr[WREG_O7], &((*grp)[SPARC_MC_O7]));



    w_addr = TARGET_STACK_BIAS + env->regwptr[WREG_O6];

    fp = i7 = 0;

    if (get_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),

                 abi_ulong) != 0) {