diff options
Diffstat (limited to 'binutils-2.25/gold/configure.ac')
| -rw-r--r-- | binutils-2.25/gold/configure.ac | 619 |
1 files changed, 619 insertions, 0 deletions
diff --git a/binutils-2.25/gold/configure.ac b/binutils-2.25/gold/configure.ac new file mode 100644 index 00000000..c23117b6 --- /dev/null +++ b/binutils-2.25/gold/configure.ac @@ -0,0 +1,619 @@ +dnl Process this file with autoconf to produce a configure script. +dnl +dnl Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 +dnl 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_PREREQ(2.59) + +AC_INIT(gold, 0.1) +AC_CONFIG_SRCDIR(gold.cc) + +AC_CANONICAL_TARGET + +AM_INIT_AUTOMAKE([no-dist parallel-tests]) + +AM_CONFIG_HEADER(config.h:config.in) + +# 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) + +dnl For now threads are a configure time option. +AC_ARG_ENABLE([threads], +[ --enable-threads multi-threaded linking], +[case "${enableval}" in + yes | "") threads=yes ;; + no) threads=no ;; + *) threads=yes ;; + esac], +[threads=no]) +if test "$threads" = "yes"; then + AC_DEFINE(ENABLE_THREADS, 1, + [Define to do multi-threaded linking]) +fi +AM_CONDITIONAL(THREADS, test "$threads" = "yes") + +AC_ARG_ENABLE([plugins], +[ --enable-plugins linker plugins], +[case "${enableval}" in + yes | "") plugins=yes ;; + no) plugins=no ;; + *) plugins=yes ;; + esac], +[plugins=no]) +if test "$plugins" = "yes"; then + AC_DEFINE(ENABLE_PLUGINS, 1, + [Define to enable linker plugins]) +fi +AM_CONDITIONAL(PLUGINS, test "$plugins" = "yes") + +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 + +# 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_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_X86_64, test "$targ_obj" = "x86_64") + AM_CONDITIONAL(DEFAULT_TARGET_TILEGX, test "$targ_obj" = "tilegx") + 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;; + *) 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([ +#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([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"]) + +AC_CACHE_CHECK([whether $CC supports -fmerge-constants], + [gold_cv_merge_constants], [ +save_CFLAGS="$CFLAGS" +CFLAGS="$CFLAGS -fmerge-constants" +AC_COMPILE_IFELSE([const char *s = "foo";], + [have_merge_constants=yes], + [have_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([__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([ +#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([ +#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([ +__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([ +#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([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) +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 if we can. This allows us to write compressed sections. +AM_ZLIB +AM_CONDITIONAL(HAVE_ZLIB, test "$ac_cv_header_zlib_h" = "yes") + +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]) + +AC_LANG_PUSH(C++) + +AC_CHECK_HEADERS(tr1/unordered_set tr1/unordered_map) +AC_CHECK_HEADERS(ext/hash_map ext/hash_set) +AC_CHECK_HEADERS(byteswap.h) + +dnl When plugins enabled dynamic loader interface is required. Check headers +dnl which may provide this interface. In case of dlfcn.h add libdl to link. +AC_CHECK_HEADERS(windows.h) +AC_CHECK_HEADERS(dlfcn.h, [DLOPEN_LIBS="-ldl"], [DLOPEN_LIBS=""]) +AC_SUBST(DLOPEN_LIBS) + +AC_CHECK_FUNCS(mallinfo posix_fallocate fallocate readv sysconf times) +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([ +#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([ +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 + +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_CXXFLAGS="$CXXFLAGS" +CXXFLAGS="$CXXFLAGS -Werror -gpubnames" +AC_COMPILE_IFELSE([int i;], [have_pubnames=yes], [have_pubnames=no]) +CXXFLAGS="$save_CXXFLAGS" +AM_CONDITIONAL(HAVE_PUBNAMES, test "$have_pubnames" = "yes") + +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) |