[IPSCCP] Create a Pass parameter to control specialization of functions.

[labrinea]

Summary

Required for D140210 in order to disable FuncSpec at {Os, Oz} optimization levels.

[chill]

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

1–2

For completeness, I'd suggest a few more run lines, so ultimately we cover:

Passes	Options
ipsccp	none	+
ipsccp	-specialize-functions=true
ipsccp	-specialize-functions=false
ipsccp<func-spec>	none	+
ipsccp<func-spec>	-specialize-functions=false
ipsccp<no-func-spec>	none
ipsccp<no-func-spec>	-specialize-functions=true	+

[nikic]

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

1–2

Maybe drop -specialize-functions entirely? Is there any benefit to keeping it if we already have the pass parameter?

[chill]

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

1–2

Agree.
When we were discussing it we weren't sure what's the policy and looking at some other passes they have both a pass option and a command line option equivalent, but of course, that may well have been for retaining compatibility (not update thousand tests, etc).

[nikic]

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

1–2

I think this may be a LegacyPM leftover, where pass options didn't exist (or rather, they existed, but not in a form that's directly accessible via opt).

[labrinea]

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

1–2

What happens in case like --passes='default<O3>' -specialize-functions (see compiler-crash-58759.ll) ?

[labrinea]

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

1–2

Transform to --passes='default<O3>,ipsccp<func-spec>' ?

[labrinea]

• Removed the cmdline option -specialize-functions.
• Changed the IPSCCPOption 'AllowFuncSpec' from std::optional<bool> to bool.

[labrinea]

llvm/test/Transforms/FunctionSpecialization/compiler-crash-58759.ll

1

This can be removed in D140210.

[chill]

llvm/include/llvm/Transforms/IPO/SCCP.h

38

Nit: spaces around =

llvm/include/llvm/Transforms/IPO/SCCP.h

 #define LLVM_TRANSFORMS_IPO_SCCP_H
 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 class Module;
 
+/// A set of parameters to control various transforms performed by IPSCCP pass.
+/// Each of the boolean parameters can be set to:
+///   true - enabling the transformation.
+///   false - disabling the transformation.
+/// Intended use is to create a default object, modify parameters with
+/// additional setters and then pass it to IPSCCP.
+struct IPSCCPOptions {
+  bool AllowFuncSpec;
+
+  IPSCCPOptions(bool AllowFuncSpec = false) : AllowFuncSpec(AllowFuncSpec) {}
+
+  /// Enables or disables Specialization of Functions.
+  IPSCCPOptions &setFuncSpec(bool FuncSpec) {
+    AllowFuncSpec = FuncSpec;
+    return *this;
+  }
+};
+
 /// Pass to perform interprocedural constant propagation.
 class IPSCCPPass : public PassInfoMixin<IPSCCPPass> {
+  IPSCCPOptions Options;
+
 public:
+  IPSCCPPass() = default;
+
+  IPSCCPPass(IPSCCPOptions Options) : Options(Options) {}
+
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+
+  bool isFuncSpecEnabled() const { return Options.AllowFuncSpec; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_SCCP_H

llvm/lib/Passes/PassBuilder.cpp

if (ParamName == "pre") {
       return make_error<StringError>(
           formatv("invalid GVN pass parameter '{0}' ", ParamName).str(),
           inconvertibleErrorCode());
     }
   }
   return Result;
 }
 
