Make code layout more consistent.

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

1 files changed, 130 insertions, 174 deletions

diff --git a/lib/CodeGen/InstrSelection/InstrForest.cpp b/lib/CodeGen/InstrSelection/InstrForest.cpp
index 90993b7a8d..5496502d5e 100644
--- a/lib/CodeGen/InstrSelection/InstrForest.cpp
+++ b/lib/CodeGen/InstrSelection/InstrForest.cpp
@@ -19,13 +19,13 @@
 // 
 //===----------------------------------------------------------------------===//
 
-#include "llvm/CodeGen/InstrForest.h"
-#include "llvm/CodeGen/MachineCodeForInstruction.h"
+#include "llvm/Constant.h"
 #include "llvm/Function.h"
 #include "llvm/iTerminators.h"
 #include "llvm/iMemory.h"
-#include "llvm/Constant.h"
 #include "llvm/Type.h"
+#include "llvm/CodeGen/InstrForest.h"
+#include "llvm/CodeGen/MachineCodeForInstruction.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "Support/STLExtras.h"
 #include "Config/alloca.h"
@@ -35,102 +35,82 @@
 //------------------------------------------------------------------------ 
 
 void
-InstrTreeNode::dump(int dumpChildren, int indent) const
-{
+InstrTreeNode::dump(int dumpChildren, int indent) const {
   dumpNode(indent);
   
-  if (dumpChildren)
-    {
-      if (LeftChild)
-	LeftChild->dump(dumpChildren, indent+1);
-      if (RightChild)
-	RightChild->dump(dumpChildren, indent+1);
-    }
+  if (dumpChildren) {
+    if (LeftChild)
+      LeftChild->dump(dumpChildren, indent+1);
+    if (RightChild)
+      RightChild->dump(dumpChildren, indent+1);
+  }
 }
 
 
 InstructionNode::InstructionNode(Instruction* I)
-  : InstrTreeNode(NTInstructionNode, I),
-    codeIsFoldedIntoParent(false)
+  : InstrTreeNode(NTInstructionNode, I), codeIsFoldedIntoParent(false)
 {
   opLabel = I->getOpcode();
 
   // Distinguish special cases of some instructions such as Ret and Br
   // 
-  if (opLabel == Instruction::Ret && cast<ReturnInst>(I)->getReturnValue())
-    {
-      opLabel = RetValueOp;              	 // ret(value) operation
-    }
+  if (opLabel == Instruction::Ret && cast<ReturnInst>(I)->getReturnValue()) {
+    opLabel = RetValueOp;              	 // ret(value) operation
+  }
   else if (opLabel ==Instruction::Br && !cast<BranchInst>(I)->isUnconditional())
+  {
+    opLabel = BrCondOp;		// br(cond) operation
+  } else if (opLabel >= Instruction::SetEQ && opLabel <= Instruction::SetGT) {
+    opLabel = SetCCOp;		// common label for all SetCC ops
+  } else if (opLabel == Instruction::Alloca && I->getNumOperands() > 0) {
+    opLabel = AllocaN;		 // Alloca(ptr, N) operation
+  } else if (opLabel == Instruction::GetElementPtr &&
+             cast<GetElementPtrInst>(I)->hasIndices()) {
+    opLabel = opLabel + 100;		 // getElem with index vector
+  } else if (opLabel == Instruction::Xor &&
+             BinaryOperator::isNot(I)) {
+    opLabel = (I->getType() == Type::BoolTy)?  NotOp  // boolean Not operator
+      : BNotOp; // bitwise Not operator
+  } else if (opLabel == Instruction::And || opLabel == Instruction::Or ||
+             opLabel == Instruction::Xor) {
+    // Distinguish bitwise operators from logical operators!
+    if (I->getType() != Type::BoolTy)
+      opLabel = opLabel + 100;	 // bitwise operator
+  } else if (opLabel == Instruction::Cast) {
+    const Type *ITy = I->getType();
+    switch(ITy->getPrimitiveID())
     {
-      opLabel = BrCondOp;		// br(cond) operation
-    }
-  else if (opLabel >= Instruction::SetEQ && opLabel <= Instruction::SetGT)
-    {
-      opLabel = SetCCOp;		// common label for all SetCC ops
-    }
-  else if (opLabel == Instruction::Alloca && I->getNumOperands() > 0)
-    {
-      opLabel = AllocaN;		 // Alloca(ptr, N) operation
-    }
-  else if (opLabel == Instruction::GetElementPtr &&
-	   cast<GetElementPtrInst>(I)->hasIndices())
-    {
-      opLabel = opLabel + 100;		 // getElem with index vector
-    }
-  else if (opLabel == Instruction::Xor &&
-           BinaryOperator::isNot(I))
-    {
-      opLabel = (I->getType() == Type::BoolTy)?  NotOp  // boolean Not operator
-                                              : BNotOp; // bitwise Not operator
-    }
-  else if (opLabel == Instruction::And ||
-           opLabel == Instruction::Or ||
-           opLabel == Instruction::Xor)
-    {
-      // Distinguish bitwise operators from logical operators!
-      if (I->getType() != Type::BoolTy)
-        opLabel = opLabel + 100;	 // bitwise operator
-    }
-  else if (opLabel == Instruction::Cast)
-    {
-      const Type *ITy = I->getType();
-      switch(ITy->getPrimitiveID())
-	{
-	case Type::BoolTyID:    opLabel = ToBoolTy;    break;
-	case Type::UByteTyID:   opLabel = ToUByteTy;   break;
-	case Type::SByteTyID:   opLabel = ToSByteTy;   break;
-	case Type::UShortTyID:  opLabel = ToUShortTy;  break;
-	case Type::ShortTyID:   opLabel = ToShortTy;   break;
-	case Type::UIntTyID:    opLabel = ToUIntTy;    break;
-	case Type::IntTyID:     opLabel = ToIntTy;     break;
-	case Type::ULongTyID:   opLabel = ToULongTy;   break;
-	case Type::LongTyID:    opLabel = ToLongTy;    break;
-	case Type::FloatTyID:   opLabel = ToFloatTy;   break;
-	case Type::DoubleTyID:  opLabel = ToDoubleTy;  break;
-	case Type::ArrayTyID:   opLabel = ToArrayTy;   break;
-	case Type::PointerTyID: opLabel = ToPointerTy; break;
-	default:
-	  // Just use `Cast' opcode otherwise. It's probably ignored.
-	  break;
-	}
+    case Type::BoolTyID:    opLabel = ToBoolTy;    break;
+    case Type::UByteTyID:   opLabel = ToUByteTy;   break;
+    case Type::SByteTyID:   opLabel = ToSByteTy;   break;
+    case Type::UShortTyID:  opLabel = ToUShortTy;  break;
+    case Type::ShortTyID:   opLabel = ToShortTy;   break;
+    case Type::UIntTyID:    opLabel = ToUIntTy;    break;
+    case Type::IntTyID:     opLabel = ToIntTy;     break;
+    case Type::ULongTyID:   opLabel = ToULongTy;   break;
+    case Type::LongTyID:    opLabel = ToLongTy;    break;
+    case Type::FloatTyID:   opLabel = ToFloatTy;   break;
+    case Type::DoubleTyID:  opLabel = ToDoubleTy;  break;
+    case Type::ArrayTyID:   opLabel = ToArrayTy;   break;
+    case Type::PointerTyID: opLabel = ToPointerTy; break;
+    default:
+      // Just use `Cast' opcode otherwise. It's probably ignored.
+      break;
     }
+  }
 }
 
 
 void
-InstructionNode::dumpNode(int indent) const
-{
+InstructionNode::dumpNode(int indent) const {
   for (int i=0; i < indent; i++)
     std::cerr << "    ";
   std::cerr << getInstruction()->getOpcodeName()
             << " [label " << getOpLabel() << "]" << "\n";
 }
 
-
 void
-VRegListNode::dumpNode(int indent) const
-{
+VRegListNode::dumpNode(int indent) const {
   for (int i=0; i < indent; i++)
     std::cerr << "    ";
   
@@ -139,8 +119,7 @@ VRegListNode::dumpNode(int indent) const
 
 
 void
-VRegNode::dumpNode(int indent) const
-{
+VRegNode::dumpNode(int indent) const {
   for (int i=0; i < indent; i++)
     std::cerr << "    ";
   
@@ -149,8 +128,7 @@ VRegNode::dumpNode(int indent) const
 }
 
 void
-ConstantNode::dumpNode(int indent) const
-{
+ConstantNode::dumpNode(int indent) const {
   for (int i=0; i < indent; i++)
     std::cerr << "    ";
   
@@ -158,9 +136,7 @@ ConstantNode::dumpNode(int indent) const
             << (int) getValue()->getValueType() << ")" << "\n";
 }
 
-void
-LabelNode::dumpNode(int indent) const
-{
+void LabelNode::dumpNode(int indent) const {
   for (int i=0; i < indent; i++)
     std::cerr << "    ";
   
@@ -173,56 +149,46 @@ LabelNode::dumpNode(int indent) const
 // A forest of instruction trees, usually for a single method.
 //------------------------------------------------------------------------ 
 
-InstrForest::InstrForest(Function *F)
-{
+InstrForest::InstrForest(Function *F) {
   for (Function::iterator BB = F->begin(), FE = F->end(); BB != FE; ++BB) {
     for(BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I)
       buildTreeForInstruction(I);
   }
 }
 
-InstrForest::~InstrForest()
-{
+InstrForest::~InstrForest() {
   for_each(treeRoots.begin(), treeRoots.end(), deleter<InstructionNode>);
 }
 
-void
-InstrForest::dump() const
-{
+void InstrForest::dump() const {
   for (const_root_iterator I = roots_begin(); I != roots_end(); ++I)
     (*I)->dump(/*dumpChildren*/ 1, /*indent*/ 0);
 }
 
-inline void
-InstrForest::eraseRoot(InstructionNode* node)
-{
+inline void InstrForest::eraseRoot(InstructionNode* node) {
   for (RootSet::reverse_iterator RI=treeRoots.rbegin(), RE=treeRoots.rend();
        RI != RE; ++RI)
     if (*RI == node)
       treeRoots.erase(RI.base()-1);
 }
 
-inline void
-InstrForest::noteTreeNodeForInstr(Instruction *instr,
-				  InstructionNode *treeNode)
-{
+inline void InstrForest::noteTreeNodeForInstr(Instruction *instr,
+                                              InstructionNode *treeNode) {
   (*this)[instr] = treeNode;
   treeRoots.push_back(treeNode);	// mark node as root of a new tree
 }
 
 
-inline void
-InstrForest::setLeftChild(InstrTreeNode *parent, InstrTreeNode *child)
-{
+inline void InstrForest::setLeftChild(InstrTreeNode *parent,
+                                      InstrTreeNode *child) {
   parent->LeftChild = child;
   child->Parent = parent;
   if (InstructionNode* instrNode = dyn_cast<InstructionNode>(child))
     eraseRoot(instrNode); // no longer a tree root
 }
 
-inline void
-InstrForest::setRightChild(InstrTreeNode *parent, InstrTreeNode *child)
-{
+inline void InstrForest::setRightChild(InstrTreeNode *parent,
+                                       InstrTreeNode *child) {
   parent->RightChild = child;
   child->Parent = parent;
   if (InstructionNode* instrNode = dyn_cast<InstructionNode>(child))
@@ -230,26 +196,23 @@ InstrForest::setRightChild(InstrTreeNode *parent, InstrTreeNode *child)
 }
 
 
-InstructionNode*
-InstrForest::buildTreeForInstruction(Instruction *instr)
-{
+InstructionNode* InstrForest::buildTreeForInstruction(Instruction *instr) {
   InstructionNode *treeNode = getTreeNodeForInstr(instr);
-  if (treeNode)
-    {
-      // treeNode has already been constructed for this instruction
-      assert(treeNode->getInstruction() == instr);
-      return treeNode;
-    }
+  if (treeNode) {
+    // treeNode has already been constructed for this instruction
+    assert(treeNode->getInstruction() == instr);
+    return treeNode;
+  }
   
   // Otherwise, create a new tree node for this instruction.
   // 
   treeNode = new InstructionNode(instr);
   noteTreeNodeForInstr(instr, treeNode);
   
-  if (instr->getOpcode() == Instruction::Call)
-    { // Operands of call instruction
-      return treeNode;
-    }
+  if (instr->getOpcode() == Instruction::Call) {
+    // Operands of call instruction
+    return treeNode;
+  }
   
   // If the instruction has more than 2 instruction operands,
   // then we need to create artificial list nodes to hold them.
@@ -285,46 +248,42 @@ InstrForest::buildTreeForInstruction(Instruction *instr)
       if (includeAddressOperand || isa<Instruction>(operand) ||
 	  isa<Constant>(operand) || isa<Argument>(operand) ||
 	  isa<GlobalVariable>(operand))
-	{
-	  // This operand is a data value
+      {
+        // This operand is a data value
 	
-	  // An instruction that computes the incoming value is added as a
-	  // child of the current instruction if:
-	  //   the value has only a single use
-	  //   AND both instructions are in the same basic block.
-	  //   AND the current instruction is not a PHI (because the incoming
-	  //		value is conceptually in a predecessor block,
-	  //		even though it may be in the same static block)
-	  // 
-	  // (Note that if the value has only a single use (viz., `instr'),
-	  //  the def of the value can be safely moved just before instr
-	  //  and therefore it is safe to combine these two instructions.)
-	  // 
-	  // In all other cases, the virtual register holding the value
-	  // is used directly, i.e., made a child of the instruction node.
-	  // 
-	  InstrTreeNode* opTreeNode;
-	  if (isa<Instruction>(operand) && operand->hasOneUse() &&
-	      cast<Instruction>(operand)->getParent() == instr->getParent() &&
-	      instr->getOpcode() != Instruction::PHI &&
-	      instr->getOpcode() != Instruction::Call)
-	    {
-	      // Recursively create a treeNode for it.
-	      opTreeNode = buildTreeForInstruction((Instruction*)operand);
-	    }
-	  else if (Constant *CPV = dyn_cast<Constant>(operand))
-	    {
-	      // Create a leaf node for a constant
-	      opTreeNode = new ConstantNode(CPV);
-	    }
-	  else
-	    {
-	      // Create a leaf node for the virtual register
-	      opTreeNode = new VRegNode(operand);
-	    }
+        // An instruction that computes the incoming value is added as a
+        // child of the current instruction if:
+        //   the value has only a single use
+        //   AND both instructions are in the same basic block.
+        //   AND the current instruction is not a PHI (because the incoming
+        //		value is conceptually in a predecessor block,
+        //		even though it may be in the same static block)
+        // 
+        // (Note that if the value has only a single use (viz., `instr'),
+        //  the def of the value can be safely moved just before instr
+        //  and therefore it is safe to combine these two instructions.)
+        // 
+        // In all other cases, the virtual register holding the value
+        // is used directly, i.e., made a child of the instruction node.
+        // 
+        InstrTreeNode* opTreeNode;
+        if (isa<Instruction>(operand) && operand->hasOneUse() &&
+            cast<Instruction>(operand)->getParent() == instr->getParent() &&
+            instr->getOpcode() != Instruction::PHI &&
+            instr->getOpcode() != Instruction::Call)
+        {
+          // Recursively create a treeNode for it.
+          opTreeNode = buildTreeForInstruction((Instruction*)operand);
+        } else if (Constant *CPV = dyn_cast<Constant>(operand)) {
+          // Create a leaf node for a constant
+          opTreeNode = new ConstantNode(CPV);
+        } else {
+          // Create a leaf node for the virtual register
+          opTreeNode = new VRegNode(operand);
+        }
 
-	  childArray[numChildren++] = opTreeNode;
-	}
+        childArray[numChildren++] = opTreeNode;
+      }
     }
   
   //-------------------------------------------------------------------- 
@@ -338,15 +297,14 @@ InstrForest::buildTreeForInstruction(Instruction *instr)
   
   InstrTreeNode *parent = treeNode;
   
-  if (numChildren > 2)
-    {
-      unsigned instrOpcode = treeNode->getInstruction()->getOpcode();
-      assert(instrOpcode == Instruction::PHI ||
-	     instrOpcode == Instruction::Call ||
-	     instrOpcode == Instruction::Load ||
-	     instrOpcode == Instruction::Store ||
-	     instrOpcode == Instruction::GetElementPtr);
-    }
+  if (numChildren > 2) {
+    unsigned instrOpcode = treeNode->getInstruction()->getOpcode();
+    assert(instrOpcode == Instruction::PHI ||
+           instrOpcode == Instruction::Call ||
+           instrOpcode == Instruction::Load ||
+           instrOpcode == Instruction::Store ||
+           instrOpcode == Instruction::GetElementPtr);
+  }
   
   // Insert the first child as a direct child
   if (numChildren >= 1)
@@ -355,21 +313,19 @@ InstrForest::buildTreeForInstruction(Instruction *instr)
   int n;
   
   // Create a list node for children 2 .. N-1, if any
-  for (n = numChildren-1; n >= 2; n--)
-    {
-      // We have more than two children
-      InstrTreeNode *listNode = new VRegListNode();
-      setRightChild(parent, listNode);
-      setLeftChild(listNode, childArray[numChildren - n]);
-      parent = listNode;
-    }
+  for (n = numChildren-1; n >= 2; n--) {
+    // We have more than two children
+    InstrTreeNode *listNode = new VRegListNode();
+    setRightChild(parent, listNode);
+    setLeftChild(listNode, childArray[numChildren - n]);
+    parent = listNode;
+  }
   
   // Now insert the last remaining child (if any).
-  if (numChildren >= 2)
-    {
-      assert(n == 1);
-      setRightChild(parent, childArray[numChildren - 1]);
-    }
+  if (numChildren >= 2) {
+    assert(n == 1);
+    setRightChild(parent, childArray[numChildren - 1]);
+  }
 
   delete [] childArray;
   return treeNode;