Add mutable double boxes for fields.

runtime/vm/intermediate_language.h

 // 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.
 
 #ifndef VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 693 matching lines @@
 FOR_EACH_INSTRUCTION(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
 
 
 // Functions required in all concrete instruction classes.
 #define DECLARE_INSTRUCTION(type)                                              \
   virtual Tag tag() const { return k##type; }                                  \
   virtual void Accept(FlowGraphVisitor* visitor);                              \
   virtual type##Instr* As##type() { return this; }                             \
   virtual const char* DebugName() const { return #type; }                      \
-  virtual LocationSummary* MakeLocationSummary() const;                        \
+  virtual LocationSummary* MakeLocationSummary(bool optimizing) const;         \
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);                    \
 
 
 class Instruction : public ZoneAllocated {
  public:
 #define DECLARE_TAG(type) k##type,
   enum Tag {
     FOR_EACH_INSTRUCTION(DECLARE_TAG)
   };
 #undef DECLARE_TAG
 
   Instruction()
       : deopt_id_(Isolate::Current()->GetNextDeoptId()),
         lifetime_position_(-1),
         previous_(NULL),
         next_(NULL),
         env_(NULL),
+        locs_(NULL),
         place_id_(kNoPlaceId) { }
 
   virtual Tag tag() const = 0;
 
   intptr_t deopt_id() const {
     ASSERT(CanDeoptimize() || CanBecomeDeoptimizationTarget());
     return deopt_id_;
   }
 
   ICData* GetICData(const Array& ic_data_array) const;
@@ skipping 81 matching lines @@
 
 #define INSTRUCTION_TYPE_CHECK(type)                                           \
   bool Is##type() { return (As##type() != NULL); }                             \
   virtual type##Instr* As##type() { return NULL; }
 FOR_EACH_INSTRUCTION(INSTRUCTION_TYPE_CHECK)
 #undef INSTRUCTION_TYPE_CHECK
 
   // Returns structure describing location constraints required
   // to emit native code for this instruction.
   virtual LocationSummary* locs() {
-    // TODO(vegorov): This should be pure virtual method.
-    // However we are temporary using NULL for instructions that
-    // were not converted to the location based code generation yet.
-    return NULL;
+    ASSERT(locs_ != NULL);
+    return locs_;
   }
 
-  virtual LocationSummary* MakeLocationSummary() const = 0;
+  virtual LocationSummary* MakeLocationSummary(bool is_optimizing) const = 0;
+
+  void InitializeLocationSummary(bool optimizing) {
+    ASSERT(locs_ == NULL);
+    locs_ = MakeLocationSummary(optimizing);
+  }
 
   static LocationSummary* MakeCallSummary();
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     UNIMPLEMENTED();
   }
 
   Environment* env() const { return env_; }
   void SetEnvironment(Environment* deopt_env);
   void RemoveEnvironment();
@@ skipping 96 matching lines @@
 
   virtual bool MayThrow() const = 0;
 
  protected:
   // Fetch deopt id without checking if this computation can deoptimize.
   intptr_t GetDeoptId() const {
     return deopt_id_;
   }
 
  private:
+  friend class FlowGraphPrinter;
   friend class Definition;  // Needed for InsertBefore, InsertAfter.
 
   // Classes that set or read deopt_id_.
   friend class UnboxIntegerInstr;
   friend class UnboxDoubleInstr;
   friend class UnboxFloat32x4Instr;
   friend class UnboxInt32x4Instr;
   friend class BinaryDoubleOpInstr;
   friend class BinaryFloat32x4OpInstr;
   friend class Float32x4ZeroInstr;
@@ skipping 54 matching lines @@
 
   enum {
     kNoPlaceId = -1
   };
 
   intptr_t deopt_id_;
   intptr_t lifetime_position_;  // Position used by register allocator.
   Instruction* previous_;
   Instruction* next_;
   Environment* env_;
+  LocationSummary* locs_;
   intptr_t place_id_;
 
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
 
 template<intptr_t N>
 class TemplateInstruction: public Instruction {
  public:
-  TemplateInstruction<N>() : locs_(NULL) { }
+  TemplateInstruction<N>() : inputs_() { }
 
   virtual intptr_t InputCount() const { return N; }
   virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
-  virtual LocationSummary* locs() {
-    if (locs_ == NULL) {
-      locs_ = MakeLocationSummary();
-    }
-    return locs_;
-  }
-
  protected:
   EmbeddedArray<Value*, N> inputs_;
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     inputs_[i] = value;
   }
-
-  LocationSummary* locs_;
 };
 
 
 class MoveOperands : public ZoneAllocated {
  public:
   MoveOperands(Location dest, Location src) : dest_(dest), src_(src) { }
 
   Location src() const { return src_; }
   Location dest() const { return dest_; }
 
@@ skipping 852 matching lines @@
 
   const intptr_t index_;
   BlockEntryInstr* block_;
 
   DISALLOW_COPY_AND_ASSIGN(ParameterInstr);
 };
 
 
 class PushArgumentInstr : public Definition {
  public:
-  explicit PushArgumentInstr(Value* value) : locs_(NULL) {
+  explicit PushArgumentInstr(Value* value) {
     SetInputAt(0, value);
     set_use_kind(kEffect);  // Override the default.
   }
 
   DECLARE_INSTRUCTION(PushArgument)
 
   intptr_t InputCount() const { return 1; }
   Value* InputAt(intptr_t i) const {
     ASSERT(i == 0);
     return value_;
   }
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual CompileType ComputeType() const;
 
   Value* value() const { return value_; }
 
-  virtual LocationSummary* locs() {
-    if (locs_ == NULL) {
-      locs_ = MakeLocationSummary();
-    }
-    return locs_;
-  }
-
   virtual intptr_t Hashcode() const {
     UNREACHABLE();
     return 0;
   }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool MayThrow() const { return false; }
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     ASSERT(i == 0);
     value_ = value;
   }
 
   Value* value_;
-  LocationSummary* locs_;
 
   DISALLOW_COPY_AND_ASSIGN(PushArgumentInstr);
 };
 
 
 inline Definition* Instruction::ArgumentAt(intptr_t index) const {
   return PushArgumentAt(index)->value()->definition();
 }
 
 
@@ skipping 137 matching lines @@
 
   // Parallel move that will be used by linear scan register allocator to
   // connect live ranges at the end of the block and resolve phis.
   ParallelMoveInstr* parallel_move_;
 };
 
 
 template<intptr_t N>
 class TemplateDefinition : public Definition {
  public:
-  TemplateDefinition<N>() : locs_(NULL) { }
+  TemplateDefinition<N>() : inputs_() { }
 
   virtual intptr_t InputCount() const { return N; }
   virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
-  // Returns a structure describing the location constraints required
-  // to emit native code for this definition.
-  LocationSummary* locs() {
-    if (locs_ == NULL) {
-      locs_ = MakeLocationSummary();
-    }
-    return locs_;
-  }
-
  protected:
   EmbeddedArray<Value*, N> inputs_;
 
  private:
   friend class BranchInstr;
   friend class IfThenElseInstr;
 
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     inputs_[i] = value;
   }
