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