Split GuardField into GuardFieldType and GuardFieldLength instructions.

runtime/vm/object.cc

 // Copyright (c) 2012, 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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 46 matching lines @@
 DEFINE_FLAG(bool, show_internal_names, false,
     "Show names of internal classes (e.g. \"OneByteString\") in error messages "
     "instead of showing the corresponding interface names (e.g. \"String\")");
 DEFINE_FLAG(bool, trace_disabling_optimized_code, false,
     "Trace disabling optimized code.");
 DEFINE_FLAG(bool, throw_on_javascript_int_overflow, false,
     "Throw an exception when the result of an integer calculation will not "
     "fit into a javascript integer.");
 DEFINE_FLAG(bool, use_field_guards, true, "Guard field cids.");
 DEFINE_FLAG(bool, use_lib_cache, true, "Use library name cache");
+DEFINE_FLAG(bool, trace_field_guards, false, "Trace changes in field's cids.");
 
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, error_on_bad_override);
 DECLARE_FLAG(bool, trace_compiler);
 DECLARE_FLAG(bool, trace_deoptimization);
 DECLARE_FLAG(bool, trace_deoptimization_verbose);
 DECLARE_FLAG(bool, verbose_stacktrace);
 DECLARE_FLAG(charp, coverage_dir);
 DECLARE_FLAG(bool, write_protect_code);
 
@@ skipping 6690 matching lines @@
     result.SetOffset(0);
   }
   result.set_is_final(is_final);
   result.set_is_const(is_const);
   result.set_owner(owner);
   result.set_token_pos(token_pos);
   result.set_has_initializer(false);
   result.set_is_unboxing_candidate(true);
   result.set_guarded_cid(FLAG_use_field_guards ? kIllegalCid : kDynamicCid);
   result.set_is_nullable(FLAG_use_field_guards ? false : true);
+  result.set_guarded_list_length_in_object_offset(Field::kUnknownLengthOffset);
   // Presently, we only attempt to remember the list length for final fields.
   if (is_final && FLAG_use_field_guards) {
     result.set_guarded_list_length(Field::kUnknownFixedLength);
   } else {
     result.set_guarded_list_length(Field::kNoFixedLength);
   }
   result.set_dependent_code(Object::null_array());
   return result.raw();
 }
 
@@ skipping 28 matching lines @@
 intptr_t Field::guarded_list_length() const {
   return Smi::Value(raw_ptr()->guarded_list_length_);
 }
 
 
 void Field::set_guarded_list_length(intptr_t list_length) const {
   raw_ptr()->guarded_list_length_ = Smi::New(list_length);
 }
 
 
+intptr_t Field::guarded_list_length_in_object_offset() const {
+  return raw_ptr()->guarded_list_length_in_object_offset_ + kHeapObjectTag;
+}
+
+
+void Field::set_guarded_list_length_in_object_offset(
+    intptr_t list_length_offset) const {
+  raw_ptr()->guarded_list_length_in_object_offset_ =
+      static_cast<int8_t>(list_length_offset - kHeapObjectTag);
+  ASSERT(guarded_list_length_in_object_offset() == list_length_offset);
+}
+
+
 bool Field::IsUnboxedField() const {
   bool valid_class = (FlowGraphCompiler::SupportsUnboxedDoubles() &&
                       (guarded_cid() == kDoubleCid)) ||
                      (FlowGraphCompiler::SupportsUnboxedSimd128() &&
                       (guarded_cid() == kFloat32x4Cid)) ||
                      (FlowGraphCompiler::SupportsUnboxedSimd128() &&
                       (guarded_cid() == kFloat64x2Cid));
   return is_unboxing_candidate() && !is_final() && !is_nullable() &&
          valid_class;
 }
