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
123
124
|
//===- unittests/StaticAnalyzer/ParamRegionTest.cpp -----------------------===//
//
// 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 "Reusables.h"
#include "clang/Tooling/Tooling.h"
#include "gtest/gtest.h"
namespace clang {
namespace ento {
namespace {
class ParamRegionTestConsumer : public ExprEngineConsumer {
void checkForSameParamRegions(MemRegionManager &MRMgr,
const StackFrameContext *SFC,
const ParmVarDecl *PVD) {
ASSERT_TRUE(llvm::all_of(PVD->redecls(), [&](const clang::VarDecl *D2) {
return MRMgr.getVarRegion(PVD, SFC) ==
MRMgr.getVarRegion(cast<ParmVarDecl>(D2), SFC);
}));
}
void performTest(const Decl *D) {
StoreManager &StMgr = Eng.getStoreManager();
MemRegionManager &MRMgr = StMgr.getRegionManager();
const StackFrameContext *SFC =
Eng.getAnalysisDeclContextManager().getStackFrame(D);
if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
for (const auto *P : FD->parameters()) {
if (SFC->inTopFrame())
assert(isa<NonParamVarRegion>(MRMgr.getVarRegion(P, SFC)));
else
assert(isa<ParamVarRegion>(MRMgr.getVarRegion(P, SFC)));
checkForSameParamRegions(MRMgr, SFC, P);
}
} else if (const auto *CD = dyn_cast<CXXConstructorDecl>(D)) {
for (const auto *P : CD->parameters()) {
if (SFC->inTopFrame())
assert(isa<NonParamVarRegion>(MRMgr.getVarRegion(P, SFC)));
else
assert(isa<ParamVarRegion>(MRMgr.getVarRegion(P, SFC)));
checkForSameParamRegions(MRMgr, SFC, P);
}
} else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
for (const auto *P : MD->parameters()) {
if (SFC->inTopFrame())
assert(isa<NonParamVarRegion>(MRMgr.getVarRegion(P, SFC)));
else
assert(isa<ParamVarRegion>(MRMgr.getVarRegion(P, SFC)));
checkForSameParamRegions(MRMgr, SFC, P);
}
}
}
public:
ParamRegionTestConsumer(CompilerInstance &C) : ExprEngineConsumer(C) {}
bool HandleTopLevelDecl(DeclGroupRef DG) override {
for (const auto *D : DG) {
performTest(D);
}
return true;
}
};
class ParamRegionTestAction : public ASTFrontendAction {
public:
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
StringRef File) override {
return std::make_unique<ParamRegionTestConsumer>(Compiler);
}
};
TEST(ParamRegion, ParamRegionTest) {
EXPECT_TRUE(
tooling::runToolOnCode(std::make_unique<ParamRegionTestAction>(),
R"(void foo(int n);
void baz(int p);
void foo(int n) {
auto lambda = [n](int m) {
return n + m;
};
int k = lambda(2);
}
void bar(int l) {
foo(l);
}
struct S {
int n;
S(int nn): n(nn) {}
};
void baz(int p) {
S s(p);
}
void bar(int l);
void baz(int p);)"));
EXPECT_TRUE(
tooling::runToolOnCode(std::make_unique<ParamRegionTestAction>(),
R"(@interface O
+ alloc;
- initWithInt:(int)q;
@end
void qix(int r) {
O *o = [[O alloc] initWithInt:r];
})",
"input.m"));
}
} // namespace
} // namespace ento
} // namespace clang
|
