[PULL 0/3] tcg patch queue
[PULL 00/28] tcg patch queue
1
The following changes since commit 2ecfc0657afa5d29a373271b342f704a1a3c6737:
1
The following changes since commit e3acc2c1961cbe22ca474cd5da4163b7bbf7cea3:
2
2
3
Merge remote-tracking branch 'remotes/armbru/tags/pull-misc-2020-12-10' into staging (2020-12-10 17:01:05 +0000)
3
tests/docker/dockerfiles: Bump fedora-i386-cross to fedora 34 (2021-10-05 16:40:39 -0700)
4
4
5
are available in the Git repository at:
5
are available in the Git repository at:
6
6
7
https://gitlab.com/rth7680/qemu.git tags/pull-tcg-20201210
7
https://gitlab.com/rth7680/qemu.git tags/pull-tcg-20211006
8
8
9
for you to fetch changes up to 9e2658d62ebc23efe7df43fc0e306f129510d874:
9
for you to fetch changes up to ea3f2af8f1b87d7bced9b75ef2e788b66ec49961:
10
10
11
accel/tcg: rename tcg-cpus functions to match module name (2020-12-10 17:44:10 -0600)
11
tcg/s390x: Implement TCG_TARGET_HAS_cmpsel_vec (2021-10-05 16:53:17 -0700)
12
12
13
----------------------------------------------------------------
13
----------------------------------------------------------------
14
Split CpusAccel for tcg variants
14
More fixes for fedora-i386-cross
15
Add dup_const_tl
16
Expand MemOp MO_SIZE
17
Move MemOpIdx out of tcg.h
18
Vector support for tcg/s390x
15
19
16
----------------------------------------------------------------
20
----------------------------------------------------------------
17
Claudio Fontana (3):
21
Philipp Tomsich (1):
18
accel/tcg: split CpusAccel into three TCG variants
22
tcg: add dup_const_tl wrapper
19
accel/tcg: split tcg_start_vcpu_thread
20
accel/tcg: rename tcg-cpus functions to match module name
21
23
22
accel/tcg/tcg-cpus-icount.h | 17 ++
24
Richard Henderson (27):
23
accel/tcg/tcg-cpus-rr.h | 21 ++
25
tests/docker: Remove fedora-i386-cross from DOCKER_PARTIAL_IMAGES
24
accel/tcg/tcg-cpus.h | 12 +-
26
tests/docker: Fix fedora-i386-cross cross-compilation
25
accel/tcg/tcg-all.c | 13 +-
27
accel/tcg: Drop signness in tracing in cputlb.c
26
accel/tcg/tcg-cpus-icount.c | 147 +++++++++++++
28
tcg: Expand MO_SIZE to 3 bits
27
accel/tcg/tcg-cpus-mttcg.c | 140 ++++++++++++
29
tcg: Rename TCGMemOpIdx to MemOpIdx
28
accel/tcg/tcg-cpus-rr.c | 305 ++++++++++++++++++++++++++
30
tcg: Split out MemOpIdx to exec/memopidx.h
29
accel/tcg/tcg-cpus.c | 506 +-------------------------------------------
31
trace/mem: Pass MemOpIdx to trace_mem_get_info
30
softmmu/icount.c | 2 +-
32
accel/tcg: Pass MemOpIdx to atomic_trace_*_post
31
accel/tcg/meson.build | 9 +-
33
plugins: Reorg arguments to qemu_plugin_vcpu_mem_cb
32
10 files changed, 670 insertions(+), 502 deletions(-)
34
trace: Split guest_mem_before
33
create mode 100644 accel/tcg/tcg-cpus-icount.h
35
hw/core/cpu: Re-sort the non-pointers to the end of CPUClass
34
create mode 100644 accel/tcg/tcg-cpus-rr.h
36
tcg: Expand usadd/ussub with umin/umax
35
create mode 100644 accel/tcg/tcg-cpus-icount.c
37
tcg/s390x: Rename from tcg/s390
36
create mode 100644 accel/tcg/tcg-cpus-mttcg.c
38
tcg/s390x: Change FACILITY representation
37
create mode 100644 accel/tcg/tcg-cpus-rr.c
39
tcg/s390x: Merge TCG_AREG0 and TCG_REG_CALL_STACK into TCGReg
40
tcg/s390x: Add host vector framework
41
tcg/s390x: Implement tcg_out_ld/st for vector types
42
tcg/s390x: Implement tcg_out_mov for vector types
43
tcg/s390x: Implement tcg_out_dup*_vec
44
tcg/s390x: Implement minimal vector operations
45
tcg/s390x: Implement andc, orc, abs, neg, not vector operations
46
tcg/s390x: Implement TCG_TARGET_HAS_mul_vec
47
tcg/s390x: Implement vector shift operations
48
tcg/s390x: Implement TCG_TARGET_HAS_minmax_vec
49
tcg/s390x: Implement TCG_TARGET_HAS_sat_vec
50
tcg/s390x: Implement TCG_TARGET_HAS_bitsel_vec
51
tcg/s390x: Implement TCG_TARGET_HAS_cmpsel_vec
38
52
53
meson.build | 2 -
54
accel/tcg/atomic_template.h | 73 +-
55
include/exec/memop.h | 14 +-
56
include/exec/memopidx.h | 55 ++
57
include/hw/core/cpu.h | 11 +-
58
include/qemu/plugin.h | 26 +-
59
include/tcg/tcg.h | 117 ++-
60
tcg/{s390 => s390x}/tcg-target-con-set.h | 7 +
61
tcg/{s390 => s390x}/tcg-target-con-str.h | 1 +
62
tcg/{s390 => s390x}/tcg-target.h | 91 ++-
63
tcg/s390x/tcg-target.opc.h | 15 +
64
trace/mem.h | 63 --
65
accel/tcg/cputlb.c | 103 ++-
66
accel/tcg/plugin-gen.c | 5 +-
67
accel/tcg/user-exec.c | 133 ++-
68
plugins/api.c | 19 +-
69
plugins/core.c | 10 +-
70
target/arm/helper-a64.c | 16 +-
71
target/arm/m_helper.c | 2 +-
72
target/arm/translate-a64.c | 2 +-
73
target/i386/tcg/mem_helper.c | 4 +-
74
target/m68k/op_helper.c | 2 +-
75
target/mips/tcg/msa_helper.c | 6 +-
76
target/s390x/tcg/mem_helper.c | 20 +-
77
target/sparc/ldst_helper.c | 2 +-
78
tcg/optimize.c | 2 +-
79
tcg/tcg-op-vec.c | 37 +-
80
tcg/tcg-op.c | 60 +-
81
tcg/tcg.c | 2 +-
82
tcg/tci.c | 14 +-
83
accel/tcg/atomic_common.c.inc | 43 +-
84
target/s390x/tcg/translate_vx.c.inc | 2 +-
85
tcg/aarch64/tcg-target.c.inc | 18 +-
86
tcg/arm/tcg-target.c.inc | 14 +-
87
tcg/i386/tcg-target.c.inc | 14 +-
88
tcg/mips/tcg-target.c.inc | 16 +-
89
tcg/ppc/tcg-target.c.inc | 18 +-
90
tcg/riscv/tcg-target.c.inc | 20 +-
91
tcg/{s390 => s390x}/tcg-target.c.inc | 949 ++++++++++++++++++++--
92
tcg/sparc/tcg-target.c.inc | 20 +-
93
tcg/tcg-ldst.c.inc | 2 +-
94
tests/docker/Makefile.include | 2 +-
95
tests/docker/dockerfiles/fedora-i386-cross.docker | 5 +-
96
trace-events | 18 +-
97
44 files changed, 1445 insertions(+), 610 deletions(-)
98
create mode 100644 include/exec/memopidx.h
99
rename tcg/{s390 => s390x}/tcg-target-con-set.h (86%)
100
rename tcg/{s390 => s390x}/tcg-target-con-str.h (96%)
101
rename tcg/{s390 => s390x}/tcg-target.h (66%)
102
create mode 100644 tcg/s390x/tcg-target.opc.h
103
delete mode 100644 trace/mem.h
104
rename tcg/{s390 => s390x}/tcg-target.c.inc (73%)
105
diff view generated by jsdifflib
New patch
[PULL 01/28] tests/docker: Remove fedora-i386-cross from DOCKER_PARTIAL_IMAGES
1
The image was upgraded to a full image in ee381b7fe146.
2
This makes it possible to use docker-test@image syntax
3
with this container.
1
4
5
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
6
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
7
Message-Id: <20210930163636.721311-2-richard.henderson@linaro.org>
8
---
9
tests/docker/Makefile.include | 2 +-
10
1 file changed, 1 insertion(+), 1 deletion(-)
11
12
diff --git a/tests/docker/Makefile.include b/tests/docker/Makefile.include
13
index XXXXXXX..XXXXXXX 100644
14
--- a/tests/docker/Makefile.include
15
+++ b/tests/docker/Makefile.include
16
@@ -XXX,XX +XXX,XX @@ DOCKER_PARTIAL_IMAGES += debian-riscv64-cross
17
DOCKER_PARTIAL_IMAGES += debian-sh4-cross debian-sparc64-cross
18
DOCKER_PARTIAL_IMAGES += debian-tricore-cross
19
DOCKER_PARTIAL_IMAGES += debian-xtensa-cross
20
-DOCKER_PARTIAL_IMAGES += fedora-i386-cross fedora-cris-cross
21
+DOCKER_PARTIAL_IMAGES += fedora-cris-cross
22
23
# Rules for building linux-user powered images
24
#
25
--
26
2.25.1
27
28
diff view generated by jsdifflib
New patch
[PULL 02/28] tests/docker: Fix fedora-i386-cross cross-compilation
1
By using PKG_CONFIG_PATH instead of PKG_CONFIG_LIBDIR,
2
we were still including the 64-bit packages. Install
3
pcre-devel.i686 to fill a missing glib2 dependency.
1
4
5
By using --extra-cflags instead of --cpu, we incorrectly
6
use the wrong probing during meson.
7
8
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
9
Reviewed-by: Richard W.M. Jones <rjones@redhat.com>
10
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
11
Message-Id: <20210930163636.721311-3-richard.henderson@linaro.org>
12
---
13
tests/docker/dockerfiles/fedora-i386-cross.docker | 5 +++--
14
1 file changed, 3 insertions(+), 2 deletions(-)
15
16
diff --git a/tests/docker/dockerfiles/fedora-i386-cross.docker b/tests/docker/dockerfiles/fedora-i386-cross.docker
17
index XXXXXXX..XXXXXXX 100644
18
--- a/tests/docker/dockerfiles/fedora-i386-cross.docker
19
+++ b/tests/docker/dockerfiles/fedora-i386-cross.docker
20
@@ -XXX,XX +XXX,XX @@ ENV PACKAGES \
21
glibc-static.i686 \
22
gnutls-devel.i686 \
23
nettle-devel.i686 \
24
+ pcre-devel.i686 \
25
perl-Test-Harness \
26
pixman-devel.i686 \
27
sysprof-capture-devel.i686 \
28
zlib-devel.i686
29
30
-ENV QEMU_CONFIGURE_OPTS --extra-cflags=-m32 --disable-vhost-user
31
-ENV PKG_CONFIG_PATH /usr/lib/pkgconfig
32
+ENV QEMU_CONFIGURE_OPTS --cpu=i386 --disable-vhost-user
33
+ENV PKG_CONFIG_LIBDIR /usr/lib/pkgconfig
34
35
RUN dnf update -y && dnf install -y $PACKAGES
36
RUN rpm -q $PACKAGES | sort > /packages.txt
37
--
38
2.25.1
39
40
diff view generated by jsdifflib
New patch
[PULL 03/28] tcg: add dup_const_tl wrapper
1
From: Philipp Tomsich <philipp.tomsich@vrull.eu>
1
2
3
dup_const always generates a uint64_t, which may exceed the size of a
4
target_long (generating warnings with recent-enough compilers).
5
6
To ensure that we can use dup_const both for 64bit and 32bit targets,
7
this adds dup_const_tl, which either maps back to dup_const (for 64bit
8
targets) or provides a similar implementation using 32bit constants.
9
10
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
11
Signed-off-by: Philipp Tomsich <philipp.tomsich@vrull.eu>
12
Message-Id: <20211003214243.3813425-1-philipp.tomsich@vrull.eu>
13
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
14
---
15
include/tcg/tcg.h | 12 ++++++++++++
16
1 file changed, 12 insertions(+)
17
18
diff --git a/include/tcg/tcg.h b/include/tcg/tcg.h
19
index XXXXXXX..XXXXXXX 100644
20
--- a/include/tcg/tcg.h
21
+++ b/include/tcg/tcg.h
22
@@ -XXX,XX +XXX,XX @@ uint64_t dup_const(unsigned vece, uint64_t c);
23
: (qemu_build_not_reached_always(), 0)) \
24
: dup_const(VECE, C))
25
26
+#if TARGET_LONG_BITS == 64
27
+# define dup_const_tl dup_const
28
+#else
29
+# define dup_const_tl(VECE, C) \
30
+ (__builtin_constant_p(VECE) \
31
+ ? ( (VECE) == MO_8 ? 0x01010101ul * (uint8_t)(C) \
32
+ : (VECE) == MO_16 ? 0x00010001ul * (uint16_t)(C) \
33
+ : (VECE) == MO_32 ? 0x00000001ul * (uint32_t)(C) \
34
+ : (qemu_build_not_reached_always(), 0)) \
35
+ : (target_long)dup_const(VECE, C))
36
+#endif
37
+
38
/*
39
* Memory helpers that will be used by TCG generated code.
40
*/
41
--
42
2.25.1
43
44
diff view generated by jsdifflib
New patch
[PULL 04/28] accel/tcg: Drop signness in tracing in cputlb.c
1
We are already inconsistent about whether or not
2
MO_SIGN is set in trace_mem_get_info. Dropping it
3
entirely allows some simplification.
1
4
5
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
6
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
7
---
8
accel/tcg/cputlb.c | 10 +++-------
9
accel/tcg/user-exec.c | 45 ++++++-------------------------------------
10
2 files changed, 9 insertions(+), 46 deletions(-)
11
12
diff --git a/accel/tcg/cputlb.c b/accel/tcg/cputlb.c
13
index XXXXXXX..XXXXXXX 100644
14
--- a/accel/tcg/cputlb.c
15
+++ b/accel/tcg/cputlb.c
16
@@ -XXX,XX +XXX,XX @@ static inline uint64_t cpu_load_helper(CPUArchState *env, abi_ptr addr,
17
meminfo = trace_mem_get_info(op, mmu_idx, false);
18
trace_guest_mem_before_exec(env_cpu(env), addr, meminfo);
19
20
- op &= ~MO_SIGN;
21
oi = make_memop_idx(op, mmu_idx);
22
ret = full_load(env, addr, oi, retaddr);
23
24
@@ -XXX,XX +XXX,XX @@ uint32_t cpu_ldub_mmuidx_ra(CPUArchState *env, abi_ptr addr,
25
int cpu_ldsb_mmuidx_ra(CPUArchState *env, abi_ptr addr,
26
int mmu_idx, uintptr_t ra)
27
{
28
- return (int8_t)cpu_load_helper(env, addr, mmu_idx, ra, MO_SB,
29
- full_ldub_mmu);
30
+ return (int8_t)cpu_ldub_mmuidx_ra(env, addr, mmu_idx, ra);
31
}
32
33
uint32_t cpu_lduw_be_mmuidx_ra(CPUArchState *env, abi_ptr addr,
34
@@ -XXX,XX +XXX,XX @@ uint32_t cpu_lduw_be_mmuidx_ra(CPUArchState *env, abi_ptr addr,
35
int cpu_ldsw_be_mmuidx_ra(CPUArchState *env, abi_ptr addr,
36
int mmu_idx, uintptr_t ra)
37
{
38
- return (int16_t)cpu_load_helper(env, addr, mmu_idx, ra, MO_BESW,
39
- full_be_lduw_mmu);
40
+ return (int16_t)cpu_lduw_be_mmuidx_ra(env, addr, mmu_idx, ra);
41
}
42
43
uint32_t cpu_ldl_be_mmuidx_ra(CPUArchState *env, abi_ptr addr,
44
@@ -XXX,XX +XXX,XX @@ uint32_t cpu_lduw_le_mmuidx_ra(CPUArchState *env, abi_ptr addr,
45
int cpu_ldsw_le_mmuidx_ra(CPUArchState *env, abi_ptr addr,
46
int mmu_idx, uintptr_t ra)
47
{
48
- return (int16_t)cpu_load_helper(env, addr, mmu_idx, ra, MO_LESW,
49
- full_le_lduw_mmu);
50
+ return (int16_t)cpu_lduw_le_mmuidx_ra(env, addr, mmu_idx, ra);
51
}
52
53
uint32_t cpu_ldl_le_mmuidx_ra(CPUArchState *env, abi_ptr addr,
54
diff --git a/accel/tcg/user-exec.c b/accel/tcg/user-exec.c
55
index XXXXXXX..XXXXXXX 100644
56
--- a/accel/tcg/user-exec.c
57
+++ b/accel/tcg/user-exec.c
58
@@ -XXX,XX +XXX,XX @@ uint32_t cpu_ldub_data(CPUArchState *env, abi_ptr ptr)
59
60
int cpu_ldsb_data(CPUArchState *env, abi_ptr ptr)
61
{
62
- int ret;
63
- uint16_t meminfo = trace_mem_get_info(MO_SB, MMU_USER_IDX, false);
64
-
65
- trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
66
- ret = ldsb_p(g2h(env_cpu(env), ptr));
67
- qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, meminfo);
68
- return ret;
69
+ return (int8_t)cpu_ldub_data(env, ptr);
70
}
71
72
uint32_t cpu_lduw_be_data(CPUArchState *env, abi_ptr ptr)
73
@@ -XXX,XX +XXX,XX @@ uint32_t cpu_lduw_be_data(CPUArchState *env, abi_ptr ptr)
74
75
int cpu_ldsw_be_data(CPUArchState *env, abi_ptr ptr)
76
{
77
- int ret;
78
- uint16_t meminfo = trace_mem_get_info(MO_BESW, MMU_USER_IDX, false);
79
-
80
- trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
81
- ret = ldsw_be_p(g2h(env_cpu(env), ptr));
82
- qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, meminfo);
83
- return ret;
84
+ return (int16_t)cpu_lduw_be_data(env, ptr);
85
}
86
87
uint32_t cpu_ldl_be_data(CPUArchState *env, abi_ptr ptr)
88
@@ -XXX,XX +XXX,XX @@ uint32_t cpu_lduw_le_data(CPUArchState *env, abi_ptr ptr)
89
90
int cpu_ldsw_le_data(CPUArchState *env, abi_ptr ptr)
91
{
92
- int ret;
93
- uint16_t meminfo = trace_mem_get_info(MO_LESW, MMU_USER_IDX, false);
94
-
95
- trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
96
- ret = ldsw_le_p(g2h(env_cpu(env), ptr));
97
- qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, meminfo);
98
- return ret;
99
+ return (int16_t)cpu_lduw_le_data(env, ptr);
100
}
101
102
uint32_t cpu_ldl_le_data(CPUArchState *env, abi_ptr ptr)
103
@@ -XXX,XX +XXX,XX @@ uint32_t cpu_ldub_data_ra(CPUArchState *env, abi_ptr ptr, uintptr_t retaddr)
104
105
int cpu_ldsb_data_ra(CPUArchState *env, abi_ptr ptr, uintptr_t retaddr)
106
{
107
- int ret;
108
-
109
- set_helper_retaddr(retaddr);
110
- ret = cpu_ldsb_data(env, ptr);
111
- clear_helper_retaddr();
112
- return ret;
113
+ return (int8_t)cpu_ldub_data_ra(env, ptr, retaddr);
114
}
115
116
uint32_t cpu_lduw_be_data_ra(CPUArchState *env, abi_ptr ptr, uintptr_t retaddr)
117
@@ -XXX,XX +XXX,XX @@ uint32_t cpu_lduw_be_data_ra(CPUArchState *env, abi_ptr ptr, uintptr_t retaddr)
118
119
int cpu_ldsw_be_data_ra(CPUArchState *env, abi_ptr ptr, uintptr_t retaddr)
120
{
121
- int ret;
122
-
123
- set_helper_retaddr(retaddr);
124
- ret = cpu_ldsw_be_data(env, ptr);
125
- clear_helper_retaddr();
126
- return ret;
127
+ return (int16_t)cpu_lduw_be_data_ra(env, ptr, retaddr);
128
}
129
130
uint32_t cpu_ldl_be_data_ra(CPUArchState *env, abi_ptr ptr, uintptr_t retaddr)
131
@@ -XXX,XX +XXX,XX @@ uint32_t cpu_lduw_le_data_ra(CPUArchState *env, abi_ptr ptr, uintptr_t retaddr)
132
133
int cpu_ldsw_le_data_ra(CPUArchState *env, abi_ptr ptr, uintptr_t retaddr)
134
{
135
- int ret;
136
-
137
- set_helper_retaddr(retaddr);
138
- ret = cpu_ldsw_le_data(env, ptr);
139
- clear_helper_retaddr();
140
- return ret;
141
+ return (int16_t)cpu_lduw_le_data_ra(env, ptr, retaddr);
142
}
143
144
uint32_t cpu_ldl_le_data_ra(CPUArchState *env, abi_ptr ptr, uintptr_t retaddr)
145
--
146
2.25.1
147
148
diff view generated by jsdifflib
New patch
[PULL 05/28] tcg: Expand MO_SIZE to 3 bits
1
We have lacked expressive support for memory sizes larger
2
than 64-bits for a while. Fixing that requires adjustment
3
to several points where we used this for array indexing,
4
and two places that develop -Wswitch warnings after the change.
1
5
6
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
7
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
8
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
9
---
10
include/exec/memop.h | 14 +++++++++-----
11
target/arm/translate-a64.c | 2 +-
12
tcg/tcg-op.c | 13 ++++++++-----
13
target/s390x/tcg/translate_vx.c.inc | 2 +-
14
tcg/aarch64/tcg-target.c.inc | 4 ++--
15
tcg/arm/tcg-target.c.inc | 4 ++--
16
tcg/i386/tcg-target.c.inc | 4 ++--
17
tcg/mips/tcg-target.c.inc | 4 ++--
18
tcg/ppc/tcg-target.c.inc | 8 ++++----
19
tcg/riscv/tcg-target.c.inc | 4 ++--
20
tcg/s390/tcg-target.c.inc | 4 ++--
21
tcg/sparc/tcg-target.c.inc | 16 ++++++++--------
22
12 files changed, 43 insertions(+), 36 deletions(-)
23
24
diff --git a/include/exec/memop.h b/include/exec/memop.h
25
index XXXXXXX..XXXXXXX 100644
26
--- a/include/exec/memop.h
27
+++ b/include/exec/memop.h
28
@@ -XXX,XX +XXX,XX @@ typedef enum MemOp {
29
MO_16 = 1,
30
MO_32 = 2,
31
MO_64 = 3,
32
- MO_SIZE = 3, /* Mask for the above. */
33
+ MO_128 = 4,
34
+ MO_256 = 5,
35
+ MO_512 = 6,
36
+ MO_1024 = 7,
37
+ MO_SIZE = 0x07, /* Mask for the above. */
38
39
- MO_SIGN = 4, /* Sign-extended, otherwise zero-extended. */
40
+ MO_SIGN = 0x08, /* Sign-extended, otherwise zero-extended. */
41
42
- MO_BSWAP = 8, /* Host reverse endian. */
43
+ MO_BSWAP = 0x10, /* Host reverse endian. */
44
#ifdef HOST_WORDS_BIGENDIAN
45
MO_LE = MO_BSWAP,
46
MO_BE = 0,
47
@@ -XXX,XX +XXX,XX @@ typedef enum MemOp {
48
* - an alignment to a specified size, which may be more or less than
49
* the access size (MO_ALIGN_x where 'x' is a size in bytes);
50
*/
51
- MO_ASHIFT = 4,
52
- MO_AMASK = 7 << MO_ASHIFT,
53
+ MO_ASHIFT = 5,
54
+ MO_AMASK = 0x7 << MO_ASHIFT,
55
#ifdef NEED_CPU_H
56
#ifdef TARGET_ALIGNED_ONLY
57
MO_ALIGN = 0,
58
diff --git a/target/arm/translate-a64.c b/target/arm/translate-a64.c
59
index XXXXXXX..XXXXXXX 100644
60
--- a/target/arm/translate-a64.c
61
+++ b/target/arm/translate-a64.c
62
@@ -XXX,XX +XXX,XX @@ static void read_vec_element(DisasContext *s, TCGv_i64 tcg_dest, int srcidx,
63
int element, MemOp memop)
64
{
65
int vect_off = vec_reg_offset(s, srcidx, element, memop & MO_SIZE);
66
- switch (memop) {
67
+ switch ((unsigned)memop) {
68
case MO_8:
69
tcg_gen_ld8u_i64(tcg_dest, cpu_env, vect_off);
70
break;
71
diff --git a/tcg/tcg-op.c b/tcg/tcg-op.c
72
index XXXXXXX..XXXXXXX 100644
73
--- a/tcg/tcg-op.c
74
+++ b/tcg/tcg-op.c
75
@@ -XXX,XX +XXX,XX @@ static inline MemOp tcg_canonicalize_memop(MemOp op, bool is64, bool st)
76
}
77
break;
78
case MO_64:
79
- if (!is64) {
80
- tcg_abort();
81
+ if (is64) {
82
+ op &= ~MO_SIGN;
83
+ break;
84
}
85
- break;
86
+ /* fall through */
87
+ default:
88
+ g_assert_not_reached();
89
}
90
if (st) {
91
op &= ~MO_SIGN;
92
@@ -XXX,XX +XXX,XX @@ typedef void (*gen_atomic_op_i64)(TCGv_i64, TCGv_env, TCGv,
93
# define WITH_ATOMIC64(X)
94
#endif
95
96
-static void * const table_cmpxchg[16] = {
97
+static void * const table_cmpxchg[(MO_SIZE | MO_BSWAP) + 1] = {
98
[MO_8] = gen_helper_atomic_cmpxchgb,
99
[MO_16 | MO_LE] = gen_helper_atomic_cmpxchgw_le,
100
[MO_16 | MO_BE] = gen_helper_atomic_cmpxchgw_be,
101
@@ -XXX,XX +XXX,XX @@ static void do_atomic_op_i64(TCGv_i64 ret, TCGv addr, TCGv_i64 val,
102
}
103
104
#define GEN_ATOMIC_HELPER(NAME, OP, NEW) \
105
-static void * const table_##NAME[16] = { \
106
+static void * const table_##NAME[(MO_SIZE | MO_BSWAP) + 1] = { \
107
[MO_8] = gen_helper_atomic_##NAME##b, \
108
[MO_16 | MO_LE] = gen_helper_atomic_##NAME##w_le, \
109
[MO_16 | MO_BE] = gen_helper_atomic_##NAME##w_be, \
110
diff --git a/target/s390x/tcg/translate_vx.c.inc b/target/s390x/tcg/translate_vx.c.inc
111
index XXXXXXX..XXXXXXX 100644
112
--- a/target/s390x/tcg/translate_vx.c.inc
113
+++ b/target/s390x/tcg/translate_vx.c.inc
114
@@ -XXX,XX +XXX,XX @@ static void read_vec_element_i64(TCGv_i64 dst, uint8_t reg, uint8_t enr,
115
{
116
const int offs = vec_reg_offset(reg, enr, memop & MO_SIZE);
117
118
- switch (memop) {
119
+ switch ((unsigned)memop) {
120
case ES_8:
121
tcg_gen_ld8u_i64(dst, cpu_env, offs);
122
break;
123
diff --git a/tcg/aarch64/tcg-target.c.inc b/tcg/aarch64/tcg-target.c.inc
124
index XXXXXXX..XXXXXXX 100644
125
--- a/tcg/aarch64/tcg-target.c.inc
126
+++ b/tcg/aarch64/tcg-target.c.inc
127
@@ -XXX,XX +XXX,XX @@ static void tcg_out_cltz(TCGContext *s, TCGType ext, TCGReg d,
128
/* helper signature: helper_ret_ld_mmu(CPUState *env, target_ulong addr,
129
* TCGMemOpIdx oi, uintptr_t ra)
130
*/
131
-static void * const qemu_ld_helpers[4] = {
132
+static void * const qemu_ld_helpers[MO_SIZE + 1] = {
133
[MO_8] = helper_ret_ldub_mmu,
134
#ifdef HOST_WORDS_BIGENDIAN
135
[MO_16] = helper_be_lduw_mmu,
136
@@ -XXX,XX +XXX,XX @@ static void * const qemu_ld_helpers[4] = {
137
* uintxx_t val, TCGMemOpIdx oi,
138
* uintptr_t ra)
139
*/
140
-static void * const qemu_st_helpers[4] = {
141
+static void * const qemu_st_helpers[MO_SIZE + 1] = {
142
[MO_8] = helper_ret_stb_mmu,
143
#ifdef HOST_WORDS_BIGENDIAN
144
[MO_16] = helper_be_stw_mmu,
145
diff --git a/tcg/arm/tcg-target.c.inc b/tcg/arm/tcg-target.c.inc
146
index XXXXXXX..XXXXXXX 100644
147
--- a/tcg/arm/tcg-target.c.inc
148
+++ b/tcg/arm/tcg-target.c.inc
149
@@ -XXX,XX +XXX,XX @@ static void tcg_out_vldst(TCGContext *s, ARMInsn insn,
150
/* helper signature: helper_ret_ld_mmu(CPUState *env, target_ulong addr,
151
* int mmu_idx, uintptr_t ra)
152
*/
153
-static void * const qemu_ld_helpers[8] = {
154
+static void * const qemu_ld_helpers[MO_SSIZE + 1] = {
155
[MO_UB] = helper_ret_ldub_mmu,
156
[MO_SB] = helper_ret_ldsb_mmu,
157
#ifdef HOST_WORDS_BIGENDIAN
158
@@ -XXX,XX +XXX,XX @@ static void * const qemu_ld_helpers[8] = {
159
/* helper signature: helper_ret_st_mmu(CPUState *env, target_ulong addr,
160
* uintxx_t val, int mmu_idx, uintptr_t ra)
161
*/
162
-static void * const qemu_st_helpers[4] = {
163
+static void * const qemu_st_helpers[MO_SIZE + 1] = {
164
[MO_8] = helper_ret_stb_mmu,
165
#ifdef HOST_WORDS_BIGENDIAN
166
[MO_16] = helper_be_stw_mmu,
167
diff --git a/tcg/i386/tcg-target.c.inc b/tcg/i386/tcg-target.c.inc
168
index XXXXXXX..XXXXXXX 100644
169
--- a/tcg/i386/tcg-target.c.inc
170
+++ b/tcg/i386/tcg-target.c.inc
171
@@ -XXX,XX +XXX,XX @@ static void tcg_out_nopn(TCGContext *s, int n)
172
/* helper signature: helper_ret_ld_mmu(CPUState *env, target_ulong addr,
173
* int mmu_idx, uintptr_t ra)
174
*/
175
-static void * const qemu_ld_helpers[16] = {
176
+static void * const qemu_ld_helpers[(MO_SIZE | MO_BSWAP) + 1] = {
177
[MO_UB] = helper_ret_ldub_mmu,
178
[MO_LEUW] = helper_le_lduw_mmu,
179
[MO_LEUL] = helper_le_ldul_mmu,
180
@@ -XXX,XX +XXX,XX @@ static void * const qemu_ld_helpers[16] = {
181
/* helper signature: helper_ret_st_mmu(CPUState *env, target_ulong addr,
182
* uintxx_t val, int mmu_idx, uintptr_t ra)
183
*/
184
-static void * const qemu_st_helpers[16] = {
185
+static void * const qemu_st_helpers[(MO_SIZE | MO_BSWAP) + 1] = {
186
[MO_UB] = helper_ret_stb_mmu,
187
[MO_LEUW] = helper_le_stw_mmu,
188
[MO_LEUL] = helper_le_stl_mmu,
189
diff --git a/tcg/mips/tcg-target.c.inc b/tcg/mips/tcg-target.c.inc
190
index XXXXXXX..XXXXXXX 100644
191
--- a/tcg/mips/tcg-target.c.inc
192
+++ b/tcg/mips/tcg-target.c.inc
193
@@ -XXX,XX +XXX,XX @@ static void tcg_out_call(TCGContext *s, const tcg_insn_unit *arg)
194
#if defined(CONFIG_SOFTMMU)
195
#include "../tcg-ldst.c.inc"
196
197
-static void * const qemu_ld_helpers[16] = {
198
+static void * const qemu_ld_helpers[(MO_SSIZE | MO_BSWAP) + 1] = {
199
[MO_UB] = helper_ret_ldub_mmu,
200
[MO_SB] = helper_ret_ldsb_mmu,
201
[MO_LEUW] = helper_le_lduw_mmu,
202
@@ -XXX,XX +XXX,XX @@ static void * const qemu_ld_helpers[16] = {
203
#endif
204
};
205
206
-static void * const qemu_st_helpers[16] = {
207
+static void * const qemu_st_helpers[(MO_SIZE | MO_BSWAP) + 1] = {
208
[MO_UB] = helper_ret_stb_mmu,
209
[MO_LEUW] = helper_le_stw_mmu,
210
[MO_LEUL] = helper_le_stl_mmu,
211
diff --git a/tcg/ppc/tcg-target.c.inc b/tcg/ppc/tcg-target.c.inc
212
index XXXXXXX..XXXXXXX 100644
213
--- a/tcg/ppc/tcg-target.c.inc
214
+++ b/tcg/ppc/tcg-target.c.inc
215
@@ -XXX,XX +XXX,XX @@ static void tcg_out_call(TCGContext *s, const tcg_insn_unit *target)
216
#endif
217
}
218
219
-static const uint32_t qemu_ldx_opc[16] = {
220
+static const uint32_t qemu_ldx_opc[(MO_SSIZE + MO_BSWAP) + 1] = {
221
[MO_UB] = LBZX,
222
[MO_UW] = LHZX,
223
[MO_UL] = LWZX,
224
@@ -XXX,XX +XXX,XX @@ static const uint32_t qemu_ldx_opc[16] = {
225
[MO_BSWAP | MO_Q] = LDBRX,
226
};
227
228
-static const uint32_t qemu_stx_opc[16] = {
229
+static const uint32_t qemu_stx_opc[(MO_SIZE + MO_BSWAP) + 1] = {
230
[MO_UB] = STBX,
231
[MO_UW] = STHX,
232
[MO_UL] = STWX,
233
@@ -XXX,XX +XXX,XX @@ static const uint32_t qemu_exts_opc[4] = {
234
/* helper signature: helper_ld_mmu(CPUState *env, target_ulong addr,
235
* int mmu_idx, uintptr_t ra)
236
*/
237
-static void * const qemu_ld_helpers[16] = {
238
+static void * const qemu_ld_helpers[(MO_SIZE | MO_BSWAP) + 1] = {
239
[MO_UB] = helper_ret_ldub_mmu,
240
[MO_LEUW] = helper_le_lduw_mmu,
241
[MO_LEUL] = helper_le_ldul_mmu,
242
@@ -XXX,XX +XXX,XX @@ static void * const qemu_ld_helpers[16] = {
243
/* helper signature: helper_st_mmu(CPUState *env, target_ulong addr,
244
* uintxx_t val, int mmu_idx, uintptr_t ra)
245
*/
246
-static void * const qemu_st_helpers[16] = {
247
+static void * const qemu_st_helpers[(MO_SIZE | MO_BSWAP) + 1] = {
248
[MO_UB] = helper_ret_stb_mmu,
249
[MO_LEUW] = helper_le_stw_mmu,
250
[MO_LEUL] = helper_le_stl_mmu,
251
diff --git a/tcg/riscv/tcg-target.c.inc b/tcg/riscv/tcg-target.c.inc
252
index XXXXXXX..XXXXXXX 100644
253
--- a/tcg/riscv/tcg-target.c.inc
254
+++ b/tcg/riscv/tcg-target.c.inc
255
@@ -XXX,XX +XXX,XX @@ static void tcg_out_mb(TCGContext *s, TCGArg a0)
256
/* helper signature: helper_ret_ld_mmu(CPUState *env, target_ulong addr,
257
* TCGMemOpIdx oi, uintptr_t ra)
258
*/
259
-static void * const qemu_ld_helpers[8] = {
260
+static void * const qemu_ld_helpers[MO_SSIZE + 1] = {
261
[MO_UB] = helper_ret_ldub_mmu,
262
[MO_SB] = helper_ret_ldsb_mmu,
263
#ifdef HOST_WORDS_BIGENDIAN
264
@@ -XXX,XX +XXX,XX @@ static void * const qemu_ld_helpers[8] = {
265
* uintxx_t val, TCGMemOpIdx oi,
266
* uintptr_t ra)
267
*/
268
-static void * const qemu_st_helpers[4] = {
269
+static void * const qemu_st_helpers[MO_SIZE + 1] = {
270
[MO_8] = helper_ret_stb_mmu,
271
#ifdef HOST_WORDS_BIGENDIAN
272
[MO_16] = helper_be_stw_mmu,
273
diff --git a/tcg/s390/tcg-target.c.inc b/tcg/s390/tcg-target.c.inc
274
index XXXXXXX..XXXXXXX 100644
275
--- a/tcg/s390/tcg-target.c.inc
276
+++ b/tcg/s390/tcg-target.c.inc
277
@@ -XXX,XX +XXX,XX @@ static const uint8_t tcg_cond_to_ltr_cond[] = {
278
};
279
280
#ifdef CONFIG_SOFTMMU
281
-static void * const qemu_ld_helpers[16] = {
282
+static void * const qemu_ld_helpers[(MO_SSIZE | MO_BSWAP) + 1] = {
283
[MO_UB] = helper_ret_ldub_mmu,
284
[MO_SB] = helper_ret_ldsb_mmu,
285
[MO_LEUW] = helper_le_lduw_mmu,
286
@@ -XXX,XX +XXX,XX @@ static void * const qemu_ld_helpers[16] = {
287
[MO_BEQ] = helper_be_ldq_mmu,
288
};
289
290
-static void * const qemu_st_helpers[16] = {
291
+static void * const qemu_st_helpers[(MO_SIZE | MO_BSWAP) + 1] = {
292
[MO_UB] = helper_ret_stb_mmu,
293
[MO_LEUW] = helper_le_stw_mmu,
294
[MO_LEUL] = helper_le_stl_mmu,
295
diff --git a/tcg/sparc/tcg-target.c.inc b/tcg/sparc/tcg-target.c.inc
296
index XXXXXXX..XXXXXXX 100644
297
--- a/tcg/sparc/tcg-target.c.inc
298
+++ b/tcg/sparc/tcg-target.c.inc
299
@@ -XXX,XX +XXX,XX @@ static void tcg_out_mb(TCGContext *s, TCGArg a0)
300
}
301
302
#ifdef CONFIG_SOFTMMU
303
-static const tcg_insn_unit *qemu_ld_trampoline[16];
304
-static const tcg_insn_unit *qemu_st_trampoline[16];
305
+static const tcg_insn_unit *qemu_ld_trampoline[(MO_SSIZE | MO_BSWAP) + 1];
306
+static const tcg_insn_unit *qemu_st_trampoline[(MO_SIZE | MO_BSWAP) + 1];
307
308
static void emit_extend(TCGContext *s, TCGReg r, int op)
309
{
310
@@ -XXX,XX +XXX,XX @@ static void emit_extend(TCGContext *s, TCGReg r, int op)
311
312
static void build_trampolines(TCGContext *s)
313
{
314
- static void * const qemu_ld_helpers[16] = {
315
+ static void * const qemu_ld_helpers[] = {
316
[MO_UB] = helper_ret_ldub_mmu,
317
[MO_SB] = helper_ret_ldsb_mmu,
318
[MO_LEUW] = helper_le_lduw_mmu,
319
@@ -XXX,XX +XXX,XX @@ static void build_trampolines(TCGContext *s)
320
[MO_BEUL] = helper_be_ldul_mmu,
321
[MO_BEQ] = helper_be_ldq_mmu,
322
};
323
- static void * const qemu_st_helpers[16] = {
324
+ static void * const qemu_st_helpers[] = {
325
[MO_UB] = helper_ret_stb_mmu,
326
[MO_LEUW] = helper_le_stw_mmu,
327
[MO_LEUL] = helper_le_stl_mmu,
328
@@ -XXX,XX +XXX,XX @@ static void build_trampolines(TCGContext *s)
329
int i;
330
TCGReg ra;
331
332
- for (i = 0; i < 16; ++i) {
333
+ for (i = 0; i < ARRAY_SIZE(qemu_ld_helpers); ++i) {
334
if (qemu_ld_helpers[i] == NULL) {
335
continue;
336
}
337
@@ -XXX,XX +XXX,XX @@ static void build_trampolines(TCGContext *s)
338
tcg_out_mov(s, TCG_TYPE_PTR, TCG_REG_O7, ra);
339
}
340
341
- for (i = 0; i < 16; ++i) {
342
+ for (i = 0; i < ARRAY_SIZE(qemu_st_helpers); ++i) {
343
if (qemu_st_helpers[i] == NULL) {
344
continue;
345
}
346
@@ -XXX,XX +XXX,XX @@ static TCGReg tcg_out_tlb_load(TCGContext *s, TCGReg addr, int mem_index,
347
}
348
#endif /* CONFIG_SOFTMMU */
349
350
-static const int qemu_ld_opc[16] = {
351
+static const int qemu_ld_opc[(MO_SSIZE | MO_BSWAP) + 1] = {
352
[MO_UB] = LDUB,
353
[MO_SB] = LDSB,
354
355
@@ -XXX,XX +XXX,XX @@ static const int qemu_ld_opc[16] = {
356
[MO_LEQ] = LDX_LE,
357
};
358
359
-static const int qemu_st_opc[16] = {
360
+static const int qemu_st_opc[(MO_SIZE | MO_BSWAP) + 1] = {
361
[MO_UB] = STB,
362
363
[MO_BEUW] = STH,
364
--
365
2.25.1
366
367
diff view generated by jsdifflib
New patch
[PULL 06/28] tcg: Rename TCGMemOpIdx to MemOpIdx
1
We're about to move this out of tcg.h, so rename it
2
as we did when moving MemOp.
1
3
4
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
5
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
6
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
7
---
8
accel/tcg/atomic_template.h | 24 +++++------
9
include/tcg/tcg.h | 74 ++++++++++++++++-----------------
10
accel/tcg/cputlb.c | 78 +++++++++++++++++------------------
11
accel/tcg/user-exec.c | 2 +-
12
target/arm/helper-a64.c | 16 +++----
13
target/arm/m_helper.c | 2 +-
14
target/i386/tcg/mem_helper.c | 4 +-
15
target/m68k/op_helper.c | 2 +-
16
target/mips/tcg/msa_helper.c | 6 +--
17
target/s390x/tcg/mem_helper.c | 20 ++++-----
18
target/sparc/ldst_helper.c | 2 +-
19
tcg/optimize.c | 2 +-
20
tcg/tcg-op.c | 12 +++---
21
tcg/tcg.c | 2 +-
22
tcg/tci.c | 14 +++----
23
accel/tcg/atomic_common.c.inc | 6 +--
24
tcg/aarch64/tcg-target.c.inc | 14 +++----
25
tcg/arm/tcg-target.c.inc | 10 ++---
26
tcg/i386/tcg-target.c.inc | 10 ++---
27
tcg/mips/tcg-target.c.inc | 12 +++---
28
tcg/ppc/tcg-target.c.inc | 10 ++---
29
tcg/riscv/tcg-target.c.inc | 16 +++----
30
tcg/s390/tcg-target.c.inc | 10 ++---
31
tcg/sparc/tcg-target.c.inc | 4 +-
32
tcg/tcg-ldst.c.inc | 2 +-
33
25 files changed, 177 insertions(+), 177 deletions(-)
34
35
diff --git a/accel/tcg/atomic_template.h b/accel/tcg/atomic_template.h
36
index XXXXXXX..XXXXXXX 100644
37
--- a/accel/tcg/atomic_template.h
38
+++ b/accel/tcg/atomic_template.h
39
@@ -XXX,XX +XXX,XX @@
40
41
ABI_TYPE ATOMIC_NAME(cmpxchg)(CPUArchState *env, target_ulong addr,
42
ABI_TYPE cmpv, ABI_TYPE newv,
43
- TCGMemOpIdx oi, uintptr_t retaddr)
44
+ MemOpIdx oi, uintptr_t retaddr)
45
{
46
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE,
47
PAGE_READ | PAGE_WRITE, retaddr);
48
@@ -XXX,XX +XXX,XX @@ ABI_TYPE ATOMIC_NAME(cmpxchg)(CPUArchState *env, target_ulong addr,
49
#if DATA_SIZE >= 16
50
#if HAVE_ATOMIC128
51
ABI_TYPE ATOMIC_NAME(ld)(CPUArchState *env, target_ulong addr,
52
- TCGMemOpIdx oi, uintptr_t retaddr)
53
+ MemOpIdx oi, uintptr_t retaddr)
54
{
55
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE,
56
PAGE_READ, retaddr);
57
@@ -XXX,XX +XXX,XX @@ ABI_TYPE ATOMIC_NAME(ld)(CPUArchState *env, target_ulong addr,
58
}
59
60
void ATOMIC_NAME(st)(CPUArchState *env, target_ulong addr, ABI_TYPE val,
61
- TCGMemOpIdx oi, uintptr_t retaddr)
62
+ MemOpIdx oi, uintptr_t retaddr)
63
{
64
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE,
65
PAGE_WRITE, retaddr);
66
@@ -XXX,XX +XXX,XX @@ void ATOMIC_NAME(st)(CPUArchState *env, target_ulong addr, ABI_TYPE val,
67
#endif
68
#else
69
ABI_TYPE ATOMIC_NAME(xchg)(CPUArchState *env, target_ulong addr, ABI_TYPE val,
70
- TCGMemOpIdx oi, uintptr_t retaddr)
71
+ MemOpIdx oi, uintptr_t retaddr)
72
{
73
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE,
74
PAGE_READ | PAGE_WRITE, retaddr);
75
@@ -XXX,XX +XXX,XX @@ ABI_TYPE ATOMIC_NAME(xchg)(CPUArchState *env, target_ulong addr, ABI_TYPE val,
76
77
#define GEN_ATOMIC_HELPER(X) \
78
ABI_TYPE ATOMIC_NAME(X)(CPUArchState *env, target_ulong addr, \
79
- ABI_TYPE val, TCGMemOpIdx oi, uintptr_t retaddr) \
80
+ ABI_TYPE val, MemOpIdx oi, uintptr_t retaddr) \
81
{ \
82
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE, \
83
PAGE_READ | PAGE_WRITE, retaddr); \
84
@@ -XXX,XX +XXX,XX @@ GEN_ATOMIC_HELPER(xor_fetch)
85
*/
86
#define GEN_ATOMIC_HELPER_FN(X, FN, XDATA_TYPE, RET) \
87
ABI_TYPE ATOMIC_NAME(X)(CPUArchState *env, target_ulong addr, \
88
- ABI_TYPE xval, TCGMemOpIdx oi, uintptr_t retaddr) \
89
+ ABI_TYPE xval, MemOpIdx oi, uintptr_t retaddr) \
90
{ \
91
XDATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE, \
92
PAGE_READ | PAGE_WRITE, retaddr); \
93
@@ -XXX,XX +XXX,XX @@ GEN_ATOMIC_HELPER_FN(umax_fetch, MAX, DATA_TYPE, new)
94
95
ABI_TYPE ATOMIC_NAME(cmpxchg)(CPUArchState *env, target_ulong addr,
96
ABI_TYPE cmpv, ABI_TYPE newv,
97
- TCGMemOpIdx oi, uintptr_t retaddr)
98
+ MemOpIdx oi, uintptr_t retaddr)
99
{
100
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE,
101
PAGE_READ | PAGE_WRITE, retaddr);
102
@@ -XXX,XX +XXX,XX @@ ABI_TYPE ATOMIC_NAME(cmpxchg)(CPUArchState *env, target_ulong addr,
103
#if DATA_SIZE >= 16
104
#if HAVE_ATOMIC128
105
ABI_TYPE ATOMIC_NAME(ld)(CPUArchState *env, target_ulong addr,
106
- TCGMemOpIdx oi, uintptr_t retaddr)
107
+ MemOpIdx oi, uintptr_t retaddr)
108
{
109
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE,
110
PAGE_READ, retaddr);
111
@@ -XXX,XX +XXX,XX @@ ABI_TYPE ATOMIC_NAME(ld)(CPUArchState *env, target_ulong addr,
112
}
113
114
void ATOMIC_NAME(st)(CPUArchState *env, target_ulong addr, ABI_TYPE val,
115
- TCGMemOpIdx oi, uintptr_t retaddr)
116
+ MemOpIdx oi, uintptr_t retaddr)
117
{
118
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE,
119
PAGE_WRITE, retaddr);
120
@@ -XXX,XX +XXX,XX @@ void ATOMIC_NAME(st)(CPUArchState *env, target_ulong addr, ABI_TYPE val,
121
#endif
122
#else
123
ABI_TYPE ATOMIC_NAME(xchg)(CPUArchState *env, target_ulong addr, ABI_TYPE val,
124
- TCGMemOpIdx oi, uintptr_t retaddr)
125
+ MemOpIdx oi, uintptr_t retaddr)
126
{
127
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE,
128
PAGE_READ | PAGE_WRITE, retaddr);
129
@@ -XXX,XX +XXX,XX @@ ABI_TYPE ATOMIC_NAME(xchg)(CPUArchState *env, target_ulong addr, ABI_TYPE val,
130
131
#define GEN_ATOMIC_HELPER(X) \
132
ABI_TYPE ATOMIC_NAME(X)(CPUArchState *env, target_ulong addr, \
133
- ABI_TYPE val, TCGMemOpIdx oi, uintptr_t retaddr) \
134
+ ABI_TYPE val, MemOpIdx oi, uintptr_t retaddr) \
135
{ \
136
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE, \
137
PAGE_READ | PAGE_WRITE, retaddr); \
138
@@ -XXX,XX +XXX,XX @@ GEN_ATOMIC_HELPER(xor_fetch)
139
*/
140
#define GEN_ATOMIC_HELPER_FN(X, FN, XDATA_TYPE, RET) \
141
ABI_TYPE ATOMIC_NAME(X)(CPUArchState *env, target_ulong addr, \
142
- ABI_TYPE xval, TCGMemOpIdx oi, uintptr_t retaddr) \
143
+ ABI_TYPE xval, MemOpIdx oi, uintptr_t retaddr) \
144
{ \
145
XDATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE, \
146
PAGE_READ | PAGE_WRITE, retaddr); \
147
diff --git a/include/tcg/tcg.h b/include/tcg/tcg.h
148
index XXXXXXX..XXXXXXX 100644
149
--- a/include/tcg/tcg.h
150
+++ b/include/tcg/tcg.h
151
@@ -XXX,XX +XXX,XX @@ static inline size_t tcg_current_code_size(TCGContext *s)
152
}
153
154
/* Combine the MemOp and mmu_idx parameters into a single value. */
155
-typedef uint32_t TCGMemOpIdx;
156
+typedef uint32_t MemOpIdx;
157
158
/**
159
* make_memop_idx
160
@@ -XXX,XX +XXX,XX @@ typedef uint32_t TCGMemOpIdx;
161
*
162
* Encode these values into a single parameter.
163
*/
164
-static inline TCGMemOpIdx make_memop_idx(MemOp op, unsigned idx)
165
+static inline MemOpIdx make_memop_idx(MemOp op, unsigned idx)
166
{
167
tcg_debug_assert(idx <= 15);
168
return (op << 4) | idx;
169
@@ -XXX,XX +XXX,XX @@ static inline TCGMemOpIdx make_memop_idx(MemOp op, unsigned idx)
170
*
171
* Extract the memory operation from the combined value.
172
*/
173
-static inline MemOp get_memop(TCGMemOpIdx oi)
174
+static inline MemOp get_memop(MemOpIdx oi)
175
{
176
return oi >> 4;
177
}
178
@@ -XXX,XX +XXX,XX @@ static inline MemOp get_memop(TCGMemOpIdx oi)
179
*
180
* Extract the mmu index from the combined value.
181
*/
182
-static inline unsigned get_mmuidx(TCGMemOpIdx oi)
183
+static inline unsigned get_mmuidx(MemOpIdx oi)
184
{
185
return oi & 15;
186
}
187
@@ -XXX,XX +XXX,XX @@ uint64_t dup_const(unsigned vece, uint64_t c);
188
#ifdef CONFIG_SOFTMMU
189
/* Value zero-extended to tcg register size. */
190
tcg_target_ulong helper_ret_ldub_mmu(CPUArchState *env, target_ulong addr,
191
- TCGMemOpIdx oi, uintptr_t retaddr);
192
+ MemOpIdx oi, uintptr_t retaddr);
193
tcg_target_ulong helper_le_lduw_mmu(CPUArchState *env, target_ulong addr,
194
- TCGMemOpIdx oi, uintptr_t retaddr);
195
+ MemOpIdx oi, uintptr_t retaddr);
196
tcg_target_ulong helper_le_ldul_mmu(CPUArchState *env, target_ulong addr,
197
- TCGMemOpIdx oi, uintptr_t retaddr);
198
+ MemOpIdx oi, uintptr_t retaddr);
199
uint64_t helper_le_ldq_mmu(CPUArchState *env, target_ulong addr,
200
- TCGMemOpIdx oi, uintptr_t retaddr);
201
+ MemOpIdx oi, uintptr_t retaddr);
202
tcg_target_ulong helper_be_lduw_mmu(CPUArchState *env, target_ulong addr,
203
- TCGMemOpIdx oi, uintptr_t retaddr);
204
+ MemOpIdx oi, uintptr_t retaddr);
205
tcg_target_ulong helper_be_ldul_mmu(CPUArchState *env, target_ulong addr,
206
- TCGMemOpIdx oi, uintptr_t retaddr);
207
+ MemOpIdx oi, uintptr_t retaddr);
208
uint64_t helper_be_ldq_mmu(CPUArchState *env, target_ulong addr,
209
- TCGMemOpIdx oi, uintptr_t retaddr);
210
+ MemOpIdx oi, uintptr_t retaddr);
211
212
/* Value sign-extended to tcg register size. */
213
tcg_target_ulong helper_ret_ldsb_mmu(CPUArchState *env, target_ulong addr,
214
- TCGMemOpIdx oi, uintptr_t retaddr);
215
+ MemOpIdx oi, uintptr_t retaddr);
216
tcg_target_ulong helper_le_ldsw_mmu(CPUArchState *env, target_ulong addr,
217
- TCGMemOpIdx oi, uintptr_t retaddr);
218
+ MemOpIdx oi, uintptr_t retaddr);
219
tcg_target_ulong helper_le_ldsl_mmu(CPUArchState *env, target_ulong addr,
220
- TCGMemOpIdx oi, uintptr_t retaddr);
221
+ MemOpIdx oi, uintptr_t retaddr);
222
tcg_target_ulong helper_be_ldsw_mmu(CPUArchState *env, target_ulong addr,
223
- TCGMemOpIdx oi, uintptr_t retaddr);
224
+ MemOpIdx oi, uintptr_t retaddr);
225
tcg_target_ulong helper_be_ldsl_mmu(CPUArchState *env, target_ulong addr,
226
- TCGMemOpIdx oi, uintptr_t retaddr);
227
+ MemOpIdx oi, uintptr_t retaddr);
228
229
void helper_ret_stb_mmu(CPUArchState *env, target_ulong addr, uint8_t val,
230
- TCGMemOpIdx oi, uintptr_t retaddr);
231
+ MemOpIdx oi, uintptr_t retaddr);
232
void helper_le_stw_mmu(CPUArchState *env, target_ulong addr, uint16_t val,
233
- TCGMemOpIdx oi, uintptr_t retaddr);
234
+ MemOpIdx oi, uintptr_t retaddr);
235
void helper_le_stl_mmu(CPUArchState *env, target_ulong addr, uint32_t val,
236
- TCGMemOpIdx oi, uintptr_t retaddr);
237
+ MemOpIdx oi, uintptr_t retaddr);
238
void helper_le_stq_mmu(CPUArchState *env, target_ulong addr, uint64_t val,
239
- TCGMemOpIdx oi, uintptr_t retaddr);
240
+ MemOpIdx oi, uintptr_t retaddr);
241
void helper_be_stw_mmu(CPUArchState *env, target_ulong addr, uint16_t val,
242
- TCGMemOpIdx oi, uintptr_t retaddr);
243
+ MemOpIdx oi, uintptr_t retaddr);
244
void helper_be_stl_mmu(CPUArchState *env, target_ulong addr, uint32_t val,
245
- TCGMemOpIdx oi, uintptr_t retaddr);
246
+ MemOpIdx oi, uintptr_t retaddr);
247
void helper_be_stq_mmu(CPUArchState *env, target_ulong addr, uint64_t val,
248
- TCGMemOpIdx oi, uintptr_t retaddr);
249
+ MemOpIdx oi, uintptr_t retaddr);
250
251
/* Temporary aliases until backends are converted. */
252
#ifdef TARGET_WORDS_BIGENDIAN
253
@@ -XXX,XX +XXX,XX @@ void helper_be_stq_mmu(CPUArchState *env, target_ulong addr, uint64_t val,
254
255
uint32_t cpu_atomic_cmpxchgb_mmu(CPUArchState *env, target_ulong addr,
256
uint32_t cmpv, uint32_t newv,
257
- TCGMemOpIdx oi, uintptr_t retaddr);
258
+ MemOpIdx oi, uintptr_t retaddr);
259
uint32_t cpu_atomic_cmpxchgw_le_mmu(CPUArchState *env, target_ulong addr,
260
uint32_t cmpv, uint32_t newv,
261
- TCGMemOpIdx oi, uintptr_t retaddr);
262
+ MemOpIdx oi, uintptr_t retaddr);
263
uint32_t cpu_atomic_cmpxchgl_le_mmu(CPUArchState *env, target_ulong addr,
264
uint32_t cmpv, uint32_t newv,
265
- TCGMemOpIdx oi, uintptr_t retaddr);
266
+ MemOpIdx oi, uintptr_t retaddr);
267
uint64_t cpu_atomic_cmpxchgq_le_mmu(CPUArchState *env, target_ulong addr,
268
uint64_t cmpv, uint64_t newv,
269
- TCGMemOpIdx oi, uintptr_t retaddr);
270
+ MemOpIdx oi, uintptr_t retaddr);
271
uint32_t cpu_atomic_cmpxchgw_be_mmu(CPUArchState *env, target_ulong addr,
272
uint32_t cmpv, uint32_t newv,
273
- TCGMemOpIdx oi, uintptr_t retaddr);
274
+ MemOpIdx oi, uintptr_t retaddr);
275
uint32_t cpu_atomic_cmpxchgl_be_mmu(CPUArchState *env, target_ulong addr,
276
uint32_t cmpv, uint32_t newv,
277
- TCGMemOpIdx oi, uintptr_t retaddr);
278
+ MemOpIdx oi, uintptr_t retaddr);
279
uint64_t cpu_atomic_cmpxchgq_be_mmu(CPUArchState *env, target_ulong addr,
280
uint64_t cmpv, uint64_t newv,
281
- TCGMemOpIdx oi, uintptr_t retaddr);
282
+ MemOpIdx oi, uintptr_t retaddr);
283
284
#define GEN_ATOMIC_HELPER(NAME, TYPE, SUFFIX) \
285
TYPE cpu_atomic_ ## NAME ## SUFFIX ## _mmu \
286
(CPUArchState *env, target_ulong addr, TYPE val, \
287
- TCGMemOpIdx oi, uintptr_t retaddr);
288
+ MemOpIdx oi, uintptr_t retaddr);
289
290
#ifdef CONFIG_ATOMIC64
291
#define GEN_ATOMIC_HELPER_ALL(NAME) \
292
@@ -XXX,XX +XXX,XX @@ GEN_ATOMIC_HELPER_ALL(xchg)
293
294
Int128 cpu_atomic_cmpxchgo_le_mmu(CPUArchState *env, target_ulong addr,
295
Int128 cmpv, Int128 newv,
296
- TCGMemOpIdx oi, uintptr_t retaddr);
297
+ MemOpIdx oi, uintptr_t retaddr);
298
Int128 cpu_atomic_cmpxchgo_be_mmu(CPUArchState *env, target_ulong addr,
299
Int128 cmpv, Int128 newv,
300
- TCGMemOpIdx oi, uintptr_t retaddr);
301
+ MemOpIdx oi, uintptr_t retaddr);
302
303
Int128 cpu_atomic_ldo_le_mmu(CPUArchState *env, target_ulong addr,
304
- TCGMemOpIdx oi, uintptr_t retaddr);
305
+ MemOpIdx oi, uintptr_t retaddr);
306
Int128 cpu_atomic_ldo_be_mmu(CPUArchState *env, target_ulong addr,
307
- TCGMemOpIdx oi, uintptr_t retaddr);
308
+ MemOpIdx oi, uintptr_t retaddr);
309
void cpu_atomic_sto_le_mmu(CPUArchState *env, target_ulong addr, Int128 val,
310
- TCGMemOpIdx oi, uintptr_t retaddr);
311
+ MemOpIdx oi, uintptr_t retaddr);
312
void cpu_atomic_sto_be_mmu(CPUArchState *env, target_ulong addr, Int128 val,
313
- TCGMemOpIdx oi, uintptr_t retaddr);
314
+ MemOpIdx oi, uintptr_t retaddr);
315
316
#ifdef CONFIG_DEBUG_TCG
317
void tcg_assert_listed_vecop(TCGOpcode);
318
diff --git a/accel/tcg/cputlb.c b/accel/tcg/cputlb.c
319
index XXXXXXX..XXXXXXX 100644
320
--- a/accel/tcg/cputlb.c
321
+++ b/accel/tcg/cputlb.c
322
@@ -XXX,XX +XXX,XX @@ bool tlb_plugin_lookup(CPUState *cpu, target_ulong addr, int mmu_idx,
323
* @prot may be PAGE_READ, PAGE_WRITE, or PAGE_READ|PAGE_WRITE.
324
*/
325
static void *atomic_mmu_lookup(CPUArchState *env, target_ulong addr,
326
- TCGMemOpIdx oi, int size, int prot,
327
+ MemOpIdx oi, int size, int prot,
328
uintptr_t retaddr)
329
{
330
size_t mmu_idx = get_mmuidx(oi);
331
@@ -XXX,XX +XXX,XX @@ static void *atomic_mmu_lookup(CPUArchState *env, target_ulong addr,
332
*/
333
334
typedef uint64_t FullLoadHelper(CPUArchState *env, target_ulong addr,
335
- TCGMemOpIdx oi, uintptr_t retaddr);
336
+ MemOpIdx oi, uintptr_t retaddr);
337
338
static inline uint64_t QEMU_ALWAYS_INLINE
339
load_memop(const void *haddr, MemOp op)
340
@@ -XXX,XX +XXX,XX @@ load_memop(const void *haddr, MemOp op)
341
}
342
343
static inline uint64_t QEMU_ALWAYS_INLINE
344
-load_helper(CPUArchState *env, target_ulong addr, TCGMemOpIdx oi,
345
+load_helper(CPUArchState *env, target_ulong addr, MemOpIdx oi,
346
uintptr_t retaddr, MemOp op, bool code_read,
347
FullLoadHelper *full_load)
348
{
349
@@ -XXX,XX +XXX,XX @@ load_helper(CPUArchState *env, target_ulong addr, TCGMemOpIdx oi,
350
*/
351
352
static uint64_t full_ldub_mmu(CPUArchState *env, target_ulong addr,
353
- TCGMemOpIdx oi, uintptr_t retaddr)
354
+ MemOpIdx oi, uintptr_t retaddr)
355
{
356
return load_helper(env, addr, oi, retaddr, MO_UB, false, full_ldub_mmu);
357
}
358
359
tcg_target_ulong helper_ret_ldub_mmu(CPUArchState *env, target_ulong addr,
360
- TCGMemOpIdx oi, uintptr_t retaddr)
361
+ MemOpIdx oi, uintptr_t retaddr)
362
{
363
return full_ldub_mmu(env, addr, oi, retaddr);
364
}
365
366
static uint64_t full_le_lduw_mmu(CPUArchState *env, target_ulong addr,
367
- TCGMemOpIdx oi, uintptr_t retaddr)
368
+ MemOpIdx oi, uintptr_t retaddr)
369
{
370
return load_helper(env, addr, oi, retaddr, MO_LEUW, false,
371
full_le_lduw_mmu);
372
}
373
374
tcg_target_ulong helper_le_lduw_mmu(CPUArchState *env, target_ulong addr,
375
- TCGMemOpIdx oi, uintptr_t retaddr)
376
+ MemOpIdx oi, uintptr_t retaddr)
377
{
378
return full_le_lduw_mmu(env, addr, oi, retaddr);
379
}
380
381
static uint64_t full_be_lduw_mmu(CPUArchState *env, target_ulong addr,
382
- TCGMemOpIdx oi, uintptr_t retaddr)
383
+ MemOpIdx oi, uintptr_t retaddr)
384
{
385
return load_helper(env, addr, oi, retaddr, MO_BEUW, false,
386
full_be_lduw_mmu);
387
}
388
389
tcg_target_ulong helper_be_lduw_mmu(CPUArchState *env, target_ulong addr,
390
- TCGMemOpIdx oi, uintptr_t retaddr)
391
+ MemOpIdx oi, uintptr_t retaddr)
392
{
393
return full_be_lduw_mmu(env, addr, oi, retaddr);
394
}
395
396
static uint64_t full_le_ldul_mmu(CPUArchState *env, target_ulong addr,
397
- TCGMemOpIdx oi, uintptr_t retaddr)
398
+ MemOpIdx oi, uintptr_t retaddr)
399
{
400
return load_helper(env, addr, oi, retaddr, MO_LEUL, false,
401
full_le_ldul_mmu);
402
}
403
404
tcg_target_ulong helper_le_ldul_mmu(CPUArchState *env, target_ulong addr,
405
- TCGMemOpIdx oi, uintptr_t retaddr)
406
+ MemOpIdx oi, uintptr_t retaddr)
407
{
408
return full_le_ldul_mmu(env, addr, oi, retaddr);
409
}
410
411
static uint64_t full_be_ldul_mmu(CPUArchState *env, target_ulong addr,
412
- TCGMemOpIdx oi, uintptr_t retaddr)
413
+ MemOpIdx oi, uintptr_t retaddr)
414
{
415
return load_helper(env, addr, oi, retaddr, MO_BEUL, false,
416
full_be_ldul_mmu);
417
}
418
419
tcg_target_ulong helper_be_ldul_mmu(CPUArchState *env, target_ulong addr,
420
- TCGMemOpIdx oi, uintptr_t retaddr)
421
+ MemOpIdx oi, uintptr_t retaddr)
422
{
423
return full_be_ldul_mmu(env, addr, oi, retaddr);
424
}
425
426
uint64_t helper_le_ldq_mmu(CPUArchState *env, target_ulong addr,
427
- TCGMemOpIdx oi, uintptr_t retaddr)
428
+ MemOpIdx oi, uintptr_t retaddr)
429
{
430
return load_helper(env, addr, oi, retaddr, MO_LEQ, false,
431
helper_le_ldq_mmu);
432
}
433
434
uint64_t helper_be_ldq_mmu(CPUArchState *env, target_ulong addr,
435
- TCGMemOpIdx oi, uintptr_t retaddr)
436
+ MemOpIdx oi, uintptr_t retaddr)
437
{
438
return load_helper(env, addr, oi, retaddr, MO_BEQ, false,
439
helper_be_ldq_mmu);
440
@@ -XXX,XX +XXX,XX @@ uint64_t helper_be_ldq_mmu(CPUArchState *env, target_ulong addr,
441
442
443
tcg_target_ulong helper_ret_ldsb_mmu(CPUArchState *env, target_ulong addr,
444
- TCGMemOpIdx oi, uintptr_t retaddr)
445
+ MemOpIdx oi, uintptr_t retaddr)
446
{
447
return (int8_t)helper_ret_ldub_mmu(env, addr, oi, retaddr);
448
}
449
450
tcg_target_ulong helper_le_ldsw_mmu(CPUArchState *env, target_ulong addr,
451
- TCGMemOpIdx oi, uintptr_t retaddr)
452
+ MemOpIdx oi, uintptr_t retaddr)
453
{
454
return (int16_t)helper_le_lduw_mmu(env, addr, oi, retaddr);
455
}
456
457
tcg_target_ulong helper_be_ldsw_mmu(CPUArchState *env, target_ulong addr,
458
- TCGMemOpIdx oi, uintptr_t retaddr)
459
+ MemOpIdx oi, uintptr_t retaddr)
460
{
461
return (int16_t)helper_be_lduw_mmu(env, addr, oi, retaddr);
462
}
463
464
tcg_target_ulong helper_le_ldsl_mmu(CPUArchState *env, target_ulong addr,
465
- TCGMemOpIdx oi, uintptr_t retaddr)
466
+ MemOpIdx oi, uintptr_t retaddr)
467
{
468
return (int32_t)helper_le_ldul_mmu(env, addr, oi, retaddr);
469
}
470
471
tcg_target_ulong helper_be_ldsl_mmu(CPUArchState *env, target_ulong addr,
472
- TCGMemOpIdx oi, uintptr_t retaddr)
473
+ MemOpIdx oi, uintptr_t retaddr)
474
{
475
return (int32_t)helper_be_ldul_mmu(env, addr, oi, retaddr);
476
}
477
@@ -XXX,XX +XXX,XX @@ static inline uint64_t cpu_load_helper(CPUArchState *env, abi_ptr addr,
478
MemOp op, FullLoadHelper *full_load)
479
{
480
uint16_t meminfo;
481
- TCGMemOpIdx oi;
482
+ MemOpIdx oi;
483
uint64_t ret;
484
485
meminfo = trace_mem_get_info(op, mmu_idx, false);
486
@@ -XXX,XX +XXX,XX @@ store_helper_unaligned(CPUArchState *env, target_ulong addr, uint64_t val,
487
uintptr_t index, index2;
488
CPUTLBEntry *entry, *entry2;
489
target_ulong page2, tlb_addr, tlb_addr2;
490
- TCGMemOpIdx oi;
491
+ MemOpIdx oi;
492
size_t size2;
493
int i;
494
495
@@ -XXX,XX +XXX,XX @@ store_helper_unaligned(CPUArchState *env, target_ulong addr, uint64_t val,
496
497
static inline void QEMU_ALWAYS_INLINE
498
store_helper(CPUArchState *env, target_ulong addr, uint64_t val,
499
- TCGMemOpIdx oi, uintptr_t retaddr, MemOp op)
500
+ MemOpIdx oi, uintptr_t retaddr, MemOp op)
501
{
502
uintptr_t mmu_idx = get_mmuidx(oi);
503
uintptr_t index = tlb_index(env, mmu_idx, addr);
504
@@ -XXX,XX +XXX,XX @@ store_helper(CPUArchState *env, target_ulong addr, uint64_t val,
505
506
void __attribute__((noinline))
507
helper_ret_stb_mmu(CPUArchState *env, target_ulong addr, uint8_t val,
508
- TCGMemOpIdx oi, uintptr_t retaddr)
509
+ MemOpIdx oi, uintptr_t retaddr)
510
{
511
store_helper(env, addr, val, oi, retaddr, MO_UB);
512
}
513
514
void helper_le_stw_mmu(CPUArchState *env, target_ulong addr, uint16_t val,
515
- TCGMemOpIdx oi, uintptr_t retaddr)
516
+ MemOpIdx oi, uintptr_t retaddr)
517
{
518
store_helper(env, addr, val, oi, retaddr, MO_LEUW);
519
}
520
521
void helper_be_stw_mmu(CPUArchState *env, target_ulong addr, uint16_t val,
522
- TCGMemOpIdx oi, uintptr_t retaddr)
523
+ MemOpIdx oi, uintptr_t retaddr)
524
{
525
store_helper(env, addr, val, oi, retaddr, MO_BEUW);
526
}
527
528
void helper_le_stl_mmu(CPUArchState *env, target_ulong addr, uint32_t val,
529
- TCGMemOpIdx oi, uintptr_t retaddr)
530
+ MemOpIdx oi, uintptr_t retaddr)
531
{
532
store_helper(env, addr, val, oi, retaddr, MO_LEUL);
533
}
534
535
void helper_be_stl_mmu(CPUArchState *env, target_ulong addr, uint32_t val,
536
- TCGMemOpIdx oi, uintptr_t retaddr)
537
+ MemOpIdx oi, uintptr_t retaddr)
538
{
539
store_helper(env, addr, val, oi, retaddr, MO_BEUL);
540
}
541
542
void helper_le_stq_mmu(CPUArchState *env, target_ulong addr, uint64_t val,
543
- TCGMemOpIdx oi, uintptr_t retaddr)
544
+ MemOpIdx oi, uintptr_t retaddr)
545
{
546
store_helper(env, addr, val, oi, retaddr, MO_LEQ);
547
}
548
549
void helper_be_stq_mmu(CPUArchState *env, target_ulong addr, uint64_t val,
550
- TCGMemOpIdx oi, uintptr_t retaddr)
551
+ MemOpIdx oi, uintptr_t retaddr)
552
{
553
store_helper(env, addr, val, oi, retaddr, MO_BEQ);
554
}
555
@@ -XXX,XX +XXX,XX @@ static inline void QEMU_ALWAYS_INLINE
556
cpu_store_helper(CPUArchState *env, target_ulong addr, uint64_t val,
557
int mmu_idx, uintptr_t retaddr, MemOp op)
558
{
559
- TCGMemOpIdx oi;
560
+ MemOpIdx oi;
561
uint16_t meminfo;
562
563
meminfo = trace_mem_get_info(op, mmu_idx, true);
564
@@ -XXX,XX +XXX,XX @@ void cpu_stq_le_data(CPUArchState *env, target_ulong ptr, uint64_t val)
565
/* Code access functions. */
566
567
static uint64_t full_ldub_code(CPUArchState *env, target_ulong addr,
568
- TCGMemOpIdx oi, uintptr_t retaddr)
569
+ MemOpIdx oi, uintptr_t retaddr)
570
{
571
return load_helper(env, addr, oi, retaddr, MO_8, true, full_ldub_code);
572
}
573
574
uint32_t cpu_ldub_code(CPUArchState *env, abi_ptr addr)
575
{
576
- TCGMemOpIdx oi = make_memop_idx(MO_UB, cpu_mmu_index(env, true));
577
+ MemOpIdx oi = make_memop_idx(MO_UB, cpu_mmu_index(env, true));
578
return full_ldub_code(env, addr, oi, 0);
579
}
580
581
static uint64_t full_lduw_code(CPUArchState *env, target_ulong addr,
582
- TCGMemOpIdx oi, uintptr_t retaddr)
583
+ MemOpIdx oi, uintptr_t retaddr)
584
{
585
return load_helper(env, addr, oi, retaddr, MO_TEUW, true, full_lduw_code);
586
}
587
588
uint32_t cpu_lduw_code(CPUArchState *env, abi_ptr addr)
589
{
590
- TCGMemOpIdx oi = make_memop_idx(MO_TEUW, cpu_mmu_index(env, true));
591
+ MemOpIdx oi = make_memop_idx(MO_TEUW, cpu_mmu_index(env, true));
592
return full_lduw_code(env, addr, oi, 0);
593
}
594
595
static uint64_t full_ldl_code(CPUArchState *env, target_ulong addr,
596
- TCGMemOpIdx oi, uintptr_t retaddr)
597
+ MemOpIdx oi, uintptr_t retaddr)
598
{
599
return load_helper(env, addr, oi, retaddr, MO_TEUL, true, full_ldl_code);
600
}
601
602
uint32_t cpu_ldl_code(CPUArchState *env, abi_ptr addr)
603
{
604
- TCGMemOpIdx oi = make_memop_idx(MO_TEUL, cpu_mmu_index(env, true));
605
+ MemOpIdx oi = make_memop_idx(MO_TEUL, cpu_mmu_index(env, true));
606
return full_ldl_code(env, addr, oi, 0);
607
}
608
609
static uint64_t full_ldq_code(CPUArchState *env, target_ulong addr,
610
- TCGMemOpIdx oi, uintptr_t retaddr)
611
+ MemOpIdx oi, uintptr_t retaddr)
612
{
613
return load_helper(env, addr, oi, retaddr, MO_TEQ, true, full_ldq_code);
614
}
615
616
uint64_t cpu_ldq_code(CPUArchState *env, abi_ptr addr)
617
{
618
- TCGMemOpIdx oi = make_memop_idx(MO_TEQ, cpu_mmu_index(env, true));
619
+ MemOpIdx oi = make_memop_idx(MO_TEQ, cpu_mmu_index(env, true));
620
return full_ldq_code(env, addr, oi, 0);
621
}
622
diff --git a/accel/tcg/user-exec.c b/accel/tcg/user-exec.c
623
index XXXXXXX..XXXXXXX 100644
624
--- a/accel/tcg/user-exec.c
625
+++ b/accel/tcg/user-exec.c
626
@@ -XXX,XX +XXX,XX @@ uint64_t cpu_ldq_code(CPUArchState *env, abi_ptr ptr)
627
* @prot may be PAGE_READ, PAGE_WRITE, or PAGE_READ|PAGE_WRITE.
628
*/
629
static void *atomic_mmu_lookup(CPUArchState *env, target_ulong addr,
630
- TCGMemOpIdx oi, int size, int prot,
631
+ MemOpIdx oi, int size, int prot,
632
uintptr_t retaddr)
633
{
634
/* Enforce qemu required alignment. */
635
diff --git a/target/arm/helper-a64.c b/target/arm/helper-a64.c
636
index XXXXXXX..XXXXXXX 100644
637
--- a/target/arm/helper-a64.c
638
+++ b/target/arm/helper-a64.c
639
@@ -XXX,XX +XXX,XX @@ uint64_t HELPER(paired_cmpxchg64_le)(CPUARMState *env, uint64_t addr,
640
clear_helper_retaddr();
641
#else
642
int mem_idx = cpu_mmu_index(env, false);
643
- TCGMemOpIdx oi0 = make_memop_idx(MO_LEQ | MO_ALIGN_16, mem_idx);
644
- TCGMemOpIdx oi1 = make_memop_idx(MO_LEQ, mem_idx);
645
+ MemOpIdx oi0 = make_memop_idx(MO_LEQ | MO_ALIGN_16, mem_idx);
646
+ MemOpIdx oi1 = make_memop_idx(MO_LEQ, mem_idx);
647
648
o0 = helper_le_ldq_mmu(env, addr + 0, oi0, ra);
649
o1 = helper_le_ldq_mmu(env, addr + 8, oi1, ra);
650
@@ -XXX,XX +XXX,XX @@ uint64_t HELPER(paired_cmpxchg64_le_parallel)(CPUARMState *env, uint64_t addr,
651
uintptr_t ra = GETPC();
652
bool success;
653
int mem_idx;
654
- TCGMemOpIdx oi;
655
+ MemOpIdx oi;
656
657
assert(HAVE_CMPXCHG128);
658
659
@@ -XXX,XX +XXX,XX @@ uint64_t HELPER(paired_cmpxchg64_be)(CPUARMState *env, uint64_t addr,
660
clear_helper_retaddr();
661
#else
662
int mem_idx = cpu_mmu_index(env, false);
663
- TCGMemOpIdx oi0 = make_memop_idx(MO_BEQ | MO_ALIGN_16, mem_idx);
664
- TCGMemOpIdx oi1 = make_memop_idx(MO_BEQ, mem_idx);
665
+ MemOpIdx oi0 = make_memop_idx(MO_BEQ | MO_ALIGN_16, mem_idx);
666
+ MemOpIdx oi1 = make_memop_idx(MO_BEQ, mem_idx);
667
668
o1 = helper_be_ldq_mmu(env, addr + 0, oi0, ra);
669
o0 = helper_be_ldq_mmu(env, addr + 8, oi1, ra);
670
@@ -XXX,XX +XXX,XX @@ uint64_t HELPER(paired_cmpxchg64_be_parallel)(CPUARMState *env, uint64_t addr,
671
uintptr_t ra = GETPC();
672
bool success;
673
int mem_idx;
674
- TCGMemOpIdx oi;
675
+ MemOpIdx oi;
676
677
assert(HAVE_CMPXCHG128);
678
679
@@ -XXX,XX +XXX,XX @@ void HELPER(casp_le_parallel)(CPUARMState *env, uint32_t rs, uint64_t addr,
680
Int128 oldv, cmpv, newv;
681
uintptr_t ra = GETPC();
682
int mem_idx;
683
- TCGMemOpIdx oi;
684
+ MemOpIdx oi;
685
686
assert(HAVE_CMPXCHG128);
687
688
@@ -XXX,XX +XXX,XX @@ void HELPER(casp_be_parallel)(CPUARMState *env, uint32_t rs, uint64_t addr,
689
Int128 oldv, cmpv, newv;
690
uintptr_t ra = GETPC();
691
int mem_idx;
692
- TCGMemOpIdx oi;
693
+ MemOpIdx oi;
694
695
assert(HAVE_CMPXCHG128);
696
697
diff --git a/target/arm/m_helper.c b/target/arm/m_helper.c
698
index XXXXXXX..XXXXXXX 100644
699
--- a/target/arm/m_helper.c
700
+++ b/target/arm/m_helper.c
701
@@ -XXX,XX +XXX,XX @@ static bool do_v7m_function_return(ARMCPU *cpu)
702
703
{
704
bool threadmode, spsel;
705
- TCGMemOpIdx oi;
706
+ MemOpIdx oi;
707
ARMMMUIdx mmu_idx;
708
uint32_t *frame_sp_p;
709
uint32_t frameptr;
710
diff --git a/target/i386/tcg/mem_helper.c b/target/i386/tcg/mem_helper.c
711
index XXXXXXX..XXXXXXX 100644
712
--- a/target/i386/tcg/mem_helper.c
713
+++ b/target/i386/tcg/mem_helper.c
714
@@ -XXX,XX +XXX,XX @@ void helper_cmpxchg8b(CPUX86State *env, target_ulong a0)
715
{
716
uintptr_t ra = GETPC();
717
int mem_idx = cpu_mmu_index(env, false);
718
- TCGMemOpIdx oi = make_memop_idx(MO_TEQ, mem_idx);
719
+ MemOpIdx oi = make_memop_idx(MO_TEQ, mem_idx);
720
oldv = cpu_atomic_cmpxchgq_le_mmu(env, a0, cmpv, newv, oi, ra);
721
}
722
723
@@ -XXX,XX +XXX,XX @@ void helper_cmpxchg16b(CPUX86State *env, target_ulong a0)
724
Int128 newv = int128_make128(env->regs[R_EBX], env->regs[R_ECX]);
725
726
int mem_idx = cpu_mmu_index(env, false);
727
- TCGMemOpIdx oi = make_memop_idx(MO_TEQ | MO_ALIGN_16, mem_idx);
728
+ MemOpIdx oi = make_memop_idx(MO_TEQ | MO_ALIGN_16, mem_idx);
729
Int128 oldv = cpu_atomic_cmpxchgo_le_mmu(env, a0, cmpv, newv, oi, ra);
730
731
if (int128_eq(oldv, cmpv)) {
732
diff --git a/target/m68k/op_helper.c b/target/m68k/op_helper.c
733
index XXXXXXX..XXXXXXX 100644
734
--- a/target/m68k/op_helper.c
735
+++ b/target/m68k/op_helper.c
736
@@ -XXX,XX +XXX,XX @@ static void do_cas2l(CPUM68KState *env, uint32_t regs, uint32_t a1, uint32_t a2,
737
uintptr_t ra = GETPC();
738
#if defined(CONFIG_ATOMIC64)
739
int mmu_idx = cpu_mmu_index(env, 0);
740
- TCGMemOpIdx oi = make_memop_idx(MO_BEQ, mmu_idx);
741
+ MemOpIdx oi = make_memop_idx(MO_BEQ, mmu_idx);
742
#endif
743
744
if (parallel) {
745
diff --git a/target/mips/tcg/msa_helper.c b/target/mips/tcg/msa_helper.c
746
index XXXXXXX..XXXXXXX 100644
747
--- a/target/mips/tcg/msa_helper.c
748
+++ b/target/mips/tcg/msa_helper.c
749
@@ -XXX,XX +XXX,XX @@ void helper_msa_ffint_u_df(CPUMIPSState *env, uint32_t df, uint32_t wd,
750
#define DF_ELEMENTS(df) (MSA_WRLEN / DF_BITS(df))
751
752
#if !defined(CONFIG_USER_ONLY)
753
-#define MEMOP_IDX(DF) \
754
- TCGMemOpIdx oi = make_memop_idx(MO_TE | DF | MO_UNALN, \
755
- cpu_mmu_index(env, false));
756
+#define MEMOP_IDX(DF) \
757
+ MemOpIdx oi = make_memop_idx(MO_TE | DF | MO_UNALN, \
758
+ cpu_mmu_index(env, false));
759
#else
760
#define MEMOP_IDX(DF)
761
#endif
762
diff --git a/target/s390x/tcg/mem_helper.c b/target/s390x/tcg/mem_helper.c
763
index XXXXXXX..XXXXXXX 100644
764
--- a/target/s390x/tcg/mem_helper.c
765
+++ b/target/s390x/tcg/mem_helper.c
766
@@ -XXX,XX +XXX,XX @@ static void do_access_memset(CPUS390XState *env, vaddr vaddr, char *haddr,
767
g_assert(haddr);
768
memset(haddr, byte, size);
769
#else
770
- TCGMemOpIdx oi = make_memop_idx(MO_UB, mmu_idx);
771
+ MemOpIdx oi = make_memop_idx(MO_UB, mmu_idx);
772
int i;
773
774
if (likely(haddr)) {
775
@@ -XXX,XX +XXX,XX @@ static uint8_t do_access_get_byte(CPUS390XState *env, vaddr vaddr, char **haddr,
776
#ifdef CONFIG_USER_ONLY
777
return ldub_p(*haddr + offset);
778
#else
779
- TCGMemOpIdx oi = make_memop_idx(MO_UB, mmu_idx);
780
+ MemOpIdx oi = make_memop_idx(MO_UB, mmu_idx);
781
uint8_t byte;
782
783
if (likely(*haddr)) {
784
@@ -XXX,XX +XXX,XX @@ static void do_access_set_byte(CPUS390XState *env, vaddr vaddr, char **haddr,
785
#ifdef CONFIG_USER_ONLY
786
stb_p(*haddr + offset, byte);
787
#else
788
- TCGMemOpIdx oi = make_memop_idx(MO_UB, mmu_idx);
789
+ MemOpIdx oi = make_memop_idx(MO_UB, mmu_idx);
790
791
if (likely(*haddr)) {
792
stb_p(*haddr + offset, byte);
793
@@ -XXX,XX +XXX,XX @@ void HELPER(cdsg_parallel)(CPUS390XState *env, uint64_t addr,
794
Int128 cmpv = int128_make128(env->regs[r1 + 1], env->regs[r1]);
795
Int128 newv = int128_make128(env->regs[r3 + 1], env->regs[r3]);
796
int mem_idx;
797
- TCGMemOpIdx oi;
798
+ MemOpIdx oi;
799
Int128 oldv;
800
bool fail;
801
802
@@ -XXX,XX +XXX,XX @@ static uint32_t do_csst(CPUS390XState *env, uint32_t r3, uint64_t a1,
803
uint32_t *haddr = g2h(env_cpu(env), a1);
804
ov = qatomic_cmpxchg__nocheck(haddr, cv, nv);
805
#else
806
- TCGMemOpIdx oi = make_memop_idx(MO_TEUL | MO_ALIGN, mem_idx);
807
+ MemOpIdx oi = make_memop_idx(MO_TEUL | MO_ALIGN, mem_idx);
808
ov = cpu_atomic_cmpxchgl_be_mmu(env, a1, cv, nv, oi, ra);
809
#endif
810
} else {
811
@@ -XXX,XX +XXX,XX @@ static uint32_t do_csst(CPUS390XState *env, uint32_t r3, uint64_t a1,
812
813
if (parallel) {
814
#ifdef CONFIG_ATOMIC64
815
- TCGMemOpIdx oi = make_memop_idx(MO_TEQ | MO_ALIGN, mem_idx);
816
+ MemOpIdx oi = make_memop_idx(MO_TEQ | MO_ALIGN, mem_idx);
817
ov = cpu_atomic_cmpxchgq_be_mmu(env, a1, cv, nv, oi, ra);
818
#else
819
/* Note that we asserted !parallel above. */
820
@@ -XXX,XX +XXX,XX @@ static uint32_t do_csst(CPUS390XState *env, uint32_t r3, uint64_t a1,
821
cpu_stq_data_ra(env, a1 + 0, int128_gethi(nv), ra);
822
cpu_stq_data_ra(env, a1 + 8, int128_getlo(nv), ra);
823
} else if (HAVE_CMPXCHG128) {
824
- TCGMemOpIdx oi = make_memop_idx(MO_TEQ | MO_ALIGN_16, mem_idx);
825
+ MemOpIdx oi = make_memop_idx(MO_TEQ | MO_ALIGN_16, mem_idx);
826
ov = cpu_atomic_cmpxchgo_be_mmu(env, a1, cv, nv, oi, ra);
827
cc = !int128_eq(ov, cv);
828
} else {
829
@@ -XXX,XX +XXX,XX @@ static uint32_t do_csst(CPUS390XState *env, uint32_t r3, uint64_t a1,
830
cpu_stq_data_ra(env, a2 + 0, svh, ra);
831
cpu_stq_data_ra(env, a2 + 8, svl, ra);
832
} else if (HAVE_ATOMIC128) {
833
- TCGMemOpIdx oi = make_memop_idx(MO_TEQ | MO_ALIGN_16, mem_idx);
834
+ MemOpIdx oi = make_memop_idx(MO_TEQ | MO_ALIGN_16, mem_idx);
835
Int128 sv = int128_make128(svl, svh);
836
cpu_atomic_sto_be_mmu(env, a2, sv, oi, ra);
837
} else {
838
@@ -XXX,XX +XXX,XX @@ uint64_t HELPER(lpq_parallel)(CPUS390XState *env, uint64_t addr)
839
uintptr_t ra = GETPC();
840
uint64_t hi, lo;
841
int mem_idx;
842
- TCGMemOpIdx oi;
843
+ MemOpIdx oi;
844
Int128 v;
845
846
assert(HAVE_ATOMIC128);
847
@@ -XXX,XX +XXX,XX @@ void HELPER(stpq_parallel)(CPUS390XState *env, uint64_t addr,
848
{
849
uintptr_t ra = GETPC();
850
int mem_idx;
851
- TCGMemOpIdx oi;
852
+ MemOpIdx oi;
853
Int128 v;
854
855
assert(HAVE_ATOMIC128);
856
diff --git a/target/sparc/ldst_helper.c b/target/sparc/ldst_helper.c
857
index XXXXXXX..XXXXXXX 100644
858
--- a/target/sparc/ldst_helper.c
859
+++ b/target/sparc/ldst_helper.c
860
@@ -XXX,XX +XXX,XX @@ uint64_t helper_ld_asi(CPUSPARCState *env, target_ulong addr,
861
case ASI_SNF:
862
case ASI_SNFL:
863
{
864
- TCGMemOpIdx oi;
865
+ MemOpIdx oi;
866
int idx = (env->pstate & PS_PRIV
867
? (asi & 1 ? MMU_KERNEL_SECONDARY_IDX : MMU_KERNEL_IDX)
868
: (asi & 1 ? MMU_USER_SECONDARY_IDX : MMU_USER_IDX));
869
diff --git a/tcg/optimize.c b/tcg/optimize.c
870
index XXXXXXX..XXXXXXX 100644
871
--- a/tcg/optimize.c
872
+++ b/tcg/optimize.c
873
@@ -XXX,XX +XXX,XX @@ void tcg_optimize(TCGContext *s)
874
875
CASE_OP_32_64(qemu_ld):
876
{
877
- TCGMemOpIdx oi = op->args[nb_oargs + nb_iargs];
878
+ MemOpIdx oi = op->args[nb_oargs + nb_iargs];
879
MemOp mop = get_memop(oi);
880
if (!(mop & MO_SIGN)) {
881
mask = (2ULL << ((8 << (mop & MO_SIZE)) - 1)) - 1;
882
diff --git a/tcg/tcg-op.c b/tcg/tcg-op.c
883
index XXXXXXX..XXXXXXX 100644
884
--- a/tcg/tcg-op.c
885
+++ b/tcg/tcg-op.c
886
@@ -XXX,XX +XXX,XX @@ static inline MemOp tcg_canonicalize_memop(MemOp op, bool is64, bool st)
887
static void gen_ldst_i32(TCGOpcode opc, TCGv_i32 val, TCGv addr,
888
MemOp memop, TCGArg idx)
889
{
890
- TCGMemOpIdx oi = make_memop_idx(memop, idx);
891
+ MemOpIdx oi = make_memop_idx(memop, idx);
892
#if TARGET_LONG_BITS == 32
893
tcg_gen_op3i_i32(opc, val, addr, oi);
894
#else
895
@@ -XXX,XX +XXX,XX @@ static void gen_ldst_i32(TCGOpcode opc, TCGv_i32 val, TCGv addr,
896
static void gen_ldst_i64(TCGOpcode opc, TCGv_i64 val, TCGv addr,
897
MemOp memop, TCGArg idx)
898
{
899
- TCGMemOpIdx oi = make_memop_idx(memop, idx);
900
+ MemOpIdx oi = make_memop_idx(memop, idx);
901
#if TARGET_LONG_BITS == 32
902
if (TCG_TARGET_REG_BITS == 32) {
903
tcg_gen_op4i_i32(opc, TCGV_LOW(val), TCGV_HIGH(val), addr, oi);
904
@@ -XXX,XX +XXX,XX @@ void tcg_gen_atomic_cmpxchg_i32(TCGv_i32 retv, TCGv addr, TCGv_i32 cmpv,
905
tcg_temp_free_i32(t1);
906
} else {
907
gen_atomic_cx_i32 gen;
908
- TCGMemOpIdx oi;
909
+ MemOpIdx oi;
910
911
gen = table_cmpxchg[memop & (MO_SIZE | MO_BSWAP)];
912
tcg_debug_assert(gen != NULL);
913
@@ -XXX,XX +XXX,XX @@ void tcg_gen_atomic_cmpxchg_i64(TCGv_i64 retv, TCGv addr, TCGv_i64 cmpv,
914
} else if ((memop & MO_SIZE) == MO_64) {
915
#ifdef CONFIG_ATOMIC64
916
gen_atomic_cx_i64 gen;
917
- TCGMemOpIdx oi;
918
+ MemOpIdx oi;
919
920
gen = table_cmpxchg[memop & (MO_SIZE | MO_BSWAP)];
921
tcg_debug_assert(gen != NULL);
922
@@ -XXX,XX +XXX,XX @@ static void do_atomic_op_i32(TCGv_i32 ret, TCGv addr, TCGv_i32 val,
923
TCGArg idx, MemOp memop, void * const table[])
924
{
925
gen_atomic_op_i32 gen;
926
- TCGMemOpIdx oi;
927
+ MemOpIdx oi;
928
929
memop = tcg_canonicalize_memop(memop, 0, 0);
930
931
@@ -XXX,XX +XXX,XX @@ static void do_atomic_op_i64(TCGv_i64 ret, TCGv addr, TCGv_i64 val,
932
if ((memop & MO_SIZE) == MO_64) {
933
#ifdef CONFIG_ATOMIC64
934
gen_atomic_op_i64 gen;
935
- TCGMemOpIdx oi;
936
+ MemOpIdx oi;
937
938
gen = table[memop & (MO_SIZE | MO_BSWAP)];
939
tcg_debug_assert(gen != NULL);
940
diff --git a/tcg/tcg.c b/tcg/tcg.c
941
index XXXXXXX..XXXXXXX 100644
942
--- a/tcg/tcg.c
943
+++ b/tcg/tcg.c
944
@@ -XXX,XX +XXX,XX @@ static void tcg_dump_ops(TCGContext *s, bool have_prefs)
945
case INDEX_op_qemu_ld_i64:
946
case INDEX_op_qemu_st_i64:
947
{
948
- TCGMemOpIdx oi = op->args[k++];
949
+ MemOpIdx oi = op->args[k++];
950
MemOp op = get_memop(oi);
951
unsigned ix = get_mmuidx(oi);
952
953
diff --git a/tcg/tci.c b/tcg/tci.c
954
index XXXXXXX..XXXXXXX 100644
955
--- a/tcg/tci.c
956
+++ b/tcg/tci.c
957
@@ -XXX,XX +XXX,XX @@ static uint64_t tci_uint64(uint32_t high, uint32_t low)
958
* i = immediate (uint32_t)
959
* I = immediate (tcg_target_ulong)
960
* l = label or pointer
961
- * m = immediate (TCGMemOpIdx)
962
+ * m = immediate (MemOpIdx)
963
* n = immediate (call return length)
964
* r = register
965
* s = signed ldst offset
966
@@ -XXX,XX +XXX,XX @@ static void tci_args_ri(uint32_t insn, TCGReg *r0, tcg_target_ulong *i1)
967
}
968
969
static void tci_args_rrm(uint32_t insn, TCGReg *r0,
970
- TCGReg *r1, TCGMemOpIdx *m2)
971
+ TCGReg *r1, MemOpIdx *m2)
972
{
973
*r0 = extract32(insn, 8, 4);
974
*r1 = extract32(insn, 12, 4);
975
@@ -XXX,XX +XXX,XX @@ static void tci_args_rrrc(uint32_t insn,
976
}
977
978
static void tci_args_rrrm(uint32_t insn,
979
- TCGReg *r0, TCGReg *r1, TCGReg *r2, TCGMemOpIdx *m3)
980
+ TCGReg *r0, TCGReg *r1, TCGReg *r2, MemOpIdx *m3)
981
{
982
*r0 = extract32(insn, 8, 4);
983
*r1 = extract32(insn, 12, 4);
984
@@ -XXX,XX +XXX,XX @@ static bool tci_compare64(uint64_t u0, uint64_t u1, TCGCond condition)
985
}
986
987
static uint64_t tci_qemu_ld(CPUArchState *env, target_ulong taddr,
988
- TCGMemOpIdx oi, const void *tb_ptr)
989
+ MemOpIdx oi, const void *tb_ptr)
990
{
991
MemOp mop = get_memop(oi) & (MO_BSWAP | MO_SSIZE);
992
uintptr_t ra = (uintptr_t)tb_ptr;
993
@@ -XXX,XX +XXX,XX @@ static uint64_t tci_qemu_ld(CPUArchState *env, target_ulong taddr,
994
}
995
996
static void tci_qemu_st(CPUArchState *env, target_ulong taddr, uint64_t val,
997
- TCGMemOpIdx oi, const void *tb_ptr)
998
+ MemOpIdx oi, const void *tb_ptr)
999
{
1000
MemOp mop = get_memop(oi) & (MO_BSWAP | MO_SSIZE);
1001
uintptr_t ra = (uintptr_t)tb_ptr;
1002
@@ -XXX,XX +XXX,XX @@ uintptr_t QEMU_DISABLE_CFI tcg_qemu_tb_exec(CPUArchState *env,
1003
uint32_t tmp32;
1004
uint64_t tmp64;
1005
uint64_t T1, T2;
1006
- TCGMemOpIdx oi;
1007
+ MemOpIdx oi;
1008
int32_t ofs;
1009
void *ptr;
1010
1011
@@ -XXX,XX +XXX,XX @@ int print_insn_tci(bfd_vma addr, disassemble_info *info)
1012
tcg_target_ulong i1;
1013
int32_t s2;
1014
TCGCond c;
1015
- TCGMemOpIdx oi;
1016
+ MemOpIdx oi;
1017
uint8_t pos, len;
1018
void *ptr;
1019
1020
diff --git a/accel/tcg/atomic_common.c.inc b/accel/tcg/atomic_common.c.inc
1021
index XXXXXXX..XXXXXXX 100644
1022
--- a/accel/tcg/atomic_common.c.inc
1023
+++ b/accel/tcg/atomic_common.c.inc
1024
@@ -XXX,XX +XXX,XX @@
1025
*/
1026
1027
static uint16_t atomic_trace_rmw_pre(CPUArchState *env, target_ulong addr,
1028
- TCGMemOpIdx oi)
1029
+ MemOpIdx oi)
1030
{
1031
CPUState *cpu = env_cpu(env);
1032
uint16_t info = trace_mem_get_info(get_memop(oi), get_mmuidx(oi), false);
1033
@@ -XXX,XX +XXX,XX @@ static void atomic_trace_rmw_post(CPUArchState *env, target_ulong addr,
1034
1035
#if HAVE_ATOMIC128
1036
static uint16_t atomic_trace_ld_pre(CPUArchState *env, target_ulong addr,
1037
- TCGMemOpIdx oi)
1038
+ MemOpIdx oi)
1039
{
1040
uint16_t info = trace_mem_get_info(get_memop(oi), get_mmuidx(oi), false);
1041
1042
@@ -XXX,XX +XXX,XX @@ static void atomic_trace_ld_post(CPUArchState *env, target_ulong addr,
1043
}
1044
1045
static uint16_t atomic_trace_st_pre(CPUArchState *env, target_ulong addr,
1046
- TCGMemOpIdx oi)
1047
+ MemOpIdx oi)
1048
{
1049
uint16_t info = trace_mem_get_info(get_memop(oi), get_mmuidx(oi), true);
1050
1051
diff --git a/tcg/aarch64/tcg-target.c.inc b/tcg/aarch64/tcg-target.c.inc
1052
index XXXXXXX..XXXXXXX 100644
1053
--- a/tcg/aarch64/tcg-target.c.inc
1054
+++ b/tcg/aarch64/tcg-target.c.inc
1055
@@ -XXX,XX +XXX,XX @@ static void tcg_out_cltz(TCGContext *s, TCGType ext, TCGReg d,
1056
#include "../tcg-ldst.c.inc"
1057
1058
/* helper signature: helper_ret_ld_mmu(CPUState *env, target_ulong addr,
1059
- * TCGMemOpIdx oi, uintptr_t ra)
1060
+ * MemOpIdx oi, uintptr_t ra)
1061
*/
1062
static void * const qemu_ld_helpers[MO_SIZE + 1] = {
1063
[MO_8] = helper_ret_ldub_mmu,
1064
@@ -XXX,XX +XXX,XX @@ static void * const qemu_ld_helpers[MO_SIZE + 1] = {
1065
};
1066
1067
/* helper signature: helper_ret_st_mmu(CPUState *env, target_ulong addr,
1068
- * uintxx_t val, TCGMemOpIdx oi,
1069
+ * uintxx_t val, MemOpIdx oi,
1070
* uintptr_t ra)
1071
*/
1072
static void * const qemu_st_helpers[MO_SIZE + 1] = {
1073
@@ -XXX,XX +XXX,XX @@ static inline void tcg_out_adr(TCGContext *s, TCGReg rd, const void *target)
1074
1075
static bool tcg_out_qemu_ld_slow_path(TCGContext *s, TCGLabelQemuLdst *lb)
1076
{
1077
- TCGMemOpIdx oi = lb->oi;
1078
+ MemOpIdx oi = lb->oi;
1079
MemOp opc = get_memop(oi);
1080
MemOp size = opc & MO_SIZE;
1081
1082
@@ -XXX,XX +XXX,XX @@ static bool tcg_out_qemu_ld_slow_path(TCGContext *s, TCGLabelQemuLdst *lb)
1083
1084
static bool tcg_out_qemu_st_slow_path(TCGContext *s, TCGLabelQemuLdst *lb)
1085
{
1086
- TCGMemOpIdx oi = lb->oi;
1087
+ MemOpIdx oi = lb->oi;
1088
MemOp opc = get_memop(oi);
1089
MemOp size = opc & MO_SIZE;
1090
1091
@@ -XXX,XX +XXX,XX @@ static bool tcg_out_qemu_st_slow_path(TCGContext *s, TCGLabelQemuLdst *lb)
1092
return true;
1093
}
1094
1095
-static void add_qemu_ldst_label(TCGContext *s, bool is_ld, TCGMemOpIdx oi,
1096
+static void add_qemu_ldst_label(TCGContext *s, bool is_ld, MemOpIdx oi,
1097
TCGType ext, TCGReg data_reg, TCGReg addr_reg,
1098
tcg_insn_unit *raddr, tcg_insn_unit *label_ptr)
1099
{
1100
@@ -XXX,XX +XXX,XX @@ static void tcg_out_qemu_st_direct(TCGContext *s, MemOp memop,
1101
}
1102
1103
static void tcg_out_qemu_ld(TCGContext *s, TCGReg data_reg, TCGReg addr_reg,
1104
- TCGMemOpIdx oi, TCGType ext)
1105
+ MemOpIdx oi, TCGType ext)
1106
{
1107
MemOp memop = get_memop(oi);
1108
const TCGType otype = TARGET_LONG_BITS == 64 ? TCG_TYPE_I64 : TCG_TYPE_I32;
1109
@@ -XXX,XX +XXX,XX @@ static void tcg_out_qemu_ld(TCGContext *s, TCGReg data_reg, TCGReg addr_reg,
1110
}
1111
1112
static void tcg_out_qemu_st(TCGContext *s, TCGReg data_reg, TCGReg addr_reg,
1113
- TCGMemOpIdx oi)
1114
+ MemOpIdx oi)
1115
{
1116
MemOp memop = get_memop(oi);
1117
const TCGType otype = TARGET_LONG_BITS == 64 ? TCG_TYPE_I64 : TCG_TYPE_I32;
1118
diff --git a/tcg/arm/tcg-target.c.inc b/tcg/arm/tcg-target.c.inc
1119
index XXXXXXX..XXXXXXX 100644
1120
--- a/tcg/arm/tcg-target.c.inc
1121
+++ b/tcg/arm/tcg-target.c.inc
1122
@@ -XXX,XX +XXX,XX @@ static TCGReg tcg_out_tlb_read(TCGContext *s, TCGReg addrlo, TCGReg addrhi,
1123
/* Record the context of a call to the out of line helper code for the slow
1124
path for a load or store, so that we can later generate the correct
1125
helper code. */
1126
-static void add_qemu_ldst_label(TCGContext *s, bool is_ld, TCGMemOpIdx oi,
1127
+static void add_qemu_ldst_label(TCGContext *s, bool is_ld, MemOpIdx oi,
1128
TCGReg datalo, TCGReg datahi, TCGReg addrlo,
1129
TCGReg addrhi, tcg_insn_unit *raddr,
1130
tcg_insn_unit *label_ptr)
1131
@@ -XXX,XX +XXX,XX @@ static void add_qemu_ldst_label(TCGContext *s, bool is_ld, TCGMemOpIdx oi,
1132
static bool tcg_out_qemu_ld_slow_path(TCGContext *s, TCGLabelQemuLdst *lb)
1133
{
1134
TCGReg argreg, datalo, datahi;
1135
- TCGMemOpIdx oi = lb->oi;
1136
+ MemOpIdx oi = lb->oi;
1137
MemOp opc = get_memop(oi);
1138
void *func;
1139
1140
@@ -XXX,XX +XXX,XX @@ static bool tcg_out_qemu_ld_slow_path(TCGContext *s, TCGLabelQemuLdst *lb)
1141
static bool tcg_out_qemu_st_slow_path(TCGContext *s, TCGLabelQemuLdst *lb)
1142
{
1143
TCGReg argreg, datalo, datahi;
1144
- TCGMemOpIdx oi = lb->oi;
1145
+ MemOpIdx oi = lb->oi;
1146
MemOp opc = get_memop(oi);
1147
1148
if (!reloc_pc24(lb->label_ptr[0], tcg_splitwx_to_rx(s->code_ptr))) {
1149
@@ -XXX,XX +XXX,XX @@ static void tcg_out_qemu_ld_direct(TCGContext *s, MemOp opc, TCGReg datalo,
1150
static void tcg_out_qemu_ld(TCGContext *s, const TCGArg *args, bool is64)
1151
{
1152
TCGReg addrlo, datalo, datahi, addrhi __attribute__((unused));
1153
- TCGMemOpIdx oi;
1154
+ MemOpIdx oi;
1155
MemOp opc;
1156
#ifdef CONFIG_SOFTMMU
1157
int mem_index;
1158
@@ -XXX,XX +XXX,XX @@ static void tcg_out_qemu_st_direct(TCGContext *s, MemOp opc, TCGReg datalo,
1159
static void tcg_out_qemu_st(TCGContext *s, const TCGArg *args, bool is64)
1160
{
1161
TCGReg addrlo, datalo, datahi, addrhi __attribute__((unused));
1162
- TCGMemOpIdx oi;
1163
+ MemOpIdx oi;
1164
MemOp opc;
1165
#ifdef CONFIG_SOFTMMU
1166
int mem_index;
1167
diff --git a/tcg/i386/tcg-target.c.inc b/tcg/i386/tcg-target.c.inc
1168
index XXXXXXX..XXXXXXX 100644
1169
--- a/tcg/i386/tcg-target.c.inc
1170
+++ b/tcg/i386/tcg-target.c.inc
1171
@@ -XXX,XX +XXX,XX @@ static inline void tcg_out_tlb_load(TCGContext *s, TCGReg addrlo, TCGReg addrhi,
1172
* for a load or store, so that we can later generate the correct helper code
1173
*/
1174
static void add_qemu_ldst_label(TCGContext *s, bool is_ld, bool is_64,
1175
- TCGMemOpIdx oi,
1176
+ MemOpIdx oi,
1177
TCGReg datalo, TCGReg datahi,
1178
TCGReg addrlo, TCGReg addrhi,
1179
tcg_insn_unit *raddr,
1180
@@ -XXX,XX +XXX,XX @@ static void add_qemu_ldst_label(TCGContext *s, bool is_ld, bool is_64,
1181
*/
1182
static bool tcg_out_qemu_ld_slow_path(TCGContext *s, TCGLabelQemuLdst *l)
1183
{
1184
- TCGMemOpIdx oi = l->oi;
1185
+ MemOpIdx oi = l->oi;
1186
MemOp opc = get_memop(oi);
1187
TCGReg data_reg;
1188
tcg_insn_unit **label_ptr = &l->label_ptr[0];
1189
@@ -XXX,XX +XXX,XX @@ static bool tcg_out_qemu_ld_slow_path(TCGContext *s, TCGLabelQemuLdst *l)
1190
*/
1191
static bool tcg_out_qemu_st_slow_path(TCGContext *s, TCGLabelQemuLdst *l)
1192
{
1193
- TCGMemOpIdx oi = l->oi;
1194
+ MemOpIdx oi = l->oi;
1195
MemOp opc = get_memop(oi);
1196
MemOp s_bits = opc & MO_SIZE;
1197
tcg_insn_unit **label_ptr = &l->label_ptr[0];
1198
@@ -XXX,XX +XXX,XX @@ static void tcg_out_qemu_ld(TCGContext *s, const TCGArg *args, bool is64)
1199
{
1200
TCGReg datalo, datahi, addrlo;
1201
TCGReg addrhi __attribute__((unused));
1202
- TCGMemOpIdx oi;
1203
+ MemOpIdx oi;
1204
MemOp opc;
1205
#if defined(CONFIG_SOFTMMU)
1206
int mem_index;
1207
@@ -XXX,XX +XXX,XX @@ static void tcg_out_qemu_st(TCGContext *s, const TCGArg *args, bool is64)
1208
{
1209
TCGReg datalo, datahi, addrlo;
1210
TCGReg addrhi __attribute__((unused));
1211
- TCGMemOpIdx oi;
1212
+ MemOpIdx oi;
1213
MemOp opc;
1214
#if defined(CONFIG_SOFTMMU)
1215
int mem_index;
1216
diff --git a/tcg/mips/tcg-target.c.inc b/tcg/mips/tcg-target.c.inc
1217
index XXXXXXX..XXXXXXX 100644
1218
--- a/tcg/mips/tcg-target.c.inc
1219
+++ b/tcg/mips/tcg-target.c.inc
1220
@@ -XXX,XX +XXX,XX @@ QEMU_BUILD_BUG_ON(TLB_MASK_TABLE_OFS(0) < -32768);
1221
* Clobbers TMP0, TMP1, TMP2, TMP3.
1222
*/
1223
static void tcg_out_tlb_load(TCGContext *s, TCGReg base, TCGReg addrl,
1224
- TCGReg addrh, TCGMemOpIdx oi,
1225
+ TCGReg addrh, MemOpIdx oi,
1226
tcg_insn_unit *label_ptr[2], bool is_load)
1227
{
1228
MemOp opc = get_memop(oi);
1229
@@ -XXX,XX +XXX,XX @@ static void tcg_out_tlb_load(TCGContext *s, TCGReg base, TCGReg addrl,
1230
tcg_out_opc_reg(s, ALIAS_PADD, base, TCG_TMP2, addrl);
1231
}
1232
1233
-static void add_qemu_ldst_label(TCGContext *s, int is_ld, TCGMemOpIdx oi,
1234
+static void add_qemu_ldst_label(TCGContext *s, int is_ld, MemOpIdx oi,
1235
TCGType ext,
1236
TCGReg datalo, TCGReg datahi,
1237
TCGReg addrlo, TCGReg addrhi,
1238
@@ -XXX,XX +XXX,XX @@ static void add_qemu_ldst_label(TCGContext *s, int is_ld, TCGMemOpIdx oi,
1239
static bool tcg_out_qemu_ld_slow_path(TCGContext *s, TCGLabelQemuLdst *l)
1240
{
1241
const tcg_insn_unit *tgt_rx = tcg_splitwx_to_rx(s->code_ptr);
1242
- TCGMemOpIdx oi = l->oi;
1243
+ MemOpIdx oi = l->oi;
1244
MemOp opc = get_memop(oi);
1245
TCGReg v0;
1246
int i;
1247
@@ -XXX,XX +XXX,XX @@ static bool tcg_out_qemu_ld_slow_path(TCGContext *s, TCGLabelQemuLdst *l)
1248
static bool tcg_out_qemu_st_slow_path(TCGContext *s, TCGLabelQemuLdst *l)
1249
{
1250
const tcg_insn_unit *tgt_rx = tcg_splitwx_to_rx(s->code_ptr);
1251
- TCGMemOpIdx oi = l->oi;
1252
+ MemOpIdx oi = l->oi;
1253
MemOp opc = get_memop(oi);
1254
MemOp s_bits = opc & MO_SIZE;
1255
int i;
1256
@@ -XXX,XX +XXX,XX @@ static void tcg_out_qemu_ld(TCGContext *s, const TCGArg *args, bool is_64)
1257
{
1258
TCGReg addr_regl, addr_regh __attribute__((unused));
1259
TCGReg data_regl, data_regh;
1260
- TCGMemOpIdx oi;
1261
+ MemOpIdx oi;
1262
MemOp opc;
1263
#if defined(CONFIG_SOFTMMU)
1264
tcg_insn_unit *label_ptr[2];
1265
@@ -XXX,XX +XXX,XX @@ static void tcg_out_qemu_st(TCGContext *s, const TCGArg *args, bool is_64)
1266
{
1267
TCGReg addr_regl, addr_regh __attribute__((unused));
1268
TCGReg data_regl, data_regh;
1269
- TCGMemOpIdx oi;
1270
+ MemOpIdx oi;
1271
MemOp opc;
1272
#if defined(CONFIG_SOFTMMU)
1273
tcg_insn_unit *label_ptr[2];
1274
diff --git a/tcg/ppc/tcg-target.c.inc b/tcg/ppc/tcg-target.c.inc
1275
index XXXXXXX..XXXXXXX 100644
1276
--- a/tcg/ppc/tcg-target.c.inc
1277
+++ b/tcg/ppc/tcg-target.c.inc
1278
@@ -XXX,XX +XXX,XX @@ static TCGReg tcg_out_tlb_read(TCGContext *s, MemOp opc,
1279
/* Record the context of a call to the out of line helper code for the slow
1280
path for a load or store, so that we can later generate the correct
1281
helper code. */
1282
-static void add_qemu_ldst_label(TCGContext *s, bool is_ld, TCGMemOpIdx oi,
1283
+static void add_qemu_ldst_label(TCGContext *s, bool is_ld, MemOpIdx oi,
1284
TCGReg datalo_reg, TCGReg datahi_reg,
1285
TCGReg addrlo_reg, TCGReg addrhi_reg,
1286
tcg_insn_unit *raddr, tcg_insn_unit *lptr)
1287
@@ -XXX,XX +XXX,XX @@ static void add_qemu_ldst_label(TCGContext *s, bool is_ld, TCGMemOpIdx oi,
1288
1289
static bool tcg_out_qemu_ld_slow_path(TCGContext *s, TCGLabelQemuLdst *lb)
1290
{
1291
- TCGMemOpIdx oi = lb->oi;
1292
+ MemOpIdx oi = lb->oi;
1293
MemOp opc = get_memop(oi);
1294
TCGReg hi, lo, arg = TCG_REG_R3;
1295
1296
@@ -XXX,XX +XXX,XX @@ static bool tcg_out_qemu_ld_slow_path(TCGContext *s, TCGLabelQemuLdst *lb)
1297
1298
static bool tcg_out_qemu_st_slow_path(TCGContext *s, TCGLabelQemuLdst *lb)
1299
{
1300
- TCGMemOpIdx oi = lb->oi;
1301
+ MemOpIdx oi = lb->oi;
1302
MemOp opc = get_memop(oi);
1303
MemOp s_bits = opc & MO_SIZE;
1304
TCGReg hi, lo, arg = TCG_REG_R3;
1305
@@ -XXX,XX +XXX,XX @@ static void tcg_out_qemu_ld(TCGContext *s, const TCGArg *args, bool is_64)
1306
{
1307
TCGReg datalo, datahi, addrlo, rbase;
1308
TCGReg addrhi __attribute__((unused));
1309
- TCGMemOpIdx oi;
1310
+ MemOpIdx oi;
1311
MemOp opc, s_bits;
1312
#ifdef CONFIG_SOFTMMU
1313
int mem_index;
1314
@@ -XXX,XX +XXX,XX @@ static void tcg_out_qemu_st(TCGContext *s, const TCGArg *args, bool is_64)
1315
{
1316
TCGReg datalo, datahi, addrlo, rbase;
1317
TCGReg addrhi __attribute__((unused));
1318
- TCGMemOpIdx oi;
1319
+ MemOpIdx oi;
1320
MemOp opc, s_bits;
1321
#ifdef CONFIG_SOFTMMU
1322
int mem_index;
1323
diff --git a/tcg/riscv/tcg-target.c.inc b/tcg/riscv/tcg-target.c.inc
1324
index XXXXXXX..XXXXXXX 100644
1325
--- a/tcg/riscv/tcg-target.c.inc
1326
+++ b/tcg/riscv/tcg-target.c.inc
1327
@@ -XXX,XX +XXX,XX @@ static void tcg_out_mb(TCGContext *s, TCGArg a0)
1328
#include "../tcg-ldst.c.inc"
1329
1330
/* helper signature: helper_ret_ld_mmu(CPUState *env, target_ulong addr,
1331
- * TCGMemOpIdx oi, uintptr_t ra)
1332
+ * MemOpIdx oi, uintptr_t ra)
1333
*/
1334
static void * const qemu_ld_helpers[MO_SSIZE + 1] = {
1335
[MO_UB] = helper_ret_ldub_mmu,
1336
@@ -XXX,XX +XXX,XX @@ static void * const qemu_ld_helpers[MO_SSIZE + 1] = {
1337
};
1338
1339
/* helper signature: helper_ret_st_mmu(CPUState *env, target_ulong addr,
1340
- * uintxx_t val, TCGMemOpIdx oi,
1341
+ * uintxx_t val, MemOpIdx oi,
1342
* uintptr_t ra)
1343
*/
1344
static void * const qemu_st_helpers[MO_SIZE + 1] = {
1345
@@ -XXX,XX +XXX,XX @@ static void tcg_out_goto(TCGContext *s, const tcg_insn_unit *target)
1346
}
1347
1348
static void tcg_out_tlb_load(TCGContext *s, TCGReg addrl,
1349
- TCGReg addrh, TCGMemOpIdx oi,
1350
+ TCGReg addrh, MemOpIdx oi,
1351
tcg_insn_unit **label_ptr, bool is_load)
1352
{
1353
MemOp opc = get_memop(oi);
1354
@@ -XXX,XX +XXX,XX @@ static void tcg_out_tlb_load(TCGContext *s, TCGReg addrl,
1355
tcg_out_opc_reg(s, OPC_ADD, TCG_REG_TMP0, TCG_REG_TMP2, addrl);
1356
}
1357
1358
-static void add_qemu_ldst_label(TCGContext *s, int is_ld, TCGMemOpIdx oi,
1359
+static void add_qemu_ldst_label(TCGContext *s, int is_ld, MemOpIdx oi,
1360
TCGType ext,
1361
TCGReg datalo, TCGReg datahi,
1362
TCGReg addrlo, TCGReg addrhi,
1363
@@ -XXX,XX +XXX,XX @@ static void add_qemu_ldst_label(TCGContext *s, int is_ld, TCGMemOpIdx oi,
1364
1365
static bool tcg_out_qemu_ld_slow_path(TCGContext *s, TCGLabelQemuLdst *l)
1366
{
1367
- TCGMemOpIdx oi = l->oi;
1368
+ MemOpIdx oi = l->oi;
1369
MemOp opc = get_memop(oi);
1370
TCGReg a0 = tcg_target_call_iarg_regs[0];
1371
TCGReg a1 = tcg_target_call_iarg_regs[1];
1372
@@ -XXX,XX +XXX,XX @@ static bool tcg_out_qemu_ld_slow_path(TCGContext *s, TCGLabelQemuLdst *l)
1373
1374
static bool tcg_out_qemu_st_slow_path(TCGContext *s, TCGLabelQemuLdst *l)
1375
{
1376
- TCGMemOpIdx oi = l->oi;
1377
+ MemOpIdx oi = l->oi;
1378
MemOp opc = get_memop(oi);
1379
MemOp s_bits = opc & MO_SIZE;
1380
TCGReg a0 = tcg_target_call_iarg_regs[0];
1381
@@ -XXX,XX +XXX,XX @@ static void tcg_out_qemu_ld(TCGContext *s, const TCGArg *args, bool is_64)
1382
{
1383
TCGReg addr_regl, addr_regh __attribute__((unused));
1384
TCGReg data_regl, data_regh;
1385
- TCGMemOpIdx oi;
1386
+ MemOpIdx oi;
1387
MemOp opc;
1388
#if defined(CONFIG_SOFTMMU)
1389
tcg_insn_unit *label_ptr[1];
1390
@@ -XXX,XX +XXX,XX @@ static void tcg_out_qemu_st(TCGContext *s, const TCGArg *args, bool is_64)
1391
{
1392
TCGReg addr_regl, addr_regh __attribute__((unused));
1393
TCGReg data_regl, data_regh;
1394
- TCGMemOpIdx oi;
1395
+ MemOpIdx oi;
1396
MemOp opc;
1397
#if defined(CONFIG_SOFTMMU)
1398
tcg_insn_unit *label_ptr[1];
1399
diff --git a/tcg/s390/tcg-target.c.inc b/tcg/s390/tcg-target.c.inc
1400
index XXXXXXX..XXXXXXX 100644
1401
--- a/tcg/s390/tcg-target.c.inc
1402
+++ b/tcg/s390/tcg-target.c.inc
1403
@@ -XXX,XX +XXX,XX @@ static TCGReg tcg_out_tlb_read(TCGContext *s, TCGReg addr_reg, MemOp opc,
1404
return addr_reg;
1405
}
1406
1407
-static void add_qemu_ldst_label(TCGContext *s, bool is_ld, TCGMemOpIdx oi,
1408
+static void add_qemu_ldst_label(TCGContext *s, bool is_ld, MemOpIdx oi,
1409
TCGReg data, TCGReg addr,
1410
tcg_insn_unit *raddr, tcg_insn_unit *label_ptr)
1411
{
1412
@@ -XXX,XX +XXX,XX @@ static bool tcg_out_qemu_ld_slow_path(TCGContext *s, TCGLabelQemuLdst *lb)
1413
{
1414
TCGReg addr_reg = lb->addrlo_reg;
1415
TCGReg data_reg = lb->datalo_reg;
1416
- TCGMemOpIdx oi = lb->oi;
1417
+ MemOpIdx oi = lb->oi;
1418
MemOp opc = get_memop(oi);
1419
1420
if (!patch_reloc(lb->label_ptr[0], R_390_PC16DBL,
1421
@@ -XXX,XX +XXX,XX @@ static bool tcg_out_qemu_st_slow_path(TCGContext *s, TCGLabelQemuLdst *lb)
1422
{
1423
TCGReg addr_reg = lb->addrlo_reg;
1424
TCGReg data_reg = lb->datalo_reg;
1425
- TCGMemOpIdx oi = lb->oi;
1426
+ MemOpIdx oi = lb->oi;
1427
MemOp opc = get_memop(oi);
1428
1429
if (!patch_reloc(lb->label_ptr[0], R_390_PC16DBL,
1430
@@ -XXX,XX +XXX,XX @@ static void tcg_prepare_user_ldst(TCGContext *s, TCGReg *addr_reg,
1431
#endif /* CONFIG_SOFTMMU */
1432
1433
static void tcg_out_qemu_ld(TCGContext* s, TCGReg data_reg, TCGReg addr_reg,
1434
- TCGMemOpIdx oi)
1435
+ MemOpIdx oi)
1436
{
1437
MemOp opc = get_memop(oi);
1438
#ifdef CONFIG_SOFTMMU
1439
@@ -XXX,XX +XXX,XX @@ static void tcg_out_qemu_ld(TCGContext* s, TCGReg data_reg, TCGReg addr_reg,
1440
}
1441
1442
static void tcg_out_qemu_st(TCGContext* s, TCGReg data_reg, TCGReg addr_reg,
1443
- TCGMemOpIdx oi)
1444
+ MemOpIdx oi)
1445
{
1446
MemOp opc = get_memop(oi);
1447
#ifdef CONFIG_SOFTMMU
1448
diff --git a/tcg/sparc/tcg-target.c.inc b/tcg/sparc/tcg-target.c.inc
1449
index XXXXXXX..XXXXXXX 100644
1450
--- a/tcg/sparc/tcg-target.c.inc
1451
+++ b/tcg/sparc/tcg-target.c.inc
1452
@@ -XXX,XX +XXX,XX @@ static const int qemu_st_opc[(MO_SIZE | MO_BSWAP) + 1] = {
1453
};
1454
1455
static void tcg_out_qemu_ld(TCGContext *s, TCGReg data, TCGReg addr,
1456
- TCGMemOpIdx oi, bool is_64)
1457
+ MemOpIdx oi, bool is_64)
1458
{
1459
MemOp memop = get_memop(oi);
1460
#ifdef CONFIG_SOFTMMU
1461
@@ -XXX,XX +XXX,XX @@ static void tcg_out_qemu_ld(TCGContext *s, TCGReg data, TCGReg addr,
1462
}
1463
1464
static void tcg_out_qemu_st(TCGContext *s, TCGReg data, TCGReg addr,
1465
- TCGMemOpIdx oi)
1466
+ MemOpIdx oi)
1467
{
1468
MemOp memop = get_memop(oi);
1469
#ifdef CONFIG_SOFTMMU
1470
diff --git a/tcg/tcg-ldst.c.inc b/tcg/tcg-ldst.c.inc
1471
index XXXXXXX..XXXXXXX 100644
1472
--- a/tcg/tcg-ldst.c.inc
1473
+++ b/tcg/tcg-ldst.c.inc
1474
@@ -XXX,XX +XXX,XX @@
1475
1476
typedef struct TCGLabelQemuLdst {
1477
bool is_ld; /* qemu_ld: true, qemu_st: false */
1478
- TCGMemOpIdx oi;
1479
+ MemOpIdx oi;
1480
TCGType type; /* result type of a load */
1481
TCGReg addrlo_reg; /* reg index for low word of guest virtual addr */
1482
TCGReg addrhi_reg; /* reg index for high word of guest virtual addr */
1483
--
1484
2.25.1
1485
1486
diff view generated by jsdifflib
[PULL 1/3] accel/tcg: split CpusAccel into three TCG variants
[PULL 07/28] tcg: Split out MemOpIdx to exec/memopidx.h
1
From: Claudio Fontana <cfontana@suse.de>
1
Move this code from tcg/tcg.h to its own header.
2
2
3
split up the CpusAccel tcg_cpus into three TCG variants:
4
5
tcg_cpus_rr (single threaded, round robin cpus)
6
tcg_cpus_icount (same as rr, but with instruction counting enabled)
7
tcg_cpus_mttcg (multi-threaded cpus)
8
9
Suggested-by: Richard Henderson <richard.henderson@linaro.org>
10
Signed-off-by: Claudio Fontana <cfontana@suse.de>
11
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
12
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
3
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
13
Message-Id: <20201015143217.29337-2-cfontana@suse.de>
14
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
4
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
15
---
5
---
16
accel/tcg/tcg-cpus-icount.h | 17 ++
6
include/exec/memopidx.h | 55 +++++++++++++++++++++++++++++++++++++++++
17
accel/tcg/tcg-cpus-mttcg.h | 21 ++
7
include/tcg/tcg.h | 39 +----------------------------
18
accel/tcg/tcg-cpus-rr.h | 20 ++
8
2 files changed, 56 insertions(+), 38 deletions(-)
19
accel/tcg/tcg-cpus.h | 13 +-
9
create mode 100644 include/exec/memopidx.h
20
accel/tcg/tcg-all.c | 8 +-
21
accel/tcg/tcg-cpus-icount.c | 147 +++++++++++
22
accel/tcg/tcg-cpus-mttcg.c | 117 +++++++++
23
accel/tcg/tcg-cpus-rr.c | 270 ++++++++++++++++++++
24
accel/tcg/tcg-cpus.c | 484 ++----------------------------------
25
softmmu/icount.c | 2 +-
26
accel/tcg/meson.build | 9 +-
27
11 files changed, 646 insertions(+), 462 deletions(-)
28
create mode 100644 accel/tcg/tcg-cpus-icount.h
29
create mode 100644 accel/tcg/tcg-cpus-mttcg.h
30
create mode 100644 accel/tcg/tcg-cpus-rr.h
31
create mode 100644 accel/tcg/tcg-cpus-icount.c
32
create mode 100644 accel/tcg/tcg-cpus-mttcg.c
33
create mode 100644 accel/tcg/tcg-cpus-rr.c
34
10
35
diff --git a/accel/tcg/tcg-cpus-icount.h b/accel/tcg/tcg-cpus-icount.h
11
diff --git a/include/exec/memopidx.h b/include/exec/memopidx.h
36
new file mode 100644
12
new file mode 100644
37
index XXXXXXX..XXXXXXX
13
index XXXXXXX..XXXXXXX
38
--- /dev/null
14
--- /dev/null
39
+++ b/accel/tcg/tcg-cpus-icount.h
15
+++ b/include/exec/memopidx.h
40
@@ -XXX,XX +XXX,XX @@
16
@@ -XXX,XX +XXX,XX @@
41
+/*
17
+/*
42
+ * QEMU TCG Single Threaded vCPUs implementation using instruction counting
18
+ * Combine the MemOp and mmu_idx parameters into a single value.
43
+ *
19
+ *
44
+ * Copyright 2020 SUSE LLC
20
+ * Authors:
21
+ * Richard Henderson <rth@twiddle.net>
45
+ *
22
+ *
46
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
23
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
47
+ * See the COPYING file in the top-level directory.
24
+ * See the COPYING file in the top-level directory.
48
+ */
25
+ */
49
+
26
+
50
+#ifndef TCG_CPUS_ICOUNT_H
27
+#ifndef EXEC_MEMOPIDX_H
51
+#define TCG_CPUS_ICOUNT_H
28
+#define EXEC_MEMOPIDX_H 1
52
+
29
+
53
+void handle_icount_deadline(void);
30
+#include "exec/memop.h"
54
+void prepare_icount_for_run(CPUState *cpu);
55
+void process_icount_data(CPUState *cpu);
56
+
31
+
57
+#endif /* TCG_CPUS_ICOUNT_H */
32
+typedef uint32_t MemOpIdx;
58
diff --git a/accel/tcg/tcg-cpus-mttcg.h b/accel/tcg/tcg-cpus-mttcg.h
33
+
59
new file mode 100644
34
+/**
60
index XXXXXXX..XXXXXXX
35
+ * make_memop_idx
61
--- /dev/null
36
+ * @op: memory operation
62
+++ b/accel/tcg/tcg-cpus-mttcg.h
37
+ * @idx: mmu index
63
@@ -XXX,XX +XXX,XX @@
64
+/*
65
+ * QEMU TCG Multi Threaded vCPUs implementation
66
+ *
38
+ *
67
+ * Copyright 2020 SUSE LLC
39
+ * Encode these values into a single parameter.
68
+ *
69
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
70
+ * See the COPYING file in the top-level directory.
71
+ */
40
+ */
72
+
41
+static inline MemOpIdx make_memop_idx(MemOp op, unsigned idx)
73
+#ifndef TCG_CPUS_MTTCG_H
74
+#define TCG_CPUS_MTTCG_H
75
+
76
+/*
77
+ * In the multi-threaded case each vCPU has its own thread. The TLS
78
+ * variable current_cpu can be used deep in the code to find the
79
+ * current CPUState for a given thread.
80
+ */
81
+
82
+void *tcg_cpu_thread_fn(void *arg);
83
+
84
+#endif /* TCG_CPUS_MTTCG_H */
85
diff --git a/accel/tcg/tcg-cpus-rr.h b/accel/tcg/tcg-cpus-rr.h
86
new file mode 100644
87
index XXXXXXX..XXXXXXX
88
--- /dev/null
89
+++ b/accel/tcg/tcg-cpus-rr.h
90
@@ -XXX,XX +XXX,XX @@
91
+/*
92
+ * QEMU TCG Single Threaded vCPUs implementation
93
+ *
94
+ * Copyright 2020 SUSE LLC
95
+ *
96
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
97
+ * See the COPYING file in the top-level directory.
98
+ */
99
+
100
+#ifndef TCG_CPUS_RR_H
101
+#define TCG_CPUS_RR_H
102
+
103
+#define TCG_KICK_PERIOD (NANOSECONDS_PER_SECOND / 10)
104
+
105
+/* Kick all RR vCPUs. */
106
+void qemu_cpu_kick_rr_cpus(CPUState *unused);
107
+
108
+void *tcg_rr_cpu_thread_fn(void *arg);
109
+
110
+#endif /* TCG_CPUS_RR_H */
111
diff --git a/accel/tcg/tcg-cpus.h b/accel/tcg/tcg-cpus.h
112
index XXXXXXX..XXXXXXX 100644
113
--- a/accel/tcg/tcg-cpus.h
114
+++ b/accel/tcg/tcg-cpus.h
115
@@ -XXX,XX +XXX,XX @@
116
/*
117
- * Accelerator CPUS Interface
118
+ * QEMU TCG vCPU common functionality
119
+ *
120
+ * Functionality common to all TCG vcpu variants: mttcg, rr and icount.
121
*
122
* Copyright 2020 SUSE LLC
123
*
124
@@ -XXX,XX +XXX,XX @@
125
126
#include "sysemu/cpus.h"
127
128
-extern const CpusAccel tcg_cpus;
129
+extern const CpusAccel tcg_cpus_mttcg;
130
+extern const CpusAccel tcg_cpus_icount;
131
+extern const CpusAccel tcg_cpus_rr;
132
+
133
+void tcg_start_vcpu_thread(CPUState *cpu);
134
+void qemu_tcg_destroy_vcpu(CPUState *cpu);
135
+int tcg_cpu_exec(CPUState *cpu);
136
+void tcg_handle_interrupt(CPUState *cpu, int mask);
137
138
#endif /* TCG_CPUS_H */
139
diff --git a/accel/tcg/tcg-all.c b/accel/tcg/tcg-all.c
140
index XXXXXXX..XXXXXXX 100644
141
--- a/accel/tcg/tcg-all.c
142
+++ b/accel/tcg/tcg-all.c
143
@@ -XXX,XX +XXX,XX @@ static int tcg_init(MachineState *ms)
144
145
tcg_exec_init(s->tb_size * 1024 * 1024);
146
mttcg_enabled = s->mttcg_enabled;
147
- cpus_register_accel(&tcg_cpus);
148
149
+ if (mttcg_enabled) {
150
+ cpus_register_accel(&tcg_cpus_mttcg);
151
+ } else if (icount_enabled()) {
152
+ cpus_register_accel(&tcg_cpus_icount);
153
+ } else {
154
+ cpus_register_accel(&tcg_cpus_rr);
155
+ }
156
return 0;
157
}
158
159
diff --git a/accel/tcg/tcg-cpus-icount.c b/accel/tcg/tcg-cpus-icount.c
160
new file mode 100644
161
index XXXXXXX..XXXXXXX
162
--- /dev/null
163
+++ b/accel/tcg/tcg-cpus-icount.c
164
@@ -XXX,XX +XXX,XX @@
165
+/*
166
+ * QEMU TCG Single Threaded vCPUs implementation using instruction counting
167
+ *
168
+ * Copyright (c) 2003-2008 Fabrice Bellard
169
+ * Copyright (c) 2014 Red Hat Inc.
170
+ *
171
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
172
+ * of this software and associated documentation files (the "Software"), to deal
173
+ * in the Software without restriction, including without limitation the rights
174
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
175
+ * copies of the Software, and to permit persons to whom the Software is
176
+ * furnished to do so, subject to the following conditions:
177
+ *
178
+ * The above copyright notice and this permission notice shall be included in
179
+ * all copies or substantial portions of the Software.
180
+ *
181
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
182
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
183
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
184
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
185
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
186
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
187
+ * THE SOFTWARE.
188
+ */
189
+
190
+#include "qemu/osdep.h"
191
+#include "qemu-common.h"
192
+#include "sysemu/tcg.h"
193
+#include "sysemu/replay.h"
194
+#include "qemu/main-loop.h"
195
+#include "qemu/guest-random.h"
196
+#include "exec/exec-all.h"
197
+#include "hw/boards.h"
198
+
199
+#include "tcg-cpus.h"
200
+#include "tcg-cpus-icount.h"
201
+#include "tcg-cpus-rr.h"
202
+
203
+static int64_t tcg_get_icount_limit(void)
204
+{
42
+{
205
+ int64_t deadline;
43
+#ifdef CONFIG_DEBUG_TCG
206
+
44
+ assert(idx <= 15);
207
+ if (replay_mode != REPLAY_MODE_PLAY) {
45
+#endif
208
+ /*
46
+ return (op << 4) | idx;
209
+ * Include all the timers, because they may need an attention.
210
+ * Too long CPU execution may create unnecessary delay in UI.
211
+ */
212
+ deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL,
213
+ QEMU_TIMER_ATTR_ALL);
214
+ /* Check realtime timers, because they help with input processing */
215
+ deadline = qemu_soonest_timeout(deadline,
216
+ qemu_clock_deadline_ns_all(QEMU_CLOCK_REALTIME,
217
+ QEMU_TIMER_ATTR_ALL));
218
+
219
+ /*
220
+ * Maintain prior (possibly buggy) behaviour where if no deadline
221
+ * was set (as there is no QEMU_CLOCK_VIRTUAL timer) or it is more than
222
+ * INT32_MAX nanoseconds ahead, we still use INT32_MAX
223
+ * nanoseconds.
224
+ */
225
+ if ((deadline < 0) || (deadline > INT32_MAX)) {
226
+ deadline = INT32_MAX;
227
+ }
228
+
229
+ return icount_round(deadline);
230
+ } else {
231
+ return replay_get_instructions();
232
+ }
233
+}
47
+}
234
+
48
+
235
+static void notify_aio_contexts(void)
49
+/**
50
+ * get_memop
51
+ * @oi: combined op/idx parameter
52
+ *
53
+ * Extract the memory operation from the combined value.
54
+ */
55
+static inline MemOp get_memop(MemOpIdx oi)
236
+{
56
+{
237
+ /* Wake up other AioContexts. */
57
+ return oi >> 4;
238
+ qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
239
+ qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
240
+}
58
+}
241
+
59
+
242
+void handle_icount_deadline(void)
60
+/**
61
+ * get_mmuidx
62
+ * @oi: combined op/idx parameter
63
+ *
64
+ * Extract the mmu index from the combined value.
65
+ */
66
+static inline unsigned get_mmuidx(MemOpIdx oi)
243
+{
67
+{
244
+ assert(qemu_in_vcpu_thread());
68
+ return oi & 15;
245
+ int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL,
246
+ QEMU_TIMER_ATTR_ALL);
247
+
248
+ if (deadline == 0) {
249
+ notify_aio_contexts();
250
+ }
251
+}
69
+}
252
+
70
+
253
+void prepare_icount_for_run(CPUState *cpu)
71
+#endif
254
+{
72
diff --git a/include/tcg/tcg.h b/include/tcg/tcg.h
255
+ int insns_left;
73
index XXXXXXX..XXXXXXX 100644
256
+
74
--- a/include/tcg/tcg.h
257
+ /*
75
+++ b/include/tcg/tcg.h
258
+ * These should always be cleared by process_icount_data after
259
+ * each vCPU execution. However u16.high can be raised
260
+ * asynchronously by cpu_exit/cpu_interrupt/tcg_handle_interrupt
261
+ */
262
+ g_assert(cpu_neg(cpu)->icount_decr.u16.low == 0);
263
+ g_assert(cpu->icount_extra == 0);
264
+
265
+ cpu->icount_budget = tcg_get_icount_limit();
266
+ insns_left = MIN(0xffff, cpu->icount_budget);
267
+ cpu_neg(cpu)->icount_decr.u16.low = insns_left;
268
+ cpu->icount_extra = cpu->icount_budget - insns_left;
269
+
270
+ replay_mutex_lock();
271
+
272
+ if (cpu->icount_budget == 0 && replay_has_checkpoint()) {
273
+ notify_aio_contexts();
274
+ }
275
+}
276
+
277
+void process_icount_data(CPUState *cpu)
278
+{
279
+ /* Account for executed instructions */
280
+ icount_update(cpu);
281
+
282
+ /* Reset the counters */
283
+ cpu_neg(cpu)->icount_decr.u16.low = 0;
284
+ cpu->icount_extra = 0;
285
+ cpu->icount_budget = 0;
286
+
287
+ replay_account_executed_instructions();
288
+
289
+ replay_mutex_unlock();
290
+}
291
+
292
+static void icount_handle_interrupt(CPUState *cpu, int mask)
293
+{
294
+ int old_mask = cpu->interrupt_request;
295
+
296
+ tcg_handle_interrupt(cpu, mask);
297
+ if (qemu_cpu_is_self(cpu) &&
298
+ !cpu->can_do_io
299
+ && (mask & ~old_mask) != 0) {
300
+ cpu_abort(cpu, "Raised interrupt while not in I/O function");
301
+ }
302
+}
303
+
304
+const CpusAccel tcg_cpus_icount = {
305
+ .create_vcpu_thread = tcg_start_vcpu_thread,
306
+ .kick_vcpu_thread = qemu_cpu_kick_rr_cpus,
307
+
308
+ .handle_interrupt = icount_handle_interrupt,
309
+ .get_virtual_clock = icount_get,
310
+ .get_elapsed_ticks = icount_get,
311
+};
312
diff --git a/accel/tcg/tcg-cpus-mttcg.c b/accel/tcg/tcg-cpus-mttcg.c
313
new file mode 100644
314
index XXXXXXX..XXXXXXX
315
--- /dev/null
316
+++ b/accel/tcg/tcg-cpus-mttcg.c
317
@@ -XXX,XX +XXX,XX @@
76
@@ -XXX,XX +XXX,XX @@
318
+/*
77
319
+ * QEMU TCG Multi Threaded vCPUs implementation
78
#include "cpu.h"
320
+ *
79
#include "exec/memop.h"
321
+ * Copyright (c) 2003-2008 Fabrice Bellard
80
+#include "exec/memopidx.h"
322
+ * Copyright (c) 2014 Red Hat Inc.
81
#include "qemu/bitops.h"
323
+ *
82
#include "qemu/plugin.h"
324
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
83
#include "qemu/queue.h"
325
+ * of this software and associated documentation files (the "Software"), to deal
84
@@ -XXX,XX +XXX,XX @@ static inline size_t tcg_current_code_size(TCGContext *s)
326
+ * in the Software without restriction, including without limitation the rights
85
return tcg_ptr_byte_diff(s->code_ptr, s->code_buf);
327
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
86
}
328
+ * copies of the Software, and to permit persons to whom the Software is
87
329
+ * furnished to do so, subject to the following conditions:
88
-/* Combine the MemOp and mmu_idx parameters into a single value. */
330
+ *
89
-typedef uint32_t MemOpIdx;
331
+ * The above copyright notice and this permission notice shall be included in
90
-
332
+ * all copies or substantial portions of the Software.
91
-/**
333
+ *
92
- * make_memop_idx
334
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
93
- * @op: memory operation
335
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
94
- * @idx: mmu index
336
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
95
- *
337
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
96
- * Encode these values into a single parameter.
338
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
97
- */
339
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
98
-static inline MemOpIdx make_memop_idx(MemOp op, unsigned idx)
340
+ * THE SOFTWARE.
341
+ */
342
+
343
+#include "qemu/osdep.h"
344
+#include "qemu-common.h"
345
+#include "sysemu/tcg.h"
346
+#include "sysemu/replay.h"
347
+#include "qemu/main-loop.h"
348
+#include "qemu/guest-random.h"
349
+#include "exec/exec-all.h"
350
+#include "hw/boards.h"
351
+
352
+#include "tcg-cpus.h"
353
+#include "tcg-cpus-mttcg.h"
354
+
355
+/*
356
+ * In the multi-threaded case each vCPU has its own thread. The TLS
357
+ * variable current_cpu can be used deep in the code to find the
358
+ * current CPUState for a given thread.
359
+ */
360
+
361
+void *tcg_cpu_thread_fn(void *arg)
362
+{
363
+ CPUState *cpu = arg;
364
+
365
+ assert(tcg_enabled());
366
+ g_assert(!icount_enabled());
367
+
368
+ rcu_register_thread();
369
+ tcg_register_thread();
370
+
371
+ qemu_mutex_lock_iothread();
372
+ qemu_thread_get_self(cpu->thread);
373
+
374
+ cpu->thread_id = qemu_get_thread_id();
375
+ cpu->can_do_io = 1;
376
+ current_cpu = cpu;
377
+ cpu_thread_signal_created(cpu);
378
+ qemu_guest_random_seed_thread_part2(cpu->random_seed);
379
+
380
+ /* process any pending work */
381
+ cpu->exit_request = 1;
382
+
383
+ do {
384
+ if (cpu_can_run(cpu)) {
385
+ int r;
386
+ qemu_mutex_unlock_iothread();
387
+ r = tcg_cpu_exec(cpu);
388
+ qemu_mutex_lock_iothread();
389
+ switch (r) {
390
+ case EXCP_DEBUG:
391
+ cpu_handle_guest_debug(cpu);
392
+ break;
393
+ case EXCP_HALTED:
394
+ /*
395
+ * during start-up the vCPU is reset and the thread is
396
+ * kicked several times. If we don't ensure we go back
397
+ * to sleep in the halted state we won't cleanly
398
+ * start-up when the vCPU is enabled.
399
+ *
400
+ * cpu->halted should ensure we sleep in wait_io_event
401
+ */
402
+ g_assert(cpu->halted);
403
+ break;
404
+ case EXCP_ATOMIC:
405
+ qemu_mutex_unlock_iothread();
406
+ cpu_exec_step_atomic(cpu);
407
+ qemu_mutex_lock_iothread();
408
+ default:
409
+ /* Ignore everything else? */
410
+ break;
411
+ }
412
+ }
413
+
414
+ qatomic_mb_set(&cpu->exit_request, 0);
415
+ qemu_wait_io_event(cpu);
416
+ } while (!cpu->unplug || cpu_can_run(cpu));
417
+
418
+ qemu_tcg_destroy_vcpu(cpu);
419
+ qemu_mutex_unlock_iothread();
420
+ rcu_unregister_thread();
421
+ return NULL;
422
+}
423
+
424
+static void mttcg_kick_vcpu_thread(CPUState *cpu)
425
+{
426
+ cpu_exit(cpu);
427
+}
428
+
429
+const CpusAccel tcg_cpus_mttcg = {
430
+ .create_vcpu_thread = tcg_start_vcpu_thread,
431
+ .kick_vcpu_thread = mttcg_kick_vcpu_thread,
432
+
433
+ .handle_interrupt = tcg_handle_interrupt,
434
+};
435
diff --git a/accel/tcg/tcg-cpus-rr.c b/accel/tcg/tcg-cpus-rr.c
436
new file mode 100644
437
index XXXXXXX..XXXXXXX
438
--- /dev/null
439
+++ b/accel/tcg/tcg-cpus-rr.c
440
@@ -XXX,XX +XXX,XX @@
441
+/*
442
+ * QEMU TCG Single Threaded vCPUs implementation
443
+ *
444
+ * Copyright (c) 2003-2008 Fabrice Bellard
445
+ * Copyright (c) 2014 Red Hat Inc.
446
+ *
447
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
448
+ * of this software and associated documentation files (the "Software"), to deal
449
+ * in the Software without restriction, including without limitation the rights
450
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
451
+ * copies of the Software, and to permit persons to whom the Software is
452
+ * furnished to do so, subject to the following conditions:
453
+ *
454
+ * The above copyright notice and this permission notice shall be included in
455
+ * all copies or substantial portions of the Software.
456
+ *
457
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
458
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
459
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
460
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
461
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
462
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
463
+ * THE SOFTWARE.
464
+ */
465
+
466
+#include "qemu/osdep.h"
467
+#include "qemu-common.h"
468
+#include "sysemu/tcg.h"
469
+#include "sysemu/replay.h"
470
+#include "qemu/main-loop.h"
471
+#include "qemu/guest-random.h"
472
+#include "exec/exec-all.h"
473
+#include "hw/boards.h"
474
+
475
+#include "tcg-cpus.h"
476
+#include "tcg-cpus-rr.h"
477
+#include "tcg-cpus-icount.h"
478
+
479
+/* Kick all RR vCPUs */
480
+void qemu_cpu_kick_rr_cpus(CPUState *unused)
481
+{
482
+ CPUState *cpu;
483
+
484
+ CPU_FOREACH(cpu) {
485
+ cpu_exit(cpu);
486
+ };
487
+}
488
+
489
+/*
490
+ * TCG vCPU kick timer
491
+ *
492
+ * The kick timer is responsible for moving single threaded vCPU
493
+ * emulation on to the next vCPU. If more than one vCPU is running a
494
+ * timer event with force a cpu->exit so the next vCPU can get
495
+ * scheduled.
496
+ *
497
+ * The timer is removed if all vCPUs are idle and restarted again once
498
+ * idleness is complete.
499
+ */
500
+
501
+static QEMUTimer *tcg_kick_vcpu_timer;
502
+static CPUState *tcg_current_rr_cpu;
503
+
504
+#define TCG_KICK_PERIOD (NANOSECONDS_PER_SECOND / 10)
505
+
506
+static inline int64_t qemu_tcg_next_kick(void)
507
+{
508
+ return qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + TCG_KICK_PERIOD;
509
+}
510
+
511
+/* Kick the currently round-robin scheduled vCPU to next */
512
+static void qemu_cpu_kick_rr_next_cpu(void)
513
+{
514
+ CPUState *cpu;
515
+ do {
516
+ cpu = qatomic_mb_read(&tcg_current_rr_cpu);
517
+ if (cpu) {
518
+ cpu_exit(cpu);
519
+ }
520
+ } while (cpu != qatomic_mb_read(&tcg_current_rr_cpu));
521
+}
522
+
523
+static void kick_tcg_thread(void *opaque)
524
+{
525
+ timer_mod(tcg_kick_vcpu_timer, qemu_tcg_next_kick());
526
+ qemu_cpu_kick_rr_next_cpu();
527
+}
528
+
529
+static void start_tcg_kick_timer(void)
530
+{
531
+ if (!tcg_kick_vcpu_timer && CPU_NEXT(first_cpu)) {
532
+ tcg_kick_vcpu_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
533
+ kick_tcg_thread, NULL);
534
+ }
535
+ if (tcg_kick_vcpu_timer && !timer_pending(tcg_kick_vcpu_timer)) {
536
+ timer_mod(tcg_kick_vcpu_timer, qemu_tcg_next_kick());
537
+ }
538
+}
539
+
540
+static void stop_tcg_kick_timer(void)
541
+{
542
+ if (tcg_kick_vcpu_timer && timer_pending(tcg_kick_vcpu_timer)) {
543
+ timer_del(tcg_kick_vcpu_timer);
544
+ }
545
+}
546
+
547
+static void qemu_tcg_rr_wait_io_event(void)
548
+{
549
+ CPUState *cpu;
550
+
551
+ while (all_cpu_threads_idle()) {
552
+ stop_tcg_kick_timer();
553
+ qemu_cond_wait_iothread(first_cpu->halt_cond);
554
+ }
555
+
556
+ start_tcg_kick_timer();
557
+
558
+ CPU_FOREACH(cpu) {
559
+ qemu_wait_io_event_common(cpu);
560
+ }
561
+}
562
+
563
+/*
564
+ * Destroy any remaining vCPUs which have been unplugged and have
565
+ * finished running
566
+ */
567
+static void deal_with_unplugged_cpus(void)
568
+{
569
+ CPUState *cpu;
570
+
571
+ CPU_FOREACH(cpu) {
572
+ if (cpu->unplug && !cpu_can_run(cpu)) {
573
+ qemu_tcg_destroy_vcpu(cpu);
574
+ break;
575
+ }
576
+ }
577
+}
578
+
579
+/*
580
+ * In the single-threaded case each vCPU is simulated in turn. If
581
+ * there is more than a single vCPU we create a simple timer to kick
582
+ * the vCPU and ensure we don't get stuck in a tight loop in one vCPU.
583
+ * This is done explicitly rather than relying on side-effects
584
+ * elsewhere.
585
+ */
586
+
587
+void *tcg_rr_cpu_thread_fn(void *arg)
588
+{
589
+ CPUState *cpu = arg;
590
+
591
+ assert(tcg_enabled());
592
+ rcu_register_thread();
593
+ tcg_register_thread();
594
+
595
+ qemu_mutex_lock_iothread();
596
+ qemu_thread_get_self(cpu->thread);
597
+
598
+ cpu->thread_id = qemu_get_thread_id();
599
+ cpu->can_do_io = 1;
600
+ cpu_thread_signal_created(cpu);
601
+ qemu_guest_random_seed_thread_part2(cpu->random_seed);
602
+
603
+ /* wait for initial kick-off after machine start */
604
+ while (first_cpu->stopped) {
605
+ qemu_cond_wait_iothread(first_cpu->halt_cond);
606
+
607
+ /* process any pending work */
608
+ CPU_FOREACH(cpu) {
609
+ current_cpu = cpu;
610
+ qemu_wait_io_event_common(cpu);
611
+ }
612
+ }
613
+
614
+ start_tcg_kick_timer();
615
+
616
+ cpu = first_cpu;
617
+
618
+ /* process any pending work */
619
+ cpu->exit_request = 1;
620
+
621
+ while (1) {
622
+ qemu_mutex_unlock_iothread();
623
+ replay_mutex_lock();
624
+ qemu_mutex_lock_iothread();
625
+
626
+ if (icount_enabled()) {
627
+ /* Account partial waits to QEMU_CLOCK_VIRTUAL. */
628
+ icount_account_warp_timer();
629
+ /*
630
+ * Run the timers here. This is much more efficient than
631
+ * waking up the I/O thread and waiting for completion.
632
+ */
633
+ handle_icount_deadline();
634
+ }
635
+
636
+ replay_mutex_unlock();
637
+
638
+ if (!cpu) {
639
+ cpu = first_cpu;
640
+ }
641
+
642
+ while (cpu && cpu_work_list_empty(cpu) && !cpu->exit_request) {
643
+
644
+ qatomic_mb_set(&tcg_current_rr_cpu, cpu);
645
+ current_cpu = cpu;
646
+
647
+ qemu_clock_enable(QEMU_CLOCK_VIRTUAL,
648
+ (cpu->singlestep_enabled & SSTEP_NOTIMER) == 0);
649
+
650
+ if (cpu_can_run(cpu)) {
651
+ int r;
652
+
653
+ qemu_mutex_unlock_iothread();
654
+ if (icount_enabled()) {
655
+ prepare_icount_for_run(cpu);
656
+ }
657
+ r = tcg_cpu_exec(cpu);
658
+ if (icount_enabled()) {
659
+ process_icount_data(cpu);
660
+ }
661
+ qemu_mutex_lock_iothread();
662
+
663
+ if (r == EXCP_DEBUG) {
664
+ cpu_handle_guest_debug(cpu);
665
+ break;
666
+ } else if (r == EXCP_ATOMIC) {
667
+ qemu_mutex_unlock_iothread();
668
+ cpu_exec_step_atomic(cpu);
669
+ qemu_mutex_lock_iothread();
670
+ break;
671
+ }
672
+ } else if (cpu->stop) {
673
+ if (cpu->unplug) {
674
+ cpu = CPU_NEXT(cpu);
675
+ }
676
+ break;
677
+ }
678
+
679
+ cpu = CPU_NEXT(cpu);
680
+ } /* while (cpu && !cpu->exit_request).. */
681
+
682
+ /* Does not need qatomic_mb_set because a spurious wakeup is okay. */
683
+ qatomic_set(&tcg_current_rr_cpu, NULL);
684
+
685
+ if (cpu && cpu->exit_request) {
686
+ qatomic_mb_set(&cpu->exit_request, 0);
687
+ }
688
+
689
+ if (icount_enabled() && all_cpu_threads_idle()) {
690
+ /*
691
+ * When all cpus are sleeping (e.g in WFI), to avoid a deadlock
692
+ * in the main_loop, wake it up in order to start the warp timer.
693
+ */
694
+ qemu_notify_event();
695
+ }
696
+
697
+ qemu_tcg_rr_wait_io_event();
698
+ deal_with_unplugged_cpus();
699
+ }
700
+
701
+ rcu_unregister_thread();
702
+ return NULL;
703
+}
704
+
705
+const CpusAccel tcg_cpus_rr = {
706
+ .create_vcpu_thread = tcg_start_vcpu_thread,
707
+ .kick_vcpu_thread = qemu_cpu_kick_rr_cpus,
708
+
709
+ .handle_interrupt = tcg_handle_interrupt,
710
+};
711
diff --git a/accel/tcg/tcg-cpus.c b/accel/tcg/tcg-cpus.c
712
index XXXXXXX..XXXXXXX 100644
713
--- a/accel/tcg/tcg-cpus.c
714
+++ b/accel/tcg/tcg-cpus.c
715
@@ -XXX,XX +XXX,XX @@
716
/*
717
- * QEMU System Emulator
718
+ * QEMU TCG vCPU common functionality
719
+ *
720
+ * Functionality common to all TCG vCPU variants: mttcg, rr and icount.
721
*
722
* Copyright (c) 2003-2008 Fabrice Bellard
723
* Copyright (c) 2014 Red Hat Inc.
724
@@ -XXX,XX +XXX,XX @@
725
#include "hw/boards.h"
726
727
#include "tcg-cpus.h"
728
+#include "tcg-cpus-mttcg.h"
729
+#include "tcg-cpus-rr.h"
730
731
-/* Kick all RR vCPUs */
732
-static void qemu_cpu_kick_rr_cpus(void)
733
-{
99
-{
734
- CPUState *cpu;
100
- tcg_debug_assert(idx <= 15);
735
+/* common functionality among all TCG variants */
101
- return (op << 4) | idx;
736
737
- CPU_FOREACH(cpu) {
738
- cpu_exit(cpu);
739
- };
740
-}
102
-}
741
-
103
-
742
-static void tcg_kick_vcpu_thread(CPUState *cpu)
104
-/**
105
- * get_memop
106
- * @oi: combined op/idx parameter
107
- *
108
- * Extract the memory operation from the combined value.
109
- */
110
-static inline MemOp get_memop(MemOpIdx oi)
743
-{
111
-{
744
- if (qemu_tcg_mttcg_enabled()) {
112
- return oi >> 4;
745
- cpu_exit(cpu);
746
- } else {
747
- qemu_cpu_kick_rr_cpus();
748
- }
749
-}
113
-}
750
-
114
-
751
-/*
115
-/**
752
- * TCG vCPU kick timer
116
- * get_mmuidx
117
- * @oi: combined op/idx parameter
753
- *
118
- *
754
- * The kick timer is responsible for moving single threaded vCPU
119
- * Extract the mmu index from the combined value.
755
- * emulation on to the next vCPU. If more than one vCPU is running a
756
- * timer event with force a cpu->exit so the next vCPU can get
757
- * scheduled.
758
- *
759
- * The timer is removed if all vCPUs are idle and restarted again once
760
- * idleness is complete.
761
- */
120
- */
762
-
121
-static inline unsigned get_mmuidx(MemOpIdx oi)
763
-static QEMUTimer *tcg_kick_vcpu_timer;
764
-static CPUState *tcg_current_rr_cpu;
765
-
766
-#define TCG_KICK_PERIOD (NANOSECONDS_PER_SECOND / 10)
767
-
768
-static inline int64_t qemu_tcg_next_kick(void)
769
-{
122
-{
770
- return qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + TCG_KICK_PERIOD;
123
- return oi & 15;
771
-}
124
-}
772
-
125
-
773
-/* Kick the currently round-robin scheduled vCPU to next */
126
/**
774
-static void qemu_cpu_kick_rr_next_cpu(void)
127
* tcg_qemu_tb_exec:
775
-{
128
* @env: pointer to CPUArchState for the CPU
776
- CPUState *cpu;
777
- do {
778
- cpu = qatomic_mb_read(&tcg_current_rr_cpu);
779
- if (cpu) {
780
- cpu_exit(cpu);
781
- }
782
- } while (cpu != qatomic_mb_read(&tcg_current_rr_cpu));
783
-}
784
-
785
-static void kick_tcg_thread(void *opaque)
786
-{
787
- timer_mod(tcg_kick_vcpu_timer, qemu_tcg_next_kick());
788
- qemu_cpu_kick_rr_next_cpu();
789
-}
790
-
791
-static void start_tcg_kick_timer(void)
792
-{
793
- assert(!mttcg_enabled);
794
- if (!tcg_kick_vcpu_timer && CPU_NEXT(first_cpu)) {
795
- tcg_kick_vcpu_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
796
- kick_tcg_thread, NULL);
797
- }
798
- if (tcg_kick_vcpu_timer && !timer_pending(tcg_kick_vcpu_timer)) {
799
- timer_mod(tcg_kick_vcpu_timer, qemu_tcg_next_kick());
800
- }
801
-}
802
-
803
-static void stop_tcg_kick_timer(void)
804
-{
805
- assert(!mttcg_enabled);
806
- if (tcg_kick_vcpu_timer && timer_pending(tcg_kick_vcpu_timer)) {
807
- timer_del(tcg_kick_vcpu_timer);
808
- }
809
-}
810
-
811
-static void qemu_tcg_destroy_vcpu(CPUState *cpu)
812
-{
813
-}
814
-
815
-static void qemu_tcg_rr_wait_io_event(void)
816
-{
817
- CPUState *cpu;
818
-
819
- while (all_cpu_threads_idle()) {
820
- stop_tcg_kick_timer();
821
- qemu_cond_wait_iothread(first_cpu->halt_cond);
822
- }
823
-
824
- start_tcg_kick_timer();
825
-
826
- CPU_FOREACH(cpu) {
827
- qemu_wait_io_event_common(cpu);
828
- }
829
-}
830
-
831
-static int64_t tcg_get_icount_limit(void)
832
-{
833
- int64_t deadline;
834
-
835
- if (replay_mode != REPLAY_MODE_PLAY) {
836
- /*
837
- * Include all the timers, because they may need an attention.
838
- * Too long CPU execution may create unnecessary delay in UI.
839
- */
840
- deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL,
841
- QEMU_TIMER_ATTR_ALL);
842
- /* Check realtime timers, because they help with input processing */
843
- deadline = qemu_soonest_timeout(deadline,
844
- qemu_clock_deadline_ns_all(QEMU_CLOCK_REALTIME,
845
- QEMU_TIMER_ATTR_ALL));
846
-
847
- /*
848
- * Maintain prior (possibly buggy) behaviour where if no deadline
849
- * was set (as there is no QEMU_CLOCK_VIRTUAL timer) or it is more than
850
- * INT32_MAX nanoseconds ahead, we still use INT32_MAX
851
- * nanoseconds.
852
- */
853
- if ((deadline < 0) || (deadline > INT32_MAX)) {
854
- deadline = INT32_MAX;
855
- }
856
-
857
- return icount_round(deadline);
858
- } else {
859
- return replay_get_instructions();
860
- }
861
-}
862
-
863
-static void notify_aio_contexts(void)
864
-{
865
- /* Wake up other AioContexts. */
866
- qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
867
- qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
868
-}
869
-
870
-static void handle_icount_deadline(void)
871
-{
872
- assert(qemu_in_vcpu_thread());
873
- if (icount_enabled()) {
874
- int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL,
875
- QEMU_TIMER_ATTR_ALL);
876
-
877
- if (deadline == 0) {
878
- notify_aio_contexts();
879
- }
880
- }
881
-}
882
-
883
-static void prepare_icount_for_run(CPUState *cpu)
884
-{
885
- if (icount_enabled()) {
886
- int insns_left;
887
-
888
- /*
889
- * These should always be cleared by process_icount_data after
890
- * each vCPU execution. However u16.high can be raised
891
- * asynchronously by cpu_exit/cpu_interrupt/tcg_handle_interrupt
892
- */
893
- g_assert(cpu_neg(cpu)->icount_decr.u16.low == 0);
894
- g_assert(cpu->icount_extra == 0);
895
-
896
- cpu->icount_budget = tcg_get_icount_limit();
897
- insns_left = MIN(0xffff, cpu->icount_budget);
898
- cpu_neg(cpu)->icount_decr.u16.low = insns_left;
899
- cpu->icount_extra = cpu->icount_budget - insns_left;
900
-
901
- replay_mutex_lock();
902
-
903
- if (cpu->icount_budget == 0 && replay_has_checkpoint()) {
904
- notify_aio_contexts();
905
- }
906
- }
907
-}
908
-
909
-static void process_icount_data(CPUState *cpu)
910
-{
911
- if (icount_enabled()) {
912
- /* Account for executed instructions */
913
- icount_update(cpu);
914
-
915
- /* Reset the counters */
916
- cpu_neg(cpu)->icount_decr.u16.low = 0;
917
- cpu->icount_extra = 0;
918
- cpu->icount_budget = 0;
919
-
920
- replay_account_executed_instructions();
921
-
922
- replay_mutex_unlock();
923
- }
924
-}
925
-
926
-static int tcg_cpu_exec(CPUState *cpu)
927
-{
928
- int ret;
929
-#ifdef CONFIG_PROFILER
930
- int64_t ti;
931
-#endif
932
-
933
- assert(tcg_enabled());
934
-#ifdef CONFIG_PROFILER
935
- ti = profile_getclock();
936
-#endif
937
- cpu_exec_start(cpu);
938
- ret = cpu_exec(cpu);
939
- cpu_exec_end(cpu);
940
-#ifdef CONFIG_PROFILER
941
- qatomic_set(&tcg_ctx->prof.cpu_exec_time,
942
- tcg_ctx->prof.cpu_exec_time + profile_getclock() - ti);
943
-#endif
944
- return ret;
945
-}
946
-
947
-/*
948
- * Destroy any remaining vCPUs which have been unplugged and have
949
- * finished running
950
- */
951
-static void deal_with_unplugged_cpus(void)
952
-{
953
- CPUState *cpu;
954
-
955
- CPU_FOREACH(cpu) {
956
- if (cpu->unplug && !cpu_can_run(cpu)) {
957
- qemu_tcg_destroy_vcpu(cpu);
958
- cpu_thread_signal_destroyed(cpu);
959
- break;
960
- }
961
- }
962
-}
963
-
964
-/*
965
- * Single-threaded TCG
966
- *
967
- * In the single-threaded case each vCPU is simulated in turn. If
968
- * there is more than a single vCPU we create a simple timer to kick
969
- * the vCPU and ensure we don't get stuck in a tight loop in one vCPU.
970
- * This is done explicitly rather than relying on side-effects
971
- * elsewhere.
972
- */
973
-
974
-static void *tcg_rr_cpu_thread_fn(void *arg)
975
-{
976
- CPUState *cpu = arg;
977
-
978
- assert(tcg_enabled());
979
- rcu_register_thread();
980
- tcg_register_thread();
981
-
982
- qemu_mutex_lock_iothread();
983
- qemu_thread_get_self(cpu->thread);
984
-
985
- cpu->thread_id = qemu_get_thread_id();
986
- cpu->can_do_io = 1;
987
- cpu_thread_signal_created(cpu);
988
- qemu_guest_random_seed_thread_part2(cpu->random_seed);
989
-
990
- /* wait for initial kick-off after machine start */
991
- while (first_cpu->stopped) {
992
- qemu_cond_wait_iothread(first_cpu->halt_cond);
993
-
994
- /* process any pending work */
995
- CPU_FOREACH(cpu) {
996
- current_cpu = cpu;
997
- qemu_wait_io_event_common(cpu);
998
- }
999
- }
1000
-
1001
- start_tcg_kick_timer();
1002
-
1003
- cpu = first_cpu;
1004
-
1005
- /* process any pending work */
1006
- cpu->exit_request = 1;
1007
-
1008
- while (1) {
1009
- qemu_mutex_unlock_iothread();
1010
- replay_mutex_lock();
1011
- qemu_mutex_lock_iothread();
1012
- /* Account partial waits to QEMU_CLOCK_VIRTUAL. */
1013
- icount_account_warp_timer();
1014
-
1015
- /*
1016
- * Run the timers here. This is much more efficient than
1017
- * waking up the I/O thread and waiting for completion.
1018
- */
1019
- handle_icount_deadline();
1020
-
1021
- replay_mutex_unlock();
1022
-
1023
- if (!cpu) {
1024
- cpu = first_cpu;
1025
- }
1026
-
1027
- while (cpu && cpu_work_list_empty(cpu) && !cpu->exit_request) {
1028
-
1029
- qatomic_mb_set(&tcg_current_rr_cpu, cpu);
1030
- current_cpu = cpu;
1031
-
1032
- qemu_clock_enable(QEMU_CLOCK_VIRTUAL,
1033
- (cpu->singlestep_enabled & SSTEP_NOTIMER) == 0);
1034
-
1035
- if (cpu_can_run(cpu)) {
1036
- int r;
1037
-
1038
- qemu_mutex_unlock_iothread();
1039
- prepare_icount_for_run(cpu);
1040
-
1041
- r = tcg_cpu_exec(cpu);
1042
-
1043
- process_icount_data(cpu);
1044
- qemu_mutex_lock_iothread();
1045
-
1046
- if (r == EXCP_DEBUG) {
1047
- cpu_handle_guest_debug(cpu);
1048
- break;
1049
- } else if (r == EXCP_ATOMIC) {
1050
- qemu_mutex_unlock_iothread();
1051
- cpu_exec_step_atomic(cpu);
1052
- qemu_mutex_lock_iothread();
1053
- break;
1054
- }
1055
- } else if (cpu->stop) {
1056
- if (cpu->unplug) {
1057
- cpu = CPU_NEXT(cpu);
1058
- }
1059
- break;
1060
- }
1061
-
1062
- cpu = CPU_NEXT(cpu);
1063
- } /* while (cpu && !cpu->exit_request).. */
1064
-
1065
- /* Does not need qatomic_mb_set because a spurious wakeup is okay. */
1066
- qatomic_set(&tcg_current_rr_cpu, NULL);
1067
-
1068
- if (cpu && cpu->exit_request) {
1069
- qatomic_mb_set(&cpu->exit_request, 0);
1070
- }
1071
-
1072
- if (icount_enabled() && all_cpu_threads_idle()) {
1073
- /*
1074
- * When all cpus are sleeping (e.g in WFI), to avoid a deadlock
1075
- * in the main_loop, wake it up in order to start the warp timer.
1076
- */
1077
- qemu_notify_event();
1078
- }
1079
-
1080
- qemu_tcg_rr_wait_io_event();
1081
- deal_with_unplugged_cpus();
1082
- }
1083
-
1084
- rcu_unregister_thread();
1085
- return NULL;
1086
-}
1087
-
1088
-/*
1089
- * Multi-threaded TCG
1090
- *
1091
- * In the multi-threaded case each vCPU has its own thread. The TLS
1092
- * variable current_cpu can be used deep in the code to find the
1093
- * current CPUState for a given thread.
1094
- */
1095
-
1096
-static void *tcg_cpu_thread_fn(void *arg)
1097
-{
1098
- CPUState *cpu = arg;
1099
-
1100
- assert(tcg_enabled());
1101
- g_assert(!icount_enabled());
1102
-
1103
- rcu_register_thread();
1104
- tcg_register_thread();
1105
-
1106
- qemu_mutex_lock_iothread();
1107
- qemu_thread_get_self(cpu->thread);
1108
-
1109
- cpu->thread_id = qemu_get_thread_id();
1110
- cpu->can_do_io = 1;
1111
- current_cpu = cpu;
1112
- cpu_thread_signal_created(cpu);
1113
- qemu_guest_random_seed_thread_part2(cpu->random_seed);
1114
-
1115
- /* process any pending work */
1116
- cpu->exit_request = 1;
1117
-
1118
- do {
1119
- if (cpu_can_run(cpu)) {
1120
- int r;
1121
- qemu_mutex_unlock_iothread();
1122
- r = tcg_cpu_exec(cpu);
1123
- qemu_mutex_lock_iothread();
1124
- switch (r) {
1125
- case EXCP_DEBUG:
1126
- cpu_handle_guest_debug(cpu);
1127
- break;
1128
- case EXCP_HALTED:
1129
- /*
1130
- * during start-up the vCPU is reset and the thread is
1131
- * kicked several times. If we don't ensure we go back
1132
- * to sleep in the halted state we won't cleanly
1133
- * start-up when the vCPU is enabled.
1134
- *
1135
- * cpu->halted should ensure we sleep in wait_io_event
1136
- */
1137
- g_assert(cpu->halted);
1138
- break;
1139
- case EXCP_ATOMIC:
1140
- qemu_mutex_unlock_iothread();
1141
- cpu_exec_step_atomic(cpu);
1142
- qemu_mutex_lock_iothread();
1143
- default:
1144
- /* Ignore everything else? */
1145
- break;
1146
- }
1147
- }
1148
-
1149
- qatomic_mb_set(&cpu->exit_request, 0);
1150
- qemu_wait_io_event(cpu);
1151
- } while (!cpu->unplug || cpu_can_run(cpu));
1152
-
1153
- qemu_tcg_destroy_vcpu(cpu);
1154
- cpu_thread_signal_destroyed(cpu);
1155
- qemu_mutex_unlock_iothread();
1156
- rcu_unregister_thread();
1157
- return NULL;
1158
-}
1159
-
1160
-static void tcg_start_vcpu_thread(CPUState *cpu)
1161
+void tcg_start_vcpu_thread(CPUState *cpu)
1162
{
1163
char thread_name[VCPU_THREAD_NAME_SIZE];
1164
static QemuCond *single_tcg_halt_cond;
1165
@@ -XXX,XX +XXX,XX @@ static void tcg_start_vcpu_thread(CPUState *cpu)
1166
}
1167
}
1168
1169
-static int64_t tcg_get_virtual_clock(void)
1170
+void qemu_tcg_destroy_vcpu(CPUState *cpu)
1171
{
1172
- if (icount_enabled()) {
1173
- return icount_get();
1174
- }
1175
- return cpu_get_clock();
1176
+ cpu_thread_signal_destroyed(cpu);
1177
}
1178
1179
-static int64_t tcg_get_elapsed_ticks(void)
1180
+int tcg_cpu_exec(CPUState *cpu)
1181
{
1182
- if (icount_enabled()) {
1183
- return icount_get();
1184
- }
1185
- return cpu_get_ticks();
1186
+ int ret;
1187
+#ifdef CONFIG_PROFILER
1188
+ int64_t ti;
1189
+#endif
1190
+ assert(tcg_enabled());
1191
+#ifdef CONFIG_PROFILER
1192
+ ti = profile_getclock();
1193
+#endif
1194
+ cpu_exec_start(cpu);
1195
+ ret = cpu_exec(cpu);
1196
+ cpu_exec_end(cpu);
1197
+#ifdef CONFIG_PROFILER
1198
+ qatomic_set(&tcg_ctx->prof.cpu_exec_time,
1199
+ tcg_ctx->prof.cpu_exec_time + profile_getclock() - ti);
1200
+#endif
1201
+ return ret;
1202
}
1203
1204
/* mask must never be zero, except for A20 change call */
1205
-static void tcg_handle_interrupt(CPUState *cpu, int mask)
1206
+void tcg_handle_interrupt(CPUState *cpu, int mask)
1207
{
1208
- int old_mask;
1209
g_assert(qemu_mutex_iothread_locked());
1210
1211
- old_mask = cpu->interrupt_request;
1212
cpu->interrupt_request |= mask;
1213
1214
/*
1215
@@ -XXX,XX +XXX,XX @@ static void tcg_handle_interrupt(CPUState *cpu, int mask)
1216
qemu_cpu_kick(cpu);
1217
} else {
1218
qatomic_set(&cpu_neg(cpu)->icount_decr.u16.high, -1);
1219
- if (icount_enabled() &&
1220
- !cpu->can_do_io
1221
- && (mask & ~old_mask) != 0) {
1222
- cpu_abort(cpu, "Raised interrupt while not in I/O function");
1223
- }
1224
}
1225
}
1226
-
1227
-const CpusAccel tcg_cpus = {
1228
- .create_vcpu_thread = tcg_start_vcpu_thread,
1229
- .kick_vcpu_thread = tcg_kick_vcpu_thread,
1230
-
1231
- .handle_interrupt = tcg_handle_interrupt,
1232
-
1233
- .get_virtual_clock = tcg_get_virtual_clock,
1234
- .get_elapsed_ticks = tcg_get_elapsed_ticks,
1235
-};
1236
diff --git a/softmmu/icount.c b/softmmu/icount.c
1237
index XXXXXXX..XXXXXXX 100644
1238
--- a/softmmu/icount.c
1239
+++ b/softmmu/icount.c
1240
@@ -XXX,XX +XXX,XX @@ void icount_start_warp_timer(void)
1241
1242
void icount_account_warp_timer(void)
1243
{
1244
- if (!icount_enabled() || !icount_sleep) {
1245
+ if (!icount_sleep) {
1246
return;
1247
}
1248
1249
diff --git a/accel/tcg/meson.build b/accel/tcg/meson.build
1250
index XXXXXXX..XXXXXXX 100644
1251
--- a/accel/tcg/meson.build
1252
+++ b/accel/tcg/meson.build
1253
@@ -XXX,XX +XXX,XX @@ tcg_ss.add(when: 'CONFIG_SOFTMMU', if_false: files('user-exec-stub.c'))
1254
tcg_ss.add(when: 'CONFIG_PLUGIN', if_true: [files('plugin-gen.c'), libdl])
1255
specific_ss.add_all(when: 'CONFIG_TCG', if_true: tcg_ss)
1256
1257
-specific_ss.add(when: ['CONFIG_SOFTMMU', 'CONFIG_TCG'], if_true: files('tcg-all.c', 'cputlb.c', 'tcg-cpus.c'))
1258
+specific_ss.add(when: ['CONFIG_SOFTMMU', 'CONFIG_TCG'], if_true: files(
1259
+ 'tcg-all.c',
1260
+ 'cputlb.c',
1261
+ 'tcg-cpus.c',
1262
+ 'tcg-cpus-mttcg.c',
1263
+ 'tcg-cpus-icount.c',
1264
+ 'tcg-cpus-rr.c'
1265
+))
1266
--
129
--
1267
2.25.1
130
2.25.1
1268
131
1269
132
diff view generated by jsdifflib
New patch
[PULL 08/28] trace/mem: Pass MemOpIdx to trace_mem_get_info
1
We (will) often have the complete MemOpIdx handy, so use that.
1
2
3
Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
4
Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
5
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
6
---
7
trace/mem.h | 32 +++++++++-----------------
8
accel/tcg/cputlb.c | 12 ++++------
9
accel/tcg/user-exec.c | 42 +++++++++++++++++++++++------------
10
tcg/tcg-op.c | 8 +++----
11
accel/tcg/atomic_common.c.inc | 6 ++---
12
5 files changed, 49 insertions(+), 51 deletions(-)
13
14
diff --git a/trace/mem.h b/trace/mem.h
15
index XXXXXXX..XXXXXXX 100644
16
--- a/trace/mem.h
17
+++ b/trace/mem.h
18
@@ -XXX,XX +XXX,XX @@
19
#ifndef TRACE__MEM_H
20
#define TRACE__MEM_H
21
22
-#include "tcg/tcg.h"
23
+#include "exec/memopidx.h"
24
25
#define TRACE_MEM_SZ_SHIFT_MASK 0xf /* size shift mask */
26
#define TRACE_MEM_SE (1ULL << 4) /* sign extended (y/n) */
27
@@ -XXX,XX +XXX,XX @@
28
#define TRACE_MEM_MMU_SHIFT 8 /* mmu idx */
29
30
/**
31
- * trace_mem_build_info:
32
+ * trace_mem_get_info:
33
*
34
* Return a value for the 'info' argument in guest memory access traces.
35
*/
36
-static inline uint16_t trace_mem_build_info(int size_shift, bool sign_extend,
37
- MemOp endianness, bool store,
38
- unsigned int mmu_idx)
39
+static inline uint16_t trace_mem_get_info(MemOpIdx oi, bool store)
40
{
41
+ MemOp op = get_memop(oi);
42
+ uint32_t size_shift = op & MO_SIZE;
43
+ bool sign_extend = op & MO_SIGN;
44
+ bool big_endian = (op & MO_BSWAP) == MO_BE;
45
uint16_t res;
46
47
res = size_shift & TRACE_MEM_SZ_SHIFT_MASK;
48
if (sign_extend) {
49
res |= TRACE_MEM_SE;
50
}
51
- if (endianness == MO_BE) {
52
+ if (big_endian) {
53
res |= TRACE_MEM_BE;
54
}
55
if (store) {
56
res |= TRACE_MEM_ST;
57
}
58
#ifdef CONFIG_SOFTMMU
59
- res |= mmu_idx << TRACE_MEM_MMU_SHIFT;
60
+ res |= get_mmuidx(oi) << TRACE_MEM_MMU_SHIFT;
61
#endif
62
+
63
return res;
64
}
65
66
-
67
-/**
68
- * trace_mem_get_info:
69
- *
70
- * Return a value for the 'info' argument in guest memory access traces.
71
- */
72
-static inline uint16_t trace_mem_get_info(MemOp op,
73
- unsigned int mmu_idx,
74
- bool store)
75
-{
76
- return trace_mem_build_info(op & MO_SIZE, !!(op & MO_SIGN),
77
- op & MO_BSWAP, store,
78
- mmu_idx);
79
-}
80
-
81
#endif /* TRACE__MEM_H */
82
diff --git a/accel/tcg/cputlb.c b/accel/tcg/cputlb.c
83
index XXXXXXX..XXXXXXX 100644
84
--- a/accel/tcg/cputlb.c
85
+++ b/accel/tcg/cputlb.c
86
@@ -XXX,XX +XXX,XX @@ static inline uint64_t cpu_load_helper(CPUArchState *env, abi_ptr addr,
87
int mmu_idx, uintptr_t retaddr,
88
MemOp op, FullLoadHelper *full_load)
89
{
90
- uint16_t meminfo;
91
- MemOpIdx oi;
92
+ MemOpIdx oi = make_memop_idx(op, mmu_idx);
93
+ uint16_t meminfo = trace_mem_get_info(oi, false);
94
uint64_t ret;
95
96
- meminfo = trace_mem_get_info(op, mmu_idx, false);
97
trace_guest_mem_before_exec(env_cpu(env), addr, meminfo);
98
99
- oi = make_memop_idx(op, mmu_idx);
100
ret = full_load(env, addr, oi, retaddr);
101
102
qemu_plugin_vcpu_mem_cb(env_cpu(env), addr, meminfo);
103
@@ -XXX,XX +XXX,XX @@ static inline void QEMU_ALWAYS_INLINE
104
cpu_store_helper(CPUArchState *env, target_ulong addr, uint64_t val,
105
int mmu_idx, uintptr_t retaddr, MemOp op)
106
{
107
- MemOpIdx oi;
108
- uint16_t meminfo;
109
+ MemOpIdx oi = make_memop_idx(op, mmu_idx);
110
+ uint16_t meminfo = trace_mem_get_info(oi, true);
111
112
- meminfo = trace_mem_get_info(op, mmu_idx, true);
113
trace_guest_mem_before_exec(env_cpu(env), addr, meminfo);
114
115
- oi = make_memop_idx(op, mmu_idx);
116
store_helper(env, addr, val, oi, retaddr, op);
117
118
qemu_plugin_vcpu_mem_cb(env_cpu(env), addr, meminfo);
119
diff --git a/accel/tcg/user-exec.c b/accel/tcg/user-exec.c
120
index XXXXXXX..XXXXXXX 100644
121
--- a/accel/tcg/user-exec.c
122
+++ b/accel/tcg/user-exec.c
123
@@ -XXX,XX +XXX,XX @@ int cpu_signal_handler(int host_signum, void *pinfo,
124
125
uint32_t cpu_ldub_data(CPUArchState *env, abi_ptr ptr)
126
{
127
+ MemOpIdx oi = make_memop_idx(MO_UB, MMU_USER_IDX);
128
+ uint16_t meminfo = trace_mem_get_info(oi, false);
129
uint32_t ret;
130
- uint16_t meminfo = trace_mem_get_info(MO_UB, MMU_USER_IDX, false);
131
132
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
133
ret = ldub_p(g2h(env_cpu(env), ptr));
134
@@ -XXX,XX +XXX,XX @@ int cpu_ldsb_data(CPUArchState *env, abi_ptr ptr)
135
136
uint32_t cpu_lduw_be_data(CPUArchState *env, abi_ptr ptr)
137
{
138
+ MemOpIdx oi = make_memop_idx(MO_BEUW, MMU_USER_IDX);
139
+ uint16_t meminfo = trace_mem_get_info(oi, false);
140
uint32_t ret;
141
- uint16_t meminfo = trace_mem_get_info(MO_BEUW, MMU_USER_IDX, false);
142
143
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
144
ret = lduw_be_p(g2h(env_cpu(env), ptr));
145
@@ -XXX,XX +XXX,XX @@ int cpu_ldsw_be_data(CPUArchState *env, abi_ptr ptr)
146
147
uint32_t cpu_ldl_be_data(CPUArchState *env, abi_ptr ptr)
148
{
149
+ MemOpIdx oi = make_memop_idx(MO_BEUL, MMU_USER_IDX);
150
+ uint16_t meminfo = trace_mem_get_info(oi, false);
151
uint32_t ret;
152
- uint16_t meminfo = trace_mem_get_info(MO_BEUL, MMU_USER_IDX, false);
153
154
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
155
ret = ldl_be_p(g2h(env_cpu(env), ptr));
156
@@ -XXX,XX +XXX,XX @@ uint32_t cpu_ldl_be_data(CPUArchState *env, abi_ptr ptr)
157
158
uint64_t cpu_ldq_be_data(CPUArchState *env, abi_ptr ptr)
159
{
160
+ MemOpIdx oi = make_memop_idx(MO_BEQ, MMU_USER_IDX);
161
+ uint16_t meminfo = trace_mem_get_info(oi, false);
162
uint64_t ret;
163
- uint16_t meminfo = trace_mem_get_info(MO_BEQ, MMU_USER_IDX, false);
164
165
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
166
ret = ldq_be_p(g2h(env_cpu(env), ptr));
167
@@ -XXX,XX +XXX,XX @@ uint64_t cpu_ldq_be_data(CPUArchState *env, abi_ptr ptr)
168
169
uint32_t cpu_lduw_le_data(CPUArchState *env, abi_ptr ptr)
170
{
171
+ MemOpIdx oi = make_memop_idx(MO_LEUW, MMU_USER_IDX);
172
+ uint16_t meminfo = trace_mem_get_info(oi, false);
173
uint32_t ret;
174
- uint16_t meminfo = trace_mem_get_info(MO_LEUW, MMU_USER_IDX, false);
175
176
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
177
ret = lduw_le_p(g2h(env_cpu(env), ptr));
178
@@ -XXX,XX +XXX,XX @@ int cpu_ldsw_le_data(CPUArchState *env, abi_ptr ptr)
179
180
uint32_t cpu_ldl_le_data(CPUArchState *env, abi_ptr ptr)
181
{
182
+ MemOpIdx oi = make_memop_idx(MO_LEUL, MMU_USER_IDX);
183
+ uint16_t meminfo = trace_mem_get_info(oi, false);
184
uint32_t ret;
185
- uint16_t meminfo = trace_mem_get_info(MO_LEUL, MMU_USER_IDX, false);
186
187
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
188
ret = ldl_le_p(g2h(env_cpu(env), ptr));
189
@@ -XXX,XX +XXX,XX @@ uint32_t cpu_ldl_le_data(CPUArchState *env, abi_ptr ptr)
190
191
uint64_t cpu_ldq_le_data(CPUArchState *env, abi_ptr ptr)
192
{
193
+ MemOpIdx oi = make_memop_idx(MO_LEQ, MMU_USER_IDX);
194
+ uint16_t meminfo = trace_mem_get_info(oi, false);
195
uint64_t ret;
196
- uint16_t meminfo = trace_mem_get_info(MO_LEQ, MMU_USER_IDX, false);
197
198
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
199
ret = ldq_le_p(g2h(env_cpu(env), ptr));
200
@@ -XXX,XX +XXX,XX @@ uint64_t cpu_ldq_le_data_ra(CPUArchState *env, abi_ptr ptr, uintptr_t retaddr)
201
202
void cpu_stb_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
203
{
204
- uint16_t meminfo = trace_mem_get_info(MO_UB, MMU_USER_IDX, true);
205
+ MemOpIdx oi = make_memop_idx(MO_UB, MMU_USER_IDX);
206
+ uint16_t meminfo = trace_mem_get_info(oi, true);
207
208
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
209
stb_p(g2h(env_cpu(env), ptr), val);
210
@@ -XXX,XX +XXX,XX @@ void cpu_stb_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
211
212
void cpu_stw_be_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
213
{
214
- uint16_t meminfo = trace_mem_get_info(MO_BEUW, MMU_USER_IDX, true);
215
+ MemOpIdx oi = make_memop_idx(MO_BEUW, MMU_USER_IDX);
216
+ uint16_t meminfo = trace_mem_get_info(oi, true);
217
218
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
219
stw_be_p(g2h(env_cpu(env), ptr), val);
220
@@ -XXX,XX +XXX,XX @@ void cpu_stw_be_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
221
222
void cpu_stl_be_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
223
{
224
- uint16_t meminfo = trace_mem_get_info(MO_BEUL, MMU_USER_IDX, true);
225
+ MemOpIdx oi = make_memop_idx(MO_BEUL, MMU_USER_IDX);
226
+ uint16_t meminfo = trace_mem_get_info(oi, true);
227
228
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
229
stl_be_p(g2h(env_cpu(env), ptr), val);
230
@@ -XXX,XX +XXX,XX @@ void cpu_stl_be_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
231
232
void cpu_stq_be_data(CPUArchState *env, abi_ptr ptr, uint64_t val)
233
{
234
- uint16_t meminfo = trace_mem_get_info(MO_BEQ, MMU_USER_IDX, true);
235
+ MemOpIdx oi = make_memop_idx(MO_BEQ, MMU_USER_IDX);
236
+ uint16_t meminfo = trace_mem_get_info(oi, true);
237
238
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
239
stq_be_p(g2h(env_cpu(env), ptr), val);
240
@@ -XXX,XX +XXX,XX @@ void cpu_stq_be_data(CPUArchState *env, abi_ptr ptr, uint64_t val)
241
242
void cpu_stw_le_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
243
{
244
- uint16_t meminfo = trace_mem_get_info(MO_LEUW, MMU_USER_IDX, true);
245
+ MemOpIdx oi = make_memop_idx(MO_LEUW, MMU_USER_IDX);
246
+ uint16_t meminfo = trace_mem_get_info(oi, true);
247
248
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
249
stw_le_p(g2h(env_cpu(env), ptr), val);
250
@@ -XXX,XX +XXX,XX @@ void cpu_stw_le_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
251
252
void cpu_stl_le_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
253
{
254
- uint16_t meminfo = trace_mem_get_info(MO_LEUL, MMU_USER_IDX, true);
255
+ MemOpIdx oi = make_memop_idx(MO_LEUL, MMU_USER_IDX);
256
+ uint16_t meminfo = trace_mem_get_info(oi, true);
257
258
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
259
stl_le_p(g2h(env_cpu(env), ptr), val);
260
@@ -XXX,XX +XXX,XX @@ void cpu_stl_le_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
261
262
void cpu_stq_le_data(CPUArchState *env, abi_ptr ptr, uint64_t val)
263
{
264
- uint16_t meminfo = trace_mem_get_info(MO_LEQ, MMU_USER_IDX, true);
265
+ MemOpIdx oi = make_memop_idx(MO_LEQ, MMU_USER_IDX);
266
+ uint16_t meminfo = trace_mem_get_info(oi, true);
267
268
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
269
stq_le_p(g2h(env_cpu(env), ptr), val);
270
diff --git a/tcg/tcg-op.c b/tcg/tcg-op.c
271
index XXXXXXX..XXXXXXX 100644
272
--- a/tcg/tcg-op.c
273
+++ b/tcg/tcg-op.c
274
@@ -XXX,XX +XXX,XX @@ static inline void plugin_gen_mem_callbacks(TCGv vaddr, uint16_t info)
275
void tcg_gen_qemu_ld_i32(TCGv_i32 val, TCGv addr, TCGArg idx, MemOp memop)
276
{
277
MemOp orig_memop;
278
- uint16_t info = trace_mem_get_info(memop, idx, 0);
279
+ uint16_t info = trace_mem_get_info(make_memop_idx(memop, idx), 0);
280
281
tcg_gen_req_mo(TCG_MO_LD_LD | TCG_MO_ST_LD);
282
memop = tcg_canonicalize_memop(memop, 0, 0);
283
@@ -XXX,XX +XXX,XX @@ void tcg_gen_qemu_ld_i32(TCGv_i32 val, TCGv addr, TCGArg idx, MemOp memop)
284
void tcg_gen_qemu_st_i32(TCGv_i32 val, TCGv addr, TCGArg idx, MemOp memop)
285
{
286
TCGv_i32 swap = NULL;
287
- uint16_t info = trace_mem_get_info(memop, idx, 1);
288
+ uint16_t info = trace_mem_get_info(make_memop_idx(memop, idx), 1);
289
290
tcg_gen_req_mo(TCG_MO_LD_ST | TCG_MO_ST_ST);
291
memop = tcg_canonicalize_memop(memop, 0, 1);
292
@@ -XXX,XX +XXX,XX @@ void tcg_gen_qemu_ld_i64(TCGv_i64 val, TCGv addr, TCGArg idx, MemOp memop)
293
294
tcg_gen_req_mo(TCG_MO_LD_LD | TCG_MO_ST_LD);
295
memop = tcg_canonicalize_memop(memop, 1, 0);
296
- info = trace_mem_get_info(memop, idx, 0);
297
+ info = trace_mem_get_info(make_memop_idx(memop, idx), 0);
298
trace_guest_mem_before_tcg(tcg_ctx->cpu, cpu_env, addr, info);
299
300
orig_memop = memop;
301
@@ -XXX,XX +XXX,XX @@ void tcg_gen_qemu_st_i64(TCGv_i64 val, TCGv addr, TCGArg idx, MemOp memop)
302
303
tcg_gen_req_mo(TCG_MO_LD_ST | TCG_MO_ST_ST);
304
memop = tcg_canonicalize_memop(memop, 1, 1);
305
- info = trace_mem_get_info(memop, idx, 1);
306
+ info = trace_mem_get_info(make_memop_idx(memop, idx), 1);
307
trace_guest_mem_before_tcg(tcg_ctx->cpu, cpu_env, addr, info);
308
309
if (!TCG_TARGET_HAS_MEMORY_BSWAP && (memop & MO_BSWAP)) {
310
diff --git a/accel/tcg/atomic_common.c.inc b/accel/tcg/atomic_common.c.inc
311
index XXXXXXX..XXXXXXX 100644
312
--- a/accel/tcg/atomic_common.c.inc
313
+++ b/accel/tcg/atomic_common.c.inc
314
@@ -XXX,XX +XXX,XX @@ static uint16_t atomic_trace_rmw_pre(CPUArchState *env, target_ulong addr,
315
MemOpIdx oi)
316
{
317
CPUState *cpu = env_cpu(env);
318
- uint16_t info = trace_mem_get_info(get_memop(oi), get_mmuidx(oi), false);
319
+ uint16_t info = trace_mem_get_info(oi, false);
320
321
trace_guest_mem_before_exec(cpu, addr, info);
322
trace_guest_mem_before_exec(cpu, addr, info | TRACE_MEM_ST);
323
@@ -XXX,XX +XXX,XX @@ static void atomic_trace_rmw_post(CPUArchState *env, target_ulong addr,
324
static uint16_t atomic_trace_ld_pre(CPUArchState *env, target_ulong addr,
325
MemOpIdx oi)
326
{
327
- uint16_t info = trace_mem_get_info(get_memop(oi), get_mmuidx(oi), false);
328
+ uint16_t info = trace_mem_get_info(oi, false);
329
330
trace_guest_mem_before_exec(env_cpu(env), addr, info);
331
332
@@ -XXX,XX +XXX,XX @@ static void atomic_trace_ld_post(CPUArchState *env, target_ulong addr,
333
static uint16_t atomic_trace_st_pre(CPUArchState *env, target_ulong addr,
334
MemOpIdx oi)
335
{
336
- uint16_t info = trace_mem_get_info(get_memop(oi), get_mmuidx(oi), true);
337
+ uint16_t info = trace_mem_get_info(oi, true);
338
339
trace_guest_mem_before_exec(env_cpu(env), addr, info);
340
341
--
342
2.25.1
343
344
diff view generated by jsdifflib
New patch
[PULL 09/28] accel/tcg: Pass MemOpIdx to atomic_trace_*_post
1
1
We will shortly use the MemOpIdx directly, but in the meantime
2
re-compute the trace meminfo.
3
4
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
5
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
6
---
7
accel/tcg/atomic_template.h | 48 +++++++++++++++++------------------
8
accel/tcg/atomic_common.c.inc | 30 +++++++++++-----------
9
2 files changed, 39 insertions(+), 39 deletions(-)
10
11
diff --git a/accel/tcg/atomic_template.h b/accel/tcg/atomic_template.h
12
index XXXXXXX..XXXXXXX 100644
13
--- a/accel/tcg/atomic_template.h
14
+++ b/accel/tcg/atomic_template.h
15
@@ -XXX,XX +XXX,XX @@ ABI_TYPE ATOMIC_NAME(cmpxchg)(CPUArchState *env, target_ulong addr,
16
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE,
17
PAGE_READ | PAGE_WRITE, retaddr);
18
DATA_TYPE ret;
19
- uint16_t info = atomic_trace_rmw_pre(env, addr, oi);
20
21
+ atomic_trace_rmw_pre(env, addr, oi);
22
#if DATA_SIZE == 16
23
ret = atomic16_cmpxchg(haddr, cmpv, newv);
24
#else
25
ret = qatomic_cmpxchg__nocheck(haddr, cmpv, newv);
26
#endif
27
ATOMIC_MMU_CLEANUP;
28
- atomic_trace_rmw_post(env, addr, info);
29
+ atomic_trace_rmw_post(env, addr, oi);
30
return ret;
31
}
32
33
@@ -XXX,XX +XXX,XX @@ ABI_TYPE ATOMIC_NAME(ld)(CPUArchState *env, target_ulong addr,
34
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE,
35
PAGE_READ, retaddr);
36
DATA_TYPE val;
37
- uint16_t info = atomic_trace_ld_pre(env, addr, oi);
38
39
+ atomic_trace_ld_pre(env, addr, oi);
40
val = atomic16_read(haddr);
41
ATOMIC_MMU_CLEANUP;
42
- atomic_trace_ld_post(env, addr, info);
43
+ atomic_trace_ld_post(env, addr, oi);
44
return val;
45
}
46
47
@@ -XXX,XX +XXX,XX @@ void ATOMIC_NAME(st)(CPUArchState *env, target_ulong addr, ABI_TYPE val,
48
{
49
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE,
50
PAGE_WRITE, retaddr);
51
- uint16_t info = atomic_trace_st_pre(env, addr, oi);
52
53
+ atomic_trace_st_pre(env, addr, oi);
54
atomic16_set(haddr, val);
55
ATOMIC_MMU_CLEANUP;
56
- atomic_trace_st_post(env, addr, info);
57
+ atomic_trace_st_post(env, addr, oi);
58
}
59
#endif
60
#else
61
@@ -XXX,XX +XXX,XX @@ ABI_TYPE ATOMIC_NAME(xchg)(CPUArchState *env, target_ulong addr, ABI_TYPE val,
62
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE,
63
PAGE_READ | PAGE_WRITE, retaddr);
64
DATA_TYPE ret;
65
- uint16_t info = atomic_trace_rmw_pre(env, addr, oi);
66
67
+ atomic_trace_rmw_pre(env, addr, oi);
68
ret = qatomic_xchg__nocheck(haddr, val);
69
ATOMIC_MMU_CLEANUP;
70
- atomic_trace_rmw_post(env, addr, info);
71
+ atomic_trace_rmw_post(env, addr, oi);
72
return ret;
73
}
74
75
@@ -XXX,XX +XXX,XX @@ ABI_TYPE ATOMIC_NAME(X)(CPUArchState *env, target_ulong addr, \
76
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE, \
77
PAGE_READ | PAGE_WRITE, retaddr); \
78
DATA_TYPE ret; \
79
- uint16_t info = atomic_trace_rmw_pre(env, addr, oi); \
80
+ atomic_trace_rmw_pre(env, addr, oi); \
81
ret = qatomic_##X(haddr, val); \
82
ATOMIC_MMU_CLEANUP; \
83
- atomic_trace_rmw_post(env, addr, info); \
84
+ atomic_trace_rmw_post(env, addr, oi); \
85
return ret; \
86
}
87
88
@@ -XXX,XX +XXX,XX @@ ABI_TYPE ATOMIC_NAME(X)(CPUArchState *env, target_ulong addr, \
89
XDATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE, \
90
PAGE_READ | PAGE_WRITE, retaddr); \
91
XDATA_TYPE cmp, old, new, val = xval; \
92
- uint16_t info = atomic_trace_rmw_pre(env, addr, oi); \
93
+ atomic_trace_rmw_pre(env, addr, oi); \
94
smp_mb(); \
95
cmp = qatomic_read__nocheck(haddr); \
96
do { \
97
@@ -XXX,XX +XXX,XX @@ ABI_TYPE ATOMIC_NAME(X)(CPUArchState *env, target_ulong addr, \
98
cmp = qatomic_cmpxchg__nocheck(haddr, old, new); \
99
} while (cmp != old); \
100
ATOMIC_MMU_CLEANUP; \
101
- atomic_trace_rmw_post(env, addr, info); \
102
+ atomic_trace_rmw_post(env, addr, oi); \
103
return RET; \
104
}
105
106
@@ -XXX,XX +XXX,XX @@ ABI_TYPE ATOMIC_NAME(cmpxchg)(CPUArchState *env, target_ulong addr,
107
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE,
108
PAGE_READ | PAGE_WRITE, retaddr);
109
DATA_TYPE ret;
110
- uint16_t info = atomic_trace_rmw_pre(env, addr, oi);
111
112
+ atomic_trace_rmw_pre(env, addr, oi);
113
#if DATA_SIZE == 16
114
ret = atomic16_cmpxchg(haddr, BSWAP(cmpv), BSWAP(newv));
115
#else
116
ret = qatomic_cmpxchg__nocheck(haddr, BSWAP(cmpv), BSWAP(newv));
117
#endif
118
ATOMIC_MMU_CLEANUP;
119
- atomic_trace_rmw_post(env, addr, info);
120
+ atomic_trace_rmw_post(env, addr, oi);
121
return BSWAP(ret);
122
}
123
124
@@ -XXX,XX +XXX,XX @@ ABI_TYPE ATOMIC_NAME(ld)(CPUArchState *env, target_ulong addr,
125
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE,
126
PAGE_READ, retaddr);
127
DATA_TYPE val;
128
- uint16_t info = atomic_trace_ld_pre(env, addr, oi);
129
130
+ atomic_trace_ld_pre(env, addr, oi);
131
val = atomic16_read(haddr);
132
ATOMIC_MMU_CLEANUP;
133
- atomic_trace_ld_post(env, addr, info);
134
+ atomic_trace_ld_post(env, addr, oi);
135
return BSWAP(val);
136
}
137
138
@@ -XXX,XX +XXX,XX @@ void ATOMIC_NAME(st)(CPUArchState *env, target_ulong addr, ABI_TYPE val,
139
{
140
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE,
141
PAGE_WRITE, retaddr);
142
- uint16_t info = atomic_trace_st_pre(env, addr, oi);
143
144
+ atomic_trace_st_pre(env, addr, oi);
145
val = BSWAP(val);
146
atomic16_set(haddr, val);
147
ATOMIC_MMU_CLEANUP;
148
- atomic_trace_st_post(env, addr, info);
149
+ atomic_trace_st_post(env, addr, oi);
150
}
151
#endif
152
#else
153
@@ -XXX,XX +XXX,XX @@ ABI_TYPE ATOMIC_NAME(xchg)(CPUArchState *env, target_ulong addr, ABI_TYPE val,
154
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE,
155
PAGE_READ | PAGE_WRITE, retaddr);
156
ABI_TYPE ret;
157
- uint16_t info = atomic_trace_rmw_pre(env, addr, oi);
158
159
+ atomic_trace_rmw_pre(env, addr, oi);
160
ret = qatomic_xchg__nocheck(haddr, BSWAP(val));
161
ATOMIC_MMU_CLEANUP;
162
- atomic_trace_rmw_post(env, addr, info);
163
+ atomic_trace_rmw_post(env, addr, oi);
164
return BSWAP(ret);
165
}
166
167
@@ -XXX,XX +XXX,XX @@ ABI_TYPE ATOMIC_NAME(X)(CPUArchState *env, target_ulong addr, \
168
DATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE, \
169
PAGE_READ | PAGE_WRITE, retaddr); \
170
DATA_TYPE ret; \
171
- uint16_t info = atomic_trace_rmw_pre(env, addr, oi); \
172
+ atomic_trace_rmw_pre(env, addr, oi); \
173
ret = qatomic_##X(haddr, BSWAP(val)); \
174
ATOMIC_MMU_CLEANUP; \
175
- atomic_trace_rmw_post(env, addr, info); \
176
+ atomic_trace_rmw_post(env, addr, oi); \
177
return BSWAP(ret); \
178
}
179
180
@@ -XXX,XX +XXX,XX @@ ABI_TYPE ATOMIC_NAME(X)(CPUArchState *env, target_ulong addr, \
181
XDATA_TYPE *haddr = atomic_mmu_lookup(env, addr, oi, DATA_SIZE, \
182
PAGE_READ | PAGE_WRITE, retaddr); \
183
XDATA_TYPE ldo, ldn, old, new, val = xval; \
184
- uint16_t info = atomic_trace_rmw_pre(env, addr, oi); \
185
+ atomic_trace_rmw_pre(env, addr, oi); \
186
smp_mb(); \
187
ldn = qatomic_read__nocheck(haddr); \
188
do { \
189
@@ -XXX,XX +XXX,XX @@ ABI_TYPE ATOMIC_NAME(X)(CPUArchState *env, target_ulong addr, \
190
ldn = qatomic_cmpxchg__nocheck(haddr, ldo, BSWAP(new)); \
191
} while (ldo != ldn); \
192
ATOMIC_MMU_CLEANUP; \
193
- atomic_trace_rmw_post(env, addr, info); \
194
+ atomic_trace_rmw_post(env, addr, oi); \
195
return RET; \
196
}
197
198
diff --git a/accel/tcg/atomic_common.c.inc b/accel/tcg/atomic_common.c.inc
199
index XXXXXXX..XXXXXXX 100644
200
--- a/accel/tcg/atomic_common.c.inc
201
+++ b/accel/tcg/atomic_common.c.inc
202
@@ -XXX,XX +XXX,XX @@
203
* See the COPYING file in the top-level directory.
204
*/
205
206
-static uint16_t atomic_trace_rmw_pre(CPUArchState *env, target_ulong addr,
207
- MemOpIdx oi)
208
+static void atomic_trace_rmw_pre(CPUArchState *env, target_ulong addr,
209
+ MemOpIdx oi)
210
{
211
CPUState *cpu = env_cpu(env);
212
uint16_t info = trace_mem_get_info(oi, false);
213
214
trace_guest_mem_before_exec(cpu, addr, info);
215
trace_guest_mem_before_exec(cpu, addr, info | TRACE_MEM_ST);
216
-
217
- return info;
218
}
219
220
static void atomic_trace_rmw_post(CPUArchState *env, target_ulong addr,
221
- uint16_t info)
222
+ MemOpIdx oi)
223
{
224
+ uint16_t info = trace_mem_get_info(oi, false);
225
+
226
qemu_plugin_vcpu_mem_cb(env_cpu(env), addr, info);
227
qemu_plugin_vcpu_mem_cb(env_cpu(env), addr, info | TRACE_MEM_ST);
228
}
229
230
#if HAVE_ATOMIC128
231
-static uint16_t atomic_trace_ld_pre(CPUArchState *env, target_ulong addr,
232
- MemOpIdx oi)
233
+static void atomic_trace_ld_pre(CPUArchState *env, target_ulong addr,
234
+ MemOpIdx oi)
235
{
236
uint16_t info = trace_mem_get_info(oi, false);
237
238
trace_guest_mem_before_exec(env_cpu(env), addr, info);
239
-
240
- return info;
241
}
242
243
static void atomic_trace_ld_post(CPUArchState *env, target_ulong addr,
244
- uint16_t info)
245
+ MemOpIdx oi)
246
{
247
+ uint16_t info = trace_mem_get_info(oi, false);
248
+
249
qemu_plugin_vcpu_mem_cb(env_cpu(env), addr, info);
250
}
251
252
-static uint16_t atomic_trace_st_pre(CPUArchState *env, target_ulong addr,
253
- MemOpIdx oi)
254
+static void atomic_trace_st_pre(CPUArchState *env, target_ulong addr,
255
+ MemOpIdx oi)
256
{
257
uint16_t info = trace_mem_get_info(oi, true);
258
259
trace_guest_mem_before_exec(env_cpu(env), addr, info);
260
-
261
- return info;
262
}
263
264
static void atomic_trace_st_post(CPUArchState *env, target_ulong addr,
265
- uint16_t info)
266
+ MemOpIdx oi)
267
{
268
+ uint16_t info = trace_mem_get_info(oi, false);
269
+
270
qemu_plugin_vcpu_mem_cb(env_cpu(env), addr, info);
271
}
272
#endif
273
--
274
2.25.1
275
276
diff view generated by jsdifflib
New patch
[PULL 10/28] plugins: Reorg arguments to qemu_plugin_vcpu_mem_cb
1
Use the MemOpIdx directly, rather than the rearrangement
2
of the same bits currently done by the trace infrastructure.
3
Pass in enum qemu_plugin_mem_rw so that we are able to treat
4
read-modify-write operations as a single operation.
1
5
6
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
7
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
8
---
9
include/qemu/plugin.h | 26 ++++++++++++++++++++++++--
10
accel/tcg/cputlb.c | 4 ++--
11
accel/tcg/plugin-gen.c | 5 ++---
12
accel/tcg/user-exec.c | 28 ++++++++++++++--------------
13
plugins/api.c | 19 +++++++++++--------
14
plugins/core.c | 10 +++++-----
15
tcg/tcg-op.c | 30 +++++++++++++++++++++---------
16
accel/tcg/atomic_common.c.inc | 13 +++----------
17
8 files changed, 82 insertions(+), 53 deletions(-)
18
19
diff --git a/include/qemu/plugin.h b/include/qemu/plugin.h
20
index XXXXXXX..XXXXXXX 100644
21
--- a/include/qemu/plugin.h
22
+++ b/include/qemu/plugin.h
23
@@ -XXX,XX +XXX,XX @@
24
#include "qemu/error-report.h"
25
#include "qemu/queue.h"
26
#include "qemu/option.h"
27
+#include "exec/memopidx.h"
28
29
/*
30
* Events that plugins can subscribe to.
31
@@ -XXX,XX +XXX,XX @@ enum qemu_plugin_event {
32
struct qemu_plugin_desc;
33
typedef QTAILQ_HEAD(, qemu_plugin_desc) QemuPluginList;
34
35
+/*
36
+ * Construct a qemu_plugin_meminfo_t.
37
+ */
38
+static inline qemu_plugin_meminfo_t
39
+make_plugin_meminfo(MemOpIdx oi, enum qemu_plugin_mem_rw rw)
40
+{
41
+ return oi | (rw << 16);
42
+}
43
+
44
+/*
45
+ * Extract the memory operation direction from a qemu_plugin_meminfo_t.
46
+ * Other portions may be extracted via get_memop and get_mmuidx.
47
+ */
48
+static inline enum qemu_plugin_mem_rw
49
+get_plugin_meminfo_rw(qemu_plugin_meminfo_t i)
50
+{
51
+ return i >> 16;
52
+}
53
+
54
#ifdef CONFIG_PLUGIN
55
extern QemuOptsList qemu_plugin_opts;
56
57
@@ -XXX,XX +XXX,XX @@ qemu_plugin_vcpu_syscall(CPUState *cpu, int64_t num, uint64_t a1,
58
uint64_t a6, uint64_t a7, uint64_t a8);
59
void qemu_plugin_vcpu_syscall_ret(CPUState *cpu, int64_t num, int64_t ret);
60
61
-void qemu_plugin_vcpu_mem_cb(CPUState *cpu, uint64_t vaddr, uint32_t meminfo);
62
+void qemu_plugin_vcpu_mem_cb(CPUState *cpu, uint64_t vaddr,
63
+ MemOpIdx oi, enum qemu_plugin_mem_rw rw);
64
65
void qemu_plugin_flush_cb(void);
66
67
@@ -XXX,XX +XXX,XX @@ void qemu_plugin_vcpu_syscall_ret(CPUState *cpu, int64_t num, int64_t ret)
68
{ }
69
70
static inline void qemu_plugin_vcpu_mem_cb(CPUState *cpu, uint64_t vaddr,
71
- uint32_t meminfo)
72
+ MemOpIdx oi,
73
+ enum qemu_plugin_mem_rw rw)
74
{ }
75
76
static inline void qemu_plugin_flush_cb(void)
77
diff --git a/accel/tcg/cputlb.c b/accel/tcg/cputlb.c
78
index XXXXXXX..XXXXXXX 100644
79
--- a/accel/tcg/cputlb.c
80
+++ b/accel/tcg/cputlb.c
81
@@ -XXX,XX +XXX,XX @@ static inline uint64_t cpu_load_helper(CPUArchState *env, abi_ptr addr,
82
83
ret = full_load(env, addr, oi, retaddr);
84
85
- qemu_plugin_vcpu_mem_cb(env_cpu(env), addr, meminfo);
86
+ qemu_plugin_vcpu_mem_cb(env_cpu(env), addr, oi, QEMU_PLUGIN_MEM_R);
87
88
return ret;
89
}
90
@@ -XXX,XX +XXX,XX @@ cpu_store_helper(CPUArchState *env, target_ulong addr, uint64_t val,
91
92
store_helper(env, addr, val, oi, retaddr, op);
93
94
- qemu_plugin_vcpu_mem_cb(env_cpu(env), addr, meminfo);
95
+ qemu_plugin_vcpu_mem_cb(env_cpu(env), addr, oi, QEMU_PLUGIN_MEM_W);
96
}
97
98
void cpu_stb_mmuidx_ra(CPUArchState *env, target_ulong addr, uint32_t val,
99
diff --git a/accel/tcg/plugin-gen.c b/accel/tcg/plugin-gen.c
100
index XXXXXXX..XXXXXXX 100644
101
--- a/accel/tcg/plugin-gen.c
102
+++ b/accel/tcg/plugin-gen.c
103
@@ -XXX,XX +XXX,XX @@
104
#include "qemu/osdep.h"
105
#include "tcg/tcg.h"
106
#include "tcg/tcg-op.h"
107
-#include "trace/mem.h"
108
#include "exec/exec-all.h"
109
#include "exec/plugin-gen.h"
110
#include "exec/translator.h"
111
@@ -XXX,XX +XXX,XX @@ static void gen_mem_wrapped(enum plugin_gen_cb type,
112
const union mem_gen_fn *f, TCGv addr,
113
uint32_t info, bool is_mem)
114
{
115
- int wr = !!(info & TRACE_MEM_ST);
116
+ enum qemu_plugin_mem_rw rw = get_plugin_meminfo_rw(info);
117
118
- gen_plugin_cb_start(PLUGIN_GEN_FROM_MEM, type, wr);
119
+ gen_plugin_cb_start(PLUGIN_GEN_FROM_MEM, type, rw);
120
if (is_mem) {
121
f->mem_fn(addr, info);
122
} else {
123
diff --git a/accel/tcg/user-exec.c b/accel/tcg/user-exec.c
124
index XXXXXXX..XXXXXXX 100644
125
--- a/accel/tcg/user-exec.c
126
+++ b/accel/tcg/user-exec.c
127
@@ -XXX,XX +XXX,XX @@ uint32_t cpu_ldub_data(CPUArchState *env, abi_ptr ptr)
128
129
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
130
ret = ldub_p(g2h(env_cpu(env), ptr));
131
- qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, meminfo);
132
+ qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_R);
133
return ret;
134
}
135
136
@@ -XXX,XX +XXX,XX @@ uint32_t cpu_lduw_be_data(CPUArchState *env, abi_ptr ptr)
137
138
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
139
ret = lduw_be_p(g2h(env_cpu(env), ptr));
140
- qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, meminfo);
141
+ qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_R);
142
return ret;
143
}
144
145
@@ -XXX,XX +XXX,XX @@ uint32_t cpu_ldl_be_data(CPUArchState *env, abi_ptr ptr)
146
147
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
148
ret = ldl_be_p(g2h(env_cpu(env), ptr));
149
- qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, meminfo);
150
+ qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_R);
151
return ret;
152
}
153
154
@@ -XXX,XX +XXX,XX @@ uint64_t cpu_ldq_be_data(CPUArchState *env, abi_ptr ptr)
155
156
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
157
ret = ldq_be_p(g2h(env_cpu(env), ptr));
158
- qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, meminfo);
159
+ qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_R);
160
return ret;
161
}
162
163
@@ -XXX,XX +XXX,XX @@ uint32_t cpu_lduw_le_data(CPUArchState *env, abi_ptr ptr)
164
165
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
166
ret = lduw_le_p(g2h(env_cpu(env), ptr));
167
- qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, meminfo);
168
+ qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_R);
169
return ret;
170
}
171
172
@@ -XXX,XX +XXX,XX @@ uint32_t cpu_ldl_le_data(CPUArchState *env, abi_ptr ptr)
173
174
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
175
ret = ldl_le_p(g2h(env_cpu(env), ptr));
176
- qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, meminfo);
177
+ qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_R);
178
return ret;
179
}
180
181
@@ -XXX,XX +XXX,XX @@ uint64_t cpu_ldq_le_data(CPUArchState *env, abi_ptr ptr)
182
183
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
184
ret = ldq_le_p(g2h(env_cpu(env), ptr));
185
- qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, meminfo);
186
+ qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_R);
187
return ret;
188
}
189
190
@@ -XXX,XX +XXX,XX @@ void cpu_stb_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
191
192
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
193
stb_p(g2h(env_cpu(env), ptr), val);
194
- qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, meminfo);
195
+ qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_W);
196
}
197
198
void cpu_stw_be_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
199
@@ -XXX,XX +XXX,XX @@ void cpu_stw_be_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
200
201
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
202
stw_be_p(g2h(env_cpu(env), ptr), val);
203
- qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, meminfo);
204
+ qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_W);
205
}
206
207
void cpu_stl_be_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
208
@@ -XXX,XX +XXX,XX @@ void cpu_stl_be_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
209
210
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
211
stl_be_p(g2h(env_cpu(env), ptr), val);
212
- qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, meminfo);
213
+ qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_W);
214
}
215
216
void cpu_stq_be_data(CPUArchState *env, abi_ptr ptr, uint64_t val)
217
@@ -XXX,XX +XXX,XX @@ void cpu_stq_be_data(CPUArchState *env, abi_ptr ptr, uint64_t val)
218
219
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
220
stq_be_p(g2h(env_cpu(env), ptr), val);
221
- qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, meminfo);
222
+ qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_W);
223
}
224
225
void cpu_stw_le_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
226
@@ -XXX,XX +XXX,XX @@ void cpu_stw_le_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
227
228
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
229
stw_le_p(g2h(env_cpu(env), ptr), val);
230
- qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, meminfo);
231
+ qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_W);
232
}
233
234
void cpu_stl_le_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
235
@@ -XXX,XX +XXX,XX @@ void cpu_stl_le_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
236
237
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
238
stl_le_p(g2h(env_cpu(env), ptr), val);
239
- qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, meminfo);
240
+ qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_W);
241
}
242
243
void cpu_stq_le_data(CPUArchState *env, abi_ptr ptr, uint64_t val)
244
@@ -XXX,XX +XXX,XX @@ void cpu_stq_le_data(CPUArchState *env, abi_ptr ptr, uint64_t val)
245
246
trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
247
stq_le_p(g2h(env_cpu(env), ptr), val);
248
- qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, meminfo);
249
+ qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_W);
250
}
251
252
void cpu_stb_data_ra(CPUArchState *env, abi_ptr ptr,
253
diff --git a/plugins/api.c b/plugins/api.c
254
index XXXXXXX..XXXXXXX 100644
255
--- a/plugins/api.c
256
+++ b/plugins/api.c
257
@@ -XXX,XX +XXX,XX @@
258
#include "qemu/plugin-memory.h"
259
#include "hw/boards.h"
260
#endif
261
-#include "trace/mem.h"
262
263
/* Uninstall and Reset handlers */
264
265
@@ -XXX,XX +XXX,XX @@ const char *qemu_plugin_insn_symbol(const struct qemu_plugin_insn *insn)
266
267
unsigned qemu_plugin_mem_size_shift(qemu_plugin_meminfo_t info)
268
{
269
- return info & TRACE_MEM_SZ_SHIFT_MASK;
270
+ MemOp op = get_memop(info);
271
+ return op & MO_SIZE;
272
}
273
274
bool qemu_plugin_mem_is_sign_extended(qemu_plugin_meminfo_t info)
275
{
276
- return !!(info & TRACE_MEM_SE);
277
+ MemOp op = get_memop(info);
278
+ return op & MO_SIGN;
279
}
280
281
bool qemu_plugin_mem_is_big_endian(qemu_plugin_meminfo_t info)
282
{
283
- return !!(info & TRACE_MEM_BE);
284
+ MemOp op = get_memop(info);
285
+ return (op & MO_BSWAP) == MO_BE;
286
}
287
288
bool qemu_plugin_mem_is_store(qemu_plugin_meminfo_t info)
289
{
290
- return !!(info & TRACE_MEM_ST);
291
+ return get_plugin_meminfo_rw(info) & QEMU_PLUGIN_MEM_W;
292
}
293
294
/*
295
@@ -XXX,XX +XXX,XX @@ struct qemu_plugin_hwaddr *qemu_plugin_get_hwaddr(qemu_plugin_meminfo_t info,
296
{
297
#ifdef CONFIG_SOFTMMU
298
CPUState *cpu = current_cpu;
299
- unsigned int mmu_idx = info >> TRACE_MEM_MMU_SHIFT;
300
- hwaddr_info.is_store = info & TRACE_MEM_ST;
301
+ unsigned int mmu_idx = get_mmuidx(info);
302
+ enum qemu_plugin_mem_rw rw = get_plugin_meminfo_rw(info);
303
+ hwaddr_info.is_store = (rw & QEMU_PLUGIN_MEM_W) != 0;
304
305
if (!tlb_plugin_lookup(cpu, vaddr, mmu_idx,
306
- info & TRACE_MEM_ST, &hwaddr_info)) {
307
+ hwaddr_info.is_store, &hwaddr_info)) {
308
error_report("invalid use of qemu_plugin_get_hwaddr");
309
return NULL;
310
}
311
diff --git a/plugins/core.c b/plugins/core.c
312
index XXXXXXX..XXXXXXX 100644
313
--- a/plugins/core.c
314
+++ b/plugins/core.c
315
@@ -XXX,XX +XXX,XX @@
316
#include "exec/helper-proto.h"
317
#include "tcg/tcg.h"
318
#include "tcg/tcg-op.h"
319
-#include "trace/mem.h" /* mem_info macros */
320
#include "plugin.h"
321
#include "qemu/compiler.h"
322
323
@@ -XXX,XX +XXX,XX @@ void exec_inline_op(struct qemu_plugin_dyn_cb *cb)
324
}
325
}
326
327
-void qemu_plugin_vcpu_mem_cb(CPUState *cpu, uint64_t vaddr, uint32_t info)
328
+void qemu_plugin_vcpu_mem_cb(CPUState *cpu, uint64_t vaddr,
329
+ MemOpIdx oi, enum qemu_plugin_mem_rw rw)
330
{
331
GArray *arr = cpu->plugin_mem_cbs;
332
size_t i;
333
@@ -XXX,XX +XXX,XX @@ void qemu_plugin_vcpu_mem_cb(CPUState *cpu, uint64_t vaddr, uint32_t info)
334
for (i = 0; i < arr->len; i++) {
335
struct qemu_plugin_dyn_cb *cb =
336
&g_array_index(arr, struct qemu_plugin_dyn_cb, i);
337
- int w = !!(info & TRACE_MEM_ST) + 1;
338
339
- if (!(w & cb->rw)) {
340
+ if (!(rw & cb->rw)) {
341
break;
342
}
343
switch (cb->type) {
344
case PLUGIN_CB_REGULAR:
345
- cb->f.vcpu_mem(cpu->cpu_index, info, vaddr, cb->userp);
346
+ cb->f.vcpu_mem(cpu->cpu_index, make_plugin_meminfo(oi, rw),
347
+ vaddr, cb->userp);
348
break;
349
case PLUGIN_CB_INLINE:
350
exec_inline_op(cb);
351
diff --git a/tcg/tcg-op.c b/tcg/tcg-op.c
352
index XXXXXXX..XXXXXXX 100644
353
--- a/tcg/tcg-op.c
354
+++ b/tcg/tcg-op.c
355
@@ -XXX,XX +XXX,XX @@ static inline TCGv plugin_prep_mem_callbacks(TCGv vaddr)
356
return vaddr;
357
}
358
359
-static inline void plugin_gen_mem_callbacks(TCGv vaddr, uint16_t info)
360
+static void plugin_gen_mem_callbacks(TCGv vaddr, MemOpIdx oi,
361
+ enum qemu_plugin_mem_rw rw)
362
{
363
#ifdef CONFIG_PLUGIN
364
if (tcg_ctx->plugin_insn != NULL) {
365
+ qemu_plugin_meminfo_t info = make_plugin_meminfo(oi, rw);
366
plugin_gen_empty_mem_callback(vaddr, info);
367
tcg_temp_free(vaddr);
368
}
369
@@ -XXX,XX +XXX,XX @@ static inline void plugin_gen_mem_callbacks(TCGv vaddr, uint16_t info)
370
void tcg_gen_qemu_ld_i32(TCGv_i32 val, TCGv addr, TCGArg idx, MemOp memop)
371
{
372
MemOp orig_memop;
373
- uint16_t info = trace_mem_get_info(make_memop_idx(memop, idx), 0);
374
+ MemOpIdx oi;
375
+ uint16_t info;
376
377
tcg_gen_req_mo(TCG_MO_LD_LD | TCG_MO_ST_LD);
378
memop = tcg_canonicalize_memop(memop, 0, 0);
379
+ oi = make_memop_idx(memop, idx);
380
+ info = trace_mem_get_info(oi, 0);
381
trace_guest_mem_before_tcg(tcg_ctx->cpu, cpu_env, addr, info);
382
383
orig_memop = memop;
384
@@ -XXX,XX +XXX,XX @@ void tcg_gen_qemu_ld_i32(TCGv_i32 val, TCGv addr, TCGArg idx, MemOp memop)
385
386
addr = plugin_prep_mem_callbacks(addr);
387
gen_ldst_i32(INDEX_op_qemu_ld_i32, val, addr, memop, idx);
388
- plugin_gen_mem_callbacks(addr, info);
389
+ plugin_gen_mem_callbacks(addr, oi, QEMU_PLUGIN_MEM_R);
390
391
if ((orig_memop ^ memop) & MO_BSWAP) {
392
switch (orig_memop & MO_SIZE) {
393
@@ -XXX,XX +XXX,XX @@ void tcg_gen_qemu_ld_i32(TCGv_i32 val, TCGv addr, TCGArg idx, MemOp memop)
394
void tcg_gen_qemu_st_i32(TCGv_i32 val, TCGv addr, TCGArg idx, MemOp memop)
395
{
396
TCGv_i32 swap = NULL;
397
- uint16_t info = trace_mem_get_info(make_memop_idx(memop, idx), 1);
398
+ MemOpIdx oi;
399
+ uint16_t info;
400
401
tcg_gen_req_mo(TCG_MO_LD_ST | TCG_MO_ST_ST);
402
memop = tcg_canonicalize_memop(memop, 0, 1);
403
+ oi = make_memop_idx(memop, idx);
404
+ info = trace_mem_get_info(oi, 1);
405
trace_guest_mem_before_tcg(tcg_ctx->cpu, cpu_env, addr, info);
406
407
if (!TCG_TARGET_HAS_MEMORY_BSWAP && (memop & MO_BSWAP)) {
408
@@ -XXX,XX +XXX,XX @@ void tcg_gen_qemu_st_i32(TCGv_i32 val, TCGv addr, TCGArg idx, MemOp memop)
409
} else {
410
gen_ldst_i32(INDEX_op_qemu_st_i32, val, addr, memop, idx);
411
}
412
- plugin_gen_mem_callbacks(addr, info);
413
+ plugin_gen_mem_callbacks(addr, oi, QEMU_PLUGIN_MEM_W);
414
415
if (swap) {
416
tcg_temp_free_i32(swap);
417
@@ -XXX,XX +XXX,XX @@ void tcg_gen_qemu_st_i32(TCGv_i32 val, TCGv addr, TCGArg idx, MemOp memop)
418
void tcg_gen_qemu_ld_i64(TCGv_i64 val, TCGv addr, TCGArg idx, MemOp memop)
419
{
420
MemOp orig_memop;
421
+ MemOpIdx oi;
422
uint16_t info;
423
424
if (TCG_TARGET_REG_BITS == 32 && (memop & MO_SIZE) < MO_64) {
425
@@ -XXX,XX +XXX,XX @@ void tcg_gen_qemu_ld_i64(TCGv_i64 val, TCGv addr, TCGArg idx, MemOp memop)
426
427
tcg_gen_req_mo(TCG_MO_LD_LD | TCG_MO_ST_LD);
428
memop = tcg_canonicalize_memop(memop, 1, 0);
429
- info = trace_mem_get_info(make_memop_idx(memop, idx), 0);
430
+ oi = make_memop_idx(memop, idx);
431
+ info = trace_mem_get_info(oi, 0);
432
trace_guest_mem_before_tcg(tcg_ctx->cpu, cpu_env, addr, info);
433
434
orig_memop = memop;
435
@@ -XXX,XX +XXX,XX @@ void tcg_gen_qemu_ld_i64(TCGv_i64 val, TCGv addr, TCGArg idx, MemOp memop)
436
437
addr = plugin_prep_mem_callbacks(addr);
438
gen_ldst_i64(INDEX_op_qemu_ld_i64, val, addr, memop, idx);
439
- plugin_gen_mem_callbacks(addr, info);
440
+ plugin_gen_mem_callbacks(addr, oi, QEMU_PLUGIN_MEM_R);
441
442
if ((orig_memop ^ memop) & MO_BSWAP) {
443
int flags = (orig_memop & MO_SIGN
444
@@ -XXX,XX +XXX,XX @@ void tcg_gen_qemu_ld_i64(TCGv_i64 val, TCGv addr, TCGArg idx, MemOp memop)
445
void tcg_gen_qemu_st_i64(TCGv_i64 val, TCGv addr, TCGArg idx, MemOp memop)
446
{
447
TCGv_i64 swap = NULL;
448
+ MemOpIdx oi;
449
uint16_t info;
450
451
if (TCG_TARGET_REG_BITS == 32 && (memop & MO_SIZE) < MO_64) {
452
@@ -XXX,XX +XXX,XX @@ void tcg_gen_qemu_st_i64(TCGv_i64 val, TCGv addr, TCGArg idx, MemOp memop)
453
454
tcg_gen_req_mo(TCG_MO_LD_ST | TCG_MO_ST_ST);
455
memop = tcg_canonicalize_memop(memop, 1, 1);
456
- info = trace_mem_get_info(make_memop_idx(memop, idx), 1);
457
+ oi = make_memop_idx(memop, idx);
458
+ info = trace_mem_get_info(oi, 1);
459
trace_guest_mem_before_tcg(tcg_ctx->cpu, cpu_env, addr, info);
460
461
if (!TCG_TARGET_HAS_MEMORY_BSWAP && (memop & MO_BSWAP)) {
462
@@ -XXX,XX +XXX,XX @@ void tcg_gen_qemu_st_i64(TCGv_i64 val, TCGv addr, TCGArg idx, MemOp memop)
463
464
addr = plugin_prep_mem_callbacks(addr);
465
gen_ldst_i64(INDEX_op_qemu_st_i64, val, addr, memop, idx);
466
- plugin_gen_mem_callbacks(addr, info);
467
+ plugin_gen_mem_callbacks(addr, oi, QEMU_PLUGIN_MEM_W);
468
469
if (swap) {
470
tcg_temp_free_i64(swap);
471
diff --git a/accel/tcg/atomic_common.c.inc b/accel/tcg/atomic_common.c.inc
472
index XXXXXXX..XXXXXXX 100644
473
--- a/accel/tcg/atomic_common.c.inc
474
+++ b/accel/tcg/atomic_common.c.inc
475
@@ -XXX,XX +XXX,XX @@ static void atomic_trace_rmw_pre(CPUArchState *env, target_ulong addr,
476
static void atomic_trace_rmw_post(CPUArchState *env, target_ulong addr,
477
MemOpIdx oi)
478
{
479
- uint16_t info = trace_mem_get_info(oi, false);
480
-
481
- qemu_plugin_vcpu_mem_cb(env_cpu(env), addr, info);
482
- qemu_plugin_vcpu_mem_cb(env_cpu(env), addr, info | TRACE_MEM_ST);
483
+ qemu_plugin_vcpu_mem_cb(env_cpu(env), addr, oi, QEMU_PLUGIN_MEM_RW);
484
}
485
486
#if HAVE_ATOMIC128
487
@@ -XXX,XX +XXX,XX @@ static void atomic_trace_ld_pre(CPUArchState *env, target_ulong addr,
488
static void atomic_trace_ld_post(CPUArchState *env, target_ulong addr,
489
MemOpIdx oi)
490
{
491
- uint16_t info = trace_mem_get_info(oi, false);
492
-
493
- qemu_plugin_vcpu_mem_cb(env_cpu(env), addr, info);
494
+ qemu_plugin_vcpu_mem_cb(env_cpu(env), addr, oi, QEMU_PLUGIN_MEM_R);
495
}
496
497
static void atomic_trace_st_pre(CPUArchState *env, target_ulong addr,
498
@@ -XXX,XX +XXX,XX @@ static void atomic_trace_st_pre(CPUArchState *env, target_ulong addr,
499
static void atomic_trace_st_post(CPUArchState *env, target_ulong addr,
500
MemOpIdx oi)
501
{
502
- uint16_t info = trace_mem_get_info(oi, false);
503
-
504
- qemu_plugin_vcpu_mem_cb(env_cpu(env), addr, info);
505
+ qemu_plugin_vcpu_mem_cb(env_cpu(env), addr, oi, QEMU_PLUGIN_MEM_W);
506
}
507
#endif
508
509
--
510
2.25.1
511
512
diff view generated by jsdifflib
[PULL 2/3] accel/tcg: split tcg_start_vcpu_thread
[PULL 11/28] trace: Split guest_mem_before
1
From: Claudio Fontana <cfontana@suse.de>
1
There is no point in encoding load/store within a bit of
2
the memory trace info operand. Represent atomic operations
3
as a single read-modify-write tracepoint. Use MemOpIdx
4
instead of inventing a form specifically for traces.
2
5
3
after the initial split into 3 tcg variants, we proceed to also
6
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
4
split tcg_start_vcpu_thread.
5
6
We actually split it in 2 this time, since the icount variant
7
just uses the round robin function.
8
9
Suggested-by: Richard Henderson <richard.henderson@linaro.org>
10
Signed-off-by: Claudio Fontana <cfontana@suse.de>
11
Message-Id: <20201015143217.29337-3-cfontana@suse.de>
12
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
7
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
13
---
8
---
14
accel/tcg/tcg-cpus-mttcg.h | 21 --------------
9
accel/tcg/atomic_template.h | 1 -
15
accel/tcg/tcg-cpus-rr.h | 3 +-
10
trace/mem.h | 51 -----------------------------------
16
accel/tcg/tcg-cpus.h | 1 -
11
accel/tcg/cputlb.c | 7 ++---
17
accel/tcg/tcg-all.c | 5 ++++
12
accel/tcg/user-exec.c | 44 +++++++++++-------------------
18
accel/tcg/tcg-cpus-icount.c | 2 +-
13
tcg/tcg-op.c | 17 +++---------
19
accel/tcg/tcg-cpus-mttcg.c | 29 +++++++++++++++++--
14
accel/tcg/atomic_common.c.inc | 12 +++------
20
accel/tcg/tcg-cpus-rr.c | 39 +++++++++++++++++++++++--
15
trace-events | 18 +++----------
21
accel/tcg/tcg-cpus.c | 58 -------------------------------------
16
7 files changed, 28 insertions(+), 122 deletions(-)
22
8 files changed, 71 insertions(+), 87 deletions(-)
17
delete mode 100644 trace/mem.h
23
delete mode 100644 accel/tcg/tcg-cpus-mttcg.h
24
18
25
diff --git a/accel/tcg/tcg-cpus-mttcg.h b/accel/tcg/tcg-cpus-mttcg.h
19
diff --git a/accel/tcg/atomic_template.h b/accel/tcg/atomic_template.h
20
index XXXXXXX..XXXXXXX 100644
21
--- a/accel/tcg/atomic_template.h
22
+++ b/accel/tcg/atomic_template.h
23
@@ -XXX,XX +XXX,XX @@
24
*/
25
26
#include "qemu/plugin.h"
27
-#include "trace/mem.h"
28
29
#if DATA_SIZE == 16
30
# define SUFFIX o
31
diff --git a/trace/mem.h b/trace/mem.h
26
deleted file mode 100644
32
deleted file mode 100644
27
index XXXXXXX..XXXXXXX
33
index XXXXXXX..XXXXXXX
28
--- a/accel/tcg/tcg-cpus-mttcg.h
34
--- a/trace/mem.h
29
+++ /dev/null
35
+++ /dev/null
30
@@ -XXX,XX +XXX,XX @@
36
@@ -XXX,XX +XXX,XX @@
31
-/*
37
-/*
32
- * QEMU TCG Multi Threaded vCPUs implementation
38
- * Helper functions for guest memory tracing
33
- *
39
- *
34
- * Copyright 2020 SUSE LLC
40
- * Copyright (C) 2016 Lluís Vilanova <vilanova@ac.upc.edu>
35
- *
41
- *
36
- * This work is licensed under the terms of the GNU GPL, version 2 or later.
42
- * This work is licensed under the terms of the GNU GPL, version 2 or later.
37
- * See the COPYING file in the top-level directory.
43
- * See the COPYING file in the top-level directory.
38
- */
44
- */
39
-
45
-
40
-#ifndef TCG_CPUS_MTTCG_H
46
-#ifndef TRACE__MEM_H
41
-#define TCG_CPUS_MTTCG_H
47
-#define TRACE__MEM_H
42
-
48
-
43
-/*
49
-#include "exec/memopidx.h"
44
- * In the multi-threaded case each vCPU has its own thread. The TLS
50
-
45
- * variable current_cpu can be used deep in the code to find the
51
-#define TRACE_MEM_SZ_SHIFT_MASK 0xf /* size shift mask */
46
- * current CPUState for a given thread.
52
-#define TRACE_MEM_SE (1ULL << 4) /* sign extended (y/n) */
53
-#define TRACE_MEM_BE (1ULL << 5) /* big endian (y/n) */
54
-#define TRACE_MEM_ST (1ULL << 6) /* store (y/n) */
55
-#define TRACE_MEM_MMU_SHIFT 8 /* mmu idx */
56
-
57
-/**
58
- * trace_mem_get_info:
59
- *
60
- * Return a value for the 'info' argument in guest memory access traces.
47
- */
61
- */
48
-
62
-static inline uint16_t trace_mem_get_info(MemOpIdx oi, bool store)
49
-void *tcg_cpu_thread_fn(void *arg);
63
-{
50
-
64
- MemOp op = get_memop(oi);
51
-#endif /* TCG_CPUS_MTTCG_H */
65
- uint32_t size_shift = op & MO_SIZE;
52
diff --git a/accel/tcg/tcg-cpus-rr.h b/accel/tcg/tcg-cpus-rr.h
66
- bool sign_extend = op & MO_SIGN;
53
index XXXXXXX..XXXXXXX 100644
67
- bool big_endian = (op & MO_BSWAP) == MO_BE;
54
--- a/accel/tcg/tcg-cpus-rr.h
68
- uint16_t res;
55
+++ b/accel/tcg/tcg-cpus-rr.h
69
-
70
- res = size_shift & TRACE_MEM_SZ_SHIFT_MASK;
71
- if (sign_extend) {
72
- res |= TRACE_MEM_SE;
73
- }
74
- if (big_endian) {
75
- res |= TRACE_MEM_BE;
76
- }
77
- if (store) {
78
- res |= TRACE_MEM_ST;
79
- }
80
-#ifdef CONFIG_SOFTMMU
81
- res |= get_mmuidx(oi) << TRACE_MEM_MMU_SHIFT;
82
-#endif
83
-
84
- return res;
85
-}
86
-
87
-#endif /* TRACE__MEM_H */
88
diff --git a/accel/tcg/cputlb.c b/accel/tcg/cputlb.c
89
index XXXXXXX..XXXXXXX 100644
90
--- a/accel/tcg/cputlb.c
91
+++ b/accel/tcg/cputlb.c
56
@@ -XXX,XX +XXX,XX @@
92
@@ -XXX,XX +XXX,XX @@
57
/* Kick all RR vCPUs. */
93
#include "qemu/atomic128.h"
58
void qemu_cpu_kick_rr_cpus(CPUState *unused);
94
#include "exec/translate-all.h"
59
95
#include "trace/trace-root.h"
60
-void *tcg_rr_cpu_thread_fn(void *arg);
96
-#include "trace/mem.h"
61
+/* start the round robin vcpu thread */
97
#include "tb-hash.h"
62
+void rr_start_vcpu_thread(CPUState *cpu);
98
#include "internal.h"
63
99
#ifdef CONFIG_PLUGIN
64
#endif /* TCG_CPUS_RR_H */
100
@@ -XXX,XX +XXX,XX @@ static inline uint64_t cpu_load_helper(CPUArchState *env, abi_ptr addr,
65
diff --git a/accel/tcg/tcg-cpus.h b/accel/tcg/tcg-cpus.h
101
MemOp op, FullLoadHelper *full_load)
66
index XXXXXXX..XXXXXXX 100644
102
{
67
--- a/accel/tcg/tcg-cpus.h
103
MemOpIdx oi = make_memop_idx(op, mmu_idx);
68
+++ b/accel/tcg/tcg-cpus.h
104
- uint16_t meminfo = trace_mem_get_info(oi, false);
69
@@ -XXX,XX +XXX,XX @@ extern const CpusAccel tcg_cpus_mttcg;
105
uint64_t ret;
70
extern const CpusAccel tcg_cpus_icount;
106
71
extern const CpusAccel tcg_cpus_rr;
107
- trace_guest_mem_before_exec(env_cpu(env), addr, meminfo);
72
108
+ trace_guest_ld_before_exec(env_cpu(env), addr, oi);
73
-void tcg_start_vcpu_thread(CPUState *cpu);
109
74
void qemu_tcg_destroy_vcpu(CPUState *cpu);
110
ret = full_load(env, addr, oi, retaddr);
75
int tcg_cpu_exec(CPUState *cpu);
111
76
void tcg_handle_interrupt(CPUState *cpu, int mask);
112
@@ -XXX,XX +XXX,XX @@ cpu_store_helper(CPUArchState *env, target_ulong addr, uint64_t val,
77
diff --git a/accel/tcg/tcg-all.c b/accel/tcg/tcg-all.c
113
int mmu_idx, uintptr_t retaddr, MemOp op)
78
index XXXXXXX..XXXXXXX 100644
114
{
79
--- a/accel/tcg/tcg-all.c
115
MemOpIdx oi = make_memop_idx(op, mmu_idx);
80
+++ b/accel/tcg/tcg-all.c
116
- uint16_t meminfo = trace_mem_get_info(oi, true);
81
@@ -XXX,XX +XXX,XX @@ static int tcg_init(MachineState *ms)
117
82
tcg_exec_init(s->tb_size * 1024 * 1024);
118
- trace_guest_mem_before_exec(env_cpu(env), addr, meminfo);
83
mttcg_enabled = s->mttcg_enabled;
119
+ trace_guest_st_before_exec(env_cpu(env), addr, oi);
84
120
85
+ /*
121
store_helper(env, addr, val, oi, retaddr, op);
86
+ * Initialize TCG regions
122
87
+ */
123
diff --git a/accel/tcg/user-exec.c b/accel/tcg/user-exec.c
88
+ tcg_region_init();
124
index XXXXXXX..XXXXXXX 100644
89
+
125
--- a/accel/tcg/user-exec.c
90
if (mttcg_enabled) {
126
+++ b/accel/tcg/user-exec.c
91
cpus_register_accel(&tcg_cpus_mttcg);
92
} else if (icount_enabled()) {
93
diff --git a/accel/tcg/tcg-cpus-icount.c b/accel/tcg/tcg-cpus-icount.c
94
index XXXXXXX..XXXXXXX 100644
95
--- a/accel/tcg/tcg-cpus-icount.c
96
+++ b/accel/tcg/tcg-cpus-icount.c
97
@@ -XXX,XX +XXX,XX @@ static void icount_handle_interrupt(CPUState *cpu, int mask)
98
}
99
100
const CpusAccel tcg_cpus_icount = {
101
- .create_vcpu_thread = tcg_start_vcpu_thread,
102
+ .create_vcpu_thread = rr_start_vcpu_thread,
103
.kick_vcpu_thread = qemu_cpu_kick_rr_cpus,
104
105
.handle_interrupt = icount_handle_interrupt,
106
diff --git a/accel/tcg/tcg-cpus-mttcg.c b/accel/tcg/tcg-cpus-mttcg.c
107
index XXXXXXX..XXXXXXX 100644
108
--- a/accel/tcg/tcg-cpus-mttcg.c
109
+++ b/accel/tcg/tcg-cpus-mttcg.c
110
@@ -XXX,XX +XXX,XX @@
127
@@ -XXX,XX +XXX,XX @@
111
#include "hw/boards.h"
128
#include "exec/helper-proto.h"
112
129
#include "qemu/atomic128.h"
113
#include "tcg-cpus.h"
130
#include "trace/trace-root.h"
114
-#include "tcg-cpus-mttcg.h"
131
-#include "trace/mem.h"
115
132
+#include "internal.h"
116
/*
133
117
* In the multi-threaded case each vCPU has its own thread. The TLS
134
#undef EAX
135
#undef ECX
136
@@ -XXX,XX +XXX,XX @@ int cpu_signal_handler(int host_signum, void *pinfo,
137
uint32_t cpu_ldub_data(CPUArchState *env, abi_ptr ptr)
138
{
139
MemOpIdx oi = make_memop_idx(MO_UB, MMU_USER_IDX);
140
- uint16_t meminfo = trace_mem_get_info(oi, false);
141
uint32_t ret;
142
143
- trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
144
+ trace_guest_ld_before_exec(env_cpu(env), ptr, oi);
145
ret = ldub_p(g2h(env_cpu(env), ptr));
146
qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_R);
147
return ret;
148
@@ -XXX,XX +XXX,XX @@ int cpu_ldsb_data(CPUArchState *env, abi_ptr ptr)
149
uint32_t cpu_lduw_be_data(CPUArchState *env, abi_ptr ptr)
150
{
151
MemOpIdx oi = make_memop_idx(MO_BEUW, MMU_USER_IDX);
152
- uint16_t meminfo = trace_mem_get_info(oi, false);
153
uint32_t ret;
154
155
- trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
156
+ trace_guest_ld_before_exec(env_cpu(env), ptr, oi);
157
ret = lduw_be_p(g2h(env_cpu(env), ptr));
158
qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_R);
159
return ret;
160
@@ -XXX,XX +XXX,XX @@ int cpu_ldsw_be_data(CPUArchState *env, abi_ptr ptr)
161
uint32_t cpu_ldl_be_data(CPUArchState *env, abi_ptr ptr)
162
{
163
MemOpIdx oi = make_memop_idx(MO_BEUL, MMU_USER_IDX);
164
- uint16_t meminfo = trace_mem_get_info(oi, false);
165
uint32_t ret;
166
167
- trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
168
+ trace_guest_ld_before_exec(env_cpu(env), ptr, oi);
169
ret = ldl_be_p(g2h(env_cpu(env), ptr));
170
qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_R);
171
return ret;
172
@@ -XXX,XX +XXX,XX @@ uint32_t cpu_ldl_be_data(CPUArchState *env, abi_ptr ptr)
173
uint64_t cpu_ldq_be_data(CPUArchState *env, abi_ptr ptr)
174
{
175
MemOpIdx oi = make_memop_idx(MO_BEQ, MMU_USER_IDX);
176
- uint16_t meminfo = trace_mem_get_info(oi, false);
177
uint64_t ret;
178
179
- trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
180
+ trace_guest_ld_before_exec(env_cpu(env), ptr, oi);
181
ret = ldq_be_p(g2h(env_cpu(env), ptr));
182
qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_R);
183
return ret;
184
@@ -XXX,XX +XXX,XX @@ uint64_t cpu_ldq_be_data(CPUArchState *env, abi_ptr ptr)
185
uint32_t cpu_lduw_le_data(CPUArchState *env, abi_ptr ptr)
186
{
187
MemOpIdx oi = make_memop_idx(MO_LEUW, MMU_USER_IDX);
188
- uint16_t meminfo = trace_mem_get_info(oi, false);
189
uint32_t ret;
190
191
- trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
192
+ trace_guest_ld_before_exec(env_cpu(env), ptr, oi);
193
ret = lduw_le_p(g2h(env_cpu(env), ptr));
194
qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_R);
195
return ret;
196
@@ -XXX,XX +XXX,XX @@ int cpu_ldsw_le_data(CPUArchState *env, abi_ptr ptr)
197
uint32_t cpu_ldl_le_data(CPUArchState *env, abi_ptr ptr)
198
{
199
MemOpIdx oi = make_memop_idx(MO_LEUL, MMU_USER_IDX);
200
- uint16_t meminfo = trace_mem_get_info(oi, false);
201
uint32_t ret;
202
203
- trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
204
+ trace_guest_ld_before_exec(env_cpu(env), ptr, oi);
205
ret = ldl_le_p(g2h(env_cpu(env), ptr));
206
qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_R);
207
return ret;
208
@@ -XXX,XX +XXX,XX @@ uint32_t cpu_ldl_le_data(CPUArchState *env, abi_ptr ptr)
209
uint64_t cpu_ldq_le_data(CPUArchState *env, abi_ptr ptr)
210
{
211
MemOpIdx oi = make_memop_idx(MO_LEQ, MMU_USER_IDX);
212
- uint16_t meminfo = trace_mem_get_info(oi, false);
213
uint64_t ret;
214
215
- trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
216
+ trace_guest_ld_before_exec(env_cpu(env), ptr, oi);
217
ret = ldq_le_p(g2h(env_cpu(env), ptr));
218
qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_R);
219
return ret;
220
@@ -XXX,XX +XXX,XX @@ uint64_t cpu_ldq_le_data_ra(CPUArchState *env, abi_ptr ptr, uintptr_t retaddr)
221
void cpu_stb_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
222
{
223
MemOpIdx oi = make_memop_idx(MO_UB, MMU_USER_IDX);
224
- uint16_t meminfo = trace_mem_get_info(oi, true);
225
226
- trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
227
+ trace_guest_st_before_exec(env_cpu(env), ptr, oi);
228
stb_p(g2h(env_cpu(env), ptr), val);
229
qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_W);
230
}
231
@@ -XXX,XX +XXX,XX @@ void cpu_stb_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
232
void cpu_stw_be_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
233
{
234
MemOpIdx oi = make_memop_idx(MO_BEUW, MMU_USER_IDX);
235
- uint16_t meminfo = trace_mem_get_info(oi, true);
236
237
- trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
238
+ trace_guest_st_before_exec(env_cpu(env), ptr, oi);
239
stw_be_p(g2h(env_cpu(env), ptr), val);
240
qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_W);
241
}
242
@@ -XXX,XX +XXX,XX @@ void cpu_stw_be_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
243
void cpu_stl_be_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
244
{
245
MemOpIdx oi = make_memop_idx(MO_BEUL, MMU_USER_IDX);
246
- uint16_t meminfo = trace_mem_get_info(oi, true);
247
248
- trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
249
+ trace_guest_st_before_exec(env_cpu(env), ptr, oi);
250
stl_be_p(g2h(env_cpu(env), ptr), val);
251
qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_W);
252
}
253
@@ -XXX,XX +XXX,XX @@ void cpu_stl_be_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
254
void cpu_stq_be_data(CPUArchState *env, abi_ptr ptr, uint64_t val)
255
{
256
MemOpIdx oi = make_memop_idx(MO_BEQ, MMU_USER_IDX);
257
- uint16_t meminfo = trace_mem_get_info(oi, true);
258
259
- trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
260
+ trace_guest_st_before_exec(env_cpu(env), ptr, oi);
261
stq_be_p(g2h(env_cpu(env), ptr), val);
262
qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_W);
263
}
264
@@ -XXX,XX +XXX,XX @@ void cpu_stq_be_data(CPUArchState *env, abi_ptr ptr, uint64_t val)
265
void cpu_stw_le_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
266
{
267
MemOpIdx oi = make_memop_idx(MO_LEUW, MMU_USER_IDX);
268
- uint16_t meminfo = trace_mem_get_info(oi, true);
269
270
- trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
271
+ trace_guest_st_before_exec(env_cpu(env), ptr, oi);
272
stw_le_p(g2h(env_cpu(env), ptr), val);
273
qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_W);
274
}
275
@@ -XXX,XX +XXX,XX @@ void cpu_stw_le_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
276
void cpu_stl_le_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
277
{
278
MemOpIdx oi = make_memop_idx(MO_LEUL, MMU_USER_IDX);
279
- uint16_t meminfo = trace_mem_get_info(oi, true);
280
281
- trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
282
+ trace_guest_st_before_exec(env_cpu(env), ptr, oi);
283
stl_le_p(g2h(env_cpu(env), ptr), val);
284
qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_W);
285
}
286
@@ -XXX,XX +XXX,XX @@ void cpu_stl_le_data(CPUArchState *env, abi_ptr ptr, uint32_t val)
287
void cpu_stq_le_data(CPUArchState *env, abi_ptr ptr, uint64_t val)
288
{
289
MemOpIdx oi = make_memop_idx(MO_LEQ, MMU_USER_IDX);
290
- uint16_t meminfo = trace_mem_get_info(oi, true);
291
292
- trace_guest_mem_before_exec(env_cpu(env), ptr, meminfo);
293
+ trace_guest_st_before_exec(env_cpu(env), ptr, oi);
294
stq_le_p(g2h(env_cpu(env), ptr), val);
295
qemu_plugin_vcpu_mem_cb(env_cpu(env), ptr, oi, QEMU_PLUGIN_MEM_W);
296
}
297
diff --git a/tcg/tcg-op.c b/tcg/tcg-op.c
298
index XXXXXXX..XXXXXXX 100644
299
--- a/tcg/tcg-op.c
300
+++ b/tcg/tcg-op.c
118
@@ -XXX,XX +XXX,XX @@
301
@@ -XXX,XX +XXX,XX @@
119
* current CPUState for a given thread.
302
#include "tcg/tcg-op.h"
120
*/
303
#include "tcg/tcg-mo.h"
121
304
#include "trace-tcg.h"
122
-void *tcg_cpu_thread_fn(void *arg)
305
-#include "trace/mem.h"
123
+static void *tcg_cpu_thread_fn(void *arg)
306
#include "exec/plugin-gen.h"
124
{
307
125
CPUState *cpu = arg;
308
/* Reduce the number of ifdefs below. This assumes that all uses of
126
309
@@ -XXX,XX +XXX,XX @@ void tcg_gen_qemu_ld_i32(TCGv_i32 val, TCGv addr, TCGArg idx, MemOp memop)
127
@@ -XXX,XX +XXX,XX @@ static void mttcg_kick_vcpu_thread(CPUState *cpu)
310
{
128
cpu_exit(cpu);
311
MemOp orig_memop;
129
}
312
MemOpIdx oi;
130
313
- uint16_t info;
131
+static void mttcg_start_vcpu_thread(CPUState *cpu)
314
132
+{
315
tcg_gen_req_mo(TCG_MO_LD_LD | TCG_MO_ST_LD);
133
+ char thread_name[VCPU_THREAD_NAME_SIZE];
316
memop = tcg_canonicalize_memop(memop, 0, 0);
134
+
317
oi = make_memop_idx(memop, idx);
135
+ g_assert(tcg_enabled());
318
- info = trace_mem_get_info(oi, 0);
136
+
319
- trace_guest_mem_before_tcg(tcg_ctx->cpu, cpu_env, addr, info);
137
+ parallel_cpus = (current_machine->smp.max_cpus > 1);
320
+ trace_guest_ld_before_tcg(tcg_ctx->cpu, cpu_env, addr, oi);
138
+
321
139
+ cpu->thread = g_malloc0(sizeof(QemuThread));
322
orig_memop = memop;
140
+ cpu->halt_cond = g_malloc0(sizeof(QemuCond));
323
if (!TCG_TARGET_HAS_MEMORY_BSWAP && (memop & MO_BSWAP)) {
141
+ qemu_cond_init(cpu->halt_cond);
324
@@ -XXX,XX +XXX,XX @@ void tcg_gen_qemu_st_i32(TCGv_i32 val, TCGv addr, TCGArg idx, MemOp memop)
142
+
325
{
143
+ /* create a thread per vCPU with TCG (MTTCG) */
326
TCGv_i32 swap = NULL;
144
+ snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/TCG",
327
MemOpIdx oi;
145
+ cpu->cpu_index);
328
- uint16_t info;
146
+
329
147
+ qemu_thread_create(cpu->thread, thread_name, tcg_cpu_thread_fn,
330
tcg_gen_req_mo(TCG_MO_LD_ST | TCG_MO_ST_ST);
148
+ cpu, QEMU_THREAD_JOINABLE);
331
memop = tcg_canonicalize_memop(memop, 0, 1);
149
+
332
oi = make_memop_idx(memop, idx);
150
+#ifdef _WIN32
333
- info = trace_mem_get_info(oi, 1);
151
+ cpu->hThread = qemu_thread_get_handle(cpu->thread);
334
- trace_guest_mem_before_tcg(tcg_ctx->cpu, cpu_env, addr, info);
152
+#endif
335
+ trace_guest_st_before_tcg(tcg_ctx->cpu, cpu_env, addr, oi);
153
+}
336
154
+
337
if (!TCG_TARGET_HAS_MEMORY_BSWAP && (memop & MO_BSWAP)) {
155
const CpusAccel tcg_cpus_mttcg = {
338
swap = tcg_temp_new_i32();
156
- .create_vcpu_thread = tcg_start_vcpu_thread,
339
@@ -XXX,XX +XXX,XX @@ void tcg_gen_qemu_ld_i64(TCGv_i64 val, TCGv addr, TCGArg idx, MemOp memop)
157
+ .create_vcpu_thread = mttcg_start_vcpu_thread,
340
{
158
.kick_vcpu_thread = mttcg_kick_vcpu_thread,
341
MemOp orig_memop;
159
342
MemOpIdx oi;
160
.handle_interrupt = tcg_handle_interrupt,
343
- uint16_t info;
161
diff --git a/accel/tcg/tcg-cpus-rr.c b/accel/tcg/tcg-cpus-rr.c
344
162
index XXXXXXX..XXXXXXX 100644
345
if (TCG_TARGET_REG_BITS == 32 && (memop & MO_SIZE) < MO_64) {
163
--- a/accel/tcg/tcg-cpus-rr.c
346
tcg_gen_qemu_ld_i32(TCGV_LOW(val), addr, idx, memop);
164
+++ b/accel/tcg/tcg-cpus-rr.c
347
@@ -XXX,XX +XXX,XX @@ void tcg_gen_qemu_ld_i64(TCGv_i64 val, TCGv addr, TCGArg idx, MemOp memop)
165
@@ -XXX,XX +XXX,XX @@ static void deal_with_unplugged_cpus(void)
348
tcg_gen_req_mo(TCG_MO_LD_LD | TCG_MO_ST_LD);
166
* elsewhere.
349
memop = tcg_canonicalize_memop(memop, 1, 0);
167
*/
350
oi = make_memop_idx(memop, idx);
168
351
- info = trace_mem_get_info(oi, 0);
169
-void *tcg_rr_cpu_thread_fn(void *arg)
352
- trace_guest_mem_before_tcg(tcg_ctx->cpu, cpu_env, addr, info);
170
+static void *tcg_rr_cpu_thread_fn(void *arg)
353
+ trace_guest_ld_before_tcg(tcg_ctx->cpu, cpu_env, addr, oi);
171
{
354
172
CPUState *cpu = arg;
355
orig_memop = memop;
173
356
if (!TCG_TARGET_HAS_MEMORY_BSWAP && (memop & MO_BSWAP)) {
174
@@ -XXX,XX +XXX,XX @@ void *tcg_rr_cpu_thread_fn(void *arg)
357
@@ -XXX,XX +XXX,XX @@ void tcg_gen_qemu_st_i64(TCGv_i64 val, TCGv addr, TCGArg idx, MemOp memop)
175
return NULL;
358
{
176
}
359
TCGv_i64 swap = NULL;
177
360
MemOpIdx oi;
178
+void rr_start_vcpu_thread(CPUState *cpu)
361
- uint16_t info;
179
+{
362
180
+ char thread_name[VCPU_THREAD_NAME_SIZE];
363
if (TCG_TARGET_REG_BITS == 32 && (memop & MO_SIZE) < MO_64) {
181
+ static QemuCond *single_tcg_halt_cond;
364
tcg_gen_qemu_st_i32(TCGV_LOW(val), addr, idx, memop);
182
+ static QemuThread *single_tcg_cpu_thread;
365
@@ -XXX,XX +XXX,XX @@ void tcg_gen_qemu_st_i64(TCGv_i64 val, TCGv addr, TCGArg idx, MemOp memop)
183
+
366
tcg_gen_req_mo(TCG_MO_LD_ST | TCG_MO_ST_ST);
184
+ g_assert(tcg_enabled());
367
memop = tcg_canonicalize_memop(memop, 1, 1);
185
+ parallel_cpus = false;
368
oi = make_memop_idx(memop, idx);
186
+
369
- info = trace_mem_get_info(oi, 1);
187
+ if (!single_tcg_cpu_thread) {
370
- trace_guest_mem_before_tcg(tcg_ctx->cpu, cpu_env, addr, info);
188
+ cpu->thread = g_malloc0(sizeof(QemuThread));
371
+ trace_guest_st_before_tcg(tcg_ctx->cpu, cpu_env, addr, oi);
189
+ cpu->halt_cond = g_malloc0(sizeof(QemuCond));
372
190
+ qemu_cond_init(cpu->halt_cond);
373
if (!TCG_TARGET_HAS_MEMORY_BSWAP && (memop & MO_BSWAP)) {
191
+
374
swap = tcg_temp_new_i64();
192
+ /* share a single thread for all cpus with TCG */
375
diff --git a/accel/tcg/atomic_common.c.inc b/accel/tcg/atomic_common.c.inc
193
+ snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "ALL CPUs/TCG");
376
index XXXXXXX..XXXXXXX 100644
194
+ qemu_thread_create(cpu->thread, thread_name,
377
--- a/accel/tcg/atomic_common.c.inc
195
+ tcg_rr_cpu_thread_fn,
378
+++ b/accel/tcg/atomic_common.c.inc
196
+ cpu, QEMU_THREAD_JOINABLE);
379
@@ -XXX,XX +XXX,XX @@ static void atomic_trace_rmw_pre(CPUArchState *env, target_ulong addr,
197
+
380
MemOpIdx oi)
198
+ single_tcg_halt_cond = cpu->halt_cond;
381
{
199
+ single_tcg_cpu_thread = cpu->thread;
382
CPUState *cpu = env_cpu(env);
200
+#ifdef _WIN32
383
- uint16_t info = trace_mem_get_info(oi, false);
201
+ cpu->hThread = qemu_thread_get_handle(cpu->thread);
384
202
+#endif
385
- trace_guest_mem_before_exec(cpu, addr, info);
203
+ } else {
386
- trace_guest_mem_before_exec(cpu, addr, info | TRACE_MEM_ST);
204
+ /* we share the thread */
387
+ trace_guest_rmw_before_exec(cpu, addr, oi);
205
+ cpu->thread = single_tcg_cpu_thread;
388
}
206
+ cpu->halt_cond = single_tcg_halt_cond;
389
207
+ cpu->thread_id = first_cpu->thread_id;
390
static void atomic_trace_rmw_post(CPUArchState *env, target_ulong addr,
208
+ cpu->can_do_io = 1;
391
@@ -XXX,XX +XXX,XX @@ static void atomic_trace_rmw_post(CPUArchState *env, target_ulong addr,
209
+ cpu->created = true;
392
static void atomic_trace_ld_pre(CPUArchState *env, target_ulong addr,
210
+ }
393
MemOpIdx oi)
211
+}
394
{
212
+
395
- uint16_t info = trace_mem_get_info(oi, false);
213
const CpusAccel tcg_cpus_rr = {
396
-
214
- .create_vcpu_thread = tcg_start_vcpu_thread,
397
- trace_guest_mem_before_exec(env_cpu(env), addr, info);
215
+ .create_vcpu_thread = rr_start_vcpu_thread,
398
+ trace_guest_ld_before_exec(env_cpu(env), addr, oi);
216
.kick_vcpu_thread = qemu_cpu_kick_rr_cpus,
399
}
217
400
218
.handle_interrupt = tcg_handle_interrupt,
401
static void atomic_trace_ld_post(CPUArchState *env, target_ulong addr,
219
diff --git a/accel/tcg/tcg-cpus.c b/accel/tcg/tcg-cpus.c
402
@@ -XXX,XX +XXX,XX @@ static void atomic_trace_ld_post(CPUArchState *env, target_ulong addr,
220
index XXXXXXX..XXXXXXX 100644
403
static void atomic_trace_st_pre(CPUArchState *env, target_ulong addr,
221
--- a/accel/tcg/tcg-cpus.c
404
MemOpIdx oi)
222
+++ b/accel/tcg/tcg-cpus.c
405
{
223
@@ -XXX,XX +XXX,XX @@
406
- uint16_t info = trace_mem_get_info(oi, true);
224
#include "hw/boards.h"
407
-
225
408
- trace_guest_mem_before_exec(env_cpu(env), addr, info);
226
#include "tcg-cpus.h"
409
+ trace_guest_st_before_exec(env_cpu(env), addr, oi);
227
-#include "tcg-cpus-mttcg.h"
410
}
228
-#include "tcg-cpus-rr.h"
411
229
412
static void atomic_trace_st_post(CPUArchState *env, target_ulong addr,
230
/* common functionality among all TCG variants */
413
diff --git a/trace-events b/trace-events
231
414
index XXXXXXX..XXXXXXX 100644
232
-void tcg_start_vcpu_thread(CPUState *cpu)
415
--- a/trace-events
233
-{
416
+++ b/trace-events
234
- char thread_name[VCPU_THREAD_NAME_SIZE];
417
@@ -XXX,XX +XXX,XX @@ vcpu guest_cpu_reset(void)
235
- static QemuCond *single_tcg_halt_cond;
418
# tcg/tcg-op.c
236
- static QemuThread *single_tcg_cpu_thread;
419
237
- static int tcg_region_inited;
420
# @vaddr: Access' virtual address.
238
-
421
-# @info : Access' information (see below).
239
- assert(tcg_enabled());
422
+# @memopidx: Access' information (see below).
240
- /*
423
#
241
- * Initialize TCG regions--once. Now is a good time, because:
424
# Start virtual memory access (before any potential access violation).
242
- * (1) TCG's init context, prologue and target globals have been set up.
425
-#
243
- * (2) qemu_tcg_mttcg_enabled() works now (TCG init code runs before the
426
# Does not include memory accesses performed by devices.
244
- * -accel flag is processed, so the check doesn't work then).
427
#
245
- */
428
-# Access information can be parsed as:
246
- if (!tcg_region_inited) {
429
-#
247
- tcg_region_inited = 1;
430
-# struct mem_info {
248
- tcg_region_init();
431
-# uint8_t size_shift : 4; /* interpreted as "1 << size_shift" bytes */
249
- parallel_cpus = qemu_tcg_mttcg_enabled() && current_machine->smp.max_cpus > 1;
432
-# bool sign_extend: 1; /* sign-extended */
250
- }
433
-# uint8_t endianness : 1; /* 0: little, 1: big */
251
-
434
-# bool store : 1; /* whether it is a store operation */
252
- if (qemu_tcg_mttcg_enabled() || !single_tcg_cpu_thread) {
435
-# pad : 1;
253
- cpu->thread = g_malloc0(sizeof(QemuThread));
436
-# uint8_t mmuidx : 4; /* mmuidx (softmmu only) */
254
- cpu->halt_cond = g_malloc0(sizeof(QemuCond));
437
-# };
255
- qemu_cond_init(cpu->halt_cond);
438
-#
256
-
439
# Mode: user, softmmu
257
- if (qemu_tcg_mttcg_enabled()) {
440
# Targets: TCG(all)
258
- /* create a thread per vCPU with TCG (MTTCG) */
441
-vcpu tcg guest_mem_before(TCGv vaddr, uint16_t info) "info=%d", "vaddr=0x%016"PRIx64" info=%d"
259
- snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/TCG",
442
+vcpu tcg guest_ld_before(TCGv vaddr, uint32_t memopidx) "info=%d", "vaddr=0x%016"PRIx64" memopidx=0x%x"
260
- cpu->cpu_index);
443
+vcpu tcg guest_st_before(TCGv vaddr, uint32_t memopidx) "info=%d", "vaddr=0x%016"PRIx64" memopidx=0x%x"
261
-
444
+vcpu tcg guest_rmw_before(TCGv vaddr, uint32_t memopidx) "info=%d", "vaddr=0x%016"PRIx64" memopidx=0x%x"
262
- qemu_thread_create(cpu->thread, thread_name, tcg_cpu_thread_fn,
445
263
- cpu, QEMU_THREAD_JOINABLE);
446
# include/user/syscall-trace.h
264
-
447
265
- } else {
266
- /* share a single thread for all cpus with TCG */
267
- snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "ALL CPUs/TCG");
268
- qemu_thread_create(cpu->thread, thread_name,
269
- tcg_rr_cpu_thread_fn,
270
- cpu, QEMU_THREAD_JOINABLE);
271
-
272
- single_tcg_halt_cond = cpu->halt_cond;
273
- single_tcg_cpu_thread = cpu->thread;
274
- }
275
-#ifdef _WIN32
276
- cpu->hThread = qemu_thread_get_handle(cpu->thread);
277
-#endif
278
- } else {
279
- /* For non-MTTCG cases we share the thread */
280
- cpu->thread = single_tcg_cpu_thread;
281
- cpu->halt_cond = single_tcg_halt_cond;
282
- cpu->thread_id = first_cpu->thread_id;
283
- cpu->can_do_io = 1;
284
- cpu->created = true;
285
- }
286
-}
287
-
288
void qemu_tcg_destroy_vcpu(CPUState *cpu)
289
{
290
cpu_thread_signal_destroyed(cpu);
291
--
448
--
292
2.25.1
449
2.25.1
293
450
294
451
diff view generated by jsdifflib
New patch
[PULL 12/28] hw/core/cpu: Re-sort the non-pointers to the end of CPUClass
1
Despite the comment, the members were not kept at the end.
1
2
3
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
4
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
5
---
6
include/hw/core/cpu.h | 11 +++++++----
7
1 file changed, 7 insertions(+), 4 deletions(-)
8
9
diff --git a/include/hw/core/cpu.h b/include/hw/core/cpu.h
10
index XXXXXXX..XXXXXXX 100644
11
--- a/include/hw/core/cpu.h
12
+++ b/include/hw/core/cpu.h
13
@@ -XXX,XX +XXX,XX @@ struct CPUClass {
14
ObjectClass *(*class_by_name)(const char *cpu_model);
15
void (*parse_features)(const char *typename, char *str, Error **errp);
16
17
- int reset_dump_flags;
18
bool (*has_work)(CPUState *cpu);
19
int (*memory_rw_debug)(CPUState *cpu, vaddr addr,
20
uint8_t *buf, int len, bool is_write);
21
@@ -XXX,XX +XXX,XX @@ struct CPUClass {
22
void (*disas_set_info)(CPUState *cpu, disassemble_info *info);
23
24
const char *deprecation_note;
25
- /* Keep non-pointer data at the end to minimize holes. */
26
- int gdb_num_core_regs;
27
- bool gdb_stop_before_watchpoint;
28
struct AccelCPUClass *accel_cpu;
29
30
/* when system emulation is not available, this pointer is NULL */
31
@@ -XXX,XX +XXX,XX @@ struct CPUClass {
32
* class data that depends on the accelerator, see accel/accel-common.c.
33
*/
34
void (*init_accel_cpu)(struct AccelCPUClass *accel_cpu, CPUClass *cc);
35
+
36
+ /*
37
+ * Keep non-pointer data at the end to minimize holes.
38
+ */
39
+ int reset_dump_flags;
40
+ int gdb_num_core_regs;
41
+ bool gdb_stop_before_watchpoint;
42
};
43
44
/*
45
--
46
2.25.1
47
48
diff view generated by jsdifflib
New patch
[PULL 13/28] tcg: Expand usadd/ussub with umin/umax
1
For usadd, we only have to consider overflow. Since ~B + B == -1,
2
the maximum value for A that saturates is ~B.
1
3
4
For ussub, we only have to consider underflow. The minimum value
5
that saturates to 0 from A - B is B.
6
7
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
8
---
9
tcg/tcg-op-vec.c | 37 +++++++++++++++++++++++++++++++++++--
10
1 file changed, 35 insertions(+), 2 deletions(-)
11
12
diff --git a/tcg/tcg-op-vec.c b/tcg/tcg-op-vec.c
13
index XXXXXXX..XXXXXXX 100644
14
--- a/tcg/tcg-op-vec.c
15
+++ b/tcg/tcg-op-vec.c
16
@@ -XXX,XX +XXX,XX @@ bool tcg_can_emit_vecop_list(const TCGOpcode *list,
17
continue;
18
}
19
break;
20
+ case INDEX_op_usadd_vec:
21
+ if (tcg_can_emit_vec_op(INDEX_op_umin_vec, type, vece) ||
22
+ tcg_can_emit_vec_op(INDEX_op_cmp_vec, type, vece)) {
23
+ continue;
24
+ }
25
+ break;
26
+ case INDEX_op_ussub_vec:
27
+ if (tcg_can_emit_vec_op(INDEX_op_umax_vec, type, vece) ||
28
+ tcg_can_emit_vec_op(INDEX_op_cmp_vec, type, vece)) {
29
+ continue;
30
+ }
31
+ break;
32
case INDEX_op_cmpsel_vec:
33
case INDEX_op_smin_vec:
34
case INDEX_op_smax_vec:
35
@@ -XXX,XX +XXX,XX @@ void tcg_gen_ssadd_vec(unsigned vece, TCGv_vec r, TCGv_vec a, TCGv_vec b)
36
37
void tcg_gen_usadd_vec(unsigned vece, TCGv_vec r, TCGv_vec a, TCGv_vec b)
38
{
39
- do_op3_nofail(vece, r, a, b, INDEX_op_usadd_vec);
40
+ if (!do_op3(vece, r, a, b, INDEX_op_usadd_vec)) {
41
+ const TCGOpcode *hold_list = tcg_swap_vecop_list(NULL);
42
+ TCGv_vec t = tcg_temp_new_vec_matching(r);
43
+
44
+ /* usadd(a, b) = min(a, ~b) + b */
45
+ tcg_gen_not_vec(vece, t, b);
46
+ tcg_gen_umin_vec(vece, t, t, a);
47
+ tcg_gen_add_vec(vece, r, t, b);
48
+
49
+ tcg_temp_free_vec(t);
50
+ tcg_swap_vecop_list(hold_list);
51
+ }
52
}
53
54
void tcg_gen_sssub_vec(unsigned vece, TCGv_vec r, TCGv_vec a, TCGv_vec b)
55
@@ -XXX,XX +XXX,XX @@ void tcg_gen_sssub_vec(unsigned vece, TCGv_vec r, TCGv_vec a, TCGv_vec b)
56
57
void tcg_gen_ussub_vec(unsigned vece, TCGv_vec r, TCGv_vec a, TCGv_vec b)
58
{
59
- do_op3_nofail(vece, r, a, b, INDEX_op_ussub_vec);
60
+ if (!do_op3(vece, r, a, b, INDEX_op_ussub_vec)) {
61
+ const TCGOpcode *hold_list = tcg_swap_vecop_list(NULL);
62
+ TCGv_vec t = tcg_temp_new_vec_matching(r);
63
+
64
+ /* ussub(a, b) = max(a, b) - b */
65
+ tcg_gen_umax_vec(vece, t, a, b);
66
+ tcg_gen_sub_vec(vece, r, t, b);
67
+
68
+ tcg_temp_free_vec(t);
69
+ tcg_swap_vecop_list(hold_list);
70
+ }
71
}
72
73
static void do_minmax(unsigned vece, TCGv_vec r, TCGv_vec a,
74
--
75
2.25.1
76
77
diff view generated by jsdifflib
New patch
[PULL 14/28] tcg/s390x: Rename from tcg/s390
1
This emphasizes that we don't support s390, only 64-bit s390x hosts.
1
2
3
Reviewed-by: Thomas Huth <thuth@redhat.com>
4
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
5
Reviewed-by: David Hildenbrand <david@redhat.com>
6
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
7
---
8
meson.build | 2 --
9
tcg/{s390 => s390x}/tcg-target-con-set.h | 0
10
tcg/{s390 => s390x}/tcg-target-con-str.h | 0
11
tcg/{s390 => s390x}/tcg-target.h | 0
12
tcg/{s390 => s390x}/tcg-target.c.inc | 0
13
5 files changed, 2 deletions(-)
14
rename tcg/{s390 => s390x}/tcg-target-con-set.h (100%)
15
rename tcg/{s390 => s390x}/tcg-target-con-str.h (100%)
16
rename tcg/{s390 => s390x}/tcg-target.h (100%)
17
rename tcg/{s390 => s390x}/tcg-target.c.inc (100%)
18
19
diff --git a/meson.build b/meson.build
20
index XXXXXXX..XXXXXXX 100644
21
--- a/meson.build
22
+++ b/meson.build
23
@@ -XXX,XX +XXX,XX @@ if not get_option('tcg').disabled()
24
tcg_arch = 'tci'
25
elif config_host['ARCH'] == 'sparc64'
26
tcg_arch = 'sparc'
27
- elif config_host['ARCH'] == 's390x'
28
- tcg_arch = 's390'
29
elif config_host['ARCH'] in ['x86_64', 'x32']
30
tcg_arch = 'i386'
31
elif config_host['ARCH'] == 'ppc64'
32
diff --git a/tcg/s390/tcg-target-con-set.h b/tcg/s390x/tcg-target-con-set.h
33
similarity index 100%
34
rename from tcg/s390/tcg-target-con-set.h
35
rename to tcg/s390x/tcg-target-con-set.h
36
diff --git a/tcg/s390/tcg-target-con-str.h b/tcg/s390x/tcg-target-con-str.h
37
similarity index 100%
38
rename from tcg/s390/tcg-target-con-str.h
39
rename to tcg/s390x/tcg-target-con-str.h
40
diff --git a/tcg/s390/tcg-target.h b/tcg/s390x/tcg-target.h
41
similarity index 100%
42
rename from tcg/s390/tcg-target.h
43
rename to tcg/s390x/tcg-target.h
44
diff --git a/tcg/s390/tcg-target.c.inc b/tcg/s390x/tcg-target.c.inc
45
similarity index 100%
46
rename from tcg/s390/tcg-target.c.inc
47
rename to tcg/s390x/tcg-target.c.inc
48
--
49
2.25.1
50
51
diff view generated by jsdifflib
New patch
[PULL 15/28] tcg/s390x: Change FACILITY representation
1
We will shortly need to be able to check facilities beyond the
2
first 64. Instead of explicitly masking against s390_facilities,
3
create a HAVE_FACILITY macro that indexes an array.
1
4
5
Reviewed-by: David Hildenbrand <david@redhat.com>
6
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
7
---
8
v2: Change name to HAVE_FACILITY (david)
9
---
10
tcg/s390x/tcg-target.h | 29 ++++++++-------
11
tcg/s390x/tcg-target.c.inc | 74 +++++++++++++++++++-------------------
12
2 files changed, 52 insertions(+), 51 deletions(-)
13
14
diff --git a/tcg/s390x/tcg-target.h b/tcg/s390x/tcg-target.h
15
index XXXXXXX..XXXXXXX 100644
16
--- a/tcg/s390x/tcg-target.h
17
+++ b/tcg/s390x/tcg-target.h
18
@@ -XXX,XX +XXX,XX @@ typedef enum TCGReg {
19
/* A list of relevant facilities used by this translator. Some of these
20
are required for proper operation, and these are checked at startup. */
21
22
-#define FACILITY_ZARCH_ACTIVE (1ULL << (63 - 2))
23
-#define FACILITY_LONG_DISP (1ULL << (63 - 18))
24
-#define FACILITY_EXT_IMM (1ULL << (63 - 21))
25
-#define FACILITY_GEN_INST_EXT (1ULL << (63 - 34))
26
-#define FACILITY_LOAD_ON_COND (1ULL << (63 - 45))
27
+#define FACILITY_ZARCH_ACTIVE 2
28
+#define FACILITY_LONG_DISP 18
29
+#define FACILITY_EXT_IMM 21
30
+#define FACILITY_GEN_INST_EXT 34
31
+#define FACILITY_LOAD_ON_COND 45
32
#define FACILITY_FAST_BCR_SER FACILITY_LOAD_ON_COND
33
#define FACILITY_DISTINCT_OPS FACILITY_LOAD_ON_COND
34
-#define FACILITY_LOAD_ON_COND2 (1ULL << (63 - 53))
35
+#define FACILITY_LOAD_ON_COND2 53
36
37
-extern uint64_t s390_facilities;
38
+extern uint64_t s390_facilities[1];
39
+
40
+#define HAVE_FACILITY(X) \
41
+ ((s390_facilities[FACILITY_##X / 64] >> (63 - FACILITY_##X % 64)) & 1)
42
43
/* optional instructions */
44
#define TCG_TARGET_HAS_div2_i32 1
45
@@ -XXX,XX +XXX,XX @@ extern uint64_t s390_facilities;
46
#define TCG_TARGET_HAS_clz_i32 0
47
#define TCG_TARGET_HAS_ctz_i32 0
48
#define TCG_TARGET_HAS_ctpop_i32 0
49
-#define TCG_TARGET_HAS_deposit_i32 (s390_facilities & FACILITY_GEN_INST_EXT)
50
-#define TCG_TARGET_HAS_extract_i32 (s390_facilities & FACILITY_GEN_INST_EXT)
51
+#define TCG_TARGET_HAS_deposit_i32 HAVE_FACILITY(GEN_INST_EXT)
52
+#define TCG_TARGET_HAS_extract_i32 HAVE_FACILITY(GEN_INST_EXT)
53
#define TCG_TARGET_HAS_sextract_i32 0
54
#define TCG_TARGET_HAS_extract2_i32 0
55
#define TCG_TARGET_HAS_movcond_i32 1
56
@@ -XXX,XX +XXX,XX @@ extern uint64_t s390_facilities;
57
#define TCG_TARGET_HAS_mulsh_i32 0
58
#define TCG_TARGET_HAS_extrl_i64_i32 0
59
#define TCG_TARGET_HAS_extrh_i64_i32 0
60
-#define TCG_TARGET_HAS_direct_jump (s390_facilities & FACILITY_GEN_INST_EXT)
61
+#define TCG_TARGET_HAS_direct_jump HAVE_FACILITY(GEN_INST_EXT)
62
#define TCG_TARGET_HAS_qemu_st8_i32 0
63
64
#define TCG_TARGET_HAS_div2_i64 1
65
@@ -XXX,XX +XXX,XX @@ extern uint64_t s390_facilities;
66
#define TCG_TARGET_HAS_eqv_i64 0
67
#define TCG_TARGET_HAS_nand_i64 0
68
#define TCG_TARGET_HAS_nor_i64 0
69
-#define TCG_TARGET_HAS_clz_i64 (s390_facilities & FACILITY_EXT_IMM)
70
+#define TCG_TARGET_HAS_clz_i64 HAVE_FACILITY(EXT_IMM)
71
#define TCG_TARGET_HAS_ctz_i64 0
72
#define TCG_TARGET_HAS_ctpop_i64 0
73
-#define TCG_TARGET_HAS_deposit_i64 (s390_facilities & FACILITY_GEN_INST_EXT)
74
-#define TCG_TARGET_HAS_extract_i64 (s390_facilities & FACILITY_GEN_INST_EXT)
75
+#define TCG_TARGET_HAS_deposit_i64 HAVE_FACILITY(GEN_INST_EXT)
76
+#define TCG_TARGET_HAS_extract_i64 HAVE_FACILITY(GEN_INST_EXT)
77
#define TCG_TARGET_HAS_sextract_i64 0
78
#define TCG_TARGET_HAS_extract2_i64 0
79
#define TCG_TARGET_HAS_movcond_i64 1
80
diff --git a/tcg/s390x/tcg-target.c.inc b/tcg/s390x/tcg-target.c.inc
81
index XXXXXXX..XXXXXXX 100644
82
--- a/tcg/s390x/tcg-target.c.inc
83
+++ b/tcg/s390x/tcg-target.c.inc
84
@@ -XXX,XX +XXX,XX @@
85
We don't need this when we have pc-relative loads with the general
86
instructions extension facility. */
87
#define TCG_REG_TB TCG_REG_R12
88
-#define USE_REG_TB (!(s390_facilities & FACILITY_GEN_INST_EXT))
89
+#define USE_REG_TB (!HAVE_FACILITY(GEN_INST_EXT))
90
91
#ifndef CONFIG_SOFTMMU
92
#define TCG_GUEST_BASE_REG TCG_REG_R13
93
@@ -XXX,XX +XXX,XX @@ static void * const qemu_st_helpers[(MO_SIZE | MO_BSWAP) + 1] = {
94
#endif
95
96
static const tcg_insn_unit *tb_ret_addr;
97
-uint64_t s390_facilities;
98
+uint64_t s390_facilities[1];
99
100
static bool patch_reloc(tcg_insn_unit *src_rw, int type,
101
intptr_t value, intptr_t addend)
102
@@ -XXX,XX +XXX,XX @@ static void tcg_out_movi_int(TCGContext *s, TCGType type, TCGReg ret,
103
}
104
105
/* Try all 48-bit insns that can load it in one go. */
106
- if (s390_facilities & FACILITY_EXT_IMM) {
107
+ if (HAVE_FACILITY(EXT_IMM)) {
108
if (sval == (int32_t)sval) {
109
tcg_out_insn(s, RIL, LGFI, ret, sval);
110
return;
111
@@ -XXX,XX +XXX,XX @@ static void tcg_out_movi_int(TCGContext *s, TCGType type, TCGReg ret,
112
}
113
114
/* Otherwise, stuff it in the constant pool. */
115
- if (s390_facilities & FACILITY_GEN_INST_EXT) {
116
+ if (HAVE_FACILITY(GEN_INST_EXT)) {
117
tcg_out_insn(s, RIL, LGRL, ret, 0);
118
new_pool_label(s, sval, R_390_PC32DBL, s->code_ptr - 2, 2);
119
} else if (USE_REG_TB && !in_prologue) {
120
@@ -XXX,XX +XXX,XX @@ static void tcg_out_ld_abs(TCGContext *s, TCGType type,
121
{
122
intptr_t addr = (intptr_t)abs;
123
124
- if ((s390_facilities & FACILITY_GEN_INST_EXT) && !(addr & 1)) {
125
+ if (HAVE_FACILITY(GEN_INST_EXT) && !(addr & 1)) {
126
ptrdiff_t disp = tcg_pcrel_diff(s, abs) >> 1;
127
if (disp == (int32_t)disp) {
128
if (type == TCG_TYPE_I32) {
129
@@ -XXX,XX +XXX,XX @@ static inline void tcg_out_risbg(TCGContext *s, TCGReg dest, TCGReg src,
130
131
static void tgen_ext8s(TCGContext *s, TCGType type, TCGReg dest, TCGReg src)
132
{
133
- if (s390_facilities & FACILITY_EXT_IMM) {
134
+ if (HAVE_FACILITY(EXT_IMM)) {
135
tcg_out_insn(s, RRE, LGBR, dest, src);
136
return;
137
}
138
@@ -XXX,XX +XXX,XX @@ static void tgen_ext8s(TCGContext *s, TCGType type, TCGReg dest, TCGReg src)
139
140
static void tgen_ext8u(TCGContext *s, TCGType type, TCGReg dest, TCGReg src)
141
{
142
- if (s390_facilities & FACILITY_EXT_IMM) {
143
+ if (HAVE_FACILITY(EXT_IMM)) {
144
tcg_out_insn(s, RRE, LLGCR, dest, src);
145
return;
146
}
147
@@ -XXX,XX +XXX,XX @@ static void tgen_ext8u(TCGContext *s, TCGType type, TCGReg dest, TCGReg src)
148
149
static void tgen_ext16s(TCGContext *s, TCGType type, TCGReg dest, TCGReg src)
150
{
151
- if (s390_facilities & FACILITY_EXT_IMM) {
152
+ if (HAVE_FACILITY(EXT_IMM)) {
153
tcg_out_insn(s, RRE, LGHR, dest, src);
154
return;
155
}
156
@@ -XXX,XX +XXX,XX @@ static void tgen_ext16s(TCGContext *s, TCGType type, TCGReg dest, TCGReg src)
157
158
static void tgen_ext16u(TCGContext *s, TCGType type, TCGReg dest, TCGReg src)
159
{
160
- if (s390_facilities & FACILITY_EXT_IMM) {
161
+ if (HAVE_FACILITY(EXT_IMM)) {
162
tcg_out_insn(s, RRE, LLGHR, dest, src);
163
return;
164
}
165
@@ -XXX,XX +XXX,XX @@ static void tgen_andi(TCGContext *s, TCGType type, TCGReg dest, uint64_t val)
166
tgen_ext32u(s, dest, dest);
167
return;
168
}
169
- if (s390_facilities & FACILITY_EXT_IMM) {
170
+ if (HAVE_FACILITY(EXT_IMM)) {
171
if ((val & valid) == 0xff) {
172
tgen_ext8u(s, TCG_TYPE_I64, dest, dest);
173
return;
174
@@ -XXX,XX +XXX,XX @@ static void tgen_andi(TCGContext *s, TCGType type, TCGReg dest, uint64_t val)
175
}
176
177
/* Try all 48-bit insns that can perform it in one go. */
178
- if (s390_facilities & FACILITY_EXT_IMM) {
179
+ if (HAVE_FACILITY(EXT_IMM)) {
180
for (i = 0; i < 2; i++) {
181
tcg_target_ulong mask = ~(0xffffffffull << i*32);
182
if (((val | ~valid) & mask) == mask) {
183
@@ -XXX,XX +XXX,XX @@ static void tgen_andi(TCGContext *s, TCGType type, TCGReg dest, uint64_t val)
184
}
185
}
186
}
187
- if ((s390_facilities & FACILITY_GEN_INST_EXT) && risbg_mask(val)) {
188
+ if (HAVE_FACILITY(GEN_INST_EXT) && risbg_mask(val)) {
189
tgen_andi_risbg(s, dest, dest, val);
190
return;
191
}
192
@@ -XXX,XX +XXX,XX @@ static void tgen_ori(TCGContext *s, TCGType type, TCGReg dest, uint64_t val)
193
}
194
195
/* Try all 48-bit insns that can perform it in one go. */
196
- if (s390_facilities & FACILITY_EXT_IMM) {
197
+ if (HAVE_FACILITY(EXT_IMM)) {
198
for (i = 0; i < 2; i++) {
199
tcg_target_ulong mask = (0xffffffffull << i*32);
200
if ((val & mask) != 0 && (val & ~mask) == 0) {
201
@@ -XXX,XX +XXX,XX @@ static void tgen_ori(TCGContext *s, TCGType type, TCGReg dest, uint64_t val)
202
/* Perform the OR via sequential modifications to the high and
203
low parts. Do this via recursion to handle 16-bit vs 32-bit
204
masks in each half. */
205
- tcg_debug_assert(s390_facilities & FACILITY_EXT_IMM);
206
+ tcg_debug_assert(HAVE_FACILITY(EXT_IMM));
207
tgen_ori(s, type, dest, val & 0x00000000ffffffffull);
208
tgen_ori(s, type, dest, val & 0xffffffff00000000ull);
209
}
210
@@ -XXX,XX +XXX,XX @@ static void tgen_ori(TCGContext *s, TCGType type, TCGReg dest, uint64_t val)
211
static void tgen_xori(TCGContext *s, TCGType type, TCGReg dest, uint64_t val)
212
{
213
/* Try all 48-bit insns that can perform it in one go. */
214
- if (s390_facilities & FACILITY_EXT_IMM) {
215
+ if (HAVE_FACILITY(EXT_IMM)) {
216
if ((val & 0xffffffff00000000ull) == 0) {
217
tcg_out_insn(s, RIL, XILF, dest, val);
218
return;
219
@@ -XXX,XX +XXX,XX @@ static void tgen_xori(TCGContext *s, TCGType type, TCGReg dest, uint64_t val)
220
tcg_tbrel_diff(s, NULL));
221
} else {
222
/* Perform the xor by parts. */
223
- tcg_debug_assert(s390_facilities & FACILITY_EXT_IMM);
224
+ tcg_debug_assert(HAVE_FACILITY(EXT_IMM));
225
if (val & 0xffffffff) {
226
tcg_out_insn(s, RIL, XILF, dest, val);
227
}
228
@@ -XXX,XX +XXX,XX @@ static int tgen_cmp(TCGContext *s, TCGType type, TCGCond c, TCGReg r1,
229
goto exit;
230
}
231
232
- if (s390_facilities & FACILITY_EXT_IMM) {
233
+ if (HAVE_FACILITY(EXT_IMM)) {
234
if (type == TCG_TYPE_I32) {
235
op = (is_unsigned ? RIL_CLFI : RIL_CFI);
236
tcg_out_insn_RIL(s, op, r1, c2);
237
@@ -XXX,XX +XXX,XX @@ static void tgen_setcond(TCGContext *s, TCGType type, TCGCond cond,
238
bool have_loc;
239
240
/* With LOC2, we can always emit the minimum 3 insns. */
241
- if (s390_facilities & FACILITY_LOAD_ON_COND2) {
242
+ if (HAVE_FACILITY(LOAD_ON_COND2)) {
243
/* Emit: d = 0, d = (cc ? 1 : d). */
244
cc = tgen_cmp(s, type, cond, c1, c2, c2const, false);
245
tcg_out_movi(s, TCG_TYPE_I64, dest, 0);
246
@@ -XXX,XX +XXX,XX @@ static void tgen_setcond(TCGContext *s, TCGType type, TCGCond cond,
247
return;
248
}
249
250
- have_loc = (s390_facilities & FACILITY_LOAD_ON_COND) != 0;
251
+ have_loc = HAVE_FACILITY(LOAD_ON_COND);
252
253
/* For HAVE_LOC, only the paths through GTU/GT/LEU/LE are smaller. */
254
restart:
255
@@ -XXX,XX +XXX,XX @@ static void tgen_movcond(TCGContext *s, TCGType type, TCGCond c, TCGReg dest,
256
TCGArg v3, int v3const)
257
{
258
int cc;
259
- if (s390_facilities & FACILITY_LOAD_ON_COND) {
260
+ if (HAVE_FACILITY(LOAD_ON_COND)) {
261
cc = tgen_cmp(s, type, c, c1, c2, c2const, false);
262
if (v3const) {
263
tcg_out_insn(s, RIE, LOCGHI, dest, v3, cc);
264
@@ -XXX,XX +XXX,XX @@ static void tgen_clz(TCGContext *s, TCGReg dest, TCGReg a1,
265
} else {
266
tcg_out_mov(s, TCG_TYPE_I64, dest, a2);
267
}
268
- if (s390_facilities & FACILITY_LOAD_ON_COND) {
269
+ if (HAVE_FACILITY(LOAD_ON_COND)) {
270
/* Emit: if (one bit found) dest = r0. */
271
tcg_out_insn(s, RRF, LOCGR, dest, TCG_REG_R0, 2);
272
} else {
273
@@ -XXX,XX +XXX,XX @@ static void tgen_brcond(TCGContext *s, TCGType type, TCGCond c,
274
{
275
int cc;
276
277
- if (s390_facilities & FACILITY_GEN_INST_EXT) {
278
+ if (HAVE_FACILITY(GEN_INST_EXT)) {
279
bool is_unsigned = is_unsigned_cond(c);
280
bool in_range;
281
S390Opcode opc;
282
@@ -XXX,XX +XXX,XX @@ static TCGReg tcg_out_tlb_read(TCGContext *s, TCGReg addr_reg, MemOp opc,
283
cross pages using the address of the last byte of the access. */
284
a_off = (a_bits >= s_bits ? 0 : s_mask - a_mask);
285
tlb_mask = (uint64_t)TARGET_PAGE_MASK | a_mask;
286
- if ((s390_facilities & FACILITY_GEN_INST_EXT) && a_off == 0) {
287
+ if (HAVE_FACILITY(GEN_INST_EXT) && a_off == 0) {
288
tgen_andi_risbg(s, TCG_REG_R3, addr_reg, tlb_mask);
289
} else {
290
tcg_out_insn(s, RX, LA, TCG_REG_R3, addr_reg, TCG_REG_NONE, a_off);
291
@@ -XXX,XX +XXX,XX @@ static inline void tcg_out_op(TCGContext *s, TCGOpcode opc,
292
tcg_out_insn(s, RI, AHI, a0, a2);
293
break;
294
}
295
- if (s390_facilities & FACILITY_EXT_IMM) {
296
+ if (HAVE_FACILITY(EXT_IMM)) {
297
tcg_out_insn(s, RIL, AFI, a0, a2);
298
break;
299
}
300
@@ -XXX,XX +XXX,XX @@ static inline void tcg_out_op(TCGContext *s, TCGOpcode opc,
301
tcg_out_insn(s, RI, AGHI, a0, a2);
302
break;
303
}
304
- if (s390_facilities & FACILITY_EXT_IMM) {
305
+ if (HAVE_FACILITY(EXT_IMM)) {
306
if (a2 == (int32_t)a2) {
307
tcg_out_insn(s, RIL, AGFI, a0, a2);
308
break;
309
@@ -XXX,XX +XXX,XX @@ static inline void tcg_out_op(TCGContext *s, TCGOpcode opc,
310
/* The host memory model is quite strong, we simply need to
311
serialize the instruction stream. */
312
if (args[0] & TCG_MO_ST_LD) {
313
- tcg_out_insn(s, RR, BCR,
314
- s390_facilities & FACILITY_FAST_BCR_SER ? 14 : 15, 0);
315
+ tcg_out_insn(s, RR, BCR, HAVE_FACILITY(FAST_BCR_SER) ? 14 : 15, 0);
316
}
317
break;
318
319
@@ -XXX,XX +XXX,XX @@ static TCGConstraintSetIndex tcg_target_op_def(TCGOpcode op)
320
case INDEX_op_or_i64:
321
case INDEX_op_xor_i32:
322
case INDEX_op_xor_i64:
323
- return (s390_facilities & FACILITY_DISTINCT_OPS
324
+ return (HAVE_FACILITY(DISTINCT_OPS)
325
? C_O1_I2(r, r, ri)
326
: C_O1_I2(r, 0, ri));
327
328
@@ -XXX,XX +XXX,XX @@ static TCGConstraintSetIndex tcg_target_op_def(TCGOpcode op)
329
/* If we have the general-instruction-extensions, then we have
330
MULTIPLY SINGLE IMMEDIATE with a signed 32-bit, otherwise we
331
have only MULTIPLY HALFWORD IMMEDIATE, with a signed 16-bit. */
332
- return (s390_facilities & FACILITY_GEN_INST_EXT
333
+ return (HAVE_FACILITY(GEN_INST_EXT)
334
? C_O1_I2(r, 0, ri)
335
: C_O1_I2(r, 0, rI));
336
337
case INDEX_op_mul_i64:
338
- return (s390_facilities & FACILITY_GEN_INST_EXT
339
+ return (HAVE_FACILITY(GEN_INST_EXT)
340
? C_O1_I2(r, 0, rJ)
341
: C_O1_I2(r, 0, rI));
342
343
case INDEX_op_shl_i32:
344
case INDEX_op_shr_i32:
345
case INDEX_op_sar_i32:
346
- return (s390_facilities & FACILITY_DISTINCT_OPS
347
+ return (HAVE_FACILITY(DISTINCT_OPS)
348
? C_O1_I2(r, r, ri)
349
: C_O1_I2(r, 0, ri));
350
351
@@ -XXX,XX +XXX,XX @@ static TCGConstraintSetIndex tcg_target_op_def(TCGOpcode op)
352
353
case INDEX_op_movcond_i32:
354
case INDEX_op_movcond_i64:
355
- return (s390_facilities & FACILITY_LOAD_ON_COND2
356
+ return (HAVE_FACILITY(LOAD_ON_COND2)
357
? C_O1_I4(r, r, ri, rI, 0)
358
: C_O1_I4(r, r, ri, r, 0));
359
360
@@ -XXX,XX +XXX,XX @@ static TCGConstraintSetIndex tcg_target_op_def(TCGOpcode op)
361
362
case INDEX_op_add2_i32:
363
case INDEX_op_sub2_i32:
364
- return (s390_facilities & FACILITY_EXT_IMM
365
+ return (HAVE_FACILITY(EXT_IMM)
366
? C_O2_I4(r, r, 0, 1, ri, r)
367
: C_O2_I4(r, r, 0, 1, r, r));
368
369
case INDEX_op_add2_i64:
370
case INDEX_op_sub2_i64:
371
- return (s390_facilities & FACILITY_EXT_IMM
372
+ return (HAVE_FACILITY(EXT_IMM)
373
? C_O2_I4(r, r, 0, 1, rA, r)
374
: C_O2_I4(r, r, 0, 1, r, r));
375
376
@@ -XXX,XX +XXX,XX @@ static void query_s390_facilities(void)
377
/* Is STORE FACILITY LIST EXTENDED available? Honestly, I believe this
378
is present on all 64-bit systems, but let's check for it anyway. */
379
if (hwcap & HWCAP_S390_STFLE) {
380
- register int r0 __asm__("0");
381
- register void *r1 __asm__("1");
382
+ register int r0 __asm__("0") = ARRAY_SIZE(s390_facilities) - 1;
383
+ register void *r1 __asm__("1") = s390_facilities;
384
385
/* stfle 0(%r1) */
386
- r1 = &s390_facilities;
387
asm volatile(".word 0xb2b0,0x1000"
388
- : "=r"(r0) : "0"(0), "r"(r1) : "memory", "cc");
389
+ : "=r"(r0) : "r"(r0), "r"(r1) : "memory", "cc");
390
}
391
}
392
393
--
394
2.25.1
395
396
diff view generated by jsdifflib
New patch
[PULL 16/28] tcg/s390x: Merge TCG_AREG0 and TCG_REG_CALL_STACK into TCGReg
1
They are rightly values in the same enumeration.
1
2
3
Reviewed-by: David Hildenbrand <david@redhat.com>
4
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
5
---
6
tcg/s390x/tcg-target.h | 28 +++++++---------------------
7
1 file changed, 7 insertions(+), 21 deletions(-)
8
9
diff --git a/tcg/s390x/tcg-target.h b/tcg/s390x/tcg-target.h
10
index XXXXXXX..XXXXXXX 100644
11
--- a/tcg/s390x/tcg-target.h
12
+++ b/tcg/s390x/tcg-target.h
13
@@ -XXX,XX +XXX,XX @@
14
#define MAX_CODE_GEN_BUFFER_SIZE (3 * GiB)
15
16
typedef enum TCGReg {
17
- TCG_REG_R0 = 0,
18
- TCG_REG_R1,
19
- TCG_REG_R2,
20
- TCG_REG_R3,
21
- TCG_REG_R4,
22
- TCG_REG_R5,
23
- TCG_REG_R6,
24
- TCG_REG_R7,
25
- TCG_REG_R8,
26
- TCG_REG_R9,
27
- TCG_REG_R10,
28
- TCG_REG_R11,
29
- TCG_REG_R12,
30
- TCG_REG_R13,
31
- TCG_REG_R14,
32
- TCG_REG_R15
33
+ TCG_REG_R0, TCG_REG_R1, TCG_REG_R2, TCG_REG_R3,
34
+ TCG_REG_R4, TCG_REG_R5, TCG_REG_R6, TCG_REG_R7,
35
+ TCG_REG_R8, TCG_REG_R9, TCG_REG_R10, TCG_REG_R11,
36
+ TCG_REG_R12, TCG_REG_R13, TCG_REG_R14, TCG_REG_R15,
37
+
38
+ TCG_AREG0 = TCG_REG_R10,
39
+ TCG_REG_CALL_STACK = TCG_REG_R15
40
} TCGReg;
41
42
#define TCG_TARGET_NB_REGS 16
43
@@ -XXX,XX +XXX,XX @@ extern uint64_t s390_facilities[1];
44
#define TCG_TARGET_HAS_mulsh_i64 0
45
46
/* used for function call generation */
47
-#define TCG_REG_CALL_STACK        TCG_REG_R15
48
#define TCG_TARGET_STACK_ALIGN        8
49
#define TCG_TARGET_CALL_STACK_OFFSET    160
50
51
@@ -XXX,XX +XXX,XX @@ extern uint64_t s390_facilities[1];
52
53
#define TCG_TARGET_DEFAULT_MO (TCG_MO_ALL & ~TCG_MO_ST_LD)
54
55
-enum {
56
- TCG_AREG0 = TCG_REG_R10,
57
-};
58
-
59
static inline void tb_target_set_jmp_target(uintptr_t tc_ptr, uintptr_t jmp_rx,
60
uintptr_t jmp_rw, uintptr_t addr)
61
{
62
--
63
2.25.1
64
65
diff view generated by jsdifflib
New patch
[PULL 17/28] tcg/s390x: Add host vector framework
1
1
Add registers and function stubs. The functionality
2
is disabled via squashing s390_facilities[2] to 0.
3
4
We must still include results for the mandatory opcodes in
5
tcg_target_op_def, as all opcodes are checked during tcg init.
6
7
Reviewed-by: David Hildenbrand <david@redhat.com>
8
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
9
---
10
tcg/s390x/tcg-target-con-set.h | 4 +
11
tcg/s390x/tcg-target-con-str.h | 1 +
12
tcg/s390x/tcg-target.h | 35 ++++++++-
13
tcg/s390x/tcg-target.opc.h | 12 +++
14
tcg/s390x/tcg-target.c.inc | 137 ++++++++++++++++++++++++++++++++-
15
5 files changed, 184 insertions(+), 5 deletions(-)
16
create mode 100644 tcg/s390x/tcg-target.opc.h
17
18
diff --git a/tcg/s390x/tcg-target-con-set.h b/tcg/s390x/tcg-target-con-set.h
19
index XXXXXXX..XXXXXXX 100644
20
--- a/tcg/s390x/tcg-target-con-set.h
21
+++ b/tcg/s390x/tcg-target-con-set.h
22
@@ -XXX,XX +XXX,XX @@ C_O0_I1(r)
23
C_O0_I2(L, L)
24
C_O0_I2(r, r)
25
C_O0_I2(r, ri)
26
+C_O0_I2(v, r)
27
C_O1_I1(r, L)
28
C_O1_I1(r, r)
29
+C_O1_I1(v, r)
30
+C_O1_I1(v, vr)
31
C_O1_I2(r, 0, ri)
32
C_O1_I2(r, 0, rI)
33
C_O1_I2(r, 0, rJ)
34
C_O1_I2(r, r, ri)
35
C_O1_I2(r, rZ, r)
36
+C_O1_I2(v, v, v)
37
C_O1_I4(r, r, ri, r, 0)
38
C_O1_I4(r, r, ri, rI, 0)
39
C_O2_I2(b, a, 0, r)
40
diff --git a/tcg/s390x/tcg-target-con-str.h b/tcg/s390x/tcg-target-con-str.h
41
index XXXXXXX..XXXXXXX 100644
42
--- a/tcg/s390x/tcg-target-con-str.h
43
+++ b/tcg/s390x/tcg-target-con-str.h
44
@@ -XXX,XX +XXX,XX @@
45
*/
46
REGS('r', ALL_GENERAL_REGS)
47
REGS('L', ALL_GENERAL_REGS & ~SOFTMMU_RESERVE_REGS)
48
+REGS('v', ALL_VECTOR_REGS)
49
/*
50
* A (single) even/odd pair for division.
51
* TODO: Add something to the register allocator to allow
52
diff --git a/tcg/s390x/tcg-target.h b/tcg/s390x/tcg-target.h
53
index XXXXXXX..XXXXXXX 100644
54
--- a/tcg/s390x/tcg-target.h
55
+++ b/tcg/s390x/tcg-target.h
56
@@ -XXX,XX +XXX,XX @@ typedef enum TCGReg {
57
TCG_REG_R8, TCG_REG_R9, TCG_REG_R10, TCG_REG_R11,
58
TCG_REG_R12, TCG_REG_R13, TCG_REG_R14, TCG_REG_R15,
59
60
+ TCG_REG_V0 = 32, TCG_REG_V1, TCG_REG_V2, TCG_REG_V3,
61
+ TCG_REG_V4, TCG_REG_V5, TCG_REG_V6, TCG_REG_V7,
62
+ TCG_REG_V8, TCG_REG_V9, TCG_REG_V10, TCG_REG_V11,
63
+ TCG_REG_V12, TCG_REG_V13, TCG_REG_V14, TCG_REG_V15,
64
+ TCG_REG_V16, TCG_REG_V17, TCG_REG_V18, TCG_REG_V19,
65
+ TCG_REG_V20, TCG_REG_V21, TCG_REG_V22, TCG_REG_V23,
66
+ TCG_REG_V24, TCG_REG_V25, TCG_REG_V26, TCG_REG_V27,
67
+ TCG_REG_V28, TCG_REG_V29, TCG_REG_V30, TCG_REG_V31,
68
+
69
TCG_AREG0 = TCG_REG_R10,
70
TCG_REG_CALL_STACK = TCG_REG_R15
71
} TCGReg;
72
73
-#define TCG_TARGET_NB_REGS 16
74
+#define TCG_TARGET_NB_REGS 64
75
76
/* A list of relevant facilities used by this translator. Some of these
77
are required for proper operation, and these are checked at startup. */
78
@@ -XXX,XX +XXX,XX @@ typedef enum TCGReg {
79
#define FACILITY_FAST_BCR_SER FACILITY_LOAD_ON_COND
80
#define FACILITY_DISTINCT_OPS FACILITY_LOAD_ON_COND
81
#define FACILITY_LOAD_ON_COND2 53
82
+#define FACILITY_VECTOR 129
83
84
-extern uint64_t s390_facilities[1];
85
+extern uint64_t s390_facilities[3];
86
87
#define HAVE_FACILITY(X) \
88
((s390_facilities[FACILITY_##X / 64] >> (63 - FACILITY_##X % 64)) & 1)
89
@@ -XXX,XX +XXX,XX @@ extern uint64_t s390_facilities[1];
90
#define TCG_TARGET_HAS_muluh_i64 0
91
#define TCG_TARGET_HAS_mulsh_i64 0
92
93
+#define TCG_TARGET_HAS_v64 HAVE_FACILITY(VECTOR)
94
+#define TCG_TARGET_HAS_v128 HAVE_FACILITY(VECTOR)
95
+#define TCG_TARGET_HAS_v256 0
96
+
97
+#define TCG_TARGET_HAS_andc_vec 0
98
+#define TCG_TARGET_HAS_orc_vec 0
99
+#define TCG_TARGET_HAS_not_vec 0
100
+#define TCG_TARGET_HAS_neg_vec 0
101
+#define TCG_TARGET_HAS_abs_vec 0
102
+#define TCG_TARGET_HAS_roti_vec 0
103
+#define TCG_TARGET_HAS_rots_vec 0
104
+#define TCG_TARGET_HAS_rotv_vec 0
105
+#define TCG_TARGET_HAS_shi_vec 0
106
+#define TCG_TARGET_HAS_shs_vec 0
107
+#define TCG_TARGET_HAS_shv_vec 0
108
+#define TCG_TARGET_HAS_mul_vec 0
109
+#define TCG_TARGET_HAS_sat_vec 0
110
+#define TCG_TARGET_HAS_minmax_vec 0
111
+#define TCG_TARGET_HAS_bitsel_vec 0
112
+#define TCG_TARGET_HAS_cmpsel_vec 0
113
+
114
/* used for function call generation */
115
#define TCG_TARGET_STACK_ALIGN        8
116
#define TCG_TARGET_CALL_STACK_OFFSET    160
117
diff --git a/tcg/s390x/tcg-target.opc.h b/tcg/s390x/tcg-target.opc.h
118
new file mode 100644
119
index XXXXXXX..XXXXXXX
120
--- /dev/null
121
+++ b/tcg/s390x/tcg-target.opc.h
122
@@ -XXX,XX +XXX,XX @@
123
+/*
124
+ * Copyright (c) 2021 Linaro
125
+ *
126
+ * This work is licensed under the terms of the GNU GPL, version 2 or
127
+ * (at your option) any later version.
128
+ *
129
+ * See the COPYING file in the top-level directory for details.
130
+ *
131
+ * Target-specific opcodes for host vector expansion. These will be
132
+ * emitted by tcg_expand_vec_op. For those familiar with GCC internals,
133
+ * consider these to be UNSPEC with names.
134
+ */
135
diff --git a/tcg/s390x/tcg-target.c.inc b/tcg/s390x/tcg-target.c.inc
136
index XXXXXXX..XXXXXXX 100644
137
--- a/tcg/s390x/tcg-target.c.inc
138
+++ b/tcg/s390x/tcg-target.c.inc
139
@@ -XXX,XX +XXX,XX @@
140
#define TCG_CT_CONST_ZERO 0x800
141
142
#define ALL_GENERAL_REGS MAKE_64BIT_MASK(0, 16)
143
+#define ALL_VECTOR_REGS MAKE_64BIT_MASK(32, 32)
144
+
145
/*
146
* For softmmu, we need to avoid conflicts with the first 3
147
* argument registers to perform the tlb lookup, and to call
148
@@ -XXX,XX +XXX,XX @@ typedef enum S390Opcode {
149
150
#ifdef CONFIG_DEBUG_TCG
151
static const char * const tcg_target_reg_names[TCG_TARGET_NB_REGS] = {
152
- "%r0", "%r1", "%r2", "%r3", "%r4", "%r5", "%r6", "%r7",
153
- "%r8", "%r9", "%r10" "%r11" "%r12" "%r13" "%r14" "%r15"
154
+ "%r0", "%r1", "%r2", "%r3", "%r4", "%r5", "%r6", "%r7",
155
+ "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15",
156
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
157
+ "%v0", "%v1", "%v2", "%v3", "%v4", "%v5", "%v6", "%v7",
158
+ "%v8", "%v9", "%v10", "%v11", "%v12", "%v13", "%v14", "%v15",
159
+ "%v16", "%v17", "%v18", "%v19", "%v20", "%v21", "%v22", "%v23",
160
+ "%v24", "%v25", "%v26", "%v27", "%v28", "%v29", "%v30", "%v31",
161
};
162
#endif
163
164
@@ -XXX,XX +XXX,XX @@ static const int tcg_target_reg_alloc_order[] = {
165
TCG_REG_R4,
166
TCG_REG_R3,
167
TCG_REG_R2,
168
+
169
+ /* V8-V15 are call saved, and omitted. */
170
+ TCG_REG_V0,
171
+ TCG_REG_V1,
172
+ TCG_REG_V2,
173
+ TCG_REG_V3,
174
+ TCG_REG_V4,
175
+ TCG_REG_V5,
176
+ TCG_REG_V6,
177
+ TCG_REG_V7,
178
+ TCG_REG_V16,
179
+ TCG_REG_V17,
180
+ TCG_REG_V18,
181
+ TCG_REG_V19,
182
+ TCG_REG_V20,
183
+ TCG_REG_V21,
184
+ TCG_REG_V22,
185
+ TCG_REG_V23,
186
+ TCG_REG_V24,
187
+ TCG_REG_V25,
188
+ TCG_REG_V26,
189
+ TCG_REG_V27,
190
+ TCG_REG_V28,
191
+ TCG_REG_V29,
192
+ TCG_REG_V30,
193
+ TCG_REG_V31,
194
};
195
196
static const int tcg_target_call_iarg_regs[] = {
197
@@ -XXX,XX +XXX,XX @@ static void * const qemu_st_helpers[(MO_SIZE | MO_BSWAP) + 1] = {
198
#endif
199
200
static const tcg_insn_unit *tb_ret_addr;
201
-uint64_t s390_facilities[1];
202
+uint64_t s390_facilities[3];
203
204
static bool patch_reloc(tcg_insn_unit *src_rw, int type,
205
intptr_t value, intptr_t addend)
206
@@ -XXX,XX +XXX,XX @@ static inline void tcg_out_op(TCGContext *s, TCGOpcode opc,
207
}
208
}
209
210
+static bool tcg_out_dup_vec(TCGContext *s, TCGType type, unsigned vece,
211
+ TCGReg dst, TCGReg src)
212
+{
213
+ g_assert_not_reached();
214
+}
215
+
216
+static bool tcg_out_dupm_vec(TCGContext *s, TCGType type, unsigned vece,
217
+ TCGReg dst, TCGReg base, intptr_t offset)
218
+{
219
+ g_assert_not_reached();
220
+}
221
+
222
+static void tcg_out_dupi_vec(TCGContext *s, TCGType type, unsigned vece,
223
+ TCGReg dst, int64_t val)
224
+{
225
+ g_assert_not_reached();
226
+}
227
+
228
+static void tcg_out_vec_op(TCGContext *s, TCGOpcode opc,
229
+ unsigned vecl, unsigned vece,
230
+ const TCGArg *args, const int *const_args)
231
+{
232
+ g_assert_not_reached();
233
+}
234
+
235
+int tcg_can_emit_vec_op(TCGOpcode opc, TCGType type, unsigned vece)
236
+{
237
+ return 0;
238
+}
239
+
240
+void tcg_expand_vec_op(TCGOpcode opc, TCGType type, unsigned vece,
241
+ TCGArg a0, ...)
242
+{
243
+ g_assert_not_reached();
244
+}
245
+
246
static TCGConstraintSetIndex tcg_target_op_def(TCGOpcode op)
247
{
248
switch (op) {
249
@@ -XXX,XX +XXX,XX @@ static TCGConstraintSetIndex tcg_target_op_def(TCGOpcode op)
250
? C_O2_I4(r, r, 0, 1, rA, r)
251
: C_O2_I4(r, r, 0, 1, r, r));
252
253
+ case INDEX_op_st_vec:
254
+ return C_O0_I2(v, r);
255
+ case INDEX_op_ld_vec:
256
+ case INDEX_op_dupm_vec:
257
+ return C_O1_I1(v, r);
258
+ case INDEX_op_dup_vec:
259
+ return C_O1_I1(v, vr);
260
+ case INDEX_op_add_vec:
261
+ case INDEX_op_sub_vec:
262
+ case INDEX_op_and_vec:
263
+ case INDEX_op_or_vec:
264
+ case INDEX_op_xor_vec:
265
+ case INDEX_op_cmp_vec:
266
+ return C_O1_I2(v, v, v);
267
+
268
default:
269
g_assert_not_reached();
270
}
271
}
272
273
+/*
274
+ * Mainline glibc added HWCAP_S390_VX before it was kernel abi.
275
+ * Some distros have fixed this up locally, others have not.
276
+ */
277
+#ifndef HWCAP_S390_VXRS
278
+#define HWCAP_S390_VXRS 2048
279
+#endif
280
+
281
static void query_s390_facilities(void)
282
{
283
unsigned long hwcap = qemu_getauxval(AT_HWCAP);
284
@@ -XXX,XX +XXX,XX @@ static void query_s390_facilities(void)
285
asm volatile(".word 0xb2b0,0x1000"
286
: "=r"(r0) : "r"(r0), "r"(r1) : "memory", "cc");
287
}
288
+
289
+ /*
290
+ * Use of vector registers requires os support beyond the facility bit.
291
+ * If the kernel does not advertise support, disable the facility bits.
292
+ * There is nothing else we currently care about in the 3rd word, so
293
+ * disable VECTOR with one store.
294
+ */
295
+ if (1 || !(hwcap & HWCAP_S390_VXRS)) {
296
+ s390_facilities[2] = 0;
297
+ }
298
}
299
300
static void tcg_target_init(TCGContext *s)
301
@@ -XXX,XX +XXX,XX @@ static void tcg_target_init(TCGContext *s)
302
303
tcg_target_available_regs[TCG_TYPE_I32] = 0xffff;
304
tcg_target_available_regs[TCG_TYPE_I64] = 0xffff;
305
+ if (HAVE_FACILITY(VECTOR)) {
306
+ tcg_target_available_regs[TCG_TYPE_V64] = 0xffffffff00000000ull;
307
+ tcg_target_available_regs[TCG_TYPE_V128] = 0xffffffff00000000ull;
308
+ }
309
310
tcg_target_call_clobber_regs = 0;
311
tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R0);
312
@@ -XXX,XX +XXX,XX @@ static void tcg_target_init(TCGContext *s)
313
/* The return register can be considered call-clobbered. */
314
tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_R14);
315
316
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V0);
317
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V1);
318
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V2);
319
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V3);
320
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V4);
321
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V5);
322
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V6);
323
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V7);
324
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V16);
325
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V17);
326
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V18);
327
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V19);
328
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V20);
329
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V21);
330
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V22);
331
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V23);
332
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V24);
333
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V25);
334
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V26);
335
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V27);
336
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V28);
337
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V29);
338
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V30);
339
+ tcg_regset_set_reg(tcg_target_call_clobber_regs, TCG_REG_V31);
340
+
341
s->reserved_regs = 0;
342
tcg_regset_set_reg(s->reserved_regs, TCG_TMP0);
343
/* XXX many insns can't be used with R0, so we better avoid it for now */
344
--
345
2.25.1
346
347
diff view generated by jsdifflib
[PULL 3/3] accel/tcg: rename tcg-cpus functions to match module name
[PULL 18/28] tcg/s390x: Implement tcg_out_ld/st for vector types
1
From: Claudio Fontana <cfontana@suse.de>
1
Reviewed-by: David Hildenbrand <david@redhat.com>
2
3
Signed-off-by: Claudio Fontana <cfontana@suse.de>
4
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
5
Message-Id: <20201015143217.29337-4-cfontana@suse.de>
6
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
2
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
7
---
3
---
8
accel/tcg/tcg-cpus-icount.h | 6 +--
4
tcg/s390x/tcg-target.c.inc | 132 +++++++++++++++++++++++++++++++++----
9
accel/tcg/tcg-cpus-rr.h | 2 +-
5
1 file changed, 120 insertions(+), 12 deletions(-)
10
accel/tcg/tcg-cpus.h | 6 +--
11
accel/tcg/tcg-cpus-icount.c | 24 ++++++------
12
accel/tcg/tcg-cpus-mttcg.c | 10 ++---
13
accel/tcg/tcg-cpus-rr.c | 74 ++++++++++++++++++-------------------
14
accel/tcg/tcg-cpus.c | 6 +--
15
7 files changed, 64 insertions(+), 64 deletions(-)
16
6
17
diff --git a/accel/tcg/tcg-cpus-icount.h b/accel/tcg/tcg-cpus-icount.h
7
diff --git a/tcg/s390x/tcg-target.c.inc b/tcg/s390x/tcg-target.c.inc
18
index XXXXXXX..XXXXXXX 100644
8
index XXXXXXX..XXXXXXX 100644
19
--- a/accel/tcg/tcg-cpus-icount.h
9
--- a/tcg/s390x/tcg-target.c.inc
20
+++ b/accel/tcg/tcg-cpus-icount.h
10
+++ b/tcg/s390x/tcg-target.c.inc
21
@@ -XXX,XX +XXX,XX @@
11
@@ -XXX,XX +XXX,XX @@ typedef enum S390Opcode {
22
#ifndef TCG_CPUS_ICOUNT_H
12
RX_STC = 0x42,
23
#define TCG_CPUS_ICOUNT_H
13
RX_STH = 0x40,
24
14
25
-void handle_icount_deadline(void);
15
+ VRX_VL = 0xe706,
26
-void prepare_icount_for_run(CPUState *cpu);
16
+ VRX_VLLEZ = 0xe704,
27
-void process_icount_data(CPUState *cpu);
17
+ VRX_VST = 0xe70e,
28
+void icount_handle_deadline(void);
18
+ VRX_VSTEF = 0xe70b,
29
+void icount_prepare_for_run(CPUState *cpu);
19
+ VRX_VSTEG = 0xe70a,
30
+void icount_process_data(CPUState *cpu);
20
+
31
21
NOP = 0x0707,
32
#endif /* TCG_CPUS_ICOUNT_H */
22
} S390Opcode;
33
diff --git a/accel/tcg/tcg-cpus-rr.h b/accel/tcg/tcg-cpus-rr.h
23
34
index XXXXXXX..XXXXXXX 100644
24
@@ -XXX,XX +XXX,XX @@ static void * const qemu_st_helpers[(MO_SIZE | MO_BSWAP) + 1] = {
35
--- a/accel/tcg/tcg-cpus-rr.h
25
static const tcg_insn_unit *tb_ret_addr;
36
+++ b/accel/tcg/tcg-cpus-rr.h
26
uint64_t s390_facilities[3];
37
@@ -XXX,XX +XXX,XX @@
27
38
#define TCG_KICK_PERIOD (NANOSECONDS_PER_SECOND / 10)
28
+static inline bool is_general_reg(TCGReg r)
39
29
+{
40
/* Kick all RR vCPUs. */
30
+ return r <= TCG_REG_R15;
41
-void qemu_cpu_kick_rr_cpus(CPUState *unused);
31
+}
42
+void rr_kick_vcpu_thread(CPUState *unused);
32
+
43
33
+static inline bool is_vector_reg(TCGReg r)
44
/* start the round robin vcpu thread */
34
+{
45
void rr_start_vcpu_thread(CPUState *cpu);
35
+ return r >= TCG_REG_V0 && r <= TCG_REG_V31;
46
diff --git a/accel/tcg/tcg-cpus.h b/accel/tcg/tcg-cpus.h
36
+}
47
index XXXXXXX..XXXXXXX 100644
37
+
48
--- a/accel/tcg/tcg-cpus.h
38
static bool patch_reloc(tcg_insn_unit *src_rw, int type,
49
+++ b/accel/tcg/tcg-cpus.h
39
intptr_t value, intptr_t addend)
50
@@ -XXX,XX +XXX,XX @@ extern const CpusAccel tcg_cpus_mttcg;
51
extern const CpusAccel tcg_cpus_icount;
52
extern const CpusAccel tcg_cpus_rr;
53
54
-void qemu_tcg_destroy_vcpu(CPUState *cpu);
55
-int tcg_cpu_exec(CPUState *cpu);
56
-void tcg_handle_interrupt(CPUState *cpu, int mask);
57
+void tcg_cpus_destroy(CPUState *cpu);
58
+int tcg_cpus_exec(CPUState *cpu);
59
+void tcg_cpus_handle_interrupt(CPUState *cpu, int mask);
60
61
#endif /* TCG_CPUS_H */
62
diff --git a/accel/tcg/tcg-cpus-icount.c b/accel/tcg/tcg-cpus-icount.c
63
index XXXXXXX..XXXXXXX 100644
64
--- a/accel/tcg/tcg-cpus-icount.c
65
+++ b/accel/tcg/tcg-cpus-icount.c
66
@@ -XXX,XX +XXX,XX @@
67
#include "tcg-cpus-icount.h"
68
#include "tcg-cpus-rr.h"
69
70
-static int64_t tcg_get_icount_limit(void)
71
+static int64_t icount_get_limit(void)
72
{
40
{
73
int64_t deadline;
41
@@ -XXX,XX +XXX,XX @@ static void tcg_out_insn_RSY(TCGContext *s, S390Opcode op, TCGReg r1,
74
42
#define tcg_out_insn_RX tcg_out_insn_RS
75
@@ -XXX,XX +XXX,XX @@ static int64_t tcg_get_icount_limit(void)
43
#define tcg_out_insn_RXY tcg_out_insn_RSY
44
45
+static int RXB(TCGReg v1, TCGReg v2, TCGReg v3, TCGReg v4)
46
+{
47
+ /*
48
+ * Shift bit 4 of each regno to its corresponding bit of RXB.
49
+ * RXB itself begins at bit 8 of the instruction so 8 - 4 = 4
50
+ * is the left-shift of the 4th operand.
51
+ */
52
+ return ((v1 & 0x10) << (4 + 3))
53
+ | ((v2 & 0x10) << (4 + 2))
54
+ | ((v3 & 0x10) << (4 + 1))
55
+ | ((v4 & 0x10) << (4 + 0));
56
+}
57
+
58
+static void tcg_out_insn_VRX(TCGContext *s, S390Opcode op, TCGReg v1,
59
+ TCGReg b2, TCGReg x2, intptr_t d2, int m3)
60
+{
61
+ tcg_debug_assert(is_vector_reg(v1));
62
+ tcg_debug_assert(d2 >= 0 && d2 <= 0xfff);
63
+ tcg_debug_assert(is_general_reg(x2));
64
+ tcg_debug_assert(is_general_reg(b2));
65
+ tcg_out16(s, (op & 0xff00) | ((v1 & 0xf) << 4) | x2);
66
+ tcg_out16(s, (b2 << 12) | d2);
67
+ tcg_out16(s, (op & 0x00ff) | RXB(v1, 0, 0, 0) | (m3 << 12));
68
+}
69
+
70
/* Emit an opcode with "type-checking" of the format. */
71
#define tcg_out_insn(S, FMT, OP, ...) \
72
glue(tcg_out_insn_,FMT)(S, glue(glue(FMT,_),OP), ## __VA_ARGS__)
73
@@ -XXX,XX +XXX,XX @@ static void tcg_out_mem(TCGContext *s, S390Opcode opc_rx, S390Opcode opc_rxy,
76
}
74
}
77
}
75
}
78
76
79
-static void notify_aio_contexts(void)
77
+static void tcg_out_vrx_mem(TCGContext *s, S390Opcode opc_vrx,
80
+static void icount_notify_aio_contexts(void)
78
+ TCGReg data, TCGReg base, TCGReg index,
79
+ tcg_target_long ofs, int m3)
80
+{
81
+ if (ofs < 0 || ofs >= 0x1000) {
82
+ if (ofs >= -0x80000 && ofs < 0x80000) {
83
+ tcg_out_insn(s, RXY, LAY, TCG_TMP0, base, index, ofs);
84
+ base = TCG_TMP0;
85
+ index = TCG_REG_NONE;
86
+ ofs = 0;
87
+ } else {
88
+ tcg_out_movi(s, TCG_TYPE_PTR, TCG_TMP0, ofs);
89
+ if (index != TCG_REG_NONE) {
90
+ tcg_out_insn(s, RRE, AGR, TCG_TMP0, index);
91
+ }
92
+ index = TCG_TMP0;
93
+ ofs = 0;
94
+ }
95
+ }
96
+ tcg_out_insn_VRX(s, opc_vrx, data, base, index, ofs, m3);
97
+}
98
99
/* load data without address translation or endianness conversion */
100
-static inline void tcg_out_ld(TCGContext *s, TCGType type, TCGReg data,
101
- TCGReg base, intptr_t ofs)
102
+static void tcg_out_ld(TCGContext *s, TCGType type, TCGReg data,
103
+ TCGReg base, intptr_t ofs)
81
{
104
{
82
/* Wake up other AioContexts. */
105
- if (type == TCG_TYPE_I32) {
83
qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
106
- tcg_out_mem(s, RX_L, RXY_LY, data, base, TCG_REG_NONE, ofs);
84
qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
107
- } else {
85
}
108
- tcg_out_mem(s, 0, RXY_LG, data, base, TCG_REG_NONE, ofs);
86
109
+ switch (type) {
87
-void handle_icount_deadline(void)
110
+ case TCG_TYPE_I32:
88
+void icount_handle_deadline(void)
111
+ if (likely(is_general_reg(data))) {
89
{
112
+ tcg_out_mem(s, RX_L, RXY_LY, data, base, TCG_REG_NONE, ofs);
90
assert(qemu_in_vcpu_thread());
113
+ break;
91
int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL,
114
+ }
92
QEMU_TIMER_ATTR_ALL);
115
+ tcg_out_vrx_mem(s, VRX_VLLEZ, data, base, TCG_REG_NONE, ofs, MO_32);
93
116
+ break;
94
if (deadline == 0) {
117
+
95
- notify_aio_contexts();
118
+ case TCG_TYPE_I64:
96
+ icount_notify_aio_contexts();
119
+ if (likely(is_general_reg(data))) {
120
+ tcg_out_mem(s, 0, RXY_LG, data, base, TCG_REG_NONE, ofs);
121
+ break;
122
+ }
123
+ /* fallthru */
124
+
125
+ case TCG_TYPE_V64:
126
+ tcg_out_vrx_mem(s, VRX_VLLEZ, data, base, TCG_REG_NONE, ofs, MO_64);
127
+ break;
128
+
129
+ case TCG_TYPE_V128:
130
+ /* Hint quadword aligned. */
131
+ tcg_out_vrx_mem(s, VRX_VL, data, base, TCG_REG_NONE, ofs, 4);
132
+ break;
133
+
134
+ default:
135
+ g_assert_not_reached();
97
}
136
}
98
}
137
}
99
138
100
-void prepare_icount_for_run(CPUState *cpu)
139
-static inline void tcg_out_st(TCGContext *s, TCGType type, TCGReg data,
101
+void icount_prepare_for_run(CPUState *cpu)
140
- TCGReg base, intptr_t ofs)
141
+static void tcg_out_st(TCGContext *s, TCGType type, TCGReg data,
142
+ TCGReg base, intptr_t ofs)
102
{
143
{
103
int insns_left;
144
- if (type == TCG_TYPE_I32) {
104
145
- tcg_out_mem(s, RX_ST, RXY_STY, data, base, TCG_REG_NONE, ofs);
105
/*
146
- } else {
106
- * These should always be cleared by process_icount_data after
147
- tcg_out_mem(s, 0, RXY_STG, data, base, TCG_REG_NONE, ofs);
107
+ * These should always be cleared by icount_process_data after
148
+ switch (type) {
108
* each vCPU execution. However u16.high can be raised
149
+ case TCG_TYPE_I32:
109
- * asynchronously by cpu_exit/cpu_interrupt/tcg_handle_interrupt
150
+ if (likely(is_general_reg(data))) {
110
+ * asynchronously by cpu_exit/cpu_interrupt/tcg_cpus_handle_interrupt
151
+ tcg_out_mem(s, RX_ST, RXY_STY, data, base, TCG_REG_NONE, ofs);
111
*/
152
+ } else {
112
g_assert(cpu_neg(cpu)->icount_decr.u16.low == 0);
153
+ tcg_out_vrx_mem(s, VRX_VSTEF, data, base, TCG_REG_NONE, ofs, 1);
113
g_assert(cpu->icount_extra == 0);
154
+ }
114
155
+ break;
115
- cpu->icount_budget = tcg_get_icount_limit();
156
+
116
+ cpu->icount_budget = icount_get_limit();
157
+ case TCG_TYPE_I64:
117
insns_left = MIN(0xffff, cpu->icount_budget);
158
+ if (likely(is_general_reg(data))) {
118
cpu_neg(cpu)->icount_decr.u16.low = insns_left;
159
+ tcg_out_mem(s, 0, RXY_STG, data, base, TCG_REG_NONE, ofs);
119
cpu->icount_extra = cpu->icount_budget - insns_left;
160
+ break;
120
@@ -XXX,XX +XXX,XX @@ void prepare_icount_for_run(CPUState *cpu)
161
+ }
121
replay_mutex_lock();
162
+ /* fallthru */
122
163
+
123
if (cpu->icount_budget == 0 && replay_has_checkpoint()) {
164
+ case TCG_TYPE_V64:
124
- notify_aio_contexts();
165
+ tcg_out_vrx_mem(s, VRX_VSTEG, data, base, TCG_REG_NONE, ofs, 0);
125
+ icount_notify_aio_contexts();
166
+ break;
167
+
168
+ case TCG_TYPE_V128:
169
+ /* Hint quadword aligned. */
170
+ tcg_out_vrx_mem(s, VRX_VST, data, base, TCG_REG_NONE, ofs, 4);
171
+ break;
172
+
173
+ default:
174
+ g_assert_not_reached();
126
}
175
}
127
}
176
}
128
129
-void process_icount_data(CPUState *cpu)
130
+void icount_process_data(CPUState *cpu)
131
{
132
/* Account for executed instructions */
133
icount_update(cpu);
134
@@ -XXX,XX +XXX,XX @@ static void icount_handle_interrupt(CPUState *cpu, int mask)
135
{
136
int old_mask = cpu->interrupt_request;
137
138
- tcg_handle_interrupt(cpu, mask);
139
+ tcg_cpus_handle_interrupt(cpu, mask);
140
if (qemu_cpu_is_self(cpu) &&
141
!cpu->can_do_io
142
&& (mask & ~old_mask) != 0) {
143
@@ -XXX,XX +XXX,XX @@ static void icount_handle_interrupt(CPUState *cpu, int mask)
144
145
const CpusAccel tcg_cpus_icount = {
146
.create_vcpu_thread = rr_start_vcpu_thread,
147
- .kick_vcpu_thread = qemu_cpu_kick_rr_cpus,
148
+ .kick_vcpu_thread = rr_kick_vcpu_thread,
149
150
.handle_interrupt = icount_handle_interrupt,
151
.get_virtual_clock = icount_get,
152
diff --git a/accel/tcg/tcg-cpus-mttcg.c b/accel/tcg/tcg-cpus-mttcg.c
153
index XXXXXXX..XXXXXXX 100644
154
--- a/accel/tcg/tcg-cpus-mttcg.c
155
+++ b/accel/tcg/tcg-cpus-mttcg.c
156
@@ -XXX,XX +XXX,XX @@
157
* current CPUState for a given thread.
158
*/
159
160
-static void *tcg_cpu_thread_fn(void *arg)
161
+static void *mttcg_cpu_thread_fn(void *arg)
162
{
163
CPUState *cpu = arg;
164
165
@@ -XXX,XX +XXX,XX @@ static void *tcg_cpu_thread_fn(void *arg)
166
if (cpu_can_run(cpu)) {
167
int r;
168
qemu_mutex_unlock_iothread();
169
- r = tcg_cpu_exec(cpu);
170
+ r = tcg_cpus_exec(cpu);
171
qemu_mutex_lock_iothread();
172
switch (r) {
173
case EXCP_DEBUG:
174
@@ -XXX,XX +XXX,XX @@ static void *tcg_cpu_thread_fn(void *arg)
175
qemu_wait_io_event(cpu);
176
} while (!cpu->unplug || cpu_can_run(cpu));
177
178
- qemu_tcg_destroy_vcpu(cpu);
179
+ tcg_cpus_destroy(cpu);
180
qemu_mutex_unlock_iothread();
181
rcu_unregister_thread();
182
return NULL;
183
@@ -XXX,XX +XXX,XX @@ static void mttcg_start_vcpu_thread(CPUState *cpu)
184
snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "CPU %d/TCG",
185
cpu->cpu_index);
186
187
- qemu_thread_create(cpu->thread, thread_name, tcg_cpu_thread_fn,
188
+ qemu_thread_create(cpu->thread, thread_name, mttcg_cpu_thread_fn,
189
cpu, QEMU_THREAD_JOINABLE);
190
191
#ifdef _WIN32
192
@@ -XXX,XX +XXX,XX @@ const CpusAccel tcg_cpus_mttcg = {
193
.create_vcpu_thread = mttcg_start_vcpu_thread,
194
.kick_vcpu_thread = mttcg_kick_vcpu_thread,
195
196
- .handle_interrupt = tcg_handle_interrupt,
197
+ .handle_interrupt = tcg_cpus_handle_interrupt,
198
};
199
diff --git a/accel/tcg/tcg-cpus-rr.c b/accel/tcg/tcg-cpus-rr.c
200
index XXXXXXX..XXXXXXX 100644
201
--- a/accel/tcg/tcg-cpus-rr.c
202
+++ b/accel/tcg/tcg-cpus-rr.c
203
@@ -XXX,XX +XXX,XX @@
204
#include "tcg-cpus-icount.h"
205
206
/* Kick all RR vCPUs */
207
-void qemu_cpu_kick_rr_cpus(CPUState *unused)
208
+void rr_kick_vcpu_thread(CPUState *unused)
209
{
210
CPUState *cpu;
211
212
@@ -XXX,XX +XXX,XX @@ void qemu_cpu_kick_rr_cpus(CPUState *unused)
213
* idleness is complete.
214
*/
215
216
-static QEMUTimer *tcg_kick_vcpu_timer;
217
-static CPUState *tcg_current_rr_cpu;
218
+static QEMUTimer *rr_kick_vcpu_timer;
219
+static CPUState *rr_current_cpu;
220
221
#define TCG_KICK_PERIOD (NANOSECONDS_PER_SECOND / 10)
222
223
-static inline int64_t qemu_tcg_next_kick(void)
224
+static inline int64_t rr_next_kick_time(void)
225
{
226
return qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + TCG_KICK_PERIOD;
227
}
228
229
/* Kick the currently round-robin scheduled vCPU to next */
230
-static void qemu_cpu_kick_rr_next_cpu(void)
231
+static void rr_kick_next_cpu(void)
232
{
233
CPUState *cpu;
234
do {
235
- cpu = qatomic_mb_read(&tcg_current_rr_cpu);
236
+ cpu = qatomic_mb_read(&rr_current_cpu);
237
if (cpu) {
238
cpu_exit(cpu);
239
}
240
- } while (cpu != qatomic_mb_read(&tcg_current_rr_cpu));
241
+ } while (cpu != qatomic_mb_read(&rr_current_cpu));
242
}
243
244
-static void kick_tcg_thread(void *opaque)
245
+static void rr_kick_thread(void *opaque)
246
{
247
- timer_mod(tcg_kick_vcpu_timer, qemu_tcg_next_kick());
248
- qemu_cpu_kick_rr_next_cpu();
249
+ timer_mod(rr_kick_vcpu_timer, rr_next_kick_time());
250
+ rr_kick_next_cpu();
251
}
252
253
-static void start_tcg_kick_timer(void)
254
+static void rr_start_kick_timer(void)
255
{
256
- if (!tcg_kick_vcpu_timer && CPU_NEXT(first_cpu)) {
257
- tcg_kick_vcpu_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
258
- kick_tcg_thread, NULL);
259
+ if (!rr_kick_vcpu_timer && CPU_NEXT(first_cpu)) {
260
+ rr_kick_vcpu_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
261
+ rr_kick_thread, NULL);
262
}
263
- if (tcg_kick_vcpu_timer && !timer_pending(tcg_kick_vcpu_timer)) {
264
- timer_mod(tcg_kick_vcpu_timer, qemu_tcg_next_kick());
265
+ if (rr_kick_vcpu_timer && !timer_pending(rr_kick_vcpu_timer)) {
266
+ timer_mod(rr_kick_vcpu_timer, rr_next_kick_time());
267
}
268
}
269
270
-static void stop_tcg_kick_timer(void)
271
+static void rr_stop_kick_timer(void)
272
{
273
- if (tcg_kick_vcpu_timer && timer_pending(tcg_kick_vcpu_timer)) {
274
- timer_del(tcg_kick_vcpu_timer);
275
+ if (rr_kick_vcpu_timer && timer_pending(rr_kick_vcpu_timer)) {
276
+ timer_del(rr_kick_vcpu_timer);
277
}
278
}
279
280
-static void qemu_tcg_rr_wait_io_event(void)
281
+static void rr_wait_io_event(void)
282
{
283
CPUState *cpu;
284
285
while (all_cpu_threads_idle()) {
286
- stop_tcg_kick_timer();
287
+ rr_stop_kick_timer();
288
qemu_cond_wait_iothread(first_cpu->halt_cond);
289
}
290
291
- start_tcg_kick_timer();
292
+ rr_start_kick_timer();
293
294
CPU_FOREACH(cpu) {
295
qemu_wait_io_event_common(cpu);
296
@@ -XXX,XX +XXX,XX @@ static void qemu_tcg_rr_wait_io_event(void)
297
* Destroy any remaining vCPUs which have been unplugged and have
298
* finished running
299
*/
300
-static void deal_with_unplugged_cpus(void)
301
+static void rr_deal_with_unplugged_cpus(void)
302
{
303
CPUState *cpu;
304
305
CPU_FOREACH(cpu) {
306
if (cpu->unplug && !cpu_can_run(cpu)) {
307
- qemu_tcg_destroy_vcpu(cpu);
308
+ tcg_cpus_destroy(cpu);
309
break;
310
}
311
}
312
@@ -XXX,XX +XXX,XX @@ static void deal_with_unplugged_cpus(void)
313
* elsewhere.
314
*/
315
316
-static void *tcg_rr_cpu_thread_fn(void *arg)
317
+static void *rr_cpu_thread_fn(void *arg)
318
{
319
CPUState *cpu = arg;
320
321
@@ -XXX,XX +XXX,XX @@ static void *tcg_rr_cpu_thread_fn(void *arg)
322
}
323
}
324
325
- start_tcg_kick_timer();
326
+ rr_start_kick_timer();
327
328
cpu = first_cpu;
329
330
@@ -XXX,XX +XXX,XX @@ static void *tcg_rr_cpu_thread_fn(void *arg)
331
* Run the timers here. This is much more efficient than
332
* waking up the I/O thread and waiting for completion.
333
*/
334
- handle_icount_deadline();
335
+ icount_handle_deadline();
336
}
337
338
replay_mutex_unlock();
339
@@ -XXX,XX +XXX,XX @@ static void *tcg_rr_cpu_thread_fn(void *arg)
340
341
while (cpu && cpu_work_list_empty(cpu) && !cpu->exit_request) {
342
343
- qatomic_mb_set(&tcg_current_rr_cpu, cpu);
344
+ qatomic_mb_set(&rr_current_cpu, cpu);
345
current_cpu = cpu;
346
347
qemu_clock_enable(QEMU_CLOCK_VIRTUAL,
348
@@ -XXX,XX +XXX,XX @@ static void *tcg_rr_cpu_thread_fn(void *arg)
349
350
qemu_mutex_unlock_iothread();
351
if (icount_enabled()) {
352
- prepare_icount_for_run(cpu);
353
+ icount_prepare_for_run(cpu);
354
}
355
- r = tcg_cpu_exec(cpu);
356
+ r = tcg_cpus_exec(cpu);
357
if (icount_enabled()) {
358
- process_icount_data(cpu);
359
+ icount_process_data(cpu);
360
}
361
qemu_mutex_lock_iothread();
362
363
@@ -XXX,XX +XXX,XX @@ static void *tcg_rr_cpu_thread_fn(void *arg)
364
} /* while (cpu && !cpu->exit_request).. */
365
366
/* Does not need qatomic_mb_set because a spurious wakeup is okay. */
367
- qatomic_set(&tcg_current_rr_cpu, NULL);
368
+ qatomic_set(&rr_current_cpu, NULL);
369
370
if (cpu && cpu->exit_request) {
371
qatomic_mb_set(&cpu->exit_request, 0);
372
@@ -XXX,XX +XXX,XX @@ static void *tcg_rr_cpu_thread_fn(void *arg)
373
qemu_notify_event();
374
}
375
376
- qemu_tcg_rr_wait_io_event();
377
- deal_with_unplugged_cpus();
378
+ rr_wait_io_event();
379
+ rr_deal_with_unplugged_cpus();
380
}
381
382
rcu_unregister_thread();
383
@@ -XXX,XX +XXX,XX @@ void rr_start_vcpu_thread(CPUState *cpu)
384
/* share a single thread for all cpus with TCG */
385
snprintf(thread_name, VCPU_THREAD_NAME_SIZE, "ALL CPUs/TCG");
386
qemu_thread_create(cpu->thread, thread_name,
387
- tcg_rr_cpu_thread_fn,
388
+ rr_cpu_thread_fn,
389
cpu, QEMU_THREAD_JOINABLE);
390
391
single_tcg_halt_cond = cpu->halt_cond;
392
@@ -XXX,XX +XXX,XX @@ void rr_start_vcpu_thread(CPUState *cpu)
393
394
const CpusAccel tcg_cpus_rr = {
395
.create_vcpu_thread = rr_start_vcpu_thread,
396
- .kick_vcpu_thread = qemu_cpu_kick_rr_cpus,
397
+ .kick_vcpu_thread = rr_kick_vcpu_thread,
398
399
- .handle_interrupt = tcg_handle_interrupt,
400
+ .handle_interrupt = tcg_cpus_handle_interrupt,
401
};
402
diff --git a/accel/tcg/tcg-cpus.c b/accel/tcg/tcg-cpus.c
403
index XXXXXXX..XXXXXXX 100644
404
--- a/accel/tcg/tcg-cpus.c
405
+++ b/accel/tcg/tcg-cpus.c
406
@@ -XXX,XX +XXX,XX @@
407
408
/* common functionality among all TCG variants */
409
410
-void qemu_tcg_destroy_vcpu(CPUState *cpu)
411
+void tcg_cpus_destroy(CPUState *cpu)
412
{
413
cpu_thread_signal_destroyed(cpu);
414
}
415
416
-int tcg_cpu_exec(CPUState *cpu)
417
+int tcg_cpus_exec(CPUState *cpu)
418
{
419
int ret;
420
#ifdef CONFIG_PROFILER
421
@@ -XXX,XX +XXX,XX @@ int tcg_cpu_exec(CPUState *cpu)
422
}
423
424
/* mask must never be zero, except for A20 change call */
425
-void tcg_handle_interrupt(CPUState *cpu, int mask)
426
+void tcg_cpus_handle_interrupt(CPUState *cpu, int mask)
427
{
428
g_assert(qemu_mutex_iothread_locked());
429
177
430
--
178
--
431
2.25.1
179
2.25.1
432
180
433
181
diff view generated by jsdifflib
New patch
[PULL 19/28] tcg/s390x: Implement tcg_out_mov for vector types
1
Reviewed-by: David Hildenbrand <david@redhat.com>
2
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
3
---
4
tcg/s390x/tcg-target.c.inc | 72 +++++++++++++++++++++++++++++++++++---
5
1 file changed, 68 insertions(+), 4 deletions(-)
1
6
7
diff --git a/tcg/s390x/tcg-target.c.inc b/tcg/s390x/tcg-target.c.inc
8
index XXXXXXX..XXXXXXX 100644
9
--- a/tcg/s390x/tcg-target.c.inc
10
+++ b/tcg/s390x/tcg-target.c.inc
11
@@ -XXX,XX +XXX,XX @@ typedef enum S390Opcode {
12
RX_STC = 0x42,
13
RX_STH = 0x40,
14
15
+ VRRa_VLR = 0xe756,
16
+
17
+ VRSb_VLVG = 0xe722,
18
+ VRSc_VLGV = 0xe721,
19
+
20
VRX_VL = 0xe706,
21
VRX_VLLEZ = 0xe704,
22
VRX_VST = 0xe70e,
23
@@ -XXX,XX +XXX,XX @@ static int RXB(TCGReg v1, TCGReg v2, TCGReg v3, TCGReg v4)
24
| ((v4 & 0x10) << (4 + 0));
25
}
26
27
+static void tcg_out_insn_VRRa(TCGContext *s, S390Opcode op,
28
+ TCGReg v1, TCGReg v2, int m3)
29
+{
30
+ tcg_debug_assert(is_vector_reg(v1));
31
+ tcg_debug_assert(is_vector_reg(v2));
32
+ tcg_out16(s, (op & 0xff00) | ((v1 & 0xf) << 4) | (v2 & 0xf));
33
+ tcg_out32(s, (op & 0x00ff) | RXB(v1, v2, 0, 0) | (m3 << 12));
34
+}
35
+
36
+static void tcg_out_insn_VRSb(TCGContext *s, S390Opcode op, TCGReg v1,
37
+ intptr_t d2, TCGReg b2, TCGReg r3, int m4)
38
+{
39
+ tcg_debug_assert(is_vector_reg(v1));
40
+ tcg_debug_assert(d2 >= 0 && d2 <= 0xfff);
41
+ tcg_debug_assert(is_general_reg(b2));
42
+ tcg_debug_assert(is_general_reg(r3));
43
+ tcg_out16(s, (op & 0xff00) | ((v1 & 0xf) << 4) | r3);
44
+ tcg_out16(s, b2 << 12 | d2);
45
+ tcg_out16(s, (op & 0x00ff) | RXB(v1, 0, 0, 0) | (m4 << 12));
46
+}
47
+
48
+static void tcg_out_insn_VRSc(TCGContext *s, S390Opcode op, TCGReg r1,
49
+ intptr_t d2, TCGReg b2, TCGReg v3, int m4)
50
+{
51
+ tcg_debug_assert(is_general_reg(r1));
52
+ tcg_debug_assert(d2 >= 0 && d2 <= 0xfff);
53
+ tcg_debug_assert(is_general_reg(b2));
54
+ tcg_debug_assert(is_vector_reg(v3));
55
+ tcg_out16(s, (op & 0xff00) | (r1 << 4) | (v3 & 0xf));
56
+ tcg_out16(s, b2 << 12 | d2);
57
+ tcg_out16(s, (op & 0x00ff) | RXB(0, 0, v3, 0) | (m4 << 12));
58
+}
59
+
60
static void tcg_out_insn_VRX(TCGContext *s, S390Opcode op, TCGReg v1,
61
TCGReg b2, TCGReg x2, intptr_t d2, int m3)
62
{
63
@@ -XXX,XX +XXX,XX @@ static void tcg_out_sh32(TCGContext* s, S390Opcode op, TCGReg dest,
64
65
static bool tcg_out_mov(TCGContext *s, TCGType type, TCGReg dst, TCGReg src)
66
{
67
- if (src != dst) {
68
- if (type == TCG_TYPE_I32) {
69
+ if (src == dst) {
70
+ return true;
71
+ }
72
+ switch (type) {
73
+ case TCG_TYPE_I32:
74
+ if (likely(is_general_reg(dst) && is_general_reg(src))) {
75
tcg_out_insn(s, RR, LR, dst, src);
76
- } else {
77
- tcg_out_insn(s, RRE, LGR, dst, src);
78
+ break;
79
}
80
+ /* fallthru */
81
+
82
+ case TCG_TYPE_I64:
83
+ if (likely(is_general_reg(dst))) {
84
+ if (likely(is_general_reg(src))) {
85
+ tcg_out_insn(s, RRE, LGR, dst, src);
86
+ } else {
87
+ tcg_out_insn(s, VRSc, VLGV, dst, 0, 0, src, 3);
88
+ }
89
+ break;
90
+ } else if (is_general_reg(src)) {
91
+ tcg_out_insn(s, VRSb, VLVG, dst, 0, 0, src, 3);
92
+ break;
93
+ }
94
+ /* fallthru */
95
+
96
+ case TCG_TYPE_V64:
97
+ case TCG_TYPE_V128:
98
+ tcg_out_insn(s, VRRa, VLR, dst, src, 0);
99
+ break;
100
+
101
+ default:
102
+ g_assert_not_reached();
103
}
104
return true;
105
}
106
--
107
2.25.1
108
109
diff view generated by jsdifflib
New patch
[PULL 20/28] tcg/s390x: Implement tcg_out_dup*_vec
1
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
2
---
3
tcg/s390x/tcg-target.c.inc | 122 ++++++++++++++++++++++++++++++++++++-
4
1 file changed, 119 insertions(+), 3 deletions(-)
1
5
6
diff --git a/tcg/s390x/tcg-target.c.inc b/tcg/s390x/tcg-target.c.inc
7
index XXXXXXX..XXXXXXX 100644
8
--- a/tcg/s390x/tcg-target.c.inc
9
+++ b/tcg/s390x/tcg-target.c.inc
10
@@ -XXX,XX +XXX,XX @@ typedef enum S390Opcode {
11
RX_STC = 0x42,
12
RX_STH = 0x40,
13
14
+ VRIa_VGBM = 0xe744,
15
+ VRIa_VREPI = 0xe745,
16
+ VRIb_VGM = 0xe746,
17
+ VRIc_VREP = 0xe74d,
18
+
19
VRRa_VLR = 0xe756,
20
+ VRRf_VLVGP = 0xe762,
21
22
VRSb_VLVG = 0xe722,
23
VRSc_VLGV = 0xe721,
24
25
VRX_VL = 0xe706,
26
VRX_VLLEZ = 0xe704,
27
+ VRX_VLREP = 0xe705,
28
VRX_VST = 0xe70e,
29
VRX_VSTEF = 0xe70b,
30
VRX_VSTEG = 0xe70a,
31
@@ -XXX,XX +XXX,XX @@ static int RXB(TCGReg v1, TCGReg v2, TCGReg v3, TCGReg v4)
32
| ((v4 & 0x10) << (4 + 0));
33
}
34
35
+static void tcg_out_insn_VRIa(TCGContext *s, S390Opcode op,
36
+ TCGReg v1, uint16_t i2, int m3)
37
+{
38
+ tcg_debug_assert(is_vector_reg(v1));
39
+ tcg_out16(s, (op & 0xff00) | ((v1 & 0xf) << 4));
40
+ tcg_out16(s, i2);
41
+ tcg_out16(s, (op & 0x00ff) | RXB(v1, 0, 0, 0) | (m3 << 12));
42
+}
43
+
44
+static void tcg_out_insn_VRIb(TCGContext *s, S390Opcode op,
45
+ TCGReg v1, uint8_t i2, uint8_t i3, int m4)
46
+{
47
+ tcg_debug_assert(is_vector_reg(v1));
48
+ tcg_out16(s, (op & 0xff00) | ((v1 & 0xf) << 4));
49
+ tcg_out16(s, (i2 << 8) | (i3 & 0xff));
50
+ tcg_out16(s, (op & 0x00ff) | RXB(v1, 0, 0, 0) | (m4 << 12));
51
+}
52
+
53
+static void tcg_out_insn_VRIc(TCGContext *s, S390Opcode op,
54
+ TCGReg v1, uint16_t i2, TCGReg v3, int m4)
55
+{
56
+ tcg_debug_assert(is_vector_reg(v1));
57
+ tcg_debug_assert(is_vector_reg(v3));
58
+ tcg_out16(s, (op & 0xff00) | ((v1 & 0xf) << 4) | (v3 & 0xf));
59
+ tcg_out16(s, i2);
60
+ tcg_out16(s, (op & 0x00ff) | RXB(v1, 0, v3, 0) | (m4 << 12));
61
+}
62
+
63
static void tcg_out_insn_VRRa(TCGContext *s, S390Opcode op,
64
TCGReg v1, TCGReg v2, int m3)
65
{
66
@@ -XXX,XX +XXX,XX @@ static void tcg_out_insn_VRRa(TCGContext *s, S390Opcode op,
67
tcg_out32(s, (op & 0x00ff) | RXB(v1, v2, 0, 0) | (m3 << 12));
68
}
69
70
+static void tcg_out_insn_VRRf(TCGContext *s, S390Opcode op,
71
+ TCGReg v1, TCGReg r2, TCGReg r3)
72
+{
73
+ tcg_debug_assert(is_vector_reg(v1));
74
+ tcg_debug_assert(is_general_reg(r2));
75
+ tcg_debug_assert(is_general_reg(r3));
76
+ tcg_out16(s, (op & 0xff00) | ((v1 & 0xf) << 4) | r2);
77
+ tcg_out16(s, r3 << 12);
78
+ tcg_out16(s, (op & 0x00ff) | RXB(v1, 0, 0, 0));
79
+}
80
+
81
static void tcg_out_insn_VRSb(TCGContext *s, S390Opcode op, TCGReg v1,
82
intptr_t d2, TCGReg b2, TCGReg r3, int m4)
83
{
84
@@ -XXX,XX +XXX,XX @@ static inline void tcg_out_op(TCGContext *s, TCGOpcode opc,
85
static bool tcg_out_dup_vec(TCGContext *s, TCGType type, unsigned vece,
86
TCGReg dst, TCGReg src)
87
{
88
- g_assert_not_reached();
89
+ if (is_general_reg(src)) {
90
+ /* Replicate general register into two MO_64. */
91
+ tcg_out_insn(s, VRRf, VLVGP, dst, src, src);
92
+ if (vece == MO_64) {
93
+ return true;
94
+ }
95
+ }
96
+
97
+ /*
98
+ * Recall that the "standard" integer, within a vector, is the
99
+ * rightmost element of the leftmost doubleword, a-la VLLEZ.
100
+ */
101
+ tcg_out_insn(s, VRIc, VREP, dst, (8 >> vece) - 1, src, vece);
102
+ return true;
103
}
104
105
static bool tcg_out_dupm_vec(TCGContext *s, TCGType type, unsigned vece,
106
TCGReg dst, TCGReg base, intptr_t offset)
107
{
108
- g_assert_not_reached();
109
+ tcg_out_vrx_mem(s, VRX_VLREP, dst, base, TCG_REG_NONE, offset, vece);
110
+ return true;
111
}
112
113
static void tcg_out_dupi_vec(TCGContext *s, TCGType type, unsigned vece,
114
TCGReg dst, int64_t val)
115
{
116
- g_assert_not_reached();
117
+ int i, mask, msb, lsb;
118
+
119
+ /* Look for int16_t elements. */
120
+ if (vece <= MO_16 ||
121
+ (vece == MO_32 ? (int32_t)val : val) == (int16_t)val) {
122
+ tcg_out_insn(s, VRIa, VREPI, dst, val, vece);
123
+ return;
124
+ }
125
+
126
+ /* Look for bit masks. */
127
+ if (vece == MO_32) {
128
+ if (risbg_mask((int32_t)val)) {
129
+ /* Handle wraparound by swapping msb and lsb. */
130
+ if ((val & 0x80000001u) == 0x80000001u) {
131
+ msb = 32 - ctz32(~val);
132
+ lsb = clz32(~val) - 1;
133
+ } else {
134
+ msb = clz32(val);
135
+ lsb = 31 - ctz32(val);
136
+ }
137
+ tcg_out_insn(s, VRIb, VGM, dst, lsb, msb, MO_32);
138
+ return;
139
+ }
140
+ } else {
141
+ if (risbg_mask(val)) {
142
+ /* Handle wraparound by swapping msb and lsb. */
143
+ if ((val & 0x8000000000000001ull) == 0x8000000000000001ull) {
144
+ /* Handle wraparound by swapping msb and lsb. */
145
+ msb = 64 - ctz64(~val);
146
+ lsb = clz64(~val) - 1;
147
+ } else {
148
+ msb = clz64(val);
149
+ lsb = 63 - ctz64(val);
150
+ }
151
+ tcg_out_insn(s, VRIb, VGM, dst, lsb, msb, MO_64);
152
+ return;
153
+ }
154
+ }
155
+
156
+ /* Look for all bytes 0x00 or 0xff. */
157
+ for (i = mask = 0; i < 8; i++) {
158
+ uint8_t byte = val >> (i * 8);
159
+ if (byte == 0xff) {
160
+ mask |= 1 << i;
161
+ } else if (byte != 0) {
162
+ break;
163
+ }
164
+ }
165
+ if (i == 8) {
166
+ tcg_out_insn(s, VRIa, VGBM, dst, mask * 0x0101, 0);
167
+ return;
168
+ }
169
+
170
+ /* Otherwise, stuff it in the constant pool. */
171
+ tcg_out_insn(s, RIL, LARL, TCG_TMP0, 0);
172
+ new_pool_label(s, val, R_390_PC32DBL, s->code_ptr - 2, 2);
173
+ tcg_out_insn(s, VRX, VLREP, dst, TCG_TMP0, TCG_REG_NONE, 0, MO_64);
174
}
175
176
static void tcg_out_vec_op(TCGContext *s, TCGOpcode opc,
177
--
178
2.25.1
179
180
diff view generated by jsdifflib
New patch
[PULL 21/28] tcg/s390x: Implement minimal vector operations
1
1
Implementing add, sub, and, or, xor as the minimal set.
2
This allows us to actually enable vectors in query_s390_facilities.
3
4
Reviewed-by: David Hildenbrand <david@redhat.com>
5
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
6
---
7
tcg/s390x/tcg-target.c.inc | 154 ++++++++++++++++++++++++++++++++++++-
8
1 file changed, 150 insertions(+), 4 deletions(-)
9
10
diff --git a/tcg/s390x/tcg-target.c.inc b/tcg/s390x/tcg-target.c.inc
11
index XXXXXXX..XXXXXXX 100644
12
--- a/tcg/s390x/tcg-target.c.inc
13
+++ b/tcg/s390x/tcg-target.c.inc
14
@@ -XXX,XX +XXX,XX @@ typedef enum S390Opcode {
15
VRIc_VREP = 0xe74d,
16
17
VRRa_VLR = 0xe756,
18
+ VRRc_VA = 0xe7f3,
19
+ VRRc_VCEQ = 0xe7f8, /* we leave the m5 cs field 0 */
20
+ VRRc_VCH = 0xe7fb, /* " */
21
+ VRRc_VCHL = 0xe7f9, /* " */
22
+ VRRc_VN = 0xe768,
23
+ VRRc_VO = 0xe76a,
24
+ VRRc_VS = 0xe7f7,
25
+ VRRc_VX = 0xe76d,
26
VRRf_VLVGP = 0xe762,
27
28
VRSb_VLVG = 0xe722,
29
@@ -XXX,XX +XXX,XX @@ static void tcg_out_insn_VRRa(TCGContext *s, S390Opcode op,
30
tcg_out32(s, (op & 0x00ff) | RXB(v1, v2, 0, 0) | (m3 << 12));
31
}
32
33
+static void tcg_out_insn_VRRc(TCGContext *s, S390Opcode op,
34
+ TCGReg v1, TCGReg v2, TCGReg v3, int m4)
35
+{
36
+ tcg_debug_assert(is_vector_reg(v1));
37
+ tcg_debug_assert(is_vector_reg(v2));
38
+ tcg_debug_assert(is_vector_reg(v3));
39
+ tcg_out16(s, (op & 0xff00) | ((v1 & 0xf) << 4) | (v2 & 0xf));
40
+ tcg_out16(s, v3 << 12);
41
+ tcg_out16(s, (op & 0x00ff) | RXB(v1, v2, v3, 0) | (m4 << 12));
42
+}
43
+
44
static void tcg_out_insn_VRRf(TCGContext *s, S390Opcode op,
45
TCGReg v1, TCGReg r2, TCGReg r3)
46
{
47
@@ -XXX,XX +XXX,XX @@ static void tcg_out_vec_op(TCGContext *s, TCGOpcode opc,
48
unsigned vecl, unsigned vece,
49
const TCGArg *args, const int *const_args)
50
{
51
- g_assert_not_reached();
52
+ TCGType type = vecl + TCG_TYPE_V64;
53
+ TCGArg a0 = args[0], a1 = args[1], a2 = args[2];
54
+
55
+ switch (opc) {
56
+ case INDEX_op_ld_vec:
57
+ tcg_out_ld(s, type, a0, a1, a2);
58
+ break;
59
+ case INDEX_op_st_vec:
60
+ tcg_out_st(s, type, a0, a1, a2);
61
+ break;
62
+ case INDEX_op_dupm_vec:
63
+ tcg_out_dupm_vec(s, type, vece, a0, a1, a2);
64
+ break;
65
+
66
+ case INDEX_op_add_vec:
67
+ tcg_out_insn(s, VRRc, VA, a0, a1, a2, vece);
68
+ break;
69
+ case INDEX_op_sub_vec:
70
+ tcg_out_insn(s, VRRc, VS, a0, a1, a2, vece);
71
+ break;
72
+ case INDEX_op_and_vec:
73
+ tcg_out_insn(s, VRRc, VN, a0, a1, a2, 0);
74
+ break;
75
+ case INDEX_op_or_vec:
76
+ tcg_out_insn(s, VRRc, VO, a0, a1, a2, 0);
77
+ break;
78
+ case INDEX_op_xor_vec:
79
+ tcg_out_insn(s, VRRc, VX, a0, a1, a2, 0);
80
+ break;
81
+
82
+ case INDEX_op_cmp_vec:
83
+ switch ((TCGCond)args[3]) {
84
+ case TCG_COND_EQ:
85
+ tcg_out_insn(s, VRRc, VCEQ, a0, a1, a2, vece);
86
+ break;
87
+ case TCG_COND_GT:
88
+ tcg_out_insn(s, VRRc, VCH, a0, a1, a2, vece);
89
+ break;
90
+ case TCG_COND_GTU:
91
+ tcg_out_insn(s, VRRc, VCHL, a0, a1, a2, vece);
92
+ break;
93
+ default:
94
+ g_assert_not_reached();
95
+ }
96
+ break;
97
+
98
+ case INDEX_op_mov_vec: /* Always emitted via tcg_out_mov. */
99
+ case INDEX_op_dup_vec: /* Always emitted via tcg_out_dup_vec. */
100
+ default:
101
+ g_assert_not_reached();
102
+ }
103
}
104
105
int tcg_can_emit_vec_op(TCGOpcode opc, TCGType type, unsigned vece)
106
{
107
- return 0;
108
+ switch (opc) {
109
+ case INDEX_op_add_vec:
110
+ case INDEX_op_and_vec:
111
+ case INDEX_op_or_vec:
112
+ case INDEX_op_sub_vec:
113
+ case INDEX_op_xor_vec:
114
+ return 1;
115
+ case INDEX_op_cmp_vec:
116
+ return -1;
117
+ default:
118
+ return 0;
119
+ }
120
+}
121
+
122
+static bool expand_vec_cmp_noinv(TCGType type, unsigned vece, TCGv_vec v0,
123
+ TCGv_vec v1, TCGv_vec v2, TCGCond cond)
124
+{
125
+ bool need_swap = false, need_inv = false;
126
+
127
+ switch (cond) {
128
+ case TCG_COND_EQ:
129
+ case TCG_COND_GT:
130
+ case TCG_COND_GTU:
131
+ break;
132
+ case TCG_COND_NE:
133
+ case TCG_COND_LE:
134
+ case TCG_COND_LEU:
135
+ need_inv = true;
136
+ break;
137
+ case TCG_COND_LT:
138
+ case TCG_COND_LTU:
139
+ need_swap = true;
140
+ break;
141
+ case TCG_COND_GE:
142
+ case TCG_COND_GEU:
143
+ need_swap = need_inv = true;
144
+ break;
145
+ default:
146
+ g_assert_not_reached();
147
+ }
148
+
149
+ if (need_inv) {
150
+ cond = tcg_invert_cond(cond);
151
+ }
152
+ if (need_swap) {
153
+ TCGv_vec t1;
154
+ t1 = v1, v1 = v2, v2 = t1;
155
+ cond = tcg_swap_cond(cond);
156
+ }
157
+
158
+ vec_gen_4(INDEX_op_cmp_vec, type, vece, tcgv_vec_arg(v0),
159
+ tcgv_vec_arg(v1), tcgv_vec_arg(v2), cond);
160
+
161
+ return need_inv;
162
+}
163
+
164
+static void expand_vec_cmp(TCGType type, unsigned vece, TCGv_vec v0,
165
+ TCGv_vec v1, TCGv_vec v2, TCGCond cond)
166
+{
167
+ if (expand_vec_cmp_noinv(type, vece, v0, v1, v2, cond)) {
168
+ tcg_gen_not_vec(vece, v0, v0);
169
+ }
170
}
171
172
void tcg_expand_vec_op(TCGOpcode opc, TCGType type, unsigned vece,
173
TCGArg a0, ...)
174
{
175
- g_assert_not_reached();
176
+ va_list va;
177
+ TCGv_vec v0, v1, v2;
178
+
179
+ va_start(va, a0);
180
+ v0 = temp_tcgv_vec(arg_temp(a0));
181
+ v1 = temp_tcgv_vec(arg_temp(va_arg(va, TCGArg)));
182
+ v2 = temp_tcgv_vec(arg_temp(va_arg(va, TCGArg)));
183
+
184
+ switch (opc) {
185
+ case INDEX_op_cmp_vec:
186
+ expand_vec_cmp(type, vece, v0, v1, v2, va_arg(va, TCGArg));
187
+ break;
188
+
189
+ default:
190
+ g_assert_not_reached();
191
+ }
192
+ va_end(va);
193
}
194
195
static TCGConstraintSetIndex tcg_target_op_def(TCGOpcode op)
196
@@ -XXX,XX +XXX,XX @@ static void query_s390_facilities(void)
197
* There is nothing else we currently care about in the 3rd word, so
198
* disable VECTOR with one store.
199
*/
200
- if (1 || !(hwcap & HWCAP_S390_VXRS)) {
201
+ if (!(hwcap & HWCAP_S390_VXRS)) {
202
s390_facilities[2] = 0;
203
}
204
}
205
--
206
2.25.1
207
208
diff view generated by jsdifflib
New patch
[PULL 22/28] tcg/s390x: Implement andc, orc, abs, neg, not vector operations
1
These logical and arithmetic operations are optional but trivial.
1
2
3
Reviewed-by: David Hildenbrand <david@redhat.com>
4
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
5
---
6
tcg/s390x/tcg-target-con-set.h | 1 +
7
tcg/s390x/tcg-target.h | 11 ++++++-----
8
tcg/s390x/tcg-target.c.inc | 32 ++++++++++++++++++++++++++++++++
9
3 files changed, 39 insertions(+), 5 deletions(-)
10
11
diff --git a/tcg/s390x/tcg-target-con-set.h b/tcg/s390x/tcg-target-con-set.h
12
index XXXXXXX..XXXXXXX 100644
13
--- a/tcg/s390x/tcg-target-con-set.h
14
+++ b/tcg/s390x/tcg-target-con-set.h
15
@@ -XXX,XX +XXX,XX @@ C_O0_I2(v, r)
16
C_O1_I1(r, L)
17
C_O1_I1(r, r)
18
C_O1_I1(v, r)
19
+C_O1_I1(v, v)
20
C_O1_I1(v, vr)
21
C_O1_I2(r, 0, ri)
22
C_O1_I2(r, 0, rI)
23
diff --git a/tcg/s390x/tcg-target.h b/tcg/s390x/tcg-target.h
24
index XXXXXXX..XXXXXXX 100644
25
--- a/tcg/s390x/tcg-target.h
26
+++ b/tcg/s390x/tcg-target.h
27
@@ -XXX,XX +XXX,XX @@ typedef enum TCGReg {
28
#define FACILITY_DISTINCT_OPS FACILITY_LOAD_ON_COND
29
#define FACILITY_LOAD_ON_COND2 53
30
#define FACILITY_VECTOR 129
31
+#define FACILITY_VECTOR_ENH1 135
32
33
extern uint64_t s390_facilities[3];
34
35
@@ -XXX,XX +XXX,XX @@ extern uint64_t s390_facilities[3];
36
#define TCG_TARGET_HAS_v128 HAVE_FACILITY(VECTOR)
37
#define TCG_TARGET_HAS_v256 0
38
39
-#define TCG_TARGET_HAS_andc_vec 0
40
-#define TCG_TARGET_HAS_orc_vec 0
41
-#define TCG_TARGET_HAS_not_vec 0
42
-#define TCG_TARGET_HAS_neg_vec 0
43
-#define TCG_TARGET_HAS_abs_vec 0
44
+#define TCG_TARGET_HAS_andc_vec 1
45
+#define TCG_TARGET_HAS_orc_vec HAVE_FACILITY(VECTOR_ENH1)
46
+#define TCG_TARGET_HAS_not_vec 1
47
+#define TCG_TARGET_HAS_neg_vec 1
48
+#define TCG_TARGET_HAS_abs_vec 1
49
#define TCG_TARGET_HAS_roti_vec 0
50
#define TCG_TARGET_HAS_rots_vec 0
51
#define TCG_TARGET_HAS_rotv_vec 0
52
diff --git a/tcg/s390x/tcg-target.c.inc b/tcg/s390x/tcg-target.c.inc
53
index XXXXXXX..XXXXXXX 100644
54
--- a/tcg/s390x/tcg-target.c.inc
55
+++ b/tcg/s390x/tcg-target.c.inc
56
@@ -XXX,XX +XXX,XX @@ typedef enum S390Opcode {
57
VRIb_VGM = 0xe746,
58
VRIc_VREP = 0xe74d,
59
60
+ VRRa_VLC = 0xe7de,
61
+ VRRa_VLP = 0xe7df,
62
VRRa_VLR = 0xe756,
63
VRRc_VA = 0xe7f3,
64
VRRc_VCEQ = 0xe7f8, /* we leave the m5 cs field 0 */
65
VRRc_VCH = 0xe7fb, /* " */
66
VRRc_VCHL = 0xe7f9, /* " */
67
VRRc_VN = 0xe768,
68
+ VRRc_VNC = 0xe769,
69
+ VRRc_VNO = 0xe76b,
70
VRRc_VO = 0xe76a,
71
+ VRRc_VOC = 0xe76f,
72
VRRc_VS = 0xe7f7,
73
VRRc_VX = 0xe76d,
74
VRRf_VLVGP = 0xe762,
75
@@ -XXX,XX +XXX,XX @@ static void tcg_out_vec_op(TCGContext *s, TCGOpcode opc,
76
tcg_out_dupm_vec(s, type, vece, a0, a1, a2);
77
break;
78
79
+ case INDEX_op_abs_vec:
80
+ tcg_out_insn(s, VRRa, VLP, a0, a1, vece);
81
+ break;
82
+ case INDEX_op_neg_vec:
83
+ tcg_out_insn(s, VRRa, VLC, a0, a1, vece);
84
+ break;
85
+ case INDEX_op_not_vec:
86
+ tcg_out_insn(s, VRRc, VNO, a0, a1, a1, 0);
87
+ break;
88
+
89
case INDEX_op_add_vec:
90
tcg_out_insn(s, VRRc, VA, a0, a1, a2, vece);
91
break;
92
@@ -XXX,XX +XXX,XX @@ static void tcg_out_vec_op(TCGContext *s, TCGOpcode opc,
93
case INDEX_op_and_vec:
94
tcg_out_insn(s, VRRc, VN, a0, a1, a2, 0);
95
break;
96
+ case INDEX_op_andc_vec:
97
+ tcg_out_insn(s, VRRc, VNC, a0, a1, a2, 0);
98
+ break;
99
case INDEX_op_or_vec:
100
tcg_out_insn(s, VRRc, VO, a0, a1, a2, 0);
101
break;
102
+ case INDEX_op_orc_vec:
103
+ tcg_out_insn(s, VRRc, VOC, a0, a1, a2, 0);
104
+ break;
105
case INDEX_op_xor_vec:
106
tcg_out_insn(s, VRRc, VX, a0, a1, a2, 0);
107
break;
108
@@ -XXX,XX +XXX,XX @@ static void tcg_out_vec_op(TCGContext *s, TCGOpcode opc,
109
int tcg_can_emit_vec_op(TCGOpcode opc, TCGType type, unsigned vece)
110
{
111
switch (opc) {
112
+ case INDEX_op_abs_vec:
113
case INDEX_op_add_vec:
114
case INDEX_op_and_vec:
115
+ case INDEX_op_andc_vec:
116
+ case INDEX_op_neg_vec:
117
+ case INDEX_op_not_vec:
118
case INDEX_op_or_vec:
119
+ case INDEX_op_orc_vec:
120
case INDEX_op_sub_vec:
121
case INDEX_op_xor_vec:
122
return 1;
123
@@ -XXX,XX +XXX,XX @@ static TCGConstraintSetIndex tcg_target_op_def(TCGOpcode op)
124
return C_O1_I1(v, r);
125
case INDEX_op_dup_vec:
126
return C_O1_I1(v, vr);
127
+ case INDEX_op_abs_vec:
128
+ case INDEX_op_neg_vec:
129
+ case INDEX_op_not_vec:
130
+ return C_O1_I1(v, v);
131
case INDEX_op_add_vec:
132
case INDEX_op_sub_vec:
133
case INDEX_op_and_vec:
134
+ case INDEX_op_andc_vec:
135
case INDEX_op_or_vec:
136
+ case INDEX_op_orc_vec:
137
case INDEX_op_xor_vec:
138
case INDEX_op_cmp_vec:
139
return C_O1_I2(v, v, v);
140
--
141
2.25.1
142
143
diff view generated by jsdifflib
New patch
[PULL 23/28] tcg/s390x: Implement TCG_TARGET_HAS_mul_vec
1
Reviewed-by: David Hildenbrand <david@redhat.com>
2
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
3
---
4
tcg/s390x/tcg-target.h | 2 +-
5
tcg/s390x/tcg-target.c.inc | 7 +++++++
6
2 files changed, 8 insertions(+), 1 deletion(-)
1
7
8
diff --git a/tcg/s390x/tcg-target.h b/tcg/s390x/tcg-target.h
9
index XXXXXXX..XXXXXXX 100644
10
--- a/tcg/s390x/tcg-target.h
11
+++ b/tcg/s390x/tcg-target.h
12
@@ -XXX,XX +XXX,XX @@ extern uint64_t s390_facilities[3];
13
#define TCG_TARGET_HAS_shi_vec 0
14
#define TCG_TARGET_HAS_shs_vec 0
15
#define TCG_TARGET_HAS_shv_vec 0
16
-#define TCG_TARGET_HAS_mul_vec 0
17
+#define TCG_TARGET_HAS_mul_vec 1
18
#define TCG_TARGET_HAS_sat_vec 0
19
#define TCG_TARGET_HAS_minmax_vec 0
20
#define TCG_TARGET_HAS_bitsel_vec 0
21
diff --git a/tcg/s390x/tcg-target.c.inc b/tcg/s390x/tcg-target.c.inc
22
index XXXXXXX..XXXXXXX 100644
23
--- a/tcg/s390x/tcg-target.c.inc
24
+++ b/tcg/s390x/tcg-target.c.inc
25
@@ -XXX,XX +XXX,XX @@ typedef enum S390Opcode {
26
VRRc_VCEQ = 0xe7f8, /* we leave the m5 cs field 0 */
27
VRRc_VCH = 0xe7fb, /* " */
28
VRRc_VCHL = 0xe7f9, /* " */
29
+ VRRc_VML = 0xe7a2,
30
VRRc_VN = 0xe768,
31
VRRc_VNC = 0xe769,
32
VRRc_VNO = 0xe76b,
33
@@ -XXX,XX +XXX,XX @@ static void tcg_out_vec_op(TCGContext *s, TCGOpcode opc,
34
case INDEX_op_andc_vec:
35
tcg_out_insn(s, VRRc, VNC, a0, a1, a2, 0);
36
break;
37
+ case INDEX_op_mul_vec:
38
+ tcg_out_insn(s, VRRc, VML, a0, a1, a2, vece);
39
+ break;
40
case INDEX_op_or_vec:
41
tcg_out_insn(s, VRRc, VO, a0, a1, a2, 0);
42
break;
43
@@ -XXX,XX +XXX,XX @@ int tcg_can_emit_vec_op(TCGOpcode opc, TCGType type, unsigned vece)
44
return 1;
45
case INDEX_op_cmp_vec:
46
return -1;
47
+ case INDEX_op_mul_vec:
48
+ return vece < MO_64;
49
default:
50
return 0;
51
}
52
@@ -XXX,XX +XXX,XX @@ static TCGConstraintSetIndex tcg_target_op_def(TCGOpcode op)
53
case INDEX_op_orc_vec:
54
case INDEX_op_xor_vec:
55
case INDEX_op_cmp_vec:
56
+ case INDEX_op_mul_vec:
57
return C_O1_I2(v, v, v);
58
59
default:
60
--
61
2.25.1
62
63
diff view generated by jsdifflib
New patch
[PULL 24/28] tcg/s390x: Implement vector shift operations
1
Reviewed-by: David Hildenbrand <david@redhat.com>
2
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
3
---
4
tcg/s390x/tcg-target-con-set.h | 1 +
5
tcg/s390x/tcg-target.h | 12 ++---
6
tcg/s390x/tcg-target.c.inc | 93 +++++++++++++++++++++++++++++++++-
7
3 files changed, 99 insertions(+), 7 deletions(-)
1
8
9
diff --git a/tcg/s390x/tcg-target-con-set.h b/tcg/s390x/tcg-target-con-set.h
10
index XXXXXXX..XXXXXXX 100644
11
--- a/tcg/s390x/tcg-target-con-set.h
12
+++ b/tcg/s390x/tcg-target-con-set.h
13
@@ -XXX,XX +XXX,XX @@ C_O1_I2(r, 0, rI)
14
C_O1_I2(r, 0, rJ)
15
C_O1_I2(r, r, ri)
16
C_O1_I2(r, rZ, r)
17
+C_O1_I2(v, v, r)
18
C_O1_I2(v, v, v)
19
C_O1_I4(r, r, ri, r, 0)
20
C_O1_I4(r, r, ri, rI, 0)
21
diff --git a/tcg/s390x/tcg-target.h b/tcg/s390x/tcg-target.h
22
index XXXXXXX..XXXXXXX 100644
23
--- a/tcg/s390x/tcg-target.h
24
+++ b/tcg/s390x/tcg-target.h
25
@@ -XXX,XX +XXX,XX @@ extern uint64_t s390_facilities[3];
26
#define TCG_TARGET_HAS_not_vec 1
27
#define TCG_TARGET_HAS_neg_vec 1
28
#define TCG_TARGET_HAS_abs_vec 1
29
-#define TCG_TARGET_HAS_roti_vec 0
30
-#define TCG_TARGET_HAS_rots_vec 0
31
-#define TCG_TARGET_HAS_rotv_vec 0
32
-#define TCG_TARGET_HAS_shi_vec 0
33
-#define TCG_TARGET_HAS_shs_vec 0
34
-#define TCG_TARGET_HAS_shv_vec 0
35
+#define TCG_TARGET_HAS_roti_vec 1
36
+#define TCG_TARGET_HAS_rots_vec 1
37
+#define TCG_TARGET_HAS_rotv_vec 1
38
+#define TCG_TARGET_HAS_shi_vec 1
39
+#define TCG_TARGET_HAS_shs_vec 1
40
+#define TCG_TARGET_HAS_shv_vec 1
41
#define TCG_TARGET_HAS_mul_vec 1
42
#define TCG_TARGET_HAS_sat_vec 0
43
#define TCG_TARGET_HAS_minmax_vec 0
44
diff --git a/tcg/s390x/tcg-target.c.inc b/tcg/s390x/tcg-target.c.inc
45
index XXXXXXX..XXXXXXX 100644
46
--- a/tcg/s390x/tcg-target.c.inc
47
+++ b/tcg/s390x/tcg-target.c.inc
48
@@ -XXX,XX +XXX,XX @@ typedef enum S390Opcode {
49
VRRc_VCEQ = 0xe7f8, /* we leave the m5 cs field 0 */
50
VRRc_VCH = 0xe7fb, /* " */
51
VRRc_VCHL = 0xe7f9, /* " */
52
+ VRRc_VERLLV = 0xe773,
53
+ VRRc_VESLV = 0xe770,
54
+ VRRc_VESRAV = 0xe77a,
55
+ VRRc_VESRLV = 0xe778,
56
VRRc_VML = 0xe7a2,
57
VRRc_VN = 0xe768,
58
VRRc_VNC = 0xe769,
59
@@ -XXX,XX +XXX,XX @@ typedef enum S390Opcode {
60
VRRc_VX = 0xe76d,
61
VRRf_VLVGP = 0xe762,
62
63
+ VRSa_VERLL = 0xe733,
64
+ VRSa_VESL = 0xe730,
65
+ VRSa_VESRA = 0xe73a,
66
+ VRSa_VESRL = 0xe738,
67
VRSb_VLVG = 0xe722,
68
VRSc_VLGV = 0xe721,
69
70
@@ -XXX,XX +XXX,XX @@ static void tcg_out_insn_VRRf(TCGContext *s, S390Opcode op,
71
tcg_out16(s, (op & 0x00ff) | RXB(v1, 0, 0, 0));
72
}
73
74
+static void tcg_out_insn_VRSa(TCGContext *s, S390Opcode op, TCGReg v1,
75
+ intptr_t d2, TCGReg b2, TCGReg v3, int m4)
76
+{
77
+ tcg_debug_assert(is_vector_reg(v1));
78
+ tcg_debug_assert(d2 >= 0 && d2 <= 0xfff);
79
+ tcg_debug_assert(is_general_reg(b2));
80
+ tcg_debug_assert(is_vector_reg(v3));
81
+ tcg_out16(s, (op & 0xff00) | ((v1 & 0xf) << 4) | (v3 & 0xf));
82
+ tcg_out16(s, b2 << 12 | d2);
83
+ tcg_out16(s, (op & 0x00ff) | RXB(v1, 0, v3, 0) | (m4 << 12));
84
+}
85
+
86
static void tcg_out_insn_VRSb(TCGContext *s, S390Opcode op, TCGReg v1,
87
intptr_t d2, TCGReg b2, TCGReg r3, int m4)
88
{
89
@@ -XXX,XX +XXX,XX @@ static void tcg_out_vec_op(TCGContext *s, TCGOpcode opc,
90
tcg_out_insn(s, VRRc, VX, a0, a1, a2, 0);
91
break;
92
93
+ case INDEX_op_shli_vec:
94
+ tcg_out_insn(s, VRSa, VESL, a0, a2, TCG_REG_NONE, a1, vece);
95
+ break;
96
+ case INDEX_op_shri_vec:
97
+ tcg_out_insn(s, VRSa, VESRL, a0, a2, TCG_REG_NONE, a1, vece);
98
+ break;
99
+ case INDEX_op_sari_vec:
100
+ tcg_out_insn(s, VRSa, VESRA, a0, a2, TCG_REG_NONE, a1, vece);
101
+ break;
102
+ case INDEX_op_rotli_vec:
103
+ tcg_out_insn(s, VRSa, VERLL, a0, a2, TCG_REG_NONE, a1, vece);
104
+ break;
105
+ case INDEX_op_shls_vec:
106
+ tcg_out_insn(s, VRSa, VESL, a0, 0, a2, a1, vece);
107
+ break;
108
+ case INDEX_op_shrs_vec:
109
+ tcg_out_insn(s, VRSa, VESRL, a0, 0, a2, a1, vece);
110
+ break;
111
+ case INDEX_op_sars_vec:
112
+ tcg_out_insn(s, VRSa, VESRA, a0, 0, a2, a1, vece);
113
+ break;
114
+ case INDEX_op_rotls_vec:
115
+ tcg_out_insn(s, VRSa, VERLL, a0, 0, a2, a1, vece);
116
+ break;
117
+ case INDEX_op_shlv_vec:
118
+ tcg_out_insn(s, VRRc, VESLV, a0, a1, a2, vece);
119
+ break;
120
+ case INDEX_op_shrv_vec:
121
+ tcg_out_insn(s, VRRc, VESRLV, a0, a1, a2, vece);
122
+ break;
123
+ case INDEX_op_sarv_vec:
124
+ tcg_out_insn(s, VRRc, VESRAV, a0, a1, a2, vece);
125
+ break;
126
+ case INDEX_op_rotlv_vec:
127
+ tcg_out_insn(s, VRRc, VERLLV, a0, a1, a2, vece);
128
+ break;
129
+
130
case INDEX_op_cmp_vec:
131
switch ((TCGCond)args[3]) {
132
case TCG_COND_EQ:
133
@@ -XXX,XX +XXX,XX @@ int tcg_can_emit_vec_op(TCGOpcode opc, TCGType type, unsigned vece)
134
case INDEX_op_not_vec:
135
case INDEX_op_or_vec:
136
case INDEX_op_orc_vec:
137
+ case INDEX_op_rotli_vec:
138
+ case INDEX_op_rotls_vec:
139
+ case INDEX_op_rotlv_vec:
140
+ case INDEX_op_sari_vec:
141
+ case INDEX_op_sars_vec:
142
+ case INDEX_op_sarv_vec:
143
+ case INDEX_op_shli_vec:
144
+ case INDEX_op_shls_vec:
145
+ case INDEX_op_shlv_vec:
146
+ case INDEX_op_shri_vec:
147
+ case INDEX_op_shrs_vec:
148
+ case INDEX_op_shrv_vec:
149
case INDEX_op_sub_vec:
150
case INDEX_op_xor_vec:
151
return 1;
152
case INDEX_op_cmp_vec:
153
+ case INDEX_op_rotrv_vec:
154
return -1;
155
case INDEX_op_mul_vec:
156
return vece < MO_64;
157
@@ -XXX,XX +XXX,XX @@ void tcg_expand_vec_op(TCGOpcode opc, TCGType type, unsigned vece,
158
TCGArg a0, ...)
159
{
160
va_list va;
161
- TCGv_vec v0, v1, v2;
162
+ TCGv_vec v0, v1, v2, t0;
163
164
va_start(va, a0);
165
v0 = temp_tcgv_vec(arg_temp(a0));
166
@@ -XXX,XX +XXX,XX @@ void tcg_expand_vec_op(TCGOpcode opc, TCGType type, unsigned vece,
167
expand_vec_cmp(type, vece, v0, v1, v2, va_arg(va, TCGArg));
168
break;
169
170
+ case INDEX_op_rotrv_vec:
171
+ t0 = tcg_temp_new_vec(type);
172
+ tcg_gen_neg_vec(vece, t0, v2);
173
+ tcg_gen_rotlv_vec(vece, v0, v1, t0);
174
+ tcg_temp_free_vec(t0);
175
+ break;
176
+
177
default:
178
g_assert_not_reached();
179
}
180
@@ -XXX,XX +XXX,XX @@ static TCGConstraintSetIndex tcg_target_op_def(TCGOpcode op)
181
case INDEX_op_abs_vec:
182
case INDEX_op_neg_vec:
183
case INDEX_op_not_vec:
184
+ case INDEX_op_rotli_vec:
185
+ case INDEX_op_sari_vec:
186
+ case INDEX_op_shli_vec:
187
+ case INDEX_op_shri_vec:
188
return C_O1_I1(v, v);
189
case INDEX_op_add_vec:
190
case INDEX_op_sub_vec:
191
@@ -XXX,XX +XXX,XX @@ static TCGConstraintSetIndex tcg_target_op_def(TCGOpcode op)
192
case INDEX_op_xor_vec:
193
case INDEX_op_cmp_vec:
194
case INDEX_op_mul_vec:
195
+ case INDEX_op_rotlv_vec:
196
+ case INDEX_op_rotrv_vec:
197
+ case INDEX_op_shlv_vec:
198
+ case INDEX_op_shrv_vec:
199
+ case INDEX_op_sarv_vec:
200
return C_O1_I2(v, v, v);
201
+ case INDEX_op_rotls_vec:
202
+ case INDEX_op_shls_vec:
203
+ case INDEX_op_shrs_vec:
204
+ case INDEX_op_sars_vec:
205
+ return C_O1_I2(v, v, r);
206
207
default:
208
g_assert_not_reached();
209
--
210
2.25.1
211
212
diff view generated by jsdifflib
New patch
[PULL 25/28] tcg/s390x: Implement TCG_TARGET_HAS_minmax_vec
1
Reviewed-by: David Hildenbrand <david@redhat.com>
2
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
3
---
4
tcg/s390x/tcg-target.h | 2 +-
5
tcg/s390x/tcg-target.c.inc | 25 +++++++++++++++++++++++++
6
2 files changed, 26 insertions(+), 1 deletion(-)
1
7
8
diff --git a/tcg/s390x/tcg-target.h b/tcg/s390x/tcg-target.h
9
index XXXXXXX..XXXXXXX 100644
10
--- a/tcg/s390x/tcg-target.h
11
+++ b/tcg/s390x/tcg-target.h
12
@@ -XXX,XX +XXX,XX @@ extern uint64_t s390_facilities[3];
13
#define TCG_TARGET_HAS_shv_vec 1
14
#define TCG_TARGET_HAS_mul_vec 1
15
#define TCG_TARGET_HAS_sat_vec 0
16
-#define TCG_TARGET_HAS_minmax_vec 0
17
+#define TCG_TARGET_HAS_minmax_vec 1
18
#define TCG_TARGET_HAS_bitsel_vec 0
19
#define TCG_TARGET_HAS_cmpsel_vec 0
20
21
diff --git a/tcg/s390x/tcg-target.c.inc b/tcg/s390x/tcg-target.c.inc
22
index XXXXXXX..XXXXXXX 100644
23
--- a/tcg/s390x/tcg-target.c.inc
24
+++ b/tcg/s390x/tcg-target.c.inc
25
@@ -XXX,XX +XXX,XX @@ typedef enum S390Opcode {
26
VRRc_VESRAV = 0xe77a,
27
VRRc_VESRLV = 0xe778,
28
VRRc_VML = 0xe7a2,
29
+ VRRc_VMN = 0xe7fe,
30
+ VRRc_VMNL = 0xe7fc,
31
+ VRRc_VMX = 0xe7ff,
32
+ VRRc_VMXL = 0xe7fd,
33
VRRc_VN = 0xe768,
34
VRRc_VNC = 0xe769,
35
VRRc_VNO = 0xe76b,
36
@@ -XXX,XX +XXX,XX @@ static void tcg_out_vec_op(TCGContext *s, TCGOpcode opc,
37
tcg_out_insn(s, VRRc, VERLLV, a0, a1, a2, vece);
38
break;
39
40
+ case INDEX_op_smin_vec:
41
+ tcg_out_insn(s, VRRc, VMN, a0, a1, a2, vece);
42
+ break;
43
+ case INDEX_op_smax_vec:
44
+ tcg_out_insn(s, VRRc, VMX, a0, a1, a2, vece);
45
+ break;
46
+ case INDEX_op_umin_vec:
47
+ tcg_out_insn(s, VRRc, VMNL, a0, a1, a2, vece);
48
+ break;
49
+ case INDEX_op_umax_vec:
50
+ tcg_out_insn(s, VRRc, VMXL, a0, a1, a2, vece);
51
+ break;
52
+
53
case INDEX_op_cmp_vec:
54
switch ((TCGCond)args[3]) {
55
case TCG_COND_EQ:
56
@@ -XXX,XX +XXX,XX @@ int tcg_can_emit_vec_op(TCGOpcode opc, TCGType type, unsigned vece)
57
case INDEX_op_shri_vec:
58
case INDEX_op_shrs_vec:
59
case INDEX_op_shrv_vec:
60
+ case INDEX_op_smax_vec:
61
+ case INDEX_op_smin_vec:
62
case INDEX_op_sub_vec:
63
+ case INDEX_op_umax_vec:
64
+ case INDEX_op_umin_vec:
65
case INDEX_op_xor_vec:
66
return 1;
67
case INDEX_op_cmp_vec:
68
@@ -XXX,XX +XXX,XX @@ static TCGConstraintSetIndex tcg_target_op_def(TCGOpcode op)
69
case INDEX_op_shlv_vec:
70
case INDEX_op_shrv_vec:
71
case INDEX_op_sarv_vec:
72
+ case INDEX_op_smax_vec:
73
+ case INDEX_op_smin_vec:
74
+ case INDEX_op_umax_vec:
75
+ case INDEX_op_umin_vec:
76
return C_O1_I2(v, v, v);
77
case INDEX_op_rotls_vec:
78
case INDEX_op_shls_vec:
79
--
80
2.25.1
81
82
diff view generated by jsdifflib
New patch
[PULL 26/28] tcg/s390x: Implement TCG_TARGET_HAS_sat_vec
1
The unsigned saturations are handled via generic code
2
using min/max. The signed saturations are expanded using
3
double-sized arithmetic and a saturating pack.
1
4
5
Since all operations are done via expansion, do not
6
actually set TCG_TARGET_HAS_sat_vec.
7
8
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
9
---
10
tcg/s390x/tcg-target.opc.h | 3 ++
11
tcg/s390x/tcg-target.c.inc | 63 ++++++++++++++++++++++++++++++++++++++
12
2 files changed, 66 insertions(+)
13
14
diff --git a/tcg/s390x/tcg-target.opc.h b/tcg/s390x/tcg-target.opc.h
15
index XXXXXXX..XXXXXXX 100644
16
--- a/tcg/s390x/tcg-target.opc.h
17
+++ b/tcg/s390x/tcg-target.opc.h
18
@@ -XXX,XX +XXX,XX @@
19
* emitted by tcg_expand_vec_op. For those familiar with GCC internals,
20
* consider these to be UNSPEC with names.
21
*/
22
+DEF(s390_vuph_vec, 1, 1, 0, IMPLVEC)
23
+DEF(s390_vupl_vec, 1, 1, 0, IMPLVEC)
24
+DEF(s390_vpks_vec, 1, 2, 0, IMPLVEC)
25
diff --git a/tcg/s390x/tcg-target.c.inc b/tcg/s390x/tcg-target.c.inc
26
index XXXXXXX..XXXXXXX 100644
27
--- a/tcg/s390x/tcg-target.c.inc
28
+++ b/tcg/s390x/tcg-target.c.inc
29
@@ -XXX,XX +XXX,XX @@ typedef enum S390Opcode {
30
VRRc_VNO = 0xe76b,
31
VRRc_VO = 0xe76a,
32
VRRc_VOC = 0xe76f,
33
+ VRRc_VPKS = 0xe797, /* we leave the m5 cs field 0 */
34
VRRc_VS = 0xe7f7,
35
+ VRRa_VUPH = 0xe7d7,
36
+ VRRa_VUPL = 0xe7d6,
37
VRRc_VX = 0xe76d,
38
VRRf_VLVGP = 0xe762,
39
40
@@ -XXX,XX +XXX,XX @@ static void tcg_out_vec_op(TCGContext *s, TCGOpcode opc,
41
}
42
break;
43
44
+ case INDEX_op_s390_vuph_vec:
45
+ tcg_out_insn(s, VRRa, VUPH, a0, a1, vece);
46
+ break;
47
+ case INDEX_op_s390_vupl_vec:
48
+ tcg_out_insn(s, VRRa, VUPL, a0, a1, vece);
49
+ break;
50
+ case INDEX_op_s390_vpks_vec:
51
+ tcg_out_insn(s, VRRc, VPKS, a0, a1, a2, vece);
52
+ break;
53
+
54
case INDEX_op_mov_vec: /* Always emitted via tcg_out_mov. */
55
case INDEX_op_dup_vec: /* Always emitted via tcg_out_dup_vec. */
56
default:
57
@@ -XXX,XX +XXX,XX @@ int tcg_can_emit_vec_op(TCGOpcode opc, TCGType type, unsigned vece)
58
return -1;
59
case INDEX_op_mul_vec:
60
return vece < MO_64;
61
+ case INDEX_op_ssadd_vec:
62
+ case INDEX_op_sssub_vec:
63
+ return vece < MO_64 ? -1 : 0;
64
default:
65
return 0;
66
}
67
@@ -XXX,XX +XXX,XX @@ static void expand_vec_cmp(TCGType type, unsigned vece, TCGv_vec v0,
68
}
69
}
70
71
+static void expand_vec_sat(TCGType type, unsigned vece, TCGv_vec v0,
72
+ TCGv_vec v1, TCGv_vec v2, TCGOpcode add_sub_opc)
73
+{
74
+ TCGv_vec h1 = tcg_temp_new_vec(type);
75
+ TCGv_vec h2 = tcg_temp_new_vec(type);
76
+ TCGv_vec l1 = tcg_temp_new_vec(type);
77
+ TCGv_vec l2 = tcg_temp_new_vec(type);
78
+
79
+ tcg_debug_assert (vece < MO_64);
80
+
81
+ /* Unpack with sign-extension. */
82
+ vec_gen_2(INDEX_op_s390_vuph_vec, type, vece,
83
+ tcgv_vec_arg(h1), tcgv_vec_arg(v1));
84
+ vec_gen_2(INDEX_op_s390_vuph_vec, type, vece,
85
+ tcgv_vec_arg(h2), tcgv_vec_arg(v2));
86
+
87
+ vec_gen_2(INDEX_op_s390_vupl_vec, type, vece,
88
+ tcgv_vec_arg(l1), tcgv_vec_arg(v1));
89
+ vec_gen_2(INDEX_op_s390_vupl_vec, type, vece,
90
+ tcgv_vec_arg(l2), tcgv_vec_arg(v2));
91
+
92
+ /* Arithmetic on a wider element size. */
93
+ vec_gen_3(add_sub_opc, type, vece + 1, tcgv_vec_arg(h1),
94
+ tcgv_vec_arg(h1), tcgv_vec_arg(h2));
95
+ vec_gen_3(add_sub_opc, type, vece + 1, tcgv_vec_arg(l1),
96
+ tcgv_vec_arg(l1), tcgv_vec_arg(l2));
97
+
98
+ /* Pack with saturation. */
99
+ vec_gen_3(INDEX_op_s390_vpks_vec, type, vece + 1,
100
+ tcgv_vec_arg(v0), tcgv_vec_arg(h1), tcgv_vec_arg(l1));
101
+
102
+ tcg_temp_free_vec(h1);
103
+ tcg_temp_free_vec(h2);
104
+ tcg_temp_free_vec(l1);
105
+ tcg_temp_free_vec(l2);
106
+}
107
+
108
void tcg_expand_vec_op(TCGOpcode opc, TCGType type, unsigned vece,
109
TCGArg a0, ...)
110
{
111
@@ -XXX,XX +XXX,XX @@ void tcg_expand_vec_op(TCGOpcode opc, TCGType type, unsigned vece,
112
tcg_temp_free_vec(t0);
113
break;
114
115
+ case INDEX_op_ssadd_vec:
116
+ expand_vec_sat(type, vece, v0, v1, v2, INDEX_op_add_vec);
117
+ break;
118
+ case INDEX_op_sssub_vec:
119
+ expand_vec_sat(type, vece, v0, v1, v2, INDEX_op_sub_vec);
120
+ break;
121
+
122
default:
123
g_assert_not_reached();
124
}
125
@@ -XXX,XX +XXX,XX @@ static TCGConstraintSetIndex tcg_target_op_def(TCGOpcode op)
126
case INDEX_op_sari_vec:
127
case INDEX_op_shli_vec:
128
case INDEX_op_shri_vec:
129
+ case INDEX_op_s390_vuph_vec:
130
+ case INDEX_op_s390_vupl_vec:
131
return C_O1_I1(v, v);
132
case INDEX_op_add_vec:
133
case INDEX_op_sub_vec:
134
@@ -XXX,XX +XXX,XX @@ static TCGConstraintSetIndex tcg_target_op_def(TCGOpcode op)
135
case INDEX_op_smin_vec:
136
case INDEX_op_umax_vec:
137
case INDEX_op_umin_vec:
138
+ case INDEX_op_s390_vpks_vec:
139
return C_O1_I2(v, v, v);
140
case INDEX_op_rotls_vec:
141
case INDEX_op_shls_vec:
142
--
143
2.25.1
144
145
diff view generated by jsdifflib
New patch
[PULL 27/28] tcg/s390x: Implement TCG_TARGET_HAS_bitsel_vec
1
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
2
---
3
tcg/s390x/tcg-target-con-set.h | 1 +
4
tcg/s390x/tcg-target.h | 2 +-
5
tcg/s390x/tcg-target.c.inc | 20 ++++++++++++++++++++
6
3 files changed, 22 insertions(+), 1 deletion(-)
1
7
8
diff --git a/tcg/s390x/tcg-target-con-set.h b/tcg/s390x/tcg-target-con-set.h
9
index XXXXXXX..XXXXXXX 100644
10
--- a/tcg/s390x/tcg-target-con-set.h
11
+++ b/tcg/s390x/tcg-target-con-set.h
12
@@ -XXX,XX +XXX,XX @@ C_O1_I2(r, r, ri)
13
C_O1_I2(r, rZ, r)
14
C_O1_I2(v, v, r)
15
C_O1_I2(v, v, v)
16
+C_O1_I3(v, v, v, v)
17
C_O1_I4(r, r, ri, r, 0)
18
C_O1_I4(r, r, ri, rI, 0)
19
C_O2_I2(b, a, 0, r)
20
diff --git a/tcg/s390x/tcg-target.h b/tcg/s390x/tcg-target.h
21
index XXXXXXX..XXXXXXX 100644
22
--- a/tcg/s390x/tcg-target.h
23
+++ b/tcg/s390x/tcg-target.h
24
@@ -XXX,XX +XXX,XX @@ extern uint64_t s390_facilities[3];
25
#define TCG_TARGET_HAS_mul_vec 1
26
#define TCG_TARGET_HAS_sat_vec 0
27
#define TCG_TARGET_HAS_minmax_vec 1
28
-#define TCG_TARGET_HAS_bitsel_vec 0
29
+#define TCG_TARGET_HAS_bitsel_vec 1
30
#define TCG_TARGET_HAS_cmpsel_vec 0
31
32
/* used for function call generation */
33
diff --git a/tcg/s390x/tcg-target.c.inc b/tcg/s390x/tcg-target.c.inc
34
index XXXXXXX..XXXXXXX 100644
35
--- a/tcg/s390x/tcg-target.c.inc
36
+++ b/tcg/s390x/tcg-target.c.inc
37
@@ -XXX,XX +XXX,XX @@ typedef enum S390Opcode {
38
VRRa_VUPH = 0xe7d7,
39
VRRa_VUPL = 0xe7d6,
40
VRRc_VX = 0xe76d,
41
+ VRRe_VSEL = 0xe78d,
42
VRRf_VLVGP = 0xe762,
43
44
VRSa_VERLL = 0xe733,
45
@@ -XXX,XX +XXX,XX @@ static void tcg_out_insn_VRRc(TCGContext *s, S390Opcode op,
46
tcg_out16(s, (op & 0x00ff) | RXB(v1, v2, v3, 0) | (m4 << 12));
47
}
48
49
+static void tcg_out_insn_VRRe(TCGContext *s, S390Opcode op,
50
+ TCGReg v1, TCGReg v2, TCGReg v3, TCGReg v4)
51
+{
52
+ tcg_debug_assert(is_vector_reg(v1));
53
+ tcg_debug_assert(is_vector_reg(v2));
54
+ tcg_debug_assert(is_vector_reg(v3));
55
+ tcg_debug_assert(is_vector_reg(v4));
56
+ tcg_out16(s, (op & 0xff00) | ((v1 & 0xf) << 4) | (v2 & 0xf));
57
+ tcg_out16(s, v3 << 12);
58
+ tcg_out16(s, (op & 0x00ff) | RXB(v1, v2, v3, v4) | (v4 << 12));
59
+}
60
+
61
static void tcg_out_insn_VRRf(TCGContext *s, S390Opcode op,
62
TCGReg v1, TCGReg r2, TCGReg r3)
63
{
64
@@ -XXX,XX +XXX,XX @@ static void tcg_out_vec_op(TCGContext *s, TCGOpcode opc,
65
tcg_out_insn(s, VRRc, VMXL, a0, a1, a2, vece);
66
break;
67
68
+ case INDEX_op_bitsel_vec:
69
+ tcg_out_insn(s, VRRe, VSEL, a0, a1, a2, args[3]);
70
+ break;
71
+
72
case INDEX_op_cmp_vec:
73
switch ((TCGCond)args[3]) {
74
case TCG_COND_EQ:
75
@@ -XXX,XX +XXX,XX @@ int tcg_can_emit_vec_op(TCGOpcode opc, TCGType type, unsigned vece)
76
case INDEX_op_add_vec:
77
case INDEX_op_and_vec:
78
case INDEX_op_andc_vec:
79
+ case INDEX_op_bitsel_vec:
80
case INDEX_op_neg_vec:
81
case INDEX_op_not_vec:
82
case INDEX_op_or_vec:
83
@@ -XXX,XX +XXX,XX @@ static TCGConstraintSetIndex tcg_target_op_def(TCGOpcode op)
84
case INDEX_op_shrs_vec:
85
case INDEX_op_sars_vec:
86
return C_O1_I2(v, v, r);
87
+ case INDEX_op_bitsel_vec:
88
+ return C_O1_I3(v, v, v, v);
89
90
default:
91
g_assert_not_reached();
92
--
93
2.25.1
94
95
diff view generated by jsdifflib
New patch
[PULL 28/28] tcg/s390x: Implement TCG_TARGET_HAS_cmpsel_vec
1
This is via expansion; don't actually set TCG_TARGET_HAS_cmpsel_vec.
1
2
3
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
4
---
5
tcg/s390x/tcg-target.c.inc | 24 +++++++++++++++++++++++-
6
1 file changed, 23 insertions(+), 1 deletion(-)
7
8
diff --git a/tcg/s390x/tcg-target.c.inc b/tcg/s390x/tcg-target.c.inc
9
index XXXXXXX..XXXXXXX 100644
10
--- a/tcg/s390x/tcg-target.c.inc
11
+++ b/tcg/s390x/tcg-target.c.inc
12
@@ -XXX,XX +XXX,XX @@ int tcg_can_emit_vec_op(TCGOpcode opc, TCGType type, unsigned vece)
13
case INDEX_op_xor_vec:
14
return 1;
15
case INDEX_op_cmp_vec:
16
+ case INDEX_op_cmpsel_vec:
17
case INDEX_op_rotrv_vec:
18
return -1;
19
case INDEX_op_mul_vec:
20
@@ -XXX,XX +XXX,XX @@ static void expand_vec_cmp(TCGType type, unsigned vece, TCGv_vec v0,
21
}
22
}
23
24
+static void expand_vec_cmpsel(TCGType type, unsigned vece, TCGv_vec v0,
25
+ TCGv_vec c1, TCGv_vec c2,
26
+ TCGv_vec v3, TCGv_vec v4, TCGCond cond)
27
+{
28
+ TCGv_vec t = tcg_temp_new_vec(type);
29
+
30
+ if (expand_vec_cmp_noinv(type, vece, t, c1, c2, cond)) {
31
+ /* Invert the sense of the compare by swapping arguments. */
32
+ tcg_gen_bitsel_vec(vece, v0, t, v4, v3);
33
+ } else {
34
+ tcg_gen_bitsel_vec(vece, v0, t, v3, v4);
35
+ }
36
+ tcg_temp_free_vec(t);
37
+}
38
+
39
static void expand_vec_sat(TCGType type, unsigned vece, TCGv_vec v0,
40
TCGv_vec v1, TCGv_vec v2, TCGOpcode add_sub_opc)
41
{
42
@@ -XXX,XX +XXX,XX @@ void tcg_expand_vec_op(TCGOpcode opc, TCGType type, unsigned vece,
43
TCGArg a0, ...)
44
{
45
va_list va;
46
- TCGv_vec v0, v1, v2, t0;
47
+ TCGv_vec v0, v1, v2, v3, v4, t0;
48
49
va_start(va, a0);
50
v0 = temp_tcgv_vec(arg_temp(a0));
51
@@ -XXX,XX +XXX,XX @@ void tcg_expand_vec_op(TCGOpcode opc, TCGType type, unsigned vece,
52
expand_vec_cmp(type, vece, v0, v1, v2, va_arg(va, TCGArg));
53
break;
54
55
+ case INDEX_op_cmpsel_vec:
56
+ v3 = temp_tcgv_vec(arg_temp(va_arg(va, TCGArg)));
57
+ v4 = temp_tcgv_vec(arg_temp(va_arg(va, TCGArg)));
58
+ expand_vec_cmpsel(type, vece, v0, v1, v2, v3, v4, va_arg(va, TCGArg));
59
+ break;
60
+
61
case INDEX_op_rotrv_vec:
62
t0 = tcg_temp_new_vec(type);
63
tcg_gen_neg_vec(vece, t0, v2);
64
--
65
2.25.1
66
67
diff view generated by jsdifflib

Patchew 2.1-devel-b67e4c2

© 2016 - 2025 Red Hat, Inc.