Compute next field offset correctly.

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 183 matching lines @@
     raw_ = value;                                                              \
     CHECK_HANDLE();                                                            \
   }                                                                            \
  private:  /* NOLINT */                                                        \
   object() : super() {}                                                        \
   BASE_OBJECT_IMPLEMENTATION(object, super)                                    \
   Raw##object* raw_ptr() const {                                               \
     ASSERT(raw() != null());                                                   \
     return raw()->ptr();                                                       \
   }                                                                            \
+  static intptr_t NextFieldOffset() {                                          \
+    return -kWordSize;                                                         \
+  }                                                                            \
   SNAPSHOT_READER_SUPPORT(object)                                              \
   friend class Isolate;                                                        \
   friend class StackFrame;                                                     \
 
 class Object {
  public:
   virtual ~Object() { }
 
   RawObject* raw() const { return raw_; }
   void operator=(RawObject* value) {
@@ skipping 307 matching lines @@
     if (value->IsNewObject() && raw()->IsOldObject() &&
         !raw()->IsRemembered()) {
       raw()->SetRememberedBit();
       Isolate::Current()->store_buffer()->AddObject(raw());
     }
   }
 
   RawObject* raw_;  // The raw object reference.
 
  private:
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static void InitializeObject(uword address, intptr_t id, intptr_t size);
 
   static void RegisterClass(const Class& cls,
                             const String& name,
                             const Library& lib);
   static void RegisterPrivateClass(const Class& cls,
                                    const String& name,
                                    const Library& lib);
 
   /* Initialize the handle based on the raw_ptr in the presence of null. */
@@ skipping 107 matching lines @@
   }
 
   intptr_t next_field_offset() const {
     return raw_ptr()->next_field_offset_in_words_ * kWordSize;
   }
   void set_next_field_offset(intptr_t value_in_bytes) const {
     ASSERT(kWordSize != 0);
     set_next_field_offset_in_words(value_in_bytes / kWordSize);
   }
   void set_next_field_offset_in_words(intptr_t value) const {
-    ASSERT((Utils::IsAligned((value * kWordSize), kObjectAlignment) &&
+    ASSERT((value == -1) ||
+           (Utils::IsAligned((value * kWordSize), kObjectAlignment) &&
             (value == raw_ptr()->instance_size_in_words_)) ||
            (!Utils::IsAligned((value * kWordSize), kObjectAlignment) &&
             ((value + 1) == raw_ptr()->instance_size_in_words_)));
     raw_ptr()->next_field_offset_in_words_ = value;
   }
 
   cpp_vtable handle_vtable() const { return raw_ptr()->handle_vtable_; }
   void set_handle_vtable(cpp_vtable value) const {
     raw_ptr()->handle_vtable_ = value;
   }
@@ skipping 407 matching lines @@
   void set_constants(const Array& value) const;
 
   void set_canonical_types(const Array& value) const;
   RawArray* canonical_types() const;
 
   RawArray* invocation_dispatcher_cache() const;
   void set_invocation_dispatcher_cache(const Array& cache) const;
   RawFunction* CreateInvocationDispatcher(const String& target_name,
                                           const Array& args_desc,
                                           RawFunction::Kind kind) const;
+
   void CalculateFieldOffsets() const;
 
   // Initial value for the cached number of type arguments.
   static const intptr_t kUnknownNumTypeArguments = -1;
 
   int16_t num_type_arguments() const {
     return raw_ptr()->num_type_arguments_;
   }
   void set_num_type_arguments(intptr_t value) const;
 
@@ skipping 41 matching lines @@
     return raw_ptr()->library_prefix_;
   }
   RawString* ident() const { return raw_ptr()->ident_; }
   intptr_t token_pos() const { return raw_ptr()->token_pos_; }
 
   RawString* Name() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawUnresolvedClass));
   }
+
   static RawUnresolvedClass* New(const LibraryPrefix& library_prefix,
                                  const String& ident,
                                  intptr_t token_pos);
 
  private:
   void set_library_prefix(const LibraryPrefix& library_prefix) const;
   void set_ident(const String& ident) const;
   void set_token_pos(intptr_t token_pos) const;
 
   static RawUnresolvedClass* New();
@@ skipping 220 matching lines @@
 
   static RawInstantiatedTypeArguments* New(
       const AbstractTypeArguments& uninstantiated_type_arguments,
       const AbstractTypeArguments& instantiator_type_arguments);
 
  private:
   void set_uninstantiated_type_arguments(
       const AbstractTypeArguments& value) const;
   void set_instantiator_type_arguments(
       const AbstractTypeArguments& value) const;
