void process_pending_signals(CPUArchState *cpu_env)

{

    CPUState *cpu = ENV_GET_CPU(cpu_env);

    int sig;

    abi_ulong handler;

    sigset_t set, old_set;

    target_sigset_t target_old_set;

    struct emulated_sigtable *k;

    struct target_sigaction *sa;

    struct sigqueue *q;

    TaskState *ts = cpu->opaque;



    if (!ts->signal_pending)

        return;



    /* FIXME: This is not threadsafe.  */

    k = ts->sigtab;

    for(sig = 1; sig <= TARGET_NSIG; sig++) {

        if (k->pending)

            goto handle_signal;

        k++;

    }

    /* if no signal is pending, just return */

    ts->signal_pending = 0;

    return;



 handle_signal:

#ifdef DEBUG_SIGNAL

    fprintf(stderr, "qemu: process signal %d\n", sig);

#endif

    /* dequeue signal */

    q = k->first;

    k->first = q->next;

    if (!k->first)

        k->pending = 0;



    sig = gdb_handlesig(cpu, sig);

    if (!sig) {

        sa = NULL;

        handler = TARGET_SIG_IGN;

    } else {

        sa = &sigact_table[sig - 1];

        handler = sa->_sa_handler;

    }



    if (handler == TARGET_SIG_DFL) {

        /* default handler : ignore some signal. The other are job control or fatal */

        if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {

            kill(getpid(),SIGSTOP);

        } else if (sig != TARGET_SIGCHLD &&

                   sig != TARGET_SIGURG &&

                   sig != TARGET_SIGWINCH &&

                   sig != TARGET_SIGCONT) {

            force_sig(sig);

        }

    } else if (handler == TARGET_SIG_IGN) {

        /* ignore sig */

    } else if (handler == TARGET_SIG_ERR) {

        force_sig(sig);

    } else {

        /* compute the blocked signals during the handler execution */

        target_to_host_sigset(&set, &sa->sa_mask);

        /* SA_NODEFER indicates that the current signal should not be

           blocked during the handler */

        if (!(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

           end of the signal execution (see do_sigreturn) */

        host_to_target_sigset_internal(&target_old_set, &old_set);



        /* if the CPU is in VM86 mode, we restore the 32 bit values */

#if defined(TARGET_I386) && !defined(TARGET_X86_64)

        {

            CPUX86State *env = cpu_env;

            if (env->eflags & VM_MASK)

                save_v86_state(env);

        }

#endif

        /* prepare the stack frame of the virtual CPU */

#if defined(TARGET_ABI_MIPSN32) || defined(TARGET_ABI_MIPSN64)

        /* These targets do not have traditional signals.  */

        setup_rt_frame(sig, sa, &q->info, &target_old_set, cpu_env);

#else

        if (sa->sa_flags & TARGET_SA_SIGINFO)

            setup_rt_frame(sig, sa, &q->info, &target_old_set, cpu_env);

        else

            setup_frame(sig, sa, &target_old_set, cpu_env);

#endif

	if (sa->sa_flags & TARGET_SA_RESETHAND)

            sa->_sa_handler = TARGET_SIG_DFL;

    }

    if (q != &k->info)

        free_sigqueue(cpu_env, q);

}

void process_pending_signals(CPUArchState *cpu_env)

{

    CPUState *cpu = ENV_GET_CPU(cpu_env);

    int sig;

    abi_ulong handler;

    sigset_t set, old_set;

    target_sigset_t target_old_set;

    struct emulated_sigtable *k;

    struct target_sigaction *sa;

    struct sigqueue *q;

    TaskState *ts = cpu->opaque;



    if (!ts->signal_pending)

        return;



    

    k = ts->sigtab;

    for(sig = 1; sig <= TARGET_NSIG; sig++) {

        if (k->pending)

            goto handle_signal;

        k++;

    }

    

    ts->signal_pending = 0;

    return;



 handle_signal:

#ifdef DEBUG_SIGNAL

    fprintf(stderr, "qemu: process signal %d\n", sig);

#endif

    

    q = k->first;

    k->first = q->next;

    if (!k->first)

        k->pending = 0;



    sig = gdb_handlesig(cpu, sig);

    if (!sig) {

        sa = NULL;

        handler = TARGET_SIG_IGN;

    } else {

        sa = &sigact_table[sig - 1];

        handler = sa->_sa_handler;

    }



    if (handler == TARGET_SIG_DFL) {

        

        if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {

            kill(getpid(),SIGSTOP);

        } else if (sig != TARGET_SIGCHLD &&

                   sig != TARGET_SIGURG &&

                   sig != TARGET_SIGWINCH &&

                   sig != TARGET_SIGCONT) {

            force_sig(sig);

        }

    } else if (handler == TARGET_SIG_IGN) {

        

    } else if (handler == TARGET_SIG_ERR) {

        force_sig(sig);

    } else {

        

        target_to_host_sigset(&set, &sa->sa_mask);

        



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

            sigaddset(&set, target_to_host_signal(sig));



        

        sigprocmask(SIG_BLOCK, &set, &old_set);

        



        host_to_target_sigset_internal(&target_old_set, &old_set);



        

#if defined(TARGET_I386) && !defined(TARGET_X86_64)

        {

            CPUX86State *env = cpu_env;

            if (env->eflags & VM_MASK)

                save_v86_state(env);

        }

#endif

        

#if defined(TARGET_ABI_MIPSN32) || defined(TARGET_ABI_MIPSN64)

        

        setup_rt_frame(sig, sa, &q->info, &target_old_set, cpu_env);

#else

        if (sa->sa_flags & TARGET_SA_SIGINFO)

            setup_rt_frame(sig, sa, &q->info, &target_old_set, cpu_env);

        else

            setup_frame(sig, sa, &target_old_set, cpu_env);

#endif

	if (sa->sa_flags & TARGET_SA_RESETHAND)

            sa->_sa_handler = TARGET_SIG_DFL;

    }

    if (q != &k->info)

        free_sigqueue(cpu_env, q);

}

void FUNC_0(CPUArchState *VAR_0)

{

    CPUState *cpu = ENV_GET_CPU(VAR_0);

    int VAR_1;

    abi_ulong handler;

    sigset_t set, old_set;

    target_sigset_t target_old_set;

    struct emulated_sigtable *VAR_2;

    struct target_sigaction *VAR_3;

    struct sigqueue *VAR_4;

    TaskState *ts = cpu->opaque;



    if (!ts->signal_pending)

        return;



    

    VAR_2 = ts->sigtab;

    for(VAR_1 = 1; VAR_1 <= TARGET_NSIG; VAR_1++) {

        if (VAR_2->pending)

            goto handle_signal;

        VAR_2++;

    }

    

    ts->signal_pending = 0;

    return;



 handle_signal:

#ifdef DEBUG_SIGNAL

    fprintf(stderr, "qemu: process signal %d\n", VAR_1);

#endif

    

    VAR_4 = VAR_2->first;

    VAR_2->first = VAR_4->next;

    if (!VAR_2->first)

        VAR_2->pending = 0;



    VAR_1 = gdb_handlesig(cpu, VAR_1);

    if (!VAR_1) {

        VAR_3 = NULL;

        handler = TARGET_SIG_IGN;

    } else {

        VAR_3 = &sigact_table[VAR_1 - 1];

        handler = VAR_3->_sa_handler;

    }



    if (handler == TARGET_SIG_DFL) {

        

        if (VAR_1 == TARGET_SIGTSTP || VAR_1 == TARGET_SIGTTIN || VAR_1 == TARGET_SIGTTOU) {

            kill(getpid(),SIGSTOP);

        } else if (VAR_1 != TARGET_SIGCHLD &&

                   VAR_1 != TARGET_SIGURG &&

                   VAR_1 != TARGET_SIGWINCH &&

                   VAR_1 != TARGET_SIGCONT) {

            force_sig(VAR_1);

        }

    } else if (handler == TARGET_SIG_IGN) {

        

    } else if (handler == TARGET_SIG_ERR) {

        force_sig(VAR_1);

    } else {

        

        target_to_host_sigset(&set, &VAR_3->sa_mask);

        



        if (!(VAR_3->sa_flags & TARGET_SA_NODEFER))

            sigaddset(&set, target_to_host_signal(VAR_1));



        

        sigprocmask(SIG_BLOCK, &set, &old_set);

        



        host_to_target_sigset_internal(&target_old_set, &old_set);



        

#if defined(TARGET_I386) && !defined(TARGET_X86_64)

        {

            CPUX86State *env = VAR_0;

            if (env->eflags & VM_MASK)

                save_v86_state(env);

        }

#endif

        

#if defined(TARGET_ABI_MIPSN32) || defined(TARGET_ABI_MIPSN64)

        

        setup_rt_frame(VAR_1, VAR_3, &VAR_4->info, &target_old_set, VAR_0);

#else

        if (VAR_3->sa_flags & TARGET_SA_SIGINFO)

            setup_rt_frame(VAR_1, VAR_3, &VAR_4->info, &target_old_set, VAR_0);

        else

            setup_frame(VAR_1, VAR_3, &target_old_set, VAR_0);

#endif

	if (VAR_3->sa_flags & TARGET_SA_RESETHAND)

            VAR_3->_sa_handler = TARGET_SIG_DFL;

    }

    if (VAR_4 != &VAR_2->info)

        free_sigqueue(VAR_0, VAR_4);

}

void FUNC_0(CPUArchState *VAR_0)
{ CPUState *cpu = ENV_GET_CPU(VAR_0); int VAR_1; abi_ulong handler; sigset_t set, old_set; target_sigset_t target_old_set; struct emulated_sigtable *VAR_2; struct target_sigaction *VAR_3; struct sigqueue *VAR_4; TaskState *ts = cpu->opaque; if (!ts->signal_pending)
return; VAR_2 = ts->sigtab; for(VAR_1 = 1; VAR_1 <= TARGET_NSIG; VAR_1++) { if (VAR_2->pending)
goto handle_signal; VAR_2++; } ts->signal_pending = 0; return; handle_signal:
#ifdef DEBUG_SIGNAL
fprintf(stderr, "qemu: process signal %d\n", VAR_1); #endif
VAR_4 = VAR_2->first; VAR_2->first = VAR_4->next; if (!VAR_2->first)
VAR_2->pending = 0; VAR_1 = gdb_handlesig(cpu, VAR_1); if (!VAR_1) { VAR_3 = NULL; handler = TARGET_SIG_IGN; } else { VAR_3 = &sigact_table[VAR_1 - 1]; handler = VAR_3->_sa_handler; } if (handler == TARGET_SIG_DFL) { if (VAR_1 == TARGET_SIGTSTP || VAR_1 == TARGET_SIGTTIN || VAR_1 == TARGET_SIGTTOU) { kill(getpid(),SIGSTOP); } else if (VAR_1 != TARGET_SIGCHLD && VAR_1 != TARGET_SIGURG &&
VAR_1 != TARGET_SIGWINCH &&
VAR_1 != TARGET_SIGCONT) { force_sig(VAR_1); } } else if (handler == TARGET_SIG_IGN) { } else if (handler == TARGET_SIG_ERR) { force_sig(VAR_1); } else { target_to_host_sigset(&set, &VAR_3->sa_mask); if (!(VAR_3->sa_flags & TARGET_SA_NODEFER))
sigaddset(&set, target_to_host_signal(VAR_1)); sigprocmask(SIG_BLOCK, &set, &old_set); host_to_target_sigset_internal(&target_old_set, &old_set); #if defined(TARGET_I386) && !defined(TARGET_X86_64)
{ CPUX86State *env = VAR_0; if (env->eflags & VM_MASK)
save_v86_state(env); } #endif
#if defined(TARGET_ABI_MIPSN32) || defined(TARGET_ABI_MIPSN64)
setup_rt_frame(VAR_1, VAR_3, &VAR_4->info, &target_old_set, VAR_0); #else
if (VAR_3->sa_flags & TARGET_SA_SIGINFO)
setup_rt_frame(VAR_1, VAR_3, &VAR_4->info, &target_old_set, VAR_0); else
setup_frame(VAR_1, VAR_3, &target_old_set, VAR_0); #endif
if (VAR_3->sa_flags & TARGET_SA_RESETHAND)
VAR_3->_sa_handler = TARGET_SIG_DFL; } if (VAR_4 != &VAR_2->info)
free_sigqueue(VAR_0, VAR_4); }