This is an archive of the discontinued LLVM Phabricator instance.

Differential D145378

[FuncSpec][NFC] Command line option renaming.
ClosedPublic

Authored by labrinea on Mar 6 2023, 6:26 AM.

Details

Reviewers
ChuanqiXu
SjoerdMeijer
chill
Commits
rG9627bcdeac33: [FuncSpec][NFC] Command line option renaming.
Summary

Standardize all options with 'funcspec' prefix and shorter abreviations.

Diff Detail

Unit TestsFailed

TimeTest
60,190 msx64 debian > AddressSanitizer-x86_64-linux-dynamic.TestCases/Posix::stack-use-after-return.cpp

Event Timeline

labrinea created this revision.Mar 6 2023, 6:26 AM
Herald added a project: Restricted Project. · View Herald TranscriptMar 6 2023, 6:26 AM
Herald added subscribers: snehasish, ormris, hiraditya. · View Herald Transcript
labrinea requested review of this revision.Mar 6 2023, 6:26 AM
Herald added a project: Restricted Project. · View Herald TranscriptMar 6 2023, 6:26 AM
labrinea added a parent revision: D145375: [FuncSpec] Minor refactoring in statistics and debug messages..Mar 6 2023, 6:26 AM
labrinea added a child revision: D145379: [FuncSpec] Cost model improvements..Mar 6 2023, 6:29 AM
Harbormaster completed remote builds in B217561: Diff 502617.Mar 6 2023, 7:45 AM
ChuanqiXu accepted this revision.Mar 6 2023, 5:57 PM

LGTM.

This revision is now accepted and ready to land.Mar 6 2023, 5:57 PM
This revision was landed with ongoing or failed builds.Mar 15 2023, 11:04 AM
Closed by commit rG9627bcdeac33: [FuncSpec][NFC] Command line option renaming. (authored by labrinea). · Explain Why
This revision was automatically updated to reflect the committed changes.
labrinea added a commit: rG9627bcdeac33: [FuncSpec][NFC] Command line option renaming..

Revision Contents

PathSize
llvm/
lib/
Transforms/
IPO/
70 lines
6 lines
test/
Transforms/
FunctionSpecialization/
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
4 lines
8 lines
6 lines
8 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
8 lines

Diff 502617

