Build for Android x64

tools/build.py

 #!/usr/bin/env python
 #
 # Copyright (c) 2012, 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.
 #
 
 import optparse
 import os
 import re
@@ skipping 101 matching lines @@
       print "Unknown os %s" % os_name
       return False
     if os_name != HOST_OS:
       if os_name != 'android':
         print "Unsupported target os %s" % os_name
         return False
       if not HOST_OS in ['linux']:
         print ("Cross-compilation to %s is not supported on host os %s."
                % (os_name, HOST_OS))
         return False
-      if not arch in ['ia32', 'arm', 'armv6', 'armv5te', 'arm64', 'mips']:
+      if not arch in ['ia32', 'x64', 'arm', 'armv6', 'armv5te', 'arm64', 'mips']:
         print ("Cross-compilation to %s is not supported for architecture %s."
                % (os_name, arch))
         return False
       # We have not yet tweaked the v8 dart build to work with the Android
       # NDK/SDK, so don't try to build it.
       if not args:
         print "For android builds you must specify a target, such as 'runtime'."
         return False
   return True
 
 
 def GetToolchainPrefix(target_os, arch, options):
   if options.toolchain != None:
     return options.toolchain
 
   if target_os == 'android':
     android_toolchain = GetAndroidToolchainDir(HOST_OS, arch)
     if arch == 'arm':
       return os.path.join(android_toolchain, 'arm-linux-androideabi')
     if arch == 'arm64':
       return os.path.join(android_toolchain, 'aarch64-linux-android')
     if arch == 'ia32':
       return os.path.join(android_toolchain, 'i686-linux-android')
+    if arch == 'x64':
+      return os.path.join(android_toolchain, 'x86_64-linux-android')
 
   # If no cross compiler is specified, only try to figure one out on Linux.
   if not HOST_OS in ['linux']:
     raise Exception('Unless --toolchain is used cross-building is only '
                     'supported on Linux.')
 
   # For ARM Linux, by default use the Linux distribution's cross-compiler.
   if arch == 'arm':
     # To use a non-hf compiler, specify on the command line with --toolchain.
     return (DEFAULT_ARM_CROSS_COMPILER_PATH + "/arm-linux-gnueabihf")
@@ skipping 32 matching lines @@
 def CheckDirExists(path, docstring):
   if not os.path.isdir(path):
     raise Exception('Could not find %s directory %s'
           % (docstring, path))
 
 
 def GetAndroidToolchainDir(host_os, target_arch):
   global THIRD_PARTY_ROOT
   if host_os not in ['linux']:
     raise Exception('Unsupported host os %s' % host_os)
-  if target_arch not in ['ia32', 'arm', 'arm64']:
+  if target_arch not in ['ia32', 'x64', 'arm', 'arm64']:
     raise Exception('Unsupported target architecture %s' % target_arch)
 
   # Set up path to the Android NDK.
   CheckDirExists(THIRD_PARTY_ROOT, 'third party tools')
   android_tools = os.path.join(THIRD_PARTY_ROOT, 'android_tools')
   CheckDirExists(android_tools, 'Android tools')
   android_ndk_root = os.path.join(android_tools, 'ndk')
   CheckDirExists(android_ndk_root, 'Android NDK')
 
   # Set up the directory of the Android NDK cross-compiler toolchain.
   toolchain_arch = 'arm-linux-androideabi-4.9'
   if target_arch == 'arm64':
     toolchain_arch = 'aarch64-linux-android-4.9'
   if target_arch == 'ia32':
     toolchain_arch = 'x86-4.9'
+  if target_arch == 'x64':
+    toolchain_arch = 'x86_64-4.9'
   toolchain_dir = 'linux-x86_64'
   android_toolchain = os.path.join(android_ndk_root,
       'toolchains', toolchain_arch,
       'prebuilt', toolchain_dir, 'bin')
   CheckDirExists(android_toolchain, 'Android toolchain')
 
   return android_toolchain
 
 
 def Execute(args):
@@ skipping 328 matching lines @@
           else:
             if BuildOneConfig(options, target, target_os,
                               mode, arch, cross_build) != 0:
               return 1
 
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(Main())