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_lib() {
 323   log check_lib "$@"
 324   check_cc $@ \
 325     && check_cmd ${LD} ${LDFLAGS} -o ${TMP_X} ${TMP_O} "$@" ${extralibs}
 326 }
 327
 328 check_header(){
 329   log check_header "$@"
 330   header=$1
 331   shift
 332   var=`echo $header | sed 's/[^A-Za-z0-9_]/_/g'`
 333   disable_feature $var
 334   check_cpp "$@" <<EOF && enable_feature $var
 335 #include "$header"
 336 int x;
 337 EOF
 338 }
 339
 340 check_cflags() {
 341  log check_cflags "$@"
 342  check_cc -Werror "$@" <<EOF
 343 int x;
 344 EOF
 345 }
 346
 347 check_cxxflags() {
 348   log check_cxxflags "$@"
 349
 350   # Catch CFLAGS that trigger CXX warnings
 351   case "$CXX" in
 352     *c++-analyzer|*clang++|*g++*)
 353       check_cxx -Werror "$@" <<EOF
 354 int x;
 355 EOF
 356       ;;
 357     *)
 358       check_cxx -Werror "$@" <<EOF
 359 int x;
 360 EOF
 361       ;;
 362     esac
 363 }
 364
 365 check_add_cflags() {
 366   check_cxxflags "$@" && add_cxxflags_only "$@"
 367   check_cflags "$@" && add_cflags_only "$@"
 368 }
 369
 370 check_add_cxxflags() {
 371   check_cxxflags "$@" && add_cxxflags_only "$@"
 372 }
 373
 374 check_add_asflags() {
 375   log add_asflags "$@"
 376   add_asflags "$@"
 377 }
 378
 379 check_add_ldflags() {
 380   log add_ldflags "$@"
 381   add_ldflags "$@"
 382 }
 383
 384 check_asm_align() {
 385   log check_asm_align "$@"
 386   cat >${TMP_ASM} <<EOF
 387 section .rodata
 388 align 16
 389 EOF
 390   log_file ${TMP_ASM}
 391   check_cmd ${AS} ${ASFLAGS} -o ${TMP_O} ${TMP_ASM}
 392   readelf -WS ${TMP_O} >${TMP_X}
 393   log_file ${TMP_X}
 394   if ! grep -q '\.rodata .* 16$' ${TMP_X}; then
 395     die "${AS} ${ASFLAGS} does not support section alignment (nasm <=2.08?)"
 396   fi
 397 }
 398
 399 # tests for -m$1 toggling the feature given in $2. If $2 is empty $1 is used.
 400 check_gcc_machine_option() {
 401   opt="$1"
 402   feature="$2"
 403   [ -n "$feature" ] || feature="$opt"
 404
 405   if enabled gcc && ! disabled "$feature" && ! check_cflags "-m$opt"; then
 406     RTCD_OPTIONS="${RTCD_OPTIONS}--disable-$feature "
 407   else
 408     soft_enable "$feature"
 409   fi
 410 }
 411
 412 # tests for -m$2, -m$3, -m$4... toggling the feature given in $1.
 413 check_gcc_machine_options() {
 414   feature="$1"
 415   shift
 416   flags="-m$1"
 417   shift
 418   for opt in $*; do
 419     flags="$flags -m$opt"
 420   done
 421
 422   if enabled gcc && ! disabled "$feature" && ! check_cflags $flags; then
 423     RTCD_OPTIONS="${RTCD_OPTIONS}--disable-$feature "
 424   else
 425     soft_enable "$feature"
 426   fi
 427 }
 428
 429 check_gcc_avx512_compiles() {
 430   if disabled gcc; then
 431     return
 432   fi
 433
 434   check_cc -mavx512f <<EOF
 435 #include <immintrin.h>
 436 void f(void) {
 437   __m512i x = _mm512_set1_epi16(0);
 438   (void)x;
 439 }
 440 EOF
 441   compile_result=$?
 442   if [ ${compile_result} -ne 0 ]; then
 443     log_echo "    disabling avx512: not supported by compiler"
 444     disable_feature avx512
 445     RTCD_OPTIONS="${RTCD_OPTIONS}--disable-avx512 "
 446   fi
 447 }
 448
 449 write_common_config_banner() {
 450   print_webm_license config.mk "##" ""
 451   echo '# This file automatically generated by configure. Do not edit!' >> config.mk
 452   echo "TOOLCHAIN := ${toolchain}" >> config.mk
 453
 454   case ${toolchain} in
 455     *-linux-rvct)
 456       echo "ALT_LIBC := ${alt_libc}" >> config.mk
 457       ;;
 458   esac
 459 }
 460
 461 write_common_config_targets() {
 462   for t in ${all_targets}; do
 463     if enabled ${t}; then
 464       if enabled child; then
 465         fwrite config.mk "ALL_TARGETS += ${t}-${toolchain}"
 466       else
 467         fwrite config.mk "ALL_TARGETS += ${t}"
 468       fi
 469     fi
 470     true;
 471   done
 472   true
 473 }
 474
 475 write_common_target_config_mk() {
 476   saved_CC="${CC}"
 477   saved_CXX="${CXX}"
 478   enabled ccache && CC="ccache ${CC}"
 479   enabled ccache && CXX="ccache ${CXX}"
 480   print_webm_license $1 "##" ""
 481
 482   cat >> $1 << EOF
 483 # This file automatically generated by configure. Do not edit!
 484 SRC_PATH="$source_path"
 485 SRC_PATH_BARE=$source_path
 486 BUILD_PFX=${BUILD_PFX}
 487 TOOLCHAIN=${toolchain}
 488 ASM_CONVERSION=${asm_conversion_cmd:-${source_path}/build/make/ads2gas.pl}
 489 GEN_VCPROJ=${gen_vcproj_cmd}
 490 MSVS_ARCH_DIR=${msvs_arch_dir}
 491
 492 CC=${CC}
 493 CXX=${CXX}
 494 AR=${AR}
 495 LD=${LD}
 496 AS=${AS}
 497 STRIP=${STRIP}
 498 NM=${NM}
 499
 500 CFLAGS  = ${CFLAGS}
 501 CXXFLAGS  = ${CXXFLAGS}
 502 ARFLAGS = -crs\$(if \$(quiet),,v)
 503 LDFLAGS = ${LDFLAGS}
 504 ASFLAGS = ${ASFLAGS}
 505 extralibs = ${extralibs}
 506 AS_SFX    = ${AS_SFX:-.asm}
 507 EXE_SFX   = ${EXE_SFX}
 508 VCPROJ_SFX = ${VCPROJ_SFX}
 509 RTCD_OPTIONS = ${RTCD_OPTIONS}
 510 LIBYUV_CXXFLAGS = ${LIBYUV_CXXFLAGS}
 511 EOF
 512
 513   if enabled rvct; then cat >> $1 << EOF
 514 fmt_deps = sed -e 's;^__image.axf;\${@:.d=.o} \$@;' #hide
 515 EOF
 516   else cat >> $1 << EOF
 517 fmt_deps = sed -e 's;^\([a-zA-Z0-9_]*\)\.o;\${@:.d=.o} \$@;'
 518 EOF
 519   fi
 520
 521   print_config_mk VPX_ARCH "${1}" ${ARCH_LIST}
 522   print_config_mk HAVE     "${1}" ${HAVE_LIST}
 523   print_config_mk CONFIG   "${1}" ${CONFIG_LIST}
 524   print_config_mk HAVE     "${1}" gnu_strip
 525
 526   enabled msvs && echo "CONFIG_VS_VERSION=${vs_version}" >> "${1}"
 527
 528   CC="${saved_CC}"
 529   CXX="${saved_CXX}"
 530 }
 531
 532 write_common_target_config_h() {
 533   print_webm_license ${TMP_H} "/*" " */"
 534   cat >> ${TMP_H} << EOF
 535 /* This file automatically generated by configure. Do not edit! */
 536 #ifndef VPX_CONFIG_H
 537 #define VPX_CONFIG_H
 538 #define RESTRICT    ${RESTRICT}
 539 #define INLINE      ${INLINE}
 540 EOF
 541   print_config_h VPX_ARCH "${TMP_H}" ${ARCH_LIST}
 542   print_config_h HAVE     "${TMP_H}" ${HAVE_LIST}
 543   print_config_h CONFIG   "${TMP_H}" ${CONFIG_LIST}
 544   print_config_vars_h     "${TMP_H}" ${VAR_LIST}
 545   echo "#endif /* VPX_CONFIG_H */" >> ${TMP_H}
 546   mkdir -p `dirname "$1"`
 547   cmp "$1" ${TMP_H} >/dev/null 2>&1 || mv ${TMP_H} "$1"
 548 }
 549
 550 write_win_arm64_neon_h_workaround() {
 551   print_webm_license ${TMP_H} "/*" " */"
 552   cat >> ${TMP_H} << EOF
 553 /* This file automatically generated by configure. Do not edit! */
 554 #ifndef VPX_WIN_ARM_NEON_H_WORKAROUND
 555 #define VPX_WIN_ARM_NEON_H_WORKAROUND
 556 /* The Windows SDK has arm_neon.h, but unlike on other platforms it is
 557  * ARM32-only. ARM64 NEON support is provided by arm64_neon.h, a proper
 558  * superset of arm_neon.h. Work around this by providing a more local
 559  * arm_neon.h that simply #includes arm64_neon.h.
 560  */
 561 #include <arm64_neon.h>
 562 #endif /* VPX_WIN_ARM_NEON_H_WORKAROUND */
 563 EOF
 564   mkdir -p `dirname "$1"`
 565   cmp "$1" ${TMP_H} >/dev/null 2>&1 || mv ${TMP_H} "$1"
 566 }
 567
 568 process_common_cmdline() {
 569   for opt in "$@"; do
 570     optval="${opt#*=}"
 571     case "$opt" in
 572       --child)
 573         enable_feature child
 574         ;;
 575       --log*)
 576         logging="$optval"
 577         if ! disabled logging ; then
 578           enabled logging || logfile="$logging"
 579         else
 580           logfile=/dev/null
 581         fi
 582         ;;
 583       --target=*)
 584         toolchain="${toolchain:-${optval}}"
 585         ;;
 586       --force-target=*)
 587         toolchain="${toolchain:-${optval}}"
 588         enable_feature force_toolchain
 589         ;;
 590       --cpu=*)
 591         tune_cpu="$optval"
 592         ;;
 593       --extra-cflags=*)
 594         extra_cflags="${optval}"
 595         ;;
 596       --extra-cxxflags=*)
 597         extra_cxxflags="${optval}"
 598         ;;
 599       --enable-?*|--disable-?*)
 600         eval `echo "$opt" | sed 's/--/action=/;s/-/ option=/;s/-/_/g'`
 601         if is_in ${option} ${ARCH_EXT_LIST}; then
 602           [ $action = "disable" ] && RTCD_OPTIONS="${RTCD_OPTIONS}--disable-${option} "
 603         elif [ $action = "disable" ] && ! disabled $option ; then
 604           is_in ${option} ${CMDLINE_SELECT} || die_unknown $opt
 605           log_echo "  disabling $option"
 606         elif [ $action = "enable" ] && ! enabled $option ; then
 607           is_in ${option} ${CMDLINE_SELECT} || die_unknown $opt
 608           log_echo "  enabling $option"
 609         fi
 610         ${action}_feature $option
 611         ;;
 612       --require-?*)
 613         eval `echo "$opt" | sed 's/--/action=/;s/-/ option=/;s/-/_/g'`
 614         if is_in ${option} ${ARCH_EXT_LIST}; then
 615             RTCD_OPTIONS="${RTCD_OPTIONS}${opt} "
 616         else
 617             die_unknown $opt
 618         fi
 619         ;;
 620       --force-enable-?*|--force-disable-?*)
 621         eval `echo "$opt" | sed 's/--force-/action=/;s/-/ option=/;s/-/_/g'`
 622         ${action}_feature $option
 623         ;;
 624       --libc=*)
 625         [ -d "${optval}" ] || die "Not a directory: ${optval}"
 626         disable_feature builtin_libc
 627         alt_libc="${optval}"
 628         ;;
 629       --as=*)
 630         [ "${optval}" = yasm ] || [ "${optval}" = nasm ] \
 631           || [ "${optval}" = auto ] \
 632           || die "Must be yasm, nasm or auto: ${optval}"
 633         alt_as="${optval}"
 634         ;;
 635       --size-limit=*)
 636         w="${optval%%x*}"
 637         h="${optval##*x}"
 638         VAR_LIST="DECODE_WIDTH_LIMIT ${w} DECODE_HEIGHT_LIMIT ${h}"
 639         [ ${w} -gt 0 ] && [ ${h} -gt 0 ] || die "Invalid size-limit: too small."
 640         [ ${w} -lt 65536 ] && [ ${h} -lt 65536 ] \
 641             || die "Invalid size-limit: too big."
 642         enable_feature size_limit
 643         ;;
 644       --prefix=*)
 645         prefix="${optval}"
 646         ;;
 647       --libdir=*)
 648         libdir="${optval}"
 649         ;;
 650       --libc|--as|--prefix|--libdir)
 651         die "Option ${opt} requires argument"
 652         ;;
 653       --help|-h)
 654         show_help
 655         ;;
 656       *)
 657         die_unknown $opt
 658         ;;
 659     esac
 660   done
 661 }
 662
 663 process_cmdline() {
 664   for opt do
 665     optval="${opt#*=}"
 666     case "$opt" in
 667       *)
 668         process_common_cmdline $opt
 669         ;;
 670     esac
 671   done
 672 }
 673
 674 post_process_common_cmdline() {
 675   prefix="${prefix:-/usr/local}"
 676   prefix="${prefix%/}"
 677   libdir="${libdir:-${prefix}/lib}"
 678   libdir="${libdir%/}"
 679   if [ "${libdir#${prefix}}" = "${libdir}" ]; then
 680     die "Libdir ${libdir} must be a subdirectory of ${prefix}"
 681   fi
 682 }
 683
 684 post_process_cmdline() {
 685   true;
 686 }
 687
 688 setup_gnu_toolchain() {
 689   CC=${CC:-${CROSS}gcc}
 690   CXX=${CXX:-${CROSS}g++}
 691   AR=${AR:-${CROSS}ar}
 692   LD=${LD:-${CROSS}${link_with_cc:-ld}}
 693   AS=${AS:-${CROSS}as}
 694   STRIP=${STRIP:-${CROSS}strip}
 695   NM=${NM:-${CROSS}nm}
 696   AS_SFX=.S
 697   EXE_SFX=
 698 }
 699
 700 # Reliably find the newest available Darwin SDKs. (Older versions of
 701 # xcrun don't support --show-sdk-path.)
 702 show_darwin_sdk_path() {
 703   xcrun --sdk $1 --show-sdk-path 2>/dev/null ||
 704     xcodebuild -sdk $1 -version Path 2>/dev/null
 705 }
 706
 707 # Print the major version number of the Darwin SDK specified by $1.
 708 show_darwin_sdk_major_version() {
 709   xcrun --sdk $1 --show-sdk-version 2>/dev/null | cut -d. -f1
 710 }
 711
 712 # Print the Xcode version.
 713 show_xcode_version() {
 714   xcodebuild -version | head -n1 | cut -d' ' -f2
 715 }
 716
 717 # Fails when Xcode version is less than 6.3.
 718 check_xcode_minimum_version() {
 719   xcode_major=$(show_xcode_version | cut -f1 -d.)
 720   xcode_minor=$(show_xcode_version | cut -f2 -d.)
 721   xcode_min_major=6
 722   xcode_min_minor=3
 723   if [ ${xcode_major} -lt ${xcode_min_major} ]; then
 724     return 1
 725   fi
 726   if [ ${xcode_major} -eq ${xcode_min_major} ] \
 727     && [ ${xcode_minor} -lt ${xcode_min_minor} ]; then
 728     return 1
 729   fi
 730 }
 731
 732 process_common_toolchain() {
 733   if [ -z "$toolchain" ]; then
 734     gcctarget="${CHOST:-$(gcc -dumpmachine 2> /dev/null)}"
 735     # detect tgt_isa
 736     case "$gcctarget" in
 737       aarch64*)
 738         tgt_isa=arm64
 739         ;;
 740       armv7*-hardfloat* | armv7*-gnueabihf | arm-*-gnueabihf)
 741         tgt_isa=armv7
 742         float_abi=hard
 743         ;;
 744       armv7*)
 745         tgt_isa=armv7
 746         float_abi=softfp
 747         ;;
 748       *x86_64*|*amd64*)
 749         tgt_isa=x86_64
 750         ;;
 751       *i[3456]86*)
 752         tgt_isa=x86
 753         ;;
 754       *sparc*)
 755         tgt_isa=sparc
 756         ;;
 757       power*64le*-*)
 758         tgt_isa=ppc64le
 759         ;;
 760       *mips64el*)
 761         tgt_isa=mips64
 762         ;;
 763       *mips32el*)
 764         tgt_isa=mips32
 765         ;;
 766     esac
 767
 768     # detect tgt_os
 769     case "$gcctarget" in
 770       *darwin10*)
 771         tgt_isa=x86_64
 772         tgt_os=darwin10
 773         ;;
 774       *darwin11*)
 775         tgt_isa=x86_64
 776         tgt_os=darwin11
 777         ;;
 778       *darwin12*)
 779         tgt_isa=x86_64
 780         tgt_os=darwin12
 781         ;;
 782       *darwin13*)
 783         tgt_isa=x86_64
 784         tgt_os=darwin13
 785         ;;
 786       *darwin14*)
 787         tgt_isa=x86_64
 788         tgt_os=darwin14
 789         ;;
 790       *darwin15*)
 791         tgt_isa=x86_64
 792         tgt_os=darwin15
 793         ;;
 794       *darwin16*)
 795         tgt_isa=x86_64
 796         tgt_os=darwin16
 797         ;;
 798       *darwin17*)
 799         tgt_isa=x86_64
 800         tgt_os=darwin17
 801         ;;
 802       x86_64*mingw32*)
 803         tgt_os=win64
 804         ;;
 805       x86_64*cygwin*)
 806         tgt_os=win64
 807         ;;
 808       *mingw32*|*cygwin*)
 809         [ -z "$tgt_isa" ] && tgt_isa=x86
 810         tgt_os=win32
 811         ;;
 812       *linux*|*bsd*)
 813         tgt_os=linux
 814         ;;
 815       *solaris2.10)
 816         tgt_os=solaris
 817         ;;
 818       *os2*)
 819         tgt_os=os2
 820         ;;
 821     esac
 822
 823     if [ -n "$tgt_isa" ] && [ -n "$tgt_os" ]; then
 824       toolchain=${tgt_isa}-${tgt_os}-gcc
 825     fi
 826   fi
 827
 828   toolchain=${toolchain:-generic-gnu}
 829
 830   is_in ${toolchain} ${all_platforms} || enabled force_toolchain \
 831     || die "Unrecognized toolchain '${toolchain}'"
 832
 833   enabled child || log_echo "Configuring for target '${toolchain}'"
 834
 835   #
 836   # Set up toolchain variables
 837   #
 838   tgt_isa=$(echo ${toolchain} | awk 'BEGIN{FS="-"}{print $1}')
 839   tgt_os=$(echo ${toolchain} | awk 'BEGIN{FS="-"}{print $2}')
 840   tgt_cc=$(echo ${toolchain} | awk 'BEGIN{FS="-"}{print $3}')
 841
 842   # Mark the specific ISA requested as enabled
 843   soft_enable ${tgt_isa}
 844   enable_feature ${tgt_os}
 845   enable_feature ${tgt_cc}
 846
 847   # Enable the architecture family
 848   case ${tgt_isa} in
 849     arm*)
 850       enable_feature arm
 851       ;;
 852     mips*)
 853       enable_feature mips
 854       ;;
 855     ppc*)
 856       enable_feature ppc
 857       ;;
 858   esac
 859
 860   # PIC is probably what we want when building shared libs
 861   enabled shared && soft_enable pic
 862
 863   # Minimum iOS version for all target platforms (darwin and iphonesimulator).
 864   # Shared library framework builds are only possible on iOS 8 and later.
 865   if enabled shared; then
 866     IOS_VERSION_OPTIONS="--enable-shared"
 867     IOS_VERSION_MIN="8.0"
 868   else
 869     IOS_VERSION_OPTIONS=""
 870     IOS_VERSION_MIN="7.0"
 871   fi
 872
 873   # Handle darwin variants. Newer SDKs allow targeting older
 874   # platforms, so use the newest one available.
 875   case ${toolchain} in
 876     arm*-darwin*)
 877       add_cflags "-miphoneos-version-min=${IOS_VERSION_MIN}"
 878       iphoneos_sdk_dir="$(show_darwin_sdk_path iphoneos)"
 879       if [ -d "${iphoneos_sdk_dir}" ]; then
 880         add_cflags  "-isysroot ${iphoneos_sdk_dir}"
 881         add_ldflags "-isysroot ${iphoneos_sdk_dir}"
 882       fi
 883       ;;
 884     x86*-darwin*)
 885       osx_sdk_dir="$(show_darwin_sdk_path macosx)"
 886       if [ -d "${osx_sdk_dir}" ]; then
 887         add_cflags  "-isysroot ${osx_sdk_dir}"
 888         add_ldflags "-isysroot ${osx_sdk_dir}"
 889       fi
 890       ;;
 891   esac
 892
 893   case ${toolchain} in
 894     *-darwin8-*)
 895       add_cflags  "-mmacosx-version-min=10.4"
 896       add_ldflags "-mmacosx-version-min=10.4"
 897       ;;
 898     *-darwin9-*)
 899       add_cflags  "-mmacosx-version-min=10.5"
 900       add_ldflags "-mmacosx-version-min=10.5"
 901       ;;
 902     *-darwin10-*)
 903       add_cflags  "-mmacosx-version-min=10.6"
 904       add_ldflags "-mmacosx-version-min=10.6"
 905       ;;
 906     *-darwin11-*)
 907       add_cflags  "-mmacosx-version-min=10.7"
 908       add_ldflags "-mmacosx-version-min=10.7"
 909       ;;
 910     *-darwin12-*)
 911       add_cflags  "-mmacosx-version-min=10.8"
 912       add_ldflags "-mmacosx-version-min=10.8"
 913       ;;
 914     *-darwin13-*)
 915       add_cflags  "-mmacosx-version-min=10.9"
 916       add_ldflags "-mmacosx-version-min=10.9"
 917       ;;
 918     *-darwin14-*)
 919       add_cflags  "-mmacosx-version-min=10.10"
 920       add_ldflags "-mmacosx-version-min=10.10"
 921       ;;
 922     *-darwin15-*)
 923       add_cflags  "-mmacosx-version-min=10.11"
 924       add_ldflags "-mmacosx-version-min=10.11"
 925       ;;
 926     *-darwin16-*)
 927       add_cflags  "-mmacosx-version-min=10.12"
 928       add_ldflags "-mmacosx-version-min=10.12"
 929       ;;
 930     *-darwin17-*)
 931       add_cflags  "-mmacosx-version-min=10.13"
 932       add_ldflags "-mmacosx-version-min=10.13"
 933       ;;
 934     *-iphonesimulator-*)
 935       add_cflags  "-miphoneos-version-min=${IOS_VERSION_MIN}"
 936       add_ldflags "-miphoneos-version-min=${IOS_VERSION_MIN}"
 937       iossim_sdk_dir="$(show_darwin_sdk_path iphonesimulator)"
 938       if [ -d "${iossim_sdk_dir}" ]; then
 939         add_cflags  "-isysroot ${iossim_sdk_dir}"
 940         add_ldflags "-isysroot ${iossim_sdk_dir}"
 941       fi
 942       ;;
 943   esac
 944
 945   # Handle Solaris variants. Solaris 10 needs -lposix4
 946   case ${toolchain} in
 947     sparc-solaris-*)
 948       add_extralibs -lposix4
 949       ;;
 950     *-solaris-*)
 951       add_extralibs -lposix4
 952       ;;
 953   esac
 954
 955   # Process ARM architecture variants
 956   case ${toolchain} in
 957     arm*)
 958       # on arm, isa versions are supersets
 959       case ${tgt_isa} in
 960         arm64|armv8)
 961           soft_enable neon
 962           ;;
 963         armv7|armv7s)
 964           soft_enable neon
 965           # Only enable neon_asm when neon is also enabled.
 966           enabled neon && soft_enable neon_asm
 967           # If someone tries to force it through, die.
 968           if disabled neon && enabled neon_asm; then
 969             die "Disabling neon while keeping neon-asm is not supported"
 970           fi
 971           ;;
 972       esac
 973
 974       asm_conversion_cmd="cat"
 975
 976       case ${tgt_cc} in
 977         gcc)
 978           link_with_cc=gcc
 979           setup_gnu_toolchain
 980           arch_int=${tgt_isa##armv}
 981           arch_int=${arch_int%%te}
 982           tune_cflags="-mtune="
 983           if [ ${tgt_isa} = "armv7" ] || [ ${tgt_isa} = "armv7s" ]; then
 984             if [ -z "${float_abi}" ]; then
 985               check_cpp <<EOF && float_abi=hard || float_abi=softfp
 986 #ifndef __ARM_PCS_VFP
 987 #error "not hardfp"
 988 #endif
 989 EOF
 990             fi
 991             check_add_cflags  -march=armv7-a -mfloat-abi=${float_abi}
 992             check_add_asflags -march=armv7-a -mfloat-abi=${float_abi}
 993
 994             if enabled neon || enabled neon_asm; then
 995               check_add_cflags -mfpu=neon #-ftree-vectorize
 996               check_add_asflags -mfpu=neon
 997             fi
 998           elif [ ${tgt_isa} = "arm64" ] || [ ${tgt_isa} = "armv8" ]; then
 999             check_add_cflags -march=armv8-a
1000             check_add_asflags -march=armv8-a
1001           else
1002             check_add_cflags -march=${tgt_isa}
1003             check_add_asflags -march=${tgt_isa}
1004           fi
1005
1006           enabled debug && add_asflags -g
1007           asm_conversion_cmd="${source_path}/build/make/ads2gas.pl"
1008
1009           case ${tgt_os} in
1010             win*)
1011               asm_conversion_cmd="$asm_conversion_cmd -noelf"
1012               AS="$CC -c"
1013               EXE_SFX=.exe
1014               enable_feature thumb
1015               ;;
1016           esac
1017
1018           if enabled thumb; then
1019             asm_conversion_cmd="$asm_conversion_cmd -thumb"
1020             check_add_cflags -mthumb
1021             check_add_asflags -mthumb -mimplicit-it=always
1022           fi
1023           ;;
1024         vs*)
1025           # A number of ARM-based Windows platforms are constrained by their
1026           # respective SDKs' limitations. Fortunately, these are all 32-bit ABIs
1027           # and so can be selected as 'win32'.
1028           if [ ${tgt_os} = "win32" ]; then
1029             asm_conversion_cmd="${source_path}/build/make/ads2armasm_ms.pl"
1030             AS_SFX=.S
1031             msvs_arch_dir=arm-msvs
1032             disable_feature multithread
1033             disable_feature unit_tests
1034             if [ ${tgt_cc##vs} -ge 12 ]; then
1035               # MSVC 2013 doesn't allow doing plain .exe projects for ARM32,
1036               # only "AppContainerApplication" which requires an AppxManifest.
1037               # Therefore disable the examples, just build the library.
1038               disable_feature examples
1039               disable_feature tools
1040             fi
1041           else
1042             # Windows 10 on ARM, on the other hand, has full Windows SDK support
1043             # for building Win32 ARM64 applications in addition to ARM64
1044             # Windows Store apps. It is the only 64-bit ARM ABI that
1045             # Windows supports, so it is the default definition of 'win64'.
1046             # ARM64 build support officially shipped in Visual Studio 15.9.0.
1047
1048             # Because the ARM64 Windows SDK's arm_neon.h is ARM32-specific
1049             # while LLVM's is not, probe its validity.
1050             if enabled neon; then
1051               if [ -n "${CC}" ]; then
1052                 check_header arm_neon.h || check_header arm64_neon.h && \
1053                     enable_feature win_arm64_neon_h_workaround
1054               else
1055                 # If a probe is not possible, assume this is the pure Windows
1056                 # SDK and so the workaround is necessary.
1057                 enable_feature win_arm64_neon_h_workaround
1058               fi
1059             fi
1060           fi
1061           ;;
1062         rvct)
1063           CC=armcc
1064           AR=armar
1065           AS=armasm
1066           LD="${source_path}/build/make/armlink_adapter.sh"
1067           STRIP=arm-none-linux-gnueabi-strip
1068           NM=arm-none-linux-gnueabi-nm
1069           tune_cflags="--cpu="
1070           tune_asflags="--cpu="
1071           if [ -z "${tune_cpu}" ]; then
1072             if [ ${tgt_isa} = "armv7" ]; then
1073               if enabled neon || enabled neon_asm
1074               then
1075                 check_add_cflags --fpu=softvfp+vfpv3
1076                 check_add_asflags --fpu=softvfp+vfpv3
1077               fi
1078               check_add_cflags --cpu=Cortex-A8
1079               check_add_asflags --cpu=Cortex-A8
1080             else
1081               check_add_cflags --cpu=${tgt_isa##armv}
1082               check_add_asflags --cpu=${tgt_isa##armv}
1083             fi
1084           fi
1085           arch_int=${tgt_isa##armv}
1086           arch_int=${arch_int%%te}
1087           enabled debug && add_asflags -g
1088           add_cflags --gnu
1089           add_cflags --enum_is_int
1090           add_cflags --wchar32
1091           ;;
1092       esac
1093
1094       case ${tgt_os} in
1095         none*)
1096           disable_feature multithread
1097           disable_feature os_support
1098           ;;
1099
1100         android*)
1101           echo "Assuming standalone build with NDK toolchain."
1102           echo "See build/make/Android.mk for details."
1103           check_add_ldflags -static
1104           soft_enable unit_tests
1105           ;;
1106
1107         darwin*)
1108           XCRUN_FIND="xcrun --sdk iphoneos --find"
1109           CXX="$(${XCRUN_FIND} clang++)"
1110           CC="$(${XCRUN_FIND} clang)"
1111           AR="$(${XCRUN_FIND} ar)"
1112           AS="$(${XCRUN_FIND} as)"
1113           STRIP="$(${XCRUN_FIND} strip)"
1114           NM="$(${XCRUN_FIND} nm)"
1115           RANLIB="$(${XCRUN_FIND} ranlib)"
1116           AS_SFX=.S
1117           LD="${CXX:-$(${XCRUN_FIND} ld)}"
1118
1119           # ASFLAGS is written here instead of using check_add_asflags
1120           # because we need to overwrite all of ASFLAGS and purge the
1121           # options that were put in above
1122           ASFLAGS="-arch ${tgt_isa} -g"
1123
1124           add_cflags -arch ${tgt_isa}
1125           add_ldflags -arch ${tgt_isa}
1126
1127           alt_libc="$(show_darwin_sdk_path iphoneos)"
1128           if [ -d "${alt_libc}" ]; then
1129             add_cflags -isysroot ${alt_libc}
1130           fi
1131
1132           if [ "${LD}" = "${CXX}" ]; then
1133             add_ldflags -miphoneos-version-min="${IOS_VERSION_MIN}"
1134           else
1135             add_ldflags -ios_version_min "${IOS_VERSION_MIN}"
1136           fi
1137
1138           for d in lib usr/lib usr/lib/system; do
1139             try_dir="${alt_libc}/${d}"
1140             [ -d "${try_dir}" ] && add_ldflags -L"${try_dir}"
1141           done
1142
1143           case ${tgt_isa} in
1144             armv7|armv7s|armv8|arm64)
1145               if enabled neon && ! check_xcode_minimum_version; then
1146                 soft_disable neon
1147                 log_echo "  neon disabled: upgrade Xcode (need v6.3+)."
1148                 if enabled neon_asm; then
1149                   soft_disable neon_asm
1150                   log_echo "  neon_asm disabled: upgrade Xcode (need v6.3+)."
1151                 fi
1152               fi
1153               ;;
1154           esac
1155
1156           asm_conversion_cmd="${source_path}/build/make/ads2gas_apple.pl"
1157
1158           if [ "$(show_darwin_sdk_major_version iphoneos)" -gt 8 ]; then
1159             check_add_cflags -fembed-bitcode
1160             check_add_asflags -fembed-bitcode
1161             check_add_ldflags -fembed-bitcode
1162           fi
1163           ;;
1164
1165         linux*)
1166           enable_feature linux
1167           if enabled rvct; then
1168             # Check if we have CodeSourcery GCC in PATH. Needed for
1169             # libraries
1170             which arm-none-linux-gnueabi-gcc 2>&- || \
1171               die "Couldn't find CodeSourcery GCC from PATH"
1172
1173             # Use armcc as a linker to enable translation of
1174             # some gcc specific options such as -lm and -lpthread.
1175             LD="armcc --translate_gcc"
1176
1177             # create configuration file (uses path to CodeSourcery GCC)
1178             armcc --arm_linux_configure --arm_linux_config_file=arm_linux.cfg
1179
1180             add_cflags --arm_linux_paths --arm_linux_config_file=arm_linux.cfg
1181             add_asflags --no_hide_all --apcs=/interwork
1182             add_ldflags --arm_linux_paths --arm_linux_config_file=arm_linux.cfg
1183             enabled pic && add_cflags --apcs=/fpic
1184             enabled pic && add_asflags --apcs=/fpic
1185             enabled shared && add_cflags --shared
1186           fi
1187           ;;
1188       esac
1189       ;;
1190     mips*)
1191       link_with_cc=gcc
1192       setup_gnu_toolchain
1193       tune_cflags="-mtune="
1194       if enabled dspr2; then
1195         check_add_cflags -mips32r2 -mdspr2
1196       fi
1197
1198       if enabled runtime_cpu_detect; then
1199         disable_feature runtime_cpu_detect
1200       fi
1201
1202       if [ -n "${tune_cpu}" ]; then
1203         case ${tune_cpu} in
1204           p5600)
1205             check_add_cflags -mips32r5 -mload-store-pairs
1206             check_add_cflags -msched-weight -mhard-float -mfp64
1207             check_add_asflags -mips32r5 -mhard-float -mfp64
1208             check_add_ldflags -mfp64
1209             ;;
1210           i6400|p6600)
1211             check_add_cflags -mips64r6 -mabi=64 -msched-weight
1212             check_add_cflags  -mload-store-pairs -mhard-float -mfp64
1213             check_add_asflags -mips64r6 -mabi=64 -mhard-float -mfp64
1214             check_add_ldflags -mips64r6 -mabi=64 -mfp64
1215             ;;
1216         esac
1217
1218         if enabled msa; then
1219           # TODO(libyuv:793)
1220           # The new mips functions in libyuv do not build
1221           # with the toolchains we currently use for testing.
1222           soft_disable libyuv
1223
1224           add_cflags -mmsa
1225           add_asflags -mmsa
1226           add_ldflags -mmsa
1227         fi
1228       fi
1229
1230       if enabled mmi; then
1231         tgt_isa=loongson3a
1232         check_add_ldflags -march=loongson3a
1233       fi
1234
1235       check_add_cflags -march=${tgt_isa}
1236       check_add_asflags -march=${tgt_isa}
1237       check_add_asflags -KPIC
1238       ;;
1239     ppc64le*)
1240       link_with_cc=gcc
1241       setup_gnu_toolchain
1242       # Do not enable vsx by default.
1243       # https://bugs.chromium.org/p/webm/issues/detail?id=1522
1244       enabled vsx || RTCD_OPTIONS="${RTCD_OPTIONS}--disable-vsx "
1245       if [ -n "${tune_cpu}" ]; then
1246         case ${tune_cpu} in
1247           power?)
1248             tune_cflags="-mcpu="
1249             ;;
1250         esac
1251       fi
1252       ;;
1253     x86*)
1254       case  ${tgt_os} in
1255         android)
1256           soft_enable realtime_only
1257           ;;
1258         win*)
1259           enabled gcc && add_cflags -fno-common
1260           ;;
1261         solaris*)
1262           CC=${CC:-${CROSS}gcc}
1263           CXX=${CXX:-${CROSS}g++}
1264           LD=${LD:-${CROSS}gcc}
1265           CROSS=${CROSS-g}
1266           ;;
1267         os2)
1268           disable_feature pic
1269           AS=${AS:-nasm}
1270           add_ldflags -Zhigh-mem
1271           ;;
1272       esac
1273
1274       AS="${alt_as:-${AS:-auto}}"
1275       case  ${tgt_cc} in
1276         icc*)
1277           CC=${CC:-icc}
1278           LD=${LD:-icc}
1279           setup_gnu_toolchain
1280           add_cflags -use-msasm  # remove -use-msasm too?
1281           # add -no-intel-extensions to suppress warning #10237
1282           # refer to http://software.intel.com/en-us/forums/topic/280199
1283           add_ldflags -i-static -no-intel-extensions
1284           enabled x86_64 && add_cflags -ipo -static -O3 -no-prec-div
1285           enabled x86_64 && AR=xiar
1286           case ${tune_cpu} in
1287             atom*)
1288               tune_cflags="-x"
1289               tune_cpu="SSE3_ATOM"
1290               ;;
1291             *)
1292               tune_cflags="-march="
1293               ;;
1294           esac
1295           ;;
1296         gcc*)
1297           link_with_cc=gcc
1298           tune_cflags="-march="
1299           setup_gnu_toolchain
1300           #for 32 bit x86 builds, -O3 did not turn on this flag
1301           enabled optimizations && disabled gprof && check_add_cflags -fomit-frame-pointer
1302           ;;
1303         vs*)
1304           # When building with Microsoft Visual Studio the assembler is
1305           # invoked directly. Checking at configure time is unnecessary.
1306           # Skip the check by setting AS arbitrarily
1307           AS=msvs
1308           msvs_arch_dir=x86-msvs
1309           case ${tgt_cc##vs} in
1310             14)
1311               echo "${tgt_cc} does not support avx512, disabling....."
1312               RTCD_OPTIONS="${RTCD_OPTIONS}--disable-avx512 "
1313               soft_disable avx512
1314               ;;
1315           esac
1316           ;;
1317       esac
1318
1319       bits=32
1320       enabled x86_64 && bits=64
1321       check_cpp <<EOF && bits=x32
1322 #if !defined(__ILP32__) || !defined(__x86_64__)
1323 #error "not x32"
1324 #endif
1325 EOF
1326       case ${tgt_cc} in
1327         gcc*)
1328           add_cflags -m${bits}
1329           add_ldflags -m${bits}
1330           ;;
1331       esac
1332
1333       soft_enable runtime_cpu_detect
1334       # We can't use 'check_cflags' until the compiler is configured and CC is
1335       # populated.
1336       for ext in ${ARCH_EXT_LIST_X86}; do
1337         # disable higher order extensions to simplify asm dependencies
1338         if [ "$disable_exts" = "yes" ]; then
1339           if ! disabled $ext; then
1340             RTCD_OPTIONS="${RTCD_OPTIONS}--disable-${ext} "
1341             disable_feature $ext
1342           fi
1343         elif disabled $ext; then
1344           disable_exts="yes"
1345         else
1346           if [ "$ext" = "avx512" ]; then
1347             check_gcc_machine_options $ext avx512f avx512cd avx512bw avx512dq avx512vl
1348             check_gcc_avx512_compiles
1349           else
1350             # use the shortened version for the flag: sse4_1 -> sse4
1351             check_gcc_machine_option ${ext%_*} $ext
1352           fi
1353         fi
1354       done
1355
1356       if enabled external_build; then
1357         log_echo "  skipping assembler detection"
1358       else
1359         case "${AS}" in
1360           auto|"")
1361             which nasm >/dev/null 2>&1 && AS=nasm
1362             which yasm >/dev/null 2>&1 && AS=yasm
1363             if [ "${AS}" = nasm ] ; then
1364               # Apple ships version 0.98 of nasm through at least Xcode 6. Revisit
1365               # this check if they start shipping a compatible version.
1366               apple=`nasm -v | grep "Apple"`
1367               [ -n "${apple}" ] \
1368                 && echo "Unsupported version of nasm: ${apple}" \
1369                 && AS=""
1370             fi
1371             [ "${AS}" = auto ] || [ -z "${AS}" ] \
1372               && die "Neither yasm nor nasm have been found." \
1373                      "See the prerequisites section in the README for more info."
1374             ;;
1375         esac
1376         log_echo "  using $AS"
1377       fi
1378       AS_SFX=.asm
1379       case  ${tgt_os} in
1380         win32)
1381           add_asflags -f win32
1382           enabled debug && add_asflags -g cv8
1383           EXE_SFX=.exe
1384           ;;
1385         win64)
1386           add_asflags -f win64
1387           enabled debug && add_asflags -g cv8
1388           EXE_SFX=.exe
1389           ;;
1390         linux*|solaris*|android*)
1391           add_asflags -f elf${bits}
1392           enabled debug && [ "${AS}" = yasm ] && add_asflags -g dwarf2
1393           enabled debug && [ "${AS}" = nasm ] && add_asflags -g
1394           [ "${AS##*/}" = nasm ] && check_asm_align
1395           ;;
1396         darwin*)
1397           add_asflags -f macho${bits}
1398           enabled x86 && darwin_arch="-arch i386" || darwin_arch="-arch x86_64"
1399           add_cflags  ${darwin_arch}
1400           add_ldflags ${darwin_arch}
1401           # -mdynamic-no-pic is still a bit of voodoo -- it was required at
1402           # one time, but does not seem to be now, and it breaks some of the
1403           # code that still relies on inline assembly.
1404           # enabled icc && ! enabled pic && add_cflags -fno-pic -mdynamic-no-pic
1405           enabled icc && ! enabled pic && add_cflags -fno-pic
1406           ;;
1407         iphonesimulator)
1408           add_asflags -f macho${bits}
1409           enabled x86 && sim_arch="-arch i386" || sim_arch="-arch x86_64"
1410           add_cflags  ${sim_arch}
1411           add_ldflags ${sim_arch}
1412
1413           if [ "$(disabled external_build)" ] &&
1414               [ "$(show_darwin_sdk_major_version iphonesimulator)" -gt 8 ]; then
1415             # yasm v1.3.0 doesn't know what -fembed-bitcode means, so turning it
1416             # on is pointless (unless building a C-only lib). Warn the user, but
1417             # do nothing here.
1418             log "Warning: Bitcode embed disabled for simulator targets."
1419           fi
1420           ;;
1421         os2)
1422           add_asflags -f aout
1423           enabled debug && add_asflags -g
1424           EXE_SFX=.exe
1425           ;;
1426         *)
1427           log "Warning: Unknown os $tgt_os while setting up $AS flags"
1428           ;;
1429       esac
1430       ;;
1431     *-gcc|generic-gnu)
1432       link_with_cc=gcc
1433       enable_feature gcc
1434       setup_gnu_toolchain
1435       ;;
1436   esac
1437
1438   # Try to enable CPU specific tuning
1439   if [ -n "${tune_cpu}" ]; then
1440     if [ -n "${tune_cflags}" ]; then
1441       check_add_cflags ${tune_cflags}${tune_cpu} || \
1442         die "Requested CPU '${tune_cpu}' not supported by compiler"
1443     fi
1444     if [ -n "${tune_asflags}" ]; then
1445       check_add_asflags ${tune_asflags}${tune_cpu} || \
1446         die "Requested CPU '${tune_cpu}' not supported by assembler"
1447     fi
1448     if [ -z "${tune_cflags}${tune_asflags}" ]; then
1449       log_echo "Warning: CPU tuning not supported by this toolchain"
1450     fi
1451   fi
1452
1453   if enabled debug; then
1454     check_add_cflags -g && check_add_ldflags -g
1455   else
1456     check_add_cflags -DNDEBUG
1457   fi
1458
1459   enabled gprof && check_add_cflags -pg && check_add_ldflags -pg
1460   enabled gcov &&
1461     check_add_cflags -fprofile-arcs -ftest-coverage &&
1462     check_add_ldflags -fprofile-arcs -ftest-coverage
1463
1464   if enabled optimizations; then
1465     if enabled rvct; then
1466       enabled small && check_add_cflags -Ospace || check_add_cflags -Otime
1467     else
1468       enabled small && check_add_cflags -O2 ||  check_add_cflags -O3
1469     fi
1470   fi
1471
1472   # Position Independent Code (PIC) support, for building relocatable
1473   # shared objects
1474   enabled gcc && enabled pic && check_add_cflags -fPIC
1475
1476   # Work around longjmp interception on glibc >= 2.11, to improve binary
1477   # compatibility. See http://code.google.com/p/webm/issues/detail?id=166
1478   enabled linux && check_add_cflags -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=0
1479
1480   # Check for strip utility variant
1481   ${STRIP} -V 2>/dev/null | grep GNU >/dev/null && enable_feature gnu_strip
1482
1483   # Try to determine target endianness
1484   check_cc <<EOF
1485 unsigned int e = 'O'<<24 | '2'<<16 | 'B'<<8 | 'E';
1486 EOF
1487     [ -f "${TMP_O}" ] && od -A n -t x1 "${TMP_O}" | tr -d '\n' |
1488         grep '4f *32 *42 *45' >/dev/null 2>&1 && enable_feature big_endian
1489
1490     # Try to find which inline keywords are supported
1491     check_cc <<EOF && INLINE="inline"
1492 static inline function() {}
1493 EOF
1494
1495   # Almost every platform uses pthreads.
1496   if enabled multithread; then
1497     case ${toolchain} in
1498       *-win*-vs*)
1499         ;;
1500       *-android-gcc)
1501         # bionic includes basic pthread functionality, obviating -lpthread.
1502         ;;
1503       *)
1504         check_header pthread.h && check_lib -lpthread <<EOF && add_extralibs -lpthread || disable_feature pthread_h
1505 #include <pthread.h>
1506 #include <stddef.h>
1507 int main(void) { return pthread_create(NULL, NULL, NULL, NULL); }
1508 EOF
1509         ;;
1510     esac
1511   fi
1512
1513   # only for MIPS platforms
1514   case ${toolchain} in
1515     mips*)
1516       if enabled big_endian; then
1517         if enabled dspr2; then
1518           echo "dspr2 optimizations are available only for little endian platforms"
1519           disable_feature dspr2
1520         fi
1521         if enabled msa; then
1522           echo "msa optimizations are available only for little endian platforms"
1523           disable_feature msa
1524         fi
1525         if enabled mmi; then
1526           echo "mmi optimizations are available only for little endian platforms"
1527           disable_feature mmi
1528         fi
1529       fi
1530       ;;
1531   esac
1532
1533   # glibc needs these
1534   if enabled linux; then
1535     add_cflags -D_LARGEFILE_SOURCE
1536     add_cflags -D_FILE_OFFSET_BITS=64
1537   fi
1538 }
1539
1540 process_toolchain() {
1541   process_common_toolchain
1542 }
1543
1544 print_config_mk() {
1545   saved_prefix="${prefix}"
1546   prefix=$1
1547   makefile=$2
1548   shift 2
1549   for cfg; do
1550     if enabled $cfg; then
1551       upname="`toupper $cfg`"
1552       echo "${prefix}_${upname}=yes" >> $makefile
1553     fi
1554   done
1555   prefix="${saved_prefix}"
1556 }
1557
1558 print_config_h() {
1559   saved_prefix="${prefix}"
1560   prefix=$1
1561   header=$2
1562   shift 2
1563   for cfg; do
1564     upname="`toupper $cfg`"
1565     if enabled $cfg; then
1566       echo "#define ${prefix}_${upname} 1" >> $header
1567     else
1568       echo "#define ${prefix}_${upname} 0" >> $header
1569     fi
1570   done
1571   prefix="${saved_prefix}"
1572 }
1573
1574 print_config_vars_h() {
1575   header=$1
1576   shift
1577   while [ $# -gt 0 ]; do
1578     upname="`toupper $1`"
1579     echo "#define ${upname} $2" >> $header
1580     shift 2
1581   done
1582 }
1583
1584 print_webm_license() {
1585   saved_prefix="${prefix}"
1586   destination=$1
1587   prefix="$2"
1588   suffix="$3"
1589   shift 3
1590   cat <<EOF > ${destination}
1591 ${prefix} Copyright (c) 2011 The WebM project authors. All Rights Reserved.${suffix}
1592 ${prefix} ${suffix}
1593 ${prefix} Use of this source code is governed by a BSD-style license${suffix}
1594 ${prefix} that can be found in the LICENSE file in the root of the source${suffix}
1595 ${prefix} tree. An additional intellectual property rights grant can be found${suffix}
1596 ${prefix} in the file PATENTS.  All contributing project authors may${suffix}
1597 ${prefix} be found in the AUTHORS file in the root of the source tree.${suffix}
1598 EOF
1599   prefix="${saved_prefix}"
1600 }
1601
1602 process_targets() {
1603   true;
1604 }
1605
1606 process_detect() {
1607   true;
1608 }
1609
1610 enable_feature logging
1611 logfile="config.log"
1612 self=$0
1613 process() {
1614   cmdline_args="$@"
1615   process_cmdline "$@"
1616   if enabled child; then
1617     echo "# ${self} $@" >> ${logfile}
1618   else
1619     echo "# ${self} $@" > ${logfile}
1620   fi
1621   post_process_common_cmdline
1622   post_process_cmdline
1623   process_toolchain
1624   process_detect
1625   process_targets
1626
1627   OOT_INSTALLS="${OOT_INSTALLS}"
1628   if enabled source_path_used; then
1629   # Prepare the PWD for building.
1630   for f in ${OOT_INSTALLS}; do
1631     install -D "${source_path}/$f" "$f"
1632   done
1633   fi
1634   cp "${source_path}/build/make/Makefile" .
1635
1636   clean_temp_files
1637   true
1638 }