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

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

LLVM: lib/CodeGen/MachineTraceMetrics.cpp Source File

,

,

)

TII = ST.getInstrInfo();

TRI = ST.getRegisterInfo();

SchedModel.

(&ST);

.

(MF, getAnalysis<MachineLoopInfoWrapperPass>().getLI());

(

&E : Ensembles)

(

&

: *

) {

(

.isTransient())

(PI->ProcResourceIdx < PRKinds &&

);

PRCycles[PI->ProcResourceIdx] += PI->ReleaseAtCycle;

(

K = 0; K != PRKinds; ++K)

ProcReleaseAtCycles[PROffset + K] =

(BlockInfo[MBBNum].hasResources() &&

);

((MBBNum+1) * PRKinds <= ProcReleaseAtCycles.

());

(ProcReleaseAtCycles.

() + MBBNum * PRKinds, PRKinds);

BlockInfo.resize(

.BlockInfo.size());

ProcResourceDepths.

(

.BlockInfo.size() * PRKinds);

ProcResourceHeights.

(

.BlockInfo.size() * PRKinds);

MTM.Loops->getLoopFor(

);

MachineTraceMetrics::Ensemble::

PRKinds = MTM.SchedModel.getNumProcResourceKinds();

std::fill(ProcResourceDepths.begin() + PROffset,

ProcResourceDepths.begin() + PROffset + PRKinds, 0);

TraceBlockInfo *PredTBI = &BlockInfo[PredNum];

(PredTBI->hasValidDepth() &&

);

FixedBlockInfo *PredFBI = MTM.getResources(TBI->

);

TBI->

= PredTBI->InstrDepth + PredFBI->InstrCount;

TBI->

= PredTBI->Head;

(

K = 0; K != PRKinds; ++K)

ProcResourceDepths[PROffset + K] = PredPRDepths[K] + PredPRCycles[K];

MachineTraceMetrics::Ensemble::

PRKinds = MTM.SchedModel.getNumProcResourceKinds();

TBI->InstrHeight = MTM.getResources(

)->InstrCount;

(PRCycles, ProcResourceHeights.begin() + PROffset);

SuccNum = TBI->Succ->getNumber();

TraceBlockInfo *SuccTBI = &BlockInfo[SuccNum];

(SuccTBI->hasValidHeight() &&

);

TBI->InstrHeight += SuccTBI->InstrHeight;

TBI->Tail = SuccTBI->Tail;

(

K = 0;

!= PRKinds; ++

)

ProcResourceHeights[PROffset + K] = SuccPRHeights[K] + PRCycles[K];

PRKinds = MTM.SchedModel.getNumProcResourceKinds();

((MBBNum+1) * PRKinds <= ProcResourceDepths.size());

(ProcResourceDepths.data() + MBBNum * PRKinds, PRKinds);

PRKinds = MTM.SchedModel.getNumProcResourceKinds();

((MBBNum+1) * PRKinds <= ProcResourceHeights.size());

(ProcResourceHeights.data() + MBBNum * PRKinds, PRKinds);

&& !

->contains(To);

*

()

{

; }

*

()

{

; }

CurCount = MTM.getResources(

)->InstrCount;

BestDepth = 0;

getDepthResources(Pred);

(!Best ||

< BestDepth) {

BestHeight = 0;

(CurLoop && Succ == CurLoop->

())

getHeightResources(Succ);

(!Best || Height < BestHeight) {

);

std::unique_ptr<MachineTraceMetrics::Ensemble> &E =

Ensembles[

(strategy)];

E = std::make_unique<MinInstrCountEnsemble>(MinInstrCountEnsemble(

));

E = std::make_unique<LocalEnsemble>(LocalEnsemble(

));

(

&E : Ensembles)

E->invalidate(

);

!PAC.preserved() &&

(

&E : Ensembles)

Downward =

;

((LB.Downward ? To : *

) == FromLoop->getHeader())

LB.Visited.insert(To).second;

LoopBounds Bounds(BlockInfo, MTM.Loops);

Bounds.Downward =

;

Bounds.Visited.clear();

TraceBlockInfo &TBI = BlockInfo[

->getNumber()];

TBI.Pred = pickTracePred(

);

() <<

;

computeDepthResources(

);

Bounds.Downward =

;

Bounds.Visited.clear();

TraceBlockInfo &TBI = BlockInfo[

->getNumber()];

TBI.Succ = pickTraceSucc(

);

() <<

;

computeHeightResources(

);

<<

() <<

);

}

