Series comparison

-[PULL 0/3] tcg patch queue
+[PATCH v3 00/28] tcg patch queue
-The following changes since commit 2ecfc0657afa5d29a373271b342f704a1a3c6737:
+v3: One more try to fix macos issues.
-  Merge remote-tracking branch 'remotes/armbru/tags/pull-misc-2020-12-10' into staging (2020-12-10 17:01:05 +0000)
 r~
 The following changes since commit e0209297cddd5e10a07e15fac5cca7aa1a8e0e59:
   Merge tag 'pull-ufs-20250217' of https://gitlab.com/jeuk20.kim/qemu into staging (2025-02-18 10:58:48 +0800)
 are available in the Git repository at:
-  https://gitlab.com/rth7680/qemu.git tags/pull-tcg-20201210
+  https://gitlab.com/rth7680/qemu.git tags/pull-tcg-20250215-3
-for you to fetch changes up to 9e2658d62ebc23efe7df43fc0e306f129510d874:
+for you to fetch changes up to e726f65867087d86436de05e9f372a86ec1381a6:
-  accel/tcg: rename tcg-cpus functions to match module name (2020-12-10 17:44:10 -0600)
+  tcg: Remove TCG_TARGET_HAS_{br,set}cond2 from riscv and loongarch64 (2025-02-18 08:29:03 -0800)
 ----------------------------------------------------------------
-Split CpusAccel for tcg variants
+tcg: Remove last traces of TCG_TARGET_NEED_POOL_LABELS
 tcg: Cleanups after disallowing 64-on-32
 tcg: Introduce constraint for zero register
 tcg: Remove TCG_TARGET_HAS_{br,set}cond2 from riscv and loongarch64
 tcg/i386: Use tcg_{high,unsigned}_cond in tcg_out_brcond2
 linux-user: Move TARGET_SA_RESTORER out of generic/signal.h
 linux-user: Fix alignment when unmapping excess reservation
 target/sparc: Fix register selection for all F*TOx and FxTO* instructions
 target/sparc: Fix gdbstub incorrectly handling registers f32-f62
 target/sparc: fake UltraSPARC T1 PCR and PIC registers
 ----------------------------------------------------------------
-Claudio Fontana (3):
+Andreas Schwab (1):
-      accel/tcg: split CpusAccel into three TCG variants
+      linux-user: Move TARGET_SA_RESTORER out of generic/signal.h
       accel/tcg: split tcg_start_vcpu_thread
       accel/tcg: rename tcg-cpus functions to match module name
- accel/tcg/tcg-cpus-icount.h |  17 ++
+Artyom Tarasenko (1):
- accel/tcg/tcg-cpus-rr.h     |  21 ++
+      target/sparc: fake UltraSPARC T1 PCR and PIC registers
  accel/tcg/tcg-cpus.h        |  12 +-
  accel/tcg/tcg-all.c         |  13 +-
  accel/tcg/tcg-cpus-icount.c | 147 +++++++++++++
  accel/tcg/tcg-cpus-mttcg.c  | 140 ++++++++++++
  accel/tcg/tcg-cpus-rr.c     | 305 ++++++++++++++++++++++++++
  accel/tcg/tcg-cpus.c        | 506 +-------------------------------------------
  softmmu/icount.c            |   2 +-
  accel/tcg/meson.build       |   9 +-
 files changed, 670 insertions(+), 502 deletions(-)
  create mode 100644 accel/tcg/tcg-cpus-icount.h
  create mode 100644 accel/tcg/tcg-cpus-rr.h
  create mode 100644 accel/tcg/tcg-cpus-icount.c
  create mode 100644 accel/tcg/tcg-cpus-mttcg.c
  create mode 100644 accel/tcg/tcg-cpus-rr.c
+Fabiano Rosas (1):
+      elfload: Fix alignment when unmapping excess reservation
+Mikael Szreder (2):
+      target/sparc: Fix register selection for all F*TOx and FxTO* instructions
+      target/sparc: Fix gdbstub incorrectly handling registers f32-f62
+Richard Henderson (23):
+      tcg: Remove last traces of TCG_TARGET_NEED_POOL_LABELS
+      tcg: Remove TCG_OVERSIZED_GUEST
+      tcg: Drop support for two address registers in gen_ldst
+      tcg: Merge INDEX_op_qemu_*_{a32,a64}_*
+      tcg/arm: Drop addrhi from prepare_host_addr
+      tcg/i386: Drop addrhi from prepare_host_addr
+      tcg/mips: Drop addrhi from prepare_host_addr
+      tcg/ppc: Drop addrhi from prepare_host_addr
+      tcg: Replace addr{lo,hi}_reg with addr_reg in TCGLabelQemuLdst
+      plugins: Fix qemu_plugin_read_memory_vaddr parameters
+      accel/tcg: Fix tlb_set_page_with_attrs, tlb_set_page
+      target/loongarch: Use VADDR_PRIx for logging pc_next
+      target/mips: Use VADDR_PRIx for logging pc_next
+      include/exec: Change vaddr to uintptr_t
+      include/exec: Use uintptr_t in CPUTLBEntry
+      tcg: Introduce the 'z' constraint for a hardware zero register
+      tcg/aarch64: Use 'z' constraint
+      tcg/loongarch64: Use 'z' constraint
+      tcg/mips: Use 'z' constraint
+      tcg/riscv: Use 'z' constraint
+      tcg/sparc64: Use 'z' constraint
+      tcg/i386: Use tcg_{high,unsigned}_cond in tcg_out_brcond2
+      tcg: Remove TCG_TARGET_HAS_{br,set}cond2 from riscv and loongarch64
+ include/exec/tlb-common.h                          |  10 +-
+ include/exec/vaddr.h                               |  16 +-
+ include/qemu/atomic.h                              |  18 +-
+ include/tcg/oversized-guest.h                      |  23 ---
+ include/tcg/tcg-opc.h                              |  28 +--
+ include/tcg/tcg.h                                  |   3 +-
+ linux-user/aarch64/target_signal.h                 |   2 +
+ linux-user/arm/target_signal.h                     |   2 +
+ linux-user/generic/signal.h                        |   1 -
+ linux-user/i386/target_signal.h                    |   2 +
+ linux-user/m68k/target_signal.h                    |   1 +
+ linux-user/microblaze/target_signal.h              |   2 +
+ linux-user/ppc/target_signal.h                     |   2 +
+ linux-user/s390x/target_signal.h                   |   2 +
+ linux-user/sh4/target_signal.h                     |   2 +
+ linux-user/x86_64/target_signal.h                  |   2 +
+ linux-user/xtensa/target_signal.h                  |   2 +
+ tcg/aarch64/tcg-target-con-set.h                   |  12 +-
+ tcg/aarch64/tcg-target.h                           |   2 +
+ tcg/loongarch64/tcg-target-con-set.h               |  15 +-
+ tcg/loongarch64/tcg-target-con-str.h               |   1 -
+ tcg/loongarch64/tcg-target-has.h                   |   2 -
+ tcg/loongarch64/tcg-target.h                       |   2 +
+ tcg/mips/tcg-target-con-set.h                      |  26 +--
+ tcg/mips/tcg-target-con-str.h                      |   1 -
+ tcg/mips/tcg-target.h                              |   2 +
+ tcg/riscv/tcg-target-con-set.h                     |  10 +-
+ tcg/riscv/tcg-target-con-str.h                     |   1 -
+ tcg/riscv/tcg-target-has.h                         |   2 -
+ tcg/riscv/tcg-target.h                             |   2 +
+ tcg/sparc64/tcg-target-con-set.h                   |  12 +-
+ tcg/sparc64/tcg-target-con-str.h                   |   1 -
+ tcg/sparc64/tcg-target.h                           |   3 +-
+ tcg/tci/tcg-target.h                               |   1 -
+ accel/tcg/cputlb.c                                 |  32 +---
+ accel/tcg/tcg-all.c                                |   9 +-
+ linux-user/elfload.c                               |   4 +-
+ plugins/api.c                                      |   2 +-
+ target/arm/ptw.c                                   |  34 ----
+ target/loongarch/tcg/translate.c                   |   2 +-
+ target/mips/tcg/octeon_translate.c                 |   4 +-
+ target/riscv/cpu_helper.c                          |  13 +-
+ target/sparc/gdbstub.c                             |  18 +-
+ target/sparc/translate.c                           |  19 +++
+ tcg/optimize.c                                     |  21 +--
+ tcg/tcg-op-ldst.c                                  | 103 +++--------
+ tcg/tcg.c                                          |  97 +++++------
+ tcg/tci.c                                          | 119 +++----------
+ docs/devel/multi-thread-tcg.rst                    |   1 -
+ docs/devel/tcg-ops.rst                             |   4 +-
+ target/loongarch/tcg/insn_trans/trans_atomic.c.inc |   2 +-
+ target/sparc/insns.decode                          |  19 ++-
+ tcg/aarch64/tcg-target.c.inc                       |  86 ++++------
+ tcg/arm/tcg-target.c.inc                           | 114 ++++---------
+ tcg/i386/tcg-target.c.inc                          | 190 +++++----------------
+ tcg/loongarch64/tcg-target.c.inc                   |  72 +++-----
+ tcg/mips/tcg-target.c.inc                          | 169 ++++++------------
+ tcg/ppc/tcg-target.c.inc                           | 164 +++++-------------
+ tcg/riscv/tcg-target.c.inc                         |  56 +++---
+ tcg/s390x/tcg-target.c.inc                         |  40 ++---
+ tcg/sparc64/tcg-target.c.inc                       |  45 ++---
+ tcg/tci/tcg-target.c.inc                           |  60 ++-----
+files changed, 550 insertions(+), 1162 deletions(-)
+ delete mode 100644 include/tcg/oversized-guest.h

