X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FValue.cpp;h=2178ce47a3f5ad7cf6761fc90be47075ea0748ef;hb=453eed147ad009f4608197928a3ed8ea7e67a78d;hp=cdde96b455b7765372e12199e39dc2f312095ce0;hpb=0d1e40728d668085257b78657b381e1f13d77d52;p=oota-llvm.git

diff --git a/lib/VMCore/Value.cpp b/lib/VMCore/Value.cpp
index cdde96b455b..2178ce47a3f 100644
--- a/lib/VMCore/Value.cpp
+++ b/lib/VMCore/Value.cpp
@@ -1,13 +1,13 @@
 //===-- Value.cpp - Implement the Value class -----------------------------===//
-// 
+//
 //                     The LLVM Compiler Infrastructure
 //
 // This file was developed by the LLVM research group and is distributed under
 // the University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
+//
 //===----------------------------------------------------------------------===//
 //
-// This file implements the Value and User classes. 
+// This file implements the Value and User classes.
 //
 //===----------------------------------------------------------------------===//
 
@@ -15,10 +15,10 @@
 #include "llvm/DerivedTypes.h"
 #include "llvm/InstrTypes.h"
 #include "llvm/Module.h"
-#include "llvm/SymbolTable.h"
+#include "llvm/ValueSymbolTable.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Support/LeakDetector.h"
 #include <algorithm>
-#include <iostream>
 using namespace llvm;
 
 //===----------------------------------------------------------------------===//
@@ -30,15 +30,13 @@ static inline const Type *checkType(const Type *Ty) {
   return Ty;
 }
 
-Value::Value(const Type *ty, unsigned scid, const std::string &name)
+Value::Value(const Type *ty, unsigned scid)
   : SubclassID(scid), SubclassData(0), Ty(checkType(ty)),
