X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FValue.cpp;h=0d9dc07fa074441c8ac2bb7af458e7e04b9062be;hb=2e3def1177c462e14b20ddad71adf5c6b7c3e867;hp=efb0cdf8e17ac2142085e06a140e51f9b135f666;hpb=d1c657e2c7d1e0afb66ffce14775a88b5d52c593;p=oota-llvm.git diff --git a/lib/VMCore/Value.cpp b/lib/VMCore/Value.cpp index efb0cdf8e17..0d9dc07fa07 100644 --- a/lib/VMCore/Value.cpp +++ b/lib/VMCore/Value.cpp @@ -1,14 +1,25 @@ //===-- Value.cpp - Implement the Value class -----------------------------===// // -// This file implements the Value and User 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/Constant.h" +#include "llvm/DerivedTypes.h" #include "llvm/InstrTypes.h" +#include "llvm/Module.h" #include "llvm/SymbolTable.h" -#include "llvm/DerivedTypes.h" -#include "Support/LeakDetector.h" +#include "llvm/Support/Debug.h" +#include "llvm/Support/LeakDetector.h" #include +using namespace llvm; //===----------------------------------------------------------------------===// // Value Class @@ -19,9 +30,15 @@ static inline const Type *checkType(const Type *Ty) { return Ty; } -Value::Value(const Type *ty, ValueTy vty, const std::string &name) - : Name(name), Ty(checkType(ty), this) { - VTy = vty; +Value::Value(const Type *ty, unsigned scid, const std::string &name) + : SubclassID(scid), SubclassData(0), Ty(checkType(ty)), + UseList(0), Name(name) { + if (!isa(this) && !isa(this)) + assert((Ty->isFirstClassType() || Ty == Type::VoidTy || + isa(ty)) && + "Cannot create non-first-class values except for constants!"); + if (ty == Type::VoidTy) + assert(name.empty() && "Cannot have named void values!"); } Value::~Value() { @@ -29,89 +46,132 @@ 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()) { - std::cerr << "While deleting: " << Ty << "%" << Name << "\n"; - for (use_const_iterator I = Uses.begin(); I != Uses.end(); ++I) - std::cerr << "Use still stuck around after Def is destroyed:" - << **I << "\n"; + 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!"); // 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!"); - assert(D->getType() == getType() && - "replaceAllUses of value with new value of different type!"); - 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) - std::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() == OldTy && "Can't refine anything but my type!"); - if (OldTy == NewTy && !OldTy->isAbstract()) - Ty.removeUserFromConcrete(); - 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; +} + + +/// 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()); } -void Value::killUse(User *U) { - if (U == 0) return; - unsigned i; - // Scan backwards through the uses list looking for the user. We do this - // because vectors like to be accessed on the end. This is incredibly - // important from a performance perspective. - for (i = Uses.size()-1; Uses[i] != U; --i) - /* empty */; +void Value::setName(const std::string &name) { + if (Name == name) return; // Name is already set. + + // Get the symbol table to update for this object. + SymbolTable *ST = 0; + if (Instruction *I = dyn_cast(this)) { + if (BasicBlock *P = I->getParent()) + if (Function *PP = P->getParent()) + ST = &PP->getSymbolTable(); + } else if (BasicBlock *BB = dyn_cast(this)) { + if (Function *P = BB->getParent()) ST = &P->getSymbolTable(); + } else if (GlobalValue *GV = dyn_cast(this)) { + if (Module *P = GV->getParent()) ST = &P->getSymbolTable(); + } else if (Argument *A = dyn_cast(this)) { + if (Function *P = A->getParent()) ST = &P->getSymbolTable(); + } else { + assert(isa(this) && "Unknown value type!"); + return; // no name is setable for this. + } - assert(i < Uses.size() && "Use not in uses list!!"); - Uses.erase(Uses.begin()+i); + if (!ST) // No symbol table to update? Just do the change. + Name = name; + else if (hasName()) { + if (!name.empty()) { // Replacing name. + ST->changeName(this, name); + } else { // Transitioning from hasName -> noname. + ST->remove(this); + Name.clear(); + } + } else { // Transitioning from noname -> hasName. + Name = name; + ST->insert(this); + } } -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; +// 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); + } + } +} + +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); } //===----------------------------------------------------------------------===// // User Class //===----------------------------------------------------------------------===// -User::User(const Type *Ty, ValueTy vty, const std::string &name) - : Value(Ty, vty, name) { -} - // 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? + 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 @@ -121,4 +181,3 @@ void User::replaceUsesOfWith(Value *From, Value *To) { } } -