-[PULL 1/3] accel/tcg: split CpusAccel into three TCG variants
+Deleted patch
-From: Claudio Fontana <cfontana@suse.de>
-split up the CpusAccel tcg_cpus into three TCG variants:
-tcg_cpus_rr (single threaded, round robin cpus)
-tcg_cpus_icount (same as rr, but with instruction counting enabled)
-tcg_cpus_mttcg (multi-threaded cpus)
-Suggested-by: Richard Henderson <richard.henderson@linaro.org>
-Signed-off-by: Claudio Fontana <cfontana@suse.de>
-Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
-Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
-Message-Id: <20201015143217.29337-2-cfontana@suse.de>
-Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
----
- accel/tcg/tcg-cpus-icount.h |  17 ++
- accel/tcg/tcg-cpus-mttcg.h  |  21 ++
- accel/tcg/tcg-cpus-rr.h     |  20 ++
- accel/tcg/tcg-cpus.h        |  13 +-
- accel/tcg/tcg-all.c         |   8 +-
- accel/tcg/tcg-cpus-icount.c | 147 +++++++++++
- accel/tcg/tcg-cpus-mttcg.c  | 117 +++++++++
- accel/tcg/tcg-cpus-rr.c     | 270 ++++++++++++++++++++
- accel/tcg/tcg-cpus.c        | 484 ++----------------------------------
- softmmu/icount.c            |   2 +-
- accel/tcg/meson.build       |   9 +-
-files changed, 646 insertions(+), 462 deletions(-)
- create mode 100644 accel/tcg/tcg-cpus-icount.h
- create mode 100644 accel/tcg/tcg-cpus-mttcg.h
- create mode 100644 accel/tcg/tcg-cpus-rr.h
- create mode 100644 accel/tcg/tcg-cpus-icount.c
- create mode 100644 accel/tcg/tcg-cpus-mttcg.c
- create mode 100644 accel/tcg/tcg-cpus-rr.c
-diff --git a/accel/tcg/tcg-cpus-icount.h b/accel/tcg/tcg-cpus-icount.h
-new file mode 100644
-index XXXXXXX..XXXXXXX
---- /dev/null
-+++ b/accel/tcg/tcg-cpus-icount.h
-@@ -XXX,XX +XXX,XX @@
-+/*
-+ * QEMU TCG Single Threaded vCPUs implementation using instruction counting
-+ *
-+ * Copyright 2020 SUSE LLC
-+ *
-+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
-+ * See the COPYING file in the top-level directory.
-+ */
-+
-+#ifndef TCG_CPUS_ICOUNT_H
-+#define TCG_CPUS_ICOUNT_H
-+
-+void handle_icount_deadline(void);
-+void prepare_icount_for_run(CPUState *cpu);
-+void process_icount_data(CPUState *cpu);
-+
-+#endif /* TCG_CPUS_ICOUNT_H */
-diff --git a/accel/tcg/tcg-cpus-mttcg.h b/accel/tcg/tcg-cpus-mttcg.h
-new file mode 100644
-index XXXXXXX..XXXXXXX
---- /dev/null
-+++ b/accel/tcg/tcg-cpus-mttcg.h
-@@ -XXX,XX +XXX,XX @@
-+/*
-+ * QEMU TCG Multi Threaded vCPUs implementation
-+ *
-+ * Copyright 2020 SUSE LLC
-+ *
-+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
-+ * See the COPYING file in the top-level directory.
-+ */
-+
-+#ifndef TCG_CPUS_MTTCG_H
-+#define TCG_CPUS_MTTCG_H
-+
-+/*
-+ * In the multi-threaded case each vCPU has its own thread. The TLS
-+ * variable current_cpu can be used deep in the code to find the
-+ * current CPUState for a given thread.
-+ */
-+
-+void *tcg_cpu_thread_fn(void *arg);
-+
-+#endif /* TCG_CPUS_MTTCG_H */
-diff --git a/accel/tcg/tcg-cpus-rr.h b/accel/tcg/tcg-cpus-rr.h
-new file mode 100644
-index XXXXXXX..XXXXXXX
---- /dev/null
-+++ b/accel/tcg/tcg-cpus-rr.h
-@@ -XXX,XX +XXX,XX @@
-+/*
-+ * QEMU TCG Single Threaded vCPUs implementation
-+ *
-+ * Copyright 2020 SUSE LLC
-+ *
-+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
-+ * See the COPYING file in the top-level directory.
-+ */
-+
-+#ifndef TCG_CPUS_RR_H
-+#define TCG_CPUS_RR_H
-+
-+#define TCG_KICK_PERIOD (NANOSECONDS_PER_SECOND / 10)
-+
-+/* Kick all RR vCPUs. */
-+void qemu_cpu_kick_rr_cpus(CPUState *unused);
-+
-+void *tcg_rr_cpu_thread_fn(void *arg);
-+
-+#endif /* TCG_CPUS_RR_H */
-diff --git a/accel/tcg/tcg-cpus.h b/accel/tcg/tcg-cpus.h
-index XXXXXXX..XXXXXXX 100644
---- a/accel/tcg/tcg-cpus.h
-+++ b/accel/tcg/tcg-cpus.h
-@@ -XXX,XX +XXX,XX @@
- /*
-- * Accelerator CPUS Interface
-+ * QEMU TCG vCPU common functionality
-+ *
-+ * Functionality common to all TCG vcpu variants: mttcg, rr and icount.
-  *
-  * Copyright 2020 SUSE LLC
-  *
-@@ -XXX,XX +XXX,XX @@
- #include "sysemu/cpus.h"
--extern const CpusAccel tcg_cpus;
-+extern const CpusAccel tcg_cpus_mttcg;
-+extern const CpusAccel tcg_cpus_icount;
-+extern const CpusAccel tcg_cpus_rr;
-+
-+void tcg_start_vcpu_thread(CPUState *cpu);
-+void qemu_tcg_destroy_vcpu(CPUState *cpu);
-+int tcg_cpu_exec(CPUState *cpu);
-+void tcg_handle_interrupt(CPUState *cpu, int mask);
- #endif /* TCG_CPUS_H */
-diff --git a/accel/tcg/tcg-all.c b/accel/tcg/tcg-all.c
-index XXXXXXX..XXXXXXX 100644
---- a/accel/tcg/tcg-all.c
-+++ b/accel/tcg/tcg-all.c
-@@ -XXX,XX +XXX,XX @@ static int tcg_init(MachineState *ms)
-     tcg_exec_init(s->tb_size * 1024 * 1024);
-     mttcg_enabled = s->mttcg_enabled;
--    cpus_register_accel(&tcg_cpus);
-+    if (mttcg_enabled) {
-+        cpus_register_accel(&tcg_cpus_mttcg);
-+    } else if (icount_enabled()) {
-+        cpus_register_accel(&tcg_cpus_icount);
-+    } else {
-+        cpus_register_accel(&tcg_cpus_rr);
-+    }
-     return 0;
- }
-diff --git a/accel/tcg/tcg-cpus-icount.c b/accel/tcg/tcg-cpus-icount.c
-new file mode 100644
-index XXXXXXX..XXXXXXX
---- /dev/null
-+++ b/accel/tcg/tcg-cpus-icount.c
-@@ -XXX,XX +XXX,XX @@
-+/*
-+ * QEMU TCG Single Threaded vCPUs implementation using instruction counting
-+ *
-+ * Copyright (c) 2003-2008 Fabrice Bellard
-+ * Copyright (c) 2014 Red Hat Inc.
-+ *
-+ * Permission is hereby granted, free of charge, to any person obtaining a copy
-+ * of this software and associated documentation files (the "Software"), to deal
-+ * in the Software without restriction, including without limitation the rights
-+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-+ * copies of the Software, and to permit persons to whom the Software is
-+ * furnished to do so, subject to the following conditions:
-+ *
-+ * The above copyright notice and this permission notice shall be included in
-+ * all copies or substantial portions of the Software.
-+ *
-+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-+ * THE SOFTWARE.
-+ */
-+
-+#include "qemu/osdep.h"
-+#include "qemu-common.h"
-+#include "sysemu/tcg.h"
-+#include "sysemu/replay.h"
-+#include "qemu/main-loop.h"
-+#include "qemu/guest-random.h"
-+#include "exec/exec-all.h"
-+#include "hw/boards.h"
-+
-+#include "tcg-cpus.h"
-+#include "tcg-cpus-icount.h"
-+#include "tcg-cpus-rr.h"
-+
-+static int64_t tcg_get_icount_limit(void)
-+{
-+    int64_t deadline;
-+
-+    if (replay_mode != REPLAY_MODE_PLAY) {
-+        /*
-+         * Include all the timers, because they may need an attention.
-+         * Too long CPU execution may create unnecessary delay in UI.
-+         */
-+        deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL,
-+                                              QEMU_TIMER_ATTR_ALL);
-+        /* Check realtime timers, because they help with input processing */
-+        deadline = qemu_soonest_timeout(deadline,
-+                qemu_clock_deadline_ns_all(QEMU_CLOCK_REALTIME,
-+                                           QEMU_TIMER_ATTR_ALL));
-+
-+        /*
-+         * Maintain prior (possibly buggy) behaviour where if no deadline
-+         * was set (as there is no QEMU_CLOCK_VIRTUAL timer) or it is more than
-+         * INT32_MAX nanoseconds ahead, we still use INT32_MAX
-+         * nanoseconds.
-+         */
-+        if ((deadline < 0) || (deadline > INT32_MAX)) {
-+            deadline = INT32_MAX;
-+        }
-+
-+        return icount_round(deadline);
-+    } else {
-+        return replay_get_instructions();
-+    }
-+}
-+
-+static void notify_aio_contexts(void)
-+{
-+    /* Wake up other AioContexts.  */
-+    qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
-+    qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
-+}
-+
-+void handle_icount_deadline(void)
-+{
-+    assert(qemu_in_vcpu_thread());
-+    int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL,
-+                                                  QEMU_TIMER_ATTR_ALL);
-+
-+    if (deadline == 0) {
-+        notify_aio_contexts();
-+    }
-+}
-+
-+void prepare_icount_for_run(CPUState *cpu)
-+{
-+    int insns_left;
-+
-+    /*
-+     * These should always be cleared by process_icount_data after
-+     * each vCPU execution. However u16.high can be raised
-+     * asynchronously by cpu_exit/cpu_interrupt/tcg_handle_interrupt
-+     */
-+    g_assert(cpu_neg(cpu)->icount_decr.u16.low == 0);
-+    g_assert(cpu->icount_extra == 0);
-+
-+    cpu->icount_budget = tcg_get_icount_limit();
-+    insns_left = MIN(0xffff, cpu->icount_budget);
-+    cpu_neg(cpu)->icount_decr.u16.low = insns_left;
-+    cpu->icount_extra = cpu->icount_budget - insns_left;
-+
-+    replay_mutex_lock();
-+
-+    if (cpu->icount_budget == 0 && replay_has_checkpoint()) {
-+        notify_aio_contexts();
-+    }
-+}
-+
-+void process_icount_data(CPUState *cpu)
-+{
-+    /* Account for executed instructions */
-+    icount_update(cpu);
-+
-+    /* Reset the counters */
-+    cpu_neg(cpu)->icount_decr.u16.low = 0;
-+    cpu->icount_extra = 0;
-+    cpu->icount_budget = 0;
-+
-+    replay_account_executed_instructions();
-+
-+    replay_mutex_unlock();
-+}
-+
-+static void icount_handle_interrupt(CPUState *cpu, int mask)
-+{
-+    int old_mask = cpu->interrupt_request;
-+
-+    tcg_handle_interrupt(cpu, mask);
-+    if (qemu_cpu_is_self(cpu) &&
-+        !cpu->can_do_io
-+        && (mask & ~old_mask) != 0) {
-+        cpu_abort(cpu, "Raised interrupt while not in I/O function");
-+    }
-+}
-+
-+const CpusAccel tcg_cpus_icount = {
-+    .create_vcpu_thread = tcg_start_vcpu_thread,
-+    .kick_vcpu_thread = qemu_cpu_kick_rr_cpus,
-+
-+    .handle_interrupt = icount_handle_interrupt,
-+    .get_virtual_clock = icount_get,
-+    .get_elapsed_ticks = icount_get,
-+};
-diff --git a/accel/tcg/tcg-cpus-mttcg.c b/accel/tcg/tcg-cpus-mttcg.c
-new file mode 100644
-index XXXXXXX..XXXXXXX
---- /dev/null
-+++ b/accel/tcg/tcg-cpus-mttcg.c
-@@ -XXX,XX +XXX,XX @@
-+/*
-+ * QEMU TCG Multi Threaded vCPUs implementation
-+ *
-+ * Copyright (c) 2003-2008 Fabrice Bellard
-+ * Copyright (c) 2014 Red Hat Inc.
-+ *
-+ * Permission is hereby granted, free of charge, to any person obtaining a copy
-+ * of this software and associated documentation files (the "Software"), to deal
-+ * in the Software without restriction, including without limitation the rights
-+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-+ * copies of the Software, and to permit persons to whom the Software is
-+ * furnished to do so, subject to the following conditions:
-+ *
-+ * The above copyright notice and this permission notice shall be included in
-+ * all copies or substantial portions of the Software.
-+ *
-+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-+ * THE SOFTWARE.
-+ */
-+
-+#include "qemu/osdep.h"
-+#include "qemu-common.h"
-+#include "sysemu/tcg.h"
-+#include "sysemu/replay.h"
-+#include "qemu/main-loop.h"
-+#include "qemu/guest-random.h"
-+#include "exec/exec-all.h"
-+#include "hw/boards.h"
-+
-+#include "tcg-cpus.h"
-+#include "tcg-cpus-mttcg.h"
-+
-+/*
-+ * In the multi-threaded case each vCPU has its own thread. The TLS
-+ * variable current_cpu can be used deep in the code to find the
-+ * current CPUState for a given thread.
-+ */
-+
-+void *tcg_cpu_thread_fn(void *arg)
-+{
-+    CPUState *cpu = arg;
-+
-+    assert(tcg_enabled());
-+    g_assert(!icount_enabled());
-+
-+    rcu_register_thread();
-+    tcg_register_thread();
-+
-+    qemu_mutex_lock_iothread();
-+    qemu_thread_get_self(cpu->thread);
-+
-+    cpu->thread_id = qemu_get_thread_id();
-+    cpu->can_do_io = 1;
-+    current_cpu = cpu;
-+    cpu_thread_signal_created(cpu);
-+    qemu_guest_random_seed_thread_part2(cpu->random_seed);
-+
-+    /* process any pending work */
-+    cpu->exit_request = 1;
-+
-+    do {
-+        if (cpu_can_run(cpu)) {
-+            int r;
-+            qemu_mutex_unlock_iothread();
-+            r = tcg_cpu_exec(cpu);
-+            qemu_mutex_lock_iothread();
-+            switch (r) {
-+            case EXCP_DEBUG:
-+                cpu_handle_guest_debug(cpu);
-+                break;
-+            case EXCP_HALTED:
-+                /*
-+                 * during start-up the vCPU is reset and the thread is
-+                 * kicked several times. If we don't ensure we go back
-+                 * to sleep in the halted state we won't cleanly
-+                 * start-up when the vCPU is enabled.
-+                 *
-+                 * cpu->halted should ensure we sleep in wait_io_event
-+                 */
-+                g_assert(cpu->halted);
-+                break;
-+            case EXCP_ATOMIC:
-+                qemu_mutex_unlock_iothread();
-+                cpu_exec_step_atomic(cpu);
-+                qemu_mutex_lock_iothread();
-+            default:
-+                /* Ignore everything else? */
-+                break;
-+            }
-+        }
-+
-+        qatomic_mb_set(&cpu->exit_request, 0);
-+        qemu_wait_io_event(cpu);
-+    } while (!cpu->unplug || cpu_can_run(cpu));
-+
-+    qemu_tcg_destroy_vcpu(cpu);
-+    qemu_mutex_unlock_iothread();
-+    rcu_unregister_thread();
-+    return NULL;
-+}
-+
-+static void mttcg_kick_vcpu_thread(CPUState *cpu)
-+{
-+    cpu_exit(cpu);
-+}
-+
-+const CpusAccel tcg_cpus_mttcg = {
-+    .create_vcpu_thread = tcg_start_vcpu_thread,
-+    .kick_vcpu_thread = mttcg_kick_vcpu_thread,
-+
-+    .handle_interrupt = tcg_handle_interrupt,
-+};
-diff --git a/accel/tcg/tcg-cpus-rr.c b/accel/tcg/tcg-cpus-rr.c
-new file mode 100644
-index XXXXXXX..XXXXXXX
---- /dev/null
-+++ b/accel/tcg/tcg-cpus-rr.c
-@@ -XXX,XX +XXX,XX @@
-+/*
-+ * QEMU TCG Single Threaded vCPUs implementation
-+ *
-+ * Copyright (c) 2003-2008 Fabrice Bellard
-+ * Copyright (c) 2014 Red Hat Inc.
-+ *
-+ * Permission is hereby granted, free of charge, to any person obtaining a copy
-+ * of this software and associated documentation files (the "Software"), to deal
-+ * in the Software without restriction, including without limitation the rights
-+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-+ * copies of the Software, and to permit persons to whom the Software is
-+ * furnished to do so, subject to the following conditions:
-+ *
-+ * The above copyright notice and this permission notice shall be included in
-+ * all copies or substantial portions of the Software.
-+ *
-+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-+ * THE SOFTWARE.
-+ */
-+
-+#include "qemu/osdep.h"
-+#include "qemu-common.h"
-+#include "sysemu/tcg.h"
-+#include "sysemu/replay.h"
-+#include "qemu/main-loop.h"
-+#include "qemu/guest-random.h"
-+#include "exec/exec-all.h"
-+#include "hw/boards.h"
-+
-+#include "tcg-cpus.h"
-+#include "tcg-cpus-rr.h"
-+#include "tcg-cpus-icount.h"
-+
-+/* Kick all RR vCPUs */
-+void qemu_cpu_kick_rr_cpus(CPUState *unused)
-+{
-+    CPUState *cpu;
-+
-+    CPU_FOREACH(cpu) {
-+        cpu_exit(cpu);
-+    };
-+}
-+
-+/*
-+ * TCG vCPU kick timer
-+ *
-+ * The kick timer is responsible for moving single threaded vCPU
-+ * emulation on to the next vCPU. If more than one vCPU is running a
-+ * timer event with force a cpu->exit so the next vCPU can get
-+ * scheduled.
-+ *
-+ * The timer is removed if all vCPUs are idle and restarted again once
-+ * idleness is complete.
-+ */
-+
-+static QEMUTimer *tcg_kick_vcpu_timer;
-+static CPUState *tcg_current_rr_cpu;
-+
-+#define TCG_KICK_PERIOD (NANOSECONDS_PER_SECOND / 10)
-+
-+static inline int64_t qemu_tcg_next_kick(void)
-+{
-+    return qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + TCG_KICK_PERIOD;
-+}
-+
-+/* Kick the currently round-robin scheduled vCPU to next */
-+static void qemu_cpu_kick_rr_next_cpu(void)
-+{
-+    CPUState *cpu;
-+    do {
-+        cpu = qatomic_mb_read(&tcg_current_rr_cpu);
-+        if (cpu) {
-+            cpu_exit(cpu);
-+        }
-+    } while (cpu != qatomic_mb_read(&tcg_current_rr_cpu));
-+}
-+
-+static void kick_tcg_thread(void *opaque)
-+{
-+    timer_mod(tcg_kick_vcpu_timer, qemu_tcg_next_kick());
-+    qemu_cpu_kick_rr_next_cpu();
-+}
-+
-+static void start_tcg_kick_timer(void)
-+{
-+    if (!tcg_kick_vcpu_timer && CPU_NEXT(first_cpu)) {
-+        tcg_kick_vcpu_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
-+                                           kick_tcg_thread, NULL);
-+    }
-+    if (tcg_kick_vcpu_timer && !timer_pending(tcg_kick_vcpu_timer)) {
-+        timer_mod(tcg_kick_vcpu_timer, qemu_tcg_next_kick());
-+    }
-+}
-+
-+static void stop_tcg_kick_timer(void)
-+{
-+    if (tcg_kick_vcpu_timer && timer_pending(tcg_kick_vcpu_timer)) {
-+        timer_del(tcg_kick_vcpu_timer);
-+    }
-+}
-+
-+static void qemu_tcg_rr_wait_io_event(void)
-+{
-+    CPUState *cpu;
-+
-+    while (all_cpu_threads_idle()) {
-+        stop_tcg_kick_timer();
-+        qemu_cond_wait_iothread(first_cpu->halt_cond);
-+    }
-+
-+    start_tcg_kick_timer();
-+
-+    CPU_FOREACH(cpu) {
-+        qemu_wait_io_event_common(cpu);
-+    }
-+}
-+
-+/*
-+ * Destroy any remaining vCPUs which have been unplugged and have
-+ * finished running
-+ */
-+static void deal_with_unplugged_cpus(void)
-+{
-+    CPUState *cpu;
-+
-+    CPU_FOREACH(cpu) {
-+        if (cpu->unplug && !cpu_can_run(cpu)) {
-+            qemu_tcg_destroy_vcpu(cpu);
-+            break;
-+        }
-+    }
-+}
-+
-+/*
-+ * In the single-threaded case each vCPU is simulated in turn. If
-+ * there is more than a single vCPU we create a simple timer to kick
-+ * the vCPU and ensure we don't get stuck in a tight loop in one vCPU.
-+ * This is done explicitly rather than relying on side-effects
-+ * elsewhere.
-+ */
-+
-+void *tcg_rr_cpu_thread_fn(void *arg)
-+{
-+    CPUState *cpu = arg;
-+
-+    assert(tcg_enabled());
-+    rcu_register_thread();
-+    tcg_register_thread();
-+
-+    qemu_mutex_lock_iothread();
-+    qemu_thread_get_self(cpu->thread);
-+
-+    cpu->thread_id = qemu_get_thread_id();
-+    cpu->can_do_io = 1;
-+    cpu_thread_signal_created(cpu);
-+    qemu_guest_random_seed_thread_part2(cpu->random_seed);
-+
-+    /* wait for initial kick-off after machine start */
-+    while (first_cpu->stopped) {
-+        qemu_cond_wait_iothread(first_cpu->halt_cond);
-+
-+        /* process any pending work */
-+        CPU_FOREACH(cpu) {
-+            current_cpu = cpu;
-+            qemu_wait_io_event_common(cpu);
-+        }
-+    }
-+
-+    start_tcg_kick_timer();
-+
-+    cpu = first_cpu;
-+
-+    /* process any pending work */
-+    cpu->exit_request = 1;
-+
-+    while (1) {
-+        qemu_mutex_unlock_iothread();
-+        replay_mutex_lock();
-+        qemu_mutex_lock_iothread();
-+
-+        if (icount_enabled()) {
-+            /* Account partial waits to QEMU_CLOCK_VIRTUAL.  */
-+            icount_account_warp_timer();
-+            /*
-+             * Run the timers here.  This is much more efficient than
-+             * waking up the I/O thread and waiting for completion.
-+             */
-+            handle_icount_deadline();
-+        }
-+
-+        replay_mutex_unlock();
-+
-+        if (!cpu) {
-+            cpu = first_cpu;
-+        }
-+
-+        while (cpu && cpu_work_list_empty(cpu) && !cpu->exit_request) {
-+
-+            qatomic_mb_set(&tcg_current_rr_cpu, cpu);
-+            current_cpu = cpu;
-+
-+            qemu_clock_enable(QEMU_CLOCK_VIRTUAL,
-+                              (cpu->singlestep_enabled & SSTEP_NOTIMER) == 0);
-+
-+            if (cpu_can_run(cpu)) {
-+                int r;
-+
-+                qemu_mutex_unlock_iothread();
-+                if (icount_enabled()) {
-+                    prepare_icount_for_run(cpu);
-+                }
-+                r = tcg_cpu_exec(cpu);
-+                if (icount_enabled()) {
-+                    process_icount_data(cpu);
-+                }
-+                qemu_mutex_lock_iothread();
-+
-+                if (r == EXCP_DEBUG) {
-+                    cpu_handle_guest_debug(cpu);
-+                    break;
-+                } else if (r == EXCP_ATOMIC) {
-+                    qemu_mutex_unlock_iothread();
-+                    cpu_exec_step_atomic(cpu);
-+                    qemu_mutex_lock_iothread();
-+                    break;
-+                }
-+            } else if (cpu->stop) {
-+                if (cpu->unplug) {
-+                    cpu = CPU_NEXT(cpu);
-+                }
-+                break;
-+            }
-+
-+            cpu = CPU_NEXT(cpu);
-+        } /* while (cpu && !cpu->exit_request).. */
-+
-+        /* Does not need qatomic_mb_set because a spurious wakeup is okay.  */
-+        qatomic_set(&tcg_current_rr_cpu, NULL);
-+
-+        if (cpu && cpu->exit_request) {
-+            qatomic_mb_set(&cpu->exit_request, 0);
-+        }
-+
-+        if (icount_enabled() && all_cpu_threads_idle()) {
-+            /*
-+             * When all cpus are sleeping (e.g in WFI), to avoid a deadlock
-+             * in the main_loop, wake it up in order to start the warp timer.
-+             */
-+            qemu_notify_event();
-+        }
-+
-+        qemu_tcg_rr_wait_io_event();
-+        deal_with_unplugged_cpus();
-+    }
-+
-+    rcu_unregister_thread();
-+    return NULL;
-+}
-+
-+const CpusAccel tcg_cpus_rr = {
-+    .create_vcpu_thread = tcg_start_vcpu_thread,
-+    .kick_vcpu_thread = qemu_cpu_kick_rr_cpus,
-+
-+    .handle_interrupt = tcg_handle_interrupt,
-+};
-diff --git a/accel/tcg/tcg-cpus.c b/accel/tcg/tcg-cpus.c
-index XXXXXXX..XXXXXXX 100644
---- a/accel/tcg/tcg-cpus.c
-+++ b/accel/tcg/tcg-cpus.c
-@@ -XXX,XX +XXX,XX @@
- /*
-- * QEMU System Emulator
-+ * QEMU TCG vCPU common functionality
-+ *
-+ * Functionality common to all TCG vCPU variants: mttcg, rr and icount.
-  *
-  * Copyright (c) 2003-2008 Fabrice Bellard
-  * Copyright (c) 2014 Red Hat Inc.
-@@ -XXX,XX +XXX,XX @@
- #include "hw/boards.h"
- #include "tcg-cpus.h"
-+#include "tcg-cpus-mttcg.h"
-+#include "tcg-cpus-rr.h"
--/* Kick all RR vCPUs */
--static void qemu_cpu_kick_rr_cpus(void)
--{
--    CPUState *cpu;
-+/* common functionality among all TCG variants */
--    CPU_FOREACH(cpu) {
--        cpu_exit(cpu);
--    };
--}
--
--static void tcg_kick_vcpu_thread(CPUState *cpu)
--{
--    if (qemu_tcg_mttcg_enabled()) {
--        cpu_exit(cpu);
--    } else {
--        qemu_cpu_kick_rr_cpus();
--    }
--}
--
--/*
-- * TCG vCPU kick timer
-- *
-- * The kick timer is responsible for moving single threaded vCPU
-- * emulation on to the next vCPU. If more than one vCPU is running a
-- * timer event with force a cpu->exit so the next vCPU can get
-- * scheduled.
-- *
-- * The timer is removed if all vCPUs are idle and restarted again once
-- * idleness is complete.
-- */
--
--static QEMUTimer *tcg_kick_vcpu_timer;
--static CPUState *tcg_current_rr_cpu;
--
--#define TCG_KICK_PERIOD (NANOSECONDS_PER_SECOND / 10)
--
--static inline int64_t qemu_tcg_next_kick(void)
--{
--    return qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + TCG_KICK_PERIOD;
--}
--
--/* Kick the currently round-robin scheduled vCPU to next */
--static void qemu_cpu_kick_rr_next_cpu(void)
--{
--    CPUState *cpu;
--    do {
--        cpu = qatomic_mb_read(&tcg_current_rr_cpu);
--        if (cpu) {
--            cpu_exit(cpu);
--        }
--    } while (cpu != qatomic_mb_read(&tcg_current_rr_cpu));
--}
--
--static void kick_tcg_thread(void *opaque)
--{
--    timer_mod(tcg_kick_vcpu_timer, qemu_tcg_next_kick());
--    qemu_cpu_kick_rr_next_cpu();
--}
--
--static void start_tcg_kick_timer(void)
--{
--    assert(!mttcg_enabled);
--    if (!tcg_kick_vcpu_timer && CPU_NEXT(first_cpu)) {
--        tcg_kick_vcpu_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
--                                           kick_tcg_thread, NULL);
--    }
--    if (tcg_kick_vcpu_timer && !timer_pending(tcg_kick_vcpu_timer)) {
--        timer_mod(tcg_kick_vcpu_timer, qemu_tcg_next_kick());
--    }
--}
--
--static void stop_tcg_kick_timer(void)
--{
--    assert(!mttcg_enabled);
--    if (tcg_kick_vcpu_timer && timer_pending(tcg_kick_vcpu_timer)) {
--        timer_del(tcg_kick_vcpu_timer);
--    }
--}
--
--static void qemu_tcg_destroy_vcpu(CPUState *cpu)
--{
--}
--
--static void qemu_tcg_rr_wait_io_event(void)
--{
--    CPUState *cpu;
--
--    while (all_cpu_threads_idle()) {
--        stop_tcg_kick_timer();
--        qemu_cond_wait_iothread(first_cpu->halt_cond);
--    }
--
--    start_tcg_kick_timer();
--
--    CPU_FOREACH(cpu) {
--        qemu_wait_io_event_common(cpu);
--    }
--}
--
--static int64_t tcg_get_icount_limit(void)
--{
--    int64_t deadline;
--
--    if (replay_mode != REPLAY_MODE_PLAY) {
--        /*
--         * Include all the timers, because they may need an attention.
--         * Too long CPU execution may create unnecessary delay in UI.
--         */
--        deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL,
--                                              QEMU_TIMER_ATTR_ALL);
--        /* Check realtime timers, because they help with input processing */
--        deadline = qemu_soonest_timeout(deadline,
--                qemu_clock_deadline_ns_all(QEMU_CLOCK_REALTIME,
--                                           QEMU_TIMER_ATTR_ALL));
--
--        /*
--         * Maintain prior (possibly buggy) behaviour where if no deadline
--         * was set (as there is no QEMU_CLOCK_VIRTUAL timer) or it is more than
--         * INT32_MAX nanoseconds ahead, we still use INT32_MAX
--         * nanoseconds.
--         */
--        if ((deadline < 0) || (deadline > INT32_MAX)) {
--            deadline = INT32_MAX;
--        }
--
--        return icount_round(deadline);
--    } else {
--        return replay_get_instructions();
--    }
--}
--
--static void notify_aio_contexts(void)
--{
--    /* Wake up other AioContexts.  */
--    qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
--    qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
--}
--
--static void handle_icount_deadline(void)
--{
--    assert(qemu_in_vcpu_thread());
--    if (icount_enabled()) {
--        int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL,
--                                                      QEMU_TIMER_ATTR_ALL);
--
--        if (deadline == 0) {
--            notify_aio_contexts();
--        }
--    }
--}
--
--static void prepare_icount_for_run(CPUState *cpu)
--{
--    if (icount_enabled()) {
--        int insns_left;
--
--        /*
--         * These should always be cleared by process_icount_data after
--         * each vCPU execution. However u16.high can be raised
--         * asynchronously by cpu_exit/cpu_interrupt/tcg_handle_interrupt
--         */
--        g_assert(cpu_neg(cpu)->icount_decr.u16.low == 0);
--        g_assert(cpu->icount_extra == 0);
--
--        cpu->icount_budget = tcg_get_icount_limit();
--        insns_left = MIN(0xffff, cpu->icount_budget);
--        cpu_neg(cpu)->icount_decr.u16.low = insns_left;
--        cpu->icount_extra = cpu->icount_budget - insns_left;
--
--        replay_mutex_lock();
--
--        if (cpu->icount_budget == 0 && replay_has_checkpoint()) {
--            notify_aio_contexts();
--        }
--    }
--}
--
--static void process_icount_data(CPUState *cpu)
--{
--    if (icount_enabled()) {
--        /* Account for executed instructions */
--        icount_update(cpu);
--
--        /* Reset the counters */
--        cpu_neg(cpu)->icount_decr.u16.low = 0;
--        cpu->icount_extra = 0;
--        cpu->icount_budget = 0;
--
--        replay_account_executed_instructions();
--
--        replay_mutex_unlock();
--    }
--}
--
--static int tcg_cpu_exec(CPUState *cpu)
--{
--    int ret;
--#ifdef CONFIG_PROFILER
--    int64_t ti;
--#endif
--
--    assert(tcg_enabled());
--#ifdef CONFIG_PROFILER
--    ti = profile_getclock();
--#endif
--    cpu_exec_start(cpu);
--    ret = cpu_exec(cpu);
--    cpu_exec_end(cpu);
--#ifdef CONFIG_PROFILER
--    qatomic_set(&tcg_ctx->prof.cpu_exec_time,
--                tcg_ctx->prof.cpu_exec_time + profile_getclock() - ti);
--#endif
--    return ret;
--}
--
--/*
-- * Destroy any remaining vCPUs which have been unplugged and have
-- * finished running
-- */
--static void deal_with_unplugged_cpus(void)
--{
--    CPUState *cpu;
--
--    CPU_FOREACH(cpu) {
--        if (cpu->unplug && !cpu_can_run(cpu)) {
--            qemu_tcg_destroy_vcpu(cpu);
--            cpu_thread_signal_destroyed(cpu);
--            break;
--        }
--    }
--}
--
--/*
-- * Single-threaded TCG
-- *
-- * In the single-threaded case each vCPU is simulated in turn. If
-- * there is more than a single vCPU we create a simple timer to kick
-- * the vCPU and ensure we don't get stuck in a tight loop in one vCPU.
-- * This is done explicitly rather than relying on side-effects
-- * elsewhere.
-- */
--
--static void *tcg_rr_cpu_thread_fn(void *arg)
--{
--    CPUState *cpu = arg;
--
--    assert(tcg_enabled());
--    rcu_register_thread();
--    tcg_register_thread();
--
--    qemu_mutex_lock_iothread();
--    qemu_thread_get_self(cpu->thread);
--
--    cpu->thread_id = qemu_get_thread_id();
--    cpu->can_do_io = 1;
--    cpu_thread_signal_created(cpu);
--    qemu_guest_random_seed_thread_part2(cpu->random_seed);
--
--    /* wait for initial kick-off after machine start */
--    while (first_cpu->stopped) {
--        qemu_cond_wait_iothread(first_cpu->halt_cond);
--
--        /* process any pending work */
--        CPU_FOREACH(cpu) {
--            current_cpu = cpu;
--            qemu_wait_io_event_common(cpu);
--        }
--    }
--
--    start_tcg_kick_timer();
--
--    cpu = first_cpu;
--
--    /* process any pending work */
--    cpu->exit_request = 1;
--
--    while (1) {
--        qemu_mutex_unlock_iothread();
--        replay_mutex_lock();
--        qemu_mutex_lock_iothread();
--        /* Account partial waits to QEMU_CLOCK_VIRTUAL.  */
--        icount_account_warp_timer();
--
--        /*
--         * Run the timers here.  This is much more efficient than
--         * waking up the I/O thread and waiting for completion.
--         */
--        handle_icount_deadline();
--
--        replay_mutex_unlock();
--
--        if (!cpu) {
--            cpu = first_cpu;
--        }
--
--        while (cpu && cpu_work_list_empty(cpu) && !cpu->exit_request) {
--
--            qatomic_mb_set(&tcg_current_rr_cpu, cpu);
--            current_cpu = cpu;
--
--            qemu_clock_enable(QEMU_CLOCK_VIRTUAL,
--                              (cpu->singlestep_enabled & SSTEP_NOTIMER) == 0);
--
--            if (cpu_can_run(cpu)) {
--                int r;
--
--                qemu_mutex_unlock_iothread();
--                prepare_icount_for_run(cpu);
--
--                r = tcg_cpu_exec(cpu);
--
--                process_icount_data(cpu);
--                qemu_mutex_lock_iothread();
--
--                if (r == EXCP_DEBUG) {
--                    cpu_handle_guest_debug(cpu);
--                    break;
--                } else if (r == EXCP_ATOMIC) {
--                    qemu_mutex_unlock_iothread();
--                    cpu_exec_step_atomic(cpu);
--                    qemu_mutex_lock_iothread();
--                    break;
--                }
--            } else if (cpu->stop) {
--                if (cpu->unplug) {
--                    cpu = CPU_NEXT(cpu);
--                }
--                break;
--            }
--
--            cpu = CPU_NEXT(cpu);
--        } /* while (cpu && !cpu->exit_request).. */
--
--        /* Does not need qatomic_mb_set because a spurious wakeup is okay.  */
--        qatomic_set(&tcg_current_rr_cpu, NULL);
--
--        if (cpu && cpu->exit_request) {
--            qatomic_mb_set(&cpu->exit_request, 0);
--        }
--
--        if (icount_enabled() && all_cpu_threads_idle()) {
--            /*
--             * When all cpus are sleeping (e.g in WFI), to avoid a deadlock
--             * in the main_loop, wake it up in order to start the warp timer.
--             */
--            qemu_notify_event();
--        }
--
--        qemu_tcg_rr_wait_io_event();
--        deal_with_unplugged_cpus();
--    }
--
--    rcu_unregister_thread();
--    return NULL;
--}
--
--/*
-- * Multi-threaded TCG
-- *
-- * In the multi-threaded case each vCPU has its own thread. The TLS
-- * variable current_cpu can be used deep in the code to find the
-- * current CPUState for a given thread.
-- */
--
--static void *tcg_cpu_thread_fn(void *arg)
--{
--    CPUState *cpu = arg;
--
--    assert(tcg_enabled());
--    g_assert(!icount_enabled());
--
--    rcu_register_thread();
--    tcg_register_thread();
--
--    qemu_mutex_lock_iothread();
--    qemu_thread_get_self(cpu->thread);
--
--    cpu->thread_id = qemu_get_thread_id();
--    cpu->can_do_io = 1;
--    current_cpu = cpu;
--    cpu_thread_signal_created(cpu);
--    qemu_guest_random_seed_thread_part2(cpu->random_seed);
--
--    /* process any pending work */
--    cpu->exit_request = 1;
--
--    do {
--        if (cpu_can_run(cpu)) {
--            int r;
--            qemu_mutex_unlock_iothread();
--            r = tcg_cpu_exec(cpu);
--            qemu_mutex_lock_iothread();
--            switch (r) {
--            case EXCP_DEBUG:
--                cpu_handle_guest_debug(cpu);
--                break;
--            case EXCP_HALTED:
--                /*
--                 * during start-up the vCPU is reset and the thread is
--                 * kicked several times. If we don't ensure we go back
--                 * to sleep in the halted state we won't cleanly
--                 * start-up when the vCPU is enabled.
--                 *
--                 * cpu->halted should ensure we sleep in wait_io_event
--                 */
--                g_assert(cpu->halted);
--                break;
--            case EXCP_ATOMIC:
--                qemu_mutex_unlock_iothread();
--                cpu_exec_step_atomic(cpu);
--                qemu_mutex_lock_iothread();
--            default:
--                /* Ignore everything else? */
--                break;
--            }
--        }
--
--        qatomic_mb_set(&cpu->exit_request, 0);
--        qemu_wait_io_event(cpu);
--    } while (!cpu->unplug || cpu_can_run(cpu));
--
--    qemu_tcg_destroy_vcpu(cpu);
--    cpu_thread_signal_destroyed(cpu);
--    qemu_mutex_unlock_iothread();
--    rcu_unregister_thread();
--    return NULL;
--}
--
--static void tcg_start_vcpu_thread(CPUState *cpu)
-+void tcg_start_vcpu_thread(CPUState *cpu)
- {
-     char thread_name[VCPU_THREAD_NAME_SIZE];
-     static QemuCond *single_tcg_halt_cond;
-@@ -XXX,XX +XXX,XX @@ static void tcg_start_vcpu_thread(CPUState *cpu)
-     }
- }
--static int64_t tcg_get_virtual_clock(void)
-+void qemu_tcg_destroy_vcpu(CPUState *cpu)
- {
--    if (icount_enabled()) {
--        return icount_get();
--    }
--    return cpu_get_clock();
-+    cpu_thread_signal_destroyed(cpu);
- }
--static int64_t tcg_get_elapsed_ticks(void)
-+int tcg_cpu_exec(CPUState *cpu)
- {
--    if (icount_enabled()) {
--        return icount_get();
--    }
--    return cpu_get_ticks();
-+    int ret;
-+#ifdef CONFIG_PROFILER
-+    int64_t ti;
-+#endif
-+    assert(tcg_enabled());
-+#ifdef CONFIG_PROFILER
-+    ti = profile_getclock();
-+#endif
-+    cpu_exec_start(cpu);
-+    ret = cpu_exec(cpu);
-+    cpu_exec_end(cpu);
-+#ifdef CONFIG_PROFILER
-+    qatomic_set(&tcg_ctx->prof.cpu_exec_time,
-+                tcg_ctx->prof.cpu_exec_time + profile_getclock() - ti);
-+#endif
-+    return ret;
- }
- /* mask must never be zero, except for A20 change call */
--static void tcg_handle_interrupt(CPUState *cpu, int mask)
-+void tcg_handle_interrupt(CPUState *cpu, int mask)
- {
--    int old_mask;
-     g_assert(qemu_mutex_iothread_locked());
--    old_mask = cpu->interrupt_request;
-     cpu->interrupt_request |= mask;
-     /*
-@@ -XXX,XX +XXX,XX @@ static void tcg_handle_interrupt(CPUState *cpu, int mask)
-         qemu_cpu_kick(cpu);
-     } else {
-         qatomic_set(&cpu_neg(cpu)->icount_decr.u16.high, -1);
--        if (icount_enabled() &&
--            !cpu->can_do_io
--            && (mask & ~old_mask) != 0) {
--            cpu_abort(cpu, "Raised interrupt while not in I/O function");
--        }
-     }
- }
--
--const CpusAccel tcg_cpus = {
--    .create_vcpu_thread = tcg_start_vcpu_thread,
--    .kick_vcpu_thread = tcg_kick_vcpu_thread,
--
--    .handle_interrupt = tcg_handle_interrupt,
--
--    .get_virtual_clock = tcg_get_virtual_clock,
--    .get_elapsed_ticks = tcg_get_elapsed_ticks,
--};
-diff --git a/softmmu/icount.c b/softmmu/icount.c
-index XXXXXXX..XXXXXXX 100644
---- a/softmmu/icount.c
-+++ b/softmmu/icount.c
-@@ -XXX,XX +XXX,XX @@ void icount_start_warp_timer(void)
- void icount_account_warp_timer(void)
- {
--    if (!icount_enabled() || !icount_sleep) {
-+    if (!icount_sleep) {
-         return;
-     }
-diff --git a/accel/tcg/meson.build b/accel/tcg/meson.build
-index XXXXXXX..XXXXXXX 100644
---- a/accel/tcg/meson.build
-+++ b/accel/tcg/meson.build
-@@ -XXX,XX +XXX,XX @@ tcg_ss.add(when: 'CONFIG_SOFTMMU', if_false: files('user-exec-stub.c'))
- tcg_ss.add(when: 'CONFIG_PLUGIN', if_true: [files('plugin-gen.c'), libdl])
- specific_ss.add_all(when: 'CONFIG_TCG', if_true: tcg_ss)
--specific_ss.add(when: ['CONFIG_SOFTMMU', 'CONFIG_TCG'], if_true: files('tcg-all.c', 'cputlb.c', 'tcg-cpus.c'))
-+specific_ss.add(when: ['CONFIG_SOFTMMU', 'CONFIG_TCG'], if_true: files(
-+  'tcg-all.c',
-+  'cputlb.c',
-+  'tcg-cpus.c',
-+  'tcg-cpus-mttcg.c',
-+  'tcg-cpus-icount.c',
-+  'tcg-cpus-rr.c'
-+))
---
-.25.1

-[PULL 2/3] accel/tcg: split tcg_start_vcpu_thread
+Deleted patch
-From: Claudio Fontana <cfontana@suse.de>
-after the initial split into 3 tcg variants, we proceed to also
-split tcg_start_vcpu_thread.
-We actually split it in 2 this time, since the icount variant
-just uses the round robin function.
-Suggested-by: Richard Henderson <richard.henderson@linaro.org>
-Signed-off-by: Claudio Fontana <cfontana@suse.de>
-Message-Id: <20201015143217.29337-3-cfontana@suse.de>
-Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
----
- accel/tcg/tcg-cpus-mttcg.h  | 21 --------------
- accel/tcg/tcg-cpus-rr.h     |  3 +-
- accel/tcg/tcg-cpus.h        |  1 -
- accel/tcg/tcg-all.c         |  5 ++++
- accel/tcg/tcg-cpus-icount.c |  2 +-
- accel/tcg/tcg-cpus-mttcg.c  | 29 +++++++++++++++++--
- accel/tcg/tcg-cpus-rr.c     | 39 +++++++++++++++++++++++--
- accel/tcg/tcg-cpus.c        | 58 -------------------------------------
-files changed, 71 insertions(+), 87 deletions(-)
- delete mode 100644 accel/tcg/tcg-cpus-mttcg.h
-diff --git a/accel/tcg/tcg-cpus-mttcg.h b/accel/tcg/tcg-cpus-mttcg.h
-deleted file mode 100644
-index XXXXXXX..XXXXXXX
---- a/accel/tcg/tcg-cpus-mttcg.h
-+++ /dev/null
-@@ -XXX,XX +XXX,XX @@
--/*
-- * QEMU TCG Multi Threaded vCPUs implementation
-- *
-- * Copyright 2020 SUSE LLC
-- *
-- * This work is licensed under the terms of the GNU GPL, version 2 or later.
-- * See the COPYING file in the top-level directory.
-- */
--
--#ifndef TCG_CPUS_MTTCG_H
--#define TCG_CPUS_MTTCG_H
--
--/*
-- * In the multi-threaded case each vCPU has its own thread. The TLS
-- * variable current_cpu can be used deep in the code to find the
-- * current CPUState for a given thread.
-- */
--
--void *tcg_cpu_thread_fn(void *arg);
--
--#endif /* TCG_CPUS_MTTCG_H */
-diff --git a/accel/tcg/tcg-cpus-rr.h b/accel/tcg/tcg-cpus-rr.h
-index XXXXXXX..XXXXXXX 100644
---- a/accel/tcg/tcg-cpus-rr.h
-+++ b/accel/tcg/tcg-cpus-rr.h
-@@ -XXX,XX +XXX,XX @@
- /* Kick all RR vCPUs. */
- void qemu_cpu_kick_rr_cpus(CPUState *unused);
--void *tcg_rr_cpu_thread_fn(void *arg);
-+/* start the round robin vcpu thread */
-+void rr_start_vcpu_thread(CPUState *cpu);
- #endif /* TCG_CPUS_RR_H */
-diff --git a/accel/tcg/tcg-cpus.h b/accel/tcg/tcg-cpus.h
-index XXXXXXX..XXXXXXX 100644
---- a/accel/tcg/tcg-cpus.h
-+++ b/accel/tcg/tcg-cpus.h
-@@ -XXX,XX +XXX,XX @@ extern const CpusAccel tcg_cpus_mttcg;
- extern const CpusAccel tcg_cpus_icount;
- extern const CpusAccel tcg_cpus_rr;
--void tcg_start_vcpu_thread(CPUState *cpu);
- void qemu_tcg_destroy_vcpu(CPUState *cpu);
- int tcg_cpu_exec(CPUState *cpu);
- void tcg_handle_interrupt(CPUState *cpu, int mask);
-diff --git a/accel/tcg/tcg-all.c b/accel/tcg/tcg-all.c
-index XXXXXXX..XXXXXXX 100644
---- a/accel/tcg/tcg-all.c
-+++ b/accel/tcg/tcg-all.c
-@@ -XXX,XX +XXX,XX @@ static int tcg_init(MachineState *ms)
-     tcg_exec_init(s->tb_size * 1024 * 1024);
-     mttcg_enabled = s->mttcg_enabled;
-+    /*
-+     * Initialize TCG regions
-+     */
-+    tcg_region_init();
-+
-     if (mttcg_enabled) {
-         cpus_register_accel(&tcg_cpus_mttcg);
-     } else if (icount_enabled()) {
-diff --git a/accel/tcg/tcg-cpus-icount.c b/accel/tcg/tcg-cpus-icount.c
-index XXXXXXX..XXXXXXX 100644
---- a/accel/tcg/tcg-cpus-icount.c
-+++ b/accel/tcg/tcg-cpus-icount.c
-@@ -XXX,XX +XXX,XX @@ static void icount_handle_interrupt(CPUState *cpu, int mask)
- }
- const CpusAccel tcg_cpus_icount = {
--    .create_vcpu_thread = tcg_start_vcpu_thread,
-+    .create_vcpu_thread = rr_start_vcpu_thread,
-     .kick_vcpu_thread = qemu_cpu_kick_rr_cpus,
-     .handle_interrupt = icount_handle_interrupt,
-diff --git a/accel/tcg/tcg-cpus-mttcg.c b/accel/tcg/tcg-cpus-mttcg.c
-index XXXXXXX..XXXXXXX 100644
---- a/accel/tcg/tcg-cpus-mttcg.c
-+++ b/accel/tcg/tcg-cpus-mttcg.c
-@@ -XXX,XX +XXX,XX @@
- #include "hw/boards.h"
- #include "tcg-cpus.h"
--#include "tcg-cpus-mttcg.h"
- /*
-  * In the multi-threaded case each vCPU has its own thread. The TLS
-@@ -XXX,XX +XXX,XX @@
-  * current CPUState for a given thread.
-  */
--void *tcg_cpu_thread_fn(void *arg)
-+static void *tcg_cpu_thread_fn(void *arg)
- {
-     CPUState *cpu = arg;
-@@ -XXX,XX +XXX,XX @@ static void mttcg_kick_vcpu_thread(CPUState *cpu)
-     cpu_exit(cpu);
- }
-+static void mttcg_start_vcpu_thread(CPUState *cpu)
-+{
-+    char thread_name[VCPU_THREAD_NAME_SIZE];
-+
-+    g_assert(tcg_enabled());
-+
-+    parallel_cpus = (current_machine->smp.max_cpus > 1);
-+
-+    cpu->thread = g_malloc0(sizeof(QemuThread));
-+    cpu->halt_cond = g_malloc0(sizeof(QemuCond));
-+    qemu_cond_init(cpu->halt_cond);
-+
-+    /* create a thread per vCPU with TCG (MTTCG) */
-+    snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/TCG",
-+             cpu->cpu_index);
-+
-+    qemu_thread_create(cpu->thread, thread_name, tcg_cpu_thread_fn,
-+                       cpu, QEMU_THREAD_JOINABLE);
-+
-+#ifdef _WIN32
-+    cpu->hThread = qemu_thread_get_handle(cpu->thread);
-+#endif
-+}
-+
- const CpusAccel tcg_cpus_mttcg = {
--    .create_vcpu_thread = tcg_start_vcpu_thread,
-+    .create_vcpu_thread = mttcg_start_vcpu_thread,
-     .kick_vcpu_thread = mttcg_kick_vcpu_thread,
-     .handle_interrupt = tcg_handle_interrupt,
-diff --git a/accel/tcg/tcg-cpus-rr.c b/accel/tcg/tcg-cpus-rr.c
-index XXXXXXX..XXXXXXX 100644
---- a/accel/tcg/tcg-cpus-rr.c
-+++ b/accel/tcg/tcg-cpus-rr.c
-@@ -XXX,XX +XXX,XX @@ static void deal_with_unplugged_cpus(void)
-  * elsewhere.
-  */
--void *tcg_rr_cpu_thread_fn(void *arg)
-+static void *tcg_rr_cpu_thread_fn(void *arg)
- {
-     CPUState *cpu = arg;
-@@ -XXX,XX +XXX,XX @@ void *tcg_rr_cpu_thread_fn(void *arg)
-     return NULL;
- }
-+void rr_start_vcpu_thread(CPUState *cpu)
-+{
-+    char thread_name[VCPU_THREAD_NAME_SIZE];
-+    static QemuCond *single_tcg_halt_cond;
-+    static QemuThread *single_tcg_cpu_thread;
-+
-+    g_assert(tcg_enabled());
-+    parallel_cpus = false;
-+
-+    if (!single_tcg_cpu_thread) {
-+        cpu->thread = g_malloc0(sizeof(QemuThread));
-+        cpu->halt_cond = g_malloc0(sizeof(QemuCond));
-+        qemu_cond_init(cpu->halt_cond);
-+
-+        /* share a single thread for all cpus with TCG */
-+        snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "ALL CPUs/TCG");
-+        qemu_thread_create(cpu->thread, thread_name,
-+                           tcg_rr_cpu_thread_fn,
-+                           cpu, QEMU_THREAD_JOINABLE);
-+
-+        single_tcg_halt_cond = cpu->halt_cond;
-+        single_tcg_cpu_thread = cpu->thread;
-+#ifdef _WIN32
-+        cpu->hThread = qemu_thread_get_handle(cpu->thread);
-+#endif
-+    } else {
-+        /* we share the thread */
-+        cpu->thread = single_tcg_cpu_thread;
-+        cpu->halt_cond = single_tcg_halt_cond;
-+        cpu->thread_id = first_cpu->thread_id;
-+        cpu->can_do_io = 1;
-+        cpu->created = true;
-+    }
-+}
-+
- const CpusAccel tcg_cpus_rr = {
--    .create_vcpu_thread = tcg_start_vcpu_thread,
-+    .create_vcpu_thread = rr_start_vcpu_thread,
-     .kick_vcpu_thread = qemu_cpu_kick_rr_cpus,
-     .handle_interrupt = tcg_handle_interrupt,
-diff --git a/accel/tcg/tcg-cpus.c b/accel/tcg/tcg-cpus.c
-index XXXXXXX..XXXXXXX 100644
---- a/accel/tcg/tcg-cpus.c
-+++ b/accel/tcg/tcg-cpus.c
-@@ -XXX,XX +XXX,XX @@
- #include "hw/boards.h"
- #include "tcg-cpus.h"
--#include "tcg-cpus-mttcg.h"
--#include "tcg-cpus-rr.h"
- /* common functionality among all TCG variants */
--void tcg_start_vcpu_thread(CPUState *cpu)
--{
--    char thread_name[VCPU_THREAD_NAME_SIZE];
--    static QemuCond *single_tcg_halt_cond;
--    static QemuThread *single_tcg_cpu_thread;
--    static int tcg_region_inited;
--
--    assert(tcg_enabled());
--    /*
--     * Initialize TCG regions--once. Now is a good time, because:
--     * (1) TCG's init context, prologue and target globals have been set up.
--     * (2) qemu_tcg_mttcg_enabled() works now (TCG init code runs before the
--     *     -accel flag is processed, so the check doesn't work then).
--     */
--    if (!tcg_region_inited) {
--        tcg_region_inited = 1;
--        tcg_region_init();
--        parallel_cpus = qemu_tcg_mttcg_enabled() && current_machine->smp.max_cpus > 1;
--    }
--
--    if (qemu_tcg_mttcg_enabled() || !single_tcg_cpu_thread) {
--        cpu->thread = g_malloc0(sizeof(QemuThread));
--        cpu->halt_cond = g_malloc0(sizeof(QemuCond));
--        qemu_cond_init(cpu->halt_cond);
--
--        if (qemu_tcg_mttcg_enabled()) {
--            /* create a thread per vCPU with TCG (MTTCG) */
--            snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/TCG",
--                 cpu->cpu_index);
--
--            qemu_thread_create(cpu->thread, thread_name, tcg_cpu_thread_fn,
--                               cpu, QEMU_THREAD_JOINABLE);
--
--        } else {
--            /* share a single thread for all cpus with TCG */
--            snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "ALL CPUs/TCG");
--            qemu_thread_create(cpu->thread, thread_name,
--                               tcg_rr_cpu_thread_fn,
--                               cpu, QEMU_THREAD_JOINABLE);
--
--            single_tcg_halt_cond = cpu->halt_cond;
--            single_tcg_cpu_thread = cpu->thread;
--        }
--#ifdef _WIN32
--        cpu->hThread = qemu_thread_get_handle(cpu->thread);
--#endif
--    } else {
--        /* For non-MTTCG cases we share the thread */
--        cpu->thread = single_tcg_cpu_thread;
--        cpu->halt_cond = single_tcg_halt_cond;
--        cpu->thread_id = first_cpu->thread_id;
--        cpu->can_do_io = 1;
--        cpu->created = true;
--    }
--}
--
- void qemu_tcg_destroy_vcpu(CPUState *cpu)
- {
-     cpu_thread_signal_destroyed(cpu);
---
-.25.1

-[PULL 3/3] accel/tcg: rename tcg-cpus functions to match module name
+[PATCH v3 13/28] target/mips: Use VADDR_PRIx for logging pc_next
-From: Claudio Fontana <cfontana@suse.de>
+DisasContextBase.pc_next has type vaddr; use the correct log format.
-Signed-off-by: Claudio Fontana <cfontana@suse.de>
+Fixes: 85c19af63e7 ("include/exec: Use vaddr in DisasContextBase for virtual addresses")
 Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
 Message-Id: <20201015143217.29337-4-cfontana@suse.de>
 Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
 ---
- accel/tcg/tcg-cpus-icount.h |  6 +--
+ target/mips/tcg/octeon_translate.c | 4 ++--
- accel/tcg/tcg-cpus-rr.h     |  2 +-
+file changed, 2 insertions(+), 2 deletions(-)
  accel/tcg/tcg-cpus.h        |  6 +--
  accel/tcg/tcg-cpus-icount.c | 24 ++++++------
  accel/tcg/tcg-cpus-mttcg.c  | 10 ++---
  accel/tcg/tcg-cpus-rr.c     | 74 ++++++++++++++++++-------------------
  accel/tcg/tcg-cpus.c        |  6 +--
 files changed, 64 insertions(+), 64 deletions(-)
-diff --git a/accel/tcg/tcg-cpus-icount.h b/accel/tcg/tcg-cpus-icount.h
+diff --git a/target/mips/tcg/octeon_translate.c b/target/mips/tcg/octeon_translate.c
 index XXXXXXX..XXXXXXX 100644
---- a/accel/tcg/tcg-cpus-icount.h
+--- a/target/mips/tcg/octeon_translate.c
-+++ b/accel/tcg/tcg-cpus-icount.h
++++ b/target/mips/tcg/octeon_translate.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static bool trans_BBIT(DisasContext *ctx, arg_BBIT *a)
- #ifndef TCG_CPUS_ICOUNT_H
+     TCGv p;
- #define TCG_CPUS_ICOUNT_H
+     if (ctx->hflags & MIPS_HFLAG_BMASK) {
--void handle_icount_deadline(void);
+-        LOG_DISAS("Branch in delay / forbidden slot at PC 0x"
--void prepare_icount_for_run(CPUState *cpu);
+-                  TARGET_FMT_lx "\n", ctx->base.pc_next);
--void process_icount_data(CPUState *cpu);
++        LOG_DISAS("Branch in delay / forbidden slot at PC 0x%" VADDR_PRIx "\n",
-+void icount_handle_deadline(void);
++                  ctx->base.pc_next);
-+void icount_prepare_for_run(CPUState *cpu);
+         generate_exception_end(ctx, EXCP_RI);
-+void icount_process_data(CPUState *cpu);
+         return true;
  #endif /* TCG_CPUS_ICOUNT_H */
 diff --git a/accel/tcg/tcg-cpus-rr.h b/accel/tcg/tcg-cpus-rr.h
 index XXXXXXX..XXXXXXX 100644
 --- a/accel/tcg/tcg-cpus-rr.h
 +++ b/accel/tcg/tcg-cpus-rr.h
@@ -XXX,XX +XXX,XX @@
  #define TCG_KICK_PERIOD (NANOSECONDS_PER_SECOND / 10)
  /* Kick all RR vCPUs. */
 -void qemu_cpu_kick_rr_cpus(CPUState *unused);
 +void rr_kick_vcpu_thread(CPUState *unused);
  /* start the round robin vcpu thread */
  void rr_start_vcpu_thread(CPUState *cpu);
 diff --git a/accel/tcg/tcg-cpus.h b/accel/tcg/tcg-cpus.h
 index XXXXXXX..XXXXXXX 100644
 --- a/accel/tcg/tcg-cpus.h
 +++ b/accel/tcg/tcg-cpus.h
@@ -XXX,XX +XXX,XX @@ extern const CpusAccel tcg_cpus_mttcg;
  extern const CpusAccel tcg_cpus_icount;
  extern const CpusAccel tcg_cpus_rr;
 -void qemu_tcg_destroy_vcpu(CPUState *cpu);
 -int tcg_cpu_exec(CPUState *cpu);
 -void tcg_handle_interrupt(CPUState *cpu, int mask);
 +void tcg_cpus_destroy(CPUState *cpu);
 +int tcg_cpus_exec(CPUState *cpu);
 +void tcg_cpus_handle_interrupt(CPUState *cpu, int mask);
  #endif /* TCG_CPUS_H */
 diff --git a/accel/tcg/tcg-cpus-icount.c b/accel/tcg/tcg-cpus-icount.c
 index XXXXXXX..XXXXXXX 100644
 --- a/accel/tcg/tcg-cpus-icount.c
 +++ b/accel/tcg/tcg-cpus-icount.c
@@ -XXX,XX +XXX,XX @@
  #include "tcg-cpus-icount.h"
  #include "tcg-cpus-rr.h"
 -static int64_t tcg_get_icount_limit(void)
 +static int64_t icount_get_limit(void)
  {
      int64_t deadline;
@@ -XXX,XX +XXX,XX @@ static int64_t tcg_get_icount_limit(void)
      }
- }
--static void notify_aio_contexts(void)
-+static void icount_notify_aio_contexts(void)
- {
-     /* Wake up other AioContexts.  */
-     qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
-     qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
- }
--void handle_icount_deadline(void)
-+void icount_handle_deadline(void)
- {
-     assert(qemu_in_vcpu_thread());
-     int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL,
-                                                   QEMU_TIMER_ATTR_ALL);
-     if (deadline == 0) {
--        notify_aio_contexts();
-+        icount_notify_aio_contexts();
-     }
- }
--void prepare_icount_for_run(CPUState *cpu)
-+void icount_prepare_for_run(CPUState *cpu)
- {
-     int insns_left;
-     /*
--     * These should always be cleared by process_icount_data after
-+     * These should always be cleared by icount_process_data after
-      * each vCPU execution. However u16.high can be raised
--     * asynchronously by cpu_exit/cpu_interrupt/tcg_handle_interrupt
-+     * asynchronously by cpu_exit/cpu_interrupt/tcg_cpus_handle_interrupt
-      */
-     g_assert(cpu_neg(cpu)->icount_decr.u16.low == 0);
-     g_assert(cpu->icount_extra == 0);
--    cpu->icount_budget = tcg_get_icount_limit();
-+    cpu->icount_budget = icount_get_limit();
-     insns_left = MIN(0xffff, cpu->icount_budget);
-     cpu_neg(cpu)->icount_decr.u16.low = insns_left;
-     cpu->icount_extra = cpu->icount_budget - insns_left;
-@@ -XXX,XX +XXX,XX @@ void prepare_icount_for_run(CPUState *cpu)
-     replay_mutex_lock();
-     if (cpu->icount_budget == 0 && replay_has_checkpoint()) {
--        notify_aio_contexts();
-+        icount_notify_aio_contexts();
-     }
- }
--void process_icount_data(CPUState *cpu)
-+void icount_process_data(CPUState *cpu)
- {
-     /* Account for executed instructions */
-     icount_update(cpu);
-@@ -XXX,XX +XXX,XX @@ static void icount_handle_interrupt(CPUState *cpu, int mask)
- {
-     int old_mask = cpu->interrupt_request;
--    tcg_handle_interrupt(cpu, mask);
-+    tcg_cpus_handle_interrupt(cpu, mask);
-     if (qemu_cpu_is_self(cpu) &&
-         !cpu->can_do_io
-         && (mask & ~old_mask) != 0) {
-@@ -XXX,XX +XXX,XX @@ static void icount_handle_interrupt(CPUState *cpu, int mask)
- const CpusAccel tcg_cpus_icount = {
-     .create_vcpu_thread = rr_start_vcpu_thread,
--    .kick_vcpu_thread = qemu_cpu_kick_rr_cpus,
-+    .kick_vcpu_thread = rr_kick_vcpu_thread,
-     .handle_interrupt = icount_handle_interrupt,
-     .get_virtual_clock = icount_get,
-diff --git a/accel/tcg/tcg-cpus-mttcg.c b/accel/tcg/tcg-cpus-mttcg.c
-index XXXXXXX..XXXXXXX 100644
---- a/accel/tcg/tcg-cpus-mttcg.c
-+++ b/accel/tcg/tcg-cpus-mttcg.c
-@@ -XXX,XX +XXX,XX @@
-  * current CPUState for a given thread.
-  */
--static void *tcg_cpu_thread_fn(void *arg)
-+static void *mttcg_cpu_thread_fn(void *arg)
- {
-     CPUState *cpu = arg;
-@@ -XXX,XX +XXX,XX @@ static void *tcg_cpu_thread_fn(void *arg)
-         if (cpu_can_run(cpu)) {
-             int r;
-             qemu_mutex_unlock_iothread();
--            r = tcg_cpu_exec(cpu);
-+            r = tcg_cpus_exec(cpu);
-             qemu_mutex_lock_iothread();
-             switch (r) {
-             case EXCP_DEBUG:
-@@ -XXX,XX +XXX,XX @@ static void *tcg_cpu_thread_fn(void *arg)
-         qemu_wait_io_event(cpu);
-     } while (!cpu->unplug || cpu_can_run(cpu));
--    qemu_tcg_destroy_vcpu(cpu);
-+    tcg_cpus_destroy(cpu);
-     qemu_mutex_unlock_iothread();
-     rcu_unregister_thread();
-     return NULL;
-@@ -XXX,XX +XXX,XX @@ static void mttcg_start_vcpu_thread(CPUState *cpu)
-     snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/TCG",
-              cpu->cpu_index);
--    qemu_thread_create(cpu->thread, thread_name, tcg_cpu_thread_fn,
-+    qemu_thread_create(cpu->thread, thread_name, mttcg_cpu_thread_fn,
-                        cpu, QEMU_THREAD_JOINABLE);
- #ifdef _WIN32
-@@ -XXX,XX +XXX,XX @@ const CpusAccel tcg_cpus_mttcg = {
-     .create_vcpu_thread = mttcg_start_vcpu_thread,
-     .kick_vcpu_thread = mttcg_kick_vcpu_thread,
--    .handle_interrupt = tcg_handle_interrupt,
-+    .handle_interrupt = tcg_cpus_handle_interrupt,
- };
-diff --git a/accel/tcg/tcg-cpus-rr.c b/accel/tcg/tcg-cpus-rr.c
-index XXXXXXX..XXXXXXX 100644
---- a/accel/tcg/tcg-cpus-rr.c
-+++ b/accel/tcg/tcg-cpus-rr.c
-@@ -XXX,XX +XXX,XX @@
- #include "tcg-cpus-icount.h"
- /* Kick all RR vCPUs */
--void qemu_cpu_kick_rr_cpus(CPUState *unused)
-+void rr_kick_vcpu_thread(CPUState *unused)
- {
-     CPUState *cpu;
-@@ -XXX,XX +XXX,XX @@ void qemu_cpu_kick_rr_cpus(CPUState *unused)
-  * idleness is complete.
-  */
--static QEMUTimer *tcg_kick_vcpu_timer;
--static CPUState *tcg_current_rr_cpu;
-+static QEMUTimer *rr_kick_vcpu_timer;
-+static CPUState *rr_current_cpu;
- #define TCG_KICK_PERIOD (NANOSECONDS_PER_SECOND / 10)
--static inline int64_t qemu_tcg_next_kick(void)
-+static inline int64_t rr_next_kick_time(void)
- {
-     return qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + TCG_KICK_PERIOD;
- }
- /* Kick the currently round-robin scheduled vCPU to next */
--static void qemu_cpu_kick_rr_next_cpu(void)
-+static void rr_kick_next_cpu(void)
- {
-     CPUState *cpu;
-     do {
--        cpu = qatomic_mb_read(&tcg_current_rr_cpu);
-+        cpu = qatomic_mb_read(&rr_current_cpu);
-         if (cpu) {
-             cpu_exit(cpu);
-         }
--    } while (cpu != qatomic_mb_read(&tcg_current_rr_cpu));
-+    } while (cpu != qatomic_mb_read(&rr_current_cpu));
- }
--static void kick_tcg_thread(void *opaque)
-+static void rr_kick_thread(void *opaque)
- {
--    timer_mod(tcg_kick_vcpu_timer, qemu_tcg_next_kick());
--    qemu_cpu_kick_rr_next_cpu();
-+    timer_mod(rr_kick_vcpu_timer, rr_next_kick_time());
-+    rr_kick_next_cpu();
- }
--static void start_tcg_kick_timer(void)
-+static void rr_start_kick_timer(void)
- {
--    if (!tcg_kick_vcpu_timer && CPU_NEXT(first_cpu)) {
--        tcg_kick_vcpu_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
--                                           kick_tcg_thread, NULL);
-+    if (!rr_kick_vcpu_timer && CPU_NEXT(first_cpu)) {
-+        rr_kick_vcpu_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
-+                                           rr_kick_thread, NULL);
-     }
--    if (tcg_kick_vcpu_timer && !timer_pending(tcg_kick_vcpu_timer)) {
--        timer_mod(tcg_kick_vcpu_timer, qemu_tcg_next_kick());
-+    if (rr_kick_vcpu_timer && !timer_pending(rr_kick_vcpu_timer)) {
-+        timer_mod(rr_kick_vcpu_timer, rr_next_kick_time());
-     }
- }
--static void stop_tcg_kick_timer(void)
-+static void rr_stop_kick_timer(void)
- {
--    if (tcg_kick_vcpu_timer && timer_pending(tcg_kick_vcpu_timer)) {
--        timer_del(tcg_kick_vcpu_timer);
-+    if (rr_kick_vcpu_timer && timer_pending(rr_kick_vcpu_timer)) {
-+        timer_del(rr_kick_vcpu_timer);
-     }
- }
--static void qemu_tcg_rr_wait_io_event(void)
-+static void rr_wait_io_event(void)
- {
-     CPUState *cpu;
-     while (all_cpu_threads_idle()) {
--        stop_tcg_kick_timer();
-+        rr_stop_kick_timer();
-         qemu_cond_wait_iothread(first_cpu->halt_cond);
-     }
--    start_tcg_kick_timer();
-+    rr_start_kick_timer();
-     CPU_FOREACH(cpu) {
-         qemu_wait_io_event_common(cpu);
-@@ -XXX,XX +XXX,XX @@ static void qemu_tcg_rr_wait_io_event(void)
-  * Destroy any remaining vCPUs which have been unplugged and have
-  * finished running
-  */
--static void deal_with_unplugged_cpus(void)
-+static void rr_deal_with_unplugged_cpus(void)
- {
-     CPUState *cpu;
-     CPU_FOREACH(cpu) {
-         if (cpu->unplug && !cpu_can_run(cpu)) {
--            qemu_tcg_destroy_vcpu(cpu);
-+            tcg_cpus_destroy(cpu);
-             break;
-         }
-     }
-@@ -XXX,XX +XXX,XX @@ static void deal_with_unplugged_cpus(void)
-  * elsewhere.
-  */
--static void *tcg_rr_cpu_thread_fn(void *arg)
-+static void *rr_cpu_thread_fn(void *arg)
- {
-     CPUState *cpu = arg;
-@@ -XXX,XX +XXX,XX @@ static void *tcg_rr_cpu_thread_fn(void *arg)
-         }
-     }
--    start_tcg_kick_timer();
-+    rr_start_kick_timer();
-     cpu = first_cpu;
-@@ -XXX,XX +XXX,XX @@ static void *tcg_rr_cpu_thread_fn(void *arg)
-              * Run the timers here.  This is much more efficient than
-              * waking up the I/O thread and waiting for completion.
-              */
--            handle_icount_deadline();
-+            icount_handle_deadline();
-         }
-         replay_mutex_unlock();
-@@ -XXX,XX +XXX,XX @@ static void *tcg_rr_cpu_thread_fn(void *arg)
-         while (cpu && cpu_work_list_empty(cpu) && !cpu->exit_request) {
--            qatomic_mb_set(&tcg_current_rr_cpu, cpu);
-+            qatomic_mb_set(&rr_current_cpu, cpu);
-             current_cpu = cpu;
-             qemu_clock_enable(QEMU_CLOCK_VIRTUAL,
-@@ -XXX,XX +XXX,XX @@ static void *tcg_rr_cpu_thread_fn(void *arg)
-                 qemu_mutex_unlock_iothread();
-                 if (icount_enabled()) {
--                    prepare_icount_for_run(cpu);
-+                    icount_prepare_for_run(cpu);
-                 }
--                r = tcg_cpu_exec(cpu);
-+                r = tcg_cpus_exec(cpu);
-                 if (icount_enabled()) {
--                    process_icount_data(cpu);
-+                    icount_process_data(cpu);
-                 }
-                 qemu_mutex_lock_iothread();
-@@ -XXX,XX +XXX,XX @@ static void *tcg_rr_cpu_thread_fn(void *arg)
-         } /* while (cpu && !cpu->exit_request).. */
-         /* Does not need qatomic_mb_set because a spurious wakeup is okay.  */
--        qatomic_set(&tcg_current_rr_cpu, NULL);
-+        qatomic_set(&rr_current_cpu, NULL);
-         if (cpu && cpu->exit_request) {
-             qatomic_mb_set(&cpu->exit_request, 0);
-@@ -XXX,XX +XXX,XX @@ static void *tcg_rr_cpu_thread_fn(void *arg)
-             qemu_notify_event();
-         }
--        qemu_tcg_rr_wait_io_event();
--        deal_with_unplugged_cpus();
-+        rr_wait_io_event();
-+        rr_deal_with_unplugged_cpus();
-     }
-     rcu_unregister_thread();
-@@ -XXX,XX +XXX,XX @@ void rr_start_vcpu_thread(CPUState *cpu)
-         /* share a single thread for all cpus with TCG */
-         snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "ALL CPUs/TCG");
-         qemu_thread_create(cpu->thread, thread_name,
--                           tcg_rr_cpu_thread_fn,
-+                           rr_cpu_thread_fn,
-                            cpu, QEMU_THREAD_JOINABLE);
-         single_tcg_halt_cond = cpu->halt_cond;
-@@ -XXX,XX +XXX,XX @@ void rr_start_vcpu_thread(CPUState *cpu)
- const CpusAccel tcg_cpus_rr = {
-     .create_vcpu_thread = rr_start_vcpu_thread,
--    .kick_vcpu_thread = qemu_cpu_kick_rr_cpus,
-+    .kick_vcpu_thread = rr_kick_vcpu_thread,
--    .handle_interrupt = tcg_handle_interrupt,
-+    .handle_interrupt = tcg_cpus_handle_interrupt,
- };
-diff --git a/accel/tcg/tcg-cpus.c b/accel/tcg/tcg-cpus.c
-index XXXXXXX..XXXXXXX 100644
---- a/accel/tcg/tcg-cpus.c
-+++ b/accel/tcg/tcg-cpus.c
-@@ -XXX,XX +XXX,XX @@
- /* common functionality among all TCG variants */
--void qemu_tcg_destroy_vcpu(CPUState *cpu)
-+void tcg_cpus_destroy(CPUState *cpu)
- {
-     cpu_thread_signal_destroyed(cpu);
- }
--int tcg_cpu_exec(CPUState *cpu)
-+int tcg_cpus_exec(CPUState *cpu)
- {
-     int ret;
- #ifdef CONFIG_PROFILER
-@@ -XXX,XX +XXX,XX @@ int tcg_cpu_exec(CPUState *cpu)
- }
- /* mask must never be zero, except for A20 change call */
--void tcg_handle_interrupt(CPUState *cpu, int mask)
-+void tcg_cpus_handle_interrupt(CPUState *cpu, int mask)
- {
-     g_assert(qemu_mutex_iothread_locked());
 --
-.25.1
+.43.0

The following changes since commit 2ecfc0657afa5d29a373271b342f704a1a3c6737:

Merge remote-tracking branch 'remotes/armbru/tags/pull-misc-2020-12-10' into staging (2020-12-10 17:01:05 +0000)

are available in the Git repository at:

https://gitlab.com/rth7680/qemu.git tags/pull-tcg-20201210

for you to fetch changes up to 9e2658d62ebc23efe7df43fc0e306f129510d874:

accel/tcg: rename tcg-cpus functions to match module name (2020-12-10 17:44:10 -0600)

----------------------------------------------------------------
Split CpusAccel for tcg variants

----------------------------------------------------------------
Claudio Fontana (3):
      accel/tcg: split CpusAccel into three TCG variants
      accel/tcg: split tcg_start_vcpu_thread
      accel/tcg: rename tcg-cpus functions to match module name

accel/tcg/tcg-cpus-icount.h |  17 ++
 accel/tcg/tcg-cpus-rr.h     |  21 ++
 accel/tcg/tcg-cpus.h        |  12 +-
 accel/tcg/tcg-all.c         |  13 +-
 accel/tcg/tcg-cpus-icount.c | 147 +++++++++++++
 accel/tcg/tcg-cpus-mttcg.c  | 140 ++++++++++++
 accel/tcg/tcg-cpus-rr.c     | 305 ++++++++++++++++++++++++++
 accel/tcg/tcg-cpus.c        | 506 +-------------------------------------------
 softmmu/icount.c            |   2 +-
 accel/tcg/meson.build       |   9 +-
 10 files changed, 670 insertions(+), 502 deletions(-)
 create mode 100644 accel/tcg/tcg-cpus-icount.h
 create mode 100644 accel/tcg/tcg-cpus-rr.h
 create mode 100644 accel/tcg/tcg-cpus-icount.c
 create mode 100644 accel/tcg/tcg-cpus-mttcg.c
 create mode 100644 accel/tcg/tcg-cpus-rr.c

From: Claudio Fontana <cfontana@suse.de>

split up the CpusAccel tcg_cpus into three TCG variants:

tcg_cpus_rr (single threaded, round robin cpus)
tcg_cpus_icount (same as rr, but with instruction counting enabled)
tcg_cpus_mttcg (multi-threaded cpus)

Suggested-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: Claudio Fontana <cfontana@suse.de>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Message-Id: <20201015143217.29337-2-cfontana@suse.de>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 accel/tcg/tcg-cpus-icount.h |  17 ++
 accel/tcg/tcg-cpus-mttcg.h  |  21 ++
 accel/tcg/tcg-cpus-rr.h     |  20 ++
 accel/tcg/tcg-cpus.h        |  13 +-
 accel/tcg/tcg-all.c         |   8 +-
 accel/tcg/tcg-cpus-icount.c | 147 +++++++++++
 accel/tcg/tcg-cpus-mttcg.c  | 117 +++++++++
 accel/tcg/tcg-cpus-rr.c     | 270 ++++++++++++++++++++
 accel/tcg/tcg-cpus.c        | 484 ++----------------------------------
 softmmu/icount.c            |   2 +-
 accel/tcg/meson.build       |   9 +-
 11 files changed, 646 insertions(+), 462 deletions(-)
 create mode 100644 accel/tcg/tcg-cpus-icount.h
 create mode 100644 accel/tcg/tcg-cpus-mttcg.h
 create mode 100644 accel/tcg/tcg-cpus-rr.h
 create mode 100644 accel/tcg/tcg-cpus-icount.c
 create mode 100644 accel/tcg/tcg-cpus-mttcg.c
 create mode 100644 accel/tcg/tcg-cpus-rr.c

diff --git a/accel/tcg/tcg-cpus-icount.h b/accel/tcg/tcg-cpus-icount.h
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/accel/tcg/tcg-cpus-icount.h
@@ -XXX,XX +XXX,XX @@
+/*
+ * QEMU TCG Single Threaded vCPUs implementation using instruction counting
+ *
+ * Copyright 2020 SUSE LLC
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ */
+
+#ifndef TCG_CPUS_ICOUNT_H
+#define TCG_CPUS_ICOUNT_H
+
+void handle_icount_deadline(void);
+void prepare_icount_for_run(CPUState *cpu);
+void process_icount_data(CPUState *cpu);
+
+#endif /* TCG_CPUS_ICOUNT_H */
diff --git a/accel/tcg/tcg-cpus-mttcg.h b/accel/tcg/tcg-cpus-mttcg.h
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/accel/tcg/tcg-cpus-mttcg.h
@@ -XXX,XX +XXX,XX @@
+/*
+ * QEMU TCG Multi Threaded vCPUs implementation
+ *
+ * Copyright 2020 SUSE LLC
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ */
+
+#ifndef TCG_CPUS_MTTCG_H
+#define TCG_CPUS_MTTCG_H
+
+/*
+ * In the multi-threaded case each vCPU has its own thread. The TLS
+ * variable current_cpu can be used deep in the code to find the
+ * current CPUState for a given thread.
+ */
+
+void *tcg_cpu_thread_fn(void *arg);
+
+#endif /* TCG_CPUS_MTTCG_H */
diff --git a/accel/tcg/tcg-cpus-rr.h b/accel/tcg/tcg-cpus-rr.h
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/accel/tcg/tcg-cpus-rr.h
@@ -XXX,XX +XXX,XX @@
+/*
+ * QEMU TCG Single Threaded vCPUs implementation
+ *
+ * Copyright 2020 SUSE LLC
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ */
+
+#ifndef TCG_CPUS_RR_H
+#define TCG_CPUS_RR_H
+
+#define TCG_KICK_PERIOD (NANOSECONDS_PER_SECOND / 10)
+
+/* Kick all RR vCPUs. */
+void qemu_cpu_kick_rr_cpus(CPUState *unused);
+
+void *tcg_rr_cpu_thread_fn(void *arg);
+
+#endif /* TCG_CPUS_RR_H */
diff --git a/accel/tcg/tcg-cpus.h b/accel/tcg/tcg-cpus.h
index XXXXXXX..XXXXXXX 100644
--- a/accel/tcg/tcg-cpus.h
+++ b/accel/tcg/tcg-cpus.h
@@ -XXX,XX +XXX,XX @@
 /*
- * Accelerator CPUS Interface
+ * QEMU TCG vCPU common functionality
+ *
+ * Functionality common to all TCG vcpu variants: mttcg, rr and icount.
  *
  * Copyright 2020 SUSE LLC
  *
@@ -XXX,XX +XXX,XX @@
 
 #include "sysemu/cpus.h"
 
-extern const CpusAccel tcg_cpus;
+extern const CpusAccel tcg_cpus_mttcg;
+extern const CpusAccel tcg_cpus_icount;
+extern const CpusAccel tcg_cpus_rr;
+
+void tcg_start_vcpu_thread(CPUState *cpu);
+void qemu_tcg_destroy_vcpu(CPUState *cpu);
+int tcg_cpu_exec(CPUState *cpu);
+void tcg_handle_interrupt(CPUState *cpu, int mask);
 
 #endif /* TCG_CPUS_H */
diff --git a/accel/tcg/tcg-all.c b/accel/tcg/tcg-all.c
index XXXXXXX..XXXXXXX 100644
--- a/accel/tcg/tcg-all.c
+++ b/accel/tcg/tcg-all.c
@@ -XXX,XX +XXX,XX @@ static int tcg_init(MachineState *ms)
 
     tcg_exec_init(s->tb_size * 1024 * 1024);
     mttcg_enabled = s->mttcg_enabled;
-    cpus_register_accel(&tcg_cpus);
 
+    if (mttcg_enabled) {
+        cpus_register_accel(&tcg_cpus_mttcg);
+    } else if (icount_enabled()) {
+        cpus_register_accel(&tcg_cpus_icount);
+    } else {
+        cpus_register_accel(&tcg_cpus_rr);
+    }
     return 0;
 }
 
diff --git a/accel/tcg/tcg-cpus-icount.c b/accel/tcg/tcg-cpus-icount.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/accel/tcg/tcg-cpus-icount.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * QEMU TCG Single Threaded vCPUs implementation using instruction counting
+ *
+ * Copyright (c) 2003-2008 Fabrice Bellard
+ * Copyright (c) 2014 Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "qemu/osdep.h"
+#include "qemu-common.h"
+#include "sysemu/tcg.h"
+#include "sysemu/replay.h"
+#include "qemu/main-loop.h"
+#include "qemu/guest-random.h"
+#include "exec/exec-all.h"
+#include "hw/boards.h"
+
+#include "tcg-cpus.h"
+#include "tcg-cpus-icount.h"
+#include "tcg-cpus-rr.h"
+
+static int64_t tcg_get_icount_limit(void)
+{
+    int64_t deadline;
+
+    if (replay_mode != REPLAY_MODE_PLAY) {
+        /*
+         * Include all the timers, because they may need an attention.
+         * Too long CPU execution may create unnecessary delay in UI.
+         */
+        deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL,
+                                              QEMU_TIMER_ATTR_ALL);
+        /* Check realtime timers, because they help with input processing */
+        deadline = qemu_soonest_timeout(deadline,
+                qemu_clock_deadline_ns_all(QEMU_CLOCK_REALTIME,
+                                           QEMU_TIMER_ATTR_ALL));
+
+        /*
+         * Maintain prior (possibly buggy) behaviour where if no deadline
+         * was set (as there is no QEMU_CLOCK_VIRTUAL timer) or it is more than
+         * INT32_MAX nanoseconds ahead, we still use INT32_MAX
+         * nanoseconds.
+         */
+        if ((deadline < 0) || (deadline > INT32_MAX)) {
+            deadline = INT32_MAX;
+        }
+
+        return icount_round(deadline);
+    } else {
+        return replay_get_instructions();
+    }
+}
+
+static void notify_aio_contexts(void)
+{
+    /* Wake up other AioContexts.  */
+    qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
+    qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
+}
+
+void handle_icount_deadline(void)
+{
+    assert(qemu_in_vcpu_thread());
+    int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL,
+                                                  QEMU_TIMER_ATTR_ALL);
+
+    if (deadline == 0) {
+        notify_aio_contexts();
+    }
+}
+
+void prepare_icount_for_run(CPUState *cpu)
+{
+    int insns_left;
+
+    /*
+     * These should always be cleared by process_icount_data after
+     * each vCPU execution. However u16.high can be raised
+     * asynchronously by cpu_exit/cpu_interrupt/tcg_handle_interrupt
+     */
+    g_assert(cpu_neg(cpu)->icount_decr.u16.low == 0);
+    g_assert(cpu->icount_extra == 0);
+
+    cpu->icount_budget = tcg_get_icount_limit();
+    insns_left = MIN(0xffff, cpu->icount_budget);
+    cpu_neg(cpu)->icount_decr.u16.low = insns_left;
+    cpu->icount_extra = cpu->icount_budget - insns_left;
+
+    replay_mutex_lock();
+
+    if (cpu->icount_budget == 0 && replay_has_checkpoint()) {
+        notify_aio_contexts();
+    }
+}
+
+void process_icount_data(CPUState *cpu)
+{
+    /* Account for executed instructions */
+    icount_update(cpu);
+
+    /* Reset the counters */
+    cpu_neg(cpu)->icount_decr.u16.low = 0;
+    cpu->icount_extra = 0;
+    cpu->icount_budget = 0;
+
+    replay_account_executed_instructions();
+
+    replay_mutex_unlock();
+}
+
+static void icount_handle_interrupt(CPUState *cpu, int mask)
+{
+    int old_mask = cpu->interrupt_request;
+
+    tcg_handle_interrupt(cpu, mask);
+    if (qemu_cpu_is_self(cpu) &&
+        !cpu->can_do_io
+        && (mask & ~old_mask) != 0) {
+        cpu_abort(cpu, "Raised interrupt while not in I/O function");
+    }
+}
+
+const CpusAccel tcg_cpus_icount = {
+    .create_vcpu_thread = tcg_start_vcpu_thread,
+    .kick_vcpu_thread = qemu_cpu_kick_rr_cpus,
+
+    .handle_interrupt = icount_handle_interrupt,
+    .get_virtual_clock = icount_get,
+    .get_elapsed_ticks = icount_get,
+};
diff --git a/accel/tcg/tcg-cpus-mttcg.c b/accel/tcg/tcg-cpus-mttcg.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/accel/tcg/tcg-cpus-mttcg.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * QEMU TCG Multi Threaded vCPUs implementation
+ *
+ * Copyright (c) 2003-2008 Fabrice Bellard
+ * Copyright (c) 2014 Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "qemu/osdep.h"
+#include "qemu-common.h"
+#include "sysemu/tcg.h"
+#include "sysemu/replay.h"
+#include "qemu/main-loop.h"
+#include "qemu/guest-random.h"
+#include "exec/exec-all.h"
+#include "hw/boards.h"
+
+#include "tcg-cpus.h"
+#include "tcg-cpus-mttcg.h"
+
+/*
+ * In the multi-threaded case each vCPU has its own thread. The TLS
+ * variable current_cpu can be used deep in the code to find the
+ * current CPUState for a given thread.
+ */
+
+void *tcg_cpu_thread_fn(void *arg)
+{
+    CPUState *cpu = arg;
+
+    assert(tcg_enabled());
+    g_assert(!icount_enabled());
+
+    rcu_register_thread();
+    tcg_register_thread();
+
+    qemu_mutex_lock_iothread();
+    qemu_thread_get_self(cpu->thread);
+
+    cpu->thread_id = qemu_get_thread_id();
+    cpu->can_do_io = 1;
+    current_cpu = cpu;
+    cpu_thread_signal_created(cpu);
+    qemu_guest_random_seed_thread_part2(cpu->random_seed);
+
+    /* process any pending work */
+    cpu->exit_request = 1;
+
+    do {
+        if (cpu_can_run(cpu)) {
+            int r;
+            qemu_mutex_unlock_iothread();
+            r = tcg_cpu_exec(cpu);
+            qemu_mutex_lock_iothread();
+            switch (r) {
+            case EXCP_DEBUG:
+                cpu_handle_guest_debug(cpu);
+                break;
+            case EXCP_HALTED:
+                /*
+                 * during start-up the vCPU is reset and the thread is
+                 * kicked several times. If we don't ensure we go back
+                 * to sleep in the halted state we won't cleanly
+                 * start-up when the vCPU is enabled.
+                 *
+                 * cpu->halted should ensure we sleep in wait_io_event
+                 */
+                g_assert(cpu->halted);
+                break;
+            case EXCP_ATOMIC:
+                qemu_mutex_unlock_iothread();
+                cpu_exec_step_atomic(cpu);
+                qemu_mutex_lock_iothread();
+            default:
+                /* Ignore everything else? */
+                break;
+            }
+        }
+
+        qatomic_mb_set(&cpu->exit_request, 0);
+        qemu_wait_io_event(cpu);
+    } while (!cpu->unplug || cpu_can_run(cpu));
+
+    qemu_tcg_destroy_vcpu(cpu);
+    qemu_mutex_unlock_iothread();
+    rcu_unregister_thread();
+    return NULL;
+}
+
+static void mttcg_kick_vcpu_thread(CPUState *cpu)
+{
+    cpu_exit(cpu);
+}
+
+const CpusAccel tcg_cpus_mttcg = {
+    .create_vcpu_thread = tcg_start_vcpu_thread,
+    .kick_vcpu_thread = mttcg_kick_vcpu_thread,
+
+    .handle_interrupt = tcg_handle_interrupt,
+};
diff --git a/accel/tcg/tcg-cpus-rr.c b/accel/tcg/tcg-cpus-rr.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/accel/tcg/tcg-cpus-rr.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * QEMU TCG Single Threaded vCPUs implementation
+ *
+ * Copyright (c) 2003-2008 Fabrice Bellard
+ * Copyright (c) 2014 Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "qemu/osdep.h"
+#include "qemu-common.h"
+#include "sysemu/tcg.h"
+#include "sysemu/replay.h"
+#include "qemu/main-loop.h"
+#include "qemu/guest-random.h"
+#include "exec/exec-all.h"
+#include "hw/boards.h"
+
+#include "tcg-cpus.h"
+#include "tcg-cpus-rr.h"
+#include "tcg-cpus-icount.h"
+
+/* Kick all RR vCPUs */
+void qemu_cpu_kick_rr_cpus(CPUState *unused)
+{
+    CPUState *cpu;
+
+    CPU_FOREACH(cpu) {
+        cpu_exit(cpu);
+    };
+}
+
+/*
+ * TCG vCPU kick timer
+ *
+ * The kick timer is responsible for moving single threaded vCPU
+ * emulation on to the next vCPU. If more than one vCPU is running a
+ * timer event with force a cpu->exit so the next vCPU can get
+ * scheduled.
+ *
+ * The timer is removed if all vCPUs are idle and restarted again once
+ * idleness is complete.
+ */
+
+static QEMUTimer *tcg_kick_vcpu_timer;
+static CPUState *tcg_current_rr_cpu;
+
+#define TCG_KICK_PERIOD (NANOSECONDS_PER_SECOND / 10)
+
+static inline int64_t qemu_tcg_next_kick(void)
+{
+    return qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + TCG_KICK_PERIOD;
+}
+
+/* Kick the currently round-robin scheduled vCPU to next */
+static void qemu_cpu_kick_rr_next_cpu(void)
+{
+    CPUState *cpu;
+    do {
+        cpu = qatomic_mb_read(&tcg_current_rr_cpu);
+        if (cpu) {
+            cpu_exit(cpu);
+        }
+    } while (cpu != qatomic_mb_read(&tcg_current_rr_cpu));
+}
+
+static void kick_tcg_thread(void *opaque)
+{
+    timer_mod(tcg_kick_vcpu_timer, qemu_tcg_next_kick());
+    qemu_cpu_kick_rr_next_cpu();
+}
+
+static void start_tcg_kick_timer(void)
+{
+    if (!tcg_kick_vcpu_timer && CPU_NEXT(first_cpu)) {
+        tcg_kick_vcpu_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
+                                           kick_tcg_thread, NULL);
+    }
+    if (tcg_kick_vcpu_timer && !timer_pending(tcg_kick_vcpu_timer)) {
+        timer_mod(tcg_kick_vcpu_timer, qemu_tcg_next_kick());
+    }
+}
+
+static void stop_tcg_kick_timer(void)
+{
+    if (tcg_kick_vcpu_timer && timer_pending(tcg_kick_vcpu_timer)) {
+        timer_del(tcg_kick_vcpu_timer);
+    }
+}
+
+static void qemu_tcg_rr_wait_io_event(void)
+{
+    CPUState *cpu;
+
+    while (all_cpu_threads_idle()) {
+        stop_tcg_kick_timer();
+        qemu_cond_wait_iothread(first_cpu->halt_cond);
+    }
+
+    start_tcg_kick_timer();
+
+    CPU_FOREACH(cpu) {
+        qemu_wait_io_event_common(cpu);
+    }
+}
+
+/*
+ * Destroy any remaining vCPUs which have been unplugged and have
+ * finished running
+ */
+static void deal_with_unplugged_cpus(void)
+{
+    CPUState *cpu;
+
+    CPU_FOREACH(cpu) {
+        if (cpu->unplug && !cpu_can_run(cpu)) {
+            qemu_tcg_destroy_vcpu(cpu);
+            break;
+        }
+    }
+}
+
+/*
+ * In the single-threaded case each vCPU is simulated in turn. If
+ * there is more than a single vCPU we create a simple timer to kick
+ * the vCPU and ensure we don't get stuck in a tight loop in one vCPU.
+ * This is done explicitly rather than relying on side-effects
+ * elsewhere.
+ */
+
+void *tcg_rr_cpu_thread_fn(void *arg)
+{
+    CPUState *cpu = arg;
+
+    assert(tcg_enabled());
+    rcu_register_thread();
+    tcg_register_thread();
+
+    qemu_mutex_lock_iothread();
+    qemu_thread_get_self(cpu->thread);
+
+    cpu->thread_id = qemu_get_thread_id();
+    cpu->can_do_io = 1;
+    cpu_thread_signal_created(cpu);
+    qemu_guest_random_seed_thread_part2(cpu->random_seed);
+
+    /* wait for initial kick-off after machine start */
+    while (first_cpu->stopped) {
+        qemu_cond_wait_iothread(first_cpu->halt_cond);
+
+        /* process any pending work */
+        CPU_FOREACH(cpu) {
+            current_cpu = cpu;
+            qemu_wait_io_event_common(cpu);
+        }
+    }
+
+    start_tcg_kick_timer();
+
+    cpu = first_cpu;
+
+    /* process any pending work */
+    cpu->exit_request = 1;
+
+    while (1) {
+        qemu_mutex_unlock_iothread();
+        replay_mutex_lock();
+        qemu_mutex_lock_iothread();
+
+        if (icount_enabled()) {
+            /* Account partial waits to QEMU_CLOCK_VIRTUAL.  */
+            icount_account_warp_timer();
+            /*
+             * Run the timers here.  This is much more efficient than
+             * waking up the I/O thread and waiting for completion.
+             */
+            handle_icount_deadline();
+        }
+
+        replay_mutex_unlock();
+
+        if (!cpu) {
+            cpu = first_cpu;
+        }
+
+        while (cpu && cpu_work_list_empty(cpu) && !cpu->exit_request) {
+
+            qatomic_mb_set(&tcg_current_rr_cpu, cpu);
+            current_cpu = cpu;
+
+            qemu_clock_enable(QEMU_CLOCK_VIRTUAL,
+                              (cpu->singlestep_enabled & SSTEP_NOTIMER) == 0);
+
+            if (cpu_can_run(cpu)) {
+                int r;
+
+                qemu_mutex_unlock_iothread();
+                if (icount_enabled()) {
+                    prepare_icount_for_run(cpu);
+                }
+                r = tcg_cpu_exec(cpu);
+                if (icount_enabled()) {
+                    process_icount_data(cpu);
+                }
+                qemu_mutex_lock_iothread();
+
+                if (r == EXCP_DEBUG) {
+                    cpu_handle_guest_debug(cpu);
+                    break;
+                } else if (r == EXCP_ATOMIC) {
+                    qemu_mutex_unlock_iothread();
+                    cpu_exec_step_atomic(cpu);
+                    qemu_mutex_lock_iothread();
+                    break;
+                }
+            } else if (cpu->stop) {
+                if (cpu->unplug) {
+                    cpu = CPU_NEXT(cpu);
+                }
+                break;
+            }
+
+            cpu = CPU_NEXT(cpu);
+        } /* while (cpu && !cpu->exit_request).. */
+
+        /* Does not need qatomic_mb_set because a spurious wakeup is okay.  */
+        qatomic_set(&tcg_current_rr_cpu, NULL);
+
+        if (cpu && cpu->exit_request) {
+            qatomic_mb_set(&cpu->exit_request, 0);
+        }
+
+        if (icount_enabled() && all_cpu_threads_idle()) {
+            /*
+             * When all cpus are sleeping (e.g in WFI), to avoid a deadlock
+             * in the main_loop, wake it up in order to start the warp timer.
+             */
+            qemu_notify_event();
+        }
+
+        qemu_tcg_rr_wait_io_event();
+        deal_with_unplugged_cpus();
+    }
+
+    rcu_unregister_thread();
+    return NULL;
+}
+
+const CpusAccel tcg_cpus_rr = {
+    .create_vcpu_thread = tcg_start_vcpu_thread,
+    .kick_vcpu_thread = qemu_cpu_kick_rr_cpus,
+
+    .handle_interrupt = tcg_handle_interrupt,
+};
diff --git a/accel/tcg/tcg-cpus.c b/accel/tcg/tcg-cpus.c
index XXXXXXX..XXXXXXX 100644
--- a/accel/tcg/tcg-cpus.c
+++ b/accel/tcg/tcg-cpus.c
@@ -XXX,XX +XXX,XX @@
 /*
- * QEMU System Emulator
+ * QEMU TCG vCPU common functionality
+ *
+ * Functionality common to all TCG vCPU variants: mttcg, rr and icount.
  *
  * Copyright (c) 2003-2008 Fabrice Bellard
  * Copyright (c) 2014 Red Hat Inc.
@@ -XXX,XX +XXX,XX @@
 #include "hw/boards.h"
 
 #include "tcg-cpus.h"
+#include "tcg-cpus-mttcg.h"
+#include "tcg-cpus-rr.h"
 
-/* Kick all RR vCPUs */
-static void qemu_cpu_kick_rr_cpus(void)
-{
-    CPUState *cpu;
+/* common functionality among all TCG variants */
 
-    CPU_FOREACH(cpu) {
-        cpu_exit(cpu);
-    };
-}
-
-static void tcg_kick_vcpu_thread(CPUState *cpu)
-{
-    if (qemu_tcg_mttcg_enabled()) {
-        cpu_exit(cpu);
-    } else {
-        qemu_cpu_kick_rr_cpus();
-    }
-}
-
-/*
- * TCG vCPU kick timer
- *
- * The kick timer is responsible for moving single threaded vCPU
- * emulation on to the next vCPU. If more than one vCPU is running a
- * timer event with force a cpu->exit so the next vCPU can get
- * scheduled.
- *
- * The timer is removed if all vCPUs are idle and restarted again once
- * idleness is complete.
- */
-
-static QEMUTimer *tcg_kick_vcpu_timer;
-static CPUState *tcg_current_rr_cpu;
-
-#define TCG_KICK_PERIOD (NANOSECONDS_PER_SECOND / 10)
-
-static inline int64_t qemu_tcg_next_kick(void)
-{
-    return qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + TCG_KICK_PERIOD;
-}
-
-/* Kick the currently round-robin scheduled vCPU to next */
-static void qemu_cpu_kick_rr_next_cpu(void)
-{
-    CPUState *cpu;
-    do {
-        cpu = qatomic_mb_read(&tcg_current_rr_cpu);
-        if (cpu) {
-            cpu_exit(cpu);
-        }
-    } while (cpu != qatomic_mb_read(&tcg_current_rr_cpu));
-}
-
-static void kick_tcg_thread(void *opaque)
-{
-    timer_mod(tcg_kick_vcpu_timer, qemu_tcg_next_kick());
-    qemu_cpu_kick_rr_next_cpu();
-}
-
-static void start_tcg_kick_timer(void)
-{
-    assert(!mttcg_enabled);
-    if (!tcg_kick_vcpu_timer && CPU_NEXT(first_cpu)) {
-        tcg_kick_vcpu_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
-                                           kick_tcg_thread, NULL);
-    }
-    if (tcg_kick_vcpu_timer && !timer_pending(tcg_kick_vcpu_timer)) {
-        timer_mod(tcg_kick_vcpu_timer, qemu_tcg_next_kick());
-    }
-}
-
-static void stop_tcg_kick_timer(void)
-{
-    assert(!mttcg_enabled);
-    if (tcg_kick_vcpu_timer && timer_pending(tcg_kick_vcpu_timer)) {
-        timer_del(tcg_kick_vcpu_timer);
-    }
-}
-
-static void qemu_tcg_destroy_vcpu(CPUState *cpu)
-{
-}
-
-static void qemu_tcg_rr_wait_io_event(void)
-{
-    CPUState *cpu;
-
-    while (all_cpu_threads_idle()) {
-        stop_tcg_kick_timer();
-        qemu_cond_wait_iothread(first_cpu->halt_cond);
-    }
-
-    start_tcg_kick_timer();
-
-    CPU_FOREACH(cpu) {
-        qemu_wait_io_event_common(cpu);
-    }
-}
-
-static int64_t tcg_get_icount_limit(void)
-{
-    int64_t deadline;
-
-    if (replay_mode != REPLAY_MODE_PLAY) {
-        /*
-         * Include all the timers, because they may need an attention.
-         * Too long CPU execution may create unnecessary delay in UI.
-         */
-        deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL,
-                                              QEMU_TIMER_ATTR_ALL);
-        /* Check realtime timers, because they help with input processing */
-        deadline = qemu_soonest_timeout(deadline,
-                qemu_clock_deadline_ns_all(QEMU_CLOCK_REALTIME,
-                                           QEMU_TIMER_ATTR_ALL));
-
-        /*
-         * Maintain prior (possibly buggy) behaviour where if no deadline
-         * was set (as there is no QEMU_CLOCK_VIRTUAL timer) or it is more than
-         * INT32_MAX nanoseconds ahead, we still use INT32_MAX
-         * nanoseconds.
-         */
-        if ((deadline < 0) || (deadline > INT32_MAX)) {
-            deadline = INT32_MAX;
-        }
-
-        return icount_round(deadline);
-    } else {
-        return replay_get_instructions();
-    }
-}
-
-static void notify_aio_contexts(void)
-{
-    /* Wake up other AioContexts.  */
-    qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
-    qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
-}
-
-static void handle_icount_deadline(void)
-{
-    assert(qemu_in_vcpu_thread());
-    if (icount_enabled()) {
-        int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL,
-                                                      QEMU_TIMER_ATTR_ALL);
-
-        if (deadline == 0) {
-            notify_aio_contexts();
-        }
-    }
-}
-
-static void prepare_icount_for_run(CPUState *cpu)
-{
-    if (icount_enabled()) {
-        int insns_left;
-
-        /*
-         * These should always be cleared by process_icount_data after
-         * each vCPU execution. However u16.high can be raised
-         * asynchronously by cpu_exit/cpu_interrupt/tcg_handle_interrupt
-         */
-        g_assert(cpu_neg(cpu)->icount_decr.u16.low == 0);
-        g_assert(cpu->icount_extra == 0);
-
-        cpu->icount_budget = tcg_get_icount_limit();
-        insns_left = MIN(0xffff, cpu->icount_budget);
-        cpu_neg(cpu)->icount_decr.u16.low = insns_left;
-        cpu->icount_extra = cpu->icount_budget - insns_left;
-
-        replay_mutex_lock();
-
-        if (cpu->icount_budget == 0 && replay_has_checkpoint()) {
-            notify_aio_contexts();
-        }
-    }
-}
-
-static void process_icount_data(CPUState *cpu)
-{
-    if (icount_enabled()) {
-        /* Account for executed instructions */
-        icount_update(cpu);
-
-        /* Reset the counters */
-        cpu_neg(cpu)->icount_decr.u16.low = 0;
-        cpu->icount_extra = 0;
-        cpu->icount_budget = 0;
-
-        replay_account_executed_instructions();
-
-        replay_mutex_unlock();
-    }
-}
-
-static int tcg_cpu_exec(CPUState *cpu)
-{
-    int ret;
-#ifdef CONFIG_PROFILER
-    int64_t ti;
-#endif
-
-    assert(tcg_enabled());
-#ifdef CONFIG_PROFILER
-    ti = profile_getclock();
-#endif
-    cpu_exec_start(cpu);
-    ret = cpu_exec(cpu);
-    cpu_exec_end(cpu);
-#ifdef CONFIG_PROFILER
-    qatomic_set(&tcg_ctx->prof.cpu_exec_time,
-                tcg_ctx->prof.cpu_exec_time + profile_getclock() - ti);
-#endif
-    return ret;
-}
-
-/*
- * Destroy any remaining vCPUs which have been unplugged and have
- * finished running
- */
-static void deal_with_unplugged_cpus(void)
-{
-    CPUState *cpu;
-
-    CPU_FOREACH(cpu) {
-        if (cpu->unplug && !cpu_can_run(cpu)) {
-            qemu_tcg_destroy_vcpu(cpu);
-            cpu_thread_signal_destroyed(cpu);
-            break;
-        }
-    }
-}
-
-/*
- * Single-threaded TCG
- *
- * In the single-threaded case each vCPU is simulated in turn. If
- * there is more than a single vCPU we create a simple timer to kick
- * the vCPU and ensure we don't get stuck in a tight loop in one vCPU.
- * This is done explicitly rather than relying on side-effects
- * elsewhere.
- */
-
-static void *tcg_rr_cpu_thread_fn(void *arg)
-{
-    CPUState *cpu = arg;
-
-    assert(tcg_enabled());
-    rcu_register_thread();
-    tcg_register_thread();
-
-    qemu_mutex_lock_iothread();
-    qemu_thread_get_self(cpu->thread);
-
-    cpu->thread_id = qemu_get_thread_id();
-    cpu->can_do_io = 1;
-    cpu_thread_signal_created(cpu);
-    qemu_guest_random_seed_thread_part2(cpu->random_seed);
-
-    /* wait for initial kick-off after machine start */
-    while (first_cpu->stopped) {
-        qemu_cond_wait_iothread(first_cpu->halt_cond);
-
-        /* process any pending work */
-        CPU_FOREACH(cpu) {
-            current_cpu = cpu;
-            qemu_wait_io_event_common(cpu);
-        }
-    }
-
-    start_tcg_kick_timer();
-
-    cpu = first_cpu;
-
-    /* process any pending work */
-    cpu->exit_request = 1;
-
-    while (1) {
-        qemu_mutex_unlock_iothread();
-        replay_mutex_lock();
-        qemu_mutex_lock_iothread();
-        /* Account partial waits to QEMU_CLOCK_VIRTUAL.  */
-        icount_account_warp_timer();
-
-        /*
-         * Run the timers here.  This is much more efficient than
-         * waking up the I/O thread and waiting for completion.
-         */
-        handle_icount_deadline();
-
-        replay_mutex_unlock();
-
-        if (!cpu) {
-            cpu = first_cpu;
-        }
-
-        while (cpu && cpu_work_list_empty(cpu) && !cpu->exit_request) {
-
-            qatomic_mb_set(&tcg_current_rr_cpu, cpu);
-            current_cpu = cpu;
-
-            qemu_clock_enable(QEMU_CLOCK_VIRTUAL,
-                              (cpu->singlestep_enabled & SSTEP_NOTIMER) == 0);
-
-            if (cpu_can_run(cpu)) {
-                int r;
-
-                qemu_mutex_unlock_iothread();
-                prepare_icount_for_run(cpu);
-
-                r = tcg_cpu_exec(cpu);
-
-                process_icount_data(cpu);
-                qemu_mutex_lock_iothread();
-
-                if (r == EXCP_DEBUG) {
-                    cpu_handle_guest_debug(cpu);
-                    break;
-                } else if (r == EXCP_ATOMIC) {
-                    qemu_mutex_unlock_iothread();
-                    cpu_exec_step_atomic(cpu);
-                    qemu_mutex_lock_iothread();
-                    break;
-                }
-            } else if (cpu->stop) {
-                if (cpu->unplug) {
-                    cpu = CPU_NEXT(cpu);
-                }
-                break;
-            }
-
-            cpu = CPU_NEXT(cpu);
-        } /* while (cpu && !cpu->exit_request).. */
-
-        /* Does not need qatomic_mb_set because a spurious wakeup is okay.  */
-        qatomic_set(&tcg_current_rr_cpu, NULL);
-
-        if (cpu && cpu->exit_request) {
-            qatomic_mb_set(&cpu->exit_request, 0);
-        }
-
-        if (icount_enabled() && all_cpu_threads_idle()) {
-            /*
-             * When all cpus are sleeping (e.g in WFI), to avoid a deadlock
-             * in the main_loop, wake it up in order to start the warp timer.
-             */
-            qemu_notify_event();
-        }
-
-        qemu_tcg_rr_wait_io_event();
-        deal_with_unplugged_cpus();
-    }
-
-    rcu_unregister_thread();
-    return NULL;
-}
-
-/*
- * Multi-threaded TCG
- *
- * In the multi-threaded case each vCPU has its own thread. The TLS
- * variable current_cpu can be used deep in the code to find the
- * current CPUState for a given thread.
- */
-
-static void *tcg_cpu_thread_fn(void *arg)
-{
-    CPUState *cpu = arg;
-
-    assert(tcg_enabled());
-    g_assert(!icount_enabled());
-
-    rcu_register_thread();
-    tcg_register_thread();
-
-    qemu_mutex_lock_iothread();
-    qemu_thread_get_self(cpu->thread);
-
-    cpu->thread_id = qemu_get_thread_id();
-    cpu->can_do_io = 1;
-    current_cpu = cpu;
-    cpu_thread_signal_created(cpu);
-    qemu_guest_random_seed_thread_part2(cpu->random_seed);
-
-    /* process any pending work */
-    cpu->exit_request = 1;
-
-    do {
-        if (cpu_can_run(cpu)) {
-            int r;
-            qemu_mutex_unlock_iothread();
-            r = tcg_cpu_exec(cpu);
-            qemu_mutex_lock_iothread();
-            switch (r) {
-            case EXCP_DEBUG:
-                cpu_handle_guest_debug(cpu);
-                break;
-            case EXCP_HALTED:
-                /*
-                 * during start-up the vCPU is reset and the thread is
-                 * kicked several times. If we don't ensure we go back
-                 * to sleep in the halted state we won't cleanly
-                 * start-up when the vCPU is enabled.
-                 *
-                 * cpu->halted should ensure we sleep in wait_io_event
-                 */
-                g_assert(cpu->halted);
-                break;
-            case EXCP_ATOMIC:
-                qemu_mutex_unlock_iothread();
-                cpu_exec_step_atomic(cpu);
-                qemu_mutex_lock_iothread();
-            default:
-                /* Ignore everything else? */
-                break;
-            }
-        }
-
-        qatomic_mb_set(&cpu->exit_request, 0);
-        qemu_wait_io_event(cpu);
-    } while (!cpu->unplug || cpu_can_run(cpu));
-
-    qemu_tcg_destroy_vcpu(cpu);
-    cpu_thread_signal_destroyed(cpu);
-    qemu_mutex_unlock_iothread();
-    rcu_unregister_thread();
-    return NULL;
-}
-
-static void tcg_start_vcpu_thread(CPUState *cpu)
+void tcg_start_vcpu_thread(CPUState *cpu)
 {
     char thread_name[VCPU_THREAD_NAME_SIZE];
     static QemuCond *single_tcg_halt_cond;
@@ -XXX,XX +XXX,XX @@ static void tcg_start_vcpu_thread(CPUState *cpu)
     }
 }
 
-static int64_t tcg_get_virtual_clock(void)
+void qemu_tcg_destroy_vcpu(CPUState *cpu)
 {
-    if (icount_enabled()) {
-        return icount_get();
-    }
-    return cpu_get_clock();
+    cpu_thread_signal_destroyed(cpu);
 }
 
-static int64_t tcg_get_elapsed_ticks(void)
+int tcg_cpu_exec(CPUState *cpu)
 {
-    if (icount_enabled()) {
-        return icount_get();
-    }
-    return cpu_get_ticks();
+    int ret;
+#ifdef CONFIG_PROFILER
+    int64_t ti;
+#endif
+    assert(tcg_enabled());
+#ifdef CONFIG_PROFILER
+    ti = profile_getclock();
+#endif
+    cpu_exec_start(cpu);
+    ret = cpu_exec(cpu);
+    cpu_exec_end(cpu);
+#ifdef CONFIG_PROFILER
+    qatomic_set(&tcg_ctx->prof.cpu_exec_time,
+                tcg_ctx->prof.cpu_exec_time + profile_getclock() - ti);
+#endif
+    return ret;
 }
 
 /* mask must never be zero, except for A20 change call */
-static void tcg_handle_interrupt(CPUState *cpu, int mask)
+void tcg_handle_interrupt(CPUState *cpu, int mask)
 {
-    int old_mask;
     g_assert(qemu_mutex_iothread_locked());
 
-    old_mask = cpu->interrupt_request;
     cpu->interrupt_request |= mask;
 
     /*
@@ -XXX,XX +XXX,XX @@ static void tcg_handle_interrupt(CPUState *cpu, int mask)
         qemu_cpu_kick(cpu);
     } else {
         qatomic_set(&cpu_neg(cpu)->icount_decr.u16.high, -1);
-        if (icount_enabled() &&
-            !cpu->can_do_io
-            && (mask & ~old_mask) != 0) {
-            cpu_abort(cpu, "Raised interrupt while not in I/O function");
-        }
     }
 }
-
-const CpusAccel tcg_cpus = {
-    .create_vcpu_thread = tcg_start_vcpu_thread,
-    .kick_vcpu_thread = tcg_kick_vcpu_thread,
-
-    .handle_interrupt = tcg_handle_interrupt,
-
-    .get_virtual_clock = tcg_get_virtual_clock,
-    .get_elapsed_ticks = tcg_get_elapsed_ticks,
-};
diff --git a/softmmu/icount.c b/softmmu/icount.c
index XXXXXXX..XXXXXXX 100644
--- a/softmmu/icount.c
+++ b/softmmu/icount.c
@@ -XXX,XX +XXX,XX @@ void icount_start_warp_timer(void)
 
 void icount_account_warp_timer(void)
 {
-    if (!icount_enabled() || !icount_sleep) {
+    if (!icount_sleep) {
         return;
     }
 
diff --git a/accel/tcg/meson.build b/accel/tcg/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/accel/tcg/meson.build
+++ b/accel/tcg/meson.build
@@ -XXX,XX +XXX,XX @@ tcg_ss.add(when: 'CONFIG_SOFTMMU', if_false: files('user-exec-stub.c'))
 tcg_ss.add(when: 'CONFIG_PLUGIN', if_true: [files('plugin-gen.c'), libdl])
 specific_ss.add_all(when: 'CONFIG_TCG', if_true: tcg_ss)
 
-specific_ss.add(when: ['CONFIG_SOFTMMU', 'CONFIG_TCG'], if_true: files('tcg-all.c', 'cputlb.c', 'tcg-cpus.c'))
+specific_ss.add(when: ['CONFIG_SOFTMMU', 'CONFIG_TCG'], if_true: files(
+  'tcg-all.c',
+  'cputlb.c',
+  'tcg-cpus.c',
+  'tcg-cpus-mttcg.c',
+  'tcg-cpus-icount.c',
+  'tcg-cpus-rr.c'
+))
-- 
2.25.1

From: Claudio Fontana <cfontana@suse.de>

after the initial split into 3 tcg variants, we proceed to also
split tcg_start_vcpu_thread.

We actually split it in 2 this time, since the icount variant
just uses the round robin function.

Suggested-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: Claudio Fontana <cfontana@suse.de>
Message-Id: <20201015143217.29337-3-cfontana@suse.de>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 accel/tcg/tcg-cpus-mttcg.h  | 21 --------------
 accel/tcg/tcg-cpus-rr.h     |  3 +-
 accel/tcg/tcg-cpus.h        |  1 -
 accel/tcg/tcg-all.c         |  5 ++++
 accel/tcg/tcg-cpus-icount.c |  2 +-
 accel/tcg/tcg-cpus-mttcg.c  | 29 +++++++++++++++++--
 accel/tcg/tcg-cpus-rr.c     | 39 +++++++++++++++++++++++--
 accel/tcg/tcg-cpus.c        | 58 -------------------------------------
 8 files changed, 71 insertions(+), 87 deletions(-)
 delete mode 100644 accel/tcg/tcg-cpus-mttcg.h

diff --git a/accel/tcg/tcg-cpus-mttcg.h b/accel/tcg/tcg-cpus-mttcg.h
deleted file mode 100644
index XXXXXXX..XXXXXXX
--- a/accel/tcg/tcg-cpus-mttcg.h
+++ /dev/null
@@ -XXX,XX +XXX,XX @@
-/*
- * QEMU TCG Multi Threaded vCPUs implementation
- *
- * Copyright 2020 SUSE LLC
- *
- * This work is licensed under the terms of the GNU GPL, version 2 or later.
- * See the COPYING file in the top-level directory.
- */
-
-#ifndef TCG_CPUS_MTTCG_H
-#define TCG_CPUS_MTTCG_H
-
-/*
- * In the multi-threaded case each vCPU has its own thread. The TLS
- * variable current_cpu can be used deep in the code to find the
- * current CPUState for a given thread.
- */
-
-void *tcg_cpu_thread_fn(void *arg);
-
-#endif /* TCG_CPUS_MTTCG_H */
diff --git a/accel/tcg/tcg-cpus-rr.h b/accel/tcg/tcg-cpus-rr.h
index XXXXXXX..XXXXXXX 100644
--- a/accel/tcg/tcg-cpus-rr.h
+++ b/accel/tcg/tcg-cpus-rr.h
@@ -XXX,XX +XXX,XX @@
 /* Kick all RR vCPUs. */
 void qemu_cpu_kick_rr_cpus(CPUState *unused);
 
-void *tcg_rr_cpu_thread_fn(void *arg);
+/* start the round robin vcpu thread */
+void rr_start_vcpu_thread(CPUState *cpu);
 
 #endif /* TCG_CPUS_RR_H */
diff --git a/accel/tcg/tcg-cpus.h b/accel/tcg/tcg-cpus.h
index XXXXXXX..XXXXXXX 100644
--- a/accel/tcg/tcg-cpus.h
+++ b/accel/tcg/tcg-cpus.h
@@ -XXX,XX +XXX,XX @@ extern const CpusAccel tcg_cpus_mttcg;
 extern const CpusAccel tcg_cpus_icount;
 extern const CpusAccel tcg_cpus_rr;
 
-void tcg_start_vcpu_thread(CPUState *cpu);
 void qemu_tcg_destroy_vcpu(CPUState *cpu);
 int tcg_cpu_exec(CPUState *cpu);
 void tcg_handle_interrupt(CPUState *cpu, int mask);
diff --git a/accel/tcg/tcg-all.c b/accel/tcg/tcg-all.c
index XXXXXXX..XXXXXXX 100644
--- a/accel/tcg/tcg-all.c
+++ b/accel/tcg/tcg-all.c
@@ -XXX,XX +XXX,XX @@ static int tcg_init(MachineState *ms)
     tcg_exec_init(s->tb_size * 1024 * 1024);
     mttcg_enabled = s->mttcg_enabled;
 
+    /*
+     * Initialize TCG regions
+     */
+    tcg_region_init();
+
     if (mttcg_enabled) {
         cpus_register_accel(&tcg_cpus_mttcg);
     } else if (icount_enabled()) {
diff --git a/accel/tcg/tcg-cpus-icount.c b/accel/tcg/tcg-cpus-icount.c
index XXXXXXX..XXXXXXX 100644
--- a/accel/tcg/tcg-cpus-icount.c
+++ b/accel/tcg/tcg-cpus-icount.c
@@ -XXX,XX +XXX,XX @@ static void icount_handle_interrupt(CPUState *cpu, int mask)
 }
 
 const CpusAccel tcg_cpus_icount = {
-    .create_vcpu_thread = tcg_start_vcpu_thread,
+    .create_vcpu_thread = rr_start_vcpu_thread,
     .kick_vcpu_thread = qemu_cpu_kick_rr_cpus,
 
     .handle_interrupt = icount_handle_interrupt,
diff --git a/accel/tcg/tcg-cpus-mttcg.c b/accel/tcg/tcg-cpus-mttcg.c
index XXXXXXX..XXXXXXX 100644
--- a/accel/tcg/tcg-cpus-mttcg.c
+++ b/accel/tcg/tcg-cpus-mttcg.c
@@ -XXX,XX +XXX,XX @@
 #include "hw/boards.h"
 
 #include "tcg-cpus.h"
-#include "tcg-cpus-mttcg.h"
 
 /*
  * In the multi-threaded case each vCPU has its own thread. The TLS
@@ -XXX,XX +XXX,XX @@
  * current CPUState for a given thread.
  */
 
-void *tcg_cpu_thread_fn(void *arg)
+static void *tcg_cpu_thread_fn(void *arg)
 {
     CPUState *cpu = arg;
 
@@ -XXX,XX +XXX,XX @@ static void mttcg_kick_vcpu_thread(CPUState *cpu)
     cpu_exit(cpu);
 }
 
+static void mttcg_start_vcpu_thread(CPUState *cpu)
+{
+    char thread_name[VCPU_THREAD_NAME_SIZE];
+
+    g_assert(tcg_enabled());
+
+    parallel_cpus = (current_machine->smp.max_cpus > 1);
+
+    cpu->thread = g_malloc0(sizeof(QemuThread));
+    cpu->halt_cond = g_malloc0(sizeof(QemuCond));
+    qemu_cond_init(cpu->halt_cond);
+
+    /* create a thread per vCPU with TCG (MTTCG) */
+    snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/TCG",
+             cpu->cpu_index);
+
+    qemu_thread_create(cpu->thread, thread_name, tcg_cpu_thread_fn,
+                       cpu, QEMU_THREAD_JOINABLE);
+
+#ifdef _WIN32
+    cpu->hThread = qemu_thread_get_handle(cpu->thread);
+#endif
+}
+
 const CpusAccel tcg_cpus_mttcg = {
-    .create_vcpu_thread = tcg_start_vcpu_thread,
+    .create_vcpu_thread = mttcg_start_vcpu_thread,
     .kick_vcpu_thread = mttcg_kick_vcpu_thread,
 
     .handle_interrupt = tcg_handle_interrupt,
diff --git a/accel/tcg/tcg-cpus-rr.c b/accel/tcg/tcg-cpus-rr.c
index XXXXXXX..XXXXXXX 100644
--- a/accel/tcg/tcg-cpus-rr.c
+++ b/accel/tcg/tcg-cpus-rr.c
@@ -XXX,XX +XXX,XX @@ static void deal_with_unplugged_cpus(void)
  * elsewhere.
  */
 
-void *tcg_rr_cpu_thread_fn(void *arg)
+static void *tcg_rr_cpu_thread_fn(void *arg)
 {
     CPUState *cpu = arg;
 
@@ -XXX,XX +XXX,XX @@ void *tcg_rr_cpu_thread_fn(void *arg)
     return NULL;
 }
 
+void rr_start_vcpu_thread(CPUState *cpu)
+{
+    char thread_name[VCPU_THREAD_NAME_SIZE];
+    static QemuCond *single_tcg_halt_cond;
+    static QemuThread *single_tcg_cpu_thread;
+
+    g_assert(tcg_enabled());
+    parallel_cpus = false;
+
+    if (!single_tcg_cpu_thread) {
+        cpu->thread = g_malloc0(sizeof(QemuThread));
+        cpu->halt_cond = g_malloc0(sizeof(QemuCond));
+        qemu_cond_init(cpu->halt_cond);
+
+        /* share a single thread for all cpus with TCG */
+        snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "ALL CPUs/TCG");
+        qemu_thread_create(cpu->thread, thread_name,
+                           tcg_rr_cpu_thread_fn,
+                           cpu, QEMU_THREAD_JOINABLE);
+
+        single_tcg_halt_cond = cpu->halt_cond;
+        single_tcg_cpu_thread = cpu->thread;
+#ifdef _WIN32
+        cpu->hThread = qemu_thread_get_handle(cpu->thread);
+#endif
+    } else {
+        /* we share the thread */
+        cpu->thread = single_tcg_cpu_thread;
+        cpu->halt_cond = single_tcg_halt_cond;
+        cpu->thread_id = first_cpu->thread_id;
+        cpu->can_do_io = 1;
+        cpu->created = true;
+    }
+}
+
 const CpusAccel tcg_cpus_rr = {
-    .create_vcpu_thread = tcg_start_vcpu_thread,
+    .create_vcpu_thread = rr_start_vcpu_thread,
     .kick_vcpu_thread = qemu_cpu_kick_rr_cpus,
 
     .handle_interrupt = tcg_handle_interrupt,
diff --git a/accel/tcg/tcg-cpus.c b/accel/tcg/tcg-cpus.c
index XXXXXXX..XXXXXXX 100644
--- a/accel/tcg/tcg-cpus.c
+++ b/accel/tcg/tcg-cpus.c
@@ -XXX,XX +XXX,XX @@
 #include "hw/boards.h"
 
 #include "tcg-cpus.h"
-#include "tcg-cpus-mttcg.h"
-#include "tcg-cpus-rr.h"
 
 /* common functionality among all TCG variants */
 
-void tcg_start_vcpu_thread(CPUState *cpu)
-{
-    char thread_name[VCPU_THREAD_NAME_SIZE];
-    static QemuCond *single_tcg_halt_cond;
-    static QemuThread *single_tcg_cpu_thread;
-    static int tcg_region_inited;
-
-    assert(tcg_enabled());
-    /*
-     * Initialize TCG regions--once. Now is a good time, because:
-     * (1) TCG's init context, prologue and target globals have been set up.
-     * (2) qemu_tcg_mttcg_enabled() works now (TCG init code runs before the
-     *     -accel flag is processed, so the check doesn't work then).
-     */
-    if (!tcg_region_inited) {
-        tcg_region_inited = 1;
-        tcg_region_init();
-        parallel_cpus = qemu_tcg_mttcg_enabled() && current_machine->smp.max_cpus > 1;
-    }
-
-    if (qemu_tcg_mttcg_enabled() || !single_tcg_cpu_thread) {
-        cpu->thread = g_malloc0(sizeof(QemuThread));
-        cpu->halt_cond = g_malloc0(sizeof(QemuCond));
-        qemu_cond_init(cpu->halt_cond);
-
-        if (qemu_tcg_mttcg_enabled()) {
-            /* create a thread per vCPU with TCG (MTTCG) */
-            snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/TCG",
-                 cpu->cpu_index);
-
-            qemu_thread_create(cpu->thread, thread_name, tcg_cpu_thread_fn,
-                               cpu, QEMU_THREAD_JOINABLE);
-
-        } else {
-            /* share a single thread for all cpus with TCG */
-            snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "ALL CPUs/TCG");
-            qemu_thread_create(cpu->thread, thread_name,
-                               tcg_rr_cpu_thread_fn,
-                               cpu, QEMU_THREAD_JOINABLE);
-
-            single_tcg_halt_cond = cpu->halt_cond;
-            single_tcg_cpu_thread = cpu->thread;
-        }
-#ifdef _WIN32
-        cpu->hThread = qemu_thread_get_handle(cpu->thread);
-#endif
-    } else {
-        /* For non-MTTCG cases we share the thread */
-        cpu->thread = single_tcg_cpu_thread;
-        cpu->halt_cond = single_tcg_halt_cond;
-        cpu->thread_id = first_cpu->thread_id;
-        cpu->can_do_io = 1;
-        cpu->created = true;
-    }
-}
-
 void qemu_tcg_destroy_vcpu(CPUState *cpu)
 {
     cpu_thread_signal_destroyed(cpu);
-- 
2.25.1

From: Claudio Fontana <cfontana@suse.de>

Signed-off-by: Claudio Fontana <cfontana@suse.de>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Message-Id: <20201015143217.29337-4-cfontana@suse.de>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 accel/tcg/tcg-cpus-icount.h |  6 +--
 accel/tcg/tcg-cpus-rr.h     |  2 +-
 accel/tcg/tcg-cpus.h        |  6 +--
 accel/tcg/tcg-cpus-icount.c | 24 ++++++------
 accel/tcg/tcg-cpus-mttcg.c  | 10 ++---
 accel/tcg/tcg-cpus-rr.c     | 74 ++++++++++++++++++-------------------
 accel/tcg/tcg-cpus.c        |  6 +--
 7 files changed, 64 insertions(+), 64 deletions(-)

diff --git a/accel/tcg/tcg-cpus-icount.h b/accel/tcg/tcg-cpus-icount.h
index XXXXXXX..XXXXXXX 100644
--- a/accel/tcg/tcg-cpus-icount.h
+++ b/accel/tcg/tcg-cpus-icount.h
@@ -XXX,XX +XXX,XX @@
 #ifndef TCG_CPUS_ICOUNT_H
 #define TCG_CPUS_ICOUNT_H
 
-void handle_icount_deadline(void);
-void prepare_icount_for_run(CPUState *cpu);
-void process_icount_data(CPUState *cpu);
+void icount_handle_deadline(void);
+void icount_prepare_for_run(CPUState *cpu);
+void icount_process_data(CPUState *cpu);
 
 #endif /* TCG_CPUS_ICOUNT_H */
diff --git a/accel/tcg/tcg-cpus-rr.h b/accel/tcg/tcg-cpus-rr.h
index XXXXXXX..XXXXXXX 100644
--- a/accel/tcg/tcg-cpus-rr.h
+++ b/accel/tcg/tcg-cpus-rr.h
@@ -XXX,XX +XXX,XX @@
 #define TCG_KICK_PERIOD (NANOSECONDS_PER_SECOND / 10)
 
 /* Kick all RR vCPUs. */
-void qemu_cpu_kick_rr_cpus(CPUState *unused);
+void rr_kick_vcpu_thread(CPUState *unused);
 
 /* start the round robin vcpu thread */
 void rr_start_vcpu_thread(CPUState *cpu);
diff --git a/accel/tcg/tcg-cpus.h b/accel/tcg/tcg-cpus.h
index XXXXXXX..XXXXXXX 100644
--- a/accel/tcg/tcg-cpus.h
+++ b/accel/tcg/tcg-cpus.h
@@ -XXX,XX +XXX,XX @@ extern const CpusAccel tcg_cpus_mttcg;
 extern const CpusAccel tcg_cpus_icount;
 extern const CpusAccel tcg_cpus_rr;
 
-void qemu_tcg_destroy_vcpu(CPUState *cpu);
-int tcg_cpu_exec(CPUState *cpu);
-void tcg_handle_interrupt(CPUState *cpu, int mask);
+void tcg_cpus_destroy(CPUState *cpu);
+int tcg_cpus_exec(CPUState *cpu);
+void tcg_cpus_handle_interrupt(CPUState *cpu, int mask);
 
 #endif /* TCG_CPUS_H */
diff --git a/accel/tcg/tcg-cpus-icount.c b/accel/tcg/tcg-cpus-icount.c
index XXXXXXX..XXXXXXX 100644
--- a/accel/tcg/tcg-cpus-icount.c
+++ b/accel/tcg/tcg-cpus-icount.c
@@ -XXX,XX +XXX,XX @@
 #include "tcg-cpus-icount.h"
 #include "tcg-cpus-rr.h"
 
-static int64_t tcg_get_icount_limit(void)
+static int64_t icount_get_limit(void)
 {
     int64_t deadline;
 
@@ -XXX,XX +XXX,XX @@ static int64_t tcg_get_icount_limit(void)
     }
 }
 
