Ensure that all goto instructions have deoptimization target.

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/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 4347 matching lines @@
     if (!reachable_->Contains(block->preorder_number())) {
       if (FLAG_trace_constant_propagation) {
         OS::Print("Unreachable B%"Pd"\n", block->block_id());
       }
       // Remove all uses in unreachable blocks.
       if (join != NULL) {
         for (PhiIterator it(join); !it.Done(); it.Advance()) {
           it.Current()->UnuseAllInputs();
         }
       }
+      block->UnuseAllInputs();
       for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
         it.Current()->UnuseAllInputs();
       }
       continue;
     }
 
     if (join != NULL) {
       // Remove phi inputs corresponding to unreachable predecessor blocks.
       // Predecessors will be recomputed (in block id order) after removing
       // unreachable code so we merely have to keep the phi inputs in order.
@@ skipping 72 matching lines @@
       TargetEntryInstr* if_true = branch->true_successor();
       TargetEntryInstr* if_false = branch->false_successor();
       JoinEntryInstr* join = NULL;
       Instruction* next = NULL;
 
       if (!reachable_->Contains(if_true->preorder_number())) {
         ASSERT(reachable_->Contains(if_false->preorder_number()));
         ASSERT(if_false->parallel_move() == NULL);
         ASSERT(if_false->loop_info() == NULL);
         join = new JoinEntryInstr(if_false->block_id(), if_false->try_index());
+        join->InheritDeoptTarget(if_false);
+        if_false->UnuseAllInputs();
         next = if_false->next();
       } else if (!reachable_->Contains(if_false->preorder_number())) {
         ASSERT(if_true->parallel_move() == NULL);
         ASSERT(if_true->loop_info() == NULL);
         join = new JoinEntryInstr(if_true->block_id(), if_true->try_index());
+        join->InheritDeoptTarget(if_true);
+        if_true->UnuseAllInputs();
         next = if_true->next();
       }
 
       if (join != NULL) {
         // Replace the branch with a jump to the reachable successor.
         // Drop the comparison, which does not have side effects as long
         // as it is a strict compare (the only one we can determine is
         // constant with the current analysis).
         GotoInstr* jump = new GotoInstr(join);
+        jump->InheritDeoptTarget(branch);
+
         Instruction* previous = branch->previous();
         branch->set_previous(NULL);
         previous->LinkTo(jump);
+
         // Replace the false target entry with the new join entry. We will
         // recompute the dominators after this pass.
         join->LinkTo(next);
         branch->UnuseAllInputs();
       }
     }
   }
 
   graph_->DiscoverBlocks();
   GrowableArray<BitVector*> dominance_frontier;
   graph_->ComputeDominators(&dominance_frontier);
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
+// Returns true if the given phi has a single input use and
+// is used in the environments either at the corresponding block entry or
+// at the same instruction where input use is.
+static bool PhiHasSingleUse(PhiInstr* phi, Value* use) {
+  if ((use->next_use() != NULL) || (phi->input_use_list() != use)) {
+    return false;
+  }
+
+  BlockEntryInstr* block = phi->block();
+  for (Value* env_use = phi->env_use_list();
+       env_use != NULL;
+       env_use = env_use->next_use()) {
+    if ((env_use->instruction() != block) &&
+        (env_use->instruction() != use->instruction())) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+
 bool BranchSimplifier::Match(JoinEntryInstr* block) {
   // Match the pattern of a branch on a comparison whose left operand is a
   // phi from the same block, and whose right operand is a constant.
   //
   //   Branch(Comparison(kind, Phi, Constant))
   //
   // These are the branches produced by inlining in a test context.  Also,
   // the phi and the constant have no other uses so they can simply be
   // eliminated.  The block has no other phis and no instructions
   // intervening between the phi, constant, and branch so the block can
   // simply be eliminated.
   BranchInstr* branch = block->last_instruction()->AsBranch();
   ASSERT(branch != NULL);
   ComparisonInstr* comparison = branch->comparison();
   Value* left = comparison->left();
   PhiInstr* phi = left->definition()->AsPhi();
   Value* right = comparison->right();
   ConstantInstr* constant = right->definition()->AsConstant();
   return (phi != NULL) &&
       (constant != NULL) &&
       (phi->GetBlock() == block) &&
-      phi->HasOnlyUse(left) &&
+      PhiHasSingleUse(phi, left) &&
       constant->HasOnlyUse(right) &&
       (block->next() == constant) &&
       (constant->next() == branch) &&
       (block->phis()->length() == 1);
 }
 
 
 JoinEntryInstr* BranchSimplifier::ToJoinEntry(TargetEntryInstr* target) {
   // Convert a target block into a join block.  Branches will be duplicated
   // so the former true and false targets become joins of the control flows
   // from all the duplicated branches.
   JoinEntryInstr* join =
       new JoinEntryInstr(target->block_id(), target->try_index());
+  join->InheritDeoptTarget(target);
   join->LinkTo(target->next());
   join->set_last_instruction(target->last_instruction());
+  target->UnuseAllInputs();
   return join;
 }
 
 
 ConstantInstr* BranchSimplifier::CloneConstant(FlowGraph* flow_graph,
                                                ConstantInstr* constant) {
   ConstantInstr* new_constant = new ConstantInstr(constant->value());
   new_constant->set_ssa_temp_index(flow_graph->alloc_ssa_temp_index());
   return new_constant;
 }
 
 
 BranchInstr* BranchSimplifier::CloneBranch(BranchInstr* branch,
                                            Value* left,
                                            Value* right) {
   ComparisonInstr* comparison = branch->comparison();
   ComparisonInstr* new_comparison = NULL;
   if (comparison->IsStrictCompare()) {
     new_comparison = new StrictCompareInstr(comparison->kind(), left, right);
   } else if (comparison->IsEqualityCompare()) {
-    new_comparison =
-        new EqualityCompareInstr(comparison->AsEqualityCompare()->token_pos(),
+    EqualityCompareInstr* equality_compare = comparison->AsEqualityCompare();
+    EqualityCompareInstr* new_equality_compare =
+        new EqualityCompareInstr(equality_compare->token_pos(),
                                  comparison->kind(),
                                  left,
                                  right);
+    new_equality_compare->set_ic_data(equality_compare->ic_data());
+    new_comparison = new_equality_compare;
   } else {
     ASSERT(comparison->IsRelationalOp());
-    new_comparison =
-        new RelationalOpInstr(comparison->AsRelationalOp()->token_pos(),
+    RelationalOpInstr* relational_op = comparison->AsRelationalOp();
+    RelationalOpInstr* new_relational_op =
+        new RelationalOpInstr(relational_op->token_pos(),
                               comparison->kind(),
                               left,
                               right);
+    new_relational_op->set_ic_data(relational_op->ic_data());
+    new_comparison = new_relational_op;
   }
   return new BranchInstr(new_comparison, branch->is_checked());
 }
 
 
 void BranchSimplifier::Simplify(FlowGraph* flow_graph) {
   // Optimize some branches that test the value of a phi.  When it is safe
   // to do so, push the branch to each of the predecessor blocks.  This is
   // an optimization when (a) it can avoid materializing a boolean object at
   // the phi only to test its value, and (b) it can expose opportunities for
@@ skipping 48 matching lines @@
 
         // Insert a copy of the constant in all the predecessors.
         ConstantInstr* new_constant = CloneConstant(flow_graph, constant);
         new_constant->InsertBefore(old_goto);
 
         // Replace the goto in each predecessor with a rewritten branch,
         // rewritten to use the corresponding phi input instead of the phi.
         Value* new_left = phi->InputAt(i)->Copy();
         Value* new_right = new Value(new_constant);
         BranchInstr* new_branch = CloneBranch(branch, new_left, new_right);
+        new_branch->InheritDeoptTarget(old_goto);
         new_branch->InsertBefore(old_goto);
         new_branch->set_next(NULL);  // Detaching the goto from the graph.
         old_goto->UnuseAllInputs();
 
         // Update the predecessor block.  We may have created another
         // instance of the pattern so add it to the worklist if necessary.
         BlockEntryInstr* branch_block = new_branch->GetBlock();
         branch_block->set_last_instruction(new_branch);
         if (branch_block->IsJoinEntry()) worklist.Add(branch_block);
 
         // Connect the branch to the true and false joins, via empty target
         // blocks.
         TargetEntryInstr* true_target =
             new TargetEntryInstr(flow_graph->max_block_id() + 1,
                                  block->try_index());
+        true_target->InheritDeoptTarget(join_true);
         TargetEntryInstr* false_target =
             new TargetEntryInstr(flow_graph->max_block_id() + 2,
                                  block->try_index());
+        false_target->InheritDeoptTarget(join_false);
         flow_graph->set_max_block_id(flow_graph->max_block_id() + 2);
         *new_branch->true_successor_address() = true_target;
         *new_branch->false_successor_address() = false_target;
         GotoInstr* goto_true = new GotoInstr(join_true);
+        goto_true->InheritDeoptTarget(join_true);
         true_target->LinkTo(goto_true);
         true_target->set_last_instruction(goto_true);
         GotoInstr* goto_false = new GotoInstr(join_false);
+        goto_false->InheritDeoptTarget(join_false);
         false_target->LinkTo(goto_false);
         false_target->set_last_instruction(goto_false);
       }
       // When all predecessors have been rewritten, the original block is
       // unreachable from the graph.
       phi->UnuseAllInputs();
       branch->UnuseAllInputs();
+      block->UnuseAllInputs();
     }
   }
 
   if (changed) {
     // We may have changed the block order and the dominator tree.
     flow_graph->DiscoverBlocks();
     GrowableArray<BitVector*> dominance_frontier;
     flow_graph->ComputeDominators(&dominance_frontier);
   }
 }
 
 
 }  // namespace dart