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

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

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

(

==

) {

(

->getBlockID() == CurBlockID)

&CurState.

;

&State = BlockToState[

->getBlockID()];

(LHSValue == RHSValue)

(

*LHSBool = dyn_cast_or_null<BoolValue>(LHSValue))

(

*RHSBool = dyn_cast_or_null<BoolValue>(RHSValue))

(

*LHSPtr = dyn_cast_or_null<PointerValue>(LHSValue))

(

*RHSPtr = dyn_cast_or_null<PointerValue>(RHSValue))

(&LHSPtr->getPointeeLoc() == &RHSPtr->getPointeeLoc())

(

*Top = llvm::dyn_cast<TopBoolValue>(&

)) {

*B = dyn_cast_or_null<BoolValue>(Val);

(&UnpackedVal == Val)

TransferVisitor(

StmtToEnvMap &StmtToEnv, Environment &Env,

Environment::ValueModel &Model)

: StmtToEnv(StmtToEnv),

(

), Model(Model) {}

VisitBinaryOperator(

BinaryOperator *S) {

Expr *LHS = S->getLHS();

assert(LHS !=

);

Expr *RHS = S->getRHS();

assert(RHS !=

);

(S->isCompoundAssignmentOp())

(S->getOpcode()) {

*LHSLoc =

.getStorageLocation(*LHS);

(LHSLoc ==

)

*RHSVal =

.getValue(*RHS);

(RHSVal ==

)

.setValue(*LHSLoc, *RHSVal);

.setStorageLocation(*S, *LHSLoc);

BoolValue &LHSVal = getLogicOperatorSubExprValue(*LHS);

BoolValue &RHSVal = getLogicOperatorSubExprValue(*RHS);

(S->getOpcode() == BO_LAnd)

.setValue(*S,

.makeAnd(LHSVal, RHSVal));

.setValue(*S,

.makeOr(LHSVal, RHSVal));

.setValue(*S, S->getOpcode() == BO_EQ ? LHSEqRHSValue

:

.makeNot(LHSEqRHSValue));

VisitDeclRefExpr(

DeclRefExpr *S) {

ValueDecl *VD = S->getDecl();

assert(VD !=

);

*DeclLoc =

.getStorageLocation(*VD);

(DeclLoc ==

)

.setStorageLocation(*S, *DeclLoc);

VisitDeclStmt(

DeclStmt *S) {

&

= *cast<VarDecl>(S->getSingleDecl());

ProcessVarDecl(

VarDecl &

) {

(

.hasGlobalStorage())

(

.getType()->isReferenceType() &&

.getStorageLocation(

) !=

)

assert(

.getStorageLocation(

) ==

);

.setStorageLocation(

,

.createObject(

));

(

*Decomp = dyn_cast<DecompositionDecl>(&

)) {

(

*B : Decomp->bindings()) {

(

*ME = dyn_cast_or_null<MemberExpr>(B->getBinding())) {

*DE = dyn_cast_or_null<DeclRefExpr>(ME->getBase());

VisitDeclRefExpr(DE);

(

*

=

.getStorageLocation(*ME))

.setStorageLocation(*B, *

);

}

(

*VD = B->getHoldingVar()) {

*VDLoc =

.getStorageLocation(*VD);

assert(VDLoc !=

);

.setStorageLocation(*B, *VDLoc);

VisitImplicitCastExpr(

ImplicitCastExpr *S) {

Expr *SubExpr = S->getSubExpr();

assert(SubExpr !=

);

(S->getCastKind()) {

CK_IntegralToBoolean: {

(

*SubExprVal =

dyn_cast_or_null<BoolValue>(

.getValue(*SubExpr)))

.setValue(*S, *SubExprVal);

.setValue(*S,

.makeAtomicBoolValue());

CK_LValueToRValue: {

(SubExprVal ==

)

.setValue(*S, *SubExprVal);

CK_IntegralCast:

CK_UncheckedDerivedToBase:

CK_ConstructorConversion:

CK_UserDefinedConversion:

CK_NullToPointer: {

&NullPointerVal =

.getOrCreateNullPointerValue(S->getType()->getPointeeType());

.setValue(*S, NullPointerVal);

CK_NullToMemberPointer:

CK_FunctionToPointerDecay: {

StorageLocation *PointeeLoc =

.getStorageLocation(*SubExpr);

(PointeeLoc ==

)

.setValue(*S,

.create<PointerValue>(*PointeeLoc));

CK_BuiltinFnToFnPtr:

VisitUnaryOperator(

UnaryOperator *S) {

Expr *SubExpr = S->getSubExpr();

assert(SubExpr !=

);

(S->getOpcode()) {

*SubExprVal =

.get<PointerValue>(*SubExpr);

(SubExprVal ==

)

.setStorageLocation(*S, SubExprVal->getPointeeLoc());

(S->getType()->isMemberPointerType())

(StorageLocation *PointeeLoc =

.getStorageLocation(*SubExpr))

.setValue(*S,

.create<PointerValue>(*PointeeLoc));

*SubExprVal = dyn_cast_or_null<BoolValue>(

.getValue(*SubExpr));

(SubExprVal ==

)

.setValue(*S,

.makeNot(*SubExprVal));

(StorageLocation *

=

.getStorageLocation(*S->getSubExpr()))

(StorageLocation *

=

.getStorageLocation(*S->getSubExpr()))

VisitCXXThisExpr(

CXXThisExpr *S) {

*ThisPointeeLoc =

.getThisPointeeStorageLocation();

(ThisPointeeLoc ==

)

.setValue(*S,

.create<PointerValue>(*ThisPointeeLoc));

VisitCXXNewExpr(

CXXNewExpr *S) {

(

*Val =

.createValue(S->getType()))

.setValue(*S, *Val);

VisitCXXDeleteExpr(

CXXDeleteExpr *S) {

VisitReturnStmt(

ReturnStmt *S) {

(!

.getDataflowAnalysisContext().getOptions().ContextSensitiveOpts)

*

= S->getRetValue();

(

->isPRValue()) {

(

->getType()->isRecordType())

*Val =

.getValue(*Ret);

.setReturnValue(Val);

*

=

.getStorageLocation(*Ret);

(

==

)

.setReturnStorageLocation(

);

VisitMemberExpr(

MemberExpr *S) {

ValueDecl *

= S->getMemberDecl();

assert(

!=

);

(

->isFunctionOrFunctionTemplate())

(isa<EnumConstantDecl>(

))

(

*

= dyn_cast<VarDecl>(

)) {

(

->hasGlobalStorage()) {

*VarDeclLoc =

.getStorageLocation(*

);

(VarDeclLoc ==

)

.setStorageLocation(*S, *VarDeclLoc);

(BaseLoc ==

)

*MemberLoc = BaseLoc->getChild(*

);

(MemberLoc ==

)

.setStorageLocation(*S, *MemberLoc);

VisitCXXDefaultArgExpr(

CXXDefaultArgExpr *S) {

Expr *ArgExpr = S->getExpr();

assert(ArgExpr !=

);

(S->isPRValue() && S->getType()->isRecordType()) {

&

=

.getResultObjectLocation(*S);

.initializeFieldsWithValues(

);

VisitCXXDefaultInitExpr(

CXXDefaultInitExpr *S) {

Expr *InitExpr = S->getExpr();

assert(InitExpr !=

);

(S->getType()->isRecordType() && S->isPRValue())

VisitCXXConstructExpr(

CXXConstructExpr *S) {

CXXConstructorDecl *ConstructorDecl = S->getConstructor();

assert(ConstructorDecl !=

);

(!S->getType()->isRecordType()) {

transferInlineCall(S, ConstructorDecl);

RecordStorageLocation &

=

.getResultObjectLocation(*S);

(ConstructorDecl->isCopyOrMoveConstructor()) {

assert(S->getNumArgs() != 0);

Expr *Arg = S->getArg(0);

assert(Arg !=

);

*ArgLoc =

.get<RecordStorageLocation>(*Arg);

(ArgLoc ==

)

.initializeFieldsWithValues(

, S->getType());

transferInlineCall(S, ConstructorDecl);

VisitCXXOperatorCallExpr(

CXXOperatorCallExpr *S) {

(S->getOperator() == OO_Equal) {

assert(S->getNumArgs() == 2);

Expr *Arg0 = S->getArg(0);

assert(Arg0 !=

);

Expr *Arg1 = S->getArg(1);

assert(Arg1 !=

);

dyn_cast_or_null<CXXMethodDecl>(S->getDirectCallee());

(!Method->isCopyAssignmentOperator() &&

!Method->isMoveAssignmentOperator())

RecordStorageLocation *LocSrc =

;

(Arg1->isPRValue()) {

LocSrc = &

.getResultObjectLocation(*Arg1);

LocSrc =

.get<RecordStorageLocation>(*Arg1);

*LocDst =

.get<RecordStorageLocation>(*Arg0);

(LocSrc ==

|| LocDst ==

)

(S->getType().getCanonicalType().getUnqualifiedType() !=

LocDst->getType().getCanonicalType().getUnqualifiedType()) {

ReturnDecl = S->getType()->getAsCXXRecordDecl();

DstDecl = LocDst->getType()->getAsCXXRecordDecl();

(ReturnDecl ==

|| DstDecl ==

)

(!DstDecl->isDerivedFrom(ReturnDecl))

.setStorageLocation(*S, *LocDst);

VisitCXXRewrittenBinaryOperator(

CXXRewrittenBinaryOperator *RBO) {

VisitCallExpr(

CallExpr *S) {

(S->isCallToStdMove()) {

assert(S->getNumArgs() == 1);

Expr *Arg = S->getArg(0);

assert(Arg !=

);

*ArgLoc =

.getStorageLocation(*Arg);

(ArgLoc ==

)

.setStorageLocation(*S, *ArgLoc);

}

(S->getDirectCallee() !=

&&

S->getDirectCallee()->getBuiltinID() ==

Builtin::BI__builtin_expect) {

assert(S->getNumArgs() > 0);

assert(S->getArg(0) !=

);

*ArgVal =

.getValue(*S->getArg(0));

(ArgVal ==

)

.setValue(*S, *ArgVal);

}

(

FunctionDecl *F = S->getDirectCallee()) {

transferInlineCall(S, F);

(S->getType()->isRecordType() && S->isPRValue()) {

RecordStorageLocation &

=

.getResultObjectLocation(*S);

.initializeFieldsWithValues(

);

VisitMaterializeTemporaryExpr(

MaterializeTemporaryExpr *S) {

Expr *SubExpr = S->getSubExpr();

assert(SubExpr !=

);

StorageLocation &

=

.createStorageLocation(*S);

.setStorageLocation(*S,

);

(SubExpr->getType()->isRecordType())

(

*SubExprVal =

.getValue(*SubExpr))

.setValue(

, *SubExprVal);

VisitCXXBindTemporaryExpr(

CXXBindTemporaryExpr *S) {

Expr *SubExpr = S->getSubExpr();

assert(SubExpr !=

);

VisitCXXStaticCastExpr(

CXXStaticCastExpr *S) {

(S->getCastKind() == CK_NoOp) {

Expr *SubExpr = S->getSubExpr();

assert(SubExpr !=

);

VisitConditionalOperator(

ConditionalOperator *S) {

Environment *TrueEnv = StmtToEnv.getEnvironment(*S->getTrueExpr());

Environment *FalseEnv = StmtToEnv.getEnvironment(*S->getFalseExpr());

(TrueEnv ==

|| FalseEnv ==

) {

(S->isGLValue()) {

StorageLocation *TrueLoc = TrueEnv->getStorageLocation(*S->getTrueExpr());

StorageLocation *FalseLoc =

FalseEnv->getStorageLocation(*S->getFalseExpr());

(TrueLoc == FalseLoc && TrueLoc !=

)

.setStorageLocation(*S, *TrueLoc);

}

(!S->getType()->isRecordType()) {

S->getType(), TrueEnv->getValue(*S->getTrueExpr()), *TrueEnv,

FalseEnv->getValue(*S->getFalseExpr()), *FalseEnv, Env, Model))

.setValue(*S, *Val);

VisitInitListExpr(

InitListExpr *S) {

QualType

= S->getType();

(!

->isRecordType()) {

(!

->isArrayType() && S->getNumInits() == 1)

(S->isSemanticForm() && S->isTransparent())

RecordStorageLocation &

=

.getResultObjectLocation(*S);

RecordInitListHelper InitListHelper(S);

(

[Field,

] : InitListHelper.field_inits()) {

(

->getType()->isRecordType())

(

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

assert(

->getType().getCanonicalType()->getPointeeType() ==

->getType().getCanonicalType());

assert(

->getType().getCanonicalType().getUnqualifiedType() ==

->getType().getCanonicalType().getUnqualifiedType());

StorageLocation *FieldLoc =

.getChild(*Field);

assert(FieldLoc !=

);

(Val ==

&& isa<ImplicitValueInitExpr>(

) &&

->getType()->isPointerType())

&

.getOrCreateNullPointerValue(

->getType()->getPointeeType());

Val =

.createValue(

->getType());

.setValue(*FieldLoc, *Val);

(

&[FieldName, FieldLoc] :

.synthetic_fields()) {

QualType FieldType = FieldLoc->getType();

(FieldType->isRecordType()) {

.initializeFieldsWithValues(*cast<RecordStorageLocation>(FieldLoc));

(

*Val =

.createValue(FieldType))

.setValue(*FieldLoc, *Val);

VisitCXXBoolLiteralExpr(

CXXBoolLiteralExpr *S) {

.setValue(*S,

.getBoolLiteralValue(S->getValue()));

VisitIntegerLiteral(

IntegerLiteral *S) {

.setValue(*S,

.getIntLiteralValue(S->getValue()));

VisitParenExpr(

ParenExpr *S) {

*SubExpr = S->getSubExpr();

assert(SubExpr !=

);

VisitExprWithCleanups(

ExprWithCleanups *S) {

*SubExpr = S->getSubExpr();

assert(SubExpr !=

);

BoolValue &getLogicOperatorSubExprValue(

Expr &SubExpr) {

(

Environment *SubExprEnv = StmtToEnv.getEnvironment(SubExpr))

dyn_cast_or_null<BoolValue>(SubExprEnv->getValue(SubExpr)))

(

.getValue(SubExpr) ==

)

(

*Val = dyn_cast_or_null<BoolValue>(

.getValue(SubExpr)))

.makeAtomicBoolValue();

<

E>

transferInlineCall(

*S,

FunctionDecl *F) {

&Options =

.getDataflowAnalysisContext().getOptions();

(!(Options.ContextSensitiveOpts &&

.canDescend(Options.ContextSensitiveOpts->Depth, F)))

AdornedCFG *ACFG =

.getDataflowAnalysisContext().getAdornedCFG(F);

ExitBlock = ACFG->getCFG().getExit().getBlockID();

CalleeEnv =

.pushCall(S);

= NoopAnalysis(ACFG->getDecl().getASTContext(),

DataflowAnalysisOptions{Options});

BlockToOutputState =

assert(BlockToOutputState);

assert(ExitBlock < BlockToOutputState->size());

&ExitState = (*BlockToOutputState)[ExitBlock];

.popCall(S, ExitState->Env);

StmtToEnvMap &StmtToEnv;

Environment::ValueModel &Model;

TransferVisitor(StmtToEnv,

, Model).Visit(&S);

Defines enum values for all the target-independent builtin functions.

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

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

Defines an enumeration for C++ overloaded operators.

TypeErasedDataflowAnalysis & Analysis

The analysis to be run.

Represents a single basic block in a source-level CFG.

ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.

This represents one expression.

Stmt - This represents one statement.

bool isRecordType() const

const CFGBlock * blockForStmt(const Stmt &S) const

Returns the basic block that contains S, or null if no basic block containing S is found.

bool isBlockReachable(const CFGBlock &B) const

Returns whether B is reachable from the entry block.

BoolValue & makeBoolValue(const Formula &)

Creates a BoolValue wrapping a particular formula.

Supplements Environment with non-standard comparison and join operations.

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

BoolValue & makeIff(BoolValue &LHS, BoolValue &RHS) const

Returns a boolean value represents LHS <=> RHS.

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

BoolValue & makeAtomicBoolValue() const

Returns an atomic boolean value.

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

BoolValue & getBoolLiteralValue(bool Value) const

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

DataflowAnalysisContext & getDataflowAnalysisContext() const

Returns the DataflowAnalysisContext used by the environment.

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 setValue(const StorageLocation &Loc, Value &Val)

Assigns Val as the value of Loc in the environment.

Maps statements to the environments of basic blocks that contain them.

const Environment * getEnvironment(const Stmt &S) const

Returns the environment of the basic block that contains S.

Base class for all values computed by abstract interpretation.

void transfer(const StmtToEnvMap &StmtToEnv, const Stmt &S, Environment &Env, Environment::ValueModel &Model)

Evaluates S and updates Env accordingly.

static void propagateValueOrStorageLocation(const Expr &From, const Expr &To, Environment &Env)

static void propagateStorageLocation(const Expr &From, const Expr &To, Environment &Env)

static void propagateValue(const Expr &From, const Expr &To, Environment &Env)

static Value * maybeUnpackLValueExpr(const Expr &E, Environment &Env)

void copyRecord(RecordStorageLocation &Src, RecordStorageLocation &Dst, Environment &Env)

Copies a record (struct, class, or union) from Src to Dst.

static BoolValue & unpackValue(BoolValue &V, Environment &Env)

static BoolValue & evaluateBooleanEquality(const Expr &LHS, const Expr &RHS, Environment &Env)

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

llvm::Expected< std::vector< std::optional< DataflowAnalysisState< typename AnalysisT::Lattice > > > > runDataflowAnalysis(const AdornedCFG &ACFG, AnalysisT &Analysis, const Environment &InitEnv, CFGEltCallbacks< AnalysisT > PostAnalysisCallbacks={}, std::int32_t MaxBlockVisits=kDefaultMaxBlockVisits)

Performs dataflow analysis and returns a mapping from basic block IDs to dataflow analysis states tha...

bool Ret(InterpState &S, CodePtr &PC)

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

Environment Env

Model of the state of the program (store and heap).

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