[PGO] Add PGO support at -O0 in the experimental new pass manager

[xur]

Summary

Add PGO support at -O0 in the experimental new pass manager to sync the behavior with the legacy pass manager.

Also change the test of gcc-flag-compatibility.c for more complete test:
(1) change the match string to "profc" and "profd" to ensure the instrumentation is happening.
(2) add IR format proftext so that PGO use is tested.

[xur]

Sent the wrong test file in last patch.
Update to the correct one.

[xur]

Ping

llvm/lib/Passes/PassBuilder.cpp

576 ↗

(On Diff #207389)

I moved this pass under the condition when Early inline is enabled. I'm under the impression that the intention is to clean up the code for the inline.
Chandler: you added this pass. If you don't like this move, I can pull it out and put it under another (Level > 0) condition.

[chandlerc]

Sorry for the delay here.

It'd be nice to land the LLVM patch first and with its own testing -- we should have testing for the pass builder independent of Clang (IE, in the LLVM tests).

One option would be to test it with a unittest, not sure we have pass builder unittests at the moment.

Probably a better option would be to define a pseudo pass name like our default<O0>, maybe pgo<O0>. Then you can parse the O0 the same way we do for the default thing. when it is O0 you can call the new routine I've suggested below. When it is higher, you can call the existing routine much like the default pipeline code does. This would all be implemented inside the pass builder so no issues w/ using the utility code there.

This would let us much more nicely write tests for the pipeline fragment generated for PGO both at O0 and above -- we have tests that specifically print out the pipeline sequence. This makes it very easy to visualize changes to the pipeline. And it would let you test the O0 code path here.

The clang part of the patch (once adapted to the narrower API) seems likely to be good then.

I'm happy for this to be two patches (first llvm, then Clang), or one patch. Whatever is easier for you.

llvm/lib/Passes/PassBuilder.cpp

579–602 ↗

(On Diff #207392)

Rather than moving the entire routine that is really only intended for the innards of the pass manager to be public, I'd do something a bit more narrow...

Maybe just add pipeline method to the pass builder to generate a minimal pipeline suitable for O0 usage?

I think this code will be simpler to read w/o having to have the O0 conditions plumbed all the way through it, and the duplication is tiny.

If you want, could pull out the use bits which are common and use early exit to make the code more clear:

if (!RunProfileGen) {
  addPGOUsePasses(...);
  return;
}

...

(Not sure what name to use for this, but you see the idea.) Then there would be almost no duplication between the O0 and this code, w/o having to have the conditions threaded throughout.

576 ↗

(On Diff #207389)

This makes sense to me. It was probably just transcription error on my part.

[xur]

I'm sorry that I missed this review for this long!

In D64029#1581952, @chandlerc wrote:

Sorry for the delay here.

It'd be nice to land the LLVM patch first and with its own testing -- we should have testing for the pass builder independent of Clang (IE, in the LLVM tests).

One option would be to test it with a unittest, not sure we have pass builder unittests at the moment.

I initially had the pipeline change for this. But clang did not use the default pipeline, so I removed that change.
But this makes sense now to me with a unittest.

Probably a better option would be to define a pseudo pass name like our default<O0>, maybe pgo<O0>. Then you can parse the O0 the same way we do for the default thing. when it is O0 you can call the new routine I've suggested below. When it is higher, you can call the existing routine much like the default pipeline code does. This would all be implemented inside the pass builder so no issues w/ using the utility code there.

This would let us much more nicely write tests for the pipeline fragment generated for PGO both at O0 and above -- we have tests that specifically print out the pipeline sequence. This makes it very easy to visualize changes to the pipeline. And it would let you test the O0 code path here.

hmm. I think PGO is orthogonal to default pipeline: we now have prefixes of "default", "thinlto-pre-link", "thinlto", "lto", "lto-pre-link". They all can work with PGO enabled. It seems to me PGO<O0> will not cover all of them.

The clang part of the patch (once adapted to the narrower API) seems likely to be good then.

I'm happy for this to be two patches (first llvm, then Clang), or one patch. Whatever is easier for you.

Great! I would prefer to have only one patch -- that would be easier.

In D64029#1581952, @chandlerc wrote:

Sorry for the delay here.

It'd be nice to land the LLVM patch first and with its own testing -- we should have testing for the pass builder independent of Clang (IE, in the LLVM tests).

One option would be to test it with a unittest, not sure we have pass builder unittests at the moment.

Probably a better option would be to define a pseudo pass name like our default<O0>, maybe pgo<O0>. Then you can parse the O0 the same way we do for the default thing. when it is O0 you can call the new routine I've suggested below. When it is higher, you can call the existing routine much like the default pipeline code does. This would all be implemented inside the pass builder so no issues w/ using the utility code there.

This would let us much more nicely write tests for the pipeline fragment generated for PGO both at O0 and above -- we have tests that specifically print out the pipeline sequence. This makes it very easy to visualize changes to the pipeline. And it would let you test the O0 code path here.

The clang part of the patch (once adapted to the narrower API) seems likely to be good then.

I'm happy for this to be two patches (first llvm, then Clang), or one patch. Whatever is easier for you.

llvm/lib/Passes/PassBuilder.cpp

579–602 ↗

(On Diff #207392)

I added a new function named as "addPGOInstrPassesForO0" which only does the O0 passes for PGO. It is a public function as it will be called from clang.
Also followed the advice to refactor the code for better readability.

576 ↗

(On Diff #207389)

Got it.

[xur]

Integrated Chandler's review comments.

[chandlerc]

LGTM with two nits addressed, thanks!

clang/lib/CodeGen/BackendUtil.cpp

1125 ↗

(On Diff #212237)

Minor nit, here and else where with the comment-named bools I'd use the style: /*RunProfileGen=*/PGOOpt->Action == PGOOPtions::IRInstr

This was suggested as more consistent w/ Clang style, and it seems a bit cleaner. Also, clang-tidy will recognize and check that the comment uses the same name as the parameter.

llvm/lib/Passes/PassBuilder.cpp

1839 ↗

(On Diff #212237)

Same nit about the parameter comments here.

[xur]

clang/lib/CodeGen/BackendUtil.cpp

1125 ↗

(On Diff #212237)

Thanks for the suggestion and the reasoning.

I actually wrote it in one line.
This was produced by "clang/tools/clang-format/clang-format-diff.py". :-)

I'm using now "/*RunProfileGen=*/ (PGOOpt->Action == PGOOPtions::IRInstr)" so clang-format-diff.py won't complain

[phosek]

Looks like this change broke Profile/gcc-flag-compatibility.c test on macOS:

******************** TEST 'Clang :: Profile/gcc-flag-compatibility.c' FAILED ********************
Script:
--
: 'RUN: at line 10';   /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/bin/clang /b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c -c -S -o - -emit-llvm -fprofile-generate -fno-experimental-new-pass-manager | /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/bin/FileCheck -check-prefix=PROFILE-GEN /b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c
: 'RUN: at line 11';   /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/bin/clang /b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c -c -S -o - -emit-llvm -fprofile-generate -fexperimental-new-pass-manager | /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/bin/FileCheck -check-prefix=PROFILE-GEN /b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c
: 'RUN: at line 16';   /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/bin/clang /b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c -c -S -o - -emit-llvm -fprofile-generate=/path/to -fno-experimental-new-pass-manager | /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/bin/FileCheck -check-prefixes=PROFILE-GEN,PROFILE-GEN-EQ /b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c
: 'RUN: at line 22';   rm -rf /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/tools/clang/test/Profile/Output/gcc-flag-compatibility.c.tmp.dir
: 'RUN: at line 23';   mkdir -p /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/tools/clang/test/Profile/Output/gcc-flag-compatibility.c.tmp.dir/some/path
: 'RUN: at line 24';   llvm-profdata merge /b/s/w/ir/k/llvm-project/clang/test/Profile/Inputs/gcc-flag-compatibility.proftext -o /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/tools/clang/test/Profile/Output/gcc-flag-compatibility.c.tmp.dir/some/path/default.profdata
: 'RUN: at line 25';   /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/bin/clang /b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c -o - -Xclang -disable-llvm-passes -emit-llvm -S -fprofile-use=/b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/tools/clang/test/Profile/Output/gcc-flag-compatibility.c.tmp.dir/some/path -fno-experimental-new-pass-manager | /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/bin/FileCheck -check-prefix=PROFILE-USE /b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c
: 'RUN: at line 26';   /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/bin/clang /b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c -o - -Xclang -disable-llvm-passes -emit-llvm -S -fprofile-use=/b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/tools/clang/test/Profile/Output/gcc-flag-compatibility.c.tmp.dir/some/path -fexperimental-new-pass-manager | /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/bin/FileCheck -check-prefix=PROFILE-USE /b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c
: 'RUN: at line 30';   rm -rf /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/tools/clang/test/Profile/Output/gcc-flag-compatibility.c.tmp.dir
: 'RUN: at line 31';   mkdir -p /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/tools/clang/test/Profile/Output/gcc-flag-compatibility.c.tmp.dir/some/path
: 'RUN: at line 32';   llvm-profdata merge /b/s/w/ir/k/llvm-project/clang/test/Profile/Inputs/gcc-flag-compatibility.proftext -o /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/tools/clang/test/Profile/Output/gcc-flag-compatibility.c.tmp.dir/some/path/file.prof
: 'RUN: at line 33';   /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/bin/clang /b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c -o - -Xclang -disable-llvm-passes -emit-llvm -S -fprofile-use=/b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/tools/clang/test/Profile/Output/gcc-flag-compatibility.c.tmp.dir/some/path/file.prof -fno-experimental-new-pass-manager | /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/bin/FileCheck -check-prefix=PROFILE-USE /b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c
: 'RUN: at line 34';   /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/bin/clang /b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c -o - -Xclang -disable-llvm-passes -emit-llvm -S -fprofile-use=/b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/tools/clang/test/Profile/Output/gcc-flag-compatibility.c.tmp.dir/some/path/file.prof -fexperimental-new-pass-manager | /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/bin/FileCheck -check-prefix=PROFILE-USE /b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c
: 'RUN: at line 39';   rm -rf /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/tools/clang/test/Profile/Output/gcc-flag-compatibility.c.tmp.dir
: 'RUN: at line 40';   mkdir -p /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/tools/clang/test/Profile/Output/gcc-flag-compatibility.c.tmp.dir/some/path
: 'RUN: at line 41';   llvm-profdata merge /b/s/w/ir/k/llvm-project/clang/test/Profile/Inputs/gcc-flag-compatibility_IR.proftext -o /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/tools/clang/test/Profile/Output/gcc-flag-compatibility.c.tmp.dir/some/path/default.profdata
: 'RUN: at line 42';   /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/bin/clang /b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c -o - -emit-llvm -S -fprofile-use=/b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/tools/clang/test/Profile/Output/gcc-flag-compatibility.c.tmp.dir/some/path -fno-experimental-new-pass-manager | /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/bin/FileCheck -check-prefix=PROFILE-USE-IR /b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c
: 'RUN: at line 43';   /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/bin/clang /b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c -o - -emit-llvm -S -fprofile-use=/b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/tools/clang/test/Profile/Output/gcc-flag-compatibility.c.tmp.dir/some/path -fexperimental-new-pass-manager | /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/bin/FileCheck -check-prefix=PROFILE-USE-IR /b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c
: 'RUN: at line 47';   rm -rf /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/tools/clang/test/Profile/Output/gcc-flag-compatibility.c.tmp.dir
: 'RUN: at line 48';   mkdir -p /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/tools/clang/test/Profile/Output/gcc-flag-compatibility.c.tmp.dir/some/path
: 'RUN: at line 49';   llvm-profdata merge /b/s/w/ir/k/llvm-project/clang/test/Profile/Inputs/gcc-flag-compatibility_IR.proftext -o /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/tools/clang/test/Profile/Output/gcc-flag-compatibility.c.tmp.dir/some/path/file.prof
: 'RUN: at line 50';   /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/bin/clang /b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c -o - -emit-llvm -S -fprofile-use=/b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/tools/clang/test/Profile/Output/gcc-flag-compatibility.c.tmp.dir/some/path/file.prof -fno-experimental-new-pass-manager | /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/bin/FileCheck -check-prefix=PROFILE-USE-IR /b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c
: 'RUN: at line 51';   /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/bin/clang /b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c -o - -emit-llvm -S -fprofile-use=/b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/tools/clang/test/Profile/Output/gcc-flag-compatibility.c.tmp.dir/some/path/file.prof -fexperimental-new-pass-manager | /b/s/w/ir/k/recipe_cleanup/clangOLc9jG/llvm_build_dir/bin/FileCheck -check-prefix=PROFILE-USE-IR /b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c
--
Exit Code: 1

Command Output (stderr):
--
/b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c:12:17: error: PROFILE-GEN: expected string not found in input
// PROFILE-GEN: @__profc_main = private global [2 x i64] zeroinitializer, section "__llvm_prf_cnts", align 8
                ^
<stdin>:1:1: note: scanning from here
; ModuleID = '/b/s/w/ir/k/llvm-project/clang/test/Profile/gcc-flag-compatibility.c'
^
<stdin>:9:1: note: possible intended match here
@__profc_main = private global [2 x i64] zeroinitializer, section "__DATA,__llvm_prf_cnts", align 8
^

--

cfe/trunk/lib/CodeGen/BackendUtil.cpp

if (CodeGenOpts.OptimizationLevel == 0) {
         MPM.addPass(InstrProfiling(*Options, false));
 
       // Build a minimal pipeline based on the semantics required by Clang,
       // which is just that always inlining occurs. Further, disable generating
       // lifetime intrinsics to avoid enabling further optimizations during
       // code generation.
       MPM.addPass(AlwaysInlinerPass(/*InsertLifetimeIntrinsics=*/false));
 
+      // At -O0, we can still do PGO. Add all the requested passes for
+      // instrumentation PGO, if requested.
+      if (PGOOpt && (PGOOpt->Action == PGOOptions::IRInstr ||
+                     PGOOpt->Action == PGOOptions::IRUse))
+        PB.addPGOInstrPassesForO0(
+            MPM, CodeGenOpts.DebugPassManager,
+            /* RunProfileGen */ (PGOOpt->Action == PGOOptions::IRInstr),
+            /* IsCS */ false, PGOOpt->ProfileFile,
+            PGOOpt->ProfileRemappingFile);
+
       // At -O0 we directly run necessary sanitizer passes.
       if (LangOpts.Sanitize.has(SanitizerKind::LocalBounds))
         MPM.addPass(createModuleToFunctionPassAdaptor(BoundsCheckingPass()));
 
       // Lastly, add semantically necessary passes for LTO.
       if (IsLTO || IsThinLTO) {
         MPM.addPass(CanonicalizeAliasesPass());
         MPM.addPass(NameAnonGlobalPass());

cfe/trunk/test/Profile/Inputs/gcc-flag-compatibility_IR.proftext

+# IR level Instrumentation Flag
+:ir
+main
+# Func Hash:
[phone]
+# Num Counters:
+2
+# Counter Values:
+100
+1
+

cfe/trunk/test/Profile/gcc-flag-compatibility.c

 // Tests for -fprofile-generate and -fprofile-use flag compatibility. These two
 // flags behave similarly to their GCC counterparts:
 //
 // -fprofile-generate         Generates the profile file ./default.profraw
 // -fprofile-generate=<dir>   Generates the profile file <dir>/default.profraw
 // -fprofile-use              Uses the profile file ./default.profdata
 // -fprofile-use=<dir>        Uses the profile file <dir>/default.profdata
 // -fprofile-use=<dir>/file   Uses the profile file <dir>/file
 
-// RUN: %clang %s -c -S -o - -emit-llvm -fprofile-generate | FileCheck -check-prefix=PROFILE-GEN %s
-// PROFILE-GEN: __llvm_profile_filename
+// RUN: %clang %s -c -S -o - -emit-llvm -fprofile-generate -fno-experimental-new-pass-manager | FileCheck -check-prefix=PROFILE-GEN %s
+// RUN: %clang %s -c -S -o - -emit-llvm -fprofile-generate -fexperimental-new-pass-manager | FileCheck -check-prefix=PROFILE-GEN %s
+// PROFILE-GEN: @__profc_main = private global [2 x i64] zeroinitializer, section "__llvm_prf_cnts", align 8
+// PROFILE-GEN: @__profd_main = private global
 
 // Check that -fprofile-generate=/path/to generates /path/to/default.profraw
-// RUN: %clang %s -c -S -o - -emit-llvm -fprofile-generate=/path/to | FileCheck -check-prefix=PROFILE-GEN-EQ %s
+// RUN: %clang %s -c -S -o - -emit-llvm -fprofile-generate=/path/to -fno-experimental-new-pass-manager | FileCheck -check-prefixes=PROFILE-GEN,PROFILE-GEN-EQ %s
+// RxUN: %clang %s -c -S -o - -emit-llvm -fprofile-generate=/path/to -fexperimental-new-pass-manager | FileCheck -check-prefixes=PROFILE-GEN,PROFILE-GEN-EQ %s
 // PROFILE-GEN-EQ: constant [{{.*}} x i8] c"/path/to{{/|\\5C}}{{.*}}\00"
 
 // Check that -fprofile-use=some/path reads some/path/default.profdata
+// This uses Clang FE format profile.
 // RUN: rm -rf %t.dir
 // RUN: mkdir -p %t.dir/some/path
 // RUN: llvm-profdata merge %S/Inputs/gcc-flag-compatibility.proftext -o %t.dir/some/path/default.profdata
-// RUN: %clang %s -o - -Xclang -disable-llvm-passes -emit-llvm -S -fprofile-use=%t.dir/some/path | FileCheck -check-prefix=PROFILE-USE-2 %s
-// PROFILE-USE-2: = !{!"branch_weights", i32 101, i32 2}
+// RUN: %clang %s -o - -Xclang -disable-llvm-passes -emit-llvm -S -fprofile-use=%t.dir/some/path -fno-experimental-new-pass-manager | FileCheck -check-prefix=PROFILE-USE %s
+// RUN: %clang %s -o - -Xclang -disable-llvm-passes -emit-llvm -S -fprofile-use=%t.dir/some/path -fexperimental-new-pass-manager | FileCheck -check-prefix=PROFILE-USE %s
 
 // Check that -fprofile-use=some/path/file.prof reads some/path/file.prof
+// This uses Clang FE format profile.
 // RUN: rm -rf %t.dir
 // RUN: mkdir -p %t.dir/some/path
 // RUN: llvm-profdata merge %S/Inputs/gcc-flag-compatibility.proftext -o %t.dir/some/path/file.prof
-// RUN: %clang %s -o - -Xclang -disable-llvm-passes -emit-llvm -S -fprofile-use=%t.dir/some/path/file.prof | FileCheck -check-prefix=PROFILE-USE-3 %s
-// PROFILE-USE-3: = !{!"branch_weights", i32 101, i32 2}
+// RUN: %clang %s -o - -Xclang -disable-llvm-passes -emit-llvm -S -fprofile-use=%t.dir/some/path/file.prof -fno-experimental-new-pass-manager | FileCheck -check-prefix=PROFILE-USE %s
+// RUN: %clang %s -o - -Xclang -disable-llvm-passes -emit-llvm -S -fprofile-use=%t.dir/some/path/file.prof -fexperimental-new-pass-manager | FileCheck -check-prefix=PROFILE-USE %s
+// PROFILE-USE: = !{!"branch_weights", i32 101, i32 2}
+
+// Check that -fprofile-use=some/path reads some/path/default.profdata
+// This uses LLVM IR format profile.
+// RUN: rm -rf %t.dir
+// RUN: mkdir -p %t.dir/some/path
+// RUN: llvm-profdata merge %S/Inputs/gcc-flag-compatibility_IR.proftext -o %t.dir/some/path/default.profdata
+// RUN: %clang %s -o - -emit-llvm -S -fprofile-use=%t.dir/some/path -fno-experimental-new-pass-manager | FileCheck -check-prefix=PROFILE-USE-IR %s
+// RUN: %clang %s -o - -emit-llvm -S -fprofile-use=%t.dir/some/path -fexperimental-new-pass-manager | FileCheck -check-prefix=PROFILE-USE-IR %s
+
+// Check that -fprofile-use=some/path/file.prof reads some/path/file.prof
+// This uses LLVM IR format profile.
+// RUN: rm -rf %t.dir
+// RUN: mkdir -p %t.dir/some/path
+// RUN: llvm-profdata merge %S/Inputs/gcc-flag-compatibility_IR.proftext -o %t.dir/some/path/file.prof
+// RUN: %clang %s -o - -emit-llvm -S -fprofile-use=%t.dir/some/path/file.prof -fno-experimental-new-pass-manager | FileCheck -check-prefix=PROFILE-USE-IR %s
+// RUN: %clang %s -o - -emit-llvm -S -fprofile-use=%t.dir/some/path/file.prof -fexperimental-new-pass-manager | FileCheck -check-prefix=PROFILE-USE-IR %s
+
+// PROFILE-USE-IR: = !{!"branch_weights", i32 100, i32 1}
 
 int X = 0;
 
 int main() {
   int i;
   for (i = 0; i < 100; i++)
     X += i;
   return 0;
 }

llvm/trunk/include/llvm/Passes/PassBuilder.h

public:
   /// text, this Callback should be used to determine the appropriate stack of
   /// PassManagers and populate the passed ModulePassManager.
   void registerParseTopLevelPipelineCallback(
       const std::function<bool(ModulePassManager &, ArrayRef<PipelineElement>,
                                bool VerifyEachPass, bool DebugLogging)> &C) {
     TopLevelPipelineParsingCallbacks.push_back(C);
   }
 
+  /// Add PGOInstrumenation passes for O0 only.
+  void addPGOInstrPassesForO0(ModulePassManager &MPM, bool DebugLogging,
+                              bool RunProfileGen, bool IsCS,
+                              std::string ProfileFile,
+                              std::string ProfileRemappingFile);
+
 private:
   static Optional<std::vector<PipelineElement>>
   parsePipelineText(StringRef Text);
 
   Error parseModulePass(ModulePassManager &MPM, const PipelineElement &E,
                         bool VerifyEachPass, bool DebugLogging);
   Error parseCGSCCPass(CGSCCPassManager &CGPM, const PipelineElement &E,
                        bool VerifyEachPass, bool DebugLogging);
private:
   Error parseModulePassPipeline(ModulePassManager &MPM,
                                 ArrayRef<PipelineElement> Pipeline,
                                 bool VerifyEachPass, bool DebugLogging);
 
   void addPGOInstrPasses(ModulePassManager &MPM, bool DebugLogging,
                          OptimizationLevel Level, bool RunProfileGen, bool IsCS,
                          std::string ProfileFile,
                          std::string ProfileRemappingFile);
-
   void invokePeepholeEPCallbacks(FunctionPassManager &, OptimizationLevel);
 
   // Extension Point callbacks
   SmallVector<std::function<void(FunctionPassManager &, OptimizationLevel)>, 2>
       PeepholeEPCallbacks;
   SmallVector<std::function<void(LoopPassManager &, OptimizationLevel)>, 2>
       LateLoopOptimizationsEPCallbacks;
   SmallVector<std::function<void(LoopPassManager &, OptimizationLevel)>, 2>

llvm/trunk/lib/Passes/PassBuilder.cpp

PassBuilder::buildFunctionSimplificationPipeline(OptimizationLevel Level,
   return FPM;
 }
 
 void PassBuilder::addPGOInstrPasses(ModulePassManager &MPM, bool DebugLogging,
                                     PassBuilder::OptimizationLevel Level,
                                     bool RunProfileGen, bool IsCS,
                                     std::string ProfileFile,
                                     std::string ProfileRemappingFile) {
+  assert(Level != O0 && "Not expecting O0 here!");
   // Generally running simplification passes and the inliner with an high
   // threshold results in smaller executables, but there may be cases where
   // the size grows, so let's be conservative here and skip this simplification
   // at -Os/Oz. We will not do this  inline for context sensistive PGO (when
   // IsCS is true).
   if (!isOptimizingForSize(Level) && !IsCS) {
     InlineParams IP;
 
if (!isOptimizingForSize(Level) && !IsCS) {
     FPM.addPass(EarlyCSEPass());    // Catch trivial redundancies.
     FPM.addPass(SimplifyCFGPass()); // Merge & remove basic blocks.
     FPM.addPass(InstCombinePass()); // Combine silly sequences.
     invokePeepholeEPCallbacks(FPM, Level);
 
     CGPipeline.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM)));
 
     MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPipeline)));
-  }
 
     // Delete anything that is now dead to make sure that we don't instrument
     // dead code. Instrumentation can end up keeping dead code around and
     // dramatically increase code size.
     MPM.addPass(GlobalDCEPass());
+  }
 
-  if (RunProfileGen) {
-    MPM.addPass(PGOInstrumentationGen(IsCS));
+  if (!RunProfileGen) {
+    assert(!ProfileFile.empty() && "Profile use expecting a profile file!");
+    MPM.addPass(PGOInstrumentationUse(ProfileFile, ProfileRemappingFile, IsCS));
+    // Cache ProfileSummaryAnalysis once to avoid the potential need to insert
+    // RequireAnalysisPass for PSI before subsequent non-module passes.
+    MPM.addPass(RequireAnalysisPass<ProfileSummaryAnalysis, Module>());
+    return;
+  }
+
+  // Perform PGO instrumentation.
 
-    FunctionPassManager FPM;
-    FPM.addPass(
-        createFunctionToLoopPassAdaptor(LoopRotatePass(), DebugLogging));
-    MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
+  FPM.addPass(createFunctionToLoopPassAdaptor(LoopRotatePass(), DebugLogging));
 
-    // Add the profile lowering pass.
-    InstrProfOptions Options;
-    if (!ProfileFile.empty())
-      Options.InstrProfileOutput = ProfileFile;
-    Options.DoCounterPromotion = true;
-    Options.UseBFIInPromotion = IsCS;
-    MPM.addPass(InstrProfiling(Options, IsCS));
-  } else if (!ProfileFile.empty()) {
+  // Do counter promotion at Level greater than O0.
+}
+
+void PassBuilder::addPGOInstrPassesForO0(ModulePassManager &MPM,
+                                         bool DebugLogging, bool RunProfileGen,
+                                         bool IsCS, std::string ProfileFile,
+                                         std::string ProfileRemappingFile) {
+  if (!RunProfileGen) {
+    assert(!ProfileFile.empty() && "Profile use expecting a profile file!");
     MPM.addPass(PGOInstrumentationUse(ProfileFile, ProfileRemappingFile, IsCS));
     // Cache ProfileSummaryAnalysis once to avoid the potential need to insert
     // RequireAnalysisPass for PSI before subsequent non-module passes.
     MPM.addPass(RequireAnalysisPass<ProfileSummaryAnalysis, Module>());
+    return;
   }
+
+  // Perform PGO instrumentation.
+  MPM.addPass(PGOInstrumentationGen(IsCS));
+  // Add the profile lowering pass.
+  InstrProfOptions Options;
+  if (!ProfileFile.empty())
+    Options.InstrProfileOutput = ProfileFile;
+  // Do not do counter promotion at O0.
+  Options.DoCounterPromotion = false;
+  Options.UseBFIInPromotion = IsCS;
+  MPM.addPass(InstrProfiling(Options, IsCS));
 }
 
 static InlineParams
 getInlineParamsFromOptLevel(PassBuilder::OptimizationLevel Level) {
   auto O3 = PassBuilder::O3;
   unsigned OptLevel = Level > O3 ? 2 : Level;
   unsigned SizeLevel = Level > O3 ? Level - O3 : 0;
   return getInlineParams(OptLevel, SizeLevel);
if (startsWithDefaultPipelineAliasPrefix(Name)) {
 
     OptimizationLevel L = StringSwitch<OptimizationLevel>(Matches[2])
                               .Case("O0", O0)
                               .Case("O1", O1)
                               .Case("O2", O2)
                               .Case("O3", O3)
                               .Case("Os", Os)
                               .Case("Oz", Oz);
-    if (L == O0)
-      // At O0 we do nothing at all!
+    if (L == O0) {
+      // Add instrumentation PGO passes -- at O0 we can still do PGO.
+      if (PGOOpt && Matches[1] != "thinlto" &&
+          (PGOOpt->Action == PGOOptions::IRInstr ||
+           PGOOpt->Action == PGOOptions::IRUse))
+        addPGOInstrPassesForO0(
+            MPM, DebugLogging,
+            /* RunProfileGen */ (PGOOpt->Action == PGOOptions::IRInstr),
+            /* IsCS */ false, PGOOpt->ProfileFile,
+            PGOOpt->ProfileRemappingFile);
+      // Do nothing else at all!
       return Error::success();
+    }
 
     if (Matches[1] == "default") {
       MPM.addPass(buildPerModuleDefaultPipeline(L, DebugLogging));
     } else if (Matches[1] == "thinlto-pre-link") {
       MPM.addPass(buildThinLTOPreLinkDefaultPipeline(L, DebugLogging));
     } else if (Matches[1] == "thinlto") {
       MPM.addPass(buildThinLTODefaultPipeline(L, DebugLogging, nullptr));
     } else if (Matches[1] == "lto-pre-link") {

llvm/trunk/test/Other/new-pm-pgo-O0.ll

+; RUN: opt -debug-pass-manager -passes='default<O0>' -pgo-kind=pgo-instr-gen-pipeline -profile-file='temp' %s 2>&1 |FileCheck %s --check-prefixes=GEN
+; RUN: llvm-profdata merge %S/Inputs/new-pm-pgo.proftext -o %t.profdata
+; RUN: opt -debug-pass-manager -passes='default<O0>' -pgo-kind=pgo-instr-use-pipeline -profile-file='%t.profdata' %s 2>&1 |FileCheck %s --check-prefixes=USE_DEFAULT,USE
+; RUN: opt -debug-pass-manager -passes='thinlto-pre-link<O0>' -pgo-kind=pgo-instr-use-pipeline -profile-file='%t.profdata' %s 2>&1 \
+; RUN:     |FileCheck %s --check-prefixes=USE_PRE_LINK,USE
+; RUN: opt -debug-pass-manager -passes='lto-pre-link<O0>' -pgo-kind=pgo-instr-use-pipeline -profile-file='%t.profdata' %s 2>&1 \
+; RUN:     |FileCheck %s --check-prefixes=USE_PRE_LINK,USE
+; RUN: opt -debug-pass-manager -passes='thinlto<O0>' -pgo-kind=pgo-instr-use-pipeline -profile-file='%t.profdata' %s 2>&1 \
+; RUN:     |FileCheck %s --check-prefixes=USE_POST_LINK,USE
+
+;
+; GEN: Running pass: PGOInstrumentationGen
+; USE_DEFAULT: Running pass: PGOInstrumentationUse
+; USE_PRE_LINK: Running pass: PGOInstrumentationUse
+; USE_POST_LINK-NOT: Running pass: PGOInstrumentationUse
+; USE-NOT: Running pass: PGOIndirectCallPromotion
+; USE-NOT: Running pass: PGOMemOPSizeOpt
+
+define void @foo() {
+  ret void
+}