Fix bug in ParallelMoveResolver::EmitSwap: implement swaps of FPU spill slots.

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 61 matching lines @@
   intptr_t slot_ix = 0;
   Environment* current = deoptimization_env_;
 
   // For the innermost environment, call the virtual return builder.
   BuildReturnAddress(builder, current->function(), slot_ix++);
 
   // For the innermost environment, set outgoing arguments and the locals.
   for (intptr_t i = current->Length() - 1;
        i >= current->fixed_parameter_count();
        i--) {
-    builder->AddCopy(current->LocationAt(i), slot_ix++);
+    builder->AddCopy(current->ValueAt(i), current->LocationAt(i), slot_ix++);
   }
 
   // PC marker and caller FP.
   builder->AddPcMarker(current->function(), slot_ix++);
   builder->AddCallerFp(slot_ix++);
 
   Environment* previous = current;
   current = current->outer();
   while (current != NULL) {
     // For any outer environment the deopt id is that of the call instruction
     // which is recorded in the outer environment.
     builder->AddReturnAddressAfter(current->function(),
                                    current->deopt_id(),
                                    slot_ix++);
 
     // The values of outgoing arguments can be changed from the inlined call so
     // we must read them from the previous environment.
     for (intptr_t i = previous->fixed_parameter_count() - 1; i >= 0; i--) {
-      builder->AddCopy(previous->LocationAt(i), slot_ix++);
+      builder->AddCopy(previous->ValueAt(i),
+                       previous->LocationAt(i),
+                       slot_ix++);
     }
 
     // Set the locals, note that outgoing arguments are not in the environment.
     for (intptr_t i = current->Length() - 1;
          i >= current->fixed_parameter_count();
          i--) {
-      builder->AddCopy(current->LocationAt(i), slot_ix++);
+      builder->AddCopy(current->ValueAt(i),
+                       current->LocationAt(i),
+                       slot_ix++);
     }
 
     // PC marker and caller FP.
     builder->AddPcMarker(current->function(), slot_ix++);
     builder->AddCallerFp(slot_ix++);
 
     // Iterate on the outer environment.
     previous = current;
     current = current->outer();
   }
   // The previous pointer is now the outermost environment.
   ASSERT(previous != NULL);
 
   // For the outermost environment, set caller PC.
   builder->AddCallerPc(slot_ix++);
 
   // For the outermost environment, set the incoming arguments.
   for (intptr_t i = previous->fixed_parameter_count() - 1; i >= 0; i--) {
-    builder->AddCopy(previous->LocationAt(i), slot_ix++);
+    builder->AddCopy(previous->ValueAt(i), previous->LocationAt(i), slot_ix++);
   }
 
   const DeoptInfo& deopt_info = DeoptInfo::Handle(builder->CreateDeoptInfo());
   return deopt_info.raw();
 }
 
 
 FlowGraphCompiler::FlowGraphCompiler(Assembler* assembler,
                                      const FlowGraph& flow_graph,
                                      bool is_optimizing)
@@ skipping 271 matching lines @@
       RegisterSet* regs = locs->live_registers();
       if (regs->fpu_regs_count() > 0) {
         // Denote FPU registers with 0 bits in the stackmap.  Based on the
         // assumption that there are normally few live FPU registers, this
         // encoding is simpler and roughly as compact as storing a separate
         // count of FPU registers.
         //
         // FPU registers have the highest register number at the highest
         // address (i.e., first in the stackmap).
         const intptr_t kFpuRegisterSpillFactor =
-            FlowGraphAllocator::kFpuRegisterSpillFactor;
+            kFpuRegisterSize / kWordSize;
         for (intptr_t i = kNumberOfFpuRegisters - 1; i >= 0; --i) {
           FpuRegister reg = static_cast<FpuRegister>(i);
           if (regs->ContainsFpuRegister(reg)) {
             for (intptr_t j = 0; j < kFpuRegisterSpillFactor; ++j) {
               bitmap->Set(bitmap->Length(), false);
             }
           }
         }
       }
       // General purpose registers have the lowest register number at the
@@ skipping 507 matching lines @@
       EmitSwap(index);
       return;
     }
   }
 
   // This move is not blocked.
   EmitMove(index);
 }
 
 
+bool ParallelMoveResolver::IsScratchLocation(Location loc) {
+  for (int i = 0; i < moves_.length(); ++i) {
+    if (moves_[i]->Blocks(loc)) {
+      return false;
+    }
+  }
+
+  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 scratch = -1;
+  for (intptr_t reg = 0; reg < register_count; 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++) {
+      if (blocked != reg) {
+        scratch = reg;
+      }
+    }
+  } 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,
+                                         &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,
+                                         &spilled_));
+
+  if (spilled_) {
+    resolver->SpillScratch(reg_);
+  }
+}
+
+
+ParallelMoveResolver::ScratchRegisterScope::~ScratchRegisterScope() {
+  if (spilled_) {
+    resolver_->RestoreScratch(reg_);
+  }
+}
+
+
 intptr_t FlowGraphCompiler::ElementSizeFor(intptr_t cid) {
   if (RawObject::IsExternalTypedDataClassId(cid)) {
     return ExternalTypedData::ElementSizeInBytes(cid);
   } else if (RawObject::IsTypedDataClassId(cid)) {
     return TypedData::ElementSizeInBytes(cid);
   }
   switch (cid) {
     case kArrayCid:
     case kImmutableArrayCid:
       return Array::kBytesPerElement;
@@ skipping 80 matching lines @@
     if (i != largest_ix) {
       // Swap.
       CidTarget temp = (*sorted)[i];
       (*sorted)[i] = (*sorted)[largest_ix];
       (*sorted)[largest_ix] = temp;
     }
   }
 }
 
 }  // namespace dart