Fix crash during parallel moves.

runtime/vm/flow_graph_compiler.cc

Index: runtime/vm/flow_graph_compiler.cc
===================================================================
--- runtime/vm/flow_graph_compiler.cc	(revision 9788)
+++ runtime/vm/flow_graph_compiler.cc	(working copy)
@@ -699,7 +699,7 @@
   BuildInitialMoveList(parallel_move);
 
   for (int i = 0; i < moves_.length(); ++i) {
-    MoveOperands move = moves_[i];
+    const MoveOperands& move = *moves_[i];
     // Skip constants to perform them last.  They don't block other moves
     // and skipping such moves with register destinations keeps those
     // registers free for the whole algorithm.
@@ -708,8 +708,9 @@
 
   // Perform the moves with constant sources.
   for (int i = 0; i < moves_.length(); ++i) {
-    if (!moves_[i].IsEliminated()) {
-      ASSERT(moves_[i].src().IsConstant());
+    const MoveOperands& move = *moves_[i];
+    if (!move.IsEliminated()) {
+      ASSERT(move.src().IsConstant());
       EmitMove(i);
     }
   }
@@ -724,10 +725,9 @@
   // moves to perform, ignoring any move that is redundant (the source is
   // the same as the destination, the destination is ignored and
   // unallocated, or the move was already eliminated).
-  const GrowableArray<MoveOperands>& moves = parallel_move->moves();
-  for (int i = 0; i < moves.length(); ++i) {
-    MoveOperands move = moves[i];
-    if (!move.IsRedundant()) moves_.Add(move);
+  for (int i = 0; i < parallel_move->NumMoves(); i++) {
+    MoveOperands* move = parallel_move->MoveOperandsAt(i);
+    if (!move->IsRedundant()) moves_.Add(move);
   }
 }
 
@@ -740,21 +740,21 @@
   // which means that a call to PerformMove could change any source operand
   // in the move graph.
 
-  ASSERT(!moves_[index].IsPending());
-  ASSERT(!moves_[index].IsRedundant());
+  ASSERT(!moves_[index]->IsPending());
+  ASSERT(!moves_[index]->IsRedundant());
 
   // Clear this move's destination to indicate a pending move.  The actual
   // destination is saved in a stack-allocated local.  Recursion may allow
   // multiple moves to be pending.
-  ASSERT(!moves_[index].src().IsInvalid());
-  Location destination = moves_[index].MarkPending();
+  ASSERT(!moves_[index]->src().IsInvalid());
+  Location destination = moves_[index]->MarkPending();
 
   // Perform a depth-first traversal of the move graph to resolve
   // dependencies.  Any unperformed, unpending move with a source the same
   // as this one's destination blocks this one so recursively perform all
   // such moves.
   for (int i = 0; i < moves_.length(); ++i) {
-    MoveOperands other_move = moves_[i];
+    const MoveOperands& other_move = *moves_[i];
     if (other_move.Blocks(destination) && !other_move.IsPending()) {
       // Though PerformMove can change any source operand in the move graph,
       // this call cannot create a blocking move via a swap (this loop does
@@ -771,12 +771,12 @@
 
   // We are about to resolve this move and don't need it marked as
   // pending, so restore its destination.
-  moves_[index].ClearPending(destination);
+  moves_[index]->ClearPending(destination);
 
   // This move's source may have changed due to swaps to resolve cycles and
   // so it may now be the last move in the cycle.  If so remove it.
-  if (moves_[index].src().Equals(destination)) {
-    moves_[index].Eliminate();
+  if (moves_[index]->src().Equals(destination)) {
+    moves_[index]->Eliminate();
     return;
   }
 
@@ -784,7 +784,7 @@
   // we have a cycle.  Search for such a blocking move and perform a swap to
   // resolve it.
   for (int i = 0; i < moves_.length(); ++i) {
-    MoveOperands other_move = moves_[i];
+    const MoveOperands& other_move = *moves_[i];
     if (other_move.Blocks(destination)) {
       ASSERT(other_move.IsPending());
       EmitSwap(index);