Refactor snapshots pieces to include a section for loading instructions into the heap of a regular …

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2013, 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 "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "lib/stacktrace.h"
@@ skipping 1154 matching lines @@
         "Dart_Initialize: "
         "Dart_InitializeParams is null.");
   }
 
   if (params->version != DART_INITIALIZE_PARAMS_CURRENT_VERSION) {
     return strdup(
         "Dart_Initialize: "
         "Invalid Dart_InitializeParams version.");
   }
 
-  return Dart::InitOnce(params->vm_isolate_snapshot,
-                        params->instructions_snapshot, params->data_snapshot,
-                        params->create, params->shutdown, params->thread_exit,
-                        params->file_open, params->file_read,
-                        params->file_write, params->file_close,
-                        params->entropy_source, params->get_service_assets);
+  return Dart::InitOnce(
+      params->vm_snapshot_data, params->vm_snapshot_instructions,
+      params->create, params->shutdown, params->thread_exit, params->file_open,
+      params->file_read, params->file_write, params->file_close,
+      params->entropy_source, params->get_service_assets);
 }
 
 
 DART_EXPORT char* Dart_Cleanup() {
   CHECK_NO_ISOLATE(Isolate::Current());
   const char* err_msg = Dart::Cleanup();
   if (err_msg != NULL) {
     return strdup(err_msg);
   }
   return NULL;
@@ skipping 42 matching lines @@
   char* chars = NULL;
   intptr_t len = OS::SNPrint(NULL, 0, "%s$%s", script_uri, main) + 1;
   chars = reinterpret_cast<char*>(malloc(len));
   OS::SNPrint(chars, len, "%s$%s", script_uri, main);
   return chars;
 }
 
 
 static Dart_Isolate CreateIsolate(const char* script_uri,
                                   const char* main,
-                                  const uint8_t* snapshot_buffer,
+                                  const uint8_t* snapshot_data,
+                                  const uint8_t* snapshot_instructions,
                                   intptr_t snapshot_length,
                                   kernel::Program* kernel_program,
                                   Dart_IsolateFlags* flags,
                                   void* callback_data,
                                   char** error) {
   CHECK_NO_ISOLATE(Isolate::Current());
   char* isolate_name = BuildIsolateName(script_uri, main);
 
   // Setup default flags in case none were passed.
   Dart_IsolateFlags api_flags;
   if (flags == NULL) {
     Isolate::FlagsInitialize(&api_flags);
     flags = &api_flags;
   }
   Isolate* I = Dart::CreateIsolate(isolate_name, *flags);
   free(isolate_name);
   if (I == NULL) {
     *error = strdup("Isolate creation failed");
     return reinterpret_cast<Dart_Isolate>(NULL);
   }
   {
     Thread* T = Thread::Current();
     StackZone zone(T);
     HANDLESCOPE(T);
     // We enter an API scope here as InitializeIsolate could compile some
     // bootstrap library files which call out to a tag handler that may create
     // Api Handles when an error is encountered.
     Dart_EnterScope();
-    const Error& error_obj = Error::Handle(
-        Z, Dart::InitializeIsolate(snapshot_buffer, snapshot_length,
-                                   kernel_program, callback_data));
+    const Error& error_obj =
+        Error::Handle(Z, Dart::InitializeIsolate(
+                             snapshot_data, snapshot_instructions,
+                             snapshot_length, kernel_program, callback_data));
     if (error_obj.IsNull()) {
 #if defined(DART_NO_SNAPSHOT) && !defined(PRODUCT)
       if (FLAG_check_function_fingerprints && kernel_program == NULL) {
         Library::CheckFunctionFingerprints();
       }
 #endif  // defined(DART_NO_SNAPSHOT) && !defined(PRODUCT).
       // We exit the API scope entered above.
       Dart_ExitScope();
       // A Thread structure has been associated to the thread, we do the
       // safepoint transition explicity here instead of using the
       // TransitionXXX scope objects as the reverse transition happens
       // outside this scope in Dart_ShutdownIsolate/Dart_ExitIsolate.
       T->set_execution_state(Thread::kThreadInNative);
       T->EnterSafepoint();
       return Api::CastIsolate(I);
     }
     *error = strdup(error_obj.ToErrorCString());
     // We exit the API scope entered above.
     Dart_ExitScope();
   }
   Dart::ShutdownIsolate();
   return reinterpret_cast<Dart_Isolate>(NULL);
 }
 
 
-DART_EXPORT Dart_Isolate Dart_CreateIsolate(const char* script_uri,
-                                            const char* main,
-                                            const uint8_t* snapshot_buffer,
-                                            Dart_IsolateFlags* flags,
-                                            void* callback_data,
-                                            char** error) {
-  return CreateIsolate(script_uri, main, snapshot_buffer, -1, NULL, flags,
-                       callback_data, error);
+DART_EXPORT Dart_Isolate
+Dart_CreateIsolate(const char* script_uri,
+                   const char* main,
+                   const uint8_t* snapshot_data,
+                   const uint8_t* snapshot_instructions,
+                   Dart_IsolateFlags* flags,
+                   void* callback_data,
+                   char** error) {
+  return CreateIsolate(script_uri, main, snapshot_data, snapshot_instructions,
+                       -1, NULL, flags, callback_data, error);
 }
 
 
 DART_EXPORT Dart_Isolate Dart_CreateIsolateFromKernel(const char* script_uri,
                                                       const char* main,
                                                       void* kernel_program,
                                                       Dart_IsolateFlags* flags,
                                                       void* callback_data,
                                                       char** error) {
-  return CreateIsolate(script_uri, main, NULL, -1,
+  return CreateIsolate(script_uri, main, NULL, NULL, -1,
                        reinterpret_cast<kernel::Program*>(kernel_program),
                        flags, callback_data, error);
 }
 
 
 DART_EXPORT void Dart_ShutdownIsolate() {
   Thread* T = Thread::Current();
   Isolate* I = T->isolate();
   CHECK_ISOLATE(I);
   I->WaitForOutstandingSpawns();
@@ skipping 209 matching lines @@
 static uint8_t* ApiReallocate(uint8_t* ptr,
                               intptr_t old_size,
                               intptr_t new_size) {
   return Api::TopScope(Thread::Current())
       ->zone()
       ->Realloc<uint8_t>(ptr, old_size, new_size);
 }
 
 
 DART_EXPORT Dart_Handle
-Dart_CreateSnapshot(uint8_t** vm_isolate_snapshot_buffer,
-                    intptr_t* vm_isolate_snapshot_size,
-                    uint8_t** isolate_snapshot_buffer,
-                    intptr_t* isolate_snapshot_size) {
+Dart_CreateSnapshot(uint8_t** vm_snapshot_data_buffer,
+                    intptr_t* vm_snapshot_data_size,
+                    uint8_t** isolate_snapshot_data_buffer,
+                    intptr_t* isolate_snapshot_data_size) {
   DARTSCOPE(Thread::Current());
   API_TIMELINE_DURATION;
   Isolate* I = T->isolate();
   if (!FLAG_load_deferred_eagerly) {
     return Api::NewError(
         "Creating full snapshots requires --load_deferred_eagerly");
   }
-  if (vm_isolate_snapshot_buffer != NULL && vm_isolate_snapshot_size == NULL) {
-    RETURN_NULL_ERROR(vm_isolate_snapshot_size);
+  if (vm_snapshot_data_buffer != NULL && vm_snapshot_data_size == NULL) {
+    RETURN_NULL_ERROR(vm_snapshot_data_size);
   }
-  if (isolate_snapshot_buffer == NULL) {
-    RETURN_NULL_ERROR(isolate_snapshot_buffer);
+  if (isolate_snapshot_data_buffer == NULL) {
+    RETURN_NULL_ERROR(isolate_snapshot_data_buffer);
   }
-  if (isolate_snapshot_size == NULL) {
-    RETURN_NULL_ERROR(isolate_snapshot_size);
+  if (isolate_snapshot_data_size == NULL) {
+    RETURN_NULL_ERROR(isolate_snapshot_data_size);
   }
   // Finalize all classes if needed.
   Dart_Handle state = Api::CheckAndFinalizePendingClasses(T);
   if (::Dart_IsError(state)) {
     return state;
   }
   I->StopBackgroundCompiler();
 
 #if defined(DEBUG)
   I->heap()->CollectAllGarbage();
   CheckFunctionTypesVisitor check_canonical(T);
   I->heap()->IterateObjects(&check_canonical);
 #endif  // #if defined(DEBUG)
 
-  FullSnapshotWriter writer(Snapshot::kCore, vm_isolate_snapshot_buffer,
-                            isolate_snapshot_buffer, ApiReallocate,
-                            NULL /* instructions_writer */);
+  FullSnapshotWriter writer(Snapshot::kCore, vm_snapshot_data_buffer,
+                            isolate_snapshot_data_buffer, ApiReallocate,
+                            NULL /* vm_instructions_writer */,
+                            NULL /* isolate_instructions_writer */);
   writer.WriteFullSnapshot();
-  if (vm_isolate_snapshot_buffer != NULL) {
-    *vm_isolate_snapshot_size = writer.VmIsolateSnapshotSize();
+  if (vm_snapshot_data_buffer != NULL) {
+    *vm_snapshot_data_size = writer.VmIsolateSnapshotSize();
   }
-  *isolate_snapshot_size = writer.IsolateSnapshotSize();
+  *isolate_snapshot_data_size = writer.IsolateSnapshotSize();
   return Api::Success();
 }
 
 
-DART_EXPORT Dart_Handle Dart_CreateScriptSnapshot(uint8_t** buffer,
-                                                  intptr_t* size) {
+DART_EXPORT Dart_Handle
+Dart_CreateScriptSnapshot(uint8_t** script_snapshot_buffer,
+                          intptr_t* script_snapshot_size) {
   API_TIMELINE_DURATION;
   DARTSCOPE(Thread::Current());
   Isolate* I = T->isolate();
-  if (buffer == NULL) {
-    RETURN_NULL_ERROR(buffer);
+  if (script_snapshot_buffer == NULL) {
+    RETURN_NULL_ERROR(script_snapshot_buffer);
   }
-  if (size == NULL) {
-    RETURN_NULL_ERROR(size);
+  if (script_snapshot_size == NULL) {
+    RETURN_NULL_ERROR(script_snapshot_size);
   }
   // Finalize all classes if needed.
   Dart_Handle state = Api::CheckAndFinalizePendingClasses(T);
   if (::Dart_IsError(state)) {
     return state;
   }
   Library& lib = Library::Handle(Z, I->object_store()->root_library());
 
 #if defined(DEBUG)
   I->heap()->CollectAllGarbage();
   CheckFunctionTypesVisitor check_canonical(T);
   I->heap()->IterateObjects(&check_canonical);
 #endif  // #if defined(DEBUG)
 
-  ScriptSnapshotWriter writer(buffer, ApiReallocate);
+  ScriptSnapshotWriter writer(script_snapshot_buffer, ApiReallocate);
   writer.WriteScriptSnapshot(lib);
-  *size = writer.BytesWritten();
+  *script_snapshot_size = writer.BytesWritten();
   return Api::Success();
 }
 
 
 DART_EXPORT void Dart_InterruptIsolate(Dart_Isolate isolate) {
   if (isolate == NULL) {
     FATAL1("%s expects argument 'isolate' to be non-null.", CURRENT_FUNC);
   }
   // TODO(16615): Validate isolate parameter.
   TransitionNativeToVM transition(Thread::Current());
@@ skipping 2230 matching lines @@
       redirect_type ^= redirect_type.Canonicalize();
     }
 
     type_obj = redirect_type.raw();
     type_arguments = redirect_type.arguments();
 
     cls = type_obj.type_class();
   }
   if (constructor.IsGenerativeConstructor()) {
 #if defined(DEBUG)
-    if (!cls.is_allocated() && (Dart::snapshot_kind() == Snapshot::kAppAOT)) {
+    if (!cls.is_allocated() &&
+        (Dart::vm_snapshot_kind() == Snapshot::kAppAOT)) {
       return Api::NewError("Precompilation dropped '%s'", cls.ToCString());
     }
 #endif
     // Create the new object.
     new_object = Instance::New(cls);
   }
 
   // Create the argument list.
   intptr_t arg_index = 0;
   int extra_args = 1;
@@ skipping 74 matching lines @@
   DARTSCOPE(Thread::Current());
   CHECK_CALLBACK_STATE(T);
 
   const Type& type_obj = Api::UnwrapTypeHandle(Z, type);
   // Get the class to instantiate.
   if (type_obj.IsNull()) {
     RETURN_TYPE_ERROR(Z, type, Type);
   }
   const Class& cls = Class::Handle(Z, type_obj.type_class());
 #if defined(DEBUG)
-  if (!cls.is_allocated() && (Dart::snapshot_kind() == Snapshot::kAppAOT)) {
+  if (!cls.is_allocated() && (Dart::vm_snapshot_kind() == Snapshot::kAppAOT)) {
     return Api::NewError("Precompilation dropped '%s'", cls.ToCString());
   }
 #endif
   const Error& error = Error::Handle(Z, cls.EnsureIsFinalized(T));
   if (!error.IsNull()) {
     // An error occurred, return error object.
     return Api::NewHandle(T, error.raw());
   }
   return Api::NewHandle(T, AllocateObject(T, cls));
 }
 
 
 DART_EXPORT Dart_Handle
 Dart_AllocateWithNativeFields(Dart_Handle type,
                               intptr_t num_native_fields,
                               const intptr_t* native_fields) {
   DARTSCOPE(Thread::Current());
   CHECK_CALLBACK_STATE(T);
 
   const Type& type_obj = Api::UnwrapTypeHandle(Z, type);
   // Get the class to instantiate.
   if (type_obj.IsNull()) {
     RETURN_TYPE_ERROR(Z, type, Type);
   }
   if (native_fields == NULL) {
     RETURN_NULL_ERROR(native_fields);
   }
   const Class& cls = Class::Handle(Z, type_obj.type_class());
 #if defined(DEBUG)
-  if (!cls.is_allocated() && (Dart::snapshot_kind() == Snapshot::kAppAOT)) {
+  if (!cls.is_allocated() && (Dart::vm_snapshot_kind() == Snapshot::kAppAOT)) {
     return Api::NewError("Precompilation dropped '%s'", cls.ToCString());
   }
 #endif
   const Error& error = Error::Handle(Z, cls.EnsureIsFinalized(T));
   if (!error.IsNull()) {
     // An error occurred, return error object.
     return Api::NewHandle(T, error.raw());
   }
   if (num_native_fields != cls.num_native_fields()) {
     return Api::NewError(
@@ skipping 2624 matching lines @@
     RETURN_NULL_ERROR(assembly_buffer);
   }
   if (assembly_size == NULL) {
     RETURN_NULL_ERROR(assembly_size);
   }
 
   NOT_IN_PRODUCT(TimelineDurationScope tds2(T, Timeline::GetIsolateStream(),
                                             "WriteAppAOTSnapshot"));
   AssemblyInstructionsWriter instructions_writer(assembly_buffer, ApiReallocate,
                                                  2 * MB /* initial_size */);
-  uint8_t* vm_isolate_snapshot_buffer = NULL;
-  uint8_t* isolate_snapshot_buffer = NULL;
-  FullSnapshotWriter writer(Snapshot::kAppAOT, &vm_isolate_snapshot_buffer,
-                            &isolate_snapshot_buffer, ApiReallocate,
-                            &instructions_writer);
+  uint8_t* vm_snapshot_data_buffer = NULL;
+  uint8_t* isolate_snapshot_data_buffer = NULL;
+  FullSnapshotWriter writer(Snapshot::kAppAOT, &vm_snapshot_data_buffer,
+                            &isolate_snapshot_data_buffer, ApiReallocate,
+                            &instructions_writer, &instructions_writer);
 
   writer.WriteFullSnapshot();
   *assembly_size = instructions_writer.AssemblySize();
 
   return Api::Success();
 #endif
 }
 
 
 DART_EXPORT Dart_Handle
-Dart_CreateAppAOTSnapshotAsBlobs(uint8_t** vm_isolate_snapshot_buffer,
-                                 intptr_t* vm_isolate_snapshot_size,
-                                 uint8_t** isolate_snapshot_buffer,
-                                 intptr_t* isolate_snapshot_size,
-                                 uint8_t** instructions_blob_buffer,
-                                 intptr_t* instructions_blob_size,
-                                 uint8_t** rodata_blob_buffer,
-                                 intptr_t* rodata_blob_size) {
+Dart_CreateAppAOTSnapshotAsBlobs(uint8_t** vm_snapshot_data_buffer,
+                                 intptr_t* vm_snapshot_data_size,
+                                 uint8_t** vm_snapshot_instructions_buffer,
+                                 intptr_t* vm_snapshot_instructions_size,
+                                 uint8_t** isolate_snapshot_data_buffer,
+                                 intptr_t* isolate_snapshot_data_size,
+                                 uint8_t** isolate_snapshot_instructions_buffer,
+                                 intptr_t* isolate_snapshot_instructions_size) {
 #if defined(TARGET_ARCH_IA32)
   return Api::NewError("AOT compilation is not supported on IA32.");
 #elif defined(TARGET_ARCH_DBC)
   return Api::NewError("AOT compilation is not supported on DBC.");
 #elif !defined(DART_PRECOMPILER)
   return Api::NewError(
       "This VM was built without support for AOT compilation.");
 #else
   API_TIMELINE_DURATION;
   DARTSCOPE(Thread::Current());
   Isolate* I = T->isolate();
   if (I->compilation_allowed()) {
     return Api::NewError(
         "Isolate is not precompiled. "
         "Did you forget to call Dart_Precompile?");
   }
   ASSERT(FLAG_load_deferred_eagerly);
-  if (vm_isolate_snapshot_buffer == NULL) {
-    RETURN_NULL_ERROR(vm_isolate_snapshot_buffer);
+  if (vm_snapshot_data_buffer == NULL) {
+    RETURN_NULL_ERROR(vm_snapshot_data_buffer);
   }
-  if (vm_isolate_snapshot_size == NULL) {
-    RETURN_NULL_ERROR(vm_isolate_snapshot_size);
+  if (vm_snapshot_data_size == NULL) {
+    RETURN_NULL_ERROR(vm_snapshot_data_size);
   }
-  if (isolate_snapshot_buffer == NULL) {
-    RETURN_NULL_ERROR(isolate_snapshot_buffer);
+  if (vm_snapshot_instructions_buffer == NULL) {
+    RETURN_NULL_ERROR(vm_snapshot_instructions_buffer);
   }
-  if (isolate_snapshot_size == NULL) {
-    RETURN_NULL_ERROR(isolate_snapshot_size);
+  if (vm_snapshot_instructions_size == NULL) {
+    RETURN_NULL_ERROR(vm_snapshot_instructions_size);
   }
-  if (instructions_blob_buffer == NULL) {
-    RETURN_NULL_ERROR(instructions_blob_buffer);
+  if (isolate_snapshot_data_buffer == NULL) {
+    RETURN_NULL_ERROR(isolate_snapshot_data_buffer);
   }
-  if (instructions_blob_size == NULL) {
-    RETURN_NULL_ERROR(instructions_blob_size);
+  if (isolate_snapshot_data_size == NULL) {
+    RETURN_NULL_ERROR(isolate_snapshot_data_size);
   }
-  if (rodata_blob_buffer == NULL) {
-    RETURN_NULL_ERROR(instructions_blob_buffer);
+  if (isolate_snapshot_instructions_buffer == NULL) {
+    RETURN_NULL_ERROR(instructions_snapshot_blob_buffer);
   }
-  if (rodata_blob_size == NULL) {
-    RETURN_NULL_ERROR(instructions_blob_size);
+  if (isolate_snapshot_instructions_buffer == NULL) {
+    RETURN_NULL_ERROR(instructions_snapshot_blob_size);
   }
 
   NOT_IN_PRODUCT(TimelineDurationScope tds2(T, Timeline::GetIsolateStream(),
                                             "WriteAppAOTSnapshot"));
-  BlobInstructionsWriter instructions_writer(instructions_blob_buffer,
-                                             rodata_blob_buffer, ApiReallocate,
-                                             2 * MB /* initial_size */);
-  FullSnapshotWriter writer(Snapshot::kAppAOT, vm_isolate_snapshot_buffer,
-                            isolate_snapshot_buffer, ApiReallocate,
-                            &instructions_writer);
+  BlobInstructionsWriter vm_instructions_writer(vm_snapshot_instructions_buffer,
+                                                ApiReallocate,
+                                                2 * MB /* initial_size */);
+  BlobInstructionsWriter isolate_instructions_writer(
+      isolate_snapshot_instructions_buffer, ApiReallocate,
+      2 * MB /* initial_size */);
+  FullSnapshotWriter writer(
+      Snapshot::kAppAOT, vm_snapshot_data_buffer, isolate_snapshot_data_buffer,
+      ApiReallocate, &vm_instructions_writer, &isolate_instructions_writer);
 
   writer.WriteFullSnapshot();
-  *vm_isolate_snapshot_size = writer.VmIsolateSnapshotSize();
-  *isolate_snapshot_size = writer.IsolateSnapshotSize();
-  *instructions_blob_size = instructions_writer.InstructionsBlobSize();
-  *rodata_blob_size = instructions_writer.RodataBlobSize();
+  *vm_snapshot_data_size = writer.VmIsolateSnapshotSize();
+  *vm_snapshot_instructions_size =
+      vm_instructions_writer.InstructionsBlobSize();
+  *isolate_snapshot_data_size = writer.IsolateSnapshotSize();
+  *isolate_snapshot_instructions_size =
+      isolate_instructions_writer.InstructionsBlobSize();
 
   return Api::Success();
 #endif
 }
 
 
 DART_EXPORT Dart_Handle
-Dart_CreateAppJITSnapshotAsBlobs(uint8_t** isolate_snapshot_buffer,
-                                 intptr_t* isolate_snapshot_size,
-                                 uint8_t** instructions_blob_buffer,
-                                 intptr_t* instructions_blob_size,
-                                 uint8_t** rodata_blob_buffer,
-                                 intptr_t* rodata_blob_size) {
+Dart_CreateAppJITSnapshotAsBlobs(uint8_t** isolate_snapshot_data_buffer,
+                                 intptr_t* isolate_snapshot_data_size,
+                                 uint8_t** isolate_snapshot_instructions_buffer,
+                                 intptr_t* isolate_snapshot_instructions_size) {
 #if defined(TARGET_ARCH_IA32)
   return Api::NewError("Snapshots with code are not supported on IA32.");
 #elif defined(TARGET_ARCH_DBC)
   return Api::NewError("Snapshots with code are not supported on DBC.");
 #elif defined(DART_PRECOMPILED_RUNTIME)
   return Api::NewError("JIT app snapshots cannot be taken from an AOT runtime");
 #else
   API_TIMELINE_DURATION;
   DARTSCOPE(Thread::Current());
   Isolate* I = T->isolate();
   if (!FLAG_load_deferred_eagerly) {
     return Api::NewError(
         "Creating full snapshots requires --load_deferred_eagerly");
   }
-  if (isolate_snapshot_buffer == NULL) {
-    RETURN_NULL_ERROR(isolate_snapshot_buffer);
+  if (isolate_snapshot_data_buffer == NULL) {
+    RETURN_NULL_ERROR(isolate_snapshot_data_buffer);
   }
-  if (isolate_snapshot_size == NULL) {
-    RETURN_NULL_ERROR(isolate_snapshot_size);
+  if (isolate_snapshot_data_size == NULL) {
+    RETURN_NULL_ERROR(isolate_snapshot_data_size);
   }
-  if (instructions_blob_buffer == NULL) {
-    RETURN_NULL_ERROR(instructions_blob_buffer);
+  if (isolate_snapshot_instructions_buffer == NULL) {
+    RETURN_NULL_ERROR(instructions_snapshot_blob_buffer);
   }
-  if (instructions_blob_size == NULL) {
-    RETURN_NULL_ERROR(instructions_blob_size);
-  }
-  if (rodata_blob_buffer == NULL) {
-    RETURN_NULL_ERROR(instructions_blob_buffer);
-  }
-  if (rodata_blob_size == NULL) {
-    RETURN_NULL_ERROR(instructions_blob_size);
+  if (isolate_snapshot_instructions_buffer == NULL) {
+    RETURN_NULL_ERROR(instructions_snapshot_blob_size);
   }
   // Finalize all classes if needed.
   Dart_Handle state = Api::CheckAndFinalizePendingClasses(T);
   if (::Dart_IsError(state)) {
     return state;
   }
   I->StopBackgroundCompiler();
 
   NOT_IN_PRODUCT(TimelineDurationScope tds2(T, Timeline::GetIsolateStream(),
                                             "WriteAppJITSnapshot"));
-  BlobInstructionsWriter instructions_writer(instructions_blob_buffer,
-                                             rodata_blob_buffer, ApiReallocate,
-                                             2 * MB /* initial_size */);
-  FullSnapshotWriter writer(Snapshot::kAppJIT, NULL, isolate_snapshot_buffer,
-                            ApiReallocate, &instructions_writer);
+  BlobInstructionsWriter isolate_instructions_writer(
+      isolate_snapshot_instructions_buffer, ApiReallocate,
+      2 * MB /* initial_size */);
+  FullSnapshotWriter writer(Snapshot::kAppJIT, NULL,
+                            isolate_snapshot_data_buffer, ApiReallocate, NULL,
+                            &isolate_instructions_writer);
   writer.WriteFullSnapshot();
-  *isolate_snapshot_size = writer.IsolateSnapshotSize();
-  *instructions_blob_size = instructions_writer.InstructionsBlobSize();
-  *rodata_blob_size = instructions_writer.RodataBlobSize();
+
+  *isolate_snapshot_data_size = writer.IsolateSnapshotSize();
+  *isolate_snapshot_instructions_size =
+      isolate_instructions_writer.InstructionsBlobSize();
 
   return Api::Success();
 #endif
 }
 
 
 DART_EXPORT bool Dart_IsPrecompiledRuntime() {
 #if defined(DART_PRECOMPILED_RUNTIME)
   return true;
 #else
   return false;
 #endif
 }
 
 
 DART_EXPORT void Dart_DumpNativeStackTrace(void* context) {
 #ifndef PRODUCT
   Profiler::DumpStackTrace(context);
 #endif
 }
 
 }  // namespace dart