X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;ds=sidebyside;f=lib%2FVMCore%2FValue.cpp;h=2178ce47a3f5ad7cf6761fc90be47075ea0748ef;hb=453eed147ad009f4608197928a3ed8ea7e67a78d;hp=d40aaca2773b67bbaa208fa1bc06347c566c3a2a;hpb=5efec2890119801f870159a59b15b116df0d070b;p=oota-llvm.git diff --git a/lib/VMCore/Value.cpp b/lib/VMCore/Value.cpp index d40aaca2773..2178ce47a3f 100644 --- a/lib/VMCore/Value.cpp +++ b/lib/VMCore/Value.cpp @@ -1,27 +1,42 @@ //===-- Value.cpp - Implement the Value class -----------------------------===// // -// This file implements the Value, User, and SymTabValue classes. +// 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. // //===----------------------------------------------------------------------===// -#include "llvm/ValueHolderImpl.h" +#include "llvm/Constant.h" +#include "llvm/DerivedTypes.h" #include "llvm/InstrTypes.h" -#include "llvm/SymbolTable.h" -#include "llvm/SymTabValue.h" -#include "llvm/ConstPoolVals.h" -#include "llvm/Type.h" -#ifndef NDEBUG // Only in -g mode... -#include "llvm/Assembly/Writer.h" -#endif +#include "llvm/Module.h" +#include "llvm/ValueSymbolTable.h" +#include "llvm/Support/Debug.h" +#include "llvm/Support/LeakDetector.h" #include +using namespace llvm; //===----------------------------------------------------------------------===// // Value Class //===----------------------------------------------------------------------===// -Value::Value(const Type *ty, ValueTy vty, const string &name = "") - : Name(name), Ty(ty, this) { - VTy = vty; +static inline const Type *checkType(const Type *Ty) { + assert(Ty && "Value defined with a null type: Error!"); + return Ty; +} + +Value::Value(const Type *ty, unsigned scid) + : SubclassID(scid), SubclassData(0), Ty(checkType(ty)), + UseList(0), Name(0) { + if (!isa(this) && !isa(this)) + assert((Ty->isFirstClassType() || Ty == Type::VoidTy || + isa(ty)) && + "Cannot create non-first-class values except for constants!"); } Value::~Value() { @@ -29,127 +44,278 @@ 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 // - if (Uses.begin() != Uses.end()) { - cerr << "While deleting: " << this; - for (use_const_iterator I = Uses.begin(); I != Uses.end(); ++I) - cerr << "Use still stuck around after Def is destroyed:" << *I << endl; + if (use_begin() != use_end()) { + DOUT << "While deleting: " << *Ty << " %" << Name << "\n"; + for (use_iterator I = use_begin(), E = use_end(); I != E; ++I) + DOUT << "Use still stuck around after Def is destroyed:" + << **I << "\n"; } #endif - assert(Uses.begin() == Uses.end()); + 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); } -void Value::replaceAllUsesWith(Value *D) { - assert(D && "Value::replaceAllUsesWith() is invalid!"); - assert(D != this && "V->replaceAllUsesWith(V) is NOT valid!"); - while (!Uses.empty()) { - User *Use = Uses.back(); -#ifndef NDEBUG - unsigned NumUses = Uses.size(); -#endif - Use->replaceUsesOfWith(this, D); +/// hasNUses - Return true if this Value has exactly N users. +/// +bool Value::hasNUses(unsigned N) const { + use_const_iterator UI = use_begin(), E = use_end(); -#ifndef NDEBUG // only in -g mode... - if (Uses.size() == NumUses) - cerr << "Use: " << Use << "replace with: " << D; -#endif - assert(Uses.size() != NumUses && "Didn't remove definition!"); - } + for (; N; --N, ++UI) + if (UI == E) return false; // Too few. + return UI == E; } -// refineAbstractType - This function is implemented because we use -// potentially abstract types, and these types may be resolved to more -// concrete types after we are constructed. For the value class, we simply -// change Ty to point to the right type. :) -// -void Value::refineAbstractType(const DerivedType *OldTy, const Type *NewTy) { - assert(Ty.get() == (const Type*)OldTy &&"Can't refine anything but my type!"); - Ty = NewTy; +/// hasNUsesOrMore - Return true if this value has N users or more. This is +/// logically equivalent to getNumUses() >= N. +/// +bool Value::hasNUsesOrMore(unsigned N) const { + use_const_iterator UI = use_begin(), E = use_end(); + + for (; N; --N, ++UI) + if (UI == E) return false; // Too few. + + return true; } -void Value::killUse(User *i) { - if (i == 0) return; - use_iterator I = find(Uses.begin(), Uses.end(), i); - assert(I != Uses.end() && "Use not in uses list!!"); - Uses.erase(I); +/// getNumUses - This method computes the number of uses of this Value. This +/// is a linear time operation. Use hasOneUse or hasNUses to check for specific +/// values. +unsigned Value::getNumUses() const { + return (unsigned)std::distance(use_begin(), use_end()); } -User *Value::use_remove(use_iterator &I) { - assert(I != Uses.end() && "Trying to remove the end of the use list!!!"); - User *i = *I; - I = Uses.erase(I); - return i; +static bool getSymTab(Value *V, ValueSymbolTable *&ST) { + ST = 0; + if (Instruction *I = dyn_cast(V)) { + if (BasicBlock *P = I->getParent()) + if (Function *PP = P->getParent()) + ST = &PP->getValueSymbolTable(); + } else if (BasicBlock *BB = dyn_cast(V)) { + if (Function *P = BB->getParent()) + ST = &P->getValueSymbolTable(); + } else if (GlobalValue *GV = dyn_cast(V)) { + if (Module *P = GV->getParent()) + ST = &P->getValueSymbolTable(); + } else if (Argument *A = dyn_cast(V)) { + if (Function *P = A->getParent()) + ST = &P->getValueSymbolTable(); + } else { + assert(isa(V) && "Unknown value type!"); + return true; // no name is setable for this. + } + return false; } -#ifndef NDEBUG // Only in -g mode... -void Value::dump() const { - cerr << this; +/// 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(); } -#endif -//===----------------------------------------------------------------------===// -// User Class -//===----------------------------------------------------------------------===// +/// getNameLen - Return the length of the string, correctly handling nul +/// characters embedded into them. +unsigned Value::getNameLen() const { + return Name->getKeyLength(); +} -User::User(const Type *Ty, ValueTy vty, const string &name) - : Value(Ty, vty, name) { + +std::string Value::getNameStr() const { + if (Name == 0) return ""; + return std::string(Name->getKeyData(), + Name->getKeyData()+Name->getKeyLength()); } -// replaceUsesOfWith - Replaces all references to the "From" definition with -// references to the "To" definition. -// -void User::replaceUsesOfWith(Value *From, Value *To) { - if (From == To) return; // Duh what? +void Value::setName(const std::string &name) { + setName(&name[0], name.size()); +} - for (unsigned i = 0, E = getNumOperands(); i != E; ++i) - if (getOperand(i) == From) { // Is This operand is pointing to oldval? - // The side effects of this setOperand call include linking to - // "To", adding "this" to the uses list of To, and - // most importantly, removing "this" from the use list of "From". - setOperand(i, To); // Fix it now... - } +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; + if (getSymTab(this, ST)) + return; // Cannot set a name on this value (e.g. constant). -//===----------------------------------------------------------------------===// -// SymTabValue Class -//===----------------------------------------------------------------------===// + 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; + } -SymTabValue::SymTabValue(Value *p) : ValueParent(p) { - assert(ValueParent && "SymTavValue without parent!?!"); - ParentSymTab = SymTab = 0; + // Name is changing to something new. + Name = ST->createValueName(NameStr, NameLen, this); } -SymTabValue::~SymTabValue() { - delete SymTab; +/// 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); } -void SymTabValue::setParentSymTab(SymbolTable *ST) { - ParentSymTab = ST; - if (SymTab) - SymTab->setParentSymTab(ST); + +// 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 +// different Type*'s at the same time. This is a sledgehammer to work around +// this problem. +// +void Value::uncheckedReplaceAllUsesWith(Value *New) { + while (!use_empty()) { + Use &U = *UseList; + // Must handle Constants specially, we cannot call replaceUsesOfWith on a + // constant! + if (Constant *C = dyn_cast(U.getUser())) { + if (!isa(C)) + C->replaceUsesOfWithOnConstant(this, New, &U); + else + U.set(New); + } else { + U.set(New); + } + } } -SymbolTable *SymTabValue::getSymbolTableSure() { - if (!SymTab) SymTab = new SymbolTable(ParentSymTab); - return SymTab; +void Value::replaceAllUsesWith(Value *New) { + assert(New && "Value::replaceAllUsesWith() is invalid!"); + assert(New != this && "this->replaceAllUsesWith(this) is NOT valid!"); + assert(New->getType() == getType() && + "replaceAllUses of value with new value of different type!"); + + uncheckedReplaceAllUsesWith(New); } -// hasSymbolTable() - Returns true if there is a symbol table allocated to -// this object AND if there is at least one name in it! +//===----------------------------------------------------------------------===// +// User Class +//===----------------------------------------------------------------------===// + +// replaceUsesOfWith - Replaces all references to the "From" definition with +// references to the "To" definition. // -bool SymTabValue::hasSymbolTable() const { - if (!SymTab) return false; +void User::replaceUsesOfWith(Value *From, Value *To) { + if (From == To) return; // Duh what? - for (SymbolTable::const_iterator I = SymTab->begin(); - I != SymTab->end(); ++I) { - if (I->second.begin() != I->second.end()) - return true; // Found nonempty type plane! - } - - return false; + assert(!isa(this) || isa(this) && + "Cannot call User::replaceUsesofWith on a constant!"); + + for (unsigned i = 0, E = getNumOperands(); i != E; ++i) + if (getOperand(i) == From) { // Is This operand is pointing to oldval? + // The side effects of this setOperand call include linking to + // "To", adding "this" to the uses list of To, and + // most importantly, removing "this" from the use list of "From". + setOperand(i, To); // Fix it now... + } } +