-
-  LocationSummary* locs_;
 };
 
 
 struct BranchLabels {
   Label* true_label;
   Label* false_label;
   Label* fall_through;
 };
 
 
@@ skipping 81 matching lines @@
 
   virtual EffectSet Effects() const {
     return comparison()->Effects();
   }
 
   ComparisonInstr* comparison() const { return comparison_; }
   void SetComparison(ComparisonInstr* comp);
 
   bool is_checked() const { return is_checked_; }
 
-  virtual LocationSummary* locs() {
-    if (comparison()->locs_ == NULL) {
-      LocationSummary* summary = comparison()->MakeLocationSummary();
-      // Branches don't produce a result.
-      summary->set_out(Location::NoLocation());
-      // The back-end expects the location summary to be stored in the
-      // comparison.
-      comparison()->locs_ = summary;
-    }
-    return comparison()->locs_;
-  }
-
   virtual intptr_t DeoptimizationTarget() const {
     return comparison()->DeoptimizationTarget();
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t i) const {
     return comparison()->RequiredInputRepresentation(i);
   }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
@@ skipping 862 matching lines @@
   Value* InputAt(intptr_t i) const { return comparison()->InputAt(i); }
 
   virtual bool CanDeoptimize() const {
     return comparison()->CanDeoptimize();
   }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     return comparison()->CanBecomeDeoptimizationTarget();
   }
 
