contrib/llvm-project/clang/include/clang/StaticAnalyzer/Core/Checker.h

   1 //== Checker.h - Registration mechanism for checkers -------------*- 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 Checker, used to create and register checkers.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #ifndef LLVM_CLANG_STATICANALYZER_CORE_CHECKER_H
  14 #define LLVM_CLANG_STATICANALYZER_CORE_CHECKER_H
  15
  16 #include "clang/Analysis/ProgramPoint.h"
  17 #include "clang/Basic/LangOptions.h"
  18 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
  19 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
  20 #include "llvm/Support/Casting.h"
  21
  22 namespace clang {
  23 namespace ento {
  24   class BugReporter;
  25
  26 namespace check {
  27
  28 template <typename DECL>
  29 class ASTDecl {
  30   template <typename CHECKER>
  31   static void _checkDecl(void *checker, const Decl *D, AnalysisManager& mgr,
  32                          BugReporter &BR) {
  33     ((const CHECKER *)checker)->checkASTDecl(cast<DECL>(D), mgr, BR);
  34   }
  35
  36   static bool _handlesDecl(const Decl *D) {
  37     return isa<DECL>(D);
  38   }
  39 public:
  40   template <typename CHECKER>
  41   static void _register(CHECKER *checker, CheckerManager &mgr) {
  42     mgr._registerForDecl(CheckerManager::CheckDeclFunc(checker,
  43                                                        _checkDecl<CHECKER>),
  44                          _handlesDecl);
  45   }
  46 };
  47
  48 class ASTCodeBody {
  49   template <typename CHECKER>
  50   static void _checkBody(void *checker, const Decl *D, AnalysisManager& mgr,
  51                          BugReporter &BR) {
  52     ((const CHECKER *)checker)->checkASTCodeBody(D, mgr, BR);
  53   }
  54
  55 public:
  56   template <typename CHECKER>
  57   static void _register(CHECKER *checker, CheckerManager &mgr) {
  58     mgr._registerForBody(CheckerManager::CheckDeclFunc(checker,
  59                                                        _checkBody<CHECKER>));
  60   }
  61 };
  62
  63 class EndOfTranslationUnit {
  64   template <typename CHECKER>
  65   static void _checkEndOfTranslationUnit(void *checker,
  66                                          const TranslationUnitDecl *TU,
  67                                          AnalysisManager& mgr,
  68                                          BugReporter &BR) {
  69     ((const CHECKER *)checker)->checkEndOfTranslationUnit(TU, mgr, BR);
  70   }
  71
  72 public:
  73   template <typename CHECKER>
  74   static void _register(CHECKER *checker, CheckerManager &mgr){
  75     mgr._registerForEndOfTranslationUnit(
  76                               CheckerManager::CheckEndOfTranslationUnit(checker,
  77                                           _checkEndOfTranslationUnit<CHECKER>));
  78   }
  79 };
  80
  81 template <typename STMT>
  82 class PreStmt {
  83   template <typename CHECKER>
  84   static void _checkStmt(void *checker, const Stmt *S, CheckerContext &C) {
  85     ((const CHECKER *)checker)->checkPreStmt(cast<STMT>(S), C);
  86   }
  87
  88   static bool _handlesStmt(const Stmt *S) {
  89     return isa<STMT>(S);
  90   }
  91 public:
  92   template <typename CHECKER>
  93   static void _register(CHECKER *checker, CheckerManager &mgr) {
  94     mgr._registerForPreStmt(CheckerManager::CheckStmtFunc(checker,
  95                                                           _checkStmt<CHECKER>),
  96                             _handlesStmt);
  97   }
  98 };
  99
 100 template <typename STMT>
 101 class PostStmt {
 102   template <typename CHECKER>
 103   static void _checkStmt(void *checker, const Stmt *S, CheckerContext &C) {
 104     ((const CHECKER *)checker)->checkPostStmt(cast<STMT>(S), C);
 105   }
 106
 107   static bool _handlesStmt(const Stmt *S) {
 108     return isa<STMT>(S);
 109   }
 110 public:
 111   template <typename CHECKER>
 112   static void _register(CHECKER *checker, CheckerManager &mgr) {
 113     mgr._registerForPostStmt(CheckerManager::CheckStmtFunc(checker,
 114                                                            _checkStmt<CHECKER>),
 115                              _handlesStmt);
 116   }
 117 };
 118
 119 class PreObjCMessage {
 120   template <typename CHECKER>
 121   static void _checkObjCMessage(void *checker, const ObjCMethodCall &msg,
 122                                 CheckerContext &C) {
 123     ((const CHECKER *)checker)->checkPreObjCMessage(msg, C);
 124   }
 125
 126 public:
 127   template <typename CHECKER>
 128   static void _register(CHECKER *checker, CheckerManager &mgr) {
 129     mgr._registerForPreObjCMessage(
 130      CheckerManager::CheckObjCMessageFunc(checker, _checkObjCMessage<CHECKER>));
 131   }
 132 };
 133
 134 class ObjCMessageNil {
 135   template <typename CHECKER>
 136   static void _checkObjCMessage(void *checker, const ObjCMethodCall &msg,
 137                                 CheckerContext &C) {
 138     ((const CHECKER *)checker)->checkObjCMessageNil(msg, C);
 139   }
 140
 141 public:
 142   template <typename CHECKER>
 143   static void _register(CHECKER *checker, CheckerManager &mgr) {
 144     mgr._registerForObjCMessageNil(
 145      CheckerManager::CheckObjCMessageFunc(checker, _checkObjCMessage<CHECKER>));
 146   }
 147 };
 148
 149 class PostObjCMessage {
 150   template <typename CHECKER>
 151   static void _checkObjCMessage(void *checker, const ObjCMethodCall &msg,
 152                                 CheckerContext &C) {
 153     ((const CHECKER *)checker)->checkPostObjCMessage(msg, C);
 154   }
 155
 156 public:
 157   template <typename CHECKER>
 158   static void _register(CHECKER *checker, CheckerManager &mgr) {
 159     mgr._registerForPostObjCMessage(
 160      CheckerManager::CheckObjCMessageFunc(checker, _checkObjCMessage<CHECKER>));
 161   }
 162 };
 163
 164 class PreCall {
 165   template <typename CHECKER>
 166   static void _checkCall(void *checker, const CallEvent &msg,
 167                          CheckerContext &C) {
 168     ((const CHECKER *)checker)->checkPreCall(msg, C);
 169   }
 170
 171 public:
 172   template <typename CHECKER>
 173   static void _register(CHECKER *checker, CheckerManager &mgr) {
 174     mgr._registerForPreCall(
 175      CheckerManager::CheckCallFunc(checker, _checkCall<CHECKER>));
 176   }
 177 };
 178
 179 class PostCall {
 180   template <typename CHECKER>
 181   static void _checkCall(void *checker, const CallEvent &msg,
 182                          CheckerContext &C) {
 183     ((const CHECKER *)checker)->checkPostCall(msg, C);
 184   }
 185
 186 public:
 187   template <typename CHECKER>
 188   static void _register(CHECKER *checker, CheckerManager &mgr) {
 189     mgr._registerForPostCall(
 190      CheckerManager::CheckCallFunc(checker, _checkCall<CHECKER>));
 191   }
 192 };
 193
 194 class Location {
 195   template <typename CHECKER>
 196   static void _checkLocation(void *checker,
 197                              const SVal &location, bool isLoad, const Stmt *S,
 198                              CheckerContext &C) {
 199     ((const CHECKER *)checker)->checkLocation(location, isLoad, S, C);
 200   }
 201
 202 public:
 203   template <typename CHECKER>
 204   static void _register(CHECKER *checker, CheckerManager &mgr) {
 205     mgr._registerForLocation(
 206            CheckerManager::CheckLocationFunc(checker, _checkLocation<CHECKER>));
 207   }
 208 };
 209
 210 class Bind {
 211   template <typename CHECKER>
 212   static void _checkBind(void *checker,
 213                          const SVal &location, const SVal &val, const Stmt *S,
 214                          CheckerContext &C) {
 215     ((const CHECKER *)checker)->checkBind(location, val, S, C);
 216   }
 217
 218 public:
 219   template <typename CHECKER>
 220   static void _register(CHECKER *checker, CheckerManager &mgr) {
 221     mgr._registerForBind(
 222            CheckerManager::CheckBindFunc(checker, _checkBind<CHECKER>));
 223   }
 224 };
 225
 226 class EndAnalysis {
 227   template <typename CHECKER>
 228   static void _checkEndAnalysis(void *checker, ExplodedGraph &G,
 229                                 BugReporter &BR, ExprEngine &Eng) {
 230     ((const CHECKER *)checker)->checkEndAnalysis(G, BR, Eng);
 231   }
 232
 233 public:
 234   template <typename CHECKER>
 235   static void _register(CHECKER *checker, CheckerManager &mgr) {
 236     mgr._registerForEndAnalysis(
 237      CheckerManager::CheckEndAnalysisFunc(checker, _checkEndAnalysis<CHECKER>));
 238   }
 239 };
 240
 241 class BeginFunction {
 242   template <typename CHECKER>
 243   static void _checkBeginFunction(void *checker, CheckerContext &C) {
 244     ((const CHECKER *)checker)->checkBeginFunction(C);
 245   }
 246
 247 public:
 248   template <typename CHECKER>
 249   static void _register(CHECKER *checker, CheckerManager &mgr) {
 250     mgr._registerForBeginFunction(CheckerManager::CheckBeginFunctionFunc(
 251         checker, _checkBeginFunction<CHECKER>));
 252   }
 253 };
 254
 255 class EndFunction {
 256   template <typename CHECKER>
 257   static void _checkEndFunction(void *checker, const ReturnStmt *RS,
 258                                 CheckerContext &C) {
 259     ((const CHECKER *)checker)->checkEndFunction(RS, C);
 260   }
 261
 262 public:
 263   template <typename CHECKER>
 264   static void _register(CHECKER *checker, CheckerManager &mgr) {
 265     mgr._registerForEndFunction(
 266      CheckerManager::CheckEndFunctionFunc(checker, _checkEndFunction<CHECKER>));
 267   }
 268 };
 269
 270 class BranchCondition {
 271   template <typename CHECKER>
 272   static void _checkBranchCondition(void *checker, const Stmt *Condition,
 273                                     CheckerContext & C) {
 274     ((const CHECKER *)checker)->checkBranchCondition(Condition, C);
 275   }
 276
 277 public:
 278   template <typename CHECKER>
 279   static void _register(CHECKER *checker, CheckerManager &mgr) {
 280     mgr._registerForBranchCondition(
 281       CheckerManager::CheckBranchConditionFunc(checker,
 282                                                _checkBranchCondition<CHECKER>));
 283   }
 284 };
 285
 286 class NewAllocator {
 287   template <typename CHECKER>
 288   static void _checkNewAllocator(void *checker, const CXXNewExpr *NE,
 289                                  SVal Target, CheckerContext &C) {
 290     ((const CHECKER *)checker)->checkNewAllocator(NE, Target, C);
 291   }
 292
 293 public:
 294   template <typename CHECKER>
 295   static void _register(CHECKER *checker, CheckerManager &mgr) {
 296     mgr._registerForNewAllocator(
 297         CheckerManager::CheckNewAllocatorFunc(checker,
 298                                               _checkNewAllocator<CHECKER>));
 299   }
 300 };
 301
 302 class LiveSymbols {
 303   template <typename CHECKER>
 304   static void _checkLiveSymbols(void *checker, ProgramStateRef state,
 305                                 SymbolReaper &SR) {
 306     ((const CHECKER *)checker)->checkLiveSymbols(state, SR);
 307   }
 308
 309 public:
 310   template <typename CHECKER>
 311   static void _register(CHECKER *checker, CheckerManager &mgr) {
 312     mgr._registerForLiveSymbols(
 313      CheckerManager::CheckLiveSymbolsFunc(checker, _checkLiveSymbols<CHECKER>));
 314   }
 315 };
 316
 317 class DeadSymbols {
 318   template <typename CHECKER>
 319   static void _checkDeadSymbols(void *checker,
 320                                 SymbolReaper &SR, CheckerContext &C) {
 321     ((const CHECKER *)checker)->checkDeadSymbols(SR, C);
 322   }
 323
 324 public:
 325   template <typename CHECKER>
 326   static void _register(CHECKER *checker, CheckerManager &mgr) {
 327     mgr._registerForDeadSymbols(
 328      CheckerManager::CheckDeadSymbolsFunc(checker, _checkDeadSymbols<CHECKER>));
 329   }
 330 };
 331
 332 class RegionChanges {
 333   template <typename CHECKER>
 334   static ProgramStateRef
 335   _checkRegionChanges(void *checker,
 336                       ProgramStateRef state,
 337                       const InvalidatedSymbols *invalidated,
 338                       ArrayRef<const MemRegion *> Explicits,
 339                       ArrayRef<const MemRegion *> Regions,
 340                       const LocationContext *LCtx,
 341                       const CallEvent *Call) {
 342     return ((const CHECKER *) checker)->checkRegionChanges(state, invalidated,
 343                                                            Explicits, Regions,
 344                                                            LCtx, Call);
 345   }
 346
 347 public:
 348   template <typename CHECKER>
 349   static void _register(CHECKER *checker, CheckerManager &mgr) {
 350     mgr._registerForRegionChanges(
 351           CheckerManager::CheckRegionChangesFunc(checker,
 352                                                  _checkRegionChanges<CHECKER>));
 353   }
 354 };
 355
 356 class PointerEscape {
 357   template <typename CHECKER>
 358   static ProgramStateRef
 359   _checkPointerEscape(void *Checker,
 360                      ProgramStateRef State,
 361                      const InvalidatedSymbols &Escaped,
 362                      const CallEvent *Call,
 363                      PointerEscapeKind Kind,
 364                      RegionAndSymbolInvalidationTraits *ETraits) {
 365
 366     if (!ETraits)
 367       return ((const CHECKER *)Checker)->checkPointerEscape(State,
 368                                                             Escaped,
 369                                                             Call,
 370                                                             Kind);
 371
 372     InvalidatedSymbols RegularEscape;
 373     for (InvalidatedSymbols::const_iterator I = Escaped.begin(),
 374                                             E = Escaped.end(); I != E; ++I)
 375       if (!ETraits->hasTrait(*I,
 376               RegionAndSymbolInvalidationTraits::TK_PreserveContents) &&
 377           !ETraits->hasTrait(*I,
 378               RegionAndSymbolInvalidationTraits::TK_SuppressEscape))
 379         RegularEscape.insert(*I);
 380
 381     if (RegularEscape.empty())
 382       return State;
 383
 384     return ((const CHECKER *)Checker)->checkPointerEscape(State,
 385                                                           RegularEscape,
 386                                                           Call,
 387                                                           Kind);
 388   }
 389
 390 public:
 391   template <typename CHECKER>
 392   static void _register(CHECKER *checker, CheckerManager &mgr) {
 393     mgr._registerForPointerEscape(
 394           CheckerManager::CheckPointerEscapeFunc(checker,
 395                                                 _checkPointerEscape<CHECKER>));
 396   }
 397 };
 398
 399 class ConstPointerEscape {
 400   template <typename CHECKER>
 401   static ProgramStateRef
 402   _checkConstPointerEscape(void *Checker,
 403                       ProgramStateRef State,
 404                       const InvalidatedSymbols &Escaped,
 405                       const CallEvent *Call,
 406                       PointerEscapeKind Kind,
 407                       RegionAndSymbolInvalidationTraits *ETraits) {
 408
 409     if (!ETraits)
 410       return State;
 411
 412     InvalidatedSymbols ConstEscape;
 413     for (InvalidatedSymbols::const_iterator I = Escaped.begin(),
 414                                             E = Escaped.end(); I != E; ++I)
 415       if (ETraits->hasTrait(*I,
 416               RegionAndSymbolInvalidationTraits::TK_PreserveContents) &&
 417           !ETraits->hasTrait(*I,
 418               RegionAndSymbolInvalidationTraits::TK_SuppressEscape))
 419         ConstEscape.insert(*I);
 420
 421     if (ConstEscape.empty())
 422       return State;
 423
 424     return ((const CHECKER *)Checker)->checkConstPointerEscape(State,
 425                                                                ConstEscape,
 426                                                                Call,
 427                                                                Kind);
 428   }
 429
 430 public:
 431   template <typename CHECKER>
 432   static void _register(CHECKER *checker, CheckerManager &mgr) {
 433     mgr._registerForPointerEscape(
 434       CheckerManager::CheckPointerEscapeFunc(checker,
 435                                             _checkConstPointerEscape<CHECKER>));
 436   }
 437 };
 438
 439
 440 template <typename EVENT>
 441 class Event {
 442   template <typename CHECKER>
 443   static void _checkEvent(void *checker, const void *event) {
 444     ((const CHECKER *)checker)->checkEvent(*(const EVENT *)event);
 445   }
 446 public:
 447   template <typename CHECKER>
 448   static void _register(CHECKER *checker, CheckerManager &mgr) {
 449     mgr._registerListenerForEvent<EVENT>(
 450                  CheckerManager::CheckEventFunc(checker, _checkEvent<CHECKER>));
 451   }
 452 };
 453
 454 } // end check namespace
 455
 456 namespace eval {
 457
 458 class Assume {
 459   template <typename CHECKER>
 460   static ProgramStateRef _evalAssume(void *checker,
 461                                          ProgramStateRef state,
 462                                          const SVal &cond,
 463                                          bool assumption) {
 464     return ((const CHECKER *)checker)->evalAssume(state, cond, assumption);
 465   }
 466
 467 public:
 468   template <typename CHECKER>
 469   static void _register(CHECKER *checker, CheckerManager &mgr) {
 470     mgr._registerForEvalAssume(
 471                  CheckerManager::EvalAssumeFunc(checker, _evalAssume<CHECKER>));
 472   }
 473 };
 474
 475 class Call {
 476   template <typename CHECKER>
 477   static bool _evalCall(void *checker, const CallEvent &Call,
 478                         CheckerContext &C) {
 479     return ((const CHECKER *)checker)->evalCall(Call, C);
 480   }
 481
 482 public:
 483   template <typename CHECKER>
 484   static void _register(CHECKER *checker, CheckerManager &mgr) {
 485     mgr._registerForEvalCall(
 486                      CheckerManager::EvalCallFunc(checker, _evalCall<CHECKER>));
 487   }
 488 };
 489
 490 } // end eval namespace
 491
 492 class CheckerBase : public ProgramPointTag {
 493   CheckerNameRef Name;
 494   friend class ::clang::ento::CheckerManager;
 495
 496 public:
 497   StringRef getTagDescription() const override;
 498   CheckerNameRef getCheckerName() const;
 499
 500   /// See CheckerManager::runCheckersForPrintState.
 501   virtual void printState(raw_ostream &Out, ProgramStateRef State,
 502                           const char *NL, const char *Sep) const { }
 503 };
 504
 505 /// Dump checker name to stream.
 506 raw_ostream& operator<<(raw_ostream &Out, const CheckerBase &Checker);
 507
 508 /// Tag that can use a checker name as a message provider
 509 /// (see SimpleProgramPointTag).
 510 class CheckerProgramPointTag : public SimpleProgramPointTag {
 511 public:
 512   CheckerProgramPointTag(StringRef CheckerName, StringRef Msg);
 513   CheckerProgramPointTag(const CheckerBase *Checker, StringRef Msg);
 514 };
 515
 516 template <typename CHECK1, typename... CHECKs>
 517 class Checker : public CHECK1, public CHECKs..., public CheckerBase {
 518 public:
 519   template <typename CHECKER>
 520   static void _register(CHECKER *checker, CheckerManager &mgr) {
 521     CHECK1::_register(checker, mgr);
 522     Checker<CHECKs...>::_register(checker, mgr);
 523   }
 524 };
 525
 526 template <typename CHECK1>
 527 class Checker<CHECK1> : public CHECK1, public CheckerBase {
 528 public:
 529   template <typename CHECKER>
 530   static void _register(CHECKER *checker, CheckerManager &mgr) {
 531     CHECK1::_register(checker, mgr);
 532   }
 533 };
 534
 535 template <typename EVENT>
 536 class EventDispatcher {
 537   CheckerManager *Mgr;
 538 public:
 539   EventDispatcher() : Mgr(nullptr) { }
 540
 541   template <typename CHECKER>
 542   static void _register(CHECKER *checker, CheckerManager &mgr) {
 543     mgr._registerDispatcherForEvent<EVENT>();
 544     static_cast<EventDispatcher<EVENT> *>(checker)->Mgr = &mgr;
 545   }
 546
 547   void dispatchEvent(const EVENT &event) const {
 548     Mgr->_dispatchEvent(event);
 549   }
 550 };
 551
 552 /// We dereferenced a location that may be null.
 553 struct ImplicitNullDerefEvent {
 554   SVal Location;
 555   bool IsLoad;
 556   ExplodedNode *SinkNode;
 557   BugReporter *BR;
 558   // When true, the dereference is in the source code directly. When false, the
 559   // dereference might happen later (for example pointer passed to a parameter
 560   // that is marked with nonnull attribute.)
 561   bool IsDirectDereference;
 562
 563   static int Tag;
 564 };
 565
 566 /// A helper class which wraps a boolean value set to false by default.
 567 ///
 568 /// This class should behave exactly like 'bool' except that it doesn't need to
 569 /// be explicitly initialized.
 570 struct DefaultBool {
 571   bool val;
 572   DefaultBool() : val(false) {}
 573   /*implicit*/ operator bool&() { return val; }
 574   /*implicit*/ operator const bool&() const { return val; }
 575   DefaultBool &operator=(bool b) { val = b; return *this; }
 576 };
 577
 578 } // end ento namespace
 579
 580 } // end clang namespace
 581
 582 #endif