Adjust to changes in the User class. Introduce a new UnaryInstruction

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

diff --git a/include/llvm/Value.h b/include/llvm/Value.h
index 7d870d67097de735e9ebbc751d421b7fc88c3917..90bbe6fe91c5d4a4ce8354404e6e158569841e69 100644 (file)
--- a/include/llvm/Value.h
+++ b/include/llvm/Value.h
@@ -19,15 +19,15 @@
 
 #include "llvm/AbstractTypeUser.h"
 #include "llvm/Use.h"
-#include "Support/Casting.h"
-#include <iostream>
+#include "llvm/Support/Casting.h"
+#include <string>
 
 namespace llvm {
 
 class Constant;
 class Argument;
 class Instruction;
-struct BasicBlock;
+class BasicBlock;
 class GlobalValue;
 class Function;
 class GlobalVariable;
@@ -40,8 +40,7 @@ class SymbolTable;
 /// Value - The base class of all values computed by a program that may be used
 /// as operands to other values.
 ///
-struct Value {
-private:
+class Value {
   unsigned SubclassID;               // Subclass identifier (for isa/dyn_cast)
   PATypeHolder Ty;
   iplist<Use> Uses;
@@ -89,8 +88,9 @@ public:
   //
   typedef UseListIteratorWrapper      use_iterator;
   typedef UseListConstIteratorWrapper use_const_iterator;
+  typedef iplist<Use>::size_type      size_type;
 
-  unsigned           use_size()  const { return Uses.size();  }
+  size_type          use_size()  const { return Uses.size();  }
   bool               use_empty() const { return Uses.empty(); }
   use_iterator       use_begin()       { return Uses.begin(); }
   use_const_iterator use_begin() const { return Uses.begin(); }
@@ -122,32 +122,36 @@ public:
   /// (and Instruction must be last).
   ///
   enum ValueTy {
-    TypeVal,                // This is an instance of Type
-    ArgumentVal,            // This is an instance of Argument
-    BasicBlockVal,          // This is an instance of BasicBlock
-    FunctionVal,            // This is an instance of Function
-    GlobalVariableVal,      // This is an instance of GlobalVariable
-    ConstantVal,            // This is an instance of Constant
-    InstructionVal,         // This is an instance of Instruction
+    ArgumentVal,              // This is an instance of Argument
+    BasicBlockVal,            // This is an instance of BasicBlock
+    FunctionVal,              // This is an instance of Function
+    GlobalVariableVal,        // This is an instance of GlobalVariable
+    UndefValueVal,            // This is an instance of UndefValue
+    ConstantExprVal,          // This is an instance of ConstantExpr
+    ConstantAggregateZeroVal, // This is an instance of ConstantAggregateNull
+    SimpleConstantVal,        // This is some other type of Constant
+    InstructionVal,           // This is an instance of Instruction
+    ValueListVal              // This is for bcreader, a special ValTy
   };
   unsigned getValueType() const {
     return SubclassID;
   }
 
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const Value *V) {
+    return true; // Values are always values.
+  }
+
+  /// getRawType - This should only be used to implement the vmcore library.
+  ///
+  const Type *getRawType() const { return Ty.getRawType(); }
+
 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) {
-  if (V == 0)
-    OS << "<null> value!\n";
-  else
-    V->print(OS);
-  return OS;
-}
-
 inline std::ostream &operator<<(std::ostream &OS, const Value &V) {
   V.print(OS);
   return OS;
@@ -163,11 +167,9 @@ inline const User *UseListConstIteratorWrapper::operator*() const {
 }
 
 
-Use::Use(Value *v, User *user) : Val(v), U(user) {
-  if (Val) Val->addUse(*this);
-}
-
-Use::Use(const Use &u) : Val(u.Val), U(u.U) {
+void Use::init(Value *v, User *user) {
+  Val = v;
+  U = user;
   if (Val) Val->addUse(*this);
 }
 
@@ -185,11 +187,13 @@ void Use::set(Value *V) {
 // isa - Provide some specializations of isa so that we don't have to include
 // the subtype header files to test to see if the value is a subclass...
 //
-template <> inline bool isa_impl<Type, Value>(const Value &Val) { 
-  return Val.getValueType() == Value::TypeVal;
-}
 template <> inline bool isa_impl<Constant, Value>(const Value &Val) { 
-  return Val.getValueType() == Value::ConstantVal; 
+  return Val.getValueType() == Value::SimpleConstantVal ||
+         Val.getValueType() == Value::FunctionVal ||
+        Val.getValueType() == Value::GlobalVariableVal ||
+         Val.getValueType() == Value::ConstantExprVal ||
+         Val.getValueType() == Value::ConstantAggregateZeroVal ||
+         Val.getValueType() == Value::UndefValueVal;
 }
 template <> inline bool isa_impl<Argument, Value>(const Value &Val) { 
   return Val.getValueType() == Value::ArgumentVal;