bellard | 7d13299 | 2003-03-06 23:23:54 +0000 | [diff] [blame] | 1 | /* |
陳韋任 | e965fc3 | 2012-02-06 14:02:55 +0800 | [diff] [blame] | 2 | * emulator main execution loop |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 3 | * |
bellard | 66321a1 | 2005-04-06 20:47:48 +0000 | [diff] [blame] | 4 | * Copyright (c) 2003-2005 Fabrice Bellard |
bellard | 7d13299 | 2003-03-06 23:23:54 +0000 | [diff] [blame] | 5 | * |
bellard | 3ef693a | 2003-03-23 20:17:16 +0000 | [diff] [blame] | 6 | * 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. |
bellard | 7d13299 | 2003-03-06 23:23:54 +0000 | [diff] [blame] | 10 | * |
bellard | 3ef693a | 2003-03-23 20:17:16 +0000 | [diff] [blame] | 11 | * 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. |
bellard | 7d13299 | 2003-03-06 23:23:54 +0000 | [diff] [blame] | 15 | * |
bellard | 3ef693a | 2003-03-23 20:17:16 +0000 | [diff] [blame] | 16 | * You should have received a copy of the GNU Lesser General Public |
Blue Swirl | 8167ee8 | 2009-07-16 20:47:01 +0000 | [diff] [blame] | 17 | * License along with this library; if not, see <http://www.gnu.org/licenses/>. |
bellard | 7d13299 | 2003-03-06 23:23:54 +0000 | [diff] [blame] | 18 | */ |
Peter Maydell | 7b31bbc | 2016-01-26 18:16:56 +0000 | [diff] [blame] | 19 | #include "qemu/osdep.h" |
Blue Swirl | cea5f9a | 2011-05-15 16:03:25 +0000 | [diff] [blame] | 20 | #include "cpu.h" |
Alex Bennée | 6db8b53 | 2014-08-01 17:08:57 +0100 | [diff] [blame] | 21 | #include "trace.h" |
Paolo Bonzini | 76cad71 | 2012-10-24 11:12:21 +0200 | [diff] [blame] | 22 | #include "disas/disas.h" |
Paolo Bonzini | 63c9155 | 2016-03-15 13:18:37 +0100 | [diff] [blame] | 23 | #include "exec/exec-all.h" |
bellard | 7cb69ca | 2008-05-10 10:55:51 +0000 | [diff] [blame] | 24 | #include "tcg.h" |
Paolo Bonzini | 1de7afc | 2012-12-17 18:20:00 +0100 | [diff] [blame] | 25 | #include "qemu/atomic.h" |
Paolo Bonzini | 9c17d61 | 2012-12-17 18:20:04 +0100 | [diff] [blame] | 26 | #include "sysemu/qtest.h" |
Sebastian Tanase | c2aa5f8 | 2014-07-25 11:56:31 +0200 | [diff] [blame] | 27 | #include "qemu/timer.h" |
Paolo Bonzini | 9d82b5a | 2013-08-16 08:26:30 +0200 | [diff] [blame] | 28 | #include "exec/address-spaces.h" |
Paolo Bonzini | 79e2b9a | 2015-01-21 12:09:14 +0100 | [diff] [blame] | 29 | #include "qemu/rcu.h" |
Peter Crosthwaite | e1b8932 | 2015-05-30 23:11:45 -0700 | [diff] [blame] | 30 | #include "exec/tb-hash.h" |
Paolo Bonzini | 508127e | 2016-01-07 16:55:28 +0300 | [diff] [blame] | 31 | #include "exec/log.h" |
Pavel Dovgalyuk | 6220e90 | 2015-09-17 19:23:31 +0300 | [diff] [blame] | 32 | #if defined(TARGET_I386) && !defined(CONFIG_USER_ONLY) |
| 33 | #include "hw/i386/apic.h" |
| 34 | #endif |
Pavel Dovgalyuk | 6f06096 | 2015-09-17 19:24:16 +0300 | [diff] [blame] | 35 | #include "sysemu/replay.h" |
Sebastian Tanase | c2aa5f8 | 2014-07-25 11:56:31 +0200 | [diff] [blame] | 36 | |
| 37 | /* -icount align implementation. */ |
| 38 | |
| 39 | typedef struct SyncClocks { |
| 40 | int64_t diff_clk; |
| 41 | int64_t last_cpu_icount; |
Sebastian Tanase | 7f7bc14 | 2014-07-25 11:56:32 +0200 | [diff] [blame] | 42 | int64_t realtime_clock; |
Sebastian Tanase | c2aa5f8 | 2014-07-25 11:56:31 +0200 | [diff] [blame] | 43 | } SyncClocks; |
| 44 | |
| 45 | #if !defined(CONFIG_USER_ONLY) |
| 46 | /* Allow the guest to have a max 3ms advance. |
| 47 | * The difference between the 2 clocks could therefore |
| 48 | * oscillate around 0. |
| 49 | */ |
| 50 | #define VM_CLOCK_ADVANCE 3000000 |
Sebastian Tanase | 7f7bc14 | 2014-07-25 11:56:32 +0200 | [diff] [blame] | 51 | #define THRESHOLD_REDUCE 1.5 |
| 52 | #define MAX_DELAY_PRINT_RATE 2000000000LL |
| 53 | #define MAX_NB_PRINTS 100 |
Sebastian Tanase | c2aa5f8 | 2014-07-25 11:56:31 +0200 | [diff] [blame] | 54 | |
| 55 | static void align_clocks(SyncClocks *sc, const CPUState *cpu) |
| 56 | { |
| 57 | int64_t cpu_icount; |
| 58 | |
| 59 | if (!icount_align_option) { |
| 60 | return; |
| 61 | } |
| 62 | |
| 63 | cpu_icount = cpu->icount_extra + cpu->icount_decr.u16.low; |
| 64 | sc->diff_clk += cpu_icount_to_ns(sc->last_cpu_icount - cpu_icount); |
| 65 | sc->last_cpu_icount = cpu_icount; |
| 66 | |
| 67 | if (sc->diff_clk > VM_CLOCK_ADVANCE) { |
| 68 | #ifndef _WIN32 |
| 69 | struct timespec sleep_delay, rem_delay; |
| 70 | sleep_delay.tv_sec = sc->diff_clk / 1000000000LL; |
| 71 | sleep_delay.tv_nsec = sc->diff_clk % 1000000000LL; |
| 72 | if (nanosleep(&sleep_delay, &rem_delay) < 0) { |
Paolo Bonzini | a498d0e | 2015-01-28 10:09:55 +0100 | [diff] [blame] | 73 | sc->diff_clk = rem_delay.tv_sec * 1000000000LL + rem_delay.tv_nsec; |
Sebastian Tanase | c2aa5f8 | 2014-07-25 11:56:31 +0200 | [diff] [blame] | 74 | } else { |
| 75 | sc->diff_clk = 0; |
| 76 | } |
| 77 | #else |
| 78 | Sleep(sc->diff_clk / SCALE_MS); |
| 79 | sc->diff_clk = 0; |
| 80 | #endif |
| 81 | } |
| 82 | } |
| 83 | |
Sebastian Tanase | 7f7bc14 | 2014-07-25 11:56:32 +0200 | [diff] [blame] | 84 | static void print_delay(const SyncClocks *sc) |
| 85 | { |
| 86 | static float threshold_delay; |
| 87 | static int64_t last_realtime_clock; |
| 88 | static int nb_prints; |
| 89 | |
| 90 | if (icount_align_option && |
| 91 | sc->realtime_clock - last_realtime_clock >= MAX_DELAY_PRINT_RATE && |
| 92 | nb_prints < MAX_NB_PRINTS) { |
| 93 | if ((-sc->diff_clk / (float)1000000000LL > threshold_delay) || |
| 94 | (-sc->diff_clk / (float)1000000000LL < |
| 95 | (threshold_delay - THRESHOLD_REDUCE))) { |
| 96 | threshold_delay = (-sc->diff_clk / 1000000000LL) + 1; |
| 97 | printf("Warning: The guest is now late by %.1f to %.1f seconds\n", |
| 98 | threshold_delay - 1, |
| 99 | threshold_delay); |
| 100 | nb_prints++; |
| 101 | last_realtime_clock = sc->realtime_clock; |
| 102 | } |
| 103 | } |
| 104 | } |
| 105 | |
Sebastian Tanase | c2aa5f8 | 2014-07-25 11:56:31 +0200 | [diff] [blame] | 106 | static void init_delay_params(SyncClocks *sc, |
| 107 | const CPUState *cpu) |
| 108 | { |
| 109 | if (!icount_align_option) { |
| 110 | return; |
| 111 | } |
Paolo Bonzini | 2e91cc6 | 2015-01-28 10:16:37 +0100 | [diff] [blame] | 112 | sc->realtime_clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT); |
| 113 | sc->diff_clk = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) - sc->realtime_clock; |
Sebastian Tanase | c2aa5f8 | 2014-07-25 11:56:31 +0200 | [diff] [blame] | 114 | sc->last_cpu_icount = cpu->icount_extra + cpu->icount_decr.u16.low; |
Sebastian Tanase | 27498be | 2014-07-25 11:56:33 +0200 | [diff] [blame] | 115 | if (sc->diff_clk < max_delay) { |
| 116 | max_delay = sc->diff_clk; |
| 117 | } |
| 118 | if (sc->diff_clk > max_advance) { |
| 119 | max_advance = sc->diff_clk; |
| 120 | } |
Sebastian Tanase | 7f7bc14 | 2014-07-25 11:56:32 +0200 | [diff] [blame] | 121 | |
| 122 | /* Print every 2s max if the guest is late. We limit the number |
| 123 | of printed messages to NB_PRINT_MAX(currently 100) */ |
| 124 | print_delay(sc); |
Sebastian Tanase | c2aa5f8 | 2014-07-25 11:56:31 +0200 | [diff] [blame] | 125 | } |
| 126 | #else |
| 127 | static void align_clocks(SyncClocks *sc, const CPUState *cpu) |
| 128 | { |
| 129 | } |
| 130 | |
| 131 | static void init_delay_params(SyncClocks *sc, const CPUState *cpu) |
| 132 | { |
| 133 | } |
| 134 | #endif /* CONFIG USER ONLY */ |
bellard | 7d13299 | 2003-03-06 23:23:54 +0000 | [diff] [blame] | 135 | |
Peter Maydell | 7721137 | 2013-02-22 18:10:02 +0000 | [diff] [blame] | 136 | /* Execute a TB, and fix up the CPU state afterwards if necessary */ |
Peter Maydell | 1a83063 | 2016-03-15 14:30:19 +0000 | [diff] [blame] | 137 | static inline tcg_target_ulong cpu_tb_exec(CPUState *cpu, TranslationBlock *itb) |
Peter Maydell | 7721137 | 2013-02-22 18:10:02 +0000 | [diff] [blame] | 138 | { |
| 139 | CPUArchState *env = cpu->env_ptr; |
Sergey Fedorov | 819af24 | 2016-04-21 15:58:23 +0300 | [diff] [blame] | 140 | uintptr_t ret; |
| 141 | TranslationBlock *last_tb; |
| 142 | int tb_exit; |
Peter Maydell | 1a83063 | 2016-03-15 14:30:19 +0000 | [diff] [blame] | 143 | uint8_t *tb_ptr = itb->tc_ptr; |
| 144 | |
Alex Bennée | d977e1c | 2016-03-15 14:30:21 +0000 | [diff] [blame] | 145 | qemu_log_mask_and_addr(CPU_LOG_EXEC, itb->pc, |
| 146 | "Trace %p [" TARGET_FMT_lx "] %s\n", |
| 147 | itb->tc_ptr, itb->pc, lookup_symbol(itb->pc)); |
Richard Henderson | 03afa5f | 2013-11-06 17:29:39 +1000 | [diff] [blame] | 148 | |
| 149 | #if defined(DEBUG_DISAS) |
| 150 | if (qemu_loglevel_mask(CPU_LOG_TB_CPU)) { |
| 151 | #if defined(TARGET_I386) |
| 152 | log_cpu_state(cpu, CPU_DUMP_CCOP); |
| 153 | #elif defined(TARGET_M68K) |
| 154 | /* ??? Should not modify env state for dumping. */ |
| 155 | cpu_m68k_flush_flags(env, env->cc_op); |
| 156 | env->cc_op = CC_OP_FLAGS; |
| 157 | env->sr = (env->sr & 0xffe0) | env->cc_dest | (env->cc_x << 4); |
| 158 | log_cpu_state(cpu, 0); |
| 159 | #else |
| 160 | log_cpu_state(cpu, 0); |
| 161 | #endif |
| 162 | } |
| 163 | #endif /* DEBUG_DISAS */ |
| 164 | |
Paolo Bonzini | 414b15c | 2015-06-24 14:16:26 +0200 | [diff] [blame] | 165 | cpu->can_do_io = !use_icount; |
Sergey Fedorov | 819af24 | 2016-04-21 15:58:23 +0300 | [diff] [blame] | 166 | ret = tcg_qemu_tb_exec(env, tb_ptr); |
Pavel Dovgalyuk | 626cf8f | 2014-12-08 10:53:17 +0300 | [diff] [blame] | 167 | cpu->can_do_io = 1; |
Sergey Fedorov | 819af24 | 2016-04-21 15:58:23 +0300 | [diff] [blame] | 168 | last_tb = (TranslationBlock *)(ret & ~TB_EXIT_MASK); |
| 169 | tb_exit = ret & TB_EXIT_MASK; |
| 170 | trace_exec_tb_exit(last_tb, tb_exit); |
Alex Bennée | 6db8b53 | 2014-08-01 17:08:57 +0100 | [diff] [blame] | 171 | |
Sergey Fedorov | 819af24 | 2016-04-21 15:58:23 +0300 | [diff] [blame] | 172 | if (tb_exit > TB_EXIT_IDX1) { |
Peter Maydell | 7721137 | 2013-02-22 18:10:02 +0000 | [diff] [blame] | 173 | /* We didn't start executing this TB (eg because the instruction |
| 174 | * counter hit zero); we must restore the guest PC to the address |
| 175 | * of the start of the TB. |
| 176 | */ |
Andreas Färber | bdf7ae5 | 2013-06-28 19:31:32 +0200 | [diff] [blame] | 177 | CPUClass *cc = CPU_GET_CLASS(cpu); |
Sergey Fedorov | 819af24 | 2016-04-21 15:58:23 +0300 | [diff] [blame] | 178 | qemu_log_mask_and_addr(CPU_LOG_EXEC, last_tb->pc, |
Alex Bennée | d977e1c | 2016-03-15 14:30:21 +0000 | [diff] [blame] | 179 | "Stopped execution of TB chain before %p [" |
| 180 | TARGET_FMT_lx "] %s\n", |
Sergey Fedorov | 819af24 | 2016-04-21 15:58:23 +0300 | [diff] [blame] | 181 | last_tb->tc_ptr, last_tb->pc, |
| 182 | lookup_symbol(last_tb->pc)); |
Andreas Färber | bdf7ae5 | 2013-06-28 19:31:32 +0200 | [diff] [blame] | 183 | if (cc->synchronize_from_tb) { |
Sergey Fedorov | 819af24 | 2016-04-21 15:58:23 +0300 | [diff] [blame] | 184 | cc->synchronize_from_tb(cpu, last_tb); |
Andreas Färber | bdf7ae5 | 2013-06-28 19:31:32 +0200 | [diff] [blame] | 185 | } else { |
| 186 | assert(cc->set_pc); |
Sergey Fedorov | 819af24 | 2016-04-21 15:58:23 +0300 | [diff] [blame] | 187 | cc->set_pc(cpu, last_tb->pc); |
Andreas Färber | bdf7ae5 | 2013-06-28 19:31:32 +0200 | [diff] [blame] | 188 | } |
Peter Maydell | 7721137 | 2013-02-22 18:10:02 +0000 | [diff] [blame] | 189 | } |
Sergey Fedorov | 819af24 | 2016-04-21 15:58:23 +0300 | [diff] [blame] | 190 | if (tb_exit == TB_EXIT_REQUESTED) { |
Peter Maydell | 378df4b | 2013-02-22 18:10:03 +0000 | [diff] [blame] | 191 | /* We were asked to stop executing TBs (probably a pending |
| 192 | * interrupt. We've now stopped, so clear the flag. |
| 193 | */ |
| 194 | cpu->tcg_exit_req = 0; |
| 195 | } |
Sergey Fedorov | 819af24 | 2016-04-21 15:58:23 +0300 | [diff] [blame] | 196 | return ret; |
Peter Maydell | 7721137 | 2013-02-22 18:10:02 +0000 | [diff] [blame] | 197 | } |
| 198 | |
Paolo Bonzini | 7687bf5 | 2015-08-11 11:05:12 +0200 | [diff] [blame] | 199 | #ifndef CONFIG_USER_ONLY |
pbrook | 2e70f6e | 2008-06-29 01:03:05 +0000 | [diff] [blame] | 200 | /* Execute the code without caching the generated code. An interpreter |
| 201 | could be used if available. */ |
Peter Crosthwaite | ea3e984 | 2015-06-18 10:24:55 -0700 | [diff] [blame] | 202 | static void cpu_exec_nocache(CPUState *cpu, int max_cycles, |
Pavel Dovgalyuk | 56c0269 | 2015-09-17 19:23:59 +0300 | [diff] [blame] | 203 | TranslationBlock *orig_tb, bool ignore_icount) |
pbrook | 2e70f6e | 2008-06-29 01:03:05 +0000 | [diff] [blame] | 204 | { |
pbrook | 2e70f6e | 2008-06-29 01:03:05 +0000 | [diff] [blame] | 205 | TranslationBlock *tb; |
Sergey Fedorov | 6f789be | 2016-04-13 22:40:18 +0300 | [diff] [blame] | 206 | bool old_tb_flushed; |
pbrook | 2e70f6e | 2008-06-29 01:03:05 +0000 | [diff] [blame] | 207 | |
| 208 | /* Should never happen. |
| 209 | We only end up here when an existing TB is too long. */ |
| 210 | if (max_cycles > CF_COUNT_MASK) |
| 211 | max_cycles = CF_COUNT_MASK; |
| 212 | |
Sergey Fedorov | 6f789be | 2016-04-13 22:40:18 +0300 | [diff] [blame] | 213 | old_tb_flushed = cpu->tb_flushed; |
| 214 | cpu->tb_flushed = false; |
Sergey Fedorov | 02d57ea | 2015-06-30 12:35:09 +0300 | [diff] [blame] | 215 | tb = tb_gen_code(cpu, orig_tb->pc, orig_tb->cs_base, orig_tb->flags, |
Pavel Dovgalyuk | 56c0269 | 2015-09-17 19:23:59 +0300 | [diff] [blame] | 216 | max_cycles | CF_NOCACHE |
| 217 | | (ignore_icount ? CF_IGNORE_ICOUNT : 0)); |
Sergey Fedorov | 6f789be | 2016-04-13 22:40:18 +0300 | [diff] [blame] | 218 | tb->orig_tb = cpu->tb_flushed ? NULL : orig_tb; |
| 219 | cpu->tb_flushed |= old_tb_flushed; |
pbrook | 2e70f6e | 2008-06-29 01:03:05 +0000 | [diff] [blame] | 220 | /* execute the generated code */ |
Alex Bennée | 6db8b53 | 2014-08-01 17:08:57 +0100 | [diff] [blame] | 221 | trace_exec_tb_nocache(tb, tb->pc); |
Peter Maydell | 1a83063 | 2016-03-15 14:30:19 +0000 | [diff] [blame] | 222 | cpu_tb_exec(cpu, tb); |
pbrook | 2e70f6e | 2008-06-29 01:03:05 +0000 | [diff] [blame] | 223 | tb_phys_invalidate(tb, -1); |
| 224 | tb_free(tb); |
| 225 | } |
Paolo Bonzini | 7687bf5 | 2015-08-11 11:05:12 +0200 | [diff] [blame] | 226 | #endif |
pbrook | 2e70f6e | 2008-06-29 01:03:05 +0000 | [diff] [blame] | 227 | |
Emilio G. Cota | 909eaac | 2016-06-08 14:55:32 -0400 | [diff] [blame] | 228 | struct tb_desc { |
| 229 | target_ulong pc; |
| 230 | target_ulong cs_base; |
| 231 | CPUArchState *env; |
| 232 | tb_page_addr_t phys_page1; |
| 233 | uint32_t flags; |
| 234 | }; |
| 235 | |
| 236 | static bool tb_cmp(const void *p, const void *d) |
| 237 | { |
| 238 | const TranslationBlock *tb = p; |
| 239 | const struct tb_desc *desc = d; |
| 240 | |
| 241 | if (tb->pc == desc->pc && |
| 242 | tb->page_addr[0] == desc->phys_page1 && |
| 243 | tb->cs_base == desc->cs_base && |
Paolo Bonzini | 6d21e42 | 2016-07-19 08:36:18 +0200 | [diff] [blame] | 244 | tb->flags == desc->flags && |
| 245 | !atomic_read(&tb->invalid)) { |
Emilio G. Cota | 909eaac | 2016-06-08 14:55:32 -0400 | [diff] [blame] | 246 | /* check next page if needed */ |
| 247 | if (tb->page_addr[1] == -1) { |
| 248 | return true; |
| 249 | } else { |
| 250 | tb_page_addr_t phys_page2; |
| 251 | target_ulong virt_page2; |
| 252 | |
| 253 | virt_page2 = (desc->pc & TARGET_PAGE_MASK) + TARGET_PAGE_SIZE; |
| 254 | phys_page2 = get_page_addr_code(desc->env, virt_page2); |
| 255 | if (tb->page_addr[1] == phys_page2) { |
| 256 | return true; |
| 257 | } |
| 258 | } |
| 259 | } |
| 260 | return false; |
| 261 | } |
| 262 | |
Paolo Bonzini | 9fd1a94 | 2015-08-11 11:33:24 +0200 | [diff] [blame] | 263 | static TranslationBlock *tb_find_physical(CPUState *cpu, |
| 264 | target_ulong pc, |
| 265 | target_ulong cs_base, |
Emilio G. Cota | 89fee74 | 2016-04-07 13:19:22 -0400 | [diff] [blame] | 266 | uint32_t flags) |
bellard | 8a40a18 | 2005-11-20 10:35:40 +0000 | [diff] [blame] | 267 | { |
Emilio G. Cota | 909eaac | 2016-06-08 14:55:32 -0400 | [diff] [blame] | 268 | tb_page_addr_t phys_pc; |
| 269 | struct tb_desc desc; |
Emilio G. Cota | 42bd322 | 2016-06-08 14:55:25 -0400 | [diff] [blame] | 270 | uint32_t h; |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 271 | |
Emilio G. Cota | 909eaac | 2016-06-08 14:55:32 -0400 | [diff] [blame] | 272 | desc.env = (CPUArchState *)cpu->env_ptr; |
| 273 | desc.cs_base = cs_base; |
| 274 | desc.flags = flags; |
| 275 | desc.pc = pc; |
| 276 | phys_pc = get_page_addr_code(desc.env, pc); |
| 277 | desc.phys_page1 = phys_pc & TARGET_PAGE_MASK; |
Emilio G. Cota | 42bd322 | 2016-06-08 14:55:25 -0400 | [diff] [blame] | 278 | h = tb_hash_func(phys_pc, pc, flags); |
Emilio G. Cota | 909eaac | 2016-06-08 14:55:32 -0400 | [diff] [blame] | 279 | return qht_lookup(&tcg_ctx.tb_ctx.htable, tb_cmp, &desc, h); |
Paolo Bonzini | 9fd1a94 | 2015-08-11 11:33:24 +0200 | [diff] [blame] | 280 | } |
| 281 | |
| 282 | static TranslationBlock *tb_find_slow(CPUState *cpu, |
| 283 | target_ulong pc, |
| 284 | target_ulong cs_base, |
Emilio G. Cota | 89fee74 | 2016-04-07 13:19:22 -0400 | [diff] [blame] | 285 | uint32_t flags) |
Paolo Bonzini | 9fd1a94 | 2015-08-11 11:33:24 +0200 | [diff] [blame] | 286 | { |
| 287 | TranslationBlock *tb; |
| 288 | |
| 289 | tb = tb_find_physical(cpu, pc, cs_base, flags); |
Alex Bennée | 518615c | 2016-07-15 20:58:49 +0300 | [diff] [blame^] | 290 | if (!tb) { |
Paolo Bonzini | 9fd1a94 | 2015-08-11 11:33:24 +0200 | [diff] [blame] | 291 | |
Alex Bennée | 518615c | 2016-07-15 20:58:49 +0300 | [diff] [blame^] | 292 | /* mmap_lock is needed by tb_gen_code, and mmap_lock must be |
| 293 | * taken outside tb_lock. As system emulation is currently |
| 294 | * single threaded the locks are NOPs. |
| 295 | */ |
| 296 | mmap_lock(); |
| 297 | tb_lock(); |
| 298 | |
| 299 | /* There's a chance that our desired tb has been translated while |
| 300 | * taking the locks so we check again inside the lock. |
| 301 | */ |
| 302 | tb = tb_find_physical(cpu, pc, cs_base, flags); |
| 303 | if (!tb) { |
| 304 | /* if no translated code available, then translate it now */ |
| 305 | tb = tb_gen_code(cpu, pc, cs_base, flags, 0); |
| 306 | } |
| 307 | |
| 308 | tb_unlock(); |
Paolo Bonzini | 9fd1a94 | 2015-08-11 11:33:24 +0200 | [diff] [blame] | 309 | mmap_unlock(); |
Paolo Bonzini | 9fd1a94 | 2015-08-11 11:33:24 +0200 | [diff] [blame] | 310 | } |
Paolo Bonzini | 9fd1a94 | 2015-08-11 11:33:24 +0200 | [diff] [blame] | 311 | |
Alex Bennée | 518615c | 2016-07-15 20:58:49 +0300 | [diff] [blame^] | 312 | /* We add the TB in the virtual pc hash table for the fast lookup */ |
Sergey Fedorov | 89a16b1 | 2016-07-15 20:58:43 +0300 | [diff] [blame] | 313 | atomic_set(&cpu->tb_jmp_cache[tb_jmp_cache_hash_func(pc)], tb); |
bellard | 8a40a18 | 2005-11-20 10:35:40 +0000 | [diff] [blame] | 314 | return tb; |
| 315 | } |
| 316 | |
Sergey Fedorov | a0522c7 | 2016-04-25 18:17:30 +0300 | [diff] [blame] | 317 | static inline TranslationBlock *tb_find_fast(CPUState *cpu, |
Sergey Fedorov | 4b7e695 | 2016-07-15 20:58:42 +0300 | [diff] [blame] | 318 | TranslationBlock *last_tb, |
Sergey Fedorov | a0522c7 | 2016-04-25 18:17:30 +0300 | [diff] [blame] | 319 | int tb_exit) |
bellard | 8a40a18 | 2005-11-20 10:35:40 +0000 | [diff] [blame] | 320 | { |
Peter Crosthwaite | ea3e984 | 2015-06-18 10:24:55 -0700 | [diff] [blame] | 321 | CPUArchState *env = (CPUArchState *)cpu->env_ptr; |
bellard | 8a40a18 | 2005-11-20 10:35:40 +0000 | [diff] [blame] | 322 | TranslationBlock *tb; |
| 323 | target_ulong cs_base, pc; |
Emilio G. Cota | 89fee74 | 2016-04-07 13:19:22 -0400 | [diff] [blame] | 324 | uint32_t flags; |
bellard | 8a40a18 | 2005-11-20 10:35:40 +0000 | [diff] [blame] | 325 | |
| 326 | /* we record a subset of the CPU state. It will |
| 327 | always be the same before a given translated block |
| 328 | is executed. */ |
aliguori | 6b91754 | 2008-11-18 19:46:41 +0000 | [diff] [blame] | 329 | cpu_get_tb_cpu_state(env, &pc, &cs_base, &flags); |
Sergey Fedorov | 89a16b1 | 2016-07-15 20:58:43 +0300 | [diff] [blame] | 330 | tb = atomic_rcu_read(&cpu->tb_jmp_cache[tb_jmp_cache_hash_func(pc)]); |
ths | 551bd27 | 2008-07-03 17:57:36 +0000 | [diff] [blame] | 331 | if (unlikely(!tb || tb->pc != pc || tb->cs_base != cs_base || |
| 332 | tb->flags != flags)) { |
Peter Crosthwaite | ea3e984 | 2015-06-18 10:24:55 -0700 | [diff] [blame] | 333 | tb = tb_find_slow(cpu, pc, cs_base, flags); |
bellard | 8a40a18 | 2005-11-20 10:35:40 +0000 | [diff] [blame] | 334 | } |
Sergey Fedorov | c88c67e | 2016-05-16 16:13:00 +0300 | [diff] [blame] | 335 | #ifndef CONFIG_USER_ONLY |
| 336 | /* We don't take care of direct jumps when address mapping changes in |
| 337 | * system emulation. So it's not safe to make a direct jump to a TB |
| 338 | * spanning two pages because the mapping for the second page can change. |
| 339 | */ |
| 340 | if (tb->page_addr[1] != -1) { |
Sergey Fedorov | 4b7e695 | 2016-07-15 20:58:42 +0300 | [diff] [blame] | 341 | last_tb = NULL; |
Sergey Fedorov | c88c67e | 2016-05-16 16:13:00 +0300 | [diff] [blame] | 342 | } |
| 343 | #endif |
Sergey Fedorov | a0522c7 | 2016-04-25 18:17:30 +0300 | [diff] [blame] | 344 | /* See if we can patch the calling TB. */ |
Sergey Fedorov | 4b7e695 | 2016-07-15 20:58:42 +0300 | [diff] [blame] | 345 | if (last_tb && !qemu_loglevel_mask(CPU_LOG_TB_NOCHAIN)) { |
Alex Bennée | 518615c | 2016-07-15 20:58:49 +0300 | [diff] [blame^] | 346 | tb_lock(); |
Sergey Fedorov | 118b073 | 2016-07-15 20:58:44 +0300 | [diff] [blame] | 347 | /* Check if translation buffer has been flushed */ |
| 348 | if (cpu->tb_flushed) { |
| 349 | cpu->tb_flushed = false; |
Paolo Bonzini | 6d21e42 | 2016-07-19 08:36:18 +0200 | [diff] [blame] | 350 | } else if (!tb->invalid) { |
Sergey Fedorov | 118b073 | 2016-07-15 20:58:44 +0300 | [diff] [blame] | 351 | tb_add_jump(last_tb, tb_exit, tb); |
| 352 | } |
Alex Bennée | 518615c | 2016-07-15 20:58:49 +0300 | [diff] [blame^] | 353 | tb_unlock(); |
Sergey Fedorov | a0522c7 | 2016-04-25 18:17:30 +0300 | [diff] [blame] | 354 | } |
bellard | 8a40a18 | 2005-11-20 10:35:40 +0000 | [diff] [blame] | 355 | return tb; |
| 356 | } |
| 357 | |
Sergey Fedorov | 8b2d34e | 2016-05-11 13:21:47 +0300 | [diff] [blame] | 358 | static inline bool cpu_handle_halt(CPUState *cpu) |
| 359 | { |
| 360 | if (cpu->halted) { |
| 361 | #if defined(TARGET_I386) && !defined(CONFIG_USER_ONLY) |
| 362 | if ((cpu->interrupt_request & CPU_INTERRUPT_POLL) |
| 363 | && replay_interrupt()) { |
| 364 | X86CPU *x86_cpu = X86_CPU(cpu); |
| 365 | apic_poll_irq(x86_cpu->apic_state); |
| 366 | cpu_reset_interrupt(cpu, CPU_INTERRUPT_POLL); |
| 367 | } |
| 368 | #endif |
| 369 | if (!cpu_has_work(cpu)) { |
| 370 | current_cpu = NULL; |
| 371 | return true; |
| 372 | } |
| 373 | |
| 374 | cpu->halted = 0; |
| 375 | } |
| 376 | |
| 377 | return false; |
| 378 | } |
| 379 | |
Sergey Fedorov | ea28476 | 2016-05-11 13:21:48 +0300 | [diff] [blame] | 380 | static inline void cpu_handle_debug_exception(CPUState *cpu) |
Jan Kiszka | 1009d2e | 2011-03-15 12:26:13 +0100 | [diff] [blame] | 381 | { |
Peter Maydell | 86025ee | 2014-09-12 14:06:48 +0100 | [diff] [blame] | 382 | CPUClass *cc = CPU_GET_CLASS(cpu); |
Jan Kiszka | 1009d2e | 2011-03-15 12:26:13 +0100 | [diff] [blame] | 383 | CPUWatchpoint *wp; |
| 384 | |
Andreas Färber | ff4700b | 2013-08-26 18:23:18 +0200 | [diff] [blame] | 385 | if (!cpu->watchpoint_hit) { |
| 386 | QTAILQ_FOREACH(wp, &cpu->watchpoints, entry) { |
Jan Kiszka | 1009d2e | 2011-03-15 12:26:13 +0100 | [diff] [blame] | 387 | wp->flags &= ~BP_WATCHPOINT_HIT; |
| 388 | } |
| 389 | } |
Peter Maydell | 86025ee | 2014-09-12 14:06:48 +0100 | [diff] [blame] | 390 | |
| 391 | cc->debug_excp_handler(cpu); |
Jan Kiszka | 1009d2e | 2011-03-15 12:26:13 +0100 | [diff] [blame] | 392 | } |
| 393 | |
Sergey Fedorov | ea28476 | 2016-05-11 13:21:48 +0300 | [diff] [blame] | 394 | static inline bool cpu_handle_exception(CPUState *cpu, int *ret) |
| 395 | { |
| 396 | if (cpu->exception_index >= 0) { |
| 397 | if (cpu->exception_index >= EXCP_INTERRUPT) { |
| 398 | /* exit request from the cpu execution loop */ |
| 399 | *ret = cpu->exception_index; |
| 400 | if (*ret == EXCP_DEBUG) { |
| 401 | cpu_handle_debug_exception(cpu); |
| 402 | } |
| 403 | cpu->exception_index = -1; |
| 404 | return true; |
| 405 | } else { |
| 406 | #if defined(CONFIG_USER_ONLY) |
| 407 | /* if user mode only, we simulate a fake exception |
| 408 | which will be handled outside the cpu execution |
| 409 | loop */ |
| 410 | #if defined(TARGET_I386) |
| 411 | CPUClass *cc = CPU_GET_CLASS(cpu); |
| 412 | cc->do_interrupt(cpu); |
| 413 | #endif |
| 414 | *ret = cpu->exception_index; |
| 415 | cpu->exception_index = -1; |
| 416 | return true; |
| 417 | #else |
| 418 | if (replay_exception()) { |
| 419 | CPUClass *cc = CPU_GET_CLASS(cpu); |
| 420 | cc->do_interrupt(cpu); |
| 421 | cpu->exception_index = -1; |
| 422 | } else if (!replay_has_interrupt()) { |
| 423 | /* give a chance to iothread in replay mode */ |
| 424 | *ret = EXCP_INTERRUPT; |
| 425 | return true; |
| 426 | } |
| 427 | #endif |
| 428 | } |
| 429 | #ifndef CONFIG_USER_ONLY |
| 430 | } else if (replay_has_exception() |
| 431 | && cpu->icount_decr.u16.low + cpu->icount_extra == 0) { |
| 432 | /* try to cause an exception pending in the log */ |
Sergey Fedorov | 4b7e695 | 2016-07-15 20:58:42 +0300 | [diff] [blame] | 433 | cpu_exec_nocache(cpu, 1, tb_find_fast(cpu, NULL, 0), true); |
Sergey Fedorov | ea28476 | 2016-05-11 13:21:48 +0300 | [diff] [blame] | 434 | *ret = -1; |
| 435 | return true; |
| 436 | #endif |
| 437 | } |
| 438 | |
| 439 | return false; |
| 440 | } |
| 441 | |
Sergey Fedorov | c385e6e | 2016-05-11 13:21:49 +0300 | [diff] [blame] | 442 | static inline void cpu_handle_interrupt(CPUState *cpu, |
| 443 | TranslationBlock **last_tb) |
| 444 | { |
| 445 | CPUClass *cc = CPU_GET_CLASS(cpu); |
| 446 | int interrupt_request = cpu->interrupt_request; |
| 447 | |
| 448 | if (unlikely(interrupt_request)) { |
| 449 | if (unlikely(cpu->singlestep_enabled & SSTEP_NOIRQ)) { |
| 450 | /* Mask out external interrupts for this step. */ |
| 451 | interrupt_request &= ~CPU_INTERRUPT_SSTEP_MASK; |
| 452 | } |
| 453 | if (interrupt_request & CPU_INTERRUPT_DEBUG) { |
| 454 | cpu->interrupt_request &= ~CPU_INTERRUPT_DEBUG; |
| 455 | cpu->exception_index = EXCP_DEBUG; |
| 456 | cpu_loop_exit(cpu); |
| 457 | } |
| 458 | if (replay_mode == REPLAY_MODE_PLAY && !replay_has_interrupt()) { |
| 459 | /* Do nothing */ |
| 460 | } else if (interrupt_request & CPU_INTERRUPT_HALT) { |
| 461 | replay_interrupt(); |
| 462 | cpu->interrupt_request &= ~CPU_INTERRUPT_HALT; |
| 463 | cpu->halted = 1; |
| 464 | cpu->exception_index = EXCP_HLT; |
| 465 | cpu_loop_exit(cpu); |
| 466 | } |
| 467 | #if defined(TARGET_I386) |
| 468 | else if (interrupt_request & CPU_INTERRUPT_INIT) { |
| 469 | X86CPU *x86_cpu = X86_CPU(cpu); |
| 470 | CPUArchState *env = &x86_cpu->env; |
| 471 | replay_interrupt(); |
| 472 | cpu_svm_check_intercept_param(env, SVM_EXIT_INIT, 0); |
| 473 | do_cpu_init(x86_cpu); |
| 474 | cpu->exception_index = EXCP_HALTED; |
| 475 | cpu_loop_exit(cpu); |
| 476 | } |
| 477 | #else |
| 478 | else if (interrupt_request & CPU_INTERRUPT_RESET) { |
| 479 | replay_interrupt(); |
| 480 | cpu_reset(cpu); |
| 481 | cpu_loop_exit(cpu); |
| 482 | } |
| 483 | #endif |
| 484 | /* The target hook has 3 exit conditions: |
| 485 | False when the interrupt isn't processed, |
| 486 | True when it is, and we should restart on a new TB, |
| 487 | and via longjmp via cpu_loop_exit. */ |
| 488 | else { |
| 489 | replay_interrupt(); |
| 490 | if (cc->cpu_exec_interrupt(cpu, interrupt_request)) { |
| 491 | *last_tb = NULL; |
| 492 | } |
Sergey Fedorov | 8b1fe3f | 2016-05-12 19:52:17 +0300 | [diff] [blame] | 493 | /* The target hook may have updated the 'cpu->interrupt_request'; |
| 494 | * reload the 'interrupt_request' value */ |
| 495 | interrupt_request = cpu->interrupt_request; |
Sergey Fedorov | c385e6e | 2016-05-11 13:21:49 +0300 | [diff] [blame] | 496 | } |
Sergey Fedorov | 8b1fe3f | 2016-05-12 19:52:17 +0300 | [diff] [blame] | 497 | if (interrupt_request & CPU_INTERRUPT_EXITTB) { |
Sergey Fedorov | c385e6e | 2016-05-11 13:21:49 +0300 | [diff] [blame] | 498 | cpu->interrupt_request &= ~CPU_INTERRUPT_EXITTB; |
| 499 | /* ensure that no TB jump will be modified as |
| 500 | the program flow was changed */ |
| 501 | *last_tb = NULL; |
| 502 | } |
| 503 | } |
| 504 | if (unlikely(cpu->exit_request || replay_has_interrupt())) { |
| 505 | cpu->exit_request = 0; |
| 506 | cpu->exception_index = EXCP_INTERRUPT; |
| 507 | cpu_loop_exit(cpu); |
| 508 | } |
| 509 | } |
| 510 | |
Sergey Fedorov | 928de9e | 2016-05-11 13:21:50 +0300 | [diff] [blame] | 511 | static inline void cpu_loop_exec_tb(CPUState *cpu, TranslationBlock *tb, |
| 512 | TranslationBlock **last_tb, int *tb_exit, |
| 513 | SyncClocks *sc) |
| 514 | { |
| 515 | uintptr_t ret; |
| 516 | |
| 517 | if (unlikely(cpu->exit_request)) { |
| 518 | return; |
| 519 | } |
| 520 | |
| 521 | trace_exec_tb(tb, tb->pc); |
| 522 | ret = cpu_tb_exec(cpu, tb); |
| 523 | *last_tb = (TranslationBlock *)(ret & ~TB_EXIT_MASK); |
| 524 | *tb_exit = ret & TB_EXIT_MASK; |
| 525 | switch (*tb_exit) { |
| 526 | case TB_EXIT_REQUESTED: |
| 527 | /* Something asked us to stop executing |
| 528 | * chained TBs; just continue round the main |
| 529 | * loop. Whatever requested the exit will also |
| 530 | * have set something else (eg exit_request or |
| 531 | * interrupt_request) which we will handle |
| 532 | * next time around the loop. But we need to |
| 533 | * ensure the tcg_exit_req read in generated code |
| 534 | * comes before the next read of cpu->exit_request |
| 535 | * or cpu->interrupt_request. |
| 536 | */ |
| 537 | smp_rmb(); |
| 538 | *last_tb = NULL; |
| 539 | break; |
| 540 | case TB_EXIT_ICOUNT_EXPIRED: |
| 541 | { |
| 542 | /* Instruction counter expired. */ |
| 543 | #ifdef CONFIG_USER_ONLY |
| 544 | abort(); |
| 545 | #else |
| 546 | int insns_left = cpu->icount_decr.u32; |
| 547 | if (cpu->icount_extra && insns_left >= 0) { |
| 548 | /* Refill decrementer and continue execution. */ |
| 549 | cpu->icount_extra += insns_left; |
| 550 | insns_left = MIN(0xffff, cpu->icount_extra); |
| 551 | cpu->icount_extra -= insns_left; |
| 552 | cpu->icount_decr.u16.low = insns_left; |
| 553 | } else { |
| 554 | if (insns_left > 0) { |
| 555 | /* Execute remaining instructions. */ |
| 556 | cpu_exec_nocache(cpu, insns_left, *last_tb, false); |
| 557 | align_clocks(sc, cpu); |
| 558 | } |
| 559 | cpu->exception_index = EXCP_INTERRUPT; |
| 560 | *last_tb = NULL; |
| 561 | cpu_loop_exit(cpu); |
| 562 | } |
| 563 | break; |
| 564 | #endif |
| 565 | } |
| 566 | default: |
| 567 | break; |
| 568 | } |
| 569 | } |
| 570 | |
bellard | 7d13299 | 2003-03-06 23:23:54 +0000 | [diff] [blame] | 571 | /* main execution loop */ |
| 572 | |
Peter Crosthwaite | ea3e984 | 2015-06-18 10:24:55 -0700 | [diff] [blame] | 573 | int cpu_exec(CPUState *cpu) |
bellard | 7d13299 | 2003-03-06 23:23:54 +0000 | [diff] [blame] | 574 | { |
Andreas Färber | 97a8ea5 | 2013-02-02 10:57:51 +0100 | [diff] [blame] | 575 | CPUClass *cc = CPU_GET_CLASS(cpu); |
Sergey Fedorov | c385e6e | 2016-05-11 13:21:49 +0300 | [diff] [blame] | 576 | int ret; |
Sebastian Tanase | c2aa5f8 | 2014-07-25 11:56:31 +0200 | [diff] [blame] | 577 | SyncClocks sc; |
| 578 | |
Pavel Dovgalyuk | 6f06096 | 2015-09-17 19:24:16 +0300 | [diff] [blame] | 579 | /* replay_interrupt may need current_cpu */ |
| 580 | current_cpu = cpu; |
| 581 | |
Sergey Fedorov | 8b2d34e | 2016-05-11 13:21:47 +0300 | [diff] [blame] | 582 | if (cpu_handle_halt(cpu)) { |
| 583 | return EXCP_HALTED; |
Paolo Bonzini | eda48c3 | 2011-03-12 17:43:56 +0100 | [diff] [blame] | 584 | } |
bellard | 5a1e3cf | 2005-11-23 21:02:53 +0000 | [diff] [blame] | 585 | |
Paolo Bonzini | 9373e63 | 2015-08-18 06:24:34 -0700 | [diff] [blame] | 586 | atomic_mb_set(&tcg_current_cpu, cpu); |
Paolo Bonzini | 79e2b9a | 2015-01-21 12:09:14 +0100 | [diff] [blame] | 587 | rcu_read_lock(); |
| 588 | |
Paolo Bonzini | aed807c | 2015-08-18 06:43:15 -0700 | [diff] [blame] | 589 | if (unlikely(atomic_mb_read(&exit_request))) { |
Andreas Färber | fcd7d00 | 2012-12-17 08:02:44 +0100 | [diff] [blame] | 590 | cpu->exit_request = 1; |
Marcelo Tosatti | 1a28cac | 2010-05-04 09:45:20 -0300 | [diff] [blame] | 591 | } |
| 592 | |
Richard Henderson | cffe7b3 | 2014-09-13 09:45:12 -0700 | [diff] [blame] | 593 | cc->cpu_exec_enter(cpu); |
bellard | 9d27abd | 2003-05-10 13:13:54 +0000 | [diff] [blame] | 594 | |
Sebastian Tanase | c2aa5f8 | 2014-07-25 11:56:31 +0200 | [diff] [blame] | 595 | /* Calculate difference between guest clock and host clock. |
| 596 | * This delay includes the delay of the last cycle, so |
| 597 | * what we have to do is sleep until it is 0. As for the |
| 598 | * advance/delay we gain here, we try to fix it next time. |
| 599 | */ |
| 600 | init_delay_params(&sc, cpu); |
| 601 | |
bellard | 3fb2ded | 2003-06-24 13:22:59 +0000 | [diff] [blame] | 602 | for(;;) { |
Sergey Fedorov | ea28476 | 2016-05-11 13:21:48 +0300 | [diff] [blame] | 603 | /* prepare setjmp context for exception handling */ |
Andreas Färber | 6f03bef | 2013-08-26 06:22:03 +0200 | [diff] [blame] | 604 | if (sigsetjmp(cpu->jmp_env, 0) == 0) { |
Sergey Fedorov | ca7d8e1 | 2016-07-15 22:31:23 +0300 | [diff] [blame] | 605 | TranslationBlock *tb, *last_tb = NULL; |
| 606 | int tb_exit = 0; |
| 607 | |
bellard | 3fb2ded | 2003-06-24 13:22:59 +0000 | [diff] [blame] | 608 | /* if an exception is pending, we execute it here */ |
Sergey Fedorov | ea28476 | 2016-05-11 13:21:48 +0300 | [diff] [blame] | 609 | if (cpu_handle_exception(cpu, &ret)) { |
Pavel Dovgalyuk | 6f06096 | 2015-09-17 19:24:16 +0300 | [diff] [blame] | 610 | break; |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 611 | } |
bellard | 9df217a | 2005-02-10 22:05:51 +0000 | [diff] [blame] | 612 | |
Sergey Fedorov | 118b073 | 2016-07-15 20:58:44 +0300 | [diff] [blame] | 613 | atomic_mb_set(&cpu->tb_flushed, false); /* reset before first TB lookup */ |
bellard | 3fb2ded | 2003-06-24 13:22:59 +0000 | [diff] [blame] | 614 | for(;;) { |
Sergey Fedorov | c385e6e | 2016-05-11 13:21:49 +0300 | [diff] [blame] | 615 | cpu_handle_interrupt(cpu, &last_tb); |
Sergey Fedorov | 4b7e695 | 2016-07-15 20:58:42 +0300 | [diff] [blame] | 616 | tb = tb_find_fast(cpu, last_tb, tb_exit); |
Sergey Fedorov | 928de9e | 2016-05-11 13:21:50 +0300 | [diff] [blame] | 617 | cpu_loop_exec_tb(cpu, tb, &last_tb, &tb_exit, &sc); |
Sebastian Tanase | c2aa5f8 | 2014-07-25 11:56:31 +0200 | [diff] [blame] | 618 | /* Try to align the host and virtual clocks |
| 619 | if the guest is in advance */ |
| 620 | align_clocks(&sc, cpu); |
ths | 50a518e | 2007-06-03 18:52:15 +0000 | [diff] [blame] | 621 | } /* for(;;) */ |
Jan Kiszka | 0d10193 | 2011-07-02 09:50:51 +0200 | [diff] [blame] | 622 | } else { |
Stefan Weil | 0448f5f | 2015-09-26 13:23:26 +0200 | [diff] [blame] | 623 | #if defined(__clang__) || !QEMU_GNUC_PREREQ(4, 6) |
| 624 | /* Some compilers wrongly smash all local variables after |
| 625 | * siglongjmp. There were bug reports for gcc 4.5.0 and clang. |
| 626 | * Reload essential local variables here for those compilers. |
| 627 | * Newer versions of gcc would complain about this code (-Wclobbered). */ |
Andreas Färber | 4917cf4 | 2013-05-27 05:17:50 +0200 | [diff] [blame] | 628 | cpu = current_cpu; |
Juergen Lock | 6c78f29 | 2013-10-03 16:09:37 +0200 | [diff] [blame] | 629 | cc = CPU_GET_CLASS(cpu); |
Stefan Weil | 0448f5f | 2015-09-26 13:23:26 +0200 | [diff] [blame] | 630 | #else /* buggy compiler */ |
| 631 | /* Assert that the compiler does not smash local variables. */ |
| 632 | g_assert(cpu == current_cpu); |
| 633 | g_assert(cc == CPU_GET_CLASS(cpu)); |
Stefan Weil | 0448f5f | 2015-09-26 13:23:26 +0200 | [diff] [blame] | 634 | #endif /* buggy compiler */ |
| 635 | cpu->can_do_io = 1; |
KONRAD Frederic | 677ef62 | 2015-08-10 17:27:02 +0200 | [diff] [blame] | 636 | tb_lock_reset(); |
bellard | 7d13299 | 2003-03-06 23:23:54 +0000 | [diff] [blame] | 637 | } |
bellard | 3fb2ded | 2003-06-24 13:22:59 +0000 | [diff] [blame] | 638 | } /* for(;;) */ |
| 639 | |
Richard Henderson | cffe7b3 | 2014-09-13 09:45:12 -0700 | [diff] [blame] | 640 | cc->cpu_exec_exit(cpu); |
Paolo Bonzini | 79e2b9a | 2015-01-21 12:09:14 +0100 | [diff] [blame] | 641 | rcu_read_unlock(); |
pbrook | 1057eaa | 2007-02-04 13:37:44 +0000 | [diff] [blame] | 642 | |
Andreas Färber | 4917cf4 | 2013-05-27 05:17:50 +0200 | [diff] [blame] | 643 | /* fail safe : never use current_cpu outside cpu_exec() */ |
| 644 | current_cpu = NULL; |
Paolo Bonzini | 9373e63 | 2015-08-18 06:24:34 -0700 | [diff] [blame] | 645 | |
| 646 | /* Does not need atomic_mb_set because a spurious wakeup is okay. */ |
| 647 | atomic_set(&tcg_current_cpu, NULL); |
bellard | 7d13299 | 2003-03-06 23:23:54 +0000 | [diff] [blame] | 648 | return ret; |
| 649 | } |