SymbolManager.cpp | Explore in Territory

//===- SymbolManager.h - Management of Symbolic Values --------------------===//
//
// 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 SymbolManager, a class that manages symbolic values
//  created for use by ExprEngine and related classes.
//
//===----------------------------------------------------------------------===//

#include "clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Expr.h"
#include "clang/AST/StmtObjC.h"
#include "clang/Analysis/Analyses/LiveVariables.h"
#include "clang/Analysis/AnalysisDeclContext.h"
#include "clang/Basic/LLVM.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/Store.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/SymExpr.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
#include <cassert>

usingnamespaceclang;
usingnamespaceento;

void SymExpr::anchor() { … }

StringRef SymbolConjured::getKindStr() const { … }
StringRef SymbolDerived::getKindStr() const { … }
StringRef SymbolExtent::getKindStr() const { … }
StringRef SymbolMetadata::getKindStr() const { … }
StringRef SymbolRegionValue::getKindStr() const { … }

LLVM_DUMP_METHOD void SymExpr::dump() const { … }

void BinarySymExpr::dumpToStreamImpl(raw_ostream &OS, const SymExpr *Sym) { … }

void BinarySymExpr::dumpToStreamImpl(raw_ostream &OS,
                                     const llvm::APSInt &Value) { … }

void BinarySymExpr::dumpToStreamImpl(raw_ostream &OS,
                                     BinaryOperator::Opcode Op) { … }

void SymbolCast::dumpToStream(raw_ostream &os) const { … }

void UnarySymExpr::dumpToStream(raw_ostream &os) const { … }

void SymbolConjured::dumpToStream(raw_ostream &os) const { … }

void SymbolDerived::dumpToStream(raw_ostream &os) const { … }

void SymbolExtent::dumpToStream(raw_ostream &os) const { … }

void SymbolMetadata::dumpToStream(raw_ostream &os) const { … }

void SymbolData::anchor() { … }

void SymbolRegionValue::dumpToStream(raw_ostream &os) const { … }

bool SymExpr::symbol_iterator::operator==(const symbol_iterator &X) const { … }

bool SymExpr::symbol_iterator::operator!=(const symbol_iterator &X) const { … }

SymExpr::symbol_iterator::symbol_iterator(const SymExpr *SE) { … }

SymExpr::symbol_iterator &SymExpr::symbol_iterator::operator++() { … }

SymbolRef SymExpr::symbol_iterator::operator*() { … }

void SymExpr::symbol_iterator::expand() { … }

const SymbolRegionValue*
SymbolManager::getRegionValueSymbol(const TypedValueRegion* R) { … }

const SymbolConjured* SymbolManager::conjureSymbol(const Stmt *E,
                                                   const LocationContext *LCtx,
                                                   QualType T,
                                                   unsigned Count,
                                                   const void *SymbolTag) { … }

const SymbolDerived*
SymbolManager::getDerivedSymbol(SymbolRef parentSymbol,
                                const TypedValueRegion *R) { … }

const SymbolExtent*
SymbolManager::getExtentSymbol(const SubRegion *R) { … }

const SymbolMetadata *
SymbolManager::getMetadataSymbol(const MemRegion* R, const Stmt *S, QualType T,
                                 const LocationContext *LCtx,
                                 unsigned Count, const void *SymbolTag) { … }

const SymbolCast*
SymbolManager::getCastSymbol(const SymExpr *Op,
                             QualType From, QualType To) { … }

const SymIntExpr *SymbolManager::getSymIntExpr(const SymExpr *lhs,
                                               BinaryOperator::Opcode op,
                                               const llvm::APSInt& v,
                                               QualType t) { … }

const IntSymExpr *SymbolManager::getIntSymExpr(const llvm::APSInt& lhs,
                                               BinaryOperator::Opcode op,
                                               const SymExpr *rhs,
                                               QualType t) { … }

const SymSymExpr *SymbolManager::getSymSymExpr(const SymExpr *lhs,
                                               BinaryOperator::Opcode op,
                                               const SymExpr *rhs,
                                               QualType t) { … }

const UnarySymExpr *SymbolManager::getUnarySymExpr(const SymExpr *Operand,
                                                   UnaryOperator::Opcode Opc,
                                                   QualType T) { … }

QualType SymbolConjured::getType() const { … }

QualType SymbolDerived::getType() const { … }

QualType SymbolExtent::getType() const { … }

QualType SymbolMetadata::getType() const { … }

QualType SymbolRegionValue::getType() const { … }

bool SymbolManager::canSymbolicate(QualType T) { … }

void SymbolManager::addSymbolDependency(const SymbolRef Primary,
                                        const SymbolRef Dependent) { … }

const SymbolRefSmallVectorTy *SymbolManager::getDependentSymbols(
                                                     const SymbolRef Primary) { … }

void SymbolReaper::markDependentsLive(SymbolRef sym) { … }

void SymbolReaper::markLive(SymbolRef sym) { … }

void SymbolReaper::markLive(const MemRegion *region) { … }

void SymbolReaper::markLazilyCopied(const clang::ento::MemRegion *region) { … }

void SymbolReaper::markElementIndicesLive(const MemRegion *region) { … }

void SymbolReaper::markInUse(SymbolRef sym) { … }

bool SymbolReaper::isLiveRegion(const MemRegion *MR) { … }

bool SymbolReaper::isLazilyCopiedRegion(const MemRegion *MR) const { … }

bool SymbolReaper::isReadableRegion(const MemRegion *MR) { … }

bool SymbolReaper::isLive(SymbolRef sym) { … }

bool
SymbolReaper::isLive(const Expr *ExprVal, const LocationContext *ELCtx) const { … }

bool SymbolReaper::isLive(const VarRegion *VR, bool includeStoreBindings) const{ … }
llvm/clang/lib/StaticAnalyzer/Core/SymbolManager.cpp
