Flow graph SIMD changes

runtime/vm/flow_graph_allocator.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/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 625 matching lines @@
   if (loc.policy() == Location::kRequiresFpuRegister) {
     return Location::kFpuRegister;
   } else {
     return Location::kRegister;
   }
 }
 
 
 static Location::Kind RegisterKindForResult(Instruction* instr) {
   if ((instr->representation() == kUnboxedDouble) ||
-      (instr->representation() == kUnboxedMint)) {
+      (instr->representation() == kUnboxedMint) ||
+      (instr->representation() == kUnboxedFloat32x4) ||
+      (instr->representation() == kUnboxedUint32x4)) {
     return Location::kFpuRegister;
   } else {
     return Location::kRegister;
   }
 }
 
 
 //
 // When describing shape of live ranges in comments below we are going to use
 // the following notation:
@@ skipping 932 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
+    // FPU register spill slots are essentially two (x64) or four (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
+    // address as an index for the FPU register 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_ + slot_idx, range->representation()));
+        idx * kFpuRegisterSpillFactor + (kFpuRegisterSpillFactor - 1);
+    Location location;
+    if (range->representation() == kUnboxedFloat32x4) {
+      location = Location::Float32x4StackSlot(cpu_spill_slot_count_ + slot_idx,

[Vyacheslav Egorov (Google), 2013/04/03 14:25:45]

moving this duplicated expression: cpu_spill_slot_count_ + slot_idx up and
storing it in a variable.

you can even make slot_idx to be equal to 

cpu_spill_slot_count_ + idx * ...

[Cutch, 2013/04/04 22:24:06]

Done.

+                                              range->representation());

[Vyacheslav Egorov (Google), 2013/04/03 14:25:45]

I find it confusing that we still pass representation to a location that
obviously has fixed representation. 

Consider making it fixed internally.

[Cutch, 2013/04/04 22:24:06]

Done.

+    } else if (range->representation() == kUnboxedUint32x4) {
+      location = Location::Uint32x4StackSlot(cpu_spill_slot_count_ + slot_idx,
+                                             range->representation());
+    } else {
+      ASSERT((range->representation() == kUnboxedDouble) ||
+             (range->representation() == kUnboxedMint));
+      location = Location::DoubleStackSlot(cpu_spill_slot_count_ + slot_idx,
+                                           range->representation());
+    }
+    range->set_spill_slot(location);
   }
 
   spilled_.Add(range);
 }
 
 
 void FlowGraphAllocator::MarkAsObjectAtSafepoints(LiveRange* range) {
   intptr_t stack_index = range->spill_slot().stack_index();
   ASSERT(stack_index >= 0);
 
@@ skipping 898 matching lines @@
                        unallocated_xmm_,
                        fpu_regs_,
                        blocked_fpu_registers_);
   AllocateUnallocatedRanges();
 
   ResolveControlFlow();
 
   GraphEntryInstr* entry = block_order_[0]->AsGraphEntry();
   ASSERT(entry != NULL);
   intptr_t double_spill_slot_count =
-      spill_slots_.length() * kDoubleSpillSlotFactor;
+      spill_slots_.length() * kFpuRegisterSpillFactor;
   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