JIT precompilated snapshots.

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 626 matching lines @@
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kClosureDataCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Context scope.
   if (ptr()->context_scope_ == Object::empty_context_scope().raw()) {
     writer->WriteVMIsolateObject(kEmptyContextScopeObject);
+  } else if (ptr()->context_scope_->ptr()->is_implicit_ ||
+             (kind == Snapshot::kAppWithJIT)) {
+    writer->WriteObjectImpl(ptr()->context_scope_, kAsInlinedObject);
   } else {
-    if (ptr()->context_scope_->ptr()->is_implicit_) {
-      writer->WriteObjectImpl(ptr()->context_scope_, kAsInlinedObject);
-    } else {
-      // We don't write non implicit context scopes in the snapshot.
-      writer->WriteVMIsolateObject(kNullObject);
-    }
+    // We don't write non implicit context scopes in the snapshot.
+    writer->WriteVMIsolateObject(kNullObject);
   }
 
   // Parent function.
   writer->WriteObjectImpl(ptr()->parent_function_, kAsInlinedObject);
 
   // Signature type.
   writer->WriteObjectImpl(ptr()->signature_type_, kAsInlinedObject);
 
   // Canonical static closure.
   writer->WriteObjectImpl(ptr()->closure_, kAsInlinedObject);
@@ skipping 59 matching lines @@
 
     // Set all the non object fields. Read the token positions now but
     // don't set them until after setting the kind.
     const int32_t token_pos = reader->Read<int32_t>();
     const int32_t end_token_pos = reader->Read<uint32_t>();
     func.set_num_fixed_parameters(reader->Read<int16_t>());
     func.set_num_optional_parameters(reader->Read<int16_t>());
     func.set_kind_tag(reader->Read<uint32_t>());
     func.set_token_pos(TokenPosition::SnapshotDecode(token_pos));
     func.set_end_token_pos(TokenPosition::SnapshotDecode(end_token_pos));
