Lines Matching defs:DAG
1 //===-- MipsISelLowering.cpp - Mips DAG Lowering Implementation -----------===//
11 // selection DAG.
73 SDValue MipsTargetLowering::getGlobalReg(SelectionDAG &DAG, EVT Ty) const {
74 MipsFunctionInfo *FI = DAG.getMachineFunction().getInfo<MipsFunctionInfo>();
75 return DAG.getRegister(FI->getGlobalBaseReg(), Ty);
78 static SDValue getTargetNode(SDValue Op, SelectionDAG &DAG, unsigned Flag) {
82 return DAG.getTargetGlobalAddress(N->getGlobal(), Op.getDebugLoc(), Ty, 0,
85 return DAG.getTargetExternalSymbol(N->getSymbol(), Ty, Flag);
87 return DAG.getTargetBlockAddress(N->getBlockAddress(), Ty, 0, Flag);
89 return DAG.getTargetJumpTable(N->getIndex(), Ty, Flag);
91 return DAG.getTargetConstantPool(N->getConstVal(), Ty, N->getAlignment(),
98 static SDValue getAddrNonPIC(SDValue Op, SelectionDAG &DAG) {
101 SDValue Hi = getTargetNode(Op, DAG, MipsII::MO_ABS_HI);
102 SDValue Lo = getTargetNode(Op, DAG, MipsII::MO_ABS_LO);
103 return DAG.getNode(ISD::ADD, DL, Ty,
104 DAG.getNode(MipsISD::Hi, DL, Ty, Hi),
105 DAG.getNode(MipsISD::Lo, DL, Ty, Lo));
108 SDValue MipsTargetLowering::getAddrLocal(SDValue Op, SelectionDAG &DAG,
113 SDValue GOT = DAG.getNode(MipsISD::Wrapper, DL, Ty, getGlobalReg(DAG, Ty),
114 getTargetNode(Op, DAG, GOTFlag));
115 SDValue Load = DAG.getLoad(Ty, DL, DAG.getEntryNode(), GOT,
119 SDValue Lo = DAG.getNode(MipsISD::Lo, DL, Ty, getTargetNode(Op, DAG, LoFlag));
120 return DAG.getNode(ISD::ADD, DL, Ty, Load, Lo);
123 SDValue MipsTargetLowering::getAddrGlobal(SDValue Op, SelectionDAG &DAG,
127 SDValue Tgt = DAG.getNode(MipsISD::Wrapper, DL, Ty, getGlobalReg(DAG, Ty),
128 getTargetNode(Op, DAG, Flag));
129 return DAG.getLoad(Ty, DL, DAG.getEntryNode(), Tgt,
133 SDValue MipsTargetLowering::getAddrGlobalLargeGOT(SDValue Op, SelectionDAG &DAG,
138 SDValue Hi = DAG.getNode(MipsISD::Hi, DL, Ty, getTargetNode(Op, DAG, HiFlag));
139 Hi = DAG.getNode(ISD::ADD, DL, Ty, Hi, getGlobalReg(DAG, Ty));
140 SDValue Wrapper = DAG.getNode(MipsISD::Wrapper, DL, Ty, Hi,
141 getTargetNode(Op, DAG, LoFlag));
142 return DAG.getLoad(Ty, DL, DAG.getEntryNode(), Wrapper,
557 static SDValue performADDECombine(SDNode *N, SelectionDAG &DAG,
564 selectMADD(N, &DAG))
570 static SDValue performSUBECombine(SDNode *N, SelectionDAG &DAG,
577 selectMSUB(N, &DAG))
583 static SDValue performDivRemCombine(SDNode *N, SelectionDAG &DAG,
596 SDValue DivRem = DAG.getNode(Opc, DL, MVT::Glue,
598 SDValue InChain = DAG.getEntryNode();
603 SDValue CopyFromLo = DAG.getCopyFromReg(InChain, DL, LO, Ty,
605 DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0), CopyFromLo);
612 SDValue CopyFromHi = DAG.getCopyFromReg(InChain, DL,
614 DAG.ReplaceAllUsesOfValueWith(SDValue(N, 1), CopyFromHi);
660 static SDValue createFPCmp(SelectionDAG &DAG, const SDValue &Op) {
677 return DAG.getNode(MipsISD::FPCmp, DL, MVT::Glue, LHS, RHS,
678 DAG.getConstant(FPCondCCodeToFCC(CC), MVT::i32));
682 static SDValue createCMovFP(SelectionDAG &DAG, SDValue Cond, SDValue True,
688 return DAG.getNode((invert ? MipsISD::CMovFP_F : MipsISD::CMovFP_T), DL,
692 static SDValue performSELECTCombine(SDNode *N, SelectionDAG &DAG,
719 SetCC = DAG.getSetCC(DL, SetCC.getValueType(), SetCC.getOperand(0),
722 return DAG.getNode(ISD::SELECT, DL, FalseTy, SetCC, False, True);
725 static SDValue performANDCombine(SDNode *N, SelectionDAG &DAG,
760 return DAG.getNode(MipsISD::Ext, N->getDebugLoc(), ValTy,
761 ShiftRight.getOperand(0), DAG.getConstant(Pos, MVT::i32),
762 DAG.getConstant(SMSize, MVT::i32));
765 static SDValue performORCombine(SDNode *N, SelectionDAG &DAG,
814 return DAG.getNode(MipsISD::Ins, N->getDebugLoc(), ValTy, Shl.getOperand(0),
815 DAG.getConstant(SMPos0, MVT::i32),
816 DAG.getConstant(SMSize0, MVT::i32), And0.getOperand(0));
819 static SDValue performADDCombine(SDNode *N, SelectionDAG &DAG,
841 SDValue Add1 = DAG.getNode(ISD::ADD, DL, ValTy, N->getOperand(0),
843 return DAG.getNode(ISD::ADD, DL, ValTy, Add1, Lo);
848 SelectionDAG &DAG = DCI.DAG;
854 return performADDECombine(N, DAG, DCI, Subtarget);
856 return performSUBECombine(N, DAG, DCI, Subtarget);
859 return performDivRemCombine(N, DAG, DCI, Subtarget);
861 return performSELECTCombine(N, DAG, DCI, Subtarget);
863 return performANDCombine(N, DAG, DCI, Subtarget);
865 return performORCombine(N, DAG, DCI, Subtarget);
867 return performADDCombine(N, DAG, DCI, Subtarget);
876 SelectionDAG &DAG) const {
877 SDValue Res = LowerOperation(SDValue(N, 0), DAG);
886 SelectionDAG &DAG) const {
887 SDValue Res = LowerOperation(SDValue(N, 0), DAG);
894 LowerOperation(SDValue Op, SelectionDAG &DAG) const
898 case ISD::BR_JT: return lowerBR_JT(Op, DAG);
899 case ISD::BRCOND: return lowerBRCOND(Op, DAG);
900 case ISD::ConstantPool: return lowerConstantPool(Op, DAG);
901 case ISD::GlobalAddress: return lowerGlobalAddress(Op, DAG);
902 case ISD::BlockAddress: return lowerBlockAddress(Op, DAG);
903 case ISD::GlobalTLSAddress: return lowerGlobalTLSAddress(Op, DAG);
904 case ISD::JumpTable: return lowerJumpTable(Op, DAG);
905 case ISD::SELECT: return lowerSELECT(Op, DAG);
906 case ISD::SELECT_CC: return lowerSELECT_CC(Op, DAG);
907 case ISD::SETCC: return lowerSETCC(Op, DAG);
908 case ISD::VASTART: return lowerVASTART(Op, DAG);
909 case ISD::FCOPYSIGN: return lowerFCOPYSIGN(Op, DAG);
910 case ISD::FABS: return lowerFABS(Op, DAG);
911 case ISD::FRAMEADDR: return lowerFRAMEADDR(Op, DAG);
912 case ISD::RETURNADDR: return lowerRETURNADDR(Op, DAG);
913 case ISD::EH_RETURN: return lowerEH_RETURN(Op, DAG);
914 case ISD::MEMBARRIER: return lowerMEMBARRIER(Op, DAG);
915 case ISD::ATOMIC_FENCE: return lowerATOMIC_FENCE(Op, DAG);
916 case ISD::SHL_PARTS: return lowerShiftLeftParts(Op, DAG);
917 case ISD::SRA_PARTS: return lowerShiftRightParts(Op, DAG, true);
918 case ISD::SRL_PARTS: return lowerShiftRightParts(Op, DAG, false);
919 case ISD::LOAD: return lowerLOAD(Op, DAG);
920 case ISD::STORE: return lowerSTORE(Op, DAG);
921 case ISD::INTRINSIC_WO_CHAIN: return lowerINTRINSIC_WO_CHAIN(Op, DAG);
922 case ISD::INTRINSIC_W_CHAIN: return lowerINTRINSIC_W_CHAIN(Op, DAG);
923 case ISD::ADD: return lowerADD(Op, DAG);
1536 SDValue MipsTargetLowering::lowerBR_JT(SDValue Op, SelectionDAG &DAG) const {
1543 DAG.getMachineFunction().getJumpTableInfo()->getEntrySize(*getDataLayout());
1545 Index = DAG.getNode(ISD::MUL, DL, PTy, Index,
1546 DAG.getConstant(EntrySize, PTy));
1547 SDValue Addr = DAG.getNode(ISD::ADD, DL, PTy, Index, Table);
1549 EVT MemVT = EVT::getIntegerVT(*DAG.getContext(), EntrySize * 8);
1550 Addr = DAG.getExtLoad(ISD::SEXTLOAD, DL, PTy, Chain, Addr,
1559 Addr = DAG.getNode(ISD::ADD, DL, PTy, Addr,
1560 getPICJumpTableRelocBase(Table, DAG));
1563 return DAG.getNode(ISD::BRIND, DL, MVT::Other, Chain, Addr);
1567 lowerBRCOND(SDValue Op, SelectionDAG &DAG) const
1575 SDValue CondRes = createFPCmp(DAG, Op.getOperand(1));
1584 SDValue BrCode = DAG.getConstant(getFPBranchCodeFromCond(CC), MVT::i32);
1586 return DAG.getNode(MipsISD::FPBrcond, DL, Op.getValueType(), Chain, BrCode,
1591 lowerSELECT(SDValue Op, SelectionDAG &DAG) const
1593 SDValue Cond = createFPCmp(DAG, Op.getOperand(0));
1599 return createCMovFP(DAG, Cond, Op.getOperand(1), Op.getOperand(2),
1604 lowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const
1608 SDValue Cond = DAG.getNode(ISD::SETCC, DL, getSetCCResultType(Ty),
1612 return DAG.getNode(ISD::SELECT, DL, Op.getValueType(), Cond, Op.getOperand(2),
1616 SDValue MipsTargetLowering::lowerSETCC(SDValue Op, SelectionDAG &DAG) const {
1617 SDValue Cond = createFPCmp(DAG, Op);
1622 SDValue True = DAG.getConstant(1, MVT::i32);
1623 SDValue False = DAG.getConstant(0, MVT::i32);
1625 return createCMovFP(DAG, Cond, True, False, Op.getDebugLoc());
1629 SelectionDAG &DAG) const {
1640 SDValue GA = DAG.getTargetGlobalAddress(GV, DL, MVT::i32, 0,
1642 SDValue GPRelNode = DAG.getNode(MipsISD::GPRel, DL,
1643 DAG.getVTList(MVT::i32), &GA, 1);
1644 SDValue GPReg = DAG.getRegister(Mips::GP, MVT::i32);
1645 return DAG.getNode(ISD::ADD, DL, MVT::i32, GPReg, GPRelNode);
1649 return getAddrNonPIC(Op, DAG);
1653 return getAddrLocal(Op, DAG, HasMips64);
1656 return getAddrGlobalLargeGOT(Op, DAG, MipsII::MO_GOT_HI16,
1659 return getAddrGlobal(Op, DAG,
1664 SelectionDAG &DAG) const {
1666 return getAddrNonPIC(Op, DAG);
1668 return getAddrLocal(Op, DAG, HasMips64);
1672 lowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const
1690 SDValue TGA = DAG.getTargetGlobalAddress(GV, DL, PtrVT, 0, Flag);
1691 SDValue Argument = DAG.getNode(MipsISD::Wrapper, DL, PtrVT,
1692 getGlobalReg(DAG, PtrVT), TGA);
1694 IntegerType *PtrTy = Type::getIntNTy(*DAG.getContext(), PtrSize);
1696 SDValue TlsGetAddr = DAG.getExternalSymbol("__tls_get_addr", PtrVT);
1704 TargetLowering::CallLoweringInfo CLI(DAG.getEntryNode(), PtrTy,
1708 TlsGetAddr, Args, DAG, DL);
1716 SDValue TGAHi = DAG.getTargetGlobalAddress(GV, DL, PtrVT, 0,
1718 SDValue Hi = DAG.getNode(MipsISD::Hi, DL, PtrVT, TGAHi);
1719 SDValue TGALo = DAG.getTargetGlobalAddress(GV, DL, PtrVT, 0,
1721 SDValue Lo = DAG.getNode(MipsISD::Lo, DL, PtrVT, TGALo);
1722 SDValue Add = DAG.getNode(ISD::ADD, DL, PtrVT, Hi, Ret);
1723 return DAG.getNode(ISD::ADD, DL, PtrVT, Add, Lo);
1729 SDValue TGA = DAG.getTargetGlobalAddress(GV, DL, PtrVT, 0,
1731 TGA = DAG.getNode(MipsISD::Wrapper, DL, PtrVT, getGlobalReg(DAG, PtrVT),
1733 Offset = DAG.getLoad(PtrVT, DL,
1734 DAG.getEntryNode(), TGA, MachinePointerInfo(),
1739 SDValue TGAHi = DAG.getTargetGlobalAddress(GV, DL, PtrVT, 0,
1741 SDValue TGALo = DAG.getTargetGlobalAddress(GV, DL, PtrVT, 0,
1743 SDValue Hi = DAG.getNode(MipsISD::Hi, DL, PtrVT, TGAHi);
1744 SDValue Lo = DAG.getNode(MipsISD::Lo, DL, PtrVT, TGALo);
1745 Offset = DAG.getNode(ISD::ADD, DL, PtrVT, Hi, Lo);
1748 SDValue ThreadPointer = DAG.getNode(MipsISD::ThreadPointer, DL, PtrVT);
1749 return DAG.getNode(ISD::ADD, DL, PtrVT, ThreadPointer, Offset);
1753 lowerJumpTable(SDValue Op, SelectionDAG &DAG) const
1756 return getAddrNonPIC(Op, DAG);
1758 return getAddrLocal(Op, DAG, HasMips64);
1762 lowerConstantPool(SDValue Op, SelectionDAG &DAG) const
1770 // SDValue GPRelNode = DAG.getNode(MipsISD::GPRel, MVT::i32, CP);
1771 // SDValue GOT = DAG.getGLOBAL_OFFSET_TABLE(MVT::i32);
1772 // ResNode = DAG.getNode(ISD::ADD, MVT::i32, GOT, GPRelNode);
1775 return getAddrNonPIC(Op, DAG);
1777 return getAddrLocal(Op, DAG, HasMips64);
1780 SDValue MipsTargetLowering::lowerVASTART(SDValue Op, SelectionDAG &DAG) const {
1781 MachineFunction &MF = DAG.getMachineFunction();
1785 SDValue FI = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
1791 return DAG.getStore(Op.getOperand(0), DL, FI, Op.getOperand(1),
1795 static SDValue lowerFCOPYSIGN32(SDValue Op, SelectionDAG &DAG, bool HasR2) {
1798 SDValue Const1 = DAG.getConstant(1, MVT::i32);
1799 SDValue Const31 = DAG.getConstant(31, MVT::i32);
1806 DAG.getNode(ISD::BITCAST, DL, MVT::i32, Op.getOperand(0)) :
1807 DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32, Op.getOperand(0),
1810 DAG.getNode(ISD::BITCAST, DL, MVT::i32, Op.getOperand(1)) :
1811 DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32, Op.getOperand(1),
1817 SDValue E = DAG.getNode(MipsISD::Ext, DL, MVT::i32, Y, Const31, Const1);
1818 Res = DAG.getNode(MipsISD::Ins, DL, MVT::i32, E, Const31, Const1, X);
1825 SDValue SllX = DAG.getNode(ISD::SHL, DL, MVT::i32, X, Const1);
1826 SDValue SrlX = DAG.getNode(ISD::SRL, DL, MVT::i32, SllX, Const1);
1827 SDValue SrlY = DAG.getNode(ISD::SRL, DL, MVT::i32, Y, Const31);
1828 SDValue SllY = DAG.getNode(ISD::SHL, DL, MVT::i32, SrlY, Const31);
1829 Res = DAG.getNode(ISD::OR, DL, MVT::i32, SrlX, SllY);
1833 return DAG.getNode(ISD::BITCAST, DL, Op.getOperand(0).getValueType(), Res);
1835 SDValue LowX = DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32,
1836 Op.getOperand(0), DAG.getConstant(0, MVT::i32));
1837 return DAG.getNode(MipsISD::BuildPairF64, DL, MVT::f64, LowX, Res);
1840 static SDValue lowerFCOPYSIGN64(SDValue Op, SelectionDAG &DAG, bool HasR2) {
1844 SDValue Const1 = DAG.getConstant(1, MVT::i32);
1848 SDValue X = DAG.getNode(ISD::BITCAST, DL, TyX, Op.getOperand(0));
1849 SDValue Y = DAG.getNode(ISD::BITCAST, DL, TyY, Op.getOperand(1));
1854 SDValue E = DAG.getNode(MipsISD::Ext, DL, TyY, Y,
1855 DAG.getConstant(WidthY - 1, MVT::i32), Const1);
1858 E = DAG.getNode(ISD::ZERO_EXTEND, DL, TyX, E);
1860 E = DAG.getNode(ISD::TRUNCATE, DL, TyX, E);
1862 SDValue I = DAG.getNode(MipsISD::Ins, DL, TyX, E,
1863 DAG.getConstant(WidthX - 1, MVT::i32), Const1, X);
1864 return DAG.getNode(ISD::BITCAST, DL, Op.getOperand(0).getValueType(), I);
1872 SDValue SllX = DAG.getNode(ISD::SHL, DL, TyX, X, Const1);
1873 SDValue SrlX = DAG.getNode(ISD::SRL, DL, TyX, SllX, Const1);
1874 SDValue SrlY = DAG.getNode(ISD::SRL, DL, TyY, Y,
1875 DAG.getConstant(WidthY - 1, MVT::i32));
1878 SrlY = DAG.getNode(ISD::ZERO_EXTEND, DL, TyX, SrlY);
1880 SrlY = DAG.getNode(ISD::TRUNCATE, DL, TyX, SrlY);
1882 SDValue SllY = DAG.getNode(ISD::SHL, DL, TyX, SrlY,
1883 DAG.getConstant(WidthX - 1, MVT::i32));
1884 SDValue Or = DAG.getNode(ISD::OR, DL, TyX, SrlX, SllY);
1885 return DAG.getNode(ISD::BITCAST, DL, Op.getOperand(0).getValueType(), Or);
1889 MipsTargetLowering::lowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) const {
1891 return lowerFCOPYSIGN64(Op, DAG, Subtarget->hasMips32r2());
1893 return lowerFCOPYSIGN32(Op, DAG, Subtarget->hasMips32r2());
1896 static SDValue lowerFABS32(SDValue Op, SelectionDAG &DAG, bool HasR2) {
1897 SDValue Res, Const1 = DAG.getConstant(1, MVT::i32);
1903 DAG.getNode(ISD::BITCAST, DL, MVT::i32, Op.getOperand(0)) :
1904 DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32, Op.getOperand(0),
1909 Res = DAG.getNode(MipsISD::Ins, DL, MVT::i32,
1910 DAG.getRegister(Mips::ZERO, MVT::i32),
1911 DAG.getConstant(31, MVT::i32), Const1, X);
1913 SDValue SllX = DAG.getNode(ISD::SHL, DL, MVT::i32, X, Const1);
1914 Res = DAG.getNode(ISD::SRL, DL, MVT::i32, SllX, Const1);
1918 return DAG.getNode(ISD::BITCAST, DL, MVT::f32, Res);
1920 SDValue LowX = DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32,
1921 Op.getOperand(0), DAG.getConstant(0, MVT::i32));
1922 return DAG.getNode(MipsISD::BuildPairF64, DL, MVT::f64, LowX, Res);
1925 static SDValue lowerFABS64(SDValue Op, SelectionDAG &DAG, bool HasR2) {
1926 SDValue Res, Const1 = DAG.getConstant(1, MVT::i32);
1930 SDValue X = DAG.getNode(ISD::BITCAST, DL, MVT::i64, Op.getOperand(0));
1934 Res = DAG.getNode(MipsISD::Ins, DL, MVT::i64,
1935 DAG.getRegister(Mips::ZERO_64, MVT::i64),
1936 DAG.getConstant(63, MVT::i32), Const1, X);
1938 SDValue SllX = DAG.getNode(ISD::SHL, DL, MVT::i64, X, Const1);
1939 Res = DAG.getNode(ISD::SRL, DL, MVT::i64, SllX, Const1);
1942 return DAG.getNode(ISD::BITCAST, DL, MVT::f64, Res);
1946 MipsTargetLowering::lowerFABS(SDValue Op, SelectionDAG &DAG) const {
1948 return lowerFABS64(Op, DAG, Subtarget->hasMips32r2());
1950 return lowerFABS32(Op, DAG, Subtarget->hasMips32r2());
1954 lowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const {
1959 MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
1963 SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), DL,
1969 SelectionDAG &DAG) const {
1974 MachineFunction &MF = DAG.getMachineFunction();
1982 return DAG.getCopyFromReg(DAG.getEntryNode(), Op.getDebugLoc(), Reg, VT);
1989 SDValue MipsTargetLowering::lowerEH_RETURN(SDValue Op, SelectionDAG &DAG)
1991 MachineFunction &MF = DAG.getMachineFunction();
2005 Chain = DAG.getCopyToReg(Chain, DL, OffsetReg, Offset, SDValue());
2006 Chain = DAG.getCopyToReg(Chain, DL, AddrReg, Handler, Chain.getValue(1));
2007 return DAG.getNode(MipsISD::EH_RETURN, DL, MVT::Other, Chain,
2008 DAG.getRegister(OffsetReg, Ty),
2009 DAG.getRegister(AddrReg, getPointerTy()),
2015 MipsTargetLowering::lowerMEMBARRIER(SDValue Op, SelectionDAG &DAG) const {
2018 return DAG.getNode(MipsISD::Sync, DL, MVT::Other, Op.getOperand(0),
2019 DAG.getConstant(SType, MVT::i32));
2023 SelectionDAG &DAG) const {
2028 return DAG.getNode(MipsISD::Sync, DL, MVT::Other, Op.getOperand(0),
2029 DAG.getConstant(SType, MVT::i32));
2033 SelectionDAG &DAG) const {
2044 SDValue Not = DAG.getNode(ISD::XOR, DL, MVT::i32, Shamt,
2045 DAG.getConstant(-1, MVT::i32));
2046 SDValue ShiftRight1Lo = DAG.getNode(ISD::SRL, DL, MVT::i32, Lo,
2047 DAG.getConstant(1, MVT::i32));
2048 SDValue ShiftRightLo = DAG.getNode(ISD::SRL, DL, MVT::i32, ShiftRight1Lo,
2050 SDValue ShiftLeftHi = DAG.getNode(ISD::SHL, DL, MVT::i32, Hi, Shamt);
2051 SDValue Or = DAG.getNode(ISD::OR, DL, MVT::i32, ShiftLeftHi, ShiftRightLo);
2052 SDValue ShiftLeftLo = DAG.getNode(ISD::SHL, DL, MVT::i32, Lo, Shamt);
2053 SDValue Cond = DAG.getNode(ISD::AND, DL, MVT::i32, Shamt,
2054 DAG.getConstant(0x20, MVT::i32));
2055 Lo = DAG.getNode(ISD::SELECT, DL, MVT::i32, Cond,
2056 DAG.getConstant(0, MVT::i32), ShiftLeftLo);
2057 Hi = DAG.getNode(ISD::SELECT, DL, MVT::i32, Cond, ShiftLeftLo, Or);
2060 return DAG.getMergeValues(Ops, 2, DL);
2063 SDValue MipsTargetLowering::lowerShiftRightParts(SDValue Op, SelectionDAG &DAG,
2082 SDValue Not = DAG.getNode(ISD::XOR, DL, MVT::i32, Shamt,
2083 DAG.getConstant(-1, MVT::i32));
2084 SDValue ShiftLeft1Hi = DAG.getNode(ISD::SHL, DL, MVT::i32, Hi,
2085 DAG.getConstant(1, MVT::i32));
2086 SDValue ShiftLeftHi = DAG.getNode(ISD::SHL, DL, MVT::i32, ShiftLeft1Hi, Not);
2087 SDValue ShiftRightLo = DAG.getNode(ISD::SRL, DL, MVT::i32, Lo, Shamt);
2088 SDValue Or = DAG.getNode(ISD::OR, DL, MVT::i32, ShiftLeftHi, ShiftRightLo);
2089 SDValue ShiftRightHi = DAG.getNode(IsSRA ? ISD::SRA : ISD::SRL, DL, MVT::i32,
2091 SDValue Cond = DAG.getNode(ISD::AND, DL, MVT::i32, Shamt,
2092 DAG.getConstant(0x20, MVT::i32));
2093 SDValue Shift31 = DAG.getNode(ISD::SRA, DL, MVT::i32, Hi,
2094 DAG.getConstant(31, MVT::i32));
2095 Lo = DAG.getNode(ISD::SELECT, DL, MVT::i32, Cond, ShiftRightHi, Or);
2096 Hi = DAG.getNode(ISD::SELECT, DL, MVT::i32, Cond,
2097 IsSRA ? Shift31 : DAG.getConstant(0, MVT::i32),
2101 return DAG.getMergeValues(Ops, 2, DL);
2104 static SDValue CreateLoadLR(unsigned Opc, SelectionDAG &DAG, LoadSDNode *LD,
2110 SDVTList VTList = DAG.getVTList(VT, MVT::Other);
2113 Ptr = DAG.getNode(ISD::ADD, DL, BasePtrVT, Ptr,
2114 DAG.getConstant(Offset, BasePtrVT));
2117 return DAG.getMemIntrinsicNode(Opc, DL, VTList, Ops, 3, MemVT,
2122 SDValue MipsTargetLowering::lowerLOAD(SDValue Op, SelectionDAG &DAG) const {
2134 SDValue Chain = LD->getChain(), Undef = DAG.getUNDEF(VT);
2144 SDValue LDL = CreateLoadLR(MipsISD::LDL, DAG, LD, Chain, Undef,
2146 return CreateLoadLR(MipsISD::LDR, DAG, LD, LDL.getValue(1), LDL,
2150 SDValue LWL = CreateLoadLR(MipsISD::LWL, DAG, LD, Chain, Undef,
2152 SDValue LWR = CreateLoadLR(MipsISD::LWR, DAG, LD, LWL.getValue(1), LWL,
2176 SDValue Const32 = DAG.getConstant(32, MVT::i32);
2177 SDValue SLL = DAG.getNode(ISD::SHL, DL, MVT::i64, LWR, Const32);
2178 SDValue SRL = DAG.getNode(ISD::SRL, DL, MVT::i64, SLL, Const32);
2180 return DAG.getMergeValues(Ops, 2, DL);
2183 static SDValue CreateStoreLR(unsigned Opc, SelectionDAG &DAG, StoreSDNode *SD,
2188 SDVTList VTList = DAG.getVTList(MVT::Other);
2191 Ptr = DAG.getNode(ISD::ADD, DL, BasePtrVT, Ptr,
2192 DAG.getConstant(Offset, BasePtrVT));
2195 return DAG.getMemIntrinsicNode(Opc, DL, VTList, Ops, 3, MemVT,
2200 SDValue MipsTargetLowering::lowerSTORE(SDValue Op, SelectionDAG &DAG) const {
2220 SDValue SWL = CreateStoreLR(MipsISD::SWL, DAG, SD, Chain,
2222 return CreateStoreLR(MipsISD::SWR, DAG, SD, SWL, IsLittle ? 0 : 3);
2232 SDValue SDL = CreateStoreLR(MipsISD::SDL, DAG, SD, Chain, IsLittle ? 7 : 0);
2233 return CreateStoreLR(MipsISD::SDR, DAG, SD, SDL, IsLittle ? 0 : 7);
2248 static SDValue lowerDSPIntr(SDValue Op, SelectionDAG &DAG,
2252 SDValue Chain = HasChainIn ? Op->getOperand(0) : DAG.getEntryNode();
2256 SDValue InLo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32,
2258 DAG.getConstant(0, MVT::i32));
2259 SDValue InHi = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32,
2261 DAG.getConstant(1, MVT::i32));
2263 Chain = DAG.getCopyToReg(Chain, DL, Mips::LO, InLo, SDValue());
2264 Chain = DAG.getCopyToReg(Chain, DL, Mips::HI, InHi, Chain.getValue(1));
2275 return DAG.getNode(Opc, DL, Op->value_begin(), Op->getNumValues(),
2278 SDValue Intr = DAG.getNode(Opc, DL, DAG.getVTList(MVT::Other, MVT::Glue),
2280 SDValue OutLo = DAG.getCopyFromReg(Intr.getValue(0), DL, Mips::LO, MVT::i32,
2282 SDValue OutHi = DAG.getCopyFromReg(OutLo.getValue(1), DL, Mips::HI, MVT::i32,
2284 SDValue Out = DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, OutLo, OutHi);
2290 return DAG.getMergeValues(Vals, 2, DL);
2294 SelectionDAG &DAG) const {
2299 return lowerDSPIntr(Op, DAG, MipsISD::SHILO, true, true);
2301 return lowerDSPIntr(Op, DAG, MipsISD::DPAU_H_QBL, true, true);
2303 return lowerDSPIntr(Op, DAG, MipsISD::DPAU_H_QBR, true, true);
2305 return lowerDSPIntr(Op, DAG, MipsISD::DPSU_H_QBL, true, true);
2307 return lowerDSPIntr(Op, DAG, MipsISD::DPSU_H_QBR, true, true);
2309 return lowerDSPIntr(Op, DAG, MipsISD::DPA_W_PH, true, true);
2311 return lowerDSPIntr(Op, DAG, MipsISD::DPS_W_PH, true, true);
2313 return lowerDSPIntr(Op, DAG, MipsISD::DPAX_W_PH, true, true);
2315 return lowerDSPIntr(Op, DAG, MipsISD::DPSX_W_PH, true, true);
2317 return lowerDSPIntr(Op, DAG, MipsISD::MULSA_W_PH, true, true);
2319 return lowerDSPIntr(Op, DAG, MipsISD::MULT, false, true);
2321 return lowerDSPIntr(Op, DAG, MipsISD::MULTU, false, true);
2323 return lowerDSPIntr(Op, DAG, MipsISD::MADD_DSP, true, true);
2325 return lowerDSPIntr(Op, DAG, MipsISD::MADDU_DSP, true, true);
2327 return lowerDSPIntr(Op, DAG, MipsISD::MSUB_DSP, true, true);
2329 return lowerDSPIntr(Op, DAG, MipsISD::MSUBU_DSP, true, true);
2334 SelectionDAG &DAG) const {
2339 return lowerDSPIntr(Op, DAG, MipsISD::EXTP, true, false);
2341 return lowerDSPIntr(Op, DAG, MipsISD::EXTPDP, true, false);
2343 return lowerDSPIntr(Op, DAG, MipsISD::EXTR_W, true, false);
2345 return lowerDSPIntr(Op, DAG, MipsISD::EXTR_R_W, true, false);
2347 return lowerDSPIntr(Op, DAG, MipsISD::EXTR_RS_W, true, false);
2349 return lowerDSPIntr(Op, DAG, MipsISD::EXTR_S_H, true, false);
2351 return lowerDSPIntr(Op, DAG, MipsISD::MTHLIP, true, true);
2353 return lowerDSPIntr(Op, DAG, MipsISD::MULSAQ_S_W_PH, true, true);
2355 return lowerDSPIntr(Op, DAG, MipsISD::MAQ_S_W_PHL, true, true);
2357 return lowerDSPIntr(Op, DAG, MipsISD::MAQ_S_W_PHR, true, true);
2359 return lowerDSPIntr(Op, DAG, MipsISD::MAQ_SA_W_PHL, true, true);
2361 return lowerDSPIntr(Op, DAG, MipsISD::MAQ_SA_W_PHR, true, true);
2363 return lowerDSPIntr(Op, DAG, MipsISD::DPAQ_S_W_PH, true, true);
2365 return lowerDSPIntr(Op, DAG, MipsISD::DPSQ_S_W_PH, true, true);
2367 return lowerDSPIntr(Op, DAG, MipsISD::DPAQ_SA_L_W, true, true);
2369 return lowerDSPIntr(Op, DAG, MipsISD::DPSQ_SA_L_W, true, true);
2371 return lowerDSPIntr(Op, DAG, MipsISD::DPAQX_S_W_PH, true, true);
2373 return lowerDSPIntr(Op, DAG, MipsISD::DPAQX_SA_W_PH, true, true);
2375 return lowerDSPIntr(Op, DAG, MipsISD::DPSQX_S_W_PH, true, true);
2377 return lowerDSPIntr(Op, DAG, MipsISD::DPSQX_SA_W_PH, true, true);
2381 SDValue MipsTargetLowering::lowerADD(SDValue Op, SelectionDAG &DAG) const {
2394 MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
2397 SDValue InArgsAddr = DAG.getFrameIndex(FI, ValTy);
2398 return DAG.getNode(ISD::ADD, Op->getDebugLoc(), ValTy, InArgsAddr,
2399 DAG.getConstant(0, ValTy));
2521 bool IsTailCall, SelectionDAG &DAG) const {
2523 SDValue PtrOff = DAG.getNode(ISD::ADD, DL, getPointerTy(), StackPtr,
2524 DAG.getIntPtrConstant(Offset));
2525 return DAG.getStore(Chain, DL, Arg, PtrOff, MachinePointerInfo(), false,
2529 MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
2531 SDValue FIN = DAG.getFrameIndex(FI, getPointerTy());
2532 return DAG.getStore(Chain, DL, Arg, FIN, MachinePointerInfo(),
2549 RegsToPass.push_back(std::make_pair(GPReg, getGlobalReg(CLI.DAG, Ty)));
2559 Chain = CLI.DAG.getCopyToReg(Chain, CLI.DL, RegsToPass[i].first,
2567 Ops.push_back(CLI.DAG.getRegister(RegsToPass[i].first,
2574 Ops.push_back(CLI.DAG.getRegisterMask(Mask));
2585 SelectionDAG &DAG = CLI.DAG;
2596 MachineFunction &MF = DAG.getMachineFunction();
2603 CCState CCInfo(CallConv, IsVarArg, DAG.getMachineFunction(),
2604 getTargetMachine(), ArgLocs, *DAG.getContext());
2628 SDValue NextStackOffsetVal = DAG.getIntPtrConstant(NextStackOffset, true);
2631 Chain = DAG.getCALLSEQ_START(Chain, NextStackOffsetVal);
2633 SDValue StackPtr = DAG.getCopyFromReg(Chain, DL,
2656 passByValArg(Chain, DL, RegsToPass, MemOpChains, StackPtr, MFI, DAG, Arg,
2670 Arg = DAG.getNode(ISD::BITCAST, DL, LocVT, Arg);
2672 SDValue Lo = DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32,
2673 Arg, DAG.getConstant(0, MVT::i32));
2674 SDValue Hi = DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32,
2675 Arg, DAG.getConstant(1, MVT::i32));
2687 Arg = DAG.getNode(ISD::SIGN_EXTEND, DL, LocVT, Arg);
2690 Arg = DAG.getNode(ISD::ZERO_EXTEND, DL, LocVT, Arg);
2693 Arg = DAG.getNode(ISD::ANY_EXTEND, DL, LocVT, Arg);
2710 Chain, Arg, DL, IsTailCall, DAG));
2716 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
2731 Callee = getAddrLocal(Callee, DAG, HasMips64);
2733 Callee = getAddrGlobalLargeGOT(Callee, DAG, MipsII::MO_CALL_HI16,
2736 Callee = getAddrGlobal(Callee, DAG, MipsII::MO_GOT_CALL);
2738 Callee = DAG.getTargetGlobalAddress(G->getGlobal(), DL, getPointerTy(), 0,
2744 Callee = DAG.getTargetExternalSymbol(S->getSymbol(), getPointerTy(),
2747 Callee = getAddrGlobalLargeGOT(Callee, DAG, MipsII::MO_CALL_HI16,
2750 Callee = getAddrGlobal(Callee, DAG, MipsII::MO_GOT_CALL);
2756 SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
2762 return DAG.getNode(MipsISD::TailCall, DL, MVT::Other, &Ops[0], Ops.size());
2764 Chain = DAG.getNode(MipsISD::JmpLink, DL, NodeTys, &Ops[0], Ops.size());
2768 Chain = DAG.getCALLSEQ_END(Chain, NextStackOffsetVal,
2769 DAG.getIntPtrConstant(0, true), InFlag);
2775 Ins, DL, DAG, InVals, CLI.Callee.getNode(), CLI.RetTy);
2784 DebugLoc DL, SelectionDAG &DAG,
2790 CCState CCInfo(CallConv, IsVarArg, DAG.getMachineFunction(),
2791 getTargetMachine(), RVLocs, *DAG.getContext());
2799 SDValue Val = DAG.getCopyFromReg(Chain, DL, RVLocs[i].getLocReg(),
2805 Val = DAG.getNode(ISD::BITCAST, DL, RVLocs[i].getValVT(), Val);
2823 DebugLoc DL, SelectionDAG &DAG,
2826 MachineFunction &MF = DAG.getMachineFunction();
2837 CCState CCInfo(CallConv, IsVarArg, DAG.getMachineFunction(),
2838 getTargetMachine(), ArgLocs, *DAG.getContext());
2841 DAG.getMachineFunction().getFunction()->arg_begin();
2863 copyByValRegs(Chain, DL, OutChains, DAG, Flags, InVals, &*FuncArg,
2889 unsigned Reg = addLiveIn(DAG.getMachineFunction(), ArgReg, RC);
2890 SDValue ArgValue = DAG.getCopyFromReg(Chain, DL, Reg, RegVT);
2902 ArgValue = DAG.getNode(Opcode, DL, RegVT, ArgValue,
2903 DAG.getValueType(ValVT));
2904 ArgValue = DAG.getNode(ISD::TRUNCATE, DL, ValVT, ArgValue);
2912 ArgValue = DAG.getNode(ISD::BITCAST, DL, ValVT, ArgValue);
2914 unsigned Reg2 = addLiveIn(DAG.getMachineFunction(),
2916 SDValue ArgValue2 = DAG.getCopyFromReg(Chain, DL, Reg2, RegVT);
2919 ArgValue = DAG.getNode(MipsISD::BuildPairF64, DL, MVT::f64,
2934 SDValue FIN = DAG.getFrameIndex(FI, getPointerTy());
2935 InVals.push_back(DAG.getLoad(ValVT, DL, Chain, FIN,
2944 if (DAG.getMachineFunction().getFunction()->hasStructRetAttr()) {
2951 SDValue Copy = DAG.getCopyToReg(DAG.getEntryNode(), DL, Reg, InVals[0]);
2952 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Copy, Chain);
2956 writeVarArgRegs(OutChains, MipsCCInfo, Chain, DL, DAG);
2962 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
2989 DebugLoc DL, SelectionDAG &DAG) const {
2993 MachineFunction &MF = DAG.getMachineFunction();
2997 *DAG.getContext());
3014 Val = DAG.getNode(ISD::BITCAST, DL, RVLocs[i].getLocVT(), Val);
3016 Chain = DAG.getCopyToReg(Chain, DL, VA.getLocReg(), Val, Flag);
3020 RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
3033 SDValue Val = DAG.getCopyFromReg(Chain, DL, Reg, getPointerTy());
3036 Chain = DAG.getCopyToReg(Chain, DL, V0, Val, Flag);
3038 RetOps.push_back(DAG.getRegister(V0, getPointerTy()));
3048 return DAG.getNode(MipsISD::Ret, DL, MVT::Other, &RetOps[0], RetOps.size());
3192 SelectionDAG &DAG) const {
3207 Result = DAG.getTargetConstant(Val, Type);
3217 Result = DAG.getTargetConstant(0, Type);
3227 Result = DAG.getTargetConstant(Val, Type);
3237 Result = DAG.getTargetConstant(Val, Type);
3247 Result = DAG.getTargetConstant(Val, Type);
3257 Result = DAG.getTargetConstant(Val, Type);
3267 Result = DAG.getTargetConstant(Val, Type);
3279 TargetLowering::LowerAsmOperandForConstraint(Op, Constraint, Ops, DAG);
3579 SelectionDAG &DAG, const ISD::ArgFlagsTy &Flags,
3582 MachineFunction &MF = DAG.getMachineFunction();
3597 SDValue FIN = DAG.getFrameIndex(FI, PtrTy);
3611 SDValue StorePtr = DAG.getNode(ISD::ADD, DL, PtrTy, FIN,
3612 DAG.getConstant(Offset, PtrTy));
3613 SDValue Store = DAG.getStore(Chain, DL, DAG.getRegister(VReg, RegTy),
3625 MachineFrameInfo *MFI, SelectionDAG &DAG, SDValue Arg,
3641 SDValue LoadPtr = DAG.getNode(ISD::ADD, DL, PtrTy, Arg,
3642 DAG.getConstant(Offset, PtrTy));
3643 SDValue LoadVal = DAG.getLoad(RegTy, DL, Chain, LoadPtr,
3669 SDValue LoadPtr = DAG.getNode(ISD::ADD, DL, PtrTy, Arg,
3670 DAG.getConstant(Offset, PtrTy));
3672 DAG.getExtLoad(ISD::ZEXTLOAD, DL, RegTy, Chain, LoadPtr,
3685 SDValue Shift = DAG.getNode(ISD::SHL, DL, RegTy, LoadVal,
3686 DAG.getConstant(Shamt, MVT::i32));
3689 Val = DAG.getNode(ISD::OR, DL, RegTy, Val, Shift);
3706 SDValue Src = DAG.getNode(ISD::ADD, DL, PtrTy, Arg,
3707 DAG.getConstant(Offset, PtrTy));
3708 SDValue Dst = DAG.getNode(ISD::ADD, DL, PtrTy, StackPtr,
3709 DAG.getIntPtrConstant(ByVal.Address));
3710 Chain = DAG.getMemcpy(Chain, DL, Dst, Src,
3711 DAG.getConstant(MemCpySize, PtrTy), Alignment,
3720 DebugLoc DL, SelectionDAG &DAG) const {
3728 MachineFunction &MF = DAG.getMachineFunction();
3752 SDValue ArgValue = DAG.getCopyFromReg(Chain, DL, Reg, RegTy);
3754 SDValue PtrOff = DAG.getFrameIndex(FI, getPointerTy());
3755 SDValue Store = DAG.getStore(Chain, DL, ArgValue, PtrOff,
