mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-11-24 02:24:46 +08:00
d87bef3a7b
The newer update-copyright.py fixes file encoding too, removing cr/lf on binutils/bfdtest2.c and ld/testsuite/ld-cygwin/exe-export.exp, and embedded cr in binutils/testsuite/binutils-all/ar.exp string match.
740 lines
23 KiB
Plaintext
740 lines
23 KiB
Plaintext
dnl Process this file with autoconf to produce a configure script.
|
|
dnl
|
|
dnl Copyright (C) 2006-2023 Free Software Foundation, Inc.
|
|
dnl
|
|
dnl This file is free software; you can redistribute it and/or modify
|
|
dnl it under the terms of the GNU General Public License as published by
|
|
dnl the Free Software Foundation; either version 3 of the License, or
|
|
dnl (at your option) any later version.
|
|
dnl
|
|
dnl This program is distributed in the hope that it will be useful,
|
|
dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
dnl GNU General Public License for more details.
|
|
dnl
|
|
dnl You should have received a copy of the GNU General Public License
|
|
dnl along with this program; see the file COPYING3. If not see
|
|
dnl <http://www.gnu.org/licenses/>.
|
|
dnl
|
|
|
|
AC_INIT(gold, 0.1)
|
|
AC_CONFIG_SRCDIR(gold.cc)
|
|
|
|
AC_CANONICAL_TARGET
|
|
|
|
AM_INIT_AUTOMAKE([no-dist parallel-tests])
|
|
AM_SILENT_RULES([yes])
|
|
|
|
AM_CONFIG_HEADER(config.h:config.in)
|
|
|
|
AC_USE_SYSTEM_EXTENSIONS
|
|
|
|
# PR 14072
|
|
AH_VERBATIM([00_CONFIG_H_CHECK],
|
|
[/* Check that config.h is #included before system headers
|
|
(this works only for glibc, but that should be enough). */
|
|
#if defined(__GLIBC__) && !defined(__FreeBSD_kernel__) && !defined(__CONFIG_H__)
|
|
# error config.h must be #included before system headers
|
|
#endif
|
|
#define __CONFIG_H__ 1])
|
|
|
|
AC_ARG_WITH(sysroot,
|
|
[ --with-sysroot[=DIR] search for usr/lib et al within DIR],
|
|
[sysroot=$withval], [sysroot=no])
|
|
|
|
if test "$sysroot" = "yes"; then
|
|
sysroot='${exec_prefix}/${target_alias}/sys-root'
|
|
elif test "$sysroot" = "no"; then
|
|
sysroot=
|
|
fi
|
|
|
|
sysroot_relocatable=0
|
|
if test -n "$sysroot"; then
|
|
case "$sysroot" in
|
|
"${prefix}" | "${prefix}/"* | \
|
|
"${exec_prefix}" | "${exec_prefix}/"* | \
|
|
'${prefix}' | '${prefix}/'*| \
|
|
'${exec_prefix}' | '${exec_prefix}/'*)
|
|
sysroot_relocatable=1
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
AC_DEFINE_UNQUOTED(TARGET_SYSTEM_ROOT, "$sysroot",
|
|
[System root for target files])
|
|
AC_DEFINE_UNQUOTED(TARGET_SYSTEM_ROOT_RELOCATABLE, $sysroot_relocatable,
|
|
[Whether the system root can be relocated])
|
|
|
|
dnl "install_as_default" is true if the linker to be installed as the
|
|
dnl default linker, ld.
|
|
dnl "installed_linker" is the installed gold linker name.
|
|
|
|
installed_linker=ld.gold
|
|
AC_ARG_ENABLE(gold,
|
|
[[ --enable-gold[=ARG] build gold [ARG={default,yes,no}]]],
|
|
[case "${enableval}" in
|
|
default)
|
|
install_as_default=yes
|
|
;;
|
|
yes)
|
|
if test x${enable_ld} = xno; then
|
|
install_as_default=yes
|
|
fi
|
|
;;
|
|
esac],
|
|
[install_as_default=no])
|
|
AC_SUBST(install_as_default)
|
|
AC_SUBST(installed_linker)
|
|
|
|
AC_PLUGINS
|
|
if test "$plugins" = "yes"; then
|
|
AC_DEFINE(ENABLE_PLUGINS, 1,
|
|
[Define to enable linker plugins])
|
|
fi
|
|
AM_CONDITIONAL(PLUGINS, test "$plugins" = "yes")
|
|
|
|
# Decide if -z relro should be enabled in ELF linker by default.
|
|
ac_default_ld_z_relro=unset
|
|
# Provide a configure time option to override our default.
|
|
AC_ARG_ENABLE(relro,
|
|
AS_HELP_STRING([--enable-relro],
|
|
[enable -z relro in ELF linker by default]),
|
|
[case "${enableval}" in
|
|
yes) ac_default_ld_z_relro=1 ;;
|
|
no) ac_default_ld_z_relro=0 ;;
|
|
esac])dnl
|
|
if test "${ac_default_ld_z_relro}" = unset; then
|
|
ac_default_ld_z_relro=1
|
|
fi
|
|
AC_DEFINE_UNQUOTED(DEFAULT_LD_Z_RELRO,
|
|
$ac_default_ld_z_relro,
|
|
[Define to 1 if you want to enable -z relro in ELF linker by default.])
|
|
|
|
AC_ARG_ENABLE([targets],
|
|
[ --enable-targets alternative target configurations],
|
|
[case "${enableval}" in
|
|
yes | "")
|
|
AC_MSG_ERROR([--enable-targets option must specify target names or 'all'])
|
|
;;
|
|
no)
|
|
enable_targets=
|
|
;;
|
|
*)
|
|
enable_targets=$enableval
|
|
;;
|
|
esac],
|
|
[# For now, enable all targets by default
|
|
enable_targets=all
|
|
])
|
|
|
|
# Canonicalize the enabled targets.
|
|
if test -n "$enable_targets"; then
|
|
for targ in `echo $enable_targets | sed -e 's/,/ /g'`; do
|
|
result=`$ac_config_sub $targ 2>/dev/null`
|
|
if test -n "$result"; then
|
|
canon_targets="$canon_targets $result"
|
|
else
|
|
# Permit unrecognized target names, like "all".
|
|
canon_targets="$canon_targets $targ"
|
|
fi
|
|
done
|
|
fi
|
|
|
|
# Decide which "--hash-style" to use by default
|
|
# Provide a configure time option to override our default.
|
|
AC_ARG_ENABLE([default-hash-style],
|
|
AS_HELP_STRING([--enable-default-hash-style={sysv,gnu,both}],
|
|
[use this default hash style]),
|
|
[case "${enable_default_hash_style}" in
|
|
sysv | gnu | both) ;;
|
|
*) AC_MSG_ERROR([bad value ${enable_default_hash_style} for enable-default-hash-style option]) ;;
|
|
esac],
|
|
[case "${target}" in
|
|
# Enable gnu hash only on GNU targets, but not mips
|
|
mips*-*-*) enable_default_hash_style=sysv ;;
|
|
*-*-gnu* | *-*-linux* | *-*-nacl*) enable_default_hash_style=both ;;
|
|
*) enable_default_hash_style=sysv ;;
|
|
esac])
|
|
|
|
AC_DEFINE_UNQUOTED([DEFAULT_HASH_STYLE],
|
|
["${enable_default_hash_style}"],
|
|
[Set the default --hash-style value])
|
|
|
|
# See which specific instantiations we need.
|
|
targetobjs=
|
|
all_targets=
|
|
default_machine=
|
|
default_size=
|
|
default_big_endian=
|
|
default_osabi=ELFOSABI_NONE
|
|
targ_32_little=
|
|
targ_32_big=
|
|
targ_64_little=
|
|
targ_64_big=
|
|
for targ in $target $canon_targets; do
|
|
if test "$targ" = "all"; then
|
|
targ_32_little=yes
|
|
targ_32_big=yes
|
|
targ_64_little=yes
|
|
targ_64_big=yes
|
|
all_targets=yes
|
|
else
|
|
. ${srcdir}/configure.tgt
|
|
|
|
if test "$targ_obj" = "UNKNOWN"; then
|
|
AC_MSG_ERROR("unsupported target $targ")
|
|
else
|
|
targetobjs="$targetobjs ${targ_obj}.\$(OBJEXT)"
|
|
if test "$targ_extra_obj" != ""; then
|
|
targetobjs="$targetobjs ${targ_extra_obj}.\$(OBJEXT)"
|
|
fi
|
|
if test "$targ_size" = "32" -o "$targ_extra_size" = "32"; then
|
|
if test "$targ_big_endian" = "true" \
|
|
-o "$targ_extra_big_endian" = "true"; then
|
|
targ_32_big=yes
|
|
fi
|
|
if test "$targ_big_endian" = "false" \
|
|
-o "$targ_extra_big_endian" = "false"; then
|
|
targ_32_little=yes
|
|
fi
|
|
fi
|
|
if test "$targ_size" = "64" -o "$targ_extra_size" = "64"; then
|
|
if test "$targ_big_endian" = "true" \
|
|
-o "$targ_extra_big_endian" = "true"; then
|
|
targ_64_big=yes
|
|
fi
|
|
if test "$targ_big_endian" = "false" \
|
|
-o "$targ_extra_big_endian" = "false"; then
|
|
targ_64_little=yes
|
|
fi
|
|
fi
|
|
|
|
if test "$target" = "$targ"; then
|
|
default_machine=$targ_machine
|
|
default_size=$targ_size
|
|
default_big_endian=$targ_big_endian
|
|
default_osabi=$targ_osabi
|
|
|
|
AM_CONDITIONAL(DEFAULT_TARGET_AARCH64, test "$targ_obj" = "aarch64")
|
|
AM_CONDITIONAL(DEFAULT_TARGET_ARM, test "$targ_obj" = "arm")
|
|
AM_CONDITIONAL(DEFAULT_TARGET_I386, test "$targ_obj" = "i386")
|
|
AM_CONDITIONAL(DEFAULT_TARGET_POWERPC, test "$targ_obj" = "powerpc")
|
|
AM_CONDITIONAL(DEFAULT_TARGET_SPARC, test "$targ_obj" = "sparc")
|
|
AM_CONDITIONAL(DEFAULT_TARGET_S390, test "$targ_obj" = "s390")
|
|
target_x86_64=no
|
|
target_x32=no
|
|
if test "$targ_obj" = "x86_64"; then
|
|
case "$target" in
|
|
x86_64*-linux-gnux32)
|
|
target_x32=yes
|
|
default_size=32
|
|
;;
|
|
*)
|
|
target_x86_64=yes
|
|
;;
|
|
esac
|
|
fi
|
|
AM_CONDITIONAL(DEFAULT_TARGET_X86_64, test "$target_x86_64" = "yes")
|
|
AM_CONDITIONAL(DEFAULT_TARGET_X32, test "$target_x32" = "yes")
|
|
AM_CONDITIONAL(DEFAULT_TARGET_X86_64_OR_X32,
|
|
test "$target_x86_64" = "yes" -o "$target_x32" = "yes")
|
|
AM_CONDITIONAL(DEFAULT_TARGET_TILEGX, test "$targ_obj" = "tilegx")
|
|
AM_CONDITIONAL(DEFAULT_TARGET_MIPS, test "$targ_obj" = "mips")
|
|
DEFAULT_TARGET=${targ_obj}
|
|
AC_SUBST(DEFAULT_TARGET)
|
|
fi
|
|
fi
|
|
fi
|
|
done
|
|
|
|
# Remove any duplicates.
|
|
to=""
|
|
for t in $targetobjs; do
|
|
case " $to " in
|
|
*" $t "*) ;;
|
|
*) to="$to $t" ;;
|
|
esac
|
|
done
|
|
targetobjs=$to
|
|
|
|
if test -n "$targ_32_little"; then
|
|
AC_DEFINE(HAVE_TARGET_32_LITTLE, 1,
|
|
[Define to support 32-bit little-endian targets])
|
|
fi
|
|
if test -n "$targ_32_big"; then
|
|
AC_DEFINE(HAVE_TARGET_32_BIG, 1,
|
|
[Define to support 32-bit big-endian targets])
|
|
fi
|
|
if test -n "$targ_64_little"; then
|
|
AC_DEFINE(HAVE_TARGET_64_LITTLE, 1,
|
|
[Define to support 64-bit little-endian targets])
|
|
fi
|
|
if test -n "$targ_64_big"; then
|
|
AC_DEFINE(HAVE_TARGET_64_BIG, 1,
|
|
[Define to support 64-bit big-endian targets])
|
|
fi
|
|
|
|
if test -n "$all_targets"; then
|
|
TARGETOBJS='$(ALL_TARGETOBJS)'
|
|
else
|
|
TARGETOBJS="$targetobjs"
|
|
fi
|
|
AC_SUBST(TARGETOBJS)
|
|
|
|
AC_DEFINE_UNQUOTED(GOLD_DEFAULT_MACHINE, $default_machine,
|
|
[Default machine code])
|
|
AC_DEFINE_UNQUOTED(GOLD_DEFAULT_SIZE, $default_size,
|
|
[Default size (32 or 64)])
|
|
AC_DEFINE_UNQUOTED(GOLD_DEFAULT_BIG_ENDIAN, $default_big_endian,
|
|
[Default big endian (true or false)])
|
|
AC_DEFINE_UNQUOTED(GOLD_DEFAULT_OSABI, $default_osabi,
|
|
[Default OSABI code])
|
|
|
|
AC_ARG_WITH(lib-path,
|
|
[ --with-lib-path=dir1:dir2... set default LIB_PATH],
|
|
[case "$withval" in
|
|
yes) LIB_PATH='"/lib:/usr/lib"' ;;
|
|
no) LIB_PATH='""' ;;
|
|
*) LIB_PATH='"'"$withval"'"' ;;
|
|
esac],
|
|
[LIB_PATH='"::DEFAULT::"'])
|
|
AC_DEFINE_UNQUOTED(LIB_PATH, $LIB_PATH,
|
|
[Default library search path])
|
|
if test "x$target_alias" = "x" -o "x$host_alias" = "x$target_alias"; then
|
|
AC_DEFINE(NATIVE_LINKER, 1, [Whether configured as a native linker])
|
|
fi
|
|
|
|
AC_CHECK_TOOL(NM, nm)
|
|
|
|
AC_PROG_CC
|
|
AC_PROG_CXX
|
|
AC_PROG_YACC
|
|
AC_PROG_RANLIB
|
|
AC_PROG_INSTALL
|
|
AC_PROG_LN_S
|
|
|
|
AC_GNU_SOURCE
|
|
|
|
ZW_GNU_GETTEXT_SISTER_DIR
|
|
AM_PO_SUBDIRS
|
|
|
|
AC_C_BIGENDIAN
|
|
|
|
AC_EXEEXT
|
|
|
|
AM_CONDITIONAL(NATIVE_LINKER,
|
|
test "x$target_alias" = "x" -o "x$host_alias" = "x$target_alias")
|
|
AM_CONDITIONAL(GCC, test "$GCC" = yes)
|
|
|
|
AM_CONDITIONAL(NATIVE_OR_CROSS_LINKER,
|
|
test "x$target_alias" = "x" -o "x$host_alias" = "x$target_alias" -o "x$host_alias" = "x$build_alias")
|
|
|
|
dnl Test for whether static linking is supported. Some systems do not
|
|
dnl install static libraries. This only affects the set of tests that
|
|
dnl we run.
|
|
AC_CACHE_CHECK([whether static linking works], [gold_cv_lib_static],
|
|
[LDFLAGS_hold=$LDFLAGS
|
|
LDFLAGS="$LDFLAGS -static"
|
|
AC_LINK_IFELSE([
|
|
AC_LANG_PROGRAM([[void f() { }]])],
|
|
[gold_cv_lib_static=yes], [gold_cv_lib_static=no])
|
|
LDFLAGS=$LDFLAGS_hold])
|
|
AM_CONDITIONAL(HAVE_STATIC, test "$gold_cv_lib_static" = "yes")
|
|
|
|
dnl Some architectures do not support taking pointers of functions
|
|
dnl defined in shared libraries except in -fPIC mode. We need to
|
|
dnl tell the unittest framework if we're compiling for one of those
|
|
dnl targets, so it doesn't try to run the tests that do that.
|
|
AM_CONDITIONAL(FN_PTRS_IN_SO_WITHOUT_PIC, [
|
|
case $target_cpu in
|
|
powerpc*) false;;
|
|
x86_64) false;;
|
|
sparc64) false;;
|
|
s390x) false;;
|
|
*) true;;
|
|
esac])
|
|
|
|
dnl Test for gcc 4.1 or later. Full support for -mcmodel=medium is
|
|
dnl only available in gcc 4.1.
|
|
AC_CACHE_CHECK([for gcc >= 4.1], [gold_cv_prog_gcc41],
|
|
[AC_COMPILE_IFELSE([AC_LANG_SOURCE([
|
|
#if !defined __GNUC__
|
|
error
|
|
#elif __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 1)
|
|
error
|
|
#endif
|
|
])], [gold_cv_prog_gcc41=yes], [gold_cv_prog_gcc41=no])])
|
|
|
|
save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS -mcmodel=medium"
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([int i;])], [have_mcmodel_medium=yes], [have_mcmodel_medium=no])
|
|
CFLAGS="$save_CFLAGS"
|
|
dnl Whether we can test -mcmodel=medium.
|
|
AM_CONDITIONAL(MCMODEL_MEDIUM,
|
|
[test "$target_cpu" = "x86_64" -a "$have_mcmodel_medium" = "yes" -a "$gold_cv_prog_gcc41" = "yes"])
|
|
|
|
dnl Test for gcc 9 or later. Some incremental tests fail with GCC 9 or
|
|
dnl later.
|
|
AC_CACHE_CHECK([for gcc >= 9], [gold_cv_prog_gcc9],
|
|
[AC_COMPILE_IFELSE([AC_LANG_SOURCE([
|
|
#if !defined __GNUC__ || __GNUC__ < 9
|
|
error
|
|
#endif
|
|
])], [gold_cv_prog_gcc9=yes], [gold_cv_prog_gcc9=no])])
|
|
AM_CONDITIONAL(GCC9, [test "$gold_cv_prog_gcc9" = "yes"])
|
|
|
|
dnl Test for -fcf-protection on x86-64. Some incremental tests fail with
|
|
dnl -fcf-protection.
|
|
AC_CACHE_CHECK([for -fcf-protection], [gold_cv_cflags_cf_protection],
|
|
[AC_COMPILE_IFELSE([AC_LANG_SOURCE([
|
|
#if !defined __x86_64__ || !defined __CET__
|
|
error
|
|
#endif
|
|
])], [gold_cv_cflags_cf_protection=yes], [gold_cv_cflags_cf_protection=no])])
|
|
AM_CONDITIONAL(CFLAGS_CF_PROTECTION, [test "$gold_cv_cflags_cf_protection" = "yes"])
|
|
|
|
AC_CACHE_CHECK([whether $CC supports -fmerge-constants],
|
|
[gold_cv_merge_constants], [
|
|
save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS -fmerge-constants"
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([const char *s = "foo";])],
|
|
[gold_cv_merge_constants=yes],
|
|
[gold_cv_merge_constants=no])
|
|
CFLAGS="$save_CFLAGS"])
|
|
AC_SUBST([MERGE_CONSTANTS_FLAG])
|
|
AS_IF([test "$gold_cv_merge_constants" = yes],
|
|
[MERGE_CONSTANTS_FLAG=-fmerge-constants],
|
|
[MERGE_CONSTANTS_FLAG=])
|
|
|
|
dnl Test for __thread support.
|
|
AC_CACHE_CHECK([for thread support], [gold_cv_c_thread],
|
|
[AC_COMPILE_IFELSE([AC_LANG_SOURCE([__thread int i = 1;])],
|
|
[gold_cv_c_thread=yes], [gold_cv_c_thread=no])])
|
|
|
|
AM_CONDITIONAL(TLS, test "$gold_cv_c_thread" = "yes")
|
|
|
|
dnl On GNU/Linux TLS in static programs only works when using glibc
|
|
dnl 2.4 or later.
|
|
AC_CACHE_CHECK([for glibc >= 2.4], [gold_cv_lib_glibc24],
|
|
[AC_COMPILE_IFELSE([AC_LANG_SOURCE([
|
|
#include <features.h>
|
|
#if !defined __GLIBC__
|
|
error
|
|
#elif __GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ < 4)
|
|
error
|
|
#endif
|
|
])], [gold_cv_lib_glibc24=yes], [gold_cv_lib_glibc24=no])])
|
|
|
|
AM_CONDITIONAL(STATIC_TLS, test "$gold_cv_lib_glibc24" = "yes")
|
|
|
|
dnl Test for #pragma omp threadprivate
|
|
AC_CACHE_CHECK([for omp support], [gold_cv_c_threadprivate],
|
|
[save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS -fopenmp"
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
|
|
#include <omp.h>
|
|
int i;
|
|
#pragma omp threadprivate (i)
|
|
])], [gold_cv_c_threadprivate=yes], [gold_cv_c_threadprivate=no])
|
|
CFLAGS="$save_CFLAGS"])
|
|
if test "$gold_cv_c_threadprivate" = "yes"; then
|
|
AC_DEFINE(HAVE_OMP_SUPPORT, 1,
|
|
[Define if compiler supports #pragma omp threadprivate])
|
|
fi
|
|
AM_CONDITIONAL(OMP_SUPPORT, test "$gold_cv_c_threadprivate" = "yes")
|
|
|
|
dnl Test for the -ftls-dialect=gnu2 option.
|
|
dnl Use -Werror in case of compilers that make unknown -m options warnings.
|
|
dnl They would pass the test here, but fail in actual use when $WARN_CFLAGS
|
|
dnl gets set later by default Autoconf magic to include -Werror. (We are
|
|
dnl assuming here that there is no compiler that groks -mtls-dialect=gnu2
|
|
dnl but does not grok -Werror.)
|
|
save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS -Werror -fpic -mtls-dialect=gnu2"
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
|
|
__thread int i;
|
|
void foo (void)
|
|
{
|
|
i = 10;
|
|
}
|
|
])], [have_tls_gnu2=yes], [have_tls_gnu2=no])
|
|
CFLAGS="$save_CFLAGS"
|
|
AM_CONDITIONAL(TLS_GNU2_DIALECT, test "$have_tls_gnu2" = "yes")
|
|
|
|
dnl On GNU/Linux TLS descriptors are supported by the dynamic loader
|
|
dnl only with glibc 2.9 or later.
|
|
AC_CACHE_CHECK([for glibc >= 2.9], [gold_cv_lib_glibc29],
|
|
[AC_COMPILE_IFELSE([AC_LANG_SOURCE([
|
|
#include <features.h>
|
|
#if !defined __GLIBC__
|
|
error
|
|
#elif __GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ < 9)
|
|
error
|
|
#endif
|
|
])], [gold_cv_lib_glibc29=yes], [gold_cv_lib_glibc29=no])])
|
|
|
|
AM_CONDITIONAL(TLS_DESCRIPTORS, test "$gold_cv_lib_glibc29" = "yes")
|
|
|
|
dnl Test for the -frandom-seed option.
|
|
AC_CACHE_CHECK([for -frandom-seed support], [gold_cv_c_random_seed],
|
|
[save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS -frandom-seed=foo"
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([int i;])], [gold_cv_c_random_seed=yes],
|
|
[gold_cv_c_random_seed=no])
|
|
CFLAGS="$save_CFLAGS"])
|
|
if test "$gold_cv_c_random_seed" = "yes"; then
|
|
# In Makefile, '$@' will be expanded to be the name of the file
|
|
# being built, providing a unique seed for each file.
|
|
RANDOM_SEED_CFLAGS=-frandom-seed=\$@
|
|
fi
|
|
AC_SUBST(RANDOM_SEED_CFLAGS)
|
|
|
|
dnl On GNU/Linux ifunc is supported by the dynamic linker in glibc
|
|
dnl 2.11 or later, and by binutils 2.20.1 or later.
|
|
AC_CACHE_CHECK([for glibc ifunc support], [gold_cv_lib_glibc_ifunc],
|
|
[save_LDFLAGS="$LDFLAGS"
|
|
LDFLAGS="$LDFLAGS -static"
|
|
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
|
|
#include <features.h>
|
|
#if !defined __GLIBC__
|
|
error
|
|
#elif __GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ < 11)
|
|
error
|
|
#endif
|
|
void func (void) { }
|
|
void invoke (void);
|
|
__asm__(".type invoke, %gnu_indirect_function");
|
|
typedef void (*funcptr) (void);
|
|
funcptr dispatch (void) __asm__ ("invoke");
|
|
funcptr dispatch (void) { return &func; }]],
|
|
[[invoke();]])
|
|
], [
|
|
if ${NM} conftest$EXEEXT | grep "__rela\?_iplt_start" >/dev/null 2>&1; then
|
|
gold_cv_lib_glibc_ifunc=both
|
|
else
|
|
gold_cv_lib_glibc_ifunc=dyn
|
|
fi], [gold_cv_lib_glibc_ifunc=no])
|
|
LDFLAGS="$save_LDFLAGS"])
|
|
|
|
AM_CONDITIONAL(IFUNC, test "$gold_cv_lib_glibc_ifunc" != "no")
|
|
AM_CONDITIONAL(IFUNC_STATIC, test "$gold_cv_lib_glibc_ifunc" = "both")
|
|
|
|
AM_BINUTILS_WARNINGS
|
|
|
|
WARN_CXXFLAGS=`echo ${WARN_CFLAGS} | sed -e 's/-Wstrict-prototypes//' -e 's/-Wmissing-prototypes//' -e 's/-Wshadow//'`
|
|
AC_SUBST(WARN_CXXFLAGS)
|
|
|
|
AC_ARG_WITH(gold-ldflags,
|
|
[ --with-gold-ldflags=FLAGS additional link flags for gold],
|
|
[if test "$withval" = "no" -o "$withval" = "yes"; then
|
|
GOLD_LDFLAGS=
|
|
else
|
|
GOLD_LDFLAGS=$withval
|
|
fi],
|
|
[GOLD_LDFLAGS=])
|
|
AC_SUBST(GOLD_LDFLAGS)
|
|
|
|
AC_ARG_WITH(gold-ldadd,
|
|
[ --with-gold-ldadd=LIBS additional libraries for gold],
|
|
[if test "$withval" = "no" -o "$withval" = "yes"; then
|
|
GOLD_LDADD=
|
|
else
|
|
GOLD_LDADD=$withval
|
|
fi],
|
|
[GOLD_LDADD=])
|
|
AC_SUBST(GOLD_LDADD)
|
|
|
|
dnl Force support for large files by default. This may need to be
|
|
dnl host dependent. If build == host, we can check getconf LFS_CFLAGS.
|
|
LFS_CFLAGS="-D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64"
|
|
AC_SUBST(LFS_CFLAGS)
|
|
|
|
AC_CHECK_HEADERS(sys/mman.h)
|
|
AC_CHECK_FUNCS(chsize mmap link)
|
|
AC_REPLACE_FUNCS(pread ftruncate ffsll)
|
|
|
|
AC_CACHE_CHECK([mremap with MREMAP_MAYMOVE], [gold_cv_lib_mremap_maymove],
|
|
[AC_LINK_IFELSE([
|
|
AC_LANG_PROGRAM([[
|
|
#include <sys/mman.h>
|
|
void f() { mremap (0, 0, 0, MREMAP_MAYMOVE); }
|
|
]])], [gold_cv_lib_mremap_maymove=yes], [gold_cv_lib_mremap_maymove=no])])
|
|
if test "$gold_cv_lib_mremap_maymove" = "yes"; then
|
|
AC_DEFINE(HAVE_MREMAP, 1,
|
|
[Define to 1 if you have the mremap function with MREMAP_MAYMOVE support])
|
|
else
|
|
AC_LIBOBJ(mremap)
|
|
fi
|
|
|
|
# Link in zlib/zstd if we can. This allows us to write compressed sections.
|
|
AM_ZLIB
|
|
AC_ZSTD
|
|
AM_CONDITIONAL(HAVE_ZSTD, test "$pkg_cv_ZSTD_LIBS" != "")
|
|
|
|
AC_ARG_ENABLE([threads],
|
|
[[ --enable-threads[=ARG] multi-threaded linking [ARG={auto,yes,no}]]],
|
|
[case "${enableval}" in
|
|
yes | "") threads=yes ;;
|
|
no) threads=no ;;
|
|
auto) threads=auto ;;
|
|
*) threads=yes ;;
|
|
esac],
|
|
[threads=auto])
|
|
|
|
if test "$threads" = "yes"; then
|
|
AX_PTHREAD([threads=yes], AC_MSG_ERROR([pthread not found]))
|
|
elif test "$threads" = "auto"; then
|
|
AX_PTHREAD([threads=yes], [threads=no])
|
|
fi
|
|
|
|
if test "$threads" = "yes"; then
|
|
AC_DEFINE(ENABLE_THREADS, 1,
|
|
[Define to do multi-threaded linking])
|
|
fi
|
|
AM_CONDITIONAL(THREADS, test "$threads" = "yes")
|
|
|
|
# Used to validate --package-metadata= input. Disabled by default.
|
|
AC_ARG_ENABLE([jansson],
|
|
[AS_HELP_STRING([--enable-jansson],
|
|
[enable jansson [default=no]])],
|
|
[enable_jansson=$enableval],
|
|
[enable_jansson="no"])
|
|
|
|
if test "x$enable_jansson" != "xno"; then
|
|
PKG_PROG_PKG_CONFIG
|
|
AS_IF([test -n "$PKG_CONFIG"],
|
|
[
|
|
PKG_CHECK_MODULES(JANSSON, [jansson],
|
|
[
|
|
AC_DEFINE(HAVE_JANSSON, 1, [The jansson library is to be used])
|
|
AC_SUBST([JANSSON_CFLAGS])
|
|
AC_SUBST([JANSSON_LIBS])
|
|
],
|
|
[
|
|
AC_MSG_ERROR([Cannot find jansson library])
|
|
])
|
|
],
|
|
[
|
|
AC_MSG_ERROR([Cannot find pkg-config])
|
|
])
|
|
fi
|
|
|
|
dnl We have to check these in C, not C++, because autoconf generates
|
|
dnl tests which have no type information, and current glibc provides
|
|
dnl multiple declarations of functions like basename when compiling
|
|
dnl with C++.
|
|
AC_CHECK_DECLS([basename, ffs, asprintf, vasprintf, snprintf, vsnprintf, strverscmp])
|
|
|
|
dnl Check if gcc supports the -gpubnames option.
|
|
dnl Use -Werror in case of compilers that make unknown -g options warnings.
|
|
dnl They would pass the test here, but fail in actual use when $WARN_CFLAGS
|
|
dnl gets set later by default Autoconf magic to include -Werror. (We are
|
|
dnl assuming here that there is no compiler that groks -gpubnames
|
|
dnl but does not grok -Werror.)
|
|
save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS -Werror -gpubnames"
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([int i;])], [have_pubnames=yes], [have_pubnames=no])
|
|
CFLAGS="$save_CFLAGS"
|
|
AM_CONDITIONAL(HAVE_PUBNAMES, test "$have_pubnames" = "yes")
|
|
|
|
dnl Check if gcc supports the -fno-use-linker-plugin option.
|
|
save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS -Werror -fno-use-linker-plugin"
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([int i;])], [have_no_use_linker_plugin=yes], [have_no_use_linker_plugin=no])
|
|
CFLAGS="$save_CFLAGS"
|
|
AM_CONDITIONAL(HAVE_NO_USE_LINKER_PLUGIN, test "$have_no_use_linker_plugin" = "yes")
|
|
|
|
AC_LANG_PUSH(C++)
|
|
|
|
AC_CHECK_HEADERS(unordered_set unordered_map)
|
|
AC_CHECK_HEADERS(tr1/unordered_set tr1/unordered_map)
|
|
AC_CHECK_HEADERS(ext/hash_map ext/hash_set)
|
|
AC_CHECK_HEADERS(byteswap.h)
|
|
|
|
dnl Check for bswap_{16,32,64}
|
|
AC_CHECK_DECLS([bswap_16, bswap_32, bswap_64], [], [], [[#include <byteswap.h>]])
|
|
|
|
dnl When plugins enabled dynamic loader interface is required. Check headers
|
|
dnl which may provide this interface. Add the necessary library to link.
|
|
AC_CHECK_HEADERS(windows.h)
|
|
AC_CHECK_HEADERS(dlfcn.h)
|
|
AC_SEARCH_LIBS(dlopen, [dl dld])
|
|
case "$ac_cv_search_dlopen" in
|
|
no*) DLOPEN_LIBS="";;
|
|
*) DLOPEN_LIBS="$ac_cv_search_dlopen";;
|
|
esac
|
|
AC_SUBST(DLOPEN_LIBS)
|
|
|
|
AC_CHECK_FUNCS(mallinfo mallinfo2 posix_fallocate fallocate readv sysconf times mkdtemp)
|
|
AC_CHECK_DECLS([basename, ffs, asprintf, vasprintf, snprintf, vsnprintf, strverscmp, strndup, memmem])
|
|
|
|
# Use of ::std::tr1::unordered_map::rehash causes undefined symbols
|
|
# at link time with some versions of GCC.
|
|
AC_CACHE_CHECK([whether ::std::tr1::unordered_map::rehash is usable.],
|
|
[gold_cv_unordered_map_rehash],
|
|
[AC_LINK_IFELSE([AC_LANG_PROGRAM([[
|
|
#include <tr1/unordered_map>
|
|
void bar() { ::std::tr1::unordered_map<int, int> x; x.rehash(10); }
|
|
]])], [gold_cv_unordered_map_rehash=yes], [gold_cv_unordered_map_rehash=no])])
|
|
if test "$gold_cv_unordered_map_rehash" = "yes"; then
|
|
AC_DEFINE(HAVE_TR1_UNORDERED_MAP_REHASH, 1,
|
|
[Define if ::std::tr1::unordered_map::rehash is usable])
|
|
fi
|
|
|
|
# Use of tr1/unordered_map with off_t as a key is not supported on GCC
|
|
# 4.1.xx when compiling in 32-bit mode with a 64-bit off_t type.
|
|
AC_CACHE_CHECK([whether std::tr1::hash<off_t> is defined],
|
|
[gold_cv_hash_off_t],
|
|
[CXXFLAGS_hold=$CXXFLAGS
|
|
CXXFLAGS="$CXXFLAGS $LFS_CFLAGS"
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
|
|
#include <sys/types.h>
|
|
#include <tr1/unordered_map>
|
|
std::tr1::hash<off_t> h;
|
|
])],
|
|
[gold_cv_hash_off_t=yes],
|
|
[gold_cv_hash_off_t=no])
|
|
CXXFLAGS=$CXXFLAGS_hold])
|
|
if test "$gold_cv_hash_off_t" = "yes"; then
|
|
AC_DEFINE(HAVE_TR1_HASH_OFF_T, 1,
|
|
[Define if std::tr1::hash<off_t> is usable])
|
|
fi
|
|
|
|
# gcc 4.3.0 doesn't recognize the printf attribute on a template
|
|
# function. Check for that. This is gcc bug 35546. This test can
|
|
# probably be removed after the bug has been fixed for a while.
|
|
AC_CACHE_CHECK([whether we can use attributes with template functions],
|
|
[gold_cv_template_attribute],
|
|
[AC_COMPILE_IFELSE([AC_LANG_SOURCE([
|
|
template<typename T> extern void foo(const char*, ...)
|
|
__attribute__ ((__format__ (__printf__, 1, 2)));
|
|
template<typename T> void foo(const char* format, ...) {}
|
|
void bar() { foo<int>("%s\n", "foo"); }
|
|
])], [gold_cv_template_attribute=yes], [gold_cv_template_attribute=no])])
|
|
if test "$gold_cv_template_attribute" = "yes"; then
|
|
AC_DEFINE(HAVE_TEMPLATE_ATTRIBUTES, 1,
|
|
[Define if attributes work on C++ templates])
|
|
fi
|
|
|
|
dnl Check if the system has struct stat::st_mtim.
|
|
AC_CACHE_CHECK([for struct stat::st_mtim.],
|
|
[gold_cv_stat_st_mtim],
|
|
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
|
|
#include <sys/stat.h>
|
|
long bar() { struct stat s; return (long)(s.st_mtim.tv_sec + s.st_mtim.tv_sec);}
|
|
]])], [gold_cv_stat_st_mtim=yes], [gold_cv_stat_st_mtim=no])])
|
|
if test "$gold_cv_stat_st_mtim" = "yes"; then
|
|
AC_DEFINE(HAVE_STAT_ST_MTIM, 1,
|
|
[Define if struct stat has a field st_mtim with timespec for mtime])
|
|
fi
|
|
|
|
AC_LANG_POP(C++)
|
|
|
|
AC_CHECK_HEADERS(locale.h)
|
|
AC_CHECK_FUNCS(setlocale)
|
|
AM_LC_MESSAGES
|
|
|
|
AM_MAINTAINER_MODE
|
|
|
|
AC_OUTPUT(Makefile testsuite/Makefile po/Makefile.in:po/Make-in)
|