From nobody Tue Feb 10 05:41:52 2026 Delivered-To: importer@patchew.org Received-SPF: temperror (zoho.com: Error in retrieving data from DNS) client-ip=208.118.235.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Authentication-Results: mx.zohomail.com; dkim=fail; spf=temperror (zoho.com: Error in retrieving data from DNS) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org Return-Path: Received: from lists.gnu.org (208.118.235.17 [208.118.235.17]) by mx.zohomail.com with SMTPS id 1508924598971315.5241761644651; Wed, 25 Oct 2017 02:43:18 -0700 (PDT) Received: from localhost ([::1]:47334 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1e7IDG-0005gu-5c for importer@patchew.org; Wed, 25 Oct 2017 05:43:02 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:45363) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1e7I6G-00084J-Db for qemu-devel@nongnu.org; Wed, 25 Oct 2017 05:35:52 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1e7I6C-0007nl-Vf for qemu-devel@nongnu.org; Wed, 25 Oct 2017 05:35:48 -0400 Received: from mail-wm0-x244.google.com ([2a00:1450:400c:c09::244]:50346) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1e7I6C-0007lM-Fw for qemu-devel@nongnu.org; Wed, 25 Oct 2017 05:35:44 -0400 Received: by mail-wm0-x244.google.com with SMTP id u138so593665wmu.5 for ; Wed, 25 Oct 2017 02:35:44 -0700 (PDT) Received: from cloudburst.twiddle.net ([62.168.35.107]) by smtp.gmail.com with ESMTPSA id v23sm2751025wmh.8.2017.10.25.02.35.41 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Wed, 25 Oct 2017 02:35:41 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=FiRl4dT33h54dNt39ROPOjr4aiwsPE8fLe2nG/qvoQg=; b=LKB+MGCcZRTob+QSFGwKIN2ZUbeUDYWe5GgZIkYSuUJ7+PMWKqCjpfAmeSzHjlEiz2 /fdH3rR4XprqJmMfVJkKqkQLPCf7A+v6talNf455m5QGU1Pv+Fq3EILwTm3bkVFmroT+ lXogwpWbtvWvxtTfx8xUD1IrTfE4Z9Bn0MRCU= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=FiRl4dT33h54dNt39ROPOjr4aiwsPE8fLe2nG/qvoQg=; b=tRmd/+Km0OZtGN1b2yUgkZXZX3Ii+WEcpaLbaYyZfWr02blbZJv1Gn42SlnBx1UjrN uunSvNWDRJnI0ocapSR3tYxffXKzAAdVVT+CVbyT8N5ZlKmvMwL2ShWA5ePSGwixRKFR pHDK2Ny50V9OdUC49+xR/zNT9/6sgEKSkROiW3yfOXWcmR1SHmu3hcEmyVyccPCPGb3c ztlRO1entiOBMqa2LIm9a/BABsHoWO4pmxOX14Zp3pzokg9xlqD40IaJ0u3eNh0y2gSQ eeeEpEOtZf6Y8VYA5vEBX0ICi9hKrUV83c8VGaA9GprIxTQ1NkLy05VUM+kDTumrcr+u leFw== X-Gm-Message-State: AMCzsaW/+Fnejt7NH+/In2rAO2H9Oq5lsS6mjLjZUzhbterspH5SMqZr pivIE217czMofZsxNRs2jEaHmrOYxBQ= X-Google-Smtp-Source: ABhQp+Si83L6/Lt/ptHGKBsDX2fQTxIUlm1sHyZcTS8V3lRqQkh0gUj7+fLrCfOa0nc8KzCjiRIiRA== X-Received: by 10.28.209.132 with SMTP id i126mr1085409wmg.65.1508924142721; Wed, 25 Oct 2017 02:35:42 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Date: Wed, 25 Oct 2017 11:34:46 +0200 Message-Id: <20171025093535.10175-3-richard.henderson@linaro.org> X-Mailer: git-send-email 2.13.6 In-Reply-To: <20171025093535.10175-1-richard.henderson@linaro.org> References: <20171025093535.10175-1-richard.henderson@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 2a00:1450:400c:c09::244 Subject: [Qemu-devel] [PULL 02/51] tcg: Propagate args to op->args in optimizer X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peter.maydell@linaro.org, Richard Henderson Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) X-ZohoMail: RDKM_2 RSF_6 Z_629925259 SPT_0 From: Richard Henderson Reviewed-by: Emilio G. Cota Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Richard Henderson --- tcg/optimize.c | 430 ++++++++++++++++++++++++++++++-----------------------= ---- 1 file changed, 227 insertions(+), 203 deletions(-) diff --git a/tcg/optimize.c b/tcg/optimize.c index 002aad6bf4..1a1c6fb90c 100644 --- a/tcg/optimize.c +++ b/tcg/optimize.c @@ -166,8 +166,7 @@ static bool temps_are_copies(TCGArg arg1, TCGArg arg2) return false; } =20 -static void tcg_opt_gen_movi(TCGContext *s, TCGOp *op, TCGArg *args, - TCGArg dst, TCGArg val) +static void tcg_opt_gen_movi(TCGContext *s, TCGOp *op, TCGArg dst, TCGArg = val) { TCGOpcode new_op =3D op_to_movi(op->opc); tcg_target_ulong mask; @@ -184,12 +183,11 @@ static void tcg_opt_gen_movi(TCGContext *s, TCGOp *op= , TCGArg *args, } temps[dst].mask =3D mask; =20 - args[0] =3D dst; - args[1] =3D val; + op->args[0] =3D dst; + op->args[1] =3D val; } =20 -static void tcg_opt_gen_mov(TCGContext *s, TCGOp *op, TCGArg *args, - TCGArg dst, TCGArg src) +static void tcg_opt_gen_mov(TCGContext *s, TCGOp *op, TCGArg dst, TCGArg s= rc) { if (temps_are_copies(dst, src)) { tcg_op_remove(s, op); @@ -218,8 +216,8 @@ static void tcg_opt_gen_mov(TCGContext *s, TCGOp *op, T= CGArg *args, temps[dst].val =3D temps[src].val; } =20 - args[0] =3D dst; - args[1] =3D src; + op->args[0] =3D dst; + op->args[1] =3D src; } =20 static TCGArg do_constant_folding_2(TCGOpcode op, TCGArg x, TCGArg y) @@ -559,7 +557,7 @@ static bool swap_commutative2(TCGArg *p1, TCGArg *p2) void tcg_optimize(TCGContext *s) { int oi, oi_next, nb_temps, nb_globals; - TCGArg *prev_mb_args =3D NULL; + TCGOp *prev_mb =3D NULL; =20 /* Array VALS has an element for each temp. If this temp holds a constant then its value is kept in VALS' eleme= nt. @@ -576,7 +574,6 @@ void tcg_optimize(TCGContext *s) TCGArg tmp; =20 TCGOp * const op =3D &s->gen_op_buf[oi]; - TCGArg * const args =3D op->args; TCGOpcode opc =3D op->opc; const TCGOpDef *def =3D &tcg_op_defs[opc]; =20 @@ -588,7 +585,7 @@ void tcg_optimize(TCGContext *s) nb_oargs =3D op->callo; nb_iargs =3D op->calli; for (i =3D 0; i < nb_oargs + nb_iargs; i++) { - tmp =3D args[i]; + tmp =3D op->args[i]; if (tmp !=3D TCG_CALL_DUMMY_ARG) { init_temp_info(tmp); } @@ -597,14 +594,14 @@ void tcg_optimize(TCGContext *s) nb_oargs =3D def->nb_oargs; nb_iargs =3D def->nb_iargs; for (i =3D 0; i < nb_oargs + nb_iargs; i++) { - init_temp_info(args[i]); + init_temp_info(op->args[i]); } } =20 /* Do copy propagation */ for (i =3D nb_oargs; i < nb_oargs + nb_iargs; i++) { - if (temp_is_copy(args[i])) { - args[i] =3D find_better_copy(s, args[i]); + if (temp_is_copy(op->args[i])) { + op->args[i] =3D find_better_copy(s, op->args[i]); } } =20 @@ -620,45 +617,45 @@ void tcg_optimize(TCGContext *s) CASE_OP_32_64(nor): CASE_OP_32_64(muluh): CASE_OP_32_64(mulsh): - swap_commutative(args[0], &args[1], &args[2]); + swap_commutative(op->args[0], &op->args[1], &op->args[2]); break; CASE_OP_32_64(brcond): - if (swap_commutative(-1, &args[0], &args[1])) { - args[2] =3D tcg_swap_cond(args[2]); + if (swap_commutative(-1, &op->args[0], &op->args[1])) { + op->args[2] =3D tcg_swap_cond(op->args[2]); } break; CASE_OP_32_64(setcond): - if (swap_commutative(args[0], &args[1], &args[2])) { - args[3] =3D tcg_swap_cond(args[3]); + if (swap_commutative(op->args[0], &op->args[1], &op->args[2]))= { + op->args[3] =3D tcg_swap_cond(op->args[3]); } break; CASE_OP_32_64(movcond): - if (swap_commutative(-1, &args[1], &args[2])) { - args[5] =3D tcg_swap_cond(args[5]); + if (swap_commutative(-1, &op->args[1], &op->args[2])) { + op->args[5] =3D tcg_swap_cond(op->args[5]); } /* For movcond, we canonicalize the "false" input reg to match the destination reg so that the tcg backend can implement a "move if true" operation. */ - if (swap_commutative(args[0], &args[4], &args[3])) { - args[5] =3D tcg_invert_cond(args[5]); + if (swap_commutative(op->args[0], &op->args[4], &op->args[3]))= { + op->args[5] =3D tcg_invert_cond(op->args[5]); } break; CASE_OP_32_64(add2): - swap_commutative(args[0], &args[2], &args[4]); - swap_commutative(args[1], &args[3], &args[5]); + swap_commutative(op->args[0], &op->args[2], &op->args[4]); + swap_commutative(op->args[1], &op->args[3], &op->args[5]); break; CASE_OP_32_64(mulu2): CASE_OP_32_64(muls2): - swap_commutative(args[0], &args[2], &args[3]); + swap_commutative(op->args[0], &op->args[2], &op->args[3]); break; case INDEX_op_brcond2_i32: - if (swap_commutative2(&args[0], &args[2])) { - args[4] =3D tcg_swap_cond(args[4]); + if (swap_commutative2(&op->args[0], &op->args[2])) { + op->args[4] =3D tcg_swap_cond(op->args[4]); } break; case INDEX_op_setcond2_i32: - if (swap_commutative2(&args[1], &args[3])) { - args[5] =3D tcg_swap_cond(args[5]); + if (swap_commutative2(&op->args[1], &op->args[3])) { + op->args[5] =3D tcg_swap_cond(op->args[5]); } break; default: @@ -673,8 +670,8 @@ void tcg_optimize(TCGContext *s) CASE_OP_32_64(sar): CASE_OP_32_64(rotl): CASE_OP_32_64(rotr): - if (temp_is_const(args[1]) && temps[args[1]].val =3D=3D 0) { - tcg_opt_gen_movi(s, op, args, args[0], 0); + if (temp_is_const(op->args[1]) && temps[op->args[1]].val =3D= =3D 0) { + tcg_opt_gen_movi(s, op, op->args[0], 0); continue; } break; @@ -683,7 +680,7 @@ void tcg_optimize(TCGContext *s) TCGOpcode neg_op; bool have_neg; =20 - if (temp_is_const(args[2])) { + if (temp_is_const(op->args[2])) { /* Proceed with possible constant folding. */ break; } @@ -697,40 +694,45 @@ void tcg_optimize(TCGContext *s) if (!have_neg) { break; } - if (temp_is_const(args[1]) && temps[args[1]].val =3D=3D 0)= { + if (temp_is_const(op->args[1]) + && temps[op->args[1]].val =3D=3D 0) { op->opc =3D neg_op; - reset_temp(args[0]); - args[1] =3D args[2]; + reset_temp(op->args[0]); + op->args[1] =3D op->args[2]; continue; } } break; CASE_OP_32_64(xor): CASE_OP_32_64(nand): - if (!temp_is_const(args[1]) - && temp_is_const(args[2]) && temps[args[2]].val =3D=3D -1)= { + if (!temp_is_const(op->args[1]) + && temp_is_const(op->args[2]) + && temps[op->args[2]].val =3D=3D -1) { i =3D 1; goto try_not; } break; CASE_OP_32_64(nor): - if (!temp_is_const(args[1]) - && temp_is_const(args[2]) && temps[args[2]].val =3D=3D 0) { + if (!temp_is_const(op->args[1]) + && temp_is_const(op->args[2]) + && temps[op->args[2]].val =3D=3D 0) { i =3D 1; goto try_not; } break; CASE_OP_32_64(andc): - if (!temp_is_const(args[2]) - && temp_is_const(args[1]) && temps[args[1]].val =3D=3D -1)= { + if (!temp_is_const(op->args[2]) + && temp_is_const(op->args[1]) + && temps[op->args[1]].val =3D=3D -1) { i =3D 2; goto try_not; } break; CASE_OP_32_64(orc): CASE_OP_32_64(eqv): - if (!temp_is_const(args[2]) - && temp_is_const(args[1]) && temps[args[1]].val =3D=3D 0) { + if (!temp_is_const(op->args[2]) + && temp_is_const(op->args[1]) + && temps[op->args[1]].val =3D=3D 0) { i =3D 2; goto try_not; } @@ -751,8 +753,8 @@ void tcg_optimize(TCGContext *s) break; } op->opc =3D not_op; - reset_temp(args[0]); - args[1] =3D args[i]; + reset_temp(op->args[0]); + op->args[1] =3D op->args[i]; continue; } default: @@ -771,18 +773,20 @@ void tcg_optimize(TCGContext *s) CASE_OP_32_64(or): CASE_OP_32_64(xor): CASE_OP_32_64(andc): - if (!temp_is_const(args[1]) - && temp_is_const(args[2]) && temps[args[2]].val =3D=3D 0) { - tcg_opt_gen_mov(s, op, args, args[0], args[1]); + if (!temp_is_const(op->args[1]) + && temp_is_const(op->args[2]) + && temps[op->args[2]].val =3D=3D 0) { + tcg_opt_gen_mov(s, op, op->args[0], op->args[1]); continue; } break; CASE_OP_32_64(and): CASE_OP_32_64(orc): CASE_OP_32_64(eqv): - if (!temp_is_const(args[1]) - && temp_is_const(args[2]) && temps[args[2]].val =3D=3D -1)= { - tcg_opt_gen_mov(s, op, args, args[0], args[1]); + if (!temp_is_const(op->args[1]) + && temp_is_const(op->args[2]) + && temps[op->args[2]].val =3D=3D -1) { + tcg_opt_gen_mov(s, op, op->args[0], op->args[1]); continue; } break; @@ -796,21 +800,21 @@ void tcg_optimize(TCGContext *s) affected =3D -1; switch (opc) { CASE_OP_32_64(ext8s): - if ((temps[args[1]].mask & 0x80) !=3D 0) { + if ((temps[op->args[1]].mask & 0x80) !=3D 0) { break; } CASE_OP_32_64(ext8u): mask =3D 0xff; goto and_const; CASE_OP_32_64(ext16s): - if ((temps[args[1]].mask & 0x8000) !=3D 0) { + if ((temps[op->args[1]].mask & 0x8000) !=3D 0) { break; } CASE_OP_32_64(ext16u): mask =3D 0xffff; goto and_const; case INDEX_op_ext32s_i64: - if ((temps[args[1]].mask & 0x80000000) !=3D 0) { + if ((temps[op->args[1]].mask & 0x80000000) !=3D 0) { break; } case INDEX_op_ext32u_i64: @@ -818,110 +822,111 @@ void tcg_optimize(TCGContext *s) goto and_const; =20 CASE_OP_32_64(and): - mask =3D temps[args[2]].mask; - if (temp_is_const(args[2])) { + mask =3D temps[op->args[2]].mask; + if (temp_is_const(op->args[2])) { and_const: - affected =3D temps[args[1]].mask & ~mask; + affected =3D temps[op->args[1]].mask & ~mask; } - mask =3D temps[args[1]].mask & mask; + mask =3D temps[op->args[1]].mask & mask; break; =20 case INDEX_op_ext_i32_i64: - if ((temps[args[1]].mask & 0x80000000) !=3D 0) { + if ((temps[op->args[1]].mask & 0x80000000) !=3D 0) { break; } case INDEX_op_extu_i32_i64: /* We do not compute affected as it is a size changing op. */ - mask =3D (uint32_t)temps[args[1]].mask; + mask =3D (uint32_t)temps[op->args[1]].mask; break; =20 CASE_OP_32_64(andc): /* Known-zeros does not imply known-ones. Therefore unless - args[2] is constant, we can't infer anything from it. */ - if (temp_is_const(args[2])) { - mask =3D ~temps[args[2]].mask; + op->args[2] is constant, we can't infer anything from it. = */ + if (temp_is_const(op->args[2])) { + mask =3D ~temps[op->args[2]].mask; goto and_const; } - /* But we certainly know nothing outside args[1] may be set. */ - mask =3D temps[args[1]].mask; + /* But we certainly know nothing outside op->args[1] may be se= t. */ + mask =3D temps[op->args[1]].mask; break; =20 case INDEX_op_sar_i32: - if (temp_is_const(args[2])) { - tmp =3D temps[args[2]].val & 31; - mask =3D (int32_t)temps[args[1]].mask >> tmp; + if (temp_is_const(op->args[2])) { + tmp =3D temps[op->args[2]].val & 31; + mask =3D (int32_t)temps[op->args[1]].mask >> tmp; } break; case INDEX_op_sar_i64: - if (temp_is_const(args[2])) { - tmp =3D temps[args[2]].val & 63; - mask =3D (int64_t)temps[args[1]].mask >> tmp; + if (temp_is_const(op->args[2])) { + tmp =3D temps[op->args[2]].val & 63; + mask =3D (int64_t)temps[op->args[1]].mask >> tmp; } break; =20 case INDEX_op_shr_i32: - if (temp_is_const(args[2])) { - tmp =3D temps[args[2]].val & 31; - mask =3D (uint32_t)temps[args[1]].mask >> tmp; + if (temp_is_const(op->args[2])) { + tmp =3D temps[op->args[2]].val & 31; + mask =3D (uint32_t)temps[op->args[1]].mask >> tmp; } break; case INDEX_op_shr_i64: - if (temp_is_const(args[2])) { - tmp =3D temps[args[2]].val & 63; - mask =3D (uint64_t)temps[args[1]].mask >> tmp; + if (temp_is_const(op->args[2])) { + tmp =3D temps[op->args[2]].val & 63; + mask =3D (uint64_t)temps[op->args[1]].mask >> tmp; } break; =20 case INDEX_op_extrl_i64_i32: - mask =3D (uint32_t)temps[args[1]].mask; + mask =3D (uint32_t)temps[op->args[1]].mask; break; case INDEX_op_extrh_i64_i32: - mask =3D (uint64_t)temps[args[1]].mask >> 32; + mask =3D (uint64_t)temps[op->args[1]].mask >> 32; break; =20 CASE_OP_32_64(shl): - if (temp_is_const(args[2])) { - tmp =3D temps[args[2]].val & (TCG_TARGET_REG_BITS - 1); - mask =3D temps[args[1]].mask << tmp; + if (temp_is_const(op->args[2])) { + tmp =3D temps[op->args[2]].val & (TCG_TARGET_REG_BITS - 1); + mask =3D temps[op->args[1]].mask << tmp; } break; =20 CASE_OP_32_64(neg): /* Set to 1 all bits to the left of the rightmost. */ - mask =3D -(temps[args[1]].mask & -temps[args[1]].mask); + mask =3D -(temps[op->args[1]].mask & -temps[op->args[1]].mask); break; =20 CASE_OP_32_64(deposit): - mask =3D deposit64(temps[args[1]].mask, args[3], args[4], - temps[args[2]].mask); + mask =3D deposit64(temps[op->args[1]].mask, op->args[3], + op->args[4], temps[op->args[2]].mask); break; =20 CASE_OP_32_64(extract): - mask =3D extract64(temps[args[1]].mask, args[2], args[3]); - if (args[2] =3D=3D 0) { - affected =3D temps[args[1]].mask & ~mask; + mask =3D extract64(temps[op->args[1]].mask, op->args[2], op->a= rgs[3]); + if (op->args[2] =3D=3D 0) { + affected =3D temps[op->args[1]].mask & ~mask; } break; CASE_OP_32_64(sextract): - mask =3D sextract64(temps[args[1]].mask, args[2], args[3]); - if (args[2] =3D=3D 0 && (tcg_target_long)mask >=3D 0) { - affected =3D temps[args[1]].mask & ~mask; + mask =3D sextract64(temps[op->args[1]].mask, + op->args[2], op->args[3]); + if (op->args[2] =3D=3D 0 && (tcg_target_long)mask >=3D 0) { + affected =3D temps[op->args[1]].mask & ~mask; } break; =20 CASE_OP_32_64(or): CASE_OP_32_64(xor): - mask =3D temps[args[1]].mask | temps[args[2]].mask; + mask =3D temps[op->args[1]].mask | temps[op->args[2]].mask; break; =20 case INDEX_op_clz_i32: case INDEX_op_ctz_i32: - mask =3D temps[args[2]].mask | 31; + mask =3D temps[op->args[2]].mask | 31; break; =20 case INDEX_op_clz_i64: case INDEX_op_ctz_i64: - mask =3D temps[args[2]].mask | 63; + mask =3D temps[op->args[2]].mask | 63; break; =20 case INDEX_op_ctpop_i32: @@ -937,7 +942,7 @@ void tcg_optimize(TCGContext *s) break; =20 CASE_OP_32_64(movcond): - mask =3D temps[args[3]].mask | temps[args[4]].mask; + mask =3D temps[op->args[3]].mask | temps[op->args[4]].mask; break; =20 CASE_OP_32_64(ld8u): @@ -952,7 +957,7 @@ void tcg_optimize(TCGContext *s) =20 CASE_OP_32_64(qemu_ld): { - TCGMemOpIdx oi =3D args[nb_oargs + nb_iargs]; + TCGMemOpIdx oi =3D op->args[nb_oargs + nb_iargs]; TCGMemOp mop =3D get_memop(oi); if (!(mop & MO_SIGN)) { mask =3D (2ULL << ((8 << (mop & MO_SIZE)) - 1)) - 1; @@ -976,12 +981,12 @@ void tcg_optimize(TCGContext *s) =20 if (partmask =3D=3D 0) { tcg_debug_assert(nb_oargs =3D=3D 1); - tcg_opt_gen_movi(s, op, args, args[0], 0); + tcg_opt_gen_movi(s, op, op->args[0], 0); continue; } if (affected =3D=3D 0) { tcg_debug_assert(nb_oargs =3D=3D 1); - tcg_opt_gen_mov(s, op, args, args[0], args[1]); + tcg_opt_gen_mov(s, op, op->args[0], op->args[1]); continue; } =20 @@ -991,8 +996,8 @@ void tcg_optimize(TCGContext *s) CASE_OP_32_64(mul): CASE_OP_32_64(muluh): CASE_OP_32_64(mulsh): - if ((temp_is_const(args[2]) && temps[args[2]].val =3D=3D 0)) { - tcg_opt_gen_movi(s, op, args, args[0], 0); + if ((temp_is_const(op->args[2]) && temps[op->args[2]].val =3D= =3D 0)) { + tcg_opt_gen_movi(s, op, op->args[0], 0); continue; } break; @@ -1004,8 +1009,8 @@ void tcg_optimize(TCGContext *s) switch (opc) { CASE_OP_32_64(or): CASE_OP_32_64(and): - if (temps_are_copies(args[1], args[2])) { - tcg_opt_gen_mov(s, op, args, args[0], args[1]); + if (temps_are_copies(op->args[1], op->args[2])) { + tcg_opt_gen_mov(s, op, op->args[0], op->args[1]); continue; } break; @@ -1018,8 +1023,8 @@ void tcg_optimize(TCGContext *s) CASE_OP_32_64(andc): CASE_OP_32_64(sub): CASE_OP_32_64(xor): - if (temps_are_copies(args[1], args[2])) { - tcg_opt_gen_movi(s, op, args, args[0], 0); + if (temps_are_copies(op->args[1], op->args[2])) { + tcg_opt_gen_movi(s, op, op->args[0], 0); continue; } break; @@ -1032,10 +1037,10 @@ void tcg_optimize(TCGContext *s) allocator where needed and possible. Also detect copies. */ switch (opc) { CASE_OP_32_64(mov): - tcg_opt_gen_mov(s, op, args, args[0], args[1]); + tcg_opt_gen_mov(s, op, op->args[0], op->args[1]); break; CASE_OP_32_64(movi): - tcg_opt_gen_movi(s, op, args, args[0], args[1]); + tcg_opt_gen_movi(s, op, op->args[0], op->args[1]); break; =20 CASE_OP_32_64(not): @@ -1051,9 +1056,9 @@ void tcg_optimize(TCGContext *s) case INDEX_op_extu_i32_i64: case INDEX_op_extrl_i64_i32: case INDEX_op_extrh_i64_i32: - if (temp_is_const(args[1])) { - tmp =3D do_constant_folding(opc, temps[args[1]].val, 0); - tcg_opt_gen_movi(s, op, args, args[0], tmp); + if (temp_is_const(op->args[1])) { + tmp =3D do_constant_folding(opc, temps[op->args[1]].val, 0= ); + tcg_opt_gen_movi(s, op, op->args[0], tmp); break; } goto do_default; @@ -1080,68 +1085,72 @@ void tcg_optimize(TCGContext *s) CASE_OP_32_64(divu): CASE_OP_32_64(rem): CASE_OP_32_64(remu): - if (temp_is_const(args[1]) && temp_is_const(args[2])) { - tmp =3D do_constant_folding(opc, temps[args[1]].val, - temps[args[2]].val); - tcg_opt_gen_movi(s, op, args, args[0], tmp); + if (temp_is_const(op->args[1]) && temp_is_const(op->args[2])) { + tmp =3D do_constant_folding(opc, temps[op->args[1]].val, + temps[op->args[2]].val); + tcg_opt_gen_movi(s, op, op->args[0], tmp); break; } goto do_default; =20 CASE_OP_32_64(clz): CASE_OP_32_64(ctz): - if (temp_is_const(args[1])) { - TCGArg v =3D temps[args[1]].val; + if (temp_is_const(op->args[1])) { + TCGArg v =3D temps[op->args[1]].val; if (v !=3D 0) { tmp =3D do_constant_folding(opc, v, 0); - tcg_opt_gen_movi(s, op, args, args[0], tmp); + tcg_opt_gen_movi(s, op, op->args[0], tmp); } else { - tcg_opt_gen_mov(s, op, args, args[0], args[2]); + tcg_opt_gen_mov(s, op, op->args[0], op->args[2]); } break; } goto do_default; =20 CASE_OP_32_64(deposit): - if (temp_is_const(args[1]) && temp_is_const(args[2])) { - tmp =3D deposit64(temps[args[1]].val, args[3], args[4], - temps[args[2]].val); - tcg_opt_gen_movi(s, op, args, args[0], tmp); + if (temp_is_const(op->args[1]) && temp_is_const(op->args[2])) { + tmp =3D deposit64(temps[op->args[1]].val, op->args[3], + op->args[4], temps[op->args[2]].val); + tcg_opt_gen_movi(s, op, op->args[0], tmp); break; } goto do_default; =20 CASE_OP_32_64(extract): - if (temp_is_const(args[1])) { - tmp =3D extract64(temps[args[1]].val, args[2], args[3]); - tcg_opt_gen_movi(s, op, args, args[0], tmp); + if (temp_is_const(op->args[1])) { + tmp =3D extract64(temps[op->args[1]].val, + op->args[2], op->args[3]); + tcg_opt_gen_movi(s, op, op->args[0], tmp); break; } goto do_default; =20 CASE_OP_32_64(sextract): - if (temp_is_const(args[1])) { - tmp =3D sextract64(temps[args[1]].val, args[2], args[3]); - tcg_opt_gen_movi(s, op, args, args[0], tmp); + if (temp_is_const(op->args[1])) { + tmp =3D sextract64(temps[op->args[1]].val, + op->args[2], op->args[3]); + tcg_opt_gen_movi(s, op, op->args[0], tmp); break; } goto do_default; =20 CASE_OP_32_64(setcond): - tmp =3D do_constant_folding_cond(opc, args[1], args[2], args[3= ]); + tmp =3D do_constant_folding_cond(opc, op->args[1], + op->args[2], op->args[3]); if (tmp !=3D 2) { - tcg_opt_gen_movi(s, op, args, args[0], tmp); + tcg_opt_gen_movi(s, op, op->args[0], tmp); break; } goto do_default; =20 CASE_OP_32_64(brcond): - tmp =3D do_constant_folding_cond(opc, args[0], args[1], args[2= ]); + tmp =3D do_constant_folding_cond(opc, op->args[0], + op->args[1], op->args[2]); if (tmp !=3D 2) { if (tmp) { reset_all_temps(nb_temps); op->opc =3D INDEX_op_br; - args[0] =3D args[3]; + op->args[0] =3D op->args[3]; } else { tcg_op_remove(s, op); } @@ -1150,21 +1159,22 @@ void tcg_optimize(TCGContext *s) goto do_default; =20 CASE_OP_32_64(movcond): - tmp =3D do_constant_folding_cond(opc, args[1], args[2], args[5= ]); + tmp =3D do_constant_folding_cond(opc, op->args[1], + op->args[2], op->args[5]); if (tmp !=3D 2) { - tcg_opt_gen_mov(s, op, args, args[0], args[4-tmp]); + tcg_opt_gen_mov(s, op, op->args[0], op->args[4-tmp]); break; } - if (temp_is_const(args[3]) && temp_is_const(args[4])) { - tcg_target_ulong tv =3D temps[args[3]].val; - tcg_target_ulong fv =3D temps[args[4]].val; - TCGCond cond =3D args[5]; + if (temp_is_const(op->args[3]) && temp_is_const(op->args[4])) { + tcg_target_ulong tv =3D temps[op->args[3]].val; + tcg_target_ulong fv =3D temps[op->args[4]].val; + TCGCond cond =3D op->args[5]; if (fv =3D=3D 1 && tv =3D=3D 0) { cond =3D tcg_invert_cond(cond); } else if (!(tv =3D=3D 1 && fv =3D=3D 0)) { goto do_default; } - args[3] =3D cond; + op->args[3] =3D cond; op->opc =3D opc =3D (opc =3D=3D INDEX_op_movcond_i32 ? INDEX_op_setcond_i32 : INDEX_op_setcond_i64); @@ -1174,17 +1184,16 @@ void tcg_optimize(TCGContext *s) =20 case INDEX_op_add2_i32: case INDEX_op_sub2_i32: - if (temp_is_const(args[2]) && temp_is_const(args[3]) - && temp_is_const(args[4]) && temp_is_const(args[5])) { - uint32_t al =3D temps[args[2]].val; - uint32_t ah =3D temps[args[3]].val; - uint32_t bl =3D temps[args[4]].val; - uint32_t bh =3D temps[args[5]].val; + if (temp_is_const(op->args[2]) && temp_is_const(op->args[3]) + && temp_is_const(op->args[4]) && temp_is_const(op->args[5]= )) { + uint32_t al =3D temps[op->args[2]].val; + uint32_t ah =3D temps[op->args[3]].val; + uint32_t bl =3D temps[op->args[4]].val; + uint32_t bh =3D temps[op->args[5]].val; uint64_t a =3D ((uint64_t)ah << 32) | al; uint64_t b =3D ((uint64_t)bh << 32) | bl; TCGArg rl, rh; TCGOp *op2 =3D tcg_op_insert_before(s, op, INDEX_op_movi_i= 32, 2); - TCGArg *args2 =3D op2->args; =20 if (opc =3D=3D INDEX_op_add2_i32) { a +=3D b; @@ -1192,10 +1201,10 @@ void tcg_optimize(TCGContext *s) a -=3D b; } =20 - rl =3D args[0]; - rh =3D args[1]; - tcg_opt_gen_movi(s, op, args, rl, (int32_t)a); - tcg_opt_gen_movi(s, op2, args2, rh, (int32_t)(a >> 32)); + rl =3D op->args[0]; + rh =3D op->args[1]; + tcg_opt_gen_movi(s, op, rl, (int32_t)a); + tcg_opt_gen_movi(s, op2, rh, (int32_t)(a >> 32)); =20 /* We've done all we need to do with the movi. Skip it. = */ oi_next =3D op2->next; @@ -1204,18 +1213,17 @@ void tcg_optimize(TCGContext *s) goto do_default; =20 case INDEX_op_mulu2_i32: - if (temp_is_const(args[2]) && temp_is_const(args[3])) { - uint32_t a =3D temps[args[2]].val; - uint32_t b =3D temps[args[3]].val; + if (temp_is_const(op->args[2]) && temp_is_const(op->args[3])) { + uint32_t a =3D temps[op->args[2]].val; + uint32_t b =3D temps[op->args[3]].val; uint64_t r =3D (uint64_t)a * b; TCGArg rl, rh; TCGOp *op2 =3D tcg_op_insert_before(s, op, INDEX_op_movi_i= 32, 2); - TCGArg *args2 =3D op2->args; =20 - rl =3D args[0]; - rh =3D args[1]; - tcg_opt_gen_movi(s, op, args, rl, (int32_t)r); - tcg_opt_gen_movi(s, op2, args2, rh, (int32_t)(r >> 32)); + rl =3D op->args[0]; + rh =3D op->args[1]; + tcg_opt_gen_movi(s, op, rl, (int32_t)r); + tcg_opt_gen_movi(s, op2, rh, (int32_t)(r >> 32)); =20 /* We've done all we need to do with the movi. Skip it. = */ oi_next =3D op2->next; @@ -1224,41 +1232,47 @@ void tcg_optimize(TCGContext *s) goto do_default; =20 case INDEX_op_brcond2_i32: - tmp =3D do_constant_folding_cond2(&args[0], &args[2], args[4]); + tmp =3D do_constant_folding_cond2(&op->args[0], &op->args[2], + op->args[4]); if (tmp !=3D 2) { if (tmp) { do_brcond_true: reset_all_temps(nb_temps); op->opc =3D INDEX_op_br; - args[0] =3D args[5]; + op->args[0] =3D op->args[5]; } else { do_brcond_false: tcg_op_remove(s, op); } - } else if ((args[4] =3D=3D TCG_COND_LT || args[4] =3D=3D TCG_C= OND_GE) - && temp_is_const(args[2]) && temps[args[2]].val =3D= =3D 0 - && temp_is_const(args[3]) && temps[args[3]].val =3D= =3D 0) { + } else if ((op->args[4] =3D=3D TCG_COND_LT + || op->args[4] =3D=3D TCG_COND_GE) + && temp_is_const(op->args[2]) + && temps[op->args[2]].val =3D=3D 0 + && temp_is_const(op->args[3]) + && temps[op->args[3]].val =3D=3D 0) { /* Simplify LT/GE comparisons vs zero to a single compare vs the high word of the input. */ do_brcond_high: reset_all_temps(nb_temps); op->opc =3D INDEX_op_brcond_i32; - args[0] =3D args[1]; - args[1] =3D args[3]; - args[2] =3D args[4]; - args[3] =3D args[5]; - } else if (args[4] =3D=3D TCG_COND_EQ) { + op->args[0] =3D op->args[1]; + op->args[1] =3D op->args[3]; + op->args[2] =3D op->args[4]; + op->args[3] =3D op->args[5]; + } else if (op->args[4] =3D=3D TCG_COND_EQ) { /* Simplify EQ comparisons where one of the pairs can be simplified. */ tmp =3D do_constant_folding_cond(INDEX_op_brcond_i32, - args[0], args[2], TCG_COND_= EQ); + op->args[0], op->args[2], + TCG_COND_EQ); if (tmp =3D=3D 0) { goto do_brcond_false; } else if (tmp =3D=3D 1) { goto do_brcond_high; } tmp =3D do_constant_folding_cond(INDEX_op_brcond_i32, - args[1], args[3], TCG_COND_= EQ); + op->args[1], op->args[3], + TCG_COND_EQ); if (tmp =3D=3D 0) { goto do_brcond_false; } else if (tmp !=3D 1) { @@ -1267,21 +1281,23 @@ void tcg_optimize(TCGContext *s) do_brcond_low: reset_all_temps(nb_temps); op->opc =3D INDEX_op_brcond_i32; - args[1] =3D args[2]; - args[2] =3D args[4]; - args[3] =3D args[5]; - } else if (args[4] =3D=3D TCG_COND_NE) { + op->args[1] =3D op->args[2]; + op->args[2] =3D op->args[4]; + op->args[3] =3D op->args[5]; + } else if (op->args[4] =3D=3D TCG_COND_NE) { /* Simplify NE comparisons where one of the pairs can be simplified. */ tmp =3D do_constant_folding_cond(INDEX_op_brcond_i32, - args[0], args[2], TCG_COND_= NE); + op->args[0], op->args[2], + TCG_COND_NE); if (tmp =3D=3D 0) { goto do_brcond_high; } else if (tmp =3D=3D 1) { goto do_brcond_true; } tmp =3D do_constant_folding_cond(INDEX_op_brcond_i32, - args[1], args[3], TCG_COND_= NE); + op->args[1], op->args[3], + TCG_COND_NE); if (tmp =3D=3D 0) { goto do_brcond_low; } else if (tmp =3D=3D 1) { @@ -1294,57 +1310,65 @@ void tcg_optimize(TCGContext *s) break; =20 case INDEX_op_setcond2_i32: - tmp =3D do_constant_folding_cond2(&args[1], &args[3], args[5]); + tmp =3D do_constant_folding_cond2(&op->args[1], &op->args[3], + op->args[5]); if (tmp !=3D 2) { do_setcond_const: - tcg_opt_gen_movi(s, op, args, args[0], tmp); - } else if ((args[5] =3D=3D TCG_COND_LT || args[5] =3D=3D TCG_C= OND_GE) - && temp_is_const(args[3]) && temps[args[3]].val =3D= =3D 0 - && temp_is_const(args[4]) && temps[args[4]].val =3D= =3D 0) { + tcg_opt_gen_movi(s, op, op->args[0], tmp); + } else if ((op->args[5] =3D=3D TCG_COND_LT + || op->args[5] =3D=3D TCG_COND_GE) + && temp_is_const(op->args[3]) + && temps[op->args[3]].val =3D=3D 0 + && temp_is_const(op->args[4]) + && temps[op->args[4]].val =3D=3D 0) { /* Simplify LT/GE comparisons vs zero to a single compare vs the high word of the input. */ do_setcond_high: - reset_temp(args[0]); - temps[args[0]].mask =3D 1; + reset_temp(op->args[0]); + temps[op->args[0]].mask =3D 1; op->opc =3D INDEX_op_setcond_i32; - args[1] =3D args[2]; - args[2] =3D args[4]; - args[3] =3D args[5]; - } else if (args[5] =3D=3D TCG_COND_EQ) { + op->args[1] =3D op->args[2]; + op->args[2] =3D op->args[4]; + op->args[3] =3D op->args[5]; + } else if (op->args[5] =3D=3D TCG_COND_EQ) { /* Simplify EQ comparisons where one of the pairs can be simplified. */ tmp =3D do_constant_folding_cond(INDEX_op_setcond_i32, - args[1], args[3], TCG_COND_= EQ); + op->args[1], op->args[3], + TCG_COND_EQ); if (tmp =3D=3D 0) { goto do_setcond_const; } else if (tmp =3D=3D 1) { goto do_setcond_high; } tmp =3D do_constant_folding_cond(INDEX_op_setcond_i32, - args[2], args[4], TCG_COND_= EQ); + op->args[2], op->args[4], + TCG_COND_EQ); if (tmp =3D=3D 0) { goto do_setcond_high; } else if (tmp !=3D 1) { goto do_default; } do_setcond_low: - reset_temp(args[0]); - temps[args[0]].mask =3D 1; + reset_temp(op->args[0]); + temps[op->args[0]].mask =3D 1; op->opc =3D INDEX_op_setcond_i32; - args[2] =3D args[3]; - args[3] =3D args[5]; - } else if (args[5] =3D=3D TCG_COND_NE) { + op->args[2] =3D op->args[3]; + op->args[3] =3D op->args[5]; + } else if (op->args[5] =3D=3D TCG_COND_NE) { /* Simplify NE comparisons where one of the pairs can be simplified. */ tmp =3D do_constant_folding_cond(INDEX_op_setcond_i32, - args[1], args[3], TCG_COND_= NE); + op->args[1], op->args[3], + TCG_COND_NE); if (tmp =3D=3D 0) { goto do_setcond_high; } else if (tmp =3D=3D 1) { goto do_setcond_const; } tmp =3D do_constant_folding_cond(INDEX_op_setcond_i32, - args[2], args[4], TCG_COND_= NE); + op->args[2], op->args[4], + TCG_COND_NE); if (tmp =3D=3D 0) { goto do_setcond_low; } else if (tmp =3D=3D 1) { @@ -1357,7 +1381,7 @@ void tcg_optimize(TCGContext *s) break; =20 case INDEX_op_call: - if (!(args[nb_oargs + nb_iargs + 1] + if (!(op->args[nb_oargs + nb_iargs + 1] & (TCG_CALL_NO_READ_GLOBALS | TCG_CALL_NO_WRITE_GLOBALS)= )) { for (i =3D 0; i < nb_globals; i++) { if (test_bit(i, temps_used.l)) { @@ -1379,11 +1403,11 @@ void tcg_optimize(TCGContext *s) } else { do_reset_output: for (i =3D 0; i < nb_oargs; i++) { - reset_temp(args[i]); + reset_temp(op->args[i]); /* Save the corresponding known-zero bits mask for the first output argument (only one supported so far). = */ if (i =3D=3D 0) { - temps[args[i]].mask =3D mask; + temps[op->args[i]].mask =3D mask; } } } @@ -1391,7 +1415,7 @@ void tcg_optimize(TCGContext *s) } =20 /* Eliminate duplicate and redundant fence instructions. */ - if (prev_mb_args) { + if (prev_mb) { switch (opc) { case INDEX_op_mb: /* Merge two barriers of the same type into one, @@ -1405,7 +1429,7 @@ void tcg_optimize(TCGContext *s) * barrier. This is stricter than specified but for * the purposes of TCG is better than not optimizing. */ - prev_mb_args[0] |=3D args[0]; + prev_mb->args[0] |=3D op->args[0]; tcg_op_remove(s, op); break; =20 @@ -1421,11 +1445,11 @@ void tcg_optimize(TCGContext *s) case INDEX_op_qemu_st_i64: case INDEX_op_call: /* Opcodes that touch guest memory stop the optimization. = */ - prev_mb_args =3D NULL; + prev_mb =3D NULL; break; } } else if (opc =3D=3D INDEX_op_mb) { - prev_mb_args =3D args; + prev_mb =3D op; } } } --=20 2.13.6