The following changes since commit 7c18f2d663521f1b31b821a13358ce38075eaf7d:

Merge tag 'for-upstream' of https://gitlab.com/bonzini/qemu into staging (2023-04-29 23:07:17 +0100)

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

for you to fetch changes up to bdc7fba1c5a29ae218b45353daac9308fe1aae82:

tcg: Introduce tcg_out_movext2 (2023-05-02 12:15:41 +0100)

Misc tcg-related patch queue.

Dickon Hood (1):

qemu/bitops.h: Limit rotate amounts

Kiran Ostrolenk (1):

qemu/host-utils.h: Add clz and ctz functions for lower-bit integers

Nazar Kazakov (2):

tcg: Add tcg_gen_gvec_andcs

tcg: Add tcg_gen_gvec_rotrs

Richard Henderson (7):

softmmu: Tidy dirtylimit_dirty_ring_full_time

qemu/int128: Re-shuffle Int128Alias members

migration/xbzrle: Use __attribute__((target)) for avx512

accel/tcg: Add cpu_ld*_code_mmu

tcg/loongarch64: Conditionalize tcg_out_exts_i32_i64

tcg/mips: Conditionalize tcg_out_exts_i32_i64

tcg: Introduce tcg_out_movext2

Drop inline marker: let compiler decide.

Change return type to uint64_t: this matches the computation in the

return statement and the local variable assignment in the caller.

Rename local to dirty_ring_size_MB to fix typo.

Simplify conversion to MiB via qemu_target_page_bits and right shift.

Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>

Reviewed-by: Thomas Huth <thuth@redhat.com>

Reviewed-by: Juan Quintela <quintela@redhat.com>

softmmu/dirtylimit.c | 15 ++++++++++-----

1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/softmmu/dirtylimit.c b/softmmu/dirtylimit.c

--- a/softmmu/dirtylimit.c

+++ b/softmmu/dirtylimit.c

@@ -XXX,XX +XXX,XX @@ bool dirtylimit_vcpu_index_valid(int cpu_index)

cpu_index >= ms->smp.max_cpus);

-static inline int64_t dirtylimit_dirty_ring_full_time(uint64_t dirtyrate)

+static uint64_t dirtylimit_dirty_ring_full_time(uint64_t dirtyrate)

static uint64_t max_dirtyrate;

- uint32_t dirty_ring_size = kvm_dirty_ring_size();

- uint64_t dirty_ring_size_meory_MB =

- dirty_ring_size * qemu_target_page_size() >> 20;

+ unsigned target_page_bits = qemu_target_page_bits();

+ uint64_t dirty_ring_size_MB;

+

+ /* So far, the largest (non-huge) page size is 64k, i.e. 16 bits. */

+ assert(target_page_bits < 20);

+

+ /* Convert ring size (pages) to MiB (2**20). */

+ dirty_ring_size_MB = kvm_dirty_ring_size() >> (20 - target_page_bits);

