Revert "[CGData][GMF] Skip No Params (#116548)"

This reverts commit fdf1f69.

Author: kyulee-com

llvm/lib/CGData/StableFunctionMap.cpp

@@ -14,7 +14,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CGData/StableFunctionMap.h"
-#include "llvm/ADT/SmallSet.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 
@@ -36,30 +35,21 @@ static cl::opt<unsigned> GlobalMergingMaxParams(
     cl::desc(
         "The maximum number of parameters allowed when merging functions."),
     cl::init(std::numeric_limits<unsigned>::max()), cl::Hidden);
-static cl::opt<bool> GlobalMergingSkipNoParams(
-    "global-merging-skip-no-params",
-    cl::desc("Skip merging functions with no parameters."), cl::init(true),
-    cl::Hidden);
-static cl::opt<double> GlobalMergingInstOverhead(
-    "global-merging-inst-overhead",
-    cl::desc("The overhead cost associated with each instruction when lowering "
-             "to machine instruction."),
-    cl::init(1.2), cl::Hidden);
-static cl::opt<double> GlobalMergingParamOverhead(
+static cl::opt<unsigned> GlobalMergingParamOverhead(
     "global-merging-param-overhead",
     cl::desc("The overhead cost associated with each parameter when merging "
              "functions."),
-    cl::init(2.0), cl::Hidden);
-static cl::opt<double>
+    cl::init(2), cl::Hidden);
+static cl::opt<unsigned>
     GlobalMergingCallOverhead("global-merging-call-overhead",
                               cl::desc("The overhead cost associated with each "
                                        "function call when merging functions."),
-                              cl::init(1.0), cl::Hidden);
-static cl::opt<double> GlobalMergingExtraThreshold(
+                              cl::init(1), cl::Hidden);
+static cl::opt<unsigned> GlobalMergingExtraThreshold(
     "global-merging-extra-threshold",
     cl::desc("An additional cost threshold that must be exceeded for merging "
              "to be considered beneficial."),
-    cl::init(0.0), cl::Hidden);
+    cl::init(0), cl::Hidden);
 
 unsigned StableFunctionMap::getIdOrCreateForName(StringRef Name) {
   auto It = NameToId.find(Name);
@@ -170,32 +160,21 @@ static bool isProfitable(
   if (InstCount < GlobalMergingMinInstrs)
     return false;
 
-  double Cost = 0.0;
-  SmallSet<stable_hash, 8> UniqueHashVals;
-  for (auto &SF : SFS) {
-    UniqueHashVals.clear();
-    for (auto &[IndexPair, Hash] : *SF->IndexOperandHashMap)
-      UniqueHashVals.insert(Hash);
-    unsigned ParamCount = UniqueHashVals.size();
-    if (ParamCount > GlobalMergingMaxParams)
-      return false;
-    // Theoretically, if ParamCount is 0, it results in identical code folding
-    // (ICF), which we can skip merging here since the linker already handles
-    // ICF. This pass would otherwise introduce unnecessary thunks that are
-    // merely direct jumps. However, enabling this could be beneficial depending
-    // on downstream passes, so we provide an option for it.
-    if (GlobalMergingSkipNoParams && ParamCount == 0)
-      return false;
-    Cost += ParamCount * GlobalMergingParamOverhead + GlobalMergingCallOverhead;
-  }
-  Cost += GlobalMergingExtraThreshold;
+  unsigned ParamCount = SFS[0]->IndexOperandHashMap->size();
+  if (ParamCount > GlobalMergingMaxParams)
+    return false;
+
+  unsigned Benefit = InstCount * (StableFunctionCount - 1);
+  unsigned Cost =
+      (GlobalMergingParamOverhead * ParamCount + GlobalMergingCallOverhead) *
+          StableFunctionCount +
+      GlobalMergingExtraThreshold;
 
-  double Benefit =
-      InstCount * (StableFunctionCount - 1) * GlobalMergingInstOverhead;
   bool Result = Benefit > Cost;
   LLVM_DEBUG(dbgs() << "isProfitable: Hash = " << SFS[0]->Hash << ", "
                     << "StableFunctionCount = " << StableFunctionCount
                     << ", InstCount = " << InstCount
+                    << ", ParamCount = " << ParamCount
                     << ", Benefit = " << Benefit << ", Cost = " << Cost
                     << ", Result = " << (Result ? "true" : "false") << "\n");
   return Result;

llvm/lib/CodeGen/GlobalMergeFunctions.cpp

@@ -405,13 +405,12 @@ static ParamLocsVecTy computeParamInfo(
   }
 
   ParamLocsVecTy ParamLocsVec;
-  for (auto &[HashSeq, Locs] : HashSeqToLocs)
+  for (auto &[HashSeq, Locs] : HashSeqToLocs) {
     ParamLocsVec.push_back(std::move(Locs));
-
-  llvm::sort(ParamLocsVec, [&](const ParamLocs &L, const ParamLocs &R) {
-    return L[0] < R[0];
-  });
-
+    llvm::sort(ParamLocsVec, [&](const ParamLocs &L, const ParamLocs &R) {
+      return L[0] < R[0];
+    });
+  }
   return ParamLocsVec;
 }
 

llvm/test/CodeGen/Generic/cgdata-merge-no-params.ll

@@ -2,7 +2,7 @@
 ; while parameterizing a difference in their global variables, g1 and g2.
 ; To achieve this, we create two instances of the global merging function, f1.Tgm and f2.Tgm,
 ; which are tail-called from thunks f1 and f2 respectively.
-; These identical functions, f1.Tgm and f2.Tgm, will be folded by the linker via Identical Code Folding (ICF).
+; These identical functions, f1.Tgm and f2.Tgm, will be folded by the linker via Identical Code Folding (IFC).
 
 ; RUN: opt -S --passes=global-merge-func %s | FileCheck %s