Add a use list iterator that allows mutation of current.

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 206 matching lines @@
         ASSERT((replacement == NULL) || current->IsDefinition());
         ReplaceCurrentInstruction(&it, current, replacement, flow_graph_);
       }
     }
   }
 }
 
 
 void FlowGraphOptimizer::InsertConversion(Representation from,
                                           Representation to,
-                                          Instruction* instr,
                                           Value* use,
-                                          Definition* def,
+                                          Instruction* insert_before,
                                           Instruction* deopt_target) {
   Definition* converted = NULL;
   if ((from == kTagged) && (to == kUnboxedMint)) {
+    ASSERT((deopt_target != NULL) ||
+           (use->definition()->GetPropagatedCid() == kDoubleCid));
     const intptr_t deopt_id = (deopt_target != NULL) ?
         deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
-    ASSERT((deopt_target != NULL) || (def->GetPropagatedCid() == kDoubleCid));
-    converted = new UnboxIntegerInstr(new Value(def), deopt_id);
+    converted = new UnboxIntegerInstr(new Value(use->definition()), deopt_id);
   } else if ((from == kUnboxedMint) && (to == kTagged)) {
-    converted = new BoxIntegerInstr(new Value(def));
+    converted = new BoxIntegerInstr(new Value(use->definition()));
   } else if (from == kUnboxedMint && to == kUnboxedDouble) {
     // Convert by boxing/unboxing.
     // TODO(fschneider): Implement direct unboxed mint-to-double conversion.
-    BoxIntegerInstr* boxed = new BoxIntegerInstr(new Value(def));
-    InsertBefore(instr, boxed, NULL, Definition::kValue);
+    BoxIntegerInstr* boxed = new BoxIntegerInstr(new Value(use->definition()));
+    InsertBefore(insert_before, boxed, NULL, Definition::kValue);
     const intptr_t deopt_id = (deopt_target != NULL) ?
         deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
     converted = new UnboxDoubleInstr(new Value(boxed), deopt_id);
   } else if ((from == kUnboxedDouble) && (to == kTagged)) {
-    converted = new BoxDoubleInstr(new Value(def), NULL);
+    converted = new BoxDoubleInstr(new Value(use->definition()), NULL);
   } else if ((from == kTagged) && (to == kUnboxedDouble)) {
     const intptr_t deopt_id = (deopt_target != NULL) ?
         deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
-    ASSERT((deopt_target != NULL) || (def->GetPropagatedCid() == kDoubleCid));
-    if (def->IsConstant() && def->AsConstant()->value().IsSmi()) {
-      const double dbl_val =
-          Smi::Cast(def->AsConstant()->value()).AsDoubleValue();
+    ASSERT((deopt_target != NULL) ||
+           (use->definition()->GetPropagatedCid() == kDoubleCid));
+    ConstantInstr* constant = use->definition()->AsConstant();
+    if ((constant != NULL) && constant->value().IsSmi()) {
+      const double dbl_val = Smi::Cast(constant->value()).AsDoubleValue();
       const Double& dbl_obj =
           Double::ZoneHandle(Double::New(dbl_val, Heap::kOld));
       ConstantInstr* double_const = new ConstantInstr(dbl_obj);
-      InsertBefore(instr, double_const, NULL, Definition::kValue);
+      InsertBefore(insert_before, double_const, NULL, Definition::kValue);
       converted = new UnboxDoubleInstr(new Value(double_const), deopt_id);
     } else {
-      converted = new UnboxDoubleInstr(new Value(def), deopt_id);
+      converted = new UnboxDoubleInstr(new Value(use->definition()), deopt_id);
     }
   }
   ASSERT(converted != NULL);
-  InsertBefore(instr, converted, use->instruction()->env(),
+  InsertBefore(insert_before, converted, use->instruction()->env(),
                Definition::kValue);
   use->set_definition(converted);
 }
 
 
 void FlowGraphOptimizer::InsertConversionsFor(Definition* def) {
   const Representation from_rep = def->representation();
 
-  for (Value* use = def->input_use_list();
-       use != NULL;
-       use = use->next_use()) {
+  for (Value::Iterator it(def->input_use_list());
+       !it.Done();
+       it.Advance()) {
+    Value* use = it.Current();
     const Representation to_rep =
         use->instruction()->RequiredInputRepresentation(use->use_index());
     if (from_rep == to_rep) {
       continue;
     }
 
-    Instruction* deopt_target = NULL;
-    Instruction* instr = use->instruction();
-    if (instr->IsPhi()) {
-      if (!instr->AsPhi()->is_alive()) continue;
+    Instruction* insert_before;
+    Instruction* deopt_target;
+    PhiInstr* phi = use->instruction()->AsPhi();
+    if (phi != NULL) {
+      if (!phi->is_alive()) continue;
 
       // For phis conversions have to be inserted in the predecessor.
-      const BlockEntryInstr* pred =
-          instr->AsPhi()->block()->PredecessorAt(use->use_index());
-      instr = pred->last_instruction();
+      insert_before =
+          phi->block()->PredecessorAt(use->use_index())->last_instruction();
+      deopt_target = NULL;
     } else {
-      deopt_target = instr;
+      deopt_target = insert_before = use->instruction();
     }
 
-    InsertConversion(from_rep, to_rep, instr, use, def, deopt_target);
+    InsertConversion(from_rep, to_rep, use, insert_before, deopt_target);
   }
 }
 
 
 void FlowGraphOptimizer::SelectRepresentations() {
   // Convervatively unbox all phis that were proven to be of type Double.
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     JoinEntryInstr* join_entry = block_order_[i]->AsJoinEntry();
     if (join_entry == NULL) continue;
 
@@ skipping 1884 matching lines @@
     return false;
   }
 
   return dom_block->Dominates(use_block);
 }
 
 
 void RangeAnalysis::RenameDominatedUses(Definition* def,
                                         Instruction* dom,
                                         Definition* other) {
-  Value* next_use = NULL;
-  for (Value* use = def->input_use_list();
-       use != NULL;
-       use = next_use) {
-    next_use = use->next_use();
+  for (Value::Iterator it(def->input_use_list());
+       !it.Done();
+       it.Advance()) {
+    Value* use = it.Current();
 
     // Skip dead phis.
     PhiInstr* phi = use->instruction()->AsPhi();
     if ((phi != NULL) && !phi->is_alive()) continue;
 
     if (IsDominatedUse(dom, use)) {
       use->RemoveFromUseList();
       use->set_definition(other);
       other->AddInputUse(use);
     }
@@ skipping 2342 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart