Make ClassFinalizer indifferent on whether we are generating a snapshot or not.

runtime/vm/raw_object_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/bigint_operations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
@@ skipping 168 matching lines @@
   UNREACHABLE();  // AbstractType is an abstract class.
 }
 
 
 RawType* Type::ReadFrom(SnapshotReader* reader,
                         intptr_t object_id,
                         intptr_t tags,
                         Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
-  // Allocate parameterized type object.
-  Type& parameterized_type = Type::ZoneHandle(
-      reader->isolate(), NEW_OBJECT(Type));
-  reader->AddBackRef(object_id, &parameterized_type, kIsDeserialized);
+  // Allocate type object.
+  Type& type = Type::ZoneHandle(reader->isolate(), NEW_OBJECT(Type));
+  reader->AddBackRef(object_id, &type, kIsDeserialized);
 
   // Set the object tags.
-  parameterized_type.set_tags(tags);
+  type.set_tags(tags);
 
   // Set all non object fields.
-  parameterized_type.set_token_pos(reader->ReadIntptrValue());
-  parameterized_type.set_type_state(reader->Read<int8_t>());
+  type.set_token_pos(reader->ReadIntptrValue());
+  type.set_type_state(reader->Read<int8_t>());
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
-  intptr_t num_flds = (parameterized_type.raw()->to() -
-                       parameterized_type.raw()->from());
+  intptr_t num_flds = (type.raw()->to() - type.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    *(parameterized_type.raw()->from() + i) = reader->ReadObjectImpl();
+    *(type.raw()->from() + i) = reader->ReadObjectRef();
   }
 
   // If object needs to be a canonical object, Canonicalize it.
-  if ((kind != Snapshot::kFull) && parameterized_type.IsCanonical()) {
-    parameterized_type ^= parameterized_type.Canonicalize();
+  if ((kind != Snapshot::kFull) && type.IsCanonical()) {
+    type ^= type.Canonicalize();
   }
-  return parameterized_type.raw();
+  return type.raw();
 }
 
 
 void RawType::WriteTo(SnapshotWriter* writer,
                       intptr_t object_id,
                       Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kTypeCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the non object pointer fields.
   writer->WriteIntptrValue(ptr()->token_pos_);
   writer->Write<int8_t>(ptr()->type_state_);
 
   // Write out all the object pointer fields.
-  SnapshotWriterVisitor visitor(writer, false);
+  SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawTypeParameter* TypeParameter::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate type parameter object.
   TypeParameter& type_parameter = TypeParameter::ZoneHandle(
           reader->isolate(), NEW_OBJECT(TypeParameter));
   reader->AddBackRef(object_id, &type_parameter, kIsDeserialized);
 
   // Set the object tags.
   type_parameter.set_tags(tags);
 
   // Set all non object fields.
   type_parameter.set_index(reader->ReadIntptrValue());
   type_parameter.set_token_pos(reader->ReadIntptrValue());
   type_parameter.set_type_state(reader->Read<int8_t>());
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (type_parameter.raw()->to() -
                        type_parameter.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    *(type_parameter.raw()->from() + i) = reader->ReadObjectImpl();
+    *(type_parameter.raw()->from() + i) = reader->ReadObjectRef();
   }
 
   return type_parameter.raw();
 }
 
 
 void RawTypeParameter::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kTypeParameterCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the non object pointer fields.
   writer->WriteIntptrValue(ptr()->index_);
   writer->WriteIntptrValue(ptr()->token_pos_);
   writer->Write<int8_t>(ptr()->type_state_);
 
   // Write out all the object pointer fields.
-  SnapshotWriterVisitor visitor(writer, false);
+  SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawAbstractTypeArguments* AbstractTypeArguments::ReadFrom(
     SnapshotReader* reader,
     intptr_t object_id,
     intptr_t tags,
     Snapshot::Kind kind) {
   UNREACHABLE();  // AbstractTypeArguments is an abstract class.
@@ skipping 79 matching lines @@
 
   // Set the object tags.
   instantiated_type_arguments.set_tags(tags);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (instantiated_type_arguments.raw()->to() -
                        instantiated_type_arguments.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    *(instantiated_type_arguments.raw()->from() + i) = reader->ReadObjectImpl();
+    *(instantiated_type_arguments.raw()->from() + i) = reader->ReadObjectRef();
   }
   return instantiated_type_arguments.raw();
 }
 
 
 void RawInstantiatedTypeArguments::WriteTo(SnapshotWriter* writer,
                                            intptr_t object_id,
                                            Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind == Snapshot::kMessage);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kInstantiatedTypeArgumentsCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the object pointer fields.
-  SnapshotWriterVisitor visitor(writer, false);
+  SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawPatchClass* PatchClass::ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind) {
   ASSERT(reader != NULL);
-  ASSERT(kind != Snapshot::kMessage && !RawObject::IsCreatedFromSnapshot(tags));
+  ASSERT((kind != Snapshot::kMessage) &&
+         !RawObject::IsCreatedFromSnapshot(tags));
 
   // Allocate function object.
   PatchClass& cls = PatchClass::ZoneHandle(reader->isolate(),
                                             NEW_OBJECT(PatchClass));
   reader->AddBackRef(object_id, &cls, kIsDeserialized);
 
   // Set the object tags.
   cls.set_tags(tags);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (cls.raw()->to() - cls.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
     *(cls.raw()->from() + i) = reader->ReadObjectRef();
   }
 
   return cls.raw();
 }
 
 
 void RawPatchClass::WriteTo(SnapshotWriter* writer,
                             intptr_t object_id,
                             Snapshot::Kind kind) {
   ASSERT(writer != NULL);
-  ASSERT(kind != Snapshot::kMessage &&
+  ASSERT((kind != Snapshot::kMessage) &&
          !RawObject::IsCreatedFromSnapshot(writer->GetObjectTags(this)));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kPatchClassCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawFunction* Function::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind) {
   ASSERT(reader != NULL);
-  ASSERT(kind != Snapshot::kMessage && !RawObject::IsCreatedFromSnapshot(tags));
+  ASSERT((kind != Snapshot::kMessage) &&
+         !RawObject::IsCreatedFromSnapshot(tags));
 
   // Allocate function object.
   Function& func = Function::ZoneHandle(
       reader->isolate(), NEW_OBJECT(Function));
   reader->AddBackRef(object_id, &func, kIsDeserialized);
 
   // Set the object tags.
   func.set_tags(tags);
 
   // Set all the non object fields.
@@ skipping 14 matching lines @@
   }
 
   return func.raw();
 }
 
 
 void RawFunction::WriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind) {
   ASSERT(writer != NULL);
-  ASSERT(kind != Snapshot::kMessage &&
+  ASSERT((kind != Snapshot::kMessage) &&
          !RawObject::IsCreatedFromSnapshot(writer->GetObjectTags(this)));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kFunctionCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the non object fields.
   writer->WriteIntptrValue(ptr()->token_pos_);
   writer->WriteIntptrValue(ptr()->end_token_pos_);
   writer->WriteIntptrValue(ptr()->num_fixed_parameters_);
   writer->WriteIntptrValue(ptr()->num_optional_parameters_);
   writer->WriteIntptrValue(ptr()->usage_counter_);
   writer->WriteIntptrValue(ptr()->deoptimization_counter_);
   writer->WriteIntptrValue(ptr()->kind_tag_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawField* Field::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
                           intptr_t tags,
                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
-  ASSERT(kind != Snapshot::kMessage && !RawObject::IsCreatedFromSnapshot(tags));
+  ASSERT((kind != Snapshot::kMessage) &&
+         !RawObject::IsCreatedFromSnapshot(tags));
 
   // Allocate field object.
   Field& field = Field::ZoneHandle(reader->isolate(), NEW_OBJECT(Field));
   reader->AddBackRef(object_id, &field, kIsDeserialized);
 
   // Set the object tags.
   field.set_tags(tags);
 
   // Set all non object fields.
   field.set_token_pos(reader->ReadIntptrValue());
   field.set_kind_bits(reader->Read<uint8_t>());
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (field.raw()->to() - field.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
     *(field.raw()->from() + i) = reader->ReadObjectRef();
   }
 
   return field.raw();
 }
 
 
 void RawField::WriteTo(SnapshotWriter* writer,
                        intptr_t object_id,
                        Snapshot::Kind kind) {
   ASSERT(writer != NULL);
-  ASSERT(kind != Snapshot::kMessage &&
+  ASSERT((kind != Snapshot::kMessage) &&
          !RawObject::IsCreatedFromSnapshot(writer->GetObjectTags(this)));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kFieldCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the non object fields.
@@ skipping 53 matching lines @@
   writer->WriteObjectImpl(ptr()->literal_);
   writer->WriteObjectImpl(ptr()->value_);
 }
 
 
 RawTokenStream* TokenStream::ReadFrom(SnapshotReader* reader,
                                       intptr_t object_id,
                                       intptr_t tags,
                                       Snapshot::Kind kind) {
   ASSERT(reader != NULL);
-  ASSERT(kind != Snapshot::kMessage && !RawObject::IsCreatedFromSnapshot(tags));
+  ASSERT((kind != Snapshot::kMessage)
+          && !RawObject::IsCreatedFromSnapshot(tags));
 
   // Read the length so that we can determine number of tokens to read.
   intptr_t len = reader->ReadSmiValue();
 
   // Create the token stream object.
   TokenStream& token_stream = TokenStream::ZoneHandle(
       reader->isolate(), NEW_OBJECT_WITH_LEN(TokenStream, len));
   reader->AddBackRef(object_id, &token_stream, kIsDeserialized);
 
   // Set the object tags.
@@ skipping 14 matching lines @@
   token_stream.SetPrivateKey(*(reader->StringHandle()));
 
   return token_stream.raw();
 }
 
 
 void RawTokenStream::WriteTo(SnapshotWriter* writer,
                              intptr_t object_id,
                              Snapshot::Kind kind) {
   ASSERT(writer != NULL);
-  ASSERT(kind != Snapshot::kMessage &&
+  ASSERT((kind != Snapshot::kMessage) &&
          !RawObject::IsCreatedFromSnapshot(writer->GetObjectTags(this)));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kTokenStreamCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out the length field and the token stream.
   intptr_t len = Smi::Value(ptr()->length_);
   writer->Write<RawObject*>(ptr()->length_);
   writer->WriteBytes(reinterpret_cast<uint8_t*>(ptr()->data_), len);
 
   // Write out the literal/identifier token array.
   writer->WriteObjectImpl(ptr()->token_objects_);
   // Write out the private key in use by the token stream.
   writer->WriteObjectImpl(ptr()->private_key_);
 }
 
 
 RawScript* Script::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind) {
   ASSERT(reader != NULL);
-  ASSERT(kind != Snapshot::kMessage && !RawObject::IsCreatedFromSnapshot(tags));
+  ASSERT((kind != Snapshot::kMessage) &&
+         !RawObject::IsCreatedFromSnapshot(tags));
 
   // Allocate script object.
   Script& script = Script::ZoneHandle(reader->isolate(), NEW_OBJECT(Script));
   reader->AddBackRef(object_id, &script, kIsDeserialized);
 
   // Set the object tags.
   script.set_tags(tags);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   *reader->StringHandle() ^= reader->ReadObjectImpl();
   script.set_url(*reader->StringHandle());
   *reader->StringHandle() ^= String::null();
   script.set_source(*reader->StringHandle());
   TokenStream& stream = TokenStream::Handle();
   stream ^= reader->ReadObjectImpl();
   script.set_tokens(stream);
 
   return script.raw();
 }
 
 
 void RawScript::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
                         Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(tokens_ != TokenStream::null());
-  ASSERT(kind != Snapshot::kMessage &&
+  ASSERT((kind != Snapshot::kMessage) &&
          !RawObject::IsCreatedFromSnapshot(writer->GetObjectTags(this)));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kScriptCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the object pointer fields.
@@ skipping 91 matching lines @@
     visitor.VisitPointers(from(), to());
   }
 }
 
 
 RawLibraryPrefix* LibraryPrefix::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
-  ASSERT(kind != Snapshot::kMessage && !RawObject::IsCreatedFromSnapshot(tags));
+  ASSERT((kind != Snapshot::kMessage) &&
+         !RawObject::IsCreatedFromSnapshot(tags));
 
   // Allocate library prefix object.
   LibraryPrefix& prefix = LibraryPrefix::ZoneHandle(
       reader->isolate(), NEW_OBJECT(LibraryPrefix));
   reader->AddBackRef(object_id, &prefix, kIsDeserialized);
 
   // Set the object tags.
   prefix.set_tags(tags);
 
   // Set all non object fields.
   prefix.raw_ptr()->num_libs_ = reader->ReadIntptrValue();
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (prefix.raw()->to() - prefix.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
     *(prefix.raw()->from() + i) = reader->ReadObjectRef();
   }
 
   return prefix.raw();
 }
 
 
 void RawLibraryPrefix::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind) {
   ASSERT(writer != NULL);
-  ASSERT(kind != Snapshot::kMessage &&
+  ASSERT((kind != Snapshot::kMessage) &&
          !RawObject::IsCreatedFromSnapshot(writer->GetObjectTags(this)));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kLibraryPrefixCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all non object fields.
@@ skipping 256 matching lines @@
                                   Snapshot::Kind kind) {
   UNREACHABLE();
 }
 
 
 RawError* Error::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
                           intptr_t tags,
                           Snapshot::Kind kind) {
   UNREACHABLE();
-  return Error::null();
+  return Error::null();  // Error is an abstract class.
 }
 
 
 void RawError::WriteTo(SnapshotWriter* writer,
                        intptr_t object_id,
                        Snapshot::Kind kind) {
-  UNREACHABLE();
+  UNREACHABLE();  // Error is an abstract class.
 }
 
 
 RawApiError* ApiError::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind) {
-  UNREACHABLE();
-  return ApiError::null();
+  ASSERT(reader != NULL);
+
+  // Allocate ApiError object.
+  ApiError& api_error =
+      ApiError::ZoneHandle(reader->isolate(), NEW_OBJECT(ApiError));
+  reader->AddBackRef(object_id, &api_error, kIsDeserialized);
+
+  // Set the object tags.
+  api_error.set_tags(tags);
+
+  // Set all the object fields.
+  // TODO(5411462): Need to assert No GC can happen here, even though
+  // allocations may happen.
+  intptr_t num_flds = (api_error.raw()->to() - api_error.raw()->from());
+  for (intptr_t i = 0; i <= num_flds; i++) {
+    *(api_error.raw()->from() + i) = reader->ReadObjectRef();
+  }
+
+  return api_error.raw();
 }
 
 
 void RawApiError::WriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind) {
-  UNREACHABLE();
+  ASSERT(writer != NULL);
+
+  // Write out the serialization header value for this object.
+  writer->WriteInlinedObjectHeader(object_id);
+
+  // Write out the class and tags information.
+  writer->WriteVMIsolateObject(kApiErrorCid);
+  writer->WriteIntptrValue(writer->GetObjectTags(this));
+
+  // Write out all the object pointer fields.
+  SnapshotWriterVisitor visitor(writer);
+  visitor.VisitPointers(from(), to());
 }
 
 
 RawLanguageError* LanguageError::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
