Lines Matching defs:DAG
54 SelectionDAG &DAG;
63 return TLI.getSetCCResultType(*DAG.getContext(), VT);
69 explicit SelectionDAGLegalize(SelectionDAG &DAG);
164 DAG.RemoveDeadNode(N);
170 DAG.ReplaceAllUsesWith(Old, New);
174 DAG.ReplaceAllUsesWith(Old, New);
178 DAG.ReplaceAllUsesWith(Old, New);
199 return DAG.getVectorShuffle(NVT, dl, N1, N2, &Mask[0]);
213 return DAG.getVectorShuffle(NVT, dl, N1, N2, &NewMask[0]);
216 SelectionDAGLegalize::SelectionDAGLegalize(SelectionDAG &dag)
217 : SelectionDAG::DAGUpdateListener(dag),
218 TM(dag.getTarget()), TLI(dag.getTargetLoweringInfo()),
219 DAG(dag) {
223 DAG.AssignTopologicalOrder();
231 for (LegalizePosition = DAG.allnodes_end();
232 LegalizePosition != DAG.allnodes_begin(); ) {
247 DAG.RemoveDeadNodes();
267 return DAG.getConstant(LLVMC->getValueAPF().bitcastToAPInt(),
280 Type *SType = SVT.getTypeForEVT(*DAG.getContext());
287 SDValue CPIdx = DAG.getConstantPool(LLVMC, TLI.getPointerTy());
291 DAG.getExtLoad(ISD::EXTLOAD, dl, OrigVT,
292 DAG.getEntryNode(),
298 DAG.getLoad(OrigVT, dl, DAG.getEntryNode(), CPIdx,
305 static void ExpandUnalignedStore(StoreSDNode *ST, SelectionDAG &DAG,
320 EVT intVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
325 SDValue Result = DAG.getNode(ISD::BITCAST, dl, intVT, Val);
326 Result = DAG.getStore(Chain, dl, Result, Ptr, ST->getPointerInfo(),
335 TLI.getRegisterType(*DAG.getContext(),
336 EVT::getIntegerVT(*DAG.getContext(),
343 SDValue StackPtr = DAG.CreateStackTemporary(StoredVT, RegVT);
346 SDValue Store = DAG.getTruncStore(Chain, dl,
349 SDValue Increment = DAG.getConstant(RegBytes, TLI.getPointerTy(AS));
356 SDValue Load = DAG.getLoad(RegVT, dl, Store, StackPtr,
360 Stores.push_back(DAG.getStore(Load.getValue(1), dl, Load, Ptr,
366 StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr,
368 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
374 EVT MemVT = EVT::getIntegerVT(*DAG.getContext(),
378 SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, RegVT, Store, StackPtr,
382 Stores.push_back(DAG.getTruncStore(Load.getValue(1), dl, Load, Ptr,
390 SDValue Result = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Stores);
398 EVT NewStoredVT = ST->getMemoryVT().getHalfSizedIntegerVT(*DAG.getContext());
403 SDValue ShiftAmount = DAG.getConstant(NumBits,
406 SDValue Hi = DAG.getNode(ISD::SRL, dl, VT, Val, ShiftAmount);
410 Store1 = DAG.getTruncStore(Chain, dl, TLI.isLittleEndian()?Lo:Hi, Ptr,
414 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
415 DAG.getConstant(IncrementSize, TLI.getPointerTy(AS)));
417 Store2 = DAG.getTruncStore(Chain, dl, TLI.isLittleEndian()?Hi:Lo, Ptr,
423 DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Store1, Store2);
429 ExpandUnalignedLoad(LoadSDNode *LD, SelectionDAG &DAG,
440 EVT intVT = EVT::getIntegerVT(*DAG.getContext(), LoadedVT.getSizeInBits());
444 SDValue newLoad = DAG.getLoad(intVT, dl, Chain, Ptr,
446 SDValue Result = DAG.getNode(ISD::BITCAST, dl, LoadedVT, newLoad);
448 Result = DAG.getNode(VT.isFloatingPoint() ? ISD::FP_EXTEND :
458 MVT RegVT = TLI.getRegisterType(*DAG.getContext(), intVT);
464 SDValue StackBase = DAG.CreateStackTemporary(LoadedVT, RegVT);
466 SDValue Increment = DAG.getConstant(RegBytes, TLI.getPointerTy());
474 SDValue Load = DAG.getLoad(RegVT, dl, Chain, Ptr,
481 Stores.push_back(DAG.getStore(Load.getValue(1), dl, Load, StackPtr,
485 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
486 StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr,
491 EVT MemVT = EVT::getIntegerVT(*DAG.getContext(),
493 SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, RegVT, Chain, Ptr,
502 Stores.push_back(DAG.getTruncStore(Load.getValue(1), dl, Load, StackPtr,
507 SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Stores);
510 Load = DAG.getExtLoad(LD->getExtensionType(), dl, VT, TF, StackBase,
525 NewLoadedVT = EVT::getIntegerVT(*DAG.getContext(), NumBits/2);
539 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, VT, Chain, Ptr, LD->getPointerInfo(),
542 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
543 DAG.getConstant(IncrementSize, Ptr.getValueType()));
544 Hi = DAG.getExtLoad(HiExtType, dl, VT, Chain, Ptr,
550 Hi = DAG.getExtLoad(HiExtType, dl, VT, Chain, Ptr, LD->getPointerInfo(),
553 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
554 DAG.getConstant(IncrementSize, Ptr.getValueType()));
555 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, VT, Chain, Ptr,
563 SDValue ShiftAmount = DAG.getConstant(NumBits,
565 SDValue Result = DAG.getNode(ISD::SHL, dl, VT, Hi, ShiftAmount);
566 Result = DAG.getNode(ISD::OR, dl, VT, Result, Lo);
568 SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
596 SDValue StackPtr = DAG.CreateStackTemporary(VT);
601 SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, Tmp1, StackPtr,
607 Tmp3 = DAG.getNode(CastOpc, dl, PtrVT, Tmp3);
610 Tmp3 = DAG.getNode(ISD::MUL, dl, IdxVT, Tmp3,DAG.getConstant(EltSize, IdxVT));
611 SDValue StackPtr2 = DAG.getNode(ISD::ADD, dl, IdxVT, Tmp3, StackPtr);
613 Ch = DAG.getTruncStore(Ch, dl, Tmp2, StackPtr2, MachinePointerInfo(), EltVT,
616 return DAG.getLoad(VT, dl, Ch, StackPtr,
631 SDValue ScVec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
642 return DAG.getVectorShuffle(Vec.getValueType(), dl, Vec, ScVec,
652 // FIXME: move this to the DAG Combiner! Note that we can't regress due
653 // to phase ordering between legalized code and the dag combiner. This
654 // probably means that we need to integrate dag combiner and legalizer
667 SDValue Con = DAG.getConstant(CFP->getValueAPF().
670 return DAG.getStore(Chain, dl, Con, Ptr, ST->getPointerInfo(),
677 SDValue Con = DAG.getConstant(CFP->getValueAPF().bitcastToAPInt().
679 return DAG.getStore(Chain, dl, Con, Ptr, ST->getPointerInfo(),
688 SDValue Lo = DAG.getConstant(IntVal.trunc(32), MVT::i32);
689 SDValue Hi = DAG.getConstant(IntVal.lshr(32).trunc(32), MVT::i32);
692 Lo = DAG.getStore(Chain, dl, Lo, Ptr, ST->getPointerInfo(), isVolatile,
694 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
695 DAG.getConstant(4, Ptr.getValueType()));
696 Hi = DAG.getStore(Chain, dl, Hi, Ptr,
701 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
735 Type *Ty = ST->getMemoryVT().getTypeForEVT(*DAG.getContext());
739 DAG, TLI, this);
744 SDValue Res = TLI.LowerOperation(SDValue(Node, 0), DAG);
753 Value = DAG.getNode(ISD::BITCAST, dl, NVT, Value);
755 DAG.getStore(Chain, dl, Value, Ptr,
774 EVT NVT = EVT::getIntegerVT(*DAG.getContext(),
776 Value = DAG.getZeroExtendInReg(Value, dl, StVT);
778 DAG.getTruncStore(Chain, dl, Value, Ptr, ST->getPointerInfo(),
791 EVT RoundVT = EVT::getIntegerVT(*DAG.getContext(), RoundWidth);
792 EVT ExtraVT = EVT::getIntegerVT(*DAG.getContext(), ExtraWidth);
799 Lo = DAG.getTruncStore(Chain, dl, Value, Ptr, ST->getPointerInfo(),
806 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
807 DAG.getConstant(IncrementSize, Ptr.getValueType()));
808 Hi = DAG.getNode(ISD::SRL, dl, Value.getValueType(), Value,
809 DAG.getConstant(RoundWidth,
811 Hi = DAG.getTruncStore(Chain, dl, Hi, Ptr,
819 Hi = DAG.getNode(ISD::SRL, dl, Value.getValueType(), Value,
820 DAG.getConstant(ExtraWidth,
822 Hi = DAG.getTruncStore(Chain, dl, Hi, Ptr, ST->getPointerInfo(),
828 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
829 DAG.getConstant(IncrementSize, Ptr.getValueType()));
830 Lo = DAG.getTruncStore(Chain, dl, Value, Ptr,
837 SDValue Result = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
848 Type *Ty = ST->getMemoryVT().getTypeForEVT(*DAG.getContext());
851 ExpandUnalignedStore(cast<StoreSDNode>(Node), DAG, TLI, this);
856 SDValue Res = TLI.LowerOperation(SDValue(Node, 0), DAG);
868 Value = DAG.getNode(ISD::TRUNCATE, dl, StVT, Value);
870 DAG.getStore(Chain, dl, Value, Ptr, ST->getPointerInfo(),
899 Type *Ty = LD->getMemoryVT().getTypeForEVT(*DAG.getContext());
903 ExpandUnalignedLoad(cast<LoadSDNode>(Node), DAG, TLI, RVal, RChain);
909 SDValue Res = TLI.LowerOperation(RVal, DAG);
921 SDValue Res = DAG.getLoad(NVT, dl, Chain, Ptr, LD->getMemOperand());
922 RVal = DAG.getNode(ISD::BITCAST, dl, VT, Res);
929 DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 0), RVal);
930 DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 1), RChain);
956 EVT NVT = EVT::getIntegerVT(*DAG.getContext(), NewWidth);
966 DAG.getExtLoad(NewExtType, dl, Node->getValueType(0),
974 Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl,
976 Result, DAG.getValueType(SrcVT));
979 Result = DAG.getNode(ISD::AssertZext, dl,
981 DAG.getValueType(SrcVT));
994 EVT RoundVT = EVT::getIntegerVT(*DAG.getContext(), RoundWidth);
995 EVT ExtraVT = EVT::getIntegerVT(*DAG.getContext(), ExtraWidth);
1002 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, Node->getValueType(0),
1009 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
1010 DAG.getConstant(IncrementSize, Ptr.getValueType()));
1011 Hi = DAG.getExtLoad(ExtType, dl, Node->getValueType(0), Chain, Ptr,
1018 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
1022 Hi = DAG.getNode(ISD::SHL, dl, Hi.getValueType(), Hi,
1023 DAG.getConstant(RoundWidth,
1027 Value = DAG.getNode(ISD::OR, dl, Node->getValueType(0), Lo, Hi);
1032 Hi = DAG.getExtLoad(ExtType, dl, Node->getValueType(0), Chain, Ptr,
1038 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
1039 DAG.getConstant(IncrementSize, Ptr.getValueType()));
1040 Lo = DAG.getExtLoad(ISD::ZEXTLOAD,
1048 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
1052 Hi = DAG.getNode(ISD::SHL, dl, Hi.getValueType(), Hi,
1053 DAG.getConstant(ExtraWidth,
1057 Value = DAG.getNode(ISD::OR, dl, Node->getValueType(0), Lo, Hi);
1073 SDValue Res = TLI.LowerOperation(SDValue(Node, 0), DAG);
1085 LD->getMemoryVT().getTypeForEVT(*DAG.getContext());
1090 DAG, TLI, Value, Chain);
1099 SDValue Load = DAG.getLoad(SrcVT, dl, Chain, Ptr,
1111 Value = DAG.getNode(ExtendOp, dl, Node->getValueType(0), Load);
1127 SDValue Result = DAG.getExtLoad(ISD::EXTLOAD, dl,
1133 ValRes = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl,
1135 Result, DAG.getValueType(SrcVT));
1137 ValRes = DAG.getZeroExtendInReg(Result, dl,
1149 DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 0), Value);
1150 DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 1), Chain);
1162 assert(TLI.getTypeAction(*DAG.getContext(), Node->getValueType(i)) ==
1167 assert((TLI.getTypeAction(*DAG.getContext(),
1270 // Named register is legal in the DAG, but blocked by register name
1280 NewVal = DAG.getNode(ISD::TRAP, SDLoc(Node), Node->getVTList(),
1310 DAG.getShiftAmountOperand(Node->getOperand(0).getValueType(),
1314 NewNode = DAG.UpdateNodeOperands(Node, Node->getOperand(0),
1325 DAG.getShiftAmountOperand(Node->getOperand(0).getValueType(),
1329 NewNode = DAG.UpdateNodeOperands(Node, Node->getOperand(0),
1337 DAG.ReplaceAllUsesWith(Node, NewNode);
1339 DAG.TransferDbgValues(SDValue(Node, i), SDValue(NewNode, i));
1349 SDValue Res = TLI.LowerOperation(SDValue(Node, 0), DAG);
1359 DAG.ReplaceAllUsesWith(Node, ResultVals.data());
1361 DAG.TransferDbgValues(SDValue(Node, i), ResultVals[i]);
1381 Node->dump( &DAG);
1420 if (!ST->getChain().reachesChainWithoutSideEffects(DAG.getEntryNode()))
1431 StackPtr = DAG.CreateStackTemporary(Vec.getValueType());
1432 Ch = DAG.getStore(DAG.getEntryNode(), dl, Vec, StackPtr,
1439 Idx = DAG.getNode(ISD::MUL, dl, Idx.getValueType(), Idx,
1440 DAG.getConstant(EltSize, Idx.getValueType()));
1442 Idx = DAG.getZExtOrTrunc(Idx, dl, TLI.getPointerTy());
1443 StackPtr = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, StackPtr);
1446 return DAG.getLoad(Op.getValueType(), dl, Ch, StackPtr,MachinePointerInfo(),
1448 return DAG.getExtLoad(ISD::EXTLOAD, dl, Op.getValueType(), Ch, StackPtr,
1464 SDValue StackPtr = DAG.CreateStackTemporary(Vec.getValueType());
1469 SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, Vec, StackPtr, PtrInfo,
1478 Idx = DAG.getNode(ISD::MUL, dl, Idx.getValueType(), Idx,
1479 DAG.getConstant(EltSize, Idx.getValueType()));
1480 Idx = DAG.getZExtOrTrunc(Idx, dl, TLI.getPointerTy());
1482 SDValue SubStackPtr = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx,
1486 Ch = DAG.getStore(DAG.getEntryNode(), dl, Part, SubStackPtr,
1490 return DAG.getLoad(Op.getValueType(), dl, Ch, StackPtr, PtrInfo,
1502 SDValue FIPtr = DAG.CreateStackTemporary(VT);
1516 SDValue Idx = DAG.getConstant(Offset, FIPtr.getValueType());
1517 Idx = DAG.getNode(ISD::ADD, dl, FIPtr.getValueType(), FIPtr, Idx);
1522 Stores.push_back(DAG.getTruncStore(DAG.getEntryNode(), dl,
1527 Stores.push_back(DAG.getStore(DAG.getEntryNode(), dl,
1535 StoreChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Stores);
1537 StoreChain = DAG.getEntryNode();
1540 return DAG.getLoad(VT, dl, StoreChain, FIPtr, PtrInfo,
1553 EVT IVT = EVT::getIntegerVT(*DAG.getContext(), FloatVT.getSizeInBits());
1556 SignBit = DAG.getNode(ISD::BITCAST, dl, IVT, Tmp2);
1561 SDValue StackPtr = DAG.CreateStackTemporary(FloatVT, LoadTy);
1564 DAG.getStore(DAG.getEntryNode(), dl, Tmp2, StackPtr, MachinePointerInfo(),
1569 SignBit = DAG.getLoad(LoadTy, dl, Ch, StackPtr, MachinePointerInfo(),
1577 LoadPtr = DAG.getNode(ISD::ADD, dl, LoadPtr.getValueType(), LoadPtr,
1578 DAG.getConstant(ByteOffset, LoadPtr.getValueType()));
1580 SignBit = DAG.getLoad(LoadTy, dl, Ch, LoadPtr, MachinePointerInfo(),
1587 SignBit = DAG.getNode(ISD::SHL, dl, LoadTy, SignBit,
1588 DAG.getConstant(BitShift,
1593 SignBit = DAG.getSetCC(dl, getSetCCResultType(SignBit.getValueType()),
1594 SignBit, DAG.getConstant(0, SignBit.getValueType()),
1597 SDValue AbsVal = DAG.getNode(ISD::FABS, dl, Tmp1.getValueType(), Tmp1);
1600 return DAG.getSelect(dl, AbsVal.getValueType(), SignBit,
1601 DAG.getNode(ISD::FNEG, dl, AbsVal.getValueType(), AbsVal),
1619 Chain = DAG.getCALLSEQ_START(Chain, DAG.getIntPtrConstant(0, true),
1623 SDValue SP = DAG.getCopyFromReg(Chain, dl, SPReg, VT);
1627 Tmp1 = DAG.getNode(ISD::SUB, dl, VT, SP, Size); // Value
1629 Tmp1 = DAG.getNode(ISD::AND, dl, VT, Tmp1,
1630 DAG.getConstant(-(uint64_t)Align, VT));
1631 Chain = DAG.getCopyToReg(Chain, dl, SPReg, Tmp1); // Output chain
1633 Tmp2 = DAG.getCALLSEQ_END(Chain, DAG.getIntPtrConstant(0, true),
1634 DAG.getIntPtrConstant(0, true), SDValue(),
1676 CC = DAG.getCondCode(InvCC);
1727 CC = DAG.getCondCode(InvCC);
1740 SetCC1 = DAG.getSetCC(dl, VT, LHS, RHS, CC1);
1741 SetCC2 = DAG.getSetCC(dl, VT, LHS, RHS, CC2);
1744 SetCC1 = DAG.getSetCC(dl, VT, LHS, LHS, CC1);
1745 SetCC2 = DAG.getSetCC(dl, VT, RHS, RHS, CC2);
1747 LHS = DAG.getNode(Opc, dl, VT, SetCC1, SetCC2);
1767 getTypeForEVT(*DAG.getContext()));
1768 SDValue FIPtr = DAG.CreateStackTemporary(SlotVT, SrcAlign);
1777 Type *DestType = DestVT.getTypeForEVT(*DAG.getContext());
1785 Store = DAG.getTruncStore(DAG.getEntryNode(), dl, SrcOp, FIPtr,
1789 Store = DAG.getStore(DAG.getEntryNode(), dl, SrcOp, FIPtr,
1795 return DAG.getLoad(DestVT, dl, Store, FIPtr, PtrInfo,
1799 return DAG.getExtLoad(ISD::EXTLOAD, dl, DestVT, Store, FIPtr,
1807 SDValue StackPtr = DAG.CreateStackTemporary(Node->getValueType(0));
1812 SDValue Ch = DAG.getTruncStore(DAG.getEntryNode(), dl, Node->getOperand(0),
1817 return DAG.getLoad(Node->getValueType(0), dl, Ch, StackPtr,
1823 ExpandBVWithShuffles(SDNode *Node, SelectionDAG &DAG,
1846 Vec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, V);
1875 Shuffle = DAG.getVectorShuffle(VT, dl, IntermedVals[i].first,
1898 Vec2 = DAG.getUNDEF(VT);
1907 Res = DAG.getVectorShuffle(VT, dl, Vec1, Vec2, ShuffleVec.data());
1950 return DAG.getUNDEF(VT);
1953 return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Node->getOperand(0));
1971 CV.push_back(ConstantInt::get(EltVT.getTypeForEVT(*DAG.getContext()),
1976 Type *OpNTy = EltVT.getTypeForEVT(*DAG.getContext());
1981 SDValue CPIdx = DAG.getConstantPool(CP, TLI.getPointerTy());
1983 return DAG.getLoad(VT, dl, DAG.getEntryNode(), CPIdx,
2006 SDValue Vec1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Value1);
2009 Vec2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Value2);
2011 Vec2 = DAG.getUNDEF(VT);
2014 return DAG.getVectorShuffle(VT, dl, Vec1, Vec2, ShuffleVec.data());
2018 if (ExpandBVWithShuffles(Node, DAG, TLI, Res))
2037 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
2043 SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
2046 Type *RetTy = Node->getValueType(0).getTypeForEVT(*DAG.getContext());
2052 SDValue InChain = DAG.getEntryNode();
2057 bool isTailCall = TLI.isInTailCallPosition(DAG, Node, TCChain);
2061 TargetLowering::CallLoweringInfo CLI(DAG);
2069 // It's a tailcall, return the chain (which is the DAG root).
2070 return DAG.getRoot();
2086 Entry.Ty = Entry.Node.getValueType().getTypeForEVT(*DAG.getContext());
2091 SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
2094 Type *RetTy = RetVT.getTypeForEVT(*DAG.getContext());
2096 TargetLowering::CallLoweringInfo CLI(DAG);
2097 CLI.setDebugLoc(dl).setChain(DAG.getEntryNode())
2118 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
2125 SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
2128 Type *RetTy = Node->getValueType(0).getTypeForEVT(*DAG.getContext());
2130 TargetLowering::CallLoweringInfo CLI(DAG);
2239 SDValue InChain = DAG.getEntryNode();
2242 Type *RetTy = RetVT.getTypeForEVT(*DAG.getContext());
2248 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
2256 SDValue FIPtr = DAG.CreateStackTemporary(RetVT);
2263 SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
2267 TargetLowering::CallLoweringInfo CLI(DAG);
2275 SDValue Rem = DAG.getLoad(RetVT, dl, CallInfo.second, FIPtr,
2346 SDValue InChain = DAG.getEntryNode();
2349 Type *RetTy = RetVT.getTypeForEVT(*DAG.getContext());
2362 SDValue SinPtr = DAG.CreateStackTemporary(RetVT);
2370 SDValue CosPtr = DAG.CreateStackTemporary(RetVT);
2377 SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
2381 TargetLowering::CallLoweringInfo CLI(DAG);
2384 Type::getVoidTy(*DAG.getContext()), Callee, std::move(Args), 0);
2388 Results.push_back(DAG.getLoad(RetVT, dl, CallInfo.second, SinPtr,
2390 Results.push_back(DAG.getLoad(RetVT, dl, CallInfo.second, CosPtr,
2406 SDValue StackSlot = DAG.CreateStackTemporary(MVT::f64);
2409 SDValue WordOff = DAG.getConstant(sizeof(int), StackSlot.getValueType());
2412 SDValue Lo = DAG.getNode(ISD::ADD, dl, StackSlot.getValueType(),
2421 SDValue SignBit = DAG.getConstant(0x80000000u, MVT::i32);
2422 Op0Mapped = DAG.getNode(ISD::XOR, dl, MVT::i32, Op0, SignBit);
2427 SDValue Store1 = DAG.getStore(DAG.getEntryNode(), dl,
2431 SDValue InitialHi = DAG.getConstant(0x43300000u, MVT::i32);
2433 SDValue Store2 = DAG.getStore(Store1, dl, InitialHi, Hi,
2437 SDValue Load = DAG.getLoad(MVT::f64, dl, Store2, StackSlot,
2440 SDValue Bias = DAG.getConstantFP(isSigned ?
2445 SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::f64, Load, Bias);
2453 Result = DAG.getNode(ISD::FP_ROUND, dl, DestVT, Sub,
2454 DAG.getIntPtrConstant(0));
2456 Result = DAG.getNode(ISD::FP_EXTEND, dl, DestVT, Sub);
2470 DAG.getConstant(UINT64_C(0x4330000000000000), MVT::i64);
2472 DAG.getConstantFP(BitsToDouble(UINT64_C(0x4530000000100000)), MVT::f64);
2474 DAG.getConstant(UINT64_C(0x4530000000000000), MVT::i64);
2476 SDValue Lo = DAG.getZeroExtendInReg(Op0, dl, MVT::i32);
2477 SDValue Hi = DAG.getNode(ISD::SRL, dl, MVT::i64, Op0,
2478 DAG.getConstant(32, MVT::i64));
2479 SDValue LoOr = DAG.getNode(ISD::OR, dl, MVT::i64, Lo, TwoP52);
2480 SDValue HiOr = DAG.getNode(ISD::OR, dl, MVT::i64, Hi, TwoP84);
2481 SDValue LoFlt = DAG.getNode(ISD::BITCAST, dl, MVT::f64, LoOr);
2482 SDValue HiFlt = DAG.getNode(ISD::BITCAST, dl, MVT::f64, HiOr);
2483 SDValue HiSub = DAG.getNode(ISD::FSUB, dl, MVT::f64, HiFlt,
2485 return DAG.getNode(ISD::FADD, dl, MVT::f64, LoFlt, HiSub);
2494 SDValue Fast = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::f32, Op0);
2497 DAG.getConstant(1, TLI.getShiftAmountTy(Op0.getValueType()));
2498 SDValue Shr = DAG.getNode(ISD::SRL, dl, MVT::i64, Op0, ShiftConst);
2499 SDValue AndConst = DAG.getConstant(1, MVT::i64);
2500 SDValue And = DAG.getNode(ISD::AND, dl, MVT::i64, Op0, AndConst);
2501 SDValue Or = DAG.getNode(ISD::OR, dl, MVT::i64, And, Shr);
2503 SDValue SignCvt = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::f32, Or);
2504 SDValue Slow = DAG.getNode(ISD::FADD, dl, MVT::f32, SignCvt, SignCvt);
2510 SDValue SignBitTest = DAG.getSetCC(dl, getSetCCResultType(MVT::i64),
2511 Op0, DAG.getConstant(0, MVT::i64), ISD::SETLT);
2512 return DAG.getSelect(dl, MVT::f32, SignBitTest, Slow, Fast);
2517 SDValue And = DAG.getNode(ISD::AND, dl, MVT::i64, Op0,
2518 DAG.getConstant(UINT64_C(0xfffffffffffff800), MVT::i64));
2519 SDValue Or = DAG.getNode(ISD::OR, dl, MVT::i64, And,
2520 DAG.getConstant(UINT64_C(0x800), MVT::i64));
2521 SDValue And2 = DAG.getNode(ISD::AND, dl, MVT::i64, Op0,
2522 DAG.getConstant(UINT64_C(0x7ff), MVT::i64));
2523 SDValue Ne = DAG.getSetCC(dl, getSetCCResultType(MVT::i64),
2524 And2, DAG.getConstant(UINT64_C(0), MVT::i64), ISD::SETNE);
2525 SDValue Sel = DAG.getSelect(dl, MVT::i64, Ne, Or, Op0);
2526 SDValue Ge = DAG.getSetCC(dl, getSetCCResultType(MVT::i64),
2527 Op0, DAG.getConstant(UINT64_C(0x0020000000000000), MVT::i64),
2529 SDValue Sel2 = DAG.getSelect(dl, MVT::i64, Ge, Sel, Op0);
2532 SDValue Sh = DAG.getNode(ISD::SRL, dl, MVT::i64, Sel2,
2533 DAG.getConstant(32, SHVT));
2534 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Sh);
2535 SDValue Fcvt = DAG.getNode(ISD::UINT_TO_FP, dl, MVT::f64, Trunc);
2537 DAG.getConstantFP(BitsToDouble(UINT64_C(0x41f0000000000000)), MVT::f64);
2538 SDValue Fmul = DAG.getNode(ISD::FMUL, dl, MVT::f64, TwoP32, Fcvt);
2539 SDValue Lo = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Sel2);
2540 SDValue Fcvt2 = DAG.getNode(ISD::UINT_TO_FP, dl, MVT::f64, Lo);
2541 SDValue Fadd = DAG.getNode(ISD::FADD, dl, MVT::f64, Fmul, Fcvt2);
2542 return DAG.getNode(ISD::FP_ROUND, dl, MVT::f32, Fadd,
2543 DAG.getIntPtrConstant(0));
2546 SDValue Tmp1 = DAG.getNode(ISD::SINT_TO_FP, dl, DestVT, Op0);
2548 SDValue SignSet = DAG.getSetCC(dl, getSetCCResultType(Op0.getValueType()),
2549 Op0, DAG.getConstant(0, Op0.getValueType()),
2551 SDValue Zero = DAG.getIntPtrConstant(0), Four = DAG.getIntPtrConstant(4);
2552 SDValue CstOffset = DAG.getSelect(dl, Zero.getValueType(),
2568 Type::getInt64Ty(*DAG.getContext()), FF);
2570 SDValue CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy());
2572 CPIdx = DAG.getNode(ISD::ADD, dl, CPIdx.getValueType(), CPIdx, CstOffset);
2576 FudgeInReg = DAG.getLoad(MVT::f32, dl, DAG.getEntryNode(), CPIdx,
2580 SDValue Load = DAG.getExtLoad(ISD::EXTLOAD, dl, DestVT,
2581 DAG.getEntryNode(), CPIdx,
2589 return DAG.getNode(ISD::FADD, dl, DestVT, Tmp1, FudgeInReg);
2629 return DAG.getNode(OpToUse, dl, DestVT,
2630 DAG.getNode(isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND,
2671 SDValue Operation = DAG.getNode(OpToUse, dl, NewOutTy, LegalOp);
2675 return DAG.getNode(ISD::TRUNCATE, dl, DestVT, Operation);
2687 Tmp2 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(8, SHVT));
2688 Tmp1 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(8, SHVT));
2689 return DAG.getNode(ISD::OR, dl, VT, Tmp1, Tmp2);
2691 Tmp4 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(24, SHVT));
2692 Tmp3 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(8, SHVT));
2693 Tmp2 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(8, SHVT));
2694 Tmp1 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(24, SHVT));
2695 Tmp3 = DAG.getNode(ISD::AND, dl, VT, Tmp3, DAG.getConstant(0xFF0000, VT));
2696 Tmp2 = DAG.getNode(ISD::AND, dl, VT, Tmp2, DAG.getConstant(0xFF00, VT));
2697 Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp3);
2698 Tmp2 = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp1);
2699 return DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp2);
2701 Tmp8 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(56, SHVT));
2702 Tmp7 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(40, SHVT));
2703 Tmp6 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(24, SHVT));
2704 Tmp5 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(8, SHVT));
2705 Tmp4 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(8, SHVT));
2706 Tmp3 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(24, SHVT));
2707 Tmp2 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(40, SHVT));
2708 Tmp1 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(56, SHVT));
2709 Tmp7 = DAG.getNode(ISD::AND, dl, VT, Tmp7, DAG.getConstant(255ULL<<48, VT));
2710 Tmp6 = DAG.getNode(ISD::AND, dl, VT, Tmp6, DAG.getConstant(255ULL<<40, VT));
2711 Tmp5 = DAG.getNode(ISD::AND, dl, VT, Tmp5, DAG.getConstant(255ULL<<32, VT));
2712 Tmp4 = DAG.getNode(ISD::AND, dl, VT, Tmp4, DAG.getConstant(255ULL<<24, VT));
2713 Tmp3 = DAG.getNode(ISD::AND, dl, VT, Tmp3, DAG.getConstant(255ULL<<16, VT));
2714 Tmp2 = DAG.getNode(ISD::AND, dl, VT, Tmp2, DAG.getConstant(255ULL<<8 , VT));
2715 Tmp8 = DAG.getNode(ISD::OR, dl, VT, Tmp8, Tmp7);
2716 Tmp6 = DAG.getNode(ISD::OR, dl, VT, Tmp6, Tmp5);
2717 Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp3);
2718 Tmp2 = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp1);
2719 Tmp8 = DAG.getNode(ISD::OR, dl, VT, Tmp8, Tmp6);
2720 Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp2);
2721 return DAG.getNode(ISD::OR, dl, VT, Tmp8, Tmp4);
2742 SDValue Mask55 = DAG.getConstant(APInt::getSplat(Len, APInt(8, 0x55)), VT);
2743 SDValue Mask33 = DAG.getConstant(APInt::getSplat(Len, APInt(8, 0x33)), VT);
2744 SDValue Mask0F = DAG.getConstant(APInt::getSplat(Len, APInt(8, 0x0F)), VT);
2745 SDValue Mask01 = DAG.getConstant(APInt::getSplat(Len, APInt(8, 0x01)), VT);
2748 Op = DAG.getNode(ISD::SUB, dl, VT, Op,
2749 DAG.getNode(ISD::AND, dl, VT,
2750 DAG.getNode(ISD::SRL, dl, VT, Op,
2751 DAG.getConstant(1, ShVT)),
2754 Op = DAG.getNode(ISD::ADD, dl, VT,
2755 DAG.getNode(ISD::AND, dl, VT, Op, Mask33),
2756 DAG.getNode(ISD::AND, dl, VT,
2757 DAG.getNode(ISD::SRL, dl, VT, Op,
2758 DAG.getConstant(2, ShVT)),
2761 Op = DAG.getNode(ISD::AND, dl, VT,
2762 DAG.getNode(ISD::ADD, dl, VT, Op,
2763 DAG.getNode(ISD::SRL, dl, VT, Op,
2764 DAG.getConstant(4, ShVT))),
2767 Op = DAG.getNode(ISD::SRL, dl, VT,
2768 DAG.getNode(ISD::MUL, dl, VT, Op, Mask01),
2769 DAG.getConstant(Len - 8, ShVT));
2775 return DAG.getNode(ISD::CTLZ, dl, Op.getValueType(), Op);
2790 SDValue Tmp3 = DAG.getConstant(1ULL << i, ShVT);
2791 Op = DAG.getNode(ISD::OR, dl, VT, Op,
2792 DAG.getNode(ISD::SRL, dl, VT, Op, Tmp3));
2794 Op = DAG.getNOT(dl, Op, VT);
2795 return DAG.getNode(ISD::CTPOP, dl, VT, Op);
2799 return DAG.getNode(ISD::CTTZ, dl, Op.getValueType(), Op);
2806 SDValue Tmp3 = DAG.getNode(ISD::AND, dl, VT,
2807 DAG.getNOT(dl, Op, VT),
2808 DAG.getNode(ISD::SUB, dl, VT, Op,
2809 DAG.getConstant(1, VT)));
2813 return DAG.getNode(ISD::SUB, dl, VT,
2814 DAG.getConstant(VT.getSizeInBits(), VT),
2815 DAG.getNode(ISD::CTLZ, dl, VT, Tmp3));
2816 return DAG.getNode(ISD::CTPOP, dl, VT, Tmp3);
2974 Results.push_back(DAG.getConstant(0, Node->getValueType(0)));
2977 Results.push_back(DAG.getConstant(1, Node->getValueType(0)));
2991 Results.push_back(DAG.getConstant(0, MVT::i32));
2999 TargetLowering::CallLoweringInfo CLI(DAG);
3001 .setCallee(CallingConv::C, Type::getVoidTy(*DAG.getContext()),
3002 DAG.getExternalSymbol("__sync_synchronize",
3012 SDValue Zero = DAG.getConstant(0, Node->getValueType(0));
3013 SDVTList VTs = DAG.getVTList(Node->getValueType(0), MVT::Other);
3014 SDValue Swap = DAG.getAtomicCmpSwap(
3027 SDValue Swap = DAG.getAtomic(ISD::ATOMIC_SWAP, dl,
3061 SDVTList VTs = DAG.getVTList(Node->getValueType(0), MVT::Other);
3062 SDValue Res = DAG.getAtomicCmpSwap(
3070 SDValue Success = DAG.getSetCC(SDLoc(Node), Node->getValueType(1),
3088 Results.push_back(DAG.getConstant(0, VT));
3091 Results.push_back(DAG.getConstantFP(0, VT));
3098 TargetLowering::CallLoweringInfo CLI(DAG);
3100 .setCallee(CallingConv::C, Type::getVoidTy(*DAG.getContext()),
3101 DAG.getExternalSymbol("abort", TLI.getPointerTy()),
3130 SDValue ShiftCst = DAG.getConstant(BitsDiff, ShiftAmountTy);
3131 Tmp1 = DAG.getNode(ISD::SHL, dl, Node->getValueType(0),
3133 Tmp1 = DAG.getNode(ISD::SRA, dl, Node->getValueType(0), Tmp1, ShiftCst);
3167 EVT IntVT = EVT::getIntegerVT(*DAG.getContext(),
3169 SDValue ExponentMask = DAG.getConstant(0x7F800000, IntVT);
3170 SDValue ExponentLoBit = DAG.getConstant(23, IntVT);
3171 SDValue Bias = DAG.getConstant(127, IntVT);
3172 SDValue SignMask = DAG.getConstant(APInt::getSignBit(VT.getSizeInBits()),
3174 SDValue SignLowBit = DAG.getConstant(VT.getSizeInBits() - 1, IntVT);
3175 SDValue MantissaMask = DAG.getConstant(0x007FFFFF, IntVT);
3177 SDValue Bits = DAG.getNode(ISD::BITCAST, dl, IntVT, Node->getOperand(0));
3179 SDValue ExponentBits = DAG.getNode(ISD::SRL, dl, IntVT,
3180 DAG.getNode(ISD::AND, dl, IntVT, Bits, ExponentMask),
3181 DAG.getZExtOrTrunc(ExponentLoBit, dl, TLI.getShiftAmountTy(IntVT)));
3182 SDValue Exponent = DAG.getNode(ISD::SUB, dl, IntVT, ExponentBits, Bias);
3184 SDValue Sign = DAG.getNode(ISD::SRA, dl, IntVT,
3185 DAG.getNode(ISD::AND, dl, IntVT, Bits, SignMask),
3186 DAG.getZExtOrTrunc(SignLowBit, dl, TLI.getShiftAmountTy(IntVT)));
3187 Sign = DAG.getSExtOrTrunc(Sign, dl, NVT);
3189 SDValue R = DAG.getNode(ISD::OR, dl, IntVT,
3190 DAG.getNode(ISD::AND, dl, IntVT, Bits, MantissaMask),
3191 DAG.getConstant(0x00800000, IntVT));
3193 R = DAG.getZExtOrTrunc(R, dl, NVT);
3196 R = DAG.getSelectCC(dl, Exponent, ExponentLoBit,
3197 DAG.getNode(ISD::SHL, dl, NVT, R,
3198 DAG.getZExtOrTrunc(
3199 DAG.getNode(ISD::SUB, dl, IntVT, Exponent, ExponentLoBit),
3201 DAG.getNode(ISD::SRL, dl, NVT, R,
3202 DAG.getZExtOrTrunc(
3203 DAG.getNode(ISD::SUB, dl, IntVT, ExponentLoBit, Exponent),
3207 SDValue Ret = DAG.getNode(ISD::SUB, dl, NVT,
3208 DAG.getNode(ISD::XOR, dl, NVT, R, Sign),
3211 Results.push_back(DAG.getSelectCC(dl, Exponent, DAG.getConstant(0, IntVT),
3212 DAG.getConstant(0, NVT), Ret, ISD::SETLT));
3219 APFloat apf(DAG.EVTToAPFloatSemantics(VT),
3223 Tmp1 = DAG.getConstantFP(apf, VT);
3224 Tmp2 = DAG.getSetCC(dl, getSetCCResultType(VT),
3227 True = DAG.getNode(ISD::FP_TO_SINT, dl, NVT, Node->getOperand(0));
3228 False = DAG.getNode(ISD::FP_TO_SINT, dl, NVT,
3229 DAG.getNode(ISD::FSUB, dl, VT,
3231 False = DAG.getNode(ISD::XOR, dl, NVT, False,
3232 DAG.getConstant(x, NVT));
3233 Tmp1 = DAG.getSelect(dl, NVT, Tmp2, True, False);
3244 SDValue VAListLoad = DAG.getLoad(TLI.getPointerTy(), dl, Tmp1, Tmp2,
3252 VAList = DAG.getNode(ISD::ADD, dl, VAList.getValueType(), VAList,
3253 DAG.getConstant(Align - 1,
3256 VAList = DAG.getNode(ISD::AND, dl, VAList.getValueType(), VAList,
3257 DAG.getConstant(-(int64_t)Align,
3262 Tmp3 = DAG.getNode(ISD::ADD, dl, VAList.getValueType(), VAList,
3263 DAG.getConstant(TLI.getDataLayout()->
3264 getTypeAllocSize(VT.getTypeForEVT(*DAG.getContext())),
3267 Tmp3 = DAG.getStore(VAListLoad.getValue(1), dl, Tmp3, Tmp2,
3270 Results.push_back(DAG.getLoad(VT, dl, Tmp3, VAList, MachinePointerInfo(),
3280 Tmp1 = DAG.getLoad(TLI.getPointerTy(), dl, Node->getOperand(0),
3283 Tmp1 = DAG.getStore(Tmp1.getValue(1), dl, Tmp1, Node->getOperand(1),
3291 Tmp1 = DAG.getNode(ISD::BITCAST, dl, Node->getValueType(0),
3325 EVT NewEltVT = TLI.getTypeToTransformTo(*DAG.getContext(), EltVT);
3338 EVT::getVectorVT(*DAG.getContext(), NewEltVT,
3343 Op0 = DAG.getNode(ISD::BITCAST, dl, NewVT, Op0);
3344 Op1 = DAG.getNode(ISD::BITCAST, dl, NewVT, Op1);
3372 Ops.push_back(DAG.getUNDEF(EltVT));
3377 Ops.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT,
3379 DAG.getConstant(Idx, TLI.getVectorIdxTy())));
3381 Ops.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT,
3383 DAG.getConstant(Idx - NumElems,
3387 Tmp1 = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops);
3389 Tmp1 = DAG.getNode(ISD::BITCAST, dl, Node->getValueType(0), Tmp1);
3397 Tmp1 = DAG.getNode(ISD::SRL, dl, OpTy, Node->getOperand(0),
3398 DAG.getConstant(OpTy.getSizeInBits()/2,
3400 Tmp1 = DAG.getNode(ISD::TRUNCATE, dl, Node->getValueType(0), Tmp1);
3403 Tmp1 = DAG.getNode(ISD::TRUNCATE, dl, Node->getValueType(0),
3413 Results.push_back(DAG.getCopyFromReg(Node->getOperand(0), dl, SP,
3417 Results.push_back(DAG.getUNDEF(Node->getValueType(0)));
3425 Results.push_back(DAG.getCopyToReg(Node->getOperand(0), dl, SP,
3436 Tmp1 = DAG.getConstantFP(-0.0, Node->getValueType(0));
3437 Tmp1 = DAG.getNode(ISD::FSUB, dl, Node->getValueType(0), Tmp1,
3445 Tmp2 = DAG.getConstantFP(0.0, VT);
3446 Tmp2 = DAG.getSetCC(dl, getSetCCResultType(Tmp1.getValueType()),
3448 Tmp3 = DAG.getNode(ISD::FNEG, dl, VT, Tmp1);
3449 Tmp1 = DAG.getSelect(dl, VT, Tmp2, Tmp1, Tmp3);
3467 SDVTList VTs = DAG.getVTList(VT, VT);
3468 Tmp1 = DAG.getNode(ISD::FSINCOS, dl, VTs, Node->getOperand(0));
3590 Tmp1 = DAG.getNode(ISD::FNEG, dl, VT, Node->getOperand(1));
3591 Tmp1 = DAG.getNode(ISD::FADD, dl, VT, Node->getOperand(0), Tmp1);
3600 Tmp1 = DAG.getNode(ISD::XOR, dl, VT, Node->getOperand(1),
3601 DAG.getConstant(APInt::getAllOnesValue(VT.getSizeInBits()), VT));
3602 Tmp1 = DAG.getNode(ISD::ADD, dl, VT, Tmp1, DAG.getConstant(1, VT));
3603 Results.push_back(DAG.getNode(ISD::ADD, dl, VT, Node->getOperand(0), Tmp1));
3619 SDVTList VTs = DAG.getVTList(VT, VT);
3620 Tmp1 = DAG.getNode(DivRemOpc, dl, VTs, Tmp2, Tmp3).getValue(1);
3623 Tmp1 = DAG.getNode(DivOpc, dl, VT, Tmp2, Tmp3);
3624 Tmp1 = DAG.getNode(ISD::MUL, dl, VT, Tmp1, Tmp3);
3625 Tmp1 = DAG.getNode(ISD::SUB, dl, VT, Tmp2, Tmp1);
3644 SDVTList VTs = DAG.getVTList(VT, VT);
3648 Tmp1 = DAG.getNode(DivRemOpc, dl, VTs, Node->getOperand(0),
3668 SDVTList VTs = DAG.getVTList(VT, VT);
3671 Tmp1 = DAG.getNode(ExpandOpcode, dl, VTs, Node->getOperand(0),
3683 SDVTList VTs = DAG.getVTList(VT, VT);
3704 Results.push_back(DAG.getNode(OpToUse, dl, VTs, Node->getOperand(0),
3710 EVT HalfType = VT.getHalfSizedIntegerVT(*DAG.getContext());
3715 TLI.expandMUL(Node, Lo, Hi, HalfType, DAG)) {
3716 Lo = DAG.getNode(ISD::ZERO_EXTEND, dl, VT, Lo);
3717 Hi = DAG.getNode(ISD::ANY_EXTEND, dl, VT, Hi);
3718 SDValue Shift = DAG.getConstant(HalfType.getSizeInBits(),
3720 Hi = DAG.getNode(ISD::SHL, dl, VT, Hi, Shift);
3721 Results.push_back(DAG.getNode(ISD::OR, dl, VT, Lo, Hi));
3736 SDValue Sum = DAG.getNode(Node->getOpcode() == ISD::SADDO ?
3743 SDValue Zero = DAG.getConstant(0, LHS.getValueType());
3754 SDValue LHSSign = DAG.getSetCC(dl, OType, LHS, Zero, ISD::SETGE);
3755 SDValue RHSSign = DAG.getSetCC(dl, OType, RHS, Zero, ISD::SETGE);
3756 SDValue SignsMatch = DAG.getSetCC(dl, OType, LHSSign, RHSSign,
3760 SDValue SumSign = DAG.getSetCC(dl, OType, Sum, Zero, ISD::SETGE);
3761 SDValue SumSignNE = DAG.getSetCC(dl, OType, LHSSign, SumSign, ISD::SETNE);
3763 SDValue Cmp = DAG.getNode(ISD::AND, dl, OType, SignsMatch, SumSignNE);
3764 Results.push_back(DAG.getBoolExtOrTrunc(Cmp, dl, ResultType, ResultType));
3771 SDValue Sum = DAG.getNode(Node->getOpcode() == ISD::UADDO ?
3780 SDValue SetCC = DAG.getSetCC(dl, SetCCType, Sum, LHS, CC);
3782 Results.push_back(DAG.getBoolExtOrTrunc(SetCC, dl, ResultType, ResultType));
3788 EVT WideVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits() * 2);
3798 BottomHalf = DAG.getNode(ISD::MUL, dl, VT, LHS, RHS);
3799 TopHalf = DAG.getNode(Ops[isSigned][0], dl, VT, LHS, RHS);
3801 BottomHalf = DAG.getNode(Ops[isSigned][1], dl, DAG.getVTList(VT, VT), LHS,
3805 LHS = DAG.getNode(Ops[isSigned][2], dl, WideVT, LHS);
3806 RHS = DAG.getNode(Ops[isSigned][2], dl, WideVT, RHS);
3807 Tmp1 = DAG.getNode(ISD::MUL, dl, WideVT, LHS, RHS);
3808 BottomHalf = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VT, Tmp1,
3809 DAG.getIntPtrConstant(0));
3810 TopHalf = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VT, Tmp1,
3811 DAG.getIntPtrConstant(1));
3831 SDValue HiLHS = DAG.getNode(ISD::SRA, dl, VT, RHS,
3832 DAG.getConstant(LoSize-1, TLI.getPointerTy()));
3833 SDValue HiRHS = DAG.getNode(ISD::SRA, dl, VT, LHS,
3834 DAG.getConstant(LoSize-1, TLI.getPointerTy()));
3842 BottomHalf = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VT, Ret,
3843 DAG.getIntPtrConstant(0));
3844 TopHalf = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VT, Ret,
3845 DAG.getIntPtrConstant(1));
3849 DAG.DeleteNode(Ret.getNode());
3853 Tmp1 = DAG.getConstant(VT.getSizeInBits() - 1,
3855 Tmp1 = DAG.getNode(ISD::SRA, dl, VT, BottomHalf, Tmp1);
3856 TopHalf = DAG.getSetCC(dl, getSetCCResultType(VT), TopHalf, Tmp1,
3859 TopHalf = DAG.getSetCC(dl, getSetCCResultType(VT), TopHalf,
3860 DAG.getConstant(0, VT), ISD::SETNE);
3868 Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, dl, PairTy, Node->getOperand(0));
3869 Tmp2 = DAG.getNode(ISD::ANY_EXTEND, dl, PairTy, Node->getOperand(1));
3870 Tmp2 = DAG.getNode(ISD::SHL, dl, PairTy, Tmp2,
3871 DAG.getConstant(PairTy.getSizeInBits()/2,
3873 Results.push_back(DAG.getNode(ISD::OR, dl, PairTy, Tmp1, Tmp2));
3881 Tmp1 = DAG.getSelectCC(dl, Tmp1.getOperand(0), Tmp1.getOperand(1),
3885 Tmp1 = DAG.getSelectCC(dl, Tmp1,
3886 DAG.getConstant(0, Tmp1.getValueType()),
3900 DAG.getMachineFunction().getJumpTableInfo()->getEntrySize(TD);
3902 Index = DAG.getNode(ISD::MUL, dl, Index.getValueType(),
3903 Index, DAG.getConstant(EntrySize, Index.getValueType()));
3904 SDValue Addr = DAG.getNode(ISD::ADD, dl, Index.getValueType(),
3907 EVT MemVT = EVT::getIntegerVT(*DAG.getContext(), EntrySize * 8);
3908 SDValue LD = DAG.getExtLoad(ISD::SEXTLOAD, dl, PTy, Chain, Addr,
3916 Addr = DAG.getNode(ISD::ADD, dl, PTy, Addr,
3917 TLI.getPICJumpTableRelocBase(Table, DAG));
3919 Tmp1 = DAG.getNode(ISD::BRIND, dl, MVT::Other, LD.getValue(1), Addr);
3929 Tmp1 = DAG.getNode(ISD::BR_CC, dl, MVT::Other,
3936 DAG.getNode(ISD::AND, dl, Tmp2.getValueType(), Tmp2,
3937 DAG.getConstant(1, Tmp2.getValueType()));
3938 Tmp1 = DAG.getNode(ISD::BR_CC, dl, MVT::Other, Tmp1,
3939 DAG.getCondCode(ISD::SETNE), Tmp3,
3940 DAG.getConstant(0, Tmp3.getValueType()),
3956 Tmp1 = DAG.getNode(ISD::SETCC, dl, Node->getValueType(0),
3962 Tmp1 = DAG.getLogicalNOT(dl, Tmp1, Tmp1->getValueType(0));
3981 Tmp1 = DAG.getNode(ISD::SELECT_CC, dl, VT, Tmp1, Tmp2,
3982 DAG.getConstant(TrueValue, VT), DAG.getConstant(0, VT),
4003 EVT CCVT = TLI.getSetCCResultType(*DAG.getContext(), CmpVT);
4004 SDValue Cond = DAG.getNode(ISD::SETCC, dl, CCVT, Tmp1, Tmp2, CC);
4005 Results.push_back(DAG.getSelect(dl, VT, Cond, Tmp3, Tmp4));
4019 Tmp1 = DAG.getSelectCC(dl, Tmp1, Tmp2, Tmp4, Tmp3, InvCC);
4028 Tmp1 = DAG.getSelectCC(dl, Tmp2, Tmp1, Tmp4, Tmp3, SwapInvCC);
4047 Tmp1 = DAG.getNode(ISD::SELECT_CC, dl, Node->getValueType(0),
4050 Tmp2 = DAG.getConstant(0, Tmp1.getValueType());
4051 CC = DAG.getCondCode(ISD::SETNE);
4052 Tmp1 = DAG.getNode(ISD::SELECT_CC, dl, Node->getValueType(0), Tmp1,
4073 Tmp4 = DAG.getNOT(dl, Tmp4, Tmp4->getValueType(0));
4078 Tmp1 = DAG.getNode(ISD::BR_CC, dl, Node->getValueType(0), Tmp1,
4081 Tmp3 = DAG.getConstant(0, Tmp2.getValueType());
4082 Tmp4 = DAG.getCondCode(ISD::SETNE);
4083 Tmp1 = DAG.getNode(ISD::BR_CC, dl, Node->getValueType(0), Tmp1, Tmp4,
4103 SDValue Ex = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
4105 Node->getOperand(0), DAG.getConstant(Idx,
4107 SDValue Sh = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
4109 Node->getOperand(1), DAG.getConstant(Idx,
4111 Scalars.push_back(DAG.getNode(Node->getOpcode(), dl,
4115 DAG.getNode(ISD::BUILD_VECTOR, dl, Node->getValueType(0), Scalars);
4155 Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Node->getOperand(0));
4158 Tmp1 = DAG.getNode(Node->getOpcode(), dl, NVT, Tmp1);
4161 Tmp2 = DAG.getSetCC(dl, getSetCCResultType(NVT),
4162 Tmp1, DAG.getConstant(NVT.getSizeInBits(), NVT),
4164 Tmp1 = DAG.getSelect(dl, NVT, Tmp2,
4165 DAG.getConstant(OVT.getSizeInBits(), NVT), Tmp1);
4169 Tmp1 = DAG.getNode(ISD::SUB, dl, NVT, Tmp1,
4170 DAG.getConstant(NVT.getSizeInBits() -
4173 Results.push_back(DAG.getNode(ISD::TRUNCATE, dl, OVT, Tmp1));
4177 Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Node->getOperand(0));
4178 Tmp1 = DAG.getNode(ISD::BSWAP, dl, NVT, Tmp1);
4179 Tmp1 = DAG.getNode(ISD::SRL, dl, NVT, Tmp1,
4180 DAG.getConstant(DiffBits, TLI.getShiftAmountTy(NVT)));
4210 Tmp1 = DAG.getVAArg(NVT, dl, Chain, Ptr, Node->getOperand(2),
4214 Tmp2 = DAG.getNode(TruncOp, dl, OVT, Tmp1);
4218 DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 0), Tmp2);
4219 DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 1), Chain);
4236 Tmp1 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(0));
4237 Tmp2 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(1));
4239 Tmp1 = DAG.getNode(Node->getOpcode(), dl, NVT, Tmp1, Tmp2);
4240 Results.push_back(DAG.getNode(TruncOp, dl, OVT, Tmp1));
4258 Tmp2 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(1));
4259 Tmp3 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(2));
4261 Tmp1 = DAG.getSelect(dl, NVT, Tmp1, Tmp2, Tmp3);
4263 Tmp1 = DAG.getNode(TruncOp, dl, Node->getValueType(0), Tmp1);
4265 Tmp1 = DAG.getNode(TruncOp, dl, Node->getValueType(0), Tmp1,
4266 DAG.getIntPtrConstant(0));
4274 Tmp1 = DAG.getNode(ISD::BITCAST, dl, NVT, Node->getOperand(0));
4275 Tmp2 = DAG.getNode(ISD::BITCAST, dl, NVT, Node->getOperand(1));
4279 Tmp1 = DAG.getNode(ISD::BITCAST, dl, OVT, Tmp1);
4290 Tmp1 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(0));
4291 Tmp2 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(1));
4292 Results.push_back(DAG.getNode(ISD::SETCC, dl, Node->getValueType(0),
4299 Tmp1 = DAG.getNode(ISD::FP_EXTEND, dl, NVT, Node->getOperand(0));
4300 Tmp2 = DAG
4301 Tmp3 = DAG.getNode(Node->getOpcode(), dl, NVT, Tmp1, Tmp2);
4302 Results.push_back(DAG.getNode(ISD::FP_ROUND, dl, OVT,
4303 Tmp3, DAG.getIntPtrConstant(0)));
4310 Tmp1 = DAG.getNode(ISD::FP_EXTEND, dl, NVT, Node->getOperand(0));
4311 Tmp2 = DAG.getNode(Node->getOpcode(), dl, NVT, Tmp1);
4312 Results.push_back(DAG.getNode(ISD::FP_ROUND, dl, OVT,
4313 Tmp2, DAG.getIntPtrConstant(0)));
