CoreJIT snapshots without training.

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 1561 matching lines @@
   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_snapshot_data_buffer != NULL && vm_snapshot_data_size == NULL) {
     RETURN_NULL_ERROR(vm_snapshot_data_size);
   }
-  if (isolate_snapshot_data_buffer == NULL) {
-    RETURN_NULL_ERROR(isolate_snapshot_data_buffer);
-  }
-  if (isolate_snapshot_data_size == NULL) {
-    RETURN_NULL_ERROR(isolate_snapshot_data_size);
-  }
+  CHECK_NULL(isolate_snapshot_data_buffer);
+  CHECK_NULL(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)
 
   Symbols::Compact(I);
 
-  FullSnapshotWriter writer(Snapshot::kCore, vm_snapshot_data_buffer,
+  FullSnapshotWriter writer(Snapshot::kFull, vm_snapshot_data_buffer,
                             isolate_snapshot_data_buffer, ApiReallocate,
                             NULL /* vm_image_writer */,
                             NULL /* isolate_image_writer */);
   writer.WriteFullSnapshot();
   if (vm_snapshot_data_buffer != NULL) {
     *vm_snapshot_data_size = writer.VmIsolateSnapshotSize();
   }
   *isolate_snapshot_data_size = writer.IsolateSnapshotSize();
   return Api::Success();
 }
 
 
 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 (script_snapshot_buffer == NULL) {
-    RETURN_NULL_ERROR(script_snapshot_buffer);
-  }
-  if (script_snapshot_size == NULL) {
-    RETURN_NULL_ERROR(script_snapshot_size);
-  }
+  CHECK_NULL(script_snapshot_buffer);
+  CHECK_NULL(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);
@@ skipping 2257 matching lines @@
     }
 
     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::vm_snapshot_kind() == Snapshot::kAppAOT)) {
+        (Dart::vm_snapshot_kind() == Snapshot::kFullAOT)) {
       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::vm_snapshot_kind() == Snapshot::kAppAOT)) {
+  if (!cls.is_allocated() && (Dart::vm_snapshot_kind() == Snapshot::kFullAOT)) {
     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::vm_snapshot_kind() == Snapshot::kAppAOT)) {
+  if (!cls.is_allocated() && (Dart::vm_snapshot_kind() == Snapshot::kFullAOT)) {
     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 2604 matching lines @@
       JITFeedbackFunctionVisitor visitor(&js_functions, zone);
       ProgramVisitor::VisitFunctions(&visitor);
     }
   }
 
   js_stream.Steal(reinterpret_cast<char**>(buffer), buffer_length);
   return Api::Success();
 #endif
 }
 
