1 //===- ExprEngine.cpp - Path-Sensitive Expression-Level Dataflow ----------===//
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 a meta-engine for path-sensitive dataflow analysis that
10 // is built on GREngine, but provides the boilerplate to execute transfer
11 // functions and build the ExplodedGraph at the expression level.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #include "clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h"
16 #include "PrettyStackTraceLocationContext.h"
17 #include "clang/AST/ASTContext.h"
18 #include "clang/AST/Decl.h"
19 #include "clang/AST/DeclBase.h"
20 #include "clang/AST/DeclCXX.h"
21 #include "clang/AST/DeclObjC.h"
22 #include "clang/AST/Expr.h"
23 #include "clang/AST/ExprCXX.h"
24 #include "clang/AST/ExprObjC.h"
25 #include "clang/AST/ParentMap.h"
26 #include "clang/AST/PrettyPrinter.h"
27 #include "clang/AST/Stmt.h"
28 #include "clang/AST/StmtCXX.h"
29 #include "clang/AST/StmtObjC.h"
30 #include "clang/AST/Type.h"
31 #include "clang/Analysis/AnalysisDeclContext.h"
32 #include "clang/Analysis/CFG.h"
33 #include "clang/Analysis/ConstructionContext.h"
34 #include "clang/Analysis/ProgramPoint.h"
35 #include "clang/Basic/IdentifierTable.h"
36 #include "clang/Basic/JsonSupport.h"
37 #include "clang/Basic/LLVM.h"
38 #include "clang/Basic/LangOptions.h"
39 #include "clang/Basic/PrettyStackTrace.h"
40 #include "clang/Basic/SourceLocation.h"
41 #include "clang/Basic/SourceManager.h"
42 #include "clang/Basic/Specifiers.h"
43 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
44 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
45 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
46 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
47 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
48 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
49 #include "clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h"
50 #include "clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h"
51 #include "clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h"
52 #include "clang/StaticAnalyzer/Core/PathSensitive/LoopUnrolling.h"
53 #include "clang/StaticAnalyzer/Core/PathSensitive/LoopWidening.h"
54 #include "clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h"
55 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
56 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h"
57 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState_Fwd.h"
58 #include "clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h"
59 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
60 #include "clang/StaticAnalyzer/Core/PathSensitive/Store.h"
61 #include "clang/StaticAnalyzer/Core/PathSensitive/SymExpr.h"
62 #include "clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h"
63 #include "llvm/ADT/APSInt.h"
64 #include "llvm/ADT/DenseMap.h"
65 #include "llvm/ADT/ImmutableMap.h"
66 #include "llvm/ADT/ImmutableSet.h"
67 #include "llvm/ADT/Optional.h"
68 #include "llvm/ADT/SmallVector.h"
69 #include "llvm/ADT/Statistic.h"
70 #include "llvm/Support/Casting.h"
71 #include "llvm/Support/Compiler.h"
72 #include "llvm/Support/DOTGraphTraits.h"
73 #include "llvm/Support/ErrorHandling.h"
74 #include "llvm/Support/GraphWriter.h"
75 #include "llvm/Support/SaveAndRestore.h"
76 #include "llvm/Support/raw_ostream.h"
77 #include <cassert>
78 #include <cstdint>
79 #include <memory>
80 #include <string>
81 #include <tuple>
82 #include <utility>
83 #include <vector>
84
85 using namespace clang;
86 using namespace ento;
87
88 #define DEBUG_TYPE "ExprEngine"
89
90 STATISTIC(NumRemoveDeadBindings,
91 "The # of times RemoveDeadBindings is called");
92 STATISTIC(NumMaxBlockCountReached,
93 "The # of aborted paths due to reaching the maximum block count in "
94 "a top level function");
95 STATISTIC(NumMaxBlockCountReachedInInlined,
96 "The # of aborted paths due to reaching the maximum block count in "
97 "an inlined function");
98 STATISTIC(NumTimesRetriedWithoutInlining,
99 "The # of times we re-evaluated a call without inlining");
100
101 //===----------------------------------------------------------------------===//
102 // Internal program state traits.
103 //===----------------------------------------------------------------------===//
104
105 namespace {
106
107 // When modeling a C++ constructor, for a variety of reasons we need to track
108 // the location of the object for the duration of its ConstructionContext.
109 // ObjectsUnderConstruction maps statements within the construction context
110 // to the object's location, so that on every such statement the location
111 // could have been retrieved.
112
113 /// ConstructedObjectKey is used for being able to find the path-sensitive
114 /// memory region of a freshly constructed object while modeling the AST node
115 /// that syntactically represents the object that is being constructed.
116 /// Semantics of such nodes may sometimes require access to the region that's
117 /// not otherwise present in the program state, or to the very fact that
118 /// the construction context was present and contained references to these
119 /// AST nodes.
120 class ConstructedObjectKey {
121 typedef std::pair<ConstructionContextItem, const LocationContext *>
122 ConstructedObjectKeyImpl;
123
124 const ConstructedObjectKeyImpl Impl;
125
getAnyASTNodePtr() const126 const void *getAnyASTNodePtr() const {
127 if (const Stmt *S = getItem().getStmtOrNull())
128 return S;
129 else
130 return getItem().getCXXCtorInitializer();
131 }
132
133 public:
ConstructedObjectKey(const ConstructionContextItem & Item,const LocationContext * LC)134 explicit ConstructedObjectKey(const ConstructionContextItem &Item,
135 const LocationContext *LC)
136 : Impl(Item, LC) {}
137
getItem() const138 const ConstructionContextItem &getItem() const { return Impl.first; }
getLocationContext() const139 const LocationContext *getLocationContext() const { return Impl.second; }
140
getASTContext() const141 ASTContext &getASTContext() const {
142 return getLocationContext()->getDecl()->getASTContext();
143 }
144
printJson(llvm::raw_ostream & Out,PrinterHelper * Helper,PrintingPolicy & PP) const145 void printJson(llvm::raw_ostream &Out, PrinterHelper *Helper,
146 PrintingPolicy &PP) const {
147 const Stmt *S = getItem().getStmtOrNull();
148 const CXXCtorInitializer *I = nullptr;
149 if (!S)
150 I = getItem().getCXXCtorInitializer();
151
152 if (S)
153 Out << "\"stmt_id\": " << S->getID(getASTContext());
154 else
155 Out << "\"init_id\": " << I->getID(getASTContext());
156
157 // Kind
158 Out << ", \"kind\": \"" << getItem().getKindAsString()
159 << "\", \"argument_index\": ";
160
161 if (getItem().getKind() == ConstructionContextItem::ArgumentKind)
162 Out << getItem().getIndex();
163 else
164 Out << "null";
165
166 // Pretty-print
167 Out << ", \"pretty\": ";
168
169 if (S) {
170 S->printJson(Out, Helper, PP, /*AddQuotes=*/true);
171 } else {
172 Out << '\"' << I->getAnyMember()->getDeclName() << '\"';
173 }
174 }
175
Profile(llvm::FoldingSetNodeID & ID) const176 void Profile(llvm::FoldingSetNodeID &ID) const {
177 ID.Add(Impl.first);
178 ID.AddPointer(Impl.second);
179 }
180
operator ==(const ConstructedObjectKey & RHS) const181 bool operator==(const ConstructedObjectKey &RHS) const {
182 return Impl == RHS.Impl;
183 }
184
operator <(const ConstructedObjectKey & RHS) const185 bool operator<(const ConstructedObjectKey &RHS) const {
186 return Impl < RHS.Impl;
187 }
188 };
189 } // namespace
190
191 typedef llvm::ImmutableMap<ConstructedObjectKey, SVal>
192 ObjectsUnderConstructionMap;
193 REGISTER_TRAIT_WITH_PROGRAMSTATE(ObjectsUnderConstruction,
194 ObjectsUnderConstructionMap)
195
196 //===----------------------------------------------------------------------===//
197 // Engine construction and deletion.
198 //===----------------------------------------------------------------------===//
199
200 static const char* TagProviderName = "ExprEngine";
201
ExprEngine(cross_tu::CrossTranslationUnitContext & CTU,AnalysisManager & mgr,SetOfConstDecls * VisitedCalleesIn,FunctionSummariesTy * FS,InliningModes HowToInlineIn)202 ExprEngine::ExprEngine(cross_tu::CrossTranslationUnitContext &CTU,
203 AnalysisManager &mgr,
204 SetOfConstDecls *VisitedCalleesIn,
205 FunctionSummariesTy *FS,
206 InliningModes HowToInlineIn)
207 : CTU(CTU), AMgr(mgr),
208 AnalysisDeclContexts(mgr.getAnalysisDeclContextManager()),
209 Engine(*this, FS, mgr.getAnalyzerOptions()), G(Engine.getGraph()),
210 StateMgr(getContext(), mgr.getStoreManagerCreator(),
211 mgr.getConstraintManagerCreator(), G.getAllocator(),
212 this),
213 SymMgr(StateMgr.getSymbolManager()),
214 MRMgr(StateMgr.getRegionManager()),
215 svalBuilder(StateMgr.getSValBuilder()),
216 ObjCNoRet(mgr.getASTContext()),
217 BR(mgr, *this),
218 VisitedCallees(VisitedCalleesIn),
219 HowToInline(HowToInlineIn)
220 {
221 unsigned TrimInterval = mgr.options.GraphTrimInterval;
222 if (TrimInterval != 0) {
223 // Enable eager node reclamation when constructing the ExplodedGraph.
224 G.enableNodeReclamation(TrimInterval);
225 }
226 }
227
228 //===----------------------------------------------------------------------===//
229 // Utility methods.
230 //===----------------------------------------------------------------------===//
231
getInitialState(const LocationContext * InitLoc)232 ProgramStateRef ExprEngine::getInitialState(const LocationContext *InitLoc) {
233 ProgramStateRef state = StateMgr.getInitialState(InitLoc);
234 const Decl *D = InitLoc->getDecl();
235
236 // Preconditions.
237 // FIXME: It would be nice if we had a more general mechanism to add
238 // such preconditions. Some day.
239 do {
240 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
241 // Precondition: the first argument of 'main' is an integer guaranteed
242 // to be > 0.
243 const IdentifierInfo *II = FD->getIdentifier();
244 if (!II || !(II->getName() == "main" && FD->getNumParams() > 0))
245 break;
246
247 const ParmVarDecl *PD = FD->getParamDecl(0);
248 QualType T = PD->getType();
249 const auto *BT = dyn_cast<BuiltinType>(T);
250 if (!BT || !BT->isInteger())
251 break;
252
253 const MemRegion *R = state->getRegion(PD, InitLoc);
254 if (!R)
255 break;
256
257 SVal V = state->getSVal(loc::MemRegionVal(R));
258 SVal Constraint_untested = evalBinOp(state, BO_GT, V,
259 svalBuilder.makeZeroVal(T),
260 svalBuilder.getConditionType());
261
262 Optional<DefinedOrUnknownSVal> Constraint =
263 Constraint_untested.getAs<DefinedOrUnknownSVal>();
264
265 if (!Constraint)
266 break;
267
268 if (ProgramStateRef newState = state->assume(*Constraint, true))
269 state = newState;
270 }
271 break;
272 }
273 while (false);
274
275 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
276 // Precondition: 'self' is always non-null upon entry to an Objective-C
277 // method.
278 const ImplicitParamDecl *SelfD = MD->getSelfDecl();
279 const MemRegion *R = state->getRegion(SelfD, InitLoc);
280 SVal V = state->getSVal(loc::MemRegionVal(R));
281
282 if (Optional<Loc> LV = V.getAs<Loc>()) {
283 // Assume that the pointer value in 'self' is non-null.
284 state = state->assume(*LV, true);
285 assert(state && "'self' cannot be null");
286 }
287 }
288
289 if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
290 if (!MD->isStatic()) {
291 // Precondition: 'this' is always non-null upon entry to the
292 // top-level function. This is our starting assumption for
293 // analyzing an "open" program.
294 const StackFrameContext *SFC = InitLoc->getStackFrame();
295 if (SFC->getParent() == nullptr) {
296 loc::MemRegionVal L = svalBuilder.getCXXThis(MD, SFC);
297 SVal V = state->getSVal(L);
298 if (Optional<Loc> LV = V.getAs<Loc>()) {
299 state = state->assume(*LV, true);
300 assert(state && "'this' cannot be null");
301 }
302 }
303 }
304 }
305
306 return state;
307 }
308
createTemporaryRegionIfNeeded(ProgramStateRef State,const LocationContext * LC,const Expr * InitWithAdjustments,const Expr * Result,const SubRegion ** OutRegionWithAdjustments)309 ProgramStateRef ExprEngine::createTemporaryRegionIfNeeded(
310 ProgramStateRef State, const LocationContext *LC,
311 const Expr *InitWithAdjustments, const Expr *Result,
312 const SubRegion **OutRegionWithAdjustments) {
313 // FIXME: This function is a hack that works around the quirky AST
314 // we're often having with respect to C++ temporaries. If only we modelled
315 // the actual execution order of statements properly in the CFG,
316 // all the hassle with adjustments would not be necessary,
317 // and perhaps the whole function would be removed.
318 SVal InitValWithAdjustments = State->getSVal(InitWithAdjustments, LC);
319 if (!Result) {
320 // If we don't have an explicit result expression, we're in "if needed"
321 // mode. Only create a region if the current value is a NonLoc.
322 if (!InitValWithAdjustments.getAs<NonLoc>()) {
323 if (OutRegionWithAdjustments)
324 *OutRegionWithAdjustments = nullptr;
325 return State;
326 }
327 Result = InitWithAdjustments;
328 } else {
329 // We need to create a region no matter what. For sanity, make sure we don't
330 // try to stuff a Loc into a non-pointer temporary region.
331 assert(!InitValWithAdjustments.getAs<Loc>() ||
332 Loc::isLocType(Result->getType()) ||
333 Result->getType()->isMemberPointerType());
334 }
335
336 ProgramStateManager &StateMgr = State->getStateManager();
337 MemRegionManager &MRMgr = StateMgr.getRegionManager();
338 StoreManager &StoreMgr = StateMgr.getStoreManager();
339
340 // MaterializeTemporaryExpr may appear out of place, after a few field and
341 // base-class accesses have been made to the object, even though semantically
342 // it is the whole object that gets materialized and lifetime-extended.
343 //
344 // For example:
345 //
346 // `-MaterializeTemporaryExpr
347 // `-MemberExpr
348 // `-CXXTemporaryObjectExpr
349 //
350 // instead of the more natural
351 //
352 // `-MemberExpr
353 // `-MaterializeTemporaryExpr
354 // `-CXXTemporaryObjectExpr
355 //
356 // Use the usual methods for obtaining the expression of the base object,
357 // and record the adjustments that we need to make to obtain the sub-object
358 // that the whole expression 'Ex' refers to. This trick is usual,
359 // in the sense that CodeGen takes a similar route.
360
361 SmallVector<const Expr *, 2> CommaLHSs;
362 SmallVector<SubobjectAdjustment, 2> Adjustments;
363
364 const Expr *Init = InitWithAdjustments->skipRValueSubobjectAdjustments(
365 CommaLHSs, Adjustments);
366
367 // Take the region for Init, i.e. for the whole object. If we do not remember
368 // the region in which the object originally was constructed, come up with
369 // a new temporary region out of thin air and copy the contents of the object
370 // (which are currently present in the Environment, because Init is an rvalue)
371 // into that region. This is not correct, but it is better than nothing.
372 const TypedValueRegion *TR = nullptr;
373 if (const auto *MT = dyn_cast<MaterializeTemporaryExpr>(Result)) {
374 if (Optional<SVal> V = getObjectUnderConstruction(State, MT, LC)) {
375 State = finishObjectConstruction(State, MT, LC);
376 State = State->BindExpr(Result, LC, *V);
377 return State;
378 } else {
379 StorageDuration SD = MT->getStorageDuration();
380 // If this object is bound to a reference with static storage duration, we
381 // put it in a different region to prevent "address leakage" warnings.
382 if (SD == SD_Static || SD == SD_Thread) {
383 TR = MRMgr.getCXXStaticTempObjectRegion(Init);
384 } else {
385 TR = MRMgr.getCXXTempObjectRegion(Init, LC);
386 }
387 }
388 } else {
389 TR = MRMgr.getCXXTempObjectRegion(Init, LC);
390 }
391
392 SVal Reg = loc::MemRegionVal(TR);
393 SVal BaseReg = Reg;
394
395 // Make the necessary adjustments to obtain the sub-object.
396 for (auto I = Adjustments.rbegin(), E = Adjustments.rend(); I != E; ++I) {
397 const SubobjectAdjustment &Adj = *I;
398 switch (Adj.Kind) {
399 case SubobjectAdjustment::DerivedToBaseAdjustment:
400 Reg = StoreMgr.evalDerivedToBase(Reg, Adj.DerivedToBase.BasePath);
401 break;
402 case SubobjectAdjustment::FieldAdjustment:
403 Reg = StoreMgr.getLValueField(Adj.Field, Reg);
404 break;
405 case SubobjectAdjustment::MemberPointerAdjustment:
406 // FIXME: Unimplemented.
407 State = State->invalidateRegions(Reg, InitWithAdjustments,
408 currBldrCtx->blockCount(), LC, true,
409 nullptr, nullptr, nullptr);
410 return State;
411 }
412 }
413
414 // What remains is to copy the value of the object to the new region.
415 // FIXME: In other words, what we should always do is copy value of the
416 // Init expression (which corresponds to the bigger object) to the whole
417 // temporary region TR. However, this value is often no longer present
418 // in the Environment. If it has disappeared, we instead invalidate TR.
419 // Still, what we can do is assign the value of expression Ex (which
420 // corresponds to the sub-object) to the TR's sub-region Reg. At least,
421 // values inside Reg would be correct.
422 SVal InitVal = State->getSVal(Init, LC);
423 if (InitVal.isUnknown()) {
424 InitVal = getSValBuilder().conjureSymbolVal(Result, LC, Init->getType(),
425 currBldrCtx->blockCount());
426 State = State->bindLoc(BaseReg.castAs<Loc>(), InitVal, LC, false);
427
428 // Then we'd need to take the value that certainly exists and bind it
429 // over.
430 if (InitValWithAdjustments.isUnknown()) {
431 // Try to recover some path sensitivity in case we couldn't
432 // compute the value.
433 InitValWithAdjustments = getSValBuilder().conjureSymbolVal(
434 Result, LC, InitWithAdjustments->getType(),
435 currBldrCtx->blockCount());
436 }
437 State =
438 State->bindLoc(Reg.castAs<Loc>(), InitValWithAdjustments, LC, false);
439 } else {
440 State = State->bindLoc(BaseReg.castAs<Loc>(), InitVal, LC, false);
441 }
442
443 // The result expression would now point to the correct sub-region of the
444 // newly created temporary region. Do this last in order to getSVal of Init
445 // correctly in case (Result == Init).
446 if (Result->isGLValue()) {
447 State = State->BindExpr(Result, LC, Reg);
448 } else {
449 State = State->BindExpr(Result, LC, InitValWithAdjustments);
450 }
451
452 // Notify checkers once for two bindLoc()s.
453 State = processRegionChange(State, TR, LC);
454
455 if (OutRegionWithAdjustments)
456 *OutRegionWithAdjustments = cast<SubRegion>(Reg.getAsRegion());
457 return State;
458 }
459
460 ProgramStateRef
addObjectUnderConstruction(ProgramStateRef State,const ConstructionContextItem & Item,const LocationContext * LC,SVal V)461 ExprEngine::addObjectUnderConstruction(ProgramStateRef State,
462 const ConstructionContextItem &Item,
463 const LocationContext *LC, SVal V) {
464 ConstructedObjectKey Key(Item, LC->getStackFrame());
465 // FIXME: Currently the state might already contain the marker due to
466 // incorrect handling of temporaries bound to default parameters.
467 assert(!State->get<ObjectsUnderConstruction>(Key) ||
468 Key.getItem().getKind() ==
469 ConstructionContextItem::TemporaryDestructorKind);
470 return State->set<ObjectsUnderConstruction>(Key, V);
471 }
472
473 Optional<SVal>
getObjectUnderConstruction(ProgramStateRef State,const ConstructionContextItem & Item,const LocationContext * LC)474 ExprEngine::getObjectUnderConstruction(ProgramStateRef State,
475 const ConstructionContextItem &Item,
476 const LocationContext *LC) {
477 ConstructedObjectKey Key(Item, LC->getStackFrame());
478 return Optional<SVal>::create(State->get<ObjectsUnderConstruction>(Key));
479 }
480
481 ProgramStateRef
finishObjectConstruction(ProgramStateRef State,const ConstructionContextItem & Item,const LocationContext * LC)482 ExprEngine::finishObjectConstruction(ProgramStateRef State,
483 const ConstructionContextItem &Item,
484 const LocationContext *LC) {
485 ConstructedObjectKey Key(Item, LC->getStackFrame());
486 assert(State->contains<ObjectsUnderConstruction>(Key));
487 return State->remove<ObjectsUnderConstruction>(Key);
488 }
489
elideDestructor(ProgramStateRef State,const CXXBindTemporaryExpr * BTE,const LocationContext * LC)490 ProgramStateRef ExprEngine::elideDestructor(ProgramStateRef State,
491 const CXXBindTemporaryExpr *BTE,
492 const LocationContext *LC) {
493 ConstructedObjectKey Key({BTE, /*IsElided=*/true}, LC);
494 // FIXME: Currently the state might already contain the marker due to
495 // incorrect handling of temporaries bound to default parameters.
496 return State->set<ObjectsUnderConstruction>(Key, UnknownVal());
497 }
498
499 ProgramStateRef
cleanupElidedDestructor(ProgramStateRef State,const CXXBindTemporaryExpr * BTE,const LocationContext * LC)500 ExprEngine::cleanupElidedDestructor(ProgramStateRef State,
501 const CXXBindTemporaryExpr *BTE,
502 const LocationContext *LC) {
503 ConstructedObjectKey Key({BTE, /*IsElided=*/true}, LC);
504 assert(State->contains<ObjectsUnderConstruction>(Key));
505 return State->remove<ObjectsUnderConstruction>(Key);
506 }
507
isDestructorElided(ProgramStateRef State,const CXXBindTemporaryExpr * BTE,const LocationContext * LC)508 bool ExprEngine::isDestructorElided(ProgramStateRef State,
509 const CXXBindTemporaryExpr *BTE,
510 const LocationContext *LC) {
511 ConstructedObjectKey Key({BTE, /*IsElided=*/true}, LC);
512 return State->contains<ObjectsUnderConstruction>(Key);
513 }
514
areAllObjectsFullyConstructed(ProgramStateRef State,const LocationContext * FromLC,const LocationContext * ToLC)515 bool ExprEngine::areAllObjectsFullyConstructed(ProgramStateRef State,
516 const LocationContext *FromLC,
517 const LocationContext *ToLC) {
518 const LocationContext *LC = FromLC;
519 while (LC != ToLC) {
520 assert(LC && "ToLC must be a parent of FromLC!");
521 for (auto I : State->get<ObjectsUnderConstruction>())
522 if (I.first.getLocationContext() == LC)
523 return false;
524
525 LC = LC->getParent();
526 }
527 return true;
528 }
529
530
531 //===----------------------------------------------------------------------===//
532 // Top-level transfer function logic (Dispatcher).
533 //===----------------------------------------------------------------------===//
534
535 /// evalAssume - Called by ConstraintManager. Used to call checker-specific
536 /// logic for handling assumptions on symbolic values.
processAssume(ProgramStateRef state,SVal cond,bool assumption)537 ProgramStateRef ExprEngine::processAssume(ProgramStateRef state,
538 SVal cond, bool assumption) {
539 return getCheckerManager().runCheckersForEvalAssume(state, cond, assumption);
540 }
541
542 ProgramStateRef
processRegionChanges(ProgramStateRef state,const InvalidatedSymbols * invalidated,ArrayRef<const MemRegion * > Explicits,ArrayRef<const MemRegion * > Regions,const LocationContext * LCtx,const CallEvent * Call)543 ExprEngine::processRegionChanges(ProgramStateRef state,
544 const InvalidatedSymbols *invalidated,
545 ArrayRef<const MemRegion *> Explicits,
546 ArrayRef<const MemRegion *> Regions,
547 const LocationContext *LCtx,
548 const CallEvent *Call) {
549 return getCheckerManager().runCheckersForRegionChanges(state, invalidated,
550 Explicits, Regions,
551 LCtx, Call);
552 }
553
554 static void
printObjectsUnderConstructionJson(raw_ostream & Out,ProgramStateRef State,const char * NL,const LocationContext * LCtx,unsigned int Space=0,bool IsDot=false)555 printObjectsUnderConstructionJson(raw_ostream &Out, ProgramStateRef State,
556 const char *NL, const LocationContext *LCtx,
557 unsigned int Space = 0, bool IsDot = false) {
558 PrintingPolicy PP =
559 LCtx->getAnalysisDeclContext()->getASTContext().getPrintingPolicy();
560
561 ++Space;
562 bool HasItem = false;
563
564 // Store the last key.
565 const ConstructedObjectKey *LastKey = nullptr;
566 for (const auto &I : State->get<ObjectsUnderConstruction>()) {
567 const ConstructedObjectKey &Key = I.first;
568 if (Key.getLocationContext() != LCtx)
569 continue;
570
571 if (!HasItem) {
572 Out << "[" << NL;
573 HasItem = true;
574 }
575
576 LastKey = &Key;
577 }
578
579 for (const auto &I : State->get<ObjectsUnderConstruction>()) {
580 const ConstructedObjectKey &Key = I.first;
581 SVal Value = I.second;
582 if (Key.getLocationContext() != LCtx)
583 continue;
584
585 Indent(Out, Space, IsDot) << "{ ";
586 Key.printJson(Out, nullptr, PP);
587 Out << ", \"value\": \"" << Value << "\" }";
588
589 if (&Key != LastKey)
590 Out << ',';
591 Out << NL;
592 }
593
594 if (HasItem)
595 Indent(Out, --Space, IsDot) << ']'; // End of "location_context".
596 else {
597 Out << "null ";
598 }
599 }
600
printJson(raw_ostream & Out,ProgramStateRef State,const LocationContext * LCtx,const char * NL,unsigned int Space,bool IsDot) const601 void ExprEngine::printJson(raw_ostream &Out, ProgramStateRef State,
602 const LocationContext *LCtx, const char *NL,
603 unsigned int Space, bool IsDot) const {
604 Indent(Out, Space, IsDot) << "\"constructing_objects\": ";
605
606 if (LCtx && !State->get<ObjectsUnderConstruction>().isEmpty()) {
607 ++Space;
608 Out << '[' << NL;
609 LCtx->printJson(Out, NL, Space, IsDot, [&](const LocationContext *LC) {
610 printObjectsUnderConstructionJson(Out, State, NL, LC, Space, IsDot);
611 });
612
613 --Space;
614 Indent(Out, Space, IsDot) << "]," << NL; // End of "constructing_objects".
615 } else {
616 Out << "null," << NL;
617 }
618
619 getCheckerManager().runCheckersForPrintStateJson(Out, State, NL, Space,
620 IsDot);
621 }
622
processEndWorklist()623 void ExprEngine::processEndWorklist() {
624 getCheckerManager().runCheckersForEndAnalysis(G, BR, *this);
625 }
626
processCFGElement(const CFGElement E,ExplodedNode * Pred,unsigned StmtIdx,NodeBuilderContext * Ctx)627 void ExprEngine::processCFGElement(const CFGElement E, ExplodedNode *Pred,
628 unsigned StmtIdx, NodeBuilderContext *Ctx) {
629 PrettyStackTraceLocationContext CrashInfo(Pred->getLocationContext());
630 currStmtIdx = StmtIdx;
631 currBldrCtx = Ctx;
632
633 switch (E.getKind()) {
634 case CFGElement::Statement:
635 case CFGElement::Constructor:
636 case CFGElement::CXXRecordTypedCall:
637 ProcessStmt(E.castAs<CFGStmt>().getStmt(), Pred);
638 return;
639 case CFGElement::Initializer:
640 ProcessInitializer(E.castAs<CFGInitializer>(), Pred);
641 return;
642 case CFGElement::NewAllocator:
643 ProcessNewAllocator(E.castAs<CFGNewAllocator>().getAllocatorExpr(),
644 Pred);
645 return;
646 case CFGElement::AutomaticObjectDtor:
647 case CFGElement::DeleteDtor:
648 case CFGElement::BaseDtor:
649 case CFGElement::MemberDtor:
650 case CFGElement::TemporaryDtor:
651 ProcessImplicitDtor(E.castAs<CFGImplicitDtor>(), Pred);
652 return;
653 case CFGElement::LoopExit:
654 ProcessLoopExit(E.castAs<CFGLoopExit>().getLoopStmt(), Pred);
655 return;
656 case CFGElement::LifetimeEnds:
657 case CFGElement::ScopeBegin:
658 case CFGElement::ScopeEnd:
659 return;
660 }
661 }
662
shouldRemoveDeadBindings(AnalysisManager & AMgr,const Stmt * S,const ExplodedNode * Pred,const LocationContext * LC)663 static bool shouldRemoveDeadBindings(AnalysisManager &AMgr,
664 const Stmt *S,
665 const ExplodedNode *Pred,
666 const LocationContext *LC) {
667 // Are we never purging state values?
668 if (AMgr.options.AnalysisPurgeOpt == PurgeNone)
669 return false;
670
671 // Is this the beginning of a basic block?
672 if (Pred->getLocation().getAs<BlockEntrance>())
673 return true;
674
675 // Is this on a non-expression?
676 if (!isa<Expr>(S))
677 return true;
678
679 // Run before processing a call.
680 if (CallEvent::isCallStmt(S))
681 return true;
682
683 // Is this an expression that is consumed by another expression? If so,
684 // postpone cleaning out the state.
685 ParentMap &PM = LC->getAnalysisDeclContext()->getParentMap();
686 return !PM.isConsumedExpr(cast<Expr>(S));
687 }
688
removeDead(ExplodedNode * Pred,ExplodedNodeSet & Out,const Stmt * ReferenceStmt,const LocationContext * LC,const Stmt * DiagnosticStmt,ProgramPoint::Kind K)689 void ExprEngine::removeDead(ExplodedNode *Pred, ExplodedNodeSet &Out,
690 const Stmt *ReferenceStmt,
691 const LocationContext *LC,
692 const Stmt *DiagnosticStmt,
693 ProgramPoint::Kind K) {
694 assert((K == ProgramPoint::PreStmtPurgeDeadSymbolsKind ||
695 ReferenceStmt == nullptr || isa<ReturnStmt>(ReferenceStmt))
696 && "PostStmt is not generally supported by the SymbolReaper yet");
697 assert(LC && "Must pass the current (or expiring) LocationContext");
698
699 if (!DiagnosticStmt) {
700 DiagnosticStmt = ReferenceStmt;
701 assert(DiagnosticStmt && "Required for clearing a LocationContext");
702 }
703
704 NumRemoveDeadBindings++;
705 ProgramStateRef CleanedState = Pred->getState();
706
707 // LC is the location context being destroyed, but SymbolReaper wants a
708 // location context that is still live. (If this is the top-level stack
709 // frame, this will be null.)
710 if (!ReferenceStmt) {
711 assert(K == ProgramPoint::PostStmtPurgeDeadSymbolsKind &&
712 "Use PostStmtPurgeDeadSymbolsKind for clearing a LocationContext");
713 LC = LC->getParent();
714 }
715
716 const StackFrameContext *SFC = LC ? LC->getStackFrame() : nullptr;
717 SymbolReaper SymReaper(SFC, ReferenceStmt, SymMgr, getStoreManager());
718
719 for (auto I : CleanedState->get<ObjectsUnderConstruction>()) {
720 if (SymbolRef Sym = I.second.getAsSymbol())
721 SymReaper.markLive(Sym);
722 if (const MemRegion *MR = I.second.getAsRegion())
723 SymReaper.markLive(MR);
724 }
725
726 getCheckerManager().runCheckersForLiveSymbols(CleanedState, SymReaper);
727
728 // Create a state in which dead bindings are removed from the environment
729 // and the store. TODO: The function should just return new env and store,
730 // not a new state.
731 CleanedState = StateMgr.removeDeadBindingsFromEnvironmentAndStore(
732 CleanedState, SFC, SymReaper);
733
734 // Process any special transfer function for dead symbols.
735 // A tag to track convenience transitions, which can be removed at cleanup.
736 static SimpleProgramPointTag cleanupTag(TagProviderName, "Clean Node");
737 // Call checkers with the non-cleaned state so that they could query the
738 // values of the soon to be dead symbols.
739 ExplodedNodeSet CheckedSet;
740 getCheckerManager().runCheckersForDeadSymbols(CheckedSet, Pred, SymReaper,
741 DiagnosticStmt, *this, K);
742
743 // For each node in CheckedSet, generate CleanedNodes that have the
744 // environment, the store, and the constraints cleaned up but have the
745 // user-supplied states as the predecessors.
746 StmtNodeBuilder Bldr(CheckedSet, Out, *currBldrCtx);
747 for (const auto I : CheckedSet) {
748 ProgramStateRef CheckerState = I->getState();
749
750 // The constraint manager has not been cleaned up yet, so clean up now.
751 CheckerState =
752 getConstraintManager().removeDeadBindings(CheckerState, SymReaper);
753
754 assert(StateMgr.haveEqualEnvironments(CheckerState, Pred->getState()) &&
755 "Checkers are not allowed to modify the Environment as a part of "
756 "checkDeadSymbols processing.");
757 assert(StateMgr.haveEqualStores(CheckerState, Pred->getState()) &&
758 "Checkers are not allowed to modify the Store as a part of "
759 "checkDeadSymbols processing.");
760
761 // Create a state based on CleanedState with CheckerState GDM and
762 // generate a transition to that state.
763 ProgramStateRef CleanedCheckerSt =
764 StateMgr.getPersistentStateWithGDM(CleanedState, CheckerState);
765 Bldr.generateNode(DiagnosticStmt, I, CleanedCheckerSt, &cleanupTag, K);
766 }
767 }
768
ProcessStmt(const Stmt * currStmt,ExplodedNode * Pred)769 void ExprEngine::ProcessStmt(const Stmt *currStmt, ExplodedNode *Pred) {
770 // Reclaim any unnecessary nodes in the ExplodedGraph.
771 G.reclaimRecentlyAllocatedNodes();
772
773 PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
774 currStmt->getBeginLoc(),
775 "Error evaluating statement");
776
777 // Remove dead bindings and symbols.
778 ExplodedNodeSet CleanedStates;
779 if (shouldRemoveDeadBindings(AMgr, currStmt, Pred,
780 Pred->getLocationContext())) {
781 removeDead(Pred, CleanedStates, currStmt,
782 Pred->getLocationContext());
783 } else
784 CleanedStates.Add(Pred);
785
786 // Visit the statement.
787 ExplodedNodeSet Dst;
788 for (const auto I : CleanedStates) {
789 ExplodedNodeSet DstI;
790 // Visit the statement.
791 Visit(currStmt, I, DstI);
792 Dst.insert(DstI);
793 }
794
795 // Enqueue the new nodes onto the work list.
796 Engine.enqueue(Dst, currBldrCtx->getBlock(), currStmtIdx);
797 }
798
ProcessLoopExit(const Stmt * S,ExplodedNode * Pred)799 void ExprEngine::ProcessLoopExit(const Stmt* S, ExplodedNode *Pred) {
800 PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
801 S->getBeginLoc(),
802 "Error evaluating end of the loop");
803 ExplodedNodeSet Dst;
804 Dst.Add(Pred);
805 NodeBuilder Bldr(Pred, Dst, *currBldrCtx);
806 ProgramStateRef NewState = Pred->getState();
807
808 if(AMgr.options.ShouldUnrollLoops)
809 NewState = processLoopEnd(S, NewState);
810
811 LoopExit PP(S, Pred->getLocationContext());
812 Bldr.generateNode(PP, NewState, Pred);
813 // Enqueue the new nodes onto the work list.
814 Engine.enqueue(Dst, currBldrCtx->getBlock(), currStmtIdx);
815 }
816
ProcessInitializer(const CFGInitializer CFGInit,ExplodedNode * Pred)817 void ExprEngine::ProcessInitializer(const CFGInitializer CFGInit,
818 ExplodedNode *Pred) {
819 const CXXCtorInitializer *BMI = CFGInit.getInitializer();
820 const Expr *Init = BMI->getInit()->IgnoreImplicit();
821 const LocationContext *LC = Pred->getLocationContext();
822
823 PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
824 BMI->getSourceLocation(),
825 "Error evaluating initializer");
826
827 // We don't clean up dead bindings here.
828 const auto *stackFrame = cast<StackFrameContext>(Pred->getLocationContext());
829 const auto *decl = cast<CXXConstructorDecl>(stackFrame->getDecl());
830
831 ProgramStateRef State = Pred->getState();
832 SVal thisVal = State->getSVal(svalBuilder.getCXXThis(decl, stackFrame));
833
834 ExplodedNodeSet Tmp;
835 SVal FieldLoc;
836
837 // Evaluate the initializer, if necessary
838 if (BMI->isAnyMemberInitializer()) {
839 // Constructors build the object directly in the field,
840 // but non-objects must be copied in from the initializer.
841 if (getObjectUnderConstruction(State, BMI, LC)) {
842 // The field was directly constructed, so there is no need to bind.
843 // But we still need to stop tracking the object under construction.
844 State = finishObjectConstruction(State, BMI, LC);
845 NodeBuilder Bldr(Pred, Tmp, *currBldrCtx);
846 PostStore PS(Init, LC, /*Loc*/ nullptr, /*tag*/ nullptr);
847 Bldr.generateNode(PS, State, Pred);
848 } else {
849 const ValueDecl *Field;
850 if (BMI->isIndirectMemberInitializer()) {
851 Field = BMI->getIndirectMember();
852 FieldLoc = State->getLValue(BMI->getIndirectMember(), thisVal);
853 } else {
854 Field = BMI->getMember();
855 FieldLoc = State->getLValue(BMI->getMember(), thisVal);
856 }
857
858 SVal InitVal;
859 if (Init->getType()->isArrayType()) {
860 // Handle arrays of trivial type. We can represent this with a
861 // primitive load/copy from the base array region.
862 const ArraySubscriptExpr *ASE;
863 while ((ASE = dyn_cast<ArraySubscriptExpr>(Init)))
864 Init = ASE->getBase()->IgnoreImplicit();
865
866 SVal LValue = State->getSVal(Init, stackFrame);
867 if (!Field->getType()->isReferenceType())
868 if (Optional<Loc> LValueLoc = LValue.getAs<Loc>())
869 InitVal = State->getSVal(*LValueLoc);
870
871 // If we fail to get the value for some reason, use a symbolic value.
872 if (InitVal.isUnknownOrUndef()) {
873 SValBuilder &SVB = getSValBuilder();
874 InitVal = SVB.conjureSymbolVal(BMI->getInit(), stackFrame,
875 Field->getType(),
876 currBldrCtx->blockCount());
877 }
878 } else {
879 InitVal = State->getSVal(BMI->getInit(), stackFrame);
880 }
881
882 PostInitializer PP(BMI, FieldLoc.getAsRegion(), stackFrame);
883 evalBind(Tmp, Init, Pred, FieldLoc, InitVal, /*isInit=*/true, &PP);
884 }
885 } else {
886 assert(BMI->isBaseInitializer() || BMI->isDelegatingInitializer());
887 Tmp.insert(Pred);
888 // We already did all the work when visiting the CXXConstructExpr.
889 }
890
891 // Construct PostInitializer nodes whether the state changed or not,
892 // so that the diagnostics don't get confused.
893 PostInitializer PP(BMI, FieldLoc.getAsRegion(), stackFrame);
894 ExplodedNodeSet Dst;
895 NodeBuilder Bldr(Tmp, Dst, *currBldrCtx);
896 for (const auto I : Tmp) {
897 ProgramStateRef State = I->getState();
898 Bldr.generateNode(PP, State, I);
899 }
900
901 // Enqueue the new nodes onto the work list.
902 Engine.enqueue(Dst, currBldrCtx->getBlock(), currStmtIdx);
903 }
904
ProcessImplicitDtor(const CFGImplicitDtor D,ExplodedNode * Pred)905 void ExprEngine::ProcessImplicitDtor(const CFGImplicitDtor D,
906 ExplodedNode *Pred) {
907 ExplodedNodeSet Dst;
908 switch (D.getKind()) {
909 case CFGElement::AutomaticObjectDtor:
910 ProcessAutomaticObjDtor(D.castAs<CFGAutomaticObjDtor>(), Pred, Dst);
911 break;
912 case CFGElement::BaseDtor:
913 ProcessBaseDtor(D.castAs<CFGBaseDtor>(), Pred, Dst);
914 break;
915 case CFGElement::MemberDtor:
916 ProcessMemberDtor(D.castAs<CFGMemberDtor>(), Pred, Dst);
917 break;
918 case CFGElement::TemporaryDtor:
919 ProcessTemporaryDtor(D.castAs<CFGTemporaryDtor>(), Pred, Dst);
920 break;
921 case CFGElement::DeleteDtor:
922 ProcessDeleteDtor(D.castAs<CFGDeleteDtor>(), Pred, Dst);
923 break;
924 default:
925 llvm_unreachable("Unexpected dtor kind.");
926 }
927
928 // Enqueue the new nodes onto the work list.
929 Engine.enqueue(Dst, currBldrCtx->getBlock(), currStmtIdx);
930 }
931
ProcessNewAllocator(const CXXNewExpr * NE,ExplodedNode * Pred)932 void ExprEngine::ProcessNewAllocator(const CXXNewExpr *NE,
933 ExplodedNode *Pred) {
934 ExplodedNodeSet Dst;
935 AnalysisManager &AMgr = getAnalysisManager();
936 AnalyzerOptions &Opts = AMgr.options;
937 // TODO: We're not evaluating allocators for all cases just yet as
938 // we're not handling the return value correctly, which causes false
939 // positives when the alpha.cplusplus.NewDeleteLeaks check is on.
940 if (Opts.MayInlineCXXAllocator)
941 VisitCXXNewAllocatorCall(NE, Pred, Dst);
942 else {
943 NodeBuilder Bldr(Pred, Dst, *currBldrCtx);
944 const LocationContext *LCtx = Pred->getLocationContext();
945 PostImplicitCall PP(NE->getOperatorNew(), NE->getBeginLoc(), LCtx);
946 Bldr.generateNode(PP, Pred->getState(), Pred);
947 }
948 Engine.enqueue(Dst, currBldrCtx->getBlock(), currStmtIdx);
949 }
950
ProcessAutomaticObjDtor(const CFGAutomaticObjDtor Dtor,ExplodedNode * Pred,ExplodedNodeSet & Dst)951 void ExprEngine::ProcessAutomaticObjDtor(const CFGAutomaticObjDtor Dtor,
952 ExplodedNode *Pred,
953 ExplodedNodeSet &Dst) {
954 const VarDecl *varDecl = Dtor.getVarDecl();
955 QualType varType = varDecl->getType();
956
957 ProgramStateRef state = Pred->getState();
958 SVal dest = state->getLValue(varDecl, Pred->getLocationContext());
959 const MemRegion *Region = dest.castAs<loc::MemRegionVal>().getRegion();
960
961 if (varType->isReferenceType()) {
962 const MemRegion *ValueRegion = state->getSVal(Region).getAsRegion();
963 if (!ValueRegion) {
964 // FIXME: This should not happen. The language guarantees a presence
965 // of a valid initializer here, so the reference shall not be undefined.
966 // It seems that we're calling destructors over variables that
967 // were not initialized yet.
968 return;
969 }
970 Region = ValueRegion->getBaseRegion();
971 varType = cast<TypedValueRegion>(Region)->getValueType();
972 }
973
974 // FIXME: We need to run the same destructor on every element of the array.
975 // This workaround will just run the first destructor (which will still
976 // invalidate the entire array).
977 EvalCallOptions CallOpts;
978 Region = makeZeroElementRegion(state, loc::MemRegionVal(Region), varType,
979 CallOpts.IsArrayCtorOrDtor).getAsRegion();
980
981 VisitCXXDestructor(varType, Region, Dtor.getTriggerStmt(),
982 /*IsBase=*/false, Pred, Dst, CallOpts);
983 }
984
ProcessDeleteDtor(const CFGDeleteDtor Dtor,ExplodedNode * Pred,ExplodedNodeSet & Dst)985 void ExprEngine::ProcessDeleteDtor(const CFGDeleteDtor Dtor,
986 ExplodedNode *Pred,
987 ExplodedNodeSet &Dst) {
988 ProgramStateRef State = Pred->getState();
989 const LocationContext *LCtx = Pred->getLocationContext();
990 const CXXDeleteExpr *DE = Dtor.getDeleteExpr();
991 const Stmt *Arg = DE->getArgument();
992 QualType DTy = DE->getDestroyedType();
993 SVal ArgVal = State->getSVal(Arg, LCtx);
994
995 // If the argument to delete is known to be a null value,
996 // don't run destructor.
997 if (State->isNull(ArgVal).isConstrainedTrue()) {
998 QualType BTy = getContext().getBaseElementType(DTy);
999 const CXXRecordDecl *RD = BTy->getAsCXXRecordDecl();
1000 const CXXDestructorDecl *Dtor = RD->getDestructor();
1001
1002 PostImplicitCall PP(Dtor, DE->getBeginLoc(), LCtx);
1003 NodeBuilder Bldr(Pred, Dst, *currBldrCtx);
1004 Bldr.generateNode(PP, Pred->getState(), Pred);
1005 return;
1006 }
1007
1008 EvalCallOptions CallOpts;
1009 const MemRegion *ArgR = ArgVal.getAsRegion();
1010 if (DE->isArrayForm()) {
1011 // FIXME: We need to run the same destructor on every element of the array.
1012 // This workaround will just run the first destructor (which will still
1013 // invalidate the entire array).
1014 CallOpts.IsArrayCtorOrDtor = true;
1015 // Yes, it may even be a multi-dimensional array.
1016 while (const auto *AT = getContext().getAsArrayType(DTy))
1017 DTy = AT->getElementType();
1018 if (ArgR)
1019 ArgR = getStoreManager().GetElementZeroRegion(cast<SubRegion>(ArgR), DTy);
1020 }
1021
1022 VisitCXXDestructor(DTy, ArgR, DE, /*IsBase=*/false, Pred, Dst, CallOpts);
1023 }
1024
ProcessBaseDtor(const CFGBaseDtor D,ExplodedNode * Pred,ExplodedNodeSet & Dst)1025 void ExprEngine::ProcessBaseDtor(const CFGBaseDtor D,
1026 ExplodedNode *Pred, ExplodedNodeSet &Dst) {
1027 const LocationContext *LCtx = Pred->getLocationContext();
1028
1029 const auto *CurDtor = cast<CXXDestructorDecl>(LCtx->getDecl());
1030 Loc ThisPtr = getSValBuilder().getCXXThis(CurDtor,
1031 LCtx->getStackFrame());
1032 SVal ThisVal = Pred->getState()->getSVal(ThisPtr);
1033
1034 // Create the base object region.
1035 const CXXBaseSpecifier *Base = D.getBaseSpecifier();
1036 QualType BaseTy = Base->getType();
1037 SVal BaseVal = getStoreManager().evalDerivedToBase(ThisVal, BaseTy,
1038 Base->isVirtual());
1039
1040 EvalCallOptions CallOpts;
1041 VisitCXXDestructor(BaseTy, BaseVal.getAsRegion(), CurDtor->getBody(),
1042 /*IsBase=*/true, Pred, Dst, CallOpts);
1043 }
1044
ProcessMemberDtor(const CFGMemberDtor D,ExplodedNode * Pred,ExplodedNodeSet & Dst)1045 void ExprEngine::ProcessMemberDtor(const CFGMemberDtor D,
1046 ExplodedNode *Pred, ExplodedNodeSet &Dst) {
1047 const FieldDecl *Member = D.getFieldDecl();
1048 QualType T = Member->getType();
1049 ProgramStateRef State = Pred->getState();
1050 const LocationContext *LCtx = Pred->getLocationContext();
1051
1052 const auto *CurDtor = cast<CXXDestructorDecl>(LCtx->getDecl());
1053 Loc ThisStorageLoc =
1054 getSValBuilder().getCXXThis(CurDtor, LCtx->getStackFrame());
1055 Loc ThisLoc = State->getSVal(ThisStorageLoc).castAs<Loc>();
1056 SVal FieldVal = State->getLValue(Member, ThisLoc);
1057
1058 // FIXME: We need to run the same destructor on every element of the array.
1059 // This workaround will just run the first destructor (which will still
1060 // invalidate the entire array).
1061 EvalCallOptions CallOpts;
1062 FieldVal = makeZeroElementRegion(State, FieldVal, T,
1063 CallOpts.IsArrayCtorOrDtor);
1064
1065 VisitCXXDestructor(T, FieldVal.getAsRegion(), CurDtor->getBody(),
1066 /*IsBase=*/false, Pred, Dst, CallOpts);
1067 }
1068
ProcessTemporaryDtor(const CFGTemporaryDtor D,ExplodedNode * Pred,ExplodedNodeSet & Dst)1069 void ExprEngine::ProcessTemporaryDtor(const CFGTemporaryDtor D,
1070 ExplodedNode *Pred,
1071 ExplodedNodeSet &Dst) {
1072 const CXXBindTemporaryExpr *BTE = D.getBindTemporaryExpr();
1073 ProgramStateRef State = Pred->getState();
1074 const LocationContext *LC = Pred->getLocationContext();
1075 const MemRegion *MR = nullptr;
1076
1077 if (Optional<SVal> V =
1078 getObjectUnderConstruction(State, D.getBindTemporaryExpr(),
1079 Pred->getLocationContext())) {
1080 // FIXME: Currently we insert temporary destructors for default parameters,
1081 // but we don't insert the constructors, so the entry in
1082 // ObjectsUnderConstruction may be missing.
1083 State = finishObjectConstruction(State, D.getBindTemporaryExpr(),
1084 Pred->getLocationContext());
1085 MR = V->getAsRegion();
1086 }
1087
1088 // If copy elision has occurred, and the constructor corresponding to the
1089 // destructor was elided, we need to skip the destructor as well.
1090 if (isDestructorElided(State, BTE, LC)) {
1091 State = cleanupElidedDestructor(State, BTE, LC);
1092 NodeBuilder Bldr(Pred, Dst, *currBldrCtx);
1093 PostImplicitCall PP(D.getDestructorDecl(getContext()),
1094 D.getBindTemporaryExpr()->getBeginLoc(),
1095 Pred->getLocationContext());
1096 Bldr.generateNode(PP, State, Pred);
1097 return;
1098 }
1099
1100 ExplodedNodeSet CleanDtorState;
1101 StmtNodeBuilder StmtBldr(Pred, CleanDtorState, *currBldrCtx);
1102 StmtBldr.generateNode(D.getBindTemporaryExpr(), Pred, State);
1103
1104 QualType T = D.getBindTemporaryExpr()->getSubExpr()->getType();
1105 // FIXME: Currently CleanDtorState can be empty here due to temporaries being
1106 // bound to default parameters.
1107 assert(CleanDtorState.size() <= 1);
1108 ExplodedNode *CleanPred =
1109 CleanDtorState.empty() ? Pred : *CleanDtorState.begin();
1110
1111 EvalCallOptions CallOpts;
1112 CallOpts.IsTemporaryCtorOrDtor = true;
1113 if (!MR) {
1114 // If we have no MR, we still need to unwrap the array to avoid destroying
1115 // the whole array at once. Regardless, we'd eventually need to model array
1116 // destructors properly, element-by-element.
1117 while (const ArrayType *AT = getContext().getAsArrayType(T)) {
1118 T = AT->getElementType();
1119 CallOpts.IsArrayCtorOrDtor = true;
1120 }
1121 } else {
1122 // We'd eventually need to makeZeroElementRegion() trick here,
1123 // but for now we don't have the respective construction contexts,
1124 // so MR would always be null in this case. Do nothing for now.
1125 }
1126 VisitCXXDestructor(T, MR, D.getBindTemporaryExpr(),
1127 /*IsBase=*/false, CleanPred, Dst, CallOpts);
1128 }
1129
processCleanupTemporaryBranch(const CXXBindTemporaryExpr * BTE,NodeBuilderContext & BldCtx,ExplodedNode * Pred,ExplodedNodeSet & Dst,const CFGBlock * DstT,const CFGBlock * DstF)1130 void ExprEngine::processCleanupTemporaryBranch(const CXXBindTemporaryExpr *BTE,
1131 NodeBuilderContext &BldCtx,
1132 ExplodedNode *Pred,
1133 ExplodedNodeSet &Dst,
1134 const CFGBlock *DstT,
1135 const CFGBlock *DstF) {
1136 BranchNodeBuilder TempDtorBuilder(Pred, Dst, BldCtx, DstT, DstF);
1137 ProgramStateRef State = Pred->getState();
1138 const LocationContext *LC = Pred->getLocationContext();
1139 if (getObjectUnderConstruction(State, BTE, LC)) {
1140 TempDtorBuilder.markInfeasible(false);
1141 TempDtorBuilder.generateNode(State, true, Pred);
1142 } else {
1143 TempDtorBuilder.markInfeasible(true);
1144 TempDtorBuilder.generateNode(State, false, Pred);
1145 }
1146 }
1147
VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr * BTE,ExplodedNodeSet & PreVisit,ExplodedNodeSet & Dst)1148 void ExprEngine::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *BTE,
1149 ExplodedNodeSet &PreVisit,
1150 ExplodedNodeSet &Dst) {
1151 // This is a fallback solution in case we didn't have a construction
1152 // context when we were constructing the temporary. Otherwise the map should
1153 // have been populated there.
1154 if (!getAnalysisManager().options.ShouldIncludeTemporaryDtorsInCFG) {
1155 // In case we don't have temporary destructors in the CFG, do not mark
1156 // the initialization - we would otherwise never clean it up.
1157 Dst = PreVisit;
1158 return;
1159 }
1160 StmtNodeBuilder StmtBldr(PreVisit, Dst, *currBldrCtx);
1161 for (ExplodedNode *Node : PreVisit) {
1162 ProgramStateRef State = Node->getState();
1163 const LocationContext *LC = Node->getLocationContext();
1164 if (!getObjectUnderConstruction(State, BTE, LC)) {
1165 // FIXME: Currently the state might also already contain the marker due to
1166 // incorrect handling of temporaries bound to default parameters; for
1167 // those, we currently skip the CXXBindTemporaryExpr but rely on adding
1168 // temporary destructor nodes.
1169 State = addObjectUnderConstruction(State, BTE, LC, UnknownVal());
1170 }
1171 StmtBldr.generateNode(BTE, Node, State);
1172 }
1173 }
1174
escapeValues(ProgramStateRef State,ArrayRef<SVal> Vs,PointerEscapeKind K,const CallEvent * Call) const1175 ProgramStateRef ExprEngine::escapeValues(ProgramStateRef State,
1176 ArrayRef<SVal> Vs,
1177 PointerEscapeKind K,
1178 const CallEvent *Call) const {
1179 class CollectReachableSymbolsCallback final : public SymbolVisitor {
1180 InvalidatedSymbols &Symbols;
1181
1182 public:
1183 explicit CollectReachableSymbolsCallback(InvalidatedSymbols &Symbols)
1184 : Symbols(Symbols) {}
1185
1186 const InvalidatedSymbols &getSymbols() const { return Symbols; }
1187
1188 bool VisitSymbol(SymbolRef Sym) override {
1189 Symbols.insert(Sym);
1190 return true;
1191 }
1192 };
1193 InvalidatedSymbols Symbols;
1194 CollectReachableSymbolsCallback CallBack(Symbols);
1195 for (SVal V : Vs)
1196 State->scanReachableSymbols(V, CallBack);
1197
1198 return getCheckerManager().runCheckersForPointerEscape(
1199 State, CallBack.getSymbols(), Call, K, nullptr);
1200 }
1201
Visit(const Stmt * S,ExplodedNode * Pred,ExplodedNodeSet & DstTop)1202 void ExprEngine::Visit(const Stmt *S, ExplodedNode *Pred,
1203 ExplodedNodeSet &DstTop) {
1204 PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
1205 S->getBeginLoc(), "Error evaluating statement");
1206 ExplodedNodeSet Dst;
1207 StmtNodeBuilder Bldr(Pred, DstTop, *currBldrCtx);
1208
1209 assert(!isa<Expr>(S) || S == cast<Expr>(S)->IgnoreParens());
1210
1211 switch (S->getStmtClass()) {
1212 // C++, OpenMP and ARC stuff we don't support yet.
1213 case Stmt::CXXDependentScopeMemberExprClass:
1214 case Stmt::CXXTryStmtClass:
1215 case Stmt::CXXTypeidExprClass:
1216 case Stmt::CXXUuidofExprClass:
1217 case Stmt::CXXFoldExprClass:
1218 case Stmt::MSPropertyRefExprClass:
1219 case Stmt::MSPropertySubscriptExprClass:
1220 case Stmt::CXXUnresolvedConstructExprClass:
1221 case Stmt::DependentScopeDeclRefExprClass:
1222 case Stmt::ArrayTypeTraitExprClass:
1223 case Stmt::ExpressionTraitExprClass:
1224 case Stmt::UnresolvedLookupExprClass:
1225 case Stmt::UnresolvedMemberExprClass:
1226 case Stmt::TypoExprClass:
1227 case Stmt::RecoveryExprClass:
1228 case Stmt::CXXNoexceptExprClass:
1229 case Stmt::PackExpansionExprClass:
1230 case Stmt::SubstNonTypeTemplateParmPackExprClass:
1231 case Stmt::FunctionParmPackExprClass:
1232 case Stmt::CoroutineBodyStmtClass:
1233 case Stmt::CoawaitExprClass:
1234 case Stmt::DependentCoawaitExprClass:
1235 case Stmt::CoreturnStmtClass:
1236 case Stmt::CoyieldExprClass:
1237 case Stmt::SEHTryStmtClass:
1238 case Stmt::SEHExceptStmtClass:
1239 case Stmt::SEHLeaveStmtClass:
1240 case Stmt::SEHFinallyStmtClass:
1241 case Stmt::OMPCanonicalLoopClass:
1242 case Stmt::OMPParallelDirectiveClass:
1243 case Stmt::OMPSimdDirectiveClass:
1244 case Stmt::OMPForDirectiveClass:
1245 case Stmt::OMPForSimdDirectiveClass:
1246 case Stmt::OMPSectionsDirectiveClass:
1247 case Stmt::OMPSectionDirectiveClass:
1248 case Stmt::OMPSingleDirectiveClass:
1249 case Stmt::OMPMasterDirectiveClass:
1250 case Stmt::OMPCriticalDirectiveClass:
1251 case Stmt::OMPParallelForDirectiveClass:
1252 case Stmt::OMPParallelForSimdDirectiveClass:
1253 case Stmt::OMPParallelSectionsDirectiveClass:
1254 case Stmt::OMPParallelMasterDirectiveClass:
1255 case Stmt::OMPTaskDirectiveClass:
1256 case Stmt::OMPTaskyieldDirectiveClass:
1257 case Stmt::OMPBarrierDirectiveClass:
1258 case Stmt::OMPTaskwaitDirectiveClass:
1259 case Stmt::OMPTaskgroupDirectiveClass:
1260 case Stmt::OMPFlushDirectiveClass:
1261 case Stmt::OMPDepobjDirectiveClass:
1262 case Stmt::OMPScanDirectiveClass:
1263 case Stmt::OMPOrderedDirectiveClass:
1264 case Stmt::OMPAtomicDirectiveClass:
1265 case Stmt::OMPTargetDirectiveClass:
1266 case Stmt::OMPTargetDataDirectiveClass:
1267 case Stmt::OMPTargetEnterDataDirectiveClass:
1268 case Stmt::OMPTargetExitDataDirectiveClass:
1269 case Stmt::OMPTargetParallelDirectiveClass:
1270 case Stmt::OMPTargetParallelForDirectiveClass:
1271 case Stmt::OMPTargetUpdateDirectiveClass:
1272 case Stmt::OMPTeamsDirectiveClass:
1273 case Stmt::OMPCancellationPointDirectiveClass:
1274 case Stmt::OMPCancelDirectiveClass:
1275 case Stmt::OMPTaskLoopDirectiveClass:
1276 case Stmt::OMPTaskLoopSimdDirectiveClass:
1277 case Stmt::OMPMasterTaskLoopDirectiveClass:
1278 case Stmt::OMPMasterTaskLoopSimdDirectiveClass:
1279 case Stmt::OMPParallelMasterTaskLoopDirectiveClass:
1280 case Stmt::OMPParallelMasterTaskLoopSimdDirectiveClass:
1281 case Stmt::OMPDistributeDirectiveClass:
1282 case Stmt::OMPDistributeParallelForDirectiveClass:
1283 case Stmt::OMPDistributeParallelForSimdDirectiveClass:
1284 case Stmt::OMPDistributeSimdDirectiveClass:
1285 case Stmt::OMPTargetParallelForSimdDirectiveClass:
1286 case Stmt::OMPTargetSimdDirectiveClass:
1287 case Stmt::OMPTeamsDistributeDirectiveClass:
1288 case Stmt::OMPTeamsDistributeSimdDirectiveClass:
1289 case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:
1290 case Stmt::OMPTeamsDistributeParallelForDirectiveClass:
1291 case Stmt::OMPTargetTeamsDirectiveClass:
1292 case Stmt::OMPTargetTeamsDistributeDirectiveClass:
1293 case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
1294 case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
1295 case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
1296 case Stmt::OMPTileDirectiveClass:
1297 case Stmt::OMPInteropDirectiveClass:
1298 case Stmt::OMPDispatchDirectiveClass:
1299 case Stmt::OMPMaskedDirectiveClass:
1300 case Stmt::CapturedStmtClass:
1301 case Stmt::OMPUnrollDirectiveClass: {
1302 const ExplodedNode *node = Bldr.generateSink(S, Pred, Pred->getState());
1303 Engine.addAbortedBlock(node, currBldrCtx->getBlock());
1304 break;
1305 }
1306
1307 case Stmt::ParenExprClass:
1308 llvm_unreachable("ParenExprs already handled.");
1309 case Stmt::GenericSelectionExprClass:
1310 llvm_unreachable("GenericSelectionExprs already handled.");
1311 // Cases that should never be evaluated simply because they shouldn't
1312 // appear in the CFG.
1313 case Stmt::BreakStmtClass:
1314 case Stmt::CaseStmtClass:
1315 case Stmt::CompoundStmtClass:
1316 case Stmt::ContinueStmtClass:
1317 case Stmt::CXXForRangeStmtClass:
1318 case Stmt::DefaultStmtClass:
1319 case Stmt::DoStmtClass:
1320 case Stmt::ForStmtClass:
1321 case Stmt::GotoStmtClass:
1322 case Stmt::IfStmtClass:
1323 case Stmt::IndirectGotoStmtClass:
1324 case Stmt::LabelStmtClass:
1325 case Stmt::NoStmtClass:
1326 case Stmt::NullStmtClass:
1327 case Stmt::SwitchStmtClass:
1328 case Stmt::WhileStmtClass:
1329 case Expr::MSDependentExistsStmtClass:
1330 llvm_unreachable("Stmt should not be in analyzer evaluation loop");
1331 case Stmt::ImplicitValueInitExprClass:
1332 // These nodes are shared in the CFG and would case caching out.
1333 // Moreover, no additional evaluation required for them, the
1334 // analyzer can reconstruct these values from the AST.
1335 llvm_unreachable("Should be pruned from CFG");
1336
1337 case Stmt::ObjCSubscriptRefExprClass:
1338 case Stmt::ObjCPropertyRefExprClass:
1339 llvm_unreachable("These are handled by PseudoObjectExpr");
1340
1341 case Stmt::GNUNullExprClass: {
1342 // GNU __null is a pointer-width integer, not an actual pointer.
1343 ProgramStateRef state = Pred->getState();
1344 state = state->BindExpr(S, Pred->getLocationContext(),
1345 svalBuilder.makeIntValWithPtrWidth(0, false));
1346 Bldr.generateNode(S, Pred, state);
1347 break;
1348 }
1349
1350 case Stmt::ObjCAtSynchronizedStmtClass:
1351 Bldr.takeNodes(Pred);
1352 VisitObjCAtSynchronizedStmt(cast<ObjCAtSynchronizedStmt>(S), Pred, Dst);
1353 Bldr.addNodes(Dst);
1354 break;
1355
1356 case Expr::ConstantExprClass:
1357 case Stmt::ExprWithCleanupsClass:
1358 // Handled due to fully linearised CFG.
1359 break;
1360
1361 case Stmt::CXXBindTemporaryExprClass: {
1362 Bldr.takeNodes(Pred);
1363 ExplodedNodeSet PreVisit;
1364 getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
1365 ExplodedNodeSet Next;
1366 VisitCXXBindTemporaryExpr(cast<CXXBindTemporaryExpr>(S), PreVisit, Next);
1367 getCheckerManager().runCheckersForPostStmt(Dst, Next, S, *this);
1368 Bldr.addNodes(Dst);
1369 break;
1370 }
1371
1372 // Cases not handled yet; but will handle some day.
1373 case Stmt::DesignatedInitExprClass:
1374 case Stmt::DesignatedInitUpdateExprClass:
1375 case Stmt::ArrayInitLoopExprClass:
1376 case Stmt::ArrayInitIndexExprClass:
1377 case Stmt::ExtVectorElementExprClass:
1378 case Stmt::ImaginaryLiteralClass:
1379 case Stmt::ObjCAtCatchStmtClass:
1380 case Stmt::ObjCAtFinallyStmtClass:
1381 case Stmt::ObjCAtTryStmtClass:
1382 case Stmt::ObjCAutoreleasePoolStmtClass:
1383 case Stmt::ObjCEncodeExprClass:
1384 case Stmt::ObjCIsaExprClass:
1385 case Stmt::ObjCProtocolExprClass:
1386 case Stmt::ObjCSelectorExprClass:
1387 case Stmt::ParenListExprClass:
1388 case Stmt::ShuffleVectorExprClass:
1389 case Stmt::ConvertVectorExprClass:
1390 case Stmt::VAArgExprClass:
1391 case Stmt::CUDAKernelCallExprClass:
1392 case Stmt::OpaqueValueExprClass:
1393 case Stmt::AsTypeExprClass:
1394 case Stmt::ConceptSpecializationExprClass:
1395 case Stmt::CXXRewrittenBinaryOperatorClass:
1396 case Stmt::RequiresExprClass:
1397 // Fall through.
1398
1399 // Cases we intentionally don't evaluate, since they don't need
1400 // to be explicitly evaluated.
1401 case Stmt::PredefinedExprClass:
1402 case Stmt::AddrLabelExprClass:
1403 case Stmt::AttributedStmtClass:
1404 case Stmt::IntegerLiteralClass:
1405 case Stmt::FixedPointLiteralClass:
1406 case Stmt::CharacterLiteralClass:
1407 case Stmt::CXXScalarValueInitExprClass:
1408 case Stmt::CXXBoolLiteralExprClass:
1409 case Stmt::ObjCBoolLiteralExprClass:
1410 case Stmt::ObjCAvailabilityCheckExprClass:
1411 case Stmt::FloatingLiteralClass:
1412 case Stmt::NoInitExprClass:
1413 case Stmt::SizeOfPackExprClass:
1414 case Stmt::StringLiteralClass:
1415 case Stmt::SourceLocExprClass:
1416 case Stmt::ObjCStringLiteralClass:
1417 case Stmt::CXXPseudoDestructorExprClass:
1418 case Stmt::SubstNonTypeTemplateParmExprClass:
1419 case Stmt::CXXNullPtrLiteralExprClass:
1420 case Stmt::OMPArraySectionExprClass:
1421 case Stmt::OMPArrayShapingExprClass:
1422 case Stmt::OMPIteratorExprClass:
1423 case Stmt::SYCLUniqueStableNameExprClass:
1424 case Stmt::TypeTraitExprClass: {
1425 Bldr.takeNodes(Pred);
1426 ExplodedNodeSet preVisit;
1427 getCheckerManager().runCheckersForPreStmt(preVisit, Pred, S, *this);
1428 getCheckerManager().runCheckersForPostStmt(Dst, preVisit, S, *this);
1429 Bldr.addNodes(Dst);
1430 break;
1431 }
1432
1433 case Stmt::CXXDefaultArgExprClass:
1434 case Stmt::CXXDefaultInitExprClass: {
1435 Bldr.takeNodes(Pred);
1436 ExplodedNodeSet PreVisit;
1437 getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
1438
1439 ExplodedNodeSet Tmp;
1440 StmtNodeBuilder Bldr2(PreVisit, Tmp, *currBldrCtx);
1441
1442 const Expr *ArgE;
1443 if (const auto *DefE = dyn_cast<CXXDefaultArgExpr>(S))
1444 ArgE = DefE->getExpr();
1445 else if (const auto *DefE = dyn_cast<CXXDefaultInitExpr>(S))
1446 ArgE = DefE->getExpr();
1447 else
1448 llvm_unreachable("unknown constant wrapper kind");
1449
1450 bool IsTemporary = false;
1451 if (const auto *MTE = dyn_cast<MaterializeTemporaryExpr>(ArgE)) {
1452 ArgE = MTE->getSubExpr();
1453 IsTemporary = true;
1454 }
1455
1456 Optional<SVal> ConstantVal = svalBuilder.getConstantVal(ArgE);
1457 if (!ConstantVal)
1458 ConstantVal = UnknownVal();
1459
1460 const LocationContext *LCtx = Pred->getLocationContext();
1461 for (const auto I : PreVisit) {
1462 ProgramStateRef State = I->getState();
1463 State = State->BindExpr(S, LCtx, *ConstantVal);
1464 if (IsTemporary)
1465 State = createTemporaryRegionIfNeeded(State, LCtx,
1466 cast<Expr>(S),
1467 cast<Expr>(S));
1468 Bldr2.generateNode(S, I, State);
1469 }
1470
1471 getCheckerManager().runCheckersForPostStmt(Dst, Tmp, S, *this);
1472 Bldr.addNodes(Dst);
1473 break;
1474 }
1475
1476 // Cases we evaluate as opaque expressions, conjuring a symbol.
1477 case Stmt::CXXStdInitializerListExprClass:
1478 case Expr::ObjCArrayLiteralClass:
1479 case Expr::ObjCDictionaryLiteralClass:
1480 case Expr::ObjCBoxedExprClass: {
1481 Bldr.takeNodes(Pred);
1482
1483 ExplodedNodeSet preVisit;
1484 getCheckerManager().runCheckersForPreStmt(preVisit, Pred, S, *this);
1485
1486 ExplodedNodeSet Tmp;
1487 StmtNodeBuilder Bldr2(preVisit, Tmp, *currBldrCtx);
1488
1489 const auto *Ex = cast<Expr>(S);
1490 QualType resultType = Ex->getType();
1491
1492 for (const auto N : preVisit) {
1493 const LocationContext *LCtx = N->getLocationContext();
1494 SVal result = svalBuilder.conjureSymbolVal(nullptr, Ex, LCtx,
1495 resultType,
1496 currBldrCtx->blockCount());
1497 ProgramStateRef State = N->getState()->BindExpr(Ex, LCtx, result);
1498
1499 // Escape pointers passed into the list, unless it's an ObjC boxed
1500 // expression which is not a boxable C structure.
1501 if (!(isa<ObjCBoxedExpr>(Ex) &&
1502 !cast<ObjCBoxedExpr>(Ex)->getSubExpr()
1503 ->getType()->isRecordType()))
1504 for (auto Child : Ex->children()) {
1505 assert(Child);
1506 SVal Val = State->getSVal(Child, LCtx);
1507 State = escapeValues(State, Val, PSK_EscapeOther);
1508 }
1509
1510 Bldr2.generateNode(S, N, State);
1511 }
1512
1513 getCheckerManager().runCheckersForPostStmt(Dst, Tmp, S, *this);
1514 Bldr.addNodes(Dst);
1515 break;
1516 }
1517
1518 case Stmt::ArraySubscriptExprClass:
1519 Bldr.takeNodes(Pred);
1520 VisitArraySubscriptExpr(cast<ArraySubscriptExpr>(S), Pred, Dst);
1521 Bldr.addNodes(Dst);
1522 break;
1523
1524 case Stmt::MatrixSubscriptExprClass:
1525 llvm_unreachable("Support for MatrixSubscriptExpr is not implemented.");
1526 break;
1527
1528 case Stmt::GCCAsmStmtClass:
1529 Bldr.takeNodes(Pred);
1530 VisitGCCAsmStmt(cast<GCCAsmStmt>(S), Pred, Dst);
1531 Bldr.addNodes(Dst);
1532 break;
1533
1534 case Stmt::MSAsmStmtClass:
1535 Bldr.takeNodes(Pred);
1536 VisitMSAsmStmt(cast<MSAsmStmt>(S), Pred, Dst);
1537 Bldr.addNodes(Dst);
1538 break;
1539
1540 case Stmt::BlockExprClass:
1541 Bldr.takeNodes(Pred);
1542 VisitBlockExpr(cast<BlockExpr>(S), Pred, Dst);
1543 Bldr.addNodes(Dst);
1544 break;
1545
1546 case Stmt::LambdaExprClass:
1547 if (AMgr.options.ShouldInlineLambdas) {
1548 Bldr.takeNodes(Pred);
1549 VisitLambdaExpr(cast<LambdaExpr>(S), Pred, Dst);
1550 Bldr.addNodes(Dst);
1551 } else {
1552 const ExplodedNode *node = Bldr.generateSink(S, Pred, Pred->getState());
1553 Engine.addAbortedBlock(node, currBldrCtx->getBlock());
1554 }
1555 break;
1556
1557 case Stmt::BinaryOperatorClass: {
1558 const auto *B = cast<BinaryOperator>(S);
1559 if (B->isLogicalOp()) {
1560 Bldr.takeNodes(Pred);
1561 VisitLogicalExpr(B, Pred, Dst);
1562 Bldr.addNodes(Dst);
1563 break;
1564 }
1565 else if (B->getOpcode() == BO_Comma) {
1566 ProgramStateRef state = Pred->getState();
1567 Bldr.generateNode(B, Pred,
1568 state->BindExpr(B, Pred->getLocationContext(),
1569 state->getSVal(B->getRHS(),
1570 Pred->getLocationContext())));
1571 break;
1572 }
1573
1574 Bldr.takeNodes(Pred);
1575
1576 if (AMgr.options.ShouldEagerlyAssume &&
1577 (B->isRelationalOp() || B->isEqualityOp())) {
1578 ExplodedNodeSet Tmp;
1579 VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Tmp);
1580 evalEagerlyAssumeBinOpBifurcation(Dst, Tmp, cast<Expr>(S));
1581 }
1582 else
1583 VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Dst);
1584
1585 Bldr.addNodes(Dst);
1586 break;
1587 }
1588
1589 case Stmt::CXXOperatorCallExprClass: {
1590 const auto *OCE = cast<CXXOperatorCallExpr>(S);
1591
1592 // For instance method operators, make sure the 'this' argument has a
1593 // valid region.
1594 const Decl *Callee = OCE->getCalleeDecl();
1595 if (const auto *MD = dyn_cast_or_null<CXXMethodDecl>(Callee)) {
1596 if (MD->isInstance()) {
1597 ProgramStateRef State = Pred->getState();
1598 const LocationContext *LCtx = Pred->getLocationContext();
1599 ProgramStateRef NewState =
1600 createTemporaryRegionIfNeeded(State, LCtx, OCE->getArg(0));
1601 if (NewState != State) {
1602 Pred = Bldr.generateNode(OCE, Pred, NewState, /*tag=*/nullptr,
1603 ProgramPoint::PreStmtKind);
1604 // Did we cache out?
1605 if (!Pred)
1606 break;
1607 }
1608 }
1609 }
1610 // FALLTHROUGH
1611 LLVM_FALLTHROUGH;
1612 }
1613
1614 case Stmt::CallExprClass:
1615 case Stmt::CXXMemberCallExprClass:
1616 case Stmt::UserDefinedLiteralClass:
1617 Bldr.takeNodes(Pred);
1618 VisitCallExpr(cast<CallExpr>(S), Pred, Dst);
1619 Bldr.addNodes(Dst);
1620 break;
1621
1622 case Stmt::CXXCatchStmtClass:
1623 Bldr.takeNodes(Pred);
1624 VisitCXXCatchStmt(cast<CXXCatchStmt>(S), Pred, Dst);
1625 Bldr.addNodes(Dst);
1626 break;
1627
1628 case Stmt::CXXTemporaryObjectExprClass:
1629 case Stmt::CXXConstructExprClass:
1630 Bldr.takeNodes(Pred);
1631 VisitCXXConstructExpr(cast<CXXConstructExpr>(S), Pred, Dst);
1632 Bldr.addNodes(Dst);
1633 break;
1634
1635 case Stmt::CXXInheritedCtorInitExprClass:
1636 Bldr.takeNodes(Pred);
1637 VisitCXXInheritedCtorInitExpr(cast<CXXInheritedCtorInitExpr>(S), Pred,
1638 Dst);
1639 Bldr.addNodes(Dst);
1640 break;
1641
1642 case Stmt::CXXNewExprClass: {
1643 Bldr.takeNodes(Pred);
1644
1645 ExplodedNodeSet PreVisit;
1646 getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
1647
1648 ExplodedNodeSet PostVisit;
1649 for (const auto i : PreVisit)
1650 VisitCXXNewExpr(cast<CXXNewExpr>(S), i, PostVisit);
1651
1652 getCheckerManager().runCheckersForPostStmt(Dst, PostVisit, S, *this);
1653 Bldr.addNodes(Dst);
1654 break;
1655 }
1656
1657 case Stmt::CXXDeleteExprClass: {
1658 Bldr.takeNodes(Pred);
1659 ExplodedNodeSet PreVisit;
1660 const auto *CDE = cast<CXXDeleteExpr>(S);
1661 getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
1662 ExplodedNodeSet PostVisit;
1663 getCheckerManager().runCheckersForPostStmt(PostVisit, PreVisit, S, *this);
1664
1665 for (const auto i : PostVisit)
1666 VisitCXXDeleteExpr(CDE, i, Dst);
1667
1668 Bldr.addNodes(Dst);
1669 break;
1670 }
1671 // FIXME: ChooseExpr is really a constant. We need to fix
1672 // the CFG do not model them as explicit control-flow.
1673
1674 case Stmt::ChooseExprClass: { // __builtin_choose_expr
1675 Bldr.takeNodes(Pred);
1676 const auto *C = cast<ChooseExpr>(S);
1677 VisitGuardedExpr(C, C->getLHS(), C->getRHS(), Pred, Dst);
1678 Bldr.addNodes(Dst);
1679 break;
1680 }
1681
1682 case Stmt::CompoundAssignOperatorClass:
1683 Bldr.takeNodes(Pred);
1684 VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Dst);
1685 Bldr.addNodes(Dst);
1686 break;
1687
1688 case Stmt::CompoundLiteralExprClass:
1689 Bldr.takeNodes(Pred);
1690 VisitCompoundLiteralExpr(cast<CompoundLiteralExpr>(S), Pred, Dst);
1691 Bldr.addNodes(Dst);
1692 break;
1693
1694 case Stmt::BinaryConditionalOperatorClass:
1695 case Stmt::ConditionalOperatorClass: { // '?' operator
1696 Bldr.takeNodes(Pred);
1697 const auto *C = cast<AbstractConditionalOperator>(S);
1698 VisitGuardedExpr(C, C->getTrueExpr(), C->getFalseExpr(), Pred, Dst);
1699 Bldr.addNodes(Dst);
1700 break;
1701 }
1702
1703 case Stmt::CXXThisExprClass:
1704 Bldr.takeNodes(Pred);
1705 VisitCXXThisExpr(cast<CXXThisExpr>(S), Pred, Dst);
1706 Bldr.addNodes(Dst);
1707 break;
1708
1709 case Stmt::DeclRefExprClass: {
1710 Bldr.takeNodes(Pred);
1711 const auto *DE = cast<DeclRefExpr>(S);
1712 VisitCommonDeclRefExpr(DE, DE->getDecl(), Pred, Dst);
1713 Bldr.addNodes(Dst);
1714 break;
1715 }
1716
1717 case Stmt::DeclStmtClass:
1718 Bldr.takeNodes(Pred);
1719 VisitDeclStmt(cast<DeclStmt>(S), Pred, Dst);
1720 Bldr.addNodes(Dst);
1721 break;
1722
1723 case Stmt::ImplicitCastExprClass:
1724 case Stmt::CStyleCastExprClass:
1725 case Stmt::CXXStaticCastExprClass:
1726 case Stmt::CXXDynamicCastExprClass:
1727 case Stmt::CXXReinterpretCastExprClass:
1728 case Stmt::CXXConstCastExprClass:
1729 case Stmt::CXXFunctionalCastExprClass:
1730 case Stmt::BuiltinBitCastExprClass:
1731 case Stmt::ObjCBridgedCastExprClass:
1732 case Stmt::CXXAddrspaceCastExprClass: {
1733 Bldr.takeNodes(Pred);
1734 const auto *C = cast<CastExpr>(S);
1735 ExplodedNodeSet dstExpr;
1736 VisitCast(C, C->getSubExpr(), Pred, dstExpr);
1737
1738 // Handle the postvisit checks.
1739 getCheckerManager().runCheckersForPostStmt(Dst, dstExpr, C, *this);
1740 Bldr.addNodes(Dst);
1741 break;
1742 }
1743
1744 case Expr::MaterializeTemporaryExprClass: {
1745 Bldr.takeNodes(Pred);
1746 const auto *MTE = cast<MaterializeTemporaryExpr>(S);
1747 ExplodedNodeSet dstPrevisit;
1748 getCheckerManager().runCheckersForPreStmt(dstPrevisit, Pred, MTE, *this);
1749 ExplodedNodeSet dstExpr;
1750 for (const auto i : dstPrevisit)
1751 CreateCXXTemporaryObject(MTE, i, dstExpr);
1752 getCheckerManager().runCheckersForPostStmt(Dst, dstExpr, MTE, *this);
1753 Bldr.addNodes(Dst);
1754 break;
1755 }
1756
1757 case Stmt::InitListExprClass:
1758 Bldr.takeNodes(Pred);
1759 VisitInitListExpr(cast<InitListExpr>(S), Pred, Dst);
1760 Bldr.addNodes(Dst);
1761 break;
1762
1763 case Stmt::MemberExprClass:
1764 Bldr.takeNodes(Pred);
1765 VisitMemberExpr(cast<MemberExpr>(S), Pred, Dst);
1766 Bldr.addNodes(Dst);
1767 break;
1768
1769 case Stmt::AtomicExprClass:
1770 Bldr.takeNodes(Pred);
1771 VisitAtomicExpr(cast<AtomicExpr>(S), Pred, Dst);
1772 Bldr.addNodes(Dst);
1773 break;
1774
1775 case Stmt::ObjCIvarRefExprClass:
1776 Bldr.takeNodes(Pred);
1777 VisitLvalObjCIvarRefExpr(cast<ObjCIvarRefExpr>(S), Pred, Dst);
1778 Bldr.addNodes(Dst);
1779 break;
1780
1781 case Stmt::ObjCForCollectionStmtClass:
1782 Bldr.takeNodes(Pred);
1783 VisitObjCForCollectionStmt(cast<ObjCForCollectionStmt>(S), Pred, Dst);
1784 Bldr.addNodes(Dst);
1785 break;
1786
1787 case Stmt::ObjCMessageExprClass:
1788 Bldr.takeNodes(Pred);
1789 VisitObjCMessage(cast<ObjCMessageExpr>(S), Pred, Dst);
1790 Bldr.addNodes(Dst);
1791 break;
1792
1793 case Stmt::ObjCAtThrowStmtClass:
1794 case Stmt::CXXThrowExprClass:
1795 // FIXME: This is not complete. We basically treat @throw as
1796 // an abort.
1797 Bldr.generateSink(S, Pred, Pred->getState());
1798 break;
1799
1800 case Stmt::ReturnStmtClass:
1801 Bldr.takeNodes(Pred);
1802 VisitReturnStmt(cast<ReturnStmt>(S), Pred, Dst);
1803 Bldr.addNodes(Dst);
1804 break;
1805
1806 case Stmt::OffsetOfExprClass: {
1807 Bldr.takeNodes(Pred);
1808 ExplodedNodeSet PreVisit;
1809 getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
1810
1811 ExplodedNodeSet PostVisit;
1812 for (const auto Node : PreVisit)
1813 VisitOffsetOfExpr(cast<OffsetOfExpr>(S), Node, PostVisit);
1814
1815 getCheckerManager().runCheckersForPostStmt(Dst, PostVisit, S, *this);
1816 Bldr.addNodes(Dst);
1817 break;
1818 }
1819
1820 case Stmt::UnaryExprOrTypeTraitExprClass:
1821 Bldr.takeNodes(Pred);
1822 VisitUnaryExprOrTypeTraitExpr(cast<UnaryExprOrTypeTraitExpr>(S),
1823 Pred, Dst);
1824 Bldr.addNodes(Dst);
1825 break;
1826
1827 case Stmt::StmtExprClass: {
1828 const auto *SE = cast<StmtExpr>(S);
1829
1830 if (SE->getSubStmt()->body_empty()) {
1831 // Empty statement expression.
1832 assert(SE->getType() == getContext().VoidTy
1833 && "Empty statement expression must have void type.");
1834 break;
1835 }
1836
1837 if (const auto *LastExpr =
1838 dyn_cast<Expr>(*SE->getSubStmt()->body_rbegin())) {
1839 ProgramStateRef state = Pred->getState();
1840 Bldr.generateNode(SE, Pred,
1841 state->BindExpr(SE, Pred->getLocationContext(),
1842 state->getSVal(LastExpr,
1843 Pred->getLocationContext())));
1844 }
1845 break;
1846 }
1847
1848 case Stmt::UnaryOperatorClass: {
1849 Bldr.takeNodes(Pred);
1850 const auto *U = cast<UnaryOperator>(S);
1851 if (AMgr.options.ShouldEagerlyAssume && (U->getOpcode() == UO_LNot)) {
1852 ExplodedNodeSet Tmp;
1853 VisitUnaryOperator(U, Pred, Tmp);
1854 evalEagerlyAssumeBinOpBifurcation(Dst, Tmp, U);
1855 }
1856 else
1857 VisitUnaryOperator(U, Pred, Dst);
1858 Bldr.addNodes(Dst);
1859 break;
1860 }
1861
1862 case Stmt::PseudoObjectExprClass: {
1863 Bldr.takeNodes(Pred);
1864 ProgramStateRef state = Pred->getState();
1865 const auto *PE = cast<PseudoObjectExpr>(S);
1866 if (const Expr *Result = PE->getResultExpr()) {
1867 SVal V = state->getSVal(Result, Pred->getLocationContext());
1868 Bldr.generateNode(S, Pred,
1869 state->BindExpr(S, Pred->getLocationContext(), V));
1870 }
1871 else
1872 Bldr.generateNode(S, Pred,
1873 state->BindExpr(S, Pred->getLocationContext(),
1874 UnknownVal()));
1875
1876 Bldr.addNodes(Dst);
1877 break;
1878 }
1879
1880 case Expr::ObjCIndirectCopyRestoreExprClass: {
1881 // ObjCIndirectCopyRestoreExpr implies passing a temporary for
1882 // correctness of lifetime management. Due to limited analysis
1883 // of ARC, this is implemented as direct arg passing.
1884 Bldr.takeNodes(Pred);
1885 ProgramStateRef state = Pred->getState();
1886 const auto *OIE = cast<ObjCIndirectCopyRestoreExpr>(S);
1887 const Expr *E = OIE->getSubExpr();
1888 SVal V = state->getSVal(E, Pred->getLocationContext());
1889 Bldr.generateNode(S, Pred,
1890 state->BindExpr(S, Pred->getLocationContext(), V));
1891 Bldr.addNodes(Dst);
1892 break;
1893 }
1894 }
1895 }
1896
replayWithoutInlining(ExplodedNode * N,const LocationContext * CalleeLC)1897 bool ExprEngine::replayWithoutInlining(ExplodedNode *N,
1898 const LocationContext *CalleeLC) {
1899 const StackFrameContext *CalleeSF = CalleeLC->getStackFrame();
1900 const StackFrameContext *CallerSF = CalleeSF->getParent()->getStackFrame();
1901 assert(CalleeSF && CallerSF);
1902 ExplodedNode *BeforeProcessingCall = nullptr;
1903 const Stmt *CE = CalleeSF->getCallSite();
1904
1905 // Find the first node before we started processing the call expression.
1906 while (N) {
1907 ProgramPoint L = N->getLocation();
1908 BeforeProcessingCall = N;
1909 N = N->pred_empty() ? nullptr : *(N->pred_begin());
1910
1911 // Skip the nodes corresponding to the inlined code.
1912 if (L.getStackFrame() != CallerSF)
1913 continue;
1914 // We reached the caller. Find the node right before we started
1915 // processing the call.
1916 if (L.isPurgeKind())
1917 continue;
1918 if (L.getAs<PreImplicitCall>())
1919 continue;
1920 if (L.getAs<CallEnter>())
1921 continue;
1922 if (Optional<StmtPoint> SP = L.getAs<StmtPoint>())
1923 if (SP->getStmt() == CE)
1924 continue;
1925 break;
1926 }
1927
1928 if (!BeforeProcessingCall)
1929 return false;
1930
1931 // TODO: Clean up the unneeded nodes.
1932
1933 // Build an Epsilon node from which we will restart the analyzes.
1934 // Note that CE is permitted to be NULL!
1935 ProgramPoint NewNodeLoc =
1936 EpsilonPoint(BeforeProcessingCall->getLocationContext(), CE);
1937 // Add the special flag to GDM to signal retrying with no inlining.
1938 // Note, changing the state ensures that we are not going to cache out.
1939 ProgramStateRef NewNodeState = BeforeProcessingCall->getState();
1940 NewNodeState =
1941 NewNodeState->set<ReplayWithoutInlining>(const_cast<Stmt *>(CE));
1942
1943 // Make the new node a successor of BeforeProcessingCall.
1944 bool IsNew = false;
1945 ExplodedNode *NewNode = G.getNode(NewNodeLoc, NewNodeState, false, &IsNew);
1946 // We cached out at this point. Caching out is common due to us backtracking
1947 // from the inlined function, which might spawn several paths.
1948 if (!IsNew)
1949 return true;
1950
1951 NewNode->addPredecessor(BeforeProcessingCall, G);
1952
1953 // Add the new node to the work list.
1954 Engine.enqueueStmtNode(NewNode, CalleeSF->getCallSiteBlock(),
1955 CalleeSF->getIndex());
1956 NumTimesRetriedWithoutInlining++;
1957 return true;
1958 }
1959
1960 /// Block entrance. (Update counters).
processCFGBlockEntrance(const BlockEdge & L,NodeBuilderWithSinks & nodeBuilder,ExplodedNode * Pred)1961 void ExprEngine::processCFGBlockEntrance(const BlockEdge &L,
1962 NodeBuilderWithSinks &nodeBuilder,
1963 ExplodedNode *Pred) {
1964 PrettyStackTraceLocationContext CrashInfo(Pred->getLocationContext());
1965 // If we reach a loop which has a known bound (and meets
1966 // other constraints) then consider completely unrolling it.
1967 if(AMgr.options.ShouldUnrollLoops) {
1968 unsigned maxBlockVisitOnPath = AMgr.options.maxBlockVisitOnPath;
1969 const Stmt *Term = nodeBuilder.getContext().getBlock()->getTerminatorStmt();
1970 if (Term) {
1971 ProgramStateRef NewState = updateLoopStack(Term, AMgr.getASTContext(),
1972 Pred, maxBlockVisitOnPath);
1973 if (NewState != Pred->getState()) {
1974 ExplodedNode *UpdatedNode = nodeBuilder.generateNode(NewState, Pred);
1975 if (!UpdatedNode)
1976 return;
1977 Pred = UpdatedNode;
1978 }
1979 }
1980 // Is we are inside an unrolled loop then no need the check the counters.
1981 if(isUnrolledState(Pred->getState()))
1982 return;
1983 }
1984
1985 // If this block is terminated by a loop and it has already been visited the
1986 // maximum number of times, widen the loop.
1987 unsigned int BlockCount = nodeBuilder.getContext().blockCount();
1988 if (BlockCount == AMgr.options.maxBlockVisitOnPath - 1 &&
1989 AMgr.options.ShouldWidenLoops) {
1990 const Stmt *Term = nodeBuilder.getContext().getBlock()->getTerminatorStmt();
1991 if (!(Term &&
1992 (isa<ForStmt>(Term) || isa<WhileStmt>(Term) || isa<DoStmt>(Term))))
1993 return;
1994 // Widen.
1995 const LocationContext *LCtx = Pred->getLocationContext();
1996 ProgramStateRef WidenedState =
1997 getWidenedLoopState(Pred->getState(), LCtx, BlockCount, Term);
1998 nodeBuilder.generateNode(WidenedState, Pred);
1999 return;
2000 }
2001
2002 // FIXME: Refactor this into a checker.
2003 if (BlockCount >= AMgr.options.maxBlockVisitOnPath) {
2004 static SimpleProgramPointTag tag(TagProviderName, "Block count exceeded");
2005 const ExplodedNode *Sink =
2006 nodeBuilder.generateSink(Pred->getState(), Pred, &tag);
2007
2008 // Check if we stopped at the top level function or not.
2009 // Root node should have the location context of the top most function.
2010 const LocationContext *CalleeLC = Pred->getLocation().getLocationContext();
2011 const LocationContext *CalleeSF = CalleeLC->getStackFrame();
2012 const LocationContext *RootLC =
2013 (*G.roots_begin())->getLocation().getLocationContext();
2014 if (RootLC->getStackFrame() != CalleeSF) {
2015 Engine.FunctionSummaries->markReachedMaxBlockCount(CalleeSF->getDecl());
2016
2017 // Re-run the call evaluation without inlining it, by storing the
2018 // no-inlining policy in the state and enqueuing the new work item on
2019 // the list. Replay should almost never fail. Use the stats to catch it
2020 // if it does.
2021 if ((!AMgr.options.NoRetryExhausted &&
2022 replayWithoutInlining(Pred, CalleeLC)))
2023 return;
2024 NumMaxBlockCountReachedInInlined++;
2025 } else
2026 NumMaxBlockCountReached++;
2027
2028 // Make sink nodes as exhausted(for stats) only if retry failed.
2029 Engine.blocksExhausted.push_back(std::make_pair(L, Sink));
2030 }
2031 }
2032
2033 //===----------------------------------------------------------------------===//
2034 // Branch processing.
2035 //===----------------------------------------------------------------------===//
2036
2037 /// RecoverCastedSymbol - A helper function for ProcessBranch that is used
2038 /// to try to recover some path-sensitivity for casts of symbolic
2039 /// integers that promote their values (which are currently not tracked well).
2040 /// This function returns the SVal bound to Condition->IgnoreCasts if all the
2041 // cast(s) did was sign-extend the original value.
RecoverCastedSymbol(ProgramStateRef state,const Stmt * Condition,const LocationContext * LCtx,ASTContext & Ctx)2042 static SVal RecoverCastedSymbol(ProgramStateRef state,
2043 const Stmt *Condition,
2044 const LocationContext *LCtx,
2045 ASTContext &Ctx) {
2046
2047 const auto *Ex = dyn_cast<Expr>(Condition);
2048 if (!Ex)
2049 return UnknownVal();
2050
2051 uint64_t bits = 0;
2052 bool bitsInit = false;
2053
2054 while (const auto *CE = dyn_cast<CastExpr>(Ex)) {
2055 QualType T = CE->getType();
2056
2057 if (!T->isIntegralOrEnumerationType())
2058 return UnknownVal();
2059
2060 uint64_t newBits = Ctx.getTypeSize(T);
2061 if (!bitsInit || newBits < bits) {
2062 bitsInit = true;
2063 bits = newBits;
2064 }
2065
2066 Ex = CE->getSubExpr();
2067 }
2068
2069 // We reached a non-cast. Is it a symbolic value?
2070 QualType T = Ex->getType();
2071
2072 if (!bitsInit || !T->isIntegralOrEnumerationType() ||
2073 Ctx.getTypeSize(T) > bits)
2074 return UnknownVal();
2075
2076 return state->getSVal(Ex, LCtx);
2077 }
2078
2079 #ifndef NDEBUG
getRightmostLeaf(const Stmt * Condition)2080 static const Stmt *getRightmostLeaf(const Stmt *Condition) {
2081 while (Condition) {
2082 const auto *BO = dyn_cast<BinaryOperator>(Condition);
2083 if (!BO || !BO->isLogicalOp()) {
2084 return Condition;
2085 }
2086 Condition = BO->getRHS()->IgnoreParens();
2087 }
2088 return nullptr;
2089 }
2090 #endif
2091
2092 // Returns the condition the branch at the end of 'B' depends on and whose value
2093 // has been evaluated within 'B'.
2094 // In most cases, the terminator condition of 'B' will be evaluated fully in
2095 // the last statement of 'B'; in those cases, the resolved condition is the
2096 // given 'Condition'.
2097 // If the condition of the branch is a logical binary operator tree, the CFG is
2098 // optimized: in that case, we know that the expression formed by all but the
2099 // rightmost leaf of the logical binary operator tree must be true, and thus
2100 // the branch condition is at this point equivalent to the truth value of that
2101 // rightmost leaf; the CFG block thus only evaluates this rightmost leaf
2102 // expression in its final statement. As the full condition in that case was
2103 // not evaluated, and is thus not in the SVal cache, we need to use that leaf
2104 // expression to evaluate the truth value of the condition in the current state
2105 // space.
ResolveCondition(const Stmt * Condition,const CFGBlock * B)2106 static const Stmt *ResolveCondition(const Stmt *Condition,
2107 const CFGBlock *B) {
2108 if (const auto *Ex = dyn_cast<Expr>(Condition))
2109 Condition = Ex->IgnoreParens();
2110
2111 const auto *BO = dyn_cast<BinaryOperator>(Condition);
2112 if (!BO || !BO->isLogicalOp())
2113 return Condition;
2114
2115 assert(B->getTerminator().isStmtBranch() &&
2116 "Other kinds of branches are handled separately!");
2117
2118 // For logical operations, we still have the case where some branches
2119 // use the traditional "merge" approach and others sink the branch
2120 // directly into the basic blocks representing the logical operation.
2121 // We need to distinguish between those two cases here.
2122
2123 // The invariants are still shifting, but it is possible that the
2124 // last element in a CFGBlock is not a CFGStmt. Look for the last
2125 // CFGStmt as the value of the condition.
2126 CFGBlock::const_reverse_iterator I = B->rbegin(), E = B->rend();
2127 for (; I != E; ++I) {
2128 CFGElement Elem = *I;
2129 Optional<CFGStmt> CS = Elem.getAs<CFGStmt>();
2130 if (!CS)
2131 continue;
2132 const Stmt *LastStmt = CS->getStmt();
2133 assert(LastStmt == Condition || LastStmt == getRightmostLeaf(Condition));
2134 return LastStmt;
2135 }
2136 llvm_unreachable("could not resolve condition");
2137 }
2138
2139 using ObjCForLctxPair =
2140 std::pair<const ObjCForCollectionStmt *, const LocationContext *>;
2141
REGISTER_MAP_WITH_PROGRAMSTATE(ObjCForHasMoreIterations,ObjCForLctxPair,bool)2142 REGISTER_MAP_WITH_PROGRAMSTATE(ObjCForHasMoreIterations, ObjCForLctxPair, bool)
2143
2144 ProgramStateRef ExprEngine::setWhetherHasMoreIteration(
2145 ProgramStateRef State, const ObjCForCollectionStmt *O,
2146 const LocationContext *LC, bool HasMoreIteraton) {
2147 assert(!State->contains<ObjCForHasMoreIterations>({O, LC}));
2148 return State->set<ObjCForHasMoreIterations>({O, LC}, HasMoreIteraton);
2149 }
2150
2151 ProgramStateRef
removeIterationState(ProgramStateRef State,const ObjCForCollectionStmt * O,const LocationContext * LC)2152 ExprEngine::removeIterationState(ProgramStateRef State,
2153 const ObjCForCollectionStmt *O,
2154 const LocationContext *LC) {
2155 assert(State->contains<ObjCForHasMoreIterations>({O, LC}));
2156 return State->remove<ObjCForHasMoreIterations>({O, LC});
2157 }
2158
hasMoreIteration(ProgramStateRef State,const ObjCForCollectionStmt * O,const LocationContext * LC)2159 bool ExprEngine::hasMoreIteration(ProgramStateRef State,
2160 const ObjCForCollectionStmt *O,
2161 const LocationContext *LC) {
2162 assert(State->contains<ObjCForHasMoreIterations>({O, LC}));
2163 return *State->get<ObjCForHasMoreIterations>({O, LC});
2164 }
2165
2166 /// Split the state on whether there are any more iterations left for this loop.
2167 /// Returns a (HasMoreIteration, HasNoMoreIteration) pair, or None when the
2168 /// acquisition of the loop condition value failed.
2169 static Optional<std::pair<ProgramStateRef, ProgramStateRef>>
assumeCondition(const Stmt * Condition,ExplodedNode * N)2170 assumeCondition(const Stmt *Condition, ExplodedNode *N) {
2171 ProgramStateRef State = N->getState();
2172 if (const auto *ObjCFor = dyn_cast<ObjCForCollectionStmt>(Condition)) {
2173 bool HasMoreIteraton =
2174 ExprEngine::hasMoreIteration(State, ObjCFor, N->getLocationContext());
2175 // Checkers have already ran on branch conditions, so the current
2176 // information as to whether the loop has more iteration becomes outdated
2177 // after this point.
2178 State = ExprEngine::removeIterationState(State, ObjCFor,
2179 N->getLocationContext());
2180 if (HasMoreIteraton)
2181 return std::pair<ProgramStateRef, ProgramStateRef>{State, nullptr};
2182 else
2183 return std::pair<ProgramStateRef, ProgramStateRef>{nullptr, State};
2184 }
2185 SVal X = State->getSVal(Condition, N->getLocationContext());
2186
2187 if (X.isUnknownOrUndef()) {
2188 // Give it a chance to recover from unknown.
2189 if (const auto *Ex = dyn_cast<Expr>(Condition)) {
2190 if (Ex->getType()->isIntegralOrEnumerationType()) {
2191 // Try to recover some path-sensitivity. Right now casts of symbolic
2192 // integers that promote their values are currently not tracked well.
2193 // If 'Condition' is such an expression, try and recover the
2194 // underlying value and use that instead.
2195 SVal recovered =
2196 RecoverCastedSymbol(State, Condition, N->getLocationContext(),
2197 N->getState()->getStateManager().getContext());
2198
2199 if (!recovered.isUnknown()) {
2200 X = recovered;
2201 }
2202 }
2203 }
2204 }
2205
2206 // If the condition is still unknown, give up.
2207 if (X.isUnknownOrUndef())
2208 return None;
2209
2210 DefinedSVal V = X.castAs<DefinedSVal>();
2211
2212 ProgramStateRef StTrue, StFalse;
2213 return State->assume(V);
2214 }
2215
processBranch(const Stmt * Condition,NodeBuilderContext & BldCtx,ExplodedNode * Pred,ExplodedNodeSet & Dst,const CFGBlock * DstT,const CFGBlock * DstF)2216 void ExprEngine::processBranch(const Stmt *Condition,
2217 NodeBuilderContext& BldCtx,
2218 ExplodedNode *Pred,
2219 ExplodedNodeSet &Dst,
2220 const CFGBlock *DstT,
2221 const CFGBlock *DstF) {
2222 assert((!Condition || !isa<CXXBindTemporaryExpr>(Condition)) &&
2223 "CXXBindTemporaryExprs are handled by processBindTemporary.");
2224 const LocationContext *LCtx = Pred->getLocationContext();
2225 PrettyStackTraceLocationContext StackCrashInfo(LCtx);
2226 currBldrCtx = &BldCtx;
2227
2228 // Check for NULL conditions; e.g. "for(;;)"
2229 if (!Condition) {
2230 BranchNodeBuilder NullCondBldr(Pred, Dst, BldCtx, DstT, DstF);
2231 NullCondBldr.markInfeasible(false);
2232 NullCondBldr.generateNode(Pred->getState(), true, Pred);
2233 return;
2234 }
2235
2236 if (const auto *Ex = dyn_cast<Expr>(Condition))
2237 Condition = Ex->IgnoreParens();
2238
2239 Condition = ResolveCondition(Condition, BldCtx.getBlock());
2240 PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
2241 Condition->getBeginLoc(),
2242 "Error evaluating branch");
2243
2244 ExplodedNodeSet CheckersOutSet;
2245 getCheckerManager().runCheckersForBranchCondition(Condition, CheckersOutSet,
2246 Pred, *this);
2247 // We generated only sinks.
2248 if (CheckersOutSet.empty())
2249 return;
2250
2251 BranchNodeBuilder builder(CheckersOutSet, Dst, BldCtx, DstT, DstF);
2252 for (ExplodedNode *PredN : CheckersOutSet) {
2253 if (PredN->isSink())
2254 continue;
2255
2256 ProgramStateRef PrevState = PredN->getState();
2257
2258 ProgramStateRef StTrue, StFalse;
2259 if (const auto KnownCondValueAssumption = assumeCondition(Condition, PredN))
2260 std::tie(StTrue, StFalse) = *KnownCondValueAssumption;
2261 else {
2262 assert(!isa<ObjCForCollectionStmt>(Condition));
2263 builder.generateNode(PrevState, true, PredN);
2264 builder.generateNode(PrevState, false, PredN);
2265 continue;
2266 }
2267 if (StTrue && StFalse)
2268 assert(!isa<ObjCForCollectionStmt>(Condition));;
2269
2270 // Process the true branch.
2271 if (builder.isFeasible(true)) {
2272 if (StTrue)
2273 builder.generateNode(StTrue, true, PredN);
2274 else
2275 builder.markInfeasible(true);
2276 }
2277
2278 // Process the false branch.
2279 if (builder.isFeasible(false)) {
2280 if (StFalse)
2281 builder.generateNode(StFalse, false, PredN);
2282 else
2283 builder.markInfeasible(false);
2284 }
2285 }
2286 currBldrCtx = nullptr;
2287 }
2288
2289 /// The GDM component containing the set of global variables which have been
2290 /// previously initialized with explicit initializers.
REGISTER_TRAIT_WITH_PROGRAMSTATE(InitializedGlobalsSet,llvm::ImmutableSet<const VarDecl * >)2291 REGISTER_TRAIT_WITH_PROGRAMSTATE(InitializedGlobalsSet,
2292 llvm::ImmutableSet<const VarDecl *>)
2293
2294 void ExprEngine::processStaticInitializer(const DeclStmt *DS,
2295 NodeBuilderContext &BuilderCtx,
2296 ExplodedNode *Pred,
2297 ExplodedNodeSet &Dst,
2298 const CFGBlock *DstT,
2299 const CFGBlock *DstF) {
2300 PrettyStackTraceLocationContext CrashInfo(Pred->getLocationContext());
2301 currBldrCtx = &BuilderCtx;
2302
2303 const auto *VD = cast<VarDecl>(DS->getSingleDecl());
2304 ProgramStateRef state = Pred->getState();
2305 bool initHasRun = state->contains<InitializedGlobalsSet>(VD);
2306 BranchNodeBuilder builder(Pred, Dst, BuilderCtx, DstT, DstF);
2307
2308 if (!initHasRun) {
2309 state = state->add<InitializedGlobalsSet>(VD);
2310 }
2311
2312 builder.generateNode(state, initHasRun, Pred);
2313 builder.markInfeasible(!initHasRun);
2314
2315 currBldrCtx = nullptr;
2316 }
2317
2318 /// processIndirectGoto - Called by CoreEngine. Used to generate successor
2319 /// nodes by processing the 'effects' of a computed goto jump.
processIndirectGoto(IndirectGotoNodeBuilder & builder)2320 void ExprEngine::processIndirectGoto(IndirectGotoNodeBuilder &builder) {
2321 ProgramStateRef state = builder.getState();
2322 SVal V = state->getSVal(builder.getTarget(), builder.getLocationContext());
2323
2324 // Three possibilities:
2325 //
2326 // (1) We know the computed label.
2327 // (2) The label is NULL (or some other constant), or Undefined.
2328 // (3) We have no clue about the label. Dispatch to all targets.
2329 //
2330
2331 using iterator = IndirectGotoNodeBuilder::iterator;
2332
2333 if (Optional<loc::GotoLabel> LV = V.getAs<loc::GotoLabel>()) {
2334 const LabelDecl *L = LV->getLabel();
2335
2336 for (iterator I = builder.begin(), E = builder.end(); I != E; ++I) {
2337 if (I.getLabel() == L) {
2338 builder.generateNode(I, state);
2339 return;
2340 }
2341 }
2342
2343 llvm_unreachable("No block with label.");
2344 }
2345
2346 if (V.getAs<loc::ConcreteInt>() || V.getAs<UndefinedVal>()) {
2347 // Dispatch to the first target and mark it as a sink.
2348 //ExplodedNode* N = builder.generateNode(builder.begin(), state, true);
2349 // FIXME: add checker visit.
2350 // UndefBranches.insert(N);
2351 return;
2352 }
2353
2354 // This is really a catch-all. We don't support symbolics yet.
2355 // FIXME: Implement dispatch for symbolic pointers.
2356
2357 for (iterator I = builder.begin(), E = builder.end(); I != E; ++I)
2358 builder.generateNode(I, state);
2359 }
2360
processBeginOfFunction(NodeBuilderContext & BC,ExplodedNode * Pred,ExplodedNodeSet & Dst,const BlockEdge & L)2361 void ExprEngine::processBeginOfFunction(NodeBuilderContext &BC,
2362 ExplodedNode *Pred,
2363 ExplodedNodeSet &Dst,
2364 const BlockEdge &L) {
2365 SaveAndRestore<const NodeBuilderContext *> NodeContextRAII(currBldrCtx, &BC);
2366 getCheckerManager().runCheckersForBeginFunction(Dst, L, Pred, *this);
2367 }
2368
2369 /// ProcessEndPath - Called by CoreEngine. Used to generate end-of-path
2370 /// nodes when the control reaches the end of a function.
processEndOfFunction(NodeBuilderContext & BC,ExplodedNode * Pred,const ReturnStmt * RS)2371 void ExprEngine::processEndOfFunction(NodeBuilderContext& BC,
2372 ExplodedNode *Pred,
2373 const ReturnStmt *RS) {
2374 ProgramStateRef State = Pred->getState();
2375
2376 if (!Pred->getStackFrame()->inTopFrame())
2377 State = finishArgumentConstruction(
2378 State, *getStateManager().getCallEventManager().getCaller(
2379 Pred->getStackFrame(), Pred->getState()));
2380
2381 // FIXME: We currently cannot assert that temporaries are clear, because
2382 // lifetime extended temporaries are not always modelled correctly. In some
2383 // cases when we materialize the temporary, we do
2384 // createTemporaryRegionIfNeeded(), and the region changes, and also the
2385 // respective destructor becomes automatic from temporary. So for now clean up
2386 // the state manually before asserting. Ideally, this braced block of code
2387 // should go away.
2388 {
2389 const LocationContext *FromLC = Pred->getLocationContext();
2390 const LocationContext *ToLC = FromLC->getStackFrame()->getParent();
2391 const LocationContext *LC = FromLC;
2392 while (LC != ToLC) {
2393 assert(LC && "ToLC must be a parent of FromLC!");
2394 for (auto I : State->get<ObjectsUnderConstruction>())
2395 if (I.first.getLocationContext() == LC) {
2396 // The comment above only pardons us for not cleaning up a
2397 // temporary destructor. If any other statements are found here,
2398 // it must be a separate problem.
2399 assert(I.first.getItem().getKind() ==
2400 ConstructionContextItem::TemporaryDestructorKind ||
2401 I.first.getItem().getKind() ==
2402 ConstructionContextItem::ElidedDestructorKind);
2403 State = State->remove<ObjectsUnderConstruction>(I.first);
2404 }
2405 LC = LC->getParent();
2406 }
2407 }
2408
2409 // Perform the transition with cleanups.
2410 if (State != Pred->getState()) {
2411 ExplodedNodeSet PostCleanup;
2412 NodeBuilder Bldr(Pred, PostCleanup, BC);
2413 Pred = Bldr.generateNode(Pred->getLocation(), State, Pred);
2414 if (!Pred) {
2415 // The node with clean temporaries already exists. We might have reached
2416 // it on a path on which we initialize different temporaries.
2417 return;
2418 }
2419 }
2420
2421 assert(areAllObjectsFullyConstructed(Pred->getState(),
2422 Pred->getLocationContext(),
2423 Pred->getStackFrame()->getParent()));
2424
2425 PrettyStackTraceLocationContext CrashInfo(Pred->getLocationContext());
2426
2427 ExplodedNodeSet Dst;
2428 if (Pred->getLocationContext()->inTopFrame()) {
2429 // Remove dead symbols.
2430 ExplodedNodeSet AfterRemovedDead;
2431 removeDeadOnEndOfFunction(BC, Pred, AfterRemovedDead);
2432
2433 // Notify checkers.
2434 for (const auto I : AfterRemovedDead)
2435 getCheckerManager().runCheckersForEndFunction(BC, Dst, I, *this, RS);
2436 } else {
2437 getCheckerManager().runCheckersForEndFunction(BC, Dst, Pred, *this, RS);
2438 }
2439
2440 Engine.enqueueEndOfFunction(Dst, RS);
2441 }
2442
2443 /// ProcessSwitch - Called by CoreEngine. Used to generate successor
2444 /// nodes by processing the 'effects' of a switch statement.
processSwitch(SwitchNodeBuilder & builder)2445 void ExprEngine::processSwitch(SwitchNodeBuilder& builder) {
2446 using iterator = SwitchNodeBuilder::iterator;
2447
2448 ProgramStateRef state = builder.getState();
2449 const Expr *CondE = builder.getCondition();
2450 SVal CondV_untested = state->getSVal(CondE, builder.getLocationContext());
2451
2452 if (CondV_untested.isUndef()) {
2453 //ExplodedNode* N = builder.generateDefaultCaseNode(state, true);
2454 // FIXME: add checker
2455 //UndefBranches.insert(N);
2456
2457 return;
2458 }
2459 DefinedOrUnknownSVal CondV = CondV_untested.castAs<DefinedOrUnknownSVal>();
2460
2461 ProgramStateRef DefaultSt = state;
2462
2463 iterator I = builder.begin(), EI = builder.end();
2464 bool defaultIsFeasible = I == EI;
2465
2466 for ( ; I != EI; ++I) {
2467 // Successor may be pruned out during CFG construction.
2468 if (!I.getBlock())
2469 continue;
2470
2471 const CaseStmt *Case = I.getCase();
2472
2473 // Evaluate the LHS of the case value.
2474 llvm::APSInt V1 = Case->getLHS()->EvaluateKnownConstInt(getContext());
2475 assert(V1.getBitWidth() == getContext().getIntWidth(CondE->getType()));
2476
2477 // Get the RHS of the case, if it exists.
2478 llvm::APSInt V2;
2479 if (const Expr *E = Case->getRHS())
2480 V2 = E->EvaluateKnownConstInt(getContext());
2481 else
2482 V2 = V1;
2483
2484 ProgramStateRef StateCase;
2485 if (Optional<NonLoc> NL = CondV.getAs<NonLoc>())
2486 std::tie(StateCase, DefaultSt) =
2487 DefaultSt->assumeInclusiveRange(*NL, V1, V2);
2488 else // UnknownVal
2489 StateCase = DefaultSt;
2490
2491 if (StateCase)
2492 builder.generateCaseStmtNode(I, StateCase);
2493
2494 // Now "assume" that the case doesn't match. Add this state
2495 // to the default state (if it is feasible).
2496 if (DefaultSt)
2497 defaultIsFeasible = true;
2498 else {
2499 defaultIsFeasible = false;
2500 break;
2501 }
2502 }
2503
2504 if (!defaultIsFeasible)
2505 return;
2506
2507 // If we have switch(enum value), the default branch is not
2508 // feasible if all of the enum constants not covered by 'case:' statements
2509 // are not feasible values for the switch condition.
2510 //
2511 // Note that this isn't as accurate as it could be. Even if there isn't
2512 // a case for a particular enum value as long as that enum value isn't
2513 // feasible then it shouldn't be considered for making 'default:' reachable.
2514 const SwitchStmt *SS = builder.getSwitch();
2515 const Expr *CondExpr = SS->getCond()->IgnoreParenImpCasts();
2516 if (CondExpr->getType()->getAs<EnumType>()) {
2517 if (SS->isAllEnumCasesCovered())
2518 return;
2519 }
2520
2521 builder.generateDefaultCaseNode(DefaultSt);
2522 }
2523
2524 //===----------------------------------------------------------------------===//
2525 // Transfer functions: Loads and stores.
2526 //===----------------------------------------------------------------------===//
2527
VisitCommonDeclRefExpr(const Expr * Ex,const NamedDecl * D,ExplodedNode * Pred,ExplodedNodeSet & Dst)2528 void ExprEngine::VisitCommonDeclRefExpr(const Expr *Ex, const NamedDecl *D,
2529 ExplodedNode *Pred,
2530 ExplodedNodeSet &Dst) {
2531 StmtNodeBuilder Bldr(Pred, Dst, *currBldrCtx);
2532
2533 ProgramStateRef state = Pred->getState();
2534 const LocationContext *LCtx = Pred->getLocationContext();
2535
2536 if (const auto *VD = dyn_cast<VarDecl>(D)) {
2537 // C permits "extern void v", and if you cast the address to a valid type,
2538 // you can even do things with it. We simply pretend
2539 assert(Ex->isGLValue() || VD->getType()->isVoidType());
2540 const LocationContext *LocCtxt = Pred->getLocationContext();
2541 const Decl *D = LocCtxt->getDecl();
2542 const auto *MD = dyn_cast_or_null<CXXMethodDecl>(D);
2543 const auto *DeclRefEx = dyn_cast<DeclRefExpr>(Ex);
2544 Optional<std::pair<SVal, QualType>> VInfo;
2545
2546 if (AMgr.options.ShouldInlineLambdas && DeclRefEx &&
2547 DeclRefEx->refersToEnclosingVariableOrCapture() && MD &&
2548 MD->getParent()->isLambda()) {
2549 // Lookup the field of the lambda.
2550 const CXXRecordDecl *CXXRec = MD->getParent();
2551 llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;
2552 FieldDecl *LambdaThisCaptureField;
2553 CXXRec->getCaptureFields(LambdaCaptureFields, LambdaThisCaptureField);
2554
2555 // Sema follows a sequence of complex rules to determine whether the
2556 // variable should be captured.
2557 if (const FieldDecl *FD = LambdaCaptureFields[VD]) {
2558 Loc CXXThis =
2559 svalBuilder.getCXXThis(MD, LocCtxt->getStackFrame());
2560 SVal CXXThisVal = state->getSVal(CXXThis);
2561 VInfo = std::make_pair(state->getLValue(FD, CXXThisVal), FD->getType());
2562 }
2563 }
2564
2565 if (!VInfo)
2566 VInfo = std::make_pair(state->getLValue(VD, LocCtxt), VD->getType());
2567
2568 SVal V = VInfo->first;
2569 bool IsReference = VInfo->second->isReferenceType();
2570
2571 // For references, the 'lvalue' is the pointer address stored in the
2572 // reference region.
2573 if (IsReference) {
2574 if (const MemRegion *R = V.getAsRegion())
2575 V = state->getSVal(R);
2576 else
2577 V = UnknownVal();
2578 }
2579
2580 Bldr.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V), nullptr,
2581 ProgramPoint::PostLValueKind);
2582 return;
2583 }
2584 if (const auto *ED = dyn_cast<EnumConstantDecl>(D)) {
2585 assert(!Ex->isGLValue());
2586 SVal V = svalBuilder.makeIntVal(ED->getInitVal());
2587 Bldr.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V));
2588 return;
2589 }
2590 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
2591 SVal V = svalBuilder.getFunctionPointer(FD);
2592 Bldr.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V), nullptr,
2593 ProgramPoint::PostLValueKind);
2594 return;
2595 }
2596 if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D)) {
2597 // Delegate all work related to pointer to members to the surrounding
2598 // operator&.
2599 return;
2600 }
2601 if (isa<BindingDecl>(D)) {
2602 // FIXME: proper support for bound declarations.
2603 // For now, let's just prevent crashing.
2604 return;
2605 }
2606
2607 llvm_unreachable("Support for this Decl not implemented.");
2608 }
2609
2610 /// VisitArraySubscriptExpr - Transfer function for array accesses
VisitArraySubscriptExpr(const ArraySubscriptExpr * A,ExplodedNode * Pred,ExplodedNodeSet & Dst)2611 void ExprEngine::VisitArraySubscriptExpr(const ArraySubscriptExpr *A,
2612 ExplodedNode *Pred,
2613 ExplodedNodeSet &Dst){
2614 const Expr *Base = A->getBase()->IgnoreParens();
2615 const Expr *Idx = A->getIdx()->IgnoreParens();
2616
2617 ExplodedNodeSet CheckerPreStmt;
2618 getCheckerManager().runCheckersForPreStmt(CheckerPreStmt, Pred, A, *this);
2619
2620 ExplodedNodeSet EvalSet;
2621 StmtNodeBuilder Bldr(CheckerPreStmt, EvalSet, *currBldrCtx);
2622
2623 bool IsVectorType = A->getBase()->getType()->isVectorType();
2624
2625 // The "like" case is for situations where C standard prohibits the type to
2626 // be an lvalue, e.g. taking the address of a subscript of an expression of
2627 // type "void *".
2628 bool IsGLValueLike = A->isGLValue() ||
2629 (A->getType().isCForbiddenLValueType() && !AMgr.getLangOpts().CPlusPlus);
2630
2631 for (auto *Node : CheckerPreStmt) {
2632 const LocationContext *LCtx = Node->getLocationContext();
2633 ProgramStateRef state = Node->getState();
2634
2635 if (IsGLValueLike) {
2636 QualType T = A->getType();
2637
2638 // One of the forbidden LValue types! We still need to have sensible
2639 // symbolic locations to represent this stuff. Note that arithmetic on
2640 // void pointers is a GCC extension.
2641 if (T->isVoidType())
2642 T = getContext().CharTy;
2643
2644 SVal V = state->getLValue(T,
2645 state->getSVal(Idx, LCtx),
2646 state->getSVal(Base, LCtx));
2647 Bldr.generateNode(A, Node, state->BindExpr(A, LCtx, V), nullptr,
2648 ProgramPoint::PostLValueKind);
2649 } else if (IsVectorType) {
2650 // FIXME: non-glvalue vector reads are not modelled.
2651 Bldr.generateNode(A, Node, state, nullptr);
2652 } else {
2653 llvm_unreachable("Array subscript should be an lValue when not \
2654 a vector and not a forbidden lvalue type");
2655 }
2656 }
2657
2658 getCheckerManager().runCheckersForPostStmt(Dst, EvalSet, A, *this);
2659 }
2660
2661 /// VisitMemberExpr - Transfer function for member expressions.
VisitMemberExpr(const MemberExpr * M,ExplodedNode * Pred,ExplodedNodeSet & Dst)2662 void ExprEngine::VisitMemberExpr(const MemberExpr *M, ExplodedNode *Pred,
2663 ExplodedNodeSet &Dst) {
2664 // FIXME: Prechecks eventually go in ::Visit().
2665 ExplodedNodeSet CheckedSet;
2666 getCheckerManager().runCheckersForPreStmt(CheckedSet, Pred, M, *this);
2667
2668 ExplodedNodeSet EvalSet;
2669 ValueDecl *Member = M->getMemberDecl();
2670
2671 // Handle static member variables and enum constants accessed via
2672 // member syntax.
2673 if (isa<VarDecl>(Member) || isa<EnumConstantDecl>(Member)) {
2674 for (const auto I : CheckedSet)
2675 VisitCommonDeclRefExpr(M, Member, I, EvalSet);
2676 } else {
2677 StmtNodeBuilder Bldr(CheckedSet, EvalSet, *currBldrCtx);
2678 ExplodedNodeSet Tmp;
2679
2680 for (const auto I : CheckedSet) {
2681 ProgramStateRef state = I->getState();
2682 const LocationContext *LCtx = I->getLocationContext();
2683 Expr *BaseExpr = M->getBase();
2684
2685 // Handle C++ method calls.
2686 if (const auto *MD = dyn_cast<CXXMethodDecl>(Member)) {
2687 if (MD->isInstance())
2688 state = createTemporaryRegionIfNeeded(state, LCtx, BaseExpr);
2689
2690 SVal MDVal = svalBuilder.getFunctionPointer(MD);
2691 state = state->BindExpr(M, LCtx, MDVal);
2692
2693 Bldr.generateNode(M, I, state);
2694 continue;
2695 }
2696
2697 // Handle regular struct fields / member variables.
2698 const SubRegion *MR = nullptr;
2699 state = createTemporaryRegionIfNeeded(state, LCtx, BaseExpr,
2700 /*Result=*/nullptr,
2701 /*OutRegionWithAdjustments=*/&MR);
2702 SVal baseExprVal =
2703 MR ? loc::MemRegionVal(MR) : state->getSVal(BaseExpr, LCtx);
2704
2705 const auto *field = cast<FieldDecl>(Member);
2706 SVal L = state->getLValue(field, baseExprVal);
2707
2708 if (M->isGLValue() || M->getType()->isArrayType()) {
2709 // We special-case rvalues of array type because the analyzer cannot
2710 // reason about them, since we expect all regions to be wrapped in Locs.
2711 // We instead treat these as lvalues and assume that they will decay to
2712 // pointers as soon as they are used.
2713 if (!M->isGLValue()) {
2714 assert(M->getType()->isArrayType());
2715 const auto *PE =
2716 dyn_cast<ImplicitCastExpr>(I->getParentMap().getParentIgnoreParens(M));
2717 if (!PE || PE->getCastKind() != CK_ArrayToPointerDecay) {
2718 llvm_unreachable("should always be wrapped in ArrayToPointerDecay");
2719 }
2720 }
2721
2722 if (field->getType()->isReferenceType()) {
2723 if (const MemRegion *R = L.getAsRegion())
2724 L = state->getSVal(R);
2725 else
2726 L = UnknownVal();
2727 }
2728
2729 Bldr.generateNode(M, I, state->BindExpr(M, LCtx, L), nullptr,
2730 ProgramPoint::PostLValueKind);
2731 } else {
2732 Bldr.takeNodes(I);
2733 evalLoad(Tmp, M, M, I, state, L);
2734 Bldr.addNodes(Tmp);
2735 }
2736 }
2737 }
2738
2739 getCheckerManager().runCheckersForPostStmt(Dst, EvalSet, M, *this);
2740 }
2741
VisitAtomicExpr(const AtomicExpr * AE,ExplodedNode * Pred,ExplodedNodeSet & Dst)2742 void ExprEngine::VisitAtomicExpr(const AtomicExpr *AE, ExplodedNode *Pred,
2743 ExplodedNodeSet &Dst) {
2744 ExplodedNodeSet AfterPreSet;
2745 getCheckerManager().runCheckersForPreStmt(AfterPreSet, Pred, AE, *this);
2746
2747 // For now, treat all the arguments to C11 atomics as escaping.
2748 // FIXME: Ideally we should model the behavior of the atomics precisely here.
2749
2750 ExplodedNodeSet AfterInvalidateSet;
2751 StmtNodeBuilder Bldr(AfterPreSet, AfterInvalidateSet, *currBldrCtx);
2752
2753 for (const auto I : AfterPreSet) {
2754 ProgramStateRef State = I->getState();
2755 const LocationContext *LCtx = I->getLocationContext();
2756
2757 SmallVector<SVal, 8> ValuesToInvalidate;
2758 for (unsigned SI = 0, Count = AE->getNumSubExprs(); SI != Count; SI++) {
2759 const Expr *SubExpr = AE->getSubExprs()[SI];
2760 SVal SubExprVal = State->getSVal(SubExpr, LCtx);
2761 ValuesToInvalidate.push_back(SubExprVal);
2762 }
2763
2764 State = State->invalidateRegions(ValuesToInvalidate, AE,
2765 currBldrCtx->blockCount(),
2766 LCtx,
2767 /*CausedByPointerEscape*/true,
2768 /*Symbols=*/nullptr);
2769
2770 SVal ResultVal = UnknownVal();
2771 State = State->BindExpr(AE, LCtx, ResultVal);
2772 Bldr.generateNode(AE, I, State, nullptr,
2773 ProgramPoint::PostStmtKind);
2774 }
2775
2776 getCheckerManager().runCheckersForPostStmt(Dst, AfterInvalidateSet, AE, *this);
2777 }
2778
2779 // A value escapes in four possible cases:
2780 // (1) We are binding to something that is not a memory region.
2781 // (2) We are binding to a MemRegion that does not have stack storage.
2782 // (3) We are binding to a top-level parameter region with a non-trivial
2783 // destructor. We won't see the destructor during analysis, but it's there.
2784 // (4) We are binding to a MemRegion with stack storage that the store
2785 // does not understand.
processPointerEscapedOnBind(ProgramStateRef State,ArrayRef<std::pair<SVal,SVal>> LocAndVals,const LocationContext * LCtx,PointerEscapeKind Kind,const CallEvent * Call)2786 ProgramStateRef ExprEngine::processPointerEscapedOnBind(
2787 ProgramStateRef State, ArrayRef<std::pair<SVal, SVal>> LocAndVals,
2788 const LocationContext *LCtx, PointerEscapeKind Kind,
2789 const CallEvent *Call) {
2790 SmallVector<SVal, 8> Escaped;
2791 for (const std::pair<SVal, SVal> &LocAndVal : LocAndVals) {
2792 // Cases (1) and (2).
2793 const MemRegion *MR = LocAndVal.first.getAsRegion();
2794 if (!MR || !MR->hasStackStorage()) {
2795 Escaped.push_back(LocAndVal.second);
2796 continue;
2797 }
2798
2799 // Case (3).
2800 if (const auto *VR = dyn_cast<VarRegion>(MR->getBaseRegion()))
2801 if (VR->hasStackParametersStorage() && VR->getStackFrame()->inTopFrame())
2802 if (const auto *RD = VR->getValueType()->getAsCXXRecordDecl())
2803 if (!RD->hasTrivialDestructor()) {
2804 Escaped.push_back(LocAndVal.second);
2805 continue;
2806 }
2807
2808 // Case (4): in order to test that, generate a new state with the binding
2809 // added. If it is the same state, then it escapes (since the store cannot
2810 // represent the binding).
2811 // Do this only if we know that the store is not supposed to generate the
2812 // same state.
2813 SVal StoredVal = State->getSVal(MR);
2814 if (StoredVal != LocAndVal.second)
2815 if (State ==
2816 (State->bindLoc(loc::MemRegionVal(MR), LocAndVal.second, LCtx)))
2817 Escaped.push_back(LocAndVal.second);
2818 }
2819
2820 if (Escaped.empty())
2821 return State;
2822
2823 return escapeValues(State, Escaped, Kind, Call);
2824 }
2825
2826 ProgramStateRef
processPointerEscapedOnBind(ProgramStateRef State,SVal Loc,SVal Val,const LocationContext * LCtx)2827 ExprEngine::processPointerEscapedOnBind(ProgramStateRef State, SVal Loc,
2828 SVal Val, const LocationContext *LCtx) {
2829 std::pair<SVal, SVal> LocAndVal(Loc, Val);
2830 return processPointerEscapedOnBind(State, LocAndVal, LCtx, PSK_EscapeOnBind,
2831 nullptr);
2832 }
2833
2834 ProgramStateRef
notifyCheckersOfPointerEscape(ProgramStateRef State,const InvalidatedSymbols * Invalidated,ArrayRef<const MemRegion * > ExplicitRegions,const CallEvent * Call,RegionAndSymbolInvalidationTraits & ITraits)2835 ExprEngine::notifyCheckersOfPointerEscape(ProgramStateRef State,
2836 const InvalidatedSymbols *Invalidated,
2837 ArrayRef<const MemRegion *> ExplicitRegions,
2838 const CallEvent *Call,
2839 RegionAndSymbolInvalidationTraits &ITraits) {
2840 if (!Invalidated || Invalidated->empty())
2841 return State;
2842
2843 if (!Call)
2844 return getCheckerManager().runCheckersForPointerEscape(State,
2845 *Invalidated,
2846 nullptr,
2847 PSK_EscapeOther,
2848 &ITraits);
2849
2850 // If the symbols were invalidated by a call, we want to find out which ones
2851 // were invalidated directly due to being arguments to the call.
2852 InvalidatedSymbols SymbolsDirectlyInvalidated;
2853 for (const auto I : ExplicitRegions) {
2854 if (const SymbolicRegion *R = I->StripCasts()->getAs<SymbolicRegion>())
2855 SymbolsDirectlyInvalidated.insert(R->getSymbol());
2856 }
2857
2858 InvalidatedSymbols SymbolsIndirectlyInvalidated;
2859 for (const auto &sym : *Invalidated) {
2860 if (SymbolsDirectlyInvalidated.count(sym))
2861 continue;
2862 SymbolsIndirectlyInvalidated.insert(sym);
2863 }
2864
2865 if (!SymbolsDirectlyInvalidated.empty())
2866 State = getCheckerManager().runCheckersForPointerEscape(State,
2867 SymbolsDirectlyInvalidated, Call, PSK_DirectEscapeOnCall, &ITraits);
2868
2869 // Notify about the symbols that get indirectly invalidated by the call.
2870 if (!SymbolsIndirectlyInvalidated.empty())
2871 State = getCheckerManager().runCheckersForPointerEscape(State,
2872 SymbolsIndirectlyInvalidated, Call, PSK_IndirectEscapeOnCall, &ITraits);
2873
2874 return State;
2875 }
2876
2877 /// evalBind - Handle the semantics of binding a value to a specific location.
2878 /// This method is used by evalStore and (soon) VisitDeclStmt, and others.
evalBind(ExplodedNodeSet & Dst,const Stmt * StoreE,ExplodedNode * Pred,SVal location,SVal Val,bool atDeclInit,const ProgramPoint * PP)2879 void ExprEngine::evalBind(ExplodedNodeSet &Dst, const Stmt *StoreE,
2880 ExplodedNode *Pred,
2881 SVal location, SVal Val,
2882 bool atDeclInit, const ProgramPoint *PP) {
2883 const LocationContext *LC = Pred->getLocationContext();
2884 PostStmt PS(StoreE, LC);
2885 if (!PP)
2886 PP = &PS;
2887
2888 // Do a previsit of the bind.
2889 ExplodedNodeSet CheckedSet;
2890 getCheckerManager().runCheckersForBind(CheckedSet, Pred, location, Val,
2891 StoreE, *this, *PP);
2892
2893 StmtNodeBuilder Bldr(CheckedSet, Dst, *currBldrCtx);
2894
2895 // If the location is not a 'Loc', it will already be handled by
2896 // the checkers. There is nothing left to do.
2897 if (!location.getAs<Loc>()) {
2898 const ProgramPoint L = PostStore(StoreE, LC, /*Loc*/nullptr,
2899 /*tag*/nullptr);
2900 ProgramStateRef state = Pred->getState();
2901 state = processPointerEscapedOnBind(state, location, Val, LC);
2902 Bldr.generateNode(L, state, Pred);
2903 return;
2904 }
2905
2906 for (const auto PredI : CheckedSet) {
2907 ProgramStateRef state = PredI->getState();
2908
2909 state = processPointerEscapedOnBind(state, location, Val, LC);
2910
2911 // When binding the value, pass on the hint that this is a initialization.
2912 // For initializations, we do not need to inform clients of region
2913 // changes.
2914 state = state->bindLoc(location.castAs<Loc>(),
2915 Val, LC, /* notifyChanges = */ !atDeclInit);
2916
2917 const MemRegion *LocReg = nullptr;
2918 if (Optional<loc::MemRegionVal> LocRegVal =
2919 location.getAs<loc::MemRegionVal>()) {
2920 LocReg = LocRegVal->getRegion();
2921 }
2922
2923 const ProgramPoint L = PostStore(StoreE, LC, LocReg, nullptr);
2924 Bldr.generateNode(L, state, PredI);
2925 }
2926 }
2927
2928 /// evalStore - Handle the semantics of a store via an assignment.
2929 /// @param Dst The node set to store generated state nodes
2930 /// @param AssignE The assignment expression if the store happens in an
2931 /// assignment.
2932 /// @param LocationE The location expression that is stored to.
2933 /// @param state The current simulation state
2934 /// @param location The location to store the value
2935 /// @param Val The value to be stored
evalStore(ExplodedNodeSet & Dst,const Expr * AssignE,const Expr * LocationE,ExplodedNode * Pred,ProgramStateRef state,SVal location,SVal Val,const ProgramPointTag * tag)2936 void ExprEngine::evalStore(ExplodedNodeSet &Dst, const Expr *AssignE,
2937 const Expr *LocationE,
2938 ExplodedNode *Pred,
2939 ProgramStateRef state, SVal location, SVal Val,
2940 const ProgramPointTag *tag) {
2941 // Proceed with the store. We use AssignE as the anchor for the PostStore
2942 // ProgramPoint if it is non-NULL, and LocationE otherwise.
2943 const Expr *StoreE = AssignE ? AssignE : LocationE;
2944
2945 // Evaluate the location (checks for bad dereferences).
2946 ExplodedNodeSet Tmp;
2947 evalLocation(Tmp, AssignE, LocationE, Pred, state, location, false);
2948
2949 if (Tmp.empty())
2950 return;
2951
2952 if (location.isUndef())
2953 return;
2954
2955 for (const auto I : Tmp)
2956 evalBind(Dst, StoreE, I, location, Val, false);
2957 }
2958
evalLoad(ExplodedNodeSet & Dst,const Expr * NodeEx,const Expr * BoundEx,ExplodedNode * Pred,ProgramStateRef state,SVal location,const ProgramPointTag * tag,QualType LoadTy)2959 void ExprEngine::evalLoad(ExplodedNodeSet &Dst,
2960 const Expr *NodeEx,
2961 const Expr *BoundEx,
2962 ExplodedNode *Pred,
2963 ProgramStateRef state,
2964 SVal location,
2965 const ProgramPointTag *tag,
2966 QualType LoadTy) {
2967 assert(!location.getAs<NonLoc>() && "location cannot be a NonLoc.");
2968 assert(NodeEx);
2969 assert(BoundEx);
2970 // Evaluate the location (checks for bad dereferences).
2971 ExplodedNodeSet Tmp;
2972 evalLocation(Tmp, NodeEx, BoundEx, Pred, state, location, true);
2973 if (Tmp.empty())
2974 return;
2975
2976 StmtNodeBuilder Bldr(Tmp, Dst, *currBldrCtx);
2977 if (location.isUndef())
2978 return;
2979
2980 // Proceed with the load.
2981 for (const auto I : Tmp) {
2982 state = I->getState();
2983 const LocationContext *LCtx = I->getLocationContext();
2984
2985 SVal V = UnknownVal();
2986 if (location.isValid()) {
2987 if (LoadTy.isNull())
2988 LoadTy = BoundEx->getType();
2989 V = state->getSVal(location.castAs<Loc>(), LoadTy);
2990 }
2991
2992 Bldr.generateNode(NodeEx, I, state->BindExpr(BoundEx, LCtx, V), tag,
2993 ProgramPoint::PostLoadKind);
2994 }
2995 }
2996
evalLocation(ExplodedNodeSet & Dst,const Stmt * NodeEx,const Stmt * BoundEx,ExplodedNode * Pred,ProgramStateRef state,SVal location,bool isLoad)2997 void ExprEngine::evalLocation(ExplodedNodeSet &Dst,
2998 const Stmt *NodeEx,
2999 const Stmt *BoundEx,
3000 ExplodedNode *Pred,
3001 ProgramStateRef state,
3002 SVal location,
3003 bool isLoad) {
3004 StmtNodeBuilder BldrTop(Pred, Dst, *currBldrCtx);
3005 // Early checks for performance reason.
3006 if (location.isUnknown()) {
3007 return;
3008 }
3009
3010 ExplodedNodeSet Src;
3011 BldrTop.takeNodes(Pred);
3012 StmtNodeBuilder Bldr(Pred, Src, *currBldrCtx);
3013 if (Pred->getState() != state) {
3014 // Associate this new state with an ExplodedNode.
3015 // FIXME: If I pass null tag, the graph is incorrect, e.g for
3016 // int *p;
3017 // p = 0;
3018 // *p = 0xDEADBEEF;
3019 // "p = 0" is not noted as "Null pointer value stored to 'p'" but
3020 // instead "int *p" is noted as
3021 // "Variable 'p' initialized to a null pointer value"
3022
3023 static SimpleProgramPointTag tag(TagProviderName, "Location");
3024 Bldr.generateNode(NodeEx, Pred, state, &tag);
3025 }
3026 ExplodedNodeSet Tmp;
3027 getCheckerManager().runCheckersForLocation(Tmp, Src, location, isLoad,
3028 NodeEx, BoundEx, *this);
3029 BldrTop.addNodes(Tmp);
3030 }
3031
3032 std::pair<const ProgramPointTag *, const ProgramPointTag*>
geteagerlyAssumeBinOpBifurcationTags()3033 ExprEngine::geteagerlyAssumeBinOpBifurcationTags() {
3034 static SimpleProgramPointTag
3035 eagerlyAssumeBinOpBifurcationTrue(TagProviderName,
3036 "Eagerly Assume True"),
3037 eagerlyAssumeBinOpBifurcationFalse(TagProviderName,
3038 "Eagerly Assume False");
3039 return std::make_pair(&eagerlyAssumeBinOpBifurcationTrue,
3040 &eagerlyAssumeBinOpBifurcationFalse);
3041 }
3042
evalEagerlyAssumeBinOpBifurcation(ExplodedNodeSet & Dst,ExplodedNodeSet & Src,const Expr * Ex)3043 void ExprEngine::evalEagerlyAssumeBinOpBifurcation(ExplodedNodeSet &Dst,
3044 ExplodedNodeSet &Src,
3045 const Expr *Ex) {
3046 StmtNodeBuilder Bldr(Src, Dst, *currBldrCtx);
3047
3048 for (const auto Pred : Src) {
3049 // Test if the previous node was as the same expression. This can happen
3050 // when the expression fails to evaluate to anything meaningful and
3051 // (as an optimization) we don't generate a node.
3052 ProgramPoint P = Pred->getLocation();
3053 if (!P.getAs<PostStmt>() || P.castAs<PostStmt>().getStmt() != Ex) {
3054 continue;
3055 }
3056
3057 ProgramStateRef state = Pred->getState();
3058 SVal V = state->getSVal(Ex, Pred->getLocationContext());
3059 Optional<nonloc::SymbolVal> SEV = V.getAs<nonloc::SymbolVal>();
3060 if (SEV && SEV->isExpression()) {
3061 const std::pair<const ProgramPointTag *, const ProgramPointTag*> &tags =
3062 geteagerlyAssumeBinOpBifurcationTags();
3063
3064 ProgramStateRef StateTrue, StateFalse;
3065 std::tie(StateTrue, StateFalse) = state->assume(*SEV);
3066
3067 // First assume that the condition is true.
3068 if (StateTrue) {
3069 SVal Val = svalBuilder.makeIntVal(1U, Ex->getType());
3070 StateTrue = StateTrue->BindExpr(Ex, Pred->getLocationContext(), Val);
3071 Bldr.generateNode(Ex, Pred, StateTrue, tags.first);
3072 }
3073
3074 // Next, assume that the condition is false.
3075 if (StateFalse) {
3076 SVal Val = svalBuilder.makeIntVal(0U, Ex->getType());
3077 StateFalse = StateFalse->BindExpr(Ex, Pred->getLocationContext(), Val);
3078 Bldr.generateNode(Ex, Pred, StateFalse, tags.second);
3079 }
3080 }
3081 }
3082 }
3083
VisitGCCAsmStmt(const GCCAsmStmt * A,ExplodedNode * Pred,ExplodedNodeSet & Dst)3084 void ExprEngine::VisitGCCAsmStmt(const GCCAsmStmt *A, ExplodedNode *Pred,
3085 ExplodedNodeSet &Dst) {
3086 StmtNodeBuilder Bldr(Pred, Dst, *currBldrCtx);
3087 // We have processed both the inputs and the outputs. All of the outputs
3088 // should evaluate to Locs. Nuke all of their values.
3089
3090 // FIXME: Some day in the future it would be nice to allow a "plug-in"
3091 // which interprets the inline asm and stores proper results in the
3092 // outputs.
3093
3094 ProgramStateRef state = Pred->getState();
3095
3096 for (const Expr *O : A->outputs()) {
3097 SVal X = state->getSVal(O, Pred->getLocationContext());
3098 assert(!X.getAs<NonLoc>()); // Should be an Lval, or unknown, undef.
3099
3100 if (Optional<Loc> LV = X.getAs<Loc>())
3101 state = state->bindLoc(*LV, UnknownVal(), Pred->getLocationContext());
3102 }
3103
3104 Bldr.generateNode(A, Pred, state);
3105 }
3106
VisitMSAsmStmt(const MSAsmStmt * A,ExplodedNode * Pred,ExplodedNodeSet & Dst)3107 void ExprEngine::VisitMSAsmStmt(const MSAsmStmt *A, ExplodedNode *Pred,
3108 ExplodedNodeSet &Dst) {
3109 StmtNodeBuilder Bldr(Pred, Dst, *currBldrCtx);
3110 Bldr.generateNode(A, Pred, Pred->getState());
3111 }
3112
3113 //===----------------------------------------------------------------------===//
3114 // Visualization.
3115 //===----------------------------------------------------------------------===//
3116
3117 #ifndef NDEBUG
3118 namespace llvm {
3119
3120 template<>
3121 struct DOTGraphTraits<ExplodedGraph*> : public DefaultDOTGraphTraits {
DOTGraphTraitsllvm::DOTGraphTraits3122 DOTGraphTraits (bool isSimple = false) : DefaultDOTGraphTraits(isSimple) {}
3123
nodeHasBugReportllvm::DOTGraphTraits3124 static bool nodeHasBugReport(const ExplodedNode *N) {
3125 BugReporter &BR = static_cast<ExprEngine &>(
3126 N->getState()->getStateManager().getOwningEngine()).getBugReporter();
3127
3128 const auto EQClasses =
3129 llvm::make_range(BR.EQClasses_begin(), BR.EQClasses_end());
3130
3131 for (const auto &EQ : EQClasses) {
3132 for (const auto &I : EQ.getReports()) {
3133 const auto *PR = dyn_cast<PathSensitiveBugReport>(I.get());
3134 if (!PR)
3135 continue;
3136 const ExplodedNode *EN = PR->getErrorNode();
3137 if (EN->getState() == N->getState() &&
3138 EN->getLocation() == N->getLocation())
3139 return true;
3140 }
3141 }
3142 return false;
3143 }
3144
3145 /// \p PreCallback: callback before break.
3146 /// \p PostCallback: callback after break.
3147 /// \p Stop: stop iteration if returns @c true
3148 /// \return Whether @c Stop ever returned @c true.
traverseHiddenNodesllvm::DOTGraphTraits3149 static bool traverseHiddenNodes(
3150 const ExplodedNode *N,
3151 llvm::function_ref<void(const ExplodedNode *)> PreCallback,
3152 llvm::function_ref<void(const ExplodedNode *)> PostCallback,
3153 llvm::function_ref<bool(const ExplodedNode *)> Stop) {
3154 while (true) {
3155 PreCallback(N);
3156 if (Stop(N))
3157 return true;
3158
3159 if (N->succ_size() != 1 || !isNodeHidden(N->getFirstSucc(), nullptr))
3160 break;
3161 PostCallback(N);
3162
3163 N = N->getFirstSucc();
3164 }
3165 return false;
3166 }
3167
isNodeHiddenllvm::DOTGraphTraits3168 static bool isNodeHidden(const ExplodedNode *N, const ExplodedGraph *G) {
3169 return N->isTrivial();
3170 }
3171
getNodeLabelllvm::DOTGraphTraits3172 static std::string getNodeLabel(const ExplodedNode *N, ExplodedGraph *G){
3173 std::string Buf;
3174 llvm::raw_string_ostream Out(Buf);
3175
3176 const bool IsDot = true;
3177 const unsigned int Space = 1;
3178 ProgramStateRef State = N->getState();
3179
3180 Out << "{ \"state_id\": " << State->getID()
3181 << ",\\l";
3182
3183 Indent(Out, Space, IsDot) << "\"program_points\": [\\l";
3184
3185 // Dump program point for all the previously skipped nodes.
3186 traverseHiddenNodes(
3187 N,
3188 [&](const ExplodedNode *OtherNode) {
3189 Indent(Out, Space + 1, IsDot) << "{ ";
3190 OtherNode->getLocation().printJson(Out, /*NL=*/"\\l");
3191 Out << ", \"tag\": ";
3192 if (const ProgramPointTag *Tag = OtherNode->getLocation().getTag())
3193 Out << '\"' << Tag->getTagDescription() << "\"";
3194 else
3195 Out << "null";
3196 Out << ", \"node_id\": " << OtherNode->getID() <<
3197 ", \"is_sink\": " << OtherNode->isSink() <<
3198 ", \"has_report\": " << nodeHasBugReport(OtherNode) << " }";
3199 },
3200 // Adds a comma and a new-line between each program point.
3201 [&](const ExplodedNode *) { Out << ",\\l"; },
3202 [&](const ExplodedNode *) { return false; });
3203
3204 Out << "\\l"; // Adds a new-line to the last program point.
3205 Indent(Out, Space, IsDot) << "],\\l";
3206
3207 State->printDOT(Out, N->getLocationContext(), Space);
3208
3209 Out << "\\l}\\l";
3210 return Out.str();
3211 }
3212 };
3213
3214 } // namespace llvm
3215 #endif
3216
ViewGraph(bool trim)3217 void ExprEngine::ViewGraph(bool trim) {
3218 #ifndef NDEBUG
3219 std::string Filename = DumpGraph(trim);
3220 llvm::DisplayGraph(Filename, false, llvm::GraphProgram::DOT);
3221 #else
3222 llvm::errs() << "Warning: viewing graph requires assertions" << "\n";
3223 #endif
3224 }
3225
3226
ViewGraph(ArrayRef<const ExplodedNode * > Nodes)3227 void ExprEngine::ViewGraph(ArrayRef<const ExplodedNode*> Nodes) {
3228 #ifndef NDEBUG
3229 std::string Filename = DumpGraph(Nodes);
3230 llvm::DisplayGraph(Filename, false, llvm::GraphProgram::DOT);
3231 #else
3232 llvm::errs() << "Warning: viewing graph requires assertions" << "\n";
3233 #endif
3234 }
3235
DumpGraph(bool trim,StringRef Filename)3236 std::string ExprEngine::DumpGraph(bool trim, StringRef Filename) {
3237 #ifndef NDEBUG
3238 if (trim) {
3239 std::vector<const ExplodedNode *> Src;
3240
3241 // Iterate through the reports and get their nodes.
3242 for (BugReporter::EQClasses_iterator
3243 EI = BR.EQClasses_begin(), EE = BR.EQClasses_end(); EI != EE; ++EI) {
3244 const auto *R =
3245 dyn_cast<PathSensitiveBugReport>(EI->getReports()[0].get());
3246 if (!R)
3247 continue;
3248 const auto *N = const_cast<ExplodedNode *>(R->getErrorNode());
3249 Src.push_back(N);
3250 }
3251 return DumpGraph(Src, Filename);
3252 } else {
3253 return llvm::WriteGraph(&G, "ExprEngine", /*ShortNames=*/false,
3254 /*Title=*/"Exploded Graph",
3255 /*Filename=*/std::string(Filename));
3256 }
3257 #else
3258 llvm::errs() << "Warning: dumping graph requires assertions" << "\n";
3259 return "";
3260 #endif
3261 }
3262
DumpGraph(ArrayRef<const ExplodedNode * > Nodes,StringRef Filename)3263 std::string ExprEngine::DumpGraph(ArrayRef<const ExplodedNode*> Nodes,
3264 StringRef Filename) {
3265 #ifndef NDEBUG
3266 std::unique_ptr<ExplodedGraph> TrimmedG(G.trim(Nodes));
3267
3268 if (!TrimmedG.get()) {
3269 llvm::errs() << "warning: Trimmed ExplodedGraph is empty.\n";
3270 return "";
3271 } else {
3272 return llvm::WriteGraph(TrimmedG.get(), "TrimmedExprEngine",
3273 /*ShortNames=*/false,
3274 /*Title=*/"Trimmed Exploded Graph",
3275 /*Filename=*/std::string(Filename));
3276 }
3277 #else
3278 llvm::errs() << "Warning: dumping graph requires assertions" << "\n";
3279 return "";
3280 #endif
3281 }
3282
GDMIndex()3283 void *ProgramStateTrait<ReplayWithoutInlining>::GDMIndex() {
3284 static int index = 0;
3285 return &index;
3286 }
3287
anchor()3288 void ExprEngine::anchor() { }
3289