Add support for hydrogen control instructions with >2 successor blocks.

src/hydrogen.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 138 matching lines @@
   }
   environment->ClearHistory();
   return instr;
 }
 
 
 void HBasicBlock::Finish(HControlInstruction* end) {
   ASSERT(!IsFinished());
   AddInstruction(end);
   end_ = end;
-  if (end->FirstSuccessor() != NULL) {
-    end->FirstSuccessor()->RegisterPredecessor(this);
-    if (end->SecondSuccessor() != NULL) {
-      end->SecondSuccessor()->RegisterPredecessor(this);
-    }
+  for (HSuccessorIterator it(end); it.HasNext(); it.Advance()) {
+    it.Next()->RegisterPredecessor(this);
   }
 }
 
 
 void HBasicBlock::Goto(HBasicBlock* block, bool include_stack_check) {
   if (block->IsInlineReturnTarget()) {
     AddInstruction(new(zone()) HLeaveInlined);
     last_environment_ = last_environment()->outer();
   }
   AddSimulate(AstNode::kNoNumber);
@@ skipping 219 matching lines @@
         !reachable_.Contains(block->block_id())) {
       reachable_.Add(block->block_id());
       stack_.Add(block);
       visited_count_++;
     }
   }
 
   void Analyze() {
     while (!stack_.is_empty()) {
       HControlInstruction* end = stack_.RemoveLast()->end();
-      PushBlock(end->FirstSuccessor());
-      PushBlock(end->SecondSuccessor());
+      for (HSuccessorIterator it(end); it.HasNext(); it.Advance()) {
+        PushBlock(it.Next());
+      }
     }
   }
 
   int visited_count_;
   ZoneList<HBasicBlock*> stack_;
   BitVector reachable_;
   HBasicBlock* dont_visit_;
 };
 
 
@@ skipping 274 matching lines @@
   }
 }
 
 
 void HGraph::PostorderLoopBlocks(HLoopInformation* loop,
                                  BitVector* visited,
                                  ZoneList<HBasicBlock*>* order,
                                  HBasicBlock* loop_header) {
   for (int i = 0; i < loop->blocks()->length(); ++i) {
     HBasicBlock* b = loop->blocks()->at(i);
-    Postorder(b->end()->SecondSuccessor(), visited, order, loop_header);
-    Postorder(b->end()->FirstSuccessor(), visited, order, loop_header);
+    for (HSuccessorIterator it(b->end()); it.HasNext(); it.Advance()) {
+      Postorder(it.Next(), visited, order, loop_header);
+    }
     if (b->IsLoopHeader() && b != loop->loop_header()) {
       PostorderLoopBlocks(b->loop_information(), visited, order, loop_header);
     }
   }
 }
 
 
 void HGraph::Postorder(HBasicBlock* block,
                        BitVector* visited,
                        ZoneList<HBasicBlock*>* order,
                        HBasicBlock* loop_header) {
   if (block == NULL || visited->Contains(block->block_id())) return;
   if (block->parent_loop_header() != loop_header) return;
   visited->Add(block->block_id());
   if (block->IsLoopHeader()) {
     PostorderLoopBlocks(block->loop_information(), visited, order, loop_header);
-    Postorder(block->end()->SecondSuccessor(), visited, order, block);
-    Postorder(block->end()->FirstSuccessor(), visited, order, block);
+    for (HSuccessorIterator it(block->end()); it.HasNext(); it.Advance()) {
+      Postorder(it.Next(), visited, order, block);
+    }
   } else {
-    Postorder(block->end()->SecondSuccessor(), visited, order, loop_header);
-    Postorder(block->end()->FirstSuccessor(), visited, order, loop_header);
+    for (HSuccessorIterator it(block->end()); it.HasNext(); it.Advance()) {
+      Postorder(it.Next(), visited, order, loop_header);
+    }
   }
   ASSERT(block->end()->FirstSuccessor() == NULL ||
          order->Contains(block->end()->FirstSuccessor()) ||
          block->end()->FirstSuccessor()->IsLoopHeader());
   ASSERT(block->end()->SecondSuccessor() == NULL ||
          order->Contains(block->end()->SecondSuccessor()) ||
          block->end()->SecondSuccessor()->IsLoopHeader());
   order->Add(block);
 }
 
@@ skipping 5347 matching lines @@
       PrintIndent();
       trace_.Add("predecessors");
       for (int j = 0; j < current->predecessors()->length(); ++j) {
         trace_.Add(" \"B%d\"", current->predecessors()->at(j)->block_id());
       }
       trace_.Add("\n");
     } else {
       PrintEmptyProperty("predecessors");
     }
 
-    if (current->end() == NULL || current->end()->FirstSuccessor() == NULL) {
+    if (current->end()->SuccessorCount() == 0) {
       PrintEmptyProperty("successors");
-    } else if (current->end()->SecondSuccessor() == NULL) {
-      PrintBlockProperty("successors",
-                             current->end()->FirstSuccessor()->block_id());
-    } else {
-      PrintBlockProperty("successors",
-                             current->end()->FirstSuccessor()->block_id(),
-                             current->end()->SecondSuccessor()->block_id());
+    } else  {
+      PrintIndent();
+      trace_.Add("successors");
+      for (HSuccessorIterator it(current->end()); it.HasNext(); it.Advance()) {
+        trace_.Add(" \"B%d\"", it.Next()->block_id());
+      }
+      trace_.Add("\n");
     }
 
     PrintEmptyProperty("xhandlers");
     PrintEmptyProperty("flags");
 
     if (current->dominator() != NULL) {
       PrintBlockProperty("dominator", current->dominator()->block_id());
     }
 
     if (chunk != NULL) {
@@ skipping 239 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify();
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal