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

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

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

CLANG_EXPORT_TEMPLATE Any::TypeId<clang::dataflow::NoopLattice>;

BlockPos = llvm::find_if(

return Succ && Succ->getBlockID() == Block.getBlockID();

TerminatorVisitor

TerminatorVisitor() =

;

*VisitIfStmt(

*S) {

S->getCond(); }

Expr *VisitWhileStmt(

WhileStmt *S) {

S->getCond(); }

Expr *VisitDoStmt(

DoStmt *S) {

S->getCond(); }

Expr *VisitForStmt(

ForStmt *S) {

S->getCond(); }

Expr *VisitCXXForRangeStmt(

CXXForRangeStmt *) {

Expr *VisitBinaryOperator(

BinaryOperator *S) {

assert(S->getOpcode() == BO_LAnd || S->getOpcode() == BO_LOr);

Expr *VisitConditionalOperator(

ConditionalOperator *S) {

AnalysisContext {

AnalysisContext(

AdornedCFG &

, TypeErasedDataflowAnalysis &

,

(*

.getDataflowAnalysisContext().getOptions().

),

~AnalysisContext() {

.endAnalysis(); }

PrettyStackTraceAnalysis :

llvm::PrettyStackTraceEntry {

PrettyStackTraceAnalysis(

AdornedCFG &ACFG,

*Message)

: ACFG(ACFG), Message(Message) {}

(raw_ostream &OS)

{

OS << Message <<

;

ACFG.getDecl().dump(OS);

ACFG.getCFG().print(OS, LangOptions(),

);

AdornedCFG &ACFG;

PrettyStackTraceCFGElement :

llvm::PrettyStackTraceEntry {

PrettyStackTraceCFGElement(

CFGElement &Element,

BlockIdx,

ElementIdx,

*Message)

: Element(Element), BlockIdx(BlockIdx), ElementIdx(ElementIdx),

(raw_ostream &OS)

{

OS << Message <<

<< BlockIdx <<

<< ElementIdx <<

;

(

Stmt = Element.getAs<CFGStmt>()) {

ASTDumper Dumper(OS,

);

Dumper.Visit(Stmt->getStmt());

CFGElement &Element;

JoinedStateBuilder {

Environment::ExprJoinBehavior JoinBehavior;

std::vector<const TypeErasedDataflowAnalysisState *>

;

std::deque<TypeErasedDataflowAnalysisState> Owned;

TypeErasedDataflowAnalysisState

join(

TypeErasedDataflowAnalysisState &L,

TypeErasedDataflowAnalysisState &R) {

{AC.Analysis.joinTypeErased(L.Lattice, R.Lattice),

Environment::join(L.Env, R.Env, AC.Analysis, JoinBehavior)};

JoinedStateBuilder(AnalysisContext &AC,

Environment::ExprJoinBehavior JoinBehavior)

: AC(AC), JoinBehavior(JoinBehavior) {}

addOwned(TypeErasedDataflowAnalysisState State) {

Owned.push_back(std::move(State));

.push_back(&Owned.back());

addUnowned(

TypeErasedDataflowAnalysisState &State) {

.push_back(&State);

TypeErasedDataflowAnalysisState take() && {

{AC.Analysis.typeErasedInitialElement(), AC.InitEnv.fork()};

(

.size() == 1)

{

[0]->Lattice, Environment::join(All[0]->

, All[0]->

,

AC.Analysis, JoinBehavior)};

Result = join(*All[0], *All[1]);

(

I = 2; I <

.size(); ++I)

Result = join(Result, *All[I]);

TerminatorStmt ==

? nullptr

: TerminatorVisitor().Visit(TerminatorStmt);

TypeErasedDataflowAnalysisState

std::vector<const CFGBlock *> Preds(

.pred_begin(),

.pred_end());

(

.getTerminator().isTemporaryDtorsBranch()) {

(

.succ_begin()->getReachableBlock() !=

&&

.succ_begin()->getReachableBlock()->hasNoReturnElement()) {

*StmtBlock =

;

(

*Terminator =

.getTerminatorStmt())

StmtBlock = AC.ACFG.blockForStmt(*Terminator);

assert(StmtBlock !=

);

llvm::erase(Preds, StmtBlock);

(

*Pred : Preds) {

(Pred && AC.ACFG.containsExprConsumedInDifferentBlock(*Pred)) {

JoinBehavior = Environment::KeepExprState;

JoinedStateBuilder Builder(AC, JoinBehavior);

(

*Pred : Preds) {

(!Pred || Pred->hasNoReturnElement())

std::optional<TypeErasedDataflowAnalysisState> &MaybePredState =

AC.BlockStates[Pred->getBlockID()];

(Cond ==

) {

Builder.addUnowned(PredState);

(AC.Analysis.builtinOptions()) {

assert(CondVal !=

);

BranchVal ? CondVal : &

.Env.makeNot(*CondVal);

AC.Analysis.transferBranchTypeErased(BranchVal, Cond,

.Lattice,

Builder.addOwned(std::move(

));

std::move(Builder).take();

AnalysisContext &AC) {

assert(S !=

);

InputState.

, AC.Analysis);

assert(Init !=

);

&

= InputState.

;

&ThisLoc = *

.getThisPointeeStorageLocation();

(!Init->isAnyMemberInitializer())

*InitExpr = Init->getInit();

assert(InitExpr !=

);

(Init->isMemberInitializer()) {

= Init->getMember();

MemberLoc = ThisLoc.getChild(*

);

assert(IndirectField !=

);

MemberLoc = &ThisLoc;

(

*I : IndirectField->

()) {

= cast<FieldDecl>(I);

ParentLoc = cast<RecordStorageLocation>(MemberLoc);

assert(

!=

);

(

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

*InitExprLoc =

.getStorageLocation(*InitExpr);

(InitExprLoc ==

)

}

(!

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

assert(MemberLoc !=

);

(

*InitExprVal =

.getValue(*InitExpr))

.setValue(*MemberLoc, *InitExprVal);

AnalysisContext &AC) {

CFGElement::Statement:

CFGElement::Initializer:

CFGElement::LifetimeEnds:

State.Env.removeDecl(*VD);

TypeErasedDataflowAnalysisState

AC.Log.enterBlock(

, PostAnalysisCallbacks.Before !=

||

PostAnalysisCallbacks.After !=

);

State = computeBlockInputState(

, AC);

AC.Log.recordState(State);

(

&Element :

) {

PrettyStackTraceCFGElement CrashInfo(Element,

.getBlockID(),

ElementIdx++,

);

AC.Log.enterElement(Element);

(PostAnalysisCallbacks.Before) {

PostAnalysisCallbacks.Before(Element, State);

(AC.Analysis.builtinOptions()) {

builtinTransfer(

.getBlockID(), Element, State, AC);

AC.Analysis.transferTypeErased(Element, State.Lattice, State.Env);

(PostAnalysisCallbacks.After) {

PostAnalysisCallbacks.After(Element, State);

AC.Log.recordState(State);

(

Expr *TerminatorCond =

dyn_cast_or_null<Expr>(

.getTerminatorCondition())) {

(State.Env.getValue(*TerminatorCond) ==

)

(StmtToEnvMap(AC.ACFG, AC.BlockStates,

.getBlockID(), State),

*TerminatorCond, State.Env, AC.Analysis);

(State.Env.getValue(*TerminatorCond) ==

)

State.Env.setValue(*TerminatorCond, State.Env.makeAtomicBoolValue());

AC.Log.recordState(State);

std::int32_t MaxBlockVisits) {

PrettyStackTraceAnalysis CrashInfo(

,

);

std::optional<Environment> MaybeStartingEnv;

(

.callStackSize() == 0) {

MaybeStartingEnv =

.fork();

MaybeStartingEnv->initialize();

MaybeStartingEnv ? *MaybeStartingEnv :

;

std::vector<std::optional<TypeErasedDataflowAnalysisState>>

(

StartingEnv.

()};

std::int32_t BlockVisits = 0;

LLVM_DEBUG(llvm::dbgs()

<<

<<

->getBlockID() <<

);

(++BlockVisits > MaxBlockVisits) {

llvm::createStringError(std::errc::timed_out,

);

std::optional<TypeErasedDataflowAnalysisState> &OldBlockState =

llvm::errs() <<

;

llvm::errs() <<

;

OldBlockState->Env.dump();

NewBlockState.

, OldBlockState->Lattice);

(Effect1 == LatticeJoinEffect::Unchanged &&

Effect2 == LatticeJoinEffect::Unchanged) {

AC.Log.blockConverged();

}

(

.isEqualTypeErased(OldBlockState->Lattice,

OldBlockState->Env.equivalentTo(NewBlockState.

,

)) {

AC.Log.blockConverged();

(

->hasNoReturnElement())

(PostAnalysisCallbacks.

|| PostAnalysisCallbacks.

) {

static const Stmt * getTerminatorCondition(const CFGBlock *B)

A customized wrapper for CFGBlock::getTerminatorCondition() which returns the element for ObjCForColl...

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

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

llvm::ArrayRef< std::optional< TypeErasedDataflowAnalysisState > > BlockStates

Stores the state of a CFG block if it has been evaluated by the analysis.

const Environment & InitEnv

Initial state to start the analysis.

TypeErasedDataflowAnalysis & Analysis

The analysis to be run.

const AdornedCFG & ACFG

Contains the CFG being analyzed.

This class represents a potential adjacent block in the CFG.

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

succ_iterator succ_begin()

const Stmt * getLoopTarget() const

unsigned getBlockID() const

Represents a top-level expression in a basic block.

T castAs() const

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

Represents C++ base or member initializer from constructor's initialization list.

CXXCtorInitializer * getInitializer() const

Represents the point where the lifetime of an automatic object ends.

const VarDecl * getVarDecl() const

const Stmt * getStmt() const

Represents a source-level, intra-procedural CFG that represents the control-flow of a Stmt.

unsigned size() const

Return the total number of CFGBlocks within the CFG This is simply a renaming of the getNumBlockIDs()...

Represents a C++ base or member initializer.

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

const CFGBlock * dequeue()

This represents one expression.

Represents a member of a struct/union/class.

IfStmt - This represents an if/then/else.

Represents a field injected from an anonymous union/struct into the parent scope.

ArrayRef< NamedDecl * > chain() const

Stmt - This represents one statement.

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

Holds CFG with additional information derived from it that is needed to perform dataflow analysis.

const Formula & formula() const

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

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

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

LLVM_DUMP_METHOD void dump() const

Environment fork() const

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

ExprJoinBehavior

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

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

StorageLocation * getChild(const ValueDecl &D) const

Returns the child storage location for D.

void setChild(const ValueDecl &D, StorageLocation *Loc)

Changes the child storage location for a field D of reference type.

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

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

Type-erased base class for dataflow analyses built on a single lattice type.

constexpr XRayInstrMask All

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

Evaluates S and updates Env accordingly.

static TypeErasedDataflowAnalysisState computeBlockInputState(const CFGBlock &Block, AnalysisContext &AC)

Computes the input state for a given basic block by joining the output states of its predecessors.

static void builtinTransfer(unsigned CurBlockID, const CFGElement &Elt, TypeErasedDataflowAnalysisState &State, AnalysisContext &AC)

static void builtinTransferInitializer(const CFGInitializer &Elt, TypeErasedDataflowAnalysisState &InputState)

Built-in transfer function for CFGInitializer.

static TypeErasedDataflowAnalysisState transferCFGBlock(const CFGBlock &Block, AnalysisContext &AC, const CFGEltCallbacksTypeErased &PostAnalysisCallbacks={})

Transfers State by evaluating each element in the Block based on the AC.Analysis specified.

static int blockIndexInPredecessor(const CFGBlock &Pred, const CFGBlock &Block)

Returns the index of Block in the successors of Pred.

static bool isBackedgeNode(const CFGBlock &B)

llvm::Expected< std::vector< std::optional< TypeErasedDataflowAnalysisState > > > runTypeErasedDataflowAnalysis(const AdornedCFG &ACFG, TypeErasedDataflowAnalysis &Analysis, const Environment &InitEnv, const CFGEltCallbacksTypeErased &PostAnalysisCallbacks, std::int32_t MaxBlockVisits)

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

static void builtinTransferStatement(unsigned CurBlockID, const CFGStmt &Elt, TypeErasedDataflowAnalysisState &InputState, AnalysisContext &AC)

Built-in transfer function for CFGStmt.

LatticeEffect

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

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

Diagnostic wrappers for TextAPI types for error reporting.

A worklist implementation for forward dataflow analysis.

void enqueueSuccessors(const CFGBlock *Block)

A pair of callbacks to be called with the state before and after visiting a CFG element.

CFGEltCallbackTypeErased Before

CFGEltCallbackTypeErased After

Type-erased model of the program at a given program point.

TypeErasedLattice Lattice

Type-erased model of a program property.

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