not working update.py to build fuchsia builtins

tools/clang/scripts/update.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """This script is used to download prebuilt clang binaries.
 
 It is also used by package.py to build the prebuilt clang binaries."""
 
 import argparse
@@ skipping 55 matching lines @@
     os.path.join(LLVM_DIR, '..', 'llvm-build-tools'))
 STAMP_FILE = os.path.normpath(
     os.path.join(LLVM_DIR, '..', 'llvm-build', 'cr_build_revision'))
 BINUTILS_DIR = os.path.join(THIRD_PARTY_DIR, 'binutils', 'Linux_x64', 'Release')
 BINUTILS_BIN_DIR = os.path.join(BINUTILS_DIR, 'bin')
 BINUTILS_LIB_DIR = os.path.join(BINUTILS_DIR, 'lib')
 BFD_PLUGINS_DIR = os.path.join(BINUTILS_LIB_DIR, 'bfd-plugins')
 VERSION = '5.0.0'
 ANDROID_NDK_DIR = os.path.join(
     CHROMIUM_DIR, 'third_party', 'android_tools', 'ndk')
+FUCHSIA_SDK_DIR = os.path.join(CHROMIUM_DIR, 'third_party', 'fuchsia-sdk')
 
 # URL for pre-built binaries.
 CDS_URL = os.environ.get('CDS_CLANG_BUCKET_OVERRIDE',
     'https://commondatastorage.googleapis.com/chromium-browser-clang')
 
 LLVM_REPO_URL='https://llvm.org/svn/llvm-project'
 if 'LLVM_REPO_URL' in os.environ:
   LLVM_REPO_URL = os.environ['LLVM_REPO_URL']
 
 # Bump after VC updates.
@@ skipping 355 matching lines @@
       return 1
 
   if args.with_android and not os.path.exists(ANDROID_NDK_DIR):
     print 'Android NDK not found at ' + ANDROID_NDK_DIR
     print 'The Android NDK is needed to build a Clang whose -fsanitize=address'
     print 'works on Android. See '
     print 'https://www.chromium.org/developers/how-tos/android-build-instructions'
     print 'for how to install the NDK, or pass --without-android.'
     return 1
 
+  if args.with_fuchsia and not os.path.exists(FUCHSIA_SDK_DIR):
+    print 'Fuchsia SDK not found at ' + FUCHSIA_SDK_DIR
+    print 'Either install it there by including target_os=[\'fuchsia\'] in '
+    print '.gclient and rerunning gclient runhooks, or pass --without-fuchsia.'
+    return 1
+
   DownloadHostGcc(args)
   AddCMakeToPath()
   AddGnuWinToPath()
 
   DeleteChromeToolsShim()
 
   Checkout('LLVM', LLVM_REPO_URL + '/llvm/trunk', LLVM_DIR)
   Checkout('Clang', LLVM_REPO_URL + '/cfe/trunk', CLANG_DIR)
   if sys.platform != 'darwin':
     Checkout('LLD', LLVM_REPO_URL + '/lld/trunk', LLD_DIR)
   elif os.path.exists(LLD_DIR):
-    # In case someone sends a tryjob that temporary adds lld to the checkout,
+    # In case someone sends a tryjob that temporarily adds lld to the checkout,
     # make sure it's not around on future builds.
     RmTree(LLD_DIR)
   Checkout('compiler-rt', LLVM_REPO_URL + '/compiler-rt/trunk', COMPILER_RT_DIR)
   if sys.platform == 'darwin':
     # clang needs a libc++ checkout, else -stdlib=libc++ won't find includes
     # (i.e. this is needed for bootstrap builds).
     Checkout('libcxx', LLVM_REPO_URL + '/libcxx/trunk', LIBCXX_DIR)
     # We used to check out libcxxabi on OS X; we no longer need that.
     if os.path.exists(LIBCXXABI_DIR):
       RmTree(LIBCXXABI_DIR)
@@ skipping 216 matching lines @@
 
   VeryifyVersionOfBuiltClangMatchesVERSION()
 
   # Do an out-of-tree build of compiler-rt.
   # On Windows, this is used to get the 32-bit ASan run-time.
   # TODO(hans): Remove once the regular build above produces this.
   # On Mac and Linux, this is used to get the regular 64-bit run-time.
   # Do a clobbered build due to cmake changes.
   if os.path.isdir(COMPILER_RT_BUILD_DIR):
     RmTree(COMPILER_RT_BUILD_DIR)
