Compute next field offset correctly.

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 462 matching lines @@
     class_class_ = reinterpret_cast<RawClass*>(address + kHeapObjectTag);
     InitializeObject(address, Class::kClassId, size);
 
     Class fake;
     // Initialization from Class::New<Class>.
     // Directly set raw_ to break a circular dependency: SetRaw will attempt
     // to lookup class class in the class table where it is not registered yet.
     cls.raw_ = class_class_;
     cls.set_handle_vtable(fake.vtable());
     cls.set_instance_size(Class::InstanceSize());
-    cls.set_next_field_offset(Class::InstanceSize());
+    cls.set_next_field_offset(Class::NextFieldOffset());
     cls.set_id(Class::kClassId);
     cls.set_state_bits(0);
     cls.set_is_finalized();
     cls.set_is_type_finalized();
     cls.set_type_arguments_field_offset_in_words(Class::kNoTypeArguments);
     cls.set_num_type_arguments(0);
     cls.set_num_own_type_arguments(0);
     cls.set_num_native_fields(0);
     cls.InitEmptyFields();
     isolate->RegisterClass(cls);
@@ skipping 1161 matching lines @@
   {
     RawObject* raw = Object::Allocate(Class::kClassId,
                                       Class::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   FakeObject fake;
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeObject::InstanceSize());
-  result.set_next_field_offset(FakeObject::InstanceSize());
+  result.set_next_field_offset(FakeObject::NextFieldOffset());
   ASSERT((FakeObject::kClassId != kInstanceCid));
   result.set_id(FakeObject::kClassId);
   result.set_state_bits(0);
   // VM backed classes are almost ready: run checks and resolve class
   // references, but do not recompute size.
   result.set_is_prefinalized();
   result.set_type_arguments_field_offset_in_words(kNoTypeArguments);
   result.set_num_type_arguments(0);
   result.set_num_own_type_arguments(0);
   result.set_num_native_fields(0);
@@ skipping 349 matching lines @@
   return TypeParameter::null();
 }
 
 
 void Class::CalculateFieldOffsets() const {
   Array& flds = Array::Handle(fields());
   const Class& super = Class::Handle(SuperClass());
   intptr_t offset = 0;
   intptr_t type_args_field_offset = kNoTypeArguments;
   if (super.IsNull()) {
-    offset = sizeof(RawObject);
+    offset = Instance::NextFieldOffset();
+    ASSERT(offset > 0);
   } else {
     ASSERT(super.is_finalized() || super.is_prefinalized());
     type_args_field_offset = super.type_arguments_field_offset();
     offset = super.next_field_offset();
     ASSERT(offset > 0);
     // We should never call CalculateFieldOffsets for native wrapper
     // classes, assert this.
     ASSERT(num_native_fields() == 0);
     set_num_native_fields(super.num_native_fields());
   }
   // If the super class is parameterized, use the same type_arguments field,
   // otherwise, if this class is the first in the super chain to be
   // parameterized, introduce a new type_arguments field.
   if (type_args_field_offset == kNoTypeArguments) {
     const TypeArguments& type_params = TypeArguments::Handle(type_parameters());
     if (!type_params.IsNull()) {
       ASSERT(type_params.Length() > 0);
       // The instance needs a type_arguments field.
       type_args_field_offset = offset;
       offset += kWordSize;
     }
   }
   set_type_arguments_field_offset(type_args_field_offset);
-  ASSERT(offset != 0);
+  ASSERT(offset > 0);
   Field& field = Field::Handle();
   intptr_t len = flds.Length();
   for (intptr_t i = 0; i < len; i++) {
     field ^= flds.At(i);
     // Offset is computed only for instance fields.
     if (!field.is_static()) {
       ASSERT(field.Offset() == 0);
       field.SetOffset(offset);
       offset += kWordSize;
     }
@@ skipping 317 matching lines @@
     RawObject* raw = Object::Allocate(Class::kClassId,
                                       Class::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   FakeInstance fake;
   ASSERT(fake.IsInstance());
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeInstance::InstanceSize());
-  result.set_next_field_offset(FakeInstance::InstanceSize());
+  result.set_next_field_offset(FakeInstance::NextFieldOffset());
   result.set_id(index);
   result.set_state_bits(0);
   result.set_type_arguments_field_offset_in_words(kNoTypeArguments);
   result.set_num_type_arguments(kUnknownNumTypeArguments);
   result.set_num_own_type_arguments(kUnknownNumTypeArguments);
   result.set_num_native_fields(0);
   result.set_token_pos(Scanner::kDummyTokenIndex);
   result.InitEmptyFields();
   Isolate::Current()->RegisterClass(result);
   return result.raw();
@@ skipping 11 matching lines @@
 }
 
 
 RawClass* Class::NewSignatureClass(const String& name,
                                    const Function& signature_function,
                                    const Script& script,
                                    intptr_t token_pos) {
   const Class& result = Class::Handle(New(name, script, token_pos));
   // Instances of a signature class can only be closures.
   result.set_instance_size(Closure::InstanceSize());
-  result.set_next_field_offset(Closure::InstanceSize());
+  result.set_next_field_offset(Closure::NextFieldOffset());
   // Signature classes extend the _FunctionImpl class.
   result.set_super_type(Type::Handle(
       Isolate::Current()->object_store()->function_impl_type()));
   result.set_is_synthesized_class();
   result.set_type_arguments_field_offset(Closure::type_arguments_offset());
   if (!signature_function.IsNull()) {
     result.PatchSignatureFunction(signature_function);
   }
   return result.raw();
 }
@@ skipping 51 matching lines @@
                                   int field_count) {
   Class& cls = Class::Handle(library.LookupClass(name));
   if (cls.IsNull()) {
     cls = New(name, Script::Handle(), Scanner::kDummyTokenIndex);
     cls.SetFields(Object::empty_array());
     cls.SetFunctions(Object::empty_array());
     // Set super class to Object.
     cls.set_super_type(Type::Handle(Type::ObjectType()));
     // Compute instance size. First word contains a pointer to a properly
     // sized typed array once the first native field has been set.
-    intptr_t instance_size = sizeof(RawObject) + kWordSize;
+    intptr_t instance_size = sizeof(RawInstance) + kWordSize;
     cls.set_instance_size(RoundedAllocationSize(instance_size));
     cls.set_next_field_offset(instance_size);
     cls.set_num_native_fields(field_count);
     cls.set_is_finalized();
     cls.set_is_type_finalized();
     library.AddClass(cls);
     return cls.raw();
   } else {
     return Class::null();
   }
 }
 
 
 RawClass* Class::NewStringClass(intptr_t class_id) {
   intptr_t instance_size;
+  intptr_t next_field_offset;
   if (class_id == kOneByteStringCid) {
+    next_field_offset = OneByteString::NextFieldOffset();
     instance_size = OneByteString::InstanceSize();
   } else if (class_id == kTwoByteStringCid) {
+    next_field_offset = TwoByteString::NextFieldOffset();
     instance_size = TwoByteString::InstanceSize();
   } else if (class_id == kExternalOneByteStringCid) {
+    next_field_offset = ExternalOneByteString::NextFieldOffset();
     instance_size = ExternalOneByteString::InstanceSize();
   } else {
     ASSERT(class_id == kExternalTwoByteStringCid);
+    next_field_offset = ExternalTwoByteString::NextFieldOffset();
     instance_size = ExternalTwoByteString::InstanceSize();
   }
   Class& result = Class::Handle(New<String>(class_id));
   result.set_instance_size(instance_size);
-  result.set_next_field_offset(instance_size);
+  result.set_next_field_offset(next_field_offset);
   result.set_is_prefinalized();
   return result.raw();
 }
 
 
 RawClass* Class::NewTypedDataClass(intptr_t class_id) {
   ASSERT(RawObject::IsTypedDataClassId(class_id));
   intptr_t instance_size = TypedData::InstanceSize();
   Class& result = Class::Handle(New<TypedData>(class_id));
   result.set_instance_size(instance_size);
-  result.set_next_field_offset(instance_size);
+  result.set_next_field_offset(TypedData::NextFieldOffset());
   result.set_is_prefinalized();
   return result.raw();
 }
 
 
 RawClass* Class::NewTypedDataViewClass(intptr_t class_id) {
   ASSERT(RawObject::IsTypedDataViewClassId(class_id));
   Class& result = Class::Handle(New<Instance>(class_id));
   result.set_instance_size(0);
-  result.set_next_field_offset(0);
+  result.set_next_field_offset(-1);

[Ivan Posva, 2013/11/03 16:08:51]

-kWordSize

[siva, 2013/11/04 16:05:01]

Done.

   return result.raw();
 }
 
 
 RawClass* Class::NewExternalTypedDataClass(intptr_t class_id) {
   ASSERT(RawObject::IsExternalTypedDataClassId(class_id));
   intptr_t instance_size = ExternalTypedData::InstanceSize();
   Class& result = Class::Handle(New<ExternalTypedData>(class_id));
   result.set_instance_size(instance_size);
-  result.set_next_field_offset(instance_size);
+  result.set_next_field_offset(ExternalTypedData::NextFieldOffset());
   result.set_is_prefinalized();
   return result.raw();
 }
 
 
 void Class::set_name(const String& value) const {
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
 }
 
@@ skipping 8236 matching lines @@
     return false;
   }
 
   {
     NoGCScope no_gc;
     // Raw bits compare.
     const intptr_t instance_size = Class::Handle(this->clazz()).instance_size();
     ASSERT(instance_size != 0);
     uword this_addr = reinterpret_cast<uword>(this->raw_ptr());
     uword other_addr = reinterpret_cast<uword>(other.raw_ptr());
-    for (intptr_t offset = sizeof(RawObject);
+    for (intptr_t offset = Instance::NextFieldOffset();
          offset < instance_size;
          offset += kWordSize) {
       if ((*reinterpret_cast<RawObject**>(this_addr + offset)) !=
           (*reinterpret_cast<RawObject**>(other_addr + offset))) {
         return false;
       }
     }
   }
   return true;
 }
@@ skipping 4873 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
 }  // namespace dart