[NewPM] Initial pipeline for ThinLTO

[davide]

Summary

As per @timshen request.
I haven't tried this in a while, and a fair amount of things changed, so use with caution, but it's still a good starting point.
Please let me know if you find any problems and I'll try to fix them ASAP.

[davide]

Also, please note this patch contains also the clang bits. you may want to apply them separately.

[timshen]

Hi Davide,

Did you ever use -Xclang=-fthin-link-bitcode? In our build we use this flag, and it turns out not to be handled with/without your patch. See https://github.com/llvm-mirror/clang/blob/0cb0ba28983d349395d2d38bdedcd9129ce556c4/lib/CodeGen/BackendUtil.cpp#L752 .

I'm going to use your patch as a start point and add the flag support.

[davide]

In D33429#762340, @timshen wrote:

Hi Davide,

Did you ever use -Xclang=-fthin-link-bitcode? In our build we use this flag, and it turns out not to be handled with/without your patch. See https://github.com/llvm-mirror/clang/blob/0cb0ba28983d349395d2d38bdedcd9129ce556c4/lib/CodeGen/BackendUtil.cpp#L752 .

I'm going to use your patch as a start point and add the flag support.

I think you just need to add the pass to EmitAssemblyWithNewPassManager.
I had that line, but it got lost in the rebase.

https://github.com/llvm-mirror/clang/blob/0cb0ba28983d349395d2d38bdedcd9129ce556c4/lib/CodeGen/BackendUtil.cpp#L1099

[chandlerc]

I patched this and re-worked the particular API it uses for exposing the ThinLTO logic into a different surface in https://reviews.llvm.org/D33540 as an alternative approach. Thoughts?

[davide]

Chandler/Tim landed a different approach, abandoning this one.

include/llvm/Passes/PassBuilder.h

 ///
 /// It's members provide the baseline state available to passes during their
 /// construction. The \c PassRegistry.def file specifies how to construct all
 /// of the built-in passes, and those may reference these members during
 /// construction.
 class PassBuilder {
   TargetMachine *TM;
   Optional<PGOOptions> PGOOpt;
+  bool PrepareForThinLTO = false;
 
 public:
   /// \brief LLVM-provided high-level optimization levels.
   ///
   /// This enumerates the LLVM-provided high-level optimization levels. Each
   /// level has a specific goal and rationale.
   enum OptimizationLevel {
     /// Disable as many optimizations as possible. This doesn't completely
enum OptimizationLevel {
     /// This is useful primarily when there are absolute size limitations and
     /// any effort taken to reduce the size is worth it regardless of the
     /// execution time impact. You should expect this level to produce rather
     /// slow, but very small, code.
     Oz
   };
 
   explicit PassBuilder(TargetMachine *TM = nullptr,
-                       Optional<PGOOptions> PGOOpt = None)
-      : TM(TM), PGOOpt(PGOOpt) {}
+                       Optional<PGOOptions> PGOOpt = None,
+                       bool PrepareForThinLTO = false)
+      : TM(TM), PGOOpt(PGOOpt), PrepareForThinLTO(PrepareForThinLTO) {}
 
   /// \brief Cross register the analysis managers through their proxies.
   ///
   /// This is an interface that can be used to cross register each
   // AnalysisManager with all the others analysis managers.
   void crossRegisterProxies(LoopAnalysisManager &LAM,
                             FunctionAnalysisManager &FAM,
                             CGSCCAnalysisManager &CGAM,
public:
   /// typically correspond to frontend "-O[123]" options for optimization
   /// levels \c O1, \c O2 and \c O3 resp.
   ///
   /// Note that \p Level cannot be `O0` here. The pipelines produced are
   /// only intended for use when attempting to optimize code. If frontends
   /// require some transformations for semantic reasons, they should explicitly
   /// build them.
   ModulePassManager buildPerModuleDefaultPipeline(OptimizationLevel Level,
-                                                  bool DebugLogging = false);
+                                                  bool DebugLogging = false,
+                                                  bool PerformThinLTO = false);
 
   /// Build a pre-link, LTO-targeting default optimization pipeline to a pass
   /// manager.
   ///
   /// This adds the pre-link optimizations tuned to work well with a later LTO
   /// run. It works to minimize the IR which needs to be analyzed without
   /// making irreversible decisions which could be made better during the LTO
   /// run.
public:
   ///
   /// Note that \p Level cannot be `O0` here. The pipelines produced are
   /// only intended for use when attempting to optimize code. If frontends
   /// require some transformations for semantic reasons, they should explicitly
   /// build them.
   ModulePassManager buildLTODefaultPipeline(OptimizationLevel Level,
                                             bool DebugLogging = false);
 
+  /// Build an ThinLTO default optimization pipeline to a pass manager.
+  ///
+  /// This provides a good default optimization pipeline for link-time
+  /// optimization and code generation. It is particularly tuned to fit well
+  /// when IR coming into the LTO phase was first run through \c
+  /// addPreLinkLTODefaultPipeline, and the two coordinate closely.
+  ///
+  /// Note that \p Level cannot be `O0` here. The pipelines produced are
+  /// only intended for use when attempting to optimize code. If frontends
+  /// require some transformations for semantic reasons, they should explicitly
+  /// build them.
+  ModulePassManager buildThinLTODefaultPipeline(OptimizationLevel Level,
+                                            bool DebugLogging = false);
+
   /// Build the default `AAManager` with the default alias analysis pipeline
   /// registered.
   AAManager buildDefaultAAPipeline();
 
   /// \brief Parse a textual pass pipeline description into a \c ModulePassManager.
   ///
   /// The format of the textual pass pipeline description looks something like:
   ///

lib/CodeGen/BackendUtil.cpp

   PassBuilder PB(TM.get(),
     (PGOOpt.RunProfileGen ||
       !PGOOpt.ProfileUseFile.empty()) ?
-        Optional<PGOOptions>(PGOOpt) : None);
+        Optional<PGOOptions>(PGOOpt) : None,
+        CodeGenOpts.EmitSummaryIndex /* PrepareForThinLTO */);
 
   LoopAnalysisManager LAM;
   FunctionAnalysisManager FAM;

