[vm,aot,kernel] Fix AOT snapshot creation with kernel front-end

runtime/bin/dfe.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/dfe.h"
 #include "bin/dartutils.h"
 #include "bin/error_exit.h"
 #include "bin/file.h"
 
 #include "vm/kernel.h"
 
 namespace dart {
 namespace bin {
 
 const char kPlatformBinaryName[] = "platform.dill";
 const char kVMServiceIOBinaryName[] = "vmservice_io.dill";
 
 DFE::DFE()
     : frontend_filename_(NULL),
       platform_binary_filename_(NULL),
       vmservice_io_binary_filename_(NULL),
       kernel_platform_(NULL),
-      kernel_vmservice_io_(NULL),
       kernel_file_specified_(false) {}
 
 DFE::~DFE() {
   frontend_filename_ = NULL;
 
   if (platform_binary_filename_ != NULL) {
     delete platform_binary_filename_;
     platform_binary_filename_ = NULL;
   }
 
   if (kernel_platform_ != NULL) {
     delete reinterpret_cast<kernel::Program*>(kernel_platform_);
     kernel_platform_ = NULL;
   }
-
-  if (kernel_vmservice_io_ != NULL) {
-    delete reinterpret_cast<kernel::Program*>(kernel_vmservice_io_);
-    kernel_vmservice_io_ = NULL;
-  }
-}
-
-void DFE::clear_kernel_vmservice_io() {
-  kernel_vmservice_io_ = NULL;
 }
 
 void DFE::SetKernelBinaries(const char* name) {
   intptr_t len = snprintf(NULL, 0, "%s%s%s", name, File::PathSeparator(),
                           kPlatformBinaryName) +
                  1;
   platform_binary_filename_ = new char[len];
   snprintf(platform_binary_filename_, len, "%s%s%s", name,
            File::PathSeparator(), kPlatformBinaryName);
 
@@ skipping 54 matching lines @@
       *exit_code = kDartFrontendErrorExitCode;
       break;
     case Dart_KernelCompilationStatus_Unknown:
       *error = result.error;  // Copy error message.
       *exit_code = kErrorExitCode;
       break;
   }
   return NULL;
 }
 
-void* DFE::ReadPlatform() {
-  return kernel_platform_ = ReadScript(platform_binary_filename_);
+void* DFE::ReadPlatform() const {
+  return ReadScript(platform_binary_filename_);
 }
 
-void* DFE::ReadVMServiceIO() {
-  return kernel_vmservice_io_ = ReadScript(vmservice_io_binary_filename_);
+void* DFE::ReadVMServiceIO() const {
+  return ReadScript(vmservice_io_binary_filename_);
 }
 
-void* DFE::ReadScript(const char* script_uri) {
+void* DFE::ReadScript(const char* script_uri) const {
   const uint8_t* buffer = NULL;
   intptr_t buffer_length = -1;
   bool result = TryReadKernelFile(script_uri, &buffer, &buffer_length);
   if (result) {
     return Dart_ReadKernelBinary(buffer, buffer_length);
   }
   return NULL;
 }
 
 bool DFE::TryReadKernelFile(const char* script_uri,
                             const uint8_t** kernel_ir,
-                            intptr_t* kernel_ir_size) {
+                            intptr_t* kernel_ir_size) const {
   *kernel_ir = NULL;
   *kernel_ir_size = -1;
   void* script_file = DartUtils::OpenFile(script_uri, false);
   if (script_file != NULL) {
     const uint8_t* buffer = NULL;
     DartUtils::ReadFile(&buffer, kernel_ir_size, script_file);
     DartUtils::CloseFile(script_file);
     if (*kernel_ir_size > 0 && buffer != NULL) {
       if (DartUtils::SniffForMagicNumber(buffer, *kernel_ir_size) !=
           DartUtils::kKernelMagicNumber) {
         free(const_cast<uint8_t*>(buffer));
         *kernel_ir = NULL;
         *kernel_ir_size = -1;
         return false;
       } else {
         // Do not free buffer if this is a kernel file - kernel_file will be
         // backed by the same memory as the buffer and caller will own it.
         // Caller is responsible for freeing the buffer when this function
         // returns true.
         *kernel_ir = buffer;
         return true;
       }
     }
   }
   return false;
 }
 
 }  // namespace bin
 }  // namespace dart