Fix a bug in ParallelMoveResolver::AllocateScratchRegister, where we end up allocating PC on ARM.

runtime/vm/flow_graph_compiler.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/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/cha.h"
 #include "vm/dart_entry.h"
@@ skipping 1219 matching lines @@
   for (int i = 0; i < moves_.length(); ++i) {
     if (moves_[i]->dest().Equals(loc)) {
       return true;
     }
   }
 
   return false;
 }
 
 
-intptr_t ParallelMoveResolver::AllocateScratchRegister(Location::Kind kind,
-                                                       intptr_t blocked,
-                                                       intptr_t register_count,
-                                                       bool* spilled) {
+intptr_t ParallelMoveResolver::AllocateScratchRegister(
+    Location::Kind kind,
+    intptr_t blocked,
+    intptr_t first_free_register,
+    intptr_t last_free_register,
+    bool* spilled) {
   intptr_t scratch = -1;
-  for (intptr_t reg = 0; reg < register_count; reg++) {
+  for (intptr_t reg = first_free_register; reg <= last_free_register; reg++) {
     if ((blocked != reg) &&
         IsScratchLocation(Location::MachineRegisterLocation(kind, reg))) {
       scratch = reg;
       break;
     }
   }
 
   if (scratch == -1) {
     *spilled = true;
-    for (intptr_t reg = 0; reg < register_count; reg++) {
+    for (intptr_t reg = first_free_register; reg <= last_free_register; reg++) {
       if (blocked != reg) {
         scratch = reg;
+        break;
       }
     }
   } else {
     *spilled = false;
   }
 
   return scratch;
 }
 
 
 ParallelMoveResolver::ScratchFpuRegisterScope::ScratchFpuRegisterScope(
     ParallelMoveResolver* resolver, FpuRegister blocked)
     : resolver_(resolver),
       reg_(kNoFpuRegister),
       spilled_(false) {
   reg_ = static_cast<FpuRegister>(
       resolver_->AllocateScratchRegister(Location::kFpuRegister,
                                          blocked,
-                                         kNumberOfFpuRegisters,
+                                         0,
+                                         kNumberOfFpuRegisters - 1,
                                          &spilled_));
 
   if (spilled_) {
     resolver->SpillFpuScratch(reg_);
   }
 }
 
 
 ParallelMoveResolver::ScratchFpuRegisterScope::~ScratchFpuRegisterScope() {
   if (spilled_) {
     resolver_->RestoreFpuScratch(reg_);
   }
 }
 
 
 ParallelMoveResolver::ScratchRegisterScope::ScratchRegisterScope(
     ParallelMoveResolver* resolver, Register blocked)
     : resolver_(resolver),
       reg_(kNoRegister),
       spilled_(false) {
   reg_ = static_cast<Register>(
       resolver_->AllocateScratchRegister(Location::kRegister,
                                          blocked,
-                                         kNumberOfCpuRegisters,
+                                         kFirstFreeCpuRegister,
+                                         kLastFreeCpuRegister,
                                          &spilled_));
 
   if (spilled_) {
     resolver->SpillScratch(reg_);
   }
 }
 
 
 ParallelMoveResolver::ScratchRegisterScope::~ScratchRegisterScope() {
   if (spilled_) {
@@ skipping 18 matching lines @@
 
   for (int i = 0; i < len; i++) {
     sorted->Add(CidTarget(ic_data.GetReceiverClassIdAt(i),
                           &Function::ZoneHandle(ic_data.GetTargetAt(i)),
                           ic_data.GetCountAt(i)));
   }
   sorted->Sort(HighestCountFirst);
 }
 
 }  // namespace dart