Check snapshots for feature compatibility.

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/code_observers.h"
 #include "vm/cpu.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
@@ skipping 97 matching lines @@
   // (compiler) and arm64 (runtime) to agree.
   CHECK_OFFSET(Heap::TopOffset(Heap::kNew), 8);
   CHECK_OFFSET(Isolate::heap_offset(), 16);
   CHECK_OFFSET(Thread::stack_limit_offset(), 8);
   CHECK_OFFSET(Thread::object_null_offset(), 72);
 #endif
 #undef CHECK_OFFSET
 }
 
 
-const char* Dart::InitOnce(const uint8_t* vm_isolate_snapshot,
-                           const uint8_t* instructions_snapshot,
-                           const uint8_t* data_snapshot,
-                           Dart_IsolateCreateCallback create,
-                           Dart_IsolateShutdownCallback shutdown,
-                           Dart_ThreadExitCallback thread_exit,
-                           Dart_FileOpenCallback file_open,
-                           Dart_FileReadCallback file_read,
-                           Dart_FileWriteCallback file_write,
-                           Dart_FileCloseCallback file_close,
-                           Dart_EntropySource entropy_source,
-                           Dart_GetVMServiceAssetsArchive get_service_assets) {
+char* Dart::InitOnce(const uint8_t* vm_isolate_snapshot,
+                     const uint8_t* instructions_snapshot,
+                     const uint8_t* data_snapshot,
+                     Dart_IsolateCreateCallback create,
+                     Dart_IsolateShutdownCallback shutdown,
+                     Dart_ThreadExitCallback thread_exit,
+                     Dart_FileOpenCallback file_open,
+                     Dart_FileReadCallback file_read,
+                     Dart_FileWriteCallback file_write,
+                     Dart_FileCloseCallback file_close,
+                     Dart_EntropySource entropy_source,
+                     Dart_GetVMServiceAssetsArchive get_service_assets) {
   CheckOffsets();
   // TODO(iposva): Fix race condition here.
   if (vm_isolate_ != NULL || !Flags::Initialized()) {
-    return "VM already initialized or flags not initialized.";
+    return strdup("VM already initialized or flags not initialized.");
   }
   set_thread_exit_callback(thread_exit);
   SetFileCallbacks(file_open, file_read, file_write, file_close);
   set_entropy_source_callback(entropy_source);
   OS::InitOnce();
   VirtualMemory::InitOnce();
   OSThread::InitOnce();
   if (FLAG_support_timeline) {
     Timeline::InitOnce();
   }
@@ skipping 44 matching lines @@
     ObjectStore::Init(vm_isolate_);
     TargetCPUFeatures::InitOnce();
     Object::InitOnce(vm_isolate_);
     ArgumentsDescriptor::InitOnce();
     ICData::InitOnce();
     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 "Invalid vm isolate snapshot seen";
+        return strdup("Invalid vm isolate snapshot seen");
       }
       snapshot_kind_ = snapshot->kind();
+
       if (Snapshot::IncludesCode(snapshot_kind_)) {
         if (snapshot_kind_ == Snapshot::kAppNoJIT) {
 #if defined(DART_PRECOMPILED_RUNTIME)
           vm_isolate_->set_compilation_allowed(false);
           if (!FLAG_precompiled_runtime) {
-            return "Flag --precompilation was not specified";
+            return strdup("Flag --precompilation was not specified");
           }
 #else
-          return "JIT runtime cannot run a precompiled snapshot";
+          return strdup("JIT runtime cannot run a precompiled snapshot");
 #endif
         }
         if (instructions_snapshot == NULL) {
-          return "Missing instructions snapshot";
+          return strdup("Missing instructions snapshot");
         }
         if (data_snapshot == NULL) {
-          return "Missing rodata snapshot";
+          return strdup("Missing rodata snapshot");
         }
         vm_isolate_->SetupInstructionsSnapshotPage(instructions_snapshot);
         vm_isolate_->SetupDataSnapshotPage(data_snapshot);
       } else if (Snapshot::IsFull(snapshot_kind_)) {
 #if defined(DART_PRECOMPILED_RUNTIME)
-        return "Precompiled runtime requires a precompiled snapshot";
+        return strdup("Precompiled runtime requires a precompiled snapshot");
 #else
         if (instructions_snapshot != NULL) {
-          return "Unexpected instructions snapshot";
+          return strdup("Unexpected instructions snapshot");
         }
         if (data_snapshot != NULL) {
-          return "Unexpected rodata snapshot";
+          return strdup("Unexpected rodata snapshot");
         }
         StubCode::InitOnce();
 #endif
       } else {
-        return "Invalid vm isolate snapshot seen";
+        return strdup("Invalid vm isolate snapshot seen");
       }
       VmIsolateSnapshotReader reader(snapshot->kind(),
                                      snapshot->content(),
                                      snapshot->length(),
                                      instructions_snapshot,
                                      data_snapshot,
                                      T);
       const Error& error = Error::Handle(reader.ReadVmIsolateSnapshot());
       if (!error.IsNull()) {
-        return error.ToErrorCString();
+        // Must copy before leaving the zone.
+        return strdup(error.ToErrorCString());
       }
       NOT_IN_PRODUCT(if (tds.enabled()) {
         tds.SetNumArguments(2);
         tds.FormatArgument(0, "snapshotSize", "%" Pd, snapshot->length());
         tds.FormatArgument(1, "heapSize", "%" Pd64,
                            vm_isolate_->heap()->UsedInWords(Heap::kOld) *
                            kWordSize);
       });
       if (FLAG_trace_isolates) {
         OS::Print("Size of vm isolate snapshot = %" Pd "\n",
                   snapshot->length());
         vm_isolate_->heap()->PrintSizes();
         MegamorphicCacheTable::PrintSizes(vm_isolate_);
         intptr_t size;
         intptr_t capacity;
         Symbols::GetStats(vm_isolate_, &size, &capacity);
         OS::Print("VM Isolate: Number of symbols : %" Pd "\n", size);
         OS::Print("VM Isolate: Symbol table capacity : %" Pd "\n", capacity);
       }
     } else {
 #if defined(DART_PRECOMPILED_RUNTIME)
-      return "Precompiled runtime requires a precompiled snapshot";
+      return strdup("Precompiled runtime requires a precompiled snapshot");
 #else
       snapshot_kind_ = Snapshot::kNone;
       StubCode::InitOnce();
       Symbols::InitOnce(vm_isolate_);
 #endif
     }
     // We need to initialize the constants here for the vm isolate thread due to
     // bootstrapping issues.
     T->InitVMConstants();
     Scanner::InitOnce();
 #if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64)
     // Dart VM requires at least SSE2.
     if (!TargetCPUFeatures::sse2_supported()) {
-      return "SSE2 is required.";
+      return strdup("SSE2 is required.");
     }
 #endif
     {
       NOT_IN_PRODUCT(TimelineDurationScope tds(Timeline::GetVMStream(),
                                                "FinalizeVMIsolate"));
       Object::FinalizeVMIsolate(vm_isolate_);
     }
 #if defined(DEBUG)
     vm_isolate_->heap()->Verify(kRequireMarked);
 #endif
