//==- 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"

using namespace clang;

using namespace ento;

//===----------------------------------------------------------------------===//

// DominatorsTreeDumper

//===----------------------------------------------------------------------===//

namespace {

class DominatorsTreeDumper : public Checker<check::ASTCodeBody> {

public:

  void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,

                        BugReporter &BR) const {

    if (AnalysisDeclContext *AC = mgr.getAnalysisDeclContext(D)) {

      CFGDomTree Dom;

      Dom.buildDominatorTree(AC->getCFG());

      Dom.dump();

    }

  }

};

}

void ento::registerDominatorsTreeDumper(CheckerManager &mgr) {

  mgr.registerChecker<DominatorsTreeDumper>();

}

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

  return true;

}

//===----------------------------------------------------------------------===//

// PostDominatorsTreeDumper

//===----------------------------------------------------------------------===//

namespace {

class PostDominatorsTreeDumper : public Checker<check::ASTCodeBody> {

public:

  void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,

                        BugReporter &BR) const {

    if (AnalysisDeclContext *AC = mgr.getAnalysisDeclContext(D)) {

      CFGPostDomTree Dom;

      Dom.buildDominatorTree(AC->getCFG());

      Dom.dump();

    }

  }

};

}

void ento::registerPostDominatorsTreeDumper(CheckerManager &mgr) {

  mgr.registerChecker<PostDominatorsTreeDumper>();

}

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

  return true;

}

//===----------------------------------------------------------------------===//

// ControlDependencyTreeDumper

//===----------------------------------------------------------------------===//

namespace {

class ControlDependencyTreeDumper : public Checker<check::ASTCodeBody> {

public:

  void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,

                        BugReporter &BR) const {

    if (AnalysisDeclContext *AC = mgr.getAnalysisDeclContext(D)) {

      ControlDependencyCalculator Dom(AC->getCFG());

      Dom.dump();

    }

  }

};

}

void ento::registerControlDependencyTreeDumper(CheckerManager &mgr) {

  mgr.registerChecker<ControlDependencyTreeDumper>();

}

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

  return true;

}

//===----------------------------------------------------------------------===//

// LiveVariablesDumper

//===----------------------------------------------------------------------===//

namespace {

class LiveVariablesDumper : public Checker<check::ASTCodeBody> {

public:

  void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,

                        BugReporter &BR) const {

    if (LiveVariables* L = mgr.getAnalysis<LiveVariables>(D)) {

      L->dumpBlockLiveness(mgr.getSourceManager());

    }

  }

};

}

void ento::registerLiveVariablesDumper(CheckerManager &mgr) {

  mgr.registerChecker<LiveVariablesDumper>();

}

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

  return true;

}

//===----------------------------------------------------------------------===//

// LiveStatementsDumper

//===----------------------------------------------------------------------===//

namespace {

class LiveExpressionsDumper : public Checker<check::ASTCodeBody> {

public:

  void checkASTCodeBody(const Decl *D, AnalysisManager& Mgr,

                        BugReporter &BR) const {

    if (LiveVariables *L = Mgr.getAnalysis<RelaxedLiveVariables>(D))

      L->dumpExprLiveness(Mgr.getSourceManager());

  }

};

}

void ento::registerLiveExpressionsDumper(CheckerManager &mgr) {

  mgr.registerChecker<LiveExpressionsDumper>();

}

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

  return true;

}

//===----------------------------------------------------------------------===//

// CFGViewer

//===----------------------------------------------------------------------===//

namespace {

class CFGViewer : public Checker<check::ASTCodeBody> {

public:

  void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,

                        BugReporter &BR) const {

    if (CFG *cfg = mgr.getCFG(D)) {

      cfg->viewCFG(mgr.getLangOpts());

    }

  }

};

}

void ento::registerCFGViewer(CheckerManager &mgr) {

  mgr.registerChecker<CFGViewer>();

}

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

  return true;

}

//===----------------------------------------------------------------------===//

// CFGDumper

//===----------------------------------------------------------------------===//

namespace {

class CFGDumper : public Checker<check::ASTCodeBody> {

public:

  void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,

                        BugReporter &BR) const {

    PrintingPolicy Policy(mgr.getLangOpts());

    Policy.TerseOutput = true;

    Policy.PolishForDeclaration = true;

    D->print(llvm::errs(), Policy);

    if (CFG *cfg = mgr.getCFG(D)) {

      cfg->dump(mgr.getLangOpts(),

                llvm::sys::Process::StandardErrHasColors());

    }

  }

};

}

