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#
16die_unknown(){
17  echo "Unknown option \"$1\"."
18  echo "See $0 --help for available options."
19  clean_temp_files
20  exit 1
21}
22
23die() {
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
35log(){
36  echo "$@" >>$logfile
37}
38
39log_file(){
40  log BEGIN $1
41  cat -n $1 >>$logfile
42  log END $1
43}
44
45log_echo() {
46  echo "$@"
47  log "$@"
48}
49
50fwrite () {
51  outfile=$1
52  shift
53  echo "$@" >> ${outfile}
54}
55
56show_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
67Usage: configure [options]
68Options:
69
70Build 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
90Install 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
97EOF
98}
99
100show_help_post(){
101  cat <<EOF
102
103
104NOTES:
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
111Supported targets:
112EOF
113  show_targets ${all_platforms}
114  echo
115  exit 1
116}
117
118show_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
135show_help() {
136  show_help_pre
137  show_help_post
138}
139
140#
141# List Processing Functions
142#
143set_all(){
144  value=$1
145  shift
146  for var in $*; do
147    eval $var=$value
148  done
149}
150
151is_in(){
152  value=$1
153  shift
154  for var in $*; do
155    [ $var = $value ] && return 0
156  done
157  return 1
158}
159
160add_cflags() {
161  CFLAGS="${CFLAGS} $@"
162  CXXFLAGS="${CXXFLAGS} $@"
163}
164
165add_cflags_only() {
166  CFLAGS="${CFLAGS} $@"
167}
168
169add_cxxflags_only() {
170  CXXFLAGS="${CXXFLAGS} $@"
171}
172
173add_ldflags() {
174  LDFLAGS="${LDFLAGS} $@"
175}
176
177add_asflags() {
178  ASFLAGS="${ASFLAGS} $@"
179}
180
181add_extralibs() {
182  extralibs="${extralibs} $@"
183}
184
185#
186# Boolean Manipulation Functions
187#
188
189enable_feature(){
190  set_all yes $*
191}
192
193disable_feature(){
194  set_all no $*
195}
196
197enabled(){
198  eval test "x\$$1" = "xyes"
199}
200
201disabled(){
202  eval test "x\$$1" = "xno"
203}
204
205enable_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
212disable_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).
223soft_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).
236soft_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#
248toupper(){
249  echo "$@" | tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ
250}
251
252tolower(){
253  echo "$@" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz
254}
255
256#
257# Temporary File Functions
258#
259source_path=${0%/*}
260enable_feature source_path_used
261if [ -z "$source_path" ] || [ "$source_path" = "." ]; then
262  source_path="`pwd`"
263  disable_feature source_path_used
264fi
265
266if test ! -z "$TMPDIR" ; then
267  TMPDIRx="${TMPDIR}"
268elif test ! -z "$TEMPDIR" ; then
269  TMPDIRx="${TEMPDIR}"
270else
271  TMPDIRx="/tmp"
272fi
273RAND=$(awk 'BEGIN { srand(); printf "%d\n",(rand() * 32768)}')
274TMP_H="${TMPDIRx}/vpx-conf-$$-${RAND}.h"
275TMP_C="${TMPDIRx}/vpx-conf-$$-${RAND}.c"
276TMP_CC="${TMPDIRx}/vpx-conf-$$-${RAND}.cc"
277TMP_O="${TMPDIRx}/vpx-conf-$$-${RAND}.o"
278TMP_X="${TMPDIRx}/vpx-conf-$$-${RAND}.x"
279TMP_ASM="${TMPDIRx}/vpx-conf-$$-${RAND}.asm"
280
281clean_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#
289check_cmd() {
290  enabled external_build && return
291  log "$@"
292  "$@" >>${logfile} 2>&1
293}
294
295check_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
302check_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
309check_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
316check_ld() {
317  log check_ld "$@"
318  check_cc $@ \
319    && check_cmd ${LD} ${LDFLAGS} "$@" -o ${TMP_X} ${TMP_O} ${extralibs}
320}
321
322check_lib() {
323  log check_lib "$@"
324  check_cc $@ \
325    && check_cmd ${LD} ${LDFLAGS} -o ${TMP_X} ${TMP_O} "$@" ${extralibs}
326}
327
328check_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"
336int x;
337EOF
338}
339
340check_cflags() {
341 log check_cflags "$@"
342 check_cc -Werror "$@" <<EOF
343int x;
344EOF
345}
346
347check_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
354int x;
355EOF
356      ;;
357    *)
358      check_cxx -Werror "$@" <<EOF
359int x;
360EOF
361      ;;
362    esac
363}
364
365check_add_cflags() {
366  check_cxxflags "$@" && add_cxxflags_only "$@"
367  check_cflags "$@" && add_cflags_only "$@"
368}
369
370check_add_cxxflags() {
371  check_cxxflags "$@" && add_cxxflags_only "$@"
372}
373
374check_add_asflags() {
375  log add_asflags "$@"
376  add_asflags "$@"
377}
378
379check_add_ldflags() {
380  log add_ldflags "$@"
381  add_ldflags "$@"
382}
383
384check_asm_align() {
385  log check_asm_align "$@"
386  cat >${TMP_ASM} <<EOF
387section .rodata
388align 16
389EOF
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.
400check_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.
413check_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
429check_gcc_avx512_compiles() {
430  if disabled gcc; then
431    return
432  fi
433
434  check_cc -mavx512f <<EOF
435#include <immintrin.h>
436void f(void) {
437  __m512i x = _mm512_set1_epi16(0);
438  (void)x;
439}
440EOF
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
449write_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
461write_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
475write_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!
484SRC_PATH="$source_path"
485SRC_PATH_BARE=$source_path
486BUILD_PFX=${BUILD_PFX}
487TOOLCHAIN=${toolchain}
488ASM_CONVERSION=${asm_conversion_cmd:-${source_path}/build/make/ads2gas.pl}
489GEN_VCPROJ=${gen_vcproj_cmd}
490MSVS_ARCH_DIR=${msvs_arch_dir}
491
492CC=${CC}
493CXX=${CXX}
494AR=${AR}
495LD=${LD}
496AS=${AS}
497STRIP=${STRIP}
498NM=${NM}
499
500CFLAGS  = ${CFLAGS}
501CXXFLAGS  = ${CXXFLAGS}
502ARFLAGS = -crs\$(if \$(quiet),,v)
503LDFLAGS = ${LDFLAGS}
504ASFLAGS = ${ASFLAGS}
505extralibs = ${extralibs}
506AS_SFX    = ${AS_SFX:-.asm}
507EXE_SFX   = ${EXE_SFX}
508VCPROJ_SFX = ${VCPROJ_SFX}
509RTCD_OPTIONS = ${RTCD_OPTIONS}
510LIBYUV_CXXFLAGS = ${LIBYUV_CXXFLAGS}
511EOF
512
513  if enabled rvct; then cat >> $1 << EOF
514fmt_deps = sed -e 's;^__image.axf;\${@:.d=.o} \$@;' #hide
515EOF
516  else cat >> $1 << EOF
517fmt_deps = sed -e 's;^\([a-zA-Z0-9_]*\)\.o;\${@:.d=.o} \$@;'
518EOF
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
532write_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}
540EOF
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
550write_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 */
563EOF
564  mkdir -p `dirname "$1"`
565  cmp "$1" ${TMP_H} >/dev/null 2>&1 || mv ${TMP_H} "$1"
566}
567
568process_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
663process_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
674post_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
684post_process_cmdline() {
685  true;
686}
687
688setup_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.)
702show_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.
708show_darwin_sdk_major_version() {
709  xcrun --sdk $1 --show-sdk-version 2>/dev/null | cut -d. -f1
710}
711
712# Print the Xcode version.
713show_xcode_version() {
714  xcodebuild -version | head -n1 | cut -d' ' -f2
715}
716
717# Fails when Xcode version is less than 6.3.
718check_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
732process_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
965EOF
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            if [ "$(show_darwin_sdk_major_version iphoneos)" -gt 8 ]; then
1134              check_add_cflags -fembed-bitcode
1135              check_add_asflags -fembed-bitcode
1136              check_add_ldflags -fembed-bitcode
1137            fi
1138          fi
1139
1140          asm_conversion_cmd="${source_path}/build/make/ads2gas_apple.pl"
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
1303EOF
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
1463unsigned int e = 'O'<<24 | '2'<<16 | 'B'<<8 | 'E';
1464EOF
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"
1470static inline function() {}
1471EOF
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>
1485int main(void) { return pthread_create(NULL, NULL, NULL, NULL); }
1486EOF
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
1518process_toolchain() {
1519  process_common_toolchain
1520}
1521
1522print_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
1536print_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
1552print_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
1562print_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}
1576EOF
1577  prefix="${saved_prefix}"
1578}
1579
1580process_targets() {
1581  true;
1582}
1583
1584process_detect() {
1585  true;
1586}
1587
1588enable_feature logging
1589logfile="config.log"
1590self=$0
1591process() {
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}
1617