1180 if (
Node->isMachineOpcode()) {
1182 Node->setNodeId(-1);
1188 unsigned Opcode =
Node->getOpcode();
1189 MVT XLenVT = Subtarget->getXLenVT();
1191 MVT VT =
Node->getSimpleValueType(0);
1193 bool HasBitTest = Subtarget->hasBEXTILike();
1197 assert(VT == Subtarget->getXLenVT() &&
"Unexpected VT!");
1199 if (ConstNode->isZero()) {
1201 CurDAG->getCopyFromReg(
CurDAG->getEntryNode(),
DL, RISCV::X0, VT);
1205 int64_t
Imm = ConstNode->getSExtValue();
1241 Imm = ((uint64_t)
Imm << 32) | (
Imm & 0xFFFFFFFF);
1251 bool Is64Bit = Subtarget->is64Bit();
1252 bool HasZdinx = Subtarget->hasStdExtZdinx();
1254 bool NegZeroF64 = APF.
isNegZero() && VT == MVT::f64;
1259 if (VT == MVT::f64 && HasZdinx && !Is64Bit)
1260 Imm =
CurDAG->getRegister(RISCV::X0_Pair, MVT::f64);
1262 Imm =
CurDAG->getRegister(RISCV::X0, XLenVT);
1273 assert(Subtarget->hasStdExtZfbfmin());
1274 Opc = RISCV::FMV_H_X;
1277 Opc = Subtarget->hasStdExtZhinxmin() ? RISCV::COPY : RISCV::FMV_H_X;
1280 Opc = Subtarget->hasStdExtZfinx() ? RISCV::COPY : RISCV::FMV_W_X;
1285 assert((Subtarget->is64Bit() || APF.
isZero()) &&
"Unexpected constant");
1289 Opc = Is64Bit ? RISCV::FMV_D_X : RISCV::FCVT_D_W;
1294 if (VT.
SimpleTy == MVT::f16 &&
Opc == RISCV::COPY) {
1296 CurDAG->getTargetExtractSubreg(RISCV::sub_16,
DL, VT,
Imm).getNode();
1297 }
else if (VT.
SimpleTy == MVT::f32 &&
Opc == RISCV::COPY) {
1299 CurDAG->getTargetExtractSubreg(RISCV::sub_32,
DL, VT,
Imm).getNode();
1300 }
else if (
Opc == RISCV::FCVT_D_W_IN32X ||
Opc == RISCV::FCVT_D_W)
1301 Res =
CurDAG->getMachineNode(
1309 Opc = RISCV::FSGNJN_D;
1311 Opc = Is64Bit ? RISCV::FSGNJN_D_INX : RISCV::FSGNJN_D_IN32X;
1319 case RISCVISD::BuildGPRPair:
1320 case RISCVISD::BuildPairF64:
1321 case RISCVISD::BuildPairGPRVec: {
1322 if (Opcode == RISCVISD::BuildPairF64 && !Subtarget->hasStdExtZdinx())
1325 assert((!Subtarget->is64Bit() || Opcode != RISCVISD::BuildPairF64) &&
1326 "BuildPairF64 only handled here on rv32i_zdinx");
1333 case RISCVISD::SplitGPRPair:
1334 case RISCVISD::SplitF64:
1335 case RISCVISD::SplitGPRVec: {
1336 if (Subtarget->hasStdExtZdinx() || Opcode != RISCVISD::SplitF64) {
1337 assert((!Subtarget->is64Bit() || Opcode != RISCVISD::SplitF64) &&
1338 "SplitF64 only handled here on rv32i_zdinx");
1342 Node->getValueType(0),
1343 Node->getOperand(0));
1349 RISCV::sub_gpr_odd,
DL,
Node->getValueType(1),
Node->getOperand(0));
1357 if (!Subtarget->hasStdExtZfa())
1359 assert(Subtarget->hasStdExtD() && !Subtarget->is64Bit() &&
1360 "Unexpected subtarget");
1365 Node->getOperand(0));
1370 Node->getOperand(0));
1385 assert(VT == Subtarget->getXLenVT() &&
"Unexpected VT!");
1386 unsigned ShAmt = N1C->getZExtValue();
1387 assert(ShAmt > 0 && ShAmt < Subtarget->getXLen() &&
1388 "Unexpected shift amount!");
1392 unsigned XLen = Subtarget->getXLen();
1395 if (ShAmt <= 32 && TrailingZeros > 0 && LeadingZeros == 32) {
1400 CurDAG->getTargetConstant(TrailingZeros,
DL, VT));
1403 CurDAG->getTargetConstant(TrailingZeros + ShAmt,
DL, VT));
1407 if (TrailingZeros == 0 && LeadingZeros > ShAmt &&
1408 XLen - LeadingZeros > 11 && LeadingZeros != 32) {
1419 CurDAG->getTargetConstant(LeadingZeros,
DL, VT));
1422 CurDAG->getTargetConstant(LeadingZeros - ShAmt,
DL, VT));
1436 assert(VT == Subtarget->getXLenVT() &&
"Unexpected VT!");
1437 unsigned ShAmt = N1C->getZExtValue();
1438 assert(ShAmt > 0 && ShAmt < Subtarget->getXLen() &&
1439 "Unexpected shift amount!");
1445 unsigned XLen = Subtarget->getXLen();
1448 if (LeadingZeros == 32 && TrailingZeros > ShAmt) {
1451 CurDAG->getTargetConstant(TrailingZeros,
DL, VT));
1454 CurDAG->getTargetConstant(TrailingZeros - ShAmt,
DL, VT));
1471 if (ShAmt >= TrailingOnes)
1474 if (TrailingOnes == 32) {
1476 Subtarget->is64Bit() ? RISCV::SRLIW : RISCV::SRLI,
DL, VT,
1487 if (HasBitTest && ShAmt + 1 == TrailingOnes) {
1489 Subtarget->hasStdExtZbs() ? RISCV::BEXTI : RISCV::TH_TST,
DL, VT,
1495 const unsigned Msb = TrailingOnes - 1;
1496 const unsigned Lsb = ShAmt;
1500 unsigned LShAmt = Subtarget->getXLen() - TrailingOnes;
1503 CurDAG->getTargetConstant(LShAmt,
DL, VT));
1506 CurDAG->getTargetConstant(LShAmt + ShAmt,
DL, VT));
1531 assert(VT == Subtarget->getXLenVT() &&
"Unexpected VT!");
1532 unsigned ShAmt = N1C->getZExtValue();
1533 assert(ShAmt > 0 && ShAmt < Subtarget->getXLen() &&
1534 "Unexpected shift amount!");
1538 if (ExtSize >= 32 || ShAmt >= ExtSize)
1540 unsigned LShAmt = Subtarget->getXLen() - ExtSize;
1543 CurDAG->getTargetConstant(LShAmt,
DL, VT));
1546 CurDAG->getTargetConstant(LShAmt + ShAmt,
DL, VT));
1565 unsigned ShAmt = ShAmtC->getZExtValue();
1566 unsigned XLen = Subtarget->getXLen();
1569 if (ExtSize >= 32 || ShAmt >= XLen - ExtSize)
1572 unsigned LShAmt = XLen - ExtSize - ShAmt;
1575 CurDAG->getTargetConstant(LShAmt,
DL, VT));
1578 CurDAG->getTargetConstant(XLen - ExtSize,
DL, VT));
1597 assert(VT == Subtarget->getXLenVT() &&
"Unexpected VT!");
1606 unsigned C2 =
C->getZExtValue();
1607 unsigned XLen = Subtarget->getXLen();
1608 assert((C2 > 0 && C2 < XLen) &&
"Unexpected shift amount!");
1616 bool IsCANDI =
isInt<6>(N1C->getSExtValue());
1618 uint64_t
C1 = N1C->getZExtValue();
1628 bool OneUseOrZExtW = N0.
hasOneUse() ||
C1 == UINT64_C(0xFFFFFFFF);
1638 if (C2 + 32 == Leading) {
1640 RISCV::SRLIW,
DL, VT,
X,
CurDAG->getTargetConstant(C2,
DL, VT));
1650 if (C2 >= 32 && (Leading - C2) == 1 && N0.
hasOneUse() &&
1654 CurDAG->getMachineNode(RISCV::SRAIW,
DL, VT,
X.getOperand(0),
1655 CurDAG->getTargetConstant(31,
DL, VT));
1657 RISCV::SRLIW,
DL, VT,
SDValue(SRAIW, 0),
1658 CurDAG->getTargetConstant(Leading - 32,
DL, VT));
1671 const unsigned Lsb = C2;
1677 bool Skip = Subtarget->hasStdExtZba() && Leading == 32 &&
1681 Skip |= HasBitTest && Leading == XLen - 1;
1682 if (OneUseOrZExtW && !Skip) {
1684 RISCV::SLLI,
DL, VT,
X,
1685 CurDAG->getTargetConstant(Leading - C2,
DL, VT));
1688 CurDAG->getTargetConstant(Leading,
DL, VT));
1700 if (C2 + Leading < XLen &&
1703 if ((XLen - (C2 + Leading)) == 32 && Subtarget->hasStdExtZba()) {
1705 CurDAG->getMachineNode(RISCV::SLLI_UW,
DL, VT,
X,
1706 CurDAG->getTargetConstant(C2,
DL, VT));
1719 const unsigned Msb = XLen - Leading - 1;
1720 const unsigned Lsb = C2;
1724 if (OneUseOrZExtW && !IsCANDI) {
1726 if (Subtarget->hasStdExtZbkb() &&
C1 == 0xff00 && C2 == 8) {
1728 RISCV::PACKH,
DL, VT,
1729 CurDAG->getRegister(RISCV::X0, Subtarget->getXLenVT()),
X);
1735 RISCV::SLLI,
DL, VT,
X,
1736 CurDAG->getTargetConstant(C2 + Leading,
DL, VT));
1739 CurDAG->getTargetConstant(Leading,
DL, VT));
1751 if (Leading == C2 && C2 + Trailing < XLen && OneUseOrZExtW &&
1753 unsigned SrliOpc = RISCV::SRLI;
1757 X.getConstantOperandVal(1) == UINT64_C(0xFFFFFFFF)) {
1758 SrliOpc = RISCV::SRLIW;
1759 X =
X.getOperand(0);
1763 CurDAG->getTargetConstant(C2 + Trailing,
DL, VT));
1766 CurDAG->getTargetConstant(Trailing,
DL, VT));
1771 if (Leading > 32 && (Leading - 32) == C2 && C2 + Trailing < 32 &&
1772 OneUseOrZExtW && !IsCANDI) {
1774 RISCV::SRLIW,
DL, VT,
X,
1775 CurDAG->getTargetConstant(C2 + Trailing,
DL, VT));
1778 CurDAG->getTargetConstant(Trailing,
DL, VT));
1783 if (Trailing > 0 && Leading + Trailing == 32 && C2 + Trailing < XLen &&
1784 OneUseOrZExtW && Subtarget->hasStdExtZba()) {
1786 RISCV::SRLI,
DL, VT,
X,
1787 CurDAG->getTargetConstant(C2 + Trailing,
DL, VT));
1789 RISCV::SLLI_UW,
DL, VT,
SDValue(SRLI, 0),
1790 CurDAG->getTargetConstant(Trailing,
DL, VT));
1801 if (Leading == 0 && C2 < Trailing && OneUseOrZExtW && !IsCANDI) {
1803 RISCV::SRLI,
DL, VT,
X,
1804 CurDAG->getTargetConstant(Trailing - C2,
DL, VT));
1807 CurDAG->getTargetConstant(Trailing,
DL, VT));
1812 if (C2 < Trailing && Leading + C2 == 32 && OneUseOrZExtW && !IsCANDI) {
1814 RISCV::SRLIW,
DL, VT,
X,
1815 CurDAG->getTargetConstant(Trailing - C2,
DL, VT));
1818 CurDAG->getTargetConstant(Trailing,
DL, VT));
1824 if (C2 < Trailing && Leading + Trailing == 32 && OneUseOrZExtW &&
1825 Subtarget->hasStdExtZba()) {
1827 RISCV::SRLI,
DL, VT,
X,
1828 CurDAG->getTargetConstant(Trailing - C2,
DL, VT));
1830 RISCV::SLLI_UW,
DL, VT,
SDValue(SRLI, 0),
1831 CurDAG->getTargetConstant(Trailing,
DL, VT));
1838 const uint64_t
C1 = N1C->getZExtValue();
1843 unsigned XLen = Subtarget->getXLen();
1844 assert((C2 > 0 && C2 < XLen) &&
"Unexpected shift amount!");
1849 bool Skip = C2 > 32 &&
isInt<12>(N1C->getSExtValue()) &&
1852 X.getConstantOperandVal(1) == 32;
1859 RISCV::SRAI,
DL, VT,
X,
1860 CurDAG->getTargetConstant(C2 - Leading,
DL, VT));
1863 CurDAG->getTargetConstant(Leading,
DL, VT));
1875 if (C2 > Leading && Leading > 0 && Trailing > 0) {
1878 CurDAG->getTargetConstant(C2 - Leading,
DL, VT));
1881 CurDAG->getTargetConstant(Leading + Trailing,
DL, VT));
1884 CurDAG->getTargetConstant(Trailing,
DL, VT));
1897 !(
C1 == 0xffff && Subtarget->hasStdExtZbb()) &&
1898 !(
C1 == 0xffffffff && Subtarget->hasStdExtZba())) {
1918 if (!N1C || !N1C->hasOneUse())
1939 (C2 == UINT64_C(0xFFFF) && Subtarget->hasStdExtZbb());
1941 IsANDIOrZExt |= C2 == UINT64_C(0xFFFF) && Subtarget->hasVendorXTHeadBb();
1946 bool IsZExtW = C2 == UINT64_C(0xFFFFFFFF) && Subtarget->hasStdExtZba();
1948 IsZExtW |= C2 == UINT64_C(0xFFFFFFFF) && Subtarget->hasVendorXTHeadBb();
1955 unsigned XLen = Subtarget->getXLen();
1960 uint64_t
C1 = N1C->getZExtValue();
1961 unsigned ConstantShift = XLen - LeadingZeros;
1965 uint64_t ShiftedC1 =
C1 << ConstantShift;
1974 CurDAG->getTargetConstant(LeadingZeros,
DL, VT));
1982 case RISCVISD::WMULSU:
1983 case RISCVISD::WADD:
1984 case RISCVISD::WSUB:
1985 case RISCVISD::WADDU:
1986 case RISCVISD::WSUBU: {
1987 assert(Subtarget->hasStdExtP() && !Subtarget->is64Bit() && VT == MVT::i32 &&
1988 "Unexpected opcode");
1991 switch (
Node->getOpcode()) {
2000 case RISCVISD::WMULSU:
2001 Opc = RISCV::WMULSU;
2003 case RISCVISD::WADD:
2006 case RISCVISD::WSUB:
2009 case RISCVISD::WADDU:
2012 case RISCVISD::WSUBU:
2018 Opc,
DL, MVT::Untyped,
Node->getOperand(0),
Node->getOperand(1));
2026 case RISCVISD::WSLL:
2027 case RISCVISD::WSLA: {
2029 assert(Subtarget->hasStdExtP() && !Subtarget->is64Bit() && VT == MVT::i32 &&
2030 "Unexpected opcode");
2032 bool IsSigned =
Node->getOpcode() == RISCVISD::WSLA;
2039 if (ShAmtC && ShAmtC->getZExtValue() < 64) {
2040 Opc = IsSigned ? RISCV::WSLAI : RISCV::WSLLI;
2041 ShAmt =
CurDAG->getTargetConstant(ShAmtC->getZExtValue(),
DL, XLenVT);
2043 Opc = IsSigned ? RISCV::WSLA : RISCV::WSLL;
2047 Node->getOperand(0), ShAmt);
2059 if (Subtarget->hasVendorXCVmem() && !Subtarget->is64Bit()) {
2069 bool Simm12 =
false;
2073 int ConstantVal = ConstantOffset->getSExtValue();
2080 unsigned Opcode = 0;
2081 switch (
Load->getMemoryVT().getSimpleVT().SimpleTy) {
2083 if (Simm12 && SignExtend)
2084 Opcode = RISCV::CV_LB_ri_inc;
2085 else if (Simm12 && !SignExtend)
2086 Opcode = RISCV::CV_LBU_ri_inc;
2087 else if (!Simm12 && SignExtend)
2088 Opcode = RISCV::CV_LB_rr_inc;
2090 Opcode = RISCV::CV_LBU_rr_inc;
2093 if (Simm12 && SignExtend)
2094 Opcode = RISCV::CV_LH_ri_inc;
2095 else if (Simm12 && !SignExtend)
2096 Opcode = RISCV::CV_LHU_ri_inc;
2097 else if (!Simm12 && SignExtend)
2098 Opcode = RISCV::CV_LH_rr_inc;
2100 Opcode = RISCV::CV_LHU_rr_inc;
2104 Opcode = RISCV::CV_LW_ri_inc;
2106 Opcode = RISCV::CV_LW_rr_inc;
2121 case RISCVISD::LD_RV32: {
2122 assert(Subtarget->hasStdExtZilsd() &&
"LD_RV32 is only used with Zilsd");
2131 RISCV::LD_RV32,
DL, {MVT::Untyped, MVT::Other},
Ops);
2140 case RISCVISD::SD_RV32: {
2152 RegPair =
CurDAG->getRegister(RISCV::X0_Pair, MVT::Untyped);
2164 case RISCVISD::MQWACC:
2165 case RISCVISD::MQRWACC:
2166 case RISCVISD::WMACC:
2167 case RISCVISD::WMACCU:
2168 case RISCVISD::WMACCSU:
2169 case RISCVISD::PM2WADDA:
2170 case RISCVISD::PM2WADDA_X:
2171 case RISCVISD::PM2WADDAU:
2172 case RISCVISD::PM2WSUBA:
2173 case RISCVISD::PM2WSUBA_X:
2174 case RISCVISD::PM2WADDASU:
2175 case RISCVISD::WADDAU:
2176 case RISCVISD::WSUBAU:
2177 case RISCVISD::WADDA:
2178 case RISCVISD::WSUBA: {
2179 assert(!Subtarget->is64Bit() && Subtarget->hasStdExtP() &&
2180 "Unexpected opcode");
2183 Node->getOperand(1));
2188 case RISCVISD::MQWACC:
2189 Opc = RISCV::MQWACC;
2191 case RISCVISD::MQRWACC:
2192 Opc = RISCV::MQRWACC;
2194 case RISCVISD::WMACC:
2197 case RISCVISD::WMACCU:
2198 Opc = RISCV::WMACCU;
2200 case RISCVISD::WMACCSU:
2201 Opc = RISCV::WMACCSU;
2203 case RISCVISD::PM2WADDA:
2204 Opc = RISCV::PM2WADDA_H;
2206 case RISCVISD::PM2WADDA_X:
2207 Opc = RISCV::PM2WADDA_HX;
2209 case RISCVISD::PM2WADDAU:
2210 Opc = RISCV::PM2WADDAU_H;
2212 case RISCVISD::PM2WSUBA:
2213 Opc = RISCV::PM2WSUBA_H;
2215 case RISCVISD::PM2WSUBA_X:
2216 Opc = RISCV::PM2WSUBA_HX;
2218 case RISCVISD::PM2WADDASU:
2219 Opc = RISCV::PM2WADDASU_H;
2221 case RISCVISD::WADDAU:
2222 Opc = RISCV::WADDAU;
2224 case RISCVISD::WSUBAU:
2225 Opc = RISCV::WSUBAU;
2227 case RISCVISD::WADDA:
2230 case RISCVISD::WSUBA:
2235 Opc,
DL, MVT::Untyped, Op0,
Node->getOperand(2),
Node->getOperand(3));
2242 case RISCVISD::PM2WADD:
2243 case RISCVISD::PM2WADDU:
2244 case RISCVISD::PM2WADDSU:
2245 case RISCVISD::PM2WADD_X:
2246 case RISCVISD::PM2WSUB:
2247 case RISCVISD::PM2WSUB_X: {
2248 assert(!Subtarget->is64Bit() && Subtarget->hasStdExtP() &&
2249 "Unexpected opcode");
2254 case RISCVISD::PM2WADD:
2255 Opc = RISCV::PM2WADD_H;
2257 case RISCVISD::PM2WADDU:
2258 Opc = RISCV::PM2WADDU_H;
2260 case RISCVISD::PM2WADDSU:
2261 Opc = RISCV::PM2WADDSU_H;
2263 case RISCVISD::PM2WADD_X:
2264 Opc = RISCV::PM2WADD_HX;
2266 case RISCVISD::PM2WSUB:
2267 Opc = RISCV::PM2WSUB_H;
2269 case RISCVISD::PM2WSUB_X:
2270 Opc = RISCV::PM2WSUB_HX;
2274 Opc,
DL, MVT::Untyped,
Node->getOperand(0),
Node->getOperand(1));
2281 case RISCVISD::ADDD:
2289 case RISCVISD::SUBD: {
2290 assert(!Subtarget->is64Bit() && Subtarget->hasStdExtP() &&
2291 "Unexpected opcode");
2298 Op0 =
CurDAG->getRegister(RISCV::X0_Pair, MVT::Untyped);
2307 unsigned Opc = Opcode == RISCVISD::ADDD ? RISCV::ADDD : RISCV::SUBD;
2309 CurDAG->getMachineNode(
Opc,
DL, MVT::Untyped, Op0, Op1);
2318 unsigned IntNo =
Node->getConstantOperandVal(0);
2323 case Intrinsic::riscv_vmsgeu:
2324 case Intrinsic::riscv_vmsge: {
2327 bool IsUnsigned = IntNo == Intrinsic::riscv_vmsgeu;
2328 bool IsCmpConstant =
false;
2329 bool IsCmpMinimum =
false;
2331 if (Src2.getValueType() != XLenVT)
2335 MVT Src1VT = Src1.getSimpleValueType();
2337 IsCmpConstant =
true;
2338 CVal =
C->getSExtValue();
2339 if (CVal >= -15 && CVal <= 16) {
2340 if (!IsUnsigned || CVal != 0)
2342 IsCmpMinimum =
true;
2346 IsCmpMinimum =
true;
2349 unsigned VMSLTOpcode, VMNANDOpcode, VMSetOpcode, VMSGTOpcode;
2353#define CASE_VMSLT_OPCODES(lmulenum, suffix) \
2354 case RISCVVType::lmulenum: \
2355 VMSLTOpcode = IsUnsigned ? RISCV::PseudoVMSLTU_VX_##suffix \
2356 : RISCV::PseudoVMSLT_VX_##suffix; \
2357 VMSGTOpcode = IsUnsigned ? RISCV::PseudoVMSGTU_VX_##suffix \
2358 : RISCV::PseudoVMSGT_VX_##suffix; \
2367#undef CASE_VMSLT_OPCODES
2373#define CASE_VMNAND_VMSET_OPCODES(lmulenum, suffix) \
2374 case RISCVVType::lmulenum: \
2375 VMNANDOpcode = RISCV::PseudoVMNAND_MM_##suffix; \
2376 VMSetOpcode = RISCV::PseudoVMSET_M_##suffix; \
2385#undef CASE_VMNAND_VMSET_OPCODES
2396 CurDAG->getMachineNode(VMSetOpcode,
DL, VT, VL, MaskSEW));
2400 if (IsCmpConstant) {
2405 {Src1, Imm, VL, SEW}));
2412 CurDAG->getMachineNode(VMSLTOpcode,
DL, VT, {Src1, Src2, VL, SEW}),
2415 {Cmp, Cmp, VL, MaskSEW}));
2418 case Intrinsic::riscv_vmsgeu_mask:
2419 case Intrinsic::riscv_vmsge_mask: {
2422 bool IsUnsigned = IntNo == Intrinsic::riscv_vmsgeu_mask;
2423 bool IsCmpConstant =
false;
2424 bool IsCmpMinimum =
false;
2426 if (Src2.getValueType() != XLenVT)
2429 MVT Src1VT = Src1.getSimpleValueType();
2432 IsCmpConstant =
true;
2433 CVal =
C->getSExtValue();
2434 if (CVal >= -15 && CVal <= 16) {
2435 if (!IsUnsigned || CVal != 0)
2437 IsCmpMinimum =
true;
2441 IsCmpMinimum =
true;
2444 unsigned VMSLTOpcode, VMSLTMaskOpcode, VMXOROpcode, VMANDNOpcode,
2445 VMOROpcode, VMSGTMaskOpcode;
2449#define CASE_VMSLT_OPCODES(lmulenum, suffix) \
2450 case RISCVVType::lmulenum: \
2451 VMSLTOpcode = IsUnsigned ? RISCV::PseudoVMSLTU_VX_##suffix \
2452 : RISCV::PseudoVMSLT_VX_##suffix; \
2453 VMSLTMaskOpcode = IsUnsigned ? RISCV::PseudoVMSLTU_VX_##suffix##_MASK \
2454 : RISCV::PseudoVMSLT_VX_##suffix##_MASK; \
2455 VMSGTMaskOpcode = IsUnsigned ? RISCV::PseudoVMSGTU_VX_##suffix##_MASK \
2456 : RISCV::PseudoVMSGT_VX_##suffix##_MASK; \
2465#undef CASE_VMSLT_OPCODES
2471#define CASE_VMXOR_VMANDN_VMOR_OPCODES(lmulenum, suffix) \
2472 case RISCVVType::lmulenum: \
2473 VMXOROpcode = RISCV::PseudoVMXOR_MM_##suffix; \
2474 VMANDNOpcode = RISCV::PseudoVMANDN_MM_##suffix; \
2475 VMOROpcode = RISCV::PseudoVMOR_MM_##suffix; \
2484#undef CASE_VMXOR_VMANDN_VMOR_OPCODES
2498 if (Mask == MaskedOff) {
2503 CurDAG->getMachineNode(VMOROpcode,
DL, VT,
2504 {Mask, MaskedOff, VL, MaskSEW}));
2511 if (Mask == MaskedOff) {
2513 CurDAG->getMachineNode(VMSLTOpcode,
DL, VT, {Src1, Src2, VL, SEW}),
2516 {Mask, Cmp, VL, MaskSEW}));
2523 if (IsCmpConstant) {
2528 VMSGTMaskOpcode,
DL, VT,
2529 {MaskedOff, Src1, Imm, Mask, VL, SEW, PolicyOp}));
2539 {MaskedOff, Src1, Src2, Mask,
2540 VL, SEW, PolicyOp}),
2544 {Cmp, Mask, VL, MaskSEW}));
2547 case Intrinsic::riscv_vsetvli:
2548 case Intrinsic::riscv_vsetvlimax:
2550 case Intrinsic::riscv_sf_vsettnt:
2551 case Intrinsic::riscv_sf_vsettm:
2552 case Intrinsic::riscv_sf_vsettk:
2558 unsigned IntNo =
Node->getConstantOperandVal(1);
2563 case Intrinsic::riscv_vlseg2:
2564 case Intrinsic::riscv_vlseg3:
2565 case Intrinsic::riscv_vlseg4:
2566 case Intrinsic::riscv_vlseg5:
2567 case Intrinsic::riscv_vlseg6:
2568 case Intrinsic::riscv_vlseg7:
2569 case Intrinsic::riscv_vlseg8: {
2574 case Intrinsic::riscv_vlseg2_mask:
2575 case Intrinsic::riscv_vlseg3_mask:
2576 case Intrinsic::riscv_vlseg4_mask:
2577 case Intrinsic::riscv_vlseg5_mask:
2578 case Intrinsic::riscv_vlseg6_mask:
2579 case Intrinsic::riscv_vlseg7_mask:
2580 case Intrinsic::riscv_vlseg8_mask: {
2585 case Intrinsic::riscv_vlsseg2:
2586 case Intrinsic::riscv_vlsseg3:
2587 case Intrinsic::riscv_vlsseg4:
2588 case Intrinsic::riscv_vlsseg5:
2589 case Intrinsic::riscv_vlsseg6:
2590 case Intrinsic::riscv_vlsseg7:
2591 case Intrinsic::riscv_vlsseg8: {
2596 case Intrinsic::riscv_vlsseg2_mask:
2597 case Intrinsic::riscv_vlsseg3_mask:
2598 case Intrinsic::riscv_vlsseg4_mask:
2599 case Intrinsic::riscv_vlsseg5_mask:
2600 case Intrinsic::riscv_vlsseg6_mask:
2601 case Intrinsic::riscv_vlsseg7_mask:
2602 case Intrinsic::riscv_vlsseg8_mask: {
2607 case Intrinsic::riscv_vloxseg2:
2608 case Intrinsic::riscv_vloxseg3:
2609 case Intrinsic::riscv_vloxseg4:
2610 case Intrinsic::riscv_vloxseg5:
2611 case Intrinsic::riscv_vloxseg6:
2612 case Intrinsic::riscv_vloxseg7:
2613 case Intrinsic::riscv_vloxseg8:
2617 case Intrinsic::riscv_vluxseg2:
2618 case Intrinsic::riscv_vluxseg3:
2619 case Intrinsic::riscv_vluxseg4:
2620 case Intrinsic::riscv_vluxseg5:
2621 case Intrinsic::riscv_vluxseg6:
2622 case Intrinsic::riscv_vluxseg7:
2623 case Intrinsic::riscv_vluxseg8:
2627 case Intrinsic::riscv_vloxseg2_mask:
2628 case Intrinsic::riscv_vloxseg3_mask:
2629 case Intrinsic::riscv_vloxseg4_mask:
2630 case Intrinsic::riscv_vloxseg5_mask:
2631 case Intrinsic::riscv_vloxseg6_mask:
2632 case Intrinsic::riscv_vloxseg7_mask:
2633 case Intrinsic::riscv_vloxseg8_mask:
2637 case Intrinsic::riscv_vluxseg2_mask:
2638 case Intrinsic::riscv_vluxseg3_mask:
2639 case Intrinsic::riscv_vluxseg4_mask:
2640 case Intrinsic::riscv_vluxseg5_mask:
2641 case Intrinsic::riscv_vluxseg6_mask:
2642 case Intrinsic::riscv_vluxseg7_mask:
2643 case Intrinsic::riscv_vluxseg8_mask:
2647 case Intrinsic::riscv_vlseg8ff:
2648 case Intrinsic::riscv_vlseg7ff:
2649 case Intrinsic::riscv_vlseg6ff:
2650 case Intrinsic::riscv_vlseg5ff:
2651 case Intrinsic::riscv_vlseg4ff:
2652 case Intrinsic::riscv_vlseg3ff:
2653 case Intrinsic::riscv_vlseg2ff: {
2657 case Intrinsic::riscv_vlseg8ff_mask:
2658 case Intrinsic::riscv_vlseg7ff_mask:
2659 case Intrinsic::riscv_vlseg6ff_mask:
2660 case Intrinsic::riscv_vlseg5ff_mask:
2661 case Intrinsic::riscv_vlseg4ff_mask:
2662 case Intrinsic::riscv_vlseg3ff_mask:
2663 case Intrinsic::riscv_vlseg2ff_mask: {
2667 case Intrinsic::riscv_vloxei:
2668 case Intrinsic::riscv_vloxei_mask:
2669 case Intrinsic::riscv_vluxei:
2670 case Intrinsic::riscv_vluxei_mask: {
2671 bool IsMasked = IntNo == Intrinsic::riscv_vloxei_mask ||
2672 IntNo == Intrinsic::riscv_vluxei_mask;
2673 bool IsOrdered = IntNo == Intrinsic::riscv_vloxei ||
2674 IntNo == Intrinsic::riscv_vloxei_mask;
2676 MVT VT =
Node->getSimpleValueType(0);
2689 "Element count mismatch");
2694 if (IndexLog2EEW == 6 && !Subtarget->is64Bit()) {
2696 "index values when XLEN=32");
2699 IsMasked, IsOrdered, IndexLog2EEW,
static_cast<unsigned>(LMUL),
2700 static_cast<unsigned>(IndexLMUL));
2709 case Intrinsic::riscv_vlm:
2710 case Intrinsic::riscv_vle:
2711 case Intrinsic::riscv_vle_mask:
2712 case Intrinsic::riscv_vlse:
2713 case Intrinsic::riscv_vlse_mask: {
2714 bool IsMasked = IntNo == Intrinsic::riscv_vle_mask ||
2715 IntNo == Intrinsic::riscv_vlse_mask;
2717 IntNo == Intrinsic::riscv_vlse || IntNo == Intrinsic::riscv_vlse_mask;
2719 MVT VT =
Node->getSimpleValueType(0);
2728 bool HasPassthruOperand = IntNo != Intrinsic::riscv_vlm;
2731 if (HasPassthruOperand)
2737 CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF,
DL, VT);
2745 RISCV::getVLEPseudo(IsMasked, IsStrided,
false, Log2SEW,
2746 static_cast<unsigned>(LMUL));
2755 case Intrinsic::riscv_vleff:
2756 case Intrinsic::riscv_vleff_mask: {
2757 bool IsMasked = IntNo == Intrinsic::riscv_vleff_mask;
2759 MVT VT =
Node->getSimpleValueType(0);
2771 RISCV::getVLEPseudo(IsMasked,
false,
true,
2772 Log2SEW,
static_cast<unsigned>(LMUL));
2780 case Intrinsic::riscv_nds_vln:
2781 case Intrinsic::riscv_nds_vln_mask:
2782 case Intrinsic::riscv_nds_vlnu:
2783 case Intrinsic::riscv_nds_vlnu_mask: {
2784 bool IsMasked = IntNo == Intrinsic::riscv_nds_vln_mask ||
2785 IntNo == Intrinsic::riscv_nds_vlnu_mask;
2786 bool IsUnsigned = IntNo == Intrinsic::riscv_nds_vlnu ||
2787 IntNo == Intrinsic::riscv_nds_vlnu_mask;
2789 MVT VT =
Node->getSimpleValueType(0);
2801 IsMasked, IsUnsigned, Log2SEW,
static_cast<unsigned>(LMUL));
2815 unsigned IntNo =
Node->getConstantOperandVal(1);
2817 case Intrinsic::riscv_vsseg2:
2818 case Intrinsic::riscv_vsseg3:
2819 case Intrinsic::riscv_vsseg4:
2820 case Intrinsic::riscv_vsseg5:
2821 case Intrinsic::riscv_vsseg6:
2822 case Intrinsic::riscv_vsseg7:
2823 case Intrinsic::riscv_vsseg8: {
2828 case Intrinsic::riscv_vsseg2_mask:
2829 case Intrinsic::riscv_vsseg3_mask:
2830 case Intrinsic::riscv_vsseg4_mask:
2831 case Intrinsic::riscv_vsseg5_mask:
2832 case Intrinsic::riscv_vsseg6_mask:
2833 case Intrinsic::riscv_vsseg7_mask:
2834 case Intrinsic::riscv_vsseg8_mask: {
2839 case Intrinsic::riscv_vssseg2:
2840 case Intrinsic::riscv_vssseg3:
2841 case Intrinsic::riscv_vssseg4:
2842 case Intrinsic::riscv_vssseg5:
2843 case Intrinsic::riscv_vssseg6:
2844 case Intrinsic::riscv_vssseg7:
2845 case Intrinsic::riscv_vssseg8: {
2850 case Intrinsic::riscv_vssseg2_mask:
2851 case Intrinsic::riscv_vssseg3_mask:
2852 case Intrinsic::riscv_vssseg4_mask:
2853 case Intrinsic::riscv_vssseg5_mask:
2854 case Intrinsic::riscv_vssseg6_mask:
2855 case Intrinsic::riscv_vssseg7_mask:
2856 case Intrinsic::riscv_vssseg8_mask: {
2861 case Intrinsic::riscv_vsoxseg2:
2862 case Intrinsic::riscv_vsoxseg3:
2863 case Intrinsic::riscv_vsoxseg4:
2864 case Intrinsic::riscv_vsoxseg5:
2865 case Intrinsic::riscv_vsoxseg6:
2866 case Intrinsic::riscv_vsoxseg7:
2867 case Intrinsic::riscv_vsoxseg8:
2871 case Intrinsic::riscv_vsuxseg2:
2872 case Intrinsic::riscv_vsuxseg3:
2873 case Intrinsic::riscv_vsuxseg4:
2874 case Intrinsic::riscv_vsuxseg5:
2875 case Intrinsic::riscv_vsuxseg6:
2876 case Intrinsic::riscv_vsuxseg7:
2877 case Intrinsic::riscv_vsuxseg8:
2881 case Intrinsic::riscv_vsoxseg2_mask:
2882 case Intrinsic::riscv_vsoxseg3_mask:
2883 case Intrinsic::riscv_vsoxseg4_mask:
2884 case Intrinsic::riscv_vsoxseg5_mask:
2885 case Intrinsic::riscv_vsoxseg6_mask:
2886 case Intrinsic::riscv_vsoxseg7_mask:
2887 case Intrinsic::riscv_vsoxseg8_mask:
2891 case Intrinsic::riscv_vsuxseg2_mask:
2892 case Intrinsic::riscv_vsuxseg3_mask:
2893 case Intrinsic::riscv_vsuxseg4_mask:
2894 case Intrinsic::riscv_vsuxseg5_mask:
2895 case Intrinsic::riscv_vsuxseg6_mask:
2896 case Intrinsic::riscv_vsuxseg7_mask:
2897 case Intrinsic::riscv_vsuxseg8_mask:
2901 case Intrinsic::riscv_vsoxei:
2902 case Intrinsic::riscv_vsoxei_mask:
2903 case Intrinsic::riscv_vsuxei:
2904 case Intrinsic::riscv_vsuxei_mask: {
2905 bool IsMasked = IntNo == Intrinsic::riscv_vsoxei_mask ||
2906 IntNo == Intrinsic::riscv_vsuxei_mask;
2907 bool IsOrdered = IntNo == Intrinsic::riscv_vsoxei ||
2908 IntNo == Intrinsic::riscv_vsoxei_mask;
2910 MVT VT =
Node->getOperand(2)->getSimpleValueType(0);
2923 "Element count mismatch");
2928 if (IndexLog2EEW == 6 && !Subtarget->is64Bit()) {
2930 "index values when XLEN=32");
2933 IsMasked, IsOrdered, IndexLog2EEW,
2934 static_cast<unsigned>(LMUL),
static_cast<unsigned>(IndexLMUL));
2943 case Intrinsic::riscv_vsm:
2944 case Intrinsic::riscv_vse:
2945 case Intrinsic::riscv_vse_mask:
2946 case Intrinsic::riscv_vsse:
2947 case Intrinsic::riscv_vsse_mask: {
2948 bool IsMasked = IntNo == Intrinsic::riscv_vse_mask ||
2949 IntNo == Intrinsic::riscv_vsse_mask;
2951 IntNo == Intrinsic::riscv_vsse || IntNo == Intrinsic::riscv_vsse_mask;
2953 MVT VT =
Node->getOperand(2)->getSimpleValueType(0);
2965 IsMasked, IsStrided, Log2SEW,
static_cast<unsigned>(LMUL));
2973 case Intrinsic::riscv_sf_vc_x_se:
2974 case Intrinsic::riscv_sf_vc_i_se:
2977 case Intrinsic::riscv_sf_vlte8:
2978 case Intrinsic::riscv_sf_vlte16:
2979 case Intrinsic::riscv_sf_vlte32:
2980 case Intrinsic::riscv_sf_vlte64: {
2982 unsigned PseudoInst;
2984 case Intrinsic::riscv_sf_vlte8:
2985 PseudoInst = RISCV::PseudoSF_VLTE8;
2988 case Intrinsic::riscv_sf_vlte16:
2989 PseudoInst = RISCV::PseudoSF_VLTE16;
2992 case Intrinsic::riscv_sf_vlte32:
2993 PseudoInst = RISCV::PseudoSF_VLTE32;
2996 case Intrinsic::riscv_sf_vlte64:
2997 PseudoInst = RISCV::PseudoSF_VLTE64;
3005 Node->getOperand(3),
3006 Node->getOperand(4),
3009 Node->getOperand(0)};
3013 CurDAG->setNodeMemRefs(TileLoad,
3019 case Intrinsic::riscv_sf_mm_s_s:
3020 case Intrinsic::riscv_sf_mm_s_u:
3021 case Intrinsic::riscv_sf_mm_u_s:
3022 case Intrinsic::riscv_sf_mm_u_u:
3023 case Intrinsic::riscv_sf_mm_e5m2_e5m2:
3024 case Intrinsic::riscv_sf_mm_e5m2_e4m3:
3025 case Intrinsic::riscv_sf_mm_e4m3_e5m2:
3026 case Intrinsic::riscv_sf_mm_e4m3_e4m3:
3027 case Intrinsic::riscv_sf_mm_f_f: {
3028 bool HasFRM =
false;
3029 unsigned PseudoInst;
3031 case Intrinsic::riscv_sf_mm_s_s:
3032 PseudoInst = RISCV::PseudoSF_MM_S_S;
3034 case Intrinsic::riscv_sf_mm_s_u:
3035 PseudoInst = RISCV::PseudoSF_MM_S_U;
3037 case Intrinsic::riscv_sf_mm_u_s:
3038 PseudoInst = RISCV::PseudoSF_MM_U_S;
3040 case Intrinsic::riscv_sf_mm_u_u:
3041 PseudoInst = RISCV::PseudoSF_MM_U_U;
3043 case Intrinsic::riscv_sf_mm_e5m2_e5m2:
3044 PseudoInst = RISCV::PseudoSF_MM_E5M2_E5M2;
3047 case Intrinsic::riscv_sf_mm_e5m2_e4m3:
3048 PseudoInst = RISCV::PseudoSF_MM_E5M2_E4M3;
3051 case Intrinsic::riscv_sf_mm_e4m3_e5m2:
3052 PseudoInst = RISCV::PseudoSF_MM_E4M3_E5M2;
3055 case Intrinsic::riscv_sf_mm_e4m3_e4m3:
3056 PseudoInst = RISCV::PseudoSF_MM_E4M3_E4M3;
3059 case Intrinsic::riscv_sf_mm_f_f:
3060 if (
Node->getOperand(3).getValueType().getScalarType() == MVT::bf16)
3061 PseudoInst = RISCV::PseudoSF_MM_F_F_ALT;
3063 PseudoInst = RISCV::PseudoSF_MM_F_F;
3067 uint64_t TileNum =
Node->getConstantOperandVal(2);
3079 if (IntNo == Intrinsic::riscv_sf_mm_f_f && Log2SEW == 5 &&
3089 CurDAG->getTargetConstant(Log2SEW,
DL, XLenVT), TWidenOp,
3098 case Intrinsic::riscv_sf_vtzero_t: {
3099 uint64_t TileNum =
Node->getConstantOperandVal(2);
3105 auto *NewNode =
CurDAG->getMachineNode(
3106 RISCV::PseudoSF_VTZERO_T,
DL,
Node->getVTList(),
3107 {CurDAG->getRegister(getTileReg(TileNum), XLenVT), Tm, Tn, Log2SEW,
3117 MVT SrcVT =
Node->getOperand(0).getSimpleValueType();
3126 if (Subtarget->hasStdExtP()) {
3128 (VT == MVT::i32 && (SrcVT == MVT::v4i8 || SrcVT == MVT::v2i16)) ||
3129 (SrcVT == MVT::i32 && (VT == MVT::v4i8 || VT == MVT::v2i16));
3131 (VT == MVT::i64 && (SrcVT == MVT::v8i8 || SrcVT == MVT::v4i16 ||
3132 SrcVT == MVT::v2i32)) ||
3133 (SrcVT == MVT::i64 &&
3134 (VT == MVT::v8i8 || VT == MVT::v4i16 || VT == MVT::v2i32));
3135 if (Is32BitCast || Is64BitCast) {
3144 if (!Subtarget->hasStdExtP())
3147 bool IsDoubleWide = Subtarget->isPExtPackedDoubleType(VT);
3149 if (ConstNode->isZero()) {
3150 MCPhysReg X0Reg = IsDoubleWide ? RISCV::X0_Pair : RISCV::X0;
3158 APInt Val = ConstNode->getAPIntValue().
trunc(EltSize);
3163 RISCV::ADDI,
DL, VT,
CurDAG->getRegister(RISCV::X0, VT),
3164 CurDAG->getAllOnesConstant(
DL, XLenVT,
true));
3171 Val = Val.
trunc(16);
3180 Opc = IsDoubleWide ? RISCV::PLI_DB : RISCV::PLI_B;
3182 Opc = IsDoubleWide ? RISCV::PLI_DH : RISCV::PLI_H;
3183 }
else if (!IsDoubleWide && EltSize == 32 &&
isInt<10>(
Imm)) {
3186 Opc = IsDoubleWide ? RISCV::PLUI_DH : RISCV::PLUI_H;
3189 Opc = RISCV::PLUI_W;
3204 if (Subtarget->hasStdExtP()) {
3205 MVT SrcVT =
Node->getOperand(0).getSimpleValueType();
3206 if (SrcVT == Subtarget->getXLenVT() &&
3215 case RISCVISD::TUPLE_INSERT: {
3219 auto Idx =
Node->getConstantOperandVal(2);
3223 MVT SubVecContainerVT = SubVecVT;
3226 SubVecContainerVT =
TLI.getContainerForFixedLengthVector(SubVecVT);
3228 [[maybe_unused]]
bool ExactlyVecRegSized =
3230 .isKnownMultipleOf(Subtarget->expandVScale(VecRegSize));
3232 .getKnownMinValue()));
3233 assert(Idx == 0 && (ExactlyVecRegSized || V.isUndef()));
3239 const auto *
TRI = Subtarget->getRegisterInfo();
3241 std::tie(SubRegIdx, Idx) =
3253 [[maybe_unused]]
bool IsSubVecPartReg =
3257 assert((V.getValueType().isRISCVVectorTuple() || !IsSubVecPartReg ||
3259 "Expecting lowering to have created legal INSERT_SUBVECTORs when "
3260 "the subvector is smaller than a full-sized register");
3264 if (SubRegIdx == RISCV::NoSubRegister) {
3265 unsigned InRegClassID =
3269 "Unexpected subvector extraction");
3271 SDNode *NewNode =
CurDAG->getMachineNode(TargetOpcode::COPY_TO_REGCLASS,
3277 SDValue Insert =
CurDAG->getTargetInsertSubreg(SubRegIdx,
DL, VT, V, SubV);
3281 case RISCVISD::TUPLE_CAST: {
3289 Node->getOperand(0).getSimpleValueType()) &&
3290 "Expected input and output of TUPLE_CAST to use the same "
3297 case RISCVISD::TUPLE_EXTRACT: {
3298 if (Subtarget->hasStdExtP())
3302 auto Idx =
Node->getConstantOperandVal(1);
3303 MVT InVT = V.getSimpleValueType();
3308 MVT SubVecContainerVT = VT;
3312 SubVecContainerVT =
TLI.getContainerForFixedLengthVector(VT);
3315 InVT =
TLI.getContainerForFixedLengthVector(InVT);
3317 const auto *
TRI = Subtarget->getRegisterInfo();
3319 std::tie(SubRegIdx, Idx) =
3321 InVT, SubVecContainerVT, Idx,
TRI);
3331 if (SubRegIdx == RISCV::NoSubRegister) {
3335 "Unexpected subvector extraction");
3338 CurDAG->getMachineNode(TargetOpcode::COPY_TO_REGCLASS,
DL, VT, V, RC);
3343 SDValue Extract =
CurDAG->getTargetExtractSubreg(SubRegIdx,
DL, VT, V);
3347 case RISCVISD::VMV_S_X_VL:
3348 case RISCVISD::VFMV_S_F_VL:
3349 case RISCVISD::VMV_V_X_VL:
3350 case RISCVISD::VFMV_V_F_VL: {
3352 bool IsScalarMove =
Node->getOpcode() == RISCVISD::VMV_S_X_VL ||
3353 Node->getOpcode() == RISCVISD::VFMV_S_F_VL;
3354 if (!
Node->getOperand(0).isUndef())
3360 if (!Ld || Ld->isIndexed())
3362 EVT MemVT = Ld->getMemoryVT();
3388 if (IsStrided && !Subtarget->hasOptimizedZeroStrideLoad())
3392 SDValue(
CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF,
DL, VT), 0),
3398 Operands.append({VL, SEW, PolicyOp, Ld->getChain()});
3402 false, IsStrided,
false,
3403 Log2SEW,
static_cast<unsigned>(LMUL));
3409 CurDAG->setNodeMemRefs(
Load, {Ld->getMemOperand()});
3414 case RISCVISD::LPAD_CALL:
3415 case RISCVISD::LPAD_CALL_INDIRECT: {
3416 bool IsIndirect = Opcode == RISCVISD::LPAD_CALL_INDIRECT;
3417 unsigned PseudoOpc = IsIndirect ? RISCV::PseudoCALLIndirectLpadAlign
3418 : RISCV::PseudoCALLLpadAlign;
3421 if (std::optional<uint32_t> Label =
3422 Subtarget->getCLOpts().landing_pad_label) {
3425 "in unsigned 20-bits");
3433 Ops.push_back(
Node->getOperand(1));
3434 Ops.push_back(
CurDAG->getTargetConstant(LpadLabel,
DL, XLenVT));
3437 bool HasGlue =
Node->getGluedNode() !=
nullptr;
3438 unsigned RegOperandsEnd = HasGlue ?
NumOps - 1 :
NumOps;
3439 for (
unsigned I = 2;
I != RegOperandsEnd; ++
I)
3440 Ops.push_back(
Node->getOperand(
I));
3442 Ops.push_back(
Node->getOperand(0));
3453 if (Subtarget->hasVendorXMIPSCBOP())
3456 unsigned Locality =
Node->getConstantOperandVal(3);
3464 int NontemporalLevel = 0;
3467 NontemporalLevel = 3;
3470 NontemporalLevel = 1;
3473 NontemporalLevel = 0;
3479 if (NontemporalLevel & 0b1)
3481 if (NontemporalLevel & 0b10)