Address review comments

- Rename local variable (s/CodeSizeCost/SpecSize)
- Rename struct member (s/CodeSizeCost/CodeSize) and update comment
- Remove early exit from specialization creation loop
- Remove redundant prefix from regression test name
- Remove regression test for exceeding FuncGrowth

Author: hazzlim

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

@@ -131,16 +131,16 @@ struct Spec {
   // Profitability of the specialization.
   unsigned Score;
 
-  // Cost of the specialization, in terms of codesize.
-  unsigned CodeSizeCost;
+  // Number of instructions in the specialization.
+  unsigned CodeSize;
 
   // List of call sites, matching this specialization.
   SmallVector<CallBase *> CallSites;
 
-  Spec(Function *F, const SpecSig &S, unsigned Score, unsigned CodeSizeCost)
-      : F(F), Sig(S), Score(Score), CodeSizeCost(CodeSizeCost) {}
-  Spec(Function *F, const SpecSig &&S, unsigned Score, unsigned CodeSizeCost)
-      : F(F), Sig(S), Score(Score), CodeSizeCost(CodeSizeCost) {}
+  Spec(Function *F, const SpecSig &S, unsigned Score, unsigned CodeSize)
+      : F(F), Sig(S), Score(Score), CodeSize(CodeSize) {}
+  Spec(Function *F, const SpecSig &&S, unsigned Score, unsigned CodeSize)
+      : F(F), Sig(S), Score(Score), CodeSize(CodeSize) {}
 };
 
 class InstCostVisitor : public InstVisitor<InstCostVisitor, Constant *> {

llvm/lib/Transforms/IPO/FunctionSpecialization.cpp

@@ -772,12 +772,9 @@ bool FunctionSpecializer::run() {
   for (unsigned I = 0; I < NSpecs; ++I) {
     Spec &S = AllSpecs[BestSpecs[I]];
 
-    // Check that creating this specialization doesn't exceed the maximum
-    // codesize growth.
-    unsigned FuncSize = getCostValue(FunctionMetrics[S.F].NumInsts);
-    if ((FunctionGrowth[S.F] + S.CodeSizeCost) / FuncSize > MaxCodeSizeGrowth)
-      continue;
-    FunctionGrowth[S.F] += S.CodeSizeCost;
+    // Accumulate the codesize growth for the function, now we are creating the
+    // specialization.
+    FunctionGrowth[S.F] += S.CodeSize;
 
     S.Clone = createSpecialization(S.F, S.Sig);
 
@@ -933,7 +930,7 @@ bool FunctionSpecializer::findSpecializations(Function *F, unsigned FuncSize,
       CodeSize += Visitor.getCodeSizeSavingsFromPendingPHIs();
 
       unsigned CodeSizeSavings = getCostValue(CodeSize);
-      unsigned CodeSizeCost = FuncSize - CodeSizeSavings;
+      unsigned SpecSize = FuncSize - CodeSizeSavings;
 
       auto IsProfitable = [&]() -> bool {
         // No check required.
@@ -970,7 +967,7 @@ bool FunctionSpecializer::findSpecializations(Function *F, unsigned FuncSize,
         if (LatencySavings < MinLatencySavings * FuncSize / 100)
           return false;
         // Maximum codesize growth.
-        if ((FunctionGrowth[F] + CodeSizeCost) / FuncSize > MaxCodeSizeGrowth)
+        if ((FunctionGrowth[F] + SpecSize) / FuncSize > MaxCodeSizeGrowth)
           return false;
 
         Score += std::max(CodeSizeSavings, LatencySavings);
@@ -982,7 +979,7 @@ bool FunctionSpecializer::findSpecializations(Function *F, unsigned FuncSize,
         continue;
 
       // Create a new specialisation entry.
-      auto &Spec = AllSpecs.emplace_back(F, S, Score, CodeSizeCost);
+      auto &Spec = AllSpecs.emplace_back(F, S, Score, SpecSize);
       if (CS.getFunction() != F)
         Spec.CallSites.push_back(&CS);
       const unsigned Index = AllSpecs.size() - 1;

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

@@ -0,0 +1,44 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --include-generated-funcs --version 5
+; RUN: opt -passes="ipsccp<func-spec>" -funcspec-min-function-size=1       \
+; RUN:                                 -funcspec-for-literal-constant=true \
+; RUN:                                 -funcspec-min-codesize-savings=50   \
+; RUN:                                 -funcspec-min-latency-savings=50    \
+; RUN:                                 -funcspec-max-codesize-growth=1     \
+; RUN:                                 -S < %s | FileCheck %s
+
+; Verify that we are able to specialize a function successfully after analysis
+; of other specializations that are found to not be profitable.
+define void @test_specialize_after_failed_analysis(i32 %n) {
+entry:
+  %notspec0 = call i32 @add(i32 0, i32 %n)
+  %notspec1 = call i32 @add(i32 1, i32 %n)
+  %spec = call i32 @add(i32 1, i32 1)
+  ret void
+}
+
+define i32 @add(i32 %x, i32 %y) {
+entry:
+  %res = add i32 %x, %y
+  ret i32 %res
+}
+; CHECK-LABEL: define void @test_specialize_after_failed_analysis(
+; CHECK-SAME: i32 [[N:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    [[NOTSPEC0:%.*]] = call i32 @add(i32 0, i32 [[N]])
+; CHECK-NEXT:    [[NOTSPEC1:%.*]] = call i32 @add(i32 1, i32 [[N]])
+; CHECK-NEXT:    [[SPEC:%.*]] = call i32 @add.specialized.1(i32 1, i32 1)
+; CHECK-NEXT:    ret void
+;
+;
+; CHECK-LABEL: define i32 @add(
+; CHECK-SAME: i32 [[X:%.*]], i32 [[Y:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    [[RES:%.*]] = add i32 [[X]], [[Y]]
+; CHECK-NEXT:    ret i32 [[RES]]
+;
+;
+; CHECK-LABEL: define internal i32 @add.specialized.1(
+; CHECK-SAME: i32 [[X:%.*]], i32 [[Y:%.*]]) {
+; CHECK-NEXT:  [[ENTRY:.*:]]
+; CHECK-NEXT:    ret i32 poison
+;