[AMDGPU] Add GlobalOpt parameter to Always Inliner pass

[rampitec]

Summary

If set to false it does not remove global aliases. With this parameter
set to false it should be safe to run the pass before link.

[arsenm]

LGTM

llvm/trunk/lib/Target/AMDGPU/AMDGPU.h

 // Passes common to R600 and SI
 FunctionPass *createAMDGPUPromoteAlloca(const TargetMachine *TM = nullptr);
 void initializeAMDGPUPromoteAllocaPass(PassRegistry&);
 extern char &AMDGPUPromoteAllocaID;
 
 Pass *createAMDGPUStructurizeCFGPass();
 FunctionPass *createAMDGPUISelDag(TargetMachine &TM,
                                   CodeGenOpt::Level OptLevel);
-ModulePass *createAMDGPUAlwaysInlinePass();
+ModulePass *createAMDGPUAlwaysInlinePass(bool GlobalOpt = true);
 ModulePass *createAMDGPUOpenCLImageTypeLoweringPass();
 FunctionPass *createAMDGPUAnnotateUniformValues();
 
 ModulePass* createAMDGPUUnifyMetadataPass();
 void initializeAMDGPUUnifyMetadataPass(PassRegistry&);
 extern char &AMDGPUUnifyMetadataID;
 
 void initializeSIFixControlFlowLiveIntervalsPass(PassRegistry&);

llvm/trunk/lib/Target/AMDGPU/AMDGPUAlwaysInlinePass.cpp

 
 using namespace llvm;
 
 namespace {
 
 class AMDGPUAlwaysInline : public ModulePass {
   static char ID;
 
+  bool GlobalOpt;
+
 public:
-  AMDGPUAlwaysInline() : ModulePass(ID) { }
+  AMDGPUAlwaysInline(bool GlobalOpt) : ModulePass(ID), GlobalOpt(GlobalOpt) { }
   bool runOnModule(Module &M) override;
   StringRef getPassName() const override { return "AMDGPU Always Inline Pass"; }
 };
 
 } // End anonymous namespace
 
 char AMDGPUAlwaysInline::ID = 0;
 
 bool AMDGPUAlwaysInline::runOnModule(Module &M) {
   std::vector<GlobalAlias*> AliasesToRemove;
   std::vector<Function *> FuncsToClone;
 
   for (GlobalAlias &A : M.aliases()) {
     if (Function* F = dyn_cast<Function>(A.getAliasee())) {
       A.replaceAllUsesWith(F);
       AliasesToRemove.push_back(&A);
     }
   }
 
+  if (GlobalOpt) {
     for (GlobalAlias* A : AliasesToRemove) {
       A->eraseFromParent();
     }
+  }
 
   for (Function &F : M) {
     if (!F.hasLocalLinkage() && !F.isDeclaration() && !F.use_empty() &&
         !F.hasFnAttribute(Attribute::NoInline))
       FuncsToClone.push_back(&F);
   }
 
   for (Function *F : FuncsToClone) {
     ValueToValueMapTy VMap;
     Function *NewFunc = CloneFunction(F, VMap);
     NewFunc->setLinkage(GlobalValue::InternalLinkage);
     F->replaceAllUsesWith(NewFunc);
   }
 
   for (Function &F : M) {
     if (F.hasLocalLinkage() && !F.hasFnAttribute(Attribute::NoInline)) {
       F.addFnAttr(Attribute::AlwaysInline);
     }
   }
   return false;
 }
 
-ModulePass *llvm::createAMDGPUAlwaysInlinePass() {
-  return new AMDGPUAlwaysInline();
+ModulePass *llvm::createAMDGPUAlwaysInlinePass(bool GlobalOpt) {
+  return new AMDGPUAlwaysInline(GlobalOpt);
 }

llvm/trunk/lib/Target/AMDGPU/AMDGPUTargetMachine.cpp

[Internalize, EarlyInline, AMDGPUAA](const PassManagerBuilder &,
               return true;
             }
           }
           return !GV.use_empty();
         }));
         PM.add(createGlobalDCEPass());
       }
       if (EarlyInline)
-        PM.add(createAMDGPUAlwaysInlinePass());
+        PM.add(createAMDGPUAlwaysInlinePass(false));
   });
 
   Builder.addExtension(
     PassManagerBuilder::EP_EarlyAsPossible,
     [AMDGPUAA](const PassManagerBuilder &, legacy::PassManagerBase &PM) {
       if (AMDGPUAA) {
         PM.add(createAMDGPUAAWrapperPass());
         PM.add(createAMDGPUExternalAAWrapperPass());

llvm/trunk/test/CodeGen/AMDGPU/early-inline.ll

 ; RUN: opt -mtriple=amdgcn-- -O1 -S -inline-threshold=1 -amdgpu-early-inline-all %s | FileCheck %s
 
+; CHECK: @c_alias
+@c_alias = alias i32 (i32), i32 (i32)* @callee
+
 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
   ret i32 %mul5