#include <LiveRangeData.hh>

Collaboration diagram for LiveRangeData:

Public Types
typedef std::set< MoveNodeUse >	MoveNodeUseSet

typedef std::map< TCEString, MoveNodeUseSet >	MoveNodeUseMapSet

typedef std::map< TCEString, MoveNodeUse >	MoveNodeUseMap

typedef std::map< TCEString, std::pair< MoveNodeUse, MoveNodeUse > >	MoveNodeUseMapPair

typedef std::pair< TCEString, MoveNodeUseSet >	MoveNodeUseSetPair

typedef std::pair< TCEString, MoveNodeUse >	MoveNodeUsePair

Public Member Functions
std::set< TCEString >	registersAlive (int cycle, int delaySlots, class DataDependenceGraph &ddg)

const std::set< TCEString > &	usedAfter ()

void	merge (LiveRangeData &succ)

Static Public Member Functions
static bool	appendUseMapSets (const MoveNodeUseMapSet &srcMap, MoveNodeUseMapSet &dstMap, bool addLoopProperty)

static void	appendMoveNodeUse (const MoveNodeUseSet &src, MoveNodeUseSet &dst, bool setLoopProperty)

Public Attributes
MoveNodeUseMapSet	regDefines_

MoveNodeUseMapSet	regLastUses_

MoveNodeUseMapPair	regLastKills_

std::map< TCEString, std::pair< MoveNodeUse, bool > >	potentialRegKills_

MoveNodeUseMapPair	regKills_

MoveNodeUseMapSet	regFirstUses_

MoveNodeUseMapSet	regFirstDefines_

MoveNodeUseMapSet	regDefReaches_

MoveNodeUseMapSet	regUseReaches_

MoveNodeUseMapSet	regDefAfter_

MoveNodeUseMapSet	regUseAfter_

MoveNodeUseMapSet	memDefines_

MoveNodeUseMapSet	memLastUses_

MoveNodeUseMap	memLastKill_

MoveNodeUseMap	memKills_

MoveNodeUseMapSet	memFirstUses_

MoveNodeUseMapSet	memFirstDefines_

MoveNodeUseMapSet	memDefReaches_

MoveNodeUseMapSet	memUseReaches_

MoveNodeUseMapSet	memDefAfter_

MoveNodeUseMapSet	memUseAfter_

MoveNodeUseSet	fuDepReaches_

MoveNodeUseSet	fuDeps_

MoveNodeUseSet	fuDepAfter_

std::set< TCEString >	registersUsedAfter_

std::set< TCEString >	registersUsedInOrAfter_

std::set< TCEString >	inlineAsmRegUses_

std::set< TCEString >	inlineAsmRegDefs_

std::set< TCEString >	inlineAsmClobbers_

Detailed Description

Definition at line 47 of file LiveRangeData.hh.

Member Typedef Documentation

◆ MoveNodeUseMap

typedef std::map<TCEString, MoveNodeUse > LiveRangeData::MoveNodeUseMap

Definition at line 53 of file LiveRangeData.hh.

◆ MoveNodeUseMapPair

typedef std::map<TCEString, std::pair<MoveNodeUse, MoveNodeUse> > LiveRangeData::MoveNodeUseMapPair

Definition at line 55 of file LiveRangeData.hh.

◆ MoveNodeUseMapSet

typedef std::map<TCEString, MoveNodeUseSet > LiveRangeData::MoveNodeUseMapSet

Definition at line 52 of file LiveRangeData.hh.

◆ MoveNodeUsePair

typedef std::pair<TCEString, MoveNodeUse> LiveRangeData::MoveNodeUsePair

Definition at line 58 of file LiveRangeData.hh.

◆ MoveNodeUseSet

typedef std::set<MoveNodeUse > LiveRangeData::MoveNodeUseSet

Definition at line 51 of file LiveRangeData.hh.

◆ MoveNodeUseSetPair

typedef std::pair<TCEString, MoveNodeUseSet > LiveRangeData::MoveNodeUseSetPair

Definition at line 57 of file LiveRangeData.hh.

Member Function Documentation

◆ appendMoveNodeUse()

void LiveRangeData::appendMoveNodeUse	(	const MoveNodeUseSet &	src,
		LiveRangeData::MoveNodeUseSet &	dst,
		bool	setLoopProperty
	)

