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