CoreJIT snapshots without training.

runtime/vm/dart.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 "vm/dart.h"
 
 #include "vm/become.h"
 #include "vm/clustered_snapshot.h"
 #include "vm/code_observers.h"
 #include "vm/cpu.h"
@@ skipping 197 matching lines @@
     if (vm_isolate_snapshot != NULL) {
       NOT_IN_PRODUCT(TimelineDurationScope tds(Timeline::GetVMStream(),
                                                "VMIsolateSnapshot"));
       const Snapshot* snapshot = Snapshot::SetupFromBuffer(vm_isolate_snapshot);
       if (snapshot == NULL) {
         return strdup("Invalid vm isolate snapshot seen");
       }
       vm_snapshot_kind_ = snapshot->kind();
 
       if (Snapshot::IncludesCode(vm_snapshot_kind_)) {
-        if (vm_snapshot_kind_ == Snapshot::kAppAOT) {
+        if (vm_snapshot_kind_ == Snapshot::kFullAOT) {
 #if defined(DART_PRECOMPILED_RUNTIME)
           vm_isolate_->set_compilation_allowed(false);
           if (!FLAG_precompiled_runtime) {
             return strdup("Flag --precompilation was not specified");
           }
 #else
           return strdup("JIT runtime cannot run a precompiled snapshot");
 #endif
         }
         if (instructions_snapshot == NULL) {
@@ skipping 274 matching lines @@
                              const Dart_IsolateFlags& api_flags) {
   // Create a new isolate.
   Isolate* isolate = Isolate::Init(name_prefix, api_flags);
   return isolate;
 }
 
 
 static bool IsSnapshotCompatible(Snapshot::Kind vm_kind,
                                  Snapshot::Kind isolate_kind) {
   if (vm_kind == isolate_kind) return true;
-  if (vm_kind == Snapshot::kCore && isolate_kind == Snapshot::kAppJIT)
+  if (vm_kind == Snapshot::kFull && isolate_kind == Snapshot::kFullJIT)
     return true;
   return Snapshot::IsFull(isolate_kind);
 }
 
 
 RawError* Dart::InitializeIsolate(const uint8_t* snapshot_data,
                                   const uint8_t* snapshot_instructions,
                                   intptr_t snapshot_length,
                                   kernel::Program* kernel_program,
                                   void* data) {
@@ skipping 143 matching lines @@
   buffer.AddString("release");
 #endif
 
   if (Snapshot::IncludesCode(kind)) {
     // Checked mode affects deopt ids.
 #define ADD_FLAG(name, isolate_flag, flag)                                     \
   do {                                                                         \
     const bool name = (isolate != NULL) ? isolate->name() : flag;              \
     buffer.AddString(name ? (" " #name) : (" no-" #name));                     \
   } while (0);
-    ISOLATE_FLAG_LIST(ADD_FLAG);
+    ADD_FLAG(type_checks, enable_type_checks, FLAG_enable_type_checks);
+    ADD_FLAG(asserts, enable_asserts, FLAG_enable_asserts);
+    ADD_FLAG(error_on_bad_type, enable_error_on_bad_type,
+             FLAG_error_on_bad_type);
+    ADD_FLAG(error_on_bad_override, enable_error_on_bad_override,
+             FLAG_error_on_bad_override);
+    if (kind == Snapshot::kFullJIT) {
+      ADD_FLAG(use_field_guards, use_field_guards, FLAG_use_field_guards);
+      ADD_FLAG(use_osr, use_osr, FLAG_use_osr);
+    }
 #undef ADD_FLAG
 
 // Generated code must match the host architecture and ABI.
 #if defined(TARGET_ARCH_ARM)
 #if defined(TARGET_OS_MACOS) || defined(TARGET_OS_MACOS_IOS)
     buffer.AddString(" arm-ios");
 #else
     buffer.AddString(" arm-eabi");
 #endif
     buffer.AddString(TargetCPUFeatures::hardfp_supported() ? " hardfp"
@@ skipping 78 matching lines @@
   return predefined_handles_->handles_.IsValidScopedHandle(address);
 }
 
 
 bool Dart::IsReadOnlyApiHandle(Dart_Handle handle) {
   ASSERT(predefined_handles_ != NULL);
   return predefined_handles_->api_handles_.IsValidHandle(handle);
 }
 
 }  // namespace dart