+
   static RawInstantiatedTypeArguments* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(InstantiatedTypeArguments,
                                    AbstractTypeArguments);
   friend class Class;
 };
 
 
 class PatchClass : public Object {
  public:
   RawClass* patched_class() const { return raw_ptr()->patched_class_; }
   RawClass* source_class() const { return raw_ptr()->source_class_; }
   RawScript* Script() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawPatchClass));
   }
 
   static RawPatchClass* New(const Class& patched_class,
                             const Class& source_class);
 
  private:
   void set_patched_class(const Class& value) const;
   void set_source_class(const Class& value) const;
+
   static RawPatchClass* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(PatchClass, Object);
   friend class Class;
 };
 
 
 class Function : public Object {
  public:
   RawString* name() const { return raw_ptr()->name_; }
@@ skipping 431 matching lines @@
   // Returns true if this function represents a local function.
   bool IsLocalFunction() const {
     return parent_function() != Function::null();
   }
 
   // Returns true if this function represents a signature function without code.
   bool IsSignatureFunction() const {
     return kind() == RawFunction::kSignatureFunction;
   }
 
-
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawFunction));
   }
 
   static RawFunction* New(const String& name,
                           RawFunction::Kind kind,
                           bool is_static,
                           bool is_const,
                           bool is_abstract,
                           bool is_external,
@@ skipping 66 matching lines @@
   void set_is_external(bool value) const;
   void set_parent_function(const Function& value) const;
   void set_owner(const Object& value) const;
   RawFunction* implicit_closure_function() const;
   void set_implicit_closure_function(const Function& value) const;
   RawInstance* implicit_static_closure() const;
   void set_implicit_static_closure(const Instance& closure) const;
   void set_num_optional_parameters(intptr_t value) const;  // Encoded value.
   void set_kind_tag(intptr_t value) const;
   void set_data(const Object& value) const;
+
   static RawFunction* New();
 
   void BuildSignatureParameters(bool instantiate,
                                 NameVisibility name_visibility,
                                 const AbstractTypeArguments& instantiator,
                                 const GrowableObjectArray& pieces) const;
   RawString* BuildSignature(bool instantiate,
                             NameVisibility name_visibility,
                             const AbstractTypeArguments& instantiator) const;
 
@@ skipping 246 matching lines @@
   }
   void set_owner(const Object& value) const {
     StorePointer(&raw_ptr()->owner_, value.raw());
   }
   void set_token_pos(intptr_t token_pos) const {
     raw_ptr()->token_pos_ = token_pos;
   }
   void set_kind_bits(intptr_t value) const {
     raw_ptr()->kind_bits_ = static_cast<uint8_t>(value);
   }
+
   static RawField* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Field, Object);
   friend class Class;
   friend class HeapProfiler;
 };
 
 
 class LiteralToken : public Object {
  public:
@@ skipping 146 matching lines @@
 
   static RawScript* New(const String& url,
                         const String& source,
                         RawScript::Kind kind);
 
  private:
   void set_url(const String& value) const;
   void set_source(const String& value) const;
   void set_kind(RawScript::Kind value) const;
   void set_tokens(const TokenStream& value) const;
+
   static RawScript* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Script, Object);
   friend class Class;
 };
 
 
 class DictionaryIterator : public ValueObject {
  public:
   explicit DictionaryIterator(const Library& library);
@@ skipping 194 matching lines @@
 
 
   // Return Function::null() if function does not exist in libs.
   static RawFunction* GetFunction(const GrowableArray<Library*>& libs,
                                   const char* class_name,
                                   const char* function_name);
 
  private:
   static const int kInitialImportsCapacity = 4;
   static const int kImportsCapacityIncrement = 8;
+
   static RawLibrary* New();
 
   void set_num_imports(intptr_t value) const {
     raw_ptr()->num_imports_ = value;
   }
   RawArray* imports() const { return raw_ptr()->imports_; }
   RawArray* exports() const { return raw_ptr()->exports_; }
   bool HasExports() const;
   RawArray* loaded_scripts() const { return raw_ptr()->loaded_scripts_; }
   RawGrowableObjectArray* metadata() const { return raw_ptr()->metadata_; }
@@ skipping 42 matching lines @@
 
   static RawLibraryPrefix* New(const String& name, const Namespace& import);
 
  private:
   static const int kInitialSize = 2;
   static const int kIncrementSize = 2;
 
   void set_name(const String& value) const;
   void set_imports(const Array& value) const;
   void set_num_imports(intptr_t value) const;
+
   static RawLibraryPrefix* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(LibraryPrefix, Object);
   friend class Class;
 };
 
 
 // A Namespace contains the names in a library dictionary, filtered by
 // the show/hide combinators.
 class Namespace : public Object {
  public:
   RawLibrary* library() const { return raw_ptr()->library_; }
   RawArray* show_names() const { return raw_ptr()->show_names_; }
   RawArray* hide_names() const { return raw_ptr()->hide_names_; }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawNamespace));
   }
 
   bool HidesName(const String& name) const;
   RawObject* Lookup(const String& name) const;
 
   static RawNamespace* New(const Library& library,
                            const Array& show_names,
                            const Array& hide_names);
