[AMDGPU] Split -amdgpu-early-inline-all option

[rampitec]

Summary

Previously it was covered by the internalization. It turns out we cannot
run internalizer in FE, it break separate compilation tests. Thus early
inliner gets its own option.

[kzhuravl]

LGTM.

lib/Target/AMDGPU/AMDGPUTargetMachine.cpp

 
 // Option to run internalize pass.
 static cl::opt<bool> InternalizeSymbols(
   "amdgpu-internalize-symbols",
   cl::desc("Enable elimination of non-kernel functions and unused globals"),
   cl::init(false),
   cl::Hidden);
 
+// Option to inline all early.
+static cl::opt<bool> EarlyInlineAll(
+  "amdgpu-early-inline-all",
+  cl::desc("Inline all functions early"),
+  cl::init(false),
+  cl::Hidden);
+
 static cl::opt<bool> EnableSDWAPeephole(
   "amdgpu-sdwa-peephole",
   cl::desc("Enable SDWA peepholer"),
   cl::init(false));
 
 // Enable address space based alias analysis
 static cl::opt<bool> EnableAMDGPUAliasAnalysis("enable-amdgpu-aa", cl::Hidden,
   cl::desc("Enable AMDGPU Alias Analysis"),

 }
 
 void AMDGPUTargetMachine::adjustPassManager(PassManagerBuilder &Builder) {
   Builder.DivergentTarget = true;
 
   bool Internalize = InternalizeSymbols &&
                      (getOptLevel() > CodeGenOpt::None) &&
                      (getTargetTriple().getArch() == Triple::amdgcn);
+  bool EarlyInline = EarlyInlineAll &&
+                     (getOptLevel() > CodeGenOpt::None);
   bool AMDGPUAA = EnableAMDGPUAliasAnalysis && getOptLevel() > CodeGenOpt::None;
 
   Builder.addExtension(
     PassManagerBuilder::EP_ModuleOptimizerEarly,
-    [Internalize, AMDGPUAA](const PassManagerBuilder &,
+    [Internalize, EarlyInline, AMDGPUAA](const PassManagerBuilder &,
                                          legacy::PassManagerBase &PM) {
       if (AMDGPUAA) {
         PM.add(createAMDGPUAAWrapperPass());
         PM.add(createAMDGPUExternalAAWrapperPass());
       }
       PM.add(createAMDGPUUnifyMetadataPass());
       if (Internalize) {
         PM.add(createInternalizePass([=](const GlobalValue &GV) -> bool {
           if (const Function *F = dyn_cast<Function>(&GV)) {
[Internalize, EarlyInline, AMDGPUAA](const PassManagerBuilder &,
             case CallingConv::AMDGPU_KERNEL:
             case CallingConv::SPIR_KERNEL:
               return true;
             }
           }
           return !GV.use_empty();
         }));
         PM.add(createGlobalDCEPass());
-        PM.add(createAMDGPUAlwaysInlinePass());
       }
+      if (EarlyInline)
+        PM.add(createAMDGPUAlwaysInlinePass());
   });
 
   Builder.addExtension(
     PassManagerBuilder::EP_EarlyAsPossible,
     [AMDGPUAA](const PassManagerBuilder &, legacy::PassManagerBase &PM) {
       if (AMDGPUAA) {
         PM.add(createAMDGPUAAWrapperPass());
         PM.add(createAMDGPUExternalAAWrapperPass());

test/CodeGen/AMDGPU/early-inline.ll

-; RUN: opt -mtriple=amdgcn-- -O1 -S -inline-threshold=1 -amdgpu-internalize-symbols %s | FileCheck %s
+; RUN: opt -mtriple=amdgcn-- -O1 -S -inline-threshold=1 -amdgpu-early-inline-all %s | FileCheck %s
 
 define i32 @callee(i32 %x) {
 entry:
   %mul1 = mul i32 %x, %x
   %mul2 = mul i32 %mul1, %x
   %mul3 = mul i32 %mul1, %mul2
   %mul4 = mul i32 %mul3, %mul2
   %mul5 = mul i32 %mul4, %mul3