Add a GEPOperator class, and move the hasNoPointerOverflow

accessors into it.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@76245 91177308-0d34-0410-b5e6-96231b3b80d8

3 files changed, 40 insertions, 21 deletions

diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h
index f2253e1ccc..5e60635a03 100644
--- a/include/llvm/Instructions.h
+++ b/include/llvm/Instructions.h
@@ -573,24 +573,6 @@ public:
   /// a constant offset between them.
   bool hasAllConstantIndices() const;
 
-  /// hasNoPointerOverflow - Return true if this GetElementPtr is known to
-  /// never have overflow in the pointer addition portions of its effective
-  /// computation. GetElementPtr computation involves several phases;
-  /// overflow can be considered to occur in index typecasting, array index
-  /// scaling, and the addition of the base pointer with offsets. This flag
-  /// only applies to the last of these. The operands are added to the base
-  /// pointer one at a time from left to right. This function returns false
-  /// if any of these additions results in an address value which is not
-  /// known to be within the allocated address space that the base pointer
-  /// points into, or within one element (of the original allocation) past
-  /// the end.
-  bool hasNoPointerOverflow() const {
-    return SubclassOptionalData & (1 << 0);
-  }
-  void setHasNoPointerOverflow(bool B) {
-    SubclassOptionalData = (SubclassOptionalData & ~(1 << 0)) | (B << 0);
-  }
-
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const GetElementPtrInst *) { return true; }
   static inline bool classof(const Instruction *I) {
diff --git a/include/llvm/Operator.h b/include/llvm/Operator.h
index 4da19219d2..1413ce3d20 100644
--- a/include/llvm/Operator.h
+++ b/include/llvm/Operator.h
@@ -127,6 +127,41 @@ public:
   }
 };
 
+class GEPOperator : public Operator {
+public:
+  /// hasNoPointerOverflow - Return true if this GetElementPtr is known to
+  /// never have overflow in the pointer addition portions of its effective
+  /// computation. GetElementPtr computation involves several phases;
+  /// overflow can be considered to occur in index typecasting, array index
+  /// scaling, and the addition of the base pointer with offsets. This flag
+  /// only applies to the last of these. The operands are added to the base
+  /// pointer one at a time from left to right. This function returns false
+  /// if any of these additions results in an address value which is not
+  /// known to be within the allocated address space that the base pointer
+  /// points into, or within one element (of the original allocation) past
+  /// the end.
+  bool hasNoPointerOverflow() const {
+    return SubclassOptionalData & (1 << 0);
+  }
+  void setHasNoPointerOverflow(bool B) {
+    SubclassOptionalData = (SubclassOptionalData & ~(1 << 0)) | (B << 0);
+  }
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const GEPOperator *) { return true; }
+  static inline bool classof(const GetElementPtrInst *) { return true; }
+  static inline bool classof(const ConstantExpr *CE) {
+    return CE->getOpcode() == Instruction::GetElementPtr;
+  }
+  static inline bool classof(const Instruction *I) {
+    return I->getOpcode() == Instruction::GetElementPtr;
+  }
+  static inline bool classof(const Value *V) {
+    return isa<GetElementPtrInst>(V) ||
+           (isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V)));
+  }
+};
+
 } // End llvm namespace
 
 #endif
diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp
index 915cbb8f8b..c1b57a6e1e 100644
--- a/lib/VMCore/Instructions.cpp
+++ b/lib/VMCore/Instructions.cpp
@@ -16,6 +16,7 @@
 #include "llvm/DerivedTypes.h"
 #include "llvm/Function.h"
 #include "llvm/Instructions.h"
+#include "llvm/Operator.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/CallSite.h"
 #include "llvm/Support/ConstantRange.h"
@@ -1024,7 +1025,7 @@ void GetElementPtrInst::init(Value *Ptr, Value* const *Idx, unsigned NumIdx,
   setName(Name);
 
   // GetElementPtr instructions have undefined results on overflow by default.
-  setHasNoPointerOverflow(true);
+  cast<GEPOperator>(this)->setHasNoPointerOverflow(true);
 }
 
 void GetElementPtrInst::init(Value *Ptr, Value *Idx, const std::string &Name) {
@@ -1036,7 +1037,7 @@ void GetElementPtrInst::init(Value *Ptr, Value *Idx, const std::string &Name) {
   setName(Name);
 
   // GetElementPtr instructions have undefined results on overflow by default.
-  setHasNoPointerOverflow(true);
+  cast<GEPOperator>(this)->setHasNoPointerOverflow(true);
 }
 
 GetElementPtrInst::GetElementPtrInst(const GetElementPtrInst &GEPI)
@@ -1050,7 +1051,8 @@ GetElementPtrInst::GetElementPtrInst(const GetElementPtrInst &GEPI)
     OL[i] = GEPIOL[i];
 
   // Transfer the hasNoPointerOverflow() value from the original GEPI.
-  setHasNoPointerOverflow(GEPI.hasNoPointerOverflow());
+  cast<GEPOperator>(this)
+    ->setHasNoPointerOverflow(cast<GEPOperator>(GEPI).hasNoPointerOverflow());
 }
 
 GetElementPtrInst::GetElementPtrInst(Value *Ptr, Value *Idx,