X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FIR%2FModule.cpp;h=f1b1f9a2acc877f094343c5c0bfbbe1919891346;hb=5535fca8bf64b58dc729a734b578bda33ee47e87;hp=f938a92741abb7d2190f2c0162ee7234d7bf1762;hpb=7b651ce261483d9360c2ac6a4879806ef2826c31;p=oota-llvm.git diff --git a/lib/IR/Module.cpp b/lib/IR/Module.cpp index f938a92741a..f1b1f9a2acc 100644 --- a/lib/IR/Module.cpp +++ b/lib/IR/Module.cpp @@ -17,12 +17,15 @@ #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/StringExtras.h" -#include "llvm/GVMaterializer.h" #include "llvm/IR/Constants.h" #include "llvm/IR/DerivedTypes.h" +#include "llvm/IR/GVMaterializer.h" #include "llvm/IR/InstrTypes.h" #include "llvm/IR/LLVMContext.h" -#include "llvm/Support/LeakDetector.h" +#include "llvm/IR/LeakDetector.h" +#include "llvm/Support/Dwarf.h" +#include "llvm/Support/Path.h" +#include "llvm/Support/RandomNumberGenerator.h" #include #include #include @@ -42,8 +45,8 @@ template class llvm::SymbolTableListTraits; // Primitive Module methods. // -Module::Module(StringRef MID, LLVMContext& C) - : Context(C), Materializer(NULL), ModuleID(MID) { +Module::Module(StringRef MID, LLVMContext &C) + : Context(C), Materializer(), ModuleID(MID), RNG(nullptr), DL("") { ValSymTab = new ValueSymbolTable(); NamedMDSymTab = new StringMap(); Context.addModule(this); @@ -58,51 +61,7 @@ Module::~Module() { NamedMDList.clear(); delete ValSymTab; delete static_cast *>(NamedMDSymTab); -} - -/// Target endian information. -Module::Endianness Module::getEndianness() const { - StringRef temp = DataLayout; - Module::Endianness ret = BigEndian; - - while (!temp.empty()) { - std::pair P = getToken(temp, "-"); - - StringRef token = P.first; - temp = P.second; - - if (token[0] == 'e') { - ret = LittleEndian; - } else if (token[0] == 'E') { - ret = BigEndian; - } - } - - return ret; -} - -/// Target Pointer Size information. -Module::PointerSize Module::getPointerSize() const { - StringRef temp = DataLayout; - Module::PointerSize ret = Pointer64; - - while (!temp.empty()) { - std::pair TmpP = getToken(temp, "-"); - temp = TmpP.second; - TmpP = getToken(TmpP.first, ":"); - StringRef token = TmpP.second, signalToken = TmpP.first; - - if (signalToken[0] == 'p') { - int size = 0; - getToken(token, ":").first.getAsInteger(10, size); - if (size == 32) - ret = Pointer32; - else if (size == 64) - ret = Pointer64; - } - } - - return ret; + delete RNG; } /// getNamedValue - Return the first global value in the module with @@ -140,7 +99,7 @@ Constant *Module::getOrInsertFunction(StringRef Name, AttributeSet AttributeList) { // See if we have a definition for the specified function already. GlobalValue *F = getNamedValue(Name); - if (F == 0) { + if (!F) { // Nope, add it Function *New = Function::Create(Ty, GlobalVariable::ExternalLinkage, Name); if (!New->isIntrinsic()) // Intrinsics get attrs set on construction @@ -149,16 +108,6 @@ Constant *Module::getOrInsertFunction(StringRef Name, return New; // Return the new prototype. } - // Okay, the function exists. Does it have externally visible linkage? - if (F->hasLocalLinkage()) { - // Clear the function's name. - F->setName(""); - // Retry, now there won't be a conflict. - Constant *NewF = getOrInsertFunction(Name, Ty); - F->setName(Name); - return NewF; - } - // If the function exists but has the wrong type, return a bitcast to the // right type. if (F->getType() != PointerType::getUnqual(Ty)) @@ -238,7 +187,7 @@ GlobalVariable *Module::getGlobalVariable(StringRef Name, bool AllowLocal) { dyn_cast_or_null(getNamedValue(Name))) if (AllowLocal || !Result->hasLocalLinkage()) return Result; - return 0; + return nullptr; } /// getOrInsertGlobal - Look up the specified global in the module symbol table. @@ -250,11 +199,11 @@ GlobalVariable *Module::getGlobalVariable(StringRef Name, bool AllowLocal) { Constant *Module::getOrInsertGlobal(StringRef Name, Type *Ty) { // See if we have a definition for the specified global already. GlobalVariable *GV = dyn_cast_or_null(getNamedValue(Name)); - if (GV == 0) { + if (!GV) { // Nope, add it GlobalVariable *New = new GlobalVariable(*this, Ty, false, GlobalVariable::ExternalLinkage, - 0, Name); + nullptr, Name); return New; // Return the new declaration. } @@ -316,8 +265,7 @@ getModuleFlagsMetadata(SmallVectorImpl &Flags) const { const NamedMDNode *ModFlags = getModuleFlagsMetadata(); if (!ModFlags) return; - for (unsigned i = 0, e = ModFlags->getNumOperands(); i != e; ++i) { - MDNode *Flag = ModFlags->getOperand(i); + for (const MDNode *Flag : ModFlags->operands()) { if (Flag->getNumOperands() >= 3 && isa(Flag->getOperand(0)) && isa(Flag->getOperand(1))) { // Check the operands of the MDNode before accessing the operands. @@ -336,12 +284,11 @@ getModuleFlagsMetadata(SmallVectorImpl &Flags) const { Value *Module::getModuleFlag(StringRef Key) const { SmallVector ModuleFlags; getModuleFlagsMetadata(ModuleFlags); - for (unsigned I = 0, E = ModuleFlags.size(); I < E; ++I) { - const ModuleFlagEntry &MFE = ModuleFlags[I]; + for (const ModuleFlagEntry &MFE : ModuleFlags) { if (Key == MFE.Key->getString()) return MFE.Val; } - return 0; + return nullptr; } /// getModuleFlagsMetadata - Returns the NamedMDNode in the module that @@ -383,6 +330,44 @@ void Module::addModuleFlag(MDNode *Node) { getOrInsertModuleFlagsMetadata()->addOperand(Node); } +void Module::setDataLayout(StringRef Desc) { + DL.reset(Desc); + + if (Desc.empty()) { + DataLayoutStr = ""; + } else { + DataLayoutStr = DL.getStringRepresentation(); + // DataLayoutStr is now equivalent to Desc, but since the representation + // is not unique, they may not be identical. + } +} + +void Module::setDataLayout(const DataLayout *Other) { + if (!Other) { + DataLayoutStr = ""; + DL.reset(""); + } else { + DL = *Other; + DataLayoutStr = DL.getStringRepresentation(); + } +} + +const DataLayout *Module::getDataLayout() const { + if (DataLayoutStr.empty()) + return nullptr; + return &DL; +} + +// We want reproducible builds, but ModuleID may be a full path so we just use +// the filename to salt the RNG (although it is not guaranteed to be unique). +RandomNumberGenerator &Module::getRNG() const { + if (RNG == nullptr) { + StringRef Salt = sys::path::filename(ModuleID); + RNG = new RandomNumberGenerator(Salt); + } + return *RNG; +} + //===----------------------------------------------------------------------===// // Methods to control the materialization of GlobalValues in the Module. // @@ -409,7 +394,7 @@ bool Module::Materialize(GlobalValue *GV, std::string *ErrInfo) { if (!Materializer) return false; - error_code EC = Materializer->Materialize(GV); + std::error_code EC = Materializer->Materialize(GV); if (!EC) return false; if (ErrInfo) @@ -422,22 +407,21 @@ void Module::Dematerialize(GlobalValue *GV) { return Materializer->Dematerialize(GV); } -bool Module::MaterializeAll(std::string *ErrInfo) { +std::error_code Module::materializeAll() { if (!Materializer) - return false; - error_code EC = Materializer->MaterializeModule(this); - if (!EC) - return false; - if (ErrInfo) - *ErrInfo = EC.message(); - return true; + return std::error_code(); + return Materializer->MaterializeModule(this); } -bool Module::MaterializeAllPermanently(std::string *ErrInfo) { - if (MaterializeAll(ErrInfo)) - return true; +std::error_code Module::materializeAllPermanently(bool ReleaseBuffer) { + if (std::error_code EC = materializeAll()) + return EC; + + if (ReleaseBuffer) + Materializer->releaseBuffer(); + Materializer.reset(); - return false; + return std::error_code(); } //===----------------------------------------------------------------------===// @@ -453,12 +437,27 @@ bool Module::MaterializeAllPermanently(std::string *ErrInfo) { // has "dropped all references", except operator delete. // void Module::dropAllReferences() { - for(Module::iterator I = begin(), E = end(); I != E; ++I) - I->dropAllReferences(); + for (Function &F : *this) + F.dropAllReferences(); + + for (GlobalVariable &GV : globals()) + GV.dropAllReferences(); - for(Module::global_iterator I = global_begin(), E = global_end(); I != E; ++I) - I->dropAllReferences(); + for (GlobalAlias &GA : aliases()) + GA.dropAllReferences(); +} + +unsigned Module::getDwarfVersion() const { + Value *Val = getModuleFlag("Dwarf Version"); + if (!Val) + return dwarf::DWARF_VERSION; + return cast(Val)->getZExtValue(); +} - for(Module::alias_iterator I = alias_begin(), E = alias_end(); I != E; ++I) - I->dropAllReferences(); +Comdat *Module::getOrInsertComdat(StringRef Name) { + Comdat C; + StringMapEntry &Entry = + ComdatSymTab.GetOrCreateValue(Name, std::move(C)); + Entry.second.Name = &Entry; + return &Entry.second; }