X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FFunction.cpp;h=eb3bf250a7308b296061457a692ee82669624760;hb=f28265402130eb03762d9a6333fd8f87765a8875;hp=f7d7953aabeeda47469705c684d336d0b77f3471;hpb=7e70829632f82de15db187845666aaca6e04b792;p=oota-llvm.git diff --git a/lib/VMCore/Function.cpp b/lib/VMCore/Function.cpp index f7d7953aabe..eb3bf250a73 100644 --- a/lib/VMCore/Function.cpp +++ b/lib/VMCore/Function.cpp @@ -1,25 +1,41 @@ -//===-- Function.cpp - Implement the Global object classes -------*- C++ -*--=// +//===-- Function.cpp - Implement the Global object 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 Function & GlobalVariable classes for the VMCore // library. // //===----------------------------------------------------------------------===// -#include "llvm/Function.h" -#include "llvm/DerivedTypes.h" #include "llvm/Module.h" -#include "llvm/GlobalVariable.h" -#include "llvm/BasicBlock.h" -#include "llvm/iOther.h" -#include "llvm/Argument.h" +#include "llvm/DerivedTypes.h" +#include "llvm/IntrinsicInst.h" +#include "llvm/Support/LeakDetector.h" #include "SymbolTableListTraitsImpl.h" +#include "llvm/ADT/StringExtras.h" +using namespace llvm; + +BasicBlock *ilist_traits::createSentinel() { + BasicBlock *Ret = new BasicBlock(); + // This should not be garbage monitored. + LeakDetector::removeGarbageObject(Ret); + return Ret; +} iplist &ilist_traits::getList(Function *F) { return F->getBasicBlockList(); } -Argument *ilist_traits::createNode() { - return new Argument(Type::IntTy); +Argument *ilist_traits::createSentinel() { + Argument *Ret = new Argument(Type::IntTy); + // This should not be garbage monitored. + LeakDetector::removeGarbageObject(Ret); + return Ret; } iplist &ilist_traits::getList(Function *F) { @@ -28,93 +44,137 @@ iplist &ilist_traits::getList(Function *F) { // Explicit instantiations of SymbolTableListTraits since some of the methods // are not in the public header file... -template SymbolTableListTraits; -template SymbolTableListTraits; +template class SymbolTableListTraits; +template class SymbolTableListTraits; //===----------------------------------------------------------------------===// // Argument Implementation //===----------------------------------------------------------------------===// -// Specialize setName to take care of symbol table majik -void Argument::setName(const std::string &name, SymbolTable *ST) { - Function *P; - assert((ST == 0 || (!getParent() || ST == getParent()->getSymbolTable())) && - "Invalid symtab argument!"); - if ((P = getParent()) && hasName()) P->getSymbolTable()->remove(this); - Value::setName(name); - if (P && hasName()) P->getSymbolTable()->insert(this); +Argument::Argument(const Type *Ty, const std::string &Name, Function *Par) + : Value(Ty, Value::ArgumentVal, Name) { + Parent = 0; + + // Make sure that we get added to a function + LeakDetector::addGarbageObject(this); + + if (Par) + Par->getArgumentList().push_back(this); +} + +void Argument::setParent(Function *parent) { + if (getParent()) + LeakDetector::addGarbageObject(this); + Parent = parent; + if (getParent()) + LeakDetector::removeGarbageObject(this); } //===----------------------------------------------------------------------===// // Function Implementation //===----------------------------------------------------------------------===// - -Function::Function(const FunctionType *Ty, bool isInternal, - const std::string &name) - : GlobalValue(PointerType::get(Ty), Value::FunctionVal, isInternal, name) { +Function::Function(const FunctionType *Ty, LinkageTypes Linkage, + const std::string &name, Module *ParentModule) + : GlobalValue(PointerType::get(Ty), Value::FunctionVal, 0, 0, Linkage, name) { + CallingConvention = 0; BasicBlocks.setItemParent(this); BasicBlocks.setParent(this); ArgumentList.setItemParent(this); ArgumentList.setParent(this); - ParentSymTab = SymTab = 0; + SymTab = new SymbolTable(); + + assert((getReturnType()->isFirstClassType() ||getReturnType() == Type::VoidTy) + && "LLVM functions cannot return aggregate values!"); + + // Create the arguments vector, all arguments start out unnamed. + for (unsigned i = 0, e = Ty->getNumParams(); i != e; ++i) { + assert(Ty->getParamType(i) != Type::VoidTy && + "Cannot have void typed arguments!"); + ArgumentList.push_back(new Argument(Ty->getParamType(i))); + } + + // Make sure that we get added to a function + LeakDetector::addGarbageObject(this); + + if (ParentModule) + ParentModule->getFunctionList().push_back(this); } Function::~Function() { dropAllReferences(); // After this it is safe to delete instructions. - BasicBlocks.clear(); // Delete all basic blocks... - // Delete all of the method arguments and unlink from symbol table... ArgumentList.clear(); ArgumentList.setParent(0); delete SymTab; } -// Specialize setName to take care of symbol table majik -void Function::setName(const std::string &name, SymbolTable *ST) { - Module *P; - assert((ST == 0 || (!getParent() || ST == getParent()->getSymbolTable())) && - "Invalid symtab argument!"); - if ((P = getParent()) && hasName()) P->getSymbolTable()->remove(this); - Value::setName(name); - if (P && getName() != "") P->getSymbolTableSure()->insert(this); -} - void Function::setParent(Module *parent) { + if (getParent()) + LeakDetector::addGarbageObject(this); Parent = parent; - - // Relink symbol tables together... - ParentSymTab = Parent ? Parent->getSymbolTableSure() : 0; - if (SymTab) SymTab->setParentSymTab(ParentSymTab); + if (getParent()) + LeakDetector::removeGarbageObject(this); } const FunctionType *Function::getFunctionType() const { return cast(getType()->getElementType()); } -const Type *Function::getReturnType() const { +bool Function::isVarArg() const { + return getFunctionType()->isVarArg(); +} + +const Type *Function::getReturnType() const { return getFunctionType()->getReturnType(); } -SymbolTable *Function::getSymbolTableSure() { - if (!SymTab) SymTab = new SymbolTable(ParentSymTab); - return SymTab; +void Function::removeFromParent() { + getParent()->getFunctionList().remove(this); } -// hasSymbolTable() - Returns true if there is a symbol table allocated to -// this object AND if there is at least one name in it! -// -bool Function::hasSymbolTable() const { - if (!SymTab) return false; +void Function::eraseFromParent() { + getParent()->getFunctionList().erase(this); +} - 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; + +/// renameLocalSymbols - This method goes through the Function's symbol table +/// and renames any symbols that conflict with symbols at global scope. This is +/// required before printing out to a textual form, to ensure that there is no +/// ambiguity when parsing. +void Function::renameLocalSymbols() { + SymbolTable &LST = getSymbolTable(); // Local Symtab + SymbolTable &GST = getParent()->getSymbolTable(); // Global Symtab + + for (SymbolTable::plane_iterator LPI = LST.plane_begin(), E = LST.plane_end(); + LPI != E; ++LPI) + // All global symbols are of pointer type, ignore any non-pointer planes. + if (const PointerType *CurTy = dyn_cast(LPI->first)) { + // Only check if the global plane has any symbols of this type. + SymbolTable::plane_iterator GPI = GST.find(LPI->first); + if (GPI != GST.plane_end()) { + SymbolTable::ValueMap &LVM = LPI->second; + const SymbolTable::ValueMap &GVM = GPI->second; + + // Loop over all local symbols, renaming those that are in the global + // symbol table already. + for (SymbolTable::value_iterator VI = LVM.begin(), E = LVM.end(); + VI != E;) { + Value *V = VI->second; + const std::string &Name = VI->first; + ++VI; + if (GVM.count(Name)) { + static unsigned UniqueNum = 0; + // Find a name that does not conflict! + while (GVM.count(Name + "_" + utostr(++UniqueNum)) || + LVM.count(Name + "_" + utostr(UniqueNum))) + /* scan for UniqueNum that works */; + V->setName(Name + "_" + utostr(UniqueNum)); + } + } + } + } } @@ -122,33 +182,73 @@ bool Function::hasSymbolTable() const { // go" of all references that they are maintaining. This allows one to // 'delete' a whole class at a time, even though there may be circular // references... first all references are dropped, and all use counts go to -// zero. Then everything is delete'd for real. Note that no operations are -// valid on an object that has "dropped all references", except operator +// zero. Then everything is deleted for real. Note that no operations are +// valid on an object that has "dropped all references", except operator // delete. // void Function::dropAllReferences() { for (iterator I = begin(), E = end(); I != E; ++I) I->dropAllReferences(); + BasicBlocks.clear(); // Delete all basic blocks... } -//===----------------------------------------------------------------------===// -// GlobalVariable Implementation -//===----------------------------------------------------------------------===// +/// getIntrinsicID - This method returns the ID number of the specified +/// function, or Intrinsic::not_intrinsic if the function is not an +/// intrinsic, or if the pointer is null. This value is always defined to be +/// zero to allow easy checking for whether a function is intrinsic or not. The +/// particular intrinsic functions which correspond to this value are defined in +/// llvm/Intrinsics.h. +/// +unsigned Function::getIntrinsicID() const { + const std::string& Name = this->getName(); + if (Name.size() < 5 || Name[4] != '.' || Name[0] != 'l' || Name[1] != 'l' + || Name[2] != 'v' || Name[3] != 'm') + return 0; // All intrinsics start with 'llvm.' + + assert(Name.size() != 5 && "'llvm.' is an invalid intrinsic name!"); + +#define GET_FUNCTION_RECOGNIZER +#include "llvm/Intrinsics.gen" +#undef GET_FUNCTION_RECOGNIZER + return 0; +} -GlobalVariable::GlobalVariable(const Type *Ty, bool constant, bool isIntern, - Constant *Initializer = 0, - const std::string &Name = "") - : GlobalValue(PointerType::get(Ty), Value::GlobalVariableVal, isIntern, Name), - isConstantGlobal(constant) { - if (Initializer) Operands.push_back(Use((Value*)Initializer, this)); +const char *Intrinsic::getName(ID id) { + assert(id < num_intrinsics && "Invalid intrinsic ID!"); + const char * const Table[] = { + "not_intrinsic", +#define GET_INTRINSIC_NAME_TABLE +#include "llvm/Intrinsics.gen" +#undef GET_INTRINSIC_NAME_TABLE + }; + return Table[id]; } -// Specialize setName to take care of symbol table majik -void GlobalVariable::setName(const std::string &name, SymbolTable *ST) { - Module *P; - assert((ST == 0 || (!getParent() || ST == getParent()->getSymbolTable())) && - "Invalid symtab argument!"); - if ((P = getParent()) && hasName()) P->getSymbolTable()->remove(this); - Value::setName(name); - if (P && getName() != "") P->getSymbolTableSure()->insert(this); +Value *IntrinsicInst::StripPointerCasts(Value *Ptr) { + if (ConstantExpr *CE = dyn_cast(Ptr)) { + if (CE->getOpcode() == Instruction::Cast) { + if (isa(CE->getOperand(0)->getType())) + return StripPointerCasts(CE->getOperand(0)); + } else if (CE->getOpcode() == Instruction::GetElementPtr) { + for (unsigned i = 1, e = CE->getNumOperands(); i != e; ++i) + if (!CE->getOperand(i)->isNullValue()) + return Ptr; + return StripPointerCasts(CE->getOperand(0)); + } + return Ptr; + } + + if (CastInst *CI = dyn_cast(Ptr)) { + if (isa(CI->getOperand(0)->getType())) + return StripPointerCasts(CI->getOperand(0)); + } else if (GetElementPtrInst *GEP = dyn_cast(Ptr)) { + for (unsigned i = 1, e = GEP->getNumOperands(); i != e; ++i) + if (!isa(GEP->getOperand(i)) || + !cast(GEP->getOperand(i))->isNullValue()) + return Ptr; + return StripPointerCasts(GEP->getOperand(0)); + } + return Ptr; } + +// vim: sw=2 ai