Archipelago » qemu

    int i;

    unsigned long sigmask;

    uint32_t target_sigmask;

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

    target_sigmask = 0;

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

        s1.sig[i] = tswapl(s->sig[i]);

    target_to_host_sigset_internal(d, &s1);

}

void host_to_target_old_sigset(target_ulong *old_sigset,

                               const sigset_t *sigset)

{

        j = host_to_target_signal_table[i];

        target_to_host_signal_table[j] = i;

    }

    /* set all host signal handlers. ALL signals are blocked during

       the handlers to serialize them. */

    sigfillset(&act.sa_mask);

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

        sigaction(i, &act, NULL);

    }

    memset(sigact_table, 0, sizeof(sigact_table));

    first_free = &sigqueue_table[0];

    target_to_host_sigset_internal(&set, &target_set);

    sigprocmask(SIG_SETMASK, &set, NULL);

    /* restore registers */

    if (restore_sigcontext(env, &frame->sc, &eax))

        goto badframe;

   	:"r" (&regs));

    /* Unreached */

#endif

    regs->PC[regs->current_tc] = regs->CP0_EPC;

    /* I am not sure this is right, but it seems to work

    * maybe a problem with nested signals ? */

    target_sigset_t target_old_set;

    struct emulated_sigaction *k;

    struct sigqueue *q;

    if (!signal_pending)

        return;

    k->first = q->next;

    if (!k->first)

        k->pending = 0;

    sig = gdb_handlesig (cpu_env, sig);

    if (!sig) {

        fprintf (stderr, "Lost signal\n");

           blocked during the handler */

        if (!(k->sa.sa_flags & TARGET_SA_NODEFER))

            sigaddset(&set, target_to_host_signal(sig));

        /* block signals in the handler using Linux */

        sigprocmask(SIG_BLOCK, &set, &old_set);

        /* save the previous blocked signal state to restore it at the