Initial isolate reload support

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/native_entry.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
+DECLARE_FLAG(bool, remove_script_timestamps_for_test);
+
 #define NEW_OBJECT(type)                                                       \
   ((Snapshot::IsFull(kind)) ? reader->New##type() : type::New())
 
 #define NEW_OBJECT_WITH_LEN(type, len)                                         \
   ((Snapshot::IsFull(kind)) ? reader->New##type(len) : type::New(len))
 
 #define NEW_OBJECT_WITH_LEN_SPACE(type, len, kind)                             \
   ((Snapshot::IsFull(kind)) ?                                                  \
   reader->New##type(len) : type::New(len, HEAP_SPACE(kind)))
 
@@ skipping 207 matching lines @@
       (!Snapshot::IsFull(kind) && typeclass_is_in_fullsnapshot);
   reader->AddBackRef(object_id, &type, kIsDeserialized, defer_canonicalization);
 
   // Set all non object fields.
   type.set_token_pos(TokenPosition::SnapshotDecode(reader->Read<int32_t>()));
   type.set_type_state(reader->Read<int8_t>());
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(type, type.raw()->from(), type.raw()->to(), kAsReference);
 
+  // Read in the type class.
+  (*reader->ClassHandle()) =
+      Class::RawCast(reader->ReadObjectImpl(kAsReference));
+  type.set_type_class(*reader->ClassHandle());
+
   // Set the canonical bit.
   if (!defer_canonicalization && is_canonical) {
     type.SetCanonical();
   }
 
   return type.raw();
 }
 
 
 void RawType::WriteTo(SnapshotWriter* writer,
                       intptr_t object_id,
                       Snapshot::Kind kind,
                       bool as_reference) {
   ASSERT(writer != NULL);
 
   // Only resolved and finalized types should be written to a snapshot.
   ASSERT((ptr()->type_state_ == RawType::kFinalizedInstantiated) ||
          (ptr()->type_state_ == RawType::kFinalizedUninstantiated));
-  ASSERT(ptr()->type_class_ != Object::null());
+  ASSERT(ptr()->type_class_id_ != Object::null());
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteIndexedObject(kTypeCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
+  // Lookup the type class.
+  RawSmi* raw_type_class_id = Smi::RawCast(ptr()->type_class_id_);
+  RawClass* type_class =
+      writer->isolate()->class_table()->At(Smi::Value(raw_type_class_id));
+
   // Write out typeclass_is_in_fullsnapshot first as this will
   // help the reader decide on how to canonicalize the type object.
-  intptr_t tags = writer->GetObjectTags(ptr()->type_class_);
+  intptr_t tags = writer->GetObjectTags(type_class);
   bool typeclass_is_in_fullsnapshot =
       (ClassIdTag::decode(tags) == kClassCid) &&
-      Class::IsInFullSnapshot(reinterpret_cast<RawClass*>(ptr()->type_class_));
+      Class::IsInFullSnapshot(reinterpret_cast<RawClass*>(type_class));
   writer->Write<bool>(typeclass_is_in_fullsnapshot);
 
   // Write out all the non object pointer fields.
   writer->Write<int32_t>(ptr()->token_pos_.SnapshotEncode());
   writer->Write<int8_t>(ptr()->type_state_);
 
   // Write out all the object pointer fields.
-  ASSERT(ptr()->type_class_ != Object::null());
+  ASSERT(ptr()->type_class_id_ != Object::null());
   SnapshotWriterVisitor visitor(writer, kAsReference);
   visitor.VisitPointers(from(), to());
+
+  // Write out the type class.
+  writer->WriteObjectImpl(type_class, kAsReference);
 }
 
 
 RawTypeRef* TypeRef::ReadFrom(SnapshotReader* reader,
                               intptr_t object_id,
                               intptr_t tags,
                               Snapshot::Kind kind,
                               bool as_reference) {
   ASSERT(reader != NULL);
 
@@ skipping 46 matching lines @@
   type_parameter.set_token_pos(
       TokenPosition::SnapshotDecode(reader->Read<int32_t>()));
   type_parameter.set_index(reader->Read<int16_t>());
   type_parameter.set_type_state(reader->Read<int8_t>());
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(type_parameter,
                      type_parameter.raw()->from(), type_parameter.raw()->to(),
                      kAsReference);
 
+  // Read in the parameterized class.
+  (*reader->ClassHandle()) =
+      Class::RawCast(reader->ReadObjectImpl(kAsReference));
+  type_parameter.set_parameterized_class(*reader->ClassHandle());
+
   return type_parameter.raw();
 }
 
 
 void RawTypeParameter::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind,
                                bool as_reference) {
   ASSERT(writer != NULL);
 
   // Only finalized type parameters should be written to a snapshot.
   ASSERT(ptr()->type_state_ == RawTypeParameter::kFinalizedUninstantiated);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteIndexedObject(kTypeParameterCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out all the non object pointer fields.
   writer->Write<int32_t>(ptr()->token_pos_.SnapshotEncode());
   writer->Write<int16_t>(ptr()->index_);
   writer->Write<int8_t>(ptr()->type_state_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer, kAsReference);
   visitor.VisitPointers(from(), to());
+
+  // Write out the parameterized class.
+  RawClass* param_class =
+      writer->isolate()->class_table()->At(ptr()->parameterized_class_id_);
+  writer->WriteObjectImpl(param_class, kAsReference);
 }
 
 
 RawBoundedType* BoundedType::ReadFrom(SnapshotReader* reader,
                                       intptr_t object_id,
                                       intptr_t tags,
                                       Snapshot::Kind kind,
                                       bool as_reference) {
   ASSERT(reader != NULL);
 
@@ skipping 705 matching lines @@
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (script.raw()->to_snapshot(kind) - script.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
     (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
     script.StorePointer((script.raw()->from() + i),
                         reader->PassiveObjectHandle()->raw());
   }
 
+  script.set_load_timestamp(FLAG_remove_script_timestamps_for_test
+                            ? 0 : OS::GetCurrentTimeMillis());
+
   return script.raw();
 }
 
 
 void RawScript::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
                         Snapshot::Kind kind,
                         bool as_reference) {
   ASSERT(writer != NULL);
   ASSERT(tokens_ != TokenStream::null());
@@ skipping 2642 matching lines @@
     // We do not allow objects with native fields in an isolate message.
     writer->SetWriteException(Exceptions::kArgument,
                               "Illegal argument in isolate message"
                               " : (object is a UserTag)");
   } else {
     UNREACHABLE();
   }
 }
 
 }  // namespace dart