-    UseList(0), Name(name) {
+    UseList(0), Name(0) {
   if (!isa<Constant>(this) && !isa<BasicBlock>(this))
-    assert((Ty->isFirstClassType() || Ty == Type::VoidTy || 
+    assert((Ty->isFirstClassType() || Ty == Type::VoidTy ||
            isa<OpaqueType>(ty)) &&
            "Cannot create non-first-class values except for constants!");
-  if (ty == Type::VoidTy)
-    assert(name.empty() && "Cannot have named void values!");
 }
 
 Value::~Value() {
@@ -46,18 +44,23 @@ Value::~Value() {
   // Check to make sure that there are no uses of this value that are still
   // around when the value is destroyed.  If there are, then we have a dangling
   // reference and something is wrong.  This code is here to print out what is
-  // still being referenced.  The value in question should be printed as 
+  // still being referenced.  The value in question should be printed as
   // a <badref>
   //
   if (use_begin() != use_end()) {
-    std::cerr << "While deleting: " << *Ty << " %" << Name << "\n";
+    DOUT << "While deleting: " << *Ty << " %" << Name << "\n";
     for (use_iterator I = use_begin(), E = use_end(); I != E; ++I)
-      std::cerr << "Use still stuck around after Def is destroyed:"
-                << **I << "\n";
+      DOUT << "Use still stuck around after Def is destroyed:"
+           << **I << "\n";
   }
 #endif
   assert(use_begin() == use_end() && "Uses remain when a value is destroyed!");
 
+  // If this value is named, destroy the name.  This should not be in a symtab
+  // at this point.
+  if (Name)
+    Name->Destroy();
+  
   // There should be no uses of this object anymore, remove it.
   LeakDetector::removeGarbageObject(this);
 }
@@ -92,32 +95,177 @@ unsigned Value::getNumUses() const {
   return (unsigned)std::distance(use_begin(), use_end());
 }
 
+static bool getSymTab(Value *V, ValueSymbolTable *&ST) {
+  ST = 0;
+  if (Instruction *I = dyn_cast<Instruction>(V)) {
+    if (BasicBlock *P = I->getParent())
+      if (Function *PP = P->getParent())
+        ST = &PP->getValueSymbolTable();
+  } else if (BasicBlock *BB = dyn_cast<BasicBlock>(V)) {
+    if (Function *P = BB->getParent()) 
+      ST = &P->getValueSymbolTable();
+  } else if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
+    if (Module *P = GV->getParent()) 
+      ST = &P->getValueSymbolTable();
+  } else if (Argument *A = dyn_cast<Argument>(V)) {
+    if (Function *P = A->getParent()) 
+      ST = &P->getValueSymbolTable();
+  } else {
+    assert(isa<Constant>(V) && "Unknown value type!");
+    return true;  // no name is setable for this.
+  }
+  return false;
+}
+
+/// 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 *Value::getNameStart() const {
+  if (Name == 0) return "";
+  return Name->getKeyData();
+}
+
+/// getNameLen - Return the length of the string, correctly handling nul
+/// characters embedded into them.
+unsigned Value::getNameLen() const {
+  return Name->getKeyLength();
+}
+
+
+std::string Value::getNameStr() const {
+  if (Name == 0) return "";
+  return std::string(Name->getKeyData(),
+                     Name->getKeyData()+Name->getKeyLength());
+}
 
 void Value::setName(const std::string &name) {
-  if (Name == name) return;   // Name is already set.
+  setName(&name[0], name.size());
+}
 
-  SymbolTable *ST = 0;
+void Value::setName(const char *Name) {
+  setName(Name, Name ? strlen(Name) : 0);
+}
 
-  if (Instruction *I = dyn_cast<Instruction>(this)) {
-    if (BasicBlock *P = I->getParent())
-      if (Function *PP = P->getParent())
-        ST = &PP->getSymbolTable();
-  } else if (BasicBlock *BB = dyn_cast<BasicBlock>(this)) {
-    if (Function *P = BB->getParent()) ST = &P->getSymbolTable();
-  } else if (GlobalValue *GV = dyn_cast<GlobalValue>(this)) {
-    if (Module *P = GV->getParent()) ST = &P->getSymbolTable();
-  } else if (Argument *A = dyn_cast<Argument>(this)) {
-    if (Function *P = A->getParent()) ST = &P->getSymbolTable();
-  } else {
-    assert(isa<Constant>(this) && "Unknown value type!");
-    return;  // no name is setable for this.
+void Value::setName(const char *NameStr, unsigned NameLen) {
+  if (NameLen == 0 && !hasName()) return;
+  assert(getType() != Type::VoidTy && "Cannot assign a name to void values!");
+  
+  // Get the symbol table to update for this object.
+  ValueSymbolTable *ST;
+  if (getSymTab(this, ST))
+    return;  // Cannot set a name on this value (e.g. constant).
+
+  if (!ST) { // No symbol table to update?  Just do the change.
+    if (NameLen == 0) {
+      // Free the name for this value.
+      Name->Destroy();
+      Name = 0;
+      return;
+    }
+    
+    if (Name) {
+      // Name isn't changing?
+      if (NameLen == Name->getKeyLength() &&
+          !memcmp(Name->getKeyData(), NameStr, NameLen))
+        return;
+      Name->Destroy();
+    }
+    
+    // NOTE: Could optimize for the case the name is shrinking to not deallocate
+    // then reallocated.
+      
+    // Create the new name.
+    Name = ValueName::Create(NameStr, NameStr+NameLen);
+    Name->setValue(this);
+    return;
+  }
+  
+  // NOTE: Could optimize for the case the name is shrinking to not deallocate
+  // then reallocated.
+  if (hasName()) {
+    // Name isn't changing?
+    if (NameLen == Name->getKeyLength() &&
+        !memcmp(Name->getKeyData(), NameStr, NameLen))
+      return;
+
+    // Remove old name.
+    ST->removeValueName(Name);
+    Name->Destroy();
+    Name = 0;
+
+    if (NameLen == 0)
+      return;
   }
 
-  if (ST && hasName()) ST->remove(this);
-  Name = name;
-  if (ST && hasName()) ST->insert(this);
+  // Name is changing to something new.
+  Name = ST->createValueName(NameStr, NameLen, this);
 }
 
+
+/// takeName - transfer the name from V to this value, setting V's name to
+/// empty.  It is an error to call V->takeName(V). 
+void Value::takeName(Value *V) {
+  ValueSymbolTable *ST = 0;
+  // If this value has a name, drop it.
+  if (hasName()) {
+    // Get the symtab this is in.
+    if (getSymTab(this, ST)) {
+      // We can't set a name on this value, but we need to clear V's name if
+      // it has one.
+      if (V->hasName()) V->setName(0, 0);
+      return;  // Cannot set a name on this value (e.g. constant).
+    }
+    
+    // Remove old name.
+    if (ST)
+      ST->removeValueName(Name);
+    Name->Destroy();
+    Name = 0;
+  } 
+  
+  // Now we know that this has no name.
+  
+  // If V has no name either, we're done.
+  if (!V->hasName()) return;
+   
+  // Get this's symtab if we didn't before.
+  if (!ST) {
+    if (getSymTab(this, ST)) {
+      // Clear V's name.
+      V->setName(0, 0);
+      return;  // Cannot set a name on this value (e.g. constant).
+    }
+  }
+  
+  // Get V's ST, this should always succed, because V has a name.
+  ValueSymbolTable *VST;
+  bool Failure = getSymTab(V, VST);
+  assert(!Failure && "V has a name, so it should have a ST!");
+  
+  // If these values are both in the same symtab, we can do this very fast.
+  // This works even if both values have no symtab yet.
+  if (ST == VST) {
+    // Take the name!
+    Name = V->Name;
+    V->Name = 0;
+    Name->setValue(this);
+    return;
+  }
+  
+  // Otherwise, things are slightly more complex.  Remove V's name from VST and
+  // then reinsert it into ST.
+  
+  if (VST)
+    VST->removeValueName(V->Name);
+  Name = V->Name;
+  V->Name = 0;
+  Name->setValue(this);
+  
+  if (ST)
+    ST->reinsertValue(this);
+}
+
+
 // uncheckedReplaceAllUsesWith - This is exactly the same as replaceAllUsesWith,
 // except that it doesn't have all of the asserts.  The asserts fail because we
 // are half-way done resolving types, which causes some types to exist as two
@@ -131,8 +279,8 @@ void Value::uncheckedReplaceAllUsesWith(Value *New) {
     // constant!
     if (Constant *C = dyn_cast<Constant>(U.getUser())) {
       if (!isa<GlobalValue>(C))
-        C->replaceUsesOfWithOnConstant(this, New, true);
-      else 
+        C->replaceUsesOfWithOnConstant(this, New, &U);
+      else
         U.set(New);
     } else {
       U.set(New);