static

Appends a MoveNodeUseSet to another. May set loop property of copied moves to true.

Parameters

src	source set
dst	destination set
setLoopProperty	whether to set loop property true in copied data

Definition at line 107 of file LiveRangeData.cc.

                           {
  
     for (LiveRangeData::MoveNodeUseSet::const_iterator i =
              src.begin(); i != src.end(); i++) {
         const MoveNodeUse& mnu = *i;
         if (setLoopProperty || mnu.loop()) {
             dst.insert(MoveNodeUse(mnu, MoveNodeUse::LOOP));
         } else {
             dst.insert(MoveNodeUse(mnu, MoveNodeUse::INTRA_BB));
         }
     }
 }

References MoveNodeUse::INTRA_BB, MoveNodeUse::LOOP, and MoveNodeUse::loop().

Referenced by appendUseMapSets(), and DataDependenceGraphBuilder::setSucceedingPredepsForBB().

Here is the call graph for this function:

◆ appendUseMapSets()

bool LiveRangeData::appendUseMapSets	(	const MoveNodeUseMapSet &	srcMap,
		MoveNodeUseMapSet &	dstMap,
		bool	addLoopProperty
	)

static

This appends the data from one MoveNodeUseMapSet to another.

it traverses the map, and for every string, set pair it finds or creates the corresponging set in the destination and appends the set to that set. This is used for copying alive definitions.

Parameters

srcMap	source where to copy from
dstMap	destination where to copy to.
addLoopProperty	whether to add loop property to the copied bookkeeping, ie create edges with loop property.

Returns: true if destination changed (needs updating)

Definition at line 79 of file LiveRangeData.cc.

                           {
     bool changed = false;
     for (MoveNodeUseMapSet::const_iterator srcIter = srcMap.begin();
          srcIter != srcMap.end(); srcIter++) {
         TCEString reg = srcIter->first;
         const MoveNodeUseSet& srcSet = srcIter->second;
         MoveNodeUseSet& dstSet = dstMap[reg];
         // dest set size before appending.
         size_t size = dstSet.size();
         appendMoveNodeUse(srcSet, dstSet, addLoopProperty);
         // if size has changed, dest is changed.
         if (dstSet.size() > size) {
             changed = true;
         }
     }
     return changed;
 }

References appendMoveNodeUse().

Referenced by merge(), DataDependenceGraphBuilder::setSucceedingPredepsForBB(), DataDependenceGraphBuilder::updateMemAndFuAliveAfter(), and DataDependenceGraphBuilder::updateRegistersAliveAfter().

Here is the call graph for this function:

◆ merge()

void LiveRangeData::merge ( LiveRangeData & succ )

merges liverangedata of successor into this.

Parameters

succ	later basic block which is merged into this one.

Definition at line 47 of file LiveRangeData.cc.

                                              {
  
     // copy outgoing live information as it is from successor
     appendUseMapSets(succ.regDefines_, regDefines_, false);
     appendUseMapSets(succ.regLastUses_, regLastUses_, false);
  
     // after this BB alive regs are those that are alive after the latter bb.
     registersUsedAfter_ = succ.registersUsedAfter_;
  
     // then in incoming deps, merge from both.
  
     appendUseMapSets(succ.regFirstDefines_, regFirstDefines_, false);
     appendUseMapSets(succ.regFirstUses_, regFirstUses_, false);
     appendUseMapSets(succ.regDefReaches_ , regDefReaches_, false);
  
 }

References appendUseMapSets(), regDefines_, regDefReaches_, regFirstDefines_, regFirstUses_, registersUsedAfter_, and regLastUses_.

Referenced by ControlFlowGraph::mergeNodes().

Here is the call graph for this function:

◆ registersAlive()

std::set< TCEString > LiveRangeData::registersAlive	(	int	cycle,
		int	delaySlots,
		class DataDependenceGraph &	ddg
	)

Returns the set of registers that are alive at the given cycle.