+
  private:
   static RawNamespace* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Namespace, Object);
   friend class Class;
 };
 
 
 class Instructions : public Object {
  public:
@@ skipping 289 matching lines @@
   // We would have a VisitPointers function here to traverse the
   // exception handler table to visit objects if any in the table.
 
  private:
   // Pick somewhat arbitrary maximum number of exception handlers
   // for a function. This value is used to catch potentially
   // malicious code.
   static const intptr_t kMaxHandlers = 1024 * 1024;
 
   void set_handled_types_data(const Array& value) const;
+
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ExceptionHandlers, Object);
   friend class Class;
 };
 
 
 // Holds deopt information at one deoptimization point. The information consists
 // of two parts:
 //  - first a prefix consiting of kMaterializeObject instructions describing
 //    objects which had their allocation removed as part of AllocationSinking
 //    pass and have to be materialized;
@@ skipping 737 matching lines @@
     return RoundedAllocationSize(sizeof(RawApiError));
   }
 
   static RawApiError* New(const String& message,
                           Heap::Space space = Heap::kNew);
 
   virtual const char* ToErrorCString() const;
 
  private:
   void set_message(const String& message) const;
+
   static RawApiError* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ApiError, Error);
   friend class Class;
 };
 
 
 class LanguageError : public Error {
  public:
   RawString* message() const { return raw_ptr()->message_; }
   static intptr_t message_offset() {
     return OFFSET_OF(RawLanguageError, message_);
   }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawLanguageError));
   }
 
   static RawLanguageError* New(const String& message,
                                Heap::Space space = Heap::kNew);
 
   virtual const char* ToErrorCString() const;
 
  private:
   void set_message(const String& message) const;
+
   static RawLanguageError* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(LanguageError, Error);
   friend class Class;
 };
 
 
 class UnhandledException : public Error {
  public:
   RawInstance* exception() const { return raw_ptr()->exception_; }
@@ skipping 123 matching lines @@
     return FieldAddrAtOffset(field.Offset());
   }
   RawObject** NativeFieldsAddr() const {
     return FieldAddrAtOffset(sizeof(RawObject));
   }
   void SetFieldAtOffset(intptr_t offset, const Object& value) const {
     StorePointer(FieldAddrAtOffset(offset), value.raw());
   }
   bool IsValidFieldOffset(int offset) const;
 
+  static intptr_t NextFieldOffset() {
+    return sizeof(RawInstance);
+  }
+
   // TODO(iposva): Determine if this gets in the way of Smi.
   HEAP_OBJECT_IMPLEMENTATION(Instance, Object);
   friend class Class;
   friend class Closure;
+  friend class SnapshotWriter;
+  friend class StubCode;
   friend class TypedDataView;
 };
 
 
 // AbstractType is an abstract superclass.
 // Subclasses of AbstractType are Type and TypeParameter.
 class AbstractType : public Instance {
  public:
   virtual bool IsFinalized() const;
   virtual bool IsBeingFinalized() const;
@@ skipping 288 matching lines @@
                                intptr_t index,
                                const String& name,
                                const AbstractType& bound,
                                intptr_t token_pos);
 
  private:
   void set_parameterized_class(const Class& value) const;
   void set_name(const String& value) const;
   void set_token_pos(intptr_t token_pos) const;
   void set_type_state(int8_t state) const;
+
   static RawTypeParameter* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(TypeParameter, AbstractType);
   friend class Class;
 };
 
 
 // A BoundedType represents a type instantiated at compile time from a type
 // parameter specifying a bound that either cannot be checked at compile time
 // because the type or the bound are still uninstantiated or can be checked and
@@ skipping 233 matching lines @@
   void operator=(RawSmi* value) {
     raw_ = value;
     CHECK_HANDLE();
   }
   void operator^=(RawObject* value) {
     raw_ = value;
     CHECK_HANDLE();
   }
 
  private:
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static intptr_t ValueFromRaw(uword raw_value) {
     intptr_t value = raw_value;
     ASSERT((value & kSmiTagMask) == kSmiTag);
     return (value >> kSmiTagShift);
   }
