6c889b67cb
* configure.in (errno): Check for declaration. * configure, config.in: Regenerated. * system.h (errno): Only declare if not already done. From-SVN: r41305
2070 lines
60 KiB
Plaintext
2070 lines
60 KiB
Plaintext
# configure.in for GNU CC
|
|
# Process this file with autoconf to generate a configuration script.
|
|
|
|
# Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
|
|
|
|
#This file is part of GNU CC.
|
|
|
|
#GNU CC 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 2, or (at your option)
|
|
#any later version.
|
|
|
|
#GNU CC 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 GNU CC; see the file COPYING. If not, write to
|
|
#the Free Software Foundation, 59 Temple Place - Suite 330,
|
|
#Boston, MA 02111-1307, USA.
|
|
|
|
# Initialization and defaults
|
|
AC_PREREQ(2.13)
|
|
AC_INIT(tree.c)
|
|
AC_CONFIG_HEADER(auto-host.h:config.in)
|
|
|
|
remove=rm
|
|
hard_link=ln
|
|
symbolic_link='ln -s'
|
|
copy=cp
|
|
|
|
# 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
|
|
|
|
# Check for additional parameters
|
|
|
|
# With GNU ld
|
|
AC_ARG_WITH(gnu-ld,
|
|
[ --with-gnu-ld arrange to work with GNU ld.],
|
|
gnu_ld_flag="$with_gnu_ld",
|
|
gnu_ld_flag=no)
|
|
|
|
# With pre-defined ld
|
|
AC_ARG_WITH(ld,
|
|
[ --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_WARN([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
|
|
fi
|
|
AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
|
|
[Define to enable the use of a default linker.])
|
|
fi
|
|
|
|
# With GNU as
|
|
AC_ARG_WITH(gnu-as,
|
|
[ --with-gnu-as arrange to work with GNU as.],
|
|
gas_flag="$with_gnu_as",
|
|
gas_flag=no)
|
|
|
|
AC_ARG_WITH(as,
|
|
[ --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_WARN([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
|
|
|
|
# With stabs
|
|
AC_ARG_WITH(stabs,
|
|
[ --with-stabs arrange to use stabs instead of host debug format.],
|
|
stabs="$with_stabs",
|
|
stabs=no)
|
|
|
|
# With ELF
|
|
AC_ARG_WITH(elf,
|
|
[ --with-elf arrange to use ELF instead of host debug format.],
|
|
elf="$with_elf",
|
|
elf=no)
|
|
|
|
# Specify the local prefix
|
|
local_prefix=
|
|
AC_ARG_WITH(local-prefix,
|
|
[ --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
|
|
|
|
# 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,
|
|
[ --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 test x${gcc_gxx_include_dir} = x; then
|
|
if test x${enable_version_specific_runtime_libs} = xyes; then
|
|
gcc_gxx_include_dir='${libsubdir}/include/g++'
|
|
else
|
|
topsrcdir=${srcdir}/.. . ${srcdir}/../config.if
|
|
changequote(<<, >>)dnl
|
|
gcc_gxx_include_dir="\$(libsubdir)/\$(unlibsubdir)/..\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/[^/]*|/..|g'\`/include/"${libstdcxx_incdir}
|
|
changequote([, ])dnl
|
|
fi
|
|
fi
|
|
|
|
# Determine whether or not multilibs are enabled.
|
|
AC_ARG_ENABLE(multilib,
|
|
[ --enable-multilib enable library support for multiple ABIs],
|
|
[], [enable_multilib=yes])
|
|
AC_SUBST(enable_multilib)
|
|
|
|
# Enable expensive internal checks
|
|
AC_ARG_ENABLE(checking,
|
|
[ --enable-checking[=LIST]
|
|
enable expensive run-time checks. With LIST,
|
|
enable only specific categories of checks.
|
|
Categories are: misc,tree,rtl,gc,gcac; default
|
|
is misc,tree,gc],
|
|
[ac_checking=
|
|
ac_tree_checking=
|
|
ac_rtl_checking=
|
|
ac_gc_checking=
|
|
ac_gc_always_collect=
|
|
case "${enableval}" in
|
|
yes) ac_checking=1 ; ac_tree_checking=1 ; ac_gc_checking=1 ;;
|
|
no) ;;
|
|
*) IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
|
|
set fnord $enableval; shift
|
|
IFS="$ac_save_IFS"
|
|
for check
|
|
do
|
|
case $check in
|
|
misc) ac_checking=1 ;;
|
|
tree) ac_tree_checking=1 ;;
|
|
rtl) ac_rtl_checking=1 ;;
|
|
gc) ac_gc_checking=1 ;;
|
|
gcac) ac_gc_always_collect=1 ;;
|
|
*) AC_MSG_ERROR(unknown check category $check) ;;
|
|
esac
|
|
done
|
|
;;
|
|
esac
|
|
],
|
|
# Enable some checks by default for development versions of GCC
|
|
[ac_checking=1; ac_tree_checking=1; ac_gc_checking=1;])
|
|
if test x$ac_checking != x ; then
|
|
AC_DEFINE(ENABLE_CHECKING, 1,
|
|
[Define if you want more run-time sanity checks. This one gets a grab
|
|
bag of miscellaneous but relatively cheap checks.])
|
|
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.])
|
|
fi
|
|
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_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
|
|
|
|
|
|
AC_ARG_ENABLE(cpp,
|
|
[ --disable-cpp don't provide a user-visible C preprocessor.],
|
|
[], [enable_cpp=yes])
|
|
|
|
AC_ARG_WITH(cpp_install_dir,
|
|
[ --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])
|
|
|
|
# Enable Multibyte Characters for C/C++
|
|
AC_ARG_ENABLE(c-mbchar,
|
|
[ --enable-c-mbchar Enable multibyte characters for C and C++.],
|
|
if test x$enable_c_mbchar != xno; then
|
|
AC_DEFINE(MULTIBYTE_CHARS, 1,
|
|
[Define if you want the C and C++ compilers to support multibyte
|
|
character sets for source code.])
|
|
fi)
|
|
|
|
# Enable threads
|
|
# Pass with no value to take the default
|
|
# Pass with a value to specify a thread package
|
|
AC_ARG_ENABLE(threads,
|
|
[ --enable-threads enable thread usage for target GCC.
|
|
--enable-threads=LIB use LIB thread package for target GCC.],,
|
|
enable_threads='')
|
|
|
|
enable_threads_flag=$enable_threads
|
|
# Check if a valid thread package
|
|
case x${enable_threads_flag} in
|
|
x | xno)
|
|
# No threads
|
|
target_thread_file='single'
|
|
;;
|
|
xyes)
|
|
# default
|
|
target_thread_file=''
|
|
;;
|
|
xdecosf1 | xirix | xmach | xos2 | xposix | xpthreads | xsingle | \
|
|
xsolaris | xwin32 | xdce | xvxworks | xaix)
|
|
target_thread_file=$enable_threads_flag
|
|
;;
|
|
*)
|
|
echo "$enable_threads is an unknown thread package" 1>&2
|
|
exit 1
|
|
;;
|
|
esac
|
|
|
|
AC_ARG_ENABLE(objc-gc,
|
|
[ --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,
|
|
[ --with-dwarf2 force the default debug format to be DWARF2.],
|
|
dwarf2="$with_dwarf2",
|
|
dwarf2=no)
|
|
|
|
AC_ARG_ENABLE(shared,
|
|
[ --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)
|
|
|
|
# Determine the host, build, and target systems
|
|
AC_CANONICAL_SYSTEM
|
|
|
|
# Find the native compiler
|
|
AC_PROG_CC
|
|
AC_PROG_CC_C_O
|
|
# autoconf is lame and doesn't give us any substitution variable for this.
|
|
if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = no"; then
|
|
NO_MINUS_C_MINUS_O=yes
|
|
else
|
|
OUTPUT_OPTION='-o $@'
|
|
fi
|
|
AC_SUBST(NO_MINUS_C_MINUS_O)
|
|
AC_SUBST(OUTPUT_OPTION)
|
|
|
|
AC_CACHE_CHECK(whether ${CC-cc} accepts -Wno-long-long,
|
|
ac_cv_prog_cc_no_long_long,
|
|
[save_CFLAGS="$CFLAGS"
|
|
CFLAGS="-Wno-long-long"
|
|
AC_TRY_COMPILE(,,ac_cv_prog_cc_no_long_long=yes,
|
|
ac_cv_prog_cc_no_long_long=no)
|
|
CFLAGS="$save_CFLAGS"])
|
|
strict1_warn=
|
|
if test $ac_cv_prog_cc_no_long_long = yes; then
|
|
strict1_warn="-pedantic -Wno-long-long"
|
|
fi
|
|
AC_SUBST(strict1_warn)
|
|
|
|
AC_PROG_CPP
|
|
AC_C_INLINE
|
|
gcc_AC_C_VOLATILE
|
|
|
|
gcc_AC_C_LONG_DOUBLE
|
|
gcc_AC_C_LONG_LONG
|
|
|
|
# sizeof(char) is 1 by definition.
|
|
gcc_AC_COMPILE_CHECK_SIZEOF(short)
|
|
gcc_AC_COMPILE_CHECK_SIZEOF(int)
|
|
gcc_AC_COMPILE_CHECK_SIZEOF(long)
|
|
if test $ac_cv_c_long_long = yes; then
|
|
gcc_AC_COMPILE_CHECK_SIZEOF(long long)
|
|
fi
|
|
if test $ac_cv_c___int64 = yes; then
|
|
gcc_AC_COMPILE_CHECK_SIZEOF(__int64)
|
|
fi
|
|
|
|
gcc_AC_C_CHARSET
|
|
|
|
# If the native compiler is GCC, we can enable warnings even in stage1.
|
|
# That's useful for people building cross-compilers, or just running a
|
|
# quick `make'.
|
|
warn_cflags=
|
|
if test "x$GCC" = "xyes"; then
|
|
warn_cflags='$(GCC_WARN_CFLAGS)'
|
|
fi
|
|
AC_SUBST(warn_cflags)
|
|
|
|
# Stage specific cflags for build.
|
|
stage1_cflags=
|
|
case $build in
|
|
vax-*-*)
|
|
if test x$GCC = xyes
|
|
then
|
|
stage1_cflags="-Wa,-J"
|
|
else
|
|
stage1_cflags="-J"
|
|
fi
|
|
;;
|
|
esac
|
|
AC_SUBST(stage1_cflags)
|
|
|
|
AC_PROG_MAKE_SET
|
|
|
|
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
|
|
|
|
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
|
|
|
|
AC_MSG_CHECKING(for GNU C library)
|
|
AC_CACHE_VAL(gcc_cv_glibc,
|
|
[AC_TRY_COMPILE(
|
|
[#include <features.h>],[
|
|
#if ! (defined __GLIBC__ || defined __GNU_LIBRARY__)
|
|
#error Not a GNU C library system
|
|
#endif],
|
|
[gcc_cv_glibc=yes],
|
|
gcc_cv_glibc=no)])
|
|
AC_MSG_RESULT($gcc_cv_glibc)
|
|
if test $gcc_cv_glibc = yes; then
|
|
AC_DEFINE(_GNU_SOURCE, 1, [Always define this when using the GNU C Library])
|
|
fi
|
|
|
|
# Find some useful tools
|
|
AC_PROG_AWK
|
|
gcc_AC_PROG_LN
|
|
gcc_AC_PROG_LN_S
|
|
AC_PROG_RANLIB
|
|
gcc_AC_PROG_INSTALL
|
|
|
|
AC_HEADER_STDC
|
|
AC_HEADER_TIME
|
|
gcc_AC_HEADER_STRING
|
|
AC_HEADER_SYS_WAIT
|
|
AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h \
|
|
fcntl.h unistd.h stab.h sys/file.h sys/time.h \
|
|
sys/resource.h sys/param.h sys/times.h sys/stat.h \
|
|
direct.h malloc.h langinfo.h iconv.h stdbool.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
|
|
gcc_AC_C_COMPILE_ENDIAN
|
|
gcc_AC_C_FLOAT_FORMAT
|
|
|
|
# See if GNAT has been installed
|
|
AC_CHECK_PROG(have_gnat, gnatbind, yes, no)
|
|
|
|
# See if we have the mktemp command.
|
|
AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
|
|
|
|
# Do we have a single-tree copy of texinfo?
|
|
if test -f $srcdir/../texinfo/Makefile.in; then
|
|
MAKEINFO='$(objdir)/../texinfo/makeinfo/makeinfo'
|
|
gcc_cv_prog_makeinfo_modern=yes
|
|
AC_MSG_RESULT([Using makeinfo from the unified source tree.])
|
|
else
|
|
# See if makeinfo has been installed and is modern enough
|
|
# that we can use it.
|
|
gcc_AC_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
|
|
[GNU texinfo.* \([0-9][0-9.]*\)],
|
|
[4.*])
|
|
fi
|
|
|
|
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 AC_SUBST(BUILD_INFO)
|
|
fi
|
|
|
|
# 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 AC_SUBST(GENERATED_MANPAGES)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
GENERATED_MANPAGES=
|
|
fi
|
|
|
|
# How about lex?
|
|
dnl Don't use AC_PROG_LEX; we insist on flex.
|
|
dnl LEXLIB is not useful in gcc.
|
|
if test -f $srcdir/../flex/skel.c; then
|
|
FLEX='$(objdir)/../flex/flex'
|
|
else
|
|
AC_CHECK_PROG(FLEX, flex, flex, false)
|
|
fi
|
|
|
|
# Bison?
|
|
# The -L switch is so bison can find its skeleton file.
|
|
if test -f $srcdir/../bison/bison.simple; then
|
|
BISON='$(objdir)/../bison/bison -L $(srcdir)/../bison/'
|
|
else
|
|
AC_CHECK_PROG(BISON, bison, bison, false)
|
|
fi
|
|
|
|
# See if the stage1 system preprocessor understands the ANSI C
|
|
# preprocessor stringification operator. (Used by symcat.h.)
|
|
AC_C_STRINGIZE
|
|
|
|
# Use <inttypes.h> only if it exists,
|
|
# doesn't clash with <sys/types.h>, and declares intmax_t.
|
|
AC_MSG_CHECKING(for inttypes.h)
|
|
AC_CACHE_VAL(gcc_cv_header_inttypes_h,
|
|
[AC_TRY_COMPILE(
|
|
[#include <sys/types.h>
|
|
#include <inttypes.h>],
|
|
[intmax_t i = -1;],
|
|
[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
|
|
|
|
dnl Disabled until we have a complete test for buggy enum bitfields.
|
|
dnl gcc_AC_C_ENUM_BF_UNSIGNED
|
|
|
|
AC_CHECK_FUNCS(strtoul bsearch popen \
|
|
strchr strrchr kill getrlimit setrlimit atoll atoq \
|
|
sysconf isascii gettimeofday strsignal putc_unlocked fputc_unlocked \
|
|
fputs_unlocked getrusage iconv nl_langinfo lstat)
|
|
|
|
AC_CHECK_TYPE(ssize_t, int)
|
|
|
|
# Try to determine the array type of the second argument of getgroups
|
|
# for the target system (int or gid_t).
|
|
AC_TYPE_GETGROUPS
|
|
if test "${target}" = "${build}"; then
|
|
TARGET_GETGROUPS_T=$ac_cv_type_getgroups
|
|
else
|
|
case "${target}" in
|
|
# This condition may need some tweaking. It should include all
|
|
# targets where the array type of the second argument of getgroups
|
|
# is int and the type of gid_t is not equivalent to int.
|
|
*-*-sunos* | *-*-ultrix*)
|
|
TARGET_GETGROUPS_T=int
|
|
;;
|
|
*)
|
|
TARGET_GETGROUPS_T=gid_t
|
|
;;
|
|
esac
|
|
fi
|
|
AC_SUBST(TARGET_GETGROUPS_T)
|
|
|
|
gcc_AC_FUNC_VFPRINTF_DOPRNT
|
|
gcc_AC_FUNC_STRSTR
|
|
gcc_AC_FUNC_PRINTF_PTR
|
|
|
|
case "${host}" in
|
|
*-*-uwin*)
|
|
AC_MSG_ERROR([
|
|
*** UWIN may not be used as a host platform because
|
|
*** linking with posix.dll is not allowed by the GNU GPL])
|
|
;;
|
|
esac
|
|
AC_FUNC_VFORK
|
|
AC_FUNC_MMAP_ANYWHERE
|
|
AC_FUNC_MMAP_FILE
|
|
|
|
# We will need to find libiberty.h and ansidecl.h
|
|
saved_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include"
|
|
gcc_AC_CHECK_DECLS(getenv atol sbrk abort atof getcwd getwd \
|
|
strsignal putc_unlocked fputs_unlocked strstr environ errno \
|
|
malloc realloc calloc free basename getopt, , ,[
|
|
#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
|
|
])
|
|
|
|
# Restore CFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
|
|
CFLAGS="$saved_CFLAGS"
|
|
|
|
# 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)
|
|
|
|
build_xm_file=
|
|
build_xm_defines=
|
|
build_install_headers_dir=install-headers-tar
|
|
build_exeext=
|
|
host_xm_file=
|
|
host_xm_defines=
|
|
host_xmake_file=
|
|
host_truncate_target=
|
|
host_exeext=
|
|
|
|
# Decode the host machine, then the target machine.
|
|
# For the host machine, we save the xm_file variable as host_xm_file;
|
|
# then we decode the target machine and forget everything else
|
|
# that came from the host machine.
|
|
for machine in $build $host $target; do
|
|
. ${srcdir}/config.gcc
|
|
done
|
|
|
|
extra_objs="${host_extra_objs} ${extra_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
|
|
|
|
if test x"$dwarf2" = xyes
|
|
then tm_file="$tm_file tm-dwarf2.h"
|
|
fi
|
|
|
|
if test x$float_format = x
|
|
then float_format=i64
|
|
fi
|
|
|
|
if test $float_format = none
|
|
then float_h_file=Makefile.in
|
|
else float_h_file=float-$float_format.h
|
|
fi
|
|
|
|
# Handle cpp installation.
|
|
if test x$enable_cpp != xno
|
|
then
|
|
tmake_file="$tmake_file t-install-cpp"
|
|
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.
|
|
|
|
changequote(,)dnl
|
|
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"
|
|
changequote([,])dnl
|
|
|
|
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
|
|
|
|
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
|
|
|
|
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 x$thread_file = x; then
|
|
if test x$target_thread_file != x; then
|
|
thread_file=$target_thread_file
|
|
else
|
|
thread_file='single'
|
|
fi
|
|
fi
|
|
|
|
# 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 hconfig 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
|
|
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
|
|
CC=${CC_FOR_BUILD} ${realsrcdir}/configure \
|
|
--target=$target --host=$build --build=$build
|
|
|
|
# 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
|
|
fi
|
|
|
|
tm_file="${tm_file} defaults.h"
|
|
host_xm_file="auto-host.h ansidecl.h ${host_xm_file} ${tm_file}"
|
|
build_xm_file="${build_auto} ansidecl.h ${build_xm_file} ${tm_file}"
|
|
xm_file="ansidecl.h ${xm_file} ${tm_file}"
|
|
|
|
# Truncate the target if necessary
|
|
if test x$host_truncate_target != x; then
|
|
target=`echo $target | sed -e 's/\(..............\).*/\1/'`
|
|
fi
|
|
|
|
# Get the version trigger filename from the toplevel
|
|
if test "${with_gcc_version_trigger+set}" = set; then
|
|
gcc_version_trigger=$with_gcc_version_trigger
|
|
else
|
|
gcc_version_trigger=${srcdir}/version.c
|
|
fi
|
|
changequote(,)dnl
|
|
gcc_version_full=`grep version_string ${gcc_version_trigger} | sed -e 's/.*\"\([^\"]*\)\".*/\1/'`
|
|
gcc_version=`echo ${gcc_version_full} | sed -e 's/\([^ ]*\) .*/\1/'`
|
|
|
|
# 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_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
|
|
else
|
|
gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
|
|
fi
|
|
cat > configargs.h <<EOF
|
|
/* Generated automatically. */
|
|
static const char configuration_arguments[] = "$gcc_config_arguments";
|
|
EOF
|
|
changequote([,])dnl
|
|
|
|
# Internationalization
|
|
PACKAGE=gcc
|
|
VERSION="$gcc_version"
|
|
AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE",
|
|
[Define to the name of the distribution.])
|
|
AC_DEFINE_UNQUOTED(VERSION, "$VERSION",
|
|
[Define to the version of the distribution.])
|
|
AC_SUBST(PACKAGE)
|
|
AC_SUBST(VERSION)
|
|
|
|
ALL_LINGUAS="sv"
|
|
|
|
# Enable NLS support by default
|
|
AC_ARG_ENABLE(nls,
|
|
[ --enable-nls use Native Language Support (default)],
|
|
, enable_nls=yes)
|
|
|
|
# if cross compiling, disable NLS support.
|
|
# It's not worth the trouble, at least for now.
|
|
|
|
if test "${build}" != "${host}" && test "x$enable_nls" = "xyes"; then
|
|
AC_MSG_WARN(Disabling NLS support for canadian cross compiler.)
|
|
enable_nls=no
|
|
fi
|
|
|
|
# if NLS is enabled, also enable check in po subdir
|
|
if test $enable_nls = yes; then
|
|
CHECK_PO=check-po
|
|
else
|
|
CHECK_PO=""
|
|
fi
|
|
|
|
AC_SUBST(CHECK_PO)
|
|
|
|
AM_GNU_GETTEXT
|
|
XGETTEXT="AWK='$AWK' \$(SHELL) \$(top_srcdir)/exgettext $XGETTEXT"
|
|
|
|
# Windows32 Registry support for specifying GCC installation paths.
|
|
AC_ARG_ENABLE(win32-registry,
|
|
[ --disable-win32-registry
|
|
Disable lookup of installation paths in the
|
|
Registry on Windows hosts.
|
|
--enable-win32-registry Enable registry lookup (default).
|
|
--enable-win32-registry=KEY
|
|
Use KEY instead of GCC version as the last portion
|
|
of the registry key.],,)
|
|
|
|
AC_MSG_CHECKING(whether windows registry support is requested)
|
|
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 Windows32
|
|
Registry. Ignored on non windows32 hosts.])
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
|
|
# Check if user specified a different registry key.
|
|
case x${enable_win32_registry} in
|
|
x | xyes)
|
|
# default.
|
|
gcc_cv_win32_registry_key="$VERSION"
|
|
;;
|
|
xno)
|
|
# no registry lookup.
|
|
gcc_cv_win32_registry_key=''
|
|
;;
|
|
*)
|
|
# user-specified key.
|
|
gcc_cv_win32_registry_key="$enable_win32_registry"
|
|
;;
|
|
esac
|
|
|
|
if test x$enable_win32_registry != xno; then
|
|
AC_MSG_CHECKING(registry key on windows hosts)
|
|
AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$gcc_cv_win32_registry_key",
|
|
[Define to be the last portion of registry key on windows hosts.])
|
|
AC_MSG_RESULT($gcc_cv_win32_registry_key)
|
|
fi
|
|
|
|
# Get an absolute path to the GCC top-level source directory
|
|
holddir=`pwd`
|
|
cd $srcdir
|
|
topdir=`pwd`
|
|
cd $holddir
|
|
|
|
# Conditionalize the makefile for this host machine.
|
|
# Make-host contains the concatenation of all host makefile fragments
|
|
# [there can be more than one]. This file is built by configure.frag.
|
|
host_overrides=Make-host
|
|
dep_host_xmake_file=
|
|
for f in .. ${host_xmake_file}
|
|
do
|
|
if test -f ${srcdir}/config/$f
|
|
then
|
|
dep_host_xmake_file="${dep_host_xmake_file} ${srcdir}/config/$f"
|
|
fi
|
|
done
|
|
|
|
# Conditionalize the makefile for this target machine.
|
|
# Make-target contains the concatenation of all host makefile fragments
|
|
# [there can be more than one]. This file is built by configure.frag.
|
|
target_overrides=Make-target
|
|
dep_tmake_file=
|
|
for f in .. ${tmake_file}
|
|
do
|
|
if test -f ${srcdir}/config/$f
|
|
then
|
|
dep_tmake_file="${dep_tmake_file} ${srcdir}/config/$f"
|
|
fi
|
|
done
|
|
|
|
# If the host doesn't support symlinks, modify CC in
|
|
# FLAGS_TO_PASS so CC="stage1/xgcc -Bstage1/" works.
|
|
# Otherwise, we can use "CC=$(CC)".
|
|
rm -f symtest.tem
|
|
if $symbolic_link $srcdir/gcc.c symtest.tem 2>/dev/null
|
|
then
|
|
cc_set_by_configure="\$(CC)"
|
|
quoted_cc_set_by_configure="\$(CC)"
|
|
stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
|
|
else
|
|
rm -f symtest.tem
|
|
if cp -p $srcdir/gcc.c symtest.tem 2>/dev/null
|
|
then
|
|
symbolic_link="cp -p"
|
|
else
|
|
symbolic_link="cp"
|
|
fi
|
|
cc_set_by_configure="\`case '\$(CC)' in stage*) echo '\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\$(CC)';; esac\`"
|
|
quoted_cc_set_by_configure="\\\`case '\\\$(CC)' in stage*) echo '\\\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(CC)';; esac\\\`"
|
|
stage_prefix_set_by_configure="\`case '\$(STAGE_PREFIX)' in stage*) echo '\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\$(STAGE_PREFIX)';; esac\`"
|
|
fi
|
|
rm -f symtest.tem
|
|
|
|
out_object_file=`basename $out_file .c`.o
|
|
|
|
tm_file_list=
|
|
for f in $tm_file; do
|
|
case $f in
|
|
ansidecl.h )
|
|
tm_file_list="${tm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
|
|
defaults.h )
|
|
tm_file_list="${tm_file_list} $f" ;;
|
|
*) tm_file_list="${tm_file_list} \$(srcdir)/config/$f" ;;
|
|
esac
|
|
done
|
|
|
|
tm_p_file_list=
|
|
for f in $tm_p_file; do
|
|
tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
|
|
done
|
|
|
|
host_xm_file_list=
|
|
for f in $host_xm_file; do
|
|
case $f in
|
|
ansidecl.h )
|
|
host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
|
|
auto-host.h | defaults.h )
|
|
host_xm_file_list="${host_xm_file_list} $f" ;;
|
|
*) host_xm_file_list="${host_xm_file_list} \$(srcdir)/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/ansidecl.h" ;;
|
|
auto-build.h | auto-host.h | defaults.h )
|
|
build_xm_file_list="${build_xm_file_list} $f" ;;
|
|
*) build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f" ;;
|
|
esac
|
|
done
|
|
|
|
# Define macro CROSS_COMPILE in compilation
|
|
# if this is a cross-compiler.
|
|
# Also use all.cross instead of all.internal
|
|
# and add cross-make to Makefile.
|
|
cross_overrides="/dev/null"
|
|
if test x$host != x$target
|
|
then
|
|
cross_defines="CROSS=-DCROSS_COMPILE"
|
|
cross_overrides="${topdir}/cross-make"
|
|
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, then define inhibit_libc in
|
|
# LIBGCC2_CFLAGS. This will cause __eprintf to be left out of
|
|
# libgcc.a, but that's OK because newlib should have its own version of
|
|
# assert.h.
|
|
inhibit_libc=
|
|
if [test x$host != x$target] && [test x$with_headers = x]; then
|
|
inhibit_libc=-Dinhibit_libc
|
|
else
|
|
if [test x$with_newlib = xyes]; then
|
|
inhibit_libc=-Dinhibit_libc
|
|
fi
|
|
fi
|
|
AC_SUBST(inhibit_libc)
|
|
|
|
# When building gcc with a cross-compiler, we need to fix a few things.
|
|
# This must come after cross-make as we want all.build to override
|
|
# all.cross.
|
|
build_overrides="/dev/null"
|
|
if test x$build != x$host
|
|
then
|
|
build_overrides="${topdir}/build-make"
|
|
fi
|
|
|
|
# Expand extra_headers to include complete path.
|
|
# This substitutes for lots of t-* files.
|
|
extra_headers_list=
|
|
if test "x$extra_headers" = x
|
|
then true
|
|
else
|
|
# Prepend ${srcdir}/ginclude/ to every entry in extra_headers.
|
|
for file in $extra_headers;
|
|
do
|
|
extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/${file}"
|
|
done
|
|
fi
|
|
|
|
if test x$use_collect2 = xno; then
|
|
use_collect2=
|
|
fi
|
|
|
|
# Add a definition of USE_COLLECT2 if system wants one.
|
|
# Also tell toplev.c what to do.
|
|
# This substitutes for lots of t-* files.
|
|
if test x$use_collect2 = x
|
|
then
|
|
will_use_collect2=
|
|
maybe_use_collect2=
|
|
else
|
|
will_use_collect2="collect2"
|
|
maybe_use_collect2="-DUSE_COLLECT2"
|
|
fi
|
|
|
|
# If we have gas in the build tree, make a link to it.
|
|
if test -f ../gas/Makefile; then
|
|
rm -f as; $symbolic_link ../gas/as-new$host_exeext as$host_exeext 2>/dev/null
|
|
fi
|
|
|
|
# If we have nm in the build tree, make a link to it.
|
|
if test -f ../binutils/Makefile; then
|
|
rm -f nm; $symbolic_link ../binutils/nm-new$host_exeext nm$host_exeext 2>/dev/null
|
|
fi
|
|
|
|
# If we have ld in the build tree, make a link to it.
|
|
if test -f ../ld/Makefile; then
|
|
# if test x$use_collect2 = x; then
|
|
# rm -f ld; $symbolic_link ../ld/ld-new$host_exeext ld$host_exeext 2>/dev/null
|
|
# else
|
|
rm -f collect-ld; $symbolic_link ../ld/ld-new$host_exeext collect-ld$host_exeext 2>/dev/null
|
|
# fi
|
|
fi
|
|
|
|
# Figure out what assembler we will be using.
|
|
AC_MSG_CHECKING(what assembler to use)
|
|
gcc_cv_as=
|
|
gcc_cv_gas_major_version=
|
|
gcc_cv_gas_minor_version=
|
|
gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
|
|
if test -x "$DEFAULT_ASSEMBLER"; then
|
|
gcc_cv_as="$DEFAULT_ASSEMBLER"
|
|
elif test -x "$AS"; then
|
|
gcc_cv_as="$AS"
|
|
elif test -x as$host_exeext; then
|
|
# Build using assembler in the current directory.
|
|
gcc_cv_as=./as$host_exeext
|
|
elif test -f $gcc_cv_as_gas_srcdir/configure.in -a -f ../gas/Makefile; then
|
|
# Single tree build which includes gas.
|
|
for f in $gcc_cv_as_gas_srcdir/configure $gcc_cv_as_gas_srcdir/configure.in $gcc_cv_as_gas_srcdir/Makefile.in
|
|
do
|
|
changequote(,)dnl
|
|
gcc_cv_gas_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
|
|
changequote([,])dnl
|
|
if test x$gcc_cv_gas_version != x; then
|
|
break
|
|
fi
|
|
done
|
|
changequote(,)dnl
|
|
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]*\)"`
|
|
changequote([,])dnl
|
|
fi
|
|
|
|
if test "x$gcc_cv_as" = x -a x$host = x$target; then
|
|
# Native build.
|
|
# Search the same directories that the installed compiler will
|
|
# search. Else we may find the wrong assembler and lose. If we
|
|
# do not find a suitable assembler binary, then try the user's
|
|
# path.
|
|
#
|
|
# Also note we have to check MD_EXEC_PREFIX before checking the
|
|
# user's path. Unfortunately, there is no good way to get at the
|
|
# value of MD_EXEC_PREFIX here. So we do a brute force search
|
|
# through all the known MD_EXEC_PREFIX values. Ugh. This needs
|
|
# to be fixed as part of the make/configure rewrite too.
|
|
|
|
if test "x$exec_prefix" = xNONE; then
|
|
if test "x$prefix" = xNONE; then
|
|
test_prefix=/usr/local
|
|
else
|
|
test_prefix=$prefix
|
|
fi
|
|
else
|
|
test_prefix=$exec_prefix
|
|
fi
|
|
|
|
# If the loop below does not find an assembler, then use whatever
|
|
# one we can find in the users's path.
|
|
# user's path.
|
|
gcc_cv_as=as$host_exeext
|
|
|
|
test_dirs="$test_prefix/lib/gcc-lib/$target/$gcc_version \
|
|
$test_prefix/lib/gcc-lib/$target \
|
|
/usr/lib/gcc/$target/$gcc_version \
|
|
/usr/lib/gcc/$target \
|
|
$test_prefix/$target/bin/$target/$gcc_version \
|
|
$test_prefix/$target/bin \
|
|
/usr/libexec \
|
|
/usr/ccs/gcc \
|
|
/usr/ccs/bin \
|
|
/udk/usr/ccs/bin \
|
|
/bsd43/usr/lib/cmplrs/cc \
|
|
/usr/cross64/usr/bin \
|
|
/usr/lib/cmplrs/cc \
|
|
/sysv/usr/lib/cmplrs/cc \
|
|
/svr4/usr/lib/cmplrs/cc \
|
|
/usr/bin"
|
|
|
|
for dir in $test_dirs; do
|
|
if test -f $dir/as$host_exeext; then
|
|
gcc_cv_as=$dir/as$host_exeext
|
|
break;
|
|
fi
|
|
done
|
|
fi
|
|
if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
|
|
AC_MSG_RESULT("newly built gas")
|
|
else
|
|
AC_MSG_RESULT($gcc_cv_as)
|
|
fi
|
|
|
|
# Figure out what nm we will be using.
|
|
AC_MSG_CHECKING(what nm to use)
|
|
if test -x nm$host_exeext; then
|
|
gcc_cv_nm=./nm$host_exeext
|
|
elif test x$host = x$target; then
|
|
# Native build.
|
|
gcc_cv_nm=nm$host_exeext
|
|
fi
|
|
AC_MSG_RESULT($gcc_cv_nm)
|
|
|
|
# Figure out what assembler alignment features are present.
|
|
AC_MSG_CHECKING(assembler alignment features)
|
|
gcc_cv_as_alignment_features=none
|
|
if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
|
|
# Gas version 2.6 and later support for .balign and .p2align.
|
|
# bytes to skip when using .p2align.
|
|
if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 6 -o "$gcc_cv_gas_major_version" -gt 2; then
|
|
gcc_cv_as_alignment_features=".balign and .p2align"
|
|
AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN)
|
|
fi
|
|
# Gas version 2.8 and later support specifying the maximum
|
|
# bytes to skip when using .p2align.
|
|
if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 8 -o "$gcc_cv_gas_major_version" -gt 2; then
|
|
gcc_cv_as_alignment_features=".p2align including maximum skip"
|
|
AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN)
|
|
fi
|
|
elif test x$gcc_cv_as != x; then
|
|
# Check if we have .balign and .p2align
|
|
echo ".balign 4" > conftest.s
|
|
echo ".p2align 2" >> conftest.s
|
|
if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
|
|
gcc_cv_as_alignment_features=".balign and .p2align"
|
|
AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN)
|
|
fi
|
|
rm -f conftest.s conftest.o
|
|
# Check if specifying the maximum bytes to skip when
|
|
# using .p2align is supported.
|
|
echo ".p2align 4,,7" > conftest.s
|
|
if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
|
|
gcc_cv_as_alignment_features=".p2align including maximum skip"
|
|
AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN)
|
|
fi
|
|
rm -f conftest.s conftest.o
|
|
fi
|
|
AC_MSG_RESULT($gcc_cv_as_alignment_features)
|
|
|
|
AC_MSG_CHECKING(assembler subsection support)
|
|
gcc_cv_as_subsections=no
|
|
if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
|
|
if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 9 -o "$gcc_cv_gas_major_version" -gt 2 && grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
|
|
gcc_cv_as_subsections="working .subsection -1"
|
|
fi
|
|
elif test x$gcc_cv_as != x; then
|
|
# Check if we have .subsection
|
|
echo ".subsection 1" > conftest.s
|
|
if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
|
|
gcc_cv_as_subsections=".subsection"
|
|
if test x$gcc_cv_nm != x; then
|
|
cat > conftest.s <<EOF
|
|
conftest_label1: .word 0
|
|
.subsection -1
|
|
conftest_label2: .word 0
|
|
.previous
|
|
EOF
|
|
if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; 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_subsections="working .subsection -1"
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
|
|
fi
|
|
if test x"$gcc_cv_as_subsections" = x"working .subsection -1"; then
|
|
AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
|
|
[Define if your assembler supports .subsection and .subsection -1 starts
|
|
emitting at the beginning of your section.])
|
|
fi
|
|
AC_MSG_RESULT($gcc_cv_as_subsections)
|
|
|
|
AC_MSG_CHECKING(assembler weak support)
|
|
gcc_cv_as_weak=no
|
|
if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
|
|
if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 2 -o "$gcc_cv_gas_major_version" -gt 2; then
|
|
gcc_cv_as_weak="yes"
|
|
fi
|
|
elif test x$gcc_cv_as != x; then
|
|
# Check if we have .weak
|
|
echo " .weak foobar" > conftest.s
|
|
if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
|
|
gcc_cv_as_weak="yes"
|
|
fi
|
|
rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
|
|
fi
|
|
if test x"$gcc_cv_as_weak" = xyes; then
|
|
AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])
|
|
fi
|
|
AC_MSG_RESULT($gcc_cv_as_weak)
|
|
|
|
AC_MSG_CHECKING(assembler hidden support)
|
|
gcc_cv_as_hidden=no
|
|
if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
|
|
if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 10 -o "$gcc_cv_gas_major_version" -gt 2 && grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
|
|
gcc_cv_as_hidden="yes"
|
|
fi
|
|
elif test x$gcc_cv_as != x; then
|
|
# Check if we have .hidden
|
|
echo " .hidden foobar" > conftest.s
|
|
echo "foobar:" >> conftest.s
|
|
if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
|
|
gcc_cv_as_hidden="yes"
|
|
fi
|
|
rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
|
|
fi
|
|
if test x"$gcc_cv_as_hidden" = xyes; then
|
|
AC_DEFINE(HAVE_GAS_HIDDEN, 1,
|
|
[Define if your assembler supports .hidden.])
|
|
fi
|
|
AC_MSG_RESULT($gcc_cv_as_hidden)
|
|
|
|
AC_MSG_CHECKING(assembler leb128 support)
|
|
gcc_cv_as_leb128=no
|
|
if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
|
|
if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 11 -o "$gcc_cv_gas_major_version" -gt 2 && grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
|
|
gcc_cv_as_leb128="yes"
|
|
fi
|
|
elif test x$gcc_cv_as != x; then
|
|
# Check if we have .[us]leb128, and support symbol arithmetic with it.
|
|
cat > conftest.s <<EOF
|
|
.data
|
|
.uleb128 L2 - L1
|
|
L1:
|
|
.uleb128 1280
|
|
.sleb128 -1010
|
|
L2:
|
|
EOF
|
|
if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
|
|
gcc_cv_as_leb128="yes"
|
|
|
|
# GAS versions before 2.11 do not support uleb128,
|
|
# despite appearing to.
|
|
# ??? There exists an elf-specific test that will crash
|
|
# the assembler. Perhaps it's better to figure out whether
|
|
# arbitrary sections are supported and try the test.
|
|
as_ver=`$gcc_cv_as --version 2>/dev/null | head -1`
|
|
if echo "$as_ver" | grep GNU > /dev/null; then
|
|
as_ver=`echo $as_ver | sed -e 's/.* //'`
|
|
as_major=`echo $as_ver | sed 's/\..*//'`
|
|
changequote(,)dnl
|
|
as_minor=`echo $as_ver | sed 's/[^.]*\.\([0-9]*\).*/\1/'`
|
|
changequote([,])dnl
|
|
if test $as_major -eq 2 -a $as_minor -lt 11; then
|
|
gcc_cv_as_leb128="no"
|
|
fi
|
|
fi
|
|
fi
|
|
rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
|
|
fi
|
|
if test x"$gcc_cv_as_leb128" = xyes; then
|
|
AC_DEFINE(HAVE_AS_LEB128, 1,
|
|
[Define if your assembler supports .uleb128.])
|
|
fi
|
|
AC_MSG_RESULT($gcc_cv_as_leb128)
|
|
|
|
case "$target" in
|
|
sparc*-*-*)
|
|
AC_CACHE_CHECK([assembler .register pseudo-op support],
|
|
gcc_cv_as_register_pseudo_op, [
|
|
gcc_cv_as_register_pseudo_op=unknown
|
|
if test x$gcc_cv_as != x; then
|
|
# Check if we have .register
|
|
echo ".register %g2, #scratch" > conftest.s
|
|
if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
|
|
gcc_cv_as_register_pseudo_op=yes
|
|
else
|
|
gcc_cv_as_register_pseudo_op=no
|
|
fi
|
|
rm -f conftest.s conftest.o
|
|
fi
|
|
])
|
|
if test "x$gcc_cv_as_register_pseudo_op" = xyes; then
|
|
AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
|
|
[Define if your assembler supports .register.])
|
|
fi
|
|
|
|
AC_CACHE_CHECK([assembler supports -relax],
|
|
gcc_cv_as_relax_opt, [
|
|
gcc_cv_as_relax_opt=unknown
|
|
if test x$gcc_cv_as != x; then
|
|
# Check if gas supports -relax
|
|
echo ".text" > conftest.s
|
|
if $gcc_cv_as -relax -o conftest.o conftest.s > /dev/null 2>&1; then
|
|
gcc_cv_as_relax_opt=yes
|
|
else
|
|
gcc_cv_as_relax_opt=no
|
|
fi
|
|
rm -f conftest.s conftest.o
|
|
fi
|
|
])
|
|
if test "x$gcc_cv_as_relax_opt" = xyes; then
|
|
AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
|
|
[Define if your assembler supports -relax option.])
|
|
fi
|
|
|
|
case "$tm_file" in
|
|
*64*)
|
|
AC_CACHE_CHECK([for 64 bit support in assembler ($gcc_cv_as)],
|
|
gcc_cv_as_flags64, [
|
|
if test -n "$gcc_cv_as"; then
|
|
echo ".xword foo" > conftest.s
|
|
gcc_cv_as_flags64=no
|
|
for flag in "-xarch=v9" "-64 -Av9"; do
|
|
if $gcc_cv_as $flag -o conftest.o conftest.s \
|
|
> /dev/null 2>&1; then
|
|
gcc_cv_as_flags64=$flag
|
|
break
|
|
fi
|
|
done
|
|
rm -f conftest.s conftest.o
|
|
else
|
|
if test "$gas" = yes; then
|
|
gcc_cv_as_flags64="-64 -Av9"
|
|
else
|
|
gcc_cv_as_flags64="-xarch=v9"
|
|
fi
|
|
fi
|
|
])
|
|
if test "x$gcc_cv_as_flags64" = xno; then
|
|
changequote(, )
|
|
tmake_file=`echo " $tmake_file " | sed -e 's, sparc/t-sol2-64 , ,' -e 's,^ ,,' -e 's, $,,'`
|
|
dep_tmake_file=`echo " $dep_tmake_file " | sed -e 's, [^ ]*/config/sparc/t-sol2-64 , ,' -e 's,^ ,,' -e 's, $,,'`
|
|
changequote([, ])
|
|
else
|
|
AC_DEFINE_UNQUOTED(AS_SPARC64_FLAG, "$gcc_cv_as_flags64",
|
|
[Define if the assembler supports 64bit sparc.])
|
|
fi
|
|
;;
|
|
*) gcc_cv_as_flags64=${gcc_cv_as_flags64-no}
|
|
;;
|
|
esac
|
|
|
|
if test "x$gcc_cv_as_flags64" != xno; then
|
|
AC_CACHE_CHECK([for assembler offsetable %lo() support],
|
|
gcc_cv_as_offsetable_lo10, [
|
|
gcc_cv_as_offsetable_lo10=unknown
|
|
if test "x$gcc_cv_as" != x; then
|
|
# Check if assembler has offsetable %lo()
|
|
echo "or %g1, %lo(ab) + 12, %g1" > conftest.s
|
|
echo "or %g1, %lo(ab + 12), %g1" > conftest1.s
|
|
if $gcc_cv_as $gcc_cv_as_flags64 -o conftest.o conftest.s \
|
|
> /dev/null 2>&1 &&
|
|
$gcc_cv_as $gcc_cv_as_flags64 -o conftest1.o conftest1.s \
|
|
> /dev/null 2>&1; then
|
|
if cmp conftest.o conftest1.o > /dev/null 2>&1; then
|
|
gcc_cv_as_offsetable_lo10=no
|
|
else
|
|
gcc_cv_as_offsetable_lo10=yes
|
|
fi
|
|
else
|
|
gcc_cv_as_offsetable_lo10=no
|
|
fi
|
|
rm -f conftest.s conftest.o conftest1.s conftest1.o
|
|
fi
|
|
])
|
|
if test "x$gcc_cv_as_offsetable_lo10" = xyes; then
|
|
AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
|
|
[Define if your assembler supports offsetable %lo().])
|
|
fi
|
|
fi
|
|
;;
|
|
|
|
changequote(,)dnl
|
|
i[34567]86-*-*)
|
|
changequote([,])dnl
|
|
AC_MSG_CHECKING(assembler instructions)
|
|
gcc_cv_as_instructions=
|
|
if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
|
|
if test "$gcc_cv_gas_major_version" -eq 2 -a "$gcc_cv_gas_minor_version" -ge 9 -o "$gcc_cv_gas_major_version" -gt 2; then
|
|
gcc_cv_as_instructions="filds fists"
|
|
fi
|
|
elif test x$gcc_cv_as != x; then
|
|
set "filds fists" "filds mem; fists mem"
|
|
while test $# -gt 0
|
|
do
|
|
echo "$2" > conftest.s
|
|
if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
|
|
gcc_cv_as_instructions=${gcc_cv_as_instructions}$1" "
|
|
fi
|
|
shift 2
|
|
done
|
|
rm -f conftest.s conftest.o
|
|
fi
|
|
if test x"$gcc_cv_as_instructions" != x; then
|
|
AC_DEFINE_UNQUOTED(HAVE_GAS_`echo "$gcc_cv_as_instructions" | sed -e 's/ $//' | tr '[a-z ]' '[A-Z_]'`)
|
|
fi
|
|
AC_MSG_RESULT($gcc_cv_as_instructions)
|
|
;;
|
|
esac
|
|
|
|
AC_MSG_CHECKING(assembler dwarf2 debug_line support)
|
|
gcc_cv_as_dwarf2_debug_line=no
|
|
# ??? Not all targets support dwarf2 debug_line, even within a version
|
|
# of gas. Moreover, we need to emit a valid instruction to trigger any
|
|
# info to the output file. So, as supported targets are added to gas 2.11,
|
|
# add some instruction here to (also) show we expect this might work.
|
|
# ??? Once 2.11 is released, probably need to add first known working
|
|
# version to the per-target configury.
|
|
case "$target" in
|
|
i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-*)
|
|
insn="nop"
|
|
;;
|
|
ia64*-*-*)
|
|
insn="nop 0"
|
|
;;
|
|
esac
|
|
if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x;
|
|
then
|
|
if test "$gcc_cv_gas_major_version" -eq 2 \
|
|
-a "$gcc_cv_gas_minor_version" -ge 11 \
|
|
-o "$gcc_cv_gas_major_version" -gt 2 \
|
|
&& grep 'obj_format = elf' ../gas/Makefile > /dev/null \
|
|
&& test x"$insn" != x ; then
|
|
gcc_cv_as_dwarf2_debug_line="yes"
|
|
fi
|
|
elif test x$gcc_cv_as != x -a x"$insn" != x ; then
|
|
echo ' .file 1 "conftest.s"' > conftest.s
|
|
echo ' .loc 1 3 0' >> conftest.s
|
|
echo " $insn" >> conftest.s
|
|
# ??? This fails with non-gnu grep.
|
|
if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
|
|
&& grep debug_line conftest.o > /dev/null 2>&1 ; then
|
|
# The .debug_line file table must be in the exact order that
|
|
# we specified the files, since these indicies are also used
|
|
# by DW_AT_decl_file. Approximate this test by testing if
|
|
# the assembler bitches if the same index is assigned twice.
|
|
echo ' .file 1 "foo.s"' > conftest.s
|
|
echo ' .file 1 "bar.s"' >> conftest.s
|
|
if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1
|
|
then
|
|
gcc_cv_as_dwarf2_debug_line="no"
|
|
else
|
|
gcc_cv_as_dwarf2_debug_line="yes"
|
|
fi
|
|
fi
|
|
rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
|
|
fi
|
|
if test x"$gcc_cv_as_dwarf2_debug_line" = xyes; then
|
|
AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
|
|
[Define if your assembler supports dwarf2 .file/.loc directives,
|
|
and preserves file table indicies exactly as given.])
|
|
fi
|
|
AC_MSG_RESULT($gcc_cv_as_dwarf2_debug_line)
|
|
|
|
# Figure out what language subdirectories are present.
|
|
# Look if the user specified --enable-languages="..."; if not, use
|
|
# the environment variable $LANGUAGES if defined. $LANGUAGES might
|
|
# go away some day.
|
|
if test x"${enable_languages+set}" != xset; then
|
|
if test x"${LANGUAGES+set}" = xset; then
|
|
enable_languages="`echo ${LANGUAGES} | tr ' ' ','`"
|
|
else
|
|
enable_languages=all
|
|
fi
|
|
else
|
|
if test x"${enable_languages}" = x; then
|
|
AC_MSG_ERROR([--enable-languages needs at least one argument])
|
|
fi
|
|
fi
|
|
|
|
# First scan to see if an enabled language requires some other language.
|
|
# We assume that a given config-lang.in will list all the language
|
|
# front ends it requires, even if some are required indirectly.
|
|
for lang in ${srcdir}/*/config-lang.in ..
|
|
do
|
|
case $lang in
|
|
..)
|
|
;;
|
|
# The odd quoting in the next line works around
|
|
# an apparent bug in bash 1.12 on linux.
|
|
changequote(,)dnl
|
|
${srcdir}/[*]/config-lang.in)
|
|
;;
|
|
*)
|
|
lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
|
|
this_lang_requires=`sed -n -e 's,^lang_requires=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^lang_requires=\([^ ]*\).*$,\1,p' $lang`
|
|
for other in $this_lang_requires
|
|
do
|
|
case ,${enable_languages}, in
|
|
*,$other,*)
|
|
;;
|
|
*,all,*)
|
|
;;
|
|
*,$lang_alias,*)
|
|
enable_languages="$enable_languages,$other"
|
|
;;
|
|
esac
|
|
done
|
|
;;
|
|
changequote([,])dnl
|
|
esac
|
|
done
|
|
|
|
subdirs=
|
|
for lang in ${srcdir}/*/config-lang.in ..
|
|
do
|
|
case $lang in
|
|
..) ;;
|
|
# The odd quoting in the next line works around
|
|
# an apparent bug in bash 1.12 on linux.
|
|
changequote(,)dnl
|
|
${srcdir}/[*]/config-lang.in) ;;
|
|
*)
|
|
lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
|
|
this_lang_libs=`sed -n -e 's,^target_libs=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^target_libs=\([^ ]*\).*$,\1,p' $lang`
|
|
build_by_default=`sed -n -e 's,^build_by_default=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^build_by_default=\([^ ]*\).*$,\1,p' $lang`
|
|
if test "x$lang_alias" = x
|
|
then
|
|
echo "$lang doesn't set \$language." 1>&2
|
|
exit 1
|
|
fi
|
|
case ${build_by_default},${enable_languages}, in
|
|
*,$lang_alias,*) add_this_lang=yes ;;
|
|
no,*) add_this_lang=no ;;
|
|
*,all,*) add_this_lang=yes ;;
|
|
*) add_this_lang=no ;;
|
|
esac
|
|
if test x"${add_this_lang}" = xyes; then
|
|
case $lang in
|
|
${srcdir}/ada/config-lang.in)
|
|
if test x$have_gnat = xyes ; then
|
|
subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
|
|
fi
|
|
;;
|
|
*)
|
|
subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
|
|
;;
|
|
esac
|
|
fi
|
|
;;
|
|
changequote([,])dnl
|
|
esac
|
|
done
|
|
|
|
# Make gthr-default.h if we have a thread file.
|
|
gthread_flags=
|
|
if test $thread_file != single; then
|
|
rm -f gthr-default.h
|
|
echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h
|
|
gthread_flags=-DHAVE_GTHR_DEFAULT
|
|
fi
|
|
AC_SUBST(gthread_flags)
|
|
|
|
# Find out what GC implementation we want, or may, use.
|
|
AC_ARG_WITH(gc,
|
|
[ --with-gc={simple,page} Choose the garbage collection mechanism to use
|
|
with the compiler.],
|
|
[case "$withval" in
|
|
simple | page)
|
|
GGC=ggc-$withval
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR([$withval is an invalid option to --with-gc])
|
|
;;
|
|
esac],
|
|
[GGC=ggc-page])
|
|
AC_SUBST(GGC)
|
|
echo "Using $GGC for garbage collection."
|
|
|
|
# Use the system's zlib library.
|
|
zlibdir=-L../zlib
|
|
zlibinc="-I\$(srcdir)/../zlib"
|
|
AC_ARG_WITH(system-zlib,
|
|
[ --with-system-zlib use installed libz],
|
|
zlibdir=
|
|
zlibinc=
|
|
)
|
|
AC_SUBST(zlibdir)
|
|
AC_SUBST(zlibinc)
|
|
|
|
AC_DEFINE_UNQUOTED(ENABLE_STD_NAMESPACE, 1,
|
|
[Define to 1 if you want to enable namespaces (-fhonor-std) by default.])
|
|
|
|
dnl Very limited version of automake's enable-maintainer-mode
|
|
|
|
AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
|
|
dnl maintainer-mode is disabled by default
|
|
AC_ARG_ENABLE(maintainer-mode,
|
|
[ --enable-maintainer-mode enable make rules and dependencies not useful
|
|
(and sometimes confusing) to the casual installer],
|
|
maintainer_mode=$enableval,
|
|
maintainer_mode=no)
|
|
|
|
AC_MSG_RESULT($maintainer_mode)
|
|
|
|
if test "$maintainer_mode" = "yes"; then
|
|
MAINT=''
|
|
else
|
|
MAINT='#'
|
|
fi
|
|
AC_SUBST(MAINT)dnl
|
|
|
|
# With Setjmp/Longjmp based exception handling.
|
|
AC_ARG_ENABLE(sjlj-exceptions,
|
|
[ --enable-sjlj-exceptions arrange to use setjmp/longjmp exception handling.],
|
|
[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.])])
|
|
|
|
# Make empty files to contain the specs and options for each language.
|
|
# Then add #include lines to for a compiler that has specs and/or options.
|
|
|
|
lang_specs_files=
|
|
lang_options_files=
|
|
lang_tree_files=
|
|
rm -f specs.h options.h gencheck.h
|
|
touch specs.h options.h gencheck.h
|
|
for subdir in . $subdirs
|
|
do
|
|
if test -f $srcdir/$subdir/lang-specs.h; then
|
|
echo "#include \"$subdir/lang-specs.h\"" >>specs.h
|
|
lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
|
|
fi
|
|
if test -f $srcdir/$subdir/lang-options.h; then
|
|
echo "#include \"$subdir/lang-options.h\"" >>options.h
|
|
lang_options_files="$lang_options_files $srcdir/$subdir/lang-options.h"
|
|
fi
|
|
if test -f $srcdir/$subdir/$subdir-tree.def; then
|
|
echo "#include \"$subdir/$subdir-tree.def\"" >>gencheck.h
|
|
lang_tree_files="$lang_tree_files $srcdir/$subdir/$subdir-tree.def"
|
|
fi
|
|
done
|
|
|
|
# These (without "all_") are set in each config-lang.in.
|
|
# `language' must be a single word so is spelled singularly.
|
|
all_languages=
|
|
all_boot_languages=
|
|
all_compilers=
|
|
all_stagestuff=
|
|
all_diff_excludes=
|
|
all_outputs='Makefile intl/Makefile po/Makefile.in fixinc/Makefile gccbug mklibgcc'
|
|
# List of language makefile fragments.
|
|
all_lang_makefiles=
|
|
all_headers=
|
|
all_lib2funcs=
|
|
|
|
# Add the language fragments.
|
|
# Languages are added via two mechanisms. Some information must be
|
|
# recorded in makefile variables, these are defined in config-lang.in.
|
|
# We accumulate them and plug them into the main Makefile.
|
|
# The other mechanism is a set of hooks for each of the main targets
|
|
# like `clean', `install', etc.
|
|
|
|
language_fragments="Make-lang"
|
|
language_hooks="Make-hooks"
|
|
|
|
for s in .. $subdirs
|
|
do
|
|
if test $s != ".."
|
|
then
|
|
language=
|
|
boot_language=
|
|
compilers=
|
|
stagestuff=
|
|
diff_excludes=
|
|
headers=
|
|
outputs=
|
|
lib2funcs=
|
|
. ${srcdir}/$s/config-lang.in
|
|
if test "x$language" = x
|
|
then
|
|
echo "${srcdir}/$s/config-lang.in doesn't set \$language." 1>&2
|
|
exit 1
|
|
fi
|
|
all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Make-lang.in"
|
|
if test -f ${srcdir}/$s/Makefile.in
|
|
then all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Makefile.in"
|
|
fi
|
|
all_languages="$all_languages $language"
|
|
if test "x$boot_language" = xyes
|
|
then
|
|
all_boot_languages="$all_boot_languages $language"
|
|
fi
|
|
all_compilers="$all_compilers $compilers"
|
|
all_stagestuff="$all_stagestuff $stagestuff"
|
|
all_diff_excludes="$all_diff_excludes $diff_excludes"
|
|
all_headers="$all_headers $headers"
|
|
all_outputs="$all_outputs $outputs"
|
|
all_lib2funcs="$all_lib2funcs $lib2funcs"
|
|
fi
|
|
done
|
|
|
|
check_languages=
|
|
for language in .. $all_languages
|
|
do
|
|
if test $language != ".."
|
|
then
|
|
check_languages="$check_languages check-$language"
|
|
fi
|
|
done
|
|
|
|
# Since we can't use `::' targets, we link each language in
|
|
# with a set of hooks, reached indirectly via lang.${target}.
|
|
|
|
rm -f Make-hooks
|
|
touch Make-hooks
|
|
target_list="all.build all.cross start.encap rest.encap \
|
|
info dvi \
|
|
install-normal install-common install-info install-man \
|
|
uninstall \
|
|
mostlyclean clean distclean extraclean maintainer-clean \
|
|
stage1 stage2 stage3 stage4"
|
|
for t in $target_list
|
|
do
|
|
x=
|
|
for lang in .. $all_languages
|
|
do
|
|
if test $lang != ".."; then
|
|
x="$x $lang.$t"
|
|
fi
|
|
done
|
|
echo "lang.$t: $x" >> Make-hooks
|
|
done
|
|
|
|
# Create .gdbinit.
|
|
|
|
echo "dir ." > .gdbinit
|
|
echo "dir ${srcdir}" >> .gdbinit
|
|
if test x$gdb_needs_out_file_path = xyes
|
|
then
|
|
echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
|
|
fi
|
|
if test "x$subdirs" != x; then
|
|
for s in $subdirs
|
|
do
|
|
echo "dir ${srcdir}/$s" >> .gdbinit
|
|
done
|
|
fi
|
|
echo "source ${srcdir}/gdbinit.in" >> .gdbinit
|
|
|
|
# Define variables host_canonical and build_canonical
|
|
# because some Cygnus local changes in the Makefile depend on them.
|
|
build_canonical=${build}
|
|
host_canonical=${host}
|
|
target_subdir=
|
|
if test "${host}" != "${target}" ; then
|
|
target_subdir=${target_alias}/
|
|
fi
|
|
AC_SUBST(build_canonical)
|
|
AC_SUBST(host_canonical)
|
|
AC_SUBST(target_subdir)
|
|
|
|
# If $(exec_prefix) exists and is not the same as $(prefix), then compute an
|
|
# absolute path for gcc_tooldir based on inserting the number of up-directory
|
|
# movements required to get from $(exec_prefix) to $(prefix) into the basic
|
|
# $(libsubdir)/@(unlibsubdir) based path.
|
|
# Don't set gcc_tooldir to tooldir since that's only passed in by the toplevel
|
|
# make and thus we'd get different behavior depending on where we built the
|
|
# sources.
|
|
if test x$exec_prefix = xNONE -o x$exec_prefix = x$prefix; then
|
|
gcc_tooldir='$(libsubdir)/$(unlibsubdir)/../$(target_alias)'
|
|
else
|
|
changequote(<<, >>)dnl
|
|
# An explanation of the sed strings:
|
|
# -e 's|^\$(prefix)||' matches and eliminates 'prefix' from 'exec_prefix'
|
|
# -e 's|/$||' match a trailing forward slash and eliminates it
|
|
# -e 's|^[^/]|/|' forces the string to start with a forward slash (*)
|
|
# -e 's|/[^/]*|../|g' replaces each occurance of /<directory> with ../
|
|
#
|
|
# (*) Note this pattern overwrites the first character of the string
|
|
# with a forward slash if one is not already present. This is not a
|
|
# problem because the exact names of the sub-directories concerned is
|
|
# unimportant, just the number of them matters.
|
|
#
|
|
# The practical upshot of these patterns is like this:
|
|
#
|
|
# prefix exec_prefix result
|
|
# ------ ----------- ------
|
|
# /foo /foo/bar ../
|
|
# /foo/ /foo/bar ../
|
|
# /foo /foo/bar/ ../
|
|
# /foo/ /foo/bar/ ../
|
|
# /foo /foo/bar/ugg ../../
|
|
#
|
|
dollar='$$'
|
|
gcc_tooldir="\$(libsubdir)/\$(unlibsubdir)/\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/\$(dollar)||' -e 's|^[^/]|/|' -e 's|/[^/]*|../|g'\`\$(target_alias)"
|
|
changequote([, ])dnl
|
|
fi
|
|
AC_SUBST(gcc_tooldir)
|
|
AC_SUBST(dollar)
|
|
|
|
# Find a directory in which to install a shared libgcc.
|
|
|
|
AC_ARG_ENABLE(version-specific-runtime-libs,
|
|
[ --enable-version-specific-runtime-libs Specify that runtime libraries shou
|
|
ld be installed in a compiler-specific directory ])
|
|
|
|
AC_ARG_WITH(slibdir,
|
|
[ --with-slibdir=DIR shared libraries in DIR [LIBDIR]],
|
|
slibdir="$with_slibdir",
|
|
if test "${enable_version_specific_runtime_libs+set}" = set; then
|
|
slibdir='$(libsubdir)'
|
|
elif test "$host" != "$target"; then
|
|
slibdir='$(build_tooldir)/lib'
|
|
else
|
|
slibdir='$(libdir)'
|
|
fi)
|
|
AC_SUBST(slibdir)
|
|
|
|
# Nothing to do for FLOAT_H, float_format already handled.
|
|
objdir=`pwd`
|
|
AC_SUBST(objdir)
|
|
|
|
# Process the language and host/target makefile fragments.
|
|
${CONFIG_SHELL-/bin/sh} $srcdir/configure.frag $srcdir "$subdirs" "$dep_host_xmake_file" "$dep_tmake_file"
|
|
|
|
# Substitute configuration variables
|
|
AC_SUBST(subdirs)
|
|
AC_SUBST(all_boot_languages)
|
|
AC_SUBST(all_compilers)
|
|
AC_SUBST(all_diff_excludes)
|
|
AC_SUBST(all_headers)
|
|
AC_SUBST(all_lang_makefiles)
|
|
AC_SUBST(all_languages)
|
|
AC_SUBST(all_lib2funcs)
|
|
AC_SUBST(all_stagestuff)
|
|
AC_SUBST(build_exeext)
|
|
AC_SUBST(build_install_headers_dir)
|
|
AC_SUBST(build_xm_file_list)
|
|
AC_SUBST(build_xm_file)
|
|
AC_SUBST(build_xm_defines)
|
|
AC_SUBST(check_languages)
|
|
AC_SUBST(cc_set_by_configure)
|
|
AC_SUBST(quoted_cc_set_by_configure)
|
|
AC_SUBST(cpp_install_dir)
|
|
AC_SUBST(dep_host_xmake_file)
|
|
AC_SUBST(dep_tmake_file)
|
|
AC_SUBST(extra_c_flags)
|
|
AC_SUBST(extra_headers_list)
|
|
AC_SUBST(extra_objs)
|
|
AC_SUBST(extra_parts)
|
|
AC_SUBST(extra_passes)
|
|
AC_SUBST(extra_programs)
|
|
AC_SUBST(float_h_file)
|
|
AC_SUBST(gcc_config_arguments)
|
|
AC_SUBST(gcc_gxx_include_dir)
|
|
AC_SUBST(libstdcxx_incdir)
|
|
AC_SUBST(gcc_version)
|
|
AC_SUBST(gcc_version_full)
|
|
AC_SUBST(gcc_version_trigger)
|
|
AC_SUBST(host_exeext)
|
|
AC_SUBST(host_extra_gcc_objs)
|
|
AC_SUBST(host_xm_file_list)
|
|
AC_SUBST(host_xm_file)
|
|
AC_SUBST(host_xm_defines)
|
|
AC_SUBST(install)
|
|
AC_SUBST(lang_options_files)
|
|
AC_SUBST(lang_specs_files)
|
|
AC_SUBST(lang_tree_files)
|
|
AC_SUBST(local_prefix)
|
|
AC_SUBST(maybe_use_collect2)
|
|
AC_SUBST(md_file)
|
|
AC_SUBST(objc_boehm_gc)
|
|
AC_SUBST(out_file)
|
|
AC_SUBST(out_object_file)
|
|
AC_SUBST(stage_prefix_set_by_configure)
|
|
AC_SUBST(symbolic_link)
|
|
AC_SUBST(thread_file)
|
|
AC_SUBST(tm_file_list)
|
|
AC_SUBST(tm_file)
|
|
AC_SUBST(tm_p_file_list)
|
|
AC_SUBST(tm_p_file)
|
|
AC_SUBST(xm_file)
|
|
AC_SUBST(xm_defines)
|
|
AC_SUBST(will_use_collect2)
|
|
AC_SUBST(c_target_objs)
|
|
AC_SUBST(cxx_target_objs)
|
|
AC_SUBST(target_cpu_default)
|
|
|
|
AC_SUBST_FILE(target_overrides)
|
|
AC_SUBST_FILE(host_overrides)
|
|
AC_SUBST(cross_defines)
|
|
AC_SUBST_FILE(cross_overrides)
|
|
AC_SUBST_FILE(build_overrides)
|
|
AC_SUBST_FILE(language_fragments)
|
|
AC_SUBST_FILE(language_hooks)
|
|
|
|
# Echo that links are built
|
|
if test x$host = x$target
|
|
then
|
|
str1="native "
|
|
else
|
|
str1="cross-"
|
|
str2=" from $host"
|
|
fi
|
|
|
|
if test x$host != x$build
|
|
then
|
|
str3=" on a $build system"
|
|
fi
|
|
|
|
if test "x$str2" != x || test "x$str3" != x
|
|
then
|
|
str4=
|
|
fi
|
|
|
|
echo "Links are now set up to build a ${str1}compiler for ${target}$str4" 1>&2
|
|
|
|
if test "x$str2" != x || test "x$str3" != x
|
|
then
|
|
echo " ${str2}${str3}." 1>&2
|
|
fi
|
|
|
|
# Truncate the target if necessary
|
|
if test x$host_truncate_target != x; then
|
|
target=`echo $target | sed -e 's/\(..............\).*/\1/'`
|
|
fi
|
|
|
|
# Configure the subdirectories
|
|
# AC_CONFIG_SUBDIRS($subdirs)
|
|
|
|
# Create the Makefile
|
|
# and configure language subdirectories
|
|
AC_OUTPUT($all_outputs,
|
|
[
|
|
case x$CONFIG_HEADERS in
|
|
xauto-host.h:config.in)
|
|
echo > cstamp-h ;;
|
|
esac
|
|
# If the host supports symlinks, point stage[1234] at ../stage[1234] so
|
|
# bootstrapping and the installation procedure can still use
|
|
# CC="stage1/xgcc -Bstage1/". If the host doesn't support symlinks,
|
|
# FLAGS_TO_PASS has been modified to solve the problem there.
|
|
# This is virtually a duplicate of what happens in configure.lang; we do
|
|
# an extra check to make sure this only happens if ln -s can be used.
|
|
if test "$symbolic_link" = "ln -s"; then
|
|
for d in .. ${subdirs} ; do
|
|
if test $d != ..; then
|
|
STARTDIR=`pwd`
|
|
cd $d
|
|
for t in stage1 stage2 stage3 stage4 include
|
|
do
|
|
rm -f $t
|
|
$symbolic_link ../$t $t 2>/dev/null
|
|
done
|
|
cd $STARTDIR
|
|
fi
|
|
done
|
|
else true ; fi
|
|
# Avoid having to add intl to our include paths.
|
|
if test -f intl/libintl.h; then
|
|
echo creating libintl.h
|
|
echo '#include "intl/libintl.h"' >libintl.h
|
|
fi
|
|
],
|
|
[
|
|
host='${host}'
|
|
build='${build}'
|
|
target='${target}'
|
|
target_alias='${target_alias}'
|
|
srcdir='${srcdir}'
|
|
subdirs='${subdirs}'
|
|
symbolic_link='${symbolic_link}'
|
|
program_transform_set='${program_transform_set}'
|
|
program_transform_name='${program_transform_name}'
|
|
dep_host_xmake_file='${dep_host_xmake_file}'
|
|
host_xmake_file='${host_xmake_file}'
|
|
dep_tmake_file='${dep_tmake_file}'
|
|
tmake_file='${tmake_file}'
|
|
thread_file='${thread_file}'
|
|
gcc_config_arguments='${gcc_config_arguments}'
|
|
gcc_version='${gcc_version}'
|
|
gcc_version_full='${gcc_version_full}'
|
|
gcc_version_trigger='${gcc_version_trigger}'
|
|
local_prefix='${local_prefix}'
|
|
build_install_headers_dir='${build_install_headers_dir}'
|
|
build_exeext='${build_exeext}'
|
|
host_exeext='${host_exeext}'
|
|
out_file='${out_file}'
|
|
gdb_needs_out_file_path='${gdb_needs_out_file_path}'
|
|
SET_MAKE='${SET_MAKE}'
|
|
target_list='${target_list}'
|
|
target_overrides='${target_overrides}'
|
|
host_overrides='${host_overrides}'
|
|
cross_defines='${cross_defines}'
|
|
cross_overrides='${cross_overrides}'
|
|
build_overrides='${build_overrides}'
|
|
cpp_install_dir='${cpp_install_dir}'
|
|
])
|