[PartialInlining] introduce an internal option to add partial inlining pass in the pipeline (off by default for now)

[davidxl]

Summary

This is the final preparation step to finally turn on partial inlining in one of the default optimization pipeline.

It is off by default for now, so there is no functional change to the compiler behavior for now. Adding the option make it more convenient for the feature to be widely tested before being enabled.

[davide]

Can you make the same change in the future pass manager pipeline?

[davidxl]

added internal option for new PM as well.

[davide]

I'm not entirely sure whether you need cl::ZeroOrMore. Few comments, with that, LG.
Feel free to submit once addressed without another round trip.

Thanks!

lib/Passes/PassBuilder.cpp

153–156

For consistency with other options (i.e. GVNHoist), I'd use enable-npm-*

lib/Transforms/IPO/PassManagerBuilder.cpp

47–50

Same here, enable-partial-inlining.

lib/Passes/PassBuilder.cpp

 #include "llvm/Transforms/Vectorize/SLPVectorizer.h"
 
 #include <type_traits>
 
 using namespace llvm;
 
 static cl::opt<unsigned> MaxDevirtIterations("pm-max-devirt-iterations",
                                              cl::ReallyHidden, cl::init(4));
+static cl::opt<bool>
+RunPartialInlining("npm-partial-inlining", cl::init(false),
+                   cl::Hidden, cl::ZeroOrMore,
+                   cl::desc("Run Partial inlinining pass"));
 
 static cl::opt<bool> EnableGVNHoist(
     "enable-npm-gvn-hoist", cl::init(false), cl::Hidden,
     cl::desc("Enable the GVN hoisting pass for the new PM (default = off)"));
 
 static Regex DefaultAliasRegex("^(default|lto-pre-link|lto)<(O[0123sz])>$");
 
 static bool isOptimizingForSize(PassBuilder::OptimizationLevel Level) {

   MPM.addPass(
       createModuleToPostOrderCGSCCPassAdaptor(createDevirtSCCRepeatedPass(
           std::move(MainCGPipeline), MaxDevirtIterations, DebugLogging)));
 
   // This ends the canonicalization and simplification phase of the pipeline.
   // At this point, we expect to have canonical and simple IR which we begin
   // *optimizing* for efficient execution going forward.
 
+  // 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.
   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());

lib/Transforms/IPO/PassManagerBuilder.cpp

 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Scalar/GVN.h"
 #include "llvm/Transforms/Scalar/SimpleLoopUnswitch.h"
 #include "llvm/Transforms/Vectorize.h"
 
 using namespace llvm;
 
 static cl::opt<bool>
+RunPartialInlining("partial-inlining", cl::init(false),
+                   cl::Hidden, cl::ZeroOrMore,
+                   cl::desc("Run Partial inlinining pass"));
+
+static cl::opt<bool>
 RunLoopVectorization("vectorize-loops", cl::Hidden,
                      cl::desc("Run the Loop vectorization passes"));
 
 static cl::opt<bool>
 RunSLPVectorization("vectorize-slp", cl::Hidden,
                     cl::desc("Run the SLP vectorization passes"));
 
 static cl::opt<bool>

 
   addExtensionsToPM(EP_CGSCCOptimizerLate, MPM);
   addFunctionSimplificationPasses(MPM);
 
   // FIXME: This is a HACK! The inliner pass above implicitly creates a CGSCC
   // pass manager that we are specifically trying to avoid. To prevent this
   // we must insert a no-op module pass to reset the pass manager.
   MPM.add(createBarrierNoopPass());
+  if (RunPartialInlining)
+    MPM.add(createPartialInliningPass());
 
   if (!DisableUnitAtATime && OptLevel > 1 && !PrepareForLTO &&
       !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.