| #!/bin/sh |
| # |
| # Copyright (C) 2012 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. |
| # |
| # Rebuild the host GCC toolchain binaries from sources. |
| # |
| # NOTE: this script does not rebuild gdb, see build-host-gdb.sh for this. |
| # |
| |
| # include common function and variable definitions |
| . `dirname $0`/prebuilt-common.sh |
| |
| PROGRAM_PARAMETERS="[<toolchain-name>+]" |
| PROGRAM_DESCRIPTION="\ |
| This program is used to rebuild one or more NDK cross-toolchains from scratch. |
| To use it, you will first need to call download-toolchain-sources.sh to download |
| the toolchain sources, then pass the corresponding directory with the |
| --toolchain-src-dir=<path> option. |
| |
| If you don't pass any parameter, the script will rebuild all NDK toolchains |
| for the current host system [$HOST_TAG]. You can otherwise give a list of |
| toolchains among the following names: |
| |
| arm-linux-androideabi-4.8 |
| arm-linux-androideabi-4.9 |
| x64-4.8 |
| x86-4.9 |
| mipsel-linux-android-4.8 |
| mipsel-linux-android-4.9 |
| aarch64-linux-android-4.9 |
| mips64el-linux-android-4.9 |
| x86_64-4.9 |
| |
| By default, the script rebuilds the toolchain(s) for you host system [$HOST_TAG], |
| but you can use --systems=<tag1>,<tag2>,.. to ask binaries that can run on |
| several distinct systems. Each <tag> value in the list can be one of the |
| following: |
| |
| linux-x86 |
| linux-x86_64 |
| windows |
| windows-x86 (equivalent to 'windows') |
| windows-x86_64 |
| darwin-x86 |
| darwin-x86_64 |
| |
| For example, here's how to rebuild the ARM toolchains on Linux |
| for four different systems: |
| |
| $PROGNAME --toolchain-src-dir=/path/to/toolchain/src \ |
| --systems=linux-x86,linux-x86_64,windows,windows-x86_64 \ |
| arm-linux-androideabi-4.8 \ |
| arm-linux-androideabi-4.9 |
| |
| You can build Windows binaries on Linux if you have a Windows-targetting |
| cross-toolchain installed and in your path. Note that the script named |
| 'build-mingw64-toolchain.sh' can be used to rebuild such a toolchain |
| (x86_64-w64-mingw32) from sources if you don't have one available. |
| |
| Building the toolchains directly under Cygwin/MSys has not be tested and |
| is not recommended (it will be *extremely* slow, if it ever works). |
| |
| On Darwin, the script will try to probe any compatibility SDK installed |
| on your development machine and will use the first it finds among a list |
| of well-known names. You can however force a specific usage with the |
| --darwin-sdk-version=<version> name, where <version> can be one of 10.4, 10.5, |
| 10.6, 10.7, etc. |
| |
| The generated binaries should run on 10.5 or higher. You can force a |
| different compatibility minimum with --darwin-min-version. |
| |
| If you want to build Darwin binaries on a non-Darwin machine, you will |
| have to define DARWIN_TOOLCHAIN / DARWIN_SYSROOT in your environment first |
| (note: this feature is highly experimental). |
| |
| The script is sufficiently clever to minimize all build steps, especially |
| if you try to build several toolchains for several distinct host systems. Note |
| however that generating a canadian-cross toolchain (e.g. building on Linux a |
| Windows toolchain that targets Android ARM binaries) will force the generation |
| of a host toolchain as well, in case it is not listed in your --systems list. |
| This is required to generate proper target GCC libraries. |
| |
| The toolchain binaries are installed under \$NDK_DIR/toolchains by default, |
| but you can use --ndk-dir=<path> to specify a different NDK installation path. |
| The script will try to build the Gold linker for host/target combination that |
| are well supported (Gold doesn't build / is buggy for some of them). However, |
| the BFD linker is still the default used by the generated toolchain. You can |
| change this behaviour with two options: |
| |
| --default-ld=<name> Changes the default toolchain linker. |
| <name> can be one of 'default', 'bfd' and 'gold'. |
| |
| For now, 'default' is an alias for 'bfd', but we plan |
| to map it to 'gold' for some combos in the future, once |
| we're confident it works reliably |
| |
| --force-gold-build Force the build of the Gold linker, even if it is known |
| to fail or generate a buggy linker. Only use this for |
| experimentation (e.g. with your own patched toolchain |
| sources). |
| " |
| |
| BINUTILS_VERSION=$DEFAULT_BINUTILS_VERSION |
| register_var_option "--binutils-version=<version>" BINUTILS_VERSION "Select binutils version" |
| |
| GMP_VERSION=$DEFAULT_GMP_VERSION |
| register_var_option "--gmp-version=<version>" GMP_VERSION "Select gmp version" |
| |
| MPFR_VERSION=$DEFAULT_MPFR_VERSION |
| register_var_option "--mpfr-version=<version>" MPFR_VERSION "Select mpfr version" |
| |
| MPC_VERSION=$DEFAULT_MPC_VERSION |
| register_var_option "--mpc-version=<version>" MPC_VERSION "Select mpc version" |
| |
| TOOLCHAIN_SRC_DIR= |
| register_var_option "--toolchain-src-dir=<path>" TOOLCHAIN_SRC_DIR "Select toolchain source directory" |
| |
| NDK_DIR=$ANDROID_NDK_ROOT |
| register_var_option "--ndk-dir=<path>" NDK_DIR "Select NDK install directory" |
| |
| BUILD_DIR= |
| register_var_option "--build-dir=<path>" BUILD_DIR "Build GCC into directory" |
| |
| PACKAGE_DIR= |
| register_var_option "--package-dir=<path>" PACKAGE_DIR "Package prebuilt tarballs into directory" |
| |
| HOST_SYSTEMS="$HOST_TAG" |
| register_var_option "--systems=<list>" HOST_SYSTEMS "Build binaries for these host systems" |
| |
| FORCE= |
| register_var_option "--force" FORCE "Force full rebuild" |
| |
| NO_TARGET_LIBS= |
| register_var_option "--no-target-libs" NO_TARGET_LIBS "Don't build gcc target libs." |
| |
| NO_STRIP= |
| register_var_option "--no-strip" NO_STRIP "Don't strip generated binaries." |
| |
| NO_COLOR= |
| register_var_option "--no-color" NO_COLOR "Don't output colored text." |
| |
| if [ "$HOST_OS" = darwin ]; then |
| DARWIN_SDK_VERSION= |
| register_var_option "--darwin-sdk-version=<version>" DARWIN_SDK "Select Darwin SDK version." |
| |
| DARWIN_MIN_VERSION= |
| register_var_option "--darwin-min-version=<version>" DARWIN_MIN_VERSION "Select minimum OS X version of generated host toolchains." |
| fi |
| |
| DEFAULT_LD= |
| register_var_option "--default-ld=<name>" DEFAULT_LD "Select default linker ('bfd' or 'gold')." |
| |
| FORCE_GOLD_BUILD= |
| register_var_option "--force-gold-build" FORCE_GOLD_BUILD "Always try to build Gold (experimental)." |
| |
| register_jobs_option |
| |
| |
| extract_parameters "$@" |
| |
| TOOLCHAINS=$PARAMETERS |
| if [ -z "$TOOLCHAINS" ]; then |
| TOOLCHAINS="arm-linux-androideabi-4.8,x86-4.8,mipsel-linux-android-4.8" |
| dump "Auto-config: $TOOLCHAINS" |
| fi |
| |
| if [ -z "$TOOLCHAIN_SRC_DIR" ]; then |
| panic "Please use --toolchain-src-dir=<path> to select toolchain source directory." |
| fi |
| |
| if [ -z "$BUILD_DIR" ]; then |
| BUILD_DIR=/tmp/ndk-$USER/build/host-gcc |
| fi |
| |
| case $DEFAULT_LD in |
| gold|bfd) |
| ;; |
| "") |
| # We always use the default gold linker. |
| # bfd is used for some of the older toolchains or archs not supported by gold. |
| DEFAULT_LD=gold |
| ;; |
| *) |
| panic "Invalid --default-ld name '$DEFAULT_LD', valid values are: bfd gold" |
| ;; |
| esac |
| |
| HOST_SYSTEMS=$(commas_to_spaces $HOST_SYSTEMS) |
| TOOLCHAINS=$(commas_to_spaces $TOOLCHAINS) |
| |
| # The values of HOST_OS/ARCH/TAG will be redefined during the build to |
| # match those of the system the generated compiler binaries will run on. |
| # |
| # Save the original ones into BUILD_XXX variants, corresponding to the |
| # machine where the build happens. |
| # |
| BUILD_OS=$HOST_OS |
| BUILD_ARCH=$HOST_ARCH |
| BUILD_TAG=$HOST_TAG |
| |
| # Important note: When identifying a build or host system, there is |
| # a difference between 'NDK system tags' and "GNU configuration triplet'. |
| # |
| # A "system tag" is specific to the NDK and identifies a given host |
| # system for the toolchain binaries, valid values: |
| # |
| # linux-x86 |
| # linux-x86_64 |
| # windows (historical alias to windows-x86) |
| # windows-x86 |
| # windows-x86_64 |
| # darwin-x86 |
| # darwin-x86_64 |
| # |
| # A GNU configuration triplet identifies a system too, but it used by |
| # configure scripts, not the NDK. They vary a lot too and some of the |
| # scripts are *very* picky about the exact values being used. |
| # |
| # Typical values that are known to work properly: |
| # |
| # i686-linux-gnu (Linux x86 system, with GNU libc) |
| # x86_64-linux-gnu (Same, with x86_64 CPU) |
| # i586-mingw32msvc (Windows 32-bits, MSVCRT.DLL) |
| # i586-pc-mingw32msvc (same) |
| # i686-w64-mingw32 (same, slightly different sources) |
| # x86_64-w64-mingw32 (Windows 64-bits, MSVCRT.DLL) |
| # i686-apple-darwin (OS X / Darwin, x86 CPU) |
| # x86_64-apple-darwin (OS X / Darwin, x86_64 CPU) |
| # |
| # A cross-toolchain will typically use the GNU configuration triplet as |
| # a prefix for all its binaries, but not always. For example, the 'mingw32' |
| # package on Ubuntu provides a Windows cross-toolchain that uses the |
| # i586-mingw32msvc prefix, but if you try to use it as a configuration |
| # triplet when configuring binutils-2.21, the build will fail. You need to |
| # pass i586-pc-mingw32msvc instead (binutils-2.19 accepts both). |
| # |
| # Another issue is that some toolchains need to use additional compiler |
| # flags to deal with backwards-compatibility SDKs (Darwin) or 32/64 bit |
| # code generation. Note all build scripts accept the same mix of |
| # '--with-cflags=...' or 'export CFLAGS' configuration, which makes |
| # things pretty difficult to manage. |
| # |
| # To work-around these issues, the script will generate "wrapper toolchains" |
| # with the prefix that the configure scripts expects. I.e. small scripts that |
| # redirect to the correct toolchain, eventually adding hidden extra compiler |
| # flags. This seems to completely get rid of the problems described above. |
| # |
| |
| |
| # $1: system tag (e.g. linux-x86) |
| tag_to_os () |
| { |
| local RET |
| case $1 in |
| linux-*) RET="linux";; |
| darwin-*) RET="darwin";; |
| windows|windows-*) RET="windows";; |
| esac |
| echo $RET |
| } |
| |
| # $1: system tag (e.g. linux-x86) |
| tag_to_arch () |
| { |
| local RET |
| case $1 in |
| windows|*-x86) RET=x86;; |
| *-x86_64) RET=x86_64;; |
| esac |
| echo $RET |
| } |
| |
| # $1: system tag (e.g. linux-x86) |
| tag_to_bits () |
| { |
| local RET |
| case $1 in |
| windows|*-x86) RET=32;; |
| *-x86_64) RET=64;; |
| esac |
| echo $RET |
| } |
| |
| if [ "$NO_COLOR" ]; then |
| COLOR_GREEN= |
| COLOR_PURPLE= |
| COLOR_CYAN= |
| COLOR_END= |
| else |
| COLOR_GREEN="\e[32m" |
| COLOR_PURPLE="\e[35m" |
| COLOR_CYAN="\e[36m" |
| COLOR_END="\e[0m" |
| fi |
| |
| # Pretty printing with colors! |
| host_text () |
| { |
| printf "[${COLOR_GREEN}${HOST}${COLOR_END}]" |
| } |
| |
| toolchain_text () |
| { |
| printf "[${COLOR_PURPLE}${TOOLCHAIN}${COLOR_END}]" |
| } |
| |
| target_text () |
| { |
| printf "[${COLOR_CYAN}${TARGET}${COLOR_END}]" |
| } |
| |
| arch_text () |
| { |
| # Print arch name in cyan |
| printf "[${COLOR_CYAN}${ARCH}${COLOR_END}]" |
| } |
| |
| # We're going to cheat a little here. If we're only building a linux-x86 |
| # on a linux-x86_64 machine, we want to change the value of BUILD_TAG |
| # to linux-x86 instead to speed-up the build. |
| # |
| # More generally speaking, we need to verify that if: |
| # - we build a $BUILD_OS-x86 toolchain on a $BUILD_OS-x86_64 machine |
| # - we don't want to build $BUILD_OS-x86_64 either. |
| # |
| # Then we can change our BUILD values to $BUILD_OS-x86 |
| # This assumes that the build machine's toolchain can generate both |
| # 32-bit and 64-bit binaries with either -m32 or -m64 |
| # |
| BUILD_BUILD_32= |
| BUILD_BUILD_64= |
| for SYSTEM in $HOST_SYSTEMS; do |
| if [ "$(tag_to_os $SYSTEM)" = "$BUILD_OS" ]; then |
| BUILD_BUILD_OS=true |
| case $(tag_to_bits $SYSTEM) in |
| 32) BUILD_BUILD_32=true;; |
| 64) BUILD_BUILD_64=true;; |
| esac |
| fi |
| done |
| |
| case $(tag_to_bits $BUILD_TAG) in |
| 64) |
| # Building on a 64-bit machine |
| if [ "$BUILD_BUILD_32" -a -z "$BUILD_BUILD_64" ]; then |
| # Ok, we want to build a 32-bit toolchain on a 64-bit machine |
| # So cheat a little now :-) |
| BUILD_ARCH=x86 |
| BUILD_TAG=$BUILD_OS-$BUILD_ARCH |
| dump "Forcing build config: $BUILD_TAG" |
| fi |
| ;; |
| esac |
| |
| BUILD_BITS=$(tag_to_bits $BUILD_TAG) |
| |
| # On Darwin, parallel installs of certain libraries do not work on |
| # some multi-core machines. So define NUM_BUILD_JOBS as 1 on this |
| # platform. |
| case $BUILD_OS in |
| darwin) NUM_INSTALL_JOBS=1;; |
| *) NUM_INSTALL_JOBS=$NUM_JOBS;; |
| esac |
| |
| tag_to_config_triplet () |
| { |
| local RET |
| case $1 in |
| linux-x86) RET=i686-linux-gnu;; |
| linux-x86_64) RET=x86_64-linux-gnu;; |
| darwin-x86) RET=i686-apple-darwin;; |
| darwin-x86_64) RET=x86_64-apple-darwin;; |
| windows|windows-x86) RET=i586-pc-mingw32msvc;; |
| windows-x86_64) RET=x86_64-w64-mingw32;; |
| esac |
| echo "$RET" |
| } |
| |
| run_on_setup () |
| { |
| if [ "$PHASE" = setup ]; then |
| run "$@" |
| fi |
| } |
| |
| setup_build () |
| { |
| run_on_setup mkdir -p "$BUILD_DIR" |
| if [ -n "$FORCE" ]; then |
| rm -rf "$BUILD_DIR"/* |
| fi |
| |
| TOP_BUILD_DIR=$BUILD_DIR |
| |
| setup_default_log_file $BUILD_DIR/build.log |
| |
| WRAPPERS_DIR="$BUILD_DIR/toolchain-wrappers" |
| run_on_setup mkdir -p "$WRAPPERS_DIR" && run_on_setup rm -rf "$WRAPPERS_DIR/*" |
| |
| STAMPS_DIR="$BUILD_DIR/timestamps" |
| run_on_setup mkdir -p "$STAMPS_DIR" |
| if [ -n "$FORCE" ]; then |
| run_on_setup rm -f "$STAMPS_DIR"/* |
| fi |
| |
| if [ "$PACKAGE_DIR" ]; then |
| mkdir -p "$PACKAGE_DIR" |
| fail_panic "Can't create packaging directory: $PACKAGE_DIR" |
| fi |
| |
| BUILD=$(tag_to_config_triplet $BUILD_TAG) |
| } |
| |
| stamps_do () |
| { |
| local NAME=$1 |
| shift |
| if [ ! -f "$STAMPS_DIR/$NAME" ]; then |
| "$@" |
| fail_panic |
| mkdir -p "$STAMPS_DIR" && touch "$STAMPS_DIR/$NAME" |
| fi |
| } |
| |
| # Check that a given compiler generates code correctly |
| # |
| # This is to detect bad/broken toolchains, e.g. amd64-mingw32msvc |
| # is totally broken on Ubuntu 10.10 and 11.04 |
| # |
| # $1: compiler |
| # $2: optional extra flags |
| # |
| check_compiler () |
| { |
| local CC="$1" |
| local TMPC=/tmp/build-host-gcc-$USER-$$.c |
| local TMPE=${TMPC%%.c} |
| local TMPL=$TMPC.log |
| local RET |
| shift |
| cat > $TMPC <<EOF |
| int main(void) { return 0; } |
| EOF |
| log_n "Checking compiler code generation ($CC)... " |
| $CC -o $TMPE $TMPC "$@" >$TMPL 2>&1 |
| RET=$? |
| rm -f $TMPC $TMPE $TMPL |
| if [ "$RET" = 0 ]; then |
| log "yes" |
| else |
| log "no" |
| fi |
| return $RET |
| } |
| |
| |
| # $1: toolchain install dir |
| # $2: toolchain prefix, no trailing dash (e.g. arm-linux-androideabi) |
| # $3: optional -m32 or -m64. |
| try_host_fullprefix () |
| { |
| local PREFIX="$1/bin/$2" |
| shift; shift; |
| if [ -z "$HOST_FULLPREFIX" ]; then |
| local GCC="$PREFIX-gcc" |
| if [ -f "$GCC" ]; then |
| if check_compiler "$GCC" "$@"; then |
| HOST_FULLPREFIX="${GCC%%gcc}" |
| dump "$(host_text) Using host gcc: $GCC $@" |
| else |
| dump "$(host_text) Ignoring broken host gcc: $GCC $@" |
| fi |
| fi |
| fi |
| } |
| |
| # $1: host prefix, no trailing slash (e.g. i686-linux-android) |
| # $2: optional compiler args (should be empty, -m32 or -m64) |
| try_host_prefix () |
| { |
| local PREFIX="$1" |
| shift |
| if [ -z "$HOST_FULLPREFIX" ]; then |
| local GCC="$(which $PREFIX-gcc 2>/dev/null)" |
| if [ "$GCC" -a -e "$GCC" ]; then |
| if check_compiler "$GCC" "$@"; then |
| HOST_FULLPREFIX=${GCC%%gcc} |
| dump "$(host_text) Using host gcc: ${HOST_FULLPREFIX}gcc $@" |
| else |
| dump "$(host_text) Ignoring broken host gcc: $GCC $@" |
| fi |
| fi |
| fi |
| } |
| |
| # Used to determine the minimum possible Darwin version that a Darwin SDK |
| # can target. This actually depends from the host architecture. |
| # $1: Host architecture name |
| # out: SDK version number (e.g. 10.4 or 10.5) |
| darwin_arch_to_min_version () |
| { |
| if [ "$DARWIN_MIN_VERSION" ]; then |
| echo "$DARWIN_MIN_VERSION" |
| elif [ "$1" = "x86" ]; then |
| echo "10.4" |
| else |
| echo "10.5" |
| fi |
| } |
| |
| # Use the check for the availability of a compatibility SDK in Darwin |
| # this can be used to generate binaries compatible with either Tiger or |
| # Leopard. |
| # |
| # $1: SDK root path |
| # $2: Darwin architecture |
| check_darwin_sdk () |
| { |
| if [ -d "$1" -a -z "$HOST_CFLAGS" ] ; then |
| local MINVER=$(darwin_arch_to_min_version $2) |
| HOST_CFLAGS="-isysroot $1 -mmacosx-version-min=$MINVER -DMAXOSX_DEPLOYEMENT_TARGET=$MINVER" |
| HOST_CXXFLAGS=$HOST_CFLAGS |
| HOST_LDFLAGS="-syslibroot $1 -mmacosx-version-min=$MINVER" |
| dump "Generating $MINVER-compatible binaries." |
| return 0 # success |
| fi |
| return 1 |
| } |
| |
| # Check that a given compiler generates 32 or 64 bit code. |
| # $1: compiler full path (.e.g /path/to/fullprefix-gcc) |
| # $2: 32 or 64 |
| # $3: extract compiler flags |
| # Return: success iff the compiler generates $2-bits code |
| check_compiler_bitness () |
| { |
| local CC="$1" |
| local BITS="$2" |
| local TMPC=/tmp/build-host-gcc-bits-$USER-$$.c |
| local TMPL=$TMPC.log |
| local RET |
| shift; shift; |
| cat > $TMPC <<EOF |
| /* this program will fail to compile if the compiler doesn't generate BITS-bits code */ |
| int tab[1-2*(sizeof(void*)*8 != BITS)]; |
| EOF |
| dump_n "$(host_text) Checking that the compiler generates $BITS-bits code ($@)... " |
| $CC -c -DBITS=$BITS -o /dev/null $TMPC $HOST_CFLAGS "$@" > $TMPL 2>&1 |
| RET=$? |
| rm -f $TMPC $TMPL |
| if [ "$RET" = 0 ]; then |
| dump "yes" |
| else |
| dump "no" |
| fi |
| return $RET |
| } |
| |
| # This function probes the system to find the best toolchain or cross-toolchain |
| # to build binaries that run on a given host system. After that, it generates |
| # a wrapper toolchain under $WRAPPERS_DIR with a prefix of ${HOST}- |
| # where $HOST is a GNU configuration name. |
| # |
| # Important: this script might redefine $HOST to a different value! |
| # Important: must be called after setup_build. |
| # |
| # $1: NDK system tag (e.g. linux-x86) |
| # |
| select_toolchain_for_host () |
| { |
| local HOST_CFLAGS HOST_CXXFLAGS HOST_LDFLAGS HOST_FULLPREFIX DARWIN_ARCH |
| |
| # We do all the complex auto-detection magic in the setup phase, |
| # then save the result in host-specific global variables. |
| # |
| # In the build phase, we will simply restore the values into the |
| # global HOST_FULLPREFIX / HOST_BUILD_DIR |
| # variables. |
| # |
| |
| # Try to find the best toolchain to do that job, assuming we are in |
| # a full Android platform source checkout, we can look at the prebuilts/ |
| # directory. |
| case $1 in |
| linux-x86) |
| # If possible, automatically use our custom toolchain to generate |
| # 32-bit executables that work on Ubuntu 8.04 and higher. |
| try_host_fullprefix "$(dirname $ANDROID_NDK_ROOT)/prebuilts/gcc/linux-x86/host/i686-linux-glibc2.7-4.6" i686-linux |
| try_host_fullprefix "$(dirname $ANDROID_NDK_ROOT)/prebuilts/gcc/linux-x86/host/i686-linux-glibc2.7-4.4.3" i686-linux |
| try_host_fullprefix "$(dirname $ANDROID_NDK_ROOT)/prebuilt/linux-x86/toolchain/i686-linux-glibc2.7-4.4.3" i686-linux |
| try_host_prefix i686-linux-gnu |
| try_host_prefix i686-linux |
| try_host_prefix x86_64-linux-gnu -m32 |
| try_host_prefix x86_64-linux -m32 |
| ;; |
| |
| linux-x86_64) |
| # If possible, automaticaly use our custom toolchain to generate |
| # 64-bit executables that work on Ubuntu 8.04 and higher. |
| try_host_fullprefix "$(dirname $ANDROID_NDK_ROOT)/prebuilts/gcc/linux-x86/host/x86_64-linux-glibc2.7-4.6" x86_64-linux |
| try_host_prefix x86_64-linux-gnu |
| try_host_prefix x84_64-linux |
| try_host_prefix i686-linux-gnu -m64 |
| try_host_prefix i686-linux -m64 |
| ;; |
| |
| darwin-*) |
| DARWIN_ARCH=$(tag_to_arch $1) |
| case $BUILD_OS in |
| darwin) |
| if [ "$DARWIN_SDK_VERSION" ]; then |
| # Compute SDK subdirectory name |
| case $DARWIN_SDK_VERSION in |
| 10.4) DARWIN_SDK_SUBDIR=$DARWIN_SDK.sdku;; |
| *) DARWIN_SDK_SUBDIR=$DARWIN_SDK.sdk;; |
| esac |
| # Since xCode moved to the App Store the SDKs have been 'sandboxed' into the Xcode.app folder. |
| check_darwin_sdk /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX$DARWIN_SDK_SUBDIR $DARWIN_ARCH |
| check_darwin_sdk /Developer/SDKs/MacOSX$DARWIN_SDK_SUBDIR $DARWIN_ARCH |
| else |
| # Since xCode moved to the App Store the SDKs have been 'sandboxed' into the Xcode.app folder. |
| check_darwin_sdk /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.7.sdk $DARWIN_ARCH |
| check_darwin_sdk /Developer/SDKs/MacOSX10.7.sdk $DARWIN_ARCH |
| check_darwin_sdk /Developer/SDKs/MacOSX10.6.sdk $DARWIN_ARCH |
| # NOTE: The 10.5.sdk on Lion is buggy and cannot build basic C++ programs |
| #check_darwin_sdk /Developer/SDKs/MacOSX10.5.sdk $DARWIN_ARCH |
| # NOTE: The 10.4.sdku is not available anymore and could not be tested. |
| #check_darwin_sdk /Developer/SDKs/MacOSX10.4.sdku $DARWIN_ARCH |
| fi |
| if [ -z "$HOST_CFLAGS" ]; then |
| local version="$(sw_vers -productVersion)" |
| log "Generating $version-compatible binaries!" |
| fi |
| ;; |
| *) |
| if [ -z "$DARWIN_TOOLCHAIN" -o -z "$DARWIN_SYSROOT" ]; then |
| dump "If you want to build Darwin binaries on a non-Darwin machine," |
| dump "Please define DARWIN_TOOLCHAIN to name it, and DARWIN_SYSROOT to point" |
| dump "to the SDK. For example:" |
| dump "" |
| dump " DARWIN_TOOLCHAIN=\"i686-apple-darwin11\"" |
| dump " DARWIN_SYSROOT=\"~/darwin-cross/MacOSX10.7.sdk\"" |
| dump " export DARWIN_TOOLCHAIN DARWIN_SYSROOT" |
| dump "" |
| exit 1 |
| fi |
| local DARWINMINVER=$(darwin_arch_to_min_version $2) |
| check_darwin_sdk $DARWIN_SYSROOT $DARWINARCH |
| try_host_prefix "$DARWIN_TOOLCHAIN" -m$(tag_to_bits $1) --sysroot "$DARWIN_SYSROOT" |
| if [ -z "$HOST_FULLPREFIX" ]; then |
| dump "It looks like $DARWIN_TOOLCHAIN-gcc is not in your path, or does not work correctly!" |
| exit 1 |
| fi |
| dump "Using darwin cross-toolchain: ${HOST_FULLPREFIX}gcc" |
| ;; |
| esac |
| ;; |
| |
| windows|windows-x86) |
| case $BUILD_OS in |
| linux) |
| # We favor these because they are more recent, and because |
| # we have a script to rebuild them from scratch. See |
| # build-mingw64-toolchain.sh. |
| try_host_prefix x86_64-w64-mingw32 -m32 |
| try_host_prefix i686-w64-mingw32 |
| # Typically provided by the 'mingw32' package on Debian |
| # and Ubuntu systems. |
| try_host_prefix i586-mingw32msvc |
| # Special note for Fedora: this distribution used |
| # to have a mingw32-gcc package that provided a 32-bit |
| # only cross-toolchain named i686-pc-mingw32. |
| # Later versions of the distro now provide a new package |
| # named mingw-gcc which provides i686-w64-mingw32 and |
| # x86_64-w64-mingw32 instead. |
| try_host_prefix i686-pc-mingw32 |
| if [ -z "$HOST_FULLPREFIX" ]; then |
| dump "There is no Windows cross-compiler. Ensure that you" |
| dump "have one of these installed and in your path:" |
| dump " x86_64-w64-mingw32-gcc (see build-mingw64-toolchain.sh)" |
| dump " i686-w64-mingw32-gcc (see build-mingw64-toolchain.sh)" |
| dump " i586-mingw32msvc-gcc ('mingw32' Debian/Ubuntu package)" |
| dump " i686-pc-mingw32 (on Fedora)" |
| dump "" |
| exit 1 |
| fi |
| # Adjust $HOST to match the toolchain to ensure proper builds. |
| # I.e. chose configuration triplets that are known to work |
| # with the gmp/mpfr/mpc/binutils/gcc configure scripts. |
| case $HOST_FULLPREFIX in |
| *-mingw32msvc-*|i686-pc-mingw32) |
| HOST=i586-pc-mingw32msvc |
| ;; |
| *) |
| HOST=i686-w64-mingw32msvc |
| ;; |
| esac |
| ;; |
| *) panic "Sorry, this script only supports building windows binaries on Linux." |
| ;; |
| esac |
| ;; |
| |
| windows-x86_64) |
| # Sanity check for GMP which doesn't build with x86_64-w64-mingw32-gcc |
| # before 5.0. We already have 5.0.5 in AOSP toolchain source tree, so |
| # suggest it here. |
| if ! version_is_at_least $GMP_VERSION 5.0; then |
| dump "You cannot build a 64-bit Windows toolchain with this version of libgmp." |
| dump "Please use --gmp-version=5.0.5 to fix this." |
| exit 1 |
| fi |
| case $BUILD_OS in |
| linux) |
| # See comments above for windows-x86 |
| try_host_prefix x86_64-w64-mingw32 |
| try_host_prefix i686-w64-mingw32 -m64 |
| # Beware that this package is completely broken on many |
| # versions of no vinegar Ubuntu (i.e. it fails at building trivial |
| # programs). |
| try_host_prefix amd64-mingw32msvc |
| # There is no x86_64-pc-mingw32 toolchain on Fedora. |
| if [ -z "$HOST_FULLPREFIX" ]; then |
| dump "There is no Windows cross-compiler in your path. Ensure you" |
| dump "have one of these installed and in your path:" |
| dump " x86_64-w64-mingw32-gcc (see build-mingw64-toolchain.sh)" |
| dump " i686-w64-mingw32-gcc (see build-mingw64-toolchain.sh)" |
| dump " amd64-mingw32msvc-gcc (Debian/Ubuntu - broken until Ubuntu 11.10)" |
| dump "" |
| exit 1 |
| fi |
| # See comment above for windows-x86 |
| case $HOST_FULLPREFIX in |
| *-mingw32msvc*) |
| # Actually, this has never been tested. |
| HOST=amd64-pc-mingw32msvc |
| ;; |
| *) |
| HOST=x86_64-w64-mingw32 |
| ;; |
| esac |
| ;; |
| |
| *) panic "Sorry, this script only supports building windows binaries on Linux." |
| ;; |
| esac |
| ;; |
| esac |
| |
| mkdir -p "$(host_build_dir)" |
| if [ "$FORCE" ]; then |
| rm -rf "$(host_build_dir)"/* |
| fi |
| |
| # Determine the default bitness of our compiler. It it doesn't match |
| # HOST_BITS, tries to see if it supports -m32 or -m64 to change it. |
| if ! check_compiler_bitness ${HOST_FULLPREFIX}gcc $HOST_BITS; then |
| TRY_CFLAGS= |
| case $HOST_BITS in |
| 32) TRY_CFLAGS=-m32;; |
| 64) TRY_CFLAGS=-m64;; |
| esac |
| if ! check_compiler_bitness ${HOST_FULLPREFIX}gcc $HOST_BITS $TRY_CFLAGS; then |
| panic "Can't find a way to generate $HOST_BITS binaries with this compiler: ${HOST_FULLPREFIX}gcc" |
| fi |
| HOST_CFLAGS=$HOST_CFLAGS" "$TRY_CFLAGS |
| HOST_CXXFLAGS=$HOST_CXXFLAGS" "$TRY_CFLAGS |
| fi |
| |
| # Support for ccache, to speed up rebuilds. |
| DST_PREFIX=$HOST_FULLPREFIX |
| if [ "$NDK_CCACHE" ]; then |
| DST_PREFIX="$NDK_CCACHE $HOST_FULLPREFIX" |
| fi |
| |
| # We're going to generate a wrapper toolchain with the $HOST prefix |
| # i.e. if $HOST is 'i686-linux-gnu', then we're going to generate a |
| # wrapper toolchain named 'i686-linux-gnu-gcc' that will redirect |
| # to whatever HOST_FULLPREFIX points to, with appropriate modifier |
| # compiler/linker flags. |
| # |
| # This helps tremendously getting stuff to compile with the GCC |
| # configure scripts. |
| # |
| run $NDK_BUILDTOOLS_PATH/gen-toolchain-wrapper.sh "$WRAPPERS_DIR" \ |
| --src-prefix="$HOST-" \ |
| --dst-prefix="$DST_PREFIX" \ |
| --cflags="$HOST_CFLAGS" \ |
| --cxxflags="$HOST_CXXFLAGS" \ |
| --ldflags="$HOST_LDFLAGS" |
| } |
| |
| # Call this before anything else to setup a few important variables that are |
| # used consistently to build any host-specific binaries. |
| # |
| # $1: Host system name (e.g. linux-x86), this is the name of the host system |
| # where the generated GCC binaries will run, not the current machine's |
| # type (this one is in $ORIGINAL_HOST_TAG instead). |
| # |
| setup_build_for_host () |
| { |
| local HOST_VARNAME=$(dashes_to_underscores $1) |
| local HOST_VAR=_HOST_${HOST_VARNAME} |
| |
| # Determine the host configuration triplet in $HOST |
| HOST=$(tag_to_config_triplet $1) |
| HOST_OS=$(tag_to_os $1) |
| HOST_ARCH=$(tag_to_arch $1) |
| HOST_BITS=$(tag_to_bits $1) |
| HOST_TAG=$1 |
| |
| # Note: since select_toolchain_for_host can change the value of $HOST |
| # we need to save it in a variable to later get the correct one when |
| # this function is called again. |
| if [ -z "$(var_value ${HOST_VAR}_SETUP)" ]; then |
| select_toolchain_for_host $1 |
| var_assign ${HOST_VAR}_CONFIG $HOST |
| var_assign ${HOST_VAR}_SETUP true |
| else |
| HOST=$(var_value ${HOST_VAR}_CONFIG) |
| fi |
| } |
| |
| # Returns the location of all $HOST specific files (build and install) |
| host_build_dir () |
| { |
| echo "$TOP_BUILD_DIR/$HOST" |
| } |
| |
| # Return the location of the build directory for a specific component |
| # $1: component name (e.g. gmp-4.2.4) |
| host_build_dir_for () |
| { |
| echo "$(host_build_dir)/build-$1" |
| } |
| |
| # Returns the install location of the $HOST pre-reqs libraries |
| host_prereqs_install_dir () |
| { |
| echo "$(host_build_dir)/temp-prereqs" |
| } |
| |
| # Returns the install location of the $HOST binutils cross-toolchain |
| host_binutils_install_dir () |
| { |
| echo "$(host_build_dir)/temp-binutils-$BINUTILS_VERSION-$TARGET" |
| } |
| |
| # Returns the install location of the $HOST binutils cross-toolchain |
| build_binutils_install_dir () |
| { |
| echo "$TOP_BUILD_DIR/$BUILD/temp-binutils-$BINUTILS_VERSION-$TARGET" |
| } |
| |
| # Returns the install location of the $HOST gcc cross-toolchain |
| host_gcc_install_dir () |
| { |
| echo "$(host_build_dir)/temp-$TOOLCHAIN" |
| } |
| |
| # Returns the install location of the $BUILD gcc cross-toolchain |
| build_gcc_install_dir () |
| { |
| echo "$TOP_BUILD_DIR/$BUILD/temp-$TOOLCHAIN" |
| } |
| |
| |
| # Location of the host sysroot used during the build |
| host_sysroot () |
| { |
| # This must be a sub-directory of $(host_gcc_install_dir) |
| # to generate relocatable binaries that are used by |
| # standalone versions of the toolchain. |
| # |
| # If you change this, you will need to modify make-standalone-toolchain.sh |
| # as well. |
| # |
| echo "$(host_gcc_install_dir)/sysroot" |
| } |
| |
| # Returns the final install location of the $HOST toolchain |
| # This ones contains the binutils binaries, the gcc ones, |
| # the target libraries, but does *not* include the sysroot |
| # and other stuff (e.g. documentation like info or man files). |
| # |
| host_gcc_final_dir () |
| { |
| echo "$(host_build_dir)/final-$TOOLCHAIN" |
| } |
| |
| setup_build_for_toolchain () |
| { |
| GCC_VERSION=$(extract_version $1) |
| BINUTILS_VERSION=$(get_default_binutils_version_for_gcc $1) |
| |
| TARGET_ARCH=$(echo $1 | cut -d - -f 1) |
| |
| # NOTE: The 'mipsel' toolchain architecture name maps to the 'mips' |
| # NDK architecture name. |
| case $TARGET_ARCH in |
| arm) TARGET=arm-linux-androideabi;; |
| x86) TARGET=i686-linux-android;; |
| x86_64) TARGET=x86_64-linux-android;; |
| mips|mipsel) TARGET=mipsel-linux-android; TARGET_ARCH=mips;; |
| *) panic "Unknown target toolchain architecture: $TARGET_ARCH" |
| esac |
| |
| # MPC is only needed starting with GCC 4.5 |
| HOST_NEED_MPC= |
| if version_is_at_least $GCC_VERSION 4.5; then |
| HOST_NEED_MPC=true |
| fi |
| |
| # TODO: We will need to place these under |
| # $NDK_DIR/prebuilts/$HOST/android-$TARGET_ARCH-gcc-$GCC_VERSION/ |
| # in a future patch. |
| TOOLCHAIN_SUB_DIR=toolchains/$TOOLCHAIN/prebuilt/$HOST_TAG |
| TOOLCHAIN_INSTALL_DIR=$NDK_DIR/$TOOLCHAIN_SUB_DIR |
| |
| # These will go into CFLAGS_FOR_TARGET and others during the build |
| # of GCC target libraries. |
| if [ -z "$NO_STRIP" ]; then |
| TARGET_CFLAGS="-O2 -s" |
| else |
| TARGET_CFLAGS="-Os -g" |
| fi |
| |
| TARGET_CXXFLAGS=$TARGET_CFLAGS |
| TARGET_LDFLAGS="" |
| |
| case $TARGET_ARCH in |
| mips) |
| # Enable C++ exceptions, RTTI and GNU libstdc++ at the same time |
| # You can't really build these separately at the moment. |
| # Add -fpic, because MIPS NDK will need to link .a into .so. |
| TARGET_CFLAGS=$TARGET_CFLAGS" -fexceptions -fpic" |
| TARGET_CXXFLAGS=$TARGET_CXXFLAGS" -frtti -fpic" |
| ;; |
| esac |
| } |
| |
| # This function is used to setup the build environment whenever we |
| # generate host-specific binaries. |
| # |
| setup_host_env () |
| { |
| CC=$HOST-gcc |
| CXX=$HOST-g++ |
| LD=$HOST-ld |
| AR=$HOST-ar |
| AS=$HOST-as |
| RANLIB=$HOST-ranlib |
| NM=$HOST-nm |
| STRIP=$HOST-strip |
| STRINGS=$HOST-strings |
| export CC CXX AS LD AR RANLIB STRIP STRINGS NM |
| |
| CFLAGS= |
| CXXFLAGS= |
| LDFLAGS= |
| if [ -z "$NO_STRIP" ]; then |
| CFLAGS="-O2 -Os -fomit-frame-pointer -s" |
| CXXFLAGS=$CFLAGS |
| fi |
| |
| # This should only used when building the target GCC libraries |
| CFLAGS_FOR_TARGET=$TARGET_CFLAGS |
| CXXFLAGS_FOR_TARGET=$TARGET_CXXFLAGS |
| LDFLAGS_FOR_TARGET=$TARGET_LDFLAGS |
| |
| export CFLAGS CXXFLAGS LDFLAGS CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET LDFLAGS_FOR_TARGET |
| |
| PATH=$WRAPPERS_DIR:$PATH |
| } |
| |
| # $1: NDK architecture name (e.g. 'arm') |
| arch_sysroot_install_dir () |
| { |
| echo "$BUILD_DIR/arch-$1/sysroot" |
| } |
| |
| # $1: NDK architecture name (e.g. 'arm') |
| arch_sysroot_dir () |
| { |
| echo "$(arch_sysroot_install_dir $1)/$(get_default_platform_sysroot_for_arch $1)" |
| } |
| |
| # $1: architecture name |
| gen_minimal_sysroot () |
| { |
| local ARCH=$1 |
| local INSTALL_DIR=$(arch_sysroot_install_dir $ARCH) |
| |
| dump "$(arch_text) Generating minimal sysroot." |
| run2 $NDK_BUILDTOOLS_PATH/gen-platforms.sh --minimal --arch=$ARCH --dst-dir="$INSTALL_DIR" |
| } |
| |
| |
| # $1: gmp version |
| extract_gmp_sources () |
| { |
| local SRC_DIR="$TOP_BUILD_DIR/temp-src" |
| |
| dump "Extracting gmp-$1" |
| run2 mkdir -p "$SRC_DIR" && |
| run2 tar xjf "$TOOLCHAIN_SRC_DIR/gmp/gmp-$1.tar.bz2" -C "$SRC_DIR" |
| } |
| |
| # $1: gmp version |
| build_gmp () |
| { |
| local SRC_DIR="$TOP_BUILD_DIR/temp-src/gmp-$1" |
| local INSTALL_DIR="$(host_prereqs_install_dir)" |
| local BUILD_DIR |
| |
| stamps_do extract-gmp-$1 extract_gmp_sources $1 |
| |
| dump "$(host_text) Building gmp-$1" |
| ( |
| setup_host_env && |
| BUILD_DIR="$(host_build_dir_for gmp-$GMP_VERSION)" && |
| run2 mkdir -p "$BUILD_DIR" && run2 rm -rf "$BUILD_DIR"/* && |
| cd "$BUILD_DIR" && |
| run2 "$SRC_DIR"/configure \ |
| --prefix=$INSTALL_DIR \ |
| --build=$BUILD \ |
| --host=$HOST \ |
| --disable-shared && |
| run2 make -j$NUM_JOBS && |
| run2 make install -j$NUM_INSTALL_JOBS |
| ) |
| return $? |
| } |
| |
| extract_mpfr_sources () |
| { |
| local SRC_DIR="$TOP_BUILD_DIR/temp-src" |
| |
| dump "Extracting mpfr-$1" |
| run2 mkdir -p "$SRC_DIR" && |
| run2 tar xjf "$TOOLCHAIN_SRC_DIR/mpfr/mpfr-$1.tar.bz2" -C "$SRC_DIR" |
| } |
| |
| # $1: mpfr-version |
| build_mpfr () |
| { |
| local SRC_DIR="$TOP_BUILD_DIR/temp-src/mpfr-$1" |
| local INSTALL_DIR="$(host_prereqs_install_dir)" |
| local BUILD_DIR |
| |
| stamps_do extract-mpfr-$MPFR_VERSION extract_mpfr_sources $1 |
| |
| stamps_do build-gmp-$GMP_VERSION-$HOST build_gmp $GMP_VERSION |
| |
| dump "$(host_text) Building mpfr-$1" |
| ( |
| setup_host_env && |
| BUILD_DIR="$(host_build_dir_for mpfr-$MPFR_VERSION)" && |
| run2 mkdir -p "$BUILD_DIR" && run2 rm -rf "$BUILD_DIR"/* && |
| cd $BUILD_DIR && |
| run2 "$SRC_DIR"/configure \ |
| --prefix=$INSTALL_DIR \ |
| --build=$BUILD \ |
| --host=$HOST \ |
| --disable-shared \ |
| --with-gmp=$INSTALL_DIR && |
| run2 make -j$NUM_JOBS && |
| run2 make -j$NUM_INSTALL_JOBS install |
| ) |
| return $? |
| } |
| |
| # $1: mpc-version |
| extract_mpc_sources () |
| { |
| local SRC_DIR="$TOP_BUILD_DIR/temp-src" |
| |
| dump "Extracting mpc-$1" |
| run2 mkdir -p "$SRC_DIR" && |
| run2 tar xzf "$TOOLCHAIN_SRC_DIR/mpc/mpc-$1.tar.gz" -C "$SRC_DIR" |
| } |
| |
| |
| # $1: mpc-version |
| build_mpc () |
| { |
| local SRC_DIR="$TOP_BUILD_DIR/temp-src/mpc-$1" |
| local INSTALL_DIR="$(host_prereqs_install_dir)" |
| local BUILD_DIR |
| |
| stamps_do extract-mpc-$1 extract_mpc_sources $1 |
| |
| stamps_do build-mpfr-$MPFR_VERSION-$HOST build_mpfr $MPFR_VERSION |
| |
| dump "$(host_text) Building mpc-$1" |
| ( |
| setup_host_env && |
| BUILD_DIR="$(host_build_dir_for mpc-$MPC_VERSION)" && |
| run2 mkdir -p "$BUILD_DIR" && run2 rm -rf "$BUILD_DIR"/* && |
| cd $BUILD_DIR && |
| run2 "$SRC_DIR"/configure \ |
| --prefix=$INSTALL_DIR \ |
| --build=$BUILD \ |
| --host=$HOST \ |
| --disable-shared \ |
| --with-gmp=$INSTALL_DIR \ |
| --with-mpfr=$INSTALL_DIR && |
| run2 make -j$NUM_JOBS && |
| run2 make -j$NUM_INSTALL_JOBS install |
| ) |
| return $? |
| } |
| |
| # Build all pre-required host libraries (gmp, mpfr, etc...) that are needed |
| # by binutils and gcc, as static libraries that will be placed under |
| # $HOST_BUILD_DIR/temp-install |
| # |
| # $1: toolchain source directory |
| # |
| build_host_prereqs () |
| { |
| local INSTALL_DIR="$(host_prereqs_install_dir)" |
| local ARGS |
| |
| ARGS=" --with-gmp=$INSTALL_DIR --with-mpfr=$INSTALL_DIR" |
| |
| # Only build MPC when we need it. |
| if [ "$HOST_NEED_MPC" ]; then |
| ARGS=$ARGS" --with-mpc=$INSTALL_DIR" |
| stamps_do build-mpc-$MPC_VERSION-$HOST build_mpc $MPC_VERSION |
| else |
| stamps_do build-mpfr-$MPFR_VERSION-$HOST build_mpfr $MPFR_VERSION |
| fi |
| |
| # This gets used by build_host_binutils and others. |
| HOST_PREREQS_ARGS=$ARGS |
| } |
| |
| build_host_binutils () |
| { |
| local SRC_DIR="$TOOLCHAIN_SRC_DIR/binutils/binutils-$BINUTILS_VERSION" |
| local INSTALL_DIR="$(host_binutils_install_dir)" |
| local PREREQS_INSTALL_DIR="$(host_prereqs_install_dir)" |
| local ARGS |
| |
| build_host_prereqs |
| |
| ARGS=" --with-gmp=$PREREQS_INSTALL_DIR --with-mpfr=$PREREQS_INSTALL_DIR" |
| if [ "$HOST_NEED_MPC" ]; then |
| ARGS=$ARGS" --with-mpc=$PREREQS_INSTALL_DIR" |
| fi |
| |
| LD_NAME=$DEFAULT_LD |
| |
| # Enable Gold globally. It can be built for all hosts. |
| BUILD_GOLD=true |
| |
| # Special case, gold is not ready for mips yet. |
| if [ "$TARGET" = "mipsel-linux-android" ]; then |
| BUILD_GOLD= |
| fi |
| |
| # Another special case, gold in binutils-2.21 for arch-x86 is buggy |
| # (i.e. when building the platform with it, the system doesn't boot) |
| # |
| if [ "$BINUTILS_VERSION" = "2.21" -a "$TARGET" = "i686-linux-android" ]; then |
| USE_LD_DEFAULT=true |
| BUILD_GOLD= |
| fi |
| |
| # Another special case, for arch-x86_64 gold supports x32 starting from 2.23 |
| # |
| if [ "$TARGET" = "x86_64-linux-android" ]; then |
| if ! version_is_at_least $BINUTILS_VERSION 2.23; then |
| USE_LD_DEFAULT=true |
| BUILD_GOLD= |
| fi |
| fi |
| |
| # Another special case. Not or 2.19, it wasn't ready |
| if [ "$BINUTILS_VERSION" = "2.19" ]; then |
| BUILD_GOLD= |
| fi |
| |
| if [ "$DEFAULT_LD" = "gold" -a -z "$BUILD_GOLD" ]; then |
| dump "$(host_text)$(target_text): Cannot build Gold for this toolchain!" |
| BUILD_GOLD= |
| fi |
| |
| # Ok, if the user *really* wants it, we're going to build Gold anyway. |
| # There are no guarantees about the correctness of the resulting binary. |
| # --default-ld still determines the default linker to use by the toolchain. |
| # |
| if [ "$FORCE_GOLD_BUILD" -a -z "$BUILD_GOLD" ]; then |
| dump "$(host_text)$(target_text): Warning: forcing build of potentially buggy Gold linker!" |
| BUILD_GOLD=true |
| fi |
| |
| # The BFD linker is always built, but to build Gold, we need a specific |
| # option for the binutils configure script. Note that its format has |
| # changed during development. |
| export host_configargs= |
| if [ "$BUILD_GOLD" ]; then |
| # The syntax of the --enable-gold option has changed. |
| if version_is_at_least $BINUTILS_VERSION 2.20; then |
| if [ "$DEFAULT_LD" = "bfd" ]; then |
| ARGS=$ARGS" --enable-gold --enable-ld=default" |
| else |
| ARGS=$ARGS" --enable-gold=default --enable-ld" |
| fi |
| else |
| if [ "$DEFAULT_LD" = "bfd" ]; then |
| ARGS=$ARGS" --enable-gold=both" |
| else |
| ARGS=$ARGS" --enable-gold=both/gold" |
| fi |
| fi |
| # This ARG needs quoting when passed to run2. |
| GOLD_LDFLAGS_ARG= |
| if [ "$HOST_OS" = 'windows' ]; then |
| # gold may have runtime dependency on libgcc_sjlj_1.dll and |
| # libstdc++-6.dll when built by newer versions of mingw. |
| # Link them statically to avoid that. |
| if version_is_at_least $BINUTILS_VERSION 2.22; then |
| export host_configargs="--with-gold-ldflags='-static-libgcc -static-libstdc++'" |
| elif version_is_at_least $BINUTILS_VERSION 2.21; then |
| GOLD_LDFLAGS_ARG="--with-gold-ldflags=-static-libgcc -static-libstdc++" |
| else |
| export LDFLAGS=$LDFLAGS" -static-libgcc -static-libstdc++" |
| fi |
| fi |
| fi |
| |
| # This is used to install libbfd which is later used to compile |
| # oprofile for the platform. This is not technically required for |
| # the NDK, but allows us to use the same toolchain for the platform |
| # build. TODO: Probably want to move this step to its own script |
| # like build-host-libbfd.sh in the future. |
| ARGS=$ARGS" --enable-install-libbfd" |
| |
| # Enable plugins support for binutils-2.21+ |
| # This is common feature for binutils and gcc |
| case "$BINUTILS_VERSION" in |
| 2.19) |
| # Add nothing |
| ;; |
| *) |
| ARGS=$ARGS" --enable-plugins" |
| ;; |
| esac |
| |
| dump "$(host_text)$(target_text) Building binutils-$BINUTILS_VERSION" |
| ( |
| setup_host_env && |
| BUILD_DIR="$(host_build_dir_for binutils-$BINUTILS_VERSION-$TARGET)" && |
| run2 mkdir -p "$BUILD_DIR" && run2 rm -rf "$BUILD_DIR"/* && |
| cd "$BUILD_DIR" && |
| run2 "$SRC_DIR"/configure \ |
| --prefix="$INSTALL_DIR" \ |
| --disable-shared \ |
| --disable-werror \ |
| --disable-nls \ |
| --build=$BUILD \ |
| --host=$HOST \ |
| --target=$TARGET \ |
| --with-sysroot="$INSTALL_DIR/sysroot" \ |
| $ARGS && |
| run2 make -j$NUM_JOBS && |
| run2 make -j$NUM_INSTALL_JOBS install && |
| # We need to take care of something weird, binutils-2.21 on mips |
| # does not seem to build gold, and the Makefile script forgets to |
| # copy it to $INSTALL/bin/mipsel-linux-android-ld. Take care of this |
| # here with a symlink, which will be enough for now. |
| if [ ! -f "$INSTALL_DIR/bin/$TARGET-ld" ]; then |
| run2 ln -s "$TARGET-ld.bfd" "$INSTALL_DIR/bin/$TARGET-ld" |
| fi |
| ) |
| return $? |
| } |
| |
| copy_target_sysroot () |
| { |
| local SRC_SYSROOT=$(arch_sysroot_dir $TARGET_ARCH) |
| local SYSROOT=$(host_sysroot) |
| |
| # We need the arch-specific minimal sysroot |
| stamps_do sysroot-arch-$TARGET_ARCH gen_minimal_sysroot $TARGET_ARCH |
| |
| dump "$(host_text)$(toolchain_text) Copying $TARGET_ARCH sysroot" |
| run2 rm -rf "$SYSROOT" && |
| run2 copy_directory "$SRC_SYSROOT" "$SYSROOT" |
| } |
| |
| build_host_gcc_core () |
| { |
| local SRC_DIR="$TOOLCHAIN_SRC_DIR/gcc/gcc-$GCC_VERSION" |
| local INSTALL_DIR="$(host_gcc_install_dir)" |
| local ARGS NEW_PATH |
| |
| stamps_do build-binutils-$BINUTILS_VERSION-$HOST-$TARGET build_host_binutils |
| stamps_do sysroot-gcc-$SYSTEM-$TOOLCHAIN copy_target_sysroot |
| |
| build_host_prereqs |
| |
| NEW_PATH=$(host_gcc_install_dir)/bin:$(host_binutils_install_dir)/bin |
| if [ "$HOST" != "$BUILD" ]; then |
| NEW_PATH=$(build_gcc_install_dir)/bin:$(build_binutils_install_dir)/bin |
| fi |
| |
| ARGS=$HOST_PREREQS_ARGS |
| |
| case "$GCC_VERSION" in |
| 4.4.3) |
| ARGS=$ARGS" --disable-plugin" |
| ;; |
| esac |
| |
| ARGS=$ARGS" --with-gnu-as --with-gnu-ld" |
| ARGS=$ARGS" --enable-threads --disable-libssp --disable-libmudflap --disable-libcilkrts --enable-gnu-indirect-function" |
| ARGS=$ARGS" --disable-libstdc__-v3 --disable-sjlj-exceptions" |
| ARGS=$ARGS" --disable-tls" |
| ARGS=$ARGS" --disable-libquadmath --disable-libitm --disable-bootstrap" |
| ARGS=$ARGS" --enable-languages=c,c++" |
| ARGS=$ARGS" --disable-shared" |
| ARGS=$ARGS" --disable-nls" |
| ARGS=$ARGS" --disable-werror" |
| ARGS=$ARGS" --enable-target-optspace" |
| ARGS=$ARGS" --enable-eh-frame-hdr-for-static" |
| # TODO: Build fails for libsanitizer which appears in 4.8. Disable for now. |
| ARGS=$ARGS" --disable-libsanitizer" |
| |
| case "$GCC_VERSION" in |
| 4.4.3) |
| ARGS=$ARGS" --disable-libgomp" |
| ;; |
| *) |
| case $TARGET_ARCH in |
| arm) ARGS=$ARGS" --enable-libgomp";; |
| x86*) ARGS=$ARGS" --enable-libgomp";; |
| mips|mipsel) ARGS=$ARGS" --disable-libgomp";; |
| esac |
| ;; |
| esac |
| |
| # Place constructors/destructors in .init_array/.fini_array, not in |
| # .ctors/.dtors on Android. Note that upstream Linux GLibc is now doing |
| # the same. |
| ARGS=$ARGS" --enable-initfini-array" |
| |
| case $TARGET_ARCH in |
| arm) |
| ARGS=$ARGS" --with-arch=armv5te --with-float=soft --with-fpu=vfpv3-d16" |
| ;; |
| x86) |
| case "$GCC_VERSION" in |
| 4.4.3|4.7) ARGS=$ARGS" --with-arch=i686 --with-tune=atom --with-fpmath=sse" ;; |
| *) ARGS=$ARGS" --with-arch=i686 --with-tune=intel --with-fpmath=sse" ;; |
| esac |
| ;; |
| x86_64) |
| case "$GCC_VERSION" in |
| 4.4.3|4.7) ARGS=$ARGS" --with-arch=x86-64 --with-tune=atom --with-fpmath=sse --with-multilib-list=m32,m64,mx32" ;; |
| *) ARGS=$ARGS" --with-arch=x86-64 --with-tune=intel --with-fpmath=sse --with-multilib-list=m32,m64,mx32" ;; |
| esac |
| ;; |
| mips) |
| # Add --disable-fixed-point to disable fixed-point support |
| ARGS=$ARGS" --with-arch=mips32 --disable-fixed-point" |
| ;; |
| esac |
| |
| dump "$(host_text)$(toolchain_text) Building gcc-core" |
| ( |
| setup_host_env && |
| BUILD_DIR="$(host_build_dir_for gcc-$GCC_VERSION-$TARGET)" && |
| run2 mkdir -p "$BUILD_DIR" && run2 rm -rf "$BUILD_DIR"/* && |
| cd "$BUILD_DIR" && |
| PATH=$NEW_PATH:$PATH && |
| run2 "$SRC_DIR"/configure \ |
| --prefix="$INSTALL_DIR" \ |
| --build=$BUILD \ |
| --host=$HOST \ |
| --target=$TARGET \ |
| --with-sysroot="$INSTALL_DIR/sysroot" \ |
| $HOST_PREREQS_ARGS $ARGS && |
| run2 make -j$NUM_JOBS all-gcc && |
| run2 make -j$NUM_INSTALL_JOBS install-gcc |
| ) |
| return $? |
| } |
| |
| build_target_gcc_libs () |
| { |
| local SRC_DIR="$TOOLCHAIN_SRC_DIR/gcc/gcc-$GCC_VERSION" |
| local INSTALL_DIR="$(host_gcc_install_dir)" |
| local ARGS NEW_PATH |
| |
| stamps_do gcc-core-$GCC_VERSION-$SYSTEM-$TOOLCHAIN build_host_gcc_core |
| |
| NEW_PATH=$(host_gcc_install_dir)/bin:$(host_binutils_install_dir)/bin |
| |
| dump "$(host_text)$(toolchain_text) Building target libraries" |
| ( |
| setup_host_env && |
| BUILD_DIR="$(host_build_dir_for gcc-$GCC_VERSION-$TARGET)" && |
| cd "$BUILD_DIR" && |
| PATH=$NEW_PATH:$PATH && |
| run2 make -j$NUM_JOBS all && |
| run2 make -j$NUM_INSTALL_JOBS install |
| ) |
| return $? |
| } |
| |
| copy_target_gcc_libs () |
| { |
| local SRC_DIR DST_DIR |
| dump "$(host_text)$(toolchain_text) Copying target GCC libraries" |
| |
| SRC_DIR="$(build_gcc_install_dir)/$TARGET" |
| DST_DIR="$(host_gcc_install_dir)/$TARGET" |
| |
| run2 copy_directory "$SRC_DIR" "$DST_DIR" |
| } |
| |
| build_host_gcc () |
| { |
| if [ "$SYSTEM" = "$BUILD_TAG" -a -z "$NO_TARGET_LIBS" ]; then |
| # This is a regular-cross build, and we need to build the target GCC libraries. |
| stamps_do gcc-all-$GCC_VERSION-$SYSTEM-$TOOLCHAIN build_target_gcc_libs |
| else |
| # This is a canadian-cross build, or we don't need the target GCC libraries. |
| stamps_do gcc-core-$GCC_VERSION-$SYSTEM-$TOOLCHAIN build_host_gcc_core |
| fi |
| } |
| |
| # $1: host system tag (e.g. linux-x86) |
| # $2: toolchain name (e.g. x86-4.4.3) |
| build_gcc () |
| { |
| local SYSTEM=$1 |
| local TOOLCHAIN=$2 |
| |
| # When performing canadian-cross builds, ensure we generate the |
| # host toolchain first (even if we don't need target GCC libraries) |
| if [ "$SYSTEM" != "$BUILD_TAG" ]; then |
| build_gcc $BUILD_TAG $TOOLCHAIN |
| fi |
| |
| # We do this both in the setup and build phase to ensure we perform |
| # as many checks as possible before launching the (long) build procedure. |
| setup_build_for_host $SYSTEM |
| setup_build_for_toolchain $TOOLCHAIN |
| |
| if [ "$PHASE" = build ]; then |
| stamps_do build-gcc-$SYSTEM-$TOOLCHAIN build_host_gcc |
| fi |
| } |
| |
| do_relink () |
| { |
| log "Relink $1 --> $2" |
| local BASENAME DIRNAME |
| DIRNAME=$(dirname "$1") |
| BASENAME=$(basename "$1") |
| ( cd "$DIRNAME" && rm -f "$BASENAME" && ln -s "$2" "$BASENAME" ) |
| } |
| |
| # $1: host system tag (e.g. linux-x86) |
| # $2: toolchain name (e.g. x86-4.4.3) |
| install_gcc () |
| { |
| local SYSTEM=$1 |
| local TOOLCHAIN=$2 |
| local BINUTILS_DIR GCC_DIR TARGET_LIBS_DIR INSTALL_DIR PROG |
| |
| build_gcc $SYSTEM $TOOLCHAIN |
| |
| dump "$(host_text)$(toolchain_text) Installing to NDK." |
| |
| BINUTILS_DIR=$(host_binutils_install_dir) |
| GCC_DIR=$(host_gcc_install_dir) |
| TARGET_LIBS_DIR=$(build_gcc_install_dir) |
| INSTALL_DIR=$TOOLCHAIN_INSTALL_DIR |
| |
| # Copy binutils binaries |
| run2 copy_directory "$BINUTILS_DIR/bin" "$INSTALL_DIR/bin" && |
| run2 copy_directory "$BINUTILS_DIR/$TARGET/lib" "$INSTALL_DIR/$TARGET/lib" && |
| |
| # The following is used to copy the libbfd. See --enable-install-libbfd |
| # which is set in build_host_binutils above. |
| run2 copy_directory "$BINUTILS_DIR/$HOST/$TARGET/include" "$INSTALL_DIR/include" && |
| run2 copy_directory "$BINUTILS_DIR/$HOST/$TARGET/lib" "$INSTALL_DIR/lib$(tag_to_bits $SYSTEM)" && |
| |
| # Copy gcc core binaries |
| run2 copy_directory "$GCC_DIR/bin" "$INSTALL_DIR/bin" && |
| run2 copy_directory "$GCC_DIR/lib/gcc/$TARGET" "$INSTALL_DIR/lib/gcc/$TARGET" && |
| run2 copy_directory "$GCC_DIR/libexec/gcc/$TARGET" "$INSTALL_DIR/libexec/gcc/$TARGET" && |
| |
| # Copy target gcc libraries |
| run2 copy_directory "$TARGET_LIBS_DIR/lib/gcc/$TARGET" "$INSTALL_DIR/lib/gcc/$TARGET" |
| run2 copy_directory "$TARGET_LIBS_DIR/$TARGET/lib" "$INSTALL_DIR/$TARGET/lib" |
| # Multilib compiler should have these |
| if [ -d "$TARGET_LIBS_DIR/$TARGET/libx32" ]; then |
| run2 copy_directory "$TARGET_LIBS_DIR/$TARGET/libx32" "$INSTALL_DIR/$TARGET/libx32" |
| fi |
| if [ -d "$TARGET_LIBS_DIR/$TARGET/lib32" ]; then |
| run2 copy_directory "$TARGET_LIBS_DIR/$TARGET/lib32" "$INSTALL_DIR/$TARGET/lib32" |
| fi |
| if [ -d "$TARGET_LIBS_DIR/$TARGET/lib64" ]; then |
| run2 copy_directory "$TARGET_LIBS_DIR/$TARGET/lib64" "$INSTALL_DIR/$TARGET/lib64" |
| fi |
| |
| # We need to generate symlinks for the binutils binaries from |
| # $INSTALL_DIR/$TARGET/bin/$PROG to $INSTALL_DIR/bin/$TARGET-$PROG |
| mkdir -p "$INSTALL_DIR/$TARGET/bin" && |
| for PROG in $(cd $INSTALL_DIR/$TARGET/bin && ls * 2>/dev/null); do |
| do_relink "$INSTALL_DIR/$TARGET/bin/$PROG" ../../bin/$TARGET-$PROG |
| fail_panic |
| done |
| |
| # Also relink a few files under $INSTALL_DIR/bin/ |
| do_relink "$INSTALL_DIR"/bin/$TARGET-c++ $TARGET-g++ && |
| do_relink "$INSTALL_DIR"/bin/$TARGET-gcc-$GCC_VERSION $TARGET-gcc && |
| if [ -f "$INSTALL_DIR"/bin/$TARGET-ld.gold ]; then |
| do_relink "$INSTALL_DIR"/bin/$TARGET-ld $TARGET-ld.gold |
| else |
| do_relink "$INSTALL_DIR"/bin/$TARGET-ld $TARGET-ld.bfd |
| fi |
| fail_panic |
| |
| # Remove unwanted $TARGET-run simulator to save about 800 KB. |
| run2 rm -f "$INSTALL_DIR"/bin/$TARGET-run |
| |
| # Copy the license files |
| local TOOLCHAIN_LICENSES="$ANDROID_NDK_ROOT"/build/tools/toolchain-licenses |
| run cp -f "$TOOLCHAIN_LICENSES"/COPYING "$TOOLCHAIN_LICENSES"/COPYING.LIB "$INSTALL_DIR" |
| } |
| |
| # $1: host system tag (e.g. linux-x86) |
| # $2: toolchain name (e.g. x86-4.4.3) |
| # $3: package directory. |
| package_gcc () |
| { |
| local SYSTEM=$1 |
| local TOOLCHAIN=$2 |
| local PACKAGE_DIR="$3" |
| local PACKAGE_NAME="$TOOLCHAIN-$SYSTEM.tar.bz2" |
| local PACKAGE_FILE="$PACKAGE_DIR/$PACKAGE_NAME" |
| |
| setup_build_for_toolchain $TOOLCHAIN |
| |
| dump "Packaging $PACKAGE_NAME." |
| pack_archive "$PACKAGE_FILE" "$NDK_DIR" "$TOOLCHAIN_SUB_DIR" |
| } |
| |
| setup_build |
| |
| for PHASE in setup build; do |
| for SYSTEM in $HOST_SYSTEMS; do |
| setup_build_for_host $SYSTEM |
| for TOOLCHAIN in $TOOLCHAINS; do |
| build_gcc $SYSTEM $TOOLCHAIN |
| done |
| done |
| done |
| |
| for SYSTEM in $HOST_SYSTEMS; do |
| setup_build_for_host $SYSTEM |
| for TOOLCHAIN in $TOOLCHAINS; do |
| install_gcc $SYSTEM $TOOLCHAIN |
| done |
| done |
| |
| if [ "$PACKAGE_DIR" ]; then |
| for SYSTEM in $HOST_SYSTEMS; do |
| setup_build_for_host $SYSTEM |
| for TOOLCHAIN in $TOOLCHAINS; do |
| package_gcc $SYSTEM $TOOLCHAIN "$PACKAGE_DIR" |
| done |
| done |
| echo "Done. See the content of $PACKAGE_DIR:" |
| ls -l "$PACKAGE_DIR" |
| echo "" |
| fi |
