BFRenameLiveRange Class Reference

#include <BFRenameLiveRange.hh>

Inheritance diagram for BFRenameLiveRange:

Collaboration diagram for BFRenameLiveRange:

Public Member Functions
	BFRenameLiveRange (BF2Scheduler &sched, std::shared_ptr< LiveRange > liveRange, int targetCycle)
virtual bool	operator() ()
virtual	~BFRenameLiveRange ()
Public Member Functions inherited from BFOptimization
	BFOptimization (BF2Scheduler &sched)
virtual bool	isFinishFront ()
virtual void	mightBeReady (MoveNode &mn)
Public Member Functions inherited from Reversible
virtual void	undo ()
virtual	~Reversible ()
void	deleteChildren (std::stack< Reversible * > &children)
int	id ()
	Reversible ()

Protected Member Functions
void	undoSetTerminal ()
void	setTerminals ()
void	setGuard (TTAProgram::Move &move, const TTAMachine::RegisterFile &rf, int regIndex)
void	setRegDefsAndLastUses ()
void	undoSetRegDefsAndLastUses ()
void	setFirstDefsAndUses ()
void	undoSetFirstDefsAndUses ()
void	setOutgoingDeps ()
void	setIncomingDeps ()
void	unsetIncomingDeps ()
void	unsetOutgoingDeps ()
void	undoNewAntiDeps ()
void	notifySelector ()
bool	renameLiveRange (class LiveRange &liveRange, const class TCEString &reg, bool usedAfter)
virtual void	undoOnlyMe () override
Protected Member Functions inherited from BFOptimization
DataDependenceGraph &	ddg ()
DataDependenceGraph *	rootDDG ()
const DataDependenceGraph &	ddg () const
DataDependenceGraph *	prologDDG ()
SimpleResourceManager &	rm () const
SimpleResourceManager *	prologRM () const
BUMoveNodeSelector &	selector ()
const TTAMachine::Machine &	targetMachine () const
unsigned int	ii () const
MoveNodeDuplicator &	duplicator () const
virtual bool	assign (int cycle, MoveNode &, const TTAMachine::Bus *bus=nullptr, const TTAMachine::FunctionUnit *srcFU_=nullptr, const TTAMachine::FunctionUnit *dstFU=nullptr, const TTAMachine::Bus *prologBus=nullptr, int immWriteCycle=-1, int prologImmWriteCycle=-1, const TTAMachine::ImmediateUnit *immu=nullptr, int immRegIndex=-1, bool ignoreGuardWriteCycle=false)
virtual void	unassign (MoveNode &mn, bool disposePrologCopy=true)
virtual int	rmEC (int cycle, MoveNode &mn, const TTAMachine::Bus *bus=nullptr, const TTAMachine::FunctionUnit *srcFU=nullptr, const TTAMachine::FunctionUnit *dstFU=nullptr, const TTAMachine::Bus *prologBus=nullptr, int immWriteCycle=-1, int prologImmWriteCycle=-1, const TTAMachine::ImmediateUnit *immu=nullptr, int immRegIndex=-1)
virtual int	rmLC (int cycle, MoveNode &mn, const TTAMachine::Bus *bus=nullptr, const TTAMachine::FunctionUnit *srcFU=nullptr, const TTAMachine::FunctionUnit *dstFU=nullptr, const TTAMachine::Bus *prologBus=nullptr, int immWriteCycle=-1, int prologImmWriteCycle=-1, const TTAMachine::ImmediateUnit *immu=nullptr, int immRegIndex=-1)
virtual bool	canAssign (int cycle, MoveNode &mn, const TTAMachine::Bus *bus=nullptr, const TTAMachine::FunctionUnit *srcFU=nullptr, const TTAMachine::FunctionUnit *dstFU=nullptr, const TTAMachine::Bus *prologBus=nullptr, int immWriteCycle=-1, int prologImmWriteCycle=-1, const TTAMachine::ImmediateUnit *immu=nullptr, int immRegIndex=-1, bool ignoreGWN=false)
bool	putAlsoToPrologEpilog (int cycle, MoveNode &mn)
void	setPrologSrcFUAnno (MoveNode &prologMN, MoveNode &loopMN)
void	setPrologDstFUAnno (MoveNode &prologMN, MoveNode &loopMN)
void	setJumpGuard (MoveNode &mn)
void	unsetJumpGuard (MoveNode &mn)
bool	needJumpGuard (const MoveNode &mn, int cycle)
int	jumpGuardAvailableCycle (const MoveNode &mn)
bool	canBeSpeculated (const Operation &op)
bool	canBeSpeculated (const MoveNode &mn)
bool	usePrologMove (const MoveNode &mn)
bool	canBeScheduled (const MoveNode &mn)
const TTAMachine::RegisterFile *	RFReadPortCountPreventsScheduling (const MoveNode &mn)
bool	immCountPreventsScheduling (const MoveNode &mn)
Protected Member Functions inherited from Reversible
bool	runPreChild (Reversible *preChild)
bool	runPostChild (Reversible *preChild)
bool	runChild (std::stack< Reversible * > &children, Reversible *child)
bool	runChild (Reversible *child, bool pre)
void	undoAndRemovePreChildren ()
void	undoAndRemovePostChildren ()
void	undoAndRemoveChildren (std::stack< Reversible * > &children)

