1217 lines
57 KiB
TableGen
1217 lines
57 KiB
TableGen
//===- PPCInstrQPX.td - The PowerPC QPX Extension --*- tablegen -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file describes the QPX extension to the PowerPC instruction set.
|
|
// Reference:
|
|
// Book Q: QPX Architecture Definition. IBM (as updated in) 2011.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def PPCRegQFRCAsmOperand : AsmOperandClass {
|
|
let Name = "RegQFRC"; let PredicateMethod = "isRegNumber";
|
|
}
|
|
def qfrc : RegisterOperand<QFRC> {
|
|
let ParserMatchClass = PPCRegQFRCAsmOperand;
|
|
}
|
|
def PPCRegQSRCAsmOperand : AsmOperandClass {
|
|
let Name = "RegQSRC"; let PredicateMethod = "isRegNumber";
|
|
}
|
|
def qsrc : RegisterOperand<QSRC> {
|
|
let ParserMatchClass = PPCRegQSRCAsmOperand;
|
|
}
|
|
def PPCRegQBRCAsmOperand : AsmOperandClass {
|
|
let Name = "RegQBRC"; let PredicateMethod = "isRegNumber";
|
|
}
|
|
def qbrc : RegisterOperand<QBRC> {
|
|
let ParserMatchClass = PPCRegQBRCAsmOperand;
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Helpers for defining instructions that directly correspond to intrinsics.
|
|
|
|
// QPXA1_Int - A AForm_1 intrinsic definition.
|
|
class QPXA1_Int<bits<6> opcode, bits<5> xo, string opc, Intrinsic IntID>
|
|
: AForm_1<opcode, xo, (outs qfrc:$FRT), (ins qfrc:$FRA, qfrc:$FRB, qfrc:$FRC),
|
|
!strconcat(opc, " $FRT, $FRA, $FRC, $FRB"), IIC_FPFused,
|
|
[(set v4f64:$FRT, (IntID v4f64:$FRA, v4f64:$FRB, v4f64:$FRC))]>;
|
|
// QPXA1s_Int - A AForm_1 intrinsic definition (simple instructions).
|
|
class QPXA1s_Int<bits<6> opcode, bits<5> xo, string opc, Intrinsic IntID>
|
|
: AForm_1<opcode, xo, (outs qfrc:$FRT), (ins qfrc:$FRA, qfrc:$FRB, qfrc:$FRC),
|
|
!strconcat(opc, " $FRT, $FRA, $FRC, $FRB"), IIC_VecPerm,
|
|
[(set v4f64:$FRT, (IntID v4f64:$FRA, v4f64:$FRB, v4f64:$FRC))]>;
|
|
// QPXA2_Int - A AForm_2 intrinsic definition.
|
|
class QPXA2_Int<bits<6> opcode, bits<5> xo, string opc, Intrinsic IntID>
|
|
: AForm_2<opcode, xo, (outs qfrc:$FRT), (ins qfrc:$FRA, qfrc:$FRB),
|
|
!strconcat(opc, " $FRT, $FRA, $FRB"), IIC_FPGeneral,
|
|
[(set v4f64:$FRT, (IntID v4f64:$FRA, v4f64:$FRB))]>;
|
|
// QPXA3_Int - A AForm_3 intrinsic definition.
|
|
class QPXA3_Int<bits<6> opcode, bits<5> xo, string opc, Intrinsic IntID>
|
|
: AForm_3<opcode, xo, (outs qfrc:$FRT), (ins qfrc:$FRA, qfrc:$FRC),
|
|
!strconcat(opc, " $FRT, $FRA, $FRC"), IIC_FPGeneral,
|
|
[(set v4f64:$FRT, (IntID v4f64:$FRA, v4f64:$FRC))]>;
|
|
// QPXA4_Int - A AForm_4a intrinsic definition.
|
|
class QPXA4_Int<bits<6> opcode, bits<5> xo, string opc, Intrinsic IntID>
|
|
: AForm_4a<opcode, xo, (outs qfrc:$FRT), (ins qfrc:$FRB),
|
|
!strconcat(opc, " $FRT, $FRB"), IIC_FPGeneral,
|
|
[(set v4f64:$FRT, (IntID v4f64:$FRB))]>;
|
|
// QPXX18_Int - A XForm_18 intrinsic definition.
|
|
class QPXX18_Int<bits<6> opcode, bits<10> xo, string opc, Intrinsic IntID>
|
|
: XForm_18<opcode, xo, (outs qfrc:$FRT), (ins qfrc:$FRA, qfrc:$FRB),
|
|
!strconcat(opc, " $FRT, $FRA, $FRB"), IIC_FPCompare,
|
|
[(set v4f64:$FRT, (IntID v4f64:$FRA, v4f64:$FRB))]>;
|
|
// QPXX19_Int - A XForm_19 intrinsic definition.
|
|
class QPXX19_Int<bits<6> opcode, bits<10> xo, string opc, Intrinsic IntID>
|
|
: XForm_19<opcode, xo, (outs qfrc:$FRT), (ins qfrc:$FRB),
|
|
!strconcat(opc, " $FRT, $FRB"), IIC_FPGeneral,
|
|
[(set v4f64:$FRT, (IntID v4f64:$FRB))]>;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Pattern Frags.
|
|
|
|
def extloadv4f32 : PatFrag<(ops node:$ptr), (extload node:$ptr), [{
|
|
return cast<LoadSDNode>(N)->getMemoryVT() == MVT::v4f32;
|
|
}]>;
|
|
|
|
def truncstorev4f32 : PatFrag<(ops node:$val, node:$ptr),
|
|
(truncstore node:$val, node:$ptr), [{
|
|
return cast<StoreSDNode>(N)->getMemoryVT() == MVT::v4f32;
|
|
}]>;
|
|
def pre_truncstv4f32 : PatFrag<(ops node:$val, node:$base, node:$offset),
|
|
(pre_truncst node:$val,
|
|
node:$base, node:$offset), [{
|
|
return cast<StoreSDNode>(N)->getMemoryVT() == MVT::v4f32;
|
|
}]>;
|
|
|
|
def fround_inexact : PatFrag<(ops node:$val), (fpround node:$val), [{
|
|
return cast<ConstantSDNode>(N->getOperand(1))->getZExtValue() == 0;
|
|
}]>;
|
|
|
|
def fround_exact : PatFrag<(ops node:$val), (fpround node:$val), [{
|
|
return cast<ConstantSDNode>(N->getOperand(1))->getZExtValue() == 1;
|
|
}]>;
|
|
|
|
let FastIselShouldIgnore = 1 in // FastIsel should ignore all u12 instrs.
|
|
def u12 : ImmLeaf<i32, [{ return (Imm & 0xFFF) == Imm; }]>;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Instruction Definitions.
|
|
|
|
def HasQPX : Predicate<"PPCSubTarget->hasQPX()">;
|
|
let Predicates = [HasQPX] in {
|
|
let DecoderNamespace = "QPX" in {
|
|
let hasSideEffects = 0 in { // QPX instructions don't have side effects.
|
|
let Uses = [RM] in {
|
|
// Add Instructions
|
|
let isCommutable = 1 in {
|
|
def QVFADD : AForm_2<4, 21,
|
|
(outs qfrc:$FRT), (ins qfrc:$FRA, qfrc:$FRB),
|
|
"qvfadd $FRT, $FRA, $FRB", IIC_FPGeneral,
|
|
[(set v4f64:$FRT, (fadd v4f64:$FRA, v4f64:$FRB))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFADDS : QPXA2_Int<0, 21, "qvfadds", int_ppc_qpx_qvfadds>;
|
|
def QVFADDSs : AForm_2<0, 21,
|
|
(outs qsrc:$FRT), (ins qsrc:$FRA, qsrc:$FRB),
|
|
"qvfadds $FRT, $FRA, $FRB", IIC_FPGeneral,
|
|
[(set v4f32:$FRT, (fadd v4f32:$FRA, v4f32:$FRB))]>;
|
|
}
|
|
def QVFSUB : AForm_2<4, 20,
|
|
(outs qfrc:$FRT), (ins qfrc:$FRA, qfrc:$FRB),
|
|
"qvfsub $FRT, $FRA, $FRB", IIC_FPGeneral,
|
|
[(set v4f64:$FRT, (fsub v4f64:$FRA, v4f64:$FRB))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFSUBS : QPXA2_Int<0, 20, "qvfsubs", int_ppc_qpx_qvfsubs>;
|
|
def QVFSUBSs : AForm_2<0, 20,
|
|
(outs qsrc:$FRT), (ins qsrc:$FRA, qsrc:$FRB),
|
|
"qvfsubs $FRT, $FRA, $FRB", IIC_FPGeneral,
|
|
[(set v4f32:$FRT, (fsub v4f32:$FRA, v4f32:$FRB))]>;
|
|
|
|
// Estimate Instructions
|
|
def QVFRE : AForm_4a<4, 24, (outs qfrc:$FRT), (ins qfrc:$FRB),
|
|
"qvfre $FRT, $FRB", IIC_FPGeneral,
|
|
[(set v4f64:$FRT, (PPCfre v4f64:$FRB))]>;
|
|
def QVFRES : QPXA4_Int<0, 24, "qvfres", int_ppc_qpx_qvfres>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFRESs : AForm_4a<0, 24, (outs qsrc:$FRT), (ins qsrc:$FRB),
|
|
"qvfres $FRT, $FRB", IIC_FPGeneral,
|
|
[(set v4f32:$FRT, (PPCfre v4f32:$FRB))]>;
|
|
|
|
def QVFRSQRTE : AForm_4a<4, 26, (outs qfrc:$FRT), (ins qfrc:$FRB),
|
|
"qvfrsqrte $FRT, $FRB", IIC_FPGeneral,
|
|
[(set v4f64:$FRT, (PPCfrsqrte v4f64:$FRB))]>;
|
|
def QVFRSQRTES : QPXA4_Int<0, 26, "qvfrsqrtes", int_ppc_qpx_qvfrsqrtes>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFRSQRTESs : AForm_4a<0, 26, (outs qsrc:$FRT), (ins qsrc:$FRB),
|
|
"qvfrsqrtes $FRT, $FRB", IIC_FPGeneral,
|
|
[(set v4f32:$FRT, (PPCfrsqrte v4f32:$FRB))]>;
|
|
|
|
// Multiply Instructions
|
|
let isCommutable = 1 in {
|
|
def QVFMUL : AForm_3<4, 25,
|
|
(outs qfrc:$FRT), (ins qfrc:$FRA, qfrc:$FRC),
|
|
"qvfmul $FRT, $FRA, $FRC", IIC_FPGeneral,
|
|
[(set v4f64:$FRT, (fmul v4f64:$FRA, v4f64:$FRC))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFMULS : QPXA3_Int<0, 25, "qvfmuls", int_ppc_qpx_qvfmuls>;
|
|
def QVFMULSs : AForm_3<0, 25,
|
|
(outs qsrc:$FRT), (ins qsrc:$FRA, qsrc:$FRC),
|
|
"qvfmuls $FRT, $FRA, $FRC", IIC_FPGeneral,
|
|
[(set v4f32:$FRT, (fmul v4f32:$FRA, v4f32:$FRC))]>;
|
|
}
|
|
def QVFXMUL : QPXA3_Int<4, 17, "qvfxmul", int_ppc_qpx_qvfxmul>;
|
|
def QVFXMULS : QPXA3_Int<0, 17, "qvfxmuls", int_ppc_qpx_qvfxmuls>;
|
|
|
|
// Multiply-add instructions
|
|
def QVFMADD : AForm_1<4, 29,
|
|
(outs qfrc:$FRT), (ins qfrc:$FRA, qfrc:$FRB, qfrc:$FRC),
|
|
"qvfmadd $FRT, $FRA, $FRC, $FRB", IIC_FPFused,
|
|
[(set v4f64:$FRT, (fma v4f64:$FRA, v4f64:$FRC, v4f64:$FRB))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFMADDS : QPXA1_Int<0, 29, "qvfmadds", int_ppc_qpx_qvfmadds>;
|
|
def QVFMADDSs : AForm_1<0, 29,
|
|
(outs qsrc:$FRT), (ins qsrc:$FRA, qsrc:$FRB, qsrc:$FRC),
|
|
"qvfmadds $FRT, $FRA, $FRC, $FRB", IIC_FPFused,
|
|
[(set v4f32:$FRT, (fma v4f32:$FRA, v4f32:$FRC, v4f32:$FRB))]>;
|
|
def QVFNMADD : AForm_1<4, 31,
|
|
(outs qfrc:$FRT), (ins qfrc:$FRA, qfrc:$FRB, qfrc:$FRC),
|
|
"qvfnmadd $FRT, $FRA, $FRC, $FRB", IIC_FPFused,
|
|
[(set v4f64:$FRT, (fneg (fma v4f64:$FRA, v4f64:$FRC,
|
|
v4f64:$FRB)))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFNMADDS : QPXA1_Int<0, 31, "qvfnmadds", int_ppc_qpx_qvfnmadds>;
|
|
def QVFNMADDSs : AForm_1<0, 31,
|
|
(outs qsrc:$FRT), (ins qsrc:$FRA, qsrc:$FRB, qsrc:$FRC),
|
|
"qvfnmadds $FRT, $FRA, $FRC, $FRB", IIC_FPFused,
|
|
[(set v4f32:$FRT, (fneg (fma v4f32:$FRA, v4f32:$FRC,
|
|
v4f32:$FRB)))]>;
|
|
def QVFMSUB : AForm_1<4, 28,
|
|
(outs qfrc:$FRT), (ins qfrc:$FRA, qfrc:$FRB, qfrc:$FRC),
|
|
"qvfmsub $FRT, $FRA, $FRC, $FRB", IIC_FPFused,
|
|
[(set v4f64:$FRT, (fma v4f64:$FRA, v4f64:$FRC,
|
|
(fneg v4f64:$FRB)))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFMSUBS : QPXA1_Int<0, 28, "qvfmsubs", int_ppc_qpx_qvfmsubs>;
|
|
def QVFMSUBSs : AForm_1<0, 28,
|
|
(outs qsrc:$FRT), (ins qsrc:$FRA, qsrc:$FRB, qsrc:$FRC),
|
|
"qvfmsubs $FRT, $FRA, $FRC, $FRB", IIC_FPFused,
|
|
[(set v4f32:$FRT, (fma v4f32:$FRA, v4f32:$FRC,
|
|
(fneg v4f32:$FRB)))]>;
|
|
def QVFNMSUB : AForm_1<4, 30,
|
|
(outs qfrc:$FRT), (ins qfrc:$FRA, qfrc:$FRB, qfrc:$FRC),
|
|
"qvfnmsub $FRT, $FRA, $FRC, $FRB", IIC_FPFused,
|
|
[(set v4f64:$FRT, (fneg (fma v4f64:$FRA, v4f64:$FRC,
|
|
(fneg v4f64:$FRB))))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFNMSUBS : QPXA1_Int<0, 30, "qvfnmsubs", int_ppc_qpx_qvfnmsubs>;
|
|
def QVFNMSUBSs : AForm_1<0, 30,
|
|
(outs qsrc:$FRT), (ins qsrc:$FRA, qsrc:$FRB, qsrc:$FRC),
|
|
"qvfnmsubs $FRT, $FRA, $FRC, $FRB", IIC_FPFused,
|
|
[(set v4f32:$FRT, (fneg (fma v4f32:$FRA, v4f32:$FRC,
|
|
(fneg v4f32:$FRB))))]>;
|
|
def QVFXMADD : QPXA1_Int<4, 9, "qvfxmadd", int_ppc_qpx_qvfxmadd>;
|
|
def QVFXMADDS : QPXA1_Int<0, 9, "qvfxmadds", int_ppc_qpx_qvfxmadds>;
|
|
def QVFXXNPMADD : QPXA1_Int<4, 11, "qvfxxnpmadd", int_ppc_qpx_qvfxxnpmadd>;
|
|
def QVFXXNPMADDS : QPXA1_Int<0, 11, "qvfxxnpmadds", int_ppc_qpx_qvfxxnpmadds>;
|
|
def QVFXXCPNMADD : QPXA1_Int<4, 3, "qvfxxcpnmadd", int_ppc_qpx_qvfxxcpnmadd>;
|
|
def QVFXXCPNMADDS : QPXA1_Int<0, 3, "qvfxxcpnmadds", int_ppc_qpx_qvfxxcpnmadds>;
|
|
def QVFXXMADD : QPXA1_Int<4, 1, "qvfxxmadd", int_ppc_qpx_qvfxxmadd>;
|
|
def QVFXXMADDS : QPXA1_Int<0, 1, "qvfxxmadds", int_ppc_qpx_qvfxxmadds>;
|
|
|
|
// Select Instruction
|
|
let isCodeGenOnly = 1 in
|
|
def QVFSEL : QPXA1s_Int<4, 23, "qvfsel", int_ppc_qpx_qvfsel>;
|
|
def QVFSELb : AForm_1<4, 23, (outs qfrc:$FRT),
|
|
(ins qbrc:$FRA, qfrc:$FRB, qfrc:$FRC),
|
|
"qvfsel $FRT, $FRA, $FRC, $FRB", IIC_VecPerm,
|
|
[(set v4f64:$FRT, (vselect v4i1:$FRA,
|
|
v4f64:$FRC, v4f64:$FRB))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFSELbs : AForm_1<4, 23, (outs qsrc:$FRT),
|
|
(ins qbrc:$FRA, qsrc:$FRB, qsrc:$FRC),
|
|
"qvfsel $FRT, $FRA, $FRC, $FRB", IIC_VecPerm,
|
|
[(set v4f32:$FRT, (vselect v4i1:$FRA,
|
|
v4f32:$FRC, v4f32:$FRB))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFSELbb: AForm_1<4, 23, (outs qbrc:$FRT),
|
|
(ins qbrc:$FRA, qbrc:$FRB, qbrc:$FRC),
|
|
"qvfsel $FRT, $FRA, $FRC, $FRB", IIC_VecPerm,
|
|
[(set v4i1:$FRT, (vselect v4i1:$FRA,
|
|
v4i1:$FRC, v4i1:$FRB))]>;
|
|
|
|
// SELECT_CC_* - Used to implement the SELECT_CC DAG operation. Expanded after
|
|
// instruction selection into a branch sequence.
|
|
let usesCustomInserter = 1 in {
|
|
def SELECT_CC_QFRC: Pseudo<(outs qfrc:$dst), (ins crrc:$cond, qfrc:$T, qfrc:$F,
|
|
i32imm:$BROPC), "#SELECT_CC_QFRC",
|
|
[]>;
|
|
def SELECT_CC_QSRC: Pseudo<(outs qsrc:$dst), (ins crrc:$cond, qsrc:$T, qsrc:$F,
|
|
i32imm:$BROPC), "#SELECT_CC_QSRC",
|
|
[]>;
|
|
def SELECT_CC_QBRC: Pseudo<(outs qbrc:$dst), (ins crrc:$cond, qbrc:$T, qbrc:$F,
|
|
i32imm:$BROPC), "#SELECT_CC_QBRC",
|
|
[]>;
|
|
|
|
// SELECT_* pseudo instructions, like SELECT_CC_* but taking condition
|
|
// register bit directly.
|
|
def SELECT_QFRC: Pseudo<(outs qfrc:$dst), (ins crbitrc:$cond,
|
|
qfrc:$T, qfrc:$F), "#SELECT_QFRC",
|
|
[(set v4f64:$dst,
|
|
(select i1:$cond, v4f64:$T, v4f64:$F))]>;
|
|
def SELECT_QSRC: Pseudo<(outs qsrc:$dst), (ins crbitrc:$cond,
|
|
qsrc:$T, qsrc:$F), "#SELECT_QSRC",
|
|
[(set v4f32:$dst,
|
|
(select i1:$cond, v4f32:$T, v4f32:$F))]>;
|
|
def SELECT_QBRC: Pseudo<(outs qbrc:$dst), (ins crbitrc:$cond,
|
|
qbrc:$T, qbrc:$F), "#SELECT_QBRC",
|
|
[(set v4i1:$dst,
|
|
(select i1:$cond, v4i1:$T, v4i1:$F))]>;
|
|
}
|
|
|
|
// Convert and Round Instructions
|
|
def QVFCTID : QPXX19_Int<4, 814, "qvfctid", int_ppc_qpx_qvfctid>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFCTIDb : XForm_19<4, 814, (outs qbrc:$FRT), (ins qbrc:$FRB),
|
|
"qvfctid $FRT, $FRB", IIC_FPGeneral, []>;
|
|
|
|
def QVFCTIDU : QPXX19_Int<4, 942, "qvfctidu", int_ppc_qpx_qvfctidu>;
|
|
def QVFCTIDZ : QPXX19_Int<4, 815, "qvfctidz", int_ppc_qpx_qvfctidz>;
|
|
def QVFCTIDUZ : QPXX19_Int<4, 943, "qvfctiduz", int_ppc_qpx_qvfctiduz>;
|
|
def QVFCTIW : QPXX19_Int<4, 14, "qvfctiw", int_ppc_qpx_qvfctiw>;
|
|
def QVFCTIWU : QPXX19_Int<4, 142, "qvfctiwu", int_ppc_qpx_qvfctiwu>;
|
|
def QVFCTIWZ : QPXX19_Int<4, 15, "qvfctiwz", int_ppc_qpx_qvfctiwz>;
|
|
def QVFCTIWUZ : QPXX19_Int<4, 143, "qvfctiwuz", int_ppc_qpx_qvfctiwuz>;
|
|
def QVFCFID : QPXX19_Int<4, 846, "qvfcfid", int_ppc_qpx_qvfcfid>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFCFIDb : XForm_19<4, 846, (outs qbrc:$FRT), (ins qbrc:$FRB),
|
|
"qvfcfid $FRT, $FRB", IIC_FPGeneral, []>;
|
|
|
|
def QVFCFIDU : QPXX19_Int<4, 974, "qvfcfidu", int_ppc_qpx_qvfcfidu>;
|
|
def QVFCFIDS : QPXX19_Int<0, 846, "qvfcfids", int_ppc_qpx_qvfcfids>;
|
|
def QVFCFIDUS : QPXX19_Int<0, 974, "qvfcfidus", int_ppc_qpx_qvfcfidus>;
|
|
|
|
let isCodeGenOnly = 1 in
|
|
def QVFRSP : QPXX19_Int<4, 12, "qvfrsp", int_ppc_qpx_qvfrsp>;
|
|
def QVFRSPs : XForm_19<4, 12,
|
|
(outs qsrc:$FRT), (ins qfrc:$FRB),
|
|
"qvfrsp $FRT, $FRB", IIC_FPGeneral,
|
|
[(set v4f32:$FRT, (fround_inexact v4f64:$FRB))]>;
|
|
|
|
def QVFRIZ : XForm_19<4, 424, (outs qfrc:$FRT), (ins qfrc:$FRB),
|
|
"qvfriz $FRT, $FRB", IIC_FPGeneral,
|
|
[(set v4f64:$FRT, (ftrunc v4f64:$FRB))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFRIZs : XForm_19<4, 424, (outs qsrc:$FRT), (ins qsrc:$FRB),
|
|
"qvfriz $FRT, $FRB", IIC_FPGeneral,
|
|
[(set v4f32:$FRT, (ftrunc v4f32:$FRB))]>;
|
|
|
|
def QVFRIN : XForm_19<4, 392, (outs qfrc:$FRT), (ins qfrc:$FRB),
|
|
"qvfrin $FRT, $FRB", IIC_FPGeneral,
|
|
[(set v4f64:$FRT, (fround v4f64:$FRB))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFRINs : XForm_19<4, 392, (outs qsrc:$FRT), (ins qsrc:$FRB),
|
|
"qvfrin $FRT, $FRB", IIC_FPGeneral,
|
|
[(set v4f32:$FRT, (fround v4f32:$FRB))]>;
|
|
|
|
def QVFRIP : XForm_19<4, 456, (outs qfrc:$FRT), (ins qfrc:$FRB),
|
|
"qvfrip $FRT, $FRB", IIC_FPGeneral,
|
|
[(set v4f64:$FRT, (fceil v4f64:$FRB))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFRIPs : XForm_19<4, 456, (outs qsrc:$FRT), (ins qsrc:$FRB),
|
|
"qvfrip $FRT, $FRB", IIC_FPGeneral,
|
|
[(set v4f32:$FRT, (fceil v4f32:$FRB))]>;
|
|
|
|
def QVFRIM : XForm_19<4, 488, (outs qfrc:$FRT), (ins qfrc:$FRB),
|
|
"qvfrim $FRT, $FRB", IIC_FPGeneral,
|
|
[(set v4f64:$FRT, (ffloor v4f64:$FRB))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFRIMs : XForm_19<4, 488, (outs qsrc:$FRT), (ins qsrc:$FRB),
|
|
"qvfrim $FRT, $FRB", IIC_FPGeneral,
|
|
[(set v4f32:$FRT, (ffloor v4f32:$FRB))]>;
|
|
|
|
// Move Instructions
|
|
def QVFMR : XForm_19<4, 72,
|
|
(outs qfrc:$FRT), (ins qfrc:$FRB),
|
|
"qvfmr $FRT, $FRB", IIC_VecPerm,
|
|
[/* (set v4f64:$FRT, v4f64:$FRB) */]>;
|
|
let isCodeGenOnly = 1 in {
|
|
def QVFMRs : XForm_19<4, 72,
|
|
(outs qsrc:$FRT), (ins qsrc:$FRB),
|
|
"qvfmr $FRT, $FRB", IIC_VecPerm,
|
|
[/* (set v4f32:$FRT, v4f32:$FRB) */]>;
|
|
def QVFMRb : XForm_19<4, 72,
|
|
(outs qbrc:$FRT), (ins qbrc:$FRB),
|
|
"qvfmr $FRT, $FRB", IIC_VecPerm,
|
|
[/* (set v4i1:$FRT, v4i1:$FRB) */]>;
|
|
}
|
|
def QVFNEG : XForm_19<4, 40,
|
|
(outs qfrc:$FRT), (ins qfrc:$FRB),
|
|
"qvfneg $FRT, $FRB", IIC_VecPerm,
|
|
[(set v4f64:$FRT, (fneg v4f64:$FRB))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFNEGs : XForm_19<4, 40,
|
|
(outs qsrc:$FRT), (ins qsrc:$FRB),
|
|
"qvfneg $FRT, $FRB", IIC_VecPerm,
|
|
[(set v4f32:$FRT, (fneg v4f32:$FRB))]>;
|
|
def QVFABS : XForm_19<4, 264,
|
|
(outs qfrc:$FRT), (ins qfrc:$FRB),
|
|
"qvfabs $FRT, $FRB", IIC_VecPerm,
|
|
[(set v4f64:$FRT, (fabs v4f64:$FRB))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFABSs : XForm_19<4, 264,
|
|
(outs qsrc:$FRT), (ins qsrc:$FRB),
|
|
"qvfabs $FRT, $FRB", IIC_VecPerm,
|
|
[(set v4f32:$FRT, (fabs v4f32:$FRB))]>;
|
|
def QVFNABS : XForm_19<4, 136,
|
|
(outs qfrc:$FRT), (ins qfrc:$FRB),
|
|
"qvfnabs $FRT, $FRB", IIC_VecPerm,
|
|
[(set v4f64:$FRT, (fneg (fabs v4f64:$FRB)))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFNABSs : XForm_19<4, 136,
|
|
(outs qsrc:$FRT), (ins qsrc:$FRB),
|
|
"qvfnabs $FRT, $FRB", IIC_VecPerm,
|
|
[(set v4f32:$FRT, (fneg (fabs v4f32:$FRB)))]>;
|
|
def QVFCPSGN : XForm_18<4, 8,
|
|
(outs qfrc:$FRT), (ins qfrc:$FRA, qfrc:$FRB),
|
|
"qvfcpsgn $FRT, $FRA, $FRB", IIC_VecPerm,
|
|
[(set v4f64:$FRT, (fcopysign v4f64:$FRB, v4f64:$FRA))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFCPSGNs : XForm_18<4, 8,
|
|
(outs qsrc:$FRT), (ins qsrc:$FRA, qsrc:$FRB),
|
|
"qvfcpsgn $FRT, $FRA, $FRB", IIC_VecPerm,
|
|
[(set v4f32:$FRT, (fcopysign v4f32:$FRB, v4f32:$FRA))]>;
|
|
|
|
def QVALIGNI : Z23Form_1<4, 5,
|
|
(outs qfrc:$FRT), (ins qfrc:$FRA, qfrc:$FRB, u2imm:$idx),
|
|
"qvaligni $FRT, $FRA, $FRB, $idx", IIC_VecPerm,
|
|
[(set v4f64:$FRT,
|
|
(PPCqvaligni v4f64:$FRA, v4f64:$FRB,
|
|
(i32 imm:$idx)))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVALIGNIs : Z23Form_1<4, 5,
|
|
(outs qsrc:$FRT), (ins qsrc:$FRA, qsrc:$FRB, u2imm:$idx),
|
|
"qvaligni $FRT, $FRA, $FRB, $idx", IIC_VecPerm,
|
|
[(set v4f32:$FRT,
|
|
(PPCqvaligni v4f32:$FRA, v4f32:$FRB,
|
|
(i32 imm:$idx)))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVALIGNIb : Z23Form_1<4, 5,
|
|
(outs qbrc:$FRT), (ins qbrc:$FRA, qbrc:$FRB, u2imm:$idx),
|
|
"qvaligni $FRT, $FRA, $FRB, $idx", IIC_VecPerm,
|
|
[(set v4i1:$FRT,
|
|
(PPCqvaligni v4i1:$FRA, v4i1:$FRB,
|
|
(i32 imm:$idx)))]>;
|
|
|
|
def QVESPLATI : Z23Form_2<4, 37,
|
|
(outs qfrc:$FRT), (ins qfrc:$FRA, u2imm:$idx),
|
|
"qvesplati $FRT, $FRA, $idx", IIC_VecPerm,
|
|
[(set v4f64:$FRT,
|
|
(PPCqvesplati v4f64:$FRA, (i32 imm:$idx)))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVESPLATIs : Z23Form_2<4, 37,
|
|
(outs qsrc:$FRT), (ins qsrc:$FRA, u2imm:$idx),
|
|
"qvesplati $FRT, $FRA, $idx", IIC_VecPerm,
|
|
[(set v4f32:$FRT,
|
|
(PPCqvesplati v4f32:$FRA, (i32 imm:$idx)))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVESPLATIb : Z23Form_2<4, 37,
|
|
(outs qbrc:$FRT), (ins qbrc:$FRA, u2imm:$idx),
|
|
"qvesplati $FRT, $FRA, $idx", IIC_VecPerm,
|
|
[(set v4i1:$FRT,
|
|
(PPCqvesplati v4i1:$FRA, (i32 imm:$idx)))]>;
|
|
|
|
def QVFPERM : AForm_1<4, 6,
|
|
(outs qfrc:$FRT), (ins qfrc:$FRA, qfrc:$FRB, qfrc:$FRC),
|
|
"qvfperm $FRT, $FRA, $FRB, $FRC", IIC_VecPerm,
|
|
[(set v4f64:$FRT,
|
|
(PPCqvfperm v4f64:$FRA, v4f64:$FRB, v4f64:$FRC))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFPERMs : AForm_1<4, 6,
|
|
(outs qsrc:$FRT), (ins qsrc:$FRA, qsrc:$FRB, qfrc:$FRC),
|
|
"qvfperm $FRT, $FRA, $FRB, $FRC", IIC_VecPerm,
|
|
[(set v4f32:$FRT,
|
|
(PPCqvfperm v4f32:$FRA, v4f32:$FRB, v4f64:$FRC))]>;
|
|
|
|
let isReMaterializable = 1, isAsCheapAsAMove = 1 in
|
|
def QVGPCI : Z23Form_3<4, 133,
|
|
(outs qfrc:$FRT), (ins u12imm:$idx),
|
|
"qvgpci $FRT, $idx", IIC_VecPerm,
|
|
[(set v4f64:$FRT, (PPCqvgpci (u12:$idx)))]>;
|
|
|
|
// Compare Instruction
|
|
let isCodeGenOnly = 1 in
|
|
def QVFTSTNAN : QPXX18_Int<4, 64, "qvftstnan", int_ppc_qpx_qvftstnan>;
|
|
def QVFTSTNANb : XForm_18<4, 64, (outs qbrc:$FRT), (ins qfrc:$FRA, qfrc:$FRB),
|
|
"qvftstnan $FRT, $FRA, $FRB", IIC_FPCompare,
|
|
[(set v4i1:$FRT,
|
|
(setcc v4f64:$FRA, v4f64:$FRB, SETUO))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFTSTNANbs : XForm_18<4, 64, (outs qbrc:$FRT), (ins qsrc:$FRA, qsrc:$FRB),
|
|
"qvftstnan $FRT, $FRA, $FRB", IIC_FPCompare,
|
|
[(set v4i1:$FRT,
|
|
(setcc v4f32:$FRA, v4f32:$FRB, SETUO))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFCMPLT : QPXX18_Int<4, 96, "qvfcmplt", int_ppc_qpx_qvfcmplt>;
|
|
def QVFCMPLTb : XForm_18<4, 96, (outs qbrc:$FRT), (ins qfrc:$FRA, qfrc:$FRB),
|
|
"qvfcmplt $FRT, $FRA, $FRB", IIC_FPCompare,
|
|
[(set v4i1:$FRT,
|
|
(setcc v4f64:$FRA, v4f64:$FRB, SETOLT))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFCMPLTbs : XForm_18<4, 96, (outs qbrc:$FRT), (ins qsrc:$FRA, qsrc:$FRB),
|
|
"qvfcmplt $FRT, $FRA, $FRB", IIC_FPCompare,
|
|
[(set v4i1:$FRT,
|
|
(setcc v4f32:$FRA, v4f32:$FRB, SETOLT))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFCMPGT : QPXX18_Int<4, 32, "qvfcmpgt", int_ppc_qpx_qvfcmpgt>;
|
|
def QVFCMPGTb : XForm_18<4, 32, (outs qbrc:$FRT), (ins qfrc:$FRA, qfrc:$FRB),
|
|
"qvfcmpgt $FRT, $FRA, $FRB", IIC_FPCompare,
|
|
[(set v4i1:$FRT,
|
|
(setcc v4f64:$FRA, v4f64:$FRB, SETOGT))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFCMPGTbs : XForm_18<4, 32, (outs qbrc:$FRT), (ins qsrc:$FRA, qsrc:$FRB),
|
|
"qvfcmpgt $FRT, $FRA, $FRB", IIC_FPCompare,
|
|
[(set v4i1:$FRT,
|
|
(setcc v4f32:$FRA, v4f32:$FRB, SETOGT))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFCMPEQ : QPXX18_Int<4, 0, "qvfcmpeq", int_ppc_qpx_qvfcmpeq>;
|
|
def QVFCMPEQb : XForm_18<4, 0, (outs qbrc:$FRT), (ins qfrc:$FRA, qfrc:$FRB),
|
|
"qvfcmpeq $FRT, $FRA, $FRB", IIC_FPCompare,
|
|
[(set v4i1:$FRT,
|
|
(setcc v4f64:$FRA, v4f64:$FRB, SETOEQ))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFCMPEQbs : XForm_18<4, 0, (outs qbrc:$FRT), (ins qsrc:$FRA, qsrc:$FRB),
|
|
"qvfcmpeq $FRT, $FRA, $FRB", IIC_FPCompare,
|
|
[(set v4i1:$FRT,
|
|
(setcc v4f32:$FRA, v4f32:$FRB, SETOEQ))]>;
|
|
|
|
let isCodeGenOnly = 1 in
|
|
def QVFLOGICAL : XForm_20<4, 4,
|
|
(outs qfrc:$FRT), (ins qfrc:$FRA, qfrc:$FRB, u12imm:$tttt),
|
|
"qvflogical $FRT, $FRA, $FRB, $tttt", IIC_VecPerm, []>;
|
|
def QVFLOGICALb : XForm_20<4, 4,
|
|
(outs qbrc:$FRT), (ins qbrc:$FRA, qbrc:$FRB, u12imm:$tttt),
|
|
"qvflogical $FRT, $FRA, $FRB, $tttt", IIC_VecPerm, []>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVFLOGICALs : XForm_20<4, 4,
|
|
(outs qbrc:$FRT), (ins qbrc:$FRA, qbrc:$FRB, u12imm:$tttt),
|
|
"qvflogical $FRT, $FRA, $FRB, $tttt", IIC_VecPerm, []>;
|
|
|
|
// Load indexed instructions
|
|
let mayLoad = 1 in {
|
|
def QVLFDX : XForm_1<31, 583,
|
|
(outs qfrc:$FRT), (ins memrr:$src),
|
|
"qvlfdx $FRT, $src", IIC_LdStLFD,
|
|
[(set v4f64:$FRT, (load xoaddr:$src))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVLFDXb : XForm_1<31, 583,
|
|
(outs qbrc:$FRT), (ins memrr:$src),
|
|
"qvlfdx $FRT, $src", IIC_LdStLFD, []>;
|
|
|
|
let RC = 1 in
|
|
def QVLFDXA : XForm_1<31, 583,
|
|
(outs qfrc:$FRT), (ins memrr:$src),
|
|
"qvlfdxa $FRT, $src", IIC_LdStLFD, []>;
|
|
|
|
def QVLFDUX : XForm_1<31, 615,
|
|
(outs qfrc:$FRT, ptr_rc_nor0:$ea_result),
|
|
(ins memrr:$src),
|
|
"qvlfdux $FRT, $src", IIC_LdStLFDU, []>,
|
|
RegConstraint<"$src.ptrreg = $ea_result">,
|
|
NoEncode<"$ea_result">;
|
|
let RC = 1 in
|
|
def QVLFDUXA : XForm_1<31, 615,
|
|
(outs qfrc:$FRT), (ins memrr:$src),
|
|
"qvlfduxa $FRT, $src", IIC_LdStLFD, []>;
|
|
|
|
def QVLFSX : XForm_1<31, 519,
|
|
(outs qfrc:$FRT), (ins memrr:$src),
|
|
"qvlfsx $FRT, $src", IIC_LdStLFD,
|
|
[(set v4f64:$FRT, (extloadv4f32 xoaddr:$src))]>;
|
|
|
|
let isCodeGenOnly = 1 in
|
|
def QVLFSXb : XForm_1<31, 519,
|
|
(outs qbrc:$FRT), (ins memrr:$src),
|
|
"qvlfsx $FRT, $src", IIC_LdStLFD,
|
|
[(set v4i1:$FRT, (PPCqvlfsb xoaddr:$src))]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVLFSXs : XForm_1<31, 519,
|
|
(outs qsrc:$FRT), (ins memrr:$src),
|
|
"qvlfsx $FRT, $src", IIC_LdStLFD,
|
|
[(set v4f32:$FRT, (load xoaddr:$src))]>;
|
|
|
|
let RC = 1 in
|
|
def QVLFSXA : XForm_1<31, 519,
|
|
(outs qfrc:$FRT), (ins memrr:$src),
|
|
"qvlfsxa $FRT, $src", IIC_LdStLFD, []>;
|
|
|
|
def QVLFSUX : XForm_1<31, 551,
|
|
(outs qsrc:$FRT, ptr_rc_nor0:$ea_result),
|
|
(ins memrr:$src),
|
|
"qvlfsux $FRT, $src", IIC_LdStLFDU, []>,
|
|
RegConstraint<"$src.ptrreg = $ea_result">,
|
|
NoEncode<"$ea_result">;
|
|
|
|
let RC = 1 in
|
|
def QVLFSUXA : XForm_1<31, 551,
|
|
(outs qfrc:$FRT), (ins memrr:$src),
|
|
"qvlfsuxa $FRT, $src", IIC_LdStLFD, []>;
|
|
|
|
def QVLFCDX : XForm_1<31, 71,
|
|
(outs qfrc:$FRT), (ins memrr:$src),
|
|
"qvlfcdx $FRT, $src", IIC_LdStLFD, []>;
|
|
let RC = 1 in
|
|
def QVLFCDXA : XForm_1<31, 71,
|
|
(outs qfrc:$FRT), (ins memrr:$src),
|
|
"qvlfcdxa $FRT, $src", IIC_LdStLFD, []>;
|
|
|
|
def QVLFCDUX : XForm_1<31, 103,
|
|
(outs qfrc:$FRT), (ins memrr:$src),
|
|
"qvlfcdux $FRT, $src", IIC_LdStLFD, []>;
|
|
let RC = 1 in
|
|
def QVLFCDUXA : XForm_1<31, 103,
|
|
(outs qfrc:$FRT), (ins memrr:$src),
|
|
"qvlfcduxa $FRT, $src", IIC_LdStLFD, []>;
|
|
|
|
def QVLFCSX : XForm_1<31, 7,
|
|
(outs qfrc:$FRT), (ins memrr:$src),
|
|
"qvlfcsx $FRT, $src", IIC_LdStLFD, []>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVLFCSXs : XForm_1<31, 7,
|
|
(outs qsrc:$FRT), (ins memrr:$src),
|
|
"qvlfcsx $FRT, $src", IIC_LdStLFD, []>;
|
|
|
|
let RC = 1 in
|
|
def QVLFCSXA : XForm_1<31, 7,
|
|
(outs qfrc:$FRT), (ins memrr:$src),
|
|
"qvlfcsxa $FRT, $src", IIC_LdStLFD, []>;
|
|
|
|
def QVLFCSUX : XForm_1<31, 39,
|
|
(outs qfrc:$FRT), (ins memrr:$src),
|
|
"qvlfcsux $FRT, $src", IIC_LdStLFD, []>;
|
|
let RC = 1 in
|
|
def QVLFCSUXA : XForm_1<31, 39,
|
|
(outs qfrc:$FRT), (ins memrr:$src),
|
|
"qvlfcsuxa $FRT, $src", IIC_LdStLFD, []>;
|
|
|
|
def QVLFIWAX : XForm_1<31, 871,
|
|
(outs qfrc:$FRT), (ins memrr:$src),
|
|
"qvlfiwax $FRT, $src", IIC_LdStLFD, []>;
|
|
let RC = 1 in
|
|
def QVLFIWAXA : XForm_1<31, 871,
|
|
(outs qfrc:$FRT), (ins memrr:$src),
|
|
"qvlfiwaxa $FRT, $src", IIC_LdStLFD, []>;
|
|
|
|
def QVLFIWZX : XForm_1<31, 839,
|
|
(outs qfrc:$FRT), (ins memrr:$src),
|
|
"qvlfiwzx $FRT, $src", IIC_LdStLFD, []>;
|
|
let RC = 1 in
|
|
def QVLFIWZXA : XForm_1<31, 839,
|
|
(outs qfrc:$FRT), (ins memrr:$src),
|
|
"qvlfiwzxa $FRT, $src", IIC_LdStLFD, []>;
|
|
}
|
|
|
|
|
|
def QVLPCLDX : XForm_1<31, 582,
|
|
(outs qfrc:$FRT), (ins memrr:$src),
|
|
"qvlpcldx $FRT, $src", IIC_LdStLFD, []>;
|
|
def QVLPCLSX : XForm_1<31, 518,
|
|
(outs qfrc:$FRT), (ins memrr:$src),
|
|
"qvlpclsx $FRT, $src", IIC_LdStLFD, []>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVLPCLSXint : XForm_11<31, 518,
|
|
(outs qfrc:$FRT), (ins G8RC:$src),
|
|
"qvlpclsx $FRT, 0, $src", IIC_LdStLFD, []>;
|
|
def QVLPCRDX : XForm_1<31, 70,
|
|
(outs qfrc:$FRT), (ins memrr:$src),
|
|
"qvlpcrdx $FRT, $src", IIC_LdStLFD, []>;
|
|
def QVLPCRSX : XForm_1<31, 6,
|
|
(outs qfrc:$FRT), (ins memrr:$src),
|
|
"qvlpcrsx $FRT, $src", IIC_LdStLFD, []>;
|
|
|
|
// Store indexed instructions
|
|
let mayStore = 1 in {
|
|
def QVSTFDX : XForm_8<31, 711,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfdx $FRT, $dst", IIC_LdStSTFD,
|
|
[(store qfrc:$FRT, xoaddr:$dst)]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVSTFDXb : XForm_8<31, 711,
|
|
(outs), (ins qbrc:$FRT, memrr:$dst),
|
|
"qvstfdx $FRT, $dst", IIC_LdStSTFD, []>;
|
|
|
|
let RC = 1 in
|
|
def QVSTFDXA : XForm_8<31, 711,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfdxa $FRT, $dst", IIC_LdStSTFD, []>;
|
|
|
|
def QVSTFDUX : XForm_8<31, 743, (outs ptr_rc_nor0:$ea_res),
|
|
(ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfdux $FRT, $dst", IIC_LdStSTFDU, []>,
|
|
RegConstraint<"$dst.ptrreg = $ea_res">,
|
|
NoEncode<"$ea_res">;
|
|
|
|
let RC = 1 in
|
|
def QVSTFDUXA : XForm_8<31, 743,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfduxa $FRT, $dst", IIC_LdStSTFD, []>;
|
|
|
|
def QVSTFDXI : XForm_8<31, 709,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfdxi $FRT, $dst", IIC_LdStSTFD, []>;
|
|
let RC = 1 in
|
|
def QVSTFDXIA : XForm_8<31, 709,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfdxia $FRT, $dst", IIC_LdStSTFD, []>;
|
|
|
|
def QVSTFDUXI : XForm_8<31, 741,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfduxi $FRT, $dst", IIC_LdStSTFD, []>;
|
|
let RC = 1 in
|
|
def QVSTFDUXIA : XForm_8<31, 741,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfduxia $FRT, $dst", IIC_LdStSTFD, []>;
|
|
|
|
def QVSTFSX : XForm_8<31, 647,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfsx $FRT, $dst", IIC_LdStSTFD,
|
|
[(truncstorev4f32 qfrc:$FRT, xoaddr:$dst)]>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVSTFSXs : XForm_8<31, 647,
|
|
(outs), (ins qsrc:$FRT, memrr:$dst),
|
|
"qvstfsx $FRT, $dst", IIC_LdStSTFD,
|
|
[(store qsrc:$FRT, xoaddr:$dst)]>;
|
|
|
|
let RC = 1 in
|
|
def QVSTFSXA : XForm_8<31, 647,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfsxa $FRT, $dst", IIC_LdStSTFD, []>;
|
|
|
|
def QVSTFSUX : XForm_8<31, 679, (outs ptr_rc_nor0:$ea_res),
|
|
(ins qsrc:$FRT, memrr:$dst),
|
|
"qvstfsux $FRT, $dst", IIC_LdStSTFDU, []>,
|
|
RegConstraint<"$dst.ptrreg = $ea_res">,
|
|
NoEncode<"$ea_res">;
|
|
let isCodeGenOnly = 1 in
|
|
def QVSTFSUXs: XForm_8<31, 679, (outs ptr_rc_nor0:$ea_res),
|
|
(ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfsux $FRT, $dst", IIC_LdStSTFDU, []>,
|
|
RegConstraint<"$dst.ptrreg = $ea_res">,
|
|
NoEncode<"$ea_res">;
|
|
|
|
let RC = 1 in
|
|
def QVSTFSUXA : XForm_8<31, 679,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfsuxa $FRT, $dst", IIC_LdStSTFD, []>;
|
|
|
|
def QVSTFSXI : XForm_8<31, 645,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfsxi $FRT, $dst", IIC_LdStSTFD, []>;
|
|
let RC = 1 in
|
|
def QVSTFSXIA : XForm_8<31, 645,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfsxia $FRT, $dst", IIC_LdStSTFD, []>;
|
|
|
|
def QVSTFSUXI : XForm_8<31, 677,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfsuxi $FRT, $dst", IIC_LdStSTFD, []>;
|
|
let RC = 1 in
|
|
def QVSTFSUXIA : XForm_8<31, 677,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfsuxia $FRT, $dst", IIC_LdStSTFD, []>;
|
|
|
|
def QVSTFCDX : XForm_8<31, 199,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfcdx $FRT, $dst", IIC_LdStSTFD, []>;
|
|
let RC = 1 in
|
|
def QVSTFCDXA : XForm_8<31, 199,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfcdxa $FRT, $dst", IIC_LdStSTFD, []>;
|
|
|
|
def QVSTFCSX : XForm_8<31, 135,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfcsx $FRT, $dst", IIC_LdStSTFD, []>;
|
|
let isCodeGenOnly = 1 in
|
|
def QVSTFCSXs : XForm_8<31, 135,
|
|
(outs), (ins qsrc:$FRT, memrr:$dst),
|
|
"qvstfcsx $FRT, $dst", IIC_LdStSTFD, []>;
|
|
|
|
let RC = 1 in
|
|
def QVSTFCSXA : XForm_8<31, 135,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfcsxa $FRT, $dst", IIC_LdStSTFD, []>;
|
|
|
|
def QVSTFCDUX : XForm_8<31, 231,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfcdux $FRT, $dst", IIC_LdStSTFD, []>;
|
|
let RC = 1 in
|
|
def QVSTFCDUXA : XForm_8<31, 231,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfcduxa $FRT, $dst", IIC_LdStSTFD, []>;
|
|
|
|
def QVSTFCSUX : XForm_8<31, 167,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfcsux $FRT, $dst", IIC_LdStSTFD, []>;
|
|
let RC = 1 in
|
|
def QVSTFCSUXA : XForm_8<31, 167,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfcsuxa $FRT, $dst", IIC_LdStSTFD, []>;
|
|
|
|
def QVSTFCDXI : XForm_8<31, 197,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfcdxi $FRT, $dst", IIC_LdStSTFD, []>;
|
|
let RC = 1 in
|
|
def QVSTFCDXIA : XForm_8<31, 197,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfcdxia $FRT, $dst", IIC_LdStSTFD, []>;
|
|
|
|
def QVSTFCSXI : XForm_8<31, 133,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfcsxi $FRT, $dst", IIC_LdStSTFD, []>;
|
|
let RC = 1 in
|
|
def QVSTFCSXIA : XForm_8<31, 133,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfcsxia $FRT, $dst", IIC_LdStSTFD, []>;
|
|
|
|
def QVSTFCDUXI : XForm_8<31, 229,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfcduxi $FRT, $dst", IIC_LdStSTFD, []>;
|
|
let RC = 1 in
|
|
def QVSTFCDUXIA : XForm_8<31, 229,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfcduxia $FRT, $dst", IIC_LdStSTFD, []>;
|
|
|
|
def QVSTFCSUXI : XForm_8<31, 165,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfcsuxi $FRT, $dst", IIC_LdStSTFD, []>;
|
|
let RC = 1 in
|
|
def QVSTFCSUXIA : XForm_8<31, 165,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfcsuxia $FRT, $dst", IIC_LdStSTFD, []>;
|
|
|
|
def QVSTFIWX : XForm_8<31, 967,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfiwx $FRT, $dst", IIC_LdStSTFD, []>;
|
|
let RC = 1 in
|
|
def QVSTFIWXA : XForm_8<31, 967,
|
|
(outs), (ins qfrc:$FRT, memrr:$dst),
|
|
"qvstfiwxa $FRT, $dst", IIC_LdStSTFD, []>;
|
|
}
|
|
}
|
|
|
|
} // neverHasSideEffects
|
|
}
|
|
|
|
def : InstAlias<"qvfclr $FRT",
|
|
(QVFLOGICALb qbrc:$FRT, qbrc:$FRT, qbrc:$FRT, 0)>;
|
|
def : InstAlias<"qvfand $FRT, $FRA, $FRB",
|
|
(QVFLOGICALb qbrc:$FRT, qbrc:$FRA, qbrc:$FRB, 1)>;
|
|
def : InstAlias<"qvfandc $FRT, $FRA, $FRB",
|
|
(QVFLOGICALb qbrc:$FRT, qbrc:$FRA, qbrc:$FRB, 4)>;
|
|
def : InstAlias<"qvfctfb $FRT, $FRA",
|
|
(QVFLOGICALb qbrc:$FRT, qbrc:$FRA, qbrc:$FRA, 5)>;
|
|
def : InstAlias<"qvfxor $FRT, $FRA, $FRB",
|
|
(QVFLOGICALb qbrc:$FRT, qbrc:$FRA, qbrc:$FRB, 6)>;
|
|
def : InstAlias<"qvfor $FRT, $FRA, $FRB",
|
|
(QVFLOGICALb qbrc:$FRT, qbrc:$FRA, qbrc:$FRB, 7)>;
|
|
def : InstAlias<"qvfnor $FRT, $FRA, $FRB",
|
|
(QVFLOGICALb qbrc:$FRT, qbrc:$FRA, qbrc:$FRB, 8)>;
|
|
def : InstAlias<"qvfequ $FRT, $FRA, $FRB",
|
|
(QVFLOGICALb qbrc:$FRT, qbrc:$FRA, qbrc:$FRB, 9)>;
|
|
def : InstAlias<"qvfnot $FRT, $FRA",
|
|
(QVFLOGICALb qbrc:$FRT, qbrc:$FRA, qbrc:$FRA, 10)>;
|
|
def : InstAlias<"qvforc $FRT, $FRA, $FRB",
|
|
(QVFLOGICALb qbrc:$FRT, qbrc:$FRA, qbrc:$FRB, 13)>;
|
|
def : InstAlias<"qvfnand $FRT, $FRA, $FRB",
|
|
(QVFLOGICALb qbrc:$FRT, qbrc:$FRA, qbrc:$FRB, 14)>;
|
|
def : InstAlias<"qvfset $FRT",
|
|
(QVFLOGICALb qbrc:$FRT, qbrc:$FRT, qbrc:$FRT, 15)>;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Additional QPX Patterns
|
|
//
|
|
|
|
def : Pat<(v4f64 (scalar_to_vector f64:$A)),
|
|
(INSERT_SUBREG (v4f64 (IMPLICIT_DEF)), $A, sub_64)>;
|
|
def : Pat<(v4f32 (scalar_to_vector f32:$A)),
|
|
(INSERT_SUBREG (v4f32 (IMPLICIT_DEF)), $A, sub_64)>;
|
|
|
|
def : Pat<(f64 (extractelt v4f64:$S, 0)),
|
|
(EXTRACT_SUBREG $S, sub_64)>;
|
|
def : Pat<(f32 (extractelt v4f32:$S, 0)),
|
|
(EXTRACT_SUBREG $S, sub_64)>;
|
|
|
|
def : Pat<(f64 (extractelt v4f64:$S, 1)),
|
|
(EXTRACT_SUBREG (QVESPLATI $S, 1), sub_64)>;
|
|
def : Pat<(f64 (extractelt v4f64:$S, 2)),
|
|
(EXTRACT_SUBREG (QVESPLATI $S, 2), sub_64)>;
|
|
def : Pat<(f64 (extractelt v4f64:$S, 3)),
|
|
(EXTRACT_SUBREG (QVESPLATI $S, 3), sub_64)>;
|
|
|
|
def : Pat<(f32 (extractelt v4f32:$S, 1)),
|
|
(EXTRACT_SUBREG (QVESPLATIs $S, 1), sub_64)>;
|
|
def : Pat<(f32 (extractelt v4f32:$S, 2)),
|
|
(EXTRACT_SUBREG (QVESPLATIs $S, 2), sub_64)>;
|
|
def : Pat<(f32 (extractelt v4f32:$S, 3)),
|
|
(EXTRACT_SUBREG (QVESPLATIs $S, 3), sub_64)>;
|
|
|
|
def : Pat<(f64 (extractelt v4f64:$S, i64:$F)),
|
|
(EXTRACT_SUBREG (QVFPERM $S, $S,
|
|
(QVLPCLSXint (RLDICR $F, 2,
|
|
/* 63-2 = */ 61))),
|
|
sub_64)>;
|
|
def : Pat<(f32 (extractelt v4f32:$S, i64:$F)),
|
|
(EXTRACT_SUBREG (QVFPERMs $S, $S,
|
|
(QVLPCLSXint (RLDICR $F, 2,
|
|
/* 63-2 = */ 61))),
|
|
sub_64)>;
|
|
|
|
def : Pat<(int_ppc_qpx_qvfperm v4f64:$A, v4f64:$B, v4f64:$C),
|
|
(QVFPERM $A, $B, $C)>;
|
|
|
|
def : Pat<(int_ppc_qpx_qvfcpsgn v4f64:$A, v4f64:$B),
|
|
(QVFCPSGN $A, $B)>;
|
|
|
|
// FCOPYSIGN's operand types need not agree.
|
|
def : Pat<(fcopysign v4f64:$frB, v4f32:$frA),
|
|
(QVFCPSGN (COPY_TO_REGCLASS $frA, QFRC), $frB)>;
|
|
def : Pat<(fcopysign QSRC:$frB, QFRC:$frA),
|
|
(QVFCPSGNs (COPY_TO_REGCLASS $frA, QSRC), $frB)>;
|
|
|
|
def : Pat<(int_ppc_qpx_qvfneg v4f64:$A), (QVFNEG $A)>;
|
|
def : Pat<(int_ppc_qpx_qvfabs v4f64:$A), (QVFABS $A)>;
|
|
def : Pat<(int_ppc_qpx_qvfnabs v4f64:$A), (QVFNABS $A)>;
|
|
|
|
def : Pat<(int_ppc_qpx_qvfriz v4f64:$A), (QVFRIZ $A)>;
|
|
def : Pat<(int_ppc_qpx_qvfrin v4f64:$A), (QVFRIN $A)>;
|
|
def : Pat<(int_ppc_qpx_qvfrip v4f64:$A), (QVFRIP $A)>;
|
|
def : Pat<(int_ppc_qpx_qvfrim v4f64:$A), (QVFRIM $A)>;
|
|
|
|
def : Pat<(int_ppc_qpx_qvfre v4f64:$A), (QVFRE $A)>;
|
|
def : Pat<(int_ppc_qpx_qvfrsqrte v4f64:$A), (QVFRSQRTE $A)>;
|
|
|
|
def : Pat<(int_ppc_qpx_qvfadd v4f64:$A, v4f64:$B),
|
|
(QVFADD $A, $B)>;
|
|
def : Pat<(int_ppc_qpx_qvfsub v4f64:$A, v4f64:$B),
|
|
(QVFSUB $A, $B)>;
|
|
def : Pat<(int_ppc_qpx_qvfmul v4f64:$A, v4f64:$B),
|
|
(QVFMUL $A, $B)>;
|
|
|
|
// Additional QVFNMSUB patterns: -a*c + b == -(a*c - b)
|
|
def : Pat<(fma (fneg v4f64:$A), v4f64:$C, v4f64:$B),
|
|
(QVFNMSUB $A, $B, $C)>;
|
|
def : Pat<(fma v4f64:$A, (fneg v4f64:$C), v4f64:$B),
|
|
(QVFNMSUB $A, $B, $C)>;
|
|
def : Pat<(fma (fneg v4f32:$A), v4f32:$C, v4f32:$B),
|
|
(QVFNMSUBSs $A, $B, $C)>;
|
|
def : Pat<(fma v4f32:$A, (fneg v4f32:$C), v4f32:$B),
|
|
(QVFNMSUBSs $A, $B, $C)>;
|
|
|
|
def : Pat<(int_ppc_qpx_qvfmadd v4f64:$A, v4f64:$B, v4f64:$C),
|
|
(QVFMADD $A, $B, $C)>;
|
|
def : Pat<(int_ppc_qpx_qvfnmadd v4f64:$A, v4f64:$B, v4f64:$C),
|
|
(QVFNMADD $A, $B, $C)>;
|
|
def : Pat<(int_ppc_qpx_qvfmsub v4f64:$A, v4f64:$B, v4f64:$C),
|
|
(QVFMSUB $A, $B, $C)>;
|
|
def : Pat<(int_ppc_qpx_qvfnmsub v4f64:$A, v4f64:$B, v4f64:$C),
|
|
(QVFNMSUB $A, $B, $C)>;
|
|
|
|
def : Pat<(int_ppc_qpx_qvlfd xoaddr:$src),
|
|
(QVLFDX xoaddr:$src)>;
|
|
def : Pat<(int_ppc_qpx_qvlfda xoaddr:$src),
|
|
(QVLFDXA xoaddr:$src)>;
|
|
def : Pat<(int_ppc_qpx_qvlfs xoaddr:$src),
|
|
(QVLFSX xoaddr:$src)>;
|
|
def : Pat<(int_ppc_qpx_qvlfsa xoaddr:$src),
|
|
(QVLFSXA xoaddr:$src)>;
|
|
def : Pat<(int_ppc_qpx_qvlfcda xoaddr:$src),
|
|
(QVLFCDXA xoaddr:$src)>;
|
|
def : Pat<(int_ppc_qpx_qvlfcd xoaddr:$src),
|
|
(QVLFCDX xoaddr:$src)>;
|
|
def : Pat<(int_ppc_qpx_qvlfcsa xoaddr:$src),
|
|
(QVLFCSXA xoaddr:$src)>;
|
|
def : Pat<(int_ppc_qpx_qvlfcs xoaddr:$src),
|
|
(QVLFCSX xoaddr:$src)>;
|
|
def : Pat<(int_ppc_qpx_qvlfda xoaddr:$src),
|
|
(QVLFDXA xoaddr:$src)>;
|
|
def : Pat<(int_ppc_qpx_qvlfiwaa xoaddr:$src),
|
|
(QVLFIWAXA xoaddr:$src)>;
|
|
def : Pat<(int_ppc_qpx_qvlfiwa xoaddr:$src),
|
|
(QVLFIWAX xoaddr:$src)>;
|
|
def : Pat<(int_ppc_qpx_qvlfiwza xoaddr:$src),
|
|
(QVLFIWZXA xoaddr:$src)>;
|
|
def : Pat<(int_ppc_qpx_qvlfiwz xoaddr:$src),
|
|
(QVLFIWZX xoaddr:$src)>;
|
|
def : Pat<(int_ppc_qpx_qvlfsa xoaddr:$src),
|
|
(QVLFSXA xoaddr:$src)>;
|
|
def : Pat<(int_ppc_qpx_qvlpcld xoaddr:$src),
|
|
(QVLPCLDX xoaddr:$src)>;
|
|
def : Pat<(int_ppc_qpx_qvlpcls xoaddr:$src),
|
|
(QVLPCLSX xoaddr:$src)>;
|
|
def : Pat<(int_ppc_qpx_qvlpcrd xoaddr:$src),
|
|
(QVLPCRDX xoaddr:$src)>;
|
|
def : Pat<(int_ppc_qpx_qvlpcrs xoaddr:$src),
|
|
(QVLPCRSX xoaddr:$src)>;
|
|
|
|
def : Pat<(int_ppc_qpx_qvstfd v4f64:$T, xoaddr:$dst),
|
|
(QVSTFDX $T, xoaddr:$dst)>;
|
|
def : Pat<(int_ppc_qpx_qvstfs v4f64:$T, xoaddr:$dst),
|
|
(QVSTFSX $T, xoaddr:$dst)>;
|
|
def : Pat<(int_ppc_qpx_qvstfcda v4f64:$T, xoaddr:$dst),
|
|
(QVSTFCDXA $T, xoaddr:$dst)>;
|
|
def : Pat<(int_ppc_qpx_qvstfcd v4f64:$T, xoaddr:$dst),
|
|
(QVSTFCDX $T, xoaddr:$dst)>;
|
|
def : Pat<(int_ppc_qpx_qvstfcsa v4f64:$T, xoaddr:$dst),
|
|
(QVSTFCSXA $T, xoaddr:$dst)>;
|
|
def : Pat<(int_ppc_qpx_qvstfcs v4f64:$T, xoaddr:$dst),
|
|
(QVSTFCSX $T, xoaddr:$dst)>;
|
|
def : Pat<(int_ppc_qpx_qvstfda v4f64:$T, xoaddr:$dst),
|
|
(QVSTFDXA $T, xoaddr:$dst)>;
|
|
def : Pat<(int_ppc_qpx_qvstfiwa v4f64:$T, xoaddr:$dst),
|
|
(QVSTFIWXA $T, xoaddr:$dst)>;
|
|
def : Pat<(int_ppc_qpx_qvstfiw v4f64:$T, xoaddr:$dst),
|
|
(QVSTFIWX $T, xoaddr:$dst)>;
|
|
def : Pat<(int_ppc_qpx_qvstfsa v4f64:$T, xoaddr:$dst),
|
|
(QVSTFSXA $T, xoaddr:$dst)>;
|
|
|
|
def : Pat<(pre_store v4f64:$rS, iPTR:$ptrreg, iPTR:$ptroff),
|
|
(QVSTFDUX $rS, $ptrreg, $ptroff)>;
|
|
def : Pat<(pre_store v4f32:$rS, iPTR:$ptrreg, iPTR:$ptroff),
|
|
(QVSTFSUX $rS, $ptrreg, $ptroff)>;
|
|
def : Pat<(pre_truncstv4f32 v4f64:$rS, iPTR:$ptrreg, iPTR:$ptroff),
|
|
(QVSTFSUXs $rS, $ptrreg, $ptroff)>;
|
|
|
|
def : Pat<(int_ppc_qpx_qvflogical v4f64:$A, v4f64:$B, (i32 imm:$idx)),
|
|
(QVFLOGICAL $A, $B, imm:$idx)>;
|
|
def : Pat<(int_ppc_qpx_qvgpci (u12:$idx)),
|
|
(QVGPCI imm:$idx)>;
|
|
|
|
def : Pat<(setcc v4f64:$FRA, v4f64:$FRB, SETOGE),
|
|
(QVFLOGICALb (QVFCMPLTb $FRA, $FRB),
|
|
(QVFTSTNANb $FRA, $FRB), (i32 8))>;
|
|
def : Pat<(setcc v4f64:$FRA, v4f64:$FRB, SETOLE),
|
|
(QVFLOGICALb (QVFCMPGTb $FRA, $FRB),
|
|
(QVFTSTNANb $FRA, $FRB), (i32 8))>;
|
|
def : Pat<(setcc v4f64:$FRA, v4f64:$FRB, SETONE),
|
|
(QVFLOGICALb (QVFCMPEQb $FRA, $FRB),
|
|
(QVFTSTNANb $FRA, $FRB), (i32 8))>;
|
|
def : Pat<(setcc v4f64:$FRA, v4f64:$FRB, SETO),
|
|
(QVFLOGICALb (QVFTSTNANb $FRA, $FRB),
|
|
(QVFTSTNANb $FRA, $FRB), (i32 10))>;
|
|
def : Pat<(setcc v4f64:$FRA, v4f64:$FRB, SETUEQ),
|
|
(QVFLOGICALb (QVFCMPEQb $FRA, $FRB),
|
|
(QVFTSTNANb $FRA, $FRB), (i32 7))>;
|
|
def : Pat<(setcc v4f64:$FRA, v4f64:$FRB, SETUGT),
|
|
(QVFLOGICALb (QVFCMPGTb $FRA, $FRB),
|
|
(QVFTSTNANb $FRA, $FRB), (i32 7))>;
|
|
def : Pat<(setcc v4f64:$FRA, v4f64:$FRB, SETUGE),
|
|
(QVFLOGICALb (QVFTSTNANb $FRA, $FRB),
|
|
(QVFCMPLTb $FRA, $FRB), (i32 13))>;
|
|
def : Pat<(setcc v4f64:$FRA, v4f64:$FRB, SETULT),
|
|
(QVFLOGICALb (QVFCMPLTb $FRA, $FRB),
|
|
(QVFTSTNANb $FRA, $FRB), (i32 7))>;
|
|
def : Pat<(setcc v4f64:$FRA, v4f64:$FRB, SETULE),
|
|
(QVFLOGICALb (QVFTSTNANb $FRA, $FRB),
|
|
(QVFCMPGTb $FRA, $FRB), (i32 13))>;
|
|
def : Pat<(setcc v4f64:$FRA, v4f64:$FRB, SETUNE),
|
|
(QVFLOGICALb (QVFTSTNANb $FRA, $FRB),
|
|
(QVFCMPEQb $FRA, $FRB), (i32 13))>;
|
|
|
|
def : Pat<(setcc v4f64:$FRA, v4f64:$FRB, SETEQ),
|
|
(QVFCMPEQb $FRA, $FRB)>;
|
|
def : Pat<(setcc v4f64:$FRA, v4f64:$FRB, SETGT),
|
|
(QVFCMPGTb $FRA, $FRB)>;
|
|
def : Pat<(setcc v4f64:$FRA, v4f64:$FRB, SETGE),
|
|
(QVFLOGICALb (QVFCMPLTb $FRA, $FRB),
|
|
(QVFCMPLTb $FRA, $FRB), (i32 10))>;
|
|
def : Pat<(setcc v4f64:$FRA, v4f64:$FRB, SETLT),
|
|
(QVFCMPLTb $FRA, $FRB)>;
|
|
def : Pat<(setcc v4f64:$FRA, v4f64:$FRB, SETLE),
|
|
(QVFLOGICALb (QVFCMPGTb $FRA, $FRB),
|
|
(QVFCMPGTb $FRA, $FRB), (i32 10))>;
|
|
def : Pat<(setcc v4f64:$FRA, v4f64:$FRB, SETNE),
|
|
(QVFLOGICALb (QVFCMPEQb $FRA, $FRB),
|
|
(QVFCMPEQb $FRA, $FRB), (i32 10))>;
|
|
|
|
def : Pat<(setcc v4f32:$FRA, v4f32:$FRB, SETOGE),
|
|
(QVFLOGICALb (QVFCMPLTbs $FRA, $FRB),
|
|
(QVFTSTNANbs $FRA, $FRB), (i32 8))>;
|
|
def : Pat<(setcc v4f32:$FRA, v4f32:$FRB, SETOLE),
|
|
(QVFLOGICALb (QVFCMPGTbs $FRA, $FRB),
|
|
(QVFTSTNANbs $FRA, $FRB), (i32 8))>;
|
|
def : Pat<(setcc v4f32:$FRA, v4f32:$FRB, SETONE),
|
|
(QVFLOGICALb (QVFCMPEQbs $FRA, $FRB),
|
|
(QVFTSTNANbs $FRA, $FRB), (i32 8))>;
|
|
def : Pat<(setcc v4f32:$FRA, v4f32:$FRB, SETO),
|
|
(QVFLOGICALb (QVFTSTNANbs $FRA, $FRB),
|
|
(QVFTSTNANbs $FRA, $FRB), (i32 10))>;
|
|
def : Pat<(setcc v4f32:$FRA, v4f32:$FRB, SETUEQ),
|
|
(QVFLOGICALb (QVFCMPEQbs $FRA, $FRB),
|
|
(QVFTSTNANbs $FRA, $FRB), (i32 7))>;
|
|
def : Pat<(setcc v4f32:$FRA, v4f32:$FRB, SETUGT),
|
|
(QVFLOGICALb (QVFCMPGTbs $FRA, $FRB),
|
|
(QVFTSTNANbs $FRA, $FRB), (i32 7))>;
|
|
def : Pat<(setcc v4f32:$FRA, v4f32:$FRB, SETUGE),
|
|
(QVFLOGICALb (QVFTSTNANbs $FRA, $FRB),
|
|
(QVFCMPLTbs $FRA, $FRB), (i32 13))>;
|
|
def : Pat<(setcc v4f32:$FRA, v4f32:$FRB, SETULT),
|
|
(QVFLOGICALb (QVFCMPLTbs $FRA, $FRB),
|
|
(QVFTSTNANbs $FRA, $FRB), (i32 7))>;
|
|
def : Pat<(setcc v4f32:$FRA, v4f32:$FRB, SETULE),
|
|
(QVFLOGICALb (QVFTSTNANbs $FRA, $FRB),
|
|
(QVFCMPGTbs $FRA, $FRB), (i32 13))>;
|
|
def : Pat<(setcc v4f32:$FRA, v4f32:$FRB, SETUNE),
|
|
(QVFLOGICALb (QVFTSTNANbs $FRA, $FRB),
|
|
(QVFCMPEQbs $FRA, $FRB), (i32 13))>;
|
|
|
|
def : Pat<(setcc v4f32:$FRA, v4f32:$FRB, SETEQ),
|
|
(QVFCMPEQbs $FRA, $FRB)>;
|
|
def : Pat<(setcc v4f32:$FRA, v4f32:$FRB, SETGT),
|
|
(QVFCMPGTbs $FRA, $FRB)>;
|
|
def : Pat<(setcc v4f32:$FRA, v4f32:$FRB, SETGE),
|
|
(QVFLOGICALb (QVFCMPLTbs $FRA, $FRB),
|
|
(QVFCMPLTbs $FRA, $FRB), (i32 10))>;
|
|
def : Pat<(setcc v4f32:$FRA, v4f32:$FRB, SETLT),
|
|
(QVFCMPLTbs $FRA, $FRB)>;
|
|
def : Pat<(setcc v4f32:$FRA, v4f32:$FRB, SETLE),
|
|
(QVFLOGICALb (QVFCMPGTbs $FRA, $FRB),
|
|
(QVFCMPGTbs $FRA, $FRB), (i32 10))>;
|
|
def : Pat<(setcc v4f32:$FRA, v4f32:$FRB, SETNE),
|
|
(QVFLOGICALb (QVFCMPEQbs $FRA, $FRB),
|
|
(QVFCMPEQbs $FRA, $FRB), (i32 10))>;
|
|
|
|
def : Pat<(and v4i1:$FRA, (not v4i1:$FRB)),
|
|
(QVFLOGICALb $FRA, $FRB, (i32 4))>;
|
|
def : Pat<(not (or v4i1:$FRA, v4i1:$FRB)),
|
|
(QVFLOGICALb $FRA, $FRB, (i32 8))>;
|
|
def : Pat<(not (xor v4i1:$FRA, v4i1:$FRB)),
|
|
(QVFLOGICALb $FRA, $FRB, (i32 9))>;
|
|
def : Pat<(or v4i1:$FRA, (not v4i1:$FRB)),
|
|
(QVFLOGICALb $FRA, $FRB, (i32 13))>;
|
|
def : Pat<(not (and v4i1:$FRA, v4i1:$FRB)),
|
|
(QVFLOGICALb $FRA, $FRB, (i32 14))>;
|
|
|
|
def : Pat<(and v4i1:$FRA, v4i1:$FRB),
|
|
(QVFLOGICALb $FRA, $FRB, (i32 1))>;
|
|
def : Pat<(or v4i1:$FRA, v4i1:$FRB),
|
|
(QVFLOGICALb $FRA, $FRB, (i32 7))>;
|
|
def : Pat<(xor v4i1:$FRA, v4i1:$FRB),
|
|
(QVFLOGICALb $FRA, $FRB, (i32 6))>;
|
|
def : Pat<(not v4i1:$FRA),
|
|
(QVFLOGICALb $FRA, $FRA, (i32 10))>;
|
|
|
|
def : Pat<(v4f64 (fpextend v4f32:$src)),
|
|
(COPY_TO_REGCLASS $src, QFRC)>;
|
|
|
|
def : Pat<(v4f32 (fround_exact v4f64:$src)),
|
|
(COPY_TO_REGCLASS $src, QSRC)>;
|
|
|
|
// Extract the underlying floating-point values from the
|
|
// QPX (-1.0, 1.0) boolean representation.
|
|
def : Pat<(v4f64 (PPCqbflt v4i1:$src)),
|
|
(COPY_TO_REGCLASS $src, QFRC)>;
|
|
|
|
def : Pat<(v4f64 (selectcc i1:$lhs, i1:$rhs, v4f64:$tval, v4f64:$fval, SETLT)),
|
|
(SELECT_QFRC (CRANDC $lhs, $rhs), $tval, $fval)>;
|
|
def : Pat<(v4f64 (selectcc i1:$lhs, i1:$rhs, v4f64:$tval, v4f64:$fval, SETULT)),
|
|
(SELECT_QFRC (CRANDC $rhs, $lhs), $tval, $fval)>;
|
|
def : Pat<(v4f64 (selectcc i1:$lhs, i1:$rhs, v4f64:$tval, v4f64:$fval, SETLE)),
|
|
(SELECT_QFRC (CRORC $lhs, $rhs), $tval, $fval)>;
|
|
def : Pat<(v4f64 (selectcc i1:$lhs, i1:$rhs, v4f64:$tval, v4f64:$fval, SETULE)),
|
|
(SELECT_QFRC (CRORC $rhs, $lhs), $tval, $fval)>;
|
|
def : Pat<(v4f64 (selectcc i1:$lhs, i1:$rhs, v4f64:$tval, v4f64:$fval, SETEQ)),
|
|
(SELECT_QFRC (CREQV $lhs, $rhs), $tval, $fval)>;
|
|
def : Pat<(v4f64 (selectcc i1:$lhs, i1:$rhs, v4f64:$tval, v4f64:$fval, SETGE)),
|
|
(SELECT_QFRC (CRORC $rhs, $lhs), $tval, $fval)>;
|
|
def : Pat<(v4f64 (selectcc i1:$lhs, i1:$rhs, v4f64:$tval, v4f64:$fval, SETUGE)),
|
|
(SELECT_QFRC (CRORC $lhs, $rhs), $tval, $fval)>;
|
|
def : Pat<(v4f64 (selectcc i1:$lhs, i1:$rhs, v4f64:$tval, v4f64:$fval, SETGT)),
|
|
(SELECT_QFRC (CRANDC $rhs, $lhs), $tval, $fval)>;
|
|
def : Pat<(v4f64 (selectcc i1:$lhs, i1:$rhs, v4f64:$tval, v4f64:$fval, SETUGT)),
|
|
(SELECT_QFRC (CRANDC $lhs, $rhs), $tval, $fval)>;
|
|
def : Pat<(v4f64 (selectcc i1:$lhs, i1:$rhs, v4f64:$tval, v4f64:$fval, SETNE)),
|
|
(SELECT_QFRC (CRXOR $lhs, $rhs), $tval, $fval)>;
|
|
|
|
def : Pat<(v4f32 (selectcc i1:$lhs, i1:$rhs, v4f32:$tval, v4f32:$fval, SETLT)),
|
|
(SELECT_QSRC (CRANDC $lhs, $rhs), $tval, $fval)>;
|
|
def : Pat<(v4f32 (selectcc i1:$lhs, i1:$rhs, v4f32:$tval, v4f32:$fval, SETULT)),
|
|
(SELECT_QSRC (CRANDC $rhs, $lhs), $tval, $fval)>;
|
|
def : Pat<(v4f32 (selectcc i1:$lhs, i1:$rhs, v4f32:$tval, v4f32:$fval, SETLE)),
|
|
(SELECT_QSRC (CRORC $lhs, $rhs), $tval, $fval)>;
|
|
def : Pat<(v4f32 (selectcc i1:$lhs, i1:$rhs, v4f32:$tval, v4f32:$fval, SETULE)),
|
|
(SELECT_QSRC (CRORC $rhs, $lhs), $tval, $fval)>;
|
|
def : Pat<(v4f32 (selectcc i1:$lhs, i1:$rhs, v4f32:$tval, v4f32:$fval, SETEQ)),
|
|
(SELECT_QSRC (CREQV $lhs, $rhs), $tval, $fval)>;
|
|
def : Pat<(v4f32 (selectcc i1:$lhs, i1:$rhs, v4f32:$tval, v4f32:$fval, SETGE)),
|
|
(SELECT_QSRC (CRORC $rhs, $lhs), $tval, $fval)>;
|
|
def : Pat<(v4f32 (selectcc i1:$lhs, i1:$rhs, v4f32:$tval, v4f32:$fval, SETUGE)),
|
|
(SELECT_QSRC (CRORC $lhs, $rhs), $tval, $fval)>;
|
|
def : Pat<(v4f32 (selectcc i1:$lhs, i1:$rhs, v4f32:$tval, v4f32:$fval, SETGT)),
|
|
(SELECT_QSRC (CRANDC $rhs, $lhs), $tval, $fval)>;
|
|
def : Pat<(v4f32 (selectcc i1:$lhs, i1:$rhs, v4f32:$tval, v4f32:$fval, SETUGT)),
|
|
(SELECT_QSRC (CRANDC $lhs, $rhs), $tval, $fval)>;
|
|
def : Pat<(v4f32 (selectcc i1:$lhs, i1:$rhs, v4f32:$tval, v4f32:$fval, SETNE)),
|
|
(SELECT_QSRC (CRXOR $lhs, $rhs), $tval, $fval)>;
|
|
|
|
def : Pat<(v4i1 (selectcc i1:$lhs, i1:$rhs, v4i1:$tval, v4i1:$fval, SETLT)),
|
|
(SELECT_QBRC (CRANDC $lhs, $rhs), $tval, $fval)>;
|
|
def : Pat<(v4i1 (selectcc i1:$lhs, i1:$rhs, v4i1:$tval, v4i1:$fval, SETULT)),
|
|
(SELECT_QBRC (CRANDC $rhs, $lhs), $tval, $fval)>;
|
|
def : Pat<(v4i1 (selectcc i1:$lhs, i1:$rhs, v4i1:$tval, v4i1:$fval, SETLE)),
|
|
(SELECT_QBRC (CRORC $lhs, $rhs), $tval, $fval)>;
|
|
def : Pat<(v4i1 (selectcc i1:$lhs, i1:$rhs, v4i1:$tval, v4i1:$fval, SETULE)),
|
|
(SELECT_QBRC (CRORC $rhs, $lhs), $tval, $fval)>;
|
|
def : Pat<(v4i1 (selectcc i1:$lhs, i1:$rhs, v4i1:$tval, v4i1:$fval, SETEQ)),
|
|
(SELECT_QBRC (CREQV $lhs, $rhs), $tval, $fval)>;
|
|
def : Pat<(v4i1 (selectcc i1:$lhs, i1:$rhs, v4i1:$tval, v4i1:$fval, SETGE)),
|
|
(SELECT_QBRC (CRORC $rhs, $lhs), $tval, $fval)>;
|
|
def : Pat<(v4i1 (selectcc i1:$lhs, i1:$rhs, v4i1:$tval, v4i1:$fval, SETUGE)),
|
|
(SELECT_QBRC (CRORC $lhs, $rhs), $tval, $fval)>;
|
|
def : Pat<(v4i1 (selectcc i1:$lhs, i1:$rhs, v4i1:$tval, v4i1:$fval, SETGT)),
|
|
(SELECT_QBRC (CRANDC $rhs, $lhs), $tval, $fval)>;
|
|
def : Pat<(v4i1 (selectcc i1:$lhs, i1:$rhs, v4i1:$tval, v4i1:$fval, SETUGT)),
|
|
(SELECT_QBRC (CRANDC $lhs, $rhs), $tval, $fval)>;
|
|
def : Pat<(v4i1 (selectcc i1:$lhs, i1:$rhs, v4i1:$tval, v4i1:$fval, SETNE)),
|
|
(SELECT_QBRC (CRXOR $lhs, $rhs), $tval, $fval)>;
|
|
|
|
} // end HasQPX
|
|
|
|
let Predicates = [HasQPX, NoNaNsFPMath] in {
|
|
def : Pat<(fminnum v4f64:$FRA, v4f64:$FRB),
|
|
(QVFSELb (QVFCMPLTb $FRA, $FRB), $FRB, $FRA)>;
|
|
def : Pat<(fmaxnum v4f64:$FRA, v4f64:$FRB),
|
|
(QVFSELb (QVFCMPGTb $FRA, $FRB), $FRB, $FRA)>;
|
|
|
|
def : Pat<(fminnum v4f32:$FRA, v4f32:$FRB),
|
|
(QVFSELbs (QVFCMPLTbs $FRA, $FRB), $FRB, $FRA)>;
|
|
def : Pat<(fmaxnum v4f32:$FRA, v4f32:$FRB),
|
|
(QVFSELbs (QVFCMPGTbs $FRA, $FRB), $FRB, $FRA)>;
|
|
}
|
|
|
|
let Predicates = [HasQPX, NaNsFPMath] in {
|
|
// When either of these operands is NaN, we should return the other operand.
|
|
// QVFCMPLT/QVFCMPGT return false is either operand is NaN, which means we need
|
|
// to explicitly or with a NaN test on the second operand.
|
|
def : Pat<(fminnum v4f64:$FRA, v4f64:$FRB),
|
|
(QVFSELb (QVFLOGICALb (QVFCMPLTb $FRA, $FRB),
|
|
(QVFTSTNANb $FRB, $FRB), (i32 7)),
|
|
$FRB, $FRA)>;
|
|
def : Pat<(fmaxnum v4f64:$FRA, v4f64:$FRB),
|
|
(QVFSELb (QVFLOGICALb (QVFCMPGTb $FRA, $FRB),
|
|
(QVFTSTNANb $FRB, $FRB), (i32 7)),
|
|
$FRB, $FRA)>;
|
|
|
|
def : Pat<(fminnum v4f32:$FRA, v4f32:$FRB),
|
|
(QVFSELbs (QVFLOGICALb (QVFCMPLTbs $FRA, $FRB),
|
|
(QVFTSTNANbs $FRB, $FRB), (i32 7)),
|
|
$FRB, $FRA)>;
|
|
def : Pat<(fmaxnum v4f32:$FRA, v4f32:$FRB),
|
|
(QVFSELbs (QVFLOGICALb (QVFCMPGTbs $FRA, $FRB),
|
|
(QVFTSTNANbs $FRB, $FRB), (i32 7)),
|
|
$FRB, $FRA)>;
|
|
}
|
|
|