libvpx: Pull from upstream

source/libvpx/build/make/configure.sh

-#!/bin/bash
+#!/bin/sh
 ##
 ##  configure.sh
 ##
 ##  This script is sourced by the main configure script and contains
 ##  utility functions and other common bits that aren't strictly libvpx
 ##  related.
 ##
 ##  This build system is based in part on the FFmpeg configure script.
 ##
 
@@ skipping 179 matching lines @@
 }
 
 
 add_extralibs() {
     extralibs="${extralibs} $@"
 }
 
 #
 # Boolean Manipulation Functions
 #
-enable(){
+enable_feature(){
     set_all yes $*
 }
 
-disable(){
+disable_feature(){
     set_all no $*
 }
 
 enabled(){
     eval test "x\$$1" = "xyes"
 }
 
 disabled(){
     eval test "x\$$1" = "xno"
 }
 
 
 soft_enable() {
     for var in $*; do
         if ! disabled $var; then
             log_echo "  enabling $var"
-            enable $var
+            enable_feature $var
         fi
     done
 }
 
 soft_disable() {
     for var in $*; do
         if ! enabled $var; then
             log_echo "  disabling $var"
-            disable $var
+            disable_feature $var
         fi
     done
 }
 
 
 #
 # Text Processing Functions
 #
 toupper(){
     echo "$@" | tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ
 }
 
 
 tolower(){
     echo "$@" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz
 }
 
 
 #
 # Temporary File Functions
 #
 source_path=${0%/*}
-enable source_path_used
+enable_feature source_path_used
 if test -z "$source_path" -o "$source_path" = "." ; then
     source_path="`pwd`"
-    disable source_path_used
+    disable_feature source_path_used
 fi
 
 if test ! -z "$TMPDIR" ; then
     TMPDIRx="${TMPDIR}"
 elif test ! -z "$TEMPDIR" ; then
     TMPDIRx="${TEMPDIR}"
 else
     TMPDIRx="/tmp"
 fi
-TMP_H="${TMPDIRx}/vpx-conf-$$-${RANDOM}.h"
-TMP_C="${TMPDIRx}/vpx-conf-$$-${RANDOM}.c"
-TMP_CC="${TMPDIRx}/vpx-conf-$$-${RANDOM}.cc"
-TMP_O="${TMPDIRx}/vpx-conf-$$-${RANDOM}.o"
-TMP_X="${TMPDIRx}/vpx-conf-$$-${RANDOM}.x"
-TMP_ASM="${TMPDIRx}/vpx-conf-$$-${RANDOM}.asm"
+RAND=$(awk 'BEGIN { srand(); printf "%d\n",(rand() * 32768)}')
+TMP_H="${TMPDIRx}/vpx-conf-$$-${RAND}.h"
+TMP_C="${TMPDIRx}/vpx-conf-$$-${RAND}.c"
+TMP_CC="${TMPDIRx}/vpx-conf-$$-${RAND}.cc"
+TMP_O="${TMPDIRx}/vpx-conf-$$-${RAND}.o"
+TMP_X="${TMPDIRx}/vpx-conf-$$-${RAND}.x"
+TMP_ASM="${TMPDIRx}/vpx-conf-$$-${RAND}.asm"
 
 clean_temp_files() {
     rm -f ${TMP_C} ${TMP_CC} ${TMP_H} ${TMP_O} ${TMP_X} ${TMP_ASM}
 }
 
 #
 # Toolchain Check Functions
 #
 check_cmd() {
     enabled external_build && return
@@ skipping 26 matching lines @@
     log check_ld "$@"
     check_cc $@ \
         && check_cmd ${LD} ${LDFLAGS} "$@" -o ${TMP_X} ${TMP_O} ${extralibs}
 }
 
 check_header(){
     log check_header "$@"
     header=$1
     shift
     var=`echo $header | sed 's/[^A-Za-z0-9_]/_/g'`
-    disable $var
-    check_cpp "$@" <<EOF && enable $var
+    disable_feature $var
+    check_cpp "$@" <<EOF && enable_feature $var
 #include "$header"
 int x;
 EOF
 }
 
 
 check_cflags() {
     log check_cflags "$@"
     check_cc "$@" <<EOF
 int x;
@@ skipping 141 matching lines @@
     print_config_h CONFIG "${TMP_H}" ${CONFIG_LIST}
     echo "#endif /* VPX_CONFIG_H */" >> ${TMP_H}
     mkdir -p `dirname "$1"`
     cmp "$1" ${TMP_H} >/dev/null 2>&1 || mv ${TMP_H} "$1"
 }
 
 process_common_cmdline() {
     for opt in "$@"; do
         optval="${opt#*=}"
         case "$opt" in
-        --child) enable child
+        --child) enable_feature child
         ;;
         --log*)
         logging="$optval"
         if ! disabled logging ; then
             enabled logging || logfile="$logging"
         else
             logfile=/dev/null
         fi
         ;;
         --target=*) toolchain="${toolchain:-${optval}}"
         ;;
