projects / oota-llvm.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
This commit changes:
[oota-llvm.git] / lib / Target / TargetSelectionDAG.td
diff --git a/lib/Target/TargetSelectionDAG.td b/lib/Target/TargetSelectionDAG.td
index 554991564bcf06524f0c6771e82bf2e3bee62db0..2560d86f52df8c7206ee047c8be095c5c17f11ad 100644 (file)
--- a/lib/Target/TargetSelectionDAG.td
+++ b/lib/Target/TargetSelectionDAG.td
@@ -2,8 +2,8 @@
 // 
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 // 
 //===----------------------------------------------------------------------===//
 //
@@ -52,7 +52,7 @@ class SDTCisOpSmallerThanOp<int SmallOp, int BigOp> : SDTypeConstraint<SmallOp>{
 }
 
 /// SDTCisIntVectorOfSameSize - This indicates that ThisOp and OtherOp are
-/// packed vector types, and that ThisOp is the result of 
+/// vector types, and that ThisOp is the result of 
 /// MVT::getIntVectorWithNumElements with the number of elements that ThisOp
 /// has.
 class SDTCisIntVectorOfSameSize<int ThisOp, int OtherOp>
@@ -154,7 +154,7 @@ def SDTBrind : SDTypeProfile<0, 1, [ // brind
   SDTCisPtrTy<0>
 ]>;
 
-def SDTRet : SDTypeProfile<0, 0, []>; // ret
+def SDTNone : SDTypeProfile<0, 0, []>; // ret, trap
 
 def SDTLoad : SDTypeProfile<1, 1, [ // load
   SDTCisPtrTy<1>  
@@ -172,6 +172,11 @@ def SDTVecShuffle : SDTypeProfile<1, 3, [
   SDTCisSameAs<0, 1>, SDTCisSameAs<1, 2>, SDTCisIntVectorOfSameSize<3, 0>
 ]>;
 
+class SDCallSeqStart<list<SDTypeConstraint> constraints> :
+        SDTypeProfile<0, 1, constraints>;
+class SDCallSeqEnd<list<SDTypeConstraint> constraints> :
+        SDTypeProfile<0, 2, constraints>;
+
 //===----------------------------------------------------------------------===//
 // Selection DAG Node Properties.
 //
@@ -184,6 +189,9 @@ def SDNPHasChain    : SDNodeProperty;   // R/W chain operand and result
 def SDNPOutFlag     : SDNodeProperty;   // Write a flag result
 def SDNPInFlag      : SDNodeProperty;   // Read a flag operand
 def SDNPOptInFlag   : SDNodeProperty;   // Optionally read a flag operand
+def SDNPMayStore    : SDNodeProperty;   // May write to memory, sets 'mayStore'.
+def SDNPMayLoad     : SDNodeProperty;   // May read memory, sets 'mayLoad'.
+def SDNPSideEffect  : SDNodeProperty;   // Sets 'HasUnmodelledSideEffects'.
 
 //===----------------------------------------------------------------------===//
 // Selection DAG Node definitions.
@@ -197,6 +205,8 @@ class SDNode<string opcode, SDTypeProfile typeprof,
 }
 
 def set;
+def implicit;
+def parallel;
 def node;
 def srcvalue;
 
@@ -211,6 +221,10 @@ def globaladdr : SDNode<"ISD::GlobalAddress",         SDTPtrLeaf, [],
                         "GlobalAddressSDNode">;
 def tglobaladdr : SDNode<"ISD::TargetGlobalAddress",  SDTPtrLeaf, [],
                          "GlobalAddressSDNode">;
+def globaltlsaddr : SDNode<"ISD::GlobalTLSAddress",         SDTPtrLeaf, [],
+                          "GlobalAddressSDNode">;
+def tglobaltlsaddr : SDNode<"ISD::TargetGlobalTLSAddress",  SDTPtrLeaf, [],
+                           "GlobalAddressSDNode">;
 def constpool   : SDNode<"ISD::ConstantPool",         SDTPtrLeaf, [],
                          "ConstantPoolSDNode">;
 def tconstpool  : SDNode<"ISD::TargetConstantPool",   SDTPtrLeaf, [],
@@ -297,13 +311,18 @@ def selectcc   : SDNode<"ISD::SELECT_CC"  , SDTSelectCC>;
 def brcond     : SDNode<"ISD::BRCOND"     , SDTBrcond, [SDNPHasChain]>;
 def brind      : SDNode<"ISD::BRIND"      , SDTBrind,  [SDNPHasChain]>;
 def br         : SDNode<"ISD::BR"         , SDTBr,     [SDNPHasChain]>;
-def ret        : SDNode<"ISD::RET"        , SDTRet,    [SDNPHasChain]>;
+def ret        : SDNode<"ISD::RET"        , SDTNone,   [SDNPHasChain]>;
+def trap       : SDNode<"ISD::TRAP"       , SDTNone,
+                        [SDNPHasChain, SDNPSideEffect]>;
 
 // Do not use ld, st directly. Use load, extload, sextload, zextload, store,
 // and truncst (see below).
-def ld         : SDNode<"ISD::LOAD"       , SDTLoad,  [SDNPHasChain]>;
-def st         : SDNode<"ISD::STORE"      , SDTStore, [SDNPHasChain]>;
-def ist        : SDNode<"ISD::STORE"      , SDTIStore, [SDNPHasChain]>;
+def ld         : SDNode<"ISD::LOAD"       , SDTLoad,
+                        [SDNPHasChain, SDNPMayLoad]>;
+def st         : SDNode<"ISD::STORE"      , SDTStore,
+                        [SDNPHasChain, SDNPMayStore]>;
+def ist        : SDNode<"ISD::STORE"      , SDTIStore,
+                        [SDNPHasChain, SDNPMayStore]>;
 
 def vector_shuffle : SDNode<"ISD::VECTOR_SHUFFLE", SDTVecShuffle, []>;
 def build_vector : SDNode<"ISD::BUILD_VECTOR", SDTypeProfile<1, 0, []>, []>;
@@ -313,6 +332,11 @@ def vector_extract : SDNode<"ISD::EXTRACT_VECTOR_ELT",
     SDTypeProfile<1, 2, [SDTCisPtrTy<2>]>, []>;
 def vector_insert : SDNode<"ISD::INSERT_VECTOR_ELT",
     SDTypeProfile<1, 3, [SDTCisSameAs<0, 1>, SDTCisPtrTy<3>]>, []>;
+    
+def extract_subreg : SDNode<"ISD::EXTRACT_SUBREG", 
+    SDTypeProfile<1, 2, []>>;
+def insert_subreg : SDNode<"ISD::INSERT_SUBREG", 
+    SDTypeProfile<1, 3, []>>;
 
 // Nodes for intrinsics, you should use the intrinsic itself and let tblgen use
 // these internally.  Don't reference these directly.
@@ -389,15 +413,18 @@ def immAllOnes : PatLeaf<(imm), [{ return N->isAllOnesValue(); }]>;
 def immAllOnesV: PatLeaf<(build_vector), [{
   return ISD::isBuildVectorAllOnes(N);
 }]>;
+def immAllOnesV_bc: PatLeaf<(bitconvert), [{
+  return ISD::isBuildVectorAllOnes(N);
+}]>;
 def immAllZerosV: PatLeaf<(build_vector), [{
   return ISD::isBuildVectorAllZeros(N);
 }]>;
-
-def immAllOnesV_bc: PatLeaf<(bitconvert), [{
-  return ISD::isBuildVectorAllOnes(N);
+def immAllZerosV_bc: PatLeaf<(bitconvert), [{
+  return ISD::isBuildVectorAllZeros(N);
 }]>;
 
 
+
 // Other helper fragments.
 def not  : PatFrag<(ops node:$in), (xor node:$in, immAllOnes)>;
 def vnot : PatFrag<(ops node:$in), (xor node:$in, immAllOnesV)>;
@@ -408,7 +435,7 @@ def ineg : PatFrag<(ops node:$in), (sub 0, node:$in)>;
 def load : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N))
     return LD->getExtensionType() == ISD::NON_EXTLOAD &&
-      LD->getAddressingMode() == ISD::UNINDEXED;
+           LD->getAddressingMode() == ISD::UNINDEXED;
   return false;
 }]>;
 
@@ -416,94 +443,101 @@ def load : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
 def extloadi1  : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N))
     return LD->getExtensionType() == ISD::EXTLOAD &&
-      LD->getAddressingMode() == ISD::UNINDEXED &&
-      LD->getLoadedVT() == MVT::i1;
+           LD->getAddressingMode() == ISD::UNINDEXED &&
+           LD->getLoadedVT() == MVT::i1;
   return false;
 }]>;
 def extloadi8  : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N))
     return LD->getExtensionType() == ISD::EXTLOAD &&
-      LD->getAddressingMode() == ISD::UNINDEXED &&
-      LD->getLoadedVT() == MVT::i8;
+           LD->getAddressingMode() == ISD::UNINDEXED &&
+           LD->getLoadedVT() == MVT::i8;
   return false;
 }]>;
 def extloadi16 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N))
     return LD->getExtensionType() == ISD::EXTLOAD &&
-      LD->getAddressingMode() == ISD::UNINDEXED &&
-      LD->getLoadedVT() == MVT::i16;
+           LD->getAddressingMode() == ISD::UNINDEXED &&
+           LD->getLoadedVT() == MVT::i16;
   return false;
 }]>;
 def extloadi32 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N))
     return LD->getExtensionType() == ISD::EXTLOAD &&
-      LD->getAddressingMode() == ISD::UNINDEXED &&
-      LD->getLoadedVT() == MVT::i32;
+           LD->getAddressingMode() == ISD::UNINDEXED &&
+           LD->getLoadedVT() == MVT::i32;
   return false;
 }]>;
 def extloadf32 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N))
     return LD->getExtensionType() == ISD::EXTLOAD &&
-      LD->getAddressingMode() == ISD::UNINDEXED &&
-      LD->getLoadedVT() == MVT::f32;
+           LD->getAddressingMode() == ISD::UNINDEXED &&
+           LD->getLoadedVT() == MVT::f32;
+  return false;
+}]>;
+def extloadf64 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
+  if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N))
+    return LD->getExtensionType() == ISD::EXTLOAD &&
+           LD->getAddressingMode() == ISD::UNINDEXED &&
+           LD->getLoadedVT() == MVT::f64;
   return false;
 }]>;
 
 def sextloadi1  : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N))
     return LD->getExtensionType() == ISD::SEXTLOAD &&
-      LD->getAddressingMode() == ISD::UNINDEXED &&
-      LD->getLoadedVT() == MVT::i1;
+           LD->getAddressingMode() == ISD::UNINDEXED &&
+           LD->getLoadedVT() == MVT::i1;
   return false;
 }]>;
 def sextloadi8  : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N))
     return LD->getExtensionType() == ISD::SEXTLOAD &&
-      LD->getAddressingMode() == ISD::UNINDEXED &&
-      LD->getLoadedVT() == MVT::i8;
+           LD->getAddressingMode() == ISD::UNINDEXED &&
+           LD->getLoadedVT() == MVT::i8;
   return false;
 }]>;
 def sextloadi16 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N))
     return LD->getExtensionType() == ISD::SEXTLOAD &&
-      LD->getAddressingMode() == ISD::UNINDEXED &&
-      LD->getLoadedVT() == MVT::i16;
+           LD->getAddressingMode() == ISD::UNINDEXED &&
+           LD->getLoadedVT() == MVT::i16;
   return false;
 }]>;
 def sextloadi32 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N))
     return LD->getExtensionType() == ISD::SEXTLOAD &&
-      LD->getAddressingMode() == ISD::UNINDEXED &&
-      LD->getLoadedVT() == MVT::i32;
+           LD->getAddressingMode() == ISD::UNINDEXED &&
+           LD->getLoadedVT() == MVT::i32;
   return false;
 }]>;
 
 def zextloadi1  : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N))
     return LD->getExtensionType() == ISD::ZEXTLOAD &&
-      LD->getAddressingMode() == ISD::UNINDEXED &&
-      LD->getLoadedVT() == MVT::i1;
+           LD->getAddressingMode() == ISD::UNINDEXED &&
+           LD->getLoadedVT() == MVT::i1;
   return false;
 }]>;
 def zextloadi8  : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N))
     return LD->getExtensionType() == ISD::ZEXTLOAD &&
-      LD->getAddressingMode() == ISD::UNINDEXED &&
-      LD->getLoadedVT() == MVT::i8;
+           LD->getAddressingMode() == ISD::UNINDEXED &&
+           LD->getLoadedVT() == MVT::i8;
   return false;
 }]>;
 def zextloadi16 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N))
     return LD->getExtensionType() == ISD::ZEXTLOAD &&
-      LD->getAddressingMode() == ISD::UNINDEXED &&
-      LD->getLoadedVT() == MVT::i16;
+           LD->getAddressingMode() == ISD::UNINDEXED &&
+           LD->getLoadedVT() == MVT::i16;
   return false;
 }]>;
 def zextloadi32 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N))
     return LD->getExtensionType() == ISD::ZEXTLOAD &&
-      LD->getAddressingMode() == ISD::UNINDEXED &&
-      LD->getLoadedVT() == MVT::i32;
+           LD->getAddressingMode() == ISD::UNINDEXED &&
+           LD->getLoadedVT() == MVT::i32;
   return false;
 }]>;
 
@@ -511,39 +545,45 @@ def zextloadi32 : PatFrag<(ops node:$ptr), (ld node:$ptr), [{
 def store : PatFrag<(ops node:$val, node:$ptr),
                     (st node:$val, node:$ptr), [{
   if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N))
-    return !ST->isTruncatingStore();
+    return !ST->isTruncatingStore() &&
+           ST->getAddressingMode() == ISD::UNINDEXED;
   return false;
 }]>;
 
 // truncstore fragments.
-def truncstorei1 : PatFrag<(ops node:$val, node:$ptr),
-                           (st node:$val, node:$ptr), [{
-  if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N))
-    return ST->isTruncatingStore() && ST->getStoredVT() == MVT::i1;
-  return false;
-}]>;
 def truncstorei8 : PatFrag<(ops node:$val, node:$ptr),
                            (st node:$val, node:$ptr), [{
   if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N))
-    return ST->isTruncatingStore() && ST->getStoredVT() == MVT::i8;
+    return ST->isTruncatingStore() && ST->getStoredVT() == MVT::i8 &&
+           ST->getAddressingMode() == ISD::UNINDEXED;
   return false;
 }]>;
 def truncstorei16 : PatFrag<(ops node:$val, node:$ptr),
                             (st node:$val, node:$ptr), [{
   if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N))
-    return ST->isTruncatingStore() && ST->getStoredVT() == MVT::i16;
+    return ST->isTruncatingStore() && ST->getStoredVT() == MVT::i16 &&
+           ST->getAddressingMode() == ISD::UNINDEXED;
   return false;
 }]>;
 def truncstorei32 : PatFrag<(ops node:$val, node:$ptr),
                             (st node:$val, node:$ptr), [{
   if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N))
-    return ST->isTruncatingStore() && ST->getStoredVT() == MVT::i32;
+    return ST->isTruncatingStore() && ST->getStoredVT() == MVT::i32 &&
+           ST->getAddressingMode() == ISD::UNINDEXED;
   return false;
 }]>;
 def truncstoref32 : PatFrag<(ops node:$val, node:$ptr),
                             (st node:$val, node:$ptr), [{
   if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N))
-    return ST->isTruncatingStore() && ST->getStoredVT() == MVT::f32;
+    return ST->isTruncatingStore() && ST->getStoredVT() == MVT::f32 &&
+           ST->getAddressingMode() == ISD::UNINDEXED;
+  return false;
+}]>;
+def truncstoref64 : PatFrag<(ops node:$val, node:$ptr),
+                            (st node:$val, node:$ptr), [{
+  if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N))
+    return ST->isTruncatingStore() && ST->getStoredVT() == MVT::f64 &&
+           ST->getAddressingMode() == ISD::UNINDEXED;
   return false;
 }]>;
 
@@ -551,7 +591,7 @@ def truncstoref32 : PatFrag<(ops node:$val, node:$ptr),
 def pre_store : PatFrag<(ops node:$val, node:$base, node:$offset),
                         (ist node:$val, node:$base, node:$offset), [{
   if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) {
-    ISD::MemOpAddrMode AM = ST->getAddressingMode();
+    ISD::MemIndexedMode AM = ST->getAddressingMode();
     return (AM == ISD::PRE_INC || AM == ISD::PRE_DEC) &&
            !ST->isTruncatingStore();
   }
@@ -561,7 +601,7 @@ def pre_store : PatFrag<(ops node:$val, node:$base, node:$offset),
 def pre_truncsti1 : PatFrag<(ops node:$val, node:$base, node:$offset),
                             (ist node:$val, node:$base, node:$offset), [{
   if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) {
-    ISD::MemOpAddrMode AM = ST->getAddressingMode();
+    ISD::MemIndexedMode AM = ST->getAddressingMode();
     return (AM == ISD::PRE_INC || AM == ISD::PRE_DEC) &&
            ST->isTruncatingStore() && ST->getStoredVT() == MVT::i1;
   }
@@ -570,7 +610,7 @@ def pre_truncsti1 : PatFrag<(ops node:$val, node:$base, node:$offset),
 def pre_truncsti8 : PatFrag<(ops node:$val, node:$base, node:$offset),
                             (ist node:$val, node:$base, node:$offset), [{
   if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) {
-    ISD::MemOpAddrMode AM = ST->getAddressingMode();
+    ISD::MemIndexedMode AM = ST->getAddressingMode();
     return (AM == ISD::PRE_INC || AM == ISD::PRE_DEC) &&
            ST->isTruncatingStore() && ST->getStoredVT() == MVT::i8;
   }
@@ -579,7 +619,7 @@ def pre_truncsti8 : PatFrag<(ops node:$val, node:$base, node:$offset),
 def pre_truncsti16 : PatFrag<(ops node:$val, node:$base, node:$offset),
                              (ist node:$val, node:$base, node:$offset), [{
   if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) {
-    ISD::MemOpAddrMode AM = ST->getAddressingMode();
+    ISD::MemIndexedMode AM = ST->getAddressingMode();
     return (AM == ISD::PRE_INC || AM == ISD::PRE_DEC) &&
            ST->isTruncatingStore() && ST->getStoredVT() == MVT::i16;
   }
@@ -588,7 +628,7 @@ def pre_truncsti16 : PatFrag<(ops node:$val, node:$base, node:$offset),
 def pre_truncsti32 : PatFrag<(ops node:$val, node:$base, node:$offset),
                              (ist node:$val, node:$base, node:$offset), [{
   if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) {
-    ISD::MemOpAddrMode AM = ST->getAddressingMode();
+    ISD::MemIndexedMode AM = ST->getAddressingMode();
     return (AM == ISD::PRE_INC || AM == ISD::PRE_DEC) &&
            ST->isTruncatingStore() && ST->getStoredVT() == MVT::i32;
   }
@@ -597,7 +637,7 @@ def pre_truncsti32 : PatFrag<(ops node:$val, node:$base, node:$offset),
 def pre_truncstf32 : PatFrag<(ops node:$val, node:$base, node:$offset),
                              (ist node:$val, node:$base, node:$offset), [{
   if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) {
-    ISD::MemOpAddrMode AM = ST->getAddressingMode();
+    ISD::MemIndexedMode AM = ST->getAddressingMode();
     return (AM == ISD::PRE_INC || AM == ISD::PRE_DEC) &&
            ST->isTruncatingStore() && ST->getStoredVT() == MVT::f32;
   }
@@ -607,7 +647,7 @@ def pre_truncstf32 : PatFrag<(ops node:$val, node:$base, node:$offset),
 def post_store : PatFrag<(ops node:$val, node:$ptr, node:$offset),
                          (ist node:$val, node:$ptr, node:$offset), [{
   if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) {
-    ISD::MemOpAddrMode AM = ST->getAddressingMode();
+    ISD::MemIndexedMode AM = ST->getAddressingMode();
     return !ST->isTruncatingStore() &&
             (AM == ISD::POST_INC || AM == ISD::POST_DEC);
   }
@@ -617,7 +657,7 @@ def post_store : PatFrag<(ops node:$val, node:$ptr, node:$offset),
 def post_truncsti1 : PatFrag<(ops node:$val, node:$base, node:$offset),
                              (ist node:$val, node:$base, node:$offset), [{
   if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) {
-    ISD::MemOpAddrMode AM = ST->getAddressingMode();
+    ISD::MemIndexedMode AM = ST->getAddressingMode();
     return (AM == ISD::POST_INC || AM == ISD::POST_DEC) &&
            ST->isTruncatingStore() && ST->getStoredVT() == MVT::i1;
   }
@@ -626,7 +666,7 @@ def post_truncsti1 : PatFrag<(ops node:$val, node:$base, node:$offset),
 def post_truncsti8 : PatFrag<(ops node:$val, node:$base, node:$offset),
                              (ist node:$val, node:$base, node:$offset), [{
   if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) {
-    ISD::MemOpAddrMode AM = ST->getAddressingMode();
+    ISD::MemIndexedMode AM = ST->getAddressingMode();
     return (AM == ISD::POST_INC || AM == ISD::POST_DEC) &&
            ST->isTruncatingStore() && ST->getStoredVT() == MVT::i8;
   }
@@ -635,7 +675,7 @@ def post_truncsti8 : PatFrag<(ops node:$val, node:$base, node:$offset),
 def post_truncsti16 : PatFrag<(ops node:$val, node:$base, node:$offset),
                               (ist node:$val, node:$base, node:$offset), [{
   if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) {
-    ISD::MemOpAddrMode AM = ST->getAddressingMode();
+    ISD::MemIndexedMode AM = ST->getAddressingMode();
     return (AM == ISD::POST_INC || AM == ISD::POST_DEC) &&
            ST->isTruncatingStore() && ST->getStoredVT() == MVT::i16;
   }
@@ -644,7 +684,7 @@ def post_truncsti16 : PatFrag<(ops node:$val, node:$base, node:$offset),
 def post_truncsti32 : PatFrag<(ops node:$val, node:$base, node:$offset),
                               (ist node:$val, node:$base, node:$offset), [{
   if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) {
-    ISD::MemOpAddrMode AM = ST->getAddressingMode();
+    ISD::MemIndexedMode AM = ST->getAddressingMode();
     return (AM == ISD::POST_INC || AM == ISD::POST_DEC) &&
            ST->isTruncatingStore() && ST->getStoredVT() == MVT::i32;
   }
@@ -653,7 +693,7 @@ def post_truncsti32 : PatFrag<(ops node:$val, node:$base, node:$offset),
 def post_truncstf32 : PatFrag<(ops node:$val, node:$base, node:$offset),
                               (ist node:$val, node:$base, node:$offset), [{
   if (StoreSDNode *ST = dyn_cast<StoreSDNode>(N)) {
-    ISD::MemOpAddrMode AM = ST->getAddressingMode();
+    ISD::MemIndexedMode AM = ST->getAddressingMode();
     return (AM == ISD::POST_INC || AM == ISD::POST_DEC) &&
            ST->isTruncatingStore() && ST->getStoredVT() == MVT::f32;
   }
@@ -749,8 +789,5 @@ def SDT_dwarf_loc : SDTypeProfile<0, 3,
                       [SDTCisInt<0>, SDTCisInt<1>, SDTCisInt<2>]>;
 def dwarf_loc : SDNode<"ISD::DEBUG_LOC", SDT_dwarf_loc,[SDNPHasChain]>;
 
-def SDT_dwarf_label : SDTypeProfile<0, 1, [SDTCisInt<0>]>;
-def dwarf_label : SDNode<"ISD::DEBUG_LABEL", SDT_dwarf_label,[SDNPHasChain]>;
-
 
 
C/C++ LLVM-based compilers that forbids OOTA behaviors