build/make/configure.sh

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