From patchwork Thu Jan 24 04:03:25 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richard Henderson X-Patchwork-Id: 215248 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 152172C00E6 for ; Thu, 24 Jan 2013 16:44:49 +1100 (EST) Received: from localhost ([::1]:58000 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1TyFcF-0000eS-9e for incoming@patchwork.ozlabs.org; Thu, 24 Jan 2013 00:44:47 -0500 Received: from eggs.gnu.org ([208.118.235.92]:51826) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1TyE3e-0002sV-9r for qemu-devel@nongnu.org; Wed, 23 Jan 2013 23:05:02 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1TyE3a-0004Sh-5J for qemu-devel@nongnu.org; Wed, 23 Jan 2013 23:04:58 -0500 Received: from mail-da0-f43.google.com ([209.85.210.43]:57521) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1TyE3Z-0004SW-Pf for qemu-devel@nongnu.org; Wed, 23 Jan 2013 23:04:54 -0500 Received: by mail-da0-f43.google.com with SMTP id u36so4020252dak.2 for ; Wed, 23 Jan 2013 20:04:53 -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=4/e8TBgVzfE6wLgR9OgI2QdrZaVsE78vPmU3mAkJw/Q=; b=T6R5xKZTUU6+YSyEvUi/QceL8vHs+EC0LqtEyefwjcqcIcQiEW6tYlZDBBbC0Q/amF 2OuEdk1r8KLu+rGrQUrAQDCW6ucO0VgA5SYiBZuHfjmIgWWg6Z1h5xYvRjl5GKVhMlqt JD22vZadvQmUGcZNeX0SAqCL6ev+2iMP5MUkpSOLSYxrQZtnxskAmXXJepasRqTXycnK LACfLgjP8mkAxselY5vHJba/ngpm+lesZRmTOo9oJVFjRY9MG4AG9zWTlLxgktTYJ96z Mm0t5/ylZT+gE4nIz9gHu116QlQvPTkLEmNeCsuMyAWfp65GATt+gpKbt+twa1Dfcn99 UZpg== X-Received: by 10.66.88.198 with SMTP id bi6mr1339155pab.54.1359000293129; Wed, 23 Jan 2013 20:04:53 -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.51 (version=TLSv1 cipher=RC4-SHA bits=128/128); Wed, 23 Jan 2013 20:04:52 -0800 (PST) From: Richard Henderson To: qemu-devel@nongnu.org Date: Wed, 23 Jan 2013 20:03:25 -0800 Message-Id: <1359000221-19834-42-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.210.43 Cc: Blue Swirl , Paolo Bonzini Subject: [Qemu-devel] [PATCH 41/57] target-i386: Don't reference ENV through most of cc helpers 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 In preparation for making this a const helper. By using the proper types in the parameters to the helper functions, we get to avoid quite a lot of subsequent casting. Signed-off-by: Richard Henderson --- target-i386/cc_helper.c | 97 +++++++++++------------ target-i386/cc_helper_template.h | 164 +++++++++++++++++++-------------------- 2 files changed, 125 insertions(+), 136 deletions(-) diff --git a/target-i386/cc_helper.c b/target-i386/cc_helper.c index 214d715..4dd73cc 100644 --- a/target-i386/cc_helper.c +++ b/target-i386/cc_helper.c @@ -75,120 +75,113 @@ const uint8_t parity_table[256] = { #endif -static int compute_all_eflags(CPUX86State *env) +static int compute_all_eflags(int dst, int src1, int src2) { - return CC_SRC; + return src1; } uint32_t helper_cc_compute_all(CPUX86State *env, int op) { + target_ulong dst = CC_DST, src1 = CC_SRC, src2 = CC_SRC2; + switch (op) { default: /* should never happen */ return 0; case CC_OP_EFLAGS: - return compute_all_eflags(env); + return compute_all_eflags(dst, src1, src2); case CC_OP_MULB: - return compute_all_mulb(env); + return compute_all_mulb(dst, src1, src2); case CC_OP_MULW: - return compute_all_mulw(env); + return compute_all_mulw(dst, src1, src2); case CC_OP_MULL: - return compute_all_mull(env); + return compute_all_mull(dst, src1, src2); case CC_OP_ADDB: - return compute_all_addb(env); + return compute_all_addb(dst, src1, src2); case CC_OP_ADDW: - return compute_all_addw(env); + return compute_all_addw(dst, src1, src2); case CC_OP_ADDL: - return compute_all_addl(env); + return compute_all_addl(dst, src1, src2); case CC_OP_ADCB: - return compute_all_adcb(env); + return compute_all_adcb(dst, src1, src2); case CC_OP_ADCW: - return compute_all_adcw(env); + return compute_all_adcw(dst, src1, src2); case CC_OP_ADCL: - return compute_all_adcl(env); + return compute_all_adcl(dst, src1, src2); case CC_OP_SUBB: - return compute_all_subb(env); + return compute_all_subb(dst, src1, src2); case CC_OP_SUBW: - return compute_all_subw(env); + return compute_all_subw(dst, src1, src2); case CC_OP_SUBL: - return compute_all_subl(env); + return compute_all_subl(dst, src1, src2); case CC_OP_SBBB: - return compute_all_sbbb(env); + return compute_all_sbbb(dst, src1, src2); case CC_OP_SBBW: - return compute_all_sbbw(env); + return compute_all_sbbw(dst, src1, src2); case CC_OP_SBBL: - return compute_all_sbbl(env); + return compute_all_sbbl(dst, src1, src2); case CC_OP_LOGICB: - return compute_all_logicb(env); + return compute_all_logicb(dst, src1, src2); case CC_OP_LOGICW: - return compute_all_logicw(env); + return compute_all_logicw(dst, src1, src2); case CC_OP_LOGICL: - return compute_all_logicl(env); + return compute_all_logicl(dst, src1, src2); case CC_OP_INCB: - return compute_all_incb(env); + return compute_all_incb(dst, src1, src2); case CC_OP_INCW: - return compute_all_incw(env); + return compute_all_incw(dst, src1, src2); case CC_OP_INCL: - return compute_all_incl(env); + return compute_all_incl(dst, src1, src2); case CC_OP_DECB: - return compute_all_decb(env); + return compute_all_decb(dst, src1, src2); case CC_OP_DECW: - return compute_all_decw(env); + return compute_all_decw(dst, src1, src2); case CC_OP_DECL: - return compute_all_decl(env); + return compute_all_decl(dst, src1, src2); case CC_OP_SHLB: - return compute_all_shlb(env); + return compute_all_shlb(dst, src1, src2); case CC_OP_SHLW: - return compute_all_shlw(env); + return compute_all_shlw(dst, src1, src2); case CC_OP_SHLL: - return compute_all_shll(env); + return compute_all_shll(dst, src1, src2); case CC_OP_SARB: - return compute_all_sarb(env); + return compute_all_sarb(dst, src1, src2); case CC_OP_SARW: - return compute_all_sarw(env); + return compute_all_sarw(dst, src1, src2); case CC_OP_SARL: - return compute_all_sarl(env); + return compute_all_sarl(dst, src1, src2); #ifdef TARGET_X86_64 case CC_OP_MULQ: - return compute_all_mulq(env); - + return compute_all_mulq(dst, src1, src2); case CC_OP_ADDQ: - return compute_all_addq(env); - + return compute_all_addq(dst, src1, src2); case CC_OP_ADCQ: - return compute_all_adcq(env); - + return compute_all_adcq(dst, src1, src2); case CC_OP_SUBQ: - return compute_all_subq(env); - + return compute_all_subq(dst, src1, src2); case CC_OP_SBBQ: - return compute_all_sbbq(env); - + return compute_all_sbbq(dst, src1, src2); case CC_OP_LOGICQ: - return compute_all_logicq(env); - + return compute_all_logicq(dst, src1, src2); case CC_OP_INCQ: - return compute_all_incq(env); - + return compute_all_incq(dst, src1, src2); case CC_OP_DECQ: - return compute_all_decq(env); - + return compute_all_decq(dst, src1, src2); case CC_OP_SHLQ: - return compute_all_shlq(env); - + return compute_all_shlq(dst, src1, src2); case CC_OP_SARQ: - return compute_all_sarq(env); + return compute_all_sarq(dst, src1, src2); #endif } } diff --git a/target-i386/cc_helper_template.h b/target-i386/cc_helper_template.h index fcb14db..5cfd232 100644 --- a/target-i386/cc_helper_template.h +++ b/target-i386/cc_helper_template.h @@ -18,89 +18,81 @@ */ #define DATA_BITS (1 << (3 + SHIFT)) -#define SIGN_MASK (((target_ulong)1) << (DATA_BITS - 1)) #if DATA_BITS == 8 #define SUFFIX b #define DATA_TYPE uint8_t -#define DATA_MASK 0xff #elif DATA_BITS == 16 #define SUFFIX w #define DATA_TYPE uint16_t -#define DATA_MASK 0xffff #elif DATA_BITS == 32 #define SUFFIX l #define DATA_TYPE uint32_t -#define DATA_MASK 0xffffffff #elif DATA_BITS == 64 #define SUFFIX q #define DATA_TYPE uint64_t -#define DATA_MASK 0xffffffffffffffffULL #else #error unhandled operand size #endif +#define SIGN_MASK (((DATA_TYPE)1) << (DATA_BITS - 1)) + /* dynamic flags computation */ -static int glue(compute_all_add, SUFFIX)(CPUX86State *env) +static int glue(compute_all_add, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1, + DATA_TYPE src2) { int cf, pf, af, zf, sf, of; - target_long src1, src2; - - src1 = CC_SRC; - src2 = CC_DST - CC_SRC; - cf = (DATA_TYPE)CC_DST < (DATA_TYPE)src1; - pf = parity_table[(uint8_t)CC_DST]; - af = (CC_DST ^ src1 ^ src2) & 0x10; - zf = ((DATA_TYPE)CC_DST == 0) << 6; - sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80; - of = lshift((src1 ^ src2 ^ -1) & (src1 ^ CC_DST), 12 - DATA_BITS) & CC_O; + + src2 = dst - src1; + cf = dst < src1; + pf = parity_table[(uint8_t)dst]; + af = (dst ^ src1 ^ src2) & CC_A; + zf = (dst == 0) * CC_Z; + sf = lshift(dst, 8 - DATA_BITS) & CC_S; + of = lshift((src1 ^ src2 ^ -1) & (src1 ^ dst), 12 - DATA_BITS) & CC_O; return cf | pf | af | zf | sf | of; } -static int glue(compute_all_adc, SUFFIX)(CPUX86State *env) +static int glue(compute_all_adc, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1, + DATA_TYPE src3) { int cf, pf, af, zf, sf, of; - DATA_TYPE dst, src1, src2, src3; - - dst = CC_DST; - src1 = CC_SRC; - src3 = CC_SRC2; /* carry-in: always 0/1. */ - src2 = dst - src1; + DATA_TYPE src2 = dst - src1; cf = dst < src1 || dst < src3; pf = parity_table[(uint8_t)dst]; - af = (dst ^ src1 ^ src2) & 0x10; - zf = (dst == 0) << 6; - sf = lshift(dst, 8 - DATA_BITS) & 0x80; + af = (dst ^ src1 ^ src2) & CC_A; + zf = (dst == 0) * CC_Z; + sf = lshift(dst, 8 - DATA_BITS) & CC_S; of = lshift((src1 ^ src2 ^ -1) & (src1 ^ dst), 12 - DATA_BITS) & CC_O; return cf | pf | af | zf | sf | of; } -static int glue(compute_all_sub, SUFFIX)(CPUX86State *env) +static int glue(compute_all_sub, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1, + DATA_TYPE src2) { int cf, pf, af, zf, sf, of; - target_long src1, src2; - - src1 = CC_DST + CC_SRC; - src2 = CC_SRC; - cf = (DATA_TYPE)src1 < (DATA_TYPE)src2; - pf = parity_table[(uint8_t)CC_DST]; - af = (CC_DST ^ src1 ^ src2) & 0x10; - zf = ((DATA_TYPE)CC_DST == 0) << 6; - sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80; - of = lshift((src1 ^ src2) & (src1 ^ CC_DST), 12 - DATA_BITS) & CC_O; + + src2 = src1; + src1 = dst + src1; + + cf = src1 < src2; + pf = parity_table[(uint8_t)dst]; + af = (dst ^ src1 ^ src2) & CC_A; + zf = (dst == 0) * CC_Z; + sf = lshift(dst, 8 - DATA_BITS) & CC_S; + of = lshift((src1 ^ src2) & (src1 ^ dst), 12 - DATA_BITS) & CC_O; return cf | pf | af | zf | sf | of; } -static int glue(compute_all_sbb, SUFFIX)(CPUX86State *env) +static int glue(compute_all_sbb, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1, + DATA_TYPE src3) { int cf, pf, af, zf, sf, of; - DATA_TYPE dst, src1, src2, src3; + DATA_TYPE src2; - dst = CC_DST; - src3 = CC_SRC2; /* borrow-in: always 0/1. */ - src2 = CC_SRC + src3; + src2 = src1 + src3; src1 = dst + src2; /* If src2 + src3 overflows, then we're logically subtracting a larger @@ -114,91 +106,95 @@ static int glue(compute_all_sbb, SUFFIX)(CPUX86State *env) return cf | pf | af | zf | sf | of; } -static int glue(compute_all_logic, SUFFIX)(CPUX86State *env) +static int glue(compute_all_logic, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1, + DATA_TYPE src2) { int cf, pf, af, zf, sf, of; cf = 0; - pf = parity_table[(uint8_t)CC_DST]; + pf = parity_table[(uint8_t)dst]; af = 0; - zf = ((DATA_TYPE)CC_DST == 0) << 6; - sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80; + zf = (dst == 0) * CC_Z; + sf = lshift(dst, 8 - DATA_BITS) & CC_S; of = 0; return cf | pf | af | zf | sf | of; } -static int glue(compute_all_inc, SUFFIX)(CPUX86State *env) +static int glue(compute_all_inc, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1, + DATA_TYPE src2) { int cf, pf, af, zf, sf, of; - target_long src1, src2; - src1 = CC_DST - 1; + cf = src1; + src1 = dst - 1; src2 = 1; - cf = CC_SRC; - pf = parity_table[(uint8_t)CC_DST]; - af = (CC_DST ^ src1 ^ src2) & 0x10; - zf = ((DATA_TYPE)CC_DST == 0) << 6; - sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80; - of = ((CC_DST & DATA_MASK) == SIGN_MASK) << 11; + pf = parity_table[(uint8_t)dst]; + af = (dst ^ src1 ^ src2) & CC_A; + zf = (dst == 0) * CC_Z; + sf = lshift(dst, 8 - DATA_BITS) & CC_S; + of = (dst == SIGN_MASK) * CC_O; return cf | pf | af | zf | sf | of; } -static int glue(compute_all_dec, SUFFIX)(CPUX86State *env) +static int glue(compute_all_dec, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1, + DATA_TYPE src2) { int cf, pf, af, zf, sf, of; - target_long src1, src2; - src1 = CC_DST + 1; + cf = src1; + src1 = dst + 1; src2 = 1; - cf = CC_SRC; - pf = parity_table[(uint8_t)CC_DST]; - af = (CC_DST ^ src1 ^ src2) & 0x10; - zf = ((DATA_TYPE)CC_DST == 0) << 6; - sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80; - of = ((CC_DST & DATA_MASK) == ((target_ulong)SIGN_MASK - 1)) << 11; + pf = parity_table[(uint8_t)dst]; + af = (dst ^ src1 ^ src2) & CC_A; + zf = (dst == 0) * CC_Z; + sf = lshift(dst, 8 - DATA_BITS) & CC_S; + of = (dst == SIGN_MASK - 1) * CC_O; return cf | pf | af | zf | sf | of; } -static int glue(compute_all_shl, SUFFIX)(CPUX86State *env) +static int glue(compute_all_shl, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1, + DATA_TYPE src2) { int cf, pf, af, zf, sf, of; - cf = (CC_SRC >> (DATA_BITS - 1)) & CC_C; - pf = parity_table[(uint8_t)CC_DST]; + cf = (src1 >> (DATA_BITS - 1)) & CC_C; + pf = parity_table[(uint8_t)dst]; af = 0; /* undefined */ - zf = ((DATA_TYPE)CC_DST == 0) << 6; - sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80; - /* of is defined if shift count == 1 */ - of = lshift(CC_SRC ^ CC_DST, 12 - DATA_BITS) & CC_O; + zf = (dst == 0) * CC_Z; + sf = lshift(dst, 8 - DATA_BITS) & CC_S; + /* of is defined iff shift count == 1 */ + of = lshift(src1 ^ dst, 12 - DATA_BITS) & CC_O; return cf | pf | af | zf | sf | of; } -static int glue(compute_all_sar, SUFFIX)(CPUX86State *env) +static int glue(compute_all_sar, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1, + DATA_TYPE src2) { int cf, pf, af, zf, sf, of; - cf = CC_SRC & 1; - pf = parity_table[(uint8_t)CC_DST]; + cf = src1 & 1; + pf = parity_table[(uint8_t)dst]; af = 0; /* undefined */ - zf = ((DATA_TYPE)CC_DST == 0) << 6; - sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80; - /* of is defined if shift count == 1 */ - of = lshift(CC_SRC ^ CC_DST, 12 - DATA_BITS) & CC_O; + zf = (dst == 0) * CC_Z; + sf = lshift(dst, 8 - DATA_BITS) & CC_S; + /* of is defined iff shift count == 1 */ + of = lshift(src1 ^ dst, 12 - DATA_BITS) & CC_O; return cf | pf | af | zf | sf | of; } /* 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) +static int glue(compute_all_mul, SUFFIX)(DATA_TYPE dst, DATA_TYPE src1, + DATA_TYPE src2) { int cf, pf, af, zf, sf, of; - cf = (CC_SRC != 0); - pf = parity_table[(uint8_t)CC_DST]; + cf = (src1 != 0); + pf = parity_table[(uint8_t)dst]; af = 0; /* undefined */ - zf = ((DATA_TYPE)CC_DST == 0) << 6; - sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80; - of = cf << 11; + zf = (dst == 0) * CC_Z; + sf = lshift(dst, 8 - DATA_BITS) & CC_S; + of = cf * CC_O; return cf | pf | af | zf | sf | of; }