# Common functions for all prebuilt-related scripts
# This is included/sourced by other scripts
#
. `dirname $0`/../core/ndk-common.sh
#====================================================
#
# UTILITY FUNCTIONS
#
#====================================================
# Return the maximum length of a series of strings
#
# Usage: len=`max_length <string1> <string2> ...`
#
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 <values>`
dashes_to_underscores ()
{
echo $@ | tr '-' '_'
}
# Translate underscores to dashes
# Usage: str=`underscores_to_dashes <values>`
underscores_to_dashes ()
{
echo $@ | tr '_' '-'
}
#====================================================
#
# OPTION PROCESSING
#
#====================================================
# We recognize the following option formats:
#
# -f
# --flag
#
# -s<value>
# --setting=<value>
#
# 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=<value>
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<value>
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
do_mingw_option () { MINGW=yes; }
register_mingw_option ()
{
if [ "$HOST_OS" = "linux" ] ; then
register_option "--mingw" do_mingw_option "Generate windows binaries on Linux."
fi
}
# 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<value>
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 <value> as -o<value>
#
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
}
register_option "--help" do_option_help "Print this help."
register_option "--verbose" do_option_verbose "Enable verbose 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=<path> to specify one."
exit 1
fi
fi
if [ ! -f $SYSROOT/usr/include/stdlib.h ] ; then
echo "ERROR: Invalid sysroot path: $SYSROOT"
echo " Use --sysroot=<path> to indicate a valid one."
exit 1
fi
}
# Use the check for the availability of a compatibility SDK in Darwin
# this can be used to generate binaries compatible with either Tiger or
# Leopard.
#
# $1: SDK root path
# $2: MacOS X minimum version (e.g. 10.4)
check_darwin_sdk ()
{
if [ -d "$1" ] ; then
HOST_CFLAGS="-isysroot $1 -mmacosx-version-min=$2 -DMAXOSX_DEPLOYEMENT_TARGET=$2"
HOST_LDFLAGS="-Wl,-syslibroot,$sdk -mmacosx-version-min=$2"
return 0 # success
fi
return 1
}
prepare_host_flags ()
{
# 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
# By default, assume host == build
ABI_CONFIGURE_HOST="$ABI_CONFIGURE_BUILD"
# On Linux, detect our legacy-compatible toolchain when in the Android
# source tree, and use it to force the generation of glibc-2.7 compatible
# binaries.
#
# We only do this if the CC variable is not defined to a given value
# and the --mingw option is not used.
#
if [ "$HOST_OS" = "linux" -a -z "$CC" -a "$MINGW" != "yes" ]; then
LEGACY_TOOLCHAIN_DIR="$ANDROID_NDK_ROOT/../prebuilt/linux-x86/toolchain/i686-linux-glibc2.7-4.4.3"
if [ -d "$LEGACY_TOOLCHAIN_DIR" ] ; then
dump "Forcing generation of Linux binaries with legacy toolchain"
CC="$LEGACY_TOOLCHAIN_DIR/bin/i686-linux-gcc"
CXX="$LEGACY_TOOLCHAIN_DIR/bin/i686-linux-g++"
fi
fi
# Force generation of 32-bit binaries on 64-bit systems
CC=${CC:-gcc}
CXX=${CXX:-g++}
case $HOST_TAG in
darwin-*)
# Try to build with Tiger SDK if available
if check_darwin_sdk /Developer/SDKs/MacOSX10.4.sdku 10.4; then
log "Generating Tiger-compatible binaries!"
# Otherwise with Leopard SDK
elif check_darwin_sdk /Developer/SDKs/MacOSX10.5.sdk 10.5; then
log "Generating Leopard-compatible binaries!"
else
local version=`sw_vers -productVersion`
log "Generating $version-compatible binaries!"
fi
;;
esac
# Force generation of 32-bit binaries on 64-bit systems.
# We used to test the value of $HOST_TAG for *-x86_64, but this is
# not sufficient on certain systems.
#
# For example, Snow Leopard can be booted with a 32-bit kernel, running
# a 64-bit userland, with a compiler that generates 64-bit binaries by
# default *even* though "gcc -v" will report --target=i686-apple-darwin10!
#
# So know, simply probe for the size of void* by performing a small runtime
# compilation test.
#
cat > $TMPC <<EOF
/* this test should fail if the compiler generates 64-bit machine code */
int test_array[1-2*(sizeof(void*) != 4)];
EOF
echo -n "Checking whether the compiler generates 32-bit binaries..."
log $CC $HOST_CFLAGS -c -o $TMPO $TMPC
$CC $HOST_CFLAGS -c -o $TMPO $TMPC >$TMPL 2>&1
if [ $? != 0 ] ; then
echo "no"
# 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"
else
echo "yes"
fi
# For now, we only support building 32-bit binaries anyway
force_32bit_binaries # to modify HOST_TAG and others
HOST_GMP_ABI="32"
# Now handle the --mingw flag
if [ "$MINGW" = "yes" ] ; then
case $HOST_TAG in
linux-*)
;;
*)
echo "ERROR: Can only enable mingw on Linux platforms !"
exit 1
;;
esac
ABI_CONFIGURE_HOST=i586-mingw32msvc
HOST_OS=windows
HOST_TAG=windows
HOST_EXE=.exe
# 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
}
parse_toolchain_name ()
{
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-eabi-*)
ARCH="arm"
ABI_CONFIGURE_TARGET="arm-eabi"
;;
arm-linux-androideabi-*)
ARCH="arm"
ABI_CONFIGURE_TARGET="arm-linux-androideabi"
ABI_CONFIGURE_EXTRA_FLAGS="--with-gmp-version=4.2.4 --with-mpfr-version=2.4.1
--with-arch=armv5te"
# Disable ARM Gold linker for now, it doesn't build on Windows, it
# crashes with SIGBUS on Darwin, and produces weird executables on
# linux that strip complains about... Sigh.
#ABI_CONFIGURE_EXTRA_FLAGS="$ABI_CONFIGURE_EXTRA_FLAGS --enable-gold=both/gold"
# 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="-fexceptions"
ABI_CXXFLAGS_FOR_TARGET="-frtti"
ABI_CONFIGURE_EXTRA_FLAGS="$ABI_CONFIGURE_EXTRA_FLAGS --enable-libstdc__-v3"
# Stick to 6.6 for now. 7.1.x doesn't seem to work right now.
#GDB_VERSION=7.1.x
;;
x86-*)
ARCH="x86"
ABI_INSTALL_NAME="x86"
ABI_CONFIGURE_TARGET="i686-android-linux-gnu"
PLATFORM=android-5
;;
* )
echo "Invalid toolchain specified. Expected (arm-eabi-*|x86-*)"
echo ""
print_help
exit 1
;;
esac
log "Targetting CPU: $ARCH"
GCC_VERSION=`expr -- "$TOOLCHAIN" : '.*-\([0-9\.]*\)'`
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"
;;
x86-*)
GDBSERVER_HOST=i686-android-linux-gnu
GDBSERVER_CFLAGS=
;;
esac
}
# Return the host/build specific path for prebuilt toolchain binaries
# relative to $1.
#
# $1: target root NDK directory
#
get_toolchain_install ()
{
echo "$1/toolchains/$TOOLCHAIN/prebuilt/$HOST_TAG"
}
# Set the toolchain target NDK location.
# this sets TOOLCHAIN_PATH and TOOLCHAIN_PREFIX
# $1: target NDK path
set_toolchain_ndk ()
{
TOOLCHAIN_PATH=`get_toolchain_install $1`
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
#
check_toolchain_install ()
{
TOOLCHAIN_PATH=`get_toolchain_install $1`
if [ ! -d "$TOOLCHAIN_PATH" ] ; then
echo "ERROR: Toolchain '$TOOLCHAIN' not installed in '$NDK_DIR'!"
echo " Ensure that the toolchain has been installed there before."
exit 1
fi
set_toolchain_ndk $1
}
random_temp_directory ()
{
mkdir -p /tmp/ndk-toolchain
mktemp -d /tmp/ndk-toolchain/build-XXXXXX
}
#
# Common definitions
#
# Current list of platform levels we support
#
# Note: levels 6 and 7 are omitted since they have the same native
# APIs as level 5.
#
API_LEVELS="3 4 5 8 9"
# Location of the STLport sources, relative to the NDK root directory
STLPORT_SUBDIR=sources/cxx-stl/stlport
# Default ABIs for the prebuilt STLport binaries
STLPORT_ABIS="armeabi armeabi-v7a"
# Location of the GNU libstdc++ headers and libraries, relative to the NDK
# root directory.
GNUSTL_SUBDIR=sources/cxx-stl/gnu-libstdc++
# The date to use when downloading toolchain sources from android.git.kernel.org
# Leave it empty for tip of tree.
TOOLCHAIN_GIT_DATE=2010-12-13