From patchwork Thu Jan 24 04:03:07 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richard Henderson X-Patchwork-Id: 215221 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [208.118.235.17]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (Client did not present a certificate) by ozlabs.org (Postfix) with ESMTPS id 866222C0040 for ; Thu, 24 Jan 2013 15:58:00 +1100 (EST) Received: from localhost ([::1]:38027 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1TyE5W-0005HH-4s for incoming@patchwork.ozlabs.org; Wed, 23 Jan 2013 23:06:54 -0500 Received: from eggs.gnu.org ([208.118.235.92]:51706) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1TyE3M-0002X5-KB for qemu-devel@nongnu.org; Wed, 23 Jan 2013 23:04:48 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1TyE35-0004Kl-UY for qemu-devel@nongnu.org; Wed, 23 Jan 2013 23:04:40 -0500 Received: from mail-pa0-f48.google.com ([209.85.220.48]:56782) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1TyE35-0004KM-Jv for qemu-devel@nongnu.org; Wed, 23 Jan 2013 23:04:23 -0500 Received: by mail-pa0-f48.google.com with SMTP id fa1so5252431pad.21 for ; Wed, 23 Jan 2013 20:04:22 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=x-received:sender:from:to:cc:subject:date:message-id:x-mailer :in-reply-to:references; bh=PsSXXtn6w1k6LeAC1ZH0y83EAaFlToFbBXveKxBIHF0=; b=r+FlHiQBwltpIRFZEfSAlvOkTWeAgNnKD6F3oQUiSdkq6PQalKRuIbnbbTq7IxlepO lKiNflDpMKIGmWODNI4MhDwnGlNScfvJ9W7B+EVIjE0UfOo6eCquSs8F0X+1Ak+Eo1xp l5Yrkz/QNVwaCDnV+4bjvDNOt7YP8exHJDpflqCr0/Ma9UViZ0l+CQ9p5V/m8RUYwkGM 6JxnJDuGcgnf92k18y2YRNV4ge8Ut4k6+cIaZKQG/PrccgpPIzIel+wmncmpUl63S+rJ Hd9ysY/j6X9/bZnNxffVjcFtwIiNExLFFcnnNU7k4R8cwDPjHLEztJe4nnUwGX/ohCW3 5ISg== X-Received: by 10.68.232.195 with SMTP id tq3mr1427185pbc.70.1359000262881; Wed, 23 Jan 2013 20:04:22 -0800 (PST) Received: from anchor.twiddle.home (50-194-63-110-static.hfc.comcastbusiness.net. [50.194.63.110]) by mx.google.com with ESMTPS id ot3sm14027480pbb.38.2013.01.23.20.04.21 (version=TLSv1 cipher=RC4-SHA bits=128/128); Wed, 23 Jan 2013 20:04:22 -0800 (PST) From: Richard Henderson To: qemu-devel@nongnu.org Date: Wed, 23 Jan 2013 20:03:07 -0800 Message-Id: <1359000221-19834-24-git-send-email-rth@twiddle.net> X-Mailer: git-send-email 1.7.11.7 In-Reply-To: <1359000221-19834-1-git-send-email-rth@twiddle.net> References: <1359000221-19834-1-git-send-email-rth@twiddle.net> X-detected-operating-system: by eggs.gnu.org: GNU/Linux 3.x [fuzzy] X-Received-From: 209.85.220.48 Cc: Blue Swirl , Paolo Bonzini Subject: [Qemu-devel] [PATCH 23/57] target-i386: convert gen_compute_eflags_c to TCG X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Do the switch at translation time, converting the helper templates to TCG opcodes. In some cases CF can be computed with a single setcond, though others it may require a little more work. In the CC_OP_DYNAMIC case, compute the whole EFLAGS, same as for ZF/SF/PF. Reviewed-by: Blue Swirl Signed-off-by: Paolo Bonzini Signed-off-by: Richard Henderson --- target-i386/cc_helper.c | 118 --------------------------------------- target-i386/cc_helper_template.h | 76 ------------------------- target-i386/helper.h | 1 - target-i386/translate.c | 104 ++++++++++++++++++++++++++++++---- 4 files changed, 93 insertions(+), 206 deletions(-) diff --git a/target-i386/cc_helper.c b/target-i386/cc_helper.c index 9422003..214d715 100644 --- a/target-i386/cc_helper.c +++ b/target-i386/cc_helper.c @@ -80,11 +80,6 @@ static int compute_all_eflags(CPUX86State *env) return CC_SRC; } -static int compute_c_eflags(CPUX86State *env) -{ - return CC_SRC & CC_C; -} - uint32_t helper_cc_compute_all(CPUX86State *env, int op) { switch (op) { @@ -203,119 +198,6 @@ uint32_t cpu_cc_compute_all(CPUX86State *env, int op) return helper_cc_compute_all(env, op); } -uint32_t helper_cc_compute_c(CPUX86State *env, int op) -{ - switch (op) { - default: /* should never happen */ - return 0; - - case CC_OP_EFLAGS: - return compute_c_eflags(env); - - case CC_OP_MULB: - return compute_c_mull(env); - case CC_OP_MULW: - return compute_c_mull(env); - case CC_OP_MULL: - return compute_c_mull(env); - - case CC_OP_ADDB: - return compute_c_addb(env); - case CC_OP_ADDW: - return compute_c_addw(env); - case CC_OP_ADDL: - return compute_c_addl(env); - - case CC_OP_ADCB: - return compute_c_adcb(env); - case CC_OP_ADCW: - return compute_c_adcw(env); - case CC_OP_ADCL: - return compute_c_adcl(env); - - case CC_OP_SUBB: - return compute_c_subb(env); - case CC_OP_SUBW: - return compute_c_subw(env); - case CC_OP_SUBL: - return compute_c_subl(env); - - case CC_OP_SBBB: - return compute_c_sbbb(env); - case CC_OP_SBBW: - return compute_c_sbbw(env); - case CC_OP_SBBL: - return compute_c_sbbl(env); - - case CC_OP_LOGICB: - return compute_c_logicb(); - case CC_OP_LOGICW: - return compute_c_logicw(); - case CC_OP_LOGICL: - return compute_c_logicl(); - - case CC_OP_INCB: - return compute_c_incl(env); - case CC_OP_INCW: - return compute_c_incl(env); - case CC_OP_INCL: - return compute_c_incl(env); - - case CC_OP_DECB: - return compute_c_incl(env); - case CC_OP_DECW: - return compute_c_incl(env); - case CC_OP_DECL: - return compute_c_incl(env); - - case CC_OP_SHLB: - return compute_c_shlb(env); - case CC_OP_SHLW: - return compute_c_shlw(env); - case CC_OP_SHLL: - return compute_c_shll(env); - - case CC_OP_SARB: - return compute_c_sarl(env); - case CC_OP_SARW: - return compute_c_sarl(env); - case CC_OP_SARL: - return compute_c_sarl(env); - -#ifdef TARGET_X86_64 - case CC_OP_MULQ: - return compute_c_mull(env); - - case CC_OP_ADDQ: - return compute_c_addq(env); - - case CC_OP_ADCQ: - return compute_c_adcq(env); - - case CC_OP_SUBQ: - return compute_c_subq(env); - - case CC_OP_SBBQ: - return compute_c_sbbq(env); - - case CC_OP_LOGICQ: - return compute_c_logicq(); - - case CC_OP_INCQ: - return compute_c_incl(env); - - case CC_OP_DECQ: - return compute_c_incl(env); - - case CC_OP_SHLQ: - return compute_c_shlq(env); - - case CC_OP_SARQ: - return compute_c_sarl(env); -#endif - } -} - void helper_write_eflags(CPUX86State *env, target_ulong t0, uint32_t update_mask) { diff --git a/target-i386/cc_helper_template.h b/target-i386/cc_helper_template.h index 1f94e11..951ceaf 100644 --- a/target-i386/cc_helper_template.h +++ b/target-i386/cc_helper_template.h @@ -58,16 +58,6 @@ static int glue(compute_all_add, SUFFIX)(CPUX86State *env) return cf | pf | af | zf | sf | of; } -static int glue(compute_c_add, SUFFIX)(CPUX86State *env) -{ - int cf; - target_long src1; - - src1 = CC_SRC; - cf = (DATA_TYPE)CC_DST < (DATA_TYPE)src1; - return cf; -} - static int glue(compute_all_adc, SUFFIX)(CPUX86State *env) { int cf, pf, af, zf, sf, of; @@ -84,16 +74,6 @@ static int glue(compute_all_adc, SUFFIX)(CPUX86State *env) return cf | pf | af | zf | sf | of; } -static int glue(compute_c_adc, SUFFIX)(CPUX86State *env) -{ - int cf; - target_long src1; - - src1 = CC_SRC; - cf = (DATA_TYPE)CC_DST <= (DATA_TYPE)src1; - return cf; -} - static int glue(compute_all_sub, SUFFIX)(CPUX86State *env) { int cf, pf, af, zf, sf, of; @@ -110,17 +90,6 @@ static int glue(compute_all_sub, SUFFIX)(CPUX86State *env) return cf | pf | af | zf | sf | of; } -static int glue(compute_c_sub, SUFFIX)(CPUX86State *env) -{ - int cf; - target_long src1, src2; - - src1 = CC_DST + CC_SRC; - src2 = CC_SRC; - cf = (DATA_TYPE)src1 < (DATA_TYPE)src2; - return cf; -} - static int glue(compute_all_sbb, SUFFIX)(CPUX86State *env) { int cf, pf, af, zf, sf, of; @@ -137,17 +106,6 @@ static int glue(compute_all_sbb, SUFFIX)(CPUX86State *env) return cf | pf | af | zf | sf | of; } -static int glue(compute_c_sbb, SUFFIX)(CPUX86State *env) -{ - int cf; - target_long src1, src2; - - src1 = CC_DST + CC_SRC + 1; - src2 = CC_SRC; - cf = (DATA_TYPE)src1 <= (DATA_TYPE)src2; - return cf; -} - static int glue(compute_all_logic, SUFFIX)(CPUX86State *env) { int cf, pf, af, zf, sf, of; @@ -161,11 +119,6 @@ static int glue(compute_all_logic, SUFFIX)(CPUX86State *env) return cf | pf | af | zf | sf | of; } -static int glue(compute_c_logic, SUFFIX)(void) -{ - return 0; -} - static int glue(compute_all_inc, SUFFIX)(CPUX86State *env) { int cf, pf, af, zf, sf, of; @@ -182,13 +135,6 @@ static int glue(compute_all_inc, SUFFIX)(CPUX86State *env) return cf | pf | af | zf | sf | of; } -#if DATA_BITS == 32 -static int glue(compute_c_inc, SUFFIX)(CPUX86State *env) -{ - return CC_SRC; -} -#endif - static int glue(compute_all_dec, SUFFIX)(CPUX86State *env) { int cf, pf, af, zf, sf, of; @@ -219,18 +165,6 @@ static int glue(compute_all_shl, SUFFIX)(CPUX86State *env) return cf | pf | af | zf | sf | of; } -static int glue(compute_c_shl, SUFFIX)(CPUX86State *env) -{ - return (CC_SRC >> (DATA_BITS - 1)) & CC_C; -} - -#if DATA_BITS == 32 -static int glue(compute_c_sar, SUFFIX)(CPUX86State *env) -{ - return CC_SRC & 1; -} -#endif - static int glue(compute_all_sar, SUFFIX)(CPUX86State *env) { int cf, pf, af, zf, sf, of; @@ -245,16 +179,6 @@ static int glue(compute_all_sar, SUFFIX)(CPUX86State *env) return cf | pf | af | zf | sf | of; } -#if DATA_BITS == 32 -static int glue(compute_c_mul, SUFFIX)(CPUX86State *env) -{ - int cf; - - cf = (CC_SRC != 0); - return cf; -} -#endif - /* NOTE: we compute the flags like the P4. On olders CPUs, only OF and CF are modified and it is slower to do that. */ static int glue(compute_all_mul, SUFFIX)(CPUX86State *env) diff --git a/target-i386/helper.h b/target-i386/helper.h index 9ed720d..89076d3 100644 --- a/target-i386/helper.h +++ b/target-i386/helper.h @@ -1,7 +1,6 @@ #include "exec/def-helper.h" DEF_HELPER_FLAGS_2(cc_compute_all, TCG_CALL_NO_SE, i32, env, int) -DEF_HELPER_FLAGS_2(cc_compute_c, TCG_CALL_NO_SE, i32, env, int) DEF_HELPER_0(lock, void) DEF_HELPER_0(unlock, void) diff --git a/target-i386/translate.c b/target-i386/translate.c index fc46894..172aad1 100644 --- a/target-i386/translate.c +++ b/target-i386/translate.c @@ -869,17 +869,6 @@ static void gen_op_update_neg_cc(void) tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]); } -/* compute eflags.C to reg */ -static void gen_compute_eflags_c(DisasContext *s, TCGv reg, bool inv) -{ - gen_update_cc_op(s); - gen_helper_cc_compute_c(cpu_tmp2_i32, cpu_env, cpu_cc_op); - tcg_gen_extu_i32_tl(reg, cpu_tmp2_i32); - if (inv) { - tcg_gen_xori_tl(reg, reg, 1); - } -} - /* compute all eflags to cc_src */ static void gen_compute_eflags(DisasContext *s) { @@ -892,6 +881,99 @@ static void gen_compute_eflags(DisasContext *s) tcg_gen_extu_i32_tl(cpu_cc_src, cpu_tmp2_i32); } +/* compute eflags.C to reg */ +static void gen_compute_eflags_c(DisasContext *s, TCGv reg, bool inv) +{ + TCGv t0, t1; + int size; + + switch (s->cc_op) { + case CC_OP_SUBB ... CC_OP_SUBQ: + /* (DATA_TYPE)(CC_DST + CC_SRC) < (DATA_TYPE)CC_SRC */ + size = s->cc_op - CC_OP_SUBB; + t1 = gen_ext_tl(cpu_tmp0, cpu_cc_src, size, false); + /* If no temporary was used, be careful not to alias t1 and t0. */ + t0 = TCGV_EQUAL(t1, cpu_cc_src) ? cpu_tmp0 : reg; + tcg_gen_add_tl(t0, cpu_cc_dst, cpu_cc_src); + gen_extu(size, t0); + goto add_sub; + + case CC_OP_ADDB ... CC_OP_ADDQ: + /* (DATA_TYPE)CC_DST < (DATA_TYPE)CC_SRC */ + size = s->cc_op - CC_OP_ADDB; + t1 = gen_ext_tl(cpu_tmp0, cpu_cc_src, size, false); + t0 = gen_ext_tl(reg, cpu_cc_dst, size, false); + add_sub: + tcg_gen_setcond_tl(inv ? TCG_COND_GEU : TCG_COND_LTU, reg, t0, t1); + inv = false; + break; + + case CC_OP_SBBB ... CC_OP_SBBQ: + /* (DATA_TYPE)(CC_DST + CC_SRC + 1) <= (DATA_TYPE)CC_SRC */ + size = s->cc_op - CC_OP_SBBB; + t1 = gen_ext_tl(cpu_tmp0, cpu_cc_src, size, false); + if (TCGV_EQUAL(t1, reg) && TCGV_EQUAL(reg, cpu_cc_src)) { + tcg_gen_mov_tl(cpu_tmp0, cpu_cc_src); + t1 = cpu_tmp0; + } + + tcg_gen_add_tl(reg, cpu_cc_dst, cpu_cc_src); + tcg_gen_addi_tl(reg, reg, 1); + gen_extu(size, reg); + t0 = reg; + goto adc_sbb; + + case CC_OP_ADCB ... CC_OP_ADCQ: + /* (DATA_TYPE)CC_DST <= (DATA_TYPE)CC_SRC */ + size = s->cc_op - CC_OP_ADCB; + t1 = gen_ext_tl(cpu_tmp0, cpu_cc_src, size, false); + t0 = gen_ext_tl(reg, cpu_cc_dst, size, false); + adc_sbb: + tcg_gen_setcond_tl(inv ? TCG_COND_GTU : TCG_COND_LEU, reg, t0, t1); + inv = false; + break; + + case CC_OP_LOGICB ... CC_OP_LOGICQ: + tcg_gen_movi_tl(reg, 0); + break; + + case CC_OP_INCB ... CC_OP_INCQ: + case CC_OP_DECB ... CC_OP_DECQ: + if (inv) { + tcg_gen_xori_tl(reg, cpu_cc_src, 1); + } else { + tcg_gen_mov_tl(reg, cpu_cc_src); + } + inv = false; + break; + + case CC_OP_SHLB ... CC_OP_SHLQ: + /* (CC_SRC >> (DATA_BITS - 1)) & 1 */ + size = s->cc_op - CC_OP_SHLB; + tcg_gen_shri_tl(reg, cpu_cc_src, (8 << size) - 1); + tcg_gen_andi_tl(reg, reg, 1); + break; + + case CC_OP_MULB ... CC_OP_MULQ: + tcg_gen_setcondi_tl(inv ? TCG_COND_EQ : TCG_COND_NE, + reg, cpu_cc_src, 0); + inv = false; + break; + + default: + gen_compute_eflags(s); + /* FALLTHRU */ + case CC_OP_EFLAGS: + case CC_OP_SARB ... CC_OP_SARQ: + /* CC_SRC & 1 */ + tcg_gen_andi_tl(reg, cpu_cc_src, 1); + break; + } + if (inv) { + tcg_gen_xori_tl(reg, reg, 1); + } +} + /* compute eflags.P to reg */ static void gen_compute_eflags_p(DisasContext *s, TCGv reg) {