mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-10-11 23:25:15 +00:00
b6489f3153
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@8148 91177308-0d34-0410-b5e6-96231b3b80d8
238 lines
5.3 KiB
C++
238 lines
5.3 KiB
C++
#include "llvm/CodeGen/SchedGraphCommon.h"
|
|
#include "Support/STLExtras.h"
|
|
|
|
class SchedGraphCommon;
|
|
|
|
//
|
|
// class SchedGraphEdge
|
|
//
|
|
|
|
/*ctor*/
|
|
SchedGraphEdge::SchedGraphEdge(SchedGraphNodeCommon* _src,
|
|
SchedGraphNodeCommon* _sink,
|
|
SchedGraphEdgeDepType _depType,
|
|
unsigned int _depOrderType,
|
|
int _minDelay)
|
|
: src(_src),
|
|
sink(_sink),
|
|
depType(_depType),
|
|
depOrderType(_depOrderType),
|
|
minDelay((_minDelay >= 0)? _minDelay : _src->getLatency()),
|
|
val(NULL)
|
|
{
|
|
iteDiff=0;
|
|
assert(src != sink && "Self-loop in scheduling graph!");
|
|
src->addOutEdge(this);
|
|
sink->addInEdge(this);
|
|
}
|
|
|
|
|
|
/*ctor*/
|
|
SchedGraphEdge::SchedGraphEdge(SchedGraphNodeCommon* _src,
|
|
SchedGraphNodeCommon* _sink,
|
|
const Value* _val,
|
|
unsigned int _depOrderType,
|
|
int _minDelay)
|
|
: src(_src),
|
|
sink(_sink),
|
|
depType(ValueDep),
|
|
depOrderType(_depOrderType),
|
|
minDelay((_minDelay >= 0)? _minDelay : _src->getLatency()),
|
|
val(_val)
|
|
{
|
|
iteDiff=0;
|
|
assert(src != sink && "Self-loop in scheduling graph!");
|
|
src->addOutEdge(this);
|
|
sink->addInEdge(this);
|
|
}
|
|
|
|
|
|
/*ctor*/
|
|
SchedGraphEdge::SchedGraphEdge(SchedGraphNodeCommon* _src,
|
|
SchedGraphNodeCommon* _sink,
|
|
unsigned int _regNum,
|
|
unsigned int _depOrderType,
|
|
int _minDelay)
|
|
: src(_src),
|
|
sink(_sink),
|
|
depType(MachineRegister),
|
|
depOrderType(_depOrderType),
|
|
minDelay((_minDelay >= 0)? _minDelay : _src->getLatency()),
|
|
machineRegNum(_regNum)
|
|
{
|
|
iteDiff=0;
|
|
assert(src != sink && "Self-loop in scheduling graph!");
|
|
src->addOutEdge(this);
|
|
sink->addInEdge(this);
|
|
}
|
|
|
|
|
|
/*ctor*/
|
|
SchedGraphEdge::SchedGraphEdge(SchedGraphNodeCommon* _src,
|
|
SchedGraphNodeCommon* _sink,
|
|
ResourceId _resourceId,
|
|
int _minDelay)
|
|
: src(_src),
|
|
sink(_sink),
|
|
depType(MachineResource),
|
|
depOrderType(NonDataDep),
|
|
minDelay((_minDelay >= 0)? _minDelay : _src->getLatency()),
|
|
resourceId(_resourceId)
|
|
{
|
|
iteDiff=0;
|
|
assert(src != sink && "Self-loop in scheduling graph!");
|
|
src->addOutEdge(this);
|
|
sink->addInEdge(this);
|
|
}
|
|
|
|
/*dtor*/
|
|
SchedGraphEdge::~SchedGraphEdge()
|
|
{
|
|
}
|
|
|
|
void SchedGraphEdge::dump(int indent) const {
|
|
std::cerr << std::string(indent*2, ' ') << *this;
|
|
}
|
|
|
|
|
|
|
|
/*ctor*/
|
|
|
|
SchedGraphNodeCommon::SchedGraphNodeCommon(unsigned _nodeId)
|
|
:ID(_nodeId),
|
|
latency(0){
|
|
|
|
}
|
|
|
|
/*dtor*/
|
|
SchedGraphNodeCommon::~SchedGraphNodeCommon()
|
|
{
|
|
// for each node, delete its out-edges
|
|
std::for_each(beginOutEdges(), endOutEdges(),
|
|
deleter<SchedGraphEdge>);
|
|
}
|
|
|
|
|
|
void SchedGraphNodeCommon::dump(int indent) const {
|
|
std::cerr << std::string(indent*2, ' ') << *this;
|
|
}
|
|
|
|
|
|
inline void
|
|
SchedGraphNodeCommon::addInEdge(SchedGraphEdge* edge)
|
|
{
|
|
inEdges.push_back(edge);
|
|
}
|
|
|
|
|
|
inline void
|
|
SchedGraphNodeCommon::addOutEdge(SchedGraphEdge* edge)
|
|
{
|
|
outEdges.push_back(edge);
|
|
}
|
|
|
|
inline void
|
|
SchedGraphNodeCommon::removeInEdge(const SchedGraphEdge* edge)
|
|
{
|
|
assert(edge->getSink() == this);
|
|
|
|
for (iterator I = beginInEdges(); I != endInEdges(); ++I)
|
|
if ((*I) == edge)
|
|
{
|
|
inEdges.erase(I);
|
|
break;
|
|
}
|
|
}
|
|
|
|
inline void
|
|
SchedGraphNodeCommon::removeOutEdge(const SchedGraphEdge* edge)
|
|
{
|
|
assert(edge->getSrc() == this);
|
|
|
|
for (iterator I = beginOutEdges(); I != endOutEdges(); ++I)
|
|
if ((*I) == edge)
|
|
{
|
|
outEdges.erase(I);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
//class SchedGraphCommon
|
|
|
|
/*ctor*/
|
|
SchedGraphCommon::SchedGraphCommon()
|
|
{
|
|
}
|
|
|
|
|
|
/*dtor*/
|
|
SchedGraphCommon::~SchedGraphCommon()
|
|
{
|
|
|
|
delete graphRoot;
|
|
delete graphLeaf;
|
|
}
|
|
|
|
|
|
void
|
|
SchedGraphCommon::eraseIncomingEdges(SchedGraphNodeCommon* node, bool addDummyEdges)
|
|
{
|
|
// Delete and disconnect all in-edges for the node
|
|
for (SchedGraphNodeCommon::iterator I = node->beginInEdges();
|
|
I != node->endInEdges(); ++I)
|
|
{
|
|
SchedGraphNodeCommon* srcNode = (*I)->getSrc();
|
|
srcNode->removeOutEdge(*I);
|
|
delete *I;
|
|
|
|
if (addDummyEdges &&
|
|
srcNode != getRoot() &&
|
|
srcNode->beginOutEdges() == srcNode->endOutEdges())
|
|
{ // srcNode has no more out edges, so add an edge to dummy EXIT node
|
|
assert(node != getLeaf() && "Adding edge that was just removed?");
|
|
(void) new SchedGraphEdge(srcNode, getLeaf(),
|
|
SchedGraphEdge::CtrlDep, SchedGraphEdge::NonDataDep, 0);
|
|
}
|
|
}
|
|
|
|
node->inEdges.clear();
|
|
}
|
|
|
|
void
|
|
SchedGraphCommon::eraseOutgoingEdges(SchedGraphNodeCommon* node, bool addDummyEdges)
|
|
{
|
|
// Delete and disconnect all out-edges for the node
|
|
for (SchedGraphNodeCommon::iterator I = node->beginOutEdges();
|
|
I != node->endOutEdges(); ++I)
|
|
{
|
|
SchedGraphNodeCommon* sinkNode = (*I)->getSink();
|
|
sinkNode->removeInEdge(*I);
|
|
delete *I;
|
|
|
|
if (addDummyEdges &&
|
|
sinkNode != getLeaf() &&
|
|
sinkNode->beginInEdges() == sinkNode->endInEdges())
|
|
{ //sinkNode has no more in edges, so add an edge from dummy ENTRY node
|
|
assert(node != getRoot() && "Adding edge that was just removed?");
|
|
(void) new SchedGraphEdge(getRoot(), sinkNode,
|
|
SchedGraphEdge::CtrlDep, SchedGraphEdge::NonDataDep, 0);
|
|
}
|
|
}
|
|
|
|
node->outEdges.clear();
|
|
}
|
|
|
|
void
|
|
SchedGraphCommon::eraseIncidentEdges(SchedGraphNodeCommon* node, bool addDummyEdges)
|
|
{
|
|
this->eraseIncomingEdges(node, addDummyEdges);
|
|
this->eraseOutgoingEdges(node, addDummyEdges);
|
|
}
|
|
|
|
std::ostream &operator<<(std::ostream &os, const SchedGraphNodeCommon& node)
|
|
{
|
|
|
|
return os;
|
|
}
|