• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //=-- ExprEngine.cpp - Path-Sensitive Expression-Level Dataflow ---*- C++ -*-=
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
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.
13 //
14 //===----------------------------------------------------------------------===//
15 
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 "llvm/ADT/ImmutableList.h"
30 #include "llvm/ADT/Statistic.h"
31 #include "llvm/Support/raw_ostream.h"
32 
33 #ifndef NDEBUG
34 #include "llvm/Support/GraphWriter.h"
35 #endif
36 
37 using namespace clang;
38 using namespace ento;
39 using llvm::APSInt;
40 
41 #define DEBUG_TYPE "ExprEngine"
42 
43 STATISTIC(NumRemoveDeadBindings,
44             "The # of times RemoveDeadBindings is called");
45 STATISTIC(NumMaxBlockCountReached,
46             "The # of aborted paths due to reaching the maximum block count in "
47             "a top level function");
48 STATISTIC(NumMaxBlockCountReachedInInlined,
49             "The # of aborted paths due to reaching the maximum block count in "
50             "an inlined function");
51 STATISTIC(NumTimesRetriedWithoutInlining,
52             "The # of times we re-evaluated a call without inlining");
53 
54 //===----------------------------------------------------------------------===//
55 // Engine construction and deletion.
56 //===----------------------------------------------------------------------===//
57 
58 static const char* TagProviderName = "ExprEngine";
59 
ExprEngine(AnalysisManager & mgr,bool gcEnabled,SetOfConstDecls * VisitedCalleesIn,FunctionSummariesTy * FS,InliningModes HowToInlineIn)60 ExprEngine::ExprEngine(AnalysisManager &mgr, bool gcEnabled,
61                        SetOfConstDecls *VisitedCalleesIn,
62                        FunctionSummariesTy *FS,
63                        InliningModes HowToInlineIn)
64   : AMgr(mgr),
65     AnalysisDeclContexts(mgr.getAnalysisDeclContextManager()),
66     Engine(*this, FS),
67     G(Engine.getGraph()),
68     StateMgr(getContext(), mgr.getStoreManagerCreator(),
69              mgr.getConstraintManagerCreator(), G.getAllocator(),
70              this),
71     SymMgr(StateMgr.getSymbolManager()),
72     svalBuilder(StateMgr.getSValBuilder()),
73     currStmtIdx(0), currBldrCtx(nullptr),
74     ObjCNoRet(mgr.getASTContext()),
75     ObjCGCEnabled(gcEnabled), BR(mgr, *this),
76     VisitedCallees(VisitedCalleesIn),
77     HowToInline(HowToInlineIn)
78 {
79   unsigned TrimInterval = mgr.options.getGraphTrimInterval();
80   if (TrimInterval != 0) {
81     // Enable eager node reclaimation when constructing the ExplodedGraph.
82     G.enableNodeReclamation(TrimInterval);
83   }
84 }
85 
~ExprEngine()86 ExprEngine::~ExprEngine() {
87   BR.FlushReports();
88 }
89 
90 //===----------------------------------------------------------------------===//
91 // Utility methods.
92 //===----------------------------------------------------------------------===//
93 
getInitialState(const LocationContext * InitLoc)94 ProgramStateRef ExprEngine::getInitialState(const LocationContext *InitLoc) {
95   ProgramStateRef state = StateMgr.getInitialState(InitLoc);
96   const Decl *D = InitLoc->getDecl();
97 
98   // Preconditions.
99   // FIXME: It would be nice if we had a more general mechanism to add
100   // such preconditions.  Some day.
101   do {
102 
103     if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
104       // Precondition: the first argument of 'main' is an integer guaranteed
105       //  to be > 0.
106       const IdentifierInfo *II = FD->getIdentifier();
107       if (!II || !(II->getName() == "main" && FD->getNumParams() > 0))
108         break;
109 
110       const ParmVarDecl *PD = FD->getParamDecl(0);
111       QualType T = PD->getType();
112       const BuiltinType *BT = dyn_cast<BuiltinType>(T);
113       if (!BT || !BT->isInteger())
114         break;
115 
116       const MemRegion *R = state->getRegion(PD, InitLoc);
117       if (!R)
118         break;
119 
120       SVal V = state->getSVal(loc::MemRegionVal(R));
121       SVal Constraint_untested = evalBinOp(state, BO_GT, V,
122                                            svalBuilder.makeZeroVal(T),
123                                            svalBuilder.getConditionType());
124 
125       Optional<DefinedOrUnknownSVal> Constraint =
126           Constraint_untested.getAs<DefinedOrUnknownSVal>();
127 
128       if (!Constraint)
129         break;
130 
131       if (ProgramStateRef newState = state->assume(*Constraint, true))
132         state = newState;
133     }
134     break;
135   }
136   while (0);
137 
138   if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
139     // Precondition: 'self' is always non-null upon entry to an Objective-C
140     // method.
141     const ImplicitParamDecl *SelfD = MD->getSelfDecl();
142     const MemRegion *R = state->getRegion(SelfD, InitLoc);
143     SVal V = state->getSVal(loc::MemRegionVal(R));
144 
145     if (Optional<Loc> LV = V.getAs<Loc>()) {
146       // Assume that the pointer value in 'self' is non-null.
147       state = state->assume(*LV, true);
148       assert(state && "'self' cannot be null");
149     }
150   }
151 
152   if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
153     if (!MD->isStatic()) {
154       // Precondition: 'this' is always non-null upon entry to the
155       // top-level function.  This is our starting assumption for
156       // analyzing an "open" program.
157       const StackFrameContext *SFC = InitLoc->getCurrentStackFrame();
158       if (SFC->getParent() == nullptr) {
159         loc::MemRegionVal L = svalBuilder.getCXXThis(MD, SFC);
160         SVal V = state->getSVal(L);
161         if (Optional<Loc> LV = V.getAs<Loc>()) {
162           state = state->assume(*LV, true);
163           assert(state && "'this' cannot be null");
164         }
165       }
166     }
167   }
168 
169   return state;
170 }
171 
172 ProgramStateRef
createTemporaryRegionIfNeeded(ProgramStateRef State,const LocationContext * LC,const Expr * Ex,const Expr * Result)173 ExprEngine::createTemporaryRegionIfNeeded(ProgramStateRef State,
174                                           const LocationContext *LC,
175                                           const Expr *Ex,
176                                           const Expr *Result) {
177   SVal V = State->getSVal(Ex, LC);
178   if (!Result) {
179     // If we don't have an explicit result expression, we're in "if needed"
180     // mode. Only create a region if the current value is a NonLoc.
181     if (!V.getAs<NonLoc>())
182       return State;
183     Result = Ex;
184   } else {
185     // We need to create a region no matter what. For sanity, make sure we don't
186     // try to stuff a Loc into a non-pointer temporary region.
187     assert(!V.getAs<Loc>() || Loc::isLocType(Result->getType()) ||
188            Result->getType()->isMemberPointerType());
189   }
190 
191   ProgramStateManager &StateMgr = State->getStateManager();
192   MemRegionManager &MRMgr = StateMgr.getRegionManager();
193   StoreManager &StoreMgr = StateMgr.getStoreManager();
194 
195   // We need to be careful about treating a derived type's value as
196   // bindings for a base type. Unless we're creating a temporary pointer region,
197   // start by stripping and recording base casts.
198   SmallVector<const CastExpr *, 4> Casts;
199   const Expr *Inner = Ex->IgnoreParens();
200   if (!Loc::isLocType(Result->getType())) {
201     while (const CastExpr *CE = dyn_cast<CastExpr>(Inner)) {
202       if (CE->getCastKind() == CK_DerivedToBase ||
203           CE->getCastKind() == CK_UncheckedDerivedToBase)
204         Casts.push_back(CE);
205       else if (CE->getCastKind() != CK_NoOp)
206         break;
207 
208       Inner = CE->getSubExpr()->IgnoreParens();
209     }
210   }
211 
212   // Create a temporary object region for the inner expression (which may have
213   // a more derived type) and bind the value into it.
214   const TypedValueRegion *TR = nullptr;
215   if (const MaterializeTemporaryExpr *MT =
216           dyn_cast<MaterializeTemporaryExpr>(Result)) {
217     StorageDuration SD = MT->getStorageDuration();
218     // If this object is bound to a reference with static storage duration, we
219     // put it in a different region to prevent "address leakage" warnings.
220     if (SD == SD_Static || SD == SD_Thread)
221         TR = MRMgr.getCXXStaticTempObjectRegion(Inner);
222   }
223   if (!TR)
224     TR = MRMgr.getCXXTempObjectRegion(Inner, LC);
225 
226   SVal Reg = loc::MemRegionVal(TR);
227 
228   if (V.isUnknown())
229     V = getSValBuilder().conjureSymbolVal(Result, LC, TR->getValueType(),
230                                           currBldrCtx->blockCount());
231   State = State->bindLoc(Reg, V);
232 
233   // Re-apply the casts (from innermost to outermost) for type sanity.
234   for (SmallVectorImpl<const CastExpr *>::reverse_iterator I = Casts.rbegin(),
235                                                            E = Casts.rend();
236        I != E; ++I) {
237     Reg = StoreMgr.evalDerivedToBase(Reg, *I);
238   }
239 
240   State = State->BindExpr(Result, LC, Reg);
241   return State;
242 }
243 
244 //===----------------------------------------------------------------------===//
245 // Top-level transfer function logic (Dispatcher).
246 //===----------------------------------------------------------------------===//
247 
248 /// evalAssume - Called by ConstraintManager. Used to call checker-specific
249 ///  logic for handling assumptions on symbolic values.
processAssume(ProgramStateRef state,SVal cond,bool assumption)250 ProgramStateRef ExprEngine::processAssume(ProgramStateRef state,
251                                               SVal cond, bool assumption) {
252   return getCheckerManager().runCheckersForEvalAssume(state, cond, assumption);
253 }
254 
wantsRegionChangeUpdate(ProgramStateRef state)255 bool ExprEngine::wantsRegionChangeUpdate(ProgramStateRef state) {
256   return getCheckerManager().wantsRegionChangeUpdate(state);
257 }
258 
259 ProgramStateRef
processRegionChanges(ProgramStateRef state,const InvalidatedSymbols * invalidated,ArrayRef<const MemRegion * > Explicits,ArrayRef<const MemRegion * > Regions,const CallEvent * Call)260 ExprEngine::processRegionChanges(ProgramStateRef state,
261                                  const InvalidatedSymbols *invalidated,
262                                  ArrayRef<const MemRegion *> Explicits,
263                                  ArrayRef<const MemRegion *> Regions,
264                                  const CallEvent *Call) {
265   return getCheckerManager().runCheckersForRegionChanges(state, invalidated,
266                                                       Explicits, Regions, Call);
267 }
268 
printState(raw_ostream & Out,ProgramStateRef State,const char * NL,const char * Sep)269 void ExprEngine::printState(raw_ostream &Out, ProgramStateRef State,
270                             const char *NL, const char *Sep) {
271   getCheckerManager().runCheckersForPrintState(Out, State, NL, Sep);
272 }
273 
processEndWorklist(bool hasWorkRemaining)274 void ExprEngine::processEndWorklist(bool hasWorkRemaining) {
275   getCheckerManager().runCheckersForEndAnalysis(G, BR, *this);
276 }
277 
processCFGElement(const CFGElement E,ExplodedNode * Pred,unsigned StmtIdx,NodeBuilderContext * Ctx)278 void ExprEngine::processCFGElement(const CFGElement E, ExplodedNode *Pred,
279                                    unsigned StmtIdx, NodeBuilderContext *Ctx) {
280   PrettyStackTraceLocationContext CrashInfo(Pred->getLocationContext());
281   currStmtIdx = StmtIdx;
282   currBldrCtx = Ctx;
283 
284   switch (E.getKind()) {
285     case CFGElement::Statement:
286       ProcessStmt(const_cast<Stmt*>(E.castAs<CFGStmt>().getStmt()), Pred);
287       return;
288     case CFGElement::Initializer:
289       ProcessInitializer(E.castAs<CFGInitializer>().getInitializer(), Pred);
290       return;
291     case CFGElement::NewAllocator:
292       ProcessNewAllocator(E.castAs<CFGNewAllocator>().getAllocatorExpr(),
293                           Pred);
294       return;
295     case CFGElement::AutomaticObjectDtor:
296     case CFGElement::DeleteDtor:
297     case CFGElement::BaseDtor:
298     case CFGElement::MemberDtor:
299     case CFGElement::TemporaryDtor:
300       ProcessImplicitDtor(E.castAs<CFGImplicitDtor>(), Pred);
301       return;
302   }
303 }
304 
shouldRemoveDeadBindings(AnalysisManager & AMgr,const CFGStmt S,const ExplodedNode * Pred,const LocationContext * LC)305 static bool shouldRemoveDeadBindings(AnalysisManager &AMgr,
306                                      const CFGStmt S,
307                                      const ExplodedNode *Pred,
308                                      const LocationContext *LC) {
309 
310   // Are we never purging state values?
311   if (AMgr.options.AnalysisPurgeOpt == PurgeNone)
312     return false;
313 
314   // Is this the beginning of a basic block?
315   if (Pred->getLocation().getAs<BlockEntrance>())
316     return true;
317 
318   // Is this on a non-expression?
319   if (!isa<Expr>(S.getStmt()))
320     return true;
321 
322   // Run before processing a call.
323   if (CallEvent::isCallStmt(S.getStmt()))
324     return true;
325 
326   // Is this an expression that is consumed by another expression?  If so,
327   // postpone cleaning out the state.
328   ParentMap &PM = LC->getAnalysisDeclContext()->getParentMap();
329   return !PM.isConsumedExpr(cast<Expr>(S.getStmt()));
330 }
331 
removeDead(ExplodedNode * Pred,ExplodedNodeSet & Out,const Stmt * ReferenceStmt,const LocationContext * LC,const Stmt * DiagnosticStmt,ProgramPoint::Kind K)332 void ExprEngine::removeDead(ExplodedNode *Pred, ExplodedNodeSet &Out,
333                             const Stmt *ReferenceStmt,
334                             const LocationContext *LC,
335                             const Stmt *DiagnosticStmt,
336                             ProgramPoint::Kind K) {
337   assert((K == ProgramPoint::PreStmtPurgeDeadSymbolsKind ||
338           ReferenceStmt == nullptr || isa<ReturnStmt>(ReferenceStmt))
339           && "PostStmt is not generally supported by the SymbolReaper yet");
340   assert(LC && "Must pass the current (or expiring) LocationContext");
341 
342   if (!DiagnosticStmt) {
343     DiagnosticStmt = ReferenceStmt;
344     assert(DiagnosticStmt && "Required for clearing a LocationContext");
345   }
346 
347   NumRemoveDeadBindings++;
348   ProgramStateRef CleanedState = Pred->getState();
349 
350   // LC is the location context being destroyed, but SymbolReaper wants a
351   // location context that is still live. (If this is the top-level stack
352   // frame, this will be null.)
353   if (!ReferenceStmt) {
354     assert(K == ProgramPoint::PostStmtPurgeDeadSymbolsKind &&
355            "Use PostStmtPurgeDeadSymbolsKind for clearing a LocationContext");
356     LC = LC->getParent();
357   }
358 
359   const StackFrameContext *SFC = LC ? LC->getCurrentStackFrame() : nullptr;
360   SymbolReaper SymReaper(SFC, ReferenceStmt, SymMgr, getStoreManager());
361 
362   getCheckerManager().runCheckersForLiveSymbols(CleanedState, SymReaper);
363 
364   // Create a state in which dead bindings are removed from the environment
365   // and the store. TODO: The function should just return new env and store,
366   // not a new state.
367   CleanedState = StateMgr.removeDeadBindings(CleanedState, SFC, SymReaper);
368 
369   // Process any special transfer function for dead symbols.
370   // A tag to track convenience transitions, which can be removed at cleanup.
371   static SimpleProgramPointTag cleanupTag(TagProviderName, "Clean Node");
372   if (!SymReaper.hasDeadSymbols()) {
373     // Generate a CleanedNode that has the environment and store cleaned
374     // up. Since no symbols are dead, we can optimize and not clean out
375     // the constraint manager.
376     StmtNodeBuilder Bldr(Pred, Out, *currBldrCtx);
377     Bldr.generateNode(DiagnosticStmt, Pred, CleanedState, &cleanupTag, K);
378 
379   } else {
380     // Call checkers with the non-cleaned state so that they could query the
381     // values of the soon to be dead symbols.
382     ExplodedNodeSet CheckedSet;
383     getCheckerManager().runCheckersForDeadSymbols(CheckedSet, Pred, SymReaper,
384                                                   DiagnosticStmt, *this, K);
385 
386     // For each node in CheckedSet, generate CleanedNodes that have the
387     // environment, the store, and the constraints cleaned up but have the
388     // user-supplied states as the predecessors.
389     StmtNodeBuilder Bldr(CheckedSet, Out, *currBldrCtx);
390     for (ExplodedNodeSet::const_iterator
391           I = CheckedSet.begin(), E = CheckedSet.end(); I != E; ++I) {
392       ProgramStateRef CheckerState = (*I)->getState();
393 
394       // The constraint manager has not been cleaned up yet, so clean up now.
395       CheckerState = getConstraintManager().removeDeadBindings(CheckerState,
396                                                                SymReaper);
397 
398       assert(StateMgr.haveEqualEnvironments(CheckerState, Pred->getState()) &&
399         "Checkers are not allowed to modify the Environment as a part of "
400         "checkDeadSymbols processing.");
401       assert(StateMgr.haveEqualStores(CheckerState, Pred->getState()) &&
402         "Checkers are not allowed to modify the Store as a part of "
403         "checkDeadSymbols processing.");
404 
405       // Create a state based on CleanedState with CheckerState GDM and
406       // generate a transition to that state.
407       ProgramStateRef CleanedCheckerSt =
408         StateMgr.getPersistentStateWithGDM(CleanedState, CheckerState);
409       Bldr.generateNode(DiagnosticStmt, *I, CleanedCheckerSt, &cleanupTag, K);
410     }
411   }
412 }
413 
ProcessStmt(const CFGStmt S,ExplodedNode * Pred)414 void ExprEngine::ProcessStmt(const CFGStmt S,
415                              ExplodedNode *Pred) {
416   // Reclaim any unnecessary nodes in the ExplodedGraph.
417   G.reclaimRecentlyAllocatedNodes();
418 
419   const Stmt *currStmt = S.getStmt();
420   PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
421                                 currStmt->getLocStart(),
422                                 "Error evaluating statement");
423 
424   // Remove dead bindings and symbols.
425   ExplodedNodeSet CleanedStates;
426   if (shouldRemoveDeadBindings(AMgr, S, Pred, Pred->getLocationContext())){
427     removeDead(Pred, CleanedStates, currStmt, Pred->getLocationContext());
428   } else
429     CleanedStates.Add(Pred);
430 
431   // Visit the statement.
432   ExplodedNodeSet Dst;
433   for (ExplodedNodeSet::iterator I = CleanedStates.begin(),
434                                  E = CleanedStates.end(); I != E; ++I) {
435     ExplodedNodeSet DstI;
436     // Visit the statement.
437     Visit(currStmt, *I, DstI);
438     Dst.insert(DstI);
439   }
440 
441   // Enqueue the new nodes onto the work list.
442   Engine.enqueue(Dst, currBldrCtx->getBlock(), currStmtIdx);
443 }
444 
ProcessInitializer(const CFGInitializer Init,ExplodedNode * Pred)445 void ExprEngine::ProcessInitializer(const CFGInitializer Init,
446                                     ExplodedNode *Pred) {
447   const CXXCtorInitializer *BMI = Init.getInitializer();
448 
449   PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
450                                 BMI->getSourceLocation(),
451                                 "Error evaluating initializer");
452 
453   // We don't clean up dead bindings here.
454   const StackFrameContext *stackFrame =
455                            cast<StackFrameContext>(Pred->getLocationContext());
456   const CXXConstructorDecl *decl =
457                            cast<CXXConstructorDecl>(stackFrame->getDecl());
458 
459   ProgramStateRef State = Pred->getState();
460   SVal thisVal = State->getSVal(svalBuilder.getCXXThis(decl, stackFrame));
461 
462   ExplodedNodeSet Tmp(Pred);
463   SVal FieldLoc;
464 
465   // Evaluate the initializer, if necessary
466   if (BMI->isAnyMemberInitializer()) {
467     // Constructors build the object directly in the field,
468     // but non-objects must be copied in from the initializer.
469     const Expr *Init = BMI->getInit()->IgnoreImplicit();
470     if (!isa<CXXConstructExpr>(Init)) {
471       const ValueDecl *Field;
472       if (BMI->isIndirectMemberInitializer()) {
473         Field = BMI->getIndirectMember();
474         FieldLoc = State->getLValue(BMI->getIndirectMember(), thisVal);
475       } else {
476         Field = BMI->getMember();
477         FieldLoc = State->getLValue(BMI->getMember(), thisVal);
478       }
479 
480       SVal InitVal;
481       if (BMI->getNumArrayIndices() > 0) {
482         // Handle arrays of trivial type. We can represent this with a
483         // primitive load/copy from the base array region.
484         const ArraySubscriptExpr *ASE;
485         while ((ASE = dyn_cast<ArraySubscriptExpr>(Init)))
486           Init = ASE->getBase()->IgnoreImplicit();
487 
488         SVal LValue = State->getSVal(Init, stackFrame);
489         if (Optional<Loc> LValueLoc = LValue.getAs<Loc>())
490           InitVal = State->getSVal(*LValueLoc);
491 
492         // If we fail to get the value for some reason, use a symbolic value.
493         if (InitVal.isUnknownOrUndef()) {
494           SValBuilder &SVB = getSValBuilder();
495           InitVal = SVB.conjureSymbolVal(BMI->getInit(), stackFrame,
496                                          Field->getType(),
497                                          currBldrCtx->blockCount());
498         }
499       } else {
500         InitVal = State->getSVal(BMI->getInit(), stackFrame);
501       }
502 
503       assert(Tmp.size() == 1 && "have not generated any new nodes yet");
504       assert(*Tmp.begin() == Pred && "have not generated any new nodes yet");
505       Tmp.clear();
506 
507       PostInitializer PP(BMI, FieldLoc.getAsRegion(), stackFrame);
508       evalBind(Tmp, Init, Pred, FieldLoc, InitVal, /*isInit=*/true, &PP);
509     }
510   } else {
511     assert(BMI->isBaseInitializer() || BMI->isDelegatingInitializer());
512     // We already did all the work when visiting the CXXConstructExpr.
513   }
514 
515   // Construct PostInitializer nodes whether the state changed or not,
516   // so that the diagnostics don't get confused.
517   PostInitializer PP(BMI, FieldLoc.getAsRegion(), stackFrame);
518   ExplodedNodeSet Dst;
519   NodeBuilder Bldr(Tmp, Dst, *currBldrCtx);
520   for (ExplodedNodeSet::iterator I = Tmp.begin(), E = Tmp.end(); I != E; ++I) {
521     ExplodedNode *N = *I;
522     Bldr.generateNode(PP, N->getState(), N);
523   }
524 
525   // Enqueue the new nodes onto the work list.
526   Engine.enqueue(Dst, currBldrCtx->getBlock(), currStmtIdx);
527 }
528 
ProcessImplicitDtor(const CFGImplicitDtor D,ExplodedNode * Pred)529 void ExprEngine::ProcessImplicitDtor(const CFGImplicitDtor D,
530                                      ExplodedNode *Pred) {
531   ExplodedNodeSet Dst;
532   switch (D.getKind()) {
533   case CFGElement::AutomaticObjectDtor:
534     ProcessAutomaticObjDtor(D.castAs<CFGAutomaticObjDtor>(), Pred, Dst);
535     break;
536   case CFGElement::BaseDtor:
537     ProcessBaseDtor(D.castAs<CFGBaseDtor>(), Pred, Dst);
538     break;
539   case CFGElement::MemberDtor:
540     ProcessMemberDtor(D.castAs<CFGMemberDtor>(), Pred, Dst);
541     break;
542   case CFGElement::TemporaryDtor:
543     ProcessTemporaryDtor(D.castAs<CFGTemporaryDtor>(), Pred, Dst);
544     break;
545   case CFGElement::DeleteDtor:
546     ProcessDeleteDtor(D.castAs<CFGDeleteDtor>(), Pred, Dst);
547     break;
548   default:
549     llvm_unreachable("Unexpected dtor kind.");
550   }
551 
552   // Enqueue the new nodes onto the work list.
553   Engine.enqueue(Dst, currBldrCtx->getBlock(), currStmtIdx);
554 }
555 
ProcessNewAllocator(const CXXNewExpr * NE,ExplodedNode * Pred)556 void ExprEngine::ProcessNewAllocator(const CXXNewExpr *NE,
557                                      ExplodedNode *Pred) {
558   ExplodedNodeSet Dst;
559   AnalysisManager &AMgr = getAnalysisManager();
560   AnalyzerOptions &Opts = AMgr.options;
561   // TODO: We're not evaluating allocators for all cases just yet as
562   // we're not handling the return value correctly, which causes false
563   // positives when the alpha.cplusplus.NewDeleteLeaks check is on.
564   if (Opts.mayInlineCXXAllocator())
565     VisitCXXNewAllocatorCall(NE, Pred, Dst);
566   else {
567     NodeBuilder Bldr(Pred, Dst, *currBldrCtx);
568     const LocationContext *LCtx = Pred->getLocationContext();
569     PostImplicitCall PP(NE->getOperatorNew(), NE->getLocStart(), LCtx);
570     Bldr.generateNode(PP, Pred->getState(), Pred);
571   }
572   Engine.enqueue(Dst, currBldrCtx->getBlock(), currStmtIdx);
573 }
574 
ProcessAutomaticObjDtor(const CFGAutomaticObjDtor Dtor,ExplodedNode * Pred,ExplodedNodeSet & Dst)575 void ExprEngine::ProcessAutomaticObjDtor(const CFGAutomaticObjDtor Dtor,
576                                          ExplodedNode *Pred,
577                                          ExplodedNodeSet &Dst) {
578   const VarDecl *varDecl = Dtor.getVarDecl();
579   QualType varType = varDecl->getType();
580 
581   ProgramStateRef state = Pred->getState();
582   SVal dest = state->getLValue(varDecl, Pred->getLocationContext());
583   const MemRegion *Region = dest.castAs<loc::MemRegionVal>().getRegion();
584 
585   if (const ReferenceType *refType = varType->getAs<ReferenceType>()) {
586     varType = refType->getPointeeType();
587     Region = state->getSVal(Region).getAsRegion();
588   }
589 
590   VisitCXXDestructor(varType, Region, Dtor.getTriggerStmt(), /*IsBase=*/ false,
591                      Pred, Dst);
592 }
593 
ProcessDeleteDtor(const CFGDeleteDtor Dtor,ExplodedNode * Pred,ExplodedNodeSet & Dst)594 void ExprEngine::ProcessDeleteDtor(const CFGDeleteDtor Dtor,
595                                    ExplodedNode *Pred,
596                                    ExplodedNodeSet &Dst) {
597   ProgramStateRef State = Pred->getState();
598   const LocationContext *LCtx = Pred->getLocationContext();
599   const CXXDeleteExpr *DE = Dtor.getDeleteExpr();
600   const Stmt *Arg = DE->getArgument();
601   SVal ArgVal = State->getSVal(Arg, LCtx);
602 
603   // If the argument to delete is known to be a null value,
604   // don't run destructor.
605   if (State->isNull(ArgVal).isConstrainedTrue()) {
606     QualType DTy = DE->getDestroyedType();
607     QualType BTy = getContext().getBaseElementType(DTy);
608     const CXXRecordDecl *RD = BTy->getAsCXXRecordDecl();
609     const CXXDestructorDecl *Dtor = RD->getDestructor();
610 
611     PostImplicitCall PP(Dtor, DE->getLocStart(), LCtx);
612     NodeBuilder Bldr(Pred, Dst, *currBldrCtx);
613     Bldr.generateNode(PP, Pred->getState(), Pred);
614     return;
615   }
616 
617   VisitCXXDestructor(DE->getDestroyedType(),
618                      ArgVal.getAsRegion(),
619                      DE, /*IsBase=*/ false,
620                      Pred, Dst);
621 }
622 
ProcessBaseDtor(const CFGBaseDtor D,ExplodedNode * Pred,ExplodedNodeSet & Dst)623 void ExprEngine::ProcessBaseDtor(const CFGBaseDtor D,
624                                  ExplodedNode *Pred, ExplodedNodeSet &Dst) {
625   const LocationContext *LCtx = Pred->getLocationContext();
626 
627   const CXXDestructorDecl *CurDtor = cast<CXXDestructorDecl>(LCtx->getDecl());
628   Loc ThisPtr = getSValBuilder().getCXXThis(CurDtor,
629                                             LCtx->getCurrentStackFrame());
630   SVal ThisVal = Pred->getState()->getSVal(ThisPtr);
631 
632   // Create the base object region.
633   const CXXBaseSpecifier *Base = D.getBaseSpecifier();
634   QualType BaseTy = Base->getType();
635   SVal BaseVal = getStoreManager().evalDerivedToBase(ThisVal, BaseTy,
636                                                      Base->isVirtual());
637 
638   VisitCXXDestructor(BaseTy, BaseVal.castAs<loc::MemRegionVal>().getRegion(),
639                      CurDtor->getBody(), /*IsBase=*/ true, Pred, Dst);
640 }
641 
ProcessMemberDtor(const CFGMemberDtor D,ExplodedNode * Pred,ExplodedNodeSet & Dst)642 void ExprEngine::ProcessMemberDtor(const CFGMemberDtor D,
643                                    ExplodedNode *Pred, ExplodedNodeSet &Dst) {
644   const FieldDecl *Member = D.getFieldDecl();
645   ProgramStateRef State = Pred->getState();
646   const LocationContext *LCtx = Pred->getLocationContext();
647 
648   const CXXDestructorDecl *CurDtor = cast<CXXDestructorDecl>(LCtx->getDecl());
649   Loc ThisVal = getSValBuilder().getCXXThis(CurDtor,
650                                             LCtx->getCurrentStackFrame());
651   SVal FieldVal =
652       State->getLValue(Member, State->getSVal(ThisVal).castAs<Loc>());
653 
654   VisitCXXDestructor(Member->getType(),
655                      FieldVal.castAs<loc::MemRegionVal>().getRegion(),
656                      CurDtor->getBody(), /*IsBase=*/false, Pred, Dst);
657 }
658 
ProcessTemporaryDtor(const CFGTemporaryDtor D,ExplodedNode * Pred,ExplodedNodeSet & Dst)659 void ExprEngine::ProcessTemporaryDtor(const CFGTemporaryDtor D,
660                                       ExplodedNode *Pred,
661                                       ExplodedNodeSet &Dst) {
662 
663   QualType varType = D.getBindTemporaryExpr()->getSubExpr()->getType();
664 
665   // FIXME: Inlining of temporary destructors is not supported yet anyway, so we
666   // just put a NULL region for now. This will need to be changed later.
667   VisitCXXDestructor(varType, nullptr, D.getBindTemporaryExpr(),
668                      /*IsBase=*/ false, Pred, Dst);
669 }
670 
Visit(const Stmt * S,ExplodedNode * Pred,ExplodedNodeSet & DstTop)671 void ExprEngine::Visit(const Stmt *S, ExplodedNode *Pred,
672                        ExplodedNodeSet &DstTop) {
673   PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
674                                 S->getLocStart(),
675                                 "Error evaluating statement");
676   ExplodedNodeSet Dst;
677   StmtNodeBuilder Bldr(Pred, DstTop, *currBldrCtx);
678 
679   assert(!isa<Expr>(S) || S == cast<Expr>(S)->IgnoreParens());
680 
681   switch (S->getStmtClass()) {
682     // C++ and ARC stuff we don't support yet.
683     case Expr::ObjCIndirectCopyRestoreExprClass:
684     case Stmt::CXXDependentScopeMemberExprClass:
685     case Stmt::CXXTryStmtClass:
686     case Stmt::CXXTypeidExprClass:
687     case Stmt::CXXUuidofExprClass:
688     case Stmt::MSPropertyRefExprClass:
689     case Stmt::CXXUnresolvedConstructExprClass:
690     case Stmt::DependentScopeDeclRefExprClass:
691     case Stmt::TypeTraitExprClass:
692     case Stmt::ArrayTypeTraitExprClass:
693     case Stmt::ExpressionTraitExprClass:
694     case Stmt::UnresolvedLookupExprClass:
695     case Stmt::UnresolvedMemberExprClass:
696     case Stmt::CXXNoexceptExprClass:
697     case Stmt::PackExpansionExprClass:
698     case Stmt::SubstNonTypeTemplateParmPackExprClass:
699     case Stmt::FunctionParmPackExprClass:
700     case Stmt::SEHTryStmtClass:
701     case Stmt::SEHExceptStmtClass:
702     case Stmt::SEHLeaveStmtClass:
703     case Stmt::LambdaExprClass:
704     case Stmt::SEHFinallyStmtClass: {
705       const ExplodedNode *node = Bldr.generateSink(S, Pred, Pred->getState());
706       Engine.addAbortedBlock(node, currBldrCtx->getBlock());
707       break;
708     }
709 
710     case Stmt::ParenExprClass:
711       llvm_unreachable("ParenExprs already handled.");
712     case Stmt::GenericSelectionExprClass:
713       llvm_unreachable("GenericSelectionExprs already handled.");
714     // Cases that should never be evaluated simply because they shouldn't
715     // appear in the CFG.
716     case Stmt::BreakStmtClass:
717     case Stmt::CaseStmtClass:
718     case Stmt::CompoundStmtClass:
719     case Stmt::ContinueStmtClass:
720     case Stmt::CXXForRangeStmtClass:
721     case Stmt::DefaultStmtClass:
722     case Stmt::DoStmtClass:
723     case Stmt::ForStmtClass:
724     case Stmt::GotoStmtClass:
725     case Stmt::IfStmtClass:
726     case Stmt::IndirectGotoStmtClass:
727     case Stmt::LabelStmtClass:
728     case Stmt::NoStmtClass:
729     case Stmt::NullStmtClass:
730     case Stmt::SwitchStmtClass:
731     case Stmt::WhileStmtClass:
732     case Expr::MSDependentExistsStmtClass:
733     case Stmt::CapturedStmtClass:
734     case Stmt::OMPParallelDirectiveClass:
735     case Stmt::OMPSimdDirectiveClass:
736     case Stmt::OMPForDirectiveClass:
737     case Stmt::OMPSectionsDirectiveClass:
738     case Stmt::OMPSectionDirectiveClass:
739     case Stmt::OMPSingleDirectiveClass:
740     case Stmt::OMPParallelForDirectiveClass:
741     case Stmt::OMPParallelSectionsDirectiveClass:
742       llvm_unreachable("Stmt should not be in analyzer evaluation loop");
743 
744     case Stmt::ObjCSubscriptRefExprClass:
745     case Stmt::ObjCPropertyRefExprClass:
746       llvm_unreachable("These are handled by PseudoObjectExpr");
747 
748     case Stmt::GNUNullExprClass: {
749       // GNU __null is a pointer-width integer, not an actual pointer.
750       ProgramStateRef state = Pred->getState();
751       state = state->BindExpr(S, Pred->getLocationContext(),
752                               svalBuilder.makeIntValWithPtrWidth(0, false));
753       Bldr.generateNode(S, Pred, state);
754       break;
755     }
756 
757     case Stmt::ObjCAtSynchronizedStmtClass:
758       Bldr.takeNodes(Pred);
759       VisitObjCAtSynchronizedStmt(cast<ObjCAtSynchronizedStmt>(S), Pred, Dst);
760       Bldr.addNodes(Dst);
761       break;
762 
763     case Stmt::ExprWithCleanupsClass:
764       // Handled due to fully linearised CFG.
765       break;
766 
767     // Cases not handled yet; but will handle some day.
768     case Stmt::DesignatedInitExprClass:
769     case Stmt::ExtVectorElementExprClass:
770     case Stmt::ImaginaryLiteralClass:
771     case Stmt::ObjCAtCatchStmtClass:
772     case Stmt::ObjCAtFinallyStmtClass:
773     case Stmt::ObjCAtTryStmtClass:
774     case Stmt::ObjCAutoreleasePoolStmtClass:
775     case Stmt::ObjCEncodeExprClass:
776     case Stmt::ObjCIsaExprClass:
777     case Stmt::ObjCProtocolExprClass:
778     case Stmt::ObjCSelectorExprClass:
779     case Stmt::ParenListExprClass:
780     case Stmt::PredefinedExprClass:
781     case Stmt::ShuffleVectorExprClass:
782     case Stmt::ConvertVectorExprClass:
783     case Stmt::VAArgExprClass:
784     case Stmt::CUDAKernelCallExprClass:
785     case Stmt::OpaqueValueExprClass:
786     case Stmt::AsTypeExprClass:
787     case Stmt::AtomicExprClass:
788       // Fall through.
789 
790     // Cases we intentionally don't evaluate, since they don't need
791     // to be explicitly evaluated.
792     case Stmt::AddrLabelExprClass:
793     case Stmt::AttributedStmtClass:
794     case Stmt::IntegerLiteralClass:
795     case Stmt::CharacterLiteralClass:
796     case Stmt::ImplicitValueInitExprClass:
797     case Stmt::CXXScalarValueInitExprClass:
798     case Stmt::CXXBoolLiteralExprClass:
799     case Stmt::ObjCBoolLiteralExprClass:
800     case Stmt::FloatingLiteralClass:
801     case Stmt::SizeOfPackExprClass:
802     case Stmt::StringLiteralClass:
803     case Stmt::ObjCStringLiteralClass:
804     case Stmt::CXXBindTemporaryExprClass:
805     case Stmt::CXXPseudoDestructorExprClass:
806     case Stmt::SubstNonTypeTemplateParmExprClass:
807     case Stmt::CXXNullPtrLiteralExprClass: {
808       Bldr.takeNodes(Pred);
809       ExplodedNodeSet preVisit;
810       getCheckerManager().runCheckersForPreStmt(preVisit, Pred, S, *this);
811       getCheckerManager().runCheckersForPostStmt(Dst, preVisit, S, *this);
812       Bldr.addNodes(Dst);
813       break;
814     }
815 
816     case Stmt::CXXDefaultArgExprClass:
817     case Stmt::CXXDefaultInitExprClass: {
818       Bldr.takeNodes(Pred);
819       ExplodedNodeSet PreVisit;
820       getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
821 
822       ExplodedNodeSet Tmp;
823       StmtNodeBuilder Bldr2(PreVisit, Tmp, *currBldrCtx);
824 
825       const Expr *ArgE;
826       if (const CXXDefaultArgExpr *DefE = dyn_cast<CXXDefaultArgExpr>(S))
827         ArgE = DefE->getExpr();
828       else if (const CXXDefaultInitExpr *DefE = dyn_cast<CXXDefaultInitExpr>(S))
829         ArgE = DefE->getExpr();
830       else
831         llvm_unreachable("unknown constant wrapper kind");
832 
833       bool IsTemporary = false;
834       if (const MaterializeTemporaryExpr *MTE =
835             dyn_cast<MaterializeTemporaryExpr>(ArgE)) {
836         ArgE = MTE->GetTemporaryExpr();
837         IsTemporary = true;
838       }
839 
840       Optional<SVal> ConstantVal = svalBuilder.getConstantVal(ArgE);
841       if (!ConstantVal)
842         ConstantVal = UnknownVal();
843 
844       const LocationContext *LCtx = Pred->getLocationContext();
845       for (ExplodedNodeSet::iterator I = PreVisit.begin(), E = PreVisit.end();
846            I != E; ++I) {
847         ProgramStateRef State = (*I)->getState();
848         State = State->BindExpr(S, LCtx, *ConstantVal);
849         if (IsTemporary)
850           State = createTemporaryRegionIfNeeded(State, LCtx,
851                                                 cast<Expr>(S),
852                                                 cast<Expr>(S));
853         Bldr2.generateNode(S, *I, State);
854       }
855 
856       getCheckerManager().runCheckersForPostStmt(Dst, Tmp, S, *this);
857       Bldr.addNodes(Dst);
858       break;
859     }
860 
861     // Cases we evaluate as opaque expressions, conjuring a symbol.
862     case Stmt::CXXStdInitializerListExprClass:
863     case Expr::ObjCArrayLiteralClass:
864     case Expr::ObjCDictionaryLiteralClass:
865     case Expr::ObjCBoxedExprClass: {
866       Bldr.takeNodes(Pred);
867 
868       ExplodedNodeSet preVisit;
869       getCheckerManager().runCheckersForPreStmt(preVisit, Pred, S, *this);
870 
871       ExplodedNodeSet Tmp;
872       StmtNodeBuilder Bldr2(preVisit, Tmp, *currBldrCtx);
873 
874       const Expr *Ex = cast<Expr>(S);
875       QualType resultType = Ex->getType();
876 
877       for (ExplodedNodeSet::iterator it = preVisit.begin(), et = preVisit.end();
878            it != et; ++it) {
879         ExplodedNode *N = *it;
880         const LocationContext *LCtx = N->getLocationContext();
881         SVal result = svalBuilder.conjureSymbolVal(nullptr, Ex, LCtx,
882                                                    resultType,
883                                                    currBldrCtx->blockCount());
884         ProgramStateRef state = N->getState()->BindExpr(Ex, LCtx, result);
885         Bldr2.generateNode(S, N, state);
886       }
887 
888       getCheckerManager().runCheckersForPostStmt(Dst, Tmp, S, *this);
889       Bldr.addNodes(Dst);
890       break;
891     }
892 
893     case Stmt::ArraySubscriptExprClass:
894       Bldr.takeNodes(Pred);
895       VisitLvalArraySubscriptExpr(cast<ArraySubscriptExpr>(S), Pred, Dst);
896       Bldr.addNodes(Dst);
897       break;
898 
899     case Stmt::GCCAsmStmtClass:
900       Bldr.takeNodes(Pred);
901       VisitGCCAsmStmt(cast<GCCAsmStmt>(S), Pred, Dst);
902       Bldr.addNodes(Dst);
903       break;
904 
905     case Stmt::MSAsmStmtClass:
906       Bldr.takeNodes(Pred);
907       VisitMSAsmStmt(cast<MSAsmStmt>(S), Pred, Dst);
908       Bldr.addNodes(Dst);
909       break;
910 
911     case Stmt::BlockExprClass:
912       Bldr.takeNodes(Pred);
913       VisitBlockExpr(cast<BlockExpr>(S), Pred, Dst);
914       Bldr.addNodes(Dst);
915       break;
916 
917     case Stmt::BinaryOperatorClass: {
918       const BinaryOperator* B = cast<BinaryOperator>(S);
919       if (B->isLogicalOp()) {
920         Bldr.takeNodes(Pred);
921         VisitLogicalExpr(B, Pred, Dst);
922         Bldr.addNodes(Dst);
923         break;
924       }
925       else if (B->getOpcode() == BO_Comma) {
926         ProgramStateRef state = Pred->getState();
927         Bldr.generateNode(B, Pred,
928                           state->BindExpr(B, Pred->getLocationContext(),
929                                           state->getSVal(B->getRHS(),
930                                                   Pred->getLocationContext())));
931         break;
932       }
933 
934       Bldr.takeNodes(Pred);
935 
936       if (AMgr.options.eagerlyAssumeBinOpBifurcation &&
937           (B->isRelationalOp() || B->isEqualityOp())) {
938         ExplodedNodeSet Tmp;
939         VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Tmp);
940         evalEagerlyAssumeBinOpBifurcation(Dst, Tmp, cast<Expr>(S));
941       }
942       else
943         VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Dst);
944 
945       Bldr.addNodes(Dst);
946       break;
947     }
948 
949     case Stmt::CXXOperatorCallExprClass: {
950       const CXXOperatorCallExpr *OCE = cast<CXXOperatorCallExpr>(S);
951 
952       // For instance method operators, make sure the 'this' argument has a
953       // valid region.
954       const Decl *Callee = OCE->getCalleeDecl();
955       if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Callee)) {
956         if (MD->isInstance()) {
957           ProgramStateRef State = Pred->getState();
958           const LocationContext *LCtx = Pred->getLocationContext();
959           ProgramStateRef NewState =
960             createTemporaryRegionIfNeeded(State, LCtx, OCE->getArg(0));
961           if (NewState != State) {
962             Pred = Bldr.generateNode(OCE, Pred, NewState, /*Tag=*/nullptr,
963                                      ProgramPoint::PreStmtKind);
964             // Did we cache out?
965             if (!Pred)
966               break;
967           }
968         }
969       }
970       // FALLTHROUGH
971     }
972     case Stmt::CallExprClass:
973     case Stmt::CXXMemberCallExprClass:
974     case Stmt::UserDefinedLiteralClass: {
975       Bldr.takeNodes(Pred);
976       VisitCallExpr(cast<CallExpr>(S), Pred, Dst);
977       Bldr.addNodes(Dst);
978       break;
979     }
980 
981     case Stmt::CXXCatchStmtClass: {
982       Bldr.takeNodes(Pred);
983       VisitCXXCatchStmt(cast<CXXCatchStmt>(S), Pred, Dst);
984       Bldr.addNodes(Dst);
985       break;
986     }
987 
988     case Stmt::CXXTemporaryObjectExprClass:
989     case Stmt::CXXConstructExprClass: {
990       Bldr.takeNodes(Pred);
991       VisitCXXConstructExpr(cast<CXXConstructExpr>(S), Pred, Dst);
992       Bldr.addNodes(Dst);
993       break;
994     }
995 
996     case Stmt::CXXNewExprClass: {
997       Bldr.takeNodes(Pred);
998       ExplodedNodeSet PostVisit;
999       VisitCXXNewExpr(cast<CXXNewExpr>(S), Pred, PostVisit);
1000       getCheckerManager().runCheckersForPostStmt(Dst, PostVisit, S, *this);
1001       Bldr.addNodes(Dst);
1002       break;
1003     }
1004 
1005     case Stmt::CXXDeleteExprClass: {
1006       Bldr.takeNodes(Pred);
1007       ExplodedNodeSet PreVisit;
1008       const CXXDeleteExpr *CDE = cast<CXXDeleteExpr>(S);
1009       getCheckerManager().runCheckersForPreStmt(PreVisit, Pred, S, *this);
1010 
1011       for (ExplodedNodeSet::iterator i = PreVisit.begin(),
1012                                      e = PreVisit.end(); i != e ; ++i)
1013         VisitCXXDeleteExpr(CDE, *i, Dst);
1014 
1015       Bldr.addNodes(Dst);
1016       break;
1017     }
1018       // FIXME: ChooseExpr is really a constant.  We need to fix
1019       //        the CFG do not model them as explicit control-flow.
1020 
1021     case Stmt::ChooseExprClass: { // __builtin_choose_expr
1022       Bldr.takeNodes(Pred);
1023       const ChooseExpr *C = cast<ChooseExpr>(S);
1024       VisitGuardedExpr(C, C->getLHS(), C->getRHS(), Pred, Dst);
1025       Bldr.addNodes(Dst);
1026       break;
1027     }
1028 
1029     case Stmt::CompoundAssignOperatorClass:
1030       Bldr.takeNodes(Pred);
1031       VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Dst);
1032       Bldr.addNodes(Dst);
1033       break;
1034 
1035     case Stmt::CompoundLiteralExprClass:
1036       Bldr.takeNodes(Pred);
1037       VisitCompoundLiteralExpr(cast<CompoundLiteralExpr>(S), Pred, Dst);
1038       Bldr.addNodes(Dst);
1039       break;
1040 
1041     case Stmt::BinaryConditionalOperatorClass:
1042     case Stmt::ConditionalOperatorClass: { // '?' operator
1043       Bldr.takeNodes(Pred);
1044       const AbstractConditionalOperator *C
1045         = cast<AbstractConditionalOperator>(S);
1046       VisitGuardedExpr(C, C->getTrueExpr(), C->getFalseExpr(), Pred, Dst);
1047       Bldr.addNodes(Dst);
1048       break;
1049     }
1050 
1051     case Stmt::CXXThisExprClass:
1052       Bldr.takeNodes(Pred);
1053       VisitCXXThisExpr(cast<CXXThisExpr>(S), Pred, Dst);
1054       Bldr.addNodes(Dst);
1055       break;
1056 
1057     case Stmt::DeclRefExprClass: {
1058       Bldr.takeNodes(Pred);
1059       const DeclRefExpr *DE = cast<DeclRefExpr>(S);
1060       VisitCommonDeclRefExpr(DE, DE->getDecl(), Pred, Dst);
1061       Bldr.addNodes(Dst);
1062       break;
1063     }
1064 
1065     case Stmt::DeclStmtClass:
1066       Bldr.takeNodes(Pred);
1067       VisitDeclStmt(cast<DeclStmt>(S), Pred, Dst);
1068       Bldr.addNodes(Dst);
1069       break;
1070 
1071     case Stmt::ImplicitCastExprClass:
1072     case Stmt::CStyleCastExprClass:
1073     case Stmt::CXXStaticCastExprClass:
1074     case Stmt::CXXDynamicCastExprClass:
1075     case Stmt::CXXReinterpretCastExprClass:
1076     case Stmt::CXXConstCastExprClass:
1077     case Stmt::CXXFunctionalCastExprClass:
1078     case Stmt::ObjCBridgedCastExprClass: {
1079       Bldr.takeNodes(Pred);
1080       const CastExpr *C = cast<CastExpr>(S);
1081       // Handle the previsit checks.
1082       ExplodedNodeSet dstPrevisit;
1083       getCheckerManager().runCheckersForPreStmt(dstPrevisit, Pred, C, *this);
1084 
1085       // Handle the expression itself.
1086       ExplodedNodeSet dstExpr;
1087       for (ExplodedNodeSet::iterator i = dstPrevisit.begin(),
1088                                      e = dstPrevisit.end(); i != e ; ++i) {
1089         VisitCast(C, C->getSubExpr(), *i, dstExpr);
1090       }
1091 
1092       // Handle the postvisit checks.
1093       getCheckerManager().runCheckersForPostStmt(Dst, dstExpr, C, *this);
1094       Bldr.addNodes(Dst);
1095       break;
1096     }
1097 
1098     case Expr::MaterializeTemporaryExprClass: {
1099       Bldr.takeNodes(Pred);
1100       const MaterializeTemporaryExpr *MTE = cast<MaterializeTemporaryExpr>(S);
1101       CreateCXXTemporaryObject(MTE, Pred, Dst);
1102       Bldr.addNodes(Dst);
1103       break;
1104     }
1105 
1106     case Stmt::InitListExprClass:
1107       Bldr.takeNodes(Pred);
1108       VisitInitListExpr(cast<InitListExpr>(S), Pred, Dst);
1109       Bldr.addNodes(Dst);
1110       break;
1111 
1112     case Stmt::MemberExprClass:
1113       Bldr.takeNodes(Pred);
1114       VisitMemberExpr(cast<MemberExpr>(S), Pred, Dst);
1115       Bldr.addNodes(Dst);
1116       break;
1117 
1118     case Stmt::ObjCIvarRefExprClass:
1119       Bldr.takeNodes(Pred);
1120       VisitLvalObjCIvarRefExpr(cast<ObjCIvarRefExpr>(S), Pred, Dst);
1121       Bldr.addNodes(Dst);
1122       break;
1123 
1124     case Stmt::ObjCForCollectionStmtClass:
1125       Bldr.takeNodes(Pred);
1126       VisitObjCForCollectionStmt(cast<ObjCForCollectionStmt>(S), Pred, Dst);
1127       Bldr.addNodes(Dst);
1128       break;
1129 
1130     case Stmt::ObjCMessageExprClass:
1131       Bldr.takeNodes(Pred);
1132       VisitObjCMessage(cast<ObjCMessageExpr>(S), Pred, Dst);
1133       Bldr.addNodes(Dst);
1134       break;
1135 
1136     case Stmt::ObjCAtThrowStmtClass:
1137     case Stmt::CXXThrowExprClass:
1138       // FIXME: This is not complete.  We basically treat @throw as
1139       // an abort.
1140       Bldr.generateSink(S, Pred, Pred->getState());
1141       break;
1142 
1143     case Stmt::ReturnStmtClass:
1144       Bldr.takeNodes(Pred);
1145       VisitReturnStmt(cast<ReturnStmt>(S), Pred, Dst);
1146       Bldr.addNodes(Dst);
1147       break;
1148 
1149     case Stmt::OffsetOfExprClass:
1150       Bldr.takeNodes(Pred);
1151       VisitOffsetOfExpr(cast<OffsetOfExpr>(S), Pred, Dst);
1152       Bldr.addNodes(Dst);
1153       break;
1154 
1155     case Stmt::UnaryExprOrTypeTraitExprClass:
1156       Bldr.takeNodes(Pred);
1157       VisitUnaryExprOrTypeTraitExpr(cast<UnaryExprOrTypeTraitExpr>(S),
1158                                     Pred, Dst);
1159       Bldr.addNodes(Dst);
1160       break;
1161 
1162     case Stmt::StmtExprClass: {
1163       const StmtExpr *SE = cast<StmtExpr>(S);
1164 
1165       if (SE->getSubStmt()->body_empty()) {
1166         // Empty statement expression.
1167         assert(SE->getType() == getContext().VoidTy
1168                && "Empty statement expression must have void type.");
1169         break;
1170       }
1171 
1172       if (Expr *LastExpr = dyn_cast<Expr>(*SE->getSubStmt()->body_rbegin())) {
1173         ProgramStateRef state = Pred->getState();
1174         Bldr.generateNode(SE, Pred,
1175                           state->BindExpr(SE, Pred->getLocationContext(),
1176                                           state->getSVal(LastExpr,
1177                                                   Pred->getLocationContext())));
1178       }
1179       break;
1180     }
1181 
1182     case Stmt::UnaryOperatorClass: {
1183       Bldr.takeNodes(Pred);
1184       const UnaryOperator *U = cast<UnaryOperator>(S);
1185       if (AMgr.options.eagerlyAssumeBinOpBifurcation && (U->getOpcode() == UO_LNot)) {
1186         ExplodedNodeSet Tmp;
1187         VisitUnaryOperator(U, Pred, Tmp);
1188         evalEagerlyAssumeBinOpBifurcation(Dst, Tmp, U);
1189       }
1190       else
1191         VisitUnaryOperator(U, Pred, Dst);
1192       Bldr.addNodes(Dst);
1193       break;
1194     }
1195 
1196     case Stmt::PseudoObjectExprClass: {
1197       Bldr.takeNodes(Pred);
1198       ProgramStateRef state = Pred->getState();
1199       const PseudoObjectExpr *PE = cast<PseudoObjectExpr>(S);
1200       if (const Expr *Result = PE->getResultExpr()) {
1201         SVal V = state->getSVal(Result, Pred->getLocationContext());
1202         Bldr.generateNode(S, Pred,
1203                           state->BindExpr(S, Pred->getLocationContext(), V));
1204       }
1205       else
1206         Bldr.generateNode(S, Pred,
1207                           state->BindExpr(S, Pred->getLocationContext(),
1208                                                    UnknownVal()));
1209 
1210       Bldr.addNodes(Dst);
1211       break;
1212     }
1213   }
1214 }
1215 
replayWithoutInlining(ExplodedNode * N,const LocationContext * CalleeLC)1216 bool ExprEngine::replayWithoutInlining(ExplodedNode *N,
1217                                        const LocationContext *CalleeLC) {
1218   const StackFrameContext *CalleeSF = CalleeLC->getCurrentStackFrame();
1219   const StackFrameContext *CallerSF = CalleeSF->getParent()->getCurrentStackFrame();
1220   assert(CalleeSF && CallerSF);
1221   ExplodedNode *BeforeProcessingCall = nullptr;
1222   const Stmt *CE = CalleeSF->getCallSite();
1223 
1224   // Find the first node before we started processing the call expression.
1225   while (N) {
1226     ProgramPoint L = N->getLocation();
1227     BeforeProcessingCall = N;
1228     N = N->pred_empty() ? nullptr : *(N->pred_begin());
1229 
1230     // Skip the nodes corresponding to the inlined code.
1231     if (L.getLocationContext()->getCurrentStackFrame() != CallerSF)
1232       continue;
1233     // We reached the caller. Find the node right before we started
1234     // processing the call.
1235     if (L.isPurgeKind())
1236       continue;
1237     if (L.getAs<PreImplicitCall>())
1238       continue;
1239     if (L.getAs<CallEnter>())
1240       continue;
1241     if (Optional<StmtPoint> SP = L.getAs<StmtPoint>())
1242       if (SP->getStmt() == CE)
1243         continue;
1244     break;
1245   }
1246 
1247   if (!BeforeProcessingCall)
1248     return false;
1249 
1250   // TODO: Clean up the unneeded nodes.
1251 
1252   // Build an Epsilon node from which we will restart the analyzes.
1253   // Note that CE is permitted to be NULL!
1254   ProgramPoint NewNodeLoc =
1255                EpsilonPoint(BeforeProcessingCall->getLocationContext(), CE);
1256   // Add the special flag to GDM to signal retrying with no inlining.
1257   // Note, changing the state ensures that we are not going to cache out.
1258   ProgramStateRef NewNodeState = BeforeProcessingCall->getState();
1259   NewNodeState =
1260     NewNodeState->set<ReplayWithoutInlining>(const_cast<Stmt *>(CE));
1261 
1262   // Make the new node a successor of BeforeProcessingCall.
1263   bool IsNew = false;
1264   ExplodedNode *NewNode = G.getNode(NewNodeLoc, NewNodeState, false, &IsNew);
1265   // We cached out at this point. Caching out is common due to us backtracking
1266   // from the inlined function, which might spawn several paths.
1267   if (!IsNew)
1268     return true;
1269 
1270   NewNode->addPredecessor(BeforeProcessingCall, G);
1271 
1272   // Add the new node to the work list.
1273   Engine.enqueueStmtNode(NewNode, CalleeSF->getCallSiteBlock(),
1274                                   CalleeSF->getIndex());
1275   NumTimesRetriedWithoutInlining++;
1276   return true;
1277 }
1278 
1279 /// Block entrance.  (Update counters).
processCFGBlockEntrance(const BlockEdge & L,NodeBuilderWithSinks & nodeBuilder,ExplodedNode * Pred)1280 void ExprEngine::processCFGBlockEntrance(const BlockEdge &L,
1281                                          NodeBuilderWithSinks &nodeBuilder,
1282                                          ExplodedNode *Pred) {
1283   PrettyStackTraceLocationContext CrashInfo(Pred->getLocationContext());
1284 
1285   // FIXME: Refactor this into a checker.
1286   if (nodeBuilder.getContext().blockCount() >= AMgr.options.maxBlockVisitOnPath) {
1287     static SimpleProgramPointTag tag(TagProviderName, "Block count exceeded");
1288     const ExplodedNode *Sink =
1289                    nodeBuilder.generateSink(Pred->getState(), Pred, &tag);
1290 
1291     // Check if we stopped at the top level function or not.
1292     // Root node should have the location context of the top most function.
1293     const LocationContext *CalleeLC = Pred->getLocation().getLocationContext();
1294     const LocationContext *CalleeSF = CalleeLC->getCurrentStackFrame();
1295     const LocationContext *RootLC =
1296                         (*G.roots_begin())->getLocation().getLocationContext();
1297     if (RootLC->getCurrentStackFrame() != CalleeSF) {
1298       Engine.FunctionSummaries->markReachedMaxBlockCount(CalleeSF->getDecl());
1299 
1300       // Re-run the call evaluation without inlining it, by storing the
1301       // no-inlining policy in the state and enqueuing the new work item on
1302       // the list. Replay should almost never fail. Use the stats to catch it
1303       // if it does.
1304       if ((!AMgr.options.NoRetryExhausted &&
1305            replayWithoutInlining(Pred, CalleeLC)))
1306         return;
1307       NumMaxBlockCountReachedInInlined++;
1308     } else
1309       NumMaxBlockCountReached++;
1310 
1311     // Make sink nodes as exhausted(for stats) only if retry failed.
1312     Engine.blocksExhausted.push_back(std::make_pair(L, Sink));
1313   }
1314 }
1315 
1316 //===----------------------------------------------------------------------===//
1317 // Branch processing.
1318 //===----------------------------------------------------------------------===//
1319 
1320 /// RecoverCastedSymbol - A helper function for ProcessBranch that is used
1321 /// to try to recover some path-sensitivity for casts of symbolic
1322 /// integers that promote their values (which are currently not tracked well).
1323 /// This function returns the SVal bound to Condition->IgnoreCasts if all the
1324 //  cast(s) did was sign-extend the original value.
RecoverCastedSymbol(ProgramStateManager & StateMgr,ProgramStateRef state,const Stmt * Condition,const LocationContext * LCtx,ASTContext & Ctx)1325 static SVal RecoverCastedSymbol(ProgramStateManager& StateMgr,
1326                                 ProgramStateRef state,
1327                                 const Stmt *Condition,
1328                                 const LocationContext *LCtx,
1329                                 ASTContext &Ctx) {
1330 
1331   const Expr *Ex = dyn_cast<Expr>(Condition);
1332   if (!Ex)
1333     return UnknownVal();
1334 
1335   uint64_t bits = 0;
1336   bool bitsInit = false;
1337 
1338   while (const CastExpr *CE = dyn_cast<CastExpr>(Ex)) {
1339     QualType T = CE->getType();
1340 
1341     if (!T->isIntegralOrEnumerationType())
1342       return UnknownVal();
1343 
1344     uint64_t newBits = Ctx.getTypeSize(T);
1345     if (!bitsInit || newBits < bits) {
1346       bitsInit = true;
1347       bits = newBits;
1348     }
1349 
1350     Ex = CE->getSubExpr();
1351   }
1352 
1353   // We reached a non-cast.  Is it a symbolic value?
1354   QualType T = Ex->getType();
1355 
1356   if (!bitsInit || !T->isIntegralOrEnumerationType() ||
1357       Ctx.getTypeSize(T) > bits)
1358     return UnknownVal();
1359 
1360   return state->getSVal(Ex, LCtx);
1361 }
1362 
1363 #ifndef NDEBUG
getRightmostLeaf(const Stmt * Condition)1364 static const Stmt *getRightmostLeaf(const Stmt *Condition) {
1365   while (Condition) {
1366     const BinaryOperator *BO = dyn_cast<BinaryOperator>(Condition);
1367     if (!BO || !BO->isLogicalOp()) {
1368       return Condition;
1369     }
1370     Condition = BO->getRHS()->IgnoreParens();
1371   }
1372   return nullptr;
1373 }
1374 #endif
1375 
1376 // Returns the condition the branch at the end of 'B' depends on and whose value
1377 // has been evaluated within 'B'.
1378 // In most cases, the terminator condition of 'B' will be evaluated fully in
1379 // the last statement of 'B'; in those cases, the resolved condition is the
1380 // given 'Condition'.
1381 // If the condition of the branch is a logical binary operator tree, the CFG is
1382 // optimized: in that case, we know that the expression formed by all but the
1383 // rightmost leaf of the logical binary operator tree must be true, and thus
1384 // the branch condition is at this point equivalent to the truth value of that
1385 // rightmost leaf; the CFG block thus only evaluates this rightmost leaf
1386 // expression in its final statement. As the full condition in that case was
1387 // not evaluated, and is thus not in the SVal cache, we need to use that leaf
1388 // expression to evaluate the truth value of the condition in the current state
1389 // space.
ResolveCondition(const Stmt * Condition,const CFGBlock * B)1390 static const Stmt *ResolveCondition(const Stmt *Condition,
1391                                     const CFGBlock *B) {
1392   if (const Expr *Ex = dyn_cast<Expr>(Condition))
1393     Condition = Ex->IgnoreParens();
1394 
1395   const BinaryOperator *BO = dyn_cast<BinaryOperator>(Condition);
1396   if (!BO || !BO->isLogicalOp())
1397     return Condition;
1398 
1399   // FIXME: This is a workaround until we handle temporary destructor branches
1400   // correctly; currently, temporary destructor branches lead to blocks that
1401   // only have a terminator (and no statements). These blocks violate the
1402   // invariant this function assumes.
1403   if (B->getTerminator().isTemporaryDtorsBranch()) return Condition;
1404 
1405   // For logical operations, we still have the case where some branches
1406   // use the traditional "merge" approach and others sink the branch
1407   // directly into the basic blocks representing the logical operation.
1408   // We need to distinguish between those two cases here.
1409 
1410   // The invariants are still shifting, but it is possible that the
1411   // last element in a CFGBlock is not a CFGStmt.  Look for the last
1412   // CFGStmt as the value of the condition.
1413   CFGBlock::const_reverse_iterator I = B->rbegin(), E = B->rend();
1414   for (; I != E; ++I) {
1415     CFGElement Elem = *I;
1416     Optional<CFGStmt> CS = Elem.getAs<CFGStmt>();
1417     if (!CS)
1418       continue;
1419     const Stmt *LastStmt = CS->getStmt();
1420     assert(LastStmt == Condition || LastStmt == getRightmostLeaf(Condition));
1421     return LastStmt;
1422   }
1423   llvm_unreachable("could not resolve condition");
1424 }
1425 
processBranch(const Stmt * Condition,const Stmt * Term,NodeBuilderContext & BldCtx,ExplodedNode * Pred,ExplodedNodeSet & Dst,const CFGBlock * DstT,const CFGBlock * DstF)1426 void ExprEngine::processBranch(const Stmt *Condition, const Stmt *Term,
1427                                NodeBuilderContext& BldCtx,
1428                                ExplodedNode *Pred,
1429                                ExplodedNodeSet &Dst,
1430                                const CFGBlock *DstT,
1431                                const CFGBlock *DstF) {
1432   const LocationContext *LCtx = Pred->getLocationContext();
1433   PrettyStackTraceLocationContext StackCrashInfo(LCtx);
1434   currBldrCtx = &BldCtx;
1435 
1436   // Check for NULL conditions; e.g. "for(;;)"
1437   if (!Condition) {
1438     BranchNodeBuilder NullCondBldr(Pred, Dst, BldCtx, DstT, DstF);
1439     NullCondBldr.markInfeasible(false);
1440     NullCondBldr.generateNode(Pred->getState(), true, Pred);
1441     return;
1442   }
1443 
1444 
1445   if (const Expr *Ex = dyn_cast<Expr>(Condition))
1446     Condition = Ex->IgnoreParens();
1447 
1448   Condition = ResolveCondition(Condition, BldCtx.getBlock());
1449   PrettyStackTraceLoc CrashInfo(getContext().getSourceManager(),
1450                                 Condition->getLocStart(),
1451                                 "Error evaluating branch");
1452 
1453   ExplodedNodeSet CheckersOutSet;
1454   getCheckerManager().runCheckersForBranchCondition(Condition, CheckersOutSet,
1455                                                     Pred, *this);
1456   // We generated only sinks.
1457   if (CheckersOutSet.empty())
1458     return;
1459 
1460   BranchNodeBuilder builder(CheckersOutSet, Dst, BldCtx, DstT, DstF);
1461   for (NodeBuilder::iterator I = CheckersOutSet.begin(),
1462                              E = CheckersOutSet.end(); E != I; ++I) {
1463     ExplodedNode *PredI = *I;
1464 
1465     if (PredI->isSink())
1466       continue;
1467 
1468     ProgramStateRef PrevState = PredI->getState();
1469     SVal X = PrevState->getSVal(Condition, PredI->getLocationContext());
1470 
1471     if (X.isUnknownOrUndef()) {
1472       // Give it a chance to recover from unknown.
1473       if (const Expr *Ex = dyn_cast<Expr>(Condition)) {
1474         if (Ex->getType()->isIntegralOrEnumerationType()) {
1475           // Try to recover some path-sensitivity.  Right now casts of symbolic
1476           // integers that promote their values are currently not tracked well.
1477           // If 'Condition' is such an expression, try and recover the
1478           // underlying value and use that instead.
1479           SVal recovered = RecoverCastedSymbol(getStateManager(),
1480                                                PrevState, Condition,
1481                                                PredI->getLocationContext(),
1482                                                getContext());
1483 
1484           if (!recovered.isUnknown()) {
1485             X = recovered;
1486           }
1487         }
1488       }
1489     }
1490 
1491     // If the condition is still unknown, give up.
1492     if (X.isUnknownOrUndef()) {
1493       builder.generateNode(PrevState, true, PredI);
1494       builder.generateNode(PrevState, false, PredI);
1495       continue;
1496     }
1497 
1498     DefinedSVal V = X.castAs<DefinedSVal>();
1499 
1500     ProgramStateRef StTrue, StFalse;
1501     std::tie(StTrue, StFalse) = PrevState->assume(V);
1502 
1503     // Process the true branch.
1504     if (builder.isFeasible(true)) {
1505       if (StTrue)
1506         builder.generateNode(StTrue, true, PredI);
1507       else
1508         builder.markInfeasible(true);
1509     }
1510 
1511     // Process the false branch.
1512     if (builder.isFeasible(false)) {
1513       if (StFalse)
1514         builder.generateNode(StFalse, false, PredI);
1515       else
1516         builder.markInfeasible(false);
1517     }
1518   }
1519   currBldrCtx = nullptr;
1520 }
1521 
1522 /// The GDM component containing the set of global variables which have been
1523 /// previously initialized with explicit initializers.
REGISTER_TRAIT_WITH_PROGRAMSTATE(InitializedGlobalsSet,llvm::ImmutableSet<const VarDecl * >)1524 REGISTER_TRAIT_WITH_PROGRAMSTATE(InitializedGlobalsSet,
1525                                  llvm::ImmutableSet<const VarDecl *>)
1526 
1527 void ExprEngine::processStaticInitializer(const DeclStmt *DS,
1528                                           NodeBuilderContext &BuilderCtx,
1529                                           ExplodedNode *Pred,
1530                                           clang::ento::ExplodedNodeSet &Dst,
1531                                           const CFGBlock *DstT,
1532                                           const CFGBlock *DstF) {
1533   PrettyStackTraceLocationContext CrashInfo(Pred->getLocationContext());
1534   currBldrCtx = &BuilderCtx;
1535 
1536   const VarDecl *VD = cast<VarDecl>(DS->getSingleDecl());
1537   ProgramStateRef state = Pred->getState();
1538   bool initHasRun = state->contains<InitializedGlobalsSet>(VD);
1539   BranchNodeBuilder builder(Pred, Dst, BuilderCtx, DstT, DstF);
1540 
1541   if (!initHasRun) {
1542     state = state->add<InitializedGlobalsSet>(VD);
1543   }
1544 
1545   builder.generateNode(state, initHasRun, Pred);
1546   builder.markInfeasible(!initHasRun);
1547 
1548   currBldrCtx = nullptr;
1549 }
1550 
1551 /// processIndirectGoto - Called by CoreEngine.  Used to generate successor
1552 ///  nodes by processing the 'effects' of a computed goto jump.
processIndirectGoto(IndirectGotoNodeBuilder & builder)1553 void ExprEngine::processIndirectGoto(IndirectGotoNodeBuilder &builder) {
1554 
1555   ProgramStateRef state = builder.getState();
1556   SVal V = state->getSVal(builder.getTarget(), builder.getLocationContext());
1557 
1558   // Three possibilities:
1559   //
1560   //   (1) We know the computed label.
1561   //   (2) The label is NULL (or some other constant), or Undefined.
1562   //   (3) We have no clue about the label.  Dispatch to all targets.
1563   //
1564 
1565   typedef IndirectGotoNodeBuilder::iterator iterator;
1566 
1567   if (Optional<loc::GotoLabel> LV = V.getAs<loc::GotoLabel>()) {
1568     const LabelDecl *L = LV->getLabel();
1569 
1570     for (iterator I = builder.begin(), E = builder.end(); I != E; ++I) {
1571       if (I.getLabel() == L) {
1572         builder.generateNode(I, state);
1573         return;
1574       }
1575     }
1576 
1577     llvm_unreachable("No block with label.");
1578   }
1579 
1580   if (V.getAs<loc::ConcreteInt>() || V.getAs<UndefinedVal>()) {
1581     // Dispatch to the first target and mark it as a sink.
1582     //ExplodedNode* N = builder.generateNode(builder.begin(), state, true);
1583     // FIXME: add checker visit.
1584     //    UndefBranches.insert(N);
1585     return;
1586   }
1587 
1588   // This is really a catch-all.  We don't support symbolics yet.
1589   // FIXME: Implement dispatch for symbolic pointers.
1590 
1591   for (iterator I=builder.begin(), E=builder.end(); I != E; ++I)
1592     builder.generateNode(I, state);
1593 }
1594 
1595 /// ProcessEndPath - Called by CoreEngine.  Used to generate end-of-path
1596 ///  nodes when the control reaches the end of a function.
processEndOfFunction(NodeBuilderContext & BC,ExplodedNode * Pred)1597 void ExprEngine::processEndOfFunction(NodeBuilderContext& BC,
1598                                       ExplodedNode *Pred) {
1599   PrettyStackTraceLocationContext CrashInfo(Pred->getLocationContext());
1600   StateMgr.EndPath(Pred->getState());
1601 
1602   ExplodedNodeSet Dst;
1603   if (Pred->getLocationContext()->inTopFrame()) {
1604     // Remove dead symbols.
1605     ExplodedNodeSet AfterRemovedDead;
1606     removeDeadOnEndOfFunction(BC, Pred, AfterRemovedDead);
1607 
1608     // Notify checkers.
1609     for (ExplodedNodeSet::iterator I = AfterRemovedDead.begin(),
1610         E = AfterRemovedDead.end(); I != E; ++I) {
1611       getCheckerManager().runCheckersForEndFunction(BC, Dst, *I, *this);
1612     }
1613   } else {
1614     getCheckerManager().runCheckersForEndFunction(BC, Dst, Pred, *this);
1615   }
1616 
1617   Engine.enqueueEndOfFunction(Dst);
1618 }
1619 
1620 /// ProcessSwitch - Called by CoreEngine.  Used to generate successor
1621 ///  nodes by processing the 'effects' of a switch statement.
processSwitch(SwitchNodeBuilder & builder)1622 void ExprEngine::processSwitch(SwitchNodeBuilder& builder) {
1623   typedef SwitchNodeBuilder::iterator iterator;
1624   ProgramStateRef state = builder.getState();
1625   const Expr *CondE = builder.getCondition();
1626   SVal  CondV_untested = state->getSVal(CondE, builder.getLocationContext());
1627 
1628   if (CondV_untested.isUndef()) {
1629     //ExplodedNode* N = builder.generateDefaultCaseNode(state, true);
1630     // FIXME: add checker
1631     //UndefBranches.insert(N);
1632 
1633     return;
1634   }
1635   DefinedOrUnknownSVal CondV = CondV_untested.castAs<DefinedOrUnknownSVal>();
1636 
1637   ProgramStateRef DefaultSt = state;
1638 
1639   iterator I = builder.begin(), EI = builder.end();
1640   bool defaultIsFeasible = I == EI;
1641 
1642   for ( ; I != EI; ++I) {
1643     // Successor may be pruned out during CFG construction.
1644     if (!I.getBlock())
1645       continue;
1646 
1647     const CaseStmt *Case = I.getCase();
1648 
1649     // Evaluate the LHS of the case value.
1650     llvm::APSInt V1 = Case->getLHS()->EvaluateKnownConstInt(getContext());
1651     assert(V1.getBitWidth() == getContext().getTypeSize(CondE->getType()));
1652 
1653     // Get the RHS of the case, if it exists.
1654     llvm::APSInt V2;
1655     if (const Expr *E = Case->getRHS())
1656       V2 = E->EvaluateKnownConstInt(getContext());
1657     else
1658       V2 = V1;
1659 
1660     // FIXME: Eventually we should replace the logic below with a range
1661     //  comparison, rather than concretize the values within the range.
1662     //  This should be easy once we have "ranges" for NonLVals.
1663 
1664     do {
1665       nonloc::ConcreteInt CaseVal(getBasicVals().getValue(V1));
1666       DefinedOrUnknownSVal Res = svalBuilder.evalEQ(DefaultSt ? DefaultSt : state,
1667                                                CondV, CaseVal);
1668 
1669       // Now "assume" that the case matches.
1670       if (ProgramStateRef stateNew = state->assume(Res, true)) {
1671         builder.generateCaseStmtNode(I, stateNew);
1672 
1673         // If CondV evaluates to a constant, then we know that this
1674         // is the *only* case that we can take, so stop evaluating the
1675         // others.
1676         if (CondV.getAs<nonloc::ConcreteInt>())
1677           return;
1678       }
1679 
1680       // Now "assume" that the case doesn't match.  Add this state
1681       // to the default state (if it is feasible).
1682       if (DefaultSt) {
1683         if (ProgramStateRef stateNew = DefaultSt->assume(Res, false)) {
1684           defaultIsFeasible = true;
1685           DefaultSt = stateNew;
1686         }
1687         else {
1688           defaultIsFeasible = false;
1689           DefaultSt = nullptr;
1690         }
1691       }
1692 
1693       // Concretize the next value in the range.
1694       if (V1 == V2)
1695         break;
1696 
1697       ++V1;
1698       assert (V1 <= V2);
1699 
1700     } while (true);
1701   }
1702 
1703   if (!defaultIsFeasible)
1704     return;
1705 
1706   // If we have switch(enum value), the default branch is not
1707   // feasible if all of the enum constants not covered by 'case:' statements
1708   // are not feasible values for the switch condition.
1709   //
1710   // Note that this isn't as accurate as it could be.  Even if there isn't
1711   // a case for a particular enum value as long as that enum value isn't
1712   // feasible then it shouldn't be considered for making 'default:' reachable.
1713   const SwitchStmt *SS = builder.getSwitch();
1714   const Expr *CondExpr = SS->getCond()->IgnoreParenImpCasts();
1715   if (CondExpr->getType()->getAs<EnumType>()) {
1716     if (SS->isAllEnumCasesCovered())
1717       return;
1718   }
1719 
1720   builder.generateDefaultCaseNode(DefaultSt);
1721 }
1722 
1723 //===----------------------------------------------------------------------===//
1724 // Transfer functions: Loads and stores.
1725 //===----------------------------------------------------------------------===//
1726 
VisitCommonDeclRefExpr(const Expr * Ex,const NamedDecl * D,ExplodedNode * Pred,ExplodedNodeSet & Dst)1727 void ExprEngine::VisitCommonDeclRefExpr(const Expr *Ex, const NamedDecl *D,
1728                                         ExplodedNode *Pred,
1729                                         ExplodedNodeSet &Dst) {
1730   StmtNodeBuilder Bldr(Pred, Dst, *currBldrCtx);
1731 
1732   ProgramStateRef state = Pred->getState();
1733   const LocationContext *LCtx = Pred->getLocationContext();
1734 
1735   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1736     // C permits "extern void v", and if you cast the address to a valid type,
1737     // you can even do things with it. We simply pretend
1738     assert(Ex->isGLValue() || VD->getType()->isVoidType());
1739     SVal V = state->getLValue(VD, Pred->getLocationContext());
1740 
1741     // For references, the 'lvalue' is the pointer address stored in the
1742     // reference region.
1743     if (VD->getType()->isReferenceType()) {
1744       if (const MemRegion *R = V.getAsRegion())
1745         V = state->getSVal(R);
1746       else
1747         V = UnknownVal();
1748     }
1749 
1750     Bldr.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V), nullptr,
1751                       ProgramPoint::PostLValueKind);
1752     return;
1753   }
1754   if (const EnumConstantDecl *ED = dyn_cast<EnumConstantDecl>(D)) {
1755     assert(!Ex->isGLValue());
1756     SVal V = svalBuilder.makeIntVal(ED->getInitVal());
1757     Bldr.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V));
1758     return;
1759   }
1760   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1761     SVal V = svalBuilder.getFunctionPointer(FD);
1762     Bldr.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V), nullptr,
1763                       ProgramPoint::PostLValueKind);
1764     return;
1765   }
1766   if (isa<FieldDecl>(D)) {
1767     // FIXME: Compute lvalue of field pointers-to-member.
1768     // Right now we just use a non-null void pointer, so that it gives proper
1769     // results in boolean contexts.
1770     SVal V = svalBuilder.conjureSymbolVal(Ex, LCtx, getContext().VoidPtrTy,
1771                                           currBldrCtx->blockCount());
1772     state = state->assume(V.castAs<DefinedOrUnknownSVal>(), true);
1773     Bldr.generateNode(Ex, Pred, state->BindExpr(Ex, LCtx, V), nullptr,
1774 		      ProgramPoint::PostLValueKind);
1775     return;
1776   }
1777 
1778   llvm_unreachable("Support for this Decl not implemented.");
1779 }
1780 
1781 /// VisitArraySubscriptExpr - Transfer function for array accesses
VisitLvalArraySubscriptExpr(const ArraySubscriptExpr * A,ExplodedNode * Pred,ExplodedNodeSet & Dst)1782 void ExprEngine::VisitLvalArraySubscriptExpr(const ArraySubscriptExpr *A,
1783                                              ExplodedNode *Pred,
1784                                              ExplodedNodeSet &Dst){
1785 
1786   const Expr *Base = A->getBase()->IgnoreParens();
1787   const Expr *Idx  = A->getIdx()->IgnoreParens();
1788 
1789 
1790   ExplodedNodeSet checkerPreStmt;
1791   getCheckerManager().runCheckersForPreStmt(checkerPreStmt, Pred, A, *this);
1792 
1793   StmtNodeBuilder Bldr(checkerPreStmt, Dst, *currBldrCtx);
1794 
1795   for (ExplodedNodeSet::iterator it = checkerPreStmt.begin(),
1796                                  ei = checkerPreStmt.end(); it != ei; ++it) {
1797     const LocationContext *LCtx = (*it)->getLocationContext();
1798     ProgramStateRef state = (*it)->getState();
1799     SVal V = state->getLValue(A->getType(),
1800                               state->getSVal(Idx, LCtx),
1801                               state->getSVal(Base, LCtx));
1802     assert(A->isGLValue());
1803     Bldr.generateNode(A, *it, state->BindExpr(A, LCtx, V), nullptr,
1804                       ProgramPoint::PostLValueKind);
1805   }
1806 }
1807 
1808 /// VisitMemberExpr - Transfer function for member expressions.
VisitMemberExpr(const MemberExpr * M,ExplodedNode * Pred,ExplodedNodeSet & Dst)1809 void ExprEngine::VisitMemberExpr(const MemberExpr *M, ExplodedNode *Pred,
1810                                  ExplodedNodeSet &Dst) {
1811 
1812   // FIXME: Prechecks eventually go in ::Visit().
1813   ExplodedNodeSet CheckedSet;
1814   getCheckerManager().runCheckersForPreStmt(CheckedSet, Pred, M, *this);
1815 
1816   ExplodedNodeSet EvalSet;
1817   ValueDecl *Member = M->getMemberDecl();
1818 
1819   // Handle static member variables and enum constants accessed via
1820   // member syntax.
1821   if (isa<VarDecl>(Member) || isa<EnumConstantDecl>(Member)) {
1822     ExplodedNodeSet Dst;
1823     for (ExplodedNodeSet::iterator I = CheckedSet.begin(), E = CheckedSet.end();
1824          I != E; ++I) {
1825       VisitCommonDeclRefExpr(M, Member, Pred, EvalSet);
1826     }
1827   } else {
1828     StmtNodeBuilder Bldr(CheckedSet, EvalSet, *currBldrCtx);
1829     ExplodedNodeSet Tmp;
1830 
1831     for (ExplodedNodeSet::iterator I = CheckedSet.begin(), E = CheckedSet.end();
1832          I != E; ++I) {
1833       ProgramStateRef state = (*I)->getState();
1834       const LocationContext *LCtx = (*I)->getLocationContext();
1835       Expr *BaseExpr = M->getBase();
1836 
1837       // Handle C++ method calls.
1838       if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Member)) {
1839         if (MD->isInstance())
1840           state = createTemporaryRegionIfNeeded(state, LCtx, BaseExpr);
1841 
1842         SVal MDVal = svalBuilder.getFunctionPointer(MD);
1843         state = state->BindExpr(M, LCtx, MDVal);
1844 
1845         Bldr.generateNode(M, *I, state);
1846         continue;
1847       }
1848 
1849       // Handle regular struct fields / member variables.
1850       state = createTemporaryRegionIfNeeded(state, LCtx, BaseExpr);
1851       SVal baseExprVal = state->getSVal(BaseExpr, LCtx);
1852 
1853       FieldDecl *field = cast<FieldDecl>(Member);
1854       SVal L = state->getLValue(field, baseExprVal);
1855 
1856       if (M->isGLValue() || M->getType()->isArrayType()) {
1857         // We special-case rvalues of array type because the analyzer cannot
1858         // reason about them, since we expect all regions to be wrapped in Locs.
1859         // We instead treat these as lvalues and assume that they will decay to
1860         // pointers as soon as they are used.
1861         if (!M->isGLValue()) {
1862           assert(M->getType()->isArrayType());
1863           const ImplicitCastExpr *PE =
1864             dyn_cast<ImplicitCastExpr>((*I)->getParentMap().getParent(M));
1865           if (!PE || PE->getCastKind() != CK_ArrayToPointerDecay) {
1866             llvm_unreachable("should always be wrapped in ArrayToPointerDecay");
1867           }
1868         }
1869 
1870         if (field->getType()->isReferenceType()) {
1871           if (const MemRegion *R = L.getAsRegion())
1872             L = state->getSVal(R);
1873           else
1874             L = UnknownVal();
1875         }
1876 
1877         Bldr.generateNode(M, *I, state->BindExpr(M, LCtx, L), nullptr,
1878                           ProgramPoint::PostLValueKind);
1879       } else {
1880         Bldr.takeNodes(*I);
1881         evalLoad(Tmp, M, M, *I, state, L);
1882         Bldr.addNodes(Tmp);
1883       }
1884     }
1885   }
1886 
1887   getCheckerManager().runCheckersForPostStmt(Dst, EvalSet, M, *this);
1888 }
1889 
1890 namespace {
1891 class CollectReachableSymbolsCallback : public SymbolVisitor {
1892   InvalidatedSymbols Symbols;
1893 public:
CollectReachableSymbolsCallback(ProgramStateRef State)1894   CollectReachableSymbolsCallback(ProgramStateRef State) {}
getSymbols() const1895   const InvalidatedSymbols &getSymbols() const { return Symbols; }
1896 
VisitSymbol(SymbolRef Sym)1897   bool VisitSymbol(SymbolRef Sym) override {
1898     Symbols.insert(Sym);
1899     return true;
1900   }
1901 };
1902 } // end anonymous namespace
1903 
1904 // A value escapes in three possible cases:
1905 // (1) We are binding to something that is not a memory region.
1906 // (2) We are binding to a MemrRegion that does not have stack storage.
1907 // (3) We are binding to a MemRegion with stack storage that the store
1908 //     does not understand.
processPointerEscapedOnBind(ProgramStateRef State,SVal Loc,SVal Val)1909 ProgramStateRef ExprEngine::processPointerEscapedOnBind(ProgramStateRef State,
1910                                                         SVal Loc, SVal Val) {
1911   // Are we storing to something that causes the value to "escape"?
1912   bool escapes = true;
1913 
1914   // TODO: Move to StoreManager.
1915   if (Optional<loc::MemRegionVal> regionLoc = Loc.getAs<loc::MemRegionVal>()) {
1916     escapes = !regionLoc->getRegion()->hasStackStorage();
1917 
1918     if (!escapes) {
1919       // To test (3), generate a new state with the binding added.  If it is
1920       // the same state, then it escapes (since the store cannot represent
1921       // the binding).
1922       // Do this only if we know that the store is not supposed to generate the
1923       // same state.
1924       SVal StoredVal = State->getSVal(regionLoc->getRegion());
1925       if (StoredVal != Val)
1926         escapes = (State == (State->bindLoc(*regionLoc, Val)));
1927     }
1928   }
1929 
1930   // If our store can represent the binding and we aren't storing to something
1931   // that doesn't have local storage then just return and have the simulation
1932   // state continue as is.
1933   if (!escapes)
1934     return State;
1935 
1936   // Otherwise, find all symbols referenced by 'val' that we are tracking
1937   // and stop tracking them.
1938   CollectReachableSymbolsCallback Scanner =
1939       State->scanReachableSymbols<CollectReachableSymbolsCallback>(Val);
1940   const InvalidatedSymbols &EscapedSymbols = Scanner.getSymbols();
1941   State = getCheckerManager().runCheckersForPointerEscape(State,
1942                                                           EscapedSymbols,
1943                                                           /*CallEvent*/ nullptr,
1944                                                           PSK_EscapeOnBind,
1945                                                           nullptr);
1946 
1947   return State;
1948 }
1949 
1950 ProgramStateRef
notifyCheckersOfPointerEscape(ProgramStateRef State,const InvalidatedSymbols * Invalidated,ArrayRef<const MemRegion * > ExplicitRegions,ArrayRef<const MemRegion * > Regions,const CallEvent * Call,RegionAndSymbolInvalidationTraits & ITraits)1951 ExprEngine::notifyCheckersOfPointerEscape(ProgramStateRef State,
1952     const InvalidatedSymbols *Invalidated,
1953     ArrayRef<const MemRegion *> ExplicitRegions,
1954     ArrayRef<const MemRegion *> Regions,
1955     const CallEvent *Call,
1956     RegionAndSymbolInvalidationTraits &ITraits) {
1957 
1958   if (!Invalidated || Invalidated->empty())
1959     return State;
1960 
1961   if (!Call)
1962     return getCheckerManager().runCheckersForPointerEscape(State,
1963                                                            *Invalidated,
1964                                                            nullptr,
1965                                                            PSK_EscapeOther,
1966                                                            &ITraits);
1967 
1968   // If the symbols were invalidated by a call, we want to find out which ones
1969   // were invalidated directly due to being arguments to the call.
1970   InvalidatedSymbols SymbolsDirectlyInvalidated;
1971   for (ArrayRef<const MemRegion *>::iterator I = ExplicitRegions.begin(),
1972       E = ExplicitRegions.end(); I != E; ++I) {
1973     if (const SymbolicRegion *R = (*I)->StripCasts()->getAs<SymbolicRegion>())
1974       SymbolsDirectlyInvalidated.insert(R->getSymbol());
1975   }
1976 
1977   InvalidatedSymbols SymbolsIndirectlyInvalidated;
1978   for (InvalidatedSymbols::const_iterator I=Invalidated->begin(),
1979       E = Invalidated->end(); I!=E; ++I) {
1980     SymbolRef sym = *I;
1981     if (SymbolsDirectlyInvalidated.count(sym))
1982       continue;
1983     SymbolsIndirectlyInvalidated.insert(sym);
1984   }
1985 
1986   if (!SymbolsDirectlyInvalidated.empty())
1987     State = getCheckerManager().runCheckersForPointerEscape(State,
1988         SymbolsDirectlyInvalidated, Call, PSK_DirectEscapeOnCall, &ITraits);
1989 
1990   // Notify about the symbols that get indirectly invalidated by the call.
1991   if (!SymbolsIndirectlyInvalidated.empty())
1992     State = getCheckerManager().runCheckersForPointerEscape(State,
1993         SymbolsIndirectlyInvalidated, Call, PSK_IndirectEscapeOnCall, &ITraits);
1994 
1995   return State;
1996 }
1997 
1998 /// evalBind - Handle the semantics of binding a value to a specific location.
1999 ///  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)2000 void ExprEngine::evalBind(ExplodedNodeSet &Dst, const Stmt *StoreE,
2001                           ExplodedNode *Pred,
2002                           SVal location, SVal Val,
2003                           bool atDeclInit, const ProgramPoint *PP) {
2004 
2005   const LocationContext *LC = Pred->getLocationContext();
2006   PostStmt PS(StoreE, LC);
2007   if (!PP)
2008     PP = &PS;
2009 
2010   // Do a previsit of the bind.
2011   ExplodedNodeSet CheckedSet;
2012   getCheckerManager().runCheckersForBind(CheckedSet, Pred, location, Val,
2013                                          StoreE, *this, *PP);
2014 
2015 
2016   StmtNodeBuilder Bldr(CheckedSet, Dst, *currBldrCtx);
2017 
2018   // If the location is not a 'Loc', it will already be handled by
2019   // the checkers.  There is nothing left to do.
2020   if (!location.getAs<Loc>()) {
2021     const ProgramPoint L = PostStore(StoreE, LC, /*Loc*/nullptr,
2022                                      /*tag*/nullptr);
2023     ProgramStateRef state = Pred->getState();
2024     state = processPointerEscapedOnBind(state, location, Val);
2025     Bldr.generateNode(L, state, Pred);
2026     return;
2027   }
2028 
2029 
2030   for (ExplodedNodeSet::iterator I = CheckedSet.begin(), E = CheckedSet.end();
2031        I!=E; ++I) {
2032     ExplodedNode *PredI = *I;
2033     ProgramStateRef state = PredI->getState();
2034 
2035     state = processPointerEscapedOnBind(state, location, Val);
2036 
2037     // When binding the value, pass on the hint that this is a initialization.
2038     // For initializations, we do not need to inform clients of region
2039     // changes.
2040     state = state->bindLoc(location.castAs<Loc>(),
2041                            Val, /* notifyChanges = */ !atDeclInit);
2042 
2043     const MemRegion *LocReg = nullptr;
2044     if (Optional<loc::MemRegionVal> LocRegVal =
2045             location.getAs<loc::MemRegionVal>()) {
2046       LocReg = LocRegVal->getRegion();
2047     }
2048 
2049     const ProgramPoint L = PostStore(StoreE, LC, LocReg, nullptr);
2050     Bldr.generateNode(L, state, PredI);
2051   }
2052 }
2053 
2054 /// evalStore - Handle the semantics of a store via an assignment.
2055 ///  @param Dst The node set to store generated state nodes
2056 ///  @param AssignE The assignment expression if the store happens in an
2057 ///         assignment.
2058 ///  @param LocationE The location expression that is stored to.
2059 ///  @param state The current simulation state
2060 ///  @param location The location to store the value
2061 ///  @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)2062 void ExprEngine::evalStore(ExplodedNodeSet &Dst, const Expr *AssignE,
2063                              const Expr *LocationE,
2064                              ExplodedNode *Pred,
2065                              ProgramStateRef state, SVal location, SVal Val,
2066                              const ProgramPointTag *tag) {
2067   // Proceed with the store.  We use AssignE as the anchor for the PostStore
2068   // ProgramPoint if it is non-NULL, and LocationE otherwise.
2069   const Expr *StoreE = AssignE ? AssignE : LocationE;
2070 
2071   // Evaluate the location (checks for bad dereferences).
2072   ExplodedNodeSet Tmp;
2073   evalLocation(Tmp, AssignE, LocationE, Pred, state, location, tag, false);
2074 
2075   if (Tmp.empty())
2076     return;
2077 
2078   if (location.isUndef())
2079     return;
2080 
2081   for (ExplodedNodeSet::iterator NI=Tmp.begin(), NE=Tmp.end(); NI!=NE; ++NI)
2082     evalBind(Dst, StoreE, *NI, location, Val, false);
2083 }
2084 
evalLoad(ExplodedNodeSet & Dst,const Expr * NodeEx,const Expr * BoundEx,ExplodedNode * Pred,ProgramStateRef state,SVal location,const ProgramPointTag * tag,QualType LoadTy)2085 void ExprEngine::evalLoad(ExplodedNodeSet &Dst,
2086                           const Expr *NodeEx,
2087                           const Expr *BoundEx,
2088                           ExplodedNode *Pred,
2089                           ProgramStateRef state,
2090                           SVal location,
2091                           const ProgramPointTag *tag,
2092                           QualType LoadTy)
2093 {
2094   assert(!location.getAs<NonLoc>() && "location cannot be a NonLoc.");
2095 
2096   // Are we loading from a region?  This actually results in two loads; one
2097   // to fetch the address of the referenced value and one to fetch the
2098   // referenced value.
2099   if (const TypedValueRegion *TR =
2100         dyn_cast_or_null<TypedValueRegion>(location.getAsRegion())) {
2101 
2102     QualType ValTy = TR->getValueType();
2103     if (const ReferenceType *RT = ValTy->getAs<ReferenceType>()) {
2104       static SimpleProgramPointTag
2105              loadReferenceTag(TagProviderName, "Load Reference");
2106       ExplodedNodeSet Tmp;
2107       evalLoadCommon(Tmp, NodeEx, BoundEx, Pred, state,
2108                      location, &loadReferenceTag,
2109                      getContext().getPointerType(RT->getPointeeType()));
2110 
2111       // Perform the load from the referenced value.
2112       for (ExplodedNodeSet::iterator I=Tmp.begin(), E=Tmp.end() ; I!=E; ++I) {
2113         state = (*I)->getState();
2114         location = state->getSVal(BoundEx, (*I)->getLocationContext());
2115         evalLoadCommon(Dst, NodeEx, BoundEx, *I, state, location, tag, LoadTy);
2116       }
2117       return;
2118     }
2119   }
2120 
2121   evalLoadCommon(Dst, NodeEx, BoundEx, Pred, state, location, tag, LoadTy);
2122 }
2123 
evalLoadCommon(ExplodedNodeSet & Dst,const Expr * NodeEx,const Expr * BoundEx,ExplodedNode * Pred,ProgramStateRef state,SVal location,const ProgramPointTag * tag,QualType LoadTy)2124 void ExprEngine::evalLoadCommon(ExplodedNodeSet &Dst,
2125                                 const Expr *NodeEx,
2126                                 const Expr *BoundEx,
2127                                 ExplodedNode *Pred,
2128                                 ProgramStateRef state,
2129                                 SVal location,
2130                                 const ProgramPointTag *tag,
2131                                 QualType LoadTy) {
2132   assert(NodeEx);
2133   assert(BoundEx);
2134   // Evaluate the location (checks for bad dereferences).
2135   ExplodedNodeSet Tmp;
2136   evalLocation(Tmp, NodeEx, BoundEx, Pred, state, location, tag, true);
2137   if (Tmp.empty())
2138     return;
2139 
2140   StmtNodeBuilder Bldr(Tmp, Dst, *currBldrCtx);
2141   if (location.isUndef())
2142     return;
2143 
2144   // Proceed with the load.
2145   for (ExplodedNodeSet::iterator NI=Tmp.begin(), NE=Tmp.end(); NI!=NE; ++NI) {
2146     state = (*NI)->getState();
2147     const LocationContext *LCtx = (*NI)->getLocationContext();
2148 
2149     SVal V = UnknownVal();
2150     if (location.isValid()) {
2151       if (LoadTy.isNull())
2152         LoadTy = BoundEx->getType();
2153       V = state->getSVal(location.castAs<Loc>(), LoadTy);
2154     }
2155 
2156     Bldr.generateNode(NodeEx, *NI, state->BindExpr(BoundEx, LCtx, V), tag,
2157                       ProgramPoint::PostLoadKind);
2158   }
2159 }
2160 
evalLocation(ExplodedNodeSet & Dst,const Stmt * NodeEx,const Stmt * BoundEx,ExplodedNode * Pred,ProgramStateRef state,SVal location,const ProgramPointTag * tag,bool isLoad)2161 void ExprEngine::evalLocation(ExplodedNodeSet &Dst,
2162                               const Stmt *NodeEx,
2163                               const Stmt *BoundEx,
2164                               ExplodedNode *Pred,
2165                               ProgramStateRef state,
2166                               SVal location,
2167                               const ProgramPointTag *tag,
2168                               bool isLoad) {
2169   StmtNodeBuilder BldrTop(Pred, Dst, *currBldrCtx);
2170   // Early checks for performance reason.
2171   if (location.isUnknown()) {
2172     return;
2173   }
2174 
2175   ExplodedNodeSet Src;
2176   BldrTop.takeNodes(Pred);
2177   StmtNodeBuilder Bldr(Pred, Src, *currBldrCtx);
2178   if (Pred->getState() != state) {
2179     // Associate this new state with an ExplodedNode.
2180     // FIXME: If I pass null tag, the graph is incorrect, e.g for
2181     //   int *p;
2182     //   p = 0;
2183     //   *p = 0xDEADBEEF;
2184     // "p = 0" is not noted as "Null pointer value stored to 'p'" but
2185     // instead "int *p" is noted as
2186     // "Variable 'p' initialized to a null pointer value"
2187 
2188     static SimpleProgramPointTag tag(TagProviderName, "Location");
2189     Bldr.generateNode(NodeEx, Pred, state, &tag);
2190   }
2191   ExplodedNodeSet Tmp;
2192   getCheckerManager().runCheckersForLocation(Tmp, Src, location, isLoad,
2193                                              NodeEx, BoundEx, *this);
2194   BldrTop.addNodes(Tmp);
2195 }
2196 
2197 std::pair<const ProgramPointTag *, const ProgramPointTag*>
geteagerlyAssumeBinOpBifurcationTags()2198 ExprEngine::geteagerlyAssumeBinOpBifurcationTags() {
2199   static SimpleProgramPointTag
2200          eagerlyAssumeBinOpBifurcationTrue(TagProviderName,
2201                                            "Eagerly Assume True"),
2202          eagerlyAssumeBinOpBifurcationFalse(TagProviderName,
2203                                             "Eagerly Assume False");
2204   return std::make_pair(&eagerlyAssumeBinOpBifurcationTrue,
2205                         &eagerlyAssumeBinOpBifurcationFalse);
2206 }
2207 
evalEagerlyAssumeBinOpBifurcation(ExplodedNodeSet & Dst,ExplodedNodeSet & Src,const Expr * Ex)2208 void ExprEngine::evalEagerlyAssumeBinOpBifurcation(ExplodedNodeSet &Dst,
2209                                                    ExplodedNodeSet &Src,
2210                                                    const Expr *Ex) {
2211   StmtNodeBuilder Bldr(Src, Dst, *currBldrCtx);
2212 
2213   for (ExplodedNodeSet::iterator I=Src.begin(), E=Src.end(); I!=E; ++I) {
2214     ExplodedNode *Pred = *I;
2215     // Test if the previous node was as the same expression.  This can happen
2216     // when the expression fails to evaluate to anything meaningful and
2217     // (as an optimization) we don't generate a node.
2218     ProgramPoint P = Pred->getLocation();
2219     if (!P.getAs<PostStmt>() || P.castAs<PostStmt>().getStmt() != Ex) {
2220       continue;
2221     }
2222 
2223     ProgramStateRef state = Pred->getState();
2224     SVal V = state->getSVal(Ex, Pred->getLocationContext());
2225     Optional<nonloc::SymbolVal> SEV = V.getAs<nonloc::SymbolVal>();
2226     if (SEV && SEV->isExpression()) {
2227       const std::pair<const ProgramPointTag *, const ProgramPointTag*> &tags =
2228         geteagerlyAssumeBinOpBifurcationTags();
2229 
2230       ProgramStateRef StateTrue, StateFalse;
2231       std::tie(StateTrue, StateFalse) = state->assume(*SEV);
2232 
2233       // First assume that the condition is true.
2234       if (StateTrue) {
2235         SVal Val = svalBuilder.makeIntVal(1U, Ex->getType());
2236         StateTrue = StateTrue->BindExpr(Ex, Pred->getLocationContext(), Val);
2237         Bldr.generateNode(Ex, Pred, StateTrue, tags.first);
2238       }
2239 
2240       // Next, assume that the condition is false.
2241       if (StateFalse) {
2242         SVal Val = svalBuilder.makeIntVal(0U, Ex->getType());
2243         StateFalse = StateFalse->BindExpr(Ex, Pred->getLocationContext(), Val);
2244         Bldr.generateNode(Ex, Pred, StateFalse, tags.second);
2245       }
2246     }
2247   }
2248 }
2249 
VisitGCCAsmStmt(const GCCAsmStmt * A,ExplodedNode * Pred,ExplodedNodeSet & Dst)2250 void ExprEngine::VisitGCCAsmStmt(const GCCAsmStmt *A, ExplodedNode *Pred,
2251                                  ExplodedNodeSet &Dst) {
2252   StmtNodeBuilder Bldr(Pred, Dst, *currBldrCtx);
2253   // We have processed both the inputs and the outputs.  All of the outputs
2254   // should evaluate to Locs.  Nuke all of their values.
2255 
2256   // FIXME: Some day in the future it would be nice to allow a "plug-in"
2257   // which interprets the inline asm and stores proper results in the
2258   // outputs.
2259 
2260   ProgramStateRef state = Pred->getState();
2261 
2262   for (const Expr *O : A->outputs()) {
2263     SVal X = state->getSVal(O, Pred->getLocationContext());
2264     assert (!X.getAs<NonLoc>());  // Should be an Lval, or unknown, undef.
2265 
2266     if (Optional<Loc> LV = X.getAs<Loc>())
2267       state = state->bindLoc(*LV, UnknownVal());
2268   }
2269 
2270   Bldr.generateNode(A, Pred, state);
2271 }
2272 
VisitMSAsmStmt(const MSAsmStmt * A,ExplodedNode * Pred,ExplodedNodeSet & Dst)2273 void ExprEngine::VisitMSAsmStmt(const MSAsmStmt *A, ExplodedNode *Pred,
2274                                 ExplodedNodeSet &Dst) {
2275   StmtNodeBuilder Bldr(Pred, Dst, *currBldrCtx);
2276   Bldr.generateNode(A, Pred, Pred->getState());
2277 }
2278 
2279 //===----------------------------------------------------------------------===//
2280 // Visualization.
2281 //===----------------------------------------------------------------------===//
2282 
2283 #ifndef NDEBUG
2284 static ExprEngine* GraphPrintCheckerState;
2285 static SourceManager* GraphPrintSourceManager;
2286 
2287 namespace llvm {
2288 template<>
2289 struct DOTGraphTraits<ExplodedNode*> :
2290   public DefaultDOTGraphTraits {
2291 
DOTGraphTraitsllvm::DOTGraphTraits2292   DOTGraphTraits (bool isSimple=false) : DefaultDOTGraphTraits(isSimple) {}
2293 
2294   // FIXME: Since we do not cache error nodes in ExprEngine now, this does not
2295   // work.
getNodeAttributesllvm::DOTGraphTraits2296   static std::string getNodeAttributes(const ExplodedNode *N, void*) {
2297 
2298 #if 0
2299       // FIXME: Replace with a general scheme to tell if the node is
2300       // an error node.
2301     if (GraphPrintCheckerState->isImplicitNullDeref(N) ||
2302         GraphPrintCheckerState->isExplicitNullDeref(N) ||
2303         GraphPrintCheckerState->isUndefDeref(N) ||
2304         GraphPrintCheckerState->isUndefStore(N) ||
2305         GraphPrintCheckerState->isUndefControlFlow(N) ||
2306         GraphPrintCheckerState->isUndefResult(N) ||
2307         GraphPrintCheckerState->isBadCall(N) ||
2308         GraphPrintCheckerState->isUndefArg(N))
2309       return "color=\"red\",style=\"filled\"";
2310 
2311     if (GraphPrintCheckerState->isNoReturnCall(N))
2312       return "color=\"blue\",style=\"filled\"";
2313 #endif
2314     return "";
2315   }
2316 
printLocationllvm::DOTGraphTraits2317   static void printLocation(raw_ostream &Out, SourceLocation SLoc) {
2318     if (SLoc.isFileID()) {
2319       Out << "\\lline="
2320         << GraphPrintSourceManager->getExpansionLineNumber(SLoc)
2321         << " col="
2322         << GraphPrintSourceManager->getExpansionColumnNumber(SLoc)
2323         << "\\l";
2324     }
2325   }
2326 
getNodeLabelllvm::DOTGraphTraits2327   static std::string getNodeLabel(const ExplodedNode *N, void*){
2328 
2329     std::string sbuf;
2330     llvm::raw_string_ostream Out(sbuf);
2331 
2332     // Program Location.
2333     ProgramPoint Loc = N->getLocation();
2334 
2335     switch (Loc.getKind()) {
2336       case ProgramPoint::BlockEntranceKind: {
2337         Out << "Block Entrance: B"
2338             << Loc.castAs<BlockEntrance>().getBlock()->getBlockID();
2339         if (const NamedDecl *ND =
2340                     dyn_cast<NamedDecl>(Loc.getLocationContext()->getDecl())) {
2341           Out << " (";
2342           ND->printName(Out);
2343           Out << ")";
2344         }
2345         break;
2346       }
2347 
2348       case ProgramPoint::BlockExitKind:
2349         assert (false);
2350         break;
2351 
2352       case ProgramPoint::CallEnterKind:
2353         Out << "CallEnter";
2354         break;
2355 
2356       case ProgramPoint::CallExitBeginKind:
2357         Out << "CallExitBegin";
2358         break;
2359 
2360       case ProgramPoint::CallExitEndKind:
2361         Out << "CallExitEnd";
2362         break;
2363 
2364       case ProgramPoint::PostStmtPurgeDeadSymbolsKind:
2365         Out << "PostStmtPurgeDeadSymbols";
2366         break;
2367 
2368       case ProgramPoint::PreStmtPurgeDeadSymbolsKind:
2369         Out << "PreStmtPurgeDeadSymbols";
2370         break;
2371 
2372       case ProgramPoint::EpsilonKind:
2373         Out << "Epsilon Point";
2374         break;
2375 
2376       case ProgramPoint::PreImplicitCallKind: {
2377         ImplicitCallPoint PC = Loc.castAs<ImplicitCallPoint>();
2378         Out << "PreCall: ";
2379 
2380         // FIXME: Get proper printing options.
2381         PC.getDecl()->print(Out, LangOptions());
2382         printLocation(Out, PC.getLocation());
2383         break;
2384       }
2385 
2386       case ProgramPoint::PostImplicitCallKind: {
2387         ImplicitCallPoint PC = Loc.castAs<ImplicitCallPoint>();
2388         Out << "PostCall: ";
2389 
2390         // FIXME: Get proper printing options.
2391         PC.getDecl()->print(Out, LangOptions());
2392         printLocation(Out, PC.getLocation());
2393         break;
2394       }
2395 
2396       case ProgramPoint::PostInitializerKind: {
2397         Out << "PostInitializer: ";
2398         const CXXCtorInitializer *Init =
2399           Loc.castAs<PostInitializer>().getInitializer();
2400         if (const FieldDecl *FD = Init->getAnyMember())
2401           Out << *FD;
2402         else {
2403           QualType Ty = Init->getTypeSourceInfo()->getType();
2404           Ty = Ty.getLocalUnqualifiedType();
2405           LangOptions LO; // FIXME.
2406           Ty.print(Out, LO);
2407         }
2408         break;
2409       }
2410 
2411       case ProgramPoint::BlockEdgeKind: {
2412         const BlockEdge &E = Loc.castAs<BlockEdge>();
2413         Out << "Edge: (B" << E.getSrc()->getBlockID() << ", B"
2414             << E.getDst()->getBlockID()  << ')';
2415 
2416         if (const Stmt *T = E.getSrc()->getTerminator()) {
2417           SourceLocation SLoc = T->getLocStart();
2418 
2419           Out << "\\|Terminator: ";
2420           LangOptions LO; // FIXME.
2421           E.getSrc()->printTerminator(Out, LO);
2422 
2423           if (SLoc.isFileID()) {
2424             Out << "\\lline="
2425               << GraphPrintSourceManager->getExpansionLineNumber(SLoc)
2426               << " col="
2427               << GraphPrintSourceManager->getExpansionColumnNumber(SLoc);
2428           }
2429 
2430           if (isa<SwitchStmt>(T)) {
2431             const Stmt *Label = E.getDst()->getLabel();
2432 
2433             if (Label) {
2434               if (const CaseStmt *C = dyn_cast<CaseStmt>(Label)) {
2435                 Out << "\\lcase ";
2436                 LangOptions LO; // FIXME.
2437                 if (C->getLHS())
2438                   C->getLHS()->printPretty(Out, nullptr, PrintingPolicy(LO));
2439 
2440                 if (const Stmt *RHS = C->getRHS()) {
2441                   Out << " .. ";
2442                   RHS->printPretty(Out, nullptr, PrintingPolicy(LO));
2443                 }
2444 
2445                 Out << ":";
2446               }
2447               else {
2448                 assert (isa<DefaultStmt>(Label));
2449                 Out << "\\ldefault:";
2450               }
2451             }
2452             else
2453               Out << "\\l(implicit) default:";
2454           }
2455           else if (isa<IndirectGotoStmt>(T)) {
2456             // FIXME
2457           }
2458           else {
2459             Out << "\\lCondition: ";
2460             if (*E.getSrc()->succ_begin() == E.getDst())
2461               Out << "true";
2462             else
2463               Out << "false";
2464           }
2465 
2466           Out << "\\l";
2467         }
2468 
2469 #if 0
2470           // FIXME: Replace with a general scheme to determine
2471           // the name of the check.
2472         if (GraphPrintCheckerState->isUndefControlFlow(N)) {
2473           Out << "\\|Control-flow based on\\lUndefined value.\\l";
2474         }
2475 #endif
2476         break;
2477       }
2478 
2479       default: {
2480         const Stmt *S = Loc.castAs<StmtPoint>().getStmt();
2481         assert(S != nullptr && "Expecting non-null Stmt");
2482 
2483         Out << S->getStmtClassName() << ' ' << (const void*) S << ' ';
2484         LangOptions LO; // FIXME.
2485         S->printPretty(Out, nullptr, PrintingPolicy(LO));
2486         printLocation(Out, S->getLocStart());
2487 
2488         if (Loc.getAs<PreStmt>())
2489           Out << "\\lPreStmt\\l;";
2490         else if (Loc.getAs<PostLoad>())
2491           Out << "\\lPostLoad\\l;";
2492         else if (Loc.getAs<PostStore>())
2493           Out << "\\lPostStore\\l";
2494         else if (Loc.getAs<PostLValue>())
2495           Out << "\\lPostLValue\\l";
2496 
2497 #if 0
2498           // FIXME: Replace with a general scheme to determine
2499           // the name of the check.
2500         if (GraphPrintCheckerState->isImplicitNullDeref(N))
2501           Out << "\\|Implicit-Null Dereference.\\l";
2502         else if (GraphPrintCheckerState->isExplicitNullDeref(N))
2503           Out << "\\|Explicit-Null Dereference.\\l";
2504         else if (GraphPrintCheckerState->isUndefDeref(N))
2505           Out << "\\|Dereference of undefialied value.\\l";
2506         else if (GraphPrintCheckerState->isUndefStore(N))
2507           Out << "\\|Store to Undefined Loc.";
2508         else if (GraphPrintCheckerState->isUndefResult(N))
2509           Out << "\\|Result of operation is undefined.";
2510         else if (GraphPrintCheckerState->isNoReturnCall(N))
2511           Out << "\\|Call to function marked \"noreturn\".";
2512         else if (GraphPrintCheckerState->isBadCall(N))
2513           Out << "\\|Call to NULL/Undefined.";
2514         else if (GraphPrintCheckerState->isUndefArg(N))
2515           Out << "\\|Argument in call is undefined";
2516 #endif
2517 
2518         break;
2519       }
2520     }
2521 
2522     ProgramStateRef state = N->getState();
2523     Out << "\\|StateID: " << (const void*) state.get()
2524         << " NodeID: " << (const void*) N << "\\|";
2525     state->printDOT(Out);
2526 
2527     Out << "\\l";
2528 
2529     if (const ProgramPointTag *tag = Loc.getTag()) {
2530       Out << "\\|Tag: " << tag->getTagDescription();
2531       Out << "\\l";
2532     }
2533     return Out.str();
2534   }
2535 };
2536 } // end llvm namespace
2537 #endif
2538 
2539 #ifndef NDEBUG
2540 template <typename ITERATOR>
GetGraphNode(ITERATOR I)2541 ExplodedNode *GetGraphNode(ITERATOR I) { return *I; }
2542 
2543 template <> ExplodedNode*
GetGraphNode(llvm::DenseMap<ExplodedNode *,Expr * >::iterator I)2544 GetGraphNode<llvm::DenseMap<ExplodedNode*, Expr*>::iterator>
2545   (llvm::DenseMap<ExplodedNode*, Expr*>::iterator I) {
2546   return I->first;
2547 }
2548 #endif
2549 
ViewGraph(bool trim)2550 void ExprEngine::ViewGraph(bool trim) {
2551 #ifndef NDEBUG
2552   if (trim) {
2553     std::vector<const ExplodedNode*> Src;
2554 
2555     // Flush any outstanding reports to make sure we cover all the nodes.
2556     // This does not cause them to get displayed.
2557     for (BugReporter::iterator I=BR.begin(), E=BR.end(); I!=E; ++I)
2558       const_cast<BugType*>(*I)->FlushReports(BR);
2559 
2560     // Iterate through the reports and get their nodes.
2561     for (BugReporter::EQClasses_iterator
2562            EI = BR.EQClasses_begin(), EE = BR.EQClasses_end(); EI != EE; ++EI) {
2563       ExplodedNode *N = const_cast<ExplodedNode*>(EI->begin()->getErrorNode());
2564       if (N) Src.push_back(N);
2565     }
2566 
2567     ViewGraph(Src);
2568   }
2569   else {
2570     GraphPrintCheckerState = this;
2571     GraphPrintSourceManager = &getContext().getSourceManager();
2572 
2573     llvm::ViewGraph(*G.roots_begin(), "ExprEngine");
2574 
2575     GraphPrintCheckerState = nullptr;
2576     GraphPrintSourceManager = nullptr;
2577   }
2578 #endif
2579 }
2580 
ViewGraph(ArrayRef<const ExplodedNode * > Nodes)2581 void ExprEngine::ViewGraph(ArrayRef<const ExplodedNode*> Nodes) {
2582 #ifndef NDEBUG
2583   GraphPrintCheckerState = this;
2584   GraphPrintSourceManager = &getContext().getSourceManager();
2585 
2586   std::unique_ptr<ExplodedGraph> TrimmedG(G.trim(Nodes));
2587 
2588   if (!TrimmedG.get())
2589     llvm::errs() << "warning: Trimmed ExplodedGraph is empty.\n";
2590   else
2591     llvm::ViewGraph(*TrimmedG->roots_begin(), "TrimmedExprEngine");
2592 
2593   GraphPrintCheckerState = nullptr;
2594   GraphPrintSourceManager = nullptr;
2595 #endif
2596 }
2597