Definition at line 127 of file LiveRangeData.cc.

                                                          {
  
     std::set<TCEString> aliveRegs;
  
     // Part 1: Live ranges incoming to this BB.
     // handles both incoming and overgoing live ranges
     for (MoveNodeUseMapSet::iterator rdrIter = regDefReaches_.begin();
          rdrIter != regDefReaches_.end(); rdrIter++) {
         const TCEString& reg = rdrIter->first;
  
         // if use after and not killed here, alive for the whole BB.
         if (registersUsedAfter_.find(reg) != registersUsedAfter_.end()) {
             // nothing in this BB overwrites this.
             if (regKills_.find(reg) == regKills_.end()) {
                 aliveRegs.insert(reg);
             }
         }
  
         // check for first uses in this BB. If before a read, is used.
         MoveNodeUseSet& firstUses = regFirstUses_[reg];
         for (MoveNodeUseSet::iterator iter = firstUses.begin();
              iter != firstUses.end(); iter++) {
             const MoveNode& mn = *(iter->mn());
             if (mn.isScheduled()) {
                 int mnCycle = mn.cycle();
                 if (iter->pseudo()) {
                     mnCycle += delaySlots;
                 }
                 if (cycle <= mnCycle) {
                     aliveRegs.insert(reg);
                 }
             } else { // unscheduled.. later?
                 aliveRegs.insert(reg);
             }
         }
     }
  
     // Part 2: check deps going out from this.
     for (std::set<TCEString>::iterator ruaIter = registersUsedAfter_.begin();
          ruaIter != registersUsedAfter_.end(); ruaIter++) {
         const TCEString& reg = *ruaIter;
  
         // check against last defines.
         MoveNodeUseSet& lastDefs = regDefines_[reg];
         for (MoveNodeUseSet::iterator iter = lastDefs.begin();
              iter != lastDefs.end(); iter++) {
             const MoveNode& mn = *iter->mn();
             if (mn.isScheduled()) {
                 int mnCycle = mn.cycle();
                 if (iter->pseudo()) {
                     mnCycle += delaySlots;
                 }
                 if (cycle >= mnCycle) {
                     aliveRegs.insert(reg);
                 }
             }
             // if not scheduld, is at end?
         }
     }
  
     // part 3: Check edges inside this BB. done from DDG.
  
     // TODO: psedo-dep delay slots.
     for (int i = 0; i < ddg.nodeCount(); i++) {
         MoveNode& node = ddg.node(i);
         // only check writes that are scheduled.
         if (!node.isScheduled() || node.cycle() > cycle) {
             continue; // write after the given cycle
         }
  
         // Find all edges out from this
         DataDependenceGraph::EdgeSet edges = ddg.outEdges(node);
         for (DataDependenceGraph::EdgeSet::iterator eIter = 
                  edges.begin(); eIter != edges.end(); eIter++) {
             DataDependenceEdge& edge = **eIter;
  
             // we are only interested in register RAWs.
             if ((edge.edgeReason() == DataDependenceEdge::EDGE_REGISTER || 
                  edge.edgeReason() == DataDependenceEdge::EDGE_RA) &&
                 (edge.dependenceType() == DataDependenceEdge::DEP_RAW)) {
                 const TCEString& reg = edge.data();
                 MoveNode &headNode = ddg.headNode(edge);
                 // if tail pseudo, delay by delaySlots amount
                 if (edge.tailPseudo()) {
                     if (node.cycle() + delaySlots > cycle) {
                         continue;
                     }
                 }
                 // if pseudo, delay mncycle by delayslot amount
                 int delay = edge.headPseudo() ? delaySlots : 0;
                 // is the read after this
                 if (headNode.isScheduled() && 
                     headNode.cycle()+delay >= cycle) {
                     aliveRegs.insert(reg);
                 }
             }
         }
     }
     return aliveRegs;
 }

Referenced by BasicBlockPass::executeDDGPass().

Here is the call graph for this function:

◆ usedAfter()

const std::set<TCEString>& LiveRangeData::usedAfter ( )

inline

Definition at line 60 of file LiveRangeData.hh.

                                          {
         return registersUsedAfter_;
     }

References registersUsedAfter_.

Member Data Documentation

◆ fuDepAfter_

MoveNodeUseSet LiveRangeData::fuDepAfter_

Definition at line 118 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::clearUnneededBookkeeping(), DataDependenceGraphBuilder::setSucceedingPredepsForBB(), and DataDependenceGraphBuilder::updateMemAndFuAliveAfter().

◆ fuDepReaches_

MoveNodeUseSet LiveRangeData::fuDepReaches_

Definition at line 116 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::clearUnneededBookkeeping(), DataDependenceGraphBuilder::createTriggerDependencies(), DataDependenceGraphBuilder::setSucceedingPredepsForBB(), and DataDependenceGraphBuilder::updateBB().

◆ fuDeps_

MoveNodeUseSet LiveRangeData::fuDeps_

Definition at line 117 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::clearUnneededBookkeeping(), DataDependenceGraphBuilder::createTriggerDependencies(), DataDependenceGraphBuilder::updateBB(), and DataDependenceGraphBuilder::updateMemAndFuAliveAfter().

◆ inlineAsmClobbers_

std::set<TCEString> LiveRangeData::inlineAsmClobbers_

Definition at line 128 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::constructIndividualFromInlineAsmBB(), and ControlFlowGraph::splitBasicBlockAtIndex().

◆ inlineAsmRegDefs_

std::set<TCEString> LiveRangeData::inlineAsmRegDefs_

Definition at line 127 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::constructIndividualFromInlineAsmBB(), and ControlFlowGraph::splitBasicBlockAtIndex().

◆ inlineAsmRegUses_

std::set<TCEString> LiveRangeData::inlineAsmRegUses_

Definition at line 126 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::constructIndividualFromInlineAsmBB(), and ControlFlowGraph::splitBasicBlockAtIndex().

◆ memDefAfter_

MoveNodeUseMapSet LiveRangeData::memDefAfter_

Definition at line 112 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::setSucceedingPredepsForBB(), and DataDependenceGraphBuilder::updateMemAndFuAliveAfter().

◆ memDefines_

MoveNodeUseMapSet LiveRangeData::memDefines_

Definition at line 98 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::clearUnneededBookkeeping(), DataDependenceGraphBuilder::processMemUse(), DataDependenceGraphBuilder::processMemWrite(), and DataDependenceGraphBuilder::updateMemAndFuAliveAfter().

◆ memDefReaches_

MoveNodeUseMapSet LiveRangeData::memDefReaches_

Definition at line 108 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::clearUnneededBookkeeping(), DataDependenceGraphBuilder::setSucceedingPredepsForBB(), DataDependenceGraphBuilder::updateMemAndFuAliveAfter(), DataDependenceGraphBuilder::updateMemUse(), and DataDependenceGraphBuilder::updateMemWrite().

◆ memFirstDefines_

MoveNodeUseMapSet LiveRangeData::memFirstDefines_

Definition at line 105 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::clearUnneededBookkeeping(), DataDependenceGraphBuilder::processMemWrite(), and DataDependenceGraphBuilder::updateBB().

◆ memFirstUses_

MoveNodeUseMapSet LiveRangeData::memFirstUses_

Definition at line 104 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::clearUnneededBookkeeping(), DataDependenceGraphBuilder::processMemUse(), and DataDependenceGraphBuilder::updateBB().

◆ memKills_

MoveNodeUseMap LiveRangeData::memKills_

Definition at line 103 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::processMemUse(), DataDependenceGraphBuilder::processMemWrite(), and DataDependenceGraphBuilder::updateMemAndFuAliveAfter().

◆ memLastKill_

MoveNodeUseMap LiveRangeData::memLastKill_

Definition at line 100 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::processMemWrite().

◆ memLastUses_

MoveNodeUseMapSet LiveRangeData::memLastUses_

Definition at line 99 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::clearUnneededBookkeeping(), DataDependenceGraphBuilder::processMemUse(), and DataDependenceGraphBuilder::processMemWrite().

◆ memUseAfter_

MoveNodeUseMapSet LiveRangeData::memUseAfter_

Definition at line 113 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::setSucceedingPredepsForBB(), and DataDependenceGraphBuilder::updateMemAndFuAliveAfter().

◆ memUseReaches_

MoveNodeUseMapSet LiveRangeData::memUseReaches_

Definition at line 109 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::clearUnneededBookkeeping(), DataDependenceGraphBuilder::setSucceedingPredepsForBB(), DataDependenceGraphBuilder::updateMemAndFuAliveAfter(), and DataDependenceGraphBuilder::updateMemWrite().

◆ potentialRegKills_

std::map<TCEString, std::pair<MoveNodeUse, bool> > LiveRangeData::potentialRegKills_

Definition at line 82 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::constructIndividualBB(), DataDependenceGraphBuilder::processRegUse(), and DataDependenceGraphBuilder::processRegWrite().

