Reintroduce binary to load and save dill file.

runtime/vm/kernel_main.cc

+// Copyright (c) 2017, 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 "bin/dartutils.h"
+#include "vm/kernel.h"
+#include "vm/timer.h"
+
+namespace dart {
+namespace bin {
+
+class BufferedFileWriter : public dart::ByteWriter {
+ public:
+  explicit BufferedFileWriter(char* filename) {
+    this->filename_ = filename;
+    buffer_size_ = 1048576;
+    buffer_ = new uint8_t[buffer_size_];
+    used_ = 0;
+  }
+
+  ~BufferedFileWriter() {
+    void* out_file = DartUtils::OpenFile(filename_, true);
+    if (out_file != NULL) {
+      DartUtils::WriteFile(buffer_, used_, out_file);
+    }
+    delete buffer_;
+  }
+
+  void WriteByte(uint8_t byte) {
+    EnsureSpaceFor(1);
+    buffer_[used_++] = byte;
+  }
+
+  void WriteBytes(uint8_t* buffer, int count) {
+    EnsureSpaceFor(count);
+    for (int i = 0; i < count; ++i) {
+      this->buffer_[used_++] = buffer[i];
+    }
+  }
+
+ private:
+  void EnsureSpaceFor(int bytes) {
+    int needed = used_ + bytes;
+    if (needed < buffer_size_) return;
+    while (buffer_size_ < needed) {
+      buffer_size_ *= 2;
+    }
+    uint8_t* tmp = new uint8_t[buffer_size_];
+    for (int i = 0; i < used_; ++i) {
+      tmp[i] = buffer_[i];
+    }
+    delete buffer_;
+    buffer_ = tmp;
+  }
+
+  char* filename_;
+  uint8_t* buffer_;
+  int buffer_size_;
+  int used_;
+};
+
+extern const uint8_t* vm_isolate_snapshot_buffer;
+
+static Dart_Isolate CreateIsolateAndSetup(const char* script_uri,
+                                          const char* main,
+                                          const char* package_root,
+                                          const char* package_config,
+                                          Dart_IsolateFlags* flags,
+                                          void* data,
+                                          char** error) {
+  return NULL;
+}
+
+int main(int argc, char** argv) {
+  Dart_SetVMFlags(0, NULL);
+  Dart_InitializeParams init_params;
+  memset(&init_params, 0, sizeof(init_params));
+  init_params.version = DART_INITIALIZE_PARAMS_CURRENT_VERSION;
+  init_params.vm_isolate_snapshot = vm_isolate_snapshot_buffer;
+  init_params.create = CreateIsolateAndSetup;
+  char* error = Dart_Initialize(&init_params);
+  if (error != NULL) {
+    printf("VM initialization failed: %s\n", error);
+    return 2;
+  }
+
+  if (argc != 3) {
+    printf("Usage: %s <input.dill> <output.dill>\n", argv[0]);
+    return 1;
+  }
+
+  char* filename = argv[1];
+  char* out_filename = argv[2];
+
+  dart::kernel::Program* kernel = NULL;
+  dart::Timer reader_timer(true, "");
+  {
+    dart::TimerScope ts(true, &reader_timer);
+    const uint8_t* kernel_file = NULL;
+    intptr_t kernel_length = -1;
+    const bool is_kernel =
+        TryReadKernel(filename, &kernel_file, &kernel_length);
+
+    if (is_kernel) {
+      kernel = reinterpret_cast<dart::kernel::Program*>(
+          Dart_ReadKernelBinary(kernel_file, kernel_length));
+      free(const_cast<uint8_t*>(kernel_file));
+    }
+    if (kernel == NULL) {
+      FATAL("Failed to read input file.");
+    }
+  }
+
+  dart::Timer writer_time(true, "");
+  {
+    dart::TimerScope ts(true, &writer_time);
+    {
+      BufferedFileWriter writer(out_filename);
+      dart::WritePrecompiledKernel(&writer, kernel);
+    }
+  }
+
+  dart::Timer delete_timer(true, "");
+  {
+    dart::TimerScope ts(true, &delete_timer);
+    delete kernel;
+  }
+
+  printf("Took %4.2lf ms to read\n", reader_timer.TotalElapsedTime() / 1000.0);
+  printf("Took %4.2lf ms to write\n", writer_time.TotalElapsedTime() / 1000.0);
+  printf("Took %4.2lf ms to delete\n",
+         delete_timer.TotalElapsedTime() / 1000.0);
+
+  return 0;
+}
+}  // namespace bin
+}  // namespace dart
+
+int main(int argc, char** argv) {
+  return dart::bin::main(argc, argv);
+}