Go to the documentation of this file.
23 using namespace clang;
34 state = createTemporaryRegionIfNeeded(
state, LCtx, tempExpr, ME);
43 bool AlwaysReturnsLValue;
46 assert(Ctor->getDecl()->isTrivial());
47 assert(Ctor->getDecl()->isCopyOrMoveConstructor());
48 ThisVal = Ctor->getCXXThisVal();
50 AlwaysReturnsLValue =
false;
52 assert(cast<CXXMethodDecl>(Call.getDecl())->isTrivial());
53 assert(cast<CXXMethodDecl>(Call.getDecl())->getOverloadedOperator() ==
55 ThisVal = cast<CXXInstanceCall>(Call).getCXXThisVal();
56 ThisRD = cast<CXXMethodDecl>(Call.getDecl())->
getParent();
57 AlwaysReturnsLValue =
true;
73 SVal
V =
Call.getArgSVal(0);
80 assert(
V.isUnknownOrUndef());
83 evalBind(Dst,
CallExpr, Pred, ThisVal,
V,
true);
89 if (AlwaysReturnsLValue)
100 SValBuilder &SVB =
State->getStateManager().getSValBuilder();
104 Ty = AT->getElementType();
105 LValue =
State->getLValue(Ty, SVB.makeZeroArrayIndex(), LValue);
124 const auto *DSCC = cast<VariableConstructionContext>(CC);
125 const auto *DS = DSCC->getDeclStmt();
126 const auto *Var = cast<VarDecl>(DS->getSingleDecl());
128 return makeZeroElementRegion(
State,
State->getLValue(Var, LCtx), Ty,
133 const auto *ICC = cast<ConstructorInitializerConstructionContext>(CC);
134 const auto *Init = ICC->getCXXCtorInitializer();
138 if (Init->isBaseInitializer()) {
139 const auto *ThisReg = cast<SubRegion>(ThisVal.
getAsRegion());
141 Init->getBaseClass()->getAsCXXRecordDecl();
142 const auto *BaseReg =
144 Init->isBaseVirtual());
147 if (Init->isDelegatingInitializer())
152 if (Init->isIndirectMemberInitializer()) {
153 Field = Init->getIndirectMember();
154 FieldVal =
State->getLValue(Init->getIndirectMember(), ThisVal);
156 Field = Init->getMember();
157 FieldVal =
State->getLValue(Init->getMember(), ThisVal);
161 return makeZeroElementRegion(
State, FieldVal, Ty,
166 const auto *NECC = cast<NewAllocatedObjectConstructionContext>(CC);
167 const auto *
NE = NECC->getCXXNewExpr();
170 dyn_cast_or_null<SubRegion>(
V.getAsRegion())) {
176 MR,
NE->getType()->getPointeeType()));
200 if (isa<BlockInvocationContext>(CallerLCtx)) {
203 CallerLCtx = CallerLCtx->getParent();
204 assert(!isa<BlockInvocationContext>(CallerLCtx));
208 RTC->getConstructionContext(), CallOpts);
219 const auto *RCC = cast<ReturnedValueConstructionContext>(CC);
222 static const int TopLevelSymRegionTag = 0;
223 const Expr *RetE = RCC->getReturnStmt()->getRetValue();
224 assert(RetE &&
"Void returns should not have a construction context");
230 llvm_unreachable(
"Unhandled return value construction context!");
234 const auto *TCC = cast<ElidedTemporaryObjectConstructionContext>(CC);
247 TCC->getConstructorAfterElision(),
State, LCtx,
248 TCC->getConstructionContextAfterElision(), CallOpts);
258 CallOpts = PreElideCallOpts;
263 const auto *TCC = cast<TemporaryObjectConstructionContext>(CC);
270 if (!VD->getType()->isReferenceType()) {
291 const auto *ACC = cast<ArgumentConstructionContext>(CC);
292 const Expr *E = ACC->getCallLikeExpr();
293 unsigned Idx = ACC->getIndex();
298 Caller->getCalleeStackFrame(currBldrCtx->
blockCount());
317 *Caller->getAdjustedParameterIndex(Idx), currBldrCtx->
blockCount());
324 if (
const auto *CE = dyn_cast<CallExpr>(E)) {
330 }
else if (
const auto *CCE = dyn_cast<CXXConstructExpr>(E)) {
339 }
else if (
const auto *ME = dyn_cast<ObjCMessageExpr>(E)) {
367 assert(CC &&
"Computed target region without construction context?");
371 const auto *DSCC = cast<VariableConstructionContext>(CC);
372 return addObjectUnderConstruction(
State, DSCC->getDeclStmt(), LCtx,
V);
376 const auto *ICC = cast<ConstructorInitializerConstructionContext>(CC);
377 const auto *Init = ICC->getCXXCtorInitializer();
379 assert(Init->isAnyMemberInitializer() &&
380 "Base and delegating initializers should have been handled by"
381 "computeObjectUnderConstruction()");
382 return addObjectUnderConstruction(
State, Init, LCtx,
V);
398 assert(RTC &&
"Could not have had a target region without it");
399 if (isa<BlockInvocationContext>(CallerLCtx)) {
403 assert(!isa<BlockInvocationContext>(CallerLCtx));
408 RTC->getConstructionContext(), CallOpts);
413 const auto *TCC = cast<ElidedTemporaryObjectConstructionContext>(CC);
415 V, TCC->getConstructorAfterElision(),
State, LCtx,
416 TCC->getConstructionContextAfterElision(), CallOpts);
419 State = addObjectUnderConstruction(
420 State, TCC->getConstructorAfterElision(), LCtx,
V);
423 if (
const auto *BTE = TCC->getCXXBindTemporaryExpr())
428 if (
const auto *MTE = TCC->getMaterializedTemporaryExpr())
429 State = addObjectUnderConstruction(
State, MTE, LCtx,
V);
438 const auto *TCC = cast<TemporaryObjectConstructionContext>(CC);
439 if (
const auto *BTE = TCC->getCXXBindTemporaryExpr())
440 State = addObjectUnderConstruction(
State, BTE, LCtx,
V);
442 if (
const auto *MTE = TCC->getMaterializedTemporaryExpr())
443 State = addObjectUnderConstruction(
State, MTE, LCtx,
V);
448 const auto *ACC = cast<ArgumentConstructionContext>(CC);
449 if (
const auto *BTE = ACC->getCXXBindTemporaryExpr())
450 State = addObjectUnderConstruction(
State, BTE, LCtx,
V);
452 return addObjectUnderConstruction(
453 State, {ACC->getCallLikeExpr(), ACC->getIndex()}, LCtx,
V);
456 llvm_unreachable(
"Unhandled construction context!");
459 void ExprEngine::handleConstructor(
const Expr *E,
462 const auto *CE = dyn_cast<CXXConstructExpr>(E);
463 const auto *CIE = dyn_cast<CXXInheritedCtorInitExpr>(E);
479 State = finishObjectConstruction(
State, CE, LCtx);
491 EvalCallOptions CallOpts;
497 CE ? CE->getConstructionKind() : CIE->getConstructionKind();
501 assert(CE && !CIE &&
"A complete constructor is inherited?!");
504 std::tie(
State, Target) =
511 const auto *OuterCtor = dyn_cast_or_null<CXXConstructExpr>(
517 (
"This virtual base should have already been initialized by "
518 "the most derived class!"));
536 Target = loc::MemRegionVal(MRMgr.getCXXTempObjectRegion(E, LCtx));
537 CallOpts.IsCtorOrDtorWithImproperlyModeledTargetRegion =
true;
545 SVal ThisVal =
State->getSVal(ThisPtr);
562 "Prepare for object construction");
563 ExplodedNodeSet DstPrepare;
564 StmtNodeBuilder BldrPrepare(Pred, DstPrepare, *currBldrCtx);
566 assert(DstPrepare.size() <= 1);
567 if (DstPrepare.size() == 0)
569 Pred = *BldrPrepare.begin();
572 const MemRegion *TargetRegion =
Target.getAsRegion();
574 CallEventRef<>
Call =
575 CIE ? (CallEventRef<>)CEMgr.getCXXInheritedConstructorCall(
576 CIE, TargetRegion,
State, LCtx)
577 : (CallEventRef<>)CEMgr.getCXXConstructorCall(
578 CE, TargetRegion,
State, LCtx);
580 ExplodedNodeSet DstPreVisit;
583 ExplodedNodeSet PreInitialized;
586 StmtNodeBuilder Bldr(DstPreVisit, PreInitialized, *currBldrCtx);
588 E = DstPreVisit.end();
591 if (CE->requiresZeroInitialization()) {
611 PreInitialized = DstPreVisit;
614 ExplodedNodeSet DstPreCall;
618 ExplodedNodeSet DstEvaluated;
620 if (CE && CE->getConstructor()->isTrivial() &&
621 CE->getConstructor()->isCopyOrMoveConstructor() &&
622 !CallOpts.IsArrayCtorOrDtor) {
623 StmtNodeBuilder Bldr(DstPreCall, DstEvaluated, *currBldrCtx);
627 performTrivialCopy(Bldr, *I, *Call);
643 ExplodedNodeSet DstEvaluatedPostProcessed;
644 StmtNodeBuilder Bldr(DstEvaluated, DstEvaluatedPostProcessed, *currBldrCtx);
647 if (llvm::isa_and_nonnull<CXXTempObjectRegion>(TargetRegion) &&
648 cast<CXXConstructorDecl>(
Call->getDecl())
650 ->isAnyDestructorNoReturn()) {
659 assert(!DstEvaluated.empty() &&
660 "We should not have inlined this constructor!");
662 for (ExplodedNode *N : DstEvaluated) {
673 ExplodedNodeSet DstPostArgumentCleanup;
674 for (ExplodedNode *I : DstEvaluatedPostProcessed)
675 finishArgumentConstruction(DstPostArgumentCleanup, I, *Call);
679 ExplodedNodeSet DstPostCall;
681 DstPostArgumentCleanup,
689 handleConstructor(CE, Pred, Dst);
695 handleConstructor(CE, Pred, Dst);
705 assert(S &&
"A destructor without a trigger!");
710 assert(
RecordDecl &&
"Only CXXRecordDecls should have destructors");
732 if (
const Expr *E = dyn_cast_or_null<Expr>(S)) {
748 Call->getSourceRange().getBegin(),
749 "Error evaluating destructor");
772 "Error evaluating New Allocator Call");
816 if (!ProtoType->isNothrow())
821 CNE, I, addObjectUnderConstruction(
State, CNE, LCtx, RetVal));
826 DstPostValue, *Call, *
this);
839 unsigned blockCount = currBldrCtx->
blockCount();
844 bool IsStandardGlobalOpNewFunction =
852 State = finishObjectConstruction(
State, CNE, LCtx);
859 if (IsStandardGlobalOpNewFunction)
875 State = Call->invalidateRegions(blockCount);
887 if (!ProtoType->isNothrow())
894 SVal Result = symVal;
899 if (
const auto *NewReg = cast_or_null<SubRegion>(symVal.
getAsRegion())) {
930 if (!isa<CXXConstructExpr>(Init)) {
933 evalBind(Dst, CNE, NewN, Result,
State->getSVal(Init, LCtx),
934 IsStandardGlobalOpNewFunction);
956 DstPostCall = DstPreCall;
1010 e =
LE->capture_init_end();
1011 i != e; ++i, ++CurField) {
1013 SVal FieldLoc =
State->getLValue(FieldForCapture,
V);
1017 Expr *InitExpr = *i;
1018 assert(InitExpr &&
"Capture missing initialization expression");
1019 InitVal =
State->getSVal(InitExpr, LocCtxt);
1025 InitVal =
State->getSVal(SizeExpr, LocCtxt);
1028 State =
State->bindLoc(FieldLoc, InitVal, LocCtxt);
1040 State->BindExpr(
LE, LocCtxt, LambdaRVal),
void VisitLambdaExpr(const LambdaExpr *LE, ExplodedNode *Pred, ExplodedNodeSet &Dst)
VisitLambdaExpr - Transfer function logic for LambdaExprs.
ProgramStateManager & getStateManager()
ProgramPoint withTag(const ProgramPointTag *tag) const
Create a new ProgramPoint object that is the same as the original except for using the specified tag ...
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...
const LocationContext * getLocationContext() const
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
It wraps the AnalysisDeclContext to represent both the call stack with the help of StackFrameContext ...
const StackFrameContext * getStackFrame() const
CallEventRef< CXXDestructorCall > getCXXDestructorCall(const CXXDestructorDecl *DD, const Stmt *Trigger, const MemRegion *Target, bool IsBase, ProgramStateRef State, const LocationContext *LCtx)
T castAs() const
Convert to the specified SVal type, asserting that this SVal is of the desired type.
ImplTy::iterator iterator
const MemRegion * getAsRegion() const
Expr * getSubExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue.
CallEventRef< CXXDeallocatorCall > getCXXDeallocatorCall(const CXXDeleteExpr *E, ProgramStateRef State, const LocationContext *LCtx)
ASTContext & getContext() const
getContext - Return the ASTContext associated with this analysis.
FunctionDecl * getOperatorNew() const
IntrusiveRefCntPtr< const ProgramState > ProgramStateRef
A (possibly-)qualified type.
@ CXX17ElidedCopyConstructorInitializerKind
ConstructionContext's subclasses describe different ways of constructing an object in C++.
CallEventRef< ObjCMethodCall > getObjCMethodCall(const ObjCMessageExpr *E, ProgramStateRef State, const LocationContext *LCtx)
AnalysisDeclContext contains the context data for the function, method or block under analysis.
Represents a member of a struct/union/class.
void runCheckersForEvalCall(ExplodedNodeSet &Dst, const ExplodedNodeSet &Src, const CallEvent &CE, ExprEngine &Eng, const EvalCallOptions &CallOpts)
Run checkers for evaluating a call.
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
@ SimpleReturnedValueKind
void Add(ExplodedNode *N)
@ CXX17ElidedCopyVariableKind
const CFGBlock * getCallSiteBlock() const
void VisitCXXNewExpr(const CXXNewExpr *CNE, ExplodedNode *Pred, ExplodedNodeSet &Dst)
It represents a stack frame of the call stack (based on CallEvent).
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
void runCheckersForPostCall(ExplodedNodeSet &Dst, const ExplodedNodeSet &Src, const CallEvent &Call, ExprEngine &Eng, bool wasInlined=false)
Run checkers for post-visiting obj-c messages.
SVal evalDerivedToBase(SVal Derived, const CastExpr *Cast)
Evaluates a chain of derived-to-base casts through the path specified in Cast.
unsigned getIndex() 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.
DefinedOrUnknownSVal getConjuredHeapSymbolVal(const Expr *E, const LocationContext *LCtx, unsigned Count)
Conjure a symbol representing heap allocated memory region.
Represents a program point just after an implicit call event.
bool hasCapturedVLAType() const
Determine whether this member captures the variable length array type.
Optional< T > getAs() const
Convert to the specified SVal type, returning None if this SVal is not of the desired type.
bool IsArrayCtorOrDtor
This call is a constructor or a destructor for a single element within an array, a part of array cons...
const CXXBaseObjectRegion * getCXXBaseObjectRegion(const CXXRecordDecl *BaseClass, const SubRegion *Super, bool IsVirtual)
Create a CXXBaseObjectRegion with the given base class for region Super.
MemRegion - The root abstract class for all memory regions.
void takeNodes(const ExplodedNodeSet &S)
AnalyzerOptions & getAnalyzerOptions() override
const ProgramStateRef & getState() const
Hints for figuring out of a call should be inlined during evalCall().
const CXXThisRegion * getCXXThisRegion(QualType thisPointerTy, const LocationContext *LC)
getCXXThisRegion - Retrieve the [artificial] region associated with the parameter 'this'.
Represents a call to a C++ constructor.
Represents C++ constructor call.
AnalysisDeclContext * getAnalysisDeclContext() const
ASTContext & getContext()
Expr * getInitializer()
The initializer of this new-expression.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
ExplodedNode * generateSink(const ProgramPoint &PP, ProgramStateRef State, ExplodedNode *Pred)
Generates a sink in the ExplodedGraph.
bool LE(InterpState &S, CodePtr OpPC)
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
SVal computeObjectUnderConstruction(const Expr *E, ProgramStateRef State, const LocationContext *LCtx, const ConstructionContext *CC, EvalCallOptions &CallOpts)
Find location of the object that is being constructed by a given constructor.
ValueDecl * getExtendingDecl()
Get the declaration which triggered the lifetime-extension of this temporary, if any.
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
void VisitCXXCatchStmt(const CXXCatchStmt *CS, ExplodedNode *Pred, ExplodedNodeSet &Dst)
loc::MemRegionVal getCXXThis(const CXXMethodDecl *D, const StackFrameContext *SFC)
Return a memory region for the 'this' object reference.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
const T * getAs() const
Member-template getAs<specific type>'.
void VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E, ExplodedNode *Pred, ExplodedNodeSet &Dst)
@ SimpleConstructorInitializerKind
void runCheckersForNewAllocator(const CXXAllocatorCall &Call, ExplodedNodeSet &Dst, ExplodedNode *Pred, ExprEngine &Eng, bool wasInlined=false)
Run checkers between C++ operator new and constructor calls.
MemRegionManager & getRegionManager()
static 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,...
const ExplodedNodeSet & getResults()
Represents a C++ destructor within a class.
CallEventRef< CXXConstructorCall > getCXXConstructorCall(const CXXConstructExpr *E, const MemRegion *Target, ProgramStateRef State, const LocationContext *LCtx)
Expr * getSizeExpr() const
Expr *const * const_capture_init_iterator
Const iterator that walks over the capture initialization arguments.
void VisitCXXThisExpr(const CXXThisExpr *TE, ExplodedNode *Pred, ExplodedNodeSet &Dst)
Represents a variable declaration or definition.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
@ SD_FullExpression
Full-expression storage duration (for temporaries).
Represents a function call that returns a C++ object by value.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
CallEventRef< CXXAllocatorCall > getCXXAllocatorCall(const CXXNewExpr *E, ProgramStateRef State, const LocationContext *LCtx)
unsigned blockCount() const
Returns the number of times the current basic block has been visited on the exploded graph path.
ElementRegion is used to represent both array elements and casts.
Represents a call to an inherited base class constructor from an inheriting constructor.
void runCheckersForPreCall(ExplodedNodeSet &Dst, const ExplodedNodeSet &Src, const CallEvent &Call, ExprEngine &Eng)
Run checkers for pre-visiting obj-c messages.
CallEventRef getSimpleCall(const CallExpr *E, ProgramStateRef State, const LocationContext *LCtx)
and static some checkers Checker The latter are built on top of the former via the Checker and CheckerVisitor and attempts to isolate them from much of the gore of the internal analysis the analyzer is basically a source code simulator that traces out possible paths of execution The state of the and the combination of state and program point is a node in an exploded which has the entry program point and initial state
const VariableArrayType * getCapturedVLAType() const
Get the captured variable length array type.
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
const LocationContext * getParent() const
Represents a C++ struct/union/class.
std::pair< ProgramStateRef, SVal > handleConstructionContext(const Expr *E, ProgramStateRef State, const LocationContext *LCtx, const ConstructionContext *CC, EvalCallOptions &CallOpts)
A convenient wrapper around computeObjectUnderConstruction and updateObjectsUnderConstruction.
loc::MemRegionVal makeLoc(SymbolRef sym)
Manages the lifetime of CallEvent objects.
CFG::BuildOptions & getCFGBuildOptions()
SVal evalCast(SVal V, QualType CastTy, QualType OriginalTy)
Cast a given SVal to another SVal using given QualType's.
void VisitCXXDestructor(QualType ObjectType, const MemRegion *Dest, const Stmt *S, bool IsBaseDtor, ExplodedNode *Pred, ExplodedNodeSet &Dst, EvalCallOptions &Options)
Optional< T > getAs() const
Convert to the specified CFGElement type, returning None if this CFGElement is not of the desired typ...
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
CallEventManager & getCallEventManager()
Represents a prototype with parameter type info, e.g.
DeclContext * getParent()
getParent - Returns the containing DeclContext.
const CXXTempObjectRegion * getCXXTempObjectRegion(Expr const *Ex, LocationContext const *LC)
Represents a delete expression for memory deallocation and destructor calls, e.g.
void runCheckersForPostStmt(ExplodedNodeSet &Dst, const ExplodedNodeSet &Src, const Stmt *S, ExprEngine &Eng, bool wasInlined=false)
Run checkers for post-visiting Stmts.
Decl - This represents one declaration (or definition), e.g.
bool isReplaceableGlobalAllocationFunction(Optional< unsigned > *AlignmentParam=nullptr, bool *IsNothrow=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
const Stmt * getCallSite() const
void VisitCXXDeleteExpr(const CXXDeleteExpr *CDE, ExplodedNode *Pred, ExplodedNodeSet &Dst)
@ SD_Static
Static storage duration.
SValBuilder & getSValBuilder()
Stmt * getParent(Stmt *) const
CFGElement getCurrentCFGElement()
Return the CFG element corresponding to the worklist element that is currently being processed by Exp...
If a crash happens while one of these objects are live, the message is printed out along with the spe...
Represents the this expression in C++.
StoreManager & getStoreManager()
bool NE(InterpState &S, CodePtr OpPC)
bool isReservedGlobalPlacementOperator() const
Determines whether this operator new or delete is one of the reserved global placement operators: voi...
bool IsElidableCtorThatHasNotBeenElided
This call is a pre-C++17 elidable constructor that we failed to elide because we failed to compute th...
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
@ SimpleTemporaryObjectKind
static bool isVariadic(const Decl *D)
Returns true if the given decl is known to be variadic.
ProgramPoint getLocation() const
getLocation - Returns the edge associated with the given node.
const CXXTempObjectRegion * getCXXStaticTempObjectRegion(const Expr *Ex)
Create a CXXTempObjectRegion for temporaries which are lifetime-extended by static references.
Stmt - This represents one statement.
ExplodedNode * generateNode(const ProgramPoint &PP, ProgramStateRef State, ExplodedNode *Pred)
Generates a node in the ExplodedGraph.
CXXCatchStmt - This represents a C++ catch block.
Represents an abstract call to a function or method along a particular path.
@ SD_Thread
Thread storage duration.
void VisitCXXConstructExpr(const CXXConstructExpr *E, ExplodedNode *Pred, ExplodedNodeSet &Dst)
bool IsTemporaryCtorOrDtor
This call is a constructor or a destructor of a temporary value.
@ ElidedTemporaryObjectKind
void VisitCXXNewAllocatorCall(const CXXNewExpr *CNE, ExplodedNode *Pred, ExplodedNodeSet &Dst)
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
SVal - This represents a symbolic expression, which can be either an L-value or an R-value.
TypedValueRegion - An abstract class representing regions having a typed value.
SubRegion - A region that subsets another larger region.
@ CXX17ElidedCopyReturnedValueKind
This represents one expression.
Expr * getPlacementArg(unsigned I)
VarDecl * getExceptionDecl() const
void runCheckersForPreStmt(ExplodedNodeSet &Dst, const ExplodedNodeSet &Src, const Stmt *S, ExprEngine &Eng)
Run checkers for pre-visiting Stmts.
DefinedOrUnknownSVal conjureSymbolVal(const void *symbolTag, const Expr *expr, const LocationContext *LCtx, unsigned count)
Create a new symbol with a unique 'name'.
const ElementRegion * GetElementZeroRegion(const SubRegion *R, QualType T)
SourceLocation getBeginLoc() const
void CreateCXXTemporaryObject(const MaterializeTemporaryExpr *ME, ExplodedNode *Pred, ExplodedNodeSet &Dst)
Create a C++ temporary object for an rvalue.
ExplodedNode * generateNode(const Stmt *S, ExplodedNode *Pred, ProgramStateRef St, const ProgramPointTag *tag=nullptr, ProgramPoint::Kind K=ProgramPoint::PostStmtKind)
const Decl * getDecl() const
Represents a function declaration or definition.
Represents a struct/union/class.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Represents a call to a C++ constructor.
void defaultEvalCall(NodeBuilder &B, ExplodedNode *Pred, const CallEvent &Call, const EvalCallOptions &CallOpts={})
Default implementation of call evaluation.
bool IsTemporaryLifetimeExtendedViaAggregate
This call is a constructor for a temporary that is lifetime-extended by binding it to a reference-typ...
const ParentMap & getParentMap() const
bool IsCtorOrDtorWithImproperlyModeledTargetRegion
This call is a constructor or a destructor for which we do not currently compute the this-region corr...
Represents a static or instance method of a struct/union/class.
CheckerManager & getCheckerManager() const