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

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

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

;

std::min(

(Lhs),

(Rhs)));

*getNullabilityString(

Nullab) {

Nullability::Contradicted:

;

Nullability::Nullable:

Nullability::Unspecified:

;

Nullability::Nonnull:

llvm_unreachable(

);

ErrorKind :

{

NullableAssignedToNonnull,

NullableReturnedToNonnull,

NullablePassedToNonnull

NullabilityChecker

:

<check::Bind, check::PreCall, check::PreStmt<ReturnStmt>,

check::PostCall, check::PostStmt<ExplicitCastExpr>,

check::PostObjCMessage, check::DeadSymbols, eval::Assume,

check::Location, check::Event<ImplicitNullDerefEvent>,

check::BeginFunction> {

NoDiagnoseCallsToSystemHeaders =

;

checkLocation(

Location,

IsLoad,

*S,

Assumption)

;

*Sep)

;

CK_NullPassedToNonnull,

CK_NullReturnedFromNonnull,

CK_NullableDereferenced,

CK_NullablePassedToNonnull,

CK_NullableReturnedFromNonnull,

ChecksEnabled[CK_NumCheckKinds] = {

};

std::unique_ptr<BugType> BTs[CK_NumCheckKinds];

std::unique_ptr<BugType> &getBugType(CheckKind Kind)

{

BTs[

].reset(

(CheckNames[Kind],

,

NeedTracking =

;

NullabilityBugVisitor(

*M) : Region(M) {}

Profile(llvm::FoldingSetNodeID &ID)

{

.AddPointer(&

);

.AddPointer(Region);

reportBugIfInvariantHolds(StringRef Msg, ErrorKind Error, CheckKind CK,

*ValueExpr =

,

SuppressPath =

)

;

reportBug(StringRef Msg, ErrorKind Error, CheckKind CK,

*N,

*ValueExpr =

)

{

std::unique_ptr<BugType> &BT = getBugType(CK);

R = std::make_unique<PathSensitiveBugReport>(*BT, Msg, N);

R->markInteresting(Region);

R->addVisitor<NullabilityBugVisitor>(Region);

R->addRange(ValueExpr->getSourceRange());

(Error == ErrorKind::NilAssignedToNonnull ||

Error == ErrorKind::NilPassedToNonnull ||

Error == ErrorKind::NilReturnedToNonnull)

(

*Ex = dyn_cast<Expr>(ValueExpr))

CheckSuperRegion =

)

;

(NoDiagnoseCallsToSystemHeaders &&

.isInSystemHeader())

NullabilityState {

: Nullab(Nullab), Source(Source) {}

*getNullabilitySource()

{

Source; }

Profile(llvm::FoldingSetNodeID &ID)

{

.AddInteger(

(Nullab));

.AddPointer(Source);

(raw_ostream &Out)

{

Out << getNullabilityString(Nullab) <<

;

(NullabilityState Lhs, NullabilityState Rhs) {

Lhs.getValue() == Rhs.getValue() &&

Lhs.getNullabilitySource() == Rhs.getNullabilitySource();

= std::pair<const MemRegion *, const IdentifierInfo *>;

ConstrainedPropertyVal {

isConstrainedNonnull;

:

(SV), isConstrainedNonnull(

) {}

Profile(llvm::FoldingSetNodeID &ID)

{

.AddInteger(isConstrainedNonnull ? 1 : 0);

(

ConstrainedPropertyVal &Lhs,

ConstrainedPropertyVal &Rhs) {

Lhs.Value == Rhs.Value &&

Lhs.isConstrainedNonnull == Rhs.isConstrainedNonnull;

ConstrainedPropertyVal)

NullabilityChecker::getTrackRegion(

Val,

CheckSuperRegion)

{

*Region = RegionSVal->getRegion();

(CheckSuperRegion) {

(

*ER = dyn_cast<ElementRegion>(FieldReg->getSuperRegion()))

dyn_cast<SymbolicRegion>(FieldReg->getSuperRegion());

dyn_cast<SymbolicRegion>(ElementReg->getSuperRegion());

dyn_cast<SymbolicRegion>(Region);

NullabilityState *TrackedNullab = State->get<NullabilityMap>(Region);

NullabilityState *TrackedNullabPrev =

StatePrev->get<NullabilityMap>(Region);

(TrackedNullabPrev &&

TrackedNullabPrev->getValue() == TrackedNullab->getValue())

*S = TrackedNullab->getNullabilitySource();

(!S || S->getBeginLoc().isInvalid()) {

std::string InfoText =

(llvm::Twine(

) +

getNullabilityString(TrackedNullab->getValue()) +

)

std::make_shared<PathDiagnosticEventPiece>(Pos, InfoText,

);

(!StoredVal || !isa<SymbolicRegion>(StoredVal->getRegion()))

(

*ParamDecl : Params) {

(ParamDecl->isParameterPack())

LV = State->getLValue(ParamDecl, LocCtxt);

*MD = dyn_cast<ObjCMethodDecl>(LocCtxt->

());

(!MD || !MD->isInstanceMethod())

SelfVal = State->getSVal(State->getRegion(SelfDecl, LocCtxt));

dyn_cast<ObjCObjectPointerType>(SelfDecl->

());

(

*IvarDecl : ID->ivars()) {

LV = State->getLValue(IvarDecl, SelfVal);

(State->get<InvariantViolated>())

(

*BD = dyn_cast<BlockDecl>(

))

Params = BD->parameters();

(

*FD = dyn_cast<FunctionDecl>(

))

Params = FD->parameters();

(

*MD = dyn_cast<ObjCMethodDecl>(

))

Params = MD->parameters();

.addTransition(State->set<InvariantViolated>(

), N);

NullabilityChecker::reportBugIfInvariantHolds(

StringRef Msg, ErrorKind Error, CheckKind CK,

*N,

SuppressPath)

{

OriginalState = OriginalState->set<InvariantViolated>(

);

N =

.addTransition(OriginalState, N);

reportBug(Msg, Error, CK, N, Region,

.getBugReporter(), ValueExpr);

NullabilityChecker::checkDeadSymbols(

&SR,

NullabilityMapTy Nullabilities = State->get<NullabilityMap>();

(

*Reg : llvm::make_first_range(Nullabilities)) {

assert(Region &&

);

(SR.

(Region->getSymbol())) {

State = State->remove<NullabilityMap>(Reg);

PropertyAccessesMapTy PropertyAccesses = State->get<PropertyAccessesMap>();

(

PropKey : llvm::make_first_range(PropertyAccesses)) {

*ReceiverRegion = PropKey.first;

State = State->remove<PropertyAccessesMap>(PropKey);

.addTransition(State);

getTrackRegion(Event.

,

);

NullabilityState *TrackedNullability =

State->get<NullabilityMap>(Region);

(!TrackedNullability)

(ChecksEnabled[CK_NullableDereferenced] &&

TrackedNullability->getValue() == Nullability::Nullable) {

reportBug(

,

ErrorKind::NullableDereferenced, CK_NullableDereferenced,

reportBug(

ErrorKind::NullablePassedToNonnull, CK_NullableDereferenced,

NullabilityChecker::checkBeginFunction(

&

)

{

(!

.inTopFrame())

(!AbstractCall || AbstractCall->parameters().empty())

(

*Param : AbstractCall->parameters()) {

(RequiredNullability != Nullability::Nullable)

*ParamRegion = State->getRegion(Param, LCtx);

State->getSVal(ParamRegion).getAsRegion();

(!ParamPointeeRegion)

State = State->set<NullabilityMap>(ParamPointeeRegion,

NullabilityState(RequiredNullability));

.addTransition(State);

NullabilityChecker::checkLocation(

Location,

IsLoad,

dyn_cast_or_null<TypedValueRegion>(Location.

());

(NullabilityOfTheLoadedValue == Nullability::Nonnull) {

Context.addTransition(NewState);

NullabilityChecker::checkPreStmt(

*S,

RetExpr = S->getRetValue();

(State->get<InvariantViolated>())

InSuppressedMethodFamily =

;

.getLocationContext()->getAnalysisDeclContext();

(

*MD = dyn_cast<ObjCMethodDecl>(

)) {

InSuppressedMethodFamily =

;

RequiredRetType = MD->getReturnType();

}

(

*FD = dyn_cast<FunctionDecl>(

)) {

RequiredRetType = FD->getReturnType();

(

*FunDecl =

.getLocationContext()->getDecl();

FunDecl && FunDecl->getAttr<ReturnsNonNullAttr>() &&

(RequiredNullability == Nullability::Unspecified ||

RequiredNullability == Nullability::Nullable)) {

RequiredNullability = Nullability::Nonnull;

NullReturnedFromNonNull = (RequiredNullability == Nullability::Nonnull &&

(ChecksEnabled[CK_NullReturnedFromNonnull] && NullReturnedFromNonNull &&

RetExprTypeLevelNullability != Nullability::Nonnull &&

!InSuppressedMethodFamily) {

llvm::raw_svector_ostream OS(SBuf);

OS << (RetExpr->getType()->isObjCObjectPointerType() ?

:

);

OS <<

<<

.getDeclDescription(

) <<

;

reportBugIfInvariantHolds(OS.str(), ErrorKind::NilReturnedToNonnull,

CK_NullReturnedFromNonnull, N,

,

,

(NullReturnedFromNonNull) {

State = State->set<InvariantViolated>(

);

.addTransition(State);

*Region = getTrackRegion(*RetSVal);

NullabilityState *TrackedNullability =

State->get<NullabilityMap>(Region);

(TrackedNullability) {

TrackedNullabValue = TrackedNullability->getValue();

(ChecksEnabled[CK_NullableReturnedFromNonnull] &&

TrackedNullabValue == Nullability::Nullable &&

RequiredNullability == Nullability::Nonnull) {

*N =

.addTransition(State,

.getPredecessor(), &Tag);

llvm::raw_svector_ostream OS(SBuf);

OS <<

<<

.getDeclDescription(

) <<

;

reportBugIfInvariantHolds(OS.str(), ErrorKind::NullableReturnedToNonnull,

CK_NullableReturnedFromNonnull, N, Region,

);

(RequiredNullability == Nullability::Nullable) {

State = State->set<NullabilityMap>(Region,

NullabilityState(RequiredNullability,

.addTransition(State);

NullabilityChecker::checkPreCall(

&

,

(!

.getDecl())

(State->get<InvariantViolated>())

(Param->isParameterPack())

(Idx >=

.getNumArgs())

*ArgExpr =

.getArgExpr(Idx);

!Param->getType()->isReferenceType())

= Param->getFunctionScopeIndex() + 1;

(ChecksEnabled[CK_NullPassedToNonnull] &&

ArgExprTypeLevelNullability != Nullability::Nonnull &&

RequiredNullability == Nullability::Nonnull &&

isDiagnosableCall(

)) {

llvm::raw_svector_ostream OS(SBuf);

OS << (Param->getType()->isObjCObjectPointerType() ?

:

);

OS <<

<<

<< llvm::getOrdinalSuffix(

) <<

;

reportBugIfInvariantHolds(OS.str(), ErrorKind::NilPassedToNonnull,

CK_NullPassedToNonnull, N,

,

, ArgExpr,

*Region = getTrackRegion(*ArgSVal);

NullabilityState *TrackedNullability =

State->get<NullabilityMap>(Region);

(TrackedNullability) {

TrackedNullability->getValue() != Nullability::Nullable)

(ChecksEnabled[CK_NullablePassedToNonnull] &&

RequiredNullability == Nullability::Nonnull &&

isDiagnosableCall(

)) {

llvm::raw_svector_ostream OS(SBuf);

OS <<

reportBugIfInvariantHolds(OS.str(), ErrorKind::NullablePassedToNonnull,

CK_NullablePassedToNonnull, N, Region,

,

(ChecksEnabled[CK_NullableDereferenced] &&

Param->getType()->isReferenceType()) {

reportBugIfInvariantHolds(

,

ErrorKind::NullableDereferenced,

CK_NullableDereferenced, N, Region,

,

(State != OrigState)

.addTransition(State);

NullabilityChecker::checkPostCall(

&

,

(State->get<InvariantViolated>())

*Region = getTrackRegion(

.getReturnValue());

(llvm::sys::path::filename(FilePath).starts_with(

)) {

State = State->set<NullabilityMap>(Region, Nullability::Contradicted);

.addTransition(State);

NullabilityState *TrackedNullability =

State->get<NullabilityMap>(Region);

(

*

=

.getOriginExpr())

(!TrackedNullability &&

State = State->set<NullabilityMap>(Region, Nullability::Nullable);

.addTransition(State);

Nullability::Nonnull;

Nullability::Nonnull;

(ValueRegionSVal) {

*SelfRegion = ValueRegionSVal->getRegion();

NullabilityState *TrackedSelfNullability =

State->get<NullabilityMap>(SelfRegion);

(TrackedSelfNullability)

TrackedSelfNullability->getValue();

Nullability::Unspecified;

Assumption)

{

PropertyAccessesMapTy PropertyAccesses = State->get<PropertyAccessesMap>();

(

[PropKey, PropVal] : PropertyAccesses) {

(!PropVal.isConstrainedNonnull) {

ConstrainedPropertyVal Replacement = PropVal;

Replacement.isConstrainedNonnull =

;

State = State->set<PropertyAccessesMap>(PropKey, Replacement);

}

(

.isConstrainedFalse()) {

State = State->remove<PropertyAccessesMap>(PropKey);

NullabilityChecker::checkPostObjCMessage(

&M,

(State->get<InvariantViolated>())

(Name.starts_with(

)) {

State->set<NullabilityMap>(ReturnRegion, Nullability::Contradicted);

.addTransition(State);

(Name.contains(

) &&

(FirstSelectorSlot ==

||

FirstSelectorSlot ==

)) {

State->set<NullabilityMap>(ReturnRegion, Nullability::Contradicted);

.addTransition(State);

(Name.contains(

)) {

(Param->getName() ==

) {

State = State->set<NullabilityMap>(ReturnRegion,

Nullability::Contradicted);

.addTransition(State);

NullabilityState *NullabilityOfReturn =

State->get<NullabilityMap>(ReturnRegion);

(NullabilityOfReturn) {

RetValTracked = NullabilityOfReturn->getValue();

getMostNullable(RetValTracked, SelfNullability);

(ComputedNullab != RetValTracked &&

ComputedNullab != Nullability::Unspecified) {

*NullabilitySource =

ComputedNullab == RetValTracked

? NullabilityOfReturn->getNullabilitySource()

: Message->getInstanceReceiver();

State = State->set<NullabilityMap>(

ReturnRegion, NullabilityState(ComputedNullab, NullabilitySource));

.addTransition(State);

(RetNullability != Nullability::Nonnull &&

LookupResolved =

;

LookupResolved =

;

ConstrainedPropertyVal *PrevPropVal =

State->get<PropertyAccessesMap>(Key);

(PrevPropVal && PrevPropVal->isConstrainedNonnull) {

RetNullability = Nullability::Nonnull;

(

ReturnSVal =

State = State->set<PropertyAccessesMap>(

Key, ConstrainedPropertyVal(*ReturnSVal));

(!LookupResolved) {

RetNullability = Nullability::Nonnull;

ComputedNullab = getMostNullable(RetNullability, SelfNullability);

(ComputedNullab == Nullability::Nullable) {

*NullabilitySource = ComputedNullab == RetNullability

: Message->getInstanceReceiver();

State = State->set<NullabilityMap>(

ReturnRegion, NullabilityState(ComputedNullab, NullabilitySource));

.addTransition(State);

(State->get<InvariantViolated>())

(DestNullability == Nullability::Unspecified)

*Region = getTrackRegion(*RegionSVal);

(DestNullability == Nullability::Nonnull) {

State = State->set<NullabilityMap>(Region, Nullability::Contradicted);

.addTransition(State);

NullabilityState *TrackedNullability =

State->get<NullabilityMap>(Region);

(!TrackedNullability) {

(DestNullability != Nullability::Nullable)

State = State->set<NullabilityMap>(Region,

NullabilityState(DestNullability, CE));

.addTransition(State);

(TrackedNullability->getValue() != DestNullability &&

TrackedNullability->getValue() != Nullability::Contradicted) {

State = State->set<NullabilityMap>(Region, Nullability::Contradicted);

.addTransition(State);

(

*BinOp = dyn_cast<BinaryOperator>(S)) {

(BinOp->getOpcode() == BO_Assign)

BinOp->getRHS();

(

*DS = dyn_cast<DeclStmt>(S)) {

(DS->isSingleDecl()) {

*VD = dyn_cast<VarDecl>(DS->getSingleDecl());

(

*

= VD->getInit())

(!

.getASTContext().getLangOpts().ObjCAutoRefCount)

*DS = dyn_cast<DeclStmt>(S);

(!DS || !DS->isSingleDecl())

*VD = dyn_cast<VarDecl>(DS->getSingleDecl());

(!VD->getType().getQualifiers().hasObjCLifetime())

assert(

&&

);

(!isa<ImplicitValueInitExpr>(

))

NullabilityChecker::checkBind(

L,

,

*S,

dyn_cast_or_null<TypedValueRegion>(L.

());

(State->get<InvariantViolated>())

(!ValDefOrUnknown)

ValNullability = Nullability::Unspecified;

(

Sym = ValDefOrUnknown->getAsSymbol())

ValueExprTypeLevelNullability = Nullability::Unspecified;

ValueExprTypeLevelNullability =

NullAssignedToNonNull = (LocNullability == Nullability::Nonnull &&

(ChecksEnabled[CK_NullPassedToNonnull] && NullAssignedToNonNull &&

ValNullability != Nullability::Nonnull &&

ValueExprTypeLevelNullability != Nullability::Nonnull &&

llvm::raw_svector_ostream OS(SBuf);

OS <<

;

reportBugIfInvariantHolds(OS.str(), ErrorKind::NilAssignedToNonnull,

CK_NullPassedToNonnull, N,

,

,

);

(NullAssignedToNonNull) {

State = State->set<InvariantViolated>(

);

.addTransition(State);

*ValueRegion = getTrackRegion(*ValDefOrUnknown);

NullabilityState *TrackedNullability =

State->get<NullabilityMap>(ValueRegion);

(TrackedNullability) {

TrackedNullability->getValue() != Nullability::Nullable)

(ChecksEnabled[CK_NullablePassedToNonnull] &&

LocNullability == Nullability::Nonnull) {

*N =

.addTransition(State,

.getPredecessor(), &Tag);

reportBugIfInvariantHolds(

,

ErrorKind::NullableAssignedToNonnull,

CK_NullablePassedToNonnull, N, ValueRegion,

);

*BinOp = dyn_cast<BinaryOperator>(S);

(ValNullability == Nullability::Nullable) {

*NullabilitySource = BinOp ? BinOp->getRHS() : S;

State = State->set<NullabilityMap>(

ValueRegion, NullabilityState(ValNullability, NullabilitySource));

.addTransition(State);

(LocNullability == Nullability::Nullable) {

*NullabilitySource = BinOp ? BinOp->getLHS() : S;

State = State->set<NullabilityMap>(

ValueRegion, NullabilityState(LocNullability, NullabilitySource));

.addTransition(State);

NullabilityChecker::printState(raw_ostream &Out,

State,

*NL,

*Sep)

{

NullabilityMapTy B = State->get<NullabilityMap>();

(State->get<InvariantViolated>())

<<

<< NL;

(!State->get<InvariantViolated>())

(

[Region, State] : B) {

Out << Region <<

;

ento::shouldRegisterNullabilityBase(

&mgr) {

, true); \

bool ento::shouldRegister##name##Checker(const CheckerManager &mgr) { \

static void print(llvm::raw_ostream &OS, const T &V, ASTContext &ASTCtx, QualType Ty)

static bool isValidPointerType(QualType T)

static NullConstraint getNullConstraint(DefinedOrUnknownSVal Val, ProgramStateRef State)

#define REGISTER_CHECKER(name, trackingRequired)

static bool isARCNilInitializedLocal(CheckerContext &C, const Stmt *S)

Returns true if.

static bool checkValueAtLValForInvariantViolation(ProgramStateRef State, SVal LV, QualType T)

Returns true when the value stored at the given location has been constrained to null after being pas...

static const Expr * matchValueExprForBind(const Stmt *S)

For a given statement performing a bind, attempt to syntactically match the expression resulting in t...

static bool checkSelfIvarsForInvariantViolation(ProgramStateRef State, const LocationContext *LocCtxt)

static bool checkInvariantViolation(ProgramStateRef State, ExplodedNode *N, CheckerContext &C)

static const Expr * lookThroughImplicitCasts(const Expr *E)

Find the outermost subexpression of E that is not an implicit cast.

static bool checkParamsForPreconditionViolation(ArrayRef< ParmVarDecl * > Params, ProgramStateRef State, const LocationContext *LocCtxt)

static Nullability getReceiverNullability(const ObjCMethodCall &M, ProgramStateRef State)

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

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

const Decl * getDecl() const

static std::optional< AnyCall > forDecl(const Decl *D)

If D is a callable (Objective-C method or a function), return a constructed AnyCall object.

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

const FunctionType * getFunctionType(bool BlocksToo=true) const

Looks through the Decl's underlying type to extract a FunctionType when possible.

SourceLocation getBeginLoc() const LLVM_READONLY

ExplicitCastExpr - An explicit cast written in the source code.

This represents one expression.

Expr * IgnoreImpCasts() LLVM_READONLY

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

FunctionType - C99 6.7.5.3 - Function Declarators.

QualType getReturnType() const

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

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

const Decl * getDecl() const

const ImplicitParamDecl * getSelfDecl() const

Represents an ObjC class declaration.

An expression that sends a message to the given Objective-C object or class.

Represents a pointer to an Objective C object.

ObjCInterfaceDecl * getInterfaceDecl() const

If this pointer points to an Objective @interface type, gets the declaration for that interface.

A single parameter index whose accessors require each use to make explicit the parameter index encodi...

Represents a parameter to a function.

A (possibly-)qualified type.

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

StringRef getNameForSlot(unsigned argIndex) const

Retrieve the name at a given position in the selector.

const IdentifierInfo * getIdentifierInfoForSlot(unsigned argIndex) const

Retrieve the identifier at a given position in the selector.

This class handles loading and caching of source files into memory.

Stmt - This represents one statement.

bool isBlockPointerType() const

bool isObjCObjectPointerType() const

bool isAnyPointerType() const

Represents a statement that could possibly have a value and type.

const SourceManager & getSourceManager() const

BugReporterVisitors are used to add custom diagnostics along a path.

BugReporter is a utility class for generating PathDiagnostics for analysis.

virtual void emitReport(std::unique_ptr< BugReport > R)

Add the given report to the set of reports tracked by BugReporter.

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

SVal getReturnValue() const

Returns the return value of the call.

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.

This wrapper is used to ensure that only StringRefs originating from the CheckerRegistry are used as ...

Tag that can use a checker name as a message provider (see SimpleProgramPointTag).

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

ElementRegion is used to represent both array elements and casts.

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

MemRegion - The root abstract class for all memory regions.

const RegionTy * getAs() const

Represents any expression that calls an Objective-C method.

const ObjCMethodDecl * getDecl() const override

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

bool isInstanceMessage() const

ObjCMessageKind getMessageKind() const

Returns how the message was written in the source (property access, subscript, or explicit message se...

const ObjCMessageExpr * getOriginExpr() const override

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

ArrayRef< ParmVarDecl * > parameters() const override

Return call's formal parameters.

SVal getReceiverSVal() const

Returns the value of the receiver at the time of this call.

bool isReceiverSelfOrSuper() const

Checks if the receiver refers to 'self' or 'super'.

Selector getSelector() const

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.

QualType getType(const ASTContext &) const

Try to get a reasonable type for the given value.

const MemRegion * getAsRegion() const

SubRegion - A region that subsets another larger region.

A class responsible for cleaning up unused symbols.

bool isDead(SymbolRef sym)

Returns whether or not a symbol has been confirmed dead.

bool isLiveRegion(const MemRegion *region)

SymbolicRegion - A special, "non-concrete" region.

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

virtual QualType getValueType() const =0

bool trackExpressionValue(const ExplodedNode *N, const Expr *E, PathSensitiveBugReport &R, TrackingOptions Opts={})

Attempts to add visitors to track expression value back to its point of origin.

const char *const MemoryError

Nullability getNullabilityAnnotation(QualType Type)

Get nullability annotation for a given type.

std::shared_ptr< PathDiagnosticPiece > PathDiagnosticPieceRef

bool IsNonNull(InterpState &S, CodePtr OpPC)

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

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

ObjCMethodFamily

A family of Objective-C methods.

const FunctionProtoType * T

@ Interface

The "__interface" keyword introduces the elaborated-type-specifier.

We dereferenced a location that may be null.

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