The following changes since commit 67e41fe0cfb62e6cdfa659f0155417d17e5274ea:

Merge tag 'pull-ppc-20220104' of https://github.com/legoater/qemu into staging (2022-01-04 07:23:27 -0800)

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

for you to fetch changes up to d7478d4229f0a2b2817a55487e6b17081099fae4:

common-user: Fix tail calls to safe_syscall_set_errno_tail (2022-01-04 15:41:03 -0800)

Fix for safe_syscall_base.

Fix for folding of vector add/sub.

Fix build on loongarch64 with gcc 8.

Remove decl for qemu_run_machine_init_done_notifiers.

Philippe Mathieu-Daudé (1):

linux-user: Fix trivial build error on loongarch64 hosts

Richard Henderson (2):

tcg/optimize: Fix folding of vector ops

common-user: Fix tail calls to safe_syscall_set_errno_tail

Xiaoyao Li (1):

sysemu: Cleanup qemu_run_machine_init_done_notifiers()

include/sysemu/sysemu.h | 1 -

linux-user/host/loongarch64/host-signal.h | 4 +--

tcg/optimize.c | 49 +++++++++++++++++++++++-------

common-user/host/i386/safe-syscall.inc.S | 1 +

common-user/host/mips/safe-syscall.inc.S | 1 +

common-user/host/x86_64/safe-syscall.inc.S | 1 +

6 files changed, 42 insertions(+), 15 deletions(-)

Bitwise operations are easy to fold, because the operation is

identical regardless of element size. But add and sub need

extra element size info that is not currently propagated.

Fixes: 2f9f08ba43d

Cc: qemu-stable@nongnu.org

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

Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>

tcg/optimize.c | 49 ++++++++++++++++++++++++++++++++++++++-----------

1 file changed, 38 insertions(+), 11 deletions(-)

diff --git a/tcg/optimize.c b/tcg/optimize.c

--- a/tcg/optimize.c

+++ b/tcg/optimize.c

@@ -XXX,XX +XXX,XX @@ static uint64_t do_constant_folding_2(TCGOpcode op, uint64_t x, uint64_t y)

CASE_OP_32_64(mul):

return x * y;

- CASE_OP_32_64(and):

+ CASE_OP_32_64_VEC(and):

return x & y;

- CASE_OP_32_64(or):

+ CASE_OP_32_64_VEC(or):

return x | y;

- CASE_OP_32_64(xor):

+ CASE_OP_32_64_VEC(xor):

return x ^ y;

case INDEX_op_shl_i32:

@@ -XXX,XX +XXX,XX @@ static uint64_t do_constant_folding_2(TCGOpcode op, uint64_t x, uint64_t y)

case INDEX_op_rotl_i64:

return rol64(x, y & 63);

- CASE_OP_32_64(not):

+ CASE_OP_32_64_VEC(not):

return ~x;

CASE_OP_32_64(neg):

return -x;

- CASE_OP_32_64(andc):

+ CASE_OP_32_64_VEC(andc):

return x & ~y;

- CASE_OP_32_64(orc):

+ CASE_OP_32_64_VEC(orc):

return x | ~y;

CASE_OP_32_64(eqv):

@@ -XXX,XX +XXX,XX @@ static bool fold_const2(OptContext *ctx, TCGOp *op)

return false;

+static bool fold_commutative(OptContext *ctx, TCGOp *op)

+ swap_commutative(op->args[0], &op->args[1], &op->args[2]);

+ return false;

static bool fold_const2_commutative(OptContext *ctx, TCGOp *op)

{

swap_commutative(op->args[0], &op->args[1], &op->args[2]);

@@ -XXX,XX +XXX,XX @@ static bool fold_add(OptContext *ctx, TCGOp *op)

return false;

}

+/* We cannot as yet do_constant_folding with vectors. */

+static bool fold_add_vec(OptContext *ctx, TCGOp *op)

+{

+ if (fold_commutative(ctx, op) ||

+ fold_xi_to_x(ctx, op, 0)) {

+ return true;

+ }

+ return false;

+}

+

static bool fold_addsub2(OptContext *ctx, TCGOp *op, bool add)

