android/build/common.sh

# Copyright (C) 2008 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 file is included by other shell scripts; do not execute it directly.
# It contains common definitions.
#
PROGNAME=`basename $0`

## Logging support
##
VERBOSE=yes
VERBOSE2=no

log ()
{
    if [ "$VERBOSE" = "yes" ] ; then
        echo "$1"
    fi
}

log2 ()
{
    if [ "$VERBOSE2" = "yes" ] ; then
        echo "$1"
    fi
}

## Utilities
##

# return the value of a given named variable
# $1: variable name
#
var_value ()
{
    # find a better way to do that ?
    local result
    eval result="$`echo $1`"
    echo $result
}

# convert to uppercase
to_uppercase ()
{
    echo $1 | tr "[:lower:]" "[:upper:]"
}

## Normalize OS and CPU
##

CPU=`uname -m`
case "$CPU" in
    i?86) CPU=x86
    ;;
    amd64) CPU=x86_64
    ;;
    powerpc) CPU=ppc
    ;;
esac

log2 "CPU=$CPU"

# at this point, the supported values for CPU are:
#   x86
#   x86_64
#   ppc
#
# other values may be possible but haven't been tested
#

EXE=""
OS=`uname -s`
case "$OS" in
    Darwin)
        OS=darwin-$CPU
        ;;
    Linux)
        # note that building  32-bit binaries on x86_64 is handled later
        OS=linux-$CPU
	;;
    FreeBSD)
        OS=freebsd-$CPU
        ;;
    CYGWIN*|*_NT-*)
        OS=windows
        EXE=.exe
        if [ "x$OSTYPE" = xcygwin ] ; then
            OS=cygwin
            HOST_CFLAGS="$CFLAGS -mno-cygwin"
            HOST_LDFLAGS="$LDFLAGS -mno-cygwin"
        fi
        ;;
esac

log2 "OS=$OS"
log2 "EXE=$EXE"

# at this point, the value of OS should be one of the following:
#   linux-x86
#   linux-x86_64
#   darwin-x86
#   darwin-x86_64
#   darwin-ppc
#   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_OS as $OS without any cpu-specific suffix
#
case $OS in
    linux-*) HOST_OS=linux
    ;;
    darwin-*) HOST_OS=darwin
    ;;
    freebsd-*) HOST_OS=freebsd
    ;;
    *) HOST_OS=$OS
esac

# define HOST_ARCH as the $CPU
HOST_ARCH=$CPU

# define HOST_TAG
# special case: windows-x86 => windows
compute_host_tag ()
{
    case $HOST_OS-$HOST_ARCH in
        cygwin-x86|windows-x86)
            HOST_TAG=windows
            ;;
        *)
            HOST_TAG=$HOST_OS-$HOST_ARCH
            ;;
    esac
}
compute_host_tag

#### Toolchain support
####

# Various probes are going to need to run a small C program
TMPC=/tmp/android-$$-test.c
TMPO=/tmp/android-$$-test.o
TMPE=/tmp/android-$$-test$EXE
TMPL=/tmp/android-$$-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 should be called to enforce the build of 32-bit binaries on 64-bit systems
# that support it.
FORCE_32BIT=no
force_32bit_binaries ()
{
    if [ $CPU = x86_64 ] ; then
        FORCE_32BIT=yes
        case $OS in
            linux-x86_64) OS=linux-x86 ;;
            darwin-x86_64) OS=darwin-x86 ;;
	    freebsd-x86_64) OS=freebsd-x86 ;;
        esac
        HOST_ARCH=x86
        CPU=x86
        compute_host_tag
        log "Check32Bits: Forcing generation of 32-bit binaries (--try-64 to disable)"
    fi
}

