use a nicer accessor.

[oota-llvm.git] / lib / VMCore / Value.cpp

diff --git a/lib/VMCore/Value.cpp b/lib/VMCore/Value.cpp
index 109994efb71a48f48e00ba1d6b7e94b5a90c8fbc..2178ce47a3f5ad7cf6761fc90be47075ea0748ef 100644 (file)
--- a/lib/VMCore/Value.cpp
+++ b/lib/VMCore/Value.cpp
@@ -56,6 +56,11 @@ Value::~Value() {
 #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);
 }
@@ -112,16 +117,38 @@ static bool getSymTab(Value *V, ValueSymbolTable *&ST) {
   return false;
 }
 
-std::string Value::getName() const {
+/// 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.empty() && !hasName()) return;
-  if (getType() != Type::VoidTy && "Cannot assign a name to void values!");
-  
+  setName(&name[0], name.size());
+}
+
+void Value::setName(const char *Name) {
+  setName(Name, Name ? strlen(Name) : 0);
+}
+
+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;
@@ -129,23 +156,27 @@ void Value::setName(const std::string &name) {
     return;  // Cannot set a name on this value (e.g. constant).
 
   if (!ST) { // No symbol table to update?  Just do the change.
-    if (name.empty()) {
+    if (NameLen == 0) {
       // Free the name for this value.
       Name->Destroy();
       Name = 0;
-    } else {
-      if (Name) {
-        // Name isn't changing.
-        if (name.size() == Name->getKeyLength() &&
-            !memcmp(Name->getKeyData(), &name[0], name.size()))
-          return;
-        Name->Destroy();
-      }
-      
-      // Create the new name.
-      Name = ValueName::Create(&name[0], &name[name.size()]);
-      Name->setValue(this);
+      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;
   }
   
@@ -153,8 +184,8 @@ void Value::setName(const std::string &name) {
   // then reallocated.
   if (hasName()) {
     // Name isn't changing?
-    if (name.size() == Name->getKeyLength() &&
-        !memcmp(Name->getKeyData(), &name[0], name.size()))
+    if (NameLen == Name->getKeyLength() &&
+        !memcmp(Name->getKeyData(), NameStr, NameLen))
       return;
 
     // Remove old name.
@@ -162,26 +193,76 @@ void Value::setName(const std::string &name) {
     Name->Destroy();
     Name = 0;
 
-    if (name.empty())
-       return;
+    if (NameLen == 0)
+      return;
   }
 
   // Name is changing to something new.
-  Name = ST->createValueName(&name[0], name.size(), this);
+  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) {
-  if (!V->hasName()) {
-    if (hasName())
-      setName("");
+  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;
   }
   
-  std::string Name = V->getName();
-  V->setName("");
-  setName(Name);
+  // 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);
 }