-    if (Snapshot::IncludesCode(kind)) {
+    if (kind == Snapshot::kAppNoJIT) {
       func.set_usage_counter(0);
       func.set_deoptimization_counter(0);
       func.set_optimized_instruction_count(0);
       func.set_optimized_call_site_count(0);
     } else {
       func.set_usage_counter(reader->Read<int32_t>());
       func.set_deoptimization_counter(reader->Read<int8_t>());
       func.set_optimized_instruction_count(reader->Read<uint16_t>());
       func.set_optimized_call_site_count(reader->Read<uint16_t>());
     }
     func.set_was_compiled(false);
 
     // Set all the object fields.
     READ_OBJECT_FIELDS(func,
                        func.raw()->from(), func.raw()->to_snapshot(),
                        kAsReference);
     // Initialize all fields that are not part of the snapshot.
-    if (Snapshot::IncludesCode(kind)) {
+    if (kind == Snapshot::kAppNoJIT) {
       func.ClearICDataArray();
       func.ClearCode();
       // Read the code object and fixup entry point.
       (*reader->CodeHandle()) ^= reader->ReadObjectImpl(kAsInlinedObject);
       func.SetInstructions(*reader->CodeHandle());
+    } else if (kind == Snapshot::kAppWithJIT) {
+      func.ClearICDataArray();
+      func.ClearCode();
+      (*reader->ArrayHandle()) ^= reader->ReadObjectImpl(kAsReference);
+      func.set_ic_data_array(*reader->ArrayHandle());
+      (*reader->CodeHandle()) ^= reader->ReadObjectImpl(kAsInlinedObject);
+      func.set_unoptimized_code(*reader->CodeHandle());
+      if (!reader->CodeHandle()->IsNull()) {
+        func.SetInstructions(*reader->CodeHandle());
+        func.set_was_compiled(true);
+      }
     } else {
       bool is_optimized = func.usage_counter() != 0;
       if (is_optimized) {
         // Read the ic data array as the function is an optimized one.
         (*reader->ArrayHandle()) ^= reader->ReadObjectImpl(kAsReference);
         func.set_ic_data_array(*reader->ArrayHandle());
       } else {
         func.ClearICDataArray();
       }
       func.ClearCode();
@@ skipping 10 matching lines @@
                           Snapshot::Kind kind,
                           bool as_reference) {
   ASSERT(writer != NULL);
   ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
   bool is_in_fullsnapshot = false;
   bool owner_is_class = false;
   if ((kind == Snapshot::kScript) && !Function::IsSignatureFunction(this)) {
     intptr_t tags = writer->GetObjectTags(ptr()->owner_);
     intptr_t cid = ClassIdTag::decode(tags);
     owner_is_class = (cid == kClassCid);
-    is_in_fullsnapshot =  owner_is_class ?
+    is_in_fullsnapshot = owner_is_class ?
         Class::IsInFullSnapshot(reinterpret_cast<RawClass*>(ptr()->owner_)) :
         PatchClass::IsInFullSnapshot(
             reinterpret_cast<RawPatchClass*>(ptr()->owner_));
   }
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kFunctionCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out the boolean is_in_fullsnapshot first as this will
   // help the reader decide how the rest of the information needs
   // to be interpreted.
   writer->Write<bool>(is_in_fullsnapshot);
 
   if (Snapshot::IsFull(kind) || !is_in_fullsnapshot) {
     bool is_optimized = Code::IsOptimized(ptr()->code_);
 
     // Write out all the non object fields.
     writer->Write<int32_t>(ptr()->token_pos_.SnapshotEncode());
     writer->Write<int32_t>(ptr()->end_token_pos_.SnapshotEncode());
     writer->Write<int16_t>(ptr()->num_fixed_parameters_);
     writer->Write<int16_t>(ptr()->num_optional_parameters_);
     writer->Write<uint32_t>(ptr()->kind_tag_);
-    if (Snapshot::IncludesCode(kind)) {
+    if (kind == Snapshot::kAppNoJIT) {
       // Omit fields used to support de/reoptimization.
     } else {
       if (is_optimized) {
         writer->Write<int32_t>(FLAG_optimization_counter_threshold);
       } else {
         writer->Write<int32_t>(0);
       }
       writer->Write<int8_t>(ptr()->deoptimization_counter_);
       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, kAsReference);
     visitor.VisitPointers(from(), to_snapshot());
-    if (Snapshot::IncludesCode(kind)) {
+    if (kind == Snapshot::kAppNoJIT) {
       ASSERT(ptr()->ic_data_array_ == Array::null());
       ASSERT((ptr()->code_ == ptr()->unoptimized_code_) ||
              (ptr()->unoptimized_code_ == Code::null()));
-      // Write out the code object as we are generating a precompiled snapshot.
       writer->WriteObjectImpl(ptr()->code_, kAsInlinedObject);
+    } else if (kind == Snapshot::kAppWithJIT) {
+      writer->WriteObjectImpl(ptr()->ic_data_array_, kAsReference);
+      writer->WriteObjectImpl(ptr()->unoptimized_code_, kAsInlinedObject);
     } else if (is_optimized) {
-      // Write out the ic data array as the function is optimized or
-      // we are generating a precompiled snapshot.
+      // Write out the ic data array as the function is optimized.
       writer->WriteObjectImpl(ptr()->ic_data_array_, kAsReference);
     }
   } else {
     writer->WriteFunctionId(this, owner_is_class);
   }
 }
 
 
 RawField* Field::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
@@ skipping 66 matching lines @@
   // Write out the owner.
   writer->WriteObjectImpl(ptr()->owner_, kAsReference);
   // Write out the type.
   writer->WriteObjectImpl(ptr()->type_, kAsReference);
   // Write out the initial static value or field offset.
   if (Field::StaticBit::decode(ptr()->kind_bits_)) {
     if (kind == Snapshot::kAppNoJIT) {
       // For precompiled static fields, the value was already reset and
       // initializer_ now contains a Function.
       writer->WriteObjectImpl(ptr()->value_.static_value_, kAsReference);
+    } else if (Field::ConstBit::decode(ptr()->kind_bits_)) {
+      // Do not reset const fields.
+      writer->WriteObjectImpl(ptr()->value_.static_value_, kAsReference);
     } else {
       // Otherwise, for static fields we write out the initial static value.
       writer->WriteObjectImpl(ptr()->initializer_.saved_value_, kAsReference);
     }
   } else {
     writer->WriteObjectImpl(ptr()->value_.offset_, kAsReference);
   }
   // Write out the initializer function or saved initial value.
   if (kind == Snapshot::kAppNoJIT) {
     writer->WriteObjectImpl(ptr()->initializer_.precompiled_, kAsReference);
@@ skipping 419 matching lines @@
   ASSERT(Snapshot::IsFull(kind));
 
   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);
 
   int32_t text_offset = reader->Read<int32_t>();
-  int32_t instructions_size = reader->Read<int32_t>();
-  uword entry_point = reader->GetInstructionsAt(text_offset);
+  RawInstructions* instr = reinterpret_cast<RawInstructions*>(
+      reader->GetInstructionsAt(text_offset) + kHeapObjectTag);
+  uword entry_point = Instructions::EntryPoint(instr);
 
 #if defined(DEBUG)
+  ASSERT(instr->IsMarked());
+  ASSERT(instr->IsVMHeapObject());
   uword expected_check = reader->Read<uword>();
+  intptr_t instructions_size = Utils::RoundUp(instr->size_,
+                                              OS::PreferredCodeAlignment());
   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));
+  result.StorePointer(&result.raw_ptr()->active_instructions_, instr);
+  result.StorePointer(&result.raw_ptr()->instructions_, instr);
 
   (*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());
 
@@ skipping 23 matching lines @@
                       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(Snapshot::IncludesCode(kind));
   ASSERT(Snapshot::IsFull(kind));
 
   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");
+  // Cannot serialize code with embedded pointers (IA32).
+  ASSERT(pointer_offsets_length == 0);
+  if (kind == Snapshot::kAppNoJIT) {
+    // No disabled code in precompilation.
+    ASSERT(ptr()->instructions_ == ptr()->active_instructions_);
+  } else {
+    ASSERT(kind == Snapshot::kAppWithJIT);
+    // We never include optimized code in JIT precompilation. Deoptimization
+    // requires code patching and we cannot patch code that is shared between
+    // isolates and should not mutate memory allocated by the embedder.
+    bool is_optimized = Code::PtrOffBits::decode(ptr()->state_bits_);
+    ASSERT(!is_optimized);
   }
 
   // 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_);
 
   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);
+  intptr_t instructions_size = Utils::RoundUp(instr->size_,
+                                              OS::PreferredCodeAlignment());
+  uword check = Checksum(entry, instructions_size);
   writer->Write<uword>(check);
 #endif
 
   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);
 }
