[NewPM] Add an option to dump pass structure

[evgeny777]

Summary

This is similar to legacy PM -debug-pass=Structure. It overlaps with -debug-pass-manager, however the latter dumps a lot of stuff which is not related to pass structure (and probably should be printed with LLVM_DEBUG).

[evgeny777]

Fix windows buildbot failure

[tejohnson]

llvm/lib/Passes/StandardInstrumentations.cpp

56

I noticed that in clang there is an -fdebug-pass-structure that eventually gets translated to the old PM's -debug-pass=Structure. Perhaps that should specify this internal option in the case of the new PM?

907

Can you instead use something like:
dbgs().indent(Ident) << Msg;

[evgeny777]

Addressed comments

[tejohnson]

clang/lib/CodeGen/BackendUtil.cpp

872

Looks like there is no existing test for -fdebug-pass-manager, even for the legacy PM. Could you add one? It looks like the way to test this would be via "-mllvm -debug-only=commandline" which currently emits:

Args: clang -debug-pass Structure

llvm/include/llvm/IR/PassManagerImpl.h

77

What is this check needed for?

[evgeny777]

llvm/include/llvm/IR/PassManagerImpl.h

77

For runBeforeAnalysis and runAfterAnalysis to be in sync. See if block above:

if (ID != PassInstrumentationAnalysis::ID()) {
      PI = getResult<PassInstrumentationAnalysis>(IR, ExtraArgs...);
      PI.runBeforeAnalysis(P, IR);
}

[evgeny777]

Added clang test

[tejohnson]

llvm/include/llvm/IR/PassManagerImpl.h

77

Sure I saw that above. But I guess my question is what is the practical effect of this change, i.e. why is it needed with your other changes in this patch when it wasn't needed before?

[evgeny777]

llvm/include/llvm/IR/PassManagerImpl.h

77

I felt this is right change, however I see no effect from it, so let's undo it for now

[evgeny777]

Addressed comments

[tejohnson]

lgtm

[haowei]

We are seeing test failures in our builders with message after your patch. Could you take a look and fix this unit test please?

FAIL: Clang :: Driver/debug-pass-structure.c (6773 of 27894)
******************** TEST 'Clang :: Driver/debug-pass-structure.c' FAILED ********************
Script:
--
: 'RUN: at line 2';   /opt/s/w/ir/x/w/staging/llvm_build/bin/clang -fexperimental-new-pass-manager -fdebug-pass-structure -O3 -S -emit-llvm /opt/s/w/ir/x/w/llvm-project/clang/test/Driver/debug-pass-structure.c -o /dev/null 2>&1 | /opt/s/w/ir/x/w/staging/llvm_build/bin/FileCheck /opt/s/w/ir/x/w/llvm-project/clang/test/Driver/debug-pass-structure.c --check-prefix=NEWPM
: 'RUN: at line 3';   /opt/s/w/ir/x/w/staging/llvm_build/bin/clang -flegacy-pass-manager -fdebug-pass-structure -O0 -S -emit-llvm /opt/s/w/ir/x/w/llvm-project/clang/test/Driver/debug-pass-structure.c -o /dev/null 2>&1 | /opt/s/w/ir/x/w/staging/llvm_build/bin/FileCheck /opt/s/w/ir/x/w/llvm-project/clang/test/Driver/debug-pass-structure.c --check-prefix=LEGACYPM
--
Exit Code: 1

Command Output (stderr):
--
/opt/s/w/ir/x/w/llvm-project/clang/test/Driver/debug-pass-structure.c:46:19: error: LEGACYPM-NEXT: expected string not found in input
// LEGACYPM-NEXT: Pass Arguments: -tti -targetlibinfo -assumption-cache-tracker -profile-summary-info -annotation2metadata -forceattrs -basiccg -always-inline -annotation-remarks
                  ^
<stdin>:5:17: note: scanning from here
 Module Verifier
                ^
<stdin>:6:1: note: possible intended match here
Pass Arguments: -tti -targetlibinfo -assumption-cache-tracker -profile-summary-info -annotation2metadata -forceattrs -basiccg -always-inline -barrier -annotation-remarks
^

Input file: <stdin>
Check file: /opt/s/w/ir/x/w/llvm-project/clang/test/Driver/debug-pass-structure.c

-dump-input=help explains the following input dump.

