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