reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Derived Classes

tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugType.h

   69 class BuiltinBug : public BugType {

tools/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp

   41 class APIMisuse : public BugType {

tools/clang/lib/StaticAnalyzer/Checkers/NSErrorChecker.cpp

  134 class NSErrorDerefBug : public BugType {
  141 class CFErrorDerefBug : public BugType {

tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.h

   27 class RefCountBug : public BugType {

Declarations

tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h

   56 class BugType;

References

tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h

  128   const BugType& BT;
  136   BugReport(Kind kind, const BugType &bt, StringRef desc)
  139   BugReport(Kind K, const BugType &BT, StringRef ShortDescription,
  149   const BugType& getBugType() const { return BT; }
  256   BasicBugReport(const BugType &bt, StringRef desc, PathDiagnosticLocation l)
  369   PathSensitiveBugReport(const BugType &bt, StringRef desc,
  375   PathSensitiveBugReport(const BugType &bt, StringRef shortDesc, StringRef desc,
  389   PathSensitiveBugReport(BugType &bt, StringRef desc,
  631   llvm::StringMap<BugType *> StrBugTypes;
  635   BugType *getBugTypeForName(CheckerNameRef CheckerName, StringRef name,

tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugType.h

   69 class BuiltinBug : public BugType {

tools/clang/lib/Analysis/plugins/SampleAnalyzer/MainCallChecker.cpp

   11   mutable std::unique_ptr<BugType> BT;
   37       BT.reset(new BugType(this, "call to main", "example analyzer plugin"));

tools/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp

   41 class APIMisuse : public BugType {
  599   mutable std::unique_ptr<BugType> BT;
  657   mutable std::unique_ptr<BugType> BT;

tools/clang/lib/StaticAnalyzer/Checkers/BlockInCriticalSectionChecker.cpp

   40   std::unique_ptr<BugType> BlockInCritSectionBugType;
   81       new BugType(this, "Call to blocking function in critical section",

tools/clang/lib/StaticAnalyzer/Checkers/CStringChecker.cpp

   37   mutable std::unique_ptr<BugType> BT_Null, BT_Bounds, BT_Overlap,
  569     BT_Overlap.reset(new BugType(Filter.CheckNameCStringBufferOverlap,

tools/clang/lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp

   37   mutable std::unique_ptr<BugType> BT_call_null;
   38   mutable std::unique_ptr<BugType> BT_call_undef;
   39   mutable std::unique_ptr<BugType> BT_cxx_call_null;
   40   mutable std::unique_ptr<BugType> BT_cxx_call_undef;
   41   mutable std::unique_ptr<BugType> BT_call_arg;
   42   mutable std::unique_ptr<BugType> BT_cxx_delete_undef;
   43   mutable std::unique_ptr<BugType> BT_msg_undef;
   44   mutable std::unique_ptr<BugType> BT_objc_prop_undef;
   45   mutable std::unique_ptr<BugType> BT_objc_subscript_undef;
   46   mutable std::unique_ptr<BugType> BT_msg_arg;
   47   mutable std::unique_ptr<BugType> BT_msg_ret;
   48   mutable std::unique_ptr<BugType> BT_call_few_args;
   69                           std::unique_ptr<BugType> &BT,
   72   static void emitBadCall(BugType *BT, CheckerContext &C, const Expr *BadE);
   80   void LazyInit_BT(const char *desc, std::unique_ptr<BugType> &BT) const {
   86                           std::unique_ptr<BugType> &BT,
   92 void CallAndMessageChecker::emitBadCall(BugType *BT, CheckerContext &C,
  145     std::unique_ptr<BugType> &BT, const ParmVarDecl *ParamDecl, const char *BD,
  239                                                std::unique_ptr<BugType> &BT,
  360     BugType *BT = BT_cxx_delete_undef.get();
  435   std::unique_ptr<BugType> *BT;
  461       BugType *BT = nullptr;

tools/clang/lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp

  106   std::unique_ptr<BugType> MissingReleaseBugType;
  107   std::unique_ptr<BugType> ExtraReleaseBugType;
  108   std::unique_ptr<BugType> MistakenDeallocBugType;
  757       new BugType(this, "Missing ivar release (leak)",
  761       new BugType(this, "Extra ivar release",
  765       new BugType(this, "Mistaken dealloc",

tools/clang/lib/StaticAnalyzer/Checkers/CloneChecker.cpp

   38   mutable std::unique_ptr<BugType> BT_Exact, BT_Suspicious;
  112     BT_Exact.reset(new BugType(this, "Exact code clone", "Code clone"));
  159         new BugType(this, "Suspicious code clone", "Code clone"));

tools/clang/lib/StaticAnalyzer/Checkers/DeleteWithNonVirtualDtorChecker.cpp

   39   mutable std::unique_ptr<BugType> BT;
   89     BT.reset(new BugType(this,

tools/clang/lib/StaticAnalyzer/Checkers/DynamicTypeChecker.cpp

   33   mutable std::unique_ptr<BugType> BT;
   37           new BugType(this, "Dynamic and static type mismatch", "Type Error"));

tools/clang/lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp

   69   mutable std::unique_ptr<BugType> ObjCGenericsBugType;
   73           new BugType(this, "Generics", categories::CoreFoundationObjectiveC));

tools/clang/lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp

   25   mutable std::unique_ptr<BugType> BT;
  149     BT.reset(new BugType(this, "Checking analyzer assumptions", "debug"));

tools/clang/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp

   94   mutable std::unique_ptr<BugType> BT;
   97       BT.reset(new BugType(this, "Use of Untrusted Data", "Untrusted Data"));

tools/clang/lib/StaticAnalyzer/Checkers/IteratorChecker.cpp

  178   std::unique_ptr<BugType> OutOfRangeBugType;
  179   std::unique_ptr<BugType> MismatchedBugType;
  180   std::unique_ptr<BugType> InvalidatedBugType;
  359       new BugType(this, "Iterator out of range", "Misuse of STL APIs"));
  361       new BugType(this, "Iterator(s) mismatched", "Misuse of STL APIs",
  364       new BugType(this, "Iterator invalidated", "Misuse of STL APIs"));

tools/clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp

   63   mutable std::unique_ptr<BugType> BT;
  110   BT.reset(new BugType(this, "Unlocalizable string",

tools/clang/lib/StaticAnalyzer/Checkers/MIGChecker.cpp

   38   BugType BT{this, "Use-after-free (MIG calling convention violation)",

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.h

   28     UnmatchedWaitBugType.reset(new BugType(&CB, "Unmatched wait", MPIError));
   30         new BugType(&CB, "Double nonblocking", MPIError));
   31     MissingWaitBugType.reset(new BugType(&CB, "Missing wait", MPIError));
   74   std::unique_ptr<BugType> UnmatchedWaitBugType;
   75   std::unique_ptr<BugType> MissingWaitBugType;
   76   std::unique_ptr<BugType> DoubleNonblockingBugType;

tools/clang/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp

   34   mutable std::unique_ptr<BugType> BT;
  104       BT.reset(new BugType(this, "Improper use of SecKeychain API",

tools/clang/lib/StaticAnalyzer/Checkers/MacOSXAPIChecker.cpp

   33   mutable std::unique_ptr<BugType> BT_dispatchOnce;
  139     BT_dispatchOnce.reset(new BugType(this, "Improper use of 'dispatch_once'",

tools/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp

  388   mutable std::unique_ptr<BugType> BT_DoubleFree[CK_NumCheckKinds];
  389   mutable std::unique_ptr<BugType> BT_DoubleDelete;
  390   mutable std::unique_ptr<BugType> BT_Leak[CK_NumCheckKinds];
  391   mutable std::unique_ptr<BugType> BT_UseFree[CK_NumCheckKinds];
  392   mutable std::unique_ptr<BugType> BT_BadFree[CK_NumCheckKinds];
  393   mutable std::unique_ptr<BugType> BT_FreeAlloca[CK_NumCheckKinds];
  394   mutable std::unique_ptr<BugType> BT_MismatchedDealloc;
  395   mutable std::unique_ptr<BugType> BT_OffsetFree[CK_NumCheckKinds];
  396   mutable std::unique_ptr<BugType> BT_UseZerroAllocated[CK_NumCheckKinds];
 2060       BT_BadFree[*CheckKind].reset(new BugType(
 2106       BT_FreeAlloca[*CheckKind].reset(new BugType(
 2131           new BugType(CheckNames[CK_MismatchedDeallocatorChecker],
 2193     BT_OffsetFree[*CheckKind].reset(new BugType(
 2246       BT_UseFree[*CheckKind].reset(new BugType(
 2284       BT_DoubleFree[*CheckKind].reset(new BugType(
 2312       BT_DoubleDelete.reset(new BugType(CheckNames[CK_NewDeleteChecker],
 2341           new BugType(CheckNames[*CheckKind], "Use of zero allocated",
 2368       BT_BadFree[*CheckKind].reset(new BugType(
 2581     BT_Leak[*CheckKind].reset(new BugType(CheckNames[*CheckKind], "Memory leak",

tools/clang/lib/StaticAnalyzer/Checkers/MmapWriteExecChecker.cpp

   34   mutable std::unique_ptr<BugType> BT;
   64         BT.reset(new BugType(this, "W^X check fails, Write Exec prot flags set", "Security"));

tools/clang/lib/StaticAnalyzer/Checkers/MoveChecker.cpp

  204   mutable std::unique_ptr<BugType> BT;
  397       BT.reset(new BugType(this, "Use-after-move",

tools/clang/lib/StaticAnalyzer/Checkers/NSAutoreleasePoolChecker.cpp

   34   mutable std::unique_ptr<BugType> BT;
   61     BT.reset(new BugType(this, "Use -drain instead of -release",

tools/clang/lib/StaticAnalyzer/Checkers/NSErrorChecker.cpp

  134 class NSErrorDerefBug : public BugType {
  141 class CFErrorDerefBug : public BugType {
  265   BugType *bug = nullptr;

tools/clang/lib/StaticAnalyzer/Checkers/NonNullParamChecker.cpp

   31   mutable std::unique_ptr<BugType> BTAttrNonNull;
   32   mutable std::unique_ptr<BugType> BTNullRefArg;
  190     BTAttrNonNull.reset(new BugType(

tools/clang/lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp

   85   mutable std::unique_ptr<BugType> BT;
  164       BT.reset(new BugType(this, "Nullability", categories::MemoryError));

tools/clang/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp

   33   mutable std::unique_ptr<BugType> BT;
   36       BT.reset(new BugType(this, "CFArray API",

tools/clang/lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp

   64   mutable std::unique_ptr<BugType> BT;
  160     BT.reset(new BugType(this, "Missing \"self = [(super or self) init...]\"",

tools/clang/lib/StaticAnalyzer/Checkers/ObjCSuperDeallocChecker.cpp

   33   std::unique_ptr<BugType> DoubleSuperDeallocBugType;
  219       new BugType(this, "[super dealloc] should not be called more than once",

tools/clang/lib/StaticAnalyzer/Checkers/PaddingChecker.cpp

   35   mutable std::unique_ptr<BugType> PaddingBug;
  309           std::make_unique<BugType>(this, "Excessive Padding", "Performance");

tools/clang/lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp

   70   mutable std::unique_ptr<BugType> BT_doublelock;
   71   mutable std::unique_ptr<BugType> BT_doubleunlock;
   72   mutable std::unique_ptr<BugType> BT_destroylock;
   73   mutable std::unique_ptr<BugType> BT_initlock;
   74   mutable std::unique_ptr<BugType> BT_lor;
  238         BT_doublelock.reset(new BugType(this, "Double locking",
  303         BT_doubleunlock.reset(new BugType(this, "Double unlocking",
  327         BT_lor.reset(new BugType(this, "Lock order reversal", "Lock checker"));
  397     BT_destroylock.reset(new BugType(this, "Destroy invalid lock",
  437     BT_initlock.reset(new BugType(this, "Init invalid lock",
  451     BT_destroylock.reset(new BugType(this, "Use destroyed lock",

tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.h

   27 class RefCountBug : public BugType {

tools/clang/lib/StaticAnalyzer/Checkers/SimpleStreamChecker.cpp

   56   std::unique_ptr<BugType> DoubleCloseBugType;
   57   std::unique_ptr<BugType> LeakBugType;
  109       new BugType(this, "Double fclose", "Unix Stream API Error"));
  113       new BugType(this, "Resource Leak", "Unix Stream API Error",

tools/clang/lib/StaticAnalyzer/Checkers/TaintTesterChecker.cpp

   27   mutable std::unique_ptr<BugType> BT;
   43     BT.reset(new BugType(this, "Tainted data", "General"));

tools/clang/lib/StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp

   29   mutable std::unique_ptr<BugType> BT;

tools/clang/lib/StaticAnalyzer/Checkers/UndefResultChecker.cpp

   30   mutable std::unique_ptr<BugType> BT;

tools/clang/lib/StaticAnalyzer/Checkers/UndefinedArraySubscriptChecker.cpp

   27   mutable std::unique_ptr<BugType> BT;

tools/clang/lib/StaticAnalyzer/Checkers/UndefinedAssignmentChecker.cpp

   26   mutable std::unique_ptr<BugType> BT;

tools/clang/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp

   41   mutable std::unique_ptr<BugType> BT_open, BT_pthreadOnce;
   68   mutable std::unique_ptr<BugType> BT_mallocZero;
   92                            std::unique_ptr<BugType> &BT,
   96   BT.reset(new BugType(Checker, name, categories::UnixAPI));

tools/clang/lib/StaticAnalyzer/Checkers/VLASizeChecker.cpp

   33   mutable std::unique_ptr<BugType> BT;

tools/clang/lib/StaticAnalyzer/Checkers/ValistChecker.cpp

   31   mutable std::unique_ptr<BugType> BT_leakedvalist, BT_uninitaccess;
  255       BT_uninitaccess.reset(new BugType(CheckNames[CK_Uninitialized],
  277           new BugType(CheckNames[CK_Unterminated].getName().empty()

tools/clang/lib/StaticAnalyzer/Checkers/VirtualCallChecker.cpp

   45   mutable std::unique_ptr<BugType> BT_Pure, BT_Impure;
  143   const std::unique_ptr<BugType> &BT = IsPure ? BT_Pure : BT_Impure;
  209   Chk->BT_Pure = std::make_unique<BugType>(Mgr.getCurrentCheckerName(),
  218     Chk->BT_Impure = std::make_unique<BugType>(

tools/clang/lib/StaticAnalyzer/Core/BugReporter.cpp

 1313   const BugType &BT = R->getBugType();
 1324   const BugType &BT = R->getBugType();
 2890   const BugType& BT = EQ.getReports()[0]->getBugType();
 3250   BugType *BT = getBugTypeForName(CheckName, name, category);
 3260 BugType *BugReporter::getBugTypeForName(CheckerNameRef CheckName,
 3265   BugType *&BT = StrBugTypes[fullDesc];
 3267     BT = new BugType(CheckName, name, category);

usr/include/c++/7.4.0/bits/move.h

   72     constexpr _Tp&&
   83     constexpr _Tp&&

usr/include/c++/7.4.0/bits/unique_ptr.h

   68         default_delete(const default_delete<_Up>&) noexcept { }
   72       operator()(_Tp* __ptr) const
   74 	static_assert(!is_void<_Tp>::value,
   76 	static_assert(sizeof(_Tp)>0,
  122 	  using type = _Up*;
  137       using pointer = typename _Ptr<_Tp, _Dp>::type;
  161 	typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
  163       __uniq_ptr_impl<_Tp, _Dp> _M_t;
  166       using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
  167       using element_type  = _Tp;
  252 	unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
  297           __safe_conversion_up<_Up, _Ep>,
  301 	operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
  811     { typedef unique_ptr<_Tp> __single_object; };
  823     inline typename _MakeUniq<_Tp>::__single_object
  824     make_unique(_Args&&... __args)
  825     { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }

usr/include/c++/7.4.0/type_traits

  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_Tp>>::type
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  602                           is_void<_Tp>>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
 1554     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1633     { typedef _Tp   type; };
 1645     { typedef _Tp&   type; };
 1650     : public __add_lvalue_reference_helper<_Tp>