llvm/clang/lib/StaticAnalyzer/Checkers/DebugCheckers.cpp

//==- DebugCheckers.cpp - Debugging Checkers ---------------------*- 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 checkers that display debugging information.
//
//===----------------------------------------------------------------------===//

#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/Analysis/Analyses/Dominators.h"
#include "clang/Analysis/Analyses/LiveVariables.h"
#include "clang/Analysis/CallGraph.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h"
#include "llvm/Support/Process.h"

usingnamespaceclang;
usingnamespaceento;

//===----------------------------------------------------------------------===//
// DominatorsTreeDumper
//===----------------------------------------------------------------------===//

namespace {
class DominatorsTreeDumper : public Checker<check::ASTCodeBody> { … };
}

void ento::registerDominatorsTreeDumper(CheckerManager &mgr) { … }

bool ento::shouldRegisterDominatorsTreeDumper(const CheckerManager &mgr) { … }

//===----------------------------------------------------------------------===//
// PostDominatorsTreeDumper
//===----------------------------------------------------------------------===//

namespace {
class PostDominatorsTreeDumper : public Checker<check::ASTCodeBody> { … };
}

void ento::registerPostDominatorsTreeDumper(CheckerManager &mgr) { … }

bool ento::shouldRegisterPostDominatorsTreeDumper(const CheckerManager &mgr) { … }

//===----------------------------------------------------------------------===//
// ControlDependencyTreeDumper
//===----------------------------------------------------------------------===//

namespace {
class ControlDependencyTreeDumper : public Checker<check::ASTCodeBody> { … };
}

void ento::registerControlDependencyTreeDumper(CheckerManager &mgr) { … }

bool ento::shouldRegisterControlDependencyTreeDumper(const CheckerManager &mgr) { … }

//===----------------------------------------------------------------------===//
// LiveVariablesDumper
//===----------------------------------------------------------------------===//

namespace {
class LiveVariablesDumper : public Checker<check::ASTCodeBody> { … };
}

void ento::registerLiveVariablesDumper(CheckerManager &mgr) { … }

bool ento::shouldRegisterLiveVariablesDumper(const CheckerManager &mgr) { … }

//===----------------------------------------------------------------------===//
// LiveStatementsDumper
//===----------------------------------------------------------------------===//

namespace {
class LiveExpressionsDumper : public Checker<check::ASTCodeBody> { … };
}

void ento::registerLiveExpressionsDumper(CheckerManager &mgr) { … }

bool ento::shouldRegisterLiveExpressionsDumper(const CheckerManager &mgr) { … }

//===----------------------------------------------------------------------===//
// CFGViewer
//===----------------------------------------------------------------------===//

namespace {
class CFGViewer : public Checker<check::ASTCodeBody> { … };
}

void ento::registerCFGViewer(CheckerManager &mgr) { … }

bool ento::shouldRegisterCFGViewer(const CheckerManager &mgr) { … }

//===----------------------------------------------------------------------===//
// CFGDumper
//===----------------------------------------------------------------------===//

namespace {
class CFGDumper : public Checker<check::ASTCodeBody> { … };
}

void ento::registerCFGDumper(CheckerManager &mgr) { … }

bool ento::shouldRegisterCFGDumper(const CheckerManager &mgr) { … }

//===----------------------------------------------------------------------===//
// CallGraphViewer
//===----------------------------------------------------------------------===//

namespace {
class CallGraphViewer : public Checker< check::ASTDecl<TranslationUnitDecl> > { … };
}

void ento::registerCallGraphViewer(CheckerManager &mgr) { … }

bool ento::shouldRegisterCallGraphViewer(const CheckerManager &mgr) { … }

//===----------------------------------------------------------------------===//
// CallGraphDumper
//===----------------------------------------------------------------------===//

namespace {
class CallGraphDumper : public Checker< check::ASTDecl<TranslationUnitDecl> > { … };
}

void ento::registerCallGraphDumper(CheckerManager &mgr) { … }

bool ento::shouldRegisterCallGraphDumper(const CheckerManager &mgr) { … }

//===----------------------------------------------------------------------===//
// ConfigDumper
//===----------------------------------------------------------------------===//

namespace {
class ConfigDumper : public Checker< check::EndOfTranslationUnit > { … };
}

void ento::registerConfigDumper(CheckerManager &mgr) { … }

bool ento::shouldRegisterConfigDumper(const CheckerManager &mgr) { … }

//===----------------------------------------------------------------------===//
// ExplodedGraph Viewer
//===----------------------------------------------------------------------===//

namespace {
class ExplodedGraphViewer : public Checker< check::EndAnalysis > { … };

}

void ento::registerExplodedGraphViewer(CheckerManager &mgr) { … }

bool ento::shouldRegisterExplodedGraphViewer(const CheckerManager &mgr) { … }

//===----------------------------------------------------------------------===//
// Emits a report for every Stmt that the analyzer visits.
//===----------------------------------------------------------------------===//

namespace {

class ReportStmts : public Checker<check::PreStmt<Stmt>> { … };

} // end of anonymous namespace

void ento::registerReportStmts(CheckerManager &mgr) { … }

bool ento::shouldRegisterReportStmts(const CheckerManager &mgr) { … }