Update monet.

tools/clang/scripts/update.sh

 #!/usr/bin/env bash
 # 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 will check out llvm and clang into third_party/llvm and build it.
 
 # Do NOT CHANGE this if you don't know what you're doing -- see
 # https://code.google.com/p/chromium/wiki/UpdatingClang
 # Reverting problematic clang rolls is safe, though.
-CLANG_REVISION=238013
+CLANG_REVISION=259396
 
 # This is incremented when pushing a new build of Clang at the same revision.
-CLANG_SUB_REVISION=3
+CLANG_SUB_REVISION=1
 
 PACKAGE_VERSION="${CLANG_REVISION}-${CLANG_SUB_REVISION}"
 
 THIS_DIR="$(dirname "${0}")"
 LLVM_DIR="${THIS_DIR}/../../../third_party/llvm"
 LLVM_BUILD_DIR="${LLVM_DIR}/../llvm-build/Release+Asserts"
 COMPILER_RT_BUILD_DIR="${LLVM_DIR}/../llvm-build/compiler-rt"
 LLVM_BOOTSTRAP_DIR="${LLVM_DIR}/../llvm-bootstrap"
 LLVM_BOOTSTRAP_INSTALL_DIR="${LLVM_DIR}/../llvm-bootstrap-install"
 CLANG_DIR="${LLVM_DIR}/tools/clang"
