Add method

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

diff --git a/include/llvm/Instruction.h b/include/llvm/Instruction.h
index d2f61965dddc07121a575d93d61bfcccf4c8e4e5..a7359731db7d513f77bd136acbb5efda4452c6d6 100644 (file)
--- a/include/llvm/Instruction.h
+++ b/include/llvm/Instruction.h
@@ -16,17 +16,17 @@
 #define LLVM_INSTRUCTION_H
 
 #include "llvm/User.h"
-#include "Support/Annotation.h"
 
 namespace llvm {
 
 struct AssemblyAnnotationWriter;
+class BinaryOperator;
 
 template<typename SC> struct ilist_traits;
 template<typename ValueSubClass, typename ItemParentClass, typename SymTabClass,
          typename SubClass> class SymbolTableListTraits;
 
-class Instruction : public User, public Annotable {
+class Instruction : public User {
   BasicBlock *Parent;
   Instruction *Prev, *Next; // Next and Prev links for our intrusive linked list
 
@@ -38,9 +38,12 @@ class Instruction : public User, public Annotable {
   void setParent(BasicBlock *P);
   void init();
 
+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:
-  unsigned iType;      // InstructionType: The opcode of the instruction
-
   Instruction(const Type *Ty, unsigned iType, const std::string &Name = "",
               Instruction *InsertBefore = 0);
   Instruction(const Type *Ty, unsigned iType, const std::string &Name,
@@ -54,12 +57,22 @@ public:
   // Specialize setName to handle symbol table majik...
   virtual void setName(const std::string &name, SymbolTable *ST = 0);
   
+  /// mayWriteToMemory - Return true if this instruction may modify memory.
+  ///
+  virtual bool mayWriteToMemory() const { return false; }
+
   /// clone() - Create a copy of 'this' instruction that is identical in all
   /// ways except the following:
   ///   * The instruction has no parent
   ///   * The instruction has no name
   ///
   virtual Instruction *clone() const = 0;
+
+  /// isIdenticalTo - Return true if the specified instruction is exactly
+  /// identical to the current one.  This means that all operands match and any
+  /// extra information (e.g. load is volatile) agree.
+  bool isIdenticalTo(Instruction *I) const;
+
   
   // Accessor methods...
   //
@@ -73,15 +86,21 @@ public:
         Instruction *getPrev()       { return Prev; }
   const Instruction *getPrev() const { return Prev; }
 
-  /// mayWriteToMemory - Return true if this instruction may modify memory.
+  /// removeFromParent - This method unlinks 'this' from the containing basic
+  /// block, but does not delete it.
   ///
-  virtual bool mayWriteToMemory() const { return false; }
+  void removeFromParent();
+
+  /// eraseFromParent - This method unlinks 'this' from the containing basic
+  /// block and deletes it.
+  ///
+  void eraseFromParent();
 
   // ---------------------------------------------------------------------------
   /// Subclass classification... getOpcode() returns a member of 
   /// one of the enums that is coming soon (down below)...
   ///
-  unsigned getOpcode() const { return iType; }
+  unsigned getOpcode() const { return getValueType() - InstructionVal; }
   virtual const char *getOpcodeName() const {
     return getOpcodeName(getOpcode());
   }
@@ -92,11 +111,11 @@ public:
   }
 
   inline bool isTerminator() const {   // Instance of TerminatorInst?
-    return isTerminator(iType);
+    return isTerminator(getOpcode());
   }
 
   inline bool isBinaryOp() const {
-    return iType >= BinaryOpsBegin && iType < BinaryOpsEnd;
+    return getOpcode() >= BinaryOpsBegin && getOpcode() < BinaryOpsEnd;
   }
 
   /// isAssociative - Return true if the instruction is associative: