Add support for TypedData in full snapshot.

runtime/vm/snapshot.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/snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 275 matching lines @@
   // instance of it. The individual fields will be read later.
   if (SerializedHeaderData::decode(class_header) == kInstanceObjectId) {
     Instance& result = Instance::ZoneHandle(isolate(), Instance::null());
     AddBackRef(object_id, &result, kIsNotDeserialized);
 
     cls_ ^= ReadObjectImpl();  // Read class information.
     ASSERT(!cls_.IsNull());
     intptr_t instance_size = cls_.instance_size();
     ASSERT(instance_size > 0);
     if (kind_ == Snapshot::kFull) {
-      result ^= AllocateUninitialized(cls_, instance_size);
+      result ^= AllocateUninitialized(cls_.id(), instance_size);
     } else {
       result ^= Object::Allocate(cls_.id(), instance_size, HEAP_SPACE(kind_));
     }
     return result.raw();
   }
   ASSERT((class_header & kSmiTagMask) != kSmiTag);
   cls_ = LookupInternalClass(class_header);
   ASSERT(!cls_.IsNull());
 
   // Similarly Array and ImmutableArray objects are also similarly only
@@ skipping 110 matching lines @@
   // Setup native resolver for bootstrap impl.
   Bootstrap::SetupNativeResolver();
 }
 
 
 #define ALLOC_NEW_OBJECT_WITH_LEN(type, class_obj, length)                     \
   ASSERT(kind_ == Snapshot::kFull);                                            \
   ASSERT(isolate()->no_gc_scope_depth() != 0);                                 \
   cls_ = class_obj;                                                            \
   Raw##type* obj = reinterpret_cast<Raw##type*>(                               \
-      AllocateUninitialized(cls_, type::InstanceSize(length)));                \
+      AllocateUninitialized(cls_.id(), type::InstanceSize(length)));           \
   obj->ptr()->length_ = Smi::New(length);                                      \
   return obj;                                                                  \
 
 
 RawArray* SnapshotReader::NewArray(intptr_t len) {
   ALLOC_NEW_OBJECT_WITH_LEN(Array, object_store()->array_class(), len);
 }
 
 
 RawImmutableArray* SnapshotReader::NewImmutableArray(intptr_t len) {
@@ skipping 22 matching lines @@
                             Object::type_arguments_class(),
                             len);
 }
 
 
 RawTokenStream* SnapshotReader::NewTokenStream(intptr_t len) {
   ASSERT(kind_ == Snapshot::kFull);
   ASSERT(isolate()->no_gc_scope_depth() != 0);
   cls_ = Object::token_stream_class();
   stream_ = reinterpret_cast<RawTokenStream*>(
-      AllocateUninitialized(cls_, TokenStream::InstanceSize()));
+      AllocateUninitialized(cls_.id(), TokenStream::InstanceSize()));
   cls_ = isolate()->class_table()->At(kExternalTypedDataUint8ArrayCid);
   uint8_t* array = const_cast<uint8_t*>(CurrentBufferAddress());
   ASSERT(array != NULL);
   Advance(len);
   data_ = reinterpret_cast<RawExternalTypedData*>(
-      AllocateUninitialized(cls_, ExternalTypedData::InstanceSize()));
+      AllocateUninitialized(cls_.id(), ExternalTypedData::InstanceSize()));
   data_.SetData(array);
   data_.SetLength(len);
   stream_.SetStream(data_);
   return stream_.raw();
 }
 
 
 RawContext* SnapshotReader::NewContext(intptr_t num_variables) {
   ASSERT(kind_ == Snapshot::kFull);
   ASSERT(isolate()->no_gc_scope_depth() != 0);
   cls_ = Object::context_class();
   RawContext* obj = reinterpret_cast<RawContext*>(
-      AllocateUninitialized(cls_, Context::InstanceSize(num_variables)));
+      AllocateUninitialized(cls_.id(), Context::InstanceSize(num_variables)));
   obj->ptr()->num_variables_ = num_variables;
   return obj;
 }
 
 
 RawClass* SnapshotReader::NewClass(intptr_t class_id) {
   ASSERT(kind_ == Snapshot::kFull);
   ASSERT(isolate()->no_gc_scope_depth() != 0);
   if (class_id < kNumPredefinedCids) {
     ASSERT((class_id >= kInstanceCid) &&
            (class_id <= kNullCid));
     return isolate()->class_table()->At(class_id);
   }
   cls_ = Object::class_class();
   RawClass* obj = reinterpret_cast<RawClass*>(
-      AllocateUninitialized(cls_, Class::InstanceSize()));
+      AllocateUninitialized(cls_.id(), Class::InstanceSize()));
   Instance fake;
   obj->ptr()->handle_vtable_ = fake.vtable();
   cls_ = obj;
   cls_.set_id(class_id);
   isolate()->RegisterClassAt(class_id, cls_);
   return cls_.raw();
 }
 
 
 RawInstance* SnapshotReader::NewInstance() {
   ASSERT(kind_ == Snapshot::kFull);
   ASSERT(isolate()->no_gc_scope_depth() != 0);
   cls_ = object_store()->object_class();
   RawInstance* obj = reinterpret_cast<RawInstance*>(
-      AllocateUninitialized(cls_, Instance::InstanceSize()));
+      AllocateUninitialized(cls_.id(), Instance::InstanceSize()));
   return obj;
 }
 
 
 RawMint* SnapshotReader::NewMint(int64_t value) {
   ASSERT(kind_ == Snapshot::kFull);
   ASSERT(isolate()->no_gc_scope_depth() != 0);
   cls_ = object_store()->mint_class();
   RawMint* obj = reinterpret_cast<RawMint*>(
-      AllocateUninitialized(cls_, Mint::InstanceSize()));
+      AllocateUninitialized(cls_.id(), Mint::InstanceSize()));
   obj->ptr()->value_ = value;
   return obj;
 }
 
 
 RawBigint* SnapshotReader::NewBigint(const char* hex_string) {
   ASSERT(kind_ == Snapshot::kFull);
   ASSERT(isolate()->no_gc_scope_depth() != 0);
   cls_ = object_store()->bigint_class();
   intptr_t bigint_length = BigintOperations::ComputeChunkLength(hex_string);
   RawBigint* obj = reinterpret_cast<RawBigint*>(
-      AllocateUninitialized(cls_, Bigint::InstanceSize(bigint_length)));
+      AllocateUninitialized(cls_.id(), Bigint::InstanceSize(bigint_length)));
   obj->ptr()->allocated_length_ = bigint_length;
   obj->ptr()->signed_length_ = bigint_length;
   BigintOperations::FromHexCString(hex_string, Bigint::Handle(obj));
   return obj;
 }
 
 
 RawDouble* SnapshotReader::NewDouble(double value) {
   ASSERT(kind_ == Snapshot::kFull);
   ASSERT(isolate()->no_gc_scope_depth() != 0);
   cls_ = object_store()->double_class();
   RawDouble* obj = reinterpret_cast<RawDouble*>(
-      AllocateUninitialized(cls_, Double::InstanceSize()));
+      AllocateUninitialized(cls_.id(), Double::InstanceSize()));
   obj->ptr()->value_ = value;
   return obj;
 }
 
 