llvm/lib/Transforms/IPO/FunctionSpecialization.cpp

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Lines
#include <cmath> #include <cmath>
using namespace llvm; using namespace llvm;
#define DEBUG_TYPE "function-specialization" #define DEBUG_TYPE "function-specialization"
STATISTIC(NumSpecsCreated, "Number of specializations created"); STATISTIC(NumSpecsCreated, "Number of specializations created");
static cl::opt<bool> ForceFunctionSpecialization( static cl::opt<bool> ForceSpecialization(
"force-function-specialization", cl::init(false), cl::Hidden, "force-specialization", cl::init(false), cl::Hidden, cl::desc(
cl::desc("Force function specialization for every call site with a " "Force function specialization for every call site with a constant "
"constant argument")); "argument"));
static cl::opt<unsigned> MaxClonesThreshold( static cl::opt<unsigned> MaxClones(
"func-specialization-max-clones", cl::Hidden, "funcspec-max-clones", cl::init(3), cl::Hidden, cl::desc(
cl::desc("The maximum number of clones allowed for a single function " "The maximum number of clones allowed for a single function "
"specialization"), "specialization"));
cl::init(3));
static cl::opt<unsigned> MinFunctionSize(
static cl::opt<unsigned> SmallFunctionThreshold( "funcspec-min-function-size", cl::init(100), cl::Hidden, cl::desc(
"func-specialization-size-threshold", cl::Hidden, "Don't specialize functions that have less than this number of "
cl::desc("Don't specialize functions that have less than this theshold " "instructions"));
"number of instructions"),
cl::init(100)); static cl::opt<unsigned> AvgLoopIters(
"funcspec-avg-loop-iters", cl::init(10), cl::Hidden, cl::desc(
static cl::opt<unsigned> "Average loop iteration count"));
AvgLoopIterationCount("func-specialization-avg-iters-cost", cl::Hidden,
cl::desc("Average loop iteration count cost"), static cl::opt<bool> SpecializeOnAddress(
cl::init(10)); "funcspec-on-address", cl::init(false), cl::Hidden, cl::desc(
"Enable function specialization on the address of global values"));
static cl::opt<bool> SpecializeOnAddresses(
"func-specialization-on-address", cl::init(false), cl::Hidden,
cl::desc("Enable function specialization on the address of global values"));
// Disabled by default as it can significantly increase compilation times. // Disabled by default as it can significantly increase compilation times.
// //
// https://llvm-compile-time-tracker.com // https://llvm-compile-time-tracker.com
// https://github.com/nikic/llvm-compile-time-tracker // https://github.com/nikic/llvm-compile-time-tracker
static cl::opt<bool> EnableSpecializationForLiteralConstant( static cl::opt<bool> SpecializeLiteralConstant(
"function-specialization-for-literal-constant", cl::init(false), cl::Hidden, "funcspec-for-literal-constant", cl::init(false), cl::Hidden, cl::desc(
cl::desc("Enable specialization of functions that take a literal constant " "Enable specialization of functions that take a literal constant as an "
"as an argument.")); "argument"));
Constant *FunctionSpecializer::getPromotableAlloca(AllocaInst *Alloca, Constant *FunctionSpecializer::getPromotableAlloca(AllocaInst *Alloca,
CallInst *Call) { CallInst *Call) {
Value *StoreValue = nullptr; Value *StoreValue = nullptr;
for (auto *User : Alloca->users()) { for (auto *User : Alloca->users()) {
// We can't use llvm::isAllocaPromotable() as that would fail because of // We can't use llvm::isAllocaPromotable() as that would fail because of
// the usage in the CallInst, which is what we check here. // the usage in the CallInst, which is what we check here.
if (User == Call) if (User == Call)
▲ Show 20 Lines • Show All 194 Lines • ▼ Show 20 Linesbool FunctionSpecializer::run() {
// Choose the most profitable specialisations, which fit in the module // Choose the most profitable specialisations, which fit in the module
// specialization budget, which is derived from maximum number of // specialization budget, which is derived from maximum number of
// specializations per specialization candidate function. // specializations per specialization candidate function.
auto CompareGain = [&AllSpecs](unsigned I, unsigned J) { auto CompareGain = [&AllSpecs](unsigned I, unsigned J) {
return AllSpecs[I].Gain > AllSpecs[J].Gain; return AllSpecs[I].Gain > AllSpecs[J].Gain;
}; };
const unsigned NSpecs = const unsigned NSpecs =
std::min(NumCandidates * MaxClonesThreshold, unsigned(AllSpecs.size())); std::min(NumCandidates * MaxClones, unsigned(AllSpecs.size()));
SmallVector<unsigned> BestSpecs(NSpecs + 1); SmallVector<unsigned> BestSpecs(NSpecs + 1);
std::iota(BestSpecs.begin(), BestSpecs.begin() + NSpecs, 0); std::iota(BestSpecs.begin(), BestSpecs.begin() + NSpecs, 0);
if (AllSpecs.size() > NSpecs) { if (AllSpecs.size() > NSpecs) {
LLVM_DEBUG(dbgs() << "FnSpecialization: Number of candidates exceed " LLVM_DEBUG(dbgs() << "FnSpecialization: Number of candidates exceed "
<< "the maximum number of clones threshold.\n" << "the maximum number of clones threshold.\n"
<< "FnSpecialization: Specializing the " << "FnSpecialization: Specializing the "
<< NSpecs << NSpecs
<< " most profitable candidates.\n"); << " most profitable candidates.\n");
▲ Show 20 Lines • Show All 155 Lines • ▼ Show 20 Lines for (User *U : F->users()) {
} else { } else {
// Calculate the specialisation gain. // Calculate the specialisation gain.
InstructionCost Gain = 0 - Cost; InstructionCost Gain = 0 - Cost;
for (ArgInfo &A : S.Args) for (ArgInfo &A : S.Args)
Gain += Gain +=
getSpecializationBonus(A.Formal, A.Actual, Solver.getLoopInfo(*F)); getSpecializationBonus(A.Formal, A.Actual, Solver.getLoopInfo(*F));
// Discard unprofitable specialisations. // Discard unprofitable specialisations.
if (!ForceFunctionSpecialization && Gain <= 0) if (!ForceSpecialization && Gain <= 0)
continue; continue;
// Create a new specialisation entry. // Create a new specialisation entry.
auto &Spec = AllSpecs.emplace_back(F, S, Gain); auto &Spec = AllSpecs.emplace_back(F, S, Gain);
if (CS.getFunction() != F) if (CS.getFunction() != F)
Spec.CallSites.push_back(&CS); Spec.CallSites.push_back(&CS);
const unsigned Index = AllSpecs.size() - 1; const unsigned Index = AllSpecs.size() - 1;
UM[S] = Index; UM[S] = Index;
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines
/// Compute and return the cost of specializing function \p F. /// Compute and return the cost of specializing function \p F.
InstructionCost FunctionSpecializer::getSpecializationCost(Function *F) { InstructionCost FunctionSpecializer::getSpecializationCost(Function *F) {
CodeMetrics &Metrics = analyzeFunction(F); CodeMetrics &Metrics = analyzeFunction(F);
// If the code metrics reveal that we shouldn't duplicate the function, we // If the code metrics reveal that we shouldn't duplicate the function, we
// shouldn't specialize it. Set the specialization cost to Invalid. // shouldn't specialize it. Set the specialization cost to Invalid.
// Or if the lines of codes implies that this function is easy to get // Or if the lines of codes implies that this function is easy to get
// inlined so that we shouldn't specialize it. // inlined so that we shouldn't specialize it.
if (Metrics.notDuplicatable || !Metrics.NumInsts.isValid() || if (Metrics.notDuplicatable || !Metrics.NumInsts.isValid() ||
(!ForceFunctionSpecialization && (!ForceSpecialization && !F->hasFnAttribute(Attribute::NoInline) &&
!F->hasFnAttribute(Attribute::NoInline) && Metrics.NumInsts < MinFunctionSize))
Metrics.NumInsts < SmallFunctionThreshold))
return InstructionCost::getInvalid(); return InstructionCost::getInvalid();
// Otherwise, set the specialization cost to be the cost of all the // Otherwise, set the specialization cost to be the cost of all the
// instructions in the function. // instructions in the function.
return Metrics.NumInsts * InlineConstants::getInstrCost(); return Metrics.NumInsts * InlineConstants::getInstrCost();
} }
static InstructionCost getUserBonus(User *U, llvm::TargetTransformInfo &TTI, static InstructionCost getUserBonus(User *U, llvm::TargetTransformInfo &TTI,
const LoopInfo &LI) { const LoopInfo &LI) {
auto *I = dyn_cast_or_null<Instruction>(U); auto *I = dyn_cast_or_null<Instruction>(U);
// If not an instruction we do not know how to evaluate. // If not an instruction we do not know how to evaluate.
// Keep minimum possible cost for now so that it doesnt affect // Keep minimum possible cost for now so that it doesnt affect
// specialization. // specialization.
if (!I) if (!I)
return std::numeric_limits<unsigned>::min(); return std::numeric_limits<unsigned>::min();
InstructionCost Cost = InstructionCost Cost =
TTI.getInstructionCost(U, TargetTransformInfo::TCK_SizeAndLatency); TTI.getInstructionCost(U, TargetTransformInfo::TCK_SizeAndLatency);
// Increase the cost if it is inside the loop. // Increase the cost if it is inside the loop.
unsigned LoopDepth = LI.getLoopDepth(I->getParent()); unsigned LoopDepth = LI.getLoopDepth(I->getParent());
Cost *= std::pow((double)AvgLoopIterationCount, LoopDepth); Cost *= std::pow((double)AvgLoopIters, LoopDepth);
// Traverse recursively if there are more uses. // Traverse recursively if there are more uses.
// TODO: Any other instructions to be added here? // TODO: Any other instructions to be added here?
if (I->mayReadFromMemory() || I->isCast()) if (I->mayReadFromMemory() || I->isCast())
for (auto *User : I->users()) for (auto *User : I->users())
Cost += getUserBonus(User, TTI, LI); Cost += getUserBonus(User, TTI, LI);
return Cost; return Cost;
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines for (User *U : A->users()) {
LLVM_DEBUG(dbgs() << "FnSpecialization: Inlining bonus " << Bonus LLVM_DEBUG(dbgs() << "FnSpecialization: Inlining bonus " << Bonus
<< " for user " << *U << "\n"); << " for user " << *U << "\n");
} }
return TotalCost + Bonus; return TotalCost + Bonus;
} }
static bool isValidArgumentType(Type *Ty) { static bool isValidArgumentType(Type *Ty) {
return Ty->isPointerTy() || (EnableSpecializationForLiteralConstant && return Ty->isPointerTy() || (SpecializeLiteralConstant &&
(Ty->isIntegerTy() || Ty->isFloatingPointTy() || Ty->isStructTy())); (Ty->isIntegerTy() || Ty->isFloatingPointTy() || Ty->isStructTy()));
} }
/// Determine if it is possible to specialise the function for constant values /// Determine if it is possible to specialise the function for constant values
/// of the formal parameter \p A. /// of the formal parameter \p A.
bool FunctionSpecializer::isArgumentInteresting(Argument *A) { bool FunctionSpecializer::isArgumentInteresting(Argument *A) {
// No point in specialization if the argument is unused. // No point in specialization if the argument is unused.
if (A->user_empty()) if (A->user_empty())
Show All 30 Lines
Constant *FunctionSpecializer::getCandidateConstant(Value *V) { Constant *FunctionSpecializer::getCandidateConstant(Value *V) {
if (isa<PoisonValue>(V)) if (isa<PoisonValue>(V))
return nullptr; return nullptr;
// TrackValueOfGlobalVariable only tracks scalar global variables. // TrackValueOfGlobalVariable only tracks scalar global variables.
if (auto *GV = dyn_cast<GlobalVariable>(V)) { if (auto *GV = dyn_cast<GlobalVariable>(V)) {
// Check if we want to specialize on the address of non-constant // Check if we want to specialize on the address of non-constant
// global values. // global values.
if (!GV->isConstant() && !SpecializeOnAddresses) if (!GV->isConstant() && !SpecializeOnAddress)
return nullptr; return nullptr;
if (!GV->getValueType()->isSingleValueType()) if (!GV->getValueType()->isSingleValueType())
return nullptr; return nullptr;
} }
// Select for possible specialisation values that are constants or // Select for possible specialisation values that are constants or
// are deduced to be constants or constant ranges with a single element. // are deduced to be constants or constant ranges with a single element.
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/SCCP.cpp

Show All 36 Lines
STATISTIC(NumInstRemoved, "Number of instructions removed"); STATISTIC(NumInstRemoved, "Number of instructions removed");
STATISTIC(NumArgsElimed ,"Number of arguments constant propagated"); STATISTIC(NumArgsElimed ,"Number of arguments constant propagated");
STATISTIC(NumGlobalConst, "Number of globals found to be constant"); STATISTIC(NumGlobalConst, "Number of globals found to be constant");
STATISTIC(NumDeadBlocks , "Number of basic blocks unreachable"); STATISTIC(NumDeadBlocks , "Number of basic blocks unreachable");
STATISTIC(NumInstReplaced, STATISTIC(NumInstReplaced,
"Number of instructions replaced with (simpler) instruction"); "Number of instructions replaced with (simpler) instruction");
static cl::opt<unsigned> FuncSpecializationMaxIters( static cl::opt<unsigned> FuncSpecMaxIters(
"func-specialization-max-iters", cl::init(1), cl::Hidden, cl::desc( "funcspec-max-iters", cl::init(1), cl::Hidden, cl::desc(
"The maximum number of iterations function specialization is run")); "The maximum number of iterations function specialization is run"));
static void findReturnsToZap(Function &F, static void findReturnsToZap(Function &F,
SmallVector<ReturnInst *, 8> &ReturnsToZap, SmallVector<ReturnInst *, 8> &ReturnsToZap,
SCCPSolver &Solver) { SCCPSolver &Solver) {
// We can only do this if we know that nothing else can call the function. // We can only do this if we know that nothing else can call the function.
if (!Solver.isArgumentTrackedFunction(&F)) if (!Solver.isArgumentTrackedFunction(&F))
return; return;
▲ Show 20 Lines • Show All 98 Lines • ▼ Show 20 Lines if (canTrackGlobalVariableInterprocedurally(&G))
Solver.trackValueOfGlobalVariable(&G); Solver.trackValueOfGlobalVariable(&G);
} }
// Solve for constants. // Solve for constants.
Solver.solveWhileResolvedUndefsIn(M); Solver.solveWhileResolvedUndefsIn(M);
if (IsFuncSpecEnabled) { if (IsFuncSpecEnabled) {
unsigned Iters = 0; unsigned Iters = 0;
while (Iters++ < FuncSpecializationMaxIters && Specializer.run()); while (Iters++ < FuncSpecMaxIters && Specializer.run());
} }
// Iterate over all of the instructions in the module, replacing them with // Iterate over all of the instructions in the module, replacing them with
// constants if we have found them to be of constant values. // constants if we have found them to be of constant values.
bool MadeChanges = false; bool MadeChanges = false;
for (Function &F : M) { for (Function &F : M) {
if (F.isDeclaration()) if (F.isDeclaration())
continue; continue;
▲ Show 20 Lines • Show All 246 Lines • Show Last 20 Lines

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

; 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 ; RUN: opt -passes="ipsccp<func-spec>" -force-specialization -funcspec-max-iters=2 -funcspec-max-clones=1 -funcspec-for-literal-constant=true -S < %s | FileCheck %s
declare hidden i1 @compare(ptr) align 2 declare hidden i1 @compare(ptr) align 2
declare hidden { i8, ptr } @getType(ptr) align 2 declare hidden { i8, ptr } @getType(ptr) align 2
; CHECK-LABEL: @foo ; CHECK-LABEL: @foo
; CHECK-LABEL: @foo.1 ; CHECK-LABEL: @foo.1
; CHECK-LABEL: @foo.2 ; CHECK-LABEL: @foo.2
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

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

; RUN: opt -S --passes="ipsccp<func-spec>" -force-function-specialization < %s | FileCheck %s ; RUN: opt -S --passes="ipsccp<func-spec>" -force-specialization < %s | FileCheck %s
@A = private constant [6 x i32] [i32 1, i32 2, i32 0, i32 0, i32 0, i32 0], align 16 @A = private constant [6 x i32] [i32 1, i32 2, i32 0, i32 0, i32 0, i32 0], align 16
@B = external global ptr, align 8 @B = external global ptr, align 8
define i32 @caller() { define i32 @caller() {
entry: entry:
%c1 = call fastcc i32 @func(ptr @f0, i32 0, ptr null) %c1 = call fastcc i32 @func(ptr @f0, i32 0, ptr null)
%c2 = call fastcc i32 @func(ptr @f1, i32 1, ptr @A) %c2 = call fastcc i32 @func(ptr @f1, i32 1, ptr @A)
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

llvm/test/Transforms/FunctionSpecialization/compiler-crash-promote-alloca.ll

; RUN: opt -S --passes="ipsccp<func-spec>" -force-function-specialization < %s | FileCheck %s ; RUN: opt -S --passes="ipsccp<func-spec>" -force-specialization < %s | FileCheck %s
; Tests that `bar` has been specialized and that the compiler did not crash ; Tests that `bar` has been specialized and that the compiler did not crash
; while attempting to promote the alloca in `entry`. ; while attempting to promote the alloca in `entry`.
; CHECK: bar.1 ; CHECK: bar.1
@block = internal global [8 x i8] zeroinitializer, align 1 @block = internal global [8 x i8] zeroinitializer, align 1
define dso_local void @entry() { define dso_local void @entry() {
Show All 18 Lines

llvm/test/Transforms/FunctionSpecialization/constant-struct.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization \ ; RUN: opt -passes="ipsccp<func-spec>" -force-specialization \
; RUN: -function-specialization-for-literal-constant -S < %s | FileCheck %s ; RUN: -funcspec-for-literal-constant -S < %s | FileCheck %s
define i32 @foo(i32 %y0, i32 %y1) { define i32 @foo(i32 %y0, i32 %y1) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[Y:%.*]] = insertvalue { i32, i32 } undef, i32 [[Y0:%.*]], 0 ; CHECK-NEXT: [[Y:%.*]] = insertvalue { i32, i32 } undef, i32 [[Y0:%.*]], 0
; CHECK-NEXT: [[YY:%.*]] = insertvalue { i32, i32 } [[Y]], i32 [[Y1:%.*]], 1 ; CHECK-NEXT: [[YY:%.*]] = insertvalue { i32, i32 } [[Y]], i32 [[Y1:%.*]], 1
; CHECK-NEXT: [[CALL:%.*]] = tail call i32 @add.1({ i32, i32 } { i32 2, i32 3 }, { i32, i32 } [[YY]]) ; CHECK-NEXT: [[CALL:%.*]] = tail call i32 @add.1({ i32, i32 } { i32 2, i32 3 }, { i32, i32 } [[YY]])
; CHECK-NEXT: ret i32 [[CALL]] ; CHECK-NEXT: ret i32 [[CALL]]
Show All 35 Lines

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

; RUN: opt -passes="ipsccp<func-spec>" -func-specialization-avg-iters-cost=3 -func-specialization-size-threshold=10 -S < %s | FileCheck %s ; RUN: opt -passes="ipsccp<func-spec>" -funcspec-avg-loop-iters=3 -funcspec-min-function-size=10 -S < %s | FileCheck %s
; CHECK-NOT: foo.{{[0-9]+}} ; CHECK-NOT: foo.{{[0-9]+}}
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128" 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 @A = external dso_local constant i32, align 4
@B = external dso_local constant i32, align 4 @B = external dso_local constant i32, align 4
@C = external dso_local constant i32, align 4 @C = external dso_local constant i32, align 4
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

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

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

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

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

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

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

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

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

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

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

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

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

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

; RUN: opt -passes="ipsccp<func-spec>" -func-specialization-avg-iters-cost=5 -func-specialization-size-threshold=10 -S < %s | FileCheck %s ; RUN: opt -passes="ipsccp<func-spec>" -funcspec-avg-loop-iters=5 -funcspec-min-function-size=10 -S < %s | FileCheck %s
; Check that the loop depth results in a larger specialization bonus. ; Check that the loop depth results in a larger specialization bonus.
; CHECK: @foo.1( ; CHECK: @foo.1(
; CHECK: @foo.2( ; CHECK: @foo.2(
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128" 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 @A = external dso_local constant i32, align 4
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

; 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-specialization -funcspec-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-specialization -funcspec-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 ; RUN: opt -passes="ipsccp<func-spec>,inline,instcombine" -force-specialization -funcspec-max-iters=4 -S < %s | FileCheck %s --check-prefix=ITERS4
@low = internal constant i32 0, align 4 @low = internal constant i32 0, align 4
@high = internal constant i32 6, align 4 @high = internal constant i32 6, align 4
define internal void @recursiveFunc(ptr nocapture readonly %lo, i32 %step, ptr nocapture readonly %hi) { define internal void @recursiveFunc(ptr nocapture readonly %lo, i32 %step, ptr nocapture readonly %hi) {
%lo.temp = alloca i32, align 4 %lo.temp = alloca i32, align 4
%hi.temp = alloca i32, align 4 %hi.temp = alloca i32, align 4
%lo.load = load i32, ptr %lo, align 4 %lo.load = load i32, ptr %lo, align 4
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

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

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

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

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

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

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

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

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

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

; RUN: opt -passes="ipsccp<func-spec>" -func-specialization-size-threshold=3 -S < %s | FileCheck %s ; RUN: opt -passes="ipsccp<func-spec>" -funcspec-min-function-size=3 -S < %s | FileCheck %s
; RUN: opt -passes="ipsccp<no-func-spec>" -func-specialization-size-threshold=3 -S < %s | FileCheck %s --check-prefix=NOFSPEC ; RUN: opt -passes="ipsccp<no-func-spec>" -funcspec-min-function-size=3 -S < %s | FileCheck %s --check-prefix=NOFSPEC
define i64 @main(i64 %x, i1 %flag) { define i64 @main(i64 %x, i1 %flag) {
; ;
; CHECK-LABEL: @main(i64 %x, i1 %flag) { ; CHECK-LABEL: @main(i64 %x, i1 %flag) {
; CHECK: entry: ; CHECK: entry:
; CHECK-NEXT: br i1 %flag, label %plus, label %minus ; CHECK-NEXT: br i1 %flag, label %plus, label %minus
; CHECK: plus: ; CHECK: plus:
; CHECK-NEXT: [[TMP0:%.+]] = call i64 @compute.1(i64 %x, ptr @plus) ; CHECK-NEXT: [[TMP0:%.+]] = call i64 @compute.1(i64 %x, ptr @plus)
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

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

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -passes="ipsccp<func-spec>,deadargelim" -force-function-specialization -S < %s | FileCheck %s ; RUN: opt -passes="ipsccp<func-spec>,deadargelim" -force-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" -funcspec-max-iters=1 -force-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" -funcspec-max-iters=0 -force-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 ; RUN: opt -passes="ipsccp<func-spec>,deadargelim" -funcspec-avg-loop-iters=1 -force-specialization -S < %s | FileCheck %s
; DISABLED-NOT: @func.1( ; DISABLED-NOT: @func.1(
; DISABLED-NOT: @func.2( ; DISABLED-NOT: @func.2(
define internal i32 @func(ptr %0, i32 %1, ptr nocapture %2) { define internal i32 @func(ptr %0, i32 %1, ptr nocapture %2) {
%4 = alloca i32, align 4 %4 = alloca i32, align 4
store i32 %1, ptr %4, align 4 store i32 %1, ptr %4, align 4
%5 = load i32, ptr %4, align 4 %5 = load i32, ptr %4, align 4
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

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

; RUN: opt -passes="ipsccp<func-spec>" -func-specialization-avg-iters-cost=3 -S < %s | \ ; RUN: opt -passes="ipsccp<func-spec>" -funcspec-avg-loop-iters=3 -S < %s | \
; RUN: FileCheck %s --check-prefixes=COMMON,DISABLED ; RUN: FileCheck %s --check-prefixes=COMMON,DISABLED
; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization -S < %s | \ ; RUN: opt -passes="ipsccp<func-spec>" -force-specialization -S < %s | \
; RUN: FileCheck %s --check-prefixes=COMMON,FORCE ; RUN: FileCheck %s --check-prefixes=COMMON,FORCE
; RUN: opt -passes="ipsccp<func-spec>" -func-specialization-avg-iters-cost=3 -force-function-specialization -S < %s | \ ; RUN: opt -passes="ipsccp<func-spec>" -funcspec-avg-loop-iters=3 -force-specialization -S < %s | \
; RUN: FileCheck %s --check-prefixes=COMMON,FORCE ; RUN: FileCheck %s --check-prefixes=COMMON,FORCE
; Test for specializing a constant global. ; Test for specializing a constant global.
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128" 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 @A = external dso_local constant i32, align 4
@B = external dso_local constant i32, align 4 @B = external dso_local constant i32, align 4
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

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

; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization \ ; RUN: opt -passes="ipsccp<func-spec>" -force-specialization \
; RUN: -func-specialization-max-clones=2 -S < %s | FileCheck %s ; RUN: -funcspec-max-clones=2 -S < %s | FileCheck %s
; RUN: opt -passes="ipsccp<func-spec>" -force-function-specialization \ ; RUN: opt -passes="ipsccp<func-spec>" -force-specialization \
; RUN: -func-specialization-max-clones=1 -S < %s | FileCheck %s --check-prefix=CONST1 ; RUN: -funcspec-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" 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 @A = external dso_local constant i32, align 4
@B = external dso_local constant i32, align 4 @B = external dso_local constant i32, align 4
@C = external dso_local constant i32, align 4 @C = external dso_local constant i32, align 4
@D = external dso_local constant i32, align 4 @D = external dso_local constant i32, align 4
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

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

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

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

; RUN: opt -S --passes="ipsccp<func-spec>" -func-specialization-max-clones=1 < %s | FileCheck %s ; RUN: opt -S --passes="ipsccp<func-spec>" -funcspec-max-clones=1 < %s | FileCheck %s
define internal i32 @f(i32 noundef %x, ptr nocapture noundef readonly %p, ptr nocapture noundef readonly %q) noinline { define internal i32 @f(i32 noundef %x, ptr nocapture noundef readonly %p, ptr nocapture noundef readonly %q) noinline {
entry: entry:
%call = tail call i32 %p(i32 noundef %x) %call = tail call i32 %p(i32 noundef %x)
%call1 = tail call i32 %q(i32 noundef %x) %call1 = tail call i32 %q(i32 noundef %x)
%add = add nsw i32 %call1, %call %add = add nsw i32 %call1, %call
ret i32 %add ret i32 %add
} }
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

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

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

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

; RUN: opt -S --passes="ipsccp<func-spec>" \ ; RUN: opt -S --passes="ipsccp<func-spec>" \
; RUN: -force-function-specialization < %s | FileCheck %s -check-prefix CHECK-NOLIT ; RUN: -force-specialization < %s | FileCheck %s -check-prefix CHECK-NOLIT
; RUN: opt -S --passes="ipsccp<func-spec>" \ ; RUN: opt -S --passes="ipsccp<func-spec>" \
; RUN: -function-specialization-for-literal-constant \ ; RUN: -funcspec-for-literal-constant \
; RUN: -force-function-specialization < %s | FileCheck %s -check-prefix CHECK-LIT ; RUN: -force-specialization < %s | FileCheck %s -check-prefix CHECK-LIT
define i32 @f0(i32 noundef %x) { define i32 @f0(i32 noundef %x) {
entry: entry:
%call = tail call i32 @neg(i32 noundef %x, i1 noundef zeroext false) %call = tail call i32 @neg(i32 noundef %x, i1 noundef zeroext false)
ret i32 %call ret i32 %call
} }
define i32 @f1(i32 noundef %x) { define i32 @f1(i32 noundef %x) {
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

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

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

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

; RUN: opt -passes="ipsccp<func-spec>" -func-specialization-size-threshold=3 -S < %s | FileCheck %s ; RUN: opt -passes="ipsccp<func-spec>" -funcspec-min-function-size=3 -S < %s | FileCheck %s
define i64 @main(i64 %x, i1 %flag) { define i64 @main(i64 %x, i1 %flag) {
entry: entry:
br i1 %flag, label %plus, label %minus br i1 %flag, label %plus, label %minus
plus: plus:
%tmp0 = call i64 @compute(i64 %x, ptr @plus) %tmp0 = call i64 @compute(i64 %x, ptr @plus)
br label %merge br label %merge
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

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

; RUN: opt -S --passes="ipsccp<func-spec>,deadargelim" -force-function-specialization < %s | FileCheck %s ; RUN: opt -S --passes="ipsccp<func-spec>,deadargelim" -force-specialization < %s | FileCheck %s
define dso_local i32 @add(i32 %x, i32 %y) { define dso_local i32 @add(i32 %x, i32 %y) {
entry: entry:
%add = add nsw i32 %y, %x %add = add nsw i32 %y, %x
ret i32 %add ret i32 %add
} }
define dso_local i32 @sub(i32 %x, i32 %y) { define dso_local i32 @sub(i32 %x, i32 %y) {
entry: entry:
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

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

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; 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>" -funcspec-max-clones=0 -funcspec-min-function-size=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>" -funcspec-max-clones=1 -funcspec-min-function-size=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>" -funcspec-max-clones=2 -funcspec-min-function-size=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 ; RUN: opt -passes="ipsccp<func-spec>" -funcspec-max-clones=3 -funcspec-min-function-size=14 -S < %s | FileCheck %s --check-prefix=THREE
; Make sure that we iterate correctly after sorting the specializations: ; Make sure that we iterate correctly after sorting the specializations:
; FnSpecialization: Specializations for function compute ; FnSpecialization: Specializations for function compute
; FnSpecialization: Gain = 608 ; FnSpecialization: Gain = 608
; FnSpecialization: FormalArg = binop1, ActualArg = power ; FnSpecialization: FormalArg = binop1, ActualArg = power
; FnSpecialization: FormalArg = binop2, ActualArg = mul ; FnSpecialization: FormalArg = binop2, ActualArg = mul
; FnSpecialization: Gain = 982 ; FnSpecialization: Gain = 982
; FnSpecialization: FormalArg = binop1, ActualArg = plus ; FnSpecialization: FormalArg = binop1, ActualArg = plus
▲ Show 20 Lines • Show All 172 Lines • Show Last 20 Lines