lib/LTO/LTOBackend.cpp

else
     RelocModel =
         M.getPICLevel() == PICLevel::NotPIC ? Reloc::Static : Reloc::PIC_;
 
   return std::unique_ptr<TargetMachine>(TheTarget->createTargetMachine(
       TheTriple, Conf.CPU, Features.getString(), Conf.Options, RelocModel,
       Conf.CodeModel, Conf.CGOptLevel));
 }
 
-static void runNewPMPasses(Module &Mod, TargetMachine *TM, unsigned OptLevel) {
+static void runNewPMPasses(Module &Mod, TargetMachine *TM, unsigned OptLevel,
+                           bool IsThinLTO) {
   PassBuilder PB(TM);
   AAManager AA;
 
   // Parse a custom AA pipeline if asked to.
   assert(PB.parseAAPipeline(AA, "default"));
 
   LoopAnalysisManager LAM;
   FunctionAnalysisManager FAM;
static void runNewPMPasses(Module &Mod, TargetMachine *TM, unsigned OptLevel,
   case 2:
     OL = PassBuilder::O2;
     break;
   case 3:
     OL = PassBuilder::O3;
     break;
   }
 
+  if (IsThinLTO)
+    MPM = PB.buildThinLTODefaultPipeline(OL, false /* DebugLogging */);
+  else
     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,
static void runOldPMPasses(Config &Conf, Module &Mod, TargetMachine *TM,
   else
     PMB.populateLTOPassManager(passes);
   passes.run(Mod);
 }
 
 bool opt(Config &Conf, TargetMachine *TM, unsigned Task, Module &Mod,
          bool IsThinLTO, ModuleSummaryIndex *ExportSummary,
          const ModuleSummaryIndex *ImportSummary) {
-  // 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!");
-
   // FIXME: Plumb the combined index into the new pass manager.
   if (!Conf.OptPipeline.empty())
     runNewPMCustomPasses(Mod, TM, Conf.OptPipeline, Conf.AAPipeline,
                          Conf.DisableVerify);
   else if (LTOUseNewPM)
-    runNewPMPasses(Mod, TM, Conf.OptLevel);
+    runNewPMPasses(Mod, TM, Conf.OptLevel, IsThinLTO);
   else
     runOldPMPasses(Conf, Mod, TM, IsThinLTO, ExportSummary, ImportSummary);
   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))

lib/Passes/PassBuilder.cpp

if (RunProfileGen) {
     MPM.addPass(InstrProfiling(Options));
   }
 
   if (!ProfileUseFile.empty())
     MPM.addPass(PGOInstrumentationUse(ProfileUseFile));
 }
 
 ModulePassManager
