#!/bin/sh
#
# Copyright (C) 2010 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.
#
# Download and rebuild all prebuilt binaries for the Android NDK
# This includes:
# - cross toolchains (gcc, ld, gdb, etc...)
# - target-specific gdbserver
# - host ccache
#
. `dirname $0`/prebuilt-common.sh
PROGDIR=`dirname $0`
NDK_DIR=
register_var_option "--ndk-dir=<path>" NDK_DIR "Don't package, copy binaries to target NDK directory"
BUILD_DIR=/tmp/ndk-$USER/build
register_var_option "--build-dir=<path>" BUILD_DIR "Specify temporary build directory"
GDB_VERSION=$DEFAULT_GDB_VERSION
register_var_option "--gdb-version=<version>" GDB_VERSION "Specify gdb version"
BINUTILS_VERSION=$DEFAULT_BINUTILS_VERSION
register_var_option "--binutils-version=<version>" BINUTILS_VERSION "Specify binutils version"
MPFR_VERSION=$DEFAULT_MPFR_VERSION
register_var_option "--mpfr-version=<version>" MPFR_VERSION "Specify mpfr version"
ARCH=arm
register_var_option "--arch=<arch>" ARCH "Specify architecture"
OPTION_SYSROOT=
register_var_option "--sysroot=<dir>" OPTION_SYSROOT "Specify sysroot"
OPTION_TOOLCHAIN_SRC_PKG=
register_var_option "--toolchain-src-pkg=<file>" OPTION_TOOLCHAIN_SRC_PKG "Use toolchain source package."
OPTION_TOOLCHAIN_SRC_DIR=
register_var_option "--toolchain-src-dir=<path>" OPTION_TOOLCHAIN_SRC_DIR "Use toolchain source directory."
RELEASE=`date +%Y%m%d`
PACKAGE_DIR=/tmp/ndk-$USER/prebuilt-$RELEASE
register_var_option "--package-dir=<path>" PACKAGE_DIR "Put prebuilt tarballs into <path>."
OPTION_GIT_HTTP=no
register_var_option "--git-http" OPTION_GIT_HTTP "Download sources with http."
HOST_ONLY=
register_var_option "--host-only" HOST_ONLY "Only rebuild host binaries."
DARWIN_SSH=
if [ "$HOST_OS" = "linux" ] ; then
register_var_option "--darwin-ssh=<hostname>" DARWIN_SSH "Specify Darwin hostname to ssh to for the build."
fi
register_mingw_option
PROGRAM_PARAMETERS=
PROGRAM_DESCRIPTION=\
"Download and rebuild from scratch all prebuilt binaries for the Android NDK.
By default, this will create prebuilt binary tarballs in: $PACKAGE_DIR
You can however use --ndk-dir=<path> to instead copy the binaries directly
to an existing NDK installation.
By default, the script will download the toolchain sources from the Internet,
but you can override this using either --toolchain-src-dir or
--toolchain-src-pkg.
Please read docs/DEVELOPMENT.TXT for more usage information about this
script.
"
extract_parameters "$@"
# Needed to set HOST_TAG to windows if --mingw is used.
handle_host
if [ -n "$PACKAGE_DIR" -a -n "$NDK_DIR" ] ; then
echo "ERROR: You cannot use both --package-dir and --ndk-dir at the same time!"
exit 1
fi
if [ -z "$NDK_DIR" ] ; then
mkdir -p "$PACKAGE_DIR"
fail_panic "Could not create directory: $PACKAGE_DIR"
NDK_DIR=$BUILD_DIR/install
mkdir -p $NDK_DIR
else
if [ ! -d "$NDK_DIR" ] ; then
echo "ERROR: NDK directory does not exists: $NDK_DIR"
exit 1
fi
PACKAGE_DIR=
fi
if [ -n "$PARAMETERS" ]; then
dump "ERROR: Too many parameters. See --help for proper usage."
exit 1
fi
mkdir -p $BUILD_DIR
if [ $? != 0 ] ; then
dump "ERROR: Could not create build directory: $BUILD_DIR"
exit 1
fi
setup_default_log_file "$BUILD_DIR/log.txt"
if [ -n "$OPTION_TOOLCHAIN_SRC_DIR" ] ; then
if [ -n "$OPTION_TOOLCHAIN_SRC_PKG" ] ; then
dump "ERROR: You can't use both --toolchain-src-dir and --toolchain-src-pkg"
exi t1
fi
SRC_DIR="$OPTION_TOOLCHAIN_SRC_DIR"
if [ ! -d "$SRC_DIR/gcc" ] ; then
dump "ERROR: Invalid toolchain source directory: $SRC_DIR"
exit 1
fi
else
SRC_DIR="$BUILD_DIR/src"
mkdir -p "$SRC_DIR"
fi
FLAGS=""
if [ $VERBOSE = yes ] ; then
FLAGS="--verbose"
fi
if [ "$MINGW" = "yes" ] ; then
FLAGS="$FLAGS --mingw"
fi
# If --toolchain-src-dir is not given, get the toolchain sources, either
# by downloading, or by extracting the, from a tarball given by the
# --toolchain-src-pkg option.
#
get_toolchain_sources ()
{
if [ -z "$OPTION_TOOLCHAIN_SRC_DIR" ] ; then
if [ -n "$OPTION_TOOLCHAIN_SRC_PKG" ] ; then
# Unpack the toolchain sources
if [ ! -f "$OPTION_TOOLCHAIN_SRC_PKG" ] ; then
dump "ERROR: Invalid toolchain source package: $OPTION_TOOLCHAIN_SRC_PKG"
exit 1
fi
unpack_archive "$OPTION_TOOLCHAIN_SRC_PKG" "$SRC_DIR"
fail_panic "Could not unpack toolchain sources!"
else
# Download the toolchain sources
dump "Download sources from android.git.kernel.org"
DOWNLOAD_FLAGS="$FLAGS"
if [ $OPTION_GIT_HTTP = "yes" ] ; then
DOWNLOAD_FLAGS="$DOWNLOAD_FLAGS --git-http"
fi
$PROGDIR/download-toolchain-sources.sh $DOWNLOAD_FLAGS $SRC_DIR
fail_panic "Could not download toolchain sources!"
fi
fi # ! $TOOLCHAIN_SRC_DIR
}
# Special treatment when building remotely on a Darwin machine through ssh
# For now, we will have to prompt the user several times.
#
if [ -n "$DARWIN_SSH" ] ; then
# 1/ Copy the NDK toolchain build scripts
# 2/ Copy the toolchain sources/package
# 3/ Ssh to unpack the build scripts, and run them
# 4/ Copy back the generated prebuilt binaries
#
dump "Preparing remote build on $DARWIN_SSH..."
dump "Getting toolchain sources"
get_toolchain_sources
dump "Creating remote temp directory"
TMPREMOTE=/tmp/ndk-$USER/darwin-prebuild
run ssh $DARWIN_SSH "mkdir -p $TMPREMOTE && rm -rf $TMPREMOTE/*"
TMPDARWIN=$NDK_TMPDIR/darwin # Where we're going to package stuff
log "Using temporary work directory: $TMPDARWIN"
dump "Prepare NDK build scripts"
copy_directory "$ANDROID_NDK_ROOT/build" "$TMPDARWIN/ndk/build"
copy_file_list "$ANDROID_NDK_ROOT" "$TMPDARWIN/ndk" sources/android/libthread_db
copy_file_list "$ANDROID_NDK_ROOT" "$TMPDARWIN/ndk" "$STLPORT_SUBDIR"
copy_file_list "$ANDROID_NDK_ROOT" "$TMPDARWIN/ndk" "$GABIXX_SUBDIR"
copy_file_list "$ANDROID_NDK_ROOT" "$TMPDARWIN/ndk" sources/host-tools/ndk-stack
dump "Prepare platforms files"
$PROGDIR/build-platforms.sh --arch=$ARCH --no-samples --dst-dir="$TMPDARWIN/ndk"
dump "Copying NDK build scripts and platform files to remote..."
(cd "$TMPDARWIN" && tar czf - ndk) | (ssh $DARWIN_SSH tar xzf - -C $TMPREMOTE)
fail_panic "Could not copy!"
rm -rf $TMPDARWIN
dump "Copy toolchain sources to remote"
ssh $DARWIN_SSH mkdir -p $TMPREMOTE/toolchain &&
(cd "$SRC_DIR" && tar czf - .) | (ssh $DARWIN_SSH tar xzf - -C $TMPREMOTE/toolchain)
fail_panic "Could not copy toolchain!"
dump "Running remote build..."
SYSROOT=$TMPREMOTE/ndk/platforms/android-$(get_default_api_level_for_arch $ARCH)/arch-$ARCH
run ssh $DARWIN_SSH "$TMPREMOTE/ndk/build/tools/rebuild-all-prebuilt.sh --toolchain-src-dir=$TMPREMOTE/toolchain --package-dir=$TMPREMOTE/packages --arch=$(spaces_to_commas $ARCH) --sysroot=$SYSROOT --host-only"
fail_panic "Could not build prebuilt packages on Darwin!"
dump "Copying back Darwin prebuilt packages..."
run scp $DARWIN_SSH:$TMPREMOTE/packages/*-darwin-* $PACKAGE_DIR/
fail_panic "Could not grab Darwin packages!"
dump "Cleaning up remote machine..."
run ssh $DARWIN_SSH rm -rf $TMPREMOTE
exit 0
fi
# Package a directory in a .tar.bz2 archive
#
# $1: textual description
# $2: final package name (without .tar.bz2 suffix)
# $3: relative root path from $NDK_DIR
#
package_it ()
{
if [ -n "$PACKAGE_DIR" ] ; then
dump "Packaging $1 ($2.tar.bz2) ..."
PREBUILT_PACKAGE="$PACKAGE_DIR/$2".tar.bz2
(cd $NDK_DIR && tar cjf $PREBUILT_PACKAGE $3)
fail_panic "Could not package $1!"
fi
}
# Rebuild the ndk-stack tool, and link to it
dump "Building host ndk-stack tool from sources."
NDK_STACK_FLAGS=
NDK_STACK_PACKAGE=$(get_host_exec_name ndk-stack)
if [ "$MINGW" = yes ]; then
NDK_STACK_FLAGS=$NDK_STACK_FLAGS" --mingw"
fi
if [ "$VERBOSE" = "yes" ]; then
NDK_STACK_FLAGS=$NDK_STACK_FLAGS" --verbose"
fi
if [ "$VERBOSE2" = "yes" ]; then
NDK_STACK_FLAGS=$NDK_STACK_FLAGS" --verbose"
fi
$ANDROID_NDK_ROOT/build/tools/build-ndk-stack.sh $NDK_STACK_FLAGS --out=$NDK_DIR/$NDK_STACK_PACKAGE &&
package_it "ndk-stack binary" ndk-stack-$HOST_TAG $NDK_STACK_PACKAGE
# If no sysroot is specified, build one explicitely
if [ -z "$OPTION_SYSROOT" ]; then
SYSROOT=$BUILD_DIR/platforms/android-9/arch-$ARCH
mkdir -p $SYSROOT
dump "Creating sysroot: $SYSROOT"
$PROGDIR/build-platforms.sh --arch=$ARCH --no-samples --no-symlinks --dst-dir=$BUILD_DIR
OPTION_SYSROOT=$SYSROOT
fi
# Build the toolchain from sources
# $1: toolchain name (e.g. arm-linux-androideabi-4.4.3)
# $2: extra flags, if needed
build_toolchain ()
{
dump "Building $1 toolchain... (this can be long)"
run $PROGDIR/build-gcc.sh $FLAGS $2 --sysroot=$OPTION_SYSROOT --mpfr-version=$MPFR_VERSION --binutils-version=$BINUTILS_VERSION --gdb-version=$GDB_VERSION --build-out=$BUILD_DIR/toolchain-$1 $SRC_DIR $NDK_DIR $1
fail_panic "Could not build $1 toolchain!"
package_it "$1 toolchain" "$1-$HOST_TAG" "toolchains/$1/prebuilt/$HOST_TAG"
}
build_gdbserver ()
{
if [ "$MINGW" = yes ] ; then
dump "Skipping gdbserver build (--mingw option being used)."
return
fi
dump "Build $1 gdbserver..."
$PROGDIR/build-gdbserver.sh $FLAGS --sysroot=$OPTION_SYSROOT --build-out=$BUILD_DIR/gdbserver-$1 --gdb-version=$GDB_VERSION $SRC_DIR $NDK_DIR $1
fail_panic "Could not build $1 gdbserver!"
package_it "$1 gdbserver" "$1-gdbserver" "toolchains/$1/prebuilt/gdbserver"
}
get_toolchain_sources
case "$ARCH" in
arm )
build_toolchain $DEFAULT_ARCH_TOOLCHAIN_NAME_arm
if [ -z "$HOST_ONLY" ]; then
build_gdbserver $DEFAULT_ARCH_TOOLCHAIN_NAME_arm
fi
;;
x86 )
build_toolchain $DEFAULT_ARCH_TOOLCHAIN_NAME_x86
if [ -z "$HOST_ONLY" ]; then
build_gdbserver $DEFAULT_ARCH_TOOLCHAIN_NAME_x86
fi
;;
esac
if [ -z "$HOST_ONLY" ]; then
# We need to package the libsupc++ binaries on Linux since the GCC build
# scripts cannot build them with --mingw option.
if [ "$HOST_OS" = "linux" ] ; then
case "$ARCH" in
arm )
LIBSUPC_DIR="toolchains/$DEFAULT_ARCH_TOOLCHAIN_NAME_arm/prebuilt/$HOST_TAG/$DEFAULT_ARCH_TOOLCHAIN_PREFIX_arm/lib"
package_it "GNU libsupc++ armeabi libs" "gnu-libsupc++-armeabi" "$LIBSUPC_DIR/libsupc++.a $LIBSUPC_DIR/thumb/libsupc++.a"
package_it "GNU libsupc++ armeabi-v7a libs" "gnu-libsupc++-armeabi-v7a" "$LIBSUPC_DIR/armv7-a/libsupc++.a $LIBSUPC_DIR/armv7-a/thumb/libsupc++.a"
;;
x86 )
LIBSUPC_DIR="toolchains/$DEFAULT_ARCH_TOOLCHAIN_NAME_x86/prebuilt/$HOST_TAG/$DEFAULT_ARCH_TOOLCHAIN_PREFIX_x86/lib"
package_it "GNU libsupc++ x86 libs" "gnu-libsupc++-x86" "$LIBSUPC_DIR/libsupc++.a"
;;
esac
fi
if [ "$MINGW" != "yes" ] ; then
package_it "GNU libstdc++ headers" "gnu-libstdc++-headers" "sources/cxx-stl/gnu-libstdc++/include"
case "$ARCH" in
arm )
package_it "GNU libstdc++ armeabi libs" "gnu-libstdc++-libs-armeabi" "sources/cxx-stl/gnu-libstdc++/libs/armeabi"
package_it "GNU libstdc++ armeabi-v7a libs" "gnu-libstdc++-libs-armeabi-v7a" "sources/cxx-stl/gnu-libstdc++/libs/armeabi-v7a"
;;
x86 )
package_it "GNU libstdc++ x86 libs" "gnu-libstdc++-libs-x86" "sources/cxx-stl/gnu-libstdc++/libs/x86"
;;
esac
fi
# Rebuild GAbi++ prebuilt libraries
if [ "$MINGW" != "yes" ]; then
dump "Building GAbi++ binaries"
BUILD_GABIXX_FLAGS="--ndk-dir=\"$NDK_DIR\" --package-dir=\"$PACKAGE_DIR\""
if [ $VERBOSE = yes ] ; then
BUILD_GABIXX_FLAGS="$BUILD_GABIXX_FLAGS --verbose"
fi
$ANDROID_NDK_ROOT/build/tools/build-platforms.sh --no-symlinks --no-samples --arch=$ARCH --dst-dir="$NDK_DIR"
case "$ARCH" in
arm )
BUILD_GABIXX_FLAGS=$BUILD_GABIXX_FLAGS" --abis=armeabi,armeabi-v7a"
;;
x86 )
BUILD_GABIXX_FLAGS=$BUILD_GABIXX_FLAGS" --abis=x86"
;;
esac
$ANDROID_NDK_ROOT/build/tools/build-gabi++.sh $BUILD_GABIXX_FLAGS
else
dump "Skipping GAbi++ binaries build (--mingw option being used)"
fi
# Rebuild STLport prebuilt libraries
if [ "$MINGW" != "yes" ] ; then
dump "Building STLport binaries"
BUILD_STLPORT_FLAGS="--ndk-dir=\"$NDK_DIR\" --package-dir=\"$PACKAGE_DIR\""
if [ $VERBOSE = yes ] ; then
BUILD_STLPORT_FLAGS="$BUILD_STLPORT_FLAGS --verbose"
fi
$ANDROID_NDK_ROOT/build/tools/build-platforms.sh --no-symlinks --no-samples --arch=$ARCH --dst-dir="$NDK_DIR"
case "$ARCH" in
arm )
BUILD_STLPORT_FLAGS=$BUILD_STLPORT_FLAGS" --abis=armeabi,armeabi-v7a"
;;
x86 )
BUILD_STLPORT_FLAGS=$BUILD_STLPORT_FLAGS" --abis=x86"
;;
esac
$ANDROID_NDK_ROOT/build/tools/build-stlport.sh $BUILD_STLPORT_FLAGS
else
dump "Skipping STLport binaries build (--mingw option being used)"
fi
fi # !HOST_ONLY
if [ -n "$PACKAGE_DIR" ] ; then
dump "Done! See $PACKAGE_DIR"
else
dump "Done! See $NDK_DIR/toolchains"
fi