+
   static cpp_vtable handle_vtable_;
 
   Smi() : Integer() {}
   BASE_OBJECT_IMPLEMENTATION(Smi, Integer);
 
   friend class Api;  // For ValueFromRaw
   friend class Class;
   friend class Object;
 };
 
@@ skipping 698 matching lines @@
     raw_ptr(str)->external_data_ = data;
   }
 
   static void Finalize(Dart_WeakPersistentHandle handle, void* peer);
 
   static RawExternalOneByteString* ReadFrom(SnapshotReader* reader,
                                             intptr_t object_id,
                                             intptr_t tags,
                                             Snapshot::Kind kind);
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   friend class Class;
   friend class String;
   friend class SnapshotReader;
 };
 
 
 class ExternalTwoByteString : public AllStatic {
  public:
   static int32_t CharAt(const String& str, intptr_t index) {
     return *CharAddr(str, index);
@@ skipping 46 matching lines @@
     raw_ptr(str)->external_data_ = data;
   }
 
   static void Finalize(Dart_WeakPersistentHandle handle, void* peer);
 
   static RawExternalTwoByteString* ReadFrom(SnapshotReader* reader,
                                             intptr_t object_id,
                                             intptr_t tags,
                                             Snapshot::Kind kind);
 
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   friend class Class;
   friend class String;
   friend class SnapshotReader;
 };
 
 
 // Class Bool implements Dart core class bool.
 class Bool : public Instance {
  public:
   bool value() const {
@@ skipping 149 matching lines @@
 
   static intptr_t InstanceSize() {
     return Array::InstanceSize();
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     return Array::InstanceSize(len);
   }
 
  private:
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
+
   static RawImmutableArray* raw(const Array& array) {
     return reinterpret_cast<RawImmutableArray*>(array.raw());
   }
 
   friend class Class;
 };
 
 
 class GrowableObjectArray : public Instance {
  public:
@@ skipping 451 matching lines @@
 
   static bool IsExternalTypedDataView(const Instance& view_obj) {
     const Instance& data = Instance::Handle(Data(view_obj));
     intptr_t cid = data.raw()->GetClassId();
     ASSERT(RawObject::IsTypedDataClassId(cid) ||
            RawObject::IsExternalTypedDataClassId(cid));
     return RawObject::IsExternalTypedDataClassId(cid);
   }
 
   static intptr_t NumberOfFields() {
-    return (kLengthOffset - kTypeArguments);
+    return kLengthOffset;
   }
 
   static intptr_t data_offset() {
     return kWordSize * kDataOffset;
   }
 
   static intptr_t offset_in_bytes_offset() {
     return kWordSize * kOffsetInBytesOffset;
   }
 
   static intptr_t length_offset() {
     return kWordSize * kLengthOffset;
   }
 
   static intptr_t ElementSizeInBytes(intptr_t class_id) {
     ASSERT(RawObject::IsTypedDataViewClassId(class_id));
     return (class_id == kByteDataViewCid) ?
         TypedData::element_size[kTypedDataInt8ArrayCid] :
         TypedData::element_size[class_id - kTypedDataInt8ArrayViewCid];
   }
 
  private:
   enum {
-    kTypeArguments = 1,
-    kDataOffset = 2,
-    kOffsetInBytesOffset = 3,
-    kLengthOffset = 4,
+    kDataOffset = 1,
+    kOffsetInBytesOffset = 2,
+    kLengthOffset = 3,
   };
 };
 
 
 class Closure : public AllStatic {
  public:
   static RawFunction* function(const Instance& closure) {
     return *FunctionAddr(closure);
   }
   static intptr_t function_offset() {
@@ skipping 52 matching lines @@
         reinterpret_cast<intptr_t>(obj.raw_ptr()) + context_offset());
   }
   static void set_function(const Instance& closure,
                            const Function& value) {
     closure.StorePointer(FunctionAddr(closure), value.raw());
   }
   static void set_context(const Instance& closure,
                           const Context& value) {
     closure.StorePointer(ContextAddr(closure), value.raw());
   }
+  static intptr_t NextFieldOffset() {
+    // Indicates this class cannot be extended by dart code.
+    return -kWordSize;
+  }
 
   friend class Class;
 };
 
 
 // Internal stacktrace object used in exceptions for printing stack traces.
 class Stacktrace : public Instance {
  public:
   static const int kPreallocatedStackdepth = 10;
 
@@ skipping 301 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_