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

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/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
@@ skipping 185 matching lines @@
       library_(Library::Handle(zone_)),
       type_(AbstractType::Handle(zone_)),
       type_arguments_(TypeArguments::Handle(zone_)),
       tokens_(GrowableObjectArray::Handle(zone_)),
       stream_(TokenStream::Handle(zone_)),
       data_(ExternalTypedData::Handle(zone_)),
       typed_data_(TypedData::Handle(zone_)),
       code_(Code::Handle(zone_)),
       function_(Function::Handle(zone_)),
       megamorphic_cache_(MegamorphicCache::Handle(zone_)),
+      object_pool_(ObjectPool::Handle(zone_)),
       error_(UnhandledException::Handle(zone_)),
       max_vm_isolate_object_id_(
           (kind == Snapshot::kFull) ?
               Object::vm_isolate_snapshot_object_table().Length() : 0),
       backward_references_(backward_refs),
       instructions_reader_(NULL) {
   if (instructions_buffer != NULL) {
     instructions_reader_ =
         new InstructionsReader(instructions_buffer, data_buffer);
   }
@@ skipping 919 matching lines @@
   }
   return Mint::NewCanonical(value);
 }
 
 
 RawStacktrace* SnapshotReader::NewStacktrace() {
   ALLOC_NEW_OBJECT(Stacktrace);
 }
 
 