Input was:
<<<<<<
           1: Pass Arguments: -tti -targetlibinfo -verify 
           2: Target Transform Information 
           3: Target Library Information 
           4:  FunctionPass Manager 
           5:  Module Verifier 
next:46'0                     X error: no match found
           6: Pass Arguments: -tti -targetlibinfo -assumption-cache-tracker -profile-summary-info -annotation2metadata -forceattrs -basiccg -always-inline -barrier -annotation-remarks 
next:46'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
next:46'1     ?                                                                                                                                                                          possible intended match
           7: Target Transform Information 
next:46'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
           8: Target Library Information 
next:46'0     ~~~~~~~~~~~~~~~~~~~~~~~~~~~
           9: Assumption Cache Tracker 
next:46'0     ~~~~~~~~~~~~~~~~~~~~~~~~~
          10: Profile summary info 
next:46'0     ~~~~~~~~~~~~~~~~~~~~~
          11:  ModulePass Manager 
next:46'0     ~~~~~~~~~~~~~~~~~~~~
           .
           .
           .
>>>>>>

[evgeny777]

@haowei What are LLVM configuration options? Also please send output from

/opt/s/w/ir/x/w/staging/llvm_build/bin/clang -flegacy-pass-manager -fdebug-pass-structure -O0 -S -emit-llvm /opt/s/w/ir/x/w/llvm-project/clang/test/Driver/debug-pass-structure.c -o /dev/null 2>&1

[evgeny777]

Hm ... I see BarrierNoop pass being added before annotation-remarks. Why's that?

[haowei]

In D99599#2726252, @evgeny777 wrote:

@haowei What are LLVM configuration options? Also please send output from

/opt/s/w/ir/x/w/staging/llvm_build/bin/clang -flegacy-pass-manager -fdebug-pass-structure -O0 -S -emit-llvm /opt/s/w/ir/x/w/llvm-project/clang/test/Driver/debug-pass-structure.c -o /dev/null 2>&1

Full cmake command line is:

'/local_path/local_path/bin/cmake',
  '-GNinja',
  '-DCMAKE_MAKE_PROGRAM=/local_path/local_path/ninja',
  '-DCMAKE_INSTALL_PREFIX=',
  '-DCMAKE_C_COMPILER=/local_path/local_path/bin/clang',
  '-DCMAKE_CXX_COMPILER=/local_path/local_path/bin/clang++',
  '-DCMAKE_ASM_COMPILER=/local_path/local_path/bin/clang',
  '-DCMAKE_AR=/local_path/local_path/bin/llvm-ar',
  '-DCMAKE_LINKER=/local_path/local_path/bin/ld.lld',
  '-DCMAKE_NM=/local_path/local_path/bin/llvm-nm',
  '-DCMAKE_OBJCOPY=/local_path/local_path/bin/llvm-objcopy',
  '-DCMAKE_OBJDUMP=/local_path/local_path/bin/llvm-objdump',
  '-DCMAKE_RANLIB=/local_path/local_path/bin/llvm-ranlib',
  '-DCMAKE_READELF=/local_path/local_path/bin/llvm-readelf',
  '-DCMAKE_STRIP=/local_path/local_path/bin/llvm-strip',
  '-DCMAKE_SYSROOT=/local_path/local_path/linux',
  '-DZLIB_INCLUDE_DIR=/local_path/staging/zlib_install/include',
  '-DZLIB_LIBRARY=/local_path/staging/zlib_install/lib/libz.a',
  '-DLIBXML2_INCLUDE_DIR=/local_path/staging/libxml2_install/include/libxml2',
  '-DLIBXML2_LIBRARY=/local_path/staging/libxml2_install/lib/libxml2.a',
  '-DCMAKE_SHARED_LINKER_FLAGS=-static-libstdc++',
  '-DCMAKE_MODULE_LINKER_FLAGS=-static-libstdc++',
  '-DCMAKE_EXE_LINKER_FLAGS=-static-libstdc++',
  '-DLLVM_ENABLE_LTO=False',
  '-DLLVM_ENABLE_ASSERTIONS=True',
  '-DLINUX_aarch64-unknown-linux-gnu_SYSROOT=/local_path/local_path/linux',
  '-DLINUX_armv7-unknown-linux-gnueabihf_SYSROOT=/local_path/local_path/linux',
  '-DLINUX_i386-unknown-linux-gnu_SYSROOT=/local_path/local_path/linux',
  '-DLINUX_x86_64-unknown-linux-gnu_SYSROOT=/local_path/local_path/linux',
  '-DFUCHSIA_SDK=/local_path/local_path/sdk',
  '-C',
  '/local_path/llvm-project/clang/cmake/caches/Fuchsia-stage2.cmake',
  '/local_path/llvm-project/llvm',

