Put live register bits in stackmaps.

runtime/vm/flow_graph_allocator.cc

 // Copyright (c) 2012, 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_allocator.h"
 
 #include "vm/bit_vector.h"
 #include "vm/intermediate_language.h"
 #include "vm/il_printer.h"
 #include "vm/flow_graph.h"
@@ skipping 17 matching lines @@
 #else
 #define TRACE_ALLOC(statement)
 #endif
 
 
 static const intptr_t kNoVirtualRegister = -1;
 static const intptr_t kTempVirtualRegister = -2;
 static const intptr_t kIllegalPosition = -1;
 static const intptr_t kMaxPosition = 0x7FFFFFFF;
 
-// Number of stack slots needed for a double spill slot.
-static const intptr_t kDoubleSpillSlotFactor = kDoubleSize / kWordSize;
-
-
 static intptr_t MinPosition(intptr_t a, intptr_t b) {
   return (a < b) ? a : b;
 }
 
 
 static bool IsInstructionStartPosition(intptr_t pos) {
   return (pos & 1) == 0;
 }
 
 
@@ skipping 1711 matching lines @@
 
   TRACE_ALLOC(OS::Print("range [%d, %d) for v%d has been allocated to ",
                         range->Start(), range->End(), range->vreg()));
   TRACE_ALLOC(loc.Print());
   TRACE_ALLOC(OS::Print(":\n"));
 
   for (UsePosition* use = range->first_use(); use != NULL; use = use->next()) {
     ConvertUseTo(use, loc);
   }
 
+  // Add live registers at all safepoints for instructions with slow-path
+  // code.
   if (loc.IsMachineRegister()) {
     for (SafepointPosition* safepoint = range->first_safepoint();
          safepoint != NULL;
          safepoint = safepoint->next()) {
-      safepoint->locs()->live_registers()->Add(loc);
+      if (!safepoint->locs()->always_calls()) {
+        ASSERT(safepoint->locs()->can_call());
+        safepoint->locs()->live_registers()->Add(loc);
+      }
     }
   }
 }
 
 
 void FlowGraphAllocator::AdvanceActiveIntervals(const intptr_t start) {
   for (intptr_t reg = 0; reg < NumberOfRegisters(); reg++) {
     if (registers_[reg].is_empty()) continue;
 
     intptr_t first_evicted = -1;
@@ skipping 323 matching lines @@
 
   PrepareForAllocation(Location::kXmmRegister,
                        kNumberOfXmmRegisters,
                        unallocated_xmm_,
                        xmm_regs_,
                        blocked_xmm_registers_);
   AllocateUnallocatedRanges();
 
   ResolveControlFlow();
 
-  // Reserve spill slots for XMM registers alive across slow path code.
-  // TODO(vegorov): remove this code when safepoints with registers are
-  // implemented.
-  intptr_t deferred_xmm_spills = 0;
-  for (intptr_t i = 0; i < safepoints_.length(); i++) {
-    if (!safepoints_[i]->locs()->always_calls()) {
-      const intptr_t count =
-          safepoints_[i]->locs()->live_registers()->xmm_regs_count();
-      if (count > deferred_xmm_spills) deferred_xmm_spills = count;
-    }
-  }
-
   GraphEntryInstr* entry = block_order_[0]->AsGraphEntry();
   ASSERT(entry != NULL);
-  entry->set_spill_slot_count(
-      (deferred_xmm_spills + spill_slots_.length()) * kDoubleSpillSlotFactor +
-      cpu_spill_slot_count_);
+  intptr_t double_spill_slot_count =
+      spill_slots_.length() * kDoubleSpillSlotFactor;
+  entry->set_spill_slot_count(cpu_spill_slot_count_ + double_spill_slot_count);
 
   if (FLAG_print_ssa_liveranges) {
     const Function& function = flow_graph_.parsed_function().function();
 
     OS::Print("-- [after ssa allocator] ranges [%s] ---------\n",
               function.ToFullyQualifiedCString());
     PrintLiveRanges();
     OS::Print("----------------------------------------------\n");
 
     OS::Print("-- [after ssa allocator] ir [%s] -------------\n",
               function.ToFullyQualifiedCString());
     FlowGraphPrinter printer(flow_graph_, true);
     printer.PrintBlocks();
     OS::Print("----------------------------------------------\n");
   }
 }
 
 
 }  // namespace dart