@@ skipping 141 matching lines @@
 
 
 bool Field::IsUninitialized() const {
   const Instance& value = Instance::Handle(raw_ptr()->value_);
   ASSERT(value.raw() != Object::transition_sentinel().raw());
   return value.raw() == Object::sentinel().raw();
 }
 
 
 static intptr_t GetListLength(const Object& value) {
-  const intptr_t cid = value.GetClassId();
-  ASSERT(RawObject::IsBuiltinListClassId(cid));
-  // Extract list length.
   if (value.IsTypedData()) {
     const TypedData& list = TypedData::Cast(value);
     return list.Length();
   } else if (value.IsArray()) {
     const Array& list = Array::Cast(value);
     return list.Length();
   } else if (value.IsGrowableObjectArray()) {
     // List length is variable.
     return Field::kNoFixedLength;
   } else if (value.IsExternalTypedData()) {
     // TODO(johnmccutchan): Enable for external typed data.
     return Field::kNoFixedLength;
-  } else if (RawObject::IsTypedDataViewClassId(cid)) {
+  } else if (RawObject::IsTypedDataViewClassId(value.GetClassId())) {
     // TODO(johnmccutchan): Enable for typed data views.
     return Field::kNoFixedLength;
   }
-  UNIMPLEMENTED();
   return Field::kNoFixedLength;
 }
 
 
+static intptr_t GetListLengthOffset(intptr_t cid) {
+  if (RawObject::IsTypedDataClassId(cid)) {
+    return TypedData::length_offset();
+  } else if (cid == kArrayCid || cid == kImmutableArrayCid) {
+    return Array::length_offset();
+  } else if (cid == kGrowableObjectArrayCid) {
+    // List length is variable.
+    return Field::kUnknownLengthOffset;
+  } else if (RawObject::IsExternalTypedDataClassId(cid)) {
+    // TODO(johnmccutchan): Enable for external typed data.
+    return Field::kUnknownLengthOffset;
+  } else if (RawObject::IsTypedDataViewClassId(cid)) {
+    // TODO(johnmccutchan): Enable for typed data views.
+    return Field::kUnknownLengthOffset;
+  }
+  return Field::kUnknownLengthOffset;
+}
+
+
+const char* Field::GuardedPropertiesAsCString() const {
+  if (guarded_cid() == kIllegalCid) {
+    return "<?>";
+  } else if (guarded_cid() == kDynamicCid) {
+    return "<*>";
+  }
+
+  const Class& cls = Class::Handle(
+      Isolate::Current()->class_table()->At(guarded_cid()));
+  const char* class_name = String::Handle(cls.Name()).ToCString();
+
+  if (RawObject::IsBuiltinListClassId(guarded_cid()) &&
+      !is_nullable() &&
+      is_final()) {
+    ASSERT(guarded_list_length() != kUnknownFixedLength);
+    if (guarded_list_length() == kNoFixedLength) {
+      return Isolate::Current()->current_zone()->PrintToString(
+          "<%s [*]>", class_name);
+    } else {
+      return Isolate::Current()->current_zone()->PrintToString(
+          "<%s [%" Pd " @%" Pd "]>",
+          class_name,
+          guarded_list_length(),
+          guarded_list_length_in_object_offset());
+    }
+  }
+
+  return Isolate::Current()->current_zone()->PrintToString("<%s %s>",
+    is_nullable() ? "nullable" : "not-nullable",
+    class_name);
+}
+
+
+void Field::InitializeGuardedListLengthInObjectOffset() const {
+  if (needs_length_check() &&
+      (guarded_list_length() != Field::kUnknownFixedLength)) {
+    const intptr_t offset = GetListLengthOffset(guarded_cid());
+    set_guarded_list_length_in_object_offset(offset);
+    ASSERT(offset != Field::kUnknownLengthOffset);
+  } else {
+    set_guarded_list_length_in_object_offset(Field::kUnknownLengthOffset);
+  }
+}
+
+
 bool Field::UpdateGuardedCidAndLength(const Object& value) const {
   const intptr_t cid = value.GetClassId();
-  bool deoptimize = UpdateCid(cid);
-  intptr_t list_length = Field::kNoFixedLength;
-  if ((guarded_cid() != kDynamicCid) &&
-      is_final() && RawObject::IsBuiltinListClassId(cid)) {
-    list_length = GetListLength(value);
-  }
-  deoptimize = UpdateLength(list_length) || deoptimize;
-  if (deoptimize) {
-    DeoptimizeDependentCode();
-  }
-  return deoptimize;
-}
 
