X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FValue.cpp;h=ac13159e30aa9f5d53930b055a1c6dcf827aa25e;hb=27287de06b0a6d3c2713fc3a78281df8f5d1a0fa;hp=79d8e0a46205f292cf839e122648b1fb04137120;hpb=7fc9fe34390c66ca58646d09a87f7dbaacb6c1f8;p=oota-llvm.git diff --git a/lib/VMCore/Value.cpp b/lib/VMCore/Value.cpp index 79d8e0a4620..ac13159e30a 100644 --- a/lib/VMCore/Value.cpp +++ b/lib/VMCore/Value.cpp @@ -1,27 +1,27 @@ //===-- Value.cpp - Implement the Value class -----------------------------===// // -// This file implements the Value class. +// This file implements the Value and User classes. // //===----------------------------------------------------------------------===// -#include "llvm/ValueHolderImpl.h" #include "llvm/InstrTypes.h" #include "llvm/SymbolTable.h" -#include "llvm/SymTabValue.h" -#include "llvm/ConstantPool.h" -#include "llvm/ConstPoolVals.h" -#include "llvm/Type.h" -#ifndef NDEBUG // Only in -g mode... -#include "llvm/Assembly/Writer.h" -#endif +#include "llvm/DerivedTypes.h" +#include "llvm/Constant.h" +#include "Support/LeakDetector.h" #include //===----------------------------------------------------------------------===// // Value Class //===----------------------------------------------------------------------===// -Value::Value(const Type *ty, ValueTy vty, const string &name = "") : Name(name){ - Ty = ty; +static inline const Type *checkType(const Type *Ty) { + assert(Ty && "Value defined with a null type: Error!"); + return Ty; +} + +Value::Value(const Type *ty, ValueTy vty, const std::string &name) + : Name(name), Ty(checkType(ty), this) { VTy = vty; } @@ -34,51 +34,70 @@ Value::~Value() { // a // if (Uses.begin() != Uses.end()) { + std::cerr << "While deleting: " << Ty << "%" << Name << "\n"; for (use_const_iterator I = Uses.begin(); I != Uses.end(); ++I) - cerr << "Use still stuck around after Def is destroyed:" << *I << endl; + std::cerr << "Use still stuck around after Def is destroyed:" + << **I << "\n"; } #endif assert(Uses.begin() == Uses.end()); + + // 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!"); - while (!Uses.empty()) { - User *Use = Uses.front(); -#ifndef NDEBUG - unsigned NumUses = Uses.size(); -#endif - Use->replaceUsesOfWith(this, D); -#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!"); - } -} -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); +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!"); + while (!Uses.empty()) { + User *Use = Uses.back(); + // Must handle Constants specially, we cannot call replaceUsesOfWith on a + // constant! + if (Constant *C = dyn_cast(Use)) { + C->replaceUsesOfWithOnConstant(this, New); + } else { + Use->replaceUsesOfWith(this, New); + } + } } -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; +// 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; } +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 */; + + assert(i < Uses.size() && "Use not in uses list!!"); + Uses[i] = Uses.back(); + Uses.pop_back(); +} //===----------------------------------------------------------------------===// // User Class //===----------------------------------------------------------------------===// -User::User(const Type *Ty, ValueTy vty, const string &name) +User::User(const Type *Ty, ValueTy vty, const std::string &name) : Value(Ty, vty, name) { } @@ -88,62 +107,14 @@ User::User(const Type *Ty, ValueTy vty, const string &name) void User::replaceUsesOfWith(Value *From, Value *To) { if (From == To) return; // Duh what? - for (unsigned OpNum = 0; Value *D = getOperand(OpNum); ++OpNum) { - if (D == From) { // Okay, this operand is pointing to our fake def. + assert(!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(OpNum, To); // Fix it now... + setOperand(i, To); // Fix it now... } - } -} - - -//===----------------------------------------------------------------------===// -// SymTabValue Class -//===----------------------------------------------------------------------===// - -// Instantiate Templates - This ugliness is the price we have to pay -// for having a ValueHolderImpl.h file seperate from ValueHolder.h! :( -// -template class ValueHolder; - -SymTabValue::SymTabValue(const Type *Ty, ValueTy dty, const string &name = "") - : Value(Ty, dty, name), ConstPool(this) { - ParentSymTab = SymTab = 0; -} - - -SymTabValue::~SymTabValue() { - ConstPool.dropAllReferences(); - ConstPool.delete_all(); - ConstPool.setParent(0); - - delete SymTab; -} - -void SymTabValue::setParentSymTab(SymbolTable *ST) { - ParentSymTab = ST; - if (SymTab) - SymTab->setParentSymTab(ST); -} - -SymbolTable *SymTabValue::getSymbolTableSure() { - if (!SymTab) SymTab = new SymbolTable(ParentSymTab); - return SymTab; -} - -// hasSymbolTable() - Returns true if there is a symbol table allocated to -// this object AND if there is at least one name in it! -// -bool SymTabValue::hasSymbolTable() const { - if (!SymTab) return false; - - 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; }