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

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

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

;

);

);

);

assert(Entry->

());

->addPredecessor(Pred, G);

std::pair<

*,

*S =

;

S = CEE->getCalleeContext()->getCallSite();

std::optional<CallEnter> CE;

}

(!CE || CE->getCalleeContext() != CEE->getCalleeContext());

}

(std::optional<BlockEdge> BE = PP.

<

>()) {

}

(std::optional<CallEnter> CE = PP.

<

>()) {

(CE->getCalleeContext() == SF)

(

->pred_empty())

std::make_pair(

,

);

std::make_pair(S, Blk);

(ExpectedTy == ActualTy)

*LastSt =

;

(!Blk || !LastSt) {

(Pred, Dst, dyn_cast<ReturnStmt>(LastSt), LCtx,

*RuntimeCallee = calleeCtx->

();

*StaticDecl =

->getDecl();

assert(RuntimeCallee);

assert(isa<CXXDestructorCall>(

) &&

);

&DtorCall = cast<CXXDestructorCall>(

);

ThisVal = DtorCall.getCXXThisVal();

(

ThisElementRegion = dyn_cast<ElementRegion>(ThisVal.getAsRegion())) {

ArrayRegion = ThisElementRegion->getAsArrayOffset().getRegion();

ElementType = ThisElementRegion->getElementType();

(!ElementCount.isConstant())

ElementCount.getAsInteger()->getLimitedValue();

assert(LCtx &&

);

State = removePendingInitLoop(State,

, LCtx);

State = removeIndexOfElementToConstruct(State,

, LCtx);

State = removePendingArrayDestruction(State, LCtx);

*LastSt =

;

ShouldRepeatCall =

;

(

*DtorDecl =

dyn_cast_or_null<CXXDestructorDecl>(

->getDecl())) {

ShouldRepeatCall = *Idx > 0;

ThisVal = svalBuilder.

(DtorDecl->getParent(), calleeCtx);

state = state->killBinding(ThisVal);

(

*RS = dyn_cast_or_null<ReturnStmt>(LastSt)) {

= state->getSVal(RS, LCtx);

(!ReturnedTy.

()) {

(

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

state = state->BindExpr(CE, callerCtx,

);

svalBuilder.

(CCE->getConstructor()->getParent(), calleeCtx);

ThisV = state->getSVal(This);

ThisV = state->getSVal(ThisV.

<

>());

state = state->BindExpr(CCE, callerCtx, ThisV);

ShouldRepeatCall = shouldRepeatCtorCall(state, CCE, callerCtx);

(

*CNE = dyn_cast<CXXNewExpr>(CE)) {

AllocV = state->getSVal(CNE, callerCtx);

state = addObjectUnderConstruction(state, CNE, calleeCtx->

(),

(!ShouldRepeatCall) {

state = removeStateTraitsUsedForArrayEvaluation(

state, dyn_cast_or_null<CXXConstructExpr>(CE), callerCtx);

= isa<ReturnStmt>(LastSt)

, &retValBind)};

isa<ReturnStmt>(LastSt) ? Blk : &CEBNode->

().

();

(BindedRetNode, CleanedNodes,

, calleeCtx,

currBldrCtx =

;

CleanedNodes.

(CEBNode);

(llvm::isa_and_nonnull<CXXNewExpr>(CE)) {

CEENode, *UpdatedCall, *

,

cast<CXXAllocatorCall>(*UpdatedCall), DstPostCall, I, *

,

*UpdatedCall, *

,

!(isa<CXXNewExpr>(CE) &&

Dst.

(DstPostCall);

Idx = calleeCtx->

() + (ShouldRepeatCall ? 0 : 1);

Cfg->

() >= AMgr.

.MinCFGSizeTreatFunctionsAsLarge;

&IsRecursive,

&StackDepth) {

IsRecursive =

;

*DI = SFC->getDecl();

(!isSmall(CalleeADC))

DynamicDispatchMode {

DynamicDispatchModeInlined = 1,

DynamicDispatchModeConservative

(

.isForeign() && !isSecondPhaseCTU()) {

BState = State->get<CTUDispatchBifurcation>();

ConservativeEvalState = State->set<CTUDispatchBifurcation>(

);

conservativeEvalCall(

, Bldr, Pred, ConservativeEvalState);

conservativeEvalCall(

, Bldr, Pred, State);

!cast<BlockCall>(

).isConversionFromLambda()) {

assert(BR &&

);

cast<BlockDecl>(

),

*CallE =

.getOriginExpr();

State = State->enterStackFrame(

, CalleeSFC);

N->addPredecessor(Pred, G);

(!isSecondPhaseCTU())

VisitedCallees->insert(

);

assert(ReplayState == CallE &&

);

(dstCallEvaluated, N, *CallTemplate);

(!

|| isa<CXXNewExpr>(

))

(

CallI = 0, CallN =

.getNumArgs(); CallI != CallN; ++CallI) {

I =

.getASTArgumentIndex(CallI);

->getStackFrame()->getParent()

State = finishObjectConstruction(State, {

, I}, LC);

(CleanedState == State) {

);

B.generateNode(PP, CleanedState, Pred);

finishArgumentConstruction(dstArgumentCleanup, I,

);

(

*MR =

.getArgSVal(Arg).getAsRegion())

(State == I->getState())

(Msg->getMethodFamily()) {

State->BindExpr(

, LCtx, Msg->getReceiverSVal());

ThisV =

->getCXXThisVal();

ThisV = State->getSVal(ThisV.

<

>());

State->BindExpr(

, LCtx, ThisV);

assert(RTC->getStmt() ==

.getOriginExpr());

.getOriginExpr(), State, currBldrCtx, LCtx,

RTC->getConstructionContext(), CallOpts);

State = State->invalidateRegions(TargetR,

, Count, LCtx,

*CNE = dyn_cast<CXXNewExpr>(

);

(CNE && CNE->getOperatorNew()->isReplaceableGlobalAllocationFunction()) {

(

*SizeExpr = CNE->getArraySize().value_or(

)) {

ElementCount = State->getSVal(SizeExpr, LCtx);

ElementCount = svalBuilder.

(1,

);

svalBuilder.

(State, BO_Mul, ElementCount, ElementSize,

State->BindExpr(

, LCtx, R);

State =

.invalidateRegions(currBldrCtx->

(), State);

ExprEngine::CallInlinePolicy

(

.getKind()) {

CIP_DisallowedAlways;

CIP_DisallowedAlways;

(llvm::isa_and_nonnull<NewAllocatedObjectConstructionContext>(CC) &&

!Opts.MayInlineCXXAllocator)

CIP_DisallowedOnce;

(!shouldInlineArrayConstruction(Pred->

(), CtorExpr, CurLC))

CIP_DisallowedOnce;

CIP_DisallowedAlways;

!Opts.ShouldIncludeTemporaryDtorsInCFG)

CIP_DisallowedOnce;

CIP_DisallowedOnce;

CIP_DisallowedOnce;

CIP_DisallowedAlways;

CIP_DisallowedOnce;

!Opts.MayInlineCXXTemporaryDtors)

CIP_DisallowedOnce;

CIP_DisallowedOnce;

(Opts.MayInlineCXXAllocator)

CIP_DisallowedAlways;

(!Opts.MayInlineObjCMethod)

CIP_DisallowedAlways;

CIP_DisallowedAlways;

(Ctx, RD,

);

(II->isStr(

))

(!Opts.MayInlineTemplateFunctions)

(!Opts.MayInlineCXXStandardLibrary)

(!Opts.MayInlineCXXContainerMethods)

(!Opts.MayInlineCXXSharedPtrDtor)

*CalleeCFG = CalleeADC->

();

(isHuge(CalleeADC))

std::optional<bool> MayInline = Engine.FunctionSummaries->

(

);

(mayInlineDecl(CalleeADC)) {

CallInlinePolicy CIP = mayInlineCallKind(

, Pred, Opts, CallOpts);

(CIP != CIP_Allowed) {

(CIP == CIP_DisallowedAlways) {

assert(!MayInline || *MayInline);

IsRecursive =

;

StackDepth = 0;

(!isSmall(CalleeADC) || IsRecursive))

Opts.MaxTimesInlineLarge) &&

isLarge(CalleeADC)) {

NumReachedInlineCountMax++;

(HowToInline ==

&& (!isSmall(CalleeADC) || IsRecursive))

ExprEngine::shouldInlineArrayConstruction(

State,

(

*CAT = dyn_cast<ConstantArrayType>(CE->

())) {

shouldInlineArrayDestruction(ArrSize);

shouldInlineArrayDestruction(*Size);

ExprEngine::shouldInlineArrayDestruction(uint64_t Size) {

Size <= maxAllowedSize && Size > 0;

(

*CAT = dyn_cast<ConstantArrayType>(Ty)) {

performTrivialCopy(Bldr, Pred, *

);

*

=

->getOriginExpr();

(InlinedFailedState) {

State = InlinedFailedState;

(shouldInlineCall(*

,

, Pred, CallOpts)) {

conservativeEvalCall(*

, Bldr, Pred, State);

ctuBifurcate(*

,

, Bldr, Pred, State);

State = removeStateTraitsUsedForArrayEvaluation(

State, dyn_cast_or_null<CXXConstructExpr>(

),

->getLocationContext());

conservativeEvalCall(*

, Bldr, Pred, State);

ExprEngine::BifurcateCall(

*BifurReg,

*BState =

State->get<DynamicDispatchBifurcationMap>(BifurReg);

(*BState == DynamicDispatchModeInlined)

ctuBifurcate(

,

, Bldr, Pred, State);

conservativeEvalCall(

, Bldr, Pred, State);

State->set<DynamicDispatchBifurcationMap>(BifurReg,

DynamicDispatchModeInlined);

ctuBifurcate(

,

, Bldr, Pred, IState);

State->set<DynamicDispatchBifurcationMap>(BifurReg,

DynamicDispatchModeConservative);

conservativeEvalCall(

, Bldr, Pred, NoIState);

NumOfDynamicDispatchPathSplits++;

ei = dstPreVisit.

(); it != ei; ++it) {

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

static bool isContainerClass(const ASTContext &Ctx, const CXXRecordDecl *RD)

Returns true if the given C++ class is a container or iterator.

static ProgramStateRef getInlineFailedState(ProgramStateRef State, const Stmt *CallE)

static std::pair< const Stmt *, const CFGBlock * > getLastStmt(const ExplodedNode *Node)

static bool isTrivialObjectAssignment(const CallEvent &Call)

static bool isCXXSharedPtrDtor(const FunctionDecl *FD)

Returns true if the given function is the destructor of a class named "shared_ptr".

static bool hasMember(const ASTContext &Ctx, const CXXRecordDecl *RD, StringRef Name)

Returns true if the given C++ class contains a member with the given name.

static bool wasDifferentDeclUsedForInlining(CallEventRef<> Call, const StackFrameContext *calleeCtx)

STATISTIC(NumOfDynamicDispatchPathSplits, "The # of times we split the path due to imprecise dynamic dispatch info")

static SVal adjustReturnValue(SVal V, QualType ExpectedTy, QualType ActualTy, StoreManager &StoreMgr)

Adjusts a return value when the called function's return type does not match the caller's expression ...

static bool isContainerMethod(const ASTContext &Ctx, const FunctionDecl *FD)

Returns true if the given function refers to a method of a C++ container or iterator.

static unsigned getElementCountOfArrayBeingDestructed(const CallEvent &Call, const ProgramStateRef State, SValBuilder &SVB)

llvm::MachO::Target Target

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

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

SourceManager & getSourceManager()

DeclarationNameTable DeclarationNames

const LangOptions & getLangOpts() const

uint64_t getConstantArrayElementCount(const ConstantArrayType *CA) const

Return number of constant array elements.

AnalysisDeclContext * getContext(const Decl *D)

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

const BlockInvocationContext * getBlockInvocationContext(const LocationContext *ParentLC, const BlockDecl *BD, const void *Data)

Obtain a context of the block invocation using its parent context.

const Decl * getDecl() const

static bool isInStdNamespace(const Decl *D)

const StackFrameContext * getStackFrame(LocationContext const *ParentLC, const Stmt *S, const CFGBlock *Blk, unsigned BlockCount, unsigned Index)

Obtain a context of the call stack using its parent context.

ASTContext & getASTContext() const

bool isBodyAutosynthesized() const

CFG::BuildOptions & getCFGBuildOptions()

Stores options for the analyzer from the command line.

bool mayInlineCXXMemberFunction(CXXInlineableMemberKind K) const

Returns the option controlling which C++ member functions will be considered for inlining.

unsigned maxBlockVisitOnPath

The maximum number of times the analyzer visits a block.

IPAKind getIPAMode() const

Returns the inter-procedural analysis mode.

CTUPhase1InliningKind getCTUPhase1Inlining() const

AnalysisPurgeMode AnalysisPurgeOpt

unsigned InlineMaxStackDepth

The inlining stack depth limit.

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

succ_iterator succ_begin()

unsigned succ_size() const

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

Represents a source-level, intra-procedural CFG that represents the control-flow of a Stmt.

unsigned size() const

Return the total number of CFGBlocks within the CFG This is simply a renaming of the getNumBlockIDs()...

bool isLinear() const

Returns true if the CFG has no branches.

unsigned getNumBlockIDs() const

Returns the total number of BlockIDs allocated (which start at 0).

BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...

Represents a call to a C++ constructor.

CXXConstructionKind getConstructionKind() const

Determine whether this constructor is actually constructing a base class (rather than a complete obje...

Represents a C++ destructor within a class.

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

const CXXRecordDecl * getParent() const

Return the parent of this method declaration, which is the class in which this method is defined.

bool isMoveAssignmentOperator() const

Determine whether this is a move assignment operator.

bool isCopyAssignmentOperator() const

Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...

Represents a C++ struct/union/class.

bool hasTrivialDestructor() const

Determine whether this class has a trivial destructor (C++ [class.dtor]p3)

bool hasMemberName(DeclarationName N) const

Determine whether this class has a member with the given name, possibly in a non-dependent base class...

bool isDerivedFrom(const CXXRecordDecl *Base) const

Determine whether this class is derived from the class Base.

Represents a point when we begin processing an inlined call.

const CFGBlock * getEntry() const

Returns the entry block in the CFG for the entered function.

const StackFrameContext * getCalleeContext() const

Represents a point when we finish the call exit sequence (for inlined call).

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

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

virtual Decl * getCanonicalDecl()

Retrieves the "canonical" declaration of the given declaration.

IdentifierInfo * getAsIdentifierInfo() const

Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn't...

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

This represents one expression.

Represents a function declaration or definition.

bool isTrivial() const

Whether this function is "trivial" in some specialized C++ senses.

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

IdentifierInfo & get(StringRef Name)

Return the identifier token info for the specified named identifier.

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

DeclarationName getDeclName() const

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

Represents a parameter to a function.

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

A (possibly-)qualified type.

bool isNull() const

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

QualType getCanonicalType() const

bool isConstQualified() const

Determine whether this type is const-qualified.

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

bool isInSystemHeader(SourceLocation Loc) const

Returns if a SourceLocation is in a system header.

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.

bool isPointerType() const

CanQualType getCanonicalTypeUnqualified() const

bool isReferenceType() const

const CXXRecordDecl * getPointeeCXXRecordDecl() const

If this is a pointer or reference to a RecordType, return the CXXRecordDecl that the type refers to.

QualType getPointeeType() const

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

bool isObjCObjectPointerType() const

static bool isInCodeFile(SourceLocation SL, const SourceManager &SM)

AnalysisDeclContext * getAnalysisDeclContext(const Decl *D)

AnalysisDeclContextManager & getAnalysisDeclContextManager()

AnalyzerOptions & options

bool shouldInlineCall() const

AnalyzerOptions & getAnalyzerOptions() override

BlockDataRegion - A region that represents a block instance.

Represents a call to a C++ constructor.

const CXXConstructorDecl * getDecl() const override

Returns the declaration of the function or method that will be called.

const CXXConstructExpr * getOriginExpr() const override

Returns the expression whose value will be the result of this call.

Represents a non-static C++ member function call, no matter how it is written.

const FunctionDecl * getDecl() const override

Returns the declaration of the function or method that will be called.

Manages the lifetime of CallEvent objects.

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

CallEventRef getCaller(const StackFrameContext *CalleeCtx, ProgramStateRef State)

Gets an outside caller given a callee context.

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

CallEventRef< T > cloneWithState(ProgramStateRef NewState) const

Returns a copy of this CallEvent, but using the given state.

static QualType getDeclaredResultType(const Decl *D)

Returns the result type of a function or method declaration.

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 runCheckersForPostObjCMessage(ExplodedNodeSet &Dst, const ExplodedNodeSet &Src, const ObjCMethodCall &msg, ExprEngine &Eng, bool wasInlined=false)

Run checkers for post-visiting obj-c messages.

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.

WorkList * getCTUWorkList() const

WorkList * getWorkList() const

void enqueue(ExplodedNodeSet &Set)

Enqueue the given set of nodes onto the work list.

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

ImplTy::iterator iterator

void insert(const ExplodedNodeSet &S)

void Add(ExplodedNode *N)

const ProgramStateRef & getState() const

void addPredecessor(ExplodedNode *V, ExplodedGraph &G)

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

const StackFrameContext * getStackFrame() const

const LocationContext * getLocationContext() const

ProgramStateManager & getStateManager()

void processCallEnter(NodeBuilderContext &BC, CallEnter CE, ExplodedNode *Pred)

Generate the entry node of the callee.

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

Called by CoreEngine.

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.

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 VisitReturnStmt(const ReturnStmt *R, ExplodedNode *Pred, ExplodedNodeSet &Dst)

VisitReturnStmt - Transfer function logic for return statements.

const CoreEngine & getCoreEngine() const

void processCallExit(ExplodedNode *Pred)

Generate the sequence of nodes that simulate the call exit and the post visit for CallExpr.

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

@ Inline_Minimal

Do minimal inlining of callees.

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.

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 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()

CFGBlock::ConstCFGElementRef getCFGElementRef() const

void evalCall(ExplodedNodeSet &Dst, ExplodedNode *Pred, const CallEvent &Call)

Evaluate a call, running pre- and post-call checkers and allowing checkers to be responsible for hand...

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

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

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 removeDeadOnEndOfFunction(NodeBuilderContext &BC, ExplodedNode *Pred, ExplodedNodeSet &Dst)

Remove dead bindings/symbols before exiting a function.

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

Default implementation of call evaluation.

AnalysisManager & getAnalysisManager()

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

Retreives the size of the array in the pending ArrayInitLoopExpr.

std::optional< bool > mayInline(const Decl *D)

void markMayInline(const Decl *D)

unsigned getNumTimesInlined(const Decl *D)

void markShouldNotInline(const Decl *D)

void bumpNumTimesInlined(const Decl *D)

MemRegion - The root abstract class for all memory regions.

LLVM_ATTRIBUTE_RETURNS_NONNULL const MemRegion * StripCasts(bool StripBaseAndDerivedCasts=true) 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 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)

Represents any expression that calls an Objective-C method.

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

CallEventManager & getCallEventManager()

Information about invalidation for a particular region/symbol.

@ TK_DoNotInvalidateSuperRegion

void setTrait(SymbolRef Sym, InvalidationKinds IK)

Defines the runtime definition of the called function.

const MemRegion * getDispatchRegion()

When other definitions are possible, returns the region whose runtime type determines the method defi...

bool mayHaveOtherDefinitions()

Check if the definition we have is precise.

nonloc::ConcreteInt makeIntVal(const IntegerLiteral *integer)

QualType getArrayIndexType() const

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.

SVal evalBinOp(ProgramStateRef state, BinaryOperator::Opcode op, SVal lhs, SVal rhs, QualType type)

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.

QualType getType(const ASTContext &) const

Try to get a reasonable type for the given value.

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.

virtual void enqueue(const WorkListUnit &U)=0

LLVM_ATTRIBUTE_RETURNS_NONNULL const MemRegion * getRegion() const

Get the underlining region.

@ PSK_EscapeOutParameters

Escape for a new symbol that was generated into a region that the analyzer cannot follow during a con...

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

ProgramStateRef setDynamicExtent(ProgramStateRef State, const MemRegion *MR, DefinedOrUnknownSVal Extent)

Set the dynamic extent Extent of the region MR.

@ CE_CXXInheritedConstructor

DefinedOrUnknownSVal getElementExtent(QualType Ty, SValBuilder &SVB)

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

@ IPAK_DynamicDispatch

Enable inlining of dynamically dispatched methods.

@ IPAK_DynamicDispatchBifurcate

Enable inlining of dynamically dispatched methods, bifurcate paths when exact type info is unavailabl...

@ CIMK_Destructors

Refers to destructors (implicit or explicit).

@ CIMK_MemberFunctions

Refers to regular member function and operator calls.

@ CIMK_Constructors

Refers to constructors (implicit or explicit).

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 IsCtorOrDtorWithImproperlyModeledTargetRegion

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

Traits for storing the call processing policy inside GDM.

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