[LTO] [Legacy] Add -debug-pass-manager option to enable pass run/skip trace.

[steven_wu]

LGTM.

[fhahn]

Could you add a test case?

[w2yehia]

Common up the -debug-pass-manager option between LTOCodeGenerator, llvm-lto (which uses LTOCodeGenerator), and llvm-lto2 (which does not use LTOCodeGenerator but uses libLLVMLTO).
Add testcase.

[tejohnson]

llvm/lib/LTO/LTOCodeGenerator.cpp

135

Needed in ThinLTOCodeGenerator.cpp too? Looks like it is passed down from llvm-lto to there but I assume you wanted to set this via the linker? Not a legacy LTO user though, @steven_wu may have more thoughts.

llvm/tools/llvm-lto2/llvm-lto2.cpp

172

It seems a little odd to have the new LTO tool rely on an option in the legacy LTO. Maybe the def should be moved to LTO.cpp which is the new LTO and which the legacy LTO is gradually starting to use?

[steven_wu]

I assume this is a debug option for LTO developer that is not going for production. That is why I said LGTM without a test case. I do think it will be good to set that in ThinLTOCodeGenerator as well, probably not needed for llvm-lto2.

[tejohnson]

In D110075#3010706, @steven_wu wrote:

I assume this is a debug option for LTO developer that is not going for production. That is why I said LGTM without a test case. I do think it will be good to set that in ThinLTOCodeGenerator as well, probably not needed for llvm-lto2.

The same option was already in llvm-lto2, but the more recent version of the patch removed the option from there and changed it to use the copy in LTOCodeGenerator.cpp, which I don't think is a good idea.

[w2yehia]

llvm/lib/LTO/LTOCodeGenerator.cpp

135

Yep, I intend to pass this option via the linker. Sorry for keep forgetting about thinLTO; we don't use it yet.

If we are to add processing of the DebugPassManager cl::opt to ThinLTOCodeGenerator then we'll have to remove it from llvm-lto, and remove the DebugPassManager parameter from a bunch of static functions in ThinLTOCodeGenerator.cpp.

@fhahn FYI, since you added that code.

llvm/tools/llvm-lto2/llvm-lto2.cpp

172

Moving the option's def to LTO.cpp makes sense.

[fhahn]

llvm/lib/LTO/LTOCodeGenerator.cpp

135

Thanks that should be fine.

[w2yehia]

@steven_wu @tejohnson ping. Thanks.

[w2yehia]

clang-format

[w2yehia]

the pre-merge build failures are noise (an NFC change has the same failures)

[w2yehia]

@steven_wu @tejohnson ping. Thanks.

[fhahn]

LGTM thanks!

[sbc100]

I bisected a breakage in our auto-roller to this change. I seems that in DLLVM_LINK_LLVM_DYLIB mode this break the opt command:

$ opt -internalize -internalize-public-api-list=main -globaldce test.o -o test2.o
: CommandLine Error: Option 'debug-pass-manager' registered more than once!
LLVM ERROR: inconsistency in registered CommandLine options

Our auto-roller that is failing is at https://autoroll.skia.org/r/llvm-project-emscripten-releases.

[sbc100]

In D110075#3030695, @sbc100 wrote:

I bisected a breakage in our auto-roller to this change. I seems that in DLLVM_LINK_LLVM_DYLIB mode this break the opt command:

$ opt -internalize -internalize-public-api-list=main -globaldce test.o -o test2.o
: CommandLine Error: Option 'debug-pass-manager' registered more than once!
LLVM ERROR: inconsistency in registered CommandLine options

Our auto-roller that is failing is at https://autoroll.skia.org/r/llvm-project-emscripten-releases.

This is currently blocking llvm changes from getting into new emscripten releases. Perhaps we can revert?

[w2yehia]

In D110075#3031328, @sbc100 wrote:

In D110075#3030695, @sbc100 wrote:

I bisected a breakage in our auto-roller to this change. I seems that in DLLVM_LINK_LLVM_DYLIB mode this break the opt command:

$ opt -internalize -internalize-public-api-list=main -globaldce test.o -o test2.o
: CommandLine Error: Option 'debug-pass-manager' registered more than once!
LLVM ERROR: inconsistency in registered CommandLine options

Our auto-roller that is failing is at https://autoroll.skia.org/r/llvm-project-emscripten-releases.

