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

//==- ExprInspectionChecker.cpp - Used for regression tests ------*- 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
//
//===----------------------------------------------------------------------===//

#include "clang/Analysis/IssueHash.h"
#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
#include "clang/StaticAnalyzer/Checkers/SValExplainer.h"
#include "clang/StaticAnalyzer/Checkers/Taint.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/DynamicExtent.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/Support/ScopedPrinter.h"
#include <optional>

usingnamespaceclang;
usingnamespaceento;

namespace {
class ExprInspectionChecker
    : public Checker<eval::Call, check::DeadSymbols, check::EndAnalysis> { … };
} // namespace

REGISTER_SET_WITH_PROGRAMSTATE(…)
REGISTER_MAP_WITH_PROGRAMSTATE(…) …

bool ExprInspectionChecker::evalCall(const CallEvent &Call,
                                     CheckerContext &C) const { … }

static const char *getArgumentValueString(const CallExpr *CE,
                                          CheckerContext &C) { … }

ExplodedNode *
ExprInspectionChecker::reportBug(llvm::StringRef Msg, CheckerContext &C,
                                 std::optional<SVal> ExprVal) const { … }

ExplodedNode *
ExprInspectionChecker::reportBug(llvm::StringRef Msg, BugReporter &BR,
                                 ExplodedNode *N,
                                 std::optional<SVal> ExprVal) const { … }

const Expr *ExprInspectionChecker::getArgExpr(const CallExpr *CE,
                                              CheckerContext &C) const { … }

const MemRegion *ExprInspectionChecker::getArgRegion(const CallExpr *CE,
                                                     CheckerContext &C) const { … }

void ExprInspectionChecker::analyzerEval(const CallExpr *CE,
                                         CheckerContext &C) const { … }

void ExprInspectionChecker::analyzerWarnIfReached(const CallExpr *CE,
                                                  CheckerContext &C) const { … }

void ExprInspectionChecker::analyzerNumTimesReached(const CallExpr *CE,
                                                    CheckerContext &C) const { … }

void ExprInspectionChecker::analyzerCheckInlined(const CallExpr *CE,
                                                 CheckerContext &C) const { … }

void ExprInspectionChecker::analyzerExplain(const CallExpr *CE,
                                            CheckerContext &C) const { … }

static void printHelper(llvm::raw_svector_ostream &Out, CheckerContext &C,
                        const llvm::APSInt &I) { … }

static void printHelper(llvm::raw_svector_ostream &Out, CheckerContext &C,
                        SymbolRef Sym) { … }

static void printHelper(llvm::raw_svector_ostream &Out, CheckerContext &C,
                        SVal V) { … }

template <typename T>
void ExprInspectionChecker::printAndReport(CheckerContext &C, T What) const { … }

void ExprInspectionChecker::analyzerValue(const CallExpr *CE,
                                          CheckerContext &C) const { … }

void ExprInspectionChecker::analyzerDumpSValType(const CallExpr *CE,
                                                 CheckerContext &C) const { … }

void ExprInspectionChecker::analyzerDump(const CallExpr *CE,
                                         CheckerContext &C) const { … }

void ExprInspectionChecker::analyzerGetExtent(const CallExpr *CE,
                                              CheckerContext &C) const { … }

void ExprInspectionChecker::analyzerDumpExtent(const CallExpr *CE,
                                               CheckerContext &C) const { … }

void ExprInspectionChecker::analyzerDumpElementCount(const CallExpr *CE,
                                                     CheckerContext &C) const { … }

void ExprInspectionChecker::analyzerPrintState(const CallExpr *CE,
                                               CheckerContext &C) const { … }

void ExprInspectionChecker::analyzerWarnOnDeadSymbol(const CallExpr *CE,
                                                     CheckerContext &C) const { … }

void ExprInspectionChecker::checkDeadSymbols(SymbolReaper &SymReaper,
                                             CheckerContext &C) const { … }

void ExprInspectionChecker::checkEndAnalysis(ExplodedGraph &G, BugReporter &BR,
                                             ExprEngine &Eng) const { … }

void ExprInspectionChecker::analyzerCrash(const CallExpr *CE,
                                          CheckerContext &C) const { … }

void ExprInspectionChecker::analyzerHashDump(const CallExpr *CE,
                                             CheckerContext &C) const { … }

void ExprInspectionChecker::analyzerDenote(const CallExpr *CE,
                                           CheckerContext &C) const { … }

namespace {
class SymbolExpressor
    : public SymExprVisitor<SymbolExpressor, std::optional<std::string>> { … };
} // namespace

void ExprInspectionChecker::analyzerExpress(const CallExpr *CE,
                                            CheckerContext &C) const { … }

void ExprInspectionChecker::analyzerIsTainted(const CallExpr *CE,
                                              CheckerContext &C) const { … }

void ento::registerExprInspectionChecker(CheckerManager &Mgr) { … }

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