-static void notify_aio_contexts(void)
+static void icount_notify_aio_contexts(void)
 {
     /* Wake up other AioContexts.  */
     qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
     qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
 }
 
-void handle_icount_deadline(void)
+void icount_handle_deadline(void)
 {
     assert(qemu_in_vcpu_thread());
     int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL,
                                                   QEMU_TIMER_ATTR_ALL);
 
     if (deadline == 0) {
-        notify_aio_contexts();
+        icount_notify_aio_contexts();
     }
 }
 
-void prepare_icount_for_run(CPUState *cpu)
+void icount_prepare_for_run(CPUState *cpu)
 {
     int insns_left;
 
     /*
-     * These should always be cleared by process_icount_data after
+     * These should always be cleared by icount_process_data after
      * each vCPU execution. However u16.high can be raised
-     * asynchronously by cpu_exit/cpu_interrupt/tcg_handle_interrupt
+     * asynchronously by cpu_exit/cpu_interrupt/tcg_cpus_handle_interrupt
      */
     g_assert(cpu_neg(cpu)->icount_decr.u16.low == 0);
     g_assert(cpu->icount_extra == 0);
 
-    cpu->icount_budget = tcg_get_icount_limit();
+    cpu->icount_budget = icount_get_limit();
     insns_left = MIN(0xffff, cpu->icount_budget);
     cpu_neg(cpu)->icount_decr.u16.low = insns_left;
     cpu->icount_extra = cpu->icount_budget - insns_left;
@@ -XXX,XX +XXX,XX @@ void prepare_icount_for_run(CPUState *cpu)
     replay_mutex_lock();
 
     if (cpu->icount_budget == 0 && replay_has_checkpoint()) {
-        notify_aio_contexts();
+        icount_notify_aio_contexts();
     }
 }
 
