gcc/configure.in

   1 # configure.in for GCC
   2 # Process this file with autoconf to generate a configuration script.
   3
   4 # Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003
   5 # Free Software Foundation, Inc.
   6
   7 #This file is part of GCC.
   8
   9 #GCC is free software; you can redistribute it and/or modify it under
  10 #the terms of the GNU General Public License as published by the Free
  11 #Software Foundation; either version 2, or (at your option) any later
  12 #version.
  13
  14 #GCC is distributed in the hope that it will be useful, but WITHOUT
  15 #ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 #FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 #for more details.
  18
  19 #You should have received a copy of the GNU General Public License
  20 #along with GCC; see the file COPYING.  If not, write to the Free
  21 #Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  22 #02111-1307, USA.
  23
  24 # Initialization and defaults
  25 AC_PREREQ(2.13)
  26 AC_INIT(tree.c)
  27 AC_CONFIG_HEADER(auto-host.h:config.in)
  28
  29 remove=rm
  30 hard_link=ln
  31 symbolic_link='ln -s'
  32 copy=cp
  33
  34 # Check for bogus environment variables.
  35 # Test if LIBRARY_PATH contains the notation for the current directory
  36 # since this would lead to problems installing/building glibc.
  37 # LIBRARY_PATH contains the current directory if one of the following
  38 # is true:
  39 # - one of the terminals (":" and ";") is the first or last sign
  40 # - two terminals occur directly after each other
  41 # - the path contains an element with a dot in it
  42 AC_MSG_CHECKING(LIBRARY_PATH variable)
  43 changequote(,)dnl
  44 case ${LIBRARY_PATH} in
  45   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
  46     library_path_setting="contains current directory"
  47     ;;
  48   *)
  49     library_path_setting="ok"
  50     ;;
  51 esac
  52 changequote([,])dnl
  53 AC_MSG_RESULT($library_path_setting)
  54 if test "$library_path_setting" != "ok"; then
  55 AC_MSG_ERROR([
  56 *** LIBRARY_PATH shouldn't contain the current directory when
  57 *** building gcc. Please change the environment variable
  58 *** and run configure again.])
  59 fi
  60
  61 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
  62 # since this would lead to problems installing/building glibc.
  63 # GCC_EXEC_PREFIX contains the current directory if one of the following
  64 # is true:
  65 # - one of the terminals (":" and ";") is the first or last sign
  66 # - two terminals occur directly after each other
  67 # - the path contains an element with a dot in it
  68 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
  69 changequote(,)dnl
  70 case ${GCC_EXEC_PREFIX} in
  71   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
  72     gcc_exec_prefix_setting="contains current directory"
  73     ;;
  74   *)
  75     gcc_exec_prefix_setting="ok"
  76     ;;
  77 esac
  78 changequote([,])dnl
  79 AC_MSG_RESULT($gcc_exec_prefix_setting)
  80 if test "$gcc_exec_prefix_setting" != "ok"; then
  81 AC_MSG_ERROR([
  82 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
  83 *** building gcc. Please change the environment variable
  84 *** and run configure again.])
  85 fi
  86
  87 # Check for additional parameters
  88
  89 # With GNU ld
  90 AC_ARG_WITH(gnu-ld,
  91 [  --with-gnu-ld           arrange to work with GNU ld.],
  92 gnu_ld_flag="$with_gnu_ld",
  93 gnu_ld_flag=no)
  94
  95 # With pre-defined ld
  96 AC_ARG_WITH(ld,
  97 [  --with-ld               arrange to use the specified ld (full pathname)],
  98 DEFAULT_LINKER="$with_ld")
  99 if test x"${DEFAULT_LINKER+set}" = x"set"; then
 100   if test ! -x "$DEFAULT_LINKER"; then
 101     AC_MSG_WARN([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
 102   elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
 103     gnu_ld_flag=yes
 104   fi
 105   AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
 106         [Define to enable the use of a default linker.])
 107 fi
 108
 109 # With GNU as
 110 AC_ARG_WITH(gnu-as,
 111 [  --with-gnu-as           arrange to work with GNU as],
 112 gas_flag="$with_gnu_as",
 113 gas_flag=no)
 114
 115 AC_ARG_WITH(as,
 116 [  --with-as               arrange to use the specified as (full pathname)],
 117 DEFAULT_ASSEMBLER="$with_as")
 118 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
 119   if test ! -x "$DEFAULT_ASSEMBLER"; then
 120     AC_MSG_WARN([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
 121   elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
 122     gas_flag=yes
 123   fi
 124   AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
 125         [Define to enable the use of a default assembler.])
 126 fi
 127
 128 # With stabs
 129 AC_ARG_WITH(stabs,
 130 [  --with-stabs            arrange to use stabs instead of host debug format],
 131 stabs="$with_stabs",
 132 stabs=no)
 133
 134 # With ELF
 135 AC_ARG_WITH(elf,
 136 [  --with-elf              arrange to use ELF instead of host debug format],
 137 elf="$with_elf",
 138 elf=no)
 139
 140 # Specify the local prefix
 141 local_prefix=
 142 AC_ARG_WITH(local-prefix,
 143 [  --with-local-prefix=DIR specifies directory to put local include],
 144 [case "${withval}" in
 145 yes)    AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
 146 no)     ;;
 147 *)      local_prefix=$with_local_prefix ;;
 148 esac])
 149
 150 # Default local prefix if it is empty
 151 if test x$local_prefix = x; then
 152         local_prefix=/usr/local
 153 fi
 154
 155 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
 156 # passed in by the toplevel make and thus we'd get different behavior
 157 # depending on where we built the sources.
 158 gcc_gxx_include_dir=
 159 # Specify the g++ header file directory
 160 AC_ARG_WITH(gxx-include-dir,
 161 [  --with-gxx-include-dir=DIR
 162                           specifies directory to put g++ header files],
 163 [case "${withval}" in
 164 yes)    AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
 165 no)     ;;
 166 *)      gcc_gxx_include_dir=$with_gxx_include_dir ;;
 167 esac])
 168
 169 if test x${gcc_gxx_include_dir} = x; then
 170   if test x${enable_version_specific_runtime_libs} = xyes; then
 171     gcc_gxx_include_dir='${libsubdir}/include/c++'
 172   else
 173     topsrcdir=${srcdir}/.. . ${srcdir}/../config.if
 174 changequote(<<, >>)dnl
 175     gcc_gxx_include_dir="\$(libsubdir)/\$(unlibsubdir)/..\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/[^/]*|/..|g'\`/include/"${libstdcxx_incdir}
 176 changequote([, ])dnl
 177   fi
 178 fi
 179
 180 # Determine the host, build, and target systems
 181 AC_CANONICAL_SYSTEM
 182
 183 # Set program_transform_name
 184 AC_ARG_PROGRAM
 185
 186 # Find the native compiler
 187 AC_PROG_CC
 188 AC_PROG_CC_C_O
 189 # autoconf is lame and doesn't give us any substitution variable for this.
 190 if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = no"; then
 191   NO_MINUS_C_MINUS_O=yes
 192 else
 193   OUTPUT_OPTION='-o $@'
 194 fi
 195 AC_SUBST(NO_MINUS_C_MINUS_O)
 196 AC_SUBST(OUTPUT_OPTION)
 197
 198 # See if GNAT has been installed
 199 gcc_AC_PROG_GNAT
 200
 201 AC_CACHE_CHECK(whether ${CC-cc} accepts -Wno-long-long,
 202 ac_cv_prog_cc_no_long_long,
 203 [save_CFLAGS="$CFLAGS"
 204 CFLAGS="-Wno-long-long"
 205 AC_TRY_COMPILE(,,ac_cv_prog_cc_no_long_long=yes,
 206                ac_cv_prog_cc_no_long_long=no)
 207 CFLAGS="$save_CFLAGS"])
 208
 209 if test x$have_gnat != xno ; then
 210 AC_CACHE_CHECK(whether ${ADAC} accepts -Wno-long-long,
 211 ac_cv_prog_adac_no_long_long,
 212 [cat >conftest.adb <<EOF
 213 procedure conftest is begin null; end conftest;
 214 EOF
 215 if $ADAC -Wno-long-long -c conftest.adb 1>&5 2>&5 ; then
 216   ac_cv_prog_adac_no_long_long=yes
 217 else
 218   ac_cv_prog_adac_no_long_long=no
 219 fi
 220 rm -f conftest*])
 221 else
 222   ac_cv_prog_adac_no_long_long=yes
 223 fi
 224
 225 strict1_warn=
 226 if test $ac_cv_prog_cc_no_long_long = yes && \
 227     test $ac_cv_prog_adac_no_long_long = yes ; then
 228   strict1_warn="-pedantic -Wno-long-long"
 229 fi
 230 AC_SUBST(strict1_warn)
 231
 232 AC_PROG_CPP
 233 AC_C_INLINE
 234 gcc_AC_C_VOLATILE
 235
 236 gcc_AC_C_LONG_DOUBLE
 237 gcc_AC_C_LONG_LONG
 238 gcc_AC_C__BOOL
 239
 240 # sizeof(char) is 1 by definition.
 241 AC_COMPILE_CHECK_SIZEOF(short)
 242 AC_COMPILE_CHECK_SIZEOF(int)
 243 AC_COMPILE_CHECK_SIZEOF(long)
 244 if test $ac_cv_c_long_long = yes; then
 245   AC_COMPILE_CHECK_SIZEOF(long long)
 246 fi
 247 if test $ac_cv_c___int64 = yes; then
 248   AC_COMPILE_CHECK_SIZEOF(__int64)
 249 fi
 250
 251 gcc_AC_C_CHARSET
 252
 253 # If the native compiler is GCC, we can enable warnings even in stage1.
 254 # That's useful for people building cross-compilers, or just running a
 255 # quick `make'.
 256 warn_cflags=
 257 if test "x$GCC" = "xyes"; then
 258   warn_cflags='$(GCC_WARN_CFLAGS)'
 259 fi
 260 AC_SUBST(warn_cflags)
 261
 262 # Determine whether or not multilibs are enabled.
 263 AC_ARG_ENABLE(multilib,
 264 [  --enable-multilib       enable library support for multiple ABIs],
 265 [], [enable_multilib=yes])
 266 AC_SUBST(enable_multilib)
 267
 268 # Enable expensive internal checks
 269 AC_ARG_ENABLE(checking,
 270 [  --enable-checking[=LIST]
 271                           enable expensive run-time checks.  With LIST,
 272                           enable only specific categories of checks.
 273                           Categories are: misc,tree,rtl,rtlflag,gc,gcac;
 274                           default is misc,tree,gc,rtlflag],
 275 [ac_checking=
 276 ac_tree_checking=
 277 ac_rtl_checking=
 278 ac_rtlflag_checking=
 279 ac_gc_checking=
 280 ac_gc_always_collect=
 281 case "${enableval}" in
 282 yes)    ac_checking=1 ; ac_tree_checking=1 ; ac_gc_checking=1 ;
 283         ac_rtlflag_checking=1 ;;
 284 no)     ;;
 285 *)      IFS="${IFS=     }"; ac_save_IFS="$IFS"; IFS="$IFS,"
 286         set fnord $enableval; shift
 287         IFS="$ac_save_IFS"
 288         for check
 289         do
 290                 case $check in
 291                 misc)   ac_checking=1 ;;
 292                 tree)   ac_tree_checking=1 ;;
 293                 rtlflag)        ac_rtlflag_checking=1 ;;
 294                 rtl)    ac_rtl_checking=1 ;;
 295                 gc)     ac_gc_checking=1 ;;
 296                 gcac)   ac_gc_always_collect=1 ;;
 297                 valgrind)       ac_checking_valgrind=1 ;;
 298                 *)      AC_MSG_ERROR(unknown check category $check) ;;
 299                 esac
 300         done
 301         ;;
 302 esac
 303 ],
 304 # Enable some checks by default for development versions of GCC
 305 [ac_checking=1; ac_tree_checking=1; ac_gc_checking=1; ac_rtlflag_checking=1;])
 306 nocommon_flag=""
 307 if test x$ac_checking != x ; then
 308   AC_DEFINE(ENABLE_CHECKING, 1,
 309 [Define if you want more run-time sanity checks.  This one gets a grab
 310    bag of miscellaneous but relatively cheap checks.])
 311   nocommon_flag=-fno-common
 312 fi
 313 AC_SUBST(nocommon_flag)
 314 if test x$ac_tree_checking != x ; then
 315   AC_DEFINE(ENABLE_TREE_CHECKING, 1,
 316 [Define if you want all operations on trees (the basic data
 317    structure of the front ends) to be checked for dynamic type safety
 318    at runtime.  This is moderately expensive.])
 319 fi
 320 if test x$ac_rtl_checking != x ; then
 321   AC_DEFINE(ENABLE_RTL_CHECKING, 1,
 322 [Define if you want all operations on RTL (the basic data structure
 323    of the optimizer and back end) to be checked for dynamic type safety
 324    at runtime.  This is quite expensive.])
 325 fi
 326 if test x$ac_rtlflag_checking != x ; then
 327   AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
 328 [Define if you want RTL flag accesses to be checked against the RTL
 329    codes that are supported for each access macro.  This is relatively
 330    cheap.])
 331 fi
 332 if test x$ac_gc_checking != x ; then
 333   AC_DEFINE(ENABLE_GC_CHECKING, 1,
 334 [Define if you want the garbage collector to do object poisoning and
 335    other memory allocation checks.  This is quite expensive.])
 336 fi
 337 if test x$ac_gc_always_collect != x ; then
 338   AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
 339 [Define if you want the garbage collector to operate in maximally
 340    paranoid mode, validating the entire heap and collecting garbage at
 341    every opportunity.  This is extremely expensive.])
 342 fi
 343 valgrind_path_defines=
 344 valgrind_command=
 345 if test x$ac_checking_valgrind != x ; then
 346   # It is certainly possible that there's valgrind but no valgrind.h.
 347   # GCC relies on making annotations so we must have both.
 348   AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
 349   AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
 350         [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
 351   if test "x$valgrind_path" = "x" || test $have_valgrind_h = no; then
 352         AC_MSG_ERROR([*** Can't find both valgrind and valgrind.h])
 353   fi
 354   valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
 355   valgrind_command="$valgrind_path -q"
 356   AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
 357 [Define if you want to run subprograms and generated programs
 358    through valgrind (a memory checker).  This is extremely expensive.])
 359 fi
 360 AC_SUBST(valgrind_path_defines)
 361 AC_SUBST(valgrind_command)
 362
 363 # Enable code coverage collection
 364 AC_ARG_ENABLE(coverage,
 365 [  --enable-coverage[=LEVEL]
 366                           enable compiler\'s code coverage collection.
 367                           Use to measure compiler performance and locate
 368                           unused parts of the compiler. With LEVEL, specify
 369                           optimization. Values are opt, noopt,
 370                           default is noopt],
 371 [case "${enableval}" in
 372 yes|noopt)
 373         coverage_flags="-fprofile-arcs -ftest-coverage -O0 -DSELF_COVERAGE=1"
 374         ;;
 375 opt)
 376         coverage_flags="-fprofile-arcs -ftest-coverage -O2 -DSELF_COVERAGE=2"
 377         ;;
 378 *)
 379         AC_MSG_ERROR(unknown coverage setting $enableval)
 380         ;;
 381 esac],
 382 [coverage_flags=""])
 383 AC_SUBST(coverage_flags)
 384
 385 AC_ARG_WITH(cpp_install_dir,
 386 [  --with-cpp-install-dir=DIR
 387                           install the user visible C preprocessor in DIR
 388                           (relative to PREFIX) as well as PREFIX/bin],
 389 [if test x$withval = xyes; then
 390   AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
 391 elif test x$withval != xno; then
 392   cpp_install_dir=$withval
 393 fi])
 394
 395 # Enable __cxa_atexit for C++.
 396 AC_ARG_ENABLE(__cxa_atexit,
 397 [  --enable-__cxa_atexit   enable __cxa_atexit for C++],
 398 [], [])
 399 if test x$enable___cxa_atexit = xyes; then
 400   AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 1,
 401   [Define if you want to use __cxa_atexit, rather than atexit, to
 402    register C++ destructors for local statics and global objects.
 403    This is essential for fully standards-compliant handling of
 404    destructors, but requires __cxa_atexit in libc.])
 405 fi
 406
 407 # Enable Multibyte Characters for C/C++
 408 AC_ARG_ENABLE(c-mbchar,
 409 [  --enable-c-mbchar       enable multibyte characters for C and C++],
 410 if test x$enable_c_mbchar != xno; then
 411   AC_DEFINE(MULTIBYTE_CHARS, 1,
 412   [Define if you want the C and C++ compilers to support multibyte
 413    character sets for source code.])
 414 fi)
 415
 416 # Enable threads
 417 # Pass with no value to take the default
 418 # Pass with a value to specify a thread package
 419 AC_ARG_ENABLE(threads,
 420 [  --enable-threads        enable thread usage for target GCC
 421   --enable-threads=LIB    use LIB thread package for target GCC],,
 422 enable_threads='')
 423
 424 enable_threads_flag=$enable_threads
 425 # Check if a valid thread package
 426 case x${enable_threads_flag} in
 427         x | xno)
 428                 # No threads
 429                 target_thread_file='single'
 430                 ;;
 431         xyes)
 432                 # default
 433                 target_thread_file=''
 434                 ;;
 435         xdecosf1 | xirix | xmach | xos2 | xposix | xpthreads | xsingle | \
 436         xsolaris | xwin32 | xdce | xrtems| xvxworks | xaix)
 437                 target_thread_file=$enable_threads_flag
 438                 ;;
 439         *)
 440                 echo "$enable_threads is an unknown thread package" 1>&2
 441                 exit 1
 442                 ;;
 443 esac
 444
 445 AC_ARG_ENABLE(objc-gc,
 446 [  --enable-objc-gc       enable the use of Boehm's garbage collector with
 447                           the GNU Objective-C runtime],
 448 if test x$enable_objc_gc = xno; then
 449         objc_boehm_gc=''
 450 else
 451         objc_boehm_gc=1
 452 fi,
 453 objc_boehm_gc='')
 454
 455 AC_ARG_WITH(dwarf2,
 456 [  --with-dwarf2           force the default debug format to be DWARF 2],
 457 dwarf2="$with_dwarf2",
 458 dwarf2=no)
 459
 460 AC_ARG_ENABLE(shared,
 461 [  --disable-shared        don't provide a shared libgcc],
 462 [
 463   case $enable_shared in
 464   yes | no) ;;
 465   *)
 466     enable_shared=no
 467     IFS="${IFS=         }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
 468     for pkg in $enableval; do
 469       if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
 470         enable_shared=yes
 471       fi
 472     done
 473     IFS="$ac_save_ifs"
 474     ;;
 475   esac
 476 ], [enable_shared=yes])
 477 AC_SUBST(enable_shared)
 478
 479 AC_ARG_WITH(sysroot,
 480 [  --with-sysroot[=DIR] Search for usr/lib, usr/include, et al, within DIR.],
 481 [
 482  case ${with_sysroot} in
 483  yes) TARGET_SYSTEM_ROOT='${gcc_tooldir}/sys-root' ;;
 484  *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
 485  esac
 486
 487  TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
 488  CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR)'
 489 ], [
 490  TARGET_SYSTEM_ROOT=
 491  TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=0'
 492  CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
 493 ])
 494 AC_SUBST(TARGET_SYSTEM_ROOT)
 495 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
 496 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
 497
 498 # Stage specific cflags for build.
 499 stage1_cflags=
 500 case $build in
 501 vax-*-*)
 502   if test x$GCC = xyes
 503   then
 504     stage1_cflags="-Wa,-J"
 505   else
 506     stage1_cflags="-J"
 507   fi
 508   ;;
 509 powerpc-*-darwin*)
 510   # The spiffy cpp-precomp chokes on some legitimate constructs in GCC
 511   # sources; use -no-cpp-precomp to get to GNU cpp.
 512   # Apple's GCC has bugs in designated initializer handling, so disable
 513   # that too.
 514   stage1_cflags="-no-cpp-precomp -DHAVE_DESIGNATED_INITIALIZERS=0"
 515   ;;
 516 esac
 517 AC_SUBST(stage1_cflags)
 518
 519 AC_PROG_MAKE_SET
 520
 521 AC_MSG_CHECKING([whether a default assembler was specified])
 522 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
 523     if test x"$gas_flag" = x"no"; then
 524         AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
 525     else
 526         AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
 527     fi
 528 else
 529     AC_MSG_RESULT(no)
 530 fi
 531
 532 AC_MSG_CHECKING([whether a default linker was specified])
 533 if test x"${DEFAULT_LINKER+set}" = x"set"; then
 534     if test x"$gnu_ld_flag" = x"no"; then
 535         AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
 536     else
 537         AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
 538     fi
 539 else
 540     AC_MSG_RESULT(no)
 541 fi
 542
 543 AC_MSG_CHECKING(for GNU C library)
 544 AC_CACHE_VAL(gcc_cv_glibc,
 545 [AC_TRY_COMPILE(
 546   [#include <features.h>],[
 547 #if ! (defined __GLIBC__ || defined __GNU_LIBRARY__)
 548 #error Not a GNU C library system
 549 #endif],
 550   [gcc_cv_glibc=yes],
 551   gcc_cv_glibc=no)])
 552 AC_MSG_RESULT($gcc_cv_glibc)
 553 if test $gcc_cv_glibc = yes; then
 554   AC_DEFINE(_GNU_SOURCE, 1, [Always define this when using the GNU C Library])
 555 fi
 556
 557 # Find some useful tools
 558 AC_PROG_AWK
 559 gcc_AC_PROG_LN
 560 gcc_AC_PROG_LN_S
 561 AC_PROG_RANLIB
 562 gcc_AC_PROG_INSTALL
 563
 564 AC_HEADER_STDC
 565 AC_HEADER_TIME
 566 gcc_AC_HEADER_STDBOOL
 567 gcc_AC_HEADER_STRING
 568 AC_HEADER_SYS_WAIT
 569 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h \
 570                  fcntl.h unistd.h sys/file.h sys/time.h \
 571                  sys/resource.h sys/param.h sys/times.h sys/stat.h \
 572                  direct.h malloc.h langinfo.h ldfcn.h)
 573
 574 # Check for thread headers.
 575 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
 576 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
 577
 578 # These tests can't be done till we know if we have limits.h.
 579 gcc_AC_C_CHAR_BIT
 580 AC_C_BIGENDIAN_CROSS
 581 gcc_AC_C_FLOAT_FORMAT
 582
 583 # See if we have the mktemp command.
 584 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
 585
 586 # Do we have a single-tree copy of texinfo?
 587 if test -f $srcdir/../texinfo/Makefile.in; then
 588   MAKEINFO='$(objdir)/../texinfo/makeinfo/makeinfo'
 589   gcc_cv_prog_makeinfo_modern=yes
 590   AC_MSG_RESULT([Using makeinfo from the unified source tree.])
 591 else
 592   # See if makeinfo has been installed and is modern enough
 593   # that we can use it.
 594   gcc_AC_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
 595   [GNU texinfo.* \([0-9][0-9.]*\)],
 596   [4.[2-9]*])
 597 fi
 598
 599 if test $gcc_cv_prog_makeinfo_modern = no; then
 600   AC_MSG_WARN([
 601 *** Makeinfo is missing or too old.
 602 *** Info documentation will not be built.])
 603   BUILD_INFO=
 604 else
 605   BUILD_INFO=info               AC_SUBST(BUILD_INFO)
 606 fi
 607
 608 # Is pod2man recent enough to regenerate manpages?
 609 AC_MSG_CHECKING([for recent Pod::Man])
 610 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
 611   AC_MSG_RESULT(yes)
 612   GENERATED_MANPAGES=generated-manpages         AC_SUBST(GENERATED_MANPAGES)
 613 else
 614   AC_MSG_RESULT(no)
 615   GENERATED_MANPAGES=
 616 fi
 617
 618 # How about lex?
 619 dnl Don't use AC_PROG_LEX; we insist on flex.
 620 dnl LEXLIB is not useful in gcc.
 621 if test -f $srcdir/../flex/skel.c; then
 622   FLEX='$(objdir)/../flex/flex'
 623 else
 624   AC_CHECK_PROG(FLEX, flex, flex, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing flex)
 625 fi
 626
 627 # Bison?
 628 # The -L switch is so bison can find its skeleton file.
 629 if test -f $srcdir/../bison/bison.simple; then
 630   BISON='$(objdir)/../bison/bison -L $(srcdir)/../bison/'
 631 else
 632   AC_CHECK_PROG(BISON, bison, bison, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing bison)
 633 fi
 634
 635 # These libraries may be used by collect2.
 636 # We may need a special search path to get them linked.
 637 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
 638 [save_LIBS="$LIBS"
 639 for libs in '' -lld -lmld \
 640                 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
 641                 '-L/usr/lib/cmplrs/cc3.11 -lmld'
 642 do
 643         LIBS="$libs"
 644         AC_TRY_LINK_FUNC(ldopen,
 645                 [gcc_cv_collect2_libs="$libs"; break])
 646 done
 647 LIBS="$save_LIBS"
 648 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
 649 case $gcc_cv_collect2_libs in
 650         "none required")        ;;
 651         *)      COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
 652 esac
 653 AC_SUBST(COLLECT2_LIBS)
 654
 655 # When building Ada code on Alpha, we need exc_resume which is usually in
 656 # -lexc.  So test for it.
 657 save_LIBS="$LIBS"
 658 LIBS=
 659 AC_SEARCH_LIBS(exc_resume, exc)
 660 GNAT_LIBEXC="$LIBS"
 661 LIBS="$save_LIBS"
 662 AC_SUBST(GNAT_LIBEXC)
 663
 664 # See if the stage1 system preprocessor understands the ANSI C
 665 # preprocessor stringification operator.  (Used by symcat.h.)
 666 AC_C_STRINGIZE
 667
 668 # Use <inttypes.h> only if it exists,
 669 # doesn't clash with <sys/types.h>, and declares intmax_t.
 670 AC_MSG_CHECKING(for inttypes.h)
 671 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
 672 [AC_TRY_COMPILE(
 673   [#include <sys/types.h>
 674 #include <inttypes.h>],
 675   [intmax_t i = -1;],
 676   [gcc_cv_header_inttypes_h=yes],
 677   gcc_cv_header_inttypes_h=no)])
 678 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
 679 if test $gcc_cv_header_inttypes_h = yes; then
 680   AC_DEFINE(HAVE_INTTYPES_H, 1,
 681         [Define if you have a working <inttypes.h> header file.])
 682 fi
 683
 684 dnl Disabled until we have a complete test for buggy enum bitfields.
 685 dnl gcc_AC_C_ENUM_BF_UNSIGNED
 686
 687 AC_CHECK_FUNCS(times clock dup2 kill getrlimit setrlimit atoll atoq \
 688         sysconf strsignal putc_unlocked fputc_unlocked fputs_unlocked \
 689         fwrite_unlocked fprintf_unlocked getrusage nl_langinfo lstat \
 690         scandir alphasort)
 691
 692 AC_CHECK_TYPE(ssize_t, int)
 693
 694 # Try to determine the array type of the second argument of getgroups
 695 # for the target system (int or gid_t).
 696 AC_TYPE_GETGROUPS
 697 if test "${target}" = "${build}"; then
 698   TARGET_GETGROUPS_T=$ac_cv_type_getgroups
 699 else
 700   case "${target}" in
 701         # This condition may need some tweaking.  It should include all
 702         # targets where the array type of the second argument of getgroups
 703         # is int and the type of gid_t is not equivalent to int.
 704         *-*-sunos* | *-*-ultrix*)
 705                 TARGET_GETGROUPS_T=int
 706                 ;;
 707         *)
 708                 TARGET_GETGROUPS_T=gid_t
 709                 ;;
 710   esac
 711 fi
 712 AC_SUBST(TARGET_GETGROUPS_T)
 713
 714 gcc_AC_FUNC_PRINTF_PTR
 715
 716 case "${host}" in
 717 *-*-uwin*)
 718   AC_MSG_ERROR([
 719 *** UWIN may not be used as a host platform because
 720 *** linking with posix.dll is not allowed by the GNU GPL])
 721   ;;
 722 *-*-*vms*)
 723   # Under VMS, vfork works very different than on Unix. The standard test
 724   # won't work, and it isn't easily adaptable. It makes more sense to
 725   # just force it.
 726   ac_cv_func_vfork_works=yes
 727   ;;
 728 esac
 729 AC_FUNC_VFORK
 730 AC_FUNC_MMAP_ANYWHERE
 731 AC_FUNC_MMAP_FILE
 732
 733 AM_ICONV
 734
 735 # We will need to find libiberty.h and ansidecl.h
 736 saved_CFLAGS="$CFLAGS"
 737 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include"
 738 gcc_AC_CHECK_DECLS(getenv atol sbrk abort atof getcwd getwd \
 739         strsignal putc_unlocked fputs_unlocked fwrite_unlocked \
 740         fprintf_unlocked strstr errno vasprintf \
 741         malloc realloc calloc free basename getopt clock, , ,[
 742 #include "ansidecl.h"
 743 #include "system.h"])
 744
 745 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
 746 #include "ansidecl.h"
 747 #include "system.h"
 748 #ifdef HAVE_SYS_RESOURCE_H
 749 #include <sys/resource.h>
 750 #endif
 751 ])
 752
 753 gcc_AC_CHECK_DECLS(ldgetname, , ,[
 754 #include "ansidecl.h"
 755 #include "system.h"
 756 #ifdef HAVE_LDFCN_H
 757 #include <ldfcn.h>
 758 #endif
 759 ])
 760
 761 gcc_AC_CHECK_DECLS(times, , ,[
 762 #include "ansidecl.h"
 763 #include "system.h"
 764 #ifdef HAVE_SYS_TIMES_H
 765 #include <sys/times.h>
 766 #endif
 767 ])
 768
 769 # More time-related stuff.
 770 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
 771 AC_TRY_COMPILE([
 772 #include "ansidecl.h"
 773 #include "system.h"
 774 #ifdef HAVE_SYS_TIMES_H
 775 #include <sys/times.h>
 776 #endif
 777 ], [struct tms tms;], ac_cv_struct_tms=yes, ac_cv_struct_tms=no)])
 778 if test $ac_cv_struct_tms = yes; then
 779   AC_DEFINE(HAVE_STRUCT_TMS, 1,
 780   [Define if <sys/times.h> defines struct tms.])
 781 fi
 782
 783 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
 784 # revisit after autoconf 2.50.
 785 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
 786 AC_TRY_COMPILE([
 787 #include "ansidecl.h"
 788 #include "system.h"
 789 ], [clock_t x;], gcc_cv_type_clock_t=yes, gcc_cv_type_clock_t=no)])
 790 if test $gcc_cv_type_clock_t = yes; then
 791   AC_DEFINE(HAVE_CLOCK_T, 1,
 792   [Define if <time.h> defines clock_t.])
 793 fi
 794
 795 AC_CACHE_CHECK(for uchar, gcc_cv_type_uchar,
 796 [AC_TRY_COMPILE([
 797 #include "ansidecl.h"
 798 #include "system.h"
 799 ],
 800 [if ((uchar *)0) return 0;
 801  if (sizeof(uchar)) return 0;],
 802 ac_cv_type_uchar=yes, ac_cv_type_uchar=no)])
 803 if test $ac_cv_type_uchar = yes; then
 804   AC_DEFINE(HAVE_UCHAR, 1,
 805   [Define if <sys/types.h> defines \`uchar'.])
 806 fi
 807
 808 # Restore CFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
 809 CFLAGS="$saved_CFLAGS"
 810
 811 gcc_AC_INITFINI_ARRAY
 812
 813 # mkdir takes a single argument on some systems.
 814 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
 815
 816 # File extensions
 817 manext='.1'
 818 objext='.o'
 819 AC_SUBST(manext)
 820 AC_SUBST(objext)
 821
 822 # With Setjmp/Longjmp based exception handling.
 823 AC_ARG_ENABLE(sjlj-exceptions,
 824 [  --enable-sjlj-exceptions
 825                           arrange to use setjmp/longjmp exception handling],
 826 [sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
 827 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
 828   [Define 0/1 to force the choice for exception handling model.])])
 829
 830 AC_CHECK_LIB(unwind, main, use_libunwind_default=yes, use_libunwind_default=no)
 831 # Use libunwind based exception handling.
 832 AC_ARG_ENABLE(libunwind-exceptions,
 833 [  --enable-libunwind-exceptions  force use libunwind for exceptions],
 834 use_libunwind_exceptions=$enableval,
 835 use_libunwind_exceptions=$use_libunwind_default)
 836 if test x"$use_libunwind_exceptions" = xyes; then
 837    AC_DEFINE(USE_LIBUNWIND_EXCEPTIONS, 1,
 838         [Define if gcc should use -lunwind.])
 839 fi
 840
 841 target_gtfiles=
 842 build_xm_file=
 843 build_xm_defines=
 844 build_install_headers_dir=install-headers-tar
 845 build_exeext=
 846 host_xm_file=
 847 host_xm_defines=
 848 host_xmake_file=
 849 host_truncate_target=
 850 host_exeext=
 851
 852 # Decode the host machine, then the target machine.
 853 # For the host machine, we save the xm_file variable as host_xm_file;
 854 # then we decode the target machine and forget everything else
 855 # that came from the host machine.
 856 for machine in $build $host $target; do
 857         . ${srcdir}/config.gcc
 858 done
 859
 860 extra_objs="${host_extra_objs} ${extra_objs}"
 861
 862 # Default the target-machine variables that were not explicitly set.
 863 if test x"$tm_file" = x
 864 then tm_file=$cpu_type/$cpu_type.h; fi
 865
 866 if test x"$extra_headers" = x
 867 then extra_headers=; fi
 868
 869 if test x$md_file = x
 870 then md_file=$cpu_type/$cpu_type.md; fi
 871
 872 if test x$out_file = x
 873 then out_file=$cpu_type/$cpu_type.c; fi
 874
 875 if test x"$tmake_file" = x
 876 then tmake_file=$cpu_type/t-$cpu_type
 877 fi
 878
 879 if test x"$dwarf2" = xyes
 880 then tm_file="$tm_file tm-dwarf2.h"
 881 fi
 882
 883 # Say what files are being used for the output code and MD file.
 884 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
 885 echo "Using \`$srcdir/config/$md_file' as machine description file."
 886
 887 # If any of the xm_file variables contain nonexistent files, warn
 888 # about them and drop them.
 889
 890 bx=
 891 for x in $build_xm_file; do
 892   if    test -f $srcdir/config/$x
 893   then      bx="$bx $x"
 894   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
 895   fi
 896 done
 897 build_xm_file="$bx"
 898
 899 hx=
 900 for x in $host_xm_file; do
 901   if    test -f $srcdir/config/$x
 902   then      hx="$hx $x"
 903   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
 904   fi
 905 done
 906 host_xm_file="$hx"
 907
 908 tx=
 909 for x in $xm_file; do
 910   if    test -f $srcdir/config/$x
 911   then      tx="$tx $x"
 912   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
 913   fi
 914 done
 915 xm_file="$tx"
 916
 917 count=a
 918 for f in $tm_file; do
 919         count=${count}x
 920 done
 921 if test $count = ax; then
 922         echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
 923 else
 924         echo "Using the following target machine macro files:"
 925         for f in $tm_file; do
 926                 echo "  $srcdir/config/$f"
 927         done
 928 fi
 929
 930 if test x$need_64bit_hwint = xyes; then
 931         AC_DEFINE(NEED_64BIT_HOST_WIDE_INT, 1,
 932 [Define to 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h).])
 933 fi
 934
 935 count=a
 936 for f in $host_xm_file; do
 937         count=${count}x
 938 done
 939 if test $count = a; then
 940         :
 941 elif test $count = ax; then
 942         echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
 943 else
 944         echo "Using the following host machine macro files:"
 945         for f in $host_xm_file; do
 946                 echo "  $srcdir/config/$f"
 947         done
 948 fi
 949
 950 if test "$host_xm_file" != "$build_xm_file"; then
 951         count=a
 952         for f in $build_xm_file; do
 953                 count=${count}x
 954         done
 955         if test $count = a; then
 956                 :
 957         elif test $count = ax; then
 958                 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
 959         else
 960                 echo "Using the following build machine macro files:"
 961                 for f in $build_xm_file; do
 962                         echo "  $srcdir/config/$f"
 963                 done
 964         fi
 965 fi
 966
 967 if test x$thread_file = x; then
 968         if test x$target_thread_file != x; then
 969                 thread_file=$target_thread_file
 970         else
 971                 thread_file='single'
 972         fi
 973 fi
 974
 975 # Look for a file containing extra machine modes.
 976 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
 977   extra_modes_file='$(srcdir)'/config/${extra_modes}
 978   AC_SUBST(extra_modes_file)
 979   AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "$extra_modes",
 980   [Define to the name of a file containing a list of extra machine modes
 981    for this architecture.])
 982   AC_DEFINE(EXTRA_CC_MODES, 1,
 983   [Define if the target architecture needs extra machine modes to represent
 984    the results of comparisons.])
 985 fi
 986
 987 # auto-host.h is the file containing items generated by autoconf and is
 988 # the first file included by config.h.
 989 # If host=build, it is correct to have bconfig include auto-host.h
 990 # as well.  If host!=build, we are in error and need to do more
 991 # work to find out the build config parameters.
 992 if test x$host = x$build
 993 then
 994         build_auto=auto-host.h
 995         FORBUILD=..
 996 else
 997         # We create a subdir, then run autoconf in the subdir.
 998         # To prevent recursion we set host and build for the new
 999         # invocation of configure to the build for this invocation
1000         # of configure.
1001         tempdir=build.$$
1002         rm -rf $tempdir
1003         mkdir $tempdir
1004         cd $tempdir
1005         case ${srcdir} in
1006         /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1007         *) realsrcdir=../${srcdir};;
1008         esac
1009         saved_CFLAGS="${CFLAGS}"
1010         CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1011         ${realsrcdir}/configure \
1012                 --target=$target_alias --host=$build_alias --build=$build_alias
1013         CFLAGS="${saved_CFLAGS}"
1014
1015         # We just finished tests for the build machine, so rename
1016         # the file auto-build.h in the gcc directory.
1017         mv auto-host.h ../auto-build.h
1018         cd ..
1019         rm -rf $tempdir
1020         build_auto=auto-build.h
1021         FORBUILD=../build-$build_alias
1022 fi
1023 AC_SUBST(FORBUILD)
1024
1025 tm_file="${tm_file} defaults.h"
1026 tm_p_file="${tm_p_file} tm-preds.h"
1027 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1028 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1029 xm_file="ansidecl.h ${xm_file}"
1030
1031 # Truncate the target if necessary
1032 if test x$host_truncate_target != x; then
1033         target=`echo $target | sed -e 's/\(..............\).*/\1/'`
1034 fi
1035
1036 # Get the version trigger filename from the toplevel
1037 if test "${with_gcc_version_trigger+set}" = set; then
1038         gcc_version_trigger=$with_gcc_version_trigger
1039 else
1040         gcc_version_trigger=${srcdir}/version.c
1041 fi
1042 changequote(,)dnl
1043 gcc_version_full=`grep version_string ${gcc_version_trigger} | sed -e 's/.*"\([^"]*\)".*/\1/'`
1044 gcc_version=`echo ${gcc_version_full} | sed -e 's/\([^ ]*\) .*/\1/'`
1045
1046 # Compile in configure arguments.
1047 if test -f configargs.h ; then
1048         # Being re-configured.
1049         gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1050         gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1051 else
1052         gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1053 fi
1054 cat > configargs.h <<EOF
1055 /* Generated automatically. */
1056 static const char configuration_arguments[] = "$gcc_config_arguments";
1057 static const char thread_model[] = "$thread_file";
1058 EOF
1059 changequote([,])dnl
1060
1061 # Internationalization
1062 PACKAGE=gcc
1063 VERSION="$gcc_version"
1064 AC_SUBST(PACKAGE)
1065 AC_SUBST(VERSION)
1066
1067 # Enable NLS support by default
1068 AC_ARG_ENABLE(nls,
1069   [  --enable-nls            use Native Language Support (default)],
1070   , enable_nls=yes)
1071
1072 # if cross compiling, disable NLS support.
1073 # It's not worth the trouble, at least for now.
1074
1075 if test "${build}" != "${host}" && test "x$enable_nls" = "xyes"; then
1076   AC_MSG_WARN(Disabling NLS support for canadian cross compiler.)
1077   enable_nls=no
1078 fi
1079
1080 AM_GNU_GETTEXT
1081
1082 # Windows32 Registry support for specifying GCC installation paths.
1083 AC_ARG_ENABLE(win32-registry,
1084 [  --disable-win32-registry
1085                           disable lookup of installation paths in the
1086                           Registry on Windows hosts
1087   --enable-win32-registry enable registry lookup (default)
1088   --enable-win32-registry=KEY
1089                           use KEY instead of GCC version as the last portion
1090                           of the registry key],,)
1091 case $host_os in
1092         win32 | pe | cygwin* | mingw32* | uwin*)
1093 AC_MSG_CHECKING(whether windows registry support is requested)
1094 if test "x$enable_win32_registry" != xno; then
1095   AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1096 [Define to 1 if installation paths should be looked up in Windows32
1097    Registry. Ignored on non windows32 hosts.])
1098   AC_MSG_RESULT(yes)
1099   AC_SEARCH_LIBS(RegOpenKeyExA, advapi32)
1100 else
1101   AC_MSG_RESULT(no)
1102 fi
1103
1104 # Check if user specified a different registry key.
1105 case "x${enable_win32_registry}" in
1106 x | xyes)
1107   # default.
1108   gcc_cv_win32_registry_key="$VERSION"
1109   ;;
1110 xno)
1111   # no registry lookup.
1112   gcc_cv_win32_registry_key=''
1113   ;;
1114 *)
1115   # user-specified key.
1116   gcc_cv_win32_registry_key="$enable_win32_registry"
1117   ;;
1118 esac
1119
1120 if test "x$enable_win32_registry" != xno; then
1121   AC_MSG_CHECKING(registry key on windows hosts)
1122   AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$gcc_cv_win32_registry_key",
1123         [Define to be the last portion of registry key on windows hosts.])
1124   AC_MSG_RESULT($gcc_cv_win32_registry_key)
1125 fi
1126 ;;
1127 esac
1128
1129 # Get an absolute path to the GCC top-level source directory
1130 holddir=`${PWDCMD-pwd}`
1131 cd $srcdir
1132 topdir=`${PWDCMD-pwd}`
1133 cd $holddir
1134
1135 # Conditionalize the makefile for this host machine.
1136 # Make-host contains the concatenation of all host makefile fragments
1137 # [there can be more than one].  This file is built by configure.frag.
1138 host_overrides=Make-host
1139 dep_host_xmake_file=
1140 for f in .. ${host_xmake_file}
1141 do
1142         if test -f ${srcdir}/config/$f
1143         then
1144                 dep_host_xmake_file="${dep_host_xmake_file} ${srcdir}/config/$f"
1145         fi
1146 done
1147
1148 # Conditionalize the makefile for this target machine.
1149 # Make-target contains the concatenation of all host makefile fragments
1150 # [there can be more than one].  This file is built by configure.frag.
1151 target_overrides=Make-target
1152 dep_tmake_file=
1153 for f in .. ${tmake_file}
1154 do
1155         if test -f ${srcdir}/config/$f
1156         then
1157                 dep_tmake_file="${dep_tmake_file} ${srcdir}/config/$f"
1158         fi
1159 done
1160
1161 # If the host doesn't support symlinks, modify CC in
1162 # FLAGS_TO_PASS so CC="stage1/xgcc -Bstage1/" works.
1163 # Otherwise, we can use "CC=$(CC)".
1164 rm -f symtest.tem
1165 if $symbolic_link $srcdir/gcc.c symtest.tem 2>/dev/null
1166 then
1167         cc_set_by_configure="\$(CC)"
1168         quoted_cc_set_by_configure="\$(CC)"
1169         stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1170         quoted_stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1171 else
1172         rm -f symtest.tem
1173         if cp -p $srcdir/gcc.c symtest.tem 2>/dev/null
1174         then
1175                 symbolic_link="cp -p"
1176         else
1177                 symbolic_link="cp"
1178         fi
1179         cc_set_by_configure="\`case '\$(CC)' in stage*) echo '\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\$(CC)';; esac\`"
1180         quoted_cc_set_by_configure="\\\`case '\\\$(CC)' in stage*) echo '\\\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(CC)';; esac\\\`"
1181         stage_prefix_set_by_configure="\`case '\$(STAGE_PREFIX)' in stage*) echo '\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\$(STAGE_PREFIX)';; esac\`"
1182         quoted_stage_prefix_set_by_configure="\\\`case '\\\$(STAGE_PREFIX)' in stage*) echo '\\\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(STAGE_PREFIX)';; esac\\\`"
1183 fi
1184 rm -f symtest.tem
1185
1186 out_object_file=`basename $out_file .c`.o
1187
1188 tm_file_list=
1189 for f in $tm_file; do
1190   case $f in
1191     ansidecl.h )
1192        tm_file_list="${tm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
1193     defaults.h )
1194        tm_file_list="${tm_file_list} \$(srcdir)/$f" ;;
1195     *) tm_file_list="${tm_file_list} \$(srcdir)/config/$f" ;;
1196   esac
1197 done
1198
1199 tm_p_file_list=
1200 for f in $tm_p_file; do
1201   case $f in
1202     tm-preds.h )
1203        tm_p_file_list="${tm_p_file_list} $f" ;;
1204     *) tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f" ;;
1205   esac
1206 done
1207
1208 host_xm_file_list=
1209 for f in $host_xm_file; do
1210   case $f in
1211     ansidecl.h )
1212        host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
1213     auto-host.h )
1214        host_xm_file_list="${host_xm_file_list} $f" ;;
1215     defaults.h )
1216        host_xm_file_list="${host_xm_file_list} \$(srcdir)/$f" ;;
1217     *) host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f" ;;
1218   esac
1219 done
1220
1221 build_xm_file_list=
1222 for f in $build_xm_file; do
1223   case $f in
1224     ansidecl.h )
1225        build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
1226     auto-build.h | auto-host.h )
1227        build_xm_file_list="${build_xm_file_list} $f" ;;
1228     defaults.h )
1229        host_xm_file_list="${host_xm_file_list} \$(srcdir)/$f" ;;
1230     *) build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f" ;;
1231   esac
1232 done
1233
1234 # Define macro CROSS_COMPILE in compilation if this is a cross-compiler.
1235 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1236 CROSS=                                          AC_SUBST(CROSS)
1237 ALL=all.internal                                AC_SUBST(ALL)
1238 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1239 if test x$host != x$target
1240 then
1241         CROSS="-DCROSS_COMPILE"
1242         ALL=all.cross
1243         SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1244         case "$host","$target" in
1245             i?86-*-*,x86_64-*-* \
1246             | powerpc*-*-*,powerpc64*-*-*)
1247                 CROSS="$CROSS -DNATIVE_CROSS" ;;
1248         esac
1249 fi
1250
1251 # If this is a cross-compiler that does not
1252 # have its own set of headers then define
1253 # inhibit_libc
1254
1255 # If this is using newlib, then define inhibit_libc in LIBGCC2_CFLAGS.
1256 # This prevents libgcc2 from containing any code which requires libc
1257 # support.
1258 inhibit_libc=
1259 if { test x$host != x$target && test "x$with_headers" = x &&
1260      test "x$with_sysroot" = x ; } || test x$with_newlib = xyes ; then
1261        inhibit_libc=-Dinhibit_libc
1262 fi
1263 AC_SUBST(inhibit_libc)
1264
1265 # When building gcc with a cross-compiler, we need to adjust things so
1266 # that the generator programs are still built with the native compiler.
1267 # Also, we cannot run fixincludes or fix-header.
1268
1269 # These are the normal (build=host) settings:
1270 BUILD_PREFIX=                   AC_SUBST(BUILD_PREFIX)
1271 BUILD_PREFIX_1=ignore-          AC_SUBST(BUILD_PREFIX_1)
1272 BUILD_CC='$(CC)'                AC_SUBST(BUILD_CC)
1273 BUILD_CFLAGS='$(ALL_CFLAGS)'    AC_SUBST(BUILD_CFLAGS)
1274
1275 STMP_FIXINC=stmp-fixinc         AC_SUBST(STMP_FIXINC)
1276 STMP_FIXPROTO=stmp-fixproto     AC_SUBST(STMP_FIXPROTO)
1277
1278 # And these apply if build != host.
1279 if test x$build != x$host
1280 then
1281     BUILD_PREFIX=build-
1282     BUILD_PREFIX_1=build-
1283     BUILD_CC='$(CC_FOR_BUILD)'
1284     BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD) $(XCFLAGS)'
1285
1286     STMP_FIXINC=
1287     STMP_FIXPROTO=
1288 fi
1289
1290 # Expand extra_headers to include complete path.
1291 # This substitutes for lots of t-* files.
1292 extra_headers_list=
1293 if test "x$extra_headers" = x
1294 then true
1295 else
1296         # Prepend ${srcdir}/config/${cpu_type}/ to every entry in extra_headers.
1297         for file in $extra_headers;
1298         do
1299                 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1300         done
1301 fi
1302
1303 if test x$use_collect2 = xno; then
1304         use_collect2=
1305 fi
1306
1307 # Add a definition of USE_COLLECT2 if system wants one.
1308 if test x$use_collect2 != x
1309 then
1310         host_xm_defines="${host_xm_defines} USE_COLLECT2"
1311         xm_defines="${xm_defines} USE_COLLECT2"
1312 fi
1313
1314 # If we have gas in the build tree, make a link to it.
1315 if test -f ../gas/Makefile; then
1316         rm -f as; $symbolic_link ../gas/as-new$host_exeext as$host_exeext 2>/dev/null
1317 fi
1318
1319 # If we have nm and objdump in the build tree, make a link to them.
1320 if test -f ../binutils/Makefile; then
1321         rm -f nm; $symbolic_link ../binutils/nm-new$host_exeext nm$host_exeext 2>/dev/null
1322         rm -f objdump; $symbolic_link ../binutils/objdump$host_exeext objdump$host_exeext 2>/dev/null
1323 fi
1324
1325 # If we have ld in the build tree, make a link to it.
1326 if test -f ../ld/Makefile; then
1327         rm -f collect-ld; $symbolic_link ../ld/ld-new$host_exeext collect-ld$host_exeext 2>/dev/null
1328 fi
1329
1330 # Figure out what assembler we will be using.
1331 AC_MSG_CHECKING(what assembler to use)
1332 gcc_cv_as=
1333 gcc_cv_gas_major_version=
1334 gcc_cv_gas_minor_version=
1335 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1336 gcc_cv_as_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1337 if test -x "$DEFAULT_ASSEMBLER"; then
1338         gcc_cv_as="$DEFAULT_ASSEMBLER"
1339 elif test -x "$AS"; then
1340         gcc_cv_as="$AS"
1341 elif test -x as$host_exeext; then
1342         # Build using assembler in the current directory.
1343         gcc_cv_as=./as$host_exeext
1344 elif test -f $gcc_cv_as_gas_srcdir/configure.in -a -f ../gas/Makefile; then
1345         # Single tree build which includes gas.
1346         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
1347         do
1348 changequote(,)dnl
1349                 gcc_cv_gas_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
1350 changequote([,])dnl
1351                 if test x$gcc_cv_gas_version != x; then
1352                         break
1353                 fi
1354         done
1355 changequote(,)dnl
1356         gcc_cv_gas_major_version=`expr "$gcc_cv_gas_version" : "VERSION=\([0-9]*\)"`
1357         gcc_cv_gas_minor_version=`expr "$gcc_cv_gas_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1358         gcc_cv_gas_patch_version=`expr "$gcc_cv_gas_version" : "VERSION=[0-9]*\.[0-9]*\.\([0-9]*\)"`
1359 changequote([,])dnl
1360 fi
1361
1362 if test "x$gcc_cv_as" = x; then
1363         # Search the same directories that the installed compiler will
1364         # search.  Else we may find the wrong assembler and lose.  If we
1365         # do not find a suitable assembler binary, then try the user's
1366         # path.
1367         #
1368         # Also note we have to check MD_EXEC_PREFIX before checking the
1369         # user's path.  Unfortunately, there is no good way to get at the
1370         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1371         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1372         # to be fixed as part of the make/configure rewrite too.
1373
1374         if test "x$exec_prefix" = xNONE; then
1375                 if test "x$prefix" = xNONE; then
1376                         test_prefix=/usr/local
1377                 else
1378                         test_prefix=$prefix
1379                 fi
1380         else
1381                 test_prefix=$exec_prefix
1382         fi
1383
1384         # If the loop below does not find an assembler, then use whatever
1385         # one we can find in the users's path.
1386         # user's path.
1387         if test "x$program_prefix" != xNONE; then
1388                 gcc_cv_as=${program_prefix}as$host_exeext
1389         else
1390                 gcc_cv_as=`echo as | sed ${program_transform_name}`$host_exeext
1391         fi
1392
1393         test_dirs="$test_prefix/lib/gcc-lib/$target_alias/$gcc_version \
1394                    $test_prefix/lib/gcc-lib/$target_alias \
1395                    /usr/lib/gcc/$target_alias/$gcc_version \
1396                    /usr/lib/gcc/$target_alias \
1397                    $test_prefix/$target_alias/bin/$target_alias/$gcc_version \
1398                    $test_prefix/$target_alias/bin"
1399
1400         if test x$host = x$target; then
1401             test_dirs="$test_dirs \
1402                    /usr/libexec \
1403                    /usr/ccs/gcc \
1404                    /usr/ccs/bin \
1405                    /udk/usr/ccs/bin \
1406                    /bsd43/usr/lib/cmplrs/cc \
1407                    /usr/cross64/usr/bin \
1408                    /usr/lib/cmplrs/cc \
1409                    /sysv/usr/lib/cmplrs/cc \
1410                    /svr4/usr/lib/cmplrs/cc \
1411                    /usr/bin"
1412         fi
1413
1414         for dir in $test_dirs; do
1415                 if test -x $dir/as$host_exeext; then
1416                         gcc_cv_as=$dir/as$host_exeext
1417                         break;
1418                 fi
1419         done
1420 fi
1421 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1422   AC_MSG_RESULT("newly built gas")
1423 else
1424   AC_MSG_RESULT($gcc_cv_as)
1425 fi
1426
1427 # Figure out what linker we will be using.
1428 AC_MSG_CHECKING(what linker to use)
1429 gcc_cv_ld=
1430 gcc_cv_gld_major_version=
1431 gcc_cv_gld_minor_version=
1432 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1433 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1434 if test -x "$DEFAULT_LINKER"; then
1435         gcc_cv_ld="$DEFAULT_LINKER"
1436 elif test -x "$LD"; then
1437         gcc_cv_ld="$LD"
1438 elif test -x ld$host_exeext; then
1439         # Build using linker in the current directory.
1440         gcc_cv_ld=./ld$host_exeext
1441 elif test -f $gcc_cv_ld_gld_srcdir/configure.in -a -f ../ld/Makefile; then
1442         # Single tree build which includes ld.
1443         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
1444         do
1445 changequote(,)dnl
1446                 gcc_cv_gld_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
1447 changequote([,])dnl
1448                 if test x$gcc_cv_gld_version != x; then
1449                         break
1450                 fi
1451         done
1452 changequote(,)dnl
1453         gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
1454         gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1455 changequote([,])dnl
1456 fi
1457
1458 if test "x$gcc_cv_ld" = x; then
1459         # Search the same directories that the installed compiler will
1460         # search.  Else we may find the wrong linker and lose.  If we
1461         # do not find a suitable linker binary, then try the user's
1462         # path.
1463         #
1464         # Also note we have to check MD_EXEC_PREFIX before checking the
1465         # user's path.  Unfortunately, there is no good way to get at the
1466         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1467         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1468         # to be fixed as part of the make/configure rewrite too.
1469
1470         if test "x$exec_prefix" = xNONE; then
1471                 if test "x$prefix" = xNONE; then
1472                         test_prefix=/usr/local
1473                 else
1474                         test_prefix=$prefix
1475                 fi
1476         else
1477                 test_prefix=$exec_prefix
1478         fi
1479
1480         # If the loop below does not find an linker, then use whatever
1481         # one we can find in the users's path.
1482         # user's path.
1483         if test "x$program_prefix" != xNONE; then
1484                 gcc_cv_ld=${program_prefix}ld$host_exeext
1485         else
1486                 gcc_cv_ld=`echo ld | sed ${program_transform_name}`$host_exeext
1487         fi
1488
1489         test_dirs="$test_prefix/lib/gcc-lib/$target_alias/$gcc_version \
1490                    $test_prefix/lib/gcc-lib/$target_alias \
1491                    /usr/lib/gcc/$target_alias/$gcc_version \
1492                    /usr/lib/gcc/$target_alias \
1493                    $test_prefix/$target_alias/bin/$target_alias/$gcc_version \
1494                    $test_prefix/$target_alias/bin"
1495
1496         if test x$host = x$target; then
1497             test_dirs="$test_dirs \
1498                    /usr/libexec \
1499                    /usr/ccs/gcc \
1500                    /usr/ccs/bin \
1501                    /udk/usr/ccs/bin \
1502                    /bsd43/usr/lib/cmplrs/cc \
1503                    /usr/cross64/usr/bin \
1504                    /usr/lib/cmplrs/cc \
1505                    /sysv/usr/lib/cmplrs/cc \
1506                    /svr4/usr/lib/cmplrs/cc \
1507                    /usr/bin"
1508         fi
1509
1510         for dir in $test_dirs; do
1511                 if test -x $dir/ld$host_exeext; then
1512                         gcc_cv_ld=$dir/ld$host_exeext
1513                         break;
1514                 fi
1515         done
1516 fi
1517 if test x$gcc_cv_gld_major_version != x -a x$gcc_cv_gld_minor_version != x; then
1518   AC_MSG_RESULT("newly built ld")
1519 else
1520   AC_MSG_RESULT($gcc_cv_ld)
1521 fi
1522
1523 # Figure out what nm we will be using.
1524 AC_MSG_CHECKING(what nm to use)
1525 if test -x nm$host_exeext; then
1526         gcc_cv_nm=./nm$host_exeext
1527 elif test "x$program_prefix" != xNONE; then
1528         gcc_cv_nm=${program_prefix}nm$host_exeext
1529 else
1530         gcc_cv_nm=`echo nm | sed ${program_transform_name}`$host_exeext
1531 fi
1532 AC_MSG_RESULT($gcc_cv_nm)
1533
1534 # Figure out what objdump we will be using.
1535 AC_MSG_CHECKING(what objdump to use)
1536 if test -x objdump$host_exeext; then
1537         gcc_cv_objdump=./objdump$host_exeext
1538 elif test "x$program_prefix" != xNONE; then
1539         gcc_cv_objdump=${program_prefix}objdump$host_exeext
1540 else
1541         gcc_cv_objdump=`echo objdump | sed ${program_transform_name}`$host_exeext
1542 fi
1543 AC_MSG_RESULT($gcc_cv_objdump)
1544
1545 # Figure out what assembler alignment features are present.
1546 AC_MSG_CHECKING(assembler alignment features)
1547 gcc_cv_as_alignment_features=none
1548 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1549         # Gas version 2.6 and later support for .balign and .p2align.
1550         # bytes to skip when using .p2align.
1551         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
1552                 gcc_cv_as_alignment_features=".balign and .p2align"
1553                 AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN)
1554         fi
1555         # Gas version 2.8 and later support specifying the maximum
1556         # bytes to skip when using .p2align.
1557         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
1558                 gcc_cv_as_alignment_features=".p2align including maximum skip"
1559                 AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN)
1560         fi
1561 elif test x$gcc_cv_as != x; then
1562         # Check if we have .balign and .p2align
1563         echo ".balign  4" > conftest.s
1564         echo ".p2align  2" >> conftest.s
1565         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1566                 gcc_cv_as_alignment_features=".balign and .p2align"
1567                 AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN)
1568         fi
1569         rm -f conftest.s conftest.o
1570         # Check if specifying the maximum bytes to skip when
1571         # using .p2align is supported.
1572         echo ".p2align 4,,7" > conftest.s
1573         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1574                 gcc_cv_as_alignment_features=".p2align including maximum skip"
1575                 AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN)
1576         fi
1577         rm -f conftest.s conftest.o
1578 fi
1579 AC_MSG_RESULT($gcc_cv_as_alignment_features)
1580
1581 AC_MSG_CHECKING(assembler subsection support)
1582 gcc_cv_as_subsections=no
1583 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1584   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
1585     gcc_cv_as_subsections="working .subsection -1"
1586   fi
1587 elif test x$gcc_cv_as != x; then
1588         # Check if we have .subsection
1589         echo ".subsection 1" > conftest.s
1590         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1591                 gcc_cv_as_subsections=".subsection"
1592                 if test x$gcc_cv_nm != x; then
1593                         cat > conftest.s <<EOF
1594 conftest_label1: .word 0
1595 .subsection -1
1596 conftest_label2: .word 0
1597 .previous
1598 EOF
1599                         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1600                                 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
1601                                 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
1602                                 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1; then
1603                                         :
1604                                 else
1605                                         gcc_cv_as_subsections="working .subsection -1"
1606                                 fi
1607                         fi
1608                 fi
1609         fi
1610         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1611 fi
1612 if test x"$gcc_cv_as_subsections" = x"working .subsection -1"; then
1613         AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
1614 [Define if your assembler supports .subsection and .subsection -1 starts
1615    emitting at the beginning of your section.])
1616 fi
1617 AC_MSG_RESULT($gcc_cv_as_subsections)
1618
1619 AC_MSG_CHECKING(assembler weak support)
1620 gcc_cv_as_weak=no
1621 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1622   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
1623     gcc_cv_as_weak="yes"
1624   fi
1625 elif test x$gcc_cv_as != x; then
1626         # Check if we have .weak
1627         echo "  .weak foobar" > conftest.s
1628         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1629                 gcc_cv_as_weak="yes"
1630         fi
1631         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1632 fi
1633 if test x"$gcc_cv_as_weak" = xyes; then
1634         AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])
1635 fi
1636 AC_MSG_RESULT($gcc_cv_as_weak)
1637
1638 AC_MSG_CHECKING(assembler hidden support)
1639 gcc_cv_as_hidden=no
1640 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1641   if test "$gcc_cv_gas_major_version" -eq 2     \
1642           -a "$gcc_cv_gas_minor_version" -eq 12 \
1643           -a "$gcc_cv_gas_patch_version" -ge 1  \
1644           -o "$gcc_cv_gas_major_version" -eq 2  \
1645           -a "$gcc_cv_gas_minor_version" -gt 12 \
1646           -o "$gcc_cv_gas_major_version" -gt 2  \
1647     && grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
1648     gcc_cv_as_hidden="yes"
1649   fi
1650 elif test x$gcc_cv_as != x; then
1651         # Check if we have .hidden
1652         echo "  .hidden foobar" > conftest.s
1653         echo "foobar:" >> conftest.s
1654         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1655                 gcc_cv_as_hidden="yes"
1656         fi
1657         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1658
1659         # GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
1660         # This is irritatingly difficult to feature test for.  Look for
1661         # the date string after the version number.
1662         ld_ver=`$gcc_cv_ld --version 2>/dev/null | head -1`
1663         if echo "$ld_ver" | grep GNU > /dev/null; then
1664 changequote(,)dnl
1665                 ld_vers=`echo $ld_ver | sed -n 's,^.*[  ]\([0-9][0-9]*\.[0-9][0-9]*\(\|\.[0-9][0-9]*\)\)\([     ].*\|\)$,\1,p'`
1666                 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'`
1667                 if test 0"$ld_date" -lt 20020404; then
1668                         if test -n "$ld_date"; then
1669                                 # If there was date string, but was earlier than 2002-04-04, fail
1670                                 gcc_cv_as_hidden="no"
1671                         elif test -z "$ld_vers"; then
1672                                 # If there was no date string nor ld version number, something is wrong
1673                                 gcc_cv_as_hidden="no"
1674                         else
1675                                 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
1676                                 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
1677                                 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
1678                                 test -z "$ld_vers_patch" && ld_vers_patch=0
1679                                 if test "$ld_vers_major" -lt 2; then
1680                                         gcc_cv_as_hidden="no"
1681                                 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
1682                                         gcc_cv_as_hidden="no"
1683                                 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 \
1684                                           -a "$ld_vers_patch" -eq 0; then
1685                                         gcc_cv_as_hidden="no"
1686                                 fi
1687                         fi
1688                 fi
1689 changequote([,])dnl
1690         fi
1691 fi
1692 if test x"$gcc_cv_as_hidden" = xyes; then
1693         AC_DEFINE(HAVE_GAS_HIDDEN, 1,
1694                 [Define if your assembler supports .hidden.])
1695 fi
1696 AC_MSG_RESULT($gcc_cv_as_hidden)
1697 libgcc_visibility=$gcc_cv_as_hidden
1698 case "$target" in
1699   mips-sgi-irix6*)
1700     if test x"$gnu_ld_flag" = x"no"; then
1701       # Even if using gas with .hidden support, the resulting object files
1702       # cannot be linked with the IRIX 6 O32 linker.  With the N32 and
1703       # N64 linkers, the problem is that the linker refuses to accept
1704       # -call_shared (passed by default to the linker) and -r (used to
1705       # link the object file generated without .hidden directives with
1706       # one that hides symbols), so we also lose.
1707       libgcc_visibility=no
1708     fi
1709     ;;
1710 esac
1711 AC_SUBST(libgcc_visibility)
1712
1713 AC_MSG_CHECKING(assembler leb128 support)
1714 gcc_cv_as_leb128=no
1715 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1716   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
1717     gcc_cv_as_leb128="yes"
1718   fi
1719 elif test x$gcc_cv_as != x; then
1720         # Check if we have .[us]leb128, and support symbol arithmetic with it.
1721         cat > conftest.s <<EOF
1722         .data
1723         .uleb128 L2 - L1
1724 L1:
1725         .uleb128 1280
1726         .sleb128 -1010
1727 L2:
1728 EOF
1729         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1730                 gcc_cv_as_leb128="yes"
1731
1732                 # GAS versions before 2.11 do not support uleb128,
1733                 # despite appearing to.
1734                 # ??? There exists an elf-specific test that will crash
1735                 # the assembler.  Perhaps it's better to figure out whether
1736                 # arbitrary sections are supported and try the test.
1737                 as_ver=`$gcc_cv_as --version 2>/dev/null | head -1`
1738                 if echo "$as_ver" | grep GNU > /dev/null; then
1739 changequote(,)dnl
1740                         as_ver=`echo $as_ver | sed -e 's/GNU assembler \([0-9.][0-9.]*\).*/\1/'`
1741                         as_major=`echo $as_ver | sed 's/\..*//'`
1742                         as_minor=`echo $as_ver | sed 's/[^.]*\.\([0-9]*\).*/\1/'`
1743 changequote([,])dnl
1744                         if test $as_major -eq 2 -a $as_minor -lt 11; then
1745                                 gcc_cv_as_leb128="no"
1746                         fi
1747                 fi
1748         fi
1749         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1750 fi
1751 if test x"$gcc_cv_as_leb128" = xyes; then
1752         AC_DEFINE(HAVE_AS_LEB128, 1,
1753                 [Define if your assembler supports .uleb128.])
1754 fi
1755 AC_MSG_RESULT($gcc_cv_as_leb128)
1756
1757 AC_MSG_CHECKING(assembler eh_frame optimization)
1758 gcc_cv_as_eh_frame=no
1759 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1760   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
1761     gcc_cv_as_eh_frame="yes"
1762   fi
1763 elif test x$gcc_cv_as != x; then
1764         # Check if this is GAS.
1765         as_ver=`$gcc_cv_as --version < /dev/null 2> /dev/null | head -1`
1766         rm -f a.out 2> /dev/null
1767         if echo "$as_ver" | grep GNU > /dev/null; then
1768                 # Versions up to and including 2.11.0 may mis-optimize
1769                 # .eh_frame data.  Try something.
1770                 cat > conftest.s <<EOF
1771         .text
1772 .LFB1:
1773         .4byte  0
1774 .L1:
1775         .4byte  0
1776 .LFE1:
1777         .section        .eh_frame,"aw",@progbits
1778 __FRAME_BEGIN__:
1779         .4byte  .LECIE1-.LSCIE1
1780 .LSCIE1:
1781         .4byte  0x0
1782         .byte   0x1
1783         .ascii "z\0"
1784         .byte   0x1
1785         .byte   0x78
1786         .byte   0x1a
1787         .byte   0x0
1788         .byte   0x4
1789         .4byte  1
1790         .p2align 1
1791 .LECIE1:
1792 .LSFDE1:
1793         .4byte  .LEFDE1-.LASFDE1
1794 .LASFDE1:
1795         .4byte  .LASFDE1-__FRAME_BEGIN__
1796         .4byte  .LFB1
1797         .4byte  .LFE1-.LFB1
1798         .byte   0x4
1799         .4byte  .LFE1-.LFB1
1800         .byte   0x4
1801         .4byte  .L1-.LFB1
1802 .LEFDE1:
1803 EOF
1804                 cat > conftest.lit <<EOF
1805  0000 10000000 00000000 017a0001 781a0004  .........z..x...
1806  0010 01000000 12000000 18000000 00000000  ................
1807  0020 08000000 04080000 0044               .........D
1808 EOF
1809                 cat > conftest.big <<EOF
1810  0000 00000010 00000000 017a0001 781a0004  .........z..x...
1811  0010 00000001 00000012 00000018 00000000  ................
1812  0020 00000008 04000000 0844               .........D
1813 EOF
1814                 # If the assembler didn't choke, and we can objdump,
1815                 # and we got the correct data, then succeed.
1816                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
1817                    && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
1818                       | tail -3 > conftest.got \
1819                    && { cmp conftest.lit conftest.got > /dev/null 2>&1 \
1820                         || cmp conftest.big conftest.got > /dev/null 2>&1; }
1821                 then
1822                         gcc_cv_as_eh_frame="yes"
1823                 else
1824                         gcc_cv_as_eh_frame="bad"
1825                         if $gcc_cv_as -o conftest.o --traditional-format /dev/null; then
1826                                 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
1827         [Define if your assembler mis-optimizes .eh_frame data.])
1828                         fi
1829                 fi
1830         fi
1831         rm -f conftest.*
1832 fi
1833 AC_MSG_RESULT($gcc_cv_as_eh_frame)
1834
1835 AC_MSG_CHECKING(assembler section merging support)
1836 gcc_cv_as_shf_merge=no
1837 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1838   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
1839     gcc_cv_as_shf_merge=yes
1840   fi
1841 elif test x$gcc_cv_as != x; then
1842         # Check if we support SHF_MERGE sections
1843         echo '.section .rodata.str, "aMS", @progbits, 1' > conftest.s
1844         if $gcc_cv_as --fatal-warnings -o conftest.o conftest.s > /dev/null 2>&1; then
1845                 gcc_cv_as_shf_merge=yes
1846         fi
1847         rm -f conftest.s conftest.o
1848 fi
1849 if test x"$gcc_cv_as_shf_merge" = xyes; then
1850         AC_DEFINE(HAVE_GAS_SHF_MERGE, 1,
1851 [Define if your assembler supports marking sections with SHF_MERGE flag.])
1852 fi
1853 AC_MSG_RESULT($gcc_cv_as_shf_merge)
1854
1855 AC_MSG_CHECKING(assembler thread-local storage support)
1856 gcc_cv_as_tls=no
1857 conftest_s=
1858 tls_first_major=
1859 tls_first_minor=
1860 case "$target" in
1861 changequote(,)dnl
1862   alpha*-*-*)
1863     conftest_s='
1864         .section ".tdata","awT",@progbits
1865 foo:    .long   25
1866         .text
1867         ldq     $27,__tls_get_addr($29)         !literal!1
1868         lda     $16,foo($29)                    !tlsgd!1
1869         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
1870         ldq     $27,__tls_get_addr($29)         !literal!2
1871         lda     $16,foo($29)                    !tlsldm!2
1872         jsr     $26,($27),__tls_get_addr        !lituse_tlsldm!2
1873         ldq     $1,foo($29)                     !gotdtprel
1874         ldah    $2,foo($29)                     !dtprelhi
1875         lda     $3,foo($2)                      !dtprello
1876         lda     $4,foo($29)                     !dtprel
1877         ldq     $1,foo($29)                     !gottprel
1878         ldah    $2,foo($29)                     !tprelhi
1879         lda     $3,foo($2)                      !tprello
1880         lda     $4,foo($29)                     !tprel'
1881         tls_first_major=2
1882         tls_first_minor=13
1883         ;;
1884   i[34567]86-*-*)
1885 changequote([,])dnl
1886     conftest_s='
1887         .section ".tdata","awT",@progbits
1888 foo:    .long   25
1889         .text
1890         movl    %gs:0, %eax
1891         leal    foo@TLSGD(,%ebx,1), %eax
1892         leal    foo@TLSLDM(%ebx), %eax
1893         leal    foo@DTPOFF(%eax), %edx
1894         movl    foo@GOTTPOFF(%ebx), %eax
1895         subl    foo@GOTTPOFF(%ebx), %eax
1896         addl    foo@GOTNTPOFF(%ebx), %eax
1897         movl    foo@INDNTPOFF, %eax
1898         movl    $foo@TPOFF, %eax
1899         subl    $foo@TPOFF, %eax
1900         leal    foo@NTPOFF(%ecx), %eax'
1901         tls_first_major=2
1902         tls_first_minor=14
1903         ;;
1904   x86_64-*-*)
1905     conftest_s='
1906         .section ".tdata","awT",@progbits
1907 foo:    .long   25
1908         .text
1909         movq    %fs:0, %rax
1910         leaq    foo@TLSGD(%rip), %rdi
1911         leaq    foo@TLSLD(%rip), %rdi
1912         leaq    foo@DTPOFF(%rax), %rdx
1913         movq    foo@GOTTPOFF(%rip), %rax
1914         movq    $foo@TPOFF, %rax'
1915         tls_first_major=2
1916         tls_first_minor=14
1917         ;;
1918   ia64-*-*)
1919     conftest_s='
1920         .section ".tdata","awT",@progbits
1921 foo:    data8   25
1922         .text
1923         addl    r16 = @ltoff(@dtpmod(foo#)), gp
1924         addl    r17 = @ltoff(@dtprel(foo#)), gp
1925         addl    r18 = @ltoff(@tprel(foo#)), gp
1926         addl    r19 = @dtprel(foo#), gp
1927         adds    r21 = @dtprel(foo#), r13
1928         movl    r23 = @dtprel(foo#)
1929         addl    r20 = @tprel(foo#), gp
1930         adds    r22 = @tprel(foo#), r13
1931         movl    r24 = @tprel(foo#)'
1932         tls_first_major=2
1933         tls_first_minor=13
1934         ;;
1935 esac
1936 if test -z "$tls_first_major"; then
1937   :
1938 elif test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x
1939 then
1940   if test "$gcc_cv_gas_major_version" -eq "$tls_first_major" \
1941           -a "$gcc_cv_gas_minor_version" -ge "$tls_first_minor" \
1942           -o "$gcc_cv_gas_major_version" -gt "$tls_first_major"; then
1943     gcc_cv_as_tls=yes
1944   fi
1945 elif test x$gcc_cv_as != x; then
1946   echo "$conftest_s" > conftest.s
1947   if $gcc_cv_as --fatal-warnings -o conftest.o conftest.s > /dev/null 2>&1
1948   then
1949     gcc_cv_as_tls=yes
1950   fi
1951   rm -f conftest.s conftest.o
1952 fi
1953 if test "$gcc_cv_as_tls" = yes; then
1954   AC_DEFINE(HAVE_AS_TLS, 1,
1955             [Define if your assembler supports thread-local storage.])
1956 fi
1957 AC_MSG_RESULT($gcc_cv_as_tls)
1958
1959 case "$target" in
1960   # All TARGET_ABI_OSF targets.
1961   alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
1962     AC_CACHE_CHECK([assembler supports explicit relocations],
1963         gcc_cv_as_explicit_relocs, [
1964         gcc_cv_as_explicit_relocs=unknown
1965         if test x$gcc_cv_gas_major_version != x \
1966                 -a x$gcc_cv_gas_minor_version != x
1967         then
1968            if test "$gcc_cv_gas_major_version" -eq 2 \
1969                    -a "$gcc_cv_gas_minor_version" -ge 12 \
1970                    -o "$gcc_cv_gas_major_version" -gt 2; then
1971               gcc_cv_as_explicit_relocs=yes
1972            fi
1973         elif test x$gcc_cv_as != x; then
1974             cat > conftest.s << 'EOF'
1975         .set nomacro
1976         .text
1977         extbl   $3, $2, $3      !lituse_bytoff!1
1978         ldq     $2, a($29)      !literal!1
1979         ldq     $4, b($29)      !literal!2
1980         ldq_u   $3, 0($2)       !lituse_base!1
1981         ldq     $27, f($29)     !literal!5
1982         jsr     $26, ($27), f   !lituse_jsr!5
1983         ldah    $29, 0($26)     !gpdisp!3
1984         lda     $0, c($29)      !gprel
1985         ldah    $1, d($29)      !gprelhigh
1986         lda     $1, d($1)       !gprellow
1987         lda     $29, 0($29)     !gpdisp!3
1988 EOF
1989             if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1990                 gcc_cv_as_explicit_relocs=yes
1991             else
1992                 gcc_cv_as_explicit_relocs=no
1993             fi
1994             rm -f conftest.s conftest.o
1995         fi
1996     ])
1997     if test "x$gcc_cv_as_explicit_relocs" = xyes; then
1998         AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
1999                 [Define if your assembler supports explicit relocations.])
2000     fi
2001     ;;
2002   sparc*-*-*)
2003     AC_CACHE_CHECK([assembler .register pseudo-op support],
2004         gcc_cv_as_register_pseudo_op, [
2005         gcc_cv_as_register_pseudo_op=unknown
2006         if test x$gcc_cv_as != x; then
2007             # Check if we have .register
2008             echo ".register %g2, #scratch" > conftest.s
2009             if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2010                 gcc_cv_as_register_pseudo_op=yes
2011             else
2012                 gcc_cv_as_register_pseudo_op=no
2013             fi
2014             rm -f conftest.s conftest.o
2015         fi
2016     ])
2017     if test "x$gcc_cv_as_register_pseudo_op" = xyes; then
2018         AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
2019                 [Define if your assembler supports .register.])
2020     fi
2021
2022     AC_CACHE_CHECK([assembler supports -relax],
2023         gcc_cv_as_relax_opt, [
2024         gcc_cv_as_relax_opt=unknown
2025         if test x$gcc_cv_as != x; then
2026             # Check if gas supports -relax
2027             echo ".text" > conftest.s
2028             if $gcc_cv_as -relax -o conftest.o conftest.s > /dev/null 2>&1; then
2029                 gcc_cv_as_relax_opt=yes
2030             else
2031                 gcc_cv_as_relax_opt=no
2032             fi
2033             rm -f conftest.s conftest.o
2034         fi
2035     ])
2036     if test "x$gcc_cv_as_relax_opt" = xyes; then
2037         AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
2038                 [Define if your assembler supports -relax option.])
2039     fi
2040
2041     AC_CACHE_CHECK([assembler and linker support unaligned pc related relocs],
2042         gcc_cv_as_sparc_ua_pcrel, [
2043         gcc_cv_as_sparc_ua_pcrel=unknown
2044         if test x$gcc_cv_as != x -a x$gcc_cv_ld != x; then
2045             gcc_cv_as_sparc_ua_pcrel=no
2046             echo ".text; foo: nop; .data; .align 4; .byte 0; .uaword %r_disp32(foo)" > conftest.s
2047             if $gcc_cv_as -K PIC -o conftest.o conftest.s > /dev/null 2>&1 \
2048                && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
2049                 gcc_cv_as_sparc_ua_pcrel=yes
2050             fi
2051             rm -f conftest.s conftest.o conftest
2052         fi
2053     ])
2054     if test "x$gcc_cv_as_sparc_ua_pcrel" = xyes; then
2055         AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
2056                 [Define if your assembler and linker support unaligned PC relative relocs.])
2057     fi
2058
2059     AC_CACHE_CHECK([assembler and linker support unaligned pc related relocs against hidden symbols],
2060         gcc_cv_as_sparc_ua_pcrel_hidden, [
2061         if test "x$gcc_cv_as_sparc_ua_pcrel" = xyes; then
2062             gcc_cv_as_sparc_ua_pcrel_hidden=unknown
2063             if test x$gcc_cv_objdump != x; then
2064                 gcc_cv_as_sparc_ua_pcrel_hidden=no
2065                 echo ".data; .align 4; .byte 0x31; .uaword %r_disp32(foo)" > conftest.s
2066                 echo ".byte 0x32, 0x33, 0x34; .global foo; .hidden foo" >> conftest.s
2067                 echo "foo: .skip 4" >> conftest.s
2068                 if $gcc_cv_as -K PIC -o conftest.o conftest.s > /dev/null 2>&1 \
2069                    && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
2070                    && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
2071                       | grep ' 31000000 07323334' > /dev/null 2>&1; then
2072                     if $gcc_cv_objdump -R conftest 2> /dev/null \
2073                        | grep 'DISP32' > /dev/null 2>&1; then
2074                         :
2075                     else
2076                         gcc_cv_as_sparc_ua_pcrel_hidden=yes
2077                     fi
2078                 fi
2079             fi
2080             rm -f conftest.s conftest.o conftest
2081         else
2082             gcc_cv_as_sparc_ua_pcrel_hidden="$gcc_cv_as_sparc_ua_pcrel"
2083         fi
2084     ])
2085     if test "x$gcc_cv_as_sparc_ua_pcrel_hidden" = xyes; then
2086         AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
2087                 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])
2088     fi
2089
2090     AC_CACHE_CHECK([for assembler offsetable %lo() support],
2091         gcc_cv_as_offsetable_lo10, [
2092         gcc_cv_as_offsetable_lo10=unknown
2093         if test "x$gcc_cv_as" != x; then
2094             # Check if assembler has offsetable %lo()
2095             echo "or %g1, %lo(ab) + 12, %g1" > conftest.s
2096             echo "or %g1, %lo(ab + 12), %g1" > conftest1.s
2097             if $gcc_cv_as -xarch=v9 -o conftest.o conftest.s \
2098                     > /dev/null 2>&1 &&
2099                $gcc_cv_as -xarch=v9 -o conftest1.o conftest1.s \
2100                     > /dev/null 2>&1; then
2101                 if cmp conftest.o conftest1.o > /dev/null 2>&1; then
2102                     gcc_cv_as_offsetable_lo10=no
2103                 else
2104                     gcc_cv_as_offsetable_lo10=yes
2105                 fi
2106             else
2107                 gcc_cv_as_offsetable_lo10=no
2108             fi
2109             rm -f conftest.s conftest.o conftest1.s conftest1.o
2110         fi
2111     ])
2112     if test "x$gcc_cv_as_offsetable_lo10" = xyes; then
2113         AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
2114             [Define if your assembler supports offsetable %lo().])
2115     fi
2116
2117     ;;
2118
2119 changequote(,)dnl
2120   i[34567]86-*-* | x86_64-*-*)
2121 changequote([,])dnl
2122     AC_MSG_CHECKING(assembler instructions)
2123     gcc_cv_as_instructions=
2124     if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
2125       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
2126         gcc_cv_as_instructions="filds fists"
2127       fi
2128     elif test x$gcc_cv_as != x; then
2129         set "filds fists" "filds mem; fists mem"
2130         while test $# -gt 0
2131         do
2132                 echo "$2" > conftest.s
2133                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2134                         gcc_cv_as_instructions=${gcc_cv_as_instructions}$1" "
2135                 fi
2136                 shift 2
2137         done
2138         rm -f conftest.s conftest.o
2139     fi
2140     if test x"$gcc_cv_as_instructions" != x; then
2141         AC_DEFINE_UNQUOTED(HAVE_GAS_`echo "$gcc_cv_as_instructions" | sed -e 's/ $//' | tr '[a-z ]' '[A-Z_]'`)
2142     fi
2143     AC_MSG_RESULT($gcc_cv_as_instructions)
2144
2145     AC_MSG_CHECKING(assembler GOTOFF in data directives)
2146     gcc_cv_as_gotoff_in_data=no
2147     if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x
2148     then
2149       if test "$gcc_cv_gas_major_version" -eq 2 \
2150          -a "$gcc_cv_gas_minor_version" -ge 11 \
2151          -o "$gcc_cv_gas_major_version" -gt 2; then
2152         gcc_cv_as_gotoff_in_data=yes
2153       fi
2154     elif test x$gcc_cv_as != x; then
2155         cat > conftest.s <<EOF
2156         .text
2157 .L0:
2158         nop
2159         .data
2160         .long .L0@GOTOFF
2161 EOF
2162         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2163           gcc_cv_as_gotoff_in_data=yes
2164         fi
2165     fi
2166     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
2167       [`if test $gcc_cv_as_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
2168       [Define true if the assembler supports '.long foo@GOTOFF'.])
2169     AC_MSG_RESULT($gcc_cv_as_gotoff_in_data)
2170     ;;
2171 esac
2172
2173 AC_MSG_CHECKING(assembler dwarf2 debug_line support)
2174 gcc_cv_as_dwarf2_debug_line=no
2175 # ??? Not all targets support dwarf2 debug_line, even within a version
2176 # of gas.  Moreover, we need to emit a valid instruction to trigger any
2177 # info to the output file.  So, as supported targets are added to gas 2.11,
2178 # add some instruction here to (also) show we expect this might work.
2179 # ??? Once 2.11 is released, probably need to add first known working
2180 # version to the per-target configury.
2181 case "$target" in
2182   i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* \
2183   | x86_64*-*-* | hppa*-*-* | arm*-*-* | strongarm*-*-* | xscale*-*-*)
2184     insn="nop"
2185     ;;
2186   ia64*-*-*)
2187     insn="nop 0"
2188     ;;
2189   esac
2190 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x;
2191 then
2192   if test "$gcc_cv_gas_major_version" -eq 2 \
2193         -a "$gcc_cv_gas_minor_version" -ge 11 \
2194         -o "$gcc_cv_gas_major_version" -gt 2 \
2195      && grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2196      && test x"$insn" != x ; then
2197     gcc_cv_as_dwarf2_debug_line="yes"
2198   fi
2199 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2200         echo '  .file 1 "conftest.s"' > conftest.s
2201         echo '  .loc 1 3 0' >> conftest.s
2202         echo "  $insn" >> conftest.s
2203         # ??? This fails with non-gnu grep.
2204         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
2205            && grep debug_line conftest.o > /dev/null 2>&1 ; then
2206                 # The .debug_line file table must be in the exact order that
2207                 # we specified the files, since these indices are also used
2208                 # by DW_AT_decl_file.  Approximate this test by testing if
2209                 # the assembler bitches if the same index is assigned twice.
2210                 echo '  .file 1 "foo.s"' > conftest.s
2211                 echo '  .file 1 "bar.s"' >> conftest.s
2212                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1
2213                 then
2214                   gcc_cv_as_dwarf2_debug_line="no"
2215                 else
2216                   gcc_cv_as_dwarf2_debug_line="yes"
2217                 fi
2218         fi
2219         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
2220 fi
2221 if test x"$gcc_cv_as_dwarf2_debug_line" = xyes; then
2222         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
2223 [Define if your assembler supports dwarf2 .file/.loc directives,
2224    and preserves file table indices exactly as given.])
2225 fi
2226 AC_MSG_RESULT($gcc_cv_as_dwarf2_debug_line)
2227
2228 AC_MSG_CHECKING(assembler --gdwarf2 support)
2229 gcc_cv_as_gdwarf2_flag=no
2230 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x;
2231 then
2232   if test "$gcc_cv_gas_major_version" -eq 2 \
2233         -a "$gcc_cv_gas_minor_version" -ge 11 \
2234         -o "$gcc_cv_gas_major_version" -gt 2 \
2235      && grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2236      && test x"$insn" != x ; then
2237     gcc_cv_as_gdwarf2_flag="yes"
2238   fi
2239 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2240         echo '' > conftest.s
2241         # ??? This fails with non-gnu grep.
2242         if $gcc_cv_as --gdwarf2 -o conftest.o conftest.s > /dev/null 2>&1
2243           then
2244           gcc_cv_as_gdwarf2_flag="yes"
2245         fi
2246         rm -f conftest.s conftest.o
2247 fi
2248 if test x"$gcc_cv_as_gdwarf2_flag" = xyes; then
2249         AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
2250 [Define if your assembler supports the --gdwarf2 option.])
2251 fi
2252 AC_MSG_RESULT($gcc_cv_as_gdwarf2_flag)
2253
2254 AC_MSG_CHECKING(assembler --gstabs support)
2255 gcc_cv_as_gstabs_flag=no
2256 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x;
2257 then
2258   if test "$gcc_cv_gas_major_version" -eq 2 \
2259         -a "$gcc_cv_gas_minor_version" -ge 11 \
2260         -o "$gcc_cv_gas_major_version" -gt 2 \
2261      && grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2262      && test x"$insn" != x ; then
2263     gcc_cv_as_gstabs_flag="yes"
2264   fi
2265 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2266         echo '' > conftest.s
2267         # ??? This fails with non-gnu grep.
2268         if $gcc_cv_as --gstabs -o conftest.o conftest.s > /dev/null 2>&1 ; then
2269           gcc_cv_as_gstabs_flag="yes"
2270         fi
2271         rm -f conftest.s conftest.o
2272 fi
2273 if test x"$gcc_cv_as_gstabs_flag" = xyes; then
2274         AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
2275 [Define if your assembler supports the --gstabs option.])
2276 fi
2277 AC_MSG_RESULT($gcc_cv_as_gstabs_flag)
2278
2279 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2280 gcc_cv_ld_ro_rw_mix=unknown
2281 if test x$gcc_cv_gld_major_version != x -a x$gcc_cv_gld_minor_version != x; then
2282   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 10 -o "$gcc_cv_gld_major_version" -gt 2 && grep 'EMUL = elf' ../ld/Makefile > /dev/null; then
2283     gcc_cv_ld_ro_rw_mix=read-write
2284   fi
2285 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2286   echo '.section "myfoosect", "a"' > conftest1.s
2287   echo '.section "myfoosect", "aw"' > conftest2.s
2288   echo '.byte 1' >> conftest2.s
2289   echo '.section "myfoosect", "a"' > conftest3.s
2290   echo '.byte 0' >> conftest3.s
2291   if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2292      && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2293      && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2294      && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2295         conftest2.o conftest3.o; then
2296     gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2297                          | grep -A1 myfoosect`
2298     if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2299       if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2300         gcc_cv_ld_ro_rw_mix=read-only
2301       else
2302         gcc_cv_ld_ro_rw_mix=read-write
2303       fi
2304     fi
2305   fi
2306 changequote(,)dnl
2307   rm -f conftest.* conftest[123].*
2308 changequote([,])dnl
2309 fi
2310 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2311         AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2312   [Define if your linker links a mix of read-only
2313    and read-write sections into a read-write section.])
2314 fi
2315 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2316
2317 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
2318 gcc_cv_ld_eh_frame_hdr=no
2319 if test x$gcc_cv_gld_major_version != x -a x$gcc_cv_gld_minor_version != x; then
2320   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
2321     gcc_cv_ld_eh_frame_hdr=yes
2322   fi
2323 elif test x$gcc_cv_ld != x; then
2324         # Check if linker supports --eh-frame-hdr option
2325         if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
2326                 gcc_cv_ld_eh_frame_hdr=yes
2327         fi
2328 fi
2329 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
2330         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
2331 [Define if your linker supports --eh-frame-hdr option.])
2332 fi
2333 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
2334
2335 # Miscellaneous target-specific checks.
2336 case "$target" in
2337   mips*-*-*)
2338     AC_MSG_CHECKING(whether libgloss uses STARTUP directives consistently)
2339     gcc_cv_mips_libgloss_startup=no
2340     gcc_cv_libgloss_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/libgloss
2341     if test "x$exec_prefix" = xNONE; then
2342       if test "x$prefix" = xNONE; then
2343         test_prefix=/usr/local
2344       else
2345         test_prefix=$prefix
2346       fi
2347     else
2348       test_prefix=$exec_prefix
2349     fi
2350     for f in $gcc_cv_libgloss_srcdir/mips/idt.ld $test_prefix/$target_alias/lib/idt.ld
2351     do
2352       if grep '^STARTUP' $f > /dev/null 2>&1; then
2353         gcc_cv_mips_libgloss_startup=yes
2354         break
2355       fi
2356     done
2357     if test x"$gcc_cv_mips_libgloss_startup" = xyes; then
2358       AC_DEFINE(HAVE_MIPS_LIBGLOSS_STARTUP_DIRECTIVES, 1,
2359         [Define if your MIPS libgloss linker scripts consistently include STARTUP directives.])
2360     fi
2361     AC_MSG_RESULT($gcc_cv_mips_libgloss_startup)
2362     ;;
2363 esac
2364
2365 if test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" ; then
2366   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include")
2367 fi
2368
2369 # Figure out what language subdirectories are present.
2370 # Look if the user specified --enable-languages="..."; if not, use
2371 # the environment variable $LANGUAGES if defined. $LANGUAGES might
2372 # go away some day.
2373 # NB:  embedded tabs in this IF block -- do not untabify
2374 if test x"${enable_languages+set}" != xset; then
2375         if test x"${LANGUAGES+set}" = xset; then
2376                 enable_languages="${LANGUAGES}"
2377                 AC_MSG_WARN([setting LANGUAGES is deprecated, use --enable-languages instead])
2378
2379         else
2380                 enable_languages=all
2381         fi
2382 else
2383         if test x"${enable_languages}" = x \
2384         || test x"${enable_languages}" = xyes;
2385         then
2386                 AC_MSG_ERROR([--enable-languages needs at least one language argument])
2387         fi
2388 fi
2389 enable_languages=`echo "${enable_languages}" | sed -e 's/[[     ,]][[   ,]]*/,/g' -e 's/,$//'`
2390
2391 # First scan to see if an enabled language requires some other language.
2392 # We assume that a given config-lang.in will list all the language
2393 # front ends it requires, even if some are required indirectly.
2394 for lang in ${srcdir}/*/config-lang.in ..
2395 do
2396    case $lang in
2397     ..)
2398        ;;
2399     # The odd quoting in the next line works around
2400     # an apparent bug in bash 1.12 on linux.
2401 changequote(,)dnl
2402     ${srcdir}/[*]/config-lang.in)
2403        ;;
2404     *)
2405        lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^      ]*\).*$,\1,p' $lang`
2406        this_lang_requires=`sed -n -e 's,^lang_requires=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^lang_requires=\([^    ]*\).*$,\1,p' $lang`
2407        for other in $this_lang_requires
2408        do
2409           case ,${enable_languages}, in
2410            *,$other,*)
2411               ;;
2412            *,all,*)
2413               ;;
2414            *,$lang_alias,*)
2415               enable_languages="$enable_languages,$other"
2416               ;;
2417           esac
2418        done
2419        ;;
2420 changequote([,])dnl
2421    esac
2422 done
2423
2424 expected_languages=`echo ,${enable_languages}, | sed -e 's:,: :g' -e 's:  *: :g' -e 's:  *: :g' -e 's:^ ::' -e 's: $::'`
2425 found_languages=
2426 subdirs=
2427 for lang in ${srcdir}/*/config-lang.in ..
2428 do
2429         case $lang in
2430         ..) ;;
2431         # The odd quoting in the next line works around
2432         # an apparent bug in bash 1.12 on linux.
2433 changequote(,)dnl
2434         ${srcdir}/[*]/config-lang.in) ;;
2435         *)
2436           lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
2437           this_lang_libs=`sed -n -e 's,^target_libs=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^target_libs=\([^         ]*\).*$,\1,p' $lang`
2438           build_by_default=`sed -n -e 's,^build_by_default=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^build_by_default=\([^     ]*\).*$,\1,p' $lang`
2439           if test "x$lang_alias" = x
2440           then
2441                 echo "$lang doesn't set \$language." 1>&2
2442                 exit 1
2443           fi
2444           case ${build_by_default},${enable_languages}, in
2445           *,$lang_alias,*) add_this_lang=yes ;;
2446           no,*) add_this_lang=no ;;
2447           *,all,*) add_this_lang=yes ;;
2448           *) add_this_lang=no ;;
2449           esac
2450           found_languages="${found_languages} ${lang_alias}"
2451           if test x"${add_this_lang}" = xyes; then
2452                 case $lang in
2453                     ${srcdir}/ada/config-lang.in)
2454                         if test x$have_gnat = xyes ; then
2455                                 subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2456                         fi
2457                         ;;
2458                     *)
2459                         subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2460                         ;;
2461                 esac
2462           fi
2463           ;;
2464 changequote([,])dnl
2465         esac
2466 done
2467
2468 missing_languages=
2469 for expected_language in ${expected_languages} ..
2470 do
2471     if test "${expected_language}" != ..; then
2472         missing_language="${expected_language}"
2473         if test "${expected_language}" = "c" \
2474            || test "${expected_language}" = "all"; then
2475                 missing_language=
2476         fi
2477         for found_language in ${found_languages} ..
2478         do
2479             if test "${found_language}" != ..; then
2480                 if test "${expected_language}" = "${found_language}"; then
2481                     missing_language=
2482                 fi
2483             fi
2484         done
2485         if test "x${missing_language}" != x; then
2486            missing_languages="${missing_languages} ${missing_language}"
2487         fi
2488     fi
2489 done
2490
2491 if test "x$missing_languages" != x; then
2492   AC_MSG_ERROR([
2493 The following requested languages were not found:${missing_languages}
2494 The following languages were available: c${found_languages}])
2495 fi
2496
2497 # Make gthr-default.h if we have a thread file.
2498 gthread_flags=
2499 if test $thread_file != single; then
2500     rm -f gthr-default.h
2501     echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h
2502     gthread_flags=-DHAVE_GTHR_DEFAULT
2503 fi
2504 AC_SUBST(gthread_flags)
2505
2506 # Find out what GC implementation we want, or may, use.
2507 AC_ARG_WITH(gc,
2508 [  --with-gc={simple,page} choose the garbage collection mechanism to use
2509                           with the compiler],
2510 [case "$withval" in
2511   simple | page)
2512     GGC=ggc-$withval
2513     ;;
2514   *)
2515     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
2516     ;;
2517 esac],
2518 [GGC=ggc-page])
2519 AC_SUBST(GGC)
2520 echo "Using $GGC for garbage collection."
2521
2522 # Use the system's zlib library.
2523 zlibdir=-L../zlib
2524 zlibinc="-I\$(srcdir)/../zlib"
2525 AC_ARG_WITH(system-zlib,
2526 [  --with-system-zlib      use installed libz],
2527 zlibdir=
2528 zlibinc=
2529 )
2530 AC_SUBST(zlibdir)
2531 AC_SUBST(zlibinc)
2532
2533 dnl Very limited version of automake's enable-maintainer-mode
2534
2535 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
2536   dnl maintainer-mode is disabled by default
2537   AC_ARG_ENABLE(maintainer-mode,
2538 [  --enable-maintainer-mode
2539                           enable make rules and dependencies not useful
2540                           (and sometimes confusing) to the casual installer],
2541       maintainer_mode=$enableval,
2542       maintainer_mode=no)
2543
2544 AC_MSG_RESULT($maintainer_mode)
2545
2546 if test "$maintainer_mode" = "yes"; then
2547   MAINT=''
2548 else
2549   MAINT='#'
2550 fi
2551 AC_SUBST(MAINT)dnl
2552
2553 # Make empty files to contain the specs and options for each language.
2554 # Then add #include lines to for a compiler that has specs and/or options.
2555
2556 lang_specs_files=
2557 lang_options_files=
2558 lang_tree_files=
2559 for subdir in . $subdirs
2560 do
2561         if test -f $srcdir/$subdir/lang-specs.h; then
2562             lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
2563         fi
2564         if test -f $srcdir/$subdir/lang-options.h; then
2565             lang_options_files="$lang_options_files $srcdir/$subdir/lang-options.h"
2566         fi
2567         if test -f $srcdir/$subdir/$subdir-tree.def; then
2568             lang_tree_files="$lang_tree_files $srcdir/$subdir/$subdir-tree.def"
2569         fi
2570 done
2571
2572 # These (without "all_") are set in each config-lang.in.
2573 # `language' must be a single word so is spelled singularly.
2574 all_languages=
2575 all_boot_languages=
2576 all_compilers=
2577 all_stagestuff=
2578 all_outputs='Makefile intl/Makefile fixinc/Makefile gccbug mklibgcc mkheaders'
2579 # List of language makefile fragments.
2580 all_lang_makefiles=
2581 # Files for gengtype
2582 all_gtfiles="$target_gtfiles"
2583 # Files for gengtype with language
2584 all_gtfiles_files_langs=
2585 all_gtfiles_files_files=
2586
2587 # Add the language fragments.
2588 # Languages are added via two mechanisms.  Some information must be
2589 # recorded in makefile variables, these are defined in config-lang.in.
2590 # We accumulate them and plug them into the main Makefile.
2591 # The other mechanism is a set of hooks for each of the main targets
2592 # like `clean', `install', etc.
2593
2594 language_fragments="Make-lang"
2595 language_hooks="Make-hooks"
2596
2597 for s in .. $subdirs
2598 do
2599         if test $s != ".."
2600         then
2601                 language=
2602                 boot_language=
2603                 compilers=
2604                 stagestuff=
2605                 outputs=
2606                 gtfiles=
2607                 . ${srcdir}/$s/config-lang.in
2608                 if test "x$language" = x
2609                 then
2610                         echo "${srcdir}/$s/config-lang.in doesn't set \$language." 1>&2
2611                         exit 1
2612                 fi
2613                 all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Make-lang.in"
2614                 if test -f ${srcdir}/$s/Makefile.in
2615                 then all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Makefile.in"
2616                 fi
2617                 all_languages="$all_languages $language"
2618                 if test "x$boot_language" = xyes
2619                 then
2620                         all_boot_languages="$all_boot_languages $language"
2621                 fi
2622                 all_compilers="$all_compilers $compilers"
2623                 all_stagestuff="$all_stagestuff $stagestuff"
2624                 all_outputs="$all_outputs $outputs"
2625                 all_gtfiles="$all_gtfiles $gtfiles"
2626                 for f in .. $gtfiles
2627                 do
2628                      if test $f != ".."
2629                      then
2630                          all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2631                          all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2632                      fi
2633                 done
2634         fi
2635 done
2636
2637 # Pick up gtfiles for c
2638 gtfiles=
2639 s="c"
2640 . ${srcdir}/c-config-lang.in
2641 all_gtfiles="$all_gtfiles $gtfiles"
2642 for f in .. $gtfiles
2643 do
2644      if test $f != ".."
2645      then
2646         all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2647         all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2648      fi
2649 done
2650
2651 check_languages=
2652 for language in .. $all_languages
2653 do
2654         if test $language != ".."
2655         then
2656                 check_languages="$check_languages check-$language"
2657         fi
2658 done
2659
2660 # Since we can't use `::' targets, we link each language in
2661 # with a set of hooks, reached indirectly via lang.${target}.
2662
2663 rm -f Make-hooks
2664 touch Make-hooks
2665 target_list="all.build all.cross start.encap rest.encap \
2666         info dvi generated-manpages \
2667         install-normal install-common install-info install-man \
2668         uninstall \
2669         mostlyclean clean distclean extraclean maintainer-clean \
2670         stage1 stage2 stage3 stage4"
2671 for t in $target_list
2672 do
2673         x=
2674         for lang in .. $all_languages
2675         do
2676                 if test $lang != ".."; then
2677                         x="$x $lang.$t"
2678                 fi
2679         done
2680         echo "lang.$t: $x" >> Make-hooks
2681 done
2682
2683 # Create .gdbinit.
2684
2685 echo "dir ." > .gdbinit
2686 echo "dir ${srcdir}" >> .gdbinit
2687 if test x$gdb_needs_out_file_path = xyes
2688 then
2689         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
2690 fi
2691 if test "x$subdirs" != x; then
2692         for s in $subdirs
2693         do
2694                 echo "dir ${srcdir}/$s" >> .gdbinit
2695         done
2696 fi
2697 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
2698
2699 # Define variables host_canonical and build_canonical
2700 # because some Cygnus local changes in the Makefile depend on them.
2701 build_canonical=${build}
2702 host_canonical=${host}
2703 target_subdir=
2704 if test "${host}" != "${target}" ; then
2705     target_subdir=${target_alias}/
2706 fi
2707 AC_SUBST(build_canonical)
2708 AC_SUBST(host_canonical)
2709 AC_SUBST(target_subdir)
2710
2711 # If $(exec_prefix) exists and is not the same as $(prefix), then compute an
2712 # absolute path for gcc_tooldir based on inserting the number of up-directory
2713 # movements required to get from $(exec_prefix) to $(prefix) into the basic
2714 # $(libsubdir)/@(unlibsubdir) based path.
2715 # Don't set gcc_tooldir to tooldir since that's only passed in by the toplevel
2716 # make and thus we'd get different behavior depending on where we built the
2717 # sources.
2718 if test x$exec_prefix = xNONE -o x$exec_prefix = x$prefix; then
2719     gcc_tooldir='$(libsubdir)/$(unlibsubdir)/../$(target_alias)'
2720 else
2721 changequote(<<, >>)dnl
2722 # An explanation of the sed strings:
2723 #  -e 's|^\$(prefix)||'   matches and eliminates 'prefix' from 'exec_prefix'
2724 #  -e 's|/$||'            match a trailing forward slash and eliminates it
2725 #  -e 's|^[^/]|/|'        forces the string to start with a forward slash (*)
2726 #  -e 's|/[^/]*|../|g'    replaces each occurrence of /<directory> with ../
2727 #
2728 # (*) Note this pattern overwrites the first character of the string
2729 # with a forward slash if one is not already present.  This is not a
2730 # problem because the exact names of the sub-directories concerned is
2731 # unimportant, just the number of them matters.
2732 #
2733 # The practical upshot of these patterns is like this:
2734 #
2735 #  prefix     exec_prefix        result
2736 #  ------     -----------        ------
2737 #   /foo        /foo/bar          ../
2738 #   /foo/       /foo/bar          ../
2739 #   /foo        /foo/bar/         ../
2740 #   /foo/       /foo/bar/         ../
2741 #   /foo        /foo/bar/ugg      ../../
2742 #
2743     dollar='$$'
2744     gcc_tooldir="\$(libsubdir)/\$(unlibsubdir)/\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/\$(dollar)||' -e 's|^[^/]|/|' -e 's|/[^/]*|../|g'\`\$(target_alias)"
2745 changequote([, ])dnl
2746 fi
2747 AC_SUBST(gcc_tooldir)
2748 AC_SUBST(dollar)
2749
2750 # Find a directory in which to install a shared libgcc.
2751
2752 AC_ARG_ENABLE(version-specific-runtime-libs,
2753 [  --enable-version-specific-runtime-libs
2754                           specify that runtime libraries should be
2755                           installed in a compiler-specific directory])
2756
2757 AC_ARG_WITH(slibdir,
2758 [  --with-slibdir=DIR      shared libraries in DIR [LIBDIR]],
2759 slibdir="$with_slibdir",
2760 if test "${enable_version_specific_runtime_libs+set}" = set; then
2761   slibdir='$(libsubdir)'
2762 elif test "$host" != "$target"; then
2763   slibdir='$(build_tooldir)/lib'
2764 else
2765   slibdir='$(libdir)'
2766 fi)
2767 AC_SUBST(slibdir)
2768
2769 objdir=`${PWDCMD-pwd}`
2770 AC_SUBST(objdir)
2771
2772 # Process the language and host/target makefile fragments.
2773 ${CONFIG_SHELL-/bin/sh} $srcdir/configure.frag $srcdir "$subdirs" "$dep_host_xmake_file" "$dep_tmake_file"
2774
2775 # Substitute configuration variables
2776 AC_SUBST(subdirs)
2777 AC_SUBST(srcdir)
2778 AC_SUBST(all_boot_languages)
2779 AC_SUBST(all_compilers)
2780 AC_SUBST(all_gtfiles)
2781 AC_SUBST(all_gtfiles_files_langs)
2782 AC_SUBST(all_gtfiles_files_files)
2783 AC_SUBST(all_lang_makefiles)
2784 AC_SUBST(all_languages)
2785 AC_SUBST(all_stagestuff)
2786 AC_SUBST(build_exeext)
2787 AC_SUBST(build_install_headers_dir)
2788 AC_SUBST(build_xm_file_list)
2789 AC_SUBST(build_xm_file)
2790 AC_SUBST(build_xm_defines)
2791 AC_SUBST(check_languages)
2792 AC_SUBST(cc_set_by_configure)
2793 AC_SUBST(quoted_cc_set_by_configure)
2794 AC_SUBST(cpp_install_dir)
2795 AC_SUBST(dep_host_xmake_file)
2796 AC_SUBST(dep_tmake_file)
2797 AC_SUBST(extra_headers_list)
2798 AC_SUBST(extra_objs)
2799 AC_SUBST(extra_parts)
2800 AC_SUBST(extra_passes)
2801 AC_SUBST(extra_programs)
2802 AC_SUBST(float_h_file)
2803 AC_SUBST(gcc_config_arguments)
2804 AC_SUBST(gcc_gxx_include_dir)
2805 AC_SUBST(libstdcxx_incdir)
2806 AC_SUBST(gcc_version)
2807 AC_SUBST(gcc_version_full)
2808 AC_SUBST(gcc_version_trigger)
2809 AC_SUBST(host_exeext)
2810 AC_SUBST(host_extra_gcc_objs)
2811 AC_SUBST(host_xm_file_list)
2812 AC_SUBST(host_xm_file)
2813 AC_SUBST(host_xm_defines)
2814 AC_SUBST(install)
2815 AC_SUBST(lang_options_files)
2816 AC_SUBST(lang_specs_files)
2817 AC_SUBST(lang_tree_files)
2818 AC_SUBST(local_prefix)
2819 AC_SUBST(md_file)
2820 AC_SUBST(objc_boehm_gc)
2821 AC_SUBST(out_file)
2822 AC_SUBST(out_object_file)
2823 AC_SUBST(stage_prefix_set_by_configure)
2824 AC_SUBST(quoted_stage_prefix_set_by_configure)
2825 AC_SUBST(symbolic_link)
2826 AC_SUBST(thread_file)
2827 AC_SUBST(tm_file_list)
2828 AC_SUBST(tm_file)
2829 AC_SUBST(tm_defines)
2830 AC_SUBST(tm_p_file_list)
2831 AC_SUBST(tm_p_file)
2832 AC_SUBST(xm_file)
2833 AC_SUBST(xm_defines)
2834 AC_SUBST(target_alias)
2835 AC_SUBST(c_target_objs)
2836 AC_SUBST(cxx_target_objs)
2837 AC_SUBST(target_cpu_default)
2838
2839 AC_SUBST_FILE(target_overrides)
2840 AC_SUBST_FILE(host_overrides)
2841 AC_SUBST_FILE(language_fragments)
2842 AC_SUBST_FILE(language_hooks)
2843
2844 # Echo that links are built
2845 if test x$host = x$target
2846 then
2847         str1="native "
2848 else
2849         str1="cross-"
2850         str2=" from $host"
2851 fi
2852
2853 if test x$host != x$build
2854 then
2855         str3=" on a $build system"
2856 fi
2857
2858 if test "x$str2" != x || test "x$str3" != x
2859 then
2860         str4=
2861 fi
2862
2863 echo "Links are now set up to build a ${str1}compiler for ${target}$str4" 1>&2
2864
2865 if test "x$str2" != x || test "x$str3" != x
2866 then
2867         echo " ${str2}${str3}." 1>&2
2868 fi
2869
2870 # Truncate the target if necessary
2871 if test x$host_truncate_target != x; then
2872         target=`echo $target | sed -e 's/\(..............\).*/\1/'`
2873 fi
2874
2875 # Configure the subdirectories
2876 # AC_CONFIG_SUBDIRS($subdirs)
2877
2878 # Create the Makefile
2879 # and configure language subdirectories
2880 AC_OUTPUT($all_outputs,
2881 [
2882 case x$CONFIG_HEADERS in
2883 xauto-host.h:config.in)
2884 echo > cstamp-h ;;
2885 esac
2886 # If the host supports symlinks, point stage[1234] at ../stage[1234] so
2887 # bootstrapping and the installation procedure can still use
2888 # CC="stage1/xgcc -Bstage1/".  If the host doesn't support symlinks,
2889 # FLAGS_TO_PASS has been modified to solve the problem there.
2890 # This is virtually a duplicate of what happens in configure.lang; we do
2891 # an extra check to make sure this only happens if ln -s can be used.
2892 if test "$symbolic_link" = "ln -s"; then
2893  for d in .. ${subdirs} fixinc ; do
2894    if test $d != ..; then
2895         STARTDIR=`${PWDCMD-pwd}`
2896         cd $d
2897         for t in stage1 stage2 stage3 stage4 include
2898         do
2899                 rm -f $t
2900                 $symbolic_link ../$t $t 2>/dev/null
2901         done
2902         cd $STARTDIR
2903    fi
2904  done
2905 else true ; fi
2906 # Avoid having to add intl to our include paths.
2907 if test -f intl/libintl.h; then
2908   echo creating libintl.h
2909   echo '#include "intl/libintl.h"' >libintl.h
2910 fi
2911 ],
2912 [subdirs='$subdirs'
2913 symbolic_link='$symbolic_link'
2914 ])