I am currently doing a local build to see if I can generate the output you required. We suspect it may be related to ENABLE_EXPERIMENTAL_NEW_PASS_MANAGER which is enabled in clang/cmake/caches/Fuchsia-stage2.cmake we used.

[haowei]

Output from clang -flegacy-pass-manager -fdebug-pass-structure -O0 -S -emit-llvm /opt/s/w/ir/x/w/llvm-project/clang/test/Driver/debug-pass-structure.c -o /dev/null 2>&1:

Pass Arguments:  -tti -targetlibinfo
Target Transform Information
Target Library Information
  FunctionPass Manager
Pass Arguments:  -tti -targetlibinfo -assumption-cache-tracker -profile-summary-info -annotation2metadata -forceattrs -basiccg -always-inline -barrier -annotation-remarks
Target Transform Information
Target Library Information
Assumption Cache Tracker
Profile summary info
  ModulePass Manager
    Annotation2Metadata
    Force set function attributes
    CallGraph Construction
    Call Graph SCC Pass Manager
      Inliner for always_inline functions
    A No-Op Barrier Pass
    FunctionPass Manager
      Annotation Remarks
    Print Module IR
Pass Arguments:  -tti
Target Transform Information
  ModulePass Manager

[phosek]

It looks like the BarrierNoop pass is inserted under -O0 when any extension is registered. We enable Polly in our toolchain so that's likely the reason why we're seeing this on our bots.

[evgeny777]

Should be fixed with c81ec19fba27ec

[phosek]

In D99599#2728092, @evgeny777 wrote:

Should be fixed with c81ec19fba27ec

Thank you, our builders went green after that change.

[aeubanks]

As you said in the description, this overlaps a lot with -debug-pass-manager. What exactly is too verbose with the existing debug logging? I'd strongly prefer to have this consolidated into one pass instrumentation rather than two.

Having a new pipeline test is very tedious when changing the pipeline. We already have a bunch.

llvm/lib/Passes/StandardInstrumentations.cpp

23

is this needed?

55

The new PM design tries to avoid global options. We should implement the above FIXME and fold this into PrintPassInstrumentation.

[aeubanks]

I've already run into having to update these two golden file tests twice, we really shouldn't be having multiple types of golden file tests for the same thing in different locations and with different formats. I'd like to revert this change.

Perhaps something like https://reviews.llvm.org/D101797 and maybe some more followups are better.

[evgeny777]

I've already run into having to update these two golden file tests twice

I think you can just reduce the tests. No need to revert the entire change, unless there is a replacement for it (D101797 is not)

[aeubanks]

In D99599#2735582, @evgeny777 wrote:

I've already run into having to update these two golden file tests twice

I think you can just reduce the tests. No need to revert the entire change, unless there is a replacement for it (D101797 is not)

Could you explain why -debug-pass-manager doesn't fit your use case?

[evgeny777]

Could you explain why -debug-pass-manager doesn't fit your use case?

I wanted to have something similar to -debug-pass=Structure, because the above is too verbose and lacks identation. What's the problem with this one, anyway?

