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

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

clang: lib/Analysis/LiveVariables.cpp Source File

;

LiveVariablesImpl {

llvm::ImmutableSet<const Expr *>::Factory ESetFact;

llvm::ImmutableSet<const VarDecl *>::Factory DSetFact;

llvm::ImmutableSet<const BindingDecl *>::Factory BSetFact;

llvm::DenseMap<const CFGBlock *, LiveVariables::LivenessValues> blocksEndToLiveness;

llvm::DenseMap<const CFGBlock *, LiveVariables::LivenessValues> blocksBeginToLiveness;

llvm::DenseMap<const Stmt *, LiveVariables::LivenessValues> stmtsToLiveness;

llvm::DenseMap<const DeclRefExpr *, unsigned> inAssignment;

killAtAssign;

: analysisContext(ac),

BSetFact(

), killAtAssign(KillAtAssign) {}

LiveVariablesImpl &

(

*x) {

*((LiveVariablesImpl *) x);

(

*DD = dyn_cast<DecompositionDecl>(

)) {

alive |= liveBindings.contains(BD);

alive |= liveDecls.contains(DD);

liveDecls.contains(

);

<

SET>

SET mergeSets(SET A, SET B) {

(

SET::iterator it = B.begin(), ei = B.end(); it != ei; ++it) {

LiveVariables::Observer::anchor() { }

llvm::ImmutableSetRef<const Expr *> SSetRefA(

valsA.

.getRootWithoutRetain(), ESetFact.getTreeFactory()),

SSetRefB(valsB.

.getRootWithoutRetain(),

ESetFact.getTreeFactory());

llvm::ImmutableSetRef<const VarDecl *>

DSetRefA(valsA.

.getRootWithoutRetain(), DSetFact.getTreeFactory()),

DSetRefB(valsB.

.getRootWithoutRetain(), DSetFact.getTreeFactory());

llvm::ImmutableSetRef<const BindingDecl *>

BSetRefA(valsA.

.getRootWithoutRetain(), BSetFact.getTreeFactory()),

BSetRefB(valsB.

.getRootWithoutRetain(), BSetFact.getTreeFactory());

SSetRefA = mergeSets(SSetRefA, SSetRefB);

DSetRefA = mergeSets(DSetRefA, DSetRefB);

BSetRefA = mergeSets(BSetRefA, BSetRefB);

DSetRefA.asImmutableSet(),

BSetRefA.asImmutableSet());

liveExprs ==

.liveExprs && liveDecls ==

.liveDecls;

->hasGlobalStorage();

(impl).stmtsToLiveness[

].isLive(Val);

TransferFunctions :

<TransferFunctions> {

LiveVariablesImpl &LV;

TransferFunctions(LiveVariablesImpl &im,

: LV(im), val(Val), observer(Observer), currentBlock(

) {}

Visit(

*S);

(

*VT = dyn_cast<ArrayType>(ty)) {

(VAT->getSizeExpr())

ty = VT->getElementType().getTypePtr();

(

*Ex = dyn_cast<Expr>(

))

(

*FE = dyn_cast<FullExpr>(

)) {

= FE->getSubExpr();

= OVE->getSourceExpr();

llvm::ImmutableSet<const Expr *>::Factory &F,

llvm::ImmutableSet<const Expr *>::Factory &F,

(

*BO = dyn_cast<BinaryOperator>(Cond->

());

BO && BO->isLogicalOp()) {

TransferFunctions::Visit(

*S) {

observer->observeStmt(S, currentBlock, val);

(

*

= dyn_cast<Expr>(S)) {

val.liveExprs = LV.ESetFact.remove(val.liveExprs,

);

(S->getStmtClass()) {

Stmt::StmtExprClass: {

S = cast<StmtExpr>(S)->getSubStmt();

Stmt::CXXMemberCallExprClass: {

(val.liveExprs, LV.ESetFact, ImplicitObj);

Stmt::ObjCMessageExprClass: {

val.liveDecls = LV.DSetFact.add(val.liveDecls,

LV.analysisContext.getSelfDecl());

Stmt::DeclStmtClass: {

*DS = cast<DeclStmt>(S);

VA !=

; VA =

(VA->getElementType())) {

(val.liveExprs, LV.ESetFact, VA->getSizeExpr());

Stmt::PseudoObjectExprClass: {

*child = cast<PseudoObjectExpr>(S)->getResultExpr();

child = OV->getSourceExpr();

val.liveExprs = LV.ESetFact.add(val.liveExprs, child);

Stmt::ExprWithCleanupsClass: {

S = cast<ExprWithCleanups>(S)->getSubExpr();

Stmt::CXXBindTemporaryExprClass: {

S = cast<CXXBindTemporaryExpr>(S)->getSubExpr();

Stmt::UnaryExprOrTypeTraitExprClass: {

Stmt::IfStmtClass: {

(val.liveExprs, LV.ESetFact, cast<IfStmt>(S)->getCond());

Stmt::WhileStmtClass: {

(val.liveExprs, LV.ESetFact, cast<WhileStmt>(S)->getCond());

Stmt::DoStmtClass: {

(val.liveExprs, LV.ESetFact, cast<DoStmt>(S)->getCond());

Stmt::ForStmtClass: {

(val.liveExprs, LV.ESetFact, cast<ForStmt>(S)->getCond());

Stmt::ConditionalOperatorClass: {

*CO = cast<ConditionalOperator>(S);

(val.liveExprs, LV.ESetFact, CO->getTrueExpr());

(val.liveExprs, LV.ESetFact, CO->getFalseExpr());

(

*Child : S->children()) {

(

*

= dyn_cast_or_null<Expr>(Child))

(LV.killAtAssign && B->

() == BO_Assign) {

LV.inAssignment[DR] = 1;

(!LV.killAtAssign)

(

*DR = dyn_cast<DeclRefExpr>(LHS)) {

*

= DR->getDecl();

Killed =

;

(

* BD = dyn_cast<BindingDecl>(

)) {

Killed = !BD->getType()->isReferenceType();

(

*HV = BD->getHoldingVar())

val.liveDecls = LV.DSetFact.remove(val.liveDecls, HV);

val.liveBindings = LV.BSetFact.remove(val.liveBindings, BD);

}

(

*VD = dyn_cast<VarDecl>(

)) {

val.liveDecls = LV.DSetFact.remove(val.liveDecls, VD);

(Killed && observer)

observer->observerKill(DR);

TransferFunctions::VisitBlockExpr(

*BE) {

LV.analysisContext.getReferencedBlockVars(BE->

())) {

val.liveDecls = LV.DSetFact.add(val.liveDecls, VD);

TransferFunctions::VisitDeclRefExpr(

*DR) {

InAssignment = LV.inAssignment[DR];

(

*BD = dyn_cast<BindingDecl>(

)) {

(

*HV = BD->getHoldingVar())

val.liveDecls = LV.DSetFact.

(val.liveDecls, HV);

val.liveBindings = LV.BSetFact.add(val.liveBindings, BD);

}

(

*VD = dyn_cast<VarDecl>(

)) {

val.liveDecls = LV.DSetFact.add(val.liveDecls, VD);

TransferFunctions::VisitDeclStmt(

*DS) {

(

*DI : DS->

()) {

(

*DD = dyn_cast<DecompositionDecl>(DI)) {

(

*BD : DD->bindings()) {

(

*HV = BD->getHoldingVar())

val.liveDecls = LV.DSetFact.remove(val.liveDecls, HV);

val.liveBindings = LV.BSetFact.remove(val.liveBindings, BD);

val.liveDecls = LV.DSetFact.remove(val.liveDecls, DD);

}

(

*VD = dyn_cast<VarDecl>(DI)) {

val.liveDecls = LV.DSetFact.remove(val.liveDecls, VD);

*element = OS->getElement();

(

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

((DR = dyn_cast<DeclRefExpr>(cast<Expr>(element)->IgnoreParens()))) {

VD = cast<VarDecl>(DR->

());

val.liveDecls = LV.DSetFact.remove(val.liveDecls, VD);

observer->observerKill(DR);

TransferFunctions::

val.liveExprs = LV.ESetFact.add(val.liveExprs, subEx->

());

TransferFunctions::VisitUnaryOperator(

*UO) {

(isa<VarDecl>(

) || isa<BindingDecl>(

)) {

observer->observerKill(DR);

LiveVariablesImpl::runOnBlock(

*block,

TransferFunctions TF(*

, val, obs, block);

TF.Visit(

*

(term));

ei = block->

(); it != ei; ++it) {

(std::optional<CFGAutomaticObjDtor> Dtor =

TF.Visit(

*

(S));

stmtsToLiveness[S] = val;

*cfg =

(impl).analysisContext.getCFG();

(impl).runOnBlock(*it,

(impl).blocksEndToLiveness[*it], &obs);

LiveVariables::LiveVariables(

*im) : impl(im) {}

(LiveVariablesImpl*) impl;

std::unique_ptr<LiveVariables>

*cfg = AC.getCFG();

LiveVariablesImpl *LV =

LiveVariablesImpl(AC, killAtAssign);

ei = block->

(); it != ei; ++it) {

val = LV->merge(val, LV->blocksBeginToLiveness[succ]);

(!everAnalyzedBlock[block->

()])

everAnalyzedBlock[block->

()] =

;

(prevVal.

(val))

LV->blocksBeginToLiveness[block] = LV->runOnBlock(block, val);

std::unique_ptr<LiveVariables>(

(LV));

(impl).dumpBlockLiveness(M);

LiveVariablesImpl::dumpBlockLiveness(

&M) {

std::vector<const CFGBlock *> vec;

(llvm::DenseMap<const CFGBlock *, LiveVariables::LivenessValues>::iterator

it = blocksEndToLiveness.begin(), ei = blocksEndToLiveness.end();

vec.push_back(it->first);

std::vector<const VarDecl*> declVec;

(std::vector<const CFGBlock *>::iterator

it = vec.begin(), ei = vec.end(); it != ei; ++it) {

llvm::errs() <<

<< (*it)->getBlockID()

<<

;

(llvm::ImmutableSet<const VarDecl *>::iterator si =

se = vals.

.end(); si != se; ++si) {

declVec.push_back(*si);

llvm::sort(declVec, [](

*A,

*B) {

(std::vector<const VarDecl*>::iterator di = declVec.begin(),

de = declVec.end(); di != de; ++di) {

llvm::errs() <<

<< (*di)->getDeclName().getAsString()

(*di)->getLocation().print(llvm::errs(), M);

llvm::errs() <<

;

llvm::errs() <<

;

(impl).dumpExprLiveness(M);

LiveVariablesImpl::dumpExprLiveness(

&M) {

(

*B : *analysisContext.getCFG()) {

llvm::errs() <<

<< B->getBlockID()

<<

;

(

*

: blocksEndToLiveness[B].liveExprs) {

llvm::errs() <<

;

llvm::errs() <<

;

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

static const VariableArrayType * FindVA(const Type *t)

static bool writeShouldKill(const VarDecl *VD)

static void AddLiveExpr(llvm::ImmutableSet< const Expr * > &Set, llvm::ImmutableSet< const Expr * >::Factory &F, const Expr *E)

static LiveVariablesImpl & getImpl(void *x)

static const Expr * LookThroughExpr(const Expr *E)

static void AddAllConditionalTerms(llvm::ImmutableSet< const Expr * > &Set, llvm::ImmutableSet< const Expr * >::Factory &F, const Expr *Cond)

Add as a live expression all individual conditions in a logical expression.

static bool isAlwaysAlive(const VarDecl *D)

const CFGBlock * CurrentBlock

static bool runOnBlock(const CFGBlock *block, const CFG &cfg, AnalysisDeclContext &ac, CFGBlockValues &vals, const ClassifyRefs &classification, llvm::BitVector &wasAnalyzed, UninitVariablesHandler &handler)

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

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

A builtin binary operation expression such as "x + y" or "x <= y".

static bool isAssignmentOp(Opcode Opc)

A binding in a decomposition declaration.

BlockExpr - Adaptor class for mixing a BlockDecl with expressions.

const BlockDecl * getBlockDecl() const

Represents C++ object destructor implicitly generated for automatic object or temporary bound to cons...

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

reverse_iterator rbegin()

succ_iterator succ_begin()

Stmt * getTerminatorStmt()

unsigned getBlockID() const

AdjacentBlocks::const_iterator const_succ_iterator

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.

std::optional< T > getAs() const

Convert to the specified CFGElement type, returning std::nullopt if this CFGElement is not of the des...

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

unsigned getNumBlockIDs() const

Returns the total number of BlockIDs allocated (which start at 0).

llvm::iterator_range< iterator > nodes()

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.

void enqueueBlock(const CFGBlock *Block)

const CFGBlock * dequeue()

A reference to a declared variable, function, enum, etc.

DeclStmt - Adaptor class for mixing declarations with statements and expressions.

const Decl * getSingleDecl() const

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

SourceLocation getBeginLoc() const LLVM_READONLY

This represents one expression.

Expr * IgnoreParens() LLVM_READONLY

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

bool isLValue() const

isLValue - True if this expression is an "l-value" according to the rules of the current language.

FullExpr - Represents a "full-expression" node.

llvm::ImmutableSet< const BindingDecl * > liveBindings

llvm::ImmutableSet< const Expr * > liveExprs

llvm::ImmutableSet< const VarDecl * > liveDecls

bool isLive(const Expr *E) const

bool equals(const LivenessValues &V) const

void dumpExprLiveness(const SourceManager &M)

Print to stderr the expression liveness information associated with each basic block.

void dumpBlockLiveness(const SourceManager &M)

Print to stderr the variable liveness information associated with each basic block.

void runOnAllBlocks(Observer &obs)

~LiveVariables() override

static const void * getTag()

bool isLive(const CFGBlock *B, const VarDecl *D)

Return true if a variable is live at the end of a specified block.

static std::unique_ptr< LiveVariables > computeLiveness(AnalysisDeclContext &analysisContext, bool killAtAssign)

Compute the liveness information for a given CFG.

Represents Objective-C's collection statement.

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

@ SuperInstance

The receiver is the instance of the superclass object.

ReceiverKind getReceiverKind() const

Determine the kind of receiver that this message is being sent to.

OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.

A (possibly-)qualified type.

const Type * getTypePtr() const

Retrieves a pointer to the underlying (unqualified) type.

static const void * getTag()

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

RetTy Visit(PTR(Stmt) S, ParamTys... P)

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

Stmt - This represents one statement.

void dump() const

Dumps the specified AST fragment and all subtrees to llvm::errs().

The base class of the type hierarchy.

bool isReferenceType() const

bool isVariableArrayType() const

UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.

bool isArgumentType() const

UnaryExprOrTypeTrait getKind() const

UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...

Expr * getSubExpr() const

Represents a variable declaration or definition.

Represents a C array with a specified size that is not an integer-constant-expression.

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

A worklist implementation for backward dataflow analysis.

void enqueuePredecessors(const CFGBlock *Block)

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