Fix issue 16592: Do not attempt to merge operations that do not have uses, otherwise we add force u…

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/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 336 matching lines @@
     Definition* right_def = curr_instr->right()->definition();
     for (intptr_t k = i + 1; k < merge_candidates->length(); k++) {
       BinarySmiOpInstr* other_binop = (*merge_candidates)[k];
       // 'other_binop' can be NULL if it was already merged.
       if ((other_binop != NULL) &&
           (other_binop->op_kind() == other_kind) &&
           (other_binop->left()->definition() == left_def) &&
           (other_binop->right()->definition() == right_def)) {
         (*merge_candidates)[k] = NULL;  // Clear it.
         // Append a LoadIndexed behind TRUNC_DIV and MOD.
+        ASSERT(curr_instr->HasUses());
         AppendLoadIndexedForMerged(
             curr_instr,
             MergedMathInstr::ResultIndexOf(curr_instr->op_kind()),
             kArrayCid);
+        ASSERT(other_binop->HasUses());
         AppendLoadIndexedForMerged(
             other_binop,
             MergedMathInstr::ResultIndexOf(other_binop->op_kind()),
             kArrayCid);
 
         ZoneGrowableArray<Value*>* args = new ZoneGrowableArray<Value*>(2);
         args->Add(new Value(curr_instr->left()->definition()));
         args->Add(new Value(curr_instr->right()->definition()));
 
         // Replace with TruncDivMod.
@@ skipping 36 matching lines @@
         (curr_instr->kind() == MethodRecognizer::kMathSin) ?
             MethodRecognizer::kMathCos : MethodRecognizer::kMathSin;
     Definition* def = curr_instr->value()->definition();
     for (intptr_t k = i + 1; k < merge_candidates->length(); k++) {
       MathUnaryInstr* other_op = (*merge_candidates)[k];
       // 'other_op' can be NULL if it was already merged.
       if ((other_op != NULL) && (other_op->kind() == other_kind) &&
           (other_op->value()->definition() == def)) {
         (*merge_candidates)[k] = NULL;  // Clear it.
         // Append a LoadIndexed behind SIN and COS.
+        ASSERT(curr_instr->HasUses());
         AppendLoadIndexedForMerged(
             curr_instr,
             MergedMathInstr::ResultIndexOf(curr_instr->kind()),
             kTypedDataFloat64ArrayCid);
+        ASSERT(other_op->HasUses());
         AppendLoadIndexedForMerged(
             other_op,
             MergedMathInstr::ResultIndexOf(other_op->kind()),
             kTypedDataFloat64ArrayCid);
         ZoneGrowableArray<Value*>* args = new ZoneGrowableArray<Value*>(1);
         args->Add(new Value(curr_instr->value()->definition()));
 
         // Replace with SinCos.
         MergedMathInstr* sin_cos = new MergedMathInstr(
             args,
@@ skipping 29 matching lines @@
     current_iterator_ = &it;
     for (; !it.Done(); it.Advance()) {
       if (it.Current()->IsBinarySmiOp()) {
         BinarySmiOpInstr* binop = it.Current()->AsBinarySmiOp();
         if (binop->op_kind() == Token::kBIT_AND) {
           OptimizeLeftShiftBitAndSmiOp(binop,
                                        binop->left()->definition(),
                                        binop->right()->definition());
         } else if ((binop->op_kind() == Token::kTRUNCDIV) ||
                    (binop->op_kind() == Token::kMOD)) {
-          div_mod_merge.Add(binop);
+          if (binop->HasUses()) {
+            div_mod_merge.Add(binop);
+          }
         }
       } else if (it.Current()->IsBinaryMintOp()) {
         BinaryMintOpInstr* mintop = it.Current()->AsBinaryMintOp();
         if (mintop->op_kind() == Token::kBIT_AND) {
           OptimizeLeftShiftBitAndSmiOp(mintop,
                                        mintop->left()->definition(),
                                        mintop->right()->definition());
         }
       } else if (it.Current()->IsMathUnary()) {
         MathUnaryInstr* math_unary = it.Current()->AsMathUnary();
         if ((math_unary->kind() == MethodRecognizer::kMathSin) ||
             (math_unary->kind() == MethodRecognizer::kMathCos)) {
-          sin_cos_merge.Add(math_unary);
+          if (math_unary->HasUses()) {
+            sin_cos_merge.Add(math_unary);
+          }
         }
       }
     }
     TryMergeTruncDivMod(&div_mod_merge);
     TryMergeMathUnary(&sin_cos_merge);
     current_iterator_ = NULL;
   }
 }
 
 
@@ skipping 7978 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *fields);
   }
 }
 
 
 }  // namespace dart