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

References

 5180   /* 0 */ MVT::f32, MVT::i32, MVT::Other,
 5181   /* 3 */ MVT::i64, MVT::Other,
 5182   /* 5 */ MVT::f16, MVT::Other,
 5183   /* 7 */ MVT::f64, MVT::i64, MVT::v2f32, MVT::v1f64, MVT::v8i8, MVT::v4i16, MVT::v2i32, MVT::v1i64, MVT::v4f16, MVT::Other,
 5184   /* 17 */ MVT::v16i8, MVT::v8i16, MVT::v4i32, MVT::v2i64, MVT::v4f32, MVT::v2f64, MVT::f128, MVT::v8f16, MVT::Other,
 5185   /* 26 */ MVT::v16i8, MVT::v8i16, MVT::v4i32, MVT::v2i64, MVT::v4f32, MVT::v2f64, MVT::v8f16, MVT::Other,
 5186   /* 34 */ MVT::nxv16i1, MVT::nxv8i1, MVT::nxv4i1, MVT::nxv2i1, MVT::Other,
 5187   /* 39 */ MVT::nxv16i8, MVT::nxv8i16, MVT::nxv4i32, MVT::nxv2i64, MVT::nxv2f16, MVT::nxv4f16, MVT::nxv8f16, MVT::nxv1f32, MVT::nxv2f32, MVT::nxv4f32, MVT::nxv1f64, MVT::nxv2f64, MVT::Other,
 5188   /* 52 */ MVT::Untyped, MVT::Other,

17459   /* 0 */ MVT::i32, MVT::f32, MVT::i16, MVT::f16, MVT::v2i16, MVT::v2f16, MVT::i1, MVT::Other,
17460   /* 8 */ MVT::i32, MVT::Other,
17461   /* 10 */ MVT::i64, MVT::f64, MVT::v2i32, MVT::v2f32, MVT::v4f16, MVT::v4i16, MVT::i64, MVT::i64, MVT::i64, MVT::Other,
17462   /* 20 */ MVT::i32, MVT::f32, MVT::v2i16, MVT::v2f16, MVT::i32, MVT::i32, MVT::i32, MVT::i32, MVT::i16, MVT::f16, MVT::Other,
17463   /* 31 */ MVT::i64, MVT::f64, MVT::Other,
17464   /* 34 */ MVT::i64, MVT::f64, MVT::v2i32, MVT::v2f32, MVT::v4f16, MVT::v4i16, MVT::Other,
17465   /* 41 */ MVT::v4i32, MVT::v4f32, MVT::v2i64, MVT::Other,
17466   /* 45 */ MVT::i32, MVT::f32, MVT::i16, MVT::f16, MVT::v2i16, MVT::v2f16, MVT::Other,
17467   /* 52 */ MVT::i32, MVT::f32, MVT::v2i16, MVT::v2f16, MVT::Other,
17468   /* 57 */ MVT::i64, MVT::f64, MVT::v4f16, MVT::Other,
17469   /* 61 */ MVT::v2i32, MVT::i64, MVT::v2f32, MVT::f64, MVT::i1, MVT::v4i16, MVT::v4f16, MVT::Other,
17470   /* 69 */ MVT::v2i32, MVT::i64, MVT::f64, MVT::v4i16, MVT::v4f16, MVT::Other,
17471   /* 75 */ MVT::v2i32, MVT::i64, MVT::v2f32, MVT::f64, MVT::v4i16, MVT::v4f16, MVT::Other,
17472   /* 82 */ MVT::v3i32, MVT::v3f32, MVT::Other,
17473   /* 85 */ MVT::v5i32, MVT::v5f32, MVT::Other,
17474   /* 88 */ MVT::v8i32, MVT::v8f32, MVT::Other,
17475   /* 91 */ MVT::v16i32, MVT::v16f32, MVT::Other,
17476   /* 94 */ MVT::v32i32, MVT::v32f32, MVT::Other,
17477   /* 97 */ MVT::v4i32, MVT::v2i64, MVT::v2f64, MVT::Other,
17478   /* 101 */ MVT::v4i32, MVT::v4f32, MVT::v2i64, MVT::v2f64, MVT::Other,

 8869   /* 0 */ MVT::f32, MVT::i32, MVT::Other,
 8870   /* 3 */ MVT::v2f32, MVT::v2i32, MVT::i64, MVT::f64, MVT::Other,
 8871   /* 8 */ MVT::v2f32, MVT::v2i32, MVT::Other,
 8872   /* 11 */ MVT::v4f32, MVT::v4i32, MVT::Other,

  555   /* 0 */ MVT::i32, MVT::Other,

 3746   /* 0 */ MVT::i32, MVT::Other,
 3747   /* 2 */ MVT::f16, MVT::Other,
 3748   /* 4 */ MVT::f32, MVT::Other,
 3749   /* 6 */ MVT::i32, MVT::v16i1, MVT::v8i1, MVT::v4i1, MVT::Other,
 3750   /* 11 */ MVT::v2i64, MVT::Other,
 3751   /* 13 */ MVT::v4i64, MVT::Other,
 3752   /* 15 */ MVT::v8i64, MVT::Other,
 3753   /* 17 */ MVT::f64, MVT::v8i8, MVT::v4i16, MVT::v2i32, MVT::v1i64, MVT::v2f32, MVT::v4f16, MVT::Other,
 3754   /* 25 */ MVT::v16i8, MVT::v8i16, MVT::v4i32, MVT::v2i64, MVT::v4f32, MVT::v2f64, MVT::v8f16, MVT::Other,
 3755   /* 33 */ MVT::v16i8, MVT::v8i16, MVT::v4i32, MVT::v2i64, MVT::v4f32, MVT::v2f64, MVT::Other,
 3756   /* 40 */ MVT::Untyped, MVT::Other,

  917   /* 0 */ MVT::i8, MVT::Other,
  918   /* 2 */ MVT::i16, MVT::Other,

  431   /* 0 */ MVT::i32, MVT::Other,
  432   /* 2 */ MVT::i64, MVT::Other,

 2339   /* 0 */ MVT::i1, MVT::Other,
 2340   /* 2 */ MVT::i1, MVT::v2i1, MVT::v4i1, MVT::v8i1, MVT::v4i8, MVT::v2i16, MVT::i32, MVT::Other,
 2341   /* 10 */ MVT::i64, MVT::Other,
 2342   /* 12 */ MVT::v512i1, MVT::v64i1, MVT::v32i1, MVT::v16i1, MVT::Other,
 2343   /* 17 */ MVT::v1024i1, MVT::v128i1, MVT::v64i1, MVT::v32i1, MVT::Other,
 2344   /* 22 */ MVT::i32, MVT::f32, MVT::v4i8, MVT::v2i16, MVT::Other,
 2345   /* 27 */ MVT::i64, MVT::f64, MVT::v8i8, MVT::v4i16, MVT::v2i32, MVT::Other,
 2346   /* 33 */ MVT::v64i8, MVT::v32i16, MVT::v16i32, MVT::Other,
 2347   /* 37 */ MVT::v128i8, MVT::v64i16, MVT::v32i32, MVT::Other,
 2348   /* 41 */ MVT::v256i8, MVT::v128i16, MVT::v64i32, MVT::Other,
 2349   /* 45 */ MVT::Untyped, MVT::Other,

  613   /* 0 */ MVT::i32, MVT::Other,

  356   /* 0 */ MVT::i8, MVT::Other,
  357   /* 2 */ MVT::i16, MVT::Other,

 3922   /* 0 */ MVT::i32, MVT::Other,
 3923   /* 2 */ MVT::i64, MVT::Other,
 3924   /* 4 */ MVT::f16, MVT::Other,
 3925   /* 6 */ MVT::f32, MVT::Other,
 3926   /* 8 */ MVT::f64, MVT::Other,
 3927   /* 10 */ MVT::v16i8, MVT::Other,
 3928   /* 12 */ MVT::v4i8, MVT::v2i16, MVT::Other,
 3929   /* 15 */ MVT::v8i16, MVT::v8f16, MVT::Other,
 3930   /* 18 */ MVT::v4i32, MVT::v4f32, MVT::Other,
 3931   /* 21 */ MVT::v2i64, MVT::v2f64, MVT::Other,
 3932   /* 24 */ MVT::Untyped, MVT::Other,

  810   /* 0 */ MVT::i1, MVT::Other,
  811   /* 2 */ MVT::i16, MVT::Other,
  812   /* 4 */ MVT::i32, MVT::Other,
  813   /* 6 */ MVT::i64, MVT::Other,
  814   /* 8 */ MVT::f16, MVT::Other,
  815   /* 10 */ MVT::f32, MVT::Other,
  816   /* 12 */ MVT::f64, MVT::Other,
  817   /* 14 */ MVT::v2f16, MVT::Other,

 3920   /* 0 */ MVT::i1, MVT::Other,
 3921   /* 2 */ MVT::i32, MVT::Other,
 3922   /* 4 */ MVT::i64, MVT::Other,
 3923   /* 6 */ MVT::i32, MVT::f32, MVT::Other,
 3924   /* 9 */ MVT::i64, MVT::f64, MVT::Other,
 3925   /* 12 */ MVT::v16i8, MVT::v8i16, MVT::v4i32, MVT::v2i64, MVT::v1i128, MVT::v4f32, MVT::v2f64, MVT::f128, MVT::Other,
 3926   /* 21 */ MVT::v4i1, MVT::Other,
 3927   /* 23 */ MVT::v4i32, MVT::v4f32, MVT::v2f64, MVT::v2i64, MVT::Other,
 3928   /* 28 */ MVT::v4f32, MVT::Other,
 3929   /* 30 */ MVT::v4f64, MVT::Other,

 1169   /* 0 */ MVT::i32, MVT::Other,
 1170   /* 2 */ MVT::i64, MVT::Other,
 1171   /* 4 */ MVT::f32, MVT::Other,
 1172   /* 6 */ MVT::f64, MVT::Other,

 1943   /* 0 */ MVT::i1, MVT::Other,
 1944   /* 2 */ MVT::i32, MVT::Other,
 1945   /* 4 */ MVT::i32, MVT::i64, MVT::Other,
 1946   /* 7 */ MVT::f32, MVT::Other,
 1947   /* 9 */ MVT::f64, MVT::Other,
 1948   /* 11 */ MVT::f128, MVT::Other,
 1949   /* 13 */ MVT::v2i32, MVT::Other,

 1846   /* 0 */ MVT::i32, MVT::Other,
 1847   /* 2 */ MVT::i64, MVT::Other,
 1848   /* 4 */ MVT::f32, MVT::Other,
 1849   /* 6 */ MVT::f64, MVT::Other,
 1850   /* 8 */ MVT::v16i8, MVT::v8i16, MVT::v4i32, MVT::v2i64, MVT::v4f32, MVT::v2f64, MVT::f128, MVT::Other,
 1851   /* 16 */ MVT::f32, MVT::v4i8, MVT::v2i16, MVT::Other,
 1852   /* 20 */ MVT::i64, MVT::f64, MVT::v8i8, MVT::v4i16, MVT::v2i32, MVT::v2f32, MVT::Other,
 1853   /* 27 */ MVT::v16i8, MVT::v8i16, MVT::v4i32, MVT::v2i64, MVT::v4f32, MVT::v2f64, MVT::Other,
 1854   /* 34 */ MVT::Untyped, MVT::Other,

  302   /* 0 */ MVT::i32, MVT::Other,
  303   /* 2 */ MVT::i64, MVT::Other,
  304   /* 4 */ MVT::f32, MVT::Other,
  305   /* 6 */ MVT::f64, MVT::Other,
  306   /* 8 */ MVT::v4f32, MVT::v2f64, MVT::v2i64, MVT::v4i32, MVT::v16i8, MVT::v8i16, MVT::Other,
  307   /* 15 */ MVT::exnref, MVT::Other,

 4472   /* 0 */ MVT::i8, MVT::Other,
 4473   /* 2 */ MVT::i16, MVT::Other,
 4474   /* 4 */ MVT::i32, MVT::Other,
 4475   /* 6 */ MVT::i64, MVT::Other,
 4476   /* 8 */ MVT::f80, MVT::f64, MVT::f32, MVT::Other,
 4477   /* 12 */ MVT::f64, MVT::Other,
 4478   /* 14 */ MVT::f80, MVT::Other,
 4479   /* 16 */ MVT::v4f32, MVT::v2f64, MVT::v16i8, MVT::v8i16, MVT::v4i32, MVT::v2i64, MVT::f128, MVT::Other,
 4480   /* 24 */ MVT::v1i1, MVT::Other,
 4481   /* 26 */ MVT::v2i1, MVT::Other,
 4482   /* 28 */ MVT::v4i1, MVT::Other,
 4483   /* 30 */ MVT::v8i1, MVT::Other,
 4484   /* 32 */ MVT::v16i1, MVT::Other,
 4485   /* 34 */ MVT::v32i1, MVT::Other,
 4486   /* 36 */ MVT::v64i1, MVT::Other,
 4487   /* 38 */ MVT::v2i64, MVT::Other,
 4488   /* 40 */ MVT::v8f32, MVT::v4f64, MVT::v32i8, MVT::v16i16, MVT::v8i32, MVT::v4i64, MVT::Other,
 4489   /* 47 */ MVT::v16f32, MVT::v8f64, MVT::v64i8, MVT::v32i16, MVT::v16i32, MVT::v8i64, MVT::Other,
 4490   /* 54 */ MVT::x86mmx, MVT::Other,
 4491   /* 56 */ MVT::Untyped, MVT::Other,

  374   /* 0 */ MVT::i32, MVT::Other,

  387     return TLI->isOperationLegalOrCustom(ISD::BR_JT, MVT::Other) ||
  388            TLI->isOperationLegalOrCustom(ISD::BRIND, MVT::Other);

  484     assert((!N.getNode() || N.getValueType() == MVT::Other) &&
  697     return getNode(ISD::CopyToReg, dl, MVT::Other, Chain,
  706     SDVTList VTs = getVTList(MVT::Other, MVT::Glue);
  715     SDVTList VTs = getVTList(MVT::Other, MVT::Glue);
  722     SDVTList VTs = getVTList(VT, MVT::Other);
  732     SDVTList VTs = getVTList(VT, MVT::Other, MVT::Glue);
  866     SDVTList VTs = getVTList(MVT::Other, MVT::Glue);
  878     SDVTList NodeTys = getVTList(MVT::Other, MVT::Glue);

 1258     : SDNode(ISD::HANDLENODE, 0, DebugLoc(), getSDVTList(MVT::Other)) {
 1913     : SDNode(ISD::BasicBlock, 0, DebugLoc(), getSDVTList(MVT::Other)), MBB(mbb)
 2021     : SDNode(ISD::SRCVALUE, 0, DebugLoc(), getSDVTList(MVT::Other)), V(v) {}
 2038   : SDNode(ISD::MDNODE_SDNODE, 0, DebugLoc(), getSDVTList(MVT::Other)), MD(md)
 2112       : SDNode(Opcode, Order, dl, getSDVTList(MVT::Other)), Label(L) {
 2168     : SDNode(ISD::CONDCODE, 0, DebugLoc(), getSDVTList(MVT::Other)),
 2187     : SDNode(ISD::VALUETYPE, 0, DebugLoc(), getSDVTList(MVT::Other)),

  159     MVT VT = MVT::Other;

  982     return (VT == MVT::Other || isTypeLegal(VT)) &&
  991     return (VT == MVT::Other || isTypeLegal(VT)) &&
 1000     return (VT == MVT::Other || isTypeLegal(VT)) &&
 1017     return isOperationLegalOrCustom(ISD::BR_JT, MVT::Other) ||
 1018            isOperationLegalOrCustom(ISD::BRIND, MVT::Other);
 1088     return (VT == MVT::Other || isTypeLegal(VT)) &&
 1532     return MVT::Other;
 3884     MVT ConstraintVT = MVT::Other;
 4232     return DAG.getNode(ISD::BRIND, dl, MVT::Other, Value, Addr);

  289     for (auto I = legalclasstypes_begin(RC); *I != MVT::Other; ++I)
  303     while (*I != MVT::Other)
  312     getMinimalPhysRegClass(unsigned Reg, MVT VT = MVT::Other) const;

  678       case Other:

  630     TRI->getMinimalPhysRegClass(SuperReg, MVT::Other);

  224         if (EVT(VT).isSimple() && VT != MVT::Other &&
 1694     if (N->getOperand(0).getValueType() == MVT::Other)
 1696     if (N->getOperand(NumOps-1).getValueType() == MVT::Other)
 1699       if (N->getOperand(i).getValueType() == MVT::Other)
 4845         if (VT != MVT::Glue && VT != MVT::Other) {
 9137   SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chains);
13312     return DAG.getNode(ISD::BR_CC, SDLoc(N), MVT::Other,
13319       return DAG.getNode(ISD::BRCOND, SDLoc(N), MVT::Other, Chain, NewN1, N2);
13441     return DAG.getNode(ISD::BR_CC, SDLoc(N), MVT::Other,
14039     if (N->getValueType(1) == MVT::Other) {
14061       assert(N->getValueType(2) == MVT::Other && "Malformed indexed loads?");
14135                                   MVT::Other, Chain, ReplLoad.getValue(1));
14693   SDValue Chain = DAG.getNode(ISD::TokenFactor, SDLoc(LD), MVT::Other,
16035                               MVT::Other, ST->getChain(), ReplStore);
16115       return DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
17073   EVT SourceType = MVT::Other;
17086       SourceType = MVT::Other;
17094     if (SourceType == MVT::Other)
17099       SourceType = MVT::Other;
17111   bool ValidTypes = SourceType != MVT::Other &&

  586   if (VT == MVT::Other || !VT.isSimple())
 1493   if (SrcVT == MVT::Other || !SrcVT.isSimple() || DstVT == MVT::Other ||
 1493   if (SrcVT == MVT::Other || !SrcVT.isSimple() || DstVT == MVT::Other ||
 1535   if (SrcEVT == MVT::Other || DstEVT == MVT::Other ||
 1535   if (SrcEVT == MVT::Other || DstEVT == MVT::Other ||
 1858       return fastEmit_(MVT::Other, MVT::Other, ISD::TRAP) != 0;
 1858       return fastEmit_(MVT::Other, MVT::Other, ISD::TRAP) != 0;
 2287       if (VT == MVT::Other || !TLI.isTypeLegal(VT)) {

   48   if (N && Node->getValueType(N - 1) == MVT::Other)
   65   if (N && Node->getOperand(N - 1).getValueType() == MVT::Other)
  128           if (VT == MVT::Other || VT == MVT::Glue)
  297   assert(Op.getValueType() != MVT::Other &&
  441     assert(Op.getValueType() != MVT::Other &&
  640   if (NumOps && Node->getOperand(NumOps-1).getValueType() == MVT::Other)

  475         return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
  614     SDValue Result = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
  806       Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
  837       Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
  993     Action = TLI.getOperationAction(Node->getOpcode(), MVT::Other);
 1003       Action = TLI.getOperationAction(Node->getOpcode(), MVT::Other);
 1426     StoreChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Stores);
 2732     SDVTList VTs = DAG.getVTList(Node->getValueType(0), MVT::Other);
 2755     SDVTList VTs = DAG.getVTList(Node->getValueType(0), MVT::Other);
 3485       Tmp1 = DAG.getNode(ISD::BR_CC, dl, MVT::Other,
 3499       Tmp1 = DAG.getNode(ISD::BR_CC, dl, MVT::Other, Tmp1,
 4568                       DAG.getVTList(NVT, MVT::Other),

 2344                     DAG.getVTList(CastVT, MVT::Other),

  259     SDVTList VTs = DAG.getVTList(N->getValueType(0), SVT, MVT::Other);
  272       DAG.getVTList(Op2.getValueType(), N->getValueType(1), MVT::Other);
  511     Res = DAG.getNode(NewOpc, dl, { NVT, MVT::Other }, 
  612   SDValue Res = DAG.getMaskedGather(DAG.getVTList(NVT, MVT::Other),
 1326   SDValue Cond = PromoteTargetBoolean(N->getOperand(1), MVT::Other);
 1736     SDVTList VTs = DAG.getVTList(N->getValueType(0), MVT::Other);
 2707     Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
 2734     Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
 2852   SDVTList VTs = DAG.getVTList(NVT, NVT, MVT::Other);
 3559   SDVTList VTs = DAG.getVTList(VT, MVT::i1, MVT::Other);
 3932     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
 3969   return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);

  932     if (Results[i].getValueType() == MVT::Other)

  274   Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
  487   return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);

  743     NewChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, LoadChains);
 1374   EVT ValueVTs[] = {EltVT, MVT::Other};
 1407   SDValue NewChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OpChains);

  226   EVT ValueVTs[] = {VT, MVT::Other};
  333                             { NewVT, MVT::Other }, 
  695                             { N->getValueType(0).getScalarType(), MVT::Other },
  802                               MVT::Other },
 1334   EVT LoValueVTs[] = {LoVT, MVT::Other};
 1335   EVT HiValueVTs[] = {HiVT, MVT::Other};
 1341   Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
 1366   EVT ChainVTs[] = {EltVT, MVT::Other};
 1398   Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Chains);
 1565   Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
 1629   Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
 1686   Lo = DAG.getMaskedGather(DAG.getVTList(LoVT, MVT::Other), LoVT, dl, OpsLo,
 1690   Hi = DAG.getMaskedGather(DAG.getVTList(HiVT, MVT::Other), HiVT, dl, OpsHi,
 1695   Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
 1751     Lo = DAG.getNode(N->getOpcode(), dl, { LoVT, MVT::Other }, 
 1753     Hi = DAG.getNode(N->getOpcode(), dl, { HiVT, MVT::Other }, 
 1755     SDValue NewChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, 
 1759     Lo = DAG.getNode(N->getOpcode(), dl, { LoVT, MVT::Other }, 
 1761     Hi = DAG.getNode(N->getOpcode(), dl, { HiVT, MVT::Other }, 
 1765     SDValue NewChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, 
 2161     Lo = DAG.getNode(N->getOpcode(), dl, { OutVT, MVT::Other }, 
 2163     Hi = DAG.getNode(N->getOpcode(), dl, { OutVT, MVT::Other }, 
 2168     SDValue Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
 2330   SDValue Lo = DAG.getMaskedGather(DAG.getVTList(LoVT, MVT::Other), LoVT, dl,
 2340   SDValue Hi = DAG.getMaskedGather(DAG.getVTList(HiVT, MVT::Other), HiVT, dl,
 2345   Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
 2413   return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Lo, Hi);
 2463   Lo = DAG.getMaskedScatter(DAG.getVTList(MVT::Other), DataLo.getValueType(),
 2475   return DAG.getMaskedScatter(DAG.getVTList(MVT::Other), DataHi.getValueType(),
 2522   return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Lo, Hi);
 2662     Lo = DAG.getNode(N->getOpcode(), DL, { OutVT, MVT::Other }, 
 2664     Hi = DAG.getNode(N->getOpcode(), DL, { OutVT, MVT::Other }, 
 2668     SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, 
 3157       EVT OperVT[] = {VT, MVT::Other};
 3185         EVT WidenVT[] = {WidenEltVT, MVT::Other}; 
 3199     NewChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Chains);
 3347   SmallVector<EVT, 2> WidenVTs = { WidenVT, MVT::Other };
 3358   SmallVector<EVT, 2> EltVTs = { EltVT, MVT::Other };
 3371   SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, OpChains);
 3727     NewChain = DAG.getNode(ISD::TokenFactor, SDLoc(LD), MVT::Other, LdChain);
 3785   SDValue Res = DAG.getMaskedGather(DAG.getVTList(WideVT, MVT::Other),
 4300       Res = DAG.getNode(Opcode, dl, { WideVT, MVT::Other }, 
 4323       Ops[i] = DAG.getNode(Opcode, dl, { EltVT, MVT::Other }, NewOps);
 4326     SDValue NewChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OpChains);
 4451     return DAG.getNode(ISD::TokenFactor, SDLoc(ST), MVT::Other, StChain);
 4543   return DAG.getMaskedScatter(DAG.getVTList(MVT::Other),

  224     else if (VT == MVT::Other)

  468       if (Op.getValueType() == MVT::Other) {
  526       if (Op.getValueType() == MVT::Other) {
 1158     } else if (VT == MVT::Other)
 2309       if (VT == MVT::Glue || VT == MVT::Other)
 2891       if (VT == MVT::Glue || VT == MVT::Other)

  203   if (Node->getOperand(NumOps-1).getValueType() == MVT::Other)
  481         bool isChain = OpVT == MVT::Other;
  560       Node->getValueType(0) == MVT::Other) {

  999       EntryNode(ISD::EntryToken, 0, DebugLoc(), getVTList(MVT::Other)),
 1496   AddNodeIDNode(ID, ISD::BasicBlock, getVTList(MVT::Other), None);
 1790   AddNodeIDNode(ID, Opcode, getVTList(MVT::Other), Ops);
 1830   AddNodeIDNode(ID, ISD::SRCVALUE, getVTList(MVT::Other), None);
 1845   AddNodeIDNode(ID, ISD::MDNODE_SDNODE, getVTList(MVT::Other), None);
 5057     assert(VT == MVT::Other && N1.getValueType() == MVT::Other &&
 5057     assert(VT == MVT::Other && N1.getValueType() == MVT::Other &&
 5058            N2.getValueType() == MVT::Other && "Invalid token factor!");
 5622   return getNode(ISD::TokenFactor, SDLoc(Chain), MVT::Other, ArgChains);
 5757   SDValue LoadToken = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
 5951   return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
 6029   Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, LoadChains);
 6043   return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
 6146   return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
 6536   SDVTList VTs = Opcode == ISD::ATOMIC_STORE ? getVTList(MVT::Other) :
 6537                                                getVTList(VT, MVT::Other);
 6547   SDVTList VTs = getVTList(VT, MVT::Other);
 6628   const auto VTs = getVTList(MVT::Other);
 6700   assert(Chain.getValueType() == MVT::Other &&
 6743     getVTList(VT, Ptr.getValueType(), MVT::Other) : getVTList(VT, MVT::Other);
 6743     getVTList(VT, Ptr.getValueType(), MVT::Other) : getVTList(VT, MVT::Other);
 6823   assert(Chain.getValueType() == MVT::Other && "Invalid chain type");
 6841   assert(Chain.getValueType() == MVT::Other &&
 6844   SDVTList VTs = getVTList(MVT::Other);
 6874   assert(Chain.getValueType() == MVT::Other &&
 6896   assert(Chain.getValueType() == MVT::Other &&
 6911   SDVTList VTs = getVTList(MVT::Other);
 6941   SDVTList VTs = getVTList(Base.getValueType(), MVT::Other);
 6968   SDVTList VTs = getVTList(VT, MVT::Other);
 6996   assert(Chain.getValueType() == MVT::Other &&
 6998   SDVTList VTs = getVTList(MVT::Other);
 7183   return getNode(ISD::VAARG, dl, getVTList(VT, MVT::Other), Ops);
 8399     if (Op.Val.getValueType() != MVT::Other)
 8442       if (Op.Val.getValueType() != MVT::Other)
 8634       getNode(ISD::TokenFactor, SDLoc(OldLoad), MVT::Other, OldChain, NewChain);
 9573     if (Ops[I].Val.getValueType() != MVT::Other) // Skip Chain. It does not carry divergence.
 9590     SDValue NewTF = getNode(ISD::TokenFactor, DL, MVT::Other, ExtractedTFs);
 9594   return getNode(ISD::TokenFactor, DL, MVT::Other, Vals);

  860       EVT FromVT(MVT::Other);
  872       assert(FromVT != MVT::Other);
  939     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Chains);
 1071   Root = DAG.getNode(ISD::TokenFactor, getCurSDLoc(), MVT::Other,
 1592     DAG.setRoot(DAG.getNode(ISD::CATCHPAD, getCurSDLoc(), MVT::Other,
 1608       DAG.setRoot(DAG.getNode(ISD::BR, getCurSDLoc(), MVT::Other,
 1628   SDValue Ret = DAG.getNode(ISD::CATCHRET, getCurSDLoc(), MVT::Other,
 1756       DAG.getNode(ISD::CLEANUPRET, getCurSDLoc(), MVT::Other, getControlRoot());
 1821                         MVT::Other, Chains);
 1921   assert(Chain.getNode() && Chain.getValueType() == MVT::Other &&
 2236                               MVT::Other, getControlRoot(),
 2321       DAG.setRoot(DAG.getNode(ISD::BR, dl, MVT::Other, getControlRoot(),
 2390                                MVT::Other, getControlRoot(), Cond,
 2396   BrCond = DAG.getNode(ISD::BR, dl, MVT::Other, BrCond,
 2411                                     MVT::Other, Index.getValue(1),
 2453                                  MVT::Other, CopyTo, CMP,
 2458       BrCond = DAG.getNode(ISD::BR, dl, MVT::Other, BrCond,
 2465       DAG.setRoot(DAG.getNode(ISD::BR, dl, MVT::Other, CopyTo,
 2581                                MVT::Other, GuardVal.getOperand(0),
 2585                            MVT::Other, BrCond,
 2611     Chain = DAG.getNode(ISD::TRAP, getCurSDLoc(), MVT::Other, Chain);
 2668     Root = DAG.getNode(ISD::BRCOND, dl, MVT::Other, Root, RangeCmp,
 2674     Root = DAG.getNode(ISD::BR, dl, MVT::Other, Root, DAG.getBasicBlock(MBB));
 2728                               MVT::Other, getControlRoot(),
 2733     BrAnd = DAG.getNode(ISD::BR, dl, MVT::Other, BrAnd,
 2782       SDVTList VTs = DAG.getVTList(ArrayRef<EVT>({MVT::Other})); // outchain
 2821   DAG.setRoot(DAG.getNode(ISD::BR, getCurSDLoc(), MVT::Other, getControlRoot(),
 2851                           MVT::Other, getControlRoot(),
 2937                           MVT::Other, getControlRoot(),
 2958   DAG.setRoot(DAG.getNode(ISD::TRAP, getCurSDLoc(), MVT::Other, DAG.getRoot()));
 3768     setValue(&I, DAG.getUNDEF(MVT(MVT::Other)));
 3816     setValue(&I, DAG.getUNDEF(MVT(MVT::Other)));
 3991   SDVTList VTs = DAG.getVTList(AllocSize.getValueType(), MVT::Other);
 4082       SDValue Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
 4114     SDValue Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
 4244       SDValue Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
 4260   SDValue StoreNode = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
 4420   SDValue Scatter = DAG.getMaskedScatter(DAG.getVTList(MVT::Other), VT, sdl,
 4541   SDValue Gather = DAG.getMaskedGather(DAG.getVTList(VT, MVT::Other), VT, sdl,
 4559   SDVTList VTs = DAG.getVTList(MemVT, MVT::i1, MVT::Other);
 4645   DAG.setRoot(DAG.getNode(ISD::ATOMIC_FENCE, dl, MVT::Other, Ops));
 4817     ValueVTs.push_back(MVT::Other);
 5679       DAG.getVTList(VT, MVT::Other), Chain, RegName);
 5690     DAG.setRoot(DAG.getNode(ISD::WRITE_REGISTER, sdl, MVT::Other, Chain,
 5932                             MVT::Other,
 5968                              DAG.getVTList(MVT::i32, MVT::Other), Ops);
 5974     DAG.setRoot(DAG.getNode(ISD::EH_SJLJ_LONGJMP, sdl, MVT::Other,
 5978     DAG.setRoot(DAG.getNode(ISD::EH_SJLJ_SETUP_DISPATCH, sdl, MVT::Other,
 6181     DAG.setRoot(DAG.getNode(ISD::PCMARKER, sdl, MVT::Other, getRoot(), Tmp));
 6187                       DAG.getVTList(MVT::i64, MVT::Other), Op);
 6342         DAG.getVTList(TLI.getPointerTy(DAG.getDataLayout()), MVT::Other), Op);
 6349     DAG.setRoot(DAG.getNode(ISD::STACKRESTORE, sdl, MVT::Other, getRoot(), Res));
 6455     Res = DAG.getNode(ISD::INIT_TRAMPOLINE, sdl, MVT::Other, Ops);
 6497       DAG.setRoot(DAG.getNode(Op, sdl,MVT::Other, getRoot()));
 6553                                              DAG.getVTList(MVT::Other), Ops,
 6722     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
 6756     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
 6840                                  getCurSDLoc(), MVT::Other, Ops),
 6987   ValueVTs.push_back(MVT::Other); // Out chain
 7756     if (!CallOperandVal) return MVT::Other;
 7910   if (OpInfo.ConstraintVT != MVT::Other) {
 7951   if (OpInfo.ConstraintVT == MVT::Other)
 7956   if (OpInfo.ConstraintVT != MVT::Other)
 8100       OpInfo.ConstraintVT = MVT::Other;
 8406                       DAG.getVTList(MVT::Other, MVT::Glue), AsmNodeOperands);
 8511     Chain = DAG.getNode(ISD::TokenFactor, getCurSDLoc(), MVT::Other, OutChains);
 8540                           MVT::Other, getRoot(),
 8562                           MVT::Other, getRoot(),
 8569                           MVT::Other, getRoot(),
 8732   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
 8865     ValueVTs.push_back(MVT::Other);
 8869     NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
 9265   assert(CLI.Chain.getNode() && CLI.Chain.getValueType() == MVT::Other &&
 9322     CLI.Chain = CLI.DAG.getNode(ISD::TokenFactor, CLI.DL, MVT::Other, Chains);
 9733   assert(NewRoot.getNode() && NewRoot.getValueType() == MVT::Other &&
 9898     NewRoot = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Chains);
10098             DAG.getNode(ISD::BRCOND, DL, MVT::Other, getControlRoot(), Cond,
10101         BrCond = DAG.getNode(ISD::BR, DL, MVT::Other, BrCond,
10526       DAG.setRoot(DAG.getNode(ISD::BR, getCurSDLoc(), MVT::Other,

  503     if (getValueType(i) == MVT::Other)
  924     if (Op.getValueType() == MVT::Other)

  754       if (Op.getValueType() == MVT::Other)
 2118     if ((Op.getValueType() == MVT::Other && IgnoreChains) || N == Def)
 2130       if ((Op.getValueType() == MVT::Other && IgnoreChains) || N == Def)
 2224   const EVT VTs[] = {MVT::Other, MVT::Glue};
 2312       assert(ChainVal.getValueType() == MVT::Other && "Not a chain?");
 2356     if (V.getValueType() != MVT::Other)
 2396                          MVT::Other, InputChains);
 2415         Node->getValueType(NTMNumResults-2) == MVT::Other)
 2417   } else if (Node->getValueType(NTMNumResults-1) == MVT::Other)
 3387         VTs.push_back(MVT::Other);
 3448           if (VTs[i] == MVT::Other || VTs[i] == MVT::Glue) break;
 3537                NodeToMatch->getValueType(i) != MVT::Other &&
 3652     bool HasInputChain = N->getOperand(0).getValueType() == MVT::Other;

  101       else if (VT == MVT::Other)

  716     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
  778   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
  806     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
 1066         DAG.getNode(ISD::TRAP, getCurSDLoc(), MVT::Other, DAG.getRoot()));

  195   if (VT == MVT::Other) {
 4200     OpInfo.ConstraintVT = MVT::Other;
 5977       Result = DAG.getNode(ISD::STRICT_FP_TO_SINT, dl, { DstVT, MVT::Other }, 
 6002       SrcBiased = DAG.getNode(ISD::STRICT_FSUB, dl, { SrcVT, MVT::Other }, 
 6011       SInt = DAG.getNode(ISD::STRICT_FP_TO_SINT, dl, { DstVT, MVT::Other }, 
 6380   SDValue NewChain = DAG.getNode(ISD::TokenFactor, SL, MVT::Other, LoadChains);
 6457   return DAG.getNode(ISD::TokenFactor, SL, MVT::Other, Stores);
 6549     SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Stores);
 6609   SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
 6705     SDValue Result = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Stores);
 6737       DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Store1, Store2);

  450                             SI->getCondition(), -1U, MVT::Other, false,

  750   setOperationAction(ISD::PREFETCH, MVT::Other, Expand);
  785   setOperationAction(ISD::TRAP, MVT::Other, Expand);
  789   setOperationAction(ISD::DEBUGTRAP, MVT::Other, Expand);
 1010   for (auto I = TRI.legalclasstypes_begin(RC); *I != MVT::Other; ++I)
 1342         TransformToType[i] = MVT::Other;

  198     if ((VT == MVT::Other || isTypeLegalForClass(*RC, VT)) &&

  136   case MVT::Other:   return "ch";
  451     if (HandleUnknown) return MVT(MVT::Other);

  984   if (evt == MVT::Other || !evt.isSimple())

 1223                                        MVT::Other, Ops);
 1252   const EVT ResTys[] = {MVT::Untyped, MVT::Other};
 1280                         MVT::Untyped, MVT::Other};
 1326                         MVT::Other}; // Type for the Chain
 1392   const EVT ResTys[] = {MVT::Untyped, MVT::Other};
 1432                         RegSeq->getValueType(0), MVT::Other};
 1491   SDNode *St = CurDAG->getMachineNode(Opc, dl, MVT::Other, Ops);
 1516                         MVT::Other};
 2682                        AArch64::MRS, DL, N->getSimpleValueType(0), MVT::Other,
 2699                        AArch64::MRS, DL, N->getSimpleValueType(0), MVT::Other,
 2707                        AArch64::ADR, DL, N->getSimpleValueType(0), MVT::Other,
 2728         N, CurDAG->getMachineNode(AArch64::MSR, DL, MVT::Other,
 2754                        State, DL, MVT::Other,
 2772                        AArch64::MSR, DL, MVT::Other,
 2805       CurDAG->getVTList(RegTy, MVT::i32, MVT::Other), Ops);
 2984                                           MVT::Other, MemAddr, Chain);
 3006       SDNode *St = CurDAG->getMachineNode(Op, DL, MVT::i32, MVT::Other, Ops);

  201   setOperationAction(ISD::BRCOND, MVT::Other, Expand);
  217   setOperationAction(ISD::BR_JT, MVT::Other, Custom);
  277   setOperationAction(ISD::VASTART, MVT::Other, Custom);
  278   setOperationAction(ISD::VAARG, MVT::Other, Custom);
  279   setOperationAction(ISD::VACOPY, MVT::Other, Custom);
  280   setOperationAction(ISD::VAEND, MVT::Other, Expand);
  283   setOperationAction(ISD::STACKSAVE, MVT::Other, Expand);
  284   setOperationAction(ISD::STACKRESTORE, MVT::Other, Expand);
  503   setOperationAction(ISD::PREFETCH, MVT::Other, Custom);
  577   setOperationAction(ISD::TRAP, MVT::Other, Legal);
  579     setOperationAction(ISD::DEBUGTRAP, MVT::Other, Legal);
  657   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
 2401   return DAG.getNode(AArch64ISD::PREFETCH, DL, MVT::Other, Op.getOperand(0),
 3166       MVT ActualMVT = ActualVT.isSimple() ? ActualVT.getSimpleVT() : MVT::Other;
 3359         Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Copy, Chain);
 3471     Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOps);
 3705   return DAG.getNode(ISD::TokenFactor, SDLoc(Chain), MVT::Other, ArgChains);
 4010     Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOpChains);
 4116   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
 4271   return DAG.getNode(AArch64ISD::RET_FLAG, DL, MVT::Other, RetOps);
 4462       DAG.getNode(AArch64ISD::CALL, DL, DAG.getVTList(MVT::Other, MVT::Glue),
 4492   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
 4722     return DAG.getNode(AArch64ISD::BRCOND, dl, MVT::Other, Chain, Dest, CCVal,
 4744           return DAG.getNode(AArch64ISD::TBZ, dl, MVT::Other, Chain, Test,
 4749         return DAG.getNode(AArch64ISD::CBZ, dl, MVT::Other, Chain, LHS, Dest);
 4760           return DAG.getNode(AArch64ISD::TBNZ, dl, MVT::Other, Chain, Test,
 4765         return DAG.getNode(AArch64ISD::CBNZ, dl, MVT::Other, Chain, LHS, Dest);
 4771         return DAG.getNode(AArch64ISD::TBNZ, dl, MVT::Other, Chain, LHS,
 4781       return DAG.getNode(AArch64ISD::TBZ, dl, MVT::Other, Chain, LHS,
 4787     return DAG.getNode(AArch64ISD::BRCOND, dl, MVT::Other, Chain, Dest, CCVal,
 4801       DAG.getNode(AArch64ISD::BRCOND, dl, MVT::Other, Chain, Dest, CC1Val, Cmp);
 4804     return DAG.getNode(AArch64ISD::BRCOND, dl, MVT::Other, BR1, Dest, CC2Val,
 5280   return DAG.getNode(ISD::BRIND, DL, MVT::Other, Op.getOperand(0),
 5408   return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOps);
 6042         if (VT != MVT::Other && VT.getSizeInBits() == 64) {
 8299       DAG.getNode(AArch64ISD::CALL, dl, DAG.getVTList(MVT::Other, MVT::Glue),
 9057   return MVT::Other;
10948     EVT Tys[3] = { VT, MVT::i64, MVT::Other };
11117     Tys[n] = MVT::Other;  // Type of the chain
11447     BR = DAG.getNode(AArch64ISD::CBZ, SDLoc(N), MVT::Other, Chain, LHS, Dest);
11449     BR = DAG.getNode(AArch64ISD::CBNZ, SDLoc(N), MVT::Other, Chain, LHS, Dest);
11556   return DAG.getNode(NewOpc, DL, MVT::Other, N->getOperand(0), NewTestSrc,
12024         Opcode, SDLoc(N), DAG.getVTList(MVT::Untyped, MVT::Other), Ops);
12044       DAG.getVTList(MVT::i64, MVT::i64, MVT::i32, MVT::Other), Ops);

   87           OpCode2, dl, DAG.getVTList(MVT::Other),
   99           OpCode1, dl, DAG.getVTList(MVT::Other),
  108   SDValue Res = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
  131         {MVT::i64, MVT::Other},
  139   const EVT ResTys[] = {MVT::i64, MVT::i64, MVT::Other};

  416     SDVTList VTList = CurDAG->getVTList(VT, MVT::Other);
  450     SDVTList VTList = CurDAG->getVTList(VT, MVT::Other);
  604   assert(N->getOperand(0).getValueType() == MVT::Other && "Expected chain");
 2041     CurDAG->SelectNodeTo(N, AMDGPU::SI_BR_UNDEF, MVT::Other,
 2079   CurDAG->SelectNodeTo(N, BrOp, MVT::Other,

  242   setOperationAction(ISD::BR_JT, MVT::Other, Expand);
  243   setOperationAction(ISD::BRIND, MVT::Other, Expand);
 1028   return DAG.getNode(AMDGPUISD::ENDPGM, DL, MVT::Other, Chain);
 1079   return DAG.getNode(ISD::TokenFactor, SDLoc(Chain), MVT::Other, ArgChains);
 1450   SDValue Ops[] = {Join, DAG.getNode(ISD::TokenFactor, SL, MVT::Other,
 1520   return DAG.getNode(ISD::TokenFactor, SL, MVT::Other, LoStore, HiStore);

  148   setOperationAction(ISD::BRCOND, MVT::Other, Custom);
  201   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::Other, Expand);
  270   setOperationAction(ISD::INTRINSIC_VOID, MVT::Other, Custom);
  271   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
 1223     Chain = DAG.getNode(AMDGPUISD::DUMMY_CHAIN, DL, MVT::Other, NewStore);
 1251       SDValue NewChain = DAG.getNode(AMDGPUISD::DUMMY_CHAIN, DL, MVT::Other, Chain);
 1674   if (!VT.isSimple() || VT == MVT::Other)

  223   setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::Other, Custom);
  225   setOperationAction(ISD::BRCOND, MVT::Other, Custom);
  357   setOperationAction(ISD::TRAP, MVT::Other, Custom);
  358   setOperationAction(ISD::DEBUGTRAP, MVT::Other, Custom);
  673   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
  686   setOperationAction(ISD::INTRINSIC_W_CHAIN, MVT::Other, Custom);
  691   setOperationAction(ISD::INTRINSIC_VOID, MVT::Other, Custom);
  932       if (Info.memVT == MVT::Other) {
 1301   if (VT == MVT::Other || (VT != MVT::Other && VT.getSizeInBits() > 1024 &&
 1301   if (VT == MVT::Other || (VT != MVT::Other && VT.getSizeInBits() > 1024 &&
 1326   return MVT::Other;
 2237     DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chains);
 2365   return DAG.getNode(Opc, DL, MVT::Other, RetOps);
 2880     Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOpChains);
 2954   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
 4131   SDVTList VTList = DAG.getVTList(EquivLoadVT, MVT::Other);
 4173   SDVTList VTList = DAG.getVTList(CastVT, MVT::Other);
 4608     return DAG.getNode(AMDGPUISD::ENDPGM, SL, MVT::Other, Chain);
 4625   return DAG.getNode(AMDGPUISD::TRAP, SL, MVT::Other, Ops);
 4648   return DAG.getNode(AMDGPUISD::TRAP, SL, MVT::Other, Ops);
 5118   SDNode *M0 = DAG.getMachineNode(AMDGPU::SI_INIT_M0, DL, MVT::Other, MVT::Glue,
 6826         return SDValue(DAG.getMachineNode(AMDGPU::WAVE_BARRIER, DL, MVT::Other,
 7092     return SDValue(DAG.getMachineNode(AMDGPU::SI_END_CF, DL, MVT::Other,
 7203   SDVTList ResList = DAG.getVTList(MVT::i32, MVT::Other);
 7576   SDVTList VTList = DAG.getVTList(VT, MVT::Other, MVT::Glue);
 7597   SDVTList VTList = DAG.getVTList(VT, MVT::Other, MVT::Glue);
 7705     SDVTList BindParamVTs = DAG.getVTList(MVT::Other, MVT::Glue);
 7755       DisableDenorm = DAG.getNode(AMDGPUISD::DENORM_MODE, SL, MVT::Other,
 7762       DisableDenorm = DAG.getNode(AMDGPUISD::SETREG, SL, MVT::Other,
 7767     SDValue OutputChain = DAG.getNode(ISD::TokenFactor, SL, MVT::Other,
10190     DAG.getVTList(ResultVT, MVT::Other) : DAG.getVTList(ResultVT);

  118   setOperationAction(ISD::BRCOND, MVT::Other, Expand);
  119   setOperationAction(ISD::BR_JT, MVT::Other, Expand);
  128   setOperationAction(ISD::VASTART, MVT::Other, Custom);
  129   setOperationAction(ISD::VAEND, MVT::Other, Expand);
  130   setOperationAction(ISD::VAARG, MVT::Other, Expand);
  131   setOperationAction(ISD::VACOPY, MVT::Other, Expand);
  134   setOperationAction(ISD::STACKSAVE, MVT::Other, Expand);
  135   setOperationAction(ISD::STACKRESTORE, MVT::Other, Expand);
  206   return DAG.getNode(ARCISD::BRcc, dl, MVT::Other, Chain, Dest, LHS, RHS,
  307     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
  334   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
  412     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
  557     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, CFRegNode);
  582     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
  656     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
  679   return DAG.getNode(ARCISD::RET, dl, MVT::Other, RetOps);

  693   if (evt == MVT::Other || !evt.isSimple()) return false;

 1528                                            MVT::Other, Ops);
 1538                                            MVT::Other, Ops);
 1569                                        MVT::i32, MVT::Other, Ops);
 1617                                          MVT::Other, Ops);
 1679                                        MVT::i32, MVT::Other, Ops);
 1973   ResTys.push_back(MVT::Other);
 2016                                           ResTy, AddrTy, MVT::Other, OpsA);
 2105   ResTys.push_back(MVT::Other);
 2187                                         MVT::Other, OpsA);
 2275   ResTys.push_back(MVT::Other);
 2481   EVT ResultTys[] = {DataTy, MVT::Other};
 2560   ResTys.push_back(MVT::Other);
 2826       CurDAG->getVTList(MVT::i32, MVT::i32, MVT::Other), Ops);
 2956             CurDAG->getMachineNode(ARM::tSTRspi, dl, MVT::Other, Ops);
 3000         ResNode = CurDAG->getMachineNode(ARM::tLDRpci, dl, MVT::i32, MVT::Other,
 3010         ResNode = CurDAG->getMachineNode(ARM::LDRcp, dl, MVT::i32, MVT::Other,
 3293     SDNode *New = CurDAG->getMachineNode(Opc, dl, MVT::Other, Ops);
 3304                              CurDAG->getVTList(MVT::i32, MVT::Other), Ops);
 3350                                    CurDAG->getVTList(MVT::i32, MVT::Other),
 3356             CurDAG->getMachineNode(ARM::t2LoopEnd, dl, MVT::Other, EndArgs);
 3385     SDNode *ResNode = CurDAG->getMachineNode(Opc, dl, MVT::Other,
 3830       const EVT RetType[] = {MVT::i32, MVT::i32, MVT::Other};
 3853       ResTys.push_back(MVT::Other);
 3905       const EVT ResTys[] = {MVT::i32, MVT::Other};
 4432       ResTypes.append({ MVT::i32, MVT::Other });
 4437       ResTypes.append({ MVT::i32, MVT::i32, MVT::Other });
 4456                                   DL, MVT::i32, MVT::Other, Ops));
 4484                 CurDAG->getMachineNode(Opcode, DL, MVT::i32, MVT::Other, Ops));
 4500         N, CurDAG->getMachineNode(ARM::t2MRS_M, DL, MVT::i32, MVT::Other, Ops));
 4510                                           DL, MVT::i32, MVT::Other, Ops));
 4519                                   MVT::i32, MVT::Other, Ops));
 4559     ReplaceNode(N, CurDAG->getMachineNode(Opcode, DL, MVT::Other, Ops));
 4571                                   DL, MVT::Other, Ops));
 4591     ReplaceNode(N, CurDAG->getMachineNode(Opcode, DL, MVT::Other, Ops));
 4610     ReplaceNode(N, CurDAG->getMachineNode(ARM::t2MSR_M, DL, MVT::Other, Ops));
 4623                                           DL, MVT::Other, Ops));
 4788       CurDAG->getVTList(MVT::Other, MVT::Glue), AsmNodeOperands);

 1051   setOperationAction(ISD::INTRINSIC_VOID, MVT::Other, Custom);
 1182   setOperationAction(ISD::TRAP, MVT::Other, Legal);
 1183   setOperationAction(ISD::DEBUGTRAP, MVT::Other, Legal);
 1186   setOperationAction(ISD::VASTART,            MVT::Other, Custom);
 1187   setOperationAction(ISD::VAARG,              MVT::Other, Expand);
 1188   setOperationAction(ISD::VACOPY,             MVT::Other, Expand);
 1189   setOperationAction(ISD::VAEND,              MVT::Other, Expand);
 1190   setOperationAction(ISD::STACKSAVE,          MVT::Other, Expand);
 1191   setOperationAction(ISD::STACKRESTORE,       MVT::Other, Expand);
 1205     setOperationAction(ISD::ATOMIC_FENCE,     MVT::Other, Custom);
 1223     setOperationAction(ISD::ATOMIC_FENCE,   MVT::Other,
 1247   setOperationAction(ISD::PREFETCH,         MVT::Other, Custom);
 1265   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
 1267   setOperationAction(ISD::EH_SJLJ_LONGJMP, MVT::Other, Custom);
 1268   setOperationAction(ISD::EH_SJLJ_SETUP_DISPATCH, MVT::Other, Custom);
 1289   setOperationAction(ISD::BRCOND,    MVT::Other, Custom);
 1295   setOperationAction(ISD::BR_JT,     MVT::Other, Custom);
 1735     if (VT == MVT::Glue || VT == MVT::Other)
 2240         SDVTList VTs = DAG.getVTList(MVT::Other, MVT::Glue);
 2254     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
 2425   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
 2716   return DAG.getNode(ARMISD::INTRET_FLAG, DL, MVT::Other, RetOps);
 2865   return DAG.getNode(ARMISD::RET_FLAG, dl, MVT::Other, RetOps);
 2970   return DAG.getNode(ISD::WRITE_REGISTER, DL, MVT::Other, Ops);
 3114       DAG.getNode(ARMISD::CALL, DL, DAG.getVTList(MVT::Other, MVT::Glue),
 3138                                    DAG.getVTList(MVT::i32, MVT::Other), Ops);
 3564                      DAG.getVTList(MVT::i32, MVT::Other), Op.getOperand(0),
 3571   return DAG.getNode(ARMISD::EH_SJLJ_LONGJMP, dl, MVT::Other, Op.getOperand(0),
 3578   return DAG.getNode(ARMISD::EH_SJLJ_SETUP_DISPATCH, dl, MVT::Other,
 3586           Op.getOperand(Op.getOperand(0).getValueType() == MVT::Other))
 3605       std::vector<EVT> ResultTys = {MVT::Other, MVT::Glue};
 3768     return DAG.getNode(ARMISD::MEMBARRIER_MCR, dl, MVT::Other, Op.getOperand(0),
 3786   return DAG.getNode(ISD::INTRINSIC_VOID, dl, MVT::Other, Op.getOperand(0),
 3813   return DAG.getNode(ARMISD::PRELOAD, dl, MVT::Other, Op.getOperand(0),
 3926     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
 5152       return DAG.getNode(ARMISD::BRCOND, dl, MVT::Other,
 5164     SDVTList VTList = DAG.getVTList(MVT::Other, MVT::Glue);
 5202     return DAG.getNode(ARMISD::BRCOND, dl, MVT::Other, Chain, Dest, ARMcc, CCR,
 5256     return DAG.getNode(ARMISD::BRCOND, dl, MVT::Other, Chain, Dest, ARMcc, CCR,
 5264     return DAG.getNode(ARMISD::BRCOND, dl, MVT::Other,
 5281   SDVTList VTList = DAG.getVTList(MVT::Other, MVT::Glue);
 5309     return DAG.getNode(ARMISD::BR2_JT, dl, MVT::Other, Chain,
 5318     return DAG.getNode(ARMISD::BR_JT, dl, MVT::Other, Chain, Addr, JTI);
 5324     return DAG.getNode(ARMISD::BR_JT, dl, MVT::Other, Chain, Addr, JTI);
 5592                              DAG.getVTList(MVT::i32, MVT::i32, MVT::Other),
 8886   SDValue DBZCHK = DAG.getNode(ARMISD::WIN__DBZCHK, dl, MVT::Other,
 8896     return DAG.getNode(ARMISD::WIN__DBZCHK, DL, MVT::Other, InChain, Op);
 8901   return DAG.getNode(ARMISD::WIN__DBZCHK, DL, MVT::Other, InChain,
 9045                                  DAG.getVTList(MVT::i32, MVT::Other), Ops);
 9080       DAG.getVTList(MVT::Untyped, MVT::i32, MVT::Other), Ops);
13034     Tys[n] = MVT::Other;
13147   Tys[n] = MVT::Other;
13227     SDVTList SDTys = DAG.getVTList(N->getValueType(0), MVT::Other);
13332   return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chains);
13386   return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Stores);
13884   SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
14153     SDValue NewBr = DAG.getNode(ISD::BR, SDLoc(Br), MVT::Other, NewBrOps);
14162       Res = DAG.getNode(ARMISD::WLS, dl, MVT::Other, Ops);
14169       Res = DAG.getNode(ARMISD::WLS, dl, MVT::Other, Ops);
14178                                   DAG.getVTList(MVT::i32, MVT::Other), Args);
14189     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
14193     return DAG.getNode(ARMISD::LE, dl, MVT::Other, EndArgs);
14669   return MVT::Other;
15694       if (VT == MVT::Other)
15704       if (VT == MVT::Other)
15714       if (VT == MVT::Other)
16090   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);

  177   SDVTList VTs = DAG.getVTList(MVT::i32, MVT::i32, MVT::Other, MVT::Glue);
  221   Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
  237   return DAG.getNode(ISD::TokenFactor, dl, MVT::Other,

  160                                            PtrVT, MVT::Other,
  349   SDNode *ResNode = CurDAG->getMachineNode(Opc, DL, MVT::Other, Ops);
  386     ResNode = CurDAG->getMachineNode(LPMOpc, DL, VT, MVT::i16, MVT::Other, Ptr,
  393       ResNode = CurDAG->getMachineNode(AVR::LPMRdZ, DL, MVT::i8, MVT::Other,
  398                                        MVT::Other, Ptr, RegZ);
  447     CurDAG->getMachineNode(AVR::ICALL, DL, MVT::Other, MVT::Glue, Ops);
  463   SDNode *ResNode = CurDAG->getMachineNode(AVR::IJMP, DL, MVT::Other, Chain);

   53   setOperationAction(ISD::STACKSAVE, MVT::Other, Expand);
   54   setOperationAction(ISD::STACKRESTORE, MVT::Other, Expand);
  100   setOperationAction(ISD::BRCOND, MVT::Other, Expand);
  125   setOperationAction(ISD::BR_JT, MVT::Other, Expand);
  127   setOperationAction(ISD::VASTART, MVT::Other, Custom);
  128   setOperationAction(ISD::VAEND, MVT::Other, Expand);
  129   setOperationAction(ISD::VAARG, MVT::Other, Expand);
  130   setOperationAction(ISD::VACOPY, MVT::Other, Expand);
  630   return DAG.getNode(AVRISD::BRCOND, dl, MVT::Other, Chain, Dest, TargetCC,
 1269   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
 1429   return DAG.getNode(RetOpc, dl, MVT::Other, RetOps);

   72   setOperationAction(ISD::BR_JT, MVT::Other, Expand);
   73   setOperationAction(ISD::BRIND, MVT::Other, Expand);
   74   setOperationAction(ISD::BRCOND, MVT::Other, Expand);
   79   setOperationAction(ISD::STACKSAVE, MVT::Other, Expand);
   80   setOperationAction(ISD::STACKRESTORE, MVT::Other, Expand);
  378   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
  423     return DAG.getNode(Opc, DL, MVT::Other, Chain);
  451   return DAG.getNode(Opc, DL, MVT::Other, RetOps);

   35   SDVTList VTs = DAG.getVTList(MVT::Other, MVT::Glue);

  158                                               MVT::i32, MVT::Other, Base,
  169     MachineSDNode *L = CurDAG->getMachineNode(Opcode, dl, ValueVT, MVT::Other,
  203     EVT RTys[] = { ValTy, MVT::i32, MVT::Other };
  337     EVT RTys[] = { ValTy, MVT::i32, MVT::Other };
  387     EVT RTys[] = { ValTy, MVT::i32, MVT::Other };
  422     EVT RTys[] = { MVT::i32, MVT::Other };
  534     MachineSDNode *S = CurDAG->getMachineNode(Opcode, dl, MVT::i32, MVT::Other,
  542     MachineSDNode *S = CurDAG->getMachineNode(Opcode, dl, MVT::Other, Ops);

  664   MVT Ty = MVT::Other;
 1020     assert(Node.Ty != MVT::Other);
 2151   SDVTList VTs = CurDAG->getVTList(MVT::Other);
 2188   SDVTList VTs = CurDAG->getVTList(MVT::Other);

  230   return DAG.getNode(HexagonISD::RET_FLAG, dl, MVT::Other, RetOps);
  446     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
  498   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
  631   return DAG.getNode(HexagonISD::DCFETCH, DL, MVT::Other, Chain, Addr, Zero);
  642   SDVTList VTs = DAG.getVTList(MVT::i32, MVT::Other);
  655     return DAG.getNode(HexagonISD::DCFETCH, DL, MVT::Other, Chain, Addr, Zero);
  684   SDVTList VTs = DAG.getVTList(MVT::i32, MVT::Other);
 1011   return DAG.getNode(HexagonISD::BARRIER, dl, MVT::Other, Op.getOperand(0));
 1079   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
 1294   setOperationAction(ISD::TRAP,                 MVT::Other, Legal);
 1299   setOperationAction(ISD::INLINEASM,            MVT::Other, Custom);
 1300   setOperationAction(ISD::INLINEASM_BR,         MVT::Other, Custom);
 1301   setOperationAction(ISD::PREFETCH,             MVT::Other, Custom);
 1303   setOperationAction(ISD::INTRINSIC_VOID,       MVT::Other, Custom);
 1304   setOperationAction(ISD::EH_RETURN,            MVT::Other, Custom);
 1307   setOperationAction(ISD::ATOMIC_FENCE,         MVT::Other, Custom);
 1321   setOperationAction(ISD::VASTART, MVT::Other, Custom);
 1322   setOperationAction(ISD::VAEND,   MVT::Other, Expand);
 1323   setOperationAction(ISD::VAARG,   MVT::Other, Expand);
 1324   setOperationAction(ISD::VACOPY,  MVT::Other, Expand);
 1326   setOperationAction(ISD::STACKSAVE, MVT::Other, Expand);
 1327   setOperationAction(ISD::STACKRESTORE, MVT::Other, Expand);
 1334   setOperationAction(ISD::BR_JT, MVT::Other, Expand);
 1410   setOperationAction(ISD::BR_CC, MVT::Other, Expand);
 2734   SDValue NewChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
 2819   return DAG.getNode(HexagonISD::EH_RETURN, dl, MVT::Other, Chain);
 3191   return MVT::Other;

 1504                 DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
 1511     NewOp = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Store0, Store1);

   86   setOperationAction(ISD::BR_JT, MVT::Other, Expand);
   87   setOperationAction(ISD::BRCOND, MVT::Other, Expand);
   98   setOperationAction(ISD::STACKSAVE, MVT::Other, Expand);
   99   setOperationAction(ISD::STACKRESTORE, MVT::Other, Expand);
  101   setOperationAction(ISD::VASTART, MVT::Other, Custom);
  102   setOperationAction(ISD::VAARG, MVT::Other, Expand);
  103   setOperationAction(ISD::VACOPY, MVT::Other, Expand);
  104   setOperationAction(ISD::VAEND, MVT::Other, Expand);
  520     Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Copy, Chain);
  590   return DAG.getNode(Opc, DL, MVT::Other,
  706     Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
  733   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);

  348               CurDAG->getMachineNode(Opcode, SDLoc(N), VT, MVT::i16, MVT::Other,
  367       CurDAG->SelectNodeTo(Op, Opc, VT, MVT::i16, MVT::Other, Ops0);

   84   setOperationAction(ISD::BR_JT,            MVT::Other, Expand);
   87   setOperationAction(ISD::BRCOND,           MVT::Other, Expand);
   97   setOperationAction(ISD::STACKSAVE,        MVT::Other, Expand);
   98   setOperationAction(ISD::STACKRESTORE,     MVT::Other, Expand);
  142   setOperationAction(ISD::VASTART,          MVT::Other, Custom);
  143   setOperationAction(ISD::VAARG,            MVT::Other, Expand);
  144   setOperationAction(ISD::VAEND,            MVT::Other, Expand);
  145   setOperationAction(ISD::VACOPY,           MVT::Other, Expand);
  700       Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Copy, Chain);
  783   return DAG.getNode(Opc, dl, MVT::Other, RetOps);
  868     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
  889   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);

  130   setOperationAction(ISD::ATOMIC_FENCE,       MVT::Other, Expand);

  599   if (evt == MVT::Other || !evt.isSimple())

  347   setOperationAction(ISD::BR_JT,              MVT::Other, Expand);
  358   setOperationAction(ISD::BRCOND,             MVT::Other, Custom);
  459   setOperationAction(ISD::EH_RETURN, MVT::Other, Custom);
  461   setOperationAction(ISD::VASTART,           MVT::Other, Custom);
  462   setOperationAction(ISD::VAARG,             MVT::Other, Custom);
  463   setOperationAction(ISD::VACOPY,            MVT::Other, Expand);
  464   setOperationAction(ISD::VAEND,             MVT::Other, Expand);
  467   setOperationAction(ISD::STACKSAVE,         MVT::Other, Expand);
  468   setOperationAction(ISD::STACKRESTORE,      MVT::Other, Expand);
  498   setOperationAction(ISD::TRAP, MVT::Other, Legal);
 2436   return DAG.getNode(MipsISD::EH_RETURN, DL, MVT::Other, Chain,
 2448   return DAG.getNode(MipsISD::Sync, DL, MVT::Other, Op.getOperand(0),
 2540   SDVTList VTList = DAG.getVTList(VT, MVT::Other);
 2621   SDVTList VTList = DAG.getVTList(MVT::Other);
 3226     Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOpChains);
 3308   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
 3315     return DAG.getNode(MipsISD::TailCall, DL, MVT::Other, Ops);
 3596       Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Copy, Chain);
 3608     Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, OutChains);
 3645   return DAG.getNode(MipsISD::ERet, DL, MVT::Other, RetOps);
 3748   return DAG.getNode(MipsISD::Ret, DL, MVT::Other, RetOps);
 3927     if (VT == MVT::Other)
 3939     RC = getRegClassFor((VT == MVT::Other) ? MVT::v16i8 : VT);
 3942     RC = getRegClassFor((VT == MVT::Other) ? MVT::i32 : VT);

  206   setOperationAction(ISD::ATOMIC_FENCE,       MVT::Other, Custom);
  212   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
  213   setOperationAction(ISD::INTRINSIC_W_CHAIN, MVT::Other, Custom);
  214   setOperationAction(ISD::INTRINSIC_VOID, MVT::Other, Custom);
  259     setOperationAction(ISD::BRCOND, MVT::Other, Legal);
 1314   bool HasChainIn = Op->getOperand(0).getValueType() == MVT::Other;
 1355   assert(Val->getValueType(1) == MVT::Other);

  927                                      MVT::Other, Ops);
  940                                      MVT::Other, Ops);
  959                                      MVT::Other, Ops);
  978                                      MVT::Other, Ops);
 1288   InstVTs.push_back(MVT::Other);
 1790     NVPTXST = CurDAG->getMachineNode(Opcode.getValue(), dl, MVT::Other, Ops);
 1809     NVPTXST = CurDAG->getMachineNode(Opcode.getValue(), dl, MVT::Other, Ops);
 1835     NVPTXST = CurDAG->getMachineNode(Opcode.getValue(), dl, MVT::Other, Ops);
 1858     NVPTXST = CurDAG->getMachineNode(Opcode.getValue(), dl, MVT::Other, Ops);
 2085   ST = CurDAG->getMachineNode(Opcode.getValue(), DL, MVT::Other, StOps);
 2152     VTs = CurDAG->getVTList(EltVT, MVT::Other, MVT::Glue);
 2154     VTs = CurDAG->getVTList(EltVT, EltVT, MVT::Other, MVT::Glue);
 2156     EVT EVTs[] = { EltVT, EltVT, EltVT, EltVT, MVT::Other, MVT::Glue };
 2233   SDNode *Ret = CurDAG->getMachineNode(Opcode.getValue(), DL, MVT::Other, Ops);
 2335   SDVTList RetVTs = CurDAG->getVTList(MVT::Other, MVT::Glue);

  438   setOperationAction(ISD::BR_JT, MVT::Other, Expand);
  439   setOperationAction(ISD::BRIND, MVT::Other, Expand);
  446   setOperationAction(ISD::INTRINSIC_W_CHAIN, MVT::Other, Custom);
  480   setOperationAction(ISD::TRAP, MVT::Other, Legal);
 1470       SDVTList DeclareParamVTs = DAG.getVTList(MVT::Other, MVT::Glue);
 1560               Op, dl, DAG.getVTList(MVT::Other, MVT::Glue), StoreOperands,
 1586     SDVTList DeclareParamVTs = DAG.getVTList(MVT::Other, MVT::Glue);
 1615       SDVTList CopyParamVTs = DAG.getVTList(MVT::Other, MVT::Glue);
 1651       SDVTList DeclareRetVTs = DAG.getVTList(MVT::Other, MVT::Glue);
 1660       SDVTList DeclareRetVTs = DAG.getVTList(MVT::Other, MVT::Glue);
 1696     SDVTList ProtoVTs = DAG.getVTList(MVT::Other, MVT::Glue);
 1707   SDVTList PrintCallVTs = DAG.getVTList(MVT::Other, MVT::Glue);
 1720   SDVTList CallVoidVTs = DAG.getVTList(MVT::Other, MVT::Glue);
 1726   SDVTList CallArgBeginVTs = DAG.getVTList(MVT::Other, MVT::Glue);
 1738     SDVTList CallArgVTs = DAG.getVTList(MVT::Other, MVT::Glue);
 1744   SDVTList CallArgEndVTs = DAG.getVTList(MVT::Other, MVT::Glue);
 1752     SDVTList PrototypeVTs = DAG.getVTList(MVT::Other, MVT::Glue);
 1807         LoadVTs.push_back(MVT::Other);
 1865       DAG.getVTList(ProxyRegOps[i].getSimpleValueType(), MVT::Other, MVT::Glue),
 2396         DAG.getMemIntrinsicNode(Opcode, DL, DAG.getVTList(MVT::Other), Ops,
 2654     DAG.setRoot(DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains));
 2732       Chain = DAG.getMemIntrinsicNode(Op, dl, DAG.getVTList(MVT::Other),
 2741   return DAG.getNode(NVPTXISD::RET_FLAG, dl, MVT::Other, Chain);
 4846     LdResVTs = DAG.getVTList(EltVT, EltVT, MVT::Other);
 4850     EVT ListVTs[] = { EltVT, EltVT, EltVT, EltVT, MVT::Other };
 4862                      MVT::Other};
 4965         LdResVTs = DAG.getVTList(EltVT, EltVT, MVT::Other);
 4982         EVT ListVTs[] = { EltVT, EltVT, EltVT, EltVT, MVT::Other };
 5029       SDVTList LdResVTs = DAG.getVTList(MVT::i16, MVT::Other);

  278   if (Evt == MVT::Other || !Evt.isSimple()) return false;

 4434                                           MVT::Other, N->getOperand(0)));
 4521           PPCLowering->getPointerTy(CurDAG->getDataLayout()), MVT::Other, Ops);
 4561           PPCLowering->getPointerTy(CurDAG->getDataLayout()), MVT::Other, Ops);
 4993                          MVT::Other, Ops);
 5010     CurDAG->SelectNodeTo(N, PPC::BCC, MVT::Other, Ops);
 5042       CurDAG->SelectNodeTo(N, PPC::BC, MVT::Other, BitComp, N->getOperand(4),
 5053     CurDAG->SelectNodeTo(N, PPC::BCC, MVT::Other, Ops);
 5064     CurDAG->SelectNodeTo(N, Reg, MVT::Other, Chain);
 6029                                            MVT::Other,

  369     setOperationAction(ISD::BRCOND, MVT::Other, Expand);
  371   setOperationAction(ISD::BR_JT,  MVT::Other, Expand);
  409   setOperationAction(ISD::EH_SJLJ_LONGJMP, MVT::Other, Custom);
  425   setOperationAction(ISD::TRAP, MVT::Other, Legal);
  428   setOperationAction(ISD::INIT_TRAMPOLINE, MVT::Other, Custom);
  429   setOperationAction(ISD::ADJUST_TRAMPOLINE, MVT::Other, Custom);
  432   setOperationAction(ISD::VASTART           , MVT::Other, Custom);
  444     setOperationAction(ISD::VAARG, MVT::Other, Expand);
  447     setOperationAction(ISD::VAARG, MVT::Other, Custom);
  450     setOperationAction(ISD::VAARG, MVT::Other, Expand);
  454     setOperationAction(ISD::VACOPY            , MVT::Other, Custom);
  456     setOperationAction(ISD::VACOPY            , MVT::Other, Expand);
  459   setOperationAction(ISD::VAEND             , MVT::Other, Expand);
  460   setOperationAction(ISD::STACKSAVE         , MVT::Other, Expand);
  461   setOperationAction(ISD::STACKRESTORE      , MVT::Other, Custom);
  470   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
  478   setOperationAction(ISD::INTRINSIC_VOID, MVT::Other, Custom);
 1083     setOperationAction(ISD::PREFETCH, MVT::Other, Legal);
 2700       PPCISD::TOC_ENTRY, dl, DAG.getVTList(VT, MVT::Other), Ops, VT,
 3669     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
 4097     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
 4457     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
 4921     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains2);
 4959   NodeTys.push_back(MVT::Other);   // Returns a chain
 5108     NodeTys.push_back(MVT::Other);
 5261     return DAG.getNode(PPCISD::TC_RETURN, dl, MVT::Other, Ops);
 5614     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
 5628     SDVTList VTs = DAG.getVTList(MVT::Other, MVT::Glue);
 6282     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
 6676     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
 6955         RetOps.push_back(DAG.getRegister(*I, MVT::Other));
 6967   return DAG.getNode(PPCISD::RET_FLAG, dl, MVT::Other, RetOps);
 7076   SDVTList VTs = DAG.getVTList(PtrVT, MVT::Other);
 7095                      DAG.getVTList(MVT::i32, MVT::Other),
 7102   return DAG.getNode(PPCISD::EH_SJLJ_LONGJMP, DL, MVT::Other,
 7388               DAG.getVTList(MVT::Other), Ops, MVT::i32, MMO);
 7559   SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
 7560                            NewResChain, DAG.getUNDEF(MVT::Other));
 7824                                      DAG.getVTList(MVT::f64, MVT::Other),
 7834                                      DAG.getVTList(MVT::f64, MVT::Other),
 7868                                      dl, DAG.getVTList(MVT::f64, MVT::Other),
 7921                                  dl, DAG.getVTList(MVT::f64, MVT::Other),
 8115     MVT::v16i8, MVT::v8i16, MVT::Other, MVT::v4i32
 8118   EVT ReqVT = VT != MVT::Other ? VT : VTys[SplatSize-1];
 8133                                 const SDLoc &dl, EVT DestVT = MVT::Other) {
 8134   if (DestVT == MVT::Other) DestVT = Op.getValueType();
 8143                                 EVT DestVT = MVT::Other) {
 8144   if (DestVT == MVT::Other) DestVT = LHS.getValueType();
 8153                                 EVT DestVT = MVT::Other) {
 8154   if (DestVT == MVT::Other) DestVT = Op0.getValueType();
 8311       SDVTList VTs = DAG.getVTList({MVT::v4i1, /*chain*/ MVT::Other});
 8342       StoreChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Stores);
 8354     SDVTList VTs = DAG.getVTList({MVT::v4f64, /*chain*/ MVT::Other});
 8401                                   DAG.getVTList(Op.getValueType(), MVT::Other),
 8520       SDValue Res = BuildSplatI(i, SplatSize, MVT::Other, DAG, dl);
 8531       SDValue Res = BuildSplatI(i, SplatSize, MVT::Other, DAG, dl);
 8542       SDValue Res = BuildSplatI(i, SplatSize, MVT::Other, DAG, dl);
 8554       SDValue Res = BuildSplatI(i, SplatSize, MVT::Other, DAG, dl);
 8921         DAG.getVTList(IsFourByte ? MVT::v4i32 : MVT::v2i64, MVT::Other);
 9529     return SDValue(DAG.getMachineNode(PPC::CFENCE8, DL, MVT::Other,
 9600   SDVTList Tys = DAG.getVTList(MVT::i32, MVT::Other);
 9691   SDVTList VTs = DAG.getVTList(/*chain*/ MVT::Other);
 9761     SDValue TF =  DAG.getNode(ISD::TokenFactor, dl, MVT::Other, LoadChains);
 9791   LoadChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, VectElmtChains);
 9851     SDValue TF =  DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Stores);
 9890   SDVTList VTs = DAG.getVTList(/*chain*/ MVT::Other);
 9907   StoreChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, LoadChains);
 9920   StoreChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Stores);
10088           PPCISD::LD_VSX_LH, dl, DAG.getVTList(MVT::v4f32, MVT::Other), LoadOps,
10101         PPCISD::LD_VSX_LH, dl, DAG.getVTList(MVT::v4f32, MVT::Other), LoadOps,
10194     SDVTList VTs = DAG.getVTList(MVT::i32, MVT::i32, MVT::Other);
10211     SDVTList VTs = DAG.getVTList(SVT, MVT::Other);
13050                                          DAG.getVTList(MVT::f64, MVT::Other),
13164                                          DAG.getVTList(MVT::v2f64, MVT::Other),
13170       PPCISD::XXSWAPD, dl, DAG.getVTList(MVT::v2f64, MVT::Other), Chain, Load);
13178     return DAG.getNode(ISD::MERGE_VALUES, dl, DAG.getVTList(VecTy, MVT::Other),
13240                              DAG.getVTList(MVT::v2f64, MVT::Other), Chain, Src);
13245                                           DAG.getVTList(MVT::Other),
13301           DAG.getVTList(MVT::Other), Ops,
13348         PPCISD::LOAD_VEC_BE, dl, DAG.getVTList(VT, MVT::Other), LoadOps,
13357         PPCISD::STORE_VEC_BE, dl, DAG.getVTList(MVT::Other), StoreOps,
13466         DAG.getMemIntrinsicNode(PPCISD::STBRX, dl, DAG.getVTList(MVT::Other),
13702                                 DAG.getVTList(PermTy, MVT::Other),
13732                                 DAG.getVTList(PermTy, MVT::Other),
13735       SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
13899                                               MVT::i64 : MVT::i32, MVT::Other),
13983       return DAG.getNode(PPCISD::BDNZ, dl, MVT::Other,
14023       return DAG.getNode(isBDNZ ? PPCISD::BDNZ : PPCISD::BDZ, dl, MVT::Other,
14042         return DAG.getNode(ISD::BR, dl, MVT::Other,
14075       return DAG.getNode(PPCISD::COND_BRANCH, dl, MVT::Other, N->getOperand(0),

  418           if (EVTy == MVT::Other)

  164                                              MVT::i32, MVT::Other,

   86   setOperationAction(ISD::BR_JT, MVT::Other, Expand);
   91   setOperationAction(ISD::STACKSAVE, MVT::Other, Expand);
   92   setOperationAction(ISD::STACKRESTORE, MVT::Other, Expand);
   94   setOperationAction(ISD::VASTART, MVT::Other, Custom);
   95   setOperationAction(ISD::VAARG, MVT::Other, Expand);
   96   setOperationAction(ISD::VACOPY, MVT::Other, Expand);
   97   setOperationAction(ISD::VAEND, MVT::Other, Expand);
  196   setOperationAction(ISD::TRAP, MVT::Other, Legal);
  197   setOperationAction(ISD::DEBUGTRAP, MVT::Other, Legal);
  871     SDVTList VTs = DAG.getVTList(MVT::i32, MVT::i32, MVT::Other);
 2002     Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, OutChains);
 2248     Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOpChains);
 2312   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
 2470     return DAG.getNode(RetOpc, DL, MVT::Other, RetOps);
 2473   return DAG.getNode(RISCVISD::RET_FLAG, DL, MVT::Other, RetOps);

  316       CurDAG->getVTList(MVT::Other, MVT::Glue), AsmNodeOperands);

  287   return DAG.getNode(SPISD::RET_FLAG, DL, MVT::Other, RetOps);
  366   return DAG.getNode(SPISD::RET_FLAG, DL, MVT::Other, RetOps);
  531     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Copy, Chain);
  570       Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
  681     Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, OutChains);
  926     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
  951   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
 1229     Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOpChains);
 1276   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
 1535   setOperationAction(ISD::BRCOND, MVT::Other, Expand);
 1536   setOperationAction(ISD::BRIND, MVT::Other, Expand);
 1537   setOperationAction(ISD::BR_JT, MVT::Other, Expand);
 1590   setOperationAction(ISD::ATOMIC_FENCE, MVT::Other, Legal);
 1683   setOperationAction(ISD::VASTART           , MVT::Other, Custom);
 1685   setOperationAction(ISD::VAARG             , MVT::Other, Custom);
 1687   setOperationAction(ISD::TRAP              , MVT::Other, Legal);
 1688   setOperationAction(ISD::DEBUGTRAP         , MVT::Other, Legal);
 1691   setOperationAction(ISD::VACOPY            , MVT::Other, Expand);
 1692   setOperationAction(ISD::VAEND             , MVT::Other, Expand);
 1693   setOperationAction(ISD::STACKSAVE         , MVT::Other, Expand);
 1694   setOperationAction(ISD::STACKRESTORE      , MVT::Other, Expand);
 1806   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
 2056     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
 2460   return DAG.getNode(Opc, dl, MVT::Other, Chain, Dest,
 2610                               dl, MVT::Other, DAG.getEntryNode());
 2763   SDValue OutChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
 2813   return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
 3311       if (VT == MVT::f32 || VT == MVT::Other) {

 1200   SDNode *Res = CurDAG->getMachineNode(Opcode, DL, VT, MVT::Other, Ops);
 1234   ReplaceNode(Store, CurDAG->getMachineNode(Opcode, DL, MVT::Other, Ops));
 1312                                    MVT::Other, ChainOps);
 1391     CurDAG->getMachineNode(NewOpc, DL, MVT::i32, MVT::Other, Ops);

  147   setOperationAction(ISD::BR_JT, MVT::Other, Expand);
  150   setOperationAction(ISD::BRCOND, MVT::Other, Expand);
  244   setOperationAction(ISD::ATOMIC_FENCE, MVT::Other, Custom);
  247   setOperationAction(ISD::TRAP, MVT::Other, Legal);
  297   setOperationAction(ISD::STACKSAVE,    MVT::Other, Custom);
  298   setOperationAction(ISD::STACKRESTORE, MVT::Other, Custom);
  301   setOperationAction(ISD::PREFETCH, MVT::Other, Custom);
  602   setOperationAction(ISD::VASTART, MVT::Other, Custom);
  603   setOperationAction(ISD::VACOPY,  MVT::Other, Custom);
  604   setOperationAction(ISD::VAEND,   MVT::Other, Expand);
  623   setOperationAction(ISD::INTRINSIC_W_CHAIN, MVT::Other, Custom);
  624   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
 1428       Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
 1554     Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOpChains);
 1601   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
 1676     return DAG.getNode(SystemZISD::RET_FLAG, DL, MVT::Other, Chain);
 1704   return DAG.getNode(SystemZISD::RET_FLAG, DL, MVT::Other, RetOps);
 1906   SDVTList RawVTs = DAG.getVTList(MVT::i32, MVT::Other);
 2898   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
 3187   return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOps);
 3632     return SDValue(DAG.getMachineNode(SystemZ::Serialize, DL, MVT::Other,
 3638   return DAG.getNode(SystemZISD::MEMBARRIER, DL, MVT::Other, Op.getOperand(0));
 3661                                        MVT::Other, Chain), 0);
 3722   SDVTList VTList = DAG.getVTList(WideVT, MVT::Other);
 3791     SDVTList Tys = DAG.getVTList(WideVT, MVT::i32, MVT::Other);
 3825   SDVTList VTList = DAG.getVTList(WideVT, MVT::i32, MVT::Other);
 5073     SDVTList Tys = DAG.getVTList(MVT::Untyped, MVT::Other);
 5084     SDVTList Tys = DAG.getVTList(MVT::Other);
 5096                                        MVT::Other, Res), 0);
 5102     SDVTList Tys = DAG.getVTList(MVT::Untyped, MVT::i32, MVT::Other);
 5621         DAG.getMemIntrinsicNode(SystemZISD::STRV, SDLoc(N), DAG.getVTList(MVT::Other),
 5637                                      DAG.getVTList(MVT::Other),
 5665                                 DAG.getVTList(LD->getValueType(0), MVT::Other),
 5857                                 DAG.getVTList(LoadVT, MVT::Other),

   41     return DAG.getNode(Loop, DL, MVT::Other, Chain, Dst, Src,
   44   return DAG.getNode(Sequence, DL, MVT::Other, Chain, Dst, Src,
  108         return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chain1, Chain2);
  121         return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chain1, Chain2);
  147   SDVTList VTs = DAG.getVTList(MVT::i32, MVT::Other);
  199   SDVTList VTs = DAG.getVTList(PtrVT, MVT::i32, MVT::Other);
  224   SDVTList VTs = DAG.getVTList(Dest.getValueType(), MVT::Other);
  234   SDVTList VTs = DAG.getVTList(Src1.getValueType(), MVT::i32, MVT::Other);
  253   SDVTList VTs = DAG.getVTList(PtrVT, MVT::i32, MVT::Other);

   66   return MVT::Other;

  105                                      MVT::Other,         // outchain type
  115           MVT::Other,                                 // outchain type
  202           WebAssembly::GLOBAL_GET_I32, DL, MVT::i32, MVT::Other,

   75   setOperationAction(ISD::BRIND, MVT::Other, Custom);
   79   setOperationAction(ISD::VASTART, MVT::Other, Custom);
   80   setOperationAction(ISD::VAARG, MVT::Other, Expand);
   81   setOperationAction(ISD::VACOPY, MVT::Other, Expand);
   82   setOperationAction(ISD::VAEND, MVT::Other, Expand);
  212   setOperationAction(ISD::STACKSAVE, MVT::Other, Expand);
  213   setOperationAction(ISD::STACKRESTORE, MVT::Other, Expand);
  217   setOperationAction(ISD::CopyToReg, MVT::Other, Custom);
  225   setOperationAction(ISD::BR_JT, MVT::Other, Custom);
  262   setOperationAction(ISD::TRAP, MVT::Other, Legal);
  265   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
  266   setOperationAction(ISD::INTRINSIC_VOID, MVT::Other, Custom);
  784       Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chains);
  832     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
  836   InTys.push_back(MVT::Other);
  871   Chain = DAG.getNode(WebAssemblyISD::RETURN, DL, MVT::Other, RetOps);
 1180   return DAG.getNode(WebAssemblyISD::BR_TABLE, DL, MVT::Other, Ops);
 1240                        MVT::Other, // outchain type

   31   return DAG.getNode(WebAssemblyISD::MEMORY_COPY, DL, MVT::Other,
   56   return DAG.getNode(WebAssemblyISD::MEMORY_FILL, DL, MVT::Other, Chain, MemIdx,

  293   if (evt == MVT::Other || !evt.isSimple())

 2037     MVT VT = MVT::Other;
 2118     MVT VT = MVT::Other;
 2199     MVT VT = MVT::Other;

  732       CurDAG->getNode(ISD::TokenFactor, SDLoc(Load), MVT::Other, Ops);
 1212                                                      MVT::i32, MVT::Other, Ops);
 2915       CurDAG->getNode(ISD::TokenFactor, SDLoc(Chain), MVT::Other, ChainOps);
 3016                                       MVT::Other, Ops);
 3033                                         MVT::Other, Ops);
 3155       Result = CurDAG->getMachineNode(NewOpc, SDLoc(Node), MVT::i32, MVT::Other,
 3160       Result = CurDAG->getMachineNode(NewOpc, SDLoc(Node), MVT::i32, MVT::Other,
 3549     SDVTList VTs = CurDAG->getVTList(NVT, MVT::i32, MVT::Other);
 3585     SDVTList VTs = CurDAG->getVTList(VT, MVT::i32, MVT::Other);
 3618     SDVTList VTs = CurDAG->getVTList(VT, MVT::i32, MVT::Other, MVT::Glue);
 4264     SDVTList VTs = CurDAG->getVTList(MaskVT, MVT::Other);
 4408         MachineSDNode *CNode = CurDAG->getMachineNode(Opc, dl, MVT::Other,
 4430       SDValue Brind = CurDAG->getNode(ISD::BRIND, dl, MVT::Other,
 4605         SDVTList VTs = CurDAG->getVTList(NVT, MVT::i32, MVT::Other);
 4673         VTs = CurDAG->getVTList(NVT, MVT::i32, MVT::Other);
 4675         VTs = CurDAG->getVTList(NVT, NVT, MVT::i32, MVT::Other);
 4753       SDVTList VTs = CurDAG->getVTList(MVT::Other, MVT::Glue);
 4856         Move = CurDAG->getMachineNode(Opc, dl, MVT::i16, MVT::Other, Ops);
 4914         CurDAG->getMachineNode(MOpc, dl, MVT::Other, MVT::Glue, Ops);
 5099         NewNode = CurDAG->getMachineNode(MOpc, dl, MVT::i32, MVT::Other, Ops);

  318   setOperationAction(ISD::BR_JT            , MVT::Other, Expand);
  319   setOperationAction(ISD::BRCOND           , MVT::Other, Custom);
  430   setOperationAction(ISD::EH_RETURN       , MVT::Other, Custom);
  434   setOperationAction(ISD::EH_SJLJ_LONGJMP, MVT::Other, Custom);
  435   setOperationAction(ISD::EH_SJLJ_SETUP_DISPATCH, MVT::Other, Custom);
  461     setOperationAction(ISD::PREFETCH      , MVT::Other, Legal);
  463   setOperationAction(ISD::ATOMIC_FENCE  , MVT::Other, Custom);
  487     setOperationAction(ISD::EH_LABEL, MVT::Other, Expand);
  493   setOperationAction(ISD::INIT_TRAMPOLINE, MVT::Other, Custom);
  494   setOperationAction(ISD::ADJUST_TRAMPOLINE, MVT::Other, Custom);
  496   setOperationAction(ISD::TRAP, MVT::Other, Legal);
  497   setOperationAction(ISD::DEBUGTRAP, MVT::Other, Legal);
  500   setOperationAction(ISD::VASTART           , MVT::Other, Custom);
  501   setOperationAction(ISD::VAEND             , MVT::Other, Expand);
  503   setOperationAction(ISD::VAARG,  MVT::Other, Is64Bit ? Custom : Expand);
  504   setOperationAction(ISD::VACOPY, MVT::Other, Is64Bit ? Custom : Expand);
  506   setOperationAction(ISD::STACKSAVE,          MVT::Other, Expand);
  507   setOperationAction(ISD::STACKRESTORE,       MVT::Other, Expand);
  512   setOperationAction(ISD::GC_TRANSITION_START, MVT::Other, Custom);
  513   setOperationAction(ISD::GC_TRANSITION_END, MVT::Other, Custom);
 1770   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
 1771   setOperationAction(ISD::INTRINSIC_W_CHAIN, MVT::Other, Custom);
 1772   setOperationAction(ISD::INTRINSIC_VOID, MVT::Other, Custom);
 2666   return DAG.getNode(opcode, dl, MVT::Other, RetOps);
 3332       Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Copy, Chain);
 3435                                    MVT::Other, SaveXMMOps));
 3439       Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
 3444     MVT VecVT = MVT::Other;
 3459     if (VecVT != MVT::Other)
 3853     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
 3976       Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains2);
 4013   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
 7983       SDVTList Tys = DAG.getVTList(VecVT, MVT::Other);
17939   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
18139     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
18480     Tys = DAG.getVTList(MVT::f64, MVT::Other, MVT::Glue);
18482     Tys = DAG.getVTList(Op.getValueType(), MVT::Other);
18514     Tys = DAG.getVTList(MVT::Other);
18862   SDVTList Tys = DAG.getVTList(MVT::f80, MVT::Other);
19000     SDVTList Tys = DAG.getVTList(TheVT, MVT::Other);
19016                                          DAG.getVTList(MVT::Other),
19898   EVT VT = MVT::Other;
21791   return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Ch0, Ch1);
21827   return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Stores);
21895   SDVTList Tys = DAG.getVTList(MVT::Other);
22250     SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
22329   return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOps);
22378   SDVTList VTs = DAG.getVTList(getPointerTy(DAG.getDataLayout()), MVT::Other);
23600     SDVTList VTs = DAG.getVTList(MVT::Untyped, MVT::Other);
23684   SDVTList VTs = DAG.getVTList(Op.getValueType(), MaskVT, MVT::Other);
23721   SDVTList VTs = DAG.getVTList(Op.getValueType(), MaskVT, MVT::Other);
23759   SDVTList VTs = DAG.getVTList(MaskVT, MVT::Other);
23784   SDNode *Res = DAG.getMachineNode(Opc, dl, MVT::Other, Ops);
23811   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
23923   SDVTList VTs = DAG.getVTList(MVT::Other);
23937   SDVTList VTs = DAG.getVTList(MVT::Other);
23956       SDVTList VTs = DAG.getVTList(MVT::i32, MVT::Other);
23965       return DAG.getNode(X86ISD::WRPKRU, dl, MVT::Other,
23988       SDVTList VTs = DAG.getVTList(MVT::i32, MVT::Other);
24016       SDVTList VTs = DAG.getVTList(MVT::i32, MVT::Other);
24043     SDVTList VTs = DAG.getVTList(Op->getValueType(0), MVT::i32, MVT::Other);
24125     SDVTList VTs = DAG.getVTList(Op->getValueType(0), MVT::Other);
24330   return DAG.getNode(X86ISD::EH_RETURN, dl, MVT::Other, Chain,
24348                      DAG.getVTList(MVT::i32, MVT::Other),
24355   return DAG.getNode(X86ISD::EH_SJLJ_LONGJMP, DL, MVT::Other,
24362   return DAG.getNode(X86ISD::EH_SJLJ_SETUP_DISPATCH, DL, MVT::Other,
24432     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
24514     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
24556                                           DAG.getVTList(MVT::Other),
26647                                      MVT::Other, Ops);
26662                                    MVT::Other, Ops);
26679       return DAG.getNode(X86ISD::MFENCE, dl, MVT::Other, Op.getOperand(0));
26686   return DAG.getNode(X86ISD::MEMBARRIER, dl, MVT::Other, Op.getOperand(0));
26712   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
27129       NewOpc, SDLoc(N), DAG.getVTList(MVT::i32, MVT::Other),
27184     SDValue NewChain = DAG.getNode(X86ISD::MEMBARRIER, DL, MVT::Other, Chain);
27224       SDVTList Tys = DAG.getVTList(MVT::Other);
27408       SDVTList VTs = DAG.getVTList(MVT::v2i1, MVT::Other);
27443   SDVTList VTs = DAG.getVTList(MaskVT, MVT::Other);
27603       DAG.getVTList(VT, MaskVT, MVT::Other), Ops, dl, N->getMemoryVT(),
27625   SDVTList VTs = DAG.getVTList(MVT::Other, MVT::Glue);
27646   SDVTList VTs = DAG.getVTList(MVT::Other, MVT::Glue);
28311     SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
28371         SDVTList Tys = DAG.getVTList(MVT::v2i64, MVT::Other);
28385         SDVTList Tys = DAG.getVTList(MVT::f80, MVT::Other, MVT::Glue);
28403                                         DAG.getVTList(MVT::Other), StoreOps,
28504         DAG.getVTList(WideVT, Mask.getValueType(), MVT::Other), Ops, dl,
28538     SDVTList Tys = DAG.getVTList(MVT::v4f32, MVT::Other);
33517       SDVTList Tys = DAG.getVTList(VT, MVT::Other);
34238       SDVTList Tys = DAG.getVTList(VT, MVT::Other);
35554     SDVTList Tys = DAG.getVTList(VT, MVT::Other);
40239     SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
40557       return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Ch0, Ch1);
40723     return DAG.getNode(ISD::TokenFactor, StDL, MVT::Other, LoSt, HiSt);
42001       SDVTList Tys = DAG.getVTList(LoadVT, MVT::Other);
42036       SDVTList Tys = DAG.getVTList(LoadVT, MVT::Other);
44507     SDVTList Tys = DAG.getVTList(OpVT, MVT::Other);
44691       SDVTList Tys = DAG.getVTList(VT, MVT::Other);
45095     return DAG.getNode(X86ISD::NT_BRIND, dl, MVT::Other, Value, Addr);
46029   if (TRI->isTypeLegalForClass(*Res.second, VT) || VT == MVT::Other)

 5653     Load = DAG.getMachineNode(Opc, dl, VT, MVT::Other, AddrOps);
 5669     if (VT != MVT::Other && i >= (unsigned)MCID.getNumDefs())
 5718                            dl, MVT::Other, AddrOps);

  162   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
  202   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
  289   return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Results);

  150                                             MVT::Other, CPIdx,
  234   return CurDAG->getNode(ISD::TokenFactor, SDLoc(Chain), MVT::Other, Ops);
  274     CurDAG->SelectNodeTo(N, XCore::BRFU_lu6, MVT::Other,
  278   CurDAG->SelectNodeTo(N, XCore::BAU_1r, MVT::Other, nextAddr, Glue);

  110   setOperationAction(ISD::TRAP, MVT::Other, Legal);
  113   setOperationAction(ISD::BR_JT, MVT::Other, Custom);
  136   setOperationAction(ISD::VAEND, MVT::Other, Expand);
  137   setOperationAction(ISD::VACOPY, MVT::Other, Expand);
  138   setOperationAction(ISD::VAARG, MVT::Other, Custom);
  139   setOperationAction(ISD::VASTART, MVT::Other, Custom);
  142   setOperationAction(ISD::STACKSAVE, MVT::Other, Expand);
  143   setOperationAction(ISD::STACKRESTORE, MVT::Other, Expand);
  147   setOperationAction(ISD::EH_RETURN, MVT::Other, Custom);
  153   setOperationAction(ISD::ATOMIC_FENCE, MVT::Other, Custom);
  158   setOperationAction(ISD::INIT_TRAMPOLINE, MVT::Other, Custom);
  159   setOperationAction(ISD::ADJUST_TRAMPOLINE, MVT::Other, Custom);
  162   setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
  357     return DAG.getNode(XCoreISD::BR_JT, dl, MVT::Other, Chain, TargetJT, Index);
  362   return DAG.getNode(XCoreISD::BR_JT32, dl, MVT::Other, Chain, TargetJT,
  397   Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Low.getValue(1),
  458     Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Low.getValue(1),
  512     return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, StoreLow, StoreHigh);
  846   Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
  848   return DAG.getNode(XCoreISD::EH_RETURN, dl, MVT::Other, Chain,
  910   return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
  933   return DAG.getNode(XCoreISD::MEMBARRIER, DL, MVT::Other, Op.getOperand(0));
 1087     SDVTList VTs = DAG.getVTList(MVT::i32, MVT::Other);
 1097     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
 1169       MemOpChains.push_back(DAG.getNode(XCoreISD::STWSP, dl, MVT::Other,
 1179     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
 1204   SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
 1382     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, CFRegNode);
 1411     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
 1493     Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
 1515   return DAG.getNode(XCoreISD::RETSP, dl, MVT::Other, RetOps);

   93     MVT T = I.second.empty() ? MVT::Other : *I.second.begin();
  111   MVT DT = MVT::Other;
 1367       if (T0.getMachineValueType() != MVT::Other) {
 1736   return MVT::Other;
 1796     if (InstInfo.HasOneImplicitDefWithKnownVT(CDP.getTargetInfo()) !=MVT::Other)
 2155       return TypeSetByHwMode(MVT::Other);
 2170     return TypeSetByHwMode(MVT::Other);
 2200   return TypeSetByHwMode(MVT::Other);
 2453       if (VT != MVT::Other)

  447   if (ImplicitDefs.empty()) return MVT::Other;
  456   return MVT::Other;

   51   case MVT::Other:   return "UNKNOWN";
   60   case MVT::Other:    return "MVT::Other";

   85     MVT LHSVT = LT->getNumTypes() != 0 ? LT->getSimpleType(0) : MVT::Other;
   86     MVT RHSVT = RT->getNumTypes() != 0 ? RT->getSimpleType(0) : MVT::Other;

  366     if (NodeType != MVT::Other)

   26   MVT::SimpleValueType VT = MVT::Other;
  898     if (II.HasOneImplicitDefWithKnownVT(CGT) != MVT::Other)
  967     if (ResultVTs[i] == MVT::Other || ResultVTs[i] == MVT::Glue) break;
 1040       if (II.HasOneImplicitDefWithKnownVT(CGT) != MVT::Other)

  255   case MVT::Other: return Sig.push_back(IIT_EMPTYSTRUCT);