Rename Value::getValueType to getValueID, to avoid confusion with

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

diff --git a/include/llvm/Instruction.h b/include/llvm/Instruction.h
index 2b025dd8753f0f033cd68afff167583930d6505f..ed0357f823bf27de4eda5c797b7bef621b3ef9d2 100644 (file)
--- a/include/llvm/Instruction.h
+++ b/include/llvm/Instruction.h
@@ -39,27 +39,18 @@ class Instruction : public User {
   friend class SymbolTableListTraits<Instruction, BasicBlock, Function,
                                      ilist_traits<Instruction> >;
   void setParent(BasicBlock *P);
-
-private:
-  // FIXME: This is a dirty hack.  Setcc instructions shouldn't encode the CC
-  // into the opcode field.  When they don't, this will be unneeded.
-  void setOpcode(unsigned NewOpcode);
-  friend class BinaryOperator;
 protected:
   Instruction(const Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,
-              const std::string &Name = "",
               Instruction *InsertBefore = 0);
   Instruction(const Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,
-              const std::string &Name, BasicBlock *InsertAtEnd);
+              BasicBlock *InsertAtEnd);
 public:
-
-  ~Instruction() {
-    assert(Parent == 0 && "Instruction still linked in the program!");
-  }
-
+  // Out of line virtual method, so the vtable, etc has a home.
+  ~Instruction();
+  
   /// mayWriteToMemory - Return true if this instruction may modify memory.
   ///
-  virtual bool mayWriteToMemory() const { return false; }
+  bool mayWriteToMemory() const;
 
   /// clone() - Create a copy of 'this' instruction that is identical in all
   /// ways except the following:
@@ -73,7 +64,21 @@ public:
   /// extra information (e.g. load is volatile) agree.
   bool isIdenticalTo(Instruction *I) const;
 
-
+  /// This function determines if the specified instruction executes the same
+  /// operation as the current one. This means that the opcodes, type, operand
+  /// types and any other factors affecting the operation must be the same. This
+  /// is similar to isIdenticalTo except the operands themselves don't have to
+  /// be identical.
+  /// @returns true if the specified instruction is the same operation as
+  /// the current one.
+  /// @brief Determine if one instruction is the same operation as another.
+  bool isSameOperationAs(Instruction *I) const;
+
+  /// use_back - Specialize the methods defined in Value, as we know that an
+  /// instruction can only be used by other instructions.
+  Instruction       *use_back()       { return cast<Instruction>(*use_begin());}
+  const Instruction *use_back() const { return cast<Instruction>(*use_begin());}
+  
   // Accessor methods...
   //
   inline const BasicBlock *getParent() const { return Parent; }
@@ -105,8 +110,8 @@ public:
   /// Subclass classification... getOpcode() returns a member of
   /// one of the enums that is coming soon (down below)...
   ///
-  unsigned getOpcode() const { return getValueType() - InstructionVal; }
-  virtual const char *getOpcodeName() const {
+  unsigned getOpcode() const { return getValueID() - InstructionVal; }
+  const char *getOpcodeName() const {
     return getOpcodeName(getOpcode());
   }
   static const char* getOpcodeName(unsigned OpCode);
@@ -123,6 +128,37 @@ public:
     return getOpcode() >= BinaryOpsBegin && getOpcode() < BinaryOpsEnd;
   }
 
+  /// @brief Determine if the Opcode is one of the shift instructions.
+  static inline bool isShift(unsigned Opcode) {
+    return Opcode >= Shl && Opcode <= AShr;
+  }
+
+  /// @brief Determine if the instruction's opcode is one of the shift 
+  /// instructions.
+  inline bool isShift() { return isShift(getOpcode()); }
+
+  /// isLogicalShift - Return true if this is a logical shift left or a logical
+  /// shift right.
+  inline bool isLogicalShift() {
+    return getOpcode() == Shl || getOpcode() == LShr;
+  }
+
+  /// isLogicalShift - Return true if this is a logical shift left or a logical
+  /// shift right.
+  inline bool isArithmeticShift() {
+    return getOpcode() == AShr;
+  }
+
+  /// @brief Determine if the OpCode is one of the CastInst instructions.
+  static inline bool isCast(unsigned OpCode) {
+    return OpCode >= CastOpsBegin && OpCode < CastOpsEnd;
+  }
+
+  /// @brief Determine if this is one of the CastInst instructions.
+  inline bool isCast() const {
+    return isCast(getOpcode());
+  }
+
   /// isAssociative - Return true if the instruction is associative:
   ///
   ///   Associative operators satisfy:  x op (y op z) === (x op y) op z
@@ -143,12 +179,6 @@ public:
   bool isCommutative() const { return isCommutative(getOpcode()); }
   static bool isCommutative(unsigned op);
 
-  /// isRelational - Return true if the instruction is a Set* instruction:
-  ///
-  bool isRelational() const { return isRelational(getOpcode()); }
-  static bool isRelational(unsigned op);
-
-
   /// isTrappingInstruction - Return true if the instruction may trap.
   ///
   bool isTrapping() const {
@@ -157,12 +187,13 @@ public:
   static bool isTrapping(unsigned op);
 
   virtual void print(std::ostream &OS) const { print(OS, 0); }
+  void print(std::ostream *OS) const { if (OS) print(*OS); }
   void print(std::ostream &OS, AssemblyAnnotationWriter *AAW) const;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Instruction *) { return true; }
   static inline bool classof(const Value *V) {
-    return V->getValueType() >= Value::InstructionVal;
+    return V->getValueID() >= Value::InstructionVal;
   }
 
   //----------------------------------------------------------------------
@@ -189,6 +220,13 @@ public:
 #include "llvm/Instruction.def"
   };
 
+  enum CastOps {
+#define  FIRST_CAST_INST(N)             CastOpsBegin = N,
+#define HANDLE_CAST_INST(N, OPC, CLASS) OPC = N,
+#define   LAST_CAST_INST(N)             CastOpsEnd = N+1
+#include "llvm/Instruction.def"
+  };
+
   enum OtherOps {
 #define  FIRST_OTHER_INST(N)             OtherOpsBegin = N,
 #define HANDLE_OTHER_INST(N, OPC, CLASS) OPC = N,