X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FFunction.cpp;h=bf9c8b48bdeef7b1ed5837cad7ee21ee6f1b2b9b;hb=068758e518f0fe4ab67490f2eec0fd3b376a4d2c;hp=d03a72a81ab88364aa0c390e8d3bdc44d6e1958c;hpb=69da5cf26143e4542d4bf8c78ffac6d079efe5c9;p=oota-llvm.git diff --git a/lib/VMCore/Function.cpp b/lib/VMCore/Function.cpp index d03a72a81ab..bf9c8b48bde 100644 --- a/lib/VMCore/Function.cpp +++ b/lib/VMCore/Function.cpp @@ -1,4 +1,11 @@ -//===-- 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. @@ -6,10 +13,13 @@ //===----------------------------------------------------------------------===// #include "llvm/Module.h" +#include "llvm/Constant.h" #include "llvm/DerivedTypes.h" -#include "llvm/iOther.h" +#include "llvm/Instructions.h" +#include "llvm/Intrinsics.h" #include "Support/LeakDetector.h" #include "SymbolTableListTraitsImpl.h" +using namespace llvm; BasicBlock *ilist_traits::createNode() { BasicBlock *Ret = new BasicBlock(); @@ -35,8 +45,8 @@ 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 @@ -57,11 +67,11 @@ Argument::Argument(const Type *Ty, const std::string &Name, Function *Par) // 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); + 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->getSymbolTableSure()->insert(this); + if (P && hasName()) P->getSymbolTable().insert(this); } void Argument::setParent(Function *parent) { @@ -72,19 +82,21 @@ void Argument::setParent(Function *parent) { LeakDetector::removeGarbageObject(this); } - //===----------------------------------------------------------------------===// // Function Implementation //===----------------------------------------------------------------------===// -Function::Function(const FunctionType *Ty, bool isInternal, +Function::Function(const FunctionType *Ty, LinkageTypes Linkage, const std::string &name, Module *ParentModule) - : GlobalValue(PointerType::get(Ty), Value::FunctionVal, isInternal, name) { + : GlobalValue(PointerType::get(Ty), Value::FunctionVal, Linkage, name) { 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) { @@ -103,8 +115,6 @@ Function::Function(const FunctionType *Ty, bool isInternal, 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); @@ -114,11 +124,11 @@ Function::~Function() { // 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); + 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); + if (P && hasName()) P->getSymbolTable().insert(this); } void Function::setParent(Module *parent) { @@ -127,10 +137,6 @@ void Function::setParent(Module *parent) { Parent = parent; if (getParent()) LeakDetector::removeGarbageObject(this); - - // Relink symbol tables together... - ParentSymTab = Parent ? Parent->getSymbolTableSure() : 0; - if (SymTab) SymTab->setParentSymTab(ParentSymTab); } const FunctionType *Function::getFunctionType() const { @@ -141,71 +147,115 @@ const Type *Function::getReturnType() const { return getFunctionType()->getReturnType(); } -SymbolTable *Function::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 Function::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; -} - - // 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 delete'd for real. Note that no operations are +// 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 -//===----------------------------------------------------------------------===// - -GlobalVariable::GlobalVariable(const Type *Ty, bool constant, bool isIntern, - Constant *Initializer, - const std::string &Name, Module *ParentModule) - : GlobalValue(PointerType::get(Ty), Value::GlobalVariableVal, isIntern, Name), - isConstantGlobal(constant) { - if (Initializer) Operands.push_back(Use((Value*)Initializer, this)); - - LeakDetector::addGarbageObject(this); - - if (ParentModule) - ParentModule->getGlobalList().push_back(this); +/// 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 { + if (getName().size() < 5 || getName()[4] != '.' || getName()[0] != 'l' || + getName()[1] != 'l' || getName()[2] != 'v' || getName()[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!"); + return 0; } -void GlobalVariable::setParent(Module *parent) { - if (getParent()) - LeakDetector::addGarbageObject(this); - Parent = parent; - if (getParent()) - LeakDetector::removeGarbageObject(this); -} -// 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); -} +// vim: sw=2 ai