Use higher level method

[oota-llvm.git] / lib / Target / SparcV9 / RegAlloc / InterferenceGraph.cpp

diff --git a/lib/Target/SparcV9/RegAlloc/InterferenceGraph.cpp b/lib/Target/SparcV9/RegAlloc/InterferenceGraph.cpp
index a366c117109b69ac7477fe40ab4ddb6492fc80b8..d18fddacabd44b318493fb2db08bb21a0884be8a 100644 (file)
--- a/lib/Target/SparcV9/RegAlloc/InterferenceGraph.cpp
+++ b/lib/Target/SparcV9/RegAlloc/InterferenceGraph.cpp
@@ -1,9 +1,22 @@
+//===-- InterferenceGraph.cpp ---------------------------------------------===//
+// 
+//  Interference graph for coloring-based register allocation for LLVM.
+// 
+//===----------------------------------------------------------------------===//
+
 #include "llvm/CodeGen/InterferenceGraph.h"
+#include "llvm/CodeGen/IGNode.h"
+#include "llvm/CodeGen/RegAllocCommon.h"
 #include "Support/STLExtras.h"
-#include <iostream>
 #include <algorithm>
 using std::cerr;
 
+// for asserting this IG node is infact in the IGNodeList of this class
+inline static void assertIGNode(const InterferenceGraph *IG,
+                                const IGNode *Node) {
+  assert(IG->getIGNodeList()[Node->getIndex()] == Node);
+}
+
 //-----------------------------------------------------------------------------
 // Constructor: Records the RegClass and initalizes IGNodeList.
 // The matrix is NOT yet created by the constructor. Call createGraph() 
@@ -14,7 +27,7 @@ InterferenceGraph::InterferenceGraph(RegClass *const RC) : RegCl(RC),
 {   
   IG = NULL;         
   Size = 0;            
-  if( DEBUG_RA) {
+  if( DEBUG_RA >= RA_DEBUG_Interference) {
     cerr << "Interference graph created!\n";
   }
 }
@@ -73,20 +86,18 @@ void InterferenceGraph::setInterference(const LiveRange *const LR1,
                                        const LiveRange *const LR2 ) {
   assert(LR1 != LR2);   
 
-  IGNode *const IGNode1 = LR1->getUserIGNode();
-  IGNode *const IGNode2 = LR2->getUserIGNode();
+  IGNode *IGNode1 = LR1->getUserIGNode();
+  IGNode *IGNode2 = LR2->getUserIGNode();
 
-  if( DEBUG_RA) {
-    assertIGNode( IGNode1 );   
-    assertIGNode( IGNode2 );
-  }
+  assertIGNode(this, IGNode1);   
+  assertIGNode(this, IGNode2);
   
-  const unsigned int row = IGNode1->getIndex();
-  const unsigned int col = IGNode2->getIndex();
+  unsigned row = IGNode1->getIndex();
+  unsigned col = IGNode2->getIndex();
 
   char *val;
 
-  if( DEBUG_RA > 1) 
+  if( DEBUG_RA >= RA_DEBUG_Interference) 
     cerr << "setting intf for: [" << row << "][" <<  col << "]\n"; 
 
   ( row > col) ?  val = &IG[row][col]: val = &IG[col][row]; 
@@ -107,11 +118,8 @@ unsigned InterferenceGraph::getInterference(const LiveRange *const LR1,
                                           const LiveRange *const LR2 ) const {
 
   assert(LR1 != LR2);
-
-  if( DEBUG_RA) {
-    assertIGNode( LR1->getUserIGNode() );  
-    assertIGNode( LR2->getUserIGNode() );
-  }
+  assertIGNode(this, LR1->getUserIGNode());  
+  assertIGNode(this, LR2->getUserIGNode());
 
   const unsigned int row = LR1->getUserIGNode()->getIndex();
   const unsigned int col = LR2->getUserIGNode()->getIndex();
@@ -133,20 +141,20 @@ unsigned InterferenceGraph::getInterference(const LiveRange *const LR1,
 //            LiveRangeInfo::unionAndUpdateLRs for that purpose.
 //----------------------------------------------------------------------------
 
-void InterferenceGraph::mergeIGNodesOfLRs(const LiveRange *const LR1, 
-                                         LiveRange *const LR2 ) {
+void InterferenceGraph::mergeIGNodesOfLRs(const LiveRange *LR1, 
+                                         LiveRange *LR2) {
 
   assert( LR1 != LR2);                  // cannot merge the same live range
 
   IGNode *const DestNode = LR1->getUserIGNode();
   IGNode *SrcNode = LR2->getUserIGNode();
 
-  assertIGNode( DestNode );
-  assertIGNode( SrcNode );
+  assertIGNode(this, DestNode);
+  assertIGNode(this, SrcNode);
 
-  if( DEBUG_RA > 1) {
-    cerr << "Merging LRs: \""; LR1->printSet(); 
-    cerr << "\" and \""; LR2->printSet();
+  if( DEBUG_RA >= RA_DEBUG_Interference) {
+    cerr << "Merging LRs: \""; printSet(*LR1); 
+    cerr << "\" and \""; printSet(*LR2);
     cerr << "\"\n";
   }
 
@@ -236,7 +244,7 @@ void InterferenceGraph::printIGNodeList() const
 
     if (Node) {
       cerr << " [" << Node->getIndex() << "] ";
-      Node->getParentLR()->printSet(); 
+      printSet(*Node->getParentLR());
       //int Deg = Node->getCurDegree();
       cerr << "\t <# of Neighs: " << Node->getNumOfNeighbors() << ">\n";
     }