From nobody Mon Feb 9 07:56:43 2026 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) client-ip=208.118.235.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Authentication-Results: mx.zoho.com; dkim=fail spf=pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; Return-Path: Received: from lists.gnu.org (lists.gnu.org [208.118.235.17]) by mx.zohomail.com with SMTPS id 1498014020179189.09977022078488; Tue, 20 Jun 2017 20:00:20 -0700 (PDT) Received: from localhost ([::1]:51577 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1dNVsQ-0007Tq-I1 for importer@patchew.org; Tue, 20 Jun 2017 23:00:18 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:34002) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1dNVhS-0006dy-Q0 for qemu-devel@nongnu.org; Tue, 20 Jun 2017 22:49:02 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1dNVhP-0002SL-Sz for qemu-devel@nongnu.org; Tue, 20 Jun 2017 22:48:58 -0400 Received: from mail-qt0-x244.google.com ([2607:f8b0:400d:c0d::244]:34446) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1dNVhP-0002SD-LL for qemu-devel@nongnu.org; Tue, 20 Jun 2017 22:48:55 -0400 Received: by mail-qt0-x244.google.com with SMTP id o21so25678466qtb.1 for ; Tue, 20 Jun 2017 19:48:55 -0700 (PDT) Received: from bigtime.twiddle.net.com (97-113-165-157.tukw.qwest.net. [97.113.165.157]) by smtp.gmail.com with ESMTPSA id l53sm2478939qta.56.2017.06.20.19.48.53 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 20 Jun 2017 19:48:53 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references; bh=lPb0fPdDAUcj4lQB2aKdxKHqeegpDzIrXlltotQYDqM=; b=M9oB8RdDE3WhQZ87ZgddTaVU02ft/YurdYOofzUBnybTa/81LN1lF8KIpKBlYbOp2e 5Ysp1IQ9YzcZyDJW5ZggvN9lA3Tx20wnvS73OEkscvMh17z3dmEIF2HFkX/L1ycD379A pS2ywwVvtmbRP9VMURUsMWb5Auu3AzNSPWwyajw6RGxVLhHPkbdyFoUuuJotqVUJtTRk xS5qj0ez9RVWVvHewQYpcwLSRyzAPIkbToHzhqAXzJFdK9k/9dewHtGhDsLEHpPKyQOz ulkDL3vidcYhiaMuvwyEkOB33XIKorDO2tW5pxK8G/RYyoVUZdILgrgL8SSDgsw9vRbA tVrQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references; bh=lPb0fPdDAUcj4lQB2aKdxKHqeegpDzIrXlltotQYDqM=; b=EONFl5S8FFTR0PZN/b3c8wPctCmZNprWlPPI1wm7pfQnAt1i4v/6z5S+OL6UJr0Us3 wv9O8CwCJJkjzj4KnhorVDT+AIiHmQIGwGsnn1prwoTxZHLGK92MCI5wCLYhC9FS26/a N2nw1XzEvEIOI/7pGLPtmhad+63n/TsjLDIlKFxMONJUNTI8ZHke7qC/OjSnJRJ8u2qD bV6JRoDLYhtF3vB5UVF0yX54CBPulLgT6kAwMvInRiA3EGO8irSK9g4OYfhgmaSAo2QE TmnaFw3Nj2AyHpW4o9Sn3RB5+TyOnA/lRHqYk17wwme+kfe7qcyvDP8Fc1QaSgtToTeq ApCg== X-Gm-Message-State: AKS2vOzVDficCkmlcqPLzRUvP26YimyrL0hzkOAzhW2I4S2I0qAQmS9a ECMm6M4F/xQiuduEkwg= X-Received: by 10.200.47.176 with SMTP id l45mr4666649qta.153.1498013334477; Tue, 20 Jun 2017 19:48:54 -0700 (PDT) From: Richard Henderson To: qemu-devel@nongnu.org Date: Tue, 20 Jun 2017 19:48:29 -0700 Message-Id: <20170621024831.26019-15-rth@twiddle.net> X-Mailer: git-send-email 2.9.4 In-Reply-To: <20170621024831.26019-1-rth@twiddle.net> References: <20170621024831.26019-1-rth@twiddle.net> X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 2607:f8b0:400d:c0d::244 Subject: [Qemu-devel] [PATCH 14/16] tcg: Use per-temp state data in optimize 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: aurelien@aurel32.net 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_0 Z_629925259 SPT_0 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" While we're touching many of the lines anyway, adjust the naming of the functions to better distinguish when "TCGArg" vs "TCGTemp" should be used. Signed-off-by: Richard Henderson --- tcg/optimize.c | 424 +++++++++++++++++++++++++++++++++--------------------= ---- tcg/tcg.h | 5 + 2 files changed, 249 insertions(+), 180 deletions(-) diff --git a/tcg/optimize.c b/tcg/optimize.c index 55f9e83..eb09ae5 100644 --- a/tcg/optimize.c +++ b/tcg/optimize.c @@ -34,34 +34,63 @@ =20 struct tcg_temp_info { bool is_const; - uint16_t prev_copy; - uint16_t next_copy; + TCGTemp *prev_copy; + TCGTemp *next_copy; tcg_target_ulong val; tcg_target_ulong mask; }; =20 -static struct tcg_temp_info temps[TCG_MAX_TEMPS]; +static struct tcg_temp_info temps_[TCG_MAX_TEMPS]; static TCGTempSet temps_used; =20 -static inline bool temp_is_const(TCGArg arg) +static inline struct tcg_temp_info *ts_info(TCGTemp *ts) { - return temps[arg].is_const; + return ts->state_ptr; } =20 -static inline bool temp_is_copy(TCGArg arg) +static inline struct tcg_temp_info *arg_info(TCGArg arg) { - return temps[arg].next_copy !=3D arg; + return ts_info(arg_temp(arg)); +} + +static inline bool ts_is_const(TCGTemp *ts) +{ + return ts_info(ts)->is_const; +} + +static inline bool arg_is_const(TCGArg arg) +{ + return ts_is_const(arg_temp(arg)); +} + +static inline bool ts_is_copy(TCGTemp *ts) +{ + return ts_info(ts)->next_copy !=3D ts; +} + +static inline bool arg_is_copy(TCGArg arg) +{ + return ts_is_copy(arg_temp(arg)); } =20 /* Reset TEMP's state, possibly removing the temp for the list of copies. = */ -static void reset_temp(TCGArg temp) +static void reset_ts(TCGTemp *ts) { - temps[temps[temp].next_copy].prev_copy =3D temps[temp].prev_copy; - temps[temps[temp].prev_copy].next_copy =3D temps[temp].next_copy; - temps[temp].next_copy =3D temp; - temps[temp].prev_copy =3D temp; - temps[temp].is_const =3D false; - temps[temp].mask =3D -1; + struct tcg_temp_info *ti =3D ts_info(ts); + struct tcg_temp_info *pi =3D ts_info(ti->prev_copy); + struct tcg_temp_info *ni =3D ts_info(ti->next_copy); + + ni->prev_copy =3D ti->prev_copy; + pi->next_copy =3D ti->next_copy; + ti->next_copy =3D ts; + ti->prev_copy =3D ts; + ti->is_const =3D false; + ti->mask =3D -1; +} + +static void reset_temp(TCGArg arg) +{ + reset_ts(arg_temp(arg)); } =20 /* Reset all temporaries, given that there are NB_TEMPS of them. */ @@ -71,17 +100,26 @@ static void reset_all_temps(int nb_temps) } =20 /* Initialize and activate a temporary. */ -static void init_temp_info(TCGArg temp) +static void init_ts_info(TCGTemp *ts) { - if (!test_bit(temp, temps_used.l)) { - temps[temp].next_copy =3D temp; - temps[temp].prev_copy =3D temp; - temps[temp].is_const =3D false; - temps[temp].mask =3D -1; - set_bit(temp, temps_used.l); + size_t idx =3D temp_idx(ts); + if (!test_bit(idx, temps_used.l)) { + struct tcg_temp_info *ti =3D &temps_[idx]; + + ts->state_ptr =3D ti; + ti->next_copy =3D ts; + ti->prev_copy =3D ts; + ti->is_const =3D false; + ti->mask =3D -1; + set_bit(idx, temps_used.l); } } =20 +static void init_arg_info(TCGArg arg) +{ + init_ts_info(arg_temp(arg)); +} + static int op_bits(TCGOpcode op) { const TCGOpDef *def =3D &tcg_op_defs[op]; @@ -119,7 +157,7 @@ static TCGOpcode op_to_movi(TCGOpcode op) static TCGArg find_better_copy(TCGContext *s, TCGArg arg) { TCGTemp *ts =3D arg_temp(arg); - TCGArg i; + TCGTemp *i; =20 /* If this is already a global, we can't do better. */ if (ts->temp_global) { @@ -127,17 +165,17 @@ static TCGArg find_better_copy(TCGContext *s, TCGArg = arg) } =20 /* Search for a global first. */ - for (i =3D temps[arg].next_copy ; i !=3D arg; i =3D temps[i].next_copy= ) { - if (i < s->nb_globals) { - return i; + for (i =3D ts_info(ts)->next_copy; i !=3D ts; i =3D ts_info(i)->next_c= opy) { + if (i->temp_global) { + return temp_arg(i); } } =20 /* If it is a temp, search for a temp local. */ if (!ts->temp_local) { - for (i =3D temps[arg].next_copy ; i !=3D arg; i =3D temps[i].next_= copy) { - if (s->temps[i].temp_local) { - return i; + for (i =3D ts_info(ts)->next_copy; i !=3D ts; i =3D ts_info(i)->ne= xt_copy) { + if (ts->temp_local) { + return temp_arg(i); } } } @@ -146,20 +184,20 @@ static TCGArg find_better_copy(TCGContext *s, TCGArg = arg) return arg; } =20 -static bool temps_are_copies(TCGArg arg1, TCGArg arg2) +static bool ts_are_copies(TCGTemp *ts1, TCGTemp *ts2) { - TCGArg i; + TCGTemp *i; =20 - if (arg1 =3D=3D arg2) { + if (ts1 =3D=3D ts2) { return true; } =20 - if (!temp_is_copy(arg1) || !temp_is_copy(arg2)) { + if (!ts_is_copy(ts1) || !ts_is_copy(ts2)) { return false; } =20 - for (i =3D temps[arg1].next_copy ; i !=3D arg1 ; i =3D temps[i].next_c= opy) { - if (i =3D=3D arg2) { + for (i =3D ts_info(ts1)->next_copy; i !=3D ts1; i =3D ts_info(i)->next= _copy) { + if (i =3D=3D ts2) { return true; } } @@ -167,22 +205,28 @@ static bool temps_are_copies(TCGArg arg1, TCGArg arg2) return false; } =20 +static bool args_are_copies(TCGArg arg1, TCGArg arg2) +{ + return ts_are_copies(arg_temp(arg1), arg_temp(arg2)); +} + 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; + struct tcg_temp_info *di =3D arg_info(dst); =20 op->opc =3D new_op; =20 reset_temp(dst); - temps[dst].is_const =3D true; - temps[dst].val =3D val; + di->is_const =3D true; + di->val =3D val; mask =3D val; if (TCG_TARGET_REG_BITS > 32 && new_op =3D=3D INDEX_op_movi_i32) { /* High bits of the destination are now garbage. */ mask |=3D ~0xffffffffull; } - temps[dst].mask =3D mask; + di->mask =3D mask; =20 op->args[0] =3D dst; op->args[1] =3D val; @@ -190,35 +234,44 @@ static void tcg_opt_gen_movi(TCGContext *s, TCGOp *op= , TCGArg dst, TCGArg val) =20 static void tcg_opt_gen_mov(TCGContext *s, TCGOp *op, TCGArg dst, TCGArg s= rc) { - if (temps_are_copies(dst, src)) { + TCGTemp *dst_ts =3D arg_temp(dst); + TCGTemp *src_ts =3D arg_temp(src); + struct tcg_temp_info *di; + struct tcg_temp_info *si; + tcg_target_ulong mask; + TCGOpcode new_op; + + if (ts_are_copies(dst_ts, src_ts)) { tcg_op_remove(s, op); return; } =20 - TCGOpcode new_op =3D op_to_mov(op->opc); - tcg_target_ulong mask; + reset_ts(dst_ts); + di =3D ts_info(dst_ts); + si =3D ts_info(src_ts); + new_op =3D op_to_mov(op->opc); =20 op->opc =3D new_op; + op->args[0] =3D dst; + op->args[1] =3D src; =20 - reset_temp(dst); - mask =3D temps[src].mask; + mask =3D si->mask; if (TCG_TARGET_REG_BITS > 32 && new_op =3D=3D INDEX_op_mov_i32) { /* High bits of the destination are now garbage. */ mask |=3D ~0xffffffffull; } - temps[dst].mask =3D mask; - - if (arg_temp(src)->type =3D=3D arg_temp(dst)->type) { - temps[dst].next_copy =3D temps[src].next_copy; - temps[dst].prev_copy =3D src; - temps[temps[dst].next_copy].prev_copy =3D dst; - temps[src].next_copy =3D dst; - temps[dst].is_const =3D temps[src].is_const; - temps[dst].val =3D temps[src].val; - } + di->mask =3D mask; =20 - op->args[0] =3D dst; - op->args[1] =3D src; + if (src_ts->type =3D=3D dst_ts->type) { + struct tcg_temp_info *ni =3D ts_info(si->next_copy); + + di->next_copy =3D si->next_copy; + di->prev_copy =3D src_ts; + ni->prev_copy =3D dst_ts; + si->next_copy =3D dst_ts; + di->is_const =3D si->is_const; + di->val =3D si->val; + } } =20 static TCGArg do_constant_folding_2(TCGOpcode op, TCGArg x, TCGArg y) @@ -465,18 +518,20 @@ static bool do_constant_folding_cond_eq(TCGCond c) static TCGArg do_constant_folding_cond(TCGOpcode op, TCGArg x, TCGArg y, TCGCond c) { - if (temp_is_const(x) && temp_is_const(y)) { + tcg_target_ulong xv =3D arg_info(x)->val; + tcg_target_ulong yv =3D arg_info(y)->val; + if (arg_is_const(x) && arg_is_const(y)) { switch (op_bits(op)) { case 32: - return do_constant_folding_cond_32(temps[x].val, temps[y].val,= c); + return do_constant_folding_cond_32(xv, yv, c); case 64: - return do_constant_folding_cond_64(temps[x].val, temps[y].val,= c); + return do_constant_folding_cond_64(xv, yv, c); default: tcg_abort(); } - } else if (temps_are_copies(x, y)) { + } else if (args_are_copies(x, y)) { return do_constant_folding_cond_eq(c); - } else if (temp_is_const(y) && temps[y].val =3D=3D 0) { + } else if (arg_is_const(y) && yv =3D=3D 0) { switch (c) { case TCG_COND_LTU: return 0; @@ -496,12 +551,15 @@ static TCGArg do_constant_folding_cond2(TCGArg *p1, T= CGArg *p2, TCGCond c) TCGArg al =3D p1[0], ah =3D p1[1]; TCGArg bl =3D p2[0], bh =3D p2[1]; =20 - if (temp_is_const(bl) && temp_is_const(bh)) { - uint64_t b =3D ((uint64_t)temps[bh].val << 32) | (uint32_t)temps[b= l].val; + if (arg_is_const(bl) && arg_is_const(bh)) { + tcg_target_ulong blv =3D arg_info(bl)->val; + tcg_target_ulong bhv =3D arg_info(bh)->val; + uint64_t b =3D deposit64(blv, 32, 32, bhv); =20 - if (temp_is_const(al) && temp_is_const(ah)) { - uint64_t a; - a =3D ((uint64_t)temps[ah].val << 32) | (uint32_t)temps[al].va= l; + if (arg_is_const(al) && arg_is_const(ah)) { + tcg_target_ulong alv =3D arg_info(al)->val; + tcg_target_ulong ahv =3D arg_info(ah)->val; + uint64_t a =3D deposit64(alv, 32, 32, ahv); return do_constant_folding_cond_64(a, b, c); } if (b =3D=3D 0) { @@ -515,7 +573,7 @@ static TCGArg do_constant_folding_cond2(TCGArg *p1, TCG= Arg *p2, TCGCond c) } } } - if (temps_are_copies(al, bl) && temps_are_copies(ah, bh)) { + if (args_are_copies(al, bl) && args_are_copies(ah, bh)) { return do_constant_folding_cond_eq(c); } return 2; @@ -525,8 +583,8 @@ static bool swap_commutative(TCGArg dest, TCGArg *p1, T= CGArg *p2) { TCGArg a1 =3D *p1, a2 =3D *p2; int sum =3D 0; - sum +=3D temp_is_const(a1); - sum -=3D temp_is_const(a2); + sum +=3D arg_is_const(a1); + sum -=3D arg_is_const(a2); =20 /* Prefer the constant in second argument, and then the form op a, a, b, which is better handled on non-RISC hosts. */ @@ -541,10 +599,10 @@ static bool swap_commutative(TCGArg dest, TCGArg *p1,= TCGArg *p2) static bool swap_commutative2(TCGArg *p1, TCGArg *p2) { int sum =3D 0; - sum +=3D temp_is_const(p1[0]); - sum +=3D temp_is_const(p1[1]); - sum -=3D temp_is_const(p2[0]); - sum -=3D temp_is_const(p2[1]); + sum +=3D arg_is_const(p1[0]); + sum +=3D arg_is_const(p1[1]); + sum -=3D arg_is_const(p2[0]); + sum -=3D arg_is_const(p2[1]); if (sum > 0) { TCGArg t; t =3D p1[0], p1[0] =3D p2[0], p2[0] =3D t; @@ -586,22 +644,22 @@ 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 op->args[i]; - if (tmp !=3D TCG_CALL_DUMMY_ARG) { - init_temp_info(tmp); + TCGTemp *ts =3D arg_temp(op->args[i]); + if (ts) { + init_ts_info(ts); } } } else { 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(op->args[i]); + init_arg_info(op->args[i]); } } =20 /* Do copy propagation */ for (i =3D nb_oargs; i < nb_oargs + nb_iargs; i++) { - if (temp_is_copy(op->args[i])) { + if (arg_is_copy(op->args[i])) { op->args[i] =3D find_better_copy(s, op->args[i]); } } @@ -671,7 +729,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(op->args[1]) && temps[op->args[1]].val =3D= =3D 0) { + if (arg_is_const(op->args[1]) + && arg_info(op->args[1])->val =3D=3D 0) { tcg_opt_gen_movi(s, op, op->args[0], 0); continue; } @@ -681,7 +740,7 @@ void tcg_optimize(TCGContext *s) TCGOpcode neg_op; bool have_neg; =20 - if (temp_is_const(op->args[2])) { + if (arg_is_const(op->args[2])) { /* Proceed with possible constant folding. */ break; } @@ -695,8 +754,8 @@ void tcg_optimize(TCGContext *s) if (!have_neg) { break; } - if (temp_is_const(op->args[1]) - && temps[op->args[1]].val =3D=3D 0) { + if (arg_is_const(op->args[1]) + && arg_info(op->args[1])->val =3D=3D 0) { op->opc =3D neg_op; reset_temp(op->args[0]); op->args[1] =3D op->args[2]; @@ -706,34 +765,34 @@ void tcg_optimize(TCGContext *s) break; CASE_OP_32_64(xor): CASE_OP_32_64(nand): - if (!temp_is_const(op->args[1]) - && temp_is_const(op->args[2]) - && temps[op->args[2]].val =3D=3D -1) { + if (!arg_is_const(op->args[1]) + && arg_is_const(op->args[2]) + && arg_info(op->args[2])->val =3D=3D -1) { i =3D 1; goto try_not; } break; CASE_OP_32_64(nor): - if (!temp_is_const(op->args[1]) - && temp_is_const(op->args[2]) - && temps[op->args[2]].val =3D=3D 0) { + if (!arg_is_const(op->args[1]) + && arg_is_const(op->args[2]) + && arg_info(op->args[2])->val =3D=3D 0) { i =3D 1; goto try_not; } break; CASE_OP_32_64(andc): - if (!temp_is_const(op->args[2]) - && temp_is_const(op->args[1]) - && temps[op->args[1]].val =3D=3D -1) { + if (!arg_is_const(op->args[2]) + && arg_is_const(op->args[1]) + && arg_info(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(op->args[2]) - && temp_is_const(op->args[1]) - && temps[op->args[1]].val =3D=3D 0) { + if (!arg_is_const(op->args[2]) + && arg_is_const(op->args[1]) + && arg_info(op->args[1])->val =3D=3D 0) { i =3D 2; goto try_not; } @@ -774,9 +833,9 @@ void tcg_optimize(TCGContext *s) CASE_OP_32_64(or): CASE_OP_32_64(xor): CASE_OP_32_64(andc): - if (!temp_is_const(op->args[1]) - && temp_is_const(op->args[2]) - && temps[op->args[2]].val =3D=3D 0) { + if (!arg_is_const(op->args[1]) + && arg_is_const(op->args[2]) + && arg_info(op->args[2])->val =3D=3D 0) { tcg_opt_gen_mov(s, op, op->args[0], op->args[1]); continue; } @@ -784,9 +843,9 @@ void tcg_optimize(TCGContext *s) CASE_OP_32_64(and): CASE_OP_32_64(orc): CASE_OP_32_64(eqv): - if (!temp_is_const(op->args[1]) - && temp_is_const(op->args[2]) - && temps[op->args[2]].val =3D=3D -1) { + if (!arg_is_const(op->args[1]) + && arg_is_const(op->args[2]) + && arg_info(op->args[2])->val =3D=3D -1) { tcg_opt_gen_mov(s, op, op->args[0], op->args[1]); continue; } @@ -801,21 +860,21 @@ void tcg_optimize(TCGContext *s) affected =3D -1; switch (opc) { CASE_OP_32_64(ext8s): - if ((temps[op->args[1]].mask & 0x80) !=3D 0) { + if ((arg_info(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[op->args[1]].mask & 0x8000) !=3D 0) { + if ((arg_info(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[op->args[1]].mask & 0x80000000) !=3D 0) { + if ((arg_info(op->args[1])->mask & 0x80000000) !=3D 0) { break; } case INDEX_op_ext32u_i64: @@ -823,111 +882,114 @@ void tcg_optimize(TCGContext *s) goto and_const; =20 CASE_OP_32_64(and): - mask =3D temps[op->args[2]].mask; - if (temp_is_const(op->args[2])) { + mask =3D arg_info(op->args[2])->mask; + if (arg_is_const(op->args[2])) { and_const: - affected =3D temps[op->args[1]].mask & ~mask; + affected =3D arg_info(op->args[1])->mask & ~mask; } - mask =3D temps[op->args[1]].mask & mask; + mask =3D arg_info(op->args[1])->mask & mask; break; =20 case INDEX_op_ext_i32_i64: - if ((temps[op->args[1]].mask & 0x80000000) !=3D 0) { + if ((arg_info(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[op->args[1]].mask; + mask =3D (uint32_t)arg_info(op->args[1])->mask; break; =20 CASE_OP_32_64(andc): /* Known-zeros does not imply known-ones. Therefore unless 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; + if (arg_is_const(op->args[2])) { + mask =3D ~arg_info(op->args[2])->mask; goto and_const; } - /* But we certainly know nothing outside op->args[1] may be se= t. */ - mask =3D temps[op->args[1]].mask; + /* But we certainly know nothing outside args[1] may be set. */ + mask =3D arg_info(op->args[1])->mask; break; =20 case INDEX_op_sar_i32: - 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; + if (arg_is_const(op->args[2])) { + tmp =3D arg_info(op->args[2])->val & 31; + mask =3D (int32_t)arg_info(op->args[1])->mask >> tmp; } break; case INDEX_op_sar_i64: - 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; + if (arg_is_const(op->args[2])) { + tmp =3D arg_info(op->args[2])->val & 63; + mask =3D (int64_t)arg_info(op->args[1])->mask >> tmp; } break; =20 case INDEX_op_shr_i32: - 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; + if (arg_is_const(op->args[2])) { + tmp =3D arg_info(op->args[2])->val & 31; + mask =3D (uint32_t)arg_info(op->args[1])->mask >> tmp; } break; case INDEX_op_shr_i64: - 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; + if (arg_is_const(op->args[2])) { + tmp =3D arg_info(op->args[2])->val & 63; + mask =3D (uint64_t)arg_info(op->args[1])->mask >> tmp; } break; =20 case INDEX_op_extrl_i64_i32: - mask =3D (uint32_t)temps[op->args[1]].mask; + mask =3D (uint32_t)arg_info(op->args[1])->mask; break; case INDEX_op_extrh_i64_i32: - mask =3D (uint64_t)temps[op->args[1]].mask >> 32; + mask =3D (uint64_t)arg_info(op->args[1])->mask >> 32; break; =20 CASE_OP_32_64(shl): - 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; + if (arg_is_const(op->args[2])) { + tmp =3D arg_info(op->args[2])->val & (TCG_TARGET_REG_BITS = - 1); + mask =3D arg_info(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[op->args[1]].mask & -temps[op->args[1]].mask); + mask =3D -(arg_info(op->args[1])->mask + & -arg_info(op->args[1])->mask); break; =20 CASE_OP_32_64(deposit): - mask =3D deposit64(temps[op->args[1]].mask, op->args[3], - op->args[4], temps[op->args[2]].mask); + mask =3D deposit64(arg_info(op->args[1])->mask, + op->args[3], op->args[4], + arg_info(op->args[2])->mask); break; =20 CASE_OP_32_64(extract): - mask =3D extract64(temps[op->args[1]].mask, op->args[2], op->a= rgs[3]); + mask =3D extract64(arg_info(op->args[1])->mask, + op->args[2], op->args[3]); if (op->args[2] =3D=3D 0) { - affected =3D temps[op->args[1]].mask & ~mask; + affected =3D arg_info(op->args[1])->mask & ~mask; } break; CASE_OP_32_64(sextract): - mask =3D sextract64(temps[op->args[1]].mask, + mask =3D sextract64(arg_info(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; + affected =3D arg_info(op->args[1])->mask & ~mask; } break; =20 CASE_OP_32_64(or): CASE_OP_32_64(xor): - mask =3D temps[op->args[1]].mask | temps[op->args[2]].mask; + mask =3D arg_info(op->args[1])->mask | arg_info(op->args[2])->= mask; break; =20 case INDEX_op_clz_i32: case INDEX_op_ctz_i32: - mask =3D temps[op->args[2]].mask | 31; + mask =3D arg_info(op->args[2])->mask | 31; break; =20 case INDEX_op_clz_i64: case INDEX_op_ctz_i64: - mask =3D temps[op->args[2]].mask | 63; + mask =3D arg_info(op->args[2])->mask | 63; break; =20 case INDEX_op_ctpop_i32: @@ -943,7 +1005,7 @@ void tcg_optimize(TCGContext *s) break; =20 CASE_OP_32_64(movcond): - mask =3D temps[op->args[3]].mask | temps[op->args[4]].mask; + mask =3D arg_info(op->args[3])->mask | arg_info(op->args[4])->= mask; break; =20 CASE_OP_32_64(ld8u): @@ -997,7 +1059,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(op->args[2]) && temps[op->args[2]].val =3D= =3D 0)) { + if (arg_is_const(op->args[2]) + && arg_info(op->args[2])->val =3D=3D 0) { tcg_opt_gen_movi(s, op, op->args[0], 0); continue; } @@ -1010,7 +1073,7 @@ void tcg_optimize(TCGContext *s) switch (opc) { CASE_OP_32_64(or): CASE_OP_32_64(and): - if (temps_are_copies(op->args[1], op->args[2])) { + if (args_are_copies(op->args[1], op->args[2])) { tcg_opt_gen_mov(s, op, op->args[0], op->args[1]); continue; } @@ -1024,7 +1087,7 @@ void tcg_optimize(TCGContext *s) CASE_OP_32_64(andc): CASE_OP_32_64(sub): CASE_OP_32_64(xor): - if (temps_are_copies(op->args[1], op->args[2])) { + if (args_are_copies(op->args[1], op->args[2])) { tcg_opt_gen_movi(s, op, op->args[0], 0); continue; } @@ -1057,8 +1120,8 @@ 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(op->args[1])) { - tmp =3D do_constant_folding(opc, temps[op->args[1]].val, 0= ); + if (arg_is_const(op->args[1])) { + tmp =3D do_constant_folding(opc, arg_info(op->args[1])->va= l, 0); tcg_opt_gen_movi(s, op, op->args[0], tmp); break; } @@ -1086,9 +1149,9 @@ void tcg_optimize(TCGContext *s) CASE_OP_32_64(divu): CASE_OP_32_64(rem): CASE_OP_32_64(remu): - 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); + if (arg_is_const(op->args[1]) && arg_is_const(op->args[2])) { + tmp =3D do_constant_folding(opc, arg_info(op->args[1])->va= l, + arg_info(op->args[2])->val); tcg_opt_gen_movi(s, op, op->args[0], tmp); break; } @@ -1096,8 +1159,8 @@ void tcg_optimize(TCGContext *s) =20 CASE_OP_32_64(clz): CASE_OP_32_64(ctz): - if (temp_is_const(op->args[1])) { - TCGArg v =3D temps[op->args[1]].val; + if (arg_is_const(op->args[1])) { + TCGArg v =3D arg_info(op->args[1])->val; if (v !=3D 0) { tmp =3D do_constant_folding(opc, v, 0); tcg_opt_gen_movi(s, op, op->args[0], tmp); @@ -1109,17 +1172,18 @@ void tcg_optimize(TCGContext *s) goto do_default; =20 CASE_OP_32_64(deposit): - 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); + if (arg_is_const(op->args[1]) && arg_is_const(op->args[2])) { + tmp =3D deposit64(arg_info(op->args[1])->val, + op->args[3], op->args[4], + arg_info(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(op->args[1])) { - tmp =3D extract64(temps[op->args[1]].val, + if (arg_is_const(op->args[1])) { + tmp =3D extract64(arg_info(op->args[1])->val, op->args[2], op->args[3]); tcg_opt_gen_movi(s, op, op->args[0], tmp); break; @@ -1127,8 +1191,8 @@ void tcg_optimize(TCGContext *s) goto do_default; =20 CASE_OP_32_64(sextract): - if (temp_is_const(op->args[1])) { - tmp =3D sextract64(temps[op->args[1]].val, + if (arg_is_const(op->args[1])) { + tmp =3D sextract64(arg_info(op->args[1])->val, op->args[2], op->args[3]); tcg_opt_gen_movi(s, op, op->args[0], tmp); break; @@ -1166,9 +1230,9 @@ void tcg_optimize(TCGContext *s) tcg_opt_gen_mov(s, op, op->args[0], op->args[4-tmp]); break; } - 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; + if (arg_is_const(op->args[3]) && arg_is_const(op->args[4])) { + tcg_target_ulong tv =3D arg_info(op->args[3])->val; + tcg_target_ulong fv =3D arg_info(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); @@ -1185,12 +1249,12 @@ void tcg_optimize(TCGContext *s) =20 case INDEX_op_add2_i32: case INDEX_op_sub2_i32: - 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; + if (arg_is_const(op->args[2]) && arg_is_const(op->args[3]) + && arg_is_const(op->args[4]) && arg_is_const(op->args[5]))= { + uint32_t al =3D arg_info(op->args[2])->val; + uint32_t ah =3D arg_info(op->args[3])->val; + uint32_t bl =3D arg_info(op->args[4])->val; + uint32_t bh =3D arg_info(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; @@ -1214,9 +1278,9 @@ void tcg_optimize(TCGContext *s) goto do_default; =20 case INDEX_op_mulu2_i32: - 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; + if (arg_is_const(op->args[2]) && arg_is_const(op->args[3])) { + uint32_t a =3D arg_info(op->args[2])->val; + uint32_t b =3D arg_info(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); @@ -1247,10 +1311,10 @@ void tcg_optimize(TCGContext *s) } } 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) { + && arg_is_const(op->args[2]) + && arg_info(op->args[2])->val =3D=3D 0 + && arg_is_const(op->args[3]) + && arg_info(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: @@ -1318,15 +1382,15 @@ void tcg_optimize(TCGContext *s) 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) { + && arg_is_const(op->args[3]) + && arg_info(op->args[3])->val =3D=3D 0 + && arg_is_const(op->args[4]) + && arg_info(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(op->args[0]); - temps[op->args[0]].mask =3D 1; + arg_info(op->args[0])->mask =3D 1; op->opc =3D INDEX_op_setcond_i32; op->args[1] =3D op->args[2]; op->args[2] =3D op->args[4]; @@ -1352,7 +1416,7 @@ void tcg_optimize(TCGContext *s) } do_setcond_low: reset_temp(op->args[0]); - temps[op->args[0]].mask =3D 1; + arg_info(op->args[0])->mask =3D 1; op->opc =3D INDEX_op_setcond_i32; op->args[2] =3D op->args[3]; op->args[3] =3D op->args[5]; @@ -1386,7 +1450,7 @@ void tcg_optimize(TCGContext *s) & (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)) { - reset_temp(i); + reset_ts(&s->temps[i]); } } } @@ -1408,7 +1472,7 @@ void tcg_optimize(TCGContext *s) /* Save the corresponding known-zero bits mask for the first output argument (only one supported so far). = */ if (i =3D=3D 0) { - temps[op->args[i]].mask =3D mask; + arg_info(op->args[i])->mask =3D mask; } } } diff --git a/tcg/tcg.h b/tcg/tcg.h index b75a745..018c01c 100644 --- a/tcg/tcg.h +++ b/tcg/tcg.h @@ -750,6 +750,11 @@ static inline TCGTemp *arg_temp(TCGArg a) return a =3D=3D TCG_CALL_DUMMY_ARG ? NULL : &tcg_ctx.temps[a]; } =20 +static inline size_t arg_index(TCGArg a) +{ + return a; +} + static inline void tcg_set_insn_param(int op_idx, int arg, TCGArg v) { tcg_ctx.gen_op_buf[op_idx].args[arg] =3D v; --=20 2.9.4