@@ skipping 450 matching lines @@
 
     // Create a descriptor for 'this' variable.
     context_scope.SetTokenIndexAt(0, TokenPosition::kMinSource);
     context_scope.SetNameAt(0, Symbols::This());
     context_scope.SetIsFinalAt(0, true);
     context_scope.SetIsConstAt(0, false);
     context_scope.SetTypeAt(0, *reader->TypeHandle());
     context_scope.SetContextIndexAt(0, 0);
     context_scope.SetContextLevelAt(0, 0);
     return context_scope.raw();
+  } else if (kind == Snapshot::kAppWithJIT) {
+    int32_t num_vars = reader->Read<int32_t>();
+
+    ContextScope& context_scope = ContextScope::ZoneHandle();
+    context_scope = reader->NewContextScope(num_vars);
+    context_scope.set_is_implicit(false);
+    reader->AddBackRef(object_id, &context_scope, kIsDeserialized);
+
+    READ_OBJECT_FIELDS(context_scope,
+                       context_scope.raw()->from(),
+                       context_scope.raw()->to(num_vars),
+                       kAsInlinedObject);
+    return context_scope.raw();
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 void RawContextScope::WriteTo(SnapshotWriter* writer,
                               intptr_t object_id,
                               Snapshot::Kind kind,
                               bool as_reference) {
@@ skipping 10 matching lines @@
     writer->WriteVMIsolateObject(kContextScopeCid);
     writer->WriteTags(writer->GetObjectTags(this));
 
     // Write out is_implicit flag for the context scope.
     writer->Write<bool>(true);
 
     // Write out the type of 'this' the variable.
     writer->WriteObjectImpl(var->type, kAsInlinedObject);
 
     return;
+  } else if (kind == Snapshot::kAppWithJIT) {
+    // Write out the serialization header value for this object.
+    writer->WriteInlinedObjectHeader(object_id);
+
+    // Write out the class and tags information.
+    writer->WriteVMIsolateObject(kContextScopeCid);
+    writer->WriteTags(writer->GetObjectTags(this));
+
+    // Write out is_implicit flag for the context scope.
+    writer->Write<bool>(false);
+    int32_t num_vars = ptr()->num_variables_;
+    writer->Write<int32_t>(num_vars);
+
+    SnapshotWriterVisitor visitor(writer, kAsInlinedObject);
+    visitor.VisitPointers(from(), to(num_vars));
+
+    return;
   }
   UNREACHABLE();
 }
 
 
 RawICData* ICData::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind,
                             bool as_reference) {
@@ skipping 1728 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