-        --force-target=*) toolchain="${toolchain:-${optval}}"; enable force_toolchain
+        --force-target=*) toolchain="${toolchain:-${optval}}"; enable_feature force_toolchain
         ;;
         --cpu)
         ;;
         --cpu=*) tune_cpu="$optval"
         ;;
         --extra-cflags=*)
         extra_cflags="${optval}"
         ;;
         --enable-?*|--disable-?*)
         eval `echo "$opt" | sed 's/--/action=/;s/-/ option=/;s/-/_/g'`
         if echo "${ARCH_EXT_LIST}" | grep "^ *$option\$" >/dev/null; then
             [ $action = "disable" ] && RTCD_OPTIONS="${RTCD_OPTIONS}${opt} "
         elif [ $action = "disable" ] && ! disabled $option ; then
           echo "${CMDLINE_SELECT}" | grep "^ *$option\$" >/dev/null ||
             die_unknown $opt
         elif [ $action = "enable" ] && ! enabled $option ; then
           echo "${CMDLINE_SELECT}" | grep "^ *$option\$" >/dev/null ||
             die_unknown $opt
         fi
-        $action $option
+        ${action}_feature $option
         ;;
         --require-?*)
         eval `echo "$opt" | sed 's/--/action=/;s/-/ option=/;s/-/_/g'`
         if echo "${ARCH_EXT_LIST}" none | grep "^ *$option\$" >/dev/null; then
             RTCD_OPTIONS="${RTCD_OPTIONS}${opt} "
         else
             die_unknown $opt
         fi
         ;;
         --force-enable-?*|--force-disable-?*)
         eval `echo "$opt" | sed 's/--force-/action=/;s/-/ option=/;s/-/_/g'`
-        $action $option
+        ${action}_feature $option
         ;;
         --libc=*)
         [ -d "${optval}" ] || die "Not a directory: ${optval}"
-        disable builtin_libc
+        disable_feature builtin_libc
         alt_libc="${optval}"
         ;;
         --as=*)
         [ "${optval}" = yasm -o "${optval}" = nasm -o "${optval}" = auto ] \
             || die "Must be yasm, nasm or auto: ${optval}"
         alt_as="${optval}"
         ;;
         --prefix=*)
         prefix="${optval}"
         ;;
@@ skipping 148 matching lines @@
 
     #
     # Set up toolchain variables
     #
     tgt_isa=$(echo ${toolchain} | awk 'BEGIN{FS="-"}{print $1}')
     tgt_os=$(echo ${toolchain} | awk 'BEGIN{FS="-"}{print $2}')
     tgt_cc=$(echo ${toolchain} | awk 'BEGIN{FS="-"}{print $3}')
 
     # Mark the specific ISA requested as enabled
     soft_enable ${tgt_isa}
-    enable ${tgt_os}
-    enable ${tgt_cc}
+    enable_feature ${tgt_os}
+    enable_feature ${tgt_cc}
 
     # Enable the architecture family
     case ${tgt_isa} in
-        arm*) enable arm;;
-        mips*) enable mips;;
+        arm*) enable_feature arm;;
+        mips*) enable_feature mips;;
     esac
 
     # PIC is probably what we want when building shared libs
     enabled shared && soft_enable pic
 
     # Handle darwin variants. Newer SDKs allow targeting older
     # platforms, so find the newest SDK available.
     case ${toolchain} in
         *-darwin*)
             if [ -z "${DEVELOPER_DIR}" ]; then
@@ skipping 42 matching lines @@
         *-darwin13-*)
             add_cflags  "-mmacosx-version-min=10.9"
             add_ldflags "-mmacosx-version-min=10.9"
             ;;
     esac
 
     # Handle Solaris variants. Solaris 10 needs -lposix4
     case ${toolchain} in
         sparc-solaris-*)
             add_extralibs -lposix4
-            disable fast_unaligned
+            disable_feature fast_unaligned
             ;;
         *-solaris-*)
             add_extralibs -lposix4
             ;;
     esac
 
     # Process ARM architecture variants
     case ${toolchain} in
     arm*)
         # on arm, isa versions are supersets
         case ${tgt_isa} in
         armv7)
             soft_enable neon
             soft_enable media
             soft_enable edsp
             soft_enable fast_unaligned
             ;;
         armv6)
             soft_enable media
             soft_enable edsp
             soft_enable fast_unaligned
             ;;
         armv5te)
             soft_enable edsp
-            disable fast_unaligned
+            disable_feature fast_unaligned
             ;;
         esac
 
         asm_conversion_cmd="cat"
 
         case ${tgt_cc} in
         gcc)
             CROSS=${CROSS:-arm-none-linux-gnueabi-}
             link_with_cc=gcc
             setup_gnu_toolchain
             arch_int=${tgt_isa##armv}
             arch_int=${arch_int%%te}
             check_add_asflags --defsym ARCHITECTURE=${arch_int}
             tune_cflags="-mtune="
-            if [ ${tgt_isa} == "armv7" ]; then
+            if [ ${tgt_isa} = "armv7" ]; then
                 if [ -z "${float_abi}" ]; then
                     check_cpp <<EOF && float_abi=hard || float_abi=softfp
 #ifndef __ARM_PCS_VFP
 #error "not hardfp"
 #endif
 EOF
                 fi
                 check_add_cflags  -march=armv7-a -mfloat-abi=${float_abi}
                 check_add_asflags -march=armv7-a -mfloat-abi=${float_abi}
 
@@ skipping 16 matching lines @@
             if enabled thumb; then
                 asm_conversion_cmd="$asm_conversion_cmd -thumb"
                 check_add_cflags -mthumb
                 check_add_asflags -mthumb -mimplicit-it=always
             fi
             ;;
         vs*)
             asm_conversion_cmd="${source_path}/build/make/ads2armasm_ms.pl"
             AS_SFX=.s
             msvs_arch_dir=arm-msvs
-            disable multithread
-            disable unit_tests
+            disable_feature multithread
+            disable_feature unit_tests
             ;;
         rvct)
             CC=armcc
             AR=armar
             AS=armasm
             LD=${source_path}/build/make/armlink_adapter.sh
             STRIP=arm-none-linux-gnueabi-strip
             NM=arm-none-linux-gnueabi-nm
             tune_cflags="--cpu="
             tune_asflags="--cpu="
             if [ -z "${tune_cpu}" ]; then
