reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

gen/lib/Target/ARM/ARMGenDAGISel.inc

54211   return !SDValue(N,0)->getValueType(0).isVector() &&

gen/lib/Target/Mips/MipsGenDAGISel.inc

30126   if (N->getValueType(0) == MVT::i64) {
30139   if (N->getValueType(0) == MVT::i64) {
30152   if (N->getValueType(0) == MVT::i32) {
30179   if (N->getValueType(0) == MVT::i32)
30281   EVT EltTy = N->getValueType(0).getVectorElementType();
30309   EVT EltTy = N->getValueType(0).getVectorElementType();
30322   EVT EltTy = N->getValueType(0).getVectorElementType();

gen/lib/Target/PowerPC/PPCGenDAGISel.inc

44323   if (N->getValueType(0) == MVT::i32)
44440   if (N->getValueType(0) == MVT::i32)

gen/lib/Target/RISCV/RISCVGenDAGISel.inc

14190                                    SDLoc(N), N->getValueType(0));
14197                                    SDLoc(N), N->getValueType(0));

gen/lib/Target/SystemZ/SystemZGenDAGISel.inc

30118   unsigned BitWidth = N->getValueType(0).getScalarSizeInBits();
30128   unsigned BitWidth = N->getValueType(0).getScalarSizeInBits();

gen/lib/Target/X86/X86GenDAGISel.inc

254517   return Ld->getAlignment() >= Ld->getValueType(0).getStoreSize();

include/llvm/CodeGen/SelectionDAGNodes.h

 1021     return getValueType(ResNo).getSimpleVT();
 1026     return getValueType(ResNo).getSizeInBits();
 1163   return Node->getValueType(ResNo);
 1528     EVT VT = getValueType(0);
 1533     assert(Idx < getValueType(0).getVectorNumElements() && "Idx out of range!");
 1537   bool isSplat() const { return isSplatMask(Mask, getValueType(0)); }
 1541     EVT VT = getValueType(0);

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

  998             N->getValueType(i) == To[i].getValueType()) &&
 1088   EVT VT = Load->getValueType(0);
 1467       assert(N->getValueType(0) == RV.getValueType() &&
 2385   EVT VT = V.getNode()->getValueType(0);
 2593   EVT CarryVT = N->getValueType(1);
 2692         TLI.isOperationLegalOrCustom(ISD::UADDO, N->getValueType(0)))
 3233   EVT CarryVT = N->getValueType(1);
 3286         TLI.isOperationLegalOrCustom(ISD::USUBO, N->getValueType(0)))
 3491   EVT NodeType = Node->getValueType(0);
 3516   EVT VT = Node->getValueType(0);
 3580   EVT VT = N->getValueType(0);
 3626   EVT VT = N->getValueType(0);
 3679   if (!N1C || TLI.isIntDivCheap(N->getValueType(0), Attr))
 3688   EVT VT = N->getValueType(0);
 3760       !TLI.isIntDivCheap(N->getValueType(0), Attr))
 3770   EVT VT = N->getValueType(0);
 3817   if (!N1C || TLI.isIntDivCheap(N->getValueType(0), Attr))
 3826   EVT VT = N->getValueType(0);
 3860       !TLI.isIntDivCheap(N->getValueType(0), Attr))
 3872   EVT VT = N->getValueType(0);
 3953   EVT VT = N->getValueType(0);
 4000   EVT VT = N->getValueType(0);
 4061                     TLI.isOperationLegalOrCustom(LoOp, N->getValueType(0)))) {
 4062     SDValue Res = DAG.getNode(LoOp, SDLoc(N), N->getValueType(0), N->ops());
 4069                     TLI.isOperationLegalOrCustom(HiOp, N->getValueType(1)))) {
 4070     SDValue Res = DAG.getNode(HiOp, SDLoc(N), N->getValueType(1), N->ops());
 4080     SDValue Lo = DAG.getNode(LoOp, SDLoc(N), N->getValueType(0), N->ops());
 4090     SDValue Hi = DAG.getNode(HiOp, SDLoc(N), N->getValueType(1), N->ops());
 4106   EVT VT = N->getValueType(0);
 4137   EVT VT = N->getValueType(0);
 4182   EVT CarryVT = N->getValueType(1);
 4736         !TLI.isLoadExtLegal(ExtType, Load->getValueType(0), MemVT))
 4796       if (isAndLoadExtLoad(Mask, Load, Load->getValueType(0), ExtVT) &&
 4886                                 FixupNode->getValueType(0),
 4910       SDValue And = DAG.getNode(ISD::AND, SDLoc(Load), Load->getValueType(0),
 4971   EVT VT = N->getValueType(0);
 4988   EVT VT = And->getValueType(0);
 5157         unsigned EltBitWidth = Vector->getValueType(0).getScalarSizeInBits();
 5181                                                     Load->getValueType(0),
 5207                               Load->getValueType(0), SDLoc(Load),
 5330   EVT VT = N->getValueType(0);
 5554   EVT VT = N->getValueType(0);
 6653   EVT VT = N->getValueType(0);
 6794   EVT VT = N->getValueType(0);
 7115   EVT VT = Shift->getValueType(0);
 7190   EVT VT = N->getValueType(0);
 7205   EVT TruncVT = N->getValueType(0);
 7227   EVT VT = N->getValueType(0);
 7263     if (C1 && C2 && C1->getValueType(0) == C2->getValueType(0)) {
 7263     if (C1 && C2 && C1->getValueType(0) == C2->getValueType(0)) {
 7264       EVT ShiftVT = C1->getValueType(0);
 7639                            N->getValueType(0), Trunc);
 7937   EVT VT = N->getValueType(0);
 8013   EVT VT = N->getValueType(0);
 8029   EVT VT = N->getValueType(0);
 8042   EVT VT = N->getValueType(0);
 8055   EVT VT = N->getValueType(0);
 8072   EVT VT = N->getValueType(0);
 8082   EVT VT = N->getValueType(0);
 8099   EVT VT = N->getValueType(0);
 8109   EVT VT = N->getValueType(0);
 8187   EVT VT = N->getValueType(0);
 8219   EVT VT = N->getValueType(0);
 8327   EVT VT = N->getValueType(0);
 8517   EVT VT = N->getValueType(0);
 8621   EVT VT = N->getValueType(0);
 8682   EVT VT = N->getValueType(0);
 8845       N->getValueType(0), N->getOperand(0), N->getOperand(1),
 8890   EVT VT = N->getValueType(0);
 8940   unsigned EVTBits = N0->getValueType(0).getScalarSizeInBits();
 9046         Ops.push_back(DAG.getNode(ExtType, DL, ExtLoad->getValueType(0), SOp));
 9050     CombineTo(SetCC, DAG.getNode(ISD::SETCC, DL, SetCC->getValueType(0), Ops));
 9057   EVT DstVT = N->getValueType(0);
 9158   EVT VT = N->getValueType(0);
 9222                                 Load->getValueType(0), ExtLoad);
 9246   EVT VT = Cast->getValueType(0);
 9362   if (!TLI.isLoadExtLegal(ExtLoadType, VT, Ld->getValueType(0)))
 9392   EVT VT = N->getValueType(0);
 9412   EVT VT = N->getValueType(0);
 9531                                       LN00->getValueType(0), ExtLoad);
 9687   EVT VT = Extend->getValueType(0);
 9701   EVT VT = N->getValueType(0);
 9823           EVT LoadResultTy = AndC->getValueType(0);
 9856                                       LN00->getValueType(0), ExtLoad);
 9957   EVT VT = N->getValueType(0);
10133     return DAG.getNode(ISD::TRUNCATE, DL, N->getValueType(0), NewAssert);
10152       return DAG.getNode(ISD::TRUNCATE, DL, N->getValueType(0), NewAssert);
10170   EVT VT = N->getValueType(0);
10374   EVT VT = N->getValueType(0);
10507   EVT VT = N->getValueType(0);
10523   EVT VT = N->getValueType(0);
10539   EVT VT = N->getValueType(0);
10591     EVT TrTy = N->getValueType(0);
10798     auto VTs = DAG.getVTList(VT, N0->getValueType(1));
10811       if (N00.getOperand(0)->getValueType(0).getVectorElementType() ==
10874   EVT LD1VT = LD1->getValueType(0);
10901   EVT VT = N->getValueType(0);
10952   EVT VT = N->getValueType(0);
11199   EVT VT = N->getValueType(0);
11207   EVT SrcEltVT = BV->getValueType(0).getVectorElementType();
11228                               BV->getValueType(0).getVectorNumElements());
11327   EVT VT = N->getValueType(0);
11539   EVT VT = N->getValueType(0);
11830   EVT VT = N->getValueType(0);
11924   EVT VT = N->getValueType(0);
12103   EVT VT = N->getValueType(0);
12195   EVT VT = N->getValueType(0);
12330   EVT VT = N->getValueType(0);
12469   EVT VT = N->getValueType(0);
12518   EVT VT = N->getValueType(0);
12622   EVT VT = N->getValueType(0);
12658     EVT N1VT = N1->getValueType(0);
12670   EVT VT = N->getValueType(0);
12721   EVT VT = N->getValueType(0);
12804   EVT VT = N->getValueType(0);
12825   EVT VT = N->getValueType(0);
12886   EVT VT = N->getValueType(0);
12933   EVT VT = N->getValueType(0);
12974   EVT VT = N->getValueType(0);
12989   EVT VT = N->getValueType(0);
13006   EVT VT = N->getValueType(0);
13060   EVT VT = N->getValueType(0);
13113   EVT VT = N->getValueType(0);
13124   EVT VT = N->getValueType(0);
13148   EVT VT = N->getValueType(0);
13160   EVT VT = N->getValueType(0);
13219   EVT VT = N->getValueType(0);
13255   EVT VT = N->getValueType(0);
13289       return DAG.getBitcast(N->getValueType(0), Int);
13710     SDValue NewOp1 = DAG.getConstant(CNV, DL, CN->getValueType(0));
13715                                  OtherUses[i]->getValueType(0), NewOp1, NewOp2);
13869                           ConstInc->getValueType(0));
13908   EVT LDType = LD->getValueType(0);
13941   EVT LDType = LD->getValueType(0);
14039     if (N->getValueType(1) == MVT::Other) {
14061       assert(N->getValueType(2) == MVT::Other && "Malformed indexed loads?");
14072         SDValue Undef = DAG.getUNDEF(N->getValueType(0));
14080           Index = DAG.getUNDEF(N->getValueType(1));
14104             LD->getExtensionType(), SDLoc(N), LD->getValueType(0), Chain, Ptr,
14124         ReplLoad = DAG.getLoad(N->getValueType(0), SDLoc(LD),
14128                                   LD->getValueType(0),
14186       EVT TruncType = LS.Inst->getValueType(0);
14201                               LS.Inst->getValueType(0)))
14346     EVT TruncateType = Inst->getValueType(0);
14406     EVT FinalType = Inst->getValueType(0);
14425     EVT ResVT = Use->getValueType(0);
14455     if (Inst->getValueType(0) != getLoadedType())
14610       !LD->getValueType(0).isInteger())
16678   EVT ResultVT = EVE->getValueType(0);
16785     EVT VT = ExtElt->getValueType(0);
16797   EVT ScalarVT = N->getValueType(0);
17066   EVT VT = N->getValueType(0);
17173   EVT VT = N->getValueType(0);
17308   EVT VT = BV->getValueType(0);
17364   EVT VT = N->getValueType(0);
17581   EVT VT = N->getValueType(0);
17625   EVT VT = N->getValueType(0);
17684         (Op0.getOperand(0).getValueType() == N->getValueType(0)))
17687         ((Offset % N->getValueType(0).getVectorNumElements()) ==
17689       return DAG.getNode(ISD::EXTRACT_SUBVECTOR, SDLoc(N), N->getValueType(0),
17714   EVT VT = N->getValueType(0);
17771   EVT VT = N->getValueType(0);
17848   EVT VT = N->getValueType(0);
17996       if (SingleSource.getValueType() != N->getValueType(0))
18048   EVT SubVT = Extract->getValueType(0);
18095   EVT VT = Extract->getValueType(0);
18201   EVT VT = Extract->getValueType(0);
18223   EVT NVT = N->getValueType(0);
18376   EVT VT = Shuf->getValueType(0);
18411   EVT VT = N->getValueType(0);
18492   EVT VT = SVN->getValueType(0);
18574   EVT VT = SVN->getValueType(0);
18629   EVT VT = SVN->getValueType(0);
18733   return DAG.getVectorShuffle(Splat->getValueType(0), SDLoc(Splat),
18845   EVT VT = N->getValueType(0);
18956       SDValue NewBV = DAG.getBuildVector(V->getValueType(0), SDLoc(N), Ops);
18960       if (V->getValueType(0) != VT)
19018       EVT InnerVT = BC0->getValueType(0);
19193   EVT VT = N->getValueType(0);
19243   EVT VT = N->getValueType(0);
19403       return DAG.getNode(ISD::FP16_TO_FP, SDLoc(N), N->getValueType(0),
19422     if (Res.getValueType() != N->getValueType(0))
19423       Res = DAG.getNode(ISD::ANY_EXTEND, dl, N->getValueType(0), Res);
19435       return DAG.getNode(NewOpcode, SDLoc(N), N->getValueType(0), N0);
19448   EVT VT = N->getValueType(0);
19538   EVT VT = N->getValueType(0);
19581   assert(N->getValueType(0).isVector() &&
19587   EVT VT = N->getValueType(0);
19878       Load = DAG.getLoad(TheSelect->getValueType(0), SDLoc(TheSelect),
19886           SDLoc(TheSelect), TheSelect->getValueType(0), LLD->getChain(), Addr,
19990       TLI.isFPImmLegal(TV->getValueAPF(), TV->getValueType(0), ForCodeSize) ||
19991       TLI.isFPImmLegal(FV->getValueAPF(), FV->getValueType(0), ForCodeSize))
20022   return DAG.getLoad(TV->getValueType(0), DL, DAG.getEntryNode(), CPIdx,
20069       N0->getValueType(0) == VT && isNullConstant(N1) && isNullConstant(N2) &&

lib/CodeGen/SelectionDAG/InstrEmitter.cpp

   46   while (N && Node->getValueType(N - 1) == MVT::Glue)
   48   if (N && Node->getValueType(N - 1) == MVT::Other)
  944   if (Node->getValueType(Node->getNumValues()-1) == MVT::Glue) {

lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

  299   EVT VT = CFP->getValueType(0);
  348   EVT VT = CP->getValueType(0);
  439     if (CFP->getValueType(0) == MVT::f32 &&
  448     if (CFP->getValueType(0) == MVT::f64) {
  737        TLI.getLoadExtAction(ExtType, Node->getValueType(0), MVT::i1) ==
  752         DAG.getExtLoad(NewExtType, dl, Node->getValueType(0), Chain, Ptr,
  790       Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, Node->getValueType(0), Chain, Ptr,
  799       Hi = DAG.getExtLoad(ExtType, dl, Node->getValueType(0), Chain, Ptr,
  816       Value = DAG.getNode(ISD::OR, dl, Node->getValueType(0), Lo, Hi);
  821       Hi = DAG.getExtLoad(ExtType, dl, Node->getValueType(0), Chain, Ptr,
  830       Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, Node->getValueType(0), Chain, Ptr,
  847       Value = DAG.getNode(ISD::OR, dl, Node->getValueType(0), Lo, Hi);
  853     switch (TLI.getLoadExtAction(ExtType, Node->getValueType(0),
  881       EVT DestVT = Node->getValueType(0);
  897           Value = DAG.getNode(ExtendOp, dl, Node->getValueType(0), Load);
  931                                       Node->getValueType(0),
  973     assert(TLI.getTypeAction(*DAG.getContext(), Node->getValueType(i)) ==
  997                                     Node->getValueType(0));
 1001                                     Node->getValueType(0));
 1038                                         Node->getValueType(0));
 1068     Action = TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0));
 1080     Action = TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0));
 1097     Action = TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0));
 1122     Action = TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0));
 1131                                               Node->getValueType(0), Scale);
 1162       Action = TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0));
 1391   EVT VT = Node->getValueType(0);
 1585   EVT VT = Node->getValueType(0);
 1788   SDValue StackPtr = DAG.CreateStackTemporary(Node->getValueType(0));
 1796       Node->getValueType(0).getVectorElementType());
 1798       Node->getValueType(0), dl, Ch, StackPtr,
 1807   EVT VT = Node->getValueType(0);
 1902   EVT VT = Node->getValueType(0);
 1987       if (TLI.isShuffleMaskLegal(ShuffleVec, Node->getValueType(0))) {
 2012   EVT VT = Node->getValueType(0);
 2038   EVT RetVT = Node->getValueType(0);
 2102   Type *RetTy = Node->getValueType(0).getTypeForEVT(*DAG.getContext());
 2202   EVT RetVT = Node->getValueType(0);
 2297   EVT RetVT = Node->getValueType(0);
 2687     Results.push_back(DAG.getConstant(0, dl, Node->getValueType(0)));
 2705     Results.push_back(DAG.getConstant(1, dl, Node->getValueType(0)));
 2720                    DAG.getConstant(0, dl, Node->getValueType(0)));
 2731     SDValue Zero = DAG.getConstant(0, dl, Node->getValueType(0));
 2732     SDVTList VTs = DAG.getVTList(Node->getValueType(0), MVT::Other);
 2755     SDVTList VTs = DAG.getVTList(Node->getValueType(0), MVT::Other);
 2766     EVT OuterType = Node->getValueType(0);
 2790         DAG.getSetCC(dl, Node->getValueType(1), LHS, RHS, ISD::SETEQ);
 2805     EVT VT = Node->getValueType(0);
 2818                                        Node->getValueType(0))
 2822                             Node->getValueType(0),
 2823                             Node->getValueType(0), dl, Node->getOperand(0));
 2830                             Node->getValueType(0),
 2831                             Node->getValueType(0), dl);
 2838                                        Node->getValueType(0))
 2843                             Node->getValueType(0), dl, Node->getOperand(0));
 2850                             Node->getValueType(0), dl);
 2855     EVT VT = Node->getValueType(0);
 2879     Tmp1 = DAG.getNode(ISD::SHL, dl, Node->getValueType(0),
 2881     Tmp1 = DAG.getNode(ISD::SRA, dl, Node->getValueType(0), Tmp1, ShiftCst);
 2893                                 Node->getOperand(0), Node->getValueType(0), dl);
 2931       Tmp1 = DAG.getNode(ISD::BITCAST, dl, Node->getValueType(0),
 2958     EVT VT = Node->getValueType(0);
 3026     Tmp1 = DAG.getNode(ISD::BITCAST, dl, Node->getValueType(0), Tmp1);
 3039       Tmp1 = DAG.getNode(ISD::TRUNCATE, dl, Node->getValueType(0), Tmp1);
 3042       Tmp1 = DAG.getNode(ISD::TRUNCATE, dl, Node->getValueType(0),
 3053                                            Node->getValueType(0)));
 3056       Results.push_back(DAG.getUNDEF(Node->getValueType(0)));
 3071     Results.push_back(DAG.getConstant(0, dl, Node->getValueType(0)));
 3079     Tmp1 = DAG.getConstantFP(-0.0, dl, Node->getValueType(0));
 3081     Tmp1 = DAG.getNode(ISD::FSUB, dl, Node->getValueType(0), Tmp1,
 3115     EVT VT = Node->getValueType(0);
 3133     if (Node->getValueType(0) != MVT::f32) {
 3140           DAG.getNode(ISD::FP_EXTEND, dl, Node->getValueType(0), Res));
 3155             DAG.getNode(ISD::FP_TO_FP16, dl, Node->getValueType(0), FloatVal));
 3163     if (!TLI.isFPImmLegal(CFP->getValueAPF(), Node->getValueType(0),
 3174     EVT VT = Node->getValueType(0);
 3185     EVT VT = Node->getValueType(0);
 3198     EVT VT = Node->getValueType(0);
 3221     EVT VT = Node->getValueType(0);
 3234     EVT VT = Node->getValueType(0);
 3276     EVT VT = Node->getValueType(0);
 3357     EVT CarryType = Node->getValueType(1);
 3358     EVT SetCCType = getSetCCResultType(Node->getValueType(0));
 3411     EVT PairTy = Node->getValueType(0);
 3510     bool Legalized = LegalizeSetCCCondCode(Node->getValueType(0), Tmp1, Tmp2,
 3517         Tmp1 = DAG.getNode(ISD::SETCC, dl, Node->getValueType(0),
 3523         Tmp1 = DAG.getLogicalNOT(dl, Tmp1, Tmp1->getValueType(0));
 3531     EVT VT = Node->getValueType(0);
 3555     EVT VT = Node->getValueType(0);
 3612         Tmp1 = DAG.getNode(ISD::SELECT_CC, dl, Node->getValueType(0),
 3617         Tmp1 = DAG.getNode(ISD::SELECT_CC, dl, Node->getValueType(0), Tmp1,
 3641       Tmp1 = DAG.getNode(ISD::BR_CC, dl, Node->getValueType(0), Tmp1,
 3646       Tmp1 = DAG.getNode(ISD::BR_CC, dl, Node->getValueType(0), Tmp1, Tmp4,
 3662     EVT VT = Node->getValueType(0);
 3679     SDValue Result = DAG.getBuildVector(Node->getValueType(0), dl, Scalars);
 3720                                          Node->getValueType(0))
 4035     if (Node->getValueType(0) == MVT::f32) {
 4181     Tmp1 = PromoteLegalFP_TO_INT(Node->getOperand(0), Node->getValueType(0),
 4187     Tmp1 = PromoteLegalINT_TO_FP(Node->getOperand(0), Node->getValueType(0),
 4280     if (Node->getValueType(0).isVector() ||
 4281         Node->getValueType(0).getSizeInBits() == NVT.getSizeInBits()) {
 4284     } else if (Node->getValueType(0).isInteger()) {
 4299       Tmp1 = DAG.getNode(TruncOp, dl, Node->getValueType(0), Tmp1);
 4301       Tmp1 = DAG.getNode(TruncOp, dl, Node->getValueType(0), Tmp1,
 4328     Results.push_back(DAG.getNode(ISD::SETCC, dl, Node->getValueType(0), Tmp1,
 4341     Results.push_back(DAG.getNode(ISD::BR_CC, dl, Node->getValueType(0),

lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp

  129                                               N->getValueType(0)),
  144       CN->getValueType(0).getSimpleVT() == llvm::MVT::ppcf128) {
  150                                                     CN->getValueType(0)));
  154                                                     CN->getValueType(0)));
  166   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  178   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  184   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  185   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  195   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  201   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  202   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  212   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  218   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  219   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  229   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  233   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  234   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  244   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  248   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  249   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  307   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  311   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  312   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  322   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  328   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  329   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  339   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  343   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  344   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  354   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  358   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  359   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  369   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  373   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  374   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  384   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  388   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  389   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  399   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  403   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  404   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  414   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  418   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  419   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  429   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  437   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  438   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  448   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  454   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  455   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  465   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  469   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  470   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  480   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  483   EVT FloatVT = N->getValueType(0);
  492   SDValue Ops[2] = { DAG.getConstantFP(-0.0, dl, N->getValueType(0)),
  495   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  505   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  511   if (Op.getValueType() == MVT::f16 && N->getValueType(0) != MVT::f32) {
  521     if (Op.getValueType() == N->getValueType(0)) {
  526   RTLIB::Libcall LC = RTLIB::getFPEXT(Op.getValueType(), N->getValueType(0));
  530   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  541   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  544   if (N->getValueType(0) == MVT::f32)
  547   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  548   RTLIB::Libcall LC = RTLIB::getFPEXT(MVT::f32, N->getValueType(0));
  554   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  556   if (N->getValueType(0) == MVT::f16) {
  562   RTLIB::Libcall LC = RTLIB::getFPROUND(Op.getValueType(), N->getValueType(0));
  566   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  571   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  577   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  578   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  590   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  595   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  596   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  606   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  612   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  613   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  623   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  627   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  628   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  638   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  642   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  643   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  653   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  657   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  658   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  668   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  672   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  673   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  683   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  689   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  690   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  700   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  701   if (N->getValueType(0) == MVT::f16)
  707   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  708   return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
  719   EVT VT = N->getValueType(0);
  768                                                N->getValueType(0)));
  774   EVT VT = N->getValueType(0);
  792   EVT RVT = N->getValueType(0);
  815   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  863   assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 1 &&
  873   return DAG.getNode(ISD::BITCAST, SDLoc(N), N->getValueType(0), Op0);
  879   EVT RVT = N->getValueType(0);
  890   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  901   EVT RVT = N->getValueType(0);
  910   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
  941   EVT RVT = N->getValueType(0);
  963   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
 1006     assert(NewLHS.getValueType() == N->getValueType(0) &&
 1036   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 1042   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
 1053   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 1059   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
 1070   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 1076   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
 1087   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 1093   CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
 1117   if (CustomLowerNode(N, N->getValueType(ResNo), true))
 1181   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 1196   assert(N->getValueType(0) == MVT::ppcf128 &&
 1210   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 1220   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 1230   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 1240   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0), RTLIB::CBRT_F32,
 1249   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 1259   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 1271   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 1283   SDValue Call = TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
 1289                                  N->getValueType(0), Ops, CallOptions,
 1296   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 1306   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 1316   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 1326   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 1336   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 1346   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 1358   SDValue Call = TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
 1364                                  N->getValueType(0), Ops, CallOptions,
 1373   SDValue Call = TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
 1379                                  N->getValueType(0), Ops, CallOptions,
 1386   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 1406   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 1415   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 1425   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 1435   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 1445   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 1455   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 1467   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 1477   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 1489   SDValue Call = TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
 1495                                  N->getValueType(0), Ops, CallOptions,
 1502   SDValue Call = LibCallify(GetFPLibCall(N->getValueType(0),
 1523   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), LD->getValueType(0));
 1544   assert(N->getValueType(0) == MVT::ppcf128 && "Unsupported XINT_TO_FP!");
 1545   EVT VT = N->getValueType(0);
 1669   assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 1 &&
 1734                      N->getValueType(0), N->getOperand(0), Hi);
 1744                      N->getValueType(0), Hi, N->getOperand(1));
 1748   EVT RVT = N->getValueType(0);
 1758   EVT RVT = N->getValueType(0);
 1764   return TLI.makeLibCall(DAG, LC, N->getValueType(0), N->getOperand(0),
 1793     assert(NewLHS.getValueType() == N->getValueType(0) &&
 1828   EVT RVT = N->getValueType(0);
 1841   EVT RVT = N->getValueType(0);
 1854   EVT RVT = N->getValueType(0);
 1867   EVT RVT = N->getValueType(0);
 1934   EVT OpVT = Op->getValueType(0);
 1937   EVT PromotedVT = Promoted->getValueType(0);
 1945   return DAG.getBitcast(N->getValueType(0), Convert);
 1954   return DAG.getNode(N->getOpcode(), SDLoc(N), N->getValueType(0),
 1961   return DAG.getNode(N->getOpcode(), SDLoc(N), N->getValueType(0), Op);
 1966   EVT VT = N->getValueType(0);
 1969   if (VT == Op->getValueType(0))
 1983   return DAG.getNode(ISD::SELECT_CC, SDLoc(N), N->getValueType(0),
 1991   EVT VT = N->getValueType(0);
 2030   if (CustomLowerNode(N, N->getValueType(ResNo), true)) {
 2111   EVT VT = N->getValueType(0);
 2123   EVT VT = N->getValueType(0);
 2150     EVT VecVT = Vec->getValueType(0);
 2196   EVT VT = N->getValueType(0);
 2205   EVT VT = N->getValueType(0);
 2218   EVT VT = N->getValueType(0);
 2229   EVT VT = N->getValueType(0);
 2237   EVT VT = N->getValueType(0);
 2248   EVT VT = N->getValueType(0);
 2262   EVT VT = N->getValueType(0);
 2263   EVT OpVT = Op->getValueType(0);
 2264   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 2275   EVT VT = N->getValueType(0);
 2299   return DAG.getNode(ISD::SELECT, SDLoc(N), TrueVal->getValueType(0),
 2310                      TrueVal.getNode()->getValueType(0), N->getOperand(0),
 2318   EVT VT = N->getValueType(0);
 2329                                                N->getValueType(0)));
 2333   EVT VT = N->getValueType(0);

lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp

   43   if (CustomLowerNode(N, N->getValueType(ResNo), true)) {
  224   EVT ResVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  252     EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(1));
  259     SDVTList VTs = DAG.getVTList(N->getValueType(0), SVT, MVT::Other);
  272       DAG.getVTList(Op2.getValueType(), N->getValueType(1), MVT::Other);
  286   EVT OutVT = N->getValueType(0);
  383   EVT OVT = N->getValueType(0);
  395   EVT OVT = N->getValueType(0);
  411                      N->getValueType(0)), JoinIntegers(N->getOperand(0),
  416   EVT VT = N->getValueType(0);
  433   EVT OVT = N->getValueType(0);
  451   EVT OVT = N->getValueType(0);
  467   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  491   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  529                      DAG.getValueType(N->getValueType(0).getScalarType()));
  533   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  540   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  547   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  576   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  590   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  604   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  625   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(1));
  626   EVT VT = N->getValueType(0);
  786   Ofl = DAG.getSetCC(dl, N->getValueType(1), Ofl, Res, ISD::SETNE);
  820   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  908   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  947                                    N->getValueType(0).getScalarType(), NumElem);
  986   Ofl = DAG.getSetCC(dl, N->getValueType(1), Ofl, Res, ISD::SETNE);
 1014   EVT ValueVTs[] = {LHS.getValueType(), N->getValueType(1)};
 1051   SDVTList VTs = DAG.getVTList(LHS.getValueType(), N->getValueType(1));
 1064     Overflow = DAG.getSetCC(DL, N->getValueType(1), Hi,
 1071     Overflow = DAG.getSetCC(DL, N->getValueType(1), SExt, Mul, ISD::SETNE);
 1076   Overflow = DAG.getNode(ISD::OR, DL, N->getValueType(1), Overflow,
 1086                                                N->getValueType(0)));
 1092   EVT VT = N->getValueType(0);
 1111   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 1234   assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 1 &&
 1293   return DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), N->getValueType(0), Op);
 1305   return CreateStackStoreLoad(N->getOperand(0), N->getValueType(0));
 1338   assert(Lo.getValueType() == N->getValueType(0) && "Operand over promoted?");
 1341   Hi = DAG.getNode(ISD::SHL, dl, N->getValueType(0), Hi,
 1344   return DAG.getNode(ISD::OR, dl, N->getValueType(0), Lo, Hi);
 1351   EVT VecVT = N->getValueType(0);
 1360          N->getValueType(0).getScalarSizeInBits() &&
 1378            N->getValueType(0).getScalarSizeInBits() &&
 1457   Op = DAG.getNode(ISD::ANY_EXTEND, dl, N->getValueType(0), Op);
 1508   EVT DataVT = N->getValueType(0);
 1521     EVT DataVT = N->getValueType(0);
 1557   return DAG.getNode(ISD::TRUNCATE, SDLoc(N), N->getValueType(0), Op);
 1568   Op = DAG.getNode(ISD::ANY_EXTEND, dl, N->getValueType(0), Op);
 1638   EVT VT = N->getValueType(0);
 1663   if (CustomLowerNode(N, N->getValueType(ResNo), true))
 1736     SDVTList VTs = DAG.getVTList(N->getValueType(0), MVT::Other);
 1745     SDValue Success = DAG.getSetCC(SDLoc(N), N->getValueType(1), Tmp,
 1840   unsigned VTBits = N->getValueType(0).getSizeInBits();
 1916   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 2003   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 2331     SDVTList VTList = DAG.getVTList(LHSL.getValueType(), N->getValueType(1));
 2348     Ovf = DAG.getSetCC(dl, N->getValueType(1), Sum, LHS, Cond);
 2363   SDVTList VTList = DAG.getVTList(LHSL.getValueType(), N->getValueType(1));
 2378   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 2392     assert(Res.getValueType() == N->getValueType(0) &&
 2459   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 2475   EVT VT = N->getValueType(0);
 2544   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 2557   EVT VT = N->getValueType(0);
 2574   EVT VT = N->getValueType(0);
 2608   EVT RetVT = N->getValueType(0);
 2636   EVT RetVT = N->getValueType(0);
 2652   EVT VT = N->getValueType(0);
 2769   EVT VT = N->getValueType(0);
 2851   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 2873   EVT VT = N->getValueType(0);
 3107   EVT OType = Node->getValueType(1);
 3127   EVT VT = N->getValueType(0);
 3155   EVT VT = N->getValueType(0);
 3261   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3279     assert(Res.getValueType() == N->getValueType(0) &&
 3318   EVT VT = N->getValueType(0);
 3346   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3358   EVT VT = N->getValueType(0);
 3379       , BitVT = N->getValueType(1);
 3467   SDValue Ofl = DAG.getSetCC(dl, N->getValueType(1), Temp2,
 3476   EVT VT = N->getValueType(0);
 3503   EVT VT = N->getValueType(0);
 3530   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3544     assert(Res.getValueType() == N->getValueType(0) &&
 3635   assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 1 &&
 3833     assert(NewLHS.getValueType() == N->getValueType(0) &&
 3857   return DAG.getNode(ISD::SETCCCARRY, dl, N->getValueType(0), LHSHi, RHSHi,
 3881   EVT DstVT = N->getValueType(0);
 3976   return DAG.getNode(ISD::TRUNCATE, SDLoc(N), N->getValueType(0), InL);
 3982   EVT DstVT = N->getValueType(0);
 4070   EVT OutVT = N->getValueType(0);
 4106   EVT VT = N->getValueType(0);
 4120   EVT OutVT = N->getValueType(0);
 4153   EVT OutVT = N->getValueType(0);
 4170   EVT OutVT = N->getValueType(0);
 4183   EVT OutVT = N->getValueType(0);
 4217   EVT VT = N->getValueType(0);
 4252   EVT OutVT = N->getValueType(0);
 4271   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 4281     V0->getValueType(0).getScalarType(), V0, V1);
 4286   return DAG.getAnyExtOrTrunc(Ext, dl, N->getValueType(0));
 4294                                N->getValueType(0).getVectorNumElements());
 4296   return DAG.getNode(ISD::TRUNCATE, dl, N->getValueType(0), Ext);
 4303   EVT RetSclrTy = N->getValueType(0).getVectorElementType();
 4311     EVT SclrTy = Incoming->getValueType(0).getVectorElementType();
 4312     unsigned NumElem = Incoming->getValueType(0).getVectorNumElements();
 4324   return DAG.getBuildVector(N->getValueType(0), dl, NewOps);

lib/CodeGen/SelectionDAG/LegalizeTypes.cpp

  234       EVT ResultVT = N->getValueType(i);
  435         if (!isTypeLegal(Node.getValueType(i))) {
  985     return TLI.makeLibCall(DAG, LC, N->getValueType(0), None, CallOptions,
  989     return TLI.makeLibCall(DAG, LC, N->getValueType(0), Op, CallOptions,
  993     return TLI.makeLibCall(DAG, LC, N->getValueType(0), Ops, CallOptions,
 1000   return TLI.makeLibCall(DAG, LC, N->getValueType(0), Ops, CallOptions, dl).first;
 1024   Type *RetTy = Node->getValueType(0).getTypeForEVT(*DAG.getContext());

lib/CodeGen/SelectionDAG/LegalizeTypesGeneric.cpp

   41   EVT OutVT = N->getValueType(0);
  199   assert(Part.getValueType() == N->getValueType(0) &&
  214   EVT OldVT = N->getValueType(0);
  251   EVT ValueVT = LD->getValueType(0);
  287   EVT OVT = N->getValueType(0);
  333   if (N->getValueType(0).isVector() &&
  352       NumElts = N->getValueType(0).getVectorNumElements();
  353       NVT = N->getValueType(0);
  361     return DAG.getNode(ISD::BITCAST, dl, N->getValueType(0), Vec);
  365   return CreateStackStoreLoad(N->getOperand(0), N->getValueType(0));
  370   EVT VecVT = N->getValueType(0);
  408   EVT VecVT = N->getValueType(0);
  444   EVT VT = N->getValueType(0);
  558   std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));

lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp

  251       switch (TLI.getLoadExtAction(LD->getExtensionType(), LD->getValueType(0),
  341     Action = TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0));
  349                                        Node->getValueType(0))
  351       EVT EltVT = Node->getValueType(0).getVectorElementType();
  452     Action = TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0));
  460                                               Node->getValueType(0), Scale);
  637     EVT DstEltVT = LD->getValueType(0).getScalarType();
  744     Value = DAG.getBuildVector(Op.getNode()->getValueType(0), dl, Vals);

lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp

  223   EVT VT = N->getValueType(0).getVectorElementType();
  255   EVT ResVT = N->getValueType(0);
  256   EVT OvVT = N->getValueType(1);
  277   EVT OtherVT = N->getValueType(OtherNo);
  301   EVT NewVT = N->getValueType(0).getVectorElementType();
  307   EVT EltVT = N->getValueType(0).getVectorElementType();
  318                      N->getValueType(0).getVectorElementType(),
  323   EVT NewVT = N->getValueType(0).getVectorElementType();
  330   EVT NewVT = N->getValueType(0).getVectorElementType();
  351   EVT EltVT = N->getValueType(0).getVectorElementType();
  363       N->getValueType(0).getVectorElementType(), SDLoc(N), N->getChain(),
  377   EVT DestVT = N->getValueType(0).getVectorElementType();
  400   EVT EltVT = N->getValueType(0).getVectorElementType();
  413   EVT EltVT = N->getValueType(0).getVectorElementType();
  438   EVT EltVT = N->getValueType(0).getVectorElementType();
  530   return DAG.getUNDEF(N->getValueType(0).getVectorElementType());
  537     return DAG.getUNDEF(N->getValueType(0).getVectorElementType());
  543   assert(N->getValueType(0).isVector() &&
  549   EVT NVT = N->getValueType(0).getVectorElementType();
  660   assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 1 &&
  672                      N->getValueType(0), Elt);
  678   assert(N->getValueType(0).getVectorNumElements() == 1 &&
  682                            N->getValueType(0).getScalarType(), Elt);
  685   return DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(N), N->getValueType(0), Op);
  691   assert(N->getValueType(0).getVectorNumElements() == 1 &&
  695                             { N->getValueType(0).getScalarType(), MVT::Other },
  702   return DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(N), N->getValueType(0), Res);
  710   return DAG.getBuildVector(N->getValueType(0), SDLoc(N), Ops);
  716   EVT VT = N->getValueType(0);
  730   EVT VT = N->getValueType(0);
  740   assert(N->getValueType(0).isVector() &&
  743   assert(N->getValueType(0) == MVT::v1i1 && "Expected v1i1 type");
  745   EVT VT = N->getValueType(0);
  791                             N->getValueType(0).getVectorElementType(), Elt,
  793   return DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(N), N->getValueType(0), Res);
  801                             { N->getValueType(0).getVectorElementType(), 
  807   return DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(N), N->getValueType(0), Res);
  813   if (Res.getValueType() != N->getValueType(0))
  814     Res = DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), N->getValueType(0), Res);
  831   if (CustomLowerNode(N, N->getValueType(ResNo), true))
 1062   std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
 1118   std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
 1139   std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
 1155   std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
 1186       std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
 1278   std::tie(OutLoVT, OutHiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
 1305   std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
 1351   EVT VT = N->getValueType(0);
 1409   EVT ResVT = N->getValueType(0);
 1410   EVT OvVT = N->getValueType(1);
 1435   EVT OtherVT = N->getValueType(OtherNo);
 1470   if (CustomLowerNode(N, N->getValueType(0), true))
 1519   std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
 1530   std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
 1540   std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(LD->getValueType(0));
 1577   std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(MLD->getValueType(0));
 1642   std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(MGT->getValueType(0));
 1705   assert(N->getValueType(0).isVector() &&
 1711   std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
 1736   std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
 1778   EVT DestVT = N->getValueType(0);
 1933   EVT OVT = N->getValueType(0);
 2008       if (N->getValueType(0).bitsLT(N->getOperand(0).getValueType()))
 2063     assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 2 &&
 2066     assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 1 &&
 2108   EVT ResVT = N->getValueType(0);
 2151   EVT ResVT = N->getValueType(0);
 2194   return DAG.getNode(ISD::BITCAST, SDLoc(N), N->getValueType(0),
 2200   EVT SubVT = N->getValueType(0);
 2241   if (CustomLowerNode(N, N->getValueType(0), true))
 2266   if (N->getValueType(0).bitsLT(EltVT)) {
 2269     return DAG.getZExtOrTrunc(Load, dl, N->getValueType(0));
 2273       ISD::EXTLOAD, dl, N->getValueType(0), Store, StackPtr,
 2284   return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), N->getValueType(0), Lo, Hi);
 2291   std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(MGT->getValueType(0));
 2352   SDValue Res = DAG.getNode(ISD::CONCAT_VECTORS, dl, MGT->getValueType(0), Lo,
 2534   EVT EltVT = N->getValueType(0).getVectorElementType();
 2544   return DAG.getBuildVector(N->getValueType(0), DL, Elts);
 2566   EVT InVT = InVec->getValueType(0);
 2567   EVT OutVT = N->getValueType(0);
 2627   assert(N->getValueType(0).isVector() &&
 2646   return DAG.getNode(ExtendCode, DL, N->getValueType(0), Con);
 2652   EVT ResVT = N->getValueType(0);
 2682   return DAG.UnrollVectorOp(N, N->getValueType(0).getVectorNumElements());
 2695   if (CustomWidenLowerNode(N, N->getValueType(ResNo)))
 2872     EVT VT = N->getValueType(0);
 2910   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 2920   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 2929   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3022   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3047   unsigned CurNumElts = N->getValueType(0).getVectorNumElements();
 3098   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3114   unsigned CurNumElts = N->getValueType(0).getVectorNumElements();
 3129       assert(Oper.getValueType() == N->getValueType(0) && 
 3207   EVT ResVT = N->getValueType(0);
 3208   EVT OvVT = N->getValueType(1);
 3243   EVT OtherVT = N->getValueType(OtherNo);
 3261   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3326   unsigned MinElts = N->getValueType(0).getVectorNumElements();
 3345   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3363   unsigned MinElts = N->getValueType(0).getVectorNumElements();
 3382   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3437   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3442   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3449   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3469   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3475   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3493   EVT VT = N->getValueType(0);
 3574   EVT VT = N->getValueType(0);
 3593   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3662   EVT      VT = N->getValueType(0);
 3738   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(),N->getValueType(0));
 3763   EVT WideVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3796   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3869   assert(Mask->getValueType(0).getScalarSizeInBits() ==
 3874   unsigned CurrMaskNumEls = Mask->getValueType(0).getVectorNumElements();
 3882     EVT SubVT = Mask->getValueType(0);
 3888   assert((Mask->getValueType(0) == ToMaskVT) &&
 3910   EVT CondVT = Cond->getValueType(0);
 3914   EVT VSelVT = N->getValueType(0);
 4005   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 4051  EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 4056   EVT VT = N->getValueType(0);
 4081   assert(N->getValueType(0).isVector() &&
 4084   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 4201     assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 2 &&
 4204     assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 1 &&
 4213   EVT VT = N->getValueType(0);
 4281   EVT VT = N->getValueType(0);
 4341   EVT VT = N->getValueType(0);
 4383   EVT VT = N->getValueType(0);
 4425                      N->getValueType(0), InOp, N->getOperand(1));
 4431                      N->getValueType(0), InOp, N->getOperand(1));
 4552   EVT VT = N->getValueType(0);
 4636   return DAG.getNode(N->getOpcode(), dl, N->getValueType(0), Op, N->getFlags());
 4643   EVT VT = N->getValueType(0);
 4766   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(),LD->getValueType(0));
 4833       if (L->getValueType(0).isVector() && NewVTWidth >= LdWidth) {
 4841           Loads.push_back(DAG.getUNDEF(L->getValueType(0)));
 4844         L = DAG.getNode(ISD::CONCAT_VECTORS, dl, LdOp->getValueType(0), Loads);
 4918   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(),LD->getValueType(0));

lib/CodeGen/SelectionDAG/ScheduleDAGFast.cpp

  727     if (NumVals && N->getValueType(NumVals-1) == MVT::Glue &&

lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp

  173   if (N->getValueType(N->getNumValues() - 1) == MVT::Glue) return false;
  187   assert((N->getValueType(N->getNumValues() - 1) == MVT::Glue &&
  379     while (N->getValueType(N->getNumValues()-1) == MVT::Glue) {
  560       Node->getValueType(0) == MVT::Other) {

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

  143   unsigned EltSize = N->getValueType(0).getVectorElementType().getSizeInBits();
  177   unsigned EltSize = N->getValueType(0).getScalarSizeInBits();
  216     unsigned EltSize = N->getValueType(0).getScalarSizeInBits();
  288     if (!Cst || Cst->getValueType(0) != SVT || !Match(Cst))
  618     for (unsigned i = 0, e = N->getValueType(0).getVectorNumElements();
  657   if (N->getValueType(0) == MVT::Glue)
  669     if (N->getValueType(i) == MVT::Glue)
  796     EVT VT = N->getValueType(0);
  811     assert(N->getValueType(0).isVector() && "Wrong return type!");
  812     assert(N->getNumOperands() == N->getValueType(0).getVectorNumElements() &&
  814     EVT EltVT = N->getValueType(0).getVectorElementType();
  892   if (!Erased && N->getValueType(N->getNumValues()-1) != MVT::Glue &&
 1702         EVT BuildVT = BV->getValueType(0);
 1743   EVT VT = SV.getValueType(0);
 1900   EVT VT = Node->getValueType(0);
 4311       if (VT == MVT::f16 && C->getValueType(0) == MVT::i16)
 4313       if (VT == MVT::f32 && C->getValueType(0) == MVT::i32)
 4315       if (VT == MVT::f64 && C->getValueType(0) == MVT::i64)
 4317       if (VT == MVT::f128 && C->getValueType(0) == MVT::i128)
 4402       if (VT == MVT::i16 && C->getValueType(0) == MVT::f16)
 4404       else if (VT == MVT::i32 && C->getValueType(0) == MVT::f32)
 4406       else if (VT == MVT::i64 && C->getValueType(0) == MVT::f64)
 4850       if (V1->getValueType(0).bitsGT(SVT))
 4852       if (V2->getValueType(0).bitsGT(SVT))
 4856     if (V1->getValueType(0) != SVT || V2->getValueType(0) != SVT)
 4856     if (V1->getValueType(0) != SVT || V2->getValueType(0) != SVT)
 7044   assert(N->getPassThru().getValueType() == N->getValueType(0) &&
 7047              N->getValueType(0).getVectorNumElements() &&
 7050              N->getValueType(0).getVectorNumElements() &&
 7799   SDVTList VTs = getVTList(Node->getValueType(0));
 8215             From->getValueType(i) == To->getValueType(i)) &&
 8215             From->getValueType(i) == To->getValueType(i)) &&
 8730       EVT CVT = CN->getValueType(0);
 8754       EVT CVT = CN->getValueType(0);
 9114   EVT VT = N->getValueType(0);
 9187   EVT ResVT = N->getValueType(0);
 9188   EVT OvVT = N->getValueType(1);
 9242   EVT VT = LD->getValueType(0);
 9365   EVT VT = getValueType(0);

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 3360                       LHSVal.getNode()->getValueType(LHSVal.getResNo() + i),
 3370           LHSVal.getNode()->getValueType(LHSVal.getResNo() + i), Ops);
 3827         DAG.getUNDEF(Agg.getNode()->getValueType(Agg.getResNo() + i)) :
 8771                                          SymbolicCallee->getValueType(0));

lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp

  503     if (getValueType(i) == MVT::Other)
  506       OS << getValueType(i).getEVTString();

lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

 1163           (TLI->getOperationAction(Node->getOpcode(), Node->getValueType(0))
 2200   EVT VT = Root->getValueType(Root->getNumValues()-1);
 2206     VT = Root->getValueType(Root->getNumValues()-1);
 2236       TLI->getRegisterByName(RegStr->getString().data(), Op->getValueType(0),
 2239                         Op->getOperand(0), dl, Reg, Op->getValueType(0));
 2260   CurDAG->SelectNodeTo(N, TargetOpcode::IMPLICIT_DEF, N->getValueType(0));
 2412   if (Node->getValueType(NTMNumResults-1) == MVT::Glue) {
 2415         Node->getValueType(NTMNumResults-2) == MVT::Other)
 2417   } else if (Node->getValueType(NTMNumResults-1) == MVT::Other)
 3537                NodeToMatch->getValueType(i) != MVT::Other &&
 3538                NodeToMatch->getValueType(i) != MVT::Glue &&
 3540         assert((NodeToMatch->getValueType(i) == Res.getValueType() ||
 3541                 NodeToMatch->getValueType(i) == MVT::iPTR ||
 3543                 NodeToMatch->getValueType(i).getSizeInBits() ==
 3556       if (NodeToMatch->getValueType(NodeToMatch->getNumValues() - 1) ==

lib/CodeGen/SelectionDAG/SelectionDAGPrinter.cpp

   45       return ((const SDNode *) Node)->getValueType(i).getEVTString();

lib/CodeGen/SelectionDAG/TargetLowering.cpp

 2715     unsigned BVEltWidth = BV->getValueType(0).getScalarSizeInBits();
 2723   switch (getBooleanContents(N->getValueType(0))) {
 2753   if (getBooleanContents(N->getValueType(0)) == UndefinedBooleanContent)
 2769     return (N->isOne() && !SExt) || (SExt && (N->getValueType(0) != MVT::i1));
 3216              isExtendedTrueVal(N1C, N0->getValueType(0), SExt))) {
 3490     unsigned OperandBitSize = N1C->getValueType(0).getScalarSizeInBits();
 3837         if (RHSC->getValueType(0).getSizeInBits() <= 64)
 4070                                                  GA->getValueType(0),
 4090             BA->getBlockAddress(), BA->getValueType(0),
 4567   EVT VT = N->getValueType(0);
 4626   if (TLI.isIntDivCheap(N->getValueType(0), Attr))
 4639   EVT VT = N->getValueType(0);
 4748   EVT VT = N->getValueType(0);
 5774   bool Ok = expandMUL_LOHI(N->getOpcode(), N->getValueType(0), N,
 5787   EVT VT = Node->getValueType(0);
 5836   EVT VT = Node->getValueType(0);
 5883   EVT DstVT = Node->getValueType(0);
 5957   EVT DstVT = Node->getValueType(0);
 6038   EVT DstVT = Node->getValueType(0);
 6124   EVT VT = Node->getValueType(0);
 6162   EVT VT = Node->getValueType(0);
 6222   EVT VT = Node->getValueType(0);
 6275   EVT VT = Node->getValueType(0);
 6330   EVT VT = N->getValueType(0);
 6359   EVT DstEltVT = LD->getValueType(0).getScalarType();
 6381   SDValue Value = DAG.getBuildVector(LD->getValueType(0), SL, Vals);
 6466   EVT VT = LD->getValueType(0);
 7111   if (isOperationLegalOrCustom(OpcCarry, Node->getValueType(0))) {
 7112     SDValue CarryIn = DAG.getConstant(0, dl, Node->getValueType(1));
 7123   EVT ResultType = Node->getValueType(1);
 7125       DAG.getDataLayout(), *DAG.getContext(), Node->getValueType(0));
 7141   EVT ResultType = Node->getValueType(1);
 7143       DAG.getDataLayout(), *DAG.getContext(), Node->getValueType(0));
 7174   EVT VT = Node->getValueType(0);
 7306   EVT RType = Node->getValueType(1);
 7368   if (EltVT != Node->getValueType(0))
 7369     Res = DAG.getNode(ISD::ANY_EXTEND, dl, Node->getValueType(0), Res);

lib/Target/AArch64/AArch64ISelDAGToDAG.cpp

  582   ReplaceNode(N, CurDAG->getMachineNode(MLAOpc, dl, N->getValueType(0), Ops));
  627   ReplaceNode(N, CurDAG->getMachineNode(SMULLOpc, dl, N->getValueType(0), Ops));
  676         Reg->getValueType(0).getSizeInBits() == 32 && isDef32(*Reg.getNode()))
 1131   EVT VT = N->getValueType(0);
 1154   EVT DstVT = N->getValueType(0);
 1246   EVT VT = N->getValueType(0);
 1272   EVT VT = N->getValueType(0);
 1304   EVT VT = N->getOperand(2)->getValueType(0);
 1312   SDNode *St = CurDAG->getMachineNode(Opc, dl, N->getValueType(0), Ops);
 1324   EVT VT = N->getOperand(2)->getValueType(0);
 1380   EVT VT = N->getValueType(0);
 1402   EVT WideVT = RegSeq.getOperand(1)->getValueType(0);
 1419   EVT VT = N->getValueType(0);
 1432                         RegSeq->getValueType(0), MVT::Other};
 1454     EVT WideVT = RegSeq.getOperand(1)->getValueType(0);
 1474   EVT VT = N->getOperand(2)->getValueType(0);
 1503   EVT VT = N->getOperand(2)->getValueType(0);
 1542   EVT VT = N->getValueType(0);
 1589     VT = Opd0->getValueType(0);
 1631   EVT VT = N->getValueType(0);
 1639     VT = Op->getValueType(0);
 1692     if (N->getValueType(0) == MVT::i32)
 1711   EVT VT = N->getValueType(0);
 1735     TruncBits = Opd0->getValueType(0).getSizeInBits() - VT.getSizeInBits();
 1775   EVT VT = N->getValueType(0);
 1776   EVT NarrowVT = N->getOperand(0)->getValueType(0);
 1800   if (N->getValueType(0) != MVT::i32 && N->getValueType(0) != MVT::i64)
 1800   if (N->getValueType(0) != MVT::i32 && N->getValueType(0) != MVT::i64)
 1843   EVT VT = N->getValueType(0);
 2196   EVT VT = N->getValueType(0);
 2285   EVT VT = N->getValueType(0);
 2450     CurDAG->SelectNodeTo(N, TargetOpcode::IMPLICIT_DEF, N->getValueType(0));
 2467   EVT VT = N->getValueType(0);
 2493   EVT VT = N->getValueType(0);
 2549       EVT SubVT = ShiftAmt->getValueType(0);
 2582   else if (VT == MVT::i64 && NewShiftAmt->getValueType(0) == MVT::i32) {
 2878   EVT VT = Node->getValueType(0);
 3363       VT = Node->getOperand(2)->getValueType(0);

lib/Target/AArch64/AArch64ISelLowering.cpp

 2207     SDVTList VTs = DAG.getVTList(Op->getValueType(0), MVT::i32);
 2246     if (!DAG.getTargetLoweringInfo().isTypeLegal(Sel->getValueType(0)))
 2650   EVT VT = N->getValueType(0);
 2677                                              N->getOperand(0)->getValueType(0),
 2678                                              N->getValueType(0),
 2682   EVT VT = N->getValueType(0);
 4710     if (!DAG.getTargetLoweringInfo().isTypeLegal(LHS->getValueType(0)))
 5226     if (!DAG.getTargetLoweringInfo().isTypeLegal(CCVal->getValueType(0)))
 6094                                           GA->getValueType(0));
 6098           DAG.getTargetBlockAddress(BA->getBlockAddress(), BA->getValueType(0));
 6102           DAG.getTargetExternalSymbol(ES->getSymbol(), ES->getValueType(0));
 7113   EVT VT = BVN->getValueType(0);
 7336   EVT VT = Bvec->getValueType(0);
 7364   EVT VT = N->getValueType(0);
 8323   EVT VT = Node->getValueType(0);
 9220   EVT VT = N->getValueType(0);
 9271   EVT VT = N->getValueType(0);
 9294   EVT VT = N->getValueType(0);
 9337   if (isIntDivCheap(N->getValueType(0), Attr))
 9341   EVT VT = N->getValueType(0);
 9456   EVT VT = N->getValueType(0);
 9488   EVT VT = N->getValueType(0);
 9491       VT.getSizeInBits() != N->getOperand(0)->getValueType(0).getSizeInBits())
 9506     EVT IntVT = BV->getValueType(0);
 9528   EVT VT = N->getValueType(0);
 9568   if (!N->getValueType(0).isSimple())
 9630     FixConv = DAG.getNode(ISD::TRUNCATE, DL, N->getValueType(0), FixConv);
 9732   EVT VT = N->getValueType(0);
 9770   EVT VT = N->getValueType(0);
 9819   EVT VT = N->getValueType(0);
 9837   EVT VT = N->getValueType(0);
 9876   EVT VT = N->getValueType(0);
 9917   EVT VT = N->getValueType(0);
 9932     if (Op0->getValueType(0).getVectorNumElements() != idx && idx != 0)
 9946   EVT SVT = Source->getValueType(0);
 9973   EVT VT = N->getValueType(0);
10075     EVT ResTy = N->getValueType(0);
10280   EVT VT = Op->getValueType(0);
10370   return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, SDLoc(N), N->getValueType(0),
10431     return DAG.getNode(Opcode, dl, N->getValueType(0), N->getOperand(1),
10435     return DAG.getNode(Opcode, dl, N->getValueType(0), N->getOperand(1),
10461   return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, N->getValueType(0),
10492     return DAG.getNode(ISD::FMAXIMUM, SDLoc(N), N->getValueType(0),
10495     return DAG.getNode(ISD::FMINIMUM, SDLoc(N), N->getValueType(0),
10498     return DAG.getNode(ISD::FMAXNUM, SDLoc(N), N->getValueType(0),
10501     return DAG.getNode(ISD::FMINNUM, SDLoc(N), N->getValueType(0),
10543       return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), N->getValueType(0),
10579   EVT ResVT = N->getValueType(0);
10586   EVT SrcVT = Src->getValueType(0);
10874   EVT VT = N->getValueType(0);
11088       VecTy = N->getValueType(0);
11384   SDVTList VTs = DAG.getVTList(SubsNode->getValueType(0),
11385                                SubsNode->getValueType(1));
11474       Bit < Op->getValueType(0).getSizeInBits()) {
11504         (Bit - C->getZExtValue()) < Op->getValueType(0).getSizeInBits()) {
11513     if (Bit >= Op->getValueType(0).getSizeInBits())
11514       Bit = Op->getValueType(0).getSizeInBits() - 1;
11519     if ((Bit + C->getZExtValue()) < Op->getValueType(0).getSizeInBits()) {
11573   EVT ResVT = N->getValueType(0);
11598   EVT ResVT = N->getValueType(0);
11656   if (N->getValueType(0) == N->getOperand(0).getValueType())
11932   if (N->getValueType(0) != MVT::i16 || Op.getValueType() != MVT::f16)
11951   std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
11989   assert(N->getValueType(0) == MVT::i128 &&
12090     assert(N->getValueType(0) == MVT::i128 && "unexpected illegal conversion");

lib/Target/AMDGPU/AMDGPUISelDAGToDAG.cpp

  113     return DAG.getMachineNode(AMDGPU::S_MOV_B32, SL, N->getValueType(0),
  400   MVT VT = N->getValueType(0).getSimpleVT();
  664   EVT VT = N->getValueType(0);
  743     if (N->getValueType(0) != MVT::i64)
  751     if (N->getValueType(0) != MVT::i32)
  772     EVT VT = N->getValueType(0);
  793     if (N->getValueType(0) == MVT::i128) {
  797     } else if (N->getValueType(0) == MVT::i64) {
  807                                           N->getValueType(0), Ops));
  813     if (N->getValueType(0).getSizeInBits() != 64 || isInlineImmediate(N))
  825     ReplaceNode(N, buildSMovImm64(DL, Imm, N->getValueType(0)));
  878     if (N->getValueType(0) != MVT::i32)
  899     if (N->getValueType(0) == MVT::i32) {
 1099   EVT VT = N->getValueType(0);
 1115   EVT VT = N->getValueType(0);
 1465                                               FI->getValueType(0));
 2328     if (N->getValueType(0) != MVT::i32)
 2779     EVT VT = N->getValueType(0);

lib/Target/AMDGPU/AMDGPUISelLowering.cpp

  599   MVT VT = N->getValueType(0).getScalarType().getSimpleVT();
  651   EVT OldVT = N->getValueType(0);
 2969       return DAG.getNode(ISD::TRUNCATE, SL, N->getValueType(0), NewInReg);
 3015   EVT VT = N->getValueType(0);
 3083   if (N->getValueType(0) != MVT::i64)
 3122   EVT VT = N->getValueType(0);
 3169   EVT VT = N->getValueType(0);
 3276   EVT VT = N->getValueType(0);
 3323   EVT VT = N->getValueType(0);
 3347   EVT VT = N->getValueType(0);
 3551   EVT VT = N->getValueType(0);
 3635   EVT VT = N->getValueType(0);
 3826     return DAG.getNode(ISD::FP16_TO_FP, SL, N->getValueType(0), IntFNeg);
 3851     return DAG.getNode(ISD::FP16_TO_FP, SL, N->getValueType(0), IntFAbs);
 3867   return DCI.DAG.getConstantFP(One / Val, SDLoc(N), N->getValueType(0));
 3879     EVT DestVT = N->getValueType(0);
 3984     assert(!N->getValueType(0).isVector() &&

lib/Target/AMDGPU/R600ISelLowering.cpp

  658     if (N->getValueType(0) == MVT::i1) {
  667     if (N->getValueType(0) == MVT::i1) {
 1804   EVT VT = LoadNode->getValueType(0);
 1861         return DAG.getNode(ISD::UINT_TO_FP, DL, N->getValueType(0),
 1886     return DAG.getNode(ISD::SELECT_CC, DL, N->getValueType(0),
 2110     if (ParentNode->getValueType(0).isVector())

lib/Target/AMDGPU/SIISelLowering.cpp

 4121   EVT LoadVT = M->getValueType(0);
 4150   EVT LoadVT = M->getValueType(0);
 4183   EVT VT = N->getValueType(0);
 4219   EVT VT = N->getValueType(0);
 4293       EVT VT = N->getValueType(0);
 4322     EVT VT = N->getValueType(0);
 4343     if (N->getValueType(0) != MVT::v2f16)
 4356     if (N->getValueType(0) != MVT::v2f16)
 4756   return DAG.getUNDEF(ASC->getValueType(0));
 7304   EVT VT = Ld->getValueType(0);
 8005   EVT VT = N->getValueType(0);
 8079   EVT VT = N->getValueType(0);
 8234   EVT VT = N->getValueType(0);
 8420   EVT VT = N->getValueType(0);
 8542   EVT VT = N->getValueType(0);
 8622   EVT VT = N->getValueType(0);
 8698   EVT VT = N->getValueType(0);
 8907   EVT VT = N->getValueType(0);
 8916     EVT VT = N->getValueType(0);
 9030   EVT VT = K0->getValueType(0);
 9107       return DAG.getNode(AMDGPUISD::FMED3, SL, K0->getValueType(0),
 9119   EVT VT = N->getValueType(0);
 9137                          N->getValueType(0),
 9150                          N->getValueType(0),
 9199   EVT VT = N->getValueType(0);
 9246     return DCI.DAG.getUNDEF(N->getValueType(0));
 9261     EVT EltVT = N->getValueType(0);
 9275     EVT EltVT = N->getValueType(0);
 9409   EVT VT = N0->getValueType(0);
 9434   EVT VT = N->getValueType(0);
 9483   EVT VT = N->getValueType(0);
 9560   EVT VT = N->getValueType(0);
 9583   if (N->getValueType(0) != MVT::i32)
 9611   EVT VT = N->getValueType(0);
 9654   EVT VT = N->getValueType(0);
 9697   EVT VT = N->getValueType(0);
 9921     return DCI.DAG.getConstantFP(Zero, SDLoc(N), N->getValueType(0));
 9927     return DCI.DAG.getConstantFP(One, SDLoc(N), N->getValueType(0));
10039     EVT VT = N->getValueType(0);
10184   MVT SVT = Node->getValueType(0).getVectorElementType().getSimpleVT();
10205                                       SDLoc(Node), Users[Lane]->getValueType(0),

lib/Target/ARM/ARMISelDAGToDAG.cpp

  303   if (N->getOpcode() == ISD::Constant && N->getValueType(0) == MVT::i32) {
 1678   SDNode *New = CurDAG->getMachineNode(Opcode, SDLoc(N), LD->getValueType(0),
 1936   EVT VT = N->getValueType(0);
 2375   switch (N->getValueType(1).getVectorElementType().getSizeInBits()) {
 2455     AddEmptyMVEPredicateToOps(Ops, Loc, N->getValueType(0));
 2462   EVT VT = N->getValueType(0);
 2515   EVT VT = N->getValueType(0);
 2667         if ((LSB + Width + 1) == N->getValueType(0).getSizeInBits()) {
 2782   EVT VT = N->getValueType(0);
 3161     EVT VT = N->getValueType(0);
 3470     EVT VT = N->getValueType(0);
 3493     EVT VT = N->getValueType(0);
 3516     EVT VT = N->getValueType(0);
 3537     EVT VecVT = N->getValueType(0);

lib/Target/ARM/ARMISelLowering.cpp

 1734     EVT VT = N->getValueType(i);
 4168              Op->getValueType(0) == MVT::f64) {
 4551     if (!DAG.getTargetLoweringInfo().isTypeLegal(Cond->getValueType(0)))
 5187     if (!DAG.getTargetLoweringInfo().isTypeLegal(Cond->getValueType(0)))
 5239     if (!DAG.getTargetLoweringInfo().isTypeLegal(LHS->getValueType(0)))
 5588   assert(N->getValueType(0) == MVT::i64
 5611   EVT DstVT = BC->getValueType(0);
 5665   EVT DstVT = N->getValueType(0);
 5723         ZeroExtend->getValueType(0) != MVT::i32)
 5892   EVT VT = N->getValueType(0);
 5947   EVT VT = N->getValueType(0);
 6033   EVT VT = N->getValueType(0);
 6076   EVT VT = N->getValueType(0);
 6095     if (ShAmt->getValueType(0).getSizeInBits() > 64 ||
 6100     if (ShAmt->getValueType(0) != MVT::i32)
 8151   EVT VT = Op->getValueType(0);
 8217   EVT VT = N->getValueType(0);
 8220     if (BVN->getValueType(0) != MVT::v4i32 ||
 8354                                         N->getOperand(0)->getValueType(0),
 8355                                         N->getValueType(0),
 8366         DAG.getNode(Opcode, SDLoc(newLoad), LD->getValueType(0), newLoad);
 8377            BVN->getValueType(0) == MVT::v4i32 && "expected v4i32 BUILD_VECTOR");
 8385   EVT VT = N->getValueType(0);
 8683   EVT VT = N->getValueType(0);
 8895   if (N->getValueType(0) == MVT::i32)
 9072   assert(N->getValueType(0) == MVT::i64 &&
10863     EVT VT = N->getValueType(0);
10912   EVT VT = N->getValueType(0);
10953   if (N->getOpcode() == ARMISD::VTRN && N->getValueType(0) == MVT::v2i32)
10968   if (!N->getValueType(0).is64BitVector())
10976   EVT VT = N->getValueType(0);
11015   EVT VT = N->getValueType(0);
11051   EVT VT = N->getValueType(0);
11268          AddcSubcNode->getValueType(0) == MVT::i32 &&
11532   if (TLI.isOperationLegal(N->getOpcode(), N->getValueType(0)))
11813   EVT VT = N->getValueType(0);
11833   EVT VT = N->getValueType(0);
11912   if (N->getValueType(0) != MVT::i32)
12015   EVT VT = N->getValueType(0);
12125   EVT VT = N->getValueType(0);
12266   EVT VT = N->getValueType(0);
12292                       N0->getOperand(0)->getValueType(0).isFloatingPoint()) ||
12294                       N1->getOperand(0)->getValueType(0).isFloatingPoint()))
12322   EVT VT = N->getValueType(0);
12419   EVT VT = N->getValueType(0);
12531       return DCI.DAG.getNode(ARMISD::BFI, SDLoc(N), N->getValueType(0),
12557     EVT VT = N->getValueType(0);
12583       InNode->getValueType(0) == MVT::f64 &&
12628                        N->getValueType(0), Op0.getOperand(0));
12637   unsigned NumElts = N->getValueType(0).getVectorNumElements();
12662   EVT VT = N->getValueType(0);
12694   EVT VT = N->getValueType(0);
12707       Use->getValueType(0).isFloatingPoint())
12773   EVT VT = N->getValueType(0);
12795   EVT VT = N->getValueType(0);
12841   EVT VT = N->getValueType(0);
12965       VecTy = N->getValueType(0);
13102   EVT VT = N->getValueType(0);
13202   EVT VT = N->getValueType(0);
13224       LD->getMemoryVT() == N->getValueType(0).getVectorElementType()) {
13227     SDVTList SDTys = DAG.getVTList(N->getValueType(0), MVT::Other);
13240   EVT VT = N->getValueType(0);
13517     FixConv = DAG.getNode(ISD::TRUNCATE, dl, N->getValueType(0), FixConv);
13538   if (!N->getValueType(0).isVector() || !N->getValueType(0).isSimple() ||
13538   if (!N->getValueType(0).isVector() || !N->getValueType(0).isSimple() ||
13704     return DAG.getNode(VShiftOpc, dl, N->getValueType(0),
13722     return DAG.getNode(VShiftOpc, dl, N->getValueType(0),
13745   EVT VT = N->getValueType(0);
13837   EVT FromVT = LD->getValueType(0);
13838   EVT ToVT = N->getValueType(0);
13904     EVT VT = N->getValueType(0);
14206   EVT VT = N->getValueType(0);
14246   EVT VT = N->getValueType(0);
14469     unsigned BitWidth = N->getValueType(0).getSizeInBits();
14476     unsigned BitWidth = N->getValueType(0).getSizeInBits();
14485     unsigned BitWidth = N->getValueType(0).getSizeInBits();
14513     unsigned BitWidth = N->getValueType(0).getSizeInBits();
14522     unsigned BitWidth = N->getValueType(0).getSizeInBits();
15138         Offset = DAG.getConstant(-RHSC, SDLoc(Ptr), RHS->getValueType(0));
15152         Offset = DAG.getConstant(-RHSC, SDLoc(Ptr), RHS->getValueType(0));
15195       Offset = DAG.getConstant(-RHSC, SDLoc(Ptr), RHS->getValueType(0));
15199       Offset = DAG.getConstant(RHSC, SDLoc(Ptr), RHS->getValueType(0));
15223       Offset = DAG.getConstant(-RHSC, SDLoc(Ptr), RHS->getValueType(0));
15227       Offset = DAG.getConstant(RHSC, SDLoc(Ptr), RHS->getValueType(0));
15331     assert(Op->getValueType(0) == MVT::i32 && "Non-i32 post-inc op?!");
15966   EVT VT = Op->getValueType(0);
15977   if (hasDivide && Op->getValueType(0).isSimple() &&
16022   switch (N->getValueType(0).getSimpleVT().SimpleTy) {
16035   RTLIB::Libcall LC = getDivRemLibcall(N, N->getValueType(0).getSimpleVT().
16176   assert(N->getValueType(0) == MVT::i64 && "Unexpected type (!= i64) on ABS.");

lib/Target/AVR/AVRISelDAGToDAG.cpp

  281       if (ImmNode->getValueType(0) != MVT::i8) {

lib/Target/AVR/AVRISelLowering.cpp

  344   EVT VT = Op->getValueType(0);
  725           ISD::SUB, DL, N->getValueType(0), N->getOperand(0),
  726           DAG.getConstant(-C->getAPIntValue(), DL, C->getValueType(0)));

lib/Target/BPF/BPFISelDAGToDAG.cpp

  227     EVT VT = Node->getValueType(0);

lib/Target/Hexagon/HexagonISelDAGToDAG.cpp

  148   EVT ValueVT = LD->getValueType(0);
  164     if (LD->getValueType(0) == MVT::i64)
  177     if (LD->getValueType(0) == MVT::i64)
  575   if (N->getValueType(0) != MVT::i32 || Shl_1.getOpcode() != ISD::Constant)
  686     SDValue R = CurDAG->getNode(N->getOpcode(), SDLoc(N), N->getValueType(0),
  702   if (N->getValueType(0) == MVT::f32) {
  707   if (N->getValueType(0) == MVT::f64) {
  720   if (N->getValueType(0) == MVT::i1) {
  771   MVT ResTy = N->getValueType(0).getSimpleVT();
  833   MVT ResTy = N->getValueType(0).getSimpleVT();
  841   MVT ResTy = N->getValueType(0).getSimpleVT();
  850   MVT ResTy = N->getValueType(0).getSimpleVT();
  864   MVT ResTy = N->getValueType(0).getSimpleVT();
  996     EVT VT = I->getValueType(0);
 1169       EVT UVT = U->getValueType(0);
 2088             GANode->getValueType(0),
 2161     EVT VT = N->getValueType(0);

lib/Target/Hexagon/HexagonISelDAGToDAGHVX.cpp

  672     : InpNode(Inp), InpTy(Inp->getValueType(0).getSimpleVT()) {}
 2006   MVT ResTy = N->getValueType(0).getSimpleVT();
 2078   MVT Ty = N->getValueType(0).getSimpleVT();
 2106                                     N->getValueType(0), {Vv, Vu, Rt});

lib/Target/Hexagon/HexagonISelLowering.cpp

 1082                                            GA->getValueType(0),
 2911       if (N->getValueType(0) == MVT::i8) {

lib/Target/Lanai/LanaiISelDAGToDAG.cpp

  109       Offset = CurDAG->getTargetConstant(Imm, DL, CN->getValueType(0));
  131         Offset = CurDAG->getTargetConstant(Imm, DL, CN->getValueType(0));
  132         Base = CurDAG->getRegister(Lanai::R0, CN->getValueType(0));
  144         Offset = CurDAG->getTargetConstant(Imm, DL, CN->getValueType(0));
  145         Base = CurDAG->getRegister(Lanai::R0, CN->getValueType(0));
  283   EVT VT = Node->getValueType(0);
  319   EVT VT = Node->getValueType(0);

lib/Target/Lanai/LanaiISelLowering.cpp

  884   EVT VT = Op->getValueType(0);
 1377     EVT VT = N->getValueType(0);
 1387     EVT VT = N->getValueType(0);
 1422   EVT VT = N->getValueType(0);

lib/Target/MSP430/MSP430ISelDAGToDAG.cpp

  394     assert(Node->getValueType(0) == MVT::i16);

lib/Target/MSP430/MSP430ISelLowering.cpp

 1058       RHS = DAG.getConstant(C->getSExtValue() + 1, dl, C->getValueType(0));
 1072       RHS = DAG.getConstant(C->getSExtValue() + 1, dl, C->getValueType(0));
 1086       RHS = DAG.getConstant(C->getSExtValue() + 1, dl, C->getValueType(0));
 1100       RHS = DAG.getConstant(C->getSExtValue() + 1, dl, C->getValueType(0));

lib/Target/Mips/Mips16ISelDAGToDAG.cpp

  187   EVT NodeTy = Node->getValueType(0);

lib/Target/Mips/MipsISelDAGToDAG.cpp

  226   EVT VT = Node->getValueType(0);

lib/Target/Mips/MipsISelDAGToDAG.h

  139     return CurDAG->getTargetConstant(Imm, SDLoc(Node), Node->getValueType(0));

lib/Target/Mips/MipsISelLowering.cpp

  573   EVT Ty = N->getValueType(0);
  791   EVT ValTy = N->getValueType(0);
  907     EVT ValTy = N->getValueType(0);
  939       EVT ValTy = N->getOperand(0)->getValueType(0);
  944         SrlX = DAG.getNode(ISD::SRL, DL, And1->getValueType(0), And1, Const1);
  947           MipsISD::Ins, DL, N->getValueType(0),
  971   if (ROOTNode->getValueType(0).isVector())
 1061         !Subtarget.inMips16Mode() && N->getValueType(0) == MVT::i64)
 1076         !Subtarget.inMips16Mode() && N->getValueType(0) == MVT::i64)
 1094   EVT ValTy = N->getValueType(0);
 1115   EVT ValTy = N->getValueType(0);
 2147   EVT VT = Node->getValueType(0);
 2537   EVT VT = LD->getValueType(0), MemVT = LD->getMemoryVT();
 2697   EVT ValTy = Op->getValueType(0);

lib/Target/Mips/MipsSEISelDAGToDAG.cpp

  552   EVT EltTy = N->getValueType(0).getVectorElementType();
  628   EVT EltTy = N->getValueType(0).getVectorElementType();
  659   EVT EltTy = N->getValueType(0).getVectorElementType();
  693   EVT EltTy = N->getValueType(0).getVectorElementType();
  715   EVT EltTy = N->getValueType(0).getVectorElementType();
  769     if (Node->getValueType(0) == MVT::f64 && CN->isExactlyValue(+0.0)) {
  859                                                Node->getValueType(0),
  893     if (Node->getValueType(0) != MVT::i32 && Node->getValueType(0) != MVT::i64)
  893     if (Node->getValueType(0) != MVT::i32 && Node->getValueType(0) != MVT::i64)
  955         CurDAG->getMachineNode(RdhwrOpc, DL, Node->getValueType(0),
  986     EVT ResVecTy = BVN->getValueType(0);
  989     if (!Subtarget->hasMSA() || !BVN->getValueType(0).is128BitVector())

lib/Target/Mips/MipsSEISelLowering.cpp

  412   EVT ResTy = Op->getValueType(0);
  602   EVT Ty = N->getValueType(0);
  832   EVT VT = N->getValueType(0);
  872   EVT Ty = N->getValueType(0);
  895   EVT Ty = N->getValueType(0);
  941   EVT Ty = N->getValueType(0);
  968   EVT Ty = N->getValueType(0);
  981   EVT Ty = N->getValueType(0);
  999   EVT Ty = N->getValueType(0);
 1355   assert(Val->getValueType(1) == MVT::Other);
 1365   EVT ResTy = Op->getValueType(0);
 1366   EVT EltTy = Vec->getValueType(0).getVectorElementType();
 1375   EVT ResVecTy = Op->getValueType(0);
 1422       APInt(Op->getValueType(0).getScalarType().getSizeInBits(),
 1424       SDLoc(Op), Op->getValueType(0));
 1466   EVT VecTy = Op->getValueType(0);
 1509   EVT ResTy = Op->getValueType(0);
 1521   EVT ResTy = Op->getValueType(0);
 1532   EVT ResTy = Op->getValueType(0);
 1583     return DAG.getNode(ISD::ADD, DL, Op->getValueType(0), Op->getOperand(1),
 1589     return DAG.getNode(ISD::ADD, DL, Op->getValueType(0), Op->getOperand(1),
 1592     return DAG.getNode(ISD::AND, DL, Op->getValueType(0), Op->getOperand(1),
 1595     return DAG.getNode(ISD::AND, DL, Op->getValueType(0), Op->getOperand(1),
 1612     EVT VecTy = Op->getValueType(0);
 1627     EVT VecTy = Op->getValueType(0);
 1638     return DAG.getNode(ISD::VSELECT, DL, Op->getValueType(0), Op->getOperand(3),
 1641     return DAG.getNode(ISD::VSELECT, DL, Op->getValueType(0),
 1645     return DAG.getNode(ISD::VSELECT, DL, Op->getValueType(0), Op->getOperand(3),
 1648     return DAG.getNode(ISD::VSELECT, DL, Op->getValueType(0),
 1655     EVT VecTy = Op->getValueType(0);
 1672     return DAG.getNode(MipsISD::VALL_NONZERO, DL, Op->getValueType(0),
 1675     return DAG.getNode(MipsISD::VANY_NONZERO, DL, Op->getValueType(0),
 1679     return DAG.getNode(ISD::VSELECT, DL, Op->getValueType(0),
 1684     return DAG.getNode(ISD::VSELECT, DL, Op->getValueType(0),
 1691     EVT VecTy = Op->getValueType(0);
 1708     return DAG.getNode(MipsISD::VALL_ZERO, DL, Op->getValueType(0),
 1711     return DAG.getNode(MipsISD::VANY_ZERO, DL, Op->getValueType(0),
 1717     return DAG.getSetCC(DL, Op->getValueType(0), Op->getOperand(1),
 1723     return DAG.getSetCC(DL, Op->getValueType(0), Op->getOperand(1),
 1729     return DAG.getSetCC(DL, Op->getValueType(0), Op->getOperand(1),
 1735     return DAG.getSetCC(DL, Op->getValueType(0), Op->getOperand(1),
 1741     return DAG.getSetCC(DL, Op->getValueType(0), Op->getOperand(1),
 1747     return DAG.getSetCC(DL, Op->getValueType(0), Op->getOperand(1),
 1753     return DAG.getSetCC(DL, Op->getValueType(0), Op->getOperand(1),
 1759     return DAG.getSetCC(DL, Op->getValueType(0), Op->getOperand(1),
 1765     return DAG.getSetCC(DL, Op->getValueType(0), Op->getOperand(1),
 1771     return DAG.getSetCC(DL, Op->getValueType(0), Op->getOperand(1),
 1785                          Op->getValueType(0), Op->getOperand(1),
 1803                          Op->getValueType(0), Op->getOperand(1),
 1810     return DAG.getNode(ISD::SDIV, DL, Op->getValueType(0), Op->getOperand(1),
 1816     return DAG.getNode(ISD::UDIV, DL, Op->getValueType(0), Op->getOperand(1),
 1821     return DAG.getNode(ISD::FADD, DL, Op->getValueType(0), Op->getOperand(1),
 1826     return DAG.getSetCC(DL, Op->getValueType(0), Op->getOperand(1),
 1830     return DAG.getSetCC(DL, Op->getValueType(0), Op->getOperand(1),
 1834     return DAG.getSetCC(DL, Op->getValueType(0), Op->getOperand(1),
 1838     return DAG.getSetCC(DL, Op->getValueType(0), Op->getOperand(1),
 1842     return DAG.getSetCC(DL, Op->getValueType(0), Op->getOperand(1),
 1846     return DAG.getSetCC(DL, Op->getValueType(0), Op->getOperand(1),
 1850     return DAG.getSetCC(DL, Op->getValueType(0), Op->getOperand(1),
 1854     return DAG.getSetCC(DL, Op->getValueType(0), Op->getOperand(1),
 1858     return DAG.getSetCC(DL, Op->getValueType(0), Op->getOperand(1),
 1862     return DAG.getSetCC(DL, Op->getValueType(0), Op->getOperand(1),
 1867     return DAG.getNode(ISD::FDIV, DL, Op->getValueType(0), Op->getOperand(1),
 1871     return DAG.getNode(ISD::UINT_TO_FP, DL, Op->getValueType(0),
 1875     return DAG.getNode(ISD::SINT_TO_FP, DL, Op->getValueType(0),
 1881     EVT ResTy = Op->getValueType(0);
 1892     EVT ResTy = Op->getValueType(0);
 1899     return DAG.getNode(ISD::FLOG2, DL, Op->getValueType(0), Op->getOperand(1));
 1902     return DAG.getNode(ISD::FMA, SDLoc(Op), Op->getValueType(0),
 1907     return DAG.getNode(ISD::FMUL, DL, Op->getValueType(0), Op->getOperand(1),
 1912     return DAG.getNode(MipsISD::FMS, SDLoc(Op), Op->getValueType(0),
 1917     return DAG.getNode(ISD::FRINT, DL, Op->getValueType(0), Op->getOperand(1));
 1920     return DAG.getNode(ISD::FSQRT, DL, Op->getValueType(0), Op->getOperand(1));
 1924     return DAG.getNode(ISD::FSUB, DL, Op->getValueType(0), Op->getOperand(1),
 1928     return DAG.getNode(ISD::FP_TO_UINT, DL, Op->getValueType(0),
 1932     return DAG.getNode(ISD::FP_TO_SINT, DL, Op->getValueType(0),
 1938     return DAG.getNode(MipsISD::ILVEV, DL, Op->getValueType(0),
 1944     return DAG.getNode(MipsISD::ILVL, DL, Op->getValueType(0),
 1950     return DAG.getNode(MipsISD::ILVOD, DL, Op->getValueType(0),
 1956     return DAG.getNode(MipsISD::ILVR, DL, Op->getValueType(0),
 1962     return DAG.getNode(ISD::INSERT_VECTOR_ELT, SDLoc(Op), Op->getValueType(0),
 1980     return DAG.getNode(MipsISD::INSVE, DL, Op->getValueType(0),
 1991     EVT ResTy = Op->getValueType(0);
 2000     EVT ResTy = Op->getValueType(0);
 2009     return DAG.getNode(ISD::SMAX, DL, Op->getValueType(0),
 2015     return DAG.getNode(ISD::UMAX, DL, Op->getValueType(0),
 2021     return DAG.getNode(ISD::SMAX, DL, Op->getValueType(0),
 2027     return DAG.getNode(ISD::UMAX, DL, Op->getValueType(0),
 2033     return DAG.getNode(ISD::SMIN, DL, Op->getValueType(0),
 2039     return DAG.getNode(ISD::UMIN, DL, Op->getValueType(0),
 2045     return DAG.getNode(ISD::SMIN, DL, Op->getValueType(0),
 2051     return DAG.getNode(ISD::UMIN, DL, Op->getValueType(0),
 2057     return DAG.getNode(ISD::SREM, DL, Op->getValueType(0), Op->getOperand(1),
 2063     return DAG.getNode(ISD::UREM, DL, Op->getValueType(0), Op->getOperand(1),
 2069     return DAG.getNode(ISD::MUL, DL, Op->getValueType(0), Op->getOperand(1),
 2075     EVT ResTy = Op->getValueType(0);
 2084     return DAG.getNode(ISD::CTLZ, DL, Op->getValueType(0), Op->getOperand(1));
 2086     SDValue Res = DAG.getNode(ISD::OR, DL, Op->getValueType(0),
 2088     return DAG.getNOT(DL, Res, Res->getValueType(0));
 2091     SDValue Res =  DAG.getNode(ISD::OR, DL, Op->getValueType(0),
 2094     return DAG.getNOT(DL, Res, Res->getValueType(0));
 2097     return DAG.getNode(ISD::OR, DL, Op->getValueType(0), Op->getOperand(1),
 2100     return DAG.getNode(ISD::OR, DL, Op->getValueType(0),
 2106     return DAG.getNode(MipsISD::PCKEV, DL, Op->getValueType(0),
 2112     return DAG.getNode(MipsISD::PCKOD, DL, Op->getValueType(0),
 2118     return DAG.getNode(ISD::CTPOP, DL, Op->getValueType(0), Op->getOperand(1));
 2151     return DAG.getNode(MipsISD::SHF, DL, Op->getValueType(0),
 2176     return DAG.getNode(ISD::SHL, DL, Op->getValueType(0), Op->getOperand(1),
 2182     return DAG.getNode(ISD::SHL, DL, Op->getValueType(0),
 2192     return DAG.getNode(MipsISD::VSHF, DL, Op->getValueType(0),
 2199     return DAG.getNode(MipsISD::VSHF, DL, Op->getValueType(0),
 2206     return DAG.getNode(ISD::SRA, DL, Op->getValueType(0), Op->getOperand(1),
 2212     return DAG.getNode(ISD::SRA, DL, Op->getValueType(0),
 2236     return DAG.getNode(ISD::SRL, DL, Op->getValueType(0), Op->getOperand(1),
 2242     return DAG.getNode(ISD::SRL, DL, Op->getValueType(0),
 2266     return DAG.getNode(ISD::SUB, DL, Op->getValueType(0), Op->getOperand(1),
 2272     return DAG.getNode(ISD::SUB, DL, Op->getValueType(0),
 2278     return DAG.getNode(MipsISD::VSHF, DL, Op->getValueType(0),
 2281     return DAG.getNode(ISD::XOR, DL, Op->getValueType(0), Op->getOperand(1),
 2284     return DAG.getNode(ISD::XOR, DL, Op->getValueType(0),
 2299   EVT ResTy = Op->getValueType(0);
 2300   EVT PtrTy = Address->getValueType(0);
 2374   EVT PtrTy = Address->getValueType(0);
 2412   EVT ResTy = Op->getValueType(0);
 2414   EVT VecTy = Op0->getValueType(0);
 2462   EVT ResTy = Op->getValueType(0);
 2518     EVT ResTy = Node->getValueType(0);
 2987   EVT ResTy = Op->getValueType(0);

lib/Target/NVPTX/NVPTXISelDAGToDAG.cpp

  524   if (N->getValueType(0) != MVT::f16)
  769     ReplaceNode(N, CurDAG->getMachineNode(Opc, SDLoc(N), N->getValueType(0),
  803     ReplaceNode(N, CurDAG->getMachineNode(Opc, SDLoc(N), N->getValueType(0),
 1059   EVT EltVT = N->getValueType(0);
 1273     if (EltVT == MVT::f16 && N->getValueType(0) == MVT::v2f16) {
 1674   EVT OrigType = N->getValueType(0);
 2116   EVT EltVT = Node->getValueType(0);

lib/Target/NVPTX/NVPTXISelLowering.cpp

 1896     EVT VVT = SubOp.getNode()->getValueType(0);
 1904   return DAG.getBuildVector(Node->getValueType(0), dl, Ops);
 1920   if (!(Op->getValueType(0) == MVT::v2f16 &&
 2253   assert(Node->getValueType(0) == MVT::i1 &&
 4550   EVT VT = N->getValueType(0);
 4644   EVT MulType = N->getValueType(0);
 4736   EVT CCType = N->getValueType(0);
 4781   EVT ResVT = N->getValueType(0);
 4926     EVT ResVT = N->getValueType(0);

lib/Target/PowerPC/PPCISelDAGToDAG.cpp

  486   if (N->getOpcode() == ISD::Constant && N->getValueType(0) == MVT::i32) {
  496   if (N->getOpcode() == ISD::Constant && N->getValueType(0) == MVT::i64) {
  576   SDValue TFI = CurDAG->getTargetFrameIndex(FI, N->getValueType(0));
  577   unsigned Opc = N->getValueType(0) == MVT::i32 ? PPC::ADDI : PPC::ADDI8;
  579     CurDAG->SelectNodeTo(SN, Opc, N->getValueType(0), TFI,
  582     ReplaceNode(SN, CurDAG->getMachineNode(Opc, dl, N->getValueType(0), TFI,
  591   if (N->getValueType(0) != MVT::i32)
  681   EVT RegVT = LD->getValueType(0);
 1047         std::max(MaxTruncation, Use->getValueType(0).getSizeInBits());
 2408         getValueBits(SDValue(N, 0), N->getValueType(0).getSizeInBits());
 2554   bool Output32Bit = N->getValueType(0) == MVT::i32;
 2571   if (N->getValueType(0) != MVT::i1)
 3622   if (N->getValueType(0) != MVT::i32 &&
 3623       N->getValueType(0) != MVT::i64)
 3650   if (N->getValueType(0) != MVT::i32 &&
 3651       N->getValueType(0) != MVT::i64)
 4375     if (N->getValueType(0) == MVT::i64) {
 4442                                   N->getValueType(0));
 4443     if (N->getValueType(0) == MVT::i64) {
 4451       assert(N->getValueType(0) == MVT::i32 &&
 4491       if (LD->getValueType(0) != MVT::i64) {
 4504         assert(LD->getValueType(0) == MVT::i64 && "Unknown load result type!");
 4520           Opcode, dl, LD->getValueType(0),
 4528       if (LD->getValueType(0) != MVT::i64) {
 4543         assert(LD->getValueType(0) == MVT::i64 && "Unknown load result type!");
 4560           Opcode, dl, LD->getValueType(0),
 4605            auto ResultType = Val.getNode()->getValueType(0);
 4684     if (N->getValueType(0) == MVT::i32)
 4837             N->getValueType(0), GenCC);
 4851                 N->getValueType(0) == MVT::i32) {
 4862     if (N->getValueType(0) == MVT::i1) {
 4895     if (N->getValueType(0) == MVT::i32)
 4897     else if (N->getValueType(0) == MVT::i64)
 4899     else if (N->getValueType(0) == MVT::f32) {
 4906     } else if (N->getValueType(0) == MVT::f64) {
 4913     } else if (N->getValueType(0) == MVT::f128)
 4917     else if (PPCSubTarget->hasQPX() && N->getValueType(0) == MVT::v4f64)
 4919     else if (PPCSubTarget->hasQPX() && N->getValueType(0) == MVT::v4f32)
 4921     else if (PPCSubTarget->hasQPX() && N->getValueType(0) == MVT::v4i1)
 4923     else if (N->getValueType(0) == MVT::v2f64 ||
 4924              N->getValueType(0) == MVT::v2i64)
 4931     CurDAG->SelectNodeTo(N, SelectCCOp, N->getValueType(0), Ops);
 4935     if (PPCSubTarget->hasVSX() && (N->getValueType(0) == MVT::v2f64 ||
 4936                                   N->getValueType(0) == MVT::v2i64)) {
 4963                                               N->getValueType(0), Ops);
 4981       CurDAG->SelectNodeTo(N, PPC::XXPERMDI, N->getValueType(0), Ops);
 5255   if (N->getValueType(0) != MVT::i32 &&
 5256       N->getValueType(0) != MVT::i64)
 5259   EVT VT = N->getValueType(0);
 5478   EVT VT = N->getValueType(0);
 5495                                             User->getValueType(0),
 5517     Res = CurDAG->getSelect(dl, User->getValueType(0), Cond, TrueRes, FalseRes);
 5622                              User->getValueType(0), User->getOperand(0),
 6017                                            MachineNode->getValueType(0),

lib/Target/PowerPC/PPCISelLowering.cpp

 1582   if (N->getValueType(0) != MVT::v16i8)
 1692   if (N->getValueType(0) != MVT::v16i8)
 1750   if (N->getValueType(0) != MVT::v16i8)
 1793   assert(N->getValueType(0) == MVT::v16i8 && isPowerOf2_32(EltSize) &&
 1937   assert(N->getValueType(0) == MVT::v16i8 && "Shuffle vector expects v16i8");
 1998   assert(N->getValueType(0) == MVT::v16i8 && "Shuffle vector expects v16i8");
 2036   assert(N->getValueType(0) == MVT::v16i8 && "Shuffle vector expects v16i8");
 2178     assert(CN->getValueType(0) == MVT::f32 && "Only one legal FP vector type!");
 2207   EVT VT = N->getValueType(0);
 2247   if (N->getValueType(0) == MVT::i32)
 2433       Disp = DAG.getTargetConstant(Imm, dl, CN->getValueType(0));
 2435                              CN->getValueType(0));
 2440     if ((CN->getValueType(0) == MVT::i32 ||
 2450       unsigned Opc = CN->getValueType(0) == MVT::i32 ? PPC::LIS : PPC::LIS8;
 2451       Base = SDValue(DAG.getMachineNode(Opc, dl, CN->getValueType(0), Base), 0);
 2621     if (LD->getValueType(0) == MVT::i64 && LD->getMemoryVT() == MVT::i32 &&
 3031   EVT VT = Node->getValueType(0);
 8189   EVT VecVT = V->getValueType(0);
 8925       if (LdSplt.getValueType() != SVOp->getValueType(0))
 8926         LdSplt = DAG.getBitcast(SVOp->getValueType(0), LdSplt);
10207     assert(N->getValueType(0) == MVT::i1 &&
10210                                  N->getValueType(0));
10223     EVT VT = N->getValueType(0);
10241     EVT TrgVT = N->getValueType(0);
12031       N->getValueType(0) != MVT::i1)
12315   if (N->getValueType(0) != MVT::i32 &&
12316       N->getValueType(0) != MVT::i64)
12465     if (Inputs[i].getValueType() == N->getValueType(0))
12469         DAG.getSExtOrTrunc(InSrc, dl, N->getValueType(0)));
12472         DAG.getZExtOrTrunc(InSrc, dl, N->getValueType(0)));
12475         DAG.getAnyExtOrTrunc(InSrc, dl, N->getValueType(0)));
12498          PromOp.getOperand(C).getValueType() != N->getValueType(0)) ||
12500          PromOp.getOperand(C+1).getValueType() != N->getValueType(0))) {
12514            PromOp.getOperand(0).getValueType() != N->getValueType(0)) ||
12516            PromOp.getOperand(1).getValueType() != N->getValueType(0))) {
12529       if (Ops[C+i].getValueType() == N->getValueType(0))
12533         Ops[C+i] = DAG.getSExtOrTrunc(Ops[C+i], dl, N->getValueType(0));
12535         Ops[C+i] = DAG.getZExtOrTrunc(Ops[C+i], dl, N->getValueType(0));
12537         Ops[C+i] = DAG.getAnyExtOrTrunc(Ops[C+i], dl, N->getValueType(0));
12553       DAG.getNode(PromOp.getOpcode(), dl, N->getValueType(0), Ops));
12563     return DAG.getNode(ISD::AND, dl, N->getValueType(0), N->getOperand(0),
12566                                        dl, N->getValueType(0)));
12570   EVT ShiftAmountTy = getShiftAmountTy(N->getValueType(0), DAG.getDataLayout());
12574       ISD::SRA, dl, N->getValueType(0),
12575       DAG.getNode(ISD::SHL, dl, N->getValueType(0), N->getOperand(0), ShiftCst),
12600       EVT VT = N->getValueType(0);
12650     EVT TargetVT = N->getValueType(0);
12719   if (!N->getValueType(0).getVectorElementType().isByteSized())
12724   unsigned ElemSize = N->getValueType(0).getScalarType().getStoreSize();
12780     return DAG.getLoad(N->getValueType(0), dl, LD1->getChain(),
12786     SDValue Load = DAG.getLoad(N->getValueType(0), dl, LDL->getChain(),
12793     return DAG.getVectorShuffle(N->getValueType(0), dl, Load,
12794                                 DAG.getUNDEF(N->getValueType(0)), Ops);
12826   EVT Ty = N->getValueType(0);
12904   int OutputSize = N->getValueType(0).getScalarSizeInBits();
12968   if (N->getValueType(0) != MVT::v2f64)
13153   MVT VecTy = N->getValueType(0).getSimpleVT();
13330   EVT VT = SVN->getValueType(0);
13503     EVT VT = LD->getValueType(0);
13550           Trunc->getValueType(0) != MVT::i32 ||
13561           Trunc2->getValueType(0) != MVT::i32 ||
13569           Bitcast->getValueType(0) != MVT::f32)
13572           Bitcast2->getValueType(0) != MVT::f32)
13885         (N->getValueType(0) == MVT::i32 || N->getValueType(0) == MVT::i16 ||
13885         (N->getValueType(0) == MVT::i32 || N->getValueType(0) == MVT::i16 ||
13887           N->getValueType(0) == MVT::i64))) {
13894         DAG.getValueType(N->getValueType(0)) // VT
13898                                 DAG.getVTList(N->getValueType(0) == MVT::i64 ?
13904       if (N->getValueType(0) == MVT::i16)
14098   EVT VT = N->getValueType(0);
15141       CN1 == nullptr || N->getValueType(0) != MVT::i64)
15292   if (Op0.getValueType() != MVT::i128 || N->getValueType(0) != MVT::i64)
15331       isOperationLegal(ISD::MUL, N->getValueType(0)))
15359   EVT VT = N->getValueType(0);
15475   EVT VT = N->getValueType(0);

lib/Target/RISCV/RISCVISelDAGToDAG.cpp

  111   EVT VT = Node->getValueType(0);

lib/Target/RISCV/RISCVISelLowering.cpp

  883     assert(N->getValueType(0) == MVT::i32 && Subtarget.is64Bit() &&
  892     assert(N->getValueType(0) == MVT::i32 && Subtarget.is64Bit() &&
  901     assert(N->getValueType(0) == MVT::i32 && Subtarget.is64Bit() &&
  909     assert(N->getValueType(0) == MVT::i32 && Subtarget.is64Bit() &&

lib/Target/Sparc/SparcISelDAGToDAG.cpp

  344     if (N->getValueType(0) == MVT::i64)

lib/Target/Sparc/SparcISelLowering.cpp

 1905                                       GA->getValueType(0),
 1910                                      CP->getValueType(0),
 1922                                        ES->getValueType(0), TF);
 2522   EVT VT = Node->getValueType(0);
 2549   EVT VT = Size->getValueType(0);
 3350         || N->getValueType(0) != MVT::i64)
 3374     if (N->getValueType(0) != MVT::f128
 3391     if (Ld->getValueType(0) != MVT::i64 || Ld->getMemoryVT() != MVT::i64)

lib/Target/SystemZ/SystemZISelDAGToDAG.cpp

  139     return CurDAG->getTargetConstant(Imm, SDLoc(Node), Node->getValueType(0));
  953   EVT VT = N->getValueType(0);
 1053   EVT VT = N->getValueType(0);
 1111   EVT VT = Node->getValueType(0);
 1150   EVT VT = Node->getValueType(0);
 1179   EVT VT = N->getValueType(0);
 1187       Load->getValueType(0).getSizeInBits())
 1484     if (Node->getValueType(0) == MVT::i64 &&
 1529     if (Node->getValueType(0) == MVT::i64) {
 1546          Node->getValueType(0).isInteger() &&
 1573     EVT VT = Node->getValueType(0);
 1853   EVT VT = Node->getValueType(0);

lib/Target/SystemZ/SystemZISelLowering.cpp

 2152         C.Op1 = DAG.getConstant(0, DL, N->getValueType(0));
 2879                                            Node->getValueType(0),
 3470   SDVTList VTs = DAG.getVTList(N->getValueType(0), MVT::i32);
 3474   if (N->getValueType(1) == MVT::i1)
 3540   if (N->getValueType(1) == MVT::i1)
 4522   EVT VT = BVN->getValueType(0);
 5111     Success = DAG.getZExtOrTrunc(Success, DL, N->getValueType(1));
 5412   EVT VT = N->getValueType(0);
 5441   EVT VT = N->getValueType(0);
 5462   EVT VT = N->getValueType(0);
 5522   EVT LdVT = N->getValueType(0);
 5654     if (isVectorElementSwap(ShuffleMask, N->getValueType(0))) {
 5665                                 DAG.getVTList(LD->getValueType(0), MVT::Other),
 5708     if (EltVT != N->getValueType(0)) {
 5710       Op = DAG.getNode(ISD::BITCAST, SDLoc(N), N->getValueType(0), Op);
 5719     return combineExtract(SDLoc(N), N->getValueType(0), VecVT, Op0,
 5730     return DAG.getNode(SystemZISD::REPLICATE, SDLoc(N), N->getValueType(0),
 5749   if (N->getValueType(0) == MVT::f32 &&
 5800   if (N->getValueType(0) == MVT::f64 &&
 5843       canLoadStoreByteSwapped(N->getValueType(0))) {
 5852       EVT LoadVT = N->getValueType(0);
 5862       if (N->getValueType(0) == MVT::i16)
 5896         (canLoadStoreByteSwapped(N->getValueType(0)) &&
 5898       EVT VecVT = N->getValueType(0);
 5899       EVT EltVT = N->getValueType(0).getVectorElementType();
 5927       EVT VecVT = N->getValueType(0);
 6058     return DAG.getNode(SystemZISD::BR_CCMASK, SDLoc(N), N->getValueType(0),
 6081     return DAG.getNode(SystemZISD::SELECT_CCMASK, SDLoc(N), N->getValueType(0),
 6134   EVT VT = N->getValueType(0);

lib/Target/X86/X86ISelDAGToDAG.cpp

  797       SDValue Res = CurDAG->getNode(ISD::AND, SDLoc(N), N->getValueType(0),
  820       SDValue Res = CurDAG->getNode(NewOpc, SDLoc(N), N->getValueType(0),
  833       if (!N->getValueType(0).isVector())
  843       SDValue Res = CurDAG->getNode(NewOpc, SDLoc(N), N->getValueType(0),
  855       if (!N->getValueType(0).isVector() ||
  863       SDValue Res = CurDAG->getNode(NewOpc, SDLoc(N), N->getValueType(0),
  889           X86ISD::VRNDSCALE, dl, N->getValueType(0), N->getOperand(0),
 3636   EVT VT = N->getValueType(0);
 3845   EVT VT = Node->getValueType(0);
 4460         X86ISD::BLENDV, SDLoc(Node), Node->getValueType(0), Node->getOperand(0),
 5214     SDValue Res = CurDAG->getNode(X86ISD::VRNDSCALE, dl, Node->getValueType(0),

lib/Target/X86/X86ISelLowering.cpp

 4007              Callee->getValueType(0) == MVT::i32) {
 4874   EVT VT = Load->getValueType(0);
 5120   EVT VT = N->getValueType(0);
 7679     EVT PVT = LD->getValueType(0);
 8598   EVT VT = N->getValueType(0);
17306          User->getValueType(0) != MVT::i32))
17942                                            GA->getValueType(0),
18018                                            GA->getValueType(0),
18061       DAG.getTargetGlobalAddress(GA->getGlobal(), dl, GA->getValueType(0),
18126                                                 GA->getValueType(0),
18214                                              GA->getValueType(0),
20309   if (isIntDivCheap(N->getValueType(0), Attr))
20321   EVT VT = N->getValueType(0);
21172   assert(Op->getValueType(1) == MVT::i8 && "Unexpected VT!");
22205   EVT VT = Node->getValueType(0);
22348   EVT ArgVT = Op.getNode()->getValueType(0);
23285       SDVTList CFVTs = DAG.getVTList(Op->getValueType(0), MVT::i32);
24043     SDVTList VTs = DAG.getVTList(Op->getValueType(0), MVT::i32, MVT::Other);
24048     SDValue Ops[] = {DAG.getZExtOrTrunc(Result, dl, Op->getValueType(1)),
24049                      DAG.getConstant(1, dl, Op->getValueType(1)),
24052     SDValue isValid = DAG.getNode(X86ISD::CMOV, dl, Op->getValueType(1), Ops);
24125     SDVTList VTs = DAG.getVTList(Op->getValueType(0), MVT::Other);
24129     SDValue Ret = DAG.getNode(ISD::ZERO_EXTEND, dl, Op->getValueType(0), SetCC);
27273   if (N->getValueType(1) == MVT::i1)
27829     assert(N->getValueType(0) == MVT::i64 && "Unexpected VT!");
27849     EVT VT = N->getValueType(0);
27872     EVT VT = N->getValueType(0);
27899     assert(N->getValueType(0) == MVT::i64 &&
27927     EVT VT = N->getValueType(0);
27941     EVT VT = N->getValueType(0);
28041     assert(N->getValueType(0) == MVT::v8i8 &&
28046     EVT VT = N->getValueType(0);
28096       std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
28119     EVT VT = N->getValueType(0);
28210     if (N->getValueType(0) != MVT::v2f32 || Src.getValueType() != MVT::v2i64)
28217     EVT VT = N->getValueType(0);
28249     assert(N->getValueType(0) == MVT::v2f32 &&
28278     EVT T = N->getValueType(0);
28354     Success = DAG.getZExtOrTrunc(Success, dl, N->getValueType(1));
28362     assert(N->getValueType(0) == MVT::i64 && "Unexpected VT!");
28438     EVT DstVT = N->getValueType(0);
28479     EVT VT = N->getValueType(0);
33839   EVT VT = N->getValueType(0);
33979   EVT VT = N->getValueType(0);
34025   EVT VT = N->getValueType(0);
34107   if (!Shuf->getValueType(0).isSimple())
34146   EVT VT = N->getValueType(0);
35071   EVT EltVT = N->getValueType(0);
35172   return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, N->getValueType(0), Shuffle,
35343   EVT DstVT = N->getValueType(0);
35462   EVT VT = N->getValueType(0);
35751   EVT ExtractVT = Extract->getValueType(0);
35829   EVT ExtractVT = Extract->getValueType(0);
36045   EVT VT = N->getValueType(0);
36171   EVT VT = ExtElt->getValueType(0);
36283   EVT VT = ExtElt->getValueType(0);
36389   EVT VT = N->getValueType(0);
36484           Use->getValueType(0) == MVT::i1) {
36637   EVT VT = N->getValueType(0);
36671   EVT VT = N->getValueType(0);
36753   EVT VT = N->getValueType(0);
36795     SDValue SB = DAG.getNode(X86ISD::BLENDV, SDLoc(U), U->getValueType(0),
36981       return DAG.getNode(Opcode, DL, N->getValueType(0), LHS, RHS);
37597       return DAG.getNode(X86ISD::CMOV, DL, N->getValueType(0), Ops);
37621         Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, TrueC->getValueType(0), Cond);
37636                            FalseC->getValueType(0), Cond);
37644       if (N->getValueType(0) == MVT::i32 || N->getValueType(0) == MVT::i64) {
37644       if (N->getValueType(0) == MVT::i32 || N->getValueType(0) == MVT::i64) {
37646         assert(Diff.getBitWidth() == N->getValueType(0).getSizeInBits() &&
37668           Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, FalseC->getValueType(0),
37718         return DAG.getNode(X86ISD::CMOV, DL, N->getValueType(0), Ops);
37753       SDValue LCMOV = DAG.getNode(X86ISD::CMOV, DL, N->getValueType(0), LOps);
37756       SDValue CMOV = DAG.getNode(X86ISD::CMOV, DL, N->getValueType(0), Ops);
37784       EVT VT = N->getValueType(0);
38026   EVT VT = N->getValueType(0);
38071   EVT VT = N->getValueType(0);
38113   EVT VT = N->getValueType(0);
38420   EVT VT = N->getValueType(0);
38519   EVT VT = N->getValueType(0);
38554   EVT VT = N->getValueType(0);
38627   EVT VT = N->getValueType(0);
38785   EVT VT = N->getValueType(0);
38851   EVT VT = N->getValueType(0);
38915   return DAG.getBitcast(N->getValueType(0), Shift);
39041   EVT VT = N->getValueType(0);
39101   return DAG.getNode(ISD::ZERO_EXTEND, DL, N->getValueType(0), Setnp);
39114   EVT VT = N->getValueType(0);
39172   EVT VT = N->getValueType(0);
39442   EVT VT = N->getValueType(0);
39561   EVT VT = OR->getValueType(0);
39585     Ret = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), N->getValueType(0), Ret);
39595   EVT VT = N->getValueType(0);
39773   EVT ResultType = N->getValueType(0);
39828   EVT VT = N->getValueType(0);
40206   EVT RegVT = Ld->getValueType(0);
40276   if (!BV || BV->getValueType(0).getVectorElementType() != MVT::i1)
40280   unsigned NumElts = BV->getValueType(0).getVectorNumElements();
40342   EVT VT = ML->getValueType(0);
40361   EVT VT = ML->getValueType(0);
40915   EVT VT = N->getValueType(0);
40944   EVT VT = N->getValueType(0);
41036   EVT OutVT = N->getValueType(0);
41050   EVT OutVT = N->getValueType(0);
41063   EVT OutVT = N->getValueType(0);
41115   if (!N->getValueType(0).isVector() || !N->getValueType(0).isSimple())
41115   if (!N->getValueType(0).isVector() || !N->getValueType(0).isSimple())
41122   MVT VT = N->getValueType(0).getSimpleVT();
41356   EVT VT = N->getValueType(0);
41396   EVT VT = N->getValueType(0);
41425   unsigned ScalarSize = N->getValueType(0).getScalarSizeInBits();
41428   EVT VT = Op->getValueType(0);
41543   EVT OrigVT = N->getValueType(0);
41735       N->getValueType(0) == MVT::v4i32) {
41765   EVT VT = N->getValueType(0);
41814   EVT VT = N->getValueType(0);
41908   return DAG.getNode(NewOp, SDLoc(N), N->getValueType(0),
41919   EVT VT = N->getValueType(0);
41979   EVT VT = N->getValueType(0);
42021   EVT VT = N->getValueType(0);
42101   EVT DstVT = N->getValueType(0);
42166   EVT VT = N->getValueType(0);
42208   EVT VT = Ext->getValueType(0);
42278   EVT TargetVT = Extend->getValueType(0);
42334   EVT VT = N->getValueType(0);
42412   EVT VT = N->getValueType(0);
42454   EVT VT = N->getValueType(0);
42494   EVT VT = N->getValueType(0);
42555   EVT VT = N->getValueType(0);
42583   EVT VT = N->getValueType(0);
42683   EVT VT = SetCC->getValueType(0);
42820   EVT VT = N->getValueType(0);
43114   EVT VT = N->getValueType(0);
43131     EVT IntVT = BV->getValueType(0);
43178   return DAG.getNode(N->getOpcode(), DL, N->getValueType(0), NewExtElt);
43184   EVT VT = N->getValueType(0);
43219   EVT VT = N->getValueType(0);
43264     EVT LdVT = Ld->getValueType(0);
43463     SDVTList VTs = DAG.getVTList(N->getValueType(0));
43510     EVT VT = N->getValueType(0);
43511     SDValue CarryOut = DAG.getConstant(0, DL, N->getValueType(1));
43564   EVT VT = N->getValueType(0);
43696   EVT VT = N->getValueType(0);
43760   EVT VT = N->getValueType(0);
44069   EVT VT = N->getValueType(0);
44122   EVT VT = N->getValueType(0);
44230   EVT VT = N->getValueType(0);
44382   EVT VT = N->getValueType(0);
44591   if (!N->getValueType(0).isSimple())
44750   EVT VT = N->getValueType(0);
44795     return DAG.getNode(N->getOpcode(), SDLoc(N), N->getValueType(0), RHS, LHS);
44800     return DAG.getConstant(0, SDLoc(N), N->getValueType(0));
44814   if (N->getValueType(0) == MVT::v2i64 && LHS.hasOneUse() &&
44824   if (N->getValueType(0) == MVT::v2i64 && RHS.hasOneUse() &&
44841   EVT VT = N->getValueType(0);
44879   EVT VT = N->getValueType(0);

lib/Target/X86/X86InstrInfo.cpp

 5668     EVT VT = N->getValueType(i);
 5966   EVT VT = Load1->getValueType(0);

lib/Target/XCore/XCoreISelLowering.cpp

  438                                                 BasePtr->getValueType(0));
  694   assert(N->getValueType(0) == MVT::i64 &&
  739   EVT VT = Node->getValueType(0); // not an aggregate
 1744     if (N->getValueType(0) == MVT::i32 &&
 1757     if (N->getValueType(0) == MVT::i64 &&