Fix branch optimizations based on range analysis.

runtime/vm/flow_graph_optimizer.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/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 7669 matching lines @@
   ConstantPropagator cp(graph, ignored);
   cp.Analyze();
   cp.Transform();
 }
 
 
 void ConstantPropagator::OptimizeBranches(FlowGraph* graph) {
   GrowableArray<BlockEntryInstr*> ignored;
   ConstantPropagator cp(graph, ignored);
   cp.Analyze();
-  cp.VisitBranches();
   cp.Transform();
   cp.EliminateRedundantBranches();
 }
 
 
 void ConstantPropagator::SetReachable(BlockEntryInstr* block) {
   if (!reachable_->Contains(block->preorder_number())) {
     reachable_->Add(block->preorder_number());
     block_worklist_.Add(block);
   }
@@ skipping 124 matching lines @@
 }
 
 
 void ConstantPropagator::VisitBranch(BranchInstr* instr) {
   instr->comparison()->Accept(this);
 
   // The successors may be reachable, but only if this instruction is.  (We
   // might be analyzing it because the constant value of one of its inputs
   // has changed.)
   if (reachable_->Contains(instr->GetBlock()->preorder_number())) {
-    const Object& value = instr->comparison()->constant_value();
-    if (IsNonConstant(value)) {
-      SetReachable(instr->true_successor());
-      SetReachable(instr->false_successor());
-    } else if (value.raw() == Bool::True().raw()) {
-      SetReachable(instr->true_successor());
-    } else if (!IsUnknown(value)) {  // Any other constant.
-      SetReachable(instr->false_successor());
+    if (instr->constant_target() != NULL) {
+      ASSERT((instr->constant_target() == instr->true_successor()) ||
+             (instr->constant_target() == instr->false_successor()));
+      SetReachable(instr->constant_target());
+    } else {
+      const Object& value = instr->comparison()->constant_value();
+      if (IsNonConstant(value)) {
+        SetReachable(instr->true_successor());
+        SetReachable(instr->false_successor());
+      } else if (value.raw() == Bool::True().raw()) {
+        SetReachable(instr->true_successor());
+      } else if (!IsUnknown(value)) {  // Any other constant.
+        SetReachable(instr->false_successor());
+      }
     }
   }
 }
 
 
 // --------------------------------------------------------------------------
 // Analysis of non-definition instructions.  They do not have values so they
 // cannot have constant values.
 void ConstantPropagator::VisitStoreContext(StoreContextInstr* instr) { }
 
@@ skipping 1075 matching lines @@
         use = use->next_use();
       }
     } else {
       BlockEntryInstr* block = block_worklist_.RemoveLast();
       block->Accept(this);
     }
   }
 }
 
 
-void ConstantPropagator::VisitBranches() {
-  GraphEntryInstr* entry = graph_->graph_entry();
-  reachable_->Add(entry->preorder_number());
-  block_worklist_.Add(entry);
-
-  while (!block_worklist_.is_empty()) {
-    BlockEntryInstr* block = block_worklist_.RemoveLast();
-    if (block->IsGraphEntry()) {
-      // TODO(fschneider): Improve this approximation. Catch entries are only
-      // reachable if a call in the corresponding try-block is reachable.
-      for (intptr_t i = 0; i < block->SuccessorCount(); ++i) {
-        SetReachable(block->SuccessorAt(i));
-      }
-      continue;
-    }
-    Instruction* last = block->last_instruction();
-    if (last->IsGoto()) {
-      SetReachable(last->AsGoto()->successor());
-    } else if (last->IsBranch()) {
-      BranchInstr* branch = last->AsBranch();
-      // The current block must be reachable.
-      ASSERT(reachable_->Contains(branch->GetBlock()->preorder_number()));
-      if (branch->constant_target() != NULL) {
-        // Found constant target computed by range analysis.
-        if (branch->constant_target() == branch->true_successor()) {
-          SetReachable(branch->true_successor());
-        } else {
-          ASSERT(branch->constant_target() == branch->false_successor());
-          SetReachable(branch->false_successor());
-        }
-      } else {
-        // No new information: Assume both targets are reachable.
-        SetReachable(branch->true_successor());
-        SetReachable(branch->false_successor());
-      }
-    }
-  }
-}
-
-
 static bool IsEmptyBlock(BlockEntryInstr* block) {
   return block->next()->IsGoto() &&
       (!block->IsJoinEntry() || (block->AsJoinEntry()->phis() == NULL));
 }
 
 
 // Traverses a chain of empty blocks and returns the first reachable non-empty
 // block that is not dominated by the start block. The empty blocks are added
 // to the supplied bit vector.
 static BlockEntryInstr* FindFirstNonEmptySuccessor(
@@ skipping 830 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart