Add a new Operator class, for handling Instructions and ConstantExprs

in a convenient manner, factoring out some common code from
InstructionCombining and ValueTracking. Move the contents of
BinaryOperators.h into Operator.h and use Operator to generalize them
to support ConstantExprs as well as Instructions.


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

2 files changed, 132 insertions, 112 deletions

diff --git a/include/llvm/BinaryOperators.h b/include/llvm/BinaryOperators.h
deleted file mode 100644
index 4dce9af56e..0000000000
--- a/include/llvm/BinaryOperators.h
+++ /dev/null
@@ -1,112 +0,0 @@
-//===-- llvm/BinaryOperators.h - BinaryOperator subclasses ------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines various classes for working with specific BinaryOperators,
-// exposing special properties that individual operations have.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_BINARY_OPTERATORS_H
-#define LLVM_BINARY_OPTERATORS_H
-
-#include "llvm/InstrTypes.h"
-
-namespace llvm {
-
-//===----------------------------------------------------------------------===//
-//                      SpecificBinaryOperator Class
-//===----------------------------------------------------------------------===//
-
-/// SpecificBinaryOperator - This is a base class for utility classes that
-/// provide additional information about binary operator instructions with
-/// specific opcodes.
-///
-class SpecificBinaryOperator : public BinaryOperator {
-private:
-  // Do not implement any of these. The SpecificBinaryOperator class is
-  // intended to be used as a utility, and is never itself instantiated.
-  void *operator new(size_t, unsigned);
-  void *operator new(size_t s);
-  void Create(BinaryOps Op, Value *S1, Value *S2,
-              const std::string &Name = "",
-              Instruction *InsertBefore = 0);
-  void Create(BinaryOps Op, Value *S1, Value *S2,
-              const std::string &Name,
-              BasicBlock *InsertAtEnd);
-  SpecificBinaryOperator();
-  ~SpecificBinaryOperator();
-  void init(BinaryOps iType);
-};
-
-/// OverflowingBinaryOperator - Base class for integer arithmetic operators
-/// which may exhibit overflow - Add, Sub, and Mul.
-///
-class OverflowingBinaryOperator : public SpecificBinaryOperator {
-public:
-  /// hasNoSignedOverflow - Test whether this operation is known to never
-  /// undergo signed overflow.
-  bool hasNoSignedOverflow() const {
-    return SubclassOptionalData & (1 << 0);
-  }
-  void setHasNoSignedOverflow(bool B) {
-    SubclassOptionalData = (SubclassOptionalData & ~(1 << 0)) | (B << 0);
-  }
-
-  /// hasNoUnsignedOverflow - Test whether this operation is known to never
-  /// undergo unsigned overflow.
-  bool hasNoUnsignedOverflow() const {
-    return SubclassOptionalData & (1 << 1);
-  }
-  void setHasNoUnsignedOverflow(bool B) {
-    SubclassOptionalData = (SubclassOptionalData & ~(1 << 1)) | (B << 1);
-  }
-
-  static inline bool classof(const OverflowingBinaryOperator *) { return true; }
-  static inline bool classof(const BinaryOperator *BO) {
-    return BO->getOpcode() == Instruction::Add ||
-           BO->getOpcode() == Instruction::Sub ||
-           BO->getOpcode() == Instruction::Mul;
-  }
-  static inline bool classof(const Instruction *I) {
-    return I->isBinaryOp() && classof(cast<BinaryOperator>(I));
-  }
-  static inline bool classof(const Value *V) {
-    return isa<Instruction>(V) && classof(cast<Instruction>(V));
-  }
-};
-
-/// UDivInst - BinaryOperators with opcode Instruction::UDiv.
-///
-class UDivInst : public SpecificBinaryOperator {
-public:
-  /// isExact - Test whether this division is known to be exact, with
-  /// zero remainder.
-  bool isExact() const {
-    return SubclassOptionalData & (1 << 0);
-  }
-  void setIsExact(bool B) {
-    SubclassOptionalData = (SubclassOptionalData & ~(1 << 0)) | (B << 0);
-  }
-
-  // Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const UDivInst *) { return true; }
-  static inline bool classof(const BinaryOperator *BO) {
-    return BO->getOpcode() == Instruction::UDiv;
-  }
-  static inline bool classof(const Instruction *I) {
-    return I->isBinaryOp() && classof(cast<BinaryOperator>(I));
-  }
-  static inline bool classof(const Value *V) {
-    return isa<Instruction>(V) && classof(cast<Instruction>(V));
-  }
-};
-
-} // End llvm namespace
-
-#endif
diff --git a/include/llvm/Operator.h b/include/llvm/Operator.h
new file mode 100644
index 0000000000..4da19219d2
--- /dev/null
+++ b/include/llvm/Operator.h
@@ -0,0 +1,132 @@
+//===-- llvm/Operator.h - Operator utility subclass -------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines various classes for working with Instructions and
+// ConstantExprs.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OPERATOR_H
+#define LLVM_OPERATOR_H
+
+#include "llvm/Instruction.h"
+#include "llvm/Constants.h"
+
+namespace llvm {
+
+/// Operator - This is a utility class that provides an abstraction for the
+/// common functionality between Instructions and ConstantExprs.
+///
+class Operator : public User {
+private:
+  // Do not implement any of these. The Operator class is intended to be used
+  // as a utility, and is never itself instantiated.
+  void *operator new(size_t, unsigned);
+  void *operator new(size_t s);
+  Operator();
+  ~Operator();
+
+public:
+  /// getOpcode - Return the opcode for this Instruction or ConstantExpr.
+  ///
+  unsigned getOpcode() const {
+    if (const Instruction *I = dyn_cast<Instruction>(this))
+      return I->getOpcode();
+    return cast<ConstantExpr>(this)->getOpcode();
+  }
+
+  /// getOpcode - If V is an Instruction or ConstantExpr, return its
+  /// opcode. Otherwise return UserOp1.
+  ///
+  static unsigned getOpcode(const Value *V) {
+    if (const Instruction *I = dyn_cast<Instruction>(V))
+      return I->getOpcode();
+    if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
+      return CE->getOpcode();
+    return Instruction::UserOp1;
+  }
+
+  static inline bool classof(const Operator *) { return true; }
+  static inline bool classof(const Instruction *I) { return true; }
+  static inline bool classof(const ConstantExpr *I) { return true; }
+  static inline bool classof(const Value *V) {
+    return isa<Instruction>(V) || isa<ConstantExpr>(V);
+  }
+};
+
+/// OverflowingBinaryOperator - Utility class for integer arithmetic operators
+/// which may exhibit overflow - Add, Sub, and Mul.
+///
+class OverflowingBinaryOperator : public Operator {
+public:
+  /// hasNoSignedOverflow - Test whether this operation is known to never
+  /// undergo signed overflow.
+  bool hasNoSignedOverflow() const {
+    return SubclassOptionalData & (1 << 0);
+  }
+  void setHasNoSignedOverflow(bool B) {
+    SubclassOptionalData = (SubclassOptionalData & ~(1 << 0)) | (B << 0);
+  }
+
+  /// hasNoUnsignedOverflow - Test whether this operation is known to never
+  /// undergo unsigned overflow.
+  bool hasNoUnsignedOverflow() const {
+    return SubclassOptionalData & (1 << 1);
+  }
+  void setHasNoUnsignedOverflow(bool B) {
+    SubclassOptionalData = (SubclassOptionalData & ~(1 << 1)) | (B << 1);
+  }
+
+  static inline bool classof(const OverflowingBinaryOperator *) { return true; }
+  static inline bool classof(const Instruction *I) {
+    return I->getOpcode() == Instruction::Add ||
+           I->getOpcode() == Instruction::Sub ||
+           I->getOpcode() == Instruction::Mul;
+  }
+  static inline bool classof(const ConstantExpr *CE) {
+    return CE->getOpcode() == Instruction::Add ||
+           CE->getOpcode() == Instruction::Sub ||
+           CE->getOpcode() == Instruction::Mul;
+  }
+  static inline bool classof(const Value *V) {
+    return (isa<Instruction>(V) && classof(cast<Instruction>(V))) ||
+           (isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V)));
+  }
+};
+
+/// UDivOperator - An Operator with opcode Instruction::UDiv.
+///
+class UDivOperator : public Operator {
+public:
+  /// isExact - Test whether this division is known to be exact, with
+  /// zero remainder.
+  bool isExact() const {
+    return SubclassOptionalData & (1 << 0);
+  }
+  void setIsExact(bool B) {
+    SubclassOptionalData = (SubclassOptionalData & ~(1 << 0)) | (B << 0);
+  }
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const UDivOperator *) { return true; }
+  static inline bool classof(const ConstantExpr *CE) {
+    return CE->getOpcode() == Instruction::UDiv;
+  }
+  static inline bool classof(const Instruction *I) {
+    return I->getOpcode() == Instruction::UDiv;
+  }
+  static inline bool classof(const Value *V) {
+    return (isa<Instruction>(V) && classof(cast<Instruction>(V))) ||
+           (isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V)));
+  }
+};
+
+} // End llvm namespace
+
+#endif