X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FValue.cpp;h=da3d87f9d2e7b7c4d623b7630a1767db3e738e33;hb=ee37bb34d133060318966b26317e063a1fee0c5f;hp=1c3f76bc4b6a06cfae55438f1319892c4247096b;hpb=009505452b713ed2e3a8e99c5545a6e721c65495;p=oota-llvm.git diff --git a/lib/VMCore/Value.cpp b/lib/VMCore/Value.cpp index 1c3f76bc4b6..da3d87f9d2e 100644 --- a/lib/VMCore/Value.cpp +++ b/lib/VMCore/Value.cpp @@ -1,35 +1,43 @@ //===-- 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 //===----------------------------------------------------------------------===// // 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; } Value::~Value() { #ifndef NDEBUG // Only in -g mode... + // 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 + // a + // if (Uses.begin() != Uses.end()) { - for (use_const_iterator I = Uses.begin(); I != Uses.end(); I++) - cerr << "Use still stuck around after Def is destroyed:" << *I << endl; + 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)->dump(); + std::cerr << "\n"; + } } #endif assert(Uses.begin() == Uses.end()); @@ -37,21 +45,40 @@ Value::~Value() { 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.front(); + User *Use = Uses.back(); #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; + if (Uses.size() == NumUses) { + std::cerr << "Use: "; + Use->dump(); + std::cerr << "replace with: "; + D->dump(); + } #endif assert(Uses.size() != NumUses && "Didn't remove definition!"); } } +// 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 *i) { if (i == 0) return; use_iterator I = find(Uses.begin(), Uses.end(), i); @@ -67,12 +94,11 @@ User *Value::use_remove(use_iterator &I) { return i; } - //===----------------------------------------------------------------------===// // 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) { } @@ -82,62 +108,13 @@ 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. + 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; -}