[FuncSpec] Minor refactoring in statistics and debug messages.

[labrinea]

Summary

• Remove redundant variable NbFunctionsSpecialized as it is no longer used by the cost model.
• Rename statistic NumFuncSpecialized to NumSpecsCreated as a better description (the old name confusingly implied number of functions we have created clones for).
• Same for variable SpecializedFuncs. Renamed to Specializations.
• Move debug message in the destructor (avoids repetition when MaxIters > 1).

[ChuanqiXu]

LGTM.

llvm/include/llvm/Transforms/IPO/FunctionSpecialization.h

class FunctionSpecializer {
   /// Analysis manager, needed to invalidate analyses.
   FunctionAnalysisManager *FAM;
 
   /// Analyses used to help determine if a function should be specialized.
   std::function<const TargetLibraryInfo &(Function &)> GetTLI;
   std::function<TargetTransformInfo &(Function &)> GetTTI;
   std::function<AssumptionCache &(Function &)> GetAC;
 
-  // The number of functions specialised, used for collecting statistics and
-  // also in the cost model.
-  unsigned NbFunctionsSpecialized = 0;
-
-  SmallPtrSet<Function *, 32> SpecializedFuncs;
+  SmallPtrSet<Function *, 32> Specializations;
   SmallPtrSet<Function *, 32> FullySpecialized;
   DenseMap<Function *, CodeMetrics> FunctionMetrics;
 
 public:
   FunctionSpecializer(
       SCCPSolver &Solver, Module &M, FunctionAnalysisManager *FAM,
       std::function<const TargetLibraryInfo &(Function &)> GetTLI,
       std::function<TargetTransformInfo &(Function &)> GetTTI,
       std::function<AssumptionCache &(Function &)> GetAC)
       : Solver(Solver), M(M), FAM(FAM), GetTLI(GetTLI), GetTTI(GetTTI),
         GetAC(GetAC) {}
 
-  ~FunctionSpecializer() {
-    // Eliminate dead code.
-    removeDeadFunctions();
-    cleanUpSSA();
-  }
+  ~FunctionSpecializer();
 
-  bool isClonedFunction(Function *F) { return SpecializedFuncs.count(F); }
+  bool isClonedFunction(Function *F) { return Specializations.count(F); }
 
   bool run();
 
 private:
   Constant *getPromotableAlloca(AllocaInst *Alloca, CallInst *Call);
 
   /// A constant stack value is an AllocaInst that has a single constant
   /// value stored to it. Return this constant if such an alloca stack value

llvm/lib/Transforms/IPO/FunctionSpecialization.cpp

 #include "llvm/Transforms/Utils/SCCPSolver.h"
 #include "llvm/Transforms/Utils/SizeOpts.h"
 #include <cmath>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "function-specialization"
 
-STATISTIC(NumFuncSpecialized, "Number of functions specialized");
+STATISTIC(NumSpecsCreated, "Number of specializations created");
 
 static cl::opt<bool> ForceFunctionSpecialization(
     "force-function-specialization", cl::init(false), cl::Hidden,
     cl::desc("Force function specialization for every call site with a "
              "constant argument"));
 
 static cl::opt<unsigned> MaxClonesThreshold(
     "func-specialization-max-clones", cl::Hidden,
for (Instruction &Inst : llvm::make_early_inc_range(BB)) {
       Inst.replaceAllUsesWith(II->getOperand(0));
       Inst.eraseFromParent();
     }
   }
 }
 
 /// Remove any ssa_copy intrinsics that may have been introduced.
 void FunctionSpecializer::cleanUpSSA() {
-  for (Function *F : SpecializedFuncs)
+  for (Function *F : Specializations)
     removeSSACopy(*F);
 }
 
 
 template <> struct llvm::DenseMapInfo<SpecSig> {
   static inline SpecSig getEmptyKey() { return {~0U, {}}; }
 
   static inline SpecSig getTombstoneKey() { return {~1U, {}}; }
 
   static unsigned getHashValue(const SpecSig &S) {
     return static_cast<unsigned>(hash_value(S));
   }
 
   static bool isEqual(const SpecSig &LHS, const SpecSig &RHS) {
     return LHS == RHS;
   }
 };
 
+FunctionSpecializer::~FunctionSpecializer() {
+  LLVM_DEBUG(
+    if (NumSpecsCreated > 0)
+      dbgs() << "FnSpecialization: Created " << NumSpecsCreated
+             << " specializations in module " << M.getName() << "\n");
+  // Eliminate dead code.
+  removeDeadFunctions();
+  cleanUpSSA();
+}
+
 /// Attempt to specialize functions in the module to enable constant
 /// propagation across function boundaries.
 ///
 /// \returns true if at least one function is specialized.
 bool FunctionSpecializer::run() {
   // Find possible specializations for each function.
   SpecMap SM;
   SmallVector<Spec, 32> AllSpecs;
bool FunctionSpecializer::run() {
   // to discarded specialisations and calls that may match a specialisation
   // after the solver runs.
   for (Function *F : OriginalFuncs) {
     auto [Begin, End] = SM[F];
     updateCallSites(F, AllSpecs.begin() + Begin, AllSpecs.begin() + End);
   }
 
   promoteConstantStackValues();
-  LLVM_DEBUG(if (NbFunctionsSpecialized) dbgs()
-             << "FnSpecialization: Specialized " << NbFunctionsSpecialized
-             << " functions in module " << M.getName() << "\n");
-
-  NumFuncSpecialized += NbFunctionsSpecialized;
   return true;
 }
 
 void FunctionSpecializer::removeDeadFunctions() {
   for (Function *F : FullySpecialized) {
     LLVM_DEBUG(dbgs() << "FnSpecialization: Removing dead function "
                       << F->getName() << "\n");
     if (FAM)
bool FunctionSpecializer::isCandidateFunction(Function *F) {
 
   if (F->hasFnAttribute(Attribute::NoDuplicate))
     return false;
 
   if (!Solver.isArgumentTrackedFunction(F))
     return false;
 
   // Do not specialize the cloned function again.
-  if (SpecializedFuncs.contains(F))
+  if (Specializations.contains(F))
     return false;
 
   // If we're optimizing the function for size, we shouldn't specialize it.
   if (F->hasOptSize() ||
       shouldOptimizeForSize(F, nullptr, nullptr, PGSOQueryType::IRPass))
     return false;
 
   // Exit if the function is not executable. There's no point in specializing
Function *FunctionSpecializer::createSpecialization(Function *F, const SpecSig &S) {
   // marking the argument on which we specialized the function constant
   // with the given value.
   Solver.markArgInFuncSpecialization(Clone, S.Args);
 
   Solver.addArgumentTrackedFunction(Clone);
   Solver.markBlockExecutable(&Clone->front());
 
   // Mark all the specialized functions
-  SpecializedFuncs.insert(Clone);
-  NbFunctionsSpecialized++;
+  Specializations.insert(Clone);
+  ++NumSpecsCreated;
 
   return Clone;
 }
 
 /// Compute and return the cost of specializing function \p F.
 InstructionCost FunctionSpecializer::getSpecializationCost(Function *F) {
   CodeMetrics &Metrics = analyzeFunction(F);
   // If the code metrics reveal that we shouldn't duplicate the function, we

llvm/test/Transforms/FunctionSpecialization/function-specialization-stats.ll

 ; REQUIRES: asserts
 ; RUN: opt -stats -passes="ipsccp<func-spec>" -S -force-function-specialization < %s 2>&1 | FileCheck %s
 
-; CHECK: 2 function-specialization - Number of functions specialized
+; CHECK: 2 function-specialization - Number of specializations created
 
 define i64 @main(i64 %x, i1 %flag) {
 entry:
   br i1 %flag, label %plus, label %minus
 
 plus:
   %tmp0 = call i64 @compute(i64 %x, ptr @plus)
   br label %merge