a74f31701a
All you need to do is place name them like the following: build/tools/toolchain-patches/<subpath>/<foo>.patch And they will be applied with 'patch -p1' into: <build-src>/<subpath> This is useful to experiment with toolchain changes without having to regenerate a whole new source package tarball each time.
724 lines
22 KiB
Bash
Executable File
724 lines
22 KiB
Bash
Executable File
#!/bin/sh
|
|
#
|
|
# 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.
|
|
#
|
|
# This shell script is used to rebuild the Android NDK's prebuilt binaries.
|
|
#
|
|
# The source tarballs must be located in $ANDROID_NDK_ROOT/build/archive
|
|
# They will be located in $ANDROID_NDK_ROOT/build/toolchain after compilation
|
|
#
|
|
|
|
# include common function and variable definitions
|
|
. `dirname $0`/../core/ndk-common.sh
|
|
|
|
# number of jobs to run in parallel when running make
|
|
JOBS=$HOST_NUM_CPUS
|
|
|
|
PLATFORM=android-3
|
|
ABI=arm
|
|
GCC_VERSION=4.2.1
|
|
GDB_VERSION=6.6
|
|
BINUTILS_VERSION=2.17
|
|
RELEASE=`date +%Y%m%d`
|
|
BUILD_OUT=`mktemp -d /tmp/ndk-toolchain-XXX`
|
|
|
|
OPTION_HELP=no
|
|
OPTION_PLATFORM=
|
|
OPTION_FORCE_32=no
|
|
OPTION_REBUILD=no
|
|
OPTION_GCC_VERSION=
|
|
OPTION_GDB_VERSION=
|
|
OPTION_PACKAGE=
|
|
OPTION_RELEASE=
|
|
OPTION_BUILD_OUT=
|
|
|
|
VERBOSE=no
|
|
for opt do
|
|
optarg=`expr "x$opt" : 'x[^=]*=\(.*\)'`
|
|
case "$opt" in
|
|
--help|-h|-\?) OPTION_HELP=yes
|
|
;;
|
|
--verbose)
|
|
if [ "$VERBOSE" = "yes" ] ; then
|
|
VERBOSE2=yes
|
|
else
|
|
VERBOSE=yes
|
|
fi
|
|
;;
|
|
--gcc-version=*)
|
|
OPTION_GCC_VERSION=$optarg
|
|
;;
|
|
--gdb-version=*)
|
|
OPTION_GDB_VERSION=$optarg
|
|
;;
|
|
--package=*)
|
|
OPTION_PACKAGE="$optarg"
|
|
;;
|
|
--platform=*)
|
|
PLATFORM=$optarg
|
|
;;
|
|
--build-out=*)
|
|
OPTION_BUILD_OUT="$optarg"
|
|
;;
|
|
--abi=*)
|
|
ABI=$optarg
|
|
;;
|
|
--release=*)
|
|
OPTION_RELEASE=$optarg
|
|
;;
|
|
--force-download)
|
|
OPTION_FORCE_DOWNLOAD=yes
|
|
OPTION_FORCE_BUILD=yes
|
|
;;
|
|
--force-build)
|
|
OPTION_FORCE_BUILD=yes
|
|
;;
|
|
--verbose)
|
|
VERBOSE=yes
|
|
;;
|
|
*)
|
|
echo "unknown option '$opt', use --help"
|
|
exit 1
|
|
esac
|
|
done
|
|
|
|
if [ $OPTION_HELP = "yes" ] ; then
|
|
echo "Rebuild the prebuilt binaries for the Android NDK toolchain."
|
|
echo "This script will automatically download the sources from the"
|
|
echo "Internet, unless you use the --package=<file> option to specify"
|
|
echo "the exact source package to use."
|
|
echo ""
|
|
echo "See build/tools/download-toolchain-sources.sh for a tool that"
|
|
echo "can create a compatible source package from the current"
|
|
echo "git repositories."
|
|
echo ""
|
|
echo "options (defaults are within brackets):"
|
|
echo ""
|
|
echo " --help print this message"
|
|
echo " --gcc-version=<version> select GCC version [$GCC_VERSION]"
|
|
echo " --gdb-version=<version> select GDB version [$GDB_VERSION]"
|
|
echo " --package=<file> specify download source package"
|
|
echo " --platform=<name> generate toolchain from platform <name> [$PLATFORM]"
|
|
echo " --abi=<name> generate toolchain from abi <name> [$ABI]"
|
|
echo " --release=<name> specify prebuilt release name [$RELEASE]"
|
|
echo " --build-out=<path> set temporary build out directory [/tmp/<random>]"
|
|
echo " --force-download force a download and unpacking of the toolchain sources"
|
|
echo " --force-build force a rebuild of the sources"
|
|
echo ""
|
|
exit 0
|
|
fi
|
|
|
|
# Force generation of 32-bit binaries on 64-bit systems
|
|
case $HOST_TAG in
|
|
*-x86_64)
|
|
HOST_CFLAGS="$HOST_CFLAGS -m32"
|
|
HOST_LDFLAGS="$HOST_LDFLAGS -m32"
|
|
force_32bit_binaries # to modify HOST_TAG and others
|
|
;;
|
|
esac
|
|
|
|
TMPLOG=/tmp/android-toolchain-build-$$.log
|
|
rm -rf $TMPLOG
|
|
|
|
if [ $VERBOSE = yes ] ; then
|
|
run ()
|
|
{
|
|
echo "##### NEW COMMAND"
|
|
echo "$@"
|
|
$@ 2>&1
|
|
}
|
|
log ()
|
|
{
|
|
echo "LOG: $@"
|
|
}
|
|
else
|
|
echo "To follow build, please use in another terminal: tail -F $TMPLOG"
|
|
run ()
|
|
{
|
|
echo "##### NEW COMMAND" >> $TMPLOG
|
|
echo "$@" >> $TMPLOG
|
|
$@ >>$TMPLOG 2>&1
|
|
}
|
|
log ()
|
|
{
|
|
echo "$@" > /dev/null
|
|
}
|
|
fi
|
|
|
|
if [ -n "$OPTION_GCC_VERSION" ] ; then
|
|
GCC_VERSION="$OPTION_GCC_VERSION"
|
|
log "Using gcc version $GCC_VERSION"
|
|
else
|
|
log "Using default gcc version $GCC_VERSION"
|
|
fi
|
|
|
|
if [ -n "$OPTION_GDB_VERSION" ] ; then
|
|
GDB_VERSION="$OPTION_GDB_VERSION"
|
|
log "Using gdb version $GDB_VERSION"
|
|
else
|
|
log "Using default gdb version $GDB_VERSION"
|
|
fi
|
|
|
|
if [ -n "$OPTION_RELEASE" ] ; then
|
|
RELEASE="$RELEASE"
|
|
log "Using toolchain release name '$RELEASE'"
|
|
else
|
|
log "Using default toolchain name '$RELEASE'"
|
|
fi
|
|
|
|
if [ -n "$OPTION_PACKAGE" ] ; then
|
|
if [ ! -f "$OPTION_PACKAGE" ] ; then
|
|
echo "Package is not a file: $OPTION_PACKAGE"
|
|
exit 1
|
|
fi
|
|
fi
|
|
|
|
if [ -n "$OPTION_BUILD_OUT" ] ; then
|
|
BUILD_OUT=$OPTION_BUILD_OUT
|
|
log "Using specific build out directory: $BUILD_OUT"
|
|
else
|
|
log "Using default random build out directory: $BUILD_OUT"
|
|
fi
|
|
|
|
ANDROID_NDK_ROOT=`cd $ANDROID_NDK_ROOT && pwd`
|
|
ANDROID_NDK_ARCHIVE=$ANDROID_NDK_ROOT/build/toolchains/archive
|
|
ANDROID_PLATFORMS_ROOT=$ANDROID_NDK_ROOT/build/platforms
|
|
|
|
# where all generated files will be placed
|
|
OUT=$BUILD_OUT
|
|
PACKAGE_OUT=$OUT/packages
|
|
TIMESTAMP_OUT=$OUT/timestamps
|
|
|
|
# where the sysroot is located
|
|
ANDROID_TOOLCHAIN_SRC=$OUT/src
|
|
ANDROID_SYSROOT=$ANDROID_NDK_ROOT/build/platforms/$PLATFORM/arch-$ABI
|
|
|
|
# Let's check that we have a working md5sum here
|
|
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 <foo>' command
|
|
# may return either an empty string (Linux) or something like
|
|
# "no <foo> 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
|
|
PROG=`which $2 2>/dev/null`
|
|
if [ -n "$PROG" ] ; then
|
|
echo "$PROG" | grep -q -e '^no '
|
|
if [ $? = 0 ] ; then
|
|
PROG=
|
|
fi
|
|
fi
|
|
eval $1="$PROG"
|
|
}
|
|
|
|
# And wget too
|
|
find_program WGET wget
|
|
find_program CURL curl
|
|
find_program SCP scp
|
|
|
|
# download a file with either 'curl', 'wget' or 'scp'
|
|
# $1: source
|
|
# $2: target
|
|
download_file ()
|
|
{
|
|
# is this HTTP, HTTPS or FTP ?
|
|
echo $1 | grep -q -e "^\(http\|https\):.*"
|
|
if [ $? = 0 ] ; then
|
|
if [ -n "$WGET" ] ; then
|
|
$WGET -O $2 $1
|
|
elif [ -n "$CURL" ] ; then
|
|
$CURL -o $2 $1
|
|
else
|
|
echo "Please install wget or curl on this machine"
|
|
exit 1
|
|
fi
|
|
return
|
|
fi
|
|
|
|
# is this SSH ?
|
|
echo $1 | grep -q -e "^ssh:.*"
|
|
if [ $? = 0 ] ; then
|
|
if [ -n "$SCP" ] ; then
|
|
scp_src=`echo $1 | sed -e s%ssh://%%g`
|
|
$SCP $scp_src $2
|
|
else
|
|
echo "Please install scp on this machine"
|
|
exit 1
|
|
fi
|
|
return
|
|
fi
|
|
|
|
echo $1 | grep -q -e "^/.*"
|
|
if [ $? = 0 ] ; then
|
|
cp -f $1 $2
|
|
fi
|
|
}
|
|
|
|
|
|
timestamp_check ()
|
|
{
|
|
[ -f $TIMESTAMP_OUT/$1/timestamp-$2 ]
|
|
}
|
|
|
|
timestamp_set ()
|
|
{
|
|
mkdir -p $TIMESTAMP_OUT/$1
|
|
touch $TIMESTAMP_OUT/$1/timestamp-$2
|
|
}
|
|
|
|
timestamp_clear ()
|
|
{
|
|
rm -f $TIMESTAMP_OUT/$1/timestamp-*
|
|
}
|
|
|
|
timestamp_force ()
|
|
{
|
|
rm -f $TIMESTAMP_OUT/$1/timestamp-$2
|
|
}
|
|
|
|
# this function will be used to download and verify a toolchain
|
|
# package.
|
|
#
|
|
# $1: directory name under build/archive (e.g. 'toolchain')
|
|
#
|
|
download_package ()
|
|
{
|
|
WORKSPACE=$ANDROID_NDK_ARCHIVE/$1
|
|
if [ ! -d $WORKSPACE ] ; then
|
|
echo "No directory named $1 under $ANDROID_NDK_ARCHIVE"
|
|
exit 2
|
|
fi
|
|
SOURCES=$WORKSPACE/sources.txt
|
|
if [ ! -f $SOURCES ] ; then
|
|
echo "Missing sources.txt in $WORKSPACE"
|
|
exit 2
|
|
fi
|
|
# First line must be file name
|
|
PKGNAME=`cat $SOURCES | sed 1q`
|
|
# Second line must be md5sum
|
|
PKGSUM=`cat $SOURCES | sed 1d | sed 1q`
|
|
if [ -z "$PKGNAME" -o -z "$PKGSUM" ] ; then
|
|
echo "Corrupted file: $SOURCES"
|
|
exit 2
|
|
fi
|
|
|
|
# Try to download the package if it is not there
|
|
# the Third line of sources.txt, and all others behind
|
|
# must be wget urls or something.
|
|
PACKAGE_TARBALL=$PACKAGE_OUT/$PKGNAME
|
|
if [ ! -f $PACKAGE_TARBALL ] ; then
|
|
cat $SOURCES | sed 1,2d | while read src; do
|
|
echo $src | grep -q -e "^/.*"
|
|
if [ $? = 0 ] ; then
|
|
if [ -f $src ] ; then
|
|
echo "Copy : $PKGNAME"
|
|
echo " from `dirname $src`"
|
|
echo " into $PACKAGE_TARBALL"
|
|
run cp -f $src $PACKAGE_TARBALL
|
|
if [ $? = 0 ] ; then
|
|
break
|
|
fi
|
|
echo "Copy : Problem copying from $src"
|
|
else
|
|
echo "Copy : Can't find $src (skipping)"
|
|
fi
|
|
continue
|
|
fi
|
|
echo $src | grep -q -e "^\(http\|https\|ftp\|ssh\):.*"
|
|
if [ $? = 0 ] ; then
|
|
echo "Download: $PKGNAME"
|
|
echo " from $src"
|
|
echo " into $PACKAGE_TARBALL"
|
|
download_file $src $PACKAGE_TARBALL
|
|
if [ $? = 0 ] ; then
|
|
break
|
|
fi
|
|
continue
|
|
else
|
|
"Copy : Unknown method in $src"
|
|
fi
|
|
done
|
|
if [ ! -f $PACKAGE_TARBALL ] ; then
|
|
echo "ERROR: Could not copy or download $PKGNAME !"
|
|
echo "Your probably need to edit $WORKSPACE/sources.txt"
|
|
exit 1
|
|
fi
|
|
fi
|
|
|
|
if ! timestamp_check $1 verify ; then
|
|
SUM=`md5sum $PACKAGE_TARBALL | cut -d " " -f 1`
|
|
if [ "$SUM" != "$PKGSUM" ] ; then
|
|
echo "ERROR: Invalid MD5 Sum for $PACKAGE_TARBALL"
|
|
echo " Expected $PKGSUM"
|
|
echo " Computed $SUM"
|
|
echo "You might want to use the --force-download option."
|
|
exit 2
|
|
fi
|
|
|
|
echo "Verified: $PACKAGE_TARBALL"
|
|
timestamp_set $1 verify
|
|
timestamp_force $1 unpack
|
|
fi
|
|
eval PKG_$1=$PACKAGE_TARBALL
|
|
}
|
|
|
|
# Unpack a given package in a target location
|
|
# $1: package name (e.g. toolchain)
|
|
# $2: target directory (e.g. /tmp/foo)
|
|
#
|
|
unpack_package ()
|
|
{
|
|
SRCPKG=`var_value PKG_$1`
|
|
SRCDIR=$2
|
|
if ! timestamp_check $1 unpack; then
|
|
echo "Unpack : $1 sources"
|
|
echo " from $SRCPKG"
|
|
echo " into $SRCDIR"
|
|
run rm -rf $SRCDIR
|
|
run mkdir -p $SRCDIR
|
|
TARFLAGS=xjf
|
|
if [ $VERBOSE2 = yes ]; then
|
|
TARFLAGS="v$TARFLAGS"
|
|
fi
|
|
run tar $TARFLAGS $SRCPKG -C $SRCDIR
|
|
if [ $? != 0 ] ; then
|
|
echo "ERROR: Could not unpack $1, See $TMPLOG"
|
|
exit 1
|
|
fi
|
|
timestamp_set $1 unpack
|
|
timestamp_force $1 patch
|
|
fi
|
|
}
|
|
|
|
# Patch a given package at a target location
|
|
# $1: package name (e.g. toolchain)
|
|
# $2: target directory (e.g. /tmp/foo)
|
|
# $3: patch directory (e.g. build/tools/toolchain-patches)
|
|
#
|
|
# The rationale here is that anything named like $3/<subpath>/<foo>.patch
|
|
# will be applied with "patch -p1" under $2/<subpath>
|
|
#
|
|
# Patches are listed and applied in alphanumerical order of their names
|
|
# as returned by 'find'. Consider using numbered prefixes like the patch
|
|
# files generated by "git format-patch" are named.
|
|
#
|
|
patch_package ()
|
|
{
|
|
SRCPKG=`var_value PKG_$1`
|
|
SRCDIR=$2
|
|
if ! timestamp_check $1 patch; then
|
|
PATCH_FILES=`(cd $3 && find . -name "*.patch") 2> /dev/null`
|
|
if [ -z "$PATCH_FILES" ] ; then
|
|
echo "Patch : none provided"
|
|
return
|
|
fi
|
|
for PATCH in $PATCH_FILES; do
|
|
echo "Patch : $1 sources"
|
|
echo " from $PATCH"
|
|
echo " into $SRCDIR"
|
|
PATCHDIR=`dirname $PATCH`
|
|
PATCHNAME=`basename $PATCH`
|
|
cd $SRCDIR/$PATCHDIR && patch -p1 < $3/$PATCH
|
|
if [ $? != 0 ] ; then
|
|
echo "Patch failure !! Please check toolchain package !"
|
|
exit 1
|
|
fi
|
|
done
|
|
timestamp_set $1 patch
|
|
timestamp_force $1 configure
|
|
fi
|
|
}
|
|
|
|
if [ $OPTION_FORCE_DOWNLOAD ] ; then
|
|
rm -rf $PACKAGE_OUT $ANDROID_TOOLCHAIN_SRC
|
|
timestamp_force toolchain unpack
|
|
timestamp_force toolchain verify
|
|
fi
|
|
|
|
if [ $OPTION_FORCE_BUILD ] ; then
|
|
rm -rf $ANDROID_TOOLCHAIN_BUILD
|
|
timestamp_clear toolchain
|
|
timestamp_clear gdbserver
|
|
fi
|
|
|
|
# checks, we need more checks..
|
|
mkdir -p $PACKAGE_OUT
|
|
if [ $? != 0 ] ; then
|
|
echo "Can't create download/archive directory for toolchain tarballs"
|
|
exit 2
|
|
fi
|
|
|
|
if [ -n "$OPTION_PACKAGE" ] ; then
|
|
PKG_toolchain="$OPTION_PACKAGE"
|
|
else
|
|
download_package toolchain
|
|
fi
|
|
|
|
unpack_package toolchain $ANDROID_TOOLCHAIN_SRC
|
|
patch_package toolchain $ANDROID_TOOLCHAIN_SRC $ANDROID_NDK_ROOT/build/tools/toolchain-patches
|
|
|
|
# remove all info files from the unpacked toolchain sources
|
|
# they create countless little problems during the build
|
|
# if you don't have exactly the configuration expected by
|
|
# the scripts.
|
|
#
|
|
find $ANDROID_TOOLCHAIN_SRC -type f -a -name "*.info" -print0 | xargs -0 rm -f
|
|
|
|
|
|
# Setup variables to properly build a new toolchain
|
|
# $1: toolchain name, e.g. arm-eabi-4.2.1
|
|
build_toolchain ()
|
|
{
|
|
TOOLCHAIN_NAME=$1
|
|
|
|
# where the toolchain is going to be built
|
|
TOOLCHAIN_BUILD=$OUT/$TOOLCHAIN_NAME
|
|
|
|
# where the gdbserver binaries will be placed
|
|
GDBSERVER_BUILD=$TOOLCHAIN_BUILD/gdbserver
|
|
|
|
TOOLCHAIN_SRC=$ANDROID_TOOLCHAIN_SRC
|
|
TOOLCHAIN_PREFIX=$OUT/build/prebuilt/$HOST_TAG/$TOOLCHAIN_NAME
|
|
TOOLCHAIN_LICENSES=$ANDROID_NDK_ROOT/build/tools/toolchain-licenses
|
|
|
|
# configure the toolchain
|
|
if ! timestamp_check $TOOLCHAIN_NAME configure; then
|
|
echo "Configure: $TOOLCHAIN_NAME toolchain build"
|
|
# Old versions of the toolchain source packages placed the
|
|
# configure script at the top-level. Newer ones place it under
|
|
# the build directory though. Probe the file system to check
|
|
# this.
|
|
BUILD_SRCDIR=$TOOLCHAIN_SRC/build
|
|
if [ ! -d $BUILD_SRCDIR ] ; then
|
|
BUILD_SRCDIR=$TOOLCHAIN_SRC
|
|
fi
|
|
OLD_ABI="$ABI"
|
|
OLD_CFLAGS="$CFLAGS"
|
|
OLD_LDFLAGS="$LDFLAGS"
|
|
mkdir -p $TOOLCHAIN_BUILD &&
|
|
cd $TOOLCHAIN_BUILD &&
|
|
export ABI="32" && # needed to build a 32-bit gmp
|
|
export CFLAGS="$HOST_CFLAGS" &&
|
|
export LDFLAGS="$HOST_LDFLAGS" && run \
|
|
$BUILD_SRCDIR/configure --target=arm-eabi \
|
|
--disable-nls \
|
|
--prefix=$TOOLCHAIN_PREFIX \
|
|
--with-sysroot=$ANDROID_SYSROOT \
|
|
--with-binutils-version=$BINUTILS_VERSION \
|
|
--with-gcc-version=$GCC_VERSION \
|
|
--with-gdb-version=$GDB_VERSION
|
|
if [ $? != 0 ] ; then
|
|
echo "Error while trying to configure toolchain build. See $TMPLOG"
|
|
exit 1
|
|
fi
|
|
ABI="$OLD_ABI"
|
|
CFLAGS="$OLD_CFLAGS"
|
|
LDFLAGS="$OLD_LDFLAGS"
|
|
timestamp_set $TOOLCHAIN_NAME configure
|
|
timestamp_force $TOOLCHAIN_NAME build
|
|
fi
|
|
|
|
# build the toolchain
|
|
if ! timestamp_check $TOOLCHAIN_NAME build ; then
|
|
echo "Building : $TOOLCHAIN_NAME toolchain [this can take a long time]."
|
|
OLD_CFLAGS="$CFLAGS"
|
|
OLD_LDFLAGS="$LDFLAGS"
|
|
OLD_ABI="$ABI"
|
|
cd $TOOLCHAIN_BUILD &&
|
|
export CFLAGS="$HOST_CFLAGS" &&
|
|
export LDFLAGS="$HOST_LDFLAGS" &&
|
|
export ABI="32" &&
|
|
run make -j$JOBS
|
|
if [ $? != 0 ] ; then
|
|
echo "Error while building toolchain. See $TMPLOG"
|
|
exit 1
|
|
fi
|
|
CFLAGS="$OLD_CFLAGS"
|
|
LDFLAGS="$OLD_LDFLAGS"
|
|
ABI="$OLD_ABI"
|
|
timestamp_set $TOOLCHAIN_NAME build
|
|
timestamp_force $TOOLCHAIN_NAME install
|
|
fi
|
|
|
|
# install the toolchain to its final location
|
|
if ! timestamp_check $TOOLCHAIN_NAME install ; then
|
|
echo "Install : $TOOLCHAIN_NAME toolchain binaries."
|
|
cd $TOOLCHAIN_BUILD &&
|
|
run make install
|
|
if [ $? != 0 ] ; then
|
|
echo "Error while installing toolchain. See $TMPLOG"
|
|
exit 1
|
|
fi
|
|
# don't forget to copy the GPL and LGPL license files
|
|
cp -f $TOOLCHAIN_LICENSES/COPYING $TOOLCHAIN_LICENSES/COPYING.LIB $TOOLCHAIN_PREFIX
|
|
# remove some unneeded files
|
|
rm -f $TOOLCHAIN_PREFIX/bin/*-gccbug
|
|
rm -rf $TOOLCHAIN_PREFIX/man $TOOLCHAIN_PREFIX/info
|
|
# strip binaries to reduce final package size
|
|
strip $TOOLCHAIN_PREFIX/bin/*
|
|
strip $TOOLCHAIN_PREFIX/arm-eabi/bin/*
|
|
strip $TOOLCHAIN_PREFIX/libexec/gcc/*/*/cc1
|
|
strip $TOOLCHAIN_PREFIX/libexec/gcc/*/*/cc1plus
|
|
strip $TOOLCHAIN_PREFIX/libexec/gcc/*/*/collect2
|
|
timestamp_set $TOOLCHAIN_NAME install
|
|
timestamp_force $TOOLCHAIN_NAME-gdbserver configure
|
|
fi
|
|
|
|
# configure the gdbserver build now
|
|
if ! timestamp_check $TOOLCHAIN_NAME-gdbserver configure; then
|
|
echo "Configure: $TOOLCHAIN_NAME gdbserver build."
|
|
# Old toolchain source packages placed the gdb sources at
|
|
# the top-level, while newer ones place them under the 'gdb'
|
|
# directory. Probe the filesystem to check which one is appropriate.
|
|
GDB_SRCDIR=$TOOLCHAIN_SRC/gdb/gdb-$GDB_VERSION
|
|
if [ ! -d $GDB_SRCDIR ] ; then
|
|
GDB_SRCDIR=$TOOLCHAIN_SRC/gdb-$GDB_VERSION
|
|
fi
|
|
mkdir -p $GDBSERVER_BUILD
|
|
OLD_CC="$CC"
|
|
OLD_CFLAGS="$CFLAGS"
|
|
OLD_LDFLAGS="$LDFLAGS"
|
|
cd $GDBSERVER_BUILD &&
|
|
export CC="$TOOLCHAIN_PREFIX/bin/arm-eabi-gcc" &&
|
|
export CFLAGS="-g -O2 -static -mandroid" &&
|
|
export LDFLAGS= &&
|
|
run $GDB_SRCDIR/gdb/gdbserver/configure \
|
|
--host=arm-eabi-linux \
|
|
--with-sysroot=$ANDROID_SYSROOT
|
|
if [ $? != 0 ] ; then
|
|
echo "Could not configure gdbserver build. See $TMPLOG"
|
|
exit 1
|
|
fi
|
|
CC="$OLD_CC"
|
|
CFLAGS="$OLD_CFLAGS"
|
|
LDFLAGS="$OLD_LDFLAGS"
|
|
timestamp_set $TOOLCHAIN_NAME-gdbserver configure
|
|
timestamp_force $TOOLCHAIN_NAME-gdbserver build
|
|
fi
|
|
|
|
# build gdbserver
|
|
if ! timestamp_check $TOOLCHAIN_NAME-gdbserver build; then
|
|
echo "Building : $TOOLCHAIN_NAME gdbserver."
|
|
cd $GDBSERVER_BUILD &&
|
|
run make -j$JOBS
|
|
if [ $? != 0 ] ; then
|
|
echo "Could not build $TOOLCHAIN_NAME gdbserver. See $TMPLOG"
|
|
exit 1
|
|
fi
|
|
timestamp_set $TOOLCHAIN_NAME-gdbserver build
|
|
timestamp_force $TOOLCHAIN_NAME-gdbserver install
|
|
fi
|
|
|
|
# install gdbserver
|
|
#
|
|
# note that we install it in the toolchain bin directory
|
|
# not in $SYSROOT/usr/bin
|
|
#
|
|
if ! timestamp_check $TOOLCHAIN_NAME-gdbserver install; then
|
|
echo "Install : $TOOLCHAIN_NAME gdbserver."
|
|
DEST=$TOOLCHAIN_PREFIX/bin
|
|
mkdir -p $DEST &&
|
|
$TOOLCHAIN_PREFIX/bin/arm-eabi-strip $GDBSERVER_BUILD/gdbserver &&
|
|
run cp -f $GDBSERVER_BUILD/gdbserver $DEST/gdbserver
|
|
if [ $? != 0 ] ; then
|
|
echo "Could not install gdbserver. See $TMPLOG"
|
|
exit 1
|
|
fi
|
|
timestamp_set $TOOLCHAIN_NAME-gdbserver install
|
|
timestamp_force package toolchain
|
|
fi
|
|
}
|
|
|
|
# Look at the toolchains available from the source package
|
|
#
|
|
# The old source tarball only contained gcc 4.2.1, the new
|
|
# ones contain multiple toolchains
|
|
#
|
|
if [ -d $ANDROID_TOOLCHAIN_SRC/gcc-4.2.1 ] ; then
|
|
# An old toolchain source package
|
|
ANDROID_TOOLCHAIN_LIST=arm-eabi-4.2.1
|
|
else
|
|
ANDROID_TOOLCHAIN_LIST="arm-eabi-4.2.1 arm-eabi-4.4.0"
|
|
fi
|
|
|
|
for _toolchain in $ANDROID_TOOLCHAIN_LIST; do
|
|
if timestamp_check toolchain build; then
|
|
timestamp_force ${_toolchain} configure
|
|
timestamp_force ${_toolchain}-gdbserver configure
|
|
fi
|
|
# Gcc 4.2.1 needs binutils 2.17
|
|
if [ ${_toolchain} = arm-eabi-4.2.1 ] ; then
|
|
GCC_VERSION=4.2.1
|
|
BINUTILS_VERSION=2.17
|
|
else
|
|
GCC_VERSION=4.4.0
|
|
BINUTILS_VERSION=2.19
|
|
fi
|
|
build_toolchain ${_toolchain}
|
|
done
|
|
|
|
# package the toolchain
|
|
TOOLCHAIN_TARBALL=/tmp/android-ndk-prebuilt-$RELEASE-$HOST_TAG.tar.bz2
|
|
if ! timestamp_check package toolchain; then
|
|
echo "Cleanup : Removing unuseful stuff"
|
|
rm -rf $OUT/build/prebuilt/$HOST_TAG/*/share
|
|
find $OUT/build/prebuilt/$HOST_TAG -name "libiberty.a" | xargs rm -f
|
|
find $OUT/build/prebuilt/$HOST_TAG -name "libarm-elf-linux-sim.a" | xargs rm -f
|
|
echo "Package : $HOST_ARCH toolchain binaries"
|
|
echo " into $TOOLCHAIN_TARBALL"
|
|
cd $ANDROID_NDK_ROOT &&
|
|
TARFLAGS="cjf"
|
|
if [ $VERBOSE = yes ] ; then
|
|
TARFLAGS="v$TARFLAGS"
|
|
fi
|
|
TOOLCHAIN_SRC_DIRS=
|
|
for _toolchain in $ANDROID_TOOLCHAIN_LIST; do
|
|
TOOLCHAIN_SRC_DIRS="$TOOLCHAIN_SRC_DIRS build/prebuilt/$HOST_TAG/${_toolchain}"
|
|
done
|
|
run tar $TARFLAGS $TOOLCHAIN_TARBALL -C $OUT $TOOLCHAIN_SRC_DIRS
|
|
if [ $? != 0 ] ; then
|
|
echo "ERROR: Cannot package prebuilt toolchain binaries. See $TMPLOG"
|
|
exit 1
|
|
fi
|
|
timestamp_set package toolchain
|
|
echo "prebuilt toolchain is in $TOOLCHAIN_TARBALL"
|
|
else
|
|
echo "prebuilt toolchain is in $TOOLCHAIN_TARBALL"
|
|
fi
|
|
|
|
if [ -z "$OPTION_BUILD_OUT" ] ; then
|
|
echo "Cleaning temporary directory $OUT"
|
|
rm -rf $OUT
|
|
else
|
|
echo "Don't forget to clean build directory $OUT"
|
|
fi
|
|
|
|
echo "Done."
|
|
rm -f $TMPLOG
|