src/third_party/libvpx/source/libvpx/build/make/configure.sh

   1 #!/bin/sh
   2 ##
   3 ##  configure.sh
   4 ##
   5 ##  This script is sourced by the main configure script and contains
   6 ##  utility functions and other common bits that aren't strictly libvpx
   7 ##  related.
   8 ##
   9 ##  This build system is based in part on the FFmpeg configure script.
  10 ##
  11
  12
  13 #
  14 # Logging / Output Functions
  15 #
  16 die_unknown(){
  17     echo "Unknown option \"$1\"."
  18     echo "See $0 --help for available options."
  19     clean_temp_files
  20     exit 1
  21 }
  22
  23
  24 die() {
  25     echo "$@"
  26     echo
  27     echo "Configuration failed. This could reflect a misconfiguration of your"
  28     echo "toolchains, improper options selected, or another problem. If you"
  29     echo "don't see any useful error messages above, the next step is to look"
  30     echo "at the configure error log file ($logfile) to determine what"
  31     echo "configure was trying to do when it died."
  32     clean_temp_files
  33     exit 1
  34 }
  35
  36
  37 log(){
  38     echo "$@" >>$logfile
  39 }
  40
  41
  42 log_file(){
  43     log BEGIN $1
  44     pr -n -t $1 >>$logfile
  45     log END $1
  46 }
  47
  48
  49 log_echo() {
  50     echo "$@"
  51     log "$@"
  52 }
  53
  54
  55 fwrite () {
  56     outfile=$1
  57     shift
  58     echo "$@" >> ${outfile}
  59 }
  60
  61
  62 show_help_pre(){
  63     for opt in ${CMDLINE_SELECT}; do
  64         opt2=`echo $opt | sed -e 's;_;-;g'`
  65         if enabled $opt; then
  66             eval "toggle_${opt}=\"--disable-${opt2}\""
  67         else
  68             eval "toggle_${opt}=\"--enable-${opt2} \""
  69         fi
  70     done
  71
  72     cat <<EOF
  73 Usage: configure [options]
  74 Options:
  75
  76 Build options:
  77   --help                      print this message
  78   --log=yes|no|FILE           file configure log is written to [config.log]
  79   --target=TARGET             target platform tuple [generic-gnu]
  80   --cpu=CPU                   optimize for a specific cpu rather than a family
  81   --extra-cflags=ECFLAGS      add ECFLAGS to CFLAGS [$CFLAGS]
  82   ${toggle_extra_warnings}    emit harmless warnings (always non-fatal)
  83   ${toggle_werror}            treat warnings as errors, if possible
  84                               (not available with all compilers)
  85   ${toggle_optimizations}     turn on/off compiler optimization flags
  86   ${toggle_pic}               turn on/off Position Independent Code
  87   ${toggle_ccache}            turn on/off compiler cache
  88   ${toggle_debug}             enable/disable debug mode
  89   ${toggle_gprof}             enable/disable gprof profiling instrumentation
  90   ${toggle_gcov}              enable/disable gcov coverage instrumentation
  91   ${toggle_thumb}             enable/disable building arm assembly in thumb mode
  92
  93 Install options:
  94   ${toggle_install_docs}      control whether docs are installed
  95   ${toggle_install_bins}      control whether binaries are installed
  96   ${toggle_install_libs}      control whether libraries are installed
  97   ${toggle_install_srcs}      control whether sources are installed
  98
  99
 100 EOF
 101 }
 102
 103
 104 show_help_post(){
 105     cat <<EOF
 106
 107
 108 NOTES:
 109     Object files are built at the place where configure is launched.
 110
 111     All boolean options can be negated. The default value is the opposite
 112     of that shown above. If the option --disable-foo is listed, then
 113     the default value for foo is enabled.
 114
 115 Supported targets:
 116 EOF
 117   show_targets ${all_platforms}
 118   echo
 119   exit 1
 120 }
 121
 122
 123 show_targets() {
 124     while [ -n "$*" ]; do
 125         if [ "${1%%-*}" = "${2%%-*}" ]; then
 126             if [ "${2%%-*}" = "${3%%-*}" ]; then
 127                 printf "    %-24s %-24s %-24s\n" "$1" "$2" "$3"
 128                 shift; shift; shift
 129             else
 130                 printf "    %-24s %-24s\n" "$1" "$2"
 131                 shift; shift
 132             fi
 133         else
 134             printf "    %-24s\n" "$1"
 135             shift
 136         fi
 137     done
 138 }
 139
 140
 141 show_help() {
 142     show_help_pre
 143     show_help_post
 144 }
 145
 146 #
 147 # List Processing Functions
 148 #
 149 set_all(){
 150     value=$1
 151     shift
 152     for var in $*; do
 153         eval $var=$value
 154     done
 155 }
 156
 157
 158 is_in(){
 159     value=$1
 160     shift
 161     for var in $*; do
 162         [ $var = $value ] && return 0
 163     done
 164     return 1
 165 }
 166
 167
 168 add_cflags() {
 169     CFLAGS="${CFLAGS} $@"
 170     CXXFLAGS="${CXXFLAGS} $@"
 171 }
 172
 173
 174 add_cflags_only() {
 175     CFLAGS="${CFLAGS} $@"
 176 }
 177
 178
 179 add_cxxflags_only() {
 180     CXXFLAGS="${CXXFLAGS} $@"
 181 }
 182
 183
 184 add_ldflags() {
 185     LDFLAGS="${LDFLAGS} $@"
 186 }
 187
 188
 189 add_asflags() {
 190     ASFLAGS="${ASFLAGS} $@"
 191 }
 192
 193
 194 add_extralibs() {
 195     extralibs="${extralibs} $@"
 196 }
 197
 198 #
 199 # Boolean Manipulation Functions
 200 #
 201 enable_feature(){
 202     set_all yes $*
 203 }
 204
 205 disable_feature(){
 206     set_all no $*
 207 }
 208
 209 enabled(){
 210     eval test "x\$$1" = "xyes"
 211 }
 212
 213 disabled(){
 214     eval test "x\$$1" = "xno"
 215 }
 216
 217
 218 soft_enable() {
 219     for var in $*; do
 220         if ! disabled $var; then
 221             log_echo "  enabling $var"
 222             enable_feature $var
 223         fi
 224     done
 225 }
 226
 227 soft_disable() {
 228     for var in $*; do
 229         if ! enabled $var; then
 230             log_echo "  disabling $var"
 231             disable_feature $var
 232         fi
 233     done
 234 }
 235
 236
 237 #
 238 # Text Processing Functions
 239 #
 240 toupper(){
 241     echo "$@" | tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ
 242 }
 243
 244
 245 tolower(){
 246     echo "$@" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz
 247 }
 248
 249
 250 #
 251 # Temporary File Functions
 252 #
 253 source_path=${0%/*}
 254 enable_feature source_path_used
 255 if test -z "$source_path" -o "$source_path" = "." ; then
 256     source_path="`pwd`"
 257     disable_feature source_path_used
 258 fi
 259
 260 if test ! -z "$TMPDIR" ; then
 261     TMPDIRx="${TMPDIR}"
 262 elif test ! -z "$TEMPDIR" ; then
 263     TMPDIRx="${TEMPDIR}"
 264 else
 265     TMPDIRx="/tmp"
 266 fi
 267 RAND=$(awk 'BEGIN { srand(); printf "%d\n",(rand() * 32768)}')
 268 TMP_H="${TMPDIRx}/vpx-conf-$$-${RAND}.h"
 269 TMP_C="${TMPDIRx}/vpx-conf-$$-${RAND}.c"
 270 TMP_CC="${TMPDIRx}/vpx-conf-$$-${RAND}.cc"
 271 TMP_O="${TMPDIRx}/vpx-conf-$$-${RAND}.o"
 272 TMP_X="${TMPDIRx}/vpx-conf-$$-${RAND}.x"
 273 TMP_ASM="${TMPDIRx}/vpx-conf-$$-${RAND}.asm"
 274
 275 clean_temp_files() {
 276     rm -f ${TMP_C} ${TMP_CC} ${TMP_H} ${TMP_O} ${TMP_X} ${TMP_ASM}
 277 }
 278
 279 #
 280 # Toolchain Check Functions
 281 #
 282 check_cmd() {
 283     enabled external_build && return
 284     log "$@"
 285     "$@" >>${logfile} 2>&1
 286 }
 287
 288 check_cc() {
 289     log check_cc "$@"
 290     cat >${TMP_C}
 291     log_file ${TMP_C}
 292     check_cmd ${CC} ${CFLAGS} "$@" -c -o ${TMP_O} ${TMP_C}
 293 }
 294
 295 check_cxx() {
 296     log check_cxx "$@"
 297     cat >${TMP_CC}
 298     log_file ${TMP_CC}
 299     check_cmd ${CXX} ${CXXFLAGS} "$@" -c -o ${TMP_O} ${TMP_CC}
 300 }
 301
 302 check_cpp() {
 303     log check_cpp "$@"
 304     cat > ${TMP_C}
 305     log_file ${TMP_C}
 306     check_cmd ${CC} ${CFLAGS} "$@" -E -o ${TMP_O} ${TMP_C}
 307 }
 308
 309 check_ld() {
 310     log check_ld "$@"
 311     check_cc $@ \
 312         && check_cmd ${LD} ${LDFLAGS} "$@" -o ${TMP_X} ${TMP_O} ${extralibs}
 313 }
 314
 315 check_header(){
 316     log check_header "$@"
 317     header=$1
 318     shift
 319     var=`echo $header | sed 's/[^A-Za-z0-9_]/_/g'`
 320     disable_feature $var
 321     check_cpp "$@" <<EOF && enable_feature $var
 322 #include "$header"
 323 int x;
 324 EOF
 325 }
 326
 327
 328 check_cflags() {
 329     log check_cflags "$@"
 330     check_cc "$@" <<EOF
 331 int x;
 332 EOF
 333 }
 334
 335 check_cxxflags() {
 336     log check_cxxflags "$@"
 337
 338     # Catch CFLAGS that trigger CXX warnings
 339     case "$CXX" in
 340       *c++-analyzer|*clang++|*g++*) check_cxx -Werror "$@" <<EOF
 341 int x;
 342 EOF
 343       ;;
 344       *) check_cxx "$@" <<EOF
 345 int x;
 346 EOF
 347       ;;
 348     esac
 349 }
 350
 351 check_add_cflags() {
 352     check_cxxflags "$@" && add_cxxflags_only "$@"
 353     check_cflags "$@" && add_cflags_only "$@"
 354 }
 355
 356 check_add_asflags() {
 357     log add_asflags "$@"
 358     add_asflags "$@"
 359 }
 360
 361 check_add_ldflags() {
 362     log add_ldflags "$@"
 363     add_ldflags "$@"
 364 }
 365
 366 check_asm_align() {
 367     log check_asm_align "$@"
 368     cat >${TMP_ASM} <<EOF
 369 section .rodata
 370 align 16
 371 EOF
 372     log_file ${TMP_ASM}
 373     check_cmd ${AS} ${ASFLAGS} -o ${TMP_O} ${TMP_ASM}
 374     readelf -WS ${TMP_O} >${TMP_X}
 375     log_file ${TMP_X}
 376     if ! grep -q '\.rodata .* 16$' ${TMP_X}; then
 377         die "${AS} ${ASFLAGS} does not support section alignment (nasm <=2.08?)"
 378     fi
 379 }
 380
 381 write_common_config_banner() {
 382     print_webm_license config.mk "##" ""
 383     echo '# This file automatically generated by configure. Do not edit!' >> config.mk
 384     echo "TOOLCHAIN := ${toolchain}" >> config.mk
 385
 386     case ${toolchain} in
 387         *-linux-rvct)
 388             echo "ALT_LIBC := ${alt_libc}" >> config.mk
 389             ;;
 390     esac
 391 }
 392
 393 write_common_config_targets() {
 394     for t in ${all_targets}; do
 395         if enabled ${t}; then
 396             if enabled universal || enabled child; then
 397                 fwrite config.mk "ALL_TARGETS += ${t}-${toolchain}"
 398             else
 399                 fwrite config.mk "ALL_TARGETS += ${t}"
 400             fi
 401         fi
 402     true;
 403     done
 404 true
 405 }
 406
 407 write_common_target_config_mk() {
 408     local CC=${CC}
 409     local CXX=${CXX}
 410     enabled ccache && CC="ccache ${CC}"
 411     enabled ccache && CXX="ccache ${CXX}"
 412     print_webm_license $1 "##" ""
 413
 414     cat >> $1 << EOF
 415 # This file automatically generated by configure. Do not edit!
 416 SRC_PATH="$source_path"
 417 SRC_PATH_BARE=$source_path
 418 BUILD_PFX=${BUILD_PFX}
 419 TOOLCHAIN=${toolchain}
 420 ASM_CONVERSION=${asm_conversion_cmd:-${source_path}/build/make/ads2gas.pl}
 421 GEN_VCPROJ=${gen_vcproj_cmd}
 422 MSVS_ARCH_DIR=${msvs_arch_dir}
 423
 424 CC=${CC}
 425 CXX=${CXX}
 426 AR=${AR}
 427 LD=${LD}
 428 AS=${AS}
 429 STRIP=${STRIP}
 430 NM=${NM}
 431
 432 CFLAGS  = ${CFLAGS}
 433 CXXFLAGS  = ${CXXFLAGS}
 434 ARFLAGS = -rus\$(if \$(quiet),c,v)
 435 LDFLAGS = ${LDFLAGS}
 436 ASFLAGS = ${ASFLAGS}
 437 extralibs = ${extralibs}
 438 AS_SFX    = ${AS_SFX:-.asm}
 439 EXE_SFX   = ${EXE_SFX}
 440 VCPROJ_SFX = ${VCPROJ_SFX}
 441 RTCD_OPTIONS = ${RTCD_OPTIONS}
 442 EOF
 443
 444     if enabled rvct; then cat >> $1 << EOF
 445 fmt_deps = sed -e 's;^__image.axf;\${@:.d=.o} \$@;' #hide
 446 EOF
 447     else cat >> $1 << EOF
 448 fmt_deps = sed -e 's;^\([a-zA-Z0-9_]*\)\.o;\${@:.d=.o} \$@;'
 449 EOF
 450     fi
 451
 452     print_config_mk ARCH   "${1}" ${ARCH_LIST}
 453     print_config_mk HAVE   "${1}" ${HAVE_LIST}
 454     print_config_mk CONFIG "${1}" ${CONFIG_LIST}
 455     print_config_mk HAVE   "${1}" gnu_strip
 456
 457     enabled msvs && echo "CONFIG_VS_VERSION=${vs_version}" >> "${1}"
 458
 459 }
 460
 461
 462 write_common_target_config_h() {
 463     print_webm_license ${TMP_H} "/*" " */"
 464     cat >> ${TMP_H} << EOF
 465 /* This file automatically generated by configure. Do not edit! */
 466 #ifndef VPX_CONFIG_H
 467 #define VPX_CONFIG_H
 468 #define RESTRICT    ${RESTRICT}
 469 #define INLINE      ${INLINE}
 470 EOF
 471     print_config_h ARCH   "${TMP_H}" ${ARCH_LIST}
 472     print_config_h HAVE   "${TMP_H}" ${HAVE_LIST}
 473     print_config_h CONFIG "${TMP_H}" ${CONFIG_LIST}
 474     echo "#endif /* VPX_CONFIG_H */" >> ${TMP_H}
 475     mkdir -p `dirname "$1"`
 476     cmp "$1" ${TMP_H} >/dev/null 2>&1 || mv ${TMP_H} "$1"
 477 }
 478
 479 process_common_cmdline() {
 480     for opt in "$@"; do
 481         optval="${opt#*=}"
 482         case "$opt" in
 483         --child) enable_feature child
 484         ;;
 485         --log*)
 486         logging="$optval"
 487         if ! disabled logging ; then
 488             enabled logging || logfile="$logging"
 489         else
 490             logfile=/dev/null
 491         fi
 492         ;;
 493         --target=*) toolchain="${toolchain:-${optval}}"
 494         ;;
 495         --force-target=*) toolchain="${toolchain:-${optval}}"; enable_feature force_toolchain
 496         ;;
 497         --cpu)
 498         ;;
 499         --cpu=*) tune_cpu="$optval"
 500         ;;
 501         --extra-cflags=*)
 502         extra_cflags="${optval}"
 503         ;;
 504         --enable-?*|--disable-?*)
 505         eval `echo "$opt" | sed 's/--/action=/;s/-/ option=/;s/-/_/g'`
 506         if echo "${ARCH_EXT_LIST}" | grep "^ *$option\$" >/dev/null; then
 507             [ $action = "disable" ] && RTCD_OPTIONS="${RTCD_OPTIONS}${opt} "
 508         elif [ $action = "disable" ] && ! disabled $option ; then
 509           echo "${CMDLINE_SELECT}" | grep "^ *$option\$" >/dev/null ||
 510             die_unknown $opt
 511         elif [ $action = "enable" ] && ! enabled $option ; then
 512           echo "${CMDLINE_SELECT}" | grep "^ *$option\$" >/dev/null ||
 513             die_unknown $opt
 514         fi
 515         ${action}_feature $option
 516         ;;
 517         --require-?*)
 518         eval `echo "$opt" | sed 's/--/action=/;s/-/ option=/;s/-/_/g'`
 519         if echo "${ARCH_EXT_LIST}" none | grep "^ *$option\$" >/dev/null; then
 520             RTCD_OPTIONS="${RTCD_OPTIONS}${opt} "
 521         else
 522             die_unknown $opt
 523         fi
 524         ;;
 525         --force-enable-?*|--force-disable-?*)
 526         eval `echo "$opt" | sed 's/--force-/action=/;s/-/ option=/;s/-/_/g'`
 527         ${action}_feature $option
 528         ;;
 529         --libc=*)
 530         [ -d "${optval}" ] || die "Not a directory: ${optval}"
 531         disable_feature builtin_libc
 532         alt_libc="${optval}"
 533         ;;
 534         --as=*)
 535         [ "${optval}" = yasm -o "${optval}" = nasm -o "${optval}" = auto ] \
 536             || die "Must be yasm, nasm or auto: ${optval}"
 537         alt_as="${optval}"
 538         ;;
 539         --prefix=*)
 540         prefix="${optval}"
 541         ;;
 542         --libdir=*)
 543         libdir="${optval}"
 544         ;;
 545         --sdk-path=*)
 546         [ -d "${optval}" ] || die "Not a directory: ${optval}"
 547         sdk_path="${optval}"
 548         ;;
 549         --libc|--as|--prefix|--libdir|--sdk-path)
 550         die "Option ${opt} requires argument"
 551         ;;
 552         --help|-h) show_help
 553         ;;
 554         *) die_unknown $opt
 555         ;;
 556         esac
 557     done
 558 }
 559
 560 process_cmdline() {
 561     for opt do
 562         optval="${opt#*=}"
 563         case "$opt" in
 564         *) process_common_cmdline $opt
 565         ;;
 566         esac
 567     done
 568 }
 569
 570
 571 post_process_common_cmdline() {
 572     prefix="${prefix:-/usr/local}"
 573     prefix="${prefix%/}"
 574     libdir="${libdir:-${prefix}/lib}"
 575     libdir="${libdir%/}"
 576     if [ "${libdir#${prefix}}" = "${libdir}" ]; then
 577         die "Libdir ${libdir} must be a subdirectory of ${prefix}"
 578     fi
 579 }
 580
 581
 582 post_process_cmdline() {
 583     true;
 584 }
 585
 586 setup_gnu_toolchain() {
 587         CC=${CC:-${CROSS}gcc}
 588         CXX=${CXX:-${CROSS}g++}
 589         AR=${AR:-${CROSS}ar}
 590         LD=${LD:-${CROSS}${link_with_cc:-ld}}
 591         AS=${AS:-${CROSS}as}
 592     STRIP=${STRIP:-${CROSS}strip}
 593     NM=${NM:-${CROSS}nm}
 594         AS_SFX=.s
 595         EXE_SFX=
 596 }
 597
 598 process_common_toolchain() {
 599     if [ -z "$toolchain" ]; then
 600         gcctarget="${CHOST:-$(gcc -dumpmachine 2> /dev/null)}"
 601
 602         # detect tgt_isa
 603         case "$gcctarget" in
 604             armv6*)
 605                 tgt_isa=armv6
 606                 ;;
 607             armv7*-hardfloat*)
 608                 tgt_isa=armv7
 609                 float_abi=hard
 610                 ;;
 611             armv7*)
 612                 tgt_isa=armv7
 613                 float_abi=softfp
 614                 ;;
 615             armv5te*)
 616                 tgt_isa=armv5te
 617                 ;;
 618             *x86_64*|*amd64*)
 619                 tgt_isa=x86_64
 620                 ;;
 621             *i[3456]86*)
 622                 tgt_isa=x86
 623                 ;;
 624             *powerpc64*)
 625                 tgt_isa=ppc64
 626                 ;;
 627             *powerpc*)
 628                 tgt_isa=ppc32
 629                 ;;
 630             *sparc*)
 631                 tgt_isa=sparc
 632                 ;;
 633         esac
 634
 635         # detect tgt_os
 636         case "$gcctarget" in
 637             *darwin8*)
 638                 tgt_isa=universal
 639                 tgt_os=darwin8
 640                 ;;
 641             *darwin9*)
 642                 tgt_isa=universal
 643                 tgt_os=darwin9
 644                 ;;
 645             *darwin10*)
 646                 tgt_isa=x86_64
 647                 tgt_os=darwin10
 648                 ;;
 649             *darwin11*)
 650                 tgt_isa=x86_64
 651                 tgt_os=darwin11
 652                 ;;
 653             *darwin12*)
 654                 tgt_isa=x86_64
 655                 tgt_os=darwin12
 656                 ;;
 657             *darwin13*)
 658                 tgt_isa=x86_64
 659                 tgt_os=darwin13
 660                 ;;
 661             x86_64*mingw32*)
 662                 tgt_os=win64
 663                 ;;
 664             *mingw32*|*cygwin*)
 665                 [ -z "$tgt_isa" ] && tgt_isa=x86
 666                 tgt_os=win32
 667                 ;;
 668             *linux*|*bsd*)
 669                 tgt_os=linux
 670                 ;;
 671             *solaris2.10)
 672                 tgt_os=solaris
 673                 ;;
 674             *os2*)
 675                 tgt_os=os2
 676                 ;;
 677         esac
 678
 679         if [ -n "$tgt_isa" ] && [ -n "$tgt_os" ]; then
 680             toolchain=${tgt_isa}-${tgt_os}-gcc
 681         fi
 682     fi
 683
 684     toolchain=${toolchain:-generic-gnu}
 685
 686     is_in ${toolchain} ${all_platforms} || enabled force_toolchain \
 687         || die "Unrecognized toolchain '${toolchain}'"
 688
 689     enabled child || log_echo "Configuring for target '${toolchain}'"
 690
 691     #
 692     # Set up toolchain variables
 693     #
 694     tgt_isa=$(echo ${toolchain} | awk 'BEGIN{FS="-"}{print $1}')
 695     tgt_os=$(echo ${toolchain} | awk 'BEGIN{FS="-"}{print $2}')
 696     tgt_cc=$(echo ${toolchain} | awk 'BEGIN{FS="-"}{print $3}')
 697
 698     # Mark the specific ISA requested as enabled
 699     soft_enable ${tgt_isa}
 700     enable_feature ${tgt_os}
 701     enable_feature ${tgt_cc}
 702
 703     # Enable the architecture family
 704     case ${tgt_isa} in
 705         arm*) enable_feature arm;;
 706         mips*) enable_feature mips;;
 707     esac
 708
 709     # PIC is probably what we want when building shared libs
 710     enabled shared && soft_enable pic
 711
 712     # Handle darwin variants. Newer SDKs allow targeting older
 713     # platforms, so find the newest SDK available.
 714     case ${toolchain} in
 715         *-darwin*)
 716             if [ -z "${DEVELOPER_DIR}" ]; then
 717                 DEVELOPER_DIR=`xcode-select -print-path 2> /dev/null`
 718                 [ $? -ne 0 ] && OSX_SKIP_DIR_CHECK=1
 719             fi
 720             if [ -z "${OSX_SKIP_DIR_CHECK}" ]; then
 721                 OSX_SDK_ROOTS="${DEVELOPER_DIR}/SDKs"
 722                 OSX_SDK_VERSIONS="MacOSX10.4u.sdk MacOSX10.5.sdk MacOSX10.6.sdk"
 723                 OSX_SDK_VERSIONS="${OSX_SDK_VERSIONS} MacOSX10.7.sdk"
 724                 for v in ${OSX_SDK_VERSIONS}; do
 725                     if [ -d "${OSX_SDK_ROOTS}/${v}" ]; then
 726                         osx_sdk_dir="${OSX_SDK_ROOTS}/${v}"
 727                     fi
 728                 done
 729             fi
 730             ;;
 731     esac
 732
 733     if [ -d "${osx_sdk_dir}" ]; then
 734         add_cflags  "-isysroot ${osx_sdk_dir}"
 735         add_ldflags "-isysroot ${osx_sdk_dir}"
 736     fi
 737
 738     case ${toolchain} in
 739         *-darwin8-*)
 740             add_cflags  "-mmacosx-version-min=10.4"
 741             add_ldflags "-mmacosx-version-min=10.4"
 742             ;;
 743         *-darwin9-*)
 744             add_cflags  "-mmacosx-version-min=10.5"
 745             add_ldflags "-mmacosx-version-min=10.5"
 746             ;;
 747         *-darwin10-*)
 748             add_cflags  "-mmacosx-version-min=10.6"
 749             add_ldflags "-mmacosx-version-min=10.6"
 750             ;;
 751         *-darwin11-*)
 752             add_cflags  "-mmacosx-version-min=10.7"
 753             add_ldflags "-mmacosx-version-min=10.7"
 754             ;;
 755         *-darwin12-*)
 756             add_cflags  "-mmacosx-version-min=10.8"
 757             add_ldflags "-mmacosx-version-min=10.8"
 758             ;;
 759         *-darwin13-*)
 760             add_cflags  "-mmacosx-version-min=10.9"
 761             add_ldflags "-mmacosx-version-min=10.9"
 762             ;;
 763     esac
 764
 765     # Handle Solaris variants. Solaris 10 needs -lposix4
 766     case ${toolchain} in
 767         sparc-solaris-*)
 768             add_extralibs -lposix4
 769             disable_feature fast_unaligned
 770             ;;
 771         *-solaris-*)
 772             add_extralibs -lposix4
 773             ;;
 774     esac
 775
 776     # Process ARM architecture variants
 777     case ${toolchain} in
 778     arm*)
 779         # on arm, isa versions are supersets
 780         case ${tgt_isa} in
 781         armv7)
 782             soft_enable neon
 783             soft_enable media
 784             soft_enable edsp
 785             soft_enable fast_unaligned
 786             ;;
 787         armv6)
 788             soft_enable media
 789             soft_enable edsp
 790             soft_enable fast_unaligned
 791             ;;
 792         armv5te)
 793             soft_enable edsp
 794             disable_feature fast_unaligned
 795             ;;
 796         esac
 797
 798         asm_conversion_cmd="cat"
 799
 800         case ${tgt_cc} in
 801         gcc)
 802             CROSS=${CROSS:-arm-none-linux-gnueabi-}
 803             link_with_cc=gcc
 804             setup_gnu_toolchain
 805             arch_int=${tgt_isa##armv}
 806             arch_int=${arch_int%%te}
 807             check_add_asflags --defsym ARCHITECTURE=${arch_int}
 808             tune_cflags="-mtune="
 809             if [ ${tgt_isa} = "armv7" ]; then
 810                 if [ -z "${float_abi}" ]; then
 811                     check_cpp <<EOF && float_abi=hard || float_abi=softfp
 812 #ifndef __ARM_PCS_VFP
 813 #error "not hardfp"
 814 #endif
 815 EOF
 816                 fi
 817                 check_add_cflags  -march=armv7-a -mfloat-abi=${float_abi}
 818                 check_add_asflags -march=armv7-a -mfloat-abi=${float_abi}
 819
 820                 if enabled neon
 821                 then
 822                     check_add_cflags -mfpu=neon #-ftree-vectorize
 823                     check_add_asflags -mfpu=neon
 824                 fi
 825
 826                 if [ -z "${tune_cpu}" ]; then
 827                     tune_cpu=cortex-a8
 828                 fi
 829             else
 830                 check_add_cflags -march=${tgt_isa}
 831                 check_add_asflags -march=${tgt_isa}
 832             fi
 833
 834             enabled debug && add_asflags -g
 835             asm_conversion_cmd="${source_path}/build/make/ads2gas.pl"
 836             if enabled thumb; then
 837                 asm_conversion_cmd="$asm_conversion_cmd -thumb"
 838                 check_add_cflags -mthumb
 839                 check_add_asflags -mthumb -mimplicit-it=always
 840             fi
 841             ;;
 842         vs*)
 843             asm_conversion_cmd="${source_path}/build/make/ads2armasm_ms.pl"
 844             AS_SFX=.s
 845             msvs_arch_dir=arm-msvs
 846             disable_feature multithread
 847             disable_feature unit_tests
 848             ;;
 849         rvct)
 850             CC=armcc
 851             AR=armar
 852             AS=armasm
 853             LD=${source_path}/build/make/armlink_adapter.sh
 854             STRIP=arm-none-linux-gnueabi-strip
 855             NM=arm-none-linux-gnueabi-nm
 856             tune_cflags="--cpu="
 857             tune_asflags="--cpu="
 858             if [ -z "${tune_cpu}" ]; then
 859                 if [ ${tgt_isa} = "armv7" ]; then
 860                     if enabled neon
 861                     then
 862                         check_add_cflags --fpu=softvfp+vfpv3
 863                         check_add_asflags --fpu=softvfp+vfpv3
 864                     fi
 865                     check_add_cflags --cpu=Cortex-A8
 866                     check_add_asflags --cpu=Cortex-A8
 867                 else
 868                     check_add_cflags --cpu=${tgt_isa##armv}
 869                     check_add_asflags --cpu=${tgt_isa##armv}
 870                 fi
 871             fi
 872             arch_int=${tgt_isa##armv}
 873             arch_int=${arch_int%%te}
 874             check_add_asflags --pd "\"ARCHITECTURE SETA ${arch_int}\""
 875             enabled debug && add_asflags -g
 876             add_cflags --gnu
 877             add_cflags --enum_is_int
 878             add_cflags --wchar32
 879         ;;
 880         esac
 881
 882         case ${tgt_os} in
 883         none*)
 884             disable_feature multithread
 885             disable_feature os_support
 886             ;;
 887
 888         android*)
 889             SDK_PATH=${sdk_path}
 890             COMPILER_LOCATION=`find "${SDK_PATH}" \
 891                                -name "arm-linux-androideabi-gcc*" -print -quit`
 892             TOOLCHAIN_PATH=${COMPILER_LOCATION%/*}/arm-linux-androideabi-
 893             CC=${TOOLCHAIN_PATH}gcc
 894             CXX=${TOOLCHAIN_PATH}g++
 895             AR=${TOOLCHAIN_PATH}ar
 896             LD=${TOOLCHAIN_PATH}gcc
 897             AS=${TOOLCHAIN_PATH}as
 898             STRIP=${TOOLCHAIN_PATH}strip
 899             NM=${TOOLCHAIN_PATH}nm
 900
 901             if [ -z "${alt_libc}" ]; then
 902                 alt_libc=`find "${SDK_PATH}" -name arch-arm -print | \
 903                           awk '{n = split($0,a,"/"); \
 904                                 split(a[n-1],b,"-"); \
 905                                 print $0 " " b[2]}' | \
 906                           sort -g -k 2 | \
 907                           awk '{ print $1 }' | tail -1`
 908             fi
 909
 910             add_cflags "--sysroot=${alt_libc}"
 911             add_ldflags "--sysroot=${alt_libc}"
 912
 913             # linker flag that routes around a CPU bug in some
 914             # Cortex-A8 implementations (NDK Dev Guide)
 915             add_ldflags "-Wl,--fix-cortex-a8"
 916
 917             enable_feature pic
 918             soft_enable realtime_only
 919             if [ ${tgt_isa} = "armv7" ]; then
 920                 soft_enable runtime_cpu_detect
 921             fi
 922             if enabled runtime_cpu_detect; then
 923                 add_cflags "-I${SDK_PATH}/sources/android/cpufeatures"
 924             fi
 925           ;;
 926
 927         darwin*)
 928
 929             XCRUN_FIND="xcrun --sdk iphoneos -find"
 930             CXX="$(${XCRUN_FIND} clang++)"
 931             CC="$(${XCRUN_FIND} clang)"
 932             AR="$(${XCRUN_FIND} ar)"
 933             LD="$(${XCRUN_FIND} ld)"
 934             AS="$(${XCRUN_FIND} as)"
 935             STRIP="$(${XCRUN_FIND} strip)"
 936             NM="$(${XCRUN_FIND} nm)"
 937             RANLIB="$(${XCRUN_FIND} ranlib)"
 938             AS_SFX=.s
 939
 940             # ASFLAGS is written here instead of using check_add_asflags
 941             # because we need to overwrite all of ASFLAGS and purge the
 942             # options that were put in above
 943             ASFLAGS="-arch ${tgt_isa} -g"
 944
 945             alt_libc="$(xcrun --sdk iphoneos --show-sdk-path)"
 946             add_cflags -arch ${tgt_isa} -isysroot ${alt_libc}
 947             add_ldflags -arch ${tgt_isa} -ios_version_min 7.0
 948
 949             for d in lib usr/lib usr/lib/system; do
 950                 try_dir="${alt_libc}/${d}"
 951                 [ -d "${try_dir}" ] && add_ldflags -L"${try_dir}"
 952             done
 953
 954             asm_conversion_cmd="${source_path}/build/make/ads2gas_apple.pl"
 955          ;;
 956
 957         linux*)
 958             enable_feature linux
 959             if enabled rvct; then
 960                 # Check if we have CodeSourcery GCC in PATH. Needed for
 961                 # libraries
 962                 hash arm-none-linux-gnueabi-gcc 2>&- || \
 963                   die "Couldn't find CodeSourcery GCC from PATH"
 964
 965                 # Use armcc as a linker to enable translation of
 966                 # some gcc specific options such as -lm and -lpthread.
 967                 LD="armcc --translate_gcc"
 968
 969                 # create configuration file (uses path to CodeSourcery GCC)
 970                 armcc --arm_linux_configure --arm_linux_config_file=arm_linux.cfg
 971
 972                 add_cflags --arm_linux_paths --arm_linux_config_file=arm_linux.cfg
 973                 add_asflags --no_hide_all --apcs=/interwork
 974                 add_ldflags --arm_linux_paths --arm_linux_config_file=arm_linux.cfg
 975                 enabled pic && add_cflags --apcs=/fpic
 976                 enabled pic && add_asflags --apcs=/fpic
 977                 enabled shared && add_cflags --shared
 978             fi
 979         ;;
 980
 981         esac
 982     ;;
 983     mips*)
 984         link_with_cc=gcc
 985         setup_gnu_toolchain
 986         tune_cflags="-mtune="
 987         if enabled dspr2; then
 988             check_add_cflags -mips32r2 -mdspr2
 989             disable_feature fast_unaligned
 990         fi
 991         check_add_cflags -march=${tgt_isa}
 992         check_add_asflags -march=${tgt_isa}
 993         check_add_asflags -KPIC
 994     ;;
 995     ppc*)
 996         enable_feature ppc
 997         bits=${tgt_isa##ppc}
 998         link_with_cc=gcc
 999         setup_gnu_toolchain
1000         add_asflags -force_cpusubtype_ALL -I"\$(dir \$<)darwin"
1001         soft_enable altivec
1002         enabled altivec && add_cflags -maltivec
1003
1004         case "$tgt_os" in
1005         linux*)
1006             add_asflags -maltivec -mregnames -I"\$(dir \$<)linux"
1007         ;;
1008         darwin*)
1009             darwin_arch="-arch ppc"
1010             enabled ppc64 && darwin_arch="${darwin_arch}64"
1011             add_cflags  ${darwin_arch} -m${bits} -fasm-blocks
1012             add_asflags ${darwin_arch} -force_cpusubtype_ALL -I"\$(dir \$<)darwin"
1013             add_ldflags ${darwin_arch} -m${bits}
1014             enabled altivec && add_cflags -faltivec
1015         ;;
1016         esac
1017     ;;
1018     x86*)
1019         bits=32
1020         enabled x86_64 && bits=64
1021         check_cpp <<EOF && bits=x32
1022 #ifndef __ILP32__
1023 #error "not x32"
1024 #endif
1025 EOF
1026
1027         case  ${tgt_os} in
1028             win*)
1029                 enabled gcc && add_cflags -fno-common
1030                 ;;
1031             solaris*)
1032                 CC=${CC:-${CROSS}gcc}
1033                 CXX=${CXX:-${CROSS}g++}
1034                 LD=${LD:-${CROSS}gcc}
1035                 CROSS=${CROSS:-g}
1036                 ;;
1037             os2)
1038                 AS=${AS:-nasm}
1039                 ;;
1040         esac
1041
1042         AS="${alt_as:-${AS:-auto}}"
1043         case  ${tgt_cc} in
1044             icc*)
1045                 CC=${CC:-icc}
1046                 LD=${LD:-icc}
1047                 setup_gnu_toolchain
1048                 add_cflags -use-msasm  # remove -use-msasm too?
1049                 # add -no-intel-extensions to suppress warning #10237
1050                 # refer to http://software.intel.com/en-us/forums/topic/280199
1051                 add_ldflags -i-static -no-intel-extensions
1052                 enabled x86_64 && add_cflags -ipo -static -O3 -no-prec-div
1053                 enabled x86_64 && AR=xiar
1054                 case ${tune_cpu} in
1055                     atom*)
1056                         tune_cflags="-x"
1057                         tune_cpu="SSE3_ATOM"
1058                     ;;
1059                     *)
1060                         tune_cflags="-march="
1061                     ;;
1062                 esac
1063             ;;
1064             gcc*)
1065                 add_cflags -m${bits}
1066                 add_ldflags -m${bits}
1067                 link_with_cc=gcc
1068                 tune_cflags="-march="
1069                 setup_gnu_toolchain
1070                 #for 32 bit x86 builds, -O3 did not turn on this flag
1071                 enabled optimizations && disabled gprof && check_add_cflags -fomit-frame-pointer
1072             ;;
1073             vs*)
1074                 # When building with Microsoft Visual Studio the assembler is
1075                 # invoked directly. Checking at configure time is unnecessary.
1076                 # Skip the check by setting AS arbitrarily
1077                 AS=msvs
1078                 msvs_arch_dir=x86-msvs
1079                 vc_version=${tgt_cc##vs}
1080                 case $vc_version in
1081                     7|8|9|10)
1082                          echo "${tgt_cc} does not support avx/avx2, disabling....."
1083                          RTCD_OPTIONS="${RTCD_OPTIONS}--disable-avx --disable-avx2 "
1084                          soft_disable avx
1085                          soft_disable avx2
1086                     ;;
1087                 esac
1088             ;;
1089         esac
1090
1091         soft_enable runtime_cpu_detect
1092         soft_enable mmx
1093         soft_enable sse
1094         soft_enable sse2
1095         soft_enable sse3
1096         soft_enable ssse3
1097         # We can't use 'check_cflags' until the compiler is configured and CC is
1098         # populated.
1099         if enabled gcc && ! disabled sse4_1 && ! check_cflags -msse4; then
1100             RTCD_OPTIONS="${RTCD_OPTIONS}--disable-sse4_1 "
1101         else
1102             soft_enable sse4_1
1103         fi
1104
1105         if enabled gcc && ! disabled avx && ! check_cflags -mavx; then
1106             RTCD_OPTIONS="${RTCD_OPTIONS}--disable-avx "
1107         else
1108             soft_enable avx
1109         fi
1110
1111         if enabled gcc && ! disabled avx2 && ! check_cflags -mavx2; then
1112             RTCD_OPTIONS="${RTCD_OPTIONS}--disable-avx2 "
1113         else
1114             soft_enable avx2
1115         fi
1116
1117         case "${AS}" in
1118             auto|"")
1119                 which nasm >/dev/null 2>&1 && AS=nasm
1120                 which yasm >/dev/null 2>&1 && AS=yasm
1121                 [ "${AS}" = auto -o -z "${AS}" ] \
1122                     && die "Neither yasm nor nasm have been found"
1123             ;;
1124         esac
1125         log_echo "  using $AS"
1126         [ "${AS##*/}" = nasm ] && add_asflags -Ox
1127         AS_SFX=.asm
1128         case  ${tgt_os} in
1129             win32)
1130                 add_asflags -f win32
1131                 enabled debug && add_asflags -g cv8
1132                 EXE_SFX=.exe
1133             ;;
1134             win64)
1135                 add_asflags -f x64
1136                 enabled debug && add_asflags -g cv8
1137                 EXE_SFX=.exe
1138             ;;
1139             linux*|solaris*|android*)
1140                 add_asflags -f elf${bits}
1141                 enabled debug && [ "${AS}" = yasm ] && add_asflags -g dwarf2
1142                 enabled debug && [ "${AS}" = nasm ] && add_asflags -g
1143                 [ "${AS##*/}" = nasm ] && check_asm_align
1144             ;;
1145             darwin*)
1146                 add_asflags -f macho${bits}
1147                 enabled x86 && darwin_arch="-arch i386" || darwin_arch="-arch x86_64"
1148                 add_cflags  ${darwin_arch}
1149                 add_ldflags ${darwin_arch}
1150                 # -mdynamic-no-pic is still a bit of voodoo -- it was required at
1151                 # one time, but does not seem to be now, and it breaks some of the
1152                 # code that still relies on inline assembly.
1153                 # enabled icc && ! enabled pic && add_cflags -fno-pic -mdynamic-no-pic
1154                 enabled icc && ! enabled pic && add_cflags -fno-pic
1155             ;;
1156             os2)
1157                 add_asflags -f aout
1158                 enabled debug && add_asflags -g
1159                 EXE_SFX=.exe
1160             ;;
1161             *) log "Warning: Unknown os $tgt_os while setting up $AS flags"
1162             ;;
1163         esac
1164     ;;
1165     universal*|*-gcc|generic-gnu)
1166         link_with_cc=gcc
1167         enable_feature gcc
1168     setup_gnu_toolchain
1169     ;;
1170     esac
1171
1172     # Try to enable CPU specific tuning
1173     if [ -n "${tune_cpu}" ]; then
1174         if [ -n "${tune_cflags}" ]; then
1175             check_add_cflags ${tune_cflags}${tune_cpu} || \
1176                 die "Requested CPU '${tune_cpu}' not supported by compiler"
1177         fi
1178     if [ -n "${tune_asflags}" ]; then
1179             check_add_asflags ${tune_asflags}${tune_cpu} || \
1180                 die "Requested CPU '${tune_cpu}' not supported by assembler"
1181         fi
1182     if [ -z "${tune_cflags}${tune_asflags}" ]; then
1183             log_echo "Warning: CPU tuning not supported by this toolchain"
1184         fi
1185     fi
1186
1187     enabled debug && check_add_cflags -g && check_add_ldflags -g
1188     enabled gprof && check_add_cflags -pg && check_add_ldflags -pg
1189     enabled gcov &&
1190         check_add_cflags -fprofile-arcs -ftest-coverage &&
1191         check_add_ldflags -fprofile-arcs -ftest-coverage
1192
1193     if enabled optimizations; then
1194         if enabled rvct; then
1195             enabled small && check_add_cflags -Ospace || check_add_cflags -Otime
1196         else
1197             enabled small && check_add_cflags -O2 ||  check_add_cflags -O3
1198         fi
1199     fi
1200
1201     # default use_x86inc to yes if pic is no or 64bit or we are not on darwin
1202     echo "  checking here for x86inc \"${tgt_isa}\" \"$pic\" "
1203     if [ ${tgt_isa} = x86_64 -o ! "$pic" = "yes" -o "${tgt_os#darwin}" = "${tgt_os}"  ]; then
1204       soft_enable use_x86inc
1205     fi
1206
1207     # Position Independent Code (PIC) support, for building relocatable
1208     # shared objects
1209     enabled gcc && enabled pic && check_add_cflags -fPIC
1210
1211     # Work around longjmp interception on glibc >= 2.11, to improve binary
1212     # compatibility. See http://code.google.com/p/webm/issues/detail?id=166
1213     enabled linux && check_add_cflags -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=0
1214
1215     # Check for strip utility variant
1216     ${STRIP} -V 2>/dev/null | grep GNU >/dev/null && enable_feature gnu_strip
1217
1218     # Try to determine target endianness
1219     check_cc <<EOF
1220     unsigned int e = 'O'<<24 | '2'<<16 | 'B'<<8 | 'E';
1221 EOF
1222     [ -f "${TMP_O}" ] && od -A n -t x1 "${TMP_O}" | tr -d '\n' |
1223         grep '4f *32 *42 *45' >/dev/null 2>&1 && enable_feature big_endian
1224
1225     # Try to find which inline keywords are supported
1226     check_cc <<EOF && INLINE="inline"
1227     static inline function() {}
1228 EOF
1229     check_cc <<EOF && INLINE="__inline__ __attribute__((always_inline))"
1230     static __attribute__((always_inline)) function() {}
1231 EOF
1232
1233     # Almost every platform uses pthreads.
1234     if enabled multithread; then
1235         case ${toolchain} in
1236             *-win*-vs*);;
1237             *-android-gcc);;
1238             *) check_header pthread.h && add_extralibs -lpthread
1239         esac
1240     fi
1241
1242     # only for MIPS platforms
1243     case ${toolchain} in
1244         mips*)
1245             if enabled dspr2; then
1246                 if enabled big_endian; then
1247                     echo "dspr2 optimizations are available only for little endian platforms"
1248                     disable_feature dspr2
1249                 fi
1250             fi
1251         ;;
1252     esac
1253
1254     # glibc needs these
1255     if enabled linux; then
1256         add_cflags -D_LARGEFILE_SOURCE
1257         add_cflags -D_FILE_OFFSET_BITS=64
1258     fi
1259
1260     # append any user defined extra cflags
1261     if [ -n "${extra_cflags}" ] ; then
1262         check_add_cflags ${extra_cflags} || \
1263         die "Requested extra CFLAGS '${extra_cflags}' not supported by compiler"
1264     fi
1265 }
1266
1267 process_toolchain() {
1268     process_common_toolchain
1269 }
1270
1271 print_config_mk() {
1272     local prefix=$1
1273     local makefile=$2
1274     shift 2
1275     for cfg; do
1276         upname="`toupper $cfg`"
1277         if enabled $cfg; then
1278             echo "${prefix}_${upname}=yes" >> $makefile
1279         fi
1280     done
1281 }
1282
1283 print_config_h() {
1284     local prefix=$1
1285     local header=$2
1286     shift 2
1287     for cfg; do
1288         upname="`toupper $cfg`"
1289         if enabled $cfg; then
1290             echo "#define ${prefix}_${upname} 1" >> $header
1291         else
1292             echo "#define ${prefix}_${upname} 0" >> $header
1293         fi
1294     done
1295 }
1296
1297 print_webm_license() {
1298     local destination=$1
1299     local prefix="$2"
1300     local suffix="$3"
1301     shift 3
1302     cat <<EOF > ${destination}
1303 ${prefix} Copyright (c) 2011 The WebM project authors. All Rights Reserved.${suffix}
1304 ${prefix} ${suffix}
1305 ${prefix} Use of this source code is governed by a BSD-style license${suffix}
1306 ${prefix} that can be found in the LICENSE file in the root of the source${suffix}
1307 ${prefix} tree. An additional intellectual property rights grant can be found${suffix}
1308 ${prefix} in the file PATENTS.  All contributing project authors may${suffix}
1309 ${prefix} be found in the AUTHORS file in the root of the source tree.${suffix}
1310 EOF
1311 }
1312
1313 process_targets() {
1314     true;
1315 }
1316
1317 process_detect() {
1318     true;
1319 }
1320
1321 enable_feature logging
1322 logfile="config.log"
1323 self=$0
1324 process() {
1325     cmdline_args="$@"
1326     process_cmdline "$@"
1327     if enabled child; then
1328         echo "# ${self} $@" >> ${logfile}
1329     else
1330         echo "# ${self} $@" > ${logfile}
1331     fi
1332     post_process_common_cmdline
1333     post_process_cmdline
1334     process_toolchain
1335     process_detect
1336     process_targets
1337
1338     OOT_INSTALLS="${OOT_INSTALLS}"
1339     if enabled source_path_used; then
1340     # Prepare the PWD for building.
1341     for f in ${OOT_INSTALLS}; do
1342             install -D ${source_path}/$f $f
1343     done
1344     fi
1345     cp ${source_path}/build/make/Makefile .
1346
1347     clean_temp_files
1348     true
1349 }