|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Declarations
tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h 59 class ExplodedNode;
tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h 38 class ExplodedNode;
tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugType.h 26 class ExplodedNode;
tools/clang/include/clang/StaticAnalyzer/Core/CheckerManager.h 45 class ExplodedNode;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SubEngine.h 35 class ExplodedNode;
References
include/llvm/ADT/DenseMapInfo.h 39 static inline T* getEmptyKey() {
41 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
45 static inline T* getTombstoneKey() {
47 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
51 static unsigned getHashValue(const T *PtrVal) {
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
include/llvm/ADT/FoldingSet.h 221 static void Profile(const T &X, FoldingSetNodeID &ID) {
224 static void Profile(T &X, FoldingSetNodeID &ID) {
232 static inline bool Equals(T &X, const FoldingSetNodeID &ID, unsigned IDHash,
240 static inline unsigned ComputeHash(T &X, FoldingSetNodeID &TempID);
250 : public DefaultFoldingSetTrait<T> {};
369 FoldingSetTrait<T>::Profile(X, TempID);
375 FoldingSetTrait<T>::Profile(X, TempID);
410 using iterator = FoldingSetIterator<T>;
415 using const_iterator = FoldingSetIterator<const T>;
420 using bucket_iterator = FoldingSetBucketIterator<T>;
432 bool RemoveNode(T *N) { return FoldingSetBase::RemoveNode(N); }
437 T *GetOrInsertNode(T *N) {
437 T *GetOrInsertNode(T *N) {
444 T *FindNodeOrInsertPos(const FoldingSetNodeID &ID, void *&InsertPos) {
451 void InsertNode(T *N, void *InsertPos) {
457 void InsertNode(T *N) {
473 template <class T> class FoldingSet final : public FoldingSetImpl<T> {
474 using Super = FoldingSetImpl<T>;
480 T *TN = static_cast<T *>(N);
481 FoldingSetTrait<T>::Profile(*TN, ID);
488 T *TN = static_cast<T *>(N);
489 return FoldingSetTrait<T>::Equals(*TN, ID, IDHash, TempID);
495 T *TN = static_cast<T *>(N);
496 return FoldingSetTrait<T>::ComputeHash(*TN, TempID);
640 T &operator*() const {
644 T *operator->() const {
include/llvm/Support/Allocator.h 81 template <typename T> T *Allocate(size_t Num = 1) {
82 return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
82 return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
include/llvm/Support/PointerLikeTypeTraits.h 56 static inline void *getAsVoidPointer(T *P) { return P; }
57 static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
59 enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
91 typedef PointerLikeTypeTraits<T *> NonConst;
93 static inline const void *getAsVoidPointer(const T *P) {
96 static inline const T *getFromVoidPointer(const void *P) {
tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h 82 virtual std::string getMessage(const ExplodedNode *N) = 0;
102 std::string getMessage(const ExplodedNode *N) override;
298 const ExplodedNode *ErrorNode = nullptr;
351 llvm::SmallSet<const ExplodedNode *, 4> TrackedConditions;
370 const ExplodedNode *errorNode)
376 const ExplodedNode *errorNode)
390 const ExplodedNode *errorNode,
403 const ExplodedNode *getErrorNode() const { return ErrorNode; }
507 bool addTrackedCondition(const ExplodedNode *Cond) {
524 const ExplodedNode *N) const {
tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h 61 virtual PathDiagnosticPieceRef VisitNode(const ExplodedNode *Succ,
68 const ExplodedNode *EndPathNode,
77 const ExplodedNode *N,
84 getDefaultEndPath(const BugReporterContext &BRC, const ExplodedNode *N,
114 bool trackExpressionValue(const ExplodedNode *N, const Expr *E,
159 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
185 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
191 bool isUnderconstrained(const ExplodedNode *N) const;
203 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
209 static const Expr *getNilReceiver(const Stmt *S, const ExplodedNode *N);
230 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
234 PathDiagnosticPieceRef VisitNodeImpl(const ExplodedNode *N,
239 VisitTerminator(const Stmt *Term, const ExplodedNode *N,
246 const ExplodedNode *N, bool TookTrue);
251 const ExplodedNode *N, bool TookTrue,
257 const ExplodedNode *N, bool TookTrue, bool IsAssuming);
262 const ExplodedNode *N, bool TookTrue,
268 const ExplodedNode *N, bool TookTrue);
280 const ExplodedNode *N, bool TookTrue, bool IsAssuming);
287 const ExplodedNode *N,
309 PathDiagnosticPieceRef VisitNode(const ExplodedNode *, BugReporterContext &,
314 void finalizeVisitor(BugReporterContext &BRC, const ExplodedNode *N,
336 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
357 SuppressInlineDefensiveChecksVisitor(DefinedSVal Val, const ExplodedNode *N);
365 PathDiagnosticPieceRef VisitNode(const ExplodedNode *Succ,
383 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
387 void finalizeVisitor(BugReporterContext &BRC, const ExplodedNode *EndPathNode,
397 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
tools/clang/include/clang/StaticAnalyzer/Core/Checker.h 556 ExplodedNode *SinkNode;
tools/clang/include/clang/StaticAnalyzer/Core/CheckerManager.h 309 ExplodedNode *Pred,
315 ExplodedNode *Pred,
321 ExplodedNodeSet &Dst, ExplodedNode *Pred,
327 ExplodedNode *Pred,
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h 26 ExplodedNode *Pred;
42 ExplodedNode *pred,
70 ExplodedNode *getPredecessor() { return Pred; }
136 static const MemRegion *getLocationRegionIfPostStore(const ExplodedNode *N) {
164 ExplodedNode *addTransition(ProgramStateRef State = nullptr,
176 ExplodedNode *addTransition(ProgramStateRef State,
177 ExplodedNode *Pred,
185 ExplodedNode *generateSink(ProgramStateRef State, ExplodedNode *Pred,
185 ExplodedNode *generateSink(ProgramStateRef State, ExplodedNode *Pred,
197 ExplodedNode *generateErrorNode(ProgramStateRef State = nullptr,
210 ExplodedNode *
324 ExplodedNode *addTransitionImpl(ProgramStateRef State,
326 ExplodedNode *P = nullptr,
348 ExplodedNode *node;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h 66 std::vector<std::pair<BlockEdge, const ExplodedNode *>>;
69 std::vector<std::pair<const CFGBlock *, const ExplodedNode *>>;
105 ExplodedNode *Pred);
107 void HandleBlockEdge(const BlockEdge &E, ExplodedNode *Pred);
108 void HandleBlockEntrance(const BlockEntrance &E, ExplodedNode *Pred);
109 void HandleBlockExit(const CFGBlock *B, ExplodedNode *Pred);
111 void HandleCallEnter(const CallEnter &CE, ExplodedNode *Pred);
113 void HandlePostStmt(const CFGBlock *B, unsigned StmtIdx, ExplodedNode *Pred);
116 ExplodedNode *Pred);
118 const CFGBlock *B, ExplodedNode *Pred);
122 ExplodedNode *Pred);
124 void HandleVirtualBaseBranch(const CFGBlock *B, ExplodedNode *Pred);
127 ExplodedNode *generateCallExitBeginNode(ExplodedNode *N,
127 ExplodedNode *generateCallExitBeginNode(ExplodedNode *N,
155 void dispatchWorkItem(ExplodedNode* Pred, ProgramPoint Loc,
167 void addAbortedBlock(const ExplodedNode *node, const CFGBlock *block) {
201 void enqueueStmtNode(ExplodedNode *N, const CFGBlock *Block, unsigned Idx);
212 NodeBuilderContext(const CoreEngine &E, const CFGBlock *B, ExplodedNode *N)
267 ExplodedNode *generateNodeImpl(const ProgramPoint &PP,
269 ExplodedNode *Pred,
273 NodeBuilder(ExplodedNode *SrcNode, ExplodedNodeSet &DstSet,
289 ExplodedNode *generateNode(const ProgramPoint &PP,
291 ExplodedNode *Pred) {
300 ExplodedNode *generateSink(const ProgramPoint &PP,
302 ExplodedNode *Pred) {
334 void takeNodes(ExplodedNode *N) { Frontier.erase(N); }
336 void addNodes(ExplodedNode *N) { Frontier.Add(N); }
345 SmallVector<ExplodedNode*, 2> sinksGenerated;
349 NodeBuilderWithSinks(ExplodedNode *Pred, ExplodedNodeSet &DstSet,
353 ExplodedNode *generateNode(ProgramStateRef State,
354 ExplodedNode *Pred,
360 ExplodedNode *generateSink(ProgramStateRef State, ExplodedNode *Pred,
360 ExplodedNode *generateSink(ProgramStateRef State, ExplodedNode *Pred,
363 ExplodedNode *N = NodeBuilder::generateSink(LocalLoc, State, Pred);
369 const SmallVectorImpl<ExplodedNode*> &getSinks() const {
385 StmtNodeBuilder(ExplodedNode *SrcNode, ExplodedNodeSet &DstSet,
407 ExplodedNode *generateNode(const Stmt *S,
408 ExplodedNode *Pred,
417 ExplodedNode *generateSink(const Stmt *S,
418 ExplodedNode *Pred,
440 BranchNodeBuilder(ExplodedNode *SrcNode, ExplodedNodeSet &DstSet,
458 ExplodedNode *generateNode(ProgramStateRef State, bool branch,
459 ExplodedNode *Pred);
482 ExplodedNode *Pred;
485 IndirectGotoNodeBuilder(ExplodedNode *pred, const CFGBlock *src,
512 ExplodedNode *generateNode(const iterator &I,
529 ExplodedNode *Pred;
532 SwitchNodeBuilder(ExplodedNode *pred, const CFGBlock *src,
564 ExplodedNode *generateCaseStmtNode(const iterator &I,
567 ExplodedNode *generateDefaultCaseNode(ProgramStateRef State,
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h 95 ExplodedNode * const *begin() const;
97 ExplodedNode * const *end() const;
106 void addNode(ExplodedNode *N, ExplodedGraph &G);
113 void replaceNode(ExplodedNode *node);
197 void addPredecessor(ExplodedNode *V, ExplodedGraph &G);
210 ExplodedNode *getFirstPred() {
214 const ExplodedNode *getFirstPred() const {
218 ExplodedNode *getFirstSucc() {
222 const ExplodedNode *getFirstSucc() const {
227 using succ_iterator = ExplodedNode * const *;
230 using const_succ_iterator = const ExplodedNode * const *;
233 using pred_iterator = ExplodedNode * const *;
236 using const_pred_iterator = const ExplodedNode * const *;
297 void replaceSuccessor(ExplodedNode *node) { Succs.replaceNode(node); }
298 void replacePredecessor(ExplodedNode *node) { Preds.replaceNode(node); }
302 llvm::DenseMap<const ExplodedNode *, const ExplodedNode *>;
302 llvm::DenseMap<const ExplodedNode *, const ExplodedNode *>;
309 using NodeVector = std::vector<ExplodedNode *>;
322 llvm::FoldingSet<ExplodedNode> Nodes;
353 ExplodedNode *getNode(const ProgramPoint &L, ProgramStateRef State,
361 ExplodedNode *createUncachedNode(const ProgramPoint &L,
371 ExplodedNode *addRoot(ExplodedNode *V) {
371 ExplodedNode *addRoot(ExplodedNode *V) {
377 ExplodedNode *addEndOfPath(ExplodedNode *V) {
377 ExplodedNode *addEndOfPath(ExplodedNode *V) {
391 using NodeTy = ExplodedNode;
392 using AllNodesTy = llvm::FoldingSet<ExplodedNode>;
427 using NodeMap = llvm::DenseMap<const ExplodedNode *, ExplodedNode *>;
427 using NodeMap = llvm::DenseMap<const ExplodedNode *, ExplodedNode *>;
459 bool shouldCollect(const ExplodedNode *node);
460 void collectNode(ExplodedNode *node);
464 using ImplTy = llvm::SmallSetVector<ExplodedNode *, 4>;
468 ExplodedNodeSet(ExplodedNode *N) {
475 void Add(ExplodedNode *N) {
484 bool erase(ExplodedNode *N) { return Impl.remove(N); }
512 using NodeRef = clang::ento::ExplodedNode *;
513 using ChildIteratorType = clang::ento::ExplodedNode::succ_iterator;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h 210 void GenerateAutoTransition(ExplodedNode *N);
212 void GenerateCallExitNode(ExplodedNode *N);
223 std::string DumpGraph(ArrayRef<const ExplodedNode *> Nodes,
231 void ViewGraph(ArrayRef<const ExplodedNode *> Nodes);
265 void removeDead(ExplodedNode *Node, ExplodedNodeSet &Out,
272 void processCFGElement(const CFGElement E, ExplodedNode *Pred,
275 void ProcessStmt(const Stmt *S, ExplodedNode *Pred);
277 void ProcessLoopExit(const Stmt* S, ExplodedNode *Pred);
279 void ProcessInitializer(const CFGInitializer I, ExplodedNode *Pred);
281 void ProcessImplicitDtor(const CFGImplicitDtor D, ExplodedNode *Pred);
283 void ProcessNewAllocator(const CXXNewExpr *NE, ExplodedNode *Pred);
286 ExplodedNode *Pred, ExplodedNodeSet &Dst);
288 ExplodedNode *Pred, ExplodedNodeSet &Dst);
290 ExplodedNode *Pred, ExplodedNodeSet &Dst);
292 ExplodedNode *Pred, ExplodedNodeSet &Dst);
294 ExplodedNode *Pred, ExplodedNodeSet &Dst);
299 ExplodedNode *Pred) override;
305 ExplodedNode *Pred,
315 ExplodedNode *Pred, ExplodedNodeSet &Dst,
323 ExplodedNode *Pred,
339 ExplodedNode *Pred, ExplodedNodeSet &Dst,
345 ExplodedNode *Pred,
350 ExplodedNode *Pred,
355 ExplodedNode *Pred) override;
359 void processCallExit(ExplodedNode *Pred) override;
413 void Visit(const Stmt *S, ExplodedNode *Pred, ExplodedNodeSet &Dst);
417 ExplodedNode *Pred,
421 void VisitGCCAsmStmt(const GCCAsmStmt *A, ExplodedNode *Pred,
425 void VisitMSAsmStmt(const MSAsmStmt *A, ExplodedNode *Pred,
429 void VisitBlockExpr(const BlockExpr *BE, ExplodedNode *Pred,
433 void VisitLambdaExpr(const LambdaExpr *LE, ExplodedNode *Pred,
437 void VisitBinaryOperator(const BinaryOperator* B, ExplodedNode *Pred,
442 void VisitCallExpr(const CallExpr *CE, ExplodedNode *Pred,
446 void VisitCast(const CastExpr *CastE, const Expr *Ex, ExplodedNode *Pred,
451 ExplodedNode *Pred, ExplodedNodeSet &Dst);
455 ExplodedNode *Pred, ExplodedNodeSet &Dst);
458 void VisitDeclStmt(const DeclStmt *DS, ExplodedNode *Pred,
463 ExplodedNode *Pred, ExplodedNodeSet &Dst);
465 void VisitInitListExpr(const InitListExpr *E, ExplodedNode *Pred,
469 void VisitLogicalExpr(const BinaryOperator* B, ExplodedNode *Pred,
473 void VisitMemberExpr(const MemberExpr *M, ExplodedNode *Pred,
477 void VisitAtomicExpr(const AtomicExpr *E, ExplodedNode *Pred,
482 ExplodedNode *Pred, ExplodedNodeSet &Dst);
485 void VisitLvalObjCIvarRefExpr(const ObjCIvarRefExpr *DR, ExplodedNode *Pred,
491 ExplodedNode *Pred, ExplodedNodeSet &Dst);
493 void VisitObjCMessage(const ObjCMessageExpr *ME, ExplodedNode *Pred,
497 void VisitReturnStmt(const ReturnStmt *R, ExplodedNode *Pred,
501 void VisitOffsetOfExpr(const OffsetOfExpr *Ex, ExplodedNode *Pred,
506 ExplodedNode *Pred, ExplodedNodeSet &Dst);
509 void VisitUnaryOperator(const UnaryOperator* B, ExplodedNode *Pred,
514 ExplodedNode *Pred,
521 void VisitCXXCatchStmt(const CXXCatchStmt *CS, ExplodedNode *Pred,
524 void VisitCXXThisExpr(const CXXThisExpr *TE, ExplodedNode *Pred,
527 void VisitCXXConstructExpr(const CXXConstructExpr *E, ExplodedNode *Pred,
532 ExplodedNode *Pred, ExplodedNodeSet &Dst,
536 ExplodedNode *Pred,
539 void VisitCXXNewExpr(const CXXNewExpr *CNE, ExplodedNode *Pred,
542 void VisitCXXDeleteExpr(const CXXDeleteExpr *CDE, ExplodedNode *Pred,
547 ExplodedNode *Pred,
571 ExplodedNode *Pred);
577 ExplodedNode *Pred);
611 void evalBind(ExplodedNodeSet &Dst, const Stmt *StoreE, ExplodedNode *Pred,
645 ExplodedNode *Pred,
654 ExplodedNode *Pred, ProgramStateRef St, SVal TargetLV, SVal Val,
671 void evalCall(ExplodedNodeSet &Dst, ExplodedNode *Pred,
675 void defaultEvalCall(NodeBuilder &B, ExplodedNode *Pred,
682 void finishArgumentConstruction(ExplodedNodeSet &Dst, ExplodedNode *Pred,
688 ExplodedNode *Pred,
697 ExplodedNode *Pred,
715 const ExplodedNode *Pred,
740 const ExplodedNode *Pred,
744 ExplodedNode *Pred, ProgramStateRef State);
749 ExplodedNode *Pred, ProgramStateRef State);
755 ExplodedNode *Pred);
757 bool replayWithoutInlining(ExplodedNode *P, const LocationContext *CalleeLC);
761 void performTrivialCopy(NodeBuilder &Bldr, ExplodedNode *Pred,
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/LoopUnrolling.h 40 ExplodedNode* Pred, unsigned maxVisitOnPath);
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SubEngine.h 62 virtual void processCFGElement(const CFGElement E, ExplodedNode* Pred,
70 ExplodedNode *Pred) = 0;
76 ExplodedNode *Pred,
86 ExplodedNode *Pred,
95 ExplodedNode *Pred,
111 ExplodedNode *Pred,
118 ExplodedNode *Pred,
123 ExplodedNode *Pred) = 0;
126 virtual void processCallExit(ExplodedNode *Pred) = 0;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/WorkList.h 28 ExplodedNode *node;
34 WorkListUnit(ExplodedNode *N, BlockCounter C,
41 explicit WorkListUnit(ExplodedNode *N, BlockCounter C)
48 ExplodedNode *getNode() const { return node; }
68 void enqueue(ExplodedNode *N, const CFGBlock *B, unsigned idx) {
72 void enqueue(ExplodedNode *N) {
tools/clang/lib/Analysis/plugins/SampleAnalyzer/MainCallChecker.cpp 32 ExplodedNode *N = C.generateErrorNode();
tools/clang/lib/StaticAnalyzer/Checkers/AnalyzerStatsChecker.cpp 48 const ExplodedNode *GraphRoot = *G.roots_begin();
tools/clang/lib/StaticAnalyzer/Checkers/ArrayBoundChecker.cpp 64 ExplodedNode *N = C.generateErrorNode(StOutBound);
tools/clang/lib/StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp 234 ExplodedNode *errorNode = checkerContext.generateErrorNode(errorState);
tools/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp 122 void generateBugReport(ExplodedNode *N,
143 if (ExplodedNode *N = C.generateErrorNode()) {
164 if (ExplodedNode *N = C.generateErrorNode()) {
206 void NilArgChecker::generateBugReport(ExplodedNode *N,
491 ExplodedNode *N = C.generateNonFatalErrorNode();
569 ExplodedNode *N = C.generateErrorNode(stateNull);
628 if (ExplodedNode *N = C.generateNonFatalErrorNode()) {
747 Optional<ExplodedNode*> errorNode;
956 static bool alreadyExecutedAtLeastOneLoopIteration(const ExplodedNode *N,
967 for (ExplodedNode::const_pred_iterator I = N->pred_begin(),
tools/clang/lib/StaticAnalyzer/Checkers/BlockInCriticalSectionChecker.cpp 168 ExplodedNode *ErrNode = C.generateNonFatalErrorNode();
tools/clang/lib/StaticAnalyzer/Checkers/BoolAssignmentChecker.cpp 34 if (ExplodedNode *N = C.generateNonFatalErrorNode(state)) {
tools/clang/lib/StaticAnalyzer/Checkers/CStringChecker.cpp 564 ExplodedNode *N = C.generateErrorNode(state);
583 if (ExplodedNode *N = C.generateErrorNode(State)) {
601 if (ExplodedNode *N = C.generateErrorNode(State)) {
623 if (ExplodedNode *N = C.generateNonFatalErrorNode(State)) {
639 if (ExplodedNode *N = C.generateErrorNode(State)) {
tools/clang/lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp 74 ExplodedNode *N) const;
94 ExplodedNode *N = C.generateErrorNode();
176 if (ExplodedNode *N = C.generateErrorNode()) {
249 if (ExplodedNode *N = C.generateErrorNode()) {
275 if (ExplodedNode *N = C.generateErrorNode()) {
350 ExplodedNode *N = C.generateErrorNode();
405 ExplodedNode *N = C.generateErrorNode();
460 if (ExplodedNode *N = C.generateErrorNode()) {
505 ExplodedNode *N) const {
578 if (ExplodedNode *N = C.generateErrorNode(state, &Tag))
tools/clang/lib/StaticAnalyzer/Checkers/CastSizeChecker.cpp 130 if (ExplodedNode *errorNode = C.generateErrorNode()) {
tools/clang/lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp 497 ExplodedNode *ErrNode = nullptr;
670 ExplodedNode *ErrNode = C.generateNonFatalErrorNode();
733 ExplodedNode *ErrNode = C.generateErrorNode();
tools/clang/lib/StaticAnalyzer/Checkers/ChrootChecker.cpp 125 if (ExplodedNode *N = C.generateNonFatalErrorNode()) {
tools/clang/lib/StaticAnalyzer/Checkers/ConversionChecker.cpp 52 void reportBug(ExplodedNode *N, CheckerContext &C, const char Msg[]) const;
107 ExplodedNode *N = C.generateNonFatalErrorNode(C.getState());
117 void ConversionChecker::reportBug(ExplodedNode *N, CheckerContext &C,
tools/clang/lib/StaticAnalyzer/Checkers/DebugCheckers.cpp 332 ExplodedNode *Node = C.generateNonFatalErrorNode();
tools/clang/lib/StaticAnalyzer/Checkers/DeleteWithNonVirtualDtorChecker.cpp 48 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
94 ExplodedNode *N = C.generateNonFatalErrorNode();
105 const ExplodedNode *N, BugReporterContext &BRC,
tools/clang/lib/StaticAnalyzer/Checkers/DereferenceChecker.cpp 122 ExplodedNode *N = C.generateErrorNode(State);
198 if (ExplodedNode *N = C.generateErrorNode()) {
235 if (ExplodedNode *N = C.generateSink(nullState, C.getPredecessor())) {
276 if (ExplodedNode *N = C.generateSink(StNull, C.getPredecessor())) {
tools/clang/lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp 36 static const Expr *getDenomExpr(const ExplodedNode *N) {
46 if (ExplodedNode *N = C.generateErrorNode(StateZero)) {
tools/clang/lib/StaticAnalyzer/Checkers/DynamicTypeChecker.cpp 50 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
92 const ExplodedNode *N, BugReporterContext &BRC, PathSensitiveBugReport &) {
tools/clang/lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp 65 ExplodedNode *dynamicTypePropagationOnCasts(const CastExpr *CE,
86 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
96 const ObjCObjectPointerType *To, ExplodedNode *N,
275 ExplodedNode *DynamicTypePropagation::dynamicTypePropagationOnCasts(
535 ExplodedNode *AfterTypeProp = dynamicTypePropagationOnCasts(CE, State, C);
588 ExplodedNode *N = C.addTransition(State, AfterTypeProp, &IllegalConv);
800 ExplodedNode *N = C.addTransition(State, &Tag);
873 ExplodedNode *Pred = C.getPredecessor();
901 ExplodedNode *N, SymbolRef Sym, CheckerContext &C,
924 const ExplodedNode *N, BugReporterContext &BRC,
tools/clang/lib/StaticAnalyzer/Checkers/EnumCastOutOfRangeChecker.cpp 80 if (const ExplodedNode *N = C.generateNonFatalErrorNode()) {
tools/clang/lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp 30 ExplodedNode *ExampleNode;
52 ExplodedNode *reportBug(llvm::StringRef Msg, CheckerContext &C) const;
53 ExplodedNode *reportBug(llvm::StringRef Msg, BugReporter &BR,
54 ExplodedNode *N) const;
108 ExplodedNode *N = C.getPredecessor();
135 ExplodedNode *ExprInspectionChecker::reportBug(llvm::StringRef Msg,
137 ExplodedNode *N = C.generateNonFatalErrorNode();
142 ExplodedNode *ExprInspectionChecker::reportBug(llvm::StringRef Msg,
144 ExplodedNode *N) const {
265 ExplodedNode *N = C.getPredecessor();
272 if (ExplodedNode *BugNode = reportBug("SYMBOL DEAD", C))
290 ExplodedNode *N = Item.second.ExampleNode;
tools/clang/lib/StaticAnalyzer/Checkers/FixedAddressChecker.cpp 51 if (ExplodedNode *N = C.generateNonFatalErrorNode()) {
tools/clang/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp 737 if (ExplodedNode *N = C.generateNonFatalErrorNode()) {
tools/clang/lib/StaticAnalyzer/Checkers/InnerPointerChecker.cpp 58 VisitNode(const ExplodedNode *N, BugReporterContext &BRC,
282 const ExplodedNode *N, BugReporterContext &BRC, PathSensitiveBugReport &) {
tools/clang/lib/StaticAnalyzer/Checkers/IteratorChecker.cpp 230 CheckerContext &C, ExplodedNode *ErrNode) const;
233 ExplodedNode *ErrNode) const;
236 ExplodedNode *ErrNode) const;
238 CheckerContext &C, ExplodedNode *ErrNode) const;
929 auto *N = C.generateErrorNode(State);
941 auto *N = C.generateErrorNode(State);
1049 auto *N = C.generateErrorNode(State);
1056 auto *N = C.generateErrorNode(State);
1091 auto *N = C.generateNonFatalErrorNode(State);
1130 auto *N = C.generateNonFatalErrorNode(State);
1592 ExplodedNode *ErrNode) const {
1602 ExplodedNode *ErrNode) const {
1613 ExplodedNode *ErrNode) const {
1623 ExplodedNode *ErrNode) const {
tools/clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp 126 PathDiagnosticPieceRef VisitNode(const ExplodedNode *Succ,
758 ExplodedNode *ErrNode = C.addTransition(C.getState(), C.getPredecessor(), &Tag);
1001 NonLocalizedStringBRVisitor::VisitNode(const ExplodedNode *Succ,
tools/clang/lib/StaticAnalyzer/Checkers/MIGChecker.cpp 273 ExplodedNode *N = C.generateErrorNode();
tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp 26 const ExplodedNode *const ExplNode,
51 const ExplodedNode *const ExplNode,
71 const ExplodedNode *const ExplNode,
88 MPIBugReporter::RequestNodeVisitor::VisitNode(const ExplodedNode *N,
tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.h 45 const ExplodedNode *const ExplNode,
56 const ExplodedNode *const ExplNode,
67 const ExplodedNode *const ExplNode,
92 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIChecker.cpp 44 ExplodedNode *ErrorNode = Ctx.generateNonFatalErrorNode();
76 ExplodedNode *ErrorNode{nullptr};
108 ExplodedNode *ErrorNode{nullptr};
tools/clang/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp 113 const ExplodedNode *getAllocationNode(const ExplodedNode *N, SymbolRef Sym,
113 const ExplodedNode *getAllocationNode(const ExplodedNode *N, SymbolRef Sym,
118 ExplodedNode *N,
145 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
230 ExplodedNode *N = C.generateNonFatalErrorNode(State);
275 ExplodedNode *N = C.generateNonFatalErrorNode(State);
337 ExplodedNode *N = C.generateNonFatalErrorNode(State);
448 const ExplodedNode *
449 MacOSKeychainAPIChecker::getAllocationNode(const ExplodedNode *N,
455 const ExplodedNode *AllocNode = N;
474 const AllocationPair &AP, ExplodedNode *N, CheckerContext &C) const {
486 const ExplodedNode *AllocNode = getAllocationNode(N, AP.first, C);
570 ExplodedNode *N = C.generateNonFatalErrorNode(C.getState(), &Tag);
622 const ExplodedNode *N, BugReporterContext &BRC,
tools/clang/lib/StaticAnalyzer/Checkers/MacOSXAPIChecker.cpp 134 ExplodedNode *N = C.generateErrorNode();
tools/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp 354 using LeakInfo = std::pair<const ExplodedNode *, const MemRegion *>;
659 static LeakInfo getAllocationSite(const ExplodedNode *N, SymbolRef Sym,
662 void reportLeak(SymbolRef Sym, ExplodedNode *N, CheckerContext &C) const;
752 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
757 const ExplodedNode *EndPathNode,
2058 if (ExplodedNode *N = C.generateErrorNode()) {
2104 if (ExplodedNode *N = C.generateErrorNode()) {
2128 if (ExplodedNode *N = C.generateErrorNode()) {
2188 ExplodedNode *N = C.generateErrorNode();
2244 if (ExplodedNode *N = C.generateErrorNode()) {
2282 if (ExplodedNode *N = C.generateErrorNode()) {
2310 if (ExplodedNode *N = C.generateErrorNode()) {
2338 if (ExplodedNode *N = C.generateErrorNode()) {
2366 if (ExplodedNode *N = C.generateErrorNode()) {
2512 MallocChecker::LeakInfo MallocChecker::getAllocationSite(const ExplodedNode *N,
2518 const ExplodedNode *AllocNode = N;
2554 void MallocChecker::reportLeak(SymbolRef Sym, ExplodedNode *N,
2590 const ExplodedNode *AllocNode = nullptr;
2663 ExplodedNode *N = C.getPredecessor();
3170 PathDiagnosticPieceRef MallocBugVisitor::VisitNode(const ExplodedNode *N,
tools/clang/lib/StaticAnalyzer/Checkers/MmapWriteExecChecker.cpp 66 ExplodedNode *N = C.generateNonFatalErrorNode();
tools/clang/lib/StaticAnalyzer/Checkers/MoveChecker.cpp 172 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
216 ExplodedNode *reportBug(const MemRegion *Region, const CXXRecordDecl *RD,
222 const ExplodedNode *getMoveLocation(const ExplodedNode *N,
222 const ExplodedNode *getMoveLocation(const ExplodedNode *N,
274 MoveChecker::MovedBugVisitor::VisitNode(const ExplodedNode *N,
332 const ExplodedNode *MoveChecker::getMoveLocation(const ExplodedNode *N,
332 const ExplodedNode *MoveChecker::getMoveLocation(const ExplodedNode *N,
337 const ExplodedNode *MoveNode = N;
380 ExplodedNode *N = reportBug(Region, RD, C, MK);
390 ExplodedNode *MoveChecker::reportBug(const MemRegion *Region,
393 if (ExplodedNode *N = misuseCausesCrash(MK) ? C.generateErrorNode()
402 const ExplodedNode *MoveNode = getMoveLocation(N, Region, C);
tools/clang/lib/StaticAnalyzer/Checkers/NSAutoreleasePoolChecker.cpp 64 ExplodedNode *N = C.generateNonFatalErrorNode();
tools/clang/lib/StaticAnalyzer/Checkers/NonNullParamChecker.cpp 39 genReportNullAttrNonNull(const ExplodedNode *ErrorN,
43 genReportReferenceToNullPointer(const ExplodedNode *ErrorN,
144 if (ExplodedNode *errorNode = C.generateErrorNode(stateNull)) {
164 if (ExplodedNode *N = C.generateSink(stateNull, C.getPredecessor())) {
183 NonNullParamChecker::genReportNullAttrNonNull(const ExplodedNode *ErrorNode,
209 const ExplodedNode *ErrorNode, const Expr *ArgE) const {
tools/clang/lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp 140 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
155 ExplodedNode *N, const MemRegion *Region,
160 void reportBug(StringRef Msg, ErrorKind Error, ExplodedNode *N,
294 const ExplodedNode *N, BugReporterContext &BRC,
404 static bool checkInvariantViolation(ProgramStateRef State, ExplodedNode *N,
434 ErrorKind Error, ExplodedNode *N, const MemRegion *Region,
581 ExplodedNode *N = C.generateErrorNode(State, &Tag);
617 ExplodedNode *N = C.addTransition(State, C.getPredecessor(), &Tag);
681 ExplodedNode *N = C.generateErrorNode(State);
711 ExplodedNode *N = C.addTransition(State);
723 ExplodedNode *N = C.addTransition(State);
1097 ExplodedNode *N = C.generateErrorNode(State, &Tag);
1141 ExplodedNode *N = C.addTransition(State, C.getPredecessor(), &Tag);
tools/clang/lib/StaticAnalyzer/Checkers/ObjCAtSyncChecker.cpp 45 if (ExplodedNode *N = C.generateErrorNode()) {
68 if (ExplodedNode *N = C.generateNonFatalErrorNode(nullState)) {
tools/clang/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp 143 ExplodedNode *N = C.generateErrorNode(StOutBound);
tools/clang/lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp 155 ExplodedNode *N = C.generateErrorNode();
tools/clang/lib/StaticAnalyzer/Checkers/ObjCSuperDeallocChecker.cpp 72 PathDiagnosticPieceRef VisitNode(const ExplodedNode *Succ,
181 ExplodedNode *ErrNode = C.generateErrorNode();
246 SuperDeallocBRVisitor::VisitNode(const ExplodedNode *Succ,
tools/clang/lib/StaticAnalyzer/Checkers/PointerArithChecker.cpp 170 if (ExplodedNode *N = C.generateNonFatalErrorNode()) {
193 if (ExplodedNode *N = C.generateNonFatalErrorNode()) {
tools/clang/lib/StaticAnalyzer/Checkers/PointerSubChecker.cpp 60 if (ExplodedNode *N = C.generateNonFatalErrorNode()) {
tools/clang/lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp 240 ExplodedNode *N = C.generateErrorNode();
305 ExplodedNode *N = C.generateErrorNode();
328 ExplodedNode *N = C.generateErrorNode();
399 ExplodedNode *N = C.generateErrorNode();
439 ExplodedNode *N = C.generateErrorNode();
453 ExplodedNode *N = C.generateErrorNode();
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp 232 const ExplodedNode *pred = C.getPredecessor();
273 const ExplodedNode *Pred = C.getPredecessor();
874 ExplodedNode *N = C.generateErrorNode(St);
963 ExplodedNode * RetainCountChecker::processReturn(const ReturnStmt *S,
965 ExplodedNode *Pred = C.getPredecessor();
1066 ExplodedNode * RetainCountChecker::checkReturnWithRetEffect(const ReturnStmt *S,
1068 ExplodedNode *Pred,
1094 ExplodedNode *N = C.addTransition(state, Pred, &ReturnOwnLeakTag);
1120 ExplodedNode *N = C.addTransition(state, Pred, &ReturnNotOwnedTag);
1208 ExplodedNode *Pred,
1264 ExplodedNode *N = Ctx.generateSink(state, Pred, Tag);
1312 ExplodedNode *
1316 ExplodedNode *Pred) const {
1318 ExplodedNode *N = Ctx.addTransition(state, Pred);
1369 ExplodedNode *Pred = processReturn(RS, Ctx);
1411 ExplodedNode *Pred = C.getPredecessor();
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.h 326 ExplodedNode* checkReturnWithRetEffect(const ReturnStmt *S, CheckerContext &C,
327 ExplodedNode *Pred, RetEffect RE, RefVal X,
352 handleAutoreleaseCounts(ProgramStateRef state, ExplodedNode *Pred,
358 ExplodedNode *processLeaks(ProgramStateRef state,
361 ExplodedNode *Pred = nullptr) const;
375 ExplodedNode * processReturn(const ReturnStmt *S, CheckerContext &C) const;
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp 328 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
333 const ExplodedNode *N,
342 const ExplodedNode *N,
352 static const ExplodedNode *getCalleeNode(const ExplodedNode *Pred) {
352 static const ExplodedNode *getCalleeNode(const ExplodedNode *Pred) {
360 const ExplodedNode *N = Pred;
372 annotateConsumedSummaryMismatch(const ExplodedNode *N,
377 const ExplodedNode *CN = getCalleeNode(N);
422 annotateStartParameter(const ExplodedNode *N, SymbolRef Sym,
452 RefCountReportVisitor::VisitNode(const ExplodedNode *N, BugReporterContext &BRC,
477 const ExplodedNode *PrevNode = N->getFirstPred();
621 const ExplodedNode* N;
624 AllocationInfo(const ExplodedNode *InN,
632 const ExplodedNode *N, SymbolRef Sym) {
633 const ExplodedNode *AllocationNode = N;
634 const ExplodedNode *AllocationNodeInCurrentOrParentContext = N;
718 const ExplodedNode *EndN,
726 const ExplodedNode *EndN,
812 ExplodedNode *n, SymbolRef sym, bool isLeak)
820 ExplodedNode *n, SymbolRef sym,
856 const ExplodedNode *AllocNode = nullptr;
906 ExplodedNode *n, SymbolRef sym,
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.h 63 ExplodedNode *n, SymbolRef sym,
67 ExplodedNode *n, SymbolRef sym,
91 RefLeakReport(const RefCountBug &D, const LangOptions &LOpts, ExplodedNode *n,
tools/clang/lib/StaticAnalyzer/Checkers/ReturnPointerRangeChecker.cpp 64 ExplodedNode *N = C.generateErrorNode(StOutBound);
tools/clang/lib/StaticAnalyzer/Checkers/ReturnUndefChecker.cpp 82 ExplodedNode *N = C.generateErrorNode();
tools/clang/lib/StaticAnalyzer/Checkers/SimpleStreamChecker.cpp 64 ExplodedNode *ErrNode) const;
193 ExplodedNode *N = C.generateNonFatalErrorNode(State);
203 ExplodedNode *ErrNode = C.generateErrorNode();
218 ExplodedNode *ErrNode) const {
tools/clang/lib/StaticAnalyzer/Checkers/StackAddrEscapeChecker.cpp 154 ExplodedNode *N = C.generateNonFatalErrorNode();
193 ExplodedNode *N = C.generateNonFatalErrorNode();
216 ExplodedNode *N = C.generateNonFatalErrorNode();
330 ExplodedNode *N = Ctx.generateNonFatalErrorNode(State);
tools/clang/lib/StaticAnalyzer/Checkers/StreamChecker.cpp 274 if (ExplodedNode *N = C.generateNonFatalErrorNode(state)) {
344 if (ExplodedNode *N = C.generateErrorNode(stateNull)) {
372 ExplodedNode *N = C.generateErrorNode();
400 ExplodedNode *N = C.generateErrorNode();
tools/clang/lib/StaticAnalyzer/Checkers/Taint.cpp 207 PathDiagnosticPieceRef TaintBugVisitor::VisitNode(const ExplodedNode *N,
tools/clang/lib/StaticAnalyzer/Checkers/Taint.h 92 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
tools/clang/lib/StaticAnalyzer/Checkers/TaintTesterChecker.cpp 53 if (ExplodedNode *N = C.generateNonFatalErrorNode()) {
tools/clang/lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp 72 PathDiagnosticPieceRef VisitNode(const ExplodedNode *Succ,
96 DivisionBRVisitor::VisitNode(const ExplodedNode *Succ, BugReporterContext &BRC,
166 if (ExplodedNode *N = C.generateErrorNode(C.getState())) {
tools/clang/lib/StaticAnalyzer/Checkers/UndefBranchChecker.cpp 65 ExplodedNode *N = Ctx.generateErrorNode();
87 ExplodedNode *PrevN = *N->pred_begin();
tools/clang/lib/StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp 74 if (ExplodedNode *N = C.generateErrorNode()) {
tools/clang/lib/StaticAnalyzer/Checkers/UndefResultChecker.cpp 88 ExplodedNode *N = C.generateErrorNode();
tools/clang/lib/StaticAnalyzer/Checkers/UndefinedArraySubscriptChecker.cpp 48 ExplodedNode *N = C.generateErrorNode();
tools/clang/lib/StaticAnalyzer/Checkers/UndefinedAssignmentChecker.cpp 48 ExplodedNode *N = C.generateErrorNode();
tools/clang/lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedObjectChecker.cpp 175 ExplodedNode *Node = Context.generateNonFatalErrorNode(UpdatedState);
tools/clang/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp 132 ExplodedNode *N = C.generateErrorNode(State);
289 ExplodedNode *N = C.generateErrorNode(state);
341 ExplodedNode *N = C.generateErrorNode(falseState);
tools/clang/lib/StaticAnalyzer/Checkers/VLASizeChecker.cpp 49 ExplodedNode *N = C.generateErrorNode(State);
tools/clang/lib/StaticAnalyzer/Checkers/ValistChecker.cpp 58 const ExplodedNode *getStartCallSite(const ExplodedNode *N,
58 const ExplodedNode *getStartCallSite(const ExplodedNode *N,
64 StringRef Msg2, CheckerContext &C, ExplodedNode *N,
81 const ExplodedNode *EndPathNode,
91 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
214 if (ExplodedNode *N = C.addTransition(State))
223 const ExplodedNode *
224 ValistChecker::getStartCallSite(const ExplodedNode *N,
227 const ExplodedNode *StartCallNode = N;
253 if (ExplodedNode *N = C.generateErrorNode()) {
267 CheckerContext &C, ExplodedNode *N,
284 const ExplodedNode *StartNode = getStartCallSite(N, Reg);
324 if (ExplodedNode *N = C.addTransition(State))
332 if (ExplodedNode *N = C.addTransition(State))
345 if (ExplodedNode *N = C.addTransition(State))
379 const ExplodedNode *N, BugReporterContext &BRC, PathSensitiveBugReport &) {
tools/clang/lib/StaticAnalyzer/Checkers/VforkChecker.cpp 122 if (ExplodedNode *N = C.generateErrorNode(C.getState())) {
tools/clang/lib/StaticAnalyzer/Checkers/VirtualCallChecker.cpp 138 ExplodedNode *N =
tools/clang/lib/StaticAnalyzer/Core/BugReporter.cpp 96 std::pair<PathDiagnosticCallPiece *, const ExplodedNode *>;
101 llvm::DenseMap<const ExplodedNode *, std::vector<PathDiagnosticPieceRef>>;
116 const ExplodedNode *CurrentNode;
135 const ExplodedNode *ErrorNode,
152 const ExplodedNode *getCurrentNode() const { return CurrentNode; }
210 const ExplodedNode *const ErrorNode;
225 PathSensitiveBugReport *r, const ExplodedNode *ErrorNode,
280 std::string StackHintGeneratorForSymbol::getMessage(const ExplodedNode *N){
723 const ExplodedNode *N = I.second;
1028 const ExplodedNode *N) {
1117 findExecutedLines(const SourceManager &SM, const ExplodedNode *N);
1967 const PathDiagnosticConsumer *PDC, const ExplodedNode *ErrorNode,
1977 PathSensitiveBugReport *r, const ExplodedNode *ErrorNode,
2129 const ExplodedNode *N = getErrorNode();
2427 const ExplodedNode *ErrorNode;
2435 using PriorityMapTy = llvm::DenseMap<const ExplodedNode *, unsigned>;
2443 std::pair<PathSensitiveBugReport *, const ExplodedNode *>;
2456 bool operator()(const ExplodedNode *LHS, const ExplodedNode *RHS) const {
2456 bool operator()(const ExplodedNode *LHS, const ExplodedNode *RHS) const {
2487 SmallVector<const ExplodedNode *, 32> Nodes;
2503 llvm::SmallPtrSet<const ExplodedNode *, 32> RemainingNodes;
2506 const ExplodedNode *NewNode = ForwardMap.lookup(Report->getErrorNode());
2517 std::queue<const ExplodedNode *> WS;
2524 const ExplodedNode *Node = WS.front();
2541 for (const ExplodedNode *Succ : Node->succs())
2553 const ExplodedNode *OrigN;
2564 ExplodedNode *Succ = nullptr;
2568 ExplodedNode *NewN = GNew->createUncachedNode(
2695 const ExplodedNode *ErrorNode,
2703 const ExplodedNode *NextNode = ErrorNode->getFirstPred();
2716 const ExplodedNode *Pred = NextNode->getFirstPred();
2760 const ExplodedNode *ErrorNode = BugPath->ErrorNode;
2848 if (const ExplodedNode *E = PR->getErrorNode()) {
2875 const ExplodedNode *N;
2876 ExplodedNode::const_succ_iterator I, E;
2878 FRIEC_WLItem(const ExplodedNode *n)
2915 const ExplodedNode *errorNode = R->getErrorNode();
2941 llvm::DenseMap<const ExplodedNode *, unsigned> Visited;
2952 const ExplodedNode *Succ = *WI.I;
3083 findExecutedLines(const SourceManager &SM, const ExplodedNode *N) {
tools/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp 165 static bool hasVisibleUpdate(const ExplodedNode *LeftNode, SVal LeftVal,
166 const ExplodedNode *RightNode, SVal RightVal) {
184 const ExplodedNode *N) {
208 getConcreteIntegerValue(const Expr *CondVarExpr, const ExplodedNode *N) {
217 const ExplodedNode *N,
232 static bool isInterestingExpr(const Expr *E, const ExplodedNode *N,
266 const ExplodedNode *N,
298 const ExplodedNode *,
304 const ExplodedNode *,
309 const ExplodedNode *EndPathNode,
376 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
395 bool isRegionOfInterestModifiedInFrame(const ExplodedNode *N) {
405 void findModifyingFrames(const ExplodedNode *N);
413 const ExplodedNode *N, const RegionVector &FieldChain,
545 NoStoreFuncVisitor::VisitNode(const ExplodedNode *N, BugReporterContext &BR,
618 void NoStoreFuncVisitor::findModifyingFrames(const ExplodedNode *N) {
658 PathSensitiveBugReport &R, const CallEvent &Call, const ExplodedNode *N,
803 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
830 const ExplodedNode *N, const MemRegion *R,
852 Optional<SourceLocation> matchAssignment(const ExplodedNode *N) {
924 static void addVisitorIfNecessary(const ExplodedNode *Node, const Stmt *S,
1003 PathDiagnosticPieceRef visitNodeInitial(const ExplodedNode *N,
1130 PathDiagnosticPieceRef visitNodeMaybeUnsuppress(const ExplodedNode *N,
1177 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
1192 void finalizeVisitor(BugReporterContext &, const ExplodedNode *,
1216 static bool isInitializationOfVar(const ExplodedNode *N, const VarRegion *VR) {
1361 FindLastStoreBRVisitor::VisitNode(const ExplodedNode *Succ,
1367 const ExplodedNode *StoreSite = nullptr;
1368 const ExplodedNode *Pred = Succ->getFirstPred();
1540 bool TrackConstraintBRVisitor::isUnderconstrained(const ExplodedNode *N) const {
1547 const ExplodedNode *N, BugReporterContext &BRC, PathSensitiveBugReport &) {
1548 const ExplodedNode *PrevN = N->getFirstPred();
1603 SuppressInlineDefensiveChecksVisitor(DefinedSVal Value, const ExplodedNode *N)
1626 SuppressInlineDefensiveChecksVisitor::VisitNode(const ExplodedNode *Succ,
1629 const ExplodedNode *Pred = Succ->getFirstPred();
1714 const ExplodedNode *Origin;
1719 TrackControlDependencyCondBRVisitor(const ExplodedNode *O)
1727 PathDiagnosticPieceRef VisitNode(const ExplodedNode *N,
1735 const ExplodedNode *N,
1786 TrackControlDependencyCondBRVisitor::VisitNode(const ExplodedNode *N,
1835 const ExplodedNode *N) {
1858 const ExplodedNode *N) {
1878 const ExplodedNode *NI = N;
1923 static const ExplodedNode* findNodeForExpression(const ExplodedNode *N,
1923 static const ExplodedNode* findNodeForExpression(const ExplodedNode *N,
1933 bool bugreporter::trackExpressionValue(const ExplodedNode *InputNode,
1943 const ExplodedNode *LVNode = findNodeForExpression(InputNode, Inner);
2081 const ExplodedNode *N) {
2095 NilReceiverBRVisitor::VisitNode(const ExplodedNode *N, BugReporterContext &BRC,
2140 ConditionBRVisitor::VisitNode(const ExplodedNode *N, BugReporterContext &BRC,
2152 ConditionBRVisitor::VisitNodeImpl(const ExplodedNode *N,
2191 const Stmt *Term, const ExplodedNode *N, const CFGBlock *srcBlk,
2251 const ExplodedNode *N, bool TookTrue) {
2322 const ExplodedNode *N,
2406 PathSensitiveBugReport &R, const ExplodedNode *N, bool TookTrue,
2526 PathSensitiveBugReport &report, const ExplodedNode *N, bool TookTrue) {
2553 PathSensitiveBugReport &report, const ExplodedNode *N, bool TookTrue,
2589 PathSensitiveBugReport &report, const ExplodedNode *N, bool TookTrue,
2626 const ExplodedNode *N, bool TookTrue,
2676 BugReporterContext &BRC, const ExplodedNode *N,
2763 UndefOrNullArgVisitor::VisitNode(const ExplodedNode *N, BugReporterContext &BRC,
2820 BugReporterContext &BRC, const ExplodedNode *EndPathNode,
2857 const ExplodedNode *N, BugReporterContext &, PathSensitiveBugReport &) {
2891 PathDiagnosticPieceRef TagVisitor::VisitNode(const ExplodedNode *N,
tools/clang/lib/StaticAnalyzer/Core/CheckerManager.cpp 170 NodeBuilder &Bldr, ExplodedNode *Pred) {
217 NodeBuilder &Bldr, ExplodedNode *Pred) {
287 NodeBuilder &Bldr, ExplodedNode *Pred) {
334 NodeBuilder &Bldr, ExplodedNode *Pred) {
382 NodeBuilder &Bldr, ExplodedNode *Pred) {
426 NodeBuilder &Bldr, ExplodedNode *Pred) {
438 ExplodedNode *Pred,
451 ExplodedNode *Pred,
483 NodeBuilder &Bldr, ExplodedNode *Pred) {
496 ExplodedNode *Pred,
524 NodeBuilder &Bldr, ExplodedNode *Pred) {
534 const CXXNewExpr *NE, SVal Target, ExplodedNodeSet &Dst, ExplodedNode *Pred,
569 NodeBuilder &Bldr, ExplodedNode *Pred) {
tools/clang/lib/StaticAnalyzer/Core/CoreEngine.cpp 110 ExplodedNode *Node = G.getNode(StartLoc, InitState, false, &IsNew);
146 ExplodedNode *Node = WU.getNode();
154 void CoreEngine::dispatchWorkItem(ExplodedNode* Pred, ProgramPoint Loc,
181 ExplodedNode *PNode = Pred->getFirstPred();
209 void CoreEngine::HandleBlockEdge(const BlockEdge &L, ExplodedNode *Pred) {
278 ExplodedNode *Pred) {
296 void CoreEngine::HandleBlockExit(const CFGBlock * B, ExplodedNode *Pred) {
419 void CoreEngine::HandleCallEnter(const CallEnter &CE, ExplodedNode *Pred) {
425 const CFGBlock * B, ExplodedNode *Pred) {
437 ExplodedNode *Pred) {
448 ExplodedNode *Pred) {
459 ExplodedNode *Pred) {
472 ExplodedNode *Pred) {
498 ExplodedNode *Pred) {
500 ExplodedNode *Node = G.getNode(Loc, State, false, &IsNew);
513 void CoreEngine::enqueueStmtNode(ExplodedNode *N,
556 ExplodedNode *Succ = G.getNode(Loc, N->getState(), false, &IsNew);
563 ExplodedNode *CoreEngine::generateCallExitBeginNode(ExplodedNode *N,
563 ExplodedNode *CoreEngine::generateCallExitBeginNode(ExplodedNode *N,
572 ExplodedNode *Node = G.getNode(Loc, N->getState(), false, &isNew);
605 ExplodedNode* NodeBuilder::generateNodeImpl(const ProgramPoint &Loc,
607 ExplodedNode *FromN,
611 ExplodedNode *N = C.Eng.G.getNode(Loc, State, MarkAsSink, &IsNew);
634 ExplodedNode *BranchNodeBuilder::generateNode(ProgramStateRef State,
636 ExplodedNode *NodePred) {
643 ExplodedNode *Succ = generateNodeImpl(Loc, State, NodePred);
647 ExplodedNode*
652 ExplodedNode *Succ =
666 ExplodedNode*
670 ExplodedNode *Succ =
681 ExplodedNode*
694 ExplodedNode *Succ =
tools/clang/lib/StaticAnalyzer/Core/ExplodedGraph.cpp 58 bool ExplodedGraph::shouldCollect(const ExplodedNode *node) {
93 const ExplodedNode *pred = *(node->pred_begin());
97 const ExplodedNode *succ = *(node->succ_begin());
155 void ExplodedGraph::collectNode(ExplodedNode *node) {
161 ExplodedNode *pred = *(node->pred_begin());
162 ExplodedNode *succ = *(node->succ_begin());
203 using ExplodedNodeVector = BumpVector<ExplodedNode *>;
204 using GroupStorage = llvm::PointerUnion<ExplodedNode *, ExplodedNodeVector *>;
206 void ExplodedNode::addPredecessor(ExplodedNode *V, ExplodedGraph &G) {
212 void ExplodedNode::NodeGroup::replaceNode(ExplodedNode *node) {
221 void ExplodedNode::NodeGroup::addNode(ExplodedNode *N, ExplodedGraph &G) {
235 ExplodedNode *Old = Storage.get<ExplodedNode *>();
235 ExplodedNode *Old = Storage.get<ExplodedNode *>();
262 ExplodedNode * const *ExplodedNode::NodeGroup::begin() const {
274 ExplodedNode * const *ExplodedNode::NodeGroup::end() const {
354 for (const ExplodedNode *N = getFirstSucc(); N; N = N->getFirstSucc()) {
381 for (const ExplodedNode *N = getFirstPred(); N; N = N->getFirstPred())
395 ExplodedNode *ExplodedGraph::getNode(const ProgramPoint &L,
433 ExplodedNode *ExplodedGraph::createUncachedNode(const ProgramPoint &L,
449 using Pass1Ty = llvm::DenseSet<const ExplodedNode *>;
456 SmallVector<const ExplodedNode*, 10> WL1, WL2;
465 const ExplodedNode *N = WL1.pop_back_val();
490 const ExplodedNode *N = WL2.pop_back_val();
498 ExplodedNode *NewN = G->createUncachedNode(N->getLocation(), N->State,
514 for (ExplodedNode::pred_iterator I = N->Preds.begin(), E = N->Preds.end();
527 for (ExplodedNode::succ_iterator I = N->Succs.begin(), E = N->Succs.end();
tools/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp 627 void ExprEngine::processCFGElement(const CFGElement E, ExplodedNode *Pred,
665 const ExplodedNode *Pred,
689 void ExprEngine::removeDead(ExplodedNode *Pred, ExplodedNodeSet &Out,
768 void ExprEngine::ProcessStmt(const Stmt *currStmt, ExplodedNode *Pred) {
798 void ExprEngine::ProcessLoopExit(const Stmt* S, ExplodedNode *Pred) {
817 ExplodedNode *Pred) {
905 ExplodedNode *Pred) {
932 ExplodedNode *Pred) {
951 ExplodedNode *Pred,
985 ExplodedNode *Pred,
1025 ExplodedNode *Pred, ExplodedNodeSet &Dst) {
1045 ExplodedNode *Pred, ExplodedNodeSet &Dst) {
1069 ExplodedNode *Pred,
1107 ExplodedNode *CleanPred =
1131 ExplodedNode *Pred,
1160 for (ExplodedNode *Node : PreVisit) {
1196 void ExprEngine::Visit(const Stmt *S, ExplodedNode *Pred,
1287 const ExplodedNode *node = Bldr.generateSink(S, Pred, Pred->getState());
1525 const ExplodedNode *node = Bldr.generateSink(S, Pred, Pred->getState());
1845 bool ExprEngine::replayWithoutInlining(ExplodedNode *N,
1850 ExplodedNode *BeforeProcessingCall = nullptr;
1893 ExplodedNode *NewNode = G.getNode(NewNodeLoc, NewNodeState, false, &IsNew);
1911 ExplodedNode *Pred) {
1922 ExplodedNode *UpdatedNode = nodeBuilder.generateNode(NewState, Pred);
1953 const ExplodedNode *Sink =
2089 ExplodedNode *Pred,
2187 ExplodedNode *Pred,
2253 ExplodedNode *Pred,
2263 ExplodedNode *Pred,
2420 ExplodedNode *Pred,
2511 ExplodedNode *Pred,
2530 for (auto *Node : CheckerPreStmt) {
2561 void ExprEngine::VisitMemberExpr(const MemberExpr *M, ExplodedNode *Pred,
2641 void ExprEngine::VisitAtomicExpr(const AtomicExpr *AE, ExplodedNode *Pred,
2760 ExplodedNode *Pred,
2818 ExplodedNode *Pred,
2842 ExplodedNode *Pred,
2880 ExplodedNode *Pred,
2964 void ExprEngine::VisitGCCAsmStmt(const GCCAsmStmt *A, ExplodedNode *Pred,
2987 void ExprEngine::VisitMSAsmStmt(const MSAsmStmt *A, ExplodedNode *Pred,
3004 static bool nodeHasBugReport(const ExplodedNode *N) {
3016 const ExplodedNode *EN = PR->getErrorNode();
3030 const ExplodedNode *N,
3031 llvm::function_ref<void(const ExplodedNode *)> PreCallback,
3032 llvm::function_ref<void(const ExplodedNode *)> PostCallback,
3033 llvm::function_ref<bool(const ExplodedNode *)> Stop) {
3048 static bool isNodeHidden(const ExplodedNode *N) {
3052 static std::string getNodeLabel(const ExplodedNode *N, ExplodedGraph *G){
3106 void ExprEngine::ViewGraph(ArrayRef<const ExplodedNode*> Nodes) {
3117 std::vector<const ExplodedNode *> Src;
3126 const auto *N = const_cast<ExplodedNode *>(R->getErrorNode());
3139 std::string ExprEngine::DumpGraph(ArrayRef<const ExplodedNode*> Nodes,
tools/clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp 41 ExplodedNode *Pred,
196 void ExprEngine::VisitBlockExpr(const BlockExpr *BE, ExplodedNode *Pred,
262 ExplodedNode* Pred) {
287 StmtNodeBuilder &Bldr, ExplodedNode* Pred) {
302 ExplodedNode *Pred, ExplodedNodeSet &Dst) {
310 ExplodedNode *subExprNode = *I;
550 ExplodedNode *Pred,
574 void ExprEngine::VisitDeclStmt(const DeclStmt *DS, ExplodedNode *Pred,
593 ExplodedNode *N = *I;
601 ExplodedNode *UpdatedN = N;
638 void ExprEngine::VisitLogicalExpr(const BinaryOperator* B, ExplodedNode *Pred,
671 ExplodedNode *N = Pred;
733 ExplodedNode *Pred,
784 ExplodedNode *Pred,
795 for (const ExplodedNode *N = Pred ; N ; N = *N->pred_begin()) {
847 ExplodedNode *Pred, ExplodedNodeSet &Dst) {
866 ExplodedNode *Pred,
924 void ExprEngine::VisitUnaryOperator(const UnaryOperator* U, ExplodedNode *Pred,
1061 ExplodedNode *Pred,
tools/clang/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp 27 ExplodedNode *Pred,
40 void ExprEngine::performTrivialCopy(NodeBuilder &Bldr, ExplodedNode *Pred,
396 ExplodedNode *Pred,
577 for (ExplodedNode *N : DstEvaluated) {
605 ExplodedNode *Pred,
669 ExplodedNode *Pred,
737 void ExprEngine::VisitCXXNewExpr(const CXXNewExpr *CNE, ExplodedNode *Pred,
831 ExplodedNode *NewN = Bldr.generateNode(CNE, Pred, State);
848 ExplodedNode *Pred, ExplodedNodeSet &Dst) {
855 ExplodedNode *Pred,
873 void ExprEngine::VisitCXXThisExpr(const CXXThisExpr *TE, ExplodedNode *Pred,
889 void ExprEngine::VisitLambdaExpr(const LambdaExpr *LE, ExplodedNode *Pred,
tools/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp 40 ExplodedNode *Pred) {
61 ExplodedNode *Node = G.getNode(Loc, state, false, &isNew);
73 const CFGBlock*> getLastStmt(const ExplodedNode *Node) {
161 ExplodedNode *Pred,
202 void ExprEngine::processCallExit(ExplodedNode *CEBNode) {
282 ExplodedNode *BindedRetNode = G.getNode(Loc, state, false, &isNew);
310 ExplodedNode *CEENode = G.getNode(Loc, CEEState, false, &isNew);
431 NodeBuilder &Bldr, ExplodedNode *Pred,
464 if (ExplodedNode *N = G.getNode(Loc, State, false, &isNew)) {
496 void ExprEngine::VisitCallExpr(const CallExpr *CE, ExplodedNode *Pred,
550 ExplodedNode *Pred,
568 void ExprEngine::evalCall(ExplodedNodeSet &Dst, ExplodedNode *Pred,
673 ExplodedNode *Pred,
683 ExprEngine::mayInlineCallKind(const CallEvent &Call, const ExplodedNode *Pred,
917 const ExplodedNode *Pred,
1002 void ExprEngine::defaultEvalCall(NodeBuilder &Bldr, ExplodedNode *Pred,
1056 NodeBuilder &Bldr, ExplodedNode *Pred) {
1092 void ExprEngine::VisitReturnStmt(const ReturnStmt *RS, ExplodedNode *Pred,
tools/clang/lib/StaticAnalyzer/Core/ExprEngineObjC.cpp 22 ExplodedNode *Pred,
39 ExplodedNode *Pred,
52 for (ExplodedNode *Pred : dstLocation) {
86 ExplodedNode *Pred,
151 ExplodedNode *Pred,
246 ExplodedNode *Pred = *DI;
tools/clang/lib/StaticAnalyzer/Core/LoopUnrolling.cpp 162 static bool isPossiblyEscaped(const VarDecl *VD, ExplodedNode *N) {
200 ExplodedNode *Pred, unsigned &maxStep) {
231 bool madeNewBranch(ExplodedNode *N, const Stmt *LoopStmt) {
252 ExplodedNode *Pred, unsigned maxVisitOnPath) {
tools/clang/lib/StaticAnalyzer/Core/WorkList.cpp 150 const ExplodedNode *N = U.getNode();
231 const ExplodedNode *N = U.getNode();
293 const ExplodedNode *N = U.getNode();
usr/include/c++/7.4.0/type_traits 1983 { typedef _Up type; };