Collect type feedback for fields.

runtime/vm/object.cc

Index: runtime/vm/object.cc
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index 7484200b7257a5b0881fee51e4894218731bd255..a85caefda5f6f54bbc60ed568e6a13e47f8cc93a 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -3227,7 +3227,13 @@ void Function::SetCode(const Code& value) const {
 
 void Function::SwitchToUnoptimizedCode() const {
   ASSERT(HasOptimizedCode());
+
   const Code& current_code = Code::Handle(CurrentCode());
+
+  if (PcDescriptors::Handle(current_code.pc_descriptors()).Length() == 0) {
+    return;
+  }
+
   if (FLAG_trace_disabling_optimized_code) {
     OS::Print("Disabling optimized code: '%s' entry: %#"Px"\n",
       ToFullyQualifiedCString(),
@@ -4687,6 +4693,9 @@ RawField* Field::New(const String& name,
   result.set_owner(owner);
   result.set_token_pos(token_pos);
   result.set_has_initializer(false);
+  result.set_guarded_cid(kIllegalCid);
+  result.set_is_nullable(false);
+  result.set_dependent_code(Array::Handle());
   return result.raw();
 }
 
@@ -4699,6 +4708,7 @@ RawField* Field::Clone(const Class& new_owner) const {
   const PatchClass& clone_owner =
       PatchClass::Handle(PatchClass::New(new_owner, owner));
   clone.set_owner(clone_owner);
+  clone.set_dependent_code(Array::Handle());
   if (!clone.is_static()) {
     clone.SetOffset(0);
   }
@@ -4728,6 +4738,161 @@ const char* Field::ToCString() const {
 }
 
 
+RawArray* Field::dependent_code() const {
+  return raw_ptr()->dependent_code_;
+}
+
+
+void Field::set_dependent_code(const Array& array) const {
+  raw_ptr()->dependent_code_ = array.raw();
+}
+
+
+void Field::RegisterDependentCode(const Code& code) const {
+  const Array& dependent = Array::Handle(dependent_code());
+
+  if (!dependent.IsNull()) {
+    for (intptr_t i = 0; i < dependent.Length(); i++) {
+      if (dependent.At(i) == Code::null()) {
+        dependent.SetAt(i, code);
+        return;
+      }
+    }
+  }
+
+  intptr_t length = dependent.IsNull() ? 0 : dependent.Length();
+  const Array& new_dependent = Array::Handle(
+      Array::Grow(dependent, length + 1, Heap::kOld));
+  new_dependent.SetAt(length, code);
+  set_dependent_code(new_dependent);
+}
+
+
+void Field::UnregisterDependentCode(const Code& code) const {
+  const Array& dependent = Array::Handle(dependent_code());
+  if (dependent.IsNull()) {
+    return;
+  }
+
+  intptr_t pos = 0;
+  Code& dependent_code_object = Code::Handle();
+  for (intptr_t i = 0; i < dependent.Length(); i++) {
+    dependent_code_object ^= dependent.At(i);
+    if (dependent_code_object.IsNull() ||
+        (dependent_code_object.raw() == code.raw())) {
+      continue;
+    }
+
+    if (pos != i) {
+      dependent.SetAt(pos++, dependent_code_object);
+    }
+  }
+
+  if (pos == 0) {
+    set_dependent_code(Array::Handle());
+  } else {
+    Code& null_handle = Code::Handle();
+    for (intptr_t i = pos; i < dependent.Length(); i++) {
+      dependent.SetAt(i, null_handle);
+    }
+  }
+}
+
+
+static void UnregisterDependentCodeBeforeDeopt(const Code& code) {
+  const Array& fields = Array::Handle(code.guarded_fields());
+
+  if (fields.IsNull()) {
+    return;
+  }
+
+  Field& field = Field::Handle();
+  for (intptr_t i = 0; i < fields.Length(); i++) {
+    field ^= fields.At(i);
+    field.UnregisterDependentCode(code);
+  }
+
+  code.set_guarded_fields(Array::Handle());
+}
+
+
+static bool ShouldDeoptimize(const Array& dependent_code, const Code& code) {
+  if (!code.is_optimized()) {
+    return false;
+  }
+
+  for (intptr_t i = 0; i < dependent_code.Length(); i++) {
+    if (code.raw() == dependent_code.At(i)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+
+void Field::DeoptimizeDependentCode() const {
+  const Array& code_objects = Array::Handle(dependent_code());
+
+  if (code_objects.IsNull()) {
+    return;
+  }
+  set_dependent_code(Array::Handle());
+
+  // First deoptimize all dependent methods on the stack.
+  Code& code = Code::Handle();
+  {
+    DartFrameIterator iterator;
+    StackFrame* frame = iterator.NextFrame();
+    while (frame != NULL) {
+      code = frame->LookupDartCode();
+      if (ShouldDeoptimize(code_objects, code)) {
+        UnregisterDependentCodeBeforeDeopt(code);
+        DeoptimizeAt(code, frame->pc());
+      }
+      frame = iterator.NextFrame();
+    }
+  }
+
+  Function& function = Function::Handle();
+  for (intptr_t i = 0; i < code_objects.Length(); i++) {
+    code ^= code_objects.At(i);
+    function ^= code.function();
+    UnregisterDependentCodeBeforeDeopt(code);
+    if (function.HasOptimizedCode()) {
+      function.SwitchToUnoptimizedCode();
+    }
+  }
+}
+
+
+void Field::UpdateCid(intptr_t cid) const {
+  if (guarded_cid() == kIllegalCid) {
+    set_guarded_cid(cid);
+    set_is_nullable(cid == kNullCid);
+    return;
+  }
+
+  if ((cid == guarded_cid()) ||
+      ((cid == kNullCid) && is_nullable())) {
+    return;
+  }
+
+  if ((cid == kNullCid) && !is_nullable()) {
+    set_is_nullable(true);
+  } else if ((cid != kNullCid) && (guarded_cid() == kNullCid)) {
+    ASSERT(is_nullable());
+    set_guarded_cid(cid);
+  } else {
+    ASSERT(guarded_cid() != cid);
+    set_guarded_cid(kDynamicCid);
+    set_is_nullable(true);
+  }
+
+  DeoptimizeDependentCode();
+}
+
+
 void LiteralToken::set_literal(const String& literal) const {
   StorePointer(&raw_ptr()->literal_, literal.raw());
 }
@@ -7464,6 +7629,16 @@ void Code::set_comments(const Code::Comments& comments) const {
 }
 
 
+RawArray* Code::guarded_fields() const {
+  return raw_ptr()->guarded_fields_;
+}
+
+
+void Code::set_guarded_fields(const Array& guarded_fields) const {
+  raw_ptr()->guarded_fields_ = guarded_fields.raw();
+}
+
+
 RawCode* Code::New(intptr_t pointer_offsets_length) {
   if (pointer_offsets_length < 0 || pointer_offsets_length > kMaxElements) {
     // This should be caught before we reach here.
@@ -7481,6 +7656,7 @@ RawCode* Code::New(intptr_t pointer_offsets_length) {
     result.set_is_optimized(false);
     result.set_is_alive(true);
     result.set_comments(Comments::New(0));
+    result.set_guarded_fields(Array::Handle());
   }
   return result.raw();
 }