+PassBuilder::buildThinLTODefaultPipeline(OptimizationLevel Level,
+                                         bool DebugLogging)
+{
+  // FIXME: The summary index is not hooked in the new pass manager yet.
+  // When it's going to be hooked, enable WholeProgramDevirt and LowerTypeTest
+  // here.
+
+  return buildPerModuleDefaultPipeline(Level, DebugLogging,
+                                       true /* PerformThinLTO */);
+}
+
+ModulePassManager
 PassBuilder::buildPerModuleDefaultPipeline(OptimizationLevel Level,
-                                           bool DebugLogging) {
+                                           bool DebugLogging,
+                                           bool PerformThinLTO) {
   assert(Level != O0 && "Must request optimizations for the default pipeline!");
   ModulePassManager MPM(DebugLogging);
 
   // Force any function attributes we want the rest of the pipeline te observe.
   MPM.addPass(ForceFunctionAttrsPass());
 
+  // For ThinLTO there are two passes of indirect call promotion. The
+  // first is during the compile phase when PerformThinLTO=false and
+  // intra-module indirect call targets are promoted. The second is during
+  // the ThinLTO backend when PerformThinLTO=true, when we promote imported
+  // inter-module indirect calls. For that we perform indirect call promotion
+  // earlier in the pass pipeline, here before globalopt. Otherwise imported
+  // available_externally functions look unreferenced and are removed.
+  if (PerformThinLTO)
+    MPM.addPass(PGOIndirectCallPromotion(true /* InLTO */,
+                                         PGOOpt && PGOOpt->SamplePGO &&
+                                         !PGOOpt->ProfileUseFile.empty()));
+
   // Do basic inference of function attributes from known properties of system
   // libraries and other oracles.
   MPM.addPass(InferFunctionAttrsPass());
 
   // Create an early function pass manager to cleanup the output of the
   // frontend.
   FunctionPassManager EarlyFPM(DebugLogging);
   EarlyFPM.addPass(SimplifyCFGPass());
PassBuilder::buildPerModuleDefaultPipeline(OptimizationLevel Level,
 
   // Create a small function pass pipeline to cleanup after all the global
   // optimizations.
   FunctionPassManager GlobalCleanupPM(DebugLogging);
   GlobalCleanupPM.addPass(InstCombinePass());
   GlobalCleanupPM.addPass(SimplifyCFGPass());
   MPM.addPass(createModuleToFunctionPassAdaptor(std::move(GlobalCleanupPM)));
 
-  // Add all the requested passes for PGO Instrumentation, if requested.
-  if (PGOOpt) {
-    assert(PGOOpt->RunProfileGen || PGOOpt->SamplePGO ||
-           !PGOOpt->ProfileUseFile.empty());
-    addPGOInstrPasses(MPM, DebugLogging, Level, PGOOpt->RunProfileGen,
-                      PGOOpt->ProfileGenFile, PGOOpt->ProfileUseFile);
-  }
+  // FIXME: `PrepareForThinLTOUsingPGOSampleProfile`.
+  if (!PerformThinLTO) {
+    // Add all the requested passes for PGO Instrumentation, if requested.
+    if (PGOOpt) {
+      assert(PGOOpt->RunProfileGen || PGOOpt->SamplePGO ||
+             !PGOOpt->ProfileUseFile.empty());
+      addPGOInstrPasses(MPM, DebugLogging, Level, PGOOpt->RunProfileGen,
+                        PGOOpt->ProfileGenFile, PGOOpt->ProfileUseFile);
+    }
 
-  // Indirect call promotion that promotes intra-module targes only.
-  MPM.addPass(PGOIndirectCallPromotion(false, PGOOpt && PGOOpt->SamplePGO));
+    // Indirect call promotion that promotes intra-module targes only.
+    MPM.addPass(PGOIndirectCallPromotion(false, PGOOpt && PGOOpt->SamplePGO));
+  }
 
   // Require the GlobalsAA analysis for the module so we can query it within
   // the CGSCC pipeline.
   MPM.addPass(RequireAnalysisPass<GlobalsAA, Module>());
 
   // Require the ProfileSummaryAnalysis for the module so we can query it within
   // the inliner pass.
   MPM.addPass(RequireAnalysisPass<ProfileSummaryAnalysis, Module>());
PassBuilder::buildPerModuleDefaultPipeline(OptimizationLevel Level,
 
   // Run partial inlining pass to partially inline functions that have
   // large bodies.
   if (RunPartialInlining)
     MPM.addPass(PartialInlinerPass());
 
   // Eliminate externally available functions now that inlining is over -- we
   // won't emit these anyways.
+  if (!PrepareForThinLTO)
+    // Remove avail extern fns and globals definitions if we aren't
+    // compiling an object file for later LTO. For LTO we want to preserve
+    // these so they are eligible for inlining at link-time. Note if they
+    // are unreferenced they will be removed by GlobalDCE later, so
+    // this only impacts referenced available externally globals.
+    // Eventually they will be suppressed during codegen, but eliminating
+    // here enables more opportunity for GlobalDCE as it may make
+    // globals referenced by available external functions dead
+    // and saves running remaining passes on the eliminated functions.
     MPM.addPass(EliminateAvailableExternallyPass());
 
   // Do RPO function attribute inference across the module to forward-propagate
   // attributes where applicable.
   // FIXME: Is this really an optimization rather than a canonicalization?
   MPM.addPass(ReversePostOrderFunctionAttrsPass());
 
+
+  // If we are planning to perform ThinLTO later, let's not bloat the code with
+  // unrolling/vectorization/... now. We'll first run the inliner + CGSCC passes
+  // during ThinLTO and perform the rest of the optimizations afterward.
+  if (PrepareForThinLTO) {
+    // Reduce the size of the IR as much as possible.
+    MPM.addPass(GlobalOptPass());
+
+    // Rename anon globals to be able to export them in the summary.
+    MPM.addPass(NameAnonGlobalPass());
+    return MPM;
+  }
+    
+
   // Re-require GloblasAA here prior to function passes. This is particularly
   // useful as the above will have inlined, DCE'ed, and function-attr
   // propagated everything. We should at this point have a reasonably minimal
   // and richly annotated call graph. By computing aliasing and mod/ref
   // information for all local globals here, the late loop passes and notably
   // the vectorizer will be able to use them to help recognize vectorizable
   // memory operations.
   MPM.addPass(RequireAnalysisPass<GlobalsAA, Module>());
 
+  // Optimize globals now when performing ThinLTO, this enables more
+  // optimizations later.
+  if (PerformThinLTO)
+    MPM.addPass(GlobalOptPass());
+
   FunctionPassManager OptimizePM(DebugLogging);
   OptimizePM.addPass(Float2IntPass());
   // FIXME: We need to run some loop optimizations to re-rotate loops after
   // simplify-cfg and others undo their rotation.
 
   // Optimize the loop execution. These passes operate on entire loop nests
   // rather than on each loop in an inside-out manner, and so they are actually
   // function passes.

test/ThinLTO/X86/error-newpm.ll

-; RUN: opt -module-summary %s -o %t1.bc
-; RUN: not llvm-lto2 run %t1.bc -o %t.o \
-; RUN:     -r=%t1.bc,_tinkywinky,pxl \
-; RUN:     -lto-use-new-pm 2>&1 | FileCheck %s
-
-; CHECK: ThinLTO not supported with the new PM yet!
-
-target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-apple-macosx10.11.0"
-
-define void @tinkywinky() {
-    ret void
-}

test/ThinLTO/X86/newpm-basic.ll

+; RUN: opt -module-summary %s -o %t1.bc
+; RUN: llvm-lto2 run %t1.bc -o %t.o \
+; RUN:     -r=%t1.bc,_tinkywinky,pxl \
+; RUN:     -lto-use-new-pm
+
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-macosx10.11.0"
+
+define void @tinkywinky() {
+    ret void
+}