static inline bool cpu_handle_interrupt(CPUState *cpu,

                                        TranslationBlock **last_tb)

{

    CPUClass *cc = CPU_GET_CLASS(cpu);

    int interrupt_request = cpu->interrupt_request;



    if (unlikely(interrupt_request)) {

        if (unlikely(cpu->singlestep_enabled & SSTEP_NOIRQ)) {

            /* Mask out external interrupts for this step. */

            interrupt_request &= ~CPU_INTERRUPT_SSTEP_MASK;

        }

        if (interrupt_request & CPU_INTERRUPT_DEBUG) {

            cpu->interrupt_request &= ~CPU_INTERRUPT_DEBUG;

            cpu->exception_index = EXCP_DEBUG;

            return true;

        }

        if (replay_mode == REPLAY_MODE_PLAY && !replay_has_interrupt()) {

            /* Do nothing */

        } else if (interrupt_request & CPU_INTERRUPT_HALT) {

            replay_interrupt();

            cpu->interrupt_request &= ~CPU_INTERRUPT_HALT;

            cpu->halted = 1;

            cpu->exception_index = EXCP_HLT;

            return true;

        }

#if defined(TARGET_I386)

        else if (interrupt_request & CPU_INTERRUPT_INIT) {

            X86CPU *x86_cpu = X86_CPU(cpu);

            CPUArchState *env = &x86_cpu->env;

            replay_interrupt();

            cpu_svm_check_intercept_param(env, SVM_EXIT_INIT, 0, 0);

            do_cpu_init(x86_cpu);

            cpu->exception_index = EXCP_HALTED;

            return true;

        }

#else

        else if (interrupt_request & CPU_INTERRUPT_RESET) {

            replay_interrupt();

            cpu_reset(cpu);

            return true;

        }

#endif

        /* The target hook has 3 exit conditions:

           False when the interrupt isn't processed,

           True when it is, and we should restart on a new TB,

           and via longjmp via cpu_loop_exit.  */

        else {

            if (cc->cpu_exec_interrupt(cpu, interrupt_request)) {

                replay_interrupt();

                *last_tb = NULL;

            }

            /* The target hook may have updated the 'cpu->interrupt_request';

             * reload the 'interrupt_request' value */

            interrupt_request = cpu->interrupt_request;

        }

        if (interrupt_request & CPU_INTERRUPT_EXITTB) {

            cpu->interrupt_request &= ~CPU_INTERRUPT_EXITTB;

            /* ensure that no TB jump will be modified as

               the program flow was changed */

            *last_tb = NULL;

        }

    }

    if (unlikely(atomic_read(&cpu->exit_request) || replay_has_interrupt())) {

        atomic_set(&cpu->exit_request, 0);

        cpu->exception_index = EXCP_INTERRUPT;

        return true;

    }



    return false;

}

static inline bool cpu_handle_interrupt(CPUState *cpu,

                                        TranslationBlock **last_tb)

{

    CPUClass *cc = CPU_GET_CLASS(cpu);

    int interrupt_request = cpu->interrupt_request;



    if (unlikely(interrupt_request)) {

        if (unlikely(cpu->singlestep_enabled & SSTEP_NOIRQ)) {

            

            interrupt_request &= ~CPU_INTERRUPT_SSTEP_MASK;

        }

        if (interrupt_request & CPU_INTERRUPT_DEBUG) {

            cpu->interrupt_request &= ~CPU_INTERRUPT_DEBUG;

            cpu->exception_index = EXCP_DEBUG;

            return true;

        }

        if (replay_mode == REPLAY_MODE_PLAY && !replay_has_interrupt()) {

            

        } else if (interrupt_request & CPU_INTERRUPT_HALT) {

            replay_interrupt();

            cpu->interrupt_request &= ~CPU_INTERRUPT_HALT;

            cpu->halted = 1;

            cpu->exception_index = EXCP_HLT;

            return true;

        }

#if defined(TARGET_I386)

        else if (interrupt_request & CPU_INTERRUPT_INIT) {

            X86CPU *x86_cpu = X86_CPU(cpu);

            CPUArchState *env = &x86_cpu->env;

            replay_interrupt();

            cpu_svm_check_intercept_param(env, SVM_EXIT_INIT, 0, 0);

            do_cpu_init(x86_cpu);

            cpu->exception_index = EXCP_HALTED;

            return true;

        }

#else

        else if (interrupt_request & CPU_INTERRUPT_RESET) {

            replay_interrupt();

            cpu_reset(cpu);

            return true;

        }

#endif

        







        else {

            if (cc->cpu_exec_interrupt(cpu, interrupt_request)) {

                replay_interrupt();

                *last_tb = NULL;

            }

            



            interrupt_request = cpu->interrupt_request;

        }

        if (interrupt_request & CPU_INTERRUPT_EXITTB) {

            cpu->interrupt_request &= ~CPU_INTERRUPT_EXITTB;

            



            *last_tb = NULL;

        }

    }

    if (unlikely(atomic_read(&cpu->exit_request) || replay_has_interrupt())) {

        atomic_set(&cpu->exit_request, 0);

        cpu->exception_index = EXCP_INTERRUPT;

        return true;

    }



    return false;

}

static inline bool FUNC_0(CPUState *cpu,

                                        TranslationBlock **last_tb)

{

    CPUClass *cc = CPU_GET_CLASS(cpu);

    int VAR_0 = cpu->VAR_0;



    if (unlikely(VAR_0)) {

        if (unlikely(cpu->singlestep_enabled & SSTEP_NOIRQ)) {

            

            VAR_0 &= ~CPU_INTERRUPT_SSTEP_MASK;

        }

        if (VAR_0 & CPU_INTERRUPT_DEBUG) {

            cpu->VAR_0 &= ~CPU_INTERRUPT_DEBUG;

            cpu->exception_index = EXCP_DEBUG;

            return true;

        }

        if (replay_mode == REPLAY_MODE_PLAY && !replay_has_interrupt()) {

            

        } else if (VAR_0 & CPU_INTERRUPT_HALT) {

            replay_interrupt();

            cpu->VAR_0 &= ~CPU_INTERRUPT_HALT;

            cpu->halted = 1;

            cpu->exception_index = EXCP_HLT;

            return true;

        }

#if defined(TARGET_I386)

        else if (VAR_0 & CPU_INTERRUPT_INIT) {

            X86CPU *x86_cpu = X86_CPU(cpu);

            CPUArchState *env = &x86_cpu->env;

            replay_interrupt();

            cpu_svm_check_intercept_param(env, SVM_EXIT_INIT, 0, 0);

            do_cpu_init(x86_cpu);

            cpu->exception_index = EXCP_HALTED;

            return true;

        }

#else

        else if (VAR_0 & CPU_INTERRUPT_RESET) {

            replay_interrupt();

            cpu_reset(cpu);

            return true;

        }

#endif

        







        else {

            if (cc->cpu_exec_interrupt(cpu, VAR_0)) {

                replay_interrupt();

                *last_tb = NULL;

            }

            



            VAR_0 = cpu->VAR_0;

        }

        if (VAR_0 & CPU_INTERRUPT_EXITTB) {

            cpu->VAR_0 &= ~CPU_INTERRUPT_EXITTB;

            



            *last_tb = NULL;

        }

    }

    if (unlikely(atomic_read(&cpu->exit_request) || replay_has_interrupt())) {

        atomic_set(&cpu->exit_request, 0);

        cpu->exception_index = EXCP_INTERRUPT;

        return true;

    }



    return false;

}

static inline bool FUNC_0(CPUState *cpu,
TranslationBlock **last_tb)
{ CPUClass *cc = CPU_GET_CLASS(cpu); int VAR_0 = cpu->VAR_0; if (unlikely(VAR_0)) { if (unlikely(cpu->singlestep_enabled & SSTEP_NOIRQ)) { VAR_0 &= ~CPU_INTERRUPT_SSTEP_MASK; } if (VAR_0 & CPU_INTERRUPT_DEBUG) { cpu->VAR_0 &= ~CPU_INTERRUPT_DEBUG; cpu->exception_index = EXCP_DEBUG; return true; } if (replay_mode == REPLAY_MODE_PLAY && !replay_has_interrupt()) { } else if (VAR_0 & CPU_INTERRUPT_HALT) { replay_interrupt(); cpu->VAR_0 &= ~CPU_INTERRUPT_HALT; cpu->halted = 1; cpu->exception_index = EXCP_HLT; return true; } #if defined(TARGET_I386)
else if (VAR_0 & CPU_INTERRUPT_INIT) { X86CPU *x86_cpu = X86_CPU(cpu); CPUArchState *env = &x86_cpu->env; replay_interrupt(); cpu_svm_check_intercept_param(env, SVM_EXIT_INIT, 0, 0); do_cpu_init(x86_cpu); cpu->exception_index = EXCP_HALTED; return true; } #else
else if (VAR_0 & CPU_INTERRUPT_RESET) { replay_interrupt(); cpu_reset(cpu); return true; } #endif
else { if (cc->cpu_exec_interrupt(cpu, VAR_0)) { replay_interrupt(); *last_tb = NULL; } VAR_0 = cpu->VAR_0; } if (VAR_0 & CPU_INTERRUPT_EXITTB) { cpu->VAR_0 &= ~CPU_INTERRUPT_EXITTB; *last_tb = NULL; } } if (unlikely(atomic_read(&cpu->exit_request) || replay_has_interrupt())) { atomic_set(&cpu->exit_request, 0); cpu->exception_index = EXCP_INTERRUPT; return true; } return false; }