| # configure.ac for GCC |
| # Process this file with autoconf to generate a configuration script. |
| |
| # Copyright (C) 1997-2021 Free Software Foundation, Inc. |
| |
| #This file is part of GCC. |
| |
| #GCC is free software; you can redistribute it and/or modify it under |
| #the terms of the GNU General Public License as published by the Free |
| #Software Foundation; either version 3, or (at your option) any later |
| #version. |
| |
| #GCC is distributed in the hope that it will be useful, but WITHOUT |
| #ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| #FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| #for more details. |
| |
| #You should have received a copy of the GNU General Public License |
| #along with GCC; see the file COPYING3. If not see |
| #<http://www.gnu.org/licenses/>. |
| |
| # -------------------------------- |
| # Initialization and sanity checks |
| # -------------------------------- |
| |
| AC_INIT |
| AC_CONFIG_SRCDIR(tree.c) |
| AC_CONFIG_HEADER(auto-host.h:config.in) |
| |
| gcc_version=`cat $srcdir/BASE-VER` |
| |
| # Determine the host, build, and target systems |
| AC_CANONICAL_BUILD |
| AC_CANONICAL_HOST |
| AC_CANONICAL_TARGET |
| |
| # Determine the noncanonical host name, for Ada. |
| ACX_NONCANONICAL_HOST |
| |
| # Determine the noncanonical target name, for directory use. |
| ACX_NONCANONICAL_TARGET |
| |
| # Used for constructing correct paths for offload compilers. |
| real_target_noncanonical=${target_noncanonical} |
| accel_dir_suffix= |
| |
| # Determine the target- and build-specific subdirectories |
| GCC_TOPLEV_SUBDIRS |
| |
| # Set program_transform_name |
| AC_ARG_PROGRAM |
| |
| # Check for bogus environment variables. |
| # Test if LIBRARY_PATH contains the notation for the current directory |
| # since this would lead to problems installing/building glibc. |
| # LIBRARY_PATH contains the current directory if one of the following |
| # is true: |
| # - one of the terminals (":" and ";") is the first or last sign |
| # - two terminals occur directly after each other |
| # - the path contains an element with a dot in it |
| AC_MSG_CHECKING(LIBRARY_PATH variable) |
| changequote(,)dnl |
| case ${LIBRARY_PATH} in |
| [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* ) |
| library_path_setting="contains current directory" |
| ;; |
| *) |
| library_path_setting="ok" |
| ;; |
| esac |
| changequote([,])dnl |
| AC_MSG_RESULT($library_path_setting) |
| if test "$library_path_setting" != "ok"; then |
| AC_MSG_ERROR([ |
| *** LIBRARY_PATH shouldn't contain the current directory when |
| *** building gcc. Please change the environment variable |
| *** and run configure again.]) |
| fi |
| |
| # Test if GCC_EXEC_PREFIX contains the notation for the current directory |
| # since this would lead to problems installing/building glibc. |
| # GCC_EXEC_PREFIX contains the current directory if one of the following |
| # is true: |
| # - one of the terminals (":" and ";") is the first or last sign |
| # - two terminals occur directly after each other |
| # - the path contains an element with a dot in it |
| AC_MSG_CHECKING(GCC_EXEC_PREFIX variable) |
| changequote(,)dnl |
| case ${GCC_EXEC_PREFIX} in |
| [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* ) |
| gcc_exec_prefix_setting="contains current directory" |
| ;; |
| *) |
| gcc_exec_prefix_setting="ok" |
| ;; |
| esac |
| changequote([,])dnl |
| AC_MSG_RESULT($gcc_exec_prefix_setting) |
| if test "$gcc_exec_prefix_setting" != "ok"; then |
| AC_MSG_ERROR([ |
| *** GCC_EXEC_PREFIX shouldn't contain the current directory when |
| *** building gcc. Please change the environment variable |
| *** and run configure again.]) |
| fi |
| |
| # ----------- |
| # Directories |
| # ----------- |
| |
| # Specify the local prefix |
| local_prefix= |
| AC_ARG_WITH(local-prefix, |
| [AS_HELP_STRING([--with-local-prefix=DIR], |
| [specifies directory to put local include])], |
| [case "${withval}" in |
| yes) AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;; |
| no) ;; |
| *) local_prefix=$with_local_prefix ;; |
| esac]) |
| |
| # Default local prefix if it is empty |
| if test x$local_prefix = x; then |
| local_prefix=/usr/local |
| fi |
| |
| AC_ARG_WITH([native-system-header-dir], |
| [ --with-native-system-header-dir=dir |
| use dir as the directory to look for standard |
| system header files in. Defaults to /usr/include.], |
| [ |
| case ${with_native_system_header_dir} in |
| yes|no) AC_MSG_ERROR([bad value ${withval} given for --with-native-system-header-dir]) ;; |
| /* | [[A-Za-z]]:[[\\/]]*) ;; |
| *) AC_MSG_ERROR([--with-native-system-header-dir argument ${withval} must be an absolute directory]) ;; |
| esac |
| configured_native_system_header_dir="${withval}" |
| ], [configured_native_system_header_dir=]) |
| |
| AC_ARG_WITH(build-sysroot, |
| [AS_HELP_STRING([--with-build-sysroot=sysroot], |
| [use sysroot as the system root during the build])], |
| [if test x"$withval" != x ; then |
| SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval" |
| fi], |
| [SYSROOT_CFLAGS_FOR_TARGET=]) |
| AC_SUBST(SYSROOT_CFLAGS_FOR_TARGET) |
| |
| if test "x$prefix" = xNONE; then |
| test_prefix=/usr/local |
| else |
| test_prefix=$prefix |
| fi |
| if test "x$exec_prefix" = xNONE; then |
| test_exec_prefix=$test_prefix |
| else |
| test_exec_prefix=$exec_prefix |
| fi |
| |
| AC_ARG_WITH(sysroot, |
| [AS_HELP_STRING([[--with-sysroot[=DIR]]], |
| [search for usr/lib, usr/include, et al, within DIR])], |
| [ |
| case ${with_sysroot} in |
| /) ;; |
| */) with_sysroot=`echo $with_sysroot | sed 's,/$,,'` ;; |
| esac |
| case ${with_sysroot} in |
| yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;; |
| *) TARGET_SYSTEM_ROOT=$with_sysroot ;; |
| esac |
| |
| TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"' |
| CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)' |
| |
| case ${TARGET_SYSTEM_ROOT} in |
| "${test_prefix}"|"${test_prefix}/"*|\ |
| "${test_exec_prefix}"|"${test_exec_prefix}/"*|\ |
| '${prefix}'|'${prefix}/'*|\ |
| '${exec_prefix}'|'${exec_prefix}/'*) |
| t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE" |
| TARGET_SYSTEM_ROOT_DEFINE="$t" |
| ;; |
| esac |
| ], [ |
| TARGET_SYSTEM_ROOT= |
| TARGET_SYSTEM_ROOT_DEFINE= |
| CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include' |
| ]) |
| AC_SUBST(TARGET_SYSTEM_ROOT) |
| AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE) |
| AC_SUBST(CROSS_SYSTEM_HEADER_DIR) |
| |
| # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only |
| # passed in by the toplevel make and thus we'd get different behavior |
| # depending on where we built the sources. |
| gcc_gxx_include_dir= |
| # Specify the g++ header file directory |
| AC_ARG_WITH(gxx-include-dir, |
| [AS_HELP_STRING([--with-gxx-include-dir=DIR], |
| [specifies directory to put g++ header files])], |
| [case "${withval}" in |
| yes) AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;; |
| no) ;; |
| *) gcc_gxx_include_dir=$with_gxx_include_dir ;; |
| esac]) |
| |
| # If both --with-sysroot and --with-gxx-include-dir are passed, we interpolate |
| # the former in the latter and, upon success, compute gcc_gxx_include_dir as |
| # relative to the sysroot. |
| gcc_gxx_include_dir_add_sysroot=0 |
| |
| # This logic must match libstdc++-v3/acinclude.m4:GLIBCXX_EXPORT_INSTALL_INFO. |
| if test x${gcc_gxx_include_dir} = x; then |
| if test x${enable_version_specific_runtime_libs} = xyes; then |
| gcc_gxx_include_dir='${libsubdir}/include/c++' |
| else |
| libstdcxx_incdir='include/c++/$(version)' |
| if test x$host != x$target; then |
| libstdcxx_incdir="$target_alias/$libstdcxx_incdir" |
| fi |
| gcc_gxx_include_dir="\$(libsubdir)/\$(libsubdir_to_prefix)$libstdcxx_incdir" |
| fi |
| elif test "${with_sysroot+set}" = set; then |
| gcc_gxx_without_sysroot=`expr "${gcc_gxx_include_dir}" : "${with_sysroot}"'\(.*\)'` |
| if test "${gcc_gxx_without_sysroot}"; then |
| gcc_gxx_include_dir="${gcc_gxx_without_sysroot}" |
| gcc_gxx_include_dir_add_sysroot=1 |
| fi |
| fi |
| |
| # Configuration for an alternate set of C++ headers. |
| gcc_gxx_libcxx_include_dir= |
| # Specify the alternate g++ header file directory |
| AC_ARG_WITH(gxx-libcxx-include-dir, |
| [AS_HELP_STRING([--with-gxx-libcxx-include-dir=DIR], |
| [specifies directory to find libc++ header files])], |
| [case "${withval}" in |
| yes) AC_MSG_ERROR(bad value ${withval} given for libc++ include directory) ;; |
| no) ;; |
| *) gcc_gxx_libcxx_include_dir=$with_gxx_libcxx_include_dir ;; |
| esac]) |
| |
| # If both --with-sysroot and --with-gxx-libcxx-include-dir are passed, we |
| # check to see if the latter starts with the former and, upon success, compute |
| # gcc_gxx_libcxx_include_dir as relative to the sysroot. |
| gcc_gxx_libcxx_include_dir_add_sysroot=0 |
| |
| if test x${gcc_gxx_libcxx_include_dir} != x; then |
| AC_DEFINE(ENABLE_STDLIB_OPTION, 1, |
| [Define if the -stdlib= option should be enabled.]) |
| else |
| AC_DEFINE(ENABLE_STDLIB_OPTION, 0) |
| fi |
| # ??? This logic must match libstdc++-v3/acinclude.m4:GLIBCXX_EXPORT_INSTALL_INFO. |
| if test x${gcc_gxx_libcxx_include_dir} = x; then |
| if test x${enable_version_specific_runtime_libs} = xyes; then |
| gcc_gxx_libcxx_include_dir='${libsubdir}/libc++_include/c++/v1' |
| else |
| libcxx_incdir='libc++_include/c++/$(version)/v1' |
| if test x$host != x$target; then |
| libcxx_incdir="$target_alias/$libcxx_incdir" |
| fi |
| gcc_gxx_libcxx_include_dir="\$(libsubdir)/\$(libsubdir_to_prefix)$libcxx_incdir" |
| fi |
| elif test "${with_sysroot+set}" = set; then |
| gcc_gxx_libcxx_without_sysroot=`expr "${gcc_gxx_libcxx_include_dir}" : "${with_sysroot}"'\(.*\)'` |
| if test "${gcc_gxx_libcxx_without_sysroot}"; then |
| gcc_gxx_libcxx_include_dir="${gcc_gxx_libcxx_without_sysroot}" |
| gcc_gxx_libcxx_include_dir_add_sysroot=1 |
| fi |
| fi |
| |
| AC_ARG_WITH(cpp_install_dir, |
| [AC_HELP_STRING([--with-cpp-install-dir=DIR], |
| [install the user visible C preprocessor in DIR |
| (relative to PREFIX) as well as PREFIX/bin])], |
| [if test x$withval = xyes; then |
| AC_MSG_ERROR([option --with-cpp-install-dir requires an argument]) |
| elif test x$withval != xno; then |
| cpp_install_dir=$withval |
| fi]) |
| |
| # We would like to our source tree to be readonly. However when releases or |
| # pre-releases are generated, the flex/bison generated files as well as the |
| # various formats of manuals need to be included along with the rest of the |
| # sources. Therefore we have --enable-generated-files-in-srcdir to do |
| # just that. |
| |
| AC_MSG_CHECKING([whether to place generated files in the source directory]) |
| dnl generated-files-in-srcdir is disabled by default |
| AC_ARG_ENABLE(generated-files-in-srcdir, |
| [AS_HELP_STRING([--enable-generated-files-in-srcdir], |
| [put copies of generated files in source dir |
| intended for creating source tarballs for users |
| without texinfo bison or flex])], |
| generated_files_in_srcdir=$enableval, |
| generated_files_in_srcdir=no) |
| |
| AC_MSG_RESULT($generated_files_in_srcdir) |
| |
| if test "$generated_files_in_srcdir" = "yes"; then |
| GENINSRC='' |
| else |
| GENINSRC='#' |
| fi |
| AC_SUBST(GENINSRC) |
| |
| # ------------------- |
| # Find default linker |
| # ------------------- |
| |
| # With GNU ld |
| AC_ARG_WITH(gnu-ld, |
| [AS_HELP_STRING([--with-gnu-ld], [arrange to work with GNU ld])], |
| gnu_ld_flag="$with_gnu_ld", |
| gnu_ld_flag=no) |
| |
| case $target in |
| *darwin*) ld64_flag=yes;; # Darwin can only use a ld64-compatible linker. |
| *) ld64_flag=no;; |
| esac |
| |
| # With pre-defined ld |
| AC_ARG_WITH(ld, |
| [AS_HELP_STRING([--with-ld], [arrange to use the specified ld (full pathname)])], |
| DEFAULT_LINKER="$with_ld") |
| if test x"${DEFAULT_LINKER+set}" = x"set"; then |
| if test ! -x "$DEFAULT_LINKER"; then |
| AC_MSG_ERROR([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER]) |
| elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then |
| gnu_ld_flag=yes |
| elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep ld64- > /dev/null; then |
| ld64_flag=yes |
| fi |
| AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER", |
| [Define to enable the use of a default linker.]) |
| fi |
| |
| AC_MSG_CHECKING([whether a default linker was specified]) |
| if test x"${DEFAULT_LINKER+set}" = x"set"; then |
| if test x"$gnu_ld_flag" = x"no"; then |
| AC_MSG_RESULT([yes ($DEFAULT_LINKER)]) |
| else |
| AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)]) |
| fi |
| else |
| AC_MSG_RESULT(no) |
| fi |
| |
| # With demangler in GNU ld |
| AC_ARG_WITH(demangler-in-ld, |
| [AS_HELP_STRING([--with-demangler-in-ld], [try to use demangler in GNU ld])], |
| demangler_in_ld="$with_demangler_in_ld", |
| demangler_in_ld=yes) |
| |
| # ---------------------- |
| # Find default assembler |
| # ---------------------- |
| |
| # With GNU as |
| AC_ARG_WITH(gnu-as, |
| [AS_HELP_STRING([--with-gnu-as], [arrange to work with GNU as])], |
| gas_flag="$with_gnu_as", |
| gas_flag=no) |
| |
| AC_ARG_WITH(as, |
| [AS_HELP_STRING([--with-as], [arrange to use the specified as (full pathname)])], |
| DEFAULT_ASSEMBLER="$with_as") |
| if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then |
| if test ! -x "$DEFAULT_ASSEMBLER"; then |
| AC_MSG_ERROR([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER]) |
| elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then |
| gas_flag=yes |
| fi |
| AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER", |
| [Define to enable the use of a default assembler.]) |
| fi |
| |
| AC_MSG_CHECKING([whether a default assembler was specified]) |
| if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then |
| if test x"$gas_flag" = x"no"; then |
| AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)]) |
| else |
| AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)]) |
| fi |
| else |
| AC_MSG_RESULT(no) |
| fi |
| |
| # --------------- |
| # Find C compiler |
| # --------------- |
| |
| # If a non-executable a.out is present (e.g. created by GNU as above even if |
| # invoked with -v only), the IRIX 6 native ld just overwrites the existing |
| # file, even when creating an executable, so an execution test fails. |
| # Remove possible default executable files to avoid this. |
| # |
| # FIXME: This really belongs into AC_PROG_CC and can be removed once |
| # Autoconf includes it. |
| rm -f a.out a.exe b.out |
| |
| # Find the native compiler |
| AC_PROG_CC |
| AC_PROG_CXX |
| ACX_PROG_GNAT([-I"$srcdir"/ada/libgnat]) |
| |
| # Do configure tests with the C++ compiler, since that's what we build with. |
| AC_LANG(C++) |
| |
| # Remove the -O2: for historical reasons, unless bootstrapping we prefer |
| # optimizations to be activated explicitly by the toplevel. |
| case "$CC" in |
| */prev-gcc/xgcc*) ;; |
| *) CFLAGS=`echo "$CFLAGS " | sed -e "s/-Ofast[[ ]]//" -e "s/-O[[gs]][[ ]]//" -e "s/-O[[0-9]]*[[ ]]//" ` |
| CXXFLAGS=`echo "$CXXFLAGS " | sed -e "s/-Ofast[[ ]]//" -e "s/-O[[gs]][[ ]]//" -e "s/-O[[0-9]]*[[ ]]//" ` ;; |
| esac |
| AC_SUBST(CFLAGS) |
| AC_SUBST(CXXFLAGS) |
| |
| # Determine PICFLAG for target gnatlib. |
| GCC_PICFLAG_FOR_TARGET |
| AC_SUBST(PICFLAG_FOR_TARGET) |
| |
| # ------------------------- |
| # Check C compiler features |
| # ------------------------- |
| |
| AC_USE_SYSTEM_EXTENSIONS |
| |
| AC_PROG_CPP |
| AC_C_INLINE |
| |
| AC_SYS_LARGEFILE |
| |
| # sizeof(char) is 1 by definition. |
| AC_CHECK_SIZEOF(void *) |
| AC_CHECK_SIZEOF(short) |
| AC_CHECK_SIZEOF(int) |
| AC_CHECK_SIZEOF(long) |
| AC_CHECK_TYPES([long long], [AC_CHECK_SIZEOF(long long)]) |
| GCC_STDINT_TYPES |
| if test x"$ac_cv_c_uint64_t" = x"no" -o x"$ac_cv_c_int64_t" = x"no"; then |
| AC_MSG_ERROR([uint64_t or int64_t not found]) |
| fi |
| |
| # check what underlying integer type int64_t uses |
| AC_CACHE_CHECK(for int64_t underlying type, ac_cv_int64_t_type, [ |
| AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ |
| #ifdef HAVE_STDINT_H |
| #include <stdint.h> |
| #endif |
| template <typename T> struct X { }; |
| template <> |
| struct X<long> { typedef long t; }; |
| ]], [[X<int64_t>::t x;]])],[ac_cv_int64_t_type=long],[ac_cv_int64_t_type="long long"])]) |
| if test "$ac_cv_int64_t_type" = "long"; then |
| AC_DEFINE(INT64_T_IS_LONG, 1, |
| [Define if int64_t uses long as underlying type.]) |
| else |
| AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ |
| #ifdef HAVE_STDINT_H |
| #include <stdint.h> |
| #endif |
| template <typename T> struct X { }; |
| template <> |
| struct X<long long> { typedef long long t; }; |
| ]], [[X<int64_t>::t x;]])],[],[AC_MSG_ERROR([error verifying int64_t uses long long])]) |
| fi |
| |
| AC_CACHE_CHECK(for std::swap in <utility>, ac_cv_std_swap_in_utility, [ |
| AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ |
| #include <utility> |
| ]], [[int a, b; std::swap(a,b);]])],[ac_cv_std_swap_in_utility=yes],[ac_cv_std_swap_in_utility=no])]) |
| if test $ac_cv_std_swap_in_utility = yes; then |
| AC_DEFINE(HAVE_SWAP_IN_UTILITY, 1, |
| [Define if <utility> defines std::swap.]) |
| fi |
| |
| # Check whether compiler is affected by placement new aliasing bug (PR 29286). |
| # If the host compiler is affected by the bug, and we build with optimization |
| # enabled (which happens e.g. when cross-compiling), the pool allocator may |
| # get miscompiled. Use -fno-strict-aliasing to work around this problem. |
| # Since there is no reliable feature check for the presence of this bug, |
| # we simply use a GCC version number check. (This should never trigger for |
| # stages 2 or 3 of a native bootstrap.) |
| aliasing_flags= |
| if test "$GCC" = yes; then |
| saved_CXXFLAGS="$CXXFLAGS" |
| |
| # The following test compilation will succeed if and only if $CXX accepts |
| # -fno-strict-aliasing *and* is older than GCC 4.3. |
| CXXFLAGS="$CXXFLAGS -fno-strict-aliasing" |
| AC_MSG_CHECKING([whether $CXX is affected by placement new aliasing bug]) |
| AC_COMPILE_IFELSE([AC_LANG_SOURCE([ |
| #if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) |
| #error compiler not affected by placement new aliasing bug |
| #endif |
| ])], |
| [AC_MSG_RESULT([yes]); aliasing_flags='-fno-strict-aliasing'], |
| [AC_MSG_RESULT([no])]) |
| |
| CXXFLAGS="$saved_CXXFLAGS" |
| fi |
| AC_SUBST(aliasing_flags) |
| |
| |
| |
| # --------------------- |
| # Warnings and checking |
| # --------------------- |
| |
| # Check $CC warning features (if it's GCC). |
| # We want to use -pedantic, but we don't want warnings about |
| # * 'long long' |
| # * variadic macros |
| # * overlong strings |
| # * C++11 narrowing conversions in { } |
| # So, we only use -pedantic if we can disable those warnings. |
| |
| # In stage 1, disable -Wformat warnings from old GCCs about new % codes |
| AC_ARG_ENABLE(build-format-warnings, |
| AS_HELP_STRING([--disable-build-format-warnings],[don't use -Wformat while building GCC]), |
| [],[enable_build_format_warnings=yes]) |
| AS_IF([test $enable_build_format_warnings = no], |
| [wf_opt=-Wno-format],[wf_opt=]) |
| ACX_PROG_CXX_WARNING_OPTS( |
| m4_quote(m4_do([-W -Wall -Wno-narrowing -Wwrite-strings ], |
| [-Wcast-qual -Wno-error=format-diag $wf_opt])), |
| [loose_warn]) |
| ACX_PROG_CC_WARNING_OPTS( |
| m4_quote(m4_do([-Wstrict-prototypes -Wmissing-prototypes ], |
| [-Wno-error=format-diag])), [c_loose_warn]) |
| ACX_PROG_CXX_WARNING_OPTS( |
| m4_quote(m4_do([-Wmissing-format-attribute ], |
| [-Woverloaded-virtual])), [strict_warn]) |
| ACX_PROG_CC_WARNING_OPTS( |
| m4_quote(m4_do([-Wold-style-definition -Wc++-compat])), [c_strict_warn]) |
| ACX_PROG_CXX_WARNING_ALMOST_PEDANTIC( |
| m4_quote(m4_do([-Wno-long-long -Wno-variadic-macros ], |
| [-Wno-overlength-strings])), [strict_warn]) |
| ACX_PROG_CXX_WARNINGS_ARE_ERRORS([manual], [strict_warn]) |
| |
| # The above macros do nothing if the compiler is not GCC. However, the |
| # Makefile has more goo to add other flags, so these variables are used |
| # to enable warnings only for GCC. |
| warn_cflags= |
| warn_cxxflags= |
| if test "x$GCC" = "xyes"; then |
| warn_cflags='$(GCC_WARN_CFLAGS)' |
| warn_cxxflags='$(GCC_WARN_CXXFLAGS)' |
| fi |
| AC_SUBST(warn_cflags) |
| AC_SUBST(warn_cxxflags) |
| |
| # Disable exceptions and RTTI if building with g++ |
| ACX_PROG_CC_WARNING_OPTS( |
| m4_quote(m4_do([-fno-exceptions -fno-rtti -fasynchronous-unwind-tables])), |
| [noexception_flags]) |
| |
| # Enable expensive internal checks |
| is_release= |
| if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then |
| is_release=yes |
| fi |
| |
| AC_ARG_ENABLE(checking, |
| [AS_HELP_STRING([[--enable-checking[=LIST]]], |
| [enable expensive run-time checks. With LIST, |
| enable only specific categories of checks. |
| Categories are: yes,no,all,none,release. |
| Flags are: assert,df,extra,fold,gc,gcac,gimple,misc, |
| rtlflag,rtl,runtime,tree,valgrind,types])], |
| [ac_checking_flags="${enableval}"],[ |
| # Determine the default checks. |
| if test x$is_release = x ; then |
| ac_checking_flags=yes,extra |
| else |
| ac_checking_flags=release |
| fi]) |
| IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS," |
| for check in release $ac_checking_flags |
| do |
| case $check in |
| # these set all the flags to specific states |
| yes) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking= ; |
| ac_fold_checking= ; ac_gc_checking=1 ; ac_extra_checking= ; |
| ac_gc_always_collect= ; ac_gimple_checking=1 ; ac_rtl_checking= ; |
| ac_rtlflag_checking=1 ; ac_runtime_checking=1 ; |
| ac_tree_checking=1 ; ac_valgrind_checking= ; |
| ac_types_checking=1 ;; |
| no|none) ac_assert_checking= ; ac_checking= ; ac_df_checking= ; |
| ac_fold_checking= ; ac_gc_checking= ; ac_extra_checking= ; |
| ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ; |
| ac_rtlflag_checking= ; ac_runtime_checking= ; |
| ac_tree_checking= ; ac_valgrind_checking= ; |
| ac_types_checking= ;; |
| all) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking=1 ; |
| ac_fold_checking=1 ; ac_gc_checking=1 ; ac_extra_checking=1 ; |
| ac_gc_always_collect=1 ; ac_gimple_checking=1 ; ac_rtl_checking=1 ; |
| ac_rtlflag_checking=1 ; ac_runtime_checking=1 ; |
| ac_tree_checking=1 ; ac_valgrind_checking= ; |
| ac_types_checking=1 ;; |
| release) ac_assert_checking=1 ; ac_checking= ; ac_df_checking= ; |
| ac_fold_checking= ; ac_gc_checking= ; ac_extra_checking= ; |
| ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ; |
| ac_rtlflag_checking= ; ac_runtime_checking=1 ; |
| ac_tree_checking= ; ac_valgrind_checking= ; |
| ac_types_checking= ;; |
| # these enable particular checks |
| assert) ac_assert_checking=1 ;; |
| df) ac_df_checking=1 ;; |
| extra) ac_extra_checking=1 ;; |
| fold) ac_fold_checking=1 ;; |
| gc) ac_gc_checking=1 ;; |
| gcac) ac_gc_always_collect=1 ;; |
| gimple) ac_gimple_checking=1 ;; |
| misc) ac_checking=1 ;; |
| rtl) ac_rtl_checking=1 ;; |
| rtlflag) ac_rtlflag_checking=1 ;; |
| runtime) ac_runtime_checking=1 ;; |
| tree) ac_tree_checking=1 ;; |
| types) ac_types_checking=1 ;; |
| valgrind) ac_valgrind_checking=1 ;; |
| *) AC_MSG_ERROR(unknown check category $check) ;; |
| esac |
| done |
| IFS="$ac_save_IFS" |
| |
| nocommon_flag="" |
| if test x$ac_checking != x ; then |
| AC_DEFINE(CHECKING_P, 1, |
| [Define to 0/1 if you want more run-time sanity checks. This one gets a grab |
| bag of miscellaneous but relatively cheap checks.]) |
| nocommon_flag=-fno-common |
| else |
| AC_DEFINE(CHECKING_P, 0) |
| fi |
| AC_SUBST(nocommon_flag) |
| if test x$ac_extra_checking != x ; then |
| AC_DEFINE(ENABLE_EXTRA_CHECKING, 1, |
| [Define to 0/1 if you want extra run-time checking that might affect code |
| generation.]) |
| else |
| AC_DEFINE(ENABLE_EXTRA_CHECKING, 0) |
| fi |
| if test x$ac_df_checking != x ; then |
| AC_DEFINE(ENABLE_DF_CHECKING, 1, |
| [Define if you want more run-time sanity checks for dataflow.]) |
| fi |
| if test x$ac_assert_checking != x ; then |
| AC_DEFINE(ENABLE_ASSERT_CHECKING, 1, |
| [Define if you want assertions enabled. This is a cheap check.]) |
| fi |
| if test x$ac_gimple_checking != x ; then |
| AC_DEFINE(ENABLE_GIMPLE_CHECKING, 1, |
| [Define if you want operations on GIMPLE (the basic data structure of |
| the high-level optimizers) to be checked for dynamic type safety at |
| runtime. This is moderately expensive.]) |
| fi |
| GCC_TARGET_TEMPLATE(ENABLE_RUNTIME_CHECKING) |
| if test x$ac_runtime_checking != x ; then |
| AC_DEFINE(ENABLE_RUNTIME_CHECKING, 1, |
| [Define if you want runtime assertions enabled. This is a cheap check.]) |
| fi |
| if test x$ac_tree_checking != x ; then |
| AC_DEFINE(ENABLE_TREE_CHECKING, 1, |
| [Define if you want all operations on trees (the basic data |
| structure of the front ends) to be checked for dynamic type safety |
| at runtime. This is moderately expensive. |
| ]) |
| TREECHECKING=yes |
| fi |
| if test x$ac_types_checking != x ; then |
| AC_DEFINE(ENABLE_TYPES_CHECKING, 1, |
| [Define if you want all gimple types to be verified after gimplifiation. |
| This is cheap. |
| ]) |
| fi |
| AC_SUBST(TREECHECKING) |
| if test x$ac_rtl_checking != x ; then |
| AC_DEFINE(ENABLE_RTL_CHECKING, 1, |
| [Define if you want all operations on RTL (the basic data structure |
| of the optimizer and back end) to be checked for dynamic type safety |
| at runtime. This is quite expensive.]) |
| fi |
| if test x$ac_rtlflag_checking != x ; then |
| AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1, |
| [Define if you want RTL flag accesses to be checked against the RTL |
| codes that are supported for each access macro. This is relatively |
| cheap.]) |
| fi |
| if test x$ac_gc_checking != x ; then |
| AC_DEFINE(ENABLE_GC_CHECKING, 1, |
| [Define if you want the garbage collector to do object poisoning and |
| other memory allocation checks. This is quite expensive.]) |
| fi |
| if test x$ac_gc_always_collect != x ; then |
| AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1, |
| [Define if you want the garbage collector to operate in maximally |
| paranoid mode, validating the entire heap and collecting garbage at |
| every opportunity. This is extremely expensive.]) |
| fi |
| if test x$ac_fold_checking != x ; then |
| AC_DEFINE(ENABLE_FOLD_CHECKING, 1, |
| [Define if you want fold checked that it never destructs its argument. |
| This is quite expensive.]) |
| fi |
| valgrind_path_defines= |
| valgrind_command= |
| |
| dnl # This check AC_REQUIREs various stuff, so it *must not* be inside |
| dnl # an if statement. This was the source of very frustrating bugs |
| dnl # in converting to autoconf 2.5x! |
| AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no) |
| |
| # It is certainly possible that there's valgrind but no valgrind.h. |
| # GCC relies on making annotations so we must have both. |
| AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>) |
| AC_PREPROC_IFELSE([AC_LANG_SOURCE( |
| [[#include <valgrind/memcheck.h> |
| #ifndef VALGRIND_DISCARD |
| #error VALGRIND_DISCARD not defined |
| #endif]])], |
| [gcc_cv_header_valgrind_memcheck_h=yes], |
| [gcc_cv_header_valgrind_memcheck_h=no]) |
| AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h) |
| AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>) |
| AC_PREPROC_IFELSE([AC_LANG_SOURCE( |
| [[#include <memcheck.h> |
| #ifndef VALGRIND_DISCARD |
| #error VALGRIND_DISCARD not defined |
| #endif]])], |
| [gcc_cv_header_memcheck_h=yes], |
| [gcc_cv_header_memcheck_h=no]) |
| AC_MSG_RESULT($gcc_cv_header_memcheck_h) |
| if test $gcc_cv_header_valgrind_memcheck_h = yes; then |
| AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1, |
| [Define if valgrind's valgrind/memcheck.h header is installed.]) |
| fi |
| if test $gcc_cv_header_memcheck_h = yes; then |
| AC_DEFINE(HAVE_MEMCHECK_H, 1, |
| [Define if valgrind's memcheck.h header is installed.]) |
| fi |
| |
| if test x$ac_valgrind_checking != x ; then |
| AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind, |
| [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1]) |
| if test "x$valgrind_path" = "x" \ |
| || (test $have_valgrind_h = no \ |
| && test $gcc_cv_header_memcheck_h = no \ |
| && test $gcc_cv_header_valgrind_memcheck_h = no); then |
| AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h]) |
| fi |
| valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"' |
| valgrind_command="$valgrind_path -q" |
| AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1, |
| [Define if you want to run subprograms and generated programs |
| through valgrind (a memory checker). This is extremely expensive.]) |
| fi |
| AC_SUBST(valgrind_path_defines) |
| AC_SUBST(valgrind_command) |
| |
| # Enable code coverage collection |
| AC_ARG_ENABLE(coverage, |
| [AS_HELP_STRING([[--enable-coverage[=LEVEL]]], |
| [enable compiler's code coverage collection. |
| Use to measure compiler performance and locate |
| unused parts of the compiler. With LEVEL, specify |
| optimization. Values are opt, noopt, |
| default is noopt])], |
| [case "${enableval}" in |
| yes|noopt) |
| coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0 -fkeep-static-functions" |
| ;; |
| opt) |
| coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2 -fkeep-static-functions" |
| ;; |
| no) |
| # a.k.a. --disable-coverage |
| coverage_flags="" |
| ;; |
| *) |
| AC_MSG_ERROR(unknown coverage setting $enableval) |
| ;; |
| esac], |
| [coverage_flags=""]) |
| AC_SUBST(coverage_flags) |
| |
| AC_ARG_ENABLE(gather-detailed-mem-stats, |
| [AS_HELP_STRING([--enable-gather-detailed-mem-stats], |
| [enable detailed memory allocation stats gathering])], [], |
| [enable_gather_detailed_mem_stats=no]) |
| gather_stats=`if test $enable_gather_detailed_mem_stats != no; then echo 1; else echo 0; fi` |
| AC_DEFINE_UNQUOTED(GATHER_STATISTICS, $gather_stats, |
| [Define to enable detailed memory allocation stats gathering.]) |
| |
| AC_ARG_ENABLE(valgrind-annotations, |
| [AS_HELP_STRING([--enable-valgrind-annotations], |
| [enable valgrind runtime interaction])], [], |
| [enable_valgrind_annotations=no]) |
| if test x$enable_valgrind_annotations != xno \ |
| || test x$ac_valgrind_checking != x; then |
| if (test $have_valgrind_h = no \ |
| && test $gcc_cv_header_memcheck_h = no \ |
| && test $gcc_cv_header_valgrind_memcheck_h = no); then |
| AC_MSG_ERROR([*** Can't find valgrind/memcheck.h, memcheck.h or valgrind.h]) |
| fi |
| AC_DEFINE(ENABLE_VALGRIND_ANNOTATIONS, 1, |
| [Define to get calls to the valgrind runtime enabled.]) |
| fi |
| |
| # ------------------------------- |
| # Miscenalleous configure options |
| # ------------------------------- |
| |
| # With stabs |
| AC_ARG_WITH(stabs, |
| [AS_HELP_STRING([--with-stabs], |
| [arrange to use stabs instead of host debug format])], |
| stabs="$with_stabs", |
| stabs=no) |
| |
| # Determine whether or not multilibs are enabled. |
| AC_ARG_ENABLE(multilib, |
| [AS_HELP_STRING([--enable-multilib], |
| [enable library support for multiple ABIs])], |
| [], [enable_multilib=yes]) |
| AC_SUBST(enable_multilib) |
| |
| # Determine whether or not multiarch is enabled. |
| AC_ARG_ENABLE(multiarch, |
| [AS_HELP_STRING([--enable-multiarch], |
| [enable support for multiarch paths])], |
| [case "${enableval}" in |
| yes|no|auto) enable_multiarch=$enableval;; |
| *) AC_MSG_ERROR(bad value ${enableval} given for --enable-multiarch option) ;; |
| esac], [enable_multiarch=auto]) |
| if test x${enable_multiarch} = xauto; then |
| if test x${with_native_system_header_dir} != x; then |
| ma_msg_suffix=", disabled auto check (configured with --native-system-header-dir)" |
| enable_multiarch=no |
| fi |
| if test x$host != x$target && test "x$with_sysroot" = x; then |
| ma_msg_suffix=", disabled auto check (cross build configured without --with-sysroot)" |
| enable_multiarch=no |
| fi |
| fi |
| AC_MSG_CHECKING(for multiarch configuration) |
| AC_SUBST(enable_multiarch) |
| AC_MSG_RESULT($enable_multiarch$ma_msg_suffix) |
| |
| # needed for setting the multiarch name for soft-float/hard-float ABIs |
| AC_SUBST(with_cpu) |
| AC_SUBST(with_float) |
| |
| # default stack clash protection guard size as power of twos in bytes. |
| # Please keep these in sync with params.def. |
| stk_clash_min=12 |
| stk_clash_max=30 |
| |
| # Keep the default value when the option is not used to 0, this allows us to |
| # distinguish between the cases where the user specifially set a value via |
| # configure and when the normal default value is used. |
| AC_ARG_WITH(stack-clash-protection-guard-size, |
| [AS_HELP_STRING([--with-stack-clash-protection-guard-size=size], |
| [Set the default stack clash protection guard size for specific targets as a power of two in bytes.])], |
| [DEFAULT_STK_CLASH_GUARD_SIZE="$with_stack_clash_protection_guard_size"], [DEFAULT_STK_CLASH_GUARD_SIZE=0]) |
| if test $DEFAULT_STK_CLASH_GUARD_SIZE -ne 0 \ |
| && (test $DEFAULT_STK_CLASH_GUARD_SIZE -lt $stk_clash_min \ |
| || test $DEFAULT_STK_CLASH_GUARD_SIZE -gt $stk_clash_max); then |
| AC_MSG_ERROR(m4_normalize([ |
| Invalid value $DEFAULT_STK_CLASH_GUARD_SIZE for --with-stack-clash-protection-guard-size. \ |
| Must be between $stk_clash_min and $stk_clash_max.])) |
| fi |
| |
| AC_DEFINE_UNQUOTED(DEFAULT_STK_CLASH_GUARD_SIZE, $DEFAULT_STK_CLASH_GUARD_SIZE, |
| [Define to larger than zero set the default stack clash protector size.]) |
| |
| # Enable __cxa_atexit for C++. |
| AC_ARG_ENABLE(__cxa_atexit, |
| [AS_HELP_STRING([--enable-__cxa_atexit], [enable __cxa_atexit for C++])], |
| [], []) |
| |
| # Enable C extension for decimal float if target supports it. |
| GCC_AC_ENABLE_DECIMAL_FLOAT([$target]) |
| |
| dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi` |
| AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp, |
| [Define to 1 to enable decimal float extension to C.]) |
| |
| # Use default_decimal_float for dependency. |
| enable_decimal_float=$default_decimal_float |
| |
| bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi` |
| AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid, |
| [Define to 1 to specify that we are using the BID decimal floating |
| point format instead of DPD]) |
| |
| # Enable C extension for fixed-point arithmetic. |
| AC_ARG_ENABLE(fixed-point, |
| [AS_HELP_STRING([--enable-fixed-point], |
| [enable fixed-point arithmetic extension to C])], |
| [], |
| [ |
| case $target in |
| arm*) |
| enable_fixed_point=yes |
| ;; |
| |
| mips*-*-*) |
| enable_fixed_point=yes |
| ;; |
| *) |
| AC_MSG_WARN([fixed-point is not supported for this target, ignored]) |
| enable_fixed_point=no |
| ;; |
| esac |
| ]) |
| AC_SUBST(enable_fixed_point) |
| |
| fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi` |
| AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint, |
| [Define to 1 to enable fixed-point arithmetic extension to C.]) |
| |
| # Enable threads |
| # Pass with no value to take the default |
| # Pass with a value to specify a thread package |
| AC_ARG_ENABLE(threads, |
| [AS_HELP_STRING([[--enable-threads[=LIB]]], |
| [enable thread usage for target GCC, |
| using LIB thread package])],, |
| [enable_threads='']) |
| |
| AC_ARG_ENABLE(tls, |
| [AS_HELP_STRING([--enable-tls], |
| [enable or disable generation of tls code |
| overriding the assembler check for tls support])], |
| [ |
| case $enable_tls in |
| yes | no) ;; |
| *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls. |
| Valid choices are 'yes' and 'no'.]) ;; |
| esac |
| ], [enable_tls='']) |
| |
| AC_ARG_ENABLE(vtable-verify, |
| [AS_HELP_STRING([--enable-vtable-verify], |
| [enable vtable verification feature])],, |
| [enable_vtable_verify=no]) |
| vtable_verify=`if test x$enable_vtable_verify = xyes; then echo 1; else echo 0; fi` |
| AC_DEFINE_UNQUOTED(ENABLE_VTABLE_VERIFY, $vtable_verify, |
| [Define 0/1 if vtable verification feature is enabled.]) |
| |
| AC_ARG_ENABLE(analyzer, |
| [AS_HELP_STRING([--disable-analyzer], |
| [disable -fanalyzer static analyzer])], |
| if test x$enable_analyzer = xno; then |
| analyzer=0 |
| else |
| analyzer=1 |
| fi, |
| analyzer=1) |
| AC_DEFINE_UNQUOTED(ENABLE_ANALYZER, $analyzer, |
| [Define 0/1 if static analyzer feature is enabled.]) |
| |
| AC_ARG_ENABLE(objc-gc, |
| [AS_HELP_STRING([--enable-objc-gc], |
| [enable the use of Boehm's garbage collector with |
| the GNU Objective-C runtime])], |
| if test x$enable_objc_gc = xno; then |
| objc_boehm_gc='' |
| else |
| objc_boehm_gc=1 |
| fi, |
| objc_boehm_gc='') |
| |
| AC_ARG_WITH(dwarf2, |
| [AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2])], |
| dwarf2="$with_dwarf2", |
| dwarf2=no) |
| |
| AC_ARG_ENABLE(shared, |
| [AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])], |
| [ |
| case $enable_shared in |
| yes | no) ;; |
| *) |
| enable_shared=no |
| IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:," |
| for pkg in $enableval; do |
| if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then |
| enable_shared=yes |
| fi |
| done |
| IFS="$ac_save_ifs" |
| ;; |
| esac |
| ], [enable_shared=yes]) |
| AC_SUBST(enable_shared) |
| |
| AC_ARG_ENABLE(gcov, |
| [ --disable-gcov don't provide libgcov and related host tools], |
| [], [enable_gcov=yes]) |
| AC_SUBST(enable_gcov) |
| |
| AC_ARG_WITH(specs, |
| [AS_HELP_STRING([--with-specs=SPECS], |
| [add SPECS to driver command-line processing])], |
| [CONFIGURE_SPECS=$withval], |
| [CONFIGURE_SPECS=] |
| ) |
| AC_SUBST(CONFIGURE_SPECS) |
| |
| ACX_PKGVERSION([GCC]) |
| ACX_BUGURL([https://gcc.gnu.org/bugs/]) |
| |
| # Allow overriding the default URL for documentation |
| AC_ARG_WITH(documentation-root-url, |
| AS_HELP_STRING([--with-documentation-root-url=URL], |
| [Root for documentation URLs]), |
| [case "$withval" in |
| yes) AC_MSG_ERROR([documentation root URL not specified]) ;; |
| no) AC_MSG_ERROR([documentation root URL not specified]) ;; |
| */) DOCUMENTATION_ROOT_URL="$withval" ;; |
| *) AC_MSG_ERROR([documentation root URL does not end with /]) ;; |
| esac], |
| DOCUMENTATION_ROOT_URL="https://gcc.gnu.org/onlinedocs/" |
| ) |
| AC_DEFINE_UNQUOTED(DOCUMENTATION_ROOT_URL,"$DOCUMENTATION_ROOT_URL", |
| [Define to the root for documentation URLs.]) |
| |
| # Allow overriding the default URL for GCC changes |
| AC_ARG_WITH(changes-root-url, |
| AS_HELP_STRING([--with-changes-root-url=URL], |
| [Root for GCC changes URLs]), |
| [case "$withval" in |
| yes) AC_MSG_ERROR([changes root URL not specified]) ;; |
| no) AC_MSG_ERROR([changes root URL not specified]) ;; |
| */) CHANGES_ROOT_URL="$withval" ;; |
| *) AC_MSG_ERROR([changes root URL does not end with /]) ;; |
| esac], |
| CHANGES_ROOT_URL="https://gcc.gnu.org/" |
| ) |
| AC_DEFINE_UNQUOTED(CHANGES_ROOT_URL,"$CHANGES_ROOT_URL", |
| [Define to the root for URLs about GCC changes.]) |
| |
| # Sanity check enable_languages in case someone does not run the toplevel |
| # configure # script. |
| AC_ARG_ENABLE(languages, |
| [AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])], |
| [case ,${enable_languages}, in |
| ,,|,yes,) |
| # go safe -- we cannot be much sure without the toplevel |
| # configure's |
| # analysis of which target libs are present and usable |
| enable_languages=c |
| ;; |
| *,all,*) |
| AC_MSG_ERROR([only the toplevel supports --enable-languages=all]) |
| ;; |
| *,c,*) |
| ;; |
| *) |
| enable_languages=c,${enable_languages} |
| ;; |
| esac], |
| [enable_languages=c]) |
| |
| # If top-level libada has been disabled, then wire in install-gnatlib |
| # invocation with `make install', so that one can build and install |
| # the library manually with `make -C gcc all gnatlib gnattools install'. |
| if test x"$enable_libada" = xno; then |
| gnat_install_lib=gnat-install-lib |
| else |
| gnat_install_lib= |
| fi |
| AC_SUBST(gnat_install_lib) |
| |
| if test x"$enable_as_accelerator_for" != x; then |
| AC_DEFINE(ACCEL_COMPILER, 1, |
| [Define if this compiler should be built as the offload target compiler.]) |
| enable_as_accelerator=yes |
| case "${target}" in |
| *-intelmicemul-*) |
| # In this case we expect offload compiler to be built as native, so we |
| # need to rename the driver to avoid clashes with host's drivers. |
| program_transform_name="s&^&${target}-&" ;; |
| esac |
| sedscript="s#${target_noncanonical}#${enable_as_accelerator_for}-accel-${target_noncanonical}#" |
| program_transform_name=`echo $program_transform_name | sed $sedscript` |
| accel_dir_suffix=/accel/${target_noncanonical} |
| real_target_noncanonical=${enable_as_accelerator_for} |
| fi |
| AC_SUBST(enable_as_accelerator) |
| AC_SUBST(real_target_noncanonical) |
| AC_SUBST(accel_dir_suffix) |
| |
| for tgt in `echo $enable_offload_targets | sed 's/,/ /g'`; do |
| tgt=`echo $tgt | sed 's/=.*//'` |
| |
| enable_offloading=1 |
| case "$tgt" in |
| *-intelmic-* | *-intelmicemul-*) |
| omp_device_property=omp-device-properties-i386 |
| omp_device_property_tmake_file="${omp_device_property_tmake_file} \$(srcdir)/config/i386/t-omp-device" |
| ;; |
| amdgcn*) |
| omp_device_property=omp-device-properties-gcn |
| omp_device_property_tmake_file="${omp_device_property_tmake_file} \$(srcdir)/config/gcn/t-omp-device" |
| ;; |
| nvptx*) |
| omp_device_property=omp-device-properties-nvptx |
| omp_device_property_tmake_file="${omp_device_property_tmake_file} \$(srcdir)/config/nvptx/t-omp-device" |
| ;; |
| *) |
| AC_MSG_ERROR([unknown offload target specified]) |
| ;; |
| esac |
| omp_device_properties="${omp_device_properties} ${tgt}=${omp_device_property}" |
| omp_device_property_deps="${omp_device_property_deps} ${omp_device_property}" |
| |
| if test x"$offload_targets" = x; then |
| offload_targets=$tgt |
| else |
| offload_targets="$offload_targets,$tgt" |
| fi |
| done |
| AC_SUBST(omp_device_properties) |
| AC_SUBST(omp_device_property_deps) |
| |
| AC_DEFINE_UNQUOTED(OFFLOAD_TARGETS, "$offload_targets", |
| [Define to offload targets, separated by commas.]) |
| if test x"$enable_offloading" != x; then |
| AC_DEFINE(ENABLE_OFFLOADING, 1, |
| [Define this to enable support for offloading.]) |
| else |
| AC_DEFINE(ENABLE_OFFLOADING, 0, |
| [Define this to enable support for offloading.]) |
| fi |
| |
| AC_ARG_WITH(multilib-list, |
| [AS_HELP_STRING([--with-multilib-list], [select multilibs (AArch64, SH and x86-64 only)])], |
| :, |
| with_multilib_list=default) |
| |
| AC_ARG_WITH(multilib-generator, |
| [AS_HELP_STRING([--with-multilib-generator], [Multi-libs configuration string (RISC-V only)])], |
| :, |
| with_multilib_generator=default) |
| |
| # ------------------------- |
| # Checks for other programs |
| # ------------------------- |
| |
| AC_PROG_MAKE_SET |
| |
| # Find some useful tools |
| AC_PROG_AWK |
| # We need awk to create options.c and options.h. |
| # Bail out if it's missing. |
| case ${AWK} in |
| "") AC_MSG_ERROR([can't build without awk, bailing out]) ;; |
| esac |
| |
| gcc_AC_PROG_LN_S |
| ACX_PROG_LN($LN_S) |
| AC_PROG_RANLIB |
| ranlib_flags="" |
| AC_SUBST(ranlib_flags) |
| |
| gcc_AC_PROG_INSTALL |
| |
| # See if cmp has --ignore-initial. |
| gcc_AC_PROG_CMP_IGNORE_INITIAL |
| |
| # See if we have the mktemp command. |
| AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no) |
| |
| # See if makeinfo has been installed and is modern enough |
| # that we can use it. |
| ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version, |
| [GNU texinfo.* \([0-9][0-9.]*\)], |
| [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*]) |
| if test $gcc_cv_prog_makeinfo_modern = no; then |
| AC_MSG_WARN([ |
| *** Makeinfo is missing or too old. |
| *** Info documentation will not be built.]) |
| BUILD_INFO= |
| else |
| BUILD_INFO=info |
| fi |
| AC_SUBST(BUILD_INFO) |
| |
| # Is pod2man recent enough to regenerate manpages? |
| AC_MSG_CHECKING([for recent Pod::Man]) |
| if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then |
| AC_MSG_RESULT(yes) |
| GENERATED_MANPAGES=generated-manpages |
| else |
| AC_MSG_RESULT(no) |
| GENERATED_MANPAGES= |
| fi |
| AC_SUBST(GENERATED_MANPAGES) |
| |
| MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing" |
| |
| # How about lex? |
| dnl Don't use AC_PROG_LEX; we insist on flex. |
| dnl LEXLIB is not useful in gcc. |
| AC_CHECK_PROGS([FLEX], flex, [$MISSING flex]) |
| |
| # Bison? |
| AC_CHECK_PROGS([BISON], bison, [$MISSING bison]) |
| |
| # Binutils are not build modules, unlike bison/flex/makeinfo. So we |
| # check for build == host before using them. |
| |
| # NM |
| if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \ |
| && test -d ../binutils ; then |
| NM='${objdir}/../binutils/nm-new' |
| else |
| AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm) |
| fi |
| |
| # AR |
| if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \ |
| && test -d ../binutils ; then |
| AR='${objdir}/../binutils/ar' |
| else |
| AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar) |
| fi |
| |
| # The jit documentation looks better if built with sphinx, but can be |
| # built with texinfo if sphinx is not available. |
| # Set "doc_build_sys" to "sphinx" or "texinfo" accordingly. |
| AC_CHECK_PROG(doc_build_sys, sphinx-build, sphinx, texinfo) |
| |
| # -------------------- |
| # Checks for C headers |
| # -------------------- |
| |
| # Need to reject headers which give warnings, so that the -Werror bootstrap |
| # works later. *sigh* This needs to come before all header checks. |
| AC_PROG_CPP_WERROR |
| |
| AC_HEADER_STDC |
| AC_HEADER_TIME |
| ACX_HEADER_STRING |
| AC_HEADER_SYS_WAIT |
| AC_HEADER_TIOCGWINSZ |
| AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \ |
| fcntl.h ftw.h unistd.h sys/file.h sys/time.h sys/mman.h \ |
| sys/resource.h sys/param.h sys/times.h sys/stat.h \ |
| direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h) |
| |
| # Check for thread headers. |
| AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=]) |
| AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=]) |
| |
| # These tests can't be done till we know if we have limits.h. |
| gcc_AC_C_CHAR_BIT |
| AC_C_BIGENDIAN |
| |
| # ---------------------- |
| # Checks for C++ headers |
| # ---------------------- |
| |
| dnl Autoconf will give an error in the configure script if there is no |
| dnl C++ preprocessor. Hack to prevent that. |
| m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl |
| AC_PROG_CXXCPP |
| m4_popdef([AC_MSG_ERROR])[]dnl |
| |
| AC_CHECK_HEADERS(unordered_map) |
| AC_CHECK_HEADERS(tr1/unordered_map) |
| AC_CHECK_HEADERS(ext/hash_map) |
| |
| # -------- |
| # Dependency checking. |
| # -------- |
| |
| ZW_CREATE_DEPDIR |
| AC_CONFIG_COMMANDS([gccdepdir],[ |
| ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs build/$DEPDIR |
| for lang in $subdirs c-family common analyzer rtl-ssa |
| do |
| ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs $lang/$DEPDIR |
| done], [subdirs="$subdirs" ac_aux_dir=$ac_aux_dir DEPDIR=$DEPDIR]) |
| |
| ZW_PROG_COMPILER_DEPENDENCIES([CXX]) |
| |
| # -------- |
| # UNSORTED |
| # -------- |
| |
| |
| # These libraries may be used by collect2. |
| # We may need a special search path to get them linked. |
| AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs, |
| [save_LIBS="$LIBS" |
| for libs in '' -lld -lmld \ |
| '-L/usr/lib/cmplrs/cc2.11 -lmld' \ |
| '-L/usr/lib/cmplrs/cc3.11 -lmld' |
| do |
| LIBS="$libs" |
| AC_TRY_LINK_FUNC(ldopen, |
| [gcc_cv_collect2_libs="$libs"; break]) |
| done |
| LIBS="$save_LIBS" |
| test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required']) |
| case $gcc_cv_collect2_libs in |
| "none required") ;; |
| *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;; |
| esac |
| AC_SUBST(COLLECT2_LIBS) |
| |
| # When building Ada code on Alpha, we need exc_resume which is usually in |
| # -lexc. So test for it. |
| save_LIBS="$LIBS" |
| LIBS= |
| AC_SEARCH_LIBS(exc_resume, exc) |
| GNAT_LIBEXC="$LIBS" |
| LIBS="$save_LIBS" |
| AC_SUBST(GNAT_LIBEXC) |
| |
| # To support -mcpu=native on Solaris/SPARC, we need libkstat. |
| save_LIBS="$LIBS" |
| LIBS= |
| AC_SEARCH_LIBS(kstat_open, kstat) |
| EXTRA_GCC_LIBS="$LIBS" |
| LIBS="$save_LIBS" |
| AC_SUBST(EXTRA_GCC_LIBS) |
| |
| # Solaris needs libsocket and libnsl for socket functions before 11.4. |
| # C++ needs those for libcody. |
| save_LIBS="$LIBS" |
| LIBS= |
| AX_LIB_SOCKET_NSL |
| NETLIBS="$LIBS" |
| LIBS="$save_LIBS" |
| AC_SUBST(NETLIBS) |
| |
| # Some systems put ldexp and frexp in libm instead of libc; assume |
| # they're both in the same place. jcf-dump needs them. |
| save_LIBS="$LIBS" |
| LIBS= |
| AC_SEARCH_LIBS(ldexp, m) |
| LDEXP_LIB="$LIBS" |
| LIBS="$save_LIBS" |
| AC_SUBST(LDEXP_LIB) |
| |
| # Some systems need dlopen |
| save_LIBS="$LIBS" |
| LIBS= |
| AC_SEARCH_LIBS(dlopen, dl) |
| DL_LIB="$LIBS" |
| LIBS="$save_LIBS" |
| AC_SUBST(DL_LIB) |
| |
| # Use <inttypes.h> only if it exists, |
| # doesn't clash with <sys/types.h>, declares intmax_t and defines |
| # PRId64 |
| AC_MSG_CHECKING(for inttypes.h) |
| AC_CACHE_VAL(gcc_cv_header_inttypes_h, |
| [AC_COMPILE_IFELSE([AC_LANG_PROGRAM( |
| [[#define __STDC_FORMAT_MACROS |
| #include <sys/types.h> |
| #include <inttypes.h>]], |
| [[intmax_t i = -1; |
| #ifndef PRId64 |
| choke me |
| #endif]])], |
| [gcc_cv_header_inttypes_h=yes], |
| [gcc_cv_header_inttypes_h=no])]) |
| AC_MSG_RESULT($gcc_cv_header_inttypes_h) |
| if test $gcc_cv_header_inttypes_h = yes; then |
| AC_DEFINE(HAVE_INTTYPES_H, 1, |
| [Define if you have a working <inttypes.h> header file.]) |
| fi |
| |
| # Look for the ZSTD package. |
| ZSTD_INCLUDE= |
| ZSTD_LIB= |
| AC_SUBST(ZSTD_INCLUDE) |
| AC_SUBST(ZSTD_LIB) |
| ZSTD_CPPFLAGS= |
| ZSTD_LDFLAGS= |
| AC_SUBST(ZSTD_CPPFLAGS) |
| AC_SUBST(ZSTD_LDFLAGS) |
| AC_ARG_WITH(zstd, |
| [AS_HELP_STRING([--with-zstd=PATH], |
| [specify prefix directory for installed zstd library. |
| Equivalent to --with-zstd-include=PATH/include |
| plus --with-zstd-lib=PATH/lib])]) |
| AC_ARG_WITH(zstd-include, |
| [AS_HELP_STRING([--with-zstd-include=PATH], |
| [specify directory for installed zstd include files])]) |
| AC_ARG_WITH(zstd-lib, |
| [AS_HELP_STRING([--with-zstd-lib=PATH], |
| [specify directory for the installed zstd library])]) |
| case "x$with_zstd" in |
| x) ;; |
| xno) |
| ZSTD_INCLUDE= |
| ZSTD_LIB= |
| ;; |
| *) ZSTD_INCLUDE=$with_zstd/include |
| ZSTD_LIB=$with_zstd/lib |
| ;; |
| esac |
| |
| if test "x$with_zstd" != xno; then |
| if test "x$with_zstd_include" != x; then |
| ZSTD_INCLUDE=$with_zstd_include |
| fi |
| if test "x$with_zstd_lib" != x; then |
| ZSTD_LIB=$with_zstd_lib |
| fi |
| if test "x$ZSTD_INCLUDE" != x \ |
| && test "x$ZSTD_INCLUDE" != xno; then |
| ZSTD_CPPFLAGS=-I$ZSTD_INCLUDE |
| fi |
| if test "x$ZSTD_LIB" != x \ |
| && test "x$ZSTD_LIB" != xno; then |
| ZSTD_LDFLAGS=-L$ZSTD_LIB |
| fi |
| |
| CXXFLAGS="$CXXFLAGS $ZSTD_CPPFLAGS" |
| LDFLAGS="$LDFLAGS $ZSTD_LDFLAGS" |
| |
| AC_MSG_CHECKING(for zstd.h) |
| AC_CACHE_VAL(gcc_cv_header_zstd_h, |
| # We require version 1.3.0 or later. This is the first version that has |
| # ZSTD_getFrameContentSize. |
| [AC_COMPILE_IFELSE([AC_LANG_PROGRAM( |
| [[#include <zstd.h> |
| #if ZSTD_VERSION_NUMBER < 10300 |
| #error "need zstd 1.3.0 or better" |
| #endif]])], |
| [gcc_cv_header_zstd_h=yes], |
| [gcc_cv_header_zstd_h=no])]) |
| AC_MSG_RESULT($gcc_cv_header_zstd_h) |
| if test $gcc_cv_header_zstd_h = yes; then |
| AC_DEFINE(HAVE_ZSTD_H, 1, |
| [Define if you have a working <zstd.h> header file.]) |
| elif test "x$with_zstd" != x; then |
| as_fn_error $? "Unable to find zstd.h. See config.log for details." "$LINENO" 5 |
| fi |
| |
| # LTO can use zstd compression algorithm |
| save_LIBS="$LIBS" |
| LIBS= |
| AC_SEARCH_LIBS(ZSTD_compress, zstd) |
| ZSTD_LIB="$LIBS" |
| LIBS="$save_LIBS" |
| AC_SUBST(ZSTD_LIB) |
| fi |
| |
| dnl Disabled until we have a complete test for buggy enum bitfields. |
| dnl gcc_AC_C_ENUM_BF_UNSIGNED |
| |
| define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl |
| ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl |
| fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl |
| fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl |
| putchar_unlocked putc_unlocked) |
| AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoq \ |
| popen sysconf strsignal getrusage nl_langinfo \ |
| gettimeofday mbstowcs wcswidth mmap posix_fallocate setlocale \ |
| gcc_UNLOCKED_FUNCS madvise mallinfo mallinfo2 fstatat) |
| |
| if test x$ac_cv_func_mbstowcs = xyes; then |
| AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works, |
| [ AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h> |
| int main() |
| { |
| mbstowcs(0, "", 0); |
| return 0; |
| }]])], |
| [gcc_cv_func_mbstowcs_works=yes], |
| [gcc_cv_func_mbstowcs_works=no], |
| [gcc_cv_func_mbstowcs_works=yes])]) |
| if test x$gcc_cv_func_mbstowcs_works = xyes; then |
| AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1, |
| [Define this macro if mbstowcs does not crash when its |
| first argument is NULL.]) |
| fi |
| fi |
| |
| AC_CHECK_TYPE(ssize_t, int) |
| AC_CHECK_TYPE(caddr_t, char *) |
| AC_CHECK_TYPE(sighander_t, |
| AC_DEFINE(HAVE_SIGHANDLER_T, 1, |
| [Define if <sys/signal.h> defines sighandler_t]), |
| ,signal.h) |
| |
| GCC_AC_FUNC_MMAP_BLACKLIST |
| |
| case "${host}" in |
| *-*-*vms*) |
| # Under VMS, vfork works very differently than on Unix. The standard test |
| # won't work, and it isn't easily adaptable. It makes more sense to |
| # just force it. |
| ac_cv_func_vfork_works=yes |
| ;; |
| esac |
| AC_FUNC_FORK |
| |
| AM_ICONV |
| |
| # Until we have in-tree GNU iconv: |
| LIBICONV_DEP= |
| if test -f "$LTLIBICONV"; then |
| LIBICONV_DEP=$LTLIBICONV |
| fi |
| AC_SUBST(LIBICONV_DEP) |
| |
| AM_LC_MESSAGES |
| |
| AM_LANGINFO_CODESET |
| |
| # We will need to find libiberty.h and ansidecl.h |
| saved_CFLAGS="$CFLAGS" |
| CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC" |
| saved_CXXFLAGS="$CXXFLAGS" |
| CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC" |
| |
| # gcc_AC_CHECK_DECLS doesn't support overloaded functions, so use the |
| # normal autoconf function for these. But force definition of |
| # HAVE_DECL_BASENAME like gcc_AC_CHECK_DECLS does, to suppress the bizarre |
| # basename handling in libiberty.h. |
| AC_CHECK_DECLS([basename(const char*), strstr(const char*,const char*)], , ,[ |
| #undef HAVE_DECL_BASENAME |
| #define HAVE_DECL_BASENAME 1 |
| #include "ansidecl.h" |
| #include "system.h"]) |
| |
| gcc_AC_CHECK_DECLS(getenv atol atoll asprintf sbrk abort atof getcwd getwd \ |
| madvise stpcpy strnlen strsignal strverscmp \ |
| strtol strtoul strtoll strtoull setenv unsetenv \ |
| errno snprintf vsnprintf vasprintf malloc realloc calloc \ |
| free getopt clock getpagesize ffs gcc_UNLOCKED_FUNCS, , ,[ |
| #include "ansidecl.h" |
| #include "system.h"]) |
| |
| gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[ |
| #include "ansidecl.h" |
| #include "system.h" |
| #ifdef HAVE_SYS_RESOURCE_H |
| #include <sys/resource.h> |
| #endif |
| ]) |
| |
| gcc_AC_CHECK_DECLS(mallinfo mallinfo2, , ,[ |
| #include "ansidecl.h" |
| #include "system.h" |
| #ifdef HAVE_MALLOC_H |
| #include <malloc.h> |
| #endif |
| ]) |
| |
| AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ |
| #include "ansidecl.h" |
| #include "system.h" |
| #ifdef HAVE_SYS_RESOURCE_H |
| #include <sys/resource.h> |
| #endif |
| ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long], |
| [Define to `long' if <sys/resource.h> doesn't define.])]) |
| |
| # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible |
| # FREAD and FWRITE macros. Fortunately, for GCC's single usage of ldgetname |
| # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs |
| # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME. |
| gcc_AC_CHECK_DECLS(ldgetname, , ,[ |
| #include "ansidecl.h" |
| #include "system.h" |
| #ifdef HAVE_LDFCN_H |
| #undef FREAD |
| #undef FWRITE |
| #include <ldfcn.h> |
| #endif |
| ]) |
| |
| gcc_AC_CHECK_DECLS(times, , ,[ |
| #include "ansidecl.h" |
| #include "system.h" |
| #ifdef HAVE_SYS_TIMES_H |
| #include <sys/times.h> |
| #endif |
| ]) |
| |
| gcc_AC_CHECK_DECLS(sigaltstack, , ,[ |
| #include "ansidecl.h" |
| #include "system.h" |
| #include <signal.h> |
| ]) |
| |
| # More time-related stuff. |
| AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [ |
| AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ |
| #include "ansidecl.h" |
| #include "system.h" |
| #ifdef HAVE_SYS_TIMES_H |
| #include <sys/times.h> |
| #endif |
| ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])]) |
| if test $ac_cv_struct_tms = yes; then |
| AC_DEFINE(HAVE_STRUCT_TMS, 1, |
| [Define if <sys/times.h> defines struct tms.]) |
| fi |
| |
| # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE. |
| # revisit after autoconf 2.50. |
| AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [ |
| AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ |
| #include "ansidecl.h" |
| #include "system.h" |
| ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])]) |
| if test $gcc_cv_type_clock_t = yes; then |
| AC_DEFINE(HAVE_CLOCK_T, 1, |
| [Define if <time.h> defines clock_t.]) |
| fi |
| |
| # Check if F_SETLKW is supported by fcntl. |
| AC_CACHE_CHECK(for F_SETLKW, ac_cv_f_setlkw, [ |
| AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ |
| #include <fcntl.h>]], [[ |
| struct flock fl; |
| fl.l_whence = 0; |
| fl.l_start = 0; |
| fl.l_len = 0; |
| fl.l_pid = 0; |
| return fcntl (1, F_SETLKW, &fl);]])], |
| [ac_cv_f_setlkw=yes],[ac_cv_f_setlkw=no])]) |
| if test $ac_cv_f_setlkw = yes; then |
| AC_DEFINE(HOST_HAS_F_SETLKW, 1, |
| [Define if F_SETLKW supported by fcntl.]) |
| fi |
| |
| # Check if O_CLOEXEC is defined by fcntl |
| AC_CACHE_CHECK(for O_CLOEXEC, ac_cv_o_cloexec, [ |
| AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ |
| #include <fcntl.h>]], [[ |
| return open ("/dev/null", O_RDONLY | O_CLOEXEC);]])], |
| [ac_cv_o_cloexec=yes],[ac_cv_o_cloexec=no])]) |
| if test $ac_cv_o_cloexec = yes; then |
| AC_DEFINE(HOST_HAS_O_CLOEXEC, 1, |
| [Define if O_CLOEXEC supported by fcntl.]) |
| fi |
| |
| # C++ Modules would like some networking features to provide the mapping |
| # server. You can still use modules without them though. |
| # The following network-related checks could probably do with some |
| # Windows and other non-linux defenses and checking. |
| |
| # Local socket connectivity wants AF_UNIX networking |
| # Check for AF_UNIX networking |
| AC_CACHE_CHECK(for AF_UNIX, ac_cv_af_unix, [ |
| AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ |
| #include <sys/types.h> |
| #include <sys/socket.h> |
| #include <sys/un.h> |
| #include <netinet/in.h>]],[[ |
| sockaddr_un un; |
| un.sun_family = AF_UNSPEC; |
| int fd = socket (AF_UNIX, SOCK_STREAM, 0); |
| connect (fd, (sockaddr *)&un, sizeof (un));]])], |
| [ac_cv_af_unix=yes], |
| [ac_cv_af_unix=no])]) |
| if test $ac_cv_af_unix = yes; then |
| AC_DEFINE(HAVE_AF_UNIX, 1, |
| [Define if AF_UNIX supported.]) |
| fi |
| |
| # Remote socket connectivity wants AF_INET6 networking |
| # Check for AF_INET6 networking |
| AC_CACHE_CHECK(for AF_INET6, ac_cv_af_inet6, [ |
| AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ |
| #include <sys/types.h> |
| #include <sys/socket.h> |
| #include <netinet/in.h> |
| #include <netdb.h>]],[[ |
| sockaddr_in6 in6; |
| in6.sin6_family = AF_UNSPEC; |
| struct addrinfo *addrs = 0; |
| struct addrinfo hints; |
| hints.ai_flags = 0; |
| hints.ai_family = AF_INET6; |
| hints.ai_socktype = SOCK_STREAM; |
| hints.ai_protocol = 0; |
| hints.ai_canonname = 0; |
| hints.ai_addr = 0; |
| hints.ai_next = 0; |
| int e = getaddrinfo ("localhost", 0, &hints, &addrs); |
| const char *str = gai_strerror (e); |
| freeaddrinfo (addrs); |
| int fd = socket (AF_INET6, SOCK_STREAM, 0); |
| connect (fd, (sockaddr *)&in6, sizeof (in6));]])], |
| [ac_cv_af_inet6=yes], |
| [ac_cv_af_inet6=no])]) |
| if test $ac_cv_af_inet6 = yes; then |
| AC_DEFINE(HAVE_AF_INET6, 1, |
| [Define if AF_INET6 supported.]) |
| fi |
| |
| # Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests. |
| CFLAGS="$saved_CFLAGS" |
| CXXFLAGS="$saved_CXXFLAGS" |
| |
| # mkdir takes a single argument on some systems. |
| gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG |
| |
| # File extensions |
| manext='.1' |
| objext='.o' |
| AC_SUBST(manext) |
| AC_SUBST(objext) |
| |
| # With Setjmp/Longjmp based exception handling. |
| AC_ARG_ENABLE(sjlj-exceptions, |
| [AS_HELP_STRING([--enable-sjlj-exceptions], |
| [arrange to use setjmp/longjmp exception handling])], |
| [case $target in |
| *-*-hpux10*) |
| if test $enableval != yes; then |
| AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced]) |
| enableval=yes |
| fi |
| ;; |
| esac |
| force_sjlj_exceptions=yes], |
| [case $target in |
| *-*-hpux10*) |
| force_sjlj_exceptions=yes |
| enableval=yes |
| ;; |
| lm32*-*-*) |
| force_sjlj_exceptions=yes |
| enableval=yes |
| ;; |
| *) |
| force_sjlj_exceptions=no |
| ;; |
| esac]) |
| if test $force_sjlj_exceptions = yes; then |
| sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi` |
| AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj, |
| [Define 0/1 to force the choice for exception handling model.]) |
| fi |
| |
| # -------------------------------------------------------- |
| # Build, host, and target specific configuration fragments |
| # -------------------------------------------------------- |
| |
| # Collect build-machine-specific information. |
| . ${srcdir}/config.build || exit 1 |
| |
| # Collect host-machine-specific information. |
| . ${srcdir}/config.host || exit 1 |
| |
| target_gtfiles= |
| |
| # Collect target-machine-specific information. |
| . ${srcdir}/config.gcc || exit 1 |
| |
| extra_objs="${host_extra_objs} ${extra_objs}" |
| extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}" |
| |
| # Default the target-machine variables that were not explicitly set. |
| if test x"$tm_file" = x |
| then tm_file=$cpu_type/$cpu_type.h; fi |
| |
| if test x"$extra_headers" = x |
| then extra_headers=; fi |
| |
| if test x$md_file = x |
| then md_file=$cpu_type/$cpu_type.md; fi |
| |
| if test x$out_file = x |
| then out_file=$cpu_type/$cpu_type.c; fi |
| |
| if test x"$tmake_file" = x |
| then tmake_file=$cpu_type/t-$cpu_type |
| fi |
| |
| # Support --enable-initfini-array. |
| if test x$enable_initfini_array != xno; then |
| tm_file="${tm_file} initfini-array.h" |
| fi |
| |
| if test x"$dwarf2" = xyes |
| then tm_file="$tm_file tm-dwarf2.h" |
| fi |
| |
| # Say what files are being used for the output code and MD file. |
| echo "Using \`$srcdir/config/$out_file' for machine-specific logic." |
| echo "Using \`$srcdir/config/$md_file' as machine description file." |
| |
| # If any of the xm_file variables contain nonexistent files, warn |
| # about them and drop them. |
| |
| bx= |
| for x in $build_xm_file; do |
| if test -f $srcdir/config/$x |
| then bx="$bx $x" |
| else AC_MSG_WARN($srcdir/config/$x does not exist.) |
| fi |
| done |
| build_xm_file="$bx" |
| |
| hx= |
| for x in $host_xm_file; do |
| if test -f $srcdir/config/$x |
| then hx="$hx $x" |
| else AC_MSG_WARN($srcdir/config/$x does not exist.) |
| fi |
| done |
| host_xm_file="$hx" |
| |
| tx= |
| for x in $xm_file; do |
| if test -f $srcdir/config/$x |
| then tx="$tx $x" |
| else AC_MSG_WARN($srcdir/config/$x does not exist.) |
| fi |
| done |
| xm_file="$tx" |
| |
| count=a |
| for f in $tm_file; do |
| count=${count}x |
| done |
| if test $count = ax; then |
| echo "Using \`$srcdir/config/$tm_file' as target machine macro file." |
| else |
| echo "Using the following target machine macro files:" |
| for f in $tm_file; do |
| echo " $srcdir/config/$f" |
| done |
| fi |
| |
| if test x$use_long_long_for_widest_fast_int = xyes; then |
| AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1, |
| [Define to 1 if the 'long long' type is wider than 'long' but still |
| efficiently supported by the host hardware.]) |
| fi |
| |
| gnu_ld_bool=`if test x"$gnu_ld" = x"yes"; then echo 1; else echo 0; fi` |
| AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld_bool, [Define to 1 if using GNU ld.]) |
| |
| gnu_as_bool=`if test x"$gas" = x"yes"; then echo 1; else echo 0; fi` |
| AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as_bool, [Define to 1 if using GNU as.]) |
| |
| count=a |
| for f in $host_xm_file; do |
| count=${count}x |
| done |
| if test $count = a; then |
| : |
| elif test $count = ax; then |
| echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file." |
| else |
| echo "Using the following host machine macro files:" |
| for f in $host_xm_file; do |
| echo " $srcdir/config/$f" |
| done |
| fi |
| echo "Using ${out_host_hook_obj} for host machine hooks." |
| |
| if test "$host_xm_file" != "$build_xm_file"; then |
| count=a |
| for f in $build_xm_file; do |
| count=${count}x |
| done |
| if test $count = a; then |
| : |
| elif test $count = ax; then |
| echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file." |
| else |
| echo "Using the following build machine macro files:" |
| for f in $build_xm_file; do |
| echo " $srcdir/config/$f" |
| done |
| fi |
| fi |
| |
| if test -n "$configured_native_system_header_dir"; then |
| native_system_header_dir=$configured_native_system_header_dir |
| fi |
| NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir" |
| AC_SUBST(NATIVE_SYSTEM_HEADER_DIR) |
| |
| case ${host} in |
| powerpc*-*-darwin*) |
| AC_CACHE_CHECK([whether mcontext_t fields have underscores], |
| gcc_cv_mcontext_underscores, |
| AC_COMPILE_IFELSE([AC_LANG_SOURCE([ |
| #include <sys/cdefs.h> |
| #include <sys/signal.h> |
| #include <ucontext.h> |
| int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; } |
| ])], |
| gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes)) |
| if test $gcc_cv_mcontext_underscores = yes; then |
| AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl |
| [mcontext_t fields start with __]) |
| fi |
| ;; |
| esac |
| |
| # --------- |
| # Threading |
| # --------- |
| |
| # Check if a valid thread package |
| case ${enable_threads} in |
| "" | no) |
| # No threads |
| target_thread_file='single' |
| ;; |
| yes) |
| # default |
| target_thread_file='single' |
| ;; |
| aix | dce | lynx | mipssde | posix | rtems | \ |
| single | tpf | vxworks | win32) |
| target_thread_file=${enable_threads} |
| ;; |
| *) |
| echo "${enable_threads} is an unknown thread package" 1>&2 |
| exit 1 |
| ;; |
| esac |
| |
| if test x${thread_file} = x; then |
| # No thread file set by target-specific clauses in config.gcc, |
| # so use file chosen by default logic above |
| thread_file=${target_thread_file} |
| fi |
| |
| # -------- |
| # UNSORTED |
| # -------- |
| |
| use_cxa_atexit=no |
| if test x$enable___cxa_atexit = xyes || \ |
| test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then |
| if test x$host = x$target; then |
| case $host in |
| # mingw32 doesn't have __cxa_atexit but uses atexit registration |
| # keyed to flag_use_cxa_atexit |
| *-*-mingw32*) |
| use_cxa_atexit=yes |
| ;; |
| powerpc-ibm-aix*) |
| use_cxa_atexit=yes |
| ;; |
| *) |
| AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes], |
| [echo "__cxa_atexit can't be enabled on this target"]) |
| ;; |
| esac |
| else |
| # We can't check for __cxa_atexit when building a cross, so assume |
| # it is available |
| use_cxa_atexit=yes |
| fi |
| if test x$use_cxa_atexit = xyes; then |
| AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2, |
| [Define if you want to use __cxa_atexit, rather than atexit, to |
| register C++ destructors for local statics and global objects. |
| This is essential for fully standards-compliant handling of |
| destructors, but requires __cxa_atexit in libc.]) |
| fi |
| fi |
| |
| # Look for a file containing extra machine modes. |
| if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then |
| extra_modes_file='$(srcdir)'/config/${extra_modes} |
| AC_SUBST(extra_modes_file) |
| AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes", |
| [Define to the name of a file containing a list of extra machine modes |
| for this architecture.]) |
| fi |
| |
| # Convert extra_options into a form suitable for Makefile use. |
| extra_opt_files= |
| all_opt_files= |
| for f in $extra_options; do |
| extra_opt_files="$extra_opt_files \$(srcdir)/config/$f" |
| all_opt_files="$all_opt_files $srcdir/config/$f" |
| done |
| AC_SUBST(extra_opt_files) |
| |
| # auto-host.h is the file containing items generated by autoconf and is |
| # the first file included by config.h. |
| # If host=build, it is correct to have bconfig include auto-host.h |
| # as well. If host!=build, we are in error and need to do more |
| # work to find out the build config parameters. |
| if test x$host = x$build |
| then |
| build_auto=auto-host.h |
| HAVE_AUTO_BUILD='# ' |
| else |
| # We create a subdir, then run autoconf in the subdir. |
| # To prevent recursion we set host and build for the new |
| # invocation of configure to the build for this invocation |
| # of configure. |
| tempdir=build.$$ |
| rm -rf $tempdir |
| mkdir $tempdir |
| cd $tempdir |
| case ${srcdir} in |
| /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};; |
| *) realsrcdir=../${srcdir};; |
| esac |
| # Clearing GMPINC is necessary to prevent host headers being |
| # used by the build compiler. Defining GENERATOR_FILE stops |
| # system.h from including gmp.h. |
| CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \ |
| CXX="${CXX_FOR_BUILD}" CXXFLAGS="${CXXFLAGS_FOR_BUILD}" \ |
| LD="${LD_FOR_BUILD}" LDFLAGS="${LDFLAGS_FOR_BUILD}" \ |
| GMPINC="" CPPFLAGS="${CPPFLAGS} -DGENERATOR_FILE" \ |
| ${realsrcdir}/configure \ |
| --enable-languages=${enable_languages-all} \ |
| ${enable_obsolete+--enable-obsolete="$enable_obsolete"} \ |
| ${enable_option_checking+--enable-option-checking="$enable_option_checking"} \ |
| --target=$target_alias --host=$build_alias \ |
| --build=$build_alias || exit # retaining $tempdir |
| |
| # We just finished tests for the build machine, so rename |
| # the file auto-build.h in the gcc directory. |
| mv auto-host.h ../auto-build.h |
| cd .. |
| rm -rf $tempdir |
| build_auto=auto-build.h |
| HAVE_AUTO_BUILD= |
| fi |
| AC_SUBST(build_subdir) |
| AC_SUBST(HAVE_AUTO_BUILD) |
| |
| tm_file="${tm_file} defaults.h" |
| tm_p_file="${tm_p_file} tm-preds.h" |
| tm_d_file="${tm_d_file} defaults.h" |
| host_xm_file="auto-host.h ansidecl.h ${host_xm_file}" |
| build_xm_file="${build_auto} ansidecl.h ${build_xm_file}" |
| # We don't want ansidecl.h in target files, write code there in ISO/GNU C. |
| # put this back in temporarily. |
| xm_file="auto-host.h ansidecl.h ${xm_file}" |
| |
| # -------- |
| # UNSORTED |
| # -------- |
| |
| changequote(,)dnl |
| # Compile in configure arguments. |
| if test -f configargs.h ; then |
| # Being re-configured. |
| gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'` |
| gcc_reconf_arguments=`echo "$gcc_config_arguments" | sed -e 's/^.*\( : (reconfigured) .*$\)/\1/'` |
| if [ "$gcc_reconf_arguments" != " : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS" ]; then |
| gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS" |
| fi |
| else |
| gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS" |
| fi |
| |
| # Double all backslashes and backslash all quotes to turn |
| # gcc_config_arguments into a C string. |
| sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out |
| $gcc_config_arguments |
| EOF |
| gcc_config_arguments_str=`cat conftest.out` |
| rm -f conftest.out |
| |
| cat > configargs.h <<EOF |
| /* Generated automatically. */ |
| static const char configuration_arguments[] = "$gcc_config_arguments_str"; |
| static const char thread_model[] = "$thread_file"; |
| |
| static const struct { |
| const char *name, *value; |
| } configure_default_options[] = $configure_default_options; |
| EOF |
| changequote([,])dnl |
| |
| changequote(,)dnl |
| gcc_BASEVER=`cat $srcdir/BASE-VER` |
| gcc_DEVPHASE=`cat $srcdir/DEV-PHASE` |
| gcc_DATESTAMP=`cat $srcdir/DATESTAMP` |
| if test -f $srcdir/REVISION ; then |
| gcc_REVISION=`cat $srcdir/REVISION` |
| else |
| gcc_REVISION="" |
| fi |
| cat > plugin-version.h <<EOF |
| #include "configargs.h" |
| |
| #define GCCPLUGIN_VERSION_MAJOR `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'` |
| #define GCCPLUGIN_VERSION_MINOR `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'` |
| #define GCCPLUGIN_VERSION_PATCHLEVEL `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'` |
| #define GCCPLUGIN_VERSION (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR) |
| |
| static char basever[] = "$gcc_BASEVER"; |
| static char datestamp[] = "$gcc_DATESTAMP"; |
| static char devphase[] = "$gcc_DEVPHASE"; |
| static char revision[] = "$gcc_REVISION"; |
| |
| /* FIXME plugins: We should make the version information more precise. |
| One way to do is to add a checksum. */ |
| |
| static struct plugin_gcc_version gcc_version = {basever, datestamp, |
| devphase, revision, |
| configuration_arguments}; |
| EOF |
| changequote([,])dnl |
| |
| # Determine what GCC version number to use in filesystem paths. |
| GCC_BASE_VER |
| |
| # Internationalization |
| ZW_GNU_GETTEXT_SISTER_DIR |
| |
| # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get |
| # -liconv on the link line twice. |
| case "$LIBINTL" in *$LIBICONV*) |
| LIBICONV= ;; |
| esac |
| |
| AC_ARG_ENABLE(secureplt, |
| [AS_HELP_STRING([--enable-secureplt], |
| [enable -msecure-plt by default for PowerPC])], |
| [], []) |
| |
| AC_ARG_ENABLE(mingw-wildcard, |
| [AS_HELP_STRING([--enable-mingw-wildcard], |
| [Set whether to expand wildcard on command-line. |
| Default to platform configuration])], |
| [],[enable_mingw_wildcard=platform]) |
| AS_IF([test x"$enable_mingw_wildcard" != xplatform ], |
| [AC_DEFINE_UNQUOTED(MINGW_DOWILDCARD, |
| $(test x"$enable_mingw_wildcard" = xno; echo $?), |
| [Value to set mingw's _dowildcard to.])]) |
| |
| AC_ARG_ENABLE(large-address-aware, |
| [AS_HELP_STRING([--enable-large-address-aware], |
| [Link mingw executables with --large-address-aware])]) |
| AS_IF([test x"$enable_large_address_aware" = xyes], |
| [AC_DEFINE([MINGW_DEFAULT_LARGE_ADDR_AWARE], 1, |
| [Define if we should link mingw executables with --large-address-aware])]) |
| |
| AC_ARG_ENABLE(leading-mingw64-underscores, |
| AS_HELP_STRING([--enable-leading-mingw64-underscores], |
| [enable leading underscores on 64 bit mingw targets]), |
| [],[]) |
| AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ], |
| [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1, |
| [Define if we should use leading underscore on 64 bit mingw targets])]) |
| |
| AC_ARG_ENABLE(cld, |
| [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [], |
| [enable_cld=no]) |
| |
| AC_ARG_ENABLE(frame-pointer, |
| [AS_HELP_STRING([--enable-frame-pointer], |
| [enable -fno-omit-frame-pointer by default for x86])], [], |
| [ |
| case $target_os in |
| linux* | gnu* | darwin[[8912]]* | cygwin* | mingw*) |
| # Enable -fomit-frame-pointer by default for these systems with DWARF2. |
| enable_frame_pointer=no |
| ;; |
| *) |
| enable_frame_pointer=yes |
| ;; |
| esac |
| ]) |
| |
| case $target in |
| i[[34567]]86-*-* | x86_64-*-*) |
| if test "x$enable_cld" = xyes; then |
| tm_defines="${tm_defines} USE_IX86_CLD=1" |
| fi |
| if test "x$enable_frame_pointer" = xyes; then |
| tm_defines="${tm_defines} USE_IX86_FRAME_POINTER=1" |
| fi |
| ;; |
| esac |
| |
| # Windows32 Registry support for specifying GCC installation paths. |
| AC_ARG_ENABLE(win32-registry, |
| [AS_HELP_STRING([--disable-win32-registry], |
| [disable lookup of installation paths in the |
| Registry on Windows hosts]) |
| AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)]) |
| AS_HELP_STRING([--enable-win32-registry=KEY], |
| [use KEY instead of GCC version as the last portion |
| of the registry key])],,) |
| |
| case $host_os in |
| win32 | pe | cygwin* | mingw32*) |
| if test "x$enable_win32_registry" != xno; then |
| AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no]) |
| fi |
| |
| if test "x$enable_win32_registry" != xno; then |
| AC_DEFINE(ENABLE_WIN32_REGISTRY, 1, |
| [Define to 1 if installation paths should be looked up in the Windows |
| Registry. Ignored on non-Windows hosts.]) |
| |
| if test "x$enable_win32_registry" != xyes \ |
| && test "x$enable_win32_registry" != x; then |
| AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry", |
| [Define to be the last component of the Windows registry key under which |
| to look for installation paths. The full key used will be |
| HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}. |
| The default is the GCC version number.]) |
| fi |
| fi |
| ;; |
| esac |
| |
| # Get an absolute path to the GCC top-level source directory |
| holddir=`${PWDCMD-pwd}` |
| cd $srcdir |
| topdir=`${PWDCMD-pwd}` |
| cd $holddir |
| |
| # Conditionalize the makefile for this host machine. |
| xmake_file= |
| for f in ${host_xmake_file} |
| do |
| if test -f ${srcdir}/config/$f |
| then |
| xmake_file="${xmake_file} \$(srcdir)/config/$f" |
| fi |
| done |
| |
| # Conditionalize the makefile for this target machine. |
| tmake_file_= |
| for f in ${tmake_file} |
| do |
| if test -f ${srcdir}/config/$f |
| then |
| tmake_file_="${tmake_file_} \$(srcdir)/config/$f" |
| fi |
| done |
| tmake_file="${tmake_file_}${omp_device_property_tmake_file}" |
| |
| out_object_file=`basename $out_file .c`.o |
| common_out_object_file=`basename $common_out_file .c`.o |
| |
| tm_file_list="options.h" |
| tm_include_list="options.h insn-constants.h" |
| for f in $tm_file; do |
| case $f in |
| ./* ) |
| f=`echo $f | sed 's/^..//'` |
| tm_file_list="${tm_file_list} $f" |
| tm_include_list="${tm_include_list} $f" |
| ;; |
| defaults.h ) |
| tm_file_list="${tm_file_list} \$(srcdir)/$f" |
| tm_include_list="${tm_include_list} $f" |
| ;; |
| * ) |
| tm_file_list="${tm_file_list} \$(srcdir)/config/$f" |
| tm_include_list="${tm_include_list} config/$f" |
| ;; |
| esac |
| done |
| |
| tm_p_file_list= |
| tm_p_include_list= |
| for f in $tm_p_file; do |
| case $f in |
| tm-preds.h ) |
| tm_p_file_list="${tm_p_file_list} $f" |
| tm_p_include_list="${tm_p_include_list} $f" |
| ;; |
| * ) |
| tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f" |
| tm_p_include_list="${tm_p_include_list} config/$f" |
| esac |
| done |
| |
| tm_d_file_list= |
| tm_d_include_list="options.h insn-constants.h" |
| for f in $tm_d_file; do |
| case $f in |
| defaults.h ) |
| tm_d_file_list="${tm_d_file_list} \$(srcdir)/$f" |
| tm_d_include_list="${tm_d_include_list} $f" |
| ;; |
| * ) |
| tm_d_file_list="${tm_d_file_list} \$(srcdir)/config/$f" |
| tm_d_include_list="${tm_d_include_list} config/$f" |
| ;; |
| esac |
| done |
| |
| xm_file_list= |
| xm_include_list= |
| for f in $xm_file; do |
| case $f in |
| ansidecl.h ) |
| xm_file_list="${xm_file_list} \$(srcdir)/../include/$f" |
| xm_include_list="${xm_include_list} $f" |
| ;; |
| auto-host.h ) |
| xm_file_list="${xm_file_list} $f" |
| xm_include_list="${xm_include_list} $f" |
| ;; |
| * ) |
| xm_file_list="${xm_file_list} \$(srcdir)/config/$f" |
| xm_include_list="${xm_include_list} config/$f" |
| ;; |
| esac |
| done |
| |
| host_xm_file_list= |
| host_xm_include_list= |
| for f in $host_xm_file; do |
| case $f in |
| ansidecl.h ) |
| host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f" |
| host_xm_include_list="${host_xm_include_list} $f" |
| ;; |
| auto-host.h ) |
| host_xm_file_list="${host_xm_file_list} $f" |
| host_xm_include_list="${host_xm_include_list} $f" |
| ;; |
| * ) |
| host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f" |
| host_xm_include_list="${host_xm_include_list} config/$f" |
| ;; |
| esac |
| done |
| |
| build_xm_file_list= |
| for f in $build_xm_file; do |
| case $f in |
| ansidecl.h ) |
| build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f" |
| build_xm_include_list="${build_xm_include_list} $f" |
| ;; |
| auto-build.h | auto-host.h ) |
| build_xm_file_list="${build_xm_file_list} $f" |
| build_xm_include_list="${build_xm_include_list} $f" |
| ;; |
| * ) |
| build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f" |
| build_xm_include_list="${build_xm_include_list} config/$f" |
| ;; |
| esac |
| done |
| |
| # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a |
| # cross-compiler which does not use the native headers and libraries. |
| # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR. |
| CROSS= AC_SUBST(CROSS) |
| ALL=all.internal AC_SUBST(ALL) |
| SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR) |
| BUILD_SYSTEM_HEADER_DIR=$SYSTEM_HEADER_DIR AC_SUBST(BUILD_SYSTEM_HEADER_DIR) |
| |
| if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x || |
| test x$build != x$host || test "x$with_build_sysroot" != x; then |
| if test "x$with_build_sysroot" != x; then |
| BUILD_SYSTEM_HEADER_DIR=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)' |
| else |
| BUILD_SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)' |
| fi |
| |
| if test x$host != x$target |
| then |
| CROSS="-DCROSS_DIRECTORY_STRUCTURE" |
| ALL=all.cross |
| SYSTEM_HEADER_DIR=$BUILD_SYSTEM_HEADER_DIR |
| elif test "x$TARGET_SYSTEM_ROOT" != x; then |
| SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)' |
| fi |
| |
| if test "x$with_build_sysroot" != "x"; then |
| target_header_dir="${with_build_sysroot}${native_system_header_dir}" |
| elif test "x$with_sysroot" = x; then |
| target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include" |
| elif test "x$with_sysroot" = xyes; then |
| target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}" |
| else |
| target_header_dir="${with_sysroot}${native_system_header_dir}" |
| fi |
| else |
| target_header_dir=${native_system_header_dir} |
| fi |
| |
| # If this is a cross-compiler that does not |
| # have its own set of headers then define |
| # inhibit_libc |
| |
| # If this is using newlib, without having the headers available now, |
| # then define inhibit_libc in LIBGCC2_CFLAGS. |
| # This prevents libgcc2 from containing any code which requires libc |
| # support. |
| : ${inhibit_libc=false} |
| if { { test x$host != x$target && test "x$with_sysroot" = x ; } || |
| test x$with_newlib = xyes ; } && |
| { test "x$with_headers" = xno || test ! -f "$target_header_dir/stdio.h"; } ; then |
| inhibit_libc=true |
| fi |
| AC_SUBST(inhibit_libc) |
| |
| # When building gcc with a cross-compiler, we need to adjust things so |
| # that the generator programs are still built with the native compiler. |
| # Also, we cannot run fixincludes. |
| |
| # These are the normal (build=host) settings: |
| CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD) |
| CXX_FOR_BUILD='$(CXX)' AC_SUBST(CXX_FOR_BUILD) |
| BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS) |
| BUILD_CXXFLAGS='$(ALL_CXXFLAGS)' AC_SUBST(BUILD_CXXFLAGS) |
| BUILD_LDFLAGS='$(LDFLAGS)' AC_SUBST(BUILD_LDFLAGS) |
| STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC) |
| |
| BUILD_NO_PIE_CFLAGS='$(NO_PIE_CFLAGS)' AC_SUBST(BUILD_NO_PIE_CFLAGS) |
| BUILD_NO_PIE_FLAG='$(NO_PIE_FLAG)' AC_SUBST(BUILD_NO_PIE_FLAG) |
| |
| # And these apply if build != host, or we are generating coverage data |
| if test x$build != x$host || test "x$coverage_flags" != x |
| then |
| BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)' |
| BUILD_CXXFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CXXFLAGS_FOR_BUILD)' |
| BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)' |
| |
| NO_PIE_CFLAGS_FOR_BUILD=${NO_PIE_CFLAGS_FOR_BUILD-${NO_PIE_CFLAGS}} |
| NO_PIE_FLAG_FOR_BUILD=${NO_PIE_FLAG_FOR_BUILD-${NO_PIE_FLAG}} |
| BUILD_NO_PIE_CFLAGS='$(NO_PIE_CFLAGS_FOR_BUILD)' |
| BUILD_NO_PIE_FLAG='$(NO_PIE_FLAG_FOR_BUILD)' |
| fi |
| AC_SUBST(NO_PIE_CFLAGS_FOR_BUILD) |
| AC_SUBST(NO_PIE_FLAG_FOR_BUILD) |
| |
| # Expand extra_headers to include complete path. |
| # This substitutes for lots of t-* files. |
| extra_headers_list= |
| # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers. |
| for file in ${extra_headers} ; do |
| extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}" |
| done |
| |
| # If use_gcc_tgmath is set, append ginclude/tgmath.h. |
| if test x"$use_gcc_tgmath" = xyes |
| then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h" |
| fi |
| |
| # Define collect2 in Makefile. |
| case $host_can_use_collect2 in |
| no) collect2= ;; |
| *) collect2='collect2$(exeext)' ;; |
| esac |
| AC_SUBST([collect2]) |
| |
| # Add a definition of USE_COLLECT2 if system wants one. |
| case $use_collect2 in |
| no) use_collect2= ;; |
| "") ;; |
| *) |
| host_xm_defines="${host_xm_defines} USE_COLLECT2" |
| xm_defines="${xm_defines} USE_COLLECT2" |
| case $host_can_use_collect2 in |
| no) |
| AC_MSG_ERROR([collect2 is required but cannot be built on this system]) |
| ;; |
| esac |
| ;; |
| esac |
| |
| AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}", |
| [Define to the name of the LTO plugin DSO that must be |
| passed to the linker's -plugin=LIB option.]) |
| |
| # --------------------------- |
| # Assembler & linker features |
| # --------------------------- |
| |
| # During stage 2, ld is actually gcc/collect-ld, which is a small script to |
| # discern between when to use prev-ld/ld-new and when to use ld/ld-new. |
| # However when ld-new is first executed from the build tree, libtool will |
| # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers |
| # to the build tree. While doing this we need to use the previous-stage |
| # linker, or we have an infinite loop. The presence of a shell script as |
| # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses |
| # the gcc/collect-ld script. So we need to know how libtool works, or |
| # exec-tool will fail. |
| |
| m4_defun([_LT_CONFIG_COMMANDS], []) |
| AC_PROG_LIBTOOL |
| AC_SUBST(objdir) |
| AC_SUBST(enable_fast_install) |
| |
| # Identify the assembler which will work hand-in-glove with the newly |
| # built GCC, so that we can examine its features. This is the assembler |
| # which will be driven by the driver program. |
| # |
| # If build != host, and we aren't building gas in-tree, we identify a |
| # build->target assembler and hope that it will have the same features |
| # as the host->target assembler we'll be using. |
| gcc_cv_gas_major_version= |
| gcc_cv_gas_minor_version= |
| gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas |
| |
| m4_pattern_allow([AS_FOR_TARGET])dnl |
| AS_VAR_SET_IF(gcc_cv_as,, [ |
| if test -x "$DEFAULT_ASSEMBLER"; then |
| gcc_cv_as="$DEFAULT_ASSEMBLER" |
| elif test -f $gcc_cv_as_gas_srcdir/configure.ac \ |
| && test -f ../gas/Makefile \ |
| && test x$build = x$host; then |
| gcc_cv_as=../gas/as-new$build_exeext |
| elif test -x as$build_exeext; then |
| # Build using assembler in the current directory. |
| gcc_cv_as=./as$build_exeext |
| elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then |
| gcc_cv_as="$AS_FOR_TARGET" |
| else |
| AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET) |
| fi]) |
| |
| ORIGINAL_AS_FOR_TARGET=$gcc_cv_as |
| AC_SUBST(ORIGINAL_AS_FOR_TARGET) |
| case "$ORIGINAL_AS_FOR_TARGET" in |
| ./as | ./as$build_exeext) ;; |
| *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;; |
| esac |
| |
| AC_MSG_CHECKING(what assembler to use) |
| if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then |
| # Single tree build which includes gas. We want to prefer it |
| # over whatever linker top-level may have detected, since |
| # we'll use what we're building after installation anyway. |
| AC_MSG_RESULT(newly built gas) |
| in_tree_gas=yes |
| _gcc_COMPUTE_GAS_VERSION |
| in_tree_gas_is_elf=no |
| if grep 'obj_format = elf' ../gas/Makefile > /dev/null \ |
| || (grep 'obj_format = multi' ../gas/Makefile \ |
| && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null |
| then |
| in_tree_gas_is_elf=yes |
| fi |
| else |
| AC_MSG_RESULT($gcc_cv_as) |
| in_tree_gas=no |
| fi |
| |
| default_ld= |
| AC_ARG_ENABLE(ld, |
| [[ --enable-ld[=ARG] build ld [ARG={default,yes,no}]]], |
| [case "${enableval}" in |
| no) |
| default_ld=ld.gold |
| ;; |
| esac]) |
| |
| install_gold_as_default=no |
| AC_ARG_ENABLE(gold, |
| [[ --enable-gold[=ARG] build gold [ARG={default,yes,no}]]], |
| [case "${enableval}" in |
| default) |
| install_gold_as_default=yes |
| ;; |
| yes) |
| if test x${default_ld} != x; then |
| install_gold_as_default=yes |
| fi |
| ;; |
| no) |
| ;; |
| *) |
| AC_MSG_ERROR([invalid --enable-gold argument]) |
| ;; |
| esac]) |
| |
| # Identify the linker which will work hand-in-glove with the newly |
| # built GCC, so that we can examine its features. This is the linker |
| # which will be driven by the driver program. |
| # |
| # If build != host, and we aren't building gas in-tree, we identify a |
| # build->target linker and hope that it will have the same features |
| # as the host->target linker we'll be using. |
| gcc_cv_gld_major_version= |
| gcc_cv_gld_minor_version= |
| gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld |
| gcc_cv_ld_gold_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gold |
| gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd |
| |
| AS_VAR_SET_IF(gcc_cv_ld,, [ |
| if test -x "$DEFAULT_LINKER"; then |
| gcc_cv_ld="$DEFAULT_LINKER" |
| elif test $install_gold_as_default = yes \ |
| && test -f $gcc_cv_ld_gold_srcdir/configure.ac \ |
| && test -f ../gold/Makefile \ |
| && test x$build = x$host; then |
| gcc_cv_ld=../gold/ld-new$build_exeext |
| elif test -f $gcc_cv_ld_gld_srcdir/configure.ac \ |
| && test -f ../ld/Makefile \ |
| && test x$build = x$host; then |
| gcc_cv_ld=../ld/ld-new$build_exeext |
| elif test -x collect-ld$build_exeext; then |
| # Build using linker in the current directory. |
| gcc_cv_ld=./collect-ld$build_exeext |
| elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then |
| gcc_cv_ld="$LD_FOR_TARGET" |
| else |
| AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET) |
| fi]) |
| |
| ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld |
| PLUGIN_LD_SUFFIX=`basename $gcc_cv_ld | sed -e "s,$target_alias-,,"` |
| # if the PLUGIN_LD is set ld-new, just have it as ld |
| # as that is the installed named. |
| if test x$PLUGIN_LD_SUFFIX = xld-new \ |
| || test x$PLUGIN_LD_SUFFIX = xcollect-ld ; then |
| PLUGIN_LD_SUFFIX=ld |
| fi |
| AC_ARG_WITH(plugin-ld, |
| [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])], |
| [if test x"$withval" != x; then |
| ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval" |
| PLUGIN_LD_SUFFIX="$withval" |
| fi]) |
| AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET) |
| AC_DEFINE_UNQUOTED(PLUGIN_LD_SUFFIX, "$PLUGIN_LD_SUFFIX", [Specify plugin linker]) |
| |
| # Check to see if we are using gold instead of ld |
| AC_MSG_CHECKING(whether we are using gold) |
| ld_is_gold=no |
| if test x$gcc_cv_ld != x; then |
| if $gcc_cv_ld --version 2>/dev/null | sed 1q \ |
| | grep "GNU gold" > /dev/null; then |
| ld_is_gold=yes |
| fi |
| fi |
| AC_MSG_RESULT($ld_is_gold) |
| |
| AC_MSG_CHECKING(gold linker with split stack support as non default) |
| # Check to see if default ld is not gold, but gold is |
| # available and has support for split stack. If gcc was configured |
| # with gold then no checking is done. |
| # |
| if test x$ld_is_gold = xno && which ${gcc_cv_ld}.gold >/dev/null 2>&1; then |
| |
| # For platforms other than powerpc64*, enable as appropriate. |
| |
| gold_non_default=no |
| ld_gold=`which ${gcc_cv_ld}.gold` |
| # Make sure this gold has minimal split stack support |
| if $ld_gold --help 2>/dev/null | grep split-stack-adjust-size >/dev/null 2>&1; then |
| ld_vers=`$ld_gold --version | sed 1q` |
| gold_vers=`echo $ld_vers | sed -n \ |
| -e 's,^[[^)]]*[[ ]]\([[0-9]][[0-9]]*\.[[0-9]][[0-9]]*[[^)]]*\)) .*$,\1,p'` |
| case $target in |
| # check that the gold version contains the complete split stack support |
| # on powerpc64 big and little endian |
| powerpc64*-*-*) |
| case "$gold_vers" in |
| 2.25.[[1-9]]*|2.2[[6-9]][[.0-9]]*|2.[[3-9]][[.0-9]]*|[[3-9]].[[.0-9]]*) gold_non_default=yes |
| ;; |
| *) gold_non_default=no |
| ;; |
| esac |
| ;; |
| esac |
| fi |
| if test $gold_non_default = yes; then |
| AC_DEFINE(HAVE_GOLD_NON_DEFAULT_SPLIT_STACK, 1, |
| [Define if the gold linker supports split stack and is available as a non-default]) |
| fi |
| fi |
| AC_MSG_RESULT($gold_non_default) |
| |
| ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld |
| AC_SUBST(ORIGINAL_LD_FOR_TARGET) |
| case "$ORIGINAL_LD_FOR_TARGET" in |
| ./collect-ld | ./collect-ld$build_exeext) ;; |
| *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;; |
| esac |
| |
| AC_MSG_CHECKING(what linker to use) |
| if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \ |
| || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then |
| # Single tree build which includes ld. We want to prefer it |
| # over whatever linker top-level may have detected, since |
| # we'll use what we're building after installation anyway. |
| AC_MSG_RESULT(newly built ld) |
| in_tree_ld=yes |
| in_tree_ld_is_elf=no |
| if (grep 'EMUL = .*elf' ../ld/Makefile \ |
| || grep 'EMUL = .*linux' ../ld/Makefile \ |
| || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then |
| in_tree_ld_is_elf=yes |
| elif test "$ld_is_gold" = yes; then |
| in_tree_ld_is_elf=yes |
| fi |
| for f in $gcc_cv_ld_bfd_srcdir/configure $gcc_cv_ld_gld_srcdir/configure $gcc_cv_ld_gld_srcdir/configure.ac $gcc_cv_ld_gld_srcdir/Makefile.in |
| do |
| changequote(,)dnl |
| gcc_cv_gld_version=`sed -n -e 's/^[ ]*VERSION=[^0-9A-Za-z_]*\([0-9]*\.[0-9]*.*\)/VERSION=\1/p' < $f` |
| if test x$gcc_cv_gld_version != x; then |
| break |
| fi |
| done |
| case $gcc_cv_gld_version in |
| VERSION=[0-9]*) ;; |
| changequote([,])dnl |
| *) AC_MSG_ERROR([[cannot find version of in-tree linker]]) ;; |
| changequote(,)dnl |
| esac |
| gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"` |
| gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"` |
| changequote([,])dnl |
| ORIGINAL_LD_BFD_FOR_TARGET=../ld/ld-new$build_exeext |
| ORIGINAL_LD_GOLD_FOR_TARGET=../gold/ld-new$build_exeext |
| else |
| AC_MSG_RESULT($gcc_cv_ld) |
| in_tree_ld=no |
| gcc_cvs_ld_program=`dirname $gcc_cv_ld`/`basename $gcc_cv_ld $host_exeext` |
| ORIGINAL_LD_BFD_FOR_TARGET=${gcc_cvs_ld_program}.bfd$host_exeext |
| ORIGINAL_LD_GOLD_FOR_TARGET=${gcc_cvs_ld_program}.gold$host_exeext |
| fi |
| |
| AC_SUBST(ORIGINAL_LD_BFD_FOR_TARGET) |
| AC_SUBST(ORIGINAL_LD_GOLD_FOR_TARGET) |
| |
| # Figure out what nm we will be using. |
| gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils |
| AS_VAR_SET_IF(gcc_cv_nm,, [ |
| if test -f $gcc_cv_binutils_srcdir/configure.ac \ |
| && test -f ../binutils/Makefile \ |
| && test x$build = x$host; then |
| gcc_cv_nm=../binutils/nm-new$build_exeext |
| elif test -x nm$build_exeext; then |
| gcc_cv_nm=./nm$build_exeext |
| elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then |
| gcc_cv_nm="$NM_FOR_TARGET" |
| else |
| AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET) |
| fi]) |
| |
| AC_MSG_CHECKING(what nm to use) |
| if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then |
| # Single tree build which includes binutils. |
| AC_MSG_RESULT(newly built nm) |
| in_tree_nm=yes |
| else |
| AC_MSG_RESULT($gcc_cv_nm) |
| in_tree_nm=no |
| fi |
| |
| ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm |
| AC_SUBST(ORIGINAL_NM_FOR_TARGET) |
| case "$ORIGINAL_NM_FOR_TARGET" in |
| ./nm | ./nm$build_exeext) ;; |
| *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;; |
| esac |
| |
| |
| # Figure out what objdump we will be using. |
| AS_VAR_SET_IF(gcc_cv_objdump,, [ |
| if test -f $gcc_cv_binutils_srcdir/configure.ac \ |
| && test -f ../binutils/Makefile \ |
| && test x$build = x$host; then |
| # Single tree build which includes binutils. |
| gcc_cv_objdump=../binutils/objdump$build_exeext |
| elif test -x objdump$build_exeext; then |
| gcc_cv_objdump=./objdump$build_exeext |
| elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then |
| gcc_cv_objdump="$OBJDUMP_FOR_TARGET" |
| else |
| AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET) |
| fi]) |
| |
| AC_MSG_CHECKING(what objdump to use) |
| if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then |
| # Single tree build which includes binutils. |
| AC_MSG_RESULT(newly built objdump) |
| elif test x$gcc_cv_objdump = x; then |
| AC_MSG_RESULT(not found) |
| else |
| AC_MSG_RESULT($gcc_cv_objdump) |
| fi |
| |
| # Figure out what readelf we will be using. |
| AS_VAR_SET_IF(gcc_cv_readelf,, [ |
| if test -f $gcc_cv_binutils_srcdir/configure.ac \ |
| && test -f ../binutils/Makefile \ |
| && test x$build = x$host; then |
| # Single tree build which includes binutils. |
| gcc_cv_readelf=../binutils/readelf$build_exeext |
| elif test -x readelf$build_exeext; then |
| gcc_cv_readelf=./readelf$build_exeext |
| elif ( set dummy $READELF_FOR_TARGET; test -x $[2] ); then |
| gcc_cv_readelf="$READELF_FOR_TARGET" |
| else |
| AC_PATH_PROG(gcc_cv_readelf, $READELF_FOR_TARGET) |
| fi]) |
| |
| AC_MSG_CHECKING(what readelf to use) |
| if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then |
| # Single tree build which includes binutils. |
| AC_MSG_RESULT(newly built readelf) |
| elif test x$gcc_cv_readelf = x; then |
| AC_MSG_RESULT(not found) |
| else |
| AC_MSG_RESULT($gcc_cv_readelf) |
| fi |
| |
| # Figure out what otool we will be using. |
| AS_VAR_SET_IF(gcc_cv_otool,, [ |
| if test -x otool$build_exeext; then |
| gcc_cv_otool=./otool$build_exeext |
| elif ( set dummy $OTOOL_FOR_TARGET; test -x $[2] ); then |
| gcc_cv_otool="$OTOOL_FOR_TARGET" |
| else |
| AC_PATH_PROG(gcc_cv_otool, $OTOOL_FOR_TARGET) |
| fi]) |
| |
| AC_MSG_CHECKING(what otool to use) |
| if test x$gcc_cv_otool = x; then |
| AC_MSG_RESULT(not found) |
| else |
| AC_MSG_RESULT($gcc_cv_otool) |
| fi |
| |
| # Figure out what assembler alignment features are present. |
| gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align, |
| [2,6,0],, |
| [.balign 4 |
| .p2align 2],, |
| [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1, |
| [Define if your assembler supports .balign and .p2align.])]) |
| |
| gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align, |
| [2,8,0],, |
| [.p2align 4,,7],, |
| [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1, |
| [Define if your assembler supports specifying the maximum number |
| of bytes to skip when using the GAS .p2align command.])]) |
| |
| gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16, |
| [2,8,0],, |
| [.literal16],, |
| [AC_DEFINE(HAVE_GAS_LITERAL16, 1, |
| [Define if your assembler supports .literal16.])]) |
| |
| gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1, |
| [elf,2,9,0],, |
| [conftest_label1: .word 0 |
| .subsection -1 |
| conftest_label2: .word 0 |
| .previous], |
| [if test x$gcc_cv_nm != x; then |
| $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1 |
| $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2 |
| if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1 |
| then : |
| else gcc_cv_as_subsection_m1=yes |
| fi |
| rm -f conftest.nm1 conftest.nm2 |
| fi], |
| [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1, |
| [Define if your assembler supports .subsection and .subsection -1 starts |
| emitting at the beginning of your section.])]) |
| |
| gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak, |
| [2,2,0],, |
| [ .weak foobar],, |
| [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])]) |
| |
| gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref, |
| [2,17,0],, |
| [ .weakref foobar, barfnot],, |
| [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])]) |
| |
| gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat, |
| [2,15,91],, |
| [ .SPACE $TEXT$ |
| .NSUBSPA $CODE$,COMDAT],, |
| [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])]) |
| |
| # .hidden needs to be supported in both the assembler and the linker, |
| # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN. |
| # This is irritatingly difficult to feature test for; we have to check the |
| # date string after the version number. If we've got an in-tree |
| # ld, we don't know its patchlevel version, so we set the baseline at 2.13 |
| # to be safe. |
| # The gcc_GAS_CHECK_FEATURE call just sets a cache variable. |
| case "${target}" in |
| *-*-aix*) |
| conftest_s=' .globl foobar,hidden' |
| ;; |
| *) |
| conftest_s=' .hidden foobar |
| foobar:' |
| ;; |
| esac |
| gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden, |
| [elf,2,13,0],, [$conftest_s]) |
| case "${target}" in |
| *-*-darwin*) |
| # Darwin as has some visibility support, though with a different syntax. |
| gcc_cv_as_hidden=yes |
| ;; |
| esac |
| |
| # gnu_indirect_function type is an extension proposed at |
| # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime |
| # selection of function implementation |
| AC_ARG_ENABLE(gnu-indirect-function, |
| [AS_HELP_STRING([--enable-gnu-indirect-function], |
| [enable the use of the @gnu_indirect_function to glibc systems])], |
| [case $enable_gnu_indirect_function in |
| yes | no) ;; |
| *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function. |
| Valid choices are 'yes' and 'no'.]) ;; |
| esac], |
| [enable_gnu_indirect_function="$default_gnu_indirect_function"]) |
| |
| case "${target}" in |
| riscv*-*-linux*) |
| AC_MSG_CHECKING(linker ifunc IRELATIVE support) |
| cat > conftest.s <<EOF |
| .text |
| .type foo_resolver, @function |
| foo_resolver: |
| ret |
| .size foo_resolver, .-foo_resolver |
| |
| .globl foo |
| .type foo, %gnu_indirect_function |
| .set foo, foo_resolver |
| |
| .globl bar |
| .type bar, @function |
| bar: |
| call foo |
| ret |
| .size bar, .-bar |
| EOF |
| if test x$gcc_cv_as != x \ |
| && test x$gcc_cv_ld != x \ |
| && test x$gcc_cv_readelf != x \ |
| && $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \ |
| && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1 \ |
| && $gcc_cv_readelf --relocs --wide conftest \ |
| | grep R_RISCV_IRELATIVE > /dev/null 2>&1; then |
| enable_gnu_indirect_function=yes |
| fi |
| rm -f conftest conftest.o conftest.s |
| AC_MSG_RESULT($enable_gnu_indirect_function) |
| ;; |
| esac |
| |
| gif=`if test x$enable_gnu_indirect_function = xyes; then echo 1; else echo 0; fi` |
| AC_DEFINE_UNQUOTED(HAVE_GNU_INDIRECT_FUNCTION, $gif, |
| [Define if your system supports gnu indirect functions.]) |
| |
| |
| changequote(,)dnl |
| if test $in_tree_ld != yes ; then |
| ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q` |
| if echo "$ld_ver" | grep GNU > /dev/null; then |
| if test x"$ld_is_gold" = xyes; then |
| # GNU gold --version looks like this: |
| # |
| # GNU gold (GNU Binutils 2.21.51.20110225) 1.11 |
| # |
| # We extract the binutils version which is more familiar and specific |
| # than the gold version. |
| ld_vers=`echo $ld_ver | sed -n \ |
| -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'` |
| else |
| # GNU ld --version looks like this: |
| # |
| # GNU ld (GNU Binutils) 2.21.51.20110225 |
| ld_vers=`echo $ld_ver | sed -n \ |
| -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'` |
| fi |
| ld_date=`echo $ld_ver | sed -n 's,^.*\([2-9][0-9][0-9][0-9]\)\(-*\)\([01][0-9]\)\2\([0-3][0-9]\).*$,\1\3\4,p'` |
| ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'` |
| ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'` |
| ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'` |
| else |
| case "${target}" in |
| *-*-solaris2*) |
| # Solaris 2 ld -V output looks like this for a regular version: |
| # |
| # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1699 |
| # |
| # but test versions add stuff at the end: |
| # |
| # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1701:onnv-ab196087-6931056-03/25/10 |
| # |
| # ld and ld.so.1 are guaranteed to be updated in lockstep, so ld version |
| # numbers can be used in ld.so.1 feature checks even if a different |
| # linker is configured. |
| ld_ver=`$gcc_cv_ld -V 2>&1` |
| if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then |
| ld_vers=`echo $ld_ver | sed -n \ |
| -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'` |
| ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'` |
| ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'` |
| fi |
| ;; |
| esac |
| fi |
| fi |
| changequote([,])dnl |
| |
| AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden, |
| [[if test $in_tree_ld = yes ; then |
| gcc_cv_ld_hidden=no |
| if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 13 -o "$gcc_cv_gld_major_version" -gt 2 \ |
| && test $in_tree_ld_is_elf = yes; then |
| gcc_cv_ld_hidden=yes |
| fi |
| else |
| gcc_cv_ld_hidden=yes |
| if test x"$ld_is_gold" = xyes; then |
| : |
| elif echo "$ld_ver" | grep GNU > /dev/null; then |
| if test 0"$ld_date" -lt 20020404; then |
| if test -n "$ld_date"; then |
| # If there was date string, but was earlier than 2002-04-04, fail |
| gcc_cv_ld_hidden=no |
| elif test -z "$ld_vers"; then |
| # If there was no date string nor ld version number, something is wrong |
| gcc_cv_ld_hidden=no |
| else |
| test -z "$ld_vers_patch" && ld_vers_patch=0 |
| if test "$ld_vers_major" -lt 2; then |
| gcc_cv_ld_hidden=no |
| elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then |
| gcc_cv_ld_hidden="no" |
| elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then |
| gcc_cv_ld_hidden=no |
| fi |
| fi |
| fi |
| else |
| case "${target}" in |
| *-*-aix[789]*) |
| gcc_cv_ld_hidden=yes |
| ;; |
| *-*-darwin*) |
| # Darwin ld has some visibility support. |
| gcc_cv_ld_hidden=yes |
| ;; |
| hppa64*-*-hpux* | ia64*-*-hpux*) |
| gcc_cv_ld_hidden=yes |
| ;; |
| *-*-solaris2*) |
| # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but |
| # .symbolic was only added in Solaris 9 12/02. |
| gcc_cv_ld_hidden=yes |
| ;; |
| *) |
| gcc_cv_ld_hidden=no |
| ;; |
| esac |
| fi |
| fi]]) |
| libgcc_visibility=no |
| AC_SUBST(libgcc_visibility) |
| GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN]) |
| if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then |
| libgcc_visibility=yes |
| AC_DEFINE(HAVE_GAS_HIDDEN, 1, |
| [Define if your assembler and linker support .hidden.]) |
| fi |
| |
| AC_MSG_CHECKING(linker read-only and read-write section mixing) |
| gcc_cv_ld_ro_rw_mix=unknown |
| if test $in_tree_ld = yes ; then |
| if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 10 -o "$gcc_cv_gld_major_version" -gt 2 \ |
| && test $in_tree_ld_is_elf = yes; then |
| gcc_cv_ld_ro_rw_mix=read-write |
| fi |
| elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then |
| echo '.section myfoosect, "a"' > conftest1.s |
| echo '.section myfoosect, "aw"' > conftest2.s |
| echo '.byte 1' >> conftest2.s |
| echo '.section myfoosect, "a"' > conftest3.s |
| echo '.byte 0' >> conftest3.s |
| if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \ |
| && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \ |
| && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \ |
| && $gcc_cv_ld -shared -o conftest1.so conftest1.o \ |
| conftest2.o conftest3.o > /dev/null 2>&1; then |
| gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \ |
| | sed -e '/myfoosect/!d' -e N` |
| if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then |
| if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then |
| gcc_cv_ld_ro_rw_mix=read-only |
| else |
| gcc_cv_ld_ro_rw_mix=read-write |
| fi |
| fi |
| fi |
| changequote(,)dnl |
| rm -f conftest.* conftest[123].* |
| changequote([,])dnl |
| fi |
| if test x$gcc_cv_ld_ro_rw_mix = xread-write; then |
| AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1, |
| [Define if your linker links a mix of read-only |
| and read-write sections into a read-write section.]) |
| fi |
| AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix) |
| |
| gcc_AC_INITFINI_ARRAY |
| |
| # Check if we have .[us]leb128, and support symbol arithmetic with it. |
| # Older versions of GAS and some non-GNU assemblers, have a bugs handling |
| # these directives, even when they appear to accept them. |
| gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128, |
| [elf,2,11,0],, |
| [ .data |
| .uleb128 L2 - L1 |
| L1: |
| .uleb128 1280 |
| .sleb128 -1010 |
| L2: |
| .uleb128 0x8000000000000000 |
| ], |
| [[ |
| if test "x$gcc_cv_objdump" != x; then |
| if $gcc_cv_objdump -s conftest.o 2>/dev/null \ |
| | grep '04800a8e 78808080 80808080 808001' >/dev/null; then |
| gcc_cv_as_leb128=yes |
| fi |
| elif test "x$gcc_cv_otool" != x; then |
| if $gcc_cv_otool -d conftest.o 2>/dev/null \ |
| | grep '04 80 0a 8e 78 80 80 80 80 80 80 80 80 80 01' >/dev/null; then |
| gcc_cv_as_leb128=yes |
| fi |
| else |
| # play safe, assume the assembler is broken. |
| : |
| fi |
| ]], |
| [AC_DEFINE(HAVE_AS_LEB128, 1, |
| [Define if your assembler supports .sleb128 and .uleb128.])], |
| [AC_DEFINE(HAVE_AS_LEB128, 0, |
| [Define if your assembler supports .sleb128 and .uleb128.])]) |
| |
| # Determine if an .eh_frame section is read-only. |
| gcc_fn_eh_frame_ro () { |
| $gcc_cv_as $1 -o conftest.o conftest.s > /dev/null 2>&1 && \ |
| $gcc_cv_objdump -h conftest.o 2>/dev/null | \ |
| sed -e '/.eh_frame/!d' -e N | grep READONLY > /dev/null |
| } |
| |
| # Check if we have assembler support for unwind directives. |
| gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive, |
| ,, |
| [ .text |
| .cfi_startproc |
| .cfi_offset 0, 0 |
| .cfi_same_value 1 |
| .cfi_def_cfa 1, 2 |
| .cfi_escape 1, 2, 3, 4, 5 |
| .cfi_endproc], |
| [case "$target" in |
| *-*-solaris*) |
| # If the linker used on Solaris (like Sun ld) isn't capable of merging |
| # read-only and read-write sections, we need to make sure that the |
| # assembler used emits read-write .eh_frame sections. |
| if test "x$gcc_cv_ld_ro_rw_mix" = xread-write; then |
| gcc_cv_as_cfi_directive=yes |
| elif test "x$gcc_cv_objdump" = x; then |
| # No objdump, err on the side of caution. |
| gcc_cv_as_cfi_directive=no |
| else |
| if test x$gas = xyes; then |
| as_32_opt="--32" |
| as_64_opt="--64" |
| else |
| as_32_opt="-m32" |
| as_64_opt="-m64" |
| fi |
| case "$target" in |
| sparc*-*-solaris2.*) |
| # On Solaris/SPARC, .eh_frame sections should always be read-write. |
| if gcc_fn_eh_frame_ro $as_32_opt \ |
| || gcc_fn_eh_frame_ro $as_64_opt; then |
| gcc_cv_as_cfi_directive=no |
| else |
| gcc_cv_as_cfi_directive=yes |
| fi |
| ;; |
| i?86-*-solaris2.* | x86_64-*-solaris2.*) |
| # On Solaris/x86, make sure that GCC and assembler agree on using |
| # read-only .eh_frame sections for 64-bit. |
| if gcc_fn_eh_frame_ro $as_32_opt; then |
| gcc_cv_as_cfi_directive=no |
| elif gcc_fn_eh_frame_ro $as_64_opt; then |
| gcc_cv_as_cfi_directive=yes |
| else |
| gcc_cv_as_cfi_directive=no |
| fi |
| ;; |
| esac |
| fi |
| ;; |
| *-*-*) |
| gcc_cv_as_cfi_directive=yes |
| ;; |
| esac]) |
| if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then |
| gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working, |
| ,, |
| [ .text |
| .cfi_startproc |
| .cfi_adjust_cfa_offset 64 |
| .skip 75040, 0 |
| .cfi_adjust_cfa_offset 128 |
| .cfi_endproc], |
| [[ |
| if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \ |
| | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then |
| gcc_cv_as_cfi_advance_working=yes |
| fi |
| ]]) |
| else |
| # no objdump, err on the side of caution |
| gcc_cv_as_cfi_advance_working=no |
| fi |
| GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE) |
| AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE, |
| [`if test $gcc_cv_as_cfi_directive = yes \ |
| && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`], |
| [Define 0/1 if your assembler supports CFI directives.]) |
| |
| GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE) |
| gcc_GAS_CHECK_FEATURE([cfi personality directive], |
| gcc_cv_as_cfi_personality_directive, ,, |
| [ .text |
| .cfi_startproc |
| .cfi_personality 0, symbol |
| .cfi_endproc]) |
| AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE, |
| [`if test $gcc_cv_as_cfi_personality_directive = yes; then echo 1; else echo 0; fi`], |
| [Define 0/1 if your assembler supports .cfi_personality.]) |
| |
| gcc_GAS_CHECK_FEATURE([cfi sections directive], |
| gcc_cv_as_cfi_sections_directive, ,, |
| [ .text |
| .cfi_sections .debug_frame, .eh_frame |
| .cfi_startproc |
| .cfi_endproc], |
| [case $target_os in |
| win32 | pe | cygwin* | mingw32*) |
| # Need to check that we generated the correct relocation for the |
| # .debug_frame section. This was fixed for binutils 2.21. |
| gcc_cv_as_cfi_sections_directive=no |
| if test "x$gcc_cv_objdump" != x; then |
| if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \ |
| grep secrel > /dev/null; then |
| gcc_cv_as_cfi_sections_directive=yes |
| fi |
| fi |
| ;; |
| *) |
| gcc_cv_as_cfi_sections_directive=yes |
| ;; |
| esac]) |
| GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE) |
| AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE, |
| [`if test $gcc_cv_as_cfi_sections_directive = yes; then echo 1; else echo 0; fi`], |
| [Define 0/1 if your assembler supports .cfi_sections.]) |
| |
| # GAS versions up to and including 2.11.0 may mis-optimize |
| # .eh_frame data. |
| gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame, |
| [elf,2,12,0],, |
| [ .text |
| .LFB1: |
| .4byte 0 |
| .L1: |
| .4byte 0 |
| .LFE1: |
| .section .eh_frame,"aw",@progbits |
| __FRAME_BEGIN__: |
| .4byte .LECIE1-.LSCIE1 |
| .LSCIE1: |
| .4byte 0x0 |
| .byte 0x1 |
| .ascii "z\0" |
| .byte 0x1 |
| .byte 0x78 |
| .byte 0x1a |
| .byte 0x0 |
| .byte 0x4 |
| .4byte 1 |
| .p2align 1 |
| .LECIE1: |
| .LSFDE1: |
| .4byte .LEFDE1-.LASFDE1 |
| .LASFDE1: |
| .4byte .LASFDE1-__FRAME_BEGIN__ |
| .4byte .LFB1 |
| .4byte .LFE1-.LFB1 |
| .byte 0x4 |
| .4byte .LFE1-.LFB1 |
| .byte 0x4 |
| .4byte .L1-.LFB1 |
| .LEFDE1:], |
| [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@. |
| cat > conftest.lit <<EOF |
| 0000 10000000 00000000 017a0001 781a0004 .........z..x... |
| 0010 01000000 12000000 18000000 00000000 ................ |
| 0020 08000000 04080000 0044 .........D @&t@ |
| EOF |
| cat > conftest.big <<EOF |
| 0000 00000010 00000000 017a0001 781a0004 .........z..x... |
| 0010 00000001 00000012 00000018 00000000 ................ |
| 0020 00000008 04000000 0844 .........D @&t@ |
| EOF |
| # If the assembler didn't choke, and we can objdump, |
| # and we got the correct data, then succeed. |
| # The text in the here-document typically retains its unix-style line |
| # endings, while the output of objdump will use host line endings. |
| # Therefore, use diff -b for the comparisons. |
| if test x$gcc_cv_objdump != x \ |
| && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \ |
| | tail -3 > conftest.got \ |
| && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \ |
| || diff -b conftest.big conftest.got > /dev/null 2>&1; } |
| then |
| gcc_cv_as_eh_frame=yes |
| elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then |
| gcc_cv_as_eh_frame=buggy |
| else |
| # Uh oh, what do we do now? |
| gcc_cv_as_eh_frame=no |
| fi]) |
| |
| if test $gcc_cv_as_eh_frame = buggy; then |
| AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1, |
| [Define if your assembler mis-optimizes .eh_frame data.]) |
| fi |
| |
| # Test if the assembler supports the section flag 'e' or #exclude for |
| # specifying an excluded section. |
| gcc_GAS_CHECK_FEATURE([section exclude flag], gcc_cv_as_section_exclude_e, |
| [2,22,51], [--fatal-warnings], |
| [.section foo1,"e" |
| .byte 0,0,0,0]) |
| if test $gcc_cv_as_section_exclude_e = no; then |
| case "${target}" in |
| # Solaris as uses #exclude instead. |
| *-*-solaris2*) |
| case "${target}" in |
| sparc*-*-solaris2*) |
| conftest_s='.section "foo1", #exclude' |
| ;; |
| i?86-*-solaris2* | x86_64-*-solaris2*) |
| conftest_s='.section foo1, #exclude' |
| ;; |
| esac |
| ;; |
| esac |
| gcc_GAS_CHECK_FEATURE([section exclude flag], gcc_cv_as_section_exclude_hash,,, |
| [$conftest_s |
| .byte 0,0,0,0]) |
| fi |
| AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE, |
| [`if test $gcc_cv_as_section_exclude_e = yes || test $gcc_cv_as_section_exclude_hash = yes; then echo 1; else echo 0; fi`], |
| [Define if your assembler supports specifying the exclude section flag.]) |
| |
| # Test if the assembler supports the section flag 'R' for specifying |
| # section with SHF_GNU_RETAIN. |
| case "${target}" in |
| # Solaris may use GNU assembler with Solairs ld. Even if GNU |
| # assembler supports the section flag 'R', it doesn't mean that |
| # Solairs ld supports it. |
| *-*-solaris2*) |
| gcc_cv_as_shf_gnu_retain=no |
| ;; |
| *) |
| gcc_GAS_CHECK_FEATURE([section 'R' flag], gcc_cv_as_shf_gnu_retain, |
| [elf,2,36,0], [--fatal-warnings], |
| [.section .foo,"awR",%progbits |
| .byte 0]) |
| ;; |
| esac |
| AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_GNU_RETAIN, |
| [`if test $gcc_cv_as_shf_gnu_retain = yes; then echo 1; else echo 0; fi`], |
| [Define 0/1 if your assembler supports marking sections with SHF_GNU_RETAIN flag.]) |
| |
| # Test if the assembler supports the section flag 'o' for specifying |
| # section with link-order. |
| case "${target}" in |
| # Solaris may use GNU assembler with Solairs ld. Even if GNU |
| # assembler supports the section flag 'o', it doesn't mean that |
| # Solairs ld supports it. |
| *-*-solaris2*) |
| gcc_cv_as_section_link_order=no |
| ;; |
| *) |
| gcc_GAS_CHECK_FEATURE([section 'o' flag], gcc_cv_as_section_link_order, |
| [2,35,0], [--fatal-warnings], |
| [.section .foo,"a" |
| .byte 0 |
| .section __patchable_function_entries,"awo",%progbits,.foo |
| .byte 0]) |
| ;; |
| esac |
| AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_LINK_ORDER, |
| [`if test $gcc_cv_as_section_link_order = yes; then echo 1; else echo 0; fi`], |
| [Define 0/1 if your assembler supports 'o' flag in .section directive.]) |
| |
| gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge, |
| [elf,2,12,0], [--fatal-warnings], |
| [.section .rodata.str, "aMS", @progbits, 1]) |
| if test $gcc_cv_as_shf_merge = no; then |
| gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge, |
| [elf,2,12,0], [--fatal-warnings], |
| [.section .rodata.str, "aMS", %progbits, 1]) |
| fi |
| AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE, |
| [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`], |
| [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.]) |
| |
| gcc_cv_ld_aligned_shf_merge=yes |
| case "$target" in |
| # SHF_MERGE support is broken in Solaris ld up to Solaris 11.3/SPARC for |
| # alignment > 1. |
| sparc*-*-solaris2.11*) |
| if test x"$gnu_ld" = xno \ |
| && test "$ld_vers_major" -lt 2 && test "$ld_vers_minor" -lt 3159; then |
| gcc_cv_ld_aligned_shf_merge=no |
| fi |
| ;; |
| esac |
| AC_DEFINE_UNQUOTED(HAVE_LD_ALIGNED_SHF_MERGE, |
| [`if test $gcc_cv_ld_aligned_shf_merge = yes; then echo 1; else echo 0; fi`], |
| [Define 0/1 if your linker supports the SHF_MERGE flag with section alignment > 1.]) |
| |
| gcc_GAS_CHECK_FEATURE([stabs directive], gcc_cv_as_stabs_directive, ,, |
| [.stabs "gcc2_compiled.",60,0,0,0],, |
| [AC_DEFINE(HAVE_AS_STABS_DIRECTIVE, 1, |
| [Define if your assembler supports .stabs.])]) |
| |
| gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)], |
| gcc_cv_as_comdat_group, |
| [elf,2,16,0], [--fatal-warnings], |
| [.section .text,"axG",@progbits,.foo,comdat]) |
| if test $gcc_cv_as_comdat_group = yes; then |
| gcc_cv_as_comdat_group_percent=no |
| gcc_cv_as_comdat_group_group=no |
| else |
| gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)], |
| gcc_cv_as_comdat_group_percent, |
| [elf,2,16,0], [--fatal-warnings], |
| [.section .text,"axG",%progbits,.foo,comdat]) |
| if test $gcc_cv_as_comdat_group_percent = yes; then |
| gcc_cv_as_comdat_group_group=no |
| else |
| case "${target}" in |
| # Sun as uses a completely different syntax. |
| *-*-solaris2*) |
| case "${target}" in |
| sparc*-*-solaris2*) |
| conftest_s=' |
| .group foo,".text%foo",#comdat |
| .section ".text%foo", #alloc,#execinstr,#progbits |
| .globl foo |
| foo: |
| ' |
| ;; |
| i?86-*-solaris2* | x86_64-*-solaris2*) |
| conftest_s=' |
| .group foo,.text%foo,#comdat |
| .section .text%foo, "ax", @progbits |
| .globl foo |
| foo: |
| ' |
| ;; |
| esac |
| gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)], |
| gcc_cv_as_comdat_group_group, |
| ,, [$conftest_s]) |
| ;; |
| esac |
| if test -z "${gcc_cv_as_comdat_group_group+set}"; then |
| gcc_cv_as_comdat_group_group=no |
| fi |
| fi |
| fi |
| if test x"$ld_is_gold" = xyes; then |
| comdat_group=yes |
| elif test $in_tree_ld = yes ; then |
| comdat_group=no |
| if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 16 -o "$gcc_cv_gld_major_version" -gt 2 \ |
| && test $in_tree_ld_is_elf = yes; then |
| comdat_group=yes |
| fi |
| elif echo "$ld_ver" | grep GNU > /dev/null; then |
| comdat_group=yes |
| if test 0"$ld_date" -lt 20050308; then |
| if test -n "$ld_date"; then |
| # If there was date string, but was earlier than 2005-03-08, fail |
| comdat_group=no |
| elif test "$ld_vers_major" -lt 2; then |
| comdat_group=no |
| elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then |
| comdat_group=no |
| fi |
| fi |
| else |
| changequote(,)dnl |
| case "${target}" in |
| *-*-solaris2.1[1-9]*) |
| comdat_group=no |
| # Sun ld has COMDAT group support since Solaris 9, but it doesn't |
| # interoperate with GNU as until Solaris 11 build 130, i.e. ld |
| # version 1.688. |
| # |
| # If using Sun as for COMDAT group as emitted by GCC, one needs at |
| # least ld version 1.2267. |
| if test "$ld_vers_major" -gt 1; then |
| comdat_group=yes |
| elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then |
| comdat_group=yes |
| elif test "$ld_vers_minor" -ge 2267; then |
| comdat_group=yes |
| fi |
| ;; |
| *) |
| # Assume linkers other than GNU ld don't support COMDAT group. |
| comdat_group=no |
| ;; |
| esac |
| changequote([,])dnl |
| fi |
| # Allow overriding the automatic COMDAT group tests above. |
| AC_ARG_ENABLE(comdat, |
| [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])], |
| [comdat_group="$enable_comdat"]) |
| if test $comdat_group = no; then |
| gcc_cv_as_comdat_group=no |
| gcc_cv_as_comdat_group_percent=no |
| gcc_cv_as_comdat_group_group=no |
| fi |
| AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP, |
| [`if test $gcc_cv_as_comdat_group = yes \ |
| || test $gcc_cv_as_comdat_group_percent = yes \ |
| || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`], |
| [Define 0/1 if your assembler and linker support COMDAT groups.]) |
| |
| # Restrict this test to Solaris/x86: other targets define this statically. |
| case "${target}" in |
| i?86-*-solaris2* | x86_64-*-solaris2*) |
| AC_MSG_CHECKING(support for hidden thunks in linkonce sections) |
| if test $in_tree_ld = yes || echo "$ld_ver" | grep GNU > /dev/null; then |
| hidden_linkonce=yes |
| else |
| case "${target}" in |
| # Full support for hidden thunks in linkonce sections only appeared in |
| # Solaris 11/OpenSolaris. |
| *-*-solaris2.1[[1-9]]*) |
| hidden_linkonce=yes |
| ;; |
| *) |
| hidden_linkonce=no |
| ;; |
| esac |
| fi |
| AC_MSG_RESULT($hidden_linkonce) |
| AC_DEFINE_UNQUOTED(USE_HIDDEN_LINKONCE, |
| [`if test $hidden_linkonce = yes; then echo 1; else echo 0; fi`], |
| [Define 0/1 if your linker supports hidden thunks in linkonce sections.]) |
| ;; |
| esac |
| |
| gcc_GAS_CHECK_FEATURE([line table is_stmt support], |
| gcc_cv_as_is_stmt, |
| [2,16,92],, |
| [ .text |
| .file 1 "conf.c" |
| .loc 1 1 0 is_stmt 1],, |
| [AC_DEFINE(HAVE_GAS_LOC_STMT, 1, |
| [Define if your assembler supports the .loc is_stmt sub-directive.])]) |
| |
| gcc_GAS_CHECK_FEATURE([line table discriminator support], |
| gcc_cv_as_discriminator, |
| [2,19,51],, |
| [ .text |
| .file 1 "conf.c" |
| .loc 1 1 0 discriminator 1],, |
| [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1, |
| [Define if your assembler supports the .loc discriminator sub-directive.])]) |
| |
| # Catch the newlib flag of the same name so we can gate GCC features on it. |
| AC_ARG_ENABLE(newlib-nano-formatted-io, |
| [AS_HELP_STRING([--enable-newlib-nano-formatted-io], [Use nano version |
| formatted IO])], |
| [case "${enableval}" in |
| yes|no) |
| ;; |
| *) |
| AC_MSG_ERROR([unknown newlib-nano-formatted-io setting $enableval]) |
| ;; |
| esac], []) |
| |
| # Thread-local storage - the check is heavily parameterized. |
| conftest_s= |
| tls_first_major= |
| tls_first_minor= |
| tls_as_opt= |
| case "$target" in |
| changequote(,)dnl |
| alpha*-*-*) |
| conftest_s=' |
| .section ".tdata","awT",@progbits |
| foo: .long 25 |
| .text |
| ldq $27,__tls_get_addr($29) !literal!1 |
| lda $16,foo($29) !tlsgd!1 |
| jsr $26,($27),__tls_get_addr !lituse_tlsgd!1 |
| ldq $27,__tls_get_addr($29) !literal!2 |
| lda $16,foo($29) !tlsldm!2 |
| jsr $26,($27),__tls_get_addr !lituse_tlsldm!2 |
| ldq $1,foo($29) !gotdtprel |
| ldah $2,foo($29) !dtprelhi |
| lda $3,foo($2) !dtprello |
| lda $4,foo($29) !dtprel |
| ldq $1,foo($29) !gottprel |
| ldah $2,foo($29) !tprelhi |
| lda $3,foo($2) !tprello |
| lda $4,foo($29) !tprel' |
| tls_first_major=2 |
| tls_first_minor=13 |
| tls_as_opt=--fatal-warnings |
| ;; |
| arc*-*-*) |
| conftest_s=' |
| add_s r0,r0, @foo@tpoff' |
| tls_first_major=2 |
| tls_first_minor=23 |
| ;; |
| cris-*-*|crisv32-*-*) |
| conftest_s=' |
| .section ".tdata","awT",@progbits |
| x: .long 25 |
| .text |
| move.d x:IE,$r10 |
| nop' |
| tls_first_major=2 |
| tls_first_minor=20 |
| tls_as_opt=--fatal-warnings |
| ;; |
| frv*-*-*) |
| conftest_s=' |
| .section ".tdata","awT",@progbits |
| x: .long 25 |
| .text |
| call #gettlsoff(x)' |
| tls_first_major=2 |
| tls_first_minor=14 |
| ;; |
| hppa*-*-linux*) |
| conftest_s=' |
| t1: .reg %r20 |
| t2: .reg %r21 |
| gp: .reg %r19 |
| .section ".tdata","awT",@progbits |
| foo: .long 25 |
| .text |
| .align 4 |
| addil LT%foo-$tls_gdidx$,gp |
| ldo RT%foo-$tls_gdidx$(%r1),%arg0 |
| b __tls_get_addr |
| nop |
| addil LT%foo-$tls_ldidx$,gp |
| b __tls_get_addr |
| ldo RT%foo-$tls_ldidx$(%r1),%arg0 |
| addil LR%foo-$tls_dtpoff$,%ret0 |
| ldo RR%foo-$tls_dtpoff$(%r1),%t1 |
| mfctl %cr27,%t1 |
| addil LT%foo-$tls_ieoff$,gp |
| ldw RT%foo-$tls_ieoff$(%r1),%t2 |
| add %t1,%t2,%t3 |
| mfctl %cr27,%t1 |
| addil LR%foo-$tls_leoff$,%t1 |
| ldo RR%foo-$tls_leoff$(%r1),%t2' |
| tls_first_major=2 |
| tls_first_minor=15 |
| tls_as_opt=--fatal-warnings |
| ;; |
| arm*-*-*) |
| conftest_s=' |
| .section ".tdata","awT",%progbits |
| foo: .long 25 |
| .text |
| .word foo(gottpoff) |
| .word foo(tpoff) |
| .word foo(tlsgd) |
| .word foo(tlsldm) |
| .word foo(tlsldo)' |
| tls_first_major=2 |
| tls_first_minor=17 |
| ;; |
| i[34567]86-*-* | x86_64-*-*) |
| case "$target" in |
| i[34567]86-*-solaris2.* | x86_64-*-solaris2.*) |
| on_solaris=yes |
| ;; |
| *) |
| on_solaris=no |
| ;; |
| esac |
| if test x$on_solaris = xyes && test x$gas_flag = xno; then |
| conftest_s=' |
| .section .tdata,"awt",@progbits' |
| tls_first_major=0 |
| tls_first_minor=0 |
| tls_section_flag=t |
| changequote([,])dnl |
| AC_DEFINE(TLS_SECTION_ASM_FLAG, 't', |
| [Define to the flag used to mark TLS sections if the default (`T') doesn't work.]) |
| changequote(,)dnl |
| else |
| conftest_s=' |
| .section ".tdata","awT",@progbits' |
| tls_first_major=2 |
| tls_first_minor=14 |
| tls_section_flag=T |
| tls_as_opt="--fatal-warnings" |
| fi |
| case "$target" in |
| i[34567]86-*-*) |
| if test x$on_solaris = xyes; then |
| case $gas_flag in |
| yes) tls_as_opt="$tls_as_opt --32" ;; |
| esac |
| fi |
| conftest_s="$conftest_s |
| foo: .long 25 |
| .text |
| movl %gs:0, %eax |
| leal foo@tlsgd(,%ebx,1), %eax |
| leal foo@tlsldm(%ebx), %eax |
| leal foo@dtpoff(%eax), %edx |
| movl foo@gottpoff(%ebx), %eax |
| subl foo@gottpoff(%ebx), %eax |
| addl foo@gotntpoff(%ebx), %eax |
| movl foo@indntpoff, %eax |
| movl \$foo@tpoff, %eax |
| subl \$foo@tpoff, %eax |
| leal foo@ntpoff(%ecx), %eax" |
| ;; |
| x86_64-*-*) |
| if test x$on_solaris = xyes; then |
| case $gas_flag in |
| yes) tls_as_opt="$tls_as_opt --64" ;; |
| no) tls_as_opt="$tls_as_opt -xarch=amd64" ;; |
| esac |
| fi |
| conftest_s="$conftest_s |
| foo: .long 25 |
| .text |
| movq %fs:0, %rax |
| leaq foo@tlsgd(%rip), %rdi |
| leaq foo@tlsld(%rip), %rdi |
| leaq foo@dtpoff(%rax), %rdx |
| movq foo@gottpoff(%rip), %rax |
| movq \$foo@tpoff, %rax" |
| ;; |
| esac |
| ;; |
| ia64-*-*) |
| conftest_s=' |
| .section ".tdata","awT",@progbits |
| foo: data8 25 |
| .text |
| addl r16 = @ltoff(@dtpmod(foo#)), gp |
| addl r17 = @ltoff(@dtprel(foo#)), gp |
| addl r18 = @ltoff(@tprel(foo#)), gp |
| addl r19 = @dtprel(foo#), gp |
| adds r21 = @dtprel(foo#), r13 |
| movl r23 = @dtprel(foo#) |
| addl r20 = @tprel(foo#), gp |
| adds r22 = @tprel(foo#), r13 |
| movl r24 = @tprel(foo#)' |
| tls_first_major=2 |
| tls_first_minor=13 |
| tls_as_opt=--fatal-warnings |
| ;; |
| microblaze*-*-*) |
| conftest_s=' |
| .section .tdata,"awT",@progbits |
| x: |
| .word 2 |
| .text |
| addik r5,r20,x@TLSGD |
| addik r5,r20,x@TLSLDM' |
| tls_first_major=2 |
| tls_first_minor=20 |
| tls_as_opt='--fatal-warnings' |
| ;; |
| mips*-*-*) |
| conftest_s=' |
| .section .tdata,"awT",@progbits |
| x: |
| .word 2 |
| .text |
| addiu $4, $28, %tlsgd(x) |
| addiu $4, $28, %tlsldm(x) |
| lui $4, %dtprel_hi(x) |
| addiu $4, $4, %dtprel_lo(x) |
| lw $4, %gottprel(x)($28) |
| lui $4, %tprel_hi(x) |
| addiu $4, $4, %tprel_lo(x)' |
| tls_first_major=2 |
| tls_first_minor=16 |
| tls_as_opt='-32 --fatal-warnings' |
| ;; |
| m68k-*-*) |
| conftest_s=' |
| .section .tdata,"awT",@progbits |
| x: |
| .word 2 |
| .text |
| foo: |
| move.l x@TLSGD(%a5),%a0 |
| move.l x@TLSLDM(%a5),%a0 |
| move.l x@TLSLDO(%a5),%a0 |
| move.l x@TLSIE(%a5),%a0 |
| move.l x@TLSLE(%a5),%a0' |
| tls_first_major=2 |
| tls_first_minor=19 |
| tls_as_opt='--fatal-warnings' |
| ;; |
| nios2-*-*) |
| conftest_s=' |
| .section ".tdata","awT",@progbits' |
| tls_first_major=2 |
| tls_first_minor=23 |
| tls_as_opt="--fatal-warnings" |
| ;; |
| aarch64*-*-*) |
| conftest_s=' |
| .section ".tdata","awT",%progbits |
| foo: .long 25 |
| .text |
| adrp x0, :tlsgd:x |
| add x0, x0, #:tlsgd_lo12:x |
| bl __tls_get_addr |
| nop' |
| tls_first_major=2 |
| tls_first_minor=20 |
| tls_as_opt='--fatal-warnings' |
| ;; |
| or1k*-*-*) |
| conftest_s=' |
| .section ".tdata","awT",@progbits |
| foo: .long 25 |
| .text |
| l.movhi r3, tpoffha(foo) |
| l.add r3, r3, r10 |
| l.lwz r4, tpofflo(foo)(r3)' |
| tls_first_major=2 |
| tls_first_minor=30 |
| tls_as_opt=--fatal-warnings |
| ;; |
| powerpc-ibm-aix*) |
| conftest_s=' |
| .extern __get_tpointer |
| .toc |
| LC..1: |
| .tc a[TC],a[TL]@le |
| .csect .text[PR] |
| .tlstest: |
| lwz 9,LC..1(2) |
| bla __get_tpointer |
| lwzx 3,9,3 |
| .globl a |
| .csect a[TL],4 |
| a: |
| .space 4' |
| tls_first_major=0 |
| tls_first_minor=0 |
| ;; |
| powerpc64*-*-*) |
| conftest_s=' |
| .section ".tdata","awT",@progbits |
| .align 3 |
| ld0: .space 8 |
| ld1: .space 8 |
| x1: .space 8 |
| x2: .space 8 |
| x3: .space 8 |
| .text |
| addi 3,2,ld0@got@tlsgd |
| bl .__tls_get_addr |
| nop |
| addi 3,2,ld1@toc |
| bl .__tls_get_addr |
| nop |
| addi 3,2,x1@got@tlsld |
| bl .__tls_get_addr |
| nop |
| addi 9,3,x1@dtprel |
| bl .__tls_get_addr |
| nop |
| addis 9,3,x2@dtprel@ha |
| addi 9,9,x2@dtprel@l |
| bl .__tls_get_addr |
| nop |
| ld 9,x3@got@dtprel(2) |
| add 9,9,3 |
| bl .__tls_get_addr |
| nop' |
| tls_first_major=2 |
| tls_first_minor=14 |
| tls_as_opt="-a64 --fatal-warnings" |
| ;; |
| powerpc*-*-*) |
| conftest_s=' |
| .section ".tdata","awT",@progbits |
| .align 2 |
| ld0: .space 4 |
| ld1: .space 4 |
| x1: .space 4 |
| x2: .space 4 |
| x3: .space 4 |
| .text |
| addi 3,31,ld0@got@tlsgd |
| bl __tls_get_addr |
| addi 3,31,x1@got@tlsld |
| bl __tls_get_addr |
| addi 9,3,x1@dtprel |
| addis 9,3,x2@dtprel@ha |
| addi 9,9,x2@dtprel@l |
| lwz 9,x3@got@tprel(31) |
| add 9,9,x@tls |
| addi 9,2,x1@tprel |
| addis 9,2,x2@tprel@ha |
| addi 9,9,x2@tprel@l' |
| tls_first_major=2 |
| tls_first_minor=14 |
| tls_as_opt="-a32 --fatal-warnings" |
| ;; |
| riscv*-*-*) |
| conftest_s=' |
| .section .tdata,"awT",@progbits |
| x: .word 2 |
| .text |
| la.tls.gd a0,x |
| call __tls_get_addr' |
| tls_first_major=2 |
| tls_first_minor=21 |
| tls_as_opt='--fatal-warnings' |
| ;; |
| s390-*-*) |
| conftest_s=' |
| .section ".tdata","awT",@progbits |
| foo: .long 25 |
| .text |
| .long foo@TLSGD |
| .long foo@TLSLDM |
| .long foo@DTPOFF |
| .long foo@NTPOFF |
| .long foo@GOTNTPOFF |
| .long foo@INDNTPOFF |
| l %r1,foo@GOTNTPOFF(%r12) |
| l %r1,0(%r1):tls_load:foo |
| bas %r14,0(%r1,%r13):tls_gdcall:foo |
| bas %r14,0(%r1,%r13):tls_ldcall:foo' |
| tls_first_major=2 |
| tls_first_minor=14 |
| tls_as_opt="-m31 --fatal-warnings" |
| ;; |
| s390x-*-*) |
| conftest_s=' |
| .section ".tdata","awT",@progbits |
| foo: .long 25 |
| .text |
| .quad foo@TLSGD |
| .quad foo@TLSLDM |
| .quad foo@DTPOFF |
| .quad foo@NTPOFF |
| .quad foo@GOTNTPOFF |
| lg %r1,foo@GOTNTPOFF(%r12) |
| larl %r1,foo@INDNTPOFF |
| brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo |
| brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo' |
| tls_first_major=2 |
| tls_first_minor=14 |
| tls_as_opt="-m64 -Aesame --fatal-warnings" |
| ;; |
| sh-*-* | sh[123456789lbe]*-*-*) |
| conftest_s=' |
| .section ".tdata","awT",@progbits |
| foo: .long 25 |
| .text |
| .long foo@TLSGD |
| .long foo@TLSLDM |
| .long foo@DTPOFF |
| .long foo@GOTTPOFF |
| .long foo@TPOFF' |
| tls_first_major=2 |
| tls_first_minor=13 |
| tls_as_opt=--fatal-warnings |
| ;; |
| sparc*-*-*) |
| case "$target" in |
| sparc*-sun-solaris2.*) |
| on_solaris=yes |
| ;; |
| *) |
| on_solaris=no |
| ;; |
| esac |
| if test x$on_solaris = xyes && test x$gas_flag = xno; then |
| conftest_s=' |
| .section ".tdata",#alloc,#write,#tls' |
| tls_first_major=0 |
| tls_first_minor=0 |
| else |
| conftest_s=' |
| .section ".tdata","awT",@progbits' |
| tls_first_major=2 |
| tls_first_minor=14 |
| tls_as_opt="-32 --fatal-warnings" |
| fi |
| conftest_s="$conftest_s |
| foo: .long 25 |
| .text |
| sethi %tgd_hi22(foo), %o0 |
| add %o0, %tgd_lo10(foo), %o1 |
| add %l7, %o1, %o0, %tgd_add(foo) |
| call __tls_get_addr, %tgd_call(foo) |
| sethi %tldm_hi22(foo), %l1 |
| add %l1, %tldm_lo10(foo), %l2 |
| add %l7, %l2, %o0, %tldm_add(foo) |
| call __tls_get_addr, %tldm_call(foo) |
| sethi %tldo_hix22(foo), %l3 |
| xor %l3, %tldo_lox10(foo), %l4 |
| add %o0, %l4, %l5, %tldo_add(foo) |
| sethi %tie_hi22(foo), %o3 |
| add %o3, %tie_lo10(foo), %o3 |
| ld [%l7 + %o3], %o2, %tie_ld(foo) |
| add %g7, %o2, %o4, %tie_add(foo) |
| sethi %tle_hix22(foo), %l1 |
| xor %l1, %tle_lox10(foo), %o5 |
| ld [%g7 + %o5], %o1" |
| ;; |
| tilepro*-*-*) |
| conftest_s=' |
| .section ".tdata","awT",@progbits |
| foo: .long 25 |
| .text |
| addli r0, zero, tls_gd(foo) |
| auli r0, zero, tls_gd_ha16(foo) |
| addli r0, r0, tls_gd_lo16(foo) |
| jal __tls_get_addr |
| addli r0, zero, tls_ie(foo) |
| auli r0, r0, tls_ie_ha16(foo) |
| addli r0, r0, tls_ie_lo16(foo)' |
| tls_first_major=2 |
| tls_first_minor=22 |
| tls_as_opt="--fatal-warnings" |
| ;; |
| tilegx*-*-*) |
| conftest_s=' |
| .section ".tdata","awT",@progbits |
| foo: .long 25 |
| .text |
| shl16insli r0, zero, hw0_last_tls_gd(foo) |
| shl16insli r0, zero, hw1_last_tls_gd(foo) |
| shl16insli r0, r0, hw0_tls_gd(foo) |
| jal __tls_get_addr |
| shl16insli r0, zero, hw1_last_tls_ie(foo) |
| shl16insli r0, r0, hw0_tls_ie(foo)' |
| tls_first_major=2 |
| tls_first_minor=22 |
| tls_as_opt="--fatal-warnings" |
| ;; |
| xtensa*-*-*) |
| conftest_s=' |
| .section ".tdata","awT",@progbits |
| foo: .long 25 |
| .text |
| movi a8, foo@TLSFUNC |
| movi a10, foo@TLSARG |
| callx8.tls a8, foo@TLSCALL' |
| tls_first_major=2 |
| tls_first_minor=19 |
| ;; |
| changequote([,])dnl |
| esac |
| set_have_as_tls=no |
| if test "x$enable_tls" = xno ; then |
| : # TLS explicitly disabled. |
| elif test "x$enable_tls" = xyes ; then |
| set_have_as_tls=yes # TLS explicitly enabled. |
| elif test -z "$tls_first_major"; then |
| : # If we don't have a check, assume no support. |
| else |
| gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls, |
| [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],, |
| [set_have_as_tls=yes]) |
| fi |
| if test $set_have_as_tls = yes ; then |
| AC_DEFINE(HAVE_AS_TLS, 1, |
| [Define if your assembler and linker support thread-local storage.]) |
| fi |
| |
| # Target-specific assembler checks. |
| |
| AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option) |
| gcc_cv_ld_static_dynamic=no |
| gcc_cv_ld_static_option='-Bstatic' |
| gcc_cv_ld_dynamic_option='-Bdynamic' |
| if test $in_tree_ld = yes ; then |
| if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 10 -o "$gcc_cv_gld_major_version" -gt 2; then |
| gcc_cv_ld_static_dynamic=yes |
| fi |
| elif test x$gcc_cv_ld != x; then |
| # Check if linker supports -Bstatic/-Bdynamic option |
| if $gcc_cv_ld --help 2>&1 | grep -- -Bstatic > /dev/null \ |
| && $gcc_cv_ld --help 2>&1 | grep -- -Bdynamic > /dev/null; then |
| gcc_cv_ld_static_dynamic=yes |
| else |
| case "$target" in |
| # AIX ld uses -b flags |
| *-*-aix4.[[23]]* | *-*-aix[[5-9]]*) |
| gcc_cv_ld_static_dynamic=yes |
| gcc_cv_ld_static_option="-bstatic" |
| gcc_cv_ld_dynamic_option="-bdynamic" |
| ;; |
| # HP-UX ld uses -a flags to select between shared and archive. |
| *-*-hpux*) |
| if test x"$gnu_ld" = xno; then |
| gcc_cv_ld_static_dynamic=yes |
| gcc_cv_ld_static_option="-aarchive_shared" |
| gcc_cv_ld_dynamic_option="-adefault" |
| fi |
| ;; |
| # Solaris 2 ld always supports -Bstatic/-Bdynamic. |
| *-*-solaris2*) |
| gcc_cv_ld_static_dynamic=yes |
| ;; |
| esac |
| fi |
| fi |
| if test x"$gcc_cv_ld_static_dynamic" = xyes; then |
| AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1, |
| [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.]) |
| AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option", |
| [Define to the linker option to disable use of shared objects.]) |
| AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option", |
| [Define to the linker option to enable use of shared objects.]) |
| fi |
| AC_MSG_RESULT($gcc_cv_ld_static_dynamic) |
| |
| AC_MSG_CHECKING(linker --version-script option) |
| gcc_cv_ld_version_script=no |
| ld_version_script_option='' |
| if test $in_tree_ld = yes || test x"$gnu_ld" = xyes; then |
| gcc_cv_ld_version_script=yes |
| ld_version_script_option='--version-script' |
| elif test x$gcc_cv_ld != x; then |
| case "$target" in |
| # Solaris 2 ld always supports -M. It also supports a subset of |
| # --version-script since Solaris 11.4, but requires |
| # -z gnu-version-script-compat to activate. |
| *-*-solaris2*) |
| gcc_cv_ld_version_script=yes |
| ld_version_script_option='-M' |
| ;; |
| esac |
| fi |
| # Don't AC_DEFINE result, only used in jit/Make-lang.in so far. |
| AC_MSG_RESULT($gcc_cv_ld_version_script) |
| AC_SUBST(ld_version_script_option) |
| |
| AC_MSG_CHECKING(linker soname option) |
| gcc_cv_ld_soname=no |
| if test $in_tree_ld = yes || test x"$gnu_ld" = xyes; then |
| gcc_cv_ld_soname=yes |
| ld_soname_option='-soname' |
| elif test x$gcc_cv_ld != x; then |
| case "$target" in |
| *-*-darwin*) |
| gcc_cv_ld_soname=yes |
| ld_soname_option='-install_name' |
| ;; |
| # Solaris 2 ld always supports -h. It also supports --soname for GNU |
| # ld compatiblity since some Solaris 10 update. |
| *-*-solaris2*) |
| gcc_cv_ld_soname=yes |
| ld_soname_option='-h' |
| ;; |
| esac |
| fi |
| # Don't AC_DEFINE result, only used in jit/Make-lang.in so far. |
| AC_MSG_RESULT($gcc_cv_ld_soname) |
| AC_SUBST(ld_soname_option) |
| |
| if test x"$demangler_in_ld" = xyes; then |
| AC_MSG_CHECKING(linker --demangle support) |
| gcc_cv_ld_demangle=no |
| if test $in_tree_ld = yes; then |
| if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 14 -o "$gcc_cv_gld_major_version" -gt 2; then \ |
| gcc_cv_ld_demangle=yes |
| fi |
| elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then |
| # Check if the GNU linker supports --demangle option |
| if $gcc_cv_ld --help 2>&1 | grep no-demangle > /dev/null; then |
| gcc_cv_ld_demangle=yes |
| fi |
| fi |
| if test x"$gcc_cv_ld_demangle" = xyes; then |
| AC_DEFINE(HAVE_LD_DEMANGLE, 1, |
| [Define if your linker supports --demangle option.]) |
| fi |
| AC_MSG_RESULT($gcc_cv_ld_demangle) |
| fi |
| |
| AC_MSG_CHECKING(linker plugin support) |
| gcc_cv_lto_plugin=0 |
| if test -f liblto_plugin.la; then |
| save_ld_ver="$ld_ver" |
| save_ld_vers_major="$ld_vers_major" |
| save_ld_vers_minor="$ld_vers_minor" |
| save_ld_is_gold="$ld_is_gold" |
| |
| ld_is_gold=no |
| |
| if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then |
| ld_ver="GNU ld" |
| # FIXME: ld_is_gold? |
| ld_vers_major="$gcc_cv_gld_major_version" |
| ld_vers_minor="$gcc_cv_gld_minor_version" |
| else |
| # Determine plugin linker version. |
| # FIXME: Partial duplicate from above, generalize. |
| changequote(,)dnl |
| ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q` |
| if echo "$ld_ver" | grep GNU > /dev/null; then |
| if echo "$ld_ver" | grep "GNU gold" > /dev/null; then |
| ld_is_gold=yes |
| ld_vers=`echo $ld_ver | sed -n \ |
| -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'` |
| else |
| ld_vers=`echo $ld_ver | sed -n \ |
| -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'` |
| fi |
| ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'` |
| ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'` |
| fi |
| changequote([,])dnl |
| fi |
| |
| # Determine plugin support. |
| if echo "$ld_ver" | grep GNU > /dev/null; then |
| # Require GNU ld or gold 2.21+ for plugin support by default. |
| if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then |
| gcc_cv_lto_plugin=2 |
| # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20. |
| elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then |
| gcc_cv_lto_plugin=1 |
| fi |
| fi |
| |
| ld_ver="$save_ld_ver" |
| ld_vers_major="$save_ld_vers_major" |
| ld_vers_minor="$save_ld_vers_minor" |
| ld_is_gold="$save_ld_is_gold" |
| fi |
| AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin, |
| [Define to the level of your linker's plugin support.]) |
| AC_MSG_RESULT($gcc_cv_lto_plugin) |
| |
| # Target OS-specific assembler checks. |
| |
| case "$target_os" in |
| darwin*) |
| gcc_GAS_CHECK_FEATURE([-mmacosx-version-min option], |
| gcc_cv_as_mmacosx_version_min,, |
| [-mmacosx-version-min=10.1], [.text],, |
| [AC_DEFINE(HAVE_AS_MMACOSX_VERSION_MIN_OPTION, 1, |
|