This is currently blocking llvm changes from getting into new emscripten releases. Perhaps we can revert?

reverted.

llvm/include/llvm/LTO/legacy/ThinLTOCodeGenerator.h

public:
   /// IR optimization level: from 0 to 3.
   void setOptLevel(unsigned NewOptLevel) {
     OptLevel = (NewOptLevel > 3) ? 3 : NewOptLevel;
   }
 
   /// Enable or disable the new pass manager.
   void setUseNewPM(unsigned Enabled) { UseNewPM = Enabled; }
 
-  /// Enable or disable debug output for the new pass manager.
-  void setDebugPassManager(unsigned Enabled) { DebugPassManager = Enabled; }
-
   /// Disable CodeGen, only run the stages till codegen and stop. The output
   /// will be bitcode.
   void disableCodeGen(bool Disable) { DisableCodeGen = Disable; }
 
   /// Perform CodeGen only: disable all other stages.
   void setCodeGenOnly(bool CGOnly) { CodeGenOnly = CGOnly; }
 
   /**@}*/
private:
   bool Freestanding = false;
 
   /// IR Optimization Level [0-3].
   unsigned OptLevel = 3;
 
   /// Flag to indicate whether the new pass manager should be used for IR
   /// optimizations.
   bool UseNewPM = LLVM_ENABLE_NEW_PASS_MANAGER;
-
-  /// Flag to indicate whether debug output should be enabled for the new pass
-  /// manager.
-  bool DebugPassManager = false;
 };
 }
 #endif

llvm/lib/LTO/LTO.cpp

static cl::opt<bool>
     DumpThinCGSCCs("dump-thin-cg-sccs", cl::init(false), cl::Hidden,
                    cl::desc("Dump the SCCs in the ThinLTO index's callgraph"));
 
 /// Enable global value internalization in LTO.
 cl::opt<bool> EnableLTOInternalization(
     "enable-lto-internalization", cl::init(true), cl::Hidden,
     cl::desc("Enable global value internalization in LTO"));
 
