X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=blobdiff_plain;f=lib%2FLTO%2FLTOCodeGenerator.cpp;h=149ec6a4f372549aacb65c4ea6ee6ae40c53c5ef;hp=75ca56fbbe7333da15044b4dfc79f460948ea94e;hb=9758b4ae957d85e4b1e7fff1592f276ae684ee98;hpb=04d21865464a342d07d000492d2678ed6f7b45ff diff --git a/lib/LTO/LTOCodeGenerator.cpp b/lib/LTO/LTOCodeGenerator.cpp index 75ca56fbbe7..149ec6a4f37 100644 --- a/lib/LTO/LTOCodeGenerator.cpp +++ b/lib/LTO/LTOCodeGenerator.cpp @@ -15,6 +15,8 @@ #include "llvm/LTO/LTOCodeGenerator.h" #include "llvm/ADT/StringExtras.h" #include "llvm/Analysis/Passes.h" +#include "llvm/Analysis/TargetLibraryInfo.h" +#include "llvm/Analysis/TargetTransformInfo.h" #include "llvm/Bitcode/ReaderWriter.h" #include "llvm/CodeGen/RuntimeLibcalls.h" #include "llvm/Config/config.h" @@ -24,6 +26,7 @@ #include "llvm/IR/DiagnosticInfo.h" #include "llvm/IR/DiagnosticPrinter.h" #include "llvm/IR/LLVMContext.h" +#include "llvm/IR/LegacyPassManager.h" #include "llvm/IR/Mangler.h" #include "llvm/IR/Module.h" #include "llvm/IR/Verifier.h" @@ -33,10 +36,8 @@ #include "llvm/MC/MCAsmInfo.h" #include "llvm/MC/MCContext.h" #include "llvm/MC/SubtargetFeature.h" -#include "llvm/PassManager.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/FileSystem.h" -#include "llvm/Support/FormattedStream.h" #include "llvm/Support/Host.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Signals.h" @@ -44,7 +45,6 @@ #include "llvm/Support/TargetSelect.h" #include "llvm/Support/ToolOutputFile.h" #include "llvm/Support/raw_ostream.h" -#include "llvm/Target/TargetLibraryInfo.h" #include "llvm/Target/TargetLowering.h" #include "llvm/Target/TargetOptions.h" #include "llvm/Target/TargetRegisterInfo.h" @@ -64,19 +64,32 @@ const char* LTOCodeGenerator::getVersionString() { } LTOCodeGenerator::LTOCodeGenerator() - : Context(getGlobalContext()), IRLinker(new Module("ld-temp.o", Context)), - TargetMach(nullptr), EmitDwarfDebugInfo(false), - ScopeRestrictionsDone(false), CodeModel(LTO_CODEGEN_PIC_MODEL_DEFAULT), - DiagHandler(nullptr), DiagContext(nullptr) { + : Context(getGlobalContext()), IRLinker(new Module("ld-temp.o", Context)) { initializeLTOPasses(); } +LTOCodeGenerator::LTOCodeGenerator(std::unique_ptr Context) + : OwnedContext(std::move(Context)), Context(*OwnedContext), + IRLinker(new Module("ld-temp.o", *OwnedContext)) { + initializeLTOPasses(); +} + +void LTOCodeGenerator::destroyMergedModule() { + if (OwnedModule) { + assert(IRLinker.getModule() == &OwnedModule->getModule() && + "The linker's module should be the same as the owned module"); + delete OwnedModule; + OwnedModule = nullptr; + } else if (IRLinker.getModule()) + IRLinker.deleteModule(); +} + LTOCodeGenerator::~LTOCodeGenerator() { + destroyMergedModule(); + delete TargetMach; TargetMach = nullptr; - IRLinker.deleteModule(); - for (std::vector::iterator I = CodegenOptions.begin(), E = CodegenOptions.end(); I != E; ++I) @@ -94,7 +107,7 @@ void LTOCodeGenerator::initializeLTOPasses() { initializeGlobalOptPass(R); initializeConstantMergePass(R); initializeDAHPass(R); - initializeInstCombinerPass(R); + initializeInstructionCombiningPassPass(R); initializeSimpleInlinerPass(R); initializePruneEHPass(R); initializeGlobalDCEPass(R); @@ -113,8 +126,11 @@ void LTOCodeGenerator::initializeLTOPasses() { initializeCFGSimplifyPassPass(R); } -bool LTOCodeGenerator::addModule(LTOModule* mod, std::string& errMsg) { - bool ret = IRLinker.linkInModule(&mod->getModule(), &errMsg); +bool LTOCodeGenerator::addModule(LTOModule *mod) { + assert(&mod->getModule().getContext() == &Context && + "Expected module in same context"); + + bool ret = IRLinker.linkInModule(&mod->getModule()); const std::vector &undefs = mod->getAsmUndefinedRefs(); for (int i = 0, e = undefs.size(); i != e; ++i) @@ -123,6 +139,22 @@ bool LTOCodeGenerator::addModule(LTOModule* mod, std::string& errMsg) { return !ret; } +void LTOCodeGenerator::setModule(LTOModule *Mod) { + assert(&Mod->getModule().getContext() == &Context && + "Expected module in same context"); + + // Delete the old merged module. + destroyMergedModule(); + AsmUndefinedRefs.clear(); + + OwnedModule = Mod; + IRLinker.setModule(&Mod->getModule()); + + const std::vector &Undefs = Mod->getAsmUndefinedRefs(); + for (int I = 0, E = Undefs.size(); I != E; ++I) + AsmUndefinedRefs[Undefs[I]] = 1; +} + void LTOCodeGenerator::setTargetOptions(TargetOptions options) { Options = options; } @@ -170,7 +202,7 @@ bool LTOCodeGenerator::writeMergedModules(const char *path, } // write bitcode to it - WriteBitcodeToFile(IRLinker.getModule(), Out.os()); + WriteBitcodeToFile(IRLinker.getModule(), Out.os(), ShouldEmbedUselists); Out.os().close(); if (Out.os().has_error()) { @@ -184,11 +216,8 @@ bool LTOCodeGenerator::writeMergedModules(const char *path, return true; } -bool LTOCodeGenerator::compile_to_file(const char** name, - bool disableOpt, - bool disableInline, - bool disableGVNLoadPRE, - std::string& errMsg) { +bool LTOCodeGenerator::compileOptimizedToFile(const char **name, + std::string &errMsg) { // make unique temp .o file to put generated object file SmallString<128> Filename; int FD; @@ -202,8 +231,7 @@ bool LTOCodeGenerator::compile_to_file(const char** name, // generate object file tool_output_file objFile(Filename.c_str(), FD); - bool genResult = generateObjectFile(objFile.os(), disableOpt, disableInline, - disableGVNLoadPRE, errMsg); + bool genResult = compileOptimized(objFile.os(), errMsg); objFile.os().close(); if (objFile.os().has_error()) { objFile.os().clear_error(); @@ -222,14 +250,10 @@ bool LTOCodeGenerator::compile_to_file(const char** name, return true; } -const void* LTOCodeGenerator::compile(size_t* length, - bool disableOpt, - bool disableInline, - bool disableGVNLoadPRE, - std::string& errMsg) { +std::unique_ptr +LTOCodeGenerator::compileOptimized(std::string &errMsg) { const char *name; - if (!compile_to_file(&name, disableOpt, disableInline, disableGVNLoadPRE, - errMsg)) + if (!compileOptimizedToFile(&name, errMsg)) return nullptr; // read .o file into memory buffer @@ -240,16 +264,34 @@ const void* LTOCodeGenerator::compile(size_t* length, sys::fs::remove(NativeObjectPath); return nullptr; } - NativeObjectFile = std::move(*BufferOrErr); // remove temp files sys::fs::remove(NativeObjectPath); - // return buffer, unless error - if (!NativeObjectFile) + return std::move(*BufferOrErr); +} + + +bool LTOCodeGenerator::compile_to_file(const char **name, + bool disableInline, + bool disableGVNLoadPRE, + bool disableVectorization, + std::string &errMsg) { + if (!optimize(disableInline, disableGVNLoadPRE, + disableVectorization, errMsg)) + return false; + + return compileOptimizedToFile(name, errMsg); +} + +std::unique_ptr +LTOCodeGenerator::compile(bool disableInline, bool disableGVNLoadPRE, + bool disableVectorization, std::string &errMsg) { + if (!optimize(disableInline, disableGVNLoadPRE, + disableVectorization, errMsg)) return nullptr; - *length = NativeObjectFile->getBufferSize(); - return NativeObjectFile->getBufferStart(); + + return compileOptimized(errMsg); } bool LTOCodeGenerator::determineTarget(std::string &errMsg) { @@ -299,9 +341,25 @@ bool LTOCodeGenerator::determineTarget(std::string &errMsg) { MCpu = "cyclone"; } + CodeGenOpt::Level CGOptLevel; + switch (OptLevel) { + case 0: + CGOptLevel = CodeGenOpt::None; + break; + case 1: + CGOptLevel = CodeGenOpt::Less; + break; + case 2: + CGOptLevel = CodeGenOpt::Default; + break; + case 3: + CGOptLevel = CodeGenOpt::Aggressive; + break; + } + TargetMach = march->createTargetMachine(TripleStr, MCpu, FeatureStr, Options, RelocModel, CodeModel::Default, - CodeGenOpt::Aggressive); + CGOptLevel); return true; } @@ -348,10 +406,13 @@ static void findUsedValues(GlobalVariable *LLVMUsed, UsedValues.insert(GV); } +// Collect names of runtime library functions. User-defined functions with the +// same names are added to llvm.compiler.used to prevent them from being +// deleted by optimizations. static void accumulateAndSortLibcalls(std::vector &Libcalls, const TargetLibraryInfo& TLI, - const TargetLowering *Lowering) -{ + const Module &Mod, + const TargetMachine &TM) { // TargetLibraryInfo has info on C runtime library calls on the current // target. for (unsigned I = 0, E = static_cast(LibFunc::NumLibFuncs); @@ -361,14 +422,21 @@ static void accumulateAndSortLibcalls(std::vector &Libcalls, Libcalls.push_back(TLI.getName(F)); } - // TargetLowering has info on library calls that CodeGen expects to be - // available, both from the C runtime and compiler-rt. - if (Lowering) - for (unsigned I = 0, E = static_cast(RTLIB::UNKNOWN_LIBCALL); - I != E; ++I) - if (const char *Name - = Lowering->getLibcallName(static_cast(I))) - Libcalls.push_back(Name); + SmallPtrSet TLSet; + + for (const Function &F : Mod) { + const TargetLowering *Lowering = + TM.getSubtargetImpl(F)->getTargetLowering(); + + if (Lowering && TLSet.insert(Lowering).second) + // TargetLowering has info on library calls that CodeGen expects to be + // available, both from the C runtime and compiler-rt. + for (unsigned I = 0, E = static_cast(RTLIB::UNKNOWN_LIBCALL); + I != E; ++I) + if (const char *Name = + Lowering->getLibcallName(static_cast(I))) + Libcalls.push_back(Name); + } array_pod_sort(Libcalls.begin(), Libcalls.end()); Libcalls.erase(std::unique(Libcalls.begin(), Libcalls.end()), @@ -376,23 +444,23 @@ static void accumulateAndSortLibcalls(std::vector &Libcalls, } void LTOCodeGenerator::applyScopeRestrictions() { - if (ScopeRestrictionsDone) + if (ScopeRestrictionsDone || !ShouldInternalize) return; Module *mergedModule = IRLinker.getModule(); // Start off with a verification pass. - PassManager passes; + legacy::PassManager passes; passes.add(createVerifierPass()); - passes.add(createDebugInfoVerifierPass()); // mark which symbols can not be internalized - Mangler Mangler(TargetMach->getSubtargetImpl()->getDataLayout()); + Mangler Mangler; std::vector MustPreserveList; SmallPtrSet AsmUsed; std::vector Libcalls; - TargetLibraryInfo TLI(Triple(TargetMach->getTargetTriple())); - accumulateAndSortLibcalls( - Libcalls, TLI, TargetMach->getSubtargetImpl()->getTargetLowering()); + TargetLibraryInfoImpl TLII(Triple(TargetMach->getTargetTriple())); + TargetLibraryInfo TLI(TLII); + + accumulateAndSortLibcalls(Libcalls, TLI, *mergedModule, *TargetMach); for (Module::iterator f = mergedModule->begin(), e = mergedModule->end(); f != e; ++f) @@ -437,11 +505,10 @@ void LTOCodeGenerator::applyScopeRestrictions() { } /// Optimize merged modules using various IPO passes -bool LTOCodeGenerator::generateObjectFile(raw_ostream &out, - bool DisableOpt, - bool DisableInline, - bool DisableGVNLoadPRE, - std::string &errMsg) { +bool LTOCodeGenerator::optimize(bool DisableInline, + bool DisableGVNLoadPRE, + bool DisableVectorization, + std::string &errMsg) { if (!this->determineTarget(errMsg)) return false; @@ -451,43 +518,53 @@ bool LTOCodeGenerator::generateObjectFile(raw_ostream &out, this->applyScopeRestrictions(); // Instantiate the pass manager to organize the passes. - PassManager passes; + legacy::PassManager passes; // Add an appropriate DataLayout instance for this module... - mergedModule->setDataLayout(TargetMach->getSubtargetImpl()->getDataLayout()); + mergedModule->setDataLayout(*TargetMach->getDataLayout()); + + passes.add( + createTargetTransformInfoWrapperPass(TargetMach->getTargetIRAnalysis())); Triple TargetTriple(TargetMach->getTargetTriple()); PassManagerBuilder PMB; PMB.DisableGVNLoadPRE = DisableGVNLoadPRE; + PMB.LoopVectorize = !DisableVectorization; + PMB.SLPVectorize = !DisableVectorization; if (!DisableInline) PMB.Inliner = createFunctionInliningPass(); - PMB.LibraryInfo = new TargetLibraryInfo(TargetTriple); - if (DisableOpt) - PMB.OptLevel = 0; + PMB.LibraryInfo = new TargetLibraryInfoImpl(TargetTriple); + PMB.OptLevel = OptLevel; PMB.VerifyInput = true; PMB.VerifyOutput = true; - PMB.populateLTOPassManager(passes, TargetMach); + PMB.populateLTOPassManager(passes); - PassManager codeGenPasses; + // Run our queue of passes all at once now, efficiently. + passes.run(*mergedModule); + + return true; +} + +bool LTOCodeGenerator::compileOptimized(raw_pwrite_stream &out, + std::string &errMsg) { + if (!this->determineTarget(errMsg)) + return false; - codeGenPasses.add(new DataLayoutPass()); + Module *mergedModule = IRLinker.getModule(); - formatted_raw_ostream Out(out); + legacy::PassManager codeGenPasses; // If the bitcode files contain ARC code and were compiled with optimization, // the ObjCARCContractPass must be run, so do it unconditionally here. codeGenPasses.add(createObjCARCContractPass()); - if (TargetMach->addPassesToEmitFile(codeGenPasses, Out, + if (TargetMach->addPassesToEmitFile(codeGenPasses, out, TargetMachine::CGFT_ObjectFile)) { errMsg = "target file type not supported"; return false; } - // Run our queue of passes all at once now, efficiently. - passes.run(*mergedModule); - // Run the code generator, and write assembly file codeGenPasses.run(*mergedModule); @@ -558,5 +635,6 @@ LTOCodeGenerator::setDiagnosticHandler(lto_diagnostic_handler_t DiagHandler, return Context.setDiagnosticHandler(nullptr, nullptr); // Register the LTOCodeGenerator stub in the LLVMContext to forward the // diagnostic to the external DiagHandler. - Context.setDiagnosticHandler(LTOCodeGenerator::DiagnosticHandler, this, true); + Context.setDiagnosticHandler(LTOCodeGenerator::DiagnosticHandler, this, + /* RespectFilters */ true); }