1 //=-- ExprEngine.cpp - Path-Sensitive Expression-Level Dataflow ---*- C++ -*-=
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines a meta-engine for path-sensitive dataflow analysis that
11 // is built on GREngine, but provides the boilerplate to execute transfer
12 // functions and build the ExplodedGraph at the expression level.
14 //===----------------------------------------------------------------------===//
16 #include "clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h"
17 #include "PrettyStackTraceLocationContext.h"
18 #include "clang/AST/CharUnits.h"
19 #include "clang/AST/ParentMap.h"
20 #include "clang/AST/StmtCXX.h"
21 #include "clang/AST/StmtObjC.h"
22 #include "clang/Basic/Builtins.h"
23 #include "clang/Basic/PrettyStackTrace.h"
24 #include "clang/Basic/SourceManager.h"
25 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
26 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
27 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
28 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
29 #include "clang/StaticAnalyzer/Core/PathSensitive/LoopWidening.h"
30 #include "llvm/ADT/ImmutableList.h"
31 #include "llvm/ADT/Statistic.h"
32 #include "llvm/Support/raw_ostream.h"
33 #include "llvm/Support/SaveAndRestore.h"
36 #include "llvm/Support/GraphWriter.h"
39 using namespace clang;
43 #define DEBUG_TYPE "ExprEngine"
45 STATISTIC(NumRemoveDeadBindings,
46 "The # of times RemoveDeadBindings is called");
47 STATISTIC(NumMaxBlockCountReached,
48 "The # of aborted paths due to reaching the maximum block count in "
49 "a top level function");
50 STATISTIC(NumMaxBlockCountReachedInInlined,
51 "The # of aborted paths due to reaching the maximum block count in "
52 "an inlined function");
53 STATISTIC(NumTimesRetriedWithoutInlining,
54 "The # of times we re-evaluated a call without inlining");
56 typedef std::pair<const CXXBindTemporaryExpr *, const StackFrameContext *>
57 CXXBindTemporaryContext;
59 // Keeps track of whether CXXBindTemporaryExpr nodes have been evaluated.
60 // The StackFrameContext assures that nested calls due to inlined recursive
61 // functions do not interfere.
62 REGISTER_TRAIT_WITH_PROGRAMSTATE(InitializedTemporariesSet,
63 llvm::ImmutableSet<CXXBindTemporaryContext>)
65 //===----------------------------------------------------------------------===//
66 // Engine construction and deletion.
67 //===----------------------------------------------------------------------===//
69 static const char* TagProviderName = "ExprEngine";
71 ExprEngine::ExprEngine(AnalysisManager &mgr, bool gcEnabled,
72 SetOfConstDecls *VisitedCalleesIn,
73 FunctionSummariesTy *FS,
74 InliningModes HowToInlineIn)
76 AnalysisDeclContexts(mgr.getAnalysisDeclContextManager()),
79 StateMgr(getContext(), mgr.getStoreManagerCreator(),
80 mgr.getConstraintManagerCreator(), G.getAllocator(),
82 SymMgr(StateMgr.getSymbolManager()),
83 svalBuilder(StateMgr.getSValBuilder()),
84 currStmtIdx(0), currBldrCtx(nullptr),
85 ObjCNoRet(mgr.getASTContext()),
86 ObjCGCEnabled(gcEnabled), BR(mgr, *this),
87 VisitedCallees(VisitedCalleesIn),
88 HowToInline(HowToInlineIn)
90 unsigned TrimInterval = mgr.options.getGraphTrimInterval();
91 if (TrimInterval != 0) {
92 // Enable eager node reclaimation when constructing the ExplodedGraph.
93 G.enableNodeReclamation(TrimInterval);
97 ExprEngine::~ExprEngine() {
101 //===----------------------------------------------------------------------===//
103 //===----------------------------------------------------------------------===//
105 ProgramStateRef ExprEngine::getInitialState(const LocationContext *InitLoc) {
106 ProgramStateRef state = StateMgr.getInitialState(InitLoc);
107 const Decl *D = InitLoc->getDecl();
110 // FIXME: It would be nice if we had a more general mechanism to add
111 // such preconditions. Some day.
114 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
115 // Precondition: the first argument of 'main' is an integer guaranteed
117 const IdentifierInfo *II = FD->getIdentifier();
118 if (!II || !(II->getName() == "main" && FD->getNumParams() > 0))
121 const ParmVarDecl *PD = FD->getParamDecl(0);
122 QualType T = PD->getType();
123 const BuiltinType *BT = dyn_cast<BuiltinType>(T);
124 if (!BT || !BT->isInteger())
127 const MemRegion *R = state->getRegion(PD, InitLoc);
131 SVal V = state->getSVal(loc::MemRegionVal(R));
132 SVal Constraint_untested = evalBinOp(state, BO_GT, V,
133 svalBuilder.makeZeroVal(T),
134 svalBuilder.getConditionType());
136 Optional<DefinedOrUnknownSVal> Constraint =
137 Constraint_untested.getAs<DefinedOrUnknownSVal>();
142 if (ProgramStateRef newState = state->assume(*Constraint, true))
149 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
150 // Precondition: 'self' is always non-null upon entry to an Objective-C
152 const ImplicitParamDecl *SelfD = MD->getSelfDecl();
153 const MemRegion *R = state->getRegion(SelfD, InitLoc);
154 SVal V = state->getSVal(loc::MemRegionVal(R));
156 if (Optional<Loc> LV = V.getAs<Loc>()) {
157 // Assume that the pointer value in 'self' is non-null.
158 state = state->assume(*LV, true);
159 assert(state && "'self' cannot be null");
163 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
164 if (!MD->isStatic()) {
165 // Precondition: 'this' is always non-null upon entry to the
166 // top-level function. This is our starting assumption for
167 // analyzing an "open" program.
168 const StackFrameContext *SFC = InitLoc->getCurrentStackFrame();
169 if (SFC->getParent() == nullptr) {
170 loc::MemRegionVal L = svalBuilder.getCXXThis(MD, SFC);
171 SVal V = state->getSVal(L);
172 if (Optional<Loc> LV = V.getAs<Loc>()) {
173 state = state->assume(*LV, true);
174 assert(state && "'this' cannot be null");
184 ExprEngine::createTemporaryRegionIfNeeded(ProgramStateRef State,
185 const LocationContext *LC,
187 const Expr *Result) {
188 SVal V = State->getSVal(Ex, LC);
190 // If we don't have an explicit result expression, we're in "if needed"
191 // mode. Only create a region if the current value is a NonLoc.
192 if (!V.getAs<NonLoc>())
196 // We need to create a region no matter what. For sanity, make sure we don't
197 // try to stuff a Loc into a non-pointer temporary region.
198 assert(!V.getAs<Loc>() || Loc::isLocType(Result->getType()) ||
199 Result->getType()->isMemberPointerType());
202 ProgramStateManager &StateMgr = State->getStateManager();
203 MemRegionManager &MRMgr = StateMgr.getRegionManager();
204 StoreManager &StoreMgr = StateMgr.getStoreManager();
206 // We need to be careful about treating a derived type's value as
207 // bindings for a base type. Unless we're creating a temporary pointer region,
208 // start by stripping and recording base casts.
209 SmallVector<const CastExpr *, 4> Casts;
210 const Expr *Inner = Ex->IgnoreParens();
211 if (!Loc::isLocType(Result->getType())) {
212 while (const CastExpr *CE = dyn_cast<CastExpr>(Inner)) {
213 if (CE->getCastKind() == CK_DerivedToBase ||
214 CE->getCastKind() == CK_UncheckedDerivedToBase)
216 else if (CE->getCastKind() != CK_NoOp)
219 Inner = CE->getSubExpr()->IgnoreParens();
223 // Create a temporary object region for the inner expression (which may have
224 // a more derived type) and bind the value into it.
225 const TypedValueRegion *TR = nullptr;
226 if (const MaterializeTemporaryExpr *MT =
227 dyn_cast<MaterializeTemporaryExpr>(Result)) {
228 StorageDuration SD = MT->getStorageDuration();
229 // If this object is bound to a reference with static storage duration, we
230 // put it in a different region to prevent "address leakage" warnings.
231 if (SD == SD_Static || SD == SD_Thread)
232 TR = MRMgr.getCXXStaticTempObjectRegion(Inner);
235 TR = MRMgr.getCXXTempObjectRegion(Inner, LC);
237 SVal Reg = loc::MemRegionVal(TR);
240 V = getSValBuilder().conjureSymbolVal(Result, LC, TR->getValueType(),
241 currBldrCtx->blockCount());
242 State = State->bindLoc(Reg, V);
244 // Re-apply the casts (from innermost to outermost) for type sanity.
245 for (SmallVectorImpl<const CastExpr *>::reverse_iterator I = Casts.rbegin(),
248 Reg = StoreMgr.evalDerivedToBase(Reg, *I);
251 State = State->BindExpr(Result, LC, Reg);
255 //===----------------------------------------------------------------------===//
256 // Top-level transfer function logic (Dispatcher).
257 //===----------------------------------------------------------------------===//
259 /// evalAssume - Called by ConstraintManager. Used to call checker-specific
260 /// logic for handling assumptions on symbolic values.
261 ProgramStateRef ExprEngine::processAssume(ProgramStateRef state,
262 SVal cond, bool assumption) {
263 return getCheckerManager().runCheckersForEvalAssume(state, cond, assumption);
266 bool ExprEngine::wantsRegionChangeUpdate(ProgramStateRef state) {
267 return getCheckerManager().wantsRegionChangeUpdate(state);
271 ExprEngine::processRegionChanges(ProgramStateRef state,
272 const InvalidatedSymbols *invalidated,
273 ArrayRef<const MemRegion *> Explicits,
274 ArrayRef<const MemRegion *> Regions,
275 const CallEvent *Call) {
276 return getCheckerManager().runCheckersForRegionChanges(state, invalidated,
277 Explicits, Regions, Call);
280 void ExprEngine::printState(raw_ostream &Out, ProgramStateRef State,
281 const char *NL, const char *Sep) {
282 getCheckerManager().runCheckersForPrintState(Out, State, NL, Sep);
285 void ExprEngine::processEndWorklist(bool hasWorkRemaining) {
286 getCheckerManager().runCheckersForEndAnalysis(G, BR, *this);
289 void ExprEngine::processCFGElement(const CFGElement E, ExplodedNode *Pred,
290 unsigned StmtIdx, NodeBuilderContext *Ctx) {
291 PrettyStackTraceLocationContext CrashInfo(Pred->getLocationContext());
292 currStmtIdx = StmtIdx;
295 switch (E.getKind()) {
296 case CFGElement::Statement:
297 ProcessStmt(const_cast<Stmt*>(E.castAs<CFGStmt>().getStmt()), Pred);
299 case CFGElement::Initializer:
300 ProcessInitializer(E.castAs<CFGInitializer>().getInitializer(), Pred);
302 case CFGElement::NewAllocator:
303 ProcessNewAllocator(E.castAs<CFGNewAllocator>().getAllocatorExpr(),
306 case CFGElement::AutomaticObjectDtor:
307 case CFGElement::DeleteDtor:
308 case CFGElement::BaseDtor:
309 case CFGElement::MemberDtor:
310 case CFGElement::TemporaryDtor:
311 ProcessImplicitDtor(E.castAs<CFGImplicitDtor>(), Pred);
316 static bool shouldRemoveDeadBindings(AnalysisManager &AMgr,
318 const ExplodedNode *Pred,
319 const LocationContext *LC) {
321 // Are we never purging state values?
322 if (AMgr.options.AnalysisPurgeOpt == PurgeNone)
325 // Is this the beginning of a basic block?
326 if (Pred->getLocation().getAs<BlockEntrance>())
329 // Is this on a non-expression?
330 if (!isa<Expr>(S.getStmt()))
333 // Run before processing a call.
334 if (CallEvent::isCallStmt(S.getStmt()))
337 // Is this an expression that is consumed by another expression? If so,
338 // postpone cleaning out the state.
339 ParentMap &PM = LC->getAnalysisDeclContext()->getParentMap();
340 return !PM.isConsumedExpr(cast<Expr>(S.getStmt()));
343 void ExprEngine::removeDead(ExplodedNode *Pred, ExplodedNodeSet &Out,
344 const Stmt *ReferenceStmt,
345 const LocationContext *LC,
346 const Stmt *DiagnosticStmt,
347 ProgramPoint::Kind K) {
348 assert((K == ProgramPoint::PreStmtPurgeDeadSymbolsKind ||
349 ReferenceStmt == nullptr || isa<ReturnStmt>(ReferenceStmt))
350 && "PostStmt is not generally supported by the SymbolReaper yet");
351 assert(LC && "Must pass the current (or expiring) LocationContext");
353 if (!DiagnosticStmt) {
354 DiagnosticStmt = ReferenceStmt;
355 assert(DiagnosticStmt && "Required for clearing a LocationContext");
358 NumRemoveDeadBindings++;
359 ProgramStateRef CleanedState = Pred->getState();
361 // LC is the location context being destroyed, but SymbolReaper wants a
362 // location context that is still live. (If this is the top-level stack
363 // frame, this will be null.)
364 if (!ReferenceStmt) {
365 assert(K == ProgramPoint::PostStmtPurgeDeadSymbolsKind &&
366 "Use PostStmtPurgeDeadSymbolsKind for clearing a LocationContext");
367 LC = LC->getParent();
370 const StackFrameContext *SFC = LC ? LC->getCurrentStackFrame() : nullptr;
371 SymbolReaper SymReaper(SFC, ReferenceStmt, SymMgr, getStoreManager());
373 getCheckerManager().runCheckersForLiveSymbols(CleanedState, SymReaper);
375 // Create a state in which dead bindings are removed from the environment
376 // and the store. TODO: The function should just return new env and store,
378 CleanedState = StateMgr.removeDeadBindings(CleanedState, SFC, SymReaper);
380 // Process any special transfer function for dead symbols.
381 // A tag to track convenience transitions, which can be removed at cleanup.
382 static SimpleProgramPointTag cleanupTag(TagProviderName, "Clean Node");
383 if (!SymReaper.hasDeadSymbols()) {
384 // Generate a CleanedNode that has the environment and store cleaned
385 // up. Since no symbols are dead, we can optimize and not clean out
386 // the constraint manager.
387 StmtNodeBuilder Bldr(Pred, Out, *currBldrCtx);
388 Bldr.generateNode(DiagnosticStmt, Pred, CleanedState, &cleanupTag, K);
391 // Call checkers with the non-cleaned state so that they could query the
392 // values of the soon to be dead symbols.
393 ExplodedNodeSet CheckedSet;
394 getCheckerManager().runCheckersForDeadSymbols(CheckedSet, Pred, SymReaper,
395 DiagnosticStmt, *this, K);
397 // For each node in CheckedSet, generate CleanedNodes that have the
398 // environment, the store, and the constraints cleaned up but have the
399 // user-supplied states as the predecessors.
400 StmtNodeBuilder Bldr(CheckedSet, Out, *currBldrCtx);
401 for (ExplodedNodeSet::const_iterator
402 I = CheckedSet.begin(), E = CheckedSet.end(); I != E; ++I) {
403 ProgramStateRef CheckerState = (*I)->getState();
405 // The constraint manager has not been cleaned up yet, so clean up now.
406 CheckerState = getConstraintManager().removeDeadBindings(CheckerState,
409 assert(StateMgr.haveEqualEnvironments(CheckerState, Pred->getState()) &&
410 "Checkers are not allowed to modify the Environment as a part of "
411 "checkDeadSymbols processing.");
412 assert(StateMgr.haveEqualStores(CheckerState, Pred->getState()) &&
413 "Checkers are not allowed to modify the Store as a part of "
414 "checkDeadSymbols processing.");
416 // Create a state based on CleanedState with CheckerState GDM and
417 // generate a transition to that state.
418 ProgramStateRef CleanedCheckerSt =
419 StateMgr.getPersistentStateWithGDM(CleanedState, CheckerState);
420 Bldr.generateNode(DiagnosticStmt, *I, CleanedCheckerSt, &cleanupTag, K);
425 void ExprEngine::ProcessStmt(const CFGStmt S,
426 ExplodedNode *Pred) {
427 // Reclaim any unnecessary nodes in the ExplodedGraph.
428 G.reclaimRecentlyAllocatedNodes();
430 const Stmt *currStmt = S.getStmt();
431 PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
432 currStmt->getLocStart(),
433 "Error evaluating statement");
435 // Remove dead bindings and symbols.
436 ExplodedNodeSet CleanedStates;
437 if (shouldRemoveDeadBindings(AMgr, S, Pred, Pred->getLocationContext())){
438 removeDead(Pred, CleanedStates, currStmt, Pred->getLocationContext());
440 CleanedStates.Add(Pred);
442 // Visit the statement.
444 for (ExplodedNodeSet::iterator I = CleanedStates.begin(),
445 E = CleanedStates.end(); I != E; ++I) {
446 ExplodedNodeSet DstI;
447 // Visit the statement.
448 Visit(currStmt, *I, DstI);
452 // Enqueue the new nodes onto the work list.
453 Engine.enqueue(Dst, currBldrCtx->getBlock(), currStmtIdx);
456 void ExprEngine::ProcessInitializer(const CFGInitializer Init,
457 ExplodedNode *Pred) {
458 const CXXCtorInitializer *BMI = Init.getInitializer();
460 PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
461 BMI->getSourceLocation(),
462 "Error evaluating initializer");
464 // We don't clean up dead bindings here.
465 const StackFrameContext *stackFrame =
466 cast<StackFrameContext>(Pred->getLocationContext());
467 const CXXConstructorDecl *decl =
468 cast<CXXConstructorDecl>(stackFrame->getDecl());
470 ProgramStateRef State = Pred->getState();
471 SVal thisVal = State->getSVal(svalBuilder.getCXXThis(decl, stackFrame));
473 ExplodedNodeSet Tmp(Pred);
476 // Evaluate the initializer, if necessary
477 if (BMI->isAnyMemberInitializer()) {
478 // Constructors build the object directly in the field,
479 // but non-objects must be copied in from the initializer.
480 if (auto *CtorExpr = findDirectConstructorForCurrentCFGElement()) {
481 assert(BMI->getInit()->IgnoreImplicit() == CtorExpr);
483 // The field was directly constructed, so there is no need to bind.
485 const Expr *Init = BMI->getInit()->IgnoreImplicit();
486 const ValueDecl *Field;
487 if (BMI->isIndirectMemberInitializer()) {
488 Field = BMI->getIndirectMember();
489 FieldLoc = State->getLValue(BMI->getIndirectMember(), thisVal);
491 Field = BMI->getMember();
492 FieldLoc = State->getLValue(BMI->getMember(), thisVal);
496 if (BMI->getNumArrayIndices() > 0) {
497 // Handle arrays of trivial type. We can represent this with a
498 // primitive load/copy from the base array region.
499 const ArraySubscriptExpr *ASE;
500 while ((ASE = dyn_cast<ArraySubscriptExpr>(Init)))
501 Init = ASE->getBase()->IgnoreImplicit();
503 SVal LValue = State->getSVal(Init, stackFrame);
504 if (Optional<Loc> LValueLoc = LValue.getAs<Loc>())
505 InitVal = State->getSVal(*LValueLoc);
507 // If we fail to get the value for some reason, use a symbolic value.
508 if (InitVal.isUnknownOrUndef()) {
509 SValBuilder &SVB = getSValBuilder();
510 InitVal = SVB.conjureSymbolVal(BMI->getInit(), stackFrame,
512 currBldrCtx->blockCount());
515 InitVal = State->getSVal(BMI->getInit(), stackFrame);
518 assert(Tmp.size() == 1 && "have not generated any new nodes yet");
519 assert(*Tmp.begin() == Pred && "have not generated any new nodes yet");
522 PostInitializer PP(BMI, FieldLoc.getAsRegion(), stackFrame);
523 evalBind(Tmp, Init, Pred, FieldLoc, InitVal, /*isInit=*/true, &PP);
526 assert(BMI->isBaseInitializer() || BMI->isDelegatingInitializer());
527 // We already did all the work when visiting the CXXConstructExpr.
530 // Construct PostInitializer nodes whether the state changed or not,
531 // so that the diagnostics don't get confused.
532 PostInitializer PP(BMI, FieldLoc.getAsRegion(), stackFrame);
534 NodeBuilder Bldr(Tmp, Dst, *currBldrCtx);
535 for (ExplodedNodeSet::iterator I = Tmp.begin(), E = Tmp.end(); I != E; ++I) {
536 ExplodedNode *N = *I;
537 Bldr.generateNode(PP, N->getState(), N);
540 // Enqueue the new nodes onto the work list.
541 Engine.enqueue(Dst, currBldrCtx->getBlock(), currStmtIdx);
544 void ExprEngine::ProcessImplicitDtor(const CFGImplicitDtor D,
545 ExplodedNode *Pred) {
547 switch (D.getKind()) {
548 case CFGElement::AutomaticObjectDtor:
549 ProcessAutomaticObjDtor(D.castAs<CFGAutomaticObjDtor>(), Pred, Dst);
551 case CFGElement::BaseDtor:
552 ProcessBaseDtor(D.castAs<CFGBaseDtor>(), Pred, Dst);
554 case CFGElement::MemberDtor:
555 ProcessMemberDtor(D.castAs<CFGMemberDtor>(), Pred, Dst);
557 case CFGElement::TemporaryDtor:
558 ProcessTemporaryDtor(D.castAs<CFGTemporaryDtor>(), Pred, Dst);
560 case CFGElement::DeleteDtor:
561 ProcessDeleteDtor(D.castAs<CFGDeleteDtor>(), Pred, Dst);
564 llvm_unreachable("Unexpected dtor kind.");
567 // Enqueue the new nodes onto the work list.
568 Engine.enqueue(Dst, currBldrCtx->getBlock(), currStmtIdx);
571 void ExprEngine::ProcessNewAllocator(const CXXNewExpr *NE,
572 ExplodedNode *Pred) {
574 AnalysisManager &AMgr = getAnalysisManager();
575 AnalyzerOptions &Opts = AMgr.options;
576 // TODO: We're not evaluating allocators for all cases just yet as
577 // we're not handling the return value correctly, which causes false
578 // positives when the alpha.cplusplus.NewDeleteLeaks check is on.
579 if (Opts.mayInlineCXXAllocator())
580 VisitCXXNewAllocatorCall(NE, Pred, Dst);
582 NodeBuilder Bldr(Pred, Dst, *currBldrCtx);
583 const LocationContext *LCtx = Pred->getLocationContext();
584 PostImplicitCall PP(NE->getOperatorNew(), NE->getLocStart(), LCtx);
585 Bldr.generateNode(PP, Pred->getState(), Pred);
587 Engine.enqueue(Dst, currBldrCtx->getBlock(), currStmtIdx);
590 void ExprEngine::ProcessAutomaticObjDtor(const CFGAutomaticObjDtor Dtor,
592 ExplodedNodeSet &Dst) {
593 const VarDecl *varDecl = Dtor.getVarDecl();
594 QualType varType = varDecl->getType();
596 ProgramStateRef state = Pred->getState();
597 SVal dest = state->getLValue(varDecl, Pred->getLocationContext());
598 const MemRegion *Region = dest.castAs<loc::MemRegionVal>().getRegion();
600 if (const ReferenceType *refType = varType->getAs<ReferenceType>()) {
601 varType = refType->getPointeeType();
602 Region = state->getSVal(Region).getAsRegion();
605 VisitCXXDestructor(varType, Region, Dtor.getTriggerStmt(), /*IsBase=*/ false,
609 void ExprEngine::ProcessDeleteDtor(const CFGDeleteDtor Dtor,
611 ExplodedNodeSet &Dst) {
612 ProgramStateRef State = Pred->getState();
613 const LocationContext *LCtx = Pred->getLocationContext();
614 const CXXDeleteExpr *DE = Dtor.getDeleteExpr();
615 const Stmt *Arg = DE->getArgument();
616 SVal ArgVal = State->getSVal(Arg, LCtx);
618 // If the argument to delete is known to be a null value,
619 // don't run destructor.
620 if (State->isNull(ArgVal).isConstrainedTrue()) {
621 QualType DTy = DE->getDestroyedType();
622 QualType BTy = getContext().getBaseElementType(DTy);
623 const CXXRecordDecl *RD = BTy->getAsCXXRecordDecl();
624 const CXXDestructorDecl *Dtor = RD->getDestructor();
626 PostImplicitCall PP(Dtor, DE->getLocStart(), LCtx);
627 NodeBuilder Bldr(Pred, Dst, *currBldrCtx);
628 Bldr.generateNode(PP, Pred->getState(), Pred);
632 VisitCXXDestructor(DE->getDestroyedType(),
633 ArgVal.getAsRegion(),
634 DE, /*IsBase=*/ false,
638 void ExprEngine::ProcessBaseDtor(const CFGBaseDtor D,
639 ExplodedNode *Pred, ExplodedNodeSet &Dst) {
640 const LocationContext *LCtx = Pred->getLocationContext();
642 const CXXDestructorDecl *CurDtor = cast<CXXDestructorDecl>(LCtx->getDecl());
643 Loc ThisPtr = getSValBuilder().getCXXThis(CurDtor,
644 LCtx->getCurrentStackFrame());
645 SVal ThisVal = Pred->getState()->getSVal(ThisPtr);
647 // Create the base object region.
648 const CXXBaseSpecifier *Base = D.getBaseSpecifier();
649 QualType BaseTy = Base->getType();
650 SVal BaseVal = getStoreManager().evalDerivedToBase(ThisVal, BaseTy,
653 VisitCXXDestructor(BaseTy, BaseVal.castAs<loc::MemRegionVal>().getRegion(),
654 CurDtor->getBody(), /*IsBase=*/ true, Pred, Dst);
657 void ExprEngine::ProcessMemberDtor(const CFGMemberDtor D,
658 ExplodedNode *Pred, ExplodedNodeSet &Dst) {
659 const FieldDecl *Member = D.getFieldDecl();
660 ProgramStateRef State = Pred->getState();
661 const LocationContext *LCtx = Pred->getLocationContext();
663 const CXXDestructorDecl *CurDtor = cast<CXXDestructorDecl>(LCtx->getDecl());
664 Loc ThisVal = getSValBuilder().getCXXThis(CurDtor,
665 LCtx->getCurrentStackFrame());
667 State->getLValue(Member, State->getSVal(ThisVal).castAs<Loc>());
669 VisitCXXDestructor(Member->getType(),
670 FieldVal.castAs<loc::MemRegionVal>().getRegion(),
671 CurDtor->getBody(), /*IsBase=*/false, Pred, Dst);
674 void ExprEngine::ProcessTemporaryDtor(const CFGTemporaryDtor D,
676 ExplodedNodeSet &Dst) {
677 ExplodedNodeSet CleanDtorState;
678 StmtNodeBuilder StmtBldr(Pred, CleanDtorState, *currBldrCtx);
679 ProgramStateRef State = Pred->getState();
680 if (State->contains<InitializedTemporariesSet>(
681 std::make_pair(D.getBindTemporaryExpr(), Pred->getStackFrame()))) {
682 // FIXME: Currently we insert temporary destructors for default parameters,
683 // but we don't insert the constructors.
684 State = State->remove<InitializedTemporariesSet>(
685 std::make_pair(D.getBindTemporaryExpr(), Pred->getStackFrame()));
687 StmtBldr.generateNode(D.getBindTemporaryExpr(), Pred, State);
689 QualType varType = D.getBindTemporaryExpr()->getSubExpr()->getType();
690 // FIXME: Currently CleanDtorState can be empty here due to temporaries being
691 // bound to default parameters.
692 assert(CleanDtorState.size() <= 1);
693 ExplodedNode *CleanPred =
694 CleanDtorState.empty() ? Pred : *CleanDtorState.begin();
695 // FIXME: Inlining of temporary destructors is not supported yet anyway, so
696 // we just put a NULL region for now. This will need to be changed later.
697 VisitCXXDestructor(varType, nullptr, D.getBindTemporaryExpr(),
698 /*IsBase=*/false, CleanPred, Dst);
701 void ExprEngine::processCleanupTemporaryBranch(const CXXBindTemporaryExpr *BTE,
702 NodeBuilderContext &BldCtx,
704 ExplodedNodeSet &Dst,
705 const CFGBlock *DstT,
706 const CFGBlock *DstF) {
707 BranchNodeBuilder TempDtorBuilder(Pred, Dst, BldCtx, DstT, DstF);
708 if (Pred->getState()->contains<InitializedTemporariesSet>(
709 std::make_pair(BTE, Pred->getStackFrame()))) {
710 TempDtorBuilder.markInfeasible(false);
711 TempDtorBuilder.generateNode(Pred->getState(), true, Pred);
713 TempDtorBuilder.markInfeasible(true);
714 TempDtorBuilder.generateNode(Pred->getState(), false, Pred);
718 void ExprEngine::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *BTE,
719 ExplodedNodeSet &PreVisit,
720 ExplodedNodeSet &Dst) {
721 if (!getAnalysisManager().options.includeTemporaryDtorsInCFG()) {
722 // In case we don't have temporary destructors in the CFG, do not mark
723 // the initialization - we would otherwise never clean it up.
727 StmtNodeBuilder StmtBldr(PreVisit, Dst, *currBldrCtx);
728 for (ExplodedNode *Node : PreVisit) {
729 ProgramStateRef State = Node->getState();
731 if (!State->contains<InitializedTemporariesSet>(
732 std::make_pair(BTE, Node->getStackFrame()))) {
733 // FIXME: Currently the state might already contain the marker due to
734 // incorrect handling of temporaries bound to default parameters; for
735 // those, we currently skip the CXXBindTemporaryExpr but rely on adding
736 // temporary destructor nodes.
737 State = State->add<InitializedTemporariesSet>(
738 std::make_pair(BTE, Node->getStackFrame()));
740 StmtBldr.generateNode(BTE, Node, State);
744 void ExprEngine::Visit(const Stmt *S, ExplodedNode *Pred,
745 ExplodedNodeSet &DstTop) {
746 PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
748 "Error evaluating statement");
750 StmtNodeBuilder Bldr(Pred, DstTop, *currBldrCtx);
752 assert(!isa<Expr>(S) || S == cast<Expr>(S)->IgnoreParens());
754 switch (S->getStmtClass()) {
755 // C++ and ARC stuff we don't support yet.
756 case Expr::ObjCIndirectCopyRestoreExprClass:
757 case Stmt::CXXDependentScopeMemberExprClass:
758 case Stmt::CXXInheritedCtorInitExprClass:
759 case Stmt::CXXTryStmtClass:
760 case Stmt::CXXTypeidExprClass:
761 case Stmt::CXXUuidofExprClass:
762 case Stmt::CXXFoldExprClass:
763 case Stmt::MSPropertyRefExprClass:
764 case Stmt::MSPropertySubscriptExprClass:
765 case Stmt::CXXUnresolvedConstructExprClass:
766 case Stmt::DependentScopeDeclRefExprClass:
767 case Stmt::ArrayTypeTraitExprClass:
768 case Stmt::ExpressionTraitExprClass:
769 case Stmt::UnresolvedLookupExprClass:
770 case Stmt::UnresolvedMemberExprClass:
771 case Stmt::TypoExprClass:
772 case Stmt::CXXNoexceptExprClass:
773 case Stmt::PackExpansionExprClass:
774 case Stmt::SubstNonTypeTemplateParmPackExprClass:
775 case Stmt::FunctionParmPackExprClass:
776 case Stmt::CoroutineBodyStmtClass:
777 case Stmt::CoawaitExprClass:
778 case Stmt::CoreturnStmtClass:
779 case Stmt::CoyieldExprClass:
780 case Stmt::SEHTryStmtClass:
781 case Stmt::SEHExceptStmtClass:
782 case Stmt::SEHLeaveStmtClass:
783 case Stmt::SEHFinallyStmtClass: {
784 const ExplodedNode *node = Bldr.generateSink(S, Pred, Pred->getState());
785 Engine.addAbortedBlock(node, currBldrCtx->getBlock());
789 case Stmt::ParenExprClass:
790 llvm_unreachable("ParenExprs already handled.");
791 case Stmt::GenericSelectionExprClass:
792 llvm_unreachable("GenericSelectionExprs already handled.");
793 // Cases that should never be evaluated simply because they shouldn't
794 // appear in the CFG.
795 case Stmt::BreakStmtClass:
796 case Stmt::CaseStmtClass:
797 case Stmt::CompoundStmtClass:
798 case Stmt::ContinueStmtClass:
799 case Stmt::CXXForRangeStmtClass:
800 case Stmt::DefaultStmtClass:
801 case Stmt::DoStmtClass:
802 case Stmt::ForStmtClass:
803 case Stmt::GotoStmtClass:
804 case Stmt::IfStmtClass:
805 case Stmt::IndirectGotoStmtClass:
806 case Stmt::LabelStmtClass:
807 case Stmt::NoStmtClass:
808 case Stmt::NullStmtClass:
809 case Stmt::SwitchStmtClass:
810 case Stmt::WhileStmtClass:
811 case Expr::MSDependentExistsStmtClass:
812 case Stmt::CapturedStmtClass:
813 case Stmt::OMPParallelDirectiveClass:
814 case Stmt::OMPSimdDirectiveClass:
815 case Stmt::OMPForDirectiveClass:
816 case Stmt::OMPForSimdDirectiveClass:
817 case Stmt::OMPSectionsDirectiveClass:
818 case Stmt::OMPSectionDirectiveClass:
819 case Stmt::OMPSingleDirectiveClass:
820 case Stmt::OMPMasterDirectiveClass:
821 case Stmt::OMPCriticalDirectiveClass:
822 case Stmt::OMPParallelForDirectiveClass:
823 case Stmt::OMPParallelForSimdDirectiveClass:
824 case Stmt::OMPParallelSectionsDirectiveClass:
825 case Stmt::OMPTaskDirectiveClass:
826 case Stmt::OMPTaskyieldDirectiveClass:
827 case Stmt::OMPBarrierDirectiveClass:
828 case Stmt::OMPTaskwaitDirectiveClass:
829 case Stmt::OMPTaskgroupDirectiveClass:
830 case Stmt::OMPFlushDirectiveClass:
831 case Stmt::OMPOrderedDirectiveClass:
832 case Stmt::OMPAtomicDirectiveClass:
833 case Stmt::OMPTargetDirectiveClass:
834 case Stmt::OMPTargetDataDirectiveClass:
835 case Stmt::OMPTargetEnterDataDirectiveClass:
836 case Stmt::OMPTargetExitDataDirectiveClass:
837 case Stmt::OMPTargetParallelDirectiveClass:
838 case Stmt::OMPTargetParallelForDirectiveClass:
839 case Stmt::OMPTargetUpdateDirectiveClass:
840 case Stmt::OMPTeamsDirectiveClass:
841 case Stmt::OMPCancellationPointDirectiveClass:
842 case Stmt::OMPCancelDirectiveClass:
843 case Stmt::OMPTaskLoopDirectiveClass:
844 case Stmt::OMPTaskLoopSimdDirectiveClass:
845 case Stmt::OMPDistributeDirectiveClass:
846 case Stmt::OMPDistributeParallelForDirectiveClass:
847 case Stmt::OMPDistributeParallelForSimdDirectiveClass:
848 case Stmt::OMPDistributeSimdDirectiveClass:
849 case Stmt::OMPTargetParallelForSimdDirectiveClass:
850 llvm_unreachable("Stmt should not be in analyzer evaluation loop");
852 case Stmt::ObjCSubscriptRefExprClass:
853 case Stmt::ObjCPropertyRefExprClass:
854 llvm_unreachable("These are handled by PseudoObjectExpr");
856 case Stmt::GNUNullExprClass: {
857 // GNU __null is a pointer-width integer, not an actual pointer.
858 ProgramStateRef state = Pred->getState();
859 state = state->BindExpr(S, Pred->getLocationContext(),
860 svalBuilder.makeIntValWithPtrWidth(0, false));
861 Bldr.generateNode(S, Pred, state);
865 case Stmt::ObjCAtSynchronizedStmtClass:
866 Bldr.takeNodes(Pred);
867 VisitObjCAtSynchronizedStmt(cast<ObjCAtSynchronizedStmt>(S), Pred, Dst);
871 case Stmt::ExprWithCleanupsClass:
872 // Handled due to fully linearised CFG.
875 case Stmt::CXXBindTemporaryExprClass: {
876 Bldr.takeNodes(Pred);
877 ExplodedNodeSet PreVisit;
878 getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
879 ExplodedNodeSet Next;
880 VisitCXXBindTemporaryExpr(cast<CXXBindTemporaryExpr>(S), PreVisit, Next);
881 getCheckerManager().runCheckersForPostStmt(Dst, Next, S, *this);
886 // Cases not handled yet; but will handle some day.
887 case Stmt::DesignatedInitExprClass:
888 case Stmt::DesignatedInitUpdateExprClass:
889 case Stmt::ExtVectorElementExprClass:
890 case Stmt::ImaginaryLiteralClass:
891 case Stmt::ObjCAtCatchStmtClass:
892 case Stmt::ObjCAtFinallyStmtClass:
893 case Stmt::ObjCAtTryStmtClass:
894 case Stmt::ObjCAutoreleasePoolStmtClass:
895 case Stmt::ObjCEncodeExprClass:
896 case Stmt::ObjCIsaExprClass:
897 case Stmt::ObjCProtocolExprClass:
898 case Stmt::ObjCSelectorExprClass:
899 case Stmt::ParenListExprClass:
900 case Stmt::ShuffleVectorExprClass:
901 case Stmt::ConvertVectorExprClass:
902 case Stmt::VAArgExprClass:
903 case Stmt::CUDAKernelCallExprClass:
904 case Stmt::OpaqueValueExprClass:
905 case Stmt::AsTypeExprClass:
908 // Cases we intentionally don't evaluate, since they don't need
909 // to be explicitly evaluated.
910 case Stmt::PredefinedExprClass:
911 case Stmt::AddrLabelExprClass:
912 case Stmt::AttributedStmtClass:
913 case Stmt::IntegerLiteralClass:
914 case Stmt::CharacterLiteralClass:
915 case Stmt::ImplicitValueInitExprClass:
916 case Stmt::CXXScalarValueInitExprClass:
917 case Stmt::CXXBoolLiteralExprClass:
918 case Stmt::ObjCBoolLiteralExprClass:
919 case Stmt::ObjCAvailabilityCheckExprClass:
920 case Stmt::FloatingLiteralClass:
921 case Stmt::NoInitExprClass:
922 case Stmt::SizeOfPackExprClass:
923 case Stmt::StringLiteralClass:
924 case Stmt::ObjCStringLiteralClass:
925 case Stmt::CXXPseudoDestructorExprClass:
926 case Stmt::SubstNonTypeTemplateParmExprClass:
927 case Stmt::CXXNullPtrLiteralExprClass:
928 case Stmt::OMPArraySectionExprClass:
929 case Stmt::TypeTraitExprClass: {
930 Bldr.takeNodes(Pred);
931 ExplodedNodeSet preVisit;
932 getCheckerManager().runCheckersForPreStmt(preVisit, Pred, S, *this);
933 getCheckerManager().runCheckersForPostStmt(Dst, preVisit, S, *this);
938 case Stmt::CXXDefaultArgExprClass:
939 case Stmt::CXXDefaultInitExprClass: {
940 Bldr.takeNodes(Pred);
941 ExplodedNodeSet PreVisit;
942 getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
945 StmtNodeBuilder Bldr2(PreVisit, Tmp, *currBldrCtx);
948 if (const CXXDefaultArgExpr *DefE = dyn_cast<CXXDefaultArgExpr>(S))
949 ArgE = DefE->getExpr();
950 else if (const CXXDefaultInitExpr *DefE = dyn_cast<CXXDefaultInitExpr>(S))
951 ArgE = DefE->getExpr();
953 llvm_unreachable("unknown constant wrapper kind");
955 bool IsTemporary = false;
956 if (const MaterializeTemporaryExpr *MTE =
957 dyn_cast<MaterializeTemporaryExpr>(ArgE)) {
958 ArgE = MTE->GetTemporaryExpr();
962 Optional<SVal> ConstantVal = svalBuilder.getConstantVal(ArgE);
964 ConstantVal = UnknownVal();
966 const LocationContext *LCtx = Pred->getLocationContext();
967 for (ExplodedNodeSet::iterator I = PreVisit.begin(), E = PreVisit.end();
969 ProgramStateRef State = (*I)->getState();
970 State = State->BindExpr(S, LCtx, *ConstantVal);
972 State = createTemporaryRegionIfNeeded(State, LCtx,
975 Bldr2.generateNode(S, *I, State);
978 getCheckerManager().runCheckersForPostStmt(Dst, Tmp, S, *this);
983 // Cases we evaluate as opaque expressions, conjuring a symbol.
984 case Stmt::CXXStdInitializerListExprClass:
985 case Expr::ObjCArrayLiteralClass:
986 case Expr::ObjCDictionaryLiteralClass:
987 case Expr::ObjCBoxedExprClass: {
988 Bldr.takeNodes(Pred);
990 ExplodedNodeSet preVisit;
991 getCheckerManager().runCheckersForPreStmt(preVisit, Pred, S, *this);
994 StmtNodeBuilder Bldr2(preVisit, Tmp, *currBldrCtx);
996 const Expr *Ex = cast<Expr>(S);
997 QualType resultType = Ex->getType();
999 for (ExplodedNodeSet::iterator it = preVisit.begin(), et = preVisit.end();
1001 ExplodedNode *N = *it;
1002 const LocationContext *LCtx = N->getLocationContext();
1003 SVal result = svalBuilder.conjureSymbolVal(nullptr, Ex, LCtx,
1005 currBldrCtx->blockCount());
1006 ProgramStateRef state = N->getState()->BindExpr(Ex, LCtx, result);
1007 Bldr2.generateNode(S, N, state);
1010 getCheckerManager().runCheckersForPostStmt(Dst, Tmp, S, *this);
1015 case Stmt::ArraySubscriptExprClass:
1016 Bldr.takeNodes(Pred);
1017 VisitLvalArraySubscriptExpr(cast<ArraySubscriptExpr>(S), Pred, Dst);
1021 case Stmt::GCCAsmStmtClass:
1022 Bldr.takeNodes(Pred);
1023 VisitGCCAsmStmt(cast<GCCAsmStmt>(S), Pred, Dst);
1027 case Stmt::MSAsmStmtClass:
1028 Bldr.takeNodes(Pred);
1029 VisitMSAsmStmt(cast<MSAsmStmt>(S), Pred, Dst);
1033 case Stmt::BlockExprClass:
1034 Bldr.takeNodes(Pred);
1035 VisitBlockExpr(cast<BlockExpr>(S), Pred, Dst);
1039 case Stmt::LambdaExprClass:
1040 if (AMgr.options.shouldInlineLambdas()) {
1041 Bldr.takeNodes(Pred);
1042 VisitLambdaExpr(cast<LambdaExpr>(S), Pred, Dst);
1045 const ExplodedNode *node = Bldr.generateSink(S, Pred, Pred->getState());
1046 Engine.addAbortedBlock(node, currBldrCtx->getBlock());
1050 case Stmt::BinaryOperatorClass: {
1051 const BinaryOperator* B = cast<BinaryOperator>(S);
1052 if (B->isLogicalOp()) {
1053 Bldr.takeNodes(Pred);
1054 VisitLogicalExpr(B, Pred, Dst);
1058 else if (B->getOpcode() == BO_Comma) {
1059 ProgramStateRef state = Pred->getState();
1060 Bldr.generateNode(B, Pred,
1061 state->BindExpr(B, Pred->getLocationContext(),
1062 state->getSVal(B->getRHS(),
1063 Pred->getLocationContext())));
1067 Bldr.takeNodes(Pred);
1069 if (AMgr.options.eagerlyAssumeBinOpBifurcation &&
1070 (B->isRelationalOp() || B->isEqualityOp())) {
1071 ExplodedNodeSet Tmp;
1072 VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Tmp);
1073 evalEagerlyAssumeBinOpBifurcation(Dst, Tmp, cast<Expr>(S));
1076 VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Dst);
1082 case Stmt::CXXOperatorCallExprClass: {
1083 const CXXOperatorCallExpr *OCE = cast<CXXOperatorCallExpr>(S);
1085 // For instance method operators, make sure the 'this' argument has a
1087 const Decl *Callee = OCE->getCalleeDecl();
1088 if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Callee)) {
1089 if (MD->isInstance()) {
1090 ProgramStateRef State = Pred->getState();
1091 const LocationContext *LCtx = Pred->getLocationContext();
1092 ProgramStateRef NewState =
1093 createTemporaryRegionIfNeeded(State, LCtx, OCE->getArg(0));
1094 if (NewState != State) {
1095 Pred = Bldr.generateNode(OCE, Pred, NewState, /*Tag=*/nullptr,
1096 ProgramPoint::PreStmtKind);
1097 // Did we cache out?
1105 case Stmt::CallExprClass:
1106 case Stmt::CXXMemberCallExprClass:
1107 case Stmt::UserDefinedLiteralClass: {
1108 Bldr.takeNodes(Pred);
1109 VisitCallExpr(cast<CallExpr>(S), Pred, Dst);
1114 case Stmt::CXXCatchStmtClass: {
1115 Bldr.takeNodes(Pred);
1116 VisitCXXCatchStmt(cast<CXXCatchStmt>(S), Pred, Dst);
1121 case Stmt::CXXTemporaryObjectExprClass:
1122 case Stmt::CXXConstructExprClass: {
1123 Bldr.takeNodes(Pred);
1124 VisitCXXConstructExpr(cast<CXXConstructExpr>(S), Pred, Dst);
1129 case Stmt::CXXNewExprClass: {
1130 Bldr.takeNodes(Pred);
1131 ExplodedNodeSet PostVisit;
1132 VisitCXXNewExpr(cast<CXXNewExpr>(S), Pred, PostVisit);
1133 getCheckerManager().runCheckersForPostStmt(Dst, PostVisit, S, *this);
1138 case Stmt::CXXDeleteExprClass: {
1139 Bldr.takeNodes(Pred);
1140 ExplodedNodeSet PreVisit;
1141 const CXXDeleteExpr *CDE = cast<CXXDeleteExpr>(S);
1142 getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
1144 for (ExplodedNodeSet::iterator i = PreVisit.begin(),
1145 e = PreVisit.end(); i != e ; ++i)
1146 VisitCXXDeleteExpr(CDE, *i, Dst);
1151 // FIXME: ChooseExpr is really a constant. We need to fix
1152 // the CFG do not model them as explicit control-flow.
1154 case Stmt::ChooseExprClass: { // __builtin_choose_expr
1155 Bldr.takeNodes(Pred);
1156 const ChooseExpr *C = cast<ChooseExpr>(S);
1157 VisitGuardedExpr(C, C->getLHS(), C->getRHS(), Pred, Dst);
1162 case Stmt::CompoundAssignOperatorClass:
1163 Bldr.takeNodes(Pred);
1164 VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Dst);
1168 case Stmt::CompoundLiteralExprClass:
1169 Bldr.takeNodes(Pred);
1170 VisitCompoundLiteralExpr(cast<CompoundLiteralExpr>(S), Pred, Dst);
1174 case Stmt::BinaryConditionalOperatorClass:
1175 case Stmt::ConditionalOperatorClass: { // '?' operator
1176 Bldr.takeNodes(Pred);
1177 const AbstractConditionalOperator *C
1178 = cast<AbstractConditionalOperator>(S);
1179 VisitGuardedExpr(C, C->getTrueExpr(), C->getFalseExpr(), Pred, Dst);
1184 case Stmt::CXXThisExprClass:
1185 Bldr.takeNodes(Pred);
1186 VisitCXXThisExpr(cast<CXXThisExpr>(S), Pred, Dst);
1190 case Stmt::DeclRefExprClass: {
1191 Bldr.takeNodes(Pred);
1192 const DeclRefExpr *DE = cast<DeclRefExpr>(S);
1193 VisitCommonDeclRefExpr(DE, DE->getDecl(), Pred, Dst);
1198 case Stmt::DeclStmtClass:
1199 Bldr.takeNodes(Pred);
1200 VisitDeclStmt(cast<DeclStmt>(S), Pred, Dst);
1204 case Stmt::ImplicitCastExprClass:
1205 case Stmt::CStyleCastExprClass:
1206 case Stmt::CXXStaticCastExprClass:
1207 case Stmt::CXXDynamicCastExprClass:
1208 case Stmt::CXXReinterpretCastExprClass:
1209 case Stmt::CXXConstCastExprClass:
1210 case Stmt::CXXFunctionalCastExprClass:
1211 case Stmt::ObjCBridgedCastExprClass: {
1212 Bldr.takeNodes(Pred);
1213 const CastExpr *C = cast<CastExpr>(S);
1214 // Handle the previsit checks.
1215 ExplodedNodeSet dstPrevisit;
1216 getCheckerManager().runCheckersForPreStmt(dstPrevisit, Pred, C, *this);
1218 // Handle the expression itself.
1219 ExplodedNodeSet dstExpr;
1220 for (ExplodedNodeSet::iterator i = dstPrevisit.begin(),
1221 e = dstPrevisit.end(); i != e ; ++i) {
1222 VisitCast(C, C->getSubExpr(), *i, dstExpr);
1225 // Handle the postvisit checks.
1226 getCheckerManager().runCheckersForPostStmt(Dst, dstExpr, C, *this);
1231 case Expr::MaterializeTemporaryExprClass: {
1232 Bldr.takeNodes(Pred);
1233 const MaterializeTemporaryExpr *MTE = cast<MaterializeTemporaryExpr>(S);
1234 CreateCXXTemporaryObject(MTE, Pred, Dst);
1239 case Stmt::InitListExprClass:
1240 Bldr.takeNodes(Pred);
1241 VisitInitListExpr(cast<InitListExpr>(S), Pred, Dst);
1245 case Stmt::MemberExprClass:
1246 Bldr.takeNodes(Pred);
1247 VisitMemberExpr(cast<MemberExpr>(S), Pred, Dst);
1251 case Stmt::AtomicExprClass:
1252 Bldr.takeNodes(Pred);
1253 VisitAtomicExpr(cast<AtomicExpr>(S), Pred, Dst);
1257 case Stmt::ObjCIvarRefExprClass:
1258 Bldr.takeNodes(Pred);
1259 VisitLvalObjCIvarRefExpr(cast<ObjCIvarRefExpr>(S), Pred, Dst);
1263 case Stmt::ObjCForCollectionStmtClass:
1264 Bldr.takeNodes(Pred);
1265 VisitObjCForCollectionStmt(cast<ObjCForCollectionStmt>(S), Pred, Dst);
1269 case Stmt::ObjCMessageExprClass:
1270 Bldr.takeNodes(Pred);
1271 VisitObjCMessage(cast<ObjCMessageExpr>(S), Pred, Dst);
1275 case Stmt::ObjCAtThrowStmtClass:
1276 case Stmt::CXXThrowExprClass:
1277 // FIXME: This is not complete. We basically treat @throw as
1279 Bldr.generateSink(S, Pred, Pred->getState());
1282 case Stmt::ReturnStmtClass:
1283 Bldr.takeNodes(Pred);
1284 VisitReturnStmt(cast<ReturnStmt>(S), Pred, Dst);
1288 case Stmt::OffsetOfExprClass:
1289 Bldr.takeNodes(Pred);
1290 VisitOffsetOfExpr(cast<OffsetOfExpr>(S), Pred, Dst);
1294 case Stmt::UnaryExprOrTypeTraitExprClass:
1295 Bldr.takeNodes(Pred);
1296 VisitUnaryExprOrTypeTraitExpr(cast<UnaryExprOrTypeTraitExpr>(S),
1301 case Stmt::StmtExprClass: {
1302 const StmtExpr *SE = cast<StmtExpr>(S);
1304 if (SE->getSubStmt()->body_empty()) {
1305 // Empty statement expression.
1306 assert(SE->getType() == getContext().VoidTy
1307 && "Empty statement expression must have void type.");
1311 if (Expr *LastExpr = dyn_cast<Expr>(*SE->getSubStmt()->body_rbegin())) {
1312 ProgramStateRef state = Pred->getState();
1313 Bldr.generateNode(SE, Pred,
1314 state->BindExpr(SE, Pred->getLocationContext(),
1315 state->getSVal(LastExpr,
1316 Pred->getLocationContext())));
1321 case Stmt::UnaryOperatorClass: {
1322 Bldr.takeNodes(Pred);
1323 const UnaryOperator *U = cast<UnaryOperator>(S);
1324 if (AMgr.options.eagerlyAssumeBinOpBifurcation && (U->getOpcode() == UO_LNot)) {
1325 ExplodedNodeSet Tmp;
1326 VisitUnaryOperator(U, Pred, Tmp);
1327 evalEagerlyAssumeBinOpBifurcation(Dst, Tmp, U);
1330 VisitUnaryOperator(U, Pred, Dst);
1335 case Stmt::PseudoObjectExprClass: {
1336 Bldr.takeNodes(Pred);
1337 ProgramStateRef state = Pred->getState();
1338 const PseudoObjectExpr *PE = cast<PseudoObjectExpr>(S);
1339 if (const Expr *Result = PE->getResultExpr()) {
1340 SVal V = state->getSVal(Result, Pred->getLocationContext());
1341 Bldr.generateNode(S, Pred,
1342 state->BindExpr(S, Pred->getLocationContext(), V));
1345 Bldr.generateNode(S, Pred,
1346 state->BindExpr(S, Pred->getLocationContext(),
1355 bool ExprEngine::replayWithoutInlining(ExplodedNode *N,
1356 const LocationContext *CalleeLC) {
1357 const StackFrameContext *CalleeSF = CalleeLC->getCurrentStackFrame();
1358 const StackFrameContext *CallerSF = CalleeSF->getParent()->getCurrentStackFrame();
1359 assert(CalleeSF && CallerSF);
1360 ExplodedNode *BeforeProcessingCall = nullptr;
1361 const Stmt *CE = CalleeSF->getCallSite();
1363 // Find the first node before we started processing the call expression.
1365 ProgramPoint L = N->getLocation();
1366 BeforeProcessingCall = N;
1367 N = N->pred_empty() ? nullptr : *(N->pred_begin());
1369 // Skip the nodes corresponding to the inlined code.
1370 if (L.getLocationContext()->getCurrentStackFrame() != CallerSF)
1372 // We reached the caller. Find the node right before we started
1373 // processing the call.
1374 if (L.isPurgeKind())
1376 if (L.getAs<PreImplicitCall>())
1378 if (L.getAs<CallEnter>())
1380 if (Optional<StmtPoint> SP = L.getAs<StmtPoint>())
1381 if (SP->getStmt() == CE)
1386 if (!BeforeProcessingCall)
1389 // TODO: Clean up the unneeded nodes.
1391 // Build an Epsilon node from which we will restart the analyzes.
1392 // Note that CE is permitted to be NULL!
1393 ProgramPoint NewNodeLoc =
1394 EpsilonPoint(BeforeProcessingCall->getLocationContext(), CE);
1395 // Add the special flag to GDM to signal retrying with no inlining.
1396 // Note, changing the state ensures that we are not going to cache out.
1397 ProgramStateRef NewNodeState = BeforeProcessingCall->getState();
1399 NewNodeState->set<ReplayWithoutInlining>(const_cast<Stmt *>(CE));
1401 // Make the new node a successor of BeforeProcessingCall.
1403 ExplodedNode *NewNode = G.getNode(NewNodeLoc, NewNodeState, false, &IsNew);
1404 // We cached out at this point. Caching out is common due to us backtracking
1405 // from the inlined function, which might spawn several paths.
1409 NewNode->addPredecessor(BeforeProcessingCall, G);
1411 // Add the new node to the work list.
1412 Engine.enqueueStmtNode(NewNode, CalleeSF->getCallSiteBlock(),
1413 CalleeSF->getIndex());
1414 NumTimesRetriedWithoutInlining++;
1418 /// Block entrance. (Update counters).
1419 void ExprEngine::processCFGBlockEntrance(const BlockEdge &L,
1420 NodeBuilderWithSinks &nodeBuilder,
1421 ExplodedNode *Pred) {
1422 PrettyStackTraceLocationContext CrashInfo(Pred->getLocationContext());
1424 // If this block is terminated by a loop and it has already been visited the
1425 // maximum number of times, widen the loop.
1426 unsigned int BlockCount = nodeBuilder.getContext().blockCount();
1427 if (BlockCount == AMgr.options.maxBlockVisitOnPath - 1 &&
1428 AMgr.options.shouldWidenLoops()) {
1429 const Stmt *Term = nodeBuilder.getContext().getBlock()->getTerminator();
1431 (isa<ForStmt>(Term) || isa<WhileStmt>(Term) || isa<DoStmt>(Term))))
1434 const LocationContext *LCtx = Pred->getLocationContext();
1435 ProgramStateRef WidenedState =
1436 getWidenedLoopState(Pred->getState(), LCtx, BlockCount, Term);
1437 nodeBuilder.generateNode(WidenedState, Pred);
1441 // FIXME: Refactor this into a checker.
1442 if (BlockCount >= AMgr.options.maxBlockVisitOnPath) {
1443 static SimpleProgramPointTag tag(TagProviderName, "Block count exceeded");
1444 const ExplodedNode *Sink =
1445 nodeBuilder.generateSink(Pred->getState(), Pred, &tag);
1447 // Check if we stopped at the top level function or not.
1448 // Root node should have the location context of the top most function.
1449 const LocationContext *CalleeLC = Pred->getLocation().getLocationContext();
1450 const LocationContext *CalleeSF = CalleeLC->getCurrentStackFrame();
1451 const LocationContext *RootLC =
1452 (*G.roots_begin())->getLocation().getLocationContext();
1453 if (RootLC->getCurrentStackFrame() != CalleeSF) {
1454 Engine.FunctionSummaries->markReachedMaxBlockCount(CalleeSF->getDecl());
1456 // Re-run the call evaluation without inlining it, by storing the
1457 // no-inlining policy in the state and enqueuing the new work item on
1458 // the list. Replay should almost never fail. Use the stats to catch it
1460 if ((!AMgr.options.NoRetryExhausted &&
1461 replayWithoutInlining(Pred, CalleeLC)))
1463 NumMaxBlockCountReachedInInlined++;
1465 NumMaxBlockCountReached++;
1467 // Make sink nodes as exhausted(for stats) only if retry failed.
1468 Engine.blocksExhausted.push_back(std::make_pair(L, Sink));
1472 //===----------------------------------------------------------------------===//
1473 // Branch processing.
1474 //===----------------------------------------------------------------------===//
1476 /// RecoverCastedSymbol - A helper function for ProcessBranch that is used
1477 /// to try to recover some path-sensitivity for casts of symbolic
1478 /// integers that promote their values (which are currently not tracked well).
1479 /// This function returns the SVal bound to Condition->IgnoreCasts if all the
1480 // cast(s) did was sign-extend the original value.
1481 static SVal RecoverCastedSymbol(ProgramStateManager& StateMgr,
1482 ProgramStateRef state,
1483 const Stmt *Condition,
1484 const LocationContext *LCtx,
1487 const Expr *Ex = dyn_cast<Expr>(Condition);
1489 return UnknownVal();
1492 bool bitsInit = false;
1494 while (const CastExpr *CE = dyn_cast<CastExpr>(Ex)) {
1495 QualType T = CE->getType();
1497 if (!T->isIntegralOrEnumerationType())
1498 return UnknownVal();
1500 uint64_t newBits = Ctx.getTypeSize(T);
1501 if (!bitsInit || newBits < bits) {
1506 Ex = CE->getSubExpr();
1509 // We reached a non-cast. Is it a symbolic value?
1510 QualType T = Ex->getType();
1512 if (!bitsInit || !T->isIntegralOrEnumerationType() ||
1513 Ctx.getTypeSize(T) > bits)
1514 return UnknownVal();
1516 return state->getSVal(Ex, LCtx);
1520 static const Stmt *getRightmostLeaf(const Stmt *Condition) {
1522 const BinaryOperator *BO = dyn_cast<BinaryOperator>(Condition);
1523 if (!BO || !BO->isLogicalOp()) {
1526 Condition = BO->getRHS()->IgnoreParens();
1532 // Returns the condition the branch at the end of 'B' depends on and whose value
1533 // has been evaluated within 'B'.
1534 // In most cases, the terminator condition of 'B' will be evaluated fully in
1535 // the last statement of 'B'; in those cases, the resolved condition is the
1536 // given 'Condition'.
1537 // If the condition of the branch is a logical binary operator tree, the CFG is
1538 // optimized: in that case, we know that the expression formed by all but the
1539 // rightmost leaf of the logical binary operator tree must be true, and thus
1540 // the branch condition is at this point equivalent to the truth value of that
1541 // rightmost leaf; the CFG block thus only evaluates this rightmost leaf
1542 // expression in its final statement. As the full condition in that case was
1543 // not evaluated, and is thus not in the SVal cache, we need to use that leaf
1544 // expression to evaluate the truth value of the condition in the current state
1546 static const Stmt *ResolveCondition(const Stmt *Condition,
1547 const CFGBlock *B) {
1548 if (const Expr *Ex = dyn_cast<Expr>(Condition))
1549 Condition = Ex->IgnoreParens();
1551 const BinaryOperator *BO = dyn_cast<BinaryOperator>(Condition);
1552 if (!BO || !BO->isLogicalOp())
1555 assert(!B->getTerminator().isTemporaryDtorsBranch() &&
1556 "Temporary destructor branches handled by processBindTemporary.");
1558 // For logical operations, we still have the case where some branches
1559 // use the traditional "merge" approach and others sink the branch
1560 // directly into the basic blocks representing the logical operation.
1561 // We need to distinguish between those two cases here.
1563 // The invariants are still shifting, but it is possible that the
1564 // last element in a CFGBlock is not a CFGStmt. Look for the last
1565 // CFGStmt as the value of the condition.
1566 CFGBlock::const_reverse_iterator I = B->rbegin(), E = B->rend();
1567 for (; I != E; ++I) {
1568 CFGElement Elem = *I;
1569 Optional<CFGStmt> CS = Elem.getAs<CFGStmt>();
1572 const Stmt *LastStmt = CS->getStmt();
1573 assert(LastStmt == Condition || LastStmt == getRightmostLeaf(Condition));
1576 llvm_unreachable("could not resolve condition");
1579 void ExprEngine::processBranch(const Stmt *Condition, const Stmt *Term,
1580 NodeBuilderContext& BldCtx,
1582 ExplodedNodeSet &Dst,
1583 const CFGBlock *DstT,
1584 const CFGBlock *DstF) {
1585 assert((!Condition || !isa<CXXBindTemporaryExpr>(Condition)) &&
1586 "CXXBindTemporaryExprs are handled by processBindTemporary.");
1587 const LocationContext *LCtx = Pred->getLocationContext();
1588 PrettyStackTraceLocationContext StackCrashInfo(LCtx);
1589 currBldrCtx = &BldCtx;
1591 // Check for NULL conditions; e.g. "for(;;)"
1593 BranchNodeBuilder NullCondBldr(Pred, Dst, BldCtx, DstT, DstF);
1594 NullCondBldr.markInfeasible(false);
1595 NullCondBldr.generateNode(Pred->getState(), true, Pred);
1599 if (const Expr *Ex = dyn_cast<Expr>(Condition))
1600 Condition = Ex->IgnoreParens();
1602 Condition = ResolveCondition(Condition, BldCtx.getBlock());
1603 PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
1604 Condition->getLocStart(),
1605 "Error evaluating branch");
1607 ExplodedNodeSet CheckersOutSet;
1608 getCheckerManager().runCheckersForBranchCondition(Condition, CheckersOutSet,
1610 // We generated only sinks.
1611 if (CheckersOutSet.empty())
1614 BranchNodeBuilder builder(CheckersOutSet, Dst, BldCtx, DstT, DstF);
1615 for (NodeBuilder::iterator I = CheckersOutSet.begin(),
1616 E = CheckersOutSet.end(); E != I; ++I) {
1617 ExplodedNode *PredI = *I;
1619 if (PredI->isSink())
1622 ProgramStateRef PrevState = PredI->getState();
1623 SVal X = PrevState->getSVal(Condition, PredI->getLocationContext());
1625 if (X.isUnknownOrUndef()) {
1626 // Give it a chance to recover from unknown.
1627 if (const Expr *Ex = dyn_cast<Expr>(Condition)) {
1628 if (Ex->getType()->isIntegralOrEnumerationType()) {
1629 // Try to recover some path-sensitivity. Right now casts of symbolic
1630 // integers that promote their values are currently not tracked well.
1631 // If 'Condition' is such an expression, try and recover the
1632 // underlying value and use that instead.
1633 SVal recovered = RecoverCastedSymbol(getStateManager(),
1634 PrevState, Condition,
1635 PredI->getLocationContext(),
1638 if (!recovered.isUnknown()) {
1645 // If the condition is still unknown, give up.
1646 if (X.isUnknownOrUndef()) {
1647 builder.generateNode(PrevState, true, PredI);
1648 builder.generateNode(PrevState, false, PredI);
1652 DefinedSVal V = X.castAs<DefinedSVal>();
1654 ProgramStateRef StTrue, StFalse;
1655 std::tie(StTrue, StFalse) = PrevState->assume(V);
1657 // Process the true branch.
1658 if (builder.isFeasible(true)) {
1660 builder.generateNode(StTrue, true, PredI);
1662 builder.markInfeasible(true);
1665 // Process the false branch.
1666 if (builder.isFeasible(false)) {
1668 builder.generateNode(StFalse, false, PredI);
1670 builder.markInfeasible(false);
1673 currBldrCtx = nullptr;
1676 /// The GDM component containing the set of global variables which have been
1677 /// previously initialized with explicit initializers.
1678 REGISTER_TRAIT_WITH_PROGRAMSTATE(InitializedGlobalsSet,
1679 llvm::ImmutableSet<const VarDecl *>)
1681 void ExprEngine::processStaticInitializer(const DeclStmt *DS,
1682 NodeBuilderContext &BuilderCtx,
1684 clang::ento::ExplodedNodeSet &Dst,
1685 const CFGBlock *DstT,
1686 const CFGBlock *DstF) {
1687 PrettyStackTraceLocationContext CrashInfo(Pred->getLocationContext());
1688 currBldrCtx = &BuilderCtx;
1690 const VarDecl *VD = cast<VarDecl>(DS->getSingleDecl());
1691 ProgramStateRef state = Pred->getState();
1692 bool initHasRun = state->contains<InitializedGlobalsSet>(VD);
1693 BranchNodeBuilder builder(Pred, Dst, BuilderCtx, DstT, DstF);
1696 state = state->add<InitializedGlobalsSet>(VD);
1699 builder.generateNode(state, initHasRun, Pred);
1700 builder.markInfeasible(!initHasRun);
1702 currBldrCtx = nullptr;
1705 /// processIndirectGoto - Called by CoreEngine. Used to generate successor
1706 /// nodes by processing the 'effects' of a computed goto jump.
1707 void ExprEngine::processIndirectGoto(IndirectGotoNodeBuilder &builder) {
1709 ProgramStateRef state = builder.getState();
1710 SVal V = state->getSVal(builder.getTarget(), builder.getLocationContext());
1712 // Three possibilities:
1714 // (1) We know the computed label.
1715 // (2) The label is NULL (or some other constant), or Undefined.
1716 // (3) We have no clue about the label. Dispatch to all targets.
1719 typedef IndirectGotoNodeBuilder::iterator iterator;
1721 if (Optional<loc::GotoLabel> LV = V.getAs<loc::GotoLabel>()) {
1722 const LabelDecl *L = LV->getLabel();
1724 for (iterator I = builder.begin(), E = builder.end(); I != E; ++I) {
1725 if (I.getLabel() == L) {
1726 builder.generateNode(I, state);
1731 llvm_unreachable("No block with label.");
1734 if (V.getAs<loc::ConcreteInt>() || V.getAs<UndefinedVal>()) {
1735 // Dispatch to the first target and mark it as a sink.
1736 //ExplodedNode* N = builder.generateNode(builder.begin(), state, true);
1737 // FIXME: add checker visit.
1738 // UndefBranches.insert(N);
1742 // This is really a catch-all. We don't support symbolics yet.
1743 // FIXME: Implement dispatch for symbolic pointers.
1745 for (iterator I=builder.begin(), E=builder.end(); I != E; ++I)
1746 builder.generateNode(I, state);
1750 static bool stackFrameDoesNotContainInitializedTemporaries(ExplodedNode &Pred) {
1751 const StackFrameContext* Frame = Pred.getStackFrame();
1752 const llvm::ImmutableSet<CXXBindTemporaryContext> &Set =
1753 Pred.getState()->get<InitializedTemporariesSet>();
1754 return std::find_if(Set.begin(), Set.end(),
1755 [&](const CXXBindTemporaryContext &Ctx) {
1756 if (Ctx.second == Frame) {
1758 llvm::errs() << "\n";
1760 return Ctx.second == Frame;
1765 void ExprEngine::processBeginOfFunction(NodeBuilderContext &BC,
1767 ExplodedNodeSet &Dst,
1768 const BlockEdge &L) {
1769 SaveAndRestore<const NodeBuilderContext *> NodeContextRAII(currBldrCtx, &BC);
1770 getCheckerManager().runCheckersForBeginFunction(Dst, L, Pred, *this);
1773 /// ProcessEndPath - Called by CoreEngine. Used to generate end-of-path
1774 /// nodes when the control reaches the end of a function.
1775 void ExprEngine::processEndOfFunction(NodeBuilderContext& BC,
1776 ExplodedNode *Pred) {
1777 // FIXME: Assert that stackFrameDoesNotContainInitializedTemporaries(*Pred)).
1778 // We currently cannot enable this assert, as lifetime extended temporaries
1779 // are not modelled correctly.
1780 PrettyStackTraceLocationContext CrashInfo(Pred->getLocationContext());
1781 StateMgr.EndPath(Pred->getState());
1783 ExplodedNodeSet Dst;
1784 if (Pred->getLocationContext()->inTopFrame()) {
1785 // Remove dead symbols.
1786 ExplodedNodeSet AfterRemovedDead;
1787 removeDeadOnEndOfFunction(BC, Pred, AfterRemovedDead);
1790 for (ExplodedNodeSet::iterator I = AfterRemovedDead.begin(),
1791 E = AfterRemovedDead.end(); I != E; ++I) {
1792 getCheckerManager().runCheckersForEndFunction(BC, Dst, *I, *this);
1795 getCheckerManager().runCheckersForEndFunction(BC, Dst, Pred, *this);
1798 Engine.enqueueEndOfFunction(Dst);
1801 /// ProcessSwitch - Called by CoreEngine. Used to generate successor
1802 /// nodes by processing the 'effects' of a switch statement.
1803 void ExprEngine::processSwitch(SwitchNodeBuilder& builder) {
1804 typedef SwitchNodeBuilder::iterator iterator;
1805 ProgramStateRef state = builder.getState();
1806 const Expr *CondE = builder.getCondition();
1807 SVal CondV_untested = state->getSVal(CondE, builder.getLocationContext());
1809 if (CondV_untested.isUndef()) {
1810 //ExplodedNode* N = builder.generateDefaultCaseNode(state, true);
1811 // FIXME: add checker
1812 //UndefBranches.insert(N);
1816 DefinedOrUnknownSVal CondV = CondV_untested.castAs<DefinedOrUnknownSVal>();
1818 ProgramStateRef DefaultSt = state;
1820 iterator I = builder.begin(), EI = builder.end();
1821 bool defaultIsFeasible = I == EI;
1823 for ( ; I != EI; ++I) {
1824 // Successor may be pruned out during CFG construction.
1828 const CaseStmt *Case = I.getCase();
1830 // Evaluate the LHS of the case value.
1831 llvm::APSInt V1 = Case->getLHS()->EvaluateKnownConstInt(getContext());
1832 assert(V1.getBitWidth() == getContext().getTypeSize(CondE->getType()));
1834 // Get the RHS of the case, if it exists.
1836 if (const Expr *E = Case->getRHS())
1837 V2 = E->EvaluateKnownConstInt(getContext());
1841 ProgramStateRef StateCase;
1842 if (Optional<NonLoc> NL = CondV.getAs<NonLoc>())
1843 std::tie(StateCase, DefaultSt) =
1844 DefaultSt->assumeWithinInclusiveRange(*NL, V1, V2);
1846 StateCase = DefaultSt;
1849 builder.generateCaseStmtNode(I, StateCase);
1851 // Now "assume" that the case doesn't match. Add this state
1852 // to the default state (if it is feasible).
1854 defaultIsFeasible = true;
1856 defaultIsFeasible = false;
1861 if (!defaultIsFeasible)
1864 // If we have switch(enum value), the default branch is not
1865 // feasible if all of the enum constants not covered by 'case:' statements
1866 // are not feasible values for the switch condition.
1868 // Note that this isn't as accurate as it could be. Even if there isn't
1869 // a case for a particular enum value as long as that enum value isn't
1870 // feasible then it shouldn't be considered for making 'default:' reachable.
1871 const SwitchStmt *SS = builder.getSwitch();
1872 const Expr *CondExpr = SS->getCond()->IgnoreParenImpCasts();
1873 if (CondExpr->getType()->getAs<EnumType>()) {
1874 if (SS->isAllEnumCasesCovered())
1878 builder.generateDefaultCaseNode(DefaultSt);
1881 //===----------------------------------------------------------------------===//
1882 // Transfer functions: Loads and stores.
1883 //===----------------------------------------------------------------------===//
1885 void ExprEngine::VisitCommonDeclRefExpr(const Expr *Ex, const NamedDecl *D,
1887 ExplodedNodeSet &Dst) {
1888 StmtNodeBuilder Bldr(Pred, Dst, *currBldrCtx);
1890 ProgramStateRef state = Pred->getState();
1891 const LocationContext *LCtx = Pred->getLocationContext();
1893 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1894 // C permits "extern void v", and if you cast the address to a valid type,
1895 // you can even do things with it. We simply pretend
1896 assert(Ex->isGLValue() || VD->getType()->isVoidType());
1897 const LocationContext *LocCtxt = Pred->getLocationContext();
1898 const Decl *D = LocCtxt->getDecl();
1899 const auto *MD = D ? dyn_cast<CXXMethodDecl>(D) : nullptr;
1900 const auto *DeclRefEx = dyn_cast<DeclRefExpr>(Ex);
1903 if (AMgr.options.shouldInlineLambdas() && DeclRefEx &&
1904 DeclRefEx->refersToEnclosingVariableOrCapture() && MD &&
1905 MD->getParent()->isLambda()) {
1906 // Lookup the field of the lambda.
1907 const CXXRecordDecl *CXXRec = MD->getParent();
1908 llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;
1909 FieldDecl *LambdaThisCaptureField;
1910 CXXRec->getCaptureFields(LambdaCaptureFields, LambdaThisCaptureField);
1911 const FieldDecl *FD = LambdaCaptureFields[VD];
1913 // When a constant is captured, sometimes no corresponding field is
1914 // created in the lambda object.
1915 assert(VD->getType().isConstQualified());
1916 V = state->getLValue(VD, LocCtxt);
1917 IsReference = false;
1920 svalBuilder.getCXXThis(MD, LocCtxt->getCurrentStackFrame());
1921 SVal CXXThisVal = state->getSVal(CXXThis);
1922 V = state->getLValue(FD, CXXThisVal);
1923 IsReference = FD->getType()->isReferenceType();
1926 V = state->getLValue(VD, LocCtxt);
1927 IsReference = VD->getType()->isReferenceType();
1930 // For references, the 'lvalue' is the pointer address stored in the
1931 // reference region.
1933 if (const MemRegion *R = V.getAsRegion())
1934 V = state->getSVal(R);
1939 Bldr.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V), nullptr,
1940 ProgramPoint::PostLValueKind);
1943 if (const EnumConstantDecl *ED = dyn_cast<EnumConstantDecl>(D)) {
1944 assert(!Ex->isGLValue());
1945 SVal V = svalBuilder.makeIntVal(ED->getInitVal());
1946 Bldr.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V));
1949 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1950 SVal V = svalBuilder.getFunctionPointer(FD);
1951 Bldr.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V), nullptr,
1952 ProgramPoint::PostLValueKind);
1955 if (isa<FieldDecl>(D)) {
1956 // FIXME: Compute lvalue of field pointers-to-member.
1957 // Right now we just use a non-null void pointer, so that it gives proper
1958 // results in boolean contexts.
1959 SVal V = svalBuilder.conjureSymbolVal(Ex, LCtx, getContext().VoidPtrTy,
1960 currBldrCtx->blockCount());
1961 state = state->assume(V.castAs<DefinedOrUnknownSVal>(), true);
1962 Bldr.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V), nullptr,
1963 ProgramPoint::PostLValueKind);
1967 llvm_unreachable("Support for this Decl not implemented.");
1970 /// VisitArraySubscriptExpr - Transfer function for array accesses
1971 void ExprEngine::VisitLvalArraySubscriptExpr(const ArraySubscriptExpr *A,
1973 ExplodedNodeSet &Dst){
1975 const Expr *Base = A->getBase()->IgnoreParens();
1976 const Expr *Idx = A->getIdx()->IgnoreParens();
1978 ExplodedNodeSet checkerPreStmt;
1979 getCheckerManager().runCheckersForPreStmt(checkerPreStmt, Pred, A, *this);
1981 StmtNodeBuilder Bldr(checkerPreStmt, Dst, *currBldrCtx);
1982 assert(A->isGLValue() ||
1983 (!AMgr.getLangOpts().CPlusPlus &&
1984 A->getType().isCForbiddenLValueType()));
1986 for (ExplodedNodeSet::iterator it = checkerPreStmt.begin(),
1987 ei = checkerPreStmt.end(); it != ei; ++it) {
1988 const LocationContext *LCtx = (*it)->getLocationContext();
1989 ProgramStateRef state = (*it)->getState();
1990 SVal V = state->getLValue(A->getType(),
1991 state->getSVal(Idx, LCtx),
1992 state->getSVal(Base, LCtx));
1993 Bldr.generateNode(A, *it, state->BindExpr(A, LCtx, V), nullptr,
1994 ProgramPoint::PostLValueKind);
1998 /// VisitMemberExpr - Transfer function for member expressions.
1999 void ExprEngine::VisitMemberExpr(const MemberExpr *M, ExplodedNode *Pred,
2000 ExplodedNodeSet &Dst) {
2002 // FIXME: Prechecks eventually go in ::Visit().
2003 ExplodedNodeSet CheckedSet;
2004 getCheckerManager().runCheckersForPreStmt(CheckedSet, Pred, M, *this);
2006 ExplodedNodeSet EvalSet;
2007 ValueDecl *Member = M->getMemberDecl();
2009 // Handle static member variables and enum constants accessed via
2011 if (isa<VarDecl>(Member) || isa<EnumConstantDecl>(Member)) {
2012 ExplodedNodeSet Dst;
2013 for (ExplodedNodeSet::iterator I = CheckedSet.begin(), E = CheckedSet.end();
2015 VisitCommonDeclRefExpr(M, Member, Pred, EvalSet);
2018 StmtNodeBuilder Bldr(CheckedSet, EvalSet, *currBldrCtx);
2019 ExplodedNodeSet Tmp;
2021 for (ExplodedNodeSet::iterator I = CheckedSet.begin(), E = CheckedSet.end();
2023 ProgramStateRef state = (*I)->getState();
2024 const LocationContext *LCtx = (*I)->getLocationContext();
2025 Expr *BaseExpr = M->getBase();
2027 // Handle C++ method calls.
2028 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Member)) {
2029 if (MD->isInstance())
2030 state = createTemporaryRegionIfNeeded(state, LCtx, BaseExpr);
2032 SVal MDVal = svalBuilder.getFunctionPointer(MD);
2033 state = state->BindExpr(M, LCtx, MDVal);
2035 Bldr.generateNode(M, *I, state);
2039 // Handle regular struct fields / member variables.
2040 state = createTemporaryRegionIfNeeded(state, LCtx, BaseExpr);
2041 SVal baseExprVal = state->getSVal(BaseExpr, LCtx);
2043 FieldDecl *field = cast<FieldDecl>(Member);
2044 SVal L = state->getLValue(field, baseExprVal);
2046 if (M->isGLValue() || M->getType()->isArrayType()) {
2047 // We special-case rvalues of array type because the analyzer cannot
2048 // reason about them, since we expect all regions to be wrapped in Locs.
2049 // We instead treat these as lvalues and assume that they will decay to
2050 // pointers as soon as they are used.
2051 if (!M->isGLValue()) {
2052 assert(M->getType()->isArrayType());
2053 const ImplicitCastExpr *PE =
2054 dyn_cast<ImplicitCastExpr>((*I)->getParentMap().getParent(M));
2055 if (!PE || PE->getCastKind() != CK_ArrayToPointerDecay) {
2056 llvm_unreachable("should always be wrapped in ArrayToPointerDecay");
2060 if (field->getType()->isReferenceType()) {
2061 if (const MemRegion *R = L.getAsRegion())
2062 L = state->getSVal(R);
2067 Bldr.generateNode(M, *I, state->BindExpr(M, LCtx, L), nullptr,
2068 ProgramPoint::PostLValueKind);
2071 evalLoad(Tmp, M, M, *I, state, L);
2077 getCheckerManager().runCheckersForPostStmt(Dst, EvalSet, M, *this);
2080 void ExprEngine::VisitAtomicExpr(const AtomicExpr *AE, ExplodedNode *Pred,
2081 ExplodedNodeSet &Dst) {
2082 ExplodedNodeSet AfterPreSet;
2083 getCheckerManager().runCheckersForPreStmt(AfterPreSet, Pred, AE, *this);
2085 // For now, treat all the arguments to C11 atomics as escaping.
2086 // FIXME: Ideally we should model the behavior of the atomics precisely here.
2088 ExplodedNodeSet AfterInvalidateSet;
2089 StmtNodeBuilder Bldr(AfterPreSet, AfterInvalidateSet, *currBldrCtx);
2091 for (ExplodedNodeSet::iterator I = AfterPreSet.begin(), E = AfterPreSet.end();
2093 ProgramStateRef State = (*I)->getState();
2094 const LocationContext *LCtx = (*I)->getLocationContext();
2096 SmallVector<SVal, 8> ValuesToInvalidate;
2097 for (unsigned SI = 0, Count = AE->getNumSubExprs(); SI != Count; SI++) {
2098 const Expr *SubExpr = AE->getSubExprs()[SI];
2099 SVal SubExprVal = State->getSVal(SubExpr, LCtx);
2100 ValuesToInvalidate.push_back(SubExprVal);
2103 State = State->invalidateRegions(ValuesToInvalidate, AE,
2104 currBldrCtx->blockCount(),
2106 /*CausedByPointerEscape*/true,
2107 /*Symbols=*/nullptr);
2109 SVal ResultVal = UnknownVal();
2110 State = State->BindExpr(AE, LCtx, ResultVal);
2111 Bldr.generateNode(AE, *I, State, nullptr,
2112 ProgramPoint::PostStmtKind);
2115 getCheckerManager().runCheckersForPostStmt(Dst, AfterInvalidateSet, AE, *this);
2119 class CollectReachableSymbolsCallback final : public SymbolVisitor {
2120 InvalidatedSymbols Symbols;
2123 CollectReachableSymbolsCallback(ProgramStateRef State) {}
2124 const InvalidatedSymbols &getSymbols() const { return Symbols; }
2126 bool VisitSymbol(SymbolRef Sym) override {
2127 Symbols.insert(Sym);
2131 } // end anonymous namespace
2133 // A value escapes in three possible cases:
2134 // (1) We are binding to something that is not a memory region.
2135 // (2) We are binding to a MemrRegion that does not have stack storage.
2136 // (3) We are binding to a MemRegion with stack storage that the store
2137 // does not understand.
2138 ProgramStateRef ExprEngine::processPointerEscapedOnBind(ProgramStateRef State,
2139 SVal Loc, SVal Val) {
2140 // Are we storing to something that causes the value to "escape"?
2141 bool escapes = true;
2143 // TODO: Move to StoreManager.
2144 if (Optional<loc::MemRegionVal> regionLoc = Loc.getAs<loc::MemRegionVal>()) {
2145 escapes = !regionLoc->getRegion()->hasStackStorage();
2148 // To test (3), generate a new state with the binding added. If it is
2149 // the same state, then it escapes (since the store cannot represent
2151 // Do this only if we know that the store is not supposed to generate the
2153 SVal StoredVal = State->getSVal(regionLoc->getRegion());
2154 if (StoredVal != Val)
2155 escapes = (State == (State->bindLoc(*regionLoc, Val)));
2159 // If our store can represent the binding and we aren't storing to something
2160 // that doesn't have local storage then just return and have the simulation
2161 // state continue as is.
2165 // Otherwise, find all symbols referenced by 'val' that we are tracking
2166 // and stop tracking them.
2167 CollectReachableSymbolsCallback Scanner =
2168 State->scanReachableSymbols<CollectReachableSymbolsCallback>(Val);
2169 const InvalidatedSymbols &EscapedSymbols = Scanner.getSymbols();
2170 State = getCheckerManager().runCheckersForPointerEscape(State,
2172 /*CallEvent*/ nullptr,
2180 ExprEngine::notifyCheckersOfPointerEscape(ProgramStateRef State,
2181 const InvalidatedSymbols *Invalidated,
2182 ArrayRef<const MemRegion *> ExplicitRegions,
2183 ArrayRef<const MemRegion *> Regions,
2184 const CallEvent *Call,
2185 RegionAndSymbolInvalidationTraits &ITraits) {
2187 if (!Invalidated || Invalidated->empty())
2191 return getCheckerManager().runCheckersForPointerEscape(State,
2197 // If the symbols were invalidated by a call, we want to find out which ones
2198 // were invalidated directly due to being arguments to the call.
2199 InvalidatedSymbols SymbolsDirectlyInvalidated;
2200 for (ArrayRef<const MemRegion *>::iterator I = ExplicitRegions.begin(),
2201 E = ExplicitRegions.end(); I != E; ++I) {
2202 if (const SymbolicRegion *R = (*I)->StripCasts()->getAs<SymbolicRegion>())
2203 SymbolsDirectlyInvalidated.insert(R->getSymbol());
2206 InvalidatedSymbols SymbolsIndirectlyInvalidated;
2207 for (InvalidatedSymbols::const_iterator I=Invalidated->begin(),
2208 E = Invalidated->end(); I!=E; ++I) {
2210 if (SymbolsDirectlyInvalidated.count(sym))
2212 SymbolsIndirectlyInvalidated.insert(sym);
2215 if (!SymbolsDirectlyInvalidated.empty())
2216 State = getCheckerManager().runCheckersForPointerEscape(State,
2217 SymbolsDirectlyInvalidated, Call, PSK_DirectEscapeOnCall, &ITraits);
2219 // Notify about the symbols that get indirectly invalidated by the call.
2220 if (!SymbolsIndirectlyInvalidated.empty())
2221 State = getCheckerManager().runCheckersForPointerEscape(State,
2222 SymbolsIndirectlyInvalidated, Call, PSK_IndirectEscapeOnCall, &ITraits);
2227 /// evalBind - Handle the semantics of binding a value to a specific location.
2228 /// This method is used by evalStore and (soon) VisitDeclStmt, and others.
2229 void ExprEngine::evalBind(ExplodedNodeSet &Dst, const Stmt *StoreE,
2231 SVal location, SVal Val,
2232 bool atDeclInit, const ProgramPoint *PP) {
2234 const LocationContext *LC = Pred->getLocationContext();
2235 PostStmt PS(StoreE, LC);
2239 // Do a previsit of the bind.
2240 ExplodedNodeSet CheckedSet;
2241 getCheckerManager().runCheckersForBind(CheckedSet, Pred, location, Val,
2242 StoreE, *this, *PP);
2244 StmtNodeBuilder Bldr(CheckedSet, Dst, *currBldrCtx);
2246 // If the location is not a 'Loc', it will already be handled by
2247 // the checkers. There is nothing left to do.
2248 if (!location.getAs<Loc>()) {
2249 const ProgramPoint L = PostStore(StoreE, LC, /*Loc*/nullptr,
2251 ProgramStateRef state = Pred->getState();
2252 state = processPointerEscapedOnBind(state, location, Val);
2253 Bldr.generateNode(L, state, Pred);
2257 for (ExplodedNodeSet::iterator I = CheckedSet.begin(), E = CheckedSet.end();
2259 ExplodedNode *PredI = *I;
2260 ProgramStateRef state = PredI->getState();
2262 state = processPointerEscapedOnBind(state, location, Val);
2264 // When binding the value, pass on the hint that this is a initialization.
2265 // For initializations, we do not need to inform clients of region
2267 state = state->bindLoc(location.castAs<Loc>(),
2268 Val, /* notifyChanges = */ !atDeclInit);
2270 const MemRegion *LocReg = nullptr;
2271 if (Optional<loc::MemRegionVal> LocRegVal =
2272 location.getAs<loc::MemRegionVal>()) {
2273 LocReg = LocRegVal->getRegion();
2276 const ProgramPoint L = PostStore(StoreE, LC, LocReg, nullptr);
2277 Bldr.generateNode(L, state, PredI);
2281 /// evalStore - Handle the semantics of a store via an assignment.
2282 /// @param Dst The node set to store generated state nodes
2283 /// @param AssignE The assignment expression if the store happens in an
2285 /// @param LocationE The location expression that is stored to.
2286 /// @param state The current simulation state
2287 /// @param location The location to store the value
2288 /// @param Val The value to be stored
2289 void ExprEngine::evalStore(ExplodedNodeSet &Dst, const Expr *AssignE,
2290 const Expr *LocationE,
2292 ProgramStateRef state, SVal location, SVal Val,
2293 const ProgramPointTag *tag) {
2294 // Proceed with the store. We use AssignE as the anchor for the PostStore
2295 // ProgramPoint if it is non-NULL, and LocationE otherwise.
2296 const Expr *StoreE = AssignE ? AssignE : LocationE;
2298 // Evaluate the location (checks for bad dereferences).
2299 ExplodedNodeSet Tmp;
2300 evalLocation(Tmp, AssignE, LocationE, Pred, state, location, tag, false);
2305 if (location.isUndef())
2308 for (ExplodedNodeSet::iterator NI=Tmp.begin(), NE=Tmp.end(); NI!=NE; ++NI)
2309 evalBind(Dst, StoreE, *NI, location, Val, false);
2312 void ExprEngine::evalLoad(ExplodedNodeSet &Dst,
2314 const Expr *BoundEx,
2316 ProgramStateRef state,
2318 const ProgramPointTag *tag,
2321 assert(!location.getAs<NonLoc>() && "location cannot be a NonLoc.");
2323 // Are we loading from a region? This actually results in two loads; one
2324 // to fetch the address of the referenced value and one to fetch the
2325 // referenced value.
2326 if (const TypedValueRegion *TR =
2327 dyn_cast_or_null<TypedValueRegion>(location.getAsRegion())) {
2329 QualType ValTy = TR->getValueType();
2330 if (const ReferenceType *RT = ValTy->getAs<ReferenceType>()) {
2331 static SimpleProgramPointTag
2332 loadReferenceTag(TagProviderName, "Load Reference");
2333 ExplodedNodeSet Tmp;
2334 evalLoadCommon(Tmp, NodeEx, BoundEx, Pred, state,
2335 location, &loadReferenceTag,
2336 getContext().getPointerType(RT->getPointeeType()));
2338 // Perform the load from the referenced value.
2339 for (ExplodedNodeSet::iterator I=Tmp.begin(), E=Tmp.end() ; I!=E; ++I) {
2340 state = (*I)->getState();
2341 location = state->getSVal(BoundEx, (*I)->getLocationContext());
2342 evalLoadCommon(Dst, NodeEx, BoundEx, *I, state, location, tag, LoadTy);
2348 evalLoadCommon(Dst, NodeEx, BoundEx, Pred, state, location, tag, LoadTy);
2351 void ExprEngine::evalLoadCommon(ExplodedNodeSet &Dst,
2353 const Expr *BoundEx,
2355 ProgramStateRef state,
2357 const ProgramPointTag *tag,
2361 // Evaluate the location (checks for bad dereferences).
2362 ExplodedNodeSet Tmp;
2363 evalLocation(Tmp, NodeEx, BoundEx, Pred, state, location, tag, true);
2367 StmtNodeBuilder Bldr(Tmp, Dst, *currBldrCtx);
2368 if (location.isUndef())
2371 // Proceed with the load.
2372 for (ExplodedNodeSet::iterator NI=Tmp.begin(), NE=Tmp.end(); NI!=NE; ++NI) {
2373 state = (*NI)->getState();
2374 const LocationContext *LCtx = (*NI)->getLocationContext();
2376 SVal V = UnknownVal();
2377 if (location.isValid()) {
2378 if (LoadTy.isNull())
2379 LoadTy = BoundEx->getType();
2380 V = state->getSVal(location.castAs<Loc>(), LoadTy);
2383 Bldr.generateNode(NodeEx, *NI, state->BindExpr(BoundEx, LCtx, V), tag,
2384 ProgramPoint::PostLoadKind);
2388 void ExprEngine::evalLocation(ExplodedNodeSet &Dst,
2390 const Stmt *BoundEx,
2392 ProgramStateRef state,
2394 const ProgramPointTag *tag,
2396 StmtNodeBuilder BldrTop(Pred, Dst, *currBldrCtx);
2397 // Early checks for performance reason.
2398 if (location.isUnknown()) {
2402 ExplodedNodeSet Src;
2403 BldrTop.takeNodes(Pred);
2404 StmtNodeBuilder Bldr(Pred, Src, *currBldrCtx);
2405 if (Pred->getState() != state) {
2406 // Associate this new state with an ExplodedNode.
2407 // FIXME: If I pass null tag, the graph is incorrect, e.g for
2411 // "p = 0" is not noted as "Null pointer value stored to 'p'" but
2412 // instead "int *p" is noted as
2413 // "Variable 'p' initialized to a null pointer value"
2415 static SimpleProgramPointTag tag(TagProviderName, "Location");
2416 Bldr.generateNode(NodeEx, Pred, state, &tag);
2418 ExplodedNodeSet Tmp;
2419 getCheckerManager().runCheckersForLocation(Tmp, Src, location, isLoad,
2420 NodeEx, BoundEx, *this);
2421 BldrTop.addNodes(Tmp);
2424 std::pair<const ProgramPointTag *, const ProgramPointTag*>
2425 ExprEngine::geteagerlyAssumeBinOpBifurcationTags() {
2426 static SimpleProgramPointTag
2427 eagerlyAssumeBinOpBifurcationTrue(TagProviderName,
2428 "Eagerly Assume True"),
2429 eagerlyAssumeBinOpBifurcationFalse(TagProviderName,
2430 "Eagerly Assume False");
2431 return std::make_pair(&eagerlyAssumeBinOpBifurcationTrue,
2432 &eagerlyAssumeBinOpBifurcationFalse);
2435 void ExprEngine::evalEagerlyAssumeBinOpBifurcation(ExplodedNodeSet &Dst,
2436 ExplodedNodeSet &Src,
2438 StmtNodeBuilder Bldr(Src, Dst, *currBldrCtx);
2440 for (ExplodedNodeSet::iterator I=Src.begin(), E=Src.end(); I!=E; ++I) {
2441 ExplodedNode *Pred = *I;
2442 // Test if the previous node was as the same expression. This can happen
2443 // when the expression fails to evaluate to anything meaningful and
2444 // (as an optimization) we don't generate a node.
2445 ProgramPoint P = Pred->getLocation();
2446 if (!P.getAs<PostStmt>() || P.castAs<PostStmt>().getStmt() != Ex) {
2450 ProgramStateRef state = Pred->getState();
2451 SVal V = state->getSVal(Ex, Pred->getLocationContext());
2452 Optional<nonloc::SymbolVal> SEV = V.getAs<nonloc::SymbolVal>();
2453 if (SEV && SEV->isExpression()) {
2454 const std::pair<const ProgramPointTag *, const ProgramPointTag*> &tags =
2455 geteagerlyAssumeBinOpBifurcationTags();
2457 ProgramStateRef StateTrue, StateFalse;
2458 std::tie(StateTrue, StateFalse) = state->assume(*SEV);
2460 // First assume that the condition is true.
2462 SVal Val = svalBuilder.makeIntVal(1U, Ex->getType());
2463 StateTrue = StateTrue->BindExpr(Ex, Pred->getLocationContext(), Val);
2464 Bldr.generateNode(Ex, Pred, StateTrue, tags.first);
2467 // Next, assume that the condition is false.
2469 SVal Val = svalBuilder.makeIntVal(0U, Ex->getType());
2470 StateFalse = StateFalse->BindExpr(Ex, Pred->getLocationContext(), Val);
2471 Bldr.generateNode(Ex, Pred, StateFalse, tags.second);
2477 void ExprEngine::VisitGCCAsmStmt(const GCCAsmStmt *A, ExplodedNode *Pred,
2478 ExplodedNodeSet &Dst) {
2479 StmtNodeBuilder Bldr(Pred, Dst, *currBldrCtx);
2480 // We have processed both the inputs and the outputs. All of the outputs
2481 // should evaluate to Locs. Nuke all of their values.
2483 // FIXME: Some day in the future it would be nice to allow a "plug-in"
2484 // which interprets the inline asm and stores proper results in the
2487 ProgramStateRef state = Pred->getState();
2489 for (const Expr *O : A->outputs()) {
2490 SVal X = state->getSVal(O, Pred->getLocationContext());
2491 assert (!X.getAs<NonLoc>()); // Should be an Lval, or unknown, undef.
2493 if (Optional<Loc> LV = X.getAs<Loc>())
2494 state = state->bindLoc(*LV, UnknownVal());
2497 Bldr.generateNode(A, Pred, state);
2500 void ExprEngine::VisitMSAsmStmt(const MSAsmStmt *A, ExplodedNode *Pred,
2501 ExplodedNodeSet &Dst) {
2502 StmtNodeBuilder Bldr(Pred, Dst, *currBldrCtx);
2503 Bldr.generateNode(A, Pred, Pred->getState());
2506 //===----------------------------------------------------------------------===//
2508 //===----------------------------------------------------------------------===//
2511 static ExprEngine* GraphPrintCheckerState;
2512 static SourceManager* GraphPrintSourceManager;
2516 struct DOTGraphTraits<ExplodedNode*> :
2517 public DefaultDOTGraphTraits {
2519 DOTGraphTraits (bool isSimple=false) : DefaultDOTGraphTraits(isSimple) {}
2521 // FIXME: Since we do not cache error nodes in ExprEngine now, this does not
2523 static std::string getNodeAttributes(const ExplodedNode *N, void*) {
2526 // FIXME: Replace with a general scheme to tell if the node is
2528 if (GraphPrintCheckerState->isImplicitNullDeref(N) ||
2529 GraphPrintCheckerState->isExplicitNullDeref(N) ||
2530 GraphPrintCheckerState->isUndefDeref(N) ||
2531 GraphPrintCheckerState->isUndefStore(N) ||
2532 GraphPrintCheckerState->isUndefControlFlow(N) ||
2533 GraphPrintCheckerState->isUndefResult(N) ||
2534 GraphPrintCheckerState->isBadCall(N) ||
2535 GraphPrintCheckerState->isUndefArg(N))
2536 return "color=\"red\",style=\"filled\"";
2538 if (GraphPrintCheckerState->isNoReturnCall(N))
2539 return "color=\"blue\",style=\"filled\"";
2544 static void printLocation(raw_ostream &Out, SourceLocation SLoc) {
2545 if (SLoc.isFileID()) {
2547 << GraphPrintSourceManager->getExpansionLineNumber(SLoc)
2549 << GraphPrintSourceManager->getExpansionColumnNumber(SLoc)
2554 static std::string getNodeLabel(const ExplodedNode *N, void*){
2557 llvm::raw_string_ostream Out(sbuf);
2559 // Program Location.
2560 ProgramPoint Loc = N->getLocation();
2562 switch (Loc.getKind()) {
2563 case ProgramPoint::BlockEntranceKind: {
2564 Out << "Block Entrance: B"
2565 << Loc.castAs<BlockEntrance>().getBlock()->getBlockID();
2566 if (const NamedDecl *ND =
2567 dyn_cast<NamedDecl>(Loc.getLocationContext()->getDecl())) {
2575 case ProgramPoint::BlockExitKind:
2579 case ProgramPoint::CallEnterKind:
2583 case ProgramPoint::CallExitBeginKind:
2584 Out << "CallExitBegin";
2587 case ProgramPoint::CallExitEndKind:
2588 Out << "CallExitEnd";
2591 case ProgramPoint::PostStmtPurgeDeadSymbolsKind:
2592 Out << "PostStmtPurgeDeadSymbols";
2595 case ProgramPoint::PreStmtPurgeDeadSymbolsKind:
2596 Out << "PreStmtPurgeDeadSymbols";
2599 case ProgramPoint::EpsilonKind:
2600 Out << "Epsilon Point";
2603 case ProgramPoint::PreImplicitCallKind: {
2604 ImplicitCallPoint PC = Loc.castAs<ImplicitCallPoint>();
2607 // FIXME: Get proper printing options.
2608 PC.getDecl()->print(Out, LangOptions());
2609 printLocation(Out, PC.getLocation());
2613 case ProgramPoint::PostImplicitCallKind: {
2614 ImplicitCallPoint PC = Loc.castAs<ImplicitCallPoint>();
2615 Out << "PostCall: ";
2617 // FIXME: Get proper printing options.
2618 PC.getDecl()->print(Out, LangOptions());
2619 printLocation(Out, PC.getLocation());
2623 case ProgramPoint::PostInitializerKind: {
2624 Out << "PostInitializer: ";
2625 const CXXCtorInitializer *Init =
2626 Loc.castAs<PostInitializer>().getInitializer();
2627 if (const FieldDecl *FD = Init->getAnyMember())
2630 QualType Ty = Init->getTypeSourceInfo()->getType();
2631 Ty = Ty.getLocalUnqualifiedType();
2632 LangOptions LO; // FIXME.
2638 case ProgramPoint::BlockEdgeKind: {
2639 const BlockEdge &E = Loc.castAs<BlockEdge>();
2640 Out << "Edge: (B" << E.getSrc()->getBlockID() << ", B"
2641 << E.getDst()->getBlockID() << ')';
2643 if (const Stmt *T = E.getSrc()->getTerminator()) {
2644 SourceLocation SLoc = T->getLocStart();
2646 Out << "\\|Terminator: ";
2647 LangOptions LO; // FIXME.
2648 E.getSrc()->printTerminator(Out, LO);
2650 if (SLoc.isFileID()) {
2652 << GraphPrintSourceManager->getExpansionLineNumber(SLoc)
2654 << GraphPrintSourceManager->getExpansionColumnNumber(SLoc);
2657 if (isa<SwitchStmt>(T)) {
2658 const Stmt *Label = E.getDst()->getLabel();
2661 if (const CaseStmt *C = dyn_cast<CaseStmt>(Label)) {
2663 LangOptions LO; // FIXME.
2665 C->getLHS()->printPretty(Out, nullptr, PrintingPolicy(LO));
2667 if (const Stmt *RHS = C->getRHS()) {
2669 RHS->printPretty(Out, nullptr, PrintingPolicy(LO));
2675 assert (isa<DefaultStmt>(Label));
2676 Out << "\\ldefault:";
2680 Out << "\\l(implicit) default:";
2682 else if (isa<IndirectGotoStmt>(T)) {
2686 Out << "\\lCondition: ";
2687 if (*E.getSrc()->succ_begin() == E.getDst())
2697 // FIXME: Replace with a general scheme to determine
2698 // the name of the check.
2699 if (GraphPrintCheckerState->isUndefControlFlow(N)) {
2700 Out << "\\|Control-flow based on\\lUndefined value.\\l";
2707 const Stmt *S = Loc.castAs<StmtPoint>().getStmt();
2708 assert(S != nullptr && "Expecting non-null Stmt");
2710 Out << S->getStmtClassName() << ' ' << (const void*) S << ' ';
2711 LangOptions LO; // FIXME.
2712 S->printPretty(Out, nullptr, PrintingPolicy(LO));
2713 printLocation(Out, S->getLocStart());
2715 if (Loc.getAs<PreStmt>())
2716 Out << "\\lPreStmt\\l;";
2717 else if (Loc.getAs<PostLoad>())
2718 Out << "\\lPostLoad\\l;";
2719 else if (Loc.getAs<PostStore>())
2720 Out << "\\lPostStore\\l";
2721 else if (Loc.getAs<PostLValue>())
2722 Out << "\\lPostLValue\\l";
2725 // FIXME: Replace with a general scheme to determine
2726 // the name of the check.
2727 if (GraphPrintCheckerState->isImplicitNullDeref(N))
2728 Out << "\\|Implicit-Null Dereference.\\l";
2729 else if (GraphPrintCheckerState->isExplicitNullDeref(N))
2730 Out << "\\|Explicit-Null Dereference.\\l";
2731 else if (GraphPrintCheckerState->isUndefDeref(N))
2732 Out << "\\|Dereference of undefialied value.\\l";
2733 else if (GraphPrintCheckerState->isUndefStore(N))
2734 Out << "\\|Store to Undefined Loc.";
2735 else if (GraphPrintCheckerState->isUndefResult(N))
2736 Out << "\\|Result of operation is undefined.";
2737 else if (GraphPrintCheckerState->isNoReturnCall(N))
2738 Out << "\\|Call to function marked \"noreturn\".";
2739 else if (GraphPrintCheckerState->isBadCall(N))
2740 Out << "\\|Call to NULL/Undefined.";
2741 else if (GraphPrintCheckerState->isUndefArg(N))
2742 Out << "\\|Argument in call is undefined";
2749 ProgramStateRef state = N->getState();
2750 Out << "\\|StateID: " << (const void*) state.get()
2751 << " NodeID: " << (const void*) N << "\\|";
2752 state->printDOT(Out);
2756 if (const ProgramPointTag *tag = Loc.getTag()) {
2757 Out << "\\|Tag: " << tag->getTagDescription();
2763 } // end llvm namespace
2766 void ExprEngine::ViewGraph(bool trim) {
2769 std::vector<const ExplodedNode*> Src;
2771 // Flush any outstanding reports to make sure we cover all the nodes.
2772 // This does not cause them to get displayed.
2773 for (BugReporter::iterator I=BR.begin(), E=BR.end(); I!=E; ++I)
2774 const_cast<BugType*>(*I)->FlushReports(BR);
2776 // Iterate through the reports and get their nodes.
2777 for (BugReporter::EQClasses_iterator
2778 EI = BR.EQClasses_begin(), EE = BR.EQClasses_end(); EI != EE; ++EI) {
2779 ExplodedNode *N = const_cast<ExplodedNode*>(EI->begin()->getErrorNode());
2780 if (N) Src.push_back(N);
2786 GraphPrintCheckerState = this;
2787 GraphPrintSourceManager = &getContext().getSourceManager();
2789 llvm::ViewGraph(*G.roots_begin(), "ExprEngine");
2791 GraphPrintCheckerState = nullptr;
2792 GraphPrintSourceManager = nullptr;
2797 void ExprEngine::ViewGraph(ArrayRef<const ExplodedNode*> Nodes) {
2799 GraphPrintCheckerState = this;
2800 GraphPrintSourceManager = &getContext().getSourceManager();
2802 std::unique_ptr<ExplodedGraph> TrimmedG(G.trim(Nodes));
2804 if (!TrimmedG.get())
2805 llvm::errs() << "warning: Trimmed ExplodedGraph is empty.\n";
2807 llvm::ViewGraph(*TrimmedG->roots_begin(), "TrimmedExprEngine");
2809 GraphPrintCheckerState = nullptr;
2810 GraphPrintSourceManager = nullptr;