668 lines
21 KiB
Python
668 lines
21 KiB
Python
#!/usr/bin/env python
|
|
#
|
|
# Copyright (C) 2015 The Android Open Source Project
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
#
|
|
"""Verifies that the build is sane.
|
|
|
|
Cleans old build artifacts, configures the required environment, determines
|
|
build goals, and invokes the build scripts.
|
|
"""
|
|
from __future__ import print_function
|
|
|
|
import argparse
|
|
import collections
|
|
import datetime
|
|
import inspect
|
|
import os
|
|
import shutil
|
|
import site
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import textwrap
|
|
|
|
site.addsitedir(os.path.join(os.path.dirname(__file__), 'build/lib'))
|
|
|
|
import build_support # pylint: disable=import-error
|
|
|
|
|
|
ALL_MODULES = {
|
|
'binutils',
|
|
'build',
|
|
'clang',
|
|
'cpufeatures',
|
|
'gabi++',
|
|
'gcc',
|
|
'gcclibs',
|
|
'gdbserver',
|
|
'gnustl',
|
|
'gtest',
|
|
'host-tools',
|
|
'libandroid_support',
|
|
'libc++',
|
|
'libc++abi',
|
|
'native_app_glue',
|
|
'ndk_helper',
|
|
'platforms',
|
|
'python-packages',
|
|
'stlport',
|
|
'system-stl',
|
|
}
|
|
|
|
|
|
class ArgParser(argparse.ArgumentParser):
|
|
def __init__(self):
|
|
super(ArgParser, self).__init__(
|
|
description=inspect.getdoc(sys.modules[__name__]))
|
|
|
|
self.add_argument(
|
|
'--arch',
|
|
choices=('arm', 'arm64', 'mips', 'mips64', 'x86', 'x86_64'),
|
|
help='Build for the given architecture. Build all by default.')
|
|
|
|
package_group = self.add_mutually_exclusive_group()
|
|
package_group.add_argument(
|
|
'--package', action='store_true', dest='package', default=True,
|
|
help='Package the NDK when done building (default).')
|
|
package_group.add_argument(
|
|
'--no-package', action='store_false', dest='package',
|
|
help='Do not package the NDK when done building.')
|
|
|
|
test_group = self.add_mutually_exclusive_group()
|
|
test_group.add_argument(
|
|
'--test', action='store_true', dest='test', default=True,
|
|
help=textwrap.dedent("""\
|
|
Run host tests when finished. --package is required. Not supported
|
|
when targeting Windows.
|
|
"""))
|
|
test_group.add_argument(
|
|
'--no-test', action='store_false', dest='test',
|
|
help='Do not run host tests when finished.')
|
|
|
|
self.add_argument(
|
|
'--release',
|
|
help='Release name. Package will be named android-ndk-RELEASE.')
|
|
|
|
self.add_argument(
|
|
'--system', choices=('darwin', 'linux', 'windows', 'windows64'),
|
|
default=build_support.get_default_host(),
|
|
help='Build for the given OS.')
|
|
|
|
module_group = self.add_mutually_exclusive_group()
|
|
|
|
module_group.add_argument(
|
|
'--module', choices=sorted(ALL_MODULES),
|
|
help='NDK modules to build.')
|
|
|
|
module_group.add_argument(
|
|
'--host-only', action='store_true',
|
|
help='Skip building target components.')
|
|
|
|
|
|
def _invoke_build(script, args):
|
|
if args is None:
|
|
args = []
|
|
subprocess.check_call([build_support.android_path(script)] + args)
|
|
|
|
|
|
def invoke_build(script, args=None):
|
|
script_path = os.path.join('build/tools', script)
|
|
_invoke_build(build_support.ndk_path(script_path), args)
|
|
|
|
|
|
def invoke_external_build(script, args=None):
|
|
_invoke_build(build_support.android_path(script), args)
|
|
|
|
|
|
def package_ndk(out_dir, dist_dir, args):
|
|
package_args = common_build_args(out_dir, dist_dir, args)
|
|
package_args.append(dist_dir)
|
|
|
|
if args.release is not None:
|
|
package_args.append('--release={}'.format(args.release))
|
|
|
|
if args.arch is not None:
|
|
package_args.append('--arch={}'.format(args.arch))
|
|
|
|
invoke_build('package.py', package_args)
|
|
|
|
|
|
def test_ndk(out_dir, args):
|
|
release = args.release
|
|
if args.release is None:
|
|
release = datetime.date.today().strftime('%Y%m%d')
|
|
|
|
# The packaging step extracts all the modules to a known directory for
|
|
# packaging. This directory is not cleaned up after packaging, so we can
|
|
# reuse that for testing.
|
|
test_dir = os.path.join(out_dir, 'android-ndk-{}'.format(release))
|
|
|
|
test_env = dict(os.environ)
|
|
test_env['NDK'] = test_dir
|
|
|
|
abis = build_support.ALL_ABIS
|
|
if args.arch is not None:
|
|
abis = build_support.arch_to_abis(args.arch)
|
|
|
|
results = {}
|
|
for abi in abis:
|
|
cmd = [
|
|
'python', build_support.ndk_path('tests/run-all.py'),
|
|
'--abi', abi, '--suite', 'build'
|
|
]
|
|
print('Running tests: {}'.format(' '.join(cmd)))
|
|
result = subprocess.call(cmd, env=test_env)
|
|
results[abi] = result == 0
|
|
|
|
print('Results:')
|
|
for abi, result in results.iteritems():
|
|
print('{}: {}'.format(abi, 'PASS' if result else 'FAIL'))
|
|
return all(results.values())
|
|
|
|
|
|
def common_build_args(out_dir, dist_dir, args):
|
|
build_args = ['--out-dir={}'.format(out_dir)]
|
|
build_args = ['--dist-dir={}'.format(dist_dir)]
|
|
build_args.append('--host={}'.format(args.system))
|
|
return build_args
|
|
|
|
|
|
def fixup_toolchain_triple(toolchain):
|
|
"""Maps toolchain names to their proper triple.
|
|
|
|
The x86 toolchains are named stupidly and aren't a proper triple.
|
|
"""
|
|
return {
|
|
'x86': 'i686-linux-android',
|
|
'x86_64': 'x86_64-linux-android',
|
|
}.get(toolchain, toolchain)
|
|
|
|
|
|
def get_binutils_files(triple, has_gold, is_windows):
|
|
files = [
|
|
'ld.bfd',
|
|
'nm',
|
|
'as',
|
|
'objcopy',
|
|
'strip',
|
|
'objdump',
|
|
'ld',
|
|
'ar',
|
|
'ranlib',
|
|
]
|
|
|
|
if has_gold:
|
|
files.append('ld.gold')
|
|
|
|
if is_windows:
|
|
files = [f + '.exe' for f in files]
|
|
|
|
# binutils programs get installed to two locations:
|
|
# 1: $INSTALL_DIR/bin/$TRIPLE-$PROGRAM
|
|
# 2: $INSTALL_DIR/$TRIPLE/bin/$PROGRAM
|
|
#
|
|
# We need to copy both.
|
|
|
|
prefixed_files = []
|
|
for file_name in files:
|
|
prefixed_name = '-'.join([triple, file_name])
|
|
prefixed_files.append(os.path.join('bin', prefixed_name))
|
|
|
|
dir_prefixed_files = []
|
|
for file_name in files:
|
|
dir_prefixed_files.append(os.path.join(triple, 'bin', file_name))
|
|
|
|
ldscripts_dir = os.path.join(triple, 'lib/ldscripts')
|
|
return prefixed_files + dir_prefixed_files + [ldscripts_dir]
|
|
|
|
|
|
def install_file(file_name, src_dir, dst_dir):
|
|
src_file = os.path.join(src_dir, file_name)
|
|
dst_file = os.path.join(dst_dir, file_name)
|
|
|
|
print('Copying {} to {}...'.format(src_file, dst_file))
|
|
if os.path.isdir(src_file):
|
|
_install_dir(src_file, dst_file)
|
|
elif os.path.islink(src_file):
|
|
_install_symlink(src_file, dst_file)
|
|
else:
|
|
_install_file(src_file, dst_file)
|
|
|
|
|
|
def _install_dir(src_dir, dst_dir):
|
|
parent_dir = os.path.normpath(os.path.join(dst_dir, '..'))
|
|
if not os.path.exists(parent_dir):
|
|
os.makedirs(parent_dir)
|
|
shutil.copytree(src_dir, dst_dir, symlinks=True)
|
|
|
|
|
|
def _install_symlink(src_file, dst_file):
|
|
dirname = os.path.dirname(dst_file)
|
|
if not os.path.exists(dirname):
|
|
os.makedirs(dirname)
|
|
link_target = os.readlink(src_file)
|
|
os.symlink(link_target, dst_file)
|
|
|
|
|
|
def _install_file(src_file, dst_file):
|
|
dirname = os.path.dirname(dst_file)
|
|
if not os.path.exists(dirname):
|
|
os.makedirs(dirname)
|
|
# copy2 is just copy followed by copystat (preserves file metadata).
|
|
shutil.copy2(src_file, dst_file)
|
|
|
|
|
|
def pack_binutils(arch, host_tag, out_dir, binutils_path):
|
|
archive_name = '-'.join(['binutils', arch, host_tag])
|
|
build_support.make_package(archive_name, binutils_path, out_dir)
|
|
|
|
|
|
def get_prebuilt_gcc(host, arch):
|
|
tag = build_support.host_to_tag(host)
|
|
system_subdir = 'prebuilts/ndk/current/toolchains/{}'.format(tag)
|
|
system_path = build_support.android_path(system_subdir)
|
|
toolchain = build_support.arch_to_toolchain(arch)
|
|
toolchain_dir = toolchain + '-4.9'
|
|
return os.path.join(system_path, toolchain_dir)
|
|
|
|
|
|
def build_binutils(out_dir, dist_dir, args):
|
|
print('Extracting binutils package from GCC...')
|
|
|
|
arches = build_support.ALL_ARCHITECTURES
|
|
if args.arch is not None:
|
|
arches = [args.arch]
|
|
|
|
host_tag = build_support.host_to_tag(args.system)
|
|
|
|
for arch in arches:
|
|
toolchain = build_support.arch_to_toolchain(arch)
|
|
toolchain_path = get_prebuilt_gcc(args.system, arch)
|
|
|
|
triple = fixup_toolchain_triple(toolchain)
|
|
|
|
install_dir = os.path.join(out_dir, 'binutils', triple)
|
|
if os.path.exists(install_dir):
|
|
shutil.rmtree(install_dir)
|
|
os.makedirs(install_dir)
|
|
|
|
has_gold = True
|
|
if host_tag == 'windows':
|
|
# Note: 64-bit Windows is fine.
|
|
has_gold = False
|
|
if arch in ('mips', 'mips64'):
|
|
has_gold = False
|
|
|
|
is_windows = host_tag.startswith('windows')
|
|
for file_name in get_binutils_files(triple, has_gold, is_windows):
|
|
install_file(file_name, toolchain_path, install_dir)
|
|
|
|
license_path = build_support.android_path(
|
|
'toolchain/binutils/binutils-2.25/COPYING')
|
|
shutil.copy2(license_path, os.path.join(install_dir, 'NOTICE'))
|
|
|
|
pack_binutils(arch, host_tag, dist_dir, install_dir)
|
|
|
|
|
|
def build_clang(out_dir, dist_dir, args):
|
|
print('Building Clang...')
|
|
invoke_build('build-llvm.py', common_build_args(out_dir, dist_dir, args))
|
|
|
|
|
|
def build_gcc(out_dir, dist_dir, args):
|
|
print('Building GCC...')
|
|
build_args = common_build_args(out_dir, dist_dir, args)
|
|
if args.arch is not None:
|
|
build_args.append('--arch={}'.format(args.arch))
|
|
invoke_build('build-gcc.py', build_args)
|
|
|
|
|
|
def build_gcc_libs(out_dir, dist_dir, args):
|
|
print('Packaging GCC libs...')
|
|
|
|
arches = build_support.ALL_ARCHITECTURES
|
|
if args.arch is not None:
|
|
arches = [args.arch]
|
|
|
|
for arch in arches:
|
|
toolchain = build_support.arch_to_toolchain(arch)
|
|
triple = fixup_toolchain_triple(toolchain)
|
|
libgcc_subdir = 'lib/gcc/{}/4.9'.format(triple)
|
|
is64 = arch.endswith('64')
|
|
libatomic_subdir = '{}/lib{}'.format(triple, '64' if is64 else '')
|
|
|
|
lib_names = [
|
|
(libatomic_subdir, 'libatomic.a'),
|
|
(libgcc_subdir, 'libgcc.a'),
|
|
]
|
|
|
|
lib_dirs = ['']
|
|
if arch == 'arm':
|
|
lib_dirs += [
|
|
'armv7-a',
|
|
'armv7-a/hard',
|
|
'armv7-a/thumb',
|
|
'armv7-a/thumb/hard',
|
|
'thumb',
|
|
]
|
|
|
|
libs = []
|
|
for lib_dir in lib_dirs:
|
|
for subdir, lib in lib_names:
|
|
libs.append((subdir, os.path.join(lib_dir, lib)))
|
|
|
|
install_dir = os.path.join(out_dir, 'gcclibs', triple)
|
|
if os.path.exists(install_dir):
|
|
shutil.rmtree(install_dir)
|
|
os.makedirs(install_dir)
|
|
|
|
# These are target libraries, so the OS we use here is not
|
|
# important. We explicitly use Linux because for whatever reason
|
|
# the Windows aarch64 toolchain doesn't include libatomic.
|
|
gcc_path = get_prebuilt_gcc('linux', arch)
|
|
for gcc_subdir, lib in libs:
|
|
src = os.path.join(gcc_path, gcc_subdir, lib)
|
|
dst = os.path.join(install_dir, lib)
|
|
dst_dir = os.path.dirname(dst)
|
|
if not os.path.exists(dst_dir):
|
|
os.makedirs(dst_dir)
|
|
shutil.copy2(src, dst)
|
|
|
|
shutil.copy2(
|
|
os.path.join(gcc_path, 'NOTICE'),
|
|
os.path.join(install_dir, 'NOTICE'))
|
|
|
|
archive_name = os.path.join('gcclibs-' + arch)
|
|
build_support.make_package(archive_name, install_dir, dist_dir)
|
|
|
|
|
|
def build_host_tools(out_dir, dist_dir, args):
|
|
build_args = common_build_args(out_dir, dist_dir, args)
|
|
|
|
print('Building ndk-stack...')
|
|
invoke_external_build(
|
|
'ndk/sources/host-tools/ndk-stack/build.py', build_args)
|
|
|
|
print('Building ndk-depends...')
|
|
invoke_external_build(
|
|
'ndk/sources/host-tools/ndk-depends/build.py', build_args)
|
|
|
|
print('Building awk...')
|
|
invoke_external_build(
|
|
'ndk/sources/host-tools/nawk-20071023/build.py', build_args)
|
|
|
|
print('Building make...')
|
|
invoke_external_build(
|
|
'ndk/sources/host-tools/make-3.81/build.py', build_args)
|
|
|
|
if args.system in ('windows', 'windows64'):
|
|
print('Building toolbox...')
|
|
invoke_external_build(
|
|
'ndk/sources/host-tools/toolbox/build.py', build_args)
|
|
|
|
print('Building Python...')
|
|
invoke_external_build('toolchain/python/build.py', build_args)
|
|
|
|
print('Building GDB...')
|
|
invoke_external_build('toolchain/gdb/build.py', build_args)
|
|
|
|
print('Building YASM...')
|
|
invoke_external_build('toolchain/yasm/build.py', build_args)
|
|
|
|
package_host_tools(out_dir, dist_dir, args.system)
|
|
|
|
|
|
def merge_license_files(output_path, files):
|
|
licenses = []
|
|
for license_path in files:
|
|
with open(license_path) as license_file:
|
|
licenses.append(license_file.read())
|
|
|
|
with open(output_path, 'w') as output_file:
|
|
output_file.write('\n'.join(licenses))
|
|
|
|
|
|
def package_host_tools(out_dir, dist_dir, host):
|
|
packages = [
|
|
'gdb-multiarch-7.10',
|
|
'ndk-awk',
|
|
'ndk-depends',
|
|
'ndk-make',
|
|
'ndk-python',
|
|
'ndk-stack',
|
|
'ndk-yasm',
|
|
]
|
|
|
|
files = [
|
|
'ndk-gdb',
|
|
'ndk-gdb.cmd',
|
|
'ndk-gdb.py',
|
|
]
|
|
|
|
if host in ('windows', 'windows64'):
|
|
packages.append('toolbox')
|
|
|
|
host_tag = build_support.host_to_tag(host)
|
|
|
|
package_names = [p + '-' + host_tag + '.tar.bz2' for p in packages]
|
|
for package_name in package_names:
|
|
package_path = os.path.join(out_dir, package_name)
|
|
subprocess.check_call(['tar', 'xf', package_path, '-C', out_dir])
|
|
|
|
for f in files:
|
|
shutil.copy2(f, os.path.join(out_dir, 'host-tools/bin'))
|
|
|
|
merge_license_files(os.path.join(out_dir, 'host-tools/NOTICE'), [
|
|
build_support.android_path('toolchain/gdb/gdb-7.10/COPYING'),
|
|
build_support.ndk_path('sources/host-tools/nawk-20071023/NOTICE'),
|
|
build_support.ndk_path('sources/host-tools/ndk-depends/NOTICE'),
|
|
build_support.ndk_path('sources/host-tools/make-3.81/COPYING'),
|
|
build_support.android_path(
|
|
'toolchain/python/Python-2.7.5/LICENSE'),
|
|
build_support.ndk_path('sources/host-tools/ndk-stack/NOTICE'),
|
|
build_support.ndk_path('sources/host-tools/toolbox/NOTICE'),
|
|
build_support.android_path('toolchain/yasm/COPYING'),
|
|
build_support.android_path('toolchain/yasm/BSD.txt'),
|
|
build_support.android_path('toolchain/yasm/Artistic.txt'),
|
|
build_support.android_path('toolchain/yasm/GNU_GPL-2.0'),
|
|
build_support.android_path('toolchain/yasm/GNU_LGPL-2.0'),
|
|
])
|
|
|
|
package_name = 'host-tools-' + host_tag
|
|
path = os.path.join(out_dir, 'host-tools')
|
|
build_support.make_package(package_name, path, dist_dir)
|
|
|
|
|
|
def build_gdbserver(out_dir, dist_dir, args):
|
|
print('Building gdbserver...')
|
|
build_args = common_build_args(out_dir, dist_dir, args)
|
|
if args.arch is not None:
|
|
build_args.append('--arch={}'.format(args.arch))
|
|
invoke_build('build-gdbserver.py', build_args)
|
|
|
|
|
|
def _build_stl(out_dir, dist_dir, args, stl):
|
|
build_args = common_build_args(out_dir, dist_dir, args)
|
|
if args.arch is not None:
|
|
build_args.append('--arch={}'.format(args.arch))
|
|
script = 'ndk/sources/cxx-stl/{}/build.py'.format(stl)
|
|
invoke_external_build(script, build_args)
|
|
|
|
|
|
def build_gnustl(out_dir, dist_dir, args):
|
|
print('Building gnustl...')
|
|
_build_stl(out_dir, dist_dir, args, 'gnu-libstdc++')
|
|
|
|
|
|
def build_libcxx(out_dir, dist_dir, args):
|
|
print('Building libc++...')
|
|
_build_stl(out_dir, dist_dir, args, 'llvm-libc++')
|
|
|
|
|
|
def build_stlport(out_dir, dist_dir, args):
|
|
print('Building stlport...')
|
|
_build_stl(out_dir, dist_dir, args, 'stlport')
|
|
|
|
|
|
def build_platforms(out_dir, dist_dir, args):
|
|
print('Building platforms...')
|
|
build_args = common_build_args(out_dir, dist_dir, args)
|
|
invoke_build('build-platforms.py', build_args)
|
|
|
|
|
|
def build_cpufeatures(_, dist_dir, __):
|
|
path = build_support.ndk_path('sources/android/cpufeatures')
|
|
build_support.make_package('cpufeatures', path, dist_dir)
|
|
|
|
|
|
def build_native_app_glue(_, dist_dir, __):
|
|
path = build_support.android_path(
|
|
'development/ndk/sources/android/native_app_glue')
|
|
build_support.make_package('native_app_glue', path, dist_dir)
|
|
|
|
|
|
def build_ndk_helper(_, dist_dir, __):
|
|
path = build_support.android_path(
|
|
'development/ndk/sources/android/ndk_helper')
|
|
build_support.make_package('ndk_helper', path, dist_dir)
|
|
|
|
|
|
def build_gtest(_, dist_dir, __):
|
|
path = build_support.ndk_path('sources/third_party/googletest')
|
|
build_support.make_package('gtest', path, dist_dir)
|
|
|
|
|
|
def build_build(_, dist_dir, __):
|
|
path = build_support.ndk_path('build')
|
|
build_support.make_package('build', path, dist_dir)
|
|
|
|
|
|
def build_python_packages(_, dist_dir, __):
|
|
# Stage the files in a temporary directory to make things easier.
|
|
temp_dir = tempfile.mkdtemp()
|
|
try:
|
|
path = os.path.join(temp_dir, 'python-packages')
|
|
shutil.copytree(
|
|
build_support.android_path('development/python-packages'), path)
|
|
build_support.make_package('python-packages', path, dist_dir)
|
|
finally:
|
|
shutil.rmtree(temp_dir)
|
|
|
|
|
|
def build_gabixx(_out_dir, dist_dir, _args):
|
|
print('Building gabi++...')
|
|
path = build_support.ndk_path('sources/cxx-stl/gabi++')
|
|
build_support.make_package('gabixx', path, dist_dir)
|
|
|
|
|
|
def build_system_stl(_out_dir, dist_dir, _args):
|
|
print('Building system-stl...')
|
|
path = build_support.ndk_path('sources/cxx-stl/system')
|
|
build_support.make_package('system-stl', path, dist_dir)
|
|
|
|
|
|
def build_libandroid_support(_out_dir, dist_dir, _args):
|
|
print('Building libandroid_support...')
|
|
path = build_support.ndk_path('sources/android/support')
|
|
build_support.make_package('libandroid_support', path, dist_dir)
|
|
|
|
|
|
def build_libcxxabi(_out_dir, dist_dir, _args):
|
|
print('Building libc++abi...')
|
|
path = build_support.ndk_path('sources/cxx-stl/llvm-libc++abi')
|
|
build_support.make_package('libcxxabi', path, dist_dir)
|
|
|
|
|
|
def main():
|
|
parser = ArgParser()
|
|
args = parser.parse_args()
|
|
|
|
if args.module is None:
|
|
modules = ALL_MODULES
|
|
else:
|
|
modules = {args.module}
|
|
|
|
if args.host_only:
|
|
modules = {
|
|
'clang',
|
|
'gcc',
|
|
'host-tools',
|
|
}
|
|
|
|
required_package_modules = ALL_MODULES
|
|
if args.package and required_package_modules <= modules:
|
|
do_package = True
|
|
else:
|
|
do_package = False
|
|
|
|
# TODO(danalbert): wine?
|
|
# We're building the Windows packages from Linux, so we can't actually run
|
|
# any of the tests from here.
|
|
if args.system.startswith('windows') or not do_package:
|
|
args.test = False
|
|
|
|
# Disable buffering on stdout so the build output doesn't hide all of our
|
|
# "Building..." messages.
|
|
sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)
|
|
|
|
os.chdir(os.path.dirname(os.path.realpath(__file__)))
|
|
|
|
# Set ANDROID_BUILD_TOP.
|
|
if 'ANDROID_BUILD_TOP' not in os.environ:
|
|
os.environ['ANDROID_BUILD_TOP'] = os.path.realpath('..')
|
|
|
|
out_dir = build_support.get_out_dir()
|
|
dist_dir = build_support.get_dist_dir(out_dir)
|
|
|
|
print('Cleaning up...')
|
|
invoke_build('dev-cleanup.sh')
|
|
|
|
module_builds = collections.OrderedDict([
|
|
('binutils', build_binutils),
|
|
('build', build_build),
|
|
('clang', build_clang),
|
|
('cpufeatures', build_cpufeatures),
|
|
('gabi++', build_gabixx),
|
|
('gcc', build_gcc),
|
|
('gcclibs', build_gcc_libs),
|
|
('gdbserver', build_gdbserver),
|
|
('gnustl', build_gnustl),
|
|
('gtest', build_gtest),
|
|
('host-tools', build_host_tools),
|
|
('libandroid_support', build_libandroid_support),
|
|
('libc++', build_libcxx),
|
|
('libc++abi', build_libcxxabi),
|
|
('native_app_glue', build_native_app_glue),
|
|
('ndk_helper', build_ndk_helper),
|
|
('platforms', build_platforms),
|
|
('python-packages', build_python_packages),
|
|
('stlport', build_stlport),
|
|
('system-stl', build_system_stl),
|
|
])
|
|
|
|
print('Building modules: {}'.format(' '.join(modules)))
|
|
for module in modules:
|
|
module_builds[module](out_dir, dist_dir, args)
|
|
|
|
if do_package:
|
|
package_ndk(out_dir, dist_dir, args)
|
|
|
|
if args.test:
|
|
result = test_ndk(out_dir, args)
|
|
sys.exit(0 if result else 1)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|