Add default index functor (an identity functor). You could use a

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

diff --git a/include/llvm/Instruction.h b/include/llvm/Instruction.h
index fae6d2a11a4b65228ba6e462cabb619312389d62..85f6cdb0b144ccc0bf8d17a043e16a736ac5b4e7 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 {
 
-class AssemblyAnnotationWriter;
+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
 
@@ -36,11 +36,18 @@ class Instruction : public User, public Annotable {
   friend class SymbolTableListTraits<Instruction, BasicBlock, Function,
                                      ilist_traits<Instruction> >;
   void setParent(BasicBlock *P);
-protected:
-  unsigned iType;      // InstructionType: The opcode of the instruction
+  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:
   Instruction(const Type *Ty, unsigned iType, const std::string &Name = "",
               Instruction *InsertBefore = 0);
+  Instruction(const Type *Ty, unsigned iType, const std::string &Name,
+              BasicBlock *InsertAtEnd);
 public:
 
   ~Instruction() {
@@ -77,17 +84,22 @@ public:
   /// 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());
   }
   static const char* getOpcodeName(unsigned OpCode);
 
+  static inline bool isTerminator(unsigned OpCode) {
+    return OpCode >= TermOpsBegin && OpCode < TermOpsEnd;
+  }
+
   inline bool isTerminator() const {   // Instance of TerminatorInst?
-    return iType >= TermOpsBegin && iType < TermOpsEnd;
+    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:
@@ -129,7 +141,7 @@ public:
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Instruction *I) { return true; }
   static inline bool classof(const Value *V) {
-    return V->getValueType() == Value::InstructionVal;
+    return V->getValueType() >= Value::InstructionVal;
   }
   
   //----------------------------------------------------------------------