# Enable linux-mingw32 compilation. This allows you to build
# windows executables on a Linux machine, which is considerably
# faster than using Cygwin / MSys to do the same job.
#
enable_linux_mingw ()
{
    # Are we on Linux ?
    log "Mingw      : Checking for Linux host"
    if [ "$HOST_OS" != "linux" ] ; then
        echo "Sorry, but mingw compilation is only supported on Linux !"
        exit 1
    fi
    # Do we have the binaries installed
    log "Mingw      : Checking for mingw32 installation"
    MINGW32_PREFIX=i586-mingw32msvc
    find_program MINGW32_CC $MINGW32_PREFIX-gcc
    if [ -z "$MINGW32_CC" ] ; then
        echo "ERROR: It looks like $MINGW32_PREFIX-gcc is not in your path"
        echo "Please install the mingw32 package !"
        exit 1
    fi
    log2 "Mingw      : Found $MINGW32_CC"
    CC=$MINGW32_CC
    LD=$MINGW32_CC
    AR=$MINGW32_PREFIX-ar
    FORCE_32BIT=no
}

# Cygwin is normally not supported, unless you call this function
#
enable_cygwin ()
{
    if [ $OS = cygwin ] ; then
        CFLAGS="$CFLAGS -mno-cygwin"
        LDFLAGS="$LDFLAGS -mno-cygwin"
        OS=windows
        HOST_OS=windows
    fi
}

# this function will setup the compiler and linker and check that they work as advertized
# note that you should call 'force_32bit_binaries' before this one if you want it to work
# as advertized.
#
setup_toolchain ()
{
    if [ "$OS" = cygwin ] ; then
        echo "Do not compile this program or library with Cygwin, use MSYS instead !!"
        echo "As an experimental feature, you can try to --try-cygwin option to override this"
        exit 2
    fi

    if [ -z "$CC" ] ; then
        CC=gcc
        if [ $CPU = "powerpc" ] ; then
            CC=gcc-3.3
        fi
    fi

    # check that we can compile a trivial C program with this compiler
    cat > $TMPC <<EOF
int main(void) {}
EOF

    if [ $FORCE_32BIT = yes ] ; then
        CFLAGS="$CFLAGS -m32"
        LDFLAGS="$LDFLAGS -m32"
        compile
        if [ $? != 0 ] ; then
            # sometimes, we need to also tell the assembler to generate 32-bit binaries
            # this is highly dependent on your GCC installation (and no, we can't set
            # this flag all the time)
            CFLAGS="$CFLAGS -Wa,--32"
        fi
    fi

    compile
    if [ $? != 0 ] ; then
        echo "your C compiler doesn't seem to work: $CC"
        cat $TMPL
        clean_exit
    fi
    log "CC         : compiler check ok ($CC)"

    # check that we can link the trivial program into an executable
    if [ -z "$LD" ] ; then
        LD=$CC
    fi
    link
    if [ $? != 0 ] ; then
        OLD_LD=$LD
        LD=gcc
        compile
        link
        if [ $? != 0 ] ; then
            LD=$OLD_LD
            echo "your linker doesn't seem to work:"
            cat $TMPL
            clean_exit
        fi
    fi
    log "LD         : linker check ok ($LD)"

    if [ -z "$AR" ]; then
        AR=ar
    fi
    log "AR         : archiver ($AR)"
    clean_temp
}

# 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
}

# 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
}

## Feature test support
##

# Each feature test allows us to check against a single target-specific feature
# We run the feature checks in a Makefile in order to be able to do them in
# parallel, and we also have some cached values in our output directory, just
# in case.
#
# check that a given C program in $TMPC can be compiled on the host system
# $1: variable name which will be set to "yes" or "no" depending on result
# you can define EXTRA_CFLAGS for extra C compiler flags
# for convenience, this variable will be unset by the function
#
feature_check_compile ()
{
    local result_cc=yes
    local OLD_CFLAGS
    OLD_CFLAGS="$CFLAGS"
    CFLAGS="$CFLAGS $EXTRA_CFLAGS"
    compile
    if [ $? != 0 ] ; then
        result_cc=no
    fi
    eval $1=$result_cc
    EXTRA_CFLAGS=
    CFLAGS=$OLD_CFLAGS
}

