Use special allocation functions for object creation while deserializing from a full snapshot in ...

vm/raw_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_RAW_OBJECT_H_
 #define VM_RAW_OBJECT_H_
 
 #include "platform/assert.h"
 #include "vm/globals.h"
 #include "vm/snapshot.h"
@@ skipping 323 matching lines @@
   intptr_t type_arguments_instance_field_offset_;  // May be kNoTypeArguments.
   intptr_t next_field_offset_;  // Offset of then next instance field.
   intptr_t num_native_fields_;  // Number of native fields in class.
   int8_t class_state_;  // Of type ClassState.
   bool is_const_;
   bool is_interface_;
 
   friend class Object;
   friend class RawInstance;
   friend RawClass* AllocateFakeClass();
+  friend class SnapshotReader;
 };
 
 
 class RawUnresolvedClass : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(UnresolvedClass);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->qualifier_);
   }
   RawString* qualifier_;  // Qualifier for the identifier.
@@ skipping 75 matching lines @@
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->length_);
   }
   RawSmi* length_;
 
   // Variable length data follows here.
   RawAbstractType* types_[0];
   RawObject** to(intptr_t length) {
     return reinterpret_cast<RawObject**>(&ptr()->types_[length - 1]);
   }
+
+  friend class SnapshotReader;
 };
 
 
 class RawInstantiatedTypeArguments : public RawAbstractTypeArguments {
  private:
   RAW_HEAP_OBJECT_IMPLEMENTATION(InstantiatedTypeArguments);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(
         &ptr()->uninstantiated_type_arguments_);
@@ skipping 84 matching lines @@
   }
   RawString* private_key_;  // Key used for private identifiers.
   RawSmi* length_;  // Number of tokens.
 
   // Variable length data follows here.
   RawObject* data_[0];
   RawObject** to(intptr_t length) {
     return reinterpret_cast<RawObject**>(
         &ptr()->data_[length * kNumberOfEntries - 1]);
   }
+
+  friend class SnapshotReader;
 };
 
 
 class RawScript : public RawObject {
  public:
   enum Kind {
     kScript = 0,
     kLibrary,
     kSource
   };
@@ skipping 140 matching lines @@
   Isolate* isolate_;
 
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->parent_); }
   RawContext* parent_;
 
   // Variable length data follows here.
   RawInstance* data_[0];
   RawObject** to(intptr_t num_vars) {
     return reinterpret_cast<RawObject**>(&ptr()->data_[num_vars - 1]);
   }
+
+  friend class SnapshotReader;
 };
 
 
 class RawContextScope : public RawObject {
   RAW_HEAP_OBJECT_IMPLEMENTATION(ContextScope);
 
   // TODO(iposva): Switch to convential enum offset based structure to avoid
   // alignment mishaps.
   struct VariableDesc {
     RawSmi* token_index;
@@ skipping 91 matching lines @@
 
 class RawSmi : public RawInteger {
   RAW_OBJECT_IMPLEMENTATION(Smi);
 };
 
 
 class RawMint : public RawInteger {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Mint);
 
   int64_t value_;
+
+  friend class SnapshotReader;
 };
 
 
 class RawBigint : public RawInteger {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Bigint);
 
   // Note that the structure is not necessarily valid unless tweaked
   // by Bigint::BNAddr().
   BIGNUM bn_;
 
   // Variable length data follows here.
   BN_ULONG data_[0];
 };
 
 
 class RawDouble : public RawNumber {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Double);
 
   double value_;
+
+  friend class SnapshotReader;
 };
 
 
 class RawString : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(String);
 
  protected:
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->length_); }
   RawSmi* length_;
   RawSmi* hash_;
   RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->hash_); }
 };
 
 
 class RawOneByteString : public RawString {
   RAW_HEAP_OBJECT_IMPLEMENTATION(OneByteString);
 
   // Variable length data follows here.
   uint8_t data_[0];
+
+  friend class SnapshotReader;
 };
 
 
 class RawTwoByteString : public RawString {
   RAW_HEAP_OBJECT_IMPLEMENTATION(TwoByteString);
 
   // Variable length data follows here.
   uint16_t data_[0];
+
+  friend class SnapshotReader;
 };
 
 
 class RawFourByteString : public RawString {
   RAW_HEAP_OBJECT_IMPLEMENTATION(FourByteString);
 
   // Variable length data follows here.
   uint32_t data_[0];
+
+  friend class SnapshotReader;
 };
 
 
 template<typename T>
 class ExternalStringData {
  public:
   typedef void Callback(void* peer);
   ExternalStringData(const T* data, void* peer, Callback* callback) :
       data_(data), peer_(peer), callback_(callback) {
   }
@@ skipping 42 matching lines @@
   // Variable length data follows here.
   RawObject** data() {
     uword address_of_length = reinterpret_cast<uword>(&length_);
     return reinterpret_cast<RawObject**>(address_of_length + kWordSize);
   }
   RawObject** to(intptr_t length) {
     return reinterpret_cast<RawObject**>(&ptr()->data()[length - 1]);
   }
 
   friend class RawImmutableArray;
+  friend class SnapshotReader;
 };
 
 
 class RawImmutableArray : public RawArray {
   RAW_HEAP_OBJECT_IMPLEMENTATION(ImmutableArray);
+
+  friend class SnapshotReader;
 };
 
 
 class RawByteBuffer : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(ByteBuffer);
 
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->length_); }
   RawSmi* length_;
   RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->length_); }
   uint8_t* data_;
@@ skipping 51 matching lines @@
   intptr_t type_;  // Uninitialized, simple or complex.
   intptr_t flags_;  // Represents global/local, case insensitive, multiline.
 
   // Variable length data follows here.
   uint8_t data_[0];
 };
 
 }  // namespace dart
 
 #endif  // VM_RAW_OBJECT_H_