[LightAttributor] Run only as CGSCCPass.

[fhahn]

Summary

Depends on D152081.

[nikic]

llvm/lib/Passes/PassBuilderPipelines.cpp

887

Supporting the SkipNonRecursive flag should improve compile-time a good bit. We only need to infer attributes at this pipeline position for non-trivial SCCs.

[arsenm]

llvm/lib/Passes/PassBuilderPipelines.cpp

260

Can you combine this with the attributor-enable flag? I dislike having various overlapping pass control flags

[fhahn]

llvm/lib/Passes/PassBuilderPipelines.cpp

260

Will do I was hoping for more promising compile-time data to have clear path towards enabling it for attribute inference, but at the moment the data doesn't look very promising unfortunately

887

When we use PostOrderFunctionAttrsPass(/*SkipNonRecursive*/ true) and LightweightAttributorCGSCCPass only at the other position, there's unfortunately still a ~2% regression: https://llvm-compile-time-tracker.com/compare.php?from=3a458256ee22a0e7c31529de42fa6caa263d88fe&to=3e8ea897fa2533f52488b7ceab27f6b0d91599dc&stat=instructions%3Au

[jdoerfert]

llvm/lib/Passes/PassBuilderPipelines.cpp

887

We'll add a skip non recursive option. @tianshilei1992 and I will look into potential regressions.

llvm/lib/Passes/PassBuilderPipelines.cpp

static cl::opt<bool>
     EnableMatrix("enable-matrix", cl::init(false), cl::Hidden,
                  cl::desc("Enable lowering of the matrix intrinsics"));
 
 static cl::opt<bool> EnableConstraintElimination(
     "enable-constraint-elimination", cl::init(true), cl::Hidden,
     cl::desc(
         "Enable pass to eliminate conditions based on linear constraints"));
 
+static cl::opt<bool> UseLightAttributor("enable-light-attributor",
+                                        cl::init(true), cl::Hidden,
+                                        cl::desc(""));
+
 static cl::opt<AttributorRunOption> AttributorRun(
     "attributor-enable", cl::Hidden, cl::init(AttributorRunOption::NONE),
     cl::desc("Enable the attributor inter-procedural deduction pass"),
     cl::values(clEnumValN(AttributorRunOption::ALL, "all",
                           "enable all attributor runs"),
                clEnumValN(AttributorRunOption::MODULE, "module",
                           "enable module-wide attributor runs"),
                clEnumValN(AttributorRunOption::CGSCC, "cgscc",
PassBuilder::buildInlinerPipeline(OptimizationLevel Level,
 
   if (AttributorRun & AttributorRunOption::CGSCC)
     MainCGPipeline.addPass(AttributorCGSCCPass());
 
   // Deduce function attributes. We do another run of this after the function
   // simplification pipeline, so this only needs to run when it could affect the
   // function simplification pipeline, which is only the case with recursive
   // functions.
-  MainCGPipeline.addPass(PostOrderFunctionAttrsPass(/*SkipNonRecursive*/ true));
+  if (UseLightAttributor)
+    MainCGPipeline.addPass(LightweightAttributorCGSCCPass());
+  else
+    MainCGPipeline.addPass(
+        PostOrderFunctionAttrsPass(/*SkipNonRecursive*/ true));
 
   // When at O3 add argument promotion to the pass pipeline.
   // FIXME: It isn't at all clear why this should be limited to O3.
   if (Level == OptimizationLevel::O3)
     MainCGPipeline.addPass(ArgumentPromotionPass());
 
   // Try to perform OpenMP specific optimizations. This is a (quick!) no-op if
   // there are no OpenMP runtime calls present in the module.
   if (Level == OptimizationLevel::O2 || Level == OptimizationLevel::O3)
     MainCGPipeline.addPass(OpenMPOptCGSCCPass());
 
   invokeCGSCCOptimizerLateEPCallbacks(MainCGPipeline, Level);
 
   // Add the core function simplification pipeline nested inside the
   // CGSCC walk.
   MainCGPipeline.addPass(createCGSCCToFunctionPassAdaptor(
       buildFunctionSimplificationPipeline(Level, Phase),
       PTO.EagerlyInvalidateAnalyses, /*NoRerun=*/true));
 
   // Finally, deduce any function attributes based on the fully simplified
   // function.
+  if (UseLightAttributor)
+    MainCGPipeline.addPass(LightweightAttributorCGSCCPass());
+  else
     MainCGPipeline.addPass(PostOrderFunctionAttrsPass());
 
   // Mark that the function is fully simplified and that it shouldn't be
   // simplified again if we somehow revisit it due to CGSCC mutations unless
   // it's been modified since.
   MainCGPipeline.addPass(createCGSCCToFunctionPassAdaptor(
       RequireAnalysisPass<ShouldNotRunFunctionPassesAnalysis, Function>()));
 
   MainCGPipeline.addPass(CoroSplitPass(Level != OptimizationLevel::O0));