X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FFunction.cpp;h=0d5f90b45df271edf1ee0be8b6c84df663dc0e2c;hb=893af8c058aad683027c604d6cbe818c59e0eda8;hp=bd342a2473c46eb0e59869b9ceffb728957ead7b;hpb=7c43a0ace7af881e86625705542ee2cf640d5c7b;p=oota-llvm.git diff --git a/lib/VMCore/Function.cpp b/lib/VMCore/Function.cpp index bd342a2473c..0d5f90b45df 100644 --- a/lib/VMCore/Function.cpp +++ b/lib/VMCore/Function.cpp @@ -1,66 +1,141 @@ -//===-- Method.cpp - Implement the Method class ------------------*- C++ -*--=// +//===-- Function.cpp - Implement the Global object classes -------*- C++ -*--=// // -// This file implements the Method class for the VMCore library. +// This file implements the Function & GlobalVariable classes for the VMCore +// library. // //===----------------------------------------------------------------------===// -#include "llvm/ValueHolderImpl.h" -#include "llvm/DerivedTypes.h" -#include "llvm/SymbolTable.h" #include "llvm/Module.h" -#include "llvm/Method.h" -#include "llvm/BasicBlock.h" +#include "llvm/DerivedTypes.h" #include "llvm/iOther.h" +#include "llvm/Intrinsics.h" +#include "Support/LeakDetector.h" +#include "SymbolTableListTraitsImpl.h" -// Instantiate Templates - This ugliness is the price we have to pay -// for having a ValueHolderImpl.h file seperate from ValueHolder.h! :( -// -template class ValueHolder; -template class ValueHolder; +BasicBlock *ilist_traits::createNode() { + 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() { + Argument *Ret = new Argument(Type::IntTy); + // This should not be garbage monitored. + LeakDetector::removeGarbageObject(Ret); + return Ret; +} + +iplist &ilist_traits::getList(Function *F) { + return F->getArgumentList(); +} + +// Explicit instantiations of SymbolTableListTraits since some of the methods +// are not in the public header file... +template SymbolTableListTraits; +template SymbolTableListTraits; + +//===----------------------------------------------------------------------===// +// Argument Implementation +//===----------------------------------------------------------------------===// -Method::Method(const MethodType *Ty, const string &name) - : Value(Ty, Value::MethodVal, name), SymTabValue(this), BasicBlocks(this), - ArgumentList(this, this) { - assert(Ty->isMethodType() && "Method signature must be of method type!"); +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); +} + + +// 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); + Parent = parent; + if (getParent()) + 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) { + BasicBlocks.setItemParent(this); + BasicBlocks.setParent(this); + ArgumentList.setItemParent(this); + ArgumentList.setParent(this); + SymTab = new SymbolTable(); + + // 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); } -Method::~Method() { +Function::~Function() { dropAllReferences(); // After this it is safe to delete instructions. - // TODO: Should remove from the end, not the beginning of vector! - iterator BI = begin(); - while ((BI = begin()) != end()) - delete BasicBlocks.remove(BI); + BasicBlocks.clear(); // Delete all basic blocks... // Delete all of the method arguments and unlink from symbol table... - ArgumentList.delete_all(); + ArgumentList.clear(); ArgumentList.setParent(0); + delete SymTab; } // Specialize setName to take care of symbol table majik -void Method::setName(const string &name, SymbolTable *ST) { +void Function::setName(const std::string &name, SymbolTable *ST) { Module *P; - assert((ST == 0 || (!getParent() || ST == getParent()->getSymbolTable())) && + assert((ST == 0 || (!getParent() || ST == &getParent()->getSymbolTable())) && "Invalid symtab argument!"); - if ((P = getParent()) && hasName()) P->getSymbolTable()->remove(this); + if ((P = getParent()) && hasName()) P->getSymbolTable().remove(this); Value::setName(name); - if (P && getName() != "") P->getSymbolTableSure()->insert(this); + if (P && getName() != "") P->getSymbolTable().insert(this); } -void Method::setParent(Module *parent) { +void Function::setParent(Module *parent) { + if (getParent()) + LeakDetector::addGarbageObject(this); Parent = parent; - - // Relink symbol tables together... - setParentSymTab(Parent ? Parent->getSymbolTableSure() : 0); + if (getParent()) + LeakDetector::removeGarbageObject(this); } -const Type *Method::getReturnType() const { - return ((const MethodType *)getType())->getReturnType(); +const FunctionType *Function::getFunctionType() const { + return cast(getType()->getElementType()); } -const MethodType *Method::getMethodType() const { - return (const MethodType *)getType(); +const Type *Function::getReturnType() const { + return getFunctionType()->getReturnType(); } // dropAllReferences() - This function causes all the subinstructions to "let @@ -71,6 +146,77 @@ const MethodType *Method::getMethodType() const { // valid on an object that has "dropped all references", except operator // delete. // -void Method::dropAllReferences() { - for_each(begin(), end(), std::mem_fun(&BasicBlock::dropAllReferences)); +void Function::dropAllReferences() { + for (iterator I = begin(), E = end(); I != E; ++I) + I->dropAllReferences(); +} + +/// getIntrinsicID - This method returns the ID number of the specified +/// function, or LLVMIntrinsic::not_intrinsic if the function is not an +/// instrinsic, 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.' + + switch (getName()[5]) { + case 'v': + if (getName().size() >= 9) { + switch (getName()[8]) { + case 's': + if (getName() == "llvm.va_start") return LLVMIntrinsic::va_start; + break; + case 'e': + if (getName() == "llvm.va_end") return LLVMIntrinsic::va_end; + break; + case 'c': + if (getName() == "llvm.va_copy") return LLVMIntrinsic::va_copy; + break; + } + } + break; + } + // The "llvm." namespace is reserved! + assert(0 && "Unknown LLVM intrinsic function!"); + return 0; +} + + +//===----------------------------------------------------------------------===// +// 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); +} + +// 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->getSymbolTable().insert(this); }