For PR411:

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

diff --git a/include/llvm/Value.h b/include/llvm/Value.h
index 5c50fd0a5d3b3104f64b803c9e23b92f4148ffed..63af0f747d6b64a1a78cf21afa1324394b00e259 100644 (file)
--- a/include/llvm/Value.h
+++ b/include/llvm/Value.h
@@ -7,9 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file defines the very important Value class.  This is subclassed by a
-// bunch of other important classes, like Instruction, Function, Type, etc...
-//
+// This file declares the Value class. 
 // This file also defines the Use<> template for users of value.
 //
 //===----------------------------------------------------------------------===//
@@ -20,6 +18,7 @@
 #include "llvm/AbstractTypeUser.h"
 #include "llvm/Use.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/Streams.h"
 #include <string>
 
 namespace llvm {
@@ -32,17 +31,25 @@ class GlobalValue;
 class Function;
 class GlobalVariable;
 class InlineAsm;
-class SymbolTable;
+class ValueSymbolTable;
+class TypeSymbolTable;
 
 //===----------------------------------------------------------------------===//
 //                                 Value Class
 //===----------------------------------------------------------------------===//
 
-/// Value - The base class of all values computed by a program that may be used
-/// as operands to other values.
+/// This is a very important LLVM class. It is the base class of all values 
+/// computed by a program that may be used as operands to other values. Value is
+/// the super class of other important classes such as Instruction and Function.
+/// All Values have a Type. Type is not a subclass of Value. All types can have
+/// a name and they should belong to some Module. Setting the name on the Value
+/// automatically update's the module's symbol table.
 ///
+/// Every value has a "use list" that keeps track of which other Values are
+/// using this Value.
+/// @brief LLVM Value Representation
 class Value {
-  unsigned short SubclassID;         // Subclass identifier (for isa/dyn_cast)
+  const unsigned short SubclassID;   // Subclass identifier (for isa/dyn_cast)
 protected:
   /// SubclassData - This member is defined by this class, but is not used for
   /// anything.  Subclasses can use it to hold whatever state they find useful.
@@ -70,6 +77,7 @@ public:
   /// print - Implement operator<< on Value...
   ///
   virtual void print(std::ostream &O) const = 0;
+  void print(std::ostream *O) const { if (O) print(*O); }
 
   /// All values are typed, get the type of this value.
   ///
@@ -133,13 +141,10 @@ public:
   ///
   void addUse(Use &U) { U.addToList(&UseList); }
 
-  /// getValueType - Return an ID for the concrete type of this object.  This is
-  /// used to implement the classof checks.  This should not be used for any
-  /// other purpose, as the values may change as LLVM evolves.  Also, note that
-  /// starting with the InstructionVal value, the value stored is actually the
-  /// Instruction opcode, so there are more than just these values possible here
-  /// (and Instruction must be last).
-  ///
+  /// An enumeration for keeping track of the concrete subclass of Value that
+  /// is actually instantiated. Values of this enumeration are kept in the 
+  /// Value classes SubclassID field. They are used for concrete type
+  /// identification.
   enum ValueTy {
     ArgumentVal,              // This is an instance of Argument
     BasicBlockVal,            // This is an instance of BasicBlock
@@ -148,9 +153,7 @@ public:
     UndefValueVal,            // This is an instance of UndefValue
     ConstantExprVal,          // This is an instance of ConstantExpr
     ConstantAggregateZeroVal, // This is an instance of ConstantAggregateNull
-    ConstantBoolVal,          // This is an instance of ConstantBool
-    ConstantSIntVal,          // This is an instance of ConstantSInt
-    ConstantUIntVal,          // This is an instance of ConstantUInt
+    ConstantIntVal,           // This is an instance of ConstantInt
     ConstantFPVal,            // This is an instance of ConstantFP
     ConstantArrayVal,         // This is an instance of ConstantArray
     ConstantStructVal,        // This is an instance of ConstantStruct
@@ -163,6 +166,14 @@ public:
     ConstantFirstVal = FunctionVal,
     ConstantLastVal  = ConstantPointerNullVal
   };
+
+  /// getValueType - Return an ID for the concrete type of this object.  This is
+  /// used to implement the classof checks.  This should not be used for any
+  /// other purpose, as the values may change as LLVM evolves.  Also, note that
+  /// starting with the InstructionVal value, the value stored is actually the
+  /// Instruction opcode, so there are more than just these values possible here
+  /// (and Instruction must be last).
+  ///
   unsigned getValueType() const {
     return SubclassID;
   }
@@ -175,11 +186,6 @@ public:
   /// 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 short VT) { SubclassID = VT; }
-  friend class Instruction;
 };
 
 inline std::ostream &operator<<(std::ostream &OS, const Value &V) {