-  os.makedirs(COMPILER_RT_BUILD_DIR)
+  EnsureDirExists(COMPILER_RT_BUILD_DIR)
   os.chdir(COMPILER_RT_BUILD_DIR)
   # TODO(thakis): Add this once compiler-rt can build with clang-cl (see
   # above).
   #if args.bootstrap and sys.platform == 'win32':
     # The bootstrap compiler produces 64-bit binaries by default.
     #cflags += ['-m32']
     #cxxflags += ['-m32']
   compiler_rt_args = base_cmake_args + [
       '-DLLVM_ENABLE_THREADS=OFF',
       '-DCMAKE_C_FLAGS=' + ' '.join(cflags),
@@ skipping 108 matching lines @@
       RmCmakeCache('.')
       RunCommand(['cmake'] + android_args + [COMPILER_RT_DIR])
       RunCommand(['ninja', 'libclang_rt.asan-%s-android.so' % target_arch])
 
       # And copy it into the main build tree.
       runtime = 'libclang_rt.asan-%s-android.so' % target_arch
       for root, _, files in os.walk(build_dir):
         if runtime in files:
           shutil.copy(os.path.join(root, runtime), asan_rt_lib_dst_dir)
 
+  if args.with_fuchsia:
+    # TODO(fuchsia): There's no aarch64 sysroot in the SDK yet.
+    for target_arch in ('x86_64',):
+      build_dir = os.path.join(LLVM_BUILD_DIR, 'fuchsia-' + target_arch)
+      if not os.path.exists(build_dir):
+        os.mkdir(os.path.join(build_dir))
+      os.chdir(build_dir)
+      sysroot = '%s/sysroot/%s-fuchsia' % (FUCHSIA_SDK_DIR, target_arch)
+      cflags = ['--target=%s-fuchsia' % target_arch,
+                '--sysroot=' + sysroot]
+      fuchsia_args = base_cmake_args + [
+        '-DLLVM_ENABLE_THREADS=OFF',
+        '-DCMAKE_C_COMPILER=' + os.path.join(LLVM_BUILD_DIR, 'bin/clang'),
+        '-DCMAKE_CXX_COMPILER=' + os.path.join(LLVM_BUILD_DIR, 'bin/clang'),
+        '-DCMAKE_C_COMPILER_WORKS=ON',
+        '-DCOMPILER_RT_DEFAULT_TARGET_ONLY=ON',
+        '-DCMAKE_C_COMPILER_TARGET=%s-fuchsia-none' % target_arch,
+        '-DCMAKE_CXX_COMPILER_WORKS=ON',
+        '-DLLVM_CONFIG_PATH=' + os.path.join(LLVM_BUILD_DIR, 'bin/llvm-config'),
+        '-DCMAKE_C_FLAGS=' + ' '.join(cflags),
+        '-DCMAKE_CXX_FLAGS=' + ' '.join(cflags)]
+
+      RmCmakeCache('.')
+      RunCommand(['cmake'] + fuchsia_args + [COMPILER_RT_DIR])
+      RunCommand(['ninja', 'builtins'])
+
   # Run tests.
   if args.run_tests or use_head_revision:
     os.chdir(LLVM_BUILD_DIR)
     RunCommand(['ninja', 'cr-check-all'], msvc_arch='x64')
   if args.run_tests:
     if sys.platform == 'win32':
       CopyDiaDllTo(os.path.join(LLVM_BUILD_DIR, 'bin'))
     os.chdir(LLVM_BUILD_DIR)
     RunCommand(['ninja', 'check-all'], msvc_arch='x64')
 
   WriteStampFile(PACKAGE_VERSION)
   print 'Clang update was successful.'
   return 0
 
 
 def main():
   parser = argparse.ArgumentParser(description='Build Clang.')
   parser.add_argument('--bootstrap', action='store_true',
                       help='first build clang with CC, then with itself.')
   parser.add_argument('--if-needed', action='store_true',
                       help="run only if the script thinks clang is needed")
   parser.add_argument('--force-local-build', action='store_true',
-                      help="don't try to download prebuild binaries")
+                      help="don't try to download prebuilt binaries")
   parser.add_argument('--gcc-toolchain', help='set the version for which gcc '
                       'version be used for building; --gcc-toolchain=/opt/foo '
                       'picks /opt/foo/bin/gcc')
   parser.add_argument('--lto-gold-plugin', action='store_true',
                       help='build LLVM Gold plugin with LTO')
   parser.add_argument('--llvm-force-head-revision', action='store_true',
                       help=('use the revision in the repo when printing '
                             'the revision'))
   parser.add_argument('--print-revision', action='store_true',
                       help='print current clang revision and exit.')
   parser.add_argument('--print-clang-version', action='store_true',
                       help='print current clang version (e.g. x.y.z) and exit.')
   parser.add_argument('--run-tests', action='store_true',
                       help='run tests after building; only for local builds')
   parser.add_argument('--extra-tools', nargs='*', default=[],
                       help='select additional chrome tools to build')
   parser.add_argument('--without-android', action='store_false',
                       help='don\'t build Android ASan runtime (linux only)',
                       dest='with_android',
                       default=sys.platform.startswith('linux'))
+  parser.add_argument('--without-fuchsia', action='store_false',
+                      help='don\'t build Fuchsia runtime (linux only)',
+                      dest='with_fuchsia',
+                      default=sys.platform.startswith('linux'))
   args = parser.parse_args()
 
   if args.lto_gold_plugin and not args.bootstrap:
     print '--lto-gold-plugin requires --bootstrap'
     return 1
   if args.lto_gold_plugin and not sys.platform.startswith('linux'):
     print '--lto-gold-plugin is only effective on Linux. Ignoring the option.'
     args.lto_gold_plugin = False
 
   if args.if_needed:
@@ skipping 33 matching lines @@
     args.force_local_build = True
     if 'OS=android' not in os.environ.get('GYP_DEFINES', ''):
       # Only build the Android ASan rt on ToT bots when targetting Android.
       args.with_android = False
 
   return UpdateClang(args)
 
 
 if __name__ == '__main__':
   sys.exit(main())