mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-28 01:46:06 +00:00
e2f1cbae45
This commit explicitly specifies the matching mode (C library function, any non-method function, or C++ method) for the `CallDescription`s constructed in various checkers where this transition was easy and straightforward. This change won't cause major functional changes, but isn't NFC because it ensures that e.g. call descriptions for a non-method function won't accidentally match a method that has the same name. Separate commits will perform (or have already performed) this change in other checkers. My goal is to ensure that the call description mode is always explicitly specified and eliminate (or strongly restrict) the vague "may be either a method or a simple function" mode that's the current default.
529 lines
20 KiB
C++
529 lines
20 KiB
C++
//===- CastValueChecker - Model implementation of custom RTTIs --*- 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 defines CastValueChecker which models casts of custom RTTIs.
|
|
//
|
|
// TODO list:
|
|
// - It only allows one succesful cast between two types however in the wild
|
|
// the object could be casted to multiple types.
|
|
// - It needs to check the most likely type information from the dynamic type
|
|
// map to increase precision of dynamic casting.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/AST/DeclTemplate.h"
|
|
#include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
|
|
#include "clang/StaticAnalyzer/Core/Checker.h"
|
|
#include "clang/StaticAnalyzer/Core/CheckerManager.h"
|
|
#include "clang/StaticAnalyzer/Core/PathSensitive/CallDescription.h"
|
|
#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
|
|
#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
|
|
#include "clang/StaticAnalyzer/Core/PathSensitive/DynamicType.h"
|
|
#include <optional>
|
|
#include <utility>
|
|
|
|
using namespace clang;
|
|
using namespace ento;
|
|
|
|
namespace {
|
|
class CastValueChecker : public Checker<check::DeadSymbols, eval::Call> {
|
|
enum class CallKind { Function, Method, InstanceOf };
|
|
|
|
using CastCheck =
|
|
std::function<void(const CastValueChecker *, const CallEvent &Call,
|
|
DefinedOrUnknownSVal, CheckerContext &)>;
|
|
|
|
public:
|
|
// We have five cases to evaluate a cast:
|
|
// 1) The parameter is non-null, the return value is non-null.
|
|
// 2) The parameter is non-null, the return value is null.
|
|
// 3) The parameter is null, the return value is null.
|
|
// cast: 1; dyn_cast: 1, 2; cast_or_null: 1, 3; dyn_cast_or_null: 1, 2, 3.
|
|
//
|
|
// 4) castAs: Has no parameter, the return value is non-null.
|
|
// 5) getAs: Has no parameter, the return value is null or non-null.
|
|
//
|
|
// We have two cases to check the parameter is an instance of the given type.
|
|
// 1) isa: The parameter is non-null, returns boolean.
|
|
// 2) isa_and_nonnull: The parameter is null or non-null, returns boolean.
|
|
bool evalCall(const CallEvent &Call, CheckerContext &C) const;
|
|
void checkDeadSymbols(SymbolReaper &SR, CheckerContext &C) const;
|
|
|
|
private:
|
|
// These are known in the LLVM project. The pairs are in the following form:
|
|
// {{match-mode, {namespace, call}, argument-count}, {callback, kind}}
|
|
const CallDescriptionMap<std::pair<CastCheck, CallKind>> CDM = {
|
|
{{CDM::SimpleFunc, {"llvm", "cast"}, 1},
|
|
{&CastValueChecker::evalCast, CallKind::Function}},
|
|
{{CDM::SimpleFunc, {"llvm", "dyn_cast"}, 1},
|
|
{&CastValueChecker::evalDynCast, CallKind::Function}},
|
|
{{CDM::SimpleFunc, {"llvm", "cast_or_null"}, 1},
|
|
{&CastValueChecker::evalCastOrNull, CallKind::Function}},
|
|
{{CDM::SimpleFunc, {"llvm", "dyn_cast_or_null"}, 1},
|
|
{&CastValueChecker::evalDynCastOrNull, CallKind::Function}},
|
|
{{CDM::CXXMethod, {"clang", "castAs"}, 0},
|
|
{&CastValueChecker::evalCastAs, CallKind::Method}},
|
|
{{CDM::CXXMethod, {"clang", "getAs"}, 0},
|
|
{&CastValueChecker::evalGetAs, CallKind::Method}},
|
|
{{CDM::SimpleFunc, {"llvm", "isa"}, 1},
|
|
{&CastValueChecker::evalIsa, CallKind::InstanceOf}},
|
|
{{CDM::SimpleFunc, {"llvm", "isa_and_nonnull"}, 1},
|
|
{&CastValueChecker::evalIsaAndNonNull, CallKind::InstanceOf}}};
|
|
|
|
void evalCast(const CallEvent &Call, DefinedOrUnknownSVal DV,
|
|
CheckerContext &C) const;
|
|
void evalDynCast(const CallEvent &Call, DefinedOrUnknownSVal DV,
|
|
CheckerContext &C) const;
|
|
void evalCastOrNull(const CallEvent &Call, DefinedOrUnknownSVal DV,
|
|
CheckerContext &C) const;
|
|
void evalDynCastOrNull(const CallEvent &Call, DefinedOrUnknownSVal DV,
|
|
CheckerContext &C) const;
|
|
void evalCastAs(const CallEvent &Call, DefinedOrUnknownSVal DV,
|
|
CheckerContext &C) const;
|
|
void evalGetAs(const CallEvent &Call, DefinedOrUnknownSVal DV,
|
|
CheckerContext &C) const;
|
|
void evalIsa(const CallEvent &Call, DefinedOrUnknownSVal DV,
|
|
CheckerContext &C) const;
|
|
void evalIsaAndNonNull(const CallEvent &Call, DefinedOrUnknownSVal DV,
|
|
CheckerContext &C) const;
|
|
};
|
|
} // namespace
|
|
|
|
static bool isInfeasibleCast(const DynamicCastInfo *CastInfo,
|
|
bool CastSucceeds) {
|
|
if (!CastInfo)
|
|
return false;
|
|
|
|
return CastSucceeds ? CastInfo->fails() : CastInfo->succeeds();
|
|
}
|
|
|
|
static const NoteTag *getNoteTag(CheckerContext &C,
|
|
const DynamicCastInfo *CastInfo,
|
|
QualType CastToTy, const Expr *Object,
|
|
bool CastSucceeds, bool IsKnownCast) {
|
|
std::string CastToName =
|
|
CastInfo ? CastInfo->to()->getAsCXXRecordDecl()->getNameAsString()
|
|
: CastToTy.getAsString();
|
|
Object = Object->IgnoreParenImpCasts();
|
|
|
|
return C.getNoteTag(
|
|
[=]() -> std::string {
|
|
SmallString<128> Msg;
|
|
llvm::raw_svector_ostream Out(Msg);
|
|
|
|
if (!IsKnownCast)
|
|
Out << "Assuming ";
|
|
|
|
if (const auto *DRE = dyn_cast<DeclRefExpr>(Object)) {
|
|
Out << '\'' << DRE->getDecl()->getDeclName() << '\'';
|
|
} else if (const auto *ME = dyn_cast<MemberExpr>(Object)) {
|
|
Out << (IsKnownCast ? "Field '" : "field '")
|
|
<< ME->getMemberDecl()->getDeclName() << '\'';
|
|
} else {
|
|
Out << (IsKnownCast ? "The object" : "the object");
|
|
}
|
|
|
|
Out << ' ' << (CastSucceeds ? "is a" : "is not a") << " '" << CastToName
|
|
<< '\'';
|
|
|
|
return std::string(Out.str());
|
|
},
|
|
/*IsPrunable=*/true);
|
|
}
|
|
|
|
static const NoteTag *getNoteTag(CheckerContext &C,
|
|
SmallVector<QualType, 4> CastToTyVec,
|
|
const Expr *Object,
|
|
bool IsKnownCast) {
|
|
Object = Object->IgnoreParenImpCasts();
|
|
|
|
return C.getNoteTag(
|
|
[=]() -> std::string {
|
|
SmallString<128> Msg;
|
|
llvm::raw_svector_ostream Out(Msg);
|
|
|
|
if (!IsKnownCast)
|
|
Out << "Assuming ";
|
|
|
|
if (const auto *DRE = dyn_cast<DeclRefExpr>(Object)) {
|
|
Out << '\'' << DRE->getDecl()->getNameAsString() << '\'';
|
|
} else if (const auto *ME = dyn_cast<MemberExpr>(Object)) {
|
|
Out << (IsKnownCast ? "Field '" : "field '")
|
|
<< ME->getMemberDecl()->getNameAsString() << '\'';
|
|
} else {
|
|
Out << (IsKnownCast ? "The object" : "the object");
|
|
}
|
|
Out << " is";
|
|
|
|
bool First = true;
|
|
for (QualType CastToTy: CastToTyVec) {
|
|
std::string CastToName =
|
|
CastToTy->getAsCXXRecordDecl()
|
|
? CastToTy->getAsCXXRecordDecl()->getNameAsString()
|
|
: CastToTy.getAsString();
|
|
Out << ' ' << ((CastToTyVec.size() == 1) ? "not" :
|
|
(First ? "neither" : "nor")) << " a '" << CastToName
|
|
<< '\'';
|
|
First = false;
|
|
}
|
|
|
|
return std::string(Out.str());
|
|
},
|
|
/*IsPrunable=*/true);
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Main logic to evaluate a cast.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
static QualType alignReferenceTypes(QualType toAlign, QualType alignTowards,
|
|
ASTContext &ACtx) {
|
|
if (alignTowards->isLValueReferenceType() &&
|
|
alignTowards.isConstQualified()) {
|
|
toAlign.addConst();
|
|
return ACtx.getLValueReferenceType(toAlign);
|
|
} else if (alignTowards->isLValueReferenceType())
|
|
return ACtx.getLValueReferenceType(toAlign);
|
|
else if (alignTowards->isRValueReferenceType())
|
|
return ACtx.getRValueReferenceType(toAlign);
|
|
|
|
llvm_unreachable("Must align towards a reference type!");
|
|
}
|
|
|
|
static void addCastTransition(const CallEvent &Call, DefinedOrUnknownSVal DV,
|
|
CheckerContext &C, bool IsNonNullParam,
|
|
bool IsNonNullReturn,
|
|
bool IsCheckedCast = false) {
|
|
ProgramStateRef State = C.getState()->assume(DV, IsNonNullParam);
|
|
if (!State)
|
|
return;
|
|
|
|
const Expr *Object;
|
|
QualType CastFromTy;
|
|
QualType CastToTy = Call.getResultType();
|
|
|
|
if (Call.getNumArgs() > 0) {
|
|
Object = Call.getArgExpr(0);
|
|
CastFromTy = Call.parameters()[0]->getType();
|
|
} else {
|
|
Object = cast<CXXInstanceCall>(&Call)->getCXXThisExpr();
|
|
CastFromTy = Object->getType();
|
|
if (CastToTy->isPointerType()) {
|
|
if (!CastFromTy->isPointerType())
|
|
return;
|
|
} else {
|
|
if (!CastFromTy->isReferenceType())
|
|
return;
|
|
|
|
CastFromTy = alignReferenceTypes(CastFromTy, CastToTy, C.getASTContext());
|
|
}
|
|
}
|
|
|
|
const MemRegion *MR = DV.getAsRegion();
|
|
const DynamicCastInfo *CastInfo =
|
|
getDynamicCastInfo(State, MR, CastFromTy, CastToTy);
|
|
|
|
// We assume that every checked cast succeeds.
|
|
bool CastSucceeds = IsCheckedCast || CastFromTy == CastToTy;
|
|
if (!CastSucceeds) {
|
|
if (CastInfo)
|
|
CastSucceeds = IsNonNullReturn && CastInfo->succeeds();
|
|
else
|
|
CastSucceeds = IsNonNullReturn;
|
|
}
|
|
|
|
// Check for infeasible casts.
|
|
if (isInfeasibleCast(CastInfo, CastSucceeds)) {
|
|
C.generateSink(State, C.getPredecessor());
|
|
return;
|
|
}
|
|
|
|
// Store the type and the cast information.
|
|
bool IsKnownCast = CastInfo || IsCheckedCast || CastFromTy == CastToTy;
|
|
if (!IsKnownCast || IsCheckedCast)
|
|
State = setDynamicTypeAndCastInfo(State, MR, CastFromTy, CastToTy,
|
|
CastSucceeds);
|
|
|
|
SVal V = CastSucceeds ? C.getSValBuilder().evalCast(DV, CastToTy, CastFromTy)
|
|
: C.getSValBuilder().makeNullWithType(CastToTy);
|
|
C.addTransition(
|
|
State->BindExpr(Call.getOriginExpr(), C.getLocationContext(), V, false),
|
|
getNoteTag(C, CastInfo, CastToTy, Object, CastSucceeds, IsKnownCast));
|
|
}
|
|
|
|
static void addInstanceOfTransition(const CallEvent &Call,
|
|
DefinedOrUnknownSVal DV,
|
|
ProgramStateRef State, CheckerContext &C,
|
|
bool IsInstanceOf) {
|
|
const FunctionDecl *FD = Call.getDecl()->getAsFunction();
|
|
QualType CastFromTy = Call.parameters()[0]->getType();
|
|
SmallVector<QualType, 4> CastToTyVec;
|
|
for (unsigned idx = 0; idx < FD->getTemplateSpecializationArgs()->size() - 1;
|
|
++idx) {
|
|
TemplateArgument CastToTempArg =
|
|
FD->getTemplateSpecializationArgs()->get(idx);
|
|
switch (CastToTempArg.getKind()) {
|
|
default:
|
|
return;
|
|
case TemplateArgument::Type:
|
|
CastToTyVec.push_back(CastToTempArg.getAsType());
|
|
break;
|
|
case TemplateArgument::Pack:
|
|
for (TemplateArgument ArgInPack: CastToTempArg.pack_elements())
|
|
CastToTyVec.push_back(ArgInPack.getAsType());
|
|
break;
|
|
}
|
|
}
|
|
|
|
const MemRegion *MR = DV.getAsRegion();
|
|
if (MR && CastFromTy->isReferenceType())
|
|
MR = State->getSVal(DV.castAs<Loc>()).getAsRegion();
|
|
|
|
bool Success = false;
|
|
bool IsAnyKnown = false;
|
|
for (QualType CastToTy: CastToTyVec) {
|
|
if (CastFromTy->isPointerType())
|
|
CastToTy = C.getASTContext().getPointerType(CastToTy);
|
|
else if (CastFromTy->isReferenceType())
|
|
CastToTy = alignReferenceTypes(CastToTy, CastFromTy, C.getASTContext());
|
|
else
|
|
return;
|
|
|
|
const DynamicCastInfo *CastInfo =
|
|
getDynamicCastInfo(State, MR, CastFromTy, CastToTy);
|
|
|
|
bool CastSucceeds;
|
|
if (CastInfo)
|
|
CastSucceeds = IsInstanceOf && CastInfo->succeeds();
|
|
else
|
|
CastSucceeds = IsInstanceOf || CastFromTy == CastToTy;
|
|
|
|
// Store the type and the cast information.
|
|
bool IsKnownCast = CastInfo || CastFromTy == CastToTy;
|
|
IsAnyKnown = IsAnyKnown || IsKnownCast;
|
|
ProgramStateRef NewState = State;
|
|
if (!IsKnownCast)
|
|
NewState = setDynamicTypeAndCastInfo(State, MR, CastFromTy, CastToTy,
|
|
IsInstanceOf);
|
|
|
|
if (CastSucceeds) {
|
|
Success = true;
|
|
C.addTransition(
|
|
NewState->BindExpr(Call.getOriginExpr(), C.getLocationContext(),
|
|
C.getSValBuilder().makeTruthVal(true)),
|
|
getNoteTag(C, CastInfo, CastToTy, Call.getArgExpr(0), true,
|
|
IsKnownCast));
|
|
if (IsKnownCast)
|
|
return;
|
|
} else if (CastInfo && CastInfo->succeeds()) {
|
|
C.generateSink(NewState, C.getPredecessor());
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!Success) {
|
|
C.addTransition(
|
|
State->BindExpr(Call.getOriginExpr(), C.getLocationContext(),
|
|
C.getSValBuilder().makeTruthVal(false)),
|
|
getNoteTag(C, CastToTyVec, Call.getArgExpr(0), IsAnyKnown));
|
|
}
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Evaluating cast, dyn_cast, cast_or_null, dyn_cast_or_null.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
static void evalNonNullParamNonNullReturn(const CallEvent &Call,
|
|
DefinedOrUnknownSVal DV,
|
|
CheckerContext &C,
|
|
bool IsCheckedCast = false) {
|
|
addCastTransition(Call, DV, C, /*IsNonNullParam=*/true,
|
|
/*IsNonNullReturn=*/true, IsCheckedCast);
|
|
}
|
|
|
|
static void evalNonNullParamNullReturn(const CallEvent &Call,
|
|
DefinedOrUnknownSVal DV,
|
|
CheckerContext &C) {
|
|
addCastTransition(Call, DV, C, /*IsNonNullParam=*/true,
|
|
/*IsNonNullReturn=*/false);
|
|
}
|
|
|
|
static void evalNullParamNullReturn(const CallEvent &Call,
|
|
DefinedOrUnknownSVal DV,
|
|
CheckerContext &C) {
|
|
if (ProgramStateRef State = C.getState()->assume(DV, false))
|
|
C.addTransition(State->BindExpr(Call.getOriginExpr(),
|
|
C.getLocationContext(),
|
|
C.getSValBuilder().makeNullWithType(
|
|
Call.getOriginExpr()->getType()),
|
|
false),
|
|
C.getNoteTag("Assuming null pointer is passed into cast",
|
|
/*IsPrunable=*/true));
|
|
}
|
|
|
|
void CastValueChecker::evalCast(const CallEvent &Call, DefinedOrUnknownSVal DV,
|
|
CheckerContext &C) const {
|
|
evalNonNullParamNonNullReturn(Call, DV, C, /*IsCheckedCast=*/true);
|
|
}
|
|
|
|
void CastValueChecker::evalDynCast(const CallEvent &Call,
|
|
DefinedOrUnknownSVal DV,
|
|
CheckerContext &C) const {
|
|
evalNonNullParamNonNullReturn(Call, DV, C);
|
|
evalNonNullParamNullReturn(Call, DV, C);
|
|
}
|
|
|
|
void CastValueChecker::evalCastOrNull(const CallEvent &Call,
|
|
DefinedOrUnknownSVal DV,
|
|
CheckerContext &C) const {
|
|
evalNonNullParamNonNullReturn(Call, DV, C);
|
|
evalNullParamNullReturn(Call, DV, C);
|
|
}
|
|
|
|
void CastValueChecker::evalDynCastOrNull(const CallEvent &Call,
|
|
DefinedOrUnknownSVal DV,
|
|
CheckerContext &C) const {
|
|
evalNonNullParamNonNullReturn(Call, DV, C);
|
|
evalNonNullParamNullReturn(Call, DV, C);
|
|
evalNullParamNullReturn(Call, DV, C);
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Evaluating castAs, getAs.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
static void evalZeroParamNonNullReturn(const CallEvent &Call,
|
|
DefinedOrUnknownSVal DV,
|
|
CheckerContext &C,
|
|
bool IsCheckedCast = false) {
|
|
addCastTransition(Call, DV, C, /*IsNonNullParam=*/true,
|
|
/*IsNonNullReturn=*/true, IsCheckedCast);
|
|
}
|
|
|
|
static void evalZeroParamNullReturn(const CallEvent &Call,
|
|
DefinedOrUnknownSVal DV,
|
|
CheckerContext &C) {
|
|
addCastTransition(Call, DV, C, /*IsNonNullParam=*/true,
|
|
/*IsNonNullReturn=*/false);
|
|
}
|
|
|
|
void CastValueChecker::evalCastAs(const CallEvent &Call,
|
|
DefinedOrUnknownSVal DV,
|
|
CheckerContext &C) const {
|
|
evalZeroParamNonNullReturn(Call, DV, C, /*IsCheckedCast=*/true);
|
|
}
|
|
|
|
void CastValueChecker::evalGetAs(const CallEvent &Call, DefinedOrUnknownSVal DV,
|
|
CheckerContext &C) const {
|
|
evalZeroParamNonNullReturn(Call, DV, C);
|
|
evalZeroParamNullReturn(Call, DV, C);
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Evaluating isa, isa_and_nonnull.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
void CastValueChecker::evalIsa(const CallEvent &Call, DefinedOrUnknownSVal DV,
|
|
CheckerContext &C) const {
|
|
ProgramStateRef NonNullState, NullState;
|
|
std::tie(NonNullState, NullState) = C.getState()->assume(DV);
|
|
|
|
if (NonNullState) {
|
|
addInstanceOfTransition(Call, DV, NonNullState, C, /*IsInstanceOf=*/true);
|
|
addInstanceOfTransition(Call, DV, NonNullState, C, /*IsInstanceOf=*/false);
|
|
}
|
|
|
|
if (NullState) {
|
|
C.generateSink(NullState, C.getPredecessor());
|
|
}
|
|
}
|
|
|
|
void CastValueChecker::evalIsaAndNonNull(const CallEvent &Call,
|
|
DefinedOrUnknownSVal DV,
|
|
CheckerContext &C) const {
|
|
ProgramStateRef NonNullState, NullState;
|
|
std::tie(NonNullState, NullState) = C.getState()->assume(DV);
|
|
|
|
if (NonNullState) {
|
|
addInstanceOfTransition(Call, DV, NonNullState, C, /*IsInstanceOf=*/true);
|
|
addInstanceOfTransition(Call, DV, NonNullState, C, /*IsInstanceOf=*/false);
|
|
}
|
|
|
|
if (NullState) {
|
|
addInstanceOfTransition(Call, DV, NullState, C, /*IsInstanceOf=*/false);
|
|
}
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Main logic to evaluate a call.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
bool CastValueChecker::evalCall(const CallEvent &Call,
|
|
CheckerContext &C) const {
|
|
const auto *Lookup = CDM.lookup(Call);
|
|
if (!Lookup)
|
|
return false;
|
|
|
|
const CastCheck &Check = Lookup->first;
|
|
CallKind Kind = Lookup->second;
|
|
|
|
std::optional<DefinedOrUnknownSVal> DV;
|
|
|
|
switch (Kind) {
|
|
case CallKind::Function: {
|
|
// We only model casts from pointers to pointers or from references
|
|
// to references. Other casts are most likely specialized and we
|
|
// cannot model them.
|
|
QualType ParamT = Call.parameters()[0]->getType();
|
|
QualType ResultT = Call.getResultType();
|
|
if (!(ParamT->isPointerType() && ResultT->isPointerType()) &&
|
|
!(ParamT->isReferenceType() && ResultT->isReferenceType())) {
|
|
return false;
|
|
}
|
|
|
|
DV = Call.getArgSVal(0).getAs<DefinedOrUnknownSVal>();
|
|
break;
|
|
}
|
|
case CallKind::InstanceOf: {
|
|
// We need to obtain the only template argument to determinte the type.
|
|
const FunctionDecl *FD = Call.getDecl()->getAsFunction();
|
|
if (!FD || !FD->getTemplateSpecializationArgs())
|
|
return false;
|
|
|
|
DV = Call.getArgSVal(0).getAs<DefinedOrUnknownSVal>();
|
|
break;
|
|
}
|
|
case CallKind::Method:
|
|
const auto *InstanceCall = dyn_cast<CXXInstanceCall>(&Call);
|
|
if (!InstanceCall)
|
|
return false;
|
|
|
|
DV = InstanceCall->getCXXThisVal().getAs<DefinedOrUnknownSVal>();
|
|
break;
|
|
}
|
|
|
|
if (!DV)
|
|
return false;
|
|
|
|
Check(this, Call, *DV, C);
|
|
return true;
|
|
}
|
|
|
|
void CastValueChecker::checkDeadSymbols(SymbolReaper &SR,
|
|
CheckerContext &C) const {
|
|
C.addTransition(removeDeadCasts(C.getState(), SR));
|
|
}
|
|
|
|
void ento::registerCastValueChecker(CheckerManager &Mgr) {
|
|
Mgr.registerChecker<CastValueChecker>();
|
|
}
|
|
|
|
bool ento::shouldRegisterCastValueChecker(const CheckerManager &mgr) {
|
|
return true;
|
|
}
|