@@ skipping 17 matching lines @@
 LLVM_REPO_URL=${LLVM_URL:-https://llvm.org/svn/llvm-project}
 
 CDS_URL=https://commondatastorage.googleapis.com/chromium-browser-clang
 
 if [[ -z "$GYP_DEFINES" ]]; then
   GYP_DEFINES=
 fi
 if [[ -z "$GYP_GENERATORS" ]]; then
   GYP_GENERATORS=
 fi
+if [[ -z "$LLVM_DOWNLOAD_GOLD_PLUGIN" ]]; then
+  LLVM_DOWNLOAD_GOLD_PLUGIN=
+fi
 
+if [[ "${OS}" == "Linux" ]] && \
+   [[ "$GYP_DEFINES" =~ .*buildtype=Official.* ]] && \
+   [[ "$GYP_DEFINES" =~ .*branding=Chrome.* ]] ; then
+  # LLVM Gold plugin is required to build with this configuration.
+  LLVM_DOWNLOAD_GOLD_PLUGIN=1
+fi
 
 # Die if any command dies, error on undefined variable expansions.
 set -eu
 
 
 if [[ -n ${LLVM_FORCE_HEAD_REVISION:-''} ]]; then
   # Use a real revision number rather than HEAD to make sure that the stamp file
   # logic works.
   CLANG_REVISION=$(svn info "$LLVM_REPO_URL" \
       | grep 'Revision:' | awk '{ printf $2; }')
@@ skipping 136 matching lines @@
       fi
       export PATH="${LLVM_BUILD_TOOLS_DIR}/cmake310/bin:${PATH}"
     fi
   fi
 
   echo "LLVM_FORCE_HEAD_REVISION was set; using r${CLANG_REVISION}"
 fi
 
 if [[ -n "$if_needed" ]]; then
   if [[ "${OS}" == "Darwin" ]]; then
-    # clang is used on Mac.
+    # clang is always used on Mac.
+    true
+  elif [[ "${OS}" == "Linux" ]]; then
+    # clang is also aways used on Linux.
     true
   elif [[ "$GYP_DEFINES" =~ .*(clang|tsan|asan|lsan|msan)=1.* ]]; then
     # clang requested via $GYP_DEFINES.
     true
   elif [[ -d "${LLVM_BUILD_DIR}" ]]; then
-    # clang previously downloaded, remove third_party/llvm-build to prevent
-    # updating.
-    true
-  elif [[ "${OS}" == "Linux" ]]; then
-    # Temporarily use clang on linux. Leave a stamp file behind, so that
-    # this script can remove clang again on machines where it was autoinstalled.
-    mkdir -p "${LLVM_BUILD_DIR}"
-    touch "${LLVM_BUILD_DIR}/autoinstall_stamp"
+    # clang previously downloaded, keep it up-to-date.
+    # If you don't want this, delete third_party/llvm-build on your machine.
     true
   else
     # clang wasn't needed, not doing anything.
     exit 0
   fi
 fi
 
 
 # Check if there's anything to be done, exit early if not.
 if [[ -f "${STAMP_FILE}" ]]; then
   PREVIOUSLY_BUILT_REVISON=$(cat "${STAMP_FILE}")
   if [[ -z "$force_local_build" ]] && \
        [[ "${PREVIOUSLY_BUILT_REVISON}" = \
           "${PACKAGE_VERSION}" ]]; then
     echo "Clang already at ${PACKAGE_VERSION}"
-    exit 0
+    if [[ -z "${LLVM_DOWNLOAD_GOLD_PLUGIN}" ]] || \
+       [[ -f "${LLVM_BUILD_DIR}/lib/LLVMgold.so" ]]; then
+      exit 0
+    fi
   fi
 fi
 # To always force a new build if someone interrupts their build half way.
 rm -f "${STAMP_FILE}"
 
 
 if [[ -z "$force_local_build" ]]; then
   # Check if there's a prebuilt binary and if so just fetch that. That's faster,
   # and goma relies on having matching binary hashes on client and server too.
   CDS_FILE="clang-${PACKAGE_VERSION}.tgz"
@@ skipping 14 matching lines @@
     echo "Neither curl nor wget found. Please install one of these."
     exit 1
   fi
   if [ -f "${CDS_OUTPUT}" ]; then
     rm -rf "${LLVM_BUILD_DIR}"
     mkdir -p "${LLVM_BUILD_DIR}"
     tar -xzf "${CDS_OUTPUT}" -C "${LLVM_BUILD_DIR}"
     echo clang "${PACKAGE_VERSION}" unpacked
     echo "${PACKAGE_VERSION}" > "${STAMP_FILE}"
     rm -rf "${CDS_OUT_DIR}"
+    # Download the gold plugin if requested to by an environment variable.
+    # This is used by the CFI ClusterFuzz bot.
+    if [[ -n "${LLVM_DOWNLOAD_GOLD_PLUGIN}" ]]; then
+      ${THIS_DIR}/../../../build/download_gold_plugin.py
+    fi
     exit 0
   else
     echo Did not find prebuilt clang "${PACKAGE_VERSION}", building
   fi
 fi
 
 if [[ -n "${with_android}" ]] && ! [[ -d "${ANDROID_NDK_DIR}" ]]; then
   echo "Android NDK not found at ${ANDROID_NDK_DIR}"
   echo "The Android NDK is needed to build a Clang whose -fsanitize=address"
   echo "works on Android. See "
@@ skipping 29 matching lines @@
       "${LLVM_DIR}/test/Bindings/Go/go.test" \
       "${CLANG_DIR}/lib/Parse/ParseExpr.cpp" \
       "${CLANG_DIR}/lib/Parse/ParseTemplate.cpp" \
       "${CLANG_DIR}/lib/Sema/SemaDeclCXX.cpp" \
       "${CLANG_DIR}/lib/Sema/SemaExprCXX.cpp" \
       "${CLANG_DIR}/test/SemaCXX/default2.cpp" \
       "${CLANG_DIR}/test/SemaCXX/typo-correction-delayed.cpp" \
       "${COMPILER_RT_DIR}/lib/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc" \
       "${COMPILER_RT_DIR}/test/tsan/signal_segv_handler.cc" \
       "${COMPILER_RT_DIR}/lib/sanitizer_common/sanitizer_coverage_libcdep.cc" \
+      "${COMPILER_RT_DIR}/cmake/config-ix.cmake" \
+      "${COMPILER_RT_DIR}/CMakeLists.txt" \
+      "${COMPILER_RT_DIR}/lib/ubsan/ubsan_platform.h" \
       ; do
   if [[ -e "${i}" ]]; then
     rm -f "${i}"  # For unversioned files.
     svn revert "${i}"
   fi;
 done
 
 echo Remove the Clang tools shim dir
 CHROME_TOOLS_SHIM_DIR=${ABS_LLVM_DIR}/tools/chrometools
 rm -rfv ${CHROME_TOOLS_SHIM_DIR}
@@ skipping 27 matching lines @@
 
 # While we're bundling our own libc++ on OS X, we need to compile libc++abi
 # into it too (since OS X 10.6 doesn't have libc++abi.dylib either).
 if [ "${OS}" = "Darwin" ]; then
   echo Getting libc++abi r"${CLANG_REVISION}" in "${LIBCXXABI_DIR}"
   svn co --force "${LLVM_REPO_URL}/libcxxabi/trunk@${CLANG_REVISION}" \
                  "${LIBCXXABI_DIR}"
 fi
 
 if [[ -n "$with_patches" ]]; then
-
-  # Apply patch for tests failing with --disable-pthreads (llvm.org/PR11974)
-  pushd "${CLANG_DIR}"
-  cat << 'EOF' |
---- third_party/llvm/tools/clang/test/Index/crash-recovery-modules.m    (revision 202554)
-+++ third_party/llvm/tools/clang/test/Index/crash-recovery-modules.m    (working copy)
-@@ -12,6 +12,8 @@
- 
- // REQUIRES: crash-recovery
- // REQUIRES: shell
-+// XFAIL: *
-+//    (PR11974)
- 
- @import Crash;
-EOF
-patch -p4
-popd
-
-pushd "${CLANG_DIR}"
-cat << 'EOF' |
---- unittests/libclang/LibclangTest.cpp (revision 215949)
-+++ unittests/libclang/LibclangTest.cpp (working copy)
-@@ -431,7 +431,7 @@
-   EXPECT_EQ(0U, clang_getNumDiagnostics(ClangTU));
- }
-
--TEST_F(LibclangReparseTest, ReparseWithModule) {
-+TEST_F(LibclangReparseTest, DISABLED_ReparseWithModule) {
-   const char *HeaderTop = "#ifndef H\n#define H\nstruct Foo { int bar;";
-   const char *HeaderBottom = "\n};\n#endif\n";
-   const char *MFile = "#include \"HeaderFile.h\"\nint main() {"
-EOF
-  patch -p0
-  popd
-
-  # Cherry-pick r234010 [sancov] Shrink pc array on Android back to 2**24."
-  pushd "${COMPILER_RT_DIR}"
-  cat << 'EOF' |
-diff --git a/lib/sanitizer_common/sanitizer_coverage_libcdep.cc b/lib/sanitizer_common/sanitizer_coverage_libcdep.cc
-index 4b976fc..cfd9e7e 100644
---- a/lib/sanitizer_common/sanitizer_coverage_libcdep.cc
-+++ b/lib/sanitizer_common/sanitizer_coverage_libcdep.cc
-@@ -109,7 +109,8 @@ class CoverageData {
- 
-   // Maximal size pc array may ever grow.
-   // We MmapNoReserve this space to ensure that the array is contiguous.
--  static const uptr kPcArrayMaxSize = FIRST_32_SECOND_64(1 << 26, 1 << 27);
-+  static const uptr kPcArrayMaxSize =
-+      FIRST_32_SECOND_64(1 << (SANITIZER_ANDROID ? 24 : 26), 1 << 27);
-   // The amount file mapping for the pc array is grown by.
-   static const uptr kPcArrayMmapSize = 64 * 1024;
-
-EOF
-  patch -p1
-  popd
-
-  # This Go bindings test doesn't work after the bootstrap build on Linux. (PR21552)
-  pushd "${LLVM_DIR}"
-  cat << 'EOF' |
-Index: test/Bindings/Go/go.test
-===================================================================
---- test/Bindings/Go/go.test    (revision 223109)
-+++ test/Bindings/Go/go.test    (working copy)
-@@ -1,3 +1,3 @@
--; RUN: llvm-go test llvm.org/llvm/bindings/go/llvm
-+; RUN: true
- 
- ; REQUIRES: shell
-EOF
-  patch -p0
-  popd
-
-
+  # No patches.
+  true
 fi
 
 # Echo all commands.
 set -x
 
 # Set default values for CC and CXX if they're not set in the environment.
 CC=${CC:-cc}
 CXX=${CXX:-c++}
 
 if [[ -n "${gcc_toolchain}" ]]; then
   # Use the specified gcc installation for building.
   CC="$gcc_toolchain/bin/gcc"
   CXX="$gcc_toolchain/bin/g++"
   # Set LD_LIBRARY_PATH to make auxiliary targets (tablegen, bootstrap compiler,
   # etc.) find the .so.
   export LD_LIBRARY_PATH="$(dirname $(${CXX} -print-file-name=libstdc++.so.6))"
 fi
 
 CFLAGS=""
 CXXFLAGS=""
 LDFLAGS=""
 
 # LLVM uses C++11 starting in llvm 3.5. On Linux, this means libstdc++4.7+ is
 # needed, on OS X it requires libc++. clang only automatically links to libc++
 # when targeting OS X 10.9+, so add stdlib=libc++ explicitly so clang can run on
 # OS X versions as old as 10.7.
-# TODO(thakis): Some bots are still on 10.6, so for now bundle libc++.dylib.
-# Remove this once all bots are on 10.7+, then use --enable-libcpp=yes and
-# change deployment_target to 10.7.
+# TODO(thakis): Some bots are still on 10.6 (nacl...), so for now bundle
+# libc++.dylib.  Remove this once all bots are on 10.7+, then use
+# -DLLVM_ENABLE_LIBCXX=ON and change deployment_target to 10.7.
 deployment_target=""
 
 if [ "${OS}" = "Darwin" ]; then
   # When building on 10.9, /usr/include usually doesn't exist, and while
   # Xcode's clang automatically sets a sysroot, self-built clangs don't.
   CFLAGS="-isysroot $(xcrun --show-sdk-path)"
-  CPPFLAGS="${CFLAGS}"
   CXXFLAGS="-stdlib=libc++ -nostdinc++ -I${ABS_LIBCXX_DIR}/include ${CFLAGS}"
 
   if [[ -n "${bootstrap}" ]]; then
     deployment_target=10.6
   fi
 fi
 
 # Build bootstrap clang if requested.
 if [[ -n "${bootstrap}" ]]; then
   ABS_INSTALL_DIR="${PWD}/${LLVM_BOOTSTRAP_INSTALL_DIR}"
@@ skipping 25 matching lines @@
     cp -v "$(${CXX} -print-file-name=libstdc++.so.6)" \
       "${ABS_INSTALL_DIR}/lib/"
   fi
 
   popd
   CC="${ABS_INSTALL_DIR}/bin/clang"
   CXX="${ABS_INSTALL_DIR}/bin/clang++"
 
   if [[ -n "${gcc_toolchain}" ]]; then
     # Tell the bootstrap compiler to use a specific gcc prefix to search
-    # for standard library headers and shared object file.
+    # for standard library headers and shared object files.
     CFLAGS="--gcc-toolchain=${gcc_toolchain}"
     CXXFLAGS="--gcc-toolchain=${gcc_toolchain}"
   fi
 
   echo "Building final compiler"
 fi
 
 # Build clang (in a separate directory).
 # The clang bots have this path hardcoded in built/scripts/slave/compile.py,
 # so if you change it you also need to change these links.
@@ skipping 20 matching lines @@
   pushd libcxxbuild
   ${CC:-cc} libcxx/*.o libcxxabi/*.o -o libc++.1.dylib -dynamiclib \
     -nodefaultlibs -current_version 1 -compatibility_version 1 \
     -lSystem -install_name @executable_path/libc++.dylib \
     -Wl,-unexported_symbols_list,${ABS_LIBCXX_DIR}/lib/libc++unexp.exp \
     -Wl,-force_symbols_not_weak_list,${ABS_LIBCXX_DIR}/lib/notweak.exp \
     -Wl,-force_symbols_weak_list,${ABS_LIBCXX_DIR}/lib/weak.exp
   ln -sf libc++.1.dylib libc++.dylib
   popd
   LDFLAGS+="-stdlib=libc++ -L${PWD}/libcxxbuild"
+
+  if [[ -n "${bootstrap}" ]]; then
+    # Now that the libc++ headers have been installed and libc++.dylib is built,
+    # delete the libc++ checkout again so that it's not part of the main
+    # build below -- the libc++(abi) tests don't pass on OS X in bootstrap
+    # builds (http://llvm.org/PR24068)
+    rm -rf "${ABS_LIBCXX_DIR}"
+    rm -rf "${ABS_LIBCXXABI_DIR}"
+    CXXFLAGS="-stdlib=libc++ -nostdinc++ -I${ABS_INSTALL_DIR}/include/c++/v1 ${CFLAGS}"
+  fi
 fi
 
 # Find the binutils include dir for the gold plugin.
 BINUTILS_INCDIR=""
 if [ "${OS}" = "Linux" ]; then
   BINUTILS_INCDIR="${ABS_BINUTILS_DIR}/Linux_x64/Release/include"
 fi
 
 
 # If building at head, define a macro that plugins can use for #ifdefing
@@ skipping 15 matching lines @@
 # to specify where build artifacts go. CMake doesn't allow reusing the same
 # binary dir for multiple source dirs, so the build artifacts have to go into a
 # subdirectory...
 add_subdirectory(\${CHROMIUM_TOOLS_SRC} \${CMAKE_CURRENT_BINARY_DIR}/a)
 EOF
 rm -fv CMakeCache.txt
 MACOSX_DEPLOYMENT_TARGET=${deployment_target} cmake -GNinja \
     -DCMAKE_BUILD_TYPE=Release \
     -DLLVM_ENABLE_ASSERTIONS=ON \
     -DLLVM_ENABLE_THREADS=OFF \
+    -DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=WebAssembly \
     -DLLVM_BINUTILS_INCDIR="${BINUTILS_INCDIR}" \
     -DCMAKE_C_COMPILER="${CC}" \
     -DCMAKE_CXX_COMPILER="${CXX}" \
     -DCMAKE_C_FLAGS="${CFLAGS}" \
     -DCMAKE_CXX_FLAGS="${CXXFLAGS}" \
     -DCMAKE_EXE_LINKER_FLAGS="${LDFLAGS}" \
     -DCMAKE_SHARED_LINKER_FLAGS="${LDFLAGS}" \
     -DCMAKE_MODULE_LINKER_FLAGS="${LDFLAGS}" \
     -DCMAKE_INSTALL_PREFIX="${ABS_LLVM_BUILD_DIR}" \
     -DCHROMIUM_TOOLS_SRC="${ABS_CHROMIUM_TOOLS_DIR}" \
@@ skipping 17 matching lines @@
 if [ "${OS}" = "Darwin" ]; then
   # See http://crbug.com/256342
   STRIP_FLAGS=-x
 
   cp libcxxbuild/libc++.1.dylib bin/
 fi
 strip ${STRIP_FLAGS} bin/clang
 popd
 
 # Build compiler-rt out-of-tree.
+# Do a clobbered build due to cmake changes.
+rm -rf "${COMPILER_RT_BUILD_DIR}"
 mkdir -p "${COMPILER_RT_BUILD_DIR}"
 pushd "${COMPILER_RT_BUILD_DIR}"
 
 rm -fv CMakeCache.txt
-MACOSX_DEPLOYMENT_TARGET=${deployment_target} cmake -GNinja \
+MACOSX_DEPLOYMENT_TARGET=${deployment_target} CC="" CXX="" cmake -GNinja \
     -DCMAKE_BUILD_TYPE=Release \
     -DLLVM_ENABLE_ASSERTIONS=ON \
     -DLLVM_ENABLE_THREADS=OFF \
-    -DCMAKE_C_COMPILER="${CC}" \
-    -DCMAKE_CXX_COMPILER="${CXX}" \
+    -DCMAKE_C_COMPILER="${ABS_LLVM_BUILD_DIR}/bin/clang" \
+    -DCMAKE_CXX_COMPILER="${ABS_LLVM_BUILD_DIR}/bin/clang++" \
+    -DSANITIZER_MIN_OSX_VERSION="10.7" \
     -DLLVM_CONFIG_PATH="${ABS_LLVM_BUILD_DIR}/bin/llvm-config" \
     "${ABS_COMPILER_RT_DIR}"
 
 ninja
 
 # Copy selected output to the main tree.
 # Darwin doesn't support cp --parents, so pipe through tar instead.
 CLANG_VERSION=$("${ABS_LLVM_BUILD_DIR}/bin/clang" --version | \
      sed -ne 's/clang version \([0-9]\.[0-9]\.[0-9]\).*/\1/p')
 ABS_LLVM_CLANG_LIB_DIR="${ABS_LLVM_BUILD_DIR}/lib/clang/${CLANG_VERSION}"
 tar -c *blacklist.txt | tar -C ${ABS_LLVM_CLANG_LIB_DIR} -xv
 tar -c include/sanitizer | tar -C ${ABS_LLVM_CLANG_LIB_DIR} -xv
 if [[ "${OS}" = "Darwin" ]]; then
   tar -c lib/darwin | tar -C ${ABS_LLVM_CLANG_LIB_DIR} -xv
 else
   tar -c lib/linux | tar -C ${ABS_LLVM_CLANG_LIB_DIR} -xv
 fi
 
 popd
 
 if [[ -n "${with_android}" ]]; then
   # Make a standalone Android toolchain.
   ${ANDROID_NDK_DIR}/build/tools/make-standalone-toolchain.sh \
-      --platform=android-14 \
-      --install-dir="${LLVM_BUILD_DIR}/android-toolchain" \
+      --platform=android-19 \
+      --install-dir="${LLVM_BUILD_DIR}/android-toolchain-arm" \
       --system=linux-x86_64 \
-      --stl=libcxx \
+      --stl=stlport \
       --toolchain=arm-linux-androideabi-4.9
 
-  # Android NDK r9d copies a broken unwind.h into the toolchain, see
-  # http://crbug.com/357890
-  rm -v "${LLVM_BUILD_DIR}"/android-toolchain/include/c++/*/unwind.h
+  # Do the same for x86.
+  ${ANDROID_NDK_DIR}/build/tools/make-standalone-toolchain.sh \
+      --platform=android-19 \
+      --install-dir="${LLVM_BUILD_DIR}/android-toolchain-i686" \
+      --system=linux-x86_64 \
+      --stl=stlport \
+      --toolchain=x86-4.9
 
-  # Build ASan runtime for Android in a separate build tree.
-  mkdir -p ${LLVM_BUILD_DIR}/android
-  pushd ${LLVM_BUILD_DIR}/android
-  rm -fv CMakeCache.txt
-  MACOSX_DEPLOYMENT_TARGET=${deployment_target} cmake -GNinja \
-      -DCMAKE_BUILD_TYPE=Release \
-      -DLLVM_ENABLE_ASSERTIONS=ON \
-      -DLLVM_ENABLE_THREADS=OFF \
-      -DCMAKE_C_COMPILER=${PWD}/../bin/clang \
-      -DCMAKE_CXX_COMPILER=${PWD}/../bin/clang++ \
-      -DLLVM_CONFIG_PATH=${PWD}/../bin/llvm-config \
-      -DCMAKE_C_FLAGS="--target=arm-linux-androideabi --sysroot=${PWD}/../android-toolchain/sysroot -B${PWD}/../android-toolchain" \
-      -DCMAKE_CXX_FLAGS="--target=arm-linux-androideabi --sysroot=${PWD}/../android-toolchain/sysroot -B${PWD}/../android-toolchain" \
-      -DANDROID=1 \
-      "${ABS_COMPILER_RT_DIR}"
-  ninja libclang_rt.asan-arm-android.so
+  for target_arch in "arm" "i686"; do
+    # Android NDK r9d copies a broken unwind.h into the toolchain, see
+    # http://crbug.com/357890
+    rm -v "${LLVM_BUILD_DIR}"/android-toolchain-${target_arch}/include/c++/*/unwind.h
 
-  # And copy it into the main build tree.
-  cp "$(find -name libclang_rt.asan-arm-android.so)" "${ABS_LLVM_CLANG_LIB_DIR}/lib/linux/"
-  popd
+    # Build ASan runtime for Android in a separate build tree.
+    mkdir -p ${LLVM_BUILD_DIR}/android-${target_arch}
+    pushd ${LLVM_BUILD_DIR}/android-${target_arch}
+    rm -fv CMakeCache.txt
+    MACOSX_DEPLOYMENT_TARGET=${deployment_target} cmake -GNinja \
+        -DCMAKE_BUILD_TYPE=Release \
+        -DLLVM_ENABLE_ASSERTIONS=ON \
+        -DLLVM_ENABLE_THREADS=OFF \
+        -DCMAKE_C_COMPILER=${PWD}/../bin/clang \
+        -DCMAKE_CXX_COMPILER=${PWD}/../bin/clang++ \
+        -DLLVM_CONFIG_PATH=${PWD}/../bin/llvm-config \
+        -DCMAKE_C_FLAGS="--target=${target_arch}-linux-androideabi --sysroot=${PWD}/../android-toolchain-${target_arch}/sysroot -B${PWD}/../android-toolchain-${target_arch}" \
+        -DCMAKE_CXX_FLAGS="--target=${target_arch}-linux-androideabi --sysroot=${PWD}/../android-toolchain-${target_arch}/sysroot -B${PWD}/../android-toolchain-${target_arch}" \
+        -DANDROID=1 \
+        "${ABS_COMPILER_RT_DIR}"
+    ninja libclang_rt.asan-${target_arch}-android.so
+
+    # And copy it into the main build tree.
+    cp "$(find -name libclang_rt.asan-${target_arch}-android.so)" "${ABS_LLVM_CLANG_LIB_DIR}/lib/linux/"
+    popd
+  done
 fi
 
-if [[ -n "$run_tests" ]]; then
+if [[ -n "$run_tests" || -n "${LLVM_FORCE_HEAD_REVISION:-''}" ]]; then
   # Run Chrome tool tests.
   ninja -C "${LLVM_BUILD_DIR}" cr-check-all
+fi
+if [[ -n "$run_tests" ]]; then
   # Run the LLVM and Clang tests.
   ninja -C "${LLVM_BUILD_DIR}" check-all
 fi
 
 # After everything is done, log success for this revision.
 echo "${PACKAGE_VERSION}" > "${STAMP_FILE}"