-void process_icount_data(CPUState *cpu)
+void icount_process_data(CPUState *cpu)
 {
     /* Account for executed instructions */
     icount_update(cpu);
@@ -XXX,XX +XXX,XX @@ static void icount_handle_interrupt(CPUState *cpu, int mask)
 {
     int old_mask = cpu->interrupt_request;
 
-    tcg_handle_interrupt(cpu, mask);
+    tcg_cpus_handle_interrupt(cpu, mask);
     if (qemu_cpu_is_self(cpu) &&
         !cpu->can_do_io
         && (mask & ~old_mask) != 0) {
@@ -XXX,XX +XXX,XX @@ static void icount_handle_interrupt(CPUState *cpu, int mask)
 
 const CpusAccel tcg_cpus_icount = {
     .create_vcpu_thread = rr_start_vcpu_thread,
-    .kick_vcpu_thread = qemu_cpu_kick_rr_cpus,
+    .kick_vcpu_thread = rr_kick_vcpu_thread,
 
     .handle_interrupt = icount_handle_interrupt,
     .get_virtual_clock = icount_get,
diff --git a/accel/tcg/tcg-cpus-mttcg.c b/accel/tcg/tcg-cpus-mttcg.c
index XXXXXXX..XXXXXXX 100644
--- a/accel/tcg/tcg-cpus-mttcg.c
+++ b/accel/tcg/tcg-cpus-mttcg.c
@@ -XXX,XX +XXX,XX @@
  * current CPUState for a given thread.
  */
 
-static void *tcg_cpu_thread_fn(void *arg)
+static void *mttcg_cpu_thread_fn(void *arg)
 {
     CPUState *cpu = arg;
 
@@ -XXX,XX +XXX,XX @@ static void *tcg_cpu_thread_fn(void *arg)
         if (cpu_can_run(cpu)) {
             int r;
             qemu_mutex_unlock_iothread();
-            r = tcg_cpu_exec(cpu);
+            r = tcg_cpus_exec(cpu);
             qemu_mutex_lock_iothread();
             switch (r) {
             case EXCP_DEBUG:
@@ -XXX,XX +XXX,XX @@ static void *tcg_cpu_thread_fn(void *arg)
         qemu_wait_io_event(cpu);
     } while (!cpu->unplug || cpu_can_run(cpu));
 
-    qemu_tcg_destroy_vcpu(cpu);
+    tcg_cpus_destroy(cpu);
     qemu_mutex_unlock_iothread();
     rcu_unregister_thread();
     return NULL;
@@ -XXX,XX +XXX,XX @@ static void mttcg_start_vcpu_thread(CPUState *cpu)
     snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/TCG",
              cpu->cpu_index);
 
-    qemu_thread_create(cpu->thread, thread_name, tcg_cpu_thread_fn,
+    qemu_thread_create(cpu->thread, thread_name, mttcg_cpu_thread_fn,
                        cpu, QEMU_THREAD_JOINABLE);
 
 #ifdef _WIN32
@@ -XXX,XX +XXX,XX @@ const CpusAccel tcg_cpus_mttcg = {
     .create_vcpu_thread = mttcg_start_vcpu_thread,
     .kick_vcpu_thread = mttcg_kick_vcpu_thread,
 
-    .handle_interrupt = tcg_handle_interrupt,
+    .handle_interrupt = tcg_cpus_handle_interrupt,
 };
diff --git a/accel/tcg/tcg-cpus-rr.c b/accel/tcg/tcg-cpus-rr.c
index XXXXXXX..XXXXXXX 100644
--- a/accel/tcg/tcg-cpus-rr.c
+++ b/accel/tcg/tcg-cpus-rr.c
@@ -XXX,XX +XXX,XX @@
 #include "tcg-cpus-icount.h"
 
 /* Kick all RR vCPUs */
-void qemu_cpu_kick_rr_cpus(CPUState *unused)
+void rr_kick_vcpu_thread(CPUState *unused)
 {
     CPUState *cpu;
 
@@ -XXX,XX +XXX,XX @@ void qemu_cpu_kick_rr_cpus(CPUState *unused)
  * idleness is complete.
  */
 
-static QEMUTimer *tcg_kick_vcpu_timer;
-static CPUState *tcg_current_rr_cpu;
+static QEMUTimer *rr_kick_vcpu_timer;
+static CPUState *rr_current_cpu;
 
 #define TCG_KICK_PERIOD (NANOSECONDS_PER_SECOND / 10)
 
-static inline int64_t qemu_tcg_next_kick(void)
+static inline int64_t rr_next_kick_time(void)
 {
     return qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + TCG_KICK_PERIOD;
 }
 
 /* Kick the currently round-robin scheduled vCPU to next */
-static void qemu_cpu_kick_rr_next_cpu(void)
+static void rr_kick_next_cpu(void)
 {
     CPUState *cpu;
     do {
-        cpu = qatomic_mb_read(&tcg_current_rr_cpu);
+        cpu = qatomic_mb_read(&rr_current_cpu);
         if (cpu) {
             cpu_exit(cpu);
         }
-    } while (cpu != qatomic_mb_read(&tcg_current_rr_cpu));
+    } while (cpu != qatomic_mb_read(&rr_current_cpu));
 }
 
-static void kick_tcg_thread(void *opaque)
+static void rr_kick_thread(void *opaque)
 {
-    timer_mod(tcg_kick_vcpu_timer, qemu_tcg_next_kick());
-    qemu_cpu_kick_rr_next_cpu();
+    timer_mod(rr_kick_vcpu_timer, rr_next_kick_time());
+    rr_kick_next_cpu();
 }
 
-static void start_tcg_kick_timer(void)
+static void rr_start_kick_timer(void)
 {
-    if (!tcg_kick_vcpu_timer && CPU_NEXT(first_cpu)) {
-        tcg_kick_vcpu_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
-                                           kick_tcg_thread, NULL);
+    if (!rr_kick_vcpu_timer && CPU_NEXT(first_cpu)) {
+        rr_kick_vcpu_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
+                                           rr_kick_thread, NULL);
     }
-    if (tcg_kick_vcpu_timer && !timer_pending(tcg_kick_vcpu_timer)) {
-        timer_mod(tcg_kick_vcpu_timer, qemu_tcg_next_kick());
+    if (rr_kick_vcpu_timer && !timer_pending(rr_kick_vcpu_timer)) {
+        timer_mod(rr_kick_vcpu_timer, rr_next_kick_time());
     }
 }
 
-static void stop_tcg_kick_timer(void)
+static void rr_stop_kick_timer(void)
 {
-    if (tcg_kick_vcpu_timer && timer_pending(tcg_kick_vcpu_timer)) {
-        timer_del(tcg_kick_vcpu_timer);
+    if (rr_kick_vcpu_timer && timer_pending(rr_kick_vcpu_timer)) {
+        timer_del(rr_kick_vcpu_timer);
     }
 }
 
-static void qemu_tcg_rr_wait_io_event(void)
+static void rr_wait_io_event(void)
 {
     CPUState *cpu;
 
     while (all_cpu_threads_idle()) {
-        stop_tcg_kick_timer();
+        rr_stop_kick_timer();
         qemu_cond_wait_iothread(first_cpu->halt_cond);
     }
 
-    start_tcg_kick_timer();
+    rr_start_kick_timer();
 
     CPU_FOREACH(cpu) {
         qemu_wait_io_event_common(cpu);
@@ -XXX,XX +XXX,XX @@ static void qemu_tcg_rr_wait_io_event(void)
  * Destroy any remaining vCPUs which have been unplugged and have
  * finished running
  */
-static void deal_with_unplugged_cpus(void)
+static void rr_deal_with_unplugged_cpus(void)
 {
     CPUState *cpu;
 
     CPU_FOREACH(cpu) {
         if (cpu->unplug && !cpu_can_run(cpu)) {
-            qemu_tcg_destroy_vcpu(cpu);
+            tcg_cpus_destroy(cpu);
             break;
         }
     }
@@ -XXX,XX +XXX,XX @@ static void deal_with_unplugged_cpus(void)
  * elsewhere.
  */
 
-static void *tcg_rr_cpu_thread_fn(void *arg)
+static void *rr_cpu_thread_fn(void *arg)
 {
     CPUState *cpu = arg;
 
@@ -XXX,XX +XXX,XX @@ static void *tcg_rr_cpu_thread_fn(void *arg)
         }
     }
 
-    start_tcg_kick_timer();
+    rr_start_kick_timer();
 
     cpu = first_cpu;
 
@@ -XXX,XX +XXX,XX @@ static void *tcg_rr_cpu_thread_fn(void *arg)
              * Run the timers here.  This is much more efficient than
              * waking up the I/O thread and waiting for completion.
              */
-            handle_icount_deadline();
+            icount_handle_deadline();
         }
 
         replay_mutex_unlock();
@@ -XXX,XX +XXX,XX @@ static void *tcg_rr_cpu_thread_fn(void *arg)
 
         while (cpu && cpu_work_list_empty(cpu) && !cpu->exit_request) {
 
-            qatomic_mb_set(&tcg_current_rr_cpu, cpu);
+            qatomic_mb_set(&rr_current_cpu, cpu);
             current_cpu = cpu;
 
             qemu_clock_enable(QEMU_CLOCK_VIRTUAL,
@@ -XXX,XX +XXX,XX @@ static void *tcg_rr_cpu_thread_fn(void *arg)
 
                 qemu_mutex_unlock_iothread();
                 if (icount_enabled()) {
-                    prepare_icount_for_run(cpu);
+                    icount_prepare_for_run(cpu);
                 }
-                r = tcg_cpu_exec(cpu);
+                r = tcg_cpus_exec(cpu);
                 if (icount_enabled()) {
-                    process_icount_data(cpu);
+                    icount_process_data(cpu);
                 }
                 qemu_mutex_lock_iothread();
 
@@ -XXX,XX +XXX,XX @@ static void *tcg_rr_cpu_thread_fn(void *arg)
         } /* while (cpu && !cpu->exit_request).. */
 
         /* Does not need qatomic_mb_set because a spurious wakeup is okay.  */
-        qatomic_set(&tcg_current_rr_cpu, NULL);
+        qatomic_set(&rr_current_cpu, NULL);
 
         if (cpu && cpu->exit_request) {
             qatomic_mb_set(&cpu->exit_request, 0);
@@ -XXX,XX +XXX,XX @@ static void *tcg_rr_cpu_thread_fn(void *arg)
             qemu_notify_event();
         }
 
-        qemu_tcg_rr_wait_io_event();
-        deal_with_unplugged_cpus();
+        rr_wait_io_event();
+        rr_deal_with_unplugged_cpus();
     }
 
     rcu_unregister_thread();
@@ -XXX,XX +XXX,XX @@ void rr_start_vcpu_thread(CPUState *cpu)
         /* share a single thread for all cpus with TCG */
         snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "ALL CPUs/TCG");
         qemu_thread_create(cpu->thread, thread_name,
-                           tcg_rr_cpu_thread_fn,
+                           rr_cpu_thread_fn,
                            cpu, QEMU_THREAD_JOINABLE);
 
         single_tcg_halt_cond = cpu->halt_cond;
@@ -XXX,XX +XXX,XX @@ void rr_start_vcpu_thread(CPUState *cpu)
 
 const CpusAccel tcg_cpus_rr = {
     .create_vcpu_thread = rr_start_vcpu_thread,
-    .kick_vcpu_thread = qemu_cpu_kick_rr_cpus,
+    .kick_vcpu_thread = rr_kick_vcpu_thread,
 
-    .handle_interrupt = tcg_handle_interrupt,
+    .handle_interrupt = tcg_cpus_handle_interrupt,
 };
diff --git a/accel/tcg/tcg-cpus.c b/accel/tcg/tcg-cpus.c
index XXXXXXX..XXXXXXX 100644
--- a/accel/tcg/tcg-cpus.c
+++ b/accel/tcg/tcg-cpus.c
@@ -XXX,XX +XXX,XX @@
 
 /* common functionality among all TCG variants */
 
-void qemu_tcg_destroy_vcpu(CPUState *cpu)
+void tcg_cpus_destroy(CPUState *cpu)
 {
     cpu_thread_signal_destroyed(cpu);
 }
 
-int tcg_cpu_exec(CPUState *cpu)
+int tcg_cpus_exec(CPUState *cpu)
 {
     int ret;
 #ifdef CONFIG_PROFILER
@@ -XXX,XX +XXX,XX @@ int tcg_cpu_exec(CPUState *cpu)
 }
 
 /* mask must never be zero, except for A20 change call */
-void tcg_handle_interrupt(CPUState *cpu, int mask)
+void tcg_cpus_handle_interrupt(CPUState *cpu, int mask)
 {
     g_assert(qemu_mutex_iothread_locked());
 
-- 
2.25.1

v3: One more try to fix macos issues.

The following changes since commit e0209297cddd5e10a07e15fac5cca7aa1a8e0e59:

Merge tag 'pull-ufs-20250217' of https://gitlab.com/jeuk20.kim/qemu into staging (2025-02-18 10:58:48 +0800)

are available in the Git repository at:

https://gitlab.com/rth7680/qemu.git tags/pull-tcg-20250215-3

for you to fetch changes up to e726f65867087d86436de05e9f372a86ec1381a6:

tcg: Remove TCG_TARGET_HAS_{br,set}cond2 from riscv and loongarch64 (2025-02-18 08:29:03 -0800)

----------------------------------------------------------------
tcg: Remove last traces of TCG_TARGET_NEED_POOL_LABELS
tcg: Cleanups after disallowing 64-on-32
tcg: Introduce constraint for zero register
tcg: Remove TCG_TARGET_HAS_{br,set}cond2 from riscv and loongarch64
tcg/i386: Use tcg_{high,unsigned}_cond in tcg_out_brcond2
linux-user: Move TARGET_SA_RESTORER out of generic/signal.h
linux-user: Fix alignment when unmapping excess reservation
target/sparc: Fix register selection for all F*TOx and FxTO* instructions
target/sparc: Fix gdbstub incorrectly handling registers f32-f62
target/sparc: fake UltraSPARC T1 PCR and PIC registers

----------------------------------------------------------------
Andreas Schwab (1):
      linux-user: Move TARGET_SA_RESTORER out of generic/signal.h

Artyom Tarasenko (1):
      target/sparc: fake UltraSPARC T1 PCR and PIC registers

Fabiano Rosas (1):
      elfload: Fix alignment when unmapping excess reservation

Mikael Szreder (2):
      target/sparc: Fix register selection for all F*TOx and FxTO* instructions
      target/sparc: Fix gdbstub incorrectly handling registers f32-f62

Richard Henderson (23):
      tcg: Remove last traces of TCG_TARGET_NEED_POOL_LABELS
      tcg: Remove TCG_OVERSIZED_GUEST
      tcg: Drop support for two address registers in gen_ldst
      tcg: Merge INDEX_op_qemu_*_{a32,a64}_*
      tcg/arm: Drop addrhi from prepare_host_addr
      tcg/i386: Drop addrhi from prepare_host_addr
      tcg/mips: Drop addrhi from prepare_host_addr
      tcg/ppc: Drop addrhi from prepare_host_addr
      tcg: Replace addr{lo,hi}_reg with addr_reg in TCGLabelQemuLdst
      plugins: Fix qemu_plugin_read_memory_vaddr parameters
      accel/tcg: Fix tlb_set_page_with_attrs, tlb_set_page
      target/loongarch: Use VADDR_PRIx for logging pc_next
      target/mips: Use VADDR_PRIx for logging pc_next
      include/exec: Change vaddr to uintptr_t
      include/exec: Use uintptr_t in CPUTLBEntry
      tcg: Introduce the 'z' constraint for a hardware zero register
      tcg/aarch64: Use 'z' constraint
      tcg/loongarch64: Use 'z' constraint
      tcg/mips: Use 'z' constraint
      tcg/riscv: Use 'z' constraint
      tcg/sparc64: Use 'z' constraint
      tcg/i386: Use tcg_{high,unsigned}_cond in tcg_out_brcond2
      tcg: Remove TCG_TARGET_HAS_{br,set}cond2 from riscv and loongarch64