if (max_dirtyrate < dirtyrate) {

max_dirtyrate = dirtyrate;

- return dirty_ring_size_meory_MB * 1000000 / max_dirtyrate;

+ return dirty_ring_size_MB * 1000000 / max_dirtyrate;

static inline bool dirtylimit_done(uint64_t quota,

From: Weiwei Li <liweiwei@iscas.ac.cn>

When PMP entry overlap part of the page, we'll set the tlb_size to 1, which

will make the address in tlb entry set with TLB_INVALID_MASK, and the next

access will again go through tlb_fill.However, this way will not work in

tb_gen_code() => get_page_addr_code_hostp(): the TLB host address will be

cached, and the following instructions can use this host address directly

which may lead to the bypass of PMP related check.

Resolves: https://gitlab.com/qemu-project/qemu/-/issues/1542.

Signed-off-by: Weiwei Li <liweiwei@iscas.ac.cn>

Signed-off-by: Junqiang Wang <wangjunqiang@iscas.ac.cn>

Reviewed-by: LIU Zhiwei <zhiwei_liu@linux.alibaba.com>

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>

Message-Id: <20230422130329.23555-6-liweiwei@iscas.ac.cn>

accel/tcg/cputlb.c | 5 +++++

1 file changed, 5 insertions(+)

@@ -XXX,XX +XXX,XX @@ tb_page_addr_t get_page_addr_code_hostp(CPUArchState *env, target_ulong addr,

From: Dickon Hood <dickon.hood@codethink.co.uk>

Rotates have been fixed up to only allow for reasonable rotate amounts

(ie, no rotates >7 on an 8b value etc.) This fixes a problem with riscv

vector rotate instructions.

Signed-off-by: Dickon Hood <dickon.hood@codethink.co.uk>

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>

Message-Id: <20230428144757.57530-9-lawrence.hunter@codethink.co.uk>

include/qemu/bitops.h | 24 ++++++++++++++++--------

1 file changed, 16 insertions(+), 8 deletions(-)

diff --git a/include/qemu/bitops.h b/include/qemu/bitops.h

--- a/include/qemu/bitops.h

+++ b/include/qemu/bitops.h

@@ -XXX,XX +XXX,XX @@ static inline unsigned long find_first_zero_bit(const unsigned long *addr,

static inline uint8_t rol8(uint8_t word, unsigned int shift)

{

- return (word << shift) | (word >> ((8 - shift) & 7));

+ shift &= 7;

+ return (word << shift) | (word >> (8 - shift));

/**

@@ -XXX,XX +XXX,XX @@ static inline uint8_t rol8(uint8_t word, unsigned int shift)

*/

static inline uint8_t ror8(uint8_t word, unsigned int shift)

{

- return (word >> shift) | (word << ((8 - shift) & 7));

+ shift &= 7;

+ return (word >> shift) | (word << (8 - shift));

/**

@@ -XXX,XX +XXX,XX @@ static inline uint8_t ror8(uint8_t word, unsigned int shift)

*/

static inline uint16_t rol16(uint16_t word, unsigned int shift)

{

- return (word << shift) | (word >> ((16 - shift) & 15));

+ shift &= 15;

+ return (word << shift) | (word >> (16 - shift));

/**

@@ -XXX,XX +XXX,XX @@ static inline uint16_t rol16(uint16_t word, unsigned int shift)

*/

static inline uint16_t ror16(uint16_t word, unsigned int shift)

{

- return (word >> shift) | (word << ((16 - shift) & 15));

+ shift &= 15;

+ return (word >> shift) | (word << (16 - shift));

/**

@@ -XXX,XX +XXX,XX @@ static inline uint16_t ror16(uint16_t word, unsigned int shift)

*/

static inline uint32_t rol32(uint32_t word, unsigned int shift)

- return (word << shift) | (word >> ((32 - shift) & 31));

+ shift &= 31;

+ return (word << shift) | (word >> (32 - shift));

/**

@@ -XXX,XX +XXX,XX @@ static inline uint32_t rol32(uint32_t word, unsigned int shift)

static inline uint32_t ror32(uint32_t word, unsigned int shift)

{

- return (word >> shift) | (word << ((32 - shift) & 31));

+ shift &= 31;

+ return (word >> shift) | (word << (32 - shift));

/**

@@ -XXX,XX +XXX,XX @@ static inline uint32_t ror32(uint32_t word, unsigned int shift)

*/

static inline uint64_t rol64(uint64_t word, unsigned int shift)

- return (word << shift) | (word >> ((64 - shift) & 63));

+ shift &= 63;

+ return (word << shift) | (word >> (64 - shift));

}

/**

@@ -XXX,XX +XXX,XX @@ static inline uint64_t rol64(uint64_t word, unsigned int shift)

*/

static inline uint64_t ror64(uint64_t word, unsigned int shift)

- return (word >> shift) | (word << ((64 - shift) & 63));

+ shift &= 63;

+ return (word >> shift) | (word << (64 - shift));

From: Kiran Ostrolenk <kiran.ostrolenk@codethink.co.uk>

This is for use in the RISC-V vclz and vctz instructions (implemented in

proceeding commit).

Signed-off-by: Kiran Ostrolenk <kiran.ostrolenk@codethink.co.uk>

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>

Message-Id: <20230428144757.57530-11-lawrence.hunter@codethink.co.uk>

include/qemu/host-utils.h | 54 +++++++++++++++++++++++++++++++++++++++

1 file changed, 54 insertions(+)

diff --git a/include/qemu/host-utils.h b/include/qemu/host-utils.h

--- a/include/qemu/host-utils.h

+++ b/include/qemu/host-utils.h

@@ -XXX,XX +XXX,XX @@ static inline uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)

}

#endif

+/**

+ * clz8 - count leading zeros in a 8-bit value.

+ * @val: The value to search

+ *

+ * Returns 8 if the value is zero. Note that the GCC builtin is

+ * undefined if the value is zero.

+ *

+ * Note that the GCC builtin will upcast its argument to an `unsigned int`

+ * so this function subtracts off the number of prepended zeroes.

+ */

+static inline int clz8(uint8_t val)

+ return val ? __builtin_clz(val) - 24 : 8;

+/**

+ * clz16 - count leading zeros in a 16-bit value.

+ * @val: The value to search

+ *

+ * Returns 16 if the value is zero. Note that the GCC builtin is

+ * undefined if the value is zero.

+ *

+ * Note that the GCC builtin will upcast its argument to an `unsigned int`

+ * so this function subtracts off the number of prepended zeroes.

+ */

+static inline int clz16(uint16_t val)

+ return val ? __builtin_clz(val) - 16 : 16;

/**

* clz32 - count leading zeros in a 32-bit value.

* @val: The value to search

@@ -XXX,XX +XXX,XX @@ static inline int clo64(uint64_t val)

return clz64(~val);

+/**

+ * ctz8 - count trailing zeros in a 8-bit value.

+ * @val: The value to search

+ *

+ * Returns 8 if the value is zero. Note that the GCC builtin is