Lines Matching defs:DAG
1 //===-- SparcISelLowering.cpp - Sparc DAG Lowering Implementation ---------===//
10 // selection DAG.
250 const SDLoc &DL, SelectionDAG &DAG) const {
252 return LowerReturn_64(Chain, CallConv, IsVarArg, Outs, OutVals, DL, DAG);
253 return LowerReturn_32(Chain, CallConv, IsVarArg, Outs, OutVals, DL, DAG);
261 const SDLoc &DL, SelectionDAG &DAG) const {
262 MachineFunction &MF = DAG.getMachineFunction();
268 CCState CCInfo(CallConv, IsVarArg, DAG.getMachineFunction(), RVLocs,
269 *DAG.getContext());
293 SDValue Part0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::i32,
295 DAG.getConstant(0, DL, getVectorIdxTy(DAG.getDataLayout())));
296 SDValue Part1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::i32,
298 DAG.getConstant(1, DL, getVectorIdxTy(DAG.getDataLayout())));
300 Chain = DAG.getCopyToReg(Chain, DL, VA.getLocReg(), Part0, Glue);
302 RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
304 Chain = DAG.getCopyToReg(Chain, DL, VA.getLocReg(), Part1,
307 Chain = DAG.getCopyToReg(Chain, DL, VA.getLocReg(), Arg, Glue);
311 RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
321 auto PtrVT = getPointerTy(DAG.getDataLayout());
322 SDValue Val = DAG.getCopyFromReg(Chain, DL, Reg, PtrVT);
323 Chain = DAG.getCopyToReg(Chain, DL, SP::I0, Val, Glue);
325 RetOps.push_back(DAG.getRegister(SP::I0, PtrVT));
330 RetOps[1] = DAG.getConstant(RetAddrOffset, DL, MVT::i32);
336 return DAG.getNode(SPISD::RET_GLUE, DL, MVT::Other, RetOps);
346 const SDLoc &DL, SelectionDAG &DAG) const {
351 CCState CCInfo(CallConv, IsVarArg, DAG.getMachineFunction(), RVLocs,
352 *DAG.getContext());
362 RetOps.push_back(DAG.getConstant(8, DL, MVT::i32));
374 OutVal = DAG.getNode(ISD::SIGN_EXTEND, DL, VA.getLocVT(), OutVal);
377 OutVal = DAG.getNode(ISD::ZERO_EXTEND, DL, VA.getLocVT(), OutVal);
380 OutVal = DAG.getNode(ISD::ANY_EXTEND, DL, VA.getLocVT(), OutVal);
389 OutVal = DAG.getNode(ISD::SHL, DL, MVT::i64, OutVal,
390 DAG.getConstant(32, DL, MVT::i32));
395 SDValue NV = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i64, OutVals[i+1]);
396 OutVal = DAG.getNode(ISD::OR, DL, MVT::i64, OutVal, NV);
402 Chain = DAG.getCopyToReg(Chain, DL, VA.getLocReg(), OutVal, Glue);
406 RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
415 return DAG.getNode(SPISD::RET_GLUE, DL, MVT::Other, RetOps);
421 SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const {
424 DL, DAG, InVals);
426 DL, DAG, InVals);
435 SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const {
436 MachineFunction &MF = DAG.getMachineFunction();
442 CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(), ArgLocs,
443 *DAG.getContext());
447 bool IsLittleEndian = DAG.getDataLayout().isLittleEndian();
458 SDValue FIPtr = DAG.getFrameIndex(FrameIdx, MVT::i32);
460 DAG.getLoad(MVT::i32, dl, Chain, FIPtr, MachinePointerInfo());
471 SDValue HiVal = DAG.getCopyFromReg(Chain, dl, VRegHi, MVT::i32);
480 SDValue FIPtr = DAG.getFrameIndex(FrameIdx, MVT::i32);
481 LoVal = DAG.getLoad(MVT::i32, dl, Chain, FIPtr, MachinePointerInfo());
485 LoVal = DAG.getCopyFromReg(Chain, dl, loReg, MVT::i32);
492 DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, LoVal, HiVal);
493 WholeValue = DAG.getNode(ISD::BITCAST, dl, VA.getLocVT(), WholeValue);
499 SDValue Arg = DAG.getCopyFromReg(Chain, dl, VReg, MVT::i32);
501 Arg = DAG.getNode(ISD::BITCAST, dl, MVT::f32, Arg);
503 Arg = DAG.getNode(ISD::AssertSext, dl, MVT::i32, Arg,
504 DAG.getValueType(VA.getLocVT()));
505 Arg = DAG.getNode(ISD::TRUNCATE, dl, VA.getLocVT(), Arg);
514 auto PtrVT = getPointerTy(DAG.getDataLayout());
523 SDValue FIPtr = DAG.getFrameIndex(FI, PtrVT);
525 DAG.getLoad(VA.getValVT(), dl, Chain, FIPtr, MachinePointerInfo());
533 SDValue FIPtr = DAG.getFrameIndex(FI, PtrVT);
535 DAG.getLoad(MVT::i32, dl, Chain, FIPtr, MachinePointerInfo());
539 SDValue FIPtr2 = DAG.getFrameIndex(FI2, PtrVT);
542 DAG.getLoad(MVT::i32, dl, Chain, FIPtr2, MachinePointerInfo());
548 DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, LoVal, HiVal);
549 WholeValue = DAG.getNode(ISD::BITCAST, dl, VA.getValVT(), WholeValue);
557 SDValue FIPtr = DAG.getFrameIndex(FI, PtrVT);
560 Load = DAG.getLoad(VA.getValVT(), dl, Chain, FIPtr, MachinePointerInfo());
579 SDValue Copy = DAG.getCopyToReg(DAG.getEntryNode(), dl, Reg, InVals[0]);
580 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Copy, Chain);
606 SDValue Arg = DAG.getCopyFromReg(DAG.getRoot(), dl, VReg, MVT::i32);
610 SDValue FIPtr = DAG.getFrameIndex(FrameIdx, MVT::i32);
613 DAG.getStore(DAG.getRoot(), dl, Arg, FIPtr, MachinePointerInfo()));
619 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
630 SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const {
631 MachineFunction &MF = DAG.getMachineFunction();
635 CCState CCInfo(CallConv, IsVarArg, DAG.getMachineFunction(), ArgLocs,
636 *DAG.getContext());
650 SDValue Arg = DAG.getCopyFromReg(Chain, DL, VReg, VA.getLocVT());
654 Arg = DAG.getNode(ISD::SRL, DL, VA.getLocVT(), Arg,
655 DAG.getConstant(32, DL, MVT::i32));
661 Arg = DAG.getNode(ISD::AssertSext, DL, VA.getLocVT(), Arg,
662 DAG.getValueType(VA.getValVT()));
665 Arg = DAG.getNode(ISD::AssertZext, DL, VA.getLocVT(), Arg,
666 DAG.getValueType(VA.getValVT()));
674 Arg = DAG.getNode(ISD::TRUNCATE, DL, VA.getValVT(), Arg);
693 DAG.getLoad(VA.getValVT(), DL, Chain,
694 DAG.getFrameIndex(FI, getPointerTy(MF.getDataLayout())),
720 SDValue VArg = DAG.getCopyFromReg(Chain, DL, VReg, MVT::i64);
724 DAG.getStore(Chain, DL, VArg, DAG.getFrameIndex(FI, PtrVT),
729 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, OutChains);
766 static bool hasReturnsTwiceAttr(SelectionDAG &DAG, SDValue Callee,
776 const Function &Fn = DAG.getMachineFunction().getFunction();
824 SelectionDAG &DAG = CLI.DAG;
834 MachineFunction &MF = DAG.getMachineFunction();
838 CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(), ArgLocs,
839 *DAG.getContext());
843 CCInfo, CLI, DAG.getMachineFunction());
851 MachineFrameInfo &MFI = DAG.getMachineFunction().getFrameInfo();
866 SDValue FIPtr = DAG.getFrameIndex(FI, getPointerTy(DAG.getDataLayout()));
867 SDValue SizeNode = DAG.getConstant(Size, dl, MVT::i32);
869 Chain = DAG.getMemcpy(Chain, dl, FIPtr, Arg, SizeNode, Alignment,
885 Chain = DAG.getCALLSEQ_START(Chain, ArgsSize, 0, dl);
915 Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Arg);
918 Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Arg);
921 Arg = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), Arg);
924 Arg = DAG.getNode(ISD::BITCAST, dl, VA.getLocVT(), Arg);
935 SDValue StackPtr = DAG.getRegister(SP::O6, MVT::i32);
936 SDValue PtrOff = DAG.getIntPtrConstant(64, dl);
937 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
939 DAG.getStore(Chain, dl, Arg, PtrOff, MachinePointerInfo()));
944 DAG.getDataLayout().getTypeAllocSize(CLI.getArgs()[0].IndirectType);
955 SDValue StackPtr = DAG.getRegister(SP::O6, MVT::i32);
956 SDValue PtrOff = DAG.getIntPtrConstant(Offset, dl);
957 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
959 DAG.getStore(Chain, dl, Arg, PtrOff, MachinePointerInfo()));
968 Arg = bitcastConstantFPToInt(C, dl, DAG);
970 Arg = DAG.getNode(ISD::BITCAST, dl, MVT::v2i32, Arg);
973 SDValue Part0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
975 DAG.getConstant(0, dl, getVectorIdxTy(DAG.getDataLayout())));
976 SDValue Part1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
978 DAG.getConstant(1, dl, getVectorIdxTy(DAG.getDataLayout())));
989 SDValue StackPtr = DAG.getRegister(SP::O6, MVT::i32);
990 SDValue PtrOff = DAG.getIntPtrConstant(Offset, dl);
991 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
993 DAG.getStore(Chain, dl, Part1, PtrOff, MachinePointerInfo()));
998 SDValue StackPtr = DAG.getRegister(SP::O6, MVT::i32);
999 SDValue PtrOff = DAG.getIntPtrConstant(Offset, dl);
1000 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
1002 DAG.getStore(Chain, dl, Part0, PtrOff, MachinePointerInfo()));
1004 PtrOff = DAG.getIntPtrConstant(Offset + 4, dl);
1005 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
1007 DAG.getStore(Chain, dl, Part1, PtrOff, MachinePointerInfo()));
1019 Arg = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Arg);
1027 SDValue StackPtr = DAG.getRegister(SP::O6, MVT::i32);
1028 SDValue PtrOff = DAG.getIntPtrConstant(VA.getLocMemOffset() + StackOffset,
1030 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
1032 DAG.getStore(Chain, dl, Arg, PtrOff, MachinePointerInfo()));
1038 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
1049 Chain = DAG.getCopyToReg(Chain, dl, Reg, RegsToPass[i].second, InGlue);
1053 bool hasReturnsTwice = hasReturnsTwiceAttr(DAG, Callee, CLI.CB);
1061 Callee = DAG.getTargetGlobalAddress(G->getGlobal(), dl, MVT::i32, 0, TF);
1063 Callee = DAG.getTargetExternalSymbol(E->getSymbol(), MVT::i32, TF);
1066 SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
1071 Ops.push_back(DAG.getTargetConstant(SRetArgSize, dl, MVT::i32));
1076 Ops.push_back(DAG.getRegister(Reg, RegsToPass[i].second.getValueType()));
1084 : TRI->getCallPreservedMask(DAG.getMachineFunction(), CallConv));
1090 Ops.push_back(DAG.getRegisterMask(Mask));
1096 DAG.getMachineFunction().getFrameInfo().setHasTailCall();
1097 return DAG.getNode(SPISD::TAIL_CALL, dl, MVT::Other, Ops);
1100 Chain = DAG.getNode(SPISD::CALL, dl, NodeTys, Ops);
1103 Chain = DAG.getCALLSEQ_END(Chain, ArgsSize, 0, InGlue, dl);
1108 CCState RVInfo(CallConv, isVarArg, DAG.getMachineFunction(), RVLocs,
1109 *DAG.getContext());
1117 SDValue Vec = DAG.getNode(ISD::UNDEF, dl, MVT::v2i32);
1118 SDValue Lo = DAG.getCopyFromReg(
1122 Vec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v2i32, Vec, Lo,
1123 DAG.getConstant(0, dl, MVT::i32));
1124 SDValue Hi = DAG.getCopyFromReg(
1128 Vec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v2i32, Vec, Hi,
1129 DAG.getConstant(1, dl, MVT::i32));
1133 DAG.getCopyFromReg(Chain, dl, toCallerWindow(RVLocs[i].getLocReg()),
1225 SelectionDAG &DAG = CLI.DAG;
1228 auto PtrVT = getPointerTy(DAG.getDataLayout());
1229 MachineFunction &MF = DAG.getMachineFunction();
1233 CCState CCInfo(CLI.CallConv, CLI.IsVarArg, DAG.getMachineFunction(), ArgLocs,
1234 *DAG.getContext());
1238 CCInfo, CLI, DAG.getMachineFunction());
1260 Chain = DAG.getCALLSEQ_START(Chain, ArgsSize, 0, DL);
1283 Arg = DAG.getNode(ISD::SIGN_EXTEND, DL, VA.getLocVT(), Arg);
1286 Arg = DAG.getNode(ISD::ZERO_EXTEND, DL, VA.getLocVT(), Arg);
1289 Arg = DAG.getNode(ISD::ANY_EXTEND, DL, VA.getLocVT(), Arg);
1296 Arg = DAG.getNode(ISD::BITCAST, DL, VA.getLocVT(), Arg);
1306 SDValue StackPtr = DAG.getRegister(SP::O6, PtrVT);
1307 SDValue HiPtrOff = DAG.getIntPtrConstant(StackOffset, DL);
1308 HiPtrOff = DAG.getNode(ISD::ADD, DL, PtrVT, StackPtr, HiPtrOff);
1309 SDValue LoPtrOff = DAG.getIntPtrConstant(StackOffset + 8, DL);
1310 LoPtrOff = DAG.getNode(ISD::ADD, DL, PtrVT, StackPtr, LoPtrOff);
1314 DAG.getStore(Chain, DL, Arg, HiPtrOff, MachinePointerInfo());
1317 DAG.getLoad(MVT::i64, DL, Store, HiPtrOff, MachinePointerInfo());
1319 DAG.getLoad(MVT::i64, DL, Store, LoPtrOff, MachinePointerInfo());
1336 Arg = DAG.getNode(ISD::SHL, DL, MVT::i64, Arg,
1337 DAG.getConstant(32, DL, MVT::i32));
1343 SDValue NV = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i64,
1345 Arg = DAG.getNode(ISD::OR, DL, MVT::i64, Arg, NV);
1361 SDValue StackPtr = DAG.getRegister(SP::O6, PtrVT);
1364 SDValue PtrOff = DAG.getIntPtrConstant(VA.getLocMemOffset() +
1367 PtrOff = DAG.getNode(ISD::ADD, DL, PtrVT, StackPtr, PtrOff);
1369 DAG.getStore(Chain, DL, Arg, PtrOff, MachinePointerInfo()));
1374 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOpChains);
1382 Chain = DAG.getCopyToReg(Chain, DL,
1391 bool hasReturnsTwice = hasReturnsTwiceAttr(DAG, Callee, CLI.CB);
1395 Callee = DAG.getTargetGlobalAddress(G->getGlobal(), DL, PtrVT, 0, TF);
1397 Callee = DAG.getTargetExternalSymbol(E->getSymbol(), PtrVT, TF);
1404 Ops.push_back(DAG.getRegister(RegsToPass[i].first,
1411 : TRI->getCallPreservedMask(DAG.getMachineFunction(),
1418 Ops.push_back(DAG.getRegisterMask(Mask));
1427 DAG.getMachineFunction().getFrameInfo().setHasTailCall();
1428 return DAG.getNode(SPISD::TAIL_CALL, DL, MVT::Other, Ops);
1430 SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
1431 Chain = DAG.getNode(SPISD::CALL, DL, NodeTys, Ops);
1435 Chain = DAG.getCALLSEQ_END(Chain, ArgsSize, 0, InGlue, DL);
1443 CCState RVInfo(CLI.CallConv, CLI.IsVarArg, DAG.getMachineFunction(), RVLocs,
1444 *DAG.getContext());
1469 RV = DAG.getCopyFromReg(Chain, DL, Reg, RVLocs[i].getLocVT(), InGlue);
1476 RV = DAG.getNode(ISD::SRL, DL, VA.getLocVT(), RV,
1477 DAG.getConstant(32, DL, MVT::i32));
1483 RV = DAG.getNode(ISD::AssertSext, DL, VA.getLocVT(), RV,
1484 DAG.getValueType(VA.getValVT()));
1487 RV = DAG.getNode(ISD::AssertZext, DL, VA.getLocVT(), RV,
1488 DAG.getValueType(VA.getValVT()));
1496 RV = DAG.getNode(ISD::TRUNCATE, DL, VA.getValVT(), RV);
1516 /// intCondCCodeToRcond - Convert a DAG integer condition code to a SPARC
1537 /// IntCondCCodeToICC - Convert a DAG integer condition code to a SPARC ICC
1555 /// FPCondCCodeToFCC - Convert a DAG floatingp oint condition code to a SPARC
2044 /// be zero. Op is expected to be a target specific node. Used by DAG
2050 const SelectionDAG &DAG,
2060 Known = DAG.computeKnownBits(Op.getOperand(1), Depth + 1);
2061 Known2 = DAG.computeKnownBits(Op.getOperand(0), Depth + 1);
2090 SelectionDAG &DAG) const {
2092 return DAG.getTargetGlobalAddress(GA->getGlobal(),
2098 return DAG.getTargetConstantPool(CP->getConstVal(), CP->getValueType(0),
2102 return DAG.getTargetBlockAddress(BA->getBlockAddress(),
2108 return DAG.getTargetExternalSymbol(ES->getSymbol(),
2118 SelectionDAG &DAG) const {
2121 SDValue Hi = DAG.getNode(SPISD::Hi, DL, VT, withTargetFlags(Op, HiTF, DAG));
2122 SDValue Lo = DAG.getNode(SPISD::Lo, DL, VT, withTargetFlags(Op, LoTF, DAG));
2123 return DAG.getNode(ISD::ADD, DL, VT, Hi, Lo);
2128 SDValue SparcTargetLowering::makeAddress(SDValue Op, SelectionDAG &DAG) const {
2130 EVT VT = getPointerTy(DAG.getDataLayout());
2134 const Module *M = DAG.getMachineFunction().getFunction().getParent();
2140 Idx = DAG.getNode(SPISD::Lo, DL, Op.getValueType(),
2141 withTargetFlags(Op, SparcMCExpr::VK_Sparc_GOT13, DAG));
2145 SparcMCExpr::VK_Sparc_GOT10, DAG);
2148 SDValue GlobalBase = DAG.getNode(SPISD::GLOBAL_BASE_REG, DL, VT);
2149 SDValue AbsAddr = DAG.getNode(ISD::ADD, DL, VT, GlobalBase, Idx);
2152 MachineFrameInfo &MFI = DAG.getMachineFunction().getFrameInfo();
2154 return DAG.getLoad(VT, DL, DAG.getEntryNode(), AbsAddr,
2155 MachinePointerInfo::getGOT(DAG.getMachineFunction()));
2165 SparcMCExpr::VK_Sparc_LO, DAG);
2169 SparcMCExpr::VK_Sparc_M44, DAG);
2170 H44 = DAG.getNode(ISD::SHL, DL, VT, H44, DAG.getConstant(12, DL, MVT::i32));
2171 SDValue L44 = withTargetFlags(Op, SparcMCExpr::VK_Sparc_L44, DAG);
2172 L44 = DAG.getNode(SPISD::Lo, DL, VT, L44);
2173 return DAG.getNode(ISD::ADD, DL, VT, H44, L44);
2178 SparcMCExpr::VK_Sparc_HM, DAG);
2179 Hi = DAG.getNode(ISD::SHL, DL, VT, Hi, DAG.getConstant(32, DL, MVT::i32));
2181 SparcMCExpr::VK_Sparc_LO, DAG);
2182 return DAG.getNode(ISD::ADD, DL, VT, Hi, Lo);
2188 SelectionDAG &DAG) const {
2189 return makeAddress(Op, DAG);
2193 SelectionDAG &DAG) const {
2194 return makeAddress(Op, DAG);
2198 SelectionDAG &DAG) const {
2199 return makeAddress(Op, DAG);
2203 SelectionDAG &DAG) const {
2206 if (DAG.getTarget().useEmulatedTLS())
2207 return LowerToTLSEmulatedModel(GA, DAG);
2211 EVT PtrVT = getPointerTy(DAG.getDataLayout());
2229 SDValue HiLo = makeHiLoPair(Op, HiTF, LoTF, DAG);
2230 SDValue Base = DAG.getNode(SPISD::GLOBAL_BASE_REG, DL, PtrVT);
2231 SDValue Argument = DAG.getNode(SPISD::TLS_ADD, DL, PtrVT, Base, HiLo,
2232 withTargetFlags(Op, addTF, DAG));
2234 SDValue Chain = DAG.getEntryNode();
2237 Chain = DAG.getCALLSEQ_START(Chain, 1, 0, DL);
2238 Chain = DAG.getCopyToReg(Chain, DL, SP::O0, Argument, InGlue);
2240 SDValue Callee = DAG.getTargetExternalSymbol("__tls_get_addr", PtrVT);
2241 SDValue Symbol = withTargetFlags(Op, callTF, DAG);
2243 SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
2245 DAG.getMachineFunction(), CallingConv::C);
2250 DAG.getRegister(SP::O0, PtrVT),
2251 DAG.getRegisterMask(Mask),
2253 Chain = DAG.getNode(SPISD::TLS_CALL, DL, NodeTys, Ops);
2255 Chain = DAG.getCALLSEQ_END(Chain, 1, 0, InGlue, DL);
2257 SDValue Ret = DAG.getCopyFromReg(Chain, DL, SP::O0, PtrVT, InGlue);
2262 SDValue Hi = DAG.getNode(SPISD::Hi, DL, PtrVT,
2263 withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LDO_HIX22, DAG));
2264 SDValue Lo = DAG.getNode(SPISD::Lo, DL, PtrVT,
2265 withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LDO_LOX10, DAG));
2266 HiLo = DAG.getNode(ISD::XOR, DL, PtrVT, Hi, Lo);
2267 return DAG.getNode(SPISD::TLS_ADD, DL, PtrVT, Ret, HiLo,
2268 withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LDO_ADD, DAG));
2275 SDValue Base = DAG.getNode(SPISD::GLOBAL_BASE_REG, DL, PtrVT);
2279 MachineFrameInfo &MFI = DAG.getMachineFunction().getFrameInfo();
2284 SparcMCExpr::VK_Sparc_TLS_IE_LO10, DAG);
2285 SDValue Ptr = DAG.getNode(ISD::ADD, DL, PtrVT, Base, TGA);
2286 SDValue Offset = DAG.getNode(SPISD::TLS_LD,
2288 withTargetFlags(Op, ldTF, DAG));
2289 return DAG.getNode(SPISD::TLS_ADD, DL, PtrVT,
2290 DAG.getRegister(SP::G7, PtrVT), Offset,
2292 SparcMCExpr::VK_Sparc_TLS_IE_ADD, DAG));
2296 SDValue Hi = DAG.getNode(SPISD::Hi, DL, PtrVT,
2297 withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LE_HIX22, DAG));
2298 SDValue Lo = DAG.getNode(SPISD::Lo, DL, PtrVT,
2299 withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LE_LOX10, DAG));
2300 SDValue Offset = DAG.getNode(ISD::XOR, DL, PtrVT, Hi, Lo);
2302 return DAG.getNode(ISD::ADD, DL, PtrVT,
2303 DAG.getRegister(SP::G7, PtrVT), Offset);
2309 SelectionDAG &DAG) const {
2310 MachineFrameInfo &MFI = DAG.getMachineFunction().getFrameInfo();
2312 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
2321 SDValue FIPtr = DAG.getFrameIndex(FI, getPointerTy(DAG.getDataLayout()));
2322 Chain = DAG.getStore(Chain, DL, Entry.Node, FIPtr, MachinePointerInfo(),
2333 SparcTargetLowering::LowerF128Op(SDValue Op, SelectionDAG &DAG,
2339 MachineFrameInfo &MFI = DAG.getMachineFunction().getFrameInfo();
2340 auto PtrVT = getPointerTy(DAG.getDataLayout());
2342 SDValue Callee = DAG.getExternalSymbol(LibFuncName, PtrVT);
2343 Type *RetTy = Op.getValueType().getTypeForEVT(*DAG.getContext());
2345 SDValue Chain = DAG.getEntryNode();
2352 RetPtr = DAG.getFrameIndex(RetFI, PtrVT);
2361 RetTyABI = Type::getVoidTy(*DAG.getContext());
2366 Chain = LowerF128_LibCallArg(Chain, Args, Op.getOperand(i), SDLoc(Op), DAG);
2368 TargetLowering::CallLoweringInfo CLI(DAG);
2383 return DAG.getLoad(Op.getValueType(), SDLoc(Op), Chain, RetPtr,
2389 SelectionDAG &DAG) const {
2411 auto PtrVT = getPointerTy(DAG.getDataLayout());
2412 SDValue Callee = DAG.getExternalSymbol(LibCall, PtrVT);
2413 Type *RetTy = Type::getInt32Ty(*DAG.getContext());
2415 SDValue Chain = DAG.getEntryNode();
2416 Chain = LowerF128_LibCallArg(Chain, Args, LHS, DL, DAG);
2417 Chain = LowerF128_LibCallArg(Chain, Args, RHS, DL, DAG);
2419 TargetLowering::CallLoweringInfo CLI(DAG);
2430 SDValue RHS = DAG.getConstant(0, DL, Result.getValueType());
2432 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2435 SDValue Mask = DAG.getConstant(1, DL, Result.getValueType());
2436 Result = DAG.getNode(ISD::AND, DL, Result.getValueType(), Result, Mask);
2437 SDValue RHS = DAG.getConstant(0, DL, Result.getValueType());
2439 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2442 SDValue RHS = DAG.getConstant(2, DL, Result.getValueType());
2444 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2447 SDValue RHS = DAG.getConstant(1, DL, Result.getValueType());
2449 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2452 SDValue RHS = DAG.getConstant(1, DL, Result.getValueType());
2454 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2458 SDValue RHS = DAG.getConstant(3, DL, Result.getValueType());
2460 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2463 SDValue RHS = DAG.getConstant(3, DL, Result.getValueType());
2465 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2468 SDValue Mask = DAG.getConstant(3, DL, Result.getValueType());
2469 Result = DAG.getNode(ISD::AND, DL, Result.getValueType(), Result, Mask);
2470 SDValue RHS = DAG.getConstant(0, DL, Result.getValueType());
2472 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2475 SDValue Mask = DAG.getConstant(3, DL, Result.getValueType());
2476 Result = DAG.getNode(ISD::AND, DL, Result.getValueType(), Result, Mask);
2477 SDValue RHS = DAG.getConstant(0, DL, Result.getValueType());
2479 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2485 LowerF128_FPEXTEND(SDValue Op, SelectionDAG &DAG,
2489 return TLI.LowerF128Op(Op, DAG,
2493 return TLI.LowerF128Op(Op, DAG,
2501 LowerF128_FPROUND(SDValue Op, SelectionDAG &DAG,
2508 return TLI.LowerF128Op(Op, DAG,
2511 return TLI.LowerF128Op(Op, DAG,
2518 static SDValue LowerFP_TO_SINT(SDValue Op, SelectionDAG &DAG,
2531 return TLI.LowerF128Op(Op, DAG, libName, 1);
2540 Op = DAG.getNode(SPISD::FTOI, dl, MVT::f32, Op.getOperand(0));
2542 Op = DAG.getNode(SPISD::FTOX, dl, MVT::f64, Op.getOperand(0));
2544 return DAG.getNode(ISD::BITCAST, dl, VT, Op);
2547 static SDValue LowerSINT_TO_FP(SDValue Op, SelectionDAG &DAG,
2562 return TLI.LowerF128Op(Op, DAG, libName, 1);
2570 SDValue Tmp = DAG.getNode(ISD::BITCAST, dl, floatVT, Op.getOperand(0));
2572 return DAG.getNode(opcode, dl, Op.getValueType(), Tmp);
2575 static SDValue LowerFP_TO_UINT(SDValue Op, SelectionDAG &DAG,
2589 return TLI.LowerF128Op(Op, DAG,
2596 static SDValue LowerUINT_TO_FP(SDValue Op, SelectionDAG &DAG,
2608 return TLI.LowerF128Op(Op, DAG,
2615 static SDValue LowerBR_CC(SDValue Op, SelectionDAG &DAG,
2638 return DAG.getNode(SPISD::BR_REG, dl, MVT::Other, Chain, Dest,
2639 DAG.getConstant(intCondCCodeToRcond(CC), dl, MVT::i32),
2642 CompareFlag = DAG.getNode(SPISD::CMPICC, dl, MVT::Glue, LHS, RHS);
2653 CompareFlag = TLI.LowerF128Compare(LHS, RHS, SPCC, dl, DAG);
2657 CompareFlag = DAG.getNode(CmpOpc, dl, MVT::Glue, LHS, RHS);
2662 return DAG.getNode(Opc, dl, MVT::Other, Chain, Dest,
2663 DAG.getConstant(SPCC, dl, MVT::i32), CompareFlag);
2666 static SDValue LowerSELECT_CC(SDValue Op, SelectionDAG &DAG,
2696 return DAG.getNode(
2698 DAG.getConstant(intCondCCodeToRcond(CC), dl, MVT::i32), LHS);
2700 CompareFlag = DAG.getNode(SPISD::CMPICC, dl, MVT::Glue, LHS, RHS);
2707 CompareFlag = TLI.LowerF128Compare(LHS, RHS, SPCC, dl, DAG);
2711 CompareFlag = DAG.getNode(CmpOpc, dl, MVT::Glue, LHS, RHS);
2716 return DAG.getNode(Opc, dl, TrueVal.getValueType(), TrueVal, FalseVal,
2717 DAG.getConstant(SPCC, dl, MVT::i32), CompareFlag);
2720 static SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG,
2722 MachineFunction &MF = DAG.getMachineFunction();
2724 auto PtrVT = TLI.getPointerTy(DAG.getDataLayout());
2733 DAG.getNode(ISD::ADD, DL, PtrVT, DAG.getRegister(SP::I6, PtrVT),
2734 DAG.getIntPtrConstant(FuncInfo->getVarArgsFrameOffset(), DL));
2736 return DAG.getStore(Op.getOperand(0), DL, Offset, Op.getOperand(1),
2740 static SDValue LowerVAARG(SDValue Op, SelectionDAG &DAG) {
2749 DAG.getLoad(PtrVT, DL, InChain, VAListPtr, MachinePointerInfo(SV));
2751 SDValue NextPtr = DAG.getNode(ISD::ADD, DL, PtrVT, VAList,
2752 DAG.getIntPtrConstant(VT.getSizeInBits()/8,
2755 InChain = DAG.getStore(VAList.getValue(1), DL, NextPtr, VAListPtr,
2759 return DAG.getLoad(
2764 static SDValue LowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG,
2775 SDValue SP = DAG.getCopyFromReg(Chain, dl, SPReg, VT);
2804 Size = DAG.getNode(ISD::ADD, dl, VT, Size,
2805 DAG.getConstant(8, dl, VT));
2815 SDValue StartOfUsableStack = DAG.getNode(
2816 ISD::ADD, dl, VT, SP, DAG.getConstant(regSpillArea + Bias, dl, VT));
2818 DAG.getNode(ISD::SUB, dl, VT, StartOfUsableStack, Size);
2823 ? DAG.getNode(ISD::AND, dl, VT, AllocatedPtr,
2824 DAG.getSignedConstant(-MaybeAlignment->value(), dl, VT))
2828 SDValue NewSP = DAG.getNode(ISD::SUB, dl, VT, AlignedPtr,
2829 DAG.getConstant(regSpillArea + Bias, dl, VT));
2830 Chain = DAG.getCopyToReg(SP.getValue(1), dl, SPReg, NewSP);
2832 return DAG.getMergeValues(Ops, dl);
2836 static SDValue getFLUSHW(SDValue Op, SelectionDAG &DAG) {
2838 SDValue Chain = DAG.getNode(SPISD::FLUSHW,
2839 dl, MVT::Other, DAG.getEntryNode());
2843 static SDValue getFRAMEADDR(uint64_t depth, SDValue Op, SelectionDAG &DAG,
2846 MachineFrameInfo &MFI = DAG.getMachineFunction().getFrameInfo();
2858 Chain = (depth || AlwaysFlush) ? getFLUSHW(Op, DAG) : DAG.getEntryNode();
2860 FrameAddr = DAG.getCopyFromReg(Chain, dl, FrameReg, VT);
2865 SDValue Ptr = DAG.getNode(ISD::ADD, dl, VT, FrameAddr,
2866 DAG.getIntPtrConstant(Offset, dl));
2867 FrameAddr = DAG.getLoad(VT, dl, Chain, Ptr, MachinePointerInfo());
2870 FrameAddr = DAG.getNode(ISD::ADD, dl, VT, FrameAddr,
2871 DAG.getIntPtrConstant(stackBias, dl));
2876 static SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG,
2881 return getFRAMEADDR(depth, Op, DAG, Subtarget);
2885 static SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG,
2888 MachineFunction &MF = DAG.getMachineFunction();
2892 if (TLI.verifyReturnAddressArgumentIsConstant(Op, DAG))
2901 auto PtrVT = TLI.getPointerTy(DAG.getDataLayout());
2903 RetAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl, RetReg, VT);
2908 SDValue FrameAddr = getFRAMEADDR(depth - 1, Op, DAG, Subtarget, true);
2911 SDValue Ptr = DAG.getNode(ISD::ADD,
2914 DAG.getIntPtrConstant(Offset, dl));
2915 RetAddr = DAG.getLoad(VT, dl, DAG.getEntryNode(), Ptr, MachinePointerInfo());
2920 static SDValue LowerF64Op(SDValue SrcReg64, const SDLoc &dl, SelectionDAG &DAG,
2934 SDValue Hi32 = DAG.getTargetExtractSubreg(SP::sub_even, dl, MVT::f32,
2936 SDValue Lo32 = DAG.getTargetExtractSubreg(SP::sub_odd, dl, MVT::f32,
2939 if (DAG.getDataLayout().isLittleEndian())
2940 Lo32 = DAG.getNode(opcode, dl, MVT::f32, Lo32);
2942 Hi32 = DAG.getNode(opcode, dl, MVT::f32, Hi32);
2944 SDValue DstReg64 = SDValue(DAG.getMachineNode(TargetOpcode::IMPLICIT_DEF,
2946 DstReg64 = DAG.getTargetInsertSubreg(SP::sub_even, dl, MVT::f64,
2948 DstReg64 = DAG.getTargetInsertSubreg(SP::sub_odd, dl, MVT::f64,
2954 static SDValue LowerF128Load(SDValue Op, SelectionDAG &DAG)
2963 DAG.getLoad(MVT::f64, dl, LdNode->getChain(), LdNode->getBasePtr(),
2966 SDValue LoPtr = DAG.getNode(ISD::ADD, dl, addrVT,
2968 DAG.getConstant(8, dl, addrVT));
2969 SDValue Lo64 = DAG.getLoad(MVT::f64, dl, LdNode->getChain(), LoPtr,
2973 SDValue SubRegEven = DAG.getTargetConstant(SP::sub_even64, dl, MVT::i32);
2974 SDValue SubRegOdd = DAG.getTargetConstant(SP::sub_odd64, dl, MVT::i32);
2976 SDNode *InFP128 = DAG.getMachineNode(TargetOpcode::IMPLICIT_DEF,
2978 InFP128 = DAG.getMachineNode(TargetOpcode::INSERT_SUBREG, dl,
2983 InFP128 = DAG.getMachineNode(TargetOpcode::INSERT_SUBREG, dl,
2990 SDValue OutChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
2992 return DAG.getMergeValues(Ops, dl);
2995 static SDValue LowerLOAD(SDValue Op, SelectionDAG &DAG)
3001 return LowerF128Load(Op, DAG);
3007 static SDValue LowerF128Store(SDValue Op, SelectionDAG &DAG) {
3012 SDValue SubRegEven = DAG.getTargetConstant(SP::sub_even64, dl, MVT::i32);
3013 SDValue SubRegOdd = DAG.getTargetConstant(SP::sub_odd64, dl, MVT::i32);
3015 SDNode *Hi64 = DAG.getMachineNode(TargetOpcode::EXTRACT_SUBREG,
3020 SDNode *Lo64 = DAG.getMachineNode(TargetOpcode::EXTRACT_SUBREG,
3030 DAG.getStore(StNode->getChain(), dl, SDValue(Hi64, 0),
3034 SDValue LoPtr = DAG.getNode(ISD::ADD, dl, addrVT,
3036 DAG.getConstant(8, dl, addrVT));
3037 OutChains[1] = DAG.getStore(StNode->getChain(), dl, SDValue(Lo64, 0), LoPtr,
3040 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
3043 static SDValue LowerSTORE(SDValue Op, SelectionDAG &DAG)
3050 return LowerF128Store(Op, DAG);
3055 SDValue Val = DAG.getNode(ISD::BITCAST, dl, MVT::v2i32, St->getValue());
3056 SDValue Chain = DAG.getStore(
3066 static SDValue LowerFNEGorFABS(SDValue Op, SelectionDAG &DAG, bool isV9) {
3073 return LowerF64Op(Op.getOperand(0), dl, DAG, Op.getOpcode());
3083 SDValue Hi64 = DAG.getTargetExtractSubreg(SP::sub_even64, dl, MVT::f64,
3085 SDValue Lo64 = DAG.getTargetExtractSubreg(SP::sub_odd64, dl, MVT::f64,
3088 if (DAG.getDataLayout().isLittleEndian()) {
3090 Lo64 = DAG.getNode(Op.getOpcode(), dl, MVT::f64, Lo64);
3092 Lo64 = LowerF64Op(Lo64, dl, DAG, Op.getOpcode());
3095 Hi64 = DAG.getNode(Op.getOpcode(), dl, MVT::f64, Hi64);
3097 Hi64 = LowerF64Op(Hi64, dl, DAG, Op.getOpcode());
3100 SDValue DstReg128 = SDValue(DAG.getMachineNode(TargetOpcode::IMPLICIT_DEF,
3102 DstReg128 = DAG.getTargetInsertSubreg(SP::sub_even64, dl, MVT::f128,
3104 DstReg128 = DAG.getTargetInsertSubreg(SP::sub_odd64, dl, MVT::f128,
3109 static SDValue LowerATOMIC_LOAD_STORE(SDValue Op, SelectionDAG &DAG) {
3120 SelectionDAG &DAG) const {
3126 EVT PtrVT = getPointerTy(DAG.getDataLayout());
3127 return DAG.getRegister(SP::G7, PtrVT);
3133 LowerOperation(SDValue Op, SelectionDAG &DAG) const {
3142 case ISD::RETURNADDR: return LowerRETURNADDR(Op, DAG, *this,
3144 case ISD::FRAMEADDR: return LowerFRAMEADDR(Op, DAG,
3146 case ISD::GlobalTLSAddress: return LowerGlobalTLSAddress(Op, DAG);
3147 case ISD::GlobalAddress: return LowerGlobalAddress(Op, DAG);
3148 case ISD::BlockAddress: return LowerBlockAddress(Op, DAG);
3149 case ISD::ConstantPool: return LowerConstantPool(Op, DAG);
3150 case ISD::FP_TO_SINT: return LowerFP_TO_SINT(Op, DAG, *this,
3152 case ISD::SINT_TO_FP: return LowerSINT_TO_FP(Op, DAG, *this,
3154 case ISD::FP_TO_UINT: return LowerFP_TO_UINT(Op, DAG, *this,
3156 case ISD::UINT_TO_FP: return LowerUINT_TO_FP(Op, DAG, *this,
3159 return LowerBR_CC(Op, DAG, *this, hasHardQuad, isV9, is64Bit);
3161 return LowerSELECT_CC(Op, DAG, *this, hasHardQuad, isV9, is64Bit);
3162 case ISD::VASTART: return LowerVASTART(Op, DAG, *this);
3163 case ISD::VAARG: return LowerVAARG(Op, DAG);
3164 case ISD::DYNAMIC_STACKALLOC: return LowerDYNAMIC_STACKALLOC(Op, DAG,
3167 case ISD::LOAD: return LowerLOAD(Op, DAG);
3168 case ISD::STORE: return LowerSTORE(Op, DAG);
3169 case ISD::FADD: return LowerF128Op(Op, DAG,
3171 case ISD::FSUB: return LowerF128Op(Op, DAG,
3173 case ISD::FMUL: return LowerF128Op(Op, DAG,
3175 case ISD::FDIV: return LowerF128Op(Op, DAG,
3177 case ISD::FSQRT: return LowerF128Op(Op, DAG,
3180 case ISD::FNEG: return LowerFNEGorFABS(Op, DAG, isV9);
3181 case ISD::FP_EXTEND: return LowerF128_FPEXTEND(Op, DAG, *this);
3182 case ISD::FP_ROUND: return LowerF128_FPROUND(Op, DAG, *this);
3184 case ISD::ATOMIC_STORE: return LowerATOMIC_LOAD_STORE(Op, DAG);
3185 case ISD::INTRINSIC_WO_CHAIN: return LowerINTRINSIC_WO_CHAIN(Op, DAG);
3191 SelectionDAG &DAG) const {
3193 SDValue Lo = DAG.getConstant(V.zextOrTrunc(32), DL, MVT::i32);
3194 SDValue Hi = DAG.getConstant(V.lshr(32).zextOrTrunc(32), DL, MVT::i32);
3195 if (DAG.getDataLayout().isLittleEndian())
3197 return DAG.getBuildVector(MVT::v2i32, DL, {Hi, Lo});
3207 return bitcastConstantFPToInt(cast<ConstantFPSDNode>(Src), dl, DCI.DAG);
3358 SelectionDAG &DAG) const {
3371 Result = DAG.getSignedTargetConstant(C->getSExtValue(), SDLoc(Op),
3383 TargetLowering::LowerAsmOperandForConstraint(Op, Constraint, Ops, DAG);
3485 SelectionDAG &DAG) const {
3506 DAG,
3512 SDValue Lo = DAG.getCopyFromReg(N->getOperand(0), dl, SP::ASR23, MVT::i32);
3513 SDValue Hi = DAG.getCopyFromReg(Lo, dl, SP::G0, MVT::i32);
3515 SDValue Pair = DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Ops);
3532 DAG,
3544 SDValue LoadRes = DAG.getExtLoad(
3550 SDValue Res = DAG.getNode(ISD::BITCAST, dl, MVT::i64, LoadRes);