-                if [ ${tgt_isa} == "armv7" ]; then
+                if [ ${tgt_isa} = "armv7" ]; then
                     if enabled neon
                     then
                         check_add_cflags --fpu=softvfp+vfpv3
                         check_add_asflags --fpu=softvfp+vfpv3
                     fi
                     check_add_cflags --cpu=Cortex-A8
                     check_add_asflags --cpu=Cortex-A8
                 else
                     check_add_cflags --cpu=${tgt_isa##armv}
                     check_add_asflags --cpu=${tgt_isa##armv}
                 fi
             fi
             arch_int=${tgt_isa##armv}
             arch_int=${arch_int%%te}
             check_add_asflags --pd "\"ARCHITECTURE SETA ${arch_int}\""
             enabled debug && add_asflags -g
             add_cflags --gnu
             add_cflags --enum_is_int
             add_cflags --wchar32
         ;;
         esac
 
         case ${tgt_os} in
         none*)
-            disable multithread
-            disable os_support
+            disable_feature multithread
+            disable_feature os_support
             ;;
 
         android*)
             SDK_PATH=${sdk_path}
             COMPILER_LOCATION=`find "${SDK_PATH}" \
                                -name "arm-linux-androideabi-gcc*" -print -quit`
             TOOLCHAIN_PATH=${COMPILER_LOCATION%/*}/arm-linux-androideabi-
             CC=${TOOLCHAIN_PATH}gcc
             CXX=${TOOLCHAIN_PATH}g++
             AR=${TOOLCHAIN_PATH}ar
@@ skipping 11 matching lines @@
                           awk '{ print $1 }' | tail -1`
             fi
 
             add_cflags "--sysroot=${alt_libc}"
             add_ldflags "--sysroot=${alt_libc}"
 
             # linker flag that routes around a CPU bug in some
             # Cortex-A8 implementations (NDK Dev Guide)
             add_ldflags "-Wl,--fix-cortex-a8"
 
-            enable pic
+            enable_feature pic
             soft_enable realtime_only
-            if [ ${tgt_isa} == "armv7" ]; then
+            if [ ${tgt_isa} = "armv7" ]; then
                 soft_enable runtime_cpu_detect
             fi
             if enabled runtime_cpu_detect; then
                 add_cflags "-I${SDK_PATH}/sources/android/cpufeatures"
             fi
           ;;
 
         darwin*)
             if [ -z "${sdk_path}" ]; then
                 SDK_PATH=`xcode-select -print-path 2> /dev/null`
@@ skipping 33 matching lines @@
 
             for d in lib usr/lib usr/lib/system; do
                 try_dir="${alt_libc}/${d}"
                 [ -d "${try_dir}" ] && add_ldflags -L"${try_dir}"
             done
 
             asm_conversion_cmd="${source_path}/build/make/ads2gas_apple.pl"
          ;;
 
         linux*)
-            enable linux
+            enable_feature linux
             if enabled rvct; then
                 # Check if we have CodeSourcery GCC in PATH. Needed for
                 # libraries
                 hash arm-none-linux-gnueabi-gcc 2>&- || \
                   die "Couldn't find CodeSourcery GCC from PATH"
 
                 # Use armcc as a linker to enable translation of
                 # some gcc specific options such as -lm and -lpthread.
                 LD="armcc --translate_gcc"
 
@@ skipping 10 matching lines @@
         ;;
 
         esac
     ;;
     mips*)
         link_with_cc=gcc
         setup_gnu_toolchain
         tune_cflags="-mtune="
         if enabled dspr2; then
             check_add_cflags -mips32r2 -mdspr2
-            disable fast_unaligned
+            disable_feature fast_unaligned
         fi
         check_add_cflags -march=${tgt_isa}
         check_add_asflags -march=${tgt_isa}
         check_add_asflags -KPIC
     ;;
     ppc*)
-        enable ppc
+        enable_feature ppc
         bits=${tgt_isa##ppc}
         link_with_cc=gcc
         setup_gnu_toolchain
         add_asflags -force_cpusubtype_ALL -I"\$(dir \$<)darwin"
         soft_enable altivec
         enabled altivec && add_cflags -maltivec
 
         case "$tgt_os" in
         linux*)
             add_asflags -maltivec -mregnames -I"\$(dir \$<)linux"
@@ skipping 127 matching lines @@
                 add_asflags -f aout
                 enabled debug && add_asflags -g
                 EXE_SFX=.exe
             ;;
             *) log "Warning: Unknown os $tgt_os while setting up $AS flags"
             ;;
         esac
     ;;
     universal*|*-gcc|generic-gnu)
         link_with_cc=gcc
-        enable gcc
+        enable_feature gcc
     setup_gnu_toolchain
     ;;
     esac
 
     # Try to enable CPU specific tuning
     if [ -n "${tune_cpu}" ]; then
         if [ -n "${tune_cflags}" ]; then
             check_add_cflags ${tune_cflags}${tune_cpu} || \
                 die "Requested CPU '${tune_cpu}' not supported by compiler"
         fi
@@ skipping 13 matching lines @@
         check_add_ldflags -fprofile-arcs -ftest-coverage
 
     if enabled optimizations; then
         if enabled rvct; then
             enabled small && check_add_cflags -Ospace || check_add_cflags -Otime
         else
             enabled small && check_add_cflags -O2 ||  check_add_cflags -O3
         fi
     fi
 
+    # default use_x86inc to yes if pic is no or 64bit or we are not on darwin
+    echo "  checking here for x86inc \"${tgt_isa}\" \"$pic\" "
+    if [ ${tgt_isa} = x86_64 -o ! "$pic" = "yes" -o "${tgt_os#darwin}" = "${tgt_os}"  ]; then
+      soft_enable use_x86inc
+    fi
+
     # Position Independent Code (PIC) support, for building relocatable
     # shared objects
     enabled gcc && enabled pic && check_add_cflags -fPIC
 
     # Work around longjmp interception on glibc >= 2.11, to improve binary
     # compatibility. See http://code.google.com/p/webm/issues/detail?id=166
     enabled linux && check_add_cflags -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=0
 
     # Check for strip utility variant
-    ${STRIP} -V 2>/dev/null | grep GNU >/dev/null && enable gnu_strip
+    ${STRIP} -V 2>/dev/null | grep GNU >/dev/null && enable_feature gnu_strip
 
     # Try to determine target endianness
     check_cc <<EOF
     unsigned int e = 'O'<<24 | '2'<<16 | 'B'<<8 | 'E';
 EOF
     [ -f "${TMP_O}" ] && od -A n -t x1 "${TMP_O}" | tr -d '\n' |
-        grep '4f *32 *42 *45' >/dev/null 2>&1 && enable big_endian
+        grep '4f *32 *42 *45' >/dev/null 2>&1 && enable_feature big_endian
 
     # Try to find which inline keywords are supported
     check_cc <<EOF && INLINE="inline"
     static inline function() {}
 EOF
     check_cc <<EOF && INLINE="__inline__ __attribute__((always_inline))"
     static __attribute__((always_inline)) function() {}
 EOF
 
     # Almost every platform uses pthreads.
     if enabled multithread; then
         case ${toolchain} in
             *-win*-vs*);;
             *-android-gcc);;
             *) check_header pthread.h && add_extralibs -lpthread
         esac
     fi
 
     # only for MIPS platforms
     case ${toolchain} in
         mips*)
             if enabled dspr2; then
                 if enabled big_endian; then
                     echo "dspr2 optimizations are available only for little endian platforms"
-                    disable dspr2
+                    disable_feature dspr2
                 fi
             fi
         ;;
     esac
 
     # glibc needs these
     if enabled linux; then
         add_cflags -D_LARGEFILE_SOURCE
         add_cflags -D_FILE_OFFSET_BITS=64
     fi
@@ skipping 30 matching lines @@
         if enabled $cfg; then
             echo "#define ${prefix}_${upname} 1" >> $header
         else
             echo "#define ${prefix}_${upname} 0" >> $header
         fi
     done
 }
 
 print_webm_license() {
     local destination=$1
-    local prefix=$2
-    local suffix=$3
+    local prefix="$2"
+    local suffix="$3"
     shift 3
     cat <<EOF > ${destination}
 ${prefix} Copyright (c) 2011 The WebM project authors. All Rights Reserved.${suffix}
 ${prefix} ${suffix}
 ${prefix} Use of this source code is governed by a BSD-style license${suffix}
 ${prefix} that can be found in the LICENSE file in the root of the source${suffix}
 ${prefix} tree. An additional intellectual property rights grant can be found${suffix}
 ${prefix} in the file PATENTS.  All contributing project authors may${suffix}
 ${prefix} be found in the AUTHORS file in the root of the source tree.${suffix}
 EOF
 }
 
 process_targets() {
     true;
 }
 
 process_detect() {
     true;
 }
 
-enable logging
+enable_feature logging
 logfile="config.log"
 self=$0
 process() {
     cmdline_args="$@"
     process_cmdline "$@"
     if enabled child; then
         echo "# ${self} $@" >> ${logfile}
     else
         echo "# ${self} $@" > ${logfile}
     fi
     post_process_common_cmdline
     post_process_cmdline
     process_toolchain
     process_detect
     process_targets
 
     OOT_INSTALLS="${OOT_INSTALLS}"
     if enabled source_path_used; then
     # Prepare the PWD for building.
     for f in ${OOT_INSTALLS}; do
             install -D ${source_path}/$f $f
     done
     fi
     cp ${source_path}/build/make/Makefile .
 
     clean_temp_files
     true
 }