# configure.in for GCC # Process this file with autoconf to generate a configuration script. # Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc. #This file is part of GCC. #GCC is free software; you can redistribute it and/or modify it under #the terms of the GNU General Public License as published by the Free #Software Foundation; either version 2, or (at your option) any later #version. #GCC is distributed in the hope that it will be useful, but WITHOUT #ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or #FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License #for more details. #You should have received a copy of the GNU General Public License #along with GCC; see the file 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/c++' 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,rtlflag,gc,gcac; default is misc,tree,gc,rtlflag], [ac_checking= ac_tree_checking= ac_rtl_checking= ac_rtlflag_checking= ac_gc_checking= ac_gc_always_collect= case "${enableval}" in yes) ac_checking=1 ; ac_tree_checking=1 ; ac_gc_checking=1 ; ac_rtlflag_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 ;; rtlflag) ac_rtlflag_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; ac_rtlflag_checking=1;]) nocommon_flag="" 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.]) nocommon_flag=-fno-common fi AC_SUBST(nocommon_flag) 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_rtlflag_checking != x ; then AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1, [Define if you want RTL flag accesses to be checked against the RTL codes that are supported for each access macro. This is relatively cheap.]) fi if test x$ac_gc_checking != x ; then AC_DEFINE(ENABLE_GC_CHECKING, 1, [Define if you want the garbage collector to do object poisoning and other memory allocation checks. This is quite expensive.]) fi if test x$ac_gc_always_collect != x ; then AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1, [Define if you want the garbage collector to operate in maximally paranoid mode, validating the entire heap and collecting garbage at every opportunity. This is extremely expensive.]) fi # Enable code coverage collection AC_ARG_ENABLE(coverage, [ --enable-coverage[=LEVEL] enable compiler\'s code coverage collection. Use to measure compiler performance and locate unused parts of the compiler. With LEVEL, specificy optimization. Values are opt, noopt, default is noopt], [case "${enableval}" in yes|noopt) coverage_flags="-fprofile-arcs -ftest-coverage -O0" ;; opt) coverage_flags="-fprofile-arcs -ftest-coverage -O2" ;; *) AC_MSG_ERROR(unknown coverage setting $enableval) ;; esac], [coverage_flags=""]) AC_SUBST(coverage_flags) 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 __cxa_atexit for C++. AC_ARG_ENABLE(__cxa_atexit, [ --enable-__cxa_atexit enable __cxa_atexit for C++], [], []) if test x$enable___cxa_atexit = xyes; then AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 1, [Define if you want to use __cxa_atexit, rather than atexit, to register C++ destructors for local statics and global objects. This is essential for fully standards-compliant handling of destructors, but requires __cxa_atexit in libc.]) fi # 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 | xrtems| 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 DWARF 2], 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 # Set program_transform_name AC_ARG_PROGRAM # 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) # See if GNAT has been installed gcc_AC_PROG_GNAT 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"]) if test x$have_gnat != xno ; then AC_CACHE_CHECK(whether ${ADAC} accepts -Wno-long-long, ac_cv_prog_adac_no_long_long, [cat >conftest.adb <&5 2>&5 ; then ac_cv_prog_adac_no_long_long=yes else ac_cv_prog_adac_no_long_long=no fi rm -f conftest*]) else ac_cv_prog_adac_no_long_long=yes fi strict1_warn= if test $ac_cv_prog_cc_no_long_long = yes && \ test $ac_cv_prog_adac_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 gcc_AC_C__BOOL # 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 ;; powerpc-*-darwin*) # The spiffy cpp-precomp chokes on some legitimate constructs in GCC # sources; use -no-cpp-precomp to get to GNU cpp. # Apple's GCC has bugs in designated initializer handling, so disable # that too. stage1_cflags="-no-cpp-precomp -DHAVE_DESIGNATED_INITIALIZERS=0" ;; 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 ],[ #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_STDBOOL 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 sys/file.h sys/time.h \ sys/resource.h sys/param.h sys/times.h sys/stat.h \ direct.h malloc.h langinfo.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 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.[1-9]*]) 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 # These libraries may be used by collect2. # We may need a special search path to get them linked. AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs, [save_LIBS="$LIBS" for libs in '' -lld -lmld \ '-L/usr/lib/cmplrs/cc2.11 -lmld' \ '-L/usr/lib/cmplrs/cc3.11 -lmld' do LIBS="$libs" AC_TRY_LINK_FUNC(ldopen, [gcc_cv_collect2_libs="$libs"; break]) done LIBS="$save_LIBS" test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required']) case $gcc_cv_collect2_libs in "none required") ;; *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;; esac AC_SUBST(COLLECT2_LIBS) # When building Ada code on Alpha, we need exc_resume which is usually in # -lexc. So test for it. save_LIBS="$LIBS" LIBS= AC_SEARCH_LIBS(exc_resume, exc) GNAT_LIBEXC="$LIBS" LIBS="$save_LIBS" AC_SUBST(GNAT_LIBEXC) # See if the stage1 system preprocessor understands the ANSI C # preprocessor stringification operator. (Used by symcat.h.) AC_C_STRINGIZE # Use only if it exists, # doesn't clash with , and declares intmax_t. AC_MSG_CHECKING(for inttypes.h) AC_CACHE_VAL(gcc_cv_header_inttypes_h, [AC_TRY_COMPILE( [#include #include ], [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 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(times clock dup2 kill getrlimit setrlimit atoll atoq \ sysconf strsignal putc_unlocked fputc_unlocked fputs_unlocked \ fwrite_unlocked fprintf_unlocked getrusage nl_langinfo lstat \ scandir alphasort) 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_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]) ;; *-*-*vms*) # Under VMS, vfork works very different than on Unix. The standard test # won't work, and it isn't easily adaptable. It makes more sense to # just force it. ac_cv_func_vfork_works=yes ;; esac AC_FUNC_VFORK AC_FUNC_MMAP_ANYWHERE AC_FUNC_MMAP_FILE AM_ICONV # 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 fwrite_unlocked \ fprintf_unlocked strstr errno \ malloc realloc calloc free basename getopt clock, , ,[ #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 #endif ]) gcc_AC_CHECK_DECLS(times, , ,[ #include "ansidecl.h" #include "system.h" #ifdef HAVE_SYS_TIMES_H #include #endif ]) # More time-related stuff. AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [ AC_TRY_COMPILE([ #include "ansidecl.h" #include "system.h" #ifdef HAVE_SYS_TIMES_H #include #endif ], [struct tms tms;], ac_cv_struct_tms=yes, ac_cv_struct_tms=no)]) if test $ac_cv_struct_tms = yes; then AC_DEFINE(HAVE_STRUCT_TMS, 1, [Define if defines struct tms.]) fi # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE. # revisit after autoconf 2.50. AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [ AC_TRY_COMPILE([ #include "ansidecl.h" #include "system.h" ], [clock_t x;], gcc_cv_type_clock_t=yes, gcc_cv_type_clock_t=no)]) if test $gcc_cv_type_clock_t = yes; then AC_DEFINE(HAVE_CLOCK_T, 1, [Define if defines clock_t.]) fi # 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) target_gtfiles= 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 # Say what files are being used for the output code and MD file. echo "Using \`$srcdir/config/$out_file' for machine-specific logic." echo "Using \`$srcdir/config/$md_file' as machine description file." # If any of the xm_file variables contain nonexistent files, warn # about them and drop them. bx= for x in $build_xm_file; do if test -f $srcdir/config/$x then bx="$bx $x" else AC_MSG_WARN($srcdir/config/$x does not exist.) fi done build_xm_file="$bx" hx= for x in $host_xm_file; do if test -f $srcdir/config/$x then hx="$hx $x" else AC_MSG_WARN($srcdir/config/$x does not exist.) fi done host_xm_file="$hx" tx= for x in $xm_file; do if test -f $srcdir/config/$x then tx="$tx $x" else AC_MSG_WARN($srcdir/config/$x does not exist.) fi done xm_file="$tx" count=a for f in $tm_file; do count=${count}x done if test $count = ax; then echo "Using \`$srcdir/config/$tm_file' as target machine macro file." else echo "Using the following target machine macro files:" for f in $tm_file; do echo " $srcdir/config/$f" done fi 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 # Look for a file containing extra machine modes. if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then extra_modes_file='$(srcdir)'/config/${extra_modes} AC_SUBST(extra_modes_file) AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "$extra_modes", [Define to the name of a file containing a list of extra machine modes for this architecture.]) AC_DEFINE(EXTRA_CC_MODES, 1, [Define if the target architecture needs extra machine modes to represent the results of comparisons.]) 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 FORBUILD=.. 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 saved_CFLAGS="${CFLAGS}" CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \ ${realsrcdir}/configure \ --target=$target_alias --host=$build_alias --build=$build_alias CFLAGS="${saved_CFLAGS}" # 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 FORBUILD=../$build_alias fi AC_SUBST(FORBUILD) 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 </dev/null then cc_set_by_configure="\$(CC)" quoted_cc_set_by_configure="\$(CC)" stage_prefix_set_by_configure="\$(STAGE_PREFIX)" quoted_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\`" quoted_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} \$(srcdir)/$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 ) host_xm_file_list="${host_xm_file_list} $f" ;; defaults.h ) host_xm_file_list="${host_xm_file_list} \$(srcdir)/$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 ) build_xm_file_list="${build_xm_file_list} $f" ;; defaults.h ) host_xm_file_list="${host_xm_file_list} \$(srcdir)/$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 adjust SYSTEM_HEADER_DIR. CROSS= AC_SUBST(CROSS) ALL=all.internal AC_SUBST(ALL) SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR) if test x$host != x$target then CROSS="-DCROSS_COMPILE" ALL=all.cross SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)' case "$host","$target" in i?86-*-*,x86_64-*-* \ | powerpc*-*-*,powerpc64*-*-*) CROSS="$CROSS -DNATIVE_CROSS" ;; esac 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 prevents libgcc2 from containing any code which requires libc # support. 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 adjust things so # that the generator programs are still built with the native compiler. # Also, we cannot run fixincludes or fix-header. # Note that the terminology here is wrong; it should be BUILD_* throughout. # FIXME. # These are the normal (build=host) settings: BUILD_PREFIX= AC_SUBST(BUILD_PREFIX) BUILD_PREFIX_1=ignore- AC_SUBST(BUILD_PREFIX_1) HOST_CC='$(CC)' AC_SUBST(HOST_CC) HOST_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(HOST_CFLAGS) STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC) STMP_FIXPROTO=stmp-fixproto AC_SUBST(STMP_FIXPROTO) # And these apply if build != host. if test x$build != x$host then BUILD_PREFIX=build- BUILD_PREFIX_1=build- HOST_CC='$(CC_FOR_BUILD)' HOST_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD) $(XCFLAGS)' STMP_FIXINC= STMP_FIXPROTO= 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}/config/${cpu_type}/ to every entry in extra_headers. for file in $extra_headers; do extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}" done fi if test x$use_collect2 = xno; then use_collect2= fi # Add a definition of USE_COLLECT2 if system wants one. if test x$use_collect2 != x then host_xm_defines="${host_xm_defines} USE_COLLECT2" xm_defines="${xm_defines} USE_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 and objdump in the build tree, make a link to them. if test -f ../binutils/Makefile; then rm -f nm; $symbolic_link ../binutils/nm-new$host_exeext nm$host_exeext 2>/dev/null rm -f objdump; $symbolic_link ../binutils/objdump$host_exeext objdump$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 rm -f collect-ld; $symbolic_link ../ld/ld-new$host_exeext collect-ld$host_exeext 2>/dev/null 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 gcc_cv_as_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd 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_bfd_srcdir/configure $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]*\)"` gcc_cv_gas_patch_version=`expr "$gcc_cv_gas_version" : "VERSION=[0-9]*\.[0-9]*\.\([0-9]*\)"` changequote([,])dnl fi if test "x$gcc_cv_as" = x; then # 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. if test "x$program_prefix" != xNONE; then gcc_cv_as=${program_prefix}as$host_exeext else gcc_cv_as=`echo as | sed ${program_transform_name}`$host_exeext fi test_dirs="$test_prefix/lib/gcc-lib/$target_alias/$gcc_version \ $test_prefix/lib/gcc-lib/$target_alias \ /usr/lib/gcc/$target_alias/$gcc_version \ /usr/lib/gcc/$target_alias \ $test_prefix/$target_alias/bin/$target_alias/$gcc_version \ $test_prefix/$target_alias/bin" if test x$host = x$target; then test_dirs="$test_dirs \ /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" fi for dir in $test_dirs; do if test -x $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 linker we will be using. AC_MSG_CHECKING(what linker to use) gcc_cv_ld= gcc_cv_gld_major_version= gcc_cv_gld_minor_version= gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd if test -x "$DEFAULT_LINKER"; then gcc_cv_ld="$DEFAULT_LINKER" elif test -x "$LD"; then gcc_cv_ld="$LD" elif test -x ld$host_exeext; then # Build using linker in the current directory. gcc_cv_ld=./ld$host_exeext elif test -f $gcc_cv_ld_gld_srcdir/configure.in -a -f ../ld/Makefile; then # Single tree build which includes ld. for f in $gcc_cv_ld_bfd_srcdir/configure $gcc_cv_ld_gld_srcdir/configure $gcc_cv_ld_gld_srcdir/configure.in $gcc_cv_ld_gld_srcdir/Makefile.in do changequote(,)dnl gcc_cv_gld_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f` changequote([,])dnl if test x$gcc_cv_gld_version != x; then break fi done changequote(,)dnl gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"` gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"` changequote([,])dnl fi if test "x$gcc_cv_ld" = x; then # Search the same directories that the installed compiler will # search. Else we may find the wrong linker and lose. If we # do not find a suitable linker 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 linker, then use whatever # one we can find in the users's path. # user's path. if test "x$program_prefix" != xNONE; then gcc_cv_ld=${program_prefix}ld$host_exeext else gcc_cv_ld=`echo ld | sed ${program_transform_name}`$host_exeext fi test_dirs="$test_prefix/lib/gcc-lib/$target_alias/$gcc_version \ $test_prefix/lib/gcc-lib/$target_alias \ /usr/lib/gcc/$target_alias/$gcc_version \ /usr/lib/gcc/$target_alias \ $test_prefix/$target_alias/bin/$target_alias/$gcc_version \ $test_prefix/$target_alias/bin" if test x$host = x$target; then test_dirs="$test_dirs \ /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" fi for dir in $test_dirs; do if test -x $dir/ld$host_exeext; then gcc_cv_ld=$dir/ld$host_exeext break; fi done fi if test x$gcc_cv_gld_major_version != x -a x$gcc_cv_gld_minor_version != x; then AC_MSG_RESULT("newly built ld") else AC_MSG_RESULT($gcc_cv_ld) 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$program_prefix" != xNONE; then gcc_cv_nm=${program_prefix}nm$host_exeext else gcc_cv_nm=`echo nm | sed ${program_transform_name}`$host_exeext fi AC_MSG_RESULT($gcc_cv_nm) # Figure out what objdump we will be using. AC_MSG_CHECKING(what objdump to use) if test -x objdump$host_exeext; then gcc_cv_objdump=./objdump$host_exeext elif test "x$program_prefix" != xNONE; then gcc_cv_objdump=${program_prefix}objdump$host_exeext else gcc_cv_objdump=`echo objdump | sed ${program_transform_name}`$host_exeext fi AC_MSG_RESULT($gcc_cv_objdump) # 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 < /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" -eq 12 \ -a "$gcc_cv_gas_patch_version" -ge 1 \ -o "$gcc_cv_gas_major_version" -eq 2 \ -a "$gcc_cv_gas_minor_version" -gt 12 \ -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 # GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN. # This is irritatingly difficult to feature test for. Look for # the date string after the version number. ld_ver=`$gcc_cv_ld --version 2>/dev/null | head -1` if echo "$ld_ver" | grep GNU > /dev/null; then changequote(,)dnl ld_vers=`echo $ld_ver | sed -n 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\(\|\.[0-9][0-9]*\)\)\([ ].*\|\)$,\1,p'` ld_date=`echo $ld_ver | sed -n 's,^.*\([2-9][0-9][0-9][0-9]\)[-]*\([01][0-9]\)[-]*\([0-3][0-9]\).*$,\1\2\3,p'` if test 0"$ld_date" -lt 20020404; then if test -n "$ld_date"; then # If there was date string, but was earlier than 2002-04-04, fail gcc_cv_as_hidden="no" elif test -z "$ld_vers"; then # If there was no date string nor ld version number, something is wrong gcc_cv_as_hidden="no" else ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'` ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'` ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'` test -z "$ld_vers_patch" && ld_vers_patch=0 if test "$ld_vers_major" -lt 2; then gcc_cv_as_hidden="no" elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then gcc_cv_as_hidden="no" elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 \ -a "$ld_vers_patch" -eq 0; then gcc_cv_as_hidden="no" fi fi fi changequote([,])dnl fi 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) libgcc_visibility=$gcc_cv_as_hidden case "$target" in mips-sgi-irix6*o32) if test x"$gnu_ld_flag" = x"no"; then # Even if using gas with .hidden support, the resulting object files # cannot be linked with the IRIX 6 O32 linker. libgcc_visibility=no fi ;; esac AC_SUBST(libgcc_visibility) 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 < /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 changequote(,)dnl as_ver=`echo $as_ver | sed -e 's/GNU assembler \([0-9.][0-9.]*\).*/\1/'` as_major=`echo $as_ver | sed 's/\..*//'` 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) AC_MSG_CHECKING(assembler eh_frame optimization) gcc_cv_as_eh_frame=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 12 -o "$gcc_cv_gas_major_version" -gt 2 && grep 'obj_format = elf' ../gas/Makefile > /dev/null; then gcc_cv_as_eh_frame="yes" fi elif test x$gcc_cv_as != x; then # Check if this is GAS. as_ver=`$gcc_cv_as --version < /dev/null 2> /dev/null | head -1` rm -f a.out 2> /dev/null if echo "$as_ver" | grep GNU > /dev/null; then # Versions up to and including 2.11.0 may mis-optimize # .eh_frame data. Try something. cat > conftest.s < conftest.lit < conftest.big < /dev/null 2>&1 \ && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \ | tail -3 > conftest.got \ && { cmp conftest.lit conftest.got > /dev/null 2>&1 \ || cmp conftest.big conftest.got > /dev/null 2>&1; } then gcc_cv_as_eh_frame="yes" else gcc_cv_as_eh_frame="bad" if $gcc_cv_as -o conftest.o --traditional-format /dev/null; then AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1, [Define if your assembler mis-optimizes .eh_frame data.]) fi fi fi rm -f conftest.* fi AC_MSG_RESULT($gcc_cv_as_eh_frame) AC_MSG_CHECKING(assembler section merging support) gcc_cv_as_shf_merge=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 12 -o "$gcc_cv_gas_major_version" -gt 2 && grep 'obj_format = elf' ../gas/Makefile > /dev/null; then gcc_cv_as_shf_merge=yes fi elif test x$gcc_cv_as != x; then # Check if we support SHF_MERGE sections echo '.section .rodata.str, "aMS", @progbits, 1' > conftest.s if $gcc_cv_as --fatal-warnings -o conftest.o conftest.s > /dev/null 2>&1; then gcc_cv_as_shf_merge=yes fi rm -f conftest.s conftest.o fi if test x"$gcc_cv_as_shf_merge" = xyes; then AC_DEFINE(HAVE_GAS_SHF_MERGE, 1, [Define if your assembler supports marking sections with SHF_MERGE flag.]) fi AC_MSG_RESULT($gcc_cv_as_shf_merge) AC_MSG_CHECKING(assembler thread-local storage support) gcc_cv_as_tls=no conftest_s= tls_first_major= tls_first_minor= case "$target" in changequote(,)dnl alpha*-*-*) conftest_s=' .section ".tdata","awT",@progbits foo: .long 25 .text ldq $27,__tls_get_addr($29) !literal!1 lda $16,foo($29) !tlsgd!1 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1 ldq $27,__tls_get_addr($29) !literal!2 lda $16,foo($29) !tlsldm!2 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2 ldq $1,foo($29) !gotdtprel ldah $2,foo($29) !dtprelhi lda $3,foo($2) !dtprello lda $4,foo($29) !dtprel ldq $1,foo($29) !gottprel ldah $2,foo($29) !tprelhi lda $3,foo($2) !tprello lda $4,foo($29) !tprel' tls_first_major=2 tls_first_minor=13 ;; i[34567]86-*-*) changequote([,])dnl conftest_s=' .section ".tdata","awT",@progbits foo: .long 25 .text movl %gs:0, %eax leal foo@TLSGD(,%ebx,1), %eax leal foo@TLSLDM(%ebx), %eax leal foo@DTPOFF(%eax), %edx movl foo@GOTTPOFF(%ebx), %eax subl foo@GOTTPOFF(%ebx), %eax addl foo@GOTNTPOFF(%ebx), %eax movl foo@INDNTPOFF, %eax movl $foo@TPOFF, %eax subl $foo@TPOFF, %eax leal foo@NTPOFF(%ecx), %eax' tls_first_major=2 tls_first_minor=14 ;; x86_64-*-*) conftest_s=' .section ".tdata","awT",@progbits foo: .long 25 .text movq %fs:0, %rax leaq foo@TLSGD(%rip), %rdi leaq foo@TLSLD(%rip), %rdi leaq foo@DTPOFF(%rax), %rdx movq foo@GOTTPOFF(%rip), %rax movq $foo@TPOFF, %rax' tls_first_major=2 tls_first_minor=14 ;; ia64-*-*) conftest_s=' .section ".tdata","awT",@progbits foo: data8 25 .text addl r16 = @ltoff(@dtpmod(foo#)), gp addl r17 = @ltoff(@dtprel(foo#)), gp addl r18 = @ltoff(@tprel(foo#)), gp addl r19 = @dtprel(foo#), gp adds r21 = @dtprel(foo#), r13 movl r23 = @dtprel(foo#) addl r20 = @tprel(foo#), gp adds r22 = @tprel(foo#), r13 movl r24 = @tprel(foo#)' tls_first_major=2 tls_first_minor=13 ;; esac if test -z "$tls_first_major"; then : elif 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 "$tls_first_major" \ -a "$gcc_cv_gas_minor_version" -ge "$tls_first_minor" \ -o "$gcc_cv_gas_major_version" -gt "$tls_first_major"; then gcc_cv_as_tls=yes fi elif test x$gcc_cv_as != x; then echo "$conftest_s" > conftest.s if $gcc_cv_as --fatal-warnings -o conftest.o conftest.s > /dev/null 2>&1 then gcc_cv_as_tls=yes fi rm -f conftest.s conftest.o fi if test "$gcc_cv_as_tls" = yes; then AC_DEFINE(HAVE_AS_TLS, 1, [Define if your assembler supports thread-local storage.]) fi AC_MSG_RESULT($gcc_cv_as_tls) case "$target" in # All TARGET_ABI_OSF targets. alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*) AC_CACHE_CHECK([assembler supports explicit relocations], gcc_cv_as_explicit_relocs, [ gcc_cv_as_explicit_relocs=unknown 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 12 \ -o "$gcc_cv_gas_major_version" -gt 2; then gcc_cv_as_explicit_relocs=yes fi elif test x$gcc_cv_as != x; then cat > conftest.s << 'EOF' .set nomacro .text extbl $3, $2, $3 !lituse_bytoff!1 ldq $2, a($29) !literal!1 ldq $4, b($29) !literal!2 ldq_u $3, 0($2) !lituse_base!1 ldq $27, f($29) !literal!5 jsr $26, ($27), f !lituse_jsr!5 ldah $29, 0($26) !gpdisp!3 lda $0, c($29) !gprel ldah $1, d($29) !gprelhigh lda $1, d($1) !gprellow lda $29, 0($29) !gpdisp!3 EOF if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then gcc_cv_as_explicit_relocs=yes else gcc_cv_as_explicit_relocs=no fi rm -f conftest.s conftest.o fi ]) if test "x$gcc_cv_as_explicit_relocs" = xyes; then AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1, [Define if your assembler supports explicit relocations.]) fi ;; 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 AC_CACHE_CHECK([assembler and linker support unaligned pc related relocs], gcc_cv_as_sparc_ua_pcrel, [ gcc_cv_as_sparc_ua_pcrel=unknown if test x$gcc_cv_as != x -a x$gcc_cv_ld != x; then gcc_cv_as_sparc_ua_pcrel=no echo ".text; foo: nop; .data; .align 4; .byte 0; .uaword %r_disp32(foo)" > conftest.s if $gcc_cv_as -K PIC -o conftest.o conftest.s > /dev/null 2>&1 \ && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then gcc_cv_as_sparc_ua_pcrel=yes fi rm -f conftest.s conftest.o conftest fi ]) if test "x$gcc_cv_as_sparc_ua_pcrel" = xyes; then AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1, [Define if your assembler and linker support unaligned PC relative relocs.]) fi AC_CACHE_CHECK([assembler and linker support unaligned pc related relocs against hidden symbols], gcc_cv_as_sparc_ua_pcrel_hidden, [ if test "x$gcc_cv_as_sparc_ua_pcrel" = xyes; then gcc_cv_as_sparc_ua_pcrel_hidden=unknown if test x$gcc_cv_objdump != x; then gcc_cv_as_sparc_ua_pcrel_hidden=no echo ".data; .align 4; .byte 0x31; .uaword %r_disp32(foo)" > conftest.s echo ".byte 0x32, 0x33, 0x34; .global foo; .hidden foo" >> conftest.s echo "foo: .skip 4" >> conftest.s if $gcc_cv_as -K PIC -o conftest.o conftest.s > /dev/null 2>&1 \ && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \ && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \ | grep ' 31000000 07323334' > /dev/null 2>&1; then if $gcc_cv_objdump -R conftest 2> /dev/null \ | grep 'DISP32' > /dev/null 2>&1; then : else gcc_cv_as_sparc_ua_pcrel_hidden=yes fi fi fi rm -f conftest.s conftest.o conftest else gcc_cv_as_sparc_ua_pcrel_hidden="$gcc_cv_as_sparc_ua_pcrel" fi ]) if test "x$gcc_cv_as_sparc_ua_pcrel_hidden" = xyes; then AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1, [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.]) fi 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 -xarch=v9 -o conftest.o conftest.s \ > /dev/null 2>&1 && $gcc_cv_as -xarch=v9 -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 ;; changequote(,)dnl i[34567]86-*-* | x86_64-*-*) 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) AC_MSG_CHECKING(assembler GOTOFF in data directives) gcc_cv_as_gotoff_in_data=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; then gcc_cv_as_gotoff_in_data=yes fi elif test x$gcc_cv_as != x; then cat > conftest.s < /dev/null 2>&1; then gcc_cv_as_gotoff_in_data=yes fi fi AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA, [`if test $gcc_cv_as_gotoff_in_data = yes; then echo 1; else echo 0; fi`], [Define true if the assembler supports '.long foo@GOTOFF'.]) AC_MSG_RESULT($gcc_cv_as_gotoff_in_data) ;; 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*-*-* | m68*-*-* | x86_64*-*-* | hppa*-*-*) 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 indices 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 indices exactly as given.]) fi AC_MSG_RESULT($gcc_cv_as_dwarf2_debug_line) AC_MSG_CHECKING(assembler --gdwarf2 support) gcc_cv_as_gdwarf2_flag=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 \ && test x"$insn" != x ; then gcc_cv_as_gdwarf2_flag="yes" fi elif test x$gcc_cv_as != x -a x"$insn" != x ; then echo '' > conftest.s # ??? This fails with non-gnu grep. if $gcc_cv_as --gdwarf2 -o conftest.o conftest.s > /dev/null 2>&1 then gcc_cv_as_gdwarf2_flag="yes" fi rm -f conftest.s conftest.o fi if test x"$gcc_cv_as_gdwarf2_flag" = xyes; then AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1, [Define if your assembler supports the --gdwarf2 option.]) fi AC_MSG_RESULT($gcc_cv_as_gdwarf2_flag) AC_MSG_CHECKING(assembler --gstabs support) gcc_cv_as_gstabs_flag=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 \ && test x"$insn" != x ; then gcc_cv_as_gstabs_flag="yes" fi elif test x$gcc_cv_as != x -a x"$insn" != x ; then echo '' > conftest.s # ??? This fails with non-gnu grep. if $gcc_cv_as --gstabs -o conftest.o conftest.s > /dev/null 2>&1 ; then gcc_cv_as_gstabs_flag="yes" fi rm -f conftest.s conftest.o fi if test x"$gcc_cv_as_gstabs_flag" = xyes; then AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1, [Define if your assembler supports the --gstabs option.]) fi AC_MSG_RESULT($gcc_cv_as_gstabs_flag) AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support) gcc_cv_ld_eh_frame_hdr=no if test x$gcc_cv_gld_major_version != x -a x$gcc_cv_gld_minor_version != x; then if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 12 -o "$gcc_cv_gld_major_version" -gt 2 && grep 'EMUL = elf' ../ld/Makefile > /dev/null; then gcc_cv_ld_eh_frame_hdr=yes fi elif test x$gcc_cv_ld != x; then # Check if linker supports --eh-frame-hdr option if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then gcc_cv_ld_eh_frame_hdr=yes fi fi if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1, [Define if your linker supports --eh-frame-hdr option.]) fi AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr) # Miscellaneous target-specific checks. case "$target" in mips*-*-*) AC_MSG_CHECKING(whether libgloss uses STARTUP directives consistently) gcc_cv_mips_libgloss_startup=no gcc_cv_libgloss_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/libgloss 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 for f in $gcc_cv_libgloss_srcdir/mips/idt.ld $test_prefix/$target_alias/lib/idt.ld do if grep '^STARTUP' $f > /dev/null 2>&1; then gcc_cv_mips_libgloss_startup=yes break fi done if test x"$gcc_cv_mips_libgloss_startup" = xyes; then AC_DEFINE(HAVE_MIPS_LIBGLOSS_STARTUP_DIRECTIVES, 1, [Define if your MIPS libgloss linker scripts consistently include STARTUP directives.]) fi AC_MSG_RESULT($gcc_cv_mips_libgloss_startup) ;; esac if test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" ; then AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include") fi # 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. # NB: embedded tabs in this IF block -- do not untabify if test x"${enable_languages+set}" != xset; then if test x"${LANGUAGES+set}" = xset; then enable_languages="${LANGUAGES}" AC_MSG_WARN([setting LANGUAGES is deprecated, use --enable-languages instead]) else enable_languages=all fi else if test x"${enable_languages}" = x \ || test x"${enable_languages}" = xyes; then AC_MSG_ERROR([--enable-languages needs at least one language argument]) fi fi enable_languages=`echo "${enable_languages}" | sed -e 's/[[ ,]][[ ,]]*/,/g' -e 's/,$//'` # 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 expected_languages=`echo ,${enable_languages}, | sed -e 's:,: :g' -e 's: *: :g' -e 's: *: :g' -e 's:^ ::' -e 's: $::'` found_languages= 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 found_languages="${found_languages} ${lang_alias}" 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 missing_languages= for expected_language in ${expected_languages} .. do if test "${expected_language}" != ..; then missing_language="${expected_language}" if test "${expected_language}" = "c" \ || test "${expected_language}" = "all"; then missing_language= fi for found_language in ${found_languages} .. do if test "${found_language}" != ..; then if test "${expected_language}" = "${found_language}"; then missing_language= fi fi done if test "x${missing_language}" != x; then missing_languages="${missing_languages} ${missing_language}" fi fi done if test "x$missing_languages" != x; then AC_MSG_ERROR([ The following requested languages were not found:${missing_languages} The following languages were available: c${found_languages}]) fi # 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) 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.])]) # Use libunwind based exception handling. AC_ARG_ENABLE(libunwind-exceptions, [ --enable-libunwind-exceptions force use libunwind for exceptions], use_libunwind_exceptions=$enableval, use_libunwind_exceptions=no) if test x"$use_libunwind_exceptions" = xyes; then AC_DEFINE(USE_LIBUNWIND_EXCEPTIONS, 1, [Define if gcc should use -lunwind.]) fi # 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= for subdir in . $subdirs do if test -f $srcdir/$subdir/lang-specs.h; then lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h" fi if test -f $srcdir/$subdir/lang-options.h; then lang_options_files="$lang_options_files $srcdir/$subdir/lang-options.h" fi if test -f $srcdir/$subdir/$subdir-tree.def; then 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_outputs='Makefile intl/Makefile fixinc/Makefile gccbug mklibgcc mkheaders' # List of language makefile fragments. all_lang_makefiles= # Files for gengtype all_gtfiles="$target_gtfiles" # Files for gengtype with language all_gtfiles_files_langs= all_gtfiles_files_files= # 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= outputs= gtfiles= . ${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_outputs="$all_outputs $outputs" all_gtfiles="$all_gtfiles $gtfiles" for f in .. $gtfiles do if test $f != ".." then all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} " all_gtfiles_files_files="$all_gtfiles_files_files ${f} " fi done fi done # Pick up gtfiles for c gtfiles= s="c" . ${srcdir}/c-config-lang.in all_gtfiles="$all_gtfiles $gtfiles" for f in .. $gtfiles do if test $f != ".." then all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} " all_gtfiles_files_files="$all_gtfiles_files_files ${f} " 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 generated-manpages \ 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 occurrence of / 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 should 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) objdir=`${PWDCMD-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(srcdir) AC_SUBST(all_boot_languages) AC_SUBST(all_compilers) AC_SUBST(all_gtfiles) AC_SUBST(all_gtfiles_files_langs) AC_SUBST(all_gtfiles_files_files) AC_SUBST(all_lang_makefiles) AC_SUBST(all_languages) 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_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(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(quoted_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_defines) AC_SUBST(tm_p_file_list) AC_SUBST(tm_p_file) AC_SUBST(xm_file) AC_SUBST(xm_defines) AC_SUBST(target_alias) 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_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} fixinc ; do if test $d != ..; then STARTDIR=`${PWDCMD-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 ], [subdirs='$subdirs' symbolic_link='$symbolic_link' ])