Protected Attributes
DataDependenceGraph::UndoData	undoWriteUpdateData_
std::map< const MoveNode *, DataDependenceGraph::UndoData, MoveNode::Comparator >	undoReadUpdateData_
class TTAProgram::Terminal *	oldReg_
std::shared_ptr< LiveRange >	liveRange_
TTAProgram::BasicBlock *	bb_
TCEString	newReg_
MoveNodeUse	oldLastKill_
MoveNodeUse	oldKill_
int	targetCycle_
LiveRangeData::MoveNodeUseSet	oldRegDefines_
LiveRangeData::MoveNodeUseSet	oldRegFirstDefines_
LiveRangeData::MoveNodeUseSet	oldRegFirstUses_
DataDependenceGraph::EdgeSet	createdAntidepEdges_
Protected Attributes inherited from BFOptimization
BF2Scheduler &	sched_
Protected Attributes inherited from Reversible
std::stack< Reversible * >	preChildren_
std::stack< Reversible * >	postChildren_

Additional Inherited Members
Static Public Member Functions inherited from BFOptimization
static void	clearPrologMoves ()
static MoveNode *	getSisterTrigger (const MoveNode &mn, const TTAMachine::Machine &mach)
Static Protected Attributes inherited from BFOptimization
static std::map< MoveNode *, MoveNode *, MoveNode::Comparator >	prologMoves_

Detailed Description

Definition at line 45 of file BFRenameLiveRange.hh.

Constructor & Destructor Documentation

BFRenameLiveRange()

BFRenameLiveRange::BFRenameLiveRange	(	BF2Scheduler &	sched,
		std::shared_ptr< LiveRange >	liveRange,
		int	targetCycle
	)

Definition at line 52 of file BFRenameLiveRange.cc.

                     :
    BFOptimization(sched), oldReg_(nullptr), liveRange_(liveRange),
    targetCycle_(targetCycle) {}

~BFRenameLiveRange()

BFRenameLiveRange::~BFRenameLiveRange ( )

virtual

Definition at line 478 of file BFRenameLiveRange.cc.

                                      {
    delete oldReg_;
}

References oldReg_.

Member Function Documentation

notifySelector()

void BFRenameLiveRange::notifySelector ( )

protected

