fuchsia libprofile wip

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
 import distutils.spawn
 import glob
 import os
 import pipes
 import re
 import shutil
 import subprocess
 import stat
 import sys
 import tarfile
 import tempfile
 import time
 import urllib2
 import zipfile
 
 
 # Do NOT CHANGE this if you don't know what you're doing -- see
 # https://chromium.googlesource.com/chromium/src/+/master/docs/updating_clang.md
 # Reverting problematic clang rolls is safe, though.
-CLANG_REVISION = '303369'
+CLANG_REVISION = '303370'
 
 use_head_revision = 'LLVM_FORCE_HEAD_REVISION' in os.environ
 if use_head_revision:
   CLANG_REVISION = 'HEAD'
 
 # This is incremented when pushing a new build of Clang at the same revision.
 CLANG_SUB_REVISION=1
 
 PACKAGE_VERSION = "%s-%s" % (CLANG_REVISION, CLANG_SUB_REVISION)
 
@@ skipping 25 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 93 matching lines @@
     if not os.access(path, os.W_OK):
       os.chmod(path, stat.S_IWUSR)
       return func(path)
     raise
 
   shutil.rmtree(dir, onerror=ChmodAndRetry)
 
 
 def RmCmakeCache(dir):
   """Delete CMake cache related files from dir."""
+  return
   for dirpath, dirs, files in os.walk(dir):
     if 'CMakeCache.txt' in files:
       os.remove(os.path.join(dirpath, 'CMakeCache.txt'))
     if 'CMakeFiles' in dirs:
       RmTree(os.path.join(dirpath, 'CMakeFiles'))
 
 
 def RunCommand(command, msvc_arch=None, env=None, fail_hard=True):
   """Run command and return success (True) or failure; or if fail_hard is
      True, exit on failure.  If msvc_arch is set, runs the command in a
@@ skipping 242 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 'The Fuchsia SDK is needed to build libclang_rt for Fuchsia.'
+    print 'Install the Fuchsia SDK by adding fuchsia to the '
+    print 'target_os section in your .gclient and running hooks, '
+    print 'or pass --without-fuchsia.'
+    # TODO(thakis): Link to "chromium/fuchsia build instructions" page once it
+    # exists.
+    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)
@@ skipping 226 matching lines @@
   elif sys.platform.startswith('linux'):
     RunCommand(['strip', os.path.join(LLVM_BUILD_DIR, 'bin', 'clang')])
 
   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)
+  #if os.path.isdir(COMPILER_RT_BUILD_DIR):
+    #RmTree(COMPILER_RT_BUILD_DIR)
+  #os.makedirs(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 107 matching lines @@
         '-DANDROID=1']
       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:
+    # Fuchsia links against libclang_rt.builtins-<arch>.a instead of libgcc.a.
+    for target_arch in ['aarch64', 'x86_64']:
+      toolchain_dir = os.path.join(
+          FUCHSIA_SDK_DIR, 'sysroot', '%s-fuchsia' % target_arch)
+      # Build clang_rt runtime for Fuchsia in a separate build tree.
+      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)
+      # TODO(thakis): Might have to pass -B here once sysroot contains
+      # binaries (e.g. gas for arm64?)
+      cflags = ['--target=%s-fuchsia' % target_arch,
+                '--sysroot=%s' % toolchain_dir]
+      ldflags = ['--sysroot=%s' % toolchain_dir]
+      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++'),
+        '-DLLVM_CONFIG_PATH=' + os.path.join(LLVM_BUILD_DIR, 'bin/llvm-config'),
+        '-DCMAKE_C_FLAGS=' + ' '.join(cflags),
+        '-DCMAKE_CXX_FLAGS=' + ' '.join(cflags),
+        '-DCMAKE_EXE_LINKER_FLAGS=' + ' '.join(ldflags),
+        '-DCMAKE_SHARED_LINKER_FLAGS=' + ' '.join(ldflags),
+        '-DCMAKE_MODULE_LINKER_FLAGS=' + ' '.join(ldflags),
+        ]
+      RmCmakeCache('.')
+      RunCommand(['cmake'] + fuchsia_args + [COMPILER_RT_DIR])
+      RunCommand(['ninja', 'libclang_rt.builtins-%s.a' % target_arch])
+
+      # And copy it into the main build tree.
+      fuchsia_lib_dst_dir = os.path.join(LLVM_BUILD_DIR, 'lib', 'clang',
+                                         VERSION, 'lib', 'fuchsia')
+      runtime = 'libclang_rt.builtins-%s.a' % target_arch
+      for root, _, files in os.walk(build_dir):
+        if runtime in files:
+          shutil.copy(os.path.join(root, runtime), fuchsia_lib_dst_dir)
 
   # 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')
@@ skipping 24 matching lines @@
   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 clang_rt 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 27 matching lines @@
   if use_head_revision:
     # Use a real revision number rather than HEAD to make sure that the stamp
     # file logic works.
     CLANG_REVISION = GetSvnRevision(LLVM_REPO_URL)
     PACKAGE_VERSION = CLANG_REVISION + '-0'
 
     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
+    # Don't build fuchsia runtime on ToT bots at all.
+    args.with_fuchsia = False
 
   return UpdateClang(args)
 
 
 if __name__ == '__main__':
   sys.exit(main())