X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FValue.h;h=67af6edb8f98a6475636038f8125b0c5709372eb;hb=80a75bfae980df96f969f1c05b0c4a80ce975240;hp=fa36706114e1905d3932947357fa3d664053a497;hpb=dec628eead87b20773c98a00830580df211acc98;p=oota-llvm.git

diff --git a/include/llvm/Value.h b/include/llvm/Value.h
index fa36706114e..67af6edb8f9 100644
--- a/include/llvm/Value.h
+++ b/include/llvm/Value.h
@@ -30,6 +30,7 @@ class BasicBlock;
 class GlobalValue;
 class Function;
 class GlobalVariable;
+class GlobalAlias;
 class InlineAsm;
 class ValueSymbolTable;
 class TypeSymbolTable;
@@ -87,10 +88,28 @@ public:
 
   // All values can potentially be named...
   inline bool hasName() const { return Name != 0; }
-  std::string getName() const;
   ValueName *getValueName() const { return Name; }
 
+  /// getNameStart - Return a pointer to a null terminated string for this name.
+  /// Note that names can have null characters within the string as well as at
+  /// their end.  This always returns a non-null pointer.
+  const char *getNameStart() const;
+  
+  /// getNameLen - Return the length of the string, correctly handling nul
+  /// characters embedded into them.
+  unsigned getNameLen() const;
+
+  /// getName()/getNameStr() - Return the name of the specified value, 
+  /// *constructing a string* to hold it.  Because these are guaranteed to
+  /// construct a string, they are very expensive and should be avoided.
+  std::string getName() const { return getNameStr(); }
+  std::string getNameStr() const;
+
+
   void setName(const std::string &name);
+  void setName(const char *Name, unsigned NameLen);
+  void setName(const char *Name);  // Takes a null-terminated string.
+
   
   /// takeName - transfer the name from V to this value, setting V's name to
   /// empty.  It is an error to call V->takeName(V). 
@@ -156,6 +175,7 @@ public:
     ArgumentVal,              // This is an instance of Argument
     BasicBlockVal,            // This is an instance of BasicBlock
     FunctionVal,              // This is an instance of Function
+    GlobalAliasVal,           // This is an instance of GlobalAlias
     GlobalVariableVal,        // This is an instance of GlobalVariable
     UndefValueVal,            // This is an instance of UndefValue
     ConstantExprVal,          // This is an instance of ConstantExpr
@@ -164,7 +184,7 @@ public:
     ConstantFPVal,            // This is an instance of ConstantFP
     ConstantArrayVal,         // This is an instance of ConstantArray
     ConstantStructVal,        // This is an instance of ConstantStruct
-    ConstantPackedVal,        // This is an instance of ConstantPacked
+    ConstantVectorVal,        // This is an instance of ConstantVector
     ConstantPointerNullVal,   // This is an instance of ConstantPointerNull
     InlineAsmVal,             // This is an instance of InlineAsm
     InstructionVal,           // This is an instance of Instruction
@@ -174,14 +194,16 @@ public:
     ConstantLastVal  = ConstantPointerNullVal
   };
 
-  /// getValueType - Return an ID for the concrete type of this object.  This is
+  /// getValueID - 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 {
+  /// for instructions, the Instruction's opcode is added to InstructionVal. So
+  /// this means three things:
+  /// # there is no value with code InstructionVal (no opcode==0).
+  /// # there are more possible values for the value type than in ValueTy enum.
+  /// # the InstructionVal enumerator must be the highest valued enumerator in
+  ///   the ValueTy enum.
+  unsigned getValueID() const {
     return SubclassID;
   }
 
@@ -221,29 +243,32 @@ void Use::set(Value *V) {
 // the subtype header files to test to see if the value is a subclass...
 //
 template <> inline bool isa_impl<Constant, Value>(const Value &Val) {
-  return Val.getValueType() >= Value::ConstantFirstVal &&
-         Val.getValueType() <= Value::ConstantLastVal;
+  return Val.getValueID() >= Value::ConstantFirstVal &&
+         Val.getValueID() <= Value::ConstantLastVal;
 }
 template <> inline bool isa_impl<Argument, Value>(const Value &Val) {
-  return Val.getValueType() == Value::ArgumentVal;
+  return Val.getValueID() == Value::ArgumentVal;
 }
 template <> inline bool isa_impl<InlineAsm, Value>(const Value &Val) {
-  return Val.getValueType() == Value::InlineAsmVal;
+  return Val.getValueID() == Value::InlineAsmVal;
 }
 template <> inline bool isa_impl<Instruction, Value>(const Value &Val) {
-  return Val.getValueType() >= Value::InstructionVal;
+  return Val.getValueID() >= Value::InstructionVal;
 }
 template <> inline bool isa_impl<BasicBlock, Value>(const Value &Val) {
-  return Val.getValueType() == Value::BasicBlockVal;
+  return Val.getValueID() == Value::BasicBlockVal;
 }
 template <> inline bool isa_impl<Function, Value>(const Value &Val) {
-  return Val.getValueType() == Value::FunctionVal;
+  return Val.getValueID() == Value::FunctionVal;
 }
 template <> inline bool isa_impl<GlobalVariable, Value>(const Value &Val) {
-  return Val.getValueType() == Value::GlobalVariableVal;
+  return Val.getValueID() == Value::GlobalVariableVal;
+}
+template <> inline bool isa_impl<GlobalAlias, Value>(const Value &Val) {
+  return Val.getValueID() == Value::GlobalAliasVal;
 }
 template <> inline bool isa_impl<GlobalValue, Value>(const Value &Val) {
-  return isa<GlobalVariable>(Val) || isa<Function>(Val);
+  return isa<GlobalVariable>(Val) || isa<Function>(Val) || isa<GlobalAlias>(Val);
 }
 
 } // End llvm namespace