tools/opt/NewPMDriver.cpp

   1 //===- NewPMDriver.cpp - Driver for opt with new PM -----------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 /// \file
   9 ///
  10 /// This file is just a split of the code that logically belongs in opt.cpp but
  11 /// that includes the new pass manager headers.
  12 ///
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "NewPMDriver.h"
  16 #include "Debugify.h"
  17 #include "PassPrinters.h"
  18 #include "llvm/ADT/StringRef.h"
  19 #include "llvm/Analysis/AliasAnalysis.h"
  20 #include "llvm/Analysis/CGSCCPassManager.h"
  21 #include "llvm/Bitcode/BitcodeWriterPass.h"
  22 #include "llvm/Config/llvm-config.h"
  23 #include "llvm/IR/Dominators.h"
  24 #include "llvm/IR/IRPrintingPasses.h"
  25 #include "llvm/IR/LLVMContext.h"
  26 #include "llvm/IR/Module.h"
  27 #include "llvm/IR/PassManager.h"
  28 #include "llvm/IR/Verifier.h"
  29 #include "llvm/Passes/PassBuilder.h"
  30 #include "llvm/Passes/PassPlugin.h"
  31 #include "llvm/Passes/StandardInstrumentations.h"
  32 #include "llvm/Support/CommandLine.h"
  33 #include "llvm/Support/ErrorHandling.h"
  34 #include "llvm/Support/ToolOutputFile.h"
  35 #include "llvm/Target/TargetMachine.h"
  36 #include "llvm/Transforms/IPO/ThinLTOBitcodeWriter.h"
  37 #include "llvm/Transforms/Scalar/LoopPassManager.h"
  38
  39 using namespace llvm;
  40 using namespace opt_tool;
  41
  42 static cl::opt<bool>
  43     DebugPM("debug-pass-manager", cl::Hidden,
  44             cl::desc("Print pass management debugging information"));
  45
  46 static cl::list<std::string>
  47     PassPlugins("load-pass-plugin",
  48                 cl::desc("Load passes from plugin library"));
  49
  50 // This flag specifies a textual description of the alias analysis pipeline to
  51 // use when querying for aliasing information. It only works in concert with
  52 // the "passes" flag above.
  53 static cl::opt<std::string>
  54     AAPipeline("aa-pipeline",
  55                cl::desc("A textual description of the alias analysis "
  56                         "pipeline for handling managed aliasing queries"),
  57                cl::Hidden);
  58
  59 /// {{@ These options accept textual pipeline descriptions which will be
  60 /// inserted into default pipelines at the respective extension points
  61 static cl::opt<std::string> PeepholeEPPipeline(
  62     "passes-ep-peephole",
  63     cl::desc("A textual description of the function pass pipeline inserted at "
  64              "the Peephole extension points into default pipelines"),
  65     cl::Hidden);
  66 static cl::opt<std::string> LateLoopOptimizationsEPPipeline(
  67     "passes-ep-late-loop-optimizations",
  68     cl::desc(
  69         "A textual description of the loop pass pipeline inserted at "
  70         "the LateLoopOptimizations extension point into default pipelines"),
  71     cl::Hidden);
  72 static cl::opt<std::string> LoopOptimizerEndEPPipeline(
  73     "passes-ep-loop-optimizer-end",
  74     cl::desc("A textual description of the loop pass pipeline inserted at "
  75              "the LoopOptimizerEnd extension point into default pipelines"),
  76     cl::Hidden);
  77 static cl::opt<std::string> ScalarOptimizerLateEPPipeline(
  78     "passes-ep-scalar-optimizer-late",
  79     cl::desc("A textual description of the function pass pipeline inserted at "
  80              "the ScalarOptimizerLate extension point into default pipelines"),
  81     cl::Hidden);
  82 static cl::opt<std::string> CGSCCOptimizerLateEPPipeline(
  83     "passes-ep-cgscc-optimizer-late",
  84     cl::desc("A textual description of the cgscc pass pipeline inserted at "
  85              "the CGSCCOptimizerLate extension point into default pipelines"),
  86     cl::Hidden);
  87 static cl::opt<std::string> VectorizerStartEPPipeline(
  88     "passes-ep-vectorizer-start",
  89     cl::desc("A textual description of the function pass pipeline inserted at "
  90              "the VectorizerStart extension point into default pipelines"),
  91     cl::Hidden);
  92 static cl::opt<std::string> PipelineStartEPPipeline(
  93     "passes-ep-pipeline-start",
  94     cl::desc("A textual description of the function pass pipeline inserted at "
  95              "the PipelineStart extension point into default pipelines"),
  96     cl::Hidden);
  97 static cl::opt<std::string> OptimizerLastEPPipeline(
  98     "passes-ep-optimizer-last",
  99     cl::desc("A textual description of the function pass pipeline inserted at "
 100              "the OptimizerLast extension point into default pipelines"),
 101     cl::Hidden);
 102
 103 extern cl::opt<PGOKind> PGOKindFlag;
 104 extern cl::opt<std::string> ProfileFile;
 105 extern cl::opt<CSPGOKind> CSPGOKindFlag;
 106 extern cl::opt<std::string> CSProfileGenFile;
 107
 108 static cl::opt<std::string>
 109     ProfileRemappingFile("profile-remapping-file",
 110                          cl::desc("Path to the profile remapping file."),
 111                          cl::Hidden);
 112 static cl::opt<bool> DebugInfoForProfiling(
 113     "new-pm-debug-info-for-profiling", cl::init(false), cl::Hidden,
 114     cl::desc("Emit special debug info to enable PGO profile generation."));
 115 /// @}}
 116
 117 template <typename PassManagerT>
 118 bool tryParsePipelineText(PassBuilder &PB,
 119                           const cl::opt<std::string> &PipelineOpt) {
 120   if (PipelineOpt.empty())
 121     return false;
 122
 123   // Verify the pipeline is parseable:
 124   PassManagerT PM;
 125   if (auto Err = PB.parsePassPipeline(PM, PipelineOpt)) {
 126     errs() << "Could not parse -" << PipelineOpt.ArgStr
 127            << " pipeline: " << toString(std::move(Err))
 128            << "... I'm going to ignore it.\n";
 129     return false;
 130   }
 131   return true;
 132 }
 133
 134 /// If one of the EPPipeline command line options was given, register callbacks
 135 /// for parsing and inserting the given pipeline
 136 static void registerEPCallbacks(PassBuilder &PB, bool VerifyEachPass,
 137                                 bool DebugLogging) {
 138   if (tryParsePipelineText<FunctionPassManager>(PB, PeepholeEPPipeline))
 139     PB.registerPeepholeEPCallback(
 140         [&PB, VerifyEachPass, DebugLogging](
 141             FunctionPassManager &PM, PassBuilder::OptimizationLevel Level) {
 142           ExitOnError Err("Unable to parse PeepholeEP pipeline: ");
 143           Err(PB.parsePassPipeline(PM, PeepholeEPPipeline, VerifyEachPass,
 144                                    DebugLogging));
 145         });
 146   if (tryParsePipelineText<LoopPassManager>(PB,
 147                                             LateLoopOptimizationsEPPipeline))
 148     PB.registerLateLoopOptimizationsEPCallback(
 149         [&PB, VerifyEachPass, DebugLogging](
 150             LoopPassManager &PM, PassBuilder::OptimizationLevel Level) {
 151           ExitOnError Err("Unable to parse LateLoopOptimizationsEP pipeline: ");
 152           Err(PB.parsePassPipeline(PM, LateLoopOptimizationsEPPipeline,
 153                                    VerifyEachPass, DebugLogging));
 154         });
 155   if (tryParsePipelineText<LoopPassManager>(PB, LoopOptimizerEndEPPipeline))
 156     PB.registerLoopOptimizerEndEPCallback(
 157         [&PB, VerifyEachPass, DebugLogging](
 158             LoopPassManager &PM, PassBuilder::OptimizationLevel Level) {
 159           ExitOnError Err("Unable to parse LoopOptimizerEndEP pipeline: ");
 160           Err(PB.parsePassPipeline(PM, LoopOptimizerEndEPPipeline,
 161                                    VerifyEachPass, DebugLogging));
 162         });
 163   if (tryParsePipelineText<FunctionPassManager>(PB,
 164                                                 ScalarOptimizerLateEPPipeline))
 165     PB.registerScalarOptimizerLateEPCallback(
 166         [&PB, VerifyEachPass, DebugLogging](
 167             FunctionPassManager &PM, PassBuilder::OptimizationLevel Level) {
 168           ExitOnError Err("Unable to parse ScalarOptimizerLateEP pipeline: ");
 169           Err(PB.parsePassPipeline(PM, ScalarOptimizerLateEPPipeline,
 170                                    VerifyEachPass, DebugLogging));
 171         });
 172   if (tryParsePipelineText<CGSCCPassManager>(PB, CGSCCOptimizerLateEPPipeline))
 173     PB.registerCGSCCOptimizerLateEPCallback(
 174         [&PB, VerifyEachPass, DebugLogging](
 175             CGSCCPassManager &PM, PassBuilder::OptimizationLevel Level) {
 176           ExitOnError Err("Unable to parse CGSCCOptimizerLateEP pipeline: ");
 177           Err(PB.parsePassPipeline(PM, CGSCCOptimizerLateEPPipeline,
 178                                    VerifyEachPass, DebugLogging));
 179         });
 180   if (tryParsePipelineText<FunctionPassManager>(PB, VectorizerStartEPPipeline))
 181     PB.registerVectorizerStartEPCallback(
 182         [&PB, VerifyEachPass, DebugLogging](
 183             FunctionPassManager &PM, PassBuilder::OptimizationLevel Level) {
 184           ExitOnError Err("Unable to parse VectorizerStartEP pipeline: ");
 185           Err(PB.parsePassPipeline(PM, VectorizerStartEPPipeline,
 186                                    VerifyEachPass, DebugLogging));
 187         });
 188   if (tryParsePipelineText<ModulePassManager>(PB, PipelineStartEPPipeline))
 189     PB.registerPipelineStartEPCallback(
 190         [&PB, VerifyEachPass, DebugLogging](ModulePassManager &PM) {
 191           ExitOnError Err("Unable to parse PipelineStartEP pipeline: ");
 192           Err(PB.parsePassPipeline(PM, PipelineStartEPPipeline, VerifyEachPass,
 193                                    DebugLogging));
 194         });
 195   if (tryParsePipelineText<FunctionPassManager>(PB, OptimizerLastEPPipeline))
 196     PB.registerOptimizerLastEPCallback(
 197         [&PB, VerifyEachPass, DebugLogging](FunctionPassManager &PM,
 198                                             PassBuilder::OptimizationLevel) {
 199           ExitOnError Err("Unable to parse OptimizerLastEP pipeline: ");
 200           Err(PB.parsePassPipeline(PM, OptimizerLastEPPipeline, VerifyEachPass,
 201                                    DebugLogging));
 202         });
 203 }
 204
 205 #ifdef LINK_POLLY_INTO_TOOLS
 206 namespace polly {
 207 void RegisterPollyPasses(PassBuilder &);
 208 }
 209 #endif
 210
 211 bool llvm::runPassPipeline(StringRef Arg0, Module &M, TargetMachine *TM,
 212                            ToolOutputFile *Out, ToolOutputFile *ThinLTOLinkOut,
 213                            ToolOutputFile *OptRemarkFile,
 214                            StringRef PassPipeline, OutputKind OK,
 215                            VerifierKind VK,
 216                            bool ShouldPreserveAssemblyUseListOrder,
 217                            bool ShouldPreserveBitcodeUseListOrder,
 218                            bool EmitSummaryIndex, bool EmitModuleHash,
 219                            bool EnableDebugify) {
 220   bool VerifyEachPass = VK == VK_VerifyEachPass;
 221
 222   Optional<PGOOptions> P;
 223   switch (PGOKindFlag) {
 224     case InstrGen:
 225       P = PGOOptions(ProfileFile, "", "", PGOOptions::IRInstr);
 226       break;
 227     case InstrUse:
 228       P = PGOOptions(ProfileFile, "", ProfileRemappingFile, PGOOptions::IRUse);
 229       break;
 230     case SampleUse:
 231       P = PGOOptions(ProfileFile, "", ProfileRemappingFile,
 232                      PGOOptions::SampleUse);
 233       break;
 234     case NoPGO:
 235       if (DebugInfoForProfiling)
 236         P = PGOOptions("", "", "", PGOOptions::NoAction, PGOOptions::NoCSAction,
 237                        true);
 238       else
 239         P = None;
 240     }
 241     if (CSPGOKindFlag != NoCSPGO) {
 242       if (P && (P->Action == PGOOptions::IRInstr ||
 243                 P->Action == PGOOptions::SampleUse))
 244         errs() << "CSPGOKind cannot be used with IRInstr or SampleUse";
 245       if (CSPGOKindFlag == CSInstrGen) {
 246         if (CSProfileGenFile.empty())
 247           errs() << "CSInstrGen needs to specify CSProfileGenFile";
 248         if (P) {
 249           P->CSAction = PGOOptions::CSIRInstr;
 250           P->CSProfileGenFile = CSProfileGenFile;
 251         } else
 252           P = PGOOptions("", CSProfileGenFile, ProfileRemappingFile,
 253                          PGOOptions::NoAction, PGOOptions::CSIRInstr);
 254       } else /* CSPGOKindFlag == CSInstrUse */ {
 255         if (!P)
 256           errs() << "CSInstrUse needs to be together with InstrUse";
 257         P->CSAction = PGOOptions::CSIRUse;
 258       }
 259     }
 260   PassInstrumentationCallbacks PIC;
 261   StandardInstrumentations SI;
 262   SI.registerCallbacks(PIC);
 263
 264   PassBuilder PB(TM, PipelineTuningOptions(), P, &PIC);
 265   registerEPCallbacks(PB, VerifyEachPass, DebugPM);
 266
 267   // Load requested pass plugins and let them register pass builder callbacks
 268   for (auto &PluginFN : PassPlugins) {
 269     auto PassPlugin = PassPlugin::Load(PluginFN);
 270     if (!PassPlugin) {
 271       errs() << "Failed to load passes from '" << PluginFN
 272              << "'. Request ignored.\n";
 273       continue;
 274     }
 275
 276     PassPlugin->registerPassBuilderCallbacks(PB);
 277   }
 278
 279   // Register a callback that creates the debugify passes as needed.
 280   PB.registerPipelineParsingCallback(
 281       [](StringRef Name, ModulePassManager &MPM,
 282          ArrayRef<PassBuilder::PipelineElement>) {
 283         if (Name == "debugify") {
 284           MPM.addPass(NewPMDebugifyPass());
 285           return true;
 286         } else if (Name == "check-debugify") {
 287           MPM.addPass(NewPMCheckDebugifyPass());
 288           return true;
 289         }
 290         return false;
 291       });
 292
 293 #ifdef LINK_POLLY_INTO_TOOLS
 294   polly::RegisterPollyPasses(PB);
 295 #endif
 296
 297   // Specially handle the alias analysis manager so that we can register
 298   // a custom pipeline of AA passes with it.
 299   AAManager AA;
 300   if (auto Err = PB.parseAAPipeline(AA, AAPipeline)) {
 301     errs() << Arg0 << ": " << toString(std::move(Err)) << "\n";
 302     return false;
 303   }
 304
 305   LoopAnalysisManager LAM(DebugPM);
 306   FunctionAnalysisManager FAM(DebugPM);
 307   CGSCCAnalysisManager CGAM(DebugPM);
 308   ModuleAnalysisManager MAM(DebugPM);
 309
 310   // Register the AA manager first so that our version is the one used.
 311   FAM.registerPass([&] { return std::move(AA); });
 312
 313   // Register all the basic analyses with the managers.
 314   PB.registerModuleAnalyses(MAM);
 315   PB.registerCGSCCAnalyses(CGAM);
 316   PB.registerFunctionAnalyses(FAM);
 317   PB.registerLoopAnalyses(LAM);
 318   PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
 319
 320   ModulePassManager MPM(DebugPM);
 321   if (VK > VK_NoVerifier)
 322     MPM.addPass(VerifierPass());
 323   if (EnableDebugify)
 324     MPM.addPass(NewPMDebugifyPass());
 325
 326   if (auto Err =
 327           PB.parsePassPipeline(MPM, PassPipeline, VerifyEachPass, DebugPM)) {
 328     errs() << Arg0 << ": " << toString(std::move(Err)) << "\n";
 329     return false;
 330   }
 331
 332   if (VK > VK_NoVerifier)
 333     MPM.addPass(VerifierPass());
 334   if (EnableDebugify)
 335     MPM.addPass(NewPMCheckDebugifyPass());
 336
 337   // Add any relevant output pass at the end of the pipeline.
 338   switch (OK) {
 339   case OK_NoOutput:
 340     break; // No output pass needed.
 341   case OK_OutputAssembly:
 342     MPM.addPass(
 343         PrintModulePass(Out->os(), "", ShouldPreserveAssemblyUseListOrder));
 344     break;
 345   case OK_OutputBitcode:
 346     MPM.addPass(BitcodeWriterPass(Out->os(), ShouldPreserveBitcodeUseListOrder,
 347                                   EmitSummaryIndex, EmitModuleHash));
 348     break;
 349   case OK_OutputThinLTOBitcode:
 350     MPM.addPass(ThinLTOBitcodeWriterPass(
 351         Out->os(), ThinLTOLinkOut ? &ThinLTOLinkOut->os() : nullptr));
 352     break;
 353   }
 354
 355   // Before executing passes, print the final values of the LLVM options.
 356   cl::PrintOptionValues();
 357
 358   // Now that we have all of the passes ready, run them.
 359   MPM.run(M, MAM);
 360
 361   // Declare success.
 362   if (OK != OK_NoOutput) {
 363     Out->keep();
 364     if (OK == OK_OutputThinLTOBitcode && ThinLTOLinkOut)
 365       ThinLTOLinkOut->keep();
 366   }
 367
 368   if (OptRemarkFile)
 369     OptRemarkFile->keep();
 370
 371   return true;
 372 }