|
150
|
1 //==- ProgramPoint.cpp - Program Points for Path-Sensitive Analysis -*- C++ -*-/
|
|
|
2 //
|
|
|
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
4 // See https://llvm.org/LICENSE.txt for license information.
|
|
|
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
|
6 //
|
|
|
7 //===----------------------------------------------------------------------===//
|
|
|
8 //
|
|
|
9 // This file defines the interface ProgramPoint, which identifies a
|
|
|
10 // distinct location in a function.
|
|
|
11 //
|
|
|
12 //===----------------------------------------------------------------------===//
|
|
|
13
|
|
|
14 #include "clang/Analysis/ProgramPoint.h"
|
|
173
|
15 #include "clang/AST/ASTContext.h"
|
|
150
|
16 #include "clang/Basic/JsonSupport.h"
|
|
|
17
|
|
|
18 using namespace clang;
|
|
|
19
|
|
|
20 ProgramPointTag::~ProgramPointTag() {}
|
|
|
21
|
|
|
22 ProgramPoint ProgramPoint::getProgramPoint(const Stmt *S, ProgramPoint::Kind K,
|
|
|
23 const LocationContext *LC,
|
|
|
24 const ProgramPointTag *tag){
|
|
|
25 switch (K) {
|
|
|
26 default:
|
|
|
27 llvm_unreachable("Unhandled ProgramPoint kind");
|
|
|
28 case ProgramPoint::PreStmtKind:
|
|
|
29 return PreStmt(S, LC, tag);
|
|
|
30 case ProgramPoint::PostStmtKind:
|
|
|
31 return PostStmt(S, LC, tag);
|
|
|
32 case ProgramPoint::PreLoadKind:
|
|
|
33 return PreLoad(S, LC, tag);
|
|
|
34 case ProgramPoint::PostLoadKind:
|
|
|
35 return PostLoad(S, LC, tag);
|
|
|
36 case ProgramPoint::PreStoreKind:
|
|
|
37 return PreStore(S, LC, tag);
|
|
|
38 case ProgramPoint::PostLValueKind:
|
|
|
39 return PostLValue(S, LC, tag);
|
|
|
40 case ProgramPoint::PostStmtPurgeDeadSymbolsKind:
|
|
|
41 return PostStmtPurgeDeadSymbols(S, LC, tag);
|
|
|
42 case ProgramPoint::PreStmtPurgeDeadSymbolsKind:
|
|
|
43 return PreStmtPurgeDeadSymbols(S, LC, tag);
|
|
|
44 }
|
|
|
45 }
|
|
|
46
|
|
|
47 LLVM_DUMP_METHOD void ProgramPoint::dump() const {
|
|
|
48 return printJson(llvm::errs());
|
|
|
49 }
|
|
|
50
|
|
|
51 void ProgramPoint::printJson(llvm::raw_ostream &Out, const char *NL) const {
|
|
|
52 const ASTContext &Context =
|
|
|
53 getLocationContext()->getAnalysisDeclContext()->getASTContext();
|
|
|
54 const SourceManager &SM = Context.getSourceManager();
|
|
|
55 const PrintingPolicy &PP = Context.getPrintingPolicy();
|
|
|
56 const bool AddQuotes = true;
|
|
|
57
|
|
|
58 Out << "\"kind\": \"";
|
|
|
59 switch (getKind()) {
|
|
|
60 case ProgramPoint::BlockEntranceKind:
|
|
|
61 Out << "BlockEntrance\""
|
|
|
62 << ", \"block_id\": "
|
|
|
63 << castAs<BlockEntrance>().getBlock()->getBlockID();
|
|
|
64 break;
|
|
|
65
|
|
|
66 case ProgramPoint::FunctionExitKind: {
|
|
|
67 auto FEP = getAs<FunctionExitPoint>();
|
|
|
68 Out << "FunctionExit\""
|
|
|
69 << ", \"block_id\": " << FEP->getBlock()->getBlockID()
|
|
|
70 << ", \"stmt_id\": ";
|
|
|
71
|
|
|
72 if (const ReturnStmt *RS = FEP->getStmt()) {
|
|
|
73 Out << RS->getID(Context) << ", \"stmt\": ";
|
|
|
74 RS->printJson(Out, nullptr, PP, AddQuotes);
|
|
|
75 } else {
|
|
|
76 Out << "null, \"stmt\": null";
|
|
|
77 }
|
|
|
78 break;
|
|
|
79 }
|
|
|
80 case ProgramPoint::BlockExitKind:
|
|
|
81 llvm_unreachable("BlockExitKind");
|
|
|
82 break;
|
|
|
83 case ProgramPoint::CallEnterKind:
|
|
|
84 Out << "CallEnter\"";
|
|
|
85 break;
|
|
|
86 case ProgramPoint::CallExitBeginKind:
|
|
|
87 Out << "CallExitBegin\"";
|
|
|
88 break;
|
|
|
89 case ProgramPoint::CallExitEndKind:
|
|
|
90 Out << "CallExitEnd\"";
|
|
|
91 break;
|
|
|
92 case ProgramPoint::EpsilonKind:
|
|
|
93 Out << "EpsilonPoint\"";
|
|
|
94 break;
|
|
|
95
|
|
|
96 case ProgramPoint::LoopExitKind:
|
|
|
97 Out << "LoopExit\", \"stmt\": \""
|
|
|
98 << castAs<LoopExit>().getLoopStmt()->getStmtClassName() << '\"';
|
|
|
99 break;
|
|
|
100
|
|
|
101 case ProgramPoint::PreImplicitCallKind: {
|
|
|
102 ImplicitCallPoint PC = castAs<ImplicitCallPoint>();
|
|
|
103 Out << "PreCall\", \"decl\": \""
|
|
|
104 << PC.getDecl()->getAsFunction()->getQualifiedNameAsString()
|
|
|
105 << "\", \"location\": ";
|
|
|
106 printSourceLocationAsJson(Out, PC.getLocation(), SM);
|
|
|
107 break;
|
|
|
108 }
|
|
|
109
|
|
|
110 case ProgramPoint::PostImplicitCallKind: {
|
|
|
111 ImplicitCallPoint PC = castAs<ImplicitCallPoint>();
|
|
|
112 Out << "PostCall\", \"decl\": \""
|
|
|
113 << PC.getDecl()->getAsFunction()->getQualifiedNameAsString()
|
|
|
114 << "\", \"location\": ";
|
|
|
115 printSourceLocationAsJson(Out, PC.getLocation(), SM);
|
|
|
116 break;
|
|
|
117 }
|
|
|
118
|
|
|
119 case ProgramPoint::PostInitializerKind: {
|
|
|
120 Out << "PostInitializer\", ";
|
|
|
121 const CXXCtorInitializer *Init = castAs<PostInitializer>().getInitializer();
|
|
|
122 if (const FieldDecl *FD = Init->getAnyMember()) {
|
|
|
123 Out << "\"field_decl\": \"" << *FD << '\"';
|
|
|
124 } else {
|
|
|
125 Out << "\"type\": \"";
|
|
|
126 QualType Ty = Init->getTypeSourceInfo()->getType();
|
|
|
127 Ty = Ty.getLocalUnqualifiedType();
|
|
|
128 Ty.print(Out, Context.getLangOpts());
|
|
|
129 Out << '\"';
|
|
|
130 }
|
|
|
131 break;
|
|
|
132 }
|
|
|
133
|
|
|
134 case ProgramPoint::BlockEdgeKind: {
|
|
|
135 const BlockEdge &E = castAs<BlockEdge>();
|
|
|
136 const Stmt *T = E.getSrc()->getTerminatorStmt();
|
|
|
137 Out << "Edge\", \"src_id\": " << E.getSrc()->getBlockID()
|
|
|
138 << ", \"dst_id\": " << E.getDst()->getBlockID() << ", \"terminator\": ";
|
|
|
139
|
|
|
140 if (!T) {
|
|
|
141 Out << "null, \"term_kind\": null";
|
|
|
142 break;
|
|
|
143 }
|
|
|
144
|
|
|
145 E.getSrc()->printTerminatorJson(Out, Context.getLangOpts(),
|
|
|
146 /*AddQuotes=*/true);
|
|
|
147 Out << ", \"location\": ";
|
|
|
148 printSourceLocationAsJson(Out, T->getBeginLoc(), SM);
|
|
|
149
|
|
|
150 Out << ", \"term_kind\": \"";
|
|
|
151 if (isa<SwitchStmt>(T)) {
|
|
|
152 Out << "SwitchStmt\", \"case\": ";
|
|
|
153 if (const Stmt *Label = E.getDst()->getLabel()) {
|
|
|
154 if (const auto *C = dyn_cast<CaseStmt>(Label)) {
|
|
|
155 Out << "{ \"lhs\": ";
|
|
|
156 if (const Stmt *LHS = C->getLHS()) {
|
|
|
157 LHS->printJson(Out, nullptr, PP, AddQuotes);
|
|
|
158 } else {
|
|
|
159 Out << "null";
|
|
|
160 }
|
|
|
161
|
|
|
162 Out << ", \"rhs\": ";
|
|
|
163 if (const Stmt *RHS = C->getRHS()) {
|
|
|
164 RHS->printJson(Out, nullptr, PP, AddQuotes);
|
|
|
165 } else {
|
|
|
166 Out << "null";
|
|
|
167 }
|
|
|
168 Out << " }";
|
|
|
169 } else {
|
|
|
170 assert(isa<DefaultStmt>(Label));
|
|
|
171 Out << "\"default\"";
|
|
|
172 }
|
|
|
173 } else {
|
|
|
174 Out << "\"implicit default\"";
|
|
|
175 }
|
|
|
176 } else if (isa<IndirectGotoStmt>(T)) {
|
|
|
177 // FIXME: More info.
|
|
|
178 Out << "IndirectGotoStmt\"";
|
|
|
179 } else {
|
|
|
180 Out << "Condition\", \"value\": "
|
|
|
181 << (*E.getSrc()->succ_begin() == E.getDst() ? "true" : "false");
|
|
|
182 }
|
|
|
183 break;
|
|
|
184 }
|
|
|
185
|
|
|
186 default: {
|
|
|
187 const Stmt *S = castAs<StmtPoint>().getStmt();
|
|
|
188 assert(S != nullptr && "Expecting non-null Stmt");
|
|
|
189
|
|
|
190 Out << "Statement\", \"stmt_kind\": \"" << S->getStmtClassName()
|
|
|
191 << "\", \"stmt_id\": " << S->getID(Context)
|
|
|
192 << ", \"pointer\": \"" << (const void *)S << "\", ";
|
|
|
193 if (const auto *CS = dyn_cast<CastExpr>(S))
|
|
|
194 Out << "\"cast_kind\": \"" << CS->getCastKindName() << "\", ";
|
|
|
195
|
|
|
196 Out << "\"pretty\": ";
|
|
|
197
|
|
|
198 S->printJson(Out, nullptr, PP, AddQuotes);
|
|
|
199
|
|
|
200 Out << ", \"location\": ";
|
|
|
201 printSourceLocationAsJson(Out, S->getBeginLoc(), SM);
|
|
|
202
|
|
|
203 Out << ", \"stmt_point_kind\": \"";
|
|
|
204 if (getAs<PreLoad>())
|
|
|
205 Out << "PreLoad";
|
|
|
206 else if (getAs<PreStore>())
|
|
|
207 Out << "PreStore";
|
|
|
208 else if (getAs<PostAllocatorCall>())
|
|
|
209 Out << "PostAllocatorCall";
|
|
|
210 else if (getAs<PostCondition>())
|
|
|
211 Out << "PostCondition";
|
|
|
212 else if (getAs<PostLoad>())
|
|
|
213 Out << "PostLoad";
|
|
|
214 else if (getAs<PostLValue>())
|
|
|
215 Out << "PostLValue";
|
|
|
216 else if (getAs<PostStore>())
|
|
|
217 Out << "PostStore";
|
|
|
218 else if (getAs<PostStmt>())
|
|
|
219 Out << "PostStmt";
|
|
|
220 else if (getAs<PostStmtPurgeDeadSymbols>())
|
|
|
221 Out << "PostStmtPurgeDeadSymbols";
|
|
|
222 else if (getAs<PreStmtPurgeDeadSymbols>())
|
|
|
223 Out << "PreStmtPurgeDeadSymbols";
|
|
|
224 else if (getAs<PreStmt>())
|
|
|
225 Out << "PreStmt";
|
|
|
226 else {
|
|
|
227 Out << "\nKind: '" << getKind();
|
|
|
228 llvm_unreachable("' is unhandled StmtPoint kind!");
|
|
|
229 }
|
|
|
230
|
|
|
231 Out << '\"';
|
|
|
232 break;
|
|
|
233 }
|
|
|
234 }
|
|
|
235 }
|
|
|
236
|
|
|
237 SimpleProgramPointTag::SimpleProgramPointTag(StringRef MsgProvider,
|
|
|
238 StringRef Msg)
|
|
|
239 : Desc((MsgProvider + " : " + Msg).str()) {}
|
|
|
240
|
|
|
241 StringRef SimpleProgramPointTag::getTagDescription() const {
|
|
|
242 return Desc;
|
|
|
243 }
|
