Move "Eliminate Available Externally" immediately after the inliner

[mehdi_amini]

Summary

This pass is supposed to reduce the size of the IR for compile time
purpose. We should run it ASAP.

[tejohnson]

lib/Transforms/IPO/PassManagerBuilder.cpp

410

Does the same concern apply to ThinLTO (want to preserve them for inlining later on as in LTO)? If not, why?

[mehdi_amini]

Preserve available_externally for ThinLTO

[mehdi_amini]

lib/Transforms/IPO/PassManagerBuilder.cpp

410

Clang will set PrepareForLTO even when -flto=thin. But I'm not sure if it is a good thing, we may want to distinguish between the two so it seems better to me to not rely on PrepareForLTO in ThinLTO mode.

[mehdi_amini]

Remove unexpected change that slipped in

[tejohnson]

LGTM

lib/Transforms/IPO/PassManagerBuilder.cpp

410

Ah, I had forgotten that PrepareForLTO included all -flto settings. Now that we have PrepareForThinLTO I like the idea of separating them. Probably should then change PrepareForLTO to PrepareForFullLTO to disambiguate (not here, but as a separate cleanup).

[mehdi_amini]

r268394

include/llvm/IR/ModuleSummaryIndex.h

struct GVFlags {
     /// index, to disambiguate from other values with the same name.
     /// In the future this will be used to update and optimize linkage
     /// types based on global summary-based analysis.
     unsigned Linkage : 4;
 
     /// Indicate if the global value is located in a specific section.
     unsigned HasSection : 1;
 
+    /// Indicate if the global value can be inlined
+    unsigned HasSection : 1;
+
     /// Convenience Constructors
     explicit GVFlags(GlobalValue::LinkageTypes Linkage, bool HasSection)
         : Linkage(Linkage), HasSection(HasSection) {}
     GVFlags(const GlobalValue &GV)
         : Linkage(GV.getLinkage()), HasSection(GV.hasSection()) {}
   };
 
 private:

lib/Transforms/IPO/PassManagerBuilder.cpp

void PassManagerBuilder::populateModulePassManager(
 
   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 (!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.
+    // 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.add(createEliminateAvailableExternallyPass());
+
   if (!DisableUnitAtATime)
     MPM.add(createReversePostOrderFunctionAttrsPass());
 
   // 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.add(createGlobalOptimizerPass());
     // Rename anon function to be able to export them in the summary.
     MPM.add(createNameAnonFunctionPass());
     return;
   }
 
   // Scheduling LoopVersioningLICM when inlining is over, because after that
   // we may see more accurate aliasing. Reason to run this late is that too
   // early versioning may prevent further inlining due to increase of code
   // size. By placing it just after inlining other optimizations which runs 
   // later might get benefit of no-alias assumption in clone loop. 
   if (UseLoopVersioningLICM) {
     MPM.add(createLoopVersioningLICMPass());    // Do LoopVersioningLICM
     MPM.add(createLICMPass());                  // Hoist loop invariants
   }
 
-  if (!DisableUnitAtATime && OptLevel > 1 && !PrepareForLTO)
-    // 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.add(createEliminateAvailableExternallyPass());
-
   if (PerformThinLTO) {
     // Remove dead fns and globals. Removing unreferenced functions could lead
     // to more opportunities for globalopt.
     MPM.add(createGlobalDCEPass());
     MPM.add(createGlobalOptimizerPass());
     // Remove dead fns and globals after globalopt.
     MPM.add(createGlobalDCEPass());
     addFunctionSimplificationPasses(MPM);

test/Other/pass-pipelines.ll

 ; and run of LICM here.
 ; CHECK-O2-NOT: Manager
 ; CHECK-O2: Loop Pass Manager
 ; CHECK-O2-NEXT: Loop Invariant Code Motion
 ; CHECK-O2-NOT: Manager
 ; Next we break out of the main Function passes inside the CGSCC pipeline with
 ; a barrier pass.
 ; CHECK-O2: A No-Op Barrier Pass
-; Inferring function attribute should be immediately after the CGSCC pipeline.
+; Reduce the size of the IR ASAP after the inliner.
+; CHECK-O2-NEXT: Eliminate Available Externally
+; Inferring function attribute should be right after the CGSCC pipeline, before
+; any other optimizations/analyses.
 ; CHECK-O2-NEXT: CallGraph
 ; CHECK-O2-NEXT: Deduce function attributes in RPO
 ; CHECK-O2-NOT: Manager
 ; Next is the late function pass pipeline.
 ; CHECK-O2: FunctionPass Manager
 ; CHECK-O2-NOT: Manager
 ; We rotate loops prior to vectorization.
 ; CHECK-O2: Loop Pass Manager