+Expected<IPSCCPOptions> parseIPSCCPOptions(StringRef Params) {
+  IPSCCPOptions Result;
+  while (!Params.empty()) {
+    StringRef ParamName;
+    std::tie(ParamName, Params) = Params.split(';');
+
+    bool Enable = !ParamName.consume_front("no-");
+    if (ParamName == "func-spec")
+      Result.setFuncSpec(Enable);
+    else
+      return make_error<StringError>(
+          formatv("invalid IPSCCP pass parameter '{0}' ", ParamName).str(),
+          inconvertibleErrorCode());
+  }
+  return Result;
+}
+
 Expected<SROAOptions> parseSROAOptions(StringRef Params) {
   if (Params.empty() || Params == "modify-cfg")
     return SROAOptions::ModifyCFG;
   if (Params == "preserve-cfg")
     return SROAOptions::PreserveCFG;
   return make_error<StringError>(
       formatv("invalid SROA pass parameter '{0}' (either preserve-cfg or "
               "modify-cfg can be specified)",

llvm/lib/Passes/PassRegistry.def

 MODULE_PASS("inliner-wrapper-no-mandatory-first", ModuleInlinerWrapperPass(
   getInlineParams(),
   false))
 MODULE_PASS("insert-gcov-profiling", GCOVProfilerPass())
 MODULE_PASS("instrorderfile", InstrOrderFilePass())
 MODULE_PASS("instrprof", InstrProfiling())
 MODULE_PASS("internalize", InternalizePass())
 MODULE_PASS("invalidate<all>", InvalidateAllAnalysesPass())
-MODULE_PASS("ipsccp", IPSCCPPass())
 MODULE_PASS("iroutliner", IROutlinerPass())
 MODULE_PASS("print-ir-similarity", IRSimilarityAnalysisPrinterPass(dbgs()))
 MODULE_PASS("lower-global-dtors", LowerGlobalDtorsPass())
 MODULE_PASS("lowertypetests", LowerTypeTestsPass())
 MODULE_PASS("metarenamer", MetaRenamerPass())
 MODULE_PASS("mergefunc", MergeFunctionsPass())
 MODULE_PASS("name-anon-globals", NameAnonGlobalPass())
 MODULE_PASS("no-op-module", NoOpModulePass())
MODULE_PASS_WITH_PARAMS("asan",
                         "kernel")
 MODULE_PASS_WITH_PARAMS("msan",
                         "MemorySanitizerPass",
                         [](MemorySanitizerOptions Opts) {
                           return MemorySanitizerPass(Opts);
                         },
                         parseMSanPassOptions,
                         "recover;kernel;eager-checks;track-origins=N")
+MODULE_PASS_WITH_PARAMS("ipsccp",
+                        "IPSCCPPass",
+                        [](IPSCCPOptions Opts) {
+                          return IPSCCPPass(Opts);
+                        },
+                        parseIPSCCPOptions,
+                        "no-func-spec;func-spec")
 #undef MODULE_PASS_WITH_PARAMS
 
 #ifndef CGSCC_ANALYSIS
 #define CGSCC_ANALYSIS(NAME, CREATE_PASS)
 #endif
 CGSCC_ANALYSIS("no-op-cgscc", NoOpCGSCCAnalysis())
 CGSCC_ANALYSIS("fam-proxy", FunctionAnalysisManagerCGSCCProxy())
 CGSCC_ANALYSIS("pass-instrumentation", PassInstrumentationAnalysis(PIC))

llvm/lib/Transforms/IPO/SCCP.cpp

 
 STATISTIC(NumInstRemoved, "Number of instructions removed");
 STATISTIC(NumArgsElimed ,"Number of arguments constant propagated");
 STATISTIC(NumGlobalConst, "Number of globals found to be constant");
 STATISTIC(NumDeadBlocks , "Number of basic blocks unreachable");
 STATISTIC(NumInstReplaced,
           "Number of instructions replaced with (simpler) instruction");
 
-static cl::opt<bool> SpecializeFunctions("specialize-functions",
-    cl::init(false), cl::Hidden, cl::desc("Enable function specialization"));
-
 static cl::opt<unsigned> FuncSpecializationMaxIters(
     "func-specialization-max-iters", cl::init(1), cl::Hidden, cl::desc(
     "The maximum number of iterations function specialization is run"));
 
 static void findReturnsToZap(Function &F,
                              SmallVector<ReturnInst *, 8> &ReturnsToZap,
                              SCCPSolver &Solver) {
   // We can only do this if we know that nothing else can call the function.
static void findReturnsToZap(Function &F,
   }
 }
 
 static bool runIPSCCP(
     Module &M, const DataLayout &DL, FunctionAnalysisManager *FAM,
     std::function<const TargetLibraryInfo &(Function &)> GetTLI,
     std::function<TargetTransformInfo &(Function &)> GetTTI,
     std::function<AssumptionCache &(Function &)> GetAC,
-    function_ref<AnalysisResultsForFn(Function &)> getAnalysis) {
+    function_ref<AnalysisResultsForFn(Function &)> getAnalysis,
+    bool IsFuncSpecEnabled) {
   SCCPSolver Solver(DL, GetTLI, M.getContext());
   FunctionSpecializer Specializer(Solver, M, FAM, GetTLI, GetTTI, GetAC);
 
   // Loop over all functions, marking arguments to those with their addresses
   // taken or that are external as overdefined.
   for (Function &F : M) {
     if (F.isDeclaration())
       continue;
for (GlobalVariable &G : M.globals()) {
     G.removeDeadConstantUsers();
     if (canTrackGlobalVariableInterprocedurally(&G))
       Solver.trackValueOfGlobalVariable(&G);
   }
 
   // Solve for constants.
   Solver.solveWhileResolvedUndefsIn(M);
 
-  if (SpecializeFunctions) {
+  if (IsFuncSpecEnabled) {
     unsigned Iters = 0;
     while (Iters++ < FuncSpecializationMaxIters && Specializer.run());
   }
 
   // Iterate over all of the instructions in the module, replacing them with
   // constants if we have found them to be of constant values.
   bool MadeChanges = false;
   for (Function &F : M) {
for (BasicBlock &BB : F) {
           BlocksToErase.push_back(&BB);
         continue;
       }
 
       MadeChanges |= simplifyInstsInBlock(Solver, BB, InsertedValues,
                                           NumInstRemoved, NumInstReplaced);
     }
 
-    DomTreeUpdater DTU = SpecializeFunctions && Specializer.isClonedFunction(&F)
+    DomTreeUpdater DTU = IsFuncSpecEnabled && Specializer.isClonedFunction(&F)
         ? DomTreeUpdater(DomTreeUpdater::UpdateStrategy::Lazy)
         : Solver.getDTU(F);
 
     // Change dead blocks to unreachable. We do it after replacing constants
     // in all executable blocks, because changeToUnreachable may remove PHI
     // nodes in executable blocks we found values for. The function's entry
     // block is not part of BlocksToErase, so we have to handle it separately.
     for (BasicBlock *BB : BlocksToErase) {
auto GetTLI = [&FAM](Function &F) -> const TargetLibraryInfo & {
     return FAM.getResult<TargetLibraryAnalysis>(F);
   };
   auto GetTTI = [&FAM](Function &F) -> TargetTransformInfo & {
     return FAM.getResult<TargetIRAnalysis>(F);
   };
   auto GetAC = [&FAM](Function &F) -> AssumptionCache & {
     return FAM.getResult<AssumptionAnalysis>(F);
   };
-  auto getAnalysis = [&FAM](Function &F) -> AnalysisResultsForFn {
+  auto getAnalysis = [&FAM, this](Function &F) -> AnalysisResultsForFn {
     DominatorTree &DT = FAM.getResult<DominatorTreeAnalysis>(F);
     return {
         std::make_unique<PredicateInfo>(F, DT, FAM.getResult<AssumptionAnalysis>(F)),
         &DT, FAM.getCachedResult<PostDominatorTreeAnalysis>(F),
-        SpecializeFunctions ? &FAM.getResult<LoopAnalysis>(F) : nullptr };
+        isFuncSpecEnabled() ? &FAM.getResult<LoopAnalysis>(F) : nullptr };
   };
 
-  if (!runIPSCCP(M, DL, &FAM, GetTLI, GetTTI, GetAC, getAnalysis))
+  if (!runIPSCCP(M, DL, &FAM, GetTLI, GetTTI, GetAC, getAnalysis,
+                 isFuncSpecEnabled()))
     return PreservedAnalyses::all();
 
   PreservedAnalyses PA;
   PA.preserve<DominatorTreeAnalysis>();
   PA.preserve<PostDominatorTreeAnalysis>();
   PA.preserve<FunctionAnalysisManagerModuleProxy>();
   return PA;
 }
auto getAnalysis = [this](Function &F) -> AnalysisResultsForFn {
               F, DT,
               this->getAnalysis<AssumptionCacheTracker>().getAssumptionCache(
                   F)),
           nullptr,  // We cannot preserve the LI, DT or PDT with the legacy pass
           nullptr,  // manager, so set them to nullptr.
           nullptr};
     };
 
-    return runIPSCCP(M, DL, nullptr, GetTLI, GetTTI, GetAC, getAnalysis);
+    return runIPSCCP(M, DL, nullptr, GetTLI, GetTTI, GetAC, getAnalysis, false);
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<AssumptionCacheTracker>();
     AU.addRequired<DominatorTreeWrapperPass>();
     AU.addRequired<TargetLibraryInfoWrapperPass>();
     AU.addRequired<TargetTransformInfoWrapperPass>();
   }

llvm/test/Transforms/FunctionSpecialization/bug52821-use-after-free.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -passes=ipsccp -specialize-functions -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -S < %s | FileCheck %s
 
 %mystruct = type { i32, [2 x i64] }
 
 define internal ptr @myfunc(ptr %arg) {
 ; CHECK-LABEL: @myfunc(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[FOR_COND:%.*]]
 ; CHECK:       for.cond:

llvm/test/Transforms/FunctionSpecialization/bug55000-read-uninitialized-value.ll

-; RUN: opt -passes=ipsccp -specialize-functions -force-function-specialization -func-specialization-max-iters=2 -func-specialization-max-clones=1 -function-specialization-for-literal-constant=true -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization -func-specialization-max-iters=2 -func-specialization-max-clones=1 -function-specialization-for-literal-constant=true -S < %s | FileCheck %s
 
 declare hidden i1 @compare(ptr) align 2
 declare hidden { i8, ptr } @getType(ptr) align 2
 
 ; CHECK-LABEL: @foo
 ; CHECK-LABEL: @foo.1
 ; CHECK-LABEL: @foo.2
 

llvm/test/Transforms/FunctionSpecialization/compiler-crash-58759.ll

-; RUN: opt -S --passes='default<O3>' -specialize-functions < %s | FileCheck %s
+; RUN: opt -S --passes="default<O3>,ipsccp<func-spec>" < %s | FileCheck %s
 
 define dso_local i32 @g0(i32 noundef %x) local_unnamed_addr {
 entry:
   %call = tail call fastcc i32 @f(i32 noundef %x, ptr noundef nonnull @p0)
   ret i32 %call
 }
 
 define internal fastcc i32 @f(i32 noundef %x, ptr nocapture noundef readonly %p) noinline {

llvm/test/Transforms/FunctionSpecialization/function-specialization-always-inline.ll

-; RUN: opt -passes=ipsccp -specialize-functions -func-specialization-avg-iters-cost=3 -func-specialization-size-threshold=10 -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -func-specialization-avg-iters-cost=3 -func-specialization-size-threshold=10 -S < %s | FileCheck %s
 
 ; CHECK-NOT: foo.{{[0-9]+}}
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 
 @A = external dso_local constant i32, align 4
 @B = external dso_local constant i32, align 4
 @C = external dso_local constant i32, align 4

llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 
 ; Test function specialization wouldn't crash due to constant expression.
 ; Note that this test case shows that function specialization pass would
 ; transform the function even if no specialization happened.
 
-; RUN: opt -passes=ipsccp -specialize-functions -force-function-specialization -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization -S < %s | FileCheck %s
 
 %struct = type { i8, i16, i32, i64, i64}
 @Global = internal constant %struct {i8 0, i16 1, i32 2, i64 3, i64 4}
 
 define internal i64 @func2(ptr %x) {
 entry:
   %val = ptrtoint ptr %x to i64
   ret i64 %val

llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression2.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -passes=ipsccp -specialize-functions -force-function-specialization -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization -S < %s | FileCheck %s
 
 ; Check that we don't crash and specialise on a constant expression.
 
 %struct.pluto = type { %struct.spam }
 %struct.quux = type { i16 }
 %struct.spam = type { i16 }
 
 @global.5 = external dso_local global [4 x %struct.pluto], align 1

llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression3.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -passes=ipsccp -specialize-functions -force-function-specialization -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization -S < %s | FileCheck %s
 
 define i32 @main() {
 ; CHECK-LABEL: @main(
 ; CHECK-NEXT:  bb:
 ; CHECK-NEXT:    tail call void @wombat.1(ptr undef, i64 undef, i64 undef, ptr @quux)
 ; CHECK-NEXT:    tail call void @wombat.2(ptr undef, i64 undef, i64 undef, ptr @eggs)
 ; CHECK-NEXT:    ret i32 undef
 ;

llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression4.ll

-; RUN: opt -passes=ipsccp -specialize-functions -force-function-specialization -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization -S < %s | FileCheck %s
 
 ; Check that we don't crash and specialise on a function call with byval attribute.
 
 ; CHECK-NOT: wombat.{{[0-9]+}}
 
 declare ptr @quux()
 declare ptr @eggs()
 

llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression5.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -passes=ipsccp -specialize-functions -force-function-specialization -func-specialization-on-address -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization -func-specialization-on-address -S < %s | FileCheck %s
 
 ; Check that we don't crash and specialise on a scalar global variable with byval attribute.
 
 ; CHECK-NOT: wombat.{{[0-9]+}}
 
 %struct.pluto = type { %struct.spam }
 %struct.quux = type { i16 }
 %struct.spam = type { i16 }

llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-integers.ll

-; RUN: opt -passes=ipsccp -specialize-functions -function-specialization-for-literal-constant=true -func-specialization-size-threshold=10 -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -function-specialization-for-literal-constant=true -func-specialization-size-threshold=10 -S < %s | FileCheck %s
 
 ; Check that the literal constant parameter could be specialized.
 ; CHECK: @foo.1(
 ; CHECK: @foo.2(
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 
 declare i32 @getValue()

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

-; RUN: opt -passes=ipsccp -specialize-functions -func-specialization-avg-iters-cost=5 -func-specialization-size-threshold=10 -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -func-specialization-avg-iters-cost=5 -func-specialization-size-threshold=10 -S < %s | FileCheck %s
 
 ; Check that the loop depth results in a larger specialization bonus.
 ; CHECK: @foo.1(
 ; CHECK: @foo.2(
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 
 @A = external dso_local constant i32, align 4

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

-; RUN: opt -passes=ipsccp -specialize-functions -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -S < %s | FileCheck %s
 
 ; CHECK-NOT: @compute.1
 ; CHECK-NOT: @compute.2
 
 define i64 @main(i64 %x, i1 %flag) {
 entry:
   br i1 %flag, label %plus, label %minus
 

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

-; RUN: opt -passes=ipsccp -specialize-functions -func-specialization-size-threshold=3 -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -func-specialization-size-threshold=3 -S < %s | FileCheck %s
 
 ; Checks for callsites that have been annotated with MinSize. No specialisation
 ; expected here:
 ;
 ; CHECK-NOT: @compute.1
 ; CHECK-NOT: @compute.2
 
 define i64 @main(i64 %x, i1 %flag) {

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

-; RUN: opt -passes=ipsccp -specialize-functions -func-specialization-size-threshold=3 -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -func-specialization-size-threshold=3 -S < %s | FileCheck %s
 
 ; Checks for callsites that have been annotated with MinSize. We only expect
 ; specialisation for the call that does not have the attribute:
 ;
 ; CHECK: plus:
 ; CHECK:   %tmp0 = call i64 @compute.1(i64 %x, ptr @plus)
 ; CHECK:   br label %merge
 ; CHECK: minus:

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

-; RUN: opt -passes=ipsccp -specialize-functions -force-function-specialization -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization -S < %s | FileCheck %s
 
 ; Function @foo has function attribute 'noduplicate', so check that we don't
 ; specialize it:
 
 ; CHECK-NOT: @foo.1(
 ; CHECK-NOT: @foo.2(
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"

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

-; RUN: opt -passes=ipsccp -specialize-functions -force-function-specialization -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization -S < %s | FileCheck %s
 
 ; Check that function foo does not gets specialised as it contains an intrinsic
 ; that is marked as NoDuplicate.
 ; Please note that the use of the hardwareloop intrinsic is arbitrary; it's
 ; just an easy to use intrinsic that has NoDuplicate.
 
 ; CHECK-NOT: @foo.1(
 ; CHECK-NOT: @foo.2(

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

-; RUN: opt -passes=ipsccp -specialize-functions -force-function-specialization -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization -S < %s | FileCheck %s
 
 ; The if.then block is not executed, so check that we don't specialise here.
 
 ; CHECK-NOT: @foo.1(
 ; CHECK-NOT: @foo.2(
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 

llvm/test/Transforms/FunctionSpecialization/function-specialization-nonconst-glob.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 
-; RUN: opt -passes=ipsccp -specialize-functions -force-function-specialization -S < %s | FileCheck %s
-; RUN: opt -passes=ipsccp -specialize-functions -force-function-specialization -func-specialization-on-address=0 -S < %s | FileCheck %s
-; RUN: opt -passes=ipsccp -specialize-functions -force-function-specialization -func-specialization-on-address=1 -S < %s | FileCheck %s --check-prefix=ON-ADDRESS
+; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization -func-specialization-on-address=0 -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization -func-specialization-on-address=1 -S < %s | FileCheck %s --check-prefix=ON-ADDRESS
 
 ; Global B is not constant. We do not specialise on addresses unless we
 ; enable that:
 
 ; ON-ADDRESS: call i32 @foo.1(i32 %x, ptr @A)
 ; ON-ADDRESS: call i32 @foo.2(i32 %y, ptr @B)
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -passes=ipsccp -specialize-functions -force-function-specialization -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization -S < %s | FileCheck %s
 
 ; Check that we don't crash and specialise on a poison value.
 
 %struct.quux = type { i16 }
 %struct.spam = type { i16 }
 
 @global.12 = external global %struct.quux, align 1
 

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

-; RUN: opt -passes=ipsccp,inline,instcombine -specialize-functions -force-function-specialization -func-specialization-max-iters=2 -S < %s | FileCheck %s --check-prefix=ITERS2
-; RUN: opt -passes=ipsccp,inline,instcombine -specialize-functions -force-function-specialization -func-specialization-max-iters=3 -S < %s | FileCheck %s --check-prefix=ITERS3
-; RUN: opt -passes=ipsccp,inline,instcombine -specialize-functions -force-function-specialization -func-specialization-max-iters=4 -S < %s | FileCheck %s --check-prefix=ITERS4
+; RUN: opt -passes="ipsccp<func-spec>,inline,instcombine" -force-function-specialization -func-specialization-max-iters=2 -S < %s | FileCheck %s --check-prefix=ITERS2
+; RUN: opt -passes="ipsccp<func-spec>,inline,instcombine" -force-function-specialization -func-specialization-max-iters=3 -S < %s | FileCheck %s --check-prefix=ITERS3
+; RUN: opt -passes="ipsccp<func-spec>,inline,instcombine" -force-function-specialization -func-specialization-max-iters=4 -S < %s | FileCheck %s --check-prefix=ITERS4
 
 @low = internal constant i32 0, align 4
 @high = internal constant i32 6, align 4
 
 define internal void @recursiveFunc(ptr nocapture readonly %lo, i32 %step, ptr nocapture readonly %hi) {
   %lo.temp = alloca i32, align 4
   %hi.temp = alloca i32, align 4
   %lo.load = load i32, ptr %lo, align 4

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

-; RUN: opt -passes=ipsccp -specialize-functions -force-function-specialization -func-specialization-max-iters=2 -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization -func-specialization-max-iters=2 -S < %s | FileCheck %s
 
 ; Volatile store preventing recursive specialisation:
 ;
 ; CHECK:     @recursiveFunc.1
 ; CHECK-NOT: @recursiveFunc.2
 
 @Global = internal constant i32 1, align 4
 

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

-; RUN: opt -passes=ipsccp -specialize-functions -force-function-specialization -func-specialization-max-iters=2 -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization -func-specialization-max-iters=2 -S < %s | FileCheck %s
 
 ; Duplicate store preventing recursive specialisation:
 ;
 ; CHECK:     @recursiveFunc.1
 ; CHECK-NOT: @recursiveFunc.2
 
 @Global = internal constant i32 1, align 4
 

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

-; RUN: opt -passes=ipsccp -specialize-functions -force-function-specialization -func-specialization-max-iters=2 -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization -func-specialization-max-iters=2 -S < %s | FileCheck %s
 
 ; Alloca is not an integer type:
 ;
 ; CHECK:     @recursiveFunc.1
 ; CHECK-NOT: @recursiveFunc.2
 
 @Global = internal constant i32 1, align 4
 

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

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

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

-; RUN: opt -passes=ipsccp -specialize-functions -func-specialization-size-threshold=3 -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -func-specialization-size-threshold=3 -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<no-func-spec>" -func-specialization-size-threshold=3 -S < %s | FileCheck %s --check-prefix=NOFSPEC
 
 define i64 @main(i64 %x, i1 %flag) {
 ;
 ; CHECK-LABEL: @main(i64 %x, i1 %flag) {
 ; CHECK:      entry:
 ; CHECK-NEXT:   br i1 %flag, label %plus, label %minus
 ; CHECK:      plus:
 ; CHECK-NEXT:   [[TMP0:%.+]] = call i64 @compute.1(i64 %x, ptr @plus)
 ; CHECK-NEXT:   br label %merge
 ; CHECK:      minus:
 ; CHECK-NEXT:   [[TMP1:%.+]] = call i64 @compute.2(i64 %x, ptr @minus)
 ; CHECK-NEXT:   br label %merge
 ; CHECK:      merge:
 ; CHECK-NEXT:   [[TMP2:%.+]] = phi i64 [ [[TMP0]], %plus ], [ [[TMP1]], %minus ]
 ; CHECK-NEXT:   ret i64 [[TMP2]]
 ; CHECK-NEXT: }
 ;
+; NOFSPEC-LABEL: @main(i64 %x, i1 %flag) {
+; NOFSPEC-NOT: call i64 @compute.{{[0-9]+}}(
+; NOFSPEC: call i64 @compute(
+;
 entry:
   br i1 %flag, label %plus, label %minus
 
 plus:
   %tmp0 = call i64 @compute(i64 %x, ptr @plus)
   br label %merge
 
 minus:

 ; CHECK-NEXT:  }
 ;
 ; CHECK-LABEL: define internal i64 @compute.2(i64 %x, ptr %binop) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TMP0:%.+]] = call i64 @minus(i64 %x)
 ; CHECK-NEXT:    ret i64 [[TMP0]]
 ; CHECK-NEXT:  }
 ;
+; NOFSPEC: define internal i64 @compute(
+; NOFSPEC-NOT: define internal i64 @compute.{{[0-9]+}}(
+;
 define internal i64 @compute(i64 %x, ptr %binop) {
 entry:
   %tmp0 = call i64 %binop(i64 %x)
   ret i64 %tmp0
 }
 
 define internal i64 @plus(i64 %x) {
 entry:

llvm/test/Transforms/FunctionSpecialization/function-specialization2.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -passes=ipsccp,deadargelim -specialize-functions -force-function-specialization -S < %s | FileCheck %s
-; RUN: opt -passes=ipsccp,deadargelim -specialize-functions -func-specialization-max-iters=1 -force-function-specialization -S < %s | FileCheck %s
-; RUN: opt -passes=ipsccp,deadargelim -specialize-functions -func-specialization-max-iters=0 -force-function-specialization -S < %s | FileCheck %s --check-prefix=DISABLED
-; RUN: opt -passes=ipsccp,deadargelim -specialize-functions -func-specialization-avg-iters-cost=1 -force-function-specialization -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>,deadargelim" -force-function-specialization -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>,deadargelim" -func-specialization-max-iters=1 -force-function-specialization -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>,deadargelim" -func-specialization-max-iters=0 -force-function-specialization -S < %s | FileCheck %s --check-prefix=DISABLED
+; RUN: opt -passes="ipsccp<func-spec>,deadargelim" -func-specialization-avg-iters-cost=1 -force-function-specialization -S < %s | FileCheck %s
 
 ; DISABLED-NOT: @func.1(
 ; DISABLED-NOT: @func.2(
 
 define internal i32 @func(ptr %0, i32 %1, ptr nocapture %2) {
   %4 = alloca i32, align 4
   store i32 %1, ptr %4, align 4
   %5 = load i32, ptr %4, align 4

llvm/test/Transforms/FunctionSpecialization/function-specialization3.ll

-; RUN: opt -passes=ipsccp -specialize-functions -func-specialization-avg-iters-cost=3 -S < %s | \
+; RUN: opt -passes="ipsccp<func-spec>" -func-specialization-avg-iters-cost=3 -S < %s | \
 ; RUN:   FileCheck %s --check-prefixes=COMMON,DISABLED
-; RUN: opt -passes=ipsccp -specialize-functions -force-function-specialization -S < %s | \
+; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization -S < %s | \
 ; RUN:   FileCheck %s --check-prefixes=COMMON,FORCE
-; RUN: opt -passes=ipsccp -specialize-functions -func-specialization-avg-iters-cost=3 -force-function-specialization -S < %s | \
+; RUN: opt -passes="ipsccp<func-spec>" -func-specialization-avg-iters-cost=3 -force-function-specialization -S < %s | \
 ; RUN:   FileCheck %s --check-prefixes=COMMON,FORCE
 
 ; Test for specializing a constant global.
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 
 @A = external dso_local constant i32, align 4
 @B = external dso_local constant i32, align 4

llvm/test/Transforms/FunctionSpecialization/function-specialization4.ll

-; RUN: opt -passes=ipsccp -specialize-functions -force-function-specialization \
+; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization \
 ; RUN:   -func-specialization-max-clones=2 -S < %s | FileCheck %s
 
-; RUN: opt -passes=ipsccp -specialize-functions -force-function-specialization \
+; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization \
 ; RUN:   -func-specialization-max-clones=1 -S < %s | FileCheck %s --check-prefix=CONST1
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 
 @A = external dso_local constant i32, align 4
 @B = external dso_local constant i32, align 4
 @C = external dso_local constant i32, align 4
 @D = external dso_local constant i32, align 4

llvm/test/Transforms/FunctionSpecialization/function-specialization5.ll

-; RUN: opt -passes=ipsccp -specialize-functions -force-function-specialization -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization -S < %s | FileCheck %s
 
 ; There's nothing to specialize here as both calls are the same, so check that:
 ;
 ; CHECK-NOT: define internal i32 @foo.1(
 ; CHECK-NOT: define internal i32 @foo.2(
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 

llvm/test/Transforms/FunctionSpecialization/get-possible-constants.ll

-; RUN: opt -S --passes=ipsccp -specialize-functions < %s | FileCheck %s
+; RUN: opt -S --passes="ipsccp<func-spec>" < %s | FileCheck %s
 define dso_local i32 @p0(i32 noundef %x) {
 entry:
   %add = add nsw i32 %x, 1
   ret i32 %add
 }
 
 define dso_local i32 @p1(i32 noundef %x) {
 entry:

llvm/test/Transforms/FunctionSpecialization/global-rank.ll

-; RUN: opt -S --passes=ipsccp  -specialize-functions -func-specialization-max-clones=1 < %s | FileCheck %s
+; RUN: opt -S --passes="ipsccp<func-spec>" -func-specialization-max-clones=1 < %s | FileCheck %s
 define internal i32 @f(i32 noundef %x, ptr nocapture noundef readonly %p, ptr nocapture noundef readonly %q) noinline {
 entry:
   %call = tail call i32 %p(i32 noundef %x)
   %call1 = tail call i32 %q(i32 noundef %x)
   %add = add nsw i32 %call1, %call
   ret i32 %add
 }
 

llvm/test/Transforms/FunctionSpecialization/identical-specializations.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -passes=ipsccp -specialize-functions -force-function-specialization -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization -S < %s | FileCheck %s
 
 define i64 @main(i64 %x, i64 %y, i1 %flag) {
 ; CHECK-LABEL: @main(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[FLAG:%.*]], label [[PLUS:%.*]], label [[MINUS:%.*]]
 ; CHECK:       plus:
 ; CHECK-NEXT:    [[CMP0:%.*]] = call i64 @compute.2(i64 [[X:%.*]], i64 [[Y:%.*]], ptr @plus, ptr @minus)
 ; CHECK-NEXT:    br label [[MERGE:%.*]]

llvm/test/Transforms/FunctionSpecialization/literal-const.ll

-; RUN: opt -S --passes=ipsccp -specialize-functions \
+; RUN: opt -S --passes="ipsccp<func-spec>" \
 ; RUN:        -force-function-specialization < %s | FileCheck %s -check-prefix CHECK-NOLIT
-; RUN: opt -S --passes=ipsccp -specialize-functions \
+; RUN: opt -S --passes="ipsccp<func-spec>" \
 ; RUN:        -function-specialization-for-literal-constant \
 ; RUN:        -force-function-specialization < %s | FileCheck %s -check-prefix CHECK-LIT
 
 define i32 @f0(i32 noundef %x) {
 entry:
   %call = tail call i32 @neg(i32 noundef %x, i1 noundef zeroext false)
   ret i32 %call
 }

llvm/test/Transforms/FunctionSpecialization/no-spec-unused-arg.ll

-; RUN: opt -S --passes=ipsccp -specialize-functions -force-function-specialization -function-specialization-for-literal-constant < %s | FileCheck %s
+; RUN: opt -S --passes="ipsccp<func-spec>" -force-function-specialization -function-specialization-for-literal-constant < %s | FileCheck %s
 define internal i32 @f(i32 %x, i32 %y) noinline {
     ret i32 %x
 }
 
 define i32 @g0() {
     %r = call i32 @f(i32 1, i32 1)
     ret i32 %r
 }

llvm/test/Transforms/FunctionSpecialization/noinline.ll

-; RUN: opt -S --passes=ipsccp -specialize-functions < %s | FileCheck %s
+; RUN: opt -S --passes="ipsccp<func-spec>" < %s | FileCheck %s
 define dso_local i32 @p0(i32 noundef %x) {
 entry:
   %add = add nsw i32 %x, 1
   ret i32 %add
 }
 
 define dso_local i32 @p1(i32 noundef %x) {
 entry:

llvm/test/Transforms/FunctionSpecialization/remove-dead-recursive-function.ll

-; RUN: opt -passes=ipsccp -specialize-functions -func-specialization-size-threshold=3 -S < %s | FileCheck %s
+; RUN: opt -passes="ipsccp<func-spec>" -func-specialization-size-threshold=3 -S < %s | FileCheck %s
 
 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

llvm/test/Transforms/FunctionSpecialization/specialization-order.ll

-; RUN: opt -S --passes=ipsccp,deadargelim -specialize-functions -force-function-specialization < %s | FileCheck %s
+; RUN: opt -S --passes="ipsccp<func-spec>,deadargelim" -force-function-specialization < %s | FileCheck %s
 define dso_local i32 @add(i32 %x, i32 %y) {
 entry:
   %add = add nsw i32 %y, %x
   ret i32 %add
 }
 
 define dso_local i32 @sub(i32 %x, i32 %y) {
 entry:

llvm/test/Transforms/FunctionSpecialization/specialize-multiple-arguments.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -passes=ipsccp -specialize-functions -func-specialization-max-clones=0 -func-specialization-size-threshold=14 -S < %s | FileCheck %s --check-prefix=NONE
-; RUN: opt -passes=ipsccp -specialize-functions -func-specialization-max-clones=1 -func-specialization-size-threshold=14 -S < %s | FileCheck %s --check-prefix=ONE
-; RUN: opt -passes=ipsccp -specialize-functions -func-specialization-max-clones=2 -func-specialization-size-threshold=14 -S < %s | FileCheck %s --check-prefix=TWO
-; RUN: opt -passes=ipsccp -specialize-functions -func-specialization-max-clones=3 -func-specialization-size-threshold=14 -S < %s | FileCheck %s --check-prefix=THREE
+; RUN: opt -passes="ipsccp<func-spec>" -func-specialization-max-clones=0 -func-specialization-size-threshold=14 -S < %s | FileCheck %s --check-prefix=NONE
+; RUN: opt -passes="ipsccp<func-spec>" -func-specialization-max-clones=1 -func-specialization-size-threshold=14 -S < %s | FileCheck %s --check-prefix=ONE
+; RUN: opt -passes="ipsccp<func-spec>" -func-specialization-max-clones=2 -func-specialization-size-threshold=14 -S < %s | FileCheck %s --check-prefix=TWO
+; RUN: opt -passes="ipsccp<func-spec>" -func-specialization-max-clones=3 -func-specialization-size-threshold=14 -S < %s | FileCheck %s --check-prefix=THREE
 
 ; Make sure that we iterate correctly after sorting the specializations:
 ; FnSpecialization: Specializations for function compute
 ; FnSpecialization:   Gain = 608
 ; FnSpecialization:   FormalArg = binop1, ActualArg = power
 ; FnSpecialization:   FormalArg = binop2, ActualArg = mul
 ; FnSpecialization:   Gain = 982
 ; FnSpecialization:   FormalArg = binop1, ActualArg = plus