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

vm/snapshot.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_SNAPSHOT_H_
 #define VM_SNAPSHOT_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/bitfield.h"
 #include "vm/globals.h"
 #include "vm/growable_array.h"
 #include "vm/isolate.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
 // Forward declarations.
 class AbstractType;
 class AbstractTypeArguments;
 class Class;
 class Heap;
 class Library;
 class Object;
 class ObjectStore;
+class RawArray;
 class RawClass;
+class RawContext;
+class RawDouble;
+class RawField;
+class RawFourByteString;
+class RawFunction;
+class RawImmutableArray;
+class RawLibrary;
+class RawLibraryPrefix;
+class RawMint;
 class RawObject;
+class RawOneByteString;
+class RawScript;
+class RawTokenStream;
+class RawType;
+class RawTypeParameter;
+class RawTypeArguments;
+class RawTwoByteString;
+class RawUnresolvedClass;
 class String;
 
 static const int8_t kSerializedBitsPerByte = 7;
 static const int8_t kMaxSerializedUnsignedValuePerByte = 127;
 static const int8_t kMaxSerializedValuePerByte = 63;
 static const int8_t kMinSerializedValuePerByte = -64;
 static const uint8_t kEndByteMarker = (255 - kMaxSerializedValuePerByte);
 static const int8_t kSerializedByteMask = (1 << kSerializedBitsPerByte) - 1;
 
 // Serialized object header encoding is as follows:
@@ skipping 274 matching lines @@
   RawObject* ReadObject();
 
   RawClass* ReadClassId(intptr_t object_id);
 
   // Add object to backward references.
   void AddBackwardReference(intptr_t id, Object* obj);
 
   // Read a full snap shot.
   void ReadFullSnapshot();
 
+  // Helper functions for creating uninitialized versions
+  // of various object types. These are used when reading a
+  // full snapshot.
+  RawArray* NewArray(intptr_t len);
+  RawImmutableArray* NewImmutableArray(intptr_t len);
+  RawOneByteString* NewOneByteString(intptr_t len);
+  RawTwoByteString* NewTwoByteString(intptr_t len);
+  RawFourByteString* NewFourByteString(intptr_t len);
+  RawTypeArguments* NewTypeArguments(intptr_t len);
+  RawTokenStream* NewTokenStream(intptr_t len);
+  RawContext* NewContext(intptr_t num_variables);
+  RawClass* NewClass(int value);
+  RawMint* NewMint(int64_t value);
+  RawDouble* NewDouble(double value);
+  RawUnresolvedClass* NewUnresolvedClass();
+  RawType* NewType();
+  RawTypeParameter* NewTypeParameter();
+  RawFunction* NewFunction();
+  RawField* NewField();
+  RawLibrary* NewLibrary();
+  RawLibraryPrefix* NewLibraryPrefix();
+  RawScript* NewScript();
+
  private:
+  // Allocate uninitialized objects, this is used when reading a full snapshot.
+  RawObject* AllocateUninitialized(const Class& cls, intptr_t size);
+
   // Internal implementation of ReadObject once the header value is read.
   RawObject* ReadObjectImpl(intptr_t header);
 
   // Read an object that was serialized as an Id (singleton, object store,
   // or an object that was already serialized before).
   RawObject* ReadIndexedObject(intptr_t object_id);
 
   // Read an inlined object from the stream.
   RawObject* ReadInlinedObject(intptr_t object_id);
 
@@ skipping 183 matching lines @@
 
  private:
   SnapshotWriter* writer_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriterVisitor);
 };
 
 }  // namespace dart
 
 #endif  // VM_SNAPSHOT_H_