void ento::registerCFGDumper(CheckerManager &mgr) {

  mgr.registerChecker<CFGDumper>();

}

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

  return true;

}

//===----------------------------------------------------------------------===//

// CallGraphViewer

//===----------------------------------------------------------------------===//

namespace {

class CallGraphViewer : public Checker< check::ASTDecl<TranslationUnitDecl> > {

public:

  void checkASTDecl(const TranslationUnitDecl *TU, AnalysisManager& mgr,

                    BugReporter &BR) const {

    CallGraph CG;

    CG.addToCallGraph(const_cast<TranslationUnitDecl*>(TU));

    CG.viewGraph();

  }

};

}

void ento::registerCallGraphViewer(CheckerManager &mgr) {

  mgr.registerChecker<CallGraphViewer>();

}

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

  return true;

}

//===----------------------------------------------------------------------===//

// CallGraphDumper

//===----------------------------------------------------------------------===//

namespace {

class CallGraphDumper : public Checker< check::ASTDecl<TranslationUnitDecl> > {

public:

  void checkASTDecl(const TranslationUnitDecl *TU, AnalysisManager& mgr,

                    BugReporter &BR) const {

    CallGraph CG;

    CG.addToCallGraph(const_cast<TranslationUnitDecl*>(TU));

    CG.dump();

  }

};

}

void ento::registerCallGraphDumper(CheckerManager &mgr) {

  mgr.registerChecker<CallGraphDumper>();

}

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

  return true;

}

//===----------------------------------------------------------------------===//

// ConfigDumper

//===----------------------------------------------------------------------===//

namespace {

class ConfigDumper : public Checker< check::EndOfTranslationUnit > {

  typedef AnalyzerOptions::ConfigTable Table;

  static int compareEntry(const Table::MapEntryTy *const *LHS,

                          const Table::MapEntryTy *const *RHS) {

    return (*LHS)->getKey().compare((*RHS)->getKey());

  }

public:

  void checkEndOfTranslationUnit(const TranslationUnitDecl *TU,

                                 AnalysisManager& mgr,

                                 BugReporter &BR) const {

    const Table &Config = mgr.options.Config;

    SmallVector<const Table::MapEntryTy *, 32> Keys;

    for (const auto &Entry : Config)

      Keys.push_back(&Entry);

    llvm::array_pod_sort(Keys.begin(), Keys.end(), compareEntry);

    llvm::errs() << "[config]\n";

    for (unsigned I = 0, E = Keys.size(); I != E; 
++I520
)

      llvm::errs() << Keys[I]->getKey() << " = "

                   << (Keys[I]->second.empty() ? 
"\"\""16
 : 
Keys[I]->second504
)

                   << '\n';

  }

};

}

void ento::registerConfigDumper(CheckerManager &mgr) {

  mgr.registerChecker<ConfigDumper>();

}

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

  return true;

}

//===----------------------------------------------------------------------===//

// ExplodedGraph Viewer

//===----------------------------------------------------------------------===//

namespace {

class ExplodedGraphViewer : public Checker< check::EndAnalysis > {

public:

  ExplodedGraphViewer() {}

  void checkEndAnalysis(ExplodedGraph &G, BugReporter &B,ExprEngine &Eng) const {

    Eng.ViewGraph(false);

  }

};

}

void ento::registerExplodedGraphViewer(CheckerManager &mgr) {

  mgr.registerChecker<ExplodedGraphViewer>();

}

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

  return true;

}

//===----------------------------------------------------------------------===//

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

//===----------------------------------------------------------------------===//

namespace {

class ReportStmts : public Checker<check::PreStmt<Stmt>> {

  BugType BT_stmtLoc{this, "Statement"};

public:

  void checkPreStmt(const Stmt *S, CheckerContext &C) const {

    ExplodedNode *Node = C.generateNonFatalErrorNode();

    if (!Node)

      return;

    auto Report =

        std::make_unique<PathSensitiveBugReport>(BT_stmtLoc, "Statement", Node);

    C.emitReport(std::move(Report));

  }

};

} // end of anonymous namespace

void ento::registerReportStmts(CheckerManager &mgr) {

  mgr.registerChecker<ReportStmts>();

}

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

  return true;

}