-
-bool Field::UpdateCid(intptr_t cid) const {
   if (guarded_cid() == kIllegalCid) {
     // Field is assigned first time.
     set_guarded_cid(cid);
     set_is_nullable(cid == kNullCid);
+
+    // Start tracking length if needed.
+    ASSERT((guarded_list_length() == Field::kUnknownFixedLength) ||
+           (guarded_list_length() == Field::kNoFixedLength));
+    if (needs_length_check()) {
+      ASSERT(guarded_list_length() == Field::kUnknownFixedLength);
+      set_guarded_list_length(GetListLength(value));
+      InitializeGuardedListLengthInObjectOffset();
+    }
+
+    if (FLAG_trace_field_guards) {
+      OS::Print("    => %s\n", GuardedPropertiesAsCString());
+    }
+
     return false;
   }
 
   if ((cid == guarded_cid()) || ((cid == kNullCid) && is_nullable())) {
     // Class id of the assigned value matches expected class id and nullability.
+
+    // If we are tracking length check if it has matches.
+    if (needs_length_check() &&
+        (guarded_list_length() != GetListLength(value))) {
+      ASSERT(guarded_list_length() != Field::kUnknownFixedLength);
+      set_guarded_list_length(Field::kNoFixedLength);
+      set_guarded_list_length_in_object_offset(Field::kUnknownLengthOffset);
+      return true;
+    }
+
+    // Everything matches.
     return false;
   }
 
   if ((cid == kNullCid) && !is_nullable()) {
     // Assigning null value to a non-nullable field makes it nullable.
     set_is_nullable(true);
   } else if ((cid != kNullCid) && (guarded_cid() == kNullCid)) {
     // Assigning non-null value to a field that previously contained only null
     // turns it into a nullable field with the given class id.
     ASSERT(is_nullable());
     set_guarded_cid(cid);
   } else {
     // Give up on tracking class id of values contained in this field.
     ASSERT(guarded_cid() != cid);
     set_guarded_cid(kDynamicCid);
     set_is_nullable(true);
   }
 
+  // If we were tracking length drop collected feedback.
+  if (needs_length_check()) {
+    ASSERT(guarded_list_length() != Field::kUnknownFixedLength);
+    set_guarded_list_length(Field::kNoFixedLength);
+    set_guarded_list_length_in_object_offset(Field::kUnknownLengthOffset);
+  }
+
   // Expected class id or nullability of the field changed.
   return true;
 }
 
 
-bool Field::UpdateLength(intptr_t list_length) const {
-  ASSERT(is_final() || (!is_final() &&
-                        (list_length < Field::kUnknownFixedLength)));
-  ASSERT((list_length == Field::kNoFixedLength) ||
-         (list_length > Field::kUnknownFixedLength));
-  ASSERT(guarded_cid() != kIllegalCid);
-
-  const bool force_invalidate = (guarded_cid() == kDynamicCid) &&
-                                (list_length != Field::kNoFixedLength);
-
-  const bool list_length_unknown =
-      (guarded_list_length() == Field::kUnknownFixedLength);
-  const bool list_length_changed = (guarded_list_length() != list_length);
-
-  if (list_length_unknown && list_length_changed && !force_invalidate) {
-    // List length set for first time.
-    set_guarded_list_length(list_length);
-    return false;
+void Field::RecordStore(const Object& value) const {
+  if (FLAG_trace_field_guards) {
+    OS::Print("Store %s %s <- %s\n",
+              ToCString(),
+              GuardedPropertiesAsCString(),
+              value.ToCString());
   }
 
-  if (!list_length_changed && !force_invalidate) {
-    // List length unchanged.
-    return false;
+  if (UpdateGuardedCidAndLength(value)) {
+    if (FLAG_trace_field_guards) {
+      OS::Print("    => %s\n", GuardedPropertiesAsCString());
+    }
+
+    DeoptimizeDependentCode();
   }
-  // Multiple list lengths assigned here, stop tracking length.
-  set_guarded_list_length(Field::kNoFixedLength);
-  return true;
 }
 
 
 void LiteralToken::set_literal(const String& literal) const {
   StorePointer(&raw_ptr()->literal_, literal.raw());
 }
 
 
 void LiteralToken::set_value(const Object& value) const {
   StorePointer(&raw_ptr()->value_, value.raw());
@@ skipping 11803 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart