Address comments from nocchijiang

Author: kyulee-com

llvm/include/llvm/Transforms/IPO/GlobalMergeFunctions.h renamed to llvm/include/llvm/CodeGen/GlobalMergeFunctions.h

@@ -22,11 +22,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_TRANSFORMS_IPO_GLOBALMERGEFUNCTIONS_H
-#define LLVM_TRANSFORMS_IPO_GLOBALMERGEFUNCTIONS_H
+#ifndef LLVM_CODEGEN_GLOBALMERGEFUNCTIONS_H
+#define LLVM_CODEGEN_GLOBALMERGEFUNCTIONS_H
 
 #include "llvm/CGData/StableFunctionMap.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
 
 enum class HashFunctionMode {
@@ -46,28 +47,24 @@ using ParamLocsVecTy = SmallVector<ParamLocs, 8>;
 /// GlobalMergeFunc is a ModulePass that implements a function merging mechanism
 /// using stable function hashes. It identifies and merges functions with
 /// matching hashes across modules to optimize binary size.
-class GlobalMergeFunc : public ModulePass {
+class GlobalMergeFunc {
   HashFunctionMode MergerMode = HashFunctionMode::Local;
 
   std::unique_ptr<StableFunctionMap> LocalFunctionMap;
 
-public:
-  static char ID;
+  const ModuleSummaryIndex *Index;
 
+public:
   /// The suffix used to identify the merged function that parameterizes
   /// the constant values. Note that the original function, without this suffix,
   /// becomes a thunk supplying contexts to the merged function via parameters.
   static constexpr const char MergingInstanceSuffix[] = ".Tgm";
 
-  GlobalMergeFunc();
-
-  StringRef getPassName() const override;
-
-  void getAnalysisUsage(AnalysisUsage &AU) const override;
+  GlobalMergeFunc(const ModuleSummaryIndex *Index) : Index(Index){};
 
   void initializeMergerMode(const Module &M);
 
-  bool runOnModule(Module &M) override;
+  bool run(Module &M);
 
   /// Analyze module to create stable function into LocalFunctionMap.
   void analyze(Module &M);
@@ -79,5 +76,10 @@ class GlobalMergeFunc : public ModulePass {
   bool merge(Module &M, const StableFunctionMap *FunctionMap);
 };
 
+/// Global function merging pass for new pass manager.
+struct GlobalMergeFuncPass : public PassInfoMixin<GlobalMergeFuncPass> {
+  PreservedAnalyses run(Module &M, AnalysisManager<Module> &);
+};
+
 } // end namespace llvm
-#endif // LLVM_TRANSFORMS_IPO_GLOBALMERGEFUNCTIONS_H
+#endif // LLVM_CODEGEN_GLOBALMERGEFUNCTIONS_H

llvm/include/llvm/CodeGen/Passes.h

@@ -507,6 +507,9 @@ namespace llvm {
   /// This pass frees the memory occupied by the MachineFunction.
   FunctionPass *createFreeMachineFunctionPass();
 
+  /// This pass performs merging similar functions globally.
+  ModulePass *createGlobalMergeFuncPass();
+
   /// This pass performs outlining on machine instructions directly before
   /// printing assembly.
   ModulePass *createMachineOutlinerPass(bool RunOnAllFunctions = true);

llvm/include/llvm/InitializePasses.h

@@ -123,7 +123,7 @@ void initializeGCEmptyBasicBlocksPass(PassRegistry &);
 void initializeGCMachineCodeAnalysisPass(PassRegistry &);
 void initializeGCModuleInfoPass(PassRegistry &);
 void initializeGVNLegacyPassPass(PassRegistry &);
-void initializeGlobalMergeFuncPass(PassRegistry &);
+void initializeGlobalMergeFuncPassWrapperPass(PassRegistry &);
 void initializeGlobalMergePass(PassRegistry &);
 void initializeGlobalsAAWrapperPassPass(PassRegistry &);
 void initializeHardwareLoopsLegacyPass(PassRegistry &);

llvm/include/llvm/Passes/CodeGenPassBuilder.h

@@ -35,6 +35,7 @@
 #include "llvm/CodeGen/FinalizeISel.h"
 #include "llvm/CodeGen/GCMetadata.h"
 #include "llvm/CodeGen/GlobalMerge.h"
+#include "llvm/CodeGen/GlobalMergeFunctions.h"
 #include "llvm/CodeGen/IndirectBrExpand.h"
 #include "llvm/CodeGen/InterleavedAccess.h"
 #include "llvm/CodeGen/InterleavedLoadCombine.h"
@@ -713,6 +714,9 @@ void CodeGenPassBuilder<Derived, TargetMachineT>::addIRPasses(
   // Convert conditional moves to conditional jumps when profitable.
   if (getOptLevel() != CodeGenOptLevel::None && !Opt.DisableSelectOptimize)
     addPass(SelectOptimizePass(&TM));
+
+  if (Opt.EnableGlobalMergeFunc)
+    addPass(GlobalMergeFuncPass());
 }
 
 /// Turn exception handling constructs into something the code generators can

llvm/include/llvm/Passes/MachinePassRegistry.def

@@ -29,6 +29,7 @@ MODULE_PASS("jmc-instrumenter", JMCInstrumenterPass())
 MODULE_PASS("lower-emutls", LowerEmuTLSPass())
 MODULE_PASS("pre-isel-intrinsic-lowering", PreISelIntrinsicLoweringPass())
 MODULE_PASS("shadow-stack-gc-lowering", ShadowStackGCLoweringPass())
+MODULE_PASS("global-merge-func", GlobalMergeFuncPass())
 #undef MODULE_PASS
 
 #ifndef FUNCTION_ANALYSIS

llvm/include/llvm/Target/CGPassBuilderOption.h

@@ -31,6 +31,7 @@ struct CGPassBuilderOption {
   bool DisableVerify = false;
   bool EnableImplicitNullChecks = false;
   bool EnableBlockPlacementStats = false;
+  bool EnableGlobalMergeFunc = false;
   bool EnableMachineFunctionSplitter = false;
   bool MISchedPostRA = false;
   bool EarlyLiveIntervals = false;

llvm/include/llvm/Transforms/IPO.h

@@ -55,11 +55,6 @@ enum class PassSummaryAction {
   Export, ///< Export information to summary.
 };
 
-/// createGlobalMergeFuncPass - This pass generates merged instances by
-/// parameterizing distinct constants across similar functions, utilizing stable
-/// function hash information.
-Pass *createGlobalMergeFuncPass();
-
 } // End llvm namespace
 
 #endif

llvm/lib/CodeGen/CMakeLists.txt

@@ -71,6 +71,7 @@ add_llvm_component_library(LLVMCodeGen
   GCMetadataPrinter.cpp
   GCRootLowering.cpp
   GlobalMerge.cpp
+  GlobalMergeFunctions.cpp
   HardwareLoops.cpp
   IfConversion.cpp
   ImplicitNullChecks.cpp

llvm/lib/Transforms/IPO/GlobalMergeFunctions.cpp renamed to llvm/lib/CodeGen/GlobalMergeFunctions.cpp

@@ -10,7 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Transforms/IPO/GlobalMergeFunctions.h"
+#include "llvm/CodeGen/GlobalMergeFunctions.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/ModuleSummaryAnalysis.h"
 #include "llvm/CGData/CodeGenData.h"
@@ -56,8 +56,6 @@ static cl::opt<unsigned> GlobalMergingExtraThreshold(
              "to be considered beneficial."),
     cl::init(0), cl::Hidden);
 
-extern cl::opt<bool> EnableGlobalMergeFunc;
-
 STATISTIC(NumMismatchedFunctionHash,
           "Number of mismatched function hash for global merge function");
 STATISTIC(NumMismatchedInstCount,
@@ -87,8 +85,12 @@ static bool canParameterizeCallOperand(const CallBase *CI, unsigned OpIdx) {
   if (Callee) {
     if (Callee->isIntrinsic())
       return false;
+    auto Name = Callee->getName();
     // objc_msgSend stubs must be called, and can't have their address taken.
-    if (Callee->getName().starts_with("objc_msgSend$"))
+    if (Name.starts_with("objc_msgSend$"))
+      return false;
+    // Calls to dtrace probes must generate unique patchpoints.
+    if (Name.starts_with("__dtrace"))
       return false;
   }
   if (isCalleeOperand(CI, OpIdx) &&
@@ -105,7 +107,8 @@ bool isEligibleFunction(Function *F) {
   if (F->isDeclaration())
     return false;
 
-  if (F->hasFnAttribute(llvm::Attribute::NoMerge))
+  if (F->hasFnAttribute(llvm::Attribute::NoMerge) ||
+      F->hasFnAttribute(llvm::Attribute::AlwaysInline))
     return false;
 
   if (F->hasAvailableExternallyLinkage())
@@ -552,8 +555,8 @@ bool GlobalMergeFunc::merge(Module &M, const StableFunctionMap *FunctionMap) {
         // Check if the matched functions fall into the same (first) module.
         // This module check is not strictly necessary as the functions can move
         // around. We just want to avoid merging functions from different
-        // modules than the first one in the functon map, as they may not end up
-        // with not being ICFed by the linker.
+        // modules than the first one in the function map, as they may not end
+        // up with being ICFed by the linker.
         if (MergedModId != *FunctionMap->getNameForId(SF->ModuleNameId)) {
           ++NumMismatchedModuleId;
           continue;
@@ -614,30 +617,6 @@ bool GlobalMergeFunc::merge(Module &M, const StableFunctionMap *FunctionMap) {
   return Changed;
 }
 
-char GlobalMergeFunc::ID = 0;
-INITIALIZE_PASS_BEGIN(GlobalMergeFunc, "global-merge-func",
-                      "Global merge function pass", false, false)
-INITIALIZE_PASS_END(GlobalMergeFunc, "global-merge-func",
-                    "Global merge function pass", false, false)
-
-StringRef GlobalMergeFunc::getPassName() const {
-  return "Global Merge Functions";
-}
-
-void GlobalMergeFunc::getAnalysisUsage(AnalysisUsage &AU) const {
-  AU.addUsedIfAvailable<ImmutableModuleSummaryIndexWrapperPass>();
-  AU.setPreservesAll();
-  ModulePass::getAnalysisUsage(AU);
-}
-
-GlobalMergeFunc::GlobalMergeFunc() : ModulePass(ID) {
-  initializeGlobalMergeFuncPass(*llvm::PassRegistry::getPassRegistry());
-}
-
-namespace llvm {
-Pass *createGlobalMergeFuncPass() { return new GlobalMergeFunc(); }
-} // namespace llvm
-
 void GlobalMergeFunc::initializeMergerMode(const Module &M) {
   // Initialize the local function map regardless of the merger mode.
   LocalFunctionMap = std::make_unique<StableFunctionMap>();
@@ -646,14 +625,10 @@ void GlobalMergeFunc::initializeMergerMode(const Module &M) {
   if (DisableGlobalMerging)
     return;
 
-  if (auto *IndexWrapperPass =
-          getAnalysisIfAvailable<ImmutableModuleSummaryIndexWrapperPass>()) {
-    auto *TheIndex = IndexWrapperPass->getIndex();
-    // (Full)LTO module does not have functions added to the index.
-    // In this case, we run a local merger without using codegen data.
-    if (TheIndex && !TheIndex->hasExportedFunctions(M))
-      return;
-  }
+  // (Full)LTO module does not have functions added to the index.
+  // In this case, we run a local merger without using codegen data.
+  if (Index && !Index->hasExportedFunctions(M))
+    return;
 
   if (cgdata::emitCGData())
     MergerMode = HashFunctionMode::BuildingHashFuncion;
@@ -681,7 +656,7 @@ void GlobalMergeFunc::emitFunctionMap(Module &M) {
                       Align(4));
 }
 
-bool GlobalMergeFunc::runOnModule(Module &M) {
+bool GlobalMergeFunc::run(Module &M) {
   initializeMergerMode(M);
 
   const StableFunctionMap *FuncMap;
@@ -700,3 +675,58 @@ bool GlobalMergeFunc::runOnModule(Module &M) {
 
   return merge(M, FuncMap);
 }
+
+namespace {
+
+class GlobalMergeFuncPassWrapper : public ModulePass {
+
+public:
+  static char ID;
+
+  GlobalMergeFuncPassWrapper();
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.addUsedIfAvailable<ImmutableModuleSummaryIndexWrapperPass>();
+    AU.setPreservesAll();
+    ModulePass::getAnalysisUsage(AU);
+  }
+
+  StringRef getPassName() const override { return "Global Merge Functions"; }
+
+  bool runOnModule(Module &M) override;
+};
+
+} // namespace
+
+char GlobalMergeFuncPassWrapper::ID = 0;
+INITIALIZE_PASS_BEGIN(GlobalMergeFuncPassWrapper, "global-merge-func",
+                      "Global merge function pass", false, false)
+INITIALIZE_PASS_END(GlobalMergeFuncPassWrapper, "global-merge-func",
+                    "Global merge function pass", false, false)
+
+namespace llvm {
+ModulePass *createGlobalMergeFuncPass() {
+  return new GlobalMergeFuncPassWrapper();
+}
+} // namespace llvm
+
+GlobalMergeFuncPassWrapper::GlobalMergeFuncPassWrapper() : ModulePass(ID) {
+  initializeGlobalMergeFuncPassWrapperPass(
+      *llvm::PassRegistry::getPassRegistry());
+}
+
+bool GlobalMergeFuncPassWrapper::runOnModule(Module &M) {
+  const ModuleSummaryIndex *Index = nullptr;
+  if (auto *IndexWrapperPass =
+          getAnalysisIfAvailable<ImmutableModuleSummaryIndexWrapperPass>())
+    Index = IndexWrapperPass->getIndex();
+
+  return GlobalMergeFunc(Index).run(M);
+}
+
+PreservedAnalyses GlobalMergeFuncPass::run(Module &M,
+                                           AnalysisManager<Module> &AM) {
+  ModuleSummaryIndex *Index = &(AM.getResult<ModuleSummaryIndexAnalysis>(M));
+  bool Changed = GlobalMergeFunc(Index).run(M);
+  return Changed ? PreservedAnalyses::none() : PreservedAnalyses::all();
+}

llvm/lib/CodeGen/TargetPassConfig.cpp

@@ -492,6 +492,7 @@ CGPassBuilderOption llvm::getCGPassBuilderOption() {
 
   SET_BOOLEAN_OPTION(EarlyLiveIntervals)
   SET_BOOLEAN_OPTION(EnableBlockPlacementStats)
+  SET_BOOLEAN_OPTION(EnableGlobalMergeFunc)
   SET_BOOLEAN_OPTION(EnableImplicitNullChecks)
   SET_BOOLEAN_OPTION(EnableMachineOutliner)
   SET_BOOLEAN_OPTION(MISchedPostRA)
@@ -890,6 +891,9 @@ void TargetPassConfig::addIRPasses() {
   // Convert conditional moves to conditional jumps when profitable.
   if (getOptLevel() != CodeGenOptLevel::None && !DisableSelectOptimize)
     addPass(createSelectOptimizePass());
+
+  if (EnableGlobalMergeFunc)
+    addPass(createGlobalMergeFuncPass());
 }
 
 /// Turn exception handling constructs into something the code generators can