Fixes for ARM/ARM64/MIPS parallel move resolver.

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/bit_vector.h"
 #include "vm/cha.h"
@@ skipping 1272 matching lines @@
       return true;
     }
   }
 
   return false;
 }
 
 
 intptr_t ParallelMoveResolver::AllocateScratchRegister(
     Location::Kind kind,
-    intptr_t blocked,
+    uword blocked_mask,
     intptr_t first_free_register,
     intptr_t last_free_register,
     bool* spilled) {
+  COMPILE_ASSERT(static_cast<intptr_t>(sizeof(blocked_mask)) * kBitsPerByte >=
+                 kNumberOfFpuRegisters);
+  COMPILE_ASSERT(static_cast<intptr_t>(sizeof(blocked_mask)) * kBitsPerByte >=
+                 kNumberOfCpuRegisters);
   intptr_t scratch = -1;
   for (intptr_t reg = first_free_register; reg <= last_free_register; reg++) {
-    if ((blocked != reg) &&
+    if ((((1 << reg) & blocked_mask) == 0) &&
         IsScratchLocation(Location::MachineRegisterLocation(kind, reg))) {
       scratch = reg;
       break;
     }
   }
 
   if (scratch == -1) {
     *spilled = true;
     for (intptr_t reg = first_free_register; reg <= last_free_register; reg++) {
-      if (blocked != reg) {
+      if (((1 << reg) & blocked_mask) == 0) {
         scratch = reg;
         break;
       }
     }
   } else {
     *spilled = false;
   }
 
   return scratch;
 }
 
 
 ParallelMoveResolver::ScratchFpuRegisterScope::ScratchFpuRegisterScope(
     ParallelMoveResolver* resolver, FpuRegister blocked)
     : resolver_(resolver),
       reg_(kNoFpuRegister),
       spilled_(false) {
+  COMPILE_ASSERT(FpuTMP != kNoFpuRegister);
+  uword blocked_mask = ((blocked != kNoFpuRegister) ? 1 << blocked : 0)
+                     | 1 << FpuTMP;
   reg_ = static_cast<FpuRegister>(
       resolver_->AllocateScratchRegister(Location::kFpuRegister,
-                                         blocked,
+                                         blocked_mask,
                                          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) {
+  uword blocked_mask = ((blocked != kNoRegister) ? 1 << blocked : 0)
+                     | 1 << CTX
+                     | 1 << SPREG
+                     | 1 << FPREG
+                     | ((TMP != kNoRegister) ? 1 << TMP : 0)
+                     | ((TMP2 != kNoRegister) ? 1 << TMP2 : 0)
+                     | ((PP != kNoRegister) ? 1 << PP : 0);
   reg_ = static_cast<Register>(
       resolver_->AllocateScratchRegister(Location::kRegister,
-                                         blocked,
+                                         blocked_mask,
                                          kFirstFreeCpuRegister,
                                          kLastFreeCpuRegister,
                                          &spilled_));
 
   if (spilled_) {
     resolver->SpillScratch(reg_);
   }
 }
 
 
@@ skipping 80 matching lines @@
     threshold = FLAG_optimization_counter_scale * basic_blocks +
         FLAG_min_optimization_counter_threshold;
     if (threshold > FLAG_optimization_counter_threshold) {
       threshold = FLAG_optimization_counter_threshold;
     }
   }
   return threshold;
 }
 
 }  // namespace dart