Add mutable double boxes for fields.

runtime/vm/flow_graph_optimizer.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_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 23 matching lines @@
     "Print constant propagation and useless code elimination.");
 DEFINE_FLAG(bool, trace_optimization, false, "Print optimization details.");
 DEFINE_FLAG(bool, trace_range_analysis, false, "Trace range analysis progress");
 DEFINE_FLAG(bool, truncating_left_shift, true,
     "Optimize left shift to truncate if possible");
 DEFINE_FLAG(bool, use_cha, true, "Use class hierarchy analysis.");
 DEFINE_FLAG(bool, trace_load_optimization, false,
     "Print live sets for load optimization pass.");
 DEFINE_FLAG(bool, enable_simd_inline, true,
     "Enable inlining of SIMD related method calls.");
+DEFINE_FLAG(int, getter_setter_ratio, 10,
+    "Ratio of getter/setter usage used for double field unboxing heuristics");
 DECLARE_FLAG(bool, eliminate_type_checks);
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, trace_type_check_elimination);
 
 
 static bool ShouldInlineSimd() {
 #if defined(TARGET_ARCH_MIPS)
   return false;
 #elif defined(TARGET_ARCH_ARM)
   return CPUFeatures::neon_supported() && FLAG_enable_simd_inline;
@@ skipping 3470 matching lines @@
     ASSERT((cid == kOneByteStringCid) || (cid == kTwoByteStringCid) ||
            (cid == kExternalOneByteStringCid) ||
            (cid == kGrowableObjectArrayCid) ||
            (cid == kImmutableArrayCid) || (cid == kArrayCid));
     ConstantInstr* cid_instr = new ConstantInstr(Smi::Handle(Smi::New(cid)));
     ReplaceCall(call, cid_instr);
   }
 }
 
 
+void FlowGraphOptimizer::VisitStoreInstanceField(
+    StoreInstanceFieldInstr* instr) {
+  if (instr->IsUnboxedStore()) {
+    ASSERT(instr->is_initialization_);
+    // Determine if this field should be unboxed based on the usage of getter
+    // and setter functions: The heuristic requires that the setter has a
+    // usage count of at least 1/kGetterSetterRatio of the getter usage count.
+    // This is to avoid unboxing fields where the setter is never or rarely
+    // executed.
+    const Field& field = Field::ZoneHandle(instr->field().raw());
+    const String& field_name = String::Handle(field.name());
+    class Class& owner = Class::Handle(field.owner());
+    const Function& getter =
+        Function::Handle(owner.LookupGetterFunction(field_name));
+    const Function& setter =
+        Function::Handle(owner.LookupSetterFunction(field_name));
+    bool result = !getter.IsNull()
+               && !setter.IsNull()
+               && (setter.usage_counter() > 0)
+               && (FLAG_getter_setter_ratio * setter.usage_counter() >
+                   getter.usage_counter());
+    if (!result) {
+      field.set_is_unboxing_candidate(false);
+      field.DeoptimizeDependentCode();
+    } else {
+      FlowGraph::AddToGuardedFields(flow_graph_->guarded_fields(), &field);
+    }
+  }
+}
+
+
 bool FlowGraphOptimizer::TryInlineInstanceSetter(InstanceCallInstr* instr,
                                                  const ICData& unary_ic_data) {
   ASSERT((unary_ic_data.NumberOfChecks() > 0) &&
       (unary_ic_data.num_args_tested() == 1));
   if (FLAG_enable_type_checks) {
     // Checked mode setters are inlined like normal methods by conventional
     // inlining.
     return false;
   }
 
@@ skipping 10 matching lines @@
   Function& target = Function::Handle();
   intptr_t class_id;
   unary_ic_data.GetOneClassCheckAt(0, &class_id, &target);
   if (target.kind() != RawFunction::kImplicitSetter) {
     // Non-implicit setter are inlined like normal method calls.
     return false;
   }
   // Inline implicit instance setter.
   const String& field_name =
       String::Handle(Field::NameFromSetter(instr->function_name()));
-  const Field& field = Field::Handle(GetField(class_id, field_name));
+  const Field& field = Field::ZoneHandle(GetField(class_id, field_name));
   ASSERT(!field.IsNull());
 
   if (InstanceCallNeedsClassCheck(instr)) {
     AddReceiverCheck(instr);
   }
   StoreBarrierType needs_store_barrier = kEmitStoreBarrier;
   if (ArgIsAlways(kSmiCid, *instr->ic_data(), 1)) {
     InsertBefore(instr,
                  new CheckSmiInstr(new Value(instr->ArgumentAt(1)),
                                    instr->deopt_id()),
@@ skipping 10 matching lines @@
                  instr->env(),
                  Definition::kEffect);
   }
 
   // Field guard was detached.
   StoreInstanceFieldInstr* store = new StoreInstanceFieldInstr(
       field,
       new Value(instr->ArgumentAt(0)),
       new Value(instr->ArgumentAt(1)),
       needs_store_barrier);
+
+  if (store->IsUnboxedStore()) {
+    FlowGraph::AddToGuardedFields(flow_graph_->guarded_fields(), &field);
+  }
+
   // Discard the environment from the original instruction because the store
   // can't deoptimize.
   instr->RemoveEnvironment();
   ReplaceCall(instr, store);
   return true;
 }
 
 
 // Range analysis for smi values.
 class RangeAnalysis : public ValueObject {
@@ skipping 4470 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *fields);
   }
 }
 
 
 }  // namespace dart