-  virtual LocationSummary* locs() {
-    if (comparison()->locs_ == NULL) {
-      LocationSummary* summary = MakeLocationSummary();
-      // The back-end expects the location summary to be stored in the
-      // comparison.
-      comparison()->locs_ = summary;
-    }
-    return comparison()->locs_;
-  }
-
   virtual intptr_t DeoptimizationTarget() const {
     return comparison()->DeoptimizationTarget();
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t i) const {
     return comparison()->RequiredInputRepresentation(i);
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
@@ skipping 286 matching lines @@
   kNoStoreBarrier,
   kEmitStoreBarrier
 };
 
 
 class StoreInstanceFieldInstr : public TemplateDefinition<2> {
  public:
   StoreInstanceFieldInstr(const Field& field,
                           Value* instance,
                           Value* value,
-                          StoreBarrierType emit_store_barrier)
+                          StoreBarrierType emit_store_barrier,
+                          bool initialization = false)
       : field_(field),
-        emit_store_barrier_(emit_store_barrier) {
+        emit_store_barrier_(emit_store_barrier),
+        initialization_(initialization) {
     SetInputAt(kInstancePos, instance);
     SetInputAt(kValuePos, value);
   }
 
   DECLARE_INSTRUCTION(StoreInstanceField)
 
   enum {
     kInstancePos = 0,
     kValuePos = 1
   };
 
   Value* instance() const { return inputs_[kInstancePos]; }
   Value* value() const { return inputs_[kValuePos]; }
 
   virtual CompileType* ComputeInitialType() const;
 
   const Field& field() const { return field_; }
 
   bool ShouldEmitStoreBarrier() const {
     return value()->NeedsStoreBuffer()
         && (emit_store_barrier_ == kEmitStoreBarrier);
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
+  // May require a deoptimziation target for input conversions.

[srdjan, 2013/12/13 18:13:17]

s/deoptimziation/deoptimization/

[Florian Schneider, 2013/12/16 13:08:09]

Done.

+  virtual intptr_t DeoptimizationTarget() const {
+    return deopt_id_;

[srdjan, 2013/12/13 18:13:17]

return GetDeoptId() (similar to other places).

[Florian Schneider, 2013/12/16 13:08:09]

Done.

+  }
+
   // Currently CSE/LICM don't operate on any instructions that can be affected
   // by stores/loads. LoadOptimizer handles loads separately. Hence stores
   // are marked as having no side-effects.
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual bool MayThrow() const { return false; }
 
+  bool IsUnboxedStore() const;
+
+  bool IsPotentialUnboxedStore() const;
+
+  virtual Representation RequiredInputRepresentation(intptr_t index) const {
+    ASSERT(index == 0 || index == 1);

[srdjan, 2013/12/13 18:13:17]

Add parentheses please. Introducing an abbreviation for that: APP :-).

[Florian Schneider, 2013/12/16 13:08:09]

Done.

+    if (index == 1 && IsUnboxedStore()) return kUnboxedDouble;

[srdjan, 2013/12/13 18:13:17]

APP

[Florian Schneider, 2013/12/16 13:08:09]

Again? :)

+    return kTagged;
+  }
+
  private:
+  friend class FlowGraphOptimizer;  // For ASSERT(initialization_).
+
   bool CanValueBeSmi() const {
     const intptr_t cid = value()->Type()->ToNullableCid();
     // Write barrier is skipped for nullable and non-nullable smis.
     ASSERT(cid != kSmiCid);
     return (cid == kDynamicCid);
   }
 
   const Field& field_;
   const StoreBarrierType emit_store_barrier_;
+  const bool initialization_;
 

[srdjan, 2013/12/13 18:13:17]

Please add brief comment what initialization_ means. Personally, I think Boolean
variables are more readable if they are prefixed with is_ or has_. In this case
is_initialization_.

[Florian Schneider, 2013/12/16 13:08:09]