+namespace llvm {
+cl::opt<bool>
+    DebugPassManager("debug-pass-manager", cl::init(false), cl::Hidden,
+                     cl::desc("Print pass management debugging information"));
+}
+
 // Computes a unique hash for the Module considering the current list of
 // export/import and other global analysis results.
 // The hash is produced in \p Key.
 void llvm::computeLTOCacheKey(
     SmallString<40> &Key, const Config &Conf, const ModuleSummaryIndex &Index,
     StringRef ModuleID, const FunctionImporter::ImportMapTy &ImportList,
     const FunctionImporter::ExportSetTy &ExportList,
     const std::map<GlobalValue::GUID, GlobalValue::LinkageTypes> &ResolvedODR,

llvm/lib/LTO/LTOCodeGenerator.cpp

cl::opt<std::string> RemarksFormat(
     "lto-pass-remarks-format",
     cl::desc("The format used for serializing remarks (default: YAML)"),
     cl::value_desc("format"), cl::init("yaml"));
 
 cl::opt<std::string> LTOStatsFile(
     "lto-stats-file",
     cl::desc("Save statistics to the specified file"),
     cl::Hidden);
+
+extern cl::opt<bool> DebugPassManager;
 }
 
 LTOCodeGenerator::LTOCodeGenerator(LLVMContext &Context)
     : Context(Context), MergedModule(new Module("ld-temp.o", Context)),
       TheLinker(new Linker(*MergedModule)) {
   Context.setDiscardValueNames(LTODiscardValueNames);
   Context.enableDebugTypeODRUniquing();
 
   Config.CodeModel = None;
   Config.StatsFile = LTOStatsFile;
   Config.PreCodeGenPassesHook = [](legacy::PassManager &PM) {
     PM.add(createObjCARCContractPass());
   };
+  Config.DebugPassManager = DebugPassManager;
 }
 
 LTOCodeGenerator::~LTOCodeGenerator() {}
 
 void LTOCodeGenerator::setAsmUndefinedRefs(LTOModule *Mod) {
   const std::vector<StringRef> &undefs = Mod->getAsmUndefinedRefs();
   for (int i = 0, e = undefs.size(); i != e; ++i)
     AsmUndefinedRefs.insert(undefs[i]);

llvm/lib/LTO/ThinLTOCodeGenerator.cpp

 // Flags -discard-value-names, defined in LTOCodeGenerator.cpp
 extern cl::opt<bool> LTODiscardValueNames;
 extern cl::opt<std::string> RemarksFilename;
 extern cl::opt<std::string> RemarksPasses;
 extern cl::opt<bool> RemarksWithHotness;
 extern cl::opt<Optional<uint64_t>, false, remarks::HotnessThresholdParser>
     RemarksHotnessThreshold;
 extern cl::opt<std::string> RemarksFormat;
+extern cl::opt<bool> DebugPassManager;
 }
 
 namespace {
 
 // Default to using all available threads in the system, but using only one
 // thred per core, as indicated by the usage of
 // heavyweight_hardware_concurrency() below.
 static cl::opt<int> ThreadCount("threads", cl::init(0));
static void optimizeModule(Module &TheModule, TargetMachine &TM,
   // Add optimizations
   PMB.populateThinLTOPassManager(PM);
 
   PM.run(TheModule);
 }
 
 static void optimizeModuleNewPM(Module &TheModule, TargetMachine &TM,
                                 unsigned OptLevel, bool Freestanding,
-                                bool DebugPassManager,
                                 ModuleSummaryIndex *Index) {
   Optional<PGOOptions> PGOOpt;
   LoopAnalysisManager LAM;
   FunctionAnalysisManager FAM;
   CGSCCAnalysisManager CGAM;
   ModuleAnalysisManager MAM;
 
   PassInstrumentationCallbacks PIC;
ProcessThinLTOModule(Module &TheModule, ModuleSummaryIndex &Index,
                      StringMap<lto::InputFile *> &ModuleMap, TargetMachine &TM,
                      const FunctionImporter::ImportMapTy &ImportList,
                      const FunctionImporter::ExportSetTy &ExportList,
                      const DenseSet<GlobalValue::GUID> &GUIDPreservedSymbols,
                      const GVSummaryMapTy &DefinedGlobals,
                      const ThinLTOCodeGenerator::CachingOptions &CacheOptions,
                      bool DisableCodeGen, StringRef SaveTempsDir,
                      bool Freestanding, unsigned OptLevel, unsigned count,
-                     bool UseNewPM, bool DebugPassManager) {
+                     bool UseNewPM) {
 
   // "Benchmark"-like optimization: single-source case
   bool SingleModule = (ModuleMap.size() == 1);
 
   // When linking an ELF shared object, dso_local should be dropped. We
   // conservatively do this for -fpic.
   bool ClearDSOLocalOnDeclarations =
       TM.getTargetTriple().isOSBinFormatELF() &&
if (!SingleModule) {
     crossImportIntoModule(TheModule, Index, ModuleMap, ImportList,
                           ClearDSOLocalOnDeclarations);
 
     // Save temps: after cross-module import.
     saveTempBitcode(TheModule, SaveTempsDir, count, ".3.imported.bc");
   }
 
   if (UseNewPM)
-    optimizeModuleNewPM(TheModule, TM, OptLevel, Freestanding, DebugPassManager,
-                        &Index);
+    optimizeModuleNewPM(TheModule, TM, OptLevel, Freestanding, &Index);
   else
     optimizeModule(TheModule, TM, OptLevel, Freestanding, &Index);
 
   saveTempBitcode(TheModule, SaveTempsDir, count, ".4.opt.bc");
 
   if (DisableCodeGen) {
     // Configured to stop before CodeGen, serialize the bitcode and return.
     SmallVector<char, 128> OutputBuffer;
for (auto IndexCount : ModulesOrdering) {
 
         auto &ImportList = ImportLists[ModuleIdentifier];
         // Run the main process now, and generates a binary
         auto OutputBuffer = ProcessThinLTOModule(
             *TheModule, *Index, ModuleMap, *TMBuilder.create(), ImportList,
             ExportList, GUIDPreservedSymbols,
             ModuleToDefinedGVSummaries[ModuleIdentifier], CacheOptions,
             DisableCodeGen, SaveTempsDir, Freestanding, OptLevel, count,
-            UseNewPM, DebugPassManager);
+            UseNewPM);
 
         // Commit to the cache (if enabled)
         CacheEntry.write(*OutputBuffer);
 
         if (SavedObjectsDirectoryPath.empty()) {
           // We need to generated a memory buffer for the linker.
           if (!CacheEntryPath.empty()) {
             // When cache is enabled, reload from the cache if possible.

llvm/test/tools/llvm-lto/lto-passes.ll

+; Test that -debug-pass-manager works in LTOCodeGenerator. The actual list of
+; passes that is run during LTO is tested in:
+;    llvm/test/Other/new-pm-lto-defaults.ll
+;
+; RUN: llvm-as < %s > %t.bc
+; RUN: llvm-lto %t.bc -O0 --debug-pass-manager 2>&1 | FileCheck %s
+; CHECK: Running pass: WholeProgramDevirtPass
+
+define i32 @main() {
+entry:
+  ret i32 42
+}

llvm/tools/llvm-lto/llvm-lto.cpp

static cl::opt<bool> PrintMachOCPUOnly(
     "print-macho-cpu-only", cl::init(false),
     cl::desc("Instead of running LTO, print the mach-o cpu in each IR file"),
     cl::cat(LTOCategory));
 
 static cl::opt<bool> UseNewPM(
     "use-new-pm", cl::desc("Run LTO passes using the new pass manager"),
     cl::init(LLVM_ENABLE_NEW_PASS_MANAGER), cl::Hidden, cl::cat(LTOCategory));
 
-static cl::opt<bool>
-    DebugPassManager("debug-pass-manager", cl::init(false), cl::Hidden,
-                     cl::desc("Print pass management debugging information"),
-                     cl::cat(LTOCategory));
-
 namespace {
 
 struct ModuleInfo {
   std::vector<bool> CanBeHidden;
 };
 
 } // end anonymous namespace
 
ThinLTOProcessing(const TargetOptions &Options) {
     ThinGenerator.setTargetOptions(Options);
     ThinGenerator.setCacheDir(ThinLTOCacheDir);
     ThinGenerator.setCachePruningInterval(ThinLTOCachePruningInterval);
     ThinGenerator.setCacheEntryExpiration(ThinLTOCacheEntryExpiration);
     ThinGenerator.setCacheMaxSizeFiles(ThinLTOCacheMaxSizeFiles);
     ThinGenerator.setCacheMaxSizeBytes(ThinLTOCacheMaxSizeBytes);
     ThinGenerator.setFreestanding(EnableFreestanding);
     ThinGenerator.setUseNewPM(UseNewPM);
-    ThinGenerator.setDebugPassManager(DebugPassManager);
 
     // Add all the exported symbols to the table of symbols to preserve.
     for (unsigned i = 0; i < ExportedSymbols.size(); ++i)
       ThinGenerator.preserveSymbol(ExportedSymbols[i]);
   }
 
   void run() {
     switch (ThinLTOMode) {

llvm/tools/llvm-lto2/llvm-lto2.cpp

RunCSIRInstr("lto-cspgo-gen",
                  cl::desc("Run PGO context sensitive IR instrumentation"),
                  cl::init(false), cl::Hidden);
 
 static cl::opt<bool>
     UseNewPM("use-new-pm",
              cl::desc("Run LTO passes using the new pass manager"),
              cl::init(LLVM_ENABLE_NEW_PASS_MANAGER), cl::Hidden);
 
-static cl::opt<bool>
-    DebugPassManager("debug-pass-manager", cl::init(false), cl::Hidden,
-                     cl::desc("Print pass management debugging information"));
-
 static cl::opt<std::string>
     StatsFile("stats-file", cl::desc("Filename to write statistics to"));
 
 static cl::list<std::string>
     PassPlugins("load-pass-plugin",
                 cl::desc("Load passes from plugin library"));
 
 static cl::opt<bool> EnableFreestanding(
     "lto-freestanding",
     cl::desc("Enable Freestanding (disable builtins / TLI) during LTO"),
     cl::init(false), cl::Hidden);
 
 static void check(Error E, std::string Msg) {
   if (!E)
     return;
   handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
     errs() << "llvm-lto2: " << Msg << ": " << EIB.message().c_str() << '\n';
   });
   exit(1);
 }
 
+namespace llvm {
+extern cl::opt<bool> DebugPassManager;
+}
+
 template <typename T> static T check(Expected<T> E, std::string Msg) {
   if (E)
     return std::move(*E);
   check(E.takeError(), Msg);
   return T();
 }
 
 static void check(std::error_code EC, std::string Msg) {