Eliminate 'BasicNode' from InstrForest.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@551 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 30 insertions, 60 deletions

diff --git a/lib/CodeGen/InstrSelection/InstrForest.cpp b/lib/CodeGen/InstrSelection/InstrForest.cpp
index 181c1a1d43..1ff4c881f7 100644
--- a/lib/CodeGen/InstrSelection/InstrForest.cpp
+++ b/lib/CodeGen/InstrSelection/InstrForest.cpp
@@ -38,23 +38,16 @@
 //------------------------------------------------------------------------ 
 
 
-InstrTreeNode::InstrTreeNode(InstrTreeNodeType nodeType,
-			     Value* _val)
-  : treeNodeType(nodeType),
-    val(_val)
-{
-  basicNode.leftChild = NULL;
-  basicNode.rightChild = NULL;
-  basicNode.parent = NULL;
-  basicNode.opLabel = InvalidOp;
-  basicNode.treeNodePtr = this;
+InstrTreeNode::InstrTreeNode(InstrTreeNodeType nodeType, Value* _val)
+  : treeNodeType(nodeType), val(_val) {
+  LeftChild   = 0;
+  RightChild  = 0;
+  Parent      = 0;
+  opLabel     = InvalidOp;
 }
 
-void
-InstrTreeNode::dump(int dumpChildren,
-		    int indent) const
-{
-  this->dumpNode(indent);
+void InstrTreeNode::dump(int dumpChildren, int indent) const {
+  dumpNode(indent);
   
   if (dumpChildren)
     {
@@ -122,7 +115,7 @@ InstructionNode::InstructionNode(Instruction* _instr)
 	}
     }
   
-  basicNode.opLabel = opLabel;
+  this->opLabel = opLabel;
 }
 
 
@@ -148,10 +141,8 @@ InstructionNode::dumpNode(int indent) const
 }
 
 
-VRegListNode::VRegListNode()
-  : InstrTreeNode(NTVRegListNode, NULL)
-{
-  basicNode.opLabel = VRegListOp;
+VRegListNode::VRegListNode() : InstrTreeNode(NTVRegListNode, 0) {
+  opLabel = VRegListOp;
 }
 
 void
@@ -164,10 +155,8 @@ VRegListNode::dumpNode(int indent) const
 }
 
 
-VRegNode::VRegNode(Value* _val)
-  : InstrTreeNode(NTVRegNode, _val)
-{
-  basicNode.opLabel = VRegNodeOp;
+VRegNode::VRegNode(Value* _val) : InstrTreeNode(NTVRegNode, _val) {
+  opLabel = VRegNodeOp;
 }
 
 void
@@ -181,10 +170,9 @@ VRegNode::dumpNode(int indent) const
 }
 
 
-ConstantNode::ConstantNode(ConstPoolVal* constVal)
-  : InstrTreeNode(NTConstNode, constVal)
-{
-  basicNode.opLabel = ConstantNodeOp;
+ConstantNode::ConstantNode(ConstPoolVal *constVal)
+  : InstrTreeNode(NTConstNode, constVal) {
+  opLabel = ConstantNodeOp;
 }
 
 void
@@ -198,10 +186,8 @@ ConstantNode::dumpNode(int indent) const
 }
 
 
-LabelNode::LabelNode(BasicBlock* _bblock)
-  : InstrTreeNode(NTLabelNode, _bblock)
-{
-  basicNode.opLabel = LabelNodeOp;
+LabelNode::LabelNode(BasicBlock *BB) : InstrTreeNode(NTLabelNode, BB) {
+  opLabel = LabelNodeOp;
 }
 
 void
@@ -255,10 +241,9 @@ InstrForest::noteTreeNodeForInstr(Instruction* instr,
 
 
 inline void
-InstrForest::setLeftChild(InstrTreeNode* parent, InstrTreeNode* child)
-{
-  parent->basicNode.leftChild = & child->basicNode;
-  child->basicNode.parent = & parent->basicNode;
+InstrForest::setLeftChild(InstrTreeNode* parent, InstrTreeNode* child) {
+  parent->LeftChild = child;
+  child->Parent = parent;
   if (child->getNodeType() == InstrTreeNode::NTInstructionNode)
     treeRoots.erase((InstructionNode*) child);	// no longer a tree root
 }
@@ -267,8 +252,8 @@ InstrForest::setLeftChild(InstrTreeNode* parent, InstrTreeNode* child)
 inline void
 InstrForest::setRightChild(InstrTreeNode* parent, InstrTreeNode* child)
 {
-  parent->basicNode.rightChild = & child->basicNode;
-  child->basicNode.parent = & parent->basicNode;
+  parent->RightChild = child;
+  child->Parent = parent;
   if (child->getNodeType() == InstrTreeNode::NTInstructionNode)
     treeRoots.erase((InstructionNode*) child);	// no longer a tree root
 }
diff --git a/lib/CodeGen/InstrSelection/InstrSelection.cpp b/lib/CodeGen/InstrSelection/InstrSelection.cpp
index e6884ab572..675e489e46 100644
--- a/lib/CodeGen/InstrSelection/InstrSelection.cpp
+++ b/lib/CodeGen/InstrSelection/InstrSelection.cpp
@@ -10,30 +10,19 @@
 //**************************************************************************/
 
 
-//************************** System Include Files ***************************/
-
-
-//*************************** User Include Files ***************************/
-
 #include "llvm/CodeGen/InstrSelection.h"
+#include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Type.h"
 #include "llvm/iMemory.h"
 #include "llvm/Instruction.h"
 #include "llvm/BasicBlock.h"
 #include "llvm/Method.h"
-#include "llvm/CodeGen/MachineInstr.h"
 
-
-//************************* Forward Declarations ***************************/
-
-static bool SelectInstructionsForTree(BasicTreeNode* treeRoot,
-				      int goalnt,
+static bool SelectInstructionsForTree(InstrTreeNode* treeRoot, int goalnt,
 				      TargetMachine &Target);
 
 
-//************************* Internal Data Types *****************************/
-
 enum SelectDebugLevel_t {
   Select_NoDebugInfo,
   Select_PrintMachineCode, 
@@ -50,8 +39,6 @@ cl::Enum<enum SelectDebugLevel_t> SelectDebugLevel("dselect", cl::NoFlags, // cl
    clEnumValN(Select_DebugBurgTrees,   "b", "print burg trees"), 0);
 
 
-//************************** External Functions ****************************/
-
 
 //---------------------------------------------------------------------------
 // Entry point for instruction selection using BURG.
@@ -87,7 +74,7 @@ SelectInstructionsForMethod(Method* method,
        treeRootIter != treeRoots.end();
        ++treeRootIter)
     {
-      BasicTreeNode* basicNode = (*treeRootIter)->getBasicNode();
+      InstrTreeNode* basicNode = *treeRootIter;
       
       // Invoke BURM to label each tree node with a state
       (void) burm_label(basicNode);
@@ -192,8 +179,7 @@ FoldGetElemChain(const InstructionNode* getElemInstrNode,
 //---------------------------------------------------------------------------
 
 bool
-SelectInstructionsForTree(BasicTreeNode* treeRoot,
-			  int goalnt,
+SelectInstructionsForTree(InstrTreeNode* treeRoot, int goalnt,
 			  TargetMachine &Target)
 {
   // Use a static vector to avoid allocating a new one per VM instruction
@@ -220,7 +206,7 @@ SelectInstructionsForTree(BasicTreeNode* treeRoot,
   // 
   if (treeRoot->opLabel != VRegListOp)
     {
-      InstructionNode* instrNode = (InstructionNode*)treeRoot->treeNodePtr;
+      InstructionNode* instrNode = (InstructionNode*)treeRoot;
       assert(instrNode->getNodeType() == InstrTreeNode::NTInstructionNode);
       
       unsigned N = GetInstructionsByRule(instrNode, ruleForNode, nts, Target,
@@ -238,7 +224,7 @@ SelectInstructionsForTree(BasicTreeNode* treeRoot,
   if (nts[0])
     { // i.e., there is at least one kid
 
-      BasicTreeNode* kids[2];
+      InstrTreeNode* kids[2];
       int currentRule = ruleForNode;
       burm_kids(treeRoot, currentRule, kids);
       
@@ -258,8 +244,7 @@ SelectInstructionsForTree(BasicTreeNode* treeRoot,
       for (int i = 0; nts[i]; i++)
 	{
 	  assert(i < 2);
-	  InstrTreeNode::InstrTreeNodeType
-	    nodeType = kids[i]->treeNodePtr->getNodeType();
+	  InstrTreeNode::InstrTreeNodeType nodeType = kids[i]->getNodeType();
 	  if (nodeType == InstrTreeNode::NTVRegListNode ||
 	      nodeType == InstrTreeNode::NTInstructionNode)
 	    {