Done.

   DISALLOW_COPY_AND_ASSIGN(StoreInstanceFieldInstr);
 };
 
 
 class GuardFieldInstr : public TemplateInstruction<1> {
  public:
   GuardFieldInstr(Value* value,
                   const Field& field,
                   intptr_t deopt_id)
     : field_(field) {
@@ skipping 459 matching lines @@
     return values_->length();
   }
 
   virtual Value* InputAt(intptr_t i) const {
     return (*values_)[i];
   }
 
   virtual bool CanDeoptimize() const { return false; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
-  LocationSummary* locs() {
-    UNREACHABLE();
-    return NULL;
-  }
-
   Location* locations() { return locations_; }
   void set_locations(Location* locations) { locations_ = locations; }
 
   virtual bool MayThrow() const { return false; }
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     (*values_)[i] = value;
   }
 
@@ skipping 195 matching lines @@
 
   Value* instance() const { return inputs_[0]; }
   intptr_t offset_in_bytes() const { return offset_in_bytes_; }
   const AbstractType& type() const { return type_; }
   void set_result_cid(intptr_t value) { result_cid_ = value; }
   intptr_t result_cid() const { return result_cid_; }
 
   const Field* field() const { return field_; }
   void set_field(const Field* field) { field_ = field; }
 
+  virtual Representation representation() const {
+    return IsUnboxedLoad() ? kUnboxedDouble : kTagged;

[Cutch, 2013/12/13 19:48:43]

Can we not hardcode kUnboxedDouble as the representation of unboxed loads and
stores? It would be better if the representation was based on the guarded field
type.

[Florian Schneider, 2013/12/16 13:08:09]

Yes. I agree. I'd like to generalize the approach in a separate CL to avoid to
much complication for now.

+  }
+
+  bool IsUnboxedLoad() const;
+
+  bool IsPotentialUnboxedLoad() const;
+
   void set_recognized_kind(MethodRecognizer::Kind kind) {
     recognized_kind_ = kind;
   }
 
   MethodRecognizer::Kind recognized_kind() const {
     return recognized_kind_;
   }
 
   DECLARE_INSTRUCTION(LoadField)
   virtual CompileType ComputeType() const;
@@ skipping 2381 matching lines @@
   virtual intptr_t DeoptimizationTarget() const { return deopt_id_; }
 
   virtual intptr_t InputCount() const {
     return inputs_->length();
   }
 
   virtual Value* InputAt(intptr_t i) const {
     return (*inputs_)[i];
   }
 
-  // Returns a structure describing the location constraints required
-  // to emit native code for this definition.
-  LocationSummary* locs() {
-    if (locs_ == NULL) {
-      locs_ = MakeLocationSummary();
-    }
-    return locs_;
-  }
-
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     InvokeMathCFunctionInstr* other_invoke = other->AsInvokeMathCFunction();
     return other_invoke->recognized_kind() == recognized_kind();
   }
 
   virtual bool MayThrow() const { return false; }
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     (*inputs_)[i] = value;
   }
 
   ZoneGrowableArray<Value*>* inputs_;
 
-  LocationSummary* locs_;
-
   const MethodRecognizer::Kind recognized_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(InvokeMathCFunctionInstr);
 };
 
 
 class MergedMathInstr : public Definition {
  public:
   enum Kind {
     kTruncDivMod,
@@ skipping 62 matching lines @@
   }
 
   virtual intptr_t DeoptimizationTarget() const { return deopt_id_; }
 
   // Returns the result index for one of the merged instructjons
   static intptr_t ResultIndexOf(MethodRecognizer::Kind kind);
   static intptr_t ResultIndexOf(Token::Kind token);
 
   DECLARE_INSTRUCTION(MergedMath)
 
-  // Returns a structure describing the location constraints required
-  // to emit native code for this definition.
-  LocationSummary* locs() {
-    if (locs_ == NULL) {
-      locs_ = MakeLocationSummary();
-    }
-    return locs_;
-  }
-
   virtual bool AllowsCSE() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     MergedMathInstr* other_invoke = other->AsMergedMath();
     return other_invoke->kind() == kind();
   }
 
   virtual bool MayThrow() const { return false; }
 
   static const char* KindToCString(MergedMathInstr::Kind kind) {
     if (kind == kTruncDivMod) return "TruncDivMod";
     if (kind == kSinCos) return "SinCos";
     UNIMPLEMENTED();
     return "";
   }
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     (*inputs_)[i] = value;
   }
 
   ZoneGrowableArray<Value*>* inputs_;
-  LocationSummary* locs_;
   MergedMathInstr::Kind kind_;
 
   DISALLOW_COPY_AND_ASSIGN(MergedMathInstr);
 };
 
 
 class CheckClassInstr : public TemplateInstruction<1> {
  public:
   CheckClassInstr(Value* value,
                   intptr_t deopt_id,
@@ skipping 322 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_