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

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

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

;

{ Symbolic = 0x2 };

llvm::PointerIntPair<const MemRegion *, 2>

;

assert(r &&

&&

);

assert(getConcreteOffsetRegion() ==

&&

);

BindingKey(

*r, uint64_t offset, Kind k)

:

(r, k),

(offset) {

assert(r &&

);

assert(getOffset() == offset &&

);

isa<ObjCIvarRegion, CXXDerivedObjectRegion>(r)) &&

isDirect()

{

.getInt() &

; }

isDefault()

{

!isDirect(); }

hasSymbolicOffset()

{

.getInt() & Symbolic; }

assert(!hasSymbolicOffset());

*getConcreteOffsetRegion()

{

assert(hasSymbolicOffset());

(hasSymbolicOffset())

Profile(llvm::FoldingSetNodeID& ID)

{

.AddPointer(

.getOpaqueValue());

(

BindingKey &

)

{

(

.getOpaqueValue() <

.P.getOpaqueValue())

(

.getOpaqueValue() >

.P.getOpaqueValue())

<

.Data;

.getOpaqueValue() ==

.P.getOpaqueValue() &&

LLVM_DUMP_METHOD

()

;

BindingKey BindingKey::Make(

*R, Kind k) {

BindingKey(cast<SubRegion>(R), cast<SubRegion>(RO.

()), k);

raw_ostream &

(raw_ostream &Out, BindingKey K) {

Out <<

<< (K.isDirect() ?

:

)

<<

;

(!K.hasSymbolicOffset())

Out << K.getOffset();

BindingKey::dump()

{ llvm::errs() << *

; }

llvm::ImmutableMap<const MemRegion *, ClusterBindings>

RegionBindingsRef :

llvm::ImmutableMapRef<const MemRegion *,

ClusterBindings::Factory *CBFactory;

llvm::ImmutableMapRef<const MemRegion *, ClusterBindings>

RegionBindingsRef(ClusterBindings::Factory &CBFactory,

RegionBindings::TreeTy *

,

RegionBindings::TreeTy::Factory *F,

: llvm::ImmutableMapRef<const MemRegion *, ClusterBindings>(

, F),

CBFactory(&CBFactory), IsMainAnalysis(IsMainAnalysis) {}

RegionBindingsRef(

ParentTy &

,

ClusterBindings::Factory &CBFactory,

: llvm::ImmutableMapRef<const MemRegion *, ClusterBindings>(

),

CBFactory(&CBFactory), IsMainAnalysis(IsMainAnalysis) {}

RegionBindingsRef add(key_type_ref K, data_type_ref

)

{

RegionBindingsRef(

ParentTy *

(

)->add(K,

),

*CBFactory, IsMainAnalysis);

RegionBindingsRef remove(key_type_ref K)

{

RegionBindingsRef(

ParentTy *

(

)->remove(K),

*CBFactory, IsMainAnalysis);

RegionBindingsRef addBinding(BindingKey K,

)

;

RegionBindingsRef addBinding(

*R,

BindingKey::Kind k,

)

;

*lookup(BindingKey K)

;

*lookup(

*R, BindingKey::Kind k)

;

RegionBindingsRef removeBinding(BindingKey K);

RegionBindingsRef removeBinding(

*R,

RegionBindingsRef removeBinding(

*R) {

removeBinding(R, BindingKey::Direct).

removeBinding(R, BindingKey::Default);

std::optional<SVal> getDirectBinding(

*R)

;

std::optional<SVal> getDefaultBinding(

*R)

;

asStore()

{

llvm::PointerIntPair<Store, 1, bool> Ptr = {

asImmutableMap().getRootWithoutRetain(), IsMainAnalysis};

(Ptr.getOpaqueValue());

isMainAnalysis()

{

IsMainAnalysis;

printJson(raw_ostream &Out,

*NL =

,

Space = 0,

IsDot =

)

{

;

DenseMap<const MemRegion *, std::string> StringifyCache;

ToString = [&StringifyCache](

*R) {

[Place, Inserted] = StringifyCache.try_emplace(R);

Place->second;

raw_string_ostream OS(Res);

std::pair<const MemRegion *, ImmutableMap<BindingKey, SVal>>;

Binding = std::pair<BindingKey, SVal>;

MemSpaceBeforeRegionName = [&ToString](

Cluster *L,

(isa<MemSpaceRegion>(L->first) && !isa<MemSpaceRegion>(R->first))

(!isa<MemSpaceRegion>(L->first) && isa<MemSpaceRegion>(R->first))

ToString(L->first) < ToString(R->first);

SymbolicBeforeOffset = [&ToString](

BindingKey &L,

BindingKey &R) {

(L.hasSymbolicOffset() && !R.hasSymbolicOffset())

(!L.hasSymbolicOffset() && R.hasSymbolicOffset())

(L.hasSymbolicOffset() && R.hasSymbolicOffset())

ToString(L.getRegion()) < ToString(R.getRegion());

L.getOffset() < R.getOffset();

DefaultBindingBeforeDirectBindings =

[&SymbolicBeforeOffset](

Binding *LPtr,

Binding *RPtr) {

BindingKey &L = LPtr->first;

BindingKey &R = RPtr->first;

(L.isDefault() && !R.isDefault())

(!L.isDefault() && R.isDefault())

assert(L.isDefault() == R.isDefault());

SymbolicBeforeOffset(L, R);

AddrOf = [](

&Item) {

&Item; };

std::vector<const Cluster *> SortedClusters;

SortedClusters.reserve(std::distance(begin(), end()));

append_range(SortedClusters, map_range(*

, AddrOf));

llvm::sort(SortedClusters, MemSpaceBeforeRegionName);

(

[Idx,

] : llvm::enumerate(SortedClusters)) {

&[BaseRegion,

] = *

;

Indent(Out, Space, IsDot)

<<

<< BaseRegion <<

<< (

*)BaseRegion <<

<< NL;

std::vector<const Binding *> SortedBindings;

append_range(SortedBindings, map_range(

, AddrOf));

llvm::sort(SortedBindings, DefaultBindingBeforeDirectBindings);

(

[Idx, B] : llvm::enumerate(SortedBindings)) {

&[Key,

] = *B;

Indent(Out, Space, IsDot) <<

<< Key <<

;

.printJson(Out,

);

(Idx != SortedBindings.size() - 1)

Indent(Out, Space, IsDot) <<

;

(Idx != SortedClusters.size() - 1)

LLVM_DUMP_METHOD

()

{ printJson(llvm::errs()); }

RegionBindingsRef::getDirectBinding(

*R)

{

*

= lookup(R, BindingKey::Direct);

? std::optional<SVal>(*

) : std::nullopt;

RegionBindingsRef::getDefaultBinding(

*R)

{

*

= lookup(R, BindingKey::Default);

? std::optional<SVal>(*

) :

::nullopt;

RegionBindingsRef RegionBindingsRef::addBinding(BindingKey K,

)

{

(ExistingCluster ? *ExistingCluster : CBFactory->getEmptyMap());

add(

, NewCluster);

RegionBindingsRef RegionBindingsRef::addBinding(

*R,

addBinding(BindingKey::Make(R, k),

);

*RegionBindingsRef::lookup(BindingKey K)

{

Cluster->lookup(K);

BindingKey::Kind k)

{

lookup(BindingKey::Make(R, k));

RegionBindingsRef RegionBindingsRef::removeBinding(BindingKey K) {

(NewCluster.isEmpty())

add(

, NewCluster);

RegionBindingsRef RegionBindingsRef::removeBinding(

*R,

removeBinding(BindingKey::Make(R, k));

InvalidateRegionsWorker;

RegionBindings::Factory RBFactory;

ClusterBindings::Factory CBFactory;

std::vector<SVal> SValListTy;

SValListTy> LazyBindingsMapTy;

LazyBindingsMapTy LazyBindingsMap;

SmallStructLimit;

SmallArrayLimit;

populateWorkList(InvalidateRegionsWorker &W,

InvalidatedRegions *TopLevelRegions);

CBFactory(mgr.getAllocator()), SmallStructLimit(0), SmallArrayLimit(0) {

SmallStructLimit = Options.RegionStoreSmallStructLimit;

SmallArrayLimit = Options.RegionStoreSmallArrayLimit;

IsMainAnalysis =

;

(

*FD = dyn_cast<FunctionDecl>(InitLoc->

()))

IsMainAnalysis = FD->isMain() && !Ctx.

().CPlusPlus;

RegionBindingsRef::ParentTy(RBFactory.getEmptyMap(), RBFactory),

CBFactory, IsMainAnalysis).asStore(), *

);

InvalidatedRegions *Invalidated);

InvalidatedRegions *Invalidated,

InvalidatedRegions *InvalidatedTopLevel)

;

(bind(getRegionBindings(store), LV,

).asStore(), *

);

RegionBindingsRef B = getRegionBindings(store);

assert(!(B.getDefaultBinding(R) || B.getDirectBinding(R)) &&

);

B = B.addBinding(BindingKey::Make(R, BindingKey::Default),

);

(B.asImmutableMap().getRootWithoutRetain(), *

);

(

*BR = dyn_cast<CXXBaseObjectRegion>(R))

(BR->getDecl()->isEmpty())

RegionBindingsRef B = getRegionBindings(store);

B = removeSubRegionBindings(B, cast<SubRegion>(R));

B = B.addBinding(BindingKey::Make(R, BindingKey::Default),

);

(B.asImmutableMap().getRootWithoutRetain(), *

);

std::optional<RegionBindingsRef>

std::optional<RegionBindingsRef>

getRegionBindings(store).manualRetain();

getRegionBindings(store).manualRelease();

RegionBindingsRef B = getRegionBindings(S);

RegionBindingsRef LazyBinding);

std::pair<Store, const SubRegion *>

RegionBindingsRef getRegionBindings(

store)

{

llvm::PointerIntPair<Store, 1, bool> Ptr;

Ptr.setFromOpaqueValue(

*

(store));

RegionBindingsRef(

RegionBindings::TreeTy *

(Ptr.getPointer()),

RBFactory.getTreeFactory(),

(raw_ostream &Out,

S,

*NL =

,

Space = 0,

IsDot =

)

;

RegionBindingsRef B = getRegionBindings(store);

(

&[Region, Cluster] : B) {

(

&[Key,

] : Cluster) {

(

*R = dyn_cast<SubRegion>(Key.getRegion())) {

(!f.HandleBinding(*

, store, R,

))

std::unique_ptr<StoreManager>

std::make_unique<RegionStoreManager>(StMgr);

GlobalsFilterKind {

<

DERIVED>

ClusterAnalysis {

llvm::DenseMap<const MemRegion *, const ClusterBindings *> ClusterMap;

* WorkListElement;

RegionStoreManager &RM;

RegionBindingsRef

)

: RM(rm), Ctx(StateMgr.getContext()),

svalBuilder(StateMgr.getSValBuilder()), B(

::move(

)) {}

RegionBindingsRef getRegionBindings()

{

B; }

.count(getCluster(R));

GenerateClusters() {

(RegionBindingsRef::iterator RI = B.begin(), RE = B.end();

assert(!Cluster.isEmpty() &&

);

DERIVED*

(

)->VisitAddedToCluster(

, Cluster);

(

DERIVED*

(

)->includeEntireMemorySpace(

))

AddToWorkList(WorkListElement(

), &Cluster);

AddToWorkList(

*R) {

DERIVED*

(

)->AddToWorkList(R);

(!WL.empty()) {

WorkListElement

= WL.pop_back_val();

DERIVED*

(

)->VisitCluster(BaseR, getCluster(BaseR));

DERIVED*

(

)->VisitCluster(BaseR,

);

RegionStoreManager::scanReachableSymbols(

S,

*R,

assert(R == R->

() &&

);

RegionBindingsRef B = getRegionBindings(S);

(ClusterBindings::iterator RI = Cluster->begin(), RE = Cluster->end();

(!Callbacks.

(RI.getData()))

assert(K.hasSymbolicOffset() &&

);

(

*FR = dyn_cast<FieldRegion>(R))

Fields.push_back(FR->getDecl());

R = cast<SubRegion>(R)->getSuperRegion();

assert(K.hasSymbolicOffset() &&

);

Delta = FieldsInBindingKey.size() - Fields.size();

std::equal(FieldsInBindingKey.begin() + Delta,

FieldsInBindingKey.end(),

std::equal(FieldsInBindingKey.begin(), FieldsInBindingKey.end(),

Fields.begin() - Delta);

IncludeAllDefaultBindings) {

(TopKey.hasSymbolicOffset()) {

Top = TopKey.getConcreteOffsetRegion();

TopKey = BindingKey::Make(Top, BindingKey::Default);

uint64_t Length = UINT64_MAX;

(std::optional<nonloc::ConcreteInt> ExtentCI =

llvm::APSInt &ExtentInt = ExtentCI->getValue();

assert(ExtentInt.isNonNegative() || ExtentInt.isUnsigned());

}

(

*FR = dyn_cast<FieldRegion>(Top)) {

(FR->getDecl()->isBitField())

Length = FR->getDecl()->getBitWidthValue();

(

&StoreEntry : Cluster) {

BindingKey NextKey = StoreEntry.first;

(NextKey.getRegion() == TopKey.getRegion()) {

(NextKey.getOffset() > TopKey.getOffset() &&

NextKey.getOffset() - TopKey.getOffset() < Length) {

}

(NextKey.getOffset() == TopKey.getOffset()) {

(IncludeAllDefaultBindings || NextKey.isDirect())

}

(NextKey.hasSymbolicOffset()) {

(IncludeAllDefaultBindings || NextKey.isDirect())

}

(

*BaseSR = dyn_cast<SubRegion>(

)) {

(BaseSR->isSubRegionOf(Top))

*Top,

IncludeAllDefaultBindings) {

BindingKey::Make(Top, BindingKey::Default),

IncludeAllDefaultBindings);

BindingKey TopKey = BindingKey::Make(Top, BindingKey::Default);

(Top == ClusterHead) {

B.remove(Top);

(TopKey.hasSymbolicOffset()) {

*Concrete = TopKey.getConcreteOffsetRegion();

B.addBinding(Concrete, BindingKey::Default,

());

(BindingKey Key : llvm::make_first_range(

))

Result = Result.remove(Key);

(TopKey.hasSymbolicOffset()) {

*Concrete = TopKey.getConcreteOffsetRegion();

Result = Result.

(BindingKey::Make(Concrete, BindingKey::Default),

(Result.isEmpty())

B.remove(ClusterHead);

B.add(ClusterHead, Result.asImmutableMap());

InvalidateRegionsWorker :

ClusterAnalysis<InvalidateRegionsWorker>

GlobalsFilterKind GlobalsFilter;

RegionBindingsRef

,

*S,

count,

GlobalsFilterKind GFK)

: ClusterAnalysis<InvalidateRegionsWorker>(rm, stateMgr,

), S(S),

Count(count), LCtx(lctx), IS(is), ITraits(ITraitsIn), Regions(r),

GlobalsFilter(GFK) {}

VisitBinding(

);

ClusterAnalysis::AddToWorkList;

AddToWorkList(

*R);

isInitiallyIncludedGlobalRegion(

*R);

InvalidateRegionsWorker::AddToWorkList(

*R) {

doNotInvalidateSuperRegion = ITraits.hasTrait(

AddToWorkList(WorkListElement(BaseR), getCluster(BaseR));

InvalidateRegionsWorker::VisitBinding(

) {

(

*R =

.getAsRegion()) {

(std::optional<nonloc::LazyCompoundVal> LCS =

(

: RM.getInterestingValues(*LCS))

(!isa<nonloc::LazyCompoundVal>(

))

InvalidateRegionsWorker::VisitCluster(

*baseR,

PreserveRegionsContents =

ITraits.hasTrait(baseR,

(

Val : llvm::make_second_range(*

))

(!PreserveRegionsContents)

B = B.remove(baseR);

(

*TO = dyn_cast<TypedValueRegion>(baseR)) {

(

*RD = TO->getValueType()->getAsCXXRecordDecl()) {

(RD->isLambda() && RD->getLambdaCallOperator()->getBody()) {

ast_matchers;

*DeclBind =

;

to(

(hasStaticStorageDuration()).bind(DeclBind)))));

(RefToStatic, *RD->getLambdaCallOperator()->getBody(),

RD->getASTContext());

*VD = Match.getNodeAs<

>(DeclBind);

RM.getRegionManager().getVarRegion(VD, LCtx);

AddToWorkList(ToInvalidate);

(

Var : BR->referenced_vars()) {

*VR = Var.getCapturedRegion();

(std::optional<Loc> L =

.getAs<

>()) {

IS.insert(SR->getSymbol());

(PreserveRegionsContents)

Regions->push_back(baseR);

(isa<AllocaRegion, SymbolicRegion>(baseR)) {

B = B.addBinding(baseR, BindingKey::Default,

);

(isInitiallyIncludedGlobalRegion(baseR)) {

B = B.addBinding(baseR, BindingKey::Default,

);

doNotInvalidateSuperRegion = ITraits.hasTrait(

(doNotInvalidateSuperRegion) {

std::optional<uint64_t> NumElements;

NumElements = CAT->getZExtSize();

conjure_default;

ElementTy = AT->getElementType();

AddToWorkList(SuperR);

conjure_default;

UpperOffset = LowerOffset + *NumElements * ElemSize;

UpperOverflow = UpperOffset < LowerOffset;

conjure_default;

conjure_default;

(

&[BK,

] : *

) {

std::optional<uint64_t> ROffset =

BK.hasSymbolicOffset() ? std::optional<uint64_t>() : BK.getOffset();

((*ROffset >= LowerOffset && *ROffset < UpperOffset) ||

(*ROffset >= LowerOffset || *ROffset < UpperOffset)) ||

(LowerOffset == UpperOffset && *ROffset == LowerOffset))) {

B = B.removeBinding(BK);

(isa_and_nonnull<SymbolicRegion>(R))

baseR, S, LCtx, AT->getElementType(), Count);

B = B.addBinding(baseR, BindingKey::Default,

);

B = B.addBinding(baseR, BindingKey::Direct,

);

InvalidateRegionsWorker::isInitiallyIncludedGlobalRegion(

(GlobalsFilter) {

GFK_SystemOnly:

llvm_unreachable(

);

InvalidateRegionsWorker::includeEntireMemorySpace(

*

) {

(isInitiallyIncludedGlobalRegion(

))

ITraits.hasTrait(MemSpace,

RegionBindingsRef RegionStoreManager::invalidateGlobalRegion(

InvalidatedRegions *Invalidated) {

Ctx.

, Count);

B = B.removeBinding(GS)

.addBinding(BindingKey::Make(GS, BindingKey::Default),

);

Invalidated->push_back(GS);

RegionStoreManager::populateWorkList(InvalidateRegionsWorker &W,

InvalidatedRegions *TopLevelRegions) {

(

: Values) {

(

S : getInterestingValues(*LCS))

(

*R = S.getAsRegion())

(

*R =

.getAsRegion()) {

(TopLevelRegions)

TopLevelRegions->push_back(R);

RegionStoreManager::invalidateRegions(

InvalidatedRegions *TopLevelRegions, InvalidatedRegions *Invalidated) {

GlobalsFilterKind GlobalsFilter;

(

->isInSystemHeader())

GlobalsFilter = GFK_SystemOnly;

GlobalsFilter = GFK_All;

GlobalsFilter = GFK_None;

RegionBindingsRef B = getRegionBindings(store);

InvalidateRegionsWorker W(*

, StateMgr, B, S, Count, LCtx, IS, ITraits,

Invalidated, GlobalsFilter);

W.GenerateClusters();

populateWorkList(W, Values, TopLevelRegions);

B = W.getRegionBindings();

(GlobalsFilter) {

B = invalidateGlobalRegion(MemRegion::GlobalInternalSpaceRegionKind, S,

Count, LCtx, B, Invalidated);

GFK_SystemOnly:

B = invalidateGlobalRegion(MemRegion::GlobalSystemSpaceRegionKind, S, Count,

LCtx, B, Invalidated);

(B.asStore(), *

);

(isa<loc::ConcreteInt>(Array))

(!isa<loc::MemRegionVal>(Array))

assert(!isa<UnknownVal>(L) &&

);

assert(!isa<UndefinedVal>(L) &&

);

(isa<BlockDataRegion>(MR)) {

(

*TVR = dyn_cast<TypedValueRegion>(MR))

= TVR->getValueType();

(

*TR = dyn_cast<TypedRegion>(MR))

(

*SR = dyn_cast<SymbolicRegion>(MR))

= SR->getPointeeStaticType();

assert(!

.isNull() &&

);

assert(!

->

() &&

);

(!isa<TypedValueRegion>(MR))

MR = GetElementZeroRegion(cast<SubRegion>(MR),

);

getBindingForStruct(B, R);

createLazyBinding(B, R);

getBindingForArray(B, R);

(

* FR = dyn_cast<FieldRegion>(R))

(

* ER = dyn_cast<ElementRegion>(R)) {

(

*VR = dyn_cast<VarRegion>(R)) {

*

= B.lookup(R, BindingKey::Direct);

RegionTy = TVR->getValueType();

RegionTy = SR->getSymbol()->getType();

std::optional<nonloc::LazyCompoundVal>

*R,

AllowSubregionBindings) {

std::optional<SVal>

= B.getDefaultBinding(R);

std::nullopt;

std::optional<nonloc::LazyCompoundVal> LCV =

std::nullopt;

(!RegionTy.

() &&

SourceRegionTy = LCV->getRegion()->getValueType();

std::nullopt;

(!AllowSubregionBindings) {

std::nullopt;

std::pair<Store, const SubRegion *>

(originalRegion != R) {

(std::optional<nonloc::LazyCompoundVal>

=

std::make_pair(

->getStore(),

->getRegion());

std::pair<Store, const SubRegion *> StoreRegionPair;

StoreRegionPair Result = StoreRegionPair();

(

*ER = dyn_cast<ElementRegion>(R)) {

Result = findLazyBinding(B, cast<SubRegion>(ER->getSuperRegion()),

Result.second = MRMgr.getElementRegionWithSuper(ER, Result.second);

}

(

*FR = dyn_cast<FieldRegion>(R)) {

Result = findLazyBinding(B, cast<SubRegion>(FR->getSuperRegion()),

Result.second = MRMgr.getFieldRegionWithSuper(FR, Result.second);

dyn_cast<CXXBaseObjectRegion>(R)) {

Result = findLazyBinding(B, cast<SubRegion>(BaseReg->getSuperRegion()),

Result.second = MRMgr.getCXXBaseObjectRegionWithSuper(BaseReg,

assert(CAT &&

);

}

((CAT = dyn_cast<ConstantArrayType>(CAT->

())));

std::pair<SmallVector<SVal, 2>,

*>

assert(ER &&

);

SValOffsets.push_back(ER->

());

ER = dyn_cast<ElementRegion>(

);

{SValOffsets,

};

std::optional<SVal>

DstOffsets.resize(SrcOffsets.size());

ExtentIt = ArrayExtents.begin();

OffsetIt = DstOffsets.begin();

(

: llvm::reverse(SrcOffsets)) {

llvm::APSInt &Offset = CI->getValue();

(Offset.isNegative() || Offset.uge(*(ExtentIt++)))

*(OffsetIt++) = Offset.getZExtValue();

std::nullopt;

std::optional<SVal> RegionStoreManager::getConstantValFromConstArrayInitializer(

assert(R &&

);

std::nullopt;

assert(!SValOffsets.empty() &&

);

std::nullopt;

std::nullopt;

std::nullopt;

(SValOffsets.size() != Extents.size())

std::nullopt;

SValOffsets, Extents, ConcreteOffsets))

(

*ILE = dyn_cast<InitListExpr>(

))

getSValFromInitListExpr(ILE, ConcreteOffsets, R->

());

(

*SL = dyn_cast<StringLiteral>(

))

getSValFromStringLiteral(SL, ConcreteOffsets.front(),

std::nullopt;

std::optional<SVal> RegionStoreManager::getSValFromInitListExpr(

assert(ILE &&

);

(uint64_t Offset : Offsets) {

(

*SL = dyn_cast<StringLiteral>(ILE->

(0)))

getSValFromStringLiteral(SL, Offset, ElemT);

*IL = dyn_cast<InitListExpr>(

);

std::nullopt;

assert(SL &&

);

svalBuilder.

(Code, ElemT);

(

std::optional<SVal> &ParentValue =

B.getDirectBinding(BaseRegion)) {

(

ParentValueAsSym = ParentValue->getAsSymbol())

(ParentValue->isUndef())

std::nullopt;

(

std::optional<SVal> &

= B.getDirectBinding(R))

(

*StrR = dyn_cast<StringRegion>(superR)) {

llvm::APSInt &Idx = CI->getValue();

getSValFromStringLiteral(SL, Idx.getZExtValue(),

);

}

(isa<ElementRegion, VarRegion>(superR)) {

(std::optional<SVal>

= getConstantValFromConstArrayInitializer(B, R))

(isa<CodeTextRegion>(superR))

getBindingForFieldOrElementCommon(B, R, R->

());

(

std::optional<SVal> &

= B.getDirectBinding(R))

(

*VR = dyn_cast<VarRegion>(superR)) {

(

*InitList = dyn_cast<InitListExpr>(

)) {

(Index < InitList->getNumInits()) {

(

*FieldInit = InitList->getInit(Index))

getBindingForFieldOrElementCommon(B, R, Ty);

std::optional<SVal> RegionStoreManager::getBindingForDerivedDefaultValue(

(

std::optional<SVal> &

= B.getDefaultBinding(superR)) {

(isa<nonloc::LazyCompoundVal, nonloc::CompoundVal>(val))

llvm_unreachable(

);

std::nullopt;

RegionStoreManager::getLazyBinding(

*LazyBindingRegion,

RegionBindingsRef LazyBinding) {

(

*ER = dyn_cast<ElementRegion>(LazyBindingRegion))

Result = getBindingForElement(LazyBinding, ER);

Result = getBindingForField(LazyBinding,

cast<FieldRegion>(LazyBindingRegion));

(Result.isUndef())

lazyBindingStore =

;

*lazyBindingRegion =

;

std::tie(lazyBindingStore, lazyBindingRegion) = findLazyBinding(B, R, R);

(lazyBindingRegion)

getLazyBinding(lazyBindingRegion,

getRegionBindings(lazyBindingStore));

hasSymbolicIndex =

;

hasPartialLazyBinding =

;

(std::optional<SVal>

=

getBindingForDerivedDefaultValue(B,

, R, Ty)) {

hasPartialLazyBinding =

;

index = ER->getIndex();

hasSymbolicIndex =

;

SR = dyn_cast<SubRegion>(

);

(isa<ElementRegion>(R)) {

(typedSuperR->getValueType()->isVectorType())

(hasSymbolicIndex)

(!hasPartialLazyBinding && !isa<BlockDataRegion>(R->

())) {

(

std::optional<SVal> &

= B.getDefaultBinding(R))

(

std::optional<SVal> &

= B.getDirectBinding(R))

(

std::optional<SVal> &

= B.getDefaultBinding(superR)) {

(

parentSym =

->getAsSymbol())

getBindingForLazySymbol(R);

(std::optional<SVal>

= B.getDirectBinding(R))

(std::optional<SVal>

= B.getDefaultBinding(R))

(isa<StackArgumentsSpaceRegion>(MS))

(isa<UnknownSpaceRegion>(MS))

(isa<GlobalsSpaceRegion>(MS)) {

(B.isMainAnalysis())

(isa<StaticGlobalSpaceRegion>(MS))

(std::optional<SVal>

= getBindingForDerivedDefaultValue(B, MS, R,

)) {

RegionStoreManager::SValListTy &

LazyBindingsMapTy::iterator I = LazyBindingsMap.find(LCV.

());

(I != LazyBindingsMap.end())

RegionBindingsRef B = getRegionBindings(LCV.

());

(LazyBindingsMap[LCV.

()] = std::move(List));

(

.isUnknownOrUndef() ||

.isConstant())

SValListTy &InnerList = getInterestingValues(*InnerLCV);

List.insert(List.end(), InnerList.begin(), InnerList.end());

List.push_back(

);

(LazyBindingsMap[LCV.

()] = std::move(List));

(std::optional<nonloc::LazyCompoundVal>

=

(std::optional<SVal> Val = getUniqueDefaultBinding(B, R))

createLazyBinding(B, R);

);

createLazyBinding(B, R);

RegionStoreManager::includedInBindings(

store,

RegionBindingsRef B = getRegionBindings(store);

(B.lookup(region))

(RegionBindingsRef::iterator RI = B.begin(), RE = B.end(); RI != RE; ++RI) {

(ClusterBindings::iterator CI = Cluster.begin(), CE = Cluster.end();

= CI.getData();

(

* R = LV->getRegion())

(getRegionBindings(ST).removeBinding(R)

.getRootWithoutRetain(),

*R = MemRegVal->getRegion();

bindArray(B, TR,

);

bindStruct(B, TR,

);

bindVector(B, TR,

);

bindAggregate(B, TR,

);

(

*SymReg = dyn_cast<SymbolicRegion>(R)) {

Ty = SymReg->getPointeeStaticType();

Ty = StateMgr.getContext().CharTy;

R = GetElementZeroRegion(SymReg, Ty);

assert((!isa<CXXThisRegion>(R) || !B.lookup(R)) &&

);

RegionBindingsRef NewB = removeSubRegionBindings(B, cast<SubRegion>(R));

KeyKind = isa<nonloc::LazyCompoundVal>(

) ? BindingKey::Default

: BindingKey::Direct;

NewB.addBinding(BindingKey::Make(R, KeyKind),

);

B.addBinding(R, BindingKey::Default,

);

std::optional<RegionBindingsRef> RegionStoreManager::tryBindSmallArray(

CAT = dyn_cast<ConstantArrayType>(AT);

std::nullopt;

std::nullopt;

(ArrSize > SmallArrayLimit)

std::nullopt;

RegionBindingsRef NewB = B;

(uint64_t i = 0; i < ArrSize; ++i) {

MRMgr.getElementRegion(Ty, Idx, LCV.

(), Ctx);

= getBindingForElement(getRegionBindings(LCV.

()), SrcER);

*DstER = MRMgr.getElementRegion(Ty, Idx, R, Ctx);

std::optional<uint64_t>

;

bindAggregate(B, R,

);

(std::optional<nonloc::LazyCompoundVal> LCV =

(std::optional<RegionBindingsRef> NewB =

tryBindSmallArray(B, R, AT, *LCV))

bindAggregate(B, R,

);

(

.isUnknown())

RegionBindingsRef NewB(B);

(;

? i < *

:

; ++i, ++VI) {

*ER = MRMgr.getElementRegion(ElementTy, Idx, R, Ctx);

NewB = bindStruct(NewB, ER, *VI);

NewB = bindArray(NewB, ER, *VI);

(!Size || i < *Size)

NewB = setImplicitDefaultValue(NewB, R, ElementTy);

(isa<nonloc::LazyCompoundVal, nonloc::SymbolVal>(

))

bindAggregate(B, R,

);

(!isa<nonloc::CompoundVal>(

)) {

RegionBindingsRef NewB(B);

( ; index != numElements ; ++index) {

*ER = MRMgr.getElementRegion(ElemType, Idx, R, Ctx);

NewB = bindArray(NewB, ER, *VI);

NewB = bindStruct(NewB, ER, *VI);

std::nullopt;

*Cluster = B.lookup(R);

(!Cluster || !llvm::hasSingleElement(*Cluster))

std::nullopt;

[Key,

] = *Cluster->begin();

Key.isDirect() ? std::optional<SVal>{} :

;

getUniqueDefaultBinding(B, LCV.

());

std::optional<RegionBindingsRef> RegionStoreManager::tryBindSmallStruct(

(std::optional<SVal> Val = getUniqueDefaultBinding(LCV)) {

B.addBinding(BindingKey::Make(R, BindingKey::Default), Val.value());

(

*Class = dyn_cast<CXXRecordDecl>(RD))

(

->getNumBases() != 0 ||

->getNumVBases() != 0)

std::nullopt;

(

*FD : RD->

()) {

(Fields.size() == SmallStructLimit)

std::nullopt;

std::nullopt;

Fields.push_back(FD);

RegionBindingsRef NewB = B;

(

*Field : Fields) {

= getBindingForField(getRegionBindings(LCV.

()), SourceFR);

*DestFR = MRMgr.getFieldRegion(Field, R);

(!RD->isCompleteDefinition())

(std::optional<nonloc::LazyCompoundVal> LCV =

(std::optional<RegionBindingsRef> NewB =

tryBindSmallStruct(B, R, RD, *LCV))

bindAggregate(B, R,

);

(isa<nonloc::SymbolVal>(

))

bindAggregate(B, R,

);

(

.isUnknown() || !isa<nonloc::CompoundVal>(

))

RegionBindingsRef NewB(B);

(

*CRD = dyn_cast<CXXRecordDecl>(RD)) {

assert((CRD->isAggregate() || (Ctx.

().ObjC && VI == VE)) &&

);

(

&B : CRD->bases()) {

assert(!B.isVirtual() &&

);

assert(BRD &&

);

MRMgr.getCXXBaseObjectRegion(BRD, R,

);

NewB = bindStruct(NewB, BR, *VI);

(FI = RD->field_begin(), FE = RD->field_end(); FI != FE; ++FI) {

(FI->isUnnamedBitField())

* FR = MRMgr.getFieldRegion(*FI, R);

NewB = bindArray(NewB, FR, *VI);

NewB = bindStruct(NewB, FR, *VI);

NewB = NewB.addBinding(R, BindingKey::Default,

removeSubRegionBindings(B, R).addBinding(R, BindingKey::Default, Val);

RemoveDeadBindingsWorker

:

ClusterAnalysis<RemoveDeadBindingsWorker> {

RemoveDeadBindingsWorker(RegionStoreManager &rm,

: ClusterAnalysis<RemoveDeadBindingsWorker>(rm, stateMgr,

),

SymReaper(symReaper), CurrentLCtx(LCtx) {}

ClusterAnalysis<RemoveDeadBindingsWorker>::VisitCluster;

ClusterAnalysis::AddToWorkList;

AddToWorkList(

*R);

UpdatePostponed();

VisitBinding(

);

RemoveDeadBindingsWorker::AddToWorkList(

*R) {

AddToWorkList(WorkListElement(BaseR), getCluster(BaseR));

RemoveDeadBindingsWorker::VisitAddedToCluster(

*baseR,

(

*VR = dyn_cast<VarRegion>(baseR)) {

(SymReaper.isLive(VR))

AddToWorkList(baseR, &

);

(

*SR = dyn_cast<SymbolicRegion>(baseR)) {

(SymReaper.isLive(SR->getSymbol()))

AddToWorkList(SR, &

);

Postponed.push_back(SR);

(isa<NonStaticGlobalSpaceRegion>(baseR)) {

AddToWorkList(baseR, &

);

(

*TR = dyn_cast<CXXThisRegion>(baseR)) {

*StackReg =

(RegCtx == CurrentLCtx || RegCtx->

(CurrentLCtx)))

AddToWorkList(TR, &

);

RemoveDeadBindingsWorker::VisitCluster(

*baseR,

(

*SymR = dyn_cast<SymbolicRegion>(baseR))

SymReaper.markLive(SymR->getSymbol());

(

&[Key, Val] : *

) {

SymReaper.markElementIndicesLive(Key.getRegion());

RemoveDeadBindingsWorker::VisitBinding(

) {

SymReaper.markLazilyCopied(LCS->getRegion());

(

: RM.getInterestingValues(*LCS)) {

SymReaper.markLazilyCopied(DepLCS->getRegion());

(

*R =

.getAsRegion()) {

SymReaper.markLive(R);

(

Var : BR->referenced_vars())

AddToWorkList(Var.getCapturedRegion());

SymReaper.markLive(Sym);

RemoveDeadBindingsWorker::UpdatePostponed() {

(SymReaper.isLive(SR->getSymbol())) {

RegionStoreManager::removeDeadBindings(

store,

RegionBindingsRef B = getRegionBindings(store);

RemoveDeadBindingsWorker W(*

, StateMgr, B, SymReaper, LCtx);

W.GenerateClusters();

W.AddToWorkList(Reg);

W.RunWorkList();

(W.UpdatePostponed());

(!W.isVisited(

))

B = B.remove(

);

(B.asStore(), *

);

RegionStoreManager::printJson(raw_ostream &Out,

S,

*NL,

Space,

IsDot)

{

RegionBindingsRef

= getRegionBindings(S);

Indent(Out, Space, IsDot) <<

;

Out <<

<< NL;

Out <<

<<

.asStore() <<

<< NL;

.printJson(Out, NL, Space + 1, IsDot);

Indent(Out, Space, IsDot) <<

<< NL;

This file defines AnalysisDeclContext, a class that manages the analysis context data for context sen...

static const MemRegion * getRegion(const CallEvent &Call, const MutexDescriptor &Descriptor, bool IsLock)

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

llvm::DenseSet< const void * > Visited

static std::optional< SVal > convertOffsetsFromSvalToUnsigneds(const SmallVector< SVal, 2 > &SrcOffsets, const SmallVector< uint64_t, 2 > ArrayExtents, SmallVector< uint64_t, 2 > &DstOffsets)

llvm::ImmutableMap< const MemRegion *, ClusterBindings > RegionBindings

static std::optional< SVal > getDerivedSymbolForBinding(RegionBindingsConstRef B, const TypedValueRegion *BaseRegion, const TypedValueRegion *SubReg, const ASTContext &Ctx, SValBuilder &SVB)

std::pair< BindingKey, SVal > BindingPair

static bool isCompatibleWithFields(BindingKey K, const FieldVector &Fields)

SmallVector< const FieldDecl *, 8 > FieldVector

llvm::ImmutableMap< BindingKey, SVal > ClusterBindings

static bool isUnionField(const FieldRegion *FR)

static void getSymbolicOffsetFields(BindingKey K, FieldVector &Fields)

static QualType getUnderlyingType(const SubRegion *R)

llvm::ImmutableMapRef< BindingKey, SVal > ClusterBindingsRef

static SmallVector< uint64_t, 2 > getConstantArrayExtents(const ConstantArrayType *CAT)

This is a helper function for getConstantValFromConstArrayInitializer.

static std::pair< SmallVector< SVal, 2 >, const MemRegion * > getElementRegionOffsetsWithBase(const ElementRegion *ER)

This is a helper function for getConstantValFromConstArrayInitializer.

const RegionBindingsRef & RegionBindingsConstRef

static std::optional< nonloc::LazyCompoundVal > getExistingLazyBinding(SValBuilder &SVB, RegionBindingsConstRef B, const SubRegion *R, bool AllowSubregionBindings)

Checks to see if store B has a lazy binding for region R.

static void collectSubRegionBindings(SmallVectorImpl< BindingPair > &Bindings, SValBuilder &SVB, const ClusterBindings &Cluster, const SubRegion *Top, BindingKey TopKey, bool IncludeAllDefaultBindings)

Collects all bindings in Cluster that may refer to bindings within Top.

llvm::SmallVector< std::pair< const MemRegion *, SVal >, 4 > Bindings

__PTRDIFF_TYPE__ ptrdiff_t

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

const ConstantArrayType * getAsConstantArrayType(QualType T) const

CanQualType getCanonicalType(QualType T) const

Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...

const LangOptions & getLangOpts() const

bool hasSameUnqualifiedType(QualType T1, QualType T2) const

Determine whether the given types are equivalent after cvr-qualifiers have been removed.

const ArrayType * getAsArrayType(QualType T) const

Type Query functions.

uint64_t getTypeSize(QualType T) const

Return the size of the specified (complete) type T, in bits.

CharUnits getTypeSizeInChars(QualType T) const

Return the size of the specified (complete) type T, in characters.

uint64_t getConstantArrayElementCount(const ConstantArrayType *CA) const

Return number of constant array elements.

uint64_t getCharWidth() const

Return the size of the character type, in bits.

Stores options for the analyzer from the command line.

Represents an array type, per C99 6.7.5.2 - Array Declarators.

QualType getElementType() const

Represents a C++ struct/union/class.

Represents the canonical version of C arrays with a specified constant size.

uint64_t getLimitedSize() const

Return the size zero-extended to uint64_t or UINT64_MAX if the value is larger than UINT64_MAX.

uint64_t getZExtSize() const

Return the size zero-extended as a uint64_t.

specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...

This represents one expression.

Represents a member of a struct/union/class.

unsigned getFieldIndex() const

Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...

const RecordDecl * getParent() const

Returns the parent of this field declaration, which is the struct in which this field is defined.

bool isUnnamedBitField() const

Determines whether this is an unnamed bitfield.

Describes an C or C++ initializer list.

bool isStringLiteralInit() const

Is this an initializer for an array of characters, initialized by a string literal or an @encode?

unsigned getNumInits() const

const Expr * getInit(unsigned Init) const

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

bool isParentOf(const LocationContext *LC) const

const Decl * getDecl() const

const StackFrameContext * getStackFrame() const

A (possibly-)qualified type.

bool isNull() const

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

bool isConstQualified() const

Determine whether this type is const-qualified.

Represents a struct/union/class.

field_range fields() const

RecordDecl * getDefinition() const

Returns the RecordDecl that actually defines this struct/union/class.

A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...

RecordDecl * getDecl() const

It represents a stack frame of the call stack (based on CallEvent).

Stmt - This represents one statement.

StringLiteral - This represents a string literal expression, e.g.

unsigned getLength() const

uint32_t getCodeUnit(size_t i) const

CXXRecordDecl * getAsCXXRecordDecl() const

Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...

bool isConstantArrayType() const

bool isVoidPointerType() const

const T * castAs() const

Member-template castAs<specific type>.

bool isReferenceType() const

bool isScalarType() const

QualType getPointeeType() const

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

bool isIntegralOrEnumerationType() const

Determine whether this type is an integral or enumeration type.

bool isAnyComplexType() const

QualType getCanonicalTypeInternal() const

bool isStructureOrClassType() const

bool isVectorType() const

bool isRecordType() const

Represents a variable declaration or definition.

bool hasGlobalStorage() const

Returns true for all variables that do not have local storage.

bool hasLocalStorage() const

Returns true if a variable with function scope is a non-static local variable.

const Expr * getAnyInitializer() const

Get the initializer for this variable, no matter which declaration it is attached to.

Represents a GCC generic vector type.

unsigned getNumElements() const

QualType getElementType() const

Maps string IDs to AST nodes matched by parts of a matcher.

AnalyzerOptions & options

BlockDataRegion - A region that represents a block instance.

CXXThisRegion - Represents the region for the implicit 'this' parameter in a call to a C++ method.

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

ElementRegion is used to represent both array elements and casts.

QualType getElementType() const

RegionRawOffset getAsArrayOffset() const

Compute the offset within the array. The array might also be a subobject.

AnalysisManager & getAnalysisManager()

LLVM_ATTRIBUTE_RETURNS_NONNULL const FieldDecl * getDecl() const override

static bool isLocType(QualType T)

DefinedOrUnknownSVal getStaticSize(const MemRegion *MR, SValBuilder &SVB) const

MemRegion - The root abstract class for all memory regions.

LLVM_ATTRIBUTE_RETURNS_NONNULL const MemSpaceRegion * getMemorySpace() const

virtual bool isBoundable() const

RegionOffset getAsOffset() const

Compute the offset within the top level memory object.

LLVM_ATTRIBUTE_RETURNS_NONNULL const MemRegion * getBaseRegion() const

bool hasStackNonParametersStorage() const

MemSpaceRegion - A memory region that represents a "memory space"; for example, the set of global var...

Information about invalidation for a particular region/symbol.

@ TK_PreserveContents

Tells that a region's contents is not changed.

@ TK_DoNotInvalidateSuperRegion

@ TK_EntireMemSpace

When applied to a MemSpaceRegion, indicates the entire memory space should be invalidated.

Represent a region's offset within the top level base region.

bool hasSymbolicOffset() const

const MemRegion * getRegion() const

It might return null.

int64_t getOffset() const

const MemRegion * getRegion() const

DefinedOrUnknownSVal makeZeroVal(QualType type)

Construct an SVal representing '0' for the specified type.

NonLoc makeArrayIndex(uint64_t idx)

ASTContext & getContext()

nonloc::ConcreteInt makeIntVal(const IntegerLiteral *integer)

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

DefinedOrUnknownSVal getDerivedRegionValueSymbolVal(SymbolRef parentSymbol, const TypedValueRegion *region)

loc::ConcreteInt makeNullWithType(QualType type)

Create NULL pointer, with proper pointer bit-width for given address space.

std::optional< SVal > getConstantVal(const Expr *E)

Returns the value of E, if it can be determined in a non-path-sensitive manner.

NonLoc makeZeroArrayIndex()

DefinedOrUnknownSVal getRegionValueSymbolVal(const TypedValueRegion *region)

Make a unique symbol for value of region.

NonLoc makeLazyCompoundVal(const StoreRef &store, const TypedValueRegion *region)

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

bool isZeroConstant() const

bool isUnknownOrUndef() const

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.

const MemRegion * getAsRegion() const

T castAs() const

Convert to the specified SVal type, asserting that this SVal is of the desired type.

A utility class that visits the reachable symbols using a custom SymbolVisitor.

bool scan(nonloc::LazyCompoundVal val)

virtual StoreRef invalidateRegions(Store store, ArrayRef< SVal > Values, const Stmt *S, unsigned Count, const LocationContext *LCtx, const CallEvent *Call, InvalidatedSymbols &IS, RegionAndSymbolInvalidationTraits &ITraits, InvalidatedRegions *TopLevelRegions, InvalidatedRegions *Invalidated)=0

invalidateRegions - Clears out the specified regions from the store, marking their values as unknown.

virtual bool scanReachableSymbols(Store S, const MemRegion *R, ScanReachableSymbols &Visitor)=0

Finds the transitive closure of symbols within the given region.

virtual void iterBindings(Store store, BindingsHandler &f)=0

iterBindings - Iterate over the bindings in the Store.

virtual StoreRef getInitialStore(const LocationContext *InitLoc)=0

getInitialStore - Returns the initial "empty" store representing the value bindings upon entry to an ...

virtual StoreRef BindDefaultZero(Store store, const MemRegion *R)=0

Return a store with in which all values within the given region are reset to zero.

virtual std::optional< SVal > getDefaultBinding(Store store, const MemRegion *R)=0

Return the default value bound to a region in a given store.

virtual StoreRef killBinding(Store ST, Loc L)=0

Create a new store with the specified binding removed.

virtual void decrementReferenceCount(Store store)

If the StoreManager supports it, decrement the reference count of the specified Store object.

virtual StoreRef removeDeadBindings(Store store, const StackFrameContext *LCtx, SymbolReaper &SymReaper)=0

virtual void incrementReferenceCount(Store store)

If the StoreManager supports it, increment the reference count of the specified Store object.

virtual SVal ArrayToPointer(Loc Array, QualType ElementTy)=0

ArrayToPointer - Used by ExprEngine::VistCast to handle implicit conversions between arrays and point...

virtual bool includedInBindings(Store store, const MemRegion *region) const =0

virtual SVal getBinding(Store store, Loc loc, QualType T=QualType())=0

Return the value bound to specified location in a given state.

virtual StoreRef BindDefaultInitial(Store store, const MemRegion *R, SVal V)=0

Return a store with the specified value bound to all sub-regions of the region.

virtual void printJson(raw_ostream &Out, Store S, const char *NL, unsigned int Space, bool IsDot) const =0

StringRegion - Region associated with a StringLiteral.

SubRegion - A region that subsets another larger region.

LLVM_ATTRIBUTE_RETURNS_NONNULL const MemRegion * getSuperRegion() const

bool isSubRegionOf(const MemRegion *R) const override

Check if the region is a subregion of the given region.

MemRegionManager & getMemRegionManager() const override

static bool canSymbolicate(QualType T)

A class responsible for cleaning up unused symbols.

llvm::iterator_range< RegionSetTy::const_iterator > regions() const

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

TypedRegion - An abstract class representing regions that are typed.

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

virtual QualType getValueType() const =0

QualType getLocationType() const override

QualType getValueType() const override

const VarDecl * getDecl() const override=0

LLVM_ATTRIBUTE_RETURNS_NONNULL const MemRegion * getRegion() const

Get the underlining region.

The simplest example of a concrete compound value is nonloc::CompoundVal, which represents a concrete...

llvm::ImmutableList< SVal >::iterator iterator

Value representing integer constant.

While nonloc::CompoundVal covers a few simple use cases, nonloc::LazyCompoundVal is a more performant...

LLVM_ATTRIBUTE_RETURNS_NONNULL const LazyCompoundValData * getCVData() const

LLVM_ATTRIBUTE_RETURNS_NONNULL const TypedValueRegion * getRegion() const

This function itself is immaterial.

const void * getStore() const

It might return null.

Defines the clang::TargetInfo interface.

const internal::VariadicDynCastAllOfMatcher< Decl, VarDecl > varDecl

Matches variable declarations.

const internal::VariadicDynCastAllOfMatcher< Stmt, DeclRefExpr > declRefExpr

Matches expressions that refer to declarations.

const internal::ArgumentAdaptingMatcherFunc< internal::HasDescendantMatcher > hasDescendant

Matches AST nodes that have descendant AST nodes that match the provided matcher.

SmallVector< BoundNodes, 1 > match(MatcherT Matcher, const NodeT &Node, ASTContext &Context)

Returns the results of matching Matcher on Node.

internal::Matcher< Stmt > StatementMatcher

const internal::VariadicAllOfMatcher< Stmt > stmt

Matches statements.

llvm::DenseSet< SymbolRef > InvalidatedSymbols

std::unique_ptr< StoreManager > CreateRegionStoreManager(ProgramStateManager &StMgr)

const void * Store

Store - This opaque type encapsulates an immutable mapping from locations to values.

ASTEdit remove(RangeSelector S)

Removes the source selected by S.

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

@ Bind

'bind' clause, allowed on routine constructs.

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

bool operator<(DeclarationName LHS, DeclarationName RHS)

Ordering on two declaration names.

const FunctionProtoType * T

@ Class

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

Diagnostic wrappers for TextAPI types for error reporting.

static raw_ostream & operator<<(raw_ostream &Out, BindingKey K)

__UINTPTR_TYPE__ uintptr_t

An unsigned integer type with the property that any valid pointer to void can be converted to this ty...

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