@@ skipping 298 matching lines @@
   I->set_current_tag(default_tag);
 
   if (FLAG_keep_code) {
     I->set_deoptimized_code_array(
         GrowableObjectArray::Handle(GrowableObjectArray::New()));
   }
   return Error::null();
 }
 
 
+const char* Dart::FeaturesString(Snapshot::Kind kind) {
+  TextBuffer buffer(64);
+
+  // Different fields are included for DEBUG/RELEASE/PRODUCT.
+#if defined(DEBUG)
+  buffer.AddString("debug");
+#elif defined(PRODUCT)
+  buffer.AddString("product");
+#else
+  buffer.AddString("release");
+#endif
+
+  if (Snapshot::IncludesCode(kind)) {
+    // Checked mode affects deopt ids.
+    buffer.AddString(FLAG_enable_asserts ? " asserts" : " no-asserts");
+    buffer.AddString(FLAG_enable_type_checks ? " type-checks"
+                                             : " no-type-checks");
+
+    // Generated code must match the host architecture and ABI.
+#if defined(TARGET_ARCH_ARM)
+#if defined(TARGET_OS_MACOS)
+    buffer.AddString(" arm-ios");
+#else
+    buffer.AddString(" arm-eabi");
+#endif
+    buffer.AddString(TargetCPUFeatures::hardfp_supported() ? " hardfp"
+                                                           : " softfp");
+#elif defined(TARGET_ARCH_ARM64)
+    buffer.AddString(" arm64");
+#elif defined(TARGET_ARCH_MIPS)
+    buffer.AddString(" mips");
+#elif defined(TARGET_ARCH_IA32)
+    buffer.AddString(" ia32");
+#elif defined(TARGET_ARCH_X64)
+#if defined(_WIN64)
+    buffer.AddString(" x64-win");
+#else
+    buffer.AddString(" x64-sysv");
+#endif
+#elif defined(TARGET_ARCH_DBC)
+    buffer.AddString(" dbc");
+#elif defined(TARGET_ARCH_DBC64)
+    buffer.AddString(" dbc64");
+#endif
+  }
+
+  return buffer.Steal();
+}
+
+
 void Dart::RunShutdownCallback() {
   Isolate* isolate = Isolate::Current();
   void* callback_data = isolate->init_callback_data();
   Dart_IsolateShutdownCallback callback = Isolate::ShutdownCallback();
   ServiceIsolate::SendIsolateShutdownMessage();
   if (callback != NULL) {
     (callback)(callback_data);
   }
 }
 
@@ skipping 42 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