Support reusable boxes for Float32x4 fields

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 437 matching lines @@
                             pending_deoptimization_env_);
   info->set_pc_offset(assembler()->CodeSize());
   deopt_infos_.Add(info);
 }
 
 
 // This function must be in sync with FlowGraphCompiler::SaveLiveRegisters
 // 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
     // slow path code (see FlowGraphCompiler::SaveLiveRegisters).
     //
     // Slow path code can have registers at the safepoint.
     if (!locs->always_calls()) {
       RegisterSet* regs = locs->live_registers();
       if (regs->FpuRegisterCount() > 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 =
-            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 776 matching lines @@
 
   for (int i = 0; i < len; i++) {
     sorted->Add(CidTarget(ic_data.GetReceiverClassIdAt(i),
                           &Function::ZoneHandle(ic_data.GetTargetAt(i)),
                           ic_data.GetCountAt(i)));
   }
   sorted->Sort(HighestCountFirst);
 }
 
 }  // namespace dart