Eliminate the Instruction::iType field, folding it into the Value::VTy field.

This reduces the size of the instruction class by 4 bytes, and means that
isa<CallInst>(V) (for example) only needs to do one load from memory instead
of two.


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

2 files changed, 15 insertions, 6 deletions

diff --git a/include/llvm/Instruction.h b/include/llvm/Instruction.h
index d2f61965dd..31407ff849 100644
--- a/include/llvm/Instruction.h
+++ b/include/llvm/Instruction.h
@@ -21,6 +21,7 @@
 namespace llvm {
 
 struct AssemblyAnnotationWriter;
+class BinaryOperator;
 
 template<typename SC> struct ilist_traits;
 template<typename ValueSubClass, typename ItemParentClass, typename SymTabClass,
@@ -38,9 +39,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,
@@ -81,7 +85,7 @@ 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());
   }
@@ -92,11 +96,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:
diff --git a/include/llvm/Value.h b/include/llvm/Value.h
index c47c96962f..7d870d6709 100644
--- a/include/llvm/Value.h
+++ b/include/llvm/Value.h
@@ -133,6 +133,11 @@ public:
   unsigned getValueType() const {
     return SubclassID;
   }
+
+private:
+  /// FIXME: this is a gross hack, needed by another gross hack.  Eliminate!
+  void setValueType(unsigned VT) { SubclassID = VT; }
+  friend class Instruction;
 };
 
 inline std::ostream &operator<<(std::ostream &OS, const Value *V) {
@@ -190,7 +195,7 @@ template <> inline bool isa_impl<Argument, Value>(const Value &Val) {
   return Val.getValueType() == Value::ArgumentVal;
 }
 template <> inline bool isa_impl<Instruction, Value>(const Value &Val) { 
-  return Val.getValueType() == Value::InstructionVal;
+  return Val.getValueType() >= Value::InstructionVal;
 }
 template <> inline bool isa_impl<BasicBlock, Value>(const Value &Val) { 
   return Val.getValueType() == Value::BasicBlockVal;