61214be10b
gcc/ChangeLog: 2016-08-20 Trevor Saunders <tbsaunde+gcc@tbsaunde.org> * acinclude.m4 (gcc_GAS_CHECK_FEATURE): Support doing an action if the feature isn't available. * configure: Regenerate. * configure.ac: define HAVE_AS_LEB128 to 0 when not available. * dwarf2asm.c (dw2_asm_output_data_uleb128): Always compile code for HAVE_AS_LEB128. (dw2_asm_output_data_sleb128): Likewise. (dw2_asm_output_delta_uleb128): Likewise. (dw2_asm_output_delta_sleb128): Likewise. * except.c (output_one_function_exception_table): Likewise. (dw2_size_of_call_site_table): Likewise. (sjlj_size_of_call_site_table): Likewise. * dwarf2out.c (output_loc_list): Likewise. (output_rnglists): Likewise. From-SVN: r242381
630 lines
20 KiB
Plaintext
630 lines
20 KiB
Plaintext
dnl Copyright (C) 2005-2016 Free Software Foundation, Inc.
|
|
dnl
|
|
dnl This file is part of GCC.
|
|
dnl
|
|
dnl GCC 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, or (at your option)
|
|
dnl any later version.
|
|
dnl
|
|
dnl GCC 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 GCC; see the file COPYING3. If not see
|
|
dnl <http://www.gnu.org/licenses/>.
|
|
|
|
dnl See whether we need a declaration for a function.
|
|
dnl The result is highly dependent on the INCLUDES passed in, so make sure
|
|
dnl to use a different cache variable name in this macro if it is invoked
|
|
dnl in a different context somewhere else.
|
|
dnl gcc_AC_CHECK_DECL(SYMBOL,
|
|
dnl [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND [, INCLUDES]]])
|
|
AC_DEFUN([gcc_AC_CHECK_DECL],
|
|
[AC_MSG_CHECKING([whether $1 is declared])
|
|
AC_CACHE_VAL(gcc_cv_have_decl_$1,
|
|
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([$4],
|
|
[#ifndef $1
|
|
char *(*pfn) = (char *(*)) $1 ;
|
|
#endif])], eval "gcc_cv_have_decl_$1=yes", eval "gcc_cv_have_decl_$1=no")])
|
|
if eval "test \"`echo '$gcc_cv_have_decl_'$1`\" = yes"; then
|
|
AC_MSG_RESULT(yes) ; ifelse([$2], , :, [$2])
|
|
else
|
|
AC_MSG_RESULT(no) ; ifelse([$3], , :, [$3])
|
|
fi
|
|
])dnl
|
|
|
|
dnl Check multiple functions to see whether each needs a declaration.
|
|
dnl Arrange to define HAVE_DECL_<FUNCTION> to 0 or 1 as appropriate.
|
|
dnl gcc_AC_CHECK_DECLS(SYMBOLS,
|
|
dnl [ACTION-IF-NEEDED [, ACTION-IF-NOT-NEEDED [, INCLUDES]]])
|
|
AC_DEFUN([gcc_AC_CHECK_DECLS],
|
|
[AC_FOREACH([gcc_AC_Func], [$1],
|
|
[AH_TEMPLATE(AS_TR_CPP(HAVE_DECL_[]gcc_AC_Func),
|
|
[Define to 1 if we found a declaration for ']gcc_AC_Func[', otherwise
|
|
define to 0.])])dnl
|
|
for ac_func in $1
|
|
do
|
|
ac_tr_decl=AS_TR_CPP([HAVE_DECL_$ac_func])
|
|
gcc_AC_CHECK_DECL($ac_func,
|
|
[AC_DEFINE_UNQUOTED($ac_tr_decl, 1) $2],
|
|
[AC_DEFINE_UNQUOTED($ac_tr_decl, 0) $3],
|
|
dnl It is possible that the include files passed in here are local headers
|
|
dnl which supply a backup declaration for the relevant prototype based on
|
|
dnl the definition of (or lack of) the HAVE_DECL_ macro. If so, this test
|
|
dnl will always return success. E.g. see libiberty.h's handling of
|
|
dnl `basename'. To avoid this, we define the relevant HAVE_DECL_ macro to
|
|
dnl 1 so that any local headers used do not provide their own prototype
|
|
dnl during this test.
|
|
#undef $ac_tr_decl
|
|
#define $ac_tr_decl 1
|
|
$4
|
|
)
|
|
done
|
|
])
|
|
|
|
dnl 'make compare' can be significantly faster, if cmp itself can
|
|
dnl skip bytes instead of using tail. The test being performed is
|
|
dnl "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2"
|
|
dnl but we need to sink errors and handle broken shells. We also test
|
|
dnl for the parameter format "cmp file1 file2 skip1 skip2" which is
|
|
dnl accepted by cmp on some systems.
|
|
AC_DEFUN([gcc_AC_PROG_CMP_IGNORE_INITIAL],
|
|
[AC_CACHE_CHECK([for cmp's capabilities], gcc_cv_prog_cmp_skip,
|
|
[ echo abfoo >t1
|
|
echo cdfoo >t2
|
|
gcc_cv_prog_cmp_skip=slowcompare
|
|
if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
|
|
if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
|
|
:
|
|
else
|
|
gcc_cv_prog_cmp_skip=gnucompare
|
|
fi
|
|
fi
|
|
if test $gcc_cv_prog_cmp_skip = slowcompare ; then
|
|
if cmp t1 t2 2 2 > /dev/null 2>&1; then
|
|
if cmp t1 t2 1 1 > /dev/null 2>&1; then
|
|
:
|
|
else
|
|
gcc_cv_prog_cmp_skip=fastcompare
|
|
fi
|
|
fi
|
|
fi
|
|
rm t1 t2
|
|
])
|
|
make_compare_target=$gcc_cv_prog_cmp_skip
|
|
AC_SUBST(make_compare_target)
|
|
])
|
|
|
|
dnl See if symbolic links work and if not, try to substitute either hard links or simple copy.
|
|
AC_DEFUN([gcc_AC_PROG_LN_S],
|
|
[AC_MSG_CHECKING(whether ln -s works)
|
|
AC_CACHE_VAL(gcc_cv_prog_LN_S,
|
|
[rm -f conftestdata_t
|
|
echo >conftestdata_f
|
|
if ln -s conftestdata_f conftestdata_t 2>/dev/null
|
|
then
|
|
gcc_cv_prog_LN_S="ln -s"
|
|
else
|
|
if ln conftestdata_f conftestdata_t 2>/dev/null
|
|
then
|
|
gcc_cv_prog_LN_S=ln
|
|
else
|
|
if cp -p conftestdata_f conftestdata_t 2>/dev/null
|
|
then
|
|
gcc_cv_prog_LN_S="cp -p"
|
|
else
|
|
gcc_cv_prog_LN_S=cp
|
|
fi
|
|
fi
|
|
fi
|
|
rm -f conftestdata_f conftestdata_t
|
|
])dnl
|
|
LN_S="$gcc_cv_prog_LN_S"
|
|
if test "$gcc_cv_prog_LN_S" = "ln -s"; then
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
if test "$gcc_cv_prog_LN_S" = "ln"; then
|
|
AC_MSG_RESULT([no, using ln])
|
|
else
|
|
AC_MSG_RESULT([no, and neither does ln, so using $gcc_cv_prog_LN_S])
|
|
fi
|
|
fi
|
|
AC_SUBST(LN_S)dnl
|
|
])
|
|
|
|
dnl Define MKDIR_TAKES_ONE_ARG if mkdir accepts only one argument instead
|
|
dnl of the usual 2.
|
|
AC_DEFUN([gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG],
|
|
[AC_CACHE_CHECK([if mkdir takes one argument], gcc_cv_mkdir_takes_one_arg,
|
|
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
|
|
#include <sys/types.h>
|
|
#ifdef HAVE_SYS_STAT_H
|
|
# include <sys/stat.h>
|
|
#endif
|
|
#ifdef HAVE_UNISTD_H
|
|
# include <unistd.h>
|
|
#endif
|
|
#ifdef HAVE_DIRECT_H
|
|
# include <direct.h>
|
|
#endif], [mkdir ("foo", 0);])],
|
|
gcc_cv_mkdir_takes_one_arg=no, gcc_cv_mkdir_takes_one_arg=yes)])
|
|
if test $gcc_cv_mkdir_takes_one_arg = yes ; then
|
|
AC_DEFINE(MKDIR_TAKES_ONE_ARG, 1, [Define if host mkdir takes a single argument.])
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN([gcc_AC_PROG_INSTALL],
|
|
[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
|
|
# Find a good install program. We prefer a C program (faster),
|
|
# so one script is as good as another. But avoid the broken or
|
|
# incompatible versions:
|
|
# SysV /etc/install, /usr/sbin/install
|
|
# SunOS /usr/etc/install
|
|
# IRIX /sbin/install
|
|
# AIX /bin/install
|
|
# AFS /usr/afsws/bin/install, which mishandles nonexistent args
|
|
# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
|
|
# ./install, which can be erroneously created by make from ./install.sh.
|
|
AC_MSG_CHECKING(for a BSD compatible install)
|
|
if test -z "$INSTALL"; then
|
|
AC_CACHE_VAL(ac_cv_path_install,
|
|
[ IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="${IFS}:"
|
|
for ac_dir in $PATH; do
|
|
# Account for people who put trailing slashes in PATH elements.
|
|
case "$ac_dir/" in
|
|
/|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
|
|
*)
|
|
# OSF1 and SCO ODT 3.0 have their own names for install.
|
|
for ac_prog in ginstall scoinst install; do
|
|
if test -f $ac_dir/$ac_prog; then
|
|
if test $ac_prog = install &&
|
|
grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
|
|
# AIX install. It has an incompatible calling convention.
|
|
# OSF/1 installbsd also uses dspmsg, but is usable.
|
|
:
|
|
else
|
|
ac_cv_path_install="$ac_dir/$ac_prog -c"
|
|
break 2
|
|
fi
|
|
fi
|
|
done
|
|
;;
|
|
esac
|
|
done
|
|
IFS="$ac_save_IFS"
|
|
])dnl
|
|
if test "${ac_cv_path_install+set}" = set; then
|
|
INSTALL="$ac_cv_path_install"
|
|
else
|
|
# As a last resort, use the slow shell script. We don't cache a
|
|
# path for INSTALL within a source directory, because that will
|
|
# break other packages using the cache if that directory is
|
|
# removed, or if the path is relative.
|
|
INSTALL="$ac_install_sh"
|
|
fi
|
|
fi
|
|
dnl We do special magic for INSTALL instead of AC_SUBST, to get
|
|
dnl relative paths right.
|
|
AC_MSG_RESULT($INSTALL)
|
|
AC_SUBST(INSTALL)dnl
|
|
|
|
# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
|
|
# It thinks the first close brace ends the variable substitution.
|
|
test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
|
|
AC_SUBST(INSTALL_PROGRAM)dnl
|
|
|
|
test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
|
|
AC_SUBST(INSTALL_DATA)dnl
|
|
])
|
|
|
|
dnl Determine if enumerated bitfields are unsigned. ISO C says they can
|
|
dnl be either signed or unsigned.
|
|
dnl
|
|
AC_DEFUN([gcc_AC_C_ENUM_BF_UNSIGNED],
|
|
[AC_CACHE_CHECK(for unsigned enumerated bitfields, gcc_cv_enum_bf_unsigned,
|
|
[AC_RUN_IFELSE([AC_LANG_SOURCE([#include <stdlib.h>
|
|
enum t { BLAH = 128 } ;
|
|
struct s_t { enum t member : 8; } s ;
|
|
int main(void)
|
|
{
|
|
s.member = BLAH;
|
|
if (s.member < 0) exit(1);
|
|
exit(0);
|
|
|
|
}])], gcc_cv_enum_bf_unsigned=yes, gcc_cv_enum_bf_unsigned=no, gcc_cv_enum_bf_unsigned=yes)])
|
|
if test $gcc_cv_enum_bf_unsigned = yes; then
|
|
AC_DEFINE(ENUM_BITFIELDS_ARE_UNSIGNED, 1,
|
|
[Define if enumerated bitfields are treated as unsigned values.])
|
|
fi])
|
|
|
|
dnl Probe number of bits in a byte.
|
|
dnl Note C89 requires CHAR_BIT >= 8.
|
|
dnl
|
|
AC_DEFUN([gcc_AC_C_CHAR_BIT],
|
|
[AC_CACHE_CHECK(for CHAR_BIT, gcc_cv_decl_char_bit,
|
|
[AC_EGREP_CPP(found,
|
|
[#ifdef HAVE_LIMITS_H
|
|
#include <limits.h>
|
|
#endif
|
|
#ifdef CHAR_BIT
|
|
found
|
|
#endif], gcc_cv_decl_char_bit=yes, gcc_cv_decl_char_bit=no)
|
|
])
|
|
if test $gcc_cv_decl_char_bit = no; then
|
|
AC_CACHE_CHECK(number of bits in a byte, gcc_cv_c_nbby,
|
|
[i=8
|
|
gcc_cv_c_nbby=
|
|
while test $i -lt 65; do
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,
|
|
[switch(0) {
|
|
case (unsigned char)((unsigned long)1 << $i) == ((unsigned long)1 << $i):
|
|
case (unsigned char)((unsigned long)1<<($i-1)) == ((unsigned long)1<<($i-1)):
|
|
; }])],
|
|
[gcc_cv_c_nbby=$i; break])
|
|
i=`expr $i + 1`
|
|
done
|
|
test -z "$gcc_cv_c_nbby" && gcc_cv_c_nbby=failed
|
|
])
|
|
if test $gcc_cv_c_nbby = failed; then
|
|
AC_MSG_ERROR(cannot determine number of bits in a byte)
|
|
else
|
|
AC_DEFINE_UNQUOTED(CHAR_BIT, $gcc_cv_c_nbby,
|
|
[Define as the number of bits in a byte, if `limits.h' doesn't.])
|
|
fi
|
|
fi])
|
|
|
|
AC_DEFUN([gcc_AC_INITFINI_ARRAY],
|
|
[AC_REQUIRE([gcc_SUN_LD_VERSION])dnl
|
|
AC_ARG_ENABLE(initfini-array,
|
|
[ --enable-initfini-array use .init_array/.fini_array sections],
|
|
[], [
|
|
AC_CACHE_CHECK(for .preinit_array/.init_array/.fini_array support,
|
|
gcc_cv_initfini_array, [dnl
|
|
if test "x${build}" = "x${target}" && test "x${build}" = "x${host}"; then
|
|
case "${target}" in
|
|
ia64-*)
|
|
AC_RUN_IFELSE([AC_LANG_SOURCE([
|
|
#ifndef __ELF__
|
|
#error Not an ELF OS
|
|
#endif
|
|
/* We turn on .preinit_array/.init_array/.fini_array support for ia64
|
|
if it can be used. */
|
|
static int x = -1;
|
|
int main (void) { return x; }
|
|
int foo (void) { x = 0; }
|
|
int (*fp) (void) __attribute__ ((section (".init_array"))) = foo;
|
|
])],
|
|
[gcc_cv_initfini_array=yes], [gcc_cv_initfini_array=no],
|
|
[gcc_cv_initfini_array=no]);;
|
|
*)
|
|
gcc_cv_initfini_array=no
|
|
if test $in_tree_ld = yes ; then
|
|
if test "$gcc_cv_gld_major_version" -eq 2 \
|
|
-a "$gcc_cv_gld_minor_version" -ge 22 \
|
|
-o "$gcc_cv_gld_major_version" -gt 2 \
|
|
&& test $in_tree_ld_is_elf = yes; then
|
|
gcc_cv_initfini_array=yes
|
|
fi
|
|
elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
|
|
case $target:$gas in
|
|
*:yes)
|
|
sh_flags='"a"'
|
|
sh_type='%progbits'
|
|
;;
|
|
i?86-*-solaris2*:no | x86_64-*-solaris2*:no)
|
|
sh_flags='"a"'
|
|
sh_type='@progbits'
|
|
;;
|
|
sparc*-*-solaris2*:no)
|
|
sh_flags='#alloc'
|
|
sh_type='#progbits'
|
|
sh_quote='"'
|
|
;;
|
|
esac
|
|
case "$target:$gnu_ld" in
|
|
*:yes)
|
|
cat > conftest.s <<EOF
|
|
.section .dtors,$sh_flags,$sh_type
|
|
.balign 4
|
|
.byte 'A', 'A', 'A', 'A'
|
|
.section .ctors,$sh_flags,$sh_type
|
|
.balign 4
|
|
.byte 'B', 'B', 'B', 'B'
|
|
.section .fini_array.65530,$sh_flags,$sh_type
|
|
.balign 4
|
|
.byte 'C', 'C', 'C', 'C'
|
|
.section .init_array.65530,$sh_flags,$sh_type
|
|
.balign 4
|
|
.byte 'D', 'D', 'D', 'D'
|
|
.section .dtors.64528,$sh_flags,$sh_type
|
|
.balign 4
|
|
.byte 'E', 'E', 'E', 'E'
|
|
.section .ctors.64528,$sh_flags,$sh_type
|
|
.balign 4
|
|
.byte 'F', 'F', 'F', 'F'
|
|
.section .fini_array.01005,$sh_flags,$sh_type
|
|
.balign 4
|
|
.byte 'G', 'G', 'G', 'G'
|
|
.section .init_array.01005,$sh_flags,$sh_type
|
|
.balign 4
|
|
.byte 'H', 'H', 'H', 'H'
|
|
.text
|
|
.globl _start
|
|
_start:
|
|
EOF
|
|
if $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_objdump -s -j .init_array conftest \
|
|
| grep HHHHFFFFDDDDBBBB > /dev/null 2>&1 \
|
|
&& $gcc_cv_objdump -s -j .fini_array conftest \
|
|
| grep GGGGEEEECCCCAAAA > /dev/null 2>&1; then
|
|
gcc_cv_initfini_array=yes
|
|
fi
|
|
;;
|
|
*-*-solaris2*:no)
|
|
# When Solaris ld added constructor priority support, it was
|
|
# decided to only handle .init_array.N/.fini_array.N since
|
|
# there was no need for backwards compatibility with
|
|
# .ctors.N/.dtors.N. .ctors/.dtors remain as separate
|
|
# sections with correct execution order resp. to
|
|
# .init_array/.fini_array, while gld merges them into
|
|
# .init_array/.fini_array.
|
|
cat > conftest.s <<EOF
|
|
.section $sh_quote.fini_array.65530$sh_quote,$sh_flags,$sh_type
|
|
.align 4
|
|
.byte 'C', 'C', 'C', 'C'
|
|
.section $sh_quote.init_array.65530$sh_quote,$sh_flags,$sh_type
|
|
.align 4
|
|
.byte 'D', 'D', 'D', 'D'
|
|
.section $sh_quote.fini_array.01005$sh_quote,$sh_flags,$sh_type
|
|
.align 4
|
|
.byte 'G', 'G', 'G', 'G'
|
|
.section $sh_quote.init_array.01005$sh_quote,$sh_flags,$sh_type
|
|
.align 4
|
|
.byte 'H', 'H', 'H', 'H'
|
|
.text
|
|
.globl _start
|
|
_start:
|
|
EOF
|
|
if $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_objdump -s -j .init_array conftest \
|
|
| grep HHHHDDDD > /dev/null 2>&1 \
|
|
&& $gcc_cv_objdump -s -j .fini_array conftest \
|
|
| grep GGGGCCCC > /dev/null 2>&1; then
|
|
gcc_cv_initfini_array=yes
|
|
fi
|
|
;;
|
|
esac
|
|
changequote(,)dnl
|
|
rm -f conftest conftest.*
|
|
changequote([,])dnl
|
|
fi
|
|
AC_PREPROC_IFELSE([AC_LANG_SOURCE([
|
|
#ifndef __ELF__
|
|
# error Not an ELF OS
|
|
#endif
|
|
#include <stdlib.h>
|
|
#if defined __GLIBC_PREREQ
|
|
# if __GLIBC_PREREQ (2, 4)
|
|
# else
|
|
# error GLIBC 2.4 required
|
|
# endif
|
|
#else
|
|
# if defined __sun__ && defined __svr4__
|
|
/* Solaris ld.so.1 supports .init_array/.fini_array since Solaris 8. */
|
|
# else
|
|
# error The C library not known to support .init_array/.fini_array
|
|
# endif
|
|
#endif
|
|
])],, [gcc_cv_initfini_array=no]);;
|
|
esac
|
|
else
|
|
AC_MSG_CHECKING(cross compile... guessing)
|
|
gcc_cv_initfini_array=no
|
|
fi])
|
|
enable_initfini_array=$gcc_cv_initfini_array
|
|
])
|
|
AC_DEFINE_UNQUOTED(HAVE_INITFINI_ARRAY_SUPPORT,
|
|
[`if test $enable_initfini_array = yes; then echo 1; else echo 0; fi`],
|
|
[Define 0/1 if .init_array/.fini_array sections are available and working.])
|
|
])
|
|
|
|
dnl # _gcc_COMPUTE_GAS_VERSION
|
|
dnl # Used by gcc_GAS_VERSION_GTE_IFELSE
|
|
dnl #
|
|
dnl # WARNING:
|
|
dnl # gcc_cv_as_gas_srcdir must be defined before this.
|
|
dnl # This gross requirement will go away eventually.
|
|
AC_DEFUN([_gcc_COMPUTE_GAS_VERSION],
|
|
[gcc_cv_as_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
|
|
for f in $gcc_cv_as_bfd_srcdir/configure \
|
|
$gcc_cv_as_gas_srcdir/configure \
|
|
$gcc_cv_as_gas_srcdir/configure.ac \
|
|
$gcc_cv_as_gas_srcdir/Makefile.in ; do
|
|
gcc_cv_gas_version=`sed -n -e 's/^[[ ]]*VERSION=[[^0-9A-Za-z_]]*\([[0-9]]*\.[[0-9]]*.*\)/VERSION=\1/p' < $f`
|
|
if test x$gcc_cv_gas_version != x; then
|
|
break
|
|
fi
|
|
done
|
|
case $gcc_cv_gas_version in
|
|
VERSION=[[0-9]]*) ;;
|
|
*) AC_MSG_ERROR([[cannot find version of in-tree assembler]]);;
|
|
esac
|
|
gcc_cv_gas_major_version=`expr "$gcc_cv_gas_version" : "VERSION=\([[0-9]]*\)"`
|
|
gcc_cv_gas_minor_version=`expr "$gcc_cv_gas_version" : "VERSION=[[0-9]]*\.\([[0-9]]*\)"`
|
|
gcc_cv_gas_patch_version=`expr "$gcc_cv_gas_version" : "VERSION=[[0-9]]*\.[[0-9]]*\.\([[0-9]]*\)"`
|
|
case $gcc_cv_gas_patch_version in
|
|
"") gcc_cv_gas_patch_version="0" ;;
|
|
esac
|
|
gcc_cv_gas_vers=`expr \( \( $gcc_cv_gas_major_version \* 1000 \) \
|
|
+ $gcc_cv_gas_minor_version \) \* 1000 \
|
|
+ $gcc_cv_gas_patch_version`
|
|
]) []dnl # _gcc_COMPUTE_GAS_VERSION
|
|
|
|
dnl # gcc_GAS_VERSION_GTE_IFELSE([elf,] major, minor, patchlevel,
|
|
dnl # [command_if_true = :], [command_if_false = :])
|
|
dnl # Check to see if the version of GAS is greater than or
|
|
dnl # equal to the specified version.
|
|
dnl #
|
|
dnl # The first ifelse() shortens the shell code if the patchlevel
|
|
dnl # is unimportant (the usual case). The others handle missing
|
|
dnl # commands. Note that the tests are structured so that the most
|
|
dnl # common version number cases are tested first.
|
|
AC_DEFUN([_gcc_GAS_VERSION_GTE_IFELSE],
|
|
[ifelse([$1], elf,
|
|
[if test $in_tree_gas_is_elf = yes \
|
|
&&],
|
|
[if]) test $gcc_cv_gas_vers -ge `expr \( \( $2 \* 1000 \) + $3 \) \* 1000 + $4`
|
|
then dnl
|
|
ifelse([$5],,:,[$5])[]dnl
|
|
ifelse([$6],,,[
|
|
else $6])
|
|
fi])
|
|
|
|
AC_DEFUN([gcc_GAS_VERSION_GTE_IFELSE],
|
|
[AC_REQUIRE([_gcc_COMPUTE_GAS_VERSION])dnl
|
|
ifelse([$1], elf, [_gcc_GAS_VERSION_GTE_IFELSE($@)],
|
|
[_gcc_GAS_VERSION_GTE_IFELSE(,$@)])])
|
|
|
|
dnl # gcc_GAS_FLAGS
|
|
dnl # Used by gcc_GAS_CHECK_FEATURE
|
|
dnl #
|
|
AC_DEFUN([gcc_GAS_FLAGS],
|
|
[AC_CACHE_CHECK([assembler flags], gcc_cv_as_flags,
|
|
[ case "$target" in
|
|
i[[34567]]86-*-linux*)
|
|
dnl Override the default, which may be incompatible.
|
|
gcc_cv_as_flags=--32
|
|
;;
|
|
x86_64-*-linux-gnux32)
|
|
dnl Override the default, which may be incompatible.
|
|
gcc_cv_as_flags=--x32
|
|
;;
|
|
x86_64-*-linux*)
|
|
dnl Override the default, which may be incompatible.
|
|
gcc_cv_as_flags=--64
|
|
;;
|
|
powerpc*-*-darwin*)
|
|
dnl Always pass -arch ppc to assembler.
|
|
gcc_cv_as_flags="-arch ppc"
|
|
;;
|
|
*)
|
|
gcc_cv_as_flags=" "
|
|
;;
|
|
esac])
|
|
])
|
|
|
|
dnl gcc_GAS_CHECK_FEATURE(description, cv, [[elf,]major,minor,patchlevel],
|
|
dnl [extra switches to as], [assembler input],
|
|
dnl [extra testing logic], [command if feature available])
|
|
dnl
|
|
dnl Checks for an assembler feature. If we are building an in-tree
|
|
dnl gas, the feature is available if the associated assembler version
|
|
dnl is greater than or equal to major.minor.patchlevel. If not, then
|
|
dnl ASSEMBLER INPUT is fed to the assembler and the feature is available
|
|
dnl if assembly succeeds. If EXTRA TESTING LOGIC is not the empty string,
|
|
dnl then it is run instead of simply setting CV to "yes" - it is responsible
|
|
dnl for doing so, if appropriate.
|
|
AC_DEFUN([gcc_GAS_CHECK_FEATURE],
|
|
[AC_REQUIRE([gcc_GAS_FLAGS])dnl
|
|
AC_CACHE_CHECK([assembler for $1], [$2],
|
|
[[$2]=no
|
|
ifelse([$3],,,[dnl
|
|
if test $in_tree_gas = yes; then
|
|
gcc_GAS_VERSION_GTE_IFELSE($3, [[$2]=yes])
|
|
el])if test x$gcc_cv_as != x; then
|
|
AS_ECHO([ifelse(m4_substr([$5],0,1),[$], "[$5]", '[$5]')]) > conftest.s
|
|
if AC_TRY_COMMAND([$gcc_cv_as $gcc_cv_as_flags $4 -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD])
|
|
then
|
|
ifelse([$6],, [$2]=yes, [$6])
|
|
else
|
|
echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
|
|
cat conftest.s >&AS_MESSAGE_LOG_FD
|
|
fi
|
|
rm -f conftest.o conftest.s
|
|
fi])
|
|
ifelse([$7],,,[dnl
|
|
if test $[$2] = yes; then
|
|
$7
|
|
fi])
|
|
ifelse([$8],,,[dnl
|
|
if test $[$2] != yes; then
|
|
$8
|
|
fi])])
|
|
|
|
dnl gcc_SUN_LD_VERSION
|
|
dnl
|
|
dnl Determines Sun linker version numbers, setting gcc_cv_sun_ld_vers to
|
|
dnl the complete version number and gcc_cv_sun_ld_vers_{major, minor} to
|
|
dnl the corresponding fields.
|
|
dnl
|
|
dnl ld and ld.so.1 are guaranteed to be updated in lockstep, so ld version
|
|
dnl numbers can be used in ld.so.1 feature checks even if a different
|
|
dnl linker is configured.
|
|
dnl
|
|
AC_DEFUN([gcc_SUN_LD_VERSION],
|
|
[changequote(,)dnl
|
|
if test "x${build}" = "x${target}" && test "x${build}" = "x${host}"; then
|
|
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
|
|
#
|
|
gcc_cv_sun_ld_ver=`/usr/ccs/bin/ld -V 2>&1`
|
|
if echo "$gcc_cv_sun_ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
|
|
gcc_cv_sun_ld_vers=`echo $gcc_cv_sun_ld_ver | sed -n \
|
|
-e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
|
|
gcc_cv_sun_ld_vers_major=`expr "$gcc_cv_sun_ld_vers" : '\([0-9]*\)'`
|
|
gcc_cv_sun_ld_vers_minor=`expr "$gcc_cv_sun_ld_vers" : '[0-9]*\.\([0-9]*\)'`
|
|
fi
|
|
;;
|
|
esac
|
|
fi
|
|
changequote([,])dnl
|
|
])
|
|
|
|
dnl GCC_TARGET_TEMPLATE(KEY)
|
|
dnl ------------------------
|
|
dnl Define KEY as a valid configure key on the target machine.
|
|
|
|
m4_define([GCC_TARGET_TEMPLATE],
|
|
[m4_define([GCC_TARGET_TEMPLATE($1)],[])])
|
|
|
|
dnl AH_TEMPLATE(KEY, DESCRIPTION)
|
|
dnl -----------------------------
|
|
dnl Issue an autoheader template for KEY, i.e., a comment composed of
|
|
dnl DESCRIPTION (properly wrapped), and then #undef KEY. Redefinition
|
|
dnl of the macro in autoheader.m4, to support definition of only a few
|
|
dnl keys while compiling target libraries.
|
|
|
|
m4_define([AH_TEMPLATE],
|
|
[AH_VERBATIM([$1],m4_text_wrap([$2 */], [ ], [/* ])
|
|
m4_ifdef([GCC_TARGET_TEMPLATE($1)],[],[#ifndef USED_FOR_TARGET
|
|
])[#undef $1]m4_ifdef([GCC_TARGET_TEMPLATE($1)],[],[
|
|
#endif
|
|
]))])
|
|
|
|
dnl Make sure that build_exeext is looked for
|
|
AC_DEFUN([gcc_AC_BUILD_EXEEXT], [
|
|
ac_executable_extensions="$build_exeext"])
|
|
|
|
dnl GCC_GLIBC_VERSION_GTE_IFELSE(MAJOR, MINOR, IF-TRUE, IF-FALSE)
|
|
dnl -------------------------------------------------------------
|
|
dnl If the target glibc version ($glibc_version_major.$glibc_version_minor)
|
|
dnl is at least MAJOR.MINOR, call IF-TRUE, otherwise call IF-FALSE.
|
|
AC_DEFUN([GCC_GLIBC_VERSION_GTE_IFELSE],
|
|
[
|
|
AS_IF([test $glibc_version_major -gt $1 \
|
|
|| ( test $glibc_version_major -eq $1 && test $glibc_version_minor -ge $2 )],
|
|
[$3], [$4])])
|