Unbox phis that were proven to be of type Double.

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 562 matching lines @@
   UsePosition* use =
       range->finger()->FirstRegisterBeneficialUse(graph_entry->start_pos());
   if (use != NULL) {
     LiveRange* tail = SplitBetween(range, graph_entry->start_pos(), use->pos());
     CompleteRange(tail, Location::kRegister);
   }
   ConvertAllUses(range);
 }
 
 
+static Location::Kind RegisterKindFromPolicy(Location loc) {
+  if (loc.policy() == Location::kRequiresXmmRegister) {
+    return Location::kXmmRegister;
+  } else {
+    return Location::kRegister;
+  }
+}
+
+
+static Location::Kind RegisterKindForResult(Instruction* instr) {
+  if (instr->representation() == kUnboxedDouble) {
+    return Location::kXmmRegister;
+  } else {
+    return Location::kRegister;
+  }
+}
+
+
 //
 // When describing shape of live ranges in comments below we are going to use
 // the following notation:
 //
 //    B    block entry
 //    g g' start and end of goto instruction
 //    i i' start and end of any other instruction
 //    j j' start and end of any other instruction
 
 //    -  body of a use interval
@@ skipping 100 matching lines @@
         MoveOperands* move =
             goto_instr->parallel_move()->MoveOperandsAt(move_idx);
         move->set_dest(Location::PrefersRegister());
         range->AddUse(pos, move->dest_slot());
       }
 
       // All phi resolution moves are connected. Phi's live range is
       // complete.
       AssignSafepoints(range);
 
-      // TODO(vegorov): unboxed double phis.
-      CompleteRange(range, Location::kRegister);
+      CompleteRange(range, RegisterKindForResult(phi));
 
       move_idx++;
     }
   }
 }
 
 
 void FlowGraphAllocator::ProcessEnvironmentUses(BlockEntryInstr* block,
                                                 Instruction* current) {
   ASSERT(current->env() != NULL);
@@ skipping 31 matching lines @@
     const intptr_t vreg = def->ssa_temp_index();
     LiveRange* range = GetLiveRange(vreg);
     range->AddUseInterval(block_start_pos, use_pos);
     range->AddUse(use_pos, &locations[i]);
   }
 
   env->set_locations(locations);
 }
 
 
-static Location::Kind RegisterKindFromPolicy(Location loc) {
-  if (loc.policy() == Location::kRequiresXmmRegister) {
-    return Location::kXmmRegister;
-  } else {
-    return Location::kRegister;
-  }
-}
-
-
-static Location::Kind RegisterKindForResult(Instruction* instr) {
-  if (instr->representation() == kUnboxedDouble) {
-    return Location::kXmmRegister;
-  } else {
-    return Location::kRegister;
-  }
-}
-
-
 // Create and update live ranges corresponding to instruction's inputs,
 // temporaries and output.
 void FlowGraphAllocator::ProcessOneInstruction(BlockEntryInstr* block,
                                                Instruction* current) {
   const intptr_t pos = current->lifetime_position();
   ASSERT(IsInstructionStartPosition(pos));
 
   LocationSummary* locs = current->locs();
 
   // Number of input locations and number of input operands have to agree.
@@ skipping 80 matching lines @@
     //              i  i'
     //              [--)
     //
     // The stack bitmap describes the position i.
     for (intptr_t reg = 0; reg < kNumberOfCpuRegisters; reg++) {
       BlockLocation(Location::RegisterLocation(static_cast<Register>(reg)),
                     pos,
                     pos + 1);
     }
 
+    for (intptr_t reg = 0; reg < kNumberOfXmmRegisters; reg++) {
+      BlockLocation(
+          Location::XmmRegisterLocation(static_cast<XmmRegister>(reg)),
+          pos,
+          pos + 1);
+    }
+
+
 #if defined(DEBUG)
     // Verify that temps, inputs and output were specified as fixed
     // locations.  Every register is blocked now so attempt to
     // allocate will not succeed.
     for (intptr_t j = 0; j < locs->temp_count(); j++) {
       ASSERT(!locs->temp(j).IsUnallocated());
     }
 
     for (intptr_t j = 0; j < locs->input_count(); j++) {
       ASSERT(!locs->in(j).IsUnallocated());
@@ skipping 297 matching lines @@
   return use;
 }
 
 
 UsePosition* AllocationFinger::FirstRegisterUse(intptr_t after) {
   for (UsePosition* use = FirstUseAfter(first_register_use_, after);
        use != NULL;
        use = use->next()) {
     Location* loc = use->location_slot();
     if (loc->IsUnallocated() &&
-        (loc->policy() == Location::kRequiresRegister)) {
+        ((loc->policy() == Location::kRequiresRegister) ||
+        (loc->policy() == Location::kRequiresXmmRegister))) {
       first_register_use_ = use;
       return use;
     }
   }
   return NULL;
 }
 
 
 UsePosition* AllocationFinger::FirstRegisterBeneficialUse(intptr_t after) {
   for (UsePosition* use = FirstUseAfter(first_register_beneficial_use_, after);
@@ skipping 225 matching lines @@
   LiveRange* last_sibling = range;
   while (last_sibling->next_sibling() != NULL) {
     last_sibling = last_sibling->next_sibling();
   }
 
   spill_slots_[idx] = last_sibling->End();
 
   if (register_kind_ == Location::kRegister) {
     range->set_spill_slot(Location::StackSlot(idx));
   } else {
+    // Double spill slots are essentially one (x64) or two (ia32) normal
+    // word size spill slots.  We use the index of the slot with the lowest
+    // address as an index for the double spill slot. In terms of indexes
+    // this relation is inverted: so we have to take the highest index.
+    const intptr_t slot_idx =
+        idx * kDoubleSpillSlotFactor + (kDoubleSpillSlotFactor - 1);
     range->set_spill_slot(
         Location::DoubleStackSlot(
-            cpu_spill_slot_count_ + idx * kDoubleSpillSlotFactor));
+            cpu_spill_slot_count_ + slot_idx));
   }
 
   spilled_.Add(range);
 }
 
 
 void FlowGraphAllocator::MarkAsObjectAtSafepoints(LiveRange* range) {
   intptr_t stack_index = range->spill_slot().stack_index();
   ASSERT(stack_index >= 0);
 
@@ skipping 217 matching lines @@
 
 
 void FlowGraphAllocator::AssignNonFreeRegister(LiveRange* unallocated,
                                                intptr_t reg) {
   intptr_t first_evicted = -1;
   for (intptr_t i = registers_[reg].length() - 1; i >= 0; i--) {
     LiveRange* allocated = registers_[reg][i];
     if (allocated->vreg() < 0) continue;  // Can't be evicted.
     if (EvictIntersection(allocated, unallocated)) {
       // If allocated was not spilled convert all pending uses.
-      if (allocated->assigned_location().IsRegister()) {
+      if (allocated->assigned_location().IsMachineRegister()) {
         ASSERT(allocated->End() <= unallocated->Start());
         ConvertAllUses(allocated);
       }
       registers_[reg][i] = NULL;
       first_evicted = i;
     }
   }
 
   // Remove evicted ranges from the array.
   if (first_evicted != -1) RemoveEvicted(reg, first_evicted);
@@ skipping 443 matching lines @@
     OS::Print("-- [after ssa allocator] ir [%s] -------------\n",
               function.ToFullyQualifiedCString());
     FlowGraphPrinter printer(flow_graph_, true);
     printer.PrintBlocks();
     OS::Print("----------------------------------------------\n");
   }
 }
 
 
 }  // namespace dart