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