[llvm] f5f377d - [IRSim][IROutliner] Adding support for recognizing and outlining indirect function calls, and function calls with different names, but the same type
Andrew Litteken via llvm-commits
llvm-commits at lists.llvm.org
Tue Jan 25 13:21:19 PST 2022
Author: Andrew Litteken
Date: 2022-01-25T15:19:28-06:00
New Revision: f5f377d1fca8ecb4ec5bd2bca656e7c719727404
URL: https://github.com/llvm/llvm-project/commit/f5f377d1fca8ecb4ec5bd2bca656e7c719727404
DIFF: https://github.com/llvm/llvm-project/commit/f5f377d1fca8ecb4ec5bd2bca656e7c719727404.diff
LOG: [IRSim][IROutliner] Adding support for recognizing and outlining indirect function calls, and function calls with different names, but the same type
The outliner currently requires that function calls not be indirect calls, and have that the function name, and function type must match, as well as other attributes such as calling conventions. This patch treats called functions as values, and just another operand, and named function calls as constants. This allows functions to be treated like any other constant, or input and output into the outlined functions.
There are also debugging flags added to enforce the old behaviors where indirect calls not be allowed, and to enforce the old rule that function calls names must also match.
Reviewers: paquette, jroelofs
Differential Revision: https://reviews.llvm.org/D109448
Added:
llvm/test/Transforms/IROutliner/legal-indirect-calls.ll
llvm/test/Transforms/IROutliner/outlining-call-and-indirect.ll
llvm/test/Transforms/IROutliner/outlining-calls-names-must-match.ll
Modified:
llvm/include/llvm/Analysis/IRSimilarityIdentifier.h
llvm/include/llvm/Transforms/IPO/IROutliner.h
llvm/lib/Analysis/IRSimilarityIdentifier.cpp
llvm/lib/Transforms/IPO/IROutliner.cpp
llvm/test/Transforms/IROutliner/illegal-indirect-calls.ll
llvm/test/Transforms/IROutliner/outlining-calls.ll
llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/Analysis/IRSimilarityIdentifier.h b/llvm/include/llvm/Analysis/IRSimilarityIdentifier.h
index 2f8ae205657d8..966bf02d128ec 100644
--- a/llvm/include/llvm/Analysis/IRSimilarityIdentifier.h
+++ b/llvm/include/llvm/Analysis/IRSimilarityIdentifier.h
@@ -128,6 +128,16 @@ struct IRInstructionData
/// to a less than form. It is None otherwise.
Optional<CmpInst::Predicate> RevisedPredicate;
+ /// This is only relevant if we are wrapping a CallInst. If we are requiring
+ /// that the function calls have matching names as well as types, and the
+ /// call is not an indirect call, this will hold the name of the function. If
+ /// it is an indirect string, it will be the empty string. However, if this
+ /// requirement is not in place it will be the empty string regardless of the
+ /// function call type. The value held here is used to create the hash of the
+ /// instruction, and check to make sure two instructions are close to one
+ /// another.
+ Optional<std::string> CalleeName;
+
/// This structure holds the distances of how far "ahead of" or "behind" the
/// target blocks of a branch, or the incoming blocks of a phi nodes are.
/// If the value is negative, it means that the block was registered before
@@ -168,6 +178,10 @@ struct IRInstructionData
/// instruction. the IRInstructionData must be wrapping a CmpInst.
CmpInst::Predicate getPredicate() const;
+ /// Get the callee name that the call instruction is using for hashing the
+ /// instruction. The IRInstructionData must be wrapping a CallInst.
+ StringRef getCalleeName() const;
+
/// A function that swaps the predicates to their less than form if they are
/// in a greater than form. Otherwise, the predicate is unchanged.
///
@@ -185,6 +199,21 @@ struct IRInstructionData
void
setBranchSuccessors(DenseMap<BasicBlock *, unsigned> &BasicBlockToInteger);
+ /// For an IRInstructionData containing a CallInst, set the function name
+ /// appropriately. This will be an empty string if it is an indirect call,
+ /// or we are not matching by name of the called function. It will be the
+ /// name of the function if \p MatchByName is true and it is not an indirect
+ /// call. We may decide not to match by name in order to expand the
+ /// size of the regions we can match. If a function name has the same type
+ /// signature, but the
diff erent name, the region of code is still almost the
+ /// same. Since function names can be treated as constants, the name itself
+ /// could be extrapolated away. However, matching by name provides a
+ /// specificity and more "identical" code than not matching by name.
+ ///
+ /// \param MatchByName - A flag to mark whether we are using the called
+ /// function name as a
diff erentiating parameter.
+ void setCalleeName(bool MatchByName = true);
+
/// Hashes \p Value based on its opcode, types, and operand types.
/// Two IRInstructionData instances produce the same hash when they perform
/// the same operation.
@@ -223,12 +252,14 @@ struct IRInstructionData
llvm::hash_value(ID.Inst->getType()),
llvm::hash_value(ID.getPredicate()),
llvm::hash_combine_range(OperTypes.begin(), OperTypes.end()));
- else if (CallInst *CI = dyn_cast<CallInst>(ID.Inst))
+ else if (CallInst *CI = dyn_cast<CallInst>(ID.Inst)) {
+ std::string FunctionName = *ID.CalleeName;
return llvm::hash_combine(
llvm::hash_value(ID.Inst->getOpcode()),
llvm::hash_value(ID.Inst->getType()),
- llvm::hash_value(CI->getCalledFunction()->getName().str()),
+ llvm::hash_value(ID.Inst->getType()), llvm::hash_value(FunctionName),
llvm::hash_combine_range(OperTypes.begin(), OperTypes.end()));
+ }
return llvm::hash_combine(
llvm::hash_value(ID.Inst->getOpcode()),
llvm::hash_value(ID.Inst->getType()),
@@ -346,6 +377,10 @@ struct IRInstructionMapper {
/// to be considered for similarity.
bool HaveLegalRange = false;
+ /// Marks whether we should use exact function names, as well as types to
+ /// find similarity between calls.
+ bool EnableMatchCallsByName = false;
+
/// This allocator pointer is in charge of holding on to the IRInstructionData
/// so it is not deallocated until whatever external tool is using it is done
/// with the information.
@@ -483,7 +518,10 @@ struct IRInstructionMapper {
// is not an indirect call.
InstrType visitCallInst(CallInst &CI) {
Function *F = CI.getCalledFunction();
- if (!F || CI.isIndirectCall() || !F->hasName())
+ bool IsIndirectCall = CI.isIndirectCall();
+ if (IsIndirectCall && !EnableIndirectCalls)
+ return Illegal;
+ if (!F && !IsIndirectCall)
return Illegal;
return Legal;
}
@@ -498,6 +536,10 @@ struct IRInstructionMapper {
// The flag variable that lets the classifier know whether we should
// allow branches to be checked for similarity.
bool EnableBranches = false;
+
+ // The flag variable that lets the classifier know whether we should
+ // allow indirect calls to be considered legal instructions.
+ bool EnableIndirectCalls = false;
};
/// Maps an Instruction to a member of InstrType.
@@ -882,9 +924,12 @@ typedef std::vector<SimilarityGroup> SimilarityGroupList;
/// analyzing the module.
class IRSimilarityIdentifier {
public:
- IRSimilarityIdentifier(bool MatchBranches = true)
+ IRSimilarityIdentifier(bool MatchBranches = true,
+ bool MatchIndirectCalls = true,
+ bool MatchCallsWithName = false)
: Mapper(&InstDataAllocator, &InstDataListAllocator),
- EnableBranches(MatchBranches) {}
+ EnableBranches(MatchBranches), EnableIndirectCalls(MatchIndirectCalls),
+ EnableMatchingCallsByName(MatchCallsWithName) {}
private:
/// Map the instructions in the module to unsigned integers, using mapping
@@ -964,6 +1009,15 @@ class IRSimilarityIdentifier {
/// similarity, or only look within basic blocks.
bool EnableBranches = true;
+ /// The flag variable that marks whether we allow indirect calls to be checked
+ /// for similarity, or exclude them as a legal instruction.
+ bool EnableIndirectCalls = true;
+
+ /// The flag variable that marks whether we allow calls to be marked as
+ /// similar if they do not have the same name, only the same calling
+ /// convention, attributes and type signature.
+ bool EnableMatchingCallsByName = true;
+
/// The SimilarityGroups found with the most recent run of \ref
/// findSimilarity. None if there is no recent run.
Optional<SimilarityGroupList> SimilarityCandidates;
diff --git a/llvm/include/llvm/Transforms/IPO/IROutliner.h b/llvm/include/llvm/Transforms/IPO/IROutliner.h
index 16f597ab898e5..9799737a529e3 100644
--- a/llvm/include/llvm/Transforms/IPO/IROutliner.h
+++ b/llvm/include/llvm/Transforms/IPO/IROutliner.h
@@ -365,7 +365,10 @@ class IROutliner {
// that they have a name in these cases.
bool visitCallInst(CallInst &CI) {
Function *F = CI.getCalledFunction();
- if (!F || CI.isIndirectCall() || !F->hasName())
+ bool IsIndirectCall = CI.isIndirectCall();
+ if (IsIndirectCall && !EnableIndirectCalls)
+ return false;
+ if (!F && !IsIndirectCall)
return false;
// Returning twice can cause issues with the state of the function call
// that were not expected when the function was used, so we do not include
@@ -389,6 +392,10 @@ class IROutliner {
// The flag variable that marks whether we should allow branch instructions
// to be outlined.
bool EnableBranches = false;
+
+ // The flag variable that marks whether we should allow indirect calls
+ // to be outlined.
+ bool EnableIndirectCalls = true;
};
/// A InstVisitor used to exclude certain instructions from being outlined.
diff --git a/llvm/lib/Analysis/IRSimilarityIdentifier.cpp b/llvm/lib/Analysis/IRSimilarityIdentifier.cpp
index ea08e50bf7283..8c3c0400d6015 100644
--- a/llvm/lib/Analysis/IRSimilarityIdentifier.cpp
+++ b/llvm/lib/Analysis/IRSimilarityIdentifier.cpp
@@ -31,6 +31,17 @@ cl::opt<bool>
"across branches for debugging purposes."));
} // namespace llvm
+cl::opt<bool>
+ DisableIndirectCalls("no-ir-sim-indirect-calls", cl::init(false),
+ cl::ReallyHidden,
+ cl::desc("disable outlining indirect calls."));
+
+cl::opt<bool>
+ MatchCallsByName("ir-sim-calls-by-name", cl::init(false), cl::ReallyHidden,
+ cl::desc("only allow matching call instructions if the "
+ "name and type signature match."));
+
+
IRInstructionData::IRInstructionData(Instruction &I, bool Legality,
IRInstructionDataList &IDList)
: Inst(&I), Legal(Legality), IDL(&IDList) {
@@ -88,6 +99,15 @@ void IRInstructionData::setBranchSuccessors(
}
}
+void IRInstructionData::setCalleeName(bool MatchByName) {
+ CallInst *CI = dyn_cast<CallInst>(Inst);
+ assert(CI && "Instruction must be call");
+
+ CalleeName = "";
+ if (!CI->isIndirectCall() && MatchByName)
+ CalleeName = CI->getCalledFunction()->getName().str();
+}
+
CmpInst::Predicate IRInstructionData::predicateForConsistency(CmpInst *CI) {
switch (CI->getPredicate()) {
case CmpInst::FCMP_OGT:
@@ -114,10 +134,13 @@ CmpInst::Predicate IRInstructionData::getPredicate() const {
return cast<CmpInst>(Inst)->getPredicate();
}
-static StringRef getCalledFunctionName(CallInst &CI) {
- assert(CI.getCalledFunction() != nullptr && "Called Function is nullptr?");
+StringRef IRInstructionData::getCalleeName() const {
+ assert(isa<CallInst>(Inst) &&
+ "Can only get a name from a call instruction");
- return CI.getCalledFunction()->getName();
+ assert(CalleeName.hasValue() && "CalleeName has not been set");
+
+ return *CalleeName;
}
bool IRSimilarity::isClose(const IRInstructionData &A,
@@ -172,13 +195,11 @@ bool IRSimilarity::isClose(const IRInstructionData &A,
});
}
- // If the instructions are functions, we make sure that the function name is
- // the same. We already know that the types are since is isSameOperationAs is
- // true.
+ // If the instructions are functions calls, we make sure that the function
+ // name is the same. We already know that the types are since is
+ // isSameOperationAs is true.
if (isa<CallInst>(A.Inst) && isa<CallInst>(B.Inst)) {
- CallInst *CIA = cast<CallInst>(A.Inst);
- CallInst *CIB = cast<CallInst>(B.Inst);
- if (getCalledFunctionName(*CIA).compare(getCalledFunctionName(*CIB)) != 0)
+ if (A.getCalleeName().str().compare(B.getCalleeName().str()) != 0)
return false;
}
@@ -246,6 +267,9 @@ unsigned IRInstructionMapper::mapToLegalUnsigned(
if (isa<BranchInst>(*It))
ID->setBranchSuccessors(BasicBlockToInteger);
+ if (isa<CallInst>(*It))
+ ID->setCalleeName(EnableMatchCallsByName);
+
// Add to the instruction list
bool WasInserted;
DenseMap<IRInstructionData *, unsigned, IRInstructionDataTraits>::iterator
@@ -1077,6 +1101,8 @@ SimilarityGroupList &IRSimilarityIdentifier::findSimilarity(
std::vector<IRInstructionData *> InstrList;
std::vector<unsigned> IntegerMapping;
Mapper.InstClassifier.EnableBranches = this->EnableBranches;
+ Mapper.InstClassifier.EnableIndirectCalls = EnableIndirectCalls;
+ Mapper.EnableMatchCallsByName = EnableMatchingCallsByName;
populateMapper(Modules, InstrList, IntegerMapping);
findCandidates(InstrList, IntegerMapping);
@@ -1087,6 +1113,8 @@ SimilarityGroupList &IRSimilarityIdentifier::findSimilarity(
SimilarityGroupList &IRSimilarityIdentifier::findSimilarity(Module &M) {
resetSimilarityCandidates();
Mapper.InstClassifier.EnableBranches = this->EnableBranches;
+ Mapper.InstClassifier.EnableIndirectCalls = EnableIndirectCalls;
+ Mapper.EnableMatchCallsByName = EnableMatchingCallsByName;
std::vector<IRInstructionData *> InstrList;
std::vector<unsigned> IntegerMapping;
@@ -1107,7 +1135,8 @@ IRSimilarityIdentifierWrapperPass::IRSimilarityIdentifierWrapperPass()
}
bool IRSimilarityIdentifierWrapperPass::doInitialization(Module &M) {
- IRSI.reset(new IRSimilarityIdentifier(!DisableBranches));
+ IRSI.reset(new IRSimilarityIdentifier(!DisableBranches, !DisableIndirectCalls,
+ MatchCallsByName));
return false;
}
@@ -1125,7 +1154,8 @@ AnalysisKey IRSimilarityAnalysis::Key;
IRSimilarityIdentifier IRSimilarityAnalysis::run(Module &M,
ModuleAnalysisManager &) {
- auto IRSI = IRSimilarityIdentifier(!DisableBranches);
+ auto IRSI = IRSimilarityIdentifier(!DisableBranches, !DisableIndirectCalls,
+ MatchCallsByName);
IRSI.findSimilarity(M);
return IRSI;
}
diff --git a/llvm/lib/Transforms/IPO/IROutliner.cpp b/llvm/lib/Transforms/IPO/IROutliner.cpp
index c3104111864a4..9c79972443fe6 100644
--- a/llvm/lib/Transforms/IPO/IROutliner.cpp
+++ b/llvm/lib/Transforms/IPO/IROutliner.cpp
@@ -40,6 +40,10 @@ namespace llvm {
extern cl::opt<bool> DisableBranches;
} // namespace llvm
+// A command flag to be used for debugging to indirect calls from similarity
+// matching and outlining.
+extern cl::opt<bool> DisableIndirectCalls;
+
// Set to true if the user wants the ir outliner to run on linkonceodr linkage
// functions. This is false by default because the linker can dedupe linkonceodr
// functions. Since the outliner is confined to a single module (modulo LTO),
@@ -2519,6 +2523,7 @@ bool IROutliner::extractSection(OutlinableRegion &Region) {
unsigned IROutliner::doOutline(Module &M) {
// Find the possible similarity sections.
InstructionClassifier.EnableBranches = !DisableBranches;
+ InstructionClassifier.EnableIndirectCalls = !DisableIndirectCalls;
IRSimilarityIdentifier &Identifier = getIRSI(M);
SimilarityGroupList &SimilarityCandidates = *Identifier.getSimilarity();
diff --git a/llvm/test/Transforms/IROutliner/illegal-indirect-calls.ll b/llvm/test/Transforms/IROutliner/illegal-indirect-calls.ll
index 513fa60dc625e..ba57a3c9ebea3 100644
--- a/llvm/test/Transforms/IROutliner/illegal-indirect-calls.ll
+++ b/llvm/test/Transforms/IROutliner/illegal-indirect-calls.ll
@@ -1,9 +1,8 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -verify -iroutliner -ir-outlining-no-cost < %s | FileCheck %s
+; RUN: opt -S -verify -iroutliner -ir-outlining-no-cost --no-ir-sim-indirect-calls < %s | FileCheck %s
-; This test checks that we do not outline indirect calls. We cannot guarantee
-; that we have the same name in these cases, so two indirect calls cannot
-; be considered similar.
+; This test checks that we do not outline indirect calls when it is specified
+; that we should not.
declare void @f1(i32*, i32*);
declare void @f2(i32*, i32*);
diff --git a/llvm/test/Transforms/IROutliner/legal-indirect-calls.ll b/llvm/test/Transforms/IROutliner/legal-indirect-calls.ll
new file mode 100644
index 0000000000000..489d8b59e1f15
--- /dev/null
+++ b/llvm/test/Transforms/IROutliner/legal-indirect-calls.ll
@@ -0,0 +1,71 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --include-generated-funcs
+; RUN: opt -S -verify -iroutliner -ir-outlining-no-cost < %s | FileCheck %s
+
+; This test checks that we do outline indirect calls when it is not specified
+; that we should not.
+
+declare void @f1(i32*, i32*);
+declare void @f2(i32*, i32*);
+
+define void @function1(void()* %func) {
+entry:
+ %a = alloca i32, align 4
+ %b = alloca i32, align 4
+ %c = alloca i32, align 4
+ store i32 2, i32* %a, align 4
+ store i32 3, i32* %b, align 4
+ store i32 4, i32* %c, align 4
+ call void %func()
+ %al = load i32, i32* %a
+ %bl = load i32, i32* %b
+ %cl = load i32, i32* %c
+ ret void
+}
+
+define void @function2(void()* %func) {
+entry:
+ %a = alloca i32, align 4
+ %b = alloca i32, align 4
+ %c = alloca i32, align 4
+ store i32 2, i32* %a, align 4
+ store i32 3, i32* %b, align 4
+ store i32 4, i32* %c, align 4
+ call void %func()
+ %al = load i32, i32* %a
+ %bl = load i32, i32* %b
+ %cl = load i32, i32* %c
+ ret void
+}
+; CHECK-LABEL: @function1(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
+; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
+; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
+; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]], void ()* [[FUNC:%.*]])
+; CHECK-NEXT: ret void
+;
+;
+; CHECK-LABEL: @function2(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
+; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
+; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
+; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]], void ()* [[FUNC:%.*]])
+; CHECK-NEXT: ret void
+;
+;
+; CHECK-LABEL: define internal void @outlined_ir_func_0(
+; CHECK-NEXT: newFuncRoot:
+; CHECK-NEXT: br label [[ENTRY_TO_OUTLINE:%.*]]
+; CHECK: entry_to_outline:
+; CHECK-NEXT: store i32 2, i32* [[TMP0:%.*]], align 4
+; CHECK-NEXT: store i32 3, i32* [[TMP1:%.*]], align 4
+; CHECK-NEXT: store i32 4, i32* [[TMP2:%.*]], align 4
+; CHECK-NEXT: call void [[TMP3:%.*]]()
+; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[TMP2]], align 4
+; CHECK-NEXT: br label [[ENTRY_AFTER_OUTLINE_EXITSTUB:%.*]]
+; CHECK: entry_after_outline.exitStub:
+; CHECK-NEXT: ret void
+;
diff --git a/llvm/test/Transforms/IROutliner/outlining-call-and-indirect.ll b/llvm/test/Transforms/IROutliner/outlining-call-and-indirect.ll
new file mode 100644
index 0000000000000..b58564ff45932
--- /dev/null
+++ b/llvm/test/Transforms/IROutliner/outlining-call-and-indirect.ll
@@ -0,0 +1,70 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --include-generated-funcs
+; RUN: opt -S -verify -iroutliner -ir-outlining-no-cost < %s | FileCheck %s
+
+; This test checks that we do can outline indirect and regular function calls
+; when the type matches when it is not specified that the names must match.
+
+declare void @f1();
+
+define void @function1(void()* %func) {
+entry:
+ %a = alloca i32, align 4
+ %b = alloca i32, align 4
+ %c = alloca i32, align 4
+ store i32 2, i32* %a, align 4
+ store i32 3, i32* %b, align 4
+ store i32 4, i32* %c, align 4
+ call void %func()
+ %al = load i32, i32* %a
+ %bl = load i32, i32* %b
+ %cl = load i32, i32* %c
+ ret void
+}
+
+define void @function2() {
+entry:
+ %a = alloca i32, align 4
+ %b = alloca i32, align 4
+ %c = alloca i32, align 4
+ store i32 2, i32* %a, align 4
+ store i32 3, i32* %b, align 4
+ store i32 4, i32* %c, align 4
+ call void @f1()
+ %al = load i32, i32* %a
+ %bl = load i32, i32* %b
+ %cl = load i32, i32* %c
+ ret void
+}
+; CHECK-LABEL: @function1(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
+; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
+; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
+; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]], void ()* [[FUNC:%.*]])
+; CHECK-NEXT: ret void
+;
+;
+; CHECK-LABEL: @function2(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
+; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
+; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
+; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]], void ()* @f1)
+; CHECK-NEXT: ret void
+;
+;
+; CHECK-LABEL: define internal void @outlined_ir_func_0(
+; CHECK-NEXT: newFuncRoot:
+; CHECK-NEXT: br label [[ENTRY_TO_OUTLINE:%.*]]
+; CHECK: entry_to_outline:
+; CHECK-NEXT: store i32 2, i32* [[TMP0:%.*]], align 4
+; CHECK-NEXT: store i32 3, i32* [[TMP1:%.*]], align 4
+; CHECK-NEXT: store i32 4, i32* [[TMP2:%.*]], align 4
+; CHECK-NEXT: call void [[TMP3:%.*]]()
+; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[TMP2]], align 4
+; CHECK-NEXT: br label [[ENTRY_AFTER_OUTLINE_EXITSTUB:%.*]]
+; CHECK: entry_after_outline.exitStub:
+; CHECK-NEXT: ret void
+;
diff --git a/llvm/test/Transforms/IROutliner/outlining-calls-names-must-match.ll b/llvm/test/Transforms/IROutliner/outlining-calls-names-must-match.ll
new file mode 100644
index 0000000000000..d7bc171d15ee2
--- /dev/null
+++ b/llvm/test/Transforms/IROutliner/outlining-calls-names-must-match.ll
@@ -0,0 +1,93 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt -S -verify -iroutliner -ir-outlining-no-cost -ir-sim-calls-by-name < %s | FileCheck %s
+
+; This test checks that we do can outline calls, but only if they have the same
+; function type and the same name.
+
+declare void @f1(i32*, i32*);
+declare void @f2(i32*, i32*);
+
+define void @function1() {
+; CHECK-LABEL: @function1(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
+; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
+; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
+; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: ret void
+;
+entry:
+ %a = alloca i32, align 4
+ %b = alloca i32, align 4
+ %c = alloca i32, align 4
+ store i32 2, i32* %a, align 4
+ store i32 3, i32* %b, align 4
+ store i32 4, i32* %c, align 4
+ call void @f1(i32* %a, i32* %b)
+ %al = load i32, i32* %a
+ %bl = load i32, i32* %b
+ %cl = load i32, i32* %c
+ ret void
+}
+
+define void @function2() {
+; CHECK-LABEL: @function2(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
+; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
+; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
+; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: ret void
+;
+entry:
+ %a = alloca i32, align 4
+ %b = alloca i32, align 4
+ %c = alloca i32, align 4
+ store i32 2, i32* %a, align 4
+ store i32 3, i32* %b, align 4
+ store i32 4, i32* %c, align 4
+ call void @f1(i32* %a, i32* %b)
+ %al = load i32, i32* %a
+ %bl = load i32, i32* %b
+ %cl = load i32, i32* %c
+ ret void
+}
+
+define void @function3() {
+; CHECK-LABEL: @function3(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
+; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
+; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
+; CHECK-NEXT: store i32 2, i32* [[A]], align 4
+; CHECK-NEXT: store i32 3, i32* [[B]], align 4
+; CHECK-NEXT: store i32 4, i32* [[C]], align 4
+; CHECK-NEXT: call void @f2(i32* [[A]], i32* [[B]])
+; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[A]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[B]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[C]], align 4
+; CHECK-NEXT: ret void
+;
+entry:
+ %a = alloca i32, align 4
+ %b = alloca i32, align 4
+ %c = alloca i32, align 4
+ store i32 2, i32* %a, align 4
+ store i32 3, i32* %b, align 4
+ store i32 4, i32* %c, align 4
+ call void @f2(i32* %a, i32* %b)
+ %al = load i32, i32* %a
+ %bl = load i32, i32* %b
+ %cl = load i32, i32* %c
+ ret void
+}
+
+; CHECK: define internal void @outlined_ir_func_0(i32* [[ARG0:%.*]], i32* [[ARG1:%.*]], i32* [[ARG2:%.*]])
+; CHECK: entry_to_outline:
+; CHECK-NEXT: store i32 2, i32* [[ARG0]], align 4
+; CHECK-NEXT: store i32 3, i32* [[ARG1]], align 4
+; CHECK-NEXT: store i32 4, i32* [[ARG2]], align 4
+; CHECK-NEXT: call void @f1(i32* [[ARG0]], i32* [[ARG1]])
+; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[ARG0]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[ARG1]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[ARG2]], align 4
diff --git a/llvm/test/Transforms/IROutliner/outlining-calls.ll b/llvm/test/Transforms/IROutliner/outlining-calls.ll
index 2372c4f674964..f925b2d0a72f9 100644
--- a/llvm/test/Transforms/IROutliner/outlining-calls.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-calls.ll
@@ -1,4 +1,4 @@
-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --include-generated-funcs
; RUN: opt -S -verify -iroutliner -ir-outlining-no-cost < %s | FileCheck %s
; This test checks that we do can outline calls, but only if they have the same
@@ -8,14 +8,6 @@ declare void @f1(i32*, i32*);
declare void @f2(i32*, i32*);
define void @function1() {
-; CHECK-LABEL: @function1(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
-; CHECK-NEXT: ret void
-;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
@@ -31,14 +23,6 @@ entry:
}
define void @function2() {
-; CHECK-LABEL: @function2(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
-; CHECK-NEXT: ret void
-;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
@@ -54,20 +38,6 @@ entry:
}
define void @function3() {
-; CHECK-LABEL: @function3(
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 2, i32* [[A]], align 4
-; CHECK-NEXT: store i32 3, i32* [[B]], align 4
-; CHECK-NEXT: store i32 4, i32* [[C]], align 4
-; CHECK-NEXT: call void @f2(i32* [[A]], i32* [[B]])
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[A]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[B]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[C]], align 4
-; CHECK-NEXT: ret void
-;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
@@ -82,12 +52,45 @@ entry:
ret void
}
-; CHECK: define internal void @outlined_ir_func_0(i32* [[ARG0:%.*]], i32* [[ARG1:%.*]], i32* [[ARG2:%.*]])
-; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 2, i32* [[ARG0]], align 4
-; CHECK-NEXT: store i32 3, i32* [[ARG1]], align 4
-; CHECK-NEXT: store i32 4, i32* [[ARG2]], align 4
-; CHECK-NEXT: call void @f1(i32* [[ARG0]], i32* [[ARG1]])
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[ARG0]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[ARG1]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[ARG2]], align 4
+; CHECK-LABEL: @function1(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
+; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
+; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
+; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]], void (i32*, i32*)* @f1)
+; CHECK-NEXT: ret void
+;
+;
+; CHECK-LABEL: @function2(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
+; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
+; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
+; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]], void (i32*, i32*)* @f1)
+; CHECK-NEXT: ret void
+;
+;
+; CHECK-LABEL: @function3(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
+; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
+; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
+; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]], void (i32*, i32*)* @f2)
+; CHECK-NEXT: ret void
+;
+;
+; CHECK-LABEL: define internal void @outlined_ir_func_0(
+; CHECK-NEXT: newFuncRoot:
+; CHECK-NEXT: br label [[ENTRY_TO_OUTLINE:%.*]]
+; CHECK: entry_to_outline:
+; CHECK-NEXT: store i32 2, i32* [[TMP0:%.*]], align 4
+; CHECK-NEXT: store i32 3, i32* [[TMP1:%.*]], align 4
+; CHECK-NEXT: store i32 4, i32* [[TMP2:%.*]], align 4
+; CHECK-NEXT: call void [[TMP3:%.*]](i32* [[TMP0]], i32* [[TMP1]])
+; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[TMP2]], align 4
+; CHECK-NEXT: br label [[ENTRY_AFTER_OUTLINE_EXITSTUB:%.*]]
+; CHECK: entry_after_outline.exitStub:
+; CHECK-NEXT: ret void
+;
diff --git a/llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp b/llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp
index 8371028ba4354..a8781e8f78af7 100644
--- a/llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp
+++ b/llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp
@@ -933,8 +933,8 @@ TEST(IRInstructionMapper, GetElementPtrDifferentInBounds) {
ASSERT_NE(UnsignedVec[0], UnsignedVec[1]);
}
-// Checks that indirect call instructions are mapped to be illegal since we
-// cannot guarantee the same function in two
diff erent cases.
+// Checks that indirect call instructions are mapped to be illegal when it is
+// specified to disallow them.
TEST(IRInstructionMapper, CallsIllegalIndirect) {
StringRef ModuleString = R"(
define i32 @f(void()* %func) {
@@ -951,12 +951,39 @@ TEST(IRInstructionMapper, CallsIllegalIndirect) {
SpecificBumpPtrAllocator<IRInstructionData> InstDataAllocator;
SpecificBumpPtrAllocator<IRInstructionDataList> IDLAllocator;
IRInstructionMapper Mapper(&InstDataAllocator, &IDLAllocator);
+ Mapper.InstClassifier.EnableIndirectCalls = false;
getVectors(*M, Mapper, InstrList, UnsignedVec);
ASSERT_EQ(InstrList.size(), UnsignedVec.size());
ASSERT_EQ(UnsignedVec.size(), static_cast<unsigned>(0));
}
+// Checks that indirect call instructions are mapped to be legal when it is not
+// specified to disallow them.
+TEST(IRInstructionMapper, CallsLegalIndirect) {
+ StringRef ModuleString = R"(
+ define i32 @f(void()* %func) {
+ bb0:
+ call void %func()
+ call void %func()
+ ret i32 0
+ })";
+ LLVMContext Context;
+ std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleString);
+
+ std::vector<IRInstructionData *> InstrList;
+ std::vector<unsigned> UnsignedVec;
+
+ SpecificBumpPtrAllocator<IRInstructionData> InstDataAllocator;
+ SpecificBumpPtrAllocator<IRInstructionDataList> IDLAllocator;
+ IRInstructionMapper Mapper(&InstDataAllocator, &IDLAllocator);
+ Mapper.InstClassifier.EnableIndirectCalls = true;
+ getVectors(*M, Mapper, InstrList, UnsignedVec);
+
+ ASSERT_EQ(InstrList.size(), UnsignedVec.size());
+ ASSERT_EQ(UnsignedVec.size(), static_cast<unsigned>(3));
+}
+
// Checks that a call instruction is mapped to be legal. Here we check that
// a call with the same name, and same types are mapped to the same
// value.
@@ -986,8 +1013,8 @@ TEST(IRInstructionMapper, CallsSameTypeSameName) {
}
// Here we check that a calls with
diff erent names, but the same arguments types
-// are mapped to
diff erent value.
-TEST(IRInstructionMapper, CallsSameArgTypeDifferentName) {
+// are mapped to
diff erent value when specified that the name must match.
+TEST(IRInstructionMapper, CallsSameArgTypeDifferentNameDisallowed) {
StringRef ModuleString = R"(
declare i32 @f1(i32, i32)
declare i32 @f2(i32, i32)
@@ -1006,6 +1033,7 @@ TEST(IRInstructionMapper, CallsSameArgTypeDifferentName) {
SpecificBumpPtrAllocator<IRInstructionData> InstDataAllocator;
SpecificBumpPtrAllocator<IRInstructionDataList> IDLAllocator;
IRInstructionMapper Mapper(&InstDataAllocator, &IDLAllocator);
+ Mapper.EnableMatchCallsByName = true;
getVectors(*M, Mapper, InstrList, UnsignedVec);
ASSERT_EQ(InstrList.size(), UnsignedVec.size());
@@ -1013,6 +1041,35 @@ TEST(IRInstructionMapper, CallsSameArgTypeDifferentName) {
ASSERT_NE(UnsignedVec[0], UnsignedVec[1]);
}
+// Here we check that a calls with
diff erent names, but the same arguments types
+// are mapped to the same value when it is not specifed that they must match.
+TEST(IRInstructionMapper, CallsSameArgTypeDifferentName) {
+ StringRef ModuleString = R"(
+ declare i32 @f1(i32, i32)
+ declare i32 @f2(i32, i32)
+ define i32 @f(i32 %a, i32 %b) {
+ bb0:
+ %0 = call i32 @f1(i32 %a, i32 %b)
+ %1 = call i32 @f2(i32 %a, i32 %b)
+ ret i32 0
+ })";
+ LLVMContext Context;
+ std::unique_ptr<Module> M = makeLLVMModule(Context, ModuleString);
+
+ std::vector<IRInstructionData *> InstrList;
+ std::vector<unsigned> UnsignedVec;
+
+ SpecificBumpPtrAllocator<IRInstructionData> InstDataAllocator;
+ SpecificBumpPtrAllocator<IRInstructionDataList> IDLAllocator;
+ IRInstructionMapper Mapper(&InstDataAllocator, &IDLAllocator);
+ Mapper.EnableMatchCallsByName = false;
+ getVectors(*M, Mapper, InstrList, UnsignedVec);
+
+ ASSERT_EQ(InstrList.size(), UnsignedVec.size());
+ ASSERT_EQ(UnsignedVec.size(), static_cast<unsigned>(3));
+ ASSERT_EQ(UnsignedVec[0], UnsignedVec[1]);
+}
+
// Here we check that a calls with
diff erent names, and
diff erent arguments
// types are mapped to
diff erent value.
TEST(IRInstructionMapper, CallsDifferentArgTypeDifferentName) {
More information about the llvm-commits
mailing list