Definition at line 419 of file BFRenameLiveRange.cc.

                                       {
    // then update ddg and notify selector.
 
    // for writes.
    for (auto i: liveRange_->writes) {
        DataDependenceGraph::NodeSet writeSuccessors =
            ddg().successors(*i);
        DataDependenceGraph::NodeSet writePredecessors =
            ddg().predecessors(*i);
 
        // notify successors of write to prevent orphan nodes.
        for (auto j: writeSuccessors) {
            sched_.currentFront()->mightBeReady(*j);
        }
 
        // notify successors of write to prevent orphan nodes.
        for (auto j: writePredecessors) {
            sched_.currentFront()->mightBeReady(*j);
        }
 
    }
 
    // for reads
    for (auto i: liveRange_->reads) {
        DataDependenceGraph::NodeSet successors =
            ddg().successors(*i);
        DataDependenceGraph::NodeSet predecessors =
            ddg().predecessors(*i);
 
        // notify successors to prevent orphan nodes.
        for (auto j: successors) {
            sched_.currentFront()->mightBeReady(*j);
        }
 
        // notify successors to prevent orphan nodes.
        for (auto j: predecessors) {
            sched_.currentFront()->mightBeReady(*j);
        }
    }
 
    // for guards
    for (auto i: liveRange_->guards) {
        DataDependenceGraph::NodeSet successors =
            ddg().successors(*i);
        DataDependenceGraph::NodeSet predecessors =
            ddg().predecessors(*i);
 
        // notify successors to prevent orphan nodes.
        for (auto j: successors) {
            sched_.currentFront()->mightBeReady(*j);
        }
 
        // notify successors to prevent orphan nodes.
        for (auto j: predecessors) {
            sched_.currentFront()->mightBeReady(*j);
        }
    }
}

References BF2Scheduler::currentFront(), BFOptimization::ddg(), liveRange_, BF2ScheduleFront::mightBeReady(), BoostGraph< GraphNode, GraphEdge >::predecessors(), BFOptimization::sched_, and BoostGraph< GraphNode, GraphEdge >::successors().

Referenced by renameLiveRange().

Here is the call graph for this function:

operator()()

bool BFRenameLiveRange::operator() ( )

virtual

This performs the operation. Returns true if success, false if fail.

Implements Reversible.

Definition at line 60 of file BFRenameLiveRange.cc.

                                   {
 
    bb_ = &sched_.renamer()->bb();
 
    assert(!liveRange_->reads.empty());
 
    auto rfs = sched_.renamer()->findConnectedRFs(*liveRange_, false);
 
    bool usedAfter = true;
    std::set<TCEString> regs;
 
    if (!ii()) {
 
        regs = sched_.renamer()->findPartiallyUsedRegistersInRFAfterCycle(
            rfs, targetCycle_);
    }
 
    if (regs.empty()) {
        usedAfter = false;
        regs = sched_.renamer()->findFreeRegistersInRF(rfs);
    }
 
    if (regs.empty()) {
        return false;
    }
 
    return renameLiveRange(*liveRange_, *regs.begin(), usedAfter);
}

References assert, RegisterRenamer::bb(), bb_, RegisterRenamer::findConnectedRFs(), RegisterRenamer::findFreeRegistersInRF(), RegisterRenamer::findPartiallyUsedRegistersInRFAfterCycle(), BFOptimization::ii(), liveRange_, renameLiveRange(), BF2Scheduler::renamer(), BFOptimization::sched_, and targetCycle_.

Here is the call graph for this function:

renameLiveRange()

bool BFRenameLiveRange::renameLiveRange ( class LiveRange &  liveRange, const class TCEString &  reg, bool  usedAfter  )

protected