+RawTypedData* SnapshotReader::NewTypedData(intptr_t class_id, intptr_t len) {
+  ASSERT(kind_ == Snapshot::kFull);
+  ASSERT(isolate()->no_gc_scope_depth() != 0);
+  const intptr_t lengthInBytes = len * TypedData::ElementSizeInBytes(class_id);
+  RawTypedData* obj = reinterpret_cast<RawTypedData*>(
+      AllocateUninitialized(class_id, TypedData::InstanceSize(lengthInBytes)));
+  obj->ptr()->length_ = Smi::New(len);
+  return obj;
+}
+
+
 #define ALLOC_NEW_OBJECT(type, class_obj)                                      \
   ASSERT(kind_ == Snapshot::kFull);                                            \
   ASSERT(isolate()->no_gc_scope_depth() != 0);                                 \
   cls_ = class_obj;                                                            \
   return reinterpret_cast<Raw##type*>(                                         \
-      AllocateUninitialized(cls_, type::InstanceSize()));                      \
+      AllocateUninitialized(cls_.id(), type::InstanceSize()));                 \
 
 
 RawUnresolvedClass* SnapshotReader::NewUnresolvedClass() {
   ALLOC_NEW_OBJECT(UnresolvedClass, Object::unresolved_class_class());
 }
 
 
 RawType* SnapshotReader::NewType() {
   ALLOC_NEW_OBJECT(Type, object_store()->type_class());
 }
