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

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

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

;

IfAnyAreNonEmpty = [](

&... Callbacks) ->

{

(!Callbacks.empty() || ...);

IfAnyAreNonEmpty(

StmtCheckers, PreObjCMessageCheckers, ObjCMessageNilCheckers,

PostObjCMessageCheckers, PreCallCheckers, PostCallCheckers,

LocationCheckers, BindCheckers, EndAnalysisCheckers,

BeginFunctionCheckers, EndFunctionCheckers, BranchConditionCheckers,

NewAllocatorCheckers, LiveSymbolsCheckers, DeadSymbolsCheckers,

RegionChangesCheckers, PointerEscapeCheckers, EvalAssumeCheckers,

EvalCallCheckers, EndOfTranslationUnitCheckers);

StringRef ExpectedValueDesc)

{

<< (llvm::Twine() +

->getTagDescription() +

+ OptionName).str()

[CCI, Inserted] = CachedDeclCheckersMap.try_emplace(DeclKind);

(

&info : DeclCheckers)

(info.IsForDeclFn(

))

checkers->push_back(info.CheckFn);

(

&checker : *checkers)

checker(

, mgr, BR);

(

&BodyChecker : BodyCheckers)

BodyChecker(

, mgr, BR);

<

CHECK_CTX>

CHECK_CTX::CheckersTy::const_iterator

I = checkCtx.checkers_begin(),

= checkCtx.checkers_end();

(; I !=

; ++I) {

CurrSet = (PrevSet == &Tmp1) ? &Tmp2 : &Tmp1;

(

&NI : *PrevSet)

checkCtx.runChecker(*I, B, NI);

(CurrSet->

())

CheckStmtContext {

CheckersTy &Checkers;

CheckStmtContext(

isPreVisit,

CheckersTy &checkers,

: IsPreVisit(isPreVisit), Checkers(checkers), S(

), Eng(eng),

WasInlined(wasInlined) {}

CheckersTy::const_iterator checkers_begin() {

Checkers.begin(); }

CheckersTy::const_iterator checkers_end() {

Checkers.end(); }

CheckStmtContext

(isPreVisit, getCachedStmtCheckersFor(S, isPreVisit),

CheckObjCMessageContext {

CheckersTy = std::vector<CheckerManager::CheckObjCMessageFunc>;

CheckersTy &Checkers;

CheckersTy &checkers,

:

(visitKind), WasInlined(wasInlined), Checkers(checkers), Msg(msg),

CheckersTy::const_iterator checkers_begin() {

Checkers.begin(); }

CheckersTy::const_iterator checkers_end() {

Checkers.end(); }

ObjCMessageVisitKind::Pre:

ObjCMessageVisitKind::MessageNil:

ObjCMessageVisitKind::Post:

&checkers = getObjCMessageCheckers(visitKind);

CheckObjCMessageContext

(visitKind, checkers, msg, Eng, WasInlined);

std::vector<CheckerManager::CheckObjCMessageFunc> &

PreObjCMessageCheckers;

PostObjCMessageCheckers;

ObjCMessageNilCheckers;

llvm_unreachable(

);

CheckCallContext {

CheckersTy = std::vector<CheckerManager::CheckCallFunc>;

IsPreVisit, WasInlined;

CheckersTy &Checkers;

CheckCallContext(

isPreVisit,

CheckersTy &checkers,

: IsPreVisit(isPreVisit), WasInlined(wasInlined), Checkers(checkers),

(call), Eng(eng) {}

CheckersTy::const_iterator checkers_begin() {

Checkers.begin(); }

CheckersTy::const_iterator checkers_end() {

Checkers.end(); }

CheckCallContext

(isPreVisit,

isPreVisit ? PreCallCheckers

, Eng, WasInlined);

CheckLocationContext {

CheckersTy = std::vector<CheckerManager::CheckLocationFunc>;

CheckersTy &Checkers;

CheckLocationContext(

CheckersTy &checkers,

loc,

isLoad,

*NodeEx,

: Checkers(checkers),

(loc), IsLoad(isLoad), NodeEx(NodeEx),

BoundEx(BoundEx), Eng(eng) {}

CheckersTy::const_iterator checkers_begin() {

Checkers.begin(); }

CheckersTy::const_iterator checkers_end() {

Checkers.end(); }

checkFn(

, IsLoad, BoundEx,

);

location,

isLoad,

CheckLocationContext

(LocationCheckers, location, isLoad, NodeEx,

CheckBindContext {

CheckersTy = std::vector<CheckerManager::CheckBindFunc>;

CheckersTy &Checkers;

CheckBindContext(

CheckersTy &checkers,

: Checkers(checkers),

(loc), Val(val), S(

), Eng(eng), PP(pp) {}

CheckersTy::const_iterator checkers_begin() {

Checkers.begin(); }

CheckersTy::const_iterator checkers_end() {

Checkers.end(); }

checkFn(

, Val, S,

);

CheckBindContext

(BindCheckers, location, val, S, Eng, PP);

(

&EndAnalysisChecker : EndAnalysisCheckers)

EndAnalysisChecker(G, BR, Eng);

CheckBeginFunctionContext {

CheckersTy = std::vector<CheckerManager::CheckBeginFunctionFunc>;

CheckersTy &Checkers;

CheckBeginFunctionContext(

CheckersTy &Checkers,

&Eng,

: Checkers(Checkers), Eng(Eng), PP(PP) {}

CheckersTy::const_iterator checkers_begin() {

Checkers.begin(); }

CheckersTy::const_iterator checkers_end() {

Checkers.end(); }

CheckBeginFunctionContext

(BeginFunctionCheckers, Eng, L);

(

&checkFn : EndFunctionCheckers) {

CheckBranchConditionContext {

CheckersTy = std::vector<CheckerManager::CheckBranchConditionFunc>;

CheckersTy &Checkers;

CheckBranchConditionContext(

CheckersTy &checkers,

: Checkers(checkers),

(Cond), Eng(eng) {}

CheckersTy::const_iterator checkers_begin() {

Checkers.begin(); }

CheckersTy::const_iterator checkers_end() {

Checkers.end(); }

CheckBranchConditionContext

(BranchConditionCheckers,

, Eng);

CheckNewAllocatorContext {

CheckersTy = std::vector<CheckerManager::CheckNewAllocatorFunc>;

CheckersTy &Checkers;

CheckNewAllocatorContext(

CheckersTy &Checkers,

: Checkers(Checkers),

(

), WasInlined(WasInlined), Eng(Eng) {}

CheckersTy::const_iterator checkers_begin() {

Checkers.begin(); }

CheckersTy::const_iterator checkers_end() {

Checkers.end(); }

checkFn(cast<CXXAllocatorCall>(*

.cloneWithState(Pred->

())),

CheckNewAllocatorContext

(NewAllocatorCheckers,

, WasInlined, Eng);

(

&LiveSymbolsChecker : LiveSymbolsCheckers)

LiveSymbolsChecker(state, SymReaper);

CheckDeadSymbolsContext {

CheckersTy = std::vector<CheckerManager::CheckDeadSymbolsFunc>;

CheckersTy &Checkers;

CheckDeadSymbolsContext(

CheckersTy &checkers,

&sr,

: Checkers(checkers), SR(sr), S(

), Eng(eng), ProgarmPointKind(K) {}

CheckersTy::const_iterator checkers_begin() {

Checkers.begin(); }

CheckersTy::const_iterator checkers_end() {

Checkers.end(); }

CheckDeadSymbolsContext

(DeadSymbolsCheckers, SymReaper, S, Eng, K);

(

&RegionChangesChecker : RegionChangesCheckers) {

state = RegionChangesChecker(state, invalidated, ExplicitRegions, Regions,

assert((

!=

||

);

(

&PointerEscapeChecker : PointerEscapeCheckers) {

State = PointerEscapeChecker(State, Escaped,

, Kind, ETraits);

Cond,

Assumption) {

(

&EvalAssumeChecker : EvalAssumeCheckers) {

state = EvalAssumeChecker(state, Cond, Assumption);

(

*

Pred : Src) {

std::optional<CheckerNameRef> evaluatorChecker;

(

&EvalCallChecker : EvalCallCheckers) {

Pred->getLocationContext(), EvalCallChecker.Checker);

evaluated =

;

evaluated = EvalCallChecker(

,

);

(evaluated && evaluatorChecker) {

llvm::raw_string_ostream

(Buf);

std::string AssertionMessage = llvm::formatv(

,

EvalCallChecker.Checker->getCheckerName());

llvm_unreachable(AssertionMessage.c_str());

evaluatorChecker = EvalCallChecker.Checker->getCheckerName();

(!evaluatorChecker) {

(

&EndOfTranslationUnitChecker : EndOfTranslationUnitCheckers)

EndOfTranslationUnitChecker(TU, mgr, BR);

Indent(Out, Space, IsDot) <<

;

llvm::raw_svector_ostream TempOut(TempBuf);

InnerSpace = Space + 2;

llvm::raw_svector_ostream NLOut(

);

NLOut <<

<< NL;

Indent(NLOut, InnerSpace, IsDot) <<

;

HasMessage =

;

*LastCT =

;

(

&CT : CheckerTags) {

CT.second->printState(TempOut, State,

.c_str(),

);

(

&CT : CheckerTags) {

CT.second->printState(TempOut, State,

.c_str(),

);

Indent(Out, Space, IsDot)

<<

<< CT.second->getCheckerName().getName()

<<

<< NL;

Indent(Out, InnerSpace, IsDot)

<<

<< TempBuf.str().trim() <<

<< NL;

Indent(Out, Space, IsDot) <<

;

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

;

DeclCheckerInfo info = { checkfn, isForDeclFn };

DeclCheckers.push_back(info);

BodyCheckers.push_back(checkfn);

StmtCheckerInfo info = { checkfn, isForStmtFn,

};

StmtCheckers.push_back(info);

StmtCheckerInfo info = { checkfn, isForStmtFn,

};

StmtCheckers.push_back(info);

PreObjCMessageCheckers.push_back(checkfn);

ObjCMessageNilCheckers.push_back(checkfn);

PostObjCMessageCheckers.push_back(checkfn);

PreCallCheckers.push_back(checkfn);

PostCallCheckers.push_back(checkfn);

LocationCheckers.push_back(checkfn);

BindCheckers.push_back(checkfn);

EndAnalysisCheckers.push_back(checkfn);

BeginFunctionCheckers.push_back(checkfn);

EndFunctionCheckers.push_back(checkfn);

BranchConditionCheckers.push_back(checkfn);

NewAllocatorCheckers.push_back(checkfn);

LiveSymbolsCheckers.push_back(checkfn);

DeadSymbolsCheckers.push_back(checkfn);

RegionChangesCheckers.push_back(checkfn);

PointerEscapeCheckers.push_back(checkfn);

PointerEscapeCheckers.push_back(checkfn);

EvalAssumeCheckers.push_back(checkfn);

EvalCallCheckers.push_back(checkfn);

EndOfTranslationUnitCheckers.push_back(checkfn);

CheckerManager::getCachedStmtCheckersFor(

*S,

isPreVisit) {

Key = (S->getStmtClass() << 1) |

(isPreVisit);

[CCI, Inserted] = CachedStmtCheckersMap.try_emplace(Key);

CachedStmtCheckers &Checkers = CCI->second;

(

&Info : StmtCheckers)

(Info.IsPreVisit == isPreVisit && Info.IsForStmtFn(S))

Checkers.push_back(Info.CheckFn);

enum clang::sema::@1704::IndirectLocalPathEntry::EntryKind Kind

static void expandGraphWithCheckers(CHECK_CTX checkCtx, ExplodedNodeSet &Dst, const ExplodedNodeSet &Src)

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

static std::string toString(const clang::SanitizerSet &Sanitizers)

Produce a string containing comma-separated names of sanitizers in Sanitizers set.

__device__ __2f16 float __ockl_bool s

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

virtual bool hasBody() const

Returns true if this Decl represents a declaration for a body of code, such as a function or method d...

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

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

static ProgramPoint getProgramPoint(const Stmt *S, ProgramPoint::Kind K, const LocationContext *LC, const ProgramPointTag *tag)

ProgramPoint withTag(const ProgramPointTag *tag) const

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

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

Stmt - This represents one statement.

The top declaration context.

BugReporter is a utility class for generating PathDiagnostics for analysis.

Represents the memory allocation call in a C++ new-expression.

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.

ProgramPoint getProgramPoint(bool IsPreVisit=false, const ProgramPointTag *Tag=nullptr) const

Returns an appropriate ProgramPoint for this call.

void _registerForLiveSymbols(CheckLiveSymbolsFunc checkfn)

void _registerForEndOfTranslationUnit(CheckEndOfTranslationUnit checkfn)

void _registerForBeginFunction(CheckBeginFunctionFunc checkfn)

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 _registerForNewAllocator(CheckNewAllocatorFunc checkfn)

void _registerForPreCall(CheckCallFunc checkfn)

void _registerForObjCMessageNil(CheckObjCMessageFunc checkfn)

bool(*)(const Decl *D) HandlesDeclFunc

void runCheckersForObjCMessage(ObjCMessageVisitKind visitKind, ExplodedNodeSet &Dst, const ExplodedNodeSet &Src, const ObjCMethodCall &msg, ExprEngine &Eng, bool wasInlined=false)

Run checkers for visiting obj-c messages.

void runCheckersOnASTDecl(const Decl *D, AnalysisManager &mgr, BugReporter &BR)

Run checkers handling Decls.

void reportInvalidCheckerOptionValue(const CheckerBase *C, StringRef OptionName, StringRef ExpectedValueDesc) const

Emits an error through a DiagnosticsEngine about an invalid user supplied checker option value.

void _registerForDecl(CheckDeclFunc checkfn, HandlesDeclFunc isForDeclFn)

void _registerForPreObjCMessage(CheckObjCMessageFunc checkfn)

void runCheckersOnEndOfTranslationUnit(const TranslationUnitDecl *TU, AnalysisManager &mgr, BugReporter &BR)

Run checkers for the entire Translation Unit.

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

Run checkers on end of function.

void _registerForEvalAssume(EvalAssumeFunc checkfn)

void _registerForEndAnalysis(CheckEndAnalysisFunc checkfn)

void _registerForBody(CheckDeclFunc checkfn)

DiagnosticsEngine & getDiagnostics() const

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 _registerForDeadSymbols(CheckDeadSymbolsFunc checkfn)

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 _registerForPostObjCMessage(CheckObjCMessageFunc checkfn)

void _registerForRegionChanges(CheckRegionChangesFunc checkfn)

bool hasPathSensitiveCheckers() const

void _registerForBind(CheckBindFunc checkfn)

void runCheckersForLiveSymbols(ProgramStateRef state, SymbolReaper &SymReaper)

Run checkers for live symbols.

void _registerForPointerEscape(CheckPointerEscapeFunc checkfn)

void _registerForPreStmt(CheckStmtFunc checkfn, HandlesStmtFunc isForStmtFn)

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

Run checkers for evaluating a call.

void _registerForPostStmt(CheckStmtFunc checkfn, HandlesStmtFunc isForStmtFn)

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

Run checkers on beginning of function.

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

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

void _registerForBranchCondition(CheckBranchConditionFunc checkfn)

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

Run checkers for visiting Stmts.

void _registerForEvalCall(EvalCallFunc checkfn)

void _registerForEndFunction(CheckEndFunctionFunc checkfn)

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

Run checkers for branch condition.

void _registerForLocation(CheckLocationFunc checkfn)

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

Run checkers when pointers escape.

void _registerForConstPointerEscape(CheckPointerEscapeFunc checkfn)

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

Run checkers for visiting obj-c messages.

bool(*)(const Stmt *D) HandlesStmtFunc

void _registerForPostCall(CheckCallFunc checkfn)

void runCheckersOnASTBody(const Decl *D, AnalysisManager &mgr, BugReporter &BR)

Run checkers handling Decls containing a Stmt body.

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

Run checkers for handling assumptions on symbolic values.

void insert(const ExplodedNodeSet &S)

const ProgramStateRef & getState() const

const LocationContext * getLocationContext() const

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

Default implementation of call evaluation.

const NodeBuilderContext & getBuilderContext()

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

Represents any expression that calls an Objective-C method.

Information about invalidation for a particular region/symbol.

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

A class responsible for cleaning up unused symbols.

PointerEscapeKind

Describes the different reasons a pointer escapes during analysis.

@ PSK_DirectEscapeOnCall

The pointer has been passed to a function call directly.

@ PSK_IndirectEscapeOnCall

The pointer has been passed to a function indirectly.

@ OS

Indicates that the tracking object is a descendant of a referenced-counted OSObject,...

llvm::DenseSet< SymbolRef > InvalidatedSymbols

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

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

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