From 5805822bd4e82d0c5717b8ccb16801d69b1b9c1f Mon Sep 17 00:00:00 2001 From: Aaron Culliney Date: Thu, 15 Sep 2016 10:07:56 -0700 Subject: [PATCH] Android : bring in scripts needed by toolchain_edits/ndk-gdb from NDK r10e --- .../build/tools/dev-defaults.sh | 304 +++ .../toolchain_edits/build/tools/ndk-common.sh | 980 ++++++++++ .../build/tools/prebuilt-common.sh | 1675 +++++++++++++++++ 3 files changed, 2959 insertions(+) create mode 100644 Android/toolchain_edits/build/tools/dev-defaults.sh create mode 100644 Android/toolchain_edits/build/tools/ndk-common.sh create mode 100644 Android/toolchain_edits/build/tools/prebuilt-common.sh diff --git a/Android/toolchain_edits/build/tools/dev-defaults.sh b/Android/toolchain_edits/build/tools/dev-defaults.sh new file mode 100644 index 00000000..9a502f5a --- /dev/null +++ b/Android/toolchain_edits/build/tools/dev-defaults.sh @@ -0,0 +1,304 @@ +# Default values used by several dev-scripts. +# + +# Current list of platform levels we support +# +# Note: levels 6 and 7 are omitted since they have the same native +# APIs as level 5. Same for levels 10, 11 and 12 +# +API_LEVELS="3 4 5 8 9 12 13 14 15 16 17 18 19 21" + +FIRST_API64_LEVEL=21 + +# Default ABIs for the target prebuilt binaries. +PREBUILT_ABIS="armeabi armeabi-v7a x86 mips armeabi-v7a-hard arm64-v8a x86_64 mips64" + +# Location of the STLport sources, relative to the NDK root directory +STLPORT_SUBDIR=sources/cxx-stl/stlport + +# Location of the GAbi++ sources, relative to the NDK root directory +GABIXX_SUBDIR=sources/cxx-stl/gabi++ + +# Location of the GNU libstdc++ headers and libraries, relative to the NDK +# root directory. +GNUSTL_SUBDIR=sources/cxx-stl/gnu-libstdc++ + +# Location of the LLVM libc++ headers and libraries, relative to the NDK +# root directory. +LIBCXX_SUBDIR=sources/cxx-stl/llvm-libc++ + +# Location of the LLVM libc++abi headers, relative to the NDK # root directory. +LIBCXXABI_SUBDIR=sources/cxx-stl/llvm-libc++abi/libcxxabi + +# Location of the libportable sources, relative to the NDK root directory +LIBPORTABLE_SUBDIR=sources/android/libportable + +# Location of the gccunwind sources, relative to the NDK root directory +GCCUNWIND_SUBDIR=sources/android/gccunwind + +# Location of the compiler-rt sources, relative to the NDK root directory +COMPILER_RT_SUBDIR=sources/android/compiler-rt + +# Location of the support sources for libc++, relative to the NDK root directory +SUPPORT_SUBDIR=sources/android/support + +# The date to use when downloading toolchain sources from AOSP servers +# Leave it empty for tip of tree. +TOOLCHAIN_GIT_DATE=now + +# The space-separated list of all GCC versions we support in this NDK +DEFAULT_GCC_VERSION_LIST="4.8 4.9" + +DEFAULT_GCC32_VERSION=4.8 +DEFAULT_GCC64_VERSION=4.9 +FIRST_GCC32_VERSION=4.8 +FIRST_GCC64_VERSION=4.9 +DEFAULT_LLVM_GCC32_VERSION=4.8 +DEFAULT_LLVM_GCC64_VERSION=4.9 + +DEFAULT_BINUTILS_VERSION=2.25 +DEFAULT_GDB_VERSION=7.7 +DEFAULT_MPFR_VERSION=3.1.1 +DEFAULT_GMP_VERSION=5.0.5 +DEFAULT_MPC_VERSION=1.0.1 +DEFAULT_CLOOG_VERSION=0.18.0 +DEFAULT_ISL_VERSION=0.11.1 +DEFAULT_PPL_VERSION=1.0 +DEFAULT_PYTHON_VERSION=2.7.5 +DEFAULT_PERL_VERSION=5.16.2 + +RECENT_BINUTILS_VERSION=2.25 + +# Default platform to build target binaries against. +DEFAULT_PLATFORM=android-9 + +# The list of default CPU architectures we support +DEFAULT_ARCHS="arm x86 mips arm64 x86_64 mips64" + +# Default toolchain names and prefix +# +# This is used by get_default_toolchain_name_for_arch and get_default_toolchain_prefix_for_arch +# defined below +DEFAULT_ARCH_TOOLCHAIN_NAME_arm=arm-linux-androideabi +DEFAULT_ARCH_TOOLCHAIN_PREFIX_arm=arm-linux-androideabi + +DEFAULT_ARCH_TOOLCHAIN_NAME_arm64=aarch64-linux-android +DEFAULT_ARCH_TOOLCHAIN_PREFIX_arm64=aarch64-linux-android + +DEFAULT_ARCH_TOOLCHAIN_NAME_x86=x86 +DEFAULT_ARCH_TOOLCHAIN_PREFIX_x86=i686-linux-android + +DEFAULT_ARCH_TOOLCHAIN_NAME_x86_64=x86_64 +DEFAULT_ARCH_TOOLCHAIN_PREFIX_x86_64=x86_64-linux-android + +DEFAULT_ARCH_TOOLCHAIN_NAME_mips=mipsel-linux-android +DEFAULT_ARCH_TOOLCHAIN_PREFIX_mips=mipsel-linux-android + +DEFAULT_ARCH_TOOLCHAIN_NAME_mips64=mips64el-linux-android +DEFAULT_ARCH_TOOLCHAIN_PREFIX_mips64=mips64el-linux-android + +# The space-separated list of all LLVM versions we support in NDK +DEFAULT_LLVM_VERSION_LIST="3.6 3.5" + +# The default LLVM version (first item in the list) +DEFAULT_LLVM_VERSION=$(echo "$DEFAULT_LLVM_VERSION_LIST" | tr ' ' '\n' | head -n 1) + +# The default URL to download the LLVM tar archive +DEFAULT_LLVM_URL="http://llvm.org/releases" + +# The list of default host NDK systems we support +DEFAULT_SYSTEMS="linux-x86 windows darwin-x86" + +# The default issue tracker URL +DEFAULT_ISSUE_TRACKER_URL="http://source.android.com/source/report-bugs.html" + +# Return the default gcc version for a given architecture +# $1: Architecture name (e.g. 'arm') +# Out: default arch-specific gcc version +get_default_gcc_version_for_arch () +{ + case $1 in + *64) echo $DEFAULT_GCC64_VERSION ;; + *) echo $DEFAULT_GCC32_VERSION ;; + esac +} + +# Return the first gcc version for a given architecture +# $1: Architecture name (e.g. 'arm') +# Out: default arch-specific gcc version +get_first_gcc_version_for_arch () +{ + case $1 in + *64) echo $FIRST_GCC64_VERSION ;; + *) echo $FIRST_GCC32_VERSION ;; + esac +} + +# Return default NDK ABI for a given architecture name +# $1: Architecture name +# Out: ABI name +get_default_abi_for_arch () +{ + local RET + case $1 in + arm) + RET="armeabi" + ;; + arm64) + RET="arm64-v8a" + ;; + x86|x86_64|mips|mips64) + RET="$1" + ;; + mips32r6) + RET="mips" + ;; + *) + 2> echo "ERROR: Unsupported architecture name: $1, use one of: arm arm64 x86 x86_64 mips mips64" + exit 1 + ;; + esac + echo "$RET" +} + + +# Retrieve the list of default ABIs supported by a given architecture +# $1: Architecture name +# Out: space-separated list of ABI names +get_default_abis_for_arch () +{ + local RET + case $1 in + arm) + RET="armeabi armeabi-v7a armeabi-v7a-hard" + ;; + arm64) + RET="arm64-v8a" + ;; + x86|x86_64|mips|mips32r6|mips64) + RET="$1" + ;; + *) + 2> echo "ERROR: Unsupported architecture name: $1, use one of: arm arm64 x86 x86_64 mips mips64" + exit 1 + ;; + esac + echo "$RET" +} + +# Return toolchain name for given architecture and GCC version +# $1: Architecture name (e.g. 'arm') +# $2: optional, GCC version (e.g. '4.8') +# Out: default arch-specific toolchain name (e.g. 'arm-linux-androideabi-$GCC_VERSION') +# Return empty for unknown arch +get_toolchain_name_for_arch () +{ + if [ ! -z "$2" ] ; then + eval echo \"\${DEFAULT_ARCH_TOOLCHAIN_NAME_$1}-$2\" + else + eval echo \"\${DEFAULT_ARCH_TOOLCHAIN_NAME_$1}\" + fi +} + +# Return the default toolchain name for a given architecture +# $1: Architecture name (e.g. 'arm') +# Out: default arch-specific toolchain name (e.g. 'arm-linux-androideabi-$GCCVER') +# Return empty for unknown arch +get_default_toolchain_name_for_arch () +{ + local GCCVER=$(get_default_gcc_version_for_arch $1) + eval echo \"\${DEFAULT_ARCH_TOOLCHAIN_NAME_$1}-$GCCVER\" +} + +# Return the default toolchain program prefix for a given architecture +# $1: Architecture name +# Out: default arch-specific toolchain prefix (e.g. arm-linux-androideabi) +# Return empty for unknown arch +get_default_toolchain_prefix_for_arch () +{ + eval echo "\$DEFAULT_ARCH_TOOLCHAIN_PREFIX_$1" +} + +# Get the list of all toolchain names for a given architecture +# $1: architecture (e.g. 'arm') +# $2: comma separated versions (optional) +# Out: list of toolchain names for this arch (e.g. arm-linux-androideabi-4.8 arm-linux-androideabi-4.9) +# Return empty for unknown arch +get_toolchain_name_list_for_arch () +{ + local PREFIX VERSION RET ADD FIRST_GCC_VERSION VERSIONS + PREFIX=$(eval echo \"\$DEFAULT_ARCH_TOOLCHAIN_NAME_$1\") + if [ -z "$PREFIX" ]; then + return 0 + fi + RET="" + FIRST_GCC_VERSION=$(get_first_gcc_version_for_arch $1) + ADD="" + VERSIONS=$(commas_to_spaces $2) + if [ -z "$VERSIONS" ]; then + VERSIONS=$DEFAULT_GCC_VERSION_LIST + else + ADD="yes" # include everything we passed explicitly + fi + for VERSION in $VERSIONS; do + if [ -z "$ADD" -a "$VERSION" = "$FIRST_GCC_VERSION" ]; then + ADD="yes" + fi + if [ -z "$ADD" ]; then + continue + fi + RET=$RET" $PREFIX-$VERSION" + done + RET=${RET## } + echo "$RET" +} + +# Return the binutils version to be used by default when +# building a given version of GCC. This is needed to ensure +# we use binutils-2.19 when building gcc-4.4.3 for ARM and x86, +# and later binutils in other cases (mips, or gcc-4.6+). +# +# Note that technically, we could use latest binutils for all versions of +# GCC, however, in NDK r7, we did build GCC 4.4.3 with binutils-2.20.1 +# and this resulted in weird C++ debugging bugs. For NDK r7b and higher, +# binutils was reverted to 2.19, to ensure at least +# feature/bug compatibility. +# +# $1: toolchain with version numer (e.g. 'arm-linux-androideabi-4.8') +# +get_default_binutils_version_for_gcc () +{ + echo "$DEFAULT_BINUTILS_VERSION" +} + +# Return the binutils version to be used by default when +# building a given version of llvm. For llvm-3.4 or later, +# we use binutils-2.23+ to ensure the LLVMgold.so could be +# built properly. For llvm-3.3, we use binutils-2.21 as default. +# +# $1: toolchain with version numer (e.g. 'llvm-3.3') +# +get_default_binutils_version_for_llvm () +{ + echo "$DEFAULT_BINUTILS_VERSION" +} + +# Return the gdb version to be used by default when building a given +# version of GCC. +# +# $1: toolchain with version numer (e.g. 'arm-linux-androideabi-4.8') +# +get_default_gdb_version_for_gcc () +{ + echo "$DEFAULT_GDB_VERSION" +} + +# Return the gdbserver version to be used by default when building a given +# version of GCC. +# +# $1: toolchain with version numer (e.g. 'arm-linux-androideabi-4.8') +# +get_default_gdbserver_version_for_gcc () +{ + echo "$DEFAULT_GDB_VERSION" +} diff --git a/Android/toolchain_edits/build/tools/ndk-common.sh b/Android/toolchain_edits/build/tools/ndk-common.sh new file mode 100644 index 00000000..f086628a --- /dev/null +++ b/Android/toolchain_edits/build/tools/ndk-common.sh @@ -0,0 +1,980 @@ +# Copyright (C) 2009 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. +# + +# A collection of shell function definitions used by various build scripts +# in the Android NDK (Native Development Kit) +# + +# Get current script name into PROGNAME +PROGNAME=`basename $0` + +# Find the Android NDK root, assuming we are invoked from a script +# within its directory structure. +# +# $1: Variable name that will receive the path +# $2: Path of invoking script +find_ndk_root () +{ + # Try to auto-detect the NDK root by walking up the directory + # path to the current script. + local PROGDIR="`dirname \"$2\"`" + while [ -n "1" ] ; do + if [ -d "$PROGDIR/build/core" ] ; then + break + fi + if [ -z "$PROGDIR" -o "$PROGDIR" = '/' ] ; then + return 1 + fi + PROGDIR="`cd \"$PROGDIR/..\" && pwd`" + done + eval $1="$PROGDIR" +} + +# Put location of Android NDK into ANDROID_NDK_ROOT and +# perform a tiny amount of sanity check +# +if [ -z "$ANDROID_NDK_ROOT" ] ; then + find_ndk_root ANDROID_NDK_ROOT "$0" + if [ $? != 0 ]; then + echo "Please define ANDROID_NDK_ROOT to point to the root of your" + echo "Android NDK installation." + exit 1 + fi +fi + +echo "$ANDROID_NDK_ROOT" | grep -q -e " " +if [ $? = 0 ] ; then + echo "ERROR: The Android NDK installation path contains a space !" + echo "Please install to a different location." + exit 1 +fi + +if [ ! -d $ANDROID_NDK_ROOT ] ; then + echo "ERROR: Your ANDROID_NDK_ROOT variable does not point to a directory." + exit 1 +fi + +if [ ! -f $ANDROID_NDK_ROOT/build/tools/ndk-common.sh ] ; then + echo "ERROR: Your ANDROID_NDK_ROOT variable does not point to a valid directory." + exit 1 +fi + +## Use DRYRUN to find out top-level commands. +DRYRUN=${DRYRUN-no} + +## Logging support +## +VERBOSE=${VERBOSE-yes} +VERBOSE2=${VERBOSE2-no} + + +# If NDK_LOGFILE is defined in the environment, use this as the log file +TMPLOG= +if [ -n "$NDK_LOGFILE" ] ; then + mkdir -p `dirname "$NDK_LOGFILE"` && touch "$NDK_LOGFILE" + TMPLOG="$NDK_LOGFILE" +fi + +# Setup a log file where all log() and log2() output will be sent +# +# $1: log file path (optional) +# +setup_default_log_file () +{ + if [ -n "$NDK_LOGFILE" ] ; then + return + fi + if [ -n "$1" ] ; then + NDK_LOGFILE="$1" + else + NDK_LOGFILE=/tmp/ndk-log-$$.txt + fi + export NDK_LOGFILE + TMPLOG="$NDK_LOGFILE" + rm -rf "$TMPLOG" && mkdir -p `dirname "$TMPLOG"` && touch "$TMPLOG" + echo "To follow build in another terminal, please use: tail -F $TMPLOG" +} + +dump () +{ + if [ -n "$TMPLOG" ] ; then + echo "$@" >> $TMPLOG + fi + echo "$@" +} + +dump_n () +{ + if [ -n "$TMPLOG" ] ; then + printf %s "$@" >> $TMPLOG + fi + printf %s "$@" +} + +log () +{ + if [ "$VERBOSE" = "yes" ] ; then + echo "$@" + else + if [ -n "$TMPLOG" ] ; then + echo "$@" >> $TMPLOG + fi + fi +} + +log_n () +{ + if [ "$VERBOSE" = "yes" ] ; then + printf %s "$@" + else + if [ -n "$TMPLOG" ] ; then + printf %s "$@" >> $TMPLOG + fi + fi +} + +log2 () +{ + if [ "$VERBOSE2" = "yes" ] ; then + echo "$@" + else + if [ -n "$TMPLOG" ] ; then + echo "$@" >> $TMPLOG + fi + fi +} + +run () +{ + if [ "$DRYRUN" = "yes" ] ; then + echo "## SKIP COMMAND: $@" + elif [ "$VERBOSE" = "yes" ] ; then + echo "## COMMAND: $@" + "$@" 2>&1 + else + if [ -n "$TMPLOG" ] ; then + echo "## COMMAND: $@" >> $TMPLOG + "$@" >>$TMPLOG 2>&1 + else + "$@" > /dev/null 2>&1 + fi + fi +} + +run2 () +{ + if [ "$DRYRUN" = "yes" ] ; then + echo "## SKIP COMMAND: $@" + elif [ "$VERBOSE2" = "yes" ] ; then + echo "## COMMAND: $@" + "$@" 2>&1 + elif [ "$VERBOSE" = "yes" ]; then + echo "## COMMAND: $@" + if [ -n "$TMPLOG" ]; then + echo "## COMMAND: $@" >> $TMPLOG + "$@" >>$TMPLOG 2>&1 + else + "$@" > /dev/null 2>&1 + fi + else + if [ -n "$TMPLOG" ]; then + "$@" >>$TMPLOG 2>&1 + else + "$@" > /dev/null 2>&1 + fi + fi +} + +panic () +{ + dump "ERROR: $@" + exit 1 +} + +fail_panic () +{ + if [ $? != 0 ] ; then + dump "ERROR: $@" + exit 1 + fi +} + +fail_warning () +{ + if [ $? != 0 ] ; then + dump "WARNING: $@" + fi +} + + +## Utilities +## + +# Return the value of a given named variable +# $1: variable name +# +# example: +# FOO=BAR +# BAR=ZOO +# echo `var_value $FOO` +# will print 'ZOO' +# +var_value () +{ + # find a better way to do that ? + eval echo "$`echo $1`" +} + +# convert to uppercase +# assumes tr is installed on the platform ? +# +to_uppercase () +{ + echo $1 | tr "[:lower:]" "[:upper:]" +} + +## First, we need to detect the HOST CPU, because proper HOST_ARCH detection +## requires platform-specific tricks. +## +HOST_EXE="" +HOST_OS=`uname -s` +case "$HOST_OS" in + Darwin) + HOST_OS=darwin + ;; + Linux) + # note that building 32-bit binaries on x86_64 is handled later + HOST_OS=linux + ;; + FreeBsd) # note: this is not tested + HOST_OS=freebsd + ;; + CYGWIN*|*_NT-*) + HOST_OS=windows + HOST_EXE=.exe + if [ "x$OSTYPE" = xcygwin ] ; then + HOST_OS=cygwin + fi + ;; +esac + +log2 "HOST_OS=$HOST_OS" +log2 "HOST_EXE=$HOST_EXE" + +## Now find the host architecture. This must correspond to the bitness of +## the binaries we're going to run with this NDK. Certain platforms allow +## you to use a 64-bit kernel with a 32-bit userland, and unfortunately +## commands like 'uname -m' only report the kernel bitness. +## +HOST_ARCH=`uname -m` +case "$HOST_ARCH" in + i?86) HOST_ARCH=x86 + # "uname -m" reports i386 on Snow Leopard even though its architecture is + # 64-bit. In order to use it to build 64-bit toolchains we need to fix the + # reporting anomoly here. + if [ "$HOST_OS" = darwin ] ; then + if ! echo __LP64__ | (CCOPTS= gcc -E - 2>/dev/null) | grep -q __LP64__ ; then + # or if gcc -dM -E - < /dev/null | grep -q __LP64__; then + HOST_ARCH=x86_64 + fi + fi + ;; + amd64) HOST_ARCH=x86_64 + ;; + powerpc) HOST_ARCH=ppc + ;; +esac + +HOST_FILE_PROGRAM="file" +case "$HOST_OS-$HOST_ARCH" in + linux-x86_64|darwin-x86_64) + ## On Linux or Darwin, a 64-bit kernel doesn't mean that the user-land + ## is always 32-bit, so use "file" to determine the bitness of the shell + ## that invoked us. The -L option is used to de-reference symlinks. + ## + ## Note that on Darwin, a single executable can contain both x86 and + ## x86_64 machine code, so just look for x86_64 (darwin) or x86-64 (Linux) + ## in the output. + ## + ## Also note that some versions of 'file' in MacPort may report erroneous + ## result. See http://b.android.com/53769. Use /usr/bin/file if exists. + if [ "$HOST_OS" = "darwin" ]; then + SYSTEM_FILE_PROGRAM="/usr/bin/file" + test -x "$SYSTEM_FILE_PROGRAM" && HOST_FILE_PROGRAM="$SYSTEM_FILE_PROGRAM" + fi + "$HOST_FILE_PROGRAM" -L "$SHELL" | grep -q "x86[_-]64" + if [ $? != 0 ]; then + # $SHELL is not a 64-bit executable, so assume our userland is too. + log2 "Detected 32-bit userland on 64-bit kernel system!" + HOST_ARCH=x86 + fi + ;; +esac + +log2 "HOST_ARCH=$HOST_ARCH" + +# at this point, the supported values for HOST_ARCH are: +# x86 +# x86_64 +# ppc +# +# other values may be possible but haven't been tested +# +# at this point, the value of HOST_OS should be one of the following: +# linux +# darwin +# windows (MSys) +# cygwin +# +# Note that cygwin is treated as a special case because it behaves very differently +# for a few things. Other values may be possible but have not been tested +# + +# define HOST_TAG as a unique tag used to identify both the host OS and CPU +# supported values are: +# +# linux-x86 +# linux-x86_64 +# darwin-x86 +# darwin-x86_64 +# darwin-ppc +# windows +# windows-x86_64 +# +# other values are possible but were not tested. +# +compute_host_tag () +{ + HOST_TAG=${HOST_OS}-${HOST_ARCH} + # Special case for windows-x86 => windows + case $HOST_TAG in + windows-x86|cygwin-x86) + HOST_TAG="windows" + ;; + esac + log2 "HOST_TAG=$HOST_TAG" +} + +compute_host_tag + +# Compute the number of host CPU cores an HOST_NUM_CPUS +# +case "$HOST_OS" in + linux) + HOST_NUM_CPUS=`cat /proc/cpuinfo | grep processor | wc -l` + ;; + darwin|freebsd) + HOST_NUM_CPUS=`sysctl -n hw.ncpu` + ;; + windows|cygwin) + HOST_NUM_CPUS=$NUMBER_OF_PROCESSORS + ;; + *) # let's play safe here + HOST_NUM_CPUS=1 +esac + +log2 "HOST_NUM_CPUS=$HOST_NUM_CPUS" + +# If BUILD_NUM_CPUS is not already defined in your environment, +# define it as the double of HOST_NUM_CPUS. This is used to +# run Make commands in parralles, as in 'make -j$BUILD_NUM_CPUS' +# +if [ -z "$BUILD_NUM_CPUS" ] ; then + BUILD_NUM_CPUS=`expr $HOST_NUM_CPUS \* 2` +fi + +log2 "BUILD_NUM_CPUS=$BUILD_NUM_CPUS" + + +## HOST TOOLCHAIN SUPPORT +## + +# force the generation of 32-bit binaries on 64-bit systems +# +FORCE_32BIT=no +force_32bit_binaries () +{ + if [ "$HOST_ARCH" = x86_64 ] ; then + log2 "Forcing generation of 32-bit host binaries on $HOST_ARCH" + FORCE_32BIT=yes + HOST_ARCH=x86 + log2 "HOST_ARCH=$HOST_ARCH" + compute_host_tag + fi +} + +# On Windows, cygwin binaries will be generated by default, but +# you can force mingw ones that do not link to cygwin.dll if you +# call this function. +# +disable_cygwin () +{ + if [ $HOST_OS = cygwin ] ; then + log2 "Disabling cygwin binaries generation" + CFLAGS="$CFLAGS -mno-cygwin" + LDFLAGS="$LDFLAGS -mno-cygwin" + HOST_OS=windows + compute_host_tag + fi +} + +# Various probes are going to need to run a small C program +mkdir -p /tmp/ndk-$USER/tmp/tests + +TMPC=/tmp/ndk-$USER/tmp/tests/test-$$.c +TMPO=/tmp/ndk-$USER/tmp/tests/test-$$.o +TMPE=/tmp/ndk-$USER/tmp/tests/test-$$$EXE +TMPL=/tmp/ndk-$USER/tmp/tests/test-$$.log + +# cleanup temporary files +clean_temp () +{ + rm -f $TMPC $TMPO $TMPL $TMPE +} + +# cleanup temp files then exit with an error +clean_exit () +{ + clean_temp + exit 1 +} + +# this function will setup the compiler and linker and check that they work as advertised +# note that you should call 'force_32bit_binaries' before this one if you want it to +# generate 32-bit binaries on 64-bit systems (that support it). +# +setup_toolchain () +{ + if [ -z "$CC" ] ; then + CC=gcc + fi + if [ -z "$CXX" ] ; then + CXX=g++ + fi + if [ -z "$CXXFLAGS" ] ; then + CXXFLAGS="$CFLAGS" + fi + if [ -z "$LD" ] ; then + LD="$CC" + fi + + log2 "Using '$CC' as the C compiler" + + # check that we can compile a trivial C program with this compiler + mkdir -p $(dirname "$TMPC") + cat > $TMPC < $TMPC < +using namespace std; +int main() +{ + cout << "Hello World!" << endl; + return 0; +} +EOF + + compile_cpp + if [ $? != 0 ] ; then + echo "your C++ compiler doesn't seem to work" + cat $TMPL + clean_exit + fi + + log "CXX : C++ compiler check ok ($CXX)" + + # XXX: TODO perform AR checks + AR=ar + ARFLAGS= +} + +# try to compile the current source file in $TMPC into an object +# stores the error log into $TMPL +# +compile () +{ + log2 "Object : $CC -o $TMPO -c $CFLAGS $TMPC" + $CC -o $TMPO -c $CFLAGS $TMPC 2> $TMPL +} + +compile_cpp () +{ + log2 "Object : $CXX -o $TMPO -c $CXXFLAGS $TMPC" + $CXX -o $TMPO -c $CXXFLAGS $TMPC 2> $TMPL +} + +# try to link the recently built file into an executable. error log in $TMPL +# +link() +{ + log2 "Link : $LD -o $TMPE $TMPO $LDFLAGS" + $LD -o $TMPE $TMPO $LDFLAGS 2> $TMPL +} + +# run a command +# +execute() +{ + log2 "Running: $*" + $* +} + +# perform a simple compile / link / run of the source file in $TMPC +compile_exec_run() +{ + log2 "RunExec : $CC -o $TMPE $CFLAGS $TMPC" + compile + if [ $? != 0 ] ; then + echo "Failure to compile test program" + cat $TMPC + cat $TMPL + clean_exit + fi + link + if [ $? != 0 ] ; then + echo "Failure to link test program" + cat $TMPC + echo "------" + cat $TMPL + clean_exit + fi + $TMPE +} + +pattern_match () +{ + echo "$2" | grep -q -E -e "$1" +} + +# Let's check that we have a working md5sum here +check_md5sum () +{ + A_MD5=`echo "A" | md5sum | cut -d' ' -f1` + if [ "$A_MD5" != "bf072e9119077b4e76437a93986787ef" ] ; then + echo "Please install md5sum on this machine" + exit 2 + fi +} + +# Find if a given shell program is available. +# We need to take care of the fact that the 'which ' command +# may return either an empty string (Linux) or something like +# "no in ..." (Darwin). Also, we need to redirect stderr +# to /dev/null for Cygwin +# +# $1: variable name +# $2: program name +# +# Result: set $1 to the full path of the corresponding command +# or to the empty/undefined string if not available +# +find_program () +{ + local PROG RET + PROG=`which $2 2>/dev/null` + RET=$? + if [ $RET != 0 ]; then + PROG= + fi + eval $1=\"$PROG\" + return $RET +} + +prepare_download () +{ + find_program CMD_WGET wget + find_program CMD_CURL curl + find_program CMD_SCRP scp +} + +find_pbzip2 () +{ + if [ -z "$_PBZIP2_initialized" ] ; then + find_program PBZIP2 pbzip2 + _PBZIP2_initialized="yes" + fi +} + +# Download a file with either 'curl', 'wget' or 'scp' +# +# $1: source URL (e.g. http://foo.com, ssh://blah, /some/path) +# $2: target file +download_file () +{ + # Is this HTTP, HTTPS or FTP ? + if pattern_match "^(http|https|ftp):.*" "$1"; then + if [ -n "$CMD_WGET" ] ; then + run $CMD_WGET -O $2 $1 + elif [ -n "$CMD_CURL" ] ; then + run $CMD_CURL -o $2 $1 + else + echo "Please install wget or curl on this machine" + exit 1 + fi + return + fi + + # Is this SSH ? + # Accept both ssh:// or : + # + if pattern_match "^(ssh|[^:]+):.*" "$1"; then + if [ -n "$CMD_SCP" ] ; then + scp_src=`echo $1 | sed -e s%ssh://%%g` + run $CMD_SCP $scp_src $2 + else + echo "Please install scp on this machine" + exit 1 + fi + return + fi + + # Is this a file copy ? + # Accept both file:// or / + # + if pattern_match "^(file://|/).*" "$1"; then + cp_src=`echo $1 | sed -e s%^file://%%g` + run cp -f $cp_src $2 + return + fi +} + +# Form the relative path between from one abs path to another +# +# $1 : start path +# $2 : end path +# +# From: +# http://stackoverflow.com/questions/2564634/bash-convert-absolute-path-into-relative-path-given-a-current-directory +relpath () +{ + [ $# -ge 1 ] && [ $# -le 2 ] || return 1 + current="${2:+"$1"}" + target="${2:-"$1"}" + [ "$target" != . ] || target=/ + target="/${target##/}" + [ "$current" != . ] || current=/ + current="${current:="/"}" + current="/${current##/}" + appendix="${target##/}" + relative='' + while appendix="${target#"$current"/}" + [ "$current" != '/' ] && [ "$appendix" = "$target" ]; do + if [ "$current" = "$appendix" ]; then + relative="${relative:-.}" + echo "${relative#/}" + return 0 + fi + current="${current%/*}" + relative="$relative${relative:+/}.." + done + relative="$relative${relative:+${appendix:+/}}${appendix#/}" + echo "$relative" +} + +# Unpack a given archive +# +# $1: archive file path +# $2: optional target directory (current one if omitted) +# +unpack_archive () +{ + local ARCHIVE="$1" + local DIR=${2-.} + local RESULT TARFLAGS ZIPFLAGS + mkdir -p "$DIR" + if [ "$VERBOSE2" = "yes" ] ; then + TARFLAGS="vxpf" + ZIPFLAGS="" + else + TARFLAGS="xpf" + ZIPFLAGS="q" + fi + case "$ARCHIVE" in + *.zip) + (cd $DIR && run unzip $ZIPFLAGS "$ARCHIVE") + ;; + *.tar) + run tar $TARFLAGS "$ARCHIVE" -C $DIR + ;; + *.tar.gz) + run tar z$TARFLAGS "$ARCHIVE" -C $DIR + ;; + *.tar.bz2) + find_pbzip2 + if [ -n "$PBZIP2" ] ; then + run tar --use-compress-prog=pbzip2 -$TARFLAGS "$ARCHIVE" -C $DIR + else + run tar j$TARFLAGS "$ARCHIVE" -C $DIR + fi + # remove ._* files by MacOSX to preserve resource forks we don't need + find $DIR -name "\._*" -exec rm {} \; + ;; + *) + panic "Cannot unpack archive with unknown extension: $ARCHIVE" + ;; + esac +} + +# Pack a given archive +# +# $1: archive file path (including extension) +# $2: source directory for archive content +# $3+: list of files (including patterns), all if empty +pack_archive () +{ + local ARCHIVE="$1" + local SRCDIR="$2" + local SRCFILES + local TARFLAGS ZIPFLAGS + shift; shift; + if [ -z "$1" ] ; then + SRCFILES="*" + else + SRCFILES="$@" + fi + if [ "`basename $ARCHIVE`" = "$ARCHIVE" ] ; then + ARCHIVE="`pwd`/$ARCHIVE" + fi + mkdir -p `dirname $ARCHIVE` + if [ "$VERBOSE2" = "yes" ] ; then + TARFLAGS="vcf" + ZIPFLAGS="-9r" + else + TARFLAGS="cf" + ZIPFLAGS="-9qr" + fi + # Ensure symlinks are stored as is in zip files. for toolchains + # this can save up to 7 MB in the size of the final archive + #ZIPFLAGS="$ZIPFLAGS --symlinks" + case "$ARCHIVE" in + *.zip) + (cd $SRCDIR && run zip $ZIPFLAGS "$ARCHIVE" $SRCFILES) + ;; + *.tar) + (cd $SRCDIR && run tar $TARFLAGS "$ARCHIVE" $SRCFILES) + ;; + *.tar.gz) + (cd $SRCDIR && run tar z$TARFLAGS "$ARCHIVE" $SRCFILES) + ;; + *.tar.bz2) + find_pbzip2 + if [ -n "$PBZIP2" ] ; then + (cd $SRCDIR && run tar --use-compress-prog=pbzip2 -$TARFLAGS "$ARCHIVE" $SRCFILES) + else + (cd $SRCDIR && run tar j$TARFLAGS "$ARCHIVE" $SRCFILES) + fi + ;; + *) + panic "Unsupported archive format: $ARCHIVE" + ;; + esac +} + +# Copy a directory, create target location if needed +# +# $1: source directory +# $2: target directory location +# +copy_directory () +{ + local SRCDIR="$1" + local DSTDIR="$2" + if [ ! -d "$SRCDIR" ] ; then + panic "Can't copy from non-directory: $SRCDIR" + fi + log "Copying directory: " + log " from $SRCDIR" + log " to $DSTDIR" + mkdir -p "$DSTDIR" && (cd "$SRCDIR" && 2>/dev/null tar cf - *) | (tar xf - -C "$DSTDIR") + fail_panic "Cannot copy to directory: $DSTDIR" +} + +# Move a directory, create target location if needed +# +# $1: source directory +# $2: target directory location +# +move_directory () +{ + local SRCDIR="$1" + local DSTDIR="$2" + if [ ! -d "$SRCDIR" ] ; then + panic "Can't move from non-directory: $SRCDIR" + fi + log "Move directory: " + log " from $SRCDIR" + log " to $DSTDIR" + mkdir -p "$DSTDIR" && (mv "$SRCDIR"/* "$DSTDIR") + fail_panic "Cannot move to directory: $DSTDIR" +} + +# This is the same than copy_directory(), but symlinks will be replaced +# by the file they actually point to instead. +copy_directory_nolinks () +{ + local SRCDIR="$1" + local DSTDIR="$2" + if [ ! -d "$SRCDIR" ] ; then + panic "Can't copy from non-directory: $SRCDIR" + fi + log "Copying directory (without symlinks): " + log " from $SRCDIR" + log " to $DSTDIR" + mkdir -p "$DSTDIR" && (cd "$SRCDIR" && tar chf - *) | (tar xf - -C "$DSTDIR") + fail_panic "Cannot copy to directory: $DSTDIR" +} + +# Copy certain files from one directory to another one +# $1: source directory +# $2: target directory +# $3+: file list (including patterns) +copy_file_list () +{ + local SRCDIR="$1" + local DSTDIR="$2" + shift; shift; + if [ ! -d "$SRCDIR" ] ; then + panic "Cant' copy from non-directory: $SRCDIR" + fi + log "Copying file: $@" + log " from $SRCDIR" + log " to $DSTDIR" + mkdir -p "$DSTDIR" && (cd "$SRCDIR" && (echo $@ | tr ' ' '\n' | tar cf - -T -)) | (tar xf - -C "$DSTDIR") + fail_panic "Cannot copy files to directory: $DSTDIR" +} + +# Rotate a log file +# If the given log file exist, add a -1 to the end of the file. +# If older log files exist, rename them to - +# $1: log file +# $2: maximum version to retain [optional] +rotate_log () +{ + # Default Maximum versions to retain + local MAXVER="5" + local LOGFILE="$1" + shift; + if [ ! -z "$1" ] ; then + local tmpmax="$1" + shift; + tmpmax=`expr $tmpmax + 0` + if [ $tmpmax -lt 1 ] ; then + panic "Invalid maximum log file versions '$tmpmax' invalid; defaulting to $MAXVER" + else + MAXVER=$tmpmax; + fi + fi + + # Do Nothing if the log file does not exist + if [ ! -f "${LOGFILE}" ] ; then + return + fi + + # Rename existing older versions + ver=$MAXVER + while [ $ver -ge 1 ] + do + local prev=$(( $ver - 1 )) + local old="-$prev" + + # Instead of old version 0; use the original filename + if [ $ver -eq 1 ] ; then + old="" + fi + + if [ -f "${LOGFILE}${old}" ] ; then + mv -f "${LOGFILE}${old}" "${LOGFILE}-${ver}" + fi + + ver=$prev + done +} + +# Dereference symlink +# $1+: directories +dereference_symlink () +{ + local DIRECTORY SYMLINKS DIR FILE LINK + for DIRECTORY in "$@"; do + if [ -d "$DIRECTORY" ]; then + while true; do + # Find all symlinks in this directory. + SYMLINKS=`find $DIRECTORY -type l` + if [ -z "$SYMLINKS" ]; then + break; + fi + # Iterate symlinks + for SYMLINK in $SYMLINKS; do + if [ -L "$SYMLINK" ]; then + DIR=`dirname "$SYMLINK"` + FILE=`basename "$SYMLINK"` + # Note that if `readlink $FILE` is also a link, we want to deal + # with it in the next iteration. There is potential infinite-loop + # situation for cicular link doesn't exist in our case, though. + (cd "$DIR" && \ + LINK=`readlink "$FILE"` && \ + test ! -L "$LINK" && \ + rm -f "$FILE" && \ + cp -a "$LINK" "$FILE") + fi + done + done + fi + done +} diff --git a/Android/toolchain_edits/build/tools/prebuilt-common.sh b/Android/toolchain_edits/build/tools/prebuilt-common.sh new file mode 100644 index 00000000..b88eb3c2 --- /dev/null +++ b/Android/toolchain_edits/build/tools/prebuilt-common.sh @@ -0,0 +1,1675 @@ +# Common functions for all prebuilt-related scripts +# This is included/sourced by other scripts +# + +# ensure stable sort order +export LC_ALL=C + +# NDK_BUILDTOOLS_PATH should point to the directory containing +# this script. If it is not defined, assume that this is one of +# the scripts in the same directory that sourced this file. +# +if [ -z "$NDK_BUILDTOOLS_PATH" ]; then + NDK_BUILDTOOLS_PATH=$(dirname $0) + if [ ! -f "$NDK_BUILDTOOLS_PATH/prebuilt-common.sh" ]; then + echo "INTERNAL ERROR: Please define NDK_BUILDTOOLS_PATH to point to $$NDK/build/tools" + exit 1 + fi +fi + +# Warn about /bin/sh ins't bash. +if [ -z "$BASH_VERSION" ] ; then + echo "WARNING: The shell running this script isn't bash. Although we try to avoid bashism in scripts, things can happen." +fi + +NDK_BUILDTOOLS_ABSPATH=$(cd $NDK_BUILDTOOLS_PATH && pwd) + +. $NDK_BUILDTOOLS_PATH/ndk-common.sh +. $NDK_BUILDTOOLS_PATH/dev-defaults.sh + + +# Given an input string of the form --, where +# can be ., extract +extract_version () +{ + echo $1 | tr '-' '\n' | tail -1 +} + +# $1: versioned name (e.g. arm-linux-androideabi-4.8) +# Out: major version (e.g. 4) +# +# Examples: arm-linux-androideabi-4.4.3 -> 4 +# gmp-0.81 -> 0 +# +extract_major_version () +{ + local RET=$(extract_version $1 | cut -d . -f 1) + RET=${RET:-0} + echo $RET +} + +# Same as extract_major_version, but for the minor version number +# $1: versioned named +# Out: minor version +# +extract_minor_version () +{ + local RET=$(extract_version $1 | cut -d . -f 2) + RET=${RET:-0} + echo $RET +} + +# Compare two version numbers and only succeeds if the first one is +# greather or equal than the second one. +# +# $1: first version (e.g. 4.9) +# $2: second version (e.g. 4.8) +# +# Example: version_is_at_least 4.9 4.8 --> success +# +version_is_at_least () +{ + local A_MAJOR A_MINOR B_MAJOR B_MINOR + A_MAJOR=$(extract_major_version $1) + B_MAJOR=$(extract_major_version $2) + + if [ $A_MAJOR -lt $B_MAJOR ]; then + return 1 + elif [ $A_MAJOR -gt $B_MAJOR ]; then + return 0 + fi + + # We have A_MAJOR == B_MAJOR here + + A_MINOR=$(extract_minor_version $1) + B_MINOR=$(extract_minor_version $2) + + if [ $A_MINOR -lt $B_MINOR ]; then + return 1 + else + return 0 + fi +} + +# Binaries built by new linux host toolchain "prebuilts/gcc/linux-x86/host/x86_64-linux-glibc2.11-4.8" +# may contain functions missing from server runs very old libc.so. Define __USE_OLD_LINUX_HOST_GCC=yes +# to use the original "prebuilts/tools/gcc-sdk" with glibc2.7 sysroot +if [ -z "$__USE_OLD_LINUX_HOST_GCC" ]; then + __USE_OLD_LINUX_HOST_GCC=yes # no +fi + +#==================================================== +# +# UTILITY FUNCTIONS +# +#==================================================== + +# Return the maximum length of a series of strings +# +# Usage: len=`max_length ...` +# +max_length () +{ + echo "$@" | tr ' ' '\n' | awk 'BEGIN {max=0} {len=length($1); if (len > max) max=len} END {print max}' +} + +# Translate dashes to underscores +# Usage: str=`dashes_to_underscores ` +dashes_to_underscores () +{ + echo "$@" | tr '-' '_' +} + +# Translate underscores to dashes +# Usage: str=`underscores_to_dashes ` +underscores_to_dashes () +{ + echo "$@" | tr '_' '-' +} + +# Translate commas to spaces +# Usage: str=`commas_to_spaces ` +commas_to_spaces () +{ + echo "$@" | tr ',' ' ' +} + +# Translate spaces to commas +# Usage: list=`spaces_to_commas ` +spaces_to_commas () +{ + echo "$@" | tr ' ' ',' +} + +# Remove trailing path of a path +# $1: path +remove_trailing_slash () { + echo ${1%%/} +} + +# Reverse a file path directory +# foo -> . +# foo/bar -> .. +# foo/bar/zoo -> ../.. +reverse_path () +{ + local path cur item + path=${1%%/} # remove trailing slash + cur="." + if [ "$path" != "." ] ; then + for item in $(echo "$path" | tr '/' ' '); do + cur="../$cur" + done + fi + echo ${cur%%/.} +} + +# test_reverse_path () +# { +# rr=`reverse_path $1` +# if [ "$rr" != "$2" ] ; then +# echo "ERROR: reverse_path '$1' -> '$rr' (expected '$2')" +# fi +# } +# +# test_reverse_path . . +# test_reverse_path ./ . +# test_reverse_path foo .. +# test_reverse_path foo/ .. +# test_reverse_path foo/bar ../.. +# test_reverse_path foo/bar/ ../.. +# test_reverse_path foo/bar/zoo ../../.. +# test_reverse_path foo/bar/zoo/ ../../.. + +# Sort a space-separated list and remove duplicates +# $1+: slist +# Output: new slist +sort_uniq () +{ + local RET + RET=$(echo "$@" | tr ' ' '\n' | sort -u) + echo $RET +} + +# Return the list of all regular files under a given directory +# $1: Directory path +# Output: list of files, relative to $1 +list_files_under () +{ + if [ -d "$1" ]; then + (cd $1 && find . -type f | sed -e "s!./!!" | sort -u) + else + echo "" + fi +} + +# Returns all words in text that do not match any of the pattern +# $1: pattern +# $2: text +filter_out () +{ + local PATTERN="$1" + local TEXT="$2" + for pat in $PATTERN; do + pat=$"${pat//\//\\/}" + TEXT=$(echo $TEXT | sed -e 's/'$pat' //g' -e 's/'$pat'$//g') + done + echo $TEXT +} + +# Assign a value to a variable +# $1: Variable name +# $2: Value +var_assign () +{ + eval $1=\"$2\" +} + +#==================================================== +# +# OPTION PROCESSING +# +#==================================================== + +# We recognize the following option formats: +# +# -f +# --flag +# +# -s +# --setting= +# + +# NOTE: We translate '-' into '_' when storing the options in global variables +# + +OPTIONS="" +OPTION_FLAGS="" +OPTION_SETTINGS="" + +# Set a given option attribute +# $1: option name +# $2: option attribute +# $3: attribute value +# +option_set_attr () +{ + eval OPTIONS_$1_$2=\"$3\" +} + +# Get a given option attribute +# $1: option name +# $2: option attribute +# +option_get_attr () +{ + echo `var_value OPTIONS_$1_$2` +} + +# Register a new option +# $1: option +# $2: small abstract for the option +# $3: optional. default value +# +register_option_internal () +{ + optlabel= + optname= + optvalue= + opttype= + while [ -n "1" ] ; do + # Check for something like --setting= + echo "$1" | grep -q -E -e '^--[^=]+=<.+>$' + if [ $? = 0 ] ; then + optlabel=`expr -- "$1" : '\(--[^=]*\)=.*'` + optvalue=`expr -- "$1" : '--[^=]*=\(<.*>\)'` + opttype="long_setting" + break + fi + + # Check for something like --flag + echo "$1" | grep -q -E -e '^--[^=]+$' + if [ $? = 0 ] ; then + optlabel="$1" + opttype="long_flag" + break + fi + + # Check for something like -f + echo "$1" | grep -q -E -e '^-[A-Za-z0-9]<.+>$' + if [ $? = 0 ] ; then + optlabel=`expr -- "$1" : '\(-.\).*'` + optvalue=`expr -- "$1" : '-.\(<.+>\)'` + opttype="short_setting" + break + fi + + # Check for something like -f + echo "$1" | grep -q -E -e '^-.$' + if [ $? = 0 ] ; then + optlabel="$1" + opttype="short_flag" + break + fi + + echo "ERROR: Invalid option format: $1" + echo " Check register_option call" + exit 1 + done + + log "new option: type='$opttype' name='$optlabel' value='$optvalue'" + + optname=`dashes_to_underscores $optlabel` + OPTIONS="$OPTIONS $optname" + OPTIONS_TEXT="$OPTIONS_TEXT $1" + option_set_attr $optname label "$optlabel" + option_set_attr $optname otype "$opttype" + option_set_attr $optname value "$optvalue" + option_set_attr $optname text "$1" + option_set_attr $optname abstract "$2" + option_set_attr $optname default "$3" +} + +# Register a new option with a function callback. +# +# $1: option +# $2: name of function that will be called when the option is parsed +# $3: small abstract for the option +# $4: optional. default value +# +register_option () +{ + local optname optvalue opttype optlabel + register_option_internal "$1" "$3" "$4" + option_set_attr $optname funcname "$2" +} + +# Register a new option with a variable store +# +# $1: option +# $2: name of variable that will be set by this option +# $3: small abstract for the option +# +# NOTE: The current value of $2 is used as the default +# +register_var_option () +{ + local optname optvalue opttype optlabel + register_option_internal "$1" "$3" "`var_value $2`" + option_set_attr $optname varname "$2" +} + + +MINGW=no +DARWIN=no +do_mingw_option () +{ + if [ "$DARWIN" = "yes" ]; then + echo "Can not have both --mingw and --darwin" + exit 1 + fi + MINGW=yes; +} +do_darwin_option () +{ + if [ "$MINGW" = "yes" ]; then + echo "Can not have both --mingw and --darwin" + exit 1 + fi + DARWIN=yes; +} + +register_canadian_option () +{ + if [ "$HOST_OS" = "linux" ] ; then + register_option "--mingw" do_mingw_option "Generate windows binaries on Linux." + register_option "--darwin" do_darwin_option "Generate darwin binaries on Linux." + fi +} + +TRY64=no +do_try64_option () { TRY64=yes; } + +register_try64_option () +{ + register_option "--try-64" do_try64_option "Generate 64-bit binaries." +} + + +register_jobs_option () +{ + NUM_JOBS=$BUILD_NUM_CPUS + register_var_option "-j" NUM_JOBS "Use parallel build jobs" +} + +# Print the help, including a list of registered options for this program +# Note: Assumes PROGRAM_PARAMETERS and PROGRAM_DESCRIPTION exist and +# correspond to the parameters list and the program description +# +print_help () +{ + local opt text abstract default + + echo "Usage: $PROGNAME [options] $PROGRAM_PARAMETERS" + echo "" + if [ -n "$PROGRAM_DESCRIPTION" ] ; then + echo "$PROGRAM_DESCRIPTION" + echo "" + fi + echo "Valid options (defaults are in brackets):" + echo "" + + maxw=`max_length "$OPTIONS_TEXT"` + AWK_SCRIPT=`echo "{ printf \"%-${maxw}s\", \\$1 }"` + for opt in $OPTIONS; do + text=`option_get_attr $opt text | awk "$AWK_SCRIPT"` + abstract=`option_get_attr $opt abstract` + default=`option_get_attr $opt default` + if [ -n "$default" ] ; then + echo " $text $abstract [$default]" + else + echo " $text $abstract" + fi + done + echo "" +} + +option_panic_no_args () +{ + echo "ERROR: Option '$1' does not take arguments. See --help for usage." + exit 1 +} + +option_panic_missing_arg () +{ + echo "ERROR: Option '$1' requires an argument. See --help for usage." + exit 1 +} + +extract_parameters () +{ + local opt optname otype value name fin funcname + PARAMETERS="" + while [ -n "$1" ] ; do + # If the parameter does not begin with a dash + # it is not an option. + param=`expr -- "$1" : '^\([^\-].*\)$'` + if [ -n "$param" ] ; then + if [ -z "$PARAMETERS" ] ; then + PARAMETERS="$1" + else + PARAMETERS="$PARAMETERS $1" + fi + shift + continue + fi + + while [ -n "1" ] ; do + # Try to match a long setting, i.e. --option=value + opt=`expr -- "$1" : '^\(--[^=]*\)=.*$'` + if [ -n "$opt" ] ; then + otype="long_setting" + value=`expr -- "$1" : '^--[^=]*=\(.*\)$'` + break + fi + + # Try to match a long flag, i.e. --option + opt=`expr -- "$1" : '^\(--.*\)$'` + if [ -n "$opt" ] ; then + otype="long_flag" + value="yes" + break + fi + + # Try to match a short setting, i.e. -o + opt=`expr -- "$1" : '^\(-[A-Za-z0-9]\)..*$'` + if [ -n "$opt" ] ; then + otype="short_setting" + value=`expr -- "$1" : '^-.\(.*\)$'` + break + fi + + # Try to match a short flag, i.e. -o + opt=`expr -- "$1" : '^\(-.\)$'` + if [ -n "$opt" ] ; then + otype="short_flag" + value="yes" + break + fi + + echo "ERROR: Unknown option '$1'. Use --help for list of valid values." + exit 1 + done + + #echo "Found opt='$opt' otype='$otype' value='$value'" + + name=`dashes_to_underscores $opt` + found=0 + for xopt in $OPTIONS; do + if [ "$name" != "$xopt" ] ; then + continue + fi + # Check that the type is correct here + # + # This also allows us to handle -o as -o + # + xotype=`option_get_attr $name otype` + if [ "$otype" != "$xotype" ] ; then + case "$xotype" in + "short_flag") + option_panic_no_args $opt + ;; + "short_setting") + if [ -z "$2" ] ; then + option_panic_missing_arg $opt + fi + value="$2" + shift + ;; + "long_flag") + option_panic_no_args $opt + ;; + "long_setting") + option_panic_missing_arg $opt + ;; + esac + fi + found=1 + break + break + done + if [ "$found" = "0" ] ; then + echo "ERROR: Unknown option '$opt'. See --help for usage." + exit 1 + fi + # Set variable or launch option-specific function. + varname=`option_get_attr $name varname` + if [ -n "$varname" ] ; then + eval ${varname}=\"$value\" + else + eval `option_get_attr $name funcname` \"$value\" + fi + shift + done +} + +do_option_help () +{ + print_help + exit 0 +} + +VERBOSE=no +VERBOSE2=no +do_option_verbose () +{ + if [ $VERBOSE = "yes" ] ; then + VERBOSE2=yes + else + VERBOSE=yes + fi +} + +DRYRUN=no +do_option_dryrun () +{ + DRYRUN=yes +} + +register_option "--help" do_option_help "Print this help." +register_option "--verbose" do_option_verbose "Enable verbose mode." +register_option "--dryrun" do_option_dryrun "Set to dryrun mode." + +#==================================================== +# +# TOOLCHAIN AND ABI PROCESSING +# +#==================================================== + +# Determine optional variable value +# $1: final variable name +# $2: option variable name +# $3: small description for the option +fix_option () +{ + if [ -n "$2" ] ; then + eval $1="$2" + log "Using specific $3: $2" + else + log "Using default $3: `var_value $1`" + fi +} + + +# If SYSROOT is empty, check that $1/$2 contains a sysroot +# and set the variable to it. +# +# $1: sysroot path +# $2: platform/arch suffix +check_sysroot () +{ + if [ -z "$SYSROOT" ] ; then + log "Probing directory for sysroot: $1/$2" + if [ -d $1/$2 ] ; then + SYSROOT=$1/$2 + fi + fi +} + +# Determine sysroot +# $1: Option value (or empty) +# +fix_sysroot () +{ + if [ -n "$1" ] ; then + eval SYSROOT="$1" + log "Using specified sysroot: $1" + else + SYSROOT_SUFFIX=$PLATFORM/arch-$ARCH + SYSROOT= + check_sysroot $NDK_DIR/platforms $SYSROOT_SUFFIX + check_sysroot $ANDROID_NDK_ROOT/platforms $SYSROOT_SUFFIX + check_sysroot `dirname $ANDROID_NDK_ROOT`/development/ndk/platforms $SYSROOT_SUFFIX + + if [ -z "$SYSROOT" ] ; then + echo "ERROR: Could not find NDK sysroot path for $SYSROOT_SUFFIX." + echo " Use --sysroot= to specify one." + exit 1 + fi + fi + + if [ ! -f $SYSROOT/usr/include/stdlib.h ] ; then + echo "ERROR: Invalid sysroot path: $SYSROOT" + echo " Use --sysroot= to indicate a valid one." + exit 1 + fi +} + +# 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: Optional MacOS X minimum version (e.g. 10.5) +DARWIN_MINVER=10.6 +check_darwin_sdk () +{ + local MACSDK="$1" + local MINVER=$2 + + if [ -z "$MINVER" ] ; then + # expect SDK root path ended up with either MacOSX##.#.sdk or MacOSX##.#u.sdk + MINVER=${MACSDK##*MacOSX} + MINVER=${MINVER%%.sdk*} + if [ "$MINVER" = "10.4u" ]; then + MINVER=10.4 + fi + fi + if [ -d "$MACSDK" ] ; then + HOST_CFLAGS=$HOST_CFLAGS" -isysroot $MACSDK -mmacosx-version-min=$MINVER -DMAXOSX_DEPLOYEMENT_TARGET=$MINVER" + HOST_LDFLAGS=$HOST_LDFLAGS" -Wl,-syslibroot,$MACSDK -mmacosx-version-min=$MINVER" + DARWIN_MINVER=$MINVER + return 0 # success + fi + return 1 +} + +# Probe Darwin SDK in specified diectory $DARWIN_SYSROOT, or +# /Developer/SDKs/MacOSX10.6.sdk +# +probe_darwin_sdk () +{ + if [ -n "$DARWIN_SYSROOT" ]; then + if check_darwin_sdk "$DARWIN_SYSROOT"; then + log "Use darwin sysroot $DARWIN_SYSROOT" + else + echo "darwin sysroot $DARWIN_SYSROOT is not valid" + exit 1 + fi + elif check_darwin_sdk /Developer/SDKs/MacOSX10.6.sdk 10.6; then + log "Generating Snow Leopard-compatible binaries!" + else + local version=`sw_vers -productVersion` + log "Generating $version-compatible binaries!" + fi +} + +handle_canadian_build () +{ + HOST_EXE= + if [ "$MINGW" = "yes" -o "$DARWIN" = "yes" ] ; then + case $HOST_TAG in + linux-*) + ;; + *) + echo "ERROR: Can only enable --mingw or --darwin on Linux platforms !" + exit 1 + ;; + esac + if [ "$MINGW" = "yes" ] ; then + # NOTE: Use x86_64-pc-mingw32msvc or i586-pc-mingw32msvc because wrappers are generated + # using these names + if [ "$TRY64" = "yes" ]; then + ABI_CONFIGURE_HOST=x86_64-pc-mingw32msvc + HOST_TAG=windows-x86_64 + else + ABI_CONFIGURE_HOST=i586-pc-mingw32msvc + HOST_TAG=windows + fi + HOST_OS=windows + HOST_EXE=.exe + else + if [ "$TRY64" = "yes" ]; then + ABI_CONFIGURE_HOST=x86_64-apple-darwin + HOST_TAG=darwin-x86_64 + else + ABI_CONFIGURE_HOST=i686-apple-darwin + HOST_TAG=darwin-x86 + fi + HOST_OS=darwin + fi + fi +} + +# Find mingw toolchain +# +# Set MINGW_GCC to the found mingw toolchain +# +find_mingw_toolchain () +{ + if [ "$DEBIAN_NAME" -a "$BINPREFIX" -a "$MINGW_GCC" ]; then + return + fi + # IMPORTANT NOTE: binutils 2.21 requires a cross toolchain named + # i585-pc-mingw32msvc-gcc, or it will fail its configure step late + # in the toolchain build. Note that binutils 2.19 can build properly + # with i585-mingw32mvsc-gcc, which is the name used by the 'mingw32' + # toolchain install on Debian/Ubuntu. + # + # To solve this dilemma, we create a wrapper toolchain named + # i586-pc-mingw32msvc-gcc that really calls i586-mingw32msvc-gcc, + # this works with all versions of binutils. + # + # We apply the same logic to the 64-bit Windows cross-toolchain + # + # Fedora note: On Fedora it's x86_64-w64-mingw32- or i686-w64-mingw32- + # On older Fedora it's 32-bit only and called i686-pc-mingw32- + # so we just add more prefixes to the list to check. + if [ "$HOST_ARCH" = "x86_64" -a "$TRY64" = "yes" ]; then + BINPREFIX=x86_64-pc-mingw32msvc- + BINPREFIXLST="x86_64-pc-mingw32msvc- x86_64-w64-mingw32- amd64-mingw32msvc-" + DEBIAN_NAME=mingw64 + else + # we are trying 32 bit anyway, so forcing it to avoid build issues + force_32bit_binaries + BINPREFIX=i586-pc-mingw32msvc- + BINPREFIXLST="i586-pc-mingw32msvc- i686-pc-mingw32- i586-mingw32msvc- i686-w64-mingw32-" + DEBIAN_NAME=mingw32 + fi + + # Scan $BINPREFIXLST list to find installed mingw toolchain. It will be + # wrapped later with $BINPREFIX. + for i in $BINPREFIXLST; do + find_program MINGW_GCC ${i}gcc + if [ -n "$MINGW_GCC" ]; then + dump "Found mingw toolchain: $MINGW_GCC" + break + fi + done +} + +# Check there is a working cross-toolchain installed. +# +# $1: install directory for mingw/darwin wrapper toolchain +# +prepare_canadian_toolchain () +{ + if [ "$MINGW" != "yes" -a "$DARWIN" != "yes" ]; then + return + fi + CROSS_GCC= + if [ "$MINGW" = "yes" ]; then + find_mingw_toolchain + if [ -z "$MINGW_GCC" ]; then + echo "ERROR: Could not find in your PATH any of:" + for i in $BINPREFIXLST; do echo " ${i}gcc"; done + echo "Please install the corresponding cross-toolchain and re-run this script" + echo "TIP: On Debian or Ubuntu, try: sudo apt-get install $DEBIAN_NAME" + exit 1 + fi + CROSS_GCC=$MINGW_GCC + else + if [ -z "$DARWIN_TOOLCHAIN" ]; then + echo "Please set DARWIN_TOOLCHAIN to darwin cross-toolchain" + exit 1 + fi + if [ ! -f "${DARWIN_TOOLCHAIN}-gcc" ]; then + echo "darwin cross-toolchain $DARWIN_TOOLCHAIN-gcc doesn't exist" + exit 1 + fi + if [ "$HOST_ARCH" = "x86_64" -a "$TRY64" = "yes" ]; then + BINPREFIX=x86_64-apple-darwin- + DEBIAN_NAME=darwin64 + HOST_CFLAGS=$HOST_CFLAGS" -m64" + else + force_32bit_binaries + BINPREFIX=i686-apple-darwin- + DEBIAN_NAME=darwin32 + HOST_CFLAGS=$HOST_CFLAGS" -m32" + fi + CROSS_GCC=${DARWIN_TOOLCHAIN}-gcc + probe_darwin_sdk + fi + + # Create a wrapper toolchain, and prepend its dir to our PATH + CROSS_WRAP_DIR="$1"/$DEBIAN_NAME-wrapper + rm -rf "$CROSS_WRAP_DIR" + mkdir -p "$CROSS_WRAP_DIR" + + if [ "$DARWIN" = "yes" ] ; then + cat > "$CROSS_WRAP_DIR/sw_vers" < $TMPC <$TMPL 2>&1 + if [ $? != 0 ] ; then + log "no" + if [ "$TRY64" != "yes" ]; then + # NOTE: We need to modify the definitions of CC and CXX directly + # here. Just changing the value of CFLAGS / HOST_CFLAGS + # will not work well with the GCC toolchain scripts. + CC="$CC -m32" + CXX="$CXX -m32" + fi + else + log "yes" + if [ "$TRY64" = "yes" ]; then + CC="$CC -m64" + CXX="$CXX -m64" + fi + fi + + if [ "$TRY64" = "yes" ]; then + HOST_BITS=64 + else + force_32bit_binaries # to modify HOST_TAG and others + HOST_BITS=32 + fi +} + +prepare_host_build () +{ + prepare_common_build + + # Now deal with mingw or darwin + if [ "$MINGW" = "yes" -o "$DARWIN" = "yes" ]; then + handle_canadian_build + CC=$ABI_CONFIGURE_HOST-gcc + CXX=$ABI_CONFIGURE_HOST-g++ + CPP=$ABI_CONFIGURE_HOST-cpp + LD=$ABI_CONFIGURE_HOST-ld + AR=$ABI_CONFIGURE_HOST-ar + AS=$ABI_CONFIGURE_HOST-as + RANLIB=$ABI_CONFIGURE_HOST-ranlib + STRIP=$ABI_CONFIGURE_HOST-strip + export CC CXX CPP LD AR AS RANLIB STRIP + fi + + setup_ccache +} + +prepare_abi_configure_build () +{ + # detect build tag + case $HOST_TAG in + linux-x86) + ABI_CONFIGURE_BUILD=i386-linux-gnu + ;; + linux-x86_64) + ABI_CONFIGURE_BUILD=x86_64-linux-gnu + ;; + darwin-x86) + ABI_CONFIGURE_BUILD=i686-apple-darwin + ;; + darwin-x86_64) + ABI_CONFIGURE_BUILD=x86_64-apple-darwin + ;; + windows) + ABI_CONFIGURE_BUILD=i686-pc-cygwin + ;; + *) + echo "ERROR: Unsupported HOST_TAG: $HOST_TAG" + echo "Please update 'prepare_host_flags' in build/tools/prebuilt-common.sh" + ;; + esac +} + +prepare_target_build () +{ + prepare_abi_configure_build + + # By default, assume host == build + ABI_CONFIGURE_HOST="$ABI_CONFIGURE_BUILD" + + prepare_common_build + HOST_GMP_ABI=$HOST_BITS + + # Now handle the --mingw/--darwin flag + if [ "$MINGW" = "yes" -o "$DARWIN" = "yes" ] ; then + handle_canadian_build + STRIP=$ABI_CONFIGURE_HOST-strip + if [ "$MINGW" = "yes" ] ; then + # It turns out that we need to undefine this to be able to + # perform a canadian-cross build with mingw. Otherwise, the + # GMP configure scripts will not be called with the right options + HOST_GMP_ABI= + fi + fi + + setup_ccache +} + +# $1: Toolchain name +# +parse_toolchain_name () +{ + TOOLCHAIN=$1 + if [ -z "$TOOLCHAIN" ] ; then + echo "ERROR: Missing toolchain name!" + exit 1 + fi + + ABI_CFLAGS_FOR_TARGET= + ABI_CXXFLAGS_FOR_TARGET= + + # Determine ABI based on toolchain name + # + case "$TOOLCHAIN" in + arm-linux-androideabi-*) + ARCH="arm" + ABI="armeabi" + ABI_CONFIGURE_TARGET="arm-linux-androideabi" + ABI_CONFIGURE_EXTRA_FLAGS="--with-arch=armv5te" + ;; + arm-eabi-*) + ARCH="arm" + ABI="armeabi" + ABI_CONFIGURE_TARGET="arm-eabi" + ABI_CONFIGURE_EXTRA_FLAGS="--with-arch=armv5te --disable-gold --disable-libgomp" + ;; + aarch64-linux-android-*) + ARCH="arm64" + ABI="arm64-v8a" + ABI_CONFIGURE_TARGET="aarch64-linux-android" + ;; + x86-*) + ARCH="x86" + ABI=$ARCH + ABI_INSTALL_NAME="x86" + ABI_CONFIGURE_TARGET="i686-linux-android" + # Enable C++ exceptions, RTTI and GNU libstdc++ at the same time + # You can't really build these separately at the moment. + ABI_CFLAGS_FOR_TARGET="-fPIC" + ;; + x86_64-*) + ARCH="x86_64" + ABI=$ARCH + ABI_INSTALL_NAME="x86_64" + ABI_CONFIGURE_TARGET="x86_64-linux-android" + # Enable C++ exceptions, RTTI and GNU libstdc++ at the same time + # You can't really build these separately at the moment. + ABI_CFLAGS_FOR_TARGET="-fPIC" + ;; + mipsel*) + ARCH="mips" + ABI=$ARCH + ABI_INSTALL_NAME="mips" + ABI_CONFIGURE_TARGET="mipsel-linux-android" + # Set default to mips32 + ABI_CONFIGURE_EXTRA_FLAGS="--with-arch=mips32" + # 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. + ABI_CFLAGS_FOR_TARGET="-fexceptions -fpic" + ABI_CXXFLAGS_FOR_TARGET="-frtti -fpic" + # Add --disable-fixed-point to disable fixed-point support + ABI_CONFIGURE_EXTRA_FLAGS="$ABI_CONFIGURE_EXTRA_FLAGS --disable-fixed-point" + ;; + mips64el*) + ARCH="mips64" + ABI=$ARCH + ABI_INSTALL_NAME="mips64" + ABI_CONFIGURE_TARGET="mips64el-linux-android" + # Set default to mips64r6 + ABI_CONFIGURE_EXTRA_FLAGS="--with-arch=mips64r6" + # 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. + ABI_CFLAGS_FOR_TARGET="-fexceptions -fpic" + ABI_CXXFLAGS_FOR_TARGET="-frtti -fpic" + # Add --disable-fixed-point to disable fixed-point support + ABI_CONFIGURE_EXTRA_FLAGS="$ABI_CONFIGURE_EXTRA_FLAGS --disable-fixed-point" + ;; + * ) + echo "Invalid toolchain specified. Expected (arm-linux-androideabi-*|arm-eabi-*|x86-*|mipsel*|mips64el*)" + echo "" + print_help + exit 1 + ;; + esac + + log "Targetting CPU: $ARCH" + + GCC_VERSION=`expr -- "$TOOLCHAIN" : '.*-\([0-9x\.]*\)'` + log "Using GCC version: $GCC_VERSION" + + # Determine --host value when building gdbserver + + case "$TOOLCHAIN" in + arm-*) + GDBSERVER_HOST=arm-eabi-linux + GDBSERVER_CFLAGS="-fno-short-enums" + GDBSERVER_LDFLAGS= + ;; + aarch64-*) + GDBSERVER_HOST=aarch64-eabi-linux + GDBSERVER_CFLAGS="-fno-short-enums -DUAPI_HEADERS" + GDBSERVER_LDFLAGS= + ;; + x86-*) + GDBSERVER_HOST=i686-linux-android + GDBSERVER_CFLAGS= + GDBSERVER_LDFLAGS= + ;; + x86_64-*) + GDBSERVER_HOST=x86_64-linux-android + GDBSERVER_CFLAGS=-DUAPI_HEADERS + GDBSERVER_LDFLAGS= + ;; + mipsel-*) + GDBSERVER_HOST=mipsel-linux-android + GDBSERVER_CFLAGS= + GDBSERVER_LDFLAGS= + ;; + mips64el-*) + GDBSERVER_HOST=mips64el-linux-android + GDBSERVER_CFLAGS=-DUAPI_HEADERS + GDBSERVER_LDFLAGS= + ;; + *) + echo "Unknown TOOLCHAIN=$TOOLCHAIN" + exit + esac +} + +# Return the host "tag" used to identify prebuilt host binaries. +# NOTE: Handles the case where '$MINGW = true' or '$DARWIN = true' +# For now, valid values are: linux-x86, darwin-x86 and windows +get_prebuilt_host_tag () +{ + local RET=$HOST_TAG + if [ "$MINGW" = "yes" ]; then + if [ "$TRY64" = "no" ]; then + RET=windows + else + RET=windows-x86_64 + fi + fi + if [ "$DARWIN" = "yes" ]; then + RET=darwin-x86_64 # let the following handles 32-bit case + fi + case $RET in + linux-x86_64) + if [ "$TRY64" = "no" ]; then + RET=linux-x86 + fi + ;; + darwin-x86_64) + if [ "$TRY64" = "no" ]; then + RET=darwin-x86 + fi + ;; + esac + echo $RET +} + +# Return the executable suffix corresponding to host executables +get_prebuilt_host_exe_ext () +{ + if [ "$MINGW" = "yes" ]; then + echo ".exe" + else + echo "" + fi +} + +# Find all archs from $DEV_DIR/platforms or $NDK_DIR/platforms +# Return: the list of found arch name +find_ndk_archs () +{ + local NDK_ROOT_DIR DEVDIR + local RESULT FOUND_ARCHS + + if [ ! -z "$NDK_DIR" ]; then + NDK_ROOT_DIR=$NDK_DIR + else + NDK_ROOT_DIR=$ANDROID_NDK_ROOT + fi + + DEVDIR="$ANDROID_NDK_ROOT/../development/ndk" + + # Check development directory first + if [ -d $DEVDIR/platforms ]; then + RESULT=$(ls $DEVDIR/platforms/android-* | grep "arch-") + for arch in $RESULT; do + arch=$(basename $arch | sed -e 's/^arch-//') + FOUND_ARCHS="$FOUND_ARCHS $arch" + done + fi + + # Check ndk directory + if [ -z "$FOUND_ARCHS" ] && [ -d $NDK_ROOT_DIR/platforms ]; then + RESULT=$(ls $NDK_ROOT_DIR/platforms/android-* | grep "arch-") + for arch in $RESULT; do + arch=$(basename $arch | sed -e 's/^arch-//') + FOUND_ARCHS="$FOUND_ARCHS $arch" + done + fi + + # If we cannot find any arch, set to default archs + if [ -z "$FOUND_ARCHS" ]; then + FOUND_ARCHS=$DEFAULT_ARCHS + fi + + echo "$(sort_uniq $FOUND_ARCHS)" +} + +# Find unknown archs from $NDK_DIR/platforms +# Return: arch names not in ndk default archs +find_ndk_unknown_archs() +{ + local FOUND_ARCHS=$(find_ndk_archs) + # TODO: arm64, x86_64 is here just to be found as known arch. + # It can be removed as soon as it is added into $DEFAULT_ARCHS + echo "$(filter_out "$DEFAULT_ARCHS arm64 x86_64 mips64" "$FOUND_ARCHS")" +} + +# Determine whether given arch is in unknown archs list +# $1: arch +# Return: yes or no +arch_in_unknown_archs() +{ + local UNKNOWN_ARCH=$(find_ndk_unknown_archs | grep $1) + if [ -z "$UNKNOWN_ARCH" ]; then + echo "no" + else + echo "yes" + fi +} + +# Get library suffix for given ABI +# $1: ABI +# Return: .so or .bc +get_lib_suffix_for_abi () +{ + local ABI=$1 + if [ $(arch_in_unknown_archs $ABI) = "yes" ]; then + echo ".bc" + else + echo ".so" + fi +} + +# Convert an ABI name into an Architecture name +# $1: ABI name +# Result: Arch name +convert_abi_to_arch () +{ + local RET + local ABI=$1 + case $ABI in + armeabi|armeabi-v7a|armeabi-v7a-hard) + RET=arm + ;; + x86|mips|x86_64|mips64) + RET=$ABI + ;; + mips32r6) + RET=mips + ;; + arm64-v8a) + RET=arm64 + ;; + *) + if [ "$(arch_in_unknown_archs $ABI)" = "yes" ]; then + RET=$ABI + else + >&2 echo "ERROR: Unsupported ABI name: $ABI, use one of: armeabi, armeabi-v7a, x86, mips, armeabi-v7a-hard, arm64-v8a, x86_64 or mips64" + exit 1 + fi + ;; + esac + echo "$RET" +} + +# Take architecture name as input, and output the list of corresponding ABIs +# Inverse for convert_abi_to_arch +# $1: ARCH name +# Out: ABI names list (comma-separated) +convert_arch_to_abi () +{ + local RET + local ARCH=$1 + case $ARCH in + arm) + RET=armeabi,armeabi-v7a,armeabi-v7a-hard + ;; + x86|x86_64|mips|mips64) + RET=$ARCH + ;; + arm64) + RET=arm64-v8a + ;; + *) + if [ "$(arch_in_unknown_archs $ARCH)" = "yes" ]; then + RET=$ARCH + else + >&2 echo "ERROR: Unsupported ARCH name: $ARCH, use one of: arm, x86, mips" + exit 1 + fi + ;; + esac + echo "$RET" +} + +# Take a list of architecture names as input, and output the list of corresponding ABIs +# $1: ARCH names list (separated by spaces or commas) +# Out: ABI names list (comma-separated) +convert_archs_to_abis () +{ + local RET + for ARCH in $(commas_to_spaces $@); do + ABI=$(convert_arch_to_abi $ARCH) + if [ -n "$ABI" ]; then + if [ -n "$RET" ]; then + RET=$RET",$ABI" + else + RET=$ABI + fi + else # Error message is printed by convert_arch_to_abi + exit 1 + fi + done + echo "$RET" +} + +# Return the default toolchain binary path prefix for given architecture and gcc version +# For example: arm 4.8 -> toolchains/arm-linux-androideabi-4.8/prebuilt//bin/arm-linux-androideabi- +# $1: Architecture name +# $2: GCC version +# $3: optional, system name, defaults to $HOST_TAG +get_toolchain_binprefix_for_arch () +{ + local NAME PREFIX DIR BINPREFIX + local SYSTEM=${3:-$(get_prebuilt_host_tag)} + NAME=$(get_toolchain_name_for_arch $1 $2) + PREFIX=$(get_default_toolchain_prefix_for_arch $1) + DIR=$(get_toolchain_install . $NAME $SYSTEM) + BINPREFIX=${DIR#./}/bin/$PREFIX- + echo "$BINPREFIX" +} + +# Return llvm toolchain binary path prefix for given llvm version +# $1: llvm version +# $2: optional, system name, defaults to $HOST_TAG +get_llvm_toolchain_binprefix () +{ + local NAME DIR BINPREFIX + local SYSTEM=${2:-$(get_prebuilt_host_tag)} + NAME=llvm-$1 + DIR=$(get_toolchain_install . $NAME $SYSTEM) + BINPREFIX=${DIR#./}/bin/ + echo "$BINPREFIX" +} + +# Return the default toochain binary path prefix for a given architecture +# For example: arm -> toolchains/arm-linux-androideabi-4.8/prebuilt//bin/arm-linux-androideabi- +# $1: Architecture name +# $2: optional, system name, defaults to $HOST_TAG +get_default_toolchain_binprefix_for_arch () +{ + local GCCVER=$(get_default_gcc_version_for_arch $ARCH) + get_toolchain_binprefix_for_arch $1 $GCCVER $2 +} + +# Return default API level for a given arch +# This is the level used to build the toolchains. +# +# $1: Architecture name +get_default_api_level_for_arch () +{ + # For unknown arch, use API level $FIRST_API64_LEVEL + if [ $(arch_in_unknown_archs $1) = "yes" ]; then + echo $FIRST_API64_LEVEL + else + # For now, always build the toolchain against API level 9 for 32-bit arch + # and API level $FIRST_API64_LEVEL for 64-bit arch + case $1 in + *64) echo $FIRST_API64_LEVEL ;; + *) echo 9 ;; + esac + fi +} + +# Return the default platform sysroot corresponding to a given architecture +# This is the sysroot used to build the toolchain and other binaries like +# the STLport libraries. +# $1: Architecture name +get_default_platform_sysroot_for_arch () +{ + local ARCH=$1 + local LEVEL=$(get_default_api_level_for_arch $ARCH) + + if [ "$ARCH" != "${ARCH%%64*}" ] ; then + LEVEL=$FIRST_API64_LEVEL + fi + echo "platforms/android-$LEVEL/arch-$ARCH" +} + +# Return the default platform sysroot corresponding to a given abi +# $1: ABI +get_default_platform_sysroot_for_abi () +{ + local ARCH=$(convert_abi_to_arch $1) + $(get_default_platform_sysroot_for_arch $ARCH) +} + +# Return the default libs dir corresponding to a given architecture +# $1: Architecture name +get_default_libdir_for_arch () +{ + case $1 in + x86_64|mips64) echo "lib64" ;; + arm64) echo "lib" ;; # return "lib" until aarch64 is built to look for sysroot/usr/lib64 + *) echo "lib" ;; + esac +} + +# Return the default libs dir corresponding to a given abi +# $1: ABI +get_default_libdir_for_abi () +{ + local ARCH + + case $1 in + mips32r6) echo "libr6" ;; + *) + local ARCH=$(convert_abi_to_arch $1) + echo "$(get_default_libdir_for_arch $ARCH)" + ;; + esac +} + +# Return the host/build specific path for prebuilt toolchain binaries +# relative to $1. +# +# $1: target root NDK directory +# $2: toolchain name +# $3: optional, host system name +# +get_toolchain_install () +{ + local NDK="$1" + shift + echo "$NDK/$(get_toolchain_install_subdir "$@")" +} + +# $1: toolchain name +# $2: optional, host system name +get_toolchain_install_subdir () +{ + local SYSTEM=${2:-$(get_prebuilt_host_tag)} + echo "toolchains/$1/prebuilt/$SYSTEM" +} + +# Return the relative install prefix for prebuilt host +# executables (relative to the NDK top directory). +# NOTE: This deals with MINGW==yes or DARWIN==yes appropriately +# +# $1: optional, system name +# Out: relative path to prebuilt install prefix +get_prebuilt_install_prefix () +{ + local TAG=${1:-$(get_prebuilt_host_tag)} + echo "prebuilt/$TAG" +} + +# Return the relative path of an installed prebuilt host +# executable +# NOTE: This deals with MINGW==yes or DARWIN==yes appropriately. +# +# $1: executable name +# $2: optional, host system name +# Out: path to prebuilt host executable, relative +get_prebuilt_host_exec () +{ + local PREFIX EXE + PREFIX=$(get_prebuilt_install_prefix $2) + EXE=$(get_prebuilt_host_exe_ext) + echo "$PREFIX/bin/$1$EXE" +} + +# Return the name of a given host executable +# $1: executable base name +# Out: executable name, with optional suffix (e.g. .exe for windows) +get_host_exec_name () +{ + local EXE=$(get_prebuilt_host_exe_ext) + echo "$1$EXE" +} + +# Return the directory where host-specific binaries are installed. +# $1: target root NDK directory +get_host_install () +{ + echo "$1/$(get_prebuilt_install_prefix)" +} + +# Set the toolchain target NDK location. +# this sets TOOLCHAIN_PATH and TOOLCHAIN_PREFIX +# $1: target NDK path +# $2: toolchain name +set_toolchain_ndk () +{ + TOOLCHAIN_PATH=`get_toolchain_install "$1" $2` + log "Using toolchain path: $TOOLCHAIN_PATH" + + TOOLCHAIN_PREFIX=$TOOLCHAIN_PATH/bin/$ABI_CONFIGURE_TARGET + log "Using toolchain prefix: $TOOLCHAIN_PREFIX" +} + +# Check that a toolchain is properly installed at a target NDK location +# +# $1: target root NDK directory +# $2: toolchain name +# +check_toolchain_install () +{ + TOOLCHAIN_PATH=`get_toolchain_install "$1" $2` + if [ ! -d "$TOOLCHAIN_PATH" ] ; then + echo "ERROR: Cannot find directory '$TOOLCHAIN_PATH'!" + echo " Toolchain '$2' not installed in '$NDK_DIR'!" + echo " Ensure that the toolchain has been installed there before." + exit 1 + fi + + set_toolchain_ndk $1 $2 +} + +# $1: toolchain source directory +check_toolchain_src_dir () +{ + local SRC_DIR="$1" + if [ -z "$SRC_DIR" ]; then + echo "ERROR: Please provide the path to the toolchain source tree. See --help" + exit 1 + fi + + if [ ! -d "$SRC_DIR" ]; then + echo "ERROR: Not a directory: '$SRC_DIR'" + exit 1 + fi + + if [ ! -f "$SRC_DIR/build/configure" -o ! -d "$SRC_DIR/gcc" ]; then + echo "ERROR: Either the file $SRC_DIR/build/configure or" + echo " the directory $SRC_DIR/gcc does not exist." + echo "This is not the top of a toolchain tree: $SRC_DIR" + echo "You must give the path to a copy of the toolchain source directories" + echo "created by 'download-toolchain-sources.sh." + exit 1 + fi +} + +# +# The NDK_TMPDIR variable is used to specify a root temporary directory +# when invoking toolchain build scripts. If it is not defined, we will +# create one here, and export the value to ensure that any scripts we +# call after that use the same one. +# +if [ -z "$NDK_TMPDIR" ]; then + NDK_TMPDIR=/tmp/ndk-$USER/tmp/build-$$ + mkdir -p $NDK_TMPDIR + if [ $? != 0 ]; then + echo "ERROR: Could not create NDK_TMPDIR: $NDK_TMPDIR" + exit 1 + fi + export NDK_TMPDIR +fi + +# Define HOST_TAG32, as the 32-bit version of HOST_TAG +# We do this by replacing an -x86_64 suffix by -x86 +HOST_TAG32=$HOST_TAG +case $HOST_TAG32 in + *-x86_64) + HOST_TAG32=${HOST_TAG%%_64} + ;; +esac