clang  9.0.0svn
BugReporter.h
Go to the documentation of this file.
1 //===- BugReporter.h - Generate PathDiagnostics -----------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines BugReporter, a utility class for generating
10 // PathDiagnostics for analyses based on ProgramState.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_BUGREPORTER_H
15 #define LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_BUGREPORTER_H
16 
17 #include "clang/Basic/LLVM.h"
26 #include "llvm/ADT/ArrayRef.h"
27 #include "llvm/ADT/DenseSet.h"
28 #include "llvm/ADT/FoldingSet.h"
29 #include "llvm/ADT/ImmutableSet.h"
30 #include "llvm/ADT/None.h"
31 #include "llvm/ADT/SmallSet.h"
32 #include "llvm/ADT/SmallVector.h"
33 #include "llvm/ADT/StringMap.h"
34 #include "llvm/ADT/StringRef.h"
35 #include "llvm/ADT/ilist.h"
36 #include "llvm/ADT/ilist_node.h"
37 #include "llvm/ADT/iterator_range.h"
38 #include <cassert>
39 #include <memory>
40 #include <string>
41 #include <utility>
42 #include <vector>
43 
44 namespace clang {
45 
46 class AnalyzerOptions;
47 class ASTContext;
48 class Decl;
49 class DiagnosticsEngine;
50 class LocationContext;
51 class SourceManager;
52 class Stmt;
53 
54 namespace ento {
55 
56 class BugType;
57 class CheckerBase;
58 class ExplodedGraph;
59 class ExplodedNode;
60 class ExprEngine;
61 class MemRegion;
62 class SValBuilder;
63 
64 //===----------------------------------------------------------------------===//
65 // Interface for individual bug reports.
66 //===----------------------------------------------------------------------===//
67 
68 /// A mapping from diagnostic consumers to the diagnostics they should
69 /// consume.
71  llvm::DenseMap<PathDiagnosticConsumer *, std::unique_ptr<PathDiagnostic>>;
72 
73 /// This class provides an interface through which checkers can create
74 /// individual bug reports.
75 class BugReport : public llvm::ilist_node<BugReport> {
76 public:
77  class NodeResolver {
78  virtual void anchor();
79 
80  public:
81  virtual ~NodeResolver() = default;
82 
83  virtual const ExplodedNode*
84  getOriginalNode(const ExplodedNode *N) = 0;
85  };
86 
87  using ranges_iterator = const SourceRange *;
89  using visitor_iterator = VisitorList::iterator;
92 
93 protected:
94  friend class BugReportEquivClass;
95  friend class BugReporter;
96 
97  const BugType& BT;
98  const Decl *DeclWithIssue = nullptr;
99  std::string ShortDescription;
100  std::string Description;
104 
105  const ExplodedNode *ErrorNode = nullptr;
109 
112 
113  /// A (stack of) a set of symbols that are registered with this
114  /// report as being "interesting", and thus used to help decide which
115  /// diagnostics to include when constructing the final path diagnostic.
116  /// The stack is largely used by BugReporter when generating PathDiagnostics
117  /// for multiple PathDiagnosticConsumers.
119 
120  /// A (stack of) set of regions that are registered with this report as being
121  /// "interesting", and thus used to help decide which diagnostics
122  /// to include when constructing the final path diagnostic.
123  /// The stack is largely used by BugReporter when generating PathDiagnostics
124  /// for multiple PathDiagnosticConsumers.
126 
127  /// A set of location contexts that correspoind to call sites which should be
128  /// considered "interesting".
129  llvm::SmallSet<const LocationContext *, 2> InterestingLocationContexts;
130 
131  /// A set of custom visitors which generate "event" diagnostics at
132  /// interesting points in the path.
134 
135  /// Used for ensuring the visitors are only added once.
136  llvm::FoldingSet<BugReporterVisitor> CallbacksSet;
137 
138  /// When set, this flag disables all callstack pruning from a diagnostic
139  /// path. This is useful for some reports that want maximum fidelty
140  /// when reporting an issue.
141  bool DoNotPrunePath = false;
142 
143  /// Used to track unique reasons why a bug report might be invalid.
144  ///
145  /// \sa markInvalid
146  /// \sa removeInvalidation
147  using InvalidationRecord = std::pair<const void *, const void *>;
148 
149  /// If non-empty, this bug report is likely a false positive and should not be
150  /// shown to the user.
151  ///
152  /// \sa markInvalid
153  /// \sa removeInvalidation
154  llvm::SmallSet<InvalidationRecord, 4> Invalidations;
155 
156 private:
157  // Used internally by BugReporter.
158  Symbols &getInterestingSymbols();
159  Regions &getInterestingRegions();
160 
161  void lazyInitializeInterestingSets();
162  void pushInterestingSymbolsAndRegions();
163  void popInterestingSymbolsAndRegions();
164 
165 public:
166  BugReport(const BugType& bt, StringRef desc, const ExplodedNode *errornode)
167  : BT(bt), Description(desc), ErrorNode(errornode) {}
168 
169  BugReport(const BugType& bt, StringRef shortDesc, StringRef desc,
170  const ExplodedNode *errornode)
171  : BT(bt), ShortDescription(shortDesc), Description(desc),
172  ErrorNode(errornode) {}
173 
174  BugReport(const BugType &bt, StringRef desc, PathDiagnosticLocation l)
175  : BT(bt), Description(desc), Location(l) {}
176 
177  /// Create a BugReport with a custom uniqueing location.
178  ///
179  /// The reports that have the same report location, description, bug type, and
180  /// ranges are uniqued - only one of the equivalent reports will be presented
181  /// to the user. This method allows to rest the location which should be used
182  /// for uniquing reports. For example, memory leaks checker, could set this to
183  /// the allocation site, rather then the location where the bug is reported.
184  BugReport(BugType& bt, StringRef desc, const ExplodedNode *errornode,
185  PathDiagnosticLocation LocationToUnique, const Decl *DeclToUnique)
186  : BT(bt), Description(desc), UniqueingLocation(LocationToUnique),
187  UniqueingDecl(DeclToUnique), ErrorNode(errornode) {}
188 
189  virtual ~BugReport();
190 
191  const BugType& getBugType() const { return BT; }
192  //BugType& getBugType() { return BT; }
193 
194  /// True when the report has an execution path associated with it.
195  ///
196  /// A report is said to be path-sensitive if it was thrown against a
197  /// particular exploded node in the path-sensitive analysis graph.
198  /// Path-sensitive reports have their intermediate path diagnostics
199  /// auto-generated, perhaps with the help of checker-defined visitors,
200  /// and may contain extra notes.
201  /// Path-insensitive reports consist only of a single warning message
202  /// in a specific location, and perhaps extra notes.
203  /// Path-sensitive checkers are allowed to throw path-insensitive reports.
204  bool isPathSensitive() const { return ErrorNode != nullptr; }
205 
206  const ExplodedNode *getErrorNode() const { return ErrorNode; }
207 
208  StringRef getDescription() const { return Description; }
209 
210  StringRef getShortDescription(bool UseFallback = true) const {
211  if (ShortDescription.empty() && UseFallback)
212  return Description;
213  return ShortDescription;
214  }
215 
216  /// Indicates whether or not any path pruning should take place
217  /// when generating a PathDiagnostic from this BugReport.
218  bool shouldPrunePath() const { return !DoNotPrunePath; }
219 
220  /// Disable all path pruning when generating a PathDiagnostic.
221  void disablePathPruning() { DoNotPrunePath = true; }
222 
223  void markInteresting(SymbolRef sym);
224  void markInteresting(const MemRegion *R);
225  void markInteresting(SVal V);
226  void markInteresting(const LocationContext *LC);
227 
228  bool isInteresting(SymbolRef sym);
229  bool isInteresting(const MemRegion *R);
230  bool isInteresting(SVal V);
231  bool isInteresting(const LocationContext *LC);
232 
233  /// Returns whether or not this report should be considered valid.
234  ///
235  /// Invalid reports are those that have been classified as likely false
236  /// positives after the fact.
237  bool isValid() const {
238  return Invalidations.empty();
239  }
240 
241  /// Marks the current report as invalid, meaning that it is probably a false
242  /// positive and should not be reported to the user.
243  ///
244  /// The \p Tag and \p Data arguments are intended to be opaque identifiers for
245  /// this particular invalidation, where \p Tag represents the visitor
246  /// responsible for invalidation, and \p Data represents the reason this
247  /// visitor decided to invalidate the bug report.
248  ///
249  /// \sa removeInvalidation
250  void markInvalid(const void *Tag, const void *Data) {
251  Invalidations.insert(std::make_pair(Tag, Data));
252  }
253 
254  /// Return the canonical declaration, be it a method or class, where
255  /// this issue semantically occurred.
256  const Decl *getDeclWithIssue() const;
257 
258  /// Specifically set the Decl where an issue occurred. This isn't necessary
259  /// for BugReports that cover a path as it will be automatically inferred.
260  void setDeclWithIssue(const Decl *declWithIssue) {
261  DeclWithIssue = declWithIssue;
262  }
263 
264  /// Add new item to the list of additional notes that need to be attached to
265  /// this path-insensitive report. If you want to add extra notes to a
266  /// path-sensitive report, you need to use a BugReporterVisitor because it
267  /// allows you to specify where exactly in the auto-generated path diagnostic
268  /// the extra note should appear.
269  void addNote(StringRef Msg, const PathDiagnosticLocation &Pos,
270  ArrayRef<SourceRange> Ranges) {
271  auto P = std::make_shared<PathDiagnosticNotePiece>(Pos, Msg);
272 
273  for (const auto &R : Ranges)
274  P->addRange(R);
275 
276  Notes.push_back(std::move(P));
277  }
278 
279  // FIXME: Instead of making an override, we could have default-initialized
280  // Ranges with {}, however it crashes the MSVC 2013 compiler.
281  void addNote(StringRef Msg, const PathDiagnosticLocation &Pos) {
282  std::vector<SourceRange> Ranges;
283  addNote(Msg, Pos, Ranges);
284  }
285 
286  virtual const NoteList &getNotes() {
287  return Notes;
288  }
289 
290  /// This allows for addition of meta data to the diagnostic.
291  ///
292  /// Currently, only the HTMLDiagnosticClient knows how to display it.
293  void addExtraText(StringRef S) {
294  ExtraText.push_back(S);
295  }
296 
297  virtual const ExtraTextList &getExtraText() {
298  return ExtraText;
299  }
300 
301  /// Return the "definitive" location of the reported bug.
302  ///
303  /// While a bug can span an entire path, usually there is a specific
304  /// location that can be used to identify where the key issue occurred.
305  /// This location is used by clients rendering diagnostics.
306  virtual PathDiagnosticLocation getLocation(const SourceManager &SM) const;
307 
308  /// Get the location on which the report should be uniqued.
310  return UniqueingLocation;
311  }
312 
313  /// Get the declaration containing the uniqueing location.
314  const Decl *getUniqueingDecl() const {
315  return UniqueingDecl;
316  }
317 
318  const Stmt *getStmt() const;
319 
320  /// Add a range to a bug report.
321  ///
322  /// Ranges are used to highlight regions of interest in the source code.
323  /// They should be at the same source code line as the BugReport location.
324  /// By default, the source range of the statement corresponding to the error
325  /// node will be used; add a single invalid range to specify absence of
326  /// ranges.
328  assert((R.isValid() || Ranges.empty()) && "Invalid range can only be used "
329  "to specify that the report does not have a range.");
330  Ranges.push_back(R);
331  }
332 
333  /// Get the SourceRanges associated with the report.
334  virtual llvm::iterator_range<ranges_iterator> getRanges();
335 
336  /// Add custom or predefined bug report visitors to this report.
337  ///
338  /// The visitors should be used when the default trace is not sufficient.
339  /// For example, they allow constructing a more elaborate trace.
340  /// \sa registerConditionVisitor(), registerTrackNullOrUndefValue(),
341  /// registerFindLastStore(), registerNilReceiverVisitor(), and
342  /// registerVarDeclsLastStore().
343  void addVisitor(std::unique_ptr<BugReporterVisitor> visitor);
344 
345  /// Remove all visitors attached to this bug report.
346  void clearVisitors();
347 
348  /// Iterators through the custom diagnostic visitors.
349  visitor_iterator visitor_begin() { return Callbacks.begin(); }
350  visitor_iterator visitor_end() { return Callbacks.end(); }
351 
352  /// Profile to identify equivalent bug reports for error report coalescing.
353  /// Reports are uniqued to ensure that we do not emit multiple diagnostics
354  /// for each bug.
355  virtual void Profile(llvm::FoldingSetNodeID& hash) const;
356 };
357 
358 //===----------------------------------------------------------------------===//
359 // BugTypes (collections of related reports).
360 //===----------------------------------------------------------------------===//
361 
362 class BugReportEquivClass : public llvm::FoldingSetNode {
363  friend class BugReporter;
364 
365  /// List of *owned* BugReport objects.
366  llvm::ilist<BugReport> Reports;
367 
368  void AddReport(std::unique_ptr<BugReport> R) {
369  Reports.push_back(R.release());
370  }
371 
372 public:
373  BugReportEquivClass(std::unique_ptr<BugReport> R) { AddReport(std::move(R)); }
375 
376  void Profile(llvm::FoldingSetNodeID& ID) const {
377  assert(!Reports.empty());
378  Reports.front().Profile(ID);
379  }
380 
381  using iterator = llvm::ilist<BugReport>::iterator;
382  using const_iterator = llvm::ilist<BugReport>::const_iterator;
383 
384  iterator begin() { return Reports.begin(); }
385  iterator end() { return Reports.end(); }
386 
387  const_iterator begin() const { return Reports.begin(); }
388  const_iterator end() const { return Reports.end(); }
389 };
390 
391 //===----------------------------------------------------------------------===//
392 // BugReporter and friends.
393 //===----------------------------------------------------------------------===//
394 
396 public:
397  virtual ~BugReporterData();
398 
399  virtual DiagnosticsEngine& getDiagnostic() = 0;
400  virtual ArrayRef<PathDiagnosticConsumer*> getPathDiagnosticConsumers() = 0;
401  virtual ASTContext &getASTContext() = 0;
402  virtual SourceManager &getSourceManager() = 0;
403  virtual AnalyzerOptions &getAnalyzerOptions() = 0;
404 };
405 
406 /// BugReporter is a utility class for generating PathDiagnostics for analysis.
407 /// It collects the BugReports and BugTypes and knows how to generate
408 /// and flush the corresponding diagnostics.
409 ///
410 /// The base class is used for generating path-insensitive
411 class BugReporter {
412 public:
413  enum Kind { BaseBRKind, GRBugReporterKind };
414 
415 private:
416  using BugTypesTy = llvm::ImmutableSet<BugType *>;
417 
418  BugTypesTy::Factory F;
419  BugTypesTy BugTypes;
420 
421  const Kind kind;
422  BugReporterData& D;
423 
424  /// Generate and flush the diagnostics for the given bug report.
425  void FlushReport(BugReportEquivClass& EQ);
426 
427  /// Generate the diagnostics for the given bug report.
428  std::unique_ptr<DiagnosticForConsumerMapTy>
429  generateDiagnosticForConsumerMap(BugReport *exampleReport,
431  ArrayRef<BugReport *> bugReports);
432 
433  /// The set of bug reports tracked by the BugReporter.
434  llvm::FoldingSet<BugReportEquivClass> EQClasses;
435 
436  /// A vector of BugReports for tracking the allocated pointers and cleanup.
437  std::vector<BugReportEquivClass *> EQClassesVector;
438 
439 protected:
441  : BugTypes(F.getEmptySet()), kind(k), D(d) {}
442 
443 public:
445  : BugTypes(F.getEmptySet()), kind(BaseBRKind), D(d) {}
446  virtual ~BugReporter();
447 
448  /// Generate and flush diagnostics for all bug reports.
449  void FlushReports();
450 
451  Kind getKind() const { return kind; }
452 
454  return D.getDiagnostic();
455  }
456 
458  return D.getPathDiagnosticConsumers();
459  }
460 
461  /// Iterator over the set of BugTypes tracked by the BugReporter.
462  using iterator = BugTypesTy::iterator;
463  iterator begin() { return BugTypes.begin(); }
464  iterator end() { return BugTypes.end(); }
465 
466  /// Iterator over the set of BugReports tracked by the BugReporter.
467  using EQClasses_iterator = llvm::FoldingSet<BugReportEquivClass>::iterator;
468  EQClasses_iterator EQClasses_begin() { return EQClasses.begin(); }
469  EQClasses_iterator EQClasses_end() { return EQClasses.end(); }
470 
472 
474 
476 
477  virtual std::unique_ptr<DiagnosticForConsumerMapTy>
479  ArrayRef<BugReport *> &bugReports) {
480  return {};
481  }
482 
483  void Register(const BugType *BT);
484 
485  /// Add the given report to the set of reports tracked by BugReporter.
486  ///
487  /// The reports are usually generated by the checkers. Further, they are
488  /// folded based on the profile value, which is done to coalesce similar
489  /// reports.
490  void emitReport(std::unique_ptr<BugReport> R);
491 
492  void EmitBasicReport(const Decl *DeclWithIssue, const CheckerBase *Checker,
493  StringRef BugName, StringRef BugCategory,
494  StringRef BugStr, PathDiagnosticLocation Loc,
496 
497  void EmitBasicReport(const Decl *DeclWithIssue, CheckName CheckName,
498  StringRef BugName, StringRef BugCategory,
499  StringRef BugStr, PathDiagnosticLocation Loc,
501 
502 private:
503  llvm::StringMap<BugType *> StrBugTypes;
504 
505  /// Returns a BugType that is associated with the given name and
506  /// category.
507  BugType *getBugTypeForName(CheckName CheckName, StringRef name,
508  StringRef category);
509 };
510 
511 /// GRBugReporter is used for generating path-sensitive reports.
512 class GRBugReporter : public BugReporter {
513  ExprEngine& Eng;
514 
515 public:
517  : BugReporter(d, GRBugReporterKind), Eng(eng) {}
518 
519  ~GRBugReporter() override;
520 
521  /// getGraph - Get the exploded graph created by the analysis engine
522  /// for the analyzed method or function.
523  ExplodedGraph &getGraph();
524 
525  /// getStateManager - Return the state manager used by the analysis
526  /// engine.
527  ProgramStateManager &getStateManager();
528 
529  /// \p bugReports A set of bug reports within a *single* equivalence class
530  ///
531  /// \return A mapping from consumers to the corresponding diagnostics.
532  /// Iterates through the bug reports within a single equivalence class,
533  /// stops at a first non-invalidated report.
534  std::unique_ptr<DiagnosticForConsumerMapTy>
535  generatePathDiagnostics(ArrayRef<PathDiagnosticConsumer *> consumers,
536  ArrayRef<BugReport *> &bugReports) override;
537 
538  /// classof - Used by isa<>, cast<>, and dyn_cast<>.
539  static bool classof(const BugReporter* R) {
540  return R->getKind() == GRBugReporterKind;
541  }
542 };
543 
544 
547 
548 public:
550 
551  const ExplodedNode *getOriginalNode(const ExplodedNode *N) override {
552  return M.lookup(N);
553  }
554 };
555 
557  GRBugReporter &BR;
558  NodeMapClosure NMC;
559 
560  virtual void anchor();
561 
562 public:
564  : BR(br), NMC(Backmap) {}
565 
566  virtual ~BugReporterContext() = default;
567 
568  GRBugReporter& getBugReporter() { return BR; }
569 
570  ExplodedGraph &getGraph() { return BR.getGraph(); }
571 
573  return BR.getStateManager();
574  }
575 
577  return getStateManager().getSValBuilder();
578  }
579 
581  return BR.getContext();
582  }
583 
585  return BR.getSourceManager();
586  }
587 
589  return BR.getAnalyzerOptions();
590  }
591 
592  NodeMapClosure& getNodeResolver() { return NMC; }
593 };
594 
595 
596 /// The tag upon which the TagVisitor reacts. Add these in order to display
597 /// additional PathDiagnosticEventPieces along the path.
598 class NoteTag : public ProgramPointTag {
599 public:
600  using Callback =
601  std::function<std::string(BugReporterContext &, BugReport &)>;
602 
603 private:
604  static int Kind;
605 
606  const Callback Cb;
607 
608  NoteTag(Callback &&Cb) : ProgramPointTag(&Kind), Cb(std::move(Cb)) {}
609 
610 public:
611  static bool classof(const ProgramPointTag *T) {
612  return T->getTagKind() == &Kind;
613  }
614 
616  BugReport &R) const {
617  std::string Msg = Cb(BRC, R);
618  if (Msg.empty())
619  return None;
620 
621  return std::move(Msg);
622  }
623 
624  StringRef getTagDescription() const override {
625  // TODO: Remember a few examples of generated messages
626  // and display them in the ExplodedGraph dump by
627  // returning them from this function.
628  return "Note Tag";
629  }
630 
631  // Manage memory for NoteTag objects.
632  class Factory {
633  std::vector<std::unique_ptr<NoteTag>> Tags;
634 
635  public:
636  const NoteTag *makeNoteTag(Callback &&Cb) {
637  // We cannot use make_unique because we cannot access the private
638  // constructor from inside it.
639  std::unique_ptr<NoteTag> T(new NoteTag(std::move(Cb)));
640  Tags.push_back(std::move(T));
641  return Tags.back().get();
642  }
643  };
644 
645  friend class TagVisitor;
646 };
647 
648 } // namespace ento
649 
650 } // namespace clang
651 
652 #endif // LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_BUGREPORTER_H
const ExplodedNode * getOriginalNode(const ExplodedNode *N) override
Definition: BugReporter.h:551
BugReporter(BugReporterData &d)
Definition: BugReporter.h:444
bool shouldPrunePath() const
Indicates whether or not any path pruning should take place when generating a PathDiagnostic from thi...
Definition: BugReporter.h:218
const NoteTag * makeNoteTag(Callback &&Cb)
Definition: BugReporter.h:636
MemRegion - The root abstract class for all memory regions.
Definition: MemRegion.h:94
PathDiagnosticLocation getUniqueingLocation() const
Get the location on which the report should be uniqued.
Definition: BugReporter.h:309
bool isInteresting(SymbolRef sym)
AnalyzerOptions & getAnalyzerOptions()
Definition: BugReporter.h:588
Stmt - This represents one statement.
Definition: Stmt.h:65
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
StringRef getDescription() const
Definition: BugReporter.h:208
StringRef P
ArrayRef< PathDiagnosticConsumer * > getPathDiagnosticConsumers()
Definition: BugReporter.h:457
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
virtual PathDiagnosticLocation getLocation(const SourceManager &SM) const
Return the "definitive" location of the reported bug.
virtual std::unique_ptr< DiagnosticForConsumerMapTy > generatePathDiagnostics(ArrayRef< PathDiagnosticConsumer *> consumers, ArrayRef< BugReport *> &bugReports)
Definition: BugReporter.h:478
NodeMapClosure(InterExplodedGraphMap &m)
Definition: BugReporter.h:549
void addNote(StringRef Msg, const PathDiagnosticLocation &Pos)
Definition: BugReporter.h:281
void disablePathPruning()
Disable all path pruning when generating a PathDiagnostic.
Definition: BugReporter.h:221
SmallVector< SourceRange, 4 > Ranges
Definition: BugReporter.h:106
virtual AnalyzerOptions & getAnalyzerOptions()=0
const BugType & BT
Definition: BugReporter.h:97
llvm::DenseMap< PathDiagnosticConsumer *, std::unique_ptr< PathDiagnostic > > DiagnosticForConsumerMapTy
A mapping from diagnostic consumers to the diagnostics they should consume.
Definition: BugReporter.h:71
void clearVisitors()
Remove all visitors attached to this bug report.
Symbolic value.
Definition: SymExpr.h:29
void addRange(SourceRange R)
Add a range to a bug report.
Definition: BugReporter.h:327
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
BugReport(BugType &bt, StringRef desc, const ExplodedNode *errornode, PathDiagnosticLocation LocationToUnique, const Decl *DeclToUnique)
Create a BugReport with a custom uniqueing location.
Definition: BugReporter.h:184
bool isValid() const
Returns whether or not this report should be considered valid.
Definition: BugReporter.h:237
std::function< std::string(BugReporterContext &, BugReport &)> Callback
Definition: BugReporter.h:601
Definition: Format.h:2222
std::string ShortDescription
Definition: BugReporter.h:99
virtual DiagnosticsEngine & getDiagnostic()=0
llvm::SmallSet< InvalidationRecord, 4 > Invalidations
If non-empty, this bug report is likely a false positive and should not be shown to the user...
Definition: BugReporter.h:154
SmallVector< Regions *, 2 > interestingRegions
A (stack of) set of regions that are registered with this report as being "interesting", and thus used to help decide which diagnostics to include when constructing the final path diagnostic.
Definition: BugReporter.h:125
virtual llvm::iterator_range< ranges_iterator > getRanges()
Get the SourceRanges associated with the report.
llvm::FoldingSet< BugReporterVisitor > CallbacksSet
Used for ensuring the visitors are only added once.
Definition: BugReporter.h:136
const Stmt * getStmt() const
llvm::SmallSet< const LocationContext *, 2 > InterestingLocationContexts
A set of location contexts that correspoind to call sites which should be considered "interesting"...
Definition: BugReporter.h:129
const BugType & getBugType() const
Definition: BugReporter.h:191
BugReporter(BugReporterData &d, Kind k)
Definition: BugReporter.h:440
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
ASTContext & getContext()
Definition: BugReporter.h:471
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:148
void Profile(llvm::FoldingSetNodeID &ID) const
Definition: BugReporter.h:376
GRBugReporter(BugReporterData &d, ExprEngine &eng)
Definition: BugReporter.h:516
const Decl * getDeclWithIssue() const
Return the canonical declaration, be it a method or class, where this issue semantically occurred...
static bool classof(const ProgramPointTag *T)
Definition: BugReporter.h:611
void addVisitor(std::unique_ptr< BugReporterVisitor > visitor)
Add custom or predefined bug report visitors to this report.
virtual const NoteList & getNotes()
Definition: BugReporter.h:286
const_iterator begin() const
Definition: BugReporter.h:387
NodeMapClosure & getNodeResolver()
Definition: BugReporter.h:592
const Decl * UniqueingDecl
Definition: BugReporter.h:103
VisitorList::iterator visitor_iterator
Definition: BugReporter.h:89
BugReportEquivClass(std::unique_ptr< BugReport > R)
Definition: BugReporter.h:373
bool DoNotPrunePath
When set, this flag disables all callstack pruning from a diagnostic path.
Definition: BugReporter.h:141
virtual const ExtraTextList & getExtraText()
Definition: BugReporter.h:297
BugTypesTy::iterator iterator
Iterator over the set of BugTypes tracked by the BugReporter.
Definition: BugReporter.h:462
visitor_iterator visitor_end()
Definition: BugReporter.h:350
visitor_iterator visitor_begin()
Iterators through the custom diagnostic visitors.
Definition: BugReporter.h:349
virtual SourceManager & getSourceManager()=0
const Decl * getUniqueingDecl() const
Get the declaration containing the uniqueing location.
Definition: BugReporter.h:314
void addNote(StringRef Msg, const PathDiagnosticLocation &Pos, ArrayRef< SourceRange > Ranges)
Add new item to the list of additional notes that need to be attached to this path-insensitive report...
Definition: BugReporter.h:269
BugReporterContext(GRBugReporter &br, InterExplodedGraphMap &Backmap)
Definition: BugReporter.h:563
void markInteresting(SymbolRef sym)
The tag upon which the TagVisitor reacts.
Definition: BugReporter.h:598
std::pair< const void *, const void * > InvalidationRecord
Used to track unique reasons why a bug report might be invalid.
Definition: BugReporter.h:147
const SourceManager & SM
Definition: Format.cpp:1568
AnalyzerOptions & getAnalyzerOptions()
Definition: BugReporter.h:475
virtual ArrayRef< PathDiagnosticConsumer * > getPathDiagnosticConsumers()=0
BugReporter is a utility class for generating PathDiagnostics for analysis.
Definition: BugReporter.h:411
PathDiagnosticLocation UniqueingLocation
Definition: BugReporter.h:102
static bool classof(const BugReporter *R)
classof - Used by isa<>, cast<>, and dyn_cast<>.
Definition: BugReporter.h:539
Kind
EQClasses_iterator EQClasses_begin()
Definition: BugReporter.h:468
const ExplodedNode * ErrorNode
Definition: BugReporter.h:105
ProgramPoints can be "tagged" as representing points specific to a given analysis entity...
Definition: ProgramPoint.h:39
ExplodedGraph & getGraph()
getGraph - Get the exploded graph created by the analysis engine for the analyzed method or function...
std::string Description
Definition: BugReporter.h:100
SVal - This represents a symbolic expression, which can be either an L-value or an R-value...
Definition: SVals.h:75
PathDiagnosticLocation Location
Definition: BugReporter.h:101
const Decl * DeclWithIssue
Definition: BugReporter.h:98
VisitorList Callbacks
A set of custom visitors which generate "event" diagnostics at interesting points in the path...
Definition: BugReporter.h:133
SmallVector< Symbols *, 2 > interestingSymbols
A (stack of) a set of symbols that are registered with this report as being "interesting", and thus used to help decide which diagnostics to include when constructing the final path diagnostic.
Definition: BugReporter.h:118
Dataflow Directional Tag Classes.
ExtraTextList ExtraText
Definition: BugReporter.h:107
BugReport(const BugType &bt, StringRef desc, const ExplodedNode *errornode)
Definition: BugReporter.h:166
Optional< std::string > generateMessage(BugReporterContext &BRC, BugReport &R) const
Definition: BugReporter.h:615
BugReport(const BugType &bt, StringRef desc, PathDiagnosticLocation l)
Definition: BugReporter.h:174
GRBugReporter & getBugReporter()
Definition: BugReporter.h:568
BugReport(const BugType &bt, StringRef shortDesc, StringRef desc, const ExplodedNode *errornode)
Definition: BugReporter.h:169
llvm::DenseMap< const ExplodedNode *, const ExplodedNode * > InterExplodedGraphMap
StringRef getTagDescription() const override
Definition: BugReporter.h:624
DiagnosticsEngine & getDiagnostic()
Definition: BugReporter.h:453
const_iterator end() const
Definition: BugReporter.h:388
ProgramStateManager & getStateManager()
Definition: BugReporter.h:572
const ExplodedNode * getErrorNode() const
Definition: BugReporter.h:206
virtual void Profile(llvm::FoldingSetNodeID &hash) const
Profile to identify equivalent bug reports for error report coalescing.
EQClasses_iterator EQClasses_end()
Definition: BugReporter.h:469
StringRef getShortDescription(bool UseFallback=true) const
Definition: BugReporter.h:210
llvm::FoldingSet< BugReportEquivClass >::iterator EQClasses_iterator
Iterator over the set of BugReports tracked by the BugReporter.
Definition: BugReporter.h:467
Stores options for the analyzer from the command line.
llvm::ilist< BugReport >::iterator iterator
Definition: BugReporter.h:381
SourceManager & getSourceManager()
Definition: BugReporter.h:473
ProgramStateManager & getStateManager()
getStateManager - Return the state manager used by the analysis engine.
Defines the clang::SourceLocation class and associated facilities.
bool isValid() const
void addExtraText(StringRef S)
This allows for addition of meta data to the diagnostic.
Definition: BugReporter.h:293
GRBugReporter is used for generating path-sensitive reports.
Definition: BugReporter.h:512
void markInvalid(const void *Tag, const void *Data)
Marks the current report as invalid, meaning that it is probably a false positive and should not be r...
Definition: BugReporter.h:250
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:60
virtual const ExplodedNode * getOriginalNode(const ExplodedNode *N)=0
A trivial tuple used to represent a source range.
This class provides an interface through which checkers can create individual bug reports...
Definition: BugReporter.h:75
llvm::ilist< BugReport >::const_iterator const_iterator
Definition: BugReporter.h:382
This class handles loading and caching of source files into memory.
const void * getTagKind() const
Used to implement &#39;isKind&#39; in subclasses.
Definition: ProgramPoint.h:46
virtual ASTContext & getASTContext()=0
SourceManager & getSourceManager()
Definition: BugReporter.h:584
void setDeclWithIssue(const Decl *declWithIssue)
Specifically set the Decl where an issue occurred.
Definition: BugReporter.h:260
bool isPathSensitive() const
True when the report has an execution path associated with it.
Definition: BugReporter.h:204