void LLVMPassManagerBuilderPopulateModulePassManager(LLVMPassManagerBuilderRef PMB, LLVMPassManagerRef PM) { PassManagerBuilder *Builder = unwrap(PMB); legacy::PassManagerBase *MPM = unwrap(PM); Builder->populateModulePassManager(*MPM); }
void LLVMPassManagerBuilderPopulateFunctionPassManager(LLVMPassManagerBuilderRef PMB, LLVMPassManagerRef PM) { PassManagerBuilder *Builder = unwrap(PMB); legacy::FunctionPassManager *FPM = unwrap<legacy::FunctionPassManager>(PM); Builder->populateFunctionPassManager(*FPM); }
/// AddOptimizationPasses - This routine adds optimization passes /// based on selected optimization level, OptLevel. This routine /// duplicates llvm-gcc behaviour. /// /// OptLevel - Optimization Level static void AddOptimizationPasses(PassManagerBase &MPM,FunctionPassManager &FPM, unsigned OptLevel, unsigned SizeLevel) { FPM.add(createVerifierPass()); // Verify that input is correct PassManagerBuilder Builder; Builder.OptLevel = OptLevel; Builder.SizeLevel = SizeLevel; if (DisableInline) { // No inlining pass } else if (OptLevel > 1) { unsigned Threshold = 225; if (SizeLevel == 1) // -Os Threshold = 75; else if (SizeLevel == 2) // -Oz Threshold = 25; if (OptLevel > 2) Threshold = 275; Builder.Inliner = createFunctionInliningPass(Threshold); } else { Builder.Inliner = createAlwaysInlinerPass(); } Builder.DisableUnitAtATime = !UnitAtATime; Builder.DisableUnrollLoops = (DisableLoopUnrolling.getNumOccurrences() > 0) ? DisableLoopUnrolling : OptLevel == 0; Builder.LoopVectorize = DisableLoopVectorization ? false : OptLevel > 1 && SizeLevel < 2; Builder.SLPVectorize = DisableSLPVectorization ? false : OptLevel > 1 && SizeLevel < 2; Builder.populateFunctionPassManager(FPM); Builder.populateModulePassManager(MPM); }
/// This routine adds optimization passes based on selected optimization level, /// OptLevel. /// /// OptLevel - Optimization Level static void AddOptimizationPasses(legacy::PassManagerBase &MPM, legacy::FunctionPassManager &FPM, unsigned OptLevel, unsigned SizeLevel) { if (!NoVerify || VerifyEach) FPM.add(createVerifierPass()); // Verify that input is correct PassManagerBuilder Builder; Builder.OptLevel = OptLevel; Builder.SizeLevel = SizeLevel; if (DisableInline) { // No inlining pass } else if (OptLevel > 1) { Builder.Inliner = createFunctionInliningPass(OptLevel, SizeLevel); } else { Builder.Inliner = createAlwaysInlinerPass(); } Builder.DisableUnitAtATime = !UnitAtATime; Builder.DisableUnrollLoops = (DisableLoopUnrolling.getNumOccurrences() > 0) ? DisableLoopUnrolling : OptLevel == 0; // This is final, unless there is a #pragma vectorize enable if (DisableLoopVectorization) Builder.LoopVectorize = false; // If option wasn't forced via cmd line (-vectorize-loops, -loop-vectorize) else if (!Builder.LoopVectorize) Builder.LoopVectorize = OptLevel > 1 && SizeLevel < 2; // When #pragma vectorize is on for SLP, do the same as above Builder.SLPVectorize = DisableSLPVectorization ? false : OptLevel > 1 && SizeLevel < 2; Builder.populateFunctionPassManager(FPM); Builder.populateModulePassManager(MPM); }
/// Optimize merged modules using various IPO passes bool LTOCodeGenerator::generateObjectFile(raw_ostream &out, bool DisableOpt, bool DisableInline, bool DisableGVNLoadPRE, bool DisableVectorization, std::string &errMsg) { if (!this->determineTarget(errMsg)) return false; Module *mergedModule = IRLinker.getModule(); // Mark which symbols can not be internalized this->applyScopeRestrictions(); // Instantiate the pass manager to organize the passes. PassManager passes; // Add an appropriate DataLayout instance for this module... mergedModule->setDataLayout(TargetMach->getSubtargetImpl()->getDataLayout()); 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.VerifyInput = true; PMB.VerifyOutput = true; PMB.populateLTOPassManager(passes, TargetMach); PassManager codeGenPasses; codeGenPasses.add(new DataLayoutPass()); formatted_raw_ostream Out(out); // 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, 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); return true; }
void LLVMPassManagerBuilderPopulateLTOPassManager(LLVMPassManagerBuilderRef PMB, LLVMPassManagerRef PM, LLVMBool Internalize, LLVMBool RunInliner) { PassManagerBuilder *Builder = unwrap(PMB); PassManagerBase *LPM = unwrap(PM); Builder->populateLTOPassManager(*LPM, Internalize != 0, RunInliner != 0); }
void AMDGPUTargetMachine::adjustPassManager(PassManagerBuilder &Builder) { Builder.DivergentTarget = true; bool EnableOpt = getOptLevel() > CodeGenOpt::None; bool Internalize = InternalizeSymbols; bool EarlyInline = EarlyInlineAll && EnableOpt && !EnableFunctionCalls; bool AMDGPUAA = EnableAMDGPUAliasAnalysis && EnableOpt; bool LibCallSimplify = EnableLibCallSimplify && EnableOpt; if (EnableFunctionCalls) { delete Builder.Inliner; Builder.Inliner = createAMDGPUFunctionInliningPass(); } Builder.addExtension( PassManagerBuilder::EP_ModuleOptimizerEarly, [Internalize, EarlyInline, AMDGPUAA](const PassManagerBuilder &, legacy::PassManagerBase &PM) { if (AMDGPUAA) { PM.add(createAMDGPUAAWrapperPass()); PM.add(createAMDGPUExternalAAWrapperPass()); } PM.add(createAMDGPUUnifyMetadataPass()); if (Internalize) { PM.add(createInternalizePass(mustPreserveGV)); PM.add(createGlobalDCEPass()); } if (EarlyInline) PM.add(createAMDGPUAlwaysInlinePass(false)); }); const auto &Opt = Options; Builder.addExtension( PassManagerBuilder::EP_EarlyAsPossible, [AMDGPUAA, LibCallSimplify, &Opt](const PassManagerBuilder &, legacy::PassManagerBase &PM) { if (AMDGPUAA) { PM.add(createAMDGPUAAWrapperPass()); PM.add(createAMDGPUExternalAAWrapperPass()); } PM.add(llvm::createAMDGPUUseNativeCallsPass()); if (LibCallSimplify) PM.add(llvm::createAMDGPUSimplifyLibCallsPass(Opt)); }); Builder.addExtension( PassManagerBuilder::EP_CGSCCOptimizerLate, [](const PassManagerBuilder &, legacy::PassManagerBase &PM) { // Add infer address spaces pass to the opt pipeline after inlining // but before SROA to increase SROA opportunities. PM.add(createInferAddressSpacesPass()); // This should run after inlining to have any chance of doing anything, // and before other cleanup optimizations. PM.add(createAMDGPULowerKernelAttributesPass()); }); }
static void AddStandardLinkPasses(legacy::PassManagerBase &PM) { PassManagerBuilder Builder; Builder.VerifyInput = true; if (DisableOptimizations) Builder.OptLevel = 0; if (!DisableInline) Builder.Inliner = createFunctionInliningPass(); Builder.populateLTOPassManager(PM); }
static void runLTOPasses(Module &M, TargetMachine &TM) { PassManager passes; PassManagerBuilder PMB; PMB.LibraryInfo = new TargetLibraryInfo(Triple(TM.getTargetTriple())); PMB.Inliner = createFunctionInliningPass(); PMB.VerifyInput = true; PMB.VerifyOutput = true; PMB.populateLTOPassManager(passes, &TM); passes.run(M); }
void LLVMZigOptimizeModule(LLVMTargetMachineRef targ_machine_ref, LLVMModuleRef module_ref) { TargetMachine* target_machine = reinterpret_cast<TargetMachine*>(targ_machine_ref); Module* module = unwrap(module_ref); TargetLibraryInfoImpl tlii(Triple(module->getTargetTriple())); PassManagerBuilder *PMBuilder = new PassManagerBuilder(); PMBuilder->OptLevel = target_machine->getOptLevel(); PMBuilder->SizeLevel = 0; PMBuilder->BBVectorize = true; PMBuilder->SLPVectorize = true; PMBuilder->LoopVectorize = true; PMBuilder->DisableUnitAtATime = false; PMBuilder->DisableUnrollLoops = false; PMBuilder->MergeFunctions = true; PMBuilder->PrepareForLTO = true; PMBuilder->RerollLoops = true; PMBuilder->addExtension(PassManagerBuilder::EP_EarlyAsPossible, addAddDiscriminatorsPass); PMBuilder->LibraryInfo = &tlii; PMBuilder->Inliner = createFunctionInliningPass(PMBuilder->OptLevel, PMBuilder->SizeLevel); // Set up the per-function pass manager. legacy::FunctionPassManager *FPM = new legacy::FunctionPassManager(module); FPM->add(createTargetTransformInfoWrapperPass(target_machine->getTargetIRAnalysis())); #ifndef NDEBUG bool verify_module = true; #else bool verify_module = false; #endif if (verify_module) { FPM->add(createVerifierPass()); } PMBuilder->populateFunctionPassManager(*FPM); // Set up the per-module pass manager. legacy::PassManager *MPM = new legacy::PassManager(); MPM->add(createTargetTransformInfoWrapperPass(target_machine->getTargetIRAnalysis())); PMBuilder->populateModulePassManager(*MPM); // run per function optimization passes FPM->doInitialization(); for (Function &F : *module) if (!F.isDeclaration()) FPM->run(F); FPM->doFinalization(); // run per module optimization passes MPM->run(*module); }
static PassManagerBuilder getBuilder() { PassManagerBuilder Builder; Builder.VerifyInput = false; Builder.VerifyOutput = false; Builder.OptLevel = 3; Builder.addGlobalExtension(PassManagerBuilder::EP_EarlyAsPossible, registerPolly); return Builder; }
Module * llvmutil_extractmodule(Module * OrigMod, TargetMachine * TM, std::vector<llvm::GlobalValue*> * livevalues, std::vector<std::string> * symbolnames, bool internalizeandoptimize) { assert(symbolnames == NULL || livevalues->size() == symbolnames->size()); ValueToValueMapTy VMap; #if LLVM_VERSION >= 34 Module * M = llvmutil_extractmodulewithproperties(OrigMod->getModuleIdentifier(), OrigMod, (llvm::GlobalValue **)&(*livevalues)[0], livevalues->size(), AlwaysCopy, NULL, VMap); #else Module * M = CloneModule(OrigMod, VMap); internalizeandoptimize = true; //we need to do this regardless of the input because it is the only way we can extract just the needed functions from the module #endif //rename values to symbolsnames std::vector<const char *> names; for(size_t i = 0; i < livevalues->size(); i++) { GlobalValue * fn = cast<GlobalValue>(VMap[(*livevalues)[i]]); const std::string & name = (*symbolnames)[i]; GlobalValue * gv = M->getNamedValue(name); if(gv) { //if there is already a symbol with this name, rename it gv->setName(Twine((*symbolnames)[i],"_renamed")); } fn->setName(name); //and set our function to this name assert(fn->getName() == name); names.push_back(name.c_str()); //internalize pass has weird interface, so we need to copy the names here } if (!internalizeandoptimize) return M; //at this point we run optimizations on the module //first internalize all functions not mentioned in "names" using an internalize pass and then perform //standard optimizations PassManager MPM; llvmutil_addtargetspecificpasses(&MPM, TM); MPM.add(createVerifierPass()); //make sure we haven't messed stuff up yet MPM.add(createInternalizePass(names)); MPM.add(createGlobalDCEPass()); //run this early since anything not in the table of exported functions is still in this module //this will remove dead functions PassManagerBuilder PMB; PMB.OptLevel = 3; PMB.SizeLevel = 0; #if LLVM_VERSION >= 35 PMB.LoopVectorize = true; PMB.SLPVectorize = true; #endif PMB.populateModulePassManager(MPM); MPM.run(*M); return M; }
void llvm::addCoroutinePassesToExtensionPoints(PassManagerBuilder &Builder) { Builder.addExtension(PassManagerBuilder::EP_EarlyAsPossible, addCoroutineEarlyPasses); Builder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0, addCoroutineOpt0Passes); Builder.addExtension(PassManagerBuilder::EP_CGSCCOptimizerLate, addCoroutineSCCPasses); Builder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate, addCoroutineScalarOptimizerPasses); Builder.addExtension(PassManagerBuilder::EP_OptimizerLast, addCoroutineOptimizerLastPasses); }
static PassManagerBuilder getDebugBuilder() { PassManagerBuilder Builder; Builder.VerifyInput = true; Builder.VerifyOutput = true; Builder.OptLevel = 0; Builder.DisableUnrollLoops = true; Builder.DisableTailCalls = true; Builder.addGlobalExtension(PassManagerBuilder::EP_EarlyAsPossible, registerPolly); return Builder; }
static void AddStandardLinkPasses(PassManagerBase &PM) { PM.add(createVerifierPass()); // Verify that input is correct // If the -strip-debug command line option was specified, do it. if (StripDebug) addPass(PM, createStripSymbolsPass(true)); if (DisableOptimizations) return; PassManagerBuilder Builder; Builder.populateLTOPassManager(PM, /*Internalize=*/ !DisableInternalize, /*RunInliner=*/ !DisableInline); }
/// Optimize merged modules using various IPO passes bool LTOCodeGenerator::optimize(bool DisableVerify, bool DisableInline, bool DisableGVNLoadPRE, bool DisableVectorization) { if (!this->determineTarget()) return false; auto DiagFileOrErr = lto::setupOptimizationRemarks( Context, LTORemarksFilename, LTOPassRemarksWithHotness); if (!DiagFileOrErr) { errs() << "Error: " << toString(DiagFileOrErr.takeError()) << "\n"; report_fatal_error("Can't get an output file for the remarks"); } DiagnosticOutputFile = std::move(*DiagFileOrErr); // We always run the verifier once on the merged module, the `DisableVerify` // parameter only applies to subsequent verify. verifyMergedModuleOnce(); // Mark which symbols can not be internalized this->applyScopeRestrictions(); // Instantiate the pass manager to organize the passes. legacy::PassManager passes; // Add an appropriate DataLayout instance for this module... MergedModule->setDataLayout(TargetMach->createDataLayout()); 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 TargetLibraryInfoImpl(TargetTriple); if (Freestanding) PMB.LibraryInfo->disableAllFunctions(); PMB.OptLevel = OptLevel; PMB.VerifyInput = !DisableVerify; PMB.VerifyOutput = !DisableVerify; PMB.populateLTOPassManager(passes); // Run our queue of passes all at once now, efficiently. passes.run(*MergedModule); return true; }
void LLVMPassManagerBuilderPopulateLTOPassManager(LLVMPassManagerBuilderRef PMB, LLVMPassManagerRef PM, LLVMBool Internalize, LLVMBool RunInliner) { PassManagerBuilder *Builder = unwrap(PMB); legacy::PassManagerBase *LPM = unwrap(PM); // A small backwards compatibility hack. populateLTOPassManager used to take // an RunInliner option. if (RunInliner && !Builder->Inliner) Builder->Inliner = createFunctionInliningPass(); Builder->populateLTOPassManager(*LPM); }
Module * llvmutil_extractmodule(Module * OrigMod, TargetMachine * TM, std::vector<Function*> * livefns, std::vector<std::string> * symbolnames) { assert(symbolnames == NULL || livefns->size() == symbolnames->size()); ValueToValueMapTy VMap; Module * M = CloneModule(OrigMod, VMap); PassManager * MPM = new PassManager(); llvmutil_addtargetspecificpasses(MPM, TM); std::vector<const char *> names; for(size_t i = 0; i < livefns->size(); i++) { Function * fn = cast<Function>(VMap[(*livefns)[i]]); const char * name; if(symbolnames) { GlobalAlias * ga = new GlobalAlias(fn->getType(), Function::ExternalLinkage, (*symbolnames)[i], fn, M); name = copyName(ga->getName()); } else { name = copyName(fn->getName()); } names.push_back(name); //internalize pass has weird interface, so we need to copy the names here } //at this point we run optimizations on the module //first internalize all functions not mentioned in "names" using an internalize pass and then perform //standard optimizations MPM->add(createVerifierPass()); //make sure we haven't messed stuff up yet MPM->add(createInternalizePass(names)); MPM->add(createGlobalDCEPass()); //run this early since anything not in the table of exported functions is still in this module //this will remove dead functions //clean up the name list for(size_t i = 0; i < names.size(); i++) { free((char*)names[i]); names[i] = NULL; } PassManagerBuilder PMB; PMB.OptLevel = 3; PMB.DisableUnrollLoops = true; PMB.populateModulePassManager(*MPM); //PMB.populateLTOPassManager(*MPM, false, false); //no need to re-internalize, we already did it MPM->run(*M); delete MPM; MPM = NULL; return M; }
LLVMFormula::LLVMFormula () { // We need to initialize the native target info, once. static bool initializeNative = false; if (!initializeNative) { InitializeNativeTarget (); initializeNative = true; } // Build a module and a JIT engine module = new Module ("AFormula JIT", getGlobalContext ()); // The Engine is going to take control of this module, // don't delete them later. std::string errorString; engine = EngineBuilder (module).setErrorStr (&errorString).create (); if (!engine) { // We won't let you call buildFunction if you catch this error errorMessage.reset (new std::string ("LLVM Error: " + errorString)); return; } // Create an IRBuilder builder = new IRBuilder<> (getGlobalContext ()); // Get a data layout for this module const std::string &moduleDataLayout = module->getDataLayout (); if (!moduleDataLayout.empty ()) TD = new DataLayout (moduleDataLayout); else TD = NULL; // Build an optimizer. We're going to get default optimization settings // in the same way that LLVM does. FPM = new FunctionPassManager (module); if (TD) FPM->add (TD); FPM->add (createVerifierPass()); PassManagerBuilder builder; builder.OptLevel = 3; builder.populateFunctionPassManager (*FPM); FPM->doInitialization (); }
static void runOldLtoPasses(Module &M, TargetMachine &TM) { // Note that the gold plugin has a similar piece of code, so // it is probably better to move this code to a common place. legacy::PassManager LtoPasses; LtoPasses.add(createTargetTransformInfoWrapperPass(TM.getTargetIRAnalysis())); PassManagerBuilder PMB; PMB.LibraryInfo = new TargetLibraryInfoImpl(Triple(TM.getTargetTriple())); PMB.Inliner = createFunctionInliningPass(); PMB.VerifyInput = PMB.VerifyOutput = !Config->DisableVerify; PMB.LoopVectorize = true; PMB.SLPVectorize = true; PMB.OptLevel = Config->LtoO; PMB.populateLTOPassManager(LtoPasses); LtoPasses.run(M); }
void llvmutil_addoptimizationpasses(PassManagerBase * fpm) { PassManagerBuilder PMB; PMB.OptLevel = 3; PMB.SizeLevel = 0; PMB.DisableUnitAtATime = true; #if LLVM_VERSION <= 34 && LLVM_VERSION >= 32 PMB.LoopVectorize = false; #elif LLVM_VERSION >= 35 PMB.LoopVectorize = true; PMB.SLPVectorize = true; #endif PassManagerWrapper W(fpm); PMB.populateModulePassManager(W); }
// Run LTO passes. // Note that the gold plugin has a similar piece of code, so // it is probably better to move this code to a common place. static void runLTOPasses(Module &M, TargetMachine &TM) { legacy::PassManager LtoPasses; LtoPasses.add(createTargetTransformInfoWrapperPass(TM.getTargetIRAnalysis())); PassManagerBuilder PMB; PMB.LibraryInfo = new TargetLibraryInfoImpl(Triple(TM.getTargetTriple())); PMB.Inliner = createFunctionInliningPass(); PMB.VerifyInput = PMB.VerifyOutput = !Config->DisableVerify; PMB.LoopVectorize = true; PMB.SLPVectorize = true; PMB.OptLevel = Config->LtoO; PMB.populateLTOPassManager(LtoPasses); LtoPasses.run(M); if (Config->SaveTemps) saveBCFile(M, ".lto.opt.bc"); }
static void AddStandardCompilePasses(PassManagerBase &PM) { PM.add(createVerifierPass()); // Verify that input is correct // If the -strip-debug command line option was specified, do it. if (StripDebug) addPass(PM, createStripSymbolsPass(true)); if (DisableOptimizations) return; // -std-compile-opts adds the same module passes as -O3. PassManagerBuilder Builder; if (!DisableInline) Builder.Inliner = createFunctionInliningPass(); Builder.OptLevel = 3; Builder.populateModulePassManager(PM); }
/// This routine adds optimization passes based on selected optimization level, /// OptLevel. /// /// OptLevel - Optimization Level static void AddOptimizationPasses(legacy::PassManagerBase &MPM, legacy::FunctionPassManager &FPM, TargetMachine *TM, unsigned OptLevel, unsigned SizeLevel) { if (!NoVerify || VerifyEach) FPM.add(createVerifierPass()); // Verify that input is correct PassManagerBuilder Builder; Builder.OptLevel = OptLevel; Builder.SizeLevel = SizeLevel; if (DisableInline) { // No inlining pass } else if (OptLevel > 1) { Builder.Inliner = createFunctionInliningPass(OptLevel, SizeLevel); } else { Builder.Inliner = createAlwaysInlinerLegacyPass(); } Builder.DisableUnitAtATime = !UnitAtATime; Builder.DisableUnrollLoops = (DisableLoopUnrolling.getNumOccurrences() > 0) ? DisableLoopUnrolling : OptLevel == 0; // This is final, unless there is a #pragma vectorize enable if (DisableLoopVectorization) Builder.LoopVectorize = false; // If option wasn't forced via cmd line (-vectorize-loops, -loop-vectorize) else if (!Builder.LoopVectorize) Builder.LoopVectorize = OptLevel > 1 && SizeLevel < 2; // When #pragma vectorize is on for SLP, do the same as above Builder.SLPVectorize = DisableSLPVectorization ? false : OptLevel > 1 && SizeLevel < 2; // Add target-specific passes that need to run as early as possible. if (TM) Builder.addExtension( PassManagerBuilder::EP_EarlyAsPossible, [&](const PassManagerBuilder &, legacy::PassManagerBase &PM) { TM->addEarlyAsPossiblePasses(PM); }); if (Coroutines) addCoroutinePassesToExtensionPoints(Builder); Builder.populateFunctionPassManager(FPM); Builder.populateModulePassManager(MPM); }
void NVPTXTargetMachine::adjustPassManager(PassManagerBuilder &Builder) { Builder.addExtension( PassManagerBuilder::EP_EarlyAsPossible, [&](const PassManagerBuilder &, legacy::PassManagerBase &PM) { PM.add(createNVVMReflectPass()); PM.add(createNVVMIntrRangePass(Subtarget.getSmVersion())); }); }
static void runLTOPasses(Module &M, TargetMachine &TM) { if (const DataLayout *DL = TM.getDataLayout()) M.setDataLayout(*DL); legacy::PassManager passes; passes.add(createTargetTransformInfoWrapperPass(TM.getTargetIRAnalysis())); PassManagerBuilder PMB; PMB.LibraryInfo = new TargetLibraryInfoImpl(Triple(TM.getTargetTriple())); PMB.Inliner = createFunctionInliningPass(); PMB.VerifyInput = true; PMB.VerifyOutput = true; PMB.LoopVectorize = true; PMB.SLPVectorize = true; PMB.OptLevel = options::OptLevel; PMB.populateLTOPassManager(passes); passes.run(M); }
// Generate current module to std::string std::string* AndroidBitcodeLinker::GenerateBitcode() { std::string *BCString = new std::string; Module *M = linker->getModule(); legacy::PassManager PM; raw_string_ostream Bitcode(*BCString); PM.add(createVerifierPass()); if (!Config.isDisableOpt()) { PassManagerBuilder PMBuilder; PMBuilder.Inliner = createFunctionInliningPass(); PMBuilder.populateLTOPassManager(PM); } // Doing clean up passes if (!Config.isDisableOpt()) { PM.add(createInstructionCombiningPass()); PM.add(createCFGSimplificationPass()); PM.add(createAggressiveDCEPass()); PM.add(createGlobalDCEPass()); } // Make sure everything is still good PM.add(createVerifierPass()); // Strip debug info and symbols. if (Config.isStripAll() || Config.isStripDebug()) PM.add(createStripSymbolsPass(Config.isStripDebug() && !Config.isStripAll())); PM.add(createBitcodeWriterPass(Bitcode)); PM.run(*M); Bitcode.flush(); // Re-compute defined and undefined symbols UpdateSymbolList(M); delete M; delete linker; linker = 0; return BCString; }
static void runLTOPasses(Module &M, TargetMachine &TM) { M.setDataLayout(TM.createDataLayout()); legacy::PassManager passes; passes.add(createTargetTransformInfoWrapperPass(TM.getTargetIRAnalysis())); PassManagerBuilder PMB; PMB.LibraryInfo = new TargetLibraryInfoImpl(Triple(TM.getTargetTriple())); PMB.Inliner = createFunctionInliningPass(); // Unconditionally verify input since it is not verified before this // point and has unknown origin. PMB.VerifyInput = true; PMB.VerifyOutput = !options::DisableVerify; PMB.LoopVectorize = true; PMB.SLPVectorize = true; PMB.OptLevel = options::OptLevel; PMB.populateLTOPassManager(passes); passes.run(M); }
/// Optimize merged modules using various IPO passes bool LTOCodeGenerator::optimize(bool DisableOpt, bool DisableInline, bool DisableGVNLoadPRE, bool DisableVectorization, std::string &errMsg) { if (!this->determineTarget(errMsg)) return false; Module *mergedModule = IRLinker.getModule(); // Mark which symbols can not be internalized this->applyScopeRestrictions(); // Instantiate the pass manager to organize the passes. legacy::PassManager passes; // Add an appropriate DataLayout instance for this module... 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 TargetLibraryInfoImpl(TargetTriple); if (DisableOpt) PMB.OptLevel = 0; PMB.VerifyInput = true; PMB.VerifyOutput = true; PMB.populateLTOPassManager(passes); // Run our queue of passes all at once now, efficiently. passes.run(*mergedModule); return true; }
/// Optimize merged modules using various IPO passes bool LTOCodeGenerator::optimize(bool DisableVerify, bool DisableInline, bool DisableGVNLoadPRE, bool DisableVectorization) { if (!this->determineTarget()) return false; // We always run the verifier once on the merged module, the `DisableVerify` // parameter only applies to subsequent verify. verifyMergedModuleOnce(); // Mark which symbols can not be internalized this->applyScopeRestrictions(); // Instantiate the pass manager to organize the passes. legacy::PassManager passes; // Add an appropriate DataLayout instance for this module... MergedModule->setDataLayout(TargetMach->createDataLayout()); 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 TargetLibraryInfoImpl(TargetTriple); PMB.OptLevel = OptLevel; PMB.VerifyInput = !DisableVerify; PMB.VerifyOutput = !DisableVerify; PMB.populateLTOPassManager(passes); // Run our queue of passes all at once now, efficiently. passes.run(*MergedModule); return true; }