79#define DEBUG_TYPE "mips-lower"
84 Mips::D12_64, Mips::D13_64, Mips::D14_64, Mips::D15_64,
85 Mips::D16_64, Mips::D17_64, Mips::D18_64, Mips::D19_64
122 unsigned &NumIntermediates,
MVT &RegisterVT)
const {
127 return NumIntermediates;
143 unsigned Flag)
const {
149 unsigned Flag)
const {
155 unsigned Flag)
const {
161 unsigned Flag)
const {
167 unsigned Flag)
const {
169 N->getOffset(), Flag);
442 isMicroMips =
Subtarget.inMicroMipsMode();
468 if (!TM.isPositionIndependent() || !
Subtarget.getABI().IsO32() ||
489 EVT Ty =
N->getValueType(0);
490 unsigned LO = (Ty == MVT::i32) ? Mips::LO0 : Mips::LO0_64;
491 unsigned HI = (Ty == MVT::i32) ? Mips::HI0 : Mips::HI0_64;
497 N->getOperand(0),
N->getOperand(1));
502 if (
N->hasAnyUseOfValue(0)) {
511 if (
N->hasAnyUseOfValue(1)) {
553 "Illegal Condition Code");
568 if (!
LHS.getValueType().isFloatingPoint())
589 return DAG.
getNode((invert ? MipsISD::CMovFP_F : MipsISD::CMovFP_T),
DL,
614 if (
Subtarget.hasMips64r6() && FalseTy == MVT::i64 &&
616 LHS.getOperand(0).getValueType() == MVT::i64 &&
657 if (!TrueC || !
True.getValueType().isInteger())
663 if (
True.getValueType() == MVT::i64)
696 SDValue ValueIfTrue =
N->getOperand(0), ValueIfFalse =
N->getOperand(2);
709 unsigned Opc = (
N->getOpcode() == MipsISD::CMovFP_T) ? MipsISD::CMovFP_F :
712 SDValue FCC =
N->getOperand(1), Glue =
N->getOperand(3);
714 ValueIfFalse, FCC, ValueIfTrue, Glue);
723 SDValue FirstOperand =
N->getOperand(0);
724 unsigned FirstOperandOpc = FirstOperand.
getOpcode();
726 EVT ValTy =
N->getValueType(0);
730 unsigned SMPos, SMSize;
771 if (SMPos != Pos || Pos >= ValTy.
getSizeInBits() || SMSize >= 32 ||
793 NewOperand = FirstOperand;
806 SDValue FirstOperand =
N->getOperand(0), SecondOperand =
N->getOperand(1);
807 unsigned SMPos0, SMSize0, SMPos1, SMSize1;
811 SecondOperand.getOpcode() ==
ISD::SHL) ||
813 SecondOperand.getOpcode() ==
ISD::AND)) {
824 ? SecondOperand.getOperand(0)
834 ? SecondOperand.getOperand(1)
840 if (SMPos0 != 0 || SMSize0 != ShlShiftValue)
844 EVT ValTy =
N->getValueType(0);
845 SMPos1 = ShlShiftValue;
847 SMSize1 = (ValTy == MVT::i64 ? 64 : 32) - SMPos1;
848 return DAG.
getNode(MipsISD::Ins,
DL, ValTy, ShlOperand0,
866 if (SecondOperand.getOpcode() ==
ISD::AND &&
867 SecondOperand.getOperand(0).getOpcode() ==
ISD::SHL) {
874 if (SMPos0 != SMPos1 || SMSize0 != SMSize1)
886 EVT ValTy =
N->getValueType(0);
887 if ((Shamt != SMPos0) || (SMPos0 + SMSize0 > ValTy.
getSizeInBits()))
902 ((SMSize0 + SMPos0 <= 64 &&
Subtarget.hasMips64r2()) ||
903 (SMSize0 + SMPos0 <= 32))) {
905 bool isConstCase = SecondOperand.getOpcode() !=
ISD::AND;
906 if (SecondOperand.getOpcode() ==
ISD::AND) {
919 EVT ValTy =
N->getOperand(0)->getValueType(0);
925 SecondOperand, Const1);
928 MipsISD::Ins,
DL,
N->getValueType(0),
1010 if (!IsSigned && !IsUnsigned)
1016 std::tie(BottomHalf, TopHalf) =
1019 CurDAG.
getNode(MipsISD::MTLOHI,
DL, MVT::Untyped, BottomHalf, TopHalf);
1023 unsigned Opcode = IsAdd ? (IsUnsigned ? MipsISD::MAddu : MipsISD::MAdd)
1024 : (IsUnsigned ? MipsISD::MSubu : MipsISD::MSub);
1043 !
Subtarget.inMips16Mode() &&
N->getValueType(0) == MVT::i64)
1058 !
Subtarget.inMips16Mode() &&
N->getValueType(0) == MVT::i64)
1068 SDValue InnerAdd =
N->getOperand(1);
1077 if (
Lo.getOpcode() != MipsISD::Lo)
1080 if ((
Lo.getOpcode() != MipsISD::Lo) ||
1084 EVT ValTy =
N->getValueType(0);
1101 SDValue FirstOperand =
N->getOperand(0);
1102 unsigned FirstOperandOpc = FirstOperand.
getOpcode();
1103 SDValue SecondOperand =
N->getOperand(1);
1104 EVT ValTy =
N->getValueType(0);
1108 unsigned SMPos, SMSize;
1131 if (SMPos != 0 || SMSize > 32 || Pos + SMSize > ValTy.
getSizeInBits())
1138 return DAG.
getNode(MipsISD::CIns,
DL, ValTy, NewOperand,
1151 EVT VT =
N->getValueType(0);
1180 int64_t ConstImm = ConstantOperand->getSExtValue();
1191 unsigned Opc =
N->getOpcode();
1200 case MipsISD::CMovFP_F:
1201 case MipsISD::CMovFP_T:
1233 return C->getAPIntValue().ule(15);
1241 N->getOperand(0).getOpcode() ==
ISD::SRL) ||
1243 N->getOperand(0).getOpcode() ==
ISD::SHL)) &&
1244 "Expected shift-shift mask");
1246 if (
N->getOperand(0).getValueType().isVector())
1261 switch (
Op.getOpcode())
1273 return lowerFSETCC(
Op, DAG);
1279 return lowerFCANONICALIZE(
Op, DAG);
1292 return lowerSTRICT_FP_TO_INT(
Op, DAG);
1295 return lowerREADCYCLECOUNTER(
Op, DAG);
1297 return lowerConstantFP(
Op, DAG);
1321 if (MCCLOpts.mno_check_zero_division)
1346 MF->
insert(++
MBB.getIterator(), BreakMBB);
1359 MBB.addSuccessor(BreakMBB);
1393 switch (
MI.getOpcode()) {
1396 case Mips::ATOMIC_LOAD_ADD_I8:
1397 return emitAtomicBinaryPartword(
MI, BB, 1);
1398 case Mips::ATOMIC_LOAD_ADD_I16:
1399 return emitAtomicBinaryPartword(
MI, BB, 2);
1400 case Mips::ATOMIC_LOAD_ADD_I32:
1401 return emitAtomicBinary(
MI, BB);
1402 case Mips::ATOMIC_LOAD_ADD_I64:
1403 return emitAtomicBinary(
MI, BB);
1405 case Mips::ATOMIC_LOAD_AND_I8:
1406 return emitAtomicBinaryPartword(
MI, BB, 1);
1407 case Mips::ATOMIC_LOAD_AND_I16:
1408 return emitAtomicBinaryPartword(
MI, BB, 2);
1409 case Mips::ATOMIC_LOAD_AND_I32:
1410 return emitAtomicBinary(
MI, BB);
1411 case Mips::ATOMIC_LOAD_AND_I64:
1412 return emitAtomicBinary(
MI, BB);
1414 case Mips::ATOMIC_LOAD_OR_I8:
1415 return emitAtomicBinaryPartword(
MI, BB, 1);
1416 case Mips::ATOMIC_LOAD_OR_I16:
1417 return emitAtomicBinaryPartword(
MI, BB, 2);
1418 case Mips::ATOMIC_LOAD_OR_I32:
1419 return emitAtomicBinary(
MI, BB);
1420 case Mips::ATOMIC_LOAD_OR_I64:
1421 return emitAtomicBinary(
MI, BB);
1423 case Mips::ATOMIC_LOAD_XOR_I8:
1424 return emitAtomicBinaryPartword(
MI, BB, 1);
1425 case Mips::ATOMIC_LOAD_XOR_I16:
1426 return emitAtomicBinaryPartword(
MI, BB, 2);
1427 case Mips::ATOMIC_LOAD_XOR_I32:
1428 return emitAtomicBinary(
MI, BB);
1429 case Mips::ATOMIC_LOAD_XOR_I64:
1430 return emitAtomicBinary(
MI, BB);
1432 case Mips::ATOMIC_LOAD_NAND_I8:
1433 return emitAtomicBinaryPartword(
MI, BB, 1);
1434 case Mips::ATOMIC_LOAD_NAND_I16:
1435 return emitAtomicBinaryPartword(
MI, BB, 2);
1436 case Mips::ATOMIC_LOAD_NAND_I32:
1437 return emitAtomicBinary(
MI, BB);
1438 case Mips::ATOMIC_LOAD_NAND_I64:
1439 return emitAtomicBinary(
MI, BB);
1441 case Mips::ATOMIC_LOAD_SUB_I8:
1442 return emitAtomicBinaryPartword(
MI, BB, 1);
1443 case Mips::ATOMIC_LOAD_SUB_I16:
1444 return emitAtomicBinaryPartword(
MI, BB, 2);
1445 case Mips::ATOMIC_LOAD_SUB_I32:
1446 return emitAtomicBinary(
MI, BB);
1447 case Mips::ATOMIC_LOAD_SUB_I64:
1448 return emitAtomicBinary(
MI, BB);
1450 case Mips::ATOMIC_SWAP_I8:
1451 return emitAtomicBinaryPartword(
MI, BB, 1);
1452 case Mips::ATOMIC_SWAP_I16:
1453 return emitAtomicBinaryPartword(
MI, BB, 2);
1454 case Mips::ATOMIC_SWAP_I32:
1455 return emitAtomicBinary(
MI, BB);
1456 case Mips::ATOMIC_SWAP_I64:
1457 return emitAtomicBinary(
MI, BB);
1459 case Mips::ATOMIC_CMP_SWAP_I8:
1460 return emitAtomicCmpSwapPartword(
MI, BB, 1);
1461 case Mips::ATOMIC_CMP_SWAP_I16:
1462 return emitAtomicCmpSwapPartword(
MI, BB, 2);
1463 case Mips::ATOMIC_CMP_SWAP_I32:
1464 return emitAtomicCmpSwap(
MI, BB);
1465 case Mips::ATOMIC_CMP_SWAP_I64:
1466 return emitAtomicCmpSwap(
MI, BB);
1468 case Mips::ATOMIC_LOAD_MIN_I8:
1469 return emitAtomicBinaryPartword(
MI, BB, 1);
1470 case Mips::ATOMIC_LOAD_MIN_I16:
1471 return emitAtomicBinaryPartword(
MI, BB, 2);
1472 case Mips::ATOMIC_LOAD_MIN_I32:
1473 return emitAtomicBinary(
MI, BB);
1474 case Mips::ATOMIC_LOAD_MIN_I64:
1475 return emitAtomicBinary(
MI, BB);
1477 case Mips::ATOMIC_LOAD_MAX_I8:
1478 return emitAtomicBinaryPartword(
MI, BB, 1);
1479 case Mips::ATOMIC_LOAD_MAX_I16:
1480 return emitAtomicBinaryPartword(
MI, BB, 2);
1481 case Mips::ATOMIC_LOAD_MAX_I32:
1482 return emitAtomicBinary(
MI, BB);
1483 case Mips::ATOMIC_LOAD_MAX_I64:
1484 return emitAtomicBinary(
MI, BB);
1486 case Mips::ATOMIC_LOAD_UMIN_I8:
1487 return emitAtomicBinaryPartword(
MI, BB, 1);
1488 case Mips::ATOMIC_LOAD_UMIN_I16:
1489 return emitAtomicBinaryPartword(
MI, BB, 2);
1490 case Mips::ATOMIC_LOAD_UMIN_I32:
1491 return emitAtomicBinary(
MI, BB);
1492 case Mips::ATOMIC_LOAD_UMIN_I64:
1493 return emitAtomicBinary(
MI, BB);
1495 case Mips::ATOMIC_LOAD_UMAX_I8:
1496 return emitAtomicBinaryPartword(
MI, BB, 1);
1497 case Mips::ATOMIC_LOAD_UMAX_I16:
1498 return emitAtomicBinaryPartword(
MI, BB, 2);
1499 case Mips::ATOMIC_LOAD_UMAX_I32:
1500 return emitAtomicBinary(
MI, BB);
1501 case Mips::ATOMIC_LOAD_UMAX_I64:
1502 return emitAtomicBinary(
MI, BB);
1504 case Mips::PseudoSDIV:
1505 case Mips::PseudoUDIV:
1514 *
Subtarget.getInstrInfo(),
false, TrapKind);
1516 case Mips::SDIV_MM_Pseudo:
1517 case Mips::UDIV_MM_Pseudo:
1520 case Mips::DIV_MMR6:
1521 case Mips::DIVU_MMR6:
1522 case Mips::MOD_MMR6:
1523 case Mips::MODU_MMR6:
1527 case Mips::PseudoDSDIV:
1528 case Mips::PseudoDUDIV:
1537 case Mips::PseudoSELECT_I:
1538 case Mips::PseudoSELECT_I64:
1539 case Mips::PseudoSELECT_S:
1540 case Mips::PseudoSELECT_D32:
1541 case Mips::PseudoSELECT_D64:
1542 return emitPseudoSELECT(
MI, BB,
false, Mips::BNE);
1543 case Mips::PseudoSELECTFP_F_I:
1544 case Mips::PseudoSELECTFP_F_I64:
1545 case Mips::PseudoSELECTFP_F_S:
1546 case Mips::PseudoSELECTFP_F_D32:
1547 case Mips::PseudoSELECTFP_F_D64:
1548 return emitPseudoSELECT(
MI, BB,
true, Mips::BC1F);
1549 case Mips::PseudoSELECTFP_T_I:
1550 case Mips::PseudoSELECTFP_T_I64:
1551 case Mips::PseudoSELECTFP_T_S:
1552 case Mips::PseudoSELECTFP_T_D32:
1553 case Mips::PseudoSELECTFP_T_D64:
1554 return emitPseudoSELECT(
MI, BB,
true, Mips::BC1T);
1555 case Mips::PseudoD_SELECT_I:
1556 case Mips::PseudoD_SELECT_I64:
1557 return emitPseudoD_SELECT(
MI, BB);
1559 return emitLDR_W(
MI, BB);
1561 return emitLDR_D(
MI, BB);
1563 return emitSTR_W(
MI, BB);
1565 return emitSTR_D(
MI, BB);
1581 bool NeedsAdditionalReg =
false;
1582 switch (
MI.getOpcode()) {
1583 case Mips::ATOMIC_LOAD_ADD_I32:
1584 AtomicOp = Mips::ATOMIC_LOAD_ADD_I32_POSTRA;
1586 case Mips::ATOMIC_LOAD_SUB_I32:
1587 AtomicOp = Mips::ATOMIC_LOAD_SUB_I32_POSTRA;
1589 case Mips::ATOMIC_LOAD_AND_I32:
1590 AtomicOp = Mips::ATOMIC_LOAD_AND_I32_POSTRA;
1592 case Mips::ATOMIC_LOAD_OR_I32:
1593 AtomicOp = Mips::ATOMIC_LOAD_OR_I32_POSTRA;
1595 case Mips::ATOMIC_LOAD_XOR_I32:
1596 AtomicOp = Mips::ATOMIC_LOAD_XOR_I32_POSTRA;
1598 case Mips::ATOMIC_LOAD_NAND_I32:
1599 AtomicOp = Mips::ATOMIC_LOAD_NAND_I32_POSTRA;
1601 case Mips::ATOMIC_SWAP_I32:
1602 AtomicOp = Mips::ATOMIC_SWAP_I32_POSTRA;
1604 case Mips::ATOMIC_LOAD_ADD_I64:
1605 AtomicOp = Mips::ATOMIC_LOAD_ADD_I64_POSTRA;
1607 case Mips::ATOMIC_LOAD_SUB_I64:
1608 AtomicOp = Mips::ATOMIC_LOAD_SUB_I64_POSTRA;
1610 case Mips::ATOMIC_LOAD_AND_I64:
1611 AtomicOp = Mips::ATOMIC_LOAD_AND_I64_POSTRA;
1613 case Mips::ATOMIC_LOAD_OR_I64:
1614 AtomicOp = Mips::ATOMIC_LOAD_OR_I64_POSTRA;
1616 case Mips::ATOMIC_LOAD_XOR_I64:
1617 AtomicOp = Mips::ATOMIC_LOAD_XOR_I64_POSTRA;
1619 case Mips::ATOMIC_LOAD_NAND_I64:
1620 AtomicOp = Mips::ATOMIC_LOAD_NAND_I64_POSTRA;
1622 case Mips::ATOMIC_SWAP_I64:
1623 AtomicOp = Mips::ATOMIC_SWAP_I64_POSTRA;
1625 case Mips::ATOMIC_LOAD_MIN_I32:
1626 AtomicOp = Mips::ATOMIC_LOAD_MIN_I32_POSTRA;
1627 NeedsAdditionalReg =
true;
1629 case Mips::ATOMIC_LOAD_MAX_I32:
1630 AtomicOp = Mips::ATOMIC_LOAD_MAX_I32_POSTRA;
1631 NeedsAdditionalReg =
true;
1633 case Mips::ATOMIC_LOAD_UMIN_I32:
1634 AtomicOp = Mips::ATOMIC_LOAD_UMIN_I32_POSTRA;
1635 NeedsAdditionalReg =
true;
1637 case Mips::ATOMIC_LOAD_UMAX_I32:
1638 AtomicOp = Mips::ATOMIC_LOAD_UMAX_I32_POSTRA;
1639 NeedsAdditionalReg =
true;
1641 case Mips::ATOMIC_LOAD_MIN_I64:
1642 AtomicOp = Mips::ATOMIC_LOAD_MIN_I64_POSTRA;
1643 NeedsAdditionalReg =
true;
1645 case Mips::ATOMIC_LOAD_MAX_I64:
1646 AtomicOp = Mips::ATOMIC_LOAD_MAX_I64_POSTRA;
1647 NeedsAdditionalReg =
true;
1649 case Mips::ATOMIC_LOAD_UMIN_I64:
1650 AtomicOp = Mips::ATOMIC_LOAD_UMIN_I64_POSTRA;
1651 NeedsAdditionalReg =
true;
1653 case Mips::ATOMIC_LOAD_UMAX_I64:
1654 AtomicOp = Mips::ATOMIC_LOAD_UMAX_I64_POSTRA;
1655 NeedsAdditionalReg =
true;
1716 if (NeedsAdditionalReg) {
1723 MI.eraseFromParent();
1730 unsigned SrcReg)
const {
1745 MachineRegisterInfo &RegInfo = MF->
getRegInfo();
1750 int64_t ShiftImm = 32 - (
Size * 8);
1761 "Unsupported size for EmitAtomicBinaryPartial.");
1764 MachineRegisterInfo &RegInfo = MF->
getRegInfo();
1766 const bool ArePtrs64bit =
ABI.ArePtrs64bit();
1788 unsigned AtomicOp = 0;
1789 bool NeedsAdditionalReg =
false;
1790 switch (
MI.getOpcode()) {
1791 case Mips::ATOMIC_LOAD_NAND_I8:
1792 AtomicOp = Mips::ATOMIC_LOAD_NAND_I8_POSTRA;
1794 case Mips::ATOMIC_LOAD_NAND_I16:
1795 AtomicOp = Mips::ATOMIC_LOAD_NAND_I16_POSTRA;
1797 case Mips::ATOMIC_SWAP_I8:
1798 AtomicOp = Mips::ATOMIC_SWAP_I8_POSTRA;
1800 case Mips::ATOMIC_SWAP_I16:
1801 AtomicOp = Mips::ATOMIC_SWAP_I16_POSTRA;
1803 case Mips::ATOMIC_LOAD_ADD_I8:
1804 AtomicOp = Mips::ATOMIC_LOAD_ADD_I8_POSTRA;
1806 case Mips::ATOMIC_LOAD_ADD_I16:
1807 AtomicOp = Mips::ATOMIC_LOAD_ADD_I16_POSTRA;
1809 case Mips::ATOMIC_LOAD_SUB_I8:
1810 AtomicOp = Mips::ATOMIC_LOAD_SUB_I8_POSTRA;
1812 case Mips::ATOMIC_LOAD_SUB_I16:
1813 AtomicOp = Mips::ATOMIC_LOAD_SUB_I16_POSTRA;
1815 case Mips::ATOMIC_LOAD_AND_I8:
1816 AtomicOp = Mips::ATOMIC_LOAD_AND_I8_POSTRA;
1818 case Mips::ATOMIC_LOAD_AND_I16:
1819 AtomicOp = Mips::ATOMIC_LOAD_AND_I16_POSTRA;
1821 case Mips::ATOMIC_LOAD_OR_I8:
1822 AtomicOp = Mips::ATOMIC_LOAD_OR_I8_POSTRA;
1824 case Mips::ATOMIC_LOAD_OR_I16:
1825 AtomicOp = Mips::ATOMIC_LOAD_OR_I16_POSTRA;
1827 case Mips::ATOMIC_LOAD_XOR_I8:
1828 AtomicOp = Mips::ATOMIC_LOAD_XOR_I8_POSTRA;
1830 case Mips::ATOMIC_LOAD_XOR_I16:
1831 AtomicOp = Mips::ATOMIC_LOAD_XOR_I16_POSTRA;
1833 case Mips::ATOMIC_LOAD_MIN_I8:
1834 AtomicOp = Mips::ATOMIC_LOAD_MIN_I8_POSTRA;
1835 NeedsAdditionalReg =
true;
1837 case Mips::ATOMIC_LOAD_MIN_I16:
1838 AtomicOp = Mips::ATOMIC_LOAD_MIN_I16_POSTRA;
1839 NeedsAdditionalReg =
true;
1841 case Mips::ATOMIC_LOAD_MAX_I8:
1842 AtomicOp = Mips::ATOMIC_LOAD_MAX_I8_POSTRA;
1843 NeedsAdditionalReg =
true;
1845 case Mips::ATOMIC_LOAD_MAX_I16:
1846 AtomicOp = Mips::ATOMIC_LOAD_MAX_I16_POSTRA;
1847 NeedsAdditionalReg =
true;
1849 case Mips::ATOMIC_LOAD_UMIN_I8:
1850 AtomicOp = Mips::ATOMIC_LOAD_UMIN_I8_POSTRA;
1851 NeedsAdditionalReg =
true;
1853 case Mips::ATOMIC_LOAD_UMIN_I16:
1854 AtomicOp = Mips::ATOMIC_LOAD_UMIN_I16_POSTRA;
1855 NeedsAdditionalReg =
true;
1857 case Mips::ATOMIC_LOAD_UMAX_I8:
1858 AtomicOp = Mips::ATOMIC_LOAD_UMAX_I8_POSTRA;
1859 NeedsAdditionalReg =
true;
1861 case Mips::ATOMIC_LOAD_UMAX_I16:
1862 AtomicOp = Mips::ATOMIC_LOAD_UMAX_I16_POSTRA;
1863 NeedsAdditionalReg =
true;
1892 int64_t MaskImm = (
Size == 1) ? 255 : 65535;
1898 .
addReg(Ptr, {}, ArePtrs64bit ? Mips::sub_32 : 0)
1921 MachineInstrBuilder MIB =
1935 if (NeedsAdditionalReg) {
1941 MI.eraseFromParent();
1955 assert((
MI.getOpcode() == Mips::ATOMIC_CMP_SWAP_I32 ||
1956 MI.getOpcode() == Mips::ATOMIC_CMP_SWAP_I64) &&
1957 "Unsupported atomic pseudo for EmitAtomicCmpSwap.");
1959 const unsigned Size =
MI.getOpcode() == Mips::ATOMIC_CMP_SWAP_I32 ? 4 : 8;
1967 unsigned AtomicOp =
MI.getOpcode() == Mips::ATOMIC_CMP_SWAP_I32
1968 ? Mips::ATOMIC_CMP_SWAP_I32_POSTRA
1969 : Mips::ATOMIC_CMP_SWAP_I64_POSTRA;
2003 MI.eraseFromParent();
2011 "Unsupported size for EmitAtomicCmpSwapPartial.");
2014 MachineRegisterInfo &RegInfo = MF->
getRegInfo();
2016 const bool ArePtrs64bit =
ABI.ArePtrs64bit();
2038 unsigned AtomicOp =
MI.getOpcode() == Mips::ATOMIC_CMP_SWAP_I8
2039 ? Mips::ATOMIC_CMP_SWAP_I8_POSTRA
2040 : Mips::ATOMIC_CMP_SWAP_I16_POSTRA;
2081 int64_t MaskImm = (
Size == 1) ? 255 : 65535;
2082 BuildMI(BB,
DL,
TII->get(ArePtrs64bit ? Mips::DADDiu : Mips::ADDiu), MaskLSB2)
2084 BuildMI(BB,
DL,
TII->get(ArePtrs64bit ? Mips::AND64 : Mips::AND), AlignedAddr)
2087 .
addReg(Ptr, {}, ArePtrs64bit ? Mips::sub_32 : 0)
2129 MI.eraseFromParent();
2136 EVT VT =
Op.getValueType();
2153 uint32_t
Lo =
Bits & 0xFFFFFFFF;
2154 if (
Lo != 0 || Bits == 0)
2162 return DAG.
getNode(MipsISD::BuildPairF64,
DL, MVT::f64,
Low,
Hi);
2174 unsigned RdhwrOpc, DestReg;
2177 if (PtrVT == MVT::i64) {
2178 RdhwrOpc = Mips::RDHWR64;
2190 RdhwrOpc = Mips::RDHWR;
2218 if (CondRes.
getOpcode() != MipsISD::FPCmp)
2226 return DAG.
getNode(MipsISD::FPBrcond,
DL,
Op.getValueType(), Chain, BrCode,
2227 FCC0, Dest, CondRes);
2237 if (
Cond.getOpcode() != MipsISD::FPCmp)
2249 "Floating point operand expected.");
2278 EVT Ty =
Op.getValueType();
2280 const GlobalValue *GV =
N->getGlobal();
2284 "Windows is the only supported COFF target");
2291 const MipsTargetObjectFile *TLOF =
2292 static_cast<const MipsTargetObjectFile *
>(
2295 if (
Subtarget.useSmallSection() && GO && TLOF->IsGlobalInSmallSection(GO))
2326 N, SDLoc(
N), Ty, DAG,
2334 EVT Ty =
Op.getValueType();
2355 const GlobalValue *GV = GA->
getGlobal();
2374 Args.emplace_back(Argument, PtrTy);
2376 TargetLowering::CallLoweringInfo CLI(DAG);
2379 .setLibCallee(
CallingConv::C, PtrTy, TlsGetAddr, std::move(Args));
2380 std::pair<SDValue, SDValue> CallResult =
LowerCallTo(CLI);
2382 SDValue Ret = CallResult.first;
2426 EVT Ty =
Op.getValueType();
2439 EVT Ty =
Op.getValueType();
2442 const MipsTargetObjectFile *TLOF =
2443 static_cast<const MipsTargetObjectFile *
>(
2460 MipsFunctionInfo *FuncInfo = MF.
getInfo<MipsFunctionInfo>();
2470 MachinePointerInfo(SV));
2474 SDNode *
Node =
Op.getNode();
2475 EVT VT =
Node->getValueType(0);
2479 llvm::MaybeAlign(
Node->getConstantOperandVal(3)).valueOrOne();
2482 unsigned ArgSlotSizeInBytes = (
ABI.IsN32() ||
ABI.IsN64()) ? 8 : 4;
2485 VAListPtr, MachinePointerInfo(SV));
2507 unsigned ArgSizeInBytes =
2515 MachinePointerInfo(SV));
2522 if (!
Subtarget.isLittle() && ArgSizeInBytes < ArgSlotSizeInBytes) {
2523 unsigned Adjustment = ArgSlotSizeInBytes - ArgSizeInBytes;
2528 return DAG.
getLoad(VT,
DL, Chain, VAList, MachinePointerInfo());
2532 bool HasExtractInsert) {
2533 EVT TyX =
Op.getOperand(0).getValueType();
2534 EVT TyY =
Op.getOperand(1).getValueType();
2544 DAG.
getNode(MipsISD::ExtractElementF64,
DL, MVT::i32,
Op.getOperand(0),
2548 DAG.
getNode(MipsISD::ExtractElementF64,
DL, MVT::i32,
Op.getOperand(1),
2551 if (HasExtractInsert) {
2555 Res = DAG.
getNode(MipsISD::Ins,
DL, MVT::i32,
E, Const31, Const1,
X);
2569 if (TyX == MVT::f32)
2575 return DAG.
getNode(MipsISD::BuildPairF64,
DL, MVT::f64, LowX, Res);
2579 bool HasExtractInsert) {
2580 unsigned WidthX =
Op.getOperand(0).getValueSizeInBits();
2581 unsigned WidthY =
Op.getOperand(1).getValueSizeInBits();
2590 if (HasExtractInsert) {
2596 if (WidthX > WidthY)
2598 else if (WidthY > WidthX)
2617 if (WidthX > WidthY)
2619 else if (WidthY > WidthX)
2637 bool HasExtractInsert)
const {
2641 if (
Op->getFlags().hasNoNaNs() ||
Subtarget.inAbs2008Mode())
2648 : DAG.
getNode(MipsISD::ExtractElementF64,
DL, MVT::i32,
2649 Op.getOperand(0), Const1);
2652 if (HasExtractInsert)
2653 Res = DAG.
getNode(MipsISD::Ins,
DL, MVT::i32,
2663 if (
Op.getValueType() == MVT::f32)
2671 DAG.
getNode(MipsISD::ExtractElementF64,
DL, MVT::i32,
Op.getOperand(0),
2673 return DAG.
getNode(MipsISD::BuildPairF64,
DL, MVT::f64, LowX, Res);
2677 bool HasExtractInsert)
const {
2681 if (
Op->getFlags().hasNoNaNs() ||
Subtarget.inAbs2008Mode())
2688 if (HasExtractInsert)
2689 Res = DAG.
getNode(MipsISD::Ins,
DL, MVT::i64,
2701 if ((
ABI.IsN32() ||
ABI.IsN64()) && (
Op.getValueType() == MVT::f64))
2702 return lowerFABS64(
Op, DAG,
Subtarget.hasExtractInsert());
2704 return lowerFABS32(
Op, DAG,
Subtarget.hasExtractInsert());
2710 EVT VT =
Op.getValueType();
2712 SDNodeFlags
Flags =
Op->getFlags();
2724 if (
Op.getConstantOperandVal(0) != 0) {
2726 "return address can be determined only for current frame");
2732 EVT VT =
Op.getValueType();
2742 if (
Op.getConstantOperandVal(0) != 0) {
2744 "return address can be determined only for current frame");
2750 MVT VT =
Op.getSimpleValueType();
2766 MipsFunctionInfo *MipsFI = MF.
getInfo<MipsFunctionInfo>();
2773 EVT Ty =
ABI.IsN64() ? MVT::i64 : MVT::i32;
2777 unsigned OffsetReg =
ABI.getReturnRegPtr(1);
2778 unsigned AddrReg =
ABI.getReturnRegPtr(0);
2781 return DAG.
getNode(MipsISD::EH_RETURN,
DL, MVT::Other, Chain,
2797 return DAG.
getNode(MipsISD::Sync,
DL, MVT::Other,
Op.getOperand(0),
2815 MVT VT =
Subtarget.isGP64bit() ? MVT::i64 : MVT::i32;
2854 MVT VT =
Subtarget.isGP64bit() ? MVT::i64 : MVT::i32;
2888 SDVTList VTList = DAG.
getVTList(VT, VT);
2910 SDValue Ptr = LD->getBasePtr();
2911 EVT VT = LD->getValueType(0), MemVT = LD->getMemoryVT();
2922 LD->getMemOperand());
2928 EVT MemVT = LD->getMemoryVT();
2930 if (
Subtarget.systemSupportsUnalignedAccess())
2934 if ((LD->getAlign().value() >= (MemVT.
getSizeInBits() / 8)) ||
2935 ((MemVT != MVT::i32) && (MemVT != MVT::i64)))
2939 EVT VT =
Op.getValueType();
2943 assert((VT == MVT::i32) || (VT == MVT::i64));
3021 return createStoreLR(MipsISD::SWR, DAG, SD, SWL, IsLittle ? 0 : 3);
3032 return createStoreLR(MipsISD::SDR, DAG, SD, SDL, IsLittle ? 0 : 7);
3057 if (!
Subtarget.systemSupportsUnalignedAccess() &&
3059 ((MemVT == MVT::i32) || (MemVT == MVT::i64)))
3071 EVT ValTy =
Op->getValueType(0);
3078 if (
Op.getValueSizeInBits() > 32 &&
Subtarget.isSingleFloat())
3096 Loc,
Op.getValueType(), SrcVal);
3102 static const MCPhysReg RCRegs[] = {Mips::FCR31};
3135 State.getMachineFunction().getSubtarget());
3150 if (LocVT == MVT::i8 || LocVT == MVT::i16 || LocVT == MVT::i32) {
3154 else if (ArgFlags.
isZExt())
3162 if (LocVT == MVT::i8 || LocVT == MVT::i16) {
3166 else if (ArgFlags.
isZExt())
3177 bool AllocateFloatsInIntReg = State.isVarArg() || ValNo > 1 ||
3178 State.getFirstUnallocated(
F32Regs) != ValNo;
3180 bool isI64 = (ValVT == MVT::i32 && OrigAlign ==
Align(8));
3184 if (ValVT == MVT::i32 && isVectorFloat) {
3190 Reg = State.AllocateReg(FloatVectorIntRegs);
3192 State.AllocateReg(
IntRegs[1]);
3194 State.AllocateReg(
IntRegs[3]);
3200 }
else if (ValVT == MVT::i32 ||
3201 (ValVT == MVT::f32 && AllocateFloatsInIntReg)) {
3208 }
else if (ValVT == MVT::f64 && AllocateFloatsInIntReg) {
3228 if (ValVT == MVT::f32) {
3233 Reg = State.AllocateReg(F64Regs);
3256 static const MCPhysReg F64Regs[] = { Mips::D6, Mips::D7 };
3258 return CC_MipsO32(ValNo, ValVT, LocVT, LocInfo, ArgFlags, OrigTy, State,
3266 static const MCPhysReg F64Regs[] = { Mips::D12_64, Mips::D14_64 };
3268 return CC_MipsO32(ValNo, ValVT, LocVT, LocInfo, ArgFlags, OrigTy, State,
3277#define GET_CALLING_CONV_IMPL
3278#include "MipsGenCallingConv.inc"
3281 return CC_Mips_FixedArg;
3293 const SDLoc &
DL,
bool IsTailCall,
3311 std::deque<std::pair<unsigned, SDValue>> &RegsToPass,
bool IsPICCall,
3312 bool GlobalOrExternal,
bool LocalLinkage,
bool IsCallReloc,
3324 if (IsPICCall && !LocalLinkage && IsCallReloc) {
3326 EVT Ty =
ABI.IsN64() ? MVT::i64 : MVT::i32;
3327 RegsToPass.push_back(std::make_pair(GPReg,
getGlobalReg(CLI.
DAG, Ty)));
3336 for (
auto &R : RegsToPass) {
3343 for (
auto &R : RegsToPass)
3350 assert(Mask &&
"Missing call preserved mask for calling convention");
3354 Function *
F =
G->getGlobal()->getParent()->getFunction(Sym);
3355 if (
F &&
F->hasFnAttribute(
"__Mips16RetHelper")) {
3363 Ops.push_back(InGlue);
3368 switch (
MI.getOpcode()) {
3372 case Mips::JALRPseudo:
3374 case Mips::JALR64Pseudo:
3375 case Mips::JALR16_MM:
3376 case Mips::JALRC16_MMR6:
3377 case Mips::TAILCALLREG:
3378 case Mips::TAILCALLREG64:
3379 case Mips::TAILCALLR6REG:
3380 case Mips::TAILCALL64R6REG:
3381 case Mips::TAILCALLREG_MM:
3382 case Mips::TAILCALLREG_MMR6: {
3385 Node->getOperand(0).getNumOperands() < 2) {
3391 const SDValue TargetAddr =
Node->getOperand(0).getOperand(1);
3401 LLVM_DEBUG(
dbgs() <<
"Not adding R_MIPS_JALR against data symbol "
3409 S =
MI.getParent()->getParent()->getContext().getOrCreateSymbol(
3485 unsigned ReservedArgArea =
3486 MemcpyInByVal ? 0 : ABI.GetCalleeAllocdArgSizeInBytes(CallConv);
3487 CCInfo.AllocateStack(ReservedArgArea,
Align(1));
3489 CCInfo.AnalyzeCallOperands(Outs,
CC_Mips);
3492 unsigned StackSize = CCInfo.getStackSize();
3504 bool CalleeIsLocal =
true;
3508 bool HasHiddenVisibility =
3511 CalleeIsLocal = HasLocalLinkage || HasHiddenVisibility;
3517 if (!
Subtarget.getCLOpts().tail_calls) {
3521 "site marked musttail");
3523 bool Eligible = isEligibleForTailCallOptimization(
3524 CCInfo, StackSize, *MF.
getInfo<MipsFunctionInfo>());
3525 if (!Eligible || !CalleeIsLocal) {
3529 "failed to perform tail call elimination on a call "
3530 "site marked musttail");
3542 StackSize =
alignTo(StackSize, StackAlignment);
3544 if (!(IsTailCall || MemcpyInByVal))
3550 std::deque<std::pair<unsigned, SDValue>> RegsToPass;
3553 CCInfo.rewindByValRegsInfo();
3556 for (
unsigned i = 0, e = ArgLocs.
size(), OutIdx = 0; i != e; ++i, ++OutIdx) {
3557 SDValue Arg = OutVals[OutIdx];
3558 CCValAssign &VA = ArgLocs[i];
3560 ISD::ArgFlagsTy
Flags = Outs[OutIdx].Flags;
3561 bool UseUpperBits =
false;
3564 if (
Flags.isByVal()) {
3565 unsigned FirstByValReg, LastByValReg;
3566 unsigned ByValIdx = CCInfo.getInRegsParamsProcessed();
3567 CCInfo.getInRegsParamInfo(ByValIdx, FirstByValReg, LastByValReg);
3570 "ByVal args of size 0 should have been ignored by front-end.");
3571 assert(ByValIdx < CCInfo.getInRegsParamsCount());
3573 "Do not tail-call optimize if there is a byval argument.");
3574 passByValArg(Chain,
DL, RegsToPass, MemOpChains, StackPtr, MFI, DAG, Arg,
3575 FirstByValReg, LastByValReg, Flags,
Subtarget.isLittle(),
3577 CCInfo.nextInRegsParam();
3587 if ((ValVT == MVT::f32 && LocVT == MVT::i32) ||
3588 (ValVT == MVT::f64 && LocVT == MVT::i64) ||
3589 (ValVT == MVT::i64 && LocVT == MVT::f64))
3591 else if (ValVT == MVT::f64 && LocVT == MVT::i32) {
3602 Register LocRegHigh = ArgLocs[++i].getLocReg();
3603 RegsToPass.
push_back(std::make_pair(LocRegLo,
Lo));
3604 RegsToPass.push_back(std::make_pair(LocRegHigh,
Hi));
3613 UseUpperBits =
true;
3619 UseUpperBits =
true;
3625 UseUpperBits =
true;
3633 unsigned ValSizeInBits = Outs[OutIdx].ArgVT.getSizeInBits();
3643 RegsToPass.push_back(std::make_pair(VA.
getLocReg(), Arg));
3664 Chain, Arg,
DL, IsTailCall, DAG));
3669 if (!MemOpChains.
empty())
3676 EVT Ty =
Callee.getValueType();
3677 bool GlobalOrExternal =
false, IsCallReloc =
false;
3682 if (!
Subtarget.isABICalls() && !IsPIC) {
3692 bool UseLongCalls =
Subtarget.useLongCalls();
3696 if (
F->hasFnAttribute(
"long-call"))
3697 UseLongCalls =
true;
3698 else if (
F->hasFnAttribute(
"short-call"))
3699 UseLongCalls =
false;
3708 bool LocalLinkage =
false;
3711 G->getGlobal()->hasDLLImportStorageClass()) {
3713 "Windows is the only supported COFF target");
3714 auto PtrInfo = MachinePointerInfo();
3718 const GlobalValue *Val =
G->getGlobal();
3737 GlobalOrExternal =
true;
3740 const char *Sym = S->getSymbol();
3756 GlobalOrExternal =
true;
3760 SDVTList NodeTys = DAG.
getVTList(MVT::Other, MVT::Glue);
3762 getOpndList(
Ops, RegsToPass, IsPIC, GlobalOrExternal, LocalLinkage,
3763 IsCallReloc, CLI, Callee, Chain);
3772 Chain = DAG.
getNode(MipsISD::JmpLink,
DL, NodeTys,
Ops);
3779 if (!(MemcpyInByVal)) {
3786 return LowerCallResult(Chain, InGlue, CallConv, IsVarArg, Ins,
DL, DAG,
3792SDValue MipsTargetLowering::LowerCallResult(
3802 CCInfo.AnalyzeCallResult(Ins, RetCC_Mips);
3805 for (
unsigned i = 0; i != RVLocs.
size(); ++i) {
3806 CCValAssign &VA = RVLocs[i];
3810 RVLocs[i].getLocVT(), InGlue);
3815 unsigned ValSizeInBits = Ins[i].ArgVT.getSizeInBits();
3916SDValue MipsTargetLowering::LowerFormalArguments(
3922 MipsFunctionInfo *MipsFI = MF.
getInfo<MipsFunctionInfo>();
3927 std::vector<SDValue> OutChains;
3933 CCInfo.AllocateStack(
ABI.GetCalleeAllocdArgSizeInBytes(CallConv),
Align(1));
3937 if (
Func.hasFnAttribute(
"interrupt") && !
Func.arg_empty())
3939 "Functions with the interrupt attribute cannot have arguments!");
3941 CCInfo.AnalyzeFormalArguments(Ins, CC_Mips_FixedArg);
3943 CCInfo.getInRegsParamsCount() > 0);
3945 unsigned CurArgIdx = 0;
3946 CCInfo.rewindByValRegsInfo();
3948 for (
unsigned i = 0, e = ArgLocs.
size(), InsIdx = 0; i != e; ++i, ++InsIdx) {
3949 CCValAssign &VA = ArgLocs[i];
3950 if (Ins[InsIdx].isOrigArg()) {
3951 std::advance(FuncArg, Ins[InsIdx].getOrigArgIndex() - CurArgIdx);
3952 CurArgIdx = Ins[InsIdx].getOrigArgIndex();
3955 ISD::ArgFlagsTy
Flags = Ins[InsIdx].Flags;
3958 if (
Flags.isByVal()) {
3959 assert(Ins[InsIdx].isOrigArg() &&
"Byval arguments cannot be implicit");
3960 unsigned FirstByValReg, LastByValReg;
3961 unsigned ByValIdx = CCInfo.getInRegsParamsProcessed();
3962 CCInfo.getInRegsParamInfo(ByValIdx, FirstByValReg, LastByValReg);
3965 "ByVal args of size 0 should have been ignored by front-end.");
3966 assert(ByValIdx < CCInfo.getInRegsParamsCount());
3967 copyByValRegs(Chain,
DL, OutChains, DAG, Flags, InVals, &*FuncArg,
3968 FirstByValReg, LastByValReg, VA, CCInfo);
3969 CCInfo.nextInRegsParam();
3989 if ((RegVT == MVT::i32 && ValVT == MVT::f32) ||
3990 (RegVT == MVT::i64 && ValVT == MVT::f64) ||
3991 (RegVT == MVT::f64 && ValVT == MVT::i64))
3993 else if (
ABI.IsO32() && RegVT == MVT::i32 &&
3994 ValVT == MVT::f64) {
3996 CCValAssign &NextVA = ArgLocs[++i];
4002 ArgValue = DAG.
getNode(MipsISD::BuildPairF64,
DL, MVT::f64,
4003 ArgValue, ArgValue2);
4022 LocVT,
DL, Chain, FIN,
4024 OutChains.push_back(ArgValue.
getValue(1));
4033 for (
unsigned i = 0, e = ArgLocs.
size(), InsIdx = 0; i != e; ++i, ++InsIdx) {
4035 if (ArgLocs[i].needsCustom()) {
4043 if (Ins[InsIdx].
Flags.isSRet()) {
4057 writeVarArgRegs(OutChains, Chain,
DL, DAG, CCInfo);
4061 if (!OutChains.empty()) {
4062 OutChains.push_back(Chain);
4079 MipsCCState CCInfo(CallConv, IsVarArg, MF, RVLocs,
Context);
4080 return CCInfo.CheckReturn(Outs, RetCC_Mips);
4083bool MipsTargetLowering::shouldSignExtendTypeInLibCall(
Type *Ty,
4084 bool IsSigned)
const {
4096 MipsFunctionInfo *MipsFI = MF.
getInfo<MipsFunctionInfo>();
4100 return DAG.
getNode(MipsISD::ERet,
DL, MVT::Other, RetOps);
4115 MipsCCState CCInfo(CallConv, IsVarArg, MF, RVLocs, *DAG.
getContext());
4118 CCInfo.AnalyzeReturn(Outs, RetCC_Mips);
4124 for (
unsigned i = 0; i != RVLocs.
size(); ++i) {
4126 CCValAssign &VA = RVLocs[i];
4128 bool UseUpperBits =
false;
4139 UseUpperBits =
true;
4145 UseUpperBits =
true;
4151 UseUpperBits =
true;
4159 unsigned ValSizeInBits = Outs[i].ArgVT.getSizeInBits();
4178 MipsFunctionInfo *MipsFI = MF.
getInfo<MipsFunctionInfo>();
4185 unsigned V0 =
ABI.getReturnRegPtr(0);
4200 return LowerInterruptReturn(RetOps,
DL, DAG);
4203 return DAG.
getNode(MipsISD::Ret,
DL, MVT::Other, RetOps);
4213MipsTargetLowering::getConstraintType(
StringRef Constraint)
const {
4225 if (Constraint.
size() == 1) {
4226 switch (Constraint[0]) {
4240 if (Constraint ==
"ZC")
4250MipsTargetLowering::getSingleConstraintMatchWeight(
4251 AsmOperandInfo &
info,
const char *constraint)
const {
4253 Value *CallOperandVal =
info.CallOperandVal;
4256 if (!CallOperandVal)
4260 switch (*constraint) {
4304 unsigned long long &
Reg) {
4305 if (
C.front() !=
'{' ||
C.back() !=
'}')
4306 return std::make_pair(
false,
false);
4310 I = std::find_if(
B,
E, isdigit);
4316 return std::make_pair(
true,
false);
4327 return VT.
bitsLT(MinVT) ? MinVT : VT;
4330std::pair<unsigned, const TargetRegisterClass *> MipsTargetLowering::
4336 unsigned long long Reg;
4341 return std::make_pair(0U,
nullptr);
4343 for (
unsigned RegClassID : {Mips::HI32RegClassID, Mips::LO32RegClassID}) {
4345 Prefix, *
TRI, RegClassID, Mips::RegAliasName)) {
4348 return std::make_pair(0U,
nullptr);
4349 return std::make_pair(NamedReg.id(),
TRI->getRegClass(RegClassID));
4353 if (
Prefix.starts_with(
"$msa")) {
4358 return std::make_pair(0U,
nullptr);
4360 RC =
TRI->getRegClass(Mips::MSACtrlRegClassID);
4362 Prefix.drop_front(), *
TRI, Mips::MSACtrlRegClassID, Mips::RegAliasName);
4364 return std::make_pair(0U,
nullptr);
4366 return std::make_pair(
Reg, RC);
4370 return std::make_pair(0U,
nullptr);
4372 if (Prefix ==
"$f") {
4377 if (VT == MVT::Other) {
4381 VT = (
Subtarget.isFP64bit() || !(
Reg % 2)) ? MVT::f64 : MVT::f32;
4386 if (RC == &Mips::AFGR64RegClass) {
4390 }
else if (Prefix ==
"$fcc")
4391 RC =
TRI->getRegClass(Mips::FCCRegClassID);
4392 else if (Prefix ==
"$w") {
4400 return std::make_pair(*(RC->
begin() +
Reg), RC);
4406std::pair<unsigned, const TargetRegisterClass *>
4410 if (Constraint.
size() == 1) {
4411 switch (Constraint[0]) {
4415 if ((VT == MVT::i32 || VT == MVT::i16 || VT == MVT::i8 ||
4417 (VT == MVT::f32 &&
Subtarget.useSoftFloat())) {
4419 return std::make_pair(0U, &Mips::CPU16RegsRegClass);
4420 return std::make_pair(0U, &Mips::GPR32RegClass);
4422 if ((VT == MVT::i64 || (VT == MVT::f64 &&
Subtarget.useSoftFloat()) ||
4423 (VT == MVT::f64 &&
Subtarget.isSingleFloat())) &&
4425 return std::make_pair(0U, &Mips::GPR32RegClass);
4426 if ((VT == MVT::i64 || (VT == MVT::f64 &&
Subtarget.useSoftFloat()) ||
4427 (VT == MVT::f64 &&
Subtarget.isSingleFloat())) &&
4429 return std::make_pair(0U, &Mips::GPR64RegClass);
4431 return std::make_pair(0U,
nullptr);
4433 if (VT == MVT::v16i8)
4434 return std::make_pair(0U, &Mips::MSA128BRegClass);
4435 else if (VT == MVT::v8i16 || VT == MVT::v8f16)
4436 return std::make_pair(0U, &Mips::MSA128HRegClass);
4437 else if (VT == MVT::v4i32 || VT == MVT::v4f32)
4438 return std::make_pair(0U, &Mips::MSA128WRegClass);
4439 else if (VT == MVT::v2i64 || VT == MVT::v2f64)
4440 return std::make_pair(0U, &Mips::MSA128DRegClass);
4441 else if (VT == MVT::f32)
4442 return std::make_pair(0U, &Mips::FGR32RegClass);
4443 else if ((VT == MVT::f64) && (!
Subtarget.isSingleFloat())) {
4445 return std::make_pair(0U, &Mips::FGR64RegClass);
4446 return std::make_pair(0U, &Mips::AFGR64RegClass);
4451 return std::make_pair(
ABI.getTempReg(9,
false).id(),
4452 &Mips::GPR32RegClass);
4454 return std::make_pair(
ABI.getTempReg(9,
true).id(),
4455 &Mips::GPR64RegClass);
4457 return std::make_pair(0U,
nullptr);
4460 if (VT == MVT::i32 || VT == MVT::i16 || VT == MVT::i8)
4461 return std::make_pair((
unsigned)Mips::LO0, &Mips::LO32RegClass);
4462 return std::make_pair((
unsigned)Mips::LO0_64, &Mips::LO64RegClass);
4467 return std::make_pair(0U,
nullptr);
4471 if (!Constraint.
empty()) {
4472 std::pair<unsigned, const TargetRegisterClass *>
R;
4473 R = parseRegForInlineAsmConstraint(Constraint, VT);
4484void MipsTargetLowering::LowerAsmOperandForConstraint(
SDValue Op,
4486 std::vector<SDValue> &
Ops,
4492 if (Constraint.
size() > 1)
4495 char ConstraintLetter = Constraint[0];
4496 switch (ConstraintLetter) {
4501 EVT
Type =
Op.getValueType();
4502 int64_t Val =
C->getSExtValue();
4511 EVT
Type =
Op.getValueType();
4512 int64_t Val =
C->getZExtValue();
4521 EVT
Type =
Op.getValueType();
4531 EVT
Type =
Op.getValueType();
4532 int64_t Val =
C->getSExtValue();
4533 if ((
isInt<32>(Val)) && ((Val & 0xffff) == 0)){
4541 EVT
Type =
Op.getValueType();
4542 int64_t Val =
C->getSExtValue();
4543 if ((Val >= -65535) && (Val <= -1)) {
4551 EVT
Type =
Op.getValueType();
4552 int64_t Val =
C->getSExtValue();
4561 EVT
Type =
Op.getValueType();
4562 int64_t Val =
C->getSExtValue();
4563 if ((Val <= 65535) && (Val >= 1)) {
4572 Ops.push_back(Result);
4579bool MipsTargetLowering::isLegalAddressingMode(
const DataLayout &
DL,
4607EVT MipsTargetLowering::getOptimalMemOpType(
4609 const AttributeList &FuncAttributes)
const {
4617MipsTargetLowering::getFPImmAction(
const APFloat &
Imm,
EVT VT,
4618 bool ForCodeSize)
const {
4619 if (VT != MVT::f32 && VT != MVT::f64)
4621 if (
Imm.isNegZero())
4626bool MipsTargetLowering::isLegalICmpImmediate(int64_t
Imm)
const {
4630bool MipsTargetLowering::isLegalAddImmediate(int64_t
Imm)
const {
4653void MipsTargetLowering::copyByValRegs(
4657 unsigned FirstReg,
unsigned LastReg,
const CCValAssign &VA,
4661 unsigned GPRSizeInBytes =
Subtarget.getGPRSizeInBytes();
4662 unsigned NumRegs = LastReg - FirstReg;
4663 unsigned RegAreaSize = NumRegs * GPRSizeInBytes;
4664 unsigned FrameObjSize = std::max(
Flags.getByValSize(), RegAreaSize);
4671 (int)((ByValArgRegs.
size() - FirstReg) * GPRSizeInBytes);
4693 for (
unsigned I = 0;
I < NumRegs; ++
I) {
4694 unsigned ArgReg = ByValArgRegs[FirstReg +
I];
4695 unsigned VReg =
addLiveIn(MF, ArgReg, RC);
4696 unsigned Offset =
I * GPRSizeInBytes;
4700 StorePtr, MachinePointerInfo(FuncArg,
Offset));
4701 OutChains.push_back(
Store);
4706void MipsTargetLowering::passByValArg(
4708 std::deque<std::pair<unsigned, SDValue>> &RegsToPass,
4713 unsigned ByValSizeInBytes =
Flags.getByValSize();
4714 unsigned OffsetInBytes = 0;
4715 unsigned RegSizeInBytes =
Subtarget.getGPRSizeInBytes();
4717 std::min(
Flags.getNonZeroByValAlign(),
Align(RegSizeInBytes));
4720 unsigned NumRegs = LastReg - FirstReg;
4724 bool LeftoverBytes = (NumRegs * RegSizeInBytes > ByValSizeInBytes);
4728 for (;
I < NumRegs - LeftoverBytes; ++
I, OffsetInBytes += RegSizeInBytes) {
4732 MachinePointerInfo(), Alignment);
4734 unsigned ArgReg = ArgRegs[FirstReg +
I];
4735 RegsToPass.push_back(std::make_pair(ArgReg, LoadVal));
4739 if (ByValSizeInBytes == OffsetInBytes)
4743 if (LeftoverBytes) {
4746 for (
unsigned LoadSizeInBytes = RegSizeInBytes / 2, TotalBytesLoaded = 0;
4747 OffsetInBytes < ByValSizeInBytes; LoadSizeInBytes /= 2) {
4748 unsigned RemainingSizeInBytes = ByValSizeInBytes - OffsetInBytes;
4750 if (RemainingSizeInBytes < LoadSizeInBytes)
4766 Shamt = TotalBytesLoaded * 8;
4768 Shamt = (RegSizeInBytes - (TotalBytesLoaded + LoadSizeInBytes)) * 8;
4778 OffsetInBytes += LoadSizeInBytes;
4779 TotalBytesLoaded += LoadSizeInBytes;
4783 unsigned ArgReg = ArgRegs[FirstReg +
I];
4784 RegsToPass.push_back(std::make_pair(ArgReg, Val));
4790 unsigned MemCpySize = ByValSizeInBytes - OffsetInBytes;
4796 Chain,
DL, Dst, Src, DAG.
getConstant(MemCpySize,
DL, PtrTy), Alignment,
4797 Alignment,
false,
false,
4798 nullptr, std::nullopt, MachinePointerInfo(), MachinePointerInfo());
4802void MipsTargetLowering::writeVarArgRegs(std::vector<SDValue> &OutChains,
4808 unsigned RegSizeInBytes =
Subtarget.getGPRSizeInBytes();
4813 MipsFunctionInfo *MipsFI = MF.
getInfo<MipsFunctionInfo>();
4818 if (ArgRegs.
size() == Idx)
4823 (int)(RegSizeInBytes * (ArgRegs.
size() - Idx));
4835 for (
unsigned I = Idx;
I < ArgRegs.
size();
4836 ++
I, VaArgOffset += RegSizeInBytes) {
4842 DAG.
getStore(Chain,
DL, ArgValue, PtrOff, MachinePointerInfo());
4845 OutChains.push_back(
Store);
4850 Align Alignment)
const {
4853 assert(
Size &&
"Byval argument's size shouldn't be 0.");
4857 unsigned FirstReg = 0;
4858 unsigned NumRegs = 0;
4861 unsigned RegSizeInBytes =
Subtarget.getGPRSizeInBytes();
4870 Alignment >=
Align(RegSizeInBytes) &&
4871 "Byval argument's alignment should be a multiple of RegSizeInBytes.");
4873 FirstReg = State->getFirstUnallocated(IntArgRegs);
4879 if ((Alignment > RegSizeInBytes) && (FirstReg % 2)) {
4880 State->AllocateReg(IntArgRegs[FirstReg], ShadowRegs[FirstReg]);
4886 for (
unsigned I = FirstReg;
Size > 0 && (
I < IntArgRegs.
size());
4887 Size -= RegSizeInBytes, ++
I, ++NumRegs)
4888 State->AllocateReg(IntArgRegs[
I], ShadowRegs[
I]);
4891 State->addInRegsParamInfo(FirstReg, FirstReg + NumRegs);
4897 unsigned Opc)
const {
4899 "Subtarget already supports SELECT nodes with the use of"
4900 "conditional-move instructions.");
4923 F->insert(It, copy0MBB);
4924 F->insert(It, sinkMBB);
4967 MI.eraseFromParent();
4976 "Subtarget already supports SELECT nodes with the use of"
4977 "conditional-move instructions.");
4996 MachineBasicBlock *thisMBB = BB;
4998 MachineBasicBlock *copy0MBB =
F->CreateMachineBasicBlock(LLVM_BB);
4999 MachineBasicBlock *sinkMBB =
F->CreateMachineBasicBlock(LLVM_BB);
5001 F->insert(It, sinkMBB);
5043 MI.eraseFromParent();
5052 Name.consume_front(
"$");
5055 if (Name.getAsInteger(10, RegIdx)) {
5056 std::string LowerName = Name.lower();
5068 unsigned RegClassID = Mips::GPR32RegClassID;
5073 RegClassID = Mips::GPR64RegClassID;
5075 RegClassID = Mips::GPR32RegClassID;
5082 RegClassID = Mips::GPR64RegClassID;
5087 if (!ReservedRegs.
test(Reg))
5102 const bool IsLittle =
Subtarget.isLittle();
5107 unsigned Imm =
MI.getOperand(2).getImm();
5113 Register Temp =
MRI.createVirtualRegister(&Mips::GPR32RegClass);
5122 Register LoadHalf =
MRI.createVirtualRegister(&Mips::GPR32RegClass);
5123 Register LoadFull =
MRI.createVirtualRegister(&Mips::GPR32RegClass);
5139 MI.eraseFromParent();
5148 const bool IsLittle =
Subtarget.isLittle();
5153 unsigned Imm =
MI.getOperand(2).getImm();
5223 MI.eraseFromParent();
5232 const bool IsLittle =
Subtarget.isLittle();
5235 Register StoreVal =
MI.getOperand(0).getReg();
5237 unsigned Imm =
MI.getOperand(2).getImm();
5272 MI.eraseFromParent();
5282 const bool IsLittle =
Subtarget.isLittle();
5285 Register StoreVal =
MI.getOperand(0).getReg();
5287 unsigned Imm =
MI.getOperand(2).getImm();
5364 MI.eraseFromParent();
static SDValue performSHLCombine(SDNode *N, TargetLowering::DAGCombinerInfo &DCI, SelectionDAG &DAG)
If the operand is a bitwise AND with a constant RHS, and the shift has a constant RHS and is the only...
static SDValue performORCombine(SDNode *N, TargetLowering::DAGCombinerInfo &DCI)
static SDValue performANDCombine(SDNode *N, TargetLowering::DAGCombinerInfo &DCI)
const AArch64Subtarget & Subtarget
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
This file declares a class to represent arbitrary precision floating point values and provide a varie...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Function Alias Analysis Results
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
const HexagonInstrInfo * TII
hexagon merge activate weight
Module.h This file contains the declarations for the Module class.
const AbstractManglingParser< Derived, Alloc >::OperatorInfo AbstractManglingParser< Derived, Alloc >::Ops[]
static SDValue performADDCombine(SDNode *N, SelectionDAG &DAG, TargetLowering::DAGCombinerInfo &DCI, const LoongArchSubtarget &Subtarget)
static SDValue performSUBCombine(SDNode *N, SelectionDAG &DAG, TargetLowering::DAGCombinerInfo &DCI, const LoongArchSubtarget &Subtarget)
static MachineBasicBlock * insertDivByZeroTrap(MachineInstr &MI, MachineBasicBlock *MBB)
static SDValue performSELECTCombine(SDNode *N, SelectionDAG &DAG, TargetLowering::DAGCombinerInfo &DCI, const LoongArchSubtarget &Subtarget)
Register const TargetRegisterInfo * TRI
Promote Memory to Register
static bool CC_Mips(unsigned ValNo, MVT ValVT, MVT LocVT, CCValAssign::LocInfo LocInfo, ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State)
static bool CC_MipsO32_FP64(unsigned ValNo, MVT ValVT, MVT LocVT, CCValAssign::LocInfo LocInfo, ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State)
static bool CC_MipsO32_FP32(unsigned ValNo, MVT ValVT, MVT LocVT, CCValAssign::LocInfo LocInfo, ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State)
static SDValue performMADD_MSUBCombine(SDNode *ROOTNode, SelectionDAG &CurDAG, const MipsSubtarget &Subtarget)
static bool invertFPCondCodeUser(Mips::CondCode CC)
This function returns true if the floating point conditional branches and conditional moves which use...
static bool CC_MipsO32(unsigned ValNo, MVT ValVT, MVT LocVT, CCValAssign::LocInfo LocInfo, ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State, ArrayRef< MCPhysReg > F64Regs)
static SDValue lowerFP_TO_SINT_STORE(StoreSDNode *SD, SelectionDAG &DAG, bool SingleFloat)
static SDValue performDivRemCombine(SDNode *N, SelectionDAG &DAG, TargetLowering::DAGCombinerInfo &DCI, const MipsSubtarget &Subtarget)
static const MCPhysReg Mips64DPRegs[8]
static SDValue lowerUnalignedIntStore(StoreSDNode *SD, SelectionDAG &DAG, bool IsLittle)
static SDValue createStoreLR(unsigned Opc, SelectionDAG &DAG, StoreSDNode *SD, SDValue Chain, unsigned Offset)
static unsigned addLiveIn(MachineFunction &MF, unsigned PReg, const TargetRegisterClass *RC)
static std::pair< bool, bool > parsePhysicalReg(StringRef C, StringRef &Prefix, unsigned long long &Reg)
This is a helper function to parse a physical register string and split it into non-numeric and numer...
static SDValue createLoadLR(unsigned Opc, SelectionDAG &DAG, LoadSDNode *LD, SDValue Chain, SDValue Src, unsigned Offset)
static SDValue lowerFCOPYSIGN64(SDValue Op, SelectionDAG &DAG, bool HasExtractInsert)
static SDValue createFPCmp(SelectionDAG &DAG, const SDValue &Op)
static SDValue lowerFCOPYSIGN32(SDValue Op, SelectionDAG &DAG, bool HasExtractInsert)
static SDValue performSignExtendCombine(SDNode *N, SelectionDAG &DAG, TargetLowering::DAGCombinerInfo &DCI, const MipsSubtarget &Subtarget)
static SDValue performCMovFPCombine(SDNode *N, SelectionDAG &DAG, TargetLowering::DAGCombinerInfo &DCI, const MipsSubtarget &Subtarget)
static SDValue UnpackFromArgumentSlot(SDValue Val, const CCValAssign &VA, EVT ArgVT, const SDLoc &DL, SelectionDAG &DAG)
static Mips::CondCode condCodeToFCC(ISD::CondCode CC)
static SDValue createCMovFP(SelectionDAG &DAG, SDValue Cond, SDValue True, SDValue False, const SDLoc &DL)
uint64_t IntrinsicInst * II
SmallVector< MachineOperand, 4 > Cond
MachineRegisterInfo & MRI
SI optimize exec mask operations pre RA
static bool contains(SmallPtrSetImpl< ConstantExpr * > &Cache, ConstantExpr *Expr, Constant *C)
This file defines the SmallVector class.
static const MCPhysReg IntRegs[32]
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
static TableGen::Emitter::Opt Y("gen-skeleton-entry", EmitSkeleton, "Generate example skeleton entry")
static const MCPhysReg F32Regs[64]
APInt bitcastToAPInt() const
uint64_t getZExtValue() const
Get zero extended value.
LLVM_ABI APInt extractBits(unsigned numBits, unsigned bitPosition) const
Return an APInt with the extracted bits [bitPosition,bitPosition+numBits).
This class represents an incoming formal argument to a Function.
Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
Get the array size.
LLVM Basic Block Representation.
bool test(unsigned Idx) const
Returns true if bit Idx is set.
static constexpr BranchProbability getOne()
CCState - This class holds information needed while lowering arguments and return values.
unsigned getFirstUnallocated(ArrayRef< MCPhysReg > Regs) const
getFirstUnallocated - Return the index of the first unallocated register in the set,...
CallingConv::ID getCallingConv() const
uint64_t getStackSize() const
Returns the size of the currently allocated portion of the stack.
CCValAssign - Represent assignment of one arg/retval to a location.
Register getLocReg() const
LocInfo getLocInfo() const
static CCValAssign getReg(unsigned ValNo, MVT ValVT, MCRegister Reg, MVT LocVT, LocInfo HTP, bool IsCustom=false)
static CCValAssign getCustomReg(unsigned ValNo, MVT ValVT, MCRegister Reg, MVT LocVT, LocInfo HTP)
bool isUpperBitsInLoc() const
static CCValAssign getMem(unsigned ValNo, MVT ValVT, int64_t Offset, MVT LocVT, LocInfo HTP, bool IsCustom=false)
int64_t getLocMemOffset() const
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
LLVM_ABI bool isMustTailCall() const
Tests if this call site must be tail call optimized.
const APFloat & getValueAPF() const
uint64_t getZExtValue() const
int64_t getSExtValue() const
A parsed version of the target data layout string in and methods for querying it.
LLVM_ABI TypeSize getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
const char * getSymbol() const
This is a fast-path instruction selection class that generates poor code and doesn't support illegal ...
FunctionLoweringInfo - This contains information that is global to a function that is used when lower...
bool hasStructRetAttr() const
Determine if the function returns a structure through first or second pointer argument.
const Argument * const_arg_iterator
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
const GlobalValue * getGlobal() const
bool hasLocalLinkage() const
bool hasPrivateLinkage() const
bool hasHiddenVisibility() const
bool hasDLLImportStorageClass() const
bool isDeclarationForLinker() const
LLVM_ABI const GlobalObject * getAliaseeObject() const
bool hasProtectedVisibility() const
constexpr bool isValid() const
constexpr TypeSize getSizeInBits() const
Returns the total size of the type. Must only be called on sized types.
This is an important class for using LLVM in a threaded context.
LLVM_ABI void emitError(const Instruction *I, const Twine &ErrorStr)
emitError - Emit an error message to the currently installed error handler with optional location inf...
Tracks which library functions to use for a particular subtarget or function.
This class is used to represent ISD::LOAD nodes.
const MCRegisterInfo * getRegisterInfo() const
MCRegisterClass - Base class of TargetRegisterClass.
MCRegister getRegister(unsigned i) const
getRegister - Return the specified register in the class.
iterator begin() const
begin/end - Return all of the registers in this class.
MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...
Wrapper class representing physical registers. Should be passed by value.
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
StringRef getName() const
getName - Get the symbol name.
static auto integer_valuetypes()
TypeSize getSizeInBits() const
Returns the size of the specified MVT in bits.
TypeSize getStoreSize() const
Return the number of bytes overwritten by a store of the specified value type.
static MVT getVectorVT(MVT VT, unsigned NumElements)
bool isFloatingPoint() const
Return true if this is a FP or a vector FP type.
bool isValid() const
Return true if this is a valid simple valuetype.
static MVT getIntegerVT(unsigned BitWidth)
static auto fp_valuetypes()
static auto fp_fixedlen_vector_valuetypes()
LLVM_ABI void transferSuccessorsAndUpdatePHIs(MachineBasicBlock *FromMBB)
Transfers all the successors, as in transferSuccessors, and update PHI operands in the successor bloc...
LLVM_ABI instr_iterator insert(instr_iterator I, MachineInstr *M)
Insert MI into the instruction list before I, possibly inside a bundle.
const BasicBlock * getBasicBlock() const
Return the LLVM basic block that this instance corresponded to originally.
LLVM_ABI void addSuccessor(MachineBasicBlock *Succ, BranchProbability Prob=BranchProbability::getUnknown())
Add Succ as a successor of this MachineBasicBlock.
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
void splice(iterator Where, MachineBasicBlock *Other, iterator From)
Take an instruction from MBB 'Other' at the position From, and insert it into this MBB right before '...
MachineInstrBundleIterator< MachineInstr > iterator
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
LLVM_ABI int CreateFixedObject(uint64_t Size, int64_t SPOffset, bool IsImmutable, bool isAliased=false)
Create a new object at a fixed location on the stack.
void setFrameAddressIsTaken(bool T)
void setHasTailCall(bool V=true)
void setReturnAddressIsTaken(bool s)
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
MCContext & getContext() const
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
const DataLayout & getDataLayout() const
Return the DataLayout attached to the Module associated to this MF.
Function & getFunction()
Return the LLVM function that this machine code represents.
BasicBlockListType::iterator iterator
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
Register addLiveIn(MCRegister PReg, const TargetRegisterClass *RC)
addLiveIn - Add the specified physical register as a live-in value and create a corresponding virtual...
MachineBasicBlock * CreateMachineBasicBlock(const BasicBlock *BB=nullptr, std::optional< UniqueBBID > BBID=std::nullopt)
CreateMachineInstr - Allocate a new MachineInstr.
void insert(iterator MBBI, MachineBasicBlock *MBB)
const TargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
const MachineInstrBuilder & addUse(Register RegNo, RegState Flags={}, unsigned SubReg=0) const
Add a virtual register use operand.
const MachineInstrBuilder & addReg(Register RegNo, RegState Flags={}, unsigned SubReg=0) const
Add a new virtual register operand.
const MachineInstrBuilder & addImm(int64_t Val) const
Add a new immediate operand.
const MachineInstrBuilder & addMBB(MachineBasicBlock *MBB, unsigned TargetFlags=0) const
const MachineInstrBuilder & addDef(Register RegNo, RegState Flags={}, unsigned SubReg=0) const
Add a virtual register definition operand.
Representation of each machine instruction.
const MachineOperand & getOperand(unsigned i) const
@ EK_GPRel32BlockAddress
EK_GPRel32BlockAddress - Each entry is an address of block, encoded with a relocation as gp-relative,...
@ EK_BlockAddress
EK_BlockAddress - Each entry is a plain address of block, e.g.: .word LBB123.
@ EK_GPRel64BlockAddress
EK_GPRel64BlockAddress - Each entry is an address of block, encoded with a relocation as gp-relative,...
@ MOVolatile
The memory access is volatile.
Flags getFlags() const
Return the raw flags of the source value,.
MachineOperand class - Representation of each machine instruction operand.
void setSubReg(unsigned subReg)
static MachineOperand CreateMCSymbol(MCSymbol *Sym, unsigned TargetFlags=0)
void setIsKill(bool Val=true)
Register getReg() const
getReg - Returns the register number.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
const TargetRegisterClass * getRegClass(Register Reg) const
Return the register class of the specified virtual register.
LLVM_ABI Register createVirtualRegister(const TargetRegisterClass *RegClass, StringRef Name="")
createVirtualRegister - Create and return a new virtual register in the function with the specified r...
void addLiveIn(MCRegister Reg, Register vreg=Register())
addLiveIn - Add the specified register as a live-in.
MachineMemOperand * getMemOperand() const
Return the unique MachineMemOperand object describing the memory reference performed by operation.
const MachinePointerInfo & getPointerInfo() const
const SDValue & getChain() const
EVT getMemoryVT() const
Return the type of the in-memory value.
static SpecialCallingConvType getSpecialCallingConvForCallee(const SDNode *Callee, const MipsSubtarget &Subtarget)
Determine the SpecialCallingConvType for the given callee.
MipsFunctionInfo - This class is derived from MachineFunction private Mips target-specific informatio...
void setVarArgsFrameIndex(int Index)
unsigned getSRetReturnReg() const
int getVarArgsFrameIndex() const
MachinePointerInfo callPtrInfo(MachineFunction &MF, const char *ES)
Create a MachinePointerInfo that has an ExternalSymbolPseudoSourceValue object representing a GOT ent...
Register getGlobalBaseReg(MachineFunction &MF)
void setSRetReturnReg(unsigned Reg)
void setFormalArgInfo(unsigned Size, bool HasByval)
static const uint32_t * getMips16RetHelperMask()
bool inMips16Mode() const
MVT getRegisterTypeForCallingConv(LLVMContext &Context, CallingConv::ID CC, EVT VT) const override
Return the register type for a given MVT, ensuring vectors are treated as a series of gpr sized integ...
bool hasBitTest(SDValue X, SDValue Y) const override
Return true if the target has a bit-test instruction: (X & (1 << Y)) ==/!= 0 This knowledge can be us...
static const MipsTargetLowering * create(const MipsTargetMachine &TM, const MipsSubtarget &STI)
SDValue getAddrGPRel(NodeTy *N, const SDLoc &DL, EVT Ty, SelectionDAG &DAG, bool IsN64) const
unsigned getVectorTypeBreakdownForCallingConv(LLVMContext &Context, CallingConv::ID CC, EVT VT, EVT &IntermediateVT, unsigned &NumIntermediates, MVT &RegisterVT) const override
Break down vectors to the correct number of gpr sized integers.
Register getRegisterByName(const char *RegName, LLT VT, const MachineFunction &MF) const override
Return the register ID of the name passed in.
SDValue getAddrNonPICSym64(NodeTy *N, const SDLoc &DL, EVT Ty, SelectionDAG &DAG) const
EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Context, EVT VT) const override
getSetCCResultType - get the ISD::SETCC result ValueType
SDValue getAddrGlobal(NodeTy *N, const SDLoc &DL, EVT Ty, SelectionDAG &DAG, unsigned Flag, SDValue Chain, const MachinePointerInfo &PtrInfo) const
MipsTargetLowering(const MipsTargetMachine &TM, const MipsSubtarget &STI)
SDValue getAddrGlobalLargeGOT(NodeTy *N, const SDLoc &DL, EVT Ty, SelectionDAG &DAG, unsigned HiFlag, unsigned LoFlag, SDValue Chain, const MachinePointerInfo &PtrInfo) const
SDValue getDllimportVariable(NodeTy *N, const SDLoc &DL, EVT Ty, SelectionDAG &DAG, SDValue Chain, const MachinePointerInfo &PtrInfo) const
bool shouldFoldConstantShiftPairToMask(const SDNode *N) const override
Return true if it is profitable to fold a pair of shifts into a mask.
SDValue PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const override
This method will be invoked for all target nodes and for any target-independent nodes that the target...
CCAssignFn * CCAssignFnForReturn() const
void ReplaceNodeResults(SDNode *N, SmallVectorImpl< SDValue > &Results, SelectionDAG &DAG) const override
ReplaceNodeResults - Replace the results of node with an illegal result type with new values built ou...
MachineBasicBlock * EmitInstrWithCustomInserter(MachineInstr &MI, MachineBasicBlock *MBB) const override
This method should be implemented by targets that mark instructions with the 'usesCustomInserter' fla...
SDValue getDllimportSymbol(NodeTy *N, const SDLoc &DL, EVT Ty, SelectionDAG &DAG) const
CCAssignFn * CCAssignFnForCall() const
unsigned getNumRegistersForCallingConv(LLVMContext &Context, CallingConv::ID CC, EVT VT) const override
Return the number of registers for a given MVT, ensuring vectors are treated as a series of gpr sized...
virtual void getOpndList(SmallVectorImpl< SDValue > &Ops, std::deque< std::pair< unsigned, SDValue > > &RegsToPass, bool IsPICCall, bool GlobalOrExternal, bool LocalLinkage, bool IsCallReloc, CallLoweringInfo &CLI, SDValue Callee, SDValue Chain) const
This function fills Ops, which is the list of operands that will later be used when a function call n...
SDValue getAddrNonPIC(NodeTy *N, const SDLoc &DL, EVT Ty, SelectionDAG &DAG) const
SDValue lowerSTORE(SDValue Op, SelectionDAG &DAG) const
FastISel * createFastISel(FunctionLoweringInfo &funcInfo, const TargetLibraryInfo *libInfo, const LibcallLoweringInfo *libcallLowering) const override
createFastISel - This method returns a target specific FastISel object, or null if the target does no...
void AdjustInstrPostInstrSelection(MachineInstr &MI, SDNode *Node) const override
This method should be implemented by targets that mark instructions with the 'hasPostISelHook' flag.
EVT getTypeForExtReturn(LLVMContext &Context, EVT VT, ISD::NodeType) const override
Return the type that should be used to zero or sign extend a zeroext/signext integer return value.
bool isCheapToSpeculateCtlz(Type *Ty) const override
Return true if it is cheap to speculate a call to intrinsic ctlz.
SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override
LowerOperation - Provide custom lowering hooks for some operations.
bool isCheapToSpeculateCttz(Type *Ty) const override
Return true if it is cheap to speculate a call to intrinsic cttz.
SDValue getAddrLocal(NodeTy *N, const SDLoc &DL, EVT Ty, SelectionDAG &DAG, bool IsN32OrN64) const
SDValue getGlobalReg(SelectionDAG &DAG, EVT Ty) const
const MipsSubtarget & Subtarget
void HandleByVal(CCState *, unsigned &, Align) const override
Target-specific cleanup for formal ByVal parameters.
SDValue lowerLOAD(SDValue Op, SelectionDAG &DAG) const
bool IsConstantInSmallSection(const DataLayout &DL, const Constant *CN, const Function *F) const
Return true if this constant should be placed into small data section.
Wrapper class representing virtual and physical registers.
Wrapper class for IR location info (IR ordering and DebugLoc) to be passed into SDNode creation funct...
Represents one node in the SelectionDAG.
unsigned getOpcode() const
Return the SelectionDAG opcode value for this node.
uint64_t getAsZExtVal() const
Helper method returns the zero-extended integer value of a ConstantSDNode.
const SDValue & getOperand(unsigned Num) const
EVT getValueType(unsigned ResNo) const
Return the type of a specified result.
Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation.
SDNode * getNode() const
get the SDNode which holds the desired result
bool hasOneUse() const
Return true if there is exactly one node using value ResNo of Node, in exactly one operand.
SDValue getValue(unsigned R) const
EVT getValueType() const
Return the ValueType of the referenced return value.
TypeSize getValueSizeInBits() const
Returns the size of the value in bits.
const SDValue & getOperand(unsigned i) const
ISD::CondCode getOperandCondCode(unsigned i) const
unsigned getOpcode() const
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
SDValue getTargetGlobalAddress(const GlobalValue *GV, const SDLoc &DL, EVT VT, int64_t offset=0, unsigned TargetFlags=0)
SDValue getCopyToReg(SDValue Chain, const SDLoc &dl, Register Reg, SDValue N)
LLVM_ABI SDValue getMergeValues(ArrayRef< SDValue > Ops, const SDLoc &dl)
Create a MERGE_VALUES node from the given operands.
LLVM_ABI SDVTList getVTList(EVT VT)
Return an SDVTList that represents the list of values specified.
LLVM_ABI MachineSDNode * getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT)
These are used for target selectors to create a new node with specified return type(s),...
LLVM_ABI SDValue getRegister(Register Reg, EVT VT)
SDValue getGLOBAL_OFFSET_TABLE(EVT VT)
Return a GLOBAL_OFFSET_TABLE node. This does not have a useful SDLoc.
LLVM_ABI SDValue getMemIntrinsicNode(unsigned Opcode, const SDLoc &dl, SDVTList VTList, ArrayRef< SDValue > Ops, EVT MemVT, MachinePointerInfo PtrInfo, Align Alignment, MachineMemOperand::Flags Flags=MachineMemOperand::MOLoad|MachineMemOperand::MOStore, LocationSize Size=LocationSize::precise(0), const AAMDNodes &AAInfo=AAMDNodes())
Creates a MemIntrinsicNode that may produce a result and takes a list of operands.
SDValue getSetCC(const SDLoc &DL, EVT VT, SDValue LHS, SDValue RHS, ISD::CondCode Cond, SDValue Chain=SDValue(), bool IsSignaling=false, SDNodeFlags Flags={})
Helper function to make it easier to build SetCC's if you just have an ISD::CondCode instead of an SD...
LLVM_ABI SDValue getMemcpy(SDValue Chain, const SDLoc &dl, SDValue Dst, SDValue Src, SDValue Size, Align DstAlign, Align SrcAlign, bool isVol, bool AlwaysInline, const CallInst *CI, std::optional< bool > OverrideTailCall, MachinePointerInfo DstPtrInfo, MachinePointerInfo SrcPtrInfo, const AAMDNodes &AAInfo=AAMDNodes(), BatchAAResults *BatchAA=nullptr)
SDValue getTargetJumpTable(int JTI, EVT VT, unsigned TargetFlags=0)
SDValue getUNDEF(EVT VT)
Return an UNDEF node. UNDEF does not have a useful SDLoc.
SDValue getCALLSEQ_END(SDValue Chain, SDValue Op1, SDValue Op2, SDValue InGlue, const SDLoc &DL)
Return a new CALLSEQ_END node, which always must have a glue result (to ensure it's not CSE'd).
SDValue getCopyFromReg(SDValue Chain, const SDLoc &dl, Register Reg, EVT VT)
const DataLayout & getDataLayout() const
LLVM_ABI SDValue getStore(SDValue Chain, const SDLoc &dl, SDValue Val, SDValue Ptr, MachinePointerInfo PtrInfo, Align Alignment, MachineMemOperand::Flags MMOFlags=MachineMemOperand::MONone, const MMOMetadata &Metadata=MMOMetadata())
Helper function to build ISD::STORE nodes.
LLVM_ABI SDValue getConstant(uint64_t Val, const SDLoc &DL, EVT VT, bool isTarget=false, bool isOpaque=false)
Create a ConstantSDNode wrapping a constant value.
SDValue getSignedTargetConstant(int64_t Val, const SDLoc &DL, EVT VT, bool isOpaque=false)
LLVM_ABI SDValue getExtLoad(ISD::LoadExtType ExtType, const SDLoc &dl, EVT VT, SDValue Chain, SDValue Ptr, MachinePointerInfo PtrInfo, EVT MemVT, MaybeAlign Alignment=MaybeAlign(), MachineMemOperand::Flags MMOFlags=MachineMemOperand::MONone, const MMOMetadata &Metadata=MMOMetadata())
LLVM_ABI SDValue getSignedConstant(int64_t Val, const SDLoc &DL, EVT VT, bool isTarget=false, bool isOpaque=false)
SDValue getCALLSEQ_START(SDValue Chain, uint64_t InSize, uint64_t OutSize, const SDLoc &DL)
Return a new CALLSEQ_START node, that starts new call frame, in which InSize bytes are set up inside ...
SDValue getSelectCC(const SDLoc &DL, SDValue LHS, SDValue RHS, SDValue True, SDValue False, ISD::CondCode Cond, SDNodeFlags Flags=SDNodeFlags())
Helper function to make it easier to build SelectCC's if you just have an ISD::CondCode instead of an...
LLVM_ABI SDValue getLoad(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr, MachinePointerInfo PtrInfo, MaybeAlign Alignment=MaybeAlign(), MachineMemOperand::Flags MMOFlags=MachineMemOperand::MONone, const MMOMetadata &Metadata=MMOMetadata())
Loads are not normal binary operators: their result type is not determined by their operands,...
LLVM_ABI SDValue getExternalSymbol(const char *Sym, EVT VT)
const TargetMachine & getTarget() const
LLVM_ABI SDValue getIntPtrConstant(uint64_t Val, const SDLoc &DL, bool isTarget=false)
LLVM_ABI SDValue getValueType(EVT)
LLVM_ABI SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, ArrayRef< SDUse > Ops)
Gets or creates the specified node.
LLVM_ABI bool isKnownNeverNaN(SDValue Op, const APInt &DemandedElts, bool SNaN=false, unsigned Depth=0) const
Test whether the given SDValue (or all elements of it, if it is a vector) is known to never be NaN in...
SDValue getTargetConstant(uint64_t Val, const SDLoc &DL, EVT VT, bool isOpaque=false)
LLVM_ABI unsigned ComputeNumSignBits(SDValue Op, unsigned Depth=0) const
Return the number of times the sign bit of the register is replicated into the other bits.
SDValue getTargetBlockAddress(const BlockAddress *BA, EVT VT, int64_t Offset=0, unsigned TargetFlags=0)
LLVM_ABI void ReplaceAllUsesOfValueWith(SDValue From, SDValue To)
Replace any uses of From with To, leaving uses of other values produced by From.getNode() alone.
MachineFunction & getMachineFunction() const
LLVM_ABI SDValue getFrameIndex(int FI, EVT VT, bool isTarget=false)
LLVM_ABI SDValue getRegisterMask(const uint32_t *RegMask)
void addCallSiteInfo(const SDNode *Node, CallSiteInfo &&CallInfo)
Set CallSiteInfo to be associated with Node.
LLVMContext * getContext() const
LLVM_ABI SDValue getTargetExternalSymbol(const char *Sym, EVT VT, unsigned TargetFlags=0)
SDValue getTargetConstantPool(const Constant *C, EVT VT, MaybeAlign Align=std::nullopt, int Offset=0, unsigned TargetFlags=0)
SDValue getEntryNode() const
Return the token chain corresponding to the entry of the function.
LLVM_ABI std::pair< SDValue, SDValue > SplitScalar(const SDValue &N, const SDLoc &DL, const EVT &LoVT, const EVT &HiVT)
Split the scalar node with EXTRACT_ELEMENT using the provided VTs and return the low/high part.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
This class is used to represent ISD::STORE nodes.
const SDValue & getBasePtr() const
const SDValue & getValue() const
bool isTruncatingStore() const
Return true if the op does a truncation before store.
Represent a constant reference to a string, i.e.
constexpr bool empty() const
Check if the string is empty.
const char * const_iterator
constexpr size_t size() const
Get the string size.
Information about stack frame layout on the target.
unsigned getStackAlignment() const
getStackAlignment - This method returns the number of bytes to which the stack pointer must be aligne...
Align getStackAlign() const
getStackAlignment - This method returns the number of bytes to which the stack pointer must be aligne...
TargetInstrInfo - Interface to description of machine instruction set.
Provides information about what library functions are available for the current target.
void setBooleanVectorContents(BooleanContent Ty)
Specify how the target extends the result of a vector boolean value from a vector of i1 to a wider ty...
void setOperationAction(unsigned Op, MVT VT, LegalizeAction Action)
Indicate that the specified operation does not work with the specified type and indicate what to do a...
virtual const TargetRegisterClass * getRegClassFor(MVT VT, bool isDivergent=false) const
Return the register class that should be used for the specified value type.
void setMinStackArgumentAlignment(Align Alignment)
Set the minimum stack alignment of an argument.
const TargetMachine & getTargetMachine() const
void setHasExtractBitsInsn(bool hasExtractInsn=true)
Tells the code generator that the target has BitExtract instructions.
MVT getRegisterType(LLVMContext &Context, EVT VT) const
Return the type of registers that this ValueType will eventually require.
virtual unsigned getNumRegisters(LLVMContext &Context, EVT VT, std::optional< MVT > RegisterVT=std::nullopt) const
Return the number of registers that this ValueType will eventually require.
void setMaxAtomicSizeInBitsSupported(unsigned SizeInBits)
Set the maximum atomic operation size supported by the backend.
void setMinFunctionAlignment(Align Alignment)
Set the target's minimum function alignment.
void setBooleanContents(BooleanContent Ty)
Specify how the target extends the result of integer and floating point boolean values from i1 to a w...
virtual MVT getPointerTy(const DataLayout &DL, uint32_t AS=0) const
Return the pointer type for the given address space, defaults to the pointer type from the data layou...
FPImmAction
How the legalizer should materialize a floating-point immediate.
@ ConstantPool
Load the immediate from the constant pool.
@ Legal
The target can instruction select the immediate natively.
@ Bitcast
Build the immediate as a bitcast of an integer constant with the same bits.
void setTruncStoreAction(MVT ValVT, MVT MemVT, LegalizeAction Action)
Indicate that the specified truncating store does not work with the specified type and indicate what ...
@ ZeroOrOneBooleanContent
@ ZeroOrNegativeOneBooleanContent
void setStackPointerRegisterToSaveRestore(Register R)
If set to a physical register, this specifies the register that llvm.savestack/llvm....
void AddPromotedToType(unsigned Opc, MVT OrigVT, MVT DestVT)
If Opc/OrigVT is specified as being promoted, the promotion code defaults to trying a larger integer/...
void setTargetDAGCombine(ArrayRef< ISD::NodeType > NTs)
Targets should invoke this method for each target independent node that they want to provide a custom...
virtual bool useSoftFloat() const
Align getMinStackArgumentAlignment() const
Return the minimum stack alignment of an argument.
void setLoadExtAction(unsigned ExtType, MVT ValVT, MVT MemVT, LegalizeAction Action)
Indicate that the specified load with extension does not work with the specified type and indicate wh...
std::vector< ArgListEntry > ArgListTy
unsigned MaxStoresPerMemcpy
Specify maximum number of store instructions per memcpy call.
virtual ConstraintType getConstraintType(StringRef Constraint) const
Given a constraint, return the type of constraint it is for this target.
virtual SDValue LowerToTLSEmulatedModel(const GlobalAddressSDNode *GA, SelectionDAG &DAG) const
Lower TLS global address SDNode for target independent emulated TLS model.
std::pair< SDValue, SDValue > LowerCallTo(CallLoweringInfo &CLI) const
This function lowers an abstract call to a function into an actual call.
bool isPositionIndependent() const
virtual ConstraintWeight getSingleConstraintMatchWeight(AsmOperandInfo &info, const char *constraint) const
Examine constraint string and operand type and determine a weight value.
virtual std::pair< unsigned, const TargetRegisterClass * > getRegForInlineAsmConstraint(const TargetRegisterInfo *TRI, StringRef Constraint, MVT VT) const
Given a physical register constraint (e.g.
TargetLowering(const TargetLowering &)=delete
virtual ArrayRef< MCPhysReg > getRoundingControlRegisters() const
Returns a 0 terminated array of rounding control registers that can be attached into strict FP call.
virtual void LowerAsmOperandForConstraint(SDValue Op, StringRef Constraint, std::vector< SDValue > &Ops, SelectionDAG &DAG) const
Lower the specified operand into the Ops vector.
virtual unsigned getJumpTableEncoding() const
Return the entry encoding for a jump table in the current function.
virtual void LowerOperationWrapper(SDNode *N, SmallVectorImpl< SDValue > &Results, SelectionDAG &DAG) const
This callback is invoked by the type legalizer to legalize nodes with an illegal operand type but leg...
void setTypeIdForCallsiteInfo(const CallBase *CB, MachineFunction &MF, MachineFunction::CallSiteInfo &CSInfo) const
TLSModel::Model getTLSModel(const GlobalValue *GV) const
Returns the TLS model which should be used for the given global variable.
bool useEmulatedTLS() const
Returns true if this target uses emulated TLS.
virtual TargetLoweringObjectFile * getObjFileLowering() const
MCSymbol * getSymbol(const GlobalValue *GV) const
unsigned EnableFastISel
EnableFastISel - This flag enables fast-path instruction selection which trades away generated code q...
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
The instances of the Type class are immutable: once they are created, they are never changed.
bool isVectorTy() const
True if this is an instance of VectorType.
bool isFloatTy() const
Return true if this is 'float', a 32-bit IEEE fp type.
LLVM_ABI TypeSize getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
bool isIntegerTy() const
True if this is an instance of IntegerType.
static LLVM_ABI IntegerType * getIntNTy(LLVMContext &C, unsigned N)
bool isFPOrFPVectorTy() const
Return true if this is a FP type or a vector of FP.
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
LLVM_ABI StringRef getName() const
Return a constant reference to the value's name.
constexpr ScalarTy getFixedValue() const
self_iterator getIterator()
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
constexpr std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
@ Fast
Attempts to make calls as fast as possible (e.g.
@ C
The default llvm calling convention, compatible with C.
NodeType
ISD::NodeType enum - This enum defines the target-independent operators for a SelectionDAG.
@ SETCC
SetCC operator - This evaluates to a true value iff the condition is true.
@ STACKRESTORE
STACKRESTORE has two operands, an input chain and a pointer to restore to it returns an output chain.
@ STACKSAVE
STACKSAVE - STACKSAVE has one operand, an input chain.
@ STRICT_FSETCC
STRICT_FSETCC/STRICT_FSETCCS - Constrained versions of SETCC, used for floating-point operands only.
@ BSWAP
Byte Swap and Counting operators.
@ VAEND
VAEND, VASTART - VAEND and VASTART have three operands: an input chain, pointer, and a SRCVALUE.
@ ATOMIC_STORE
OUTCHAIN = ATOMIC_STORE(INCHAIN, val, ptr) This corresponds to "store atomic" instruction.
@ ADD
Simple integer binary arithmetic operators.
@ LOAD
LOAD and STORE have token chains as their first operand, then the same operands as an LLVM load/store...
@ ANY_EXTEND
ANY_EXTEND - Used for integer types. The high bits are undefined.
@ FMA
FMA - Perform a * b + c with no intermediate rounding step.
@ FADD
Simple binary floating point operators.
@ MEMBARRIER
MEMBARRIER - Compiler barrier only; generate a no-op.
@ ATOMIC_FENCE
OUTCHAIN = ATOMIC_FENCE(INCHAIN, ordering, scope) This corresponds to the fence instruction.
@ SDIVREM
SDIVREM/UDIVREM - Divide two integers and produce both a quotient and remainder result.
@ FP16_TO_FP
FP16_TO_FP, FP_TO_FP16 - These operators are used to perform promotions and truncation for half-preci...
@ BITCAST
BITCAST - This operator converts between integer, vector and FP values, as if the value was stored to...
@ BUILD_PAIR
BUILD_PAIR - This is the opposite of EXTRACT_ELEMENT in some ways.
@ EH_RETURN
OUTCHAIN = EH_RETURN(INCHAIN, OFFSET, HANDLER) - This node represents 'eh_return' gcc dwarf builtin,...
@ SIGN_EXTEND
Conversion operators.
@ FSINCOS
FSINCOS - Compute both fsin and fcos as a single operation.
@ BR_CC
BR_CC - Conditional branch.
@ BR_JT
BR_JT - Jumptable branch.
@ FCANONICALIZE
Returns platform specific canonical encoding of a floating point number.
@ IS_FPCLASS
Performs a check of floating point class property, defined by IEEE-754.
@ SELECT
Select(COND, TRUEVAL, FALSEVAL).
@ ATOMIC_LOAD
Val, OUTCHAIN = ATOMIC_LOAD(INCHAIN, ptr) This corresponds to "load atomic" instruction.
@ VACOPY
VACOPY - VACOPY has 5 operands: an input chain, a destination pointer, a source pointer,...
@ BasicBlock
Various leaf nodes.
@ SHL
Shift and rotation operations.
@ FMINNUM_IEEE
FMINNUM_IEEE/FMAXNUM_IEEE - Same as FMINNUM/FMAXNUM, except that a signaling NaN operand deterministi...
@ ZERO_EXTEND
ZERO_EXTEND - Used for integer types, zeroing the new bits.
@ SELECT_CC
Select with condition operator - This selects between a true value and a false value (ops #2 and #3) ...
@ FMINNUM
FMINNUM/FMAXNUM - Same semantics as the llvm.minnum/maxnum intrinsics.
@ DYNAMIC_STACKALLOC
DYNAMIC_STACKALLOC - Allocate some number of bytes on the stack aligned to a specified boundary.
@ SIGN_EXTEND_INREG
SIGN_EXTEND_INREG - This operator atomically performs a SHL/SRA pair to sign extend a small value in ...
@ EH_DWARF_CFA
EH_DWARF_CFA - This node represents the pointer to the DWARF Canonical Frame Address (CFA),...
@ FRAMEADDR
FRAMEADDR, RETURNADDR - These nodes represent llvm.frameaddress and llvm.returnaddress on the DAG.
@ STRICT_FP_TO_SINT
STRICT_FP_TO_[US]INT - Convert a floating point value to a signed or unsigned integer.
@ FP_TO_SINT
FP_TO_[US]INT - Convert a floating point value to a signed or unsigned integer.
@ READCYCLECOUNTER
READCYCLECOUNTER - This corresponds to the readcyclecounter intrinsic.
@ AND
Bitwise operators - logical and, logical or, logical xor.
@ TRAP
TRAP - Trapping instruction.
@ TokenFactor
TokenFactor - This node takes multiple tokens as input and produces a single token result.
@ TRUNCATE
TRUNCATE - Completely drop the high bits.
@ VAARG
VAARG - VAARG has four operands: an input chain, a pointer, a SRCVALUE, and the alignment.
@ BRCOND
BRCOND - Conditional branch.
@ SHL_PARTS
SHL_PARTS/SRA_PARTS/SRL_PARTS - These operators are used for expanded integer shift operations.
@ AssertSext
AssertSext, AssertZext - These nodes record if a register contains a value that has already been zero...
@ FCOPYSIGN
FCOPYSIGN(X, Y) - Return the value of X with the sign of Y.
@ CALLSEQ_START
CALLSEQ_START/CALLSEQ_END - These operators mark the beginning and end of a call sequence,...
LLVM_ABI CondCode getSetCCInverse(CondCode Operation, EVT Type)
Return the operation corresponding to !(X op Y), where 'op' is a valid SetCC operation.
CondCode
ISD::CondCode enum - These are ordered carefully to make the bitfields below work out,...
LoadExtType
LoadExtType enum - This enum defines the three variants of LOADEXT (load with extension).
@ MO_TLSGD
On a symbol operand, this indicates that the immediate is the offset to the slot in GOT which stores ...
Flag
These should be considered private to the implementation of the MCInstrDesc class.
MCRegister matchRegisterName(StringRef Name, const MCRegisterInfo &MRI, unsigned RegClassID, unsigned AltIdx)
Match a symbolic name in RegClassID, or return an invalid register.
int getCPURegisterIndex(StringRef Name, const MCRegisterInfo &MRI, unsigned AltIdx, bool *IsDeprecated=nullptr)
Return a GPR name's hardware index, or -1 if unknown.
constexpr MCPhysReg FP_64
FastISel * createFastISel(FunctionLoweringInfo &funcInfo, const TargetLibraryInfo *libInfo, const LibcallLoweringInfo *libcallLowering)
constexpr MCPhysReg GP_64
constexpr MCPhysReg RA_64
constexpr MCPhysReg SP_64
Not(const Pred &P) -> Not< Pred >
@ SingleThread
Synchronized with respect to signal handlers executing in the same thread.
@ System
Synchronized with respect to all concurrently executing threads.
NodeAddr< NodeBase * > Node
NodeAddr< FuncNode * > Func
This is an optimization pass for GlobalISel generic memory operations.
@ Low
Lower the current thread's priority such that it does not affect foreground tasks significantly.
MachineInstrBuilder BuildMI(MachineFunction &MF, const MIMetadata &MIMD, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
constexpr bool isInt(int64_t x)
Checks if an integer fits into the given bit width.
LLVM_ABI bool isNullConstant(SDValue V)
Returns true if V is a constant integer zero.
@ Implicit
Not emitted register (e.g. carry, or temporary result).
@ Undef
Value of the register doesn't matter.
@ EarlyClobber
Register definition happens before uses.
@ Define
Register definition.
constexpr RegState getKillRegState(bool B)
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
bool CCAssignFn(unsigned ValNo, MVT ValVT, MVT LocVT, CCValAssign::LocInfo LocInfo, ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State)
CCAssignFn - This function assigns a location for Val, updating State to reflect the change.
@ Store
The extracted value is stored (ExtractElement only).
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Value
constexpr bool isShiftedMask_64(uint64_t Value)
Return true if the argument contains a non-empty sequence of ones with the remainder zero (64 bit ver...
auto dyn_cast_or_null(const Y &Val)
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
constexpr uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
constexpr bool isUInt(uint64_t x)
Checks if an unsigned integer fits into the given bit width.
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
constexpr T divideCeil(U Numerator, V Denominator)
Returns the integer ceil(Numerator / Denominator).
const MipsTargetLowering * createMips16TargetLowering(const MipsTargetMachine &TM, const MipsSubtarget &STI)
Create MipsTargetLowering objects.
@ Or
Bitwise or logical OR of integers.
uint16_t MCPhysReg
An unsigned integer type large enough to represent all physical registers, but not necessarily virtua...
DWARFExpression::Operation Op
ArrayRef(const T &OneElt) -> ArrayRef< T >
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
const MipsTargetLowering * createMipsSETargetLowering(const MipsTargetMachine &TM, const MipsSubtarget &STI)
LLVM_ABI bool getAsUnsignedInteger(StringRef Str, unsigned Radix, unsigned long long &Result)
Helper functions for StringRef::getAsInteger.
constexpr T maskTrailingOnes(unsigned N)
Create a bitmask with the N right-most bits set to 1, and all other bits set to 0.
MCRegisterClass TargetRegisterClass
LLVM_ABI void reportFatalUsageError(Error Err)
Report a fatal error that does not indicate a bug in LLVM.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
This struct is a compact representation of a valid (non-zero power of two) alignment.
constexpr uint64_t value() const
This is a hole in the type system and should not be abused.
EVT changeVectorElementTypeToInteger() const
Return a vector with the same number of elements as this vector, but with the element type converted ...
bool bitsLT(EVT VT) const
Return true if this has less bits than VT.
TypeSize getSizeInBits() const
Return the size of the specified value type in bits.
bool isPow2VectorType() const
Returns true if the given vector is a power of 2.
MVT getSimpleVT() const
Return the SimpleValueType held in the specified simple EVT.
static EVT getFloatingPointVT(unsigned BitWidth)
Returns the EVT that represents a floating-point type with the given number of bits.
bool isVector() const
Return true if this is a vector value type.
LLVM_ABI Type * getTypeForEVT(LLVMContext &Context) const
This method returns an LLVM type corresponding to the specified EVT.
bool isRound() const
Return true if the size is a power-of-two number of bytes.
EVT getVectorElementType() const
Given a vector type, return the type of each element.
unsigned getVectorNumElements() const
Given a vector type, return the number of elements it contains.
bool isInteger() const
Return true if this is an integer or a vector integer type.
Align getNonZeroOrigAlign() const
SmallVector< ArgRegPair, 1 > ArgRegPairs
Vector of call argument and its forwarding register.
This class contains a discriminated union of information about pointers in memory operands,...
static LLVM_ABI MachinePointerInfo getGOT(MachineFunction &MF)
Return a MachinePointerInfo record that refers to a GOT entry.
static LLVM_ABI MachinePointerInfo getFixedStack(MachineFunction &MF, int FI, int64_t Offset=0)
Return a MachinePointerInfo record that refers to the specified FrameIndex.
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
This represents a list of ValueType's that has been intern'd by a SelectionDAG.
This structure contains all information that is necessary for lowering calls.
SmallVector< ISD::InputArg, 32 > Ins
SmallVector< ISD::OutputArg, 32 > Outs
SmallVector< SDValue, 32 > OutVals
bool isBeforeLegalizeOps() const