Support reusable boxes for Float32x4 fields

runtime/vm/flow_graph_compiler.cc

Index: runtime/vm/flow_graph_compiler.cc
diff --git a/runtime/vm/flow_graph_compiler.cc b/runtime/vm/flow_graph_compiler.cc
index 6b4f67d46937bc78ba56db36a2463267a6c9c232..9a4897da711297dd40d1c6a7b3ee9748c3d7cc4b 100644
--- a/runtime/vm/flow_graph_compiler.cc
+++ b/runtime/vm/flow_graph_compiler.cc
@@ -455,10 +455,15 @@ void FlowGraphCompiler::AddDeoptIndexAtCall(intptr_t deopt_id,
 // and FlowGraphCompiler::SlowPathEnvironmentFor.
 void FlowGraphCompiler::RecordSafepoint(LocationSummary* locs) {
   if (is_optimizing()) {
+    RegisterSet* registers = locs->live_registers();
+    ASSERT(registers != NULL);
+    const intptr_t kFpuRegisterSpillFactor =
+            kFpuRegisterSize / kWordSize;
+    const intptr_t live_registers_size = registers->CpuRegisterCount() +
+        (registers->FpuRegisterCount() * kFpuRegisterSpillFactor);
     BitmapBuilder* bitmap = locs->stack_bitmap();
     ASSERT(bitmap != NULL);
-    ASSERT(bitmap->Length() <= StackSize());
-    // Pad the bitmap out to describe all the spill slots.
+    ASSERT(bitmap->Length() <= (StackSize() + live_registers_size));

[Florian Schneider, 2014/02/06 12:38:49]

We should comment what's going on here:

Maybe add a comment saying that bitmap maybe larger if there are >1 safepoint at
an instruction.

An instruction may have two safepoints in deferred code (like in this CL). The
call to RecordSafepoint has the side-effect of appending the live registers to
the bitmap. This is why the second call to RecordSafepoint with the same
instruction (and same location summary) sees a bitmap that is larger than
StackSize().

Right now, the second RecordSafepoint then truncates bitmap again to StackSize
and appends the live-registers again. - It works but looks a little strange and
all safe points in one instruction have the same bitmap in the end.

I know I suggested to refactor the code to use only one slow-path code object.
But could you try your previous patch set with this updated assert? I think it
will work, and it may be more concise with two slow-path objects.

[Cutch, 2014/02/06 23:15:38]

Done.

     bitmap->SetLength(StackSize());
 
     // Mark the bits in the stack map in the same order we push registers in
@@ -475,8 +480,6 @@ void FlowGraphCompiler::RecordSafepoint(LocationSummary* locs) {
         //
         // FPU registers have the highest register number at the highest
         // address (i.e., first in the stackmap).
-        const intptr_t kFpuRegisterSpillFactor =
-            kFpuRegisterSize / kWordSize;
         for (intptr_t i = kNumberOfFpuRegisters - 1; i >= 0; --i) {
           FpuRegister reg = static_cast<FpuRegister>(i);
           if (regs->ContainsFpuRegister(reg)) {