X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FFunction.cpp;h=eb3bf250a7308b296061457a692ee82669624760;hb=f28265402130eb03762d9a6333fd8f87765a8875;hp=82f3645acb10b534f7e581202faa445933b00353;hpb=f616f22e816ce7f7ba3414cf3d91c9410aa03223;p=oota-llvm.git diff --git a/lib/VMCore/Function.cpp b/lib/VMCore/Function.cpp index 82f3645acb1..eb3bf250a73 100644 --- a/lib/VMCore/Function.cpp +++ b/lib/VMCore/Function.cpp @@ -1,10 +1,10 @@ //===-- 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 @@ -14,13 +14,13 @@ #include "llvm/Module.h" #include "llvm/DerivedTypes.h" -#include "llvm/iOther.h" -#include "llvm/Intrinsics.h" -#include "Support/LeakDetector.h" +#include "llvm/IntrinsicInst.h" +#include "llvm/Support/LeakDetector.h" #include "SymbolTableListTraitsImpl.h" +#include "llvm/ADT/StringExtras.h" using namespace llvm; -BasicBlock *ilist_traits::createNode() { +BasicBlock *ilist_traits::createSentinel() { BasicBlock *Ret = new BasicBlock(); // This should not be garbage monitored. LeakDetector::removeGarbageObject(Ret); @@ -31,7 +31,7 @@ iplist &ilist_traits::getList(Function *F) { return F->getBasicBlockList(); } -Argument *ilist_traits::createNode() { +Argument *ilist_traits::createSentinel() { Argument *Ret = new Argument(Type::IntTy); // This should not be garbage monitored. LeakDetector::removeGarbageObject(Ret); @@ -51,7 +51,7 @@ template class SymbolTableListTraits; // Argument Implementation //===----------------------------------------------------------------------===// -Argument::Argument(const Type *Ty, const std::string &Name, Function *Par) +Argument::Argument(const Type *Ty, const std::string &Name, Function *Par) : Value(Ty, Value::ArgumentVal, Name) { Parent = 0; @@ -62,17 +62,6 @@ Argument::Argument(const Type *Ty, const std::string &Name, Function *Par) Par->getArgumentList().push_back(this); } - -// 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); -} - void Argument::setParent(Function *parent) { if (getParent()) LeakDetector::addGarbageObject(this); @@ -81,14 +70,14 @@ void Argument::setParent(Function *parent) { LeakDetector::removeGarbageObject(this); } - //===----------------------------------------------------------------------===// // Function Implementation //===----------------------------------------------------------------------===// Function::Function(const FunctionType *Ty, LinkageTypes Linkage, const std::string &name, Module *ParentModule) - : GlobalValue(PointerType::get(Ty), Value::FunctionVal, Linkage, name) { + : GlobalValue(PointerType::get(Ty), Value::FunctionVal, 0, 0, Linkage, name) { + CallingConvention = 0; BasicBlocks.setItemParent(this); BasicBlocks.setParent(this); ArgumentList.setItemParent(this); @@ -121,16 +110,6 @@ Function::~Function() { 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 && hasName()) P->getSymbolTable().insert(this); -} - void Function::setParent(Module *parent) { if (getParent()) LeakDetector::addGarbageObject(this); @@ -143,16 +122,68 @@ 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(); } +void Function::removeFromParent() { + getParent()->getFunctionList().remove(this); +} + +void Function::eraseFromParent() { + getParent()->getFunctionList().erase(this); +} + + +/// 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)); + } + } + } + } +} + + // dropAllReferences() - This function causes all the subinstructions to "let // 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 deleted for real. Note that no operations are -// valid on an object that has "dropped all references", except operator +// valid on an object that has "dropped all references", except operator // delete. // void Function::dropAllReferences() { @@ -169,126 +200,55 @@ void Function::dropAllReferences() { /// llvm/Intrinsics.h. /// unsigned Function::getIntrinsicID() const { - if (getName().size() < 5 || getName()[4] != '.' || getName()[0] != 'l' || - getName()[1] != 'l' || getName()[2] != 'v' || getName()[3] != 'm') + 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(getName().size() != 5 && "'llvm.' is an invalid intrinsic name!"); - - // a table of all Alpha intrinsic functions - struct { - std::string name; // The name of the intrinsic - unsigned id; // Its ID number - } alpha_intrinsics[] = { - { "llvm.alpha.ctlz", Intrinsic::alpha_ctlz }, - { "llvm.alpha.cttz", Intrinsic::alpha_cttz }, - { "llvm.alpha.ctpop", Intrinsic::alpha_ctpop }, - { "llvm.alpha.umulh", Intrinsic::alpha_umulh }, - { "llvm.alpha.vecop", Intrinsic::alpha_vecop }, - { "llvm.alpha.pup", Intrinsic::alpha_pup }, - { "llvm.alpha.bytezap", Intrinsic::alpha_bytezap }, - { "llvm.alpha.bytemanip", Intrinsic::alpha_bytemanip }, - { "llvm.alpha.dfp_bop", Intrinsic::alpha_dfpbop }, - { "llvm.alpha.dfp_uop", Intrinsic::alpha_dfpuop }, - { "llvm.alpha.unordered", Intrinsic::alpha_unordered }, - { "llvm.alpha.uqtodfp", Intrinsic::alpha_uqtodfp }, - { "llvm.alpha.uqtosfp", Intrinsic::alpha_uqtosfp }, - { "llvm.alpha.dfptosq", Intrinsic::alpha_dfptosq }, - { "llvm.alpha.sfptosq", Intrinsic::alpha_sfptosq }, - }; - const unsigned num_alpha_intrinsics = - sizeof(alpha_intrinsics) / sizeof(*alpha_intrinsics); - - switch (getName()[5]) { - case 'a': - if (getName().size() > 11 && - std::string(getName().begin()+4, getName().begin()+11) == ".alpha.") - for (unsigned i = 0; i < num_alpha_intrinsics; ++i) - if (getName() == alpha_intrinsics[i].name) - return alpha_intrinsics[i].id; - break; - case 'd': - if (getName() == "llvm.dbg.stoppoint") return Intrinsic::dbg_stoppoint; - if (getName() == "llvm.dbg.region.start")return Intrinsic::dbg_region_start; - if (getName() == "llvm.dbg.region.end") return Intrinsic::dbg_region_end; - if (getName() == "llvm.dbg.func.start") return Intrinsic::dbg_func_start; - if (getName() == "llvm.dbg.declare") return Intrinsic::dbg_declare; - break; - case 'f': - if (getName() == "llvm.frameaddress") return Intrinsic::frameaddress; - break; - case 'g': - if (getName() == "llvm.gcwrite") return Intrinsic::gcwrite; - if (getName() == "llvm.gcread") return Intrinsic::gcread; - if (getName() == "llvm.gcroot") return Intrinsic::gcroot; - break; - case 'i': - if (getName() == "llvm.isunordered") return Intrinsic::isunordered; - break; - case 'l': - if (getName() == "llvm.longjmp") return Intrinsic::longjmp; - break; - case 'm': - if (getName() == "llvm.memcpy") return Intrinsic::memcpy; - if (getName() == "llvm.memmove") return Intrinsic::memmove; - if (getName() == "llvm.memset") return Intrinsic::memset; - break; - case 'r': - if (getName() == "llvm.returnaddress") return Intrinsic::returnaddress; - if (getName() == "llvm.readport") return Intrinsic::readport; - if (getName() == "llvm.readio") return Intrinsic::readio; - break; - case 's': - if (getName() == "llvm.setjmp") return Intrinsic::setjmp; - if (getName() == "llvm.sigsetjmp") return Intrinsic::sigsetjmp; - if (getName() == "llvm.siglongjmp") return Intrinsic::siglongjmp; - break; - case 'v': - if (getName() == "llvm.va_copy") return Intrinsic::vacopy; - if (getName() == "llvm.va_end") return Intrinsic::vaend; - if (getName() == "llvm.va_start") return Intrinsic::vastart; - case 'w': - if (getName() == "llvm.writeport") return Intrinsic::writeport; - if (getName() == "llvm.writeio") return Intrinsic::writeio; - break; - } - // The "llvm." namespace is reserved! - assert(0 && "Unknown LLVM intrinsic function!"); + assert(Name.size() != 5 && "'llvm.' is an invalid intrinsic name!"); + +#define GET_FUNCTION_RECOGNIZER +#include "llvm/Intrinsics.gen" +#undef GET_FUNCTION_RECOGNIZER return 0; } +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]; +} + +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; + } -//===----------------------------------------------------------------------===// -// GlobalVariable Implementation -//===----------------------------------------------------------------------===// - -GlobalVariable::GlobalVariable(const Type *Ty, bool constant, LinkageTypes Link, - Constant *Initializer, - const std::string &Name, Module *ParentModule) - : GlobalValue(PointerType::get(Ty), Value::GlobalVariableVal, Link, Name), - isConstantGlobal(constant) { - if (Initializer) Operands.push_back(Use((Value*)Initializer, this)); - - LeakDetector::addGarbageObject(this); - - if (ParentModule) - ParentModule->getGlobalList().push_back(this); -} - -void GlobalVariable::setParent(Module *parent) { - if (getParent()) - LeakDetector::addGarbageObject(this); - Parent = parent; - if (getParent()) - LeakDetector::removeGarbageObject(this); + 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; } -// 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 && hasName()) P->getSymbolTable().insert(this); -} +// vim: sw=2 ai