tools/clang/scripts/update.sh

   1 #!/usr/bin/env bash
   2 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
   3 # Use of this source code is governed by a BSD-style license that can be
   4 # found in the LICENSE file.
   5
   6 # This script will check out llvm and clang into third_party/llvm and build it.
   7
   8 # Do NOT CHANGE this if you don't know what you're doing -- see
   9 # https://code.google.com/p/chromium/wiki/UpdatingClang
  10 # Reverting problematic clang rolls is safe, though.
  11 CLANG_REVISION=217949
  12
  13 THIS_DIR="$(dirname "${0}")"
  14 LLVM_DIR="${THIS_DIR}/../../../third_party/llvm"
  15 LLVM_BUILD_DIR="${LLVM_DIR}/../llvm-build/Release+Asserts"
  16 COMPILER_RT_BUILD_DIR="${LLVM_DIR}/../llvm-build/compiler-rt"
  17 LLVM_BOOTSTRAP_DIR="${LLVM_DIR}/../llvm-bootstrap"
  18 LLVM_BOOTSTRAP_INSTALL_DIR="${LLVM_DIR}/../llvm-bootstrap-install"
  19 CLANG_DIR="${LLVM_DIR}/tools/clang"
  20 COMPILER_RT_DIR="${LLVM_DIR}/compiler-rt"
  21 LIBCXX_DIR="${LLVM_DIR}/projects/libcxx"
  22 LIBCXXABI_DIR="${LLVM_DIR}/projects/libcxxabi"
  23 ANDROID_NDK_DIR="${THIS_DIR}/../../../third_party/android_tools/ndk"
  24 STAMP_FILE="${LLVM_DIR}/../llvm-build/cr_build_revision"
  25
  26 ABS_LIBCXX_DIR="${PWD}/${LIBCXX_DIR}"
  27 ABS_LIBCXXABI_DIR="${PWD}/${LIBCXXABI_DIR}"
  28 ABS_LLVM_DIR="${PWD}/${LLVM_DIR}"
  29 ABS_LLVM_BUILD_DIR="${PWD}/${LLVM_BUILD_DIR}"
  30 ABS_COMPILER_RT_DIR="${PWD}/${COMPILER_RT_DIR}"
  31
  32
  33 # Use both the clang revision and the plugin revisions to test for updates.
  34 BLINKGCPLUGIN_REVISION=\
  35 $(grep 'set(LIBRARYNAME' "$THIS_DIR"/../blink_gc_plugin/CMakeLists.txt \
  36     | cut -d ' ' -f 2 | tr -cd '[0-9]')
  37 CLANG_AND_PLUGINS_REVISION="${CLANG_REVISION}-${BLINKGCPLUGIN_REVISION}"
  38
  39 # ${A:-a} returns $A if it's set, a else.
  40 LLVM_REPO_URL=${LLVM_URL:-https://llvm.org/svn/llvm-project}
  41
  42 if [[ -z "$GYP_DEFINES" ]]; then
  43   GYP_DEFINES=
  44 fi
  45 if [[ -z "$GYP_GENERATORS" ]]; then
  46   GYP_GENERATORS=
  47 fi
  48
  49
  50 # Die if any command dies, error on undefined variable expansions.
  51 set -eu
  52
  53 OS="$(uname -s)"
  54
  55 # Parse command line options.
  56 if_needed=
  57 force_local_build=
  58 run_tests=
  59 bootstrap=
  60 with_android=yes
  61 chrome_tools="plugins;blink_gc_plugin"
  62 gcc_toolchain=
  63
  64 if [[ "${OS}" = "Darwin" ]]; then
  65   with_android=
  66 fi
  67
  68 while [[ $# > 0 ]]; do
  69   case $1 in
  70     --bootstrap)
  71       bootstrap=yes
  72       ;;
  73     --if-needed)
  74       if_needed=yes
  75       ;;
  76     --force-local-build)
  77       force_local_build=yes
  78       ;;
  79     --print-revision)
  80       echo $CLANG_REVISION
  81       exit 0
  82       ;;
  83     --run-tests)
  84       run_tests=yes
  85       ;;
  86     --without-android)
  87       with_android=
  88       ;;
  89     --with-chrome-tools)
  90       shift
  91       if [[ $# == 0 ]]; then
  92         echo "--with-chrome-tools requires an argument."
  93         exit 1
  94       fi
  95       chrome_tools=$1
  96       ;;
  97     --gcc-toolchain)
  98       shift
  99       if [[ $# == 0 ]]; then
 100         echo "--gcc-toolchain requires an argument."
 101         exit 1
 102       fi
 103       if [[ -x "$1/bin/gcc" ]]; then
 104         gcc_toolchain=$1
 105       else
 106         echo "Invalid --gcc-toolchain: '$1'."
 107         echo "'$1/bin/gcc' does not appear to be valid."
 108         exit 1
 109       fi
 110       ;;
 111
 112     --help)
 113       echo "usage: $0 [--force-local-build] [--if-needed] [--run-tests] "
 114       echo "--bootstrap: First build clang with CC, then with itself."
 115       echo "--force-local-build: Don't try to download prebuilt binaries."
 116       echo "--if-needed: Download clang only if the script thinks it is needed."
 117       echo "--run-tests: Run tests after building. Only for local builds."
 118       echo "--print-revision: Print current clang revision and exit."
 119       echo "--without-android: Don't build ASan Android runtime library."
 120       echo "--with-chrome-tools: Select which chrome tools to build." \
 121            "Defaults to plugins;blink_gc_plugin."
 122       echo "    Example: --with-chrome-tools plugins;empty-string"
 123       echo "--gcc-toolchain: Set the prefix for which GCC version should"
 124       echo "    be used for building. For example, to use gcc in"
 125       echo "    /opt/foo/bin/gcc, use '--gcc-toolchain '/opt/foo"
 126       echo
 127       exit 1
 128       ;;
 129     *)
 130       echo "Unknown argument: '$1'."
 131       echo "Use --help for help."
 132       exit 1
 133       ;;
 134   esac
 135   shift
 136 done
 137
 138 if [[ -n "$if_needed" ]]; then
 139   if [[ "${OS}" == "Darwin" ]]; then
 140     # clang is used on Mac.
 141     true
 142   elif [[ "$GYP_DEFINES" =~ .*(clang|tsan|asan|lsan|msan)=1.* ]]; then
 143     # clang requested via $GYP_DEFINES.
 144     true
 145   elif [[ -d "${LLVM_BUILD_DIR}" ]]; then
 146     # clang previously downloaded, remove third_party/llvm-build to prevent
 147     # updating.
 148     true
 149   elif [[ "${OS}" == "Linux" ]]; then
 150     # Temporarily use clang on linux. Leave a stamp file behind, so that
 151     # this script can remove clang again on machines where it was autoinstalled.
 152     mkdir -p "${LLVM_BUILD_DIR}"
 153     touch "${LLVM_BUILD_DIR}/autoinstall_stamp"
 154     true
 155   else
 156     # clang wasn't needed, not doing anything.
 157     exit 0
 158   fi
 159 fi
 160
 161
 162 # Check if there's anything to be done, exit early if not.
 163 if [[ -f "${STAMP_FILE}" ]]; then
 164   PREVIOUSLY_BUILT_REVISON=$(cat "${STAMP_FILE}")
 165   if [[ -z "$force_local_build" ]] && \
 166        [[ "${PREVIOUSLY_BUILT_REVISON}" = \
 167           "${CLANG_AND_PLUGINS_REVISION}" ]]; then
 168     echo "Clang already at ${CLANG_AND_PLUGINS_REVISION}"
 169     exit 0
 170   fi
 171 fi
 172 # To always force a new build if someone interrupts their build half way.
 173 rm -f "${STAMP_FILE}"
 174
 175
 176 if [[ -z "$force_local_build" ]]; then
 177   # Check if there's a prebuilt binary and if so just fetch that. That's faster,
 178   # and goma relies on having matching binary hashes on client and server too.
 179   CDS_URL=https://commondatastorage.googleapis.com/chromium-browser-clang
 180   CDS_FILE="clang-${CLANG_REVISION}.tgz"
 181   CDS_OUT_DIR=$(mktemp -d -t clang_download.XXXXXX)
 182   CDS_OUTPUT="${CDS_OUT_DIR}/${CDS_FILE}"
 183   if [ "${OS}" = "Linux" ]; then
 184     CDS_FULL_URL="${CDS_URL}/Linux_x64/${CDS_FILE}"
 185   elif [ "${OS}" = "Darwin" ]; then
 186     CDS_FULL_URL="${CDS_URL}/Mac/${CDS_FILE}"
 187   fi
 188   echo Trying to download prebuilt clang
 189   if which curl > /dev/null; then
 190     curl -L --fail "${CDS_FULL_URL}" -o "${CDS_OUTPUT}" || \
 191         rm -rf "${CDS_OUT_DIR}"
 192   elif which wget > /dev/null; then
 193     wget "${CDS_FULL_URL}" -O "${CDS_OUTPUT}" || rm -rf "${CDS_OUT_DIR}"
 194   else
 195     echo "Neither curl nor wget found. Please install one of these."
 196     exit 1
 197   fi
 198   if [ -f "${CDS_OUTPUT}" ]; then
 199     rm -rf "${LLVM_BUILD_DIR}"
 200     mkdir -p "${LLVM_BUILD_DIR}"
 201     tar -xzf "${CDS_OUTPUT}" -C "${LLVM_BUILD_DIR}"
 202     echo clang "${CLANG_REVISION}" unpacked
 203     echo "${CLANG_AND_PLUGINS_REVISION}" > "${STAMP_FILE}"
 204     rm -rf "${CDS_OUT_DIR}"
 205     exit 0
 206   else
 207     echo Did not find prebuilt clang at r"${CLANG_REVISION}", building
 208   fi
 209 fi
 210
 211 if [[ -n "${with_android}" ]] && ! [[ -d "${ANDROID_NDK_DIR}" ]]; then
 212   echo "Android NDK not found at ${ANDROID_NDK_DIR}"
 213   echo "The Android NDK is needed to build a Clang whose -fsanitize=address"
 214   echo "works on Android. See "
 215   echo "http://code.google.com/p/chromium/wiki/AndroidBuildInstructions for how"
 216   echo "to install the NDK, or pass --without-android."
 217   exit 1
 218 fi
 219
 220 # Check that cmake and ninja are available.
 221 if ! which cmake > /dev/null; then
 222   echo "CMake needed to build clang; please install"
 223   exit 1
 224 fi
 225 if ! which ninja > /dev/null; then
 226   echo "ninja needed to build clang, please install"
 227   exit 1
 228 fi
 229
 230 echo Reverting previously patched files
 231 for i in \
 232       "${CLANG_DIR}/test/Index/crash-recovery-modules.m" \
 233       "${CLANG_DIR}/unittests/libclang/LibclangTest.cpp" \
 234       "${COMPILER_RT_DIR}/lib/asan/asan_rtl.cc" \
 235       "${COMPILER_RT_DIR}/test/asan/TestCases/Linux/new_array_cookie_test.cc" \
 236       ; do
 237   if [[ -e "${i}" ]]; then
 238     svn revert "${i}"
 239   fi;
 240 done
 241
 242 echo Getting LLVM r"${CLANG_REVISION}" in "${LLVM_DIR}"
 243 if ! svn co --force "${LLVM_REPO_URL}/llvm/trunk@${CLANG_REVISION}" \
 244                     "${LLVM_DIR}"; then
 245   echo Checkout failed, retrying
 246   rm -rf "${LLVM_DIR}"
 247   svn co --force "${LLVM_REPO_URL}/llvm/trunk@${CLANG_REVISION}" "${LLVM_DIR}"
 248 fi
 249
 250 echo Getting clang r"${CLANG_REVISION}" in "${CLANG_DIR}"
 251 svn co --force "${LLVM_REPO_URL}/cfe/trunk@${CLANG_REVISION}" "${CLANG_DIR}"
 252
 253 # We have moved from building compiler-rt in the LLVM tree, to a separate
 254 # directory. Nuke any previous checkout to avoid building it.
 255 rm -rf "${LLVM_DIR}/projects/compiler-rt"
 256
 257 echo Getting compiler-rt r"${CLANG_REVISION}" in "${COMPILER_RT_DIR}"
 258 svn co --force "${LLVM_REPO_URL}/compiler-rt/trunk@${CLANG_REVISION}" \
 259                "${COMPILER_RT_DIR}"
 260
 261 # clang needs a libc++ checkout, else -stdlib=libc++ won't find includes
 262 # (i.e. this is needed for bootstrap builds).
 263 if [ "${OS}" = "Darwin" ]; then
 264   echo Getting libc++ r"${CLANG_REVISION}" in "${LIBCXX_DIR}"
 265   svn co --force "${LLVM_REPO_URL}/libcxx/trunk@${CLANG_REVISION}" \
 266                  "${LIBCXX_DIR}"
 267 fi
 268
 269 # While we're bundling our own libc++ on OS X, we need to compile libc++abi
 270 # into it too (since OS X 10.6 doesn't have libc++abi.dylib either).
 271 if [ "${OS}" = "Darwin" ]; then
 272   echo Getting libc++abi r"${CLANG_REVISION}" in "${LIBCXXABI_DIR}"
 273   svn co --force "${LLVM_REPO_URL}/libcxxabi/trunk@${CLANG_REVISION}" \
 274                  "${LIBCXXABI_DIR}"
 275 fi
 276
 277 # Apply patch for tests failing with --disable-pthreads (llvm.org/PR11974)
 278 pushd "${CLANG_DIR}"
 279 cat << 'EOF' |
 280 --- third_party/llvm/tools/clang/test/Index/crash-recovery-modules.m    (revision 202554)
 281 +++ third_party/llvm/tools/clang/test/Index/crash-recovery-modules.m    (working copy)
 282 @@ -12,6 +12,8 @@
 283
 284  // REQUIRES: crash-recovery
 285  // REQUIRES: shell
 286 +// XFAIL: *
 287 +//    (PR11974)
 288
 289  @import Crash;
 290 EOF
 291 patch -p4
 292 popd
 293
 294 pushd "${CLANG_DIR}"
 295 cat << 'EOF' |
 296 --- unittests/libclang/LibclangTest.cpp (revision 215949)
 297 +++ unittests/libclang/LibclangTest.cpp (working copy)
 298 @@ -431,7 +431,7 @@
 299    EXPECT_EQ(0U, clang_getNumDiagnostics(ClangTU));
 300  }
 301
 302 -TEST_F(LibclangReparseTest, ReparseWithModule) {
 303 +TEST_F(LibclangReparseTest, DISABLED_ReparseWithModule) {
 304    const char *HeaderTop = "#ifndef H\n#define H\nstruct Foo { int bar;";
 305    const char *HeaderBottom = "\n};\n#endif\n";
 306    const char *MFile = "#include \"HeaderFile.h\"\nint main() {"
 307 EOF
 308 patch -p0
 309 popd
 310
 311 # Echo all commands.
 312 set -x
 313
 314 # Set default values for CC and CXX if they're not set in the environment.
 315 CC=${CC:-cc}
 316 CXX=${CXX:-c++}
 317
 318 if [[ -n "${gcc_toolchain}" ]]; then
 319   # Use the specified gcc installation for building.
 320   CC="$gcc_toolchain/bin/gcc"
 321   CXX="$gcc_toolchain/bin/g++"
 322   # Set LD_LIBRARY_PATH to make auxiliary targets (tablegen, bootstrap compiler,
 323   # etc.) find the .so.
 324   export LD_LIBRARY_PATH="$(dirname $(${CXX} -print-file-name=libstdc++.so.6))"
 325 fi
 326
 327 CFLAGS=""
 328 CXXFLAGS=""
 329 LDFLAGS=""
 330
 331 # LLVM uses C++11 starting in llvm 3.5. On Linux, this means libstdc++4.7+ is
 332 # needed, on OS X it requires libc++. clang only automatically links to libc++
 333 # when targeting OS X 10.9+, so add stdlib=libc++ explicitly so clang can run on
 334 # OS X versions as old as 10.7.
 335 # TODO(thakis): Some bots are still on 10.6, so for now bundle libc++.dylib.
 336 # Remove this once all bots are on 10.7+, then use --enable-libcpp=yes and
 337 # change deployment_target to 10.7.
 338 deployment_target=""
 339
 340 if [ "${OS}" = "Darwin" ]; then
 341   # When building on 10.9, /usr/include usually doesn't exist, and while
 342   # Xcode's clang automatically sets a sysroot, self-built clangs don't.
 343   CFLAGS="-isysroot $(xcrun --show-sdk-path)"
 344   CPPFLAGS="${CFLAGS}"
 345   CXXFLAGS="-stdlib=libc++ -nostdinc++ -I${ABS_LIBCXX_DIR}/include ${CFLAGS}"
 346
 347   if [[ -n "${bootstrap}" ]]; then
 348     deployment_target=10.6
 349   fi
 350 fi
 351
 352 # Build bootstrap clang if requested.
 353 if [[ -n "${bootstrap}" ]]; then
 354   ABS_INSTALL_DIR="${PWD}/${LLVM_BOOTSTRAP_INSTALL_DIR}"
 355   echo "Building bootstrap compiler"
 356   mkdir -p "${LLVM_BOOTSTRAP_DIR}"
 357   pushd "${LLVM_BOOTSTRAP_DIR}"
 358
 359   cmake -GNinja \
 360       -DCMAKE_BUILD_TYPE=Release \
 361       -DLLVM_ENABLE_ASSERTIONS=ON \
 362       -DLLVM_TARGETS_TO_BUILD=host \
 363       -DLLVM_ENABLE_THREADS=OFF \
 364       -DCMAKE_INSTALL_PREFIX="${ABS_INSTALL_DIR}" \
 365       -DCMAKE_C_COMPILER="${CC}" \
 366       -DCMAKE_CXX_COMPILER="${CXX}" \
 367       -DCMAKE_C_FLAGS="${CFLAGS}" \
 368       -DCMAKE_CXX_FLAGS="${CXXFLAGS}" \
 369       ../llvm
 370
 371   ninja
 372   if [[ -n "${run_tests}" ]]; then
 373     ninja check-all
 374   fi
 375
 376   ninja install
 377   if [[ -n "${gcc_toolchain}" ]]; then
 378     # Copy that gcc's stdlibc++.so.6 to the build dir, so the bootstrap
 379     # compiler can start.
 380     cp -v "$(${CXX} -print-file-name=libstdc++.so.6)" \
 381       "${ABS_INSTALL_DIR}/lib/"
 382   fi
 383
 384   popd
 385   CC="${ABS_INSTALL_DIR}/bin/clang"
 386   CXX="${ABS_INSTALL_DIR}/bin/clang++"
 387
 388   if [[ -n "${gcc_toolchain}" ]]; then
 389     # Tell the bootstrap compiler to use a specific gcc prefix to search
 390     # for standard library headers and shared object file.
 391     CFLAGS="--gcc-toolchain=${gcc_toolchain}"
 392     CXXFLAGS="--gcc-toolchain=${gcc_toolchain}"
 393   fi
 394
 395   echo "Building final compiler"
 396 fi
 397
 398 # Build clang (in a separate directory).
 399 # The clang bots have this path hardcoded in built/scripts/slave/compile.py,
 400 # so if you change it you also need to change these links.
 401 mkdir -p "${LLVM_BUILD_DIR}"
 402 pushd "${LLVM_BUILD_DIR}"
 403
 404 # Build libc++.dylib while some bots are still on OS X 10.6.
 405 if [ "${OS}" = "Darwin" ]; then
 406   rm -rf libcxxbuild
 407   LIBCXXFLAGS="-O3 -std=c++11 -fstrict-aliasing"
 408
 409   # libcxx and libcxxabi both have a file stdexcept.cpp, so put their .o files
 410   # into different subdirectories.
 411   mkdir -p libcxxbuild/libcxx
 412   pushd libcxxbuild/libcxx
 413   ${CXX:-c++} -c ${CXXFLAGS} ${LIBCXXFLAGS} "${ABS_LIBCXX_DIR}"/src/*.cpp
 414   popd
 415
 416   mkdir -p libcxxbuild/libcxxabi
 417   pushd libcxxbuild/libcxxabi
 418   ${CXX:-c++} -c ${CXXFLAGS} ${LIBCXXFLAGS} "${ABS_LIBCXXABI_DIR}"/src/*.cpp -I"${ABS_LIBCXXABI_DIR}/include"
 419   popd
 420
 421   pushd libcxxbuild
 422   ${CC:-cc} libcxx/*.o libcxxabi/*.o -o libc++.1.dylib -dynamiclib \
 423     -nodefaultlibs -current_version 1 -compatibility_version 1 \
 424     -lSystem -install_name @executable_path/libc++.dylib \
 425     -Wl,-unexported_symbols_list,${ABS_LIBCXX_DIR}/lib/libc++unexp.exp \
 426     -Wl,-force_symbols_not_weak_list,${ABS_LIBCXX_DIR}/lib/notweak.exp \
 427     -Wl,-force_symbols_weak_list,${ABS_LIBCXX_DIR}/lib/weak.exp
 428   ln -sf libc++.1.dylib libc++.dylib
 429   popd
 430   LDFLAGS+="-stdlib=libc++ -L${PWD}/libcxxbuild"
 431 fi
 432
 433 rm -fv CMakeCache.txt
 434 MACOSX_DEPLOYMENT_TARGET=${deployment_target} cmake -GNinja \
 435     -DCMAKE_BUILD_TYPE=Release \
 436     -DLLVM_ENABLE_ASSERTIONS=ON \
 437     -DLLVM_ENABLE_THREADS=OFF \
 438     -DCMAKE_C_COMPILER="${CC}" \
 439     -DCMAKE_CXX_COMPILER="${CXX}" \
 440     -DCMAKE_C_FLAGS="${CFLAGS}" \
 441     -DCMAKE_CXX_FLAGS="${CXXFLAGS}" \
 442     -DCMAKE_EXE_LINKER_FLAGS="${LDFLAGS}" \
 443     -DCMAKE_SHARED_LINKER_FLAGS="${LDFLAGS}" \
 444     -DCMAKE_MODULE_LINKER_FLAGS="${LDFLAGS}" \
 445     "${ABS_LLVM_DIR}"
 446 env
 447
 448 if [[ -n "${gcc_toolchain}" ]]; then
 449   # Copy in the right stdlibc++.so.6 so clang can start.
 450   mkdir -p lib
 451   cp -v "$(${CXX} ${CXXFLAGS} -print-file-name=libstdc++.so.6)" lib/
 452 fi
 453
 454 ninja
 455
 456 STRIP_FLAGS=
 457 if [ "${OS}" = "Darwin" ]; then
 458   # See http://crbug.com/256342
 459   STRIP_FLAGS=-x
 460
 461   cp libcxxbuild/libc++.1.dylib bin/
 462 fi
 463 strip ${STRIP_FLAGS} bin/clang
 464 popd
 465
 466 # Build compiler-rt out-of-tree.
 467 mkdir -p "${COMPILER_RT_BUILD_DIR}"
 468 pushd "${COMPILER_RT_BUILD_DIR}"
 469
 470 rm -fv CMakeCache.txt
 471 MACOSX_DEPLOYMENT_TARGET=${deployment_target} cmake -GNinja \
 472     -DCMAKE_BUILD_TYPE=Release \
 473     -DLLVM_ENABLE_ASSERTIONS=ON \
 474     -DLLVM_ENABLE_THREADS=OFF \
 475     -DCMAKE_C_COMPILER="${CC}" \
 476     -DCMAKE_CXX_COMPILER="${CXX}" \
 477     -DLLVM_CONFIG_PATH="${ABS_LLVM_BUILD_DIR}/bin/llvm-config" \
 478     "${ABS_COMPILER_RT_DIR}"
 479
 480 ninja
 481
 482 # Copy selected output to the main tree.
 483 # Darwin doesn't support cp --parents, so pipe through tar instead.
 484 CLANG_VERSION=$("${ABS_LLVM_BUILD_DIR}/bin/clang" --version | \
 485      sed -ne 's/clang version \([0-9]\.[0-9]\.[0-9]\).*/\1/p')
 486 ABS_LLVM_CLANG_LIB_DIR="${ABS_LLVM_BUILD_DIR}/lib/clang/${CLANG_VERSION}"
 487 tar -c *blacklist.txt | tar -C ${ABS_LLVM_CLANG_LIB_DIR} -xv
 488 tar -c include/sanitizer | tar -C ${ABS_LLVM_CLANG_LIB_DIR} -xv
 489 if [[ "${OS}" = "Darwin" ]]; then
 490   tar -c lib/darwin | tar -C ${ABS_LLVM_CLANG_LIB_DIR} -xv
 491 else
 492   tar -c lib/linux | tar -C ${ABS_LLVM_CLANG_LIB_DIR} -xv
 493 fi
 494
 495 popd
 496
 497 if [[ -n "${with_android}" ]]; then
 498   # Make a standalone Android toolchain.
 499   ${ANDROID_NDK_DIR}/build/tools/make-standalone-toolchain.sh \
 500       --platform=android-14 \
 501       --install-dir="${LLVM_BUILD_DIR}/android-toolchain" \
 502       --system=linux-x86_64 \
 503       --stl=stlport
 504
 505   # Android NDK r9d copies a broken unwind.h into the toolchain, see
 506   # http://crbug.com/357890
 507   rm -v "${LLVM_BUILD_DIR}"/android-toolchain/include/c++/*/unwind.h
 508
 509   # Build ASan runtime for Android in a separate build tree.
 510   mkdir -p ${LLVM_BUILD_DIR}/android
 511   pushd ${LLVM_BUILD_DIR}/android
 512   rm -fv CMakeCache.txt
 513   MACOSX_DEPLOYMENT_TARGET=${deployment_target} cmake -GNinja \
 514       -DCMAKE_BUILD_TYPE=Release \
 515       -DLLVM_ENABLE_ASSERTIONS=ON \
 516       -DLLVM_ENABLE_THREADS=OFF \
 517       -DCMAKE_C_COMPILER=${PWD}/../bin/clang \
 518       -DCMAKE_CXX_COMPILER=${PWD}/../bin/clang++ \
 519       -DLLVM_CONFIG_PATH=${PWD}/../bin/llvm-config \
 520       -DCMAKE_C_FLAGS="--target=arm-linux-androideabi --sysroot=${PWD}/../android-toolchain/sysroot -B${PWD}/../android-toolchain" \
 521       -DCMAKE_CXX_FLAGS="--target=arm-linux-androideabi --sysroot=${PWD}/../android-toolchain/sysroot -B${PWD}/../android-toolchain" \
 522       -DANDROID=1 \
 523       "${ABS_COMPILER_RT_DIR}"
 524   ninja clang_rt.asan-arm-android
 525
 526   # And copy it into the main build tree.
 527   cp "$(find -name libclang_rt.asan-arm-android.so)" "${ABS_LLVM_CLANG_LIB_DIR}/lib/linux/"
 528   popd
 529 fi
 530
 531 # Build Chrome-specific clang tools. Paths in this list should be relative to
 532 # tools/clang.
 533 TOOL_SRC_DIR="${PWD}/${THIS_DIR}/../"
 534 TOOL_BUILD_DIR="${ABS_LLVM_BUILD_DIR}/tools/clang/tools/chrome-extras"
 535
 536 rm -rf "${TOOL_BUILD_DIR}"
 537 mkdir -p "${TOOL_BUILD_DIR}"
 538 pushd "${TOOL_BUILD_DIR}"
 539 rm -fv CMakeCache.txt
 540 MACOSX_DEPLOYMENT_TARGET=${deployment_target} cmake -GNinja  \
 541     -DLLVM_BUILD_DIR="${ABS_LLVM_BUILD_DIR}" \
 542     -DLLVM_SRC_DIR="${ABS_LLVM_DIR}" \
 543     -DCMAKE_C_COMPILER="${CC}" \
 544     -DCMAKE_CXX_COMPILER="${CXX}" \
 545     -DCMAKE_C_FLAGS="${CFLAGS}" \
 546     -DCMAKE_CXX_FLAGS="${CXXFLAGS}" \
 547     -DCMAKE_EXE_LINKER_FLAGS="${LDFLAGS}" \
 548     -DCMAKE_SHARED_LINKER_FLAGS="${LDFLAGS}" \
 549     -DCMAKE_MODULE_LINKER_FLAGS="${LDFLAGS}" \
 550     -DCMAKE_INSTALL_PREFIX="${ABS_LLVM_BUILD_DIR}" \
 551     -DCHROMIUM_TOOLS="${chrome_tools}" \
 552     "${TOOL_SRC_DIR}"
 553 popd
 554 ninja -C "${TOOL_BUILD_DIR}" install
 555
 556 if [[ -n "$run_tests" ]]; then
 557   # Run Chrome tool tests.
 558   ninja -C "${TOOL_BUILD_DIR}" check-all
 559   # Run the LLVM and Clang tests.
 560   ninja -C "${LLVM_BUILD_DIR}" check-all
 561 fi
 562
 563 # After everything is done, log success for this revision.
 564 echo "${CLANG_AND_PLUGINS_REVISION}" > "${STAMP_FILE}"