# check that a given C program $TMPC can be linked on the host system
# $1: variable name which will be set to "yes" or "no" depending on result
# you can define EXTRA_CFLAGS for extra C compiler flags
# you can define EXTRA_LDFLAGS for extra linker flags
# for convenience, these variables will be unset by the function
#
feature_check_link ()
{
    local result_cl=yes
    local OLD_CFLAGS OLD_LDFLAGS
    OLD_CFLAGS=$CFLAGS
    OLD_LDFLAGS=$LDFLAGS
    CFLAGS="$CFLAGS $EXTRA_CFLAGS"
    LDFLAGS="$LDFLAGS $EXTRA_LDFLAGS"
    compile
    if [ $? != 0 ] ; then
        result_cl=no
    else
        link
        if [ $? != 0 ] ; then
            result_cl=no
        fi
    fi
    CFLAGS=$OLD_CFLAGS
    LDFLAGS=$OLD_LDFLAGS
    eval $1=$result_cl
    clean_temp
}

# check that a given C header file exists on the host system
# $1: variable name which will be set to "yes" or "no" depending on result
# $2: header name
#
# you can define EXTRA_CFLAGS for extra C compiler flags
# for convenience, this variable will be unset by the function.
#
feature_check_header ()
{
    local result_ch
    log "HeaderCheck: $2"
    echo "#include $2" > $TMPC
    cat >> $TMPC <<EOF
        int main(void) { return 0; }
EOF
    feature_check_compile result_ch
    eval $1=$result_ch
    #eval result=$`echo $1`
    #log  "Host       : $1=$result_ch"
    clean_temp
}

# run the test program that is in $TMPC and set its exit status
# in the $1 variable.
# you can define EXTRA_CFLAGS and EXTRA_LDFLAGS
#
feature_run_exec ()
{
    local run_exec_result
    local OLD_CFLAGS="$CFLAGS"
    local OLD_LDFLAGS="$LDFLAGS"
    CFLAGS="$CFLAGS $EXTRA_CFLAGS"
    LDFLAGS="$LDFLAGS $EXTRA_LDFLAGS"
    compile_exec_run
    run_exec_result=$?
    CFLAGS="$OLD_CFLAGS"
    LDFLAGS="$OLD_LDFLAGS"
    eval $1=$run_exec_result
    log "Host       : $1=$run_exec_result"
    clean_temp
}

## Android build system auto-detection
##

# check whether we're running within the Android build system
# sets the variable IN_ANDROID_BUILD to either "yes" or "no"
#
# in case of success, defines ANDROID_TOP to point to the top
# of the Android source tree.
#
check_android_build ()
{
    unset ANDROID_TOP
    IN_ANDROID_BUILD=no

    if [ -z "$ANDROID_BUILD_TOP" ] ; then
        return ;
    fi

    ANDROID_TOP=$ANDROID_BUILD_TOP
    log "ANDROID_TOP found at $ANDROID_TOP"
    # $ANDROID_TOP/config/envsetup.make is for the old tree layout
    # $ANDROID_TOP/build/envsetup.sh is for the new one
    ANDROID_CONFIG_MK=$ANDROID_TOP/build/core/config.mk
    if [ ! -f $ANDROID_CONFIG_MK ] ; then
        ANDROID_CONFIG_MK=$ANDROID_TOP/config/envsetup.make
    fi
    if [ ! -f $ANDROID_CONFIG_MK ] ; then
        echo "Weird: Cannot find build system root defaulting to non-Android build"
        unset ANDROID_TOP
        return
    fi
    # normalize ANDROID_TOP, we don't want a trailing /
    ANDROID_TOPDIR=`dirname $ANDROID_TOP`
    if [ "$ANDROID_TOPDIR" != "." ] ; then
        ANDROID_TOP=$ANDROID_TOPDIR/`basename $ANDROID_TOP`
    fi
    IN_ANDROID_BUILD=yes
}

# Get the value of an Android build variable as an absolute path.
# you should only call this if IN_ANDROID_BUILD is "yes"
#
get_android_abs_build_var ()
{
   (cd $ANDROID_TOP && CALLED_FROM_SETUP=true BUILD_SYSTEM=build/core make -f $ANDROID_CONFIG_MK dumpvar-abs-$1)
}

# Locate the Android prebuilt directory for your os
# you should only call this if IN_ANDROID_BUILD is "yes"
#
# This will set ANDROID_PREBUILT_HOST_TAG, ANDROID_PREBUILT and ANDROID_PREBUILTS
#
locate_android_prebuilt ()
{
    # locate prebuilt directory
    ANDROID_PREBUILT_HOST_TAG=$OS
    ANDROID_PREBUILT=$ANDROID_TOP/prebuilt/$ANDROID_PREBUILT_HOST_TAG  # AOSP still has it
    ANDROID_PREBUILTS=$ANDROID_TOP/prebuilts/misc/$ANDROID_PREBUILT_HOST_TAG # AOSP does't have it yet
    if [ ! -d $ANDROID_PREBUILT ] ; then
        # this can happen when building on x86_64, or in AOSP
        case $OS in
            linux-x86_64)
                ANDROID_PREBUILT_HOST_TAG=linux-x86
                ANDROID_PREBUILT=$ANDROID_TOP/prebuilt/$ANDROID_PREBUILT_HOST_TAG
                ;;
            *)
        esac
        if [ ! -d $ANDROID_PREBUILT ] ; then
            ANDROID_PREBUILT=
        fi
    fi
    if [ ! -d $ANDROID_PREBUILTS ] ; then
        # this can happen when building on x86_64
        case $OS in
            linux-x86_64)
                ANDROID_PREBUILT_HOST_TAG=linux-x86
                ANDROID_PREBUILTS=$ANDROID_TOP/prebuilts/misc/$ANDROID_PREBUILT_HOST_TAG
                ;;
            *)
        esac
        if [ ! -d $ANDROID_PREBUILTS ] ; then
            ANDROID_PREBUILTS=
        fi
    fi
    log "Prebuilt   : ANDROID_PREBUILT=$ANDROID_PREBUILT"
    log "Prebuilts  : ANDROID_PREBUILTS=$ANDROID_PREBUILTS"
}

## Build configuration file support
## you must define $config_mk before calling this function
##
create_config_mk ()
{
    # create the directory if needed
    local  config_dir
    config_mk=${config_mk:-objs/config.make}
    config_dir=`dirname $config_mk`
    mkdir -p $config_dir 2> $TMPL
    if [ $? != 0 ] ; then
        echo "Can't create directory for build config file: $config_dir"
        cat $TMPL
        clean_exit
    fi

    # re-create the start of the configuration file
    log "Generate   : $config_mk"

    echo "# This file was autogenerated by $PROGNAME. Do not edit !" > $config_mk
    echo "OS          := $OS" >> $config_mk
    echo "HOST_OS     := $HOST_OS" >> $config_mk
    echo "HOST_ARCH   := $HOST_ARCH" >> $config_mk
    echo "CC          := $CC" >> $config_mk
    echo "LD          := $LD" >> $config_mk
    echo "AR          := $AR" >> $config_mk
    echo "CFLAGS      := $CFLAGS" >> $config_mk
    echo "LDFLAGS     := $LDFLAGS" >> $config_mk
    echo "HOST_CC     := $CC" >> $config_mk
    echo "HOST_LD     := $LD" >> $config_mk
    echo "HOST_AR     := $AR" >> $config_mk
}

add_android_config_mk ()
{
    echo "" >> $config_mk
    if [ $TARGET_ARCH = arm ] ; then
    echo "TARGET_ARCH       := arm" >> $config_mk
    fi
    if [ $TARGET_ARCH = x86 ] ; then
    echo "TARGET_ARCH       := x86" >> $config_mk
    fi
    echo "HOST_PREBUILT_TAG := $HOST_TAG" >> $config_mk
    echo "PREBUILT          := $ANDROID_PREBUILT" >> $config_mk
    echo "PREBUILTS         := $ANDROID_PREBUILTS" >> $config_mk
}

# Find pattern $1 in string $2
# This is to be used in if statements as in:
#
#    if pattern_match <pattern> <string>; then
#       ...
#    fi
#
pattern_match ()
{
    echo "$2" | grep -q -E -e "$1"
}

# 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
        if pattern_match '^no ' "$PROG"; then
            PROG=
        fi
    fi
    eval $1="$PROG"
}