[LTO] Teach lib/LTO about the new pass manager

[davide]

Summary

Depends on D28996.
With this in, we can teach the gold plugin and lld about the new PM and start to experiment with that.

[mehdi_amini]

lib/LTO/LTOBackend.cpp

248 ↗

(On Diff #85308)

In the meantime, we shouldn't accept the combination ThinLTO+Conf.OptUseNewPM.

[davide]

lib/LTO/LTOBackend.cpp

248 ↗

(On Diff #85308)

Indeed. Are you fine with this being a fatal error for the time being as the configuration is forbidden (similarly to what we do around line 212)?
Otherwise I can just change the return value to std::pair<Error, bool> or return Error and pass bool as argument by reference, or whatever you like better.

[chandlerc]

FWIW, all of this seems fine. I don't have a lot of opinions about the best way to wire up the lib/LTO side, leaving that mostly to Mehdi.

[mehdi_amini]

lib/LTO/LTOBackend.cpp

248 ↗

(On Diff #85308)

I'm fine with a report_fatal_error for this.

[tejohnson]

lib/LTO/LTOBackend.cpp

248 ↗

(On Diff #85308)

The issue for ThinLTO seems larger than just not having the summary plumbed through (it isn't being used yet in the new pass manager pipeline set up in D28996 in any case, since the LowerTypeTestsPass is currently disabled there). The bigger issue is that a new pass manager pipeline for ThinLTO (analogous to the one for LTO added in D28996) needs to be set up. Can you add a FIXME by the fatal error about this?

[davide]

-> Addressed comments (Teresa/Mehdi)
-> Added a cl::opt so that we don't have to teach linkers about the new pm
-> Added basic testing

PTAL

[davide]

Revert accidentally included chunk.

[tejohnson]

A couple of nits, otherwise LGTM

lib/LTO/LTOBackend.cpp

46 ↗

(On Diff #85434)

Maybe more explicit "Run LTO passes using..."

test/ThinLTO/X86/error-newpm.ll

13 ↗

(On Diff #85434)

Seems like this test could be even simpler since we are just checking for an error (i.e. a single function). Alternatively, if we want to instead make this a test that will eventually test the new PM when it is implemented for ThinLTO, maybe the file name should be changed to just "newpm.ll"?

[pcc]

lib/LTO/LTOBackend.cpp

45 ↗

(On Diff #85434)

static?

248 ↗

(On Diff #85308)

Could be rewritten more simply as:

if (!Conf.OptPipeline.empty())
  runNewPMCustomPasses
else if (LTOUseNewPM)
  runNewPMPasses
else
  runOldPMPasses

?

[davide]

Address Peter's an Teresa's comments.

llvm/trunk/lib/LTO/LTOBackend.cpp

 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
 #include "llvm/Transforms/Scalar/LoopPassManager.h"
 #include "llvm/Transforms/Utils/FunctionImportUtils.h"
 #include "llvm/Transforms/Utils/SplitModule.h"
 
 using namespace llvm;
 using namespace lto;
 
+static cl::opt<bool>
+    LTOUseNewPM("lto-use-new-pm",
+                cl::desc("Run LTO passes using the new pass manager"),
+                cl::init(false), cl::Hidden);
+
 LLVM_ATTRIBUTE_NORETURN static void reportOpenError(StringRef Path, Twine Msg) {
   errs() << "failed to open " << Path << ": " << Msg << '\n';
   errs().flush();
   exit(1);
 }
 
 Error Config::addSaveTemps(std::string OutputFileName,
                            bool UseInputModulePath) {
createTargetMachine(Config &Conf, StringRef TheTriple,
   for (const std::string &A : Conf.MAttrs)
     Features.AddFeature(A);
 
   return std::unique_ptr<TargetMachine>(TheTarget->createTargetMachine(
       TheTriple, Conf.CPU, Features.getString(), Conf.Options, Conf.RelocModel,
       Conf.CodeModel, Conf.CGOptLevel));
 }
 
+static void runNewPMPasses(Module &Mod, TargetMachine *TM, unsigned OptLevel) {
+  PassBuilder PB(TM);
+  AAManager AA;
+
+  // Parse a custom AA pipeline if asked to.
+  assert(PB.parseAAPipeline(AA, "default"));
+
+  LoopAnalysisManager LAM;
+  FunctionAnalysisManager FAM;
+  CGSCCAnalysisManager CGAM;
+  ModuleAnalysisManager MAM;
+
+  // Register the AA manager first so that our version is the one used.
+  FAM.registerPass([&] { return std::move(AA); });
+
+  // Register all the basic analyses with the managers.
+  PB.registerModuleAnalyses(MAM);
+  PB.registerCGSCCAnalyses(CGAM);
+  PB.registerFunctionAnalyses(FAM);
+  PB.registerLoopAnalyses(LAM);
+  PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+
+  ModulePassManager MPM;
+  // FIXME (davide): verify the input.
+
+  PassBuilder::OptimizationLevel OL;
+
+  switch (OptLevel) {
+  default:
+    llvm_unreachable("Invalid optimization level");
+  case 0:
+    OL = PassBuilder::O0;
+    break;
+  case 1:
+    OL = PassBuilder::O1;
+    break;
+  case 2:
+    OL = PassBuilder::O2;
+    break;
+  case 3:
+    OL = PassBuilder::O3;
+    break;
+  }
+
+  MPM = PB.buildLTODefaultPipeline(OL, false /* DebugLogging */);
+  MPM.run(Mod, MAM);
+
+  // FIXME (davide): verify the output.
+}
+
 static void runNewPMCustomPasses(Module &Mod, TargetMachine *TM,
                                  std::string PipelineDesc,
                                  std::string AAPipelineDesc,
                                  bool DisableVerify) {
   PassBuilder PB(TM);
   AAManager AA;
 
   // Parse a custom AA pipeline if asked to.
if (IsThinLTO)
     PMB.populateThinLTOPassManager(passes);
   else
     PMB.populateLTOPassManager(passes);
   passes.run(Mod);
 }
 
 bool opt(Config &Conf, TargetMachine *TM, unsigned Task, Module &Mod,
          bool IsThinLTO, ModuleSummaryIndex &CombinedIndex) {
-  if (Conf.OptPipeline.empty())
-    runOldPMPasses(Conf, Mod, TM, IsThinLTO, CombinedIndex);
-  else
-    // FIXME: Plumb the combined index into the new pass manager.
+  // There's still no ThinLTO pipeline hooked up in the new pass manager,
+  // once there is one, we can just remove this.
+  if (LTOUseNewPM && IsThinLTO)
+    report_fatal_error("ThinLTO not supported with the new PM yet!");
+
+  if (!Conf.OptPipeline.empty())
     runNewPMCustomPasses(Mod, TM, Conf.OptPipeline, Conf.AAPipeline,
                          Conf.DisableVerify);
+  else if (LTOUseNewPM)
+    runNewPMPasses(Mod, TM, Conf.OptLevel);
+  else
+    runOldPMPasses(Conf, Mod, TM, IsThinLTO, CombinedIndex);
   return !Conf.PostOptModuleHook || Conf.PostOptModuleHook(Task, Mod);
 }
 
 void codegen(Config &Conf, TargetMachine *TM, AddStreamFn AddStream,
              unsigned Task, Module &Mod) {
   if (Conf.PreCodeGenModuleHook && !Conf.PreCodeGenModuleHook(Task, Mod))
     return;
 

llvm/trunk/test/tools/llvm-lto2/X86/pipeline.ll

 ; RUN: llvm-as < %s > %t1.bc
 
 ; Try a custom pipeline
 ; RUN: llvm-lto2 %t1.bc -o %t.o -save-temps \
 ; RUN:  -r %t1.bc,patatino,px -opt-pipeline loweratomic \
 ; RUN:  -aa-pipeline basic-aa
 ; RUN: llvm-dis < %t.o.0.4.opt.bc | FileCheck %s --check-prefix=CUSTOM
 
+; Try the new pass manager LTO default pipeline (make sure the option
+; is accepted).
+; RUN: llvm-lto2 %t1.bc -o %t.o -lto-use-new-pm -r %t1.bc,patatino,px
+
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @patatino() {
   fence seq_cst
   ret void
 }