-  UNREACHABLE();
-  return LanguageError::null();
+  ASSERT(reader != NULL);
+
+  // Allocate LanguageError object.
+  LanguageError& language_error =
+      LanguageError::ZoneHandle(reader->isolate(), NEW_OBJECT(LanguageError));
+  reader->AddBackRef(object_id, &language_error, kIsDeserialized);
+
+  // Set the object tags.
+  language_error.set_tags(tags);
+
+  // Set all the object fields.
+  // TODO(5411462): Need to assert No GC can happen here, even though
+  // allocations may happen.
+  intptr_t num_flds =
+      (language_error.raw()->to() - language_error.raw()->from());
+  for (intptr_t i = 0; i <= num_flds; i++) {
+    *(language_error.raw()->from() + i) = reader->ReadObjectRef();
+  }
+
+  return language_error.raw();
 }
 
 
 void RawLanguageError::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind) {
-  UNREACHABLE();
+  ASSERT(writer != NULL);
+
+  // Write out the serialization header value for this object.
+  writer->WriteInlinedObjectHeader(object_id);
+
+  // Write out the class and tags information.
+  writer->WriteVMIsolateObject(kLanguageErrorCid);
+  writer->WriteIntptrValue(writer->GetObjectTags(this));
+
+  // Write out all the object pointer fields.
+  SnapshotWriterVisitor visitor(writer);
+  visitor.VisitPointers(from(), to());
 }
 
 
 RawUnhandledException* UnhandledException::ReadFrom(SnapshotReader* reader,
                                                     intptr_t object_id,
                                                     intptr_t tags,
                                                     Snapshot::Kind kind) {
   UNREACHABLE();
   return UnhandledException::null();
 }
@@ skipping 899 matching lines @@
   // Write out the class and tags information.
   writer->WriteIndexedObject(kWeakPropertyCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the other fields.
   writer->Write<RawObject*>(ptr()->key_);
   writer->Write<RawObject*>(ptr()->value_);
 }
 
 }  // namespace dart