AnalysisBasedWarnings.h

Go to the documentation of this file.

//=- AnalysisBasedWarnings.h - Sema warnings based on libAnalysis -*- C++ -*-=//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines AnalysisBasedWarnings, a worker object used by Sema
// that issues warnings based on dataflow-analysis.
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_CLANG_SEMA_ANALYSISBASEDWARNINGS_H
#define LLVM_CLANG_SEMA_ANALYSISBASEDWARNINGS_H
 
#include "clang/AST/Decl.h"
#include "clang/Analysis/Analyses/LifetimeSafety/LifetimeStats.h"
#include "clang/Sema/ScopeInfo.h"
#include <memory>
 
namespace clang {
 
class AnalysisDeclContext;
class Decl;
class FunctionDecl;
class QualType;
class Sema;
class VarDecl;
namespace sema {
  class FunctionScopeInfo;
  class SemaPPCallbacks;
}
 
namespace sema {
 
class AnalysisBasedWarnings {
public:
  class Policy {
    friend class AnalysisBasedWarnings;
    friend class SemaPPCallbacks;
    // The warnings to run.
    LLVM_PREFERRED_TYPE(bool)
    unsigned enableCheckFallThrough : 1;
    LLVM_PREFERRED_TYPE(bool)
    unsigned enableCheckUnreachable : 1;
    LLVM_PREFERRED_TYPE(bool)
    unsigned enableThreadSafetyAnalysis : 1;
    LLVM_PREFERRED_TYPE(bool)
    unsigned enableConsumedAnalysis : 1;
  public:
    Policy();
    void disableCheckFallThrough() { enableCheckFallThrough = 0; }
  };
 
private:
  Sema &S;
 
  class InterProceduralData;
  std::unique_ptr<InterProceduralData> IPData;
 
  enum VisitFlag { NotVisited = 0, Visited = 1, Pending = 2 };
  llvm::DenseMap<const FunctionDecl*, VisitFlag> VisitedFD;
  std::multimap<VarDecl *, PossiblyUnreachableDiag>
      VarDeclPossiblyUnreachableDiags;
 
  Policy PolicyOverrides;
  void clearOverrides();
 
  /// Caches results for getPolicyInEffectAt().
  /// Flushed whenever a diagnostic pragma changes severities.
  llvm::DenseMap<const void *, Policy>
      PolicyCache[static_cast<unsigned>(DiagStateSystemClass::NUM_CLASSES)];
 
  /// \name Statistics
  /// @{
 
  /// Number of function CFGs built and analyzed.
  unsigned NumFunctionsAnalyzed;
 
  /// Number of functions for which the CFG could not be successfully
  /// built.
  unsigned NumFunctionsWithBadCFGs;
 
  /// Total number of blocks across all CFGs.
  unsigned NumCFGBlocks;
 
  /// Largest number of CFG blocks for a single function analyzed.
  unsigned MaxCFGBlocksPerFunction;
 
  /// Total number of CFGs with variables analyzed for uninitialized
  /// uses.
  unsigned NumUninitAnalysisFunctions;
 
  /// Total number of variables analyzed for uninitialized uses.
  unsigned NumUninitAnalysisVariables;
 
  /// Max number of variables analyzed for uninitialized uses in a single
  /// function.
  unsigned MaxUninitAnalysisVariablesPerFunction;
 
  /// Total number of block visits during uninitialized use analysis.
  unsigned NumUninitAnalysisBlockVisits;
 
  /// Max number of block visits during uninitialized use analysis of
  /// a single function.
  unsigned MaxUninitAnalysisBlockVisitsPerFunction;
 
  /// Statistics collected during lifetime safety analysis.
  /// These are accumulated across all analyzed functions and printed
  /// when -print-stats is enabled.
  clang::lifetimes::LifetimeSafetyStats LSStats;
 
  /// @}
 
public:
  AnalysisBasedWarnings(Sema &s);
  ~AnalysisBasedWarnings();
 
  void IssueWarnings(Policy P, FunctionScopeInfo *fscope,
                     const Decl *D, QualType BlockType);
 
  // Issue warnings that require whole-translation-unit analysis.
  void IssueWarnings(TranslationUnitDecl *D);
 
  // Run analysis-based warnings on an implicitly-defined function body (e.g. a
  // defaulted/implicit default constructor). Such functions never reach the
  // normal IssueWarnings path.
  void IssueWarningsForImplicitFunction(const Decl *D);
 
  void registerVarDeclWarning(VarDecl *VD, PossiblyUnreachableDiag PUD);
 
  void issueWarningsForRegisteredVarDecl(VarDecl *VD);
 
  // Gets the default policy which is in effect at the given source location.
  Policy getPolicyInEffectAt(SourceLocation Loc);
 
  // Get the policies we may want to override due to things like #pragma clang
  // diagnostic handling. If a caller sets any of these policies to true, that
  // will override the policy used to issue warnings.
  Policy &getPolicyOverrides() { return PolicyOverrides; }
 
  /// Drop cached getPolicyInEffectAt() results (diagnostic state changed).
  void clearPolicyCache();
 
  void PrintStats() const;
};
 
} // namespace sema
} // namespace clang
 
#endif