From nobody Thu Nov 13 22:04:22 2025 Delivered-To: importer@patchew.org Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Authentication-Results: mx.zohomail.com; dkim=fail header.i=@quicinc.com; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=quicinc.com ARC-Seal: i=1; a=rsa-sha256; t=1582910012; cv=none; d=zohomail.com; s=zohoarc; b=Y/yJAY/Bm8nKo4INYjyJMz/C0alkF76Z845EGwxNecFePv1FJhUx6nRJGFc9GzGKscX75IodDiBqcdqSeT0UhIk1LB+eUwr5K83JKzooV9fiIQZm+YHe3nOqgB7cLkF07xxUdX1e4w2rLOHIkPo2YtHMf+Oi2McW3ZE+9PAiwEQ= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1582910012; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=FhbiVb0LyRDYiC030iK39U33v1SoyG4LAaAQjpUsgqA=; b=n+Y6v+0XtBs/RU8N7NU0AdgrIWWijLQsirF5y0jh6U6wlYDi5p7OhnBMFuRFeZUZ6GugE4hUBqHsCJRi34uY0hNQINmj0O4WXEZwWPLlx5utEhbrs9EIb6bkqDTsfFrrIu/8z++cMVepz2Jb8U6FbDORBcymo3Vvzl4sVvecNk4= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail header.i=@quicinc.com; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1582910012086606.7332663012198; Fri, 28 Feb 2020 09:13:32 -0800 (PST) Received: from localhost ([::1]:51066 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1j7jCb-0006du-D2 for importer@patchew.org; Fri, 28 Feb 2020 12:13:29 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:58257) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1j7ilZ-0004jl-7i for qemu-devel@nongnu.org; Fri, 28 Feb 2020 11:45:44 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1j7ilO-0006V8-0T for qemu-devel@nongnu.org; Fri, 28 Feb 2020 11:45:32 -0500 Received: from alexa-out-sd-01.qualcomm.com ([199.106.114.38]:13250) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1j7iky-0005Uz-VH for qemu-devel@nongnu.org; Fri, 28 Feb 2020 11:45:21 -0500 Received: from unknown (HELO ironmsg02-sd.qualcomm.com) ([10.53.140.142]) by alexa-out-sd-01.qualcomm.com with ESMTP; 28 Feb 2020 08:44:29 -0800 Received: from vu-tsimpson-aus.qualcomm.com (HELO vu-tsimpson1-aus.qualcomm.com) ([10.222.150.1]) by ironmsg02-sd.qualcomm.com with ESMTP; 28 Feb 2020 08:44:28 -0800 Received: by vu-tsimpson1-aus.qualcomm.com (Postfix, from userid 47164) id C7059F0B; Fri, 28 Feb 2020 10:44:28 -0600 (CST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=quicinc.com; i=@quicinc.com; q=dns/txt; s=qcdkim; t=1582908296; x=1614444296; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=FhbiVb0LyRDYiC030iK39U33v1SoyG4LAaAQjpUsgqA=; b=Ad1m6vUbUHBVGE1qNJJAI/6GbsQRpNf19I/mnibOZP2FbBHM/7kvK03m +nAMyOBXKn5WMp7x3rAiHoQFkOlW+7w0LIBLC9hd8PSRVFZGSa5IezEfV 5v2YXitwRw1StnmrYKKFqTdIE6e/YSCcPhS7Bk6rGPOkEL++B9DiEqqFv 8=; From: Taylor Simpson To: qemu-devel@nongnu.org Subject: [RFC PATCH v2 16/67] Hexagon arch import - instruction semantics definitions Date: Fri, 28 Feb 2020 10:43:12 -0600 Message-Id: <1582908244-304-17-git-send-email-tsimpson@quicinc.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1582908244-304-1-git-send-email-tsimpson@quicinc.com> References: <1582908244-304-1-git-send-email-tsimpson@quicinc.com> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable X-detected-operating-system: by eggs.gnu.org: FreeBSD 9.x [fuzzy] X-Received-From: 199.106.114.38 X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: riku.voipio@iki.fi, richard.henderson@linaro.org, laurent@vivier.eu, Taylor Simpson , philmd@redhat.com, aleksandar.m.mail@gmail.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Imported from the Hexagon architecture library imported/allidefs.def Top level instruction definition file imported/*.idef Instruction definition files These files are input to the first phase of the generator (gen_semantics.c) to create a python include file with the instruction semantics and attribut= es. The python include file is fed to the second phase (do_qemu.py). Signed-off-by: Taylor Simpson --- target/hexagon/imported/allidefs.def | 91 +++ target/hexagon/imported/alu.idef | 1335 +++++++++++++++++++++++++++++= ++++ target/hexagon/imported/branch.idef | 344 +++++++++ target/hexagon/imported/compare.idef | 639 ++++++++++++++++ target/hexagon/imported/float.idef | 498 ++++++++++++ target/hexagon/imported/ldst.idef | 421 +++++++++++ target/hexagon/imported/mpy.idef | 1269 +++++++++++++++++++++++++++++= ++ target/hexagon/imported/shift.idef | 1211 ++++++++++++++++++++++++++++++ target/hexagon/imported/subinsns.idef | 152 ++++ target/hexagon/imported/system.idef | 302 ++++++++ 10 files changed, 6262 insertions(+) create mode 100644 target/hexagon/imported/allidefs.def create mode 100644 target/hexagon/imported/alu.idef create mode 100644 target/hexagon/imported/branch.idef create mode 100644 target/hexagon/imported/compare.idef create mode 100644 target/hexagon/imported/float.idef create mode 100644 target/hexagon/imported/ldst.idef create mode 100644 target/hexagon/imported/mpy.idef create mode 100644 target/hexagon/imported/shift.idef create mode 100644 target/hexagon/imported/subinsns.idef create mode 100644 target/hexagon/imported/system.idef diff --git a/target/hexagon/imported/allidefs.def b/target/hexagon/imported= /allidefs.def new file mode 100644 index 0000000..d2f13a2 --- /dev/null +++ b/target/hexagon/imported/allidefs.def @@ -0,0 +1,91 @@ +/* + * Copyright(c) 2019-2020 Qualcomm Innovation Center, Inc. All Rights Res= erved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +/* + * Top level instruction definition file + */ + +#define DEF_MAPPING(TAG,FROMSYN,TOSYN) \ + Q6INSN(TAG,FROMSYN,ATTRIBS(A_MAPPING), \ + "Mapping from " FROMSYN " to " TOSYN, \ + fASM_MAP(FROMSYN,TOSYN)) + +#define DEF_COND_MAPPING(TAG,FROMSYN,COND,TOSYNA,TOSYNB) \ + Q6INSN(TAG,FROMSYN,ATTRIBS(A_MAPPING,A_CONDMAPPING), \ + "Conditional Mapping from " FROMSYN " to either " TOSYNA " or " TOSYNB, \ + fCOND_ASM_MAP(FROMSYN,COND,TOSYNA,TOSYNB)) + +#define DEF_V2_MAPPING(TAG,FROMSYN,TOSYN) \ + Q6INSN(TAG,FROMSYN,ATTRIBS(A_MAPPING,A_ARCHV2), \ + "Mapping from " FROMSYN " to " TOSYN, \ + fASM_MAP(FROMSYN,TOSYN)) + +#define DEF_V2_COND_MAPPING(TAG,FROMSYN,COND,TOSYNA,TOSYNB) \ + Q6INSN(TAG,FROMSYN,ATTRIBS(A_MAPPING,A_CONDMAPPING,A_ARCHV2), \ + "Conditional Mapping from " FROMSYN " to either " TOSYNA " or " TOSYNB, \ + fCOND_ASM_MAP(FROMSYN,COND,TOSYNA,TOSYNB)) + +#define DEF_V3_MAPPING(TAG,FROMSYN,TOSYN) \ + Q6INSN(TAG,FROMSYN,ATTRIBS(A_MAPPING,A_ARCHV3), \ + "Mapping from " FROMSYN " to " TOSYN, \ + fASM_MAP(FROMSYN,TOSYN)) + +#define DEF_V3_COND_MAPPING(TAG,FROMSYN,COND,TOSYNA,TOSYNB) \ + Q6INSN(TAG,FROMSYN,ATTRIBS(A_MAPPING,A_CONDMAPPING,A_ARCHV3), \ + "Conditional Mapping from " FROMSYN " to either " TOSYNA " or " TOSYNB, \ + fCOND_ASM_MAP(FROMSYN,COND,TOSYNA,TOSYNB)) + +#define DEF_V4_MAPPING(TAG,FROMSYN,TOSYN) \ + Q6INSN(TAG,FROMSYN,ATTRIBS(A_MAPPING,A_ARCHV4), \ + "Mapping from " FROMSYN " to " TOSYN, \ + fASM_MAP(FROMSYN,TOSYN)) + +#define DEF_V4_COND_MAPPING(TAG,FROMSYN,COND,TOSYNA,TOSYNB) \ + Q6INSN(TAG,FROMSYN,ATTRIBS(A_MAPPING,A_CONDMAPPING,A_ARCHV4), \ + "Conditional Mapping from " FROMSYN " to either " TOSYNA " or " TOSYNB, \ + fCOND_ASM_MAP(FROMSYN,COND,TOSYNA,TOSYNB)) + +#define DEF_V5_MAPPING(TAG,FROMSYN,TOSYN) \ + Q6INSN(TAG,FROMSYN,ATTRIBS(A_MAPPING,A_ARCHV5), \ + "Mapping from " FROMSYN " to " TOSYN, \ + fASM_MAP(FROMSYN,TOSYN)) + +#define DEF_V5_COND_MAPPING(TAG,FROMSYN,COND,TOSYNA,TOSYNB) \ + Q6INSN(TAG,FROMSYN,ATTRIBS(A_MAPPING,A_CONDMAPPING,A_ARCHV5), \ + "Conditional Mapping from " FROMSYN " to either " TOSYNA " or " TOSYNB, \ + fCOND_ASM_MAP(FROMSYN,COND,TOSYNA,TOSYNB)) + +#define DEF_VECX_MAPPING(TAG,FROMSYN,TOSYN) \ + EXTINSN(TAG,FROMSYN,ATTRIBS(A_MAPPING,A_VECX), \ + "VECX Mapping from " FROMSYN " to " TOSYN, \ + fASM_MAP(FROMSYN,TOSYN)) + +#define DEF_CVI_MAPPING(TAG,FROMSYN,TOSYN) \ + Q6INSN(TAG,FROMSYN,ATTRIBS(A_MAPPING,A_CVI), \ + "CVI Mapping from " FROMSYN " to " TOSYN, \ + fASM_MAP(FROMSYN,TOSYN)) + + +#include "branch.idef" +#include "ldst.idef" +#include "compare.idef" +#include "mpy.idef" +#include "alu.idef" +#include "float.idef" +#include "shift.idef" +#include "system.idef" +#include "subinsns.idef" diff --git a/target/hexagon/imported/alu.idef b/target/hexagon/imported/alu= .idef new file mode 100644 index 0000000..c17d52f --- /dev/null +++ b/target/hexagon/imported/alu.idef @@ -0,0 +1,1335 @@ +/* + * Copyright(c) 2019-2020 Qualcomm Innovation Center, Inc. All Rights Res= erved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +/* + * ALU Instructions + */ + + +/**********************************************/ +/* Add/Sub instructions */ +/**********************************************/ + +Q6INSN(A2_add,"Rd32=3Dadd(Rs32,Rt32)",ATTRIBS(), +"Add 32-bit registers", +{ RdV=3DRsV+RtV;}) + +Q6INSN(A2_sub,"Rd32=3Dsub(Rt32,Rs32)",ATTRIBS(), +"Subtract 32-bit registers", +{ RdV=3DRtV-RsV;}) + +#define COND_ALU(TAG,OPER,DESCR,SEMANTICS)\ +Q6INSN(TAG##t,"if (Pu4) "OPER,ATTRIBS(A_ARCHV2),DESCR,{if(fLSBOLD(PuV)){SE= MANTICS;} else {CANCEL;}})\ +Q6INSN(TAG##f,"if (!Pu4) "OPER,ATTRIBS(A_ARCHV2),DESCR,{if(fLSBOLDNOT(PuV)= ){SEMANTICS;} else {CANCEL;}})\ +Q6INSN(TAG##tnew,"if (Pu4.new) " OPER,ATTRIBS(A_ARCHV2),DESCR,{if(fLSBNEW(= PuN)){SEMANTICS;} else {CANCEL;}})\ +Q6INSN(TAG##fnew,"if (!Pu4.new) "OPER,ATTRIBS(A_ARCHV2),DESCR,{if(fLSBNEWN= OT(PuN)){SEMANTICS;} else {CANCEL;}}) + +COND_ALU(A2_padd,"Rd32=3Dadd(Rs32,Rt32)","Conditionally Add 32-bit registe= rs",RdV=3DRsV+RtV) +COND_ALU(A2_psub,"Rd32=3Dsub(Rt32,Rs32)","Conditionally Subtract 32-bit re= gisters",RdV=3DRtV-RsV) +COND_ALU(A2_paddi,"Rd32=3Dadd(Rs32,#s8)","Conditionally Add Register and i= mmediate",fIMMEXT(siV); RdV=3DRsV+siV) +COND_ALU(A2_pxor,"Rd32=3Dxor(Rs32,Rt32)","Conditionally XOR registers",RdV= =3DRsV^RtV); +COND_ALU(A2_pand,"Rd32=3Dand(Rs32,Rt32)","Conditionally AND registers",RdV= =3DRsV&RtV); +COND_ALU(A2_por,"Rd32=3Dor(Rs32,Rt32)","Conditionally OR registers",RdV=3D= RsV|RtV); + +COND_ALU(A4_psxtb,"Rd32=3Dsxtb(Rs32)","Conditionally sign-extend byte", Rd= V=3DfSXTN(8,32,RsV)); +COND_ALU(A4_pzxtb,"Rd32=3Dzxtb(Rs32)","Conditionally zero-extend byte", Rd= V=3DfZXTN(8,32,RsV)); +COND_ALU(A4_psxth,"Rd32=3Dsxth(Rs32)","Conditionally sign-extend halfword"= , RdV=3DfSXTN(16,32,RsV)); +COND_ALU(A4_pzxth,"Rd32=3Dzxth(Rs32)","Conditionally zero-extend halfword"= , RdV=3DfZXTN(16,32,RsV)); +COND_ALU(A4_paslh,"Rd32=3Daslh(Rs32)","Conditionally zero-extend halfword"= , RdV=3DRsV<<16); +COND_ALU(A4_pasrh,"Rd32=3Dasrh(Rs32)","Conditionally zero-extend halfword"= , RdV=3DRsV>>16); + + +DEF_V2_MAPPING(A2_tfrt, "if (Pu4) Rd32=3DRs32","if (Pu4) Rd32=3Dadd(Rs32= ,#0)") +DEF_V2_MAPPING(A2_tfrf, "if (!Pu4) Rd32=3DRs32","if (!Pu4) Rd32=3Dadd(Rs= 32,#0)") +DEF_V2_MAPPING(A2_tfrtnew,"if (Pu4.new) Rd32=3DRs32","if (Pu4.new) Rd32=3D= add(Rs32,#0)") +DEF_V2_MAPPING(A2_tfrfnew,"if (!Pu4.new) Rd32=3DRs32","if (!Pu4.new) Rd32= =3Dadd(Rs32,#0)") + + +DEF_V2_MAPPING(A2_tfrpt, "if (Pu4) Rdd32=3DRss32","if (Pu4) Rdd32=3Dcomb= ine(Rss.H32,Rss.L32)") +DEF_V2_MAPPING(A2_tfrpf, "if (!Pu4) Rdd32=3DRss32","if (!Pu4) Rdd32=3Dco= mbine(Rss.H32,Rss.L32)") +DEF_V2_MAPPING(A2_tfrptnew,"if (Pu4.new) Rdd32=3DRss32","if (Pu4.new) Rdd3= 2=3Dcombine(Rss.H32,Rss.L32)") +DEF_V2_MAPPING(A2_tfrpfnew,"if (!Pu4.new) Rdd32=3DRss32","if (!Pu4.new) Rd= d32=3Dcombine(Rss.H32,Rss.L32)") + + +Q6INSN(A2_addsat,"Rd32=3Dadd(Rs32,Rt32):sat",ATTRIBS(), +"Add 32-bit registers with saturation", +{ RdV=3DfSAT(fSE32_64(RsV)+fSE32_64(RtV)); }) + +Q6INSN(A2_subsat,"Rd32=3Dsub(Rt32,Rs32):sat",ATTRIBS(), +"Subtract 32-bit registers with saturation", +{ RdV=3DfSAT(fSE32_64(RtV) - fSE32_64(RsV)); }) + + +Q6INSN(A2_addi,"Rd32=3Dadd(Rs32,#s16)",ATTRIBS(), +"Add a signed immediate to a register", +{ fIMMEXT(siV); RdV=3DRsV+siV;}) + + +Q6INSN(C4_addipc,"Rd32=3Dadd(pc,#u6)",ATTRIBS(), +"Add immediate to PC", +{ RdV=3DfREAD_PC()+fIMMEXT(uiV);}) + + + +/**********************************************/ +/* Single-precision HL forms */ +/* These insns and the SP mpy are the ones */ +/* that can do .HL stuff */ +/**********************************************/ +#define STD_HL_INSN(TAG,OPER,AOPER,ATR,SEM)\ +Q6INSN(A2_##TAG##_ll, OPER"(Rt.L32,Rs.L32)"AOPER, ATR,"",{SEM(fGETHALF(= 0,RtV),fGETHALF(0,RsV));})\ +Q6INSN(A2_##TAG##_lh, OPER"(Rt.L32,Rs.H32)"AOPER, ATR,"",{SEM(fGETHALF(= 0,RtV),fGETHALF(1,RsV));})\ +Q6INSN(A2_##TAG##_hl, OPER"(Rt.H32,Rs.L32)"AOPER, ATR,"",{SEM(fGETHALF(= 1,RtV),fGETHALF(0,RsV));})\ +Q6INSN(A2_##TAG##_hh, OPER"(Rt.H32,Rs.H32)"AOPER, ATR,"",{SEM(fGETHALF(= 1,RtV),fGETHALF(1,RsV));}) + +#define SUBSTD_HL_INSN(TAG,OPER,AOPER,ATR,SEM)\ +Q6INSN(A2_##TAG##_ll, OPER"(Rt.L32,Rs.L32)"AOPER, ATR,"",{SEM(fGETHALF(= 0,RtV),fGETHALF(0,RsV));})\ +Q6INSN(A2_##TAG##_hl, OPER"(Rt.L32,Rs.H32)"AOPER, ATR,"",{SEM(fGETHALF(= 0,RtV),fGETHALF(1,RsV));}) + + +#undef HLSEM +#define HLSEM(A,B) RdV=3DfSXTN(16,32,(A+B)) +SUBSTD_HL_INSN(addh_l16,"Rd32=3Dadd","",ATTRIBS(),HLSEM) + +#undef HLSEM +#define HLSEM(A,B) RdV=3DfSATH(A+B) +SUBSTD_HL_INSN(addh_l16_sat,"Rd32=3Dadd",":sat",ATTRIBS(),HLSEM) + +#undef HLSEM +#define HLSEM(A,B) RdV=3DfSXTN(16,32,(A-B)) +SUBSTD_HL_INSN(subh_l16,"Rd32=3Dsub","",ATTRIBS(),HLSEM) + +#undef HLSEM +#define HLSEM(A,B) RdV=3DfSATH(A-B) +SUBSTD_HL_INSN(subh_l16_sat,"Rd32=3Dsub",":sat",ATTRIBS(),HLSEM) + +#undef HLSEM +#define HLSEM(A,B) RdV=3D(A+B)<<16 +STD_HL_INSN(addh_h16,"Rd32=3Dadd",":<<16",ATTRIBS(),HLSEM) + +#undef HLSEM +#define HLSEM(A,B) RdV=3D(fSATH(A+B))<<16 +STD_HL_INSN(addh_h16_sat,"Rd32=3Dadd",":sat:<<16",ATTRIBS(),HLSEM) + +#undef HLSEM +#define HLSEM(A,B) RdV=3D(A-B)<<16 +STD_HL_INSN(subh_h16,"Rd32=3Dsub",":<<16",ATTRIBS(),HLSEM) + +#undef HLSEM +#define HLSEM(A,B) RdV=3D(fSATH(A-B))<<16 +STD_HL_INSN(subh_h16_sat,"Rd32=3Dsub",":sat:<<16",ATTRIBS(),HLSEM) + + + + +Q6INSN(A2_aslh,"Rd32=3Daslh(Rs32)",ATTRIBS(), +"Arithmetic Shift Left by Halfword",{ RdV=3DRsV<<16; }) + +Q6INSN(A2_asrh,"Rd32=3Dasrh(Rs32)",ATTRIBS(), +"Arithmetic Shift Right by Halfword",{ RdV=3DRsV>>16; }) + + +/* 64-bit versions */ + +Q6INSN(A2_addp,"Rdd32=3Dadd(Rss32,Rtt32)",ATTRIBS(), +"Add", +{ RddV=3DRssV+RttV;}) + +Q6INSN(A2_addpsat,"Rdd32=3Dadd(Rss32,Rtt32):sat",ATTRIBS(A_ARCHV3), +"Add", +{ fADDSAT64(RddV,RssV,RttV);}) + +Q6INSN(A2_addspl,"Rdd32=3Dadd(Rss32,Rtt32):raw:lo",ATTRIBS(A_ARCHV3), +"Add", +{ RddV=3DRttV+fSXTN(32,64,fGETWORD(0,RssV));}) + +Q6INSN(A2_addsph,"Rdd32=3Dadd(Rss32,Rtt32):raw:hi",ATTRIBS(A_ARCHV3), +"Add", +{ RddV=3DRttV+fSXTN(32,64,fGETWORD(1,RssV));}) + +DEF_V3_COND_MAPPING(A2_addsp,"Rdd32=3Dadd(Rs32,Rtt32)","Rs32 & 1","Rdd32= =3Dadd(Rss32,Rtt32):raw:hi","Rdd32=3Dadd(Rss32,Rtt32):raw:lo") + +Q6INSN(A2_subp,"Rdd32=3Dsub(Rtt32,Rss32)",ATTRIBS(), +"Sub", +{ RddV=3DRttV-RssV;}) + +/* 64-bit with carry */ + +Q6INSN(A4_addp_c,"Rdd32=3Dadd(Rss32,Rtt32,Px4):carry",ATTRIBS(A_RESTRICT_L= ATEPRED,A_NOTE_LATEPRED),"Add with Carry", +{ + fPREDUSE_TIMING(); + RddV =3D RssV + RttV + fLSBOLD(PxV); + PxV =3D f8BITSOF(fCARRY_FROM_ADD(RssV,RttV,fLSBOLD(PxV))); + fHIDE(MARK_LATE_PRED_WRITE(PxN)) +}) + +Q6INSN(A4_subp_c,"Rdd32=3Dsub(Rss32,Rtt32,Px4):carry",ATTRIBS(A_RESTRICT_L= ATEPRED,A_NOTE_LATEPRED),"Sub with Carry", +{ + fPREDUSE_TIMING(); + RddV =3D RssV + ~RttV + fLSBOLD(PxV); + PxV =3D f8BITSOF(fCARRY_FROM_ADD(RssV,~RttV,fLSBOLD(PxV))); + fHIDE(MARK_LATE_PRED_WRITE(PxN)) +}) + + +/* NEG and ABS */ + +DEF_MAPPING(A2_neg,"Rd32=3Dneg(Rs32)","Rd32=3Dsub(#0,Rs32)") + + +Q6INSN(A2_negsat,"Rd32=3Dneg(Rs32):sat",ATTRIBS(), +"Arithmetic negate register", { RdV =3D fSAT(-fCAST8s(RsV)); }) + +Q6INSN(A2_abs,"Rd32=3Dabs(Rs32)",ATTRIBS(), +"Absolute Value register", { RdV =3D fABS(RsV); }) + +Q6INSN(A2_abssat,"Rd32=3Dabs(Rs32):sat",ATTRIBS(), +"Arithmetic negate register", { RdV =3D fSAT(fABS(fCAST4_8s(RsV))); }) + +Q6INSN(A2_vconj,"Rdd32=3Dvconj(Rss32):sat",ATTRIBS(A_ARCHV2), +"Vector Complex conjugate of Rss", +{ fSETHALF(1,RddV,fSATN(16,-fGETHALF(1,RssV))); + fSETHALF(0,RddV,fGETHALF(0,RssV)); + fSETHALF(3,RddV,fSATN(16,-fGETHALF(3,RssV))); + fSETHALF(2,RddV,fGETHALF(2,RssV)); +}) + + +/* 64-bit versions */ + +Q6INSN(A2_negp,"Rdd32=3Dneg(Rss32)",ATTRIBS(), +"Arithmetic negate register", { RddV =3D -RssV; }) + +Q6INSN(A2_absp,"Rdd32=3Dabs(Rss32)",ATTRIBS(), +"Absolute Value register", { RddV =3D fABS(RssV); }) + + +/* MIN and MAX R */ + +Q6INSN(A2_max,"Rd32=3Dmax(Rs32,Rt32)",ATTRIBS(), +"Maximum of two registers", +{ RdV =3D fMAX(RsV,RtV); }) + +Q6INSN(A2_maxu,"Rd32=3Dmaxu(Rs32,Rt32)",ATTRIBS(A_INTRINSIC_RETURNS_UNSIGN= ED), +"Maximum of two registers (unsigned)", +{ RdV =3D fMAX(fCAST4u(RsV),fCAST4u(RtV)); }) + +Q6INSN(A2_min,"Rd32=3Dmin(Rt32,Rs32)",ATTRIBS(), +"Minimum of two registers", +{ RdV =3D fMIN(RtV,RsV); }) + +Q6INSN(A2_minu,"Rd32=3Dminu(Rt32,Rs32)",ATTRIBS(A_INTRINSIC_RETURNS_UNSIGN= ED), +"Minimum of two registers (unsigned)", +{ RdV =3D fMIN(fCAST4u(RtV),fCAST4u(RsV)); }) + +/* MIN and MAX Pairs */ +#if 1 +Q6INSN(A2_maxp,"Rdd32=3Dmax(Rss32,Rtt32)",ATTRIBS(A_ARCHV3), +"Maximum of two register pairs", +{ RddV =3D fMAX(RssV,RttV); }) + +Q6INSN(A2_maxup,"Rdd32=3Dmaxu(Rss32,Rtt32)",ATTRIBS(A_INTRINSIC_RETURNS_UN= SIGNED,A_ARCHV3), +"Maximum of two register pairs (unsigned)", +{ RddV =3D fMAX(fCAST8u(RssV),fCAST8u(RttV)); }) + +Q6INSN(A2_minp,"Rdd32=3Dmin(Rtt32,Rss32)",ATTRIBS(A_ARCHV3), +"Minimum of two register pairs", +{ RddV =3D fMIN(RttV,RssV); }) + +Q6INSN(A2_minup,"Rdd32=3Dminu(Rtt32,Rss32)",ATTRIBS(A_INTRINSIC_RETURNS_UN= SIGNED,A_ARCHV3), +"Minimum of two register pairs (unsigned)", +{ RddV =3D fMIN(fCAST8u(RttV),fCAST8u(RssV)); }) +#endif + +/**********************************************/ +/* Register and Immediate Transfers */ +/**********************************************/ + +Q6INSN(A2_nop,"nop",ATTRIBS(A_IT_NOP), +"Nop (32-bit encoding)", + fHIDE( { fNOP_EXECUTED } )) + + +Q6INSN(A4_ext,"immext(#u26:6)",ATTRIBS(A_IT_EXTENDER), +"This instruction carries the 26 most-significant immediate bits for the n= ext instruction", +{ fHIDE(); }) + + +Q6INSN(A2_tfr,"Rd32=3DRs32",ATTRIBS(), +"tfr register",{ RdV=3DRsV;}) + +Q6INSN(A2_tfrsi,"Rd32=3D#s16",ATTRIBS(), +"transfer signed immediate to register",{ fIMMEXT(siV); RdV=3DsiV;}) + +DEF_MAPPING(A2_tfrp,"Rdd32=3DRss32","Rdd32=3Dcombine(Rss.H32,Rss.L32)") +DEF_V2_COND_MAPPING(A2_tfrpi,"Rdd32=3D#s8","#s8<0","Rdd32=3Dcombine(#-1,#s= 8)","Rdd32=3Dcombine(#0,#s8)") +DEF_MAPPING(A2_zxtb,"Rd32=3Dzxtb(Rs32)","Rd32=3Dand(Rs32,#255)") + +Q6INSN(A2_sxtb,"Rd32=3Dsxtb(Rs32)",ATTRIBS(), +"Sign extend byte", {RdV =3D fSXTN(8,32,RsV);}) + +Q6INSN(A2_zxth,"Rd32=3Dzxth(Rs32)",ATTRIBS(), +"Zero extend half", {RdV =3D fZXTN(16,32,RsV);}) + +Q6INSN(A2_sxth,"Rd32=3Dsxth(Rs32)",ATTRIBS(), +"Sign extend half", {RdV =3D fSXTN(16,32,RsV);}) + +Q6INSN(A2_combinew,"Rdd32=3Dcombine(Rs32,Rt32)",ATTRIBS(A_ROPS_2), +"Combine two words into a register pair", +{ fSETWORD(0,RddV,RtV); + fSETWORD(1,RddV,RsV); +}) + +Q6INSN(A4_combineri,"Rdd32=3Dcombine(Rs32,#s8)",ATTRIBS(A_ROPS_2), +"Combine a word and an immediate into a register pair", +{ fIMMEXT(siV); fSETWORD(0,RddV,siV); + fSETWORD(1,RddV,RsV); +}) + +Q6INSN(A4_combineir,"Rdd32=3Dcombine(#s8,Rs32)",ATTRIBS(A_ROPS_2), +"Combine a word and an immediate into a register pair", +{ fIMMEXT(siV); fSETWORD(0,RddV,RsV); + fSETWORD(1,RddV,siV); +}) + + + +Q6INSN(A2_combineii,"Rdd32=3Dcombine(#s8,#S8)",ATTRIBS(A_ARCHV2,A_ROPS_2), +"Set two small immediates", +{ fIMMEXT(siV); fSETWORD(0,RddV,SiV); fSETWORD(1,RddV,siV); }) + +Q6INSN(A4_combineii,"Rdd32=3Dcombine(#s8,#U6)",ATTRIBS(A_ROPS_2),"Set two = small immediates", +{ fIMMEXT(UiV); fSETWORD(0,RddV,UiV); fSETWORD(1,RddV,siV); }) + + +Q6INSN(A2_combine_hh,"Rd32=3Dcombine(Rt.H32,Rs.H32)",ATTRIBS(), +"Combine two halfs into a register", {RdV =3D (fGETUHALF(1,RtV)<<16) | fGE= TUHALF(1,RsV);}) + +Q6INSN(A2_combine_hl,"Rd32=3Dcombine(Rt.H32,Rs.L32)",ATTRIBS(), +"Combine two halfs into a register", {RdV =3D (fGETUHALF(1,RtV)<<16) | fGE= TUHALF(0,RsV);}) + +Q6INSN(A2_combine_lh,"Rd32=3Dcombine(Rt.L32,Rs.H32)",ATTRIBS(), +"Combine two halfs into a register", {RdV =3D (fGETUHALF(0,RtV)<<16) | fGE= TUHALF(1,RsV);}) + +Q6INSN(A2_combine_ll,"Rd32=3Dcombine(Rt.L32,Rs.L32)",ATTRIBS(), +"Combine two halfs into a register", {RdV =3D (fGETUHALF(0,RtV)<<16) | fGE= TUHALF(0,RsV);}) + +Q6INSN(A2_tfril,"Rx.L32=3D#u16",ATTRIBS(), +"Set low 16-bits, leave upper 16 unchanged",{ fSETHALF(0,RxV,uiV);}) + +Q6INSN(A2_tfrih,"Rx.H32=3D#u16",ATTRIBS(), +"Set high 16-bits, leave low 16 unchanged",{ fSETHALF(1,RxV,uiV);}) + +Q6INSN(A2_tfrcrr,"Rd32=3DCs32",ATTRIBS(), +"transfer control register to general register",{ RdV=3DCsV;}) + +Q6INSN(A2_tfrrcr,"Cd32=3DRs32",ATTRIBS(), +"transfer general register to control register",{ CdV=3DRsV;}) + +Q6INSN(A4_tfrcpp,"Rdd32=3DCss32",ATTRIBS(), +"transfer control register to general register",{ RddV=3DCssV;}) + +Q6INSN(A4_tfrpcp,"Cdd32=3DRss32",ATTRIBS(), +"transfer general register to control register",{ CddV=3DRssV;}) + + +/**********************************************/ +/* Logicals */ +/**********************************************/ + +Q6INSN(A2_and,"Rd32=3Dand(Rs32,Rt32)",ATTRIBS(), +"logical AND",{ RdV=3DRsV&RtV;}) + +Q6INSN(A2_or,"Rd32=3Dor(Rs32,Rt32)",ATTRIBS(), +"logical OR",{ RdV=3DRsV|RtV;}) + +Q6INSN(A2_xor,"Rd32=3Dxor(Rs32,Rt32)",ATTRIBS(), +"logical XOR",{ RdV=3DRsV^RtV;}) + +DEF_MAPPING(A2_not,"Rd32=3Dnot(Rs32)","Rd32=3Dsub(#-1,Rs32)") + +Q6INSN(M2_xor_xacc,"Rx32^=3Dxor(Rs32,Rt32)",ATTRIBS(A_ARCHV2), +"logical XOR with XOR accumulation",{ RxV^=3DRsV^RtV;}) + +Q6INSN(M4_xor_xacc,"Rxx32^=3Dxor(Rss32,Rtt32)",, +"logical XOR with XOR accumulation",{ RxxV^=3DRssV^RttV;}) + + + +Q6INSN(A4_andn,"Rd32=3Dand(Rt32,~Rs32)",, +"And-Not", { RdV =3D (RtV & ~RsV); }) + +Q6INSN(A4_orn,"Rd32=3Dor(Rt32,~Rs32)",, +"Or-Not", { RdV =3D (RtV | ~RsV); }) + + +Q6INSN(A4_andnp,"Rdd32=3Dand(Rtt32,~Rss32)",, +"And-Not", { RddV =3D (RttV & ~RssV); }) + +Q6INSN(A4_ornp,"Rdd32=3Dor(Rtt32,~Rss32)",, +"Or-Not", { RddV =3D (RttV | ~RssV); }) + + + + +/********************/ +/* Compound add-add */ +/********************/ + +Q6INSN(S4_addaddi,"Rd32=3Dadd(Rs32,add(Ru32,#s6))",ATTRIBS(A_ROPS_2), + "3-input add", + { RdV =3D RsV + RuV + fIMMEXT(siV); }) + + +Q6INSN(S4_subaddi,"Rd32=3Dadd(Rs32,sub(#s6,Ru32))",ATTRIBS(A_ROPS_2), + "3-input sub", + { RdV =3D RsV - RuV + fIMMEXT(siV); }) + + + +/****************************/ +/* Compound logical-logical */ +/****************************/ + +Q6INSN(M4_and_and,"Rx32&=3Dand(Rs32,Rt32)",ATTRIBS(A_ROPS_2), +"Compound And-And", { RxV &=3D (RsV & RtV); }) + +Q6INSN(M4_and_andn,"Rx32&=3Dand(Rs32,~Rt32)",ATTRIBS(A_ROPS_2), +"Compound And-Andn", { RxV &=3D (RsV & ~RtV); }) + +Q6INSN(M4_and_or,"Rx32&=3Dor(Rs32,Rt32)",ATTRIBS(A_ROPS_2), +"Compound And-Or", { RxV &=3D (RsV | RtV); }) + +Q6INSN(M4_and_xor,"Rx32&=3Dxor(Rs32,Rt32)",ATTRIBS(A_ROPS_2), +"Compound And-xor", { RxV &=3D (RsV ^ RtV); }) + + + +Q6INSN(M4_or_and,"Rx32|=3Dand(Rs32,Rt32)",ATTRIBS(A_ROPS_2), +"Compound Or-And", { RxV |=3D (RsV & RtV); }) + +Q6INSN(M4_or_andn,"Rx32|=3Dand(Rs32,~Rt32)",ATTRIBS(A_ROPS_2), +"Compound Or-AndN", { RxV |=3D (RsV & ~RtV); }) + +Q6INSN(M4_or_or,"Rx32|=3Dor(Rs32,Rt32)",ATTRIBS(A_ROPS_2), +"Compound Or-Or", { RxV |=3D (RsV | RtV); }) + +Q6INSN(M4_or_xor,"Rx32|=3Dxor(Rs32,Rt32)",ATTRIBS(A_ROPS_2), +"Compound Or-xor", { RxV |=3D (RsV ^ RtV); }) + + +Q6INSN(S4_or_andix,"Rx32=3Dor(Ru32,and(Rx32,#s10))",ATTRIBS(A_ROPS_2), +"Compound Or-And", { RxV =3D RuV | (RxV & fIMMEXT(siV)); }) + +Q6INSN(S4_or_andi,"Rx32|=3Dand(Rs32,#s10)",ATTRIBS(A_ROPS_2), +"Compound Or-And", { RxV =3D RxV | (RsV & fIMMEXT(siV)); }) + +Q6INSN(S4_or_ori,"Rx32|=3Dor(Rs32,#s10)",ATTRIBS(A_ROPS_2), +"Compound Or-And", { RxV =3D RxV | (RsV | fIMMEXT(siV)); }) + + + + +Q6INSN(M4_xor_and,"Rx32^=3Dand(Rs32,Rt32)",ATTRIBS(A_ROPS_2), +"Compound Xor-And", { RxV ^=3D (RsV & RtV); }) + +Q6INSN(M4_xor_or,"Rx32^=3Dor(Rs32,Rt32)",ATTRIBS(A_ROPS_2), +"Compound Xor-Or", { RxV ^=3D (RsV | RtV); }) + +Q6INSN(M4_xor_andn,"Rx32^=3Dand(Rs32,~Rt32)",ATTRIBS(A_ROPS_2), +"Compound Xor-And", { RxV ^=3D (RsV & ~RtV); }) + + + + + + +Q6INSN(A2_subri,"Rd32=3Dsub(#s10,Rs32)",ATTRIBS(A_ARCHV2), +"Subtract register from immediate",{ fIMMEXT(siV); RdV=3DsiV-RsV;}) + +Q6INSN(A2_andir,"Rd32=3Dand(Rs32,#s10)",ATTRIBS(A_ARCHV2), +"logical AND with immediate",{ fIMMEXT(siV); RdV=3DRsV&siV;}) + +Q6INSN(A2_orir,"Rd32=3Dor(Rs32,#s10)",ATTRIBS(A_ARCHV2), +"logical OR with immediate",{ fIMMEXT(siV); RdV=3DRsV|siV;}) + + + + +Q6INSN(A2_andp,"Rdd32=3Dand(Rss32,Rtt32)",ATTRIBS(), +"logical AND pair",{ RddV=3DRssV&RttV;}) + +Q6INSN(A2_orp,"Rdd32=3Dor(Rss32,Rtt32)",ATTRIBS(), +"logical OR pair",{ RddV=3DRssV|RttV;}) + +Q6INSN(A2_xorp,"Rdd32=3Dxor(Rss32,Rtt32)",ATTRIBS(), +"logical eXclusive OR pair",{ RddV=3DRssV^RttV;}) + +Q6INSN(A2_notp,"Rdd32=3Dnot(Rss32)",ATTRIBS(), +"logical NOT pair",{ RddV=3D~RssV;}) + +Q6INSN(A2_sxtw,"Rdd32=3Dsxtw(Rs32)",ATTRIBS(), +"Sign extend 32-bit word to 64-bit pair", +{ RddV =3D fCAST4_8s(RsV); }) + +Q6INSN(A2_sat,"Rd32=3Dsat(Rss32)",ATTRIBS(), +"Saturate to 32-bit Signed", +{ RdV =3D fSAT(RssV); }) + +Q6INSN(A2_roundsat,"Rd32=3Dround(Rss32):sat",ATTRIBS(), +"Round & Saturate to 32-bit Signed", +{ fHIDE(size8s_t tmp;) fADDSAT64(tmp,RssV,0x080000000ULL); RdV =3D fGETWOR= D(1,tmp); }) + +Q6INSN(A2_sath,"Rd32=3Dsath(Rs32)",ATTRIBS(), +"Saturate to 16-bit Signed", +{ RdV =3D fSATH(RsV); }) + +Q6INSN(A2_satuh,"Rd32=3Dsatuh(Rs32)",ATTRIBS(), +"Saturate to 16-bit Unsigned", +{ RdV =3D fSATUH(RsV); }) + +Q6INSN(A2_satub,"Rd32=3Dsatub(Rs32)",ATTRIBS(), +"Saturate to 8-bit Unsigned", +{ RdV =3D fSATUB(RsV); }) + +Q6INSN(A2_satb,"Rd32=3Dsatb(Rs32)",ATTRIBS(A_ARCHV2), +"Saturate to 8-bit Signed", +{ RdV =3D fSATB(RsV); }) + +/**********************************************/ +/* Vector Add */ +/**********************************************/ + +Q6INSN(A2_vaddub,"Rdd32=3Dvaddub(Rss32,Rtt32)",ATTRIBS(), +"Add vector of bytes", +{ + fHIDE(int i;) + for (i =3D 0; i < 8; i++) { + fSETBYTE(i,RddV,(fGETUBYTE(i,RssV)+fGETUBYTE(i,RttV))); + } +}) +DEF_MAPPING(A2_vaddb_map,"Rdd32=3Dvaddb(Rss32,Rtt32)","Rdd32=3Dvaddub(Rss3= 2,Rtt32)") + +Q6INSN(A2_vaddubs,"Rdd32=3Dvaddub(Rss32,Rtt32):sat",ATTRIBS(), +"Add vector of bytes", +{ + fHIDE(int i;) + for (i =3D 0; i < 8; i++) { + fSETBYTE(i,RddV,fSATUN(8,fGETUBYTE(i,RssV)+fGETUBYTE(i,RttV))); + } +}) + +Q6INSN(A2_vaddh,"Rdd32=3Dvaddh(Rss32,Rtt32)",ATTRIBS(), +"Add vector of half integers", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV,fGETHALF(i,RssV)+fGETHALF(i,RttV)); + } +}) + +Q6INSN(A2_vaddhs,"Rdd32=3Dvaddh(Rss32,Rtt32):sat",ATTRIBS(), +"Add vector of half integers with saturation", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV,fSATN(16,fGETHALF(i,RssV)+fGETHALF(i,RttV))); + } +}) + +Q6INSN(A2_vadduhs,"Rdd32=3Dvadduh(Rss32,Rtt32):sat",ATTRIBS(), +"Add vector of unsigned half integers with saturation", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV,fSATUN(16,fGETUHALF(i,RssV)+fGETUHALF(i,RttV))); + } +}) + +Q6INSN(A5_vaddhubs,"Rd32=3Dvaddhub(Rss32,Rtt32):sat",ATTRIBS(), +"Add vector of half integers with saturation and pack to unsigned bytes", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETBYTE(i,RdV,fSATUB(fGETHALF(i,RssV)+fGETHALF(i,RttV))); + } +}) + +Q6INSN(A2_vaddw,"Rdd32=3Dvaddw(Rss32,Rtt32)",ATTRIBS(), +"Add vector of words", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETWORD(i,RddV,fGETWORD(i,RssV)+fGETWORD(i,RttV)); + } +}) + +Q6INSN(A2_vaddws,"Rdd32=3Dvaddw(Rss32,Rtt32):sat",ATTRIBS(), +"Add vector of words with saturation", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETWORD(i,RddV,fSATN(32,fGETWORD(i,RssV)+fGETWORD(i,RttV))); + } +}) + + + +Q6INSN(S4_vxaddsubw,"Rdd32=3Dvxaddsubw(Rss32,Rtt32):sat",ATTRIBS(), +"Cross vector add-sub words with saturation", +{ + fSETWORD(0,RddV,fSAT(fGETWORD(0,RssV)+fGETWORD(1,RttV))); + fSETWORD(1,RddV,fSAT(fGETWORD(1,RssV)-fGETWORD(0,RttV))); +}) +Q6INSN(S4_vxsubaddw,"Rdd32=3Dvxsubaddw(Rss32,Rtt32):sat",ATTRIBS(), +"Cross vector sub-add words with saturation", +{ + fSETWORD(0,RddV,fSAT(fGETWORD(0,RssV)-fGETWORD(1,RttV))); + fSETWORD(1,RddV,fSAT(fGETWORD(1,RssV)+fGETWORD(0,RttV))); +}) + + + +Q6INSN(S4_vxaddsubh,"Rdd32=3Dvxaddsubh(Rss32,Rtt32):sat",ATTRIBS(), +"Cross vector add-sub halfwords with saturation", +{ + fSETHALF(0,RddV,fSATH(fGETHALF(0,RssV)+fGETHALF(1,RttV))); + fSETHALF(1,RddV,fSATH(fGETHALF(1,RssV)-fGETHALF(0,RttV))); + + fSETHALF(2,RddV,fSATH(fGETHALF(2,RssV)+fGETHALF(3,RttV))); + fSETHALF(3,RddV,fSATH(fGETHALF(3,RssV)-fGETHALF(2,RttV))); + +}) +Q6INSN(S4_vxsubaddh,"Rdd32=3Dvxsubaddh(Rss32,Rtt32):sat",ATTRIBS(), +"Cross vector sub-add halfwords with saturation", +{ + fSETHALF(0,RddV,fSATH(fGETHALF(0,RssV)-fGETHALF(1,RttV))); + fSETHALF(1,RddV,fSATH(fGETHALF(1,RssV)+fGETHALF(0,RttV))); + + fSETHALF(2,RddV,fSATH(fGETHALF(2,RssV)-fGETHALF(3,RttV))); + fSETHALF(3,RddV,fSATH(fGETHALF(3,RssV)+fGETHALF(2,RttV))); +}) + + + + +Q6INSN(S4_vxaddsubhr,"Rdd32=3Dvxaddsubh(Rss32,Rtt32):rnd:>>1:sat",ATTRIBS(= ), +"Cross vector add-sub halfwords with shift, round, and saturation", +{ + fSETHALF(0,RddV,fSATH((fGETHALF(0,RssV)+fGETHALF(1,RttV)+1)>>1)); + fSETHALF(1,RddV,fSATH((fGETHALF(1,RssV)-fGETHALF(0,RttV)+1)>>1)); + + fSETHALF(2,RddV,fSATH((fGETHALF(2,RssV)+fGETHALF(3,RttV)+1)>>1)); + fSETHALF(3,RddV,fSATH((fGETHALF(3,RssV)-fGETHALF(2,RttV)+1)>>1)); + +}) +Q6INSN(S4_vxsubaddhr,"Rdd32=3Dvxsubaddh(Rss32,Rtt32):rnd:>>1:sat",ATTRIBS(= ), +"Cross vector sub-add halfwords with shift, round, and saturation", +{ + fSETHALF(0,RddV,fSATH((fGETHALF(0,RssV)-fGETHALF(1,RttV)+1)>>1)); + fSETHALF(1,RddV,fSATH((fGETHALF(1,RssV)+fGETHALF(0,RttV)+1)>>1)); + + fSETHALF(2,RddV,fSATH((fGETHALF(2,RssV)-fGETHALF(3,RttV)+1)>>1)); + fSETHALF(3,RddV,fSATH((fGETHALF(3,RssV)+fGETHALF(2,RttV)+1)>>1)); +}) + + + + + +/**********************************************/ +/* 1/2 Vector operations */ +/**********************************************/ + + +Q6INSN(A2_svavgh,"Rd32=3Dvavgh(Rs32,Rt32)",ATTRIBS(A_ARCHV2), +"Avg vector of half integers", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETHALF(i,RdV,((fGETHALF(i,RsV)+fGETHALF(i,RtV))>>1)); + } +}) + +Q6INSN(A2_svavghs,"Rd32=3Dvavgh(Rs32,Rt32):rnd",ATTRIBS(A_ARCHV2), +"Avg vector of half integers with rounding", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETHALF(i,RdV,((fGETHALF(i,RsV)+fGETHALF(i,RtV)+1)>>1)); + } +}) + + + +Q6INSN(A2_svnavgh,"Rd32=3Dvnavgh(Rt32,Rs32)",ATTRIBS(A_ARCHV2), +"Avg vector of half integers", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETHALF(i,RdV,((fGETHALF(i,RtV)-fGETHALF(i,RsV))>>1)); + } +}) + + +Q6INSN(A2_svaddh,"Rd32=3Dvaddh(Rs32,Rt32)",ATTRIBS(), +"Add vector of half integers", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETHALF(i,RdV,fGETHALF(i,RsV)+fGETHALF(i,RtV)); + } +}) + +Q6INSN(A2_svaddhs,"Rd32=3Dvaddh(Rs32,Rt32):sat",ATTRIBS(), +"Add vector of half integers with saturation", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETHALF(i,RdV,fSATN(16,fGETHALF(i,RsV)+fGETHALF(i,RtV))); + } +}) + +Q6INSN(A2_svadduhs,"Rd32=3Dvadduh(Rs32,Rt32):sat",ATTRIBS(), +"Add vector of unsigned half integers with saturation", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETHALF(i,RdV,fSATUN(16,fGETUHALF(i,RsV)+fGETUHALF(i,RtV))); + } +}) + + +Q6INSN(A2_svsubh,"Rd32=3Dvsubh(Rt32,Rs32)",ATTRIBS(), +"Sub vector of half integers", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETHALF(i,RdV,fGETHALF(i,RtV)-fGETHALF(i,RsV)); + } +}) + +Q6INSN(A2_svsubhs,"Rd32=3Dvsubh(Rt32,Rs32):sat",ATTRIBS(), +"Sub vector of half integers with saturation", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETHALF(i,RdV,fSATN(16,fGETHALF(i,RtV)-fGETHALF(i,RsV))); + } +}) + +Q6INSN(A2_svsubuhs,"Rd32=3Dvsubuh(Rt32,Rs32):sat",ATTRIBS(), +"Sub vector of unsigned half integers with saturation", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETHALF(i,RdV,fSATUN(16,fGETUHALF(i,RtV)-fGETUHALF(i,RsV))); + } +}) + + + + +/**********************************************/ +/* Vector Reduce Add */ +/**********************************************/ + +Q6INSN(A2_vraddub,"Rdd32=3Dvraddub(Rss32,Rtt32)",ATTRIBS(), +"Sum: two vectors of unsigned bytes", +{ + fHIDE(int i;) + RddV =3D 0; + for (i=3D0;i<4;i++) { + fSETWORD(0,RddV,(fGETWORD(0,RddV) + (fGETUBYTE(i,RssV)+fGETUBYTE(i,RttV)= ))); + } + for (i=3D4;i<8;i++) { + fSETWORD(1,RddV,(fGETWORD(1,RddV) + (fGETUBYTE(i,RssV)+fGETUBYTE(i,RttV)= ))); + } +}) + +Q6INSN(A2_vraddub_acc,"Rxx32+=3Dvraddub(Rss32,Rtt32)",ATTRIBS(), +"Sum: two vectors of unsigned bytes", +{ + fHIDE(int i;) + for (i =3D 0; i < 4; i++) { + fSETWORD(0,RxxV,(fGETWORD(0,RxxV) + (fGETUBYTE(i,RssV)+fGETUBYTE(i,RttV)= ))); + } + for (i =3D 4; i < 8; i++) { + fSETWORD(1,RxxV,(fGETWORD(1,RxxV) + (fGETUBYTE(i,RssV)+fGETUBYTE(i,RttV)= ))); + } + fACC();\ +}) + + + +Q6INSN(M2_vraddh,"Rd32=3Dvraddh(Rss32,Rtt32)",ATTRIBS(A_ARCHV3), +"Sum: two vectors of halves", +{ + fHIDE(int i;) + RdV =3D 0; + for (i=3D0;i<4;i++) { + RdV +=3D (fGETHALF(i,RssV)+fGETHALF(i,RttV)); + } +}) + +Q6INSN(M2_vradduh,"Rd32=3Dvradduh(Rss32,Rtt32)",ATTRIBS(A_ARCHV3), +"Sum: two vectors of unsigned halves", +{ + fHIDE(int i;) + RdV =3D 0; + for (i=3D0;i<4;i++) { + RdV +=3D (fGETUHALF(i,RssV)+fGETUHALF(i,RttV)); + } +}) + +/**********************************************/ +/* Vector Sub */ +/**********************************************/ + +Q6INSN(A2_vsubub,"Rdd32=3Dvsubub(Rtt32,Rss32)",ATTRIBS(), +"Sub vector of bytes", +{ + fHIDE(int i;) + for (i =3D 0; i < 8; i++) { + fSETBYTE(i,RddV,(fGETUBYTE(i,RttV)-fGETUBYTE(i,RssV))); + } +}) +DEF_MAPPING(A2_vsubb_map,"Rdd32=3Dvsubb(Rss32,Rtt32)","Rdd32=3Dvsubub(Rss3= 2,Rtt32)") + +Q6INSN(A2_vsububs,"Rdd32=3Dvsubub(Rtt32,Rss32):sat",ATTRIBS(), +"Sub vector of bytes", +{ + fHIDE(int i;) + for (i =3D 0; i < 8; i++) { + fSETBYTE(i,RddV,fSATUN(8,fGETUBYTE(i,RttV)-fGETUBYTE(i,RssV))); + } +}) + +Q6INSN(A2_vsubh,"Rdd32=3Dvsubh(Rtt32,Rss32)",ATTRIBS(), +"Sub vector of half integers", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV,fGETHALF(i,RttV)-fGETHALF(i,RssV)); + } +}) + +Q6INSN(A2_vsubhs,"Rdd32=3Dvsubh(Rtt32,Rss32):sat",ATTRIBS(), +"Sub vector of half integers with saturation", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV,fSATN(16,fGETHALF(i,RttV)-fGETHALF(i,RssV))); + } +}) + +Q6INSN(A2_vsubuhs,"Rdd32=3Dvsubuh(Rtt32,Rss32):sat",ATTRIBS(), +"Sub vector of unsigned half integers with saturation", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV,fSATUN(16,fGETUHALF(i,RttV)-fGETUHALF(i,RssV))); + } +}) + +Q6INSN(A2_vsubw,"Rdd32=3Dvsubw(Rtt32,Rss32)",ATTRIBS(), +"Sub vector of words", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETWORD(i,RddV,fGETWORD(i,RttV)-fGETWORD(i,RssV)); + } +}) + +Q6INSN(A2_vsubws,"Rdd32=3Dvsubw(Rtt32,Rss32):sat",ATTRIBS(), +"Sub vector of words with saturation", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETWORD(i,RddV,fSATN(32,fGETWORD(i,RttV)-fGETWORD(i,RssV))); + } +}) + + + + +/**********************************************/ +/* Vector Abs */ +/**********************************************/ + +Q6INSN(A2_vabsh,"Rdd32=3Dvabsh(Rss32)",ATTRIBS(), +"Negate vector of half integers", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV,fABS(fGETHALF(i,RssV))); + } +}) + +Q6INSN(A2_vabshsat,"Rdd32=3Dvabsh(Rss32):sat",ATTRIBS(), +"Negate vector of half integers", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV,fSATH(fABS(fGETHALF(i,RssV)))); + } +}) + +Q6INSN(A2_vabsw,"Rdd32=3Dvabsw(Rss32)",ATTRIBS(), +"Absolute Value vector of words", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETWORD(i,RddV,fABS(fGETWORD(i,RssV))); + } +}) + +Q6INSN(A2_vabswsat,"Rdd32=3Dvabsw(Rss32):sat",ATTRIBS(), +"Absolute Value vector of words", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETWORD(i,RddV,fSAT(fABS(fGETWORD(i,RssV)))); + } +}) + +/**********************************************/ +/* Vector SAD */ +/**********************************************/ + + +Q6INSN(M2_vabsdiffw,"Rdd32=3Dvabsdiffw(Rtt32,Rss32)",ATTRIBS(A_ARCHV2), +"Absolute Differences: vector of words", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETWORD(i,RddV,fABS(fGETWORD(i,RttV) - fGETWORD(i,RssV))); + } +}) + +Q6INSN(M2_vabsdiffh,"Rdd32=3Dvabsdiffh(Rtt32,Rss32)",ATTRIBS(A_ARCHV2), +"Absolute Differences: vector of halfwords", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV,fABS(fGETHALF(i,RttV) - fGETHALF(i,RssV))); + } +}) + +Q6INSN(M6_vabsdiffb,"Rdd32=3Dvabsdiffb(Rtt32,Rss32)",ATTRIBS(), +"Absolute Differences: vector of halfwords", +{ + fHIDE(int i;) + for (i=3D0;i<8;i++) { + fSETBYTE(i,RddV,fABS(fGETBYTE(i,RttV) - fGETBYTE(i,RssV))); + } +}) + +Q6INSN(M6_vabsdiffub,"Rdd32=3Dvabsdiffub(Rtt32,Rss32)",ATTRIBS(), +"Absolute Differences: vector of halfwords", +{ + fHIDE(int i;) + for (i=3D0;i<8;i++) { + fSETBYTE(i,RddV,fABS(fGETUBYTE(i,RttV) - fGETUBYTE(i,RssV))); + } +}) + + + +Q6INSN(A2_vrsadub,"Rdd32=3Dvrsadub(Rss32,Rtt32)",ATTRIBS(), +"Sum of Absolute Differences: vector of unsigned bytes", +{ + fHIDE(int i;) + RddV =3D 0; + for (i =3D 0; i < 4; i++) { + fSETWORD(0,RddV,(fGETWORD(0,RddV) + fABS((fGETUBYTE(i,RssV) - fGETUBYTE(= i,RttV))))); + } + for (i =3D 4; i < 8; i++) { + fSETWORD(1,RddV,(fGETWORD(1,RddV) + fABS((fGETUBYTE(i,RssV) - fGETUBYTE(= i,RttV))))); + } +}) + +Q6INSN(A2_vrsadub_acc,"Rxx32+=3Dvrsadub(Rss32,Rtt32)",ATTRIBS(), +"Sum of Absolute Differences: vector of unsigned bytes", +{ + fHIDE(int i;) + for (i =3D 0; i < 4; i++) { + fSETWORD(0,RxxV,(fGETWORD(0,RxxV) + fABS((fGETUBYTE(i,RssV) - fGETUBYTE(= i,RttV))))); + } + for (i =3D 4; i < 8; i++) { + fSETWORD(1,RxxV,(fGETWORD(1,RxxV) + fABS((fGETUBYTE(i,RssV) - fGETUBYTE(= i,RttV))))); + } + fACC();\ +}) + + +/**********************************************/ +/* Vector Average */ +/**********************************************/ + +Q6INSN(A2_vavgub,"Rdd32=3Dvavgub(Rss32,Rtt32)",ATTRIBS(), +"Average vector of unsigned bytes", +{ + fHIDE(int i;) + for (i =3D 0; i < 8; i++) { + fSETBYTE(i,RddV,((fGETUBYTE(i,RssV) + fGETUBYTE(i,RttV))>>1)); + } +}) + +Q6INSN(A2_vavguh,"Rdd32=3Dvavguh(Rss32,Rtt32)",ATTRIBS(), +"Average vector of unsigned halfwords", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV,(fGETUHALF(i,RssV)+fGETUHALF(i,RttV))>>1); + } +}) + +Q6INSN(A2_vavgh,"Rdd32=3Dvavgh(Rss32,Rtt32)",ATTRIBS(), +"Average vector of halfwords", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV,(fGETHALF(i,RssV)+fGETHALF(i,RttV))>>1); + } +}) + +Q6INSN(A2_vnavgh,"Rdd32=3Dvnavgh(Rtt32,Rss32)",ATTRIBS(), +"Negative Average vector of halfwords", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV,(fGETHALF(i,RttV)-fGETHALF(i,RssV))>>1); + } +}) + +Q6INSN(A2_vavgw,"Rdd32=3Dvavgw(Rss32,Rtt32)",ATTRIBS(), +"Average vector of words", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETWORD(i,RddV,(fSXTN(32,33,fGETWORD(i,RssV))+fSXTN(32,33,fGETWORD(i,Rt= tV)))>>1); + } +}) + +Q6INSN(A2_vnavgw,"Rdd32=3Dvnavgw(Rtt32,Rss32)",ATTRIBS(A_ARCHV2), +"Average vector of words", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETWORD(i,RddV,(fSXTN(32,33,fGETWORD(i,RttV))-fSXTN(32,33,fGETWORD(i,Rs= sV)))>>1); + } +}) + +Q6INSN(A2_vavgwr,"Rdd32=3Dvavgw(Rss32,Rtt32):rnd",ATTRIBS(), +"Average vector of words", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETWORD(i,RddV,(fSXTN(32,33,fGETWORD(i,RssV))+fSXTN(32,33,fGETWORD(i,Rt= tV))+1)>>1); + } +}) + +Q6INSN(A2_vnavgwr,"Rdd32=3Dvnavgw(Rtt32,Rss32):rnd:sat",ATTRIBS(A_ARCHV2), +"Average vector of words", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETWORD(i,RddV,fSAT((fSXTN(32,33,fGETWORD(i,RttV))-fSXTN(32,33,fGETWORD= (i,RssV))+1)>>1)); + } +}) + +Q6INSN(A2_vavgwcr,"Rdd32=3Dvavgw(Rss32,Rtt32):crnd",ATTRIBS(A_ARCHV2), +"Average vector of words with convergent rounding", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETWORD(i,RddV,(fCRND(fSXTN(32,33,fGETWORD(i,RssV))+fSXTN(32,33,fGETWOR= D(i,RttV)))>>1)); + } +}) + +Q6INSN(A2_vnavgwcr,"Rdd32=3Dvnavgw(Rtt32,Rss32):crnd:sat",ATTRIBS(A_ARCHV2= ), +"Average negative vector of words with convergent rounding", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETWORD(i,RddV,fSAT(fCRND(fSXTN(32,33,fGETWORD(i,RttV))-fSXTN(32,33,fGE= TWORD(i,RssV)))>>1)); + } +}) + +Q6INSN(A2_vavghcr,"Rdd32=3Dvavgh(Rss32,Rtt32):crnd",ATTRIBS(A_ARCHV2), +"Average vector of halfwords with conv rounding", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV,fCRND(fGETHALF(i,RssV)+fGETHALF(i,RttV))>>1); + } +}) + +Q6INSN(A2_vnavghcr,"Rdd32=3Dvnavgh(Rtt32,Rss32):crnd:sat",ATTRIBS(A_ARCHV2= ), +"Average negative vector of halfwords with conv rounding", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV,fSATH(fCRND(fGETHALF(i,RttV)-fGETHALF(i,RssV))>>1)); + } +}) + + +Q6INSN(A2_vavguw,"Rdd32=3Dvavguw(Rss32,Rtt32)",ATTRIBS(), +"Average vector of unsigned words", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETWORD(i,RddV,(fZXTN(32,33,fGETUWORD(i,RssV))+fZXTN(32,33,fGETUWORD(i,= RttV)))>>1); + } +}) + +Q6INSN(A2_vavguwr,"Rdd32=3Dvavguw(Rss32,Rtt32):rnd",ATTRIBS(), +"Average vector of unsigned words", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETWORD(i,RddV,(fZXTN(32,33,fGETUWORD(i,RssV))+fZXTN(32,33,fGETUWORD(i,= RttV))+1)>>1); + } +}) + +Q6INSN(A2_vavgubr,"Rdd32=3Dvavgub(Rss32,Rtt32):rnd",ATTRIBS(), +"Average vector of unsigned bytes", +{ + fHIDE(int i;) + for (i =3D 0; i < 8; i++) { + fSETBYTE(i,RddV,((fGETUBYTE(i,RssV)+fGETUBYTE(i,RttV)+1)>>1)); + } +}) + +Q6INSN(A2_vavguhr,"Rdd32=3Dvavguh(Rss32,Rtt32):rnd",ATTRIBS(), +"Average vector of unsigned halfwords with rounding", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV,(fGETUHALF(i,RssV)+fGETUHALF(i,RttV)+1)>>1); + } +}) + +Q6INSN(A2_vavghr,"Rdd32=3Dvavgh(Rss32,Rtt32):rnd",ATTRIBS(), +"Average vector of halfwords with rounding", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV,(fGETHALF(i,RssV)+fGETHALF(i,RttV)+1)>>1); + } +}) + +Q6INSN(A2_vnavghr,"Rdd32=3Dvnavgh(Rtt32,Rss32):rnd:sat",ATTRIBS(A_ARCHV2), +"Negative Average vector of halfwords with rounding", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV,fSATH((fGETHALF(i,RttV)-fGETHALF(i,RssV)+1)>>1)); + } +}) + + +/* Rounding Instruction */ + +Q6INSN(A4_round_ri,"Rd32=3Dround(Rs32,#u5)",ATTRIBS(),"Round", {RdV =3D fR= NDN(RsV,uiV)>>uiV; }) +Q6INSN(A4_round_rr,"Rd32=3Dround(Rs32,Rt32)",ATTRIBS(),"Round", {RdV =3D f= RNDN(RsV,fZXTN(5,32,RtV))>>fZXTN(5,32,RtV); }) +Q6INSN(A4_round_ri_sat,"Rd32=3Dround(Rs32,#u5):sat",ATTRIBS(),"Round", {Rd= V =3D (fSAT(fRNDN(RsV,uiV)))>>uiV; }) +Q6INSN(A4_round_rr_sat,"Rd32=3Dround(Rs32,Rt32):sat",ATTRIBS(),"Round", {R= dV =3D (fSAT(fRNDN(RsV,fZXTN(5,32,RtV))))>>fZXTN(5,32,RtV); }) + + +Q6INSN(A4_cround_ri,"Rd32=3Dcround(Rs32,#u5)",ATTRIBS(),"Convergent Round"= , {RdV =3D fCRNDN(RsV,uiV); }) +Q6INSN(A4_cround_rr,"Rd32=3Dcround(Rs32,Rt32)",ATTRIBS(),"Convergent Round= ", {RdV =3D fCRNDN(RsV,fZXTN(5,32,RtV)); }) + + +#define CROUND(DST,SRC,SHIFT) \ + fHIDE(size16s_t rndbit_128;)\ + fHIDE(size16s_t tmp128;)\ + fHIDE(size16s_t src_128;)\ + if (SHIFT =3D=3D 0) { \ + DST =3D SRC;\ + } else if ((SRC & (size8s_t)((1LL << (SHIFT - 1)) - 1LL)) =3D=3D 0) { \ + src_128 =3D fCAST8S_16S(SRC);\ + rndbit_128 =3D fCAST8S_16S(1LL);\ + rndbit_128 =3D fSHIFTL128(rndbit_128, SHIFT);\ + rndbit_128 =3D fAND128(rndbit_128, src_128);\ + rndbit_128 =3D fSHIFTR128(rndbit_128, 1);\ + tmp128 =3D fADD128(src_128, rndbit_128);\ + tmp128 =3D fSHIFTR128(tmp128, SHIFT);\ + DST =3D fCAST16S_8S(tmp128);\ + } else {\ + size16s_t rndbit_128 =3D fCAST8S_16S((1LL << (SHIFT - 1))); \ + size16s_t src_128 =3D fCAST8S_16S(SRC); \ + size16s_t tmp128 =3D fADD128(src_128, rndbit_128);\ + tmp128 =3D fSHIFTR128(tmp128, SHIFT);\ + DST =3D fCAST16S_8S(tmp128);\ + } + +Q6INSN(A7_croundd_ri,"Rdd32=3Dcround(Rss32,#u6)",ATTRIBS(),"Convergent Rou= nd", +{ +CROUND(RddV,RssV,uiV); +fEXTENSION_AUDIO();}) + +Q6INSN(A7_croundd_rr,"Rdd32=3Dcround(Rss32,Rt32)",ATTRIBS(),"Convergent Ro= und", +{ +CROUND(RddV,RssV,fZXTN(6,32,RtV)); +fEXTENSION_AUDIO();}) + + + + + + + + + +Q6INSN(A7_clip,"Rd32=3Dclip(Rs32,#u5)",ATTRIBS(),"Clip to #s5", { fCLI= P(RdV,RsV,uiV); fEXTENSION_AUDIO();}) +Q6INSN(A7_vclip,"Rdd32=3Dvclip(Rss32,#u5)",ATTRIBS(),"Clip to #s5", +{ +fHIDE(size4s_t tmp;) +fCLIP(tmp, fGETWORD(0, RssV), uiV); +fSETWORD(0, RddV, tmp); +fCLIP(tmp,fGETWORD(1, RssV), uiV); +fSETWORD(1, RddV, tmp); +fEXTENSION_AUDIO(); +} +) + + + +/**********************************************/ +/* V4: Cross Vector Min/Max */ +/**********************************************/ + + +#define VRMINORMAX(TAG,STR,OP,SHORTTYPE,SETTYPE,GETTYPE,NEL,SHIFT) \ +Q6INSN(A4_vr##TAG##SHORTTYPE,"Rxx32=3Dvr"#TAG#SHORTTYPE"(Rss32,Ru32)",ATTR= IBS(), \ +"Choose " STR " elements of a vector", \ +{ \ + fHIDE(int i; size8s_t TAG; size4s_t addr;) \ + TAG =3D fGET##GETTYPE(0,RxxV); \ + addr =3D fGETWORD(1,RxxV); \ + for (i =3D 0; i < NEL; i++) { \ + if (TAG OP fGET##GETTYPE(i,RssV)) { \ + TAG =3D fGET##GETTYPE(i,RssV); \ + addr =3D RuV | i<,SHORTTYPE,SETTYPE,GETTYPE,NEL,SHIFT) \ +VRMINORMAX(max,"maximum",<,SHORTTYPE,SETTYPE,GETTYPE,NEL,SHIFT) + + +RMINMAX(h,HALF,HALF,4,1) +RMINMAX(uh,HALF,UHALF,4,1) +RMINMAX(w,WORD,WORD,2,2) +RMINMAX(uw,WORD,UWORD,2,2) + +#undef RMINMAX +#undef VRMINORMAX + +/**********************************************/ +/* Vector Min/Max */ +/**********************************************/ + +#define VMINORMAX(TAG,STR,FUNC,SHORTTYPE,SETTYPE,GETTYPE,NEL) \ +Q6INSN(A2_v##TAG##SHORTTYPE,"Rdd32=3Dv"#TAG#SHORTTYPE"(Rtt32,Rss32)",ATTRI= BS(), \ +"Choose " STR " elements of two vectors", \ +{ \ + fHIDE(int i;) \ + for (i =3D 0; i < NEL; i++) { \ + fSET##SETTYPE(i,RddV,FUNC(fGET##GETTYPE(i,RttV),fGET##GETTYPE(i,RssV)));= \ + } \ +}) + +#define VMINORMAX3(TAG,STR,FUNC,SHORTTYPE,SETTYPE,GETTYPE,NEL) \ +Q6INSN(A6_v##TAG##SHORTTYPE##3,"Rxx32=3Dv"#TAG#SHORTTYPE"3(Rtt32,Rss32)",A= TTRIBS(), \ +"Choose " STR " elements of two vectors", \ +{ \ + fHIDE(int i;) \ + for (i =3D 0; i < NEL; i++) { \ + fSET##SETTYPE(i,RxxV,FUNC(fGET##GETTYPE(i,RxxV),FUNC(fGET##GETTYPE(i,Rtt= V),fGET##GETTYPE(i,RssV)))); \ + } \ +}) + +#define MINMAX(SHORTTYPE,SETTYPE,GETTYPE,NEL) \ +VMINORMAX(min,"minimum",fMIN,SHORTTYPE,SETTYPE,GETTYPE,NEL) \ +VMINORMAX(max,"maximum",fMAX,SHORTTYPE,SETTYPE,GETTYPE,NEL) + +MINMAX(b,BYTE,BYTE,8) +MINMAX(ub,BYTE,UBYTE,8) +MINMAX(h,HALF,HALF,4) +MINMAX(uh,HALF,UHALF,4) +MINMAX(w,WORD,WORD,2) +MINMAX(uw,WORD,UWORD,2) + +#undef MINMAX +#undef VMINORMAX +#undef VMINORMAX3 + + +Q6INSN(A5_ACS,"Rxx32,Pe4=3Dvacsh(Rss32,Rtt32)",ATTRIBS(A_NOTE_LATEPRED,A_R= ESTRICT_LATEPRED), +"Add Compare and Select elements of two vectors, record the maximums and t= he decisions ", +{ + fHIDE(int i;) + fHIDE(int xv;) + fHIDE(int sv;) + fHIDE(int tv;) + for (i =3D 0; i < 4; i++) { + xv =3D (int) fGETHALF(i,RxxV); + sv =3D (int) fGETHALF(i,RssV); + tv =3D (int) fGETHALF(i,RttV); + xv =3D xv + tv; //assumes 17bit datapath + sv =3D sv - tv; //assumes 17bit datapath + fSETBIT(i*2, PeV, (xv > sv)); + fSETBIT(i*2+1,PeV, (xv > sv)); + fSETHALF(i, RxxV, fSATH(fMAX(xv,sv))); + } +}) + +Q6INSN(A6_vminub_RdP,"Rdd32,Pe4=3Dvminub(Rtt32,Rss32)",ATTRIBS(A_NOTE_LATE= PRED,A_RESTRICT_LATEPRED), +"Vector minimum of bytes, records minimum and decision vector", +{ + fHIDE(int i;) + for (i =3D 0; i < 8; i++) { + fSETBIT(i, PeV, (fGETUBYTE(i,RttV) > fGETUBYTE(i,RssV))); + fSETBYTE(i,RddV,fMIN(fGETUBYTE(i,RttV),fGETUBYTE(i,RssV))); + } +}) + +/**********************************************/ +/* Vector Min/Max */ +/**********************************************/ + + +Q6INSN(A4_modwrapu,"Rd32=3Dmodwrap(Rs32,Rt32)",ATTRIBS(), +"Wrap to an unsigned modulo buffer", +{ + if (RsV < 0) { + RdV =3D RsV + fCAST4u(RtV); + } else if (fCAST4u(RsV) >=3D fCAST4u(RtV)) { + RdV =3D RsV - fCAST4u(RtV); + } else { + RdV =3D RsV; + } +}) + diff --git a/target/hexagon/imported/branch.idef b/target/hexagon/imported/= branch.idef new file mode 100644 index 0000000..ed066f6 --- /dev/null +++ b/target/hexagon/imported/branch.idef @@ -0,0 +1,344 @@ +/* + * Copyright(c) 2019-2020 Qualcomm Innovation Center, Inc. All Rights Res= erved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + + +/*********************************************/ +/* Jump instructions */ +/*********************************************/ + +#define A_COFSTD A_RESTRICT_LOOP_LA,A_RESTRICT_COF_MAX1 +#define A_JDIR A_JUMP,A_DIRECT,A_COFSTD,A_BRANCHADDER +#define A_CJNEWDIR A_JUMP,A_DIRECT,A_CJUMP,A_COFSTD,A_BRANCHADDER,A_DOTNEW= ,A_ROPS_2 +#define A_CJOLDDIR A_JUMP,A_DIRECT,A_CJUMP,A_COFSTD,A_BRANCHADDER,A_DOTOLD +#define A_NEWVALUEJ A_JUMP,A_DIRECT,A_CJUMP,A_COFSTD,A_BRANCHADDER,A_RESTR= ICT_COF_MAX1,A_DOTNEWVALUE,A_MEMLIKE_PACKET_RULES,A_RESTRICT_SINGLE_MEM_FIR= ST,A_ROPS_2 +#define A_JINDIR A_JUMP,A_INDIRECT,A_COFSTD +#define A_JINDIRNEW A_JUMP,A_INDIRECT,A_COFSTD,A_CJUMP,A_DOTNEW +#define A_JINDIROLD A_JUMP,A_INDIRECT,A_COFSTD,A_CJUMP,A_DOTOLD + +#define A_RELAX_COND A_RESTRICT_COF_MAX1,A_RELAX_COF_2ND,A_RELAX_COF_1ST +#define A_RELAX_UNC A_RESTRICT_COF_MAX1,A_RELAX_COF_2ND + +Q6INSN(J2_jump,"jump #r22:2",ATTRIBS(A_JDIR,A_RELAX_UNC), "direct uncondit= ional jump", +{fIMMEXT(riV); fPCALIGN(riV); fBRANCH(fREAD_PC()+riV,COF_TYPE_JUMP);}) + +Q6INSN(J2_jumpr,"jumpr Rs32",ATTRIBS(A_JINDIR), "indirect unconditional ju= mp", +{fJUMPR(RsN,RsV,COF_TYPE_JUMPR);}) + +#define OLDCOND_JUMP(TAG,OPER,OPER2,ATTRIB,DESCR,SEMANTICS) \ +Q6INSN(TAG##t,"if (Pu4) "OPER":nt "OPER2,ATTRIB,DESCR,{fBRANCH_SPECULATE_S= TALL(fLSBOLD(PuV),,SPECULATE_NOT_TAKEN,12,0); if (fLSBOLD(PuV)) { SEMANTICS= ; }}) \ +Q6INSN(TAG##f,"if (!Pu4) "OPER":nt "OPER2,ATTRIB,DESCR,{fBRANCH_SPECULATE_= STALL(fLSBOLDNOT(PuV),,SPECULATE_NOT_TAKEN,12,0); if (fLSBOLDNOT(PuV)) { SE= MANTICS; }}) \ +Q6INSN(TAG##tpt,"if (Pu4) "OPER":t "OPER2,ATTRIB,DESCR,{fBRANCH_SPECULATE_= STALL(fLSBOLD(PuV),,SPECULATE_TAKEN,12,0); if (fLSBOLD(PuV)) { SEMANTICS; }= }) \ +Q6INSN(TAG##fpt,"if (!Pu4) "OPER":t "OPER2,ATTRIB,DESCR,{fBRANCH_SPECULATE= _STALL(fLSBOLDNOT(PuV),,SPECULATE_TAKEN,12,0); if (fLSBOLDNOT(PuV)) { SEMAN= TICS; }}) \ +DEF_MAPPING(TAG##t_nopred_map,"if (Pu4) "OPER" "OPER2,"if (Pu4) "OPER":nt = "OPER2) \ +DEF_MAPPING(TAG##f_nopred_map,"if (!Pu4) "OPER" "OPER2,"if (!Pu4) "OPER":n= t "OPER2) + +OLDCOND_JUMP(J2_jump,"jump","#r15:2",ATTRIBS(A_CJOLDDIR,A_NOTE_CONDITIONAL= ,A_RELAX_COND,A_PRED_BIT_12),"direct conditional jump", +fIMMEXT(riV);fPCALIGN(riV); fBRANCH(fREAD_PC()+riV,COF_TYPE_JUMP);) + +OLDCOND_JUMP(J2_jumpr,"jumpr","Rs32",ATTRIBS(A_JINDIROLD,A_NOTE_CONDITIONA= L,A_PRED_BIT_12),"indirect conditional jump", +fJUMPR(RsN,RsV,COF_TYPE_JUMPR);) + +#define NEWCOND_JUMP(TAG,OPER,OPER2,ATTRIB,DESCR,SEMANTICS)\ +Q6INSN(TAG##tnew,"if (Pu4.new) "OPER":nt "OPER2,ATTRIB,DESCR,{fBRANCH_SPEC= ULATE_STALL(fLSBNEW(PuN),, SPECULATE_NOT_TAKEN , 12,0)} {if(fLSBNEW(PuN)){S= EMANTICS;}})\ +Q6INSN(TAG##fnew,"if (!Pu4.new) "OPER":nt "OPER2,ATTRIB,DESCR,{fBRANCH_SPE= CULATE_STALL(fLSBNEWNOT(PuN),, SPECULATE_NOT_TAKEN , 12,0)} {if(fLSBNEWNOT(= PuN)){SEMANTICS;}})\ +Q6INSN(TAG##tnewpt,"if (Pu4.new) "OPER":t "OPER2,ATTRIB,DESCR,{fBRANCH_SPE= CULATE_STALL(fLSBNEW(PuN),, SPECULATE_TAKEN , 12,0)} {if(fLSBNEW(PuN)){SEMA= NTICS;}})\ +Q6INSN(TAG##fnewpt,"if (!Pu4.new) "OPER":t "OPER2,ATTRIB,DESCR,{fBRANCH_SP= ECULATE_STALL(fLSBNEWNOT(PuN),, SPECULATE_TAKEN , 12,0)} {if(fLSBNEWNOT(PuN= )){SEMANTICS;}}) + +NEWCOND_JUMP(J2_jump,"jump","#r15:2",ATTRIBS(A_CJNEWDIR,A_NOTE_CONDITIONAL= ,A_ARCHV2,A_RELAX_COND,A_PRED_BIT_12),"direct conditional jump", +fIMMEXT(riV); fPCALIGN(riV); fBRANCH(fREAD_PC()+riV,COF_TYPE_JUMPNEW);) + +NEWCOND_JUMP(J2_jumpr,"jumpr","Rs32",ATTRIBS(A_JINDIRNEW,A_NOTE_CONDITIONA= L,A_ARCHV3,A_PRED_BIT_12),"indirect conditional jump", +fJUMPR(RsN,RsV,COF_TYPE_JUMPR);) + + + +Q6INSN(J4_hintjumpr,"hintjr(Rs32)",ATTRIBS(A_JINDIR,A_HINTJR),"hint indire= ct conditional jump", +{fHINTJR(RsV);}) + + +/*********************************************/ +/* Compound Compare-Jumps */ +/*********************************************/ +Q6INSN(J2_jumprz,"if (Rs32!=3D#0) jump:nt #r13:2",ATTRIBS(A_NOTE_DEPRECATE= D,A_CJNEWDIR,A_ARCHV3,A_RELAX_COND,A_PRED_BIT_12),"direct conditional jump = if register true", +{fBRANCH_SPECULATE_STALL((RsV!=3D0), , SPECULATE_NOT_TAKEN,12,0) if (RsV != =3D 0) { fBRANCH(fREAD_PC()+riV,COF_TYPE_JUMP);}}) + +Q6INSN(J2_jumprnz,"if (Rs32=3D=3D#0) jump:nt #r13:2",ATTRIBS(A_NOTE_DEPREC= ATED,A_CJNEWDIR,A_ARCHV3,A_RELAX_COND,A_PRED_BIT_12),"direct conditional ju= mp if register false", +{fBRANCH_SPECULATE_STALL((RsV=3D=3D0), , SPECULATE_NOT_TAKEN,12,0) if (RsV= =3D=3D 0) {fBRANCH(fREAD_PC()+riV,COF_TYPE_JUMP);}}) + +Q6INSN(J2_jumprzpt,"if (Rs32!=3D#0) jump:t #r13:2",ATTRIBS(A_NOTE_DEPRECAT= ED,A_CJNEWDIR,A_ARCHV3,A_RELAX_COND,A_PRED_BIT_12),"direct conditional jump= if register true", +{fBRANCH_SPECULATE_STALL((RsV!=3D0), , SPECULATE_TAKEN,12,0) if (RsV !=3D = 0) { fBRANCH(fREAD_PC()+riV,COF_TYPE_JUMP);}}) + +Q6INSN(J2_jumprnzpt,"if (Rs32=3D=3D#0) jump:t #r13:2",ATTRIBS(A_NOTE_DEPRE= CATED,A_CJNEWDIR,A_ARCHV3,A_RELAX_COND,A_PRED_BIT_12),"direct conditional j= ump if register false", +{fBRANCH_SPECULATE_STALL((RsV=3D=3D0), , SPECULATE_TAKEN,12,0) if (RsV =3D= =3D 0) {fBRANCH(fREAD_PC()+riV,COF_TYPE_JUMP);}}) + +Q6INSN(J2_jumprgtez,"if (Rs32>=3D#0) jump:nt #r13:2",ATTRIBS(A_NOTE_DEPREC= ATED,A_CJNEWDIR,A_ARCHV3,A_RELAX_COND,A_PRED_BIT_12),"direct conditional ju= mp if register greater or equal to zero", +{fBRANCH_SPECULATE_STALL((RsV>=3D0), , SPECULATE_NOT_TAKEN,12,0) if (RsV>= =3D0) { fBRANCH(fREAD_PC()+riV,COF_TYPE_JUMP);}}) + +Q6INSN(J2_jumprgtezpt,"if (Rs32>=3D#0) jump:t #r13:2",ATTRIBS(A_NOTE_DEPRE= CATED,A_CJNEWDIR,A_ARCHV3,A_RELAX_COND,A_PRED_BIT_12),"direct conditional j= ump if register greater or equal to zero", +{fBRANCH_SPECULATE_STALL((RsV>=3D0), , SPECULATE_TAKEN,12,0) if (RsV>=3D0)= { fBRANCH(fREAD_PC()+riV,COF_TYPE_JUMP);}}) + +Q6INSN(J2_jumprltez,"if (Rs32<=3D#0) jump:nt #r13:2",ATTRIBS(A_NOTE_DEPREC= ATED,A_CJNEWDIR,A_ARCHV3,A_RELAX_COND,A_PRED_BIT_12),"direct conditional ju= mp if register less than or equal to zero", +{fBRANCH_SPECULATE_STALL((RsV<=3D0), , SPECULATE_NOT_TAKEN,12,0) if (RsV<= =3D0) { fBRANCH(fREAD_PC()+riV,COF_TYPE_JUMP);}}) + +Q6INSN(J2_jumprltezpt,"if (Rs32<=3D#0) jump:t #r13:2",ATTRIBS(A_NOTE_DEPRE= CATED,A_CJNEWDIR,A_ARCHV3,A_RELAX_COND,A_PRED_BIT_12),"direct conditional j= ump if register less than or equal to zero", +{fBRANCH_SPECULATE_STALL((RsV<=3D0), , SPECULATE_TAKEN,12,0) if (RsV<=3D0)= { fBRANCH(fREAD_PC()+riV,COF_TYPE_JUMP);}}) + + + +/*********************************************/ +/* V4 Compound Compare-Jumps */ +/*********************************************/ + + +/* V4 compound compare jumps (CJ) */ +#define STD_CMPJUMP(TAG,TST,TSTSEM)\ +Q6INSN(J4_##TAG##_tp0_jump_nt, "p0=3D"TST"; if (p0.new) jump:nt #r9:2", AT= TRIBS(A_CJNEWDIR,A_RELAX_COND,A_NEWCMPJUMP,A_PRED_BIT_13),"compound compare= -jump", {fPART1(fWRITE_P0(f8BITSOF(TSTSEM))) fBRANCH_SPECULATE_STALL(fLSBN= EW0,,SPECULATE_NOT_TAKEN,13,0) if (fLSBNEW0) {fIMMEXT(riV); fPCALIGN(riV);= fBRANCH(fREAD_PC()+riV,COF_TYPE_JUMP);}})\ +Q6INSN(J4_##TAG##_fp0_jump_nt, "p0=3D"TST"; if (!p0.new) jump:nt #r9:2", A= TTRIBS(A_CJNEWDIR,A_RELAX_COND,A_NEWCMPJUMP,A_PRED_BIT_13),"compound compar= e-jump",{fPART1(fWRITE_P0(f8BITSOF(TSTSEM))) fBRANCH_SPECULATE_STALL(fLSBN= EW0NOT,,SPECULATE_NOT_TAKEN,13,0) if (fLSBNEW0NOT) {fIMMEXT(riV); fPCALIGN(= riV); fBRANCH(fREAD_PC()+riV,COF_TYPE_JUMP);}})\ +Q6INSN(J4_##TAG##_tp0_jump_t, "p0=3D"TST"; if (p0.new) jump:t #r9:2", ATT= RIBS(A_CJNEWDIR,A_RELAX_COND,A_NEWCMPJUMP,A_PRED_BIT_13),"compound compare-= jump", {fPART1(fWRITE_P0(f8BITSOF(TSTSEM))) fBRANCH_SPECULATE_STALL(fLSBN= EW0,,SPECULATE_TAKEN,13,0) if (fLSBNEW0) {fIMMEXT(riV); fPCALIGN(riV);= fBRANCH(fREAD_PC()+riV,COF_TYPE_JUMP);}})\ +Q6INSN(J4_##TAG##_fp0_jump_t, "p0=3D"TST"; if (!p0.new) jump:t #r9:2", AT= TRIBS(A_CJNEWDIR,A_RELAX_COND,A_NEWCMPJUMP,A_PRED_BIT_13),"compound compare= -jump", {fPART1(fWRITE_P0(f8BITSOF(TSTSEM))) fBRANCH_SPECULATE_STALL(fLSBN= EW0NOT,,SPECULATE_TAKEN,13,0) if (fLSBNEW0NOT) {fIMMEXT(riV); fPCALIGN(= riV); fBRANCH(fREAD_PC()+riV,COF_TYPE_JUMP);}})\ +Q6INSN(J4_##TAG##_tp1_jump_nt, "p1=3D"TST"; if (p1.new) jump:nt #r9:2", AT= TRIBS(A_CJNEWDIR,A_RELAX_COND,A_NEWCMPJUMP,A_PRED_BIT_13),"compound compare= -jump", {fPART1(fWRITE_P1(f8BITSOF(TSTSEM))) fBRANCH_SPECULATE_STALL(fLSBN= EW1,,SPECULATE_NOT_TAKEN,13,0) if (fLSBNEW1) {fIMMEXT(riV); fPCALIGN(riV);= fBRANCH(fREAD_PC()+riV,COF_TYPE_JUMP);}})\ +Q6INSN(J4_##TAG##_fp1_jump_nt, "p1=3D"TST"; if (!p1.new) jump:nt #r9:2", A= TTRIBS(A_CJNEWDIR,A_RELAX_COND,A_NEWCMPJUMP,A_PRED_BIT_13),"compound compar= e-jump",{fPART1(fWRITE_P1(f8BITSOF(TSTSEM))) fBRANCH_SPECULATE_STALL(fLSBN= EW1NOT,,SPECULATE_NOT_TAKEN,13,0) if (fLSBNEW1NOT) {fIMMEXT(riV); fPCALIGN(= riV); fBRANCH(fREAD_PC()+riV,COF_TYPE_JUMP);}})\ +Q6INSN(J4_##TAG##_tp1_jump_t, "p1=3D"TST"; if (p1.new) jump:t #r9:2", ATT= RIBS(A_CJNEWDIR,A_RELAX_COND,A_NEWCMPJUMP,A_PRED_BIT_13),"compound compare-= jump", {fPART1(fWRITE_P1(f8BITSOF(TSTSEM))) fBRANCH_SPECULATE_STALL(fLSBN= EW1,,SPECULATE_TAKEN,13,0) if (fLSBNEW1) {fIMMEXT(riV); fPCALIGN(riV);= fBRANCH(fREAD_PC()+riV,COF_TYPE_JUMP);}})\ +Q6INSN(J4_##TAG##_fp1_jump_t, "p1=3D"TST"; if (!p1.new) jump:t #r9:2", AT= TRIBS(A_CJNEWDIR,A_RELAX_COND,A_NEWCMPJUMP,A_PRED_BIT_13),"compound compare= -jump", {fPART1(fWRITE_P1(f8BITSOF(TSTSEM))) fBRANCH_SPECULATE_STALL(fLSBN= EW1NOT,,SPECULATE_TAKEN,13,0) if (fLSBNEW1NOT) {fIMMEXT(riV); fPCALIGN(= riV); fBRANCH(fREAD_PC()+riV,COF_TYPE_JUMP);}}) + + +STD_CMPJUMP(cmpeqi,"cmp.eq(Rs16,#U5)",(RsV=3D=3DUiV)) +STD_CMPJUMP(cmpgti,"cmp.gt(Rs16,#U5)",(RsV>UiV)) +STD_CMPJUMP(cmpgtui,"cmp.gtu(Rs16,#U5)",(fCAST4u(RsV)>UiV)) + +STD_CMPJUMP(cmpeqn1,"cmp.eq(Rs16,#-1)",(RsV=3D=3D-1)) +STD_CMPJUMP(cmpgtn1,"cmp.gt(Rs16,#-1)",(RsV>-1)) +STD_CMPJUMP(tstbit0,"tstbit(Rs16,#0)",(RsV & 1)) + +STD_CMPJUMP(cmpeq,"cmp.eq(Rs16,Rt16)",(RsV=3D=3DRtV)) +STD_CMPJUMP(cmpgt,"cmp.gt(Rs16,Rt16)",(RsV>RtV)) +STD_CMPJUMP(cmpgtu,"cmp.gtu(Rs16,Rt16)",(fCAST4u(RsV)>RtV)) + + + +/* V4 jump and transfer (CJ) */ +Q6INSN(J4_jumpseti,"Rd16=3D#U6 ; jump #r9:2",ATTRIBS(A_JDIR,A_RELAX_UNC), = "direct unconditional jump and set register to immediate", +{fIMMEXT(riV); fPCALIGN(riV); RdV=3DUiV; fBRANCH(fREAD_PC()+riV,COF_TYPE_J= UMP);}) + +Q6INSN(J4_jumpsetr,"Rd16=3DRs16 ; jump #r9:2",ATTRIBS(A_JDIR,A_RELAX_UNC),= "direct unconditional jump and transfer register", +{fIMMEXT(riV); fPCALIGN(riV); RdV=3DRsV; fBRANCH(fREAD_PC()+riV,COF_TYPE_J= UMP);}) + + +/* V4 new-value jumps (NCJ) */ +#define STD_CMPJUMPNEWRS(TAG,TST,TSTSEM)\ +Q6INSN(J4_##TAG##_jumpnv_t, "if ("TST") jump:t #r9:2", ATTRIBS(A_NEWVALUEJ= ,A_RESTRICT_NOSLOT1_STORE,A_RESTRICT_SLOT0ONLY,A_PRED_BIT_13),"compound com= pare-jump",{fBRANCH_SPECULATE_STALL(TSTSEM,,SPECULATE_TAKEN,13,0);if (TSTSE= M) {fIMMEXT(riV); fPCALIGN(riV); fBRANCH(fREAD_PC()+riV,COF_TYPE_JUMP);}})\ +Q6INSN(J4_##TAG##_jumpnv_nt,"if ("TST") jump:nt #r9:2",ATTRIBS(A_NEWVALUEJ= ,A_RESTRICT_NOSLOT1_STORE,A_RESTRICT_SLOT0ONLY,A_PRED_BIT_13),"compound com= pare-jump",{fBRANCH_SPECULATE_STALL(TSTSEM,,SPECULATE_NOT_TAKEN,13,0); if (= TSTSEM) {fIMMEXT(riV); fPCALIGN(riV); fBRANCH(fREAD_PC()+riV,COF_TYPE_JUMP)= ;}}) + + + + +STD_CMPJUMPNEWRS(cmpeqi_t,"cmp.eq(Ns8.new,#U5)",(fNEWREG(NsN)=3D=3D(UiV))) +STD_CMPJUMPNEWRS(cmpeqi_f,"!cmp.eq(Ns8.new,#U5)",(fNEWREG(NsN)!=3D(UiV))) +STD_CMPJUMPNEWRS(cmpgti_t,"cmp.gt(Ns8.new,#U5)",(fNEWREG(NsN)>(UiV))) +STD_CMPJUMPNEWRS(cmpgti_f,"!cmp.gt(Ns8.new,#U5)",!(fNEWREG(NsN)>(UiV))) +STD_CMPJUMPNEWRS(cmpgtui_t,"cmp.gtu(Ns8.new,#U5)",(fCAST4u(fNEWREG(NsN))>(= UiV))) +STD_CMPJUMPNEWRS(cmpgtui_f,"!cmp.gtu(Ns8.new,#U5)",!(fCAST4u(fNEWREG(NsN))= >(UiV))) + + +STD_CMPJUMPNEWRS(cmpeqn1_t,"cmp.eq(Ns8.new,#-1)",(fNEWREG(NsN)=3D=3D(-1))) +STD_CMPJUMPNEWRS(cmpeqn1_f,"!cmp.eq(Ns8.new,#-1)",(fNEWREG(NsN)!=3D(-1))) +STD_CMPJUMPNEWRS(cmpgtn1_t,"cmp.gt(Ns8.new,#-1)",(fNEWREG(NsN)>(-1))) +STD_CMPJUMPNEWRS(cmpgtn1_f,"!cmp.gt(Ns8.new,#-1)",!(fNEWREG(NsN)>(-1))) +STD_CMPJUMPNEWRS(tstbit0_t,"tstbit(Ns8.new,#0)",((fNEWREG(NsN)) & 1)) +STD_CMPJUMPNEWRS(tstbit0_f,"!tstbit(Ns8.new,#0)",!((fNEWREG(NsN)) & 1)) + + +STD_CMPJUMPNEWRS(cmpeq_t, "cmp.eq(Ns8.new,Rt32)", (fNEWREG(NsN)=3D=3DRtV)) +STD_CMPJUMPNEWRS(cmpgt_t, "cmp.gt(Ns8.new,Rt32)", (fNEWREG(NsN)>RtV)) +STD_CMPJUMPNEWRS(cmpgtu_t,"cmp.gtu(Ns8.new,Rt32)",(fCAST4u(fNEWREG(NsN))>f= CAST4u(RtV))) +STD_CMPJUMPNEWRS(cmplt_t, "cmp.gt(Rt32,Ns8.new)", (RtV>fNEWREG(NsN))) +STD_CMPJUMPNEWRS(cmpltu_t,"cmp.gtu(Rt32,Ns8.new)",(fCAST4u(RtV)>fCAST4u(fN= EWREG(NsN)))) +STD_CMPJUMPNEWRS(cmpeq_f, "!cmp.eq(Ns8.new,Rt32)", (fNEWREG(NsN)!=3DRtV)) +STD_CMPJUMPNEWRS(cmpgt_f, "!cmp.gt(Ns8.new,Rt32)", !(fNEWREG(NsN)>RtV)) +STD_CMPJUMPNEWRS(cmpgtu_f,"!cmp.gtu(Ns8.new,Rt32)",!(fCAST4u(fNEWREG(NsN))= >fCAST4u(RtV))) +STD_CMPJUMPNEWRS(cmplt_f, "!cmp.gt(Rt32,Ns8.new)", !(RtV>fNEWREG(NsN))) +STD_CMPJUMPNEWRS(cmpltu_f,"!cmp.gtu(Rt32,Ns8.new)",!(fCAST4u(RtV)>fCAST4u(= fNEWREG(NsN)))) + + + + + +/*********************************************/ +/* Subroutine Call instructions */ +/*********************************************/ + +#define CALL_NOTES A_NOTE_PACKET_PC,A_NOTE_PACKET_NPC,A_NOTE_RELATIVE_ADDR= ESS +#define CDIR_STD A_CALL,A_DIRECT,CALL_NOTES,A_COFSTD,A_BRANCHADDER +#define CINDIR_STD A_CALL,A_INDIRECT,A_COFSTD + +Q6INSN(J2_call,"call #r22:2",ATTRIBS(CDIR_STD,A_RELAX_UNC), "direct uncond= itional call", +{fIMMEXT(riV); fPCALIGN(riV); fCALL(fREAD_PC()+riV); }) + +Q6INSN(J2_callt,"if (Pu4) call #r15:2",ATTRIBS(CDIR_STD,A_NOTE_CONDITIONAL= ,A_RELAX_COND,A_PRED_BIT_12),"direct conditional call if true", +{fIMMEXT(riV); fPCALIGN(riV); fBRANCH_SPECULATE_STALL(fLSBOLD(PuV),,SPECUL= ATE_NOT_TAKEN,12,0); if (fLSBOLD(PuV)) { fCALL(fREAD_PC()+riV); }}) + +Q6INSN(J2_callf,"if (!Pu4) call #r15:2",ATTRIBS(CDIR_STD,A_NOTE_CONDITIONA= L,A_RELAX_COND,A_PRED_BIT_12),"direct conditional call if false", +{fIMMEXT(riV); fPCALIGN(riV); fBRANCH_SPECULATE_STALL(fLSBOLDNOT(PuV),,SPE= CULATE_NOT_TAKEN,12,0);if (fLSBOLDNOT(PuV)) { fCALL(fREAD_PC()+riV); }}) + +Q6INSN(J2_callr,"callr Rs32",ATTRIBS(CINDIR_STD), "indirect unconditional = call", +{ fCALLR(RsV); }) + +Q6INSN(J2_callrt,"if (Pu4) callr Rs32",ATTRIBS(CINDIR_STD,A_NOTE_CONDITION= AL,A_PRED_BIT_12),"indirect conditional call if true", +{fBRANCH_SPECULATE_STALL(fLSBOLD(PuV),,SPECULATE_NOT_TAKEN,12,0);if (fLSBO= LD(PuV)) { fCALLR(RsV); }}) + +Q6INSN(J2_callrf,"if (!Pu4) callr Rs32",ATTRIBS(CINDIR_STD,A_NOTE_CONDITIO= NAL,A_PRED_BIT_12),"indirect conditional call if false", +{fBRANCH_SPECULATE_STALL(fLSBOLDNOT(PuV),,SPECULATE_NOT_TAKEN,12,0);if (fL= SBOLDNOT(PuV)) { fCALLR(RsV); }}) + + + + +#define ATTRIB_HWLOOP_SETUP A_NOTE_PACKET_NPC,A_NOTE_RELATIVE_ADDRESS,A_NO= TE_PACKET_PC,A_NOTE_LA_RESTRICT,A_RESTRICT_LOOP_LA,A_BRANCHADDER,A_IT_HWLOO= P,A_RELAX_COF_1ST,A_RELAX_COF_2ND +#define ATTRIB_HWLOOP A_NOTE_PACKET_NPC,A_NOTE_PACKET_PC,A_RESTRICT_NOCOF,= A_NOTE_NOCOF_RESTRICT,A_ROPS_3 + +/*********************************************/ +/* HW Loop instructions */ +/*********************************************/ + +Q6INSN(J2_loop0r,"loop0(#r7:2,Rs32)",ATTRIBS(ATTRIB_HWLOOP_SETUP,A_HWLOOP0= _SETUP),"Initialize HW loop 0", +{ fIMMEXT(riV); fPCALIGN(riV); + fWRITE_LOOP_REGS0(/*sa,lc*/ fREAD_PC()+riV, RsV); + fSET_LPCFG(0); +}) + +Q6INSN(J2_loop1r,"loop1(#r7:2,Rs32)",ATTRIBS(ATTRIB_HWLOOP_SETUP,A_HWLOOP1= _SETUP),"Initialize HW loop 1", +{ fIMMEXT(riV); fPCALIGN(riV); + fWRITE_LOOP_REGS1(/*sa,lc*/ fREAD_PC()+riV, RsV); +}) + +Q6INSN(J2_loop0i,"loop0(#r7:2,#U10)",ATTRIBS(ATTRIB_HWLOOP_SETUP,A_HWLOOP0= _SETUP),"Initialize HW loop 0", +{ fIMMEXT(riV); fPCALIGN(riV); + fWRITE_LOOP_REGS0(/*sa,lc*/ fREAD_PC()+riV, UiV); + fSET_LPCFG(0); +}) + +Q6INSN(J2_loop1i,"loop1(#r7:2,#U10)",ATTRIBS(ATTRIB_HWLOOP_SETUP,A_HWLOOP1= _SETUP),"Initialize HW loop 1", +{ fIMMEXT(riV); fPCALIGN(riV); + fWRITE_LOOP_REGS1(/*sa,lc*/ fREAD_PC()+riV, UiV); +}) + + +Q6INSN(J2_ploop1sr,"p3=3Dsp1loop0(#r7:2,Rs32)",ATTRIBS(ATTRIB_HWLOOP_SETUP= ,A_ARCHV2,A_RESTRICT_LATEPRED,A_NOTE_LATEPRED,A_HWLOOP0_SETUP),"Initialize = HW loop 0", +{ fIMMEXT(riV); fPCALIGN(riV); + fWRITE_LOOP_REGS0(/*sa,lc*/ fREAD_PC()+riV, RsV); + fSET_LPCFG(1); + fWRITE_P3_LATE(0); +}) +Q6INSN(J2_ploop1si,"p3=3Dsp1loop0(#r7:2,#U10)",ATTRIBS(ATTRIB_HWLOOP_SETUP= ,A_ARCHV2,A_RESTRICT_LATEPRED,A_NOTE_LATEPRED,A_HWLOOP0_SETUP),"Initialize = HW loop 0", +{ fIMMEXT(riV); fPCALIGN(riV); + fWRITE_LOOP_REGS0(/*sa,lc*/ fREAD_PC()+riV, UiV); + fSET_LPCFG(1); + fWRITE_P3_LATE(0); +}) + +Q6INSN(J2_ploop2sr,"p3=3Dsp2loop0(#r7:2,Rs32)",ATTRIBS(ATTRIB_HWLOOP_SETUP= ,A_ARCHV2,A_RESTRICT_LATEPRED,A_NOTE_LATEPRED,A_HWLOOP0_SETUP),"Initialize = HW loop 0", +{ fIMMEXT(riV); fPCALIGN(riV); + fWRITE_LOOP_REGS0(/*sa,lc*/ fREAD_PC()+riV, RsV); + fSET_LPCFG(2); + fWRITE_P3_LATE(0); +}) +Q6INSN(J2_ploop2si,"p3=3Dsp2loop0(#r7:2,#U10)",ATTRIBS(ATTRIB_HWLOOP_SETUP= ,A_ARCHV2,A_RESTRICT_LATEPRED,A_NOTE_LATEPRED,A_HWLOOP0_SETUP),"Initialize = HW loop 0", +{ fIMMEXT(riV); fPCALIGN(riV); + fWRITE_LOOP_REGS0(/*sa,lc*/ fREAD_PC()+riV, UiV); + fSET_LPCFG(2); + fWRITE_P3_LATE(0); +}) + +Q6INSN(J2_ploop3sr,"p3=3Dsp3loop0(#r7:2,Rs32)",ATTRIBS(ATTRIB_HWLOOP_SETUP= ,A_ARCHV2,A_RESTRICT_LATEPRED,A_NOTE_LATEPRED,A_HWLOOP0_SETUP),"Initialize = HW loop 0", +{ fIMMEXT(riV); fPCALIGN(riV); + fWRITE_LOOP_REGS0(/*sa,lc*/ fREAD_PC()+riV, RsV); + fSET_LPCFG(3); + fWRITE_P3_LATE(0); +}) +Q6INSN(J2_ploop3si,"p3=3Dsp3loop0(#r7:2,#U10)",ATTRIBS(ATTRIB_HWLOOP_SETUP= ,A_ARCHV2,A_RESTRICT_LATEPRED,A_NOTE_LATEPRED,A_HWLOOP0_SETUP),"Initialize = HW loop 0", +{ fIMMEXT(riV); fPCALIGN(riV); + fWRITE_LOOP_REGS0(/*sa,lc*/ fREAD_PC()+riV, UiV); + fSET_LPCFG(3); + fWRITE_P3_LATE(0); +}) + + + +Q6INSN(J2_endloop01,"endloop01",ATTRIBS(ATTRIB_HWLOOP,A_HWLOOP0_END,A_HWLO= OP1_END,A_RESTRICT_LATEPRED),"Loopend for inner and outer loop", +{ + + /* V2: With predicate control */ + if (fGET_LPCFG) { + fHIDE( if (fGET_LPCFG >=3D 2) { fWRITE_P3(fNOATTRIB_READ_P3()); } else= ) + if (fGET_LPCFG=3D=3D1) { + fWRITE_P3(0xff); + } + fSET_LPCFG(fGET_LPCFG-1); + fHIDE(MARK_LATE_PRED_WRITE(3)) + } + + /* check if iterate */ + if (fREAD_LC0>1) { + fBRANCH(fREAD_SA0,COF_TYPE_LOOPEND0); + fHIDE(fLOOPSTATS(fREAD_SA0);) + /* decrement loop count */ + fWRITE_LC0(fREAD_LC0-1); + } else { + /* check if iterate */ + if (fREAD_LC1>1) { + fBRANCH(fREAD_SA1,COF_TYPE_LOOPEND1); + fHIDE(fLOOPSTATS(fREAD_SA1);) + /* decrement loop count */ + fWRITE_LC1(fREAD_LC1-1); + } + } + +}) + +Q6INSN(J2_endloop0,"endloop0",ATTRIBS(ATTRIB_HWLOOP,A_HWLOOP0_END,A_RESTRI= CT_LATEPRED),"Loopend for inner loop", +{ + + /* V2: With predicate control */ + if (fGET_LPCFG) { + fHIDE( if (fGET_LPCFG >=3D 2) { fWRITE_P3(fNOATTRIB_READ_P3()); } else= ) + if (fGET_LPCFG=3D=3D1) { + fWRITE_P3(0xff); + } + fHIDE(MARK_LATE_PRED_WRITE(3)) + fSET_LPCFG(fGET_LPCFG-1); + } + + /* check if iterate */ + if (fREAD_LC0>1) { + fBRANCH(fREAD_SA0,COF_TYPE_LOOPEND0); + fHIDE(fLOOPSTATS(fREAD_SA0);) + /* decrement loop count */ + fWRITE_LC0(fREAD_LC0-1); + } +}) + +Q6INSN(J2_endloop1,"endloop1",ATTRIBS(ATTRIB_HWLOOP,A_HWLOOP1_END),"Loopen= d for outer loop", +{ + /* check if iterate */ + if (fREAD_LC1>1) { + fBRANCH(fREAD_SA1,COF_TYPE_LOOPEND1); + fHIDE(fLOOPSTATS(fREAD_SA1);) + /* decrement loop count */ + fWRITE_LC1(fREAD_LC1-1); + } +}) + + diff --git a/target/hexagon/imported/compare.idef b/target/hexagon/imported= /compare.idef new file mode 100644 index 0000000..0f05307 --- /dev/null +++ b/target/hexagon/imported/compare.idef @@ -0,0 +1,639 @@ +/* + * Copyright(c) 2019-2020 Qualcomm Innovation Center, Inc. All Rights Res= erved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +/* + * Compare Instructions + */ + + + +/*********************************************/ +/* Scalar compare instructions */ +/*********************************************/ + +Q6INSN(C2_cmpeq,"Pd4=3Dcmp.eq(Rs32,Rt32)",ATTRIBS(), +"Compare for Equal", +{PdV=3Df8BITSOF(RsV=3D=3DRtV);}) + +Q6INSN(C2_cmpgt,"Pd4=3Dcmp.gt(Rs32,Rt32)",ATTRIBS(), +"Compare for signed Greater Than", +{PdV=3Df8BITSOF(RsV>RtV);}) + +Q6INSN(C2_cmpgtu,"Pd4=3Dcmp.gtu(Rs32,Rt32)",ATTRIBS(), +"Compare for Greater Than Unsigned", +{PdV=3Df8BITSOF(fCAST4u(RsV)>fCAST4u(RtV));}) + +Q6INSN(C2_cmpeqp,"Pd4=3Dcmp.eq(Rss32,Rtt32)",ATTRIBS(), +"Compare for Equal", +{PdV=3Df8BITSOF(RssV=3D=3DRttV);}) + +Q6INSN(C2_cmpgtp,"Pd4=3Dcmp.gt(Rss32,Rtt32)",ATTRIBS(), +"Compare for signed Greater Than", +{PdV=3Df8BITSOF(RssV>RttV);}) + +Q6INSN(C2_cmpgtup,"Pd4=3Dcmp.gtu(Rss32,Rtt32)",ATTRIBS(), +"Compare for Greater Than Unsigned", +{PdV=3Df8BITSOF(fCAST8u(RssV)>fCAST8u(RttV));}) + + + + +/*********************************************/ +/* Compare and put result in GPR */ +/* typically for function I/O */ +/*********************************************/ + +Q6INSN(A4_rcmpeqi,"Rd32=3Dcmp.eq(Rs32,#s8)",ATTRIBS(), +"Compare for Equal", +{fIMMEXT(siV); RdV=3D(RsV=3D=3DsiV); }) + +Q6INSN(A4_rcmpneqi,"Rd32=3D!cmp.eq(Rs32,#s8)",ATTRIBS(), +"Compare for Equal", +{fIMMEXT(siV); RdV=3D(RsV!=3DsiV); }) + + +Q6INSN(A4_rcmpeq,"Rd32=3Dcmp.eq(Rs32,Rt32)",ATTRIBS(), +"Compare for Equal", +{RdV=3D(RsV=3D=3DRtV); }) + +Q6INSN(A4_rcmpneq,"Rd32=3D!cmp.eq(Rs32,Rt32)",ATTRIBS(), +"Compare for Equal", +{RdV=3D(RsV!=3DRtV); }) + + + +/*********************************************/ +/* Scalar compare instructions */ +/*********************************************/ + + +Q6INSN(C2_bitsset,"Pd4=3Dbitsset(Rs32,Rt32)",ATTRIBS(A_ARCHV2), +"Compare for selected bits set", +{PdV=3Df8BITSOF((RsV&RtV)=3D=3DRtV);}) + +Q6INSN(C2_bitsclr,"Pd4=3Dbitsclr(Rs32,Rt32)",ATTRIBS(A_ARCHV2), +"Compare for selected bits clear", +{PdV=3Df8BITSOF((RsV&RtV)=3D=3D0);}) + + +Q6INSN(C4_nbitsset,"Pd4=3D!bitsset(Rs32,Rt32)",ATTRIBS(A_ARCHV2), +"Compare for selected bits set", +{PdV=3Df8BITSOF((RsV&RtV)!=3DRtV);}) + +Q6INSN(C4_nbitsclr,"Pd4=3D!bitsclr(Rs32,Rt32)",ATTRIBS(A_ARCHV2), +"Compare for selected bits clear", +{PdV=3Df8BITSOF((RsV&RtV)!=3D0);}) + + + +/*********************************************/ +/* Scalar compare instructions W/ immediate */ +/*********************************************/ + +Q6INSN(C2_cmpeqi,"Pd4=3Dcmp.eq(Rs32,#s10)",ATTRIBS(), +"Compare for Equal", +{fIMMEXT(siV); PdV=3Df8BITSOF(RsV=3D=3DsiV);}) + +Q6INSN(C2_cmpgti,"Pd4=3Dcmp.gt(Rs32,#s10)",ATTRIBS(), +"Compare for signed Greater Than", +{fIMMEXT(siV); PdV=3Df8BITSOF(RsV>siV);}) + +Q6INSN(C2_cmpgtui,"Pd4=3Dcmp.gtu(Rs32,#u9)",ATTRIBS(), +"Compare for Greater Than Unsigned", +{fIMMEXT(uiV); PdV=3Df8BITSOF(fCAST4u(RsV)>fCAST4u(uiV));}) + +DEF_MAPPING(C2_cmpgei,"Pd4=3Dcmp.ge(Rs32,#s8)","Pd4=3Dcmp.gt(Rs32,#s8-1)") +DEF_COND_MAPPING(C2_cmpgeui,"Pd4=3Dcmp.geu(Rs32,#u8)","#u8=3D=3D0","Pd4=3D= cmp.eq(Rs32,Rs32)","Pd4=3Dcmp.gtu(Rs32,#u8-1)") + +/* Just for fun */ +DEF_V2_MAPPING(C2_cmplt,"Pd4=3Dcmp.lt(Rs32,Rt32)","Pd4=3Dcmp.gt(Rt32,Rs32)= ") +DEF_V2_MAPPING(C2_cmpltu,"Pd4=3Dcmp.ltu(Rs32,Rt32)","Pd4=3Dcmp.gtu(Rt32,Rs= 32)") + + +Q6INSN(C2_bitsclri,"Pd4=3Dbitsclr(Rs32,#u6)",ATTRIBS(A_ARCHV2), +"Compare for selected bits clear", +{PdV=3Df8BITSOF((RsV&uiV)=3D=3D0);}) + +Q6INSN(C4_nbitsclri,"Pd4=3D!bitsclr(Rs32,#u6)",ATTRIBS(A_ARCHV2), +"Compare for selected bits clear", +{PdV=3Df8BITSOF((RsV&uiV)!=3D0);}) + + + + +Q6INSN(C4_cmpneqi,"Pd4=3D!cmp.eq(Rs32,#s10)",ATTRIBS(), "Compare for Not E= qual", {fIMMEXT(siV); PdV=3Df8BITSOF(RsV!=3DsiV);}) +Q6INSN(C4_cmpltei,"Pd4=3D!cmp.gt(Rs32,#s10)",ATTRIBS(), "Compare for Less = Than or Equal", {fIMMEXT(siV); PdV=3Df8BITSOF(RsV<=3DsiV);}) +Q6INSN(C4_cmplteui,"Pd4=3D!cmp.gtu(Rs32,#u9)",ATTRIBS(), "Compare for Less= Than or Equal Unsigned", {fIMMEXT(uiV); PdV=3Df8BITSOF(fCAST4u(RsV)<=3DfCA= ST4u(uiV));}) + +Q6INSN(C4_cmpneq,"Pd4=3D!cmp.eq(Rs32,Rt32)",ATTRIBS(), "And-Compare for Eq= ual", {PdV=3Df8BITSOF(RsV!=3DRtV);}) +Q6INSN(C4_cmplte,"Pd4=3D!cmp.gt(Rs32,Rt32)",ATTRIBS(), "And-Compare for si= gned Greater Than", {PdV=3Df8BITSOF(RsV<=3DRtV);}) +Q6INSN(C4_cmplteu,"Pd4=3D!cmp.gtu(Rs32,Rt32)",ATTRIBS(), "And-Compare for = Greater Than Unsigned", {PdV=3Df8BITSOF(fCAST4u(RsV)<=3DfCAST4u(RtV));}) + + + + + +/* Predicate Logical Operations */ + +Q6INSN(C2_and,"Pd4=3Dand(Pt4,Ps4)",ATTRIBS(A_CRSLOT23,A_NOTE_CRSLOT23), +"Predicate AND", +{fPREDUSE_TIMING();PdV=3DPsV & PtV;}) + +Q6INSN(C2_or,"Pd4=3Dor(Pt4,Ps4)",ATTRIBS(A_CRSLOT23,A_NOTE_CRSLOT23), +"Predicate OR", +{fPREDUSE_TIMING();PdV=3DPsV | PtV;}) + +Q6INSN(C2_xor,"Pd4=3Dxor(Ps4,Pt4)",ATTRIBS(A_CRSLOT23,A_NOTE_CRSLOT23), +"Predicate XOR", +{fPREDUSE_TIMING();PdV=3DPsV ^ PtV;}) + +Q6INSN(C2_andn,"Pd4=3Dand(Pt4,!Ps4)",ATTRIBS(A_CRSLOT23,A_NOTE_CRSLOT23), +"Predicate AND NOT", +{fPREDUSE_TIMING();PdV=3DPtV & (~PsV);}) + +Q6INSN(C2_not,"Pd4=3Dnot(Ps4)",ATTRIBS(A_CRSLOT23,A_NOTE_CRSLOT23), +"Logical NOT Predicate", +{fPREDUSE_TIMING();PdV=3D~PsV;}) + +Q6INSN(C2_orn,"Pd4=3Dor(Pt4,!Ps4)",ATTRIBS(A_ARCHV2,A_CRSLOT23,A_NOTE_CRSL= OT23), +"Predicate OR NOT", +{fPREDUSE_TIMING();PdV=3DPtV | (~PsV);}) + + + + + +Q6INSN(C4_and_and,"Pd4=3Dand(Ps4,and(Pt4,Pu4))",ATTRIBS(A_CRSLOT23,A_NOTE_= CRSLOT23), +"Compound And-And", { fPREDUSE_TIMING();PdV =3D PsV & PtV & PuV; }) + +Q6INSN(C4_and_or,"Pd4=3Dand(Ps4,or(Pt4,Pu4))",ATTRIBS(A_CRSLOT23,A_NOTE_CR= SLOT23), +"Compound And-Or", { fPREDUSE_TIMING();PdV =3D PsV & (PtV | PuV); }) + +Q6INSN(C4_or_and,"Pd4=3Dor(Ps4,and(Pt4,Pu4))",ATTRIBS(A_CRSLOT23,A_NOTE_CR= SLOT23), +"Compound Or-And", { fPREDUSE_TIMING();PdV =3D PsV | (PtV & PuV); }) + +Q6INSN(C4_or_or,"Pd4=3Dor(Ps4,or(Pt4,Pu4))",ATTRIBS(A_CRSLOT23,A_NOTE_CRSL= OT23), +"Compound Or-Or", { fPREDUSE_TIMING();PdV =3D PsV | PtV | PuV; }) + + + +Q6INSN(C4_and_andn,"Pd4=3Dand(Ps4,and(Pt4,!Pu4))",ATTRIBS(A_CRSLOT23,A_NOT= E_CRSLOT23), +"Compound And-And", { fPREDUSE_TIMING();PdV =3D PsV & PtV & (~PuV); }) + +Q6INSN(C4_and_orn,"Pd4=3Dand(Ps4,or(Pt4,!Pu4))",ATTRIBS(A_CRSLOT23,A_NOTE_= CRSLOT23), +"Compound And-Or", { fPREDUSE_TIMING();PdV =3D PsV & (PtV | (~PuV)); }) + +Q6INSN(C4_or_andn,"Pd4=3Dor(Ps4,and(Pt4,!Pu4))",ATTRIBS(A_CRSLOT23,A_NOTE_= CRSLOT23), +"Compound Or-And", { fPREDUSE_TIMING();PdV =3D PsV | (PtV & (~PuV)); }) + +Q6INSN(C4_or_orn,"Pd4=3Dor(Ps4,or(Pt4,!Pu4))",ATTRIBS(A_CRSLOT23,A_NOTE_CR= SLOT23), +"Compound Or-Or", { fPREDUSE_TIMING();PdV =3D PsV | PtV | (~PuV); }) + + + + + +DEF_V2_MAPPING(C2_pxfer_map,"Pd4=3DPs4","Pd4=3Dor(Ps4,Ps4)") + + +Q6INSN(C2_any8,"Pd4=3Dany8(Ps4)",ATTRIBS(A_CRSLOT23,A_NOTE_CRSLOT23), +"Logical ANY of low 8 predicate bits", +{ fPREDUSE_TIMING();PsV ? (PdV=3D0xff) : (PdV=3D0x00); }) + +Q6INSN(C2_all8,"Pd4=3Dall8(Ps4)",ATTRIBS(A_CRSLOT23,A_NOTE_CRSLOT23), +"Logical ALL of low 8 predicate bits", +{ fPREDUSE_TIMING();(PsV=3D=3D0xff) ? (PdV=3D0xff) : (PdV=3D0x00); }) + +Q6INSN(C2_vitpack,"Rd32=3Dvitpack(Ps4,Pt4)",ATTRIBS(), +"Pack the odd and even bits of two predicate registers", +{ fPREDUSE_TIMING();RdV =3D (PsV&0x55) | (PtV&0xAA); }) + +/* Mux instructions */ + +Q6INSN(C2_mux,"Rd32=3Dmux(Pu4,Rs32,Rt32)",ATTRIBS(), +"Scalar MUX", +{ fPREDUSE_TIMING();(fLSBOLD(PuV)) ? (RdV=3DRsV):(RdV=3DRtV); }) + + +Q6INSN(C2_cmovenewit,"if (Pu4.new) Rd32=3D#s12",ATTRIBS(A_ARCHV2), +"Scalar conditional move", +{ fIMMEXT(siV); if (fLSBNEW(PuN)) RdV=3DsiV; else CANCEL;}) + +Q6INSN(C2_cmovenewif,"if (!Pu4.new) Rd32=3D#s12",ATTRIBS(A_ARCHV2), +"Scalar conditional move", +{ fIMMEXT(siV); if (fLSBNEWNOT(PuN)) RdV=3DsiV; else CANCEL;}) + +Q6INSN(C2_cmoveit,"if (Pu4) Rd32=3D#s12",ATTRIBS(A_ARCHV2), +"Scalar conditional move", +{ fIMMEXT(siV); if (fLSBOLD(PuV)) RdV=3DsiV; else CANCEL;}) + +Q6INSN(C2_cmoveif,"if (!Pu4) Rd32=3D#s12",ATTRIBS(A_ARCHV2), +"Scalar conditional move", +{ fIMMEXT(siV); if (fLSBOLDNOT(PuV)) RdV=3DsiV; else CANCEL;}) + + + +Q6INSN(C2_ccombinewnewt,"if (Pu4.new) Rdd32=3Dcombine(Rs32,Rt32)",ATTRIBS(= A_ROPS_2,A_ARCHV2), +"Conditionally combine two words into a register pair", +{ if (fLSBNEW(PuN)) { + fSETWORD(0,RddV,RtV); + fSETWORD(1,RddV,RsV); + } else {CANCEL;} +}) + +Q6INSN(C2_ccombinewnewf,"if (!Pu4.new) Rdd32=3Dcombine(Rs32,Rt32)",ATTRIBS= (A_ARCHV2,A_ROPS_2), +"Conditionally combine two words into a register pair", +{ if (fLSBNEWNOT(PuN)) { + fSETWORD(0,RddV,RtV); + fSETWORD(1,RddV,RsV); + } else {CANCEL;} +}) + +Q6INSN(C2_ccombinewt,"if (Pu4) Rdd32=3Dcombine(Rs32,Rt32)",ATTRIBS(A_ARCHV= 2,A_ROPS_2), +"Conditionally combine two words into a register pair", +{ if (fLSBOLD(PuV)) { + fSETWORD(0,RddV,RtV); + fSETWORD(1,RddV,RsV); + } else {CANCEL;} +}) + +Q6INSN(C2_ccombinewf,"if (!Pu4) Rdd32=3Dcombine(Rs32,Rt32)",ATTRIBS(A_ARCH= V2,A_ROPS_2), +"Conditionally combine two words into a register pair", +{ if (fLSBOLDNOT(PuV)) { + fSETWORD(0,RddV,RtV); + fSETWORD(1,RddV,RsV); + } else {CANCEL;} +}) + + + +Q6INSN(C2_muxii,"Rd32=3Dmux(Pu4,#s8,#S8)",ATTRIBS(A_ARCHV2), +"Scalar MUX immediates", +{ fPREDUSE_TIMING();fIMMEXT(siV); (fLSBOLD(PuV)) ? (RdV=3DsiV):(RdV=3DSiV)= ; }) + + + +Q6INSN(C2_muxir,"Rd32=3Dmux(Pu4,Rs32,#s8)",ATTRIBS(A_ARCHV2), +"Scalar MUX register immediate", +{ fPREDUSE_TIMING();fIMMEXT(siV); (fLSBOLD(PuV)) ? (RdV=3DRsV):(RdV=3DsiV)= ; }) + + +Q6INSN(C2_muxri,"Rd32=3Dmux(Pu4,#s8,Rs32)",ATTRIBS(A_ARCHV2), +"Scalar MUX register immediate", +{ fPREDUSE_TIMING();fIMMEXT(siV); (fLSBOLD(PuV)) ? (RdV=3DsiV):(RdV=3DRsV)= ; }) + + + +Q6INSN(C2_vmux,"Rdd32=3Dvmux(Pu4,Rss32,Rtt32)",ATTRIBS(), +"Vector MUX", +{ fPREDUSE_TIMING(); + fHIDE(int i;) + for (i =3D 0; i < 8; i++) { + fSETBYTE(i,RddV,(fGETBIT(i,PuV)?(fGETBYTE(i,RssV)):(fGETBYTE(i,RttV)))); + } +}) + +Q6INSN(C2_mask,"Rdd32=3Dmask(Pt4)",ATTRIBS(), +"Vector Mask Generation", +{ fPREDUSE_TIMING(); + fHIDE(int i;) + for (i =3D 0; i < 8; i++) { + fSETBYTE(i,RddV,(fGETBIT(i,PtV)?(0xff):(0x00))); + } +}) + +/* VCMP */ + +Q6INSN(A2_vcmpbeq,"Pd4=3Dvcmpb.eq(Rss32,Rtt32)",ATTRIBS(), +"Compare elements of two vectors ", +{ + fHIDE(int i;) + for (i =3D 0; i < 8; i++) { + fSETBIT(i,PdV,(fGETBYTE(i,RssV) =3D=3D fGETBYTE(i,RttV))); + } +}) + +Q6INSN(A4_vcmpbeqi,"Pd4=3Dvcmpb.eq(Rss32,#u8)",ATTRIBS(), +"Compare elements of two vectors ", +{ + fHIDE(int i;) + for (i =3D 0; i < 8; i++) { + fSETBIT(i,PdV,(fGETUBYTE(i,RssV) =3D=3D uiV)); + } +}) + +Q6INSN(A4_vcmpbeq_any,"Pd4=3Dany8(vcmpb.eq(Rss32,Rtt32))",ATTRIBS(), +"Compare elements of two vectors ", +{ + fHIDE(int i;) + PdV =3D 0; + for (i =3D 0; i < 8; i++) { + if (fGETBYTE(i,RssV) =3D=3D fGETBYTE(i,RttV)) PdV =3D 0xff; + } +}) + +Q6INSN(A6_vcmpbeq_notany,"Pd4=3D!any8(vcmpb.eq(Rss32,Rtt32))",ATTRIBS(), +"Compare elements of two vectors ", +{ + fHIDE(int i;) + PdV =3D 0; + for (i =3D 0; i < 8; i++) { + if (fGETBYTE(i,RssV) =3D=3D fGETBYTE(i,RttV)) PdV =3D 0xff; + } + PdV =3D ~PdV; +}) + +Q6INSN(A2_vcmpbgtu,"Pd4=3Dvcmpb.gtu(Rss32,Rtt32)",ATTRIBS(), +"Compare elements of two vectors ", +{ + fHIDE(int i;) + for (i =3D 0; i < 8; i++) { + fSETBIT(i,PdV,(fGETUBYTE(i,RssV) > fGETUBYTE(i,RttV))); + } +}) + +Q6INSN(A4_vcmpbgtui,"Pd4=3Dvcmpb.gtu(Rss32,#u7)",ATTRIBS(), +"Compare elements of two vectors ", +{ + fHIDE(int i;) + for (i =3D 0; i < 8; i++) { + fSETBIT(i,PdV,(fGETUBYTE(i,RssV) > uiV)); + } +}) + +Q6INSN(A4_vcmpbgt,"Pd4=3Dvcmpb.gt(Rss32,Rtt32)",ATTRIBS(), +"Compare elements of two vectors ", +{ + fHIDE(int i;) + for (i =3D 0; i < 8; i++) { + fSETBIT(i,PdV,(fGETBYTE(i,RssV) > fGETBYTE(i,RttV))); + } +}) + +Q6INSN(A4_vcmpbgti,"Pd4=3Dvcmpb.gt(Rss32,#s8)",ATTRIBS(), +"Compare elements of two vectors ", +{ + fHIDE(int i;) + for (i =3D 0; i < 8; i++) { + fSETBIT(i,PdV,(fGETBYTE(i,RssV) > siV)); + } +}) + + + +Q6INSN(A4_cmpbeq,"Pd4=3Dcmpb.eq(Rs32,Rt32)",ATTRIBS(), +"Compare bytes ", +{ + PdV=3Df8BITSOF(fGETBYTE(0,RsV) =3D=3D fGETBYTE(0,RtV)); +}) + +Q6INSN(A4_cmpbeqi,"Pd4=3Dcmpb.eq(Rs32,#u8)",ATTRIBS(), +"Compare bytes ", +{ + PdV=3Df8BITSOF(fGETUBYTE(0,RsV) =3D=3D uiV); +}) + +Q6INSN(A4_cmpbgtu,"Pd4=3Dcmpb.gtu(Rs32,Rt32)",ATTRIBS(), +"Compare bytes ", +{ + PdV=3Df8BITSOF(fGETUBYTE(0,RsV) > fGETUBYTE(0,RtV)); +}) + +Q6INSN(A4_cmpbgtui,"Pd4=3Dcmpb.gtu(Rs32,#u7)",ATTRIBS(), +"Compare bytes ", +{ + fIMMEXT(uiV); + PdV=3Df8BITSOF(fGETUBYTE(0,RsV) > fCAST4u(uiV)); +}) + +Q6INSN(A4_cmpbgt,"Pd4=3Dcmpb.gt(Rs32,Rt32)",ATTRIBS(), +"Compare bytes ", +{ + PdV=3Df8BITSOF(fGETBYTE(0,RsV) > fGETBYTE(0,RtV)); +}) + +Q6INSN(A4_cmpbgti,"Pd4=3Dcmpb.gt(Rs32,#s8)",ATTRIBS(), +"Compare bytes ", +{ + PdV=3Df8BITSOF(fGETBYTE(0,RsV) > siV); +}) + +Q6INSN(A2_vcmpheq,"Pd4=3Dvcmph.eq(Rss32,Rtt32)",ATTRIBS(), +"Compare elements of two vectors ", +{ + fHIDE(int i;) + for (i =3D 0; i < 4; i++) { + fSETBIT(i*2,PdV, (fGETHALF(i,RssV) =3D=3D fGETHALF(i,RttV))); + fSETBIT(i*2+1,PdV,(fGETHALF(i,RssV) =3D=3D fGETHALF(i,RttV))); + } +}) + +Q6INSN(A2_vcmphgt,"Pd4=3Dvcmph.gt(Rss32,Rtt32)",ATTRIBS(), +"Compare elements of two vectors ", +{ + fHIDE(int i;) + for (i =3D 0; i < 4; i++) { + fSETBIT(i*2, PdV, (fGETHALF(i,RssV) > fGETHALF(i,RttV))); + fSETBIT(i*2+1,PdV, (fGETHALF(i,RssV) > fGETHALF(i,RttV))); + } +}) + +Q6INSN(A2_vcmphgtu,"Pd4=3Dvcmph.gtu(Rss32,Rtt32)",ATTRIBS(), +"Compare elements of two vectors ", +{ + fHIDE(int i;) + for (i =3D 0; i < 4; i++) { + fSETBIT(i*2, PdV, (fGETUHALF(i,RssV) > fGETUHALF(i,RttV))); + fSETBIT(i*2+1,PdV, (fGETUHALF(i,RssV) > fGETUHALF(i,RttV))); + } +}) + +Q6INSN(A4_vcmpheqi,"Pd4=3Dvcmph.eq(Rss32,#s8)",ATTRIBS(), +"Compare elements of two vectors ", +{ + fHIDE(int i;) + for (i =3D 0; i < 4; i++) { + fSETBIT(i*2,PdV, (fGETHALF(i,RssV) =3D=3D siV)); + fSETBIT(i*2+1,PdV,(fGETHALF(i,RssV) =3D=3D siV)); + } +}) + +Q6INSN(A4_vcmphgti,"Pd4=3Dvcmph.gt(Rss32,#s8)",ATTRIBS(), +"Compare elements of two vectors ", +{ + fHIDE(int i;) + for (i =3D 0; i < 4; i++) { + fSETBIT(i*2, PdV, (fGETHALF(i,RssV) > siV)); + fSETBIT(i*2+1,PdV, (fGETHALF(i,RssV) > siV)); + } +}) + + +Q6INSN(A4_vcmphgtui,"Pd4=3Dvcmph.gtu(Rss32,#u7)",ATTRIBS(), +"Compare elements of two vectors ", +{ + fHIDE(int i;) + for (i =3D 0; i < 4; i++) { + fSETBIT(i*2, PdV, (fGETUHALF(i,RssV) > uiV)); + fSETBIT(i*2+1,PdV, (fGETUHALF(i,RssV) > uiV)); + } +}) + +Q6INSN(A4_cmpheq,"Pd4=3Dcmph.eq(Rs32,Rt32)",ATTRIBS(), +"Compare halfwords ", +{ + PdV=3Df8BITSOF(fGETHALF(0,RsV) =3D=3D fGETHALF(0,RtV)); +}) + +Q6INSN(A4_cmphgt,"Pd4=3Dcmph.gt(Rs32,Rt32)",ATTRIBS(), +"Compare halfwords ", +{ + PdV=3Df8BITSOF(fGETHALF(0,RsV) > fGETHALF(0,RtV)); +}) + +Q6INSN(A4_cmphgtu,"Pd4=3Dcmph.gtu(Rs32,Rt32)",ATTRIBS(), +"Compare halfwords ", +{ + PdV=3Df8BITSOF(fGETUHALF(0,RsV) > fGETUHALF(0,RtV)); +}) + +Q6INSN(A4_cmpheqi,"Pd4=3Dcmph.eq(Rs32,#s8)",ATTRIBS(), +"Compare halfwords ", +{ + fIMMEXT(siV); + PdV=3Df8BITSOF(fGETHALF(0,RsV) =3D=3D siV); +}) + +Q6INSN(A4_cmphgti,"Pd4=3Dcmph.gt(Rs32,#s8)",ATTRIBS(), +"Compare halfwords ", +{ + fIMMEXT(siV); + PdV=3Df8BITSOF(fGETHALF(0,RsV) > siV); +}) + +Q6INSN(A4_cmphgtui,"Pd4=3Dcmph.gtu(Rs32,#u7)",ATTRIBS(), +"Compare halfwords ", +{ + fIMMEXT(uiV); + PdV=3Df8BITSOF(fGETUHALF(0,RsV) > fCAST4u(uiV)); +}) + +Q6INSN(A2_vcmpweq,"Pd4=3Dvcmpw.eq(Rss32,Rtt32)",ATTRIBS(), +"Compare elements of two vectors ", +{ + fSETBITS(3,0,PdV,(fGETWORD(0,RssV)=3D=3DfGETWORD(0,RttV))); + fSETBITS(7,4,PdV,(fGETWORD(1,RssV)=3D=3DfGETWORD(1,RttV))); +}) + +Q6INSN(A2_vcmpwgt,"Pd4=3Dvcmpw.gt(Rss32,Rtt32)",ATTRIBS(), +"Compare elements of two vectors ", +{ + fSETBITS(3,0,PdV,(fGETWORD(0,RssV)>fGETWORD(0,RttV))); + fSETBITS(7,4,PdV,(fGETWORD(1,RssV)>fGETWORD(1,RttV))); +}) + +Q6INSN(A2_vcmpwgtu,"Pd4=3Dvcmpw.gtu(Rss32,Rtt32)",ATTRIBS(), +"Compare elements of two vectors ", +{ + fSETBITS(3,0,PdV,(fGETUWORD(0,RssV)>fGETUWORD(0,RttV))); + fSETBITS(7,4,PdV,(fGETUWORD(1,RssV)>fGETUWORD(1,RttV))); +}) + +Q6INSN(A4_vcmpweqi,"Pd4=3Dvcmpw.eq(Rss32,#s8)",ATTRIBS(), +"Compare elements of two vectors ", +{ + fSETBITS(3,0,PdV,(fGETWORD(0,RssV)=3D=3DsiV)); + fSETBITS(7,4,PdV,(fGETWORD(1,RssV)=3D=3DsiV)); +}) + +Q6INSN(A4_vcmpwgti,"Pd4=3Dvcmpw.gt(Rss32,#s8)",ATTRIBS(), +"Compare elements of two vectors ", +{ + fSETBITS(3,0,PdV,(fGETWORD(0,RssV)>siV)); + fSETBITS(7,4,PdV,(fGETWORD(1,RssV)>siV)); +}) + +Q6INSN(A4_vcmpwgtui,"Pd4=3Dvcmpw.gtu(Rss32,#u7)",ATTRIBS(), +"Compare elements of two vectors ", +{ + fSETBITS(3,0,PdV,(fGETUWORD(0,RssV)>fCAST4u(uiV))); + fSETBITS(7,4,PdV,(fGETUWORD(1,RssV)>fCAST4u(uiV))); +}) + +Q6INSN(A4_boundscheck_hi,"Pd4=3Dboundscheck(Rss32,Rtt32):raw:hi",ATTRIBS(), +"Detect if a register is within bounds", +{ + fHIDE(size4u_t src;) + src =3D fGETUWORD(1,RssV); + PdV =3D f8BITSOF((fCAST4u(src) >=3D fGETUWORD(0,RttV)) && (fCAST4u(src) <= fGETUWORD(1,RttV))); +}) + +Q6INSN(A4_boundscheck_lo,"Pd4=3Dboundscheck(Rss32,Rtt32):raw:lo",ATTRIBS(), +"Detect if a register is within bounds", +{ + fHIDE(size4u_t src;) + src =3D fGETUWORD(0,RssV); + PdV =3D f8BITSOF((fCAST4u(src) >=3D fGETUWORD(0,RttV)) && (fCAST4u(src) <= fGETUWORD(1,RttV))); +}) + +DEF_V4_COND_MAPPING(A4_boundscheck,"Pd4=3Dboundscheck(Rs32,Rtt32)","Rs32 &= 1","Pd4=3Dboundscheck(Rss32,Rtt32):raw:hi","Pd4=3Dboundscheck(Rss32,Rtt32)= :raw:lo") + +Q6INSN(A4_tlbmatch,"Pd4=3Dtlbmatch(Rss32,Rt32)",ATTRIBS(A_NOTE_LATEPRED,A_= RESTRICT_LATEPRED), +"Detect if a VA/ASID matches a TLB entry", +{ + fHIDE(size4u_t TLBHI; size4u_t TLBLO; size4u_t MASK; size4u_t SIZE;) + MASK =3D 0x07ffffff; + TLBLO =3D fGETUWORD(0,RssV); + TLBHI =3D fGETUWORD(1,RssV); + SIZE =3D fMIN(6,fCL1_4(~fBREV_4(TLBLO))); + MASK &=3D (0xffffffff << 2*SIZE); + PdV =3D f8BITSOF(fGETBIT(31,TLBHI) && ((TLBHI & MASK) =3D=3D (RtV & MASK)= )); + fHIDE(MARK_LATE_PRED_WRITE(PdN)) +}) + +Q6INSN(C2_tfrpr,"Rd32=3DPs4",ATTRIBS(), +"Transfer predicate to general register", { fPREDUSE_TIMING();RdV =3D fZXT= N(8,32,PsV); }) + +Q6INSN(C2_tfrrp,"Pd4=3DRs32",ATTRIBS(), +"Transfer general register to Predicate", { PdV =3D fGETUBYTE(0,RsV); }) + +Q6INSN(C4_fastcorner9,"Pd4=3Dfastcorner9(Ps4,Pt4)",ATTRIBS(A_CRSLOT23,A_NO= TE_CRSLOT23), +"Determine whether the predicate sources define a corner", +{ fPREDUSE_TIMING(); + fHIDE(size4u_t tmp =3D 0; size4u_t i;) + fSETHALF(0,tmp,(PsV<<8)|PtV); + fSETHALF(1,tmp,(PsV<<8)|PtV); + for (i =3D 1; i < 9; i++) { + tmp &=3D tmp >> 1; + } + PdV =3D f8BITSOF(tmp !=3D 0); +}) + +Q6INSN(C4_fastcorner9_not,"Pd4=3D!fastcorner9(Ps4,Pt4)",ATTRIBS(A_CRSLOT23= ,A_NOTE_CRSLOT23), +"Determine whether the predicate sources define a corner", +{ + fPREDUSE_TIMING(); + fHIDE(size4u_t tmp =3D 0; size4u_t i;) + fSETHALF(0,tmp,(PsV<<8)|PtV); + fSETHALF(1,tmp,(PsV<<8)|PtV); + for (i =3D 1; i < 9; i++) { + tmp &=3D tmp >> 1; + } + PdV =3D f8BITSOF(tmp =3D=3D 0); +}) + + diff --git a/target/hexagon/imported/float.idef b/target/hexagon/imported/f= loat.idef new file mode 100644 index 0000000..ee9e940 --- /dev/null +++ b/target/hexagon/imported/float.idef @@ -0,0 +1,498 @@ +/* + * Copyright(c) 2019-2020 Qualcomm Innovation Center, Inc. All Rights Res= erved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +/* + * Floating-Point Instructions + */ + +/*************************************/ +/* Scalar FP */ +/*************************************/ +Q6INSN(F2_sfadd,"Rd32=3Dsfadd(Rs32,Rt32)",ATTRIBS(), +"Floating-Point Add", +{ RdV=3DfUNFLOAT(fFLOAT(RsV)+fFLOAT(RtV));}) + +Q6INSN(F2_sfsub,"Rd32=3Dsfsub(Rs32,Rt32)",ATTRIBS(), +"Floating-Point Subtract", +{ RdV=3DfUNFLOAT(fFLOAT(RsV)-fFLOAT(RtV));}) + +Q6INSN(F2_sfmpy,"Rd32=3Dsfmpy(Rs32,Rt32)",ATTRIBS(), +"Floating-Point Multiply", +{ RdV=3DfUNFLOAT(fSFMPY(fFLOAT(RsV),fFLOAT(RtV)));}) + +Q6INSN(F2_sffma,"Rx32+=3Dsfmpy(Rs32,Rt32)",ATTRIBS(), +"Floating-Point Fused Multiply Add", +{ RxV=3DfUNFLOAT(fFMAF(fFLOAT(RsV),fFLOAT(RtV),fFLOAT(RxV)));}) + +Q6INSN(F2_sffma_sc,"Rx32+=3Dsfmpy(Rs32,Rt32,Pu4):scale",ATTRIBS(), +"Floating-Point Fused Multiply Add w/ Additional Scaling (2**Pu)", +{ + fPREDUSE_TIMING(); + fHIDE(size4s_t tmp;) + fCHECKSFNAN3(RxV,RxV,RsV,RtV); + tmp=3DfUNFLOAT(fFMAFX(fFLOAT(RsV),fFLOAT(RtV),fFLOAT(RxV),PuV)); + if (!((fFLOAT(RxV) =3D=3D 0.0) && fISZEROPROD(fFLOAT(RsV),fFLOAT(RtV)))) = RxV =3D tmp; +}) + +Q6INSN(F2_sffms,"Rx32-=3Dsfmpy(Rs32,Rt32)",ATTRIBS(), +"Floating-Point Fused Multiply Add", +{ RxV=3DfUNFLOAT(fFMAF(-fFLOAT(RsV),fFLOAT(RtV),fFLOAT(RxV))); }) + +Q6INSN(F2_sffma_lib,"Rx32+=3Dsfmpy(Rs32,Rt32):lib",ATTRIBS(), +"Floating-Point Fused Multiply Add for Library Routines", +{ fFPSETROUND_NEAREST(); fHIDE(int infinp; int infminusinf; size4s_t tmp;) + infminusinf =3D ((isinf(fFLOAT(RxV))) && + (fISINFPROD(fFLOAT(RsV),fFLOAT(RtV))) && + (fGETBIT(31,RsV ^ RxV ^ RtV) !=3D 0)); + infinp =3D (isinf(fFLOAT(RxV))) || (isinf(fFLOAT(RtV))) || (isinf(fFLOAT(= RsV))); + fCHECKSFNAN3(RxV,RxV,RsV,RtV); + tmp=3DfUNFLOAT(fFMAF(fFLOAT(RsV),fFLOAT(RtV),fFLOAT(RxV))); + if (!((fFLOAT(RxV) =3D=3D 0.0) && fISZEROPROD(fFLOAT(RsV),fFLOAT(RtV)))) = RxV =3D tmp; + fFPCANCELFLAGS(); + if (isinf(fFLOAT(RxV)) && !infinp) RxV =3D RxV - 1; + if (infminusinf) RxV =3D 0; +}) + +Q6INSN(F2_sffms_lib,"Rx32-=3Dsfmpy(Rs32,Rt32):lib",ATTRIBS(), +"Floating-Point Fused Multiply Add for Library Routines", +{ fFPSETROUND_NEAREST(); fHIDE(int infinp; int infminusinf; size4s_t tmp;) + infminusinf =3D ((isinf(fFLOAT(RxV))) && + (fISINFPROD(fFLOAT(RsV),fFLOAT(RtV))) && + (fGETBIT(31,RsV ^ RxV ^ RtV) =3D=3D 0)); + infinp =3D (isinf(fFLOAT(RxV))) || (isinf(fFLOAT(RtV))) || (isinf(fFLOAT(= RsV))); + fCHECKSFNAN3(RxV,RxV,RsV,RtV); + tmp=3DfUNFLOAT(fFMAF(-fFLOAT(RsV),fFLOAT(RtV),fFLOAT(RxV))); + if (!((fFLOAT(RxV) =3D=3D 0.0) && fISZEROPROD(fFLOAT(RsV),fFLOAT(RtV)))) = RxV =3D tmp; + fFPCANCELFLAGS(); + if (isinf(fFLOAT(RxV)) && !infinp) RxV =3D RxV - 1; + if (infminusinf) RxV =3D 0; +}) + + +Q6INSN(F2_sfcmpeq,"Pd4=3Dsfcmp.eq(Rs32,Rt32)",ATTRIBS(), +"Floating Point Compare for Equal", +{PdV=3Df8BITSOF(fFLOAT(RsV)=3D=3DfFLOAT(RtV));}) + +Q6INSN(F2_sfcmpgt,"Pd4=3Dsfcmp.gt(Rs32,Rt32)",ATTRIBS(), +"Floating-Point Compare for Greater Than", +{PdV=3Df8BITSOF(fFLOAT(RsV)>fFLOAT(RtV));}) + +/* cmpge is not the same as !cmpgt(swapops) in IEEE */ + +Q6INSN(F2_sfcmpge,"Pd4=3Dsfcmp.ge(Rs32,Rt32)",ATTRIBS(), +"Floating-Point Compare for Greater Than / Equal To", +{PdV=3Df8BITSOF(fFLOAT(RsV)>=3DfFLOAT(RtV));}) + +/* Everyone seems to have this... */ + +Q6INSN(F2_sfcmpuo,"Pd4=3Dsfcmp.uo(Rs32,Rt32)",ATTRIBS(), +"Floating-Point Compare for Unordered", +{PdV=3Df8BITSOF(isunordered(fFLOAT(RsV),fFLOAT(RtV)));}) + + +Q6INSN(F2_sfmax,"Rd32=3Dsfmax(Rs32,Rt32)",ATTRIBS(), +"Maximum of Floating-Point values", +{ RdV =3D fUNFLOAT(fSF_MAX(fFLOAT(RsV),fFLOAT(RtV))); }) + +Q6INSN(F2_sfmin,"Rd32=3Dsfmin(Rs32,Rt32)",ATTRIBS(), +"Minimum of Floating-Point values", +{ RdV =3D fUNFLOAT(fSF_MIN(fFLOAT(RsV),fFLOAT(RtV))); }) + + +Q6INSN(F2_sfclass,"Pd4=3Dsfclass(Rs32,#u5)",ATTRIBS(), +"Classify Floating-Point Value", +{ + fHIDE(int class;) + PdV =3D 0; + class =3D fpclassify(fFLOAT(RsV)); + /* Is the value zero? */ + if (fGETBIT(0,uiV) && (class =3D=3D FP_ZERO)) PdV =3D 0xff; + if (fGETBIT(1,uiV) && (class =3D=3D FP_NORMAL)) PdV =3D 0xff; + if (fGETBIT(2,uiV) && (class =3D=3D FP_SUBNORMAL)) PdV =3D 0xff; + if (fGETBIT(3,uiV) && (class =3D=3D FP_INFINITE)) PdV =3D 0xff; + if (fGETBIT(4,uiV) && (class =3D=3D FP_NAN)) PdV =3D 0xff; + fFPCANCELFLAGS(); +}) + +/* Range: +/- (1.0 .. 1+(63/64)) * 2**(-6 .. +9) */ +/* More immediate bits should probably be used for more precision? */ + +Q6INSN(F2_sfimm_p,"Rd32=3Dsfmake(#u10):pos",ATTRIBS(A_SFMAKE), +"Make Floating Point Value", +{ + RdV =3D (127 - 6) << 23; + RdV +=3D uiV << 17; +}) + +Q6INSN(F2_sfimm_n,"Rd32=3Dsfmake(#u10):neg",ATTRIBS(A_SFMAKE), +"Make Floating Point Value", +{ + RdV =3D (127 - 6) << 23; + RdV +=3D (uiV << 17); + RdV |=3D (1 << 31); +}) + + +Q6INSN(F2_sfdivcheat,"Rd32=3Dsfdivcheat(Rs32,Rt32)",ATTRIBS(A_FAKEINSN), +"Cheating Instruction for Divide Testing", +{ + RdV =3D fUNFLOAT(fFLOAT(RsV) / fFLOAT(RtV)); +}) + +Q6INSN(F2_sfrecipa,"Rd32,Pe4=3Dsfrecipa(Rs32,Rt32)",ATTRIBS(A_NOTE_COMPAT_= ACCURACY,A_RESTRICT_LATEPRED,A_NOTE_LATEPRED), +"Reciprocal Approximation for Division", +{ + fHIDE(int idx;) + fHIDE(int adjust;) + fHIDE(int mant;) + fHIDE(int exp;) + if (fSF_RECIP_COMMON(RsV,RtV,RdV,adjust)) { + PeV =3D adjust; + idx =3D (RtV >> 16) & 0x7f; + mant =3D (fSF_RECIP_LOOKUP(idx) << 15) | 1; + exp =3D fSF_BIAS() - (fSF_GETEXP(RtV) - fSF_BIAS()) - 1; + RdV =3D fMAKESF(fGETBIT(31,RtV),exp,mant); + } +}) + +Q6INSN(F2_sffixupn,"Rd32=3Dsffixupn(Rs32,Rt32)",ATTRIBS(), +"Fix Up Numerator", +{ + fHIDE(int adjust;) + fSF_RECIP_COMMON(RsV,RtV,RdV,adjust); + RdV =3D RsV; +}) + +Q6INSN(F2_sffixupd,"Rd32=3Dsffixupd(Rs32,Rt32)",ATTRIBS(), +"Fix Up Denominator", +{ + fHIDE(int adjust;) + fSF_RECIP_COMMON(RsV,RtV,RdV,adjust); + RdV =3D RtV; +}) + +Q6INSN(F2_sfinvsqrta,"Rd32,Pe4=3Dsfinvsqrta(Rs32)",ATTRIBS(A_NOTE_COMPAT_A= CCURACY,A_NOTE_LATEPRED,A_RESTRICT_LATEPRED), +"Reciprocal Square Root Approximation", +{ + fHIDE(int idx;) + fHIDE(int adjust;) + fHIDE(int mant;) + fHIDE(int exp;) + if (fSF_INVSQRT_COMMON(RsV,RdV,adjust)) { + PeV =3D adjust; + idx =3D (RsV >> 17) & 0x7f; + mant =3D (fSF_INVSQRT_LOOKUP(idx) << 15); + exp =3D fSF_BIAS() - ((fSF_GETEXP(RsV) - fSF_BIAS()) >> 1) - 1; + RdV =3D fMAKESF(fGETBIT(31,RsV),exp,mant); + } +}) + +Q6INSN(F2_sffixupr,"Rd32=3Dsffixupr(Rs32)",ATTRIBS(), +"Fix Up Radicand", +{ + fHIDE(int adjust;) + fSF_INVSQRT_COMMON(RsV,RdV,adjust); + RdV =3D RsV; +}) + +Q6INSN(F2_sfsqrtcheat,"Rd32=3Dsfsqrtcheat(Rs32)",ATTRIBS(A_FAKEINSN), +"Cheating instruction for SQRT Testing", +{ + RdV =3D fUNFLOAT(sqrtf(fFLOAT(RsV))); +}) + +/*************************************/ +/* Scalar DP */ +/*************************************/ +Q6INSN(F2_dfadd,"Rdd32=3Ddfadd(Rss32,Rtt32)",ATTRIBS(), +"Floating-Point Add", +{ RddV=3DfUNDOUBLE(fDOUBLE(RssV)+fDOUBLE(RttV));}) + +Q6INSN(F2_dfsub,"Rdd32=3Ddfsub(Rss32,Rtt32)",ATTRIBS(), +"Floating-Point Subtract", +{ RddV=3DfUNDOUBLE(fDOUBLE(RssV)-fDOUBLE(RttV));}) + +Q6INSN(F2_dfmax,"Rdd32=3Ddfmax(Rss32,Rtt32)",ATTRIBS(), +"Maximum of Floating-Point values", +{ RddV =3D fUNDOUBLE(fDF_MAX(fDOUBLE(RssV),fDOUBLE(RttV))); }) + +Q6INSN(F2_dfmin,"Rdd32=3Ddfmin(Rss32,Rtt32)",ATTRIBS(), +"Minimum of Floating-Point values", +{ RddV =3D fUNDOUBLE(fDF_MIN(fDOUBLE(RssV),fDOUBLE(RttV))); }) + +Q6INSN(F2_dfmpyfix,"Rdd32=3Ddfmpyfix(Rss32,Rtt32)",ATTRIBS(), +"Fix Up Multiplicand for Multiplication", +{ + if (fDF_ISDENORM(RssV) && fDF_ISBIG(RttV) && fDF_ISNORMAL(RttV)) RddV =3D= fUNDOUBLE(fDOUBLE(RssV) * 0x1.0p52); + else if (fDF_ISDENORM(RttV) && fDF_ISBIG(RssV) && fDF_ISNORMAL(RssV)) Rdd= V =3D fUNDOUBLE(fDOUBLE(RssV) * 0x1.0p-52); + else RddV =3D RssV; +}) + +Q6INSN(F2_dfmpyll,"Rdd32=3Ddfmpyll(Rss32,Rtt32)",ATTRIBS(), +"Multiply low*low and shift off low 32 bits into sticky (in MSB)", +{ + fHIDE(size8u_t prod;) + prod =3D fMPY32UU(fGETUWORD(0,RssV),fGETUWORD(0,RttV)); + RddV =3D (prod >> 32) << 1; + if (fGETUWORD(0,prod) !=3D 0) fSETBIT(0,RddV,1); +}) + +Q6INSN(F2_dfmpylh,"Rxx32+=3Ddfmpylh(Rss32,Rtt32)",ATTRIBS(), +"Multiply low*high and accumulate", +{ + RxxV +=3D (fGETUWORD(0,RssV) * (0x00100000 | fZXTN(20,64,fGETUWORD(1,RttV= )))) << 1; +}) + +Q6INSN(F2_dfmpyhh,"Rxx32+=3Ddfmpyhh(Rss32,Rtt32)",ATTRIBS(), +"Multiply high*high and accumulate with L*H value", +{ + RxxV =3D fUNDOUBLE(fDF_MPY_HH(fDOUBLE(RssV),fDOUBLE(RttV),RxxV)); +}) + + + +#ifdef ADD_DP_OPS +Q6INSN(F2_dfmpy,"Rdd32=3Ddfmpy(Rss32,Rtt32)",ATTRIBS(A_FAKEINSN), +"Floating-Point Multiply", +{ FLATENCY(4);RddV=3DfUNDOUBLE(fDFMPY(fDOUBLE(RssV),fDOUBLE(RttV)));}) + +Q6INSN(F2_dffma,"Rxx32+=3Ddfmpy(Rss32,Rtt32)",ATTRIBS(A_FAKEINSN), +"Floating-Point Fused Multiply Add", +{ FLATENCY(5);RxxV=3DfUNDOUBLE(fFMA(fDOUBLE(RssV),fDOUBLE(RttV),fDOUBLE(Rx= xV)));}) + +Q6INSN(F2_dffms,"Rxx32-=3Ddfmpy(Rss32,Rtt32)",ATTRIBS(A_FAKEINSN), +"Floating-Point Fused Multiply Add", +{ FLATENCY(5);RxxV=3DfUNDOUBLE(fFMA(-fDOUBLE(RssV),fDOUBLE(RttV),fDOUBLE(R= xxV)));}) + +Q6INSN(F2_dffma_lib,"Rxx32+=3Ddfmpy(Rss32,Rtt32):lib",ATTRIBS(A_FAKEINSN), +"Floating-Point Fused Multiply Add for Library Routines", +{ FLATENCY(5);fFPSETROUND_NEAREST(); fHIDE(int infinp; int infminusinf;) + infinp =3D (isinf(fDOUBLE(RxxV))) || (isinf(fDOUBLE(RttV))) || (isinf(fD= OUBLE(RssV))); + infminusinf =3D ((isinf(fDOUBLE(RxxV))) && + (fISINFPROD(fDOUBLE(RssV),fDOUBLE(RttV))) && + (fGETBIT(63,RssV ^ RxxV ^ RttV) !=3D 0)); + fCHECKDFNAN3(RxxV,RxxV,RssV,RttV); + if ((fDOUBLE(RssV) !=3D 0.0) && (fDOUBLE(RttV) !=3D 0.0)) { + RxxV=3DfUNDOUBLE(fFMA(fDOUBLE(RssV),fDOUBLE(RttV),fDOUBLE(RxxV))); + } else { + if (isinf(fDOUBLE(RssV)) || isinf(fDOUBLE(RttV))) RxxV =3D fDFNANVAL(); + } + fFPCANCELFLAGS(); + if (isinf(fDOUBLE(RxxV)) && !infinp) RxxV =3D RxxV - 1; + if (infminusinf) RxxV =3D 0; +}) + + +Q6INSN(F2_dffms_lib,"Rxx32-=3Ddfmpy(Rss32,Rtt32):lib",ATTRIBS(A_FAKEINSN), +"Floating-Point Fused Multiply Add for Library Routines", +{ FLATENCY(5); fFPSETROUND_NEAREST(); fHIDE(int infinp; int infminusinf;) + infinp =3D (isinf(fDOUBLE(RxxV))) || (isinf(fDOUBLE(RttV))) || (isinf(fD= OUBLE(RssV))); + infminusinf =3D ((isinf(fDOUBLE(RxxV))) && + (fISINFPROD(fDOUBLE(RssV),fDOUBLE(RttV))) && + (fGETBIT(63,RssV ^ RxxV ^ RttV) =3D=3D 0)); + fCHECKDFNAN3(RxxV,RxxV,RssV,RttV); + if ((fDOUBLE(RssV) !=3D 0.0) && (fDOUBLE(RttV) !=3D 0.0)) { + RxxV=3DfUNDOUBLE(fFMA(-fDOUBLE(RssV),fDOUBLE(RttV),fDOUBLE(RxxV))); + } else { + if (isinf(fDOUBLE(RssV)) || isinf(fDOUBLE(RttV))) RxxV =3D fDFNANVAL(); + } + fFPCANCELFLAGS(); + if (isinf(fDOUBLE(RxxV)) && !infinp) RxxV =3D RxxV - 1; + if (infminusinf) RxxV =3D 0; +}) + + +Q6INSN(F2_dffma_sc,"Rxx32+=3Ddfmpy(Rss32,Rtt32,Pu4):scale",ATTRIBS(A_FAKEI= NSN), +"Floating-Point Fused Multiply Add w/ Additional Scaling (2**(4*Pu))", +{ FLATENCY(5); + fHIDE(size8s_t tmp;) + fCHECKDFNAN3(RxxV,RxxV,RssV,RttV); + tmp=3DfUNDOUBLE(fFMAX(fDOUBLE(RssV),fDOUBLE(RttV),fDOUBLE(RxxV),PuV)); + if ((fDOUBLE(tmp) !=3D fDOUBLE(RxxV)) || ((fDOUBLE(RssV) !=3D 0.0) && (f= DOUBLE(RttV) !=3D 0.0))) RxxV =3D tmp; +}) + +#endif + +Q6INSN(F2_dfcmpeq,"Pd4=3Ddfcmp.eq(Rss32,Rtt32)",ATTRIBS(), +"Floating Point Compare for Equal", +{PdV=3Df8BITSOF(fDOUBLE(RssV)=3D=3DfDOUBLE(RttV));}) + +Q6INSN(F2_dfcmpgt,"Pd4=3Ddfcmp.gt(Rss32,Rtt32)",ATTRIBS(), +"Floating-Point Compare for Greater Than", +{PdV=3Df8BITSOF(fDOUBLE(RssV)>fDOUBLE(RttV));}) + + +/* cmpge is not the same as !cmpgt(swapops) in IEEE */ + +Q6INSN(F2_dfcmpge,"Pd4=3Ddfcmp.ge(Rss32,Rtt32)",ATTRIBS(), +"Floating-Point Compare for Greater Than / Equal To", +{PdV=3Df8BITSOF(fDOUBLE(RssV)>=3DfDOUBLE(RttV));}) + +/* Everyone seems to have this... */ + +Q6INSN(F2_dfcmpuo,"Pd4=3Ddfcmp.uo(Rss32,Rtt32)",ATTRIBS(), +"Floating-Point Compare for Unordered", +{PdV=3Df8BITSOF(isunordered(fDOUBLE(RssV),fDOUBLE(RttV)));}) + + +Q6INSN(F2_dfclass,"Pd4=3Ddfclass(Rss32,#u5)",ATTRIBS(), +"Classify Floating-Point Value", +{ + fHIDE(int class;) + PdV =3D 0; + class =3D fpclassify(fDOUBLE(RssV)); + /* Is the value zero? */ + if (fGETBIT(0,uiV) && (class =3D=3D FP_ZERO)) PdV =3D 0xff; + if (fGETBIT(1,uiV) && (class =3D=3D FP_NORMAL)) PdV =3D 0xff; + if (fGETBIT(2,uiV) && (class =3D=3D FP_SUBNORMAL)) PdV =3D 0xff; + if (fGETBIT(3,uiV) && (class =3D=3D FP_INFINITE)) PdV =3D 0xff; + if (fGETBIT(4,uiV) && (class =3D=3D FP_NAN)) PdV =3D 0xff; + fFPCANCELFLAGS(); +}) + + +/* Range: +/- (1.0 .. 1+(63/64)) * 2**(-6 .. +9) */ +/* More immediate bits should probably be used for more precision? */ + +Q6INSN(F2_dfimm_p,"Rdd32=3Ddfmake(#u10):pos",ATTRIBS(A_DFMAKE), +"Make Floating Point Value", +{ + RddV =3D (1023ULL - 6) << 52; + RddV +=3D (fHIDE((size8u_t))uiV) << 46; +}) + +Q6INSN(F2_dfimm_n,"Rdd32=3Ddfmake(#u10):neg",ATTRIBS(A_DFMAKE), +"Make Floating Point Value", +{ + RddV =3D (1023ULL - 6) << 52; + RddV +=3D (fHIDE((size8u_t))uiV) << 46; + RddV |=3D ((1ULL) << 63); +}) + + +#ifdef ADD_DP_OPS +Q6INSN(F2_dfdivcheat,"Rdd32=3Ddfdivcheat(Rss32,Rtt32)",ATTRIBS(A_FAKEINSN), +"Cheating Instruction for Divide Testing", +{ + RddV =3D fUNDOUBLE(fDOUBLE(RssV) / fDOUBLE(RttV)); +}) + + +Q6INSN(F2_dfrecipa,"Rdd32,Pe4=3Ddfrecipa(Rss32,Rtt32)",ATTRIBS(A_NOTE_COMP= AT_ACCURACY,A_FAKEINSN), +"Reciprocal Approximation for Division", +{ + fHIDE(int idx;) + fHIDE(int adjust;) + fHIDE(size8s_t mant;) + fHIDE(int exp;) + if (fDF_RECIP_COMMON(RssV,RttV,RddV,adjust)) { + PeV =3D adjust; + idx =3D (RttV >> 45) & 0x7f; + mant =3D (fDF_RECIP_LOOKUP(idx) << 44) | 1; + exp =3D fDF_BIAS() - (fDF_GETEXP(RttV) - fDF_BIAS()) - 1; + RddV =3D fMAKEDF(fGETBIT(63,RttV),exp,mant); + } +}) + +Q6INSN(F2_dffixupn,"Rdd32=3Ddffixupn(Rss32,Rtt32)",ATTRIBS(A_FAKEINSN), +"Fix Up Numerator", +{ + fHIDE(int adjust;) + fDF_RECIP_COMMON(RssV,RttV,RddV,adjust); + RddV =3D RssV; +}) + +Q6INSN(F2_dffixupd,"Rdd32=3Ddffixupd(Rss32,Rtt32)",ATTRIBS(A_FAKEINSN), +"Fix Up Denominator", +{ + fHIDE(int adjust;) + fDF_RECIP_COMMON(RssV,RttV,RddV,adjust); + RddV =3D RttV; +}) + + + + +Q6INSN(F2_dfinvsqrta,"Rdd32,Pe4=3Ddfinvsqrta(Rss32)",ATTRIBS(A_NOTE_COMPAT= _ACCURACY,A_FAKEINSN), +"Reciprocal Approximation for Division", +{ + fHIDE(int idx;) + fHIDE(int adjust;) + fHIDE(size8u_t mant;) + fHIDE(int exp;) + if (fDF_INVSQRT_COMMON(RssV,RddV,adjust)) { + PeV =3D adjust; + idx =3D (RssV >> 46) & 0x7f; + mant =3D (fDF_INVSQRT_LOOKUP(idx) << 44); + exp =3D fDF_BIAS() - ((fDF_GETEXP(RssV) - fDF_BIAS()) >> 1) - 1; + RddV =3D fMAKEDF(fGETBIT(63,RssV),exp,mant); + } +}) + +Q6INSN(F2_dffixupr,"Rdd32=3Ddffixupr(Rss32)",ATTRIBS(A_FAKEINSN), +"Fix Up Radicand", +{ + fHIDE(int adjust;) + fDF_INVSQRT_COMMON(RssV,RddV,adjust); + RddV =3D RssV; +}) + +Q6INSN(F2_dfsqrtcheat,"Rdd32=3Ddfsqrtcheat(Rss32)",ATTRIBS(A_FAKEINSN), +"Cheating instruction for SQRT Testing", +{ + RddV =3D fUNDOUBLE(sqrt(fDOUBLE(RssV))); +}) +#endif + + + + + +/* CONVERSION */ + +#define CONVERT(TAG,DEST,DESTV,SRC,SRCV,OUTCAST,OUTTYPE,INCAST,INTYPE,MODE= TAG,MODESYN,MODEBEH) \ + Q6INSN(F2_conv_##TAG##MODETAG,#DEST"=3Dconvert_"#TAG"("#SRC")"#MODESYN= ,ATTRIBS(), \ + "Floating point format conversion", \ + { MODEBEH DESTV =3D OUTCAST(conv_##INTYPE##_to_##OUTTYPE(INCAST(SRCV))= ); }) + +CONVERT(sf2df,Rdd32,RddV,Rs32,RsV,fUNDOUBLE,df,fFLOAT,sf,,,) +CONVERT(df2sf,Rd32,RdV,Rss32,RssV,fUNFLOAT,sf,fDOUBLE,df,,,) + +#define ALLINTDST(TAGSTART,SRC,SRCV,INCAST,INTYPE,MODETAG,MODESYN,MODEBEH)= \ +CONVERT(TAGSTART##uw,Rd32,RdV,SRC,SRCV,fCAST4u,4u,INCAST,INTYPE,MODETAG,MO= DESYN,MODEBEH) \ +CONVERT(TAGSTART##w,Rd32,RdV,SRC,SRCV,fCAST4s,4s,INCAST,INTYPE,MODETAG,MOD= ESYN,MODEBEH) \ +CONVERT(TAGSTART##ud,Rdd32,RddV,SRC,SRCV,fCAST8u,8u,INCAST,INTYPE,MODETAG,= MODESYN,MODEBEH) \ +CONVERT(TAGSTART##d,Rdd32,RddV,SRC,SRCV,fCAST8s,8s,INCAST,INTYPE,MODETAG,M= ODESYN,MODEBEH) + +#define ALLFPDST(TAGSTART,SRC,SRCV,INCAST,INTYPE,MODETAG,MODESYN,MODEBEH) \ +CONVERT(TAGSTART##sf,Rd32,RdV,SRC,SRCV,fUNFLOAT,sf,INCAST,INTYPE,MODETAG,M= ODESYN,MODEBEH) \ +CONVERT(TAGSTART##df,Rdd32,RddV,SRC,SRCV,fUNDOUBLE,df,INCAST,INTYPE,MODETA= G,MODESYN,MODEBEH) + +#define ALLINTSRC(GEN,MODETAG,MODESYN,MODEBEH) \ +GEN(uw##2,Rs32,RsV,fCAST4u,4u,MODETAG,MODESYN,MODEBEH) \ +GEN(w##2,Rs32,RsV,fCAST4s,4s,MODETAG,MODESYN,MODEBEH) \ +GEN(ud##2,Rss32,RssV,fCAST8u,8u,MODETAG,MODESYN,MODEBEH) \ +GEN(d##2,Rss32,RssV,fCAST8s,8s,MODETAG,MODESYN,MODEBEH) + +#define ALLFPSRC(GEN,MODETAG,MODESYN,MODEBEH) \ +GEN(sf##2,Rs32,RsV,fFLOAT,sf,MODETAG,MODESYN,MODEBEH) \ +GEN(df##2,Rss32,RssV,fDOUBLE,df,MODETAG,MODESYN,MODEBEH) + +ALLINTSRC(ALLFPDST,,,) +ALLFPSRC(ALLINTDST,,,) +ALLFPSRC(ALLINTDST,_chop,:chop,fFPSETROUND_CHOP();) + diff --git a/target/hexagon/imported/ldst.idef b/target/hexagon/imported/ld= st.idef new file mode 100644 index 0000000..2b03bbc --- /dev/null +++ b/target/hexagon/imported/ldst.idef @@ -0,0 +1,421 @@ +/* + * Copyright(c) 2019-2020 Qualcomm Innovation Center, Inc. All Rights Res= erved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +/* + * Load and Store instruction definitions + */ + +#define FRAME_EXPLICIT 1 + +/* The set of addressing modes standard to all Load instructions */ +#define STD_LD_AMODES(TAG,OPER,DESCR,ATTRIB,SHFT,SEMANTICS,SCALE)\ +Q6INSN(L2_##TAG##_io, OPER"(Rs32+#s11:"SHFT")", ATTRIB,DESCR,{fI= MMEXT(siV); fEA_RI(RsV,siV); SEMANTICS; })\ +Q6INSN(L4_##TAG##_ur, OPER"(Rt32<<#u2+#U6)", ATTRIB,DESCR,{fM= UST_IMMEXT(UiV); fEA_IRs(UiV,RtV,uiV); SEMANTICS;})\ +Q6INSN(L4_##TAG##_ap, OPER"(Re32=3D#U6)", ATTRIB,DESCR,{= fMUST_IMMEXT(UiV); fEA_IMM(UiV); SEMANTICS; ReV=3DUiV; })\ +Q6INSN(L2_##TAG##_pr, OPER"(Rx32++Mu2)", ATTRIB,DESCR,{fE= A_REG(RxV); fPM_M(RxV,MuV); SEMANTICS;})\ +Q6INSN(L2_##TAG##_pbr, OPER"(Rx32++Mu2:brev)", ATTRIB,DESCR,{fE= A_BREVR(RxV); fPM_M(RxV,MuV); SEMANTICS;})\ +Q6INSN(L2_##TAG##_pi, OPER"(Rx32++#s4:"SHFT")", ATTRIB,DESCR,{fE= A_REG(RxV); fPM_I(RxV,siV); SEMANTICS;})\ +Q6INSN(L2_##TAG##_pci, OPER"(Rx32++#s4:"SHFT":circ(Mu2))",ATTRIB,DESCR,{fE= A_REG(RxV); fPM_CIRI(RxV,siV,MuV); SEMANTICS;})\ +Q6INSN(L2_##TAG##_pcr, OPER"(Rx32++I:circ(Mu2))", ATTRIB,DESCR,{fEA_REG(R= xV); fPM_CIRR(RxV,fREAD_IREG(MuV)<>16)|(tmpV<<48); +},1) + + +STD_LD_AMODES(loadalignb, "Ryy32=3Dmemb_fifo", "Load byte into shifted vec= tor", +ATTRIBS(A_MEMSIZE_1B,A_LOAD),"0", +{ + fHIDE(size8u_t tmpV;) + fLOAD(1,1,u,EA,tmpV); + RyyV =3D (((size8u_t)RyyV)>>8)|(tmpV<<56); +},0) + + + + +/* The set of addressing modes standard to all Store instructions */ +#define STD_ST_AMODES(TAG,DEST,OPER,DESCR,ATTRIB,SHFT,SEMANTICS,SCALE)\ +Q6INSN(S2_##TAG##_io, OPER"(Rs32+#s11:"SHFT")=3D"DEST, ATTRIB,DESCR,{= fIMMEXT(siV); fEA_RI(RsV,siV); SEMANTICS; })\ +Q6INSN(S2_##TAG##_pi, OPER"(Rx32++#s4:"SHFT")=3D"DEST, ATTRIB,DESCR,{= fEA_REG(RxV); fPM_I(RxV,siV); SEMANTICS; })\ +Q6INSN(S4_##TAG##_ap, OPER"(Re32=3D#U6)=3D"DEST, ATTRIB,DESCR= ,{fMUST_IMMEXT(UiV); fEA_IMM(UiV); SEMANTICS; ReV=3DUiV; })\ +Q6INSN(S2_##TAG##_pr, OPER"(Rx32++Mu2)=3D"DEST, ATTRIB,DESCR,{= fEA_REG(RxV); fPM_M(RxV,MuV); SEMANTICS; })\ +Q6INSN(S4_##TAG##_ur, OPER"(Ru32<<#u2+#U6)=3D"DEST, ATTRIB,DES= CR,{fMUST_IMMEXT(UiV); fEA_IRs(UiV,RuV,uiV); SEMANTICS;})\ +Q6INSN(S2_##TAG##_pbr, OPER"(Rx32++Mu2:brev)=3D"DEST, ATTRIB,DESCR,{= fEA_BREVR(RxV); fPM_M(RxV,MuV); SEMANTICS; })\ +Q6INSN(S2_##TAG##_pci, OPER"(Rx32++#s4:"SHFT":circ(Mu2))=3D"DEST, ATTRIB,= DESCR,{fEA_REG(RxV); fPM_CIRI(RxV,siV,MuV); SEMANTICS;})\ +Q6INSN(S2_##TAG##_pcr, OPER"(Rx32++I:circ(Mu2))=3D"DEST, ATTRIB,DESCR,{fE= A_REG(RxV); fPM_CIRR(RxV,fREAD_IREG(MuV)<. + */ + +/* + * Multiply Instructions + */ + + +#define STD_SP_MODES(TAG,OPER,ATR,DST,ACCSEM,SEM,OSEM,SATSEM,RNDSEM,ACCSYN= )\ +Q6INSN(M2_##TAG##_hh_s0, OPER"(Rs.H32,Rt.H32)"OSEM, ATR,"",{DST=3DS= ATSEM(RNDSEM(ACCSEM SEM( fGETHALF(1,RsV),fGETHALF(1,RtV)))); ACCSYN= ;})\ +Q6INSN(M2_##TAG##_hh_s1, OPER"(Rs.H32,Rt.H32):<<1"OSEM, ATR,"",{DST=3DS= ATSEM(RNDSEM(ACCSEM fSCALE(1,SEM(fGETHALF(1,RsV),fGETHALF(1,RtV))))); ACCSY= N;})\ +Q6INSN(M2_##TAG##_hl_s0, OPER"(Rs.H32,Rt.L32)"OSEM, ATR,"",{DST=3DS= ATSEM(RNDSEM(ACCSEM SEM( fGETHALF(1,RsV),fGETHALF(0,RtV)))); ACCSYN= ;})\ +Q6INSN(M2_##TAG##_hl_s1, OPER"(Rs.H32,Rt.L32):<<1"OSEM, ATR,"",{DST=3DS= ATSEM(RNDSEM(ACCSEM fSCALE(1,SEM(fGETHALF(1,RsV),fGETHALF(0,RtV))))); ACCSY= N;})\ +Q6INSN(M2_##TAG##_lh_s0, OPER"(Rs.L32,Rt.H32)"OSEM, ATR,"",{DST=3DS= ATSEM(RNDSEM(ACCSEM SEM( fGETHALF(0,RsV),fGETHALF(1,RtV)))); ACCSYN= ;})\ +Q6INSN(M2_##TAG##_lh_s1, OPER"(Rs.L32,Rt.H32):<<1"OSEM, ATR,"",{DST=3DS= ATSEM(RNDSEM(ACCSEM fSCALE(1,SEM(fGETHALF(0,RsV),fGETHALF(1,RtV))))); ACCSY= N;})\ +Q6INSN(M2_##TAG##_ll_s0, OPER"(Rs.L32,Rt.L32)"OSEM, ATR,"",{DST=3DS= ATSEM(RNDSEM(ACCSEM SEM( fGETHALF(0,RsV),fGETHALF(0,RtV)))); ACCSYN= ;})\ +Q6INSN(M2_##TAG##_ll_s1, OPER"(Rs.L32,Rt.L32):<<1"OSEM, ATR,"",{DST=3DS= ATSEM(RNDSEM(ACCSEM fSCALE(1,SEM(fGETHALF(0,RsV),fGETHALF(0,RtV))))); ACCSY= N;}) + +/*****************************************************/ +/* multiply 16x16->32 signed instructions */ +/*****************************************************/ +STD_SP_MODES(mpy_acc, "Rx32+=3Dmpy", ,RxV,RxV+ ,fMPY16SS, ,= fPASS,fPASS,fACC()) +STD_SP_MODES(mpy_nac, "Rx32-=3Dmpy", ,RxV,RxV- ,fMPY16SS, ,= fPASS,fPASS,fACC()) +STD_SP_MODES(mpy_acc_sat,"Rx32+=3Dmpy", ,RxV,RxV+ ,fMPY16SS,":sat" ,= fSAT, fPASS,fACC()) +STD_SP_MODES(mpy_nac_sat,"Rx32-=3Dmpy", ,RxV,RxV- ,fMPY16SS,":sat" ,= fSAT, fPASS,fACC()) +STD_SP_MODES(mpy, "Rd32=3Dmpy", ,RdV, ,fMPY16SS, ,= fPASS,fPASS,) +STD_SP_MODES(mpy_sat, "Rd32=3Dmpy", ,RdV, ,fMPY16SS,":sat" ,= fSAT, fPASS,) +STD_SP_MODES(mpy_rnd, "Rd32=3Dmpy", ,RdV, ,fMPY16SS,":rnd" ,= fPASS,fROUND,) +STD_SP_MODES(mpy_sat_rnd,"Rd32=3Dmpy", ,RdV, ,fMPY16SS,":rnd:sat",= fSAT, fROUND,) +STD_SP_MODES(mpyd_acc, "Rxx32+=3Dmpy",,RxxV,RxxV+ ,fMPY16SS, ,= fPASS,fPASS,fACC()) +STD_SP_MODES(mpyd_nac, "Rxx32-=3Dmpy",,RxxV,RxxV- ,fMPY16SS, ,= fPASS,fPASS,fACC()) +STD_SP_MODES(mpyd, "Rdd32=3Dmpy", ,RddV, ,fMPY16SS, ,= fPASS,fPASS,) +STD_SP_MODES(mpyd_rnd, "Rdd32=3Dmpy", ,RddV, ,fMPY16SS,":rnd" ,= fPASS,fROUND,) + + +/*****************************************************/ +/* multiply 16x16->32 unsigned instructions */ +/*****************************************************/ +#define STD_USP_MODES(TAG,OPER,ATR,DST,ACCSEM,SEM,OSEM,SATSEM,RNDSEM,ACCSY= N)\ +Q6INSN(M2_##TAG##_hh_s0, OPER"(Rs.H32,Rt.H32)"OSEM, ATR,"",{DST=3DS= ATSEM(RNDSEM(ACCSEM SEM( fGETUHALF(1,RsV),fGETUHALF(1,RtV)))); ACCS= YN;})\ +Q6INSN(M2_##TAG##_hh_s1, OPER"(Rs.H32,Rt.H32):<<1"OSEM, ATR,"",{DST=3DS= ATSEM(RNDSEM(ACCSEM fSCALE(1,SEM(fGETUHALF(1,RsV),fGETUHALF(1,RtV))))); ACC= SYN;})\ +Q6INSN(M2_##TAG##_hl_s0, OPER"(Rs.H32,Rt.L32)"OSEM, ATR,"",{DST=3DS= ATSEM(RNDSEM(ACCSEM SEM( fGETUHALF(1,RsV),fGETUHALF(0,RtV)))); ACCS= YN;})\ +Q6INSN(M2_##TAG##_hl_s1, OPER"(Rs.H32,Rt.L32):<<1"OSEM, ATR,"",{DST=3DS= ATSEM(RNDSEM(ACCSEM fSCALE(1,SEM(fGETUHALF(1,RsV),fGETUHALF(0,RtV))))); ACC= SYN;})\ +Q6INSN(M2_##TAG##_lh_s0, OPER"(Rs.L32,Rt.H32)"OSEM, ATR,"",{DST=3DS= ATSEM(RNDSEM(ACCSEM SEM( fGETUHALF(0,RsV),fGETUHALF(1,RtV))));} ACC= SYN;)\ +Q6INSN(M2_##TAG##_lh_s1, OPER"(Rs.L32,Rt.H32):<<1"OSEM, ATR,"",{DST=3DS= ATSEM(RNDSEM(ACCSEM fSCALE(1,SEM(fGETUHALF(0,RsV),fGETUHALF(1,RtV))))); ACC= SYN;})\ +Q6INSN(M2_##TAG##_ll_s0, OPER"(Rs.L32,Rt.L32)"OSEM, ATR,"",{DST=3DS= ATSEM(RNDSEM(ACCSEM SEM( fGETUHALF(0,RsV),fGETUHALF(0,RtV)))); ACCS= YN;})\ +Q6INSN(M2_##TAG##_ll_s1, OPER"(Rs.L32,Rt.L32):<<1"OSEM, ATR,"",{DST=3DS= ATSEM(RNDSEM(ACCSEM fSCALE(1,SEM(fGETUHALF(0,RsV),fGETUHALF(0,RtV))))); ACC= SYN;}) + +STD_USP_MODES(mpyu_acc, "Rx32+=3Dmpyu", ,RxV,RxV+ ,fMPY16UU, = ,fPASS,fPASS,fACC()) +STD_USP_MODES(mpyu_nac, "Rx32-=3Dmpyu", ,RxV,RxV- ,fMPY16UU, = ,fPASS,fPASS,fACC()) +STD_USP_MODES(mpyu, "Rd32=3Dmpyu", ATTRIBS(A_INTRINSIC_RETURNS_UNS= IGNED) ,RdV, ,fMPY16UU, ,fPASS,fPASS,) +STD_USP_MODES(mpyud_acc, "Rxx32+=3Dmpyu",,RxxV,RxxV+,fMPY16UU, = ,fPASS,fPASS,fACC()) +STD_USP_MODES(mpyud_nac, "Rxx32-=3Dmpyu",,RxxV,RxxV-,fMPY16UU, = ,fPASS,fPASS,fACC()) +STD_USP_MODES(mpyud, "Rdd32=3Dmpyu", ATTRIBS(A_INTRINSIC_RETURNS_UNS= IGNED) ,RddV, ,fMPY16UU, ,fPASS,fPASS,) + +/**********************************************/ +/* mpy 16x#s8->32 */ +/**********************************************/ + +Q6INSN(M2_mpysip,"Rd32=3D+mpyi(Rs32,#u8)",ATTRIBS(A_ARCHV2,A_ROPS_2,A_MPY), +"32-bit Multiply by unsigned immediate", +{ fIMMEXT(uiV); RdV=3DRsV*uiV; }) + +Q6INSN(M2_mpysin,"Rd32=3D-mpyi(Rs32,#u8)",ATTRIBS(A_ARCHV2,A_ROPS_2,A_MPY), +"32-bit Multiply by unsigned immediate, negate result", +{ RdV=3DRsV*-uiV; }) + +DEF_V2_COND_MAPPING(M2_mpysmi,"Rd32=3Dmpyi(Rs32,#m9)","((#m9<0) && (#m9>-2= 56))","Rd32=3D-mpyi(Rs32,#m9*(-1))","Rd32=3D+mpyi(Rs32,#m9)") + +Q6INSN(M2_macsip,"Rx32+=3Dmpyi(Rs32,#u8)",ATTRIBS(A_ARCHV2,A_ROPS_2,A_MPY), +"32-bit Multiply-Add by unsigned immediate", +{ fIMMEXT(uiV); RxV=3DRxV + (RsV*uiV); fACC();}) + +Q6INSN(M2_macsin,"Rx32-=3Dmpyi(Rs32,#u8)",ATTRIBS(A_ARCHV2,A_ROPS_2,A_MPY), +"32-bit Multiply-Subtract by unsigned immediate", +{ fIMMEXT(uiV); RxV=3DRxV - (RsV*uiV); fACC();}) + + +/**********************************************/ +/* multiply/mac 32x32->64 instructions */ +/**********************************************/ +Q6INSN(M2_dpmpyss_s0, "Rdd32=3Dmpy(Rs32,Rt32)", ATTRIBS(A_IT_MPY,A_IT_M= PY_32),"Multiply 32x32",{RddV=3DfMPY32SS(RsV,RtV);}) +Q6INSN(M2_dpmpyss_acc_s0,"Rxx32+=3Dmpy(Rs32,Rt32)",ATTRIBS(A_IT_MPY,A_IT_M= PY_32,A_ROPS_2),"Multiply 32x32",{RxxV=3D RxxV + fMPY32SS(RsV,RtV); fACC();= }) +Q6INSN(M2_dpmpyss_nac_s0,"Rxx32-=3Dmpy(Rs32,Rt32)",ATTRIBS(A_IT_MPY,A_IT_M= PY_32,A_ROPS_2),"Multiply 32x32",{RxxV=3D RxxV - fMPY32SS(RsV,RtV); fACC();= }) + +Q6INSN(M2_dpmpyuu_s0, "Rdd32=3Dmpyu(Rs32,Rt32)", ATTRIBS(A_IT_MPY,A_IT_= MPY_32,A_INTRINSIC_RETURNS_UNSIGNED),"Multiply 32x32",{RddV=3DfMPY32UU(fCAS= T4u(RsV),fCAST4u(RtV));}) +Q6INSN(M2_dpmpyuu_acc_s0,"Rxx32+=3Dmpyu(Rs32,Rt32)",ATTRIBS(A_IT_MPY,A_IT_= MPY_32,A_ROPS_2),"Multiply 32x32",{RxxV=3D RxxV + fMPY32UU(fCAST4u(RsV),fCA= ST4u(RtV)); fACC();}) +Q6INSN(M2_dpmpyuu_nac_s0,"Rxx32-=3Dmpyu(Rs32,Rt32)",ATTRIBS(A_IT_MPY,A_IT_= MPY_32,A_ROPS_2),"Multiply 32x32",{RxxV=3D RxxV - fMPY32UU(fCAST4u(RsV),fCA= ST4u(RtV)); fACC();}) + + +/******************************************************/ +/* multiply/mac 32x32->32 (upper) instructions */ +/******************************************************/ +Q6INSN(M2_mpy_up, "Rd32=3Dmpy(Rs32,Rt32)", ATTRIBS(A_IT_MPY,A_IT_MP= Y_32),"Multiply 32x32",{RdV=3DfMPY32SS(RsV,RtV)>>32;}) +Q6INSN(M2_mpy_up_s1, "Rd32=3Dmpy(Rs32,Rt32):<<1", ATTRIBS(A_IT_MPY,A_I= T_MPY_32),"Multiply 32x32",{RdV=3DfMPY32SS(RsV,RtV)>>31;}) +Q6INSN(M2_mpy_up_s1_sat, "Rd32=3Dmpy(Rs32,Rt32):<<1:sat", ATTRIBS(A_IT_MPY= ,A_IT_MPY_32),"Multiply 32x32",{RdV=3DfSAT(fMPY32SS(RsV,RtV)>>31);}) +Q6INSN(M2_mpyu_up, "Rd32=3Dmpyu(Rs32,Rt32)", ATTRIBS(A_IT_MPY,A_IT_M= PY_32,A_INTRINSIC_RETURNS_UNSIGNED),"Multiply 32x32",{RdV=3DfMPY32UU(fCAST4= u(RsV),fCAST4u(RtV))>>32;}) +Q6INSN(M2_mpysu_up, "Rd32=3Dmpysu(Rs32,Rt32)", ATTRIBS(A_IT_MPY,A_IT_= MPY_32),"Multiply 32x32",{RdV=3DfMPY32SU(RsV,fCAST4u(RtV))>>32;}) +Q6INSN(M2_dpmpyss_rnd_s0,"Rd32=3Dmpy(Rs32,Rt32):rnd", ATTRIBS(A_IT_MPY,A_I= T_MPY_32),"Multiply 32x32",{RdV=3D(fMPY32SS(RsV,RtV)+fCONSTLL(0x80000000))>= >32;}) + +Q6INSN(M4_mac_up_s1_sat, "Rx32+=3Dmpy(Rs32,Rt32):<<1:sat", ATTRIBS(A_IT_MP= Y,A_IT_MPY_32),"Multiply 32x32",{RxV=3DfSAT( (fSE32_64(RxV)) + (fMPY32SS(R= sV,RtV)>>31)); fACC();}) +Q6INSN(M4_nac_up_s1_sat, "Rx32-=3Dmpy(Rs32,Rt32):<<1:sat", ATTRIBS(A_IT_MP= Y,A_IT_MPY_32),"Multiply 32x32",{RxV=3DfSAT( (fSE32_64(RxV)) - (fMPY32SS(R= sV,RtV)>>31)); fACC();}) + + +/**********************************************/ +/* 32x32->32 multiply (lower) */ +/**********************************************/ + +Q6INSN(M2_mpyi,"Rd32=3Dmpyi(Rs32,Rt32)",ATTRIBS(A_IT_MPY,A_IT_MPY_32,A_MPY= ), +"Multiply Integer", +{ RdV=3DRsV*RtV;}) + + + +DEF_MAPPING(M2_mpyui,"Rd32=3Dmpyui(Rs32,Rt32)","Rd32=3Dmpyi(Rs32,Rt32)") + + +Q6INSN(M2_maci,"Rx32+=3Dmpyi(Rs32,Rt32)",ATTRIBS(A_IT_MPY,A_IT_MPY_32,A_AR= CHV2,A_ROPS_2,A_MPY), +"Multiply-Accumulate Integer", +{ RxV=3DRxV + RsV*RtV; fACC();}) + +Q6INSN(M2_mnaci,"Rx32-=3Dmpyi(Rs32,Rt32)",ATTRIBS(A_IT_MPY,A_IT_MPY_32,A_A= RCHV2,A_ROPS_2,A_MPY), +"Multiply-Neg-Accumulate Integer", +{ RxV=3DRxV - RsV*RtV; fACC();}) + +/****** WHY ARE THESE IN MPY.IDEF? **********/ + +Q6INSN(M2_acci,"Rx32+=3Dadd(Rs32,Rt32)",ATTRIBS(A_ROPS_2,A_ARCHV2), +"Add with accumulate", +{ RxV=3DRxV + RsV + RtV;}) + +Q6INSN(M2_accii,"Rx32+=3Dadd(Rs32,#s8)",ATTRIBS(A_ROPS_2,A_ARCHV2), +"Add with accumulate", +{ fIMMEXT(siV); RxV=3DRxV + RsV + siV;}) + +Q6INSN(M2_nacci,"Rx32-=3Dadd(Rs32,Rt32)",ATTRIBS(A_ROPS_2,A_ARCHV2), +"Add with neg accumulate", +{ RxV=3DRxV - (RsV + RtV);}) + +Q6INSN(M2_naccii,"Rx32-=3Dadd(Rs32,#s8)",ATTRIBS(A_ROPS_2,A_ARCHV2), +"Add with neg accumulate", +{ fIMMEXT(siV); RxV=3DRxV - (RsV + siV);}) + +Q6INSN(M2_subacc,"Rx32+=3Dsub(Rt32,Rs32)",ATTRIBS(A_ROPS_2,A_ARCHV2), +"Sub with accumulate", +{ RxV=3DRxV + RtV - RsV;}) + + + + +Q6INSN(M4_mpyrr_addr,"Ry32=3Dadd(Ru32,mpyi(Ry32,Rs32))",ATTRIBS(A_ROPS_2,A= _MPY), +"Mpy by immed and add immed", +{ RyV =3D RuV + RsV*RyV; fACC();}) + +Q6INSN(M4_mpyri_addr_u2,"Rd32=3Dadd(Ru32,mpyi(#u6:2,Rs32))",ATTRIBS(A_ROPS= _2,A_MPY), +"Mpy by immed and add immed", +{ RdV =3D RuV + RsV*uiV; fACC();}) + +Q6INSN(M4_mpyri_addr,"Rd32=3Dadd(Ru32,mpyi(Rs32,#u6))",ATTRIBS(A_ROPS_2,A_= MPY), +"Mpy by immed and add immed", +{ fIMMEXT(uiV); RdV =3D RuV + RsV*uiV; fACC();}) + + + +Q6INSN(M4_mpyri_addi,"Rd32=3Dadd(#u6,mpyi(Rs32,#U6))",ATTRIBS(A_ROPS_2,A_M= PY), +"Mpy by immed and add immed", +{ fIMMEXT(uiV); RdV =3D uiV + RsV*UiV;}) + + + +Q6INSN(M4_mpyrr_addi,"Rd32=3Dadd(#u6,mpyi(Rs32,Rt32))",ATTRIBS(A_ROPS_2,A_= MPY), +"Mpy by immed and add immed", +{ fIMMEXT(uiV); RdV =3D uiV + RsV*RtV;}) + + + + + + + + + + + + + + + + + +/**********************************************/ +/* vector mac 2x[16x16 -> 32] */ +/**********************************************/ + +#undef vmac_sema +#define vmac_sema(N)\ +{ fSETWORD(0,RddV,fSAT(fSCALE(N,fMPY16SS(fGETHALF(0,RsV),fGETHALF(0,RtV)))= ));\ + fSETWORD(1,RddV,fSAT(fSCALE(N,fMPY16SS(fGETHALF(1,RsV),fGETHALF(1,RtV)))= ));\ +} +Q6INSN(M2_vmpy2s_s0,"Rdd32=3Dvmpyh(Rs32,Rt32):sat",ATTRIBS(),"Vector Multi= ply",vmac_sema(0)) +Q6INSN(M2_vmpy2s_s1,"Rdd32=3Dvmpyh(Rs32,Rt32):<<1:sat",ATTRIBS(),"Vector M= ultiply",vmac_sema(1)) + + +#undef vmac_sema +#define vmac_sema(N)\ +{ fSETWORD(0,RxxV,fSAT(fGETWORD(0,RxxV) + fSCALE(N,fMPY16SS(fGETHALF(0,RsV= ),fGETHALF(0,RtV)))));\ + fSETWORD(1,RxxV,fSAT(fGETWORD(1,RxxV) + fSCALE(N,fMPY16SS(fGETHALF(1,RsV= ),fGETHALF(1,RtV)))));\ + fACC();\ +} +Q6INSN(M2_vmac2s_s0,"Rxx32+=3Dvmpyh(Rs32,Rt32):sat",ATTRIBS(),"Vector Mult= iply",vmac_sema(0)) +Q6INSN(M2_vmac2s_s1,"Rxx32+=3Dvmpyh(Rs32,Rt32):<<1:sat",ATTRIBS(),"Vector = Multiply",vmac_sema(1)) + +#undef vmac_sema +#define vmac_sema(N)\ +{ fSETWORD(0,RddV,fSAT(fSCALE(N,fMPY16SU(fGETHALF(0,RsV),fGETUHALF(0,RtV))= )));\ + fSETWORD(1,RddV,fSAT(fSCALE(N,fMPY16SU(fGETHALF(1,RsV),fGETUHALF(1,RtV))= )));\ +} +Q6INSN(M2_vmpy2su_s0,"Rdd32=3Dvmpyhsu(Rs32,Rt32):sat",ATTRIBS(),"Vector Mu= ltiply",vmac_sema(0)) +Q6INSN(M2_vmpy2su_s1,"Rdd32=3Dvmpyhsu(Rs32,Rt32):<<1:sat",ATTRIBS(),"Vecto= r Multiply",vmac_sema(1)) + + +#undef vmac_sema +#define vmac_sema(N)\ +{ fSETWORD(0,RxxV,fSAT(fGETWORD(0,RxxV) + fSCALE(N,fMPY16SU(fGETHALF(0,RsV= ),fGETUHALF(0,RtV)))));\ + fSETWORD(1,RxxV,fSAT(fGETWORD(1,RxxV) + fSCALE(N,fMPY16SU(fGETHALF(1,RsV= ),fGETUHALF(1,RtV)))));\ + fACC();\ +} +Q6INSN(M2_vmac2su_s0,"Rxx32+=3Dvmpyhsu(Rs32,Rt32):sat",ATTRIBS(),"Vector M= ultiply",vmac_sema(0)) +Q6INSN(M2_vmac2su_s1,"Rxx32+=3Dvmpyhsu(Rs32,Rt32):<<1:sat",ATTRIBS(),"Vect= or Multiply",vmac_sema(1)) + + + +#undef vmac_sema +#define vmac_sema(N)\ +{ fSETHALF(1,RdV,fGETHALF(1,(fSAT(fSCALE(N,fMPY16SS(fGETHALF(1,RsV),fGETHA= LF(1,RtV))) + 0x8000))));\ + fSETHALF(0,RdV,fGETHALF(1,(fSAT(fSCALE(N,fMPY16SS(fGETHALF(0,RsV),fGETHA= LF(0,RtV))) + 0x8000))));\ +} +Q6INSN(M2_vmpy2s_s0pack,"Rd32=3Dvmpyh(Rs32,Rt32):rnd:sat",ATTRIBS(A_ARCHV2= ),"Vector Multiply",vmac_sema(0)) +Q6INSN(M2_vmpy2s_s1pack,"Rd32=3Dvmpyh(Rs32,Rt32):<<1:rnd:sat",ATTRIBS(A_AR= CHV2),"Vector Multiply",vmac_sema(1)) + + +#undef vmac_sema +#define vmac_sema(N)\ +{ fSETWORD(0,RxxV,fGETWORD(0,RxxV) + fMPY16SS(fGETHALF(0,RsV),fGETHALF(0,R= tV)));\ + fSETWORD(1,RxxV,fGETWORD(1,RxxV) + fMPY16SS(fGETHALF(1,RsV),fGETHALF(1,R= tV)));\ + fACC();\ +} +Q6INSN(M2_vmac2,"Rxx32+=3Dvmpyh(Rs32,Rt32)",ATTRIBS(A_ARCHV2),"Vector Mult= iply",vmac_sema(0)) + +#undef vmac_sema +#define vmac_sema(N)\ +{ fSETWORD(0,RddV,fSAT(fSCALE(N,fMPY16SS(fGETHALF(0,RssV),fGETHALF(0,RttV)= ))));\ + fSETWORD(1,RddV,fSAT(fSCALE(N,fMPY16SS(fGETHALF(2,RssV),fGETHALF(2,RttV)= ))));\ +} +Q6INSN(M2_vmpy2es_s0,"Rdd32=3Dvmpyeh(Rss32,Rtt32):sat",ATTRIBS(),"Vector M= ultiply",vmac_sema(0)) +Q6INSN(M2_vmpy2es_s1,"Rdd32=3Dvmpyeh(Rss32,Rtt32):<<1:sat",ATTRIBS(),"Vect= or Multiply",vmac_sema(1)) + +#undef vmac_sema +#define vmac_sema(N)\ +{ fSETWORD(0,RxxV,fSAT(fGETWORD(0,RxxV) + fSCALE(N,fMPY16SS(fGETHALF(0,Rss= V),fGETHALF(0,RttV)))));\ + fSETWORD(1,RxxV,fSAT(fGETWORD(1,RxxV) + fSCALE(N,fMPY16SS(fGETHALF(2,Rss= V),fGETHALF(2,RttV)))));\ + fACC();\ +} +Q6INSN(M2_vmac2es_s0,"Rxx32+=3Dvmpyeh(Rss32,Rtt32):sat",ATTRIBS(),"Vector = Multiply",vmac_sema(0)) +Q6INSN(M2_vmac2es_s1,"Rxx32+=3Dvmpyeh(Rss32,Rtt32):<<1:sat",ATTRIBS(),"Vec= tor Multiply",vmac_sema(1)) + +#undef vmac_sema +#define vmac_sema(N)\ +{ fSETWORD(0,RxxV,fGETWORD(0,RxxV) + fMPY16SS(fGETHALF(0,RssV),fGETHALF(0,= RttV)));\ + fSETWORD(1,RxxV,fGETWORD(1,RxxV) + fMPY16SS(fGETHALF(2,RssV),fGETHALF(2,= RttV)));\ + fACC();\ +} +Q6INSN(M2_vmac2es,"Rxx32+=3Dvmpyeh(Rss32,Rtt32)",ATTRIBS(A_ARCHV2),"Vector= Multiply",vmac_sema(0)) + + + + +/********************************************************/ +/* vrmpyh, aka Big Mac, aka Mac Daddy, aka Mac-ac-ac-ac */ +/* vector mac 4x[16x16] + 64 ->64 */ +/********************************************************/ + + +#undef vmac_sema +#define vmac_sema(N)\ +{ RxxV =3D RxxV + fMPY16SS(fGETHALF(0,RssV),fGETHALF(0,RttV))\ + + fMPY16SS(fGETHALF(1,RssV),fGETHALF(1,RttV))\ + + fMPY16SS(fGETHALF(2,RssV),fGETHALF(2,RttV))\ + + fMPY16SS(fGETHALF(3,RssV),fGETHALF(3,RttV));\ + fACC();\ +} +Q6INSN(M2_vrmac_s0,"Rxx32+=3Dvrmpyh(Rss32,Rtt32)",ATTRIBS(),"Vector Multip= ly",vmac_sema(0)) + +#undef vmac_sema +#define vmac_sema(N)\ +{ RddV =3D fMPY16SS(fGETHALF(0,RssV),fGETHALF(0,RttV))\ + + fMPY16SS(fGETHALF(1,RssV),fGETHALF(1,RttV))\ + + fMPY16SS(fGETHALF(2,RssV),fGETHALF(2,RttV))\ + + fMPY16SS(fGETHALF(3,RssV),fGETHALF(3,RttV));\ +} +Q6INSN(M2_vrmpy_s0,"Rdd32=3Dvrmpyh(Rss32,Rtt32)",ATTRIBS(),"Vector Multipl= y",vmac_sema(0)) + + + +/******************************************************/ +/* vector dual macs. just like complex */ +/******************************************************/ + + +/* With round&pack */ +#undef dmpy_sema +#define dmpy_sema(N)\ +{ fSETHALF(0,RdV,fGETHALF(1,(fSAT(fSCALE(N,fMPY16SS(fGETHALF(0,RssV),fGETH= ALF(0,RttV))) + \ + fSCALE(N,fMPY16SS(fGETHALF(1,RssV),fGETH= ALF(1,RttV))) + 0x8000))));\ + fSETHALF(1,RdV,fGETHALF(1,(fSAT(fSCALE(N,fMPY16SS(fGETHALF(2,RssV),fGETH= ALF(2,RttV))) + \ + fSCALE(N,fMPY16SS(fGETHALF(3,RssV),fGETH= ALF(3,RttV))) + 0x8000))));\ +} +Q6INSN(M2_vdmpyrs_s0,"Rd32=3Dvdmpy(Rss32,Rtt32):rnd:sat",ATTRIBS(), "ve= ctor dual mac w/ round&pack",dmpy_sema(0)) +Q6INSN(M2_vdmpyrs_s1,"Rd32=3Dvdmpy(Rss32,Rtt32):<<1:rnd:sat",ATTRIBS(),"ve= ctor dual mac w/ round&pack",dmpy_sema(1)) + + + + + +/******************************************************/ +/* vector byte multiplies */ +/******************************************************/ + + +Q6INSN(M5_vrmpybuu,"Rdd32=3Dvrmpybu(Rss32,Rtt32)",ATTRIBS(), + "vector dual mpy bytes", +{ + fSETWORD(0,RddV,(fMPY16SS(fGETUBYTE(0,RssV),fGETUBYTE(0,RttV)) + + fMPY16SS(fGETUBYTE(1,RssV),fGETUBYTE(1,RttV)) + + fMPY16SS(fGETUBYTE(2,RssV),fGETUBYTE(2,RttV)) + + fMPY16SS(fGETUBYTE(3,RssV),fGETUBYTE(3,RttV)))); + fSETWORD(1,RddV,(fMPY16SS(fGETUBYTE(4,RssV),fGETUBYTE(4,RttV)) + + fMPY16SS(fGETUBYTE(5,RssV),fGETUBYTE(5,RttV)) + + fMPY16SS(fGETUBYTE(6,RssV),fGETUBYTE(6,RttV)) + + fMPY16SS(fGETUBYTE(7,RssV),fGETUBYTE(7,RttV)))); + }) + +Q6INSN(M5_vrmacbuu,"Rxx32+=3Dvrmpybu(Rss32,Rtt32)",ATTRIBS(), + "vector dual mac bytes", +{ + fSETWORD(0,RxxV,(fGETWORD(0,RxxV) + + fMPY16SS(fGETUBYTE(0,RssV),fGETUBYTE(0,RttV)) + + fMPY16SS(fGETUBYTE(1,RssV),fGETUBYTE(1,RttV)) + + fMPY16SS(fGETUBYTE(2,RssV),fGETUBYTE(2,RttV)) + + fMPY16SS(fGETUBYTE(3,RssV),fGETUBYTE(3,RttV)))); + fSETWORD(1,RxxV,(fGETWORD(1,RxxV) + + fMPY16SS(fGETUBYTE(4,RssV),fGETUBYTE(4,RttV)) + + fMPY16SS(fGETUBYTE(5,RssV),fGETUBYTE(5,RttV)) + + fMPY16SS(fGETUBYTE(6,RssV),fGETUBYTE(6,RttV)) + + fMPY16SS(fGETUBYTE(7,RssV),fGETUBYTE(7,RttV)))); + fACC();\ + }) + + +Q6INSN(M5_vrmpybsu,"Rdd32=3Dvrmpybsu(Rss32,Rtt32)",ATTRIBS(), + "vector dual mpy bytes", +{ + fSETWORD(0,RddV,(fMPY16SS(fGETBYTE(0,RssV),fGETUBYTE(0,RttV)) + + fMPY16SS(fGETBYTE(1,RssV),fGETUBYTE(1,RttV)) + + fMPY16SS(fGETBYTE(2,RssV),fGETUBYTE(2,RttV)) + + fMPY16SS(fGETBYTE(3,RssV),fGETUBYTE(3,RttV)))); + fSETWORD(1,RddV,(fMPY16SS(fGETBYTE(4,RssV),fGETUBYTE(4,RttV)) + + fMPY16SS(fGETBYTE(5,RssV),fGETUBYTE(5,RttV)) + + fMPY16SS(fGETBYTE(6,RssV),fGETUBYTE(6,RttV)) + + fMPY16SS(fGETBYTE(7,RssV),fGETUBYTE(7,RttV)))); + }) + +Q6INSN(M5_vrmacbsu,"Rxx32+=3Dvrmpybsu(Rss32,Rtt32)",ATTRIBS(), + "vector dual mac bytes", +{ + fSETWORD(0,RxxV,(fGETWORD(0,RxxV) + + fMPY16SS(fGETBYTE(0,RssV),fGETUBYTE(0,RttV)) + + fMPY16SS(fGETBYTE(1,RssV),fGETUBYTE(1,RttV)) + + fMPY16SS(fGETBYTE(2,RssV),fGETUBYTE(2,RttV)) + + fMPY16SS(fGETBYTE(3,RssV),fGETUBYTE(3,RttV)))); + fSETWORD(1,RxxV,(fGETWORD(1,RxxV) + + fMPY16SS(fGETBYTE(4,RssV),fGETUBYTE(4,RttV)) + + fMPY16SS(fGETBYTE(5,RssV),fGETUBYTE(5,RttV)) + + fMPY16SS(fGETBYTE(6,RssV),fGETUBYTE(6,RttV)) + + fMPY16SS(fGETBYTE(7,RssV),fGETUBYTE(7,RttV)))); + fACC();\ + }) + + +Q6INSN(M5_vmpybuu,"Rdd32=3Dvmpybu(Rs32,Rt32)",ATTRIBS(), + "vector mpy bytes", +{ + fSETHALF(0,RddV,(fMPY16SS(fGETUBYTE(0,RsV),fGETUBYTE(0,RtV)))); + fSETHALF(1,RddV,(fMPY16SS(fGETUBYTE(1,RsV),fGETUBYTE(1,RtV)))); + fSETHALF(2,RddV,(fMPY16SS(fGETUBYTE(2,RsV),fGETUBYTE(2,RtV)))); + fSETHALF(3,RddV,(fMPY16SS(fGETUBYTE(3,RsV),fGETUBYTE(3,RtV)))); + }) + +Q6INSN(M5_vmpybsu,"Rdd32=3Dvmpybsu(Rs32,Rt32)",ATTRIBS(), + "vector mpy bytes", +{ + fSETHALF(0,RddV,(fMPY16SS(fGETBYTE(0,RsV),fGETUBYTE(0,RtV)))); + fSETHALF(1,RddV,(fMPY16SS(fGETBYTE(1,RsV),fGETUBYTE(1,RtV)))); + fSETHALF(2,RddV,(fMPY16SS(fGETBYTE(2,RsV),fGETUBYTE(2,RtV)))); + fSETHALF(3,RddV,(fMPY16SS(fGETBYTE(3,RsV),fGETUBYTE(3,RtV)))); + }) + + +Q6INSN(M5_vmacbuu,"Rxx32+=3Dvmpybu(Rs32,Rt32)",ATTRIBS(), + "vector mac bytes", +{ + fSETHALF(0,RxxV,(fGETHALF(0,RxxV)+fMPY16SS(fGETUBYTE(0,RsV),fGETUBYTE(0,= RtV)))); + fSETHALF(1,RxxV,(fGETHALF(1,RxxV)+fMPY16SS(fGETUBYTE(1,RsV),fGETUBYTE(1,= RtV)))); + fSETHALF(2,RxxV,(fGETHALF(2,RxxV)+fMPY16SS(fGETUBYTE(2,RsV),fGETUBYTE(2,= RtV)))); + fSETHALF(3,RxxV,(fGETHALF(3,RxxV)+fMPY16SS(fGETUBYTE(3,RsV),fGETUBYTE(3,= RtV)))); + fACC();\ + }) + +Q6INSN(M5_vmacbsu,"Rxx32+=3Dvmpybsu(Rs32,Rt32)",ATTRIBS(), + "vector mac bytes", +{ + fSETHALF(0,RxxV,(fGETHALF(0,RxxV)+fMPY16SS(fGETBYTE(0,RsV),fGETUBYTE(0,R= tV)))); + fSETHALF(1,RxxV,(fGETHALF(1,RxxV)+fMPY16SS(fGETBYTE(1,RsV),fGETUBYTE(1,R= tV)))); + fSETHALF(2,RxxV,(fGETHALF(2,RxxV)+fMPY16SS(fGETBYTE(2,RsV),fGETUBYTE(2,R= tV)))); + fSETHALF(3,RxxV,(fGETHALF(3,RxxV)+fMPY16SS(fGETBYTE(3,RsV),fGETUBYTE(3,R= tV)))); + fACC();\ + }) + + + +Q6INSN(M5_vdmpybsu,"Rdd32=3Dvdmpybsu(Rss32,Rtt32):sat",ATTRIBS(), + "vector quad mpy bytes", +{ + fSETHALF(0,RddV,fSATN(16,(fMPY16SS(fGETBYTE(0,RssV),fGETUBYTE(0,RttV)) + + fMPY16SS(fGETBYTE(1,RssV),fGETUBYTE(1,RttV))))); + fSETHALF(1,RddV,fSATN(16,(fMPY16SS(fGETBYTE(2,RssV),fGETUBYTE(2,RttV)) + + fMPY16SS(fGETBYTE(3,RssV),fGETUBYTE(3,RttV))))); + fSETHALF(2,RddV,fSATN(16,(fMPY16SS(fGETBYTE(4,RssV),fGETUBYTE(4,RttV)) + + fMPY16SS(fGETBYTE(5,RssV),fGETUBYTE(5,RttV))))); + fSETHALF(3,RddV,fSATN(16,(fMPY16SS(fGETBYTE(6,RssV),fGETUBYTE(6,RttV)) + + fMPY16SS(fGETBYTE(7,RssV),fGETUBYTE(7,RttV))))); + }) + + +Q6INSN(M5_vdmacbsu,"Rxx32+=3Dvdmpybsu(Rss32,Rtt32):sat",ATTRIBS(), + "vector quad mac bytes", +{ + fSETHALF(0,RxxV,fSATN(16,(fGETHALF(0,RxxV) + + fMPY16SS(fGETBYTE(0,RssV),fGETUBYTE(0,RttV)) + + fMPY16SS(fGETBYTE(1,RssV),fGETUBYTE(1,RttV))))); + fSETHALF(1,RxxV,fSATN(16,(fGETHALF(1,RxxV) + + fMPY16SS(fGETBYTE(2,RssV),fGETUBYTE(2,RttV)) + + fMPY16SS(fGETBYTE(3,RssV),fGETUBYTE(3,RttV))))); + fSETHALF(2,RxxV,fSATN(16,(fGETHALF(2,RxxV) + + fMPY16SS(fGETBYTE(4,RssV),fGETUBYTE(4,RttV)) + + fMPY16SS(fGETBYTE(5,RssV),fGETUBYTE(5,RttV))))); + fSETHALF(3,RxxV,fSATN(16,(fGETHALF(3,RxxV) + + fMPY16SS(fGETBYTE(6,RssV),fGETUBYTE(6,RttV)) + + fMPY16SS(fGETBYTE(7,RssV),fGETUBYTE(7,RttV))))); + fACC();\ + }) + + + +/* Full version */ +#undef dmpy_sema +#define dmpy_sema(N)\ +{ fSETWORD(0,RxxV,fSAT(fGETWORD(0,RxxV) + fSCALE(N,fMPY16SS(fGETHALF(0,Rss= V),fGETHALF(0,RttV))) + \ + fSCALE(N,fMPY16SS(fGETHALF(1,RssV),fGETHALF(1,RttV)))= ));\ + fSETWORD(1,RxxV,fSAT(fGETWORD(1,RxxV) + fSCALE(N,fMPY16SS(fGETHALF(2,Rss= V),fGETHALF(2,RttV))) + \ + fSCALE(N,fMPY16SS(fGETHALF(3,RssV),fGETHALF(3,RttV)))= ));\ + fACC();\ +} +Q6INSN(M2_vdmacs_s0,"Rxx32+=3Dvdmpy(Rss32,Rtt32):sat",ATTRIBS(), "",dmp= y_sema(0)) +Q6INSN(M2_vdmacs_s1,"Rxx32+=3Dvdmpy(Rss32,Rtt32):<<1:sat",ATTRIBS(),"",dmp= y_sema(1)) + +#undef dmpy_sema +#define dmpy_sema(N)\ +{ fSETWORD(0,RddV,fSAT(fSCALE(N,fMPY16SS(fGETHALF(0,RssV),fGETHALF(0,RttV)= )) + \ + fSCALE(N,fMPY16SS(fGETHALF(1,RssV),fGETHALF(1,RttV)))));\ + fSETWORD(1,RddV,fSAT(fSCALE(N,fMPY16SS(fGETHALF(2,RssV),fGETHALF(2,RttV)= )) + \ + fSCALE(N,fMPY16SS(fGETHALF(3,RssV),fGETHALF(3,RttV)))));\ +} + +Q6INSN(M2_vdmpys_s0,"Rdd32=3Dvdmpy(Rss32,Rtt32):sat",ATTRIBS(), "",dmpy= _sema(0)) +Q6INSN(M2_vdmpys_s1,"Rdd32=3Dvdmpy(Rss32,Rtt32):<<1:sat",ATTRIBS(),"",dmpy= _sema(1)) + + + +/******************************************************/ +/* complex multiply/mac with */ +/* real&imag are packed together and always saturated */ +/* to protect against overflow. */ +/******************************************************/ + +#undef cmpy_sema +#define cmpy_sema(N,CONJMINUS,CONJPLUS)\ +{ fSETHALF(1,RdV,fGETHALF(1,(fSAT(fSCALE(N,fMPY16SS(fGETHALF(1,RsV),fGETHA= LF(0,RtV))) CONJMINUS \ + fSCALE(N,fMPY16SS(fGETHALF(0,RsV),fGETHA= LF(1,RtV))) + 0x8000))));\ + fSETHALF(0,RdV,fGETHALF(1,(fSAT(fSCALE(N,fMPY16SS(fGETHALF(0,RsV),fGETHA= LF(0,RtV))) CONJPLUS \ + fSCALE(N,fMPY16SS(fGETHALF(1,RsV),fGETHA= LF(1,RtV))) + 0x8000))));\ +} +Q6INSN(M2_cmpyrs_s0,"Rd32=3Dcmpy(Rs32,Rt32):rnd:sat",ATTRIBS(), "Comple= x Multiply",cmpy_sema(0,+,-)) +Q6INSN(M2_cmpyrs_s1,"Rd32=3Dcmpy(Rs32,Rt32):<<1:rnd:sat",ATTRIBS(),"Comple= x Multiply",cmpy_sema(1,+,-)) + + +Q6INSN(M2_cmpyrsc_s0,"Rd32=3Dcmpy(Rs32,Rt32*):rnd:sat",ATTRIBS(A_ARCHV2), = "Complex Multiply",cmpy_sema(0,-,+)) +Q6INSN(M2_cmpyrsc_s1,"Rd32=3Dcmpy(Rs32,Rt32*):<<1:rnd:sat",ATTRIBS(A_ARCHV= 2),"Complex Multiply",cmpy_sema(1,-,+)) + + +#undef cmpy_sema +#define cmpy_sema(N,CONJMINUS,CONJPLUS)\ +{ fSETWORD(1,RxxV,fSAT(fGETWORD(1,RxxV) + fSCALE(N,fMPY16SS(fGETHALF(1,RsV= ),fGETHALF(0,RtV))) CONJMINUS \ + fSCALE(N,fMPY16SS(fGETHALF(0,RsV= ),fGETHALF(1,RtV)))));\ + fSETWORD(0,RxxV,fSAT(fGETWORD(0,RxxV) + fSCALE(N,fMPY16SS(fGETHALF(0,RsV= ),fGETHALF(0,RtV))) CONJPLUS \ + fSCALE(N,fMPY16SS(fGETHALF(1,RsV= ),fGETHALF(1,RtV)))));\ + fACC();\ +} +Q6INSN(M2_cmacs_s0,"Rxx32+=3Dcmpy(Rs32,Rt32):sat",ATTRIBS(), "Complex M= ultiply",cmpy_sema(0,+,-)) +Q6INSN(M2_cmacs_s1,"Rxx32+=3Dcmpy(Rs32,Rt32):<<1:sat",ATTRIBS(),"Complex M= ultiply",cmpy_sema(1,+,-)) + +/* EJP: Need mac versions w/ CONJ T? */ +Q6INSN(M2_cmacsc_s0,"Rxx32+=3Dcmpy(Rs32,Rt32*):sat",ATTRIBS(A_ARCHV2), = "Complex Multiply",cmpy_sema(0,-,+)) +Q6INSN(M2_cmacsc_s1,"Rxx32+=3Dcmpy(Rs32,Rt32*):<<1:sat",ATTRIBS(A_ARCHV2),= "Complex Multiply",cmpy_sema(1,-,+)) + + +#undef cmpy_sema +#define cmpy_sema(N,CONJMINUS,CONJPLUS)\ +{ fSETWORD(1,RddV,fSAT(fSCALE(N,fMPY16SS(fGETHALF(1,RsV),fGETHALF(0,RtV)))= CONJMINUS \ + fSCALE(N,fMPY16SS(fGETHALF(0,RsV),fGETHALF(1,RtV)))= ));\ + fSETWORD(0,RddV,fSAT(fSCALE(N,fMPY16SS(fGETHALF(0,RsV),fGETHALF(0,RtV)))= CONJPLUS \ + fSCALE(N,fMPY16SS(fGETHALF(1,RsV),fGETHALF(1,RtV)))= ));\ +} + +Q6INSN(M2_cmpys_s0,"Rdd32=3Dcmpy(Rs32,Rt32):sat",ATTRIBS(), "Complex Mu= ltiply",cmpy_sema(0,+,-)) +Q6INSN(M2_cmpys_s1,"Rdd32=3Dcmpy(Rs32,Rt32):<<1:sat",ATTRIBS(),"Complex Mu= ltiply",cmpy_sema(1,+,-)) + +Q6INSN(M2_cmpysc_s0,"Rdd32=3Dcmpy(Rs32,Rt32*):sat",ATTRIBS(A_ARCHV2), "= Complex Multiply",cmpy_sema(0,-,+)) +Q6INSN(M2_cmpysc_s1,"Rdd32=3Dcmpy(Rs32,Rt32*):<<1:sat",ATTRIBS(A_ARCHV2),"= Complex Multiply",cmpy_sema(1,-,+)) + + + +#undef cmpy_sema +#define cmpy_sema(N,CONJMINUS,CONJPLUS)\ +{ fSETWORD(1,RxxV,fSAT(fGETWORD(1,RxxV) - (fSCALE(N,fMPY16SS(fGETHALF(1,Rs= V),fGETHALF(0,RtV))) CONJMINUS \ + fSCALE(N,fMPY16SS(fGETHALF(0,Rs= V),fGETHALF(1,RtV))))));\ + fSETWORD(0,RxxV,fSAT(fGETWORD(0,RxxV) - (fSCALE(N,fMPY16SS(fGETHALF(0,Rs= V),fGETHALF(0,RtV))) CONJPLUS \ + fSCALE(N,fMPY16SS(fGETHALF(1,Rs= V),fGETHALF(1,RtV))))));\ + fACC();\ +} +Q6INSN(M2_cnacs_s0,"Rxx32-=3Dcmpy(Rs32,Rt32):sat",ATTRIBS(A_ARCHV2), "C= omplex Multiply",cmpy_sema(0,+,-)) +Q6INSN(M2_cnacs_s1,"Rxx32-=3Dcmpy(Rs32,Rt32):<<1:sat",ATTRIBS(A_ARCHV2),"C= omplex Multiply",cmpy_sema(1,+,-)) + +/* EJP: need CONJ versions? */ +Q6INSN(M2_cnacsc_s0,"Rxx32-=3Dcmpy(Rs32,Rt32*):sat",ATTRIBS(A_ARCHV2), = "Complex Multiply",cmpy_sema(0,-,+)) +Q6INSN(M2_cnacsc_s1,"Rxx32-=3Dcmpy(Rs32,Rt32*):<<1:sat",ATTRIBS(A_ARCHV2),= "Complex Multiply",cmpy_sema(1,-,+)) + + +/******************************************************/ +/* complex interpolation */ +/* Given a pair of complex values, scale by a,b, sum */ +/* Saturate/shift1 and round/pack */ +/******************************************************/ + +#undef vrcmpys_sema +#define vrcmpys_sema(N,INWORD) \ +{ fSETWORD(1,RddV,fSAT(fSCALE(N,fMPY16SS(fGETHALF(1,RssV),fGETHALF(0,INWOR= D))) + \ + fSCALE(N,fMPY16SS(fGETHALF(3,RssV),fGETHALF(1,INWOR= D)))));\ + fSETWORD(0,RddV,fSAT(fSCALE(N,fMPY16SS(fGETHALF(0,RssV),fGETHALF(0,INWOR= D))) + \ + fSCALE(N,fMPY16SS(fGETHALF(2,RssV),fGETHALF(1,INWOR= D)))));\ +} + + + +Q6INSN(M2_vrcmpys_s1_h,"Rdd32=3Dvrcmpys(Rss32,Rtt32):<<1:sat:raw:hi",ATTRI= BS(A_ARCHV3), "Vector Reduce Complex Multiply by Scalar",vrcmpys_sema(1,fGE= TWORD(1,RttV))) +Q6INSN(M2_vrcmpys_s1_l,"Rdd32=3Dvrcmpys(Rss32,Rtt32):<<1:sat:raw:lo",ATTRI= BS(A_ARCHV3), "Vector Reduce Complex Multiply by Scalar",vrcmpys_sema(1,fGE= TWORD(0,RttV))) + +DEF_V3_COND_MAPPING(M2_vrcmpys_s1,"Rdd32=3Dvrcmpys(Rss32,Rt32):<<1:sat","R= t32 & 1","Rdd32=3Dvrcmpys(Rss32,Rtt32):<<1:sat:raw:hi","Rdd32=3Dvrcmpys(Rss= 32,Rtt32):<<1:sat:raw:lo") + +#undef vrcmpys_sema +#define vrcmpys_sema(N,INWORD) \ +{ fSETWORD(1,RxxV,fSAT(fGETWORD(1,RxxV) + fSCALE(N,fMPY16SS(fGETHALF(1,Rss= V),fGETHALF(0,INWORD))) + \ + fSCALE(N,fMPY16SS(fGETHALF(3,RssV),fGETHALF(1,INWOR= D)))));\ + fSETWORD(0,RxxV,fSAT(fGETWORD(0,RxxV) + fSCALE(N,fMPY16SS(fGETHALF(0,Rss= V),fGETHALF(0,INWORD))) + \ + fSCALE(N,fMPY16SS(fGETHALF(2,RssV),fGETHALF(1,INWOR= D)))));\ + fACC();\ +} + + + +Q6INSN(M2_vrcmpys_acc_s1_h,"Rxx32+=3Dvrcmpys(Rss32,Rtt32):<<1:sat:raw:hi",= ATTRIBS(A_ARCHV3), "Vector Reduce Complex Multiply by Scalar",vrcmpys_sema(= 1,fGETWORD(1,RttV))) +Q6INSN(M2_vrcmpys_acc_s1_l,"Rxx32+=3Dvrcmpys(Rss32,Rtt32):<<1:sat:raw:lo",= ATTRIBS(A_ARCHV3), "Vector Reduce Complex Multiply by Scalar",vrcmpys_sema(= 1,fGETWORD(0,RttV))) + +DEF_V3_COND_MAPPING(M2_vrcmpys_acc_s1,"Rxx32+=3Dvrcmpys(Rss32,Rt32):<<1:sa= t","Rt32 & 1","Rxx32+=3Dvrcmpys(Rss32,Rtt32):<<1:sat:raw:hi","Rxx32+=3Dvrcm= pys(Rss32,Rtt32):<<1:sat:raw:lo") + + +#undef vrcmpys_sema +#define vrcmpys_sema(N,INWORD) \ +{ fSETHALF(1,RdV,fGETHALF(1,fSAT(fSCALE(N,fMPY16SS(fGETHALF(1,RssV),fGETHA= LF(0,INWORD))) + \ + fSCALE(N,fMPY16SS(fGETHALF(3,RssV),fGETHALF(1,INWOR= D))) + 0x8000)));\ + fSETHALF(0,RdV,fGETHALF(1,fSAT(fSCALE(N,fMPY16SS(fGETHALF(0,RssV),fGETHA= LF(0,INWORD))) + \ + fSCALE(N,fMPY16SS(fGETHALF(2,RssV),fGETHALF(1,INWOR= D))) + 0x8000)));\ +} + +Q6INSN(M2_vrcmpys_s1rp_h,"Rd32=3Dvrcmpys(Rss32,Rtt32):<<1:rnd:sat:raw:hi",= ATTRIBS(A_ARCHV3), "Vector Reduce Complex Multiply by Scalar",vrcmpys_sema(= 1,fGETWORD(1,RttV))) +Q6INSN(M2_vrcmpys_s1rp_l,"Rd32=3Dvrcmpys(Rss32,Rtt32):<<1:rnd:sat:raw:lo",= ATTRIBS(A_ARCHV3), "Vector Reduce Complex Multiply by Scalar",vrcmpys_sema(= 1,fGETWORD(0,RttV))) + +DEF_V3_COND_MAPPING(M2_vrcmpys_s1rp,"Rd32=3Dvrcmpys(Rss32,Rt32):<<1:rnd:sa= t","Rt32 & 1","Rd32=3Dvrcmpys(Rss32,Rtt32):<<1:rnd:sat:raw:hi","Rd32=3Dvrcm= pys(Rss32,Rtt32):<<1:rnd:sat:raw:lo") + +#if 1 +/**************************************************************/ +/* mixed mode 32x16 vector dual multiplies */ +/* */ +/**************************************************************/ + +/* SIGNED 32 x SIGNED 16 */ + + +#undef mixmpy_sema +#define mixmpy_sema(N)\ +{ fSETWORD(1,RxxV,fSAT(fGETWORD(1,RxxV) + ((fSCALE(N,fMPY3216SS(fGETWORD(1= ,RssV),fGETHALF(2,RttV))))>>16)) ); \ + fSETWORD(0,RxxV,fSAT(fGETWORD(0,RxxV) + ((fSCALE(N,fMPY3216SS(fGETWORD(0= ,RssV),fGETHALF(0,RttV))))>>16)) ); \ + fACC();\ +} +Q6INSN(M2_mmacls_s0,"Rxx32+=3Dvmpyweh(Rss32,Rtt32):sat",ATTRIBS(), "Mix= ed Precision Multiply",mixmpy_sema(0)) +Q6INSN(M2_mmacls_s1,"Rxx32+=3Dvmpyweh(Rss32,Rtt32):<<1:sat",ATTRIBS(),"Mix= ed Precision Multiply",mixmpy_sema(1)) + +#undef mixmpy_sema +#define mixmpy_sema(N)\ +{ fSETWORD(1,RxxV,fSAT(fGETWORD(1,RxxV) + ((fSCALE(N,fMPY3216SS(fGETWORD(1= ,RssV),fGETHALF(3,RttV))))>>16) )); \ + fSETWORD(0,RxxV,fSAT(fGETWORD(0,RxxV) + ((fSCALE(N,fMPY3216SS(fGETWORD(0= ,RssV),fGETHALF(1,RttV))))>>16 ))); \ + fACC();\ +} +Q6INSN(M2_mmachs_s0,"Rxx32+=3Dvmpywoh(Rss32,Rtt32):sat",ATTRIBS(), "Mix= ed Precision Multiply",mixmpy_sema(0)) +Q6INSN(M2_mmachs_s1,"Rxx32+=3Dvmpywoh(Rss32,Rtt32):<<1:sat",ATTRIBS(),"Mix= ed Precision Multiply",mixmpy_sema(1)) + +#undef mixmpy_sema +#define mixmpy_sema(N)\ +{ fSETWORD(1,RddV,fSAT((fSCALE(N,fMPY3216SS(fGETWORD(1,RssV),fGETHALF(2,Rt= tV))))>>16)); \ + fSETWORD(0,RddV,fSAT((fSCALE(N,fMPY3216SS(fGETWORD(0,RssV),fGETHALF(0,Rt= tV))))>>16)); \ +} +Q6INSN(M2_mmpyl_s0,"Rdd32=3Dvmpyweh(Rss32,Rtt32):sat",ATTRIBS(), "Mixed= Precision Multiply",mixmpy_sema(0)) +Q6INSN(M2_mmpyl_s1,"Rdd32=3Dvmpyweh(Rss32,Rtt32):<<1:sat",ATTRIBS(),"Mixed= Precision Multiply",mixmpy_sema(1)) + +#undef mixmpy_sema +#define mixmpy_sema(N)\ +{ fSETWORD(1,RddV,fSAT((fSCALE(N,fMPY3216SS(fGETWORD(1,RssV),fGETHALF(3,Rt= tV))))>>16)); \ + fSETWORD(0,RddV,fSAT((fSCALE(N,fMPY3216SS(fGETWORD(0,RssV),fGETHALF(1,Rt= tV))))>>16)); \ +} +Q6INSN(M2_mmpyh_s0,"Rdd32=3Dvmpywoh(Rss32,Rtt32):sat",ATTRIBS(), "Mixed= Precision Multiply",mixmpy_sema(0)) +Q6INSN(M2_mmpyh_s1,"Rdd32=3Dvmpywoh(Rss32,Rtt32):<<1:sat",ATTRIBS(),"Mixed= Precision Multiply",mixmpy_sema(1)) + + +/* With rounding */ + +#undef mixmpy_sema +#define mixmpy_sema(N)\ +{ fSETWORD(1,RxxV,fSAT(fGETWORD(1,RxxV) + ((fSCALE(N,fMPY3216SS(fGETWORD(1= ,RssV),fGETHALF(2,RttV)))+0x8000)>>16)) ); \ + fSETWORD(0,RxxV,fSAT(fGETWORD(0,RxxV) + ((fSCALE(N,fMPY3216SS(fGETWORD(0= ,RssV),fGETHALF(0,RttV)))+0x8000)>>16)) ); \ + fACC();\ +} +Q6INSN(M2_mmacls_rs0,"Rxx32+=3Dvmpyweh(Rss32,Rtt32):rnd:sat",ATTRIBS(), = "Mixed Precision Multiply",mixmpy_sema(0)) +Q6INSN(M2_mmacls_rs1,"Rxx32+=3Dvmpyweh(Rss32,Rtt32):<<1:rnd:sat",ATTRIBS()= ,"Mixed Precision Multiply",mixmpy_sema(1)) + +#undef mixmpy_sema +#define mixmpy_sema(N)\ +{ fSETWORD(1,RxxV,fSAT(fGETWORD(1,RxxV) + ((fSCALE(N,fMPY3216SS(fGETWORD(1= ,RssV),fGETHALF(3,RttV)))+0x8000)>>16) )); \ + fSETWORD(0,RxxV,fSAT(fGETWORD(0,RxxV) + ((fSCALE(N,fMPY3216SS(fGETWORD(0= ,RssV),fGETHALF(1,RttV)))+0x8000)>>16 ))); \ + fACC();\ +} +Q6INSN(M2_mmachs_rs0,"Rxx32+=3Dvmpywoh(Rss32,Rtt32):rnd:sat",ATTRIBS(), = "Mixed Precision Multiply",mixmpy_sema(0)) +Q6INSN(M2_mmachs_rs1,"Rxx32+=3Dvmpywoh(Rss32,Rtt32):<<1:rnd:sat",ATTRIBS()= ,"Mixed Precision Multiply",mixmpy_sema(1)) + +#undef mixmpy_sema +#define mixmpy_sema(N)\ +{ fSETWORD(1,RddV,fSAT((fSCALE(N,fMPY3216SS(fGETWORD(1,RssV),fGETHALF(2,Rt= tV)))+0x8000)>>16)); \ + fSETWORD(0,RddV,fSAT((fSCALE(N,fMPY3216SS(fGETWORD(0,RssV),fGETHALF(0,Rt= tV)))+0x8000)>>16)); \ +} +Q6INSN(M2_mmpyl_rs0,"Rdd32=3Dvmpyweh(Rss32,Rtt32):rnd:sat",ATTRIBS(), "= Mixed Precision Multiply",mixmpy_sema(0)) +Q6INSN(M2_mmpyl_rs1,"Rdd32=3Dvmpyweh(Rss32,Rtt32):<<1:rnd:sat",ATTRIBS(),"= Mixed Precision Multiply",mixmpy_sema(1)) + +#undef mixmpy_sema +#define mixmpy_sema(N)\ +{ fSETWORD(1,RddV,fSAT((fSCALE(N,fMPY3216SS(fGETWORD(1,RssV),fGETHALF(3,Rt= tV)))+0x8000)>>16)); \ + fSETWORD(0,RddV,fSAT((fSCALE(N,fMPY3216SS(fGETWORD(0,RssV),fGETHALF(1,Rt= tV)))+0x8000)>>16)); \ +} +Q6INSN(M2_mmpyh_rs0,"Rdd32=3Dvmpywoh(Rss32,Rtt32):rnd:sat",ATTRIBS(), "= Mixed Precision Multiply",mixmpy_sema(0)) +Q6INSN(M2_mmpyh_rs1,"Rdd32=3Dvmpywoh(Rss32,Rtt32):<<1:rnd:sat",ATTRIBS(),"= Mixed Precision Multiply",mixmpy_sema(1)) + + +#undef mixmpy_sema +#define mixmpy_sema(DEST,EQUALS,N,ACCSYN)\ +{ DEST EQUALS fSCALE(N,fMPY3216SS(fGETWORD(1,RssV),fGETHALF(2,RttV))) + fS= CALE(N,fMPY3216SS(fGETWORD(0,RssV),fGETHALF(0,RttV))); ACCSYN;} + +Q6INSN(M4_vrmpyeh_s0,"Rdd32=3Dvrmpyweh(Rss32,Rtt32)",ATTRIBS(), "Mixed = Precision Multiply",mixmpy_sema(RddV,=3D,0,)) +Q6INSN(M4_vrmpyeh_s1,"Rdd32=3Dvrmpyweh(Rss32,Rtt32):<<1",ATTRIBS(),"Mixed = Precision Multiply",mixmpy_sema(RddV,=3D,1,)) +Q6INSN(M4_vrmpyeh_acc_s0,"Rxx32+=3Dvrmpyweh(Rss32,Rtt32)",ATTRIBS(), "M= ixed Precision Multiply",mixmpy_sema(RxxV,+=3D,0,fACC())) +Q6INSN(M4_vrmpyeh_acc_s1,"Rxx32+=3Dvrmpyweh(Rss32,Rtt32):<<1",ATTRIBS(),"M= ixed Precision Multiply",mixmpy_sema(RxxV,+=3D,1,fACC())) + +#undef mixmpy_sema +#define mixmpy_sema(DEST,EQUALS,N,ACCSYN)\ +{ DEST EQUALS fSCALE(N,fMPY3216SS(fGETWORD(1,RssV),fGETHALF(3,RttV))) + fS= CALE(N,fMPY3216SS(fGETWORD(0,RssV),fGETHALF(1,RttV))); ACCSYN;} + +Q6INSN(M4_vrmpyoh_s0,"Rdd32=3Dvrmpywoh(Rss32,Rtt32)",ATTRIBS(), "Mixed = Precision Multiply",mixmpy_sema(RddV,=3D,0,)) +Q6INSN(M4_vrmpyoh_s1,"Rdd32=3Dvrmpywoh(Rss32,Rtt32):<<1",ATTRIBS(),"Mixed = Precision Multiply",mixmpy_sema(RddV,=3D,1,)) +Q6INSN(M4_vrmpyoh_acc_s0,"Rxx32+=3Dvrmpywoh(Rss32,Rtt32)",ATTRIBS(), "M= ixed Precision Multiply",mixmpy_sema(RxxV,+=3D,0,fACC())) +Q6INSN(M4_vrmpyoh_acc_s1,"Rxx32+=3Dvrmpywoh(Rss32,Rtt32):<<1",ATTRIBS(),"M= ixed Precision Multiply",mixmpy_sema(RxxV,+=3D,1,fACC())) + + + + + + +#undef mixmpy_sema +#define mixmpy_sema(N,H,RND)\ +{ RdV =3D fSAT((fSCALE(N,fMPY3216SS(RsV,fGETHALF(H,RtV)))RND)>>16); \ +} +Q6INSN(M2_hmmpyl_rs1,"Rd32=3Dmpy(Rs32,Rt.L32):<<1:rnd:sat",ATTRIBS(A_ARCHV= 2),"Mixed Precision Multiply",mixmpy_sema(1,0,+0x8000)) +Q6INSN(M2_hmmpyh_rs1,"Rd32=3Dmpy(Rs32,Rt.H32):<<1:rnd:sat",ATTRIBS(A_ARCHV= 2),"Mixed Precision Multiply",mixmpy_sema(1,1,+0x8000)) +Q6INSN(M2_hmmpyl_s1,"Rd32=3Dmpy(Rs32,Rt.L32):<<1:sat",ATTRIBS(A_ARCHV2),"M= ixed Precision Multiply",mixmpy_sema(1,0,)) +Q6INSN(M2_hmmpyh_s1,"Rd32=3Dmpy(Rs32,Rt.H32):<<1:sat",ATTRIBS(A_ARCHV2),"M= ixed Precision Multiply",mixmpy_sema(1,1,)) + + + + + + + + + +/* SIGNED 32 x UNSIGNED 16 */ + +#undef mixmpy_sema +#define mixmpy_sema(N)\ +{ fSETWORD(1,RxxV,fSAT(fGETWORD(1,RxxV) + ((fSCALE(N,fMPY3216SU(fGETWORD(1= ,RssV),fGETUHALF(2,RttV))))>>16)) ); \ + fSETWORD(0,RxxV,fSAT(fGETWORD(0,RxxV) + ((fSCALE(N,fMPY3216SU(fGETWORD(0= ,RssV),fGETUHALF(0,RttV))))>>16)) ); \ + fACC();\ +} +Q6INSN(M2_mmaculs_s0,"Rxx32+=3Dvmpyweuh(Rss32,Rtt32):sat",ATTRIBS(), "M= ixed Precision Multiply",mixmpy_sema(0)) +Q6INSN(M2_mmaculs_s1,"Rxx32+=3Dvmpyweuh(Rss32,Rtt32):<<1:sat",ATTRIBS(),"M= ixed Precision Multiply",mixmpy_sema(1)) + +#undef mixmpy_sema +#define mixmpy_sema(N)\ +{ fSETWORD(1,RxxV,fSAT(fGETWORD(1,RxxV) + ((fSCALE(N,fMPY3216SU(fGETWORD(1= ,RssV),fGETUHALF(3,RttV))))>>16) )); \ + fSETWORD(0,RxxV,fSAT(fGETWORD(0,RxxV) + ((fSCALE(N,fMPY3216SU(fGETWORD(0= ,RssV),fGETUHALF(1,RttV))))>>16 ))); \ + fACC();\ +} +Q6INSN(M2_mmacuhs_s0,"Rxx32+=3Dvmpywouh(Rss32,Rtt32):sat",ATTRIBS(), "M= ixed Precision Multiply",mixmpy_sema(0)) +Q6INSN(M2_mmacuhs_s1,"Rxx32+=3Dvmpywouh(Rss32,Rtt32):<<1:sat",ATTRIBS(),"M= ixed Precision Multiply",mixmpy_sema(1)) + +#undef mixmpy_sema +#define mixmpy_sema(N)\ +{ fSETWORD(1,RddV,fSAT((fSCALE(N,fMPY3216SU(fGETWORD(1,RssV),fGETUHALF(2,R= ttV))))>>16)); \ + fSETWORD(0,RddV,fSAT((fSCALE(N,fMPY3216SU(fGETWORD(0,RssV),fGETUHALF(0,R= ttV))))>>16)); \ +} +Q6INSN(M2_mmpyul_s0,"Rdd32=3Dvmpyweuh(Rss32,Rtt32):sat",ATTRIBS(), "Mix= ed Precision Multiply",mixmpy_sema(0)) +Q6INSN(M2_mmpyul_s1,"Rdd32=3Dvmpyweuh(Rss32,Rtt32):<<1:sat",ATTRIBS(),"Mix= ed Precision Multiply",mixmpy_sema(1)) + +#undef mixmpy_sema +#define mixmpy_sema(N)\ +{ fSETWORD(1,RddV,fSAT((fSCALE(N,fMPY3216SU(fGETWORD(1,RssV),fGETUHALF(3,R= ttV))))>>16)); \ + fSETWORD(0,RddV,fSAT((fSCALE(N,fMPY3216SU(fGETWORD(0,RssV),fGETUHALF(1,R= ttV))))>>16)); \ +} +Q6INSN(M2_mmpyuh_s0,"Rdd32=3Dvmpywouh(Rss32,Rtt32):sat",ATTRIBS(), "Mix= ed Precision Multiply",mixmpy_sema(0)) +Q6INSN(M2_mmpyuh_s1,"Rdd32=3Dvmpywouh(Rss32,Rtt32):<<1:sat",ATTRIBS(),"Mix= ed Precision Multiply",mixmpy_sema(1)) + + +/* With rounding */ + +#undef mixmpy_sema +#define mixmpy_sema(N)\ +{ fSETWORD(1,RxxV,fSAT(fGETWORD(1,RxxV) + ((fSCALE(N,fMPY3216SU(fGETWORD(1= ,RssV),fGETUHALF(2,RttV)))+0x8000)>>16)) ); \ + fSETWORD(0,RxxV,fSAT(fGETWORD(0,RxxV) + ((fSCALE(N,fMPY3216SU(fGETWORD(0= ,RssV),fGETUHALF(0,RttV)))+0x8000)>>16)) ); \ + fACC();\ +} +Q6INSN(M2_mmaculs_rs0,"Rxx32+=3Dvmpyweuh(Rss32,Rtt32):rnd:sat",ATTRIBS(), = "Mixed Precision Multiply",mixmpy_sema(0)) +Q6INSN(M2_mmaculs_rs1,"Rxx32+=3Dvmpyweuh(Rss32,Rtt32):<<1:rnd:sat",ATTRIBS= (),"Mixed Precision Multiply",mixmpy_sema(1)) + +#undef mixmpy_sema +#define mixmpy_sema(N)\ +{ fSETWORD(1,RxxV,fSAT(fGETWORD(1,RxxV) + ((fSCALE(N,fMPY3216SU(fGETWORD(1= ,RssV),fGETUHALF(3,RttV)))+0x8000)>>16) )); \ + fSETWORD(0,RxxV,fSAT(fGETWORD(0,RxxV) + ((fSCALE(N,fMPY3216SU(fGETWORD(0= ,RssV),fGETUHALF(1,RttV)))+0x8000)>>16 ))); \ + fACC();\ +} +Q6INSN(M2_mmacuhs_rs0,"Rxx32+=3Dvmpywouh(Rss32,Rtt32):rnd:sat",ATTRIBS(), = "Mixed Precision Multiply",mixmpy_sema(0)) +Q6INSN(M2_mmacuhs_rs1,"Rxx32+=3Dvmpywouh(Rss32,Rtt32):<<1:rnd:sat",ATTRIBS= (),"Mixed Precision Multiply",mixmpy_sema(1)) + +#undef mixmpy_sema +#define mixmpy_sema(N)\ +{ fSETWORD(1,RddV,fSAT((fSCALE(N,fMPY3216SU(fGETWORD(1,RssV),fGETUHALF(2,R= ttV)))+0x8000)>>16)); \ + fSETWORD(0,RddV,fSAT((fSCALE(N,fMPY3216SU(fGETWORD(0,RssV),fGETUHALF(0,R= ttV)))+0x8000)>>16)); \ +} +Q6INSN(M2_mmpyul_rs0,"Rdd32=3Dvmpyweuh(Rss32,Rtt32):rnd:sat",ATTRIBS(), = "Mixed Precision Multiply",mixmpy_sema(0)) +Q6INSN(M2_mmpyul_rs1,"Rdd32=3Dvmpyweuh(Rss32,Rtt32):<<1:rnd:sat",ATTRIBS()= ,"Mixed Precision Multiply",mixmpy_sema(1)) + +#undef mixmpy_sema +#define mixmpy_sema(N)\ +{ fSETWORD(1,RddV,fSAT((fSCALE(N,fMPY3216SU(fGETWORD(1,RssV),fGETUHALF(3,R= ttV)))+0x8000)>>16)); \ + fSETWORD(0,RddV,fSAT((fSCALE(N,fMPY3216SU(fGETWORD(0,RssV),fGETUHALF(1,R= ttV)))+0x8000)>>16)); \ +} +Q6INSN(M2_mmpyuh_rs0,"Rdd32=3Dvmpywouh(Rss32,Rtt32):rnd:sat",ATTRIBS(), = "Mixed Precision Multiply",mixmpy_sema(0)) +Q6INSN(M2_mmpyuh_rs1,"Rdd32=3Dvmpywouh(Rss32,Rtt32):<<1:rnd:sat",ATTRIBS()= ,"Mixed Precision Multiply",mixmpy_sema(1)) + + +#endif + + + +/**************************************************************/ +/* complex mac with full 64-bit accum - no sat, no shift */ +/* either do real or accum, never both */ +/**************************************************************/ + +Q6INSN(M2_vrcmaci_s0,"Rxx32+=3Dvrcmpyi(Rss32,Rtt32)",ATTRIBS(),"Vector Com= plex Mac Imaginary", +{ +RxxV =3D RxxV + fMPY16SS(fGETHALF(1,RssV),fGETHALF(0,RttV)) + \ + fMPY16SS(fGETHALF(0,RssV),fGETHALF(1,RttV)) + \ + fMPY16SS(fGETHALF(3,RssV),fGETHALF(2,RttV)) + \ + fMPY16SS(fGETHALF(2,RssV),fGETHALF(3,RttV));\ +fACC();\ +}) + +Q6INSN(M2_vrcmacr_s0,"Rxx32+=3Dvrcmpyr(Rss32,Rtt32)",ATTRIBS(),"Vector Com= plex Mac Real", +{ RxxV =3D RxxV + fMPY16SS(fGETHALF(0,RssV),fGETHALF(0,RttV)) - \ + fMPY16SS(fGETHALF(1,RssV),fGETHALF(1,RttV)) + \ + fMPY16SS(fGETHALF(2,RssV),fGETHALF(2,RttV)) - \ + fMPY16SS(fGETHALF(3,RssV),fGETHALF(3,RttV));\ +fACC();\ +}) + +Q6INSN(M2_vrcmaci_s0c,"Rxx32+=3Dvrcmpyi(Rss32,Rtt32*)",ATTRIBS(A_ARCHV2),"= Vector Complex Mac Imaginary", +{ +RxxV =3D RxxV + fMPY16SS(fGETHALF(1,RssV),fGETHALF(0,RttV)) - \ + fMPY16SS(fGETHALF(0,RssV),fGETHALF(1,RttV)) + \ + fMPY16SS(fGETHALF(3,RssV),fGETHALF(2,RttV)) - \ + fMPY16SS(fGETHALF(2,RssV),fGETHALF(3,RttV));\ +fACC();\ +}) + +Q6INSN(M2_vrcmacr_s0c,"Rxx32+=3Dvrcmpyr(Rss32,Rtt32*)",ATTRIBS(A_ARCHV2),"= Vector Complex Mac Real", +{ RxxV =3D RxxV + fMPY16SS(fGETHALF(0,RssV),fGETHALF(0,RttV)) + \ + fMPY16SS(fGETHALF(1,RssV),fGETHALF(1,RttV)) + \ + fMPY16SS(fGETHALF(2,RssV),fGETHALF(2,RttV)) + \ + fMPY16SS(fGETHALF(3,RssV),fGETHALF(3,RttV));\ +fACC();\ +}) + +Q6INSN(M2_cmaci_s0,"Rxx32+=3Dcmpyi(Rs32,Rt32)",ATTRIBS(),"Vector Complex M= ac Imaginary", +{ +RxxV =3D RxxV + fMPY16SS(fGETHALF(1,RsV),fGETHALF(0,RtV)) + \ + fMPY16SS(fGETHALF(0,RsV),fGETHALF(1,RtV)); +fACC();\ +}) + +Q6INSN(M2_cmacr_s0,"Rxx32+=3Dcmpyr(Rs32,Rt32)",ATTRIBS(),"Vector Complex M= ac Real", +{ RxxV =3D RxxV + fMPY16SS(fGETHALF(0,RsV),fGETHALF(0,RtV)) - \ + fMPY16SS(fGETHALF(1,RsV),fGETHALF(1,RtV)); +fACC();\ +}) + + +Q6INSN(M2_vrcmpyi_s0,"Rdd32=3Dvrcmpyi(Rss32,Rtt32)",ATTRIBS(),"Vector Comp= lex Mpy Imaginary", +{ +RddV =3D fMPY16SS(fGETHALF(1,RssV),fGETHALF(0,RttV)) + \ + fMPY16SS(fGETHALF(0,RssV),fGETHALF(1,RttV)) + \ + fMPY16SS(fGETHALF(3,RssV),fGETHALF(2,RttV)) + \ + fMPY16SS(fGETHALF(2,RssV),fGETHALF(3,RttV));\ +}) + +Q6INSN(M2_vrcmpyr_s0,"Rdd32=3Dvrcmpyr(Rss32,Rtt32)",ATTRIBS(),"Vector Comp= lex Mpy Real", +{ RddV =3D fMPY16SS(fGETHALF(0,RssV),fGETHALF(0,RttV)) - \ + fMPY16SS(fGETHALF(1,RssV),fGETHALF(1,RttV)) + \ + fMPY16SS(fGETHALF(2,RssV),fGETHALF(2,RttV)) - \ + fMPY16SS(fGETHALF(3,RssV),fGETHALF(3,RttV));\ +}) + +Q6INSN(M2_vrcmpyi_s0c,"Rdd32=3Dvrcmpyi(Rss32,Rtt32*)",ATTRIBS(A_ARCHV2),"V= ector Complex Mpy Imaginary", +{ +RddV =3D fMPY16SS(fGETHALF(1,RssV),fGETHALF(0,RttV)) - \ + fMPY16SS(fGETHALF(0,RssV),fGETHALF(1,RttV)) + \ + fMPY16SS(fGETHALF(3,RssV),fGETHALF(2,RttV)) - \ + fMPY16SS(fGETHALF(2,RssV),fGETHALF(3,RttV));\ +}) + +Q6INSN(M2_vrcmpyr_s0c,"Rdd32=3Dvrcmpyr(Rss32,Rtt32*)",ATTRIBS(A_ARCHV2),"V= ector Complex Mpy Real", +{ RddV =3D fMPY16SS(fGETHALF(0,RssV),fGETHALF(0,RttV)) + \ + fMPY16SS(fGETHALF(1,RssV),fGETHALF(1,RttV)) + \ + fMPY16SS(fGETHALF(2,RssV),fGETHALF(2,RttV)) + \ + fMPY16SS(fGETHALF(3,RssV),fGETHALF(3,RttV));\ +}) + +Q6INSN(M2_cmpyi_s0,"Rdd32=3Dcmpyi(Rs32,Rt32)",ATTRIBS(),"Vector Complex Mp= y Imaginary", +{ +RddV =3D fMPY16SS(fGETHALF(1,RsV),fGETHALF(0,RtV)) + \ + fMPY16SS(fGETHALF(0,RsV),fGETHALF(1,RtV)); +}) + +Q6INSN(M2_cmpyr_s0,"Rdd32=3Dcmpyr(Rs32,Rt32)",ATTRIBS(),"Vector Complex Mp= y Real", +{ RddV =3D fMPY16SS(fGETHALF(0,RsV),fGETHALF(0,RtV)) - \ + fMPY16SS(fGETHALF(1,RsV),fGETHALF(1,RtV)); +}) + + +/**************************************************************/ +/* Complex mpy/mac with 2x32 bit accum, sat, shift */ +/* 32x16 real or imag */ +/**************************************************************/ + +#if 1 + +Q6INSN(M4_cmpyi_wh,"Rd32=3Dcmpyiwh(Rss32,Rt32):<<1:rnd:sat",ATTRIBS(),"Mix= ed Precision Complex Multiply", +{ + RdV =3D fSAT( ( fMPY3216SS(fGETWORD(0,RssV),fGETHALF(1,RtV)) + + fMPY3216SS(fGETWORD(1,RssV),fGETHALF(0,RtV)) + + 0x4000)>>15); +}) + + +Q6INSN(M4_cmpyr_wh,"Rd32=3Dcmpyrwh(Rss32,Rt32):<<1:rnd:sat",ATTRIBS(),"Mix= ed Precision Complex Multiply", +{ + RdV =3D fSAT( ( fMPY3216SS(fGETWORD(0,RssV),fGETHALF(0,RtV)) + - fMPY3216SS(fGETWORD(1,RssV),fGETHALF(1,RtV)) + + 0x4000)>>15); +}) + +Q6INSN(M4_cmpyi_whc,"Rd32=3Dcmpyiwh(Rss32,Rt32*):<<1:rnd:sat",ATTRIBS(),"M= ixed Precision Complex Multiply", +{ + RdV =3D fSAT( ( fMPY3216SS(fGETWORD(1,RssV),fGETHALF(0,RtV)) + - fMPY3216SS(fGETWORD(0,RssV),fGETHALF(1,RtV)) + + 0x4000)>>15); +}) + + +Q6INSN(M4_cmpyr_whc,"Rd32=3Dcmpyrwh(Rss32,Rt32*):<<1:rnd:sat",ATTRIBS(),"M= ixed Precision Complex Multiply", +{ + RdV =3D fSAT( ( fMPY3216SS(fGETWORD(0,RssV),fGETHALF(0,RtV)) + + fMPY3216SS(fGETWORD(1,RssV),fGETHALF(1,RtV)) + + 0x4000)>>15); +}) + + +#endif + +/**************************************************************/ +/* Vector mpy/mac with 2x32 bit accum, sat, shift */ +/* either do real or imag, never both */ +/**************************************************************/ + +#undef VCMPYSEMI +#define VCMPYSEMI(DST,ACC0,ACC1,SHIFT,SAT,ACCSYN) \ + fSETWORD(0,DST,SAT(ACC0 fSCALE(SHIFT,fMPY16SS(fGETHALF(1,RssV),fGETHALF(0= ,RttV)) + \ + fMPY16SS(fGETHALF(0,RssV),fGETHALF(1,= RttV))))); \ + fSETWORD(1,DST,SAT(ACC1 fSCALE(SHIFT,fMPY16SS(fGETHALF(3,RssV),fGETHALF(2= ,RttV)) + \ + fMPY16SS(fGETHALF(2,RssV),fGETHALF(3,= RttV))))); \ + ACCSYN;\ + +#undef VCMPYSEMR +#define VCMPYSEMR(DST,ACC0,ACC1,SHIFT,SAT,ACCSYN) \ + fSETWORD(0,DST,SAT(ACC0 fSCALE(SHIFT,fMPY16SS(fGETHALF(0,RssV),fGETHALF(0= ,RttV)) - \ + fMPY16SS(fGETHALF(1,RssV),fGETHALF(1,RttV))))); \ + fSETWORD(1,DST,SAT(ACC1 fSCALE(SHIFT,fMPY16SS(fGETHALF(2,RssV),fGETHALF(2= ,RttV)) - \ + fMPY16SS(fGETHALF(3,RssV),fGETHALF(3,RttV))))); \ + ACCSYN;\ + + +#undef VCMPYIR +#define VCMPYIR(TAGBASE,DSTSYN,DSTVAL,ACCSEM,ACCVAL0,ACCVAL1,SHIFTSYN,SHIF= TVAL,SATSYN,SATVAL,ACCSYN) \ +Q6INSN(M2_##TAGBASE##i,DSTSYN ACCSEM "vcmpyi(Rss32,Rtt32)" SHIFTSYN SATSYN= ,ATTRIBS(A_ARCHV2), \ + "Vector Complex Multiply Imaginary", { VCMPYSEMI(DSTVAL,ACCVAL0,ACCVAL1,S= HIFTVAL,SATVAL,ACCSYN); }) \ +Q6INSN(M2_##TAGBASE##r,DSTSYN ACCSEM "vcmpyr(Rss32,Rtt32)" SHIFTSYN SATSYN= ,ATTRIBS(A_ARCHV2), \ + "Vector Complex Multiply Imaginary", { VCMPYSEMR(DSTVAL,ACCVAL0,ACCVAL1,S= HIFTVAL,SATVAL,ACCSYN); }) + + +VCMPYIR(vcmpy_s0_sat_,"Rdd32",RddV,"=3D",,,"",0,":sat",fSAT,) +VCMPYIR(vcmpy_s1_sat_,"Rdd32",RddV,"=3D",,,":<<1",1,":sat",fSAT,) +VCMPYIR(vcmac_s0_sat_,"Rxx32",RxxV,"+=3D",fGETWORD(0,RxxV) + ,fGETWORD(1,R= xxV) + ,"",0,":sat",fSAT,fACC()) + + +/********************************************************************** + * Rotation -- by 0, 90, 180, or 270 means mult by 1, J, -1, -J * + *********************************************************************/ + +Q6INSN(S2_vcrotate,"Rdd32=3Dvcrotate(Rss32,Rt32)",ATTRIBS(A_ARCHV2),"Rotat= e complex value by multiple of PI/2", +{ + fHIDE(size1u_t tmp;) + tmp =3D fEXTRACTU_RANGE(RtV,1,0); + if (tmp =3D=3D 0) { /* No rotation */ + fSETHALF(0,RddV,fGETHALF(0,RssV)); + fSETHALF(1,RddV,fGETHALF(1,RssV)); + } else if (tmp =3D=3D 1) { /* Multiply by -J */ + fSETHALF(0,RddV,fGETHALF(1,RssV)); + fSETHALF(1,RddV,fSATH(-fGETHALF(0,RssV))); + } else if (tmp =3D=3D 2) { /* Multiply by J */ + fSETHALF(0,RddV,fSATH(-fGETHALF(1,RssV))); + fSETHALF(1,RddV,fGETHALF(0,RssV)); + } else { /* Multiply by -1 */ + fHIDE(if (tmp !=3D 3) fatal("C is broken");) + fSETHALF(0,RddV,fSATH(-fGETHALF(0,RssV))); + fSETHALF(1,RddV,fSATH(-fGETHALF(1,RssV))); + } + tmp =3D fEXTRACTU_RANGE(RtV,3,2); + if (tmp =3D=3D 0) { /* No rotation */ + fSETHALF(2,RddV,fGETHALF(2,RssV)); + fSETHALF(3,RddV,fGETHALF(3,RssV)); + } else if (tmp =3D=3D 1) { /* Multiply by -J */ + fSETHALF(2,RddV,fGETHALF(3,RssV)); + fSETHALF(3,RddV,fSATH(-fGETHALF(2,RssV))); + } else if (tmp =3D=3D 2) { /* Multiply by J */ + fSETHALF(2,RddV,fSATH(-fGETHALF(3,RssV))); + fSETHALF(3,RddV,fGETHALF(2,RssV)); + } else { /* Multiply by -1 */ + fHIDE(if (tmp !=3D 3) fatal("C is broken");) + fSETHALF(2,RddV,fSATH(-fGETHALF(2,RssV))); + fSETHALF(3,RddV,fSATH(-fGETHALF(3,RssV))); + } +}) + + +Q6INSN(S4_vrcrotate_acc,"Rxx32+=3Dvrcrotate(Rss32,Rt32,#u2)",ATTRIBS(),"Ro= tate and Reduce Bytes", +{ + fHIDE(int i; int tmpr; int tmpi; unsigned int control;) + fHIDE(int sumr; int sumi;) + sumr =3D 0; + sumi =3D 0; + control =3D fGETUBYTE(uiV,RtV); + for (i =3D 0; i < 8; i +=3D 2) { + tmpr =3D fGETBYTE(i ,RssV); + tmpi =3D fGETBYTE(i+1,RssV); + switch (control & 3) { + case 0: /* No Rotation */ + sumr +=3D tmpr; + sumi +=3D tmpi; + break; + case 1: /* Multiply by -J */ + sumr +=3D tmpi; + sumi -=3D tmpr; + break; + case 2: /* Multiply by J */ + sumr -=3D tmpi; + sumi +=3D tmpr; + break; + case 3: /* Multiply by -1 */ + sumr -=3D tmpr; + sumi -=3D tmpi; + break; + fHIDE(default: fatal("C is broken!");) + } + control =3D control >> 2; + } + fSETWORD(0,RxxV,fGETWORD(0,RxxV) + sumr); + fSETWORD(1,RxxV,fGETWORD(1,RxxV) + sumi); + fACC();\ +}) + +Q6INSN(S4_vrcrotate,"Rdd32=3Dvrcrotate(Rss32,Rt32,#u2)",ATTRIBS(),"Rotate = and Reduce Bytes", +{ + fHIDE(int i; int tmpr; int tmpi; unsigned int control;) + fHIDE(int sumr; int sumi;) + sumr =3D 0; + sumi =3D 0; + control =3D fGETUBYTE(uiV,RtV); + for (i =3D 0; i < 8; i +=3D 2) { + tmpr =3D fGETBYTE(i ,RssV); + tmpi =3D fGETBYTE(i+1,RssV); + switch (control & 3) { + case 0: /* No Rotation */ + sumr +=3D tmpr; + sumi +=3D tmpi; + break; + case 1: /* Multiply by -J */ + sumr +=3D tmpi; + sumi -=3D tmpr; + break; + case 2: /* Multiply by J */ + sumr -=3D tmpi; + sumi +=3D tmpr; + break; + case 3: /* Multiply by -1 */ + sumr -=3D tmpr; + sumi -=3D tmpi; + break; + fHIDE(default: fatal("C is broken!");) + } + control =3D control >> 2; + } + fSETWORD(0,RddV,sumr); + fSETWORD(1,RddV,sumi); +}) + + +Q6INSN(S2_vcnegh,"Rdd32=3Dvcnegh(Rss32,Rt32)",ATTRIBS(),"Conditional Negat= e halfwords", +{ + fHIDE(int i;) + for (i =3D 0; i < 4; i++) { + if (fGETBIT(i,RtV)) { + fSETHALF(i,RddV,fSATH(-fGETHALF(i,RssV))); + } else { + fSETHALF(i,RddV,fGETHALF(i,RssV)); + } + } +}) + +Q6INSN(S2_vrcnegh,"Rxx32+=3Dvrcnegh(Rss32,Rt32)",ATTRIBS(),"Vector Reduce = Conditional Negate halfwords", +{ + fHIDE(int i;) + for (i =3D 0; i < 4; i++) { + if (fGETBIT(i,RtV)) { + RxxV +=3D -fGETHALF(i,RssV); + } else { + RxxV +=3D fGETHALF(i,RssV); + } + } + fACC(); +}) + + +/********************************************************************** + * Finite-field multiplies. Written by David Hoyle * + *********************************************************************/ + +Q6INSN(M4_pmpyw,"Rdd32=3Dpmpyw(Rs32,Rt32)",ATTRIBS(),"Polynomial 32bit Mul= tiplication with Addition in GF(2)", +{ + fHIDE(int i; unsigned int y;) + fHIDE(unsigned long long x; unsigned long long prod;) + x =3D fGETUWORD(0, RsV); + y =3D fGETUWORD(0, RtV); + + prod =3D 0; + for(i=3D0; i < 32; i++) { + if((y >> i) & 1) prod ^=3D (x << i); + } + RddV =3D prod; +}) + +Q6INSN(M4_vpmpyh,"Rdd32=3Dvpmpyh(Rs32,Rt32)",ATTRIBS(),"Dual Polynomial 16= bit Multiplication with Addition in GF(2)", +{ + fHIDE(int i; unsigned int x0; unsigned int x1;) + fHIDE(unsigned int y0; unsigned int y1;) + fHIDE(unsigned int prod0; unsigned int prod1;) + + x0 =3D fGETUHALF(0, RsV); + x1 =3D fGETUHALF(1, RsV); + y0 =3D fGETUHALF(0, RtV); + y1 =3D fGETUHALF(1, RtV); + + prod0 =3D prod1 =3D 0; + for(i=3D0; i < 16; i++) { + if((y0 >> i) & 1) prod0 ^=3D (x0 << i); + if((y1 >> i) & 1) prod1 ^=3D (x1 << i); + } + fSETHALF(0,RddV,fGETUHALF(0,prod0)); + fSETHALF(1,RddV,fGETUHALF(0,prod1)); + fSETHALF(2,RddV,fGETUHALF(1,prod0)); + fSETHALF(3,RddV,fGETUHALF(1,prod1)); +}) + +Q6INSN(M4_pmpyw_acc,"Rxx32^=3Dpmpyw(Rs32,Rt32)",ATTRIBS(),"Polynomial 32bi= t Multiplication with Addition in GF(2)", +{ + fHIDE(int i; unsigned int y;) + fHIDE(unsigned long long x; unsigned long long prod;) + x =3D fGETUWORD(0, RsV); + y =3D fGETUWORD(0, RtV); + + prod =3D 0; + for(i=3D0; i < 32; i++) { + if((y >> i) & 1) prod ^=3D (x << i); + } + RxxV ^=3D prod; +}) + +Q6INSN(M4_vpmpyh_acc,"Rxx32^=3Dvpmpyh(Rs32,Rt32)",ATTRIBS(),"Dual Polynomi= al 16bit Multiplication with Addition in GF(2)", +{ + fHIDE(int i; unsigned int x0; unsigned int x1;) + fHIDE(unsigned int y0; unsigned int y1;) + fHIDE(unsigned int prod0; unsigned int prod1;) + + x0 =3D fGETUHALF(0, RsV); + x1 =3D fGETUHALF(1, RsV); + y0 =3D fGETUHALF(0, RtV); + y1 =3D fGETUHALF(1, RtV); + + prod0 =3D prod1 =3D 0; + for(i=3D0; i < 16; i++) { + if((y0 >> i) & 1) prod0 ^=3D (x0 << i); + if((y1 >> i) & 1) prod1 ^=3D (x1 << i); + } + fSETHALF(0,RxxV,fGETUHALF(0,RxxV) ^ fGETUHALF(0,prod0)); + fSETHALF(1,RxxV,fGETUHALF(1,RxxV) ^ fGETUHALF(0,prod1)); + fSETHALF(2,RxxV,fGETUHALF(2,RxxV) ^ fGETUHALF(1,prod0)); + fSETHALF(3,RxxV,fGETUHALF(3,RxxV) ^ fGETUHALF(1,prod1)); +}) + + +/* V70: TINY CORE */ + +#define CMPY64(TAG,NAME,DESC,OPERAND1,OP,W0,W1,W2,W3) \ +Q6INSN(M7_##TAG,"Rdd32=3D" NAME "(Rss32," OPERAND1 ")",ATTRIBS(A_RESTRICT_= SLOT3ONLY,A_RESTRICT_NOSLOT2_MPY),"Complex Multiply 64-bit " DESC, { Rdd= V =3D (fMPY32SS(fGETWORD(W0, RssV), fGETWORD(W1, RttV)) OP fMPY32SS(fGETWO= RD(W2, RssV), fGETWORD(W3, RttV))); fEXTENSION_AUDIO();})\ +Q6INSN(M7_##TAG##_acc,"Rxx32+=3D" NAME "(Rss32,"OPERAND1")",ATTRIBS(A_REST= RICT_SLOT3ONLY,A_RESTRICT_NOSLOT2_MPY,A_NOTE_NOSLOT2_MPY),"Complex Multiply= -Accumulate 64-bit " DESC, { RxxV +=3D (fMPY32SS(fGETWORD(W0, RssV), fGETWO= RD(W1, RttV)) OP fMPY32SS(fGETWORD(W2, RssV), fGETWORD(W3, RttV))); fEXTENS= ION_AUDIO(); fACC(); }) + +CMPY64(dcmpyrw, "cmpyrw","Real","Rtt32" ,-,0,0,1,1) +CMPY64(dcmpyrwc,"cmpyrw","Real","Rtt32*",+,0,0,1,1) +CMPY64(dcmpyiw, "cmpyiw","Imag","Rtt32" ,+,0,1,1,0) +CMPY64(dcmpyiwc,"cmpyiw","Imag","Rtt32*",-,1,0,0,1) + +DEF_MAPPING(M7_vdmpy,"Rdd32=3Dvdmpyw(Rss32,Rtt32)","Rdd32=3Dcmpyrw(Rss32,R= tt32*)") +DEF_MAPPING(M7_vdmpy_acc,"Rxx32+=3Dvdmpyw(Rss32,Rtt32)","Rxx32+=3Dcmpyrw(R= ss32,Rtt32*)") + + + +#define CMPY128(TAG, NAME, OPERAND1, WORD0, WORD1, WORD2, WORD3, OP) \ +Q6INSN(M7_##TAG,"Rd32=3D" NAME "(Rss32,"OPERAND1"):<<1:sat",ATTRIBS(A_REST= RICT_SLOT3ONLY,A_RESTRICT_NOSLOT2_MPY,A_NOTE_NOSLOT2_MPY),"Complex Multiply= 32-bit result real", \ +{ \ +fHIDE(size16s_t acc128;)\ +fHIDE(size16s_t tmp128;)\ +fHIDE(size8s_t acc64;)\ +tmp128 =3D fCAST8S_16S(fMPY32SS(fGETWORD(WORD0, RssV), fGETWORD(WORD1, Rtt= V)));\ +acc128 =3D fCAST8S_16S(fMPY32SS(fGETWORD(WORD2, RssV), fGETWORD(WORD3, Rtt= V)));\ +acc128 =3D OP(tmp128,acc128);\ +acc128 =3D fSHIFTR128(acc128, 31);\ +acc64 =3D fCAST16S_8S(acc128);\ +RdV =3D fSATW(acc64);\ +fEXTENSION_AUDIO();}) + + +CMPY128(wcmpyrw, "cmpyrw", "Rtt32", 0, 0, 1, 1, fSUB128) +CMPY128(wcmpyrwc, "cmpyrw", "Rtt32*", 0, 0, 1, 1, fADD128) +CMPY128(wcmpyiw, "cmpyiw", "Rtt32", 0, 1, 1, 0, fADD128) +CMPY128(wcmpyiwc, "cmpyiw", "Rtt32*", 1, 0, 0, 1, fSUB128) + + +#define CMPY128RND(TAG, NAME, OPERAND1, WORD0, WORD1, WORD2, WORD3, OP) \ +Q6INSN(M7_##TAG##_rnd,"Rd32=3D" NAME "(Rss32,"OPERAND1"):<<1:rnd:sat",ATTR= IBS(A_RESTRICT_SLOT3ONLY,A_RESTRICT_NOSLOT2_MPY,A_NOTE_NOSLOT2_MPY),"Comple= x Multiply 32-bit result real", \ +{ \ +fHIDE(size16s_t acc128;)\ +fHIDE(size16s_t tmp128;)\ +fHIDE(size16s_t const128;)\ +fHIDE(size8s_t acc64;)\ +tmp128 =3D fCAST8S_16S(fMPY32SS(fGETWORD(WORD0, RssV), fGETWORD(WORD1, Rtt= V)));\ +acc128 =3D fCAST8S_16S(fMPY32SS(fGETWORD(WORD2, RssV), fGETWORD(WORD3, Rtt= V)));\ +const128 =3D fCAST8S_16S(fCONSTLL(0x40000000));\ +acc128 =3D OP(tmp128,acc128);\ +acc128 =3D fADD128(acc128,const128);\ +acc128 =3D fSHIFTR128(acc128, 31);\ +acc64 =3D fCAST16S_8S(acc128);\ +RdV =3D fSATW(acc64);\ +fEXTENSION_AUDIO();}) + +CMPY128RND(wcmpyrw, "cmpyrw", "Rtt32", 0, 0, 1, 1, fSUB128) +CMPY128RND(wcmpyrwc, "cmpyrw", "Rtt32*", 0, 0, 1, 1, fADD128) +CMPY128RND(wcmpyiw, "cmpyiw", "Rtt32", 0, 1, 1, 0, fADD128) +CMPY128RND(wcmpyiwc, "cmpyiw", "Rtt32*", 1, 0, 0, 1, fSUB128) + + + + diff --git a/target/hexagon/imported/shift.idef b/target/hexagon/imported/s= hift.idef new file mode 100644 index 0000000..81c440f --- /dev/null +++ b/target/hexagon/imported/shift.idef @@ -0,0 +1,1211 @@ +/* + * Copyright(c) 2019-2020 Qualcomm Innovation Center, Inc. All Rights Res= erved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +/* + * S-type Instructions + */ + +/**********************************************/ +/* SHIFTS */ +/**********************************************/ + +/* NOTE: Rdd =3D Rs *right* shifts don't make sense */ +/* NOTE: Rd[d] =3D Rs[s] *right* shifts with saturation don't make sense */ + + +#define RSHIFTTYPES(TAGEND,REGD,REGS,REGSTYPE,ACC,ACCSRC,SAT,SATOPT,ATTRS)= \ +Q6INSN(S2_asr_r_##TAGEND,#REGD "32" #ACC "=3Dasr(" #REGS "32,Rt32)" #SATOP= T,ATTRIBS(ATTRS), \ + "Arithmetic Shift Right by Register", \ + { \ + fHIDE(size4s_t) shamt=3DfSXTN(7,32,RtV);\ + REGD##V =3D SAT(ACCSRC ACC fBIDIR_ASHIFTR(REGS##V,shamt,REGSTYPE)); \ + })\ +\ +Q6INSN(S2_asl_r_##TAGEND,#REGD "32" #ACC "=3Dasl(" #REGS "32,Rt32)" #SATOP= T,ATTRIBS(ATTRS), \ + "Arithmetic Shift Left by Register", \ + { \ + fHIDE(size4s_t) shamt=3DfSXTN(7,32,RtV);\ + REGD##V =3D SAT(ACCSRC ACC fBIDIR_ASHIFTL(REGS##V,shamt,REGSTYPE)); \ + })\ +\ +Q6INSN(S2_lsr_r_##TAGEND,#REGD "32" #ACC "=3Dlsr(" #REGS "32,Rt32)" #SATOP= T,ATTRIBS(ATTRS), \ + "Logical Shift Right by Register", \ + { \ + fHIDE(size4s_t) shamt=3DfSXTN(7,32,RtV);\ + REGD##V =3D SAT(ACCSRC ACC fBIDIR_LSHIFTR(REGS##V,shamt,REGSTYPE)); \ + })\ +\ +Q6INSN(S2_lsl_r_##TAGEND,#REGD "32" #ACC "=3Dlsl(" #REGS "32,Rt32)" #SATOP= T,ATTRIBS(ATTRS), \ + "Logical Shift Left by Register", \ + { \ + fHIDE(size4s_t) shamt=3DfSXTN(7,32,RtV);\ + REGD##V =3D SAT(ACCSRC ACC fBIDIR_LSHIFTL(REGS##V,shamt,REGSTYPE)); \ + }) + +RSHIFTTYPES(r,Rd,Rs,4_8,,,fECHO,,) +RSHIFTTYPES(p,Rdd,Rss,8_8,,,fECHO,,) +RSHIFTTYPES(r_acc,Rx,Rs,4_8,+,RxV,fECHO,,A_ROPS_2) +RSHIFTTYPES(p_acc,Rxx,Rss,8_8,+,RxxV,fECHO,,A_ROPS_2) +RSHIFTTYPES(r_nac,Rx,Rs,4_8,-,RxV,fECHO,,A_ROPS_2) +RSHIFTTYPES(p_nac,Rxx,Rss,8_8,-,RxxV,fECHO,,A_ROPS_2) + +RSHIFTTYPES(r_and,Rx,Rs,4_8,&,RxV,fECHO,,A_ROPS_2) +RSHIFTTYPES(r_or,Rx,Rs,4_8,|,RxV,fECHO,,A_ROPS_2) +RSHIFTTYPES(p_and,Rxx,Rss,8_8,&,RxxV,fECHO,,A_ROPS_2) +RSHIFTTYPES(p_or,Rxx,Rss,8_8,|,RxxV,fECHO,,A_ROPS_2) +RSHIFTTYPES(p_xor,Rxx,Rss,8_8,^,RxxV,fECHO,,A_ROPS_2) + + +#undef RSHIFTTYPES + +/* Register shift with saturation */ +#define RSATSHIFTTYPES(TAGEND,REGD,REGS,REGSTYPE) \ +Q6INSN(S2_asr_r_##TAGEND,#REGD "32" "=3Dasr(" #REGS "32,Rt32):sat",ATTRIBS= (), \ + "Arithmetic Shift Right by Register", \ + { \ + fHIDE(size4s_t) shamt=3DfSXTN(7,32,RtV);\ + REGD##V =3D fBIDIR_ASHIFTR_SAT(REGS##V,shamt,REGSTYPE); \ + })\ +\ +Q6INSN(S2_asl_r_##TAGEND,#REGD "32" "=3Dasl(" #REGS "32,Rt32):sat",ATTRIBS= (), \ + "Arithmetic Shift Left by Register", \ + { \ + fHIDE(size4s_t) shamt=3DfSXTN(7,32,RtV);\ + REGD##V =3D fBIDIR_ASHIFTL_SAT(REGS##V,shamt,REGSTYPE); \ + }) + +RSATSHIFTTYPES(r_sat,Rd,Rs,4_8) + + + + + +#define ISHIFTTYPES(TAGEND,SIZE,REGD,REGS,REGSTYPE,ACC,ACCSRC,SAT,SATOPT,A= TTRS) \ +Q6INSN(S2_asr_i_##TAGEND,#REGD "32" #ACC "=3Dasr(" #REGS "32,#u" #SIZE ")"= #SATOPT,ATTRIBS(ATTRS), \ + "Arithmetic Shift Right by Immediate", \ + { REGD##V =3D SAT(ACCSRC ACC fASHIFTR(REGS##V,uiV,REGSTYPE)); }) \ +\ +Q6INSN(S2_lsr_i_##TAGEND,#REGD "32" #ACC "=3Dlsr(" #REGS "32,#u" #SIZE ")"= #SATOPT,ATTRIBS(ATTRS), \ + "Logical Shift Right by Immediate", \ + { REGD##V =3D SAT(ACCSRC ACC fLSHIFTR(REGS##V,uiV,REGSTYPE)); }) \ +\ +Q6INSN(S2_asl_i_##TAGEND,#REGD "32" #ACC "=3Dasl(" #REGS "32,#u" #SIZE ")"= #SATOPT,ATTRIBS(ATTRS), \ + "Shift Left by Immediate", \ + { REGD##V =3D SAT(ACCSRC ACC fASHIFTL(REGS##V,uiV,REGSTYPE)); }) \ +Q6INSN(S6_rol_i_##TAGEND,#REGD "32" #ACC "=3Drol(" #REGS "32,#u" #SIZE ")"= #SATOPT,ATTRIBS(ATTRS), \ + "Rotate Left by Immediate", \ + { REGD##V =3D SAT(ACCSRC ACC fROTL(REGS##V,uiV,REGSTYPE)); }) + + +#define ISHIFTTYPES_ONLY_ASL(TAGEND,SIZE,REGD,REGS,REGSTYPE,ACC,ACCSRC,SAT= ,SATOPT) \ +Q6INSN(S2_asl_i_##TAGEND,#REGD "32" #ACC "=3Dasl(" #REGS "32,#u" #SIZE ")"= #SATOPT,ATTRIBS(), \ + "", \ + { REGD##V =3D SAT(ACCSRC ACC fASHIFTL(REGS##V,uiV,REGSTYPE)); }) + +#define ISHIFTTYPES_ONLY_ASR(TAGEND,SIZE,REGD,REGS,REGSTYPE,ACC,ACCSRC,SAT= ,SATOPT) \ +Q6INSN(S2_asr_i_##TAGEND,#REGD "32" #ACC "=3Dasr(" #REGS "32,#u" #SIZE ")"= #SATOPT,ATTRIBS(), \ + "", \ + { REGD##V =3D SAT(ACCSRC ACC fASHIFTR(REGS##V,uiV,REGSTYPE)); }) + + +#define ISHIFTTYPES_NOASR(TAGEND,SIZE,REGD,REGS,REGSTYPE,ACC,ACCSRC,SAT,SA= TOPT) \ +Q6INSN(S2_lsr_i_##TAGEND,#REGD "32" #ACC "=3Dlsr(" #REGS "32,#u" #SIZE ")"= #SATOPT,ATTRIBS(), \ + "Logical Shift Right by Register", \ + { REGD##V =3D SAT(ACCSRC ACC fLSHIFTR(REGS##V,uiV,REGSTYPE)); }) \ +Q6INSN(S2_asl_i_##TAGEND,#REGD "32" #ACC "=3Dasl(" #REGS "32,#u" #SIZE ")"= #SATOPT,ATTRIBS(), \ + "Shift Left by Register", \ + { REGD##V =3D SAT(ACCSRC ACC fASHIFTL(REGS##V,uiV,REGSTYPE)); }) \ +Q6INSN(S6_rol_i_##TAGEND,#REGD "32" #ACC "=3Drol(" #REGS "32,#u" #SIZE ")"= #SATOPT,ATTRIBS(), \ + "Rotate Left by Immediate", \ + { REGD##V =3D SAT(ACCSRC ACC fROTL(REGS##V,uiV,REGSTYPE)); }) + + + +ISHIFTTYPES(r,5,Rd,Rs,4_4,,,fECHO,,) +ISHIFTTYPES(p,6,Rdd,Rss,8_8,,,fECHO,,) +ISHIFTTYPES(r_acc,5,Rx,Rs,4_4,+,RxV,fECHO,,A_ROPS_2) +ISHIFTTYPES(p_acc,6,Rxx,Rss,8_8,+,RxxV,fECHO,,A_ROPS_2) +ISHIFTTYPES(r_nac,5,Rx,Rs,4_4,-,RxV,fECHO,,A_ROPS_2) +ISHIFTTYPES(p_nac,6,Rxx,Rss,8_8,-,RxxV,fECHO,,A_ROPS_2) + +ISHIFTTYPES_NOASR(r_xacc,5,Rx,Rs,4_4,^, RxV,fECHO,) +ISHIFTTYPES_NOASR(p_xacc,6,Rxx,Rss,8_8,^, RxxV,fECHO,) + +ISHIFTTYPES(r_and,5,Rx,Rs,4_4,&,RxV,fECHO,,A_ROPS_2) +ISHIFTTYPES(r_or,5,Rx,Rs,4_4,|,RxV,fECHO,,A_ROPS_2) +ISHIFTTYPES(p_and,6,Rxx,Rss,8_8,&,RxxV,fECHO,,A_ROPS_2) +ISHIFTTYPES(p_or,6,Rxx,Rss,8_8,|,RxxV,fECHO,,A_ROPS_2) + +ISHIFTTYPES_ONLY_ASL(r_sat,5,Rd,Rs,4_8,,,fSAT,:sat) + + +Q6INSN(S2_asr_i_r_rnd,"Rd32=3Dasr(Rs32,#u5):rnd",ATTRIBS(), + "Shift right with round", + { RdV =3D fASHIFTR(((fASHIFTR(RsV,uiV,4_8))+1),1,8_8); }) + + +DEF_V2_COND_MAPPING(S2_asr_i_r_rnd_goodsyntax,"Rd32=3Dasrrnd(Rs32,#u5)","#= u5=3D=3D0","Rd32=3DRs32","Rd32=3Dasr(Rs32,#u5-1):rnd") + + + + +Q6INSN(S2_asr_i_p_rnd,"Rdd32=3Dasr(Rss32,#u6):rnd",ATTRIBS(), "Shift right= with round", +{ fHIDE(size8u_t tmp;) + fHIDE(size8u_t rnd;) + tmp =3D fASHIFTR(RssV,uiV,8_8); + rnd =3D tmp & 1; + RddV =3D fASHIFTR(tmp,1,8_8) + rnd; }) + + +DEF_V5_COND_MAPPING(S2_asr_i_p_rnd_goodsyntax,"Rdd32=3Dasrrnd(Rss32,#u6)",= "#u6=3D=3D0","Rdd32=3DRss32","Rdd32=3Dasr(Rss32,#u6-1):rnd") + + + +Q6INSN(S4_lsli,"Rd32=3Dlsl(#s6,Rt32)",ATTRIBS(), "Shift an immediate left = by register amount", +{ + fHIDE(size4s_t) shamt =3D fSXTN(7,32,RtV); + RdV =3D fBIDIR_LSHIFTL(siV,shamt,4_8); +}) + + + + +Q6INSN(S2_addasl_rrri,"Rd32=3Daddasl(Rt32,Rs32,#u3)",ATTRIBS(), + "Shift left by small amount and add", + { RdV =3D RtV + fASHIFTL(RsV,uiV,4_4); }) + + + +#define SHIFTOPI(TAGEND,INNEROP,INNERSEM)\ +Q6INSN(S4_andi_##TAGEND,"Rx32=3Dand(#u8,"INNEROP")",,"Shift-op",{RxV=3DfIM= MEXT(uiV)&INNERSEM;})\ +Q6INSN(S4_ori_##TAGEND, "Rx32=3Dor(#u8,"INNEROP")",,"Shift-op",{RxV=3DfIMM= EXT(uiV)|INNERSEM;})\ +Q6INSN(S4_addi_##TAGEND,"Rx32=3Dadd(#u8,"INNEROP")",,"Shift-op",{RxV=3DfIM= MEXT(uiV)+INNERSEM;})\ +Q6INSN(S4_subi_##TAGEND,"Rx32=3Dsub(#u8,"INNEROP")",,"Shift-op",{RxV=3DfIM= MEXT(uiV)-INNERSEM;}) + + +SHIFTOPI(asl_ri,"asl(Rx32,#U5)",(RxV<>UiV)) + + +/**********************************************/ +/* PERMUTES */ +/**********************************************/ +Q6INSN(S2_valignib,"Rdd32=3Dvalignb(Rtt32,Rss32,#u3)", +ATTRIBS(), "Vector align bytes", +{ + RddV =3D (fLSHIFTR(RssV,uiV*8,8_8))|(fASHIFTL(RttV,((8-uiV)*8),8_8)); +}) + +Q6INSN(S2_valignrb,"Rdd32=3Dvalignb(Rtt32,Rss32,Pu4)", +ATTRIBS(), "Align with register", +{ fPREDUSE_TIMING();RddV =3D fLSHIFTR(RssV,(PuV&0x7)*8,8_8)|(fASHIFTL(RttV= ,(8-(PuV&0x7))*8,8_8));}) + +Q6INSN(S2_vspliceib,"Rdd32=3Dvspliceb(Rss32,Rtt32,#u3)", +ATTRIBS(), "Vector splice bytes", +{ RddV =3D fASHIFTL(RttV,uiV*8,8_8) | fZXTN(uiV*8,64,RssV); }) + +Q6INSN(S2_vsplicerb,"Rdd32=3Dvspliceb(Rss32,Rtt32,Pu4)", +ATTRIBS(), "Splice with register", +{ fPREDUSE_TIMING();RddV =3D fASHIFTL(RttV,(PuV&7)*8,8_8) | fZXTN((PuV&7)*= 8,64,RssV); }) + +Q6INSN(S2_vsplatrh,"Rdd32=3Dvsplath(Rs32)", +ATTRIBS(), "Vector splat halfwords from register", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV, fGETHALF(0,RsV)); + } +}) + + +Q6INSN(S2_vsplatrb,"Rd32=3Dvsplatb(Rs32)", +ATTRIBS(), "Vector splat bytes from register", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETBYTE(i,RdV, fGETBYTE(0,RsV)); + } +}) + +Q6INSN(S6_vsplatrbp,"Rdd32=3Dvsplatb(Rs32)", +ATTRIBS(), "Vector splat bytes from register", +{ + fHIDE(int i;) + for (i=3D0;i<8;i++) { + fSETBYTE(i,RddV, fGETBYTE(0,RsV)); + } +}) + + + +/**********************************************/ +/* Insert/Extract[u] */ +/**********************************************/ + +Q6INSN(S2_insert,"Rx32=3Dinsert(Rs32,#u5,#U5)", +ATTRIBS(), "Insert bits", +{ + fHIDE(int) width=3DuiV; + fHIDE(int) offset=3DUiV; + /* clear bits in Rxx where new bits go */ + RxV &=3D ~(((fCONSTLL(1)<>uiV)); + fSETWORD(0,RddV,fZXTN(uiV,32,RsV)); +}) + +Q6INSN(A4_bitsplit,"Rdd32=3Dbitsplit(Rs32,Rt32)", +ATTRIBS(), "Split a bitfield into two registers", +{ + fHIDE(size4u_t) shamt =3D fZXTN(5,32,RtV); + fSETWORD(1,RddV,(fCAST4_4u(RsV)>>shamt)); + fSETWORD(0,RddV,fZXTN(shamt,32,RsV)); +}) + + + + +Q6INSN(S4_extract,"Rd32=3Dextract(Rs32,#u5,#U5)", +ATTRIBS(), "Extract signed bitfield", +{ + fHIDE(int) width=3DuiV; + fHIDE(int) offset=3DUiV; + RdV =3D fSXTN(width,32,(fCAST4_4u(RsV) >> offset)); +}) + + +Q6INSN(S2_extractu,"Rd32=3Dextractu(Rs32,#u5,#U5)", +ATTRIBS(), "Extract unsigned bitfield", +{ + fHIDE(int) width=3DuiV; + fHIDE(int) offset=3DUiV; + RdV =3D fZXTN(width,32,(fCAST4_4u(RsV) >> offset)); +}) + +Q6INSN(S2_insertp,"Rxx32=3Dinsert(Rss32,#u6,#U6)", +ATTRIBS(), "Insert bits", +{ + fHIDE(int) width=3DuiV; + fHIDE(int) offset=3DUiV; + /* clear bits in Rxx where new bits go */ + RxxV &=3D ~(((fCONSTLL(1)<> offset)); +}) + + +Q6INSN(S2_extractup,"Rdd32=3Dextractu(Rss32,#u6,#U6)", +ATTRIBS(), "Extract unsigned bitfield", +{ + fHIDE(int) width=3DuiV; + fHIDE(int) offset=3DUiV; + RddV =3D fZXTN(width,64,(fCAST8_8u(RssV) >> offset)); +}) + + + + +Q6INSN(S2_mask,"Rd32=3Dmask(#u5,#U5)", +ATTRIBS(), "Form mask from immediate", +{ + RdV =3D ((1<>uiV)); + } +}) + + +Q6INSN(S2_lsr_i_vh,"Rdd32=3Dvlsrh(Rss32,#u4)",ATTRIBS(), + "Vector Logical Shift Right by Immediate", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV, (fGETUHALF(i,RssV)>>uiV)); + } +}) + +Q6INSN(S2_asl_i_vh,"Rdd32=3Dvaslh(Rss32,#u4)",ATTRIBS(), + "Vector Arithmetic Shift Left by Immediate", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV, (fGETHALF(i,RssV)<> uiV )+1)>>1 )); + } +}) + +DEF_V5_COND_MAPPING(S5_asrhub_rnd_sat_goodsyntax,"Rd32=3Dvasrhub(Rss32,#u4= ):rnd:sat","#u4=3D=3D0","Rd32=3Dvsathub(Rss32)","Rd32=3Dvasrhub(Rss32,#u4-1= ):raw") + +Q6INSN(S5_asrhub_sat,"Rd32=3Dvasrhub(Rss32,#u4):sat",, + "Vector Arithmetic Shift Right by Immediate with Saturate and Pack", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETBYTE(i,RdV, fSATUB( fGETHALF(i,RssV) >> uiV )); + } +}) + + + +Q6INSN(S5_vasrhrnd,"Rdd32=3Dvasrh(Rss32,#u4):raw",, + "Vector Arithmetic Shift Right by Immediate with Round", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV, ( ((fGETHALF(i,RssV) >> uiV)+1)>>1 )); + } +}) + +DEF_V5_COND_MAPPING(S5_vasrhrnd_goodsyntax,"Rdd32=3Dvasrh(Rss32,#u4):rnd",= "#u4=3D=3D0","Rdd32=3DRss32","Rdd32=3Dvasrh(Rss32,#u4-1):raw") + + + +Q6INSN(S2_asl_r_vh,"Rdd32=3Dvaslh(Rss32,Rt32)",ATTRIBS(A_NOTE_OOBVSHIFT), + "Vector Arithmetic Shift Left by Register", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV, fBIDIR_ASHIFTL(fGETHALF(i,RssV),fSXTN(7,32,RtV),2_8)); + } +}) + + + +Q6INSN(S2_lsr_r_vh,"Rdd32=3Dvlsrh(Rss32,Rt32)",ATTRIBS(A_NOTE_OOBVSHIFT), + "Vector Logical Shift Right by Register", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV, fBIDIR_LSHIFTR(fGETUHALF(i,RssV),fSXTN(7,32,RtV),2_8)); + } +}) + + +Q6INSN(S2_lsl_r_vh,"Rdd32=3Dvlslh(Rss32,Rt32)",ATTRIBS(A_NOTE_OOBVSHIFT), + "Vector Logical Shift Left by Register", +{ + fHIDE(int i;) + for (i=3D0;i<4;i++) { + fSETHALF(i,RddV, fBIDIR_LSHIFTL(fGETUHALF(i,RssV),fSXTN(7,32,RtV),2_8)); + } +}) + + + + +/* Word Vector Immediate Shifts */ + +Q6INSN(S2_asr_i_vw,"Rdd32=3Dvasrw(Rss32,#u5)",ATTRIBS(), + "Vector Arithmetic Shift Right by Immediate", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETWORD(i,RddV,(fGETWORD(i,RssV)>>uiV)); + } +}) + + + +Q6INSN(S2_asr_i_svw_trun,"Rd32=3Dvasrw(Rss32,#u5)",ATTRIBS(A_ARCHV2), + "Vector Arithmetic Shift Right by Immediate with Truncate and Pack", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETHALF(i,RdV,fGETHALF(0,(fGETWORD(i,RssV)>>uiV))); + } +}) + +Q6INSN(S2_asr_r_svw_trun,"Rd32=3Dvasrw(Rss32,Rt32)",ATTRIBS(A_ARCHV2), + "Vector Arithmetic Shift Right truncate and Pack", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETHALF(i,RdV,fGETHALF(0,fBIDIR_ASHIFTR(fGETWORD(i,RssV),fSXTN(7,32,R= tV),4_8))); + } +}) + + +Q6INSN(S2_lsr_i_vw,"Rdd32=3Dvlsrw(Rss32,#u5)",ATTRIBS(), + "Vector Logical Shift Right by Immediate", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETWORD(i,RddV,(fGETUWORD(i,RssV)>>uiV)); + } +}) + +Q6INSN(S2_asl_i_vw,"Rdd32=3Dvaslw(Rss32,#u5)",ATTRIBS(), + "Vector Arithmetic Shift Left by Immediate", +{ + fHIDE(int i;) + for (i=3D0;i<2;i++) { + fSETWORD(i,RddV,(fGETWORD(i,RssV)<> 1) | (fCAST8u((1&fC= OUNTONES_8(RssV & RttV)))<<63) ; }) + +Q6INSN(S2_clbnorm,"Rd32=3Dnormamt(Rs32)",ATTRIBS(A_ARCHV2), +"Count leading sign bits - 1", { if (RsV =3D=3D 0) { RdV =3D 0; } else { R= dV =3D (fMAX(fCL1_4(RsV),fCL1_4(~RsV)))-1;} }) + +Q6INSN(S4_clbaddi,"Rd32=3Dadd(clb(Rs32),#s6)",ATTRIBS(A_ARCHV2), +"Count leading sign bits then add signed number", +{ RdV =3D (fMAX(fCL1_4(RsV),fCL1_4(~RsV)))+siV;} ) + +Q6INSN(S4_clbpnorm,"Rd32=3Dnormamt(Rss32)",ATTRIBS(A_ARCHV2), +"Count leading sign bits - 1", { if (RssV =3D=3D 0) { RdV =3D 0; } +else { RdV =3D (fMAX(fCL1_8(RssV),fCL1_8(~RssV)))-1;}}) + +Q6INSN(S4_clbpaddi,"Rd32=3Dadd(clb(Rss32),#s6)",ATTRIBS(A_ARCHV2), +"Count leading sign bits then add signed number", +{ RdV =3D (fMAX(fCL1_8(RssV),fCL1_8(~RssV)))+siV;}) + + + +Q6INSN(S2_cabacdecbin,"Rdd32=3Ddecbin(Rss32,Rtt32)",ATTRIBS(A_ARCHV3,A_NOT= E_LATEPRED,A_RESTRICT_LATEPRED),"CABAC decode bin", +{ + fHIDE(size4u_t state;) + fHIDE(size4u_t valMPS;) + fHIDE(size4u_t bitpos;) + fHIDE(size4u_t range;) + fHIDE(size4u_t offset;) + fHIDE(size4u_t rLPS;) + fHIDE(size4u_t rMPS;) + + state =3D fEXTRACTU_RANGE( fGETWORD(1,RttV) ,5,0); + valMPS =3D fEXTRACTU_RANGE( fGETWORD(1,RttV) ,8,8); + bitpos =3D fEXTRACTU_RANGE( fGETWORD(0,RttV) ,4,0); + range =3D fGETWORD(0,RssV); + offset =3D fGETWORD(1,RssV); + + /* calculate rLPS */ + range <<=3D bitpos; + offset <<=3D bitpos; + rLPS =3D rLPS_table_64x4[state][ (range >>29)&3]; + rLPS =3D rLPS << 23; /* left aligned */ + + /* calculate rMPS */ + rMPS=3D (range&0xff800000) - rLPS; + + /* most probable region */ + if (offset < rMPS) { + RddV =3D AC_next_state_MPS_64[state]; + fINSERT_RANGE(RddV,8,8,valMPS); + fINSERT_RANGE(RddV,31,23,(rMPS>>23)); + fSETWORD(1,RddV,offset); + fWRITE_P0(valMPS); + + + } + /* least probable region */ + else { + RddV =3D AC_next_state_LPS_64[state]; + fINSERT_RANGE(RddV,8,8,((!state)?(1-valMPS):(valMPS))); + fINSERT_RANGE(RddV,31,23,(rLPS>>23)); + fSETWORD(1,RddV,(offset-rMPS)); + fWRITE_P0((valMPS^1)); + } + fHIDE(MARK_LATE_PRED_WRITE(0)) +}) + + + + +Q6INSN(S2_cabacencbin,"Rdd32=3Dencbin(Rss32,Rtt32,Pu4)",ATTRIBS(A_FAKEINSN= ),"CABAC encode bin", +{ + fPREDUSE_TIMING(); + fHIDE(size4u_t state;) + fHIDE(size4u_t valMPS;) + fHIDE(size4u_t bitpos;) + fHIDE(size4u_t range;) + fHIDE(size4u_t low;) + fHIDE(size4u_t rLPS;) + fHIDE(size4u_t rMPS;) + fHIDE(size4u_t bin;) + + state =3D fEXTRACTU_RANGE( fGETWORD(1,RttV) ,5,0); + valMPS =3D fEXTRACTU_RANGE( fGETWORD(1,RttV) ,8,8); + bitpos =3D fEXTRACTU_RANGE( fGETWORD(0,RttV) ,4,0); + range =3D fGETWORD(0,RssV); + low =3D fGETWORD(1,RssV); + bin =3D fLSBOLD(PuV); + + /* Strip of MSB zeros */ + range <<=3D bitpos; + /* Mask off low bits */ + range &=3D 0xFF800000U; + + /* calculate rLPS */ + rLPS =3D rLPS_table_64x4[state][(range>>29)&3]; + rLPS =3D rLPS << 23; /* left aligned */ + + /* Calculate rMPS */ + rMPS =3D range - rLPS; + + /* most probable region */ + if (bin =3D=3D valMPS) { + RddV =3D AC_next_state_MPS_64[state]; + fINSERT_RANGE(RddV,8,8,valMPS); + fINSERT_RANGE(RddV,31,23,(rMPS>>23)); + fSETWORD(1,RddV,low); + } + /* least probable region */ + else { + RddV =3D AC_next_state_LPS_64[state]; + fINSERT_RANGE(RddV,8,8,((!state)?(1-valMPS):(valMPS))); + fINSERT_RANGE(RddV,31,23,(rLPS>>23)); + fSETWORD(1,RddV,(low+(rMPS >> bitpos))); + } +}) + + + + +Q6INSN(S2_clb,"Rd32=3Dclb(Rs32)",ATTRIBS(), +"Count leading bits", {RdV =3D fMAX(fCL1_4(RsV),fCL1_4(~RsV));}) + + +Q6INSN(S2_cl0,"Rd32=3Dcl0(Rs32)",ATTRIBS(), +"Count leading bits", {RdV =3D fCL1_4(~RsV);}) + +Q6INSN(S2_cl1,"Rd32=3Dcl1(Rs32)",ATTRIBS(), +"Count leading bits", {RdV =3D fCL1_4(RsV);}) + +Q6INSN(S2_clbp,"Rd32=3Dclb(Rss32)",ATTRIBS(), +"Count leading bits", {RdV =3D fMAX(fCL1_8(RssV),fCL1_8(~RssV));}) + +Q6INSN(S2_cl0p,"Rd32=3Dcl0(Rss32)",ATTRIBS(), +"Count leading bits", {RdV =3D fCL1_8(~RssV);}) + +Q6INSN(S2_cl1p,"Rd32=3Dcl1(Rss32)",ATTRIBS(), +"Count leading bits", {RdV =3D fCL1_8(RssV);}) + + + + +Q6INSN(S2_brev, "Rd32=3Dbrev(Rs32)", ATTRIBS(A_ARCHV2), "Bit Reverse",{R= dV =3D fBREV_4(RsV);}) +Q6INSN(S2_brevp,"Rdd32=3Dbrev(Rss32)", ATTRIBS(), "Bit Reverse",{RddV =3D = fBREV_8(RssV);}) +Q6INSN(S2_ct0, "Rd32=3Dct0(Rs32)", ATTRIBS(A_ARCHV2), "Count Trailing"= ,{RdV =3D fCL1_4(~fBREV_4(RsV));}) +Q6INSN(S2_ct1, "Rd32=3Dct1(Rs32)", ATTRIBS(A_ARCHV2), "Count Trailing"= ,{RdV =3D fCL1_4(fBREV_4(RsV));}) +Q6INSN(S2_ct0p, "Rd32=3Dct0(Rss32)", ATTRIBS(), "Count Trailing",{RdV = =3D fCL1_8(~fBREV_8(RssV));}) +Q6INSN(S2_ct1p, "Rd32=3Dct1(Rss32)", ATTRIBS(), "Count Trailing",{RdV = =3D fCL1_8(fBREV_8(RssV));}) + + +Q6INSN(S2_interleave,"Rdd32=3Dinterleave(Rss32)",ATTRIBS(A_ARCHV2),"Interl= eave bits", +{RddV =3D fINTERLEAVE(fGETWORD(1,RssV),fGETWORD(0,RssV));}) + +Q6INSN(S2_deinterleave,"Rdd32=3Ddeinterleave(Rss32)",ATTRIBS(A_ARCHV2),"In= terleave bits", +{RddV =3D fDEINTERLEAVE(RssV);}) + + + + +Q6INSN(S6_userinsn,"Rxx32=3Duserinsn(Rss32,Rtt32,#u7)",ATTRIBS(A_FAKEINSN), +"User Defined Instruction", +{ + if (thread->processor_ptr->options->userinsn_callback) { + RxxV =3D thread->processor_ptr->options->userinsn_callback( + thread->system_ptr,thread->processor_ptr, + thread->threadId,RssV,RttV,RxxV,uiV); + } else { + warn("User instruction encountered but no callback!"); + } + +}) + + + + + + + diff --git a/target/hexagon/imported/subinsns.idef b/target/hexagon/importe= d/subinsns.idef new file mode 100644 index 0000000..08658df --- /dev/null +++ b/target/hexagon/imported/subinsns.idef @@ -0,0 +1,152 @@ +/* + * Copyright(c) 2019-2020 Qualcomm Innovation Center, Inc. All Rights Res= erved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +/* + * sub-instructions + */ + + + +/*****************************************************************/ +/* */ +/* A-type subinsns */ +/* */ +/*****************************************************************/ + +Q6INSN(SA1_addi, "Rx16=3Dadd(Rx16,#s7)", ATTRIBS(A_SUBINSN),"Add", = { fIMMEXT(siV); RxV=3DRxV+siV;}) +Q6INSN(SA1_tfr, "Rd16=3DRs16", ATTRIBS(A_SUBINSN),"Tfr", = { RdV=3DRsV;}) +Q6INSN(SA1_seti, "Rd16=3D#u6", ATTRIBS(A_SUBINSN),"Set im= med", { fIMMEXT(uiV); RdV=3DuiV;}) +Q6INSN(SA1_setin1, "Rd16=3D#-1", ATTRIBS(A_SUBINSN),"Set to= -1", { RdV=3D-1;}) +Q6INSN(SA1_clrtnew, "if (p0.new) Rd16=3D#0", ATTRIBS(A_SUBINSN),"clear = if true", { if (fLSBNEW0) {RdV=3D0;} else {CANCEL;} }) +Q6INSN(SA1_clrfnew, "if (!p0.new) Rd16=3D#0", ATTRIBS(A_SUBINSN),"clear = if false",{ if (fLSBNEW0NOT) {RdV=3D0;} else {CANCEL;} }) +Q6INSN(SA1_clrt, "if (p0) Rd16=3D#0", ATTRIBS(A_SUBINSN),"clear = if true", { if (fLSBOLD(fREAD_P0())) {RdV=3D0;} else {CANCEL;} }) +Q6INSN(SA1_clrf, "if (!p0) Rd16=3D#0", ATTRIBS(A_SUBINSN),"clear = if false",{ if (fLSBOLDNOT(fREAD_P0())) {RdV=3D0;} else {CANCEL;} }) + +Q6INSN(SA1_addsp, "Rd16=3Dadd(r29,#u6:2)", ATTRIBS(A_SUBINSN),"Add", = { RdV=3DfREAD_SP()+uiV; }) +Q6INSN(SA1_inc, "Rd16=3Dadd(Rs16,#1)", ATTRIBS(A_SUBINSN),"Inc", = { RdV=3DRsV+1;}) +Q6INSN(SA1_dec, "Rd16=3Dadd(Rs16,#-1)", ATTRIBS(A_SUBINSN),"Dec", = { RdV=3DRsV-1;}) +Q6INSN(SA1_addrx, "Rx16=3Dadd(Rx16,Rs16)", ATTRIBS(A_SUBINSN,A_COMMUT= ES),"Add", { RxV=3DRxV+RsV; }) +Q6INSN(SA1_zxtb, "Rd16=3Dand(Rs16,#255)", ATTRIBS(A_SUBINSN),"Zxtb",= { RdV=3D fZXTN(8,32,RsV);}) +Q6INSN(SA1_and1, "Rd16=3Dand(Rs16,#1)", ATTRIBS(A_SUBINSN),"And #1= ", { RdV=3D RsV&1;}) +Q6INSN(SA1_sxtb, "Rd16=3Dsxtb(Rs16)", ATTRIBS(A_SUBINSN),"Sxtb",= { RdV=3D fSXTN(8,32,RsV);}) +Q6INSN(SA1_zxth, "Rd16=3Dzxth(Rs16)", ATTRIBS(A_SUBINSN),"Zxth",= { RdV=3D fZXTN(16,32,RsV);}) +Q6INSN(SA1_sxth, "Rd16=3Dsxth(Rs16)", ATTRIBS(A_SUBINSN),"Sxth",= { RdV=3D fSXTN(16,32,RsV);}) +Q6INSN(SA1_combinezr,"Rdd8=3Dcombine(#0,Rs16)", ATTRIBS(A_SUBINSN,A_ROPS_2= ),"Combines", { fSETWORD(0,RddV,RsV); fSETWORD(1,RddV,0); }) +Q6INSN(SA1_combinerz,"Rdd8=3Dcombine(Rs16,#0)", ATTRIBS(A_SUBINSN,A_ROPS_2= ),"Combines", { fSETWORD(0,RddV,0); fSETWORD(1,RddV,RsV); }) +Q6INSN(SA1_combine0i,"Rdd8=3Dcombine(#0,#u2)", ATTRIBS(A_SUBINSN,A_ROPS_2)= ,"Combines", { fSETWORD(0,RddV,uiV); fSETWORD(1,RddV,0); }) +Q6INSN(SA1_combine1i,"Rdd8=3Dcombine(#1,#u2)", ATTRIBS(A_SUBINSN,A_ROPS_2)= ,"Combines", { fSETWORD(0,RddV,uiV); fSETWORD(1,RddV,1); }) +Q6INSN(SA1_combine2i,"Rdd8=3Dcombine(#2,#u2)", ATTRIBS(A_SUBINSN,A_ROPS_2)= ,"Combines", { fSETWORD(0,RddV,uiV); fSETWORD(1,RddV,2); }) +Q6INSN(SA1_combine3i,"Rdd8=3Dcombine(#3,#u2)", ATTRIBS(A_SUBINSN,A_ROPS_2)= ,"Combines", { fSETWORD(0,RddV,uiV); fSETWORD(1,RddV,3); }) +Q6INSN(SA1_cmpeqi, "p0=3Dcmp.eq(Rs16,#u2)", ATTRIBS(A_SUBINSN),"Compar= eImmed",{fWRITE_P0(f8BITSOF(RsV=3D=3DuiV));}) + + + + +/*****************************************************************/ +/* */ +/* Ld1/2 subinsns */ +/* */ +/*****************************************************************/ + +Q6INSN(SL1_loadri_io, "Rd16=3Dmemw(Rs16+#u4:2)", ATTRIBS(A_MEMSIZE_4B,A_L= OAD,A_SUBINSN),"load word", {fEA_RI(RsV,uiV); fLOAD(1,4,u,EA,RdV);}) +Q6INSN(SL1_loadrub_io, "Rd16=3Dmemub(Rs16+#u4:0)",ATTRIBS(A_MEMSIZE_1B,A_L= OAD,A_SUBINSN),"load byte", {fEA_RI(RsV,uiV); fLOAD(1,1,u,EA,RdV);}) + +Q6INSN(SL2_loadrh_io, "Rd16=3Dmemh(Rs16+#u3:1)", ATTRIBS(A_MEMSIZE_2B,A_L= OAD,A_SUBINSN),"load half", {fEA_RI(RsV,uiV); fLOAD(1,2,s,EA,RdV);}) +Q6INSN(SL2_loadruh_io, "Rd16=3Dmemuh(Rs16+#u3:1)",ATTRIBS(A_MEMSIZE_2B,A_L= OAD,A_SUBINSN),"load half", {fEA_RI(RsV,uiV); fLOAD(1,2,u,EA,RdV);}) +Q6INSN(SL2_loadrb_io, "Rd16=3Dmemb(Rs16+#u3:0)", ATTRIBS(A_MEMSIZE_1B,A_L= OAD,A_SUBINSN),"load byte", {fEA_RI(RsV,uiV); fLOAD(1,1,s,EA,RdV);}) +Q6INSN(SL2_loadri_sp, "Rd16=3Dmemw(r29+#u5:2)", ATTRIBS(A_MEMSIZE_4B,A_L= OAD,A_SUBINSN),"load word", {fEA_RI(fREAD_SP(),uiV); fLOAD(1,4,u,EA,RdV);}) +Q6INSN(SL2_loadrd_sp, "Rdd8=3Dmemd(r29+#u5:3)", ATTRIBS(A_MEMSIZE_8B,A_LO= AD,A_SUBINSN),"load dword",{fEA_RI(fREAD_SP(),uiV); fLOAD(1,8,u,EA,RddV);}) + +Q6INSN(SL2_deallocframe,"deallocframe", ATTRIBS(A_SUBINSN,A_MEMSIZE_8B,A_L= OAD,A_DEALLOCFRAME), "Deallocate stack frame", +{ fHIDE(size8u_t tmp;) fEA_REG(fREAD_FP()); + fLOAD(1,8,u,EA,tmp); + tmp =3D fFRAME_UNSCRAMBLE(tmp); + fWRITE_LR(fGETWORD(1,tmp)); + fWRITE_FP(fGETWORD(0,tmp)); + fWRITE_SP(EA+8); }) + +Q6INSN(SL2_return,"dealloc_return", ATTRIBS(A_JINDIR,A_SUBINSN,A_ROPS_2,A_= MEMSIZE_8B,A_LOAD,A_RETURN,A_RESTRICT_SLOT0ONLY,A_RET_TYPE,A_DEALLOCRET), "= Deallocate stack frame and return", +{ fHIDE(size8u_t tmp;) fEA_REG(fREAD_FP()); + fLOAD(1,8,u,EA,tmp); + tmp =3D fFRAME_UNSCRAMBLE(tmp); + fWRITE_LR(fGETWORD(1,tmp)); + fWRITE_FP(fGETWORD(0,tmp)); + fWRITE_SP(EA+8); + fJUMPR(REG_LR,fGETWORD(1,tmp),COF_TYPE_JUMPR);}) + +Q6INSN(SL2_return_t,"if (p0) dealloc_return", ATTRIBS(A_JINDIROLD,A_SUBINS= N,A_ROPS_2,A_MEMSIZE_8B,A_LOAD,A_RETURN,A_RESTRICT_SLOT0ONLY,A_RET_TYPE,A_P= RED_BIT_4), "Deallocate stack frame and return", +{ fHIDE(size8u_t tmp;); fBRANCH_SPECULATE_STALL(fLSBOLD(fREAD_P0()),, SPEC= ULATE_NOT_TAKEN,4,0); fEA_REG(fREAD_FP()); if (fLSBOLD(fREAD_P0())) { fLOAD= (1,8,u,EA,tmp); tmp =3D fFRAME_UNSCRAMBLE(tmp); fWRITE_LR(fGETWORD(1,tmp));= fWRITE_FP(fGETWORD(0,tmp)); fWRITE_SP(EA+8); + fJUMPR(REG_LR,fGETWORD(1,tmp),COF_TYPE_JUMPR);} else {LOAD_CANCEL(EA);} = }) + +Q6INSN(SL2_return_f,"if (!p0) dealloc_return", ATTRIBS(A_JINDIROLD,A_SUBIN= SN,A_ROPS_2,A_MEMSIZE_8B,A_LOAD,A_RETURN,A_RESTRICT_SLOT0ONLY,A_RET_TYPE,A_= PRED_BIT_4), "Deallocate stack frame and return", +{ fHIDE(size8u_t tmp;);fBRANCH_SPECULATE_STALL(fLSBOLDNOT(fREAD_P0()),, SP= ECULATE_NOT_TAKEN,4,0); fEA_REG(fREAD_FP()); if (fLSBOLDNOT(fREAD_P0())) { = fLOAD(1,8,u,EA,tmp); tmp =3D fFRAME_UNSCRAMBLE(tmp); fWRITE_LR(fGETWORD(1,t= mp)); fWRITE_FP(fGETWORD(0,tmp)); fWRITE_SP(EA+8); + fJUMPR(REG_LR,fGETWORD(1,tmp),COF_TYPE_JUMPR);} else {LOAD_CANCEL(EA);} = }) + + + +Q6INSN(SL2_return_tnew,"if (p0.new) dealloc_return:nt", ATTRIBS(A_JINDIRNE= W,A_SUBINSN,A_ROPS_2,A_MEMSIZE_8B,A_LOAD,A_RETURN,A_RESTRICT_SLOT0ONLY,A_RE= T_TYPE,A_PRED_BIT_4), "Deallocate stack frame and return", +{ fHIDE(size8u_t tmp;) fBRANCH_SPECULATE_STALL(fLSBNEW0,, SPECULATE_NOT_TA= KEN , 4,3); fEA_REG(fREAD_FP()); if (fLSBNEW0) { fLOAD(1,8,u,EA,tmp); tmp = =3D fFRAME_UNSCRAMBLE(tmp); fWRITE_LR(fGETWORD(1,tmp)); fWRITE_FP(fGETWORD(= 0,tmp)); fWRITE_SP(EA+8); + fJUMPR(REG_LR,fGETWORD(1,tmp),COF_TYPE_JUMPR);} else {LOAD_CANCEL(EA);} = }) + +Q6INSN(SL2_return_fnew,"if (!p0.new) dealloc_return:nt", ATTRIBS(A_JINDIRN= EW,A_SUBINSN,A_ROPS_2,A_MEMSIZE_8B,A_LOAD,A_RETURN,A_RESTRICT_SLOT0ONLY,A_R= ET_TYPE,A_PRED_BIT_4), "Deallocate stack frame and return", +{ fHIDE(size8u_t tmp;) fBRANCH_SPECULATE_STALL(fLSBNEW0NOT,, SPECULATE_NOT= _TAKEN , 4,3); fEA_REG(fREAD_FP()); if (fLSBNEW0NOT) { fLOAD(1,8,u,EA,tmp);= tmp =3D fFRAME_UNSCRAMBLE(tmp); fWRITE_LR(fGETWORD(1,tmp)); fWRITE_FP(fGET= WORD(0,tmp)); fWRITE_SP(EA+8); + fJUMPR(REG_LR,fGETWORD(1,tmp),COF_TYPE_JUMPR);} else {LOAD_CANCEL(EA);} = }) + + +Q6INSN(SL2_jumpr31,"jumpr r31",ATTRIBS(A_SUBINSN,A_JINDIR,A_RESTRICT_SLOT0= ONLY,A_RET_TYPE),"indirect unconditional jump", +{ fJUMPR(REG_LR,fREAD_LR(),COF_TYPE_JUMPR);}) + +Q6INSN(SL2_jumpr31_t,"if (p0) jumpr r31",ATTRIBS(A_SUBINSN,A_JINDIROLD,A_N= OTE_CONDITIONAL,A_RESTRICT_SLOT0ONLY,A_RET_TYPE,A_PRED_BIT_4),"indirect con= ditional jump if true", +{fBRANCH_SPECULATE_STALL(fLSBOLD(fREAD_P0()),, SPECULATE_TAKEN,4,0); if (f= LSBOLD(fREAD_P0())) {fJUMPR(REG_LR,fREAD_LR(),COF_TYPE_JUMPR);}}) + +Q6INSN(SL2_jumpr31_f,"if (!p0) jumpr r31",ATTRIBS(A_SUBINSN,A_JINDIROLD,A_= NOTE_CONDITIONAL,A_RESTRICT_SLOT0ONLY,A_RET_TYPE,A_PRED_BIT_4),"indirect co= nditional jump if false", +{fBRANCH_SPECULATE_STALL(fLSBOLDNOT(fREAD_P0()),, SPECULATE_TAKEN,4,0); if= (fLSBOLDNOT(fREAD_P0())) {fJUMPR(REG_LR,fREAD_LR(),COF_TYPE_JUMPR);}}) + + + +Q6INSN(SL2_jumpr31_tnew,"if (p0.new) jumpr:nt r31",ATTRIBS(A_SUBINSN,A_JIN= DIRNEW,A_NOTE_CONDITIONAL,A_RESTRICT_SLOT0ONLY,A_RET_TYPE,A_PRED_BIT_4),"in= direct conditional jump if true", +{fBRANCH_SPECULATE_STALL(fLSBNEW0,, SPECULATE_NOT_TAKEN , 4,3); if (fLSBNE= W0) {fJUMPR(REG_LR,fREAD_LR(),COF_TYPE_JUMPR);}}) + +Q6INSN(SL2_jumpr31_fnew,"if (!p0.new) jumpr:nt r31",ATTRIBS(A_SUBINSN,A_JI= NDIRNEW,A_NOTE_CONDITIONAL,A_RESTRICT_SLOT0ONLY,A_RET_TYPE,A_PRED_BIT_4),"i= ndirect conditional jump if false", +{fBRANCH_SPECULATE_STALL(fLSBNEW0NOT,, SPECULATE_NOT_TAKEN , 4,3); if (fLS= BNEW0NOT) {fJUMPR(REG_LR,fREAD_LR(),COF_TYPE_JUMPR);}}) + + + + + +/*****************************************************************/ +/* */ +/* St1/2 subinsns */ +/* */ +/*****************************************************************/ + +Q6INSN(SS1_storew_io, "memw(Rs16+#u4:2)=3DRt16", ATTRIBS(A_MEMSIZE_4B,A_S= TORE,A_SUBINSN), "store word", {fEA_RI(RsV,uiV); fSTORE(1,4,EA,RtV);}) +Q6INSN(SS1_storeb_io, "memb(Rs16+#u4:0)=3DRt16", ATTRIBS(A_MEMSIZE_1B,A_S= TORE,A_SUBINSN), "store byte", {fEA_RI(RsV,uiV); fSTORE(1,1,EA,fGETBYTE(0,R= tV));}) +Q6INSN(SS2_storeh_io, "memh(Rs16+#u3:1)=3DRt16", ATTRIBS(A_MEMSIZE_2B,A_S= TORE,A_SUBINSN), "store half", {fEA_RI(RsV,uiV); fSTORE(1,2,EA,fGETHALF(0,R= tV));}) +Q6INSN(SS2_stored_sp, "memd(r29+#s6:3)=3DRtt8", ATTRIBS(A_MEMSIZE_8B,A_ST= ORE,A_SUBINSN), "store dword",{fEA_RI(fREAD_SP(),siV); fSTORE(1,8,EA,RttV);= }) +Q6INSN(SS2_storew_sp, "memw(r29+#u5:2)=3DRt16", ATTRIBS(A_MEMSIZE_4B,A_S= TORE,A_SUBINSN), "store word", {fEA_RI(fREAD_SP(),uiV); fSTORE(1,4,EA,RtV);= }) +Q6INSN(SS2_storewi0, "memw(Rs16+#u4:2)=3D#0", ATTRIBS(A_MEMSIZE_4B,A_STO= RE,A_SUBINSN,A_ROPS_2), "store word", {fEA_RI(RsV,uiV); fSTORE(1,4,EA,0);}) +Q6INSN(SS2_storebi0, "memb(Rs16+#u4:0)=3D#0", ATTRIBS(A_MEMSIZE_1B,A_STO= RE,A_SUBINSN,A_ROPS_2), "store byte", {fEA_RI(RsV,uiV); fSTORE(1,1,EA,0);}) +Q6INSN(SS2_storewi1, "memw(Rs16+#u4:2)=3D#1", ATTRIBS(A_MEMSIZE_4B,A_STO= RE,A_SUBINSN,A_ROPS_2), "store word", {fEA_RI(RsV,uiV); fSTORE(1,4,EA,1);}) +Q6INSN(SS2_storebi1, "memb(Rs16+#u4:0)=3D#1", ATTRIBS(A_MEMSIZE_1B,A_STO= RE,A_SUBINSN,A_ROPS_2), "store byte", {fEA_RI(RsV,uiV); fSTORE(1,1,EA,1);}) + + +Q6INSN(SS2_allocframe,"allocframe(#u5:3)", ATTRIBS(A_SUBINSN,A_MEMSIZE_8B,= A_STORE,A_RESTRICT_SLOT0ONLY), "Allocate stack frame", +{ fEA_RI(fREAD_SP(),-8); fSTORE(1,8,EA,fFRAME_SCRAMBLE((fCAST8_8u(fREAD_L= R()) << 32) | fCAST4_4u(fREAD_FP()))); fWRITE_FP(EA); fFRAMECHECK(EA-uiV,EA= ); fWRITE_SP(EA-uiV); }) + + + diff --git a/target/hexagon/imported/system.idef b/target/hexagon/imported/= system.idef new file mode 100644 index 0000000..86660c5 --- /dev/null +++ b/target/hexagon/imported/system.idef @@ -0,0 +1,302 @@ +/* + * Copyright(c) 2019-2020 Qualcomm Innovation Center, Inc. All Rights Res= erved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +/* + * System Interface Instructions + */ + + + +/********************************************/ +/* User->OS interface */ +/********************************************/ + +Q6INSN(J2_trap0,"trap0(#u8)",ATTRIBS(A_COF,A_NOTE_NOPACKET,A_RESTRICT_NOPA= CKET), +"Trap to Operating System", + fTRAP(0,uiV); +) + +Q6INSN(J2_trap1,"trap1(Rx32,#u8)",ATTRIBS(A_COF,A_NOTE_NOPACKET,A_RESTRICT= _NOPACKET), +"Trap to Operating System", + /* + * Note: if RxV is not written, we get the same as the input. + * Since trap1 is SOLO, this means the register will effectively not be u= pdated + */ + if (!fTRAP1_VIRTINSN(uiV)) { + fTRAP(1,uiV); + } else if (uiV =3D=3D 1) { + fVIRTINSN_RTE(uiV,RxV); + } else if (uiV =3D=3D 3) { + fVIRTINSN_SETIE(uiV,RxV); + } else if (uiV =3D=3D 4) { + fVIRTINSN_GETIE(uiV,RxV); + } else if (uiV =3D=3D 6) { + fVIRTINSN_SPSWAP(uiV,RxV); + }) + +DEF_MAPPING(J2_trap1_noregmap,"trap1(#u8)","trap1(R0,#u8)") + +Q6INSN(J2_pause,"pause(#u8)",ATTRIBS(A_COF,A_NOTE_NOPACKET,A_RESTRICT_NOPA= CKET), +"Enter low-power state for #u8 cycles",{fPAUSE(uiV);}) + +Q6INSN(J2_rte, "rte", ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NO_TIMING_LOG), +"Return from Exception", +{ +fHIDE(if((thread->timing_on) && (thread->status & EXEC_STATUS_REPLAY)) { r= eturn; }) +fHIDE(CALLBACK(thread->processor_ptr->options->rte_callback, + thread->system_ptr,thread->processor_ptr, + thread->threadId,0);) +fCLEAR_RTE_EX(); +fBRANCH(fREAD_ELR(),COF_TYPE_RTE);}) + + +/********************************************/ +/* Interrupt Management */ +/********************************************/ + +Q6INSN(Y2_swi,"swi(Rs32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_AXOK,A_RESTRIC= T_PACKET_AXOK),"Software Interrupt",{DO_SWI(RsV);}) +Q6INSN(Y2_cswi,"cswi(Rs32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_AXOK,A_RESTR= ICT_PACKET_AXOK),"Cancel Software Interrupt",{DO_CSWI(RsV);}) +Q6INSN(Y2_ciad,"ciad(Rs32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_AXOK,A_RESTR= ICT_PACKET_AXOK),"Re-enable interrupt in IAD",{DO_CIAD(RsV);}) +Q6INSN(Y4_siad,"siad(Rs32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_AXOK,A_RESTR= ICT_PACKET_AXOK),"Disable interrupt in IAD",{DO_SIAD(RsV);}) +Q6INSN(Y2_iassignr,"Rd32=3Diassignr(Rs32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NO= TE_AXOK,A_RESTRICT_PACKET_AXOK),"Read interrupt to thread assignments",{DO_= IASSIGNR(RsV,RdV);}) +Q6INSN(Y2_iassignw,"iassignw(Rs32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_AXOK= ,A_RESTRICT_PACKET_AXOK),"Write interrupt to thread assignments",{DO_IASSIG= NW(RsV);}) + + +Q6INSN(Y2_getimask,"Rd32=3Dgetimask(Rs32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NO= TE_AXOK,A_RESTRICT_PACKET_AXOK),"Read imask register of another thread", +{RdV =3D READ_IMASK(RsV & thread->processor_ptr->thread_system_mask); }) + +Q6INSN(Y2_setimask,"setimask(Pt4,Rs32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_= AXOK,A_RESTRICT_PACKET_AXOK),"Change imask register of another thread", +{fPREDUSE_TIMING();WRITE_IMASK(PtV & thread->processor_ptr->thread_system_= mask,RsV); }) + + + +/********************************************/ +/* TLB management */ +/********************************************/ + +Q6INSN(Y2_tlbw,"tlbw(Rss32,Rt32)", ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_NOPAC= KET,A_RESTRICT_NOPACKET), +"Write TLB entry", {fTLBW(RtV,RssV);}) + +Q6INSN(Y5_ctlbw,"Rd32=3Dctlbw(Rss32,Rt32)", ATTRIBS(A_PRIV,A_NOTE_PRIV,A_N= OTE_NOPACKET,A_RESTRICT_NOPACKET), +"Conditional Write TLB entry", +{ + if (fTLB_ENTRY_OVERLAP( (1LL<<63) | RssV )) { + RdV=3DfTLB_ENTRY_OVERLAP_IDX( (1LL<<63) | RssV); + } else { + fTLBW(RtV,RssV); + RdV=3D0x80000000; + } +}) + +Q6INSN(Y5_tlboc,"Rd32=3Dtlboc(Rss32)", ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_N= OPACKET,A_RESTRICT_NOPACKET), +"TLB overlap check", +{ + if (fTLB_ENTRY_OVERLAP( (1LL<<63) | RssV )) { + RdV=3DfTLB_ENTRY_OVERLAP_IDX( (1LL<<63) | RssV); + } else { + RdV=3D0x80000000; + } +}) + +Q6INSN(Y2_tlbr,"Rdd32=3Dtlbr(Rs32)", ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_NOP= ACKET,A_RESTRICT_NOPACKET), "Read TLB entry", +{RddV =3D fTLBR(RsV);}) + +Q6INSN(Y2_tlbp,"Rd32=3Dtlbp(Rs32)", ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_NOPA= CKET,A_RESTRICT_NOPACKET), "Probe TLB", {RdV=3DfTLBP(RsV);}) + +Q6INSN(Y5_tlbasidi,"tlbinvasid(Rs32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_NO= PACKET,A_RESTRICT_NOPACKET), "Invalidate ASID", +{ + fHIDE(int i;) + fHIDE(unsigned int NUM_TLB_ENTRIES =3D NUM_TLB_REGS(thread->processor_= ptr);) + for (i =3D 0; i < NUM_TLB_ENTRIES; i++) { + if ((fGET_FIELD(fTLBR(i),PTE_G) =3D=3D 0) && + (fGET_FIELD(fTLBR(i),PTE_ASID) =3D=3D fEXTRACTU_RANGE(RsV,26,20))) { + fTLBW(i,fTLBR(i) & ~(1ULL << 63)); + } + } +}) + +Q6INSN(Y2_tlblock,"tlblock", ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_NOPACKET,A_= RESTRICT_NOPACKET,A_NO_TIMING_LOG), "Lock TLB", +{fSET_TLB_LOCK()}) + +Q6INSN(Y2_tlbunlock,"tlbunlock", ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_NOPACKE= T,A_RESTRICT_NOPACKET), "Unlock TLB", +{fCLEAR_TLB_LOCK();}) + +DEF_MAPPING(Y2_k1lock_map,"k1lock","tlblock") +DEF_MAPPING(Y2_k1unlock_map,"k1unlock","tlbunlock") + +Q6INSN(Y2_k0lock,"k0lock", ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_NOPACKET,A_RE= STRICT_NOPACKET,A_NO_TIMING_LOG), "Lock K0", +{fSET_K0_LOCK()}) + +Q6INSN(Y2_k0unlock,"k0unlock", ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_NOPACKET,= A_RESTRICT_NOPACKET), "Unlock K0", +{fCLEAR_K0_LOCK();}) + +/********************************************/ +/* Supervisor Reg Management */ +/********************************************/ + +DEF_V4_MAPPING(Y2_crswap_old,"crswap(Rx32,sgp)","crswap(Rx32,sgp0)") + +Q6INSN(Y2_crswap0,"crswap(Rx32,sgp0)",ATTRIBS(A_PRIV,A_NOTE_PRIV), "Swap s= ystem general pointer 0 with GPR", +{fHIDE(size4s_t tmp;) tmp =3D RxV; RxV =3D READ_SGP0(); WRITE_SGP0(tmp);}) +Q6INSN(Y4_crswap1,"crswap(Rx32,sgp1)",ATTRIBS(A_PRIV,A_NOTE_PRIV), "Swap s= ystem general pointer 1 with GPR", +{fHIDE(size4s_t tmp;) tmp =3D RxV; RxV =3D READ_SGP1(); WRITE_SGP1(tmp);}) + +Q6INSN(Y4_crswap10,"crswap(Rxx32,sgp1:0)",ATTRIBS(A_PRIV,A_NOTE_PRIV), "Sw= ap system general purpose 0/1 with GPR Pair", +{fHIDE(size8s_t tmp;) tmp =3D RxxV; RxxV=3DREAD_SGP10(); WRITE_SGP10(tmp);= }) + +Q6INSN(Y2_tfrscrr,"Rd32=3DSs128",ATTRIBS(A_PRIV,A_NOTE_PRIV),"Transfer Sup= ervisor Reg to GPR", {RdV=3DSsV;}) +Q6INSN(Y2_tfrsrcr,"Sd128=3DRs32",ATTRIBS(A_PRIV,A_NOTE_PRIV),"Transfer GPR= to Supervisor Reg", {SdV=3DRsV;}) +Q6INSN(Y4_tfrscpp,"Rdd32=3DSss128",ATTRIBS(A_PRIV,A_NOTE_PRIV),"Transfer S= upervisor Reg to GPR", {RddV=3DSssV;}) +Q6INSN(Y4_tfrspcp,"Sdd128=3DRss32",ATTRIBS(A_PRIV,A_NOTE_PRIV),"Transfer G= PR to Supervisor Reg", {SddV=3DRssV;}) + +#ifdef PTWALK +Q6INSN(Y6_tfracrr,"Rd32=3DAs64",ATTRIBS(A_PRIV,A_NOTE_PRIV),"Transfer Addr= ess Reg to GPR", {RdV=3DAsV;}) +Q6INSN(Y6_tfrarcr,"Ad64=3DRs32",ATTRIBS(A_PRIV,A_NOTE_PRIV),"Transfer GPR = to Address Reg", {AdV=3DRsV;}) +Q6INSN(Y6_tfracpp,"Rdd32=3DAss64",ATTRIBS(A_PRIV,A_NOTE_PRIV),"Transfer Ad= dress Reg to GPR", {RddV=3DAssV;}) +Q6INSN(Y6_tfrapcp,"Add64=3DRss32",ATTRIBS(A_PRIV,A_NOTE_PRIV),"Transfer GP= R to Address Reg", {AddV=3DRssV;}) +#endif + +Q6INSN(G4_tfrgcrr,"Rd32=3DGs32",ATTRIBS(A_GUEST,A_NOTE_GUEST),"Transfer Gu= est Reg to GPR", {RdV=3DGsV;}) +Q6INSN(G4_tfrgrcr,"Gd32=3DRs32",ATTRIBS(A_GUEST,A_NOTE_GUEST),"Transfer GP= R to Guest Reg", {GdV=3DRsV;}) +Q6INSN(G4_tfrgcpp,"Rdd32=3DGss32",ATTRIBS(A_GUEST,A_NOTE_GUEST),"Transfer = Guest Reg to GPR", {RddV=3DGssV;}) +Q6INSN(G4_tfrgpcp,"Gdd32=3DRss32",ATTRIBS(A_GUEST,A_NOTE_GUEST),"Transfer = GPR to Guest Reg", {GddV=3DRssV;}) + + + +Q6INSN(Y2_setprio,"setprio(Pt4,Rs32)",ATTRIBS(A_PRIV,A_NOTE_PRIV),"Change = TID Prio of another thread", +{fPREDUSE_TIMING();WRITE_PRIO(PtV & thread->processor_ptr->thread_system_m= ask,RsV); }) + + + + +/********************************************/ +/* Power Management / Thread on/off */ +/********************************************/ +Q6INSN(Y6_diag,"diag(Rs32)",ATTRIBS(),"Send value to Diag trace module",{ +}) +Q6INSN(Y6_diag0,"diag0(Rss32,Rtt32)",ATTRIBS(),"Send values of two registe= r to DIAG Trace. Set X=3D0",{ +}) +Q6INSN(Y6_diag1,"diag1(Rss32,Rtt32)",ATTRIBS(),"Send values of two registe= r to DIAG Trace. Set X=3D1",{ +}) + + +Q6INSN(Y4_trace,"trace(Rs32)",ATTRIBS(A_NOTE_AXOK,A_RESTRICT_PACKET_AXOK),= "Send value to ETM trace",{ + fDO_TRACE(RsV); +}) + +Q6INSN(Y2_stop,"stop(Rs32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_NOPACKET,A_R= ESTRICT_NOPACKET),"Stop thread(s)",{ + fHIDE(RsV=3DRsV;) + if (!fIN_DEBUG_MODE_NO_ISDB(fGET_TNUM())) fCLEAR_RUN_MODE(fGET_TNUM()); +}) + +Q6INSN(Y4_nmi,"nmi(Rs32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_NOPACKET,A_RES= TRICT_NOPACKET,A_NO_TIMING_LOG),"Raise NMI on thread(s)",{ + fDO_NMI(RsV); +}) + +Q6INSN(Y2_start,"start(Rs32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_NOPACKET,A= _RESTRICT_NOPACKET),"Start thread(s)",fSTART(RsV);) + +Q6INSN(Y2_wait,"wait(Rs32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_NOPACKET,A_R= ESTRICT_NOPACKET,A_NO_TIMING_LOG),"Make thread(s) wait",{ + fHIDE(RsV=3DRsV;) + if (!fIN_DEBUG_MODE(fGET_TNUM())) fSET_WAIT_MODE(fGET_TNUM()); + fIN_DEBUG_MODE_WARN(fGET_TNUM()); +}) + +Q6INSN(Y2_resume,"resume(Rs32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_NOPACKET= ,A_RESTRICT_NOPACKET),"Make thread(s) stop waiting",fRESUME(RsV);) + +Q6INSN(Y2_break,"brkpt",ATTRIBS(A_NOTE_NOPACKET,A_RESTRICT_NOPACKET),"Brea= kpoint",{fBREAK();}) + + +/********************************************/ +/* Cache Management */ +/********************************************/ + +Q6INSN(Y2_ictagr,"Rd32=3Dictagr(Rs32)",ATTRIBS(A_ICOP,A_PRIV,A_NOTE_PRIV,A= _NOTE_NOPACKET,A_RESTRICT_NOPACKET,A_CACHEOP,A_COPBYIDX,A_ICTAGOP),"Instruc= tion Cache Tag Read",{fICTAGR(RsV,RdV,RdN);}) +Q6INSN(Y2_ictagw,"ictagw(Rs32,Rt32)",ATTRIBS(A_ICOP,A_PRIV,A_NOTE_PRIV,A_N= OTE_NOPACKET,A_RESTRICT_NOPACKET,A_CACHEOP,A_COPBYIDX,A_ICTAGOP),"Instructi= on Cache Tag Write",{fICTAGW(RsV,RtV);}) +Q6INSN(Y2_icdataw,"icdataw(Rs32,Rt32)",ATTRIBS(A_ICOP,A_PRIV,A_NOTE_PRIV,A= _NOTE_NOPACKET,A_RESTRICT_NOPACKET,A_CACHEOP,A_COPBYIDX,A_ICTAGOP),"Instruc= tion Cache Data Write",{fICDATAW(RsV,RtV);}) +Q6INSN(Y2_icdatar,"Rd32=3Dicdatar(Rs32)",ATTRIBS(A_ICOP,A_PRIV,A_NOTE_PRIV= ,A_NOTE_NOPACKET,A_RESTRICT_NOPACKET,A_CACHEOP,A_COPBYIDX,A_ICTAGOP),"Instr= uction Cache Data Read",{fICDATAR(RsV, RdV);}) +Q6INSN(Y2_icinva,"icinva(Rs32)",ATTRIBS(A_ICOP,A_NOTE_NOPACKET,A_RESTRICT_= NOPACKET,A_CACHEOP,A_COPBYADDRESS,A_ICFLUSHOP),"Instruction Cache Invalidat= e Address",{fEA_REG(RsV); fICINVA(EA);}) +Q6INSN(Y2_icinvidx,"icinvidx(Rs32)",ATTRIBS(A_ICOP,A_PRIV,A_NOTE_PRIV,A_NO= TE_NOPACKET,A_RESTRICT_NOPACKET,A_CACHEOP,A_COPBYIDX,A_ICFLUSHOP),"Instruct= ion Cache Invalidate Index",{fICINVIDX(RsV);}) +Q6INSN(Y2_ickill,"ickill",ATTRIBS(A_ICOP,A_PRIV,A_NOTE_PRIV,A_NOTE_NOPACKE= T,A_RESTRICT_NOPACKET,A_CACHEOP,A_ICFLUSHOP),"Instruction Cache Invalidate"= ,{fICKILL();}) + +Q6INSN(Y2_isync,"isync",ATTRIBS(A_NOTE_NOPACKET,A_RESTRICT_NOPACKET),"Memo= ry Synchronization",{fISYNC();}) +Q6INSN(Y2_barrier,"barrier",ATTRIBS(A_NOTE_NOPACKET,A_RESTRICT_SLOT0ONLY,A= _RESTRICT_PACKET_AXOK),"Memory Barrier",{fBARRIER();}) +Q6INSN(Y2_syncht,"syncht",ATTRIBS(A_NOTE_NOPACKET,A_RESTRICT_SLOT0ONLY,A_R= ESTRICT_NOPACKET),"Memory Synchronization",{fSYNCH();}) + + +Q6INSN(Y2_dcfetchbo,"dcfetch(Rs32+#u11:3)",ATTRIBS(A_RESTRICT_PREFERSLOT0,= A_DCFETCH,A_RESTRICT_NOSLOT1_STORE),"Data Cache Prefetch",{fEA_RI(RsV,uiV);= fDCFETCH(EA);}) +DEF_MAPPING(Y2_dcfetch, "dcfetch(Rs32)","dcfetch(Rs32+#0)") +Q6INSN(Y2_dckill,"dckill",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_NOPACKET,A_RES= TRICT_SLOT0ONLY,A_RESTRICT_NOPACKET,A_CACHEOP,A_DCFLUSHOP),"Data Cache Inva= lidate",{fDCKILL();}) + + +Q6INSN(Y2_dczeroa,"dczeroa(Rs32)",ATTRIBS(A_STORE,A_RESTRICT_SLOT1_AOK,A_N= OTE_SLOT1_AOK,A_RESTRICT_SLOT0ONLY,A_CACHEOP,A_COPBYADDRESS,A_DCZEROA),"Zer= o an aligned 32-byte cacheline",{fEA_REG(RsV); fDCZEROA(EA);}) +Q6INSN(Y2_dccleana,"dccleana(Rs32)",ATTRIBS(A_RESTRICT_SLOT1_AOK,A_NOTE_SL= OT1_AOK,A_RESTRICT_SLOT0ONLY,A_CACHEOP,A_COPBYADDRESS,A_DCFLUSHOP),"Data Ca= che Clean Address",{fEA_REG(RsV); fDCCLEANA(EA);}) +Q6INSN(Y2_dccleanidx,"dccleanidx(Rs32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_RESTR= ICT_PACKET_AXOK,A_NOTE_AXOK,A_RESTRICT_SLOT0ONLY,A_CACHEOP,A_COPBYIDX,A_DCF= LUSHOP),"Data Cache Clean Index",{fDCCLEANIDX(RsV);}) +Q6INSN(Y2_dccleaninva,"dccleaninva(Rs32)",ATTRIBS(A_RESTRICT_SLOT1_AOK,A_N= OTE_SLOT1_AOK,A_RESTRICT_SLOT0ONLY,A_CACHEOP,A_COPBYADDRESS,A_DCFLUSHOP),"D= ata Cache Clean and Invalidate Address",{fEA_REG(RsV); fDCCLEANINVA(EA);}) +Q6INSN(Y2_dccleaninvidx,"dccleaninvidx(Rs32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A= _RESTRICT_PACKET_AXOK,A_NOTE_AXOK,A_RESTRICT_SLOT0ONLY,A_CACHEOP,A_COPBYIDX= ,A_DCFLUSHOP),"Data Cache Clean and Invalidate Index",{fDCCLEANINVIDX(RsV);= }) +Q6INSN(Y2_dcinva,"dcinva(Rs32)",ATTRIBS(A_RESTRICT_SLOT1_AOK,A_NOTE_SLOT1_= AOK,A_RESTRICT_SLOT0ONLY,A_CACHEOP,A_COPBYADDRESS,A_DCFLUSHOP),"Data Cache = Invalidate Address",{fEA_REG(RsV); fDCCLEANINVA(EA);}) +Q6INSN(Y2_dcinvidx,"dcinvidx(Rs32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_RESTRICT_= PACKET_AXOK,A_NOTE_AXOK,A_RESTRICT_SLOT0ONLY,A_CACHEOP,A_COPBYIDX,A_DCFLUSH= OP),"Data Cache Invalidate Index",{fDCINVIDX(RsV);}) +Q6INSN(Y2_dctagr,"Rd32=3Ddctagr(Rs32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_RESTRI= CT_PACKET_AXOK,A_NOTE_AXOK,A_RESTRICT_SLOT0ONLY,A_CACHEOP,A_COPBYIDX,A_DCTA= GOP),"Data Cache Tag Read",{fDCTAGR(RsV,RdV,RdN);}) +Q6INSN(Y2_dctagw,"dctagw(Rs32,Rt32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_RESTRICT= _SLOT0ONLY,A_NOTE_NOPACKET,A_RESTRICT_NOPACKET,A_CACHEOP,A_COPBYIDX,A_DCTAG= OP),"Data Cache Tag Write",{fDCTAGW(RsV,RtV);}) + + +Q6INSN(Y2_l2kill,"l2kill",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_NOPACKET,A_RES= TRICT_SLOT0ONLY,A_RESTRICT_NOPACKET,A_CACHEOP,A_L2FLUSHOP),"L2 Cache Invali= date",{fL2KILL();}) +Q6INSN(Y4_l2tagw,"l2tagw(Rs32,Rt32)",ATTRIBS(A_PRIV,A_NOTE_BADTAG_UNDEF,A_= NOTE_PRIV,A_RESTRICT_SLOT0ONLY,A_NOTE_NOPACKET,A_RESTRICT_NOPACKET,A_CACHEO= P,A_COPBYIDX,A_L2TAGOP),"L2 Cache Tag Write",{fL2TAGW(RsV,RtV);}) +Q6INSN(Y4_l2tagr,"Rd32=3Dl2tagr(Rs32)",ATTRIBS(A_PRIV,A_NOTE_BADTAG_UNDEF,= A_NOTE_PRIV,A_NOTE_AXOK,A_RESTRICT_PACKET_AXOK,A_RESTRICT_SLOT0ONLY,A_CACHE= OP,A_COPBYIDX,A_L2TAGOP),"L2 Cache Tag Read",{fL2TAGR(RsV,RdV,RdN);}) + +Q6INSN(Y2_l2cleaninvidx,"l2cleaninvidx(Rs32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A= _NOTE_AXOK,A_RESTRICT_PACKET_AXOK,A_RESTRICT_SLOT0ONLY,A_CACHEOP,A_COPBYIDX= ,A_L2FLUSHOP),"L2 Cache Clean and Invalidate Index",{fL2CLEANINVIDX(RsV); }) +Q6INSN(Y5_l2cleanidx,"l2cleanidx(Rs32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_= AXOK,A_RESTRICT_PACKET_AXOK,A_RESTRICT_SLOT0ONLY,A_CACHEOP,A_COPBYIDX,A_L2F= LUSHOP),"L2 Cache Clean by Index",{fL2CLEANIDX(RsV); }) +Q6INSN(Y5_l2invidx,"l2invidx(Rs32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_AXOK= ,A_RESTRICT_PACKET_AXOK,A_RESTRICT_SLOT0ONLY,A_CACHEOP,A_COPBYIDX,A_L2FLUSH= OP),"L2 Cache Invalidate by Index",{fL2INVIDX(RsV); }) + + + +Q6INSN(Y4_l2fetch,"l2fetch(Rs32,Rt32)",ATTRIBS(A_RESTRICT_SLOT0ONLY,A_REST= RICT_PACKET_AXOK,A_NOTE_AXOK),"L2 Cache Prefetch", +{ fL2FETCH(RsV, + (RtV&0xff), /*height*/ + ((RtV>>8)&0xff), /*width*/ + ((RtV>>16)&0xffff), /*stride*/ + 0); /*extra attrib flags*/ +}) + + + +Q6INSN(Y5_l2fetch,"l2fetch(Rs32,Rtt32)",ATTRIBS(A_RESTRICT_SLOT0ONLY,A_RES= TRICT_PACKET_AXOK,A_NOTE_AXOK),"L2 Cache Prefetch", +{ fL2FETCH(RsV, + fGETUHALF(0,RttV), /*height*/ + fGETUHALF(1,RttV), /*width*/ + fGETUHALF(2,RttV), /*stride*/ + fGETUHALF(3,RttV)); /*flags*/ +}) + +Q6INSN(Y5_l2locka,"Pd4=3Dl2locka(Rs32)", ATTRIBS(A_PRIV,A_NOTE_PRIV,A_CACH= EOP,A_COPBYADDRESS,A_RESTRICT_SLOT0ONLY,A_RESTRICT_PACKET_AXOK,A_NOTE_AXOK,= A_RESTRICT_LATEPRED,A_NOTE_LATEPRED), +"Lock L2 cache line by address", { fEA_REG(RsV); fL2LOCKA(EA,PdV,PdN); fHI= DE(MARK_LATE_PRED_WRITE(PdN)) }); + + +Q6INSN(Y5_l2unlocka,"l2unlocka(Rs32)", ATTRIBS(A_PRIV,A_NOTE_PRIV,A_CACHEO= P,A_COPBYADDRESS,A_RESTRICT_SLOT0ONLY,A_RESTRICT_PACKET_AXOK,A_NOTE_AXOK), = "UnLock L2 cache line by address", { fEA_REG(RsV); fL2UNLOCKA(EA); }) + + + +Q6INSN(Y5_l2gunlock,"l2gunlock",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_NOPACKET= ,A_RESTRICT_SLOT0ONLY,A_RESTRICT_NOPACKET,A_CACHEOP,A_L2FLUSHOP),"L2 Global= Unlock",{fL2UNLOCK();}) + +Q6INSN(Y5_l2gclean,"l2gclean",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_NOPACKET,A= _RESTRICT_SLOT0ONLY,A_RESTRICT_NOPACKET,A_CACHEOP,A_L2FLUSHOP),"L2 Global C= lean",{fL2CLEAN();}) + +Q6INSN(Y5_l2gcleaninv,"l2gcleaninv",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_NOPA= CKET,A_RESTRICT_SLOT0ONLY,A_RESTRICT_NOPACKET,A_CACHEOP,A_L2FLUSHOP),"L2 Gl= obal Clean and Invalidate",{fL2CLEANINV();}) + +Q6INSN(Y6_l2gcleanpa,"l2gclean(Rtt32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_NOTE_N= OPACKET,A_RESTRICT_SLOT0ONLY,A_RESTRICT_NOPACKET,A_CACHEOP,A_L2FLUSHOP),"L2= Global Clean by PA Range",{fL2CLEANPA(RttV);}) + +Q6INSN(Y6_l2gcleaninvpa,"l2gcleaninv(Rtt32)",ATTRIBS(A_PRIV,A_NOTE_PRIV,A_= NOTE_NOPACKET,A_RESTRICT_SLOT0ONLY,A_RESTRICT_NOPACKET,A_CACHEOP,A_L2FLUSHO= P),"L2 Global Clean and Invalidate by PA Range",{fL2CLEANINVPA(RttV);}) + + --=20 2.7.4