diff --git a/llvm/lib/CodeGen/InstrSched/SchedGraphCommon.cpp b/llvm/lib/CodeGen/InstrSched/SchedGraphCommon.cpp
index 287a679..ec0e0952 100644
--- a/llvm/lib/CodeGen/InstrSched/SchedGraphCommon.cpp
+++ b/llvm/lib/CodeGen/InstrSched/SchedGraphCommon.cpp
@@ -1,109 +1,80 @@
+//===- SchedGraphCommon.cpp - Scheduling Graphs Base Class- ---------------===//
+//
+// Scheduling graph base class that contains common information for SchedGraph
+// and ModuloSchedGraph scheduling graphs.
+//
+//===----------------------------------------------------------------------===//
+
 #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)
-{
+  : 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)
-{
+  : 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),
+  : src(_src), sink(_sink), depType(MachineRegister),
     depOrderType(_depOrderType),
     minDelay((_minDelay >= 0)? _minDelay : _src->getLatency()),
-    machineRegNum(_regNum)
-{
+    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),
+  : src(_src), sink(_sink), depType(MachineResource), depOrderType(NonDataDep),
     minDelay((_minDelay >= 0)? _minDelay : _src->getLatency()),
-    resourceId(_resourceId)
-{
+    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()
 {
@@ -112,126 +83,88 @@
                 deleter<SchedGraphEdge>);
 }
 
+void SchedGraphNodeCommon::removeInEdge(const SchedGraphEdge* edge) {
+  assert(edge->getSink() == this);
+  
+  for (iterator I = beginInEdges(); I != endInEdges(); ++I)
+    if ((*I) == edge) {
+      inEdges.erase(I);
+      break;
+    }
+}
+
+void SchedGraphNodeCommon::removeOutEdge(const SchedGraphEdge* edge) {
+  assert(edge->getSrc() == this);
+  
+  for (iterator I = beginOutEdges(); I != endOutEdges(); ++I)
+    if ((*I) == edge) {
+      outEdges.erase(I);
+      break;
+    }
+}
 
 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()
-{
-
+SchedGraphCommon::~SchedGraphCommon() {
   delete graphRoot;
   delete graphLeaf;
 }
 
 
-void
-SchedGraphCommon::eraseIncomingEdges(SchedGraphNodeCommon* node, bool addDummyEdges)
-{
+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;
+       I != node->endInEdges(); ++I) {
+    SchedGraphNodeCommon* srcNode = (*I)->getSrc();
+    srcNode->removeOutEdge(*I);
+    delete *I;
+    
+    if (addDummyEdges && srcNode != getRoot() &&
+	srcNode->beginOutEdges() == srcNode->endOutEdges()) { 
       
-      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);
-	}
+      // 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)
-{
+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;
+       I != node->endOutEdges(); ++I) {
+    SchedGraphNodeCommon* sinkNode = (*I)->getSink();
+    sinkNode->removeInEdge(*I);
+    delete *I;
+    
+    if (addDummyEdges &&
+	sinkNode != getLeaf() &&
+	sinkNode->beginInEdges() == sinkNode->endInEdges()) {
       
-      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);
-	}
+      //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)
-{
+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;
-}