clang/lib/CodeGen/BackendUtil.cpp

 }
 
 static void setCommandLineOpts(const CodeGenOptions &CodeGenOpts) {
   SmallVector<const char *, 16> BackendArgs;
   BackendArgs.push_back("clang"); // Fake program name.
   if (!CodeGenOpts.DebugPass.empty()) {
     BackendArgs.push_back("-debug-pass");
     BackendArgs.push_back(CodeGenOpts.DebugPass.c_str());
+    // New PM supports structure dumping. Old PM is still used for codegen,
+    // so we need to pass both options.
+    if (!CodeGenOpts.LegacyPassManager && CodeGenOpts.DebugPass == "Structure")
+      BackendArgs.push_back("-debug-pass-structure");
   }
   if (!CodeGenOpts.LimitFloatPrecision.empty()) {
     BackendArgs.push_back("-limit-float-precision");
     BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
   }
   // Check for the default "clang" invocation that won't set any cl::opt values.
   // Skip trying to parse the command line invocation to avoid the issues
   // described below.

llvm/include/llvm/IR/PassManagerImpl.h

if (Inserted) {
     if (ID != PassInstrumentationAnalysis::ID()) {
       PI = getResult<PassInstrumentationAnalysis>(IR, ExtraArgs...);
       PI.runBeforeAnalysis(P, IR);
     }
 
     AnalysisResultListT &ResultList = AnalysisResultLists[&IR];
     ResultList.emplace_back(ID, P.run(IR, *this, ExtraArgs...));
 
+    if (ID != PassInstrumentationAnalysis::ID())
       PI.runAfterAnalysis(P, IR);
 
     // P.run may have inserted elements into AnalysisResults and invalidated
     // RI.
     RI = AnalysisResults.find({ID, &IR});
     assert(RI != AnalysisResults.end() && "we just inserted it!");
 
     RI->second = std::prev(ResultList.end());
   }

llvm/include/llvm/Passes/StandardInstrumentations.h

 class OptBisectInstrumentation {
 public:
   OptBisectInstrumentation() {}
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 };
 
 // Debug logging for transformation and analysis passes.
 class PrintPassInstrumentation {
+  void printWithIdent(bool Expand, const Twine &Msg);
+
 public:
   PrintPassInstrumentation(bool DebugLogging) : DebugLogging(DebugLogging) {}
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 
 private:
   bool DebugLogging;
+  int Ident = 0;
+};
+
+// Pass structure dumper
+class PassStructurePrinter {
+  int Ident = 0;
+  void printWithIdent(bool Expand, const Twine &Msg);
+
+public:
+  PassStructurePrinter() {}
+  void registerCallbacks(PassInstrumentationCallbacks &PIC);
 };
 
 class PreservedCFGCheckerInstrumentation {
 public:
   // Keeps sticky poisoned flag for the given basic block once it has been
   // deleted or RAUWed.
   struct BBGuard final : public CallbackVH {
     BBGuard(const BasicBlock *BB) : CallbackVH(BB) {}
public:
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 };
 
 /// This class provides an interface to register all the standard pass
 /// instrumentations and manages their state (if any).
 class StandardInstrumentations {
   PrintIRInstrumentation PrintIR;
   PrintPassInstrumentation PrintPass;
+  PassStructurePrinter StructurePrinter;
   TimePassesHandler TimePasses;
   OptNoneInstrumentation OptNone;
   OptBisectInstrumentation OptBisect;
   PreservedCFGCheckerInstrumentation PreservedCFGChecker;
   IRChangedPrinter PrintChangedIR;
   PseudoProbeVerifier PseudoProbeVerification;
   InLineChangePrinter PrintChangedDiff;
   VerifyInstrumentation Verify;

llvm/lib/Passes/StandardInstrumentations.cpp

 #include "llvm/Passes/StandardInstrumentations.h"
 #include "llvm/ADT/Any.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Analysis/CallGraphSCCPass.h"
 #include "llvm/Analysis/LazyCallGraph.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/IR/Function.h"
+#include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassInstrumentation.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/PrintPasses.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FormatVariadic.h"

 
 // FIXME: Change `-debug-pass-manager` from boolean to enum type. Similar to
 // `-debug-pass` in legacy PM.
 static cl::opt<bool>
     DebugPMVerbose("debug-pass-manager-verbose", cl::Hidden, cl::init(false),
                    cl::desc("Print all pass management debugging information. "
                             "`-debug-pass-manager` must also be specified"));
 
+static cl::opt<bool>
+    DebugPassStructure("debug-pass-structure", cl::Hidden, cl::init(false),
+                       cl::desc("Print pass structure information."));
+
 // An option that prints out the IR after passes, similar to
 // -print-after-all except that it only prints the IR after passes that
 // change the IR.  Those passes that do not make changes to the IR are
 // reported as not making any changes.  In addition, the initial IR is
 // also reported.  Other hidden options affect the output from this
 // option.  -filter-passes will limit the output to the named passes
 // that actually change the IR and other passes are reported as filtered out.
 // The specified passes will either be reported as making no changes (with
PIC.registerBeforeNonSkippedPassCallback(
         dbgs() << "Running pass: " << PassID << " on " << getIRName(IR) << "\n";
       });
 
   PIC.registerBeforeAnalysisCallback([](StringRef PassID, Any IR) {
     dbgs() << "Running analysis: " << PassID << " on " << getIRName(IR) << "\n";
   });
 }
 
+void PassStructurePrinter::printWithIdent(bool Expand, const Twine &Msg) {
+  if (!Msg.isTriviallyEmpty())
+    dbgs().indent(Ident) << Msg << "\n";
+  Ident = Expand ? Ident + 2 : Ident - 2;
+  assert(Ident >= 0);
+}
+
+void PassStructurePrinter::registerCallbacks(
+    PassInstrumentationCallbacks &PIC) {
+  if (!DebugPassStructure)
+    return;
+
+  PIC.registerBeforeNonSkippedPassCallback([this](StringRef PassID, Any IR) {
+    printWithIdent(true, PassID + " on " + getIRName(IR));
+  });
+  PIC.registerAfterPassCallback(
+      [this](StringRef PassID, Any IR, const PreservedAnalyses &) {
+        printWithIdent(false, Twine());
+      });
+
+  PIC.registerAfterPassInvalidatedCallback(
+      [this](StringRef PassID, const PreservedAnalyses &) {
+        printWithIdent(false, Twine());
+      });
+
+  PIC.registerBeforeAnalysisCallback([this](StringRef PassID, Any IR) {
+    printWithIdent(true, PassID + " analysis on " + getIRName(IR));
+  });
+  PIC.registerAfterAnalysisCallback(
+      [this](StringRef PassID, Any IR) { printWithIdent(false, Twine()); });
+}
+
 PreservedCFGCheckerInstrumentation::CFG::CFG(const Function *F,
                                              bool TrackBBLifetime) {
   if (TrackBBLifetime)
     BBGuards = DenseMap<intptr_t, BBGuard>(F->size());
   for (const auto &BB : *F) {
     if (BBGuards)
       BBGuards->try_emplace(intptr_t(&BB), &BB);
     for (auto *Succ : successors(&BB)) {
: PrintPass(DebugLogging), OptNone(DebugLogging),
           PrintChanged == ChangePrinter::PrintChangedColourDiffVerbose ||
               PrintChanged == ChangePrinter::PrintChangedColourDiffQuiet),
       Verify(DebugLogging), VerifyEach(VerifyEach) {}
 
 void StandardInstrumentations::registerCallbacks(
     PassInstrumentationCallbacks &PIC, FunctionAnalysisManager *FAM) {
   PrintIR.registerCallbacks(PIC);
   PrintPass.registerCallbacks(PIC);
+  StructurePrinter.registerCallbacks(PIC);
   TimePasses.registerCallbacks(PIC);
   OptNone.registerCallbacks(PIC);
   OptBisect.registerCallbacks(PIC);
   if (FAM)
     PreservedCFGChecker.registerCallbacks(PIC, *FAM);
   PrintChangedIR.registerCallbacks(PIC);
   PseudoProbeVerification.registerCallbacks(PIC);
   if (VerifyEach)

llvm/test/Other/opt-O3-pipeline.ll

 ; RUN: opt -enable-new-pm=0 -mtriple=x86_64-- -O3 -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck --check-prefixes=CHECK,%llvmcheckext %s
+; RUN: opt -enable-new-pm=1 -mtriple=x86_64-- -O3 -debug-pass-structure < %s -o /dev/null 2>&1 | FileCheck --check-prefixes=NEWPM,%llvmcheckext %s
 
 ; REQUIRES: asserts
 
 ; CHECK-LABEL: Pass Arguments:
 ; CHECK-NEXT: Target Transform Information
 ; CHECK-NEXT: Type-Based Alias Analysis
 ; CHECK-NEXT: Scoped NoAlias Alias Analysis
 ; CHECK-NEXT: Assumption Cache Tracker

 ; CHECK-NEXT: Target Library Information
 ; CHECK-NEXT:   FunctionPass Manager
 ; CHECK-NEXT:     Dominator Tree Construction
 ; CHECK-NEXT:     Natural Loop Information
 ; CHECK-NEXT:     Post-Dominator Tree Construction
 ; CHECK-NEXT:     Branch Probability Analysis
 ; CHECK-NEXT:     Block Frequency Analysis
 
+; NEWPM:      VerifierPass on [module]
+; NEWPM-NEXT:   VerifierAnalysis analysis on [module]
+; NEWPM-NEXT: Annotation2MetadataPass on [module]
+; NEWPM-NEXT: ForceFunctionAttrsPass on [module]
+; NEWPM-NEXT: InferFunctionAttrsPass on [module]
+; NEWPM-NEXT:   InnerAnalysisManagerProxy<{{.*}}> analysis on [module]
+; NEWPM-NEXT: ModuleToFunctionPassAdaptor on [module]
+; NEWPM-NEXT:   PassManager<{{.*}}> on f
+; NEWPM-NEXT:     PreservedCFGCheckerAnalysis analysis on f
+; NEWPM-NEXT:     LowerExpectIntrinsicPass on f
+; NEWPM-NEXT:     SimplifyCFGPass on f
+; NEWPM-NEXT:       TargetIRAnalysis analysis on f
+; NEWPM-NEXT:       AssumptionAnalysis analysis on f
+; NEWPM-NEXT:     SROA on f
+; NEWPM-NEXT:       DominatorTreeAnalysis analysis on f
+; NEWPM-NEXT:     EarlyCSEPass on f
+; NEWPM-NEXT:       TargetLibraryAnalysis analysis on f
+; NEWPM-NEXT:     CallSiteSplittingPass on f
+; NEWPM-NEXT: OpenMPOptPass on [module]
+; NEWPM-NEXT: IPSCCPPass on [module]
+; NEWPM-NEXT: CalledValuePropagationPass on [module]
+; NEWPM-NEXT: GlobalOptPass on [module]
+; NEWPM-NEXT: ModuleToFunctionPassAdaptor on [module]
+; NEWPM-NEXT:   InnerAnalysisManagerProxy<{{.*}}> analysis on [module]
+; NEWPM-NEXT:   PromotePass on f
+; NEWPM-NEXT:     PreservedCFGCheckerAnalysis analysis on f
+; NEWPM-NEXT:     DominatorTreeAnalysis analysis on f
+; NEWPM-NEXT:     AssumptionAnalysis analysis on f
+; NEWPM-NEXT: DeadArgumentEliminationPass on [module]
+; NEWPM-NEXT: ModuleToFunctionPassAdaptor on [module]
+; NEWPM-NEXT:   PassManager<{{.*}}> on f
+; NEWPM-NEXT:     InstCombinePass on f
+; NEWPM-NEXT:       TargetLibraryAnalysis analysis on f
+; NEWPM-NEXT:       OptimizationRemarkEmitterAnalysis analysis on f
+; NEWPM-NEXT:       TargetIRAnalysis analysis on f
+; NEWPM-NEXT:       AAManager analysis on f
+; NEWPM-NEXT:         BasicAA analysis on f
+; NEWPM-NEXT:       OuterAnalysisManagerProxy<{{.*}}> analysis on f
+; NEWPM-NEXT:     SimplifyCFGPass on f
+; NEWPM-NEXT: ModuleInlinerWrapperPass on [module]
+; NEWPM-NEXT:   InlineAdvisorAnalysis analysis on [module]
+; NEWPM-NEXT:   RequireAnalysisPass<{{.*}}> on [module]
+; NEWPM-NEXT:     GlobalsAA analysis on [module]
+; NEWPM-NEXT:       CallGraphAnalysis analysis on [module]
+; NEWPM-NEXT:   RequireAnalysisPass<{{.*}}> on [module]
+; NEWPM-NEXT:     ProfileSummaryAnalysis analysis on [module]
+; NEWPM-NEXT:   ModuleToPostOrderCGSCCPassAdaptor on [module]
+; NEWPM-NEXT:     InnerAnalysisManagerProxy<{{.*}}> analysis on [module]
+; NEWPM-NEXT:       LazyCallGraphAnalysis analysis on [module]
+; NEWPM-NEXT:     FunctionAnalysisManagerCGSCCProxy analysis on (f)
+; NEWPM-NEXT:       OuterAnalysisManagerProxy<{{.*}}> analysis on (f)
+; NEWPM-NEXT:     DevirtSCCRepeatedPass on (f)
+; NEWPM-NEXT:       PassManager<{{.*}}> on (f)
+; NEWPM-NEXT:         InlinerPass on (f)
+; NEWPM-NEXT:         InlinerPass on (f)
+; NEWPM-NEXT:         PostOrderFunctionAttrsPass on (f)
+; NEWPM-NEXT:         ArgumentPromotionPass on (f)
+; NEWPM-NEXT:         OpenMPOptCGSCCPass on (f)
+; NEWPM-NEXT:         CGSCCToFunctionPassAdaptor on (f)
+; NEWPM-NEXT:           PassManager<{{.*}}> on f
+; NEWPM-NEXT:             PreservedCFGCheckerAnalysis analysis on f
+; NEWPM-NEXT:             SROA on f
+; NEWPM-NEXT:               DominatorTreeAnalysis analysis on f
+; NEWPM-NEXT:             EarlyCSEPass on f
+; NEWPM-NEXT:               MemorySSAAnalysis analysis on f
+; NEWPM-NEXT:                 AAManager analysis on f
+; NEWPM-NEXT:                   BasicAA analysis on f
+; NEWPM-NEXT:             SpeculativeExecutionPass on f
+; NEWPM-NEXT:             JumpThreadingPass on f
+; NEWPM-NEXT:               LazyValueAnalysis analysis on f
+; NEWPM-NEXT:             CorrelatedValuePropagationPass on f
+; NEWPM-NEXT:             SimplifyCFGPass on f
+; NEWPM-NEXT:             AggressiveInstCombinePass on f
+; NEWPM-NEXT:             InstCombinePass on f
+; NEWPM-NEXT:             LibCallsShrinkWrapPass on f
+; NEWPM-NEXT:             TailCallElimPass on f
+; NEWPM-NEXT:             SimplifyCFGPass on f
+; NEWPM-NEXT:             ReassociatePass on f
+; NEWPM-NEXT:             RequireAnalysisPass<{{.*}}> on f
+; NEWPM-NEXT:             FunctionToLoopPassAdaptor on f
+; NEWPM-NEXT:               PassManager<{{.*}}> on f
+; NEWPM-NEXT:                 LoopSimplifyPass on f
+; NEWPM-NEXT:                   LoopAnalysis analysis on f
+; NEWPM-NEXT:                 LCSSAPass on f
+; NEWPM-NEXT:             SimplifyCFGPass on f
+; NEWPM-NEXT:             InstCombinePass on f
+; NEWPM-NEXT:             FunctionToLoopPassAdaptor on f
+; NEWPM-NEXT:               PassManager<{{.*}}> on f
+; NEWPM-NEXT:                 LoopSimplifyPass on f
+; NEWPM-NEXT:                 LCSSAPass on f
+; NEWPM-NEXT:             SROA on f
+; NEWPM-NEXT:             MergedLoadStoreMotionPass on f
+; NEWPM-NEXT:             GVN on f
+; NEWPM-NEXT:               MemoryDependenceAnalysis analysis on f
+; NEWPM-NEXT:                 PhiValuesAnalysis analysis on f
+; NEWPM-NEXT:             SCCPPass on f
+; NEWPM-NEXT:             BDCEPass on f
+; NEWPM-NEXT:               DemandedBitsAnalysis analysis on f
+; NEWPM-NEXT:             InstCombinePass on f
+; NEWPM-NEXT:             JumpThreadingPass on f
+; NEWPM-NEXT:               LazyValueAnalysis analysis on f
+; NEWPM-NEXT:             CorrelatedValuePropagationPass on f
+; NEWPM-NEXT:             ADCEPass on f
+; NEWPM-NEXT:               PostDominatorTreeAnalysis analysis on f
+; NEWPM-NEXT:             MemCpyOptPass on f
+; NEWPM-NEXT:             DSEPass on f
+; NEWPM-NEXT:             FunctionToLoopPassAdaptor on f
+; NEWPM-NEXT:               PassManager<{{.*}}> on f
+; NEWPM-NEXT:                 LoopSimplifyPass on f
+; NEWPM-NEXT:                 LCSSAPass on f
+; NEWPM-NEXT:             SimplifyCFGPass on f
+; NEWPM-NEXT:             InstCombinePass on f
+; NEWPM-NEXT: GlobalOptPass on [module]
+; NEWPM-NEXT: GlobalDCEPass on [module]
+; NEWPM-NEXT: EliminateAvailableExternallyPass on [module]
+; NEWPM-NEXT: ReversePostOrderFunctionAttrsPass on [module]
+; NEWPM-NEXT:   CallGraphAnalysis analysis on [module]
+; NEWPM-NEXT: RequireAnalysisPass<{{.*}}> on [module]
+; NEWPM-NEXT: ModuleToFunctionPassAdaptor on [module]
+; NEWPM-NEXT:   PassManager<{{.*}}> on f
+; NEWPM-NEXT:     PreservedCFGCheckerAnalysis analysis on f
+; NEWPM-NEXT:     Float2IntPass on f
+; NEWPM-NEXT:       DominatorTreeAnalysis analysis on f
+; NEWPM-NEXT:     LowerConstantIntrinsicsPass on f
+; NEWPM-NEXT:     FunctionToLoopPassAdaptor on f
+; NEWPM-NEXT:       PassManager<{{.*}}> on f
+; NEWPM-NEXT:         LoopSimplifyPass on f
+; NEWPM-NEXT:           LoopAnalysis analysis on f
+; NEWPM-NEXT:         LCSSAPass on f
+; NEWPM-NEXT:     LoopDistributePass on f
+; NEWPM-NEXT:       ScalarEvolutionAnalysis analysis on f
+; NEWPM-NEXT:       AAManager analysis on f
+; NEWPM-NEXT:         BasicAA analysis on f
+; NEWPM-NEXT:       InnerAnalysisManagerProxy<{{.*}}> analysis on f
+; NEWPM-NEXT:     InjectTLIMappings on f
+; NEWPM-NEXT:     LoopVectorizePass on f
+; NEWPM-NEXT:       BlockFrequencyAnalysis analysis on f
+; NEWPM-NEXT:         BranchProbabilityAnalysis analysis on f
+; NEWPM-NEXT:           PostDominatorTreeAnalysis analysis on f
+; NEWPM-NEXT:       DemandedBitsAnalysis analysis on f
+; NEWPM-NEXT:       MemorySSAAnalysis analysis on f
+; NEWPM-NEXT:     LoopLoadEliminationPass on f
+; NEWPM-NEXT:     InstCombinePass on f
+; NEWPM-NEXT:     SimplifyCFGPass on f
+; NEWPM-NEXT:     SLPVectorizerPass on f
+; NEWPM-NEXT:     VectorCombinePass on f
+; NEWPM-NEXT:     InstCombinePass on f
+; NEWPM-NEXT:     LoopUnrollPass on f
+; NEWPM-NEXT:     WarnMissedTransformationsPass on f
+; NEWPM-NEXT:     InstCombinePass on f
+; NEWPM-NEXT:     RequireAnalysisPass<{{.*}}> on f
+; NEWPM-NEXT:     FunctionToLoopPassAdaptor on f
+; NEWPM-NEXT:       PassManager<{{.*}}> on f
+; NEWPM-NEXT:         LoopSimplifyPass on f
+; NEWPM-NEXT:         LCSSAPass on f
+; NEWPM-NEXT:     AlignmentFromAssumptionsPass on f
+; NEWPM-NEXT:     LoopSinkPass on f
+; NEWPM-NEXT:     InstSimplifyPass on f
+; NEWPM-NEXT:     DivRemPairsPass on f
+; NEWPM-NEXT:     SimplifyCFGPass on f
+; NEWPM-NEXT:     SpeculateAroundPHIsPass on f
+; NEWPM-NEXT: CGProfilePass on [module]
+; NEWPM-NEXT: GlobalDCEPass on [module]
+; NEWPM-NEXT: ConstantMergePass on [module]
+; NEWPM-NEXT: RelLookupTableConverterPass on [module]
+; NEWPM-NEXT: ModuleToFunctionPassAdaptor on [module]
+; NEWPM-NEXT:   PassManager<{{.*}}> on f
+; NEWPM-NEXT:     AnnotationRemarksPass on f
+; NEWPM-NEXT: VerifierPass on [module]
+; NEWPM-NEXT:   VerifierAnalysis analysis on [module]
+; NEWPM-NEXT: BitcodeWriterPass on [module]
+
 define void @f() {
   ret void
 }