1#!/usr/bin/env python 2# 3# Copyright (C) 2015 The Android Open Source Project 4# 5# Licensed under the Apache License, Version 2.0 (the "License"); 6# you may not use this file except in compliance with the License. 7# You may obtain a copy of the License at 8# 9# http://www.apache.org/licenses/LICENSE-2.0 10# 11# Unless required by applicable law or agreed to in writing, software 12# distributed under the License is distributed on an "AS IS" BASIS, 13# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14# See the License for the specific language governing permissions and 15# limitations under the License. 16# 17"""Builds the Android Clang toolchain.""" 18import argparse 19import glob 20import logging 21import multiprocessing 22import os 23import pprint 24import subprocess 25import sys 26 27import version 28 29 30# Disable all the "too many/few methods/parameters" warnings and the like. 31# pylint: disable=design 32 33# Disable lint warnings for todo comments and the like. 34# pylint: disable=fixme 35 36# TODO: Add docstrings? 37# pylint: disable=missing-docstring 38 39 40THIS_DIR = os.path.realpath(os.path.dirname(__file__)) 41ORIG_ENV = dict(os.environ) 42 43 44class Config(object): 45 """Container for global configuration options.""" 46 47 # Set True to skip all actions (log only). Controlled by --dry-run. 48 dry_run = False 49 50 51def logger(): 52 """Returns the default logger for the module.""" 53 return logging.getLogger(__name__) 54 55 56def android_path(*args): 57 return os.path.realpath(os.path.join(THIS_DIR, '../..', *args)) 58 59 60def build_path(*args): 61 # Our multistage build directories will be placed under OUT_DIR if it is in 62 # the environment. By default they will be placed under 63 # $ANDROID_BUILD_TOP/out. 64 top_out = ORIG_ENV.get('OUT_DIR', 'out') 65 return os.path.join(top_out, *args) 66 67 68def short_version(): 69 return '.'.join([version.major, version.minor]) 70 71 72def long_version(): 73 return '.'.join([version.major, version.minor, version.patch]) 74 75 76def check_call(cmd, *args, **kwargs): 77 """Proxy for subprocess.check_call with logging and dry-run support.""" 78 import subprocess 79 logger().info('check_call: %s', ' '.join(cmd)) 80 if 'env' in kwargs: 81 # Rather than dump the whole environment to the terminal every time, 82 # just print the difference between this call and our environment. 83 # Note that this will not include environment that was *removed* from 84 # os.environ. 85 extra_env = dict(set(kwargs['env'].items()) - set(os.environ.items())) 86 if len(extra_env) > 0: 87 logger().info('check_call additional env:\n%s', 88 pprint.pformat(extra_env)) 89 if not Config.dry_run: 90 subprocess.check_call(cmd, *args, **kwargs) 91 92 93def install_file(src, dst): 94 """Proxy for shutil.copy2 with logging and dry-run support.""" 95 import shutil 96 logger().info('copy %s %s', src, dst) 97 if not Config.dry_run: 98 shutil.copy2(src, dst) 99 100 101def install_directory(src, dst): 102 """Proxy for shutil.copytree with logging and dry-run support.""" 103 import shutil 104 logger().info('copytree %s %s', src, dst) 105 if not Config.dry_run: 106 shutil.copytree(src, dst) 107 108 109def rmtree(path): 110 """Proxy for shutil.rmtree with logging and dry-run support.""" 111 import shutil 112 logger().info('rmtree %s', path) 113 if not Config.dry_run: 114 shutil.rmtree(path) 115 116 117def rename(src, dst): 118 """Proxy for os.rename with logging and dry-run support.""" 119 logger().info('rename %s %s', src, dst) 120 if not Config.dry_run: 121 os.rename(src, dst) 122 123 124def makedirs(path): 125 """Proxy for os.makedirs with logging and dry-run support.""" 126 logger().info('makedirs %s', path) 127 if not Config.dry_run: 128 os.makedirs(path) 129 130 131def symlink(src, dst): 132 """Proxy for os.symlink with logging and dry-run support.""" 133 logger().info('symlink %s %s', src, dst) 134 if not Config.dry_run: 135 os.symlink(src, dst) 136 137 138def build(out_dir, prebuilts_path=None, prebuilts_version=None, 139 build_all_clang_tools=None, build_all_llvm_tools=None, 140 debug_clang=None, max_jobs=multiprocessing.cpu_count()): 141 products = ( 142 'aosp_arm', 143 'aosp_arm64', 144 'aosp_mips', 145 'aosp_mips64', 146 'aosp_x86', 147 'aosp_x86_64', 148 ) 149 for product in products: 150 build_product(out_dir, product, prebuilts_path, prebuilts_version, 151 build_all_clang_tools, build_all_llvm_tools, debug_clang, 152 max_jobs) 153 154 155def build_product(out_dir, product, prebuilts_path, prebuilts_version, 156 build_all_clang_tools, build_all_llvm_tools, debug_clang, 157 max_jobs): 158 env = dict(ORIG_ENV) 159 env['DISABLE_LLVM_DEVICE_BUILDS'] = 'true' 160 env['DISABLE_RELOCATION_PACKER'] = 'true' 161 env['FORCE_BUILD_LLVM_COMPONENTS'] = 'true' 162 env['FORCE_BUILD_SANITIZER_SHARED_OBJECTS'] = 'true' 163 env['OUT_DIR'] = out_dir 164 env['SKIP_LLVM_TESTS'] = 'true' 165 env['SOONG_ALLOW_MISSING_DEPENDENCIES'] = 'true' 166 env['TARGET_BUILD_VARIANT'] = 'userdebug' 167 env['TARGET_PRODUCT'] = product 168 169 if debug_clang: 170 env['FORCE_BUILD_LLVM_DEBUG'] = 'true' 171 env['FORCE_BUILD_LLVM_DISABLE_NDEBUG'] = 'true' 172 173 overrides = [] 174 if prebuilts_path is not None: 175 overrides.append('LLVM_PREBUILTS_BASE={}'.format(prebuilts_path)) 176 if prebuilts_version is not None: 177 overrides.append('LLVM_PREBUILTS_VERSION={}'.format(prebuilts_version)) 178 179 # Use at least 1 and at most all available CPUs (sanitize the user input). 180 jobs_arg = '-j{}'.format( 181 max(1, min(max_jobs, multiprocessing.cpu_count()))) 182 183 targets = ['clang-toolchain-minimal'] 184 if build_all_clang_tools: 185 targets += ['clang-toolchain-full'] 186 if build_all_llvm_tools: 187 targets += ['llvm-tools'] 188 check_call(['make', jobs_arg] + overrides + targets, 189 cwd=android_path(), env=env) 190 191 192def package_toolchain(build_dir, build_name, host, dist_dir): 193 package_name = 'clang-' + build_name 194 install_host_dir = build_path('install', host) 195 install_dir = os.path.join(install_host_dir, package_name) 196 197 # Remove any previously installed toolchain so it doesn't pollute the 198 # build. 199 if os.path.exists(install_host_dir): 200 rmtree(install_host_dir) 201 202 install_toolchain(build_dir, install_dir, host, True) 203 204 version_file_path = os.path.join(install_dir, 'AndroidVersion.txt') 205 with open(version_file_path, 'w') as version_file: 206 version_file.write('{}.{}.{}\n'.format( 207 version.major, version.minor, version.patch)) 208 209 tarball_name = package_name + '-' + host 210 package_path = os.path.join(dist_dir, tarball_name) + '.tar.bz2' 211 logger().info('Packaging %s', package_path) 212 args = [ 213 'tar', '-cjC', install_host_dir, '-f', package_path, package_name 214 ] 215 check_call(args) 216 217 218def install_minimal_toolchain(build_dir, install_dir, host, strip): 219 install_built_host_files(build_dir, install_dir, host, strip, minimal=True) 220 install_headers(build_dir, install_dir, host) 221 install_sanitizers(build_dir, install_dir, host) 222 223 224def install_toolchain(build_dir, install_dir, host, strip): 225 install_built_host_files(build_dir, install_dir, host, strip) 226 install_compiler_wrapper(install_dir, host) 227 install_sanitizer_scripts(install_dir) 228 install_scan_scripts(install_dir) 229 install_analyzer_scripts(install_dir) 230 install_headers(build_dir, install_dir, host) 231 install_profile_rt(build_dir, install_dir, host) 232 install_sanitizers(build_dir, install_dir, host) 233 install_sanitizer_tests(build_dir, install_dir, host) 234 install_libomp(build_dir, install_dir, host) 235 install_license_files(install_dir) 236 install_repo_prop(install_dir) 237 238 239def get_built_host_files(host, minimal): 240 is_windows = host.startswith('windows') 241 is_darwin = host.startswith('darwin-x86') 242 bin_ext = '.exe' if is_windows else '' 243 244 if is_windows: 245 lib_ext = '.dll' 246 elif is_darwin: 247 lib_ext = '.dylib' 248 else: 249 lib_ext = '.so' 250 251 built_files = [ 252 'bin/clang' + bin_ext, 253 'bin/clang++' + bin_ext, 254 ] 255 if not is_windows: 256 built_files.extend(['lib64/libc++' + lib_ext]) 257 258 if minimal: 259 return built_files 260 261 built_files.extend([ 262 'bin/clang-format' + bin_ext, 263 'bin/clang-tidy' + bin_ext, 264 ]) 265 266 if is_windows: 267 built_files.extend([ 268 'bin/clang_32' + bin_ext, 269 ]) 270 else: 271 built_files.extend([ 272 'bin/FileCheck' + bin_ext, 273 'bin/llvm-as' + bin_ext, 274 'bin/llvm-dis' + bin_ext, 275 'bin/llvm-link' + bin_ext, 276 'bin/llvm-symbolizer' + bin_ext, 277 'lib64/libLLVM' + lib_ext, 278 'lib64/LLVMgold' + lib_ext, 279 ]) 280 return built_files 281 282 283def install_built_host_files(build_dir, install_dir, host, strip, minimal=None): 284 built_files = get_built_host_files(host, minimal) 285 for built_file in built_files: 286 dirname = os.path.dirname(built_file) 287 install_path = os.path.join(install_dir, dirname) 288 if not os.path.exists(install_path): 289 makedirs(install_path) 290 291 built_path = os.path.join(build_dir, 'host', host, built_file) 292 install_file(built_path, install_path) 293 294 file_name = os.path.basename(built_file) 295 296 # Only strip bin files (not libs) on darwin. 297 is_darwin = host.startswith('darwin-x86') 298 if strip and (not is_darwin or built_file.startswith('bin/')): 299 check_call(['strip', os.path.join(install_path, file_name)]) 300 301 302def install_sanitizer_scripts(install_dir): 303 script_path = android_path( 304 'external/compiler-rt/lib/asan/scripts/asan_device_setup') 305 install_file(script_path, os.path.join(install_dir, 'bin')) 306 307 308def install_analyzer_scripts(install_dir): 309 """Create and install bash scripts for invoking Clang for analysis.""" 310 analyzer_text = ( 311 '#!/bin/bash\n' 312 'if [ "$1" != "-cc1" ]; then\n' 313 ' `dirname $0`/../clang{clang_suffix} -target {target} "$@"\n' 314 'else\n' 315 ' # target/triple already spelled out.\n' 316 ' `dirname $0`/../clang{clang_suffix} "$@"\n' 317 'fi\n' 318 ) 319 320 arch_target_pairs = ( 321 ('arm64-v8a', 'aarch64-none-linux-android'), 322 ('armeabi', 'armv5te-none-linux-androideabi'), 323 ('armeabi-v7a', 'armv7-none-linux-androideabi'), 324 ('armeabi-v7a-hard', 'armv7-none-linux-androideabi'), 325 ('mips', 'mipsel-none-linux-android'), 326 ('mips64', 'mips64el-none-linux-android'), 327 ('x86', 'i686-none-linux-android'), 328 ('x86_64', 'x86_64-none-linux-android'), 329 ) 330 331 for arch, target in arch_target_pairs: 332 arch_path = os.path.join(install_dir, 'bin', arch) 333 makedirs(arch_path) 334 335 analyzer_file_path = os.path.join(arch_path, 'analyzer') 336 logger().info('Creating %s', analyzer_file_path) 337 with open(analyzer_file_path, 'w') as analyzer_file: 338 analyzer_file.write( 339 analyzer_text.format(clang_suffix='', target=target)) 340 subprocess.check_call(['chmod', 'a+x', analyzer_file_path]) 341 342 analyzerpp_file_path = os.path.join(arch_path, 'analyzer++') 343 logger().info('Creating %s', analyzerpp_file_path) 344 with open(analyzerpp_file_path, 'w') as analyzerpp_file: 345 analyzerpp_file.write( 346 analyzer_text.format(clang_suffix='++', target=target)) 347 subprocess.check_call(['chmod', 'a+x', analyzerpp_file_path]) 348 349 350def install_scan_scripts(install_dir): 351 tools_install_dir = os.path.join(install_dir, 'tools') 352 makedirs(tools_install_dir) 353 tools = ('scan-build', 'scan-view') 354 tools_dir = android_path('external/clang/tools') 355 for tool in tools: 356 tool_path = os.path.join(tools_dir, tool) 357 install_path = os.path.join(install_dir, 'tools', tool) 358 install_directory(tool_path, install_path) 359 360 361def install_headers(build_dir, install_dir, host): 362 def should_copy(path): 363 if os.path.basename(path) in ('Makefile', 'CMakeLists.txt'): 364 return False 365 _, ext = os.path.splitext(path) 366 if ext == '.mk': 367 return False 368 return True 369 370 headers_src = android_path('external/clang/lib/Headers') 371 headers_dst = os.path.join( 372 install_dir, 'lib64/clang', short_version(), 'include') 373 makedirs(headers_dst) 374 for header in os.listdir(headers_src): 375 if not should_copy(header): 376 continue 377 install_file(os.path.join(headers_src, header), headers_dst) 378 379 install_file(android_path('bionic/libc/include/stdatomic.h'), headers_dst) 380 381 # arm_neon.h gets produced as part of external/clang/Android.bp. 382 # We must bundle the resulting file as part of the official Clang headers. 383 arm_neon_h = os.path.join( 384 build_dir, 'soong/.intermediates/external/clang/clang-gen-arm-neon/gen/clang/Basic/arm_neon.h') 385 install_file(arm_neon_h, headers_dst) 386 387 symlink(short_version(), 388 os.path.join(install_dir, 'lib64/clang', long_version())) 389 390 391def install_profile_rt(build_dir, install_dir, host): 392 lib_dir = os.path.join( 393 install_dir, 'lib64/clang', short_version(), 'lib/linux') 394 makedirs(lib_dir) 395 396 install_target_profile_rt(build_dir, lib_dir) 397 398 # We only support profiling libs for Linux and Android. 399 if host == 'linux-x86': 400 install_host_profile_rt(build_dir, host, lib_dir) 401 402 403def install_target_profile_rt(build_dir, lib_dir): 404 product_to_arch = { 405 'generic': 'arm', 406 'generic_arm64': 'aarch64', 407 'generic_mips': 'mipsel', 408 'generic_mips64': 'mips64el', 409 'generic_x86': 'i686', 410 'generic_x86_64': 'x86_64', 411 } 412 413 for product, arch in product_to_arch.items(): 414 product_dir = os.path.join(build_dir, 'target/product', product) 415 static_libs = os.path.join(product_dir, 'obj/STATIC_LIBRARIES') 416 built_lib = os.path.join( 417 static_libs, 'libprofile_rt_intermediates/libprofile_rt.a') 418 lib_name = 'libclang_rt.profile-{}-android.a'.format(arch) 419 install_file(built_lib, os.path.join(lib_dir, lib_name)) 420 421 422def install_host_profile_rt(build_dir, host, lib_dir): 423 arch_to_obj_dir = { 424 'i686': 'obj32', 425 'x86_64': 'obj', 426 } 427 428 for arch, obj_dir in arch_to_obj_dir.items(): 429 static_libs = os.path.join( 430 build_dir, 'host', host, obj_dir, 'STATIC_LIBRARIES') 431 built_lib = os.path.join( 432 static_libs, 'libprofile_rt_intermediates/libprofile_rt.a') 433 lib_name = 'libclang_rt.profile-{}.a'.format(arch) 434 install_file(built_lib, os.path.join(lib_dir, lib_name)) 435 436 437def install_libomp(build_dir, install_dir, host): 438 # libomp is not built for Darwin 439 if host == 'darwin-x86': 440 return 441 442 lib_dir = os.path.join( 443 install_dir, 'lib64/clang', short_version(), 'lib/linux') 444 if not os.path.isdir(lib_dir): 445 makedirs(lib_dir) 446 447 product_to_arch = { 448 'generic': 'arm', 449 'generic_arm64': 'arm64', 450 'generic_x86': 'x86', 451 'generic_x86_64': 'x86_64', 452 } 453 454 for product, arch in product_to_arch.items(): 455 module = 'libomp-' + arch 456 product_dir = os.path.join(build_dir, 'target/product', product) 457 shared_libs = os.path.join(product_dir, 'obj/SHARED_LIBRARIES') 458 built_lib = os.path.join( 459 shared_libs, 460 '{}_intermediates/PACKED/{}.so'.format(module, module)) 461 install_file(built_lib, os.path.join(lib_dir, module + '.so')) 462 463 464def install_sanitizers(build_dir, install_dir, host): 465 headers_src = android_path('external/compiler-rt/include/sanitizer') 466 clang_lib = os.path.join(install_dir, 'lib64/clang', short_version()) 467 headers_dst = os.path.join(clang_lib, 'include/sanitizer') 468 lib_dst = os.path.join(clang_lib, 'lib/linux') 469 install_directory(headers_src, headers_dst) 470 471 if not os.path.exists(lib_dst): 472 makedirs(lib_dst) 473 474 if host == 'linux-x86': 475 install_host_sanitizers(build_dir, host, lib_dst) 476 477 # Tuples of (product, arch) 478 product_to_arch = ( 479 ('generic', 'arm'), 480 ('generic_arm64', 'aarch64'), 481 ('generic_x86', 'i686'), 482 ('generic_mips', 'mips'), 483 ('generic_mips64', 'mips64'), 484 ) 485 486 sanitizers = ('asan', 'ubsan_standalone') 487 488 for product, arch in product_to_arch: 489 for sanitizer in sanitizers: 490 module = 'libclang_rt.{}-{}-android'.format(sanitizer, arch) 491 product_dir = os.path.join(build_dir, 'target/product', product) 492 lib_dir = os.path.join(product_dir, 'obj/SHARED_LIBRARIES', 493 '{}_intermediates'.format(module)) 494 lib_name = '{}.so'.format(module) 495 built_lib = os.path.join(lib_dir, 'PACKED', lib_name) 496 install_file(built_lib, lib_dst) 497 498 499# Also install the asan_test binaries. We need to do this because the 500# platform sources for compiler-rt are potentially different from our 501# toolchain sources. The only way to ensure that this test builds 502# correctly is to make it a prebuilt based on our latest toolchain 503# sources. Note that this is only created/compiled by the previous 504# stage (usually stage1) compiler. We are not doing a subsequent 505# compile with our stage2 binaries to construct any further 506# device-targeted objects. 507def install_sanitizer_tests(build_dir, install_dir, host): 508 # Tuples of (product, arch) 509 product_to_arch = ( 510 ('generic', 'arm'), 511 ('generic_arm64', 'aarch64'), 512 ('generic_x86', 'i686'), 513 ('generic_mips', 'mips'), 514 ('generic_mips64', 'mips64'), 515 ) 516 517 for product, arch in product_to_arch: 518 product_dir = os.path.join(build_dir, 'target/product', product) 519 test_module = 'asan_test' 520 test_dir = os.path.join(product_dir, 'obj/EXECUTABLES', 521 '{}_intermediates'.format(test_module)) 522 built_test = os.path.join(test_dir, 'PACKED', test_module) 523 test_dst = os.path.join(install_dir, 'test', arch, 'bin') 524 makedirs(test_dst) 525 install_file(built_test, test_dst) 526 527 528def install_host_sanitizers(build_dir, host, lib_dst): 529 # Tuples of (name, multilib). 530 libs = ( 531 ('asan', True), 532 ('asan_cxx', True), 533 ('ubsan_standalone', True), 534 ('ubsan_standalone_cxx', True), 535 ('tsan', False), 536 ('tsan_cxx', False), 537 ) 538 539 obj32 = os.path.join(build_dir, 'host', host, 'obj32/STATIC_LIBRARIES') 540 obj64 = os.path.join(build_dir, 'host', host, 'obj/STATIC_LIBRARIES') 541 for lib, is_multilib in libs: 542 built_lib_name = 'lib{}.a'.format(lib) 543 544 obj64_dir = os.path.join(obj64, 'lib{}_intermediates'.format(lib)) 545 lib64_name = 'libclang_rt.{}-x86_64.a'.format(lib) 546 built_lib64 = os.path.join(obj64_dir, built_lib_name) 547 install_file(built_lib64, os.path.join(lib_dst, lib64_name)) 548 if is_multilib: 549 obj32_dir = os.path.join(obj32, 'lib{}_intermediates'.format(lib)) 550 lib32_name = 'libclang_rt.{}-i686.a'.format(lib) 551 built_lib32 = os.path.join(obj32_dir, built_lib_name) 552 install_file(built_lib32, os.path.join(lib_dst, lib32_name)) 553 554 555def install_license_files(install_dir): 556 projects = ( 557 'clang', 558 'clang-tools-extra', 559 'compiler-rt', 560 'libcxx', 561 'libcxxabi', 562 'libunwind_llvm', 563 'llvm', 564 'openmp_llvm' 565 ) 566 567 notices = [] 568 for project in projects: 569 project_path = android_path('external', project) 570 license_pattern = os.path.join(project_path, 'MODULE_LICENSE_*') 571 for license_file in glob.glob(license_pattern): 572 install_file(license_file, install_dir) 573 with open(os.path.join(project_path, 'NOTICE')) as notice_file: 574 notices.append(notice_file.read()) 575 with open(os.path.join(install_dir, 'NOTICE'), 'w') as notice_file: 576 notice_file.write('\n'.join(notices)) 577 578 579def install_repo_prop(install_dir): 580 file_name = 'repo.prop' 581 582 dist_dir = os.environ.get('DIST_DIR') 583 if dist_dir is not None: 584 dist_repo_prop = os.path.join(dist_dir, file_name) 585 install_file(dist_repo_prop, install_dir) 586 else: 587 out_file = os.path.join(install_dir, file_name) 588 with open(out_file, 'w') as prop_file: 589 cmd = [ 590 'repo', 'forall', '-c', 591 'echo $REPO_PROJECT $(git rev-parse HEAD)', 592 ] 593 check_call(cmd, stdout=prop_file) 594 595 596def install_compiler_wrapper(install_dir, host): 597 is_windows = host.startswith('windows') 598 bin_ext = '.exe' if is_windows else '' 599 600 built_files = [ 601 'bin/clang' + bin_ext, 602 'bin/clang++' + bin_ext, 603 ] 604 605 if is_windows: 606 built_files.extend([ 607 'bin/clang_32' + bin_ext, 608 ]) 609 610 wrapper_dir = android_path('external/clang') 611 wrapper = os.path.join(wrapper_dir, 'compiler_wrapper') 612 613 for built_file in built_files: 614 old_file = os.path.join(install_dir, built_file) 615 new_file = os.path.join(install_dir, built_file + ".real") 616 rename(old_file, new_file) 617 install_file(wrapper, old_file) 618 619 620def parse_args(): 621 parser = argparse.ArgumentParser() 622 623 parser.add_argument('-j', action='store', dest='jobs', type=int, 624 default=multiprocessing.cpu_count(), 625 help='Specify number of executed jobs') 626 627 parser.add_argument( 628 '--build-name', default='dev', help='Release name for the package.') 629 parser.add_argument( 630 '--dry-run', action='store_true', default=False, 631 help='Skip running commands; just print.') 632 parser.add_argument( 633 '-v', '--verbose', action='store_true', default=False, 634 help='Print debug output.') 635 636 multi_stage_group = parser.add_mutually_exclusive_group() 637 multi_stage_group.add_argument( 638 '--multi-stage', action='store_true', default=True, 639 help='Perform multi-stage build (enabled by default).') 640 multi_stage_group.add_argument( 641 '--no-multi-stage', action='store_false', dest='multi_stage', 642 help='Do not perform multi-stage build.') 643 644 build_all_llvm_tools_group = parser.add_mutually_exclusive_group() 645 build_all_llvm_tools_group.add_argument( 646 '--build-all-llvm-tools', action='store_true', default=True, 647 help='Build all the LLVM tools/utilities.') 648 build_all_llvm_tools_group.add_argument( 649 '--no-build-all-llvm-tools', action='store_false', 650 dest='build_all_llvm_tools', 651 help='Do not build all the LLVM tools/utilities.') 652 653 build_debug_clang_group = parser.add_mutually_exclusive_group() 654 build_debug_clang_group.add_argument( 655 '--debug-clang', action='store_true', default=True, 656 help='Also generate a debug version of clang (enabled by default).') 657 build_debug_clang_group.add_argument( 658 '--no-debug-clang', action='store_false', 659 dest='debug_clang', 660 help='Skip generating a debug version of clang.') 661 662 return parser.parse_args() 663 664 665def main(): 666 args = parse_args() 667 log_level = logging.INFO 668 if args.verbose: 669 log_level = logging.DEBUG 670 logging.basicConfig(level=log_level) 671 672 logger().info('chdir %s', android_path()) 673 os.chdir(android_path()) 674 675 Config.dry_run = args.dry_run 676 677 if sys.platform.startswith('linux'): 678 hosts = ['linux-x86', 'windows-x86'] 679 elif sys.platform == 'darwin': 680 hosts = ['darwin-x86'] 681 else: 682 raise RuntimeError('Unsupported host: {}'.format(sys.platform)) 683 684 stage_1_out_dir = build_path('stage1') 685 686 # For a multi-stage build, build a minimum clang for the first stage that is 687 # just enough to build the second stage. 688 is_stage1_final = not args.multi_stage 689 build(out_dir=stage_1_out_dir, 690 build_all_clang_tools=is_stage1_final, 691 build_all_llvm_tools=(is_stage1_final and args.build_all_llvm_tools), 692 max_jobs=args.jobs) 693 final_out_dir = stage_1_out_dir 694 if args.multi_stage: 695 stage_1_install_dir = build_path('stage1-install') 696 for host in hosts: 697 package_name = 'clang-' + args.build_name 698 install_host_dir = os.path.join(stage_1_install_dir, host) 699 install_dir = os.path.join(install_host_dir, package_name) 700 701 # Remove any previously installed toolchain so it doesn't pollute 702 # the build. 703 if os.path.exists(install_host_dir): 704 rmtree(install_host_dir) 705 706 install_minimal_toolchain(stage_1_out_dir, install_dir, host, True) 707 708 stage_2_out_dir = build_path('stage2') 709 build(out_dir=stage_2_out_dir, prebuilts_path=stage_1_install_dir, 710 prebuilts_version=package_name, 711 build_all_clang_tools=True, 712 build_all_llvm_tools=args.build_all_llvm_tools, 713 max_jobs=args.jobs) 714 final_out_dir = stage_2_out_dir 715 716 if args.debug_clang: 717 debug_clang_out_dir = build_path('debug') 718 build(out_dir=debug_clang_out_dir, 719 prebuilts_path=stage_1_install_dir, 720 prebuilts_version=package_name, 721 build_all_clang_tools=True, 722 build_all_llvm_tools=args.build_all_llvm_tools, 723 debug_clang=args.debug_clang, 724 max_jobs=args.jobs) 725 # Install the actual debug toolchain somewhere, so it is easier to 726 # use. 727 debug_package_name = 'clang-debug' 728 base_debug_install_dir = build_path('debug-install') 729 for host in hosts: 730 debug_install_host_dir = os.path.join( 731 base_debug_install_dir, host) 732 debug_install_dir = os.path.join( 733 debug_install_host_dir, debug_package_name) 734 if os.path.exists(debug_install_host_dir): 735 rmtree(debug_install_host_dir) 736 install_toolchain( 737 debug_clang_out_dir, debug_install_dir, host, False) 738 739 dist_dir = ORIG_ENV.get('DIST_DIR', final_out_dir) 740 for host in hosts: 741 package_toolchain(final_out_dir, args.build_name, host, dist_dir) 742 743 744if __name__ == '__main__': 745 main() 746