@@ skipping 74 matching lines @@
                    object_store()->growable_object_array_class());
 }
 
 
 RawFloat32x4* SnapshotReader::NewFloat32x4(float v0, float v1, float v2,
                                            float v3) {
   ASSERT(kind_ == Snapshot::kFull);
   ASSERT(isolate()->no_gc_scope_depth() != 0);
   cls_ = object_store()->float32x4_class();
   RawFloat32x4* obj = reinterpret_cast<RawFloat32x4*>(
-      AllocateUninitialized(cls_, Float32x4::InstanceSize()));
+      AllocateUninitialized(cls_.id(), Float32x4::InstanceSize()));
   obj->ptr()->value_[0] = v0;
   obj->ptr()->value_[1] = v1;
   obj->ptr()->value_[2] = v2;
   obj->ptr()->value_[3] = v3;
   return obj;
 }
 
 
 RawInt32x4* SnapshotReader::NewInt32x4(uint32_t v0, uint32_t v1, uint32_t v2,
                                          uint32_t v3) {
   ASSERT(kind_ == Snapshot::kFull);
   ASSERT(isolate()->no_gc_scope_depth() != 0);
   cls_ = object_store()->int32x4_class();
   RawInt32x4* obj = reinterpret_cast<RawInt32x4*>(
-      AllocateUninitialized(cls_, Int32x4::InstanceSize()));
+      AllocateUninitialized(cls_.id(), Int32x4::InstanceSize()));
   obj->ptr()->value_[0] = v0;
   obj->ptr()->value_[1] = v1;
   obj->ptr()->value_[2] = v2;
   obj->ptr()->value_[3] = v3;
   return obj;
 }
 
 
 RawFloat64x2* SnapshotReader::NewFloat64x2(double v0, double v1) {
   ASSERT(kind_ == Snapshot::kFull);
   ASSERT(isolate()->no_gc_scope_depth() != 0);
   cls_ = object_store()->float64x2_class();
   RawFloat64x2* obj = reinterpret_cast<RawFloat64x2*>(
-      AllocateUninitialized(cls_, Float64x2::InstanceSize()));
+      AllocateUninitialized(cls_.id(), Float64x2::InstanceSize()));
   obj->ptr()->value_[0] = v0;
   obj->ptr()->value_[1] = v1;
   return obj;
 }
 
 
 RawApiError* SnapshotReader::NewApiError() {
   ALLOC_NEW_OBJECT(ApiError, Object::api_error_class());
 }
 
@@ skipping 37 matching lines @@
   } else if (SerializedHeaderTag::decode(class_header) == kObjectId) {
     intptr_t class_id = SerializedHeaderData::decode(class_header);
     if (IsObjectStoreClassId(class_id)) {
       return isolate()->class_table()->At(class_id);  // get singleton class.
     }
   }
   return Class::null();
 }
 
 
-RawObject* SnapshotReader::AllocateUninitialized(const Class& cls,
+RawObject* SnapshotReader::AllocateUninitialized(intptr_t class_id,
                                                  intptr_t size) {
   ASSERT(isolate()->no_gc_scope_depth() != 0);
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
   Heap* heap = isolate()->heap();
 
   uword address = heap->TryAllocate(size, Heap::kOld, PageSpace::kForceGrowth);
   if (address == 0) {
     // Use the preallocated out of memory exception to avoid calling
     // into dart code or allocating any code.
     // We do a longjmp at this point to unwind out of the entire
@@ skipping 10 matching lines @@
     *reinterpret_cast<intptr_t*>(current) = kZapUninitializedWord;
     current += kWordSize;
   }
 #endif  // defined(DBEUG)
   // Make sure to initialize the last word, as this can be left untouched in
   // case the object deserialized has an alignment tail.
   *reinterpret_cast<RawObject**>(address + size - kWordSize) = Object::null();
 
   RawObject* raw_obj = reinterpret_cast<RawObject*>(address + kHeapObjectTag);
   uword tags = 0;
-  intptr_t index = cls.id();
-  ASSERT(index != kIllegalCid);
-  tags = RawObject::ClassIdTag::update(index, tags);
+  ASSERT(class_id != kIllegalCid);
+  tags = RawObject::ClassIdTag::update(class_id, tags);
   tags = RawObject::SizeTag::update(size, tags);
   raw_obj->ptr()->tags_ = tags;
   return raw_obj;
 }
 
 
 RawObject* SnapshotReader::ReadVMIsolateObject(intptr_t header_value) {
   intptr_t object_id = GetVMIsolateObjectId(header_value);
   if (object_id == kNullObject) {
     // This is a singleton null object, return it.
@@ skipping 61 matching lines @@
     intptr_t instance_size = 0;
     if (result == NULL) {
       result = &(Instance::ZoneHandle(isolate(), Instance::null()));
       AddBackRef(object_id, result, kIsDeserialized);
       cls_ ^= ReadObjectImpl();
       ASSERT(!cls_.IsNull());
       instance_size = cls_.instance_size();
       ASSERT(instance_size > 0);
       // Allocate the instance and read in all the fields for the object.
       if (kind_ == Snapshot::kFull) {
-        *result ^= AllocateUninitialized(cls_, instance_size);
+        *result ^= AllocateUninitialized(cls_.id(), instance_size);
       } else {
         *result ^= Object::Allocate(cls_.id(),
                                     instance_size,
                                     HEAP_SPACE(kind_));
       }
     } else {
       cls_ ^= ReadObjectImpl();
       ASSERT(!cls_.IsNull());
       instance_size = cls_.instance_size();
     }
@@ skipping 767 matching lines @@
     NoGCScope no_gc;
     WriteObject(obj.raw());
     UnmarkAll();
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart