Thorium_Archive/thorium
1
0
Fork 0
Code Issues 207 Pull requests 3 Projects Releases 53 Packages Wiki Activity

Update build.py

Browse source
This commit is contained in:
Alexander David Frick 2022-08-03 06:04:18 -05:00 committed by GitHub
parent 48ec8f8e8b
commit 114cf8fe55
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1 changed files with 341 additions and 432 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

773
src/tools/clang/scripts/build.py
View file

@ -25,22 +25,24 @@ import subprocess
import sys
import tempfile
os.environ['NINJA_STATUS'] = "[%r processes, %f/%t @ %o/s | %e sec. ] "
from update import (CDS_URL, CHROMIUM_DIR, CLANG_REVISION, LLVM_BUILD_DIR,
FORCE_HEAD_REVISION_FILE, PACKAGE_VERSION, RELEASE_VERSION,
STAMP_FILE, DownloadUrl, DownloadAndUnpack, EnsureDirExists,
ReadStampFile, RmTree, WriteStampFile)
STAMP_FILE, THIS_DIR, DownloadUrl, DownloadAndUnpack,
EnsureDirExists, ReadStampFile, RmTree, WriteStampFile)
# Path constants. (All of these should be absolute paths.)
THIRD_PARTY_DIR = os.path.join(CHROMIUM_DIR, 'third_party')
LLVM_DIR = os.path.join(THIRD_PARTY_DIR, 'llvm')
COMPILER_RT_DIR = os.path.join(LLVM_DIR, 'compiler-rt')
LLVM_BUILD_TOOLS_DIR = os.path.abspath(
os.path.join(THIRD_PARTY_DIR, 'llvm-build-tools'))
LLVM_BOOTSTRAP_DIR = os.path.join(LLVM_BUILD_TOOLS_DIR, 'llvm-bootstrap')
LLVM_BOOTSTRAP_INSTALL_DIR = os.path.join(LLVM_BUILD_TOOLS_DIR,
LLVM_BOOTSTRAP_DIR = os.path.join(THIRD_PARTY_DIR, 'llvm-bootstrap')
LLVM_BOOTSTRAP_INSTALL_DIR = os.path.join(THIRD_PARTY_DIR,
'llvm-bootstrap-install')
LLVM_INSTRUMENTED_DIR = os.path.join(LLVM_BUILD_TOOLS_DIR, 'llvm-instrumented')
LLVM_INSTRUMENTED_DIR = os.path.join(THIRD_PARTY_DIR, 'llvm-instrumented')
LLVM_PROFDATA_FILE = os.path.join(LLVM_INSTRUMENTED_DIR, 'profdata.prof')
LLVM_BUILD_TOOLS_DIR = os.path.abspath(
os.path.join(LLVM_DIR, '..', 'llvm-build-tools'))
ANDROID_NDK_DIR = os.path.join(
CHROMIUM_DIR, 'third_party', 'android_ndk')
FUCHSIA_SDK_DIR = os.path.join(CHROMIUM_DIR, 'third_party', 'fuchsia-sdk',
@ -183,14 +185,6 @@ def GetCommitDescription(commit):
universal_newlines=True).rstrip()
def DeleteChromeToolsShim():
# TODO: These dirs are no longer used. Remove this code after a while.
OLD_SHIM_DIR = os.path.join(LLVM_DIR, 'tools', 'zzz-chrometools')
shutil.rmtree(OLD_SHIM_DIR, ignore_errors=True)
CHROME_TOOLS_SHIM_DIR = os.path.join(LLVM_DIR, 'llvm', 'tools', 'chrometools')
shutil.rmtree(CHROME_TOOLS_SHIM_DIR, ignore_errors=True)
def AddCMakeToPath(args):
"""Download CMake and add it to PATH."""
if args.use_system_cmake:
@ -302,6 +296,7 @@ def BuildLibXml2():
[
'cmake',
'-GNinja',
'-DCMAKE_VERBOSE_MAKEFILE=ON',
'-DCMAKE_BUILD_TYPE=Release',
'-DCMAKE_INSTALL_PREFIX=install',
# The mac_arm bot builds a clang arm binary, but currently on an intel
@ -392,16 +387,19 @@ def DownloadPinnedClang():
# The update.py in this current revision may have a patched revision while
# building new clang packages. Get update.py off HEAD~ to pull the current
# pinned clang.
with tempfile.NamedTemporaryFile() as f:
if not os.path.exists(PINNED_CLANG_DIR):
os.mkdir(os.path.join(PINNED_CLANG_DIR))
script_path = os.path.join(PINNED_CLANG_DIR, 'update.py')
with open(script_path, 'w') as f:
subprocess.check_call(
['git', 'show', 'HEAD~:tools/clang/scripts/update.py'],
stdout=f,
cwd=CHROMIUM_DIR)
print("Running update.py")
# Without the flush, the subprocess call below doesn't work.
f.flush()
subprocess.check_call(
[sys.executable, f.name, '--output-dir=' + PINNED_CLANG_DIR])
print("Running pinned update.py")
subprocess.check_call(
[sys.executable, script_path, '--output-dir=' + PINNED_CLANG_DIR])
# TODO(crbug.com/929645): Remove once we don't need gcc's libstdc++.
@ -410,9 +408,11 @@ def MaybeDownloadHostGcc(args):
assert sys.platform.startswith('linux')
if args.gcc_toolchain:
return
gcc_dir = os.path.join(LLVM_BUILD_TOOLS_DIR, 'gcc-10.2.0-trusty')
gcc_dir = os.path.join(LLVM_BUILD_TOOLS_DIR, 'gcc-10.2.0-bionic')
if os.path.isdir(gcc_dir):
RmTree(gcc_dir) # TODO(thakis): Remove this branch after a few weeks.
if not os.path.exists(gcc_dir):
DownloadAndUnpack(CDS_URL + '/tools/gcc-10.2.0-trusty.tgz', gcc_dir)
DownloadAndUnpack(CDS_URL + '/tools/gcc-10.2.0-bionic.tgz', gcc_dir)
args.gcc_toolchain = gcc_dir
@ -471,6 +471,28 @@ def CopyLibstdcpp(args, build_dir):
CopyFile(libstdcpp, os.path.join(build_dir, 'lib'))
def compiler_rt_cmake_flags(*, sanitizers, profile):
# Don't set -DCOMPILER_RT_BUILD_BUILTINS=ON/OFF as it interferes with the
# runtimes logic of building builtins.
args = [
# Build crtbegin/crtend. It's just two tiny TUs, so just enable this
# everywhere, even though we only need it on Linux.
'COMPILER_RT_BUILD_CRT=ON',
'COMPILER_RT_BUILD_LIBFUZZER=OFF',
'COMPILER_RT_BUILD_MEMPROF=OFF',
'COMPILER_RT_BUILD_ORC=OFF',
'COMPILER_RT_BUILD_PROFILE=' + ('ON' if profile else 'OFF'),
'COMPILER_RT_BUILD_SANITIZERS=' + ('ON' if sanitizers else 'OFF'),
'COMPILER_RT_BUILD_XRAY=OFF',
# See crbug.com/1205046: don't build scudo (and others we don't need).
'COMPILER_RT_SANITIZERS_TO_BUILD=asan;dfsan;msan;hwasan;tsan;cfi',
# We explicitly list all targets we want to build, do not autodetect
# targets.
'COMPILER_RT_DEFAULT_TARGET_ONLY=ON',
]
return args
def gn_arg(v):
if v == 'True':
return True
@ -488,6 +510,12 @@ def main():
help='Build arm binaries. Only valid on macOS.')
parser.add_argument('--disable-asserts', action='store_true',
help='build with asserts disabled')
parser.add_argument('--host-cc',
help='build with host C compiler, requires --host-cxx as '
'well')
parser.add_argument('--host-cxx',
help='build with host C++ compiler, requires --host-cc '
'as well')
parser.add_argument('--gcc-toolchain', help='what gcc toolchain to use for '
'building; --gcc-toolchain=/opt/foo picks '
'/opt/foo/bin/gcc')
@ -579,9 +607,6 @@ def main():
# move this down to where we fetch other build tools.
AddGnuWinToPath()
if sys.platform == 'darwin':
isysroot = subprocess.check_output(['xcrun', '--show-sdk-path'],
universal_newlines=True).rstrip()
if args.build_dir:
LLVM_BUILD_DIR = args.build_dir
@ -603,7 +628,6 @@ def main():
WriteStampFile('', FORCE_HEAD_REVISION_FILE)
AddCMakeToPath(args)
DeleteChromeToolsShim()
if args.skip_build:
@ -616,24 +640,22 @@ def main():
# LLVM_ENABLE_LLD).
cc, cxx, lld = None, None, None
cflags = []
cxxflags = []
ldflags = []
cflags = [ "-O3", ]
cxxflags = [ "-O3", ]
ldflags = [ "-Wl,-O3", ]
targets = 'AArch64;ARM;Mips;PowerPC;RISCV;SystemZ;WebAssembly;X86'
projects = 'clang;compiler-rt;lld;clang-tools-extra;polly'
if sys.platform == 'darwin':
# clang needs libc++, else -stdlib=libc++ won't find includes
# (this is needed for bootstrap builds and for building the fuchsia runtime)
projects += ';libcxx'
projects = 'clang;lld;clang-tools-extra;polly'
runtimes = 'compiler-rt'
base_cmake_args = [
'-GNinja',
'-DCMAKE_VERBOSE_MAKEFILE=ON',
'-DCMAKE_BUILD_TYPE=Release',
'-DLLVM_ENABLE_ASSERTIONS=%s' % ('OFF' if args.disable_asserts else 'ON'),
'-DLLVM_ENABLE_PROJECTS=' + projects,
'-DLLVM_ENABLE_RUNTIMES=' + runtimes,
'-DLLVM_TARGETS_TO_BUILD=' + targets,
# PIC needed for Rust build (links LLVM into shared object)
'-DLLVM_ENABLE_PIC=ON',
@ -646,12 +668,8 @@ def main():
'-DBUG_REPORT_URL=' + BUG_REPORT_URL,
# Don't run Go bindings tests; PGO makes them confused.
'-DLLVM_INCLUDE_GO_TESTS=OFF',
# TODO(crbug.com/1113475): Update binutils.
'-DENABLE_X86_RELAX_RELOCATIONS=NO',
# See crbug.com/1126219: Use native symbolizer instead of DIA
'-DLLVM_ENABLE_DIA_SDK=OFF',
# See crbug.com/1205046: don't build scudo (and others we don't need).
'-DCOMPILER_RT_SANITIZERS_TO_BUILD=asan;dfsan;msan;hwasan;tsan;cfi',
# The default value differs per platform, force it off everywhere.
'-DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=OFF',
# Don't use curl.
@ -660,37 +678,105 @@ def main():
'-DLIBCLANG_BUILD_STATIC=ON',
]
if sys.platform.startswith('linux'):
MaybeDownloadHostGcc(args)
DownloadPinnedClang()
cc = os.path.join(PINNED_CLANG_DIR, 'bin', 'clang')
cxx = os.path.join(PINNED_CLANG_DIR, 'bin', 'clang++')
# Use the libraries in the specified gcc installation for building.
cflags.append('--gcc-toolchain=' + args.gcc_toolchain)
cxxflags.append('--gcc-toolchain=' + args.gcc_toolchain)
base_cmake_args += [
# The host clang has lld.
'-DLLVM_ENABLE_LLD=ON',
'-DLLVM_STATIC_LINK_CXX_STDLIB=ON',
# Force compiler-rt tests to use our gcc toolchain
# because the one on the host may be too old.
# Even with -static-libstdc++ the compiler-rt tests add -lstdc++
# which adds a DT_NEEDED to libstdc++.so so we need to add RPATHs
# to the gcc toolchain.
'-DCOMPILER_RT_TEST_COMPILER_CFLAGS=--gcc-toolchain=' +
args.gcc_toolchain + ' -Wl,-rpath,' +
os.path.join(args.gcc_toolchain, 'lib64') + ' -Wl,-rpath,' +
os.path.join(args.gcc_toolchain, 'lib32')
]
if sys.platform == 'darwin':
# For libc++, we only want the headers.
base_cmake_args.extend([
'-DLIBCXX_ENABLE_SHARED=OFF',
'-DLIBCXX_ENABLE_STATIC=OFF',
'-DLIBCXX_INCLUDE_TESTS=OFF',
'-DLIBCXX_ENABLE_EXPERIMENTAL_LIBRARY=OFF',
])
isysroot = subprocess.check_output(['xcrun', '--show-sdk-path'],
universal_newlines=True).rstrip()
# 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.
cxxflags += ['-stdlib=libc++']
ldflags += ['-stdlib=libc++']
# See https://crbug.com/1302636#c49 - #c56 -- intercepting crypt_r() does not
# work with the sysroot for not fully understood reasons. Disable it.
sanitizers_override = [
'-DSANITIZER_OVERRIDE_INTERCEPTORS',
'-I' + os.path.join(THIS_DIR, 'sanitizers'),
]
cflags += sanitizers_override
cxxflags += sanitizers_override
if args.host_cc or args.host_cxx:
assert args.host_cc and args.host_cxx, \
"--host-cc and --host-cxx need to be used together"
cc = args.host_cc
cxx = args.host_cxx
else:
DownloadPinnedClang()
if sys.platform == 'win32':
cc = os.path.join(PINNED_CLANG_DIR, 'bin', 'clang-cl.exe')
cxx = os.path.join(PINNED_CLANG_DIR, 'bin', 'clang-cl.exe')
lld = os.path.join(PINNED_CLANG_DIR, 'bin', 'lld-link.exe')
# CMake has a hard time with backslashes in compiler paths:
# https://stackoverflow.com/questions/13050827
cc = cc.replace('\\', '/')
cxx = cxx.replace('\\', '/')
lld = lld.replace('\\', '/')
else:
cc = os.path.join(PINNED_CLANG_DIR, 'bin', 'clang')
cxx = os.path.join(PINNED_CLANG_DIR, 'bin', 'clang++')
if sys.platform.startswith('linux'):
MaybeDownloadHostGcc(args)
base_cmake_args += [ '-DLLVM_STATIC_LINK_CXX_STDLIB=ON' ]
if sys.platform != 'darwin':
# The host clang has lld, but self-hosting with lld is still slightly
# broken on mac.
# TODO: check if this works now.
base_cmake_args.append('-DLLVM_ENABLE_LLD=ON')
if sys.platform.startswith('linux'):
# Download sysroots. This uses basically Chromium's sysroots, but with
# minor changes:
# - glibc version bumped to 2.18 to make __cxa_thread_atexit_impl
# work (clang can require 2.18; chromium currently doesn't)
# - libcrypt.so.1 reversioned so that crypt() is picked up from glibc
# The sysroot was built at
# https://chromium-review.googlesource.com/c/chromium/src/+/3684954/1
# and the hashes here are from sysroots.json in that CL.
toolchain_bucket = 'https://commondatastorage.googleapis.com/chrome-linux-sysroot/toolchain/'
# amd64
# hash from https://chromium-review.googlesource.com/c/chromium/src/+/3684954/1/build/linux/sysroot_scripts/sysroots.json#3
toolchain_hash = '2028cdaf24259d23adcff95393b8cc4f0eef714b'
toolchain_name = 'debian_bullseye_amd64_sysroot'
U = toolchain_bucket + toolchain_hash + '/' + toolchain_name + '.tar.xz'
sysroot_amd64 = os.path.join(LLVM_BUILD_TOOLS_DIR, toolchain_name)
DownloadAndUnpack(U, sysroot_amd64)
# i386
# hash from https://chromium-review.googlesource.com/c/chromium/src/+/3684954/1/build/linux/sysroot_scripts/sysroots.json#23
toolchain_hash = 'a033618b5e092c86e96d62d3c43f7363df6cebe7'
toolchain_name = 'debian_bullseye_i386_sysroot'
U = toolchain_bucket + toolchain_hash + '/' + toolchain_name + '.tar.xz'
sysroot_i386 = os.path.join(LLVM_BUILD_TOOLS_DIR, toolchain_name)
DownloadAndUnpack(U, sysroot_i386)
# arm
# hash from https://chromium-review.googlesource.com/c/chromium/src/+/3684954/1/build/linux/sysroot_scripts/sysroots.json#8
toolchain_hash = '0b9a3c54d2d5f6b1a428369aaa8d7ba7b227f701'
toolchain_name = 'debian_bullseye_arm_sysroot'
U = toolchain_bucket + toolchain_hash + '/' + toolchain_name + '.tar.xz'
sysroot_arm = os.path.join(LLVM_BUILD_TOOLS_DIR, toolchain_name)
DownloadAndUnpack(U, sysroot_arm)
# arm64
# hash from https://chromium-review.googlesource.com/c/chromium/src/+/3684954/1/build/linux/sysroot_scripts/sysroots.json#12
toolchain_hash = '0e28d9832614729bb5b731161ff96cb4d516f345'
toolchain_name = 'debian_bullseye_arm64_sysroot'
U = toolchain_bucket + toolchain_hash + '/' + toolchain_name + '.tar.xz'
sysroot_arm64 = os.path.join(LLVM_BUILD_TOOLS_DIR, toolchain_name)
DownloadAndUnpack(U, sysroot_arm64)
# Add the sysroot to base_cmake_args.
if platform.machine() == 'aarch64':
base_cmake_args.append('-DCMAKE_SYSROOT=' + sysroot_arm64)
else:
# amd64 is the default toolchain.
base_cmake_args.append('-DCMAKE_SYSROOT=' + sysroot_amd64)
if sys.platform == 'win32':
base_cmake_args.append('-DLLVM_USE_CRT_RELEASE=MT')
@ -721,14 +807,16 @@ def main():
os.chdir(LLVM_BOOTSTRAP_DIR)
projects = 'clang'
if args.pgo:
# Need libclang_rt.profile
projects += ';compiler-rt'
runtimes = ''
if args.pgo or sys.platform == 'darwin':
# Need libclang_rt.profile for PGO.
# On macOS, the bootstrap toolchain needs to have compiler-rt because
# dsymutil's link needs libclang_rt.osx.a. Only the x86_64 osx
# libraries are needed though, and only libclang_rt (i.e.
# COMPILER_RT_BUILD_BUILTINS).
runtimes += ';compiler-rt'
if sys.platform != 'darwin':
projects += ';lld'
if sys.platform == 'darwin':
# Need libc++ and compiler-rt for the bootstrap compiler on mac.
projects += ';libcxx;compiler-rt'
bootstrap_targets = 'X86'
if sys.platform == 'darwin':
@ -737,6 +825,7 @@ def main():
bootstrap_args = base_cmake_args + [
'-DLLVM_TARGETS_TO_BUILD=' + bootstrap_targets,
'-DLLVM_ENABLE_PROJECTS=' + projects,
'-DLLVM_ENABLE_RUNTIMES=' + runtimes,
'-DCMAKE_INSTALL_PREFIX=' + LLVM_BOOTSTRAP_INSTALL_DIR,
'-DCMAKE_C_FLAGS=' + ' '.join(cflags),
'-DCMAKE_CXX_FLAGS=' + ' '.join(cxxflags),
@ -746,19 +835,13 @@ def main():
# Ignore args.disable_asserts for the bootstrap compiler.
'-DLLVM_ENABLE_ASSERTIONS=ON',
]
# PGO needs libclang_rt.profile but none of the other compiler-rt stuff.
bootstrap_args.extend([
'-D' + f
for f in compiler_rt_cmake_flags(sanitizers=False, profile=args.pgo)
])
if sys.platform == 'darwin':
# On macOS, the bootstrap toolchain needs to have compiler-rt because
# dsymutil's link needs libclang_rt.osx.a. Only the x86_64 osx
# libraries are needed though, and only libclang_rt (i.e.
# COMPILER_RT_BUILD_BUILTINS).
bootstrap_args.extend([
'-DCOMPILER_RT_BUILD_BUILTINS=ON',
'-DCOMPILER_RT_BUILD_CRT=OFF',
'-DCOMPILER_RT_BUILD_LIBFUZZER=OFF',
'-DCOMPILER_RT_BUILD_MEMPROF=OFF',
'-DCOMPILER_RT_BUILD_ORC=OFF',
'-DCOMPILER_RT_BUILD_SANITIZERS=OFF',
'-DCOMPILER_RT_BUILD_XRAY=OFF',
'-DCOMPILER_RT_ENABLE_IOS=OFF',
'-DCOMPILER_RT_ENABLE_WATCHOS=OFF',
'-DCOMPILER_RT_ENABLE_TVOS=OFF',
@ -767,18 +850,6 @@ def main():
bootstrap_args.extend(['-DDARWIN_osx_ARCHS=arm64'])
else:
bootstrap_args.extend(['-DDARWIN_osx_ARCHS=x86_64'])
elif args.pgo:
# PGO needs libclang_rt.profile but none of the other compiler-rt stuff.
bootstrap_args.extend([
'-DCOMPILER_RT_BUILD_BUILTINS=OFF',
'-DCOMPILER_RT_BUILD_CRT=OFF',
'-DCOMPILER_RT_BUILD_LIBFUZZER=OFF',
'-DCOMPILER_RT_BUILD_MEMPROF=OFF',
'-DCOMPILER_RT_BUILD_ORC=OFF',
'-DCOMPILER_RT_BUILD_PROFILE=ON',
'-DCOMPILER_RT_BUILD_SANITIZERS=OFF',
'-DCOMPILER_RT_BUILD_XRAY=OFF',
])
if cc is not None: bootstrap_args.append('-DCMAKE_C_COMPILER=' + cc)
if cxx is not None: bootstrap_args.append('-DCMAKE_CXX_COMPILER=' + cxx)
@ -813,8 +884,6 @@ def main():
os.chdir(LLVM_INSTRUMENTED_DIR)
projects = 'clang'
if sys.platform == 'darwin':
projects += ';libcxx;compiler-rt'
instrument_args = base_cmake_args + [
'-DLLVM_ENABLE_PROJECTS=' + projects,
@ -862,7 +931,7 @@ def main():
with open(training_source, 'wb') as f:
DownloadUrl(CDS_URL + '/' + training_source, f)
train_cmd = [os.path.join(LLVM_INSTRUMENTED_DIR, 'bin', 'clang++'),
'-target', 'x86_64-unknown-unknown', '-O2', '-g', '-std=c++14',
'-target', 'x86_64-unknown-unknown', '-O3', '-g', '-std=c++14',
'-fno-exceptions', '-fno-rtti', '-w', '-c', training_source]
if sys.platform == 'darwin':
train_cmd.extend(['-stdlib=libc++', '-isysroot', isysroot])
@ -875,49 +944,7 @@ def main():
'*.profraw')), msvc_arch='x64')
print('Profile generated.')
compiler_rt_args = [
# Build crtbegin/crtend. It's just two tiny TUs, so just enable this
# everywhere, even though we only need it on Linux.
'-DCOMPILER_RT_BUILD_CRT=ON',
'-DCOMPILER_RT_BUILD_LIBFUZZER=OFF',
'-DCOMPILER_RT_BUILD_MEMPROF=OFF',
'-DCOMPILER_RT_BUILD_ORC=OFF',
'-DCOMPILER_RT_BUILD_PROFILE=ON',
'-DCOMPILER_RT_BUILD_SANITIZERS=ON',
'-DCOMPILER_RT_BUILD_XRAY=OFF',
]
if sys.platform == 'darwin':
compiler_rt_args.extend([
'-DCOMPILER_RT_ENABLE_IOS=ON',
'-DCOMPILER_RT_ENABLE_WATCHOS=OFF',
'-DCOMPILER_RT_ENABLE_TVOS=OFF',
# armv7 is A5 and earlier, armv7s is A6+ (2012 and later, before 64-bit
# iPhones). armv7k is Apple Watch, which we don't need.
'-DDARWIN_ios_ARCHS=armv7;armv7s;arm64',
'-DDARWIN_iossim_ARCHS=i386;x86_64;arm64',
# We don't need 32-bit intel support for macOS, we only ship 64-bit.
'-DDARWIN_osx_ARCHS=arm64;x86_64',
])
if sys.platform == 'win32':
# https://crbug.com/1293778
compiler_rt_args.append('-DCOMPILER_RT_BUILD_BUILTINS=OFF')
else:
compiler_rt_args.append('-DCOMPILER_RT_BUILD_BUILTINS=ON')
# 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.
deployment_target = ''
if sys.platform == 'darwin' and args.bootstrap:
# 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', isysroot]
cxxflags = ['-stdlib=libc++'] + cflags
ldflags += ['-stdlib=libc++']
deployment_target = '10.7'
deployment_target = '10.7'
# If building at head, define a macro that plugins can use for #ifdefing
# out code that builds at head, but not at CLANG_REVISION or vice versa.
@ -945,7 +972,7 @@ def main():
if cc is not None: base_cmake_args.append('-DCMAKE_C_COMPILER=' + cc)
if cxx is not None: base_cmake_args.append('-DCMAKE_CXX_COMPILER=' + cxx)
if lld is not None: base_cmake_args.append('-DCMAKE_LINKER=' + lld)
cmake_args = base_cmake_args + compiler_rt_args + [
cmake_args = base_cmake_args + [
'-DCMAKE_C_FLAGS=' + ' '.join(cflags),
'-DCMAKE_CXX_FLAGS=' + ' '.join(cxxflags),
'-DCMAKE_EXE_LINKER_FLAGS=' + ' '.join(ldflags),
@ -963,13 +990,11 @@ def main():
if sys.platform == 'win32':
cmake_args.append('-DLLVM_ENABLE_ZLIB=FORCE_ON')
if sys.platform == 'darwin':
cmake_args += ['-DCOMPILER_RT_ENABLE_IOS=ON',
'-DSANITIZER_MIN_OSX_VERSION=10.7']
if args.build_mac_arm:
assert platform.machine() != 'arm64', 'build_mac_arm for cross build only'
cmake_args += ['-DCMAKE_OSX_ARCHITECTURES=arm64',
'-DLLVM_USE_HOST_TOOLS=ON']
if args.build_mac_arm:
assert platform.machine() != 'arm64', 'build_mac_arm for cross build only'
cmake_args += [
'-DCMAKE_OSX_ARCHITECTURES=arm64', '-DCMAKE_SYSTEM_NAME=Darwin'
]
# The default LLVM_DEFAULT_TARGET_TRIPLE depends on the host machine.
# Set it explicitly to make the build of clang more hermetic, and also to
@ -992,12 +1017,164 @@ def main():
elif sys.platform == 'win32':
cmake_args.append('-DLLVM_DEFAULT_TARGET_TRIPLE=x86_64-pc-windows-msvc')
# List of (triple, list of CMake vars without '-D').
runtimes_triples_args = []
if sys.platform.startswith('linux'):
runtimes_triples_args.append(
('i386-unknown-linux-gnu',
compiler_rt_cmake_flags(sanitizers=True, profile=True) + [
'CMAKE_SYSROOT=%s' % sysroot_i386,
]))
runtimes_triples_args.append(
('x86_64-unknown-linux-gnu',
compiler_rt_cmake_flags(sanitizers=True, profile=True) + [
'CMAKE_SYSROOT=%s' % sysroot_amd64,
]))
runtimes_triples_args.append(
# Using "armv7a-unknown-linux-gnueabhihf" confuses the compiler-rt
# builtins build, since compiler-rt/cmake/builtin-config-ix.cmake
# doesn't include "armv7a" in its `ARM32` list.
# TODO(thakis): It seems to work for everything else though, see try
# results on
# https://chromium-review.googlesource.com/c/chromium/src/+/3702739/4
# Maybe it should work for builtins too?
('armv7-unknown-linux-gnueabihf',
compiler_rt_cmake_flags(sanitizers=True, profile=True) + [
'CMAKE_SYSROOT=%s' % sysroot_arm,
]))
runtimes_triples_args.append(
('aarch64-unknown-linux-gnu',
compiler_rt_cmake_flags(sanitizers=True, profile=True) + [
'CMAKE_SYSROOT=%s' % sysroot_arm64,
]))
elif sys.platform == 'win32':
runtimes_triples_args.append(
('i386-pc-windows-msvc',
compiler_rt_cmake_flags(sanitizers=False, profile=True) + [
'LLVM_ENABLE_PER_TARGET_RUNTIME_DIR=OFF',
]))
runtimes_triples_args.append(
('x86_64-pc-windows-msvc',
compiler_rt_cmake_flags(sanitizers=True, profile=True) + [
'LLVM_ENABLE_PER_TARGET_RUNTIME_DIR=OFF',
]))
elif sys.platform == 'darwin':
compiler_rt_args = [
'SANITIZER_MIN_OSX_VERSION=10.7',
'COMPILER_RT_ENABLE_MACCATALYST=ON',
'COMPILER_RT_ENABLE_IOS=ON',
'COMPILER_RT_ENABLE_WATCHOS=OFF',
'COMPILER_RT_ENABLE_TVOS=OFF',
'DARWIN_ios_ARCHS=arm64',
'DARWIN_iossim_ARCHS=arm64;x86_64',
'DARWIN_osx_ARCHS=arm64;x86_64',
] + compiler_rt_cmake_flags(sanitizers=True, profile=True)
# compiler-rt is built for all platforms/arches with a single
# configuration, we should only specify one target triple. 'default' is
# specially handled.
runtimes_triples_args.append(('default', compiler_rt_args))
if args.with_android:
toolchain_dir = ANDROID_NDK_DIR + '/toolchains/llvm/prebuilt/linux-x86_64'
for target_arch in ['aarch64', 'arm', 'i686', 'x86_64']:
target_triple = target_arch
if target_arch == 'arm':
target_triple = 'armv7'
api_level = '19'
if target_arch == 'aarch64' or target_arch == 'x86_64':
api_level = '21'
target_triple += '-linux-android' + api_level
cflags = [
'--sysroot=%s/sysroot' % toolchain_dir,
# We don't have an unwinder ready, and don't need it either.
'--unwindlib=none',
]
if target_arch == 'aarch64':
# Use PAC/BTI instructions for AArch64
cflags += [ '-mbranch-protection=standard' ]
android_args = compiler_rt_cmake_flags(sanitizers=True, profile=True) + [
'LLVM_ENABLE_RUNTIMES=compiler-rt',
# On Android, we want DWARF info for the builtins for unwinding. See
# crbug.com/1311807.
'CMAKE_BUILD_TYPE=RelWithDebInfo',
'CMAKE_C_FLAGS=' + ' '.join(cflags),
'CMAKE_CXX_FLAGS=' + ' '.join(cflags),
'CMAKE_ASM_FLAGS=' + ' '.join(cflags),
'COMPILER_RT_USE_BUILTINS_LIBRARY=ON',
'SANITIZER_CXX_ABI=libcxxabi',
'CMAKE_SHARED_LINKER_FLAGS=-Wl,-u__cxa_demangle',
'ANDROID=1',
'LLVM_ENABLE_PER_TARGET_RUNTIME_DIR=OFF',
'LLVM_INCLUDE_TESTS=OFF',
# This prevents static_asserts from firing in 32-bit builds.
# TODO: remove once we only support API >=24.
'ANDROID_NATIVE_API_LEVEL=' + api_level,
]
runtimes_triples_args.append((target_triple, android_args))
if args.with_fuchsia:
# Fuchsia links against libclang_rt.builtins-<arch>.a instead of libgcc.a.
for target_arch in ['aarch64', 'x86_64']:
fuchsia_arch_name = {'aarch64': 'arm64', 'x86_64': 'x64'}[target_arch]
toolchain_dir = os.path.join(
FUCHSIA_SDK_DIR, 'arch', fuchsia_arch_name, 'sysroot')
target_triple = target_arch + '-unknown-fuchsia'
# Build the Fuchsia profile and asan runtimes. This is done after the rt
# builtins have been created because the CMake build runs link checks that
# require that the builtins already exist to succeed.
# TODO(thakis): Figure out why this doesn't build with the stage0
# compiler in arm cross builds.
build_profile = target_arch == 'x86_64' and not args.build_mac_arm
# Build the asan runtime only on non-Mac platforms. Macs are excluded
# because the asan install changes library RPATHs which CMake only
# supports on ELF platforms and MacOS uses Mach-O instead of ELF.
build_sanitizers = build_profile and sys.platform != 'darwin'
# TODO(thakis): Might have to pass -B here once sysroot contains
# binaries (e.g. gas for arm64?)
fuchsia_args = compiler_rt_cmake_flags(
sanitizers=build_sanitizers, profile=build_profile
) + [
'LLVM_ENABLE_RUNTIMES=compiler-rt',
'CMAKE_SYSTEM_NAME=Fuchsia',
'CMAKE_SYSROOT=%s' % toolchain_dir,
# TODO(thakis|scottmg): Use PER_TARGET_RUNTIME_DIR for all platforms.
# https://crbug.com/882485.
'LLVM_ENABLE_PER_TARGET_RUNTIME_DIR=ON',
]
if build_sanitizers:
fuchsia_args.append('SANITIZER_NO_UNDEFINED_SYMBOLS=OFF')
runtimes_triples_args.append((target_triple, fuchsia_args))
# Convert FOO=BAR CMake flags per triple into
# -DBUILTINS_$triple_FOO=BAR/-DRUNTIMES_$triple_FOO=BAR and build up
# -DLLVM_BUILTIN_TARGETS/-DLLVM_RUNTIME_TARGETS.
all_triples = ''
for (triple, a) in runtimes_triples_args:
all_triples += ';' + triple
for arg in a:
assert not arg.startswith('-')
# 'default' is specially handled to pass through relevant CMake flags.
if triple == 'default':
cmake_args.append('-D' + arg)
else:
cmake_args.append('-DBUILTINS_' + triple + '_' + arg)
cmake_args.append('-DRUNTIMES_' + triple + '_' + arg)
cmake_args.append('-DLLVM_BUILTIN_TARGETS=' + all_triples)
cmake_args.append('-DLLVM_RUNTIME_TARGETS=' + all_triples)
if os.path.exists(LLVM_BUILD_DIR):
RmTree(LLVM_BUILD_DIR)
EnsureDirExists(LLVM_BUILD_DIR)
os.chdir(LLVM_BUILD_DIR)
RunCommand(['cmake'] + cmake_args + [os.path.join(LLVM_DIR, 'llvm')],
msvc_arch='x64', env=deployment_env)
msvc_arch='x64',
env=deployment_env)
CopyLibstdcpp(args, LLVM_BUILD_DIR)
RunCommand(['ninja'], msvc_arch='x64')
@ -1009,290 +1186,22 @@ def main():
VerifyVersionOfBuiltClangMatchesVERSION()
VerifyZlibSupport()
if sys.platform == 'win32':
rt_platform = 'windows'
elif sys.platform == 'darwin':
rt_platform = 'darwin'
else:
assert sys.platform.startswith('linux')
rt_platform = 'linux'
rt_lib_dst_dir = os.path.join(LLVM_BUILD_DIR, 'lib', 'clang', RELEASE_VERSION,
'lib', rt_platform)
# Make sure the directory exists; this will not be implicilty created if
# built with per-target runtime directories.
if not os.path.exists(rt_lib_dst_dir):
os.makedirs(rt_lib_dst_dir)
# Do an out-of-tree build of compiler-rt for 32-bit Win clang_rt.profile.lib.
if sys.platform == 'win32':
compiler_rt_build_dir = os.path.join(LLVM_BUILD_DIR, 'compiler-rt')
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)
if args.bootstrap:
# The bootstrap compiler produces 64-bit binaries by default.
cflags += ['-m32']
cxxflags += ['-m32']
compiler_rt_args = base_cmake_args + [
'-DCMAKE_C_FLAGS=' + ' '.join(cflags),
'-DCMAKE_CXX_FLAGS=' + ' '.join(cxxflags),
'-DCMAKE_EXE_LINKER_FLAGS=' + ' '.join(ldflags),
'-DCMAKE_SHARED_LINKER_FLAGS=' + ' '.join(ldflags),
'-DCMAKE_MODULE_LINKER_FLAGS=' + ' '.join(ldflags),
'-DCOMPILER_RT_BUILD_BUILTINS=OFF',
'-DCOMPILER_RT_BUILD_CRT=OFF',
'-DCOMPILER_RT_BUILD_LIBFUZZER=OFF',
'-DCOMPILER_RT_BUILD_MEMPROF=OFF',
'-DCOMPILER_RT_BUILD_ORC=OFF',
'-DCOMPILER_RT_BUILD_PROFILE=ON',
'-DCOMPILER_RT_BUILD_SANITIZERS=OFF',
'-DCOMPILER_RT_BUILD_XRAY=OFF',
# The libxml2 we built above is 64-bit. Since it's only needed by
# lld-link and not compiler-rt, just turn it off down here.
'-DLLVM_ENABLE_LIBXML2=OFF',
]
RunCommand(['cmake'] + compiler_rt_args +
[os.path.join(LLVM_DIR, 'llvm')],
msvc_arch='x86', env=deployment_env)
RunCommand(['ninja', 'compiler-rt'], msvc_arch='x86')
# Copy select output to the main tree.
rt_lib_src_dir = os.path.join(compiler_rt_build_dir, 'lib', 'clang',
RELEASE_VERSION, 'lib', rt_platform)
# Static and dynamic libraries:
CopyDirectoryContents(rt_lib_src_dir, rt_lib_dst_dir)
if args.with_android:
# TODO(thakis): Now that the NDK uses clang, try to build all archs in
# one LLVM build instead of building 3 times.
toolchain_dir = ANDROID_NDK_DIR + '/toolchains/llvm/prebuilt/linux-x86_64'
for target_arch in ['aarch64', 'arm', 'i686', 'x86_64']:
# Build compiler-rt runtimes needed for Android in a separate build tree.
build_dir = os.path.join(LLVM_BUILD_DIR, 'android-' + target_arch)
if not os.path.exists(build_dir):
os.mkdir(os.path.join(build_dir))
os.chdir(build_dir)
target_triple = target_arch
if target_arch == 'arm':
target_triple = 'armv7'
api_level = '19'
if target_arch == 'aarch64' or target_arch == 'x86_64':
api_level = '21'
target_triple += '-linux-android' + api_level
cflags = [
'--target=' + target_triple,
'--sysroot=%s/sysroot' % toolchain_dir,
# pylint: disable=line-too-long
# android_ndk/toolchains/llvm/prebuilt/linux-x86_64/aarch64-linux-android/bin/ld
# depends on a newer version of libxml2.so than what's available on
# the bots. To make things work, use our just-built lld as linker.
# pylint: enable=line-too-long
'-fuse-ld=lld',
# We don't have an unwinder ready, and don't need it either.
'--unwindlib=none',
]
if target_arch == 'aarch64':
# Use PAC/BTI instructions for AArch64
cflags += [ '-mbranch-protection=standard' ]
android_args = base_cmake_args + [
'-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_ASM_FLAGS=' + ' '.join(cflags),
'-DCOMPILER_RT_BUILD_BUILTINS=ON',
'-DCOMPILER_RT_BUILD_CRT=OFF',
'-DCOMPILER_RT_BUILD_LIBFUZZER=OFF',
'-DCOMPILER_RT_BUILD_MEMPROF=OFF',
'-DCOMPILER_RT_BUILD_ORC=OFF',
'-DCOMPILER_RT_BUILD_PROFILE=OFF',
'-DCOMPILER_RT_BUILD_SANITIZERS=OFF',
'-DCOMPILER_RT_BUILD_XRAY=OFF',
'-DSANITIZER_CXX_ABI=libcxxabi',
'-DCMAKE_SHARED_LINKER_FLAGS=-Wl,-u__cxa_demangle',
'-DANDROID=1'
# These are necessary because otherwise CMake tries to build an
# executable to test to see if the compiler is working, but in doing so,
# it links against the builtins.a that we're about to build.
'-DCMAKE_CXX_COMPILER_WORKS=ON',
'-DCMAKE_C_COMPILER_WORKS=ON',
'-DCMAKE_ASM_COMPILER_WORKS=ON',
]
# First build the builtins and copy to the main build tree.
RunCommand(
['cmake'] + android_args +
# On Android, we want DWARF info for the builtins for
# unwinding. See crbug.com/1311807.
['-DCMAKE_BUILD_TYPE=RelWithDebInfo'] +
[os.path.join(COMPILER_RT_DIR, 'lib', 'builtins')])
builtins_a = 'lib/linux/libclang_rt.builtins-%s-android.a' % target_arch
RunCommand(['ninja', builtins_a])
shutil.copy(builtins_a, rt_lib_dst_dir)
# With the builtins in place, we can build the other runtimes.
build_dir_2 = build_dir + '-phase2'
if not os.path.exists(build_dir_2):
os.mkdir(os.path.join(build_dir_2))
os.chdir(build_dir_2)
android_args.extend([
'-DCOMPILER_RT_BUILD_BUILTINS=OFF',
'-DCOMPILER_RT_USE_BUILTINS_LIBRARY=ON',
'-DCOMPILER_RT_BUILD_PROFILE=ON',
'-DCOMPILER_RT_BUILD_SANITIZERS=ON',
])
RunCommand(['cmake'] + android_args + [COMPILER_RT_DIR])
libs_want = [
'lib/linux/libclang_rt.asan-{0}-android.so',
'lib/linux/libclang_rt.asan_static-{0}-android.a',
'lib/linux/libclang_rt.ubsan_standalone-{0}-android.so',
'lib/linux/libclang_rt.profile-{0}-android.a',
]
# Only build HWASan for AArch64.
if target_arch == 'aarch64':
libs_want += ['lib/linux/libclang_rt.hwasan-{0}-android.so']
libs_want = [lib.format(target_arch) for lib in libs_want]
RunCommand(['ninja'] + libs_want)
# And copy them into the main build tree.
for p in libs_want:
shutil.copy(p, 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']:
fuchsia_arch_name = {'aarch64': 'arm64', 'x86_64': 'x64'}[target_arch]
toolchain_dir = os.path.join(
FUCHSIA_SDK_DIR, 'arch', fuchsia_arch_name, 'sysroot')
# 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)
target_spec = target_arch + '-unknown-fuchsia'
if args.build_mac_arm:
# Just-built clang can't run (it's an arm binary on an intel host), so
# use the bootstrap compiler instead.
host_path = LLVM_BOOTSTRAP_INSTALL_DIR
else:
host_path = LLVM_BUILD_DIR
# TODO(thakis): Might have to pass -B here once sysroot contains
# binaries (e.g. gas for arm64?)
fuchsia_args = base_cmake_args + [
'-DCMAKE_C_COMPILER=' + os.path.join(host_path, 'bin/clang'),
'-DCMAKE_CXX_COMPILER=' + os.path.join(host_path, 'bin/clang++'),
'-DCMAKE_LINKER=' + os.path.join(host_path, 'bin/clang'),
'-DCMAKE_AR=' + os.path.join(host_path, 'bin/llvm-ar'),
'-DLLVM_CONFIG_PATH=' + os.path.join(host_path, 'bin/llvm-config'),
'-DCMAKE_SYSTEM_NAME=Fuchsia',
'-DCMAKE_CXX_COMPILER_TARGET=' + target_spec,
'-DCMAKE_C_COMPILER_TARGET=' + target_spec,
'-DCMAKE_ASM_COMPILER_TARGET=' + target_spec,
'-DCOMPILER_RT_BUILD_BUILTINS=ON',
'-DCOMPILER_RT_BUILD_CRT=OFF',
'-DCOMPILER_RT_BUILD_LIBFUZZER=OFF',
'-DCOMPILER_RT_BUILD_MEMPROF=OFF',
'-DCOMPILER_RT_BUILD_ORC=OFF',
'-DCOMPILER_RT_BUILD_PROFILE=OFF',
'-DCOMPILER_RT_BUILD_SANITIZERS=OFF',
'-DCOMPILER_RT_BUILD_XRAY=OFF',
'-DCOMPILER_RT_DEFAULT_TARGET_ONLY=ON',
'-DCMAKE_SYSROOT=%s' % toolchain_dir,
# TODO(thakis|scottmg): Use PER_TARGET_RUNTIME_DIR for all platforms.
# https://crbug.com/882485.
'-DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=ON',
# These are necessary because otherwise CMake tries to build an
# executable to test to see if the compiler is working, but in doing so,
# it links against the builtins.a that we're about to build.
'-DCMAKE_CXX_COMPILER_WORKS=ON',
'-DCMAKE_C_COMPILER_WORKS=ON',
'-DCMAKE_ASM_COMPILER_WORKS=ON',
]
RunCommand(['cmake'] +
fuchsia_args +
[os.path.join(COMPILER_RT_DIR, 'lib', 'builtins')])
builtins_a = 'libclang_rt.builtins.a'
RunCommand(['ninja', builtins_a])
# And copy it into the main build tree.
fuchsia_lib_dst_dir = os.path.join(LLVM_BUILD_DIR, 'lib', 'clang',
RELEASE_VERSION, 'lib', target_spec)
if not os.path.exists(fuchsia_lib_dst_dir):
os.makedirs(fuchsia_lib_dst_dir)
CopyFile(os.path.join(build_dir, 'lib', target_spec, builtins_a),
fuchsia_lib_dst_dir)
# Build the Fuchsia profile and asan runtimes. This is done after the rt
# builtins have been created because the CMake build runs link checks that
# require that the builtins already exist to succeed.
# TODO(thakis): Figure out why this doesn't build with the stage0
# compiler in arm cross builds.
if target_arch == 'x86_64' and not args.build_mac_arm:
fuchsia_args.extend([
'-DCOMPILER_RT_BUILD_BUILTINS=OFF',
'-DCOMPILER_RT_BUILD_PROFILE=ON',
])
# Build the asan runtime only on non-Mac platforms. Macs are excluded
# because the asan install changes library RPATHs which CMake only
# supports on ELF platforms and MacOS uses Mach-O instead of ELF.
if sys.platform != 'darwin':
fuchsia_args.extend([
'-DCOMPILER_RT_BUILD_SANITIZERS=ON',
'-DSANITIZER_NO_UNDEFINED_SYMBOLS=OFF',
])
build_phase2_dir = os.path.join(LLVM_BUILD_DIR,
'fuchsia-phase2-' + target_arch)
if not os.path.exists(build_phase2_dir):
os.mkdir(os.path.join(build_phase2_dir))
os.chdir(build_phase2_dir)
RunCommand(['cmake'] +
fuchsia_args +
[COMPILER_RT_DIR])
profile_a = 'libclang_rt.profile.a'
asan_preinit_a = 'libclang_rt.asan-preinit.a'
asan_static_a = 'libclang_rt.asan_static.a'
asan_so = 'libclang_rt.asan.so'
ninja_command = ['ninja', profile_a]
if sys.platform != 'darwin':
ninja_command.append(asan_so)
ninja_command.append(asan_preinit_a)
ninja_command.append(asan_static_a)
RunCommand(ninja_command)
CopyFile(os.path.join(build_phase2_dir, 'lib', target_spec, profile_a),
fuchsia_lib_dst_dir)
if sys.platform != 'darwin':
CopyFile(os.path.join(build_phase2_dir, 'lib', target_spec, asan_so),
fuchsia_lib_dst_dir)
CopyFile(
os.path.join(build_phase2_dir, 'lib', target_spec,
asan_preinit_a), fuchsia_lib_dst_dir)
CopyFile(
os.path.join(build_phase2_dir, 'lib', target_spec, asan_static_a),
fuchsia_lib_dst_dir)
# Run tests.
if (not args.build_mac_arm and
(args.run_tests or args.llvm_force_head_revision)):
RunCommand(['ninja', '-C', LLVM_BUILD_DIR, 'cr-check-all'], msvc_arch='x64')
if not args.build_mac_arm and args.run_tests:
test_targets = [ 'check-all' ]
if sys.platform == 'darwin':
# TODO(thakis): Run check-all on Darwin too, https://crbug.com/959361
test_targets = [ 'check-llvm', 'check-clang', 'check-lld' ]
RunCommand(['ninja', '-C', LLVM_BUILD_DIR] + test_targets, msvc_arch='x64')
env = None
if sys.platform.startswith('linux'):
env = os.environ.copy()
# See SANITIZER_OVERRIDE_INTERCEPTORS above: We disable crypt_r()
# interception, so its tests can't pass.
env['LIT_FILTER_OUT'] = ('^SanitizerCommon-(a|l|m|ub|t)san-x86_64-Linux' +
' :: Linux/crypt_r.cpp$')
RunCommand(['ninja', '-C', LLVM_BUILD_DIR, 'check-all'],
env=env,
msvc_arch='x64')
WriteStampFile(PACKAGE_VERSION, STAMP_FILE)
WriteStampFile(PACKAGE_VERSION, FORCE_HEAD_REVISION_FILE)