Lines Matching refs:DAG
52 SelectionDAG &DAG;
78 DAG.TransferDbgValues(From, To);
82 explicit SelectionDAGLegalize(SelectionDAG &DAG);
175 return DAG.getVectorShuffle(NVT, dl, N1, N2, &Mask[0]);
189 return DAG.getVectorShuffle(NVT, dl, N1, N2, &NewMask[0]);
192 SelectionDAGLegalize::SelectionDAGLegalize(SelectionDAG &dag)
193 : TM(dag.getTarget()), TLI(dag.getTargetLoweringInfo()),
194 DAG(dag) {
198 LastCALLSEQ_END = DAG.getEntryNode();
207 DAG.AssignTopologicalOrder();
208 for (SelectionDAG::allnodes_iterator I = DAG.allnodes_begin(),
209 E = prior(DAG.allnodes_end()); I != llvm::next(E); ++I)
213 SDValue OldRoot = DAG.getRoot();
215 DAG.setRoot(LegalizedNodes[OldRoot]);
220 DAG.RemoveDeadNodes();
336 SelectionDAG &DAG, const TargetLowering &TLI) {
350 return DAG.getConstant(LLVMC->getValueAPF().bitcastToAPInt(),
363 Type *SType = SVT.getTypeForEVT(*DAG.getContext());
370 SDValue CPIdx = DAG.getConstantPool(LLVMC, TLI.getPointerTy());
373 return DAG.getExtLoad(ISD::EXTLOAD, dl, OrigVT,
374 DAG.getEntryNode(),
377 return DAG.getLoad(OrigVT, dl, DAG.getEntryNode(), CPIdx,
384 SDValue ExpandUnalignedStore(StoreSDNode *ST, SelectionDAG &DAG,
394 EVT intVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
399 SDValue Result = DAG
400 return DAG.getStore(Chain, dl, Result, Ptr, ST->getPointerInfo(),
407 TLI.getRegisterType(*DAG.getContext(),
408 EVT::getIntegerVT(*DAG.getContext(),
415 SDValue StackPtr = DAG.CreateStackTemporary(StoredVT, RegVT);
418 SDValue Store = DAG.getTruncStore(Chain, dl,
421 SDValue Increment = DAG.getConstant(RegBytes, TLI.getPointerTy());
428 SDValue Load = DAG.getLoad(RegVT, dl, Store, StackPtr,
432 Stores.push_back(DAG.getStore(Load.getValue(1), dl, Load, Ptr,
438 StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr,
440 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
446 EVT MemVT = EVT::getIntegerVT(*DAG.getContext(),
450 SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, RegVT, Store, StackPtr,
454 Stores.push_back(DAG.getTruncStore(Load.getValue(1), dl, Load, Ptr,
461 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &Stores[0],
468 EVT NewStoredVT = ST->getMemoryVT().getHalfSizedIntegerVT(*DAG.getContext());
473 SDValue ShiftAmount = DAG.getConstant(NumBits,
476 SDValue Hi = DAG.getNode(ISD::SRL, dl, VT, Val, ShiftAmount);
480 Store1 = DAG.getTruncStore(Chain, dl, TLI.isLittleEndian()?Lo:Hi, Ptr,
483 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
484 DAG.getConstant(IncrementSize, TLI.getPointerTy()));
486 Store2 = DAG.getTruncStore(Chain, dl, TLI.isLittleEndian()?Hi:Lo, Ptr,
491 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Store1, Store2);
496 SDValue ExpandUnalignedLoad(LoadSDNode *LD, SelectionDAG &DAG,
504 EVT intVT = EVT::getIntegerVT(*DAG.getContext(), LoadedVT.getSizeInBits());
508 SDValue newLoad = DAG.getLoad(intVT, dl, Chain, Ptr, LD->getPointerInfo(),
511 SDValue Result = DAG.getNode(ISD::BITCAST, dl, LoadedVT, newLoad);
513 Result = DAG.getNode(ISD::FP_EXTEND, dl, VT, Result);
516 return DAG.getMergeValues(Ops, 2, dl);
521 EVT RegVT = TLI.getRegisterType(*DAG.getContext(), intVT);
527 SDValue StackBase = DAG.CreateStackTemporary(LoadedVT, RegVT);
529 SDValue Increment = DAG.getConstant(RegBytes, TLI.getPointerTy());
537 SDValue Load = DAG.getLoad(RegVT, dl, Chain, Ptr,
542 Stores.push_back(DAG.getStore(Load.getValue(1), dl, Load, StackPtr,
546 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
547 StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr,
552 EVT MemVT = EVT::getIntegerVT(*DAG.getContext(),
554 SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, RegVT, Chain, Ptr,
562 Stores.push_back(DAG.getTruncStore(Load.getValue(1), dl, Load, StackPtr,
567 SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &Stores[0],
571 Load = DAG.getExtLoad(LD->getExtensionType(), dl, VT, TF, StackBase,
576 return DAG.getMergeValues(Ops, 2, dl);
585 NewLoadedVT = EVT::getIntegerVT(*DAG.getContext(), NumBits/2);
599 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, VT, Chain, Ptr, LD->getPointerInfo(),
602 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
603 DAG.getConstant(IncrementSize, TLI.getPointerTy()));
604 Hi = DAG.getExtLoad(HiExtType, dl, VT, Chain, Ptr,
609 Hi = DAG.getExtLoad(HiExtType, dl, VT, Chain, Ptr, LD->getPointerInfo(),
612 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
613 DAG.getConstant(IncrementSize, TLI.getPointerTy()));
614 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, VT, Chain, Ptr,
621 SDValue ShiftAmount = DAG.getConstant(NumBits,
623 SDValue Result = DAG.getNode(ISD::SHL, dl, VT, Hi, ShiftAmount);
624 Result = DAG.getNode(ISD::OR, dl, VT, Result, Lo);
626 SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
630 return DAG.getMergeValues(Ops, 2, dl);
654 SDValue StackPtr = DAG.CreateStackTemporary(VT);
659 SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, Tmp1, StackPtr,
665 Tmp3 = DAG.getNode(CastOpc, dl, PtrVT, Tmp3);
668 Tmp3 = DAG.getNode(ISD::MUL, dl, IdxVT, Tmp3,DAG.getConstant(EltSize, IdxVT));
669 SDValue StackPtr2 = DAG.getNode(ISD::ADD, dl, IdxVT, Tmp3, StackPtr);
671 Ch = DAG.getTruncStore(Ch, dl, Tmp2, StackPtr2, MachinePointerInfo(), EltVT,
674 return DAG.getLoad(VT, dl, Ch, StackPtr,
688 SDValue ScVec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
699 return DAG.getVectorShuffle(Vec.getValueType(), dl, Vec, ScVec,
709 // FIXME: move this to the DAG Combiner! Note that we can't regress due
710 // to phase ordering between legalized code and the dag combiner. This
711 // probably means that we need to integrate dag combiner and legalizer
724 Tmp3 = DAG.getConstant(CFP->getValueAPF().
727 return DAG.getStore(Tmp1, dl, Tmp3, Tmp2, ST->getPointerInfo(),
734 Tmp3 = DAG.getConstant(CFP->getValueAPF().bitcastToAPInt().
736 return DAG.getStore(Tmp1, dl, Tmp3, Tmp2, ST->getPointerInfo(),
745 SDValue Lo = DAG.getConstant(IntVal.trunc(32), MVT::i32);
746 SDValue Hi = DAG.getConstant(IntVal.lshr(32).trunc(32), MVT::i32);
749 Lo = DAG.getStore(Tmp1, dl, Lo, Tmp2, ST->getPointerInfo(), isVolatile,
751 Tmp2 = DAG.getNode(ISD::ADD, dl, Tmp2.getValueType(), Tmp2,
752 DAG.getIntPtrConstant(4));
753 Hi = DAG.getStore(Tmp1, dl, Hi, Tmp2,
757 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
774 assert(TLI.getTypeAction(*DAG.getContext(), Node->getValueType(i)) ==
779 assert((TLI.getTypeAction(*DAG.getContext(),
917 Ops[0] = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Ops[0],
920 LastCALLSEQ_END = DAG.getEntryNode();
930 Ops[1] = LegalizeOp(DAG.getShiftAmountOperand(Ops[0].getValueType(),
939 Ops[2] = LegalizeOp(DAG.getShiftAmountOperand(Ops[0].getValueType(),
944 Result = SDValue(DAG.UpdateNodeOperands(Result.getNode(), Ops.data(),
954 Tmp1 = TLI.LowerOperation(Result, DAG);
987 Node->dump( &DAG);
1003 SDValue Ex = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
1005 Node->getOperand(0), DAG.getIntPtrConstant(Idx));
1006 SDValue Sh = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
1008 Node->getOperand(1), DAG.getIntPtrConstant(Idx));
1009 Scalars.push_back(DAG.getNode(Node->getOpcode(), dl,
1012 Result = DAG.getNode(ISD::BUILD_VECTOR, dl, Node->getValueType(0),
1021 Tmp3 = TLI.LowerOperation(Result, DAG);
1051 Tmp1 = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
1060 Result = SDValue(DAG.UpdateNodeOperands(Result.getNode(), &Ops[0],
1103 Result = SDValue(DAG.UpdateNodeOperands(Result.getNode(),
1114 Result = SDValue(DAG.UpdateNodeOperands(Result.getNode(),
1136 Result = SDValue(DAG.UpdateNodeOperands(Result.getNode(),
1148 Type *Ty = LD->getMemoryVT().getTypeForEVT(*DAG.getContext());
1152 DAG, TLI);
1161 Tmp1 = TLI.LowerOperation(Tmp3, DAG);
1173 Tmp1 = DAG.getLoad(NVT, dl, Tmp1, Tmp2, LD->getPointerInfo(),
1176 Tmp3 = LegalizeOp(DAG.getNode(ISD::BITCAST, dl, VT, Tmp1));
1207 EVT NVT = EVT::getIntegerVT(*DAG.getContext(), NewWidth);
1216 Result = DAG.getExtLoad(NewExtType, dl, Node->getValueType(0),
1224 Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl,
1226 Result, DAG.getValueType(SrcVT));
1229 Result = DAG.getNode(ISD::AssertZext, dl,
1231 DAG.getValueType(SrcVT));
1244 EVT RoundVT = EVT::getIntegerVT(*DAG.getContext(), RoundWidth);
1245 EVT ExtraVT = EVT::getIntegerVT(*DAG.getContext(), ExtraWidth);
1252 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, Node->getValueType(0),
1259 Tmp2 = DAG.getNode(ISD::ADD, dl, Tmp2.getValueType(), Tmp2,
1260 DAG.getIntPtrConstant(IncrementSize));
1261 Hi = DAG.getExtLoad(ExtType, dl, Node->getValueType(0), Tmp1, Tmp2,
1268 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
1272 Hi = DAG.getNode(ISD::SHL, dl, Hi.getValueType(), Hi,
1273 DAG.getConstant(RoundWidth,
1277 Result = DAG.getNode(ISD::OR, dl, Node->getValueType(0), Lo, Hi);
1282 Hi = DAG.getExtLoad(ExtType, dl, Node->getValueType(0), Tmp1, Tmp2,
1288 Tmp2 = DAG.getNode(ISD::ADD, dl, Tmp2.getValueType(), Tmp2,
1289 DAG.getIntPtrConstant(IncrementSize));
1290 Lo = DAG.getExtLoad(ISD::ZEXTLOAD,
1298 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
1302 Hi = DAG.getNode(ISD::SHL, dl, Hi.getValueType(), Hi,
1303 DAG.getConstant(ExtraWidth,
1307 Result = DAG.getNode(ISD::OR, dl, Node->getValueType(0), Lo, Hi);
1319 Result = SDValue(DAG.UpdateNodeOperands(Result.getNode(),
1326 Tmp3 = TLI.LowerOperation(Result, DAG);
1336 LD->getMemoryVT().getTypeForEVT(*DAG.getContext());
1341 DAG, TLI);
1352 SDValue Load = DAG.getLoad(SrcVT, dl, Tmp1, Tmp2,
1366 Result = DAG.getNode(ExtendOp, dl, Node->getValueType(0), Load);
1383 Result = DAG.getExtLoad(ISD::EXTLOAD, dl, Node->getValueType(0),
1389 ValRes = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl,
1391 Result, DAG.getValueType(SrcVT));
1393 ValRes = DAG.getZeroExtendInReg(Result, dl, SrcVT.getScalarType());
1422 Result = SDValue(DAG.UpdateNodeOperands(Result.getNode(),
1434 Type *Ty = ST->getMemoryVT().getTypeForEVT(*DAG.getContext());
1438 DAG, TLI);
1442 Tmp1 = TLI.LowerOperation(Result, DAG);
1447 Tmp3 = DAG.getNode(ISD::BITCAST, dl,
1449 Result = DAG.getStore(Tmp1, dl, Tmp3, Tmp2,
1466 EVT NVT = EVT::getIntegerVT(*DAG.getContext(),
1468 Tmp3 = DAG.getZeroExtendInReg(Tmp3, dl, StVT);
1469 Result = DAG.getTruncStore(Tmp1, dl, Tmp3, Tmp2, ST->getPointerInfo(),
1480 EVT RoundVT = EVT::getIntegerVT(*DAG.getContext(), RoundWidth);
1481 EVT ExtraVT = EVT::getIntegerVT(*DAG.getContext(), ExtraWidth);
1488 Lo = DAG.getTruncStore(Tmp1, dl, Tmp3, Tmp2, ST->getPointerInfo(),
1494 Tmp2 = DAG.getNode(ISD::ADD, dl, Tmp2.getValueType(), Tmp2,
1495 DAG.getIntPtrConstant(IncrementSize));
1496 Hi = DAG.getNode(ISD::SRL, dl, Tmp3.getValueType(), Tmp3,
1497 DAG.getConstant(RoundWidth,
1499 Hi = DAG.getTruncStore(Tmp1, dl, Hi, Tmp2,
1507 DAG.getNode(ISD::SRL, dl, Tmp3.getValueType(), Tmp3,
1508 DAG.getConstant(ExtraWidth,
1510 Hi = DAG.getTruncStore(Tmp1, dl, Hi, Tmp2, ST->getPointerInfo(),
1515 Tmp2 = DAG.getNode(ISD::ADD, dl, Tmp2.getValueType(), Tmp2,
1516 DAG.getIntPtrConstant(IncrementSize));
1517 Lo = DAG.getTruncStore(Tmp1, dl, Tmp3, Tmp2,
1524 Result = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
1528 Result = SDValue(DAG.UpdateNodeOperands(Result.getNode(),
1539 Type *Ty = ST->getMemoryVT().getTypeForEVT(*DAG.getContext());
1543 DAG, TLI);
1547 Result = TLI.LowerOperation(Result, DAG);
1555 Tmp3 = DAG.getNode(ISD::TRUNCATE, dl, StVT, Tmp3);
1556 Result = DAG.getStore(Tmp1, dl, Tmp3, Tmp2, ST->getPointerInfo(),
1583 SDValue StackPtr = DAG.CreateStackTemporary(Vec.getValueType());
1584 SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, Vec, StackPtr,
1590 Idx = DAG.getNode(ISD::MUL, dl, Idx.getValueType(), Idx,
1591 DAG.getConstant(EltSize, Idx.getValueType()));
1594 Idx = DAG.getNode(ISD::TRUNCATE, dl, TLI.getPointerTy(), Idx);
1596 Idx = DAG.getNode(ISD::ZERO_EXTEND, dl, TLI.getPointerTy(), Idx);
1598 StackPtr = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, StackPtr);
1601 return DAG.getLoad(Op.getValueType(), dl, Ch, StackPtr,MachinePointerInfo(),
1603 return DAG.getExtLoad(ISD::EXTLOAD, dl, Op.getValueType(), Ch, StackPtr,
1619 SDValue StackPtr = DAG.CreateStackTemporary(Vec.getValueType());
1624 SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, Vec, StackPtr, PtrInfo,
1633 Idx = DAG.getNode(ISD::MUL, dl, Idx.getValueType(), Idx,
1634 DAG.getConstant(EltSize, Idx.getValueType()));
1637 Idx = DAG.getNode(ISD::TRUNCATE, dl, TLI.getPointerTy(), Idx);
1639 Idx = DAG.getNode(ISD::ZERO_EXTEND, dl, TLI.getPointerTy(), Idx);
1641 SDValue SubStackPtr = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx,
1645 Ch = DAG.getStore(DAG.getEntryNode(), dl, Part, SubStackPtr,
1649 return DAG.getLoad(Op.getValueType(), dl, Ch, StackPtr, PtrInfo,
1661 SDValue FIPtr = DAG.CreateStackTemporary(VT);
1675 SDValue Idx = DAG.getConstant(Offset, FIPtr.getValueType());
1676 Idx = DAG.getNode(ISD::ADD, dl, FIPtr.getValueType(), FIPtr, Idx);
1681 Stores.push_back(DAG.getTruncStore(DAG.getEntryNode(), dl,
1686 Stores.push_back(DAG.getStore(DAG.getEntryNode(), dl,
1694 StoreChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
1697 StoreChain = DAG.getEntryNode();
1700 return DAG.getLoad(VT, dl, StoreChain, FIPtr, PtrInfo, false, false, 0);
1712 EVT IVT = EVT::getIntegerVT(*DAG.getContext(), FloatVT.getSizeInBits());
1715 SignBit = DAG.getNode(ISD::BITCAST, dl, IVT, Tmp2);
1720 SDValue StackPtr = DAG.CreateStackTemporary(FloatVT, LoadTy);
1723 DAG.getStore(DAG.getEntryNode(), dl, Tmp2, StackPtr, MachinePointerInfo(),
1728 SignBit = DAG.getLoad(LoadTy, dl, Ch, StackPtr, MachinePointerInfo(),
1736 LoadPtr = DAG.getNode(ISD::ADD, dl, LoadPtr.getValueType(),
1737 LoadPtr, DAG.getIntPtrConstant(ByteOffset));
1739 SignBit = DAG.getLoad(LoadTy, dl, Ch, LoadPtr, MachinePointerInfo(),
1746 SignBit = DAG.getNode(ISD::SHL, dl, LoadTy, SignBit,
1747 DAG.getConstant(BitShift,
1752 SignBit = DAG.getSetCC(dl, TLI.getSetCCResultType(SignBit.getValueType()),
1753 SignBit, DAG.getConstant(0, SignBit.getValueType()),
1756 SDValue AbsVal = DAG.getNode(ISD::FABS, dl, Tmp1.getValueType(), Tmp1);
1759 return DAG.getNode(ISD::SELECT, dl, AbsVal.getValueType(), SignBit,
1760 DAG.getNode(ISD::FNEG, dl, AbsVal.getValueType(), AbsVal),
1778 Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(0, true));
1781 SDValue SP = DAG.getCopyFromReg(Chain, dl, SPReg, VT);
1786 SP = DAG.getNode(ISD::AND, dl, VT, SP,
1787 DAG.getConstant(-(uint64_t)Align, VT));
1788 Tmp1 = DAG.getNode(ISD::SUB, dl, VT, SP, Size); // Value
1789 Chain = DAG.getCopyToReg(Chain, dl, SPReg, Tmp1); // Output chain
1791 Tmp2 = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(0, true),
1792 DAG.getIntPtrConstant(0, true), SDValue());
1832 SDValue SetCC1 = DAG.getSetCC(dl, VT, LHS, RHS, CC1);
1833 SDValue SetCC2 = DAG.getSetCC(dl, VT, LHS, RHS, CC2);
1834 LHS = DAG.getNode(Opc, dl, VT, SetCC1, SetCC2);
1853 getTypeForEVT(*DAG.getContext()));
1854 SDValue FIPtr = DAG.CreateStackTemporary(SlotVT, SrcAlign);
1863 Type *DestType = DestVT.getTypeForEVT(*DAG.getContext());
1871 Store = DAG.getTruncStore(DAG.getEntryNode(), dl, SrcOp, FIPtr,
1875 Store = DAG.getStore(DAG.getEntryNode(), dl, SrcOp, FIPtr,
1881 return DAG.getLoad(DestVT, dl, Store, FIPtr, PtrInfo,
1885 return DAG.getExtLoad(ISD::EXTLOAD, dl, DestVT, Store, FIPtr,
1893 SDValue StackPtr = DAG.CreateStackTemporary(Node->getValueType(0));
1898 SDValue Ch = DAG.getTruncStore(DAG.getEntryNode(), dl, Node->getOperand(0),
1903 return DAG.getLoad(Node->getValueType(0), dl, Ch, StackPtr,
1944 return DAG.getUNDEF(VT);
1947 return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Node->getOperand(0));
1965 CV.push_back(ConstantInt::get(EltVT.getTypeForEVT(*DAG.getContext()),
1970 Type *OpNTy = EltVT.getTypeForEVT(*DAG.getContext());
1975 SDValue CPIdx = DAG.getConstantPool(CP, TLI.getPointerTy());
1977 return DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
1992 SDValue Vec1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Value1);
1995 Vec2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Value2);
1997 Vec2 = DAG.getUNDEF(VT);
2000 return DAG.getVectorShuffle(VT, dl, Vec1, Vec2, ShuffleVec.data());
2018 SDValue InChain = DAG.getEntryNode();
2024 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
2030 SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
2034 Type *RetTy = Node->getValueType(0).getTypeForEVT(*DAG.getContext());
2038 bool isTailCall = isInTailCallPosition(DAG, Node, TLI);
2043 Callee, Args, DAG, Node->getDebugLoc());
2046 // It's a tailcall, return the chain (which is the DAG root).
2047 return DAG.getRoot();
2067 Entry.Ty = Entry.Node.getValueType().getTypeForEVT(*DAG.getContext());
2072 SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
2075 Type *RetTy = RetVT.getTypeForEVT(*DAG.getContext());
2077 TLI.LowerCallTo(DAG.getEntryNode(), RetTy, isSigned, !isSigned, false,
2080 Callee, Args, DAG, dl);
2103 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
2110 SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
2114 Type *RetTy = Node->getValueType(0).getTypeForEVT(*DAG.getContext());
2119 Callee, Args, DAG, Node->getDebugLoc());
2223 SDValue InChain = DAG.getEntryNode();
2226 Type *RetTy = RetVT.getTypeForEVT(*DAG.getContext());
2232 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
2240 SDValue FIPtr = DAG.CreateStackTemporary(RetVT);
2247 SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
2255 /*isReturnValueUsed=*/true, Callee, Args, DAG, dl);
2263 SDValue Rem = DAG.getLoad(RetVT, dl, LastCALLSEQ_END, FIPtr,
2281 SDValue StackSlot = DAG.CreateStackTemporary(MVT::f64);
2284 SDValue WordOff = DAG.getConstant(sizeof(int), TLI.getPointerTy());
2287 SDValue Lo = DAG.getNode(ISD::ADD, dl,
2296 SDValue SignBit = DAG.getConstant(0x80000000u, MVT::i32);
2297 Op0Mapped = DAG.getNode(ISD::XOR, dl, MVT::i32, Op0, SignBit);
2302 SDValue Store1 = DAG.getStore(DAG.getEntryNode(), dl,
2306 SDValue InitialHi = DAG.getConstant(0x43300000u, MVT::i32);
2308 SDValue Store2 = DAG.getStore(Store1, dl, InitialHi, Hi,
2312 SDValue Load = DAG.getLoad(MVT::f64, dl, Store2, StackSlot,
2315 SDValue Bias = DAG.getConstantFP(isSigned ?
2320 SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::f64, Load, Bias);
2328 Result = DAG.getNode(ISD::FP_ROUND, dl, DestVT, Sub,
2329 DAG.getIntPtrConstant(0));
2331 Result = DAG.getNode(ISD::FP_EXTEND, dl, DestVT, Sub);
2345 DAG.getConstant(UINT64_C(0x4330000000000000), MVT::i64);
2347 DAG.getConstantFP(BitsToDouble(UINT64_C(0x4530000000100000)), MVT::f64);
2349 DAG.getConstant(UINT64_C(0x4530000000000000), MVT::i64);
2351 SDValue Lo = DAG.getZeroExtendInReg(Op0, dl, MVT::i32);
2352 SDValue Hi = DAG.getNode(ISD::SRL, dl, MVT::i64, Op0,
2353 DAG.getConstant(32, MVT::i64));
2354 SDValue LoOr = DAG.getNode(ISD::OR, dl, MVT::i64, Lo, TwoP52);
2355 SDValue HiOr = DAG.getNode(ISD::OR, dl, MVT::i64, Hi, TwoP84);
2356 SDValue LoFlt = DAG.getNode(ISD::BITCAST, dl, MVT::f64, LoOr);
2357 SDValue HiFlt = DAG.getNode(ISD::BITCAST, dl, MVT::f64, HiOr);
2358 SDValue HiSub = DAG.getNode(ISD::FSUB, dl, MVT::f64, HiFlt,
2360 return DAG.getNode(ISD::FADD, dl, MVT::f64, LoFlt, HiSub);
2369 SDValue Fast = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::f32, Op0);
2372 DAG.getConstant(1, TLI.getShiftAmountTy(Op0.getValueType()));
2373 SDValue Shr = DAG.getNode(ISD::SRL, dl, MVT::i64, Op0, ShiftConst);
2374 SDValue AndConst = DAG.getConstant(1, MVT::i64);
2375 SDValue And = DAG.getNode(ISD::AND, dl, MVT::i64, Op0, AndConst);
2376 SDValue Or = DAG.getNode(ISD::OR, dl, MVT::i64, And, Shr);
2378 SDValue SignCvt = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::f32, Or);
2379 SDValue Slow = DAG.getNode(ISD::FADD, dl, MVT::f32, SignCvt, SignCvt);
2385 SDValue SignBitTest = DAG.getSetCC(dl, TLI.getSetCCResultType(MVT::i64),
2386 Op0, DAG.getConstant(0, MVT::i64), ISD::SETLT);
2387 return DAG.getNode(ISD::SELECT, dl, MVT::f32, SignBitTest, Slow, Fast);
2392 SDValue And = DAG.getNode(ISD::AND, dl, MVT::i64, Op0,
2393 DAG.getConstant(UINT64_C(0xfffffffffffff800), MVT::i64));
2394 SDValue Or = DAG.getNode(ISD::OR, dl, MVT::i64, And,
2395 DAG.getConstant(UINT64_C(0x800), MVT::i64));
2396 SDValue And2 = DAG.getNode(ISD::AND, dl, MVT::i64, Op0,
2397 DAG.getConstant(UINT64_C(0x7ff), MVT::i64));
2398 SDValue Ne = DAG.getSetCC(dl, TLI.getSetCCResultType(MVT::i64),
2399 And2, DAG.getConstant(UINT64_C(0), MVT::i64), ISD::SETNE);
2400 SDValue Sel = DAG.getNode(ISD::SELECT, dl, MVT::i64, Ne, Or, Op0);
2401 SDValue Ge = DAG.getSetCC(dl, TLI.getSetCCResultType(MVT::i64),
2402 Op0, DAG.getConstant(UINT64_C(0x0020000000000000), MVT::i64),
2404 SDValue Sel2 = DAG.getNode(ISD::SELECT, dl, MVT::i64, Ge, Sel, Op0);
2407 SDValue Sh = DAG.getNode(ISD::SRL, dl, MVT::i64, Sel2,
2408 DAG.getConstant(32, SHVT));
2409 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Sh);
2410 SDValue Fcvt = DAG.getNode(ISD::UINT_TO_FP, dl, MVT::f64, Trunc);
2412 DAG.getConstantFP(BitsToDouble(UINT64_C(0x41f0000000000000)), MVT::f64);
2413 SDValue Fmul = DAG.getNode(ISD::FMUL, dl, MVT::f64, TwoP32, Fcvt);
2414 SDValue Lo = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Sel2);
2415 SDValue Fcvt2 = DAG.getNode(ISD::UINT_TO_FP, dl, MVT::f64, Lo);
2416 SDValue Fadd = DAG.getNode(ISD::FADD, dl, MVT::f64, Fmul, Fcvt2);
2417 return DAG.getNode(ISD::FP_ROUND, dl, MVT::f32, Fadd,
2418 DAG.getIntPtrConstant(0));
2421 SDValue Tmp1 = DAG.getNode(ISD::SINT_TO_FP, dl, DestVT, Op0);
2423 SDValue SignSet = DAG.getSetCC(dl, TLI.getSetCCResultType(Op0.getValueType()),
2424 Op0, DAG.getConstant(0, Op0.getValueType()),
2426 SDValue Zero = DAG.getIntPtrConstant(0), Four = DAG.getIntPtrConstant(4);
2427 SDValue CstOffset = DAG.getNode(ISD::SELECT, dl, Zero.getValueType(),
2443 Type::getInt64Ty(*DAG.getContext()), FF);
2445 SDValue CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy());
2447 CPIdx = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(), CPIdx, CstOffset);
2451 FudgeInReg = DAG.getLoad(MVT::f32, dl, DAG.getEntryNode(), CPIdx,
2456 LegalizeOp(DAG.getExtLoad(ISD::EXTLOAD, dl, DestVT,
2457 DAG.getEntryNode(), CPIdx,
2462 return DAG.getNode(ISD::FADD, dl, DestVT, Tmp1, FudgeInReg);
2502 return DAG.getNode(OpToUse, dl, DestVT,
2503 DAG.getNode(isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND,
2541 SDValue Operation = DAG.getNode(OpToUse, dl, NewOutTy, LegalOp);
2545 return DAG.getNode(ISD::TRUNCATE, dl, DestVT, Operation);
2557 Tmp2 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(8, SHVT));
2558 Tmp1 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(8, SHVT));
2559 return DAG.getNode(ISD::OR, dl, VT, Tmp1, Tmp2);
2561 Tmp4 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(24, SHVT));
2562 Tmp3 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(8, SHVT));
2563 Tmp2 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(8, SHVT));
2564 Tmp1 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(24, SHVT));
2565 Tmp3 = DAG.getNode(ISD::AND, dl, VT, Tmp3, DAG.getConstant(0xFF0000, VT));
2566 Tmp2 = DAG.getNode(ISD::AND, dl, VT, Tmp2, DAG.getConstant(0xFF00, VT));
2567 Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp3);
2568 Tmp2 = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp1);
2569 return DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp2);
2571 Tmp8 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(56, SHVT));
2572 Tmp7 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(40, SHVT));
2573 Tmp6 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(24, SHVT));
2574 Tmp5 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(8, SHVT));
2575 Tmp4 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(8, SHVT));
2576 Tmp3 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(24, SHVT));
2577 Tmp2 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(40, SHVT));
2578 Tmp1 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(56, SHVT));
2579 Tmp7 = DAG.getNode(ISD::AND, dl, VT, Tmp7, DAG.getConstant(255ULL<<48, VT));
2580 Tmp6 = DAG.getNode(ISD::AND, dl, VT, Tmp6, DAG.getConstant(255ULL<<40, VT));
2581 Tmp5 = DAG.getNode(ISD::AND, dl, VT, Tmp5, DAG.getConstant(255ULL<<32, VT));
2582 Tmp4 = DAG.getNode(ISD::AND, dl, VT, Tmp4, DAG.getConstant(255ULL<<24, VT));
2583 Tmp3 = DAG.getNode(ISD::AND, dl, VT, Tmp3, DAG.getConstant(255ULL<<16, VT));
2584 Tmp2 = DAG.getNode(ISD::AND, dl, VT, Tmp2, DAG.getConstant(255ULL<<8 , VT));
2585 Tmp8 = DAG.getNode(ISD::OR, dl, VT, Tmp8, Tmp7);
2586 Tmp6 = DAG.getNode(ISD::OR, dl, VT, Tmp6, Tmp5);
2587 Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp3);
2588 Tmp2 = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp1);
2589 Tmp8 = DAG.getNode(ISD::OR, dl, VT, Tmp8, Tmp6);
2590 Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp2);
2591 return DAG.getNode(ISD::OR, dl, VT, Tmp8, Tmp4);
2624 SDValue Mask55 = DAG.getConstant(SplatByte(Len, 0x55), VT);
2625 SDValue Mask33 = DAG.getConstant(SplatByte(Len, 0x33), VT);
2626 SDValue Mask0F = DAG.getConstant(SplatByte(Len, 0x0F), VT);
2627 SDValue Mask01 = DAG.getConstant(SplatByte(Len, 0x01), VT);
2630 Op = DAG.getNode(ISD::SUB, dl, VT, Op,
2631 DAG.getNode(ISD::AND, dl, VT,
2632 DAG.getNode(ISD::SRL, dl, VT, Op,
2633 DAG.getConstant(1, ShVT)),
2636 Op = DAG.getNode(ISD::ADD, dl, VT,
2637 DAG.getNode(ISD::AND, dl, VT, Op, Mask33),
2638 DAG.getNode(ISD::AND, dl, VT,
2639 DAG.getNode(ISD::SRL, dl, VT, Op,
2640 DAG.getConstant(2, ShVT)),
2643 Op = DAG.getNode(ISD::AND, dl, VT,
2644 DAG.getNode(ISD::ADD, dl, VT, Op,
2645 DAG.getNode(ISD::SRL, dl, VT, Op,
2646 DAG.getConstant(4, ShVT))),
2649 Op = DAG.getNode(ISD::SRL, dl, VT,
2650 DAG.getNode(ISD::MUL, dl, VT, Op, Mask01),
2651 DAG.getConstant(Len - 8, ShVT));
2669 SDValue Tmp3 = DAG.getConstant(1ULL << i, ShVT);
2670 Op = DAG.getNode(ISD::OR, dl, VT, Op,
2671 DAG.getNode(ISD::SRL, dl, VT, Op, Tmp3));
2673 Op = DAG.getNOT(dl, Op, VT);
2674 return DAG.getNode(ISD::CTPOP, dl, VT, Op);
2682 SDValue Tmp3 = DAG.getNode(ISD::AND, dl, VT,
2683 DAG.getNOT(dl, Op, VT),
2684 DAG.getNode(ISD::SUB, dl, VT, Op,
2685 DAG.getConstant(1, VT)));
2689 return DAG.getNode(ISD::SUB, dl, VT,
2690 DAG.getConstant(VT.getSizeInBits(), VT),
2691 DAG.getNode(ISD::CTLZ, dl, VT, Tmp3));
2692 return DAG.getNode(ISD::CTPOP, dl, VT, Tmp3);
2800 Results.push_back(DAG.getConstant(0, Node->getValueType(0)));
2803 Results.push_back(DAG.getConstant(1, Node->getValueType(0)));
2818 Results.push_back(DAG.getConstant(0, MVT::i32));
2827 TLI.LowerCallTo(Node->getOperand(0), Type::getVoidTy(*DAG.getContext()),
2831 DAG.getExternalSymbol("__sync_synchronize",
2833 Args, DAG, dl);
2839 SDValue Zero = DAG.getConstant(0, Node->getValueType(0));
2840 SDValue Swap = DAG.getAtomic(ISD::ATOMIC_CMP_SWAP, dl,
2853 SDValue Swap = DAG.getAtomic(ISD::ATOMIC_SWAP, dl,
2893 Results.push_back(DAG.getConstant(0, VT));
2896 Results.push_back(DAG.getConstantFP(0, VT));
2904 TLI.LowerCallTo(Node->getOperand(0), Type::getVoidTy(*DAG.getContext()),
2908 DAG.getExternalSymbol("abort", TLI.getPointerTy()),
2909 Args, DAG, dl);
2935 SDValue ShiftCst = DAG.getConstant(BitsDiff, ShiftAmountTy);
2936 Tmp1 = DAG.getNode(ISD::SHL, dl, Node->getValueType(0),
2938 Tmp1 = DAG.getNode(ISD::SRA, dl, Node->getValueType(0), Tmp1, ShiftCst);
2968 Tmp1 = DAG.getConstantFP(apf, VT);
2969 Tmp2 = DAG.getSetCC(dl, TLI.getSetCCResultType(VT),
2972 True = DAG.getNode(ISD::FP_TO_SINT, dl, NVT, Node->getOperand(0));
2973 False = DAG.getNode(ISD::FP_TO_SINT, dl, NVT,
2974 DAG.getNode(ISD::FSUB, dl, VT,
2976 False = DAG.getNode(ISD::XOR, dl, NVT, False,
2977 DAG.getConstant(x, NVT));
2978 Tmp1 = DAG.getNode(ISD::SELECT, dl, NVT, Tmp2, True, False);
2989 SDValue VAListLoad = DAG.getLoad(TLI.getPointerTy(), dl, Tmp1, Tmp2,
2996 VAList = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(), VAList,
2997 DAG.getConstant(Align - 1,
3000 VAList = DAG.getNode(ISD::AND, dl, TLI.getPointerTy(), VAList,
3001 DAG.getConstant(-(int64_t)Align,
3006 Tmp3 = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(), VAList,
3007 DAG
3008 getTypeAllocSize(VT.getTypeForEVT(*DAG.getContext())),
3011 Tmp3 = DAG.getStore(VAListLoad.getValue(1), dl, Tmp3, Tmp2,
3014 Results.push_back(DAG.getLoad(VT, dl, Tmp3, VAList, MachinePointerInfo(),
3024 Tmp1 = DAG.getLoad(TLI.getPointerTy(), dl, Node->getOperand(0),
3027 Tmp1 = DAG.getStore(Tmp1.getValue(1), dl, Tmp1, Node->getOperand(1),
3035 Tmp1 = DAG.getNode(ISD::BITCAST, dl, Node->getValueType(0),
3066 EltVT = TLI.getTypeToTransformTo(*DAG.getContext(), EltVT);
3071 Ops.push_back(DAG.getUNDEF(EltVT));
3076 Ops.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT,
3078 DAG.getIntPtrConstant(Idx)));
3080 Ops.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT,
3082 DAG.getIntPtrConstant(Idx - NumElems)));
3084 Tmp1 = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &Ops[0], Ops.size());
3092 Tmp1 = DAG.getNode(ISD::SRL, dl, OpTy, Node->getOperand(0),
3093 DAG.getConstant(OpTy.getSizeInBits()/2,
3095 Tmp1 = DAG.getNode(ISD::TRUNCATE, dl, Node->getValueType(0), Tmp1);
3098 Tmp1 = DAG.getNode(ISD::TRUNCATE, dl, Node->getValueType(0),
3108 Results.push_back(DAG.getCopyFromReg(Node->getOperand(0), dl, SP,
3112 Results.push_back(DAG.getUNDEF(Node->getValueType(0)));
3120 Results.push_back(DAG.getCopyToReg(Node->getOperand(0), dl, SP,
3131 Tmp1 = DAG.getConstantFP(-0.0, Node->getValueType(0));
3132 Tmp1 = DAG.getNode(ISD::FSUB, dl, Node->getValueType(0), Tmp1,
3140 Tmp2 = DAG.getConstantFP(0.0, VT);
3141 Tmp2 = DAG.getSetCC(dl, TLI.getSetCCResultType(Tmp1.getValueType()),
3143 Tmp3 = DAG.getNode(ISD::FNEG, dl, VT, Tmp1);
3144 Tmp1 = DAG.getNode(ISD::SELECT, dl, VT, Tmp2, Tmp1, Tmp3);
3235 Results.push_back(ExpandConstantFP(CFP, true, DAG, TLI));
3241 Results.push_back(DAG.getCopyFromReg(Node->getOperand(1), dl, Reg,
3249 Results.push_back(DAG.getCopyFromReg(Node->getOperand(0), dl, Reg,
3259 Tmp1 = DAG.getNode(ISD::XOR, dl, VT, Node->getOperand(1),
3260 DAG.getConstant(APInt::getAllOnesValue(VT.getSizeInBits()), VT));
3261 Tmp1 = DAG.getNode(ISD::ADD, dl, VT, Tmp2, DAG.getConstant(1, VT));
3262 Results.push_back(DAG.getNode(ISD::ADD, dl, VT, Node->getOperand(0), Tmp1));
3268 SDVTList VTs = DAG.getVTList(VT, VT);
3277 Tmp1 = DAG.getNode(DivRemOpc, dl, VTs, Tmp2, Tmp3).getValue(1);
3280 Tmp1 = DAG.getNode(DivOpc, dl, VT, Tmp2, Tmp3);
3281 Tmp1 = DAG.getNode(ISD::MUL, dl, VT, Tmp1, Tmp3);
3282 Tmp1 = DAG.getNode(ISD::SUB, dl, VT, Tmp2, Tmp1);
3301 SDVTList VTs = DAG.getVTList(VT, VT);
3305 Tmp1 = DAG.getNode(DivRemOpc, dl, VTs, Node->getOperand(0),
3325 SDVTList VTs = DAG.getVTList(VT, VT);
3328 Tmp1 = DAG.getNode(ExpandOpcode, dl, VTs, Node->getOperand(0),
3340 SDVTList VTs = DAG.getVTList(VT, VT);
3361 Results.push_back(DAG.getNode(OpToUse, dl, VTs, Node->getOperand(0),
3376 SDValue Sum = DAG.getNode(Node->getOpcode() == ISD::SADDO ?
3382 SDValue Zero = DAG.getConstant(0, LHS.getValueType());
3393 SDValue LHSSign = DAG.getSetCC(dl, OType, LHS, Zero, ISD::SETGE);
3394 SDValue RHSSign = DAG.getSetCC(dl, OType, RHS, Zero, ISD::SETGE);
3395 DAG.getSetCC(dl, OType, LHSSign, RHSSign,
3399 SDValue SumSign = DAG.getSetCC(dl, OType, Sum, Zero, ISD::SETGE);
3400 SDValue SumSignNE = DAG.getSetCC(dl, OType, LHSSign, SumSign, ISD::SETNE);
3402 SDValue Cmp = DAG.getNode(ISD::AND, dl, OType, SignsMatch, SumSignNE);
3410 SDValue Sum = DAG.getNode(Node->getOpcode() == ISD::UADDO ?
3414 Results.push_back(DAG.getSetCC(dl, Node->getValueType(1), Sum, LHS,
3422 EVT WideVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits() * 2);
3432 BottomHalf = DAG.getNode(ISD::MUL, dl, VT, LHS, RHS);
3433 TopHalf = DAG.getNode(Ops[isSigned][0], dl, VT, LHS, RHS);
3435 BottomHalf = DAG.getNode(Ops[isSigned][1], dl, DAG.getVTList(VT, VT), LHS,
3438 } else if (TLI.isTypeLegal(EVT::getIntegerVT(*DAG.getContext(),
3440 LHS = DAG.getNode(Ops[isSigned][2], dl, WideVT, LHS);
3441 RHS = DAG.getNode(Ops[isSigned][2], dl, WideVT, RHS);
3442 Tmp1 = DAG.getNode(ISD::MUL, dl, WideVT, LHS, RHS);
3443 BottomHalf = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VT, Tmp1,
3444 DAG.getIntPtrConstant(0));
3445 TopHalf = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VT, Tmp1,
3446 DAG.getIntPtrConstant(1));
3466 SDValue HiLHS = DAG.getNode(ISD::SRA, dl, VT, RHS,
3467 DAG.getConstant(LoSize-1, TLI.getPointerTy()));
3468 SDValue HiRHS = DAG.getNode(ISD::SRA, dl, VT, LHS,
3469 DAG.getConstant(LoSize-1, TLI.getPointerTy()));
3477 BottomHalf = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VT, Ret,
3478 DAG.getIntPtrConstant(0));
3479 TopHalf = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VT, Ret,
3480 DAG.getIntPtrConstant(1));
3484 Tmp1 = DAG.getConstant(VT.getSizeInBits() - 1,
3486 Tmp1 = DAG.getNode(ISD::SRA, dl, VT, BottomHalf, Tmp1);
3487 TopHalf = DAG.getSetCC(dl, TLI.getSetCCResultType(VT), TopHalf, Tmp1,
3490 TopHalf = DAG.getSetCC(dl, TLI.getSetCCResultType(VT), TopHalf,
3491 DAG.getConstant(0, VT), ISD::SETNE);
3499 Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, dl, PairTy, Node->getOperand(0));
3500 Tmp2 = DAG.getNode(ISD::ANY_EXTEND, dl, PairTy, Node->getOperand(1));
3501 Tmp2 = DAG.getNode(ISD::SHL, dl, PairTy, Tmp2,
3502 DAG.getConstant(PairTy.getSizeInBits()/2,
3504 Results.push_back(DAG.getNode(ISD::OR, dl, PairTy, Tmp1, Tmp2));
3512 Tmp1 = DAG.getSelectCC(dl, Tmp1.getOperand(0), Tmp1.getOperand(1),
3516 Tmp1 = DAG.getSelectCC(dl, Tmp1,
3517 DAG.getConstant(0, Tmp1.getValueType()),
3531 DAG.getMachineFunction().getJumpTableInfo()->getEntrySize(TD);
3533 Index = DAG.getNode(ISD::MUL, dl, PTy,
3534 Index, DAG.getConstant(EntrySize, PTy));
3535 SDValue Addr = DAG.getNode(ISD::ADD, dl, PTy, Index, Table);
3537 EVT MemVT = EVT::getIntegerVT(*DAG.getContext(), EntrySize * 8);
3538 SDValue LD = DAG.getExtLoad(ISD::SEXTLOAD, dl, PTy, Chain, Addr,
3546 Addr = DAG.getNode(ISD::ADD, dl, PTy, Addr,
3547 TLI.getPICJumpTableRelocBase(Table, DAG));
3549 Tmp1 = DAG.getNode(ISD::BRIND, dl, MVT::Other, LD.getValue(1), Addr);
3559 Tmp1 = DAG.getNode(ISD::BR_CC, dl, MVT::Other,
3566 DAG.getNode(ISD::AND, dl, Tmp2.getValueType(), Tmp2,
3567 DAG.getConstant(1, Tmp2.getValueType()));
3568 Tmp1 = DAG.getNode(ISD::BR_CC, dl, MVT::Other, Tmp1,
3569 DAG.getCondCode(ISD::SETNE), Tmp3,
3570 DAG.getConstant(0, Tmp3.getValueType()),
3590 Tmp1 = DAG.getNode(ISD::SELECT_CC, dl, VT, Tmp1, Tmp2,
3591 DAG.getConstant(1, VT), DAG.getConstant(0, VT), Tmp3);
3606 Tmp2 = DAG.getConstant(0, Tmp1.getValueType());
3607 CC = DAG.getCondCode(ISD::SETNE);
3608 Tmp1 = DAG.getNode(ISD::SELECT_CC, dl, Node->getValueType(0), Tmp1, Tmp2,
3621 LastCALLSEQ_END = DAG.getEntryNode();
3624 Tmp3 = DAG.getConstant(0, Tmp2.getValueType());
3625 Tmp4 = DAG.getCondCode(ISD::SETNE);
3626 Tmp1 = DAG.getNode(ISD::BR_CC, dl, Node->getValueType(0), Tmp1, Tmp4, Tmp2,
3662 Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Node->getOperand(0));
3664 Tmp1 = DAG.getNode(Node->getOpcode(), dl, NVT, Tmp1);
3667 Tmp2 = DAG.getSetCC(dl, TLI.getSetCCResultType(NVT),
3668 Tmp1, DAG.getConstant(NVT.getSizeInBits(), NVT),
3670 Tmp1 = DAG.getNode(ISD::SELECT, dl, NVT, Tmp2,
3671 DAG.getConstant(OVT.getSizeInBits(), NVT), Tmp1);
3674 Tmp1 = DAG.getNode(ISD::SUB, dl, NVT, Tmp1,
3675 DAG.getConstant(NVT.getSizeInBits() -
3678 Results.push_back(DAG.getNode(ISD::TRUNCATE, dl, OVT, Tmp1));
3682 Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Node->getOperand(0));
3683 Tmp1 = DAG.getNode(ISD::BSWAP, dl, NVT, Tmp1);
3684 Tmp1 = DAG.getNode(ISD::SRL, dl, NVT, Tmp1,
3685 DAG.getConstant(DiffBits, TLI.getShiftAmountTy(NVT)));
3714 Tmp1 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(0));
3715 Tmp2 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(1));
3717 Tmp1 = DAG.getNode(Node->getOpcode(), dl, NVT, Tmp1, Tmp2);
3718 Results.push_back(DAG.getNode(TruncOp, dl, OVT, Tmp1));
3735 Tmp2 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(1));
3736 Tmp3 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(2));
3738 Tmp1 = DAG.getNode(ISD::SELECT, dl, NVT, Tmp1, Tmp2, Tmp3);
3740 Tmp1 = DAG.getNode(TruncOp, dl, Node->getValueType(0), Tmp1);
3742 Tmp1 = DAG.getNode(TruncOp, dl, Node->getValueType(0), Tmp1,
3743 DAG.getIntPtrConstant(0));
3752 Tmp1 = DAG.getNode(ISD::BITCAST, dl, NVT, Node->getOperand(0));
3753 Tmp2 = DAG.getNode(ISD::BITCAST, dl, NVT, Node->getOperand(1));
3757 Tmp1 = DAG.getNode(ISD::BITCAST, dl, OVT, Tmp1);
3768 Tmp1 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(0));
3769 Tmp2 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(1));
3770 Results.push_back(DAG.getNode(ISD::SETCC, dl, Node->getValueType(0),