Definition at line 319 of file BFRenameLiveRange.cc.

                                                                   {
 
    bool usedBefore = false;
 
    newReg_ = newReg;
    oldReg_ = (*liveRange.writes.begin())->move().destination().copy();
 
    assert(newReg.length() > 2);
 
    if (usedAfter) {
        TCEString rfName = newReg_.substr(0, newReg_.find('.'));
        TTAMachine::RegisterFile* rf =
            targetMachine().registerFileNavigator().item(rfName);
        int newRegIndex = atoi(newReg_.substr(newReg_.find('.')+1).c_str());
        DataDependenceGraph::NodeSet firstWrites =
            ddg().firstScheduledRegisterWrites(*rf, newRegIndex);
 
        // make sure no circular antidep path
        for (auto j: firstWrites) {
            for (auto i: liveRange.reads) {
                if (ddg().hasPath(*j, *i)) {
                    return false;
                }
            }
 
            for (auto i: liveRange.writes) {
                if (ddg().hasPath(*j, *i)) {
                    return false;
                }
            }
        }
 
        // antideps
        for (auto j: firstWrites) {
            for (auto i: liveRange.writes) {
                DataDependenceEdge* newWAW =
                    new DataDependenceEdge(
                        DataDependenceEdge::EDGE_REGISTER,
                        DataDependenceEdge::DEP_WAW, newReg);
                ddg().connectNodes(*i,*j, *newWAW);
                createdAntidepEdges_.insert(newWAW);
            }
 
            for (auto i: liveRange.reads) {
                DataDependenceEdge* newWAR =
                    new DataDependenceEdge(
                        DataDependenceEdge::EDGE_REGISTER,
                        DataDependenceEdge::DEP_WAR, newReg);
                ddg().connectNodes(*i,*j, *newWAR);
                createdAntidepEdges_.insert(newWAR);
            }
        }
    } else {
        setOutgoingDeps();
        setRegDefsAndLastUses();
 
 
// TODO
#if 0
        // need to create backedges to first if we are loop scheduling.
        if (loopScheduling) {
            updateAntiEdgesFromLRTo(liveRange, newReg, bb_, 1);
        }
#endif
    }
 
    if (usedBefore) {
        return false;
    } else {
        setIncomingDeps();
        setFirstDefsAndUses();
    }
 
    setTerminals();
    notifySelector();
 
    // for writes.
    assert (liveRange_->writes.size() == 1);
    for (auto i: liveRange_->writes) {
        undoWriteUpdateData_ = ddg().destRenamed(*i);
    }
 
    // for reads
    for (auto i: liveRange_->reads) {
        undoReadUpdateData_[i] = ddg().sourceRenamed(*i);
    }
 
    assert(liveRange_->guards.size() == 0);
    // for guards
    for (auto i: liveRange_->guards) {
        undoReadUpdateData_[i] = ddg().guardRenamed(*i);
    }
 
    sched_.renamer()->renamedToRegister(newReg);
    notifySelector();
    return true;
}

References assert, bb_, BoostGraph< GraphNode, GraphEdge >::connectNodes(), TTAProgram::Terminal::copy(), createdAntidepEdges_, BFOptimization::ddg(), DataDependenceEdge::DEP_WAR, DataDependenceEdge::DEP_WAW, DataDependenceGraph::destRenamed(), DataDependenceEdge::EDGE_REGISTER, DataDependenceGraph::firstScheduledRegisterWrites(), DataDependenceGraph::guardRenamed(), TTAMachine::Machine::Navigator< ComponentType >::item(), liveRange_, newReg_, notifySelector(), oldReg_, LiveRange::reads, TTAMachine::Machine::registerFileNavigator(), RegisterRenamer::renamedToRegister(), BF2Scheduler::renamer(), BFOptimization::sched_, setFirstDefsAndUses(), setIncomingDeps(), setOutgoingDeps(), setRegDefsAndLastUses(), setTerminals(), DataDependenceGraph::sourceRenamed(), BFOptimization::targetMachine(), undoReadUpdateData_, undoWriteUpdateData_, and LiveRange::writes.

Referenced by operator()().

Here is the call graph for this function:

setFirstDefsAndUses()

void BFRenameLiveRange::setFirstDefsAndUses ( )

protected

Definition at line 263 of file BFRenameLiveRange.cc.

                                            {
 
    // for writing.
    for (auto i: liveRange_->writes) {
        MoveNodeUse mnd(*i);
        bb_->liveRangeData_->regFirstDefines_[newReg_].insert(mnd);
        // TODO: only if intra-bb-antideps enabled?
//        static_cast<DataDependenceGraph*>(ddg().rootGraph())->
//            updateRegWrite(mnd, newReg, *bb_);
    }
 
    // for reading.
    for (auto i: liveRange_->reads) {
        MoveNodeUse mnd(*i);
        bb_->liveRangeData_->regFirstUses_[newReg_].insert(mnd);
        // no need to create raw deps here
    }
 
    // for guards.
    for (auto i: liveRange_->guards) {
        MoveNodeUse mnd(*i, true);
        bb_->liveRangeData_->regFirstUses_[newReg_].insert(mnd);
        // no need to create raw deps here
    }
}

References bb_, liveRange_, TTAProgram::BasicBlock::liveRangeData_, newReg_, LiveRangeData::regFirstDefines_, and LiveRangeData::regFirstUses_.

Referenced by renameLiveRange().

setGuard()

void BFRenameLiveRange::setGuard ( TTAProgram::Move &  move, const TTAMachine::RegisterFile &  rf, int  regIndex  )

protected

Definition at line 117 of file BFRenameLiveRange.cc.

                                                                         {
 
    const TTAMachine::Guard& guard = move.guard().guard();
    TTAMachine::Bus* guardBus =  guard.parentBus();
    for (int j = 0 ; j < guardBus->guardCount(); j++) {
        TTAMachine::Guard *g = guardBus->guard(j);
        TTAMachine::RegisterGuard* rg =
            dynamic_cast<TTAMachine::RegisterGuard*>(g);
        if (rg) {
            if (rg->registerFile() == &rf &&
                rg->registerIndex() == regIndex &&
                rg->isInverted() == guard.isInverted()) {
                move.setGuard(new TTAProgram::MoveGuard(*g));
            }
        }
    }
}

References TTAProgram::MoveGuard::guard(), TTAProgram::Move::guard(), TTAMachine::Bus::guard(), TTAMachine::Bus::guardCount(), TTAMachine::Guard::isInverted(), TTAMachine::Guard::parentBus(), TTAMachine::RegisterGuard::registerFile(), TTAMachine::RegisterGuard::registerIndex(), and TTAProgram::Move::setGuard().

Referenced by setTerminals(), and undoSetTerminal().

Here is the call graph for this function:

setIncomingDeps()

void BFRenameLiveRange::setIncomingDeps ( )

protected

Definition at line 186 of file BFRenameLiveRange.cc.

                                        {
    if (liveRange_->writes.size() != 1 ||
        !(*liveRange_->writes.begin())->move().isUnconditional()) {
        return;
    }
 
    oldKill_ = bb_->liveRangeData_->regKills_[newReg_].first;
    oldRegFirstDefines_ = bb_->liveRangeData_->regFirstDefines_[newReg_];
    oldRegFirstUses_ = bb_->liveRangeData_->regFirstUses_[newReg_];
}

References bb_, liveRange_, TTAProgram::BasicBlock::liveRangeData_, newReg_, oldKill_, oldRegFirstDefines_, oldRegFirstUses_, LiveRangeData::regFirstDefines_, LiveRangeData::regFirstUses_, and LiveRangeData::regKills_.

Referenced by renameLiveRange().

setOutgoingDeps()

void BFRenameLiveRange::setOutgoingDeps ( )

protected

Definition at line 207 of file BFRenameLiveRange.cc.

                                        {
    if (liveRange_->writes.size() != 1 ||
        !(*liveRange_->writes.begin())->move().isUnconditional()) {
        return;
    }
 
    oldLastKill_ = bb_->liveRangeData_->regLastKills_[newReg_].first;
    oldRegDefines_ = bb_->liveRangeData_->regDefines_[newReg_];
 
    bb_->liveRangeData_->regLastKills_[newReg_].first =
        MoveNodeUse(**liveRange_->writes.begin());
    bb_->liveRangeData_->regDefines_[newReg_].clear();
}

References bb_, liveRange_, TTAProgram::BasicBlock::liveRangeData_, newReg_, oldLastKill_, oldRegDefines_, LiveRangeData::regDefines_, and LiveRangeData::regLastKills_.

Referenced by renameLiveRange().

setRegDefsAndLastUses()

void BFRenameLiveRange::setRegDefsAndLastUses ( )

protected

Definition at line 222 of file BFRenameLiveRange.cc.

                                              {
    // for writing.
    for (auto i: liveRange_->writes) {
        MoveNodeUse mnd(*i);
        bb_->liveRangeData_->regDefines_[newReg_].insert(mnd);
    }
 
    // for reading.
    for (auto i: liveRange_->reads) {
        MoveNodeUse mnd(*i);
        bb_->liveRangeData_->regLastUses_[newReg_].insert(mnd);
    }
 
    // for reading.
    for (auto i: liveRange_->guards) {
        MoveNodeUse mnd(*i, true);
        bb_->liveRangeData_->regLastUses_[newReg_].insert(mnd);
    }
 
}

