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

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

clang: lib/Analysis/FlowSensitive/DataflowEnvironment.cpp Source File

llvm::DenseMap<const ValueDecl *, StorageLocation *> &DeclToLoc1,

llvm::DenseMap<const ValueDecl *, StorageLocation *> &DeclToLoc2) {

llvm::DenseMap<const ValueDecl *, StorageLocation *>

;

(

&Entry : DeclToLoc1) {

It = DeclToLoc2.find(Entry.first);

(It != DeclToLoc2.end() && Entry.second == It->second)

.insert({Entry.first, Entry.second});

<

MapT>

(

&Entry : Map2) {

[[maybe_unused]]

[It, Inserted] =

.insert(Entry);

assert(It->second == Entry.second);

(Model.

(

, Val1, Env1, Val2, Env2)) {

llvm_unreachable(

);

(isa<BoolValue>(&Val1) && isa<BoolValue>(&Val2)) {

&Expr1 = cast<BoolValue>(Val1).formula();

&Expr2 = cast<BoolValue>(Val2).formula();

&A = JoinedEnv.

();

A.makeEquals(JoinedVal, Expr1)),

A.makeEquals(JoinedVal, Expr2))));

&A.makeBoolValue(JoinedVal);

Model.

(

, Val1, Env1, Val2, Env2, *JoinedVal, JoinedEnv);

(isa<BoolValue>(Prev) && isa<BoolValue>(Current)) {

&PrevBool = cast<BoolValue>(Prev);

&CurBool = cast<BoolValue>(Current);

(isa<TopBoolValue>(Prev))

TruePrev = PrevEnv.

(PrevBool.formula());

TrueCur = CurrentEnv.

(CurBool.formula());

(TruePrev && TrueCur)

(!TruePrev && !TrueCur &&

(

= Model.

(

, Prev, PrevEnv, Current, CurrentEnv))

<

Key>

llvm::MapVector<Key, Value *> &Map2,

(

&Entry : Map1) {

assert(K !=

);

*Val = Entry.second;

assert(Val !=

);

It = Map2.find(K);

(It == Map2.end())

assert(It->second !=

);

llvm::MapVector<const StorageLocation *, Value *>

(

llvm::MapVector<const StorageLocation *, Value *> &LocToVal,

llvm::MapVector<const StorageLocation *, Value *> &LocToVal2,

llvm::MapVector<const StorageLocation *, Value *>

;

(

&Entry : LocToVal) {

assert(

!=

);

*Val = Entry.second;

assert(Val !=

);

It = LocToVal2.find(

);

(It == LocToVal2.end())

assert(It->second !=

);

->getType(), Val, Env1, It->second, Env2, JoinedEnv, Model)) {

<

Key>

llvm::MapVector<Key, Value *>

llvm::MapVector<Key, Value *> &PrevMap,

llvm::MapVector<Key, Value *> WidenedMap;

(

&Entry : CurMap) {

assert(K !=

);

*Val = Entry.second;

assert(Val !=

);

PrevIt = PrevMap.find(K);

(PrevIt == PrevMap.end())

assert(PrevIt->second !=

);

WidenedMap.insert({K, Val});

K->getType(), *PrevIt->second, PrevEnv, *Val, CurEnv, Model);

WidenedMap.insert({K, WidenedVal});

ResultObjectVisitor :

AnalysisASTVisitor {

ResultObjectVisitor(

llvm::DenseMap<const Expr *, RecordStorageLocation *> &ResultObjectMap,

RecordStorageLocation *LocForRecordReturnVal,

DataflowAnalysisContext &DACtx)

: ResultObjectMap(ResultObjectMap),

LocForRecordReturnVal(LocForRecordReturnVal), DACtx(DACtx) {}

traverseConstructorInits(

CXXConstructorDecl *Ctor,

RecordStorageLocation *ThisPointeeLoc) {

assert(ThisPointeeLoc !=

);

(

CXXCtorInitializer *

: Ctor->inits()) {

Expr *InitExpr =

->getInit();

(FieldDecl *Field =

->getMember();

Field !=

&& Field->getType()->isRecordType()) {

PropagateResultObject(InitExpr, cast<RecordStorageLocation>(

ThisPointeeLoc->getChild(*Field)));

}

(

->getBaseClass()) {

PropagateResultObject(InitExpr, ThisPointeeLoc);

TraverseStmt(InitExpr);

(

*DefaultInit = dyn_cast<CXXDefaultInitExpr>(InitExpr))

TraverseStmt(DefaultInit->getExpr());

VisitVarDecl(VarDecl *VD)

{

(VD->getType()->isRecordType() && VD->hasInit())

PropagateResultObject(

&cast<RecordStorageLocation>(DACtx.getStableStorageLocation(*VD)));

VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *MTE)

{

(MTE->getType()->isRecordType())

PropagateResultObject(

&cast<RecordStorageLocation>(DACtx.getStableStorageLocation(*MTE)));

VisitReturnStmt(ReturnStmt *Return)

{

Expr *

= Return->getRetValue();

PropagateResultObject(

, LocForRecordReturnVal);

VisitExpr(Expr *

)

{

(

->isPRValue() &&

->getType()->isRecordType() &&

!ResultObjectMap.contains(

))

PropagateResultObject(

, &cast<RecordStorageLocation>(DACtx.getStableStorageLocation(*

)));

PropagateResultObjectToRecordInitList(

RecordInitListHelper &InitList,

RecordStorageLocation *

) {

(

[

,

] : InitList.base_inits()) {

assert(

->getType().getCanonicalType() ==

->getType().getCanonicalType());

PropagateResultObject(

,

);

(

[Field,

] : InitList.field_inits()) {

(

->getType()->isRecordType())

PropagateResultObject(

, cast<RecordStorageLocation>(

->getChild(*Field)));

PropagateResultObject(Expr *

, RecordStorageLocation *

) {

(!

->isPRValue() || !

->getType()->isRecordType()) {

ResultObjectMap[

] =

;

(isa<CXXConstructExpr>(

) || isa<CallExpr>(

) || isa<LambdaExpr>(

) ||

isa<CXXDefaultArgExpr>(

) || isa<CXXStdInitializerListExpr>(

) ||

isa<AtomicExpr>(

) || isa<CXXInheritedCtorInitExpr>(

) ||

isa<BuiltinBitCastExpr>(

)) {

(

*Op = dyn_cast<BinaryOperator>(

);

Op && Op->getOpcode() == BO_Cmp) {

(

*InitList = dyn_cast<InitListExpr>(

)) {

(!InitList->isSemanticForm())

(InitList->isTransparent()) {

PropagateResultObject(InitList->getInit(0),

);

PropagateResultObjectToRecordInitList(RecordInitListHelper(InitList),

(

*ParenInitList = dyn_cast<CXXParenListInitExpr>(

)) {

PropagateResultObjectToRecordInitList(RecordInitListHelper(ParenInitList),

(

*Op = dyn_cast<BinaryOperator>(

); Op && Op->isCommaOp()) {

PropagateResultObject(Op->getRHS(),

);

(

*Cond = dyn_cast<AbstractConditionalOperator>(

)) {

PropagateResultObject(Cond->getTrueExpr(),

);

PropagateResultObject(Cond->getFalseExpr(),

);

(

*SE = dyn_cast<StmtExpr>(

)) {

PropagateResultObject(cast<Expr>(SE->getSubStmt()->body_back()),

);

(

*DIE = dyn_cast<CXXDefaultInitExpr>(

)) {

PropagateResultObject(DIE->getExpr(),

);

SmallVector<Stmt *, 1> Children(

->child_begin(),

->child_end());

(Children.size() != 1)

assert(Children.size() == 1);

(Stmt *S : Children)

PropagateResultObject(cast<Expr>(S),

);

llvm::DenseMap<const Expr *, RecordStorageLocation *> &ResultObjectMap;

RecordStorageLocation *LocForRecordReturnVal;

DataflowAnalysisContext &DACtx;

(InitialTargetStmt ==

)

(InitialTargetFunc ==

) {

std::make_shared<PrValueToResultObject>(buildResultObjectMap(

(

*ParamDecl : InitialTargetFunc->

()) {

assert(ParamDecl !=

);

LocForRecordReturnVal = &cast<RecordStorageLocation>(

(

*MethodDecl = dyn_cast<CXXMethodDecl>(InitialTargetFunc)) {

*

= MethodDecl->getParent();

assert(

!=

);

(

->isLambda()) {

(

.capturesVariable()) {

}

(

.capturesThis()) {

*SurroundingMethodDecl = cast<CXXMethodDecl>(Ancestor);

SurroundingMethodDecl->getFunctionObjectParameterType();

cast<RecordStorageLocation>(

(ThisPointeeType)));

}

(

*FieldBeingInitialized =

dyn_cast<FieldDecl>(

->getLambdaContextDecl())) {

FieldBeingInitialized->getParent()->getTypeForDecl(), 0))));

assert(

&&

);

}

(MethodDecl->isImplicitObjectMemberFunction()) {

ThisPointeeType = MethodDecl->getFunctionObjectParameterType();

(!isa<CXXConstructorDecl>(MethodDecl))

std::make_shared<PrValueToResultObject>(buildResultObjectMap(

LocForRecordReturnVal));

Environment::initFieldsGlobalsAndFuncs(

&Referenced) {

DACtx->addModeledFields(Referenced.

);

CallStack.size() < MaxDepth && !llvm::is_contained(CallStack, Callee);

(

*MethodCall = dyn_cast<CXXMemberCallExpr>(

)) {

(

*Arg = MethodCall->getImplicitObjectArgument()) {

(!isa<CXXThisExpr>(Arg))

.ThisPointeeLoc =

(

->getType()->isRecordType() &&

->isPRValue())

.LocForRecordReturnVal = &

.getResultObjectLocation(*

);

.pushCallInternal(

->getDirectCallee(),

.ThisPointeeLoc = &

.getResultObjectLocation(*

);

.LocForRecordReturnVal = &

.getResultObjectLocation(*

);

.pushCallInternal(

->getConstructor(),

Environment::pushCallInternal(

*FuncDecl,

CallStack.push_back(FuncDecl);

(

ArgIndex = 0; ArgIndex < Args.size(); ++ParamIt, ++ArgIndex) {

assert(ParamIt != FuncDecl->

());

*Param = *ParamIt;

ResultObjectMap = std::make_shared<PrValueToResultObject>(

LocForRecordReturnVal));

this->LocToVal = std::move(CalleeEnv.LocToVal);

this->FlowConditionToken = std::move(CalleeEnv.FlowConditionToken);

(

->isGLValue()) {

(CalleeEnv.ReturnLoc !=

)

}

(!

->getType()->isVoidType()) {

(CalleeEnv.ReturnVal !=

)

this->LocToVal = std::move(CalleeEnv.LocToVal);

this->FlowConditionToken = std::move(CalleeEnv.FlowConditionToken);

assert(DACtx ==

.DACtx);

(ReturnVal !=

.ReturnVal)

(ReturnLoc !=

.ReturnLoc)

(LocForRecordReturnVal !=

.LocForRecordReturnVal)

(ThisPointeeLoc !=

.ThisPointeeLoc)

(DeclToLoc !=

.DeclToLoc)

(ExprToLoc !=

.ExprToLoc)

assert(DACtx == PrevEnv.DACtx);

assert(ReturnVal == PrevEnv.ReturnVal);

assert(ReturnLoc == PrevEnv.ReturnLoc);

assert(LocForRecordReturnVal == PrevEnv.LocForRecordReturnVal);

assert(ThisPointeeLoc == PrevEnv.ThisPointeeLoc);

assert(CallStack == PrevEnv.CallStack);

assert(ResultObjectMap == PrevEnv.ResultObjectMap);

assert(InitialTargetFunc == PrevEnv.InitialTargetFunc);

assert(InitialTargetStmt == PrevEnv.InitialTargetStmt);

assert(DeclToLoc.size() <= PrevEnv.DeclToLoc.size());

assert(ExprToVal.size() <= PrevEnv.ExprToVal.size());

assert(ExprToLoc.size() <= PrevEnv.ExprToLoc.size());

(DeclToLoc.size() != PrevEnv.DeclToLoc.size() ||

ExprToLoc.size() != PrevEnv.ExprToLoc.size() ||

ExprToVal.size() != PrevEnv.ExprToVal.size() ||

LocToVal.size() != PrevEnv.LocToVal.size())

assert(EnvA.DACtx == EnvB.DACtx);

assert(EnvA.LocForRecordReturnVal == EnvB.LocForRecordReturnVal);

assert(EnvA.ThisPointeeLoc == EnvB.ThisPointeeLoc);

assert(EnvA.CallStack == EnvB.CallStack);

assert(EnvA.ResultObjectMap == EnvB.ResultObjectMap);

assert(EnvA.InitialTargetFunc == EnvB.InitialTargetFunc);

assert(EnvA.InitialTargetStmt == EnvB.InitialTargetStmt);

JoinedEnv.CallStack = EnvA.CallStack;

JoinedEnv.ResultObjectMap = EnvA.ResultObjectMap;

JoinedEnv.LocForRecordReturnVal = EnvA.LocForRecordReturnVal;

JoinedEnv.ThisPointeeLoc = EnvA.ThisPointeeLoc;

JoinedEnv.InitialTargetFunc = EnvA.InitialTargetFunc;

JoinedEnv.InitialTargetStmt = EnvA.InitialTargetStmt;

JoinedEnv.ReturnVal =

;

JoinedEnv.ReturnVal =

(

->getReturnType(), EnvA.ReturnVal, EnvA, EnvB.ReturnVal,

EnvB, JoinedEnv, Model);

(EnvA.ReturnLoc == EnvB.ReturnLoc)

JoinedEnv.ReturnLoc = EnvA.ReturnLoc;

JoinedEnv.ReturnLoc =

;

EnvA.FlowConditionToken, EnvB.FlowConditionToken);

(EnvA.LocToVal, EnvB.LocToVal, EnvA, EnvB, JoinedEnv, Model);

JoinedEnv.ExprToVal =

(EnvA.ExprToVal, EnvB.ExprToVal);

JoinedEnv.ExprToLoc =

(EnvA.ExprToLoc, EnvB.ExprToLoc);

(Val1 ==

|| Val2 ==

)

assert(!DeclToLoc.contains(&

));

assert(

.getType()->isReferenceType() || isa<BindingDecl>(

) ||

DeclToLoc[&

] = &

;

It = DeclToLoc.find(&

);

(It == DeclToLoc.end())

assert(

.isGLValue() ||

.getType()->isSpecificBuiltinType(BuiltinType::BuiltinFn));

assert(!ExprToLoc.contains(&CanonE));

ExprToLoc[&CanonE] = &

;

assert(

.isGLValue() ||

.getType()->isSpecificBuiltinType(BuiltinType::BuiltinFn));

It == ExprToLoc.end() ? nullptr : &*It->second;

assert(ResultObjectMap !=

);

assert(

!=

);

(

==

)

cast<RecordStorageLocation>(

llvm::DenseSet<QualType>

;

CreatedValuesCount = 0;

llvm::errs() <<

<<

assert(!isa<RecordStorageLocation>(

));

LocToVal[&

] = &Val;

ExprToVal[&CanonE] = &Val;

assert(!isa<RecordStorageLocation>(

));

LocToVal.lookup(&

);

(

==

)

assert(!

.getType()->isRecordType());

(

.isPRValue()) {

It == ExprToVal.end() ? nullptr : It->second;

(It == ExprToLoc.end())

llvm::DenseSet<QualType>

;

CreatedValuesCount = 0;

llvm::errs() <<

<<

*Environment::createValueUnlessSelfReferential(

&CreatedValuesCount) {

assert(!

.isNull());

CreatedValuesCount++;

CreatedValuesCount++;

(

->isPointerType()) {

CreatedValuesCount++;

QualType PointeeType =

->getPointeeType();

StorageLocation &PointeeLoc =

createLocAndMaybeValue(PointeeType,

, Depth, CreatedValuesCount);

&

().

<PointerValue>(PointeeLoc);

Environment::createLocAndMaybeValue(QualType Ty,

llvm::DenseSet<QualType> &

,

Depth,

&CreatedValuesCount) {

(!

.insert(Ty.getCanonicalType()).second)

EraseVisited = llvm::make_scope_exit(

Ty = Ty.getNonReferenceType();

(Ty->isRecordType()) {

(

*Val = createValueUnlessSelfReferential(Ty,

, Depth,

CreatedValuesCount))

llvm::DenseSet<QualType> &

,

&CreatedValuesCount) {

= [&](QualType FieldType, StorageLocation &FieldLoc) {

(FieldType->isRecordType()) {

&FieldRecordLoc = cast<RecordStorageLocation>(FieldLoc);

, Depth + 1, CreatedValuesCount);

(

(FieldLoc) !=

)

(!

.insert(FieldType.getCanonicalType()).second)

(

*Val = createValueUnlessSelfReferential(

FieldType,

, Depth + 1, CreatedValuesCount))

.erase(FieldType.getCanonicalType());

assert(Field !=

);

QualType FieldType =

->getType();

(FieldType->isReferenceType()) {

.setChild(*Field,

&createLocAndMaybeValue(FieldType,

, Depth + 1,

CreatedValuesCount));

StorageLocation *FieldLoc =

.getChild(*Field);

assert(FieldLoc !=

);

assert(!FieldType->isReferenceType());

(FieldType,

.getSyntheticField(FieldName));

StorageLocation &Environment::createObjectInternal(

ValueDecl *

,

Expr *InitExpr) {

(Ty->isReferenceType()) {

*InitExprLoc;

createObjectInternal(

, Ty.getNonReferenceType(),

);

StorageLocation &

=

(Ty->isRecordType()) {

*Val =

;

llvm::DenseMap<const StorageLocation *, std::string> LocToName;

(LocForRecordReturnVal !=

)

LocToName[LocForRecordReturnVal] =

;

(ThisPointeeLoc !=

)

LocToName[ThisPointeeLoc] =

;

OS <<

;

(

[

, L] : DeclToLoc) {

= LocToName.insert({L,

->getNameAsString()}).first;

OS <<

<<

->second <<

<< L <<

;

OS <<

;

(

[

, L] : ExprToLoc)

OS <<

<<

<<

<< L <<

;

OS <<

;

(

[

,

] : ExprToVal)

OS <<

<<

<<

<<

<<

<< *

<<

;

OS <<

;

(

[L,

] : LocToVal) {

(

= LocToName.find(L);

!= LocToName.end())

OS <<

<<

->second <<

;

OS <<

<<

<<

<< *

<<

;

(

->getReturnType()->isReferenceType()) {

OS <<

<< ReturnLoc;

(

= LocToName.find(ReturnLoc);

!= LocToName.end())

OS <<

<<

->second <<

;

}

(

->getReturnType()->isRecordType() ||

isa<CXXConstructorDecl>(

)) {

OS <<

<< LocForRecordReturnVal <<

;

}

(!

->getReturnType()->isVoidType()) {

(ReturnVal ==

)

OS <<

;

OS <<

<< *ReturnVal <<

;

(isa<CXXMethodDecl>(

)) {

OS <<

<< ThisPointeeLoc <<

;

Environment::PrValueToResultObject Environment::buildResultObjectMap(

PrValueToResultObject Map = buildResultObjectMap(

DACtx, FuncDecl->

(), ThisPointeeLoc, LocForRecordReturnVal);

ResultObjectVisitor Visitor(Map, LocForRecordReturnVal, *DACtx);

(

*Ctor = dyn_cast<CXXConstructorDecl>(FuncDecl))

Visitor.traverseConstructorInits(Ctor, ThisPointeeLoc);

Environment::PrValueToResultObject Environment::buildResultObjectMap(

DataflowAnalysisContext *DACtx,

*S,

RecordStorageLocation *ThisPointeeLoc,

RecordStorageLocation *LocForRecordReturnVal) {

PrValueToResultObject Map;

ResultObjectVisitor Visitor(Map, LocForRecordReturnVal, *DACtx);

Visitor.TraverseStmt(S);

(ImplicitObject ==

)

&cast<RecordStorageLocation>(Val->getPointeeLoc());

cast_or_null<RecordStorageLocation>(

(

==

)

&cast<RecordStorageLocation>(Val->getPointeeLoc());

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

static void initField(Block *B, std::byte *Ptr, bool IsConst, bool IsMutable, bool IsActive, bool IsUnionField, bool InUnion, const Descriptor *D, unsigned FieldOffset)

Defines the clang::Expr interface and subclasses for C++ expressions.

llvm::DenseSet< const void * > Visited

static bool RetValue(InterpState &S, CodePtr &Pt)

llvm::MachO::RecordLoc RecordLoc

C Language Family Type Representation.

Represents a call to a C++ constructor.

Represents a call to a member function that may be written either with member call syntax (e....

Expr * getImplicitObjectArgument() const

Retrieve the implicit object argument for the member call.

CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).

Decl * getNonClosureAncestor()

Find the nearest non-closure ancestor of this context, i.e.

This represents one expression.

Represents a function declaration or definition.

Stmt * getBody(const FunctionDecl *&Definition) const

Retrieve the body (definition) of the function.

param_iterator param_end()

QualType getReturnType() const

ArrayRef< ParmVarDecl * > parameters() const

param_iterator param_begin()

bool doesThisDeclarationHaveABody() const

Returns whether this specific declaration of the function has a body.

FunctionDecl * getDefinition()

Get the definition for this declaration.

MemberExpr - [C99 6.5.2.3] Structure and Union Members.

A (possibly-)qualified type.

Stmt - This represents one statement.

The base class of the type hierarchy.

bool isBooleanType() const

bool isPointerType() const

bool isIntegerType() const

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

bool isReferenceType() const

bool isRecordType() const

Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...

Represents a variable declaration or definition.

const Formula & makeAtomRef(Atom A)

Returns a formula for the variable A.

const Formula & makeNot(const Formula &Val)

Returns a formula for the negation of Val.

std::enable_if_t< std::is_base_of< StorageLocation, T >::value, T & > create(Args &&...args)

Creates a T (some subclass of StorageLocation), forwarding args to the constructor,...

Owns objects that encompass the state of a program and stores context that is used during dataflow an...

Atom joinFlowConditions(Atom FirstToken, Atom SecondToken)

Creates a new flow condition that represents the disjunction of the flow conditions identified by Fir...

void addFlowConditionConstraint(Atom Token, const Formula &Constraint)

Adds Constraint to the flow condition identified by Token.

Atom forkFlowCondition(Atom Token)

Creates a new flow condition with the same constraints as the flow condition identified by Token and ...

StorageLocation & getStableStorageLocation(const ValueDecl &D)

Returns a stable storage location for D.

bool flowConditionImplies(Atom Token, const Formula &F)

Returns true if the constraints of the flow condition identified by Token imply that F is true.

bool flowConditionAllows(Atom Token, const Formula &F)

Returns true if the constraints of the flow condition identified by Token still allow F to be true.

PointerValue & getOrCreateNullPointerValue(QualType PointeeType)

Returns a pointer value that represents a null pointer.

llvm::StringMap< QualType > getSyntheticFields(QualType Type)

Returns the names and types of the synthetic fields for the given record type.

StorageLocation & createStorageLocation(QualType Type)

Returns a new storage location appropriate for Type.

FieldSet getModeledFields(QualType Type)

Returns the fields of Type, limited to the set of fields modeled by this context.

LLVM_DUMP_METHOD void dumpFlowCondition(Atom Token, llvm::raw_ostream &OS=llvm::dbgs())

Supplements Environment with non-standard comparison and join operations.

virtual std::optional< WidenResult > widen(QualType Type, Value &Prev, const Environment &PrevEnv, Value &Current, Environment &CurrentEnv)

This function may widen the current value – replace it with an approximation that can reach a fixed p...

virtual void join(QualType Type, const Value &Val1, const Environment &Env1, const Value &Val2, const Environment &Env2, Value &JoinedVal, Environment &JoinedEnv)

Modifies JoinedVal to approximate both Val1 and Val2.

virtual ComparisonResult compare(QualType Type, const Value &Val1, const Environment &Env1, const Value &Val2, const Environment &Env2)

Returns: Same: Val1 is equivalent to Val2, according to the model.

Holds the state of the program (store and heap) at a given program point.

bool allows(const Formula &) const

Returns true if the formula may be true when this point is reached.

LatticeEffect widen(const Environment &PrevEnv, Environment::ValueModel &Model)

Widens the environment point-wise, using PrevEnv as needed to inform the approximation.

PointerValue & getOrCreateNullPointerValue(QualType PointeeType)

Returns a pointer value that represents a null pointer.

RecordStorageLocation * getThisPointeeStorageLocation() const

Returns the storage location assigned to the this pointee in the environment or null if the this poin...

Environment pushCall(const CallExpr *Call) const

Creates and returns an environment to use for an inline analysis of the callee.

StorageLocation * getStorageLocation(const ValueDecl &D) const

Returns the storage location assigned to D in the environment, or null if D isn't assigned a storage ...

LLVM_DUMP_METHOD void dump() const

BoolValue & makeTopBoolValue() const

Returns a unique instance of boolean Top.

void initializeFieldsWithValues(RecordStorageLocation &Loc, QualType Type)

Initializes the fields (including synthetic fields) of Loc with values, unless values of the field ty...

StorageLocation & createStorageLocation(QualType Type)

Creates a storage location appropriate for Type.

Environment fork() const

Returns a new environment that is a copy of this one.

void popCall(const CallExpr *Call, const Environment &CalleeEnv)

Moves gathered information back into this from a CalleeEnv created via pushCall.

bool equivalentTo(const Environment &Other, Environment::ValueModel &Model) const

Returns true if and only if the environment is equivalent to Other, i.e the two environments:

BoolValue & makeAtomicBoolValue() const

Returns an atomic boolean value.

bool proves(const Formula &) const

Returns true if the formula is always true when this point is reached.

Value * getValue(const StorageLocation &Loc) const

Returns the value assigned to Loc in the environment or null if Loc isn't assigned a value in the env...

const FunctionDecl * getCurrentFunc() const

Returns the function currently being analyzed, or null if the code being analyzed isn't part of a fun...

BoolValue & getBoolLiteralValue(bool Value) const

Returns a symbolic boolean value that models a boolean literal equal to Value

StorageLocation & createObject(QualType Ty, const Expr *InitExpr=nullptr)

Creates an object (i.e.

void assume(const Formula &)

Record a fact that must be true if this point in the program is reached.

static Value * joinValues(QualType Ty, Value *Val1, const Environment &Env1, Value *Val2, const Environment &Env2, Environment &JoinedEnv, Environment::ValueModel &Model)

Returns a value that approximates both Val1 and Val2, or null if no such value can be produced.

void setStorageLocation(const ValueDecl &D, StorageLocation &Loc)

Assigns Loc as the storage location of D in the environment.

void removeDecl(const ValueDecl &D)

Removes the location assigned to D in the environment (if any).

RecordStorageLocation & getResultObjectLocation(const Expr &RecordPRValue) const

Returns the location of the result object for a record-type prvalue.

ExprJoinBehavior

How to treat expression state (ExprToLoc and ExprToVal) in a join.

static Environment join(const Environment &EnvA, const Environment &EnvB, Environment::ValueModel &Model, ExprJoinBehavior ExprBehavior)

Joins two environments by taking the intersection of storage locations and values that are stored in ...

Value * createValue(QualType Type)

Creates a value appropriate for Type, if Type is supported, otherwise returns null.

void setValue(const StorageLocation &Loc, Value &Val)

Assigns Val as the value of Loc in the environment.

void setThisPointeeStorageLocation(RecordStorageLocation &Loc)

Sets the storage location assigned to the this pointee in the environment.

Atom getFlowConditionToken() const

Returns a boolean variable that identifies the flow condition (FC).

bool canDescend(unsigned MaxDepth, const FunctionDecl *Callee) const

Returns whether this Environment can be extended to analyze the given Callee (i.e.

std::enable_if_t< std::is_base_of_v< StorageLocation, T >, T * > get(const ValueDecl &D) const

Returns the result of casting getStorageLocation(...) to a subclass of StorageLocation (using cast_or...

void initialize()

Assigns storage locations and values to all parameters, captures, global variables,...

Models a symbolic pointer. Specifically, any value of type T*.

A storage location for a record (struct, class, or union).

Base class for elements of the local variable store and of the heap.

Base class for all values computed by abstract interpretation.

static bool compareKeyToValueMaps(const llvm::MapVector< Key, Value * > &Map1, const llvm::MapVector< Key, Value * > &Map2, const Environment &Env1, const Environment &Env2, Environment::ValueModel &Model)

static llvm::DenseMap< const ValueDecl *, StorageLocation * > intersectDeclToLoc(const llvm::DenseMap< const ValueDecl *, StorageLocation * > &DeclToLoc1, const llvm::DenseMap< const ValueDecl *, StorageLocation * > &DeclToLoc2)

Returns a map consisting of key-value entries that are present in both maps.

static bool equateUnknownValues(Value::Kind K)

bool areEquivalentValues(const Value &Val1, const Value &Val2)

An equivalence relation for values.

static llvm::MapVector< Key, Value * > widenKeyToValueMap(const llvm::MapVector< Key, Value * > &CurMap, const llvm::MapVector< Key, Value * > &PrevMap, Environment &CurEnv, const Environment &PrevEnv, Environment::ValueModel &Model, LatticeEffect &Effect)

static constexpr int MaxCompositeValueDepth

static constexpr int MaxCompositeValueSize

ReferencedDecls getReferencedDecls(const FunctionDecl &FD)

Returns declarations that are declared in or referenced from FD.

RecordStorageLocation * getImplicitObjectLocation(const CXXMemberCallExpr &MCE, const Environment &Env)

Returns the storage location for the implicit object of a CXXMemberCallExpr, or null if none is defin...

static WidenResult widenDistinctValues(QualType Type, Value &Prev, const Environment &PrevEnv, Value &Current, Environment &CurrentEnv, Environment::ValueModel &Model)

const Expr & ignoreCFGOmittedNodes(const Expr &E)

Skip past nodes that the CFG does not emit.

static llvm::MapVector< const StorageLocation *, Value * > joinLocToVal(const llvm::MapVector< const StorageLocation *, Value * > &LocToVal, const llvm::MapVector< const StorageLocation *, Value * > &LocToVal2, const Environment &Env1, const Environment &Env2, Environment &JoinedEnv, Environment::ValueModel &Model)

static MapT joinExprMaps(const MapT &Map1, const MapT &Map2)

static bool compareDistinctValues(QualType Type, Value &Val1, const Environment &Env1, Value &Val2, const Environment &Env2, Environment::ValueModel &Model)

RecordStorageLocation * getBaseObjectLocation(const MemberExpr &ME, const Environment &Env)

Returns the storage location for the base object of a MemberExpr, or null if none is defined in the e...

static Value * joinDistinctValues(QualType Type, Value &Val1, const Environment &Env1, Value &Val2, const Environment &Env2, Environment &JoinedEnv, Environment::ValueModel &Model)

Attempts to join distinct values Val1 and Val2 in Env1 and Env2, respectively, of the same type Type.

LatticeEffect

Effect indicating whether a lattice operation resulted in a new value.

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

@ Result

The result type of a method or function.

@ Other

Other implicit parameter.

A collection of several types of declarations, all referenced from the same function.

llvm::DenseSet< const VarDecl * > Globals

All variables with static storage duration, notably including static member variables and static vari...

llvm::DenseSet< const FunctionDecl * > Functions

Free functions and member functions which are referenced (but not necessarily called).

FieldSet Fields

Non-static member variables.

The result of a widen operation.

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