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

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

clang: lib/StaticAnalyzer/Checkers/FuchsiaHandleChecker.cpp Source File

;

StringRef HandleTypeName =

;

StringRef ErrorTypeName =

;

{ MaybeAllocated, Allocated, Released, Escaped, Unowned } K;

HandleState(Kind K,

ErrorSym) : K(K), ErrorSym(ErrorSym) {}

K ==

.K && ErrorSym ==

.ErrorSym;

isAllocated()

{

K == Kind::Allocated; }

maybeAllocated()

{

K == Kind::MaybeAllocated; }

()

{

K == Kind::Released; }

isEscaped()

{

K == Kind::Escaped; }

isUnowned()

{

K == Kind::Unowned; }

HandleState getMaybeAllocated(

ErrorSym) {

HandleState(Kind::MaybeAllocated, ErrorSym);

HandleState getAllocated(

State, HandleState S) {

assert(S.maybeAllocated());

assert(State->getConstraintManager()

.isNull(State, S.getErrorSym())

HandleState(Kind::Allocated,

);

HandleState getReleased() {

HandleState(Kind::Released,

);

HandleState getEscaped() {

HandleState(Kind::Escaped,

);

HandleState getUnowned() {

HandleState(Kind::Unowned,

);

getErrorSym()

{

ErrorSym; }

Profile(llvm::FoldingSetNodeID &ID)

{

.AddInteger(

(K));

.AddPointer(ErrorSym);

LLVM_DUMP_METHOD

(raw_ostream &OS)

{

(Kind::MaybeAllocated)

(Kind::Allocated)

(Kind::Released)

OS <<

;

LLVM_DUMP_METHOD

()

{

(llvm::errs()); }

<

Attr>

hasFuchsiaAttr(

*

) {

<

Attr>

hasFuchsiaUnownedAttr(

*

) {

->

<

>()->getHandleType() ==

;

FuchsiaHandleChecker

:

<check::PostCall, check::PreCall, check::DeadSymbols,

check::PointerEscape, eval::Assume> {

LeakBugType{

,

,

,

DoubleReleaseBugType{

,

,

};

UseAfterReleaseBugType{

,

,

};

,

,

};

Assumption)

;

StringRef Msg)

;

*Sep)

;

(!State->get<HStateMap>(Sym))

N = N->getFirstPred();

State = N->getState();

(!State->get<HStateMap>(Sym)) {

HandleState *HState = Pred->

()->get<HStateMap>(Sym);

(HState && (HState->isAllocated() || HState->maybeAllocated()))

FuchsiaHandleSymbolVisitor final :

{

(

*HandleType = S->getType()->getAs<

>())

(HandleType->getDecl()->getName() == HandleTypeName)

Symbols.push_back(S);

PtrToHandleLevel = 0;

FuchsiaHandleSymbolVisitor Visitor;

State->scanReachableSymbols(Arg, Visitor);

Visitor.GetSymbols();

(HandleType->getDecl()->getName() != HandleTypeName)

(PtrToHandleLevel > 1)

(PtrToHandleLevel == 0) {

assert(PtrToHandleLevel == 1);

(std::optional<Loc> ArgLoc = Arg.

<

>()) {

Sym = State->getSVal(*ArgLoc).getAsSymbol();

FuchsiaHandleChecker::checkPreCall(

&

,

*FuncDecl = dyn_cast_or_null<FunctionDecl>(

.getDecl());

(

Arg = 0; Arg <

.getNumArgs(); ++Arg) {

State = State->set<HStateMap>(Handle, HandleState::getEscaped());

.addTransition(State);

(

Arg = 0; Arg <

.getNumArgs(); ++Arg) {

(hasFuchsiaAttr<ReleaseHandleAttr>(PVD) ||

hasFuchsiaAttr<AcquireHandleAttr>(PVD))

HandleState *HState = State->get<HStateMap>(Handle);

(!HState || HState->isEscaped())

(hasFuchsiaAttr<UseHandleAttr>(PVD) ||

(HState->isReleased()) {

reportUseAfterFree(Handle,

.getArgSourceRange(Arg),

);

.addTransition(State);

FuchsiaHandleChecker::checkPostCall(

&

,

*FuncDecl = dyn_cast_or_null<FunctionDecl>(

.getDecl());

std::vector<std::function<std::string(

& BR)>> Notes;

(TypeDefTy->getDecl()->getName() == ErrorTypeName)

ResultSymbol =

.getReturnValue().getAsSymbol();

(hasFuchsiaAttr<AcquireHandleAttr>(FuncDecl)) {

Notes.push_back([RetSym, FuncDecl](

&BR) -> std::string {

(PathBR->getInterestingnessKind(RetSym)) {

llvm::raw_string_ostream OS(SBuf);

<<

;

State->set<HStateMap>(RetSym, HandleState::getMaybeAllocated(

));

}

(hasFuchsiaUnownedAttr<AcquireHandleAttr>(FuncDecl)) {

Notes.push_back([RetSym, FuncDecl](

&BR) -> std::string {

(PathBR->getInterestingnessKind(RetSym)) {

llvm::raw_string_ostream OS(SBuf);

<<

;

State = State->set<HStateMap>(RetSym, HandleState::getUnowned());

(

Arg = 0; Arg <

.getNumArgs(); ++Arg) {

HandleState *HState = State->get<HStateMap>(Handle);

(HState && HState->isEscaped())

(hasFuchsiaAttr<ReleaseHandleAttr>(PVD)) {

(HState && HState->isReleased()) {

reportDoubleRelease(Handle,

.getArgSourceRange(Arg),

);

}

(HState && HState->isUnowned()) {

reportUnownedRelease(Handle,

.getArgSourceRange(Arg),

);

Notes.push_back([Handle, ParamDiagIdx](

&BR) -> std::string {

(PathBR->getInterestingnessKind(Handle)) {

llvm::raw_string_ostream OS(SBuf);

OS <<

<< ParamDiagIdx

<< llvm::getOrdinalSuffix(ParamDiagIdx) <<

;

State = State->set<HStateMap>(Handle, HandleState::getReleased());

}

(hasFuchsiaAttr<AcquireHandleAttr>(PVD)) {

Notes.push_back([Handle, ParamDiagIdx](

&BR) -> std::string {

(PathBR->getInterestingnessKind(Handle)) {

llvm::raw_string_ostream OS(SBuf);

OS <<

<< ParamDiagIdx

<< llvm::getOrdinalSuffix(ParamDiagIdx) <<

;

State = State->set<HStateMap>(

Handle, HandleState::getMaybeAllocated(ResultSymbol));

}

(hasFuchsiaUnownedAttr<AcquireHandleAttr>(PVD)) {

Notes.push_back([Handle, ParamDiagIdx](

&BR) -> std::string {

(PathBR->getInterestingnessKind(Handle)) {

llvm::raw_string_ostream OS(SBuf);

OS <<

<< ParamDiagIdx

<< llvm::getOrdinalSuffix(ParamDiagIdx) <<

;

State = State->set<HStateMap>(Handle, HandleState::getUnowned());

}

(!hasFuchsiaAttr<UseHandleAttr>(PVD) &&

State = State->set<HStateMap>(Handle, HandleState::getEscaped());

(!Notes.empty()) {

=

.getNoteTag([

, Notes{std::move(Notes)}](

(&BR.

() != &UseAfterReleaseBugType &&

&BR.

() != &DoubleReleaseBugType &&

(

&

: Notes) {

.addTransition(State,

);

FuchsiaHandleChecker::checkDeadSymbols(

&SymReaper,

HStateMapTy TrackedHandles = State->get<HStateMap>();

(

&CurItem : TrackedHandles) {

ErrorSym = CurItem.second.getErrorSym();

(!SymReaper.

(CurItem.first) ||

(ErrorSym && !SymReaper.

(ErrorSym)))

(CurItem.second.isAllocated() || CurItem.second.maybeAllocated())

LeakedSyms.push_back(CurItem.first);

State = State->remove<HStateMap>(CurItem.first);

(!LeakedSyms.empty())

N = reportLeaks(LeakedSyms,

, N);

.addTransition(State, N);

Assumption)

{

HStateMapTy TrackedHandles = State->get<HStateMap>();

(

&CurItem : TrackedHandles) {

State = State->remove<HStateMap>(CurItem.first);

ErrorSym = CurItem.second.getErrorSym();

(CurItem.second.maybeAllocated())

State = State->set<HStateMap>(

CurItem.first, HandleState::getAllocated(State, CurItem.second));

(CurItem.second.maybeAllocated())

State = State->remove<HStateMap>(CurItem.first);

? dyn_cast_or_null<FunctionDecl>(

->getDecl()) : nullptr;

llvm::DenseSet<SymbolRef> UnEscaped;

(

Arg = 0; Arg <

->getNumArgs(); ++Arg) {

(hasFuchsiaAttr<UseHandleAttr>(PVD) ||

hasFuchsiaAttr<ReleaseHandleAttr>(PVD)) {

UnEscaped.insert(Handle);

(

I : State->get<HStateMap>()) {

(Escaped.count(I.first) && !UnEscaped.count(I.first))

State = State->set<HStateMap>(I.first, HandleState::getEscaped());

(

*SD = dyn_cast<SymbolDerived>(I.first)) {

ParentSym = SD->getParentSymbol();

(Escaped.count(ParentSym))

State = State->set<HStateMap>(I.first, HandleState::getEscaped());

*ErrNode =

.generateNonFatalErrorNode(

.getState(), Pred);

(

LeakedHandle : LeakedHandles) {

reportBug(LeakedHandle, ErrNode,

,

, LeakBugType,

);

FuchsiaHandleChecker::reportDoubleRelease(

HandleSym,

reportBug(HandleSym, ErrNode,

, &

, DoubleReleaseBugType,

);

FuchsiaHandleChecker::reportUnownedRelease(

HandleSym,

reportBug(HandleSym, ErrNode,

, &

, ReleaseUnownedBugType,

);

FuchsiaHandleChecker::reportUseAfterFree(

HandleSym,

reportBug(HandleSym, ErrNode,

, &

, UseAfterReleaseBugType,

);

std::unique_ptr<PathSensitiveBugReport> R;

(

.isSuppressOnSink()) {

assert(S &&

);

R = std::make_unique<PathSensitiveBugReport>(

, Msg, ErrorNode, LocUsedForUniqueing,

R = std::make_unique<PathSensitiveBugReport>(

, Msg, ErrorNode);

R->addRange(*

);

R->markInteresting(Sym);

.emitReport(std::move(R));

ento::shouldRegisterFuchsiaHandleChecker(

&mgr) {

FuchsiaHandleChecker::printState(raw_ostream &Out,

State,

*NL,

*Sep)

{

HStateMapTy StateMap = State->get<HStateMap>();

(!StateMap.isEmpty()) {

Out << Sep <<

<< NL;

(

&[Sym, HandleState] : StateMap) {

HandleState.dump(Out);

static void dump(llvm::raw_ostream &OS, StringRef FunctionName, ArrayRef< CounterExpression > Expressions, ArrayRef< CounterMappingRegion > Regions)

static const ExplodedNode * getAcquireSite(const ExplodedNode *N, SymbolRef Sym, CheckerContext &Ctx)

static SmallVector< SymbolRef, 1024 > getFuchsiaHandleSymbols(QualType QT, SVal Arg, ProgramStateRef State)

Returns the symbols extracted from the argument or empty vector if it cannot be found.

static bool isReleased(SymbolRef Sym, CheckerContext &C)

Check if the memory associated with this symbol was released.

#define REGISTER_MAP_WITH_PROGRAMSTATE(Name, Key, Value)

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

C Language Family Type Representation.

Attr - This represents one attribute.

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

Represents a function declaration or definition.

const ParmVarDecl * getParamDecl(unsigned i) const

QualType getReturnType() const

unsigned getNumParams() const

Return the number of parameters this function must have based on its FunctionType.

const Decl * getDecl() const

DeclarationName getDeclName() const

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

Represents a parameter to a function.

unsigned getFunctionScopeIndex() const

Returns the index of this parameter in its prototype or method scope.

A (possibly-)qualified type.

A trivial tuple used to represent a source range.

Stmt - This represents one statement.

The base class of the type hierarchy.

bool isStructureType() const

bool isIntegerType() const

isIntegerType() does not include complex integers (a GCC extension).

bool isReferenceType() const

QualType getPointeeType() const

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

bool isAnyPointerType() const

const T * getAs() const

Member-template getAs<specific type>'.

This class provides an interface through which checkers can create individual bug reports.

const BugType & getBugType() const

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

virtual void printState(raw_ostream &Out, ProgramStateRef State, const char *NL, const char *Sep) const

See CheckerManager::runCheckersForPrintState.

CHECKER * registerChecker(AT &&... Args)

Used to register checkers.

bool isConstrainedFalse() const

Return true if the constraint is perfectly constrained to 'false'.

bool isConstrainedTrue() const

Return true if the constraint is perfectly constrained to 'true'.

ConditionTruthVal isNull(ProgramStateRef State, SymbolRef Sym)

Convenience method to query the state to see if a symbol is null or not null, or if neither assumptio...

const ProgramStateRef & getState() const

const Stmt * getStmtForDiagnostics() const

If the node's program point corresponds to a statement, retrieve that statement.

const LocationContext * getLocationContext() const

ExplodedNode * getFirstPred()

The tag upon which the TagVisitor reacts.

static PathDiagnosticLocation createBegin(const Decl *D, const SourceManager &SM)

Create a location for the beginning of the declaration.

A Range represents the closed range [from, to].

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

SymbolRef getAsSymbol(bool IncludeBaseRegions=false) const

If this SVal wraps a symbol return that SymbolRef.

std::optional< T > getAs() const

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

virtual void dumpToStream(raw_ostream &os) const

A class responsible for cleaning up unused symbols.

bool isDead(SymbolRef sym)

Returns whether or not a symbol has been confirmed dead.

virtual bool VisitSymbol(SymbolRef sym)=0

A visitor method invoked by ProgramStateManager::scanReachableSymbols.

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.

@ PSK_EscapeOutParameters

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

llvm::DenseSet< SymbolRef > InvalidatedSymbols

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

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

const FunctionProtoType * T

@ Other

Other implicit parameter.

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