Pass path to platform kernel binary to kernel-service.

utils/kernel-service/kernel-service.dart

 // Copyright (c) 2016, 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.
 
 /// This is an interface to the Dart Kernel parser and Kernel binary generator.
 ///
 /// It is used by the kernel-isolate to load Dart source code and generate
 /// Kernel binary format.
 ///
 /// This is either invoked as the root script of the Kernel isolate when used
@@ skipping 27 matching lines @@
 
 const bool verbose = const bool.fromEnvironment('DFE_VERBOSE');
 const bool strongMode = const bool.fromEnvironment('DFE_STRONG_MODE');
 
 abstract class Compiler {
   final FileSystem fileSystem;
   final List<String> errors = new List<String>();
 
   CompilerOptions options;
 
-  Compiler(this.fileSystem) {
+  Compiler(this.fileSystem, Uri platformKernel) {
     Uri packagesUri = (Platform.packageConfig != null)
         ? Uri.parse(Platform.packageConfig)
         : null;
 
-    Uri sdkSummary = Uri.base
-        .resolveUri(new Uri.file(Platform.resolvedExecutable))
-        .resolveUri(new Uri.directory("patched_sdk"))
-        // TODO(sigmund): use outline.dill when the mixin transformer is
-        // modular.
-        .resolve('platform.dill');
-
     if (verbose) {
       print("DFE: Platform.packageConfig: ${Platform.packageConfig}");
       print("DFE: packagesUri: ${packagesUri}");
       print("DFE: Platform.resolvedExecutable: ${Platform.resolvedExecutable}");
-      print("DFE: sdkSummary: ${sdkSummary}");
+      print("DFE: platformKernel: ${platformKernel}");
     }
 
     options = new CompilerOptions()
       ..strongMode = strongMode
       ..fileSystem = fileSystem
       ..target = new VmFastaTarget(new TargetFlags(strongMode: strongMode))
       ..packagesFileUri = packagesUri
-      ..sdkSummary = sdkSummary
+      ..sdkSummary = platformKernel
       ..verbose = verbose
       ..throwOnErrors = false
       ..reportMessages = true
       ..onError = (CompilationMessage e) {
         if (e.severity == Severity.error) {
           // TODO(sigmund): support emitting code with errors as long as they
           // are handled in the generated code (issue #30194).
           errors.add(e.message);
         }
       };
   }
 
   Future<Program> compile(Uri script);
 }
 
 class IncrementalCompiler extends Compiler {
   IncrementalKernelGenerator generator;
 
-  IncrementalCompiler(FileSystem fileSystem) : super(fileSystem);
+  IncrementalCompiler(FileSystem fileSystem, Uri platformKernel)
+      : super(fileSystem, platformKernel);
 
   @override
   Future<Program> compile(Uri script) async {
     if (generator == null) {
       generator = await IncrementalKernelGenerator.newInstance(options, script);
     }
     DeltaProgram deltaProgram = await generator.computeDelta();
     // TODO(aam): Accepting/rejecting should be done based on VM response.
     generator.acceptLastDelta();
     return deltaProgram.newProgram;
   }
 
   void invalidate(Uri uri) {
     generator.invalidate(uri);
   }
 }
 
 class SingleShotCompiler extends Compiler {
   final bool requireMain;
 
-  SingleShotCompiler(FileSystem fileSystem, this.requireMain)
-      : super(fileSystem);
+  SingleShotCompiler(
+      FileSystem fileSystem, Uri platformKernel, this.requireMain)
+      : super(fileSystem, platformKernel);
 
   @override
   Future<Program> compile(Uri script) async {
     return requireMain
         ? kernelForProgram(script, options)
         : kernelForBuildUnit([script], options..chaseDependencies = true);
   }
 }
 
 final Map<int, Compiler> isolateCompilers = new Map<int, Compiler>();
 
 Future<Compiler> lookupOrBuildNewIncrementalCompiler(
-    int isolateId, List sourceFiles) async {
+    int isolateId, List sourceFiles, Uri platformKernel) async {
   IncrementalCompiler compiler;
   if (isolateCompilers.containsKey(isolateId)) {
     compiler = isolateCompilers[isolateId];
     final HybridFileSystem fileSystem = compiler.fileSystem;
     if (sourceFiles != null) {
       for (int i = 0; i < sourceFiles.length ~/ 2; i++) {
         Uri uri = Uri.parse(sourceFiles[i * 2]);
         fileSystem.memory
             .entityForUri(uri)
             .writeAsBytesSync(sourceFiles[i * 2 + 1]);
         compiler.invalidate(uri);
       }
     }
   } else {
     final FileSystem fileSystem = sourceFiles == null
         ? PhysicalFileSystem.instance
         : _buildFileSystem(sourceFiles);
 
     // TODO(aam): IncrementalCompiler instance created below have to be
     // destroyed when corresponding isolate is shut down. To achieve that kernel
     // isolate needs to receive a message indicating that particular
     // isolate was shut down. Message should be handled here in this script.
-    compiler = new IncrementalCompiler(fileSystem);
+    compiler = new IncrementalCompiler(fileSystem, platformKernel);
     isolateCompilers[isolateId] = compiler;
   }
   return compiler;
 }
 
 // Process a request from the runtime. See KernelIsolate::CompileToKernel in
 // kernel_isolate.cc and Loader::SendKernelRequest in loader.cc.
 Future _processLoadRequest(request) async {
   if (verbose) print("DFE: request: $request");
 
   int tag = request[0];
   final SendPort port = request[1];
   final String inputFileUri = request[2];
   final Uri script = Uri.base.resolve(inputFileUri);
-  final bool incremental = request[3];
+  final Uri platformKernel = request[3] != null
+      ? Uri.base.resolveUri(new Uri.file(request[3]))
+      : Uri.base
+          .resolveUri(new Uri.file(Platform.resolvedExecutable))
+          .resolveUri(new Uri.directory("patched_sdk"))
+          // TODO(sigmund): use outline.dill when the mixin transformer is
+          // modular.
+          .resolve('platform.dill');
 
-  final List sourceFiles = request.length > 5 ? request[5] : null;
+  final bool incremental = request[4];
+
+  final List sourceFiles = request.length > 6 ? request[6] : null;
 
   Compiler compiler;
   // TODO(aam): There should be no need to have an option to choose
   // one compiler or another. We should always use an incremental
   // compiler as its functionality is a super set of the other one. We need to
   // watch the performance though.
   if (incremental) {
-    final int isolateId = request[4];
-    compiler =
-        await lookupOrBuildNewIncrementalCompiler(isolateId, sourceFiles);
+    final int isolateId = request[5];
+    compiler = await lookupOrBuildNewIncrementalCompiler(
+        isolateId, sourceFiles, platformKernel);
   } else {
     final FileSystem fileSystem = sourceFiles == null
         ? PhysicalFileSystem.instance
         : _buildFileSystem(sourceFiles);
     compiler = new SingleShotCompiler(
-        fileSystem, sourceFiles == null /* requireMain */);
+        fileSystem, platformKernel, sourceFiles == null /* requireMain */);
   }
 
   CompilationResult result;
   try {
     if (verbose) {
       print("DFE: scriptUri: ${script}");
     }
 
     Program program = await compiler.compile(script);
 
@@ skipping 62 matching lines @@
       // Compilation error.
       throw response[4];
     } else {
       throw "Unexpected response: $response";
     }
   };
   var request = [
     tag,
     responsePort.sendPort,
     scriptUri,
-    1 /* isolateId chosen randomly */,
-    false /* incremental */
+    null /* platformKernel */,
+    false /* incremental */,
+    1 /* isolateId chosen randomly */
   ];
   _processLoadRequest(request);
 }
 
 main([args]) {
   if (args?.length == 2 && args[0] == '--train') {
     // This entry point is used when creating an app snapshot. The argument
     // provides a script to compile to warm-up generated code.
     train(args[1]);
   } else {
@@ skipping 79 matching lines @@
   _CompilationCrash(this.exception, this.stack);
 
   @override
   Status get status => Status.crash;
 
   @override
   String get errorString => "${exception}\n${stack}";
 
   String toString() => "_CompilationCrash(${errorString})";
 }