First version of SchedGraph common class and refactoring of SchedGraph.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@8148 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/CodeGen/InstrSched/SchedGraphCommon.cpp b/lib/CodeGen/InstrSched/SchedGraphCommon.cpp
new file mode 100644
index 0000000..287a679
--- /dev/null
+++ b/lib/CodeGen/InstrSched/SchedGraphCommon.cpp
@@ -0,0 +1,237 @@
+#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;
+}