(!WorkList.

());

<<

() <<

);

}

(!WorkList.

());

(

&

: *BadMBB)

(BlockInfo.size() == MTM.MF->getNumBlockIDs() &&

);

(

Num = 0, e = BlockInfo.size(); Num != e; ++Num) {

);

);

);

:

(

), DefOp(DefOp), UseOp(UseOp) {}

(DefMO &&

);

(

.isDebugInstr())

HasPhysRegs =

;

(Reg.isPhysical()) {

Deps.

(DataDep(

, Reg, MO.getOperandNo()));

(

i = 1; i !=

.getNumOperands(); i += 2) {

(

.getOperand(i + 1).getMBB() == Pred) {

(!MO.isReg() || !MO.getReg().isPhysical())

LiveDefOps.

(MO.getOperandNo());

}

(MO.isKill())

(

== RegUnits.

())

Deps.

(DataDep(

->MI,

->Op, MO.getOperandNo()));

RegUnits.

(Unit);

(

DefOp : LiveDefOps) {

MachineTraceMetrics::Ensemble::

computeCrossBlockCriticalPath(

TraceBlockInfo &TBI) {

(TBI.HasValidInstrDepths &&

);

(TBI.HasValidInstrHeights &&

);

(

LiveInReg &LIR : TBI.LiveIns) {

(!LIR.Reg.isVirtual())

(!DefTBI.isUsefulDominator(TBI))

= LIR.Height + Cycles[

].Depth;

MaxLen = std::max(MaxLen, Len);

(

DataDep &Dep : Deps) {

BlockInfo[Dep.DefMI->getParent()->getNumber()];

DepCycle = Cycles.lookup(Dep.DefMI).Depth;

(!Dep.DefMI->isTransient())

DepCycle += MTM.SchedModel

.computeOperandLatency(Dep.DefMI, Dep.DefOp, &

, Dep.UseOp);

(; Start !=

; Start++)

updateDepth(Start->getParent(), *Start, RegUnits);

MachineTraceMetrics::Ensemble::

Stack.push_back(

);

(!Stack.empty()) {

= Stack.pop_back_val();

TBI.HasValidInstrDepths =

;

TBI.CriticalPath = 0;

() <<

(

, TBI.InstrDepth);

(

K = 0; K != PRDepths.

(); ++K)

Factor = MTM.SchedModel.getResourceFactor(K);

() <<

(

, MTM.getCycles(PRDepths[K]))

<< MTM.SchedModel.getProcResource(K)->Name <<

<< PRDepths[K]/Factor <<

<< Factor <<

;

(TBI.HasValidInstrHeights)

TBI.CriticalPath = computeCrossBlockCriticalPath(TBI);

(

&

: *

) {

updateDepth(TBI,

, RegUnits);

(!Reg.isPhysical())

(

== RegUnits.

())

DepHeight =

->Cycle;

(!

.isTransient()) {

Height = std::max(Height, DepHeight);

(

: ReadOps) {

(LRU.

<= Height && LRU.

!= &

) {

(!Dep.DefMI->isTransient())

std::tie(

, New) = Heights.

(std::make_pair(Dep.DefMI, UseHeight));

(

->second < UseHeight)

->second = UseHeight;

MachineTraceMetrics::Ensemble::

TBI.LiveIns.push_back(Reg);

MachineTraceMetrics::Ensemble::

(TBI.hasValidHeight() &&

);

(TBI.HasValidInstrHeights)

TBI.LiveIns.clear();

RegUnits.

(MTM.TRI->getNumRegUnits());

(LiveInReg &LI : TBI.LiveIns) {

(LI.Reg.isVirtual()) {

&Height = Heights[MTM.MRI->getVRegDef(LI.Reg)];

(Height < LI.Height)

RegUnits[LI.Reg].Cycle = LI.Height;

TBI.HasValidInstrHeights =

;

TBI.CriticalPath = 0;

() <<

(

, TBI.InstrHeight);

(

K = 0;

!= PRHeights.

(); ++

)

Factor = MTM.SchedModel.getResourceFactor(K);

() <<

(

, MTM.getCycles(PRHeights[K]))

<< MTM.SchedModel.getProcResource(K)->Name <<

<< PRHeights[

]/Factor <<

<< Factor <<

;

(

&

: *Succ) {

(!Deps.

()) {

Height = TBI.Succ ? Cycles.lookup(&

).Height : 0;

(HeightI != Heights.

()) {

= HeightI->second;

Heights.

(HeightI);

HasPhysRegs = !

.isPHI() &&

(

, Deps, MTM.MRI);

(

DataDep &Dep : Deps)

InstrCycles &MICycles = Cycles[&

];

MICycles.Height =

;

(!TBI.HasValidInstrDepths) {

TBI.CriticalPath = std::max(TBI.CriticalPath,

+ MICycles.Depth);

(LiveInReg &LIR : TBI.LiveIns) {

TBI.LiveIns.push_back(LiveInReg(RU.RegUnit, RU.Cycle));

(!TBI.HasValidInstrDepths)

TBI.CriticalPath = std::max(TBI.CriticalPath,

computeCrossBlockCriticalPath(TBI));

(

() <<

<< TBI.CriticalPath <<

);

computeTrace(

);

computeInstrDepths(

);

computeInstrHeights(

);

(*

, TBI);

(getBlockNum() ==

(

.getParent()->getNumber()) &&

);

getCriticalPath() - (Cyc.

+ Cyc.

);

(Deps.

() == 1 &&

);

DataDep &Dep = Deps.

();

DepCycle = getInstrCycles(*Dep.DefMI).Depth;

(!Dep.DefMI->isTransient())

DepCycle += TE.MTM.SchedModel.computeOperandLatency(Dep.DefMI, Dep.DefOp,

(

K = 0; K != PRDepths.

(); ++K)

PRMax = std::max(PRMax, PRDepths[K] + PRCycles[K]);

(

PRD : PRDepths)

PRMax = std::max(PRMax, PRD);

PRMax = TE.MTM.getCycles(PRMax);

Instrs = TBI.InstrDepth;

Instrs += TE.MTM.BlockInfo[getBlockNum()].InstrCount;

(

IW = TE.MTM.SchedModel.getIssueWidth())

std::max(Instrs, PRMax);

ResourceIdx)

Cycles = 0;

PI = TE.MTM.SchedModel.getWriteProcResBegin(SC),

PE = TE.MTM.SchedModel.getWriteProcResEnd(SC);

(PI->ProcResourceIdx != ResourceIdx)

Cycles += (PI->ReleaseAtCycle *

TE.MTM.SchedModel.getResourceFactor(ResourceIdx));

(

K = 0; K != PRDepths.

(); ++K) {

PRCycles = PRDepths[K] + PRHeights[K];

PRCycles += TE.MTM.getProcReleaseAtCycles(

->

())[K];

PRCycles += extraCycles(ExtraInstrs, K);

PRCycles -= extraCycles(RemoveInstrs, K);

PRMax = std::max(PRMax, PRCycles);

PRMax = TE.MTM.getCycles(PRMax);

Instrs = TBI.InstrDepth + TBI.InstrHeight;

Instrs += TE.MTM.getResources(

)->InstrCount;

Instrs += ExtraInstrs.

();

Instrs -= RemoveInstrs.

();

(

IW = TE.MTM.SchedModel.getIssueWidth())

std::max(Instrs, PRMax);

(

.getParent() ==

.getParent())

(

i = 0, e = BlockInfo.size(); i != e; ++i) {

<<

<< i <<

;

BlockInfo[i].print(

);

(hasValidDepth()) {

<<

<< InstrDepth;

<<

;

<<

<< Head;

(HasValidInstrDepths)

<<

;

(hasValidHeight()) {

<<

<< InstrHeight;

<<

;

<<

<<

;

(HasValidInstrHeights)

<<

;

(HasValidInstrDepths && HasValidInstrHeights)

<<

<< CriticalPath;

MBBNum = &TBI - &TE.BlockInfo[0];

<< TE.getName() <<

<< TBI.Head <<

<< MBBNum

<<

<< TBI.Tail <<

;

(TBI.hasValidHeight() && TBI.hasValidDepth())

<<

<< getInstrCount() <<

;

(TBI.HasValidInstrDepths && TBI.HasValidInstrHeights)

<<

<< TBI.CriticalPath <<

;

<<

<< MBBNum;

(

->hasValidDepth() &&

->Pred) {

Num =

->Pred->getNumber();

= &TE.BlockInfo[Num];

(

->hasValidHeight() &&

->Succ) {

Num =

->Succ->getNumber();

= &TE.BlockInfo[Num];

unsigned const MachineRegisterInfo * MRI

MachineInstrBuilder & UseMI

MachineInstrBuilder MachineInstrBuilder & DefMI

bbsections Prepares for basic block by splitting functions into clusters of basic blocks

BlockVerifier::State From

COFF::MachineTypes Machine

static unsigned InstrCount

This file defines the DenseMap class.

DenseMap< Block *, BlockRelaxAux > Blocks

unsigned const TargetRegisterInfo * TRI

static bool pushDepHeight(const DataDep &Dep, const MachineInstr &UseMI, unsigned UseHeight, MIHeightMap &Heights, const TargetSchedModel &SchedModel, const TargetInstrInfo *TII)

static void getPHIDeps(const MachineInstr &UseMI, SmallVectorImpl< DataDep > &Deps, const MachineBasicBlock *Pred, const MachineRegisterInfo *MRI)

static bool getDataDeps(const MachineInstr &UseMI, SmallVectorImpl< DataDep > &Deps, const MachineRegisterInfo *MRI)

static void updatePhysDepsDownwards(const MachineInstr *UseMI, SmallVectorImpl< DataDep > &Deps, SparseSet< LiveRegUnit > &RegUnits, const TargetRegisterInfo *TRI)

static unsigned updatePhysDepsUpwards(const MachineInstr &MI, unsigned Height, SparseSet< LiveRegUnit > &RegUnits, const TargetSchedModel &SchedModel, const TargetInstrInfo *TII, const TargetRegisterInfo *TRI)

static bool isExitingLoop(const MachineLoop *From, const MachineLoop *To)

#define INITIALIZE_PASS_DEPENDENCY(depName)

#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)

#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)

This file builds on the ADT/GraphTraits.h file to build a generic graph post order iterator.

static StringRef getName(Value *V)

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

This file defines the SmallPtrSet class.

This file defines the SmallVector class.

This file defines the SparseSet class derived from the version described in Briggs,...

This templated class represents "all analyses that operate over <a particular IR unit>" (e....

API to communicate dependencies between analyses during invalidation.

A container for analyses that lazily runs them and caches their results.

PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)

Get the result of an analysis pass for a given IR unit.

Represent the analysis usage information of a pass.

AnalysisUsage & addRequired()

void setPreservesAll()

Set by analyses that do not transform their input at all.

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

size_t size() const

size - Get the array size.

Represents analyses that only rely on functions' control flow.

This class represents an Operation in the Expression.

ValueT lookup(const_arg_type_t< KeyT > Val) const

lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...

iterator find(const_arg_type_t< KeyT > Val)

bool erase(const KeyT &Val)

std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)

A possibly irreducible generalization of a Loop.

BlockT * getHeader() const

Represents a single loop in the control flow graph.

Wrapper class representing physical registers. Should be passed by value.

int getNumber() const

MachineBasicBlocks are uniquely numbered at the function level, unless they're not in a MachineFuncti...

bool isPredecessor(const MachineBasicBlock *MBB) const

Return true if the specified MBB is a predecessor of this block.

iterator_range< succ_iterator > successors()

bool isSuccessor(const MachineBasicBlock *MBB) const

Return true if the specified MBB is a successor of this block.

iterator_range< pred_iterator > predecessors()

MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...

void getAnalysisUsage(AnalysisUsage &AU) const override

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.

const TargetSubtargetInfo & getSubtarget() const

getSubtarget - Return the subtarget for which this machine code is being compiled.

MachineRegisterInfo & getRegInfo()

getRegInfo - Return information about the registers currently in use.

unsigned getNumBlockIDs() const

getNumBlockIDs - Return the number of MBB ID's allocated.

Register getReg(unsigned Idx) const

Get the register for the operand index.

Representation of each machine instruction.

const MachineBasicBlock * getParent() const

iterator_range< mop_iterator > operands()

const MachineOperand & getOperand(unsigned i) const

Analysis pass that exposes the MachineLoopInfo for a machine function.

MachineOperand class - Representation of each machine instruction operand.

unsigned getOperandNo() const

Returns the index of this operand in the instruction that it belongs to.

MachineInstr * getParent()

getParent - Return the instruction that this operand belongs to.

Register getReg() const

getReg - Returns the register number.

MachineRegisterInfo - Keep track of information for virtual and physical registers,...

Result run(MachineFunction &MF, MachineFunctionAnalysisManager &MFAM)

MachineTraceMetrics Result

void getAnalysisUsage(AnalysisUsage &) const override

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.

bool runOnMachineFunction(MachineFunction &) override

runOnMachineFunction - This method must be overloaded to perform the desired machine code transformat...

A trace ensemble is a collection of traces selected using the same strategy, for example 'minimum res...

void invalidate(const MachineBasicBlock *MBB)

Invalidate traces through BadMBB.

ArrayRef< unsigned > getProcResourceHeights(unsigned MBBNum) const

Get an array of processor resource heights for MBB.

void updateDepth(TraceBlockInfo &TBI, const MachineInstr &, SparseSet< LiveRegUnit > &RegUnits)

Updates the depth of an machine instruction, given RegUnits.

const MachineLoop * getLoopFor(const MachineBasicBlock *) const

const TraceBlockInfo * getHeightResources(const MachineBasicBlock *) const

void updateDepths(MachineBasicBlock::iterator Start, MachineBasicBlock::iterator End, SparseSet< LiveRegUnit > &RegUnits)

Updates the depth of the instructions from Start to End.

const TraceBlockInfo * getDepthResources(const MachineBasicBlock *) const

ArrayRef< unsigned > getProcResourceDepths(unsigned MBBNum) const

Get an array of processor resource depths for MBB.

Ensemble(MachineTraceMetrics *)

MachineTraceMetrics & MTM

void print(raw_ostream &) const

Trace getTrace(const MachineBasicBlock *MBB)

Get the trace that passes through MBB.

A trace represents a plausible sequence of executed basic blocks that passes through the current basi...

unsigned getResourceLength(ArrayRef< const MachineBasicBlock * > Extrablocks={}, ArrayRef< const MCSchedClassDesc * > ExtraInstrs={}, ArrayRef< const MCSchedClassDesc * > RemoveInstrs={}) const

Return the resource length of the trace.

unsigned getInstrSlack(const MachineInstr &MI) const

Return the slack of MI.

bool isDepInTrace(const MachineInstr &DefMI, const MachineInstr &UseMI) const

A dependence is useful if the basic block of the defining instruction is part of the trace of the use...

unsigned getPHIDepth(const MachineInstr &PHI) const

Return the Depth of a PHI instruction in a trace center block successor.

void print(raw_ostream &) const

unsigned getResourceDepth(bool Bottom) const

Return the resource depth of the top/bottom of the trace center block.

Ensemble * getEnsemble(MachineTraceStrategy)

Get the trace ensemble representing the given trace selection strategy.

void verifyAnalysis() const

void invalidate(const MachineBasicBlock *MBB)

Invalidate cached information about MBB.

const FixedBlockInfo * getResources(const MachineBasicBlock *)

Get the fixed resource information about MBB. Compute it on demand.

ArrayRef< unsigned > getProcReleaseAtCycles(unsigned MBBNum) const

Get the scaled number of cycles used per processor resource in MBB.

void init(MachineFunction &Func, const MachineLoopInfo &LI)

MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...

A set of analyses that are preserved following a run of a transformation pass.

static PreservedAnalyses all()

Construct a special preserved set that preserves all passes.

PreservedAnalysisChecker getChecker() const

Build a checker for this PreservedAnalyses and the specified analysis type.

Wrapper class representing virtual and physical registers.

MCRegister asMCReg() const

Utility to check-convert this value to a MCRegister.

static constexpr bool isVirtualRegister(unsigned Reg)

Return true if the specified register number is in the virtual register namespace.

SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.

This class consists of common code factored out of the SmallVector class to reduce code duplication b...

void push_back(const T &Elt)

pointer data()

Return a pointer to the vector's buffer, even if empty().

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

SparseSet - Fast set implementation for objects that can be identified by small unsigned keys.

iterator erase(iterator I)

erase - Erases an existing element identified by a valid iterator.

typename DenseT::iterator iterator

const_iterator end() const

void setUniverse(unsigned U)

setUniverse - Set the universe size which determines the largest key the set can hold.

iterator find(const KeyT &Key)

find - Find an element by its key.

TargetInstrInfo - Interface to description of machine instruction set.

TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...

Provide an instruction scheduling machine model to CodeGen passes.

ProcResIter getWriteProcResEnd(const MCSchedClassDesc *SC) const

bool hasInstrSchedModel() const

Return true if this machine model includes an instruction-level scheduling model.

unsigned getResourceFactor(unsigned ResIdx) const

Multiply the number of units consumed for a resource by this factor to normalize it relative to other...

const MCSchedClassDesc * resolveSchedClass(const MachineInstr *MI) const

Return the MCSchedClassDesc for this instruction.

void init(const TargetSubtargetInfo *TSInfo)

Initialize the machine model for instruction scheduling.

unsigned computeOperandLatency(const MachineInstr *DefMI, unsigned DefOperIdx, const MachineInstr *UseMI, unsigned UseOperIdx) const

Compute operand latency based on the available machine model.

unsigned getNumProcResourceKinds() const

Get the number of kinds of resources for this target.

ProcResIter getWriteProcResBegin(const MCSchedClassDesc *SC) const

TargetSubtargetInfo - Generic base class for all target subtargets.

bool insertEdge(std::optional< const MachineBasicBlock * > From, const MachineBasicBlock *To)

void finishPostorder(const MachineBasicBlock *)

po_iterator_storage(LoopBounds &lb)

Default po_iterator_storage implementation with an internal set object.

This class implements an extremely fast bulk output stream that can only output to a stream.

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

@ Tail

Attemps to make calls as fast as possible while guaranteeing that tail call optimization can always b...

Reg

All possible values of the reg field in the ModR/M byte.

This is an optimization pass for GlobalISel generic memory operations.

MachineTraceStrategy

Strategies for selecting traces.

@ TS_MinInstrCount

Select the trace through a block that has the fewest instructions.

@ TS_Local

Select the trace that contains only the current basic block.

iterator_range< po_ext_iterator< T, SetType > > post_order_ext(const T &G, SetType &S)

iterator_range< ipo_ext_iterator< T, SetType > > inverse_post_order_ext(const T &G, SetType &S)

Printable printRegUnit(unsigned Unit, const TargetRegisterInfo *TRI)

Create Printable object to print register units on a raw_ostream.

auto reverse(ContainerTy &&C)

raw_ostream & dbgs()

dbgs() - This returns a reference to a raw_ostream for debugging messages.

format_object< Ts... > format(const char *Fmt, const Ts &... Vals)

These are helper functions used to produce formatted output.

char & MachineTraceMetricsID

MachineTraceMetrics - This pass computes critical path and CPU resource usage in an ensemble of trace...

DWARFExpression::Operation Op

OutputIt copy(R &&Range, OutputIt Out)

Printable printReg(Register Reg, const TargetRegisterInfo *TRI=nullptr, unsigned SubIdx=0, const MachineRegisterInfo *MRI=nullptr)

Prints virtual and physical registers with or without a TRI instance.

Printable printMBBReference(const MachineBasicBlock &MBB)

Prints a machine basic block reference.

void addLiveIns(MachineBasicBlock &MBB, const LivePhysRegs &LiveRegs)

Adds registers contained in LiveRegs to the block live-in list of MBB.

A special type used by analysis passes to provide an address that identifies that particular analysis...

Summarize the scheduling resources required for an instruction of a particular scheduling class.

Identify one of the processor resource kinds consumed by a particular scheduling class for the specif...

PreservedAnalyses run(MachineFunction &MF, MachineFunctionAnalysisManager &MFAM)

Per-basic block information that doesn't depend on the trace through the block.

bool hasResources() const

Returns true when resource information for this block has been computed.

unsigned InstrCount

The number of non-trivial instructions in the block.

bool HasCalls

True when the block contains calls.

InstrCycles represents the cycle height and depth of an instruction in a trace.

unsigned Height

Minimum number of cycles from this instruction is issued to the of the trace, as determined by data d...

unsigned Depth

Earliest issue cycle as determined by data dependencies and instruction latencies from the beginning ...

Per-basic block information that relates to a specific trace through the block.

unsigned InstrDepth

Accumulated number of instructions in the trace above this block.

void invalidateDepth()

Invalidate depth resources when some block above this one has changed.

const MachineBasicBlock * Pred

Trace predecessor, or NULL for the first block in the trace.

unsigned InstrHeight

Accumulated number of instructions in the trace below this block.

const MachineBasicBlock * Succ

Trace successor, or NULL for the last block in the trace.

bool hasValidDepth() const

Returns true if the depth resources have been computed from the trace above this block.

bool isUsefulDominator(const TraceBlockInfo &TBI) const

Assuming that this is a dominator of TBI, determine if it contains useful instruction depths.

void invalidateHeight()

Invalidate height resources when a block below this one has changed.

unsigned CriticalPath

Critical path length.

void print(raw_ostream &) const

unsigned Head

The block number of the head of the trace. (When hasValidDepth()).

bool HasValidInstrDepths

Instruction depths have been computed. This implies hasValidDepth().

bool hasValidHeight() const

Returns true if the height resources have been computed from the trace below this block.

bool HasValidInstrHeights

Instruction heights have been computed. This implies hasValidHeight().

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