#!/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. ## # # Logging / Output Functions # die_unknown(){ echo "Unknown option \"$1\"." echo "See $0 --help for available options." clean_temp_files exit 1 } die() { echo "$@" echo echo "Configuration failed. This could reflect a misconfiguration of your" echo "toolchains, improper options selected, or another problem. If you" echo "don't see any useful error messages above, the next step is to look" echo "at the configure error log file ($logfile) to determine what" echo "configure was trying to do when it died." clean_temp_files exit 1 } log(){ echo "$@" >>$logfile } log_file(){ log BEGIN $1 pr -n -t $1 >>$logfile log END $1 } log_echo() { echo "$@" log "$@" } fwrite () { outfile=$1 shift echo "$@" >> ${outfile} } show_help_pre(){ for opt in ${CMDLINE_SELECT}; do opt2=`echo $opt | sed -e 's;_;-;g'` if enabled $opt; then eval "toggle_${opt}=\"--disable-${opt2}\"" else eval "toggle_${opt}=\"--enable-${opt2} \"" fi done cat <<EOF Usage: configure [options] Options: Build options: --help print this message --log=yes|no|FILE file configure log is written to [config.log] --target=TARGET target platform tuple [generic-gnu] --cpu=CPU optimize for a specific cpu rather than a family --extra-cflags=ECFLAGS add ECFLAGS to CFLAGS [$CFLAGS] ${toggle_extra_warnings} emit harmless warnings (always non-fatal) ${toggle_werror} treat warnings as errors, if possible (not available with all compilers) ${toggle_optimizations} turn on/off compiler optimization flags ${toggle_pic} turn on/off Position Independent Code ${toggle_ccache} turn on/off compiler cache ${toggle_debug} enable/disable debug mode ${toggle_gprof} enable/disable gprof profiling instrumentation ${toggle_gcov} enable/disable gcov coverage instrumentation ${toggle_thumb} enable/disable building arm assembly in thumb mode Install options: ${toggle_install_docs} control whether docs are installed ${toggle_install_bins} control whether binaries are installed ${toggle_install_libs} control whether libraries are installed ${toggle_install_srcs} control whether sources are installed EOF } show_help_post(){ cat <<EOF NOTES: Object files are built at the place where configure is launched. All boolean options can be negated. The default value is the opposite of that shown above. If the option --disable-foo is listed, then the default value for foo is enabled. Supported targets: EOF show_targets ${all_platforms} echo exit 1 } show_targets() { while [ -n "$*" ]; do if [ "${1%%-*}" = "${2%%-*}" ]; then if [ "${2%%-*}" = "${3%%-*}" ]; then printf " %-24s %-24s %-24s\n" "$1" "$2" "$3" shift; shift; shift else printf " %-24s %-24s\n" "$1" "$2" shift; shift fi else printf " %-24s\n" "$1" shift fi done } show_help() { show_help_pre show_help_post } # # List Processing Functions # set_all(){ value=$1 shift for var in $*; do eval $var=$value done } is_in(){ value=$1 shift for var in $*; do [ $var = $value ] && return 0 done return 1 } add_cflags() { CFLAGS="${CFLAGS} $@" CXXFLAGS="${CXXFLAGS} $@" } add_cflags_only() { CFLAGS="${CFLAGS} $@" } add_cxxflags_only() { CXXFLAGS="${CXXFLAGS} $@" } add_ldflags() { LDFLAGS="${LDFLAGS} $@" } add_asflags() { ASFLAGS="${ASFLAGS} $@" } add_extralibs() { extralibs="${extralibs} $@" } # # Boolean Manipulation Functions # enable_feature(){ set_all yes $* } 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_feature $var fi done } soft_disable() { for var in $*; do if ! enabled $var; then log_echo " disabling $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_feature source_path_used if test -z "$source_path" -o "$source_path" = "." ; then source_path="`pwd`" disable_feature source_path_used fi if test ! -z "$TMPDIR" ; then TMPDIRx="${TMPDIR}" elif test ! -z "$TEMPDIR" ; then TMPDIRx="${TEMPDIR}" else TMPDIRx="/tmp" fi 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 log "$@" "$@" >>${logfile} 2>&1 } check_cc() { log check_cc "$@" cat >${TMP_C} log_file ${TMP_C} check_cmd ${CC} ${CFLAGS} "$@" -c -o ${TMP_O} ${TMP_C} } check_cxx() { log check_cxx "$@" cat >${TMP_CC} log_file ${TMP_CC} check_cmd ${CXX} ${CXXFLAGS} "$@" -c -o ${TMP_O} ${TMP_CC} } check_cpp() { log check_cpp "$@" cat > ${TMP_C} log_file ${TMP_C} check_cmd ${CC} ${CFLAGS} "$@" -E -o ${TMP_O} ${TMP_C} } check_ld() { 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_feature $var check_cpp "$@" <<EOF && enable_feature $var #include "$header" int x; EOF } check_cflags() { log check_cflags "$@" check_cc "$@" <<EOF int x; EOF } check_cxxflags() { log check_cxxflags "$@" # Catch CFLAGS that trigger CXX warnings case "$CXX" in *c++-analyzer|*clang++|*g++*) check_cxx -Werror "$@" <<EOF int x; EOF ;; *) check_cxx "$@" <<EOF int x; EOF ;; esac } check_add_cflags() { check_cxxflags "$@" && add_cxxflags_only "$@" check_cflags "$@" && add_cflags_only "$@" } check_add_asflags() { log add_asflags "$@" add_asflags "$@" } check_add_ldflags() { log add_ldflags "$@" add_ldflags "$@" } check_asm_align() { log check_asm_align "$@" cat >${TMP_ASM} <<EOF section .rodata align 16 EOF log_file ${TMP_ASM} check_cmd ${AS} ${ASFLAGS} -o ${TMP_O} ${TMP_ASM} readelf -WS ${TMP_O} >${TMP_X} log_file ${TMP_X} if ! grep -q '\.rodata .* 16$' ${TMP_X}; then die "${AS} ${ASFLAGS} does not support section alignment (nasm <=2.08?)" fi } write_common_config_banner() { print_webm_license config.mk "##" "" echo '# This file automatically generated by configure. Do not edit!' >> config.mk echo "TOOLCHAIN := ${toolchain}" >> config.mk case ${toolchain} in *-linux-rvct) echo "ALT_LIBC := ${alt_libc}" >> config.mk ;; esac } write_common_config_targets() { for t in ${all_targets}; do if enabled ${t}; then if enabled universal || enabled child; then fwrite config.mk "ALL_TARGETS += ${t}-${toolchain}" else fwrite config.mk "ALL_TARGETS += ${t}" fi fi true; done true } write_common_target_config_mk() { local CC=${CC} local CXX=${CXX} enabled ccache && CC="ccache ${CC}" enabled ccache && CXX="ccache ${CXX}" print_webm_license $1 "##" "" cat >> $1 << EOF # This file automatically generated by configure. Do not edit! SRC_PATH="$source_path" SRC_PATH_BARE=$source_path BUILD_PFX=${BUILD_PFX} TOOLCHAIN=${toolchain} ASM_CONVERSION=${asm_conversion_cmd:-${source_path}/build/make/ads2gas.pl} GEN_VCPROJ=${gen_vcproj_cmd} MSVS_ARCH_DIR=${msvs_arch_dir} CC=${CC} CXX=${CXX} AR=${AR} LD=${LD} AS=${AS} STRIP=${STRIP} NM=${NM} CFLAGS = ${CFLAGS} CXXFLAGS = ${CXXFLAGS} ARFLAGS = -rus\$(if \$(quiet),c,v) LDFLAGS = ${LDFLAGS} ASFLAGS = ${ASFLAGS} extralibs = ${extralibs} AS_SFX = ${AS_SFX:-.asm} EXE_SFX = ${EXE_SFX} VCPROJ_SFX = ${VCPROJ_SFX} RTCD_OPTIONS = ${RTCD_OPTIONS} EOF if enabled rvct; then cat >> $1 << EOF fmt_deps = sed -e 's;^__image.axf;\${@:.d=.o} \$@;' #hide EOF else cat >> $1 << EOF fmt_deps = sed -e 's;^\([a-zA-Z0-9_]*\)\.o;\${@:.d=.o} \$@;' EOF fi print_config_mk ARCH "${1}" ${ARCH_LIST} print_config_mk HAVE "${1}" ${HAVE_LIST} print_config_mk CONFIG "${1}" ${CONFIG_LIST} print_config_mk HAVE "${1}" gnu_strip enabled msvs && echo "CONFIG_VS_VERSION=${vs_version}" >> "${1}" } write_common_target_config_h() { print_webm_license ${TMP_H} "/*" " */" cat >> ${TMP_H} << EOF /* This file automatically generated by configure. Do not edit! */ #ifndef VPX_CONFIG_H #define VPX_CONFIG_H #define RESTRICT ${RESTRICT} #define INLINE ${INLINE} EOF print_config_h ARCH "${TMP_H}" ${ARCH_LIST} print_config_h HAVE "${TMP_H}" ${HAVE_LIST} 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_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_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}_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}_feature $option ;; --libc=*) [ -d "${optval}" ] || die "Not a directory: ${optval}" 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}" ;; --libdir=*) libdir="${optval}" ;; --sdk-path=*) [ -d "${optval}" ] || die "Not a directory: ${optval}" sdk_path="${optval}" ;; --libc|--as|--prefix|--libdir|--sdk-path) die "Option ${opt} requires argument" ;; --help|-h) show_help ;; *) die_unknown $opt ;; esac done } process_cmdline() { for opt do optval="${opt#*=}" case "$opt" in *) process_common_cmdline $opt ;; esac done } post_process_common_cmdline() { prefix="${prefix:-/usr/local}" prefix="${prefix%/}" libdir="${libdir:-${prefix}/lib}" libdir="${libdir%/}" if [ "${libdir#${prefix}}" = "${libdir}" ]; then die "Libdir ${libdir} must be a subdirectory of ${prefix}" fi } post_process_cmdline() { true; } setup_gnu_toolchain() { CC=${CC:-${CROSS}gcc} CXX=${CXX:-${CROSS}g++} AR=${AR:-${CROSS}ar} LD=${LD:-${CROSS}${link_with_cc:-ld}} AS=${AS:-${CROSS}as} STRIP=${STRIP:-${CROSS}strip} NM=${NM:-${CROSS}nm} AS_SFX=.s EXE_SFX= } process_common_toolchain() { if [ -z "$toolchain" ]; then gcctarget="${CHOST:-$(gcc -dumpmachine 2> /dev/null)}" # detect tgt_isa case "$gcctarget" in armv6*) tgt_isa=armv6 ;; armv7*-hardfloat*) tgt_isa=armv7 float_abi=hard ;; armv7*) tgt_isa=armv7 float_abi=softfp ;; armv5te*) tgt_isa=armv5te ;; *x86_64*|*amd64*) tgt_isa=x86_64 ;; *i[3456]86*) tgt_isa=x86 ;; *powerpc64*) tgt_isa=ppc64 ;; *powerpc*) tgt_isa=ppc32 ;; *sparc*) tgt_isa=sparc ;; esac # detect tgt_os case "$gcctarget" in *darwin8*) tgt_isa=universal tgt_os=darwin8 ;; *darwin9*) tgt_isa=universal tgt_os=darwin9 ;; *darwin10*) tgt_isa=x86_64 tgt_os=darwin10 ;; *darwin11*) tgt_isa=x86_64 tgt_os=darwin11 ;; *darwin12*) tgt_isa=x86_64 tgt_os=darwin12 ;; *darwin13*) tgt_isa=x86_64 tgt_os=darwin13 ;; x86_64*mingw32*) tgt_os=win64 ;; *mingw32*|*cygwin*) [ -z "$tgt_isa" ] && tgt_isa=x86 tgt_os=win32 ;; *linux*|*bsd*) tgt_os=linux ;; *solaris2.10) tgt_os=solaris ;; *os2*) tgt_os=os2 ;; esac if [ -n "$tgt_isa" ] && [ -n "$tgt_os" ]; then toolchain=${tgt_isa}-${tgt_os}-gcc fi fi toolchain=${toolchain:-generic-gnu} is_in ${toolchain} ${all_platforms} || enabled force_toolchain \ || die "Unrecognized toolchain '${toolchain}'" enabled child || log_echo "Configuring for target '${toolchain}'" # # 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_feature ${tgt_os} enable_feature ${tgt_cc} # Enable the architecture family case ${tgt_isa} in 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 DEVELOPER_DIR=`xcode-select -print-path 2> /dev/null` [ $? -ne 0 ] && OSX_SKIP_DIR_CHECK=1 fi if [ -z "${OSX_SKIP_DIR_CHECK}" ]; then OSX_SDK_ROOTS="${DEVELOPER_DIR}/SDKs" OSX_SDK_VERSIONS="MacOSX10.4u.sdk MacOSX10.5.sdk MacOSX10.6.sdk" OSX_SDK_VERSIONS="${OSX_SDK_VERSIONS} MacOSX10.7.sdk" for v in ${OSX_SDK_VERSIONS}; do if [ -d "${OSX_SDK_ROOTS}/${v}" ]; then osx_sdk_dir="${OSX_SDK_ROOTS}/${v}" fi done fi ;; esac if [ -d "${osx_sdk_dir}" ]; then add_cflags "-isysroot ${osx_sdk_dir}" add_ldflags "-isysroot ${osx_sdk_dir}" fi case ${toolchain} in *-darwin8-*) add_cflags "-mmacosx-version-min=10.4" add_ldflags "-mmacosx-version-min=10.4" ;; *-darwin9-*) add_cflags "-mmacosx-version-min=10.5" add_ldflags "-mmacosx-version-min=10.5" ;; *-darwin10-*) add_cflags "-mmacosx-version-min=10.6" add_ldflags "-mmacosx-version-min=10.6" ;; *-darwin11-*) add_cflags "-mmacosx-version-min=10.7" add_ldflags "-mmacosx-version-min=10.7" ;; *-darwin12-*) add_cflags "-mmacosx-version-min=10.8" add_ldflags "-mmacosx-version-min=10.8" ;; *-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_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_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 [ -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} if enabled neon then check_add_cflags -mfpu=neon #-ftree-vectorize check_add_asflags -mfpu=neon fi if [ -z "${tune_cpu}" ]; then tune_cpu=cortex-a8 fi else check_add_cflags -march=${tgt_isa} check_add_asflags -march=${tgt_isa} fi enabled debug && add_asflags -g asm_conversion_cmd="${source_path}/build/make/ads2gas.pl" 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_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 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_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 LD=${TOOLCHAIN_PATH}gcc AS=${TOOLCHAIN_PATH}as STRIP=${TOOLCHAIN_PATH}strip NM=${TOOLCHAIN_PATH}nm if [ -z "${alt_libc}" ]; then alt_libc=`find "${SDK_PATH}" -name arch-arm -print | \ awk '{n = split($0,a,"/"); \ split(a[n-1],b,"-"); \ print $0 " " b[2]}' | \ sort -g -k 2 | \ 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_feature pic soft_enable realtime_only 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*) XCRUN_FIND="xcrun --sdk iphoneos -find" CXX="$(${XCRUN_FIND} clang++)" CC="$(${XCRUN_FIND} clang)" AR="$(${XCRUN_FIND} ar)" LD="$(${XCRUN_FIND} ld)" AS="$(${XCRUN_FIND} as)" STRIP="$(${XCRUN_FIND} strip)" NM="$(${XCRUN_FIND} nm)" RANLIB="$(${XCRUN_FIND} ranlib)" AS_SFX=.s # ASFLAGS is written here instead of using check_add_asflags # because we need to overwrite all of ASFLAGS and purge the # options that were put in above ASFLAGS="-arch ${tgt_isa} -g" alt_libc="$(xcrun --sdk iphoneos --show-sdk-path)" add_cflags -arch ${tgt_isa} -isysroot ${alt_libc} add_ldflags -arch ${tgt_isa} -ios_version_min 7.0 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_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" # create configuration file (uses path to CodeSourcery GCC) armcc --arm_linux_configure --arm_linux_config_file=arm_linux.cfg add_cflags --arm_linux_paths --arm_linux_config_file=arm_linux.cfg add_asflags --no_hide_all --apcs=/interwork add_ldflags --arm_linux_paths --arm_linux_config_file=arm_linux.cfg enabled pic && add_cflags --apcs=/fpic enabled pic && add_asflags --apcs=/fpic enabled shared && add_cflags --shared fi ;; esac ;; mips*) link_with_cc=gcc setup_gnu_toolchain tune_cflags="-mtune=" if enabled dspr2; then check_add_cflags -mips32r2 -mdspr2 disable_feature fast_unaligned fi check_add_cflags -march=${tgt_isa} check_add_asflags -march=${tgt_isa} check_add_asflags -KPIC ;; 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" ;; darwin*) darwin_arch="-arch ppc" enabled ppc64 && darwin_arch="${darwin_arch}64" add_cflags ${darwin_arch} -m${bits} -fasm-blocks add_asflags ${darwin_arch} -force_cpusubtype_ALL -I"\$(dir \$<)darwin" add_ldflags ${darwin_arch} -m${bits} enabled altivec && add_cflags -faltivec ;; esac ;; x86*) bits=32 enabled x86_64 && bits=64 check_cpp <<EOF && bits=x32 #ifndef __ILP32__ #error "not x32" #endif EOF case ${tgt_os} in win*) enabled gcc && add_cflags -fno-common ;; solaris*) CC=${CC:-${CROSS}gcc} CXX=${CXX:-${CROSS}g++} LD=${LD:-${CROSS}gcc} CROSS=${CROSS:-g} ;; os2) AS=${AS:-nasm} ;; esac AS="${alt_as:-${AS:-auto}}" case ${tgt_cc} in icc*) CC=${CC:-icc} LD=${LD:-icc} setup_gnu_toolchain add_cflags -use-msasm # remove -use-msasm too? # add -no-intel-extensions to suppress warning #10237 # refer to http://software.intel.com/en-us/forums/topic/280199 add_ldflags -i-static -no-intel-extensions enabled x86_64 && add_cflags -ipo -static -O3 -no-prec-div enabled x86_64 && AR=xiar case ${tune_cpu} in atom*) tune_cflags="-x" tune_cpu="SSE3_ATOM" ;; *) tune_cflags="-march=" ;; esac ;; gcc*) add_cflags -m${bits} add_ldflags -m${bits} link_with_cc=gcc tune_cflags="-march=" setup_gnu_toolchain #for 32 bit x86 builds, -O3 did not turn on this flag enabled optimizations && disabled gprof && check_add_cflags -fomit-frame-pointer ;; vs*) # When building with Microsoft Visual Studio the assembler is # invoked directly. Checking at configure time is unnecessary. # Skip the check by setting AS arbitrarily AS=msvs msvs_arch_dir=x86-msvs vc_version=${tgt_cc##vs} case $vc_version in 7|8|9|10) echo "${tgt_cc} does not support avx/avx2, disabling....." RTCD_OPTIONS="${RTCD_OPTIONS}--disable-avx --disable-avx2 " soft_disable avx soft_disable avx2 ;; esac ;; esac soft_enable runtime_cpu_detect soft_enable mmx soft_enable sse soft_enable sse2 soft_enable sse3 soft_enable ssse3 # We can't use 'check_cflags' until the compiler is configured and CC is # populated. if enabled gcc && ! disabled sse4_1 && ! check_cflags -msse4; then RTCD_OPTIONS="${RTCD_OPTIONS}--disable-sse4_1 " else soft_enable sse4_1 fi if enabled gcc && ! disabled avx && ! check_cflags -mavx; then RTCD_OPTIONS="${RTCD_OPTIONS}--disable-avx " else soft_enable avx fi if enabled gcc && ! disabled avx2 && ! check_cflags -mavx2; then RTCD_OPTIONS="${RTCD_OPTIONS}--disable-avx2 " else soft_enable avx2 fi case "${AS}" in auto|"") which nasm >/dev/null 2>&1 && AS=nasm which yasm >/dev/null 2>&1 && AS=yasm [ "${AS}" = auto -o -z "${AS}" ] \ && die "Neither yasm nor nasm have been found" ;; esac log_echo " using $AS" [ "${AS##*/}" = nasm ] && add_asflags -Ox AS_SFX=.asm case ${tgt_os} in win32) add_asflags -f win32 enabled debug && add_asflags -g cv8 EXE_SFX=.exe ;; win64) add_asflags -f x64 enabled debug && add_asflags -g cv8 EXE_SFX=.exe ;; linux*|solaris*|android*) add_asflags -f elf${bits} enabled debug && [ "${AS}" = yasm ] && add_asflags -g dwarf2 enabled debug && [ "${AS}" = nasm ] && add_asflags -g [ "${AS##*/}" = nasm ] && check_asm_align ;; darwin*) add_asflags -f macho${bits} enabled x86 && darwin_arch="-arch i386" || darwin_arch="-arch x86_64" add_cflags ${darwin_arch} add_ldflags ${darwin_arch} # -mdynamic-no-pic is still a bit of voodoo -- it was required at # one time, but does not seem to be now, and it breaks some of the # code that still relies on inline assembly. # enabled icc && ! enabled pic && add_cflags -fno-pic -mdynamic-no-pic enabled icc && ! enabled pic && add_cflags -fno-pic ;; os2) 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_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 if [ -n "${tune_asflags}" ]; then check_add_asflags ${tune_asflags}${tune_cpu} || \ die "Requested CPU '${tune_cpu}' not supported by assembler" fi if [ -z "${tune_cflags}${tune_asflags}" ]; then log_echo "Warning: CPU tuning not supported by this toolchain" fi fi enabled debug && check_add_cflags -g && check_add_ldflags -g enabled gprof && check_add_cflags -pg && check_add_ldflags -pg enabled gcov && check_add_cflags -fprofile-arcs -ftest-coverage && 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_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_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_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 # append any user defined extra cflags if [ -n "${extra_cflags}" ] ; then check_add_cflags ${extra_cflags} || \ die "Requested extra CFLAGS '${extra_cflags}' not supported by compiler" fi } process_toolchain() { process_common_toolchain } print_config_mk() { local prefix=$1 local makefile=$2 shift 2 for cfg; do upname="`toupper $cfg`" if enabled $cfg; then echo "${prefix}_${upname}=yes" >> $makefile fi done } print_config_h() { local prefix=$1 local header=$2 shift 2 for cfg; do upname="`toupper $cfg`" 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" 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_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 }