1
0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 03:02:36 +01:00
llvm-mirror/lib/Target/ARM/ARMInstrCDE.td
2020-04-23 14:26:32 +09:00

667 lines
24 KiB
TableGen

//===-- ARMInstrCDE.td - CDE support for ARM ---------------*- tablegen -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file describes the Arm CDE (Custom Datapath Extension) instruction set.
//
//===----------------------------------------------------------------------===//
// Immediate operand of arbitrary bit width
class BitWidthImmOperand<int width>
: ImmAsmOperand<0, !add(!shl(1, width), -1)> {
let Name = "Imm"#width#"b";
}
class BitWidthImm<int width>
: Operand<i32>,
ImmLeaf<i32, "{ return Imm >= 0 && Imm < (1 << "#width#"); }"> {
let ParserMatchClass = BitWidthImmOperand<width>;
}
def CDEDualRegOp : RegisterOperand<GPRPairnosp, "printGPRPairOperand">;
// Used by VCX3 FP
def imm_3b : BitWidthImm<3>;
// Used by VCX3 vector
def imm_4b : BitWidthImm<4>;
// Used by VCX2 FP and CX3
def imm_6b : BitWidthImm<6>;
// Used by VCX2 vector
def imm_7b : BitWidthImm<7>;
// Used by CX2
def imm_9b : BitWidthImm<9>;
// Used by VCX1 FP
def imm_11b : BitWidthImm<11>;
// Used by VCX1 vector
def imm_12b : BitWidthImm<12>;
// Used by CX1
def imm_13b : BitWidthImm<13>;
// Base class for all CDE instructions
class CDE_Instr<bit acc, dag oops, dag iops, string asm, string cstr>
: Thumb2XI<oops, !con((ins p_imm:$coproc), iops),
AddrModeNone, /*sz=*/4, NoItinerary,
asm, cstr, /*pattern=*/[]>,
Sched<[]> {
bits<3> coproc;
let Inst{31-29} = 0b111; // 15:13
let Inst{28} = acc;
let Inst{27-26} = 0b11;
let Inst{11} = 0b0;
let Inst{10-8} = coproc{2-0};
let isPredicable = 0;
let DecoderNamespace = "Thumb2CDE";
}
// Base class for CX* CDE instructions
class CDE_GPR_Instr<bit dual, bit acc, dag oops, dag iops,
string asm, string cstr>
: CDE_Instr<acc, oops, iops, asm, cstr>,
Requires<[HasCDE]> {
let Inst{25-24} = 0b10;
let Inst{6} = dual;
let isPredicable = acc;
}
// Set of registers used by the CDE instructions.
class CDE_RegisterOperands {
dag Rd;
dag Rd_src;
dag Rn;
dag Rm;
}
// CX* CDE instruction parameter set
class CX_Params {
dag Oops; // Output operands for CX* instructions
dag Iops1; // Input operands for CX1* instructions
dag Iops2; // Input operands for CX2* instructions
dag Iops3; // Input operands for CX3* instructions
dag PredOp; // Input predicate operand
string PAsm; // Predicate assembly string
string Cstr; // asm constraint string
bit Dual; // "dual" field for encoding
bit Acc; // "acc" field for encoding
}
// VCX* CDE instruction parameter set
class VCX_Params {
dag Oops; // Output operands for VCX* instructions
dag Iops1; // Input operands for VCX1* instructions
dag Iops2; // Input operands for VCX2* instructions
dag Iops3; // Input operands for VCX3* instructions
string Cstr; // asm constraint string
bit Acc; // "acc" field for encoding
vpred_ops Vpred; // Predication type for VCX* vector instructions
}
// CX1, CX1A, CX1D, CX1DA
class CDE_CX1_Instr<string iname, CX_Params params>
: CDE_GPR_Instr<params.Dual, params.Acc, params.Oops,
!con(params.Iops1, (ins imm_13b:$imm), params.PredOp),
!strconcat(iname, params.PAsm, "\t$coproc, $Rd, $imm"),
params.Cstr> {
bits<13> imm;
bits<4> Rd;
let Inst{23-22} = 0b00;
let Inst{21-16} = imm{12-7};
let Inst{15-12} = Rd{3-0};
let Inst{7} = imm{6};
let Inst{5-0} = imm{5-0};
}
// CX2, CX2A, CX2D, CX2DA
class CDE_CX2_Instr<string iname, CX_Params params>
: CDE_GPR_Instr<params.Dual, params.Acc, params.Oops,
!con(params.Iops2, (ins imm_9b:$imm), params.PredOp),
!strconcat(iname, params.PAsm, "\t$coproc, $Rd, $Rn, $imm"),
params.Cstr> {
bits<9> imm;
bits<4> Rd;
bits<4> Rn;
let Inst{23-22} = 0b01;
let Inst{21-20} = imm{8-7};
let Inst{19-16} = Rn{3-0};
let Inst{15-12} = Rd{3-0};
let Inst{7} = imm{6};
let Inst{5-0} = imm{5-0};
}
// CX3, CX3A, CX3D, CX3DA
class CDE_CX3_Instr<string iname, CX_Params params>
: CDE_GPR_Instr<params.Dual, params.Acc, params.Oops,
!con(params.Iops3, (ins imm_6b:$imm), params.PredOp),
!strconcat(iname, params.PAsm, "\t$coproc, $Rd, $Rn, $Rm, $imm"),
params.Cstr> {
bits<6> imm;
bits<4> Rd;
bits<4> Rn;
bits<4> Rm;
let Inst{23} = 0b1;
let Inst{22-20} = imm{5-3};
let Inst{19-16} = Rn{3-0};
let Inst{15-12} = Rm{3-0};
let Inst{7} = imm{2};
let Inst{5-4} = imm{1-0};
let Inst{3-0} = Rd{3-0};
}
// Registers for single-register variants of CX* instructions
def cde_cx_single_regs : CDE_RegisterOperands {
let Rd = (outs GPRwithAPSR_NZCVnosp:$Rd);
let Rd_src = (ins GPRwithAPSR_NZCVnosp:$Rd_src);
let Rn = (ins GPRwithAPSR_NZCVnosp:$Rn);
let Rm = (ins GPRwithAPSR_NZCVnosp:$Rm);
}
// Registers for single-register variants of CX* instructions
def cde_cx_dual_regs : CDE_RegisterOperands {
let Rd = (outs CDEDualRegOp:$Rd);
let Rd_src = (ins CDEDualRegOp:$Rd_src);
let Rn = (ins GPRwithAPSR_NZCVnosp:$Rn);
let Rm = (ins GPRwithAPSR_NZCVnosp:$Rm);
}
class CDE_CX_ParamsTemplate<bit dual, bit acc, CDE_RegisterOperands ops>
: CX_Params {
dag IOpsPrefix = !if(acc, ops.Rd_src, (ins));
let Oops = ops.Rd;
let Iops1 = IOpsPrefix;
let Iops2 = !con(IOpsPrefix, ops.Rn);
let Iops3 = !con(IOpsPrefix, ops.Rn, ops.Rm);
let PredOp = !if(acc, (ins pred:$p), (ins));
let PAsm = !if(acc, "${p}", "");
let Cstr = !if(acc, "$Rd = $Rd_src", "");
let Dual = dual;
let Acc = acc;
}
def cde_cx_params_single_noacc : CDE_CX_ParamsTemplate<0b0, 0b0, cde_cx_single_regs>;
def cde_cx_params_single_acc : CDE_CX_ParamsTemplate<0b0, 0b1, cde_cx_single_regs>;
def cde_cx_params_dual_noacc : CDE_CX_ParamsTemplate<0b1, 0b0, cde_cx_dual_regs>;
def cde_cx_params_dual_acc : CDE_CX_ParamsTemplate<0b1, 0b1, cde_cx_dual_regs>;
def CDE_CX1 : CDE_CX1_Instr<"cx1", cde_cx_params_single_noacc>;
def CDE_CX1A : CDE_CX1_Instr<"cx1a", cde_cx_params_single_acc>;
def CDE_CX1D : CDE_CX1_Instr<"cx1d", cde_cx_params_dual_noacc>;
def CDE_CX1DA : CDE_CX1_Instr<"cx1da", cde_cx_params_dual_acc>;
def CDE_CX2 : CDE_CX2_Instr<"cx2", cde_cx_params_single_noacc>;
def CDE_CX2A : CDE_CX2_Instr<"cx2a", cde_cx_params_single_acc>;
def CDE_CX2D : CDE_CX2_Instr<"cx2d", cde_cx_params_dual_noacc>;
def CDE_CX2DA : CDE_CX2_Instr<"cx2da", cde_cx_params_dual_acc>;
def CDE_CX3 : CDE_CX3_Instr<"cx3", cde_cx_params_single_noacc>;
def CDE_CX3A : CDE_CX3_Instr<"cx3a", cde_cx_params_single_acc>;
def CDE_CX3D : CDE_CX3_Instr<"cx3d", cde_cx_params_dual_noacc>;
def CDE_CX3DA : CDE_CX3_Instr<"cx3da", cde_cx_params_dual_acc>;
let Predicates = [HasCDE] in {
def : Pat<(i32 (int_arm_cde_cx1 timm:$coproc, timm:$imm)),
(i32 (CDE_CX1 p_imm:$coproc, imm_13b:$imm))>;
def : Pat<(i32 (int_arm_cde_cx1a timm:$coproc, GPRwithAPSR_NZCVnosp:$acc,
timm:$imm)),
(i32 (CDE_CX1A p_imm:$coproc, GPRwithAPSR_NZCVnosp:$acc,
imm_13b:$imm))>;
def : Pat<(i32 (int_arm_cde_cx2 timm:$coproc, GPRwithAPSR_NZCVnosp:$n,
timm:$imm)),
(i32 (CDE_CX2 p_imm:$coproc, GPRwithAPSR_NZCVnosp:$n,
imm_9b:$imm))>;
def : Pat<(i32 (int_arm_cde_cx2a timm:$coproc, GPRwithAPSR_NZCVnosp:$acc,
GPRwithAPSR_NZCVnosp:$n, timm:$imm)),
(i32 (CDE_CX2A p_imm:$coproc, GPRwithAPSR_NZCVnosp:$acc,
GPRwithAPSR_NZCVnosp:$n, imm_9b:$imm))>;
def : Pat<(i32 (int_arm_cde_cx3 timm:$coproc, GPRwithAPSR_NZCVnosp:$n,
GPRwithAPSR_NZCVnosp:$m, timm:$imm)),
(i32 (CDE_CX3 p_imm:$coproc, GPRwithAPSR_NZCVnosp:$n,
GPRwithAPSR_NZCVnosp:$m, imm_6b:$imm))>;
def : Pat<(i32 (int_arm_cde_cx3a timm:$coproc,
GPRwithAPSR_NZCVnosp:$acc,
GPRwithAPSR_NZCVnosp:$n,
GPRwithAPSR_NZCVnosp:$m, timm:$imm)),
(i32 (CDE_CX3A p_imm:$coproc,
GPRwithAPSR_NZCVnosp:$acc,
GPRwithAPSR_NZCVnosp:$n,
GPRwithAPSR_NZCVnosp:$m, imm_6b:$imm))>;
}
class CDE_RequiresSReg : Requires<[HasCDE, HasFPRegs]>;
class CDE_RequiresDReg : Requires<[HasCDE, HasFPRegs]>;
class CDE_RequiresQReg : Requires<[HasCDE, HasMVEInt]>;
// Base class for CDE VCX* instructions
class CDE_FP_Vec_Instr<bit vec, bit acc, dag oops, dag iops, string asm, string cstr>
: CDE_Instr<acc, oops, iops, asm, cstr> {
let Inst{25} = 0b0;
let Inst{6} = vec;
}
// Base class for floating-point variants of CDE VCX* instructions
class CDE_FP_Instr<bit acc, bit sz, dag oops, dag iops, string asm, string cstr>
: CDE_FP_Vec_Instr<0b0, acc, oops, iops, asm, cstr> {
let Inst{24} = sz;
}
// Base class for vector variants of CDE VCX* instruction
class CDE_Vec_Instr<bit acc, dag oops, dag iops, string asm, string cstr,
vpred_ops vpred>
: CDE_FP_Vec_Instr<0b1, acc, oops,
!con(iops, (ins vpred:$vp)), asm,
!strconcat(cstr, vpred.vpred_constraint)>,
CDE_RequiresQReg {
}
// VCX1/VCX1A, vector variant
class CDE_VCX1_Vec_Instr<string iname, VCX_Params params>
: CDE_Vec_Instr<params.Acc, params.Oops,
!con(params.Iops1, (ins imm_12b:$imm)),
iname#"${vp}\t$coproc, $Qd, $imm", params.Cstr, params.Vpred> {
bits<12> imm;
bits<3> Qd;
let Inst{24} = imm{11};
let Inst{23} = 0b0;
let Inst{22} = 0b0;
let Inst{21-20} = 0b10;
let Inst{19-16} = imm{10-7};
let Inst{15-13} = Qd{2-0};
let Inst{12} = 0b0;
let Inst{7} = imm{6};
let Inst{5-0} = imm{5-0};
let Unpredictable{22} = 0b1;
}
// VCX1/VCX1A, base class for FP variants
class CDE_VCX1_FP_Instr<bit sz, string iname, VCX_Params params>
: CDE_FP_Instr<params.Acc, sz, params.Oops,
!con(params.Iops1, (ins imm_11b:$imm)),
iname#"\t$coproc, $Vd, $imm", params.Cstr> {
bits<11> imm;
let Inst{23} = 0b0;
let Inst{21-20} = 0b10;
let Inst{19-16} = imm{10-7};
let Inst{7} = imm{6};
let Inst{5-0} = imm{5-0};
}
// VCX1/VCX1A, S registers
class CDE_VCX1_FP_Instr_S<string iname, VCX_Params params>
: CDE_VCX1_FP_Instr<0b0, iname, params>,
CDE_RequiresSReg {
bits<5> Vd;
let Inst{22} = Vd{0};
let Inst{15-12} = Vd{4-1};
}
// VCX1/VCX1A, D registers
class CDE_VCX1_FP_Instr_D<string iname, VCX_Params params>
: CDE_VCX1_FP_Instr<0b1, iname, params>,
CDE_RequiresDReg {
bits<5> Vd;
let Inst{22} = Vd{4};
let Inst{15-12} = Vd{3-0};
}
// VCX2/VCX2A, vector variant
class CDE_VCX2_Vec_Instr<string iname, VCX_Params params>
: CDE_Vec_Instr<params.Acc, params.Oops,
!con(params.Iops2, (ins imm_7b:$imm)),
iname#"${vp}\t$coproc, $Qd, $Qm, $imm", params.Cstr,
params.Vpred> {
bits<7> imm;
bits<3> Qd;
bits<3> Qm;
let Inst{24} = imm{6};
let Inst{23} = 0b0;
let Inst{22} = 0b0;
let Inst{21-20} = 0b11;
let Inst{19-16} = imm{5-2};
let Inst{15-13} = Qd{2-0};
let Inst{12} = 0b0;
let Inst{7} = imm{1};
let Inst{5} = 0b0;
let Inst{4} = imm{0};
let Inst{3-1} = Qm{2-0};
let Inst{0} = 0b0;
let Unpredictable{22} = 0b1;
let Unpredictable{5} = 0b1;
}
// VCX2/VCX2A, base class for FP variants
class CDE_VCX2_FP_Instr<bit sz, string iname, VCX_Params params>
: CDE_FP_Instr<params.Acc, sz, params.Oops,
!con(params.Iops2, (ins imm_6b:$imm)),
iname#"\t$coproc, $Vd, $Vm, $imm", params.Cstr> {
bits<6> imm;
let Inst{23} = 0b0;
let Inst{21-20} = 0b11;
let Inst{19-16} = imm{5-2};
let Inst{7} = imm{1};
let Inst{4} = imm{0};
}
// VCX2/VCX2A, S registers
class CDE_VCX2_FP_Instr_S<string iname, VCX_Params params>
: CDE_VCX2_FP_Instr<0b0, iname, params>,
CDE_RequiresSReg {
bits<5> Vd;
bits<5> Vm;
let Inst{15-12} = Vd{4-1};
let Inst{22} = Vd{0};
let Inst{3-0} = Vm{4-1};
let Inst{5} = Vm{0};
}
// VCX2/VCX2A, D registers
class CDE_VCX2_FP_Instr_D<string iname, VCX_Params params>
: CDE_VCX2_FP_Instr<0b1, iname, params>,
CDE_RequiresDReg {
bits<5> Vd;
bits<5> Vm;
let Inst{15-12} = Vd{3-0};
let Inst{22} = Vd{4};
let Inst{3-0} = Vm{3-0};
let Inst{5} = Vm{4};
}
// VCX3/VCX3A, vector variant
class CDE_VCX3_Vec_Instr<string iname, VCX_Params params>
: CDE_Vec_Instr<params.Acc, params.Oops,
!con(params.Iops3, (ins imm_4b:$imm)),
iname#"${vp}\t$coproc, $Qd, $Qn, $Qm, $imm", params.Cstr,
params.Vpred> {
bits<4> imm;
bits<3> Qd;
bits<3> Qm;
bits<3> Qn;
let Inst{24} = imm{3};
let Inst{23} = 0b1;
let Inst{22} = 0b0;
let Inst{21-20} = imm{2-1};
let Inst{19-17} = Qn{2-0};
let Inst{16} = 0b0;
let Inst{15-13} = Qd{2-0};
let Inst{12} = 0b0;
let Inst{7} = 0b0;
let Inst{5} = 0b0;
let Inst{4} = imm{0};
let Inst{3-1} = Qm{2-0};
let Inst{0} = 0b0;
let Unpredictable{22} = 0b1;
let Unpredictable{7} = 0b1;
let Unpredictable{5} = 0b1;
}
// VCX3/VCX3A, base class for FP variants
class CDE_VCX3_FP_Instr<bit sz, string iname, VCX_Params params>
: CDE_FP_Instr<params.Acc, sz, params.Oops,
!con(params.Iops3, (ins imm_3b:$imm)),
iname#"\t$coproc, $Vd, $Vn, $Vm, $imm", params.Cstr> {
bits<3> imm;
let Inst{23} = 0b1;
let Inst{21-20} = imm{2-1};
let Inst{4} = imm{0};
}
// VCX3/VCX3A, S registers
class CDE_VCX3_FP_Instr_S<string iname, VCX_Params params>
: CDE_VCX3_FP_Instr<0b0, iname, params>,
CDE_RequiresSReg {
bits<5> Vd;
bits<5> Vm;
bits<5> Vn;
let Inst{22} = Vd{0};
let Inst{19-16} = Vn{4-1};
let Inst{15-12} = Vd{4-1};
let Inst{7} = Vn{0};
let Inst{5} = Vm{0};
let Inst{3-0} = Vm{4-1};
}
// VCX3/VCX3A, D registers
class CDE_VCX3_FP_Instr_D<string iname, VCX_Params params>
: CDE_VCX3_FP_Instr<0b1, iname, params>,
CDE_RequiresDReg {
bits<5> Vd;
bits<5> Vm;
bits<5> Vn;
let Inst{22} = Vd{4};
let Inst{19-16} = Vn{3-0};
let Inst{15-12} = Vd{3-0};
let Inst{7} = Vn{4};
let Inst{5} = Vm{4};
let Inst{3-0} = Vm{3-0};
}
// Register operands for VCX* instructions
class CDE_VCX_RegisterOperandsTemplate<RegisterClass regclass>
: CDE_RegisterOperands {
let Rd = (outs regclass:$Vd);
let Rd_src = (ins regclass:$Vd_src);
let Rn = (ins regclass:$Vn);
let Rm = (ins regclass:$Vm);
}
class CDE_VCXQ_RegisterOperandsTemplate<RegisterClass regclass>
: CDE_RegisterOperands {
let Rd = (outs regclass:$Qd);
let Rd_src = (ins regclass:$Qd_src);
let Rn = (ins regclass:$Qn);
let Rm = (ins regclass:$Qm);
}
def cde_vcx_s_regs : CDE_VCX_RegisterOperandsTemplate<SPR>;
def cde_vcx_d_regs : CDE_VCX_RegisterOperandsTemplate<DPR_VFP2>;
def cde_vcx_q_regs : CDE_VCXQ_RegisterOperandsTemplate<MQPR>;
class CDE_VCX_ParamsTemplate<bit acc, CDE_RegisterOperands ops>
: VCX_Params {
dag IOpsPrefix = !if(acc, ops.Rd_src, (ins));
let Oops = ops.Rd;
let Iops1 = IOpsPrefix;
let Iops2 = !con(IOpsPrefix, ops.Rm);
let Iops3 = !con(IOpsPrefix, ops.Rn, ops.Rm);
let Cstr = !if(acc, "$Vd = $Vd_src", "");
let Acc = acc;
}
class CDE_VCXQ_ParamsTemplate<bit acc, CDE_RegisterOperands ops>
: VCX_Params {
dag IOpsPrefix = !if(acc, ops.Rd_src, (ins));
let Oops = ops.Rd;
let Iops1 = IOpsPrefix;
let Iops2 = !con(IOpsPrefix, ops.Rm);
let Iops3 = !con(IOpsPrefix, ops.Rn, ops.Rm);
let Cstr = !if(acc, "$Qd = $Qd_src", "");
let Acc = acc;
let Vpred = !if(acc, vpred_n, vpred_r);
}
def cde_vcx_params_s_noacc : CDE_VCX_ParamsTemplate<0b0, cde_vcx_s_regs>;
def cde_vcx_params_s_acc : CDE_VCX_ParamsTemplate<0b1, cde_vcx_s_regs>;
def cde_vcx_params_d_noacc : CDE_VCX_ParamsTemplate<0b0, cde_vcx_d_regs>;
def cde_vcx_params_d_acc : CDE_VCX_ParamsTemplate<0b1, cde_vcx_d_regs>;
def cde_vcx_params_q_noacc : CDE_VCXQ_ParamsTemplate<0b0, cde_vcx_q_regs>;
def cde_vcx_params_q_acc : CDE_VCXQ_ParamsTemplate<0b1, cde_vcx_q_regs>;
def CDE_VCX1_fpsp : CDE_VCX1_FP_Instr_S<"vcx1", cde_vcx_params_s_noacc>;
def CDE_VCX1A_fpsp : CDE_VCX1_FP_Instr_S<"vcx1a", cde_vcx_params_s_acc>;
def CDE_VCX1_fpdp : CDE_VCX1_FP_Instr_D<"vcx1", cde_vcx_params_d_noacc>;
def CDE_VCX1A_fpdp : CDE_VCX1_FP_Instr_D<"vcx1a", cde_vcx_params_d_acc>;
def CDE_VCX1_vec : CDE_VCX1_Vec_Instr<"vcx1", cde_vcx_params_q_noacc>;
def CDE_VCX1A_vec : CDE_VCX1_Vec_Instr<"vcx1a", cde_vcx_params_q_acc>;
def CDE_VCX2_fpsp : CDE_VCX2_FP_Instr_S<"vcx2", cde_vcx_params_s_noacc>;
def CDE_VCX2A_fpsp : CDE_VCX2_FP_Instr_S<"vcx2a", cde_vcx_params_s_acc>;
def CDE_VCX2_fpdp : CDE_VCX2_FP_Instr_D<"vcx2", cde_vcx_params_d_noacc>;
def CDE_VCX2A_fpdp : CDE_VCX2_FP_Instr_D<"vcx2a", cde_vcx_params_d_acc>;
def CDE_VCX2_vec : CDE_VCX2_Vec_Instr<"vcx2", cde_vcx_params_q_noacc>;
def CDE_VCX2A_vec : CDE_VCX2_Vec_Instr<"vcx2a", cde_vcx_params_q_acc>;
def CDE_VCX3_fpsp : CDE_VCX3_FP_Instr_S<"vcx3", cde_vcx_params_s_noacc>;
def CDE_VCX3A_fpsp : CDE_VCX3_FP_Instr_S<"vcx3a", cde_vcx_params_s_acc>;
def CDE_VCX3_fpdp : CDE_VCX3_FP_Instr_D<"vcx3", cde_vcx_params_d_noacc>;
def CDE_VCX3A_fpdp : CDE_VCX3_FP_Instr_D<"vcx3a", cde_vcx_params_d_acc>;
def CDE_VCX3_vec : CDE_VCX3_Vec_Instr<"vcx3", cde_vcx_params_q_noacc>;
def CDE_VCX3A_vec : CDE_VCX3_Vec_Instr<"vcx3a", cde_vcx_params_q_acc>;
let Predicates = [HasCDE, HasFPRegs] in {
def : Pat<(f32 (int_arm_cde_vcx1 timm:$coproc, timm:$imm)),
(f32 (CDE_VCX1_fpsp p_imm:$coproc, imm_11b:$imm))>;
def : Pat<(f32 (int_arm_cde_vcx1a timm:$coproc, (f32 SPR:$acc), timm:$imm)),
(f32 (CDE_VCX1A_fpsp p_imm:$coproc, SPR:$acc, imm_11b:$imm))>;
def : Pat<(f64 (int_arm_cde_vcx1 timm:$coproc, timm:$imm)),
(f64 (CDE_VCX1_fpdp p_imm:$coproc, imm_11b:$imm))>;
def : Pat<(f64 (int_arm_cde_vcx1a timm:$coproc, (f64 DPR:$acc), timm:$imm)),
(f64 (CDE_VCX1A_fpdp p_imm:$coproc, DPR:$acc, imm_11b:$imm))>;
def : Pat<(f32 (int_arm_cde_vcx2 timm:$coproc, (f32 SPR:$n), timm:$imm)),
(f32 (CDE_VCX2_fpsp p_imm:$coproc, SPR:$n, imm_6b:$imm))>;
def : Pat<(f32 (int_arm_cde_vcx2a timm:$coproc, (f32 SPR:$acc), (f32 SPR:$n),
timm:$imm)),
(f32 (CDE_VCX2A_fpsp p_imm:$coproc, SPR:$acc, SPR:$n, imm_6b:$imm))>;
def : Pat<(f64 (int_arm_cde_vcx2 timm:$coproc, (f64 DPR:$n), timm:$imm)),
(f64 (CDE_VCX2_fpdp p_imm:$coproc, DPR:$n, imm_6b:$imm))>;
def : Pat<(f64 (int_arm_cde_vcx2a timm:$coproc, (f64 DPR:$acc), (f64 DPR:$n),
timm:$imm)),
(f64 (CDE_VCX2A_fpdp p_imm:$coproc, DPR:$acc, DPR:$n, imm_6b:$imm))>;
def : Pat<(f32 (int_arm_cde_vcx3 timm:$coproc, (f32 SPR:$n), (f32 SPR:$m),
timm:$imm)),
(f32 (CDE_VCX3_fpsp p_imm:$coproc, (f32 SPR:$n), (f32 SPR:$m),
imm_3b:$imm))>;
def : Pat<(f32 (int_arm_cde_vcx3a timm:$coproc, (f32 SPR:$acc), (f32 SPR:$n),
(f32 SPR:$m), timm:$imm)),
(f32 (CDE_VCX3A_fpsp p_imm:$coproc, SPR:$acc, SPR:$n, SPR:$m,
imm_3b:$imm))>;
def : Pat<(f64 (int_arm_cde_vcx3 timm:$coproc, (f64 DPR:$n), (f64 DPR:$m),
timm:$imm)),
(f64 (CDE_VCX3_fpdp p_imm:$coproc, DPR:$n, DPR:$m, imm_3b:$imm))>;
def : Pat<(f64 (int_arm_cde_vcx3a timm:$coproc, (f64 DPR:$acc), (f64 DPR:$n),
(f64 DPR:$m), timm:$imm)),
(f64 (CDE_VCX3A_fpdp p_imm:$coproc, DPR:$acc, DPR:$n, DPR:$m,
imm_3b:$imm))>;
}
let Predicates = [HasCDE, HasMVEInt] in {
def : Pat<(v16i8 (int_arm_cde_vcx1q timm:$coproc, timm:$imm)),
(v16i8 (CDE_VCX1_vec p_imm:$coproc, imm_12b:$imm))>;
def : Pat<(v16i8 (int_arm_cde_vcx1qa timm:$coproc, (v16i8 MQPR:$acc),
timm:$imm)),
(v16i8 (CDE_VCX1A_vec p_imm:$coproc, MQPR:$acc, imm_12b:$imm))>;
def : Pat<(v16i8 (int_arm_cde_vcx2q timm:$coproc, (v16i8 MQPR:$n), timm:$imm)),
(v16i8 (CDE_VCX2_vec p_imm:$coproc, MQPR:$n, imm_7b:$imm))>;
def : Pat<(v16i8 (int_arm_cde_vcx2qa timm:$coproc, (v16i8 MQPR:$acc),
(v16i8 MQPR:$n), timm:$imm)),
(v16i8 (CDE_VCX2A_vec p_imm:$coproc, MQPR:$acc, MQPR:$n,
imm_7b:$imm))>;
def : Pat<(v16i8 (int_arm_cde_vcx3q timm:$coproc, (v16i8 MQPR:$n),
(v16i8 MQPR:$m), timm:$imm)),
(v16i8 (CDE_VCX3_vec p_imm:$coproc, MQPR:$n, MQPR:$m,
imm_4b:$imm))>;
def : Pat<(v16i8 (int_arm_cde_vcx3qa timm:$coproc, (v16i8 MQPR:$acc),
(v16i8 MQPR:$n), (v16i8 MQPR:$m),
timm:$imm)),
(v16i8 (CDE_VCX3A_vec p_imm:$coproc, MQPR:$acc, MQPR:$n, MQPR:$m,
imm_4b:$imm))>;
}
multiclass VCXPredicatedPat_m<MVEVectorVTInfo VTI> {
def : Pat<(VTI.Vec (int_arm_cde_vcx1q_predicated timm:$coproc,
(VTI.Vec MQPR:$inactive), timm:$imm,
(VTI.Pred VCCR:$pred))),
(VTI.Vec (CDE_VCX1_vec p_imm:$coproc, imm_12b:$imm, ARMVCCThen,
(VTI.Pred VCCR:$pred),
(VTI.Vec MQPR:$inactive)))>;
def : Pat<(VTI.Vec (int_arm_cde_vcx1qa_predicated timm:$coproc,
(VTI.Vec MQPR:$acc), timm:$imm,
(VTI.Pred VCCR:$pred))),
(VTI.Vec (CDE_VCX1A_vec p_imm:$coproc, (VTI.Vec MQPR:$acc),
imm_12b:$imm, ARMVCCThen,
(VTI.Pred VCCR:$pred)))>;
def : Pat<(VTI.Vec (int_arm_cde_vcx2q_predicated timm:$coproc,
(VTI.Vec MQPR:$inactive),
(v16i8 MQPR:$n), timm:$imm,
(VTI.Pred VCCR:$pred))),
(VTI.Vec (CDE_VCX2_vec p_imm:$coproc, (v16i8 MQPR:$n),
imm_7b:$imm, ARMVCCThen,
(VTI.Pred VCCR:$pred),
(VTI.Vec MQPR:$inactive)))>;
def : Pat<(VTI.Vec (int_arm_cde_vcx2qa_predicated timm:$coproc,
(VTI.Vec MQPR:$acc),
(v16i8 MQPR:$n), timm:$imm,
(VTI.Pred VCCR:$pred))),
(VTI.Vec (CDE_VCX2A_vec p_imm:$coproc, (VTI.Vec MQPR:$acc),
(v16i8 MQPR:$n), timm:$imm, ARMVCCThen,
(VTI.Pred VCCR:$pred)))>;
def : Pat<(VTI.Vec (int_arm_cde_vcx3q_predicated timm:$coproc,
(VTI.Vec MQPR:$inactive),
(v16i8 MQPR:$n), (v16i8 MQPR:$m),
timm:$imm,
(VTI.Pred VCCR:$pred))),
(VTI.Vec (CDE_VCX3_vec p_imm:$coproc, (v16i8 MQPR:$n),
(v16i8 MQPR:$m),
imm_4b:$imm, ARMVCCThen,
(VTI.Pred VCCR:$pred),
(VTI.Vec MQPR:$inactive)))>;
def : Pat<(VTI.Vec (int_arm_cde_vcx3qa_predicated timm:$coproc,
(VTI.Vec MQPR:$acc),
(v16i8 MQPR:$n), (v16i8 MQPR:$m), timm:$imm,
(VTI.Pred VCCR:$pred))),
(VTI.Vec (CDE_VCX3A_vec p_imm:$coproc, (VTI.Vec MQPR:$acc),
(v16i8 MQPR:$n), (v16i8 MQPR:$m),
imm_4b:$imm, ARMVCCThen,
(VTI.Pred VCCR:$pred)))>;
}
let Predicates = [HasCDE, HasMVEInt] in
foreach VTI = [ MVE_v16i8, MVE_v8i16, MVE_v4i32, MVE_v2i64 ] in
defm : VCXPredicatedPat_m<VTI>;
let Predicates = [HasCDE, HasMVEFloat] in
foreach VTI = [ MVE_v8f16, MVE_v4f32 ] in
defm : VCXPredicatedPat_m<VTI>;