Lines Matching defs: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, RetOps);
248 SDLoc DL, SelectionDAG &DAG) const {
253 CCState CCInfo(CallConv, IsVarArg, DAG.getMachineFunction(),
254 DAG.getTarget(), RVLocs, *DAG.getContext());
264 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);
291 OutVal = DAG.getNode(ISD::SHL, DL, MVT::i64, OutVal,
292 DAG.getConstant(32, MVT::i32));
297 SDValue NV = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i64, OutVals[i+1]);
298 OutVal = DAG.getNode(ISD::OR, DL, MVT::i64, OutVal, NV);
304 Chain = DAG.getCopyToReg(Chain, DL, VA.getLocReg(), OutVal, Flag);
308 RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
317 return DAG.getNode(SPISD::RET_FLAG, DL, MVT::Other, RetOps);
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());
367 SDValue FIPtr = DAG.getFrameIndex(FrameIdx, MVT::i32);
368 SDValue Arg = DAG.getLoad(MVT::i32, dl, Chain, FIPtr,
380 SDValue HiVal = DAG.getCopyFromReg(Chain, dl, VRegHi, MVT::i32);
389 SDValue FIPtr = DAG.getFrameIndex(FrameIdx, MVT::i32);
390 LoVal = DAG.getLoad(MVT::i32, dl, Chain, FIPtr,
396 LoVal = DAG.getCopyFromReg(Chain, dl, loReg, MVT::i32);
399 DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, LoVal, HiVal);
400 WholeValue = DAG.getNode(ISD::BITCAST, dl, MVT::f64, WholeValue);
406 SDValue Arg = DAG.getCopyFromReg(Chain, dl, VReg, MVT::i32);
408 Arg = DAG.getNode(ISD::BITCAST, dl, MVT::f32, Arg);
410 Arg = DAG.getNode(ISD::AssertSext, dl, MVT::i32, Arg,
411 DAG.getValueType(VA.getLocVT()));
412 Arg = DAG.getNode(ISD::TRUNCATE, dl, VA.getLocVT(), Arg);
429 SDValue FIPtr = DAG.getFrameIndex(FI, getPointerTy());
430 SDValue Load = DAG.getLoad(VA.getValVT(), dl, Chain, FIPtr,
440 SDValue FIPtr = DAG.getFrameIndex(FI, getPointerTy());
441 SDValue HiVal = DAG.getLoad(MVT::i32, dl, Chain, FIPtr,
447 SDValue FIPtr2 = DAG.getFrameIndex(FI2, getPointerTy());
449 SDValue LoVal = DAG.getLoad(MVT::i32, dl, Chain, FIPtr2,
454 DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, LoVal, HiVal);
455 WholeValue = DAG.getNode(ISD::BITCAST, dl, MVT::f64, WholeValue);
463 SDValue FIPtr = DAG.getFrameIndex(FI, getPointerTy());
466 Load = DAG.getLoad(VA.getValVT(), dl, Chain, FIPtr,
473 FIPtr = DAG.getNode(ISD::ADD, dl, MVT::i32, FIPtr,
474 DAG.getConstant(Offset, MVT::i32));
475 Load = DAG.getExtLoad(LoadOp, dl, MVT::i32, Chain, FIPtr,
478 Load = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), Load);
491 SDValue Copy = DAG.getCopyToReg(DAG.getEntryNode(), dl, Reg, InVals[0]);
492 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Copy, Chain);
518 SDValue Arg = DAG.getCopyFromReg(DAG.getRoot(), dl, VReg, MVT::i32);
522 SDValue FIPtr = DAG.getFrameIndex(FrameIdx, MVT::i32);
524 OutChains.push_back(DAG.getStore(DAG.getRoot(), dl, Arg, FIPtr,
532 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
546 SelectionDAG &DAG,
548 MachineFunction &MF = DAG.getMachineFunction();
552 CCState CCInfo(CallConv, IsVarArg, DAG.getMachineFunction(),
553 getTargetMachine(), ArgLocs, *DAG.getContext());
568 SDValue Arg = DAG.getCopyFromReg(Chain, DL, VReg, VA.getLocVT());
572 Arg = DAG.getNode(ISD::SRL, DL, VA.getLocVT(), Arg,
573 DAG.getConstant(32, MVT::i32));
579 Arg = DAG.getNode(ISD::AssertSext, DL, VA.getLocVT(), Arg,
580 DAG.getValueType(VA.getValVT()));
583 Arg = DAG.getNode(ISD::AssertZext, DL, VA.getLocVT(), Arg,
584 DAG.getValueType(VA.getValVT()));
592 Arg = DAG.getNode(ISD::TRUNCATE, DL, VA.getValVT(), Arg);
610 InVals.push_back(DAG.getLoad(VA.getValVT(), DL, Chain,
611 DAG.getFrameIndex(FI, getPointerTy()),
638 SDValue VArg = DAG.getCopyFromReg(Chain, DL, VReg, MVT::i64);
640 OutChains.push_back(DAG.getStore(Chain, DL, VArg,
641 DAG.getFrameIndex(FI, getPointerTy()),
647 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, OutChains);
660 static bool hasReturnsTwiceAttr(SelectionDAG &DAG, SDValue Callee,
670 const Function *Fn = DAG.getMachineFunction().getFunction();
685 SelectionDAG &DAG = CLI.DAG;
701 CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
702 DAG.getTarget(), ArgLocs, *DAG.getContext());
711 MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
725 SDValue FIPtr = DAG.getFrameIndex(FI, getPointerTy());
726 SDValue SizeNode = DAG.getConstant(Size, MVT::i32);
728 Chain = DAG.getMemcpy(Chain, dl, FIPtr, Arg, SizeNode, Align,
735 Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(ArgsSize, true),
761 Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Arg);
764 Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Arg);
767 Arg = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), Arg);
770 Arg = DAG.getNode(ISD::BITCAST, dl, VA.getLocVT(), Arg);
777 SDValue StackPtr = DAG.getRegister(SP::O6, MVT::i32);
778 SDValue PtrOff = DAG.getIntPtrConstant(64);
779 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
780 MemOpChains.push_back(DAG.getStore(Chain, dl, Arg, PtrOff,
794 SDValue StackPtr = DAG.getRegister(SP::O6, MVT::i32);
795 SDValue PtrOff = DAG.getIntPtrConstant(Offset);
796 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
797 MemOpChains.push_back(DAG.getStore(Chain, dl, Arg, PtrOff,
804 SDValue StackPtr = DAG.CreateStackTemporary(MVT::f64, MVT::i32);
805 SDValue Store = DAG.getStore(DAG.getEntryNode(), dl,
809 SDValue Hi = DAG.getLoad(MVT::i32, dl, Store, StackPtr,
812 StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr,
813 DAG.getIntPtrConstant(4));
815 SDValue Lo = DAG.getLoad(MVT::i32, dl, Store, StackPtr,
827 SDValue StackPtr = DAG.getRegister(SP::O6, MVT::i32);
828 SDValue PtrOff = DAG.getIntPtrConstant(Offset);
829 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
830 MemOpChains.push_back(DAG.getStore(Chain, dl, Lo, PtrOff,
837 SDValue StackPtr = DAG.getRegister(SP::O6, MVT::i32);
838 SDValue PtrOff = DAG.getIntPtrConstant(Offset);
839 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
840 MemOpChains.push_back(DAG.getStore(Chain, dl, Hi, PtrOff,
844 PtrOff = DAG.getIntPtrConstant(Offset+4);
845 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
846 MemOpChains.push_back(DAG.getStore(Chain, dl, Lo, PtrOff,
860 Arg = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Arg);
868 SDValue StackPtr = DAG.getRegister(SP::O6, MVT::i32);
869 SDValue PtrOff = DAG.getIntPtrConstant(VA.getLocMemOffset()+StackOffset);
870 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
871 MemOpChains.push_back(DAG.getStore(Chain, dl, Arg, PtrOff,
879 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
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);
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, MemOpChains);
1203 Chain = DAG.getCopyToReg(Chain, DL,
1212 bool hasReturnsTwice = hasReturnsTwiceAttr(DAG, Callee, CLI.CS);
1216 Callee = DAG.getTargetGlobalAddress(G->getGlobal(), DL, getPointerTy(), 0,
1219 Callee = DAG.getTargetExternalSymbol(E->getSymbol(), getPointerTy(), TF);
1226 Ops.push_back(DAG.getRegister(RegsToPass[i].first,
1236 Ops.push_back(DAG.getRegisterMask(Mask));
1244 SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
1245 Chain = DAG.getNode(SPISD::CALL, DL, NodeTys, Ops);
1249 Chain = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(ArgsSize, true),
1250 DAG.getIntPtrConstant(0, true), InGlue, DL);
1258 CCState RVInfo(CLI.CallConv, CLI.IsVarArg, DAG.getMachineFunction(),
1259 DAG.getTarget(), RVLocs, *DAG.getContext());
1283 RV = DAG.getCopyFromReg(Chain, DL, Reg, RVLocs[i].getLocVT(), InGlue);
1290 RV = DAG.getNode(ISD::SRL, DL, VA.getLocVT(), RV,
1291 DAG.getConstant(32, MVT::i32));
1297 RV = DAG.getNode(ISD::AssertSext, DL, VA.getLocVT(), RV,
1298 DAG.getValueType(VA.getValVT()));
1301 RV = DAG.getNode(ISD::AssertZext, DL, VA.getLocVT(), RV,
1302 DAG.getValueType(VA.getValVT()));
1310 RV = DAG.getNode(ISD::TRUNCATE, DL, VA.getValVT(), RV);
1322 /// IntCondCCodeToICC - Convert a DAG integer condition code to a SPARC ICC
1340 /// FPCondCCodeToFCC - Convert a DAG floatingp oint condition code to a SPARC
1709 /// be zero. Op is expected to be a target specific node. Used by DAG
1715 const SelectionDAG &DAG,
1725 DAG.computeKnownBits(Op.getOperand(1), KnownZero, KnownOne, Depth+1);
1726 DAG.computeKnownBits(Op.getOperand(0), KnownZero2, KnownOne2, Depth+1);
1760 SelectionDAG &DAG) const {
1762 return DAG.getTargetGlobalAddress(GA->getGlobal(),
1768 return DAG.getTargetConstantPool(CP->getConstVal(),
1774 return DAG.getTargetBlockAddress(BA->getBlockAddress(),
1780 return DAG.getTargetExternalSymbol(ES->getSymbol(),
1790 SelectionDAG &DAG) const {
1793 SDValue Hi = DAG.getNode(SPISD::Hi, DL, VT, withTargetFlags(Op, HiTF, DAG));
1794 SDValue Lo = DAG.getNode(SPISD::Lo, DL, VT, withTargetFlags(Op, LoTF, DAG));
1795 return DAG.getNode(ISD::ADD, DL, VT, Hi, Lo);
1800 SDValue SparcTargetLowering::makeAddress(SDValue Op, SelectionDAG &DAG) const {
1808 SparcMCExpr::VK_Sparc_GOT10, DAG);
1809 SDValue GlobalBase = DAG.getNode(SPISD::GLOBAL_BASE_REG, DL, VT);
1810 SDValue AbsAddr = DAG.getNode(ISD::ADD, DL, VT, GlobalBase, HiLo);
1813 MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
1815 return DAG.getLoad(VT, DL, DAG.getEntryNode(), AbsAddr,
1826 SparcMCExpr::VK_Sparc_LO, DAG);
1830 SparcMCExpr::VK_Sparc_M44, DAG);
1831 H44 = DAG.getNode(ISD::SHL, DL, VT, H44, DAG.getConstant(12, MVT::i32));
1832 SDValue L44 = withTargetFlags(Op, SparcMCExpr::VK_Sparc_L44, DAG);
1833 L44 = DAG.getNode(SPISD::Lo, DL, VT, L44);
1834 return DAG.getNode(ISD::ADD, DL, VT, H44, L44);
1839 SparcMCExpr::VK_Sparc_HM, DAG);
1840 Hi = DAG.getNode(ISD::SHL, DL, VT, Hi, DAG.getConstant(32, MVT::i32));
1842 SparcMCExpr::VK_Sparc_LO, DAG);
1843 return DAG.getNode(ISD::ADD, DL, VT, Hi, Lo);
1849 SelectionDAG &DAG) const {
1850 return makeAddress(Op, DAG);
1854 SelectionDAG &DAG) const {
1855 return makeAddress(Op, DAG);
1859 SelectionDAG &DAG) const {
1860 return makeAddress(Op, DAG);
1864 SelectionDAG &DAG) const {
1887 SDValue HiLo = makeHiLoPair(Op, HiTF, LoTF, DAG);
1888 SDValue Base = DAG.getNode(SPISD::GLOBAL_BASE_REG, DL, PtrVT);
1889 SDValue Argument = DAG.getNode(SPISD::TLS_ADD, DL, PtrVT, Base, HiLo,
1890 withTargetFlags(Op, addTF, DAG));
1892 SDValue Chain = DAG.getEntryNode();
1895 Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(1, true), DL);
1896 Chain = DAG.getCopyToReg(Chain, DL, SP::O0, Argument, InFlag);
1898 SDValue Callee = DAG.getTargetExternalSymbol("__tls_get_addr", PtrVT);
1899 SDValue Symbol = withTargetFlags(Op, callTF, DAG);
1901 SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
1906 Ops.push_back(DAG.getRegister(SP::O0, PtrVT));
1910 Ops.push_back(DAG.getRegisterMask(Mask));
1912 Chain = DAG.getNode(SPISD::TLS_CALL, DL, NodeTys, Ops);
1914 Chain = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(1, true),
1915 DAG.getIntPtrConstant(0, true), InFlag, DL);
1917 SDValue Ret = DAG.getCopyFromReg(Chain, DL, SP::O0, PtrVT, InFlag);
1922 SDValue Hi = DAG.getNode(SPISD::Hi, DL, PtrVT,
1923 withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LDO_HIX22, DAG));
1924 SDValue Lo = DAG.getNode(SPISD::Lo, DL, PtrVT,
1925 withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LDO_LOX10, DAG));
1926 HiLo = DAG.getNode(ISD::XOR, DL, PtrVT, Hi, Lo);
1927 return DAG.getNode(SPISD::TLS_ADD, DL, PtrVT, Ret, HiLo,
1928 withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LDO_ADD, DAG));
1935 SDValue Base = DAG.getNode(SPISD::GLOBAL_BASE_REG, DL, PtrVT);
1939 MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
1944 SparcMCExpr::VK_Sparc_TLS_IE_LO10, DAG);
1945 SDValue Ptr = DAG.getNode(ISD::ADD, DL, PtrVT, Base, TGA);
1946 SDValue Offset = DAG.getNode(SPISD::TLS_LD,
1948 withTargetFlags(Op, ldTF, DAG));
1949 return DAG.getNode(SPISD::TLS_ADD, DL, PtrVT,
1950 DAG.getRegister(SP::G7, PtrVT), Offset,
1952 SparcMCExpr::VK_Sparc_TLS_IE_ADD, DAG));
1956 SDValue Hi = DAG.getNode(SPISD::Hi, DL, PtrVT,
1957 withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LE_HIX22, DAG));
1958 SDValue Lo = DAG.getNode(SPISD::Lo, DL, PtrVT,
1959 withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LE_LOX10, DAG));
1960 SDValue Offset = DAG.getNode(ISD::XOR, DL, PtrVT, Hi, Lo);
1962 return DAG.getNode(ISD::ADD, DL, PtrVT,
1963 DAG.getRegister(SP::G7, PtrVT), Offset);
1969 SelectionDAG &DAG) const {
1970 MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
1972 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
1981 SDValue FIPtr = DAG.getFrameIndex(FI, getPointerTy());
1982 Chain = DAG.getStore(Chain,
1999 SparcTargetLowering::LowerF128Op(SDValue Op, SelectionDAG &DAG,
2005 MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
2007 SDValue Callee = DAG.getExternalSymbol(LibFuncName, getPointerTy());
2008 Type *RetTy = Op.getValueType().getTypeForEVT(*DAG.getContext());
2010 SDValue Chain = DAG.getEntryNode();
2017 RetPtr = DAG.getFrameIndex(RetFI, getPointerTy());
2024 RetTyABI = Type::getVoidTy(*DAG.getContext());
2029 Chain = LowerF128_LibCallArg(Chain, Args, Op.getOperand(i), SDLoc(Op), DAG);
2031 TargetLowering::CallLoweringInfo CLI(DAG);
2046 return DAG.getLoad(Op.getValueType(),
2058 SelectionDAG &DAG) const {
2080 SDValue Callee = DAG.getExternalSymbol(LibCall, getPointerTy());
2081 Type *RetTy = Type::getInt32Ty(*DAG.getContext());
2083 SDValue Chain = DAG.getEntryNode();
2084 Chain = LowerF128_LibCallArg(Chain, Args, LHS, DL, DAG);
2085 Chain = LowerF128_LibCallArg(Chain, Args, RHS, DL, DAG);
2087 TargetLowering::CallLoweringInfo CLI(DAG);
2098 SDValue RHS = DAG.getTargetConstant(0, Result.getValueType());
2100 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2103 SDValue Mask = DAG.getTargetConstant(1, Result.getValueType());
2104 Result = DAG.getNode(ISD::AND, DL, Result.getValueType(), Result, Mask);
2105 SDValue RHS = DAG.getTargetConstant(0, Result.getValueType());
2107 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2110 SDValue RHS = DAG.getTargetConstant(2, Result.getValueType());
2112 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2115 SDValue RHS = DAG.getTargetConstant(1, Result.getValueType());
2117 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2120 SDValue RHS = DAG.getTargetConstant(1, Result.getValueType());
2122 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2126 SDValue RHS = DAG.getTargetConstant(3, Result.getValueType());
2128 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2131 SDValue RHS = DAG.getTargetConstant(3, Result.getValueType());
2133 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2136 SDValue Mask = DAG.getTargetConstant(3, Result.getValueType());
2137 Result = DAG.getNode(ISD::AND, DL, Result.getValueType(), Result, Mask);
2138 SDValue RHS = DAG.getTargetConstant(0, Result.getValueType());
2140 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2143 SDValue Mask = DAG.getTargetConstant(3, Result.getValueType());
2144 Result = DAG.getNode(ISD::AND, DL, Result.getValueType(), Result, Mask);
2145 SDValue RHS = DAG.getTargetConstant(0, Result.getValueType());
2147 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2153 LowerF128_FPEXTEND(SDValue Op, SelectionDAG &DAG,
2157 return TLI.LowerF128Op(Op, DAG,
2161 return TLI.LowerF128Op(Op, DAG,
2169 LowerF128_FPROUND(SDValue Op, SelectionDAG &DAG,
2176 return TLI.LowerF128Op(Op, DAG,
2179 return TLI.LowerF128Op(Op, DAG,
2186 static SDValue LowerFP_TO_SINT(SDValue Op, SelectionDAG &DAG,
2199 return TLI.LowerF128Op(Op, DAG, libName, 1);
2208 Op = DAG.getNode(SPISD::FTOI, dl, MVT::f32, Op.getOperand(0));
2210 Op = DAG.getNode(SPISD::FTOX, dl, MVT::f64, Op.getOperand(0));
2212 return DAG.getNode(ISD::BITCAST, dl, VT, Op);
2215 static SDValue LowerSINT_TO_FP(SDValue Op, SelectionDAG &DAG,
2230 return TLI.LowerF128Op(Op, DAG, libName, 1);
2238 SDValue Tmp = DAG.getNode(ISD::BITCAST, dl, floatVT, Op.getOperand(0));
2240 return DAG.getNode(opcode, dl, Op.getValueType(), Tmp);
2243 static SDValue LowerFP_TO_UINT(SDValue Op, SelectionDAG &DAG,
2257 return TLI.LowerF128Op(Op, DAG,
2264 static SDValue LowerUINT_TO_FP(SDValue Op, SelectionDAG &DAG,
2276 return TLI.LowerF128Op(Op, DAG,
2283 static SDValue LowerBR_CC(SDValue Op, SelectionDAG &DAG,
2301 CompareFlag = DAG.getNode(SPISD::CMPICC, dl, MVT::Glue, LHS, RHS);
2308 CompareFlag = TLI.LowerF128Compare(LHS, RHS, SPCC, dl, DAG);
2311 CompareFlag = DAG.getNode(SPISD::CMPFCC, dl, MVT::Glue, LHS, RHS);
2316 return DAG.getNode(Opc, dl, MVT::Other, Chain, Dest,
2317 DAG.getConstant(SPCC, MVT::i32), CompareFlag);
2320 static SDValue LowerSELECT_CC(SDValue Op, SelectionDAG &DAG,
2337 CompareFlag = DAG.getNode(SPISD::CMPICC, dl, MVT::Glue, LHS, RHS);
2344 CompareFlag = TLI.LowerF128Compare(LHS, RHS, SPCC, dl, DAG);
2347 CompareFlag = DAG.getNode(SPISD::CMPFCC, dl, MVT::Glue, LHS, RHS);
2352 return DAG.getNode(Opc, dl, TrueVal.getValueType(), TrueVal, FalseVal,
2353 DAG.getConstant(SPCC, MVT::i32), CompareFlag);
2356 static SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG,
2358 MachineFunction &MF = DAG.getMachineFunction();
2368 DAG.getNode(ISD::ADD, DL, TLI.getPointerTy(),
2369 DAG.getRegister(SP::I6, TLI.getPointerTy()),
2370 DAG.getIntPtrConstant(FuncInfo->getVarArgsFrameOffset()));
2372 return DAG.getStore(Op.getOperand(0), DL, Offset, Op.getOperand(1),
2376 static SDValue LowerVAARG(SDValue Op, SelectionDAG &DAG) {
2384 SDValue VAList = DAG.getLoad(PtrVT, DL, InChain, VAListPtr,
2387 SDValue NextPtr = DAG.getNode(ISD::ADD, DL, PtrVT, VAList,
2388 DAG.getIntPtrConstant(VT.getSizeInBits()/8));
2390 InChain = DAG.getStore(VAList.getValue(1), DL, NextPtr,
2394 return DAG.getLoad(VT, DL, InChain, VAList, MachinePointerInfo(),
2399 static SDValue LowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG,
2407 SDValue SP = DAG.getCopyFromReg(Chain, dl, SPReg, VT);
2408 SDValue NewSP = DAG.getNode(ISD::SUB, dl, VT, SP, Size); // Value
2409 Chain = DAG.getCopyToReg(SP.getValue(1), dl, SPReg, NewSP); // Output chain
2416 SDValue NewVal = DAG.getNode(ISD::ADD, dl, VT, NewSP,
2417 DAG.getConstant(regSpillArea, VT));
2419 return DAG.getMergeValues(Ops, dl);
2423 static SDValue getFLUSHW(SDValue Op, SelectionDAG &DAG) {
2425 SDValue Chain = DAG.getNode(SPISD::FLUSHW,
2426 dl, MVT::Other, DAG.getEntryNode());
2430 static SDValue getFRAMEADDR(uint64_t depth, SDValue Op, SelectionDAG &DAG,
2432 MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
2443 FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl, FrameReg, VT);
2445 FrameAddr = DAG.getNode(ISD::ADD, dl, VT, FrameAddr,
2446 DAG.getIntPtrConstant(stackBias));
2451 SDValue Chain = getFLUSHW(Op, DAG);
2452 FrameAddr = DAG.getCopyFromReg(Chain, dl, FrameReg, VT);
2457 SDValue Ptr = DAG.getNode(ISD::ADD, dl, VT, FrameAddr,
2458 DAG.getIntPtrConstant(Offset));
2459 FrameAddr = DAG.getLoad(VT, dl, Chain, Ptr, MachinePointerInfo(),
2463 FrameAddr = DAG.getNode(ISD::ADD, dl, VT, FrameAddr,
2464 DAG.getIntPtrConstant(stackBias));
2469 static SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG,
2474 return getFRAMEADDR(depth, Op, DAG, Subtarget);
2478 static SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG,
2481 MachineFunction &MF = DAG.getMachineFunction();
2485 if (TLI.verifyReturnAddressArgumentIsConstant(Op, DAG))
2496 RetAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl, RetReg, VT);
2501 SDValue FrameAddr = getFRAMEADDR(depth - 1, Op, DAG, Subtarget);
2504 SDValue Ptr = DAG.getNode(ISD::ADD,
2507 DAG.getIntPtrConstant(Offset));
2508 RetAddr = DAG.getLoad(VT, dl, DAG.getEntryNode(), Ptr,
2514 static SDValue LowerF64Op(SDValue Op, SelectionDAG &DAG, unsigned opcode)
2526 SDValue Hi32 = DAG.getTargetExtractSubreg(SP::sub_even, dl, MVT::f32,
2528 SDValue Lo32 = DAG.getTargetExtractSubreg(SP::sub_odd, dl, MVT::f32,
2531 Hi32 = DAG.getNode(opcode, dl, MVT::f32, Hi32);
2533 SDValue DstReg64 = SDValue(DAG.getMachineNode(TargetOpcode::IMPLICIT_DEF,
2535 DstReg64 = DAG.getTargetInsertSubreg(SP::sub_even, dl, MVT::f64,
2537 DstReg64 = DAG.getTargetInsertSubreg(SP::sub_odd, dl, MVT::f64,
2543 static SDValue LowerF128Load(SDValue Op, SelectionDAG &DAG)
2554 SDValue Hi64 = DAG.getLoad(MVT::f64,
2561 SDValue LoPtr = DAG.getNode(ISD::ADD, dl, addrVT,
2563 DAG.getConstant(8, addrVT));
2564 SDValue Lo64 = DAG.getLoad(MVT::f64,
2571 SDValue SubRegEven = DAG.getTargetConstant(SP::sub_even64, MVT::i32);
2572 SDValue SubRegOdd = DAG.getTargetConstant(SP::sub_odd64, MVT::i32);
2574 SDNode *InFP128 = DAG.getMachineNode(TargetOpcode::IMPLICIT_DEF,
2576 InFP128 = DAG.getMachineNode(TargetOpcode::INSERT_SUBREG, dl,
2581 InFP128 = DAG.getMachineNode(TargetOpcode::INSERT_SUBREG, dl,
2588 SDValue OutChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
2590 return DAG.getMergeValues(Ops, dl);
2594 static SDValue LowerF128Store(SDValue Op, SelectionDAG &DAG) {
2599 SDValue SubRegEven = DAG.getTargetConstant(SP::sub_even64, MVT::i32);
2600 SDValue SubRegOdd = DAG.getTargetConstant(SP::sub_odd64, MVT::i32);
2602 SDNode *Hi64 = DAG.getMachineNode(TargetOpcode::EXTRACT_SUBREG,
2607 SDNode *Lo64 = DAG.getMachineNode(TargetOpcode::EXTRACT_SUBREG,
2618 OutChains[0] = DAG.getStore(StNode->getChain(),
2625 SDValue LoPtr = DAG.getNode(ISD::ADD, dl, addrVT,
2627 DAG.getConstant(8, addrVT));
2628 OutChains[1] = DAG.getStore(StNode->getChain(),
2634 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
2637 static SDValue LowerFNEGorFABS(SDValue Op, SelectionDAG &DAG, bool isV9) {
2642 return LowerF64Op(Op, DAG, Op.getOpcode());
2651 SDValue Hi64 = DAG.getTargetExtractSubreg(SP::sub_even64, dl, MVT::f64,
2653 SDValue Lo64 = DAG.getTargetExtractSubreg(SP::sub_odd64, dl, MVT::f64,
2656 Hi64 = DAG.getNode(Op.getOpcode(), dl, MVT::f64, Hi64);
2658 Hi64 = LowerF64Op(Hi64, DAG, Op.getOpcode());
2660 SDValue DstReg128 = SDValue(DAG.getMachineNode(TargetOpcode::IMPLICIT_DEF,
2662 DstReg128 = DAG.getTargetInsertSubreg(SP::sub_even64, dl, MVT::f128,
2664 DstReg128 = DAG.getTargetInsertSubreg(SP::sub_odd64, dl, MVT::f128,
2669 static SDValue LowerADDC_ADDE_SUBC_SUBE(SDValue Op, SelectionDAG &DAG) {
2676 SDValue Src1Lo = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Src1);
2677 SDValue Src1Hi = DAG.getNode(ISD::SRL, dl, MVT::i64, Src1,
2678 DAG.getConstant(32, MVT::i64));
2679 Src1Hi = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Src1Hi);
2682 SDValue Src2Lo = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Src2);
2683 SDValue Src2Hi = DAG.getNode(ISD::SRL, dl, MVT::i64, Src2,
2684 DAG.getConstant(32, MVT::i64));
2685 Src2Hi = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Src2Hi);
2698 SDVTList VTs = DAG.getVTList(MVT::i32, MVT::Glue);
2700 Lo = DAG.getNode(Op.getOpcode(), dl, VTs, Src1Lo, Src2Lo,
2703 Lo = DAG.getNode(Op.getOpcode(), dl, VTs, Src1Lo, Src2Lo);
2705 SDValue Hi = DAG.getNode(hiOpc, dl, VTs, Src1Hi, Src2Hi, Lo.getValue(1));
2708 Lo = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, Lo);
2709 Hi = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, Hi);
2710 Hi = DAG.getNode(ISD::SHL, dl, MVT::i64, Hi,
2711 DAG.getConstant(32, MVT::i64));
2713 SDValue Dst = DAG.getNode(ISD::OR, dl, MVT::i64, Hi, Lo);
2715 return DAG.getMergeValues(Ops, dl);
2720 static SDValue LowerUMULO_SMULO(SDValue Op, SelectionDAG &DAG,
2735 SDValue ShiftAmt = DAG.getConstant(63, VT);
2738 SDValue HiLHS = DAG.getNode(ISD::SRA, dl, VT, LHS, ShiftAmt);
2739 SDValue HiRHS = DAG.getNode(ISD::SRA, dl, MVT::i64, RHS, ShiftAmt);
2742 SDValue MulResult = TLI.makeLibCall(DAG,
2745 SDValue BottomHalf = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VT,
2746 MulResult, DAG.getIntPtrConstant(0));
2747 SDValue TopHalf = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VT,
2748 MulResult, DAG.getIntPtrConstant(1));
2750 SDValue Tmp1 = DAG.getNode(ISD::SRA, dl, VT, BottomHalf, ShiftAmt);
2751 TopHalf = DAG.getSetCC(dl, MVT::i32, TopHalf, Tmp1, ISD::SETNE);
2753 TopHalf = DAG.getSetCC(dl, MVT::i32, TopHalf, DAG.getConstant(0, VT),
2759 DAG.DeleteNode(MulResult.getNode());
2762 return DAG.getMergeValues(Ops, dl);
2765 static SDValue LowerATOMIC_LOAD_STORE(SDValue Op, SelectionDAG &DAG) {
2776 LowerOperation(SDValue Op, SelectionDAG &DAG) const {
2784 case ISD::RETURNADDR: return LowerRETURNADDR(Op, DAG, *this,
2786 case ISD::FRAMEADDR: return LowerFRAMEADDR(Op, DAG,
2788 case ISD::GlobalTLSAddress: return LowerGlobalTLSAddress(Op, DAG);
2789 case ISD::GlobalAddress: return LowerGlobalAddress(Op, DAG);
2790 case ISD::BlockAddress: return LowerBlockAddress(Op, DAG);
2791 case ISD::ConstantPool: return LowerConstantPool(Op, DAG);
2792 case ISD::FP_TO_SINT: return LowerFP_TO_SINT(Op, DAG, *this,
2794 case ISD::SINT_TO_FP: return LowerSINT_TO_FP(Op, DAG, *this,
2796 case ISD::FP_TO_UINT: return LowerFP_TO_UINT(Op, DAG, *this,
2798 case ISD::UINT_TO_FP: return LowerUINT_TO_FP(Op, DAG, *this,
2800 case ISD::BR_CC: return LowerBR_CC(Op, DAG, *this,
2802 case ISD::SELECT_CC: return LowerSELECT_CC(Op, DAG, *this,
2804 case ISD::VASTART: return LowerVASTART(Op, DAG, *this);
2805 case ISD::VAARG: return LowerVAARG(Op, DAG);
2806 case ISD::DYNAMIC_STACKALLOC: return LowerDYNAMIC_STACKALLOC(Op, DAG,
2809 case ISD::LOAD: return LowerF128Load(Op, DAG);
2810 case ISD::STORE: return LowerF128Store(Op, DAG);
2811 case ISD::FADD: return LowerF128Op(Op, DAG,
2813 case ISD::FSUB: return LowerF128Op(Op, DAG,
2815 case ISD::FMUL: return LowerF128Op(Op, DAG,
2817 case ISD::FDIV: return LowerF128Op(Op, DAG,
2819 case ISD::FSQRT: return LowerF128Op(Op, DAG,
2822 case ISD::FNEG: return LowerFNEGorFABS(Op, DAG, isV9);
2823 case ISD::FP_EXTEND: return LowerF128_FPEXTEND(Op, DAG, *this);
2824 case ISD::FP_ROUND: return LowerF128_FPROUND(Op, DAG, *this);
2828 case ISD::SUBE: return LowerADDC_ADDE_SUBC_SUBE(Op, DAG);
2830 case ISD::SMULO: return LowerUMULO_SMULO(Op, DAG, *this);
2832 case ISD::ATOMIC_STORE: return LowerATOMIC_LOAD_STORE(Op, DAG);
3105 SelectionDAG &DAG) const {
3118 Result = DAG.getTargetConstant(C->getSExtValue(), Op.getValueType());
3129 TargetLowering::LowerAsmOperandForConstraint(Op, Constraint, Ops, DAG);
3173 SelectionDAG &DAG) const {
3194 DAG,
3211 DAG,