Collect type feedback 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 124 matching lines @@
         cid_(other.cid_),
         type_(other.type_) { }
 
   CompileType& operator=(const CompileType& other) {
     is_nullable_ = other.is_nullable_;
     cid_ = other.cid_;
     type_ =  other.type_;
     return *this;
   }
 
+  bool is_nullable() const { return is_nullable_; }
+
   // Return type such that concrete value's type in runtime is guaranteed to
   // be subtype of it.
   const AbstractType* ToAbstractType();
 
   // Return class id such that it is either kDynamicCid or in runtime
   // value is guaranteed to have an equal class id.
   intptr_t ToCid();
 
   // Return class id such that it is either kDynamicCid or in runtime
   // value is guaranteed to be either null or have an equal class id.
@@ skipping 14 matching lines @@
   bool IsAssignableTo(const AbstractType& type) {
     bool is_instance;
     return CanComputeIsInstanceOf(type, kNullable, &is_instance) &&
            is_instance;
   }
 
   // Create a new CompileType representing given combination of class id and
   // abstract type. The pair is assumed to be coherent.
   static CompileType Create(intptr_t cid, const AbstractType& type);
 
+  CompileType CopyNonNullable() const {
+    return CompileType(kNonNullable, cid_, type_);
+  }
+
+  static CompileType CreateNullable(bool is_nullable, intptr_t cid) {
+    return CompileType(is_nullable, cid, NULL);
+  }
+
   // Create a new CompileType representing given abstract type. By default
   // values as assumed to be nullable.
   static CompileType FromAbstractType(const AbstractType& type,
                                        bool is_nullable = kNullable);
 
   // Create a new CompileType representing an value with the given class id.
   // Resulting CompileType is nullable only if cid is kDynamicCid or kNullCid.
   static CompileType FromCid(intptr_t cid);
 
   // Create None CompileType. It is the bottom of the lattice and is used to
@@ skipping 40 matching lines @@
   intptr_t cid_;
   const AbstractType* type_;
 };
 
 
 // Zone allocated wrapper for the CompileType value.
 class ZoneCompileType : public ZoneAllocated {
  public:
   static CompileType* Wrap(const CompileType& type) {
     ZoneCompileType* zone_type = new ZoneCompileType(type);
-    return &zone_type->type_;
+    return zone_type->ToCompileType();
   }
 
- private:
+  CompileType* ToCompileType() {
+    return &type_;
+  }
+
+ protected:
   explicit ZoneCompileType(const CompileType& type) : type_(type) { }
 
   CompileType type_;
 };
 
 
+// ConstrainedCompileType represents a compile type that is computed from
+// another compile type.
+class ConstrainedCompileType : public ZoneCompileType {
+ public:
+  // Recompute compile type.
+  virtual void Update() = 0;
+
+ protected:
+  explicit ConstrainedCompileType(const CompileType& type)
+      : ZoneCompileType(type) { }
+};
+
+
+// NotNullConstrainedCompileType represents not-null constraint applied to
+// the source compile type. Result is non-nullable version of the incomming
+// compile type. It is used to represent compile type propagated downwards
+// from strict comparison with the null constant.
+class NotNullConstrainedCompileType : public ConstrainedCompileType {
+ public:
+  explicit NotNullConstrainedCompileType(CompileType* source)
+      : ConstrainedCompileType(source->CopyNonNullable()), source_(source) { }
+
+  virtual void Update() {
+    type_ = source_->CopyNonNullable();
+  }
+
+ private:
+  CompileType* source_;
+};
+
+
 class Value : public ZoneAllocated {
  public:
   // A forward iterator that allows removing the current value from the
   // underlying use list during iteration.
   class Iterator {
    public:
     explicit Iterator(Value* head) : next_(head) { Advance(); }
     Value* Current() const { return current_; }
     bool Done() const { return current_ == NULL; }
     void Advance() {
@@ skipping 215 matching lines @@
   M(BoxDouble)                                                                 \
   M(UnboxInteger)                                                              \
   M(BoxInteger)                                                                \
   M(BinaryMintOp)                                                              \
   M(ShiftMintOp)                                                               \
   M(UnaryMintOp)                                                               \
   M(CheckArrayBound)                                                           \
   M(Constraint)                                                                \
   M(StringFromCharCode)                                                        \
   M(InvokeMathCFunction)                                                       \
+  M(GuardField)                                                                \
 
 
 #define FORWARD_DECLARATION(type) class type##Instr;
 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; }                                  \
@@ skipping 229 matching lines @@
   friend class UnboxIntegerInstr;
   friend class UnboxDoubleInstr;
   friend class BinaryDoubleOpInstr;
   friend class BinaryMintOpInstr;
   friend class BinarySmiOpInstr;
   friend class UnarySmiOpInstr;
   friend class ShiftMintOpInstr;
   friend class UnaryMintOpInstr;
   friend class MathSqrtInstr;
   friend class CheckClassInstr;
+  friend class GuardFieldInstr;
   friend class CheckSmiInstr;
   friend class CheckArrayBoundInstr;
   friend class CheckEitherNonSmiInstr;
   friend class LICM;
   friend class DoubleToSmiInstr;
   friend class DoubleToDoubleInstr;
   friend class InvokeMathCFunctionInstr;
   friend class FlowGraphOptimizer;
   friend class LoadIndexedInstr;
   friend class StoreIndexedInstr;
+  friend class StoreInstanceFieldInstr;
 
   virtual void RawSetInputAt(intptr_t i, Value* value) = 0;
 
   intptr_t deopt_id_;
   intptr_t lifetime_position_;  // Position used by register allocator.
   Instruction* previous_;
   Instruction* next_;
   Environment* env_;
   intptr_t expr_id_;
 
@@ skipping 1006 matching lines @@
   // its comparison with another comparison that has been removed from the
   // graph but still has uses properly linked into their definition's use
   // list.
   void ReplaceWith(ComparisonInstr* other,
                    ForwardInstructionIterator* ignored);
 
   virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
 
   virtual void PrintTo(BufferFormatter* f) const;
 
+  // Set compile type constrained by the comparison of this branch.
+  // FlowGraphPropagator propagates it downwards into either true or false
+  // successor.
+  void set_constrained_type(ConstrainedCompileType* type) {
+    constrained_type_ = type;
+  }
+
+  // Return compile type constrained by the comparison of this branch.
+  ConstrainedCompileType* constrained_type() const {
+    return constrained_type_;
+  }
+
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value);
 
   ComparisonInstr* comparison_;
   const bool is_checked_;
 
+  ConstrainedCompileType* constrained_type_;
+
   DISALLOW_COPY_AND_ASSIGN(BranchInstr);
 };
 
 
 class StoreContextInstr : public TemplateInstruction<1> {
  public:
   explicit StoreContextInstr(Value* value) {
     SetInputAt(0, value);
   }
 
@@ skipping 964 matching lines @@
   kEmitStoreBarrier
 };
 
 
 class StoreInstanceFieldInstr : public TemplateDefinition<2> {
  public:
   StoreInstanceFieldInstr(const Field& field,
                           Value* instance,
                           Value* value,
                           StoreBarrierType emit_store_barrier)
-      : field_(field), emit_store_barrier_(emit_store_barrier) {
+      : field_(field),
+        emit_store_barrier_(emit_store_barrier) {
     SetInputAt(0, instance);
     SetInputAt(1, value);
   }
 
+  void SetDeoptId(intptr_t deopt_id) {
+    ASSERT(CanDeoptimize());
+    deopt_id_ = deopt_id;
+  }
+
   DECLARE_INSTRUCTION(StoreInstanceField)
   virtual CompileType* ComputeInitialType() const;
 
   const Field& field() const { return field_; }
 
   Value* instance() const { return inputs_[0]; }
   Value* value() const { return inputs_[1]; }
   bool ShouldEmitStoreBarrier() const {
     return value()->NeedsStoreBuffer()
         && (emit_store_barrier_ == kEmitStoreBarrier);
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return true; }
 
  private:
   const Field& field_;
   const StoreBarrierType emit_store_barrier_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreInstanceFieldInstr);
 };
 
 
+class GuardFieldInstr : public TemplateInstruction<1> {
+ public:
+  GuardFieldInstr(Value* value,
+                  const Field& field,
+                  intptr_t deopt_id)
+    : field_(field) {
+    deopt_id_ = deopt_id;
+    SetInputAt(0, value);
+  }
+
+  DECLARE_INSTRUCTION(GuardField)
+
+  virtual intptr_t ArgumentCount() const { return 0; }
+
+  virtual bool CanDeoptimize() const { return true; }
+
+  virtual bool HasSideEffect() const { return false; }
+
+  virtual bool AttributesEqual(Instruction* other) const;
+
+  virtual bool AffectedBySideEffect() const;
+
+  Value* value() const { return inputs_[0]; }
+
+  virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
+
+  virtual void PrintOperandsTo(BufferFormatter* f) const;
+
+  const Field& field() const { return field_; }
+
+ private:
+  const Field& field_;
+
+  DISALLOW_COPY_AND_ASSIGN(GuardFieldInstr);
+};
+
+
 class LoadStaticFieldInstr : public TemplateDefinition<0> {
  public:
   explicit LoadStaticFieldInstr(const Field& field) : field_(field) {}
 
   DECLARE_INSTRUCTION(LoadStaticField);
   virtual CompileType ComputeType() const;
 
   const Field& field() const { return field_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
@@ skipping 373 matching lines @@
 class LoadFieldInstr : public TemplateDefinition<1> {
  public:
   LoadFieldInstr(Value* value,
                  intptr_t offset_in_bytes,
                  const AbstractType& type,
                  bool immutable = false)
       : offset_in_bytes_(offset_in_bytes),
         type_(type),
         result_cid_(kDynamicCid),
         immutable_(immutable),
-        recognized_kind_(MethodRecognizer::kUnknown) {
+        recognized_kind_(MethodRecognizer::kUnknown),
+        field_name_(NULL),
+        field_(NULL) {
     ASSERT(type.IsZoneHandle());  // May be null if field is not an instance.
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(LoadField)
   virtual CompileType ComputeType() const;
 
   Value* value() const { return inputs_[0]; }
   intptr_t offset_in_bytes() const { return offset_in_bytes_; }
   const AbstractType& type() const { return type_; }
@@ skipping 20 matching lines @@
   }
 
   bool IsImmutableLengthLoad() const;
 
   virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
 
   static MethodRecognizer::Kind RecognizedKindFromArrayCid(intptr_t cid);
 
   static bool IsFixedLengthArrayCid(intptr_t cid);
 
+  void set_field_name(const char* name) { field_name_ = name; }
+  const char* field_name() const { return field_name_; }
+
+  Field* field() const { return field_; }
+  void set_field(Field* field) { field_ = field; }
+
  private:
   const intptr_t offset_in_bytes_;
   const AbstractType& type_;
   intptr_t result_cid_;
   const bool immutable_;
 
   MethodRecognizer::Kind recognized_kind_;
 
+  const char* field_name_;
+  Field* field_;
+
   DISALLOW_COPY_AND_ASSIGN(LoadFieldInstr);
 };
 
 
 class StoreVMFieldInstr : public TemplateDefinition<2> {
  public:
   StoreVMFieldInstr(Value* dest,
                     intptr_t offset_in_bytes,
                     Value* value,
                     const AbstractType& type)
@@ skipping 964 matching lines @@
   virtual bool AffectedBySideEffect() const;
 
   Value* value() const { return inputs_[0]; }
 
   const ICData& unary_checks() const { return unary_checks_; }
 
   virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  void set_null_check(bool flag) { null_check_ = flag; }
+
+  bool null_check() const { return null_check_; }
+
  private:
   const ICData& unary_checks_;
 
+  bool null_check_;
+
   DISALLOW_COPY_AND_ASSIGN(CheckClassInstr);
 };
 
 
 class CheckSmiInstr : public TemplateInstruction<1> {
  public:
   CheckSmiInstr(Value* value, intptr_t original_deopt_id) {
     ASSERT(original_deopt_id != Isolate::kNoDeoptId);
     SetInputAt(0, value);
     deopt_id_ = original_deopt_id;
@@ skipping 285 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_