-DART_EXPORT void Dart_SortClasses() {
+DART_EXPORT Dart_Handle Dart_SortClasses() {
   DARTSCOPE(Thread::Current());
   // We don't have mechanisms to change class-ids that are embedded in code and
   // ICData.
   ClassFinalizer::ClearAllCode();
   // Make sure that ICData etc. that have been cleared are also removed from
   // the heap so that they are not found by the heap verifier.
   Isolate::Current()->heap()->CollectAllGarbage();
   ClassFinalizer::SortClasses();
+  return Api::Success();
 }
 
 DART_EXPORT Dart_Handle
 Dart_Precompile(Dart_QualifiedFunctionName entry_points[],
                 uint8_t* jit_feedback,
                 intptr_t jit_feedback_length) {
 #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.");
@@ skipping 34 matching lines @@
 #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 (assembly_buffer == NULL) {
-    RETURN_NULL_ERROR(assembly_buffer);
-  }
-  if (assembly_size == NULL) {
-    RETURN_NULL_ERROR(assembly_size);
-  }
+  CHECK_NULL(assembly_buffer);
+  CHECK_NULL(assembly_size);
 
   NOT_IN_PRODUCT(TimelineDurationScope tds2(T, Timeline::GetIsolateStream(),
                                             "WriteAppAOTSnapshot"));
   AssemblyImageWriter image_writer(assembly_buffer, ApiReallocate,
                                    2 * MB /* initial_size */);
   uint8_t* vm_snapshot_data_buffer = NULL;
   uint8_t* isolate_snapshot_data_buffer = NULL;
-  FullSnapshotWriter writer(Snapshot::kAppAOT, &vm_snapshot_data_buffer,
+  FullSnapshotWriter writer(Snapshot::kFullAOT, &vm_snapshot_data_buffer,
                             &isolate_snapshot_data_buffer, ApiReallocate,
                             &image_writer, &image_writer);
 
   writer.WriteFullSnapshot();
   image_writer.Finalize();
   *assembly_size = image_writer.AssemblySize();
 
   return Api::Success();
 #endif
 }
@@ skipping 21 matching lines @@
 #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_snapshot_data_buffer == NULL) {
-    RETURN_NULL_ERROR(vm_snapshot_data_buffer);
-  }
-  if (vm_snapshot_data_size == NULL) {
-    RETURN_NULL_ERROR(vm_snapshot_data_size);
-  }
-  if (vm_snapshot_instructions_buffer == NULL) {
-    RETURN_NULL_ERROR(vm_snapshot_instructions_buffer);
-  }
-  if (vm_snapshot_instructions_size == NULL) {
-    RETURN_NULL_ERROR(vm_snapshot_instructions_size);
-  }
-  if (isolate_snapshot_data_buffer == NULL) {
-    RETURN_NULL_ERROR(isolate_snapshot_data_buffer);
-  }
-  if (isolate_snapshot_data_size == NULL) {
-    RETURN_NULL_ERROR(isolate_snapshot_data_size);
-  }
-  if (isolate_snapshot_instructions_buffer == NULL) {
-    RETURN_NULL_ERROR(instructions_snapshot_blob_buffer);
-  }
-  if (isolate_snapshot_instructions_buffer == NULL) {
-    RETURN_NULL_ERROR(instructions_snapshot_blob_size);
-  }
+  CHECK_NULL(vm_snapshot_data_buffer);
+  CHECK_NULL(vm_snapshot_data_size);
+  CHECK_NULL(vm_snapshot_instructions_buffer);
+  CHECK_NULL(vm_snapshot_instructions_size);
+  CHECK_NULL(isolate_snapshot_data_buffer);
+  CHECK_NULL(isolate_snapshot_data_size);
+  CHECK_NULL(isolate_snapshot_instructions_buffer);
+  CHECK_NULL(isolate_snapshot_instructions_size);
 
   NOT_IN_PRODUCT(TimelineDurationScope tds2(T, Timeline::GetIsolateStream(),
                                             "WriteAppAOTSnapshot"));
   BlobImageWriter vm_image_writer(vm_snapshot_instructions_buffer,
                                   ApiReallocate, 2 * MB /* initial_size */);
   BlobImageWriter isolate_image_writer(isolate_snapshot_instructions_buffer,
                                        ApiReallocate,
                                        2 * MB /* initial_size */);
-  FullSnapshotWriter writer(Snapshot::kAppAOT, vm_snapshot_data_buffer,
+  FullSnapshotWriter writer(Snapshot::kFullAOT, vm_snapshot_data_buffer,
                             isolate_snapshot_data_buffer, ApiReallocate,
                             &vm_image_writer, &isolate_image_writer);
 
   writer.WriteFullSnapshot();
   *vm_snapshot_data_size = writer.VmIsolateSnapshotSize();
   *vm_snapshot_instructions_size = vm_image_writer.InstructionsBlobSize();
   *isolate_snapshot_data_size = writer.IsolateSnapshotSize();
   *isolate_snapshot_instructions_size =
       isolate_image_writer.InstructionsBlobSize();
 
   return Api::Success();
 #endif
 }
 
 
