Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2025-02-13 13:45:16 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

[analyzer] Use the signature of the primary template for issue hash calculation

Browse Source 
Now when a template is instantiated more times and there is a bug found in the
instantiations the issue hash will be different for each instantiation even if
every other property of the bug (path, message, location) is the same.

This patch aims to resolve this issue. Note that explicit specializations still
generate different hashes but that is intended.

Differential Revision: https://reviews.llvm.org/D38728

llvm-svn: 316900
This commit is contained in:
Gabor Horvath 2017-10-30 12:16:07 +00:00
parent 3bd24f9440
commit 404fcd3069
3 changed files with 17 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
clang/lib/StaticAnalyzer/Core/IssueHash.cpp
View File

@ -33,6 +33,13 @@ static std::string GetSignature(const FunctionDecl *Target) {
return "";
std::string Signature;
// When a flow sensitive bug happens in templated code we should not generate
// distinct hash value for every instantiation. Use the signature from the
// primary template.
if (const FunctionDecl *InstantiatedFrom =
Target->getTemplateInstantiationPattern())
Target = InstantiatedFrom;
if (!isa<CXXConstructorDecl>(Target) && !isa<CXXDestructorDecl>(Target) &&
!isa<CXXConversionDecl>(Target))
Signature.append(Target->getReturnType().getAsString()).append(" ");

14
clang/test/Analysis/bug_hash_test.cpp
View File

@ -71,15 +71,13 @@ void testLambda() {
template <typename T>
void f(T) {
clang_analyzer_hashDump(5); // expected-warning {{debug.ExprInspection$void f(double)$27$clang_analyzer_hashDump(5);$Category}}
// expected-warning@-1{{debug.ExprInspection$void f(int)$27$clang_analyzer_hashDump(5);$Category}}
clang_analyzer_hashDump(5); // expected-warning {{debug.ExprInspection$void f(T)$27$clang_analyzer_hashDump(5);$Category}}
}
template <typename T>
struct TX {
void f(T) {
clang_analyzer_hashDump(5); // expected-warning {{debug.ExprInspection$void TX<double>::f(double)$29$clang_analyzer_hashDump(5);$Category}}
// expected-warning@-1{{debug.ExprInspection$void TX<int>::f(int)$29$clang_analyzer_hashDump(5);$Category}}
clang_analyzer_hashDump(5); // expected-warning {{debug.ExprInspection$void TX::f(T)$29$clang_analyzer_hashDump(5);$Category}}
}
};
@ -99,11 +97,17 @@ template <typename T>
struct TTX {
template<typename S>
void f(T, S) {
clang_analyzer_hashDump(5); // expected-warning {{debug.ExprInspection$void TTX<int>::f(int, int)$29$clang_analyzer_hashDump(5);$Category}}
clang_analyzer_hashDump(5); // expected-warning {{debug.ExprInspection$void TTX::f(T, S)$29$clang_analyzer_hashDump(5);$Category}}
}
};
void g() {
// TX<int> and TX<double> is instantiated from the same code with the same
// source locations. The same error happining in both of the instantiations
// should share the common hash. This means we should not include the
// template argument for these types in the function signature.
// Note that, we still want the hash to be different for explicit
// specializations.
TX<int> x;
TX<double> y;
TX<long> xl;

2
clang/test/Analysis/edges-new.mm
View File

@ -20288,7 +20288,7 @@ namespace rdar14960554 {
// CHECK-NEXT: <key>type</key><string>Bad deallocator</string>
// CHECK-NEXT: <key>check_name</key><string>unix.MismatchedDeallocator</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! -->
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>d9dbbf68db41ab74e2158f4b131abe34</string>
// CHECK-NEXT: <key>issue_hash_content_of_line_in_context</key><string>046c88d1c91ff46d6506dff5ff880756</string>
// CHECK-NEXT: <key>issue_hash_function_offset</key><string>0</string>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>