References bb_, liveRange_, TTAProgram::BasicBlock::liveRangeData_, newReg_, LiveRangeData::regDefines_, and LiveRangeData::regLastUses_.

Referenced by renameLiveRange().

setTerminals()

void BFRenameLiveRange::setTerminals ( )

protected

Definition at line 89 of file BFRenameLiveRange.cc.

                                     {
 
    TCEString rfName = newReg_.substr(0, newReg_.find('.'));
    TTAMachine::RegisterFile* rf =
        targetMachine().registerFileNavigator().item(rfName);
    int newRegIndex = atoi(newReg_.substr(newReg_.find('.')+1).c_str());
 
    // for writes.
    for (auto i: liveRange_->writes) {
        TTAProgram::Move& move = i->move();
        move.setDestination(new TTAProgram::TerminalRegister(
                                *rf->firstWritePort(), newRegIndex));
    }
 
    // for reads.
    for (auto i: liveRange_->reads) {
        TTAProgram::Move& move = i->move();
        move.setSource(new TTAProgram::TerminalRegister(
                           *rf->firstReadPort(), newRegIndex));
    }
 
    // for guards.
    for (auto i: liveRange_->guards) {
        TTAProgram::Move& move = i->move();
        setGuard(move, *rf, newRegIndex);
    }
}

References TTAMachine::RegisterFile::firstReadPort(), TTAMachine::RegisterFile::firstWritePort(), TTAMachine::Machine::Navigator< ComponentType >::item(), liveRange_, newReg_, TTAMachine::Machine::registerFileNavigator(), TTAProgram::Move::setDestination(), setGuard(), TTAProgram::Move::setSource(), and BFOptimization::targetMachine().

Referenced by renameLiveRange().

Here is the call graph for this function:

undoNewAntiDeps()

void BFRenameLiveRange::undoNewAntiDeps ( )

protected

Definition at line 179 of file BFRenameLiveRange.cc.

                                        {
    for (auto e: createdAntidepEdges_) {
        ddg().removeEdge(*e);
    }
    createdAntidepEdges_.clear();
}

References createdAntidepEdges_, BFOptimization::ddg(), and BoostGraph< GraphNode, GraphEdge >::removeEdge().

Referenced by undoOnlyMe().

Here is the call graph for this function:

undoOnlyMe()

void BFRenameLiveRange::undoOnlyMe ( )

overrideprotectedvirtual

Undoes the operations done by this class but not children. This method should be overloaded by most derived classes.

Reimplemented from Reversible.

Definition at line 158 of file BFRenameLiveRange.cc.

                                   {
    // restore the DDG stage before the rename
    for (auto i: undoReadUpdateData_) {
        ddg().undo(i.second);
    }
    ddg().undo(undoWriteUpdateData_);
 
    undoSetTerminal();
 
    undoSetFirstDefsAndUses();
    undoSetRegDefsAndLastUses();
 
    unsetIncomingDeps();
    unsetOutgoingDeps();
 
    sched_.renamer()->revertedRenameToRegister(newReg_);
 
    undoNewAntiDeps();
 
}

References BFOptimization::ddg(), newReg_, BF2Scheduler::renamer(), RegisterRenamer::revertedRenameToRegister(), BFOptimization::sched_, DataDependenceGraph::undo(), undoNewAntiDeps(), undoReadUpdateData_, undoSetFirstDefsAndUses(), undoSetRegDefsAndLastUses(), undoSetTerminal(), undoWriteUpdateData_, unsetIncomingDeps(), and unsetOutgoingDeps().

Here is the call graph for this function:

undoSetFirstDefsAndUses()

void BFRenameLiveRange::undoSetFirstDefsAndUses ( )

protected

Definition at line 289 of file BFRenameLiveRange.cc.

                                                {
 
    // for writing.
    for (auto i: liveRange_->writes) {
        MoveNodeUse mnd(*i);
        bb_->liveRangeData_->regFirstDefines_[newReg_].erase(mnd);
 
 
        // TODO: only if intra-bb-antideps enabled?
//        static_cast<DataDependenceGraph*>(ddg().rootGraph())->
//            updateRegWrite(mnd, newReg, *bb_);
    }
 
    // for reading.
    for (auto i: liveRange_->reads) {
        MoveNodeUse mnd(*i);
        bb_->liveRangeData_->regFirstUses_[newReg_].erase(mnd);
    }
 
    // for guards.
    for (auto i: liveRange_->guards) {
        MoveNodeUse mnd(*i, true);
        bb_->liveRangeData_->regFirstUses_[newReg_].erase(mnd);
    }
}

References bb_, liveRange_, TTAProgram::BasicBlock::liveRangeData_, newReg_, LiveRangeData::regFirstDefines_, and LiveRangeData::regFirstUses_.

Referenced by undoOnlyMe().

undoSetRegDefsAndLastUses()

void BFRenameLiveRange::undoSetRegDefsAndLastUses ( )

protected

Definition at line 243 of file BFRenameLiveRange.cc.

                                                  {
    // for writing.
    for (auto i: liveRange_->writes) {
        MoveNodeUse mnd(*i);
        bb_->liveRangeData_->regDefines_[newReg_].erase(mnd);
    }
 
    // for reading.
    for (auto i: liveRange_->reads) {
        MoveNodeUse mnd(*i);
        bb_->liveRangeData_->regLastUses_[newReg_].erase(mnd);
    }
 
    // for reading.
    for (auto i: liveRange_->guards) {
        MoveNodeUse mnd(*i, true);
        bb_->liveRangeData_->regLastUses_[newReg_].erase(mnd);
    }
}

References bb_, liveRange_, TTAProgram::BasicBlock::liveRangeData_, newReg_, LiveRangeData::regDefines_, and LiveRangeData::regLastUses_.

Referenced by undoOnlyMe().

undoSetTerminal()

void BFRenameLiveRange::undoSetTerminal ( )

protected

Definition at line 136 of file BFRenameLiveRange.cc.

                                        {
 
    // for writes.
    for (auto i: liveRange_->writes) {
        TTAProgram::Move& move = i->move();
        move.setDestination(oldReg_->copy());
    }
 
    // for reads.
    for (auto i: liveRange_->reads) {
        TTAProgram::Move& move = i->move();
        move.setSource(oldReg_->copy());
    }
 
    // for guards
    for (auto i: liveRange_->guards) {
        TTAProgram::Move& move = i->move();
        setGuard(move, oldReg_->registerFile(), oldReg_->index());
    }
 
}

References TTAProgram::Terminal::copy(), TTAProgram::Terminal::index(), liveRange_, oldReg_, TTAProgram::Terminal::registerFile(), TTAProgram::Move::setDestination(), setGuard(), and TTAProgram::Move::setSource().

Referenced by undoOnlyMe().

Here is the call graph for this function:

unsetIncomingDeps()

void BFRenameLiveRange::unsetIncomingDeps ( )

protected

Definition at line 196 of file BFRenameLiveRange.cc.

                                          {
    bb_->liveRangeData_->regKills_[newReg_].first = oldKill_;
    bb_->liveRangeData_->regFirstDefines_[newReg_] = oldRegFirstDefines_;
    bb_->liveRangeData_->regFirstUses_[newReg_] = oldRegFirstUses_;
}

References bb_, TTAProgram::BasicBlock::liveRangeData_, newReg_, oldKill_, oldRegFirstDefines_, oldRegFirstUses_, LiveRangeData::regFirstDefines_, LiveRangeData::regFirstUses_, and LiveRangeData::regKills_.

Referenced by undoOnlyMe().

unsetOutgoingDeps()

void BFRenameLiveRange::unsetOutgoingDeps ( )

protected

Definition at line 202 of file BFRenameLiveRange.cc.

                                          {
    bb_->liveRangeData_->regLastKills_[newReg_].first = oldLastKill_;
    bb_->liveRangeData_->regDefines_[newReg_] = oldRegDefines_;
}

References bb_, TTAProgram::BasicBlock::liveRangeData_, newReg_, oldLastKill_, oldRegDefines_, LiveRangeData::regDefines_, and LiveRangeData::regLastKills_.