◆ regDefAfter_

MoveNodeUseMapSet LiveRangeData::regDefAfter_

Definition at line 94 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::clearUnneededBookkeeping(), DataDependenceGraphBuilder::setSucceedingPredepsForBB(), and DataDependenceGraphBuilder::updateRegistersAliveAfter().

◆ regDefines_

MoveNodeUseMapSet LiveRangeData::regDefines_

Definition at line 78 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::clearUnneededBookkeeping(), DataDependenceGraphBuilder::constructIndividualFromInlineAsmBB(), BFRegCopy::createAntidepsForReg(), RegisterCopyAdder::createAntidepsForReg(), BBSchedulerController::handleBasicBlock(), RegisterRenamer::initializeFreeRegisters(), merge(), DataDependenceGraphBuilder::processRegUse(), DataDependenceGraphBuilder::processRegWrite(), registersAlive(), RegisterRenamer::renameLiveRange(), BF2Scheduler::revertBBLiveRangeBookkeepingForDestination(), RegisterRenamer::revertedRenameToRegister(), BFRenameLiveRange::setOutgoingDeps(), BFRenameLiveRange::setRegDefsAndLastUses(), BFRenameLiveRange::undoSetRegDefsAndLastUses(), BFRenameLiveRange::unsetOutgoingDeps(), and DataDependenceGraphBuilder::updateRegistersAliveAfter().

◆ regDefReaches_

MoveNodeUseMapSet LiveRangeData::regDefReaches_

Definition at line 90 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::clearUnneededBookkeeping(), BBSchedulerController::handleBasicBlock(), RegisterRenamer::initializeFreeRegisters(), merge(), DataDependenceGraphBuilder::processEntryNode(), registersAlive(), DataDependenceGraphBuilder::setSucceedingPredepsForBB(), DataDependenceGraphBuilder::updateRegistersAliveAfter(), DataDependenceGraph::updateRegUse(), and DataDependenceGraph::updateRegWrite().

◆ regFirstDefines_

MoveNodeUseMapSet LiveRangeData::regFirstDefines_

Definition at line 87 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::clearUnneededBookkeeping(), BFRegCopy::createAntidepsForReg(), RegisterCopyAdder::createAntidepsForReg(), BBSchedulerController::handleBasicBlock(), merge(), DataDependenceGraphBuilder::processRegWrite(), RegisterRenamer::renameLiveRange(), BF2Scheduler::revertBBLiveRangeBookkeepingForDestination(), RegisterRenamer::revertedRenameToRegister(), BFRenameLiveRange::setFirstDefsAndUses(), BFRenameLiveRange::setIncomingDeps(), BFRenameLiveRange::undoSetFirstDefsAndUses(), BFRenameLiveRange::unsetIncomingDeps(), RegisterRenamer::updateAntiEdgesFromLRTo(), and DataDependenceGraphBuilder::updateBB().

◆ regFirstUses_

MoveNodeUseMapSet LiveRangeData::regFirstUses_

Definition at line 86 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::clearUnneededBookkeeping(), DataDependenceGraphBuilder::constructIndividualFromInlineAsmBB(), BFRegCopy::createAntidepsForReg(), RegisterCopyAdder::createAntidepsForReg(), BBSchedulerController::handleBasicBlock(), RegisterRenamer::initializeFreeRegisters(), merge(), DataDependenceGraphBuilder::processRegUse(), registersAlive(), RegisterRenamer::renameLiveRange(), BF2Scheduler::revertBBLiveRangeBookkeepingForSource(), RegisterRenamer::revertedRenameToRegister(), BFRenameLiveRange::setFirstDefsAndUses(), BFRenameLiveRange::setIncomingDeps(), BFRenameLiveRange::undoSetFirstDefsAndUses(), BFRenameLiveRange::unsetIncomingDeps(), DataDependenceGraphBuilder::updateBB(), and DataDependenceGraphBuilder::updateRegistersUsedInOrAfter().

◆ registersUsedAfter_

std::set<TCEString> LiveRangeData::registersUsedAfter_

Definition at line 121 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::clearUnneededBookkeeping(), BBSchedulerController::handleBasicBlock(), RegisterRenamer::initializeFreeRegisters(), merge(), registersAlive(), DataDependenceGraphBuilder::updatePreceedingRegistersUsedAfter(), DataDependenceGraphBuilder::updateRegistersUsedInOrAfter(), and usedAfter().

◆ registersUsedInOrAfter_

std::set<TCEString> LiveRangeData::registersUsedInOrAfter_

Definition at line 122 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::clearUnneededBookkeeping(), DataDependenceGraphBuilder::updatePreceedingRegistersUsedAfter(), and DataDependenceGraphBuilder::updateRegistersUsedInOrAfter().

◆ regKills_

MoveNodeUseMapPair LiveRangeData::regKills_

Definition at line 85 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::constructIndividualFromInlineAsmBB(), DataDependenceGraphBuilder::processRegUse(), DataDependenceGraphBuilder::processRegWrite(), registersAlive(), RegisterRenamer::renameLiveRange(), BFRenameLiveRange::setIncomingDeps(), BFRenameLiveRange::unsetIncomingDeps(), DataDependenceGraphBuilder::updateRegistersAliveAfter(), and DataDependenceGraphBuilder::updateRegistersUsedInOrAfter().

◆ regLastKills_

MoveNodeUseMapPair LiveRangeData::regLastKills_

Definition at line 80 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::clearUnneededBookkeeping(), DataDependenceGraphBuilder::processRegWrite(), RegisterRenamer::renameLiveRange(), BFRenameLiveRange::setOutgoingDeps(), and BFRenameLiveRange::unsetOutgoingDeps().

◆ regLastUses_

MoveNodeUseMapSet LiveRangeData::regLastUses_

Definition at line 79 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::clearUnneededBookkeeping(), BFRegCopy::createAntidepsForReg(), RegisterCopyAdder::createAntidepsForReg(), BBSchedulerController::handleBasicBlock(), RegisterRenamer::initializeFreeRegisters(), merge(), DataDependenceGraphBuilder::processRegUse(), DataDependenceGraphBuilder::processRegWrite(), RegisterRenamer::renameLiveRange(), BF2Scheduler::revertBBLiveRangeBookkeepingForSource(), RegisterRenamer::revertedRenameToRegister(), BFRenameLiveRange::setRegDefsAndLastUses(), BFRenameLiveRange::undoSetRegDefsAndLastUses(), and DataDependenceGraphBuilder::updateRegistersAliveAfter().

◆ regUseAfter_

MoveNodeUseMapSet LiveRangeData::regUseAfter_

Definition at line 95 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::clearUnneededBookkeeping(), DataDependenceGraphBuilder::setSucceedingPredepsForBB(), and DataDependenceGraphBuilder::updateRegistersAliveAfter().

◆ regUseReaches_

MoveNodeUseMapSet LiveRangeData::regUseReaches_

Definition at line 91 of file LiveRangeData.hh.

Referenced by DataDependenceGraphBuilder::clearUnneededBookkeeping(), DataDependenceGraphBuilder::setSucceedingPredepsForBB(), DataDependenceGraphBuilder::updateRegistersAliveAfter(), and DataDependenceGraph::updateRegWrite().

The documentation for this struct was generated from the following files:

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Member Typedef Documentation

◆ MoveNodeUseMap

◆ MoveNodeUseMapPair

◆ MoveNodeUseMapSet

◆ MoveNodeUsePair

◆ MoveNodeUseSet

◆ MoveNodeUseSetPair

Member Function Documentation

◆ appendMoveNodeUse()

◆ appendUseMapSets()

◆ merge()

◆ registersAlive()

◆ usedAfter()

Member Data Documentation

◆ fuDepAfter_

◆ fuDepReaches_

◆ fuDeps_

◆ inlineAsmClobbers_

◆ inlineAsmRegDefs_

◆ inlineAsmRegUses_

◆ memDefAfter_

◆ memDefines_

◆ memDefReaches_

◆ memFirstDefines_

◆ memFirstUses_

◆ memKills_

◆ memLastKill_

◆ memLastUses_

◆ memUseAfter_

◆ memUseReaches_

◆ potentialRegKills_

◆ regDefAfter_

◆ regDefines_

◆ regDefReaches_

◆ regFirstDefines_

◆ regFirstUses_

◆ registersUsedAfter_

◆ registersUsedInOrAfter_

◆ regKills_

◆ regLastKills_

◆ regLastUses_

◆ regUseAfter_

◆ regUseReaches_