Always run GlobalDCE before the inliner

[eugenis]

Summary

Inliner, as an SCC pass, does not run on functions that are not reachable from the callgraph entry node.
Because of this, it may fail to inline an alwaysinline function.

The change runs GlobalDCE before inlining to make sure that this does not happen.
See the testcase for a sample input triggering this issue (the interesting case here is -O1, reproducing with both opt -O1 and clang -O1).

[bruno]

Hi Evgeniy,

Did you run the test-suite? What is the overall compile time impact of this patch?

Thanks,

[eugenis]

One more test + -O0 support in opt.

[eugenis]

I'll run the test-suite and be back with the results.

[eugenis]

Also see this change, which helps Clang tests deal with the new behavior of -O0:
http://reviews.llvm.org/D11238

[hfinkel]

Why does it matter if we don't inline an always_inline function into dead code?

[eugenis]

To answer your question (better late than never):
https://groups.google.com/forum/#!msg/llvm-dev/gd5iud_trcA/UJ0JONSFAQAJ
http://reviews.llvm.org/D12087

I'm going to abandon this change in favor of D12087

lib/Transforms/IPO/PassManagerBuilder.cpp

 }
 
 void PassManagerBuilder::populateModulePassManager(
     legacy::PassManagerBase &MPM) {
   // If all optimizations are disabled, just run the always-inline pass and,
   // if enabled, the function merging pass.
   if (OptLevel == 0) {
     if (Inliner) {
+      MPM.add(createGlobalDCEPass());         // Remove dead fns and globals.
       MPM.add(Inliner);
       Inliner = nullptr;
     }
 
     // FIXME: The BarrierNoopPass is a HACK! The inliner pass above implicitly
     // creates a CGSCC pass manager, but we don't want to add extensions into
     // that pass manager. To prevent this we insert a no-op module pass to reset
     // the pass manager to get the same behavior as EP_OptimizerLast in non-O0
if (!DisableUnitAtATime) {
     addExtensionsToPM(EP_Peephole, MPM);
     MPM.add(createCFGSimplificationPass());   // Clean up after IPCP & DAE
   }
 
   // Start of CallGraph SCC passes.
   if (!DisableUnitAtATime)
     MPM.add(createPruneEHPass());             // Remove dead EH info
   if (Inliner) {
+    MPM.add(createGlobalDCEPass());         // Remove dead fns and globals.
     MPM.add(Inliner);
     Inliner = nullptr;
   }
   if (!DisableUnitAtATime)
     MPM.add(createFunctionAttrsPass());       // Set readonly/readnone attrs
   if (OptLevel > 2)
     MPM.add(createArgumentPromotionPass());   // Scalarize uninlined fn args
 
void PassManagerBuilder::addLTOOptimizationPasses(legacy::PassManagerBase &PM) {
   // function pointers.  When this happens, we often have to resolve varargs
   // calls, etc, so let instcombine do this.
   PM.add(createInstructionCombiningPass());
   addExtensionsToPM(EP_Peephole, PM);
 
   // Inline small functions
   bool RunInliner = Inliner;
   if (RunInliner) {
+    PM.add(createGlobalDCEPass());         // Remove dead fns and globals.
     PM.add(Inliner);
     Inliner = nullptr;
   }
 
   PM.add(createPruneEHPass());   // Remove dead EH info.
 
   // Optimize globals again if we ran the inliner.
   if (RunInliner)

test/Transforms/Inline/always-inline-O0.ll

+; RUN: opt < %s -O0 -S | FileCheck %s
+; CHECK-NOT: call{{.*}}AAA
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-linux-gnu"
+
+define void @AAA() alwaysinline {
+  ret void
+}
+
+define internal void @BBB() {
+  call void @CCC()
+  call void @AAA()
+  ret void
+}
+
+define internal void @CCC() {
+  call void @AAA()
+  ret void
+}

test/Transforms/Inline/always-inline-O1.ll

+; RUN: opt < %s -O1 -S | FileCheck %s
+; RUN: opt < %s -O2 -S | FileCheck %s
+; RUN: opt < %s -O3 -S | FileCheck %s
+; CHECK-NOT: call{{.*}}BBB
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+declare void @AAA()
+
+define void @BBB() alwaysinline {
+entry:
+  call void @AAA()
+  ret void
+}
+
+define internal void @CCC()  {
+entry:
+  call void @BBB()
+  ret void
+}
+
+define void @DDD(i8* %x) {
+entry:
+  %a = load i8, i8* %x, align 4
+  %cmpa = icmp ne i8 %a, 1
+  br i1 %cmpa, label %return, label %if.end
+
+if.end:
+  %b = load i8, i8* %x, align 4
+  %cmpb = icmp eq i8 %b, 1
+  br i1 %cmpb, label %return, label %if.end.2
+
+if.end.2:
+  call void @CCC()
+  br label %return
+
+return:
+  ret void
+}

tools/opt/opt.cpp

 DisableOptimizations("disable-opt",
                      cl::desc("Do not run any optimization passes"));
 
 static cl::opt<bool>
 StandardLinkOpts("std-link-opts",
                  cl::desc("Include the standard link time optimizations"));
 
 static cl::opt<bool>
+OptLevelO0("O0",
+           cl::desc("Optimization level 0. Similar to clang -O0"));
+
+static cl::opt<bool>
 OptLevelO1("O1",
            cl::desc("Optimization level 1. Similar to clang -O1"));
 
 static cl::opt<bool>
 OptLevelO2("O2",
            cl::desc("Optimization level 2. Similar to clang -O2"));
 
 static cl::opt<bool>
if (DL.isDefault() && !DefaultDataLayout.empty()) {
     M->setDataLayout(DefaultDataLayout);
   }
 
   // Add internal analysis passes from the target machine.
   Passes.add(createTargetTransformInfoWrapperPass(TM ? TM->getTargetIRAnalysis()
                                                      : TargetIRAnalysis()));
 
   std::unique_ptr<legacy::FunctionPassManager> FPasses;
-  if (OptLevelO1 || OptLevelO2 || OptLevelOs || OptLevelOz || OptLevelO3) {
+  if (OptLevelO0 || OptLevelO1 || OptLevelO2 || OptLevelOs || OptLevelOz || OptLevelO3) {
     FPasses.reset(new legacy::FunctionPassManager(M.get()));
     FPasses->add(createTargetTransformInfoWrapperPass(
         TM ? TM->getTargetIRAnalysis() : TargetIRAnalysis()));
   }
 
   if (PrintBreakpoints) {
     // Default to standard output.
     if (!Out) {
#endif
   // Create a new optimization pass for each one specified on the command line
   for (unsigned i = 0; i < PassList.size(); ++i) {
     if (StandardLinkOpts &&
         StandardLinkOpts.getPosition() < PassList.getPosition(i)) {
       AddStandardLinkPasses(Passes);
       StandardLinkOpts = false;
     }
 
+    if (OptLevelO0 && OptLevelO0.getPosition() < PassList.getPosition(i)) {
+      AddOptimizationPasses(Passes, *FPasses, 0, 0);
+      OptLevelO0 = false;
+    }
+
     if (OptLevelO1 && OptLevelO1.getPosition() < PassList.getPosition(i)) {
       AddOptimizationPasses(Passes, *FPasses, 1, 0);
       OptLevelO1 = false;
     }
 
     if (OptLevelO2 && OptLevelO2.getPosition() < PassList.getPosition(i)) {
       AddOptimizationPasses(Passes, *FPasses, 2, 0);
       OptLevelO2 = false;
if (PrintEachXForm)
           createPrintModulePass(errs(), "", PreserveAssemblyUseListOrder));
   }
 
   if (StandardLinkOpts) {
     AddStandardLinkPasses(Passes);
     StandardLinkOpts = false;
   }
 
+  if (OptLevelO0)
+    AddOptimizationPasses(Passes, *FPasses, 0, 0);
+
   if (OptLevelO1)
     AddOptimizationPasses(Passes, *FPasses, 1, 0);
 
   if (OptLevelO2)
     AddOptimizationPasses(Passes, *FPasses, 2, 0);
 
   if (OptLevelOs)
     AddOptimizationPasses(Passes, *FPasses, 2, 1);
 
   if (OptLevelOz)
     AddOptimizationPasses(Passes, *FPasses, 2, 2);
 
   if (OptLevelO3)
     AddOptimizationPasses(Passes, *FPasses, 3, 0);
 
-  if (OptLevelO1 || OptLevelO2 || OptLevelOs || OptLevelOz || OptLevelO3) {
+  if (OptLevelO0 || OptLevelO1 || OptLevelO2 || OptLevelOs || OptLevelOz || OptLevelO3) {
     FPasses->doInitialization();
     for (Function &F : *M)
       FPasses->run(F);
     FPasses->doFinalization();
   }
 
   // Check that the module is well formed on completion of optimization
   if (!NoVerify && !VerifyEach)