Allows build of the standalone VM for ARM adroid.

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 83 matching lines @@
       print "Unknown os %s" % os
       return False
     if os != HOST_OS:
       if os != 'android':
         print "Unsupported target os %s" % os
         return False
       if not HOST_OS in ['linux']:
         print ("Cross-compilation to %s is not supported on host os %s."
                % (os, HOST_OS))
         return False
-      if not arch in ['ia32']:
+      if not arch in ['ia32', 'arm']:
         print ("Cross-compilation to %s is not supported for architecture %s."
                % (os, 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 args == []:
         print "For android builds you must specify a target, such as 'samples'."
         return False
       if 'v8' in args:
         print "The v8 target is not supported for android builds."
@@ skipping 22 matching lines @@
     raise Exception('Could not find %s directory %s'
           % (docstring, path))
 
 
 def SetCrossCompilationEnvironment(host_os, target_os, target_arch, old_path):
   global THIRD_PARTY_ROOT
   if host_os not in ['linux']:
     raise Exception('Unsupported host os %s' % host_os)
   if target_os not in ['android']:
     raise Exception('Unsupported target os %s' % target_os)
-  if target_arch not in ['ia32']:
+  if target_arch not in ['ia32', 'arm']:
     raise Exception('Unsupported target architecture %s' % target_arch)
 
   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')
   android_sdk_root = os.path.join(android_tools, 'sdk')
   CheckDirExists(android_sdk_root, 'Android SDK')
 
   os.environ['ANDROID_NDK_ROOT'] = android_ndk_root
   os.environ['ANDROID_SDK_ROOT'] = android_sdk_root
 
-  toolchain_arch = 'x86-4.4.3'
+  if target_arch == 'arm':
+    toolchain_arch = 'arm-linux-androideabi-4.6'
+  else:
+    toolchain_arch = 'x86-4.4.3'
   toolchain_dir = 'linux-x86'
   android_toolchain = os.path.join(android_ndk_root,
       'toolchains', toolchain_arch,
       'prebuilt', toolchain_dir, 'bin')
   CheckDirExists(android_toolchain, 'Android toolchain')
 
   os.environ['ANDROID_TOOLCHAIN'] = android_toolchain
 
   android_sdk_version = 15
 
   android_sdk_tools = os.path.join(android_sdk_root, 'tools')
   CheckDirExists(android_sdk_tools, 'Android SDK tools')
 
   android_sdk_platform_tools = os.path.join(android_sdk_root, 'platform-tools')
   CheckDirExists(android_sdk_platform_tools, 'Android SDK platform tools')
 
   pathList = [old_path,
               android_ndk_root,
               android_sdk_tools,
               android_sdk_platform_tools,
               # for Ninja - maybe don't need?
               android_toolchain
               ]
   os.environ['PATH'] = ':'.join(pathList)
 
+  android_target_arch = target_arch
+  if target_arch == 'ia32':
+    android_target_arch = 'x86'
+
   gypDefinesList = [
-    'target_arch=ia32',
+    'target_arch=%s' % target_arch,
+    'android_target_arch=%s' % android_target_arch,
     'OS=%s' % target_os,
     'android_build_type=0',
     'host_os=%s' % host_os,
     'linux_fpic=1',
     'release_optimize=s',
     'linux_use_tcmalloc=0',
     'android_sdk=%s', os.path.join(android_sdk_root, 'platforms',
         'android-%d' % android_sdk_version),
     'android_sdk_tools=%s' % android_sdk_platform_tools
     ]
 
   os.environ['GYP_DEFINES'] = ' '.join(gypDefinesList)
 
 
 def Execute(args):
   process = subprocess.Popen(args)
   process.wait()
   if process.returncode != 0:
     raise Exception(args[0] + " failed")
 
 
 def GClientRunHooks():
   Execute(['gclient', 'runhooks'])
 
 
-def RunhooksIfNeeded(host_os, mode, arch, target_os):
+def RunhooksIfNeeded(host_os, mode, target_arch, target_os):
   if host_os != 'linux':
     return
   build_root = utils.GetBuildRoot(host_os)
   build_cookie_path = os.path.join(build_root, 'lastHooksTargetOS.txt')
 
   old_target_os = None
+  old_target_arch = None
   try:
     with open(build_cookie_path) as f:
-      old_target_os = f.read(1024)
+      lines = f.readlines()
+      old_target_os = lines[0]
+      old_target_arch = lines[1]
   except IOError as e:
     pass
-  if target_os != old_target_os:
+  if (target_os != old_target_os) or (target_arch != old_target_arch):
     try:
       os.mkdir(build_root)
     except OSError as e:
       pass
     with open(build_cookie_path, 'w') as f:
-      f.write(target_os)
+      f.write(target_os + '\n')
+      f.write(target_arch + '\n')
     GClientRunHooks()
 
 
 def CurrentDirectoryBaseName():
   """Returns the name of the current directory"""
   return os.path.relpath(os.curdir, start=os.pardir)
 
 
 def FilterEmptyXcodebuildSections(process):
   """
@@ skipping 167 matching lines @@
 
             args += [target]
 
           if target_os != HOST_OS:
             SetCrossCompilationEnvironment(
                 HOST_OS, target_os, arch, old_path)
 
           RunhooksIfNeeded(HOST_OS, mode, arch, target_os)
 
           toolchainprefix = None
-          if target_os == 'android':
+          if target_os == 'android' and arch == 'ia32':
             toolchainprefix = ('%s/i686-linux-android'
                                 % os.environ['ANDROID_TOOLCHAIN'])
+          elif target_os == 'android' and arch == 'arm':
+            toolchainprefix = ('%s/arm-linux-androideabi'
+                                % os.environ['ANDROID_TOOLCHAIN'])
           toolsOverride = SetTools(arch, toolchainprefix)
           if toolsOverride:
             printToolOverrides = target_os != 'android'
             for k, v in toolsOverride.iteritems():
               args.append(  k + "=" + v)
               if printToolOverrides:
                 print k + " = " + v
             if not os.path.isfile(toolsOverride['CC.target']):
               if arch == 'arm':
                 print arm_cc_error
@@ skipping 16 matching lines @@
           process.wait()
           if process.returncode != 0:
             print "BUILD FAILED"
             return 1
 
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(Main())