Lines Matching refs:DAG
1 //===-- SparcISelLowering.cpp - Sparc DAG Lowering Implementation ---------===//
11 // selection DAG.
175 SDLoc DL, SelectionDAG &DAG) const {
177 return LowerReturn_64(Chain, CallConv, IsVarArg, Outs, OutVals, DL, DAG);
178 return LowerReturn_32(Chain, CallConv, IsVarArg, Outs, OutVals, DL, DAG);
186 SDLoc DL, SelectionDAG &DAG) const {
187 MachineFunction &MF = DAG.getMachineFunction();
193 CCState CCInfo(CallConv, IsVarArg, DAG.getMachineFunction(),
194 DAG.getTarget(), RVLocs, *DAG.getContext());
209 Chain = DAG.getCopyToReg(Chain, DL, VA.getLocReg(),
214 RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
224 SDValue Val = DAG.getCopyFromReg(Chain, DL, Reg, getPointerTy());
225 Chain = DAG.getCopyToReg(Chain, DL, SP::I0, Val, Flag);
227 RetOps.push_back(DAG.getRegister(SP::I0, getPointerTy()));
232 RetOps[1] = DAG.getConstant(RetAddrOffset, MVT::i32);
238 return DAG.getNode(SPISD::RET_FLAG, DL, MVT::Other,
249 SDLoc DL, SelectionDAG &DAG) const {
254 CCState CCInfo(CallConv, IsVarArg, DAG.getMachineFunction(),
255 DAG.getTarget(), RVLocs, *DAG.getContext());
265 RetOps.push_back(DAG.getConstant(8, MVT::i32));
276 OutVal = DAG.getNode(ISD::SIGN_EXTEND, DL, VA.getLocVT(), OutVal);
279 OutVal = DAG.getNode(ISD::ZERO_EXTEND, DL, VA.getLocVT(), OutVal);
282 OutVal = DAG.getNode(ISD::ANY_EXTEND, DL, VA.getLocVT(), OutVal);
290 OutVal = DAG.getNode(ISD::SHL, DL, MVT::i64, OutVal,
291 DAG.getConstant(32, MVT::i32));
296 SDValue NV = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i64, OutVals[i+1]);
297 OutVal = DAG.getNode(ISD::OR, DL, MVT::i64, OutVal, NV);
303 Chain = DAG.getCopyToReg(Chain, DL, VA.getLocReg(), OutVal, Flag);
307 RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
316 return DAG.getNode(SPISD::RET_FLAG, DL, MVT::Other,
326 SelectionDAG &DAG,
330 DL, DAG, InVals);
332 DL, DAG, InVals);
344 SelectionDAG &DAG,
346 MachineFunction &MF = DAG.getMachineFunction();
352 CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
353 getTargetMachine(), ArgLocs, *DAG.getContext());
364 SDValue FIPtr = DAG.getFrameIndex(FrameIdx, MVT::i32);
365 SDValue Arg = DAG.getLoad(MVT::i32, dl, Chain, FIPtr,
377 SDValue HiVal = DAG.getCopyFromReg(Chain, dl, VRegHi, MVT::i32);
386 SDValue FIPtr = DAG.getFrameIndex(FrameIdx, MVT::i32);
387 LoVal = DAG.getLoad(MVT::i32, dl, Chain, FIPtr,
393 LoVal = DAG.getCopyFromReg(Chain, dl, loReg, MVT::i32);
396 DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, LoVal, HiVal);
397 WholeValue = DAG.getNode(ISD::BITCAST, dl, MVT::f64, WholeValue);
403 SDValue Arg = DAG.getCopyFromReg(Chain, dl, VReg, MVT::i32);
405 Arg = DAG.getNode(ISD::BITCAST, dl, MVT::f32, Arg);
407 Arg = DAG.getNode(ISD::AssertSext, dl, MVT::i32, Arg,
408 DAG.getValueType(VA.getLocVT()));
409 Arg = DAG.getNode(ISD::TRUNCATE, dl, VA.getLocVT(), Arg);
426 SDValue FIPtr = DAG.getFrameIndex(FI, getPointerTy());
427 SDValue Load = DAG.getLoad(VA.getValVT(), dl, Chain, FIPtr,
437 SDValue FIPtr = DAG.getFrameIndex(FI, getPointerTy());
438 SDValue HiVal = DAG.getLoad(MVT::i32, dl, Chain, FIPtr,
444 SDValue FIPtr2 = DAG.getFrameIndex(FI2, getPointerTy());
446 SDValue LoVal = DAG.getLoad(MVT::i32, dl, Chain, FIPtr2,
451 DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, LoVal, HiVal);
452 WholeValue = DAG.getNode(ISD::BITCAST, dl, MVT::f64, WholeValue);
460 SDValue FIPtr = DAG.getFrameIndex(FI, getPointerTy());
463 Load = DAG.getLoad(VA.getValVT(), dl, Chain, FIPtr,
470 FIPtr = DAG.getNode(ISD::ADD, dl, MVT::i32, FIPtr,
471 DAG.getConstant(Offset, MVT::i32));
472 Load = DAG.getExtLoad(LoadOp, dl, MVT::i32, Chain, FIPtr,
475 Load = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), Load);
488 SDValue Copy = DAG.getCopyToReg(DAG.getEntryNode(), dl, Reg, InVals[0]);
489 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Copy, Chain);
515 SDValue Arg = DAG.getCopyFromReg(DAG.getRoot(), dl, VReg, MVT::i32);
519 SDValue FIPtr = DAG.getFrameIndex(FrameIdx, MVT::i32);
521 OutChains.push_back(DAG.getStore(DAG.getRoot(), dl, Arg, FIPtr,
529 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
544 SelectionDAG &DAG,
546 MachineFunction &MF = DAG.getMachineFunction();
550 CCState CCInfo(CallConv, IsVarArg, DAG.getMachineFunction(),
551 getTargetMachine(), ArgLocs, *DAG.getContext());
566 SDValue Arg = DAG.getCopyFromReg(Chain, DL, VReg, VA.getLocVT());
570 Arg = DAG.getNode(ISD::SRL, DL, VA.getLocVT(), Arg,
571 DAG.getConstant(32, MVT::i32));
577 Arg = DAG.getNode(ISD::AssertSext, DL, VA.getLocVT(), Arg,
578 DAG.getValueType(VA.getValVT()));
581 Arg = DAG.getNode(ISD::AssertZext, DL, VA.getLocVT(), Arg,
582 DAG.getValueType(VA.getValVT()));
590 Arg = DAG.getNode(ISD::TRUNCATE, DL, VA.getValVT(), Arg);
608 InVals.push_back(DAG.getLoad(VA.getValVT(), DL, Chain,
609 DAG.getFrameIndex(FI, getPointerTy()),
636 SDValue VArg = DAG.getCopyFromReg(Chain, DL, VReg, MVT::i64);
638 OutChains.push_back(DAG.getStore(Chain, DL, VArg,
639 DAG.getFrameIndex(FI, getPointerTy()),
645 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
659 static bool hasReturnsTwiceAttr(SelectionDAG &DAG, SDValue Callee,
669 const Function *Fn = DAG.getMachineFunction().getFunction();
684 SelectionDAG &DAG = CLI.DAG;
700 CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
701 DAG.getTarget(), ArgLocs, *DAG.getContext());
710 MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
724 SDValue FIPtr = DAG.getFrameIndex(FI, getPointerTy());
725 SDValue SizeNode = DAG.getConstant(Size, MVT::i32);
727 Chain = DAG.getMemcpy(Chain, dl, FIPtr, Arg, SizeNode, Align,
734 Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(ArgsSize, true),
760 Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Arg);
763 Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Arg);
766 Arg = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), Arg);
769 Arg = DAG.getNode(ISD::BITCAST, dl, VA.getLocVT(), Arg);
776 SDValue StackPtr = DAG.getRegister(SP::O6, MVT::i32);
777 SDValue PtrOff = DAG.getIntPtrConstant(64);
778 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
779 MemOpChains.push_back(DAG.getStore(Chain, dl, Arg, PtrOff,
793 SDValue StackPtr = DAG.getRegister(SP::O6, MVT::i32);
794 SDValue PtrOff = DAG.getIntPtrConstant(Offset);
795 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
796 MemOpChains.push_back(DAG.getStore(Chain, dl, Arg, PtrOff,
803 SDValue StackPtr = DAG.CreateStackTemporary(MVT::f64, MVT::i32);
804 SDValue Store = DAG.getStore(DAG.getEntryNode(), dl,
808 SDValue Hi = DAG.getLoad(MVT::i32, dl, Store, StackPtr,
811 StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr,
812 DAG.getIntPtrConstant(4));
814 SDValue Lo = DAG.getLoad(MVT::i32, dl, Store, StackPtr,
826 SDValue StackPtr = DAG.getRegister(SP::O6, MVT::i32);
827 SDValue PtrOff = DAG.getIntPtrConstant(Offset);
828 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
829 MemOpChains.push_back(DAG.getStore(Chain, dl, Lo, PtrOff,
836 SDValue StackPtr = DAG.getRegister(SP::O6, MVT::i32);
837 SDValue PtrOff = DAG.getIntPtrConstant(Offset);
838 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
839 MemOpChains.push_back(DAG.getStore(Chain, dl, Hi, PtrOff,
843 PtrOff = DAG.getIntPtrConstant(Offset+4);
844 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
845 MemOpChains.push_back(DAG.getStore(Chain, dl, Lo, PtrOff,
859 Arg = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Arg);
867 SDValue StackPtr = DAG.getRegister(SP::O6, MVT::i32);
868 SDValue PtrOff = DAG.getIntPtrConstant(VA.getLocMemOffset()+StackOffset);
869 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
870 MemOpChains.push_back(DAG.getStore(Chain, dl, Arg, PtrOff,
878 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
888 Chain = DAG.getCopyToReg(Chain, dl, Reg, RegsToPass[i].second, InFlag);
892 unsigned SRetArgSize = (hasStructRetAttr)? getSRetArgSize(DAG, Callee):0;
893 bool hasReturnsTwice = hasReturnsTwiceAttr(DAG, Callee, CLI.CS);
901 Callee = DAG.getTargetGlobalAddress(G->getGlobal(), dl, MVT::i32, 0, TF);
903 Callee = DAG.getTargetExternalSymbol(E->getSymbol(), MVT::i32, TF);
906 SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
911 Ops.push_back(DAG.getTargetConstant(SRetArgSize, MVT::i32));
913 Ops.push_back(DAG.getRegister(toCallerWindow(RegsToPass[i].first),
923 Ops.push_back(DAG.getRegisterMask(Mask));
928 Chain = DAG.getNode(SPISD::CALL, dl, NodeTys, &Ops[0], Ops.size());
931 Chain = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(ArgsSize, true),
932 DAG.getIntPtrConstant(0, true), InFlag, dl);
937 CCState RVInfo(CallConv, isVarArg, DAG.getMachineFunction(),
938 DAG.getTarget(), RVLocs, *DAG.getContext());
944 Chain = DAG.getCopyFromReg(Chain, dl, toCallerWindow(RVLocs[i].getLocReg()),
971 SparcTargetLowering::getSRetArgSize(SelectionDAG &DAG, SDValue Callee) const
978 const Function *Fn = DAG.getMachineFunction().getFunction();
1055 SelectionDAG &DAG = CLI.DAG;
1064 CCState CCInfo(CLI.CallConv, CLI.IsVarArg, DAG.getMachineFunction(),
1065 DAG.getTarget(), ArgLocs, *DAG.getContext());
1084 Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(ArgsSize, true),
1108 Arg = DAG.getNode(ISD::SIGN_EXTEND, DL, VA.getLocVT(), Arg);
1111 Arg = DAG.getNode(ISD::ZERO_EXTEND, DL, VA.getLocVT(), Arg);
1114 Arg = DAG.getNode(ISD::ANY_EXTEND, DL, VA.getLocVT(), Arg);
1121 Arg = DAG.getNode(ISD::BITCAST, DL, VA.getLocVT(), Arg);
1131 SDValue StackPtr = DAG.getRegister(SP::O6, getPointerTy());
1132 SDValue HiPtrOff = DAG.getIntPtrConstant(StackOffset);
1133 HiPtrOff = DAG.getNode(ISD::ADD, DL, getPointerTy(), StackPtr,
1135 SDValue LoPtrOff = DAG.getIntPtrConstant(StackOffset + 8);
1136 LoPtrOff = DAG.getNode(ISD::ADD, DL, getPointerTy(), StackPtr,
1140 SDValue Store = DAG.getStore(Chain, DL, Arg, HiPtrOff,
1144 SDValue Hi64 = DAG.getLoad(MVT::i64, DL, Store, HiPtrOff,
1147 SDValue Lo64 = DAG.getLoad(MVT::i64, DL, Store, LoPtrOff,
1160 Arg = DAG.getNode(ISD::SHL, DL, MVT::i64, Arg,
1161 DAG.getConstant(32, MVT::i32));
1167 SDValue NV = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i64,
1169 Arg = DAG.getNode(ISD::OR, DL, MVT::i64, Arg, NV);
1181 SDValue StackPtr = DAG.getRegister(SP::O6, getPointerTy());
1184 SDValue PtrOff = DAG.getIntPtrConstant(VA.getLocMemOffset() +
1187 PtrOff = DAG.getNode(ISD::ADD, DL, getPointerTy(), StackPtr, PtrOff);
1188 MemOpChains.push_back(DAG.getStore(Chain, DL, Arg, PtrOff,
1195 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
1204 Chain = DAG.getCopyToReg(Chain, DL,
1213 bool hasReturnsTwice = hasReturnsTwiceAttr(DAG, Callee, CLI.CS);
1217 Callee = DAG.getTargetGlobalAddress(G->getGlobal(), DL, getPointerTy(), 0,
1220 Callee = DAG.getTargetExternalSymbol(E->getSymbol(), getPointerTy(), TF);
1227 Ops.push_back(DAG.getRegister(RegsToPass[i].first,
1237 Ops.push_back(DAG.getRegisterMask(Mask));
1245 SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
1246 Chain = DAG.getNode(SPISD::CALL, DL, NodeTys, &Ops[0], Ops.size());
1250 Chain = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(ArgsSize, true),
1251 DAG.getIntPtrConstant(0, true), InGlue, DL);
1259 CCState RVInfo(CLI.CallConv, CLI.IsVarArg, DAG.getMachineFunction(),
1260 DAG.getTarget(), RVLocs, *DAG.getContext());
1284 RV = DAG.getCopyFromReg(Chain, DL, Reg, RVLocs[i].getLocVT(), InGlue);
1291 RV = DAG.getNode(ISD::SRL, DL, VA.getLocVT(), RV,
1292 DAG.getConstant(32, MVT::i32));
1298 RV = DAG.getNode(ISD::AssertSext, DL, VA.getLocVT(), RV,
1299 DAG.getValueType(VA.getValVT()));
1302 RV = DAG.getNode(ISD::AssertZext, DL, VA.getLocVT(), RV,
1303 DAG.getValueType(VA.getValVT()));
1311 RV = DAG.getNode(ISD::TRUNCATE, DL, VA.getValVT(), RV);
1323 /// IntCondCCodeToICC - Convert a DAG integer condition code to a SPARC ICC
1341 /// FPCondCCodeToFCC - Convert a DAG floatingp oint condition code to a SPARC
1710 /// be zero. Op is expected to be a target specific node. Used by DAG
1716 const SelectionDAG &DAG,
1726 DAG.ComputeMaskedBits(Op.getOperand(1), KnownZero, KnownOne, Depth+1);
1727 DAG.ComputeMaskedBits(Op.getOperand(0), KnownZero2, KnownOne2, Depth+1);
1763 SelectionDAG &DAG) const {
1765 return DAG.getTargetGlobalAddress(GA->getGlobal(),
1771 return DAG.getTargetConstantPool(CP->getConstVal(),
1777 return DAG.getTargetBlockAddress(BA->getBlockAddress(),
1783 return DAG.getTargetExternalSymbol(ES->getSymbol(),
1793 SelectionDAG &DAG) const {
1796 SDValue Hi = DAG.getNode(SPISD::Hi, DL, VT, withTargetFlags(Op, HiTF, DAG));
1797 SDValue Lo = DAG.getNode(SPISD::Lo, DL, VT, withTargetFlags(Op, LoTF, DAG));
1798 return DAG.getNode(ISD::ADD, DL, VT, Hi, Lo);
1803 SDValue SparcTargetLowering::makeAddress(SDValue Op, SelectionDAG &DAG) const {
1811 SparcMCExpr::VK_Sparc_GOT10, DAG);
1812 SDValue GlobalBase = DAG.getNode(SPISD::GLOBAL_BASE_REG, DL, VT);
1813 SDValue AbsAddr = DAG.getNode(ISD::ADD, DL, VT, GlobalBase, HiLo);
1816 MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
1818 return DAG.getLoad(VT, DL, DAG.getEntryNode(), AbsAddr,
1829 SparcMCExpr::VK_Sparc_LO, DAG);
1833 SparcMCExpr::VK_Sparc_M44, DAG);
1834 H44 = DAG.getNode(ISD::SHL, DL, VT, H44, DAG.getConstant(12, MVT::i32));
1835 SDValue L44 = withTargetFlags(Op, SparcMCExpr::VK_Sparc_L44, DAG);
1836 L44 = DAG.getNode(SPISD::Lo, DL, VT, L44);
1837 return DAG.getNode(ISD::ADD, DL, VT, H44, L44);
1842 SparcMCExpr::VK_Sparc_HM, DAG);
1843 Hi = DAG.getNode(ISD::SHL, DL, VT, Hi, DAG.getConstant(32, MVT::i32));
1845 SparcMCExpr::VK_Sparc_LO, DAG);
1846 return DAG.getNode(ISD::ADD, DL, VT, Hi, Lo);
1852 SelectionDAG &DAG) const {
1853 return makeAddress(Op, DAG);
1857 SelectionDAG &DAG) const {
1858 return makeAddress(Op, DAG);
1862 SelectionDAG &DAG) const {
1863 return makeAddress(Op, DAG);
1867 SelectionDAG &DAG) const {
1890 SDValue HiLo = makeHiLoPair(Op, HiTF, LoTF, DAG);
1891 SDValue Base = DAG.getNode(SPISD::GLOBAL_BASE_REG, DL, PtrVT);
1892 SDValue Argument = DAG.getNode(SPISD::TLS_ADD, DL, PtrVT, Base, HiLo,
1893 withTargetFlags(Op, addTF, DAG));
1895 SDValue Chain = DAG.getEntryNode();
1898 Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(1, true), DL);
1899 Chain = DAG.getCopyToReg(Chain, DL, SP::O0, Argument, InFlag);
1901 SDValue Callee = DAG.getTargetExternalSymbol("__tls_get_addr", PtrVT);
1902 SDValue Symbol = withTargetFlags(Op, callTF, DAG);
1904 SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
1909 Ops.push_back(DAG.getRegister(SP::O0, PtrVT));
1913 Ops.push_back(DAG.getRegisterMask(Mask));
1915 Chain = DAG.getNode(SPISD::TLS_CALL, DL, NodeTys, &Ops[0], Ops.size());
1917 Chain = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(1, true),
1918 DAG.getIntPtrConstant(0, true), InFlag, DL);
1920 SDValue Ret = DAG.getCopyFromReg(Chain, DL, SP::O0, PtrVT, InFlag);
1925 SDValue Hi = DAG.getNode(SPISD::Hi, DL, PtrVT,
1926 withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LDO_HIX22, DAG));
1927 SDValue Lo = DAG.getNode(SPISD::Lo, DL, PtrVT,
1928 withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LDO_LOX10, DAG));
1929 HiLo = DAG.getNode(ISD::XOR, DL, PtrVT, Hi, Lo);
1930 return DAG.getNode(SPISD::TLS_ADD, DL, PtrVT, Ret, HiLo,
1931 withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LDO_ADD, DAG));
1938 SDValue Base = DAG.getNode(SPISD::GLOBAL_BASE_REG, DL, PtrVT);
1942 MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
1947 SparcMCExpr::VK_Sparc_TLS_IE_LO10, DAG);
1948 SDValue Ptr = DAG.getNode(ISD::ADD, DL, PtrVT, Base, TGA);
1949 SDValue Offset = DAG.getNode(SPISD::TLS_LD,
1951 withTargetFlags(Op, ldTF, DAG));
1952 return DAG.getNode(SPISD::TLS_ADD, DL, PtrVT,
1953 DAG.getRegister(SP::G7, PtrVT), Offset,
1955 SparcMCExpr::VK_Sparc_TLS_IE_ADD, DAG));
1959 SDValue Hi = DAG.getNode(SPISD::Hi, DL, PtrVT,
1960 withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LE_HIX22, DAG));
1961 SDValue Lo = DAG.getNode(SPISD::Lo, DL, PtrVT,
1962 withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LE_LOX10, DAG));
1963 SDValue Offset = DAG.getNode(ISD::XOR, DL, PtrVT, Hi, Lo);
1965 return DAG.getNode(ISD::ADD, DL, PtrVT,
1966 DAG.getRegister(SP::G7, PtrVT), Offset);
1972 SelectionDAG &DAG) const {
1973 MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
1975 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
1984 SDValue FIPtr = DAG.getFrameIndex(FI, getPointerTy());
1985 Chain = DAG.getStore(Chain,
2002 SparcTargetLowering::LowerF128Op(SDValue Op, SelectionDAG &DAG,
2008 MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
2010 SDValue Callee = DAG.getExternalSymbol(LibFuncName, getPointerTy());
2011 Type *RetTy = Op.getValueType().getTypeForEVT(*DAG.getContext());
2013 SDValue Chain = DAG.getEntryNode();
2020 RetPtr = DAG.getFrameIndex(RetFI, getPointerTy());
2027 RetTyABI = Type::getVoidTy(*DAG.getContext());
2032 Chain = LowerF128_LibCallArg(Chain, Args, Op.getOperand(i), SDLoc(Op), DAG);
2040 Callee, Args, DAG, SDLoc(Op));
2052 return DAG.getLoad(Op.getValueType(),
2064 SelectionDAG &DAG) const {
2086 SDValue Callee = DAG.getExternalSymbol(LibCall, getPointerTy());
2087 Type *RetTy = Type::getInt32Ty(*DAG.getContext());
2089 SDValue Chain = DAG.getEntryNode();
2090 Chain = LowerF128_LibCallArg(Chain, Args, LHS, DL, DAG);
2091 Chain = LowerF128_LibCallArg(Chain, Args, RHS, DL, DAG);
2099 Callee, Args, DAG, DL);
2108 SDValue RHS = DAG.getTargetConstant(0, Result.getValueType());
2110 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2113 SDValue Mask = DAG.getTargetConstant(1, Result.getValueType());
2114 Result = DAG.getNode(ISD::AND, DL, Result.getValueType(), Result, Mask);
2115 SDValue RHS = DAG.getTargetConstant(0, Result.getValueType());
2117 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2120 SDValue RHS = DAG.getTargetConstant(2, Result.getValueType());
2122 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2125 SDValue RHS = DAG.getTargetConstant(1, Result.getValueType());
2127 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2130 SDValue RHS = DAG.getTargetConstant(1, Result.getValueType());
2132 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2136 SDValue RHS = DAG.getTargetConstant(3, Result.getValueType());
2138 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2141 SDValue RHS = DAG.getTargetConstant(3, Result.getValueType());
2143 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2146 SDValue Mask = DAG.getTargetConstant(3, Result.getValueType());
2147 Result = DAG.getNode(ISD::AND, DL, Result.getValueType(), Result, Mask);
2148 SDValue RHS = DAG.getTargetConstant(0, Result.getValueType());
2150 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2153 SDValue Mask = DAG.getTargetConstant(3, Result.getValueType());
2154 Result = DAG.getNode(ISD::AND, DL, Result.getValueType(), Result, Mask);
2155 SDValue RHS = DAG.getTargetConstant(0, Result.getValueType());
2157 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2163 LowerF128_FPEXTEND(SDValue Op, SelectionDAG &DAG,
2167 return TLI.LowerF128Op(Op, DAG,
2171 return TLI.LowerF128Op(Op, DAG,
2179 LowerF128_FPROUND(SDValue Op, SelectionDAG &DAG,
2186 return TLI.LowerF128Op(Op, DAG,
2189 return TLI.LowerF128Op(Op, DAG,
2196 static SDValue LowerFP_TO_SINT(SDValue Op, SelectionDAG &DAG,
2209 return TLI.LowerF128Op(Op, DAG, libName, 1);
2218 Op = DAG.getNode(SPISD::FTOI, dl, MVT::f32, Op.getOperand(0));
2220 Op = DAG.getNode(SPISD::FTOX, dl, MVT::f64, Op.getOperand(0));
2222 return DAG.getNode(ISD::BITCAST, dl, VT, Op);
2225 static SDValue LowerSINT_TO_FP(SDValue Op, SelectionDAG &DAG,
2240 return TLI.LowerF128Op(Op, DAG, libName, 1);
2248 SDValue Tmp = DAG.getNode(ISD::BITCAST, dl, floatVT, Op.getOperand(0));
2250 return DAG.getNode(opcode, dl, Op.getValueType(), Tmp);
2253 static SDValue LowerFP_TO_UINT(SDValue Op, SelectionDAG &DAG,
2267 return TLI.LowerF128Op(Op, DAG,
2274 static SDValue LowerUINT_TO_FP(SDValue Op, SelectionDAG &DAG,
2286 return TLI.LowerF128Op(Op, DAG,
2293 static SDValue LowerBR_CC(SDValue Op, SelectionDAG &DAG,
2311 CompareFlag = DAG.getNode(SPISD::CMPICC, dl, MVT::Glue, LHS, RHS);
2318 CompareFlag = TLI.LowerF128Compare(LHS, RHS, SPCC, dl, DAG);
2321 CompareFlag = DAG.getNode(SPISD::CMPFCC, dl, MVT::Glue, LHS, RHS);
2326 return DAG.getNode(Opc, dl, MVT::Other, Chain, Dest,
2327 DAG.getConstant(SPCC, MVT::i32), CompareFlag);
2330 static SDValue LowerSELECT_CC(SDValue Op, SelectionDAG &DAG,
2347 CompareFlag = DAG.getNode(SPISD::CMPICC, dl, MVT::Glue, LHS, RHS);
2354 CompareFlag = TLI.LowerF128Compare(LHS, RHS, SPCC, dl, DAG);
2357 CompareFlag = DAG.getNode(SPISD::CMPFCC, dl, MVT::Glue, LHS, RHS);
2362 return DAG.getNode(Opc, dl, TrueVal.getValueType(), TrueVal, FalseVal,
2363 DAG.getConstant(SPCC, MVT::i32), CompareFlag);
2366 static SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG,
2368 MachineFunction &MF = DAG.getMachineFunction();
2378 DAG.getNode(ISD::ADD, DL, TLI.getPointerTy(),
2379 DAG.getRegister(SP::I6, TLI.getPointerTy()),
2380 DAG.getIntPtrConstant(FuncInfo->getVarArgsFrameOffset()));
2382 return DAG.getStore(Op.getOperand(0), DL, Offset, Op.getOperand(1),
2386 static SDValue LowerVAARG(SDValue Op, SelectionDAG &DAG) {
2394 SDValue VAList = DAG.getLoad(PtrVT, DL, InChain, VAListPtr,
2397 SDValue NextPtr = DAG.getNode(ISD::ADD, DL, PtrVT, VAList,
2398 DAG.getIntPtrConstant(VT.getSizeInBits()/8));
2400 InChain = DAG.getStore(VAList.getValue(1), DL, NextPtr,
2404 return DAG.getLoad(VT, DL, InChain, VAList, MachinePointerInfo(),
2409 static SDValue LowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG,
2417 SDValue SP = DAG.getCopyFromReg(Chain, dl, SPReg, VT);
2418 SDValue NewSP = DAG.getNode(ISD::SUB, dl, VT, SP, Size); // Value
2419 Chain = DAG.getCopyToReg(SP.getValue(1), dl, SPReg, NewSP); // Output chain
2426 SDValue NewVal = DAG.getNode(ISD::ADD, dl, VT, NewSP,
2427 DAG.getConstant(regSpillArea, VT));
2429 return DAG.getMergeValues(Ops, 2, dl);
2433 static SDValue getFLUSHW(SDValue Op, SelectionDAG &DAG) {
2435 SDValue Chain = DAG.getNode(SPISD::FLUSHW,
2436 dl, MVT::Other, DAG.getEntryNode());
2440 static SDValue getFRAMEADDR(uint64_t depth, SDValue Op, SelectionDAG &DAG,
2442 MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
2453 FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl, FrameReg, VT);
2455 FrameAddr = DAG.getNode(ISD::ADD, dl, VT, FrameAddr,
2456 DAG.getIntPtrConstant(stackBias));
2461 SDValue Chain = getFLUSHW(Op, DAG);
2462 FrameAddr = DAG.getCopyFromReg(Chain, dl, FrameReg, VT);
2467 SDValue Ptr = DAG.getNode(ISD::ADD, dl, VT, FrameAddr,
2468 DAG.getIntPtrConstant(Offset));
2469 FrameAddr = DAG.getLoad(VT, dl, Chain, Ptr, MachinePointerInfo(),
2473 FrameAddr = DAG.getNode(ISD::ADD, dl, VT, FrameAddr,
2474 DAG.getIntPtrConstant(stackBias));
2479 static SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG,
2484 return getFRAMEADDR(depth, Op, DAG, Subtarget);
2488 static SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG,
2491 MachineFunction &MF = DAG.getMachineFunction();
2503 RetAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl, RetReg, VT);
2508 SDValue FrameAddr = getFRAMEADDR(depth - 1, Op, DAG, Subtarget);
2511 SDValue Ptr = DAG.getNode(ISD::ADD,
2514 DAG.getIntPtrConstant(Offset));
2515 RetAddr = DAG.getLoad(VT, dl, DAG.getEntryNode(), Ptr,
2521 static SDValue LowerF64Op(SDValue Op, SelectionDAG &DAG, unsigned opcode)
2533 SDValue Hi32 = DAG.getTargetExtractSubreg(SP::sub_even, dl, MVT::f32,
2535 SDValue Lo32 = DAG.getTargetExtractSubreg(SP::sub_odd, dl, MVT::f32,
2538 Hi32 = DAG.getNode(opcode, dl, MVT::f32, Hi32);
2540 SDValue DstReg64 = SDValue(DAG.getMachineNode(TargetOpcode::IMPLICIT_DEF,
2542 DstReg64 = DAG.getTargetInsertSubreg(SP::sub_even, dl, MVT::f64,
2544 DstReg64 = DAG.getTargetInsertSubreg(SP::sub_odd, dl, MVT::f64,
2550 static SDValue LowerF128Load(SDValue Op, SelectionDAG &DAG)
2561 SDValue Hi64 = DAG.getLoad(MVT::f64,
2568 SDValue LoPtr = DAG.getNode(ISD::ADD, dl, addrVT,
2570 DAG.getConstant(8, addrVT));
2571 SDValue Lo64 = DAG.getLoad(MVT::f64,
2578 SDValue SubRegEven = DAG.getTargetConstant(SP::sub_even64, MVT::i32);
2579 SDValue SubRegOdd = DAG.getTargetConstant(SP::sub_odd64, MVT::i32);
2581 SDNode *InFP128 = DAG.getMachineNode(TargetOpcode::IMPLICIT_DEF,
2583 InFP128 = DAG.getMachineNode(TargetOpcode::INSERT_SUBREG, dl,
2588 InFP128 = DAG.getMachineNode(TargetOpcode::INSERT_SUBREG, dl,
2595 SDValue OutChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
2598 return DAG.getMergeValues(Ops, 2, dl);
2602 static SDValue LowerF128Store(SDValue Op, SelectionDAG &DAG) {
2607 SDValue SubRegEven = DAG.getTargetConstant(SP::sub_even64, MVT::i32);
2608 SDValue SubRegOdd = DAG.getTargetConstant(SP::sub_odd64, MVT::i32);
2610 SDNode *Hi64 = DAG.getMachineNode(TargetOpcode::EXTRACT_SUBREG,
2615 SDNode *Lo64 = DAG.getMachineNode(TargetOpcode::EXTRACT_SUBREG,
2626 OutChains[0] = DAG.getStore(StNode->getChain(),
2633 SDValue LoPtr = DAG.getNode(ISD::ADD, dl, addrVT,
2635 DAG.getConstant(8, addrVT));
2636 OutChains[1] = DAG.getStore(StNode->getChain(),
2642 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
2646 static SDValue LowerFNEGorFABS(SDValue Op, SelectionDAG &DAG, bool isV9) {
2650 return LowerF64Op(Op, DAG, Op.getOpcode());
2659 SDValue Hi64 = DAG.getTargetExtractSubreg(SP::sub_even64, dl, MVT::f64,
2661 SDValue Lo64 = DAG.getTargetExtractSubreg(SP::sub_odd64, dl, MVT::f64,
2664 Hi64 = DAG.getNode(Op.getOpcode(), dl, MVT::f64, Hi64);
2666 Hi64 = LowerF64Op(Hi64, DAG, Op.getOpcode());
2668 SDValue DstReg128 = SDValue(DAG.getMachineNode(TargetOpcode::IMPLICIT_DEF,
2670 DstReg128 = DAG.getTargetInsertSubreg(SP::sub_even64, dl, MVT::f128,
2672 DstReg128 = DAG.getTargetInsertSubreg(SP::sub_odd64, dl, MVT::f128,
2677 static SDValue LowerADDC_ADDE_SUBC_SUBE(SDValue Op, SelectionDAG &DAG) {
2684 SDValue Src1Lo = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Src1);
2685 SDValue Src1Hi = DAG.getNode(ISD::SRL, dl, MVT::i64, Src1,
2686 DAG.getConstant(32, MVT::i64));
2687 Src1Hi = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Src1Hi);
2690 SDValue Src2Lo = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Src2);
2691 SDValue Src2Hi = DAG.getNode(ISD::SRL, dl, MVT::i64, Src2,
2692 DAG.getConstant(32, MVT::i64));
2693 Src2Hi = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Src2Hi);
2706 SDVTList VTs = DAG.getVTList(MVT::i32, MVT::Glue);
2708 Lo = DAG.getNode(Op.getOpcode(), dl, VTs, Src1Lo, Src2Lo,
2711 Lo = DAG.getNode(Op.getOpcode(), dl, VTs, Src1Lo, Src2Lo);
2713 SDValue Hi = DAG.getNode(hiOpc, dl, VTs, Src1Hi, Src2Hi, Lo.getValue(1));
2716 Lo = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, Lo);
2717 Hi = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, Hi);
2718 Hi = DAG.getNode(ISD::SHL, dl, MVT::i64, Hi,
2719 DAG.getConstant(32, MVT::i64));
2721 SDValue Dst = DAG.getNode(ISD::OR, dl, MVT::i64, Hi, Lo);
2723 return DAG.getMergeValues(Ops, 2, dl);
2728 static SDValue LowerUMULO_SMULO(SDValue Op, SelectionDAG &DAG,
2743 SDValue ShiftAmt = DAG.getConstant(63, VT);
2746 SDValue HiLHS = DAG.getNode(ISD::SRA, dl, VT, LHS, ShiftAmt);
2747 SDValue HiRHS = DAG.getNode(ISD::SRA, dl, MVT::i64, RHS, ShiftAmt);
2750 SDValue MulResult = TLI.makeLibCall(DAG,
2753 SDValue BottomHalf = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VT,
2754 MulResult, DAG.getIntPtrConstant(0));
2755 SDValue TopHalf = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VT,
2756 MulResult, DAG.getIntPtrConstant(1));
2758 SDValue Tmp1 = DAG.getNode(ISD::SRA, dl, VT, BottomHalf, ShiftAmt);
2759 TopHalf = DAG.getSetCC(dl, MVT::i32, TopHalf, Tmp1, ISD::SETNE);
2761 TopHalf = DAG.getSetCC(dl, MVT::i32, TopHalf, DAG.getConstant(0, VT),
2767 DAG.DeleteNode(MulResult.getNode());
2770 return DAG.getMergeValues(Ops, 2, dl);
2773 static SDValue LowerATOMIC_LOAD_STORE(SDValue Op, SelectionDAG &DAG) {
2784 LowerOperation(SDValue Op, SelectionDAG &DAG) const {
2792 case ISD::RETURNADDR: return LowerRETURNADDR(Op, DAG, *this,
2794 case ISD::FRAMEADDR: return LowerFRAMEADDR(Op, DAG,
2796 case ISD::GlobalTLSAddress: return LowerGlobalTLSAddress(Op, DAG);
2797 case ISD::GlobalAddress: return LowerGlobalAddress(Op, DAG);
2798 case ISD::BlockAddress: return LowerBlockAddress(Op, DAG);
2799 case ISD::ConstantPool: return LowerConstantPool(Op, DAG);
2800 case ISD::FP_TO_SINT: return LowerFP_TO_SINT(Op, DAG, *this,
2802 case ISD::SINT_TO_FP: return LowerSINT_TO_FP(Op, DAG, *this,
2804 case ISD::FP_TO_UINT: return LowerFP_TO_UINT(Op, DAG, *this,
2806 case ISD::UINT_TO_FP: return LowerUINT_TO_FP(Op, DAG, *this,
2808 case ISD::BR_CC: return LowerBR_CC(Op, DAG, *this,
2810 case ISD::SELECT_CC: return LowerSELECT_CC(Op, DAG, *this,
2812 case ISD::VASTART: return LowerVASTART(Op, DAG, *this);
2813 case ISD::VAARG: return LowerVAARG(Op, DAG);
2814 case ISD::DYNAMIC_STACKALLOC: return LowerDYNAMIC_STACKALLOC(Op, DAG,
2817 case ISD::LOAD: return LowerF128Load(Op, DAG);
2818 case ISD::STORE: return LowerF128Store(Op, DAG);
2819 case ISD::FADD: return LowerF128Op(Op, DAG,
2821 case ISD::FSUB: return LowerF128Op(Op, DAG,
2823 case ISD::FMUL: return LowerF128Op(Op, DAG,
2825 case ISD::FDIV: return LowerF128Op(Op, DAG,
2827 case ISD::FSQRT: return LowerF128Op(Op, DAG,
2830 case ISD::FNEG: return LowerFNEGorFABS(Op, DAG, isV9);
2831 case ISD::FP_EXTEND: return LowerF128_FPEXTEND(Op, DAG, *this);
2832 case ISD::FP_ROUND: return LowerF128_FPROUND(Op, DAG, *this);
2836 case ISD::SUBE: return LowerADDC_ADDE_SUBC_SUBE(Op, DAG);
2838 case ISD::SMULO: return LowerUMULO_SMULO(Op, DAG, *this);
2840 case ISD::ATOMIC_STORE: return LowerATOMIC_LOAD_STORE(Op, DAG);
3113 SelectionDAG &DAG) const {
3126 Result = DAG.getTargetConstant(C->getSExtValue(), Op.getValueType());
3137 TargetLowering::LowerAsmOperandForConstraint(Op, Constraint, Ops, DAG);
3181 SelectionDAG &DAG) const {
3202 DAG,
3219 DAG,