-int32_t InstructionsWriter::GetOffsetFor(RawInstructions* instructions) {
-  intptr_t heap_size = instructions->Size();
+int32_t InstructionsWriter::GetOffsetFor(RawInstructions* instructions,
+                                         RawCode* code) {
+#if defined(PRODUCT)
+  // Instructions are only dedup in product mode because it obfuscates profiler
+  // results.
+  for (intptr_t i = 0; i < instructions_.length(); i++) {
+    if (instructions_[i].raw_insns_ == instructions) {
+      return instructions_[i].offset_;
+    }
+  }
+#endif
+
+  intptr_t payload_size = instructions->ptr()->size_;
+  payload_size = Utils::RoundUp(payload_size, OS::PreferredCodeAlignment());
+
   intptr_t offset = next_offset_;
-  next_offset_ += heap_size;
-  instructions_.Add(InstructionsData(instructions));
+  ASSERT(Utils::IsAligned(next_offset_, OS::PreferredCodeAlignment()));
+  next_offset_ += payload_size;
+  ASSERT(Utils::IsAligned(next_offset_, OS::PreferredCodeAlignment()));
+  instructions_.Add(InstructionsData(instructions, code, offset));
+
   return offset;
 }
 
 
 int32_t InstructionsWriter::GetObjectOffsetFor(RawObject* raw_object) {
   intptr_t heap_size = raw_object->Size();
   intptr_t offset = next_object_offset_;
   next_object_offset_ += heap_size;
   objects_.Add(ObjectData(raw_object));
   return offset;
@@ skipping 46 matching lines @@
 
   Object& owner = Object::Handle(zone);
   String& str = String::Handle(zone);
 
   for (intptr_t i = 0; i < instructions_.length(); i++) {
     const Instructions& insns = *instructions_[i].insns_;
     const Code& code = *instructions_[i].code_;
 
     ASSERT(insns.raw()->Size() % sizeof(uint64_t) == 0);
 
-    {
-      // 1. Write from the header to the entry point.
-      NoSafepointScope no_safepoint;
-
-      uword beginning = reinterpret_cast<uword>(insns.raw_ptr());
-      uword entry = beginning + Instructions::HeaderSize();
-
-      ASSERT(Utils::IsAligned(beginning, sizeof(uint64_t)));
-      ASSERT(Utils::IsAligned(entry, sizeof(uint64_t)));
-
-      // Write Instructions with the mark and VM heap bits set.
-      uword marked_tags = insns.raw_ptr()->tags_;
-      marked_tags = RawObject::VMHeapObjectTag::update(true, marked_tags);
-      marked_tags = RawObject::MarkBit::update(true, marked_tags);
-
-      WriteWordLiteral(marked_tags);
-      beginning += sizeof(uword);
-
-      for (uword* cursor = reinterpret_cast<uword*>(beginning);
-           cursor < reinterpret_cast<uword*>(entry);
-           cursor++) {
-        WriteWordLiteral(*cursor);
-      }
-    }
-
-    // 2. Write a label at the entry point.
+    // 1. Write a label at the entry point.
     owner = code.owner();
     if (owner.IsNull()) {
       const char* name = StubCode::NameOfStub(insns.EntryPoint());
       stream_.Print("Precompiled_Stub_%s:\n", name);
     } else if (owner.IsClass()) {
       str = Class::Cast(owner).Name();
       const char* name = str.ToCString();
       EnsureIdentifier(const_cast<char*>(name));
       stream_.Print("Precompiled_AllocationStub_%s_%" Pd ":\n", name, i);
     } else if (owner.IsFunction()) {
       const char* name = Function::Cast(owner).ToQualifiedCString();
       EnsureIdentifier(const_cast<char*>(name));
       stream_.Print("Precompiled_%s_%" Pd ":\n", name, i);
     } else {
       UNREACHABLE();
     }
 
     {
       // 3. Write from the entry point to the end.
       NoSafepointScope no_safepoint;
       uword beginning = reinterpret_cast<uword>(insns.raw()) - kHeapObjectTag;
       uword entry = beginning + Instructions::HeaderSize();
-      uword end = beginning + insns.raw()->Size();
+      uword payload_size = insns.size();
+      payload_size = Utils::RoundUp(payload_size, OS::PreferredCodeAlignment());
+      uword end = entry + payload_size;
 
       ASSERT(Utils::IsAligned(beginning, sizeof(uint64_t)));
       ASSERT(Utils::IsAligned(entry, sizeof(uint64_t)));
       ASSERT(Utils::IsAligned(end, sizeof(uint64_t)));
 
       for (uword* cursor = reinterpret_cast<uword*>(entry);
            cursor < reinterpret_cast<uword*>(end);
            cursor++) {
         WriteWordLiteral(*cursor);
       }
@@ skipping 31 matching lines @@
     start += sizeof(uword);
     for (uword* cursor = reinterpret_cast<uword*>(start);
          cursor < reinterpret_cast<uword*>(end);
          cursor++) {
       WriteWordLiteral(*cursor);
     }
   }
 }
 
 
-RawInstructions* InstructionsReader::GetInstructionsAt(int32_t offset,
-                                                       uword expected_tags) {
+uword InstructionsReader::GetInstructionsAt(int32_t offset) {
   ASSERT(Utils::IsAligned(offset, OS::PreferredCodeAlignment()));
-
-  RawInstructions* result =
-      reinterpret_cast<RawInstructions*>(
-          reinterpret_cast<uword>(instructions_buffer_) +
-          offset + kHeapObjectTag);
-
-#ifdef DEBUG
-  uword actual_tags = result->ptr()->tags_;
-  if (actual_tags != expected_tags) {
-    FATAL2("Instructions tag mismatch: expected %" Pd ", saw %" Pd,
-           expected_tags,
-           actual_tags);
-  }
-#endif
-
-  ASSERT(result->IsMarked());
-
-  return result;
+  return reinterpret_cast<uword>(instructions_buffer_) + offset;
 }
 
 
 RawObject* InstructionsReader::GetObjectAt(int32_t offset) {
   ASSERT(Utils::IsAligned(offset, kWordSize));
 
   RawObject* result =
       reinterpret_cast<RawObject*>(
           reinterpret_cast<uword>(data_buffer_) + offset + kHeapObjectTag);
   ASSERT(result->IsMarked());
@@ skipping 1340 matching lines @@
   if (setjmp(*jump.Set()) == 0) {
     NoSafepointScope no_safepoint;
     WriteObject(obj.raw());
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart