blob: 3913de020b9106f3dc37baf12984c3694f5bedb6 [file] [log] [blame]
bellard7d132992003-03-06 23:23:54 +00001/*
陳韋任e965fc32012-02-06 14:02:55 +08002 * emulator main execution loop
ths5fafdf22007-09-16 21:08:06 +00003 *
bellard66321a12005-04-06 20:47:48 +00004 * Copyright (c) 2003-2005 Fabrice Bellard
bellard7d132992003-03-06 23:23:54 +00005 *
bellard3ef693a2003-03-23 20:17:16 +00006 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
bellard7d132992003-03-06 23:23:54 +000010 *
bellard3ef693a2003-03-23 20:17:16 +000011 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
bellard7d132992003-03-06 23:23:54 +000015 *
bellard3ef693a2003-03-23 20:17:16 +000016 * You should have received a copy of the GNU Lesser General Public
Blue Swirl8167ee82009-07-16 20:47:01 +000017 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
bellard7d132992003-03-06 23:23:54 +000018 */
bellarde4533c72003-06-15 19:51:39 +000019#include "config.h"
Blue Swirlcea5f9a2011-05-15 16:03:25 +000020#include "cpu.h"
Alex Bennée6db8b532014-08-01 17:08:57 +010021#include "trace.h"
Paolo Bonzini76cad712012-10-24 11:12:21 +020022#include "disas/disas.h"
bellard7cb69ca2008-05-10 10:55:51 +000023#include "tcg.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010024#include "qemu/atomic.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010025#include "sysemu/qtest.h"
Sebastian Tanasec2aa5f82014-07-25 11:56:31 +020026#include "qemu/timer.h"
27
28/* -icount align implementation. */
29
30typedef struct SyncClocks {
31 int64_t diff_clk;
32 int64_t last_cpu_icount;
Sebastian Tanase7f7bc142014-07-25 11:56:32 +020033 int64_t realtime_clock;
Sebastian Tanasec2aa5f82014-07-25 11:56:31 +020034} SyncClocks;
35
36#if !defined(CONFIG_USER_ONLY)
37/* Allow the guest to have a max 3ms advance.
38 * The difference between the 2 clocks could therefore
39 * oscillate around 0.
40 */
41#define VM_CLOCK_ADVANCE 3000000
Sebastian Tanase7f7bc142014-07-25 11:56:32 +020042#define THRESHOLD_REDUCE 1.5
43#define MAX_DELAY_PRINT_RATE 2000000000LL
44#define MAX_NB_PRINTS 100
Sebastian Tanasec2aa5f82014-07-25 11:56:31 +020045
46static void align_clocks(SyncClocks *sc, const CPUState *cpu)
47{
48 int64_t cpu_icount;
49
50 if (!icount_align_option) {
51 return;
52 }
53
54 cpu_icount = cpu->icount_extra + cpu->icount_decr.u16.low;
55 sc->diff_clk += cpu_icount_to_ns(sc->last_cpu_icount - cpu_icount);
56 sc->last_cpu_icount = cpu_icount;
57
58 if (sc->diff_clk > VM_CLOCK_ADVANCE) {
59#ifndef _WIN32
60 struct timespec sleep_delay, rem_delay;
61 sleep_delay.tv_sec = sc->diff_clk / 1000000000LL;
62 sleep_delay.tv_nsec = sc->diff_clk % 1000000000LL;
63 if (nanosleep(&sleep_delay, &rem_delay) < 0) {
64 sc->diff_clk -= (sleep_delay.tv_sec - rem_delay.tv_sec) * 1000000000LL;
65 sc->diff_clk -= sleep_delay.tv_nsec - rem_delay.tv_nsec;
66 } else {
67 sc->diff_clk = 0;
68 }
69#else
70 Sleep(sc->diff_clk / SCALE_MS);
71 sc->diff_clk = 0;
72#endif
73 }
74}
75
Sebastian Tanase7f7bc142014-07-25 11:56:32 +020076static void print_delay(const SyncClocks *sc)
77{
78 static float threshold_delay;
79 static int64_t last_realtime_clock;
80 static int nb_prints;
81
82 if (icount_align_option &&
83 sc->realtime_clock - last_realtime_clock >= MAX_DELAY_PRINT_RATE &&
84 nb_prints < MAX_NB_PRINTS) {
85 if ((-sc->diff_clk / (float)1000000000LL > threshold_delay) ||
86 (-sc->diff_clk / (float)1000000000LL <
87 (threshold_delay - THRESHOLD_REDUCE))) {
88 threshold_delay = (-sc->diff_clk / 1000000000LL) + 1;
89 printf("Warning: The guest is now late by %.1f to %.1f seconds\n",
90 threshold_delay - 1,
91 threshold_delay);
92 nb_prints++;
93 last_realtime_clock = sc->realtime_clock;
94 }
95 }
96}
97
Sebastian Tanasec2aa5f82014-07-25 11:56:31 +020098static void init_delay_params(SyncClocks *sc,
99 const CPUState *cpu)
100{
101 if (!icount_align_option) {
102 return;
103 }
Sebastian Tanase7f7bc142014-07-25 11:56:32 +0200104 sc->realtime_clock = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
Sebastian Tanasec2aa5f82014-07-25 11:56:31 +0200105 sc->diff_clk = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) -
Sebastian Tanase7f7bc142014-07-25 11:56:32 +0200106 sc->realtime_clock +
Sebastian Tanasec2aa5f82014-07-25 11:56:31 +0200107 cpu_get_clock_offset();
108 sc->last_cpu_icount = cpu->icount_extra + cpu->icount_decr.u16.low;
Sebastian Tanase27498be2014-07-25 11:56:33 +0200109 if (sc->diff_clk < max_delay) {
110 max_delay = sc->diff_clk;
111 }
112 if (sc->diff_clk > max_advance) {
113 max_advance = sc->diff_clk;
114 }
Sebastian Tanase7f7bc142014-07-25 11:56:32 +0200115
116 /* Print every 2s max if the guest is late. We limit the number
117 of printed messages to NB_PRINT_MAX(currently 100) */
118 print_delay(sc);
Sebastian Tanasec2aa5f82014-07-25 11:56:31 +0200119}
120#else
121static void align_clocks(SyncClocks *sc, const CPUState *cpu)
122{
123}
124
125static void init_delay_params(SyncClocks *sc, const CPUState *cpu)
126{
127}
128#endif /* CONFIG USER ONLY */
bellard7d132992003-03-06 23:23:54 +0000129
Andreas Färber5638d182013-08-27 17:52:12 +0200130void cpu_loop_exit(CPUState *cpu)
bellarde4533c72003-06-15 19:51:39 +0000131{
Andreas Färberd77953b2013-01-16 19:29:31 +0100132 cpu->current_tb = NULL;
Andreas Färber6f03bef2013-08-26 06:22:03 +0200133 siglongjmp(cpu->jmp_env, 1);
bellarde4533c72003-06-15 19:51:39 +0000134}
thsbfed01f2007-06-03 17:44:37 +0000135
bellardfbf9eeb2004-04-25 21:21:33 +0000136/* exit the current TB from a signal handler. The host registers are
137 restored in a state compatible with the CPU emulator
138 */
Blue Swirl9eff14f2011-05-21 08:42:35 +0000139#if defined(CONFIG_SOFTMMU)
Andreas Färber0ea8cb82013-09-03 02:12:23 +0200140void cpu_resume_from_signal(CPUState *cpu, void *puc)
bellardfbf9eeb2004-04-25 21:21:33 +0000141{
Blue Swirl9eff14f2011-05-21 08:42:35 +0000142 /* XXX: restore cpu registers saved in host registers */
143
Andreas Färber27103422013-08-26 08:31:06 +0200144 cpu->exception_index = -1;
Andreas Färber6f03bef2013-08-26 06:22:03 +0200145 siglongjmp(cpu->jmp_env, 1);
Blue Swirl9eff14f2011-05-21 08:42:35 +0000146}
Blue Swirl9eff14f2011-05-21 08:42:35 +0000147#endif
bellardfbf9eeb2004-04-25 21:21:33 +0000148
Peter Maydell77211372013-02-22 18:10:02 +0000149/* Execute a TB, and fix up the CPU state afterwards if necessary */
150static inline tcg_target_ulong cpu_tb_exec(CPUState *cpu, uint8_t *tb_ptr)
151{
152 CPUArchState *env = cpu->env_ptr;
Richard Henderson03afa5f2013-11-06 17:29:39 +1000153 uintptr_t next_tb;
154
155#if defined(DEBUG_DISAS)
156 if (qemu_loglevel_mask(CPU_LOG_TB_CPU)) {
157#if defined(TARGET_I386)
158 log_cpu_state(cpu, CPU_DUMP_CCOP);
159#elif defined(TARGET_M68K)
160 /* ??? Should not modify env state for dumping. */
161 cpu_m68k_flush_flags(env, env->cc_op);
162 env->cc_op = CC_OP_FLAGS;
163 env->sr = (env->sr & 0xffe0) | env->cc_dest | (env->cc_x << 4);
164 log_cpu_state(cpu, 0);
165#else
166 log_cpu_state(cpu, 0);
167#endif
168 }
169#endif /* DEBUG_DISAS */
170
171 next_tb = tcg_qemu_tb_exec(env, tb_ptr);
Alex Bennée6db8b532014-08-01 17:08:57 +0100172 trace_exec_tb_exit((void *) (next_tb & ~TB_EXIT_MASK),
173 next_tb & TB_EXIT_MASK);
174
Peter Maydell77211372013-02-22 18:10:02 +0000175 if ((next_tb & TB_EXIT_MASK) > TB_EXIT_IDX1) {
176 /* We didn't start executing this TB (eg because the instruction
177 * counter hit zero); we must restore the guest PC to the address
178 * of the start of the TB.
179 */
Andreas Färberbdf7ae52013-06-28 19:31:32 +0200180 CPUClass *cc = CPU_GET_CLASS(cpu);
Peter Maydell77211372013-02-22 18:10:02 +0000181 TranslationBlock *tb = (TranslationBlock *)(next_tb & ~TB_EXIT_MASK);
Andreas Färberbdf7ae52013-06-28 19:31:32 +0200182 if (cc->synchronize_from_tb) {
183 cc->synchronize_from_tb(cpu, tb);
184 } else {
185 assert(cc->set_pc);
186 cc->set_pc(cpu, tb->pc);
187 }
Peter Maydell77211372013-02-22 18:10:02 +0000188 }
Peter Maydell378df4b2013-02-22 18:10:03 +0000189 if ((next_tb & TB_EXIT_MASK) == TB_EXIT_REQUESTED) {
190 /* We were asked to stop executing TBs (probably a pending
191 * interrupt. We've now stopped, so clear the flag.
192 */
193 cpu->tcg_exit_req = 0;
194 }
Peter Maydell77211372013-02-22 18:10:02 +0000195 return next_tb;
196}
197
pbrook2e70f6e2008-06-29 01:03:05 +0000198/* Execute the code without caching the generated code. An interpreter
199 could be used if available. */
Andreas Färber9349b4f2012-03-14 01:38:32 +0100200static void cpu_exec_nocache(CPUArchState *env, int max_cycles,
Blue Swirlcea5f9a2011-05-15 16:03:25 +0000201 TranslationBlock *orig_tb)
pbrook2e70f6e2008-06-29 01:03:05 +0000202{
Andreas Färberd77953b2013-01-16 19:29:31 +0100203 CPUState *cpu = ENV_GET_CPU(env);
pbrook2e70f6e2008-06-29 01:03:05 +0000204 TranslationBlock *tb;
205
206 /* Should never happen.
207 We only end up here when an existing TB is too long. */
208 if (max_cycles > CF_COUNT_MASK)
209 max_cycles = CF_COUNT_MASK;
210
Andreas Färber648f0342013-09-01 17:43:17 +0200211 tb = tb_gen_code(cpu, orig_tb->pc, orig_tb->cs_base, orig_tb->flags,
pbrook2e70f6e2008-06-29 01:03:05 +0000212 max_cycles);
Andreas Färberd77953b2013-01-16 19:29:31 +0100213 cpu->current_tb = tb;
pbrook2e70f6e2008-06-29 01:03:05 +0000214 /* execute the generated code */
Alex Bennée6db8b532014-08-01 17:08:57 +0100215 trace_exec_tb_nocache(tb, tb->pc);
Peter Maydell77211372013-02-22 18:10:02 +0000216 cpu_tb_exec(cpu, tb->tc_ptr);
Andreas Färberd77953b2013-01-16 19:29:31 +0100217 cpu->current_tb = NULL;
pbrook2e70f6e2008-06-29 01:03:05 +0000218 tb_phys_invalidate(tb, -1);
219 tb_free(tb);
220}
221
Andreas Färber9349b4f2012-03-14 01:38:32 +0100222static TranslationBlock *tb_find_slow(CPUArchState *env,
Blue Swirlcea5f9a2011-05-15 16:03:25 +0000223 target_ulong pc,
bellard8a40a182005-11-20 10:35:40 +0000224 target_ulong cs_base,
j_mayerc0686882007-09-20 22:47:42 +0000225 uint64_t flags)
bellard8a40a182005-11-20 10:35:40 +0000226{
Andreas Färber8cd70432013-08-26 06:03:38 +0200227 CPUState *cpu = ENV_GET_CPU(env);
bellard8a40a182005-11-20 10:35:40 +0000228 TranslationBlock *tb, **ptb1;
bellard8a40a182005-11-20 10:35:40 +0000229 unsigned int h;
Blue Swirl337fc752011-09-04 11:06:22 +0000230 tb_page_addr_t phys_pc, phys_page1;
Paul Brook41c1b1c2010-03-12 16:54:58 +0000231 target_ulong virt_page2;
ths3b46e622007-09-17 08:09:54 +0000232
Evgeny Voevodin5e5f07e2013-02-01 01:47:23 +0700233 tcg_ctx.tb_ctx.tb_invalidated_flag = 0;
ths3b46e622007-09-17 08:09:54 +0000234
bellard8a40a182005-11-20 10:35:40 +0000235 /* find translated block using physical mappings */
Paul Brook41c1b1c2010-03-12 16:54:58 +0000236 phys_pc = get_page_addr_code(env, pc);
bellard8a40a182005-11-20 10:35:40 +0000237 phys_page1 = phys_pc & TARGET_PAGE_MASK;
bellard8a40a182005-11-20 10:35:40 +0000238 h = tb_phys_hash_func(phys_pc);
Evgeny Voevodin5e5f07e2013-02-01 01:47:23 +0700239 ptb1 = &tcg_ctx.tb_ctx.tb_phys_hash[h];
bellard8a40a182005-11-20 10:35:40 +0000240 for(;;) {
241 tb = *ptb1;
242 if (!tb)
243 goto not_found;
ths5fafdf22007-09-16 21:08:06 +0000244 if (tb->pc == pc &&
bellard8a40a182005-11-20 10:35:40 +0000245 tb->page_addr[0] == phys_page1 &&
ths5fafdf22007-09-16 21:08:06 +0000246 tb->cs_base == cs_base &&
bellard8a40a182005-11-20 10:35:40 +0000247 tb->flags == flags) {
248 /* check next page if needed */
249 if (tb->page_addr[1] != -1) {
Blue Swirl337fc752011-09-04 11:06:22 +0000250 tb_page_addr_t phys_page2;
251
ths5fafdf22007-09-16 21:08:06 +0000252 virt_page2 = (pc & TARGET_PAGE_MASK) +
bellard8a40a182005-11-20 10:35:40 +0000253 TARGET_PAGE_SIZE;
Paul Brook41c1b1c2010-03-12 16:54:58 +0000254 phys_page2 = get_page_addr_code(env, virt_page2);
bellard8a40a182005-11-20 10:35:40 +0000255 if (tb->page_addr[1] == phys_page2)
256 goto found;
257 } else {
258 goto found;
259 }
260 }
261 ptb1 = &tb->phys_hash_next;
262 }
263 not_found:
pbrook2e70f6e2008-06-29 01:03:05 +0000264 /* if no translated code available, then translate it now */
Andreas Färber648f0342013-09-01 17:43:17 +0200265 tb = tb_gen_code(cpu, pc, cs_base, flags, 0);
ths3b46e622007-09-17 08:09:54 +0000266
bellard8a40a182005-11-20 10:35:40 +0000267 found:
Kirill Batuzov2c90fe22010-12-02 16:12:46 +0300268 /* Move the last found TB to the head of the list */
269 if (likely(*ptb1)) {
270 *ptb1 = tb->phys_hash_next;
Evgeny Voevodin5e5f07e2013-02-01 01:47:23 +0700271 tb->phys_hash_next = tcg_ctx.tb_ctx.tb_phys_hash[h];
272 tcg_ctx.tb_ctx.tb_phys_hash[h] = tb;
Kirill Batuzov2c90fe22010-12-02 16:12:46 +0300273 }
bellard8a40a182005-11-20 10:35:40 +0000274 /* we add the TB in the virtual pc hash table */
Andreas Färber8cd70432013-08-26 06:03:38 +0200275 cpu->tb_jmp_cache[tb_jmp_cache_hash_func(pc)] = tb;
bellard8a40a182005-11-20 10:35:40 +0000276 return tb;
277}
278
Andreas Färber9349b4f2012-03-14 01:38:32 +0100279static inline TranslationBlock *tb_find_fast(CPUArchState *env)
bellard8a40a182005-11-20 10:35:40 +0000280{
Andreas Färber8cd70432013-08-26 06:03:38 +0200281 CPUState *cpu = ENV_GET_CPU(env);
bellard8a40a182005-11-20 10:35:40 +0000282 TranslationBlock *tb;
283 target_ulong cs_base, pc;
aliguori6b917542008-11-18 19:46:41 +0000284 int flags;
bellard8a40a182005-11-20 10:35:40 +0000285
286 /* we record a subset of the CPU state. It will
287 always be the same before a given translated block
288 is executed. */
aliguori6b917542008-11-18 19:46:41 +0000289 cpu_get_tb_cpu_state(env, &pc, &cs_base, &flags);
Andreas Färber8cd70432013-08-26 06:03:38 +0200290 tb = cpu->tb_jmp_cache[tb_jmp_cache_hash_func(pc)];
ths551bd272008-07-03 17:57:36 +0000291 if (unlikely(!tb || tb->pc != pc || tb->cs_base != cs_base ||
292 tb->flags != flags)) {
Blue Swirlcea5f9a2011-05-15 16:03:25 +0000293 tb = tb_find_slow(env, pc, cs_base, flags);
bellard8a40a182005-11-20 10:35:40 +0000294 }
295 return tb;
296}
297
Andreas Färber9349b4f2012-03-14 01:38:32 +0100298static void cpu_handle_debug_exception(CPUArchState *env)
Jan Kiszka1009d2e2011-03-15 12:26:13 +0100299{
Andreas Färberff4700b2013-08-26 18:23:18 +0200300 CPUState *cpu = ENV_GET_CPU(env);
Peter Maydell86025ee2014-09-12 14:06:48 +0100301 CPUClass *cc = CPU_GET_CLASS(cpu);
Jan Kiszka1009d2e2011-03-15 12:26:13 +0100302 CPUWatchpoint *wp;
303
Andreas Färberff4700b2013-08-26 18:23:18 +0200304 if (!cpu->watchpoint_hit) {
305 QTAILQ_FOREACH(wp, &cpu->watchpoints, entry) {
Jan Kiszka1009d2e2011-03-15 12:26:13 +0100306 wp->flags &= ~BP_WATCHPOINT_HIT;
307 }
308 }
Peter Maydell86025ee2014-09-12 14:06:48 +0100309
310 cc->debug_excp_handler(cpu);
Jan Kiszka1009d2e2011-03-15 12:26:13 +0100311}
312
bellard7d132992003-03-06 23:23:54 +0000313/* main execution loop */
314
Marcelo Tosatti1a28cac2010-05-04 09:45:20 -0300315volatile sig_atomic_t exit_request;
316
Andreas Färber9349b4f2012-03-14 01:38:32 +0100317int cpu_exec(CPUArchState *env)
bellard7d132992003-03-06 23:23:54 +0000318{
Andreas Färberc356a1b2012-05-04 19:39:23 +0200319 CPUState *cpu = ENV_GET_CPU(env);
Andreas Färber97a8ea52013-02-02 10:57:51 +0100320 CPUClass *cc = CPU_GET_CLASS(cpu);
Andreas Färber693fa552013-12-24 03:18:12 +0100321#ifdef TARGET_I386
322 X86CPU *x86_cpu = X86_CPU(cpu);
323#endif
bellard8a40a182005-11-20 10:35:40 +0000324 int ret, interrupt_request;
bellard8a40a182005-11-20 10:35:40 +0000325 TranslationBlock *tb;
bellardc27004e2005-01-03 23:35:10 +0000326 uint8_t *tc_ptr;
Richard Henderson3e9bd632013-08-20 14:40:25 -0700327 uintptr_t next_tb;
Sebastian Tanasec2aa5f82014-07-25 11:56:31 +0200328 SyncClocks sc;
329
Peter Maydellbae2c272014-04-04 17:42:56 +0100330 /* This must be volatile so it is not trashed by longjmp() */
331 volatile bool have_tb_lock = false;
bellard8c6939c2003-06-09 15:28:00 +0000332
Andreas Färber259186a2013-01-17 18:51:17 +0100333 if (cpu->halted) {
Andreas Färber3993c6b2012-05-03 06:43:49 +0200334 if (!cpu_has_work(cpu)) {
Paolo Bonzinieda48c32011-03-12 17:43:56 +0100335 return EXCP_HALTED;
336 }
337
Andreas Färber259186a2013-01-17 18:51:17 +0100338 cpu->halted = 0;
Paolo Bonzinieda48c32011-03-12 17:43:56 +0100339 }
bellard5a1e3cf2005-11-23 21:02:53 +0000340
Andreas Färber4917cf42013-05-27 05:17:50 +0200341 current_cpu = cpu;
bellarde4533c72003-06-15 19:51:39 +0000342
Andreas Färber4917cf42013-05-27 05:17:50 +0200343 /* As long as current_cpu is null, up to the assignment just above,
Olivier Hainqueec9bd892013-04-09 18:06:54 +0200344 * requests by other threads to exit the execution loop are expected to
345 * be issued using the exit_request global. We must make sure that our
Andreas Färber4917cf42013-05-27 05:17:50 +0200346 * evaluation of the global value is performed past the current_cpu
Olivier Hainqueec9bd892013-04-09 18:06:54 +0200347 * value transition point, which requires a memory barrier as well as
348 * an instruction scheduling constraint on modern architectures. */
349 smp_mb();
350
Jan Kiszkac629a4b2010-06-25 16:56:52 +0200351 if (unlikely(exit_request)) {
Andreas Färberfcd7d002012-12-17 08:02:44 +0100352 cpu->exit_request = 1;
Marcelo Tosatti1a28cac2010-05-04 09:45:20 -0300353 }
354
Richard Hendersoncffe7b32014-09-13 09:45:12 -0700355 cc->cpu_exec_enter(cpu);
Andreas Färber27103422013-08-26 08:31:06 +0200356 cpu->exception_index = -1;
bellard9d27abd2003-05-10 13:13:54 +0000357
Sebastian Tanasec2aa5f82014-07-25 11:56:31 +0200358 /* Calculate difference between guest clock and host clock.
359 * This delay includes the delay of the last cycle, so
360 * what we have to do is sleep until it is 0. As for the
361 * advance/delay we gain here, we try to fix it next time.
362 */
363 init_delay_params(&sc, cpu);
364
bellard7d132992003-03-06 23:23:54 +0000365 /* prepare setjmp context for exception handling */
bellard3fb2ded2003-06-24 13:22:59 +0000366 for(;;) {
Andreas Färber6f03bef2013-08-26 06:22:03 +0200367 if (sigsetjmp(cpu->jmp_env, 0) == 0) {
bellard3fb2ded2003-06-24 13:22:59 +0000368 /* if an exception is pending, we execute it here */
Andreas Färber27103422013-08-26 08:31:06 +0200369 if (cpu->exception_index >= 0) {
370 if (cpu->exception_index >= EXCP_INTERRUPT) {
bellard3fb2ded2003-06-24 13:22:59 +0000371 /* exit request from the cpu execution loop */
Andreas Färber27103422013-08-26 08:31:06 +0200372 ret = cpu->exception_index;
Jan Kiszka1009d2e2011-03-15 12:26:13 +0100373 if (ret == EXCP_DEBUG) {
374 cpu_handle_debug_exception(env);
375 }
bellard3fb2ded2003-06-24 13:22:59 +0000376 break;
aurel3272d239e2009-01-14 19:40:27 +0000377 } else {
378#if defined(CONFIG_USER_ONLY)
bellard3fb2ded2003-06-24 13:22:59 +0000379 /* if user mode only, we simulate a fake exception
ths9f083492006-12-07 18:28:42 +0000380 which will be handled outside the cpu execution
bellard3fb2ded2003-06-24 13:22:59 +0000381 loop */
bellard83479e72003-06-25 16:12:37 +0000382#if defined(TARGET_I386)
Andreas Färber97a8ea52013-02-02 10:57:51 +0100383 cc->do_interrupt(cpu);
bellard83479e72003-06-25 16:12:37 +0000384#endif
Andreas Färber27103422013-08-26 08:31:06 +0200385 ret = cpu->exception_index;
bellard3fb2ded2003-06-24 13:22:59 +0000386 break;
aurel3272d239e2009-01-14 19:40:27 +0000387#else
Andreas Färber97a8ea52013-02-02 10:57:51 +0100388 cc->do_interrupt(cpu);
Andreas Färber27103422013-08-26 08:31:06 +0200389 cpu->exception_index = -1;
aurel3272d239e2009-01-14 19:40:27 +0000390#endif
bellard3fb2ded2003-06-24 13:22:59 +0000391 }
ths5fafdf22007-09-16 21:08:06 +0000392 }
bellard9df217a2005-02-10 22:05:51 +0000393
blueswir1b5fc09a2008-05-04 06:38:18 +0000394 next_tb = 0; /* force lookup of first TB */
bellard3fb2ded2003-06-24 13:22:59 +0000395 for(;;) {
Andreas Färber259186a2013-01-17 18:51:17 +0100396 interrupt_request = cpu->interrupt_request;
malce1638bd2008-11-06 18:54:46 +0000397 if (unlikely(interrupt_request)) {
Andreas Färbered2803d2013-06-21 20:20:45 +0200398 if (unlikely(cpu->singlestep_enabled & SSTEP_NOIRQ)) {
malce1638bd2008-11-06 18:54:46 +0000399 /* Mask out external interrupts for this step. */
Richard Henderson3125f762011-05-04 13:34:25 -0700400 interrupt_request &= ~CPU_INTERRUPT_SSTEP_MASK;
malce1638bd2008-11-06 18:54:46 +0000401 }
pbrook6658ffb2007-03-16 23:58:11 +0000402 if (interrupt_request & CPU_INTERRUPT_DEBUG) {
Andreas Färber259186a2013-01-17 18:51:17 +0100403 cpu->interrupt_request &= ~CPU_INTERRUPT_DEBUG;
Andreas Färber27103422013-08-26 08:31:06 +0200404 cpu->exception_index = EXCP_DEBUG;
Andreas Färber5638d182013-08-27 17:52:12 +0200405 cpu_loop_exit(cpu);
pbrook6658ffb2007-03-16 23:58:11 +0000406 }
balroga90b7312007-05-01 01:28:01 +0000407 if (interrupt_request & CPU_INTERRUPT_HALT) {
Andreas Färber259186a2013-01-17 18:51:17 +0100408 cpu->interrupt_request &= ~CPU_INTERRUPT_HALT;
409 cpu->halted = 1;
Andreas Färber27103422013-08-26 08:31:06 +0200410 cpu->exception_index = EXCP_HLT;
Andreas Färber5638d182013-08-27 17:52:12 +0200411 cpu_loop_exit(cpu);
balroga90b7312007-05-01 01:28:01 +0000412 }
bellard68a79312003-06-30 13:12:32 +0000413#if defined(TARGET_I386)
Paolo Bonzini4a92a552013-03-05 15:35:17 +0100414 if (interrupt_request & CPU_INTERRUPT_INIT) {
415 cpu_svm_check_intercept_param(env, SVM_EXIT_INIT, 0);
416 do_cpu_init(x86_cpu);
417 cpu->exception_index = EXCP_HALTED;
418 cpu_loop_exit(cpu);
419 }
420#else
421 if (interrupt_request & CPU_INTERRUPT_RESET) {
422 cpu_reset(cpu);
423 }
424#endif
Richard Henderson9585db62014-09-13 09:45:17 -0700425 /* The target hook has 3 exit conditions:
426 False when the interrupt isn't processed,
427 True when it is, and we should restart on a new TB,
428 and via longjmp via cpu_loop_exit. */
429 if (cc->cpu_exec_interrupt(cpu, interrupt_request)) {
430 next_tb = 0;
431 }
432 /* Don't use the cached interrupt_request value,
433 do_interrupt may have updated the EXITTB flag. */
Andreas Färber259186a2013-01-17 18:51:17 +0100434 if (cpu->interrupt_request & CPU_INTERRUPT_EXITTB) {
435 cpu->interrupt_request &= ~CPU_INTERRUPT_EXITTB;
bellardbf3e8bf2004-02-16 21:58:54 +0000436 /* ensure that no TB jump will be modified as
437 the program flow was changed */
blueswir1b5fc09a2008-05-04 06:38:18 +0000438 next_tb = 0;
bellardbf3e8bf2004-02-16 21:58:54 +0000439 }
aurel32be214e62009-03-06 21:48:00 +0000440 }
Andreas Färberfcd7d002012-12-17 08:02:44 +0100441 if (unlikely(cpu->exit_request)) {
442 cpu->exit_request = 0;
Andreas Färber27103422013-08-26 08:31:06 +0200443 cpu->exception_index = EXCP_INTERRUPT;
Andreas Färber5638d182013-08-27 17:52:12 +0200444 cpu_loop_exit(cpu);
bellard3fb2ded2003-06-24 13:22:59 +0000445 }
Evgeny Voevodin5e5f07e2013-02-01 01:47:23 +0700446 spin_lock(&tcg_ctx.tb_ctx.tb_lock);
Peter Maydellbae2c272014-04-04 17:42:56 +0100447 have_tb_lock = true;
Blue Swirlcea5f9a2011-05-15 16:03:25 +0000448 tb = tb_find_fast(env);
pbrookd5975362008-06-07 20:50:51 +0000449 /* Note: we do it here to avoid a gcc bug on Mac OS X when
450 doing it in tb_find_slow */
Evgeny Voevodin5e5f07e2013-02-01 01:47:23 +0700451 if (tcg_ctx.tb_ctx.tb_invalidated_flag) {
pbrookd5975362008-06-07 20:50:51 +0000452 /* as some TB could have been invalidated because
453 of memory exceptions while generating the code, we
454 must recompute the hash index here */
455 next_tb = 0;
Evgeny Voevodin5e5f07e2013-02-01 01:47:23 +0700456 tcg_ctx.tb_ctx.tb_invalidated_flag = 0;
pbrookd5975362008-06-07 20:50:51 +0000457 }
Peter Maydellc30d1ae2013-04-11 21:21:46 +0100458 if (qemu_loglevel_mask(CPU_LOG_EXEC)) {
459 qemu_log("Trace %p [" TARGET_FMT_lx "] %s\n",
460 tb->tc_ptr, tb->pc, lookup_symbol(tb->pc));
461 }
bellard8a40a182005-11-20 10:35:40 +0000462 /* see if we can patch the calling TB. When the TB
463 spans two pages, we cannot safely do a direct
464 jump. */
Paolo Bonzini040f2fb2010-01-15 08:56:36 +0100465 if (next_tb != 0 && tb->page_addr[1] == -1) {
Peter Maydell09800112013-02-22 18:10:00 +0000466 tb_add_jump((TranslationBlock *)(next_tb & ~TB_EXIT_MASK),
467 next_tb & TB_EXIT_MASK, tb);
bellard3fb2ded2003-06-24 13:22:59 +0000468 }
Peter Maydellbae2c272014-04-04 17:42:56 +0100469 have_tb_lock = false;
Evgeny Voevodin5e5f07e2013-02-01 01:47:23 +0700470 spin_unlock(&tcg_ctx.tb_ctx.tb_lock);
malc55e8b852008-11-04 14:18:13 +0000471
472 /* cpu_interrupt might be called while translating the
473 TB, but before it is linked into a potentially
474 infinite loop and becomes env->current_tb. Avoid
475 starting execution if there is a pending interrupt. */
Andreas Färberd77953b2013-01-16 19:29:31 +0100476 cpu->current_tb = tb;
Jan Kiszkab0052d12010-06-25 16:56:50 +0200477 barrier();
Andreas Färberfcd7d002012-12-17 08:02:44 +0100478 if (likely(!cpu->exit_request)) {
Alex Bennée6db8b532014-08-01 17:08:57 +0100479 trace_exec_tb(tb, tb->pc);
pbrook2e70f6e2008-06-29 01:03:05 +0000480 tc_ptr = tb->tc_ptr;
陳韋任e965fc32012-02-06 14:02:55 +0800481 /* execute the generated code */
Peter Maydell77211372013-02-22 18:10:02 +0000482 next_tb = cpu_tb_exec(cpu, tc_ptr);
Peter Maydell378df4b2013-02-22 18:10:03 +0000483 switch (next_tb & TB_EXIT_MASK) {
484 case TB_EXIT_REQUESTED:
485 /* Something asked us to stop executing
486 * chained TBs; just continue round the main
487 * loop. Whatever requested the exit will also
488 * have set something else (eg exit_request or
489 * interrupt_request) which we will handle
490 * next time around the loop.
491 */
492 tb = (TranslationBlock *)(next_tb & ~TB_EXIT_MASK);
493 next_tb = 0;
494 break;
495 case TB_EXIT_ICOUNT_EXPIRED:
496 {
thsbf20dc02008-06-30 17:22:19 +0000497 /* Instruction counter expired. */
pbrook2e70f6e2008-06-29 01:03:05 +0000498 int insns_left;
Peter Maydell09800112013-02-22 18:10:00 +0000499 tb = (TranslationBlock *)(next_tb & ~TB_EXIT_MASK);
Andreas Färber28ecfd72013-08-26 05:51:49 +0200500 insns_left = cpu->icount_decr.u32;
Andreas Färberefee7342013-08-26 05:39:29 +0200501 if (cpu->icount_extra && insns_left >= 0) {
pbrook2e70f6e2008-06-29 01:03:05 +0000502 /* Refill decrementer and continue execution. */
Andreas Färberefee7342013-08-26 05:39:29 +0200503 cpu->icount_extra += insns_left;
504 if (cpu->icount_extra > 0xffff) {
pbrook2e70f6e2008-06-29 01:03:05 +0000505 insns_left = 0xffff;
506 } else {
Andreas Färberefee7342013-08-26 05:39:29 +0200507 insns_left = cpu->icount_extra;
pbrook2e70f6e2008-06-29 01:03:05 +0000508 }
Andreas Färberefee7342013-08-26 05:39:29 +0200509 cpu->icount_extra -= insns_left;
Andreas Färber28ecfd72013-08-26 05:51:49 +0200510 cpu->icount_decr.u16.low = insns_left;
pbrook2e70f6e2008-06-29 01:03:05 +0000511 } else {
512 if (insns_left > 0) {
513 /* Execute remaining instructions. */
Blue Swirlcea5f9a2011-05-15 16:03:25 +0000514 cpu_exec_nocache(env, insns_left, tb);
Sebastian Tanasec2aa5f82014-07-25 11:56:31 +0200515 align_clocks(&sc, cpu);
pbrook2e70f6e2008-06-29 01:03:05 +0000516 }
Andreas Färber27103422013-08-26 08:31:06 +0200517 cpu->exception_index = EXCP_INTERRUPT;
pbrook2e70f6e2008-06-29 01:03:05 +0000518 next_tb = 0;
Andreas Färber5638d182013-08-27 17:52:12 +0200519 cpu_loop_exit(cpu);
pbrook2e70f6e2008-06-29 01:03:05 +0000520 }
Peter Maydell378df4b2013-02-22 18:10:03 +0000521 break;
522 }
523 default:
524 break;
pbrook2e70f6e2008-06-29 01:03:05 +0000525 }
526 }
Andreas Färberd77953b2013-01-16 19:29:31 +0100527 cpu->current_tb = NULL;
Sebastian Tanasec2aa5f82014-07-25 11:56:31 +0200528 /* Try to align the host and virtual clocks
529 if the guest is in advance */
530 align_clocks(&sc, cpu);
bellard4cbf74b2003-08-10 21:48:43 +0000531 /* reset soft MMU for next block (it can currently
532 only be set by a memory fault) */
ths50a518e2007-06-03 18:52:15 +0000533 } /* for(;;) */
Jan Kiszka0d101932011-07-02 09:50:51 +0200534 } else {
535 /* Reload env after longjmp - the compiler may have smashed all
536 * local variables as longjmp is marked 'noreturn'. */
Andreas Färber4917cf42013-05-27 05:17:50 +0200537 cpu = current_cpu;
538 env = cpu->env_ptr;
Juergen Lock6c78f292013-10-03 16:09:37 +0200539 cc = CPU_GET_CLASS(cpu);
Andreas Färber693fa552013-12-24 03:18:12 +0100540#ifdef TARGET_I386
541 x86_cpu = X86_CPU(cpu);
542#endif
Peter Maydellbae2c272014-04-04 17:42:56 +0100543 if (have_tb_lock) {
544 spin_unlock(&tcg_ctx.tb_ctx.tb_lock);
545 have_tb_lock = false;
546 }
bellard7d132992003-03-06 23:23:54 +0000547 }
bellard3fb2ded2003-06-24 13:22:59 +0000548 } /* for(;;) */
549
Richard Hendersoncffe7b32014-09-13 09:45:12 -0700550 cc->cpu_exec_exit(cpu);
pbrook1057eaa2007-02-04 13:37:44 +0000551
Andreas Färber4917cf42013-05-27 05:17:50 +0200552 /* fail safe : never use current_cpu outside cpu_exec() */
553 current_cpu = NULL;
bellard7d132992003-03-06 23:23:54 +0000554 return ret;
555}