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

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

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

;

state = createTemporaryRegionIfNeeded(state, LCtx, tempExpr, ME);

AlwaysReturnsLValue;

assert(Ctor->getDecl()->isTrivial());

assert(Ctor->getDecl()->isCopyOrMoveConstructor());

ThisVal = Ctor->getCXXThisVal();

AlwaysReturnsLValue =

;

assert(cast<CXXMethodDecl>(

.getDecl())->isTrivial());

assert(cast<CXXMethodDecl>(

.getDecl())->getOverloadedOperator() ==

ThisVal = cast<CXXInstanceCall>(

).getCXXThisVal();

ThisRD = cast<CXXMethodDecl>(

.getDecl())->

();

AlwaysReturnsLValue =

;

(std::optional<Loc> L =

.getAs<

>())

assert(

.isUnknownOrUndef());

evalBind(Dst,

, Pred, ThisVal,

,

);

(AlwaysReturnsLValue)

State = State->BindExpr(

, LCtx, ThisVal);

&Ty,

&IsArray,

Idx) {

&SVB = State->getStateManager().getSValBuilder();

Ty = AT->getElementType();

AT = dyn_cast<ArrayType>(AT->getElementType());

*DSCC = cast<VariableConstructionContext>(CC);

*DS = DSCC->getDeclStmt();

*Var = cast<VarDecl>(DS->getSingleDecl());

makeElementRegion(State, State->getLValue(Var, LCtx), Ty,

*ICC = cast<ConstructorInitializerConstructionContext>(CC);

*

= ICC->getCXXCtorInitializer();

ThisVal = State->getSVal(ThisPtr);

(

->isBaseInitializer()) {

*ThisReg = cast<SubRegion>(ThisVal.

());

->getBaseClass()->getAsCXXRecordDecl();

*BaseReg =

->isBaseVirtual());

(

->isDelegatingInitializer())

(

->isIndirectMemberInitializer()) {

Field =

->getIndirectMember();

FieldVal = State->getLValue(

->getIndirectMember(), ThisVal);

Field =

->getMember();

FieldVal = State->getLValue(

->getMember(), ThisVal);

*NECC = cast<NewAllocatedObjectConstructionContext>(CC);

*NE = NECC->getCXXNewExpr();

dyn_cast_or_null<SubRegion>(

.getAsRegion())) {

Ty = NE->getType()->getPointeeType();

(

*AT =

().getAsArrayType(Ty))

Ty = AT->getElementType();

(isa<BlockInvocationContext>(CallerLCtx)) {

CallerLCtx = CallerLCtx->getParent();

assert(!isa<BlockInvocationContext>(CallerLCtx));

cast<Expr>(SFC->

()), State, &CallerBldrCtx, CallerLCtx,

RTC->getConstructionContext(), CallOpts);

*RCC = cast<ReturnedValueConstructionContext>(CC);

TopLevelSymRegionTag = 0;

*RetE = RCC->getReturnStmt()->getRetValue();

assert(RetE &&

);

llvm_unreachable(

);

*TCC = cast<ElidedTemporaryObjectConstructionContext>(CC);

TCC->getConstructorAfterElision(), State, BldrCtx, LCtx,

TCC->getConstructionContextAfterElision(), CallOpts);

CallOpts = PreElideCallOpts;

*TCC = cast<TemporaryObjectConstructionContext>(CC);

(!VD->getType()->isReferenceType()) {

*LCC = cast<LambdaCaptureConstructionContext>(CC);

*CE = dyn_cast_or_null<CXXConstructExpr>(

);

*ACC = cast<ArgumentConstructionContext>(CC);

*

= ACC->getCallLikeExpr();

Idx = ACC->getIndex();

getArgLoc = [&](

Caller) -> std::optional<SVal> {

Caller->getCalleeStackFrame(BldrCtx->

());

*Caller->getAdjustedParameterIndex(Idx), BldrCtx->

());

(

*CE = dyn_cast<CallExpr>(

)) {

(std::optional<SVal>

= getArgLoc(Caller))

}

(

*CCE = dyn_cast<CXXConstructExpr>(

)) {

(std::optional<SVal>

= getArgLoc(Caller))

}

(

*ME = dyn_cast<ObjCMessageExpr>(

)) {

(std::optional<SVal>

= getArgLoc(Caller))

assert(CC &&

);

*DSCC = cast<VariableConstructionContext>(CC);

addObjectUnderConstruction(State, DSCC->getDeclStmt(), LCtx,

);

*ICC = cast<ConstructorInitializerConstructionContext>(CC);

*

= ICC->getCXXCtorInitializer();

assert(

->isAnyMemberInitializer() &&

);

addObjectUnderConstruction(State,

, LCtx,

);

assert(RTC &&

);

(isa<BlockInvocationContext>(CallerLCtx)) {

assert(!isa<BlockInvocationContext>(CallerLCtx));

cast<Expr>(SFC->

()), State, CallerLCtx,

RTC->getConstructionContext(), CallOpts);

*TCC = cast<ElidedTemporaryObjectConstructionContext>(CC);

, TCC->getConstructorAfterElision(), State, LCtx,

TCC->getConstructionContextAfterElision(), CallOpts);

State = addObjectUnderConstruction(

State, TCC->getConstructorAfterElision(), LCtx,

);

(

*BTE = TCC->getCXXBindTemporaryExpr())

State = elideDestructor(State, BTE, LCtx);

(

*MTE = TCC->getMaterializedTemporaryExpr())

State = addObjectUnderConstruction(State, MTE, LCtx,

);

*TCC = cast<TemporaryObjectConstructionContext>(CC);

(

*BTE = TCC->getCXXBindTemporaryExpr())

State = addObjectUnderConstruction(State, BTE, LCtx,

);

(

*MTE = TCC->getMaterializedTemporaryExpr())

State = addObjectUnderConstruction(State, MTE, LCtx,

);

*LCC = cast<LambdaCaptureConstructionContext>(CC);

(

*EL = dyn_cast_or_null<ElementRegion>(

.getAsRegion()))

addObjectUnderConstruction(

State, {LCC->getLambdaExpr(), LCC->getIndex()}, LCtx,

);

*ACC = cast<ArgumentConstructionContext>(CC);

(

*BTE = ACC->getCXXBindTemporaryExpr())

State = addObjectUnderConstruction(State, BTE, LCtx,

);

addObjectUnderConstruction(

State, {ACC->getCallLikeExpr(), ACC->getIndex()}, LCtx,

);

llvm_unreachable(

);

&SVB = State->getStateManager().getSValBuilder();

*SourceArrayRegion =

cast<SubRegion>(State->getSVal(SourceArray, LCtx).getAsRegion());

State->BindExpr(Ctor->getArg(0), LCtx,

ExprEngine::handleConstructor(

*

,

*CE = dyn_cast<CXXConstructExpr>(

);

*CIE = dyn_cast<CXXInheritedCtorInitExpr>(

);

(std::optional<SVal> ElidedTarget =

State = finishObjectConstruction(State, CE, LCtx);

State = State->BindExpr(CE, LCtx, State->getSVal(*L, CE->getType()));

CE ? CE->getConstructionKind() : CIE->getConstructionKind();

assert(CE && !CIE &&

);

(CE->getType()->isArrayType() || AILE) {

isZeroSizeArray = [&] {

(

*CAT = dyn_cast<ConstantArrayType>(CE->getType()))

(isZeroSizeArray()) {

};

State = setIndexOfElementToConstruct(State, CE, LCtx, Idx + 1);

State = setPendingInitLoop(

().getArrayInitLoopExprElementCount(AILE));

CE, State, currBldrCtx, LCtx, CC, CallOpts, Idx);

*OuterCtor = dyn_cast_or_null<CXXConstructExpr>(

(

));

ThisVal = State->getSVal(ThisPtr);

);

assert(DstPrepare.

() <= 1);

(DstPrepare.

() == 0)

Pred = *BldrPrepare.begin();

(CE->requiresZeroInitialization()) {

State = State->bindDefaultZero(

, LCtx);

PreInitialized = DstPreVisit;

(CE && CE->getConstructor()->isTrivial() &&

CE->getConstructor()->isCopyOrMoveConstructor() &&

performTrivialCopy(Bldr, N, *

);

Bldr(DstEvaluated, DstEvaluatedPostProcessed, *currBldrCtx);

cast<CXXConstructorDecl>(

->getDecl())

->isAnyDestructorNoReturn()) {

assert(!DstEvaluated.

() &&

);

finishArgumentConstruction(DstPostArgumentCleanup, I, *

);

DstPostArgumentCleanup,

handleConstructor(CE, Pred, Dst);

handleConstructor(CE, Pred, Dst);

assert(S &&

);

assert(

&&

);

(

*

= dyn_cast_or_null<Expr>(S)) {

->getSourceRange().getBegin(),

);

);

RetVal = State->getSVal(CNE, LCtx);

State = State->bindDefaultInitial(RetVal,

{}, LCtx);

(!ProtoType->isNothrow())

CNE, I, addObjectUnderConstruction(State, CNE, LCtx, RetVal));

DstPostValue, *

, *

);

blockCount = currBldrCtx->

();

IsStandardGlobalOpNewFunction =

State = finishObjectConstruction(State, CNE, LCtx);

(IsStandardGlobalOpNewFunction)

State =

->invalidateRegions(blockCount);

(!ProtoType->isNothrow())

State = State->assume(*dSymVal,

);

(

*NewReg = cast_or_null<SubRegion>(symVal.

())) {

isInitList = isa_and_nonnull<InitListExpr>(

);

evalBind(evaluated, CNE, Pred,

,

,

);

Pred = *evaluated.

();

State = State->BindExpr(CNE, LCtx,

);

(!isa<CXXConstructExpr>(

)) {

evalBind(Dst, CNE, NewN,

, State->getSVal(

, LCtx),

IsStandardGlobalOpNewFunction);

DstPostCall = DstPreCall;

state = state->bindLoc(state->getLValue(VD, LCtx),

, LCtx);

Bldr.

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

));

(

[Idx, FieldForCapture, InitExpr] :

llvm::zip(llvm::seq<unsigned>(0, -1), LE->getLambdaClass()->fields(),

LE->capture_inits())) {

FieldLoc = State->getLValue(FieldForCapture,

);

(!FieldForCapture->hasCapturedVLAType()) {

assert(InitExpr &&

);

FTy = FieldForCapture->getType();

(FTy->isConstantArrayType() &&

().getAsConstantArrayType(FTy)) == 0)

(

OUC =

InitVal = State->getSVal(OUC->getAsRegion());

State = finishObjectConstruction(State, {LE, Idx}, LocCtxt);

InitVal = State->getSVal(InitExpr, LocCtxt);

);

*SizeExpr = FieldForCapture->getCapturedVLAType()->getSizeExpr();

InitVal = State->getSVal(SizeExpr, LocCtxt);

State = State->bindLoc(FieldLoc, InitVal, LocCtxt);

LambdaRVal = State->getSVal(R);

State->BindExpr(LE, LocCtxt, LambdaRVal),

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

static ProgramStateRef bindRequiredArrayElementToEnvironment(ProgramStateRef State, const ArrayInitLoopExpr *AILE, const LocationContext *LCtx, NonLoc Idx)

llvm::MachO::Target Target

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

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

QualType getPointerType(QualType T) const

Return the uniqued reference to the type for a pointer to the specified type.

const ArrayType * getAsArrayType(QualType T) const

Type Query functions.

uint64_t getConstantArrayElementCount(const ConstantArrayType *CA) const

Return number of constant array elements.

uint64_t getArrayInitLoopExprElementCount(const ArrayInitLoopExpr *AILE) const

Return number of elements initialized in an ArrayInitLoopExpr.

AnalysisDeclContext contains the context data for the function, method or block under analysis.

CFG::BuildOptions & getCFGBuildOptions()

Represents a loop initializing the elements of an array.

OpaqueValueExpr * getCommonExpr() const

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

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

Represents a function call that returns a C++ object by value.

Represents C++ constructor call.

std::optional< T > getAs() const

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

CXXCatchStmt - This represents a C++ catch block.

VarDecl * getExceptionDecl() const

Represents a call to a C++ constructor.

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

Represents a C++ destructor within a class.

Represents a call to an inherited base class constructor from an inheriting constructor.

Represents a static or instance method of a struct/union/class.

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

Expr * getPlacementArg(unsigned I)

SourceLocation getBeginLoc() const

FunctionDecl * getOperatorNew() const

Expr * getInitializer()

The initializer of this new-expression.

Represents a C++ struct/union/class.

Represents the this expression in C++.

CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).

ConstructionContext's subclasses describe different ways of constructing an object in C++.

virtual const ArrayInitLoopExpr * getArrayInitLoop() const

@ CXX17ElidedCopyVariableKind

@ ElidedTemporaryObjectKind

@ SimpleTemporaryObjectKind

@ CXX17ElidedCopyConstructorInitializerKind

@ SimpleConstructorInitializerKind

@ SimpleReturnedValueKind

@ CXX17ElidedCopyReturnedValueKind

DeclContext * getParent()

getParent - Returns the containing DeclContext.

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

This represents one expression.

Expr * IgnoreParens() LLVM_READONLY

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

Represents a function declaration or definition.

bool isReservedGlobalPlacementOperator() const

Determines whether this operator new or delete is one of the reserved global placement operators: voi...

bool isReplaceableGlobalAllocationFunction(std::optional< unsigned > *AlignmentParam=nullptr, bool *IsNothrow=nullptr) const

Determines whether this function is one of the replaceable global allocation functions: void *operato...

Represents a prototype with parameter type info, e.g.

A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...

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

const Decl * getDecl() const

const ParentMap & getParentMap() const

LLVM_ATTRIBUTE_RETURNS_NONNULL AnalysisDeclContext * getAnalysisDeclContext() const

const LocationContext * getParent() const

It might return null.

const StackFrameContext * getStackFrame() const

Represents a prvalue temporary that is written into memory so that a reference can bind to it.

StorageDuration getStorageDuration() const

Retrieve the storage duration for the materialized temporary.

Expr * getSubExpr() const

Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue.

ValueDecl * getExtendingDecl()

Get the declaration which triggered the lifetime-extension of this temporary, if any.

Expr * getSourceExpr() const

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

Stmt * getParent(Stmt *) const

Represents a program point just after an implicit call event.

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

ProgramPoint withTag(const ProgramPointTag *tag) const

Create a new ProgramPoint object that is the same as the original except for using the specified tag ...

A (possibly-)qualified type.

Represents a struct/union/class.

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

unsigned getIndex() const

const Stmt * getCallSite() const

const CFGBlock * getCallSiteBlock() const

Stmt - This represents one statement.

CXXRecordDecl * getAsCXXRecordDecl() const

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

QualType getPointeeType() const

If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.

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.

AnalyzerOptions & getAnalyzerOptions() override

Represents a call to a C++ constructor.

Manages the lifetime of CallEvent objects.

CallEventRef< CXXDestructorCall > getCXXDestructorCall(const CXXDestructorDecl *DD, const Stmt *Trigger, const MemRegion *Target, bool IsBase, ProgramStateRef State, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)

CallEventRef< CXXDeallocatorCall > getCXXDeallocatorCall(const CXXDeleteExpr *E, ProgramStateRef State, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)

CallEventRef getSimpleCall(const CallExpr *E, ProgramStateRef State, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)

CallEventRef< ObjCMethodCall > getObjCMethodCall(const ObjCMessageExpr *E, ProgramStateRef State, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)

CallEventRef< CXXAllocatorCall > getCXXAllocatorCall(const CXXNewExpr *E, ProgramStateRef State, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)

CallEventRef< CXXConstructorCall > getCXXConstructorCall(const CXXConstructExpr *E, const MemRegion *Target, ProgramStateRef State, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)

CallEventRef< CXXInheritedConstructorCall > getCXXInheritedConstructorCall(const CXXInheritedCtorInitExpr *E, const MemRegion *Target, ProgramStateRef State, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)

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

static bool isVariadic(const Decl *D)

Returns true if the given decl is known to be variadic.

void runCheckersForPreCall(ExplodedNodeSet &Dst, const ExplodedNodeSet &Src, const CallEvent &Call, ExprEngine &Eng)

Run checkers for pre-visiting obj-c messages.

void runCheckersForEvalCall(ExplodedNodeSet &Dst, const ExplodedNodeSet &Src, const CallEvent &CE, ExprEngine &Eng, const EvalCallOptions &CallOpts)

Run checkers for evaluating a call.

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

Run checkers for post-visiting Stmts.

void runCheckersForNewAllocator(const CXXAllocatorCall &Call, ExplodedNodeSet &Dst, ExplodedNode *Pred, ExprEngine &Eng, bool wasInlined=false)

Run checkers between C++ operator new and constructor calls.

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

Run checkers for pre-visiting Stmts.

void runCheckersForPostCall(ExplodedNodeSet &Dst, const ExplodedNodeSet &Src, const CallEvent &Call, ExprEngine &Eng, bool wasInlined=false)

Run checkers for post-visiting obj-c messages.

ElementRegion is used to represent both array elements and casts.

void Add(ExplodedNode *N)

const ProgramStateRef & getState() const

ProgramPoint getLocation() const

getLocation - Returns the edge associated with the given node.

const LocationContext * getLocationContext() const

ProgramStateManager & getStateManager()

std::pair< ProgramStateRef, SVal > handleConstructionContext(const Expr *E, ProgramStateRef State, const NodeBuilderContext *BldrCtx, const LocationContext *LCtx, const ConstructionContext *CC, EvalCallOptions &CallOpts, unsigned Idx=0)

A convenient wrapper around computeObjectUnderConstruction and updateObjectsUnderConstruction.

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

const CoreEngine & getCoreEngine() const

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

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

VisitLambdaExpr - Transfer function logic for LambdaExprs.

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,...

CFGElement getCurrentCFGElement()

Return the CFG element corresponding to the worklist element that is currently being processed by Exp...

SVal computeObjectUnderConstruction(const Expr *E, ProgramStateRef State, const NodeBuilderContext *BldrCtx, const LocationContext *LCtx, const ConstructionContext *CC, EvalCallOptions &CallOpts, unsigned Idx=0)

Find location of the object that is being constructed by a given constructor.

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.

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

CheckerManager & getCheckerManager() const

ProgramStateRef bindReturnValue(const CallEvent &Call, const LocationContext *LCtx, ProgramStateRef State)

Create a new state in which the call return value is binded to the call origin expression.

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

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

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

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

void defaultEvalCall(NodeBuilder &B, ExplodedNode *Pred, const CallEvent &Call, const EvalCallOptions &CallOpts={})

Default implementation of call evaluation.

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

SValBuilder & getSValBuilder()

ProgramStateRef updateObjectsUnderConstruction(SVal V, const Expr *E, ProgramStateRef State, const LocationContext *LCtx, const ConstructionContext *CC, const EvalCallOptions &CallOpts)

Update the program state with all the path-sensitive information that's necessary to perform construc...

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

Retreives the size of the array in the pending ArrayInitLoopExpr.

const CXXThisRegion * getCXXThisRegion(QualType thisPointerTy, const LocationContext *LC)

getCXXThisRegion - Retrieve the [artificial] region associated with the parameter 'this'.

const ElementRegion * getElementRegion(QualType elementType, NonLoc Idx, const SubRegion *superRegion, const ASTContext &Ctx)

getElementRegion - Retrieve the memory region associated with the associated element type,...

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 CXXBaseObjectRegion * getCXXBaseObjectRegion(const CXXRecordDecl *BaseClass, const SubRegion *Super, bool IsVirtual)

Create a CXXBaseObjectRegion with the given base class for region Super.

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.

unsigned blockCount() const

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

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 ExplodedNodeSet & getResults()

CallEventManager & getCallEventManager()

MemRegionManager & getRegionManager()

NonLoc makeArrayIndex(uint64_t idx)

ASTContext & getContext()

loc::MemRegionVal makeLoc(SymbolRef sym)

SVal evalCast(SVal V, QualType CastTy, QualType OriginalTy)

Cast a given SVal to another SVal using given QualType's.

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

Create a new symbol with a unique 'name'.

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

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

DefinedSVal getConjuredHeapSymbolVal(const Expr *E, const LocationContext *LCtx, unsigned Count)

Conjure a symbol representing heap allocated memory region.

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

std::optional< T > getAs() const

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

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)

SVal evalDerivedToBase(SVal Derived, const CastExpr *Cast)

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

SubRegion - A region that subsets another larger region.

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

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

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

Expr * extractElementInitializerFromNestedAILE(const ArrayInitLoopExpr *AILE)

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

bool IsTemporaryLifetimeExtendedViaAggregate

This call is a constructor for a temporary that is lifetime-extended by binding it to a reference-typ...

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...

bool IsElidableCtorThatHasNotBeenElided

This call is a pre-C++17 elidable constructor that we failed to elide because we failed to compute th...

bool IsCtorOrDtorWithImproperlyModeledTargetRegion

This call is a constructor or a destructor for which we do not currently compute the this-region corr...

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