Fuchsia: Initial check-in.

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 42 matching lines @@
   result.add_option("-v", "--verbose",
       help='Verbose output.',
       default=False, action="store_true")
   result.add_option("-a", "--arch",
       help='Target architectures (comma-separated).',
       metavar='[all,ia32,x64,simarm,arm,simarmv6,armv6,simarmv5te,armv5te,'
               'simmips,mips,simarm64,arm64,simdbc,armsimdbc]',
       default=utils.GuessArchitecture())
   result.add_option("--os",
     help='Target OSs (comma-separated).',
-    metavar='[all,host,android]',
+    metavar='[all,host,android,fuchsia]',
     default='host')
   result.add_option("-t", "--toolchain",
     help='Cross-compiler toolchain path',
     default=None)
   result.add_option("-j",
       help='The number of parallel jobs to run.',
       metavar=HOST_CPUS,
       default=str(HOST_CPUS))
   (vs_directory, vs_executable) = utils.GuessVisualStudioPath()
   result.add_option("--devenv",
@@ skipping 28 matching lines @@
       return False
   for arch in options.arch:
     archs = ['ia32', 'x64', 'simarm', 'arm', 'simarmv6', 'armv6',
              'simarmv5te', 'armv5te', 'simmips', 'mips', 'simarm64', 'arm64',
              'simdbc', 'simdbc64', 'armsimdbc']
     if not arch in archs:
       print "Unknown arch %s" % arch
       return False
   options.os = [ProcessOsOption(os_name) for os_name in options.os]
   for os_name in options.os:
-    if not os_name in ['android', 'freebsd', 'linux', 'macos', 'win32']:
+    if not os_name in ['android', 'freebsd', 'fuchsia', 'linux', 'macos', 'win32']:
       print "Unknown os %s" % os_name
       return False
     if os_name != HOST_OS:
-      if os_name != 'android':
+      if os_name != 'android' and os_name != 'fuchsia':
         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', 'x64', 'arm', 'armv6', 'armv5te', 'arm64', 'mips',
                       'simdbc', 'simdbc64']:
         print ("Cross-compilation to %s is not supported for architecture %s."
                % (os_name, arch))
@@ skipping 14 matching lines @@
     android_toolchain = GetAndroidToolchainDir(HOST_OS, arch)
     if arch == 'arm' or arch == 'simdbc':
       return os.path.join(android_toolchain, 'arm-linux-androideabi')
     if arch == 'arm64' or arch == 'simdbc64':
       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 target_os == 'fuchsia':
+    fuchsia_toolchain = GetFuchsiaToolchainDir(HOST_OS, arch)
+    if arch == 'arm64':
+      return os.path.join(fuchsia_toolchain, 'aarch64-elf')
+    if arch == 'x64':
+      return os.path.join(fuchsia_toolchain, 'x86_64-elf')
+
   # 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' or arch == 'armsimdbc':
     # To use a non-hf compiler, specify on the command line with --toolchain.
     return (DEFAULT_ARM_CROSS_COMPILER_PATH + "/arm-linux-gnueabihf")
   if arch == 'arm64':
     return (DEFAULT_ARM_CROSS_COMPILER_PATH + "/aarch64-linux-gnu")
 
   # TODO(zra): Find default MIPS Linux cross-compiler.
 
   return None
 
 
 def SetTools(arch, target_os, options):
   toolsOverride = None
 
   toolchainprefix = GetToolchainPrefix(target_os, arch, options)
 
   # Override the Android toolchain's linker to handle some complexity in the
   # linker arguments that gyp has trouble with.
   linker = ""
   if target_os == 'android':
     linker = os.path.join(DART_ROOT, 'tools', 'android_link.py')
+  elif target_os == 'fuchsia':
+    linker = os.path.join(DART_ROOT, 'tools', 'fuchsia_link.py')
   elif toolchainprefix:
     linker = toolchainprefix + "-g++"
 
   if toolchainprefix:
     toolsOverride = {
       "CC.target"  :  toolchainprefix + "-gcc",
       "CXX.target" :  toolchainprefix + "-g++",
       "AR.target"  :  toolchainprefix + "-ar",
       "LINK.target":  linker,
       "NM.target"  :  toolchainprefix + "-nm",
@@ skipping 31 matching lines @@
     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 GetFuchsiaToolchainDir(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 ['x64', 'arm64',]:
+    raise Exception('Unsupported target architecture %s' % target_arch)
+
+  # Set up path to the Android NDK.
+  CheckDirExists(THIRD_PARTY_ROOT, 'third party tools')
+  fuchsia_tools = os.path.join(THIRD_PARTY_ROOT, 'fuchsia_tools')
+  CheckDirExists(fuchsia_tools, 'Fuchsia tools')
+
+  toolchain_arch = 'x86_64-elf-5.3.0-Linux-x86_64'
+  if target_arch == 'arm64':
+    toolchain_arch = 'aarch64-elf-5.3.0-Linux-x86_64'
+  fuchsia_toolchain = os.path.join(
+      fuchsia_tools, 'toolchains', toolchain_arch, 'bin')
+  CheckDirExists(fuchsia_toolchain, 'Fuchsia toolchain')
+
+  return fuchsia_toolchain
+
+
 def Execute(args):
   process = subprocess.Popen(args)
   process.wait()
   if process.returncode != 0:
     raise Exception(args[0] + " failed")
 
 
 def CurrentDirectoryBaseName():
   """Returns the name of the current directory"""
   return os.path.relpath(os.curdir, start=os.pardir)
@@ skipping 319 matching lines @@
           else:
             if BuildOneConfig(options, target, target_os,
                               mode, arch, cross_build) != 0:
               return 1
 
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(Main())