remove SectionFlags::Small: it is only used on Xcore, and we'll find

[oota-llvm.git] / include / llvm / Operator.h

diff --git a/include/llvm/Operator.h b/include/llvm/Operator.h
index 2f9f9ca12ce3f2c05583b2678b0084ca32632c3a..541f13d859175444e8b66c18457869f9a074ebe8 100644 (file)
--- a/include/llvm/Operator.h
+++ b/include/llvm/Operator.h
@@ -61,7 +61,8 @@ public:
 };
 
 /// OverflowingBinaryOperator - Utility class for integer arithmetic operators
-/// which may exhibit overflow - Add, Sub, and Mul.
+/// which may exhibit overflow - Add, Sub, and Mul. It does not include SDiv,
+/// despite that operator having the potential for overflow.
 ///
 class OverflowingBinaryOperator : public Operator {
 public:
@@ -100,9 +101,9 @@ public:
   }
 };
 
-/// UDivOperator - An Operator with opcode Instruction::UDiv.
+/// SDivOperator - An Operator with opcode Instruction::SDiv.
 ///
-class UDivOperator : public Operator {
+class SDivOperator : public Operator {
 public:
   /// isExact - Test whether this division is known to be exact, with
   /// zero remainder.
@@ -114,12 +115,12 @@ public:
   }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const UDivOperator *) { return true; }
+  static inline bool classof(const SDivOperator *) { return true; }
   static inline bool classof(const ConstantExpr *CE) {
-    return CE->getOpcode() == Instruction::UDiv;
+    return CE->getOpcode() == Instruction::SDiv;
   }
   static inline bool classof(const Instruction *I) {
-    return I->getOpcode() == Instruction::UDiv;
+    return I->getOpcode() == Instruction::SDiv;
   }
   static inline bool classof(const Value *V) {
     return (isa<Instruction>(V) && classof(cast<Instruction>(V))) ||
@@ -171,24 +172,6 @@ public:
     return true;
   }
 
-  /// 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; }