Precompilation: don't include an object header for instructions in the text section.

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 1321 matching lines @@
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kNamespaceCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer, kAsReference);
   visitor.VisitPointers(from(), to());
 }
 
 
+#if defined(DEBUG)
+static uword Checksum(uword entry, intptr_t size) {
+  uword sum = 0;
+  uword* start = reinterpret_cast<uword*>(entry);
+  uword* end = reinterpret_cast<uword*>(entry + size);
+  for (uword* cursor = start; cursor < end; cursor++) {
+    sum ^= *cursor;
+  }
+  return sum;
+}
+#endif
+
+
 RawCode* Code::ReadFrom(SnapshotReader* reader,
                         intptr_t object_id,
                         intptr_t tags,
                         Snapshot::Kind kind,
                         bool as_reference) {
   ASSERT(reader->snapshot_code());
   ASSERT(kind == Snapshot::kFull);
 
   Code& result = Code::ZoneHandle(reader->zone(), NEW_OBJECT_WITH_LEN(Code, 0));
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   result.set_compile_timestamp(0);
   result.set_state_bits(reader->Read<int32_t>());
   result.set_lazy_deopt_pc_offset(-1);
 
-  // Set all the object fields.
-  READ_OBJECT_FIELDS(result,
-                     result.raw()->from(), result.raw()->to_snapshot(),
-                     kAsReference);
-  for (RawObject** ptr = result.raw()->to();
-       ptr > result.raw()->to_snapshot();
-       ptr--) {
-    result.StorePointer(ptr, Object::null());
-  }
+  int32_t text_offset = reader->Read<int32_t>();
+  int32_t instructions_size = reader->Read<int32_t>();
+  uword entry_point = reader->GetInstructionsAt(text_offset);
 
-  // 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);
+#if defined(DEBUG)
+  uword expected_check = reader->Read<uword>();
+  uword actual_check = Checksum(entry_point, instructions_size);
+  ASSERT(expected_check == actual_check);
+#endif
+
+  result.StoreNonPointer(&result.raw_ptr()->entry_point_, entry_point);
+
+  result.StorePointer(reinterpret_cast<RawSmi*const*>(
+                          &result.raw_ptr()->instructions_),
+                      Smi::New(instructions_size));
+
+  (*reader->PassiveObjectHandle()) ^= reader->ReadObjectImpl(kAsReference);
+  result.StorePointer(reinterpret_cast<RawObject*const*>(
+                          &result.raw_ptr()->object_pool_),
+                      reader->PassiveObjectHandle()->raw());
+
+  (*reader->PassiveObjectHandle()) ^= reader->ReadObjectImpl(kAsReference);
+  result.StorePointer(&result.raw_ptr()->owner_,
+                      reader->PassiveObjectHandle()->raw());
+
+  (*reader->PassiveObjectHandle()) ^= reader->ReadObjectImpl(kAsReference);
+  result.StorePointer(reinterpret_cast<RawObject*const*>(
+                          &result.raw_ptr()->exception_handlers_),
+                      reader->PassiveObjectHandle()->raw());
+
+  (*reader->PassiveObjectHandle()) ^= reader->ReadObjectImpl(kAsReference);
+  result.StorePointer(reinterpret_cast<RawObject*const*>(
+                          &result.raw_ptr()->pc_descriptors_),
+                      reader->PassiveObjectHandle()->raw());
+
+  (*reader->PassiveObjectHandle()) ^= reader->ReadObjectImpl(kAsReference);
+  result.StorePointer(reinterpret_cast<RawObject*const*>(
+                          &result.raw_ptr()->code_source_map_),
+                      reader->PassiveObjectHandle()->raw());
+
+  (*reader->PassiveObjectHandle()) ^= reader->ReadObjectImpl(kAsReference);
+  result.StorePointer(reinterpret_cast<RawObject*const*>(
+                          &result.raw_ptr()->stackmaps_),
+                      reader->PassiveObjectHandle()->raw());
+
+  result.StorePointer(&result.raw_ptr()->deopt_info_array_,
+                      Array::null());
+  result.StorePointer(&result.raw_ptr()->static_calls_target_table_,
+                      Array::null());
+  result.StorePointer(&result.raw_ptr()->var_descriptors_,
+                      LocalVarDescriptors::null());
+  result.StorePointer(&result.raw_ptr()->inlined_metadata_,
+                      Array::null());
+  result.StorePointer(&result.raw_ptr()->comments_,
+                      Array::null());
+  result.StorePointer(&result.raw_ptr()->return_address_metadata_,
+                      Object::null());
+
+  ASSERT(result.Size() == instructions_size);
+  ASSERT(result.EntryPoint() == entry_point);
 
   return result.raw();
 }
 
 
 void RawCode::WriteTo(SnapshotWriter* writer,
                       intptr_t object_id,
                       Snapshot::Kind kind,
                       bool as_reference) {
   ASSERT(writer->snapshot_code());
   ASSERT(kind == Snapshot::kFull);
 
   intptr_t pointer_offsets_length =
       Code::PtrOffBits::decode(ptr()->state_bits_);
   if (pointer_offsets_length != 0) {
     // Should only be IA32.
     FATAL("Cannot serialize code with embedded pointers");
   }
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kCodeCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out all the non object fields.
   writer->Write<int32_t>(ptr()->state_bits_);
 
-  // Write out all the object pointer fields.
-  SnapshotWriterVisitor visitor(writer, kAsReference);
-  visitor.VisitPointers(from(), to_snapshot());
+  RawInstructions* instr = ptr()->instructions_;
+  intptr_t size = instr->ptr()->size_;
+  int32_t text_offset = writer->GetInstructionsId(instr, this);
+  writer->Write<int32_t>(text_offset);
+  writer->Write<int32_t>(size);
+#if defined(DEBUG)
+  uword entry = ptr()->entry_point_;
+  uword check = Checksum(entry, size);
+  writer->Write<uword>(check);
+#endif
 
-  writer->SetInstructionsCode(ptr()->instructions_, this);
+  writer->WriteObjectImpl(ptr()->object_pool_, kAsReference);
+  writer->WriteObjectImpl(ptr()->owner_, kAsReference);
+  writer->WriteObjectImpl(ptr()->exception_handlers_, kAsReference);
+  writer->WriteObjectImpl(ptr()->pc_descriptors_, kAsReference);
+  writer->WriteObjectImpl(ptr()->code_source_map_, kAsReference);
+  writer->WriteObjectImpl(ptr()->stackmaps_, kAsReference);
 }
 
 
 RawInstructions* Instructions::ReadFrom(SnapshotReader* reader,
                                         intptr_t object_id,
                                         intptr_t tags,
                                         Snapshot::Kind kind,
                                         bool as_reference) {
-  ASSERT(reader->snapshot_code());
-  ASSERT(kind == Snapshot::kFull);
-
-#ifdef DEBUG
-  intptr_t full_tags = static_cast<uword>(reader->Read<intptr_t>());
-#else
-  intptr_t full_tags = 0;  // unused in release mode
-#endif
-  intptr_t offset = reader->Read<int32_t>();
-  Instructions& result =
-      Instructions::ZoneHandle(reader->zone(),
-                               reader->GetInstructionsAt(offset, full_tags));
-  reader->AddBackRef(object_id, &result, kIsDeserialized);
-
-  return result.raw();
+  UNREACHABLE();
+  return Instructions::null();
 }
 
 
 void RawInstructions::WriteTo(SnapshotWriter* writer,
                               intptr_t object_id,
                               Snapshot::Kind kind,
                               bool as_reference) {
-  ASSERT(writer->snapshot_code());
-  ASSERT(kind == Snapshot::kFull);
-
-  writer->WriteInlinedObjectHeader(object_id);
-  writer->WriteVMIsolateObject(kInstructionsCid);
-  writer->WriteTags(writer->GetObjectTags(this));
-
-#ifdef DEBUG
-  // Instructions will 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 = writer->GetObjectTags(this);
-  written_tags = RawObject::VMHeapObjectTag::update(true, written_tags);
-  written_tags = RawObject::MarkBit::update(true, written_tags);
-  writer->Write<intptr_t>(written_tags);
-#endif
-
-  writer->Write<int32_t>(writer->GetInstructionsId(this));
+  UNREACHABLE();
 }
 
 
 RawObjectPool* ObjectPool::ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind,
                                     bool as_reference) {
   ASSERT(reader->snapshot_code());
   ASSERT(kind == Snapshot::kFull);
@@ skipping 2190 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