Lines Matching defs:DAG
1 //===-- PPCISelLowering.cpp - PPC DAG Lowering Implementation -------------===//
411 // We have target-specific dag combine patterns for the following nodes:
705 SDValue PPC::get_VSPLTI_elt(SDNode *N, unsigned ByteSize, SelectionDAG &DAG) {
748 return DAG.getTargetConstant(0, MVT::i32); // 0,0,0,undef
751 return DAG.getTargetConstant(Val, MVT::i32); // 0,0,0,4 -> vspltisw(4)
755 return DAG.getTargetConstant(~0U, MVT::i32); // -1,-1,-1,undef
758 return DAG.getTargetConstant(Val, MVT::i32);
810 return DAG.getTargetConstant(MaskVal, MVT::i32);
842 SelectionDAG &DAG) const {
862 DAG.ComputeMaskedBits(N.getOperand(0),
866 DAG.ComputeMaskedBits(N.getOperand(1),
886 SelectionDAG &DAG) const {
890 if (SelectAddressRegReg(N, Disp, Base, DAG))
896 Disp = DAG.getTargetConstant((int)imm & 0xFFFF, MVT::i32);
898 Base = DAG.getTargetFrameIndex(FI->getIndex(), N.getValueType());
921 DAG.ComputeMaskedBits(N.getOperand(0), LHSKnownZero, LHSKnownOne);
927 Disp = DAG.getTargetConstant((int)imm & 0xFFFF, MVT::i32);
938 Disp = DAG.getTargetConstant(Imm, CN->getValueType(0));
939 Base = DAG.getRegister(PPCSubTarget.isPPC64() ? PPC::X0 : PPC::R0,
950 Disp = DAG.getTargetConstant((short)Addr, MVT::i32);
952 Base = DAG.getTargetConstant((Addr - (signed short)Addr) >> 16, MVT::i32);
954 Base = SDValue(DAG.getMachineNode(Opc, dl, CN->getValueType(0), Base), 0);
959 Disp = DAG.getTargetConstant(0, getPointerTy());
961 Base = DAG.getTargetFrameIndex(FI->getIndex(), N.getValueType());
971 SelectionDAG &DAG) const {
975 if (SelectAddressRegReg(N, Base, Index, DAG))
988 Base = DAG.getRegister(PPCSubTarget.isPPC64() ? PPC::X0 : PPC::R0,
999 SelectionDAG &DAG) const {
1003 if (SelectAddressRegReg(N, Disp, Base, DAG))
1009 Disp = DAG.getTargetConstant(((int)imm & 0xFFFF) >> 2, MVT::i32);
1011 Base = DAG.getTargetFrameIndex(FI->getIndex(), N.getValueType());
1034 DAG.ComputeMaskedBits(N.getOperand(0), LHSKnownZero, LHSKnownOne);
1039 Disp = DAG.getTargetConstant(((int)imm & 0xFFFF) >> 2, MVT::i32);
1050 Disp = DAG.getTargetConstant((unsigned short)Imm >> 2, getPointerTy());
1051 Base = DAG.getRegister(PPCSubTarget.isPPC64() ? PPC::X0 : PPC::R0,
1062 Disp = DAG.getTargetConstant((short)Addr >> 2, MVT::i32);
1063 Base = DAG.getTargetConstant((Addr-(signed short)Addr) >> 16, MVT::i32);
1065 Base = SDValue(DAG.getMachineNode(Opc, dl, CN->getValueType(0), Base),0);
1071 Disp = DAG.getTargetConstant(0, getPointerTy());
1073 Base = DAG.getTargetFrameIndex(FI->getIndex(), N.getValueType());
1086 SelectionDAG &DAG) const {
1111 if (!SelectAddressRegImm(Ptr, Offset, Base, DAG))
1115 if (!SelectAddressRegImmShift(Ptr, Offset, Base, DAG))
1168 SelectionDAG &DAG) {
1170 SDValue Zero = DAG.getConstant(0, PtrVT);
1173 SDValue Hi = DAG.getNode(PPCISD::Hi, DL, PtrVT, HiPart, Zero);
1174 SDValue Lo = DAG.getNode(PPCISD::Lo, DL, PtrVT, LoPart, Zero);
1178 Hi = DAG.getNode(ISD::ADD, DL, PtrVT,
1179 DAG.getNode(PPCISD::GlobalBaseReg, DL, PtrVT), Hi);
1183 return DAG.getNode(ISD::ADD, DL, PtrVT, Hi, Lo);
1187 SelectionDAG &DAG) const {
1193 bool isPIC = GetLabelAccessInfo(DAG.getTarget(), MOHiFlag, MOLoFlag);
1195 DAG.getTargetConstantPool(C, PtrVT, CP->getAlignment(), 0, MOHiFlag);
1197 DAG.getTargetConstantPool(C, PtrVT, CP->getAlignment(), 0, MOLoFlag);
1198 return LowerLabelRef(CPIHi, CPILo, isPIC, DAG);
1201 SDValue PPCTargetLowering::LowerJumpTable(SDValue Op, SelectionDAG &DAG) const {
1206 bool isPIC = GetLabelAccessInfo(DAG.getTarget(), MOHiFlag, MOLoFlag);
1207 SDValue JTIHi = DAG.getTargetJumpTable(JT->getIndex(), PtrVT, MOHiFlag);
1208 SDValue JTILo = DAG.getTargetJumpTable(JT->getIndex(), PtrVT, MOLoFlag);
1209 return LowerLabelRef(JTIHi, JTILo, isPIC, DAG);
1213 SelectionDAG &DAG) const {
1219 bool isPIC = GetLabelAccessInfo(DAG.getTarget(), MOHiFlag, MOLoFlag);
1220 SDValue TgtBAHi = DAG.getBlockAddress(BA, PtrVT, /*isTarget=*/true, MOHiFlag);
1221 SDValue TgtBALo = DAG.getBlockAddress(BA, PtrVT, /*isTarget=*/true, MOLoFlag);
1222 return LowerLabelRef(TgtBAHi, TgtBALo, isPIC, DAG);
1226 SelectionDAG &DAG) const {
1235 SDValue GA = DAG.getTargetGlobalAddress(GV, DL, PtrVT, GSDN->getOffset());
1236 return DAG.getNode(PPCISD::TOC_ENTRY, DL, MVT::i64, GA,
1237 DAG.getRegister(PPC::X2, MVT::i64));
1241 bool isPIC = GetLabelAccessInfo(DAG.getTarget(), MOHiFlag, MOLoFlag, GV);
1244 DAG.getTargetGlobalAddress(GV, DL, PtrVT, GSDN->getOffset(), MOHiFlag);
1246 DAG.getTargetGlobalAddress(GV, DL, PtrVT, GSDN->getOffset(), MOLoFlag);
1248 SDValue Ptr = LowerLabelRef(GAHi, GALo, isPIC, DAG);
1253 Ptr = DAG.getLoad(PtrVT, DL, DAG.getEntryNode(), Ptr, MachinePointerInfo(),
1258 SDValue PPCTargetLowering::LowerSETCC(SDValue Op, SelectionDAG &DAG) const {
1263 // implented as a ctlz/srl pair on ppc, so that the dag combiner can
1271 Zext = DAG.getNode(ISD::ZERO_EXTEND, dl, VT, Op.getOperand(0));
1274 SDValue Clz = DAG.getNode(ISD::CTLZ, dl, VT, Zext);
1275 SDValue Scc = DAG.getNode(ISD::SRL, dl, VT, Clz,
1276 DAG.getConstant(Log2b, MVT::i32));
1277 return DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Scc);
1294 SDValue Sub = DAG.getNode(ISD::XOR, dl, LHSVT, Op.getOperand(0),
1296 return DAG.getSetCC(dl, VT, Sub, DAG.getConstant(0, LHSVT), CC);
1301 SDValue PPCTargetLowering::LowerVAARG(SDValue Op, SelectionDAG &DAG,
1305 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
1314 SDValue GprIndex = DAG.getExtLoad(ISD::ZEXTLOAD, dl, MVT::i32, InChain,
1321 SDValue GprAnd = DAG.getNode(ISD::AND, dl, MVT::i32, GprIndex,
1322 DAG.getConstant(1, MVT::i32));
1323 SDValue CC64 = DAG.getSetCC(dl, MVT::i32, GprAnd,
1324 DAG.getConstant(0, MVT::i32), ISD::SETNE);
1325 SDValue GprIndexPlusOne = DAG.getNode(ISD::ADD, dl, MVT::i32, GprIndex,
1326 DAG.getConstant(1, MVT::i32));
1328 GprIndex = DAG.getNode(ISD::SELECT, dl, MVT::i32, CC64, GprIndexPlusOne,
1333 SDValue FprPtr = DAG.getNode(ISD::ADD, dl, PtrVT, VAListPtr,
1334 DAG.getConstant(1, MVT::i32));
1337 SDValue FprIndex = DAG.getExtLoad(ISD::ZEXTLOAD, dl, MVT::i32, InChain,
1342 SDValue RegSaveAreaPtr = DAG.getNode(ISD::ADD, dl, PtrVT, VAListPtr,
1343 DAG.getConstant(8, MVT::i32));
1345 SDValue OverflowAreaPtr = DAG.getNode(ISD::ADD, dl, PtrVT, VAListPtr,
1346 DAG.getConstant(4, MVT::i32));
1349 SDValue OverflowArea = DAG.getLoad(MVT::i32, dl, InChain, OverflowAreaPtr,
1354 SDValue RegSaveArea = DAG.getLoad(MVT::i32, dl, InChain, RegSaveAreaPtr,
1360 SDValue CC = DAG.getSetCC(dl, MVT::i32, VT.isInteger() ? GprIndex : FprIndex,
1361 DAG.getConstant(8, MVT::i32), ISD::SETLT);
1364 SDValue RegConstant = DAG.getNode(ISD::MUL, dl, MVT::i32,
1366 DAG.getConstant(VT.isInteger() ? 4 : 8,
1370 SDValue OurReg = DAG.getNode(ISD::ADD, dl, PtrVT, RegSaveArea,
1375 OurReg = DAG.getNode(ISD::ADD, dl, PtrVT, OurReg,
1376 DAG.getConstant(32, MVT::i32));
1379 SDValue IndexPlus1 = DAG.getNode(ISD::ADD, dl, MVT::i32,
1381 DAG.getConstant(VT == MVT::i64 ? 2 : 1,
1384 InChain = DAG.getTruncStore(InChain, dl, IndexPlus1,
1390 SDValue Result = DAG.getNode(ISD::SELECT, dl, PtrVT, CC, OurReg, OverflowArea);
1393 SDValue OverflowAreaPlusN = DAG.getNode(ISD::ADD, dl, PtrVT, OverflowArea,
1394 DAG.getConstant(VT.isInteger() ? 4 : 8,
1397 OverflowArea = DAG.getNode(ISD::SELECT, dl, MVT::i32, CC, OverflowArea,
1400 InChain = DAG.getTruncStore(InChain, dl, OverflowArea,
1405 return DAG.getLoad(VT, dl, InChain, Result, MachinePointerInfo(),
1410 SelectionDAG &DAG) const {
1415 SelectionDAG &DAG) const {
1422 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
1425 DAG.getTargetLoweringInfo().getTargetData()->getIntPtrType(
1426 *DAG.getContext());
1435 Entry.Node = DAG.getConstant(isPPC64 ? 48 : 40,
1444 LowerCallTo(Chain, Type::getVoidTy(*DAG.getContext()),
1448 DAG.getExternalSymbol("__trampoline_setup", PtrVT),
1449 Args, DAG, dl);
1454 SDValue PPCTargetLowering::LowerVASTART(SDValue Op, SelectionDAG &DAG,
1456 MachineFunction &MF = DAG.getMachineFunction();
1464 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
1465 SDValue FR = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), PtrVT);
1467 return DAG.getStore(Op.getOperand(0), dl, FR, Op.getOperand(1),
1497 SDValue ArgGPR = DAG.getConstant(FuncInfo->getVarArgsNumGPR(), MVT::i32);
1498 SDValue ArgFPR = DAG.getConstant(FuncInfo->getVarArgsNumFPR(), MVT::i32);
1501 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
1503 SDValue StackOffsetFI = DAG.getFrameIndex(FuncInfo->getVarArgsStackOffset(),
1505 SDValue FR = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
1509 SDValue ConstFrameOffset = DAG.getConstant(FrameOffset, PtrVT);
1512 SDValue ConstStackOffset = DAG.getConstant(StackOffset, PtrVT);
1515 SDValue ConstFPROffset = DAG.getConstant(FPROffset, PtrVT);
1520 SDValue firstStore = DAG.getTruncStore(Op.getOperand(0), dl, ArgGPR,
1525 SDValue nextPtr = DAG.getNode(ISD::ADD, dl, PtrVT, Op.getOperand(1),
1530 DAG.getTruncStore(firstStore, dl, ArgFPR, nextPtr,
1534 nextPtr = DAG.getNode(ISD::ADD, dl, PtrVT, nextPtr, ConstStackOffset);
1538 DAG.getStore(secondStore, dl, StackOffsetFI, nextPtr,
1542 nextPtr = DAG.getNode(ISD::ADD, dl, PtrVT, nextPtr, ConstFrameOffset);
1545 return DAG.getStore(thirdStore, dl, FR, nextPtr,
1642 DebugLoc dl, SelectionDAG &DAG,
1647 dl, DAG, InVals);
1650 dl, DAG, InVals);
1660 DebugLoc dl, SelectionDAG &DAG,
1692 MachineFunction &MF = DAG.getMachineFunction();
1696 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
1704 CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
1705 getTargetMachine(), ArgLocs, *DAG.getContext());
1742 SDValue ArgValue = DAG.getCopyFromReg(Chain, dl, Reg, ValVT);
1754 SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
1755 InVals.push_back(DAG.getLoad(VA.getValVT(), dl, Chain, FIN,
1765 CCState CCByValInfo(CallConv, isVarArg, DAG.getMachineFunction(),
1766 getTargetMachine(), ByValArgLocs, *DAG.getContext());
1786 unsigned TargetAlign = DAG.getMachineFunction().getTarget().getFrameLowering()->
1824 SDValue FIN = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), PtrVT);
1835 SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
1836 SDValue Store = DAG.getStore(Val.getValue(1), dl, Val, FIN,
1840 SDValue PtrOff = DAG.getConstant(PtrVT.getSizeInBits()/8, PtrVT);
1841 FIN = DAG.getNode(ISD::ADD, dl, PtrOff.getValueType(), FIN, PtrOff);
1854 SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, MVT::f64);
1855 SDValue Store = DAG.getStore(Val.getValue(1), dl, Val, FIN,
1859 SDValue PtrOff = DAG.getConstant(EVT(MVT::f64).getSizeInBits()/8,
1861 FIN = DAG.getNode(ISD::ADD, dl, PtrOff.getValueType(), FIN, PtrOff);
1866 Chain = DAG.getNode(ISD::TokenFactor, dl,
1878 DebugLoc dl, SelectionDAG &DAG,
1882 MachineFunction &MF = DAG.getMachineFunction();
1886 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
1968 // Add DAG nodes to load the arguments or copy them out of registers. On
2012 SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
2021 SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
2022 SDValue Store = DAG.getTruncStore(Val.getValue(1), dl, Val, FIN,
2045 SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
2046 SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
2047 SDValue Store = DAG.getStore(Val.getValue(1), dl, Val, FIN,
2067 ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, MVT::i32);
2081 ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, MVT::i64);
2087 ArgVal = DAG.getNode(ISD::AssertSext, dl, MVT::i64, ArgVal,
2088 DAG.getValueType(ObjectVT));
2090 ArgVal = DAG.getNode(ISD::AssertZext, dl, MVT::i64, ArgVal,
2091 DAG.getValueType(ObjectVT));
2093 ArgVal = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, ArgVal);
2122 ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, ObjectVT);
2139 ArgVal = DAG.getCopyFromReg(Chain, dl, VReg, ObjectVT);
2172 SDValue FIN = DAG.getFrameIndex(FI, PtrVT);
2173 ArgVal = DAG.getLoad(ObjectVT, dl, Chain, FIN, MachinePointerInfo(),
2193 unsigned TargetAlign = DAG.getMachineFunction().getTarget().getFrameLowering()->
2207 SDValue FIN = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), PtrVT);
2220 SDValue Val = DAG.getCopyFromReg(Chain, dl, VReg, PtrVT);
2221 SDValue Store = DAG.getStore(Val.getValue(1), dl, Val, FIN,
2225 SDValue PtrOff = DAG.getConstant(PtrVT.getSizeInBits()/8, PtrVT);
2226 FIN = DAG.getNode(ISD::ADD, dl, PtrOff.getValueType(), FIN, PtrOff);
2231 Chain = DAG.getNode(ISD::TokenFactor, dl,
2240 CalculateParameterAndLinkageAreaSize(SelectionDAG &DAG,
2295 if (CC == CallingConv::Fast && DAG.getTarget().Options.GuaranteedTailCallOpt){
2296 unsigned TargetAlign = DAG.getMachineFunction().getTarget().
2307 static int CalculateTailCallSPDiff(SelectionDAG& DAG, bool isTailCall,
2312 PPCFunctionInfo *FI = DAG.getMachineFunction().getInfo<PPCFunctionInfo>();
2330 SelectionDAG& DAG) const {
2338 MachineFunction &MF = DAG.getMachineFunction();
2363 static SDNode *isBLACompatibleAddress(SDValue Op, SelectionDAG &DAG) {
2372 return DAG.getConstant((int)C->getZExtValue() >> 2,
2373 DAG.getTargetLoweringInfo().getPointerTy()).getNode();
2390 StoreTailCallArgumentsToStackSlot(SelectionDAG &DAG,
2400 MemOpChains.push_back(DAG.getStore(Chain, dl, Arg, FIN,
2408 static SDValue EmitTailCallStoreFPAndRetAddr(SelectionDAG &DAG,
2425 SDValue NewRetAddrFrIdx = DAG.getFrameIndex(NewRetAddr, VT);
2426 Chain = DAG.getStore(Chain, dl, OldRetAddr, NewRetAddrFrIdx,
2437 SDValue NewFramePtrIdx = DAG.getFrameIndex(NewFPIdx, VT);
2438 Chain = DAG.getStore(Chain, dl, OldFP, NewFramePtrIdx,
2449 CalculateTailCallArgDest(SelectionDAG &DAG, MachineFunction &MF, bool isPPC64,
2456 SDValue FIN = DAG.getFrameIndex(FI, VT);
2467 SDValue PPCTargetLowering::EmitTailCallLoadFPAndRetAddr(SelectionDAG & DAG,
2477 LROpOut = getReturnAddrFrameIndex(DAG);
2478 LROpOut = DAG.getLoad(VT, dl, Chain, LROpOut, MachinePointerInfo(),
2485 FPOpOut = getFramePointerFrameIndex(DAG);
2486 FPOpOut = DAG.getLoad(VT, dl, Chain, FPOpOut, MachinePointerInfo(),
2502 ISD::ArgFlagsTy Flags, SelectionDAG &DAG,
2504 SDValue SizeNode = DAG.getConstant(Flags.getByValSize(), MVT::i32);
2505 return DAG.getMemcpy(Chain, dl, Dst, Src, SizeNode, Flags.getByValAlign(),
2513 LowerMemOpCallTo(SelectionDAG &DAG, MachineFunction &MF, SDValue Chain,
2519 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
2524 StackPtr = DAG.getRegister(PPC::X1, MVT::i64);
2526 StackPtr = DAG.getRegister(PPC::R1, MVT::i32);
2527 PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr,
2528 DAG.getConstant(ArgOffset, PtrVT));
2530 MemOpChains.push_back(DAG.getStore(Chain, dl, Arg, PtrOff,
2533 } else CalculateTailCallArgDest(DAG, MF, isPPC64, Arg, SPDiff, ArgOffset,
2538 void PrepareTailCall(SelectionDAG &DAG, SDValue &InFlag, SDValue &Chain,
2542 MachineFunction &MF = DAG.getMachineFunction();
2549 StoreTailCallArgumentsToStackSlot(DAG, Chain, TailCallArguments,
2552 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
2556 Chain = EmitTailCallStoreFPAndRetAddr(DAG, MF, Chain, LROp, FPOp, SPDiff,
2560 Chain = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(NumBytes, true),
2561 DAG.getIntPtrConstant(0, true), InFlag);
2566 unsigned PrepareCall(SelectionDAG &DAG, SDValue &Callee, SDValue &InFlag,
2575 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
2582 if (SDNode *Dest = isBLACompatibleAddress(Callee, DAG)) {
2592 if (!DAG.getTarget().getSubtarget<PPCSubtarget>().isJITCodeModel()) {
2594 if (DAG.getTarget().getRelocationModel() != Reloc::Static &&
2608 Callee = DAG.getTargetGlobalAddress(G->getGlobal(), dl,
2618 if (DAG.getTarget().getRelocationModel() != Reloc::Static &&
2627 Callee = DAG.getTargetExternalSymbol(S->getSymbol(), Callee.getValueType(),
2666 SDVTList VTs = DAG.getVTList(MVT::i64, MVT::Other, MVT::Glue);
2667 SDValue LoadFuncPtr = DAG.getNode(PPCISD::LOAD, dl, VTs, MTCTROps,
2674 SDValue PtrOff = DAG.getIntPtrConstant(16);
2676 SDValue AddPtr = DAG.getNode(ISD::ADD, dl, MVT::i64, Callee, PtrOff);
2677 SDValue LoadEnvPtr = DAG.getNode(PPCISD::LOAD, dl, VTs, Chain, AddPtr,
2682 SDValue EnvVal = DAG.getCopyToReg(Chain, dl, PPC::X11, LoadEnvPtr,
2693 VTs = DAG.getVTList(MVT::Other, MVT::Glue);
2694 SDValue LoadTOCPtr = DAG.getNode(PPCISD::LOAD_TOC, dl, VTs, Chain,
2704 Chain = DAG.getNode(PPCISD::MTCTR, dl, NodeTys, MTCTROps,
2716 Ops.push_back(DAG.getRegister(isPPC64 ? PPC::CTR8 : PPC::CTR, PtrVT));
2726 Ops.push_back(DAG.getConstant(SPDiff, MVT::i32));
2731 Ops.push_back(DAG.getRegister(RegsToPass[i].first,
2741 DebugLoc dl, SelectionDAG &DAG,
2745 CCState CCRetInfo(CallConv, isVarArg, DAG.getMachineFunction(),
2746 getTargetMachine(), RVLocs, *DAG.getContext());
2754 Chain = DAG.getCopyFromReg(Chain, dl,
2766 SelectionDAG &DAG,
2776 unsigned CallOpc = PrepareCall(DAG, Callee, InFlag, Chain, dl, SPDiff,
2791 Ops.push_back(DAG.getRegisterMask(Mask));
2800 if (DAG.getMachineFunction().getRegInfo().liveout_empty()) {
2802 CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
2803 getTargetMachine(), RVLocs, *DAG.getContext());
2806 DAG.getMachineFunction().getRegInfo().addLiveOut(RVLocs[i].getLocReg());
2816 return DAG.getNode(PPCISD::TC_RETURN, dl, MVT::Other, &Ops[0], Ops.size());
2847 Chain = DAG.getNode(CallOpc, dl, NodeTys, &Ops[0], Ops.size());
2851 SDVTList VTs = DAG.getVTList(MVT::Other, MVT::Glue);
2852 Chain = DAG.getNode(PPCISD::TOC_RESTORE, dl, VTs, Chain, InFlag);
2856 Chain = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(NumBytes, true),
2857 DAG.getIntPtrConstant(BytesCalleePops, true),
2863 Ins, dl, DAG, InVals);
2873 DebugLoc dl, SelectionDAG &DAG,
2877 Ins, DAG);
2882 dl, DAG, InVals);
2886 dl, DAG, InVals);
2896 DebugLoc dl, SelectionDAG &DAG,
2906 MachineFunction &MF = DAG.getMachineFunction();
2923 CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
2924 getTargetMachine(), ArgLocs, *DAG.getContext());
2963 CCState CCByValInfo(CallConv, isVarArg, DAG.getMachineFunction(),
2964 getTargetMachine(), ByValArgLocs, *DAG.getContext());
2978 int SPDiff = CalculateTailCallSPDiff(DAG, isTailCall, NumBytes);
2982 Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(NumBytes, true));
2988 Chain = EmitTailCallLoadFPAndRetAddr(DAG, SPDiff, Chain, LROp, FPOp, false,
2994 SDValue StackPtr = DAG.getRegister(PPC::R1, MVT::i32);
3021 SDValue PtrOff = DAG.getIntPtrConstant(LocMemOffset);
3022 PtrOff = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr, PtrOff);
3029 Flags, DAG, dl);
3032 SDValue NewCallSeqStart = DAG.getCALLSEQ_START(MemcpyCall,
3034 DAG.ReplaceAllUsesWith(CallSeqStart.getNode(),
3054 SDValue PtrOff = DAG.getIntPtrConstant(LocMemOffset);
3055 PtrOff = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr, PtrOff);
3057 MemOpChains.push_back(DAG.getStore(Chain, dl, Arg, PtrOff,
3062 CalculateTailCallArgDest(DAG, MF, false, Arg, SPDiff, LocMemOffset,
3069 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
3075 SDValue SetCR(DAG.getMachineNode(seenFloatArg ? PPC::CRSET : PPC::CRUNSET,
3084 Chain = DAG.getCopyToReg(Chain, dl, RegsToPass[i].first,
3090 PrepareTailCall(DAG, InFlag, Chain, dl, false, SPDiff, NumBytes, LROp, FPOp,
3093 return FinishCall(CallConv, dl, isTailCall, isVarArg, DAG,
3105 DebugLoc dl, SelectionDAG &DAG,
3110 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
3114 MachineFunction &MF = DAG.getMachineFunction();
3131 CalculateParameterAndLinkageAreaSize(DAG, isPPC64, isVarArg, CallConv,
3137 int SPDiff = CalculateTailCallSPDiff(DAG, isTailCall, NumBytes);
3142 Chain = DAG.getStackArgumentTokenFactor(Chain);
3146 Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(NumBytes, true));
3152 Chain = EmitTailCallLoadFPAndRetAddr(DAG, SPDiff, Chain, LROp, FPOp, true,
3160 StackPtr = DAG.getRegister(PPC::X1, MVT::i64);
3162 StackPtr = DAG.getRegister(PPC::R1, MVT::i32);
3203 PtrOff = DAG.getConstant(ArgOffset, StackPtr.getValueType());
3205 PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr, PtrOff);
3211 Arg = DAG.getNode(ExtOp, dl, MVT::i64, Arg);
3222 SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, PtrVT, Chain, Arg,
3230 SDValue Const = DAG.getConstant(4 - Size, PtrOff.getValueType());
3231 SDValue AddPtr = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, Const);
3234 Flags, DAG, dl);
3236 SDValue NewCallSeqStart = DAG.getCALLSEQ_START(MemcpyCall,
3238 DAG.ReplaceAllUsesWith(CallSeqStart.getNode(),
3250 Flags, DAG, dl);
3252 SDValue NewCallSeqStart = DAG.getCALLSEQ_START(MemcpyCall,
3254 DAG.ReplaceAllUsesWith(CallSeqStart.getNode(), NewCallSeqStart.getNode());
3258 SDValue Const = DAG.getConstant(j, PtrOff.getValueType());
3259 SDValue AddArg = DAG.getNode(ISD::ADD, dl, PtrVT, Arg, Const);
3261 SDValue Load = DAG.getLoad(PtrVT, dl, Chain, AddArg,
3282 LowerMemOpCallTo(DAG, MF, Chain, Arg, PtrOff, SPDiff, ArgOffset,
3294 SDValue Store = DAG.getStore(Chain, dl, Arg, PtrOff,
3300 SDValue Load = DAG.getLoad(PtrVT, dl, Store, PtrOff,
3307 SDValue ConstFour = DAG.getConstant(4, PtrOff.getValueType());
3308 PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, ConstFour);
3309 SDValue Load = DAG.getLoad(PtrVT, dl, Store, PtrOff,
3326 LowerMemOpCallTo(DAG, MF, Chain, Arg, PtrOff, SPDiff, ArgOffset,
3352 PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr,
3353 DAG.getConstant(ArgOffset, PtrVT));
3354 SDValue Store = DAG.getStore(Chain, dl, Arg, PtrOff,
3358 SDValue Load = DAG.getLoad(MVT::v4f32, dl, Store, PtrOff,
3368 SDValue Ix = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff,
3369 DAG.getConstant(i, PtrVT));
3370 SDValue Load = DAG.getLoad(PtrVT, dl, Store, Ix, MachinePointerInfo(),
3385 LowerMemOpCallTo(DAG, MF, Chain, Arg, PtrOff, SPDiff, ArgOffset,
3411 LowerMemOpCallTo(DAG, MF, Chain, Arg, PtrOff, SPDiff, ArgOffset,
3421 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
3430 !isBLACompatibleAddress(Callee, DAG)) {
3432 SDValue Val = DAG.getCopyFromReg(Chain, dl, PPC::X2, MVT::i64);
3434 SDValue PtrOff = DAG.getIntPtrConstant(40);
3435 SDValue AddPtr = DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr, PtrOff);
3436 Chain = DAG.getStore(Val.getValue(1), dl, Val, AddPtr, MachinePointerInfo(),
3446 !isBLACompatibleAddress(Callee, DAG))
3454 Chain = DAG.getCopyToReg(Chain, dl, RegsToPass[i].first,
3460 PrepareTailCall(DAG, InFlag, Chain, dl, isPPC64, SPDiff, NumBytes, LROp,
3463 return FinishCall(CallConv, dl, isTailCall, isVarArg, DAG,
3484 DebugLoc dl, SelectionDAG &DAG) const {
3487 CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
3488 getTargetMachine(), RVLocs, *DAG.getContext());
3493 if (DAG.getMachineFunction().getRegInfo().liveout_empty()) {
3495 DAG.getMachineFunction().getRegInfo().addLiveOut(RVLocs[i].getLocReg());
3504 Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(),
3510 return DAG.getNode(PPCISD::RET_FLAG, dl, MVT::Other, Chain, Flag);
3512 return DAG.getNode(PPCISD::RET_FLAG, dl, MVT::Other, Chain);
3515 SDValue PPCTargetLowering::LowerSTACKRESTORE(SDValue Op, SelectionDAG &DAG,
3521 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
3526 SDValue StackPtr = DAG.getRegister(SP, PtrVT);
3533 SDValue LoadLinkSP = DAG.getLoad(PtrVT, dl, Chain, StackPtr,
3538 Chain = DAG.getCopyToReg(LoadLinkSP.getValue(1), dl, SP, SaveSP);
3541 return DAG.getStore(Chain, dl, LoadLinkSP, StackPtr, MachinePointerInfo(),
3548 PPCTargetLowering::getReturnAddrFrameIndex(SelectionDAG & DAG) const {
3549 MachineFunction &MF = DAG.getMachineFunction();
3552 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
3568 return DAG.getFrameIndex(RASI, PtrVT);
3572 PPCTargetLowering::getFramePointerFrameIndex(SelectionDAG & DAG) const {
3573 MachineFunction &MF = DAG.getMachineFunction();
3576 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
3594 return DAG.getFrameIndex(FPSI, PtrVT);
3598 SelectionDAG &DAG,
3606 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
3608 SDValue NegSize = DAG.getNode(ISD::SUB, dl, PtrVT,
3609 DAG.getConstant(0, PtrVT), Size);
3611 SDValue FPSIdx = getFramePointerFrameIndex(DAG);
3614 SDVTList VTs = DAG.getVTList(PtrVT, MVT::Other);
3615 return DAG.getNode(PPCISD::DYNALLOC, dl, VTs, Ops, 3);
3620 SDValue PPCTargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const {
3648 LHS = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, LHS);
3649 return DAG.getNode(PPCISD::FSEL, dl, ResVT, LHS, TV, FV);
3656 LHS = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, LHS);
3657 return DAG.getNode(PPCISD::FSEL, dl, ResVT,
3658 DAG.getNode(ISD::FNEG, dl, MVT::f64, LHS), TV, FV);
3666 Cmp = DAG.getNode(ISD::FSUB, dl, CmpVT, LHS, RHS);
3668 Cmp = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Cmp);
3669 return DAG.getNode(PPCISD::FSEL, dl, ResVT, Cmp, FV, TV);
3672 Cmp = DAG.getNode(ISD::FSUB, dl, CmpVT, LHS, RHS);
3674 Cmp = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Cmp);
3675 return DAG.getNode(PPCISD::FSEL, dl, ResVT, Cmp, TV, FV);
3678 Cmp = DAG.getNode(ISD::FSUB, dl, CmpVT, RHS, LHS);
3680 Cmp = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Cmp);
3681 return DAG.getNode(PPCISD::FSEL, dl, ResVT, Cmp, FV, TV);
3684 Cmp = DAG.getNode(ISD::FSUB, dl, CmpVT, RHS, LHS);
3686 Cmp = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Cmp);
3687 return DAG.getNode(PPCISD::FSEL, dl, ResVT, Cmp, TV, FV);
3693 SDValue PPCTargetLowering::LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG,
3698 Src = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Src);
3704 Tmp = DAG.getNode(Op.getOpcode()==ISD::FP_TO_SINT ? PPCISD::FCTIWZ :
3709 Tmp = DAG.getNode(PPCISD::FCTIDZ, dl, MVT::f64, Src);
3714 SDValue FIPtr = DAG.CreateStackTemporary(MVT::f64);
3717 SDValue Chain = DAG.getStore(DAG.getEntryNode(), dl, Tmp, FIPtr,
3723 FIPtr = DAG.getNode(ISD::ADD, dl, FIPtr.getValueType(), FIPtr,
3724 DAG.getConstant(4, FIPtr.getValueType()));
3725 return DAG.getLoad(Op.getValueType(), dl, Chain, FIPtr, MachinePointerInfo(),
3730 SelectionDAG &DAG) const {
3737 SDValue Bits = DAG.getNode(ISD::BITCAST, dl, MVT::f64, Op.getOperand(0));
3738 SDValue FP = DAG.getNode(PPCISD::FCFID, dl, MVT::f64, Bits);
3740 FP = DAG.getNode(ISD::FP_ROUND, dl,
3741 MVT::f32, FP, DAG.getIntPtrConstant(0));
3751 MachineFunction &MF = DAG.getMachineFunction();
3754 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
3755 SDValue FIdx = DAG.getFrameIndex(FrameIdx, PtrVT);
3757 SDValue Ext64 = DAG.getNode(PPCISD::EXTSW_32, dl, MVT::i32,
3764 SDValue Ops[] = { DAG.getEntryNode(), Ext64, FIdx };
3766 DAG.getMemIntrinsicNode(PPCISD::STD_32, dl, DAG.getVTList(MVT::Other),
3769 SDValue Ld = DAG.getLoad(MVT::f64, dl, Store, FIdx, MachinePointerInfo(),
3773 SDValue FP = DAG.getNode(PPCISD::FCFID, dl, MVT::f64, Ld);
3775 FP = DAG.getNode(ISD::FP_ROUND, dl, MVT::f32, FP, DAG.getIntPtrConstant(0));
3780 SelectionDAG &DAG) const {
3801 MachineFunction &MF = DAG.getMachineFunction();
3803 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
3810 SDValue Chain = DAG.getNode(PPCISD::MFFS, dl, NodeTys, &InFlag, 0);
3814 SDValue StackSlot = DAG.getFrameIndex(SSFI, PtrVT);
3815 SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, Chain,
3819 SDValue Four = DAG.getConstant(4, PtrVT);
3820 SDValue Addr = DAG.getNode(ISD::ADD, dl, PtrVT, StackSlot, Four);
3821 SDValue CWD = DAG.getLoad(MVT::i32, dl, Store, Addr, MachinePointerInfo(),
3826 DAG.getNode(ISD::AND, dl, MVT::i32,
3827 CWD, DAG.getConstant(3, MVT::i32));
3829 DAG.getNode(ISD::SRL, dl, MVT::i32,
3830 DAG.getNode(ISD::AND, dl, MVT::i32,
3831 DAG.getNode(ISD::XOR, dl, MVT::i32,
3832 CWD, DAG.getConstant(3, MVT::i32)),
3833 DAG.getConstant(3, MVT::i32)),
3834 DAG.getConstant(1, MVT::i32));
3837 DAG.getNode(ISD::XOR, dl, MVT::i32, CWD1, CWD2);
3839 return DAG.getNode((VT.getSizeInBits() < 16 ?
3843 SDValue PPCTargetLowering::LowerSHL_PARTS(SDValue Op, SelectionDAG &DAG) const {
3858 SDValue Tmp1 = DAG.getNode(ISD::SUB, dl, AmtVT,
3859 DAG.getConstant(BitWidth, AmtVT), Amt);
3860 SDValue Tmp2 = DAG.getNode(PPCISD::SHL, dl, VT, Hi, Amt);
3861 SDValue Tmp3 = DAG.getNode(PPCISD::SRL, dl, VT, Lo, Tmp1);
3862 SDValue Tmp4 = DAG.getNode(ISD::OR , dl, VT, Tmp2, Tmp3);
3863 SDValue Tmp5 = DAG.getNode(ISD::ADD, dl, AmtVT, Amt,
3864 DAG.getConstant(-BitWidth, AmtVT));
3865 SDValue Tmp6 = DAG.getNode(PPCISD::SHL, dl, VT, Lo, Tmp5);
3866 SDValue OutHi = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp6);
3867 SDValue OutLo = DAG.getNode(PPCISD::SHL, dl, VT, Lo, Amt);
3869 return DAG.getMergeValues(OutOps, 2, dl);
3872 SDValue PPCTargetLowering::LowerSRL_PARTS(SDValue Op, SelectionDAG &DAG) const {
3887 SDValue Tmp1 = DAG.getNode(ISD::SUB, dl, AmtVT,
3888 DAG.getConstant(BitWidth, AmtVT), Amt);
3889 SDValue Tmp2 = DAG.getNode(PPCISD::SRL, dl, VT, Lo, Amt);
3890 SDValue Tmp3 = DAG.getNode(PPCISD::SHL, dl, VT, Hi, Tmp1);
3891 SDValue Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp3);
3892 SDValue Tmp5 = DAG.getNode(ISD::ADD, dl, AmtVT, Amt,
3893 DAG.getConstant(-BitWidth, AmtVT));
3894 SDValue Tmp6 = DAG.getNode(PPCISD::SRL, dl, VT, Hi, Tmp5);
3895 SDValue OutLo = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp6);
3896 SDValue OutHi = DAG.getNode(PPCISD::SRL, dl, VT, Hi, Amt);
3898 return DAG.getMergeValues(OutOps, 2, dl);
3901 DAG) const {
3915 SDValue Tmp1 = DAG.getNode(ISD::SUB, dl, AmtVT,
3916 DAG.getConstant(BitWidth, AmtVT), Amt);
3917 SDValue Tmp2 = DAG.getNode(PPCISD::SRL, dl, VT, Lo, Amt);
3918 SDValue Tmp3 = DAG.getNode(PPCISD::SHL, dl, VT, Hi, Tmp1);
3919 SDValue Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp3);
3920 SDValue Tmp5 = DAG.getNode(ISD::ADD, dl, AmtVT, Amt,
3921 DAG.getConstant(-BitWidth, AmtVT));
3922 SDValue Tmp6 = DAG.getNode(PPCISD::SRA, dl, VT, Hi, Tmp5);
3923 SDValue OutHi = DAG.getNode(PPCISD::SRA, dl, VT, Hi, Amt);
3924 SDValue OutLo = DAG.getSelectCC(dl, Tmp5, DAG.getConstant(0, AmtVT),
3927 return DAG.getMergeValues(OutOps, 2, dl);
3937 SelectionDAG &DAG, DebugLoc dl) {
3953 SDValue Elt = DAG.getConstant(Val, MVT::i32);
3956 SDValue Res = DAG.getNode(ISD::BUILD_VECTOR, dl, CanonicalVT,
3958 return DAG.getNode(ISD::BITCAST, dl, ReqVT, Res);
3964 SelectionDAG &DAG, DebugLoc dl,
3967 return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, DestVT,
3968 DAG.getConstant(IID, MVT::i32), LHS, RHS);
3974 SDValue Op2, SelectionDAG &DAG,
3977 return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, DestVT,
3978 DAG.getConstant(IID, MVT::i32), Op0, Op1, Op2);
3985 EVT VT, SelectionDAG &DAG, DebugLoc dl) {
3987 LHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, LHS);
3988 RHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, RHS);
3993 SDValue T = DAG.getVectorShuffle(MVT::v16i8, dl, LHS, RHS, Ops);
3994 return DAG.getNode(ISD::BITCAST, dl, VT, T);
4003 SelectionDAG &DAG) const {
4026 SDValue Z = DAG.getConstant(0, MVT::i32);
4027 Z = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Z, Z, Z, Z);
4028 Op = DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Z);
4037 return BuildSplatI(SextVal, SplatSize, Op.getValueType(), DAG, dl);
4045 SDValue Res = BuildSplatI(SextVal >> 1, SplatSize, MVT::Other, DAG, dl);
4046 Res = DAG.getNode(ISD::ADD, dl, Res.getValueType(), Res, Res);
4047 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
4055 SDValue OnesV = BuildSplatI(-1, 4, MVT::v4i32, DAG, dl);
4059 OnesV, DAG, dl);
4062 Res = DAG.getNode(ISD::XOR, dl, MVT::v4i32, Res, OnesV);
4063 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
4083 SDValue Res = BuildSplatI(i, SplatSize, MVT::Other, DAG, dl);
4088 Res = BuildIntrinsicOp(IIDs[SplatSize-1], Res, Res, DAG, dl);
4089 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
4094 SDValue Res = BuildSplatI(i, SplatSize, MVT::Other, DAG, dl);
4099 Res = BuildIntrinsicOp(IIDs[SplatSize-1], Res, Res, DAG, dl);
4100 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
4105 SDValue Res = BuildSplatI(i, SplatSize, MVT::Other, DAG, dl);
4110 Res = BuildIntrinsicOp(IIDs[SplatSize-1], Res, Res, DAG, dl);
4111 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
4117 SDValue Res = BuildSplatI(i, SplatSize, MVT::Other, DAG, dl);
4122 Res = BuildIntrinsicOp(IIDs[SplatSize-1], Res, Res, DAG, dl);
4123 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
4128 SDValue T = BuildSplatI(i, SplatSize, MVT::v16i8, DAG, dl);
4129 return BuildVSLDOI(T, T, 1, Op.getValueType(), DAG, dl);
4133 SDValue T = BuildSplatI(i, SplatSize, MVT::v16i8, DAG, dl);
4134 return BuildVSLDOI(T, T, 2, Op.getValueType(), DAG, dl);
4138 SDValue T = BuildSplatI(i, SplatSize, MVT::v16i8, DAG, dl);
4139 return BuildVSLDOI(T, T, 3, Op.getValueType(), DAG, dl);
4147 SDValue LHS = BuildSplatI(SextVal-16, SplatSize, MVT::Other, DAG, dl);
4148 SDValue RHS = BuildSplatI(-16, SplatSize, MVT::Other, DAG, dl);
4149 LHS = DAG.getNode(ISD::SUB, dl, LHS.getValueType(), LHS, RHS);
4150 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), LHS);
4154 SDValue LHS = BuildSplatI(SextVal+16, SplatSize, MVT::Other, DAG, dl);
4155 SDValue RHS = BuildSplatI(-16, SplatSize, MVT::Other, DAG, dl);
4156 LHS = DAG.getNode(ISD::ADD, dl, LHS.getValueType(), LHS, RHS);
4157 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), LHS);
4166 SDValue RHS, SelectionDAG &DAG,
4192 OpLHS = GeneratePerfectShuffle(PerfectShuffleTable[LHSID], LHS, RHS, DAG, dl);
4193 OpRHS = GeneratePerfectShuffle(PerfectShuffleTable[RHSID], LHS, RHS, DAG, dl);
4227 return BuildVSLDOI(OpLHS, OpRHS, 4, OpLHS.getValueType(), DAG, dl);
4229 return BuildVSLDOI(OpLHS, OpRHS, 8, OpLHS.getValueType(), DAG, dl);
4231 return BuildVSLDOI(OpLHS, OpRHS, 12, OpLHS.getValueType(), DAG, dl);
4234 OpLHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, OpLHS);
4235 OpRHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, OpRHS);
4236 SDValue T = DAG.getVectorShuffle(MVT::v16i8, dl, OpLHS, OpRHS, ShufIdxs);
4237 return DAG.getNode(ISD::BITCAST, dl, VT, T);
4245 SelectionDAG &DAG) const {
4337 return GeneratePerfectShuffle(PFEntry, V1, V2, DAG, dl);
4354 ResultMask.push_back(DAG.getConstant(SrcElt*BytesPerElement+j,
4358 SDValue VPermMask = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v16i8,
4360 return DAG.getNode(PPCISD::VPERM, dl, V1.getValueType(), V1, V2, VPermMask);
4410 SelectionDAG &DAG) const {
4421 SDValue Tmp = DAG.getNode(PPCISD::VCMP, dl, Op.getOperand(2).getValueType(),
4423 DAG.getConstant(CompareOpc, MVT::i32));
4424 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Tmp);
4431 DAG.getConstant(CompareOpc, MVT::i32)
4436 SDValue CompNode = DAG.getNode(PPCISD::VCMPo, dl, VTs, Ops, 3);
4440 SDValue Flags = DAG.getNode(PPCISD::MFCR, dl, MVT::i32,
4441 DAG.getRegister(PPC::CR6, MVT::i32),
4464 Flags = DAG.getNode(ISD::SRL, dl, MVT::i32, Flags,
4465 DAG.getConstant(8-(3-BitNo), MVT::i32));
4467 Flags = DAG.getNode(ISD::AND, dl, MVT::i32, Flags,
4468 DAG.getConstant(1, MVT::i32));
4472 Flags = DAG.getNode(ISD::XOR, dl, MVT::i32, Flags,
4473 DAG.getConstant(1, MVT::i32));
4478 SelectionDAG &DAG) const {
4481 MachineFrameInfo *FrameInfo = DAG.getMachineFunction().getFrameInfo();
4484 SDValue FIdx = DAG.getFrameIndex(FrameIdx, PtrVT);
4487 SDValue Store = DAG.getStore(DAG.getEntryNode(), dl,
4491 return DAG.getLoad(Op.getValueType(), dl, Store, FIdx, MachinePointerInfo(),
4495 SDValue PPCTargetLowering::LowerMUL(SDValue Op, SelectionDAG &DAG) const {
4500 SDValue Zero = BuildSplatI( 0, 1, MVT::v4i32, DAG, dl);
4501 SDValue Neg16 = BuildSplatI(-16, 4, MVT::v4i32, DAG, dl);//+16 as shift amt.
4504 BuildIntrinsicOp(Intrinsic::ppc_altivec_vrlw, RHS, Neg16, DAG, dl);
4507 LHS = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, LHS);
4508 RHS = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, RHS);
4509 RHSSwap = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, RHSSwap);
4514 LHS, RHS, DAG, dl, MVT::v4i32);
4517 LHS, RHSSwap, Zero, DAG, dl, MVT::v4i32);
4520 Neg16, DAG, dl);
4521 return DAG.getNode(ISD::ADD, dl, MVT::v4i32, LoProd, HiProd);
4525 SDValue Zero = BuildSplatI(0, 1, MVT::v8i16, DAG, dl);
4528 LHS, RHS, Zero, DAG, dl);
4534 LHS, RHS, DAG, dl, MVT::v8i16);
4535 EvenParts = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, EvenParts);
4539 LHS, RHS, DAG, dl, MVT::v8i16);
4540 OddParts = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, OddParts);
4548 return DAG.getVectorShuffle(MVT::v16i8, dl, EvenParts, OddParts, Ops);
4556 SDValue PPCTargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
4559 case ISD::ConstantPool: return LowerConstantPool(Op, DAG);
4560 case ISD::BlockAddress: return LowerBlockAddress(Op, DAG);
4561 case ISD::GlobalAddress: return LowerGlobalAddress(Op, DAG);
4563 case ISD::JumpTable: return LowerJumpTable(Op, DAG);
4564 case ISD::SETCC: return LowerSETCC(Op, DAG);
4565 case ISD::INIT_TRAMPOLINE: return LowerINIT_TRAMPOLINE(Op, DAG);
4566 case ISD::ADJUST_TRAMPOLINE: return LowerADJUST_TRAMPOLINE(Op, DAG);
4568 return LowerVASTART(Op, DAG, PPCSubTarget);
4571 return LowerVAARG(Op, DAG, PPCSubTarget);
4573 case ISD::STACKRESTORE: return LowerSTACKRESTORE(Op, DAG, PPCSubTarget);
4575 return LowerDYNAMIC_STACKALLOC(Op, DAG, PPCSubTarget);
4577 case ISD::SELECT_CC: return LowerSELECT_CC(Op, DAG);
4579 case ISD::FP_TO_SINT: return LowerFP_TO_INT(Op, DAG,
4581 case ISD::SINT_TO_FP: return LowerSINT_TO_FP(Op, DAG);
4582 case ISD::FLT_ROUNDS_: return LowerFLT_ROUNDS_(Op, DAG);
4585 case ISD::SHL_PARTS: return LowerSHL_PARTS(Op, DAG);
4586 case ISD::SRL_PARTS: return LowerSRL_PARTS(Op, DAG);
4587 case ISD::SRA_PARTS: return LowerSRA_PARTS(Op, DAG);
4590 case ISD::BUILD_VECTOR: return LowerBUILD_VECTOR(Op, DAG);
4591 case ISD::VECTOR_SHUFFLE: return LowerVECTOR_SHUFFLE(Op, DAG);
4592 case ISD::INTRINSIC_WO_CHAIN: return LowerINTRINSIC_WO_CHAIN(Op, DAG);
4593 case ISD::SCALAR_TO_VECTOR: return LowerSCALAR_TO_VECTOR(Op, DAG);
4594 case ISD::MUL: return LowerMUL(Op, DAG);
4597 case ISD::RETURNADDR: return LowerRETURNADDR(Op, DAG);
4598 case ISD::FRAMEADDR: return LowerFRAMEADDR(Op, DAG);
4604 SelectionDAG &DAG) const {
4618 SDValue NewNode = LowerVAARG(SDValue(N, 1), DAG, PPCSubTarget);
4628 SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl,
4630 DAG.getIntPtrConstant(0));
4631 SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl,
4633 DAG.getIntPtrConstant(1));
4643 Result = DAG.getNode(PPCISD::MFFS, dl, NodeTys, &InFlag, 0);
4649 Ops[0] = DAG.getConstant(31, MVT::i32);
4651 Result = DAG.getNode(PPCISD::MTFSB1, dl, NodeTys, Ops, 2);
4656 Ops[0] = DAG.getConstant(30, MVT::i32);
4658 Result = DAG.getNode(PPCISD::MTFSB0, dl, NodeTys, Ops, 2);
4667 Result = DAG.getNode(PPCISD::FADDRTZ, dl, NodeTys, Ops, 3);
4673 Ops[0] = DAG.getConstant(1, MVT::i32);
4677 Result = DAG.getNode(PPCISD::MTFSF, dl, NodeTys, Ops, 4);
4682 Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, MVT::ppcf128,
4687 Results.push_back(LowerFP_TO_INT(SDValue(N, 0), DAG, dl));
5251 SelectionDAG &DAG = DCI.DAG;
5285 Val = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Val);
5289 Val = DAG.getNode(PPCISD::FCTIDZ, dl, MVT::f64, Val);
5291 Val = DAG.getNode(PPCISD::FCFID, dl, MVT::f64, Val);
5294 Val = DAG.getNode(ISD::FP_ROUND, dl, MVT::f32, Val,
5295 DAG.getIntPtrConstant(0));
5315 Val = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Val);
5318 Val = DAG.getNode(PPCISD::FCTIWZ, dl, MVT::f64, Val);
5321 Val = DAG.getNode(PPCISD::STFIWX, dl, MVT::Other, N->getOperand(0), Val,
5336 BSwapOp = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, BSwapOp);
5340 DAG.getValueType(N->getOperand(1).getValueType())
5343 DAG.getMemIntrinsicNode(PPCISD::STBRX, dl, DAG.getVTList(MVT::Other),
5360 DAG.getValueType(N->getValueType(0)) // VT
5363 DAG.getMemIntrinsicNode(PPCISD::LBRX, dl,
5364 DAG.getVTList(MVT::i32, MVT::Other), Ops, 3,
5370 ResVal = DAG.getNode(ISD::TRUNCATE, dl, MVT::i16, BSLoad);
5458 return DAG.getNode(ISD::BR, dl, MVT::Other,
5469 DAG.getConstant(CompareOpc, MVT::i32)
5473 SDValue CompNode = DAG.getNode(PPCISD::VCMPo, dl, VTs, Ops, 3);
5493 return DAG.getNode(PPCISD::COND_BRANCH, dl, MVT::Other, N->getOperand(0),
5494 DAG.getConstant(CompOpc, MVT::i32),
5495 DAG.getRegister(PPC::CR6, MVT::i32),
5512 const SelectionDAG &DAG,
5639 SelectionDAG &DAG) const {
5663 Result = DAG.getTargetConstant(Value, Op.getValueType());
5668 Result = DAG.getTargetConstant(Value, Op.getValueType());
5672 Result = DAG.getTargetConstant(Value, Op.getValueType());
5676 Result = DAG.getTargetConstant(Value, Op.getValueType());
5680 Result = DAG.getTargetConstant(Value, Op.getValueType());
5684 Result = DAG.getTargetConstant(Value, Op.getValueType());
5688 Result = DAG.getTargetConstant(Value, Op.getValueType());
5701 TargetLowering::LowerAsmOperandForConstraint(Op, Constraint, Ops, DAG);
5753 SelectionDAG &DAG) const {
5754 MachineFunction &MF = DAG.getMachineFunction();
5769 SDValue FrameAddr = LowerFRAMEADDR(Op, DAG);
5772 DAG.getConstant(PPCFrameLowering::getReturnSaveOffset(isPPC64, isDarwinABI),
5774 return DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(),
5775 DAG.getNode(ISD::ADD, dl, getPointerTy(),
5781 SDValue RetAddrFI = getReturnAddrFrameIndex(DAG);
5782 return DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(),
5787 SelectionDAG &DAG) const {
5791 EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
5794 MachineFunction &MF = DAG.getMachineFunction();
5803 SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl, FrameReg,
5806 FrameAddr = DAG.getLoad(Op.getValueType(), dl, DAG.getEntryNode(),
