Fix a bug in block reordering/block compaction.

runtime/vm/flow_graph_compiler.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/cha.h"
 #include "vm/dart_entry.h"
@@ skipping 162 matching lines @@
 static bool IsEmptyBlock(BlockEntryInstr* block) {
   return !block->HasParallelMove() &&
          block->next()->IsGoto() &&
          !block->next()->AsGoto()->HasParallelMove();
 }
 
 
 void FlowGraphCompiler::CompactBlock(BlockEntryInstr* block) {
   BlockInfo* block_info = block_info_[block->postorder_number()];
 
+  // Break out of cycles in the control flow graph.
   if (block_info->is_marked()) {
     return;
   }
   block_info->mark();
 
   if (IsEmptyBlock(block)) {
+    // For empty blocks, record a corresponding nonempty target as their
+    // jump label.
     BlockEntryInstr* target = block->next()->AsGoto()->successor();
     CompactBlock(target);
     block_info->set_jump_label(GetJumpLabel(target));
   }
 }
 
 
 void FlowGraphCompiler::CompactBlocks() {
-  Label* fallthrough_label = NULL;
+  // This algorithm does not garbage collect blocks in place, but merely
+  // records forwarding label information.  In this way it avoids having to
+  // change join and target entries.
+  Label* nonempty_label = NULL;
   for (intptr_t i = block_order().length() - 1; i >= 1; --i) {
     BlockEntryInstr* block = block_order()[i];
 
     // Unoptimized code must emit all possible deoptimization points.
     if (is_optimizing()) {
       CompactBlock(block);
     }
 
+    // For nonempty blocks, record the next nonempty block in the block
+    // order.  Since no code is emitted for empty blocks, control flow is
+    // eligible to fall through to the next nonempty one.
     if (!WasCompacted(block)) {
       BlockInfo* block_info = block_info_[block->postorder_number()];
-      block_info->set_fallthrough_label(fallthrough_label);
-      fallthrough_label = GetJumpLabel(block);
+      block_info->set_next_nonempty_label(nonempty_label);
+      nonempty_label = GetJumpLabel(block);
     }
   }
 
   ASSERT(block_order()[0]->IsGraphEntry());
   BlockInfo* block_info = block_info_[block_order()[0]->postorder_number()];
-  block_info->set_fallthrough_label(fallthrough_label);
+  block_info->set_next_nonempty_label(nonempty_label);
 }
 
 
 void FlowGraphCompiler::VisitBlocks() {
   CompactBlocks();
 
   for (intptr_t i = 0; i < block_order().length(); ++i) {
     // Compile the block entry.
     BlockEntryInstr* entry = block_order()[i];
     assembler()->Comment("B%" Pd "", entry->block_id());
@@ skipping 56 matching lines @@
 
 bool FlowGraphCompiler::WasCompacted(
     BlockEntryInstr* block_entry) const {
   const intptr_t block_index = block_entry->postorder_number();
   return block_info_[block_index]->WasCompacted();
 }
 
 
 bool FlowGraphCompiler::CanFallThroughTo(BlockEntryInstr* block_entry) const {
   const intptr_t current_index = current_block()->postorder_number();
-  Label* fallthrough_label = block_info_[current_index]->fallthrough_label();
-  return fallthrough_label == GetJumpLabel(block_entry);
+  Label* next_nonempty = block_info_[current_index]->next_nonempty_label();
+  return next_nonempty == GetJumpLabel(block_entry);
 }
 
 
 void FlowGraphCompiler::AddSlowPathCode(SlowPathCode* code) {
   slow_path_code_.Add(code);
 }
 
 
 void FlowGraphCompiler::GenerateDeferredCode() {
   for (intptr_t i = 0; i < slow_path_code_.length(); i++) {
@@ skipping 796 matching lines @@
 
   for (int i = 0; i < len; i++) {
     sorted->Add(CidTarget(ic_data.GetReceiverClassIdAt(i),
                           &Function::ZoneHandle(ic_data.GetTargetAt(i)),
                           ic_data.GetCountAt(i)));
   }
   sorted->Sort(HighestCountFirst);
 }
 
 }  // namespace dart