llvm/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 "llvm/ADT/SmallVector.h"
  17 #include "llvm/ADT/StringRef.h"
  18 #include "llvm/Analysis/AliasAnalysis.h"
  19 #include "llvm/Analysis/CGSCCPassManager.h"
  20 #include "llvm/Analysis/TargetLibraryInfo.h"
  21 #include "llvm/Bitcode/BitcodeWriterPass.h"
  22 #include "llvm/Config/llvm-config.h"
  23 #include "llvm/IR/Dominators.h"
  24 #include "llvm/IR/LLVMContext.h"
  25 #include "llvm/IR/Module.h"
  26 #include "llvm/IR/PassManager.h"
  27 #include "llvm/IR/Verifier.h"
  28 #include "llvm/IRPrinter/IRPrintingPasses.h"
  29 #include "llvm/Passes/PassBuilder.h"
  30 #include "llvm/Passes/PassPlugin.h"
  31 #include "llvm/Passes/StandardInstrumentations.h"
  32 #include "llvm/Support/ErrorHandling.h"
  33 #include "llvm/Support/ToolOutputFile.h"
  34 #include "llvm/Support/VirtualFileSystem.h"
  35 #include "llvm/Support/raw_ostream.h"
  36 #include "llvm/Target/TargetMachine.h"
  37 #include "llvm/Transforms/IPO/ThinLTOBitcodeWriter.h"
  38 #include "llvm/Transforms/Instrumentation/AddressSanitizer.h"
  39 #include "llvm/Transforms/Scalar/LoopPassManager.h"
  40 #include "llvm/Transforms/Utils/Debugify.h"
  41
  42 using namespace llvm;
  43 using namespace opt_tool;
  44
  45 namespace llvm {
  46 cl::opt<bool> DebugifyEach(
  47     "debugify-each",
  48     cl::desc("Start each pass with debugify and end it with check-debugify"));
  49
  50 cl::opt<std::string>
  51     DebugifyExport("debugify-export",
  52                    cl::desc("Export per-pass debugify statistics to this file"),
  53                    cl::value_desc("filename"));
  54
  55 cl::opt<bool> VerifyEachDebugInfoPreserve(
  56     "verify-each-debuginfo-preserve",
  57     cl::desc("Start each pass with collecting and end it with checking of "
  58              "debug info preservation."));
  59
  60 cl::opt<std::string>
  61     VerifyDIPreserveExport("verify-di-preserve-export",
  62                    cl::desc("Export debug info preservation failures into "
  63                             "specified (JSON) file (should be abs path as we use"
  64                             " append mode to insert new JSON objects)"),
  65                    cl::value_desc("filename"), cl::init(""));
  66
  67 } // namespace llvm
  68
  69 enum class DebugLogging { None, Normal, Verbose, Quiet };
  70
  71 static cl::opt<DebugLogging> DebugPM(
  72     "debug-pass-manager", cl::Hidden, cl::ValueOptional,
  73     cl::desc("Print pass management debugging information"),
  74     cl::init(DebugLogging::None),
  75     cl::values(
  76         clEnumValN(DebugLogging::Normal, "", ""),
  77         clEnumValN(DebugLogging::Quiet, "quiet",
  78                    "Skip printing info about analyses"),
  79         clEnumValN(
  80             DebugLogging::Verbose, "verbose",
  81             "Print extra information about adaptors and pass managers")));
  82
  83 // This flag specifies a textual description of the alias analysis pipeline to
  84 // use when querying for aliasing information. It only works in concert with
  85 // the "passes" flag above.
  86 static cl::opt<std::string>
  87     AAPipeline("aa-pipeline",
  88                cl::desc("A textual description of the alias analysis "
  89                         "pipeline for handling managed aliasing queries"),
  90                cl::Hidden, cl::init("default"));
  91
  92 /// {{@ These options accept textual pipeline descriptions which will be
  93 /// inserted into default pipelines at the respective extension points
  94 static cl::opt<std::string> PeepholeEPPipeline(
  95     "passes-ep-peephole",
  96     cl::desc("A textual description of the function pass pipeline inserted at "
  97              "the Peephole extension points into default pipelines"),
  98     cl::Hidden);
  99 static cl::opt<std::string> LateLoopOptimizationsEPPipeline(
 100     "passes-ep-late-loop-optimizations",
 101     cl::desc(
 102         "A textual description of the loop pass pipeline inserted at "
 103         "the LateLoopOptimizations extension point into default pipelines"),
 104     cl::Hidden);
 105 static cl::opt<std::string> LoopOptimizerEndEPPipeline(
 106     "passes-ep-loop-optimizer-end",
 107     cl::desc("A textual description of the loop pass pipeline inserted at "
 108              "the LoopOptimizerEnd extension point into default pipelines"),
 109     cl::Hidden);
 110 static cl::opt<std::string> ScalarOptimizerLateEPPipeline(
 111     "passes-ep-scalar-optimizer-late",
 112     cl::desc("A textual description of the function pass pipeline inserted at "
 113              "the ScalarOptimizerLate extension point into default pipelines"),
 114     cl::Hidden);
 115 static cl::opt<std::string> CGSCCOptimizerLateEPPipeline(
 116     "passes-ep-cgscc-optimizer-late",
 117     cl::desc("A textual description of the cgscc pass pipeline inserted at "
 118              "the CGSCCOptimizerLate extension point into default pipelines"),
 119     cl::Hidden);
 120 static cl::opt<std::string> VectorizerStartEPPipeline(
 121     "passes-ep-vectorizer-start",
 122     cl::desc("A textual description of the function pass pipeline inserted at "
 123              "the VectorizerStart extension point into default pipelines"),
 124     cl::Hidden);
 125 static cl::opt<std::string> PipelineStartEPPipeline(
 126     "passes-ep-pipeline-start",
 127     cl::desc("A textual description of the module pass pipeline inserted at "
 128              "the PipelineStart extension point into default pipelines"),
 129     cl::Hidden);
 130 static cl::opt<std::string> PipelineEarlySimplificationEPPipeline(
 131     "passes-ep-pipeline-early-simplification",
 132     cl::desc("A textual description of the module pass pipeline inserted at "
 133              "the EarlySimplification extension point into default pipelines"),
 134     cl::Hidden);
 135 static cl::opt<std::string> OptimizerEarlyEPPipeline(
 136     "passes-ep-optimizer-early",
 137     cl::desc("A textual description of the module pass pipeline inserted at "
 138              "the OptimizerEarly extension point into default pipelines"),
 139     cl::Hidden);
 140 static cl::opt<std::string> OptimizerLastEPPipeline(
 141     "passes-ep-optimizer-last",
 142     cl::desc("A textual description of the module pass pipeline inserted at "
 143              "the OptimizerLast extension point into default pipelines"),
 144     cl::Hidden);
 145 static cl::opt<std::string> FullLinkTimeOptimizationEarlyEPPipeline(
 146     "passes-ep-full-link-time-optimization-early",
 147     cl::desc("A textual description of the module pass pipeline inserted at "
 148              "the FullLinkTimeOptimizationEarly extension point into default "
 149              "pipelines"),
 150     cl::Hidden);
 151 static cl::opt<std::string> FullLinkTimeOptimizationLastEPPipeline(
 152     "passes-ep-full-link-time-optimization-last",
 153     cl::desc("A textual description of the module pass pipeline inserted at "
 154              "the FullLinkTimeOptimizationLast extension point into default "
 155              "pipelines"),
 156     cl::Hidden);
 157 /// @}}
 158
 159 static cl::opt<bool> DisablePipelineVerification(
 160     "disable-pipeline-verification",
 161     cl::desc("Only has an effect when specified with -print-pipeline-passes. "
 162              "Disables verifying that the textual pipeline generated by "
 163              "-print-pipeline-passes can be used to create a pipeline."),
 164     cl::Hidden);
 165
 166
 167 static cl::opt<PGOKind>
 168     PGOKindFlag("pgo-kind", cl::init(NoPGO), cl::Hidden,
 169                 cl::desc("The kind of profile guided optimization"),
 170                 cl::values(clEnumValN(NoPGO, "nopgo", "Do not use PGO."),
 171                            clEnumValN(InstrGen, "pgo-instr-gen-pipeline",
 172                                       "Instrument the IR to generate profile."),
 173                            clEnumValN(InstrUse, "pgo-instr-use-pipeline",
 174                                       "Use instrumented profile to guide PGO."),
 175                            clEnumValN(SampleUse, "pgo-sample-use-pipeline",
 176                                       "Use sampled profile to guide PGO.")));
 177 static cl::opt<std::string> ProfileFile("profile-file",
 178                                  cl::desc("Path to the profile."), cl::Hidden);
 179 static cl::opt<std::string>
 180     MemoryProfileFile("memory-profile-file",
 181                       cl::desc("Path to the memory profile."), cl::Hidden);
 182
 183 static cl::opt<CSPGOKind> CSPGOKindFlag(
 184     "cspgo-kind", cl::init(NoCSPGO), cl::Hidden,
 185     cl::desc("The kind of context sensitive profile guided optimization"),
 186     cl::values(
 187         clEnumValN(NoCSPGO, "nocspgo", "Do not use CSPGO."),
 188         clEnumValN(
 189             CSInstrGen, "cspgo-instr-gen-pipeline",
 190             "Instrument (context sensitive) the IR to generate profile."),
 191         clEnumValN(
 192             CSInstrUse, "cspgo-instr-use-pipeline",
 193             "Use instrumented (context sensitive) profile to guide PGO.")));
 194
 195 static cl::opt<std::string> CSProfileGenFile(
 196     "cs-profilegen-file",
 197     cl::desc("Path to the instrumented context sensitive profile."),
 198     cl::Hidden);
 199
 200 static cl::opt<std::string>
 201     ProfileRemappingFile("profile-remapping-file",
 202                          cl::desc("Path to the profile remapping file."),
 203                          cl::Hidden);
 204
 205 static cl::opt<bool> DebugInfoForProfiling(
 206     "debug-info-for-profiling", cl::init(false), cl::Hidden,
 207     cl::desc("Emit special debug info to enable PGO profile generation."));
 208
 209 static cl::opt<bool> PseudoProbeForProfiling(
 210     "pseudo-probe-for-profiling", cl::init(false), cl::Hidden,
 211     cl::desc("Emit pseudo probes to enable PGO profile generation."));
 212
 213 static cl::opt<bool> DisableLoopUnrolling(
 214     "disable-loop-unrolling",
 215     cl::desc("Disable loop unrolling in all relevant passes"), cl::init(false));
 216
 217 namespace llvm {
 218 extern cl::opt<bool> PrintPipelinePasses;
 219 } // namespace llvm
 220
 221 template <typename PassManagerT>
 222 bool tryParsePipelineText(PassBuilder &PB,
 223                           const cl::opt<std::string> &PipelineOpt) {
 224   if (PipelineOpt.empty())
 225     return false;
 226
 227   // Verify the pipeline is parseable:
 228   PassManagerT PM;
 229   if (auto Err = PB.parsePassPipeline(PM, PipelineOpt)) {
 230     errs() << "Could not parse -" << PipelineOpt.ArgStr
 231            << " pipeline: " << toString(std::move(Err))
 232            << "... I'm going to ignore it.\n";
 233     return false;
 234   }
 235   return true;
 236 }
 237
 238 /// If one of the EPPipeline command line options was given, register callbacks
 239 /// for parsing and inserting the given pipeline
 240 static void registerEPCallbacks(PassBuilder &PB) {
 241   if (tryParsePipelineText<FunctionPassManager>(PB, PeepholeEPPipeline))
 242     PB.registerPeepholeEPCallback(
 243         [&PB](FunctionPassManager &PM, OptimizationLevel Level) {
 244           ExitOnError Err("Unable to parse PeepholeEP pipeline: ");
 245           Err(PB.parsePassPipeline(PM, PeepholeEPPipeline));
 246         });
 247   if (tryParsePipelineText<LoopPassManager>(PB,
 248                                             LateLoopOptimizationsEPPipeline))
 249     PB.registerLateLoopOptimizationsEPCallback(
 250         [&PB](LoopPassManager &PM, OptimizationLevel Level) {
 251           ExitOnError Err("Unable to parse LateLoopOptimizationsEP pipeline: ");
 252           Err(PB.parsePassPipeline(PM, LateLoopOptimizationsEPPipeline));
 253         });
 254   if (tryParsePipelineText<LoopPassManager>(PB, LoopOptimizerEndEPPipeline))
 255     PB.registerLoopOptimizerEndEPCallback(
 256         [&PB](LoopPassManager &PM, OptimizationLevel Level) {
 257           ExitOnError Err("Unable to parse LoopOptimizerEndEP pipeline: ");
 258           Err(PB.parsePassPipeline(PM, LoopOptimizerEndEPPipeline));
 259         });
 260   if (tryParsePipelineText<FunctionPassManager>(PB,
 261                                                 ScalarOptimizerLateEPPipeline))
 262     PB.registerScalarOptimizerLateEPCallback(
 263         [&PB](FunctionPassManager &PM, OptimizationLevel Level) {
 264           ExitOnError Err("Unable to parse ScalarOptimizerLateEP pipeline: ");
 265           Err(PB.parsePassPipeline(PM, ScalarOptimizerLateEPPipeline));
 266         });
 267   if (tryParsePipelineText<CGSCCPassManager>(PB, CGSCCOptimizerLateEPPipeline))
 268     PB.registerCGSCCOptimizerLateEPCallback(
 269         [&PB](CGSCCPassManager &PM, OptimizationLevel Level) {
 270           ExitOnError Err("Unable to parse CGSCCOptimizerLateEP pipeline: ");
 271           Err(PB.parsePassPipeline(PM, CGSCCOptimizerLateEPPipeline));
 272         });
 273   if (tryParsePipelineText<FunctionPassManager>(PB, VectorizerStartEPPipeline))
 274     PB.registerVectorizerStartEPCallback(
 275         [&PB](FunctionPassManager &PM, OptimizationLevel Level) {
 276           ExitOnError Err("Unable to parse VectorizerStartEP pipeline: ");
 277           Err(PB.parsePassPipeline(PM, VectorizerStartEPPipeline));
 278         });
 279   if (tryParsePipelineText<ModulePassManager>(PB, PipelineStartEPPipeline))
 280     PB.registerPipelineStartEPCallback(
 281         [&PB](ModulePassManager &PM, OptimizationLevel) {
 282           ExitOnError Err("Unable to parse PipelineStartEP pipeline: ");
 283           Err(PB.parsePassPipeline(PM, PipelineStartEPPipeline));
 284         });
 285   if (tryParsePipelineText<ModulePassManager>(
 286           PB, PipelineEarlySimplificationEPPipeline))
 287     PB.registerPipelineEarlySimplificationEPCallback(
 288         [&PB](ModulePassManager &PM, OptimizationLevel) {
 289           ExitOnError Err("Unable to parse EarlySimplification pipeline: ");
 290           Err(PB.parsePassPipeline(PM, PipelineEarlySimplificationEPPipeline));
 291         });
 292   if (tryParsePipelineText<ModulePassManager>(PB, OptimizerEarlyEPPipeline))
 293     PB.registerOptimizerEarlyEPCallback(
 294         [&PB](ModulePassManager &PM, OptimizationLevel) {
 295           ExitOnError Err("Unable to parse OptimizerEarlyEP pipeline: ");
 296           Err(PB.parsePassPipeline(PM, OptimizerEarlyEPPipeline));
 297         });
 298   if (tryParsePipelineText<ModulePassManager>(PB, OptimizerLastEPPipeline))
 299     PB.registerOptimizerLastEPCallback(
 300         [&PB](ModulePassManager &PM, OptimizationLevel) {
 301           ExitOnError Err("Unable to parse OptimizerLastEP pipeline: ");
 302           Err(PB.parsePassPipeline(PM, OptimizerLastEPPipeline));
 303         });
 304   if (tryParsePipelineText<ModulePassManager>(
 305           PB, FullLinkTimeOptimizationEarlyEPPipeline))
 306     PB.registerFullLinkTimeOptimizationEarlyEPCallback(
 307         [&PB](ModulePassManager &PM, OptimizationLevel) {
 308           ExitOnError Err(
 309               "Unable to parse FullLinkTimeOptimizationEarlyEP pipeline: ");
 310           Err(PB.parsePassPipeline(PM,
 311                                    FullLinkTimeOptimizationEarlyEPPipeline));
 312         });
 313   if (tryParsePipelineText<ModulePassManager>(
 314           PB, FullLinkTimeOptimizationLastEPPipeline))
 315     PB.registerFullLinkTimeOptimizationLastEPCallback(
 316         [&PB](ModulePassManager &PM, OptimizationLevel) {
 317           ExitOnError Err(
 318               "Unable to parse FullLinkTimeOptimizationLastEP pipeline: ");
 319           Err(PB.parsePassPipeline(PM, FullLinkTimeOptimizationLastEPPipeline));
 320         });
 321 }
 322
 323 #define HANDLE_EXTENSION(Ext)                                                  \
 324   llvm::PassPluginLibraryInfo get##Ext##PluginInfo();
 325 #include "llvm/Support/Extension.def"
 326
 327 bool llvm::runPassPipeline(
 328     StringRef Arg0, Module &M, TargetMachine *TM, TargetLibraryInfoImpl *TLII,
 329     ToolOutputFile *Out, ToolOutputFile *ThinLTOLinkOut,
 330     ToolOutputFile *OptRemarkFile, StringRef PassPipeline,
 331     ArrayRef<PassPlugin> PassPlugins, OutputKind OK, VerifierKind VK,
 332     bool ShouldPreserveAssemblyUseListOrder,
 333     bool ShouldPreserveBitcodeUseListOrder, bool EmitSummaryIndex,
 334     bool EmitModuleHash, bool EnableDebugify, bool VerifyDIPreserve,
 335     bool UnifiedLTO) {
 336   bool VerifyEachPass = VK == VK_VerifyEachPass;
 337
 338   auto FS = vfs::getRealFileSystem();
 339   std::optional<PGOOptions> P;
 340   switch (PGOKindFlag) {
 341   case InstrGen:
 342     P = PGOOptions(ProfileFile, "", "", MemoryProfileFile, FS,
 343                    PGOOptions::IRInstr);
 344     break;
 345   case InstrUse:
 346     P = PGOOptions(ProfileFile, "", ProfileRemappingFile, MemoryProfileFile, FS,
 347                    PGOOptions::IRUse);
 348     break;
 349   case SampleUse:
 350     P = PGOOptions(ProfileFile, "", ProfileRemappingFile, MemoryProfileFile, FS,
 351                    PGOOptions::SampleUse);
 352     break;
 353   case NoPGO:
 354     if (DebugInfoForProfiling || PseudoProbeForProfiling ||
 355         !MemoryProfileFile.empty())
 356       P = PGOOptions("", "", "", MemoryProfileFile, FS, PGOOptions::NoAction,
 357                      PGOOptions::NoCSAction, DebugInfoForProfiling,
 358                      PseudoProbeForProfiling);
 359     else
 360       P = std::nullopt;
 361   }
 362   if (CSPGOKindFlag != NoCSPGO) {
 363     if (P && (P->Action == PGOOptions::IRInstr ||
 364               P->Action == PGOOptions::SampleUse)) {
 365       errs() << "CSPGOKind cannot be used with IRInstr or SampleUse";
 366       return false;
 367     }
 368     if (CSPGOKindFlag == CSInstrGen) {
 369       if (CSProfileGenFile.empty()) {
 370         errs() << "CSInstrGen needs to specify CSProfileGenFile";
 371         return false;
 372       }
 373       if (P) {
 374         P->CSAction = PGOOptions::CSIRInstr;
 375         P->CSProfileGenFile = CSProfileGenFile;
 376       } else
 377         P = PGOOptions("", CSProfileGenFile, ProfileRemappingFile,
 378                        /*MemoryProfile=*/"", FS, PGOOptions::NoAction,
 379                        PGOOptions::CSIRInstr);
 380     } else /* CSPGOKindFlag == CSInstrUse */ {
 381       if (!P) {
 382         errs() << "CSInstrUse needs to be together with InstrUse";
 383         return false;
 384       }
 385       P->CSAction = PGOOptions::CSIRUse;
 386     }
 387   }
 388   if (TM)
 389     TM->setPGOOption(P);
 390
 391   LoopAnalysisManager LAM;
 392   FunctionAnalysisManager FAM;
 393   CGSCCAnalysisManager CGAM;
 394   ModuleAnalysisManager MAM;
 395
 396   PassInstrumentationCallbacks PIC;
 397   PrintPassOptions PrintPassOpts;
 398   PrintPassOpts.Verbose = DebugPM == DebugLogging::Verbose;
 399   PrintPassOpts.SkipAnalyses = DebugPM == DebugLogging::Quiet;
 400   StandardInstrumentations SI(M.getContext(), DebugPM != DebugLogging::None,
 401                               VerifyEachPass, PrintPassOpts);
 402   SI.registerCallbacks(PIC, &MAM);
 403   DebugifyEachInstrumentation Debugify;
 404   DebugifyStatsMap DIStatsMap;
 405   DebugInfoPerPass DebugInfoBeforePass;
 406   if (DebugifyEach) {
 407     Debugify.setDIStatsMap(DIStatsMap);
 408     Debugify.setDebugifyMode(DebugifyMode::SyntheticDebugInfo);
 409     Debugify.registerCallbacks(PIC, MAM);
 410   } else if (VerifyEachDebugInfoPreserve) {
 411     Debugify.setDebugInfoBeforePass(DebugInfoBeforePass);
 412     Debugify.setDebugifyMode(DebugifyMode::OriginalDebugInfo);
 413     Debugify.setOrigDIVerifyBugsReportFilePath(
 414       VerifyDIPreserveExport);
 415     Debugify.registerCallbacks(PIC, MAM);
 416   }
 417
 418   PipelineTuningOptions PTO;
 419   // LoopUnrolling defaults on to true and DisableLoopUnrolling is initialized
 420   // to false above so we shouldn't necessarily need to check whether or not the
 421   // option has been enabled.
 422   PTO.LoopUnrolling = !DisableLoopUnrolling;
 423   PTO.UnifiedLTO = UnifiedLTO;
 424   PassBuilder PB(TM, PTO, P, &PIC);
 425   registerEPCallbacks(PB);
 426
 427   // For any loaded plugins, let them register pass builder callbacks.
 428   for (auto &PassPlugin : PassPlugins)
 429     PassPlugin.registerPassBuilderCallbacks(PB);
 430
 431 #define HANDLE_EXTENSION(Ext)                                                  \
 432   get##Ext##PluginInfo().RegisterPassBuilderCallbacks(PB);
 433 #include "llvm/Support/Extension.def"
 434
 435   // Specially handle the alias analysis manager so that we can register
 436   // a custom pipeline of AA passes with it.
 437   AAManager AA;
 438   if (auto Err = PB.parseAAPipeline(AA, AAPipeline)) {
 439     errs() << Arg0 << ": " << toString(std::move(Err)) << "\n";
 440     return false;
 441   }
 442
 443   // Register the AA manager first so that our version is the one used.
 444   FAM.registerPass([&] { return std::move(AA); });
 445   // Register our TargetLibraryInfoImpl.
 446   FAM.registerPass([&] { return TargetLibraryAnalysis(*TLII); });
 447
 448   // Register all the basic analyses with the managers.
 449   PB.registerModuleAnalyses(MAM);
 450   PB.registerCGSCCAnalyses(CGAM);
 451   PB.registerFunctionAnalyses(FAM);
 452   PB.registerLoopAnalyses(LAM);
 453   PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
 454
 455   ModulePassManager MPM;
 456   if (EnableDebugify)
 457     MPM.addPass(NewPMDebugifyPass());
 458   if (VerifyDIPreserve)
 459     MPM.addPass(NewPMDebugifyPass(DebugifyMode::OriginalDebugInfo, "",
 460                                   &DebugInfoBeforePass));
 461
 462   // Add passes according to the -passes options.
 463   if (!PassPipeline.empty()) {
 464     if (auto Err = PB.parsePassPipeline(MPM, PassPipeline)) {
 465       errs() << Arg0 << ": " << toString(std::move(Err)) << "\n";
 466       return false;
 467     }
 468   }
 469
 470   if (VK > VK_NoVerifier)
 471     MPM.addPass(VerifierPass());
 472   if (EnableDebugify)
 473     MPM.addPass(NewPMCheckDebugifyPass(false, "", &DIStatsMap));
 474   if (VerifyDIPreserve)
 475     MPM.addPass(NewPMCheckDebugifyPass(
 476         false, "", nullptr, DebugifyMode::OriginalDebugInfo,
 477         &DebugInfoBeforePass, VerifyDIPreserveExport));
 478
 479   // Add any relevant output pass at the end of the pipeline.
 480   switch (OK) {
 481   case OK_NoOutput:
 482     break; // No output pass needed.
 483   case OK_OutputAssembly:
 484     MPM.addPass(PrintModulePass(
 485         Out->os(), "", ShouldPreserveAssemblyUseListOrder, EmitSummaryIndex));
 486     break;
 487   case OK_OutputBitcode:
 488     MPM.addPass(BitcodeWriterPass(Out->os(), ShouldPreserveBitcodeUseListOrder,
 489                                   EmitSummaryIndex, EmitModuleHash));
 490     break;
 491   case OK_OutputThinLTOBitcode:
 492     MPM.addPass(ThinLTOBitcodeWriterPass(
 493         Out->os(), ThinLTOLinkOut ? &ThinLTOLinkOut->os() : nullptr));
 494     break;
 495   }
 496
 497   // Before executing passes, print the final values of the LLVM options.
 498   cl::PrintOptionValues();
 499
 500   // Print a textual, '-passes=' compatible, representation of pipeline if
 501   // requested.
 502   if (PrintPipelinePasses) {
 503     std::string Pipeline;
 504     raw_string_ostream SOS(Pipeline);
 505     MPM.printPipeline(SOS, [&PIC](StringRef ClassName) {
 506       auto PassName = PIC.getPassNameForClassName(ClassName);
 507       return PassName.empty() ? ClassName : PassName;
 508     });
 509     outs() << Pipeline;
 510     outs() << "\n";
 511
 512     if (!DisablePipelineVerification) {
 513       // Check that we can parse the returned pipeline string as an actual
 514       // pipeline.
 515       ModulePassManager TempPM;
 516       if (auto Err = PB.parsePassPipeline(TempPM, Pipeline)) {
 517         errs() << "Could not parse dumped pass pipeline: "
 518                << toString(std::move(Err)) << "\n";
 519         return false;
 520       }
 521     }
 522
 523     return true;
 524   }
 525
 526   // Now that we have all of the passes ready, run them.
 527   MPM.run(M, MAM);
 528
 529   // Declare success.
 530   if (OK != OK_NoOutput) {
 531     Out->keep();
 532     if (OK == OK_OutputThinLTOBitcode && ThinLTOLinkOut)
 533       ThinLTOLinkOut->keep();
 534   }
 535
 536   if (OptRemarkFile)
 537     OptRemarkFile->keep();
 538
 539   if (DebugifyEach && !DebugifyExport.empty())
 540     exportDebugifyStats(DebugifyExport, Debugify.getDebugifyStatsMap());
 541
 542   return true;
 543 }
 544
 545 void llvm::printPasses(raw_ostream &OS) {
 546   PassBuilder PB;
 547   PB.printPassNames(OS);
 548 }