{

if (arg_is_const(op->args[2]) && arg_is_const(op->args[3]) &&

@@ -XXX,XX +XXX,XX @@ static bool fold_sub_to_neg(OptContext *ctx, TCGOp *op)

return false;

}

-static bool fold_sub(OptContext *ctx, TCGOp *op)

+/* We cannot as yet do_constant_folding with vectors. */

+static bool fold_sub_vec(OptContext *ctx, TCGOp *op)

{

- if (fold_const2(ctx, op) ||

- fold_xx_to_i(ctx, op, 0) ||

+ if (fold_xx_to_i(ctx, op, 0) ||

fold_xi_to_x(ctx, op, 0) ||

fold_sub_to_neg(ctx, op)) {

return true;

@@ -XXX,XX +XXX,XX @@ static bool fold_sub(OptContext *ctx, TCGOp *op)

return false;

}

+static bool fold_sub(OptContext *ctx, TCGOp *op)

+{

+ return fold_const2(ctx, op) || fold_sub_vec(ctx, op);

+}

+

static bool fold_sub2(OptContext *ctx, TCGOp *op)

{

return fold_addsub2(ctx, op, false);

@@ -XXX,XX +XXX,XX @@ void tcg_optimize(TCGContext *s)

* Sorted alphabetically by opcode as much as possible.

*/

switch (opc) {

- CASE_OP_32_64_VEC(add):

+ CASE_OP_32_64(add):

done = fold_add(&ctx, op);

break;

+ case INDEX_op_add_vec:

+ done = fold_add_vec(&ctx, op);

+ break;

CASE_OP_32_64(add2):

done = fold_add2(&ctx, op);

break;

@@ -XXX,XX +XXX,XX @@ void tcg_optimize(TCGContext *s)

CASE_OP_32_64(sextract):

done = fold_sextract(&ctx, op);

break;

- CASE_OP_32_64_VEC(sub):

+ CASE_OP_32_64(sub):

done = fold_sub(&ctx, op);

break;

+ case INDEX_op_sub_vec:

+ done = fold_sub_vec(&ctx, op);

+ break;

CASE_OP_32_64(sub2):

done = fold_sub2(&ctx, op);

break;

2.25.1

From: Philippe Mathieu-Daudé <f4bug@amsat.org>

When building using GCC 8.3.0 on loongarch64 (Loongnix) we get:

In file included from ../linux-user/signal.c:33:

../linux-user/host/loongarch64/host-signal.h: In function ‘host_signal_write’:

../linux-user/host/loongarch64/host-signal.h:57:9: error: a label can only be part of a statement and a declaration is not a statement

uint32_t sel = (insn >> 15) & 0b11111111111;

^~~~~~~~

We don't use the 'sel' variable more than once, so drop it.

Meson output for the record:

Host machine cpu family: loongarch64

Host machine cpu: loongarch64

C compiler for the host machine: cc (gcc 8.3.0 "cc (Loongnix 8.3.0-6.lnd.vec.27) 8.3.0")

C linker for the host machine: cc ld.bfd 2.31.1-system

Fixes: ad812c3bd65 ("linux-user: Implement CPU-specific signal handler for loongarch64 hosts")

Reported-by: Song Gao <gaosong@loongson.cn>

Suggested-by: Song Gao <gaosong@loongson.cn>

Signed-off-by: Philippe Mathieu-Daudé <f4bug@amsat.org>

Reviewed-by: WANG Xuerui <git@xen0n.name>

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

Message-Id: <20220104215027.2180972-1-f4bug@amsat.org>

linux-user/host/loongarch64/host-signal.h | 4 +---

1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/linux-user/host/loongarch64/host-signal.h b/linux-user/host/loongarch64/host-signal.h

--- a/linux-user/host/loongarch64/host-signal.h

+++ b/linux-user/host/loongarch64/host-signal.h

@@ -XXX,XX +XXX,XX @@ static inline bool host_signal_write(siginfo_t *info, ucontext_t *uc)

}

break;

case 0b001110: /* indexed, atomic, bounds-checking memory operations */

- uint32_t sel = (insn >> 15) & 0b11111111111;

-

- switch (sel) {

+ switch ((insn >> 15) & 0b11111111111) {

case 0b00000100000: /* stx.b */

case 0b00000101000: /* stx.h */

case 0b00000110000: /* stx.w */

2.25.1

From: Xiaoyao Li <xiaoyao.li@intel.com>

Remove qemu_run_machine_init_done_notifiers() since no implementation

and user.

Fixes: f66dc8737c9 ("vl: move all generic initialization out of vl.c")

Signed-off-by: Xiaoyao Li <xiaoyao.li@intel.com>

Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>

Message-Id: <20220104024136.1433545-1-xiaoyao.li@intel.com>

include/sysemu/sysemu.h | 1 -

1 file changed, 1 deletion(-)

diff --git a/include/sysemu/sysemu.h b/include/sysemu/sysemu.h

--- a/include/sysemu/sysemu.h

+++ b/include/sysemu/sysemu.h

@@ -XXX,XX +XXX,XX @@ extern bool qemu_uuid_set;

void qemu_add_exit_notifier(Notifier *notify);

void qemu_remove_exit_notifier(Notifier *notify);

-void qemu_run_machine_init_done_notifiers(void);

void qemu_add_machine_init_done_notifier(Notifier *notify);

void qemu_remove_machine_init_done_notifier(Notifier *notify);

2.25.1