Lines Matching defs:DAG
52 SelectionDAG &DAG;
63 explicit SelectionDAGLegalize(SelectionDAG &DAG);
156 DAG.RemoveDeadNode(N);
162 DAG.ReplaceAllUsesWith(Old, New);
166 DAG.ReplaceAllUsesWith(Old, New);
170 DAG.ReplaceAllUsesWith(Old, New);
191 return DAG.getVectorShuffle(NVT, dl, N1, N2, &Mask[0]);
205 return DAG.getVectorShuffle(NVT, dl, N1, N2, &NewMask[0]);
208 SelectionDAGLegalize::SelectionDAGLegalize(SelectionDAG &dag)
209 : SelectionDAG::DAGUpdateListener(dag),
210 TM(dag.getTarget()), TLI(dag.getTargetLoweringInfo()),
211 DAG(dag) {
215 DAG.AssignTopologicalOrder();
223 for (LegalizePosition = DAG.allnodes_end();
224 LegalizePosition != DAG.allnodes_begin(); ) {
239 DAG.RemoveDeadNodes();
259 return DAG.getConstant(LLVMC->getValueAPF().bitcastToAPInt(),
272 Type *SType = SVT.getTypeForEVT(*DAG.getContext());
279 SDValue CPIdx = DAG.getConstantPool(LLVMC, TLI.getPointerTy());
283 DAG.getExtLoad(ISD::EXTLOAD, dl, OrigVT,
284 DAG.getEntryNode(),
290 DAG.getLoad(OrigVT, dl, DAG.getEntryNode(), CPIdx,
297 static void ExpandUnalignedStore(StoreSDNode *ST, SelectionDAG &DAG,
310 EVT intVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
315 SDValue Result = DAG.getNode(ISD::BITCAST, dl, intVT, Val);
316 Result = DAG.getStore(Chain, dl, Result, Ptr, ST->getPointerInfo(),
325 TLI.getRegisterType(*DAG.getContext(),
326 EVT::getIntegerVT(*DAG.getContext(),
333 SDValue StackPtr = DAG.CreateStackTemporary(StoredVT, RegVT);
336 SDValue Store = DAG.getTruncStore(Chain, dl,
339 SDValue Increment = DAG.getConstant(RegBytes, TLI.getPointerTy());
346 SDValue Load = DAG.getLoad(RegVT, dl, Store, StackPtr,
350 Stores.push_back(DAG.getStore(Load.getValue(1), dl, Load, Ptr,
356 StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr,
358 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
364 EVT MemVT = EVT::getIntegerVT(*DAG.getContext(),
368 SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, RegVT, Store, StackPtr,
372 Stores.push_back(DAG.getTruncStore(Load.getValue(1), dl, Load, Ptr,
380 DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &Stores[0],
389 EVT NewStoredVT = ST->getMemoryVT().getHalfSizedIntegerVT(*DAG.getContext());
394 SDValue ShiftAmount = DAG.getConstant(NumBits,
397 SDValue Hi = DAG.getNode(ISD::SRL, dl, VT, Val, ShiftAmount);
401 Store1 = DAG.getTruncStore(Chain, dl, TLI.isLittleEndian()?Lo:Hi, Ptr,
404 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
405 DAG.getConstant(IncrementSize, TLI.getPointerTy()));
407 Store2 = DAG.getTruncStore(Chain, dl, TLI.isLittleEndian()?Hi:Lo, Ptr,
413 DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Store1, Store2);
419 ExpandUnalignedLoad(LoadSDNode *LD, SelectionDAG &DAG,
430 EVT intVT = EVT::getIntegerVT(*DAG.getContext(), LoadedVT.getSizeInBits());
434 SDValue newLoad = DAG.getLoad(intVT, dl, Chain, Ptr, LD->getPointerInfo(),
438 SDValue Result = DAG.getNode(ISD::BITCAST, dl, LoadedVT, newLoad);
440 Result = DAG.getNode(VT.isFloatingPoint() ? ISD::FP_EXTEND :
450 EVT RegVT = TLI.getRegisterType(*DAG.getContext(), intVT);
456 SDValue StackBase = DAG.CreateStackTemporary(LoadedVT, RegVT);
458 SDValue Increment = DAG.getConstant(RegBytes, TLI.getPointerTy());
466 SDValue Load = DAG.getLoad(RegVT, dl, Chain, Ptr,
472 Stores.push_back(DAG.getStore(Load.getValue(1), dl, Load, StackPtr,
476 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
477 StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr,
482 EVT MemVT = EVT::getIntegerVT(*DAG.getContext(),
484 SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, RegVT, Chain, Ptr,
492 Stores.push_back(DAG.getTruncStore(Load.getValue(1), dl, Load, StackPtr,
497 SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &Stores[0],
501 Load = DAG.getExtLoad(LD->getExtensionType(), dl, VT, TF, StackBase,
516 NewLoadedVT = EVT::getIntegerVT(*DAG.getContext(), NumBits/2);
530 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, VT, Chain, Ptr, LD->getPointerInfo(),
533 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
534 DAG.getConstant(IncrementSize, TLI.getPointerTy()));
535 Hi = DAG.getExtLoad(HiExtType, dl, VT, Chain, Ptr,
540 Hi = DAG.getExtLoad(HiExtType, dl, VT, Chain, Ptr, LD->getPointerInfo(),
543 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
544 DAG.getConstant(IncrementSize, TLI.getPointerTy()));
545 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, VT, Chain, Ptr,
552 SDValue ShiftAmount = DAG.getConstant(NumBits,
554 SDValue Result = DAG.getNode(ISD::SHL, dl, VT, Hi, ShiftAmount);
555 Result = DAG.getNode(ISD::OR, dl, VT, Result, Lo);
557 SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
585 SDValue StackPtr = DAG.CreateStackTemporary(VT);
590 SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, Tmp1, StackPtr,
596 Tmp3 = DAG.getNode(CastOpc, dl, PtrVT, Tmp3);
599 Tmp3 = DAG.getNode(ISD::MUL, dl, IdxVT, Tmp3,DAG.getConstant(EltSize, IdxVT));
600 SDValue StackPtr2 = DAG.getNode(ISD::ADD, dl, IdxVT, Tmp3, StackPtr);
602 Ch = DAG.getTruncStore(Ch, dl, Tmp2, StackPtr2, MachinePointerInfo(), EltVT,
605 return DAG.getLoad(VT, dl, Ch, StackPtr,
620 SDValue ScVec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
631 return DAG.getVectorShuffle(Vec.getValueType(), dl, Vec, ScVec,
641 // FIXME: move this to the DAG Combiner! Note that we can't regress due
642 // to phase ordering between legalized code and the dag combiner. This
643 // probably means that we need to integrate dag combiner and legalizer
655 SDValue Con = DAG.getConstant(CFP->getValueAPF().
658 return DAG.getStore(Chain, dl, Con, Ptr, ST->getPointerInfo(),
665 SDValue Con = DAG.getConstant(CFP->getValueAPF().bitcastToAPInt().
667 return DAG.getStore(Chain, dl, Con, Ptr, ST->getPointerInfo(),
676 SDValue Lo = DAG.getConstant(IntVal.trunc(32), MVT::i32);
677 SDValue Hi = DAG.getConstant(IntVal.lshr(32).trunc(32), MVT::i32);
680 Lo = DAG.getStore(Chain, dl, Lo, Ptr, ST->getPointerInfo(), isVolatile,
682 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
683 DAG.getIntPtrConstant(4));
684 Hi = DAG.getStore(Chain, dl, Hi, Ptr,
688 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
720 Type *Ty = ST->getMemoryVT().getTypeForEVT(*DAG.getContext());
724 DAG, TLI, this);
728 SDValue Res = TLI.LowerOperation(SDValue(Node, 0), DAG);
735 Value = DAG.getNode(ISD::BITCAST, dl,
738 DAG.getStore(Chain, dl, Value, Ptr,
757 EVT NVT = EVT::getIntegerVT(*DAG.getContext(),
759 DAG.getZeroExtendInReg(Value, dl, StVT);
761 DAG.getTruncStore(Chain, dl, Value, Ptr, ST->getPointerInfo(),
773 EVT RoundVT = EVT::getIntegerVT(*DAG.getContext(), RoundWidth);
774 EVT ExtraVT = EVT::getIntegerVT(*DAG.getContext(), ExtraWidth);
781 Lo = DAG.getTruncStore(Chain, dl, Value, Ptr, ST->getPointerInfo(),
787 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
788 DAG.getIntPtrConstant(IncrementSize));
789 Hi = DAG.getNode(ISD::SRL, dl, Value.getValueType(), Value,
790 DAG.getConstant(RoundWidth,
792 Hi = DAG.getTruncStore(Chain, dl, Hi, Ptr,
800 Hi = DAG.getNode(ISD::SRL, dl, Value.getValueType(), Value,
801 DAG.getConstant(ExtraWidth,
803 Hi = DAG.getTruncStore(Chain, dl, Hi, Ptr, ST->getPointerInfo(),
808 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
809 DAG.getIntPtrConstant(IncrementSize));
810 Lo = DAG.getTruncStore(Chain, dl, Value, Ptr,
817 SDValue Result = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
826 Type *Ty = ST->getMemoryVT().getTypeForEVT(*DAG.getContext());
829 ExpandUnalignedStore(cast<StoreSDNode>(Node), DAG, TLI, this);
833 SDValue Res = TLI.LowerOperation(SDValue(Node, 0), DAG);
845 Value = DAG.getNode(ISD::TRUNCATE, dl, StVT, Value);
847 DAG.getStore(Chain, dl, Value, Ptr, ST->getPointerInfo(),
875 Type *Ty = LD->getMemoryVT().getTypeForEVT(*DAG.getContext());
880 DAG, TLI, RVal, RChain);
885 SDValue Res = TLI.LowerOperation(RVal, DAG);
898 SDValue Res = DAG.getLoad(NVT, dl, Chain, Ptr, LD->getPointerInfo(),
901 RVal = DAG.getNode(ISD::BITCAST, dl, VT, Res);
908 DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 0), RVal);
909 DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 1), RChain);
934 EVT NVT = EVT::getIntegerVT(*DAG.getContext(), NewWidth);
944 DAG.getExtLoad(NewExtType, dl, Node->getValueType(0),
952 Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl,
954 Result, DAG.getValueType(SrcVT));
957 Result = DAG.getNode(ISD::AssertZext, dl,
959 DAG.getValueType(SrcVT));
972 EVT RoundVT = EVT::getIntegerVT(*DAG.getContext(), RoundWidth);
973 EVT ExtraVT = EVT::getIntegerVT(*DAG.getContext(), ExtraWidth);
980 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, Node->getValueType(0),
987 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
988 DAG.getIntPtrConstant(IncrementSize));
989 Hi = DAG.getExtLoad(ExtType, dl, Node->getValueType(0), Chain, Ptr,
996 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
1000 Hi = DAG.getNode(ISD::SHL, dl, Hi.getValueType(), Hi,
1001 DAG.getConstant(RoundWidth,
1005 Value = DAG.getNode(ISD::OR, dl, Node->getValueType(0), Lo, Hi);
1010 Hi = DAG.getExtLoad(ExtType, dl, Node->getValueType(0), Chain, Ptr,
1016 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
1017 DAG.getIntPtrConstant(IncrementSize));
1018 Lo = DAG.getExtLoad(ISD::ZEXTLOAD,
1026 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
1030 Hi = DAG.getNode(ISD::SHL, dl, Hi.getValueType(), Hi,
1031 DAG.getConstant(ExtraWidth,
1035 Value = DAG.getNode(ISD::OR, dl, Node->getValueType(0), Lo, Hi);
1051 SDValue Res = TLI.LowerOperation(SDValue(Node, 0), DAG);
1061 LD->getMemoryVT().getTypeForEVT(*DAG.getContext());
1066 DAG, TLI, Value, Chain);
1074 SDValue Load = DAG.getLoad(SrcVT, dl, Chain, Ptr,
1088 Value = DAG.getNode(ExtendOp, dl, Node->getValueType(0), Load);
1104 SDValue Result = DAG.getExtLoad(ISD::EXTLOAD, dl, Node->getValueType(0),
1110 ValRes = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl,
1112 DAG.getValueType(SrcVT));
1114 ValRes = DAG.getZeroExtendInReg(Result, dl, SrcVT.getScalarType());
1125 DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 0), Value);
1126 DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 1), Chain);
1138 assert(TLI.getTypeAction(*DAG.getContext(), Node->getValueType(i)) ==
1143 assert((TLI.getTypeAction(*DAG.getContext(),
1266 DAG.getShiftAmountOperand(Node->getOperand(0).getValueType(),
1270 NewNode = DAG.UpdateNodeOperands(Node, Node->getOperand(0),
1281 DAG.getShiftAmountOperand(Node->getOperand(0).getValueType(),
1285 NewNode = DAG.UpdateNodeOperands(Node, Node->getOperand(0),
1293 DAG.ReplaceAllUsesWith(Node, NewNode);
1295 DAG.TransferDbgValues(SDValue(Node, i), SDValue(NewNode, i));
1305 SDValue Res = TLI.LowerOperation(SDValue(Node, 0), DAG);
1315 DAG.ReplaceAllUsesWith(Node, ResultVals.data());
1317 DAG.TransferDbgValues(SDValue(Node, i), ResultVals[i]);
1337 Node->dump( &DAG);
1359 SDValue StackPtr = DAG.CreateStackTemporary(Vec.getValueType());
1360 SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, Vec, StackPtr,
1366 Idx = DAG.getNode(ISD::MUL, dl, Idx.getValueType(), Idx,
1367 DAG.getConstant(EltSize, Idx.getValueType()));
1370 Idx = DAG.getNode(ISD::TRUNCATE, dl, TLI.getPointerTy(), Idx);
1372 Idx = DAG.getNode(ISD::ZERO_EXTEND, dl, TLI.getPointerTy(), Idx);
1374 StackPtr = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, StackPtr);
1377 return DAG.getLoad(Op.getValueType(), dl, Ch, StackPtr,MachinePointerInfo(),
1379 return DAG.getExtLoad(ISD::EXTLOAD, dl, Op.getValueType(), Ch, StackPtr,
1395 SDValue StackPtr = DAG.CreateStackTemporary(Vec.getValueType());
1400 SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, Vec, StackPtr, PtrInfo,
1409 Idx = DAG.getNode(ISD::MUL, dl, Idx.getValueType(), Idx,
1410 DAG.getConstant(EltSize, Idx.getValueType()));
1413 Idx = DAG.getNode(ISD::TRUNCATE, dl, TLI.getPointerTy(), Idx);
1415 Idx = DAG.getNode(ISD::ZERO_EXTEND, dl, TLI.getPointerTy(), Idx);
1417 SDValue SubStackPtr = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx,
1421 Ch = DAG.getStore(DAG.getEntryNode(), dl, Part, SubStackPtr,
1425 return DAG.getLoad(Op.getValueType(), dl, Ch, StackPtr, PtrInfo,
1437 SDValue FIPtr = DAG.CreateStackTemporary(VT);
1451 SDValue Idx = DAG.getConstant(Offset, FIPtr.getValueType());
1452 Idx = DAG.getNode(ISD::ADD, dl, FIPtr.getValueType(), FIPtr, Idx);
1457 Stores.push_back(DAG.getTruncStore(DAG.getEntryNode(), dl,
1462 Stores.push_back(DAG.getStore(DAG.getEntryNode(), dl,
1470 StoreChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
1473 StoreChain = DAG.getEntryNode();
1476 return DAG.getLoad(VT, dl, StoreChain, FIPtr, PtrInfo,
1489 EVT IVT = EVT::getIntegerVT(*DAG.getContext(), FloatVT.getSizeInBits());
1492 SignBit = DAG.getNode(ISD::BITCAST, dl, IVT, Tmp2);
1497 SDValue StackPtr = DAG.CreateStackTemporary(FloatVT, LoadTy);
1500 DAG.getStore(DAG.getEntryNode(), dl, Tmp2, StackPtr, MachinePointerInfo(),
1505 SignBit = DAG.getLoad(LoadTy, dl, Ch, StackPtr, MachinePointerInfo(),
1513 LoadPtr = DAG.getNode(ISD::ADD, dl, LoadPtr.getValueType(),
1514 LoadPtr, DAG.getIntPtrConstant(ByteOffset));
1516 SignBit = DAG.getLoad(LoadTy, dl, Ch, LoadPtr, MachinePointerInfo(),
1523 SignBit = DAG.getNode(ISD::SHL, dl, LoadTy, SignBit,
1524 DAG.getConstant(BitShift,
1529 SignBit = DAG.getSetCC(dl, TLI.getSetCCResultType(SignBit.getValueType()),
1530 SignBit, DAG.getConstant(0, SignBit.getValueType()),
1533 SDValue AbsVal = DAG.getNode(ISD::FABS, dl, Tmp1.getValueType(), Tmp1);
1536 return DAG.getNode(ISD::SELECT, dl, AbsVal.getValueType(), SignBit,
1537 DAG.getNode(ISD::FNEG, dl, AbsVal.getValueType(), AbsVal),
1555 Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(0, true));
1558 SDValue SP = DAG.getCopyFromReg(Chain, dl, SPReg, VT);
1563 SP = DAG.getNode(ISD::AND, dl, VT, SP,
1564 DAG.getConstant(-(uint64_t)Align, VT));
1565 Tmp1 = DAG.getNode(ISD::SUB, dl, VT, SP, Size); // Value
1566 Chain = DAG.getCopyToReg(Chain, dl, SPReg, Tmp1); // Output chain
1568 Tmp2 = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(0, true),
1569 DAG.getIntPtrConstant(0, true), SDValue());
1609 SDValue SetCC1 = DAG.getSetCC(dl, VT, LHS, RHS, CC1);
1610 SDValue SetCC2 = DAG.getSetCC(dl, VT, LHS, RHS, CC2);
1611 LHS = DAG.getNode(Opc, dl, VT, SetCC1, SetCC2);
1630 getTypeForEVT(*DAG.getContext()));
1631 SDValue FIPtr = DAG.CreateStackTemporary(SlotVT, SrcAlign);
1640 Type *DestType = DestVT.getTypeForEVT(*DAG.getContext());
1648 Store = DAG.getTruncStore(DAG.getEntryNode(), dl, SrcOp, FIPtr,
1652 Store = DAG.getStore(DAG.getEntryNode(), dl, SrcOp, FIPtr,
1658 return DAG.getLoad(DestVT, dl, Store, FIPtr, PtrInfo,
1662 return DAG.getExtLoad(ISD::EXTLOAD, dl, DestVT, Store, FIPtr,
1670 SDValue StackPtr = DAG.CreateStackTemporary(Node->getValueType(0));
1675 SDValue Ch = DAG.getTruncStore(DAG.getEntryNode(), dl, Node->getOperand(0),
1680 return DAG.getLoad(Node->getValueType(0), dl, Ch, StackPtr,
1721 return DAG.getUNDEF(VT);
1724 return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Node->getOperand(0));
1742 CV.push_back(ConstantInt::get(EltVT.getTypeForEVT(*DAG.getContext()),
1747 Type *OpNTy = EltVT.getTypeForEVT(*DAG.getContext());
1752 SDValue CPIdx = DAG.getConstantPool(CP, TLI.getPointerTy());
1754 return DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
1769 SDValue Vec1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Value1);
1772 Vec2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Value2);
1774 Vec2 = DAG.getUNDEF(VT);
1777 return DAG.getVectorShuffle(VT, dl, Vec1, Vec2, ShuffleVec.data());
1795 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
1801 SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
1804 Type *RetTy = Node->getValueType(0).getTypeForEVT(*DAG.getContext());
1810 SDValue InChain = DAG.getEntryNode();
1815 bool isTailCall = isInTailCallPosition(DAG, Node, TCChain, TLI);
1823 Callee, Args, DAG, Node->getDebugLoc());
1828 // It's a tailcall, return the chain (which is the DAG root).
1829 return DAG.getRoot();
1845 Entry.Ty = Entry.Node.getValueType().getTypeForEVT(*DAG.getContext());
1850 SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
1853 Type *RetTy = RetVT.getTypeForEVT(*DAG.getContext());
1855 CallLoweringInfo CLI(DAG.getEntryNode(), RetTy, isSigned, !isSigned, false,
1859 Callee, Args, DAG, dl);
1877 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
1884 SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
1887 Type *RetTy = Node->getValueType(0).getTypeForEVT(*DAG.getContext());
1892 Callee, Args, DAG, Node->getDebugLoc());
1995 SDValue InChain = DAG.getEntryNode();
1998 Type *RetTy = RetVT.getTypeForEVT(*DAG.getContext());
2004 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
2012 SDValue FIPtr = DAG.CreateStackTemporary(RetVT);
2019 SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
2027 Callee, Args, DAG, dl);
2031 SDValue Rem = DAG.getLoad(RetVT, dl, CallInfo.second, FIPtr,
2049 SDValue StackSlot = DAG.CreateStackTemporary(MVT::f64);
2052 SDValue WordOff = DAG.getConstant(sizeof(int), TLI.getPointerTy());
2055 SDValue Lo = DAG.getNode(ISD::ADD, dl,
2064 SDValue SignBit = DAG.getConstant(0x80000000u, MVT::i32);
2065 Op0Mapped = DAG.getNode(ISD::XOR, dl, MVT::i32, Op0, SignBit);
2070 SDValue Store1 = DAG.getStore(DAG.getEntryNode(), dl,
2074 SDValue InitialHi = DAG.getConstant(0x43300000u, MVT::i32);
2076 SDValue Store2 = DAG.getStore(Store1, dl, InitialHi, Hi,
2080 SDValue Load = DAG.getLoad(MVT::f64, dl, Store2, StackSlot,
2083 SDValue Bias = DAG.getConstantFP(isSigned ?
2088 SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::f64, Load, Bias);
2096 Result = DAG.getNode(ISD::FP_ROUND, dl, DestVT, Sub,
2097 DAG.getIntPtrConstant(0));
2099 Result = DAG.getNode(ISD::FP_EXTEND, dl, DestVT, Sub);
2113 DAG.getConstant(UINT64_C(0x4330000000000000), MVT::i64);
2115 DAG.getConstantFP(BitsToDouble(UINT64_C(0x4530000000100000)), MVT::f64);
2117 DAG.getConstant(UINT64_C(0x4530000000000000), MVT::i64);
2119 SDValue Lo = DAG.getZeroExtendInReg(Op0, dl, MVT::i32);
2120 SDValue Hi = DAG.getNode(ISD::SRL, dl, MVT::i64, Op0,
2121 DAG.getConstant(32, MVT::i64));
2122 SDValue LoOr = DAG.getNode(ISD::OR, dl, MVT::i64, Lo, TwoP52);
2123 SDValue HiOr = DAG.getNode(ISD::OR, dl, MVT::i64, Hi, TwoP84);
2124 SDValue LoFlt = DAG.getNode(ISD::BITCAST, dl, MVT::f64, LoOr);
2125 SDValue HiFlt = DAG.getNode(ISD::BITCAST, dl, MVT::f64, HiOr);
2126 SDValue HiSub = DAG.getNode(ISD::FSUB, dl, MVT::f64, HiFlt,
2128 return DAG.getNode(ISD::FADD, dl, MVT::f64, LoFlt, HiSub);
2137 SDValue Fast = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::f32, Op0);
2140 DAG.getConstant(1, TLI.getShiftAmountTy(Op0.getValueType()));
2141 SDValue Shr = DAG.getNode(ISD::SRL, dl, MVT::i64, Op0, ShiftConst);
2142 SDValue AndConst = DAG.getConstant(1, MVT::i64);
2143 SDValue And = DAG.getNode(ISD::AND, dl, MVT::i64, Op0, AndConst);
2144 SDValue Or = DAG.getNode(ISD::OR, dl, MVT::i64, And, Shr);
2146 SDValue SignCvt = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::f32, Or);
2147 SDValue Slow = DAG.getNode(ISD::FADD, dl, MVT::f32, SignCvt, SignCvt);
2153 SDValue SignBitTest = DAG.getSetCC(dl, TLI.getSetCCResultType(MVT::i64),
2154 Op0, DAG.getConstant(0, MVT::i64), ISD::SETLT);
2155 return DAG.getNode(ISD::SELECT, dl, MVT::f32, SignBitTest, Slow, Fast);
2160 SDValue And = DAG.getNode(ISD::AND, dl, MVT::i64, Op0,
2161 DAG.getConstant(UINT64_C(0xfffffffffffff800), MVT::i64));
2162 SDValue Or = DAG.getNode(ISD::OR, dl, MVT::i64, And,
2163 DAG.getConstant(UINT64_C(0x800), MVT::i64));
2164 SDValue And2 = DAG.getNode(ISD::AND, dl, MVT::i64, Op0,
2165 DAG.getConstant(UINT64_C(0x7ff), MVT::i64));
2166 SDValue Ne = DAG.getSetCC(dl, TLI.getSetCCResultType(MVT::i64),
2167 And2, DAG.getConstant(UINT64_C(0), MVT::i64), ISD::SETNE);
2168 SDValue Sel = DAG.getNode(ISD::SELECT, dl, MVT::i64, Ne, Or, Op0);
2169 SDValue Ge = DAG.getSetCC(dl, TLI.getSetCCResultType(MVT::i64),
2170 Op0, DAG.getConstant(UINT64_C(0x0020000000000000), MVT::i64),
2172 SDValue Sel2 = DAG.getNode(ISD::SELECT, dl, MVT::i64, Ge, Sel, Op0);
2175 SDValue Sh = DAG.getNode(ISD::SRL, dl, MVT::i64, Sel2,
2176 DAG.getConstant(32, SHVT));
2177 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Sh);
2178 SDValue Fcvt = DAG.getNode(ISD::UINT_TO_FP, dl, MVT::f64, Trunc);
2180 DAG.getConstantFP(BitsToDouble(UINT64_C(0x41f0000000000000)), MVT::f64);
2181 SDValue Fmul = DAG.getNode(ISD::FMUL, dl, MVT::f64, TwoP32, Fcvt);
2182 SDValue Lo = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Sel2);
2183 SDValue Fcvt2 = DAG.getNode(ISD::UINT_TO_FP, dl, MVT::f64, Lo);
2184 SDValue Fadd = DAG.getNode(ISD::FADD, dl, MVT::f64, Fmul, Fcvt2);
2185 return DAG.getNode(ISD::FP_ROUND, dl, MVT::f32, Fadd,
2186 DAG.getIntPtrConstant(0));
2189 SDValue Tmp1 = DAG.getNode(ISD::SINT_TO_FP, dl, DestVT, Op0);
2191 SDValue SignSet = DAG.getSetCC(dl, TLI.getSetCCResultType(Op0.getValueType()),
2192 Op0, DAG.getConstant(0, Op0.getValueType()),
2194 SDValue Zero = DAG.getIntPtrConstant(0), Four = DAG.getIntPtrConstant(4);
2195 SDValue CstOffset = DAG.getNode(ISD::SELECT, dl, Zero.getValueType(),
2211 Type::getInt64Ty(*DAG.getContext()), FF);
2213 SDValue CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy());
2215 CPIdx = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(), CPIdx, CstOffset);
2219 FudgeInReg = DAG.getLoad(MVT::f32, dl, DAG.getEntryNode(), CPIdx,
2223 SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, DestVT,
2224 DAG.getEntryNode(), CPIdx,
2232 return DAG.getNode(ISD::FADD, dl, DestVT, Tmp1, FudgeInReg);
2272 return DAG.getNode(OpToUse, dl, DestVT,
2273 DAG
2311 SDValue Operation = DAG.getNode(OpToUse, dl, NewOutTy, LegalOp);
2315 return DAG.getNode(ISD::TRUNCATE, dl, DestVT, Operation);
2327 Tmp2 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(8, SHVT));
2328 Tmp1 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(8, SHVT));
2329 return DAG.getNode(ISD::OR, dl, VT, Tmp1, Tmp2);
2331 Tmp4 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(24, SHVT));
2332 Tmp3 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(8, SHVT));
2333 Tmp2 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(8, SHVT));
2334 Tmp1 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(24, SHVT));
2335 Tmp3 = DAG.getNode(ISD::AND, dl, VT, Tmp3, DAG.getConstant(0xFF0000, VT));
2336 Tmp2 = DAG.getNode(ISD::AND, dl, VT, Tmp2, DAG.getConstant(0xFF00, VT));
2337 Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp3);
2338 Tmp2 = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp1);
2339 return DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp2);
2341 Tmp8 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(56, SHVT));
2342 Tmp7 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(40, SHVT));
2343 Tmp6 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(24, SHVT));
2344 Tmp5 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(8, SHVT));
2345 Tmp4 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(8, SHVT));
2346 Tmp3 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(24, SHVT));
2347 Tmp2 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(40, SHVT));
2348 Tmp1 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(56, SHVT));
2349 Tmp7 = DAG.getNode(ISD::AND, dl, VT, Tmp7, DAG.getConstant(255ULL<<48, VT));
2350 Tmp6 = DAG.getNode(ISD::AND, dl, VT, Tmp6, DAG.getConstant(255ULL<<40, VT));
2351 Tmp5 = DAG.getNode(ISD::AND, dl, VT, Tmp5, DAG.getConstant(255ULL<<32, VT));
2352 Tmp4 = DAG.getNode(ISD::AND, dl, VT, Tmp4, DAG.getConstant(255ULL<<24, VT));
2353 Tmp3 = DAG.getNode(ISD::AND, dl, VT, Tmp3, DAG.getConstant(255ULL<<16, VT));
2354 Tmp2 = DAG.getNode(ISD::AND, dl, VT, Tmp2, DAG.getConstant(255ULL<<8 , VT));
2355 Tmp8 = DAG.getNode(ISD::OR, dl, VT, Tmp8, Tmp7);
2356 Tmp6 = DAG.getNode(ISD::OR, dl, VT, Tmp6, Tmp5);
2357 Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp3);
2358 Tmp2 = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp1);
2359 Tmp8 = DAG.getNode(ISD::OR, dl, VT, Tmp8, Tmp6);
2360 Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp2);
2361 return DAG.getNode(ISD::OR, dl, VT, Tmp8, Tmp4);
2394 SDValue Mask55 = DAG.getConstant(SplatByte(Len, 0x55), VT);
2395 SDValue Mask33 = DAG.getConstant(SplatByte(Len, 0x33), VT);
2396 SDValue Mask0F = DAG.getConstant(SplatByte(Len, 0x0F), VT);
2397 SDValue Mask01 = DAG.getConstant(SplatByte(Len, 0x01), VT);
2400 Op = DAG.getNode(ISD::SUB, dl, VT, Op,
2401 DAG.getNode(ISD::AND, dl, VT,
2402 DAG.getNode(ISD::SRL, dl, VT, Op,
2403 DAG.getConstant(1, ShVT)),
2406 Op = DAG.getNode(ISD::ADD, dl, VT,
2407 DAG.getNode(ISD::AND, dl, VT, Op, Mask33),
2408 DAG.getNode(ISD::AND, dl, VT,
2409 DAG.getNode(ISD::SRL, dl, VT, Op,
2410 DAG.getConstant(2, ShVT)),
2413 Op = DAG.getNode(ISD::AND, dl, VT,
2414 DAG.getNode(ISD::ADD, dl, VT, Op,
2415 DAG.getNode(ISD::SRL, dl, VT, Op,
2416 DAG.getConstant(4, ShVT))),
2419 Op = DAG.getNode(ISD::SRL, dl, VT,
2420 DAG.getNode(ISD::MUL, dl, VT, Op, Mask01),
2421 DAG.getConstant(Len - 8, ShVT));
2427 return DAG.getNode(ISD::CTLZ, dl, Op.getValueType(), Op);
2442 SDValue Tmp3 = DAG.getConstant(1ULL << i, ShVT);
2443 Op = DAG.getNode(ISD::OR, dl, VT, Op,
2444 DAG.getNode(ISD::SRL, dl, VT, Op, Tmp3));
2446 Op = DAG.getNOT(dl, Op, VT);
2447 return DAG.getNode(ISD::CTPOP, dl, VT, Op);
2451 return DAG.getNode(ISD::CTTZ, dl, Op.getValueType(), Op);
2458 SDValue Tmp3 = DAG.getNode(ISD::AND, dl, VT,
2459 DAG.getNOT(dl, Op, VT),
2460 DAG.getNode(ISD::SUB, dl, VT, Op,
2461 DAG.getConstant(1, VT)));
2465 return DAG.getNode(ISD::SUB, dl, VT,
2466 DAG.getConstant(VT.getSizeInBits(), VT),
2467 DAG.getNode(ISD::CTLZ, dl, VT, Tmp3));
2468 return DAG.getNode(ISD::CTPOP, dl, VT, Tmp3);
2577 Results.push_back(DAG.getConstant(0, Node->getValueType(0)));
2580 Results.push_back(DAG.getConstant(1, Node->getValueType(0)));
2594 Results.push_back(DAG.getConstant(0, MVT::i32));
2604 Type::getVoidTy(*DAG.getContext()),
2608 DAG.getExternalSymbol("__sync_synchronize",
2610 Args, DAG, dl);
2618 SDValue Zero = DAG.getConstant(0, Node->getValueType(0));
2619 SDValue Swap = DAG.getAtomic(ISD::ATOMIC_CMP_SWAP, dl,
2632 SDValue Swap = DAG.getAtomic(ISD::ATOMIC_SWAP, dl,
2672 Results.push_back(DAG.getConstant(0, VT));
2675 Results.push_back(DAG.getConstantFP(0, VT));
2684 Type::getVoidTy(*DAG.getContext()),
2688 DAG.getExternalSymbol("abort", TLI.getPointerTy()),
2689 Args, DAG, dl);
2717 SDValue ShiftCst = DAG.getConstant(BitsDiff, ShiftAmountTy);
2718 Tmp1 = DAG.getNode(ISD::SHL, dl, Node->getValueType(0),
2720 Tmp1 = DAG.getNode(ISD::SRA, dl, Node->getValueType(0), Tmp1, ShiftCst);
2750 Tmp1 = DAG.getConstantFP(apf, VT);
2751 Tmp2 = DAG.getSetCC(dl, TLI.getSetCCResultType(VT),
2754 True = DAG.getNode(ISD::FP_TO_SINT, dl, NVT, Node->getOperand(0));
2755 False = DAG.getNode(ISD::FP_TO_SINT, dl, NVT,
2756 DAG.getNode(ISD::FSUB, dl, VT,
2758 False = DAG.getNode(ISD::XOR, dl, NVT, False,
2759 DAG.getConstant(x, NVT));
2760 Tmp1 = DAG.getNode(ISD::SELECT, dl, NVT, Tmp2, True, False);
2771 SDValue VAListLoad = DAG.getLoad(TLI.getPointerTy(), dl, Tmp1, Tmp2,
2779 VAList = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(), VAList,
2780 DAG.getConstant(Align - 1,
2783 VAList = DAG.getNode(ISD::AND, dl, TLI.getPointerTy(), VAList,
2784 DAG.getConstant(-(int64_t)Align,
2789 Tmp3 = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(), VAList,
2790 DAG.getConstant(TLI.getTargetData()->
2791 getTypeAllocSize(VT.getTypeForEVT(*DAG.getContext())),
2794 Tmp3 = DAG.getStore(VAListLoad.getValue(1), dl, Tmp3, Tmp2,
2797 Results.push_back(DAG.getLoad(VT, dl, Tmp3, VAList, MachinePointerInfo(),
2807 Tmp1 = DAG.getLoad(TLI.getPointerTy(), dl, Node->getOperand(0),
2810 Tmp1 = DAG.getStore(Tmp1.getValue(1), dl, Tmp1, Node->getOperand(1),
2818 Tmp1 = DAG.getNode(ISD::BITCAST, dl, Node->getValueType(0),
2852 EVT NewEltVT = TLI.getTypeToTransformTo(*DAG.getContext(), EltVT);
2863 EVT NewVT = EVT::getVectorVT(*DAG.getContext(), NewEltVT,
2868 Op0 = DAG.getNode(ISD::BITCAST, dl, NewVT, Op0);
2869 Op1 = DAG.getNode(ISD::BITCAST, dl, NewVT, Op1);
2896 Ops.push_back(DAG.getUNDEF(EltVT));
2901 Ops.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT,
2903 DAG.getIntPtrConstant(Idx)));
2905 Ops.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT,
2907 DAG.getIntPtrConstant(Idx - NumElems)));
2910 Tmp1 = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &Ops[0], Ops.size());
2912 Tmp1 = DAG.getNode(ISD::BITCAST, dl, Node->getValueType(0), Tmp1);
2920 Tmp1 = DAG.getNode(ISD::SRL, dl, OpTy, Node->getOperand(0),
2921 DAG.getConstant(OpTy.getSizeInBits()/2,
2923 Tmp1 = DAG.getNode(ISD::TRUNCATE, dl, Node->getValueType(0), Tmp1);
2926 Tmp1 = DAG.getNode(ISD::TRUNCATE, dl, Node->getValueType(0),
2936 Results.push_back(DAG.getCopyFromReg(Node->getOperand(0), dl, SP,
2940 Results.push_back(DAG.getUNDEF(Node->getValueType(0)));
2948 Results.push_back(DAG.getCopyToReg(Node->getOperand(0), dl, SP,
2959 Tmp1 = DAG.getConstantFP(-0.0, Node->getValueType(0));
2960 Tmp1 = DAG.getNode(ISD::FSUB, dl, Node->getValueType(0), Tmp1,
2968 Tmp2 = DAG.getConstantFP(0.0, VT);
2969 Tmp2 = DAG.getSetCC(dl, TLI.getSetCCResultType(Tmp1.getValueType()),
2971 Tmp3 = DAG.getNode(ISD::FNEG, dl, VT, Tmp1);
2972 Tmp1 = DAG.getNode(ISD::SELECT, dl, VT, Tmp2, Tmp1, Tmp3);
3067 Results.push_back(DAG.getCopyFromReg(Node->getOperand(1), dl, Reg,
3075 Results.push_back(DAG.getCopyFromReg(Node->getOperand(0), dl, Reg,
3085 Tmp1 = DAG.getNode(ISD::FNEG, dl, VT, Node->getOperand(1));
3086 Tmp1 = DAG.getNode(ISD::FADD, dl, VT, Node->getOperand(0), Tmp1);
3095 Tmp1 = DAG.getNode(ISD::XOR, dl, VT, Node->getOperand(1),
3096 DAG.getConstant(APInt::getAllOnesValue(VT.getSizeInBits()), VT));
3097 Tmp1 = DAG.getNode(ISD::ADD, dl, VT, Tmp1, DAG.getConstant(1, VT));
3098 Results.push_back(DAG.getNode(ISD::ADD, dl, VT, Node->getOperand(0), Tmp1));
3104 SDVTList VTs = DAG.getVTList(VT, VT);
3113 Tmp1 = DAG.getNode(DivRemOpc, dl, VTs, Tmp2, Tmp3).getValue(1);
3116 Tmp1 = DAG.getNode(DivOpc, dl, VT, Tmp2, Tmp3);
3117 Tmp1 = DAG.getNode(ISD::MUL, dl, VT, Tmp1, Tmp3);
3118 Tmp1 = DAG.getNode(ISD::SUB, dl, VT, Tmp2, Tmp1);
3137 SDVTList VTs = DAG.getVTList(VT, VT);
3141 Tmp1 = DAG.getNode(DivRemOpc, dl, VTs, Node->getOperand(0),
3161 SDVTList VTs = DAG.getVTList(VT, VT);
3164 Tmp1 = DAG.getNode(ExpandOpcode, dl, VTs, Node->getOperand(0),
3176 SDVTList VTs = DAG.getVTList(VT, VT);
3197 Results.push_back(DAG.getNode(OpToUse, dl, VTs, Node->getOperand(0),
3212 SDValue Sum = DAG.getNode(Node->getOpcode() == ISD::SADDO ?
3218 SDValue Zero = DAG.getConstant(0, LHS.getValueType());
3229 SDValue LHSSign = DAG.getSetCC(dl, OType, LHS, Zero, ISD::SETGE);
3230 SDValue RHSSign = DAG.getSetCC(dl, OType, RHS, Zero, ISD::SETGE);
3231 SDValue SignsMatch = DAG.getSetCC(dl, OType, LHSSign, RHSSign,
3235 SDValue SumSign = DAG.getSetCC(dl, OType, Sum, Zero, ISD::SETGE);
3236 SDValue SumSignNE = DAG.getSetCC(dl, OType, LHSSign, SumSign, ISD::SETNE);
3238 SDValue Cmp = DAG.getNode(ISD::AND, dl, OType, SignsMatch, SumSignNE);
3246 SDValue Sum = DAG.getNode(Node->getOpcode() == ISD::UADDO ?
3250 Results.push_back(DAG.getSetCC(dl, Node->getValueType(1), Sum, LHS,
3258 EVT WideVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits() * 2);
3268 BottomHalf = DAG.getNode(ISD::MUL, dl, VT, LHS, RHS);
3269 TopHalf = DAG.getNode(Ops[isSigned][0], dl, VT, LHS, RHS);
3271 BottomHalf = DAG.getNode(Ops[isSigned][1], dl, DAG.getVTList(VT, VT), LHS,
3274 } else if (TLI.isTypeLegal(EVT::getIntegerVT(*DAG.getContext(),
3276 LHS = DAG.getNode(Ops[isSigned][2], dl, WideVT, LHS);
3277 RHS = DAG.getNode(Ops[isSigned][2], dl, WideVT, RHS);
3278 Tmp1 = DAG.getNode(ISD::MUL, dl, WideVT, LHS, RHS);
3279 BottomHalf = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VT, Tmp1,
3280 DAG.getIntPtrConstant(0));
3281 TopHalf = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VT, Tmp1,
3282 DAG.getIntPtrConstant(1));
3302 SDValue HiLHS = DAG.getNode(ISD::SRA, dl, VT, RHS,
3303 DAG.getConstant(LoSize-1, TLI.getPointerTy()));
3304 SDValue HiRHS = DAG.getNode(ISD::SRA, dl, VT, LHS,
3305 DAG.getConstant(LoSize-1, TLI.getPointerTy()));
3313 BottomHalf = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VT, Ret,
3314 DAG.getIntPtrConstant(0));
3315 TopHalf = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VT, Ret,
3316 DAG.getIntPtrConstant(1));
3320 DAG.DeleteNode(Ret.getNode());
3324 Tmp1 = DAG.getConstant(VT.getSizeInBits() - 1,
3326 Tmp1 = DAG.getNode(ISD::SRA, dl, VT, BottomHalf, Tmp1);
3327 TopHalf = DAG.getSetCC(dl, TLI.getSetCCResultType(VT), TopHalf, Tmp1,
3330 TopHalf = DAG.getSetCC(dl, TLI.getSetCCResultType(VT), TopHalf,
3331 DAG.getConstant(0, VT), ISD::SETNE);
3339 Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, dl, PairTy, Node->getOperand(0));
3340 Tmp2 = DAG.getNode(ISD::ANY_EXTEND, dl, PairTy, Node->getOperand(1));
3341 Tmp2 = DAG.getNode(ISD::SHL, dl, PairTy, Tmp2,
3342 DAG.getConstant(PairTy.getSizeInBits()/2,
3344 Results.push_back(DAG.getNode(ISD::OR, dl, PairTy, Tmp1, Tmp2));
3352 Tmp1 = DAG.getSelectCC(dl, Tmp1.getOperand(0), Tmp1.getOperand(1),
3356 Tmp1 = DAG.getSelectCC(dl, Tmp1,
3357 DAG.getConstant(0, Tmp1.getValueType()),
3371 DAG.getMachineFunction().getJumpTableInfo()->getEntrySize(TD);
3373 Index = DAG.getNode(ISD::MUL, dl, PTy,
3374 Index, DAG.getConstant(EntrySize, PTy));
3375 SDValue Addr = DAG.getNode(ISD::ADD, dl, PTy, Index, Table);
3377 EVT MemVT = EVT::getIntegerVT(*DAG.getContext(), EntrySize * 8);
3378 SDValue LD = DAG.getExtLoad(ISD::SEXTLOAD, dl, PTy, Chain, Addr,
3386 Addr = DAG.getNode(ISD::ADD, dl, PTy, Addr,
3387 TLI.getPICJumpTableRelocBase(Table, DAG));
3389 Tmp1 = DAG.getNode(ISD::BRIND, dl, MVT::Other, LD.getValue(1), Addr);
3399 Tmp1 = DAG.getNode(ISD::BR_CC, dl, MVT::Other,
3406 DAG.getNode(ISD::AND, dl, Tmp2.getValueType(), Tmp2,
3407 DAG.getConstant(1, Tmp2.getValueType()));
3408 Tmp1 = DAG.getNode(ISD::BR_CC, dl, MVT::Other, Tmp1,
3409 DAG.getCondCode(ISD::SETNE), Tmp3,
3410 DAG.getConstant(0, Tmp3.getValueType()),
3430 Tmp1 = DAG.getNode(ISD::SELECT_CC, dl, VT, Tmp1, Tmp2,
3431 DAG.getConstant(1, VT), DAG.getConstant(0, VT), Tmp3);
3446 Tmp2 = DAG.getConstant(0, Tmp1.getValueType());
3447 CC = DAG.getCondCode(ISD::SETNE);
3448 Tmp1 = DAG.getNode(ISD::SELECT_CC, dl, Node->getValueType(0), Tmp1, Tmp2,
3463 Tmp3 = DAG.getConstant(0, Tmp2.getValueType());
3464 Tmp4 = DAG.getCondCode(ISD::SETNE);
3465 Tmp1 = DAG.getNode(ISD::BR_CC, dl, Node->getValueType(0), Tmp1, Tmp4, Tmp2,
3484 SDValue Ex = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
3486 Node->getOperand(0), DAG.getIntPtrConstant(Idx));
3487 SDValue Sh = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
3489 Node->getOperand(1), DAG.getIntPtrConstant(Idx));
3490 Scalars.push_back(DAG.getNode(Node->getOpcode(), dl,
3494 DAG.getNode(ISD::BUILD_VECTOR, dl, Node->getValueType(0),
3535 Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Node->getOperand(0));
3538 Tmp1 = DAG.getNode(Node->getOpcode(), dl, NVT, Tmp1);
3541 Tmp2 = DAG.getSetCC(dl, TLI.getSetCCResultType(NVT),
3542 Tmp1, DAG.getConstant(NVT.getSizeInBits(), NVT),
3544 Tmp1 = DAG.getNode(ISD::SELECT, dl, NVT, Tmp2,
3545 DAG.getConstant(OVT.getSizeInBits(), NVT), Tmp1);
3549 Tmp1 = DAG.getNode(ISD::SUB, dl, NVT, Tmp1,
3550 DAG.getConstant(NVT.getSizeInBits() -
3553 Results.push_back(DAG.getNode(ISD::TRUNCATE, dl, OVT, Tmp1));
3557 Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Node->getOperand(0));
3558 Tmp1 = DAG.getNode(ISD::BSWAP, dl, NVT, Tmp1);
3559 Tmp1 = DAG.getNode(ISD::SRL, dl, NVT, Tmp1,
3560 DAG.getConstant(DiffBits, TLI.getShiftAmountTy(NVT)));
3590 Tmp1 = DAG.getVAArg(NVT, dl, Chain, Ptr, Node->getOperand(2),
3594 Tmp2 = DAG.getNode(TruncOp, dl, OVT, Tmp1);
3598 DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 0), Tmp2);
3599 DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 1), Chain);
3616 Tmp1 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(0));
3617 Tmp2 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(1));
3619 Tmp1 = DAG.getNode(Node->getOpcode(), dl, NVT, Tmp1, Tmp2);
3620 Results.push_back(DAG.getNode(TruncOp, dl, OVT, Tmp1));
3637 Tmp2 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(1));
3638 Tmp3 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(2));
3640 Tmp1 = DAG.getNode(ISD::SELECT, dl, NVT, Tmp1, Tmp2, Tmp3);
3642 Tmp1 = DAG.getNode(TruncOp, dl, Node->getValueType(0), Tmp1);
3644 Tmp1 = DAG.getNode(TruncOp, dl, Node->getValueType(0), Tmp1,
3645 DAG.getIntPtrConstant(0));
3653 Tmp1 = DAG.getNode(ISD::BITCAST, dl, NVT, Node->getOperand(0));
3654 Tmp2 = DAG.getNode(ISD::BITCAST, dl, NVT, Node->getOperand(1));
3658 Tmp1 = DAG.getNode(ISD::BITCAST, dl, OVT, Tmp1);
3669 Tmp1 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(0));
3670 Tmp2 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(1));
3671 Results.push_back(DAG.getNode(ISD::SETCC, dl, Node->getValueType(0),
3678 Tmp1 = DAG.getNode(ISD::FP_EXTEND, dl, NVT, Node->getOperand(0));
3679 Tmp2 = DAG.getNode(ISD::FP_EXTEND, dl, NVT, Node->getOperand(1));
3680 Tmp3 = DAG.getNode(Node->getOpcode(), dl, NVT, Tmp1, Tmp2);
3681 Results.push_back(DAG.getNode(ISD::FP_ROUND, dl, OVT,
3682 Tmp3, DAG.getIntPtrConstant(0)));
3689 Tmp1 = DAG.getNode(ISD::FP_EXTEND, dl, NVT, Node->getOperand(0));
3690 Tmp2 = DAG.getNode(Node->getOpcode(), dl, NVT, Tmp1);
3691 Results.push_back(DAG.getNode(ISD::FP_ROUND, dl, OVT,
3692 Tmp2, DAG.getIntPtrConstant(0)));
