Fix bug with guarded fields and deserialization.

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 1721 matching lines @@
   StorePointer(&raw_ptr()->interfaces_, Object::empty_array().raw());
   StorePointer(&raw_ptr()->constants_, Object::empty_array().raw());
   StorePointer(&raw_ptr()->canonical_types_, Object::empty_array().raw());
   StorePointer(&raw_ptr()->functions_, Object::empty_array().raw());
   StorePointer(&raw_ptr()->fields_, Object::empty_array().raw());
   StorePointer(&raw_ptr()->invocation_dispatcher_cache_,
                Object::empty_array().raw());
 }
 
 
+RawArray* Class::OffsetToFieldMap() const {
+  Array& array = Array::Handle(raw_ptr()->offset_in_words_to_field_);
+  if (array.IsNull()) {
+    ASSERT(is_finalized());
+    const intptr_t length = raw_ptr()->instance_size_in_words_;
+    array = Array::New(length);

[Ivan Posva, 2013/11/01 04:50:05]

This array should be allocated in old space. It will survive as long as this
class exists and classes are allocated in old space.

[Florian Schneider, 2013/11/01 10:39:27]

Done.

+    Class& cls = Class::Handle(this->raw());
+    Array& fields = Array::Handle();
+    Field& f = Field::Handle();
+    while (!cls.IsNull()) {
+      fields = cls.fields();
+      for (intptr_t i = 0; i < fields.Length(); ++i) {
+        f ^= fields.At(i);
+        if (!f.is_static()) {
+          array.SetAt(f.Offset() / kWordSize, f);

[Ivan Posva, 2013/11/01 04:50:05]

f.Offset() >> kWordSizeLog2

[Florian Schneider, 2013/11/01 10:39:27]

Done.

+        }
+      }
+      cls = cls.SuperClass();
+    }
+    StorePointer(&raw_ptr()->offset_in_words_to_field_, array.raw());
+  }
+  return array.raw();
+}
+
+
 bool Class::HasInstanceFields() const {
   const Array& field_array = Array::Handle(fields());
   Field& field = Field::Handle();
   for (intptr_t i = 0; i < field_array.Length(); ++i) {
     field ^= field_array.At(i);
     if (!field.is_static()) {
       return true;
     }
   }
   return false;
@@ skipping 4201 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();
 }
 
 
-void Field::UpdateCid(intptr_t cid) const {
+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)) {
+    // TODO(johnmccutchan): Enable for typed data views.
+    return Field::kNoFixedLength;
+  }
+  UNIMPLEMENTED();
+  return Field::kNoFixedLength;
+}
+
+
+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);
-    return;
+    return false;
   }
 
   if ((cid == guarded_cid()) || ((cid == kNullCid) && is_nullable())) {
     // Class id of the assigned value matches expected class id and nullability.
-    return;
+    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);
   }
 
   // Expected class id or nullability of the field changed.
-  DeoptimizeDependentCode();
+  return true;
 }
 
 
-void Field::UpdateLength(intptr_t list_length) const {
+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;
+    return false;
   }
 
   if (!list_length_changed && !force_invalidate) {
     // List length unchanged.
-    return;
+    return false;
   }
   // Multiple list lengths assigned here, stop tracking length.
   set_guarded_list_length(Field::kNoFixedLength);
-  DeoptimizeDependentCode();
+  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 9563 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
 }  // namespace dart