[llvm-branch-commits] [llvm] 0d21e66 - [IRSim] Letting call instructions be legal for similarity identification.
Andrew Litteken via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Thu Dec 31 19:00:03 PST 2020
Author: Andrew Litteken
Date: 2020-12-31T20:52:45-06:00
New Revision: 0d21e66014fc5cac1302a148e65d5ad6a41af37b
URL: https://github.com/llvm/llvm-project/commit/0d21e66014fc5cac1302a148e65d5ad6a41af37b
DIFF: https://github.com/llvm/llvm-project/commit/0d21e66014fc5cac1302a148e65d5ad6a41af37b.diff
LOG: [IRSim] Letting call instructions be legal for similarity identification.
Here we let non-intrinsic calls be considered legal and valid for
similarity only if the call is not indirect, and has a name.
For two calls to be considered similar, they must have the same name,
the same function types, and the same set of parameters, including tail
calls and calling conventions.
Tests are found in unittests/Analysis/IRSimilarityIdentifierTest.cpp.
Reviewers: jroelofs, paquette
Differential Revision: https://reviews.llvm.org/D87312
Added:
Modified:
llvm/include/llvm/Analysis/IRSimilarityIdentifier.h
llvm/lib/Analysis/IRSimilarityIdentifier.cpp
llvm/test/Transforms/IROutliner/illegal-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 a3004ca0dc59..9e97541e542b 100644
--- a/llvm/include/llvm/Analysis/IRSimilarityIdentifier.h
+++ b/llvm/include/llvm/Analysis/IRSimilarityIdentifier.h
@@ -183,6 +183,12 @@ struct IRInstructionData : ilist_node<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))
+ 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_combine_range(OperTypes.begin(), OperTypes.end()));
return llvm::hash_combine(
llvm::hash_value(ID.Inst->getOpcode()),
llvm::hash_value(ID.Inst->getType()),
@@ -398,8 +404,14 @@ struct IRInstructionMapper {
InstrType visitDbgInfoIntrinsic(DbgInfoIntrinsic &DII) { return Invisible; }
// TODO: Handle specific intrinsics.
InstrType visitIntrinsicInst(IntrinsicInst &II) { return Illegal; }
- // TODO: Handle CallInsts.
- InstrType visitCallInst(CallInst &CI) { return Illegal; }
+ // We only allow call instructions where the function has a name and
+ // is not an indirect call.
+ InstrType visitCallInst(CallInst &CI) {
+ Function *F = CI.getCalledFunction();
+ if (!F || CI.isIndirectCall() || !F->hasName())
+ return Illegal;
+ return Legal;
+ }
// TODO: We do not current handle similarity that changes the control flow.
InstrType visitInvokeInst(InvokeInst &II) { return Illegal; }
// TODO: We do not current handle similarity that changes the control flow.
diff --git a/llvm/lib/Analysis/IRSimilarityIdentifier.cpp b/llvm/lib/Analysis/IRSimilarityIdentifier.cpp
index c276e3f28d73..60b4f427e189 100644
--- a/llvm/lib/Analysis/IRSimilarityIdentifier.cpp
+++ b/llvm/lib/Analysis/IRSimilarityIdentifier.cpp
@@ -75,6 +75,12 @@ CmpInst::Predicate IRInstructionData::getPredicate() const {
return cast<CmpInst>(Inst)->getPredicate();
}
+static StringRef getCalledFunctionName(CallInst &CI) {
+ assert(CI.getCalledFunction() != nullptr && "Called Function is nullptr?");
+
+ return CI.getCalledFunction()->getName();
+}
+
bool IRSimilarity::isClose(const IRInstructionData &A,
const IRInstructionData &B) {
@@ -129,6 +135,16 @@ 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 (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)
+ return false;
+ }
+
return true;
}
diff --git a/llvm/test/Transforms/IROutliner/illegal-calls.ll b/llvm/test/Transforms/IROutliner/illegal-calls.ll
index 99c8f6fa838d..18d37c2f4dc0 100644
--- a/llvm/test/Transforms/IROutliner/illegal-calls.ll
+++ b/llvm/test/Transforms/IROutliner/illegal-calls.ll
@@ -13,7 +13,9 @@ define void @outline_constants1() {
; 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_1(i32* [[A]], i32* [[B]], i32* [[C]])
+; 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 @f1(i32* [[A]], i32* [[B]])
; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
; CHECK-NEXT: ret void
@@ -38,7 +40,9 @@ define void @outline_constants2() {
; 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_1(i32* [[A]], i32* [[B]], i32* [[C]])
+; 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 @f1(i32* [[A]], i32* [[B]])
; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
; CHECK-NEXT: ret void
diff --git a/llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp b/llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp
index ba33144c8ef6..6bb6d7da228f 100644
--- a/llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp
+++ b/llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp
@@ -929,14 +929,40 @@ TEST(IRInstructionMapper, GetElementPtrDifferentInBounds) {
ASSERT_NE(UnsignedVec[0], UnsignedVec[1]);
}
-// Checks that a call instruction is mapped to be illegal. We have to perform
-// extra checks to ensure that both the name and function type are the same.
-TEST(IRInstructionMapper, CallIllegal) {
+// Checks that indirect call instructions are mapped to be illegal since we
+// cannot guarantee the same function in two
diff erent cases.
+TEST(IRInstructionMapper, CallsIllegalIndirect) {
+ StringRef ModuleString = R"(
+ define i32 @f(void()* %func) {
+ bb0:
+ 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);
+ getVectors(*M, Mapper, InstrList, UnsignedVec);
+
+ ASSERT_EQ(InstrList.size(), UnsignedVec.size());
+ ASSERT_EQ(UnsignedVec.size(), static_cast<unsigned>(0));
+}
+
+// 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.
+TEST(IRInstructionMapper, CallsSameTypeSameName) {
StringRef ModuleString = R"(
declare i32 @f1(i32, i32)
define i32 @f(i32 %a, i32 %b) {
bb0:
%0 = call i32 @f1(i32 %a, i32 %b)
+ %1 = call i32 @f1(i32 %a, i32 %b)
ret i32 0
})";
LLVMContext Context;
@@ -951,7 +977,173 @@ TEST(IRInstructionMapper, CallIllegal) {
getVectors(*M, Mapper, InstrList, UnsignedVec);
ASSERT_EQ(InstrList.size(), UnsignedVec.size());
- ASSERT_EQ(UnsignedVec.size(), static_cast<unsigned>(0));
+ ASSERT_EQ(UnsignedVec.size(), static_cast<unsigned>(3));
+ ASSERT_EQ(UnsignedVec[0], UnsignedVec[1]);
+}
+
+// Here we check that a calls with
diff erent names, but the same arguments types
+// are mapped to
diff erent value.
+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);
+ getVectors(*M, Mapper, InstrList, UnsignedVec);
+
+ ASSERT_EQ(InstrList.size(), UnsignedVec.size());
+ ASSERT_EQ(UnsignedVec.size(), static_cast<unsigned>(3));
+ ASSERT_NE(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) {
+ StringRef ModuleString = R"(
+ declare i32 @f1(i32, i32)
+ declare i32 @f2(i32)
+ define i32 @f(i32 %a, i32 %b) {
+ bb0:
+ %0 = call i32 @f1(i32 %a, i32 %b)
+ %1 = call i32 @f2(i32 %a)
+ 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);
+ getVectors(*M, Mapper, InstrList, UnsignedVec);
+
+ ASSERT_EQ(InstrList.size(), UnsignedVec.size());
+ ASSERT_EQ(UnsignedVec.size(), static_cast<unsigned>(3));
+ ASSERT_NE(UnsignedVec[0], UnsignedVec[1]);
+}
+
+// Here we check that calls with
diff erent names, and
diff erent return
+// types are mapped to
diff erent value.
+TEST(IRInstructionMapper, CallsDifferentReturnTypeDifferentName) {
+ StringRef ModuleString = R"(
+ declare i64 @f1(i32, i32)
+ declare i32 @f2(i32, i32)
+ define i32 @f(i32 %a, i32 %b) {
+ bb0:
+ %0 = call i64 @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);
+ getVectors(*M, Mapper, InstrList, UnsignedVec);
+
+ ASSERT_EQ(InstrList.size(), UnsignedVec.size());
+ ASSERT_EQ(UnsignedVec.size(), static_cast<unsigned>(3));
+ ASSERT_NE(UnsignedVec[0], UnsignedVec[1]);
+}
+
+// Here we check that calls with the same name, types, and parameters map to the
+// same unsigned integer.
+TEST(IRInstructionMapper, CallsSameParameters) {
+ StringRef ModuleString = R"(
+ declare i32 @f1(i32, i32)
+ define i32 @f(i32 %a, i32 %b) {
+ bb0:
+ %0 = tail call fastcc i32 @f1(i32 %a, i32 %b)
+ %1 = tail call fastcc i32 @f1(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);
+ 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 calls with
diff erent tail call settings are mapped to
+//
diff erent values.
+TEST(IRInstructionMapper, CallsDifferentTails) {
+ StringRef ModuleString = R"(
+ declare i32 @f1(i32, i32)
+ define i32 @f(i32 %a, i32 %b) {
+ bb0:
+ %0 = tail call i32 @f1(i32 %a, i32 %b)
+ %1 = call i32 @f1(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);
+ getVectors(*M, Mapper, InstrList, UnsignedVec);
+
+ ASSERT_EQ(InstrList.size(), UnsignedVec.size());
+ ASSERT_EQ(UnsignedVec.size(), static_cast<unsigned>(3));
+ ASSERT_NE(UnsignedVec[0], UnsignedVec[1]);
+}
+
+// Here we check that calls with
diff erent calling convention settings are
+// mapped to
diff erent values.
+TEST(IRInstructionMapper, CallsDifferentCallingConventions) {
+ StringRef ModuleString = R"(
+ declare i32 @f1(i32, i32)
+ define i32 @f(i32 %a, i32 %b) {
+ bb0:
+ %0 = call fastcc i32 @f1(i32 %a, i32 %b)
+ %1 = call i32 @f1(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);
+ getVectors(*M, Mapper, InstrList, UnsignedVec);
+
+ ASSERT_EQ(InstrList.size(), UnsignedVec.size());
+ ASSERT_EQ(UnsignedVec.size(), static_cast<unsigned>(3));
+ ASSERT_NE(UnsignedVec[0], UnsignedVec[1]);
}
// Checks that an invoke instruction is mapped to be illegal. Invoke
@@ -1378,8 +1570,8 @@ TEST(IRInstructionMapper, RepeatedIllegalLength) {
bb0:
%0 = add i32 %a, %b
%1 = mul i32 %a, %b
- %2 = call i32 @f(i32 %a, i32 %b)
- %3 = call i32 @f(i32 %a, i32 %b)
+ %2 = alloca i32
+ %3 = alloca i32
%4 = add i32 %a, %b
%5 = mul i32 %a, %b
ret i32 0
More information about the llvm-branch-commits
mailing list