Last snapshot bits to get working precompiled hello_world on x64.

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"
@@ skipping 635 matching lines @@
   func.set_deoptimization_counter(reader->Read<int16_t>());
   func.set_kind_tag(reader->Read<uint32_t>());
   func.set_optimized_instruction_count(reader->Read<uint16_t>());
   func.set_optimized_call_site_count(reader->Read<uint16_t>());
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(func,
                      func.raw()->from(),
                      reader->snapshot_code() ? func.raw()->to()
                                              : func.raw()->to_snapshot(),
-                     kAsReference);
+                     kAsInlinedObject);
 
   if (!reader->snapshot_code()) {
     // Initialize all fields that are not part of the snapshot.
     func.ClearICDataArray();
     func.ClearCode();
   } else {
-    // TODO(rmacnak): Fix entry_point_.
+    // Fix entry point.
+    (*reader->CodeHandle()) = func.CurrentCode();
+    uword new_entry = (*reader->CodeHandle()).EntryPoint();
+    ASSERT(Dart::vm_isolate()->heap()->CodeContains(new_entry));
+    func.StoreNonPointer(&func.raw_ptr()->entry_point_, new_entry);
   }
   return func.raw();
 }
 
 
 void RawFunction::WriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT((kind == Snapshot::kScript) || (kind == Snapshot::kFull));
@@ skipping 14 matching lines @@
     writer->Write<int32_t>(0);
   }
   writer->Write<int16_t>(ptr()->num_fixed_parameters_);
   writer->Write<int16_t>(ptr()->num_optional_parameters_);
   writer->Write<int16_t>(ptr()->deoptimization_counter_);
   writer->Write<uint32_t>(ptr()->kind_tag_);
   writer->Write<uint16_t>(ptr()->optimized_instruction_count_);
   writer->Write<uint16_t>(ptr()->optimized_call_site_count_);
 
   // Write out all the object pointer fields.
-  SnapshotWriterVisitor visitor(writer);
+  SnapshotWriterVisitor visitor(writer, kAsInlinedObject);
   visitor.VisitPointers(from(), writer->snapshot_code() ? to()
                                                         : to_snapshot());
 }
 
 
 RawField* Field::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
                           intptr_t tags,
                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
@@ skipping 443 matching lines @@
 
   result.set_compile_timestamp(reader->Read<int64_t>());
   result.set_state_bits(reader->Read<int32_t>());
   result.set_entry_patch_pc_offset(reader->Read<int32_t>());
   result.set_patch_code_pc_offset(reader->Read<int32_t>());
   result.set_lazy_deopt_pc_offset(reader->Read<int32_t>());
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(result,
                      result.raw()->from(), result.raw()->to(),
-                     kAsReference);
+                     kAsInlinedObject);
 
-  // TODO(rmacnak): Fix entry_point_.
+  // Fix entry point.
+  uword new_entry = result.EntryPoint();
+  ASSERT(Dart::vm_isolate()->heap()->CodeContains(new_entry));
+  result.StoreNonPointer(&result.raw_ptr()->entry_point_, new_entry);
 
   return result.raw();
 }
 
 
 void RawCode::WriteTo(SnapshotWriter* writer,
                       intptr_t object_id,
                       Snapshot::Kind kind) {
   ASSERT(writer->snapshot_code());
   ASSERT(kind == Snapshot::kFull);
@@ skipping 13 matching lines @@
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out all the non object fields.
   writer->Write<int64_t>(ptr()->compile_timestamp_);
   writer->Write<int32_t>(ptr()->state_bits_);
   writer->Write<int32_t>(ptr()->entry_patch_pc_offset_);
   writer->Write<int32_t>(ptr()->patch_code_pc_offset_);
   writer->Write<int32_t>(ptr()->lazy_deopt_pc_offset_);
 
   // Write out all the object pointer fields.
-  SnapshotWriterVisitor visitor(writer);
+  SnapshotWriterVisitor visitor(writer, kAsInlinedObject);
   visitor.VisitPointers(from(), to());
 
   writer->SetInstructionsCode(ptr()->instructions_, this);
 }
 
 
 RawInstructions* Instructions::ReadFrom(SnapshotReader* reader,
                                         intptr_t object_id,
                                         intptr_t tags,
                                         Snapshot::Kind kind) {
   ASSERT(reader->snapshot_code());
   ASSERT(kind == Snapshot::kFull);
 
   intptr_t full_tags = static_cast<uword>(reader->Read<intptr_t>());
   intptr_t offset = reader->Read<int32_t>();
   Instructions& result =
       Instructions::ZoneHandle(reader->zone(),
                                reader->GetInstructionsAt(offset, full_tags));
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
-  {
-    // TODO(rmacnak): Drop after calling convention change.
-    Code::CheckedHandle(reader->ReadObjectImpl(kAsReference));
-    ObjectPool::CheckedHandle(reader->ReadObjectImpl(kAsReference));
-  }
-
   return result.raw();
 }
 
 
 void RawInstructions::WriteTo(SnapshotWriter* writer,
                               intptr_t object_id,
                               Snapshot::Kind kind) {
   ASSERT(writer->snapshot_code());
   ASSERT(kind == Snapshot::kFull);
 
-  {
-    // TODO(rmacnak): Drop after calling convention change.
-    writer->WriteInlinedObjectHeader(object_id);
-    writer->WriteVMIsolateObject(kInstructionsCid);
-    writer->WriteTags(writer->GetObjectTags(this));
-  }
-
-  writer->Write<intptr_t>(writer->GetObjectTags(this));  // For sanity check.
+  writer->WriteInlinedObjectHeader(object_id);
+  writer->WriteVMIsolateObject(kInstructionsCid);
+  writer->WriteTags(writer->GetObjectTags(this));
 
   // Temporarily restore the object header for writing to the text section.
   // TODO(asiva): Don't mutate object headers during serialization.

[siva, 2015/09/15 23:22:01]

Is this temporary restore of tags stuff necessary now that you are extracting
the tags and writing it out and if you fix GetOffsetFor to use SizeFromClass
(see comment in snapshot.cc file).

[rmacnak, 2015/09/16 01:34:45]

Dropped.

   uword object_tags = writer->GetObjectTags(this);
   uword snapshot_tags = ptr()->tags_;
   ptr()->tags_ = object_tags;
+
+  // Instructions with be written pre-marked and in the VM heap. Write out
+  // the tags we expect to find when reading the snapshot for a sanity check
+  // that our offsets/alignment didn't get out of sync.
+  uword written_tags = object_tags;
+  written_tags = RawObject::VMHeapObjectTag::update(true, written_tags);
+  written_tags = RawObject::MarkBit::update(true, written_tags);
+  writer->Write<intptr_t>(written_tags);
+
   writer->Write<int32_t>(writer->GetInstructionsId(this));
+
   ptr()->tags_ = snapshot_tags;
 
   {
     // TODO(rmacnak): Drop after calling convention change.
     writer->WriteObjectImpl(ptr()->code_, kAsReference);
     writer->WriteObjectImpl(ptr()->object_pool_, kAsReference);
   }
 }
 
 
@@ skipping 2004 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