1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
//===--- ExceptionEscapeCheck.cpp - clang-tidy ----------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "ExceptionEscapeCheck.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "llvm/ADT/StringSet.h"
using namespace clang::ast_matchers;
namespace clang::tidy::bugprone {
namespace {
AST_MATCHER_P(FunctionDecl, isEnabled, llvm::StringSet<>,
FunctionsThatShouldNotThrow) {
return FunctionsThatShouldNotThrow.contains(Node.getNameAsString());
}
AST_MATCHER(FunctionDecl, isExplicitThrow) {
return isExplicitThrowExceptionSpec(Node.getExceptionSpecType()) &&
Node.getExceptionSpecSourceRange().isValid();
}
AST_MATCHER(FunctionDecl, hasAtLeastOneParameter) {
return Node.getNumParams() > 0;
}
} // namespace
ExceptionEscapeCheck::ExceptionEscapeCheck(StringRef Name,
ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), RawFunctionsThatShouldNotThrow(Options.get(
"FunctionsThatShouldNotThrow", "")),
RawIgnoredExceptions(Options.get("IgnoredExceptions", "")) {
llvm::SmallVector<StringRef, 8> FunctionsThatShouldNotThrowVec,
IgnoredExceptionsVec;
StringRef(RawFunctionsThatShouldNotThrow)
.split(FunctionsThatShouldNotThrowVec, ",", -1, false);
FunctionsThatShouldNotThrow.insert_range(FunctionsThatShouldNotThrowVec);
llvm::StringSet<> IgnoredExceptions;
StringRef(RawIgnoredExceptions).split(IgnoredExceptionsVec, ",", -1, false);
IgnoredExceptions.insert_range(IgnoredExceptionsVec);
Tracer.ignoreExceptions(std::move(IgnoredExceptions));
Tracer.ignoreBadAlloc(true);
}
void ExceptionEscapeCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "FunctionsThatShouldNotThrow",
RawFunctionsThatShouldNotThrow);
Options.store(Opts, "IgnoredExceptions", RawIgnoredExceptions);
}
void ExceptionEscapeCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(
functionDecl(
isDefinition(),
anyOf(isNoThrow(),
allOf(anyOf(cxxDestructorDecl(),
cxxConstructorDecl(isMoveConstructor()),
cxxMethodDecl(isMoveAssignmentOperator()), isMain(),
allOf(hasAnyName("swap", "iter_swap", "iter_move"),
hasAtLeastOneParameter())),
unless(isExplicitThrow())),
isEnabled(FunctionsThatShouldNotThrow)))
.bind("thrower"),
this);
}
void ExceptionEscapeCheck::check(const MatchFinder::MatchResult &Result) {
const auto *MatchedDecl = Result.Nodes.getNodeAs<FunctionDecl>("thrower");
if (!MatchedDecl)
return;
const utils::ExceptionAnalyzer::ExceptionInfo Info =
Tracer.analyze(MatchedDecl);
if (Info.getBehaviour() != utils::ExceptionAnalyzer::State::Throwing)
return;
diag(MatchedDecl->getLocation(), "an exception may be thrown in function "
"%0 which should not throw exceptions")
<< MatchedDecl;
const auto &[ThrowType, ThrowInfo] = *Info.getExceptions().begin();
if (ThrowInfo.Loc.isInvalid())
return;
const utils::ExceptionAnalyzer::CallStack &Stack = ThrowInfo.Stack;
diag(ThrowInfo.Loc,
"frame #0: unhandled exception of type %0 may be thrown in function %1 "
"here",
DiagnosticIDs::Note)
<< QualType(ThrowType, 0U) << Stack.back().first;
size_t FrameNo = 1;
for (auto CurrIt = ++Stack.rbegin(), PrevIt = Stack.rbegin();
CurrIt != Stack.rend(); ++CurrIt, ++PrevIt) {
const FunctionDecl *CurrFunction = CurrIt->first;
const FunctionDecl *PrevFunction = PrevIt->first;
const SourceLocation PrevLocation = PrevIt->second;
if (PrevLocation.isValid()) {
diag(PrevLocation, "frame #%0: function %1 calls function %2 here",
DiagnosticIDs::Note)
<< FrameNo << CurrFunction << PrevFunction;
} else {
diag(CurrFunction->getLocation(),
"frame #%0: function %1 calls function %2", DiagnosticIDs::Note)
<< FrameNo << CurrFunction << PrevFunction;
}
++FrameNo;
}
}
} // namespace clang::tidy::bugprone
|
