X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FValue.cpp;h=f59e8ef957e5a5e97a5f6e6de83544f81bd442a9;hb=9530ddcc605cb65d0a19bbfbfb8b73b09c4e4cfa;hp=01c7b3f4620193b819ec22eb6e1bfd1e88bdb192;hpb=e2fac77ad355b732da347e51234f02579da62bb6;p=oota-llvm.git diff --git a/lib/VMCore/Value.cpp b/lib/VMCore/Value.cpp index 01c7b3f4620..f59e8ef957e 100644 --- a/lib/VMCore/Value.cpp +++ b/lib/VMCore/Value.cpp @@ -1,21 +1,22 @@ //===-- 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. // //===----------------------------------------------------------------------===// +#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 "llvm/Constant.h" -#include "Support/LeakDetector.h" +#include "llvm/Support/LeakDetector.h" #include #include using namespace llvm; @@ -30,7 +31,14 @@ static inline const Type *checkType(const Type *Ty) { } Value::Value(const Type *ty, unsigned scid, const std::string &name) - : SubclassID(scid), Ty(checkType(ty)), Name(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() { @@ -38,22 +46,87 @@ 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(), E = Uses.end(); I != E; ++I) + if (use_begin() != use_end()) { + std::cerr << "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"; } #endif - assert(Uses.begin() == Uses.end() &&"Uses remain when a value is destroyed!"); + 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); } +/// 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(); + + for (; N; --N, ++UI) + if (UI == E) return false; // Too few. + return UI == E; +} + +/// 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::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. + } + + 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); + } +} // uncheckedReplaceAllUsesWith - This is exactly the same as replaceAllUsesWith, // except that it doesn't have all of the asserts. The asserts fail because we @@ -62,12 +135,15 @@ Value::~Value() { // this problem. // void Value::uncheckedReplaceAllUsesWith(Value *New) { - while (!Uses.empty()) { - Use &U = Uses.back(); + while (!use_empty()) { + Use &U = *UseList; // Must handle Constants specially, we cannot call replaceUsesOfWith on a // constant! if (Constant *C = dyn_cast(U.getUser())) { - C->replaceUsesOfWithOnConstant(this, New, true); + if (!isa(C)) + C->replaceUsesOfWithOnConstant(this, New, true); + else + U.set(New); } else { U.set(New); } @@ -93,7 +169,7 @@ void Value::replaceAllUsesWith(Value *New) { void User::replaceUsesOfWith(Value *From, Value *To) { if (From == To) return; // Duh what? - assert(!isa(this) && + assert(!isa(this) || isa(this) && "Cannot call User::replaceUsesofWith on a constant!"); for (unsigned i = 0, E = getNumOperands(); i != E; ++i) @@ -104,3 +180,4 @@ void User::replaceUsesOfWith(Value *From, Value *To) { setOperand(i, To); // Fix it now... } } +