Add mutable double boxes for fields.

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/flow_graph_optimizer.h"
 #include "vm/locations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/resolver.h"
 #include "vm/scopes.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 #include "vm/il_printer.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, propagate_ic_data, true,
     "Propagate IC data from unoptimized to optimized IC calls.");
+DEFINE_FLAG(bool, unbox_double_fields, true, "Support unboxed double fields.");
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, eliminate_type_checks);
 DECLARE_FLAG(bool, trace_optimization);
 DECLARE_FLAG(bool, trace_constant_propagation);
 DECLARE_FLAG(bool, throw_on_javascript_int_overflow);
 
 Definition::Definition()
     : range_(NULL),
       type_(NULL),
       temp_index_(-1),
@@ skipping 90 matching lines @@
     return false;
   }
   CompileType* in_type = value()->Type();
   const intptr_t cid = unary_checks().GetCidAt(0);
   // Performance check: use CheckSmiInstr instead.
   ASSERT(cid != kSmiCid);
   return in_type->is_nullable() && (in_type->ToNullableCid() == cid);
 }
 
 
+bool LoadFieldInstr::IsUnboxedLoad() const {
+  return FLAG_unbox_double_fields
+      && (field() != NULL)
+      && field()->IsUnboxedField();
+}
+
+
+bool LoadFieldInstr::IsPotentialUnboxedLoad() const {
+  return FLAG_unbox_double_fields
+      && (field() != NULL)
+      && field()->IsPotentialUnboxedField();
+}
+
+
+bool StoreInstanceFieldInstr::IsUnboxedStore() const {
+  return FLAG_unbox_double_fields && field().IsUnboxedField();
+}
+
+
+bool StoreInstanceFieldInstr::IsPotentialUnboxedStore() const {
+  return FLAG_unbox_double_fields && field().IsPotentialUnboxedField();
+}
+
+
 bool GuardFieldInstr::AttributesEqual(Instruction* other) const {
   return field().raw() == other->AsGuardField()->field().raw();
 }
 
 
 bool AssertAssignableInstr::AttributesEqual(Instruction* other) const {
   AssertAssignableInstr* other_assert = other->AsAssertAssignable();
   ASSERT(other_assert != NULL);
   // This predicate has to be commutative for DominatorBasedCSE to work.
   // TODO(fschneider): Eliminate more asserts with subtype relation.
@@ skipping 1601 matching lines @@
 }
 
 
 // Shared code generation methods (EmitNativeCode and
 // MakeLocationSummary). Only assembly code that can be shared across all
 // architectures can be used. Machine specific register allocation and code
 // generation is located in intermediate_language_<arch>.cc
 
 #define __ compiler->assembler()->
 
-LocationSummary* GraphEntryInstr::MakeLocationSummary() const {
+LocationSummary* GraphEntryInstr::MakeLocationSummary(bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
-LocationSummary* JoinEntryInstr::MakeLocationSummary() const {
+LocationSummary* JoinEntryInstr::MakeLocationSummary(bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void JoinEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ Bind(compiler->GetJumpLabel(this));
   if (!compiler->is_optimizing()) {
     compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                    deopt_id_,
                                    Scanner::kDummyTokenIndex);
   }
   if (HasParallelMove()) {
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
 }
 
 
-LocationSummary* TargetEntryInstr::MakeLocationSummary() const {
+LocationSummary* TargetEntryInstr::MakeLocationSummary(bool optimizing) const {
   // FlowGraphCompiler::EmitInstructionPrologue is not called for block
   // entry instructions, so this function is unused.  If it becomes
   // reachable, note that the deoptimization descriptor in unoptimized code
   // comes after the point of local register allocation due to pattern
   // matching the edge counter code backwards (as a code reuse convenience
   // on some platforms).
   UNREACHABLE();
   return NULL;
 }
 
 
-LocationSummary* PhiInstr::MakeLocationSummary() const {
+LocationSummary* PhiInstr::MakeLocationSummary(bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void PhiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNREACHABLE();
 }
 
 
-LocationSummary* RedefinitionInstr::MakeLocationSummary() const {
+LocationSummary* RedefinitionInstr::MakeLocationSummary(bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void RedefinitionInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNREACHABLE();
 }
 
 
-LocationSummary* ParameterInstr::MakeLocationSummary() const {
+LocationSummary* ParameterInstr::MakeLocationSummary(bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void ParameterInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNREACHABLE();
 }
 
 
-LocationSummary* ParallelMoveInstr::MakeLocationSummary() const {
+LocationSummary* ParallelMoveInstr::MakeLocationSummary(bool optimizing) const {
   return NULL;
 }
 
 
 void ParallelMoveInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNREACHABLE();
 }
 
 
-LocationSummary* ConstraintInstr::MakeLocationSummary() const {
+LocationSummary* ConstraintInstr::MakeLocationSummary(bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void ConstraintInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNREACHABLE();
 }
 
 
-LocationSummary* MaterializeObjectInstr::MakeLocationSummary() const {
+LocationSummary* MaterializeObjectInstr::MakeLocationSummary(
+    bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void MaterializeObjectInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNREACHABLE();
 }
 
 
-LocationSummary* StoreContextInstr::MakeLocationSummary() const {
+LocationSummary* StoreContextInstr::MakeLocationSummary(bool optimizing) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RegisterLocation(CTX));
   return summary;
 }
 
 
-LocationSummary* PushTempInstr::MakeLocationSummary() const {
+LocationSummary* PushTempInstr::MakeLocationSummary(bool optimizing) const {
   return LocationSummary::Make(1,
                                Location::NoLocation(),
                                LocationSummary::kNoCall);
 }
 
 
 void PushTempInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(!compiler->is_optimizing());
   // Nothing to do.
 }
 
 
-LocationSummary* DropTempsInstr::MakeLocationSummary() const {
+LocationSummary* DropTempsInstr::MakeLocationSummary(bool optimizing) const {
   return LocationSummary::Make(1,
                                Location::SameAsFirstInput(),
                                LocationSummary::kNoCall);
 }
 
 
 void DropTempsInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(!compiler->is_optimizing());
   Register value = locs()->in(0).reg();
   Register result = locs()->out().reg();
@@ skipping 12 matching lines @@
                                        Token::Kind kind,
                                        Value* left,
                                        Value* right,
                                        bool needs_number_check)
     : ComparisonInstr(token_pos, kind, left, right),
       needs_number_check_(needs_number_check) {
   ASSERT((kind == Token::kEQ_STRICT) || (kind == Token::kNE_STRICT));
 }
 
 
-LocationSummary* InstanceCallInstr::MakeLocationSummary() const {
+LocationSummary* InstanceCallInstr::MakeLocationSummary(bool optimizing) const {
   return MakeCallSummary();
 }
 
 
 void InstanceCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ICData& call_ic_data = ICData::ZoneHandle(ic_data()->raw());
   if (!FLAG_propagate_ic_data || !compiler->is_optimizing()) {
     const Array& arguments_descriptor =
         Array::Handle(ArgumentsDescriptor::New(ArgumentCount(),
                                                argument_names()));
@@ skipping 40 matching lines @@
 
 
 bool PolymorphicInstanceCallInstr::HasRecognizedTarget() const {
   return ic_data().HasOneTarget() &&
       (MethodRecognizer::RecognizeKind(
           Function::Handle(ic_data().GetTargetAt(0))) !=
        MethodRecognizer::kUnknown);
 }
 
 
-LocationSummary* StaticCallInstr::MakeLocationSummary() const {
+LocationSummary* StaticCallInstr::MakeLocationSummary(bool optimizing) const {
   return MakeCallSummary();
 }
 
 
 void StaticCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (!compiler->is_optimizing()) {
     // Some static calls can be optimized by the optimizing compiler (e.g. sqrt)
     // and therefore need a deoptimization descriptor.
     compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                    deopt_id(),
@@ skipping 873 matching lines @@
   concatenated = Symbols::New(concatenated);
   return flow_graph->GetConstant(concatenated);
 }
 
 
 InvokeMathCFunctionInstr::InvokeMathCFunctionInstr(
     ZoneGrowableArray<Value*>* inputs,
     intptr_t original_deopt_id,
     MethodRecognizer::Kind recognized_kind)
     : inputs_(inputs),
-      locs_(NULL),
       recognized_kind_(recognized_kind) {
   ASSERT(inputs_->length() == ArgumentCountFor(recognized_kind_));
   for (intptr_t i = 0; i < inputs_->length(); ++i) {
     ASSERT((*inputs)[i] != NULL);
     (*inputs)[i]->set_instruction(this);
     (*inputs)[i]->set_use_index(i);
   }
   deopt_id_ = original_deopt_id;
 }
 
@@ skipping 87 matching lines @@
       UNREACHABLE();
   }
   return kSinRuntimeEntry;
 }
 
 
 MergedMathInstr::MergedMathInstr(ZoneGrowableArray<Value*>* inputs,
                                  intptr_t original_deopt_id,
                                  MergedMathInstr::Kind kind)
     : inputs_(inputs),
-      locs_(NULL),
       kind_(kind) {
   ASSERT(inputs_->length() == InputCountFor(kind_));
   for (intptr_t i = 0; i < inputs_->length(); ++i) {
     ASSERT((*inputs)[i] != NULL);
     (*inputs)[i]->set_instruction(this);
     (*inputs)[i]->set_use_index(i);
   }
   deopt_id_ = original_deopt_id;
 }
 
@@ skipping 12 matching lines @@
     case Token::kTRUNCDIV: return 0;
     case Token::kMOD: return 1;
     default: UNIMPLEMENTED(); return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart