Initial support to test.dart for running precompiler tests on android devices

tools/testing/dart/compiler_configuration.dart

 // Copyright (c) 2014, 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.
 
 library compiler_configuration;
 
 import 'dart:io' show Platform;
 
 import 'runtime_configuration.dart' show RuntimeConfiguration;
 
@@ skipping 61 matching lines @@
             extraDart2jsOptions:
                 TestUtils.getExtraOptions(configuration, 'dart2js_options'));
       case 'dart2app':
         return new Dart2AppSnapshotCompilerConfiguration(
             isDebug: isDebug, isChecked: isChecked);
       case 'precompiler':
         return new PrecompilerCompilerConfiguration(
             isDebug: isDebug,
             isChecked: isChecked,
             arch: configuration['arch'],
-            useBlobs: useBlobs);
+            useBlobs: useBlobs,
+            isAndroid: configuration['system'] == 'android');
       case 'none':
         return new NoneCompilerConfiguration(
             isDebug: isDebug,
             isChecked: isChecked,
             isHostChecked: isHostChecked,
             useSdk: useSdk);
       default:
         throw "Unknown compiler '$compiler'";
     }
   }
@@ skipping 202 matching lines @@
             .resolve('sdk/');
     Uri preambleDir = sdk.resolve('lib/_internal/js_runtime/lib/preambles/');
     return runtimeConfiguration.dart2jsPreambles(preambleDir)
       ..add(artifact.filename);
   }
 }
 
 class PrecompilerCompilerConfiguration extends CompilerConfiguration {
   final String arch;
   final bool useBlobs;
+  final bool isAndroid;
 
-  PrecompilerCompilerConfiguration({bool isDebug, bool isChecked, String arch, bool useBlobs})
-      : super._subclass(isDebug: isDebug, isChecked: isChecked),
-        arch = arch,
-        useBlobs = useBlobs;
+  PrecompilerCompilerConfiguration({bool isDebug, bool isChecked,
+    this.arch, this.useBlobs, this.isAndroid})
+      : super._subclass(isDebug: isDebug, isChecked: isChecked);
 
   int computeTimeoutMultiplier() {
     int multiplier = 2;
     if (isDebug) multiplier *= 4;
     if (isChecked) multiplier *= 2;
     return multiplier;
   }
 
   CommandArtifact computeCompilationArtifact(
       String buildDir,
@@ skipping 18 matching lines @@
       String buildDir,
       CommandBuilder commandBuilder,
       List arguments,
       Map<String, String> environmentOverrides) {
     var exec = "$buildDir/dart_bootstrap";
     var args = new List();
     args.add("--gen-precompiled-snapshot=$tempDir");
     if (useBlobs) {
       args.add("--use_blobs");
     }
+    if (isAndroid && arch == 'arm') {
+      args.add('--no-sim-use-hardfp');
+    }
     args.addAll(arguments);
 
     return commandBuilder.getCompilationCommand('precompiler', tempDir, !useSdk,
         bootstrapDependencies(buildDir), exec, args, environmentOverrides);
   }
 
   CompilationCommand computeAssembleCommand(
       String tempDir,
       String buildDir,
       CommandBuilder commandBuilder,
       List arguments,
       Map<String, String> environmentOverrides) {
-    var cc, cc_flags, shared, libname;
+
+    var cc, shared, libname;
     if (Platform.isLinux) {
       cc = 'gcc';
       shared = '-shared';
       libname = 'libprecompiled.so';
     } else if (Platform.isMacOS) {
       cc = 'clang';
       shared = '-dynamiclib';
       libname = 'libprecompiled.dylib';
     } else {
       throw "Platform not supported: ${Platform.operatingSystem}";
     }
+    if (isAndroid) {
+      // TODO: If we're not using "--use_blobs" we need to use the arm cross
+      // compiler instead of just 'gcc' for .
+    }
 
+    var cc_flags;
     if (arch == 'x64') {
       cc_flags = "-m64";
     } else if (arch == 'simarm64') {
       cc_flags = "-m64";
+    } else if (arch == 'ia32') {
+      cc_flags = "-m32";
     } else if (arch == 'simarm') {
       cc_flags = "-m32";
     } else if (arch == 'simmips') {
       cc_flags = "-m32";
     } else if (arch == 'arm') {
-      cc_flags = "";
+      cc_flags = null;
     } else if (arch == 'mips') {
       cc_flags = "-EL";
     } else {
       throw "Architecture not supported: $arch";
     }
 
     var exec = cc;
-    var args = [
-      shared,
-      cc_flags,
+    var args = (cc_flags != null) ? [ shared, cc_flags ] : [ shared ];

[Bill Hesse, 2016/04/27 13:54:40]

I like this better.

[kustermann, 2016/05/02 10:40:23]

Acknowledged.

+    args.addAll([
       '-o',
       '$tempDir/$libname',
       '$tempDir/precompiled.S'
-    ];
+    ]);
 
     return commandBuilder.getCompilationCommand('assemble', tempDir, !useSdk,
         bootstrapDependencies(buildDir), exec, args, environmentOverrides);
   }
 
   // This step reduces the amount of space needed to run the precompilation
   // tests by 60%.
   CompilationCommand computeRemoveAssemblyCommand(
       String tempDir,
       String buildDir,
@@ skipping 191 matching lines @@
       RuntimeConfiguration runtimeConfiguration,
       String buildDir,
       TestInformation info,
       List<String> vmOptions,
       List<String> sharedOptions,
       List<String> originalArguments,
       CommandArtifact artifact) {
     return <String>[];
   }
 }