+DART_EXPORT Dart_Handle Dart_CreateCoreJITSnapshotAsBlobs(
+    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("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");
+  }
+  CHECK_NULL(vm_snapshot_data_buffer);
+  CHECK_NULL(vm_snapshot_data_size);
+  CHECK_NULL(vm_snapshot_instructions_buffer);
+  CHECK_NULL(vm_snapshot_instructions_size);
+  CHECK_NULL(isolate_snapshot_data_buffer);
+  CHECK_NULL(isolate_snapshot_data_size);
+  CHECK_NULL(isolate_snapshot_instructions_buffer);
+  CHECK_NULL(isolate_snapshot_instructions_size);
+  // Finalize all classes if needed.
+  Dart_Handle state = Api::CheckAndFinalizePendingClasses(T);
+  if (::Dart_IsError(state)) {
+    return state;
+  }
+  I->StopBackgroundCompiler();
+
+  ProgramVisitor::Dedup();
+  Symbols::Compact(I);
+
+  NOT_IN_PRODUCT(TimelineDurationScope tds2(T, Timeline::GetIsolateStream(),
+                                            "WriteCoreJITSnapshot"));
+  BlobImageWriter vm_image_writer(vm_snapshot_instructions_buffer,
+                                  ApiReallocate, 2 * MB /* initial_size */);
+  BlobImageWriter isolate_image_writer(isolate_snapshot_instructions_buffer,
+                                       ApiReallocate,
+                                       2 * MB /* initial_size */);
+  FullSnapshotWriter writer(Snapshot::kFullJIT, vm_snapshot_data_buffer,
+                            isolate_snapshot_data_buffer, ApiReallocate,
+                            &vm_image_writer, &isolate_image_writer);
+  writer.WriteFullSnapshot();
+
+  *vm_snapshot_data_size = writer.VmIsolateSnapshotSize();
+  *vm_snapshot_instructions_size = vm_image_writer.InstructionsBlobSize();
+  *isolate_snapshot_data_size = writer.IsolateSnapshotSize();
+  *isolate_snapshot_instructions_size =
+      isolate_image_writer.InstructionsBlobSize();
+
+  return Api::Success();
+#endif
+}
+
+
 DART_EXPORT Dart_Handle
 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_data_buffer == NULL) {
-    RETURN_NULL_ERROR(isolate_snapshot_data_buffer);
-  }
-  if (isolate_snapshot_data_size == NULL) {
-    RETURN_NULL_ERROR(isolate_snapshot_data_size);
-  }
-  if (isolate_snapshot_instructions_buffer == NULL) {
-    RETURN_NULL_ERROR(instructions_snapshot_blob_buffer);
-  }
-  if (isolate_snapshot_instructions_buffer == NULL) {
-    RETURN_NULL_ERROR(instructions_snapshot_blob_size);
-  }
+  CHECK_NULL(isolate_snapshot_data_buffer);
+  CHECK_NULL(isolate_snapshot_data_size);
+  CHECK_NULL(isolate_snapshot_instructions_buffer);
+  CHECK_NULL(isolate_snapshot_instructions_size);
   // Finalize all classes if needed.
   Dart_Handle state = Api::CheckAndFinalizePendingClasses(T);
   if (::Dart_IsError(state)) {
     return state;
   }
   I->StopBackgroundCompiler();
 
   ProgramVisitor::Dedup();
   Symbols::Compact(I);
 
   NOT_IN_PRODUCT(TimelineDurationScope tds2(T, Timeline::GetIsolateStream(),
                                             "WriteAppJITSnapshot"));
   BlobImageWriter isolate_image_writer(isolate_snapshot_instructions_buffer,
                                        ApiReallocate,
                                        2 * MB /* initial_size */);
-  FullSnapshotWriter writer(Snapshot::kAppJIT, NULL,
+  FullSnapshotWriter writer(Snapshot::kFullJIT, NULL,
                             isolate_snapshot_data_buffer, ApiReallocate, NULL,
                             &isolate_image_writer);
   writer.WriteFullSnapshot();
 
   *isolate_snapshot_data_size = writer.IsolateSnapshotSize();
   *isolate_snapshot_instructions_size =
       isolate_image_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