Lines Matching defs:DAG
1 //===-- PPCISelLowering.cpp - PPC DAG Lowering Implementation -------------===//
639 // We have target-specific dag combine patterns for the following nodes:
857 SelectionDAG &DAG) {
858 unsigned j = DAG.getTarget().getDataLayout()->isLittleEndian() ? 0 : 1;
875 SelectionDAG &DAG) {
877 if (DAG.getTarget().getDataLayout()->isLittleEndian()) {
923 bool isUnary, SelectionDAG &DAG) {
924 if (DAG.getTarget().getDataLayout()->isLittleEndian()) {
938 bool isUnary, SelectionDAG &DAG) {
939 if (DAG.getTarget().getDataLayout()->isLittleEndian()) {
953 int PPC::isVSLDOIShuffleMask(SDNode *N, bool isUnary, SelectionDAG &DAG) {
971 if (DAG.getTarget().getDataLayout()->isLittleEndian()) {
1055 SelectionDAG &DAG) {
1058 if (DAG.getTarget().getDataLayout()->isLittleEndian())
1068 SDValue PPC::get_VSPLTI_elt(SDNode *N, unsigned ByteSize, SelectionDAG &DAG) {
1111 return DAG.getTargetConstant(0, MVT::i32); // 0,0,0,undef
1114 return DAG.getTargetConstant(Val, MVT::i32); // 0,0,0,4 -> vspltisw(4)
1118 return DAG.getTargetConstant(~0U, MVT::i32); // -1,-1,-1,undef
1121 return DAG.getTargetConstant(Val, MVT::i32);
1172 return DAG.getTargetConstant(MaskVal, MVT::i32);
1204 SelectionDAG &DAG) const {
1224 DAG.computeKnownBits(N.getOperand(0),
1228 DAG.computeKnownBits(N.getOperand(1),
1251 static void fixupFuncForFI(SelectionDAG &DAG, int FrameIdx, EVT VT) {
1272 MachineFunction &MF = DAG.getMachineFunction();
1289 SelectionDAG &DAG,
1294 if (SelectAddressRegReg(N, Disp, Base, DAG))
1301 Disp = DAG.getTargetConstant(imm, N.getValueType());
1303 Base = DAG.getTargetFrameIndex(FI->getIndex(), N.getValueType());
1304 fixupFuncForFI(DAG, FI->getIndex(), N.getValueType());
1329 DAG.computeKnownBits(N.getOperand(0), LHSKnownZero, LHSKnownOne);
1335 Disp = DAG.getTargetConstant(imm, N.getValueType());
1346 Disp = DAG.getTargetConstant(Imm, CN->getValueType(0));
1347 Base = DAG.getRegister(Subtarget.isPPC64() ? PPC::ZERO8 : PPC::ZERO,
1359 Disp = DAG.getTargetConstant((short)Addr, MVT::i32);
1361 Base = DAG.getTargetConstant((Addr - (signed short)Addr) >> 16, MVT::i32);
1363 Base = SDValue(DAG.getMachineNode(Opc, dl, CN->getValueType(0), Base), 0);
1368 Disp = DAG.getTargetConstant(0, getPointerTy());
1370 Base = DAG.getTargetFrameIndex(FI->getIndex(), N.getValueType());
1371 fixupFuncForFI(DAG, FI->getIndex(), N.getValueType());
1381 SelectionDAG &DAG) const {
1385 if (SelectAddressRegReg(N, Base, Index, DAG))
1398 Base = DAG.getRegister(Subtarget.isPPC64() ? PPC::ZERO8 : PPC::ZERO,
1410 SelectionDAG &DAG) const {
1433 if (SelectAddressRegReg(Ptr, Base, Offset, DAG)) {
1458 if (!SelectAddressRegImm(Ptr, Offset, Base, DAG, false))
1465 if (!SelectAddressRegImm(Ptr, Offset, Base, DAG, true))
1519 SelectionDAG &DAG) {
1521 SDValue Zero = DAG.getConstant(0, PtrVT);
1524 SDValue Hi = DAG.getNode(PPCISD::Hi, DL, PtrVT, HiPart, Zero);
1525 SDValue Lo = DAG.getNode(PPCISD::Lo, DL, PtrVT, LoPart, Zero);
1529 Hi = DAG.getNode(ISD::ADD, DL, PtrVT,
1530 DAG.getNode(PPCISD::GlobalBaseReg, DL, PtrVT), Hi);
1534 return DAG.getNode(ISD::ADD, DL, PtrVT, Hi, Lo);
1538 SelectionDAG &DAG) const {
1546 SDValue GA = DAG.getTargetConstantPool(C, PtrVT, CP->getAlignment(), 0);
1547 return DAG.getNode(PPCISD::TOC_ENTRY, SDLoc(CP), MVT::i64, GA,
1548 DAG.getRegister(PPC::X2, MVT::i64));
1552 bool isPIC = GetLabelAccessInfo(DAG.getTarget(), MOHiFlag, MOLoFlag);
1554 DAG.getTargetConstantPool(C, PtrVT, CP->getAlignment(), 0, MOHiFlag);
1556 DAG.getTargetConstantPool(C, PtrVT, CP->getAlignment(), 0, MOLoFlag);
1557 return LowerLabelRef(CPIHi, CPILo, isPIC, DAG);
1560 SDValue PPCTargetLowering::LowerJumpTable(SDValue Op, SelectionDAG &DAG) const {
1567 SDValue GA = DAG.getTargetJumpTable(JT->getIndex(), PtrVT);
1568 return DAG.getNode(PPCISD::TOC_ENTRY, SDLoc(JT), MVT::i64, GA,
1569 DAG.getRegister(PPC::X2, MVT::i64));
1573 bool isPIC = GetLabelAccessInfo(DAG.getTarget(), MOHiFlag, MOLoFlag);
1574 SDValue JTIHi = DAG.getTargetJumpTable(JT->getIndex(), PtrVT, MOHiFlag);
1575 SDValue JTILo = DAG.getTargetJumpTable(JT->getIndex(), PtrVT, MOLoFlag);
1576 return LowerLabelRef(JTIHi, JTILo, isPIC, DAG);
1580 SelectionDAG &DAG) const {
1586 bool isPIC = GetLabelAccessInfo(DAG.getTarget(), MOHiFlag, MOLoFlag);
1587 SDValue TgtBAHi = DAG.getTargetBlockAddress(BA, PtrVT, 0, MOHiFlag);
1588 SDValue TgtBALo = DAG.getTargetBlockAddress(BA, PtrVT, 0, MOLoFlag);
1589 return LowerLabelRef(TgtBAHi, TgtBALo, isPIC, DAG);
1593 SelectionDAG &DAG) const {
1608 SDValue TGAHi = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0,
1610 SDValue TGALo = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0,
1612 SDValue TLSReg = DAG.getRegister(is64bit ? PPC::X13 : PPC::R2,
1614 SDValue Hi = DAG.getNode(PPCISD::Hi, dl, PtrVT, TGAHi, TLSReg);
1615 return DAG.getNode(PPCISD::Lo, dl, PtrVT, TGALo, Hi);
1619 SDValue TGA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0, 0);
1620 SDValue TGATLS = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0,
1624 SDValue GOTReg = DAG.getRegister(PPC::X2, MVT::i64);
1625 GOTPtr = DAG.getNode(PPCISD::ADDIS_GOT_TPREL_HA, dl,
1628 GOTPtr = DAG.getNode(PPCISD::PPC32_GOT, dl, PtrVT);
1629 SDValue TPOffset = DAG.getNode(PPCISD::LD_GOT_TPREL_L, dl,
1631 return DAG.getNode(PPCISD::ADD_TLS, dl, PtrVT, TPOffset, TGATLS);
1635 SDValue TGA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0, 0);
1636 SDValue GOTReg = DAG.getRegister(PPC::X2, MVT::i64);
1637 SDValue GOTEntryHi = DAG.getNode(PPCISD::ADDIS_TLSGD_HA, dl, PtrVT,
1639 SDValue GOTEntry = DAG.getNode(PPCISD::ADDI_TLSGD_L, dl, PtrVT,
1645 SDValue Chain = DAG.getEntryNode();
1646 Chain = DAG.getCopyToReg(Chain, dl, PPC::X3, GOTEntry);
1647 SDValue ParmReg = DAG.getRegister(PPC::X3, MVT::i64);
1648 SDValue TLSAddr = DAG.getNode(PPCISD::GET_TLS_ADDR, dl,
1653 Chain = DAG.getCopyToReg(Chain, dl, PPC::X3, TLSAddr);
1654 return DAG.getCopyFromReg(Chain, dl, PPC::X3, PtrVT);
1658 SDValue TGA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0, 0);
1659 SDValue GOTReg = DAG.getRegister(PPC::X2, MVT::i64);
1660 SDValue GOTEntryHi = DAG.getNode(PPCISD::ADDIS_TLSLD_HA, dl, PtrVT,
1662 SDValue GOTEntry = DAG.getNode(PPCISD::ADDI_TLSLD_L, dl, PtrVT,
1668 SDValue Chain = DAG.getEntryNode();
1669 Chain = DAG.getCopyToReg(Chain, dl, PPC::X3, GOTEntry);
1670 SDValue ParmReg = DAG.getRegister(PPC::X3, MVT::i64);
1671 SDValue TLSAddr = DAG.getNode(PPCISD::GET_TLSLD_ADDR, dl,
1676 Chain = DAG.getCopyToReg(Chain, dl, PPC::X3, TLSAddr);
1677 SDValue DtvOffsetHi = DAG.getNode(PPCISD::ADDIS_DTPREL_HA, dl, PtrVT,
1679 return DAG.getNode(PPCISD::ADDI_DTPREL_L, dl, PtrVT, DtvOffsetHi, TGA);
1686 SelectionDAG &DAG) const {
1695 SDValue GA = DAG.getTargetGlobalAddress(GV, DL, PtrVT, GSDN->getOffset());
1696 return DAG.getNode(PPCISD::TOC_ENTRY, DL, MVT::i64, GA,
1697 DAG.getRegister(PPC::X2, MVT::i64));
1701 bool isPIC = GetLabelAccessInfo(DAG.getTarget(), MOHiFlag, MOLoFlag, GV);
1704 DAG.getTargetGlobalAddress(GV, DL, PtrVT, GSDN->getOffset(), MOHiFlag);
1706 DAG.getTargetGlobalAddress(GV, DL, PtrVT, GSDN->getOffset(), MOLoFlag);
1708 SDValue Ptr = LowerLabelRef(GAHi, GALo, isPIC, DAG);
1713 Ptr = DAG.getLoad(PtrVT, DL, DAG.getEntryNode(), Ptr, MachinePointerInfo(),
1718 SDValue PPCTargetLowering::LowerSETCC(SDValue Op, SelectionDAG &DAG) const {
1729 return DAG.getNode(ISD::BITCAST, dl, MVT::v2i64,
1730 DAG.getSetCC(dl, MVT::v4i32,
1731 DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op.getOperand(0)),
1732 DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op.getOperand(1)),
1744 // implented as a ctlz/srl pair on ppc, so that the dag combiner can
1752 Zext = DAG.getNode(ISD::ZERO_EXTEND, dl, VT, Op.getOperand(0));
1755 SDValue Clz = DAG.getNode(ISD::CTLZ, dl, VT, Zext);
1756 SDValue Scc = DAG.getNode(ISD::SRL, dl, VT, Clz,
1757 DAG.getConstant(Log2b, MVT::i32));
1758 return DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Scc);
1775 SDValue Sub = DAG.getNode(ISD::XOR, dl, LHSVT, Op.getOperand(0),
1777 return DAG.getSetCC(dl, VT, Sub, DAG.getConstant(0, LHSVT), CC);
1782 SDValue PPCTargetLowering::LowerVAARG(SDValue Op, SelectionDAG &DAG,
1786 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
1795 SDValue GprIndex = DAG.getExtLoad(ISD::ZEXTLOAD, dl, MVT::i32, InChain,
1802 SDValue GprAnd = DAG.getNode(ISD::AND, dl, MVT::i32, GprIndex,
1803 DAG.getConstant(1, MVT::i32));
1804 SDValue CC64 = DAG.getSetCC(dl, MVT::i32, GprAnd,
1805 DAG.getConstant(0, MVT::i32), ISD::SETNE);
1806 SDValue GprIndexPlusOne = DAG.getNode(ISD::ADD, dl, MVT::i32, GprIndex,
1807 DAG.getConstant(1, MVT::i32));
1809 GprIndex = DAG.getNode(ISD::SELECT, dl, MVT::i32, CC64, GprIndexPlusOne,
1814 SDValue FprPtr = DAG.getNode(ISD::ADD, dl, PtrVT, VAListPtr,
1815 DAG.getConstant(1, MVT::i32));
1818 SDValue FprIndex = DAG.getExtLoad(ISD::ZEXTLOAD, dl, MVT::i32, InChain,
1823 SDValue RegSaveAreaPtr = DAG.getNode(ISD::ADD, dl, PtrVT, VAListPtr,
1824 DAG.getConstant(8, MVT::i32));
1826 SDValue OverflowAreaPtr = DAG.getNode(ISD::ADD, dl, PtrVT, VAListPtr,
1827 DAG.getConstant(4, MVT::i32));
1830 SDValue OverflowArea = DAG.getLoad(MVT::i32, dl, InChain, OverflowAreaPtr,
1835 SDValue RegSaveArea = DAG.getLoad(MVT::i32, dl, InChain, RegSaveAreaPtr,
1841 SDValue CC = DAG.getSetCC(dl, MVT::i32, VT.isInteger() ? GprIndex : FprIndex,
1842 DAG.getConstant(8, MVT::i32), ISD::SETLT);
1845 SDValue RegConstant = DAG.getNode(ISD::MUL, dl, MVT::i32,
1847 DAG.getConstant(VT.isInteger() ? 4 : 8,
1851 SDValue OurReg = DAG.getNode(ISD::ADD, dl, PtrVT, RegSaveArea,
1856 OurReg = DAG.getNode(ISD::ADD, dl, PtrVT, OurReg,
1857 DAG.getConstant(32, MVT::i32));
1860 SDValue IndexPlus1 = DAG.getNode(ISD::ADD, dl, MVT::i32,
1862 DAG.getConstant(VT == MVT::i64 ? 2 : 1,
1865 InChain = DAG.getTruncStore(InChain, dl, IndexPlus1,
1871 SDValue Result = DAG.getNode(ISD::SELECT, dl, PtrVT, CC, OurReg, OverflowArea);
1874 SDValue OverflowAreaPlusN = DAG.getNode(ISD::ADD, dl, PtrVT, OverflowArea,
1875 DAG.getConstant(VT.isInteger() ? 4 : 8,
1878 OverflowArea = DAG.getNode(ISD::SELECT, dl, MVT::i32, CC, OverflowArea,
1881 InChain = DAG.getTruncStore(InChain, dl, OverflowArea,
1886 return DAG.getLoad(VT, dl, InChain, Result, MachinePointerInfo(),
1890 SDValue PPCTargetLowering::LowerVACOPY(SDValue Op, SelectionDAG &DAG,
1896 return DAG.getMemcpy(Op.getOperand(0), Op,
1898 DAG.getConstant(12, MVT::i32), 8, false, true,
1903 SelectionDAG &DAG) const {
1908 SelectionDAG &DAG) const {
1915 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
1918 DAG.getTargetLoweringInfo().getDataLayout()->getIntPtrType(
1919 *DAG.getContext());
1928 Entry.Node = DAG.getConstant(isPPC64 ? 48 : 40,
1936 TargetLowering::CallLoweringInfo CLI(DAG);
1938 .setCallee(CallingConv::C, Type::getVoidTy(*DAG.getContext()),
1939 DAG.getExternalSymbol("__trampoline_setup", PtrVT),
1946 SDValue PPCTargetLowering::LowerVASTART(SDValue Op, SelectionDAG &DAG,
1948 MachineFunction &MF = DAG.getMachineFunction();
1956 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
1957 SDValue FR = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), PtrVT);
1959 return DAG.getStore(Op.getOperand(0), dl, FR, Op.getOperand(1),
1989 SDValue ArgGPR = DAG.getConstant(FuncInfo->getVarArgsNumGPR(), MVT::i32);
1990 SDValue ArgFPR = DAG.getConstant(FuncInfo->getVarArgsNumFPR(), MVT::i32);
1993 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
1995 SDValue StackOffsetFI = DAG.getFrameIndex(FuncInfo->getVarArgsStackOffset(),
1997 SDValue FR = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
2001 SDValue ConstFrameOffset = DAG.getConstant(FrameOffset, PtrVT);
2004 SDValue ConstStackOffset = DAG.getConstant(StackOffset, PtrVT);
2007 SDValue ConstFPROffset = DAG.getConstant(FPROffset, PtrVT);
2012 SDValue firstStore = DAG.getTruncStore(Op.getOperand(0), dl, ArgGPR,
2017 SDValue nextPtr = DAG.getNode(ISD::ADD, dl, PtrVT, Op.getOperand(1),
2022 DAG.getTruncStore(firstStore, dl, ArgFPR, nextPtr,
2026 nextPtr = DAG.getNode(ISD::ADD, dl, PtrVT, nextPtr, ConstStackOffset);
2030 DAG.getStore(secondStore, dl, StackOffsetFI, nextPtr,
2034 nextPtr = DAG.getNode(ISD::ADD, dl, PtrVT, nextPtr, ConstFrameOffset);
2037 return DAG.getStore(thirdStore, dl, FR, nextPtr,
2177 SDLoc dl, SelectionDAG &DAG,
2183 dl, DAG, InVals);
2186 dl, DAG, InVals);
2189 dl, DAG, InVals);
2199 SDLoc dl, SelectionDAG &DAG,
2231 MachineFunction &MF = DAG.getMachineFunction();
2235 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
2243 CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
2244 getTargetMachine(), ArgLocs, *DAG.getContext());
2290 SDValue ArgValue = DAG.getCopyFromReg(Chain, dl, Reg,
2294 ArgValue = DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, ArgValue);
2306 SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
2307 InVals.push_back(DAG.getLoad(VA.getValVT(), dl, Chain, FIN,
2317 CCState CCByValInfo(CallConv, isVarArg, DAG.getMachineFunction(),
2318 getTargetMachine(), ByValArgLocs, *DAG.getContext());
2367 SDValue FIN = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), PtrVT);
2378 SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
2379 SDValue Store = DAG.getStore(Val.getValue(1), dl, Val, FIN,
2383 SDValue PtrOff = DAG.getConstant(PtrVT.getSizeInBits()/8, PtrVT);
2384 FIN = DAG.getNode(ISD::ADD, dl, PtrOff.getValueType(), FIN, PtrOff);
2397 SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, MVT::f64);
2398 SDValue Store = DAG.getStore(Val.getValue(1), dl, Val, FIN,
2402 SDValue PtrOff = DAG.getConstant(EVT(MVT::f64).getSizeInBits()/8,
2404 FIN = DAG.getNode(ISD::ADD, dl, PtrOff.getValueType(), FIN, PtrOff);
2409 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
2418 SelectionDAG &DAG, SDValue ArgVal,
2421 ArgVal = DAG.getNode(ISD::AssertSext, dl, MVT::i64, ArgVal,
2422 DAG.getValueType(ObjectVT));
2424 ArgVal = DAG.getNode(ISD::AssertZext, dl, MVT::i64, ArgVal,
2425 DAG.getValueType(ObjectVT));
2427 return DAG.getNode(ISD::TRUNCATE, dl, ObjectVT, ArgVal);
2436 SDLoc dl, SelectionDAG &DAG,
2441 MachineFunction &MF = DAG.getMachineFunction();
2445 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
2476 // Add DAG nodes to load the arguments or copy them out of registers. On
2518 SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
2528 SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
2534 SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
2540 Store = DAG.getTruncStore(Val.getValue(1), dl, Val, FIN,
2551 SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
2552 Store = DAG.getStore(Val.getValue(1), dl, Val, FIN,
2573 SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
2574 SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
2575 SDValue Store = DAG.getStore(Val.getValue(1), dl, Val, FIN,
2596 ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, MVT::i64);
2601 ArgVal = extendArgForPPC64(Flags, ObjectVT, DAG, ArgVal, dl);
2621 ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, ObjectVT);
2640 ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, ObjectVT);
2655 SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
2656 ArgVal = DAG.getLoad(ObjectVT, dl, Chain, FIN, MachinePointerInfo(),
2681 SDValue FIN = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), PtrVT);
2689 SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
2690 SDValue Store = DAG.getStore(Val.getValue(1), dl, Val, FIN,
2694 SDValue PtrOff = DAG.getConstant(PtrByteSize, PtrVT);
2695 FIN = DAG.getNode(ISD::ADD, dl, PtrOff.getValueType(), FIN, PtrOff);
2700 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
2711 SDLoc dl, SelectionDAG &DAG,
2715 MachineFunction &MF = DAG.getMachineFunction();
2719 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
2805 // Add DAG nodes to load the arguments or copy them out of registers. On
2853 SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
2862 SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
2864 SDValue Store = DAG.getTruncStore(Val.getValue(1), dl, Val, FIN,
2886 SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
2887 SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
2888 SDValue Store = DAG.getStore(Val.getValue(1), dl, Val, FIN,
2909 ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, MVT::i32);
2912 ArgVal = DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, ArgVal);
2927 ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, MVT::i64);
2932 ArgVal = extendArgForPPC64(Flags, ObjectVT, DAG, ArgVal, dl);
2960 ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, ObjectVT);
2977 ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, ObjectVT);
3010 SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
3011 ArgVal = DAG.getLoad(ObjectVT, dl, Chain, FIN, MachinePointerInfo(),
3042 SDValue FIN = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), PtrVT);
3055 SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
3056 SDValue Store = DAG.getStore(Val.getValue(1), dl, Val, FIN,
3060 SDValue PtrOff = DAG.getConstant(PtrVT.getSizeInBits()/8, PtrVT);
3061 FIN = DAG.getNode(ISD::ADD, dl, PtrOff.getValueType(), FIN, PtrOff);
3066 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
3073 static int CalculateTailCallSPDiff(SelectionDAG& DAG, bool isTailCall,
3078 PPCFunctionInfo *FI = DAG.getMachineFunction().getInfo<PPCFunctionInfo>();
3096 SelectionDAG& DAG) const {
3104 MachineFunction &MF = DAG.getMachineFunction();
3129 static SDNode *isBLACompatibleAddress(SDValue Op, SelectionDAG &DAG) {
3138 return DAG.getConstant((int)C->getZExtValue() >> 2,
3139 DAG.getTargetLoweringInfo().getPointerTy()).getNode();
3156 StoreTailCallArgumentsToStackSlot(SelectionDAG &DAG,
3166 MemOpChains.push_back(DAG.getStore(Chain, dl, Arg, FIN,
3174 static SDValue EmitTailCallStoreFPAndRetAddr(SelectionDAG &DAG,
3191 SDValue NewRetAddrFrIdx = DAG.getFrameIndex(NewRetAddr, VT);
3192 Chain = DAG.getStore(Chain, dl, OldRetAddr, NewRetAddrFrIdx,
3203 SDValue NewFramePtrIdx = DAG.getFrameIndex(NewFPIdx, VT);
3204 Chain = DAG.getStore(Chain, dl, OldFP, NewFramePtrIdx,
3215 CalculateTailCallArgDest(SelectionDAG &DAG, MachineFunction &MF, bool isPPC64,
3222 SDValue FIN = DAG.getFrameIndex(FI, VT);
3233 SDValue PPCTargetLowering::EmitTailCallLoadFPAndRetAddr(SelectionDAG & DAG,
3243 LROpOut = getReturnAddrFrameIndex(DAG);
3244 LROpOut = DAG.getLoad(VT, dl, Chain, LROpOut, MachinePointerInfo(),
3251 FPOpOut = getFramePointerFrameIndex(DAG);
3252 FPOpOut = DAG.getLoad(VT, dl, Chain, FPOpOut, MachinePointerInfo(),
3268 ISD::ArgFlagsTy Flags, SelectionDAG &DAG,
3270 SDValue SizeNode = DAG.getConstant(Flags.getByValSize(), MVT::i32);
3271 return DAG.getMemcpy(Chain, dl, Dst, Src, SizeNode, Flags.getByValAlign(),
3279 LowerMemOpCallTo(SelectionDAG &DAG, MachineFunction &MF, SDValue Chain,
3285 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
3290 StackPtr = DAG.getRegister(PPC::X1, MVT::i64);
3292 StackPtr = DAG.getRegister(PPC::R1, MVT::i32);
3293 PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr,
3294 DAG.getConstant(ArgOffset, PtrVT));
3296 MemOpChains.push_back(DAG.getStore(Chain, dl, Arg, PtrOff,
3299 } else CalculateTailCallArgDest(DAG, MF, isPPC64, Arg, SPDiff, ArgOffset,
3304 void PrepareTailCall(SelectionDAG &DAG, SDValue &InFlag, SDValue &Chain,
3308 MachineFunction &MF = DAG.getMachineFunction();
3315 StoreTailCallArgumentsToStackSlot(DAG, Chain, TailCallArguments,
3318 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains2);
3321 Chain = EmitTailCallStoreFPAndRetAddr(DAG, MF, Chain, LROp, FPOp, SPDiff,
3325 Chain = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(NumBytes, true),
3326 DAG.getIntPtrConstant(0, true), InFlag, dl);
3331 unsigned PrepareCall(SelectionDAG &DAG, SDValue &Callee, SDValue &InFlag,
3340 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
3348 if (SDNode *Dest = isBLACompatibleAddress(Callee, DAG)) {
3358 if (!DAG.getTarget().getSubtarget<PPCSubtarget>().isJITCodeModel()) {
3360 if (DAG.getTarget().getRelocationModel() != Reloc::Static &&
3374 Callee = DAG.getTargetGlobalAddress(G->getGlobal(), dl,
3384 if (DAG.getTarget().getRelocationModel() != Reloc::Static &&
3393 Callee = DAG.getTargetExternalSymbol(S->getSymbol(), Callee.getValueType(),
3432 SDVTList VTs = DAG.getVTList(MVT::i64, MVT::Other, MVT::Glue);
3433 SDValue LoadFuncPtr = DAG.getNode(PPCISD::LOAD, dl, VTs,
3440 SDValue PtrOff = DAG.getIntPtrConstant(16);
3442 SDValue AddPtr = DAG.getNode(ISD::ADD, dl, MVT::i64, Callee, PtrOff);
3443 SDValue LoadEnvPtr = DAG.getNode(PPCISD::LOAD, dl, VTs, Chain, AddPtr,
3448 SDValue EnvVal = DAG.getCopyToReg(Chain, dl, PPC::X11, LoadEnvPtr,
3459 VTs = DAG.getVTList(MVT::Other, MVT::Glue);
3460 SDValue TOCOff = DAG.getIntPtrConstant(8);
3461 SDValue AddTOC = DAG.getNode(ISD::ADD, dl, MVT::i64, Callee, TOCOff);
3462 SDValue LoadTOCPtr = DAG.getNode(PPCISD::LOAD_TOC, dl, VTs, Chain,
3472 Chain = DAG.getNode(PPCISD::MTCTR, dl, NodeTys,
3484 Ops.push_back(DAG.getRegister(PPC::X11, PtrVT));
3487 Ops.push_back(DAG.getRegister(isPPC64 ? PPC::CTR8 : PPC::CTR, PtrVT));
3497 Ops.push_back(DAG.getConstant(SPDiff, MVT::i32));
3502 Ops.push_back(DAG.getRegister(RegsToPass[i].first,
3521 SDLoc dl, SelectionDAG &DAG,
3525 CCState CCRetInfo(CallConv, isVarArg, DAG.getMachineFunction(),
3526 getTargetMachine(), RVLocs, *DAG.getContext());
3534 SDValue Val = DAG.getCopyFromReg(Chain, dl,
3543 Val = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), Val);
3546 Val = DAG.getNode(ISD::AssertZext, dl, VA.getLocVT(), Val,
3547 DAG.getValueType(VA.getValVT()));
3548 Val = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), Val);
3551 Val = DAG.getNode(ISD::AssertSext, dl, VA.getLocVT(), Val,
3552 DAG.getValueType(VA.getValVT()));
3553 Val = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), Val);
3566 SelectionDAG &DAG,
3576 unsigned CallOpc = PrepareCall(DAG, Callee, InFlag, Chain, dl, SPDiff,
3582 Ops.push_back(DAG.getRegister(PPC::CR1EQ, MVT::i32));
3595 Ops.push_back(DAG.getRegisterMask(Mask));
3609 return DAG.getNode(PPCISD::TC_RETURN, dl, MVT::Other, Ops);
3636 DAG.getTarget().getRelocationModel() == Reloc::PIC_)) {
3642 Chain = DAG.getNode(CallOpc, dl, NodeTys, Ops);
3646 SDVTList VTs = DAG.getVTList(MVT::Other, MVT::Glue);
3647 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
3648 SDValue StackPtr = DAG.getRegister(PPC::X1, PtrVT);
3650 SDValue TOCOff = DAG.getIntPtrConstant(TOCSaveOffset);
3651 SDValue AddTOC = DAG.getNode(ISD::ADD, dl, MVT::i64, StackPtr, TOCOff);
3652 Chain = DAG.getNode(PPCISD::LOAD_TOC, dl, VTs, Chain, AddTOC, InFlag);
3656 Chain = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(NumBytes, true),
3657 DAG.getIntPtrConstant(BytesCalleePops, true),
3663 Ins, dl, DAG, InVals);
3669 SelectionDAG &DAG = CLI.DAG;
3682 Ins, DAG);
3692 dl, DAG, InVals);
3696 dl, DAG, InVals);
3701 dl, DAG, InVals);
3711 SDLoc dl, SelectionDAG &DAG,
3721 MachineFunction &MF = DAG.getMachineFunction();
3738 CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
3739 getTargetMachine(), ArgLocs, *DAG.getContext());
3778 CCState CCByValInfo(CallConv, isVarArg, DAG.getMachineFunction(),
3779 getTargetMachine(), ByValArgLocs, *DAG.getContext());
3793 int SPDiff = CalculateTailCallSPDiff(DAG, isTailCall, NumBytes);
3797 Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(NumBytes, true),
3804 Chain = EmitTailCallLoadFPAndRetAddr(DAG, SPDiff, Chain, LROp, FPOp, false,
3810 SDValue StackPtr = DAG.getRegister(PPC::R1, MVT::i32);
3837 SDValue PtrOff = DAG.getIntPtrConstant(LocMemOffset);
3838 PtrOff = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr, PtrOff);
3845 Flags, DAG, dl);
3848 SDValue NewCallSeqStart = DAG.getCALLSEQ_START(MemcpyCall,
3851 DAG.ReplaceAllUsesWith(CallSeqStart.getNode(),
3863 Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, Arg);
3874 SDValue PtrOff = DAG.getIntPtrConstant(LocMemOffset);
3875 PtrOff = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr, PtrOff);
3877 MemOpChains.push_back(DAG.getStore(Chain, dl, Arg, PtrOff,
3882 CalculateTailCallArgDest(DAG, MF, false, Arg, SPDiff, LocMemOffset,
3889 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
3895 Chain = DAG.getCopyToReg(Chain, dl, RegsToPass[i].first,
3903 SDVTList VTs = DAG.getVTList(MVT::Other, MVT::Glue);
3906 Chain = DAG.getNode(seenFloatArg ? PPCISD::CR6SET : PPCISD::CR6UNSET,
3913 PrepareTailCall(DAG, InFlag, Chain, dl, false, SPDiff, NumBytes, LROp, FPOp,
3916 return FinishCall(CallConv, dl, isTailCall, isVarArg, DAG,
3927 SelectionDAG &DAG,
3931 Flags, DAG, dl);
3933 SDValue NewCallSeqStart = DAG.getCALLSEQ_START(MemcpyCall,
3936 DAG.ReplaceAllUsesWith(CallSeqStart.getNode(),
3948 SDLoc dl, SelectionDAG &DAG,
3954 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
3957 MachineFunction &MF = DAG.getMachineFunction();
4002 int SPDiff = CalculateTailCallSPDiff(DAG, isTailCall, NumBytes);
4007 Chain = DAG.getStackArgumentTokenFactor(Chain);
4011 Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(NumBytes, true),
4018 Chain = EmitTailCallLoadFPAndRetAddr(DAG, SPDiff, Chain, LROp, FPOp, true,
4024 SDValue StackPtr = DAG.getRegister(PPC::X1, MVT::i64);
4073 PtrOff = DAG.getConstant(ArgOffset, StackPtr.getValueType());
4075 PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr, PtrOff);
4081 Arg = DAG.getNode(ExtOp, dl, MVT::i64, Arg);
4104 SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, PtrVT, Chain, Arg,
4118 SDValue Const = DAG.getConstant(PtrByteSize - Size,
4120 AddPtr = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, Const);
4124 Flags, DAG, dl);
4144 Flags, DAG, dl);
4158 SDValue Const = DAG.getConstant(8 - Size, PtrOff.getValueType());
4159 AddPtr = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, Const);
4163 Flags, DAG, dl);
4166 SDValue Load = DAG.getLoad(PtrVT, dl, Chain, PtrOff,
4180 SDValue Const = DAG.getConstant(j, PtrOff.getValueType());
4181 SDValue AddArg = DAG.getNode(ISD::ADD, dl, PtrVT, Arg, Const);
4183 SDValue Load = DAG.getLoad(PtrVT, dl, Chain, AddArg,
4205 LowerMemOpCallTo(DAG, MF, Chain, Arg, PtrOff, SPDiff, ArgOffset,
4223 SDValue ConstFour = DAG.getConstant(4, PtrOff.getValueType());
4224 StoreOff = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, ConstFour);
4228 SDValue Store = DAG.getStore(Chain, dl, Arg, StoreOff,
4234 SDValue Load = DAG.getLoad(PtrVT, dl, Store, PtrOff,
4245 SDValue ConstFour = DAG.getConstant(4, PtrOff.getValueType());
4246 PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, ConstFour);
4249 LowerMemOpCallTo(DAG, MF, Chain, Arg, PtrOff, SPDiff, ArgOffset,
4268 SDValue Store = DAG.getStore(Chain, dl, Arg, PtrOff,
4272 SDValue Load = DAG.getLoad(MVT::v4f32, dl, Store, PtrOff,
4288 SDValue Ix = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff,
4289 DAG.getConstant(i, PtrVT));
4290 SDValue Load = DAG.getLoad(PtrVT, dl, Store, Ix, MachinePointerInfo(),
4307 LowerMemOpCallTo(DAG, MF, Chain, Arg, PtrOff, SPDiff, ArgOffset,
4320 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
4329 DAG.getCopyFromReg(Chain, dl, PPC::X2, MVT::i64);
4332 SDValue PtrOff = DAG.getIntPtrConstant(TOCSaveOffset);
4333 SDValue AddPtr = DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr, PtrOff);
4334 Chain = DAG.getStore(Val.getValue(1), dl, Val, AddPtr, MachinePointerInfo(),
4342 Chain = DAG.getCopyToReg(Chain, dl, RegsToPass[i].first,
4348 PrepareTailCall(DAG, InFlag, Chain, dl, true, SPDiff, NumBytes, LROp,
4351 return FinishCall(CallConv, dl, isTailCall, isVarArg, DAG,
4363 SDLoc dl, SelectionDAG &DAG,
4368 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
4372 MachineFunction &MF = DAG.getMachineFunction();
4435 int SPDiff = CalculateTailCallSPDiff(DAG, isTailCall, NumBytes);
4440 Chain = DAG.getStackArgumentTokenFactor(Chain);
4444 Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(NumBytes, true),
4451 Chain = EmitTailCallLoadFPAndRetAddr(DAG, SPDiff, Chain, LROp, FPOp, true,
4459 StackPtr = DAG.getRegister(PPC::X1, MVT::i64);
4461 StackPtr = DAG.getRegister(PPC::R1, MVT::i32);
4502 PtrOff = DAG.getConstant(ArgOffset, StackPtr.getValueType());
4504 PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr, PtrOff);
4510 Arg = DAG.getNode(ExtOp, dl, MVT::i64, Arg);
4523 SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, PtrVT, Chain, Arg,
4531 SDValue Const = DAG.getConstant(PtrByteSize - Size,
4533 SDValue AddPtr = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, Const);
4536 Flags, DAG, dl);
4546 Flags, DAG, dl);
4552 SDValue Const = DAG.getConstant(j, PtrOff.getValueType());
4553 SDValue AddArg = DAG.getNode(ISD::ADD, dl, PtrVT, Arg, Const);
4555 SDValue Load = DAG.getLoad(PtrVT, dl, Chain, AddArg,
4576 Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, PtrVT, Arg);
4580 LowerMemOpCallTo(DAG, MF, Chain, Arg, PtrOff, SPDiff, ArgOffset,
4592 SDValue Store = DAG.getStore(Chain, dl, Arg, PtrOff,
4598 SDValue Load = DAG.getLoad(PtrVT, dl, Store, PtrOff,
4605 SDValue ConstFour = DAG.getConstant(4, PtrOff.getValueType());
4606 PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, ConstFour);
4607 SDValue Load = DAG.getLoad(PtrVT, dl, Store, PtrOff,
4624 LowerMemOpCallTo(DAG, MF, Chain, Arg, PtrOff, SPDiff, ArgOffset,
4649 PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr,
4650 DAG.getConstant(ArgOffset, PtrVT));
4651 SDValue Store = DAG.getStore(Chain, dl, Arg, PtrOff,
4655 SDValue Load = DAG.getLoad(MVT::v4f32, dl, Store, PtrOff,
4665 SDValue Ix = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff,
4666 DAG.getConstant(i, PtrVT));
4667 SDValue Load = DAG.getLoad(PtrVT, dl, Store, Ix, MachinePointerInfo(),
4682 LowerMemOpCallTo(DAG, MF, Chain, Arg, PtrOff, SPDiff, ArgOffset,
4708 LowerMemOpCallTo(DAG, MF, Chain, Arg, PtrOff, SPDiff, ArgOffset,
4718 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
4726 !isBLACompatibleAddress(Callee, DAG))
4734 Chain = DAG.getCopyToReg(Chain, dl, RegsToPass[i].first,
4740 PrepareTailCall(DAG, InFlag, Chain, dl, isPPC64, SPDiff, NumBytes, LROp,
4743 return FinishCall(CallConv, dl, isTailCall, isVarArg, DAG,
4764 SDLoc dl, SelectionDAG &DAG) const {
4767 CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
4768 getTargetMachine(), RVLocs, *DAG.getContext());
4785 Arg = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), Arg);
4788 Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Arg);
4791 Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Arg);
4795 Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), Arg, Flag);
4797 RetOps.push_back(DAG.getRegister(VA.getLocReg(), VA.getLocVT()));
4806 return DAG.getNode(PPCISD::RET_FLAG, dl, MVT::Other, RetOps);
4809 SDValue PPCTargetLowering::LowerSTACKRESTORE(SDValue Op, SelectionDAG &DAG,
4815 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
4820 SDValue StackPtr = DAG.getRegister(SP, PtrVT);
4827 SDValue LoadLinkSP = DAG.getLoad(PtrVT, dl, Chain, StackPtr,
4832 Chain = DAG.getCopyToReg(LoadLinkSP.getValue(1), dl, SP, SaveSP);
4835 return DAG.getStore(Chain, dl, LoadLinkSP, StackPtr, MachinePointerInfo(),
4842 PPCTargetLowering::getReturnAddrFrameIndex(SelectionDAG & DAG) const {
4843 MachineFunction &MF = DAG.getMachineFunction();
4846 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
4862 return DAG.getFrameIndex(RASI, PtrVT);
4866 PPCTargetLowering::getFramePointerFrameIndex(SelectionDAG & DAG) const {
4867 MachineFunction &MF = DAG.getMachineFunction();
4870 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
4888 return DAG.getFrameIndex(FPSI, PtrVT);
4892 SelectionDAG &DAG,
4900 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
4902 SDValue NegSize = DAG.getNode(ISD::SUB, dl, PtrVT,
4903 DAG.getConstant(0, PtrVT), Size);
4905 SDValue FPSIdx = getFramePointerFrameIndex(DAG);
4908 SDVTList VTs = DAG.getVTList(PtrVT, MVT::Other);
4909 return DAG.getNode(PPCISD::DYNALLOC, dl, VTs, Ops);
4913 SelectionDAG &DAG) const {
4915 return DAG.getNode(PPCISD::EH_SJLJ_SETJMP, DL,
4916 DAG.getVTList(MVT::i32, MVT::Other),
4921 SelectionDAG &DAG) const {
4923 return DAG.getNode(PPCISD::EH_SJLJ_LONGJMP, DL, MVT::Other,
4927 SDValue PPCTargetLowering::LowerLOAD(SDValue Op, SelectionDAG &DAG) const {
4940 SDValue NewLD = DAG.getExtLoad(ISD::EXTLOAD, dl, getPointerTy(), Chain,
4942 SDValue Result = DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, NewLD);
4945 return DAG.getMergeValues(Ops, dl);
4948 SDValue PPCTargetLowering::LowerSTORE(SDValue Op, SelectionDAG &DAG) const {
4962 Value = DAG.getNode(ISD::ZERO_EXTEND, dl, getPointerTy(), Value);
4963 return DAG.getTruncStore(Chain, dl, Value, BasePtr, MVT::i8, MMO);
4967 SDValue PPCTargetLowering::LowerTRUNCATE(SDValue Op, SelectionDAG &DAG) const {
4972 return DAG.getNode(PPCISD::ANDIo_1_GT_BIT, DL, MVT::i1,
4978 SDValue PPCTargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const {
4987 if (!DAG.getTarget().Options.NoInfsFPMath ||
4988 !DAG.getTarget().Options.NoNaNsFPMath)
5009 LHS = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, LHS);
5010 Sel1 = DAG.getNode(PPCISD::FSEL, dl, ResVT, LHS, TV, FV);
5012 Sel1 = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Sel1);
5013 return DAG.getNode(PPCISD::FSEL, dl, ResVT,
5014 DAG.getNode(ISD::FNEG, dl, MVT::f64, LHS), Sel1, FV);
5021 LHS = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, LHS);
5022 return DAG.getNode(PPCISD::FSEL, dl, ResVT, LHS, TV, FV);
5029 LHS = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, LHS);
5030 return DAG.getNode(PPCISD::FSEL, dl, ResVT,
5031 DAG.getNode(ISD::FNEG, dl, MVT::f64, LHS), TV, FV);
5040 Cmp = DAG.getNode(ISD::FSUB, dl, CmpVT, LHS, RHS);
5042 Cmp = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Cmp);
5043 Sel1 = DAG.getNode(PPCISD::FSEL, dl, ResVT, Cmp, TV, FV);
5045 Sel1 = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Sel1);
5046 return DAG.getNode(PPCISD::FSEL, dl, ResVT,
5047 DAG.getNode(ISD::FNEG, dl, MVT::f64, Cmp), Sel1, FV);
5050 Cmp = DAG.getNode(ISD::FSUB, dl, CmpVT, LHS, RHS);
5052 Cmp = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Cmp);
5053 return DAG.getNode(PPCISD::FSEL, dl, ResVT, Cmp, FV, TV);
5056 Cmp = DAG.getNode(ISD::FSUB, dl, CmpVT, LHS, RHS);
5058 Cmp = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Cmp);
5059 return DAG.getNode(PPCISD::FSEL, dl, ResVT, Cmp, TV, FV);
5062 Cmp = DAG.getNode(ISD::FSUB, dl, CmpVT, RHS, LHS);
5064 Cmp = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Cmp);
5065 return DAG.getNode(PPCISD::FSEL, dl, ResVT, Cmp, FV, TV);
5068 Cmp = DAG.getNode(ISD::FSUB, dl, CmpVT, RHS, LHS);
5070 Cmp = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Cmp);
5071 return DAG.getNode(PPCISD::FSEL, dl, ResVT, Cmp, TV, FV);
5077 SDValue PPCTargetLowering::LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG,
5082 Src = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Src);
5088 Tmp = DAG.getNode(Op.getOpcode()==ISD::FP_TO_SINT ? PPCISD::FCTIWZ :
5096 Tmp = DAG.getNode(Op.getOpcode()==ISD::FP_TO_SINT ? PPCISD::FCTIDZ :
5105 SDValue FIPtr = DAG.CreateStackTemporary(i32Stack ? MVT::i32 : MVT::f64);
5112 MachineFunction &MF = DAG.getMachineFunction();
5115 SDValue Ops[] = { DAG.getEntryNode(), Tmp, FIPtr };
5116 Chain = DAG.getMemIntrinsicNode(PPCISD::STFIWX, dl,
5117 DAG
5119 Chain = DAG.getStore(DAG.getEntryNode(), dl, Tmp, FIPtr,
5125 FIPtr = DAG.getNode(ISD::ADD, dl, FIPtr.getValueType(), FIPtr,
5126 DAG.getConstant(4, FIPtr.getValueType()));
5130 return DAG.getLoad(Op.getValueType(), dl, Chain, FIPtr, MPI,
5135 SelectionDAG &DAG) const {
5142 return DAG.getNode(ISD::SELECT, dl, Op.getValueType(), Op.getOperand(0),
5143 DAG.getConstantFP(1.0, Op.getValueType()),
5144 DAG.getConstantFP(0.0, Op.getValueType()));
5173 !DAG.getTarget().Options.UnsafeFPMath) {
5181 SDValue Round = DAG.getNode(ISD::AND, dl, MVT::i64,
5182 SINT, DAG.getConstant(2047, MVT::i64));
5183 Round = DAG.getNode(ISD::ADD, dl, MVT::i64,
5184 Round, DAG.getConstant(2047, MVT::i64));
5185 Round = DAG.getNode(ISD::OR, dl, MVT::i64, Round, SINT);
5186 Round = DAG.getNode(ISD::AND, dl, MVT::i64,
5187 Round, DAG.getConstant(-2048, MVT::i64));
5197 SDValue Cond = DAG.getNode(ISD::SRA, dl, MVT::i64,
5198 SINT, DAG.getConstant(53, MVT::i32));
5199 Cond = DAG.getNode(ISD::ADD, dl, MVT::i64,
5200 Cond, DAG.getConstant(1, MVT::i64));
5201 Cond = DAG.getSetCC(dl, MVT::i32,
5202 Cond, DAG.getConstant(1, MVT::i64), ISD::SETUGT);
5204 SINT = DAG.getNode(ISD::SELECT, dl, MVT::i64, Cond, Round, SINT);
5207 SDValue Bits = DAG.getNode(ISD::BITCAST, dl, MVT::f64, SINT);
5208 SDValue FP = DAG.getNode(FCFOp, dl, FCFTy, Bits);
5211 FP = DAG.getNode(ISD::FP_ROUND, dl,
5212 MVT::f32, FP, DAG.getIntPtrConstant(0));
5222 MachineFunction &MF = DAG.getMachineFunction();
5224 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
5229 SDValue FIdx = DAG.getFrameIndex(FrameIdx, PtrVT);
5231 SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, Op.getOperand(0), FIdx,
5241 Ld = DAG.getMemIntrinsicNode(Op.getOpcode() == ISD::UINT_TO_FP ?
5243 dl, DAG.getVTList(MVT::f64, MVT::Other),
5250 SDValue FIdx = DAG.getFrameIndex(FrameIdx, PtrVT);
5252 SDValue Ext64 = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::i64,
5256 SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, Ext64, FIdx,
5261 Ld = DAG.getLoad(MVT::f64, dl, Store, FIdx,
5267 SDValue FP = DAG.getNode(FCFOp, dl, FCFTy, Ld);
5269 FP = DAG.getNode(ISD::FP_ROUND, dl, MVT::f32, FP, DAG.getIntPtrConstant(0));
5274 SelectionDAG &DAG) const {
5295 MachineFunction &MF = DAG.getMachineFunction();
5297 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
5304 SDValue Chain = DAG.getNode(PPCISD::MFFS, dl, NodeTys, None);
5308 SDValue StackSlot = DAG.getFrameIndex(SSFI, PtrVT);
5309 SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, Chain,
5313 SDValue Four = DAG.getConstant(4, PtrVT);
5314 SDValue Addr = DAG.getNode(ISD::ADD, dl, PtrVT, StackSlot, Four);
5315 SDValue CWD = DAG.getLoad(MVT::i32, dl, Store, Addr, MachinePointerInfo(),
5320 DAG.getNode(ISD::AND, dl, MVT::i32,
5321 CWD, DAG.getConstant(3, MVT::i32));
5323 DAG.getNode(ISD::SRL, dl, MVT::i32,
5324 DAG.getNode(ISD::AND, dl, MVT::i32,
5325 DAG.getNode(ISD::XOR, dl, MVT::i32,
5326 CWD, DAG.getConstant(3, MVT::i32)),
5327 DAG.getConstant(3, MVT::i32)),
5328 DAG.getConstant(1, MVT::i32));
5331 DAG.getNode(ISD::XOR, dl, MVT::i32, CWD1, CWD2);
5333 return DAG.getNode((VT.getSizeInBits() < 16 ?
5337 SDValue PPCTargetLowering::LowerSHL_PARTS(SDValue Op, SelectionDAG &DAG) const {
5352 SDValue Tmp1 = DAG.getNode(ISD::SUB, dl, AmtVT,
5353 DAG.getConstant(BitWidth, AmtVT), Amt);
5354 SDValue Tmp2 = DAG.getNode(PPCISD::SHL, dl, VT, Hi, Amt);
5355 SDValue Tmp3 = DAG.getNode(PPCISD::SRL, dl, VT, Lo, Tmp1);
5356 SDValue Tmp4 = DAG.getNode(ISD::OR , dl, VT, Tmp2, Tmp3);
5357 SDValue Tmp5 = DAG.getNode(ISD::ADD, dl, AmtVT, Amt,
5358 DAG.getConstant(-BitWidth, AmtVT));
5359 SDValue Tmp6 = DAG.getNode(PPCISD::SHL, dl, VT, Lo, Tmp5);
5360 SDValue OutHi = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp6);
5361 SDValue OutLo = DAG.getNode(PPCISD::SHL, dl, VT, Lo, Amt);
5363 return DAG.getMergeValues(OutOps, dl);
5366 SDValue PPCTargetLowering::LowerSRL_PARTS(SDValue Op, SelectionDAG &DAG) const {
5381 SDValue Tmp1 = DAG.getNode(ISD::SUB, dl, AmtVT,
5382 DAG.getConstant(BitWidth, AmtVT), Amt);
5383 SDValue Tmp2 = DAG.getNode(PPCISD::SRL, dl, VT, Lo, Amt);
5384 SDValue Tmp3 = DAG.getNode(PPCISD::SHL, dl, VT, Hi, Tmp1);
5385 SDValue Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp3);
5386 SDValue Tmp5 = DAG.getNode(ISD::ADD, dl, AmtVT, Amt,
5387 DAG.getConstant(-BitWidth, AmtVT));
5388 SDValue Tmp6 = DAG.getNode(PPCISD::SRL, dl, VT, Hi, Tmp5);
5389 SDValue OutLo = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp6);
5390 SDValue OutHi = DAG.getNode(PPCISD::SRL, dl, VT, Hi, Amt);
5392 return DAG.getMergeValues(OutOps, dl);
5395 SDValue PPCTargetLowering::LowerSRA_PARTS(SDValue Op, SelectionDAG &DAG) const {
5409 SDValue Tmp1 = DAG.getNode(ISD::SUB, dl, AmtVT,
5410 DAG.getConstant(BitWidth, AmtVT), Amt);
5411 SDValue Tmp2 = DAG.getNode(PPCISD::SRL, dl, VT, Lo, Amt);
5412 SDValue Tmp3 = DAG.getNode(PPCISD::SHL, dl, VT, Hi, Tmp1);
5413 SDValue Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp3);
5414 SDValue Tmp5 = DAG.getNode(ISD::ADD, dl, AmtVT, Amt,
5415 DAG.getConstant(-BitWidth, AmtVT));
5416 SDValue Tmp6 = DAG.getNode(PPCISD::SRA, dl, VT, Hi, Tmp5);
5417 SDValue OutHi = DAG.getNode(PPCISD::SRA, dl, VT, Hi, Amt);
5418 SDValue OutLo = DAG.getSelectCC(dl, Tmp5, DAG.getConstant(0, AmtVT),
5421 return DAG.getMergeValues(OutOps, dl);
5431 SelectionDAG &DAG, SDLoc dl) {
5447 SDValue Elt = DAG.getConstant(Val, MVT::i32);
5450 SDValue Res = DAG.getNode(ISD::BUILD_VECTOR, dl, CanonicalVT, Ops);
5451 return DAG.getNode(ISD::BITCAST, dl, ReqVT, Res);
5457 SelectionDAG &DAG, SDLoc dl,
5460 return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, DestVT,
5461 DAG.getConstant(IID, MVT::i32), Op);
5467 SelectionDAG &DAG, SDLoc dl,
5470 return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, DestVT,
5471 DAG.getConstant(IID, MVT::i32), LHS, RHS);
5477 SDValue Op2, SelectionDAG &DAG,
5480 return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, DestVT,
5481 DAG.getConstant(IID, MVT::i32), Op0, Op1, Op2);
5488 EVT VT, SelectionDAG &DAG, SDLoc dl) {
5490 LHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, LHS);
5491 RHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, RHS);
5496 SDValue T = DAG.getVectorShuffle(MVT::v16i8, dl, LHS, RHS, Ops);
5497 return DAG.getNode(ISD::BITCAST, dl, VT, T);
5506 SelectionDAG &DAG) const {
5529 SDValue Z = DAG.getConstant(0, MVT::i32);
5530 Z = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Z, Z, Z, Z);
5531 Op = DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Z);
5540 return BuildSplatI(SextVal, SplatSize, Op.getValueType(), DAG, dl);
5556 SDValue Elt = DAG.getConstant(SextVal, MVT::i32);
5559 SDValue EltSize = DAG.getConstant(SplatSize, MVT::i32);
5560 SDValue RetVal = DAG.getNode(PPCISD::VADD_SPLAT, dl, VT, Elt, EltSize);
5564 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), RetVal);
5572 SDValue OnesV = BuildSplatI(-1, 4, MVT::v4i32, DAG, dl);
5576 OnesV, DAG, dl);
5579 Res = DAG.getNode(ISD::XOR, dl, MVT::v4i32, Res, OnesV);
5580 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
5616 SDValue Res = BuildSplatI(i, SplatSize, MVT::Other, DAG, dl);
5621 Res = BuildIntrinsicOp(IIDs[SplatSize-1], Res, Res, DAG, dl);
5622 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
5627 SDValue Res = BuildSplatI(i, SplatSize, MVT::Other, DAG, dl);
5632 Res = BuildIntrinsicOp(IIDs[SplatSize-1], Res, Res, DAG, dl);
5633 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
5638 SDValue Res = BuildSplatI(i, SplatSize, MVT::Other, DAG, dl);
5643 Res = BuildIntrinsicOp(IIDs[SplatSize-1], Res, Res, DAG, dl);
5644 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
5650 SDValue Res = BuildSplatI(i, SplatSize, MVT::Other, DAG, dl);
5655 Res = BuildIntrinsicOp(IIDs[SplatSize-1], Res, Res, DAG, dl);
5656 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
5661 SDValue T = BuildSplatI(i, SplatSize, MVT::v16i8, DAG, dl);
5662 return BuildVSLDOI(T, T, 1, Op.getValueType(), DAG, dl);
5666 SDValue T = BuildSplatI(i, SplatSize, MVT::v16i8, DAG, dl);
5667 return BuildVSLDOI(T, T, 2, Op.getValueType(), DAG, dl);
5671 SDValue T = BuildSplatI(i, SplatSize, MVT::v16i8, DAG, dl);
5672 return BuildVSLDOI(T, T, 3, Op.getValueType(), DAG, dl);
5682 SDValue RHS, SelectionDAG &DAG,
5708 OpLHS = GeneratePerfectShuffle(PerfectShuffleTable[LHSID], LHS, RHS, DAG, dl);
5709 OpRHS = GeneratePerfectShuffle(PerfectShuffleTable[RHSID], LHS, RHS, DAG, dl);
5743 return BuildVSLDOI(OpLHS, OpRHS, 4, OpLHS.getValueType(), DAG, dl);
5745 return BuildVSLDOI(OpLHS, OpRHS, 8, OpLHS.getValueType(), DAG, dl);
5747 return BuildVSLDOI(OpLHS, OpRHS, 12, OpLHS.getValueType(), DAG, dl);
5750 OpLHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, OpLHS);
5751 OpRHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, OpRHS);
5752 SDValue T = DAG.getVectorShuffle(MVT::v16i8, dl, OpLHS, OpRHS, ShufIdxs);
5753 return DAG.getNode(ISD::BITCAST, dl, VT, T);
5761 SelectionDAG &DAG) const {
5776 PPC::isVPKUWUMShuffleMask(SVOp, true, DAG) ||
5777 PPC::isVPKUHUMShuffleMask(SVOp, true, DAG) ||
5778 PPC::isVSLDOIShuffleMask(SVOp, true, DAG) != -1 ||
5779 PPC::isVMRGLShuffleMask(SVOp, 1, true, DAG) ||
5780 PPC::isVMRGLShuffleMask(SVOp, 2, true, DAG) ||
5781 PPC::isVMRGLShuffleMask(SVOp, 4, true, DAG) ||
5782 PPC::isVMRGHShuffleMask(SVOp, 1, true, DAG) ||
5783 PPC::isVMRGHShuffleMask(SVOp, 2, true, DAG) ||
5784 PPC::isVMRGHShuffleMask(SVOp, 4, true, DAG)) {
5792 if (PPC::isVPKUWUMShuffleMask(SVOp, false, DAG) ||
5793 PPC::isVPKUHUMShuffleMask(SVOp, false, DAG) ||
5794 PPC::isVSLDOIShuffleMask(SVOp, false, DAG) != -1 ||
5795 PPC::isVMRGLShuffleMask(SVOp, 1, false, DAG) ||
5796 PPC::isVMRGLShuffleMask(SVOp, 2, false, DAG) ||
5797 PPC::isVMRGLShuffleMask(SVOp, 4, false, DAG) ||
5798 PPC::isVMRGHShuffleMask(SVOp, 1, false, DAG) ||
5799 PPC::isVMRGHShuffleMask(SVOp, 2, false, DAG) ||
5800 PPC::isVMRGHShuffleMask(SVOp, 4, false, DAG))
5856 return GeneratePerfectShuffle(PFEntry, V1, V2, DAG, dl);
5879 ResultMask.push_back(DAG.getConstant(31 - (SrcElt*BytesPerElement+j),
5882 ResultMask.push_back(DAG.getConstant(SrcElt*BytesPerElement+j,
5886 SDValue VPermMask = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v16i8,
5889 return DAG.getNode(PPCISD::VPERM, dl, V1.getValueType(),
5892 return DAG.getNode(PPCISD::VPERM, dl, V1.getValueType(),
5943 SelectionDAG &DAG) const {
5954 SDValue Tmp = DAG.getNode(PPCISD::VCMP, dl, Op.getOperand(2).getValueType(),
5956 DAG.getConstant(CompareOpc, MVT::i32));
5957 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Tmp);
5964 DAG.getConstant(CompareOpc, MVT::i32)
5967 SDValue CompNode = DAG.getNode(PPCISD::VCMPo, dl, VTs, Ops);
5971 SDValue Flags = DAG.getNode(PPCISD::MFOCRF, dl, MVT::i32,
5972 DAG.getRegister(PPC::CR6, MVT::i32),
5995 Flags = DAG.getNode(ISD::SRL, dl, MVT::i32, Flags,
5996 DAG.getConstant(8-(3-BitNo), MVT::i32));
5998 Flags = DAG.getNode(ISD::AND, dl, MVT::i32, Flags,
5999 DAG.getConstant(1, MVT::i32));
6003 Flags = DAG.getNode(ISD::XOR, dl, MVT::i32, Flags,
6004 DAG.getConstant(1, MVT::i32));
6009 SelectionDAG &DAG) const {
6017 Op = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op.getOperand(0));
6018 Op = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, MVT::v4i32, Op,
6019 DAG.getValueType(EVT::getVectorVT(*DAG.getContext(),
6021 Op = DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, Op);
6022 Op = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, MVT::v2i64, Op,
6023 DAG.getValueType(MVT::v2i32));
6033 SelectionDAG &DAG) const {
6036 MachineFrameInfo *FrameInfo = DAG.getMachineFunction().getFrameInfo();
6039 SDValue FIdx = DAG.getFrameIndex(FrameIdx, PtrVT);
6042 SDValue Store = DAG.getStore(DAG.getEntryNode(), dl,
6046 return DAG.getLoad(Op.getValueType(), dl, Store, FIdx, MachinePointerInfo(),
6050 SDValue PPCTargetLowering::LowerMUL(SDValue Op, SelectionDAG &DAG) const {
6055 SDValue Zero = BuildSplatI( 0, 1, MVT::v4i32, DAG, dl);
6056 SDValue Neg16 = BuildSplatI(-16, 4, MVT::v4i32, DAG, dl);//+16 as shift amt.
6059 BuildIntrinsicOp(Intrinsic::ppc_altivec_vrlw, RHS, Neg16, DAG, dl);
6062 LHS = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, LHS);
6063 RHS = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, RHS);
6064 RHSSwap = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, RHSSwap);
6069 LHS, RHS, DAG, dl, MVT::v4i32);
6072 LHS, RHSSwap, Zero, DAG, dl, MVT::v4i32);
6075 Neg16, DAG, dl);
6076 return DAG.getNode(ISD::ADD, dl, MVT::v4i32, LoProd, HiProd);
6080 SDValue Zero = BuildSplatI(0, 1, MVT::v8i16, DAG, dl);
6083 LHS, RHS, Zero, DAG, dl);
6090 LHS, RHS, DAG, dl, MVT::v8i16);
6091 EvenParts = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, EvenParts);
6095 LHS, RHS, DAG, dl, MVT::v8i16);
6096 OddParts = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, OddParts);
6113 return DAG.getVectorShuffle(MVT::v16i8, dl, OddParts, EvenParts, Ops);
6115 return DAG.getVectorShuffle(MVT::v16i8, dl, EvenParts, OddParts, Ops);
6123 SDValue PPCTargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
6126 case ISD::ConstantPool: return LowerConstantPool(Op, DAG);
6127 case ISD::BlockAddress: return LowerBlockAddress(Op, DAG);
6128 case ISD::GlobalAddress: return LowerGlobalAddress(Op, DAG);
6129 case ISD::GlobalTLSAddress: return LowerGlobalTLSAddress(Op, DAG);
6130 case ISD::JumpTable: return LowerJumpTable(Op, DAG);
6131 case ISD::SETCC: return LowerSETCC(Op, DAG);
6132 case ISD::INIT_TRAMPOLINE: return LowerINIT_TRAMPOLINE(Op, DAG);
6133 case ISD::ADJUST_TRAMPOLINE: return LowerADJUST_TRAMPOLINE(Op, DAG);
6135 return LowerVASTART(Op, DAG, Subtarget);
6138 return LowerVAARG(Op, DAG, Subtarget);
6141 return LowerVACOPY(Op, DAG, Subtarget);
6143 case ISD::STACKRESTORE: return LowerSTACKRESTORE(Op, DAG, Subtarget);
6145 return LowerDYNAMIC_STACKALLOC(Op, DAG, Subtarget);
6147 case ISD::EH_SJLJ_SETJMP: return lowerEH_SJLJ_SETJMP(Op, DAG);
6148 case ISD::EH_SJLJ_LONGJMP: return lowerEH_SJLJ_LONGJMP(Op, DAG);
6150 case ISD::LOAD: return LowerLOAD(Op, DAG);
6151 case ISD::STORE: return LowerSTORE(Op, DAG);
6152 case ISD::TRUNCATE: return LowerTRUNCATE(Op, DAG);
6153 case ISD::SELECT_CC: return LowerSELECT_CC(Op, DAG);
6155 case ISD::FP_TO_SINT: return LowerFP_TO_INT(Op, DAG,
6158 case ISD::SINT_TO_FP: return LowerINT_TO_FP(Op, DAG);
6159 case ISD::FLT_ROUNDS_: return LowerFLT_ROUNDS_(Op, DAG);
6162 case ISD::SHL_PARTS: return LowerSHL_PARTS(Op, DAG);
6163 case ISD::SRL_PARTS: return LowerSRL_PARTS(Op, DAG);
6164 case ISD::SRA_PARTS: return LowerSRA_PARTS(Op, DAG);
6167 case ISD::BUILD_VECTOR: return LowerBUILD_VECTOR(Op, DAG);
6168 case ISD::VECTOR_SHUFFLE: return LowerVECTOR_SHUFFLE(Op, DAG);
6169 case ISD::INTRINSIC_WO_CHAIN: return LowerINTRINSIC_WO_CHAIN(Op, DAG);
6170 case ISD::SCALAR_TO_VECTOR: return LowerSCALAR_TO_VECTOR(Op, DAG);
6171 case ISD::SIGN_EXTEND_INREG: return LowerSIGN_EXTEND_INREG(Op, DAG);
6172 case ISD::MUL: return LowerMUL(Op, DAG);
6178 case ISD::RETURNADDR: return LowerRETURNADDR(Op, DAG);
6179 case ISD::FRAMEADDR: return LowerFRAMEADDR(Op, DAG);
6185 SelectionDAG &DAG) const {
6198 EVT SVT = getSetCCResultType(*DAG.getContext(), N->getValueType(0));
6199 SDVTList VTs = DAG.getVTList(SVT, MVT::Other);
6200 SDValue NewInt = DAG.getNode(N->getOpcode(), dl, VTs, N->getOperand(0),
6215 SDValue NewNode = LowerVAARG(SDValue(N, 1), DAG, Subtarget);
6225 SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl,
6227 DAG.getIntPtrConstant(0));
6228 SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl,
6230 DAG.getIntPtrConstant(1));
6233 SDValue FPreg = DAG.getNode(PPCISD::FADDRTZ, dl, MVT::f64, Lo, Hi);
6237 Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, MVT::ppcf128,
6245 Results.push_back(LowerFP_TO_INT(SDValue(N, 0), DAG, dl));
7161 SelectionDAG &DAG = DCI.DAG;
7165 DAG.getConstantFP(1.0, VT.getScalarType());
7169 FPOne = DAG.getNode(ISD::BUILD_VECTOR, dl, VT,
7173 SDValue Est = DAG.getNode(PPCISD::FRE, dl, VT, Op);
7178 SDValue NewEst = DAG.getNode(ISD::FMUL, dl, VT, Op, Est);
7181 NewEst = DAG.getNode(ISD::FSUB, dl, VT, FPOne, NewEst);
7184 NewEst = DAG.getNode(ISD::FMUL, dl, VT, Est, NewEst);
7187 Est = DAG.getNode(ISD::FADD, dl, VT, Est, NewEst);
7224 SelectionDAG &DAG = DCI.DAG;
7228 DAG.getConstantFP(1.5, VT.getScalarType());
7232 FPThreeHalves = DAG.getNode(ISD::BUILD_VECTOR, dl, VT,
7237 SDValue Est = DAG.getNode(PPCISD::FRSQRTE, dl, VT, Op);
7242 SDValue HalfArg = DAG.getNode(ISD::FMUL, dl, VT, FPThreeHalves, Op);
7245 HalfArg = DAG.getNode(ISD::FSUB, dl, VT, HalfArg, Op);
7250 SDValue NewEst = DAG.getNode(ISD::FMUL, dl, VT, Est, Est);
7253 NewEst = DAG.getNode(ISD::FMUL, dl, VT, HalfArg, NewEst);
7256 NewEst = DAG.getNode(ISD::FSUB, dl, VT, FPThreeHalves, NewEst);
7259 Est = DAG.getNode(ISD::FMUL, dl, VT, Est, NewEst);
7273 SelectionDAG &DAG) {
7283 const MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
7293 if (DAG.isBaseWithConstantOffset(Loc) && Loc.getOperand(0) == BaseLoc &&
7297 const TargetLowering &TLI = DAG.getTargetLoweringInfo();
7314 static bool findConsecutiveLoad(LoadSDNode *LD, SelectionDAG &DAG) {
7331 if (isConsecutiveLS(ChainLD, LD, VT.getStoreSize(), 1, DAG))
7362 if (isConsecutiveLS(ChainLD, LD, VT.getStoreSize(), 1, DAG))
7379 SelectionDAG &DAG = DCI.DAG;
7411 if (DAG.ComputeNumSignBits(N->getOperand(0)) != OpBits ||
7412 DAG.ComputeNumSignBits(N->getOperand(1)) != OpBits)
7415 if (!DAG.MaskedValueIsZero(N->getOperand(0),
7417 !DAG.MaskedValueIsZero(N->getOperand(1),
7425 DAG.computeKnownBits(N->getOperand(0), Op1Zero, Op1One);
7426 DAG.computeKnownBits(N->getOperand(1), Op2Zero, Op2One);
7585 DAG.ReplaceAllUsesOfValueWith(Inputs[i], Inputs[i].getOperand(0));
7589 // (i1) return type). DAG.getNode will validate that the types of
7610 RepValue = DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, RepValue);
7612 DAG.ReplaceAllUsesOfValueWith(PromOp, RepValue);
7641 Ops[C+i] = DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, Ops[C+i]);
7643 DAG.ReplaceAllUsesOfValueWith(PromOp,
7644 DAG.getNode(PromOp.getOpcode(), dl, MVT::i1, Ops));
7658 SelectionDAG &DAG = DCI.DAG;
7799 !DAG.MaskedValueIsZero(Inputs[i].getOperand(0),
7803 DAG.ComputeNumSignBits(Inputs[i].getOperand(0)) <
7822 DAG.ReplaceAllUsesOfValueWith(Inputs[i], InSrc);
7824 DAG.ReplaceAllUsesOfValueWith(Inputs[i],
7825 DAG.getSExtOrTrunc(InSrc, dl, N->getValueType(0)));
7827 DAG.ReplaceAllUsesOfValueWith(Inputs[i],
7828 DAG.getZExtOrTrunc(InSrc, dl, N->getValueType(0)));
7830 DAG.ReplaceAllUsesOfValueWith(Inputs[i],
7831 DAG.getAnyExtOrTrunc(InSrc, dl, N->getValueType(0)));
7835 // (promoted) return type). DAG.getNode will validate that the types of
7872 Ops[C+i] = DAG.getSExtOrTrunc(Ops[C+i], dl, N->getValueType(0));
7874 Ops[C+i] = DAG.getZExtOrTrunc(Ops[C+i], dl, N->getValueType(0));
7876 Ops[C+i] = DAG.getAnyExtOrTrunc(Ops[C+i], dl, N->getValueType(0));
7879 DAG.ReplaceAllUsesOfValueWith(PromOp,
7880 DAG.getNode(PromOp.getOpcode(), dl, N->getValueType(0), Ops));
7890 return DAG.getNode(ISD::AND, dl, N->getValueType(0), N->getOperand(0),
7891 DAG.getConstant(APInt::getLowBitsSet(
7899 DAG.getConstant(N->getValueSizeInBits(0)-PromBits, ShiftAmountTy);
7900 return DAG.getNode(ISD::SRA, dl, N->getValueType(0),
7901 DAG.getNode(ISD::SHL, dl, N->getValueType(0),
7908 SelectionDAG &DAG = DCI.DAG;
7948 return DAG.getNode(ISD::FMUL, dl, N->getValueType(0),
7958 RV = DAG.getNode(ISD::FP_EXTEND, SDLoc(N->getOperand(1)),
7961 return DAG.getNode(ISD::FMUL, dl, N->getValueType(0),
7971 RV = DAG
7975 return DAG.getNode(ISD::FMUL, dl, N->getValueType(0),
7983 return DAG.getNode(ISD::FMUL, dl, N->getValueType(0),
8005 SDValue Zero = DAG.getConstantFP(0.0, VT.getScalarType());
8008 Zero = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Zero, Zero, Zero, Zero);
8012 DAG.getSetCC(dl, getSetCCResultType(*DAG.getContext(), VT),
8017 RV = DAG.getNode(VT.isVector() ? ISD::VSELECT : ISD::SELECT, dl, VT,
8035 Val = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Val);
8039 Val = DAG.getNode(PPCISD::FCTIDZ, dl, MVT::f64, Val);
8041 Val = DAG.getNode(PPCISD::FCFID, dl, MVT::f64, Val);
8044 Val = DAG.getNode(ISD::FP_ROUND, dl, MVT::f32, Val,
8045 DAG.getIntPtrConstant(0));
8065 Val = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Val);
8068 Val = DAG.getNode(PPCISD::FCTIWZ, dl, MVT::f64, Val);
8073 DAG.getValueType(N->getOperand(1).getValueType())
8076 Val = DAG.getMemIntrinsicNode(PPCISD::STFIWX, dl,
8077 DAG.getVTList(MVT::Other), Ops,
8096 BSwapOp = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, BSwapOp);
8100 DAG.getValueType(N->getOperand(1).getValueType())
8103 DAG.getMemIntrinsicNode(PPCISD::STBRX, dl, DAG.getVTList(MVT::Other),
8111 Type *Ty = LD->getMemoryVT().getTypeForEVT(*DAG.getContext());
8145 // The INTRINSIC_WO_CHAIN DAG combine will attempt to perform this
8150 SDValue PermCntl = BuildIntrinsicOp(Intr, Ptr, DAG, dl, MVT::v16i8);
8155 MachineFunction &MF = DAG.getMachineFunction();
8178 if (!findConsecutiveLoad(LD, DAG))
8181 SDValue Increment = DAG.getConstant(IncValue, getPointerTy());
8182 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
8185 DAG.getLoad(VT, dl, Chain, Ptr,
8190 SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
8194 BaseLoad = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, BaseLoad);
8197 ExtraLoad = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, ExtraLoad);
8207 ExtraLoad, BaseLoad, PermCntl, DAG, dl);
8210 BaseLoad, ExtraLoad, PermCntl, DAG, dl);
8213 Perm = DAG.getNode(ISD::BITCAST, dl, VT, Perm);
8217 // DAG.ReplaceAllUsesWith for that matter), because the load still has
8242 DAG.UpdateNodeOperands(User, Ops);
8258 if (DAG.MaskedValueIsZero(Add->getOperand(1),
8293 DAG.getValueType(N->getValueType(0)) // VT
8296 DAG.getMemIntrinsicNode(PPCISD::LBRX, dl,
8297 DAG.getVTList(N->getValueType(0) == MVT::i64 ?
8304 ResVal = DAG.getNode(ISD::TRUNCATE, dl, MVT::i16, BSLoad);
8380 DAG.ReplaceAllUsesOfValueWith(Cond.getValue(1), Cond.getOperand(0));
8384 return DAG.getNode(PPCISD::BDNZ, dl, MVT::Other,
8421 DAG.ReplaceAllUsesOfValueWith(LHS.getValue(1), LHS.getOperand(0));
8425 return DAG.getNode(isBDNZ ? PPCISD::BDNZ : PPCISD::BDZ, dl, MVT::Other,
8444 return DAG.getNode(ISD::BR, dl, MVT::Other,
8454 DAG.getConstant(CompareOpc, MVT::i32)
8457 SDValue CompNode = DAG.getNode(PPCISD::VCMPo, dl, VTs, Ops);
8477 return DAG.getNode(PPCISD::COND_BRANCH, dl, MVT::Other, N->getOperand(0),
8478 DAG.getConstant(CompOpc, MVT::i32),
8479 DAG.getRegister(PPC::CR6, MVT::i32),
8496 const SelectionDAG &DAG,
8677 SelectionDAG &DAG) const {
8701 Result = DAG.getTargetConstant(Value, Op.getValueType());
8706 Result = DAG.getTargetConstant(Value, Op.getValueType());
8710 Result = DAG.getTargetConstant(Value, Op.getValueType());
8714 Result = DAG.getTargetConstant(Value, Op.getValueType());
8718 Result = DAG.getTargetConstant(Value, Op.getValueType());
8722 Result = DAG.getTargetConstant(Value, Op.getValueType());
8726 Result = DAG.getTargetConstant(Value, Op.getValueType());
8739 TargetLowering::LowerAsmOperandForConstraint(Op, Constraint, Ops, DAG);
8779 SelectionDAG &DAG) const {
8780 MachineFunction &MF = DAG.getMachineFunction();
8784 if (verifyReturnAddressArgumentIsConstant(Op, DAG))
8798 SDValue FrameAddr = LowerFRAMEADDR(Op, DAG);
8801 DAG
8803 return DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(),
8804 DAG.getNode(ISD::ADD, dl, getPointerTy(),
8810 SDValue RetAddrFI = getReturnAddrFrameIndex(DAG);
8811 return DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(),
8816 SelectionDAG &DAG) const {
8820 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
8823 MachineFunction &MF = DAG.getMachineFunction();
8836 SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl, FrameReg,
8839 FrameAddr = DAG.getLoad(Op.getValueType(), dl, DAG.getEntryNode(),
