Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/ExprEngine_8cpp_source.html below:

clang: lib/StaticAnalyzer/Core/ExprEngine.cpp Source File

;

);

);

);

);

ConstructedObjectKey {

ConstructedObjectKeyImpl =

std::pair<ConstructionContextItem, const LocationContext *>;

ConstructedObjectKeyImpl Impl;

*getLocationContext()

{

Impl.second; }

getLocationContext()->getDecl()->getASTContext();

printJson(llvm::raw_ostream &Out,

*Helper,

*S = getItem().getStmtOrNull();

I = getItem().getCXXCtorInitializer();

Out <<

<< S->getID(getASTContext());

Out <<

<< I->

(getASTContext());

Out <<

<< getItem().getKindAsString()

<<

;

Out << getItem().getIndex();

Out <<

;

S->printJson(Out, Helper, PP,

);

Profile(llvm::FoldingSetNodeID &ID)

{

.AddPointer(Impl.second);

(

ConstructedObjectKey &RHS)

{

Impl == RHS.Impl;

(

ConstructedObjectKey &RHS)

{

Impl < RHS.Impl;

llvm::ImmutableMap<ConstructedObjectKey, SVal>

llvm::ImmutableMap<

std::pair<const CXXConstructExpr *, const LocationContext *>,

>

IndexOfElementToConstructMap;

IndexOfElementToConstructMap)

llvm::ImmutableMap<

std::pair<const CXXConstructExpr *, const LocationContext *>,

>

llvm::ImmutableMap<const LocationContext *, unsigned>

* TagProviderName =

;

: CTU(CTU), IsCTUEnabled(mgr.getAnalyzerOptions().IsNaiveCTUEnabled),

AMgr(mgr), AnalysisDeclContexts(mgr.getAnalysisDeclContextManager()),

Engine(*this, FS, mgr.getAnalyzerOptions()), G(Engine.getGraph()),

StateMgr(getContext(), mgr.getStoreManagerCreator(),

mgr.getConstraintManagerCreator(), G.getAllocator(), this),

SymMgr(StateMgr.getSymbolManager()), MRMgr(StateMgr.getRegionManager()),

svalBuilder(StateMgr.getSValBuilder()), ObjCNoRet(mgr.getASTContext()),

BR(mgr, *this), VisitedCallees(VisitedCalleesIn),

HowToInline(HowToInlineIn) {

TrimInterval = mgr.

.GraphTrimInterval;

(TrimInterval != 0) {

(

*FD = dyn_cast<FunctionDecl>(

)) {

(!II || !(II->

() ==

&& FD->getNumParams() > 0))

*BT = dyn_cast<BuiltinType>(

);

(!BT || !BT->isInteger())

*R = state->getRegion(PD, InitLoc);

std::optional<DefinedOrUnknownSVal> Constraint =

(

*MD = dyn_cast<ObjCMethodDecl>(

)) {

*R = state->getRegion(SelfD, InitLoc);

(std::optional<Loc> LV =

.getAs<

>()) {

state = state->assume(*LV,

);

assert(state &&

);

(

*MD = dyn_cast<CXXMethodDecl>(

)) {

(MD->isImplicitObjectMemberFunction()) {

= state->getSVal(L);

(std::optional<Loc> LV =

.getAs<

>()) {

state = state->assume(*LV,

);

assert(state &&

);

**OutRegionWithAdjustments) {

InitValWithAdjustments = State->getSVal(InitWithAdjustments, LC);

(!isa<NonLoc>(InitValWithAdjustments)) {

(OutRegionWithAdjustments)

*OutRegionWithAdjustments =

;

= InitWithAdjustments;

assert(!isa<Loc>(InitValWithAdjustments) ||

->getType()->isMemberPointerType());

CommaLHSs, Adjustments);

(

*MT = dyn_cast<MaterializeTemporaryExpr>(

)) {

State = finishObjectConstruction(State, MT, LC);

State = State->BindExpr(

, LC, *

);

}

(

*VD = MT->getExtendingDecl()) {

State = State->invalidateRegions(Reg, InitWithAdjustments,

,

,

);

InitVal = State->getSVal(

, LC);

State = State->bindLoc(BaseReg.

<

>(), InitVal, LC,

);

(InitValWithAdjustments.

()) {

State->bindLoc(Reg.

<

>(), InitValWithAdjustments, LC,

);

State = State->bindLoc(BaseReg.

<

>(), InitVal, LC,

);

(

->isGLValue()) {

State = State->BindExpr(

, LC, Reg);

State = State->BindExpr(

, LC, InitValWithAdjustments);

(OutRegionWithAdjustments)

*OutRegionWithAdjustments = cast<SubRegion>(Reg.

());

assert(!State->contains<IndexOfElementToConstruct>(Key) || Idx > 0);

State->set<IndexOfElementToConstruct>(Key, Idx);

std::optional<unsigned>

*

= State->get<PendingInitLoop>({

, LCtx->

()});

? std::make_optional(*

) : std::nullopt;

assert(

&& State->contains<PendingInitLoop>(Key));

State->remove<PendingInitLoop>(Key);

assert(!State->contains<PendingInitLoop>(Key) && Size > 0);

State->set<PendingInitLoop>(Key, Size);

std::optional<unsigned>

State->get<IndexOfElementToConstruct>({

, LCtx->

()});

? std::make_optional(*

) : std::nullopt;

assert(

&& State->contains<IndexOfElementToConstruct>(Key));

State->remove<IndexOfElementToConstruct>(Key);

std::optional<unsigned>

assert(LCtx &&

);

State->get<PendingArrayDestruction>(LCtx->

());

? std::make_optional(*

) : std::nullopt;

assert(LCtx &&

);

State->set<PendingArrayDestruction>(Key, Idx);

assert(LCtx &&

);

assert(LCtx && State->contains<PendingArrayDestruction>(Key));

State->remove<PendingArrayDestruction>(Key);

(

DS = dyn_cast_or_null<DeclStmt>(Item.

())) {

(

VD = dyn_cast_or_null<VarDecl>(DS->getSingleDecl()))

= VD->getInit();

(

LE = dyn_cast_or_null<LambdaExpr>(Item.

()))

(

*AILE = dyn_cast_or_null<ArrayInitLoopExpr>(

))

assert((!State->get<ObjectsUnderConstruction>(Key) ||

Key.getItem().getKind() ==

State->contains<IndexOfElementToConstruct>(

{dyn_cast_or_null<CXXConstructExpr>(Init), LC})) &&

State->set<ObjectsUnderConstruction>(Key,

);

*

= State->get<ObjectsUnderConstruction>(Key);

? std::make_optional(*

) : std::nullopt;

assert(State->contains<ObjectsUnderConstruction>(Key));

State->remove<ObjectsUnderConstruction>(Key);

ConstructedObjectKey Key({BTE,

}, LC);

State->set<ObjectsUnderConstruction>(Key,

());

ConstructedObjectKey Key({BTE,

}, LC);

assert(State->contains<ObjectsUnderConstruction>(Key));

State->remove<ObjectsUnderConstruction>(Key);

ConstructedObjectKey Key({BTE,

}, LC);

State->contains<ObjectsUnderConstruction>(Key);

assert(LC &&

);

(

I : State->get<ObjectsUnderConstruction>())

(I.first.getLocationContext() == LC)

cond,

assumption) {

Space = 0,

IsDot =

) {

HasItem =

;

ConstructedObjectKey *LastKey =

;

(

&I : State->get<ObjectsUnderConstruction>()) {

ConstructedObjectKey &Key = I.first;

(Key.getLocationContext() != LCtx)

(

&I : State->get<ObjectsUnderConstruction>()) {

ConstructedObjectKey &Key = I.first;

(Key.getLocationContext() != LCtx)

Indent(Out, Space, IsDot) <<

;

Key.printJson(Out,

, PP);

Out <<

<<

<<

;

Indent(Out, --Space, IsDot) <<

;

*LCtx,

Space = 0,

IsDot =

) {

KeyT = std::pair<const Expr *, const LocationContext *>;

HasItem =

;

(

&I : State->get<IndexOfElementToConstruct>()) {

KeyT &Key = I.first;

(Key.second != LCtx)

(

&I : State->get<IndexOfElementToConstruct>()) {

KeyT &Key = I.first;

= I.second;

(Key.second != LCtx)

Indent(Out, Space, IsDot) <<

;

*

= Key.first;

Out <<

<<

->

(Context);

Out <<

;

Out <<

;

Out <<

<<

- 1 <<

;

Indent(Out, --Space, IsDot) <<

;

Space = 0,

IsDot =

) {

KeyT = std::pair<const CXXConstructExpr *, const LocationContext *>;

HasItem =

;

(

&I : State->get<PendingInitLoop>()) {

KeyT &Key = I.first;

(Key.second != LCtx)

(

&I : State->get<PendingInitLoop>()) {

KeyT &Key = I.first;

= I.second;

(Key.second != LCtx)

Indent(Out, Space, IsDot) <<

;

Out <<

<<

->

(Context);

Out <<

;

Out <<

;

Out <<

<<

<<

;

Indent(Out, --Space, IsDot) <<

;

Space = 0,

IsDot =

) {

HasItem =

;

KeyT LastKey =

;

(

&I : State->get<PendingArrayDestruction>()) {

KeyT &Key = I.first;

(

&I : State->get<PendingArrayDestruction>()) {

KeyT &Key = I.first;

Indent(Out, Space, IsDot) <<

;

Out <<

;

Out <<

;

Out <<

;

Out <<

<< I.second <<

;

Indent(Out, --Space, IsDot) <<

;

<

Trait,

Printer,

... Args>

*NL,

Space,

IsDot,

*jsonPropertyName, Printer printer, Args &&...args) {

(std::is_function_v<std::remove_pointer_t<Printer>>,

);

(std::is_convertible_v<Printer, RequiredType>,

);

(LCtx && !State->get<Trait>().isEmpty()) {

Indent(Out, Space, IsDot) <<

<< jsonPropertyName <<

;

printer(Out, State, NL, LC, Space, IsDot, std::forward<Args>(args)...);

Indent(Out, Space, IsDot) <<

<< NL;

Space,

IsDot)

{

printStateTraitWithLocationContextJson<ObjectsUnderConstruction>(

Out, State, LCtx, NL, Space, IsDot,

,

printStateTraitWithLocationContextJson<IndexOfElementToConstruct>(

Out, State, LCtx, NL, Space, IsDot,

,

printStateTraitWithLocationContextJson<PendingInitLoop>(

Out, State, LCtx, NL, Space, IsDot,

,

printStateTraitWithLocationContextJson<PendingArrayDestruction>(

Out, State, LCtx, NL, Space, IsDot,

,

currStmtIdx = StmtIdx;

(

.getKind()) {

*ReferenceStmt,

*DiagnosticStmt,

ReferenceStmt ==

|| isa<ReturnStmt>(ReferenceStmt))

&&

);

assert(LC &&

);

(!DiagnosticStmt) {

DiagnosticStmt = ReferenceStmt;

assert(DiagnosticStmt &&

);

NumRemoveDeadBindings++;

(!ReferenceStmt) {

);

(

I : CleanedState->get<ObjectsUnderConstruction>()) {

(

Sym = I.second.getAsSymbol())

(

*MR = I.second.getAsRegion())

CleanedState, SFC, SymReaper);

DiagnosticStmt, *

, K);

(

I : CheckedSet) {

);

);

);

CleanedStates.

(Pred);

(

I : CleanedStates) {

(currStmt, I, DstI);

);

(AMgr.

.ShouldUnrollLoops)

);

*

= cast<CXXConstructorDecl>(stackFrame->getDecl());

State = finishObjectConstruction(State, BMI, LC);

FieldLoc = State->getLValue(BMI->

(), thisVal);

(

->getType()->isArrayType()) {

((ASE = dyn_cast<ArraySubscriptExpr>(

)))

InitVal = State->getSVal(

, stackFrame);

InitVal = State->getSVal(BMI->

(), stackFrame);

evalBind(Tmp,

, Pred, FieldLoc, InitVal,

, &PP);

InitVal = State->getSVal(

, stackFrame);

evalBind(Tmp,

, Pred, BaseLoc, InitVal,

);

(

I : Tmp) {

std::pair<ProgramStateRef, uint64_t>

ExprEngine::prepareStateForArrayDestruction(

State,

*ElementCountVal) {

assert(Region !=

&&

);

(

*NTy = dyn_cast<ArrayType>(Ty))

Ty = NTy->getElementType().getDesugaredType(

());

(ElementCountVal)

*ElementCountVal = ElementCount;

(!ElementCount.isConstant())

Idx = ElementCount.getAsInteger()->getLimitedValue();

{setPendingArrayDestruction(State, LCtx, Idx), Idx};

llvm_unreachable(

);

(Opts.MayInlineCXXAllocator)

*ValueRegion = state->getSVal(Region).getAsRegion();

varType = cast<TypedValueRegion>(Region)->getValueType();

(isa<ArrayType>(varType)) {

std::tie(state, Idx) = prepareStateForArrayDestruction(

state, Region, varType, LCtx, &ElementCount);

uint64_t ArrayLength = ElementCount.

()->getLimitedValue();

assert(ArrayLength &&

);

,

);

);

, Pred, Dst, CallOpts);

ArgVal = State->getSVal(Arg, LCtx);

(State->isNull(ArgVal).isConstrainedTrue()) {

getDtorDecl = [](

&DTy) {

DTy = AT->getElementType();

std::tie(State, Idx) = prepareStateForArrayDestruction(

State, ArgR, DTy, LCtx, &ElementCount);

ElementCount.

()->getLimitedValue() == 0) {

,

);

ArgR = State->getLValue(DTy, svalBuilder.

(Idx), ArgVal)

);

*CurDtor = cast<CXXDestructorDecl>(LCtx->

());

->isVirtual());

, Pred, Dst, CallOpts);

*DtorDecl =

.getDestructorDecl(

());

*CurDtor = cast<CXXDestructorDecl>(LCtx->

());

ThisStorageLoc =

ThisLoc = State->getSVal(ThisStorageLoc).castAs<

>();

FieldVal = State->getLValue(

, ThisLoc);

(isa<ArrayType>(

)) {

std::tie(State, Idx) = prepareStateForArrayDestruction(

State, FieldVal.getAsRegion(),

, LCtx, &ElementCount);

uint64_t ArrayLength = ElementCount.

()->getLimitedValue();

assert(ArrayLength &&

);

,

);

);

, Pred, Dst, CallOpts);

State = finishObjectConstruction(State,

.getBindTemporaryExpr(),

MR =

->getAsRegion();

(isDestructorElided(State, BTE, LC)) {

State = cleanupElidedDestructor(State, BTE, LC);

StmtBldr.

(

.getBindTemporaryExpr(), Pred, State);

=

.getBindTemporaryExpr()->getSubExpr()->getType();

assert(CleanDtorState.

() <= 1);

CleanDtorState.

() ? Pred : *CleanDtorState.

();

= AT->getElementType();

, CleanPred, Dst, CallOpts);

State = addObjectUnderConstruction(State, BTE, LC,

());

CollectReachableSymbolsCallback final :

{

: Symbols(Symbols) {}

VisitSymbol(

Sym)

{

Symbols.insert(Sym);

CollectReachableSymbolsCallback CallBack(Symbols);

State->scanReachableSymbols(

, CallBack);

State, CallBack.getSymbols(),

, K,

);

S->getBeginLoc(),

);

assert(!isa<Expr>(S) || S == cast<Expr>(S)->IgnoreParens());

(S->getStmtClass()) {

Stmt::CXXDependentScopeMemberExprClass:

Stmt::CXXTryStmtClass:

Stmt::CXXTypeidExprClass:

Stmt::CXXUuidofExprClass:

Stmt::CXXFoldExprClass:

Stmt::MSPropertyRefExprClass:

Stmt::MSPropertySubscriptExprClass:

Stmt::CXXUnresolvedConstructExprClass:

Stmt::DependentScopeDeclRefExprClass:

Stmt::ArrayTypeTraitExprClass:

Stmt::ExpressionTraitExprClass:

Stmt::UnresolvedLookupExprClass:

Stmt::UnresolvedMemberExprClass:

Stmt::TypoExprClass:

Stmt::RecoveryExprClass:

Stmt::CXXNoexceptExprClass:

Stmt::PackExpansionExprClass:

Stmt::PackIndexingExprClass:

Stmt::SubstNonTypeTemplateParmPackExprClass:

Stmt::FunctionParmPackExprClass:

Stmt::CoroutineBodyStmtClass:

Stmt::CoawaitExprClass:

Stmt::DependentCoawaitExprClass:

Stmt::CoreturnStmtClass:

Stmt::CoyieldExprClass:

Stmt::ResolvedUnexpandedPackExprClass:

Stmt::SEHTryStmtClass:

Stmt::SEHExceptStmtClass:

Stmt::SEHLeaveStmtClass:

Stmt::SEHFinallyStmtClass:

Stmt::OMPCanonicalLoopClass:

Stmt::OMPParallelDirectiveClass:

Stmt::OMPSimdDirectiveClass:

Stmt::OMPForDirectiveClass:

Stmt::OMPForSimdDirectiveClass:

Stmt::OMPSectionsDirectiveClass:

Stmt::OMPSectionDirectiveClass:

Stmt::OMPScopeDirectiveClass:

Stmt::OMPSingleDirectiveClass:

Stmt::OMPMasterDirectiveClass:

Stmt::OMPCriticalDirectiveClass:

Stmt::OMPParallelForDirectiveClass:

Stmt::OMPParallelForSimdDirectiveClass:

Stmt::OMPParallelSectionsDirectiveClass:

Stmt::OMPParallelMasterDirectiveClass:

Stmt::OMPParallelMaskedDirectiveClass:

Stmt::OMPTaskDirectiveClass:

Stmt::OMPTaskyieldDirectiveClass:

Stmt::OMPBarrierDirectiveClass:

Stmt::OMPTaskwaitDirectiveClass:

Stmt::OMPErrorDirectiveClass:

Stmt::OMPTaskgroupDirectiveClass:

Stmt::OMPFlushDirectiveClass:

Stmt::OMPDepobjDirectiveClass:

Stmt::OMPScanDirectiveClass:

Stmt::OMPOrderedDirectiveClass:

Stmt::OMPAtomicDirectiveClass:

Stmt::OMPAssumeDirectiveClass:

Stmt::OMPTargetDirectiveClass:

Stmt::OMPTargetDataDirectiveClass:

Stmt::OMPTargetEnterDataDirectiveClass:

Stmt::OMPTargetExitDataDirectiveClass:

Stmt::OMPTargetParallelDirectiveClass:

Stmt::OMPTargetParallelForDirectiveClass:

Stmt::OMPTargetUpdateDirectiveClass:

Stmt::OMPTeamsDirectiveClass:

Stmt::OMPCancellationPointDirectiveClass:

Stmt::OMPCancelDirectiveClass:

Stmt::OMPTaskLoopDirectiveClass:

Stmt::OMPTaskLoopSimdDirectiveClass:

Stmt::OMPMasterTaskLoopDirectiveClass:

Stmt::OMPMaskedTaskLoopDirectiveClass:

Stmt::OMPMasterTaskLoopSimdDirectiveClass:

Stmt::OMPMaskedTaskLoopSimdDirectiveClass:

Stmt::OMPParallelMasterTaskLoopDirectiveClass:

Stmt::OMPParallelMaskedTaskLoopDirectiveClass:

Stmt::OMPParallelMasterTaskLoopSimdDirectiveClass:

Stmt::OMPParallelMaskedTaskLoopSimdDirectiveClass:

Stmt::OMPDistributeDirectiveClass:

Stmt::OMPDistributeParallelForDirectiveClass:

Stmt::OMPDistributeParallelForSimdDirectiveClass:

Stmt::OMPDistributeSimdDirectiveClass:

Stmt::OMPTargetParallelForSimdDirectiveClass:

Stmt::OMPTargetSimdDirectiveClass:

Stmt::OMPTeamsDistributeDirectiveClass:

Stmt::OMPTeamsDistributeSimdDirectiveClass:

Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:

Stmt::OMPTeamsDistributeParallelForDirectiveClass:

Stmt::OMPTargetTeamsDirectiveClass:

Stmt::OMPTargetTeamsDistributeDirectiveClass:

Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:

Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:

Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:

Stmt::OMPReverseDirectiveClass:

Stmt::OMPTileDirectiveClass:

Stmt::OMPInterchangeDirectiveClass:

Stmt::OMPInteropDirectiveClass:

Stmt::OMPDispatchDirectiveClass:

Stmt::OMPMaskedDirectiveClass:

Stmt::OMPGenericLoopDirectiveClass:

Stmt::OMPTeamsGenericLoopDirectiveClass:

Stmt::OMPTargetTeamsGenericLoopDirectiveClass:

Stmt::OMPParallelGenericLoopDirectiveClass:

Stmt::OMPTargetParallelGenericLoopDirectiveClass:

Stmt::CapturedStmtClass:

Stmt::SYCLKernelCallStmtClass:

Stmt::OpenACCComputeConstructClass:

Stmt::OpenACCLoopConstructClass:

Stmt::OpenACCCombinedConstructClass:

Stmt::OpenACCDataConstructClass:

Stmt::OpenACCEnterDataConstructClass:

Stmt::OpenACCExitDataConstructClass:

Stmt::OpenACCHostDataConstructClass:

Stmt::OpenACCWaitConstructClass:

Stmt::OpenACCInitConstructClass:

Stmt::OpenACCShutdownConstructClass:

Stmt::OpenACCSetConstructClass:

Stmt::OpenACCUpdateConstructClass:

Stmt::OMPUnrollDirectiveClass:

Stmt::OMPMetaDirectiveClass:

Stmt::HLSLOutArgExprClass: {

Stmt::ParenExprClass:

llvm_unreachable(

);

Stmt::GenericSelectionExprClass:

llvm_unreachable(

);

Stmt::BreakStmtClass:

Stmt::CaseStmtClass:

Stmt::CompoundStmtClass:

Stmt::ContinueStmtClass:

Stmt::CXXForRangeStmtClass:

Stmt::DefaultStmtClass:

Stmt::DoStmtClass:

Stmt::ForStmtClass:

Stmt::GotoStmtClass:

Stmt::IfStmtClass:

Stmt::IndirectGotoStmtClass:

Stmt::LabelStmtClass:

Stmt::NullStmtClass:

Stmt::SwitchStmtClass:

Stmt::WhileStmtClass:

Expr::MSDependentExistsStmtClass:

llvm_unreachable(

);

Stmt::ImplicitValueInitExprClass:

llvm_unreachable(

);

Stmt::ObjCSubscriptRefExprClass:

Stmt::ObjCPropertyRefExprClass:

llvm_unreachable(

);

Stmt::GNUNullExprClass: {

state = state->BindExpr(

Stmt::ObjCAtSynchronizedStmtClass:

Expr::ConstantExprClass:

Stmt::ExprWithCleanupsClass:

Stmt::CXXBindTemporaryExprClass: {

Stmt::ArrayInitLoopExprClass:

Stmt::DesignatedInitExprClass:

Stmt::DesignatedInitUpdateExprClass:

Stmt::ArrayInitIndexExprClass:

Stmt::ExtVectorElementExprClass:

Stmt::ImaginaryLiteralClass:

Stmt::ObjCAtCatchStmtClass:

Stmt::ObjCAtFinallyStmtClass:

Stmt::ObjCAtTryStmtClass:

Stmt::ObjCAutoreleasePoolStmtClass:

Stmt::ObjCEncodeExprClass:

Stmt::ObjCIsaExprClass:

Stmt::ObjCProtocolExprClass:

Stmt::ObjCSelectorExprClass:

Stmt::ParenListExprClass:

Stmt::ShuffleVectorExprClass:

Stmt::ConvertVectorExprClass:

Stmt::VAArgExprClass:

Stmt::CUDAKernelCallExprClass:

Stmt::OpaqueValueExprClass:

Stmt::AsTypeExprClass:

Stmt::ConceptSpecializationExprClass:

Stmt::CXXRewrittenBinaryOperatorClass:

Stmt::RequiresExprClass:

Expr::CXXParenListInitExprClass:

Stmt::EmbedExprClass:

Stmt::PredefinedExprClass:

Stmt::AddrLabelExprClass:

Stmt::AttributedStmtClass:

Stmt::IntegerLiteralClass:

Stmt::FixedPointLiteralClass:

Stmt::CharacterLiteralClass:

Stmt::CXXScalarValueInitExprClass:

Stmt::CXXBoolLiteralExprClass:

Stmt::ObjCBoolLiteralExprClass:

Stmt::ObjCAvailabilityCheckExprClass:

Stmt::FloatingLiteralClass:

Stmt::NoInitExprClass:

Stmt::SizeOfPackExprClass:

Stmt::StringLiteralClass:

Stmt::SourceLocExprClass:

Stmt::ObjCStringLiteralClass:

Stmt::CXXPseudoDestructorExprClass:

Stmt::SubstNonTypeTemplateParmExprClass:

Stmt::CXXNullPtrLiteralExprClass:

Stmt::ArraySectionExprClass:

Stmt::OMPArrayShapingExprClass:

Stmt::OMPIteratorExprClass:

Stmt::SYCLUniqueStableNameExprClass:

Stmt::OpenACCAsteriskSizeExprClass:

Stmt::TypeTraitExprClass: {

Stmt::CXXDefaultArgExprClass:

Stmt::CXXDefaultInitExprClass: {

(

*DefE = dyn_cast<CXXDefaultArgExpr>(S))

ArgE = DefE->getExpr();

(

*DefE = dyn_cast<CXXDefaultInitExpr>(S))

ArgE = DefE->getExpr();

llvm_unreachable(

);

IsTemporary =

;

(

*MTE = dyn_cast<MaterializeTemporaryExpr>(ArgE)) {

ArgE = MTE->getSubExpr();

IsTemporary =

;

std::optional<SVal> ConstantVal = svalBuilder.

(ArgE);

(

I : PreVisit) {

State = State->BindExpr(S, LCtx, *ConstantVal);

State = createTemporaryRegionIfNeeded(State, LCtx,

Stmt::CXXStdInitializerListExprClass:

Expr::ObjCArrayLiteralClass:

Expr::ObjCDictionaryLiteralClass:

Expr::ObjCBoxedExprClass: {

*Ex = cast<Expr>(S);

resultType = Ex->getType();

(

N : preVisit) {

(!(isa<ObjCBoxedExpr>(Ex) &&

!cast<ObjCBoxedExpr>(Ex)->getSubExpr()

(

Child : Ex->children()) {

Val = State->getSVal(Child, LCtx);

Stmt::ArraySubscriptExprClass:

Stmt::MatrixSubscriptExprClass:

llvm_unreachable(

);

Stmt::GCCAsmStmtClass: {

Stmt::MSAsmStmtClass:

Stmt::BlockExprClass:

Stmt::LambdaExprClass:

(AMgr.

.ShouldInlineLambdas) {

Stmt::BinaryOperatorClass: {

*B = cast<BinaryOperator>(S);

(B->isLogicalOp()) {

(B->getOpcode() == BO_Comma) {

state->getSVal(B->getRHS(),

(AMgr.

.ShouldEagerlyAssume &&

(B->isRelationalOp() || B->isEqualityOp())) {

Stmt::CXXOperatorCallExprClass: {

*OCE = cast<CXXOperatorCallExpr>(S);

*Callee = OCE->getCalleeDecl();

(

*MD = dyn_cast_or_null<CXXMethodDecl>(Callee)) {

(MD->isImplicitObjectMemberFunction()) {

createTemporaryRegionIfNeeded(State, LCtx, OCE->getArg(0));

(NewState != State) {

Pred = Bldr.

(OCE, Pred, NewState,

,

Stmt::CallExprClass:

Stmt::CXXMemberCallExprClass:

Stmt::UserDefinedLiteralClass:

Stmt::CXXCatchStmtClass:

Stmt::CXXTemporaryObjectExprClass:

Stmt::CXXConstructExprClass:

Stmt::CXXInheritedCtorInitExprClass:

Stmt::CXXNewExprClass: {

(

i : PreVisit)

Stmt::CXXDeleteExprClass: {

*CDE = cast<CXXDeleteExpr>(S);

Stmt::ChooseExprClass: {

*

= cast<ChooseExpr>(S);

Stmt::CompoundAssignOperatorClass:

Stmt::CompoundLiteralExprClass:

Stmt::BinaryConditionalOperatorClass:

Stmt::ConditionalOperatorClass: {

*

= cast<AbstractConditionalOperator>(S);

Stmt::CXXThisExprClass:

Stmt::DeclRefExprClass: {

*DE = cast<DeclRefExpr>(S);

Stmt::DeclStmtClass:

Stmt::ImplicitCastExprClass:

Stmt::CStyleCastExprClass:

Stmt::CXXStaticCastExprClass:

Stmt::CXXDynamicCastExprClass:

Stmt::CXXReinterpretCastExprClass:

Stmt::CXXConstCastExprClass:

Stmt::CXXFunctionalCastExprClass:

Stmt::BuiltinBitCastExprClass:

Stmt::ObjCBridgedCastExprClass:

Stmt::CXXAddrspaceCastExprClass: {

*

= cast<CastExpr>(S);

Expr::MaterializeTemporaryExprClass: {

*MTE = cast<MaterializeTemporaryExpr>(S);

(

i : dstPrevisit)

Stmt::InitListExprClass:

Stmt::MemberExprClass:

Stmt::AtomicExprClass:

Stmt::ObjCIvarRefExprClass:

Stmt::ObjCForCollectionStmtClass:

Stmt::ObjCMessageExprClass:

Stmt::ObjCAtThrowStmtClass:

Stmt::CXXThrowExprClass:

Stmt::ReturnStmtClass:

Stmt::OffsetOfExprClass: {

(

: PreVisit)

Stmt::UnaryExprOrTypeTraitExprClass:

Stmt::StmtExprClass: {

*SE = cast<StmtExpr>(S);

(SE->getSubStmt()->body_empty()) {

&&

);

(

*LastExpr =

dyn_cast<Expr>(*SE->getSubStmt()->body_rbegin())) {

state->getSVal(LastExpr,

Stmt::UnaryOperatorClass: {

*

= cast<UnaryOperator>(S);

(AMgr.

.ShouldEagerlyAssume && (

->getOpcode() == UO_LNot)) {

Stmt::PseudoObjectExprClass: {

*PE = cast<PseudoObjectExpr>(S);

(

*

= PE->getResultExpr()) {

Expr::ObjCIndirectCopyRestoreExprClass: {

*OIE = cast<ObjCIndirectCopyRestoreExpr>(S);

*

= OIE->getSubExpr();

ExprEngine::replayWithoutInlining(

*N,

assert(CalleeSF && CallerSF);

BeforeProcessingCall = N;

(SP->getStmt() == CE)

(!BeforeProcessingCall)

IsNew =

;

NumTimesRetriedWithoutInlining++;

(AMgr.

.ShouldUnrollLoops) {

Pred, maxBlockVisitOnPath);

(NewState != Pred->

()) {

AMgr.

.ShouldWidenLoops) {

(!isa_and_nonnull<ForStmt, WhileStmt, DoStmt, CXXForRangeStmt>(Term))

(*G.

())->getLocation().getLocationContext();

replayWithoutInlining(Pred, CalleeLC)))

NumMaxBlockCountReachedInInlined++;

NumMaxBlockCountReached++;

Engine.blocksExhausted.push_back(std::make_pair(L, Sink));

*Ex = dyn_cast<Expr>(

);

bitsInit =

;

(

*CE = dyn_cast<CastExpr>(Ex)) {

(!bitsInit || newBits < bits) {

Ex = CE->getSubExpr();

state->getSVal(Ex, LCtx);

*BO = dyn_cast<BinaryOperator>(

);

(!BO || !BO->isLogicalOp()) {

= BO->getRHS()->IgnoreParens();

(

*Ex = dyn_cast<Expr>(

))

*BO = dyn_cast<BinaryOperator>(

);

(!BO || !BO->isLogicalOp())

);

std::optional<CFGStmt> CS = Elem.getAs<

>();

*LastStmt = CS->getStmt();

llvm_unreachable(

);

std::pair<const ObjCForCollectionStmt *, const LocationContext *>;

assert(!State->contains<ObjCForHasMoreIterations>({O, LC}));

State->set<ObjCForHasMoreIterations>({O, LC}, HasMoreIteraton);

assert(State->contains<ObjCForHasMoreIterations>({O, LC}));

State->remove<ObjCForHasMoreIterations>({O, LC});

assert(State->contains<ObjCForHasMoreIterations>({O, LC}));

*State->get<ObjCForHasMoreIterations>({O, LC});

std::optional<std::pair<ProgramStateRef, ProgramStateRef>>

(

*ObjCFor = dyn_cast<ObjCForCollectionStmt>(

)) {

HasMoreIteraton =

(HasMoreIteraton)

std::pair<ProgramStateRef, ProgramStateRef>{State,

};

std::pair<ProgramStateRef, ProgramStateRef>{

, State};

(

.isUnknownOrUndef()) {

(

*Ex = dyn_cast<Expr>(

)) {

(Ex->getType()->isIntegralOrEnumerationType()) {

N->

()->getStateManager().getContext());

(

.isUnknownOrUndef())

std::nullopt;

State->assume(

);

std::optional<unsigned> IterationsCompletedInLoop) {

);

currBldrCtx = &BldCtx;

(

*Ex = dyn_cast<Expr>(

))

);

(CheckersOutSet.

())

(PredN->isSink())

std::tie(StTrue, StFalse) = *KnownCondValueAssumption;

(StTrue && StFalse)

assert(!isa<ObjCForCollectionStmt>(

));

CompletedTwoIterations = IterationsCompletedInLoop.value_or(0) >= 2;

FalseAlsoFeasible =

SkipTrueBranch = CompletedTwoIterations && FalseAlsoFeasible;

(!SkipTrueBranch || AMgr.

.ShouldWidenLoops)

Builder.generateNode(StTrue,

, PredN);

Builder.generateNode(StFalse,

, PredN);

currBldrCtx =

;

llvm::ImmutableSet<const VarDecl *>)

currBldrCtx = &BuilderCtx;

initHasRun = state->contains<InitializedGlobalsSet>(VD);

state = state->add<InitializedGlobalsSet>(VD);

Builder.generateNode(state, initHasRun, Pred);

currBldrCtx =

;

(std::optional<loc::GotoLabel> LV =

.getAs<

>()) {

(iterator Succ : builder) {

(Succ.getLabel() == L) {

builder.generateNode(Succ, state);

llvm_unreachable(

);

(isa<UndefinedVal, loc::ConcreteInt>(

)) {

(iterator Succ : builder)

State = finishArgumentConstruction(

(LC != ToLC) {

assert(LC &&

);

(

I : State->get<ObjectsUnderConstruction>())

(I.first.getLocationContext() == LC) {

assert(I.first.getItem().getKind() ==

I.first.getItem().getKind() ==

State = State->remove<ObjectsUnderConstruction>(I.first);

assert(areAllObjectsFullyConstructed(Pred->

(),

(

I : AfterRemovedDead)

(CondV_untested.

()) {

iterator I = builder.

(), EI = builder.

();

defaultIsFeasible = I == EI;

( ; I != EI; ++I) {

*Case = I.getCase();

(std::optional<NonLoc> NL = CondV.

<

>())

std::tie(StateCase, DefaultSt) =

DefaultSt->assumeInclusiveRange(*NL, V1, V2);

StateCase = DefaultSt;

defaultIsFeasible =

;

defaultIsFeasible =

;

(!defaultIsFeasible)

(

*VD = dyn_cast<VarDecl>(

)) {

assert(Ex->

() || VD->getType()->isVoidType());

*MD = dyn_cast_or_null<CXXMethodDecl>(

);

*DeclRefEx = dyn_cast<DeclRefExpr>(Ex);

std::optional<std::pair<SVal, QualType>> VInfo;

(AMgr.

.ShouldInlineLambdas && DeclRefEx &&

DeclRefEx->refersToEnclosingVariableOrCapture() && MD &&

MD->getParent()->isLambda()) {

llvm::DenseMap<const ValueDecl *, FieldDecl *> LambdaCaptureFields;

(

*FD = LambdaCaptureFields[VD]) {

VInfo = std::make_pair(state->getLValue(FD, CXXThisVal), FD->getType());

VInfo = std::make_pair(state->getLValue(VD, LocCtxt), VD->getType());

= VInfo->first;

IsReference = VInfo->second->isReferenceType();

= state->getSVal(R);

Bldr.

(Ex, Pred, state->BindExpr(Ex, LCtx,

),

,

(

*ED = dyn_cast<EnumConstantDecl>(

)) {

Bldr.

(Ex, Pred, state->BindExpr(Ex, LCtx,

));

(

*FD = dyn_cast<FunctionDecl>(

)) {

Bldr.

(Ex, Pred, state->BindExpr(Ex, LCtx,

),

,

(isa<FieldDecl, IndirectFieldDecl>(

)) {

(

*BD = dyn_cast<BindingDecl>(

)) {

*DD = cast<DecompositionDecl>(BD->getDecomposedDecl());

= state->getLValue(DD, LCtx);

(DD->getType()->isReferenceType()) {

= state->getSVal(R);

(

*ME = dyn_cast<MemberExpr>(BD->getBinding())) {

*Field = cast<FieldDecl>(ME->getMemberDecl());

= state->getLValue(Field,

);

(

*ASE = dyn_cast<ArraySubscriptExpr>(BD->getBinding())) {

Idx = state->getSVal(ASE->getIdx(), LCtx);

assert(Idx.

() &&

);

= state->getLValue(BD->getType(), Idx,

);

(

*HV = BD->getHoldingVar()) {

= state->getLValue(HV, LCtx);

(HV->getType()->isReferenceType()) {

= state->getSVal(R);

llvm_unreachable(

);

(BD->getType()->isReferenceType() && !BD->getHoldingVar()) {

= state->getSVal(R);

Bldr.

(Ex, Pred, state->BindExpr(Ex, LCtx,

),

,

(

*TPO = dyn_cast<TemplateParamObjectDecl>(

)) {

llvm_unreachable(

);

(

*

: CheckerPreStmt) {

(isa<CXXConstructExpr>(Ex->

()))

(

*ME = dyn_cast<MemberExpr>(Arr)) {

*MEBase = ME->getBase();

(

CXXSCE = dyn_cast<CXXStaticCastExpr>(MEBase)) {

MEBase = CXXSCE->getSubExpr();

ObjDeclExpr = cast<DeclRefExpr>(MEBase);

Obj = state->getLValue(cast<VarDecl>(ObjDeclExpr->getDecl()), LCtx);

= state->getLValue(cast<FieldDecl>(ME->getMemberDecl()), Obj);

(

*DRE = dyn_cast<DeclRefExpr>(Arr))

= state->getLValue(cast<VarDecl>(DRE->getDecl()), LCtx);

= state->getSVal(R);

IsGLValueLike = A->

() ||

(

*

: CheckerPreStmt) {

(IsGLValueLike) {

= state->getLValue(

,

state->getSVal(Idx, LCtx),

state->getSVal(

, LCtx));

}

(IsVectorType) {

llvm_unreachable(

);

(isa<VarDecl, EnumConstantDecl>(

)) {

(

I : CheckedSet)

(

I : CheckedSet) {

(

*MD = dyn_cast<CXXMethodDecl>(

)) {

(MD->isImplicitObjectMemberFunction())

state = createTemporaryRegionIfNeeded(state, LCtx, BaseExpr);

state = state->BindExpr(M, LCtx, MDVal);

state = createTemporaryRegionIfNeeded(state, LCtx, BaseExpr,

(

*SR =

dyn_cast_or_null<SymbolicRegion>(baseExprVal.

())) {

= SR->getPointeeStaticType();

*field = cast<FieldDecl>(

);

L = state->getLValue(field, baseExprVal);

dyn_cast<ImplicitCastExpr>(I->getParentMap().getParentIgnoreParens(M));

(!PE || PE->getCastKind() != CK_ArrayToPointerDecay) {

llvm_unreachable(

);

(field->getType()->isReferenceType()) {

L = state->getSVal(R);

Bldr.

(M, I, state->BindExpr(M, LCtx, L),

,

(

I : AfterPreSet) {

(

SI = 0, Count = AE->

(); SI != Count; SI++) {

SubExprVal = State->getSVal(SubExpr, LCtx);

ValuesToInvalidate.push_back(SubExprVal);

State = State->invalidateRegions(ValuesToInvalidate, AE,

State = State->BindExpr(AE, LCtx, ResultVal);

(

std::pair<SVal, SVal> &LocAndVal : LocAndVals) {

*MR = LocAndVal.first.getAsRegion();

!isa<StackSpaceRegion, StaticGlobalSpaceRegion>(MR->

())) {

Escaped.push_back(LocAndVal.second);

(

*VR = dyn_cast<VarRegion>(MR->

()))

(VR->hasStackParametersStorage() && VR->getStackFrame()->inTopFrame())

(

*RD = VR->getValueType()->getAsCXXRecordDecl())

(!RD->hasTrivialDestructor()) {

Escaped.push_back(LocAndVal.second);

StoredVal = State->getSVal(MR);

(StoredVal != LocAndVal.second)

Escaped.push_back(LocAndVal.second);

(Escaped.empty())

escapeValues(State, Escaped, Kind,

);

std::pair<SVal, SVal> LocAndVal(

, Val);

(!Invalidated || Invalidated->empty())

(

I : ExplicitRegions) {

SymbolsDirectlyInvalidated.insert(R->getSymbol());

(

&sym : *Invalidated) {

(SymbolsDirectlyInvalidated.count(sym))

SymbolsIndirectlyInvalidated.insert(sym);

(!SymbolsDirectlyInvalidated.empty())

(!SymbolsIndirectlyInvalidated.empty())

StoreE, *

, *PP);

(!isa<Loc>(location)) {

Bldr.generateNode(L, state, Pred);

(

PredI : CheckedSet) {

state = state->bindLoc(location.

<

>(),

Val, LC,

!atDeclInit);

(std::optional<loc::MemRegionVal> LocRegVal =

LocReg = LocRegVal->getRegion();

Bldr.generateNode(L, state, PredI);

*LocationE,

*StoreE = AssignE ? AssignE : LocationE;

evalLocation(Tmp, AssignE, LocationE, Pred, state, location,

);

(

I : Tmp)

evalBind(Dst, StoreE, I, location, Val,

);

*BoundEx,

assert(!isa<NonLoc>(location) &&

);

evalLocation(Tmp, NodeEx, BoundEx, Pred, state, location,

);

(

I : Tmp) {

state = I->getState();

LoadTy = BoundEx->

();

= state->getSVal(location.

<

>(), LoadTy);

Bldr.

(NodeEx, I, state->BindExpr(BoundEx, LCtx,

), tag,

*BoundEx,

BldrTop.takeNodes(Pred);

Bldr.generateNode(NodeEx, Pred, state, &tag);

NodeEx, BoundEx, *

);

BldrTop.addNodes(Tmp);

std::pair<const ProgramPointTag *, const ProgramPointTag *>

FalseTag(TagProviderName,

);

std::make_pair(&TrueTag, &FalseTag);

State = State->set<LastEagerlyAssumeExprIfSuccessful>(

);

(SEV && SEV->isExpression()) {

[StateTrue, StateFalse] = State->assume(*SEV);

(StateTrue && StateFalse) {

StateTrue = StateTrue->set<LastEagerlyAssumeExprIfSuccessful>(Ex);

StateFalse = StateFalse->set<LastEagerlyAssumeExprIfSuccessful>(Ex);

*Ex)

{

Ex && State->get<LastEagerlyAssumeExprIfSuccessful>() == Ex;

assert(!isa<NonLoc>(

));

(std::optional<Loc> LV =

.getAs<

>())

state = state->invalidateRegions(*LV, A, currBldrCtx->

(),

(std::optional<Loc> LV =

.getAs<

>())

state = state->invalidateRegions(*LV, A, currBldrCtx->

(),

N->

()->getStateManager().getOwningEngine()).getBugReporter();

(

&

:

.getReports()) {

*PR = dyn_cast<PathSensitiveBugReport>(

.get());

llvm::function_ref<

(

*)> PreCallback,

llvm::function_ref<

(

*)> PostCallback,

llvm::function_ref<

(

*)> Stop) {

llvm::raw_string_ostream Out(Buf);

IsDot =

;

Space = 1;

Out <<

<< State->getID()

Indent(Out, Space, IsDot) <<

;

traverseHiddenNodes(

Indent(Out, Space + 1, IsDot) <<

;

Out <<

;

Out <<

<< Tag->getTagDescription() <<

;

Out <<

<< OtherNode->

() <<

<< OtherNode->

() <<

<< nodeHasBugReport(OtherNode) <<

;

Indent(Out, Space, IsDot) <<

;

llvm::DisplayGraph(

,

, llvm::GraphProgram::DOT);

llvm::DisplayGraph(

,

, llvm::GraphProgram::DOT);

std::vector<const ExplodedNode *> Src;

dyn_cast<PathSensitiveBugReport>(

.getReports()[0].get());

*N =

*

(R->getErrorNode());

llvm::WriteGraph(&G,

,

,

std::unique_ptr<ExplodedGraph> TrimmedG(G.

(

));

(!TrimmedG.get()) {

llvm::errs() <<

;

llvm::WriteGraph(TrimmedG.get(),

,

,

index = 0;

ExprEngine::anchor() { }

Defines the clang::ASTContext interface.

BoundNodesTreeBuilder Nodes

This file defines AnalysisDeclContext, a class that manages the analysis context data for context sen...

static const MemRegion * getRegion(const CallEvent &Call, const MutexDescriptor &Descriptor, bool IsLock)

static Decl::Kind getKind(const Decl *D)

Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....

Defines the clang::Expr interface and subclasses for C++ expressions.

static const Stmt * getRightmostLeaf(const Stmt *Condition)

std::pair< const ObjCForCollectionStmt *, const LocationContext * > ObjCForLctxPair

static SVal RecoverCastedSymbol(ProgramStateRef state, const Stmt *Condition, const LocationContext *LCtx, ASTContext &Ctx)

RecoverCastedSymbol - A helper function for ProcessBranch that is used to try to recover some path-se...

static void printObjectsUnderConstructionJson(raw_ostream &Out, ProgramStateRef State, const char *NL, const LocationContext *LCtx, unsigned int Space=0, bool IsDot=false)

static void printIndicesOfElementsToConstructJson(raw_ostream &Out, ProgramStateRef State, const char *NL, const LocationContext *LCtx, unsigned int Space=0, bool IsDot=false)

static void printStateTraitWithLocationContextJson(raw_ostream &Out, ProgramStateRef State, const LocationContext *LCtx, const char *NL, unsigned int Space, bool IsDot, const char *jsonPropertyName, Printer printer, Args &&...args)

A helper function to generalize program state trait printing.

static void printPendingArrayDestructionsJson(raw_ostream &Out, ProgramStateRef State, const char *NL, const LocationContext *LCtx, unsigned int Space=0, bool IsDot=false)

static bool shouldRemoveDeadBindings(AnalysisManager &AMgr, const Stmt *S, const ExplodedNode *Pred, const LocationContext *LC)

static const Stmt * ResolveCondition(const Stmt *Condition, const CFGBlock *B)

REGISTER_TRAIT_WITH_PROGRAMSTATE(ObjectsUnderConstruction, ObjectsUnderConstructionMap) typedef llvm REGISTER_TRAIT_WITH_PROGRAMSTATE(IndexOfElementToConstruct, IndexOfElementToConstructMap) typedef llvm typedef llvm::ImmutableMap< const LocationContext *, unsigned > PendingArrayDestructionMap

static void printPendingInitLoopJson(raw_ostream &Out, ProgramStateRef State, const char *NL, const LocationContext *LCtx, unsigned int Space=0, bool IsDot=false)

llvm::ImmutableMap< ConstructedObjectKey, SVal > ObjectsUnderConstructionMap

static std::optional< std::pair< ProgramStateRef, ProgramStateRef > > assumeCondition(const Stmt *Condition, ExplodedNode *N)

Split the state on whether there are any more iterations left for this loop.

STATISTIC(NumRemoveDeadBindings, "The # of times RemoveDeadBindings is called")

Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.

Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.

Defines the clang::LangOptions interface.

This header contains the declarations of functions which are used to decide which loops should be com...

This header contains the declarations of functions which are used to widen loops which do not otherwi...

Defines the PrettyStackTraceEntry class, which is used to make crashes give more contextual informati...

#define REGISTER_MAP_WITH_PROGRAMSTATE(Name, Key, Value)

Declares an immutable map of type NameTy, suitable for placement into the ProgramState.

#define REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, Type)

Declares a program state trait for type Type called Name, and introduce a type named NameTy.

static bool isRecordType(QualType T)

Defines the clang::SourceLocation class and associated facilities.

Defines the SourceManager interface.

Defines various enumerations that describe declaration and type specifiers.

Defines the Objective-C statement AST node classes.

C Language Family Type Representation.

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

SourceManager & getSourceManager()

QualType getBaseElementType(const ArrayType *VAT) const

Return the innermost element type of an array type.

const clang::PrintingPolicy & getPrintingPolicy() const

const ArrayType * getAsArrayType(QualType T) const

Type Query functions.

uint64_t getTypeSize(QualType T) const

Return the size of the specified (complete) type T, in bits.

ParentMap & getParentMap()

ASTContext & getASTContext() const

Stores options for the analyzer from the command line.

unsigned NoRetryExhausted

Do not re-analyze paths leading to exhausted nodes with a different strategy.

unsigned maxBlockVisitOnPath

The maximum number of times the analyzer visits a block.

AnalysisPurgeMode AnalysisPurgeOpt

Represents a loop initializing the elements of an array.

OpaqueValueExpr * getCommonExpr() const

Get the common subexpression shared by all initializations (the source array).

Expr * getSubExpr() const

Get the initializer to use for each array element.

ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.

Represents an array type, per C99 6.7.5.2 - Array Declarators.

AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load,...

static unsigned getNumSubExprs(AtomicOp Op)

Determine the number of arguments the specified atomic builtin should have.

Represents C++ object destructor implicitly generated for automatic object or temporary bound to cons...

const VarDecl * getVarDecl() const

const Stmt * getTriggerStmt() const

Represents C++ object destructor implicitly generated for base object in destructor.

Represents a single basic block in a source-level CFG.

CFGTerminator getTerminator() const

Stmt * getTerminatorStmt()

Represents C++ object destructor generated from a call to delete.

const CXXDeleteExpr * getDeleteExpr() const

Represents a top-level expression in a basic block.

Represents C++ object destructor implicitly generated by compiler on various occasions.

const CXXDestructorDecl * getDestructorDecl(ASTContext &astContext) const

Represents C++ base or member initializer from constructor's initialization list.

CXXCtorInitializer * getInitializer() const

Represents the point where a loop ends.

const Stmt * getLoopStmt() const

Represents C++ object destructor implicitly generated for member object in destructor.

Represents C++ allocator call.

const CXXNewExpr * getAllocatorExpr() const

const Stmt * getStmt() const

Represents C++ object destructor implicitly generated at the end of full expression for temporary obj...

bool isStmtBranch() const

Represents a base class of a C++ class.

Represents binding an expression to a temporary.

Represents a call to a C++ constructor.

Represents a C++ base or member initializer.

FieldDecl * getMember() const

If this is a member initializer, returns the declaration of the non-static data member being initiali...

bool isDelegatingInitializer() const

Determine whether this initializer is creating a delegating constructor.

Expr * getInit() const

Get the initializer.

SourceLocation getSourceLocation() const

Determine the source location of the initializer.

bool isAnyMemberInitializer() const

bool isBaseInitializer() const

Determine whether this initializer is initializing a base class.

bool isIndirectMemberInitializer() const

int64_t getID(const ASTContext &Context) const

const Type * getBaseClass() const

If this is a base class initializer, returns the type of the base class.

FieldDecl * getAnyMember() const

IndirectFieldDecl * getIndirectMember() const

bool isBaseVirtual() const

Returns whether the base is virtual or not.

Represents a delete expression for memory deallocation and destructor calls, e.g.

SourceLocation getBeginLoc() const

QualType getDestroyedType() const

Retrieve the type being destroyed.

Represents a C++ destructor within a class.

Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".

Represents a C++ struct/union/class.

void getCaptureFields(llvm::DenseMap< const ValueDecl *, FieldDecl * > &Captures, FieldDecl *&ThisCapture) const

For a closure type, retrieve the mapping from captured variables and this to the non-static data memb...

CXXDestructorDecl * getDestructor() const

Returns the destructor decl for this class.

Represents a point when we begin processing an inlined call.

CaseStmt - Represent a case statement.

Represents a single point (AST node) in the program that requires attention during construction of an...

unsigned getIndex() const

If a single trigger statement triggers multiple constructors, they are usually being enumerated.

const CXXCtorInitializer * getCXXCtorInitializer() const

The construction site is not necessarily a statement.

@ TemporaryDestructorKind

const Stmt * getStmtOrNull() const

DeclContext * getParent()

getParent - Returns the containing DeclContext.

A reference to a declared variable, function, enum, etc.

DeclStmt - Adaptor class for mixing declarations with statements and expressions.

const Decl * getSingleDecl() const

Decl - This represents one declaration (or definition), e.g.

SourceLocation getBeginLoc() const LLVM_READONLY

A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.

This is a meta program point, which should be skipped by all the diagnostic reasoning etc.

This represents one expression.

const Expr * skipRValueSubobjectAdjustments(SmallVectorImpl< const Expr * > &CommaLHS, SmallVectorImpl< SubobjectAdjustment > &Adjustments) const

Walk outwards from an expression we want to bind a reference to and find the expression whose lifetim...

llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const

EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.

Expr * IgnoreParenImpCasts() LLVM_READONLY

Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...

Expr * IgnoreImplicit() LLVM_READONLY

Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.

Expr * IgnoreParens() LLVM_READONLY

Skip past any parentheses which might surround this expression until reaching a fixed point.

Represents a member of a struct/union/class.

This represents a GCC inline-assembly statement extension.

One of these records is kept for each identifier that is lexed.

StringRef getName() const

Return the actual identifier string.

Represents the declaration of a label.

It wraps the AnalysisDeclContext to represent both the call stack with the help of StackFrameContext ...

const Decl * getDecl() const

LLVM_ATTRIBUTE_RETURNS_NONNULL AnalysisDeclContext * getAnalysisDeclContext() const

const LocationContext * getParent() const

It might return null.

const StackFrameContext * getStackFrame() const

virtual bool inTopFrame() const

void printJson(raw_ostream &Out, const char *NL="\n", unsigned int Space=0, bool IsDot=false, std::function< void(const LocationContext *)> printMoreInfoPerContext=[](const LocationContext *) {}) const

Prints out the call stack in json format.

Represents a point when we exit a loop.

This represents a Microsoft inline-assembly statement extension.

MemberExpr - [C99 6.5.2.3] Structure and Union Members.

ValueDecl * getMemberDecl() const

Retrieve the member declaration to which this expression refers.

This represents a decl that may have a name.

DeclarationName getDeclName() const

Get the actual, stored name of the declaration, which may be a special name.

Represents Objective-C's collection statement.

Expr * getSourceExpr() const

The source expression of an opaque value expression is the expression which originally generated the ...

bool isConsumedExpr(Expr *E) const

Represents a parameter to a function.

Represents a program point just after an implicit call event.

Represents a program point after a store evaluation.

Represents a program point just before an implicit call event.

If a crash happens while one of these objects are live, the message is printed out along with the spe...

ProgramPoints can be "tagged" as representing points specific to a given analysis entity.

const ProgramPointTag * getTag() const

bool isPurgeKind()

Is this a program point corresponding to purge/removal of dead symbols and bindings.

void printJson(llvm::raw_ostream &Out, const char *NL="\n") const

@ PreStmtPurgeDeadSymbolsKind

@ PostStmtPurgeDeadSymbolsKind

const StackFrameContext * getStackFrame() const

std::optional< T > getAs() const

Convert to the specified ProgramPoint type, returning std::nullopt if this ProgramPoint is not of the...

const LocationContext * getLocationContext() const

A (possibly-)qualified type.

QualType getDesugaredType(const ASTContext &Context) const

Return the specified type with any "sugar" removed from the type.

bool isNull() const

Return true if this QualType doesn't point to a type yet.

SplitQualType split() const

Divides a QualType into its unqualified type and a set of local qualifiers.

bool isCForbiddenLValueType() const

Determine whether expressions of the given type are forbidden from being lvalues in C.

std::string getAsString() const

ReturnStmt - This represents a return, optionally of an expression: return; return 4;.

std::string printToString(const SourceManager &SM) const

It represents a stack frame of the call stack (based on CallEvent).

unsigned getIndex() const

const Stmt * getCallSite() const

const CFGBlock * getCallSiteBlock() const

bool inTopFrame() const override

const Stmt * getStmt() const

Stmt - This represents one statement.

SourceRange getSourceRange() const LLVM_READONLY

SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...

const char * getStmtClassName() const

int64_t getID(const ASTContext &Context) const

SourceLocation getBeginLoc() const LLVM_READONLY

SwitchStmt - This represents a 'switch' stmt.

bool isAllEnumCasesCovered() const

Returns true if the SwitchStmt is a switch of an enum value and all cases have been explicitly covere...

CXXRecordDecl * getAsCXXRecordDecl() const

Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...

bool isReferenceType() const

bool isIntegralOrEnumerationType() const

Determine whether this type is an integral or enumeration type.

bool isVectorType() const

const T * getAs() const

Member-template getAs<specific type>'.

Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...

Represents a variable declaration or definition.

This class is used for tools that requires cross translation unit capability.

const LangOptions & getLangOpts() const

ASTContext & getASTContext() override

AnalyzerOptions & options

BranchNodeBuilder is responsible for constructing the nodes corresponding to the two branches of the ...

ExplodedNode * generateNode(ProgramStateRef State, bool branch, ExplodedNode *Pred)

BugReporter is a utility class for generating PathDiagnostics for analysis.

llvm::iterator_range< EQClasses_iterator > equivalenceClasses()

Represents an abstract call to a function or method along a particular path.

static bool isCallStmt(const Stmt *S)

Returns true if this is a statement is a function or method call of some kind.

void runCheckersForBind(ExplodedNodeSet &Dst, const ExplodedNodeSet &Src, SVal location, SVal val, const Stmt *S, ExprEngine &Eng, const ProgramPoint &PP)

Run checkers for binding of a value to a location.

void runCheckersForEndFunction(NodeBuilderContext &BC, ExplodedNodeSet &Dst, ExplodedNode *Pred, ExprEngine &Eng, const ReturnStmt *RS)

Run checkers on end of function.

void runCheckersForLocation(ExplodedNodeSet &Dst, const ExplodedNodeSet &Src, SVal location, bool isLoad, const Stmt *NodeEx, const Stmt *BoundEx, ExprEngine &Eng)

Run checkers for load/store of a location.

void runCheckersForEndAnalysis(ExplodedGraph &G, BugReporter &BR, ExprEngine &Eng)

Run checkers for end of analysis.

void runCheckersForPrintStateJson(raw_ostream &Out, ProgramStateRef State, const char *NL="\n", unsigned int Space=0, bool IsDot=false) const

Run checkers for debug-printing a ProgramState.

void runCheckersForDeadSymbols(ExplodedNodeSet &Dst, const ExplodedNodeSet &Src, SymbolReaper &SymReaper, const Stmt *S, ExprEngine &Eng, ProgramPoint::Kind K)

Run checkers for dead symbols.

ProgramStateRef runCheckersForRegionChanges(ProgramStateRef state, const InvalidatedSymbols *invalidated, ArrayRef< const MemRegion * > ExplicitRegions, ArrayRef< const MemRegion * > Regions, const LocationContext *LCtx, const CallEvent *Call)

Run checkers for region changes.

void runCheckersForLiveSymbols(ProgramStateRef state, SymbolReaper &SymReaper)

Run checkers for live symbols.

void runCheckersForBeginFunction(ExplodedNodeSet &Dst, const BlockEdge &L, ExplodedNode *Pred, ExprEngine &Eng)

Run checkers on beginning of function.

void runCheckersForPostStmt(ExplodedNodeSet &Dst, const ExplodedNodeSet &Src, const Stmt *S, ExprEngine &Eng, bool wasInlined=false)

Run checkers for post-visiting Stmts.

void runCheckersForPreStmt(ExplodedNodeSet &Dst, const ExplodedNodeSet &Src, const Stmt *S, ExprEngine &Eng)

Run checkers for pre-visiting Stmts.

void runCheckersForBranchCondition(const Stmt *condition, ExplodedNodeSet &Dst, ExplodedNode *Pred, ExprEngine &Eng)

Run checkers for branch condition.

ProgramStateRef runCheckersForPointerEscape(ProgramStateRef State, const InvalidatedSymbols &Escaped, const CallEvent *Call, PointerEscapeKind Kind, RegionAndSymbolInvalidationTraits *ITraits)

Run checkers when pointers escape.

ProgramStateRef runCheckersForEvalAssume(ProgramStateRef state, SVal Cond, bool Assumption)

Run checkers for handling assumptions on symbolic values.

virtual ProgramStateRef removeDeadBindings(ProgramStateRef state, SymbolReaper &SymReaper)=0

Scan all symbols referenced by the constraints.

void addAbortedBlock(const ExplodedNode *node, const CFGBlock *block)

Inform the CoreEngine that a basic block was aborted because it could not be completely analyzed.

void enqueueStmtNode(ExplodedNode *N, const CFGBlock *Block, unsigned Idx)

Enqueue a single node created as a result of statement processing.

void enqueueEndOfFunction(ExplodedNodeSet &Set, const ReturnStmt *RS)

enqueue the nodes corresponding to the end of function onto the end of path / work list.

void enqueue(ExplodedNodeSet &Set)

Enqueue the given set of nodes onto the work list.

std::unique_ptr< ExplodedGraph > trim(ArrayRef< const NodeTy * > Nodes, InterExplodedGraphMap *ForwardMap=nullptr, InterExplodedGraphMap *InverseMap=nullptr) const

Creates a trimmed version of the graph that only contains paths leading to the given nodes.

void enableNodeReclamation(unsigned Interval)

Enable tracking of recently allocated nodes for potential reclamation when calling reclaimRecentlyAll...

void reclaimRecentlyAllocatedNodes()

Reclaim "uninteresting" nodes created since the last time this method was called.

ExplodedNode * getNode(const ProgramPoint &L, ProgramStateRef State, bool IsSink=false, bool *IsNew=nullptr)

Retrieve the node associated with a (Location,State) pair, where the 'Location' is a ProgramPoint in ...

roots_iterator roots_begin()

void insert(const ExplodedNodeSet &S)

void Add(ExplodedNode *N)

const ProgramStateRef & getState() const

pred_iterator pred_begin()

bool isTrivial() const

The node is trivial if it has only one successor, only one predecessor, it's predecessor has only one...

ProgramPoint getLocation() const

getLocation - Returns the edge associated with the given node.

void addPredecessor(ExplodedNode *V, ExplodedGraph &G)

addPredeccessor - Adds a predecessor to the current node, and in tandem add this node as a successor ...

ExplodedNode * getFirstSucc()

const StackFrameContext * getStackFrame() const

const LocationContext * getLocationContext() const

unsigned succ_size() const

void processEndOfFunction(NodeBuilderContext &BC, ExplodedNode *Pred, const ReturnStmt *RS=nullptr)

Called by CoreEngine.

void VisitBinaryOperator(const BinaryOperator *B, ExplodedNode *Pred, ExplodedNodeSet &Dst)

VisitBinaryOperator - Transfer function logic for binary operators.

ProgramStateManager & getStateManager()

void VisitArraySubscriptExpr(const ArraySubscriptExpr *Ex, ExplodedNode *Pred, ExplodedNodeSet &Dst)

VisitArraySubscriptExpr - Transfer function for array accesses.

void VisitCommonDeclRefExpr(const Expr *DR, const NamedDecl *D, ExplodedNode *Pred, ExplodedNodeSet &Dst)

Transfer function logic for DeclRefExprs and BlockDeclRefExprs.

void ProcessInitializer(const CFGInitializer I, ExplodedNode *Pred)

void VisitObjCMessage(const ObjCMessageExpr *ME, ExplodedNode *Pred, ExplodedNodeSet &Dst)

void ProcessTemporaryDtor(const CFGTemporaryDtor D, ExplodedNode *Pred, ExplodedNodeSet &Dst)

void VisitGuardedExpr(const Expr *Ex, const Expr *L, const Expr *R, ExplodedNode *Pred, ExplodedNodeSet &Dst)

VisitGuardedExpr - Transfer function logic for ?, __builtin_choose.

void processBeginOfFunction(NodeBuilderContext &BC, ExplodedNode *Pred, ExplodedNodeSet &Dst, const BlockEdge &L)

Called by CoreEngine.

void VisitCast(const CastExpr *CastE, const Expr *Ex, ExplodedNode *Pred, ExplodedNodeSet &Dst)

VisitCast - Transfer function logic for all casts (implicit and explicit).

void removeDead(ExplodedNode *Node, ExplodedNodeSet &Out, const Stmt *ReferenceStmt, const LocationContext *LC, const Stmt *DiagnosticStmt=nullptr, ProgramPoint::Kind K=ProgramPoint::PreStmtPurgeDeadSymbolsKind)

Run the analyzer's garbage collection - remove dead symbols and bindings from the state.

void VisitLogicalExpr(const BinaryOperator *B, ExplodedNode *Pred, ExplodedNodeSet &Dst)

VisitLogicalExpr - Transfer function logic for '&&', '||'.

void VisitCXXDestructor(QualType ObjectType, const MemRegion *Dest, const Stmt *S, bool IsBaseDtor, ExplodedNode *Pred, ExplodedNodeSet &Dst, EvalCallOptions &Options)

void evalEagerlyAssumeBifurcation(ExplodedNodeSet &Dst, ExplodedNodeSet &Src, const Expr *Ex)

evalEagerlyAssumeBifurcation - Given the nodes in 'Src', eagerly assume concrete boolean values for '...

void VisitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt *S, ExplodedNode *Pred, ExplodedNodeSet &Dst)

Transfer function logic for ObjCAtSynchronizedStmts.

void VisitReturnStmt(const ReturnStmt *R, ExplodedNode *Pred, ExplodedNodeSet &Dst)

VisitReturnStmt - Transfer function logic for return statements.

SVal evalBinOp(ProgramStateRef ST, BinaryOperator::Opcode Op, SVal LHS, SVal RHS, QualType T)

void VisitCXXNewExpr(const CXXNewExpr *CNE, ExplodedNode *Pred, ExplodedNodeSet &Dst)

ProgramStateRef processRegionChange(ProgramStateRef state, const MemRegion *MR, const LocationContext *LCtx)

void VisitLambdaExpr(const LambdaExpr *LE, ExplodedNode *Pred, ExplodedNodeSet &Dst)

VisitLambdaExpr - Transfer function logic for LambdaExprs.

void ProcessImplicitDtor(const CFGImplicitDtor D, ExplodedNode *Pred)

void VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S, ExplodedNode *Pred, ExplodedNodeSet &Dst)

VisitObjCForCollectionStmt - Transfer function logic for ObjCForCollectionStmt.

void VisitUnaryOperator(const UnaryOperator *B, ExplodedNode *Pred, ExplodedNodeSet &Dst)

VisitUnaryOperator - Transfer function logic for unary operators.

ProgramStateRef getInitialState(const LocationContext *InitLoc)

getInitialState - Return the initial state used for the root vertex in the ExplodedGraph.

void VisitLvalObjCIvarRefExpr(const ObjCIvarRefExpr *DR, ExplodedNode *Pred, ExplodedNodeSet &Dst)

Transfer function logic for computing the lvalue of an Objective-C ivar.

static bool hasMoreIteration(ProgramStateRef State, const ObjCForCollectionStmt *O, const LocationContext *LC)

void VisitDeclStmt(const DeclStmt *DS, ExplodedNode *Pred, ExplodedNodeSet &Dst)

VisitDeclStmt - Transfer function logic for DeclStmts.

void VisitMSAsmStmt(const MSAsmStmt *A, ExplodedNode *Pred, ExplodedNodeSet &Dst)

VisitMSAsmStmt - Transfer function logic for MS inline asm.

static std::optional< SVal > getObjectUnderConstruction(ProgramStateRef State, const ConstructionContextItem &Item, const LocationContext *LC)

By looking at a certain item that may be potentially part of an object's ConstructionContext,...

std::string DumpGraph(bool trim=false, StringRef Filename="")

Dump graph to the specified filename.

void printJson(raw_ostream &Out, ProgramStateRef State, const LocationContext *LCtx, const char *NL, unsigned int Space, bool IsDot) const

printJson - Called by ProgramStateManager to print checker-specific data.

InliningModes

The modes of inlining, which override the default analysis-wide settings.

ProgramStateRef processPointerEscapedOnBind(ProgramStateRef State, ArrayRef< std::pair< SVal, SVal > > LocAndVals, const LocationContext *LCtx, PointerEscapeKind Kind, const CallEvent *Call)

Call PointerEscape callback when a value escapes as a result of bind.

const LocationContext * getRootLocationContext() const

static ProgramStateRef removeIterationState(ProgramStateRef State, const ObjCForCollectionStmt *O, const LocationContext *LC)

ProgramStateRef processAssume(ProgramStateRef state, SVal cond, bool assumption)

evalAssume - Callback function invoked by the ConstraintManager when making assumptions about state v...

static std::optional< unsigned > getIndexOfElementToConstruct(ProgramStateRef State, const CXXConstructExpr *E, const LocationContext *LCtx)

Retreives which element is being constructed in a non-POD type array.

void VisitBlockExpr(const BlockExpr *BE, ExplodedNode *Pred, ExplodedNodeSet &Dst)

VisitBlockExpr - Transfer function logic for BlockExprs.

void ProcessBaseDtor(const CFGBaseDtor D, ExplodedNode *Pred, ExplodedNodeSet &Dst)

static std::pair< const ProgramPointTag *, const ProgramPointTag * > getEagerlyAssumeBifurcationTags()

void VisitCallExpr(const CallExpr *CE, ExplodedNode *Pred, ExplodedNodeSet &Dst)

VisitCall - Transfer function for function calls.

ASTContext & getContext() const

getContext - Return the ASTContext associated with this analysis.

StoreManager & getStoreManager()

void VisitCXXNewAllocatorCall(const CXXNewExpr *CNE, ExplodedNode *Pred, ExplodedNodeSet &Dst)

void CreateCXXTemporaryObject(const MaterializeTemporaryExpr *ME, ExplodedNode *Pred, ExplodedNodeSet &Dst)

Create a C++ temporary object for an rvalue.

CFGBlock::ConstCFGElementRef getCFGElementRef() const

void VisitGCCAsmStmt(const GCCAsmStmt *A, ExplodedNode *Pred, ExplodedNodeSet &Dst)

VisitGCCAsmStmt - Transfer function logic for inline asm.

void processCFGBlockEntrance(const BlockEdge &L, NodeBuilderWithSinks &nodeBuilder, ExplodedNode *Pred)

Called by CoreEngine when processing the entrance of a CFGBlock.

void VisitInitListExpr(const InitListExpr *E, ExplodedNode *Pred, ExplodedNodeSet &Dst)

ProgramStateRef processRegionChanges(ProgramStateRef state, const InvalidatedSymbols *invalidated, ArrayRef< const MemRegion * > ExplicitRegions, ArrayRef< const MemRegion * > Regions, const LocationContext *LCtx, const CallEvent *Call)

processRegionChanges - Called by ProgramStateManager whenever a change is made to the store.

void ProcessStmt(const Stmt *S, ExplodedNode *Pred)

ExprEngine(cross_tu::CrossTranslationUnitContext &CTU, AnalysisManager &mgr, SetOfConstDecls *VisitedCalleesIn, FunctionSummariesTy *FS, InliningModes HowToInlineIn)

void ViewGraph(bool trim=false)

Visualize the ExplodedGraph created by executing the simulation.

static std::optional< unsigned > getPendingArrayDestruction(ProgramStateRef State, const LocationContext *LCtx)

Retreives which element is being destructed in a non-POD type array.

ProgramStateRef notifyCheckersOfPointerEscape(ProgramStateRef State, const InvalidatedSymbols *Invalidated, ArrayRef< const MemRegion * > ExplicitRegions, const CallEvent *Call, RegionAndSymbolInvalidationTraits &ITraits)

Call PointerEscape callback when a value escapes as a result of region invalidation.

static const ProgramPointTag * cleanupNodeTag()

A tag to track convenience transitions, which can be removed at cleanup.

void processCFGElement(const CFGElement E, ExplodedNode *Pred, unsigned StmtIdx, NodeBuilderContext *Ctx)

processCFGElement - Called by CoreEngine.

void processStaticInitializer(const DeclStmt *DS, NodeBuilderContext &BuilderCtx, ExplodedNode *Pred, ExplodedNodeSet &Dst, const CFGBlock *DstT, const CFGBlock *DstF)

Called by CoreEngine.

void VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *Ex, ExplodedNode *Pred, ExplodedNodeSet &Dst)

VisitUnaryExprOrTypeTraitExpr - Transfer function for sizeof.

void processBranch(const Stmt *Condition, NodeBuilderContext &BuilderCtx, ExplodedNode *Pred, ExplodedNodeSet &Dst, const CFGBlock *DstT, const CFGBlock *DstF, std::optional< unsigned > IterationsCompletedInLoop)

ProcessBranch - Called by CoreEngine.

void ProcessLoopExit(const Stmt *S, ExplodedNode *Pred)

void processSwitch(SwitchNodeBuilder &builder)

ProcessSwitch - Called by CoreEngine.

void processEndWorklist()

Called by CoreEngine when the analysis worklist has terminated.

CheckerManager & getCheckerManager() const

void VisitAtomicExpr(const AtomicExpr *E, ExplodedNode *Pred, ExplodedNodeSet &Dst)

VisitAtomicExpr - Transfer function for builtin atomic expressions.

void ProcessMemberDtor(const CFGMemberDtor D, ExplodedNode *Pred, ExplodedNodeSet &Dst)

void VisitCXXThisExpr(const CXXThisExpr *TE, ExplodedNode *Pred, ExplodedNodeSet &Dst)

void VisitCXXDeleteExpr(const CXXDeleteExpr *CDE, ExplodedNode *Pred, ExplodedNodeSet &Dst)

void VisitMemberExpr(const MemberExpr *M, ExplodedNode *Pred, ExplodedNodeSet &Dst)

VisitMemberExpr - Transfer function for member expressions.

void VisitCXXConstructExpr(const CXXConstructExpr *E, ExplodedNode *Pred, ExplodedNodeSet &Dst)

void VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E, ExplodedNode *Pred, ExplodedNodeSet &Dst)

bool didEagerlyAssumeBifurcateAt(ProgramStateRef State, const Expr *Ex) const

ConstraintManager & getConstraintManager()

void processCleanupTemporaryBranch(const CXXBindTemporaryExpr *BTE, NodeBuilderContext &BldCtx, ExplodedNode *Pred, ExplodedNodeSet &Dst, const CFGBlock *DstT, const CFGBlock *DstF)

Called by CoreEngine.

void ProcessAutomaticObjDtor(const CFGAutomaticObjDtor D, ExplodedNode *Pred, ExplodedNodeSet &Dst)

void VisitOffsetOfExpr(const OffsetOfExpr *Ex, ExplodedNode *Pred, ExplodedNodeSet &Dst)

VisitOffsetOfExpr - Transfer function for offsetof.

void evalLoad(ExplodedNodeSet &Dst, const Expr *NodeEx, const Expr *BoundExpr, ExplodedNode *Pred, ProgramStateRef St, SVal location, const ProgramPointTag *tag=nullptr, QualType LoadTy=QualType())

Simulate a read of the result of Ex.

void removeDeadOnEndOfFunction(NodeBuilderContext &BC, ExplodedNode *Pred, ExplodedNodeSet &Dst)

Remove dead bindings/symbols before exiting a function.

void Visit(const Stmt *S, ExplodedNode *Pred, ExplodedNodeSet &Dst)

Visit - Transfer function logic for all statements.

AnalysisManager & getAnalysisManager()

void ProcessDeleteDtor(const CFGDeleteDtor D, ExplodedNode *Pred, ExplodedNodeSet &Dst)

void VisitCXXCatchStmt(const CXXCatchStmt *CS, ExplodedNode *Pred, ExplodedNodeSet &Dst)

void VisitCompoundLiteralExpr(const CompoundLiteralExpr *CL, ExplodedNode *Pred, ExplodedNodeSet &Dst)

VisitCompoundLiteralExpr - Transfer function logic for compound literals.

SValBuilder & getSValBuilder()

void VisitArrayInitLoopExpr(const ArrayInitLoopExpr *Ex, ExplodedNode *Pred, ExplodedNodeSet &Dst)

VisitArrayInitLoopExpr - Transfer function for array init loop.

void evalStore(ExplodedNodeSet &Dst, const Expr *AssignE, const Expr *StoreE, ExplodedNode *Pred, ProgramStateRef St, SVal TargetLV, SVal Val, const ProgramPointTag *tag=nullptr)

evalStore - Handle the semantics of a store via an assignment.

void VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *BTE, ExplodedNodeSet &PreVisit, ExplodedNodeSet &Dst)

void processIndirectGoto(IndirectGotoNodeBuilder &builder)

processIndirectGoto - Called by CoreEngine.

const NodeBuilderContext & getBuilderContext()

static std::optional< unsigned > getPendingInitLoop(ProgramStateRef State, const CXXConstructExpr *E, const LocationContext *LCtx)

Retreives the size of the array in the pending ArrayInitLoopExpr.

void ProcessNewAllocator(const CXXNewExpr *NE, ExplodedNode *Pred)

void markReachedMaxBlockCount(const Decl *D)

const Expr * getTarget() const

const LocationContext * getLocationContext() const

ProgramStateRef getState() const

ExplodedNode * generateNode(const iterator &I, ProgramStateRef State, bool isSink=false)

static bool isLocType(QualType T)

const CXXLifetimeExtendedObjectRegion * getCXXLifetimeExtendedObjectRegion(Expr const *Ex, ValueDecl const *VD, LocationContext const *LC)

Create a CXXLifetimeExtendedObjectRegion for temporaries which are lifetime-extended by local referen...

const CXXTempObjectRegion * getCXXTempObjectRegion(Expr const *Ex, LocationContext const *LC)

const CXXLifetimeExtendedObjectRegion * getCXXStaticLifetimeExtendedObjectRegion(const Expr *Ex, ValueDecl const *VD)

Create a CXXLifetimeExtendedObjectRegion for temporaries which are lifetime-extended by static refere...

MemRegion - The root abstract class for all memory regions.

LLVM_ATTRIBUTE_RETURNS_NONNULL const MemSpaceRegion * getMemorySpace() const

LLVM_ATTRIBUTE_RETURNS_NONNULL const MemRegion * getBaseRegion() const

const CFGBlock * getBlock() const

Return the CFGBlock associated with this builder.

unsigned blockCount() const

Returns the number of times the current basic block has been visited on the exploded graph path.

This node builder keeps track of the generated sink nodes.

ExplodedNode * generateNode(ProgramStateRef State, ExplodedNode *Pred, const ProgramPointTag *Tag=nullptr)

ExplodedNode * generateSink(ProgramStateRef State, ExplodedNode *Pred, const ProgramPointTag *Tag=nullptr)

This is the simplest builder which generates nodes in the ExplodedGraph.

ExplodedNode * generateNode(const ProgramPoint &PP, ProgramStateRef State, ExplodedNode *Pred)

Generates a node in the ExplodedGraph.

void takeNodes(const ExplodedNodeSet &S)

ExplodedNode * generateSink(const ProgramPoint &PP, ProgramStateRef State, ExplodedNode *Pred)

Generates a sink in the ExplodedGraph.

void addNodes(const ExplodedNodeSet &S)

const NodeBuilderContext & getContext()

While alive, includes the current analysis stack in a crash trace.

ProgramStateRef removeDeadBindingsFromEnvironmentAndStore(ProgramStateRef St, const StackFrameContext *LCtx, SymbolReaper &SymReaper)

bool haveEqualStores(ProgramStateRef S1, ProgramStateRef S2) const

bool haveEqualEnvironments(ProgramStateRef S1, ProgramStateRef S2) const

ProgramStateRef getPersistentStateWithGDM(ProgramStateRef FromState, ProgramStateRef GDMState)

MemRegionManager & getRegionManager()

ProgramStateRef getInitialState(const LocationContext *InitLoc)

StoreManager & getStoreManager()

Information about invalidation for a particular region/symbol.

DefinedOrUnknownSVal makeZeroVal(QualType type)

Construct an SVal representing '0' for the specified type.

DefinedSVal getFunctionPointer(const FunctionDecl *func)

NonLoc makeIntValWithWidth(QualType ptrType, uint64_t integer)

NonLoc makeArrayIndex(uint64_t idx)

nonloc::ConcreteInt makeIntVal(const IntegerLiteral *integer)

DefinedOrUnknownSVal conjureSymbolVal(const void *symbolTag, const Expr *expr, const LocationContext *LCtx, unsigned count)

Create a new symbol with a unique 'name'.

QualType getConditionType() const

loc::MemRegionVal getCXXThis(const CXXMethodDecl *D, const StackFrameContext *SFC)

Return a memory region for the 'this' object reference.

std::optional< SVal > getConstantVal(const Expr *E)

Returns the value of E, if it can be determined in a non-path-sensitive manner.

SVal - This represents a symbolic expression, which can be either an L-value or an R-value.

bool isUnknownOrUndef() const

std::optional< T > getAs() const

Convert to the specified SVal type, returning std::nullopt if this SVal is not of the desired type.

const llvm::APSInt * getAsInteger() const

If this SVal is loc::ConcreteInt or nonloc::ConcreteInt, return a pointer to APSInt which is held in ...

const MemRegion * getAsRegion() const

T castAs() const

Convert to the specified SVal type, asserting that this SVal is of the desired type.

This builder class is useful for generating nodes that resulted from visiting a statement.

ExplodedNode * generateNode(const Stmt *S, ExplodedNode *Pred, ProgramStateRef St, const ProgramPointTag *tag=nullptr, ProgramPoint::Kind K=ProgramPoint::PostStmtKind)

ExplodedNode * generateSink(const Stmt *S, ExplodedNode *Pred, ProgramStateRef St, const ProgramPointTag *tag=nullptr, ProgramPoint::Kind K=ProgramPoint::PostStmtKind)

SVal evalDerivedToBase(SVal Derived, const CastExpr *Cast)

Evaluates a chain of derived-to-base casts through the path specified in Cast.

virtual SVal getLValueField(const FieldDecl *D, SVal Base)

SubRegion - A region that subsets another larger region.

ProgramStateRef getState() const

const Expr * getCondition() const

ExplodedNode * generateDefaultCaseNode(ProgramStateRef State, bool isSink=false)

ExplodedNode * generateCaseStmtNode(const iterator &I, ProgramStateRef State)

const LocationContext * getLocationContext() const

const SwitchStmt * getSwitch() const

A class responsible for cleaning up unused symbols.

void markLive(SymbolRef sym)

Unconditionally marks a symbol as live.

SymbolicRegion - A special, "non-concrete" region.

TypedValueRegion - An abstract class representing regions having a typed value.

Represents symbolic expression that isn't a location.

const internal::VariadicDynCastAllOfMatcher< Decl, VarDecl > varDecl

Matches variable declarations.

const internal::VariadicAllOfMatcher< Decl > decl

Matches declarations.

llvm::DenseSet< const Decl * > SetOfConstDecls

PointerEscapeKind

Describes the different reasons a pointer escapes during analysis.

@ PSK_DirectEscapeOnCall

The pointer has been passed to a function call directly.

@ PSK_EscapeOnBind

A pointer escapes due to binding its value to a location that the analyzer cannot track.

@ PSK_IndirectEscapeOnCall

The pointer has been passed to a function indirectly.

@ PSK_EscapeOther

The reason for pointer escape is unknown.

DefinedOrUnknownSVal getDynamicElementCount(ProgramStateRef State, const MemRegion *MR, SValBuilder &SVB, QualType Ty)

IntrusiveRefCntPtr< const ProgramState > ProgramStateRef

ProgramStateRef processLoopEnd(const Stmt *LoopStmt, ProgramStateRef State)

Updates the given ProgramState.

ProgramStateRef getWidenedLoopState(ProgramStateRef PrevState, const LocationContext *LCtx, unsigned BlockCount, const Stmt *LoopStmt)

Get the states that result from widening the loop.

llvm::DenseSet< SymbolRef > InvalidatedSymbols

bool isUnrolledState(ProgramStateRef State)

Returns if the given State indicates that is inside a completely unrolled loop.

ProgramStateRef updateLoopStack(const Stmt *LoopStmt, ASTContext &ASTCtx, ExplodedNode *Pred, unsigned maxVisitOnPath)

Updates the stack of loops contained by the ProgramState.

bool LE(InterpState &S, CodePtr OpPC)

The JSON file list parser is used to communicate input to InstallAPI.

bool operator==(const CallGraphNode::CallRecord &LHS, const CallGraphNode::CallRecord &RHS)

bool operator<(DeclarationName LHS, DeclarationName RHS)

Ordering on two declaration names.

StorageDuration

The storage duration for an object (per C++ [basic.stc]).

@ SD_Thread

Thread storage duration.

@ SD_Static

Static storage duration.

@ SD_FullExpression

Full-expression storage duration (for temporaries).

@ Result

The result type of a method or function.

const FunctionProtoType * T

@ Class

The "class" keyword introduces the elaborated-type-specifier.

Expr * extractElementInitializerFromNestedAILE(const ArrayInitLoopExpr *AILE)

@ CXXThis

Parameter for C++ 'this' argument.

Diagnostic wrappers for TextAPI types for error reporting.

Describes how types, statements, expressions, and declarations should be printed.

An adjustment to be made to the temporary created when emitting a reference binding,...

@ DerivedToBaseAdjustment

@ MemberPointerAdjustment

Hints for figuring out of a call should be inlined during evalCall().

bool IsTemporaryCtorOrDtor

This call is a constructor or a destructor of a temporary value.

bool IsArrayCtorOrDtor

This call is a constructor or a destructor for a single element within an array, a part of array cons...

Traits for storing the call processing policy inside GDM.

DOTGraphTraits(bool isSimple=false)

static std::string getNodeLabel(const ExplodedNode *N, ExplodedGraph *G)

static bool nodeHasBugReport(const ExplodedNode *N)

static bool traverseHiddenNodes(const ExplodedNode *N, llvm::function_ref< void(const ExplodedNode *)> PreCallback, llvm::function_ref< void(const ExplodedNode *)> PostCallback, llvm::function_ref< bool(const ExplodedNode *)> Stop)

PreCallback: callback before break.

static bool isNodeHidden(const ExplodedNode *N, const ExplodedGraph *G)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4