Lines Matching defs:DAG
1 //===-- MipsISelLowering.cpp - Mips DAG Lowering Implementation -----------===//
11 // selection DAG.
85 SDValue MipsTargetLowering::getGlobalReg(SelectionDAG &DAG, EVT Ty) const {
86 MipsFunctionInfo *FI = DAG.getMachineFunction().getInfo<MipsFunctionInfo>();
87 return DAG.getRegister(FI->getGlobalBaseReg(), Ty);
91 SelectionDAG &DAG,
93 return DAG.getTargetGlobalAddress(N->getGlobal(), SDLoc(N), Ty, 0, Flag);
97 SelectionDAG &DAG,
99 return DAG.getTargetExternalSymbol(N->getSymbol(), Ty, Flag);
103 SelectionDAG &DAG,
105 return DAG.getTargetBlockAddress(N->getBlockAddress(), Ty, 0, Flag);
109 SelectionDAG &DAG,
111 return DAG.getTargetJumpTable(N->getIndex(), Ty, Flag);
115 SelectionDAG &DAG,
117 return DAG.getTargetConstantPool(N->getConstVal(), Ty, N->getAlignment(),
428 static SDValue performDivRemCombine(SDNode *N, SelectionDAG &DAG,
441 SDValue DivRem = DAG.getNode(Opc, DL, MVT::Glue,
443 SDValue InChain = DAG.getEntryNode();
448 SDValue CopyFromLo = DAG.getCopyFromReg(InChain, DL, LO, Ty,
450 DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0), CopyFromLo);
457 SDValue CopyFromHi = DAG.getCopyFromReg(InChain, DL,
459 DAG.ReplaceAllUsesOfValueWith(SDValue(N, 1), CopyFromHi);
506 static SDValue createFPCmp(SelectionDAG &DAG, const SDValue &Op) {
523 return DAG.getNode(MipsISD::FPCmp, DL, MVT::Glue, LHS, RHS,
524 DAG.getConstant(condCodeToFCC(CC), MVT::i32));
528 static SDValue createCMovFP(SelectionDAG &DAG, SDValue Cond, SDValue True,
532 SDValue FCC0 = DAG.getRegister(Mips::FCC0, MVT::i32);
534 return DAG.getNode((invert ? MipsISD::CMovFP_F : MipsISD::CMovFP_T), DL,
538 static SDValue performSELECTCombine(SDNode *N, SelectionDAG &DAG,
574 SetCC = DAG.getSetCC(DL, SetCC.getValueType(), SetCC.getOperand(0),
577 return DAG.getNode(ISD::SELECT, DL, FalseTy, SetCC, False, True);
600 return DAG.getNode(ISD::ADD, DL, SetCC.getValueType(), SetCC, False);
608 SetCC = DAG.getSetCC(DL, SetCC.getValueType(), SetCC.getOperand(0),
610 return DAG.getNode(ISD::ADD, DL, SetCC.getValueType(), SetCC, True);
617 static SDValue performANDCombine(SDNode *N, SelectionDAG &DAG,
652 return DAG.getNode(MipsISD::Ext, SDLoc(N), ValTy,
653 ShiftRight.getOperand(0), DAG.getConstant(Pos, MVT::i32),
654 DAG.getConstant(SMSize, MVT::i32));
657 static SDValue performORCombine(SDNode *N, SelectionDAG &DAG,
706 return DAG.getNode(MipsISD::Ins, SDLoc(N), ValTy, Shl.getOperand(0),
707 DAG.getConstant(SMPos0, MVT::i32),
708 DAG.getConstant(SMSize0, MVT::i32), And0.getOperand(0));
711 static SDValue performADDCombine(SDNode *N, SelectionDAG &DAG,
733 SDValue Add1 = DAG.getNode(ISD::ADD, DL, ValTy, N->getOperand(0),
735 return DAG.getNode(ISD::ADD, DL, ValTy, Add1, Lo);
740 SelectionDAG &DAG = DCI.DAG;
747 return performDivRemCombine(N, DAG, DCI, Subtarget);
749 return performSELECTCombine(N, DAG, DCI, Subtarget);
751 return performANDCombine(N, DAG, DCI, Subtarget);
753 return performORCombine(N, DAG, DCI, Subtarget);
755 return performADDCombine(N, DAG, DCI, Subtarget);
764 SelectionDAG &DAG) const {
765 SDValue Res = LowerOperation(SDValue(N, 0), DAG);
774 SelectionDAG &DAG) const {
775 return LowerOperationWrapper(N, Results, DAG);
779 LowerOperation(SDValue Op, SelectionDAG &DAG) const
783 case ISD::BR_JT: return lowerBR_JT(Op, DAG);
784 case ISD::BRCOND: return lowerBRCOND(Op, DAG);
785 case ISD::ConstantPool: return lowerConstantPool(Op, DAG);
786 case ISD::GlobalAddress: return lowerGlobalAddress(Op, DAG);
787 case ISD::BlockAddress: return lowerBlockAddress(Op, DAG);
788 case ISD::GlobalTLSAddress: return lowerGlobalTLSAddress(Op, DAG);
789 case ISD::JumpTable: return lowerJumpTable(Op, DAG);
790 case ISD::SELECT: return lowerSELECT(Op, DAG);
791 case ISD::SELECT_CC: return lowerSELECT_CC(Op, DAG);
792 case ISD::SETCC: return lowerSETCC(Op, DAG);
793 case ISD::VASTART: return lowerVASTART(Op, DAG);
794 case ISD::FCOPYSIGN: return lowerFCOPYSIGN(Op, DAG);
795 case ISD::FRAMEADDR: return lowerFRAMEADDR(Op, DAG);
796 case ISD::RETURNADDR: return lowerRETURNADDR(Op, DAG);
797 case ISD::EH_RETURN: return lowerEH_RETURN(Op, DAG);
798 case ISD::ATOMIC_FENCE: return lowerATOMIC_FENCE(Op, DAG);
799 case ISD::SHL_PARTS: return lowerShiftLeftParts(Op, DAG);
800 case ISD::SRA_PARTS: return lowerShiftRightParts(Op, DAG, true);
801 case ISD::SRL_PARTS: return lowerShiftRightParts(Op, DAG, false);
802 case ISD::LOAD: return lowerLOAD(Op, DAG);
803 case ISD::STORE: return lowerSTORE(Op, DAG);
804 case ISD::ADD: return lowerADD(Op, DAG);
805 case ISD::FP_TO_SINT: return lowerFP_TO_SINT(Op, DAG);
1474 SDValue MipsTargetLowering::lowerBR_JT(SDValue Op, SelectionDAG &DAG) const {
1481 DAG.getMachineFunction().getJumpTableInfo()->getEntrySize(*getDataLayout());
1483 Index = DAG.getNode(ISD::MUL, DL, PTy, Index,
1484 DAG.getConstant(EntrySize, PTy));
1485 SDValue Addr = DAG.getNode(ISD::ADD, DL, PTy, Index, Table);
1487 EVT MemVT = EVT::getIntegerVT(*DAG.getContext(), EntrySize * 8);
1488 Addr = DAG.getExtLoad(ISD::SEXTLOAD, DL, PTy, Chain, Addr,
1498 Addr = DAG.getNode(ISD::ADD, DL, PTy, Addr,
1499 getPICJumpTableRelocBase(Table, DAG));
1502 return DAG.getNode(ISD::BRIND, DL, MVT::Other, Chain, Addr);
1505 SDValue MipsTargetLowering::lowerBRCOND(SDValue Op, SelectionDAG &DAG) const {
1513 SDValue CondRes = createFPCmp(DAG, Op.getOperand(1));
1523 SDValue BrCode = DAG.getConstant(Opc, MVT::i32);
1524 SDValue FCC0 = DAG.getRegister(Mips::FCC0, MVT::i32);
1525 return DAG.getNode(MipsISD::FPBrcond, DL, Op.getValueType(), Chain, BrCode,
1530 lowerSELECT(SDValue Op, SelectionDAG &DAG) const
1533 SDValue Cond = createFPCmp(DAG, Op.getOperand(0));
1539 return createCMovFP(DAG, Cond, Op.getOperand(1), Op.getOperand(2),
1544 lowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const
1548 SDValue Cond = DAG.getNode(ISD::SETCC, DL,
1549 getSetCCResultType(*DAG.getContext(), Ty),
1553 return DAG.getNode(ISD::SELECT, DL, Op.getValueType(), Cond, Op.getOperand(2),
1557 SDValue MipsTargetLowering::lowerSETCC(SDValue Op, SelectionDAG &DAG) const {
1559 SDValue Cond = createFPCmp(DAG, Op);
1564 SDValue True = DAG.getConstant(1, MVT::i32);
1565 SDValue False = DAG.getConstant(0, MVT::i32);
1567 return createCMovFP(DAG, Cond, True, False, SDLoc(Op));
1571 SelectionDAG &DAG) const {
1585 SDValue GA = DAG.getTargetGlobalAddress(GV, DL, MVT::i32, 0,
1587 SDValue GPRelNode = DAG.getNode(MipsISD::GPRel, DL,
1588 DAG.getVTList(MVT::i32), GA);
1589 SDValue GPReg = DAG.getRegister(Mips::GP, MVT::i32);
1590 return DAG.getNode(ISD::ADD, DL, MVT::i32, GPReg, GPRelNode);
1594 return getAddrNonPIC(N, Ty, DAG);
1598 return getAddrLocal(N, Ty, DAG,
1602 return getAddrGlobalLargeGOT(N, Ty, DAG, MipsII::MO_GOT_HI16,
1603 MipsII::MO_GOT_LO16, DAG.getEntryNode(),
1606 return getAddrGlobal(N, Ty, DAG,
1610 DAG.getEntryNode(), MachinePointerInfo::getGOT());
1614 SelectionDAG &DAG) const {
1620 return getAddrNonPIC(N, Ty, DAG);
1622 return getAddrLocal(N, Ty, DAG,
1627 lowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const
1645 SDValue TGA = DAG.getTargetGlobalAddress(GV, DL, PtrVT, 0, Flag);
1646 SDValue Argument = DAG.getNode(MipsISD::Wrapper, DL, PtrVT,
1647 getGlobalReg(DAG, PtrVT), TGA);
1649 IntegerType *PtrTy = Type::getIntNTy(*DAG.getContext(), PtrSize);
1651 SDValue TlsGetAddr = DAG.getExternalSymbol("__tls_get_addr", PtrVT);
1659 TargetLowering::CallLoweringInfo CLI(DAG);
1660 CLI.setDebugLoc(DL).setChain(DAG.getEntryNode())
1669 SDValue TGAHi = DAG.getTargetGlobalAddress(GV, DL, PtrVT, 0,
1671 SDValue Hi = DAG.getNode(MipsISD::Hi, DL, PtrVT, TGAHi);
1672 SDValue TGALo = DAG.getTargetGlobalAddress(GV, DL, PtrVT, 0,
1674 SDValue Lo = DAG.getNode(MipsISD::Lo, DL, PtrVT, TGALo);
1675 SDValue Add = DAG.getNode(ISD::ADD, DL, PtrVT, Hi, Ret);
1676 return DAG.getNode(ISD::ADD, DL, PtrVT, Add, Lo);
1682 SDValue TGA = DAG.getTargetGlobalAddress(GV, DL, PtrVT, 0,
1684 TGA = DAG.getNode(MipsISD::Wrapper, DL, PtrVT, getGlobalReg(DAG, PtrVT),
1686 Offset = DAG.getLoad(PtrVT, DL,
1687 DAG.getEntryNode(), TGA, MachinePointerInfo(),
1692 SDValue TGAHi = DAG.getTargetGlobalAddress(GV, DL, PtrVT, 0,
1694 SDValue TGALo = DAG.getTargetGlobalAddress(GV, DL, PtrVT, 0,
1696 SDValue Hi = DAG.getNode(MipsISD::Hi, DL, PtrVT, TGAHi);
1697 SDValue Lo = DAG.getNode(MipsISD::Lo, DL, PtrVT, TGALo);
1698 Offset = DAG.getNode(ISD::ADD, DL, PtrVT, Hi, Lo);
1701 SDValue ThreadPointer = DAG.getNode(MipsISD::ThreadPointer, DL, PtrVT);
1702 return DAG.getNode(ISD::ADD, DL, PtrVT, ThreadPointer, Offset);
1706 lowerJumpTable(SDValue Op, SelectionDAG &DAG) const
1713 return getAddrNonPIC(N, Ty, DAG);
1715 return getAddrLocal(N, Ty, DAG,
1720 lowerConstantPool(SDValue Op, SelectionDAG &DAG) const
1728 // SDValue GPRelNode = DAG.getNode(MipsISD::GPRel, MVT::i32, CP);
1729 // SDValue GOT = DAG.getGLOBAL_OFFSET_TABLE(MVT::i32);
1730 // ResNode = DAG.getNode(ISD::ADD, MVT::i32, GOT, GPRelNode);
1736 return getAddrNonPIC(N, Ty, DAG);
1738 return getAddrLocal(N, Ty, DAG,
1742 SDValue MipsTargetLowering::lowerVASTART(SDValue Op, SelectionDAG &DAG) const {
1743 MachineFunction &MF = DAG.getMachineFunction();
1747 SDValue FI = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
1753 return DAG.getStore(Op.getOperand(0), DL, FI, Op.getOperand(1),
1757 static SDValue lowerFCOPYSIGN32(SDValue Op, SelectionDAG &DAG,
1761 SDValue Const1 = DAG.getConstant(1, MVT::i32);
1762 SDValue Const31 = DAG.getConstant(31, MVT::i32);
1769 DAG.getNode(ISD::BITCAST, DL, MVT::i32, Op.getOperand(0)) :
1770 DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32, Op.getOperand(0),
1773 DAG.getNode(ISD::BITCAST, DL, MVT::i32, Op.getOperand(1)) :
1774 DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32, Op.getOperand(1),
1780 SDValue E = DAG.getNode(MipsISD::Ext, DL, MVT::i32, Y, Const31, Const1);
1781 Res = DAG.getNode(MipsISD::Ins, DL, MVT::i32, E, Const31, Const1, X);
1788 SDValue SllX = DAG.getNode(ISD::SHL, DL, MVT::i32, X, Const1);
1789 SDValue SrlX = DAG.getNode(ISD::SRL, DL, MVT::i32, SllX, Const1);
1790 SDValue SrlY = DAG.getNode(ISD::SRL, DL, MVT::i32, Y, Const31);
1791 SDValue SllY = DAG.getNode(ISD::SHL, DL, MVT::i32, SrlY, Const31);
1792 Res = DAG.getNode(ISD::OR, DL, MVT::i32, SrlX, SllY);
1796 return DAG.getNode(ISD::BITCAST, DL, Op.getOperand(0).getValueType(), Res);
1798 SDValue LowX = DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32,
1799 Op.getOperand(0), DAG.getConstant(0, MVT::i32));
1800 return DAG.getNode(MipsISD::BuildPairF64, DL, MVT::f64, LowX, Res);
1803 static SDValue lowerFCOPYSIGN64(SDValue Op, SelectionDAG &DAG,
1808 SDValue Const1 = DAG.getConstant(1, MVT::i32);
1812 SDValue X = DAG.getNode(ISD::BITCAST, DL, TyX, Op.getOperand(0));
1813 SDValue Y = DAG.getNode(ISD::BITCAST, DL, TyY, Op.getOperand(1));
1818 SDValue E = DAG.getNode(MipsISD::Ext, DL, TyY, Y,
1819 DAG.getConstant(WidthY - 1, MVT::i32), Const1);
1822 E = DAG.getNode(ISD::ZERO_EXTEND, DL, TyX, E);
1824 E = DAG.getNode(ISD::TRUNCATE, DL, TyX, E);
1826 SDValue I = DAG.getNode(MipsISD::Ins, DL, TyX, E,
1827 DAG.getConstant(WidthX - 1, MVT::i32), Const1, X);
1828 return DAG.getNode(ISD::BITCAST, DL, Op.getOperand(0).getValueType(), I);
1836 SDValue SllX = DAG.getNode(ISD::SHL, DL, TyX, X, Const1);
1837 SDValue SrlX = DAG.getNode(ISD::SRL, DL, TyX, SllX, Const1);
1838 SDValue SrlY = DAG.getNode(ISD::SRL, DL, TyY, Y,
1839 DAG.getConstant(WidthY - 1, MVT::i32));
1842 SrlY = DAG.getNode(ISD::ZERO_EXTEND, DL, TyX, SrlY);
1844 SrlY = DAG.getNode(ISD::TRUNCATE, DL, TyX, SrlY);
1846 SDValue SllY = DAG.getNode(ISD::SHL, DL, TyX, SrlY,
1847 DAG.getConstant(WidthX - 1, MVT::i32));
1848 SDValue Or = DAG.getNode(ISD::OR, DL, TyX, SrlX, SllY);
1849 return DAG.getNode(ISD::BITCAST, DL, Op.getOperand(0).getValueType(), Or);
1853 MipsTargetLowering::lowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) const {
1855 return lowerFCOPYSIGN64(Op, DAG, Subtarget->hasExtractInsert());
1857 return lowerFCOPYSIGN32(Op, DAG, Subtarget->hasExtractInsert());
1861 lowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const {
1866 MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
1871 DAG.getCopyFromReg(DAG.getEntryNode(), DL,
1877 SelectionDAG &DAG) const {
1878 if (verifyReturnAddressArgumentIsConstant(Op, DAG))
1885 MachineFunction &MF = DAG.getMachineFunction();
1893 return DAG.getCopyFromReg(DAG.getEntryNode(), SDLoc(Op), Reg, VT);
1900 SDValue MipsTargetLowering::lowerEH_RETURN(SDValue Op, SelectionDAG &DAG)
1902 MachineFunction &MF = DAG.getMachineFunction();
1916 Chain = DAG.getCopyToReg(Chain, DL, OffsetReg, Offset, SDValue());
1917 Chain = DAG.getCopyToReg(Chain, DL, AddrReg, Handler, Chain.getValue(1));
1918 return DAG.getNode(MipsISD::EH_RETURN, DL, MVT::Other, Chain,
1919 DAG.getRegister(OffsetReg, Ty),
1920 DAG.getRegister(AddrReg, getPointerTy()),
1925 SelectionDAG &DAG) const {
1930 return DAG.getNode(MipsISD::Sync, DL, MVT::Other, Op.getOperand(0),
1931 DAG.getConstant(SType, MVT::i32));
1935 SelectionDAG &DAG) const {
1946 SDValue Not = DAG.getNode(ISD::XOR, DL, MVT::i32, Shamt,
1947 DAG.getConstant(-1, MVT::i32));
1948 SDValue ShiftRight1Lo = DAG.getNode(ISD::SRL, DL, MVT::i32, Lo,
1949 DAG.getConstant(1, MVT::i32));
1950 SDValue ShiftRightLo = DAG.getNode(ISD::SRL, DL, MVT::i32, ShiftRight1Lo,
1952 SDValue ShiftLeftHi = DAG.getNode(ISD::SHL, DL, MVT::i32, Hi, Shamt);
1953 SDValue Or = DAG.getNode(ISD::OR, DL, MVT::i32, ShiftLeftHi, ShiftRightLo);
1954 SDValue ShiftLeftLo = DAG.getNode(ISD::SHL, DL, MVT::i32, Lo, Shamt);
1955 SDValue Cond = DAG.getNode(ISD::AND, DL, MVT::i32, Shamt,
1956 DAG.getConstant(0x20, MVT::i32));
1957 Lo = DAG.getNode(ISD::SELECT, DL, MVT::i32, Cond,
1958 DAG.getConstant(0, MVT::i32), ShiftLeftLo);
1959 Hi = DAG.getNode(ISD::SELECT, DL, MVT::i32, Cond, ShiftLeftLo, Or);
1962 return DAG.getMergeValues(Ops, DL);
1965 SDValue MipsTargetLowering::lowerShiftRightParts(SDValue Op, SelectionDAG &DAG,
1984 SDValue Not = DAG.getNode(ISD::XOR, DL, MVT::i32, Shamt,
1985 DAG.getConstant(-1, MVT::i32));
1986 SDValue ShiftLeft1Hi = DAG.getNode(ISD::SHL, DL, MVT::i32, Hi,
1987 DAG.getConstant(1, MVT::i32));
1988 SDValue ShiftLeftHi = DAG.getNode(ISD::SHL, DL, MVT::i32, ShiftLeft1Hi, Not);
1989 SDValue ShiftRightLo = DAG.getNode(ISD::SRL, DL, MVT::i32, Lo, Shamt);
1990 SDValue Or = DAG.getNode(ISD::OR, DL, MVT::i32, ShiftLeftHi, ShiftRightLo);
1991 SDValue ShiftRightHi = DAG.getNode(IsSRA ? ISD::SRA : ISD::SRL, DL, MVT::i32,
1993 SDValue Cond = DAG.getNode(ISD::AND, DL, MVT::i32, Shamt,
1994 DAG.getConstant(0x20, MVT::i32));
1995 SDValue Shift31 = DAG.getNode(ISD::SRA, DL, MVT::i32, Hi,
1996 DAG.getConstant(31, MVT::i32));
1997 Lo = DAG.getNode(ISD::SELECT, DL, MVT::i32, Cond, ShiftRightHi, Or);
1998 Hi = DAG.getNode(ISD::SELECT, DL, MVT::i32, Cond,
1999 IsSRA ? Shift31 : DAG.getConstant(0, MVT::i32),
2003 return DAG.getMergeValues(Ops, DL);
2006 static SDValue createLoadLR(unsigned Opc, SelectionDAG &DAG, LoadSDNode *LD,
2012 SDVTList VTList = DAG.getVTList(VT, MVT::Other);
2015 Ptr = DAG.getNode(ISD::ADD, DL, BasePtrVT, Ptr,
2016 DAG.getConstant(Offset, BasePtrVT));
2019 return DAG.getMemIntrinsicNode(Opc, DL, VTList, Ops, MemVT,
2024 SDValue MipsTargetLowering::lowerLOAD(SDValue Op, SelectionDAG &DAG) const {
2039 SDValue Chain = LD->getChain(), Undef = DAG.getUNDEF(VT);
2049 SDValue LDL = createLoadLR(MipsISD::LDL, DAG, LD, Chain, Undef,
2051 return createLoadLR(MipsISD::LDR, DAG, LD, LDL.getValue(1), LDL,
2055 SDValue LWL = createLoadLR(MipsISD::LWL, DAG, LD, Chain, Undef,
2057 SDValue LWR = createLoadLR(MipsISD::LWR, DAG, LD, LWL.getValue(1), LWL,
2081 SDValue Const32 = DAG.getConstant(32, MVT::i32);
2082 SDValue SLL = DAG.getNode(ISD::SHL, DL, MVT::i64, LWR, Const32);
2083 SDValue SRL = DAG.getNode(ISD::SRL, DL, MVT::i64, SLL, Const32);
2085 return DAG.getMergeValues(Ops, DL);
2088 static SDValue createStoreLR(unsigned Opc, SelectionDAG &DAG, StoreSDNode *SD,
2093 SDVTList VTList = DAG.getVTList(MVT::Other);
2096 Ptr = DAG.getNode(ISD::ADD, DL, BasePtrVT, Ptr,
2097 DAG.getConstant(Offset, BasePtrVT));
2100 return DAG.getMemIntrinsicNode(Opc, DL, VTList, Ops, MemVT,
2105 static SDValue lowerUnalignedIntStore(StoreSDNode *SD, SelectionDAG &DAG,
2117 SDValue SWL = createStoreLR(MipsISD::SWL, DAG, SD, Chain,
2119 return createStoreLR(MipsISD::SWR, DAG, SD, SWL, IsLittle ? 0 : 3);
2129 SDValue SDL = createStoreLR(MipsISD::SDL, DAG, SD, Chain, IsLittle ? 7 : 0);
2130 return createStoreLR(MipsISD::SDR, DAG, SD, SDL, IsLittle ? 0 : 7);
2134 static SDValue lowerFP_TO_SINT_STORE(StoreSDNode *SD, SelectionDAG &DAG) {
2141 SDValue Tr = DAG.getNode(MipsISD::TruncIntFP, SDLoc(Val), FPTy,
2144 return DAG.getStore(SD->getChain(), SDLoc(SD), Tr, SD->getBasePtr(),
2149 SDValue MipsTargetLowering::lowerSTORE(SDValue Op, SelectionDAG &DAG) const {
2157 return lowerUnalignedIntStore(SD, DAG, Subtarget->isLittle());
2159 return lowerFP_TO_SINT_STORE(SD, DAG);
2162 SDValue MipsTargetLowering::lowerADD(SDValue Op, SelectionDAG &DAG) const {
2175 MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
2178 SDValue InArgsAddr = DAG.getFrameIndex(FI, ValTy);
2179 return DAG.getNode(ISD::ADD, SDLoc(Op), ValTy, InArgsAddr,
2180 DAG.getConstant(0, ValTy));
2184 SelectionDAG &DAG) const {
2186 SDValue Trunc = DAG.getNode(MipsISD::TruncIntFP, SDLoc(Op), FPTy,
2188 return DAG.getNode(ISD::BITCAST, SDLoc(Op), Op.getValueType(), Trunc);
2317 bool IsTailCall, SelectionDAG &DAG) const {
2319 SDValue PtrOff = DAG.getNode(ISD::ADD, DL, getPointerTy(), StackPtr,
2320 DAG.getIntPtrConstant(Offset));
2321 return DAG.getStore(Chain, DL, Arg, PtrOff, MachinePointerInfo(), false,
2325 MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
2327 SDValue FIN = DAG.getFrameIndex(FI, getPointerTy());
2328 return DAG.getStore(Chain, DL, Arg, FIN, MachinePointerInfo(),
2345 RegsToPass.push_back(std::make_pair(GPReg, getGlobalReg(CLI.DAG, Ty)));
2355 Chain = CLI.DAG.getCopyToReg(Chain, CLI.DL, RegsToPass[i].first,
2363 Ops.push_back(CLI.DAG.getRegister(RegsToPass[i].first,
2379 Ops.push_back(CLI.DAG.getRegisterMask(Mask));
2390 SelectionDAG &DAG = CLI.DAG;
2401 MachineFunction &MF = DAG.getMachineFunction();
2409 CCState CCInfo(CallConv, IsVarArg, DAG.getMachineFunction(),
2410 getTargetMachine(), ArgLocs, *DAG.getContext());
2441 SDValue NextStackOffsetVal = DAG.getIntPtrConstant(NextStackOffset, true);
2444 Chain = DAG.getCALLSEQ_START(Chain, NextStackOffsetVal, DL);
2446 SDValue StackPtr = DAG.getCopyFromReg(
2469 passByValArg(Chain, DL, RegsToPass, MemOpChains, StackPtr, MFI, DAG, Arg,
2483 Arg = DAG.getNode(ISD::BITCAST, DL, LocVT, Arg);
2485 SDValue Lo = DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32,
2486 Arg, DAG.getConstant(0, MVT::i32));
2487 SDValue Hi = DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32,
2488 Arg, DAG.getConstant(1, MVT::i32));
2500 Arg = DAG.getNode(ISD::SIGN_EXTEND, DL, LocVT, Arg);
2503 Arg = DAG.getNode(ISD::ZERO_EXTEND, DL, LocVT, Arg);
2506 Arg = DAG.getNode(ISD::ANY_EXTEND, DL, LocVT, Arg);
2523 Chain, Arg, DL, IsTailCall, DAG));
2529 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOpChains);
2547 Callee = getAddrLocal(G, Ty, DAG,
2550 Callee = getAddrGlobalLargeGOT(G, Ty, DAG, MipsII::MO_CALL_HI16,
2554 Callee = getAddrGlobal(G, Ty, DAG, MipsII::MO_GOT_CALL, Chain,
2557 Callee = DAG.getTargetGlobalAddress(G->getGlobal(), DL, getPointerTy(), 0,
2565 Callee = DAG.getTargetExternalSymbol(Sym, getPointerTy(),
2568 Callee = getAddrGlobalLargeGOT(S, Ty, DAG, MipsII::MO_CALL_HI16,
2572 Callee = getAddrGlobal(S, Ty, DAG, MipsII::MO_GOT_CALL, Chain,
2579 SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
2585 return DAG.getNode(MipsISD::TailCall, DL, MVT::Other, Ops);
2587 Chain = DAG.getNode(MipsISD::JmpLink, DL, NodeTys, Ops);
2591 Chain = DAG.getCALLSEQ_END(Chain, NextStackOffsetVal,
2592 DAG.getIntPtrConstant(0, true), InFlag, DL);
2598 Ins, DL, DAG, InVals, CLI.Callee.getNode(), CLI.RetTy);
2607 SDLoc DL, SelectionDAG &DAG,
2613 CCState CCInfo(CallConv, IsVarArg, DAG.getMachineFunction(),
2614 getTargetMachine(), RVLocs, *DAG.getContext());
2623 SDValue Val = DAG.getCopyFromReg(Chain, DL, RVLocs[i].getLocReg(),
2629 Val = DAG.getNode(ISD::BITCAST, DL, RVLocs[i].getValVT(), Val);
2647 SDLoc DL, SelectionDAG &DAG,
2650 MachineFunction &MF = DAG.getMachineFunction();
2661 CCState CCInfo(CallConv, IsVarArg, DAG.getMachineFunction(),
2662 getTargetMachine(), ArgLocs, *DAG.getContext());
2666 DAG.getMachineFunction().getFunction()->arg_begin();
2688 copyByValRegs(Chain, DL, OutChains, DAG, Flags, InVals, &*FuncArg,
2702 unsigned Reg = addLiveIn(DAG.getMachineFunction(), ArgReg, RC);
2703 SDValue ArgValue = DAG.getCopyFromReg(Chain, DL, Reg, RegVT);
2715 ArgValue = DAG.getNode(Opcode, DL, RegVT, ArgValue,
2716 DAG.getValueType(ValVT));
2717 ArgValue = DAG.getNode(ISD::TRUNCATE, DL, ValVT, ArgValue);
2725 ArgValue = DAG.getNode(ISD::BITCAST, DL, ValVT, ArgValue);
2728 unsigned Reg2 = addLiveIn(DAG.getMachineFunction(),
2730 SDValue ArgValue2 = DAG.getCopyFromReg(Chain, DL, Reg2, RegVT);
2733 ArgValue = DAG.getNode(MipsISD::BuildPairF64, DL, MVT::f64,
2748 SDValue FIN = DAG.getFrameIndex(FI, getPointerTy());
2749 SDValue Load = DAG.getLoad(ValVT, DL, Chain, FIN,
2768 SDValue Copy = DAG.getCopyToReg(DAG.getEntryNode(), DL, Reg, InVals[i]);
2769 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Copy, Chain);
2775 writeVarArgRegs(OutChains, MipsCCInfo, Chain, DL, DAG);
2781 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, OutChains);
2807 SDLoc DL, SelectionDAG &DAG) const {
2811 MachineFunction &MF = DAG.getMachineFunction();
2815 *DAG.getContext());
2833 Val = DAG.getNode(ISD::BITCAST, DL, RVLocs[i].getLocVT(), Val);
2835 Chain = DAG.getCopyToReg(Chain, DL, VA.getLocReg(), Val, Flag);
2839 RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
2852 SDValue Val = DAG.getCopyFromReg(Chain, DL, Reg, getPointerTy());
2855 Chain = DAG.getCopyToReg(Chain, DL, V0, Val, Flag);
2857 RetOps.push_back(DAG.getRegister(V0, getPointerTy()));
2867 return DAG.getNode(MipsISD::Ret, DL, MVT::Other, RetOps);
3127 SelectionDAG &DAG) const {
3142 Result = DAG.getTargetConstant(Val, Type);
3152 Result = DAG.getTargetConstant(0, Type);
3162 Result = DAG.getTargetConstant(Val, Type);
3172 Result = DAG.getTargetConstant(Val, Type);
3182 Result = DAG.getTargetConstant(Val, Type);
3192 Result = DAG.getTargetConstant(Val, Type);
3202 Result = DAG.getTargetConstant(Val, Type);
3214 TargetLowering::LowerAsmOperandForConstraint(Op, Constraint, Ops, DAG);
3534 SelectionDAG &DAG, const ISD::ArgFlagsTy &Flags,
3537 MachineFunction &MF = DAG.getMachineFunction();
3552 SDValue FIN = DAG.getFrameIndex(FI, PtrTy);
3566 SDValue StorePtr = DAG.getNode(ISD::ADD, DL, PtrTy, FIN,
3567 DAG.getConstant(Offset, PtrTy));
3568 SDValue Store = DAG.getStore(Chain, DL, DAG.getRegister(VReg, RegTy),
3580 MachineFrameInfo *MFI, SelectionDAG &DAG, SDValue Arg,
3597 SDValue LoadPtr = DAG.getNode(ISD::ADD, DL, PtrTy, Arg,
3598 DAG.getConstant(OffsetInBytes, PtrTy));
3599 SDValue LoadVal = DAG.getLoad(RegTy, DL, Chain, LoadPtr,
3626 SDValue LoadPtr = DAG.getNode(ISD::ADD, DL, PtrTy, Arg,
3627 DAG.getConstant(OffsetInBytes, PtrTy));
3628 SDValue LoadVal = DAG.getExtLoad(
3641 SDValue Shift = DAG.getNode(ISD::SHL, DL, RegTy, LoadVal,
3642 DAG.getConstant(Shamt, MVT::i32));
3645 Val = DAG.getNode(ISD::OR, DL, RegTy, Val, Shift);
3662 SDValue Src = DAG.getNode(ISD::ADD, DL, PtrTy, Arg,
3663 DAG.getConstant(OffsetInBytes, PtrTy));
3664 SDValue Dst = DAG.getNode(ISD::ADD, DL, PtrTy, StackPtr,
3665 DAG.getIntPtrConstant(ByVal.Address));
3666 Chain = DAG.getMemcpy(Chain, DL, Dst, Src, DAG.getConstant(MemCpySize, PtrTy),
3674 SDLoc DL, SelectionDAG &DAG) const {
3682 MachineFunction &MF = DAG.getMachineFunction();
3705 SDValue ArgValue = DAG.getCopyFromReg(Chain, DL, Reg, RegTy);
3707 SDValue PtrOff = DAG.getFrameIndex(FI, getPointerTy());
3708 SDValue Store = DAG.getStore(Chain, DL, ArgValue, PtrOff,