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 13 matching lines @@
 namespace dart {
 
 DECLARE_FLAG(bool, code_comments);
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, intrinsify);
 DECLARE_FLAG(bool, propagate_ic_data);
 DECLARE_FLAG(bool, report_usage_count);
 DECLARE_FLAG(int, optimization_counter_threshold);
 DECLARE_FLAG(bool, use_cha);
 DECLARE_FLAG(bool, use_osr);
-
+DEFINE_FLAG(bool, enable_simd_inline, true,
+    "Enable inlining of SIMD related method calls.");
 
 // Assign locations to incoming arguments, i.e., values pushed above spill slots
 // with PushArgument.  Recursively allocates from outermost to innermost
 // environment.
 void CompilerDeoptInfo::AllocateIncomingParametersRecursive(
     Environment* env,
     intptr_t* stack_height) {
   if (env == NULL) return;
   AllocateIncomingParametersRecursive(env->outer(), stack_height);
   for (Environment::ShallowIterator it(env); !it.Done(); it.Advance()) {
@@ skipping 403 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.
+    // An instruction may have two safepoints in deferred code. 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 that StackSize(). It will never be larger than StackSize() +
+    // live_registers_size.
+    ASSERT(bitmap->Length() <= (StackSize() + live_registers_size));
+    // The first safepoint will grow the bitmap to be the size of StackSize()
+    // but the second safepoint will truncate the bitmap and append the
+    // live registers to it again. The bitmap produced by both calls will
+    // be the same.
     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