Referenced by undoOnlyMe().

Member Data Documentation

bb_

TTAProgram::BasicBlock* BFRenameLiveRange::bb_

protected

Definition at line 87 of file BFRenameLiveRange.hh.

Referenced by operator()(), renameLiveRange(), setFirstDefsAndUses(), setIncomingDeps(), setOutgoingDeps(), setRegDefsAndLastUses(), undoSetFirstDefsAndUses(), undoSetRegDefsAndLastUses(), unsetIncomingDeps(), and unsetOutgoingDeps().

createdAntidepEdges_

DataDependenceGraph::EdgeSet BFRenameLiveRange::createdAntidepEdges_

protected

Definition at line 97 of file BFRenameLiveRange.hh.

Referenced by renameLiveRange(), and undoNewAntiDeps().

liveRange_

std::shared_ptr<LiveRange> BFRenameLiveRange::liveRange_

protected

Definition at line 86 of file BFRenameLiveRange.hh.

Referenced by notifySelector(), operator()(), renameLiveRange(), setFirstDefsAndUses(), setIncomingDeps(), setOutgoingDeps(), setRegDefsAndLastUses(), setTerminals(), undoSetFirstDefsAndUses(), undoSetRegDefsAndLastUses(), and undoSetTerminal().

newReg_

TCEString BFRenameLiveRange::newReg_

protected

Definition at line 88 of file BFRenameLiveRange.hh.

Referenced by renameLiveRange(), setFirstDefsAndUses(), setIncomingDeps(), setOutgoingDeps(), setRegDefsAndLastUses(), setTerminals(), undoOnlyMe(), undoSetFirstDefsAndUses(), undoSetRegDefsAndLastUses(), unsetIncomingDeps(), and unsetOutgoingDeps().

oldKill_

MoveNodeUse BFRenameLiveRange::oldKill_

protected

Definition at line 91 of file BFRenameLiveRange.hh.

Referenced by setIncomingDeps(), and unsetIncomingDeps().

oldLastKill_

MoveNodeUse BFRenameLiveRange::oldLastKill_

protected

Definition at line 90 of file BFRenameLiveRange.hh.

Referenced by setOutgoingDeps(), and unsetOutgoingDeps().

oldReg_

class TTAProgram::Terminal* BFRenameLiveRange::oldReg_

protected

Definition at line 85 of file BFRenameLiveRange.hh.

Referenced by renameLiveRange(), undoSetTerminal(), and ~BFRenameLiveRange().

oldRegDefines_

LiveRangeData::MoveNodeUseSet BFRenameLiveRange::oldRegDefines_

protected

Definition at line 94 of file BFRenameLiveRange.hh.

Referenced by setOutgoingDeps(), and unsetOutgoingDeps().

oldRegFirstDefines_

LiveRangeData::MoveNodeUseSet BFRenameLiveRange::oldRegFirstDefines_

protected

Definition at line 95 of file BFRenameLiveRange.hh.

Referenced by setIncomingDeps(), and unsetIncomingDeps().

oldRegFirstUses_

LiveRangeData::MoveNodeUseSet BFRenameLiveRange::oldRegFirstUses_

protected

Definition at line 96 of file BFRenameLiveRange.hh.

Referenced by setIncomingDeps(), and unsetIncomingDeps().

targetCycle_

int BFRenameLiveRange::targetCycle_

protected

Definition at line 92 of file BFRenameLiveRange.hh.

Referenced by operator()().

undoReadUpdateData_

std::map<const MoveNode*, DataDependenceGraph::UndoData, MoveNode::Comparator> BFRenameLiveRange::undoReadUpdateData_

protected

Definition at line 83 of file BFRenameLiveRange.hh.

Referenced by renameLiveRange(), and undoOnlyMe().

undoWriteUpdateData_

DataDependenceGraph::UndoData BFRenameLiveRange::undoWriteUpdateData_

protected

Definition at line 79 of file BFRenameLiveRange.hh.

Referenced by renameLiveRange(), and undoOnlyMe().

---

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

• BFRenameLiveRange.hh
• BFRenameLiveRange.cc