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 # Restore CFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
 796 CFLAGS="$saved_CFLAGS"
 797
 798 gcc_AC_INITFINI_ARRAY
 799
 800 # mkdir takes a single argument on some systems.
 801 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
 802
 803 # File extensions
 804 manext='.1'
 805 objext='.o'
 806 AC_SUBST(manext)
 807 AC_SUBST(objext)
 808
 809 # With Setjmp/Longjmp based exception handling.
 810 AC_ARG_ENABLE(sjlj-exceptions,
 811 [  --enable-sjlj-exceptions
 812                           arrange to use setjmp/longjmp exception handling],
 813 [sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
 814 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
 815   [Define 0/1 to force the choice for exception handling model.])])
 816
 817 AC_CHECK_LIB(unwind, main, use_libunwind_default=yes, use_libunwind_default=no)
 818 # Use libunwind based exception handling.
 819 AC_ARG_ENABLE(libunwind-exceptions,
 820 [  --enable-libunwind-exceptions  force use libunwind for exceptions],
 821 use_libunwind_exceptions=$enableval,
 822 use_libunwind_exceptions=$use_libunwind_default)
 823 if test x"$use_libunwind_exceptions" = xyes; then
 824    AC_DEFINE(USE_LIBUNWIND_EXCEPTIONS, 1,
 825         [Define if gcc should use -lunwind.])
 826 fi
 827
 828 target_gtfiles=
 829 build_xm_file=
 830 build_xm_defines=
 831 build_install_headers_dir=install-headers-tar
 832 build_exeext=
 833 host_xm_file=
 834 host_xm_defines=
 835 host_xmake_file=
 836 host_truncate_target=
 837 host_exeext=
 838
 839 # Decode the host machine, then the target machine.
 840 # For the host machine, we save the xm_file variable as host_xm_file;
 841 # then we decode the target machine and forget everything else
 842 # that came from the host machine.
 843 for machine in $build $host $target; do
 844         . ${srcdir}/config.gcc
 845 done
 846
 847 extra_objs="${host_extra_objs} ${extra_objs}"
 848
 849 # Default the target-machine variables that were not explicitly set.
 850 if test x"$tm_file" = x
 851 then tm_file=$cpu_type/$cpu_type.h; fi
 852
 853 if test x"$extra_headers" = x
 854 then extra_headers=; fi
 855
 856 if test x$md_file = x
 857 then md_file=$cpu_type/$cpu_type.md; fi
 858
 859 if test x$out_file = x
 860 then out_file=$cpu_type/$cpu_type.c; fi
 861
 862 if test x"$tmake_file" = x
 863 then tmake_file=$cpu_type/t-$cpu_type
 864 fi
 865
 866 if test x"$dwarf2" = xyes
 867 then tm_file="$tm_file tm-dwarf2.h"
 868 fi
 869
 870 # Say what files are being used for the output code and MD file.
 871 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
 872 echo "Using \`$srcdir/config/$md_file' as machine description file."
 873
 874 # If any of the xm_file variables contain nonexistent files, warn
 875 # about them and drop them.
 876
 877 bx=
 878 for x in $build_xm_file; do
 879   if    test -f $srcdir/config/$x
 880   then      bx="$bx $x"
 881   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
 882   fi
 883 done
 884 build_xm_file="$bx"
 885
 886 hx=
 887 for x in $host_xm_file; do
 888   if    test -f $srcdir/config/$x
 889   then      hx="$hx $x"
 890   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
 891   fi
 892 done
 893 host_xm_file="$hx"
 894
 895 tx=
 896 for x in $xm_file; do
 897   if    test -f $srcdir/config/$x
 898   then      tx="$tx $x"
 899   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
 900   fi
 901 done
 902 xm_file="$tx"
 903
 904 count=a
 905 for f in $tm_file; do
 906         count=${count}x
 907 done
 908 if test $count = ax; then
 909         echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
 910 else
 911         echo "Using the following target machine macro files:"
 912         for f in $tm_file; do
 913                 echo "  $srcdir/config/$f"
 914         done
 915 fi
 916
 917 if test x$need_64bit_hwint = xyes; then
 918         AC_DEFINE(NEED_64BIT_HOST_WIDE_INT, 1,
 919 [Define to 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h).])
 920 fi
 921
 922 count=a
 923 for f in $host_xm_file; do
 924         count=${count}x
 925 done
 926 if test $count = a; then
 927         :
 928 elif test $count = ax; then
 929         echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
 930 else
 931         echo "Using the following host machine macro files:"
 932         for f in $host_xm_file; do
 933                 echo "  $srcdir/config/$f"
 934         done
 935 fi
 936
 937 if test "$host_xm_file" != "$build_xm_file"; then
 938         count=a
 939         for f in $build_xm_file; do
 940                 count=${count}x
 941         done
 942         if test $count = a; then
 943                 :
 944         elif test $count = ax; then
 945                 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
 946         else
 947                 echo "Using the following build machine macro files:"
 948                 for f in $build_xm_file; do
 949                         echo "  $srcdir/config/$f"
 950                 done
 951         fi
 952 fi
 953
 954 if test x$thread_file = x; then
 955         if test x$target_thread_file != x; then
 956                 thread_file=$target_thread_file
 957         else
 958                 thread_file='single'
 959         fi
 960 fi
 961
 962 # Look for a file containing extra machine modes.
 963 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
 964   extra_modes_file='$(srcdir)'/config/${extra_modes}
 965   AC_SUBST(extra_modes_file)
 966   AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "$extra_modes",
 967   [Define to the name of a file containing a list of extra machine modes
 968    for this architecture.])
 969   AC_DEFINE(EXTRA_CC_MODES, 1,
 970   [Define if the target architecture needs extra machine modes to represent
 971    the results of comparisons.])
 972 fi
 973
 974 # auto-host.h is the file containing items generated by autoconf and is
 975 # the first file included by config.h.
 976 # If host=build, it is correct to have bconfig include auto-host.h
 977 # as well.  If host!=build, we are in error and need to do more
 978 # work to find out the build config parameters.
 979 if test x$host = x$build
 980 then
 981         build_auto=auto-host.h
 982         FORBUILD=..
 983 else
 984         # We create a subdir, then run autoconf in the subdir.
 985         # To prevent recursion we set host and build for the new
 986         # invocation of configure to the build for this invocation
 987         # of configure.
 988         tempdir=build.$$
 989         rm -rf $tempdir
 990         mkdir $tempdir
 991         cd $tempdir
 992         case ${srcdir} in
 993         /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
 994         *) realsrcdir=../${srcdir};;
 995         esac
 996         saved_CFLAGS="${CFLAGS}"
 997         CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
 998         ${realsrcdir}/configure \
 999                 --target=$target_alias --host=$build_alias --build=$build_alias
1000         CFLAGS="${saved_CFLAGS}"
1001
1002         # We just finished tests for the build machine, so rename
1003         # the file auto-build.h in the gcc directory.
1004         mv auto-host.h ../auto-build.h
1005         cd ..
1006         rm -rf $tempdir
1007         build_auto=auto-build.h
1008         FORBUILD=../build-$build_alias
1009 fi
1010 AC_SUBST(FORBUILD)
1011
1012 tm_file="${tm_file} defaults.h"
1013 tm_p_file="${tm_p_file} tm-preds.h"
1014 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1015 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1016 xm_file="ansidecl.h ${xm_file}"
1017
1018 # Truncate the target if necessary
1019 if test x$host_truncate_target != x; then
1020         target=`echo $target | sed -e 's/\(..............\).*/\1/'`
1021 fi
1022
1023 # Get the version trigger filename from the toplevel
1024 if test "${with_gcc_version_trigger+set}" = set; then
1025         gcc_version_trigger=$with_gcc_version_trigger
1026 else
1027         gcc_version_trigger=${srcdir}/version.c
1028 fi
1029 changequote(,)dnl
1030 gcc_version_full=`grep version_string ${gcc_version_trigger} | sed -e 's/.*"\([^"]*\)".*/\1/'`
1031 gcc_version=`echo ${gcc_version_full} | sed -e 's/\([^ ]*\) .*/\1/'`
1032
1033 # Compile in configure arguments.
1034 if test -f configargs.h ; then
1035         # Being re-configured.
1036         gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1037         gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1038 else
1039         gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1040 fi
1041 cat > configargs.h <<EOF
1042 /* Generated automatically. */
1043 static const char configuration_arguments[] = "$gcc_config_arguments";
1044 static const char thread_model[] = "$thread_file";
1045 EOF
1046 changequote([,])dnl
1047
1048 # Internationalization
1049 PACKAGE=gcc
1050 VERSION="$gcc_version"
1051 AC_SUBST(PACKAGE)
1052 AC_SUBST(VERSION)
1053
1054 # Enable NLS support by default
1055 AC_ARG_ENABLE(nls,
1056   [  --enable-nls            use Native Language Support (default)],
1057   , enable_nls=yes)
1058
1059 # if cross compiling, disable NLS support.
1060 # It's not worth the trouble, at least for now.
1061
1062 if test "${build}" != "${host}" && test "x$enable_nls" = "xyes"; then
1063   AC_MSG_WARN(Disabling NLS support for canadian cross compiler.)
1064   enable_nls=no
1065 fi
1066
1067 AM_GNU_GETTEXT
1068
1069 # Windows32 Registry support for specifying GCC installation paths.
1070 AC_ARG_ENABLE(win32-registry,
1071 [  --disable-win32-registry
1072                           disable lookup of installation paths in the
1073                           Registry on Windows hosts
1074   --enable-win32-registry enable registry lookup (default)
1075   --enable-win32-registry=KEY
1076                           use KEY instead of GCC version as the last portion
1077                           of the registry key],,)
1078 case $host_os in
1079         win32 | pe | cygwin* | mingw32* | uwin*)
1080 AC_MSG_CHECKING(whether windows registry support is requested)
1081 if test "x$enable_win32_registry" != xno; then
1082   AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1083 [Define to 1 if installation paths should be looked up in Windows32
1084    Registry. Ignored on non windows32 hosts.])
1085   AC_MSG_RESULT(yes)
1086   AC_SEARCH_LIBS(RegOpenKeyExA, advapi32)
1087 else
1088   AC_MSG_RESULT(no)
1089 fi
1090
1091 # Check if user specified a different registry key.
1092 case "x${enable_win32_registry}" in
1093 x | xyes)
1094   # default.
1095   gcc_cv_win32_registry_key="$VERSION"
1096   ;;
1097 xno)
1098   # no registry lookup.
1099   gcc_cv_win32_registry_key=''
1100   ;;
1101 *)
1102   # user-specified key.
1103   gcc_cv_win32_registry_key="$enable_win32_registry"
1104   ;;
1105 esac
1106
1107 if test "x$enable_win32_registry" != xno; then
1108   AC_MSG_CHECKING(registry key on windows hosts)
1109   AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$gcc_cv_win32_registry_key",
1110         [Define to be the last portion of registry key on windows hosts.])
1111   AC_MSG_RESULT($gcc_cv_win32_registry_key)
1112 fi
1113 ;;
1114 esac
1115
1116 # Get an absolute path to the GCC top-level source directory
1117 holddir=`${PWDCMD-pwd}`
1118 cd $srcdir
1119 topdir=`${PWDCMD-pwd}`
1120 cd $holddir
1121
1122 # Conditionalize the makefile for this host machine.
1123 # Make-host contains the concatenation of all host makefile fragments
1124 # [there can be more than one].  This file is built by configure.frag.
1125 host_overrides=Make-host
1126 dep_host_xmake_file=
1127 for f in .. ${host_xmake_file}
1128 do
1129         if test -f ${srcdir}/config/$f
1130         then
1131                 dep_host_xmake_file="${dep_host_xmake_file} ${srcdir}/config/$f"
1132         fi
1133 done
1134
1135 # Conditionalize the makefile for this target machine.
1136 # Make-target contains the concatenation of all host makefile fragments
1137 # [there can be more than one].  This file is built by configure.frag.
1138 target_overrides=Make-target
1139 dep_tmake_file=
1140 for f in .. ${tmake_file}
1141 do
1142         if test -f ${srcdir}/config/$f
1143         then
1144                 dep_tmake_file="${dep_tmake_file} ${srcdir}/config/$f"
1145         fi
1146 done
1147
1148 # If the host doesn't support symlinks, modify CC in
1149 # FLAGS_TO_PASS so CC="stage1/xgcc -Bstage1/" works.
1150 # Otherwise, we can use "CC=$(CC)".
1151 rm -f symtest.tem
1152 if $symbolic_link $srcdir/gcc.c symtest.tem 2>/dev/null
1153 then
1154         cc_set_by_configure="\$(CC)"
1155         quoted_cc_set_by_configure="\$(CC)"
1156         stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1157         quoted_stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1158 else
1159         rm -f symtest.tem
1160         if cp -p $srcdir/gcc.c symtest.tem 2>/dev/null
1161         then
1162                 symbolic_link="cp -p"
1163         else
1164                 symbolic_link="cp"
1165         fi
1166         cc_set_by_configure="\`case '\$(CC)' in stage*) echo '\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\$(CC)';; esac\`"
1167         quoted_cc_set_by_configure="\\\`case '\\\$(CC)' in stage*) echo '\\\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(CC)';; esac\\\`"
1168         stage_prefix_set_by_configure="\`case '\$(STAGE_PREFIX)' in stage*) echo '\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\$(STAGE_PREFIX)';; esac\`"
1169         quoted_stage_prefix_set_by_configure="\\\`case '\\\$(STAGE_PREFIX)' in stage*) echo '\\\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(STAGE_PREFIX)';; esac\\\`"
1170 fi
1171 rm -f symtest.tem
1172
1173 out_object_file=`basename $out_file .c`.o
1174
1175 tm_file_list=
1176 for f in $tm_file; do
1177   case $f in
1178     ansidecl.h )
1179        tm_file_list="${tm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
1180     defaults.h )
1181        tm_file_list="${tm_file_list} \$(srcdir)/$f" ;;
1182     *) tm_file_list="${tm_file_list} \$(srcdir)/config/$f" ;;
1183   esac
1184 done
1185
1186 tm_p_file_list=
1187 for f in $tm_p_file; do
1188   case $f in
1189     tm-preds.h )
1190        tm_p_file_list="${tm_p_file_list} $f" ;;
1191     *) tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f" ;;
1192   esac
1193 done
1194
1195 host_xm_file_list=
1196 for f in $host_xm_file; do
1197   case $f in
1198     ansidecl.h )
1199        host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
1200     auto-host.h )
1201        host_xm_file_list="${host_xm_file_list} $f" ;;
1202     defaults.h )
1203        host_xm_file_list="${host_xm_file_list} \$(srcdir)/$f" ;;
1204     *) host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f" ;;
1205   esac
1206 done
1207
1208 build_xm_file_list=
1209 for f in $build_xm_file; do
1210   case $f in
1211     ansidecl.h )
1212        build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/ansidecl.h" ;;
1213     auto-build.h | auto-host.h )
1214        build_xm_file_list="${build_xm_file_list} $f" ;;
1215     defaults.h )
1216        host_xm_file_list="${host_xm_file_list} \$(srcdir)/$f" ;;
1217     *) build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f" ;;
1218   esac
1219 done
1220
1221 # Define macro CROSS_COMPILE in compilation if this is a cross-compiler.
1222 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1223 CROSS=                                          AC_SUBST(CROSS)
1224 ALL=all.internal                                AC_SUBST(ALL)
1225 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1226 if test x$host != x$target
1227 then
1228         CROSS="-DCROSS_COMPILE"
1229         ALL=all.cross
1230         SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1231         case "$host","$target" in
1232             i?86-*-*,x86_64-*-* \
1233             | powerpc*-*-*,powerpc64*-*-*)
1234                 CROSS="$CROSS -DNATIVE_CROSS" ;;
1235         esac
1236 fi
1237
1238 # If this is a cross-compiler that does not
1239 # have its own set of headers then define
1240 # inhibit_libc
1241
1242 # If this is using newlib, then define inhibit_libc in LIBGCC2_CFLAGS.
1243 # This prevents libgcc2 from containing any code which requires libc
1244 # support.
1245 inhibit_libc=
1246 if { test x$host != x$target && test "x$with_headers" = x &&
1247      test "x$with_sysroot" = x ; } || test x$with_newlib = xyes ; then
1248        inhibit_libc=-Dinhibit_libc
1249 fi
1250 AC_SUBST(inhibit_libc)
1251
1252 # When building gcc with a cross-compiler, we need to adjust things so
1253 # that the generator programs are still built with the native compiler.
1254 # Also, we cannot run fixincludes or fix-header.
1255
1256 # These are the normal (build=host) settings:
1257 BUILD_PREFIX=                   AC_SUBST(BUILD_PREFIX)
1258 BUILD_PREFIX_1=ignore-          AC_SUBST(BUILD_PREFIX_1)
1259 BUILD_CC='$(CC)'                AC_SUBST(BUILD_CC)
1260 BUILD_CFLAGS='$(ALL_CFLAGS)'    AC_SUBST(BUILD_CFLAGS)
1261
1262 STMP_FIXINC=stmp-fixinc         AC_SUBST(STMP_FIXINC)
1263 STMP_FIXPROTO=stmp-fixproto     AC_SUBST(STMP_FIXPROTO)
1264
1265 # And these apply if build != host.
1266 if test x$build != x$host
1267 then
1268     BUILD_PREFIX=build-
1269     BUILD_PREFIX_1=build-
1270     BUILD_CC='$(CC_FOR_BUILD)'
1271     BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD) $(XCFLAGS)'
1272
1273     STMP_FIXINC=
1274     STMP_FIXPROTO=
1275 fi
1276
1277 # Expand extra_headers to include complete path.
1278 # This substitutes for lots of t-* files.
1279 extra_headers_list=
1280 if test "x$extra_headers" = x
1281 then true
1282 else
1283         # Prepend ${srcdir}/config/${cpu_type}/ to every entry in extra_headers.
1284         for file in $extra_headers;
1285         do
1286                 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1287         done
1288 fi
1289
1290 if test x$use_collect2 = xno; then
1291         use_collect2=
1292 fi
1293
1294 # Add a definition of USE_COLLECT2 if system wants one.
1295 if test x$use_collect2 != x
1296 then
1297         host_xm_defines="${host_xm_defines} USE_COLLECT2"
1298         xm_defines="${xm_defines} USE_COLLECT2"
1299 fi
1300
1301 # If we have gas in the build tree, make a link to it.
1302 if test -f ../gas/Makefile; then
1303         rm -f as; $symbolic_link ../gas/as-new$host_exeext as$host_exeext 2>/dev/null
1304 fi
1305
1306 # If we have nm and objdump in the build tree, make a link to them.
1307 if test -f ../binutils/Makefile; then
1308         rm -f nm; $symbolic_link ../binutils/nm-new$host_exeext nm$host_exeext 2>/dev/null
1309         rm -f objdump; $symbolic_link ../binutils/objdump$host_exeext objdump$host_exeext 2>/dev/null
1310 fi
1311
1312 # If we have ld in the build tree, make a link to it.
1313 if test -f ../ld/Makefile; then
1314         rm -f collect-ld; $symbolic_link ../ld/ld-new$host_exeext collect-ld$host_exeext 2>/dev/null
1315 fi
1316
1317 # Figure out what assembler we will be using.
1318 AC_MSG_CHECKING(what assembler to use)
1319 gcc_cv_as=
1320 gcc_cv_gas_major_version=
1321 gcc_cv_gas_minor_version=
1322 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1323 gcc_cv_as_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1324 if test -x "$DEFAULT_ASSEMBLER"; then
1325         gcc_cv_as="$DEFAULT_ASSEMBLER"
1326 elif test -x "$AS"; then
1327         gcc_cv_as="$AS"
1328 elif test -x as$host_exeext; then
1329         # Build using assembler in the current directory.
1330         gcc_cv_as=./as$host_exeext
1331 elif test -f $gcc_cv_as_gas_srcdir/configure.in -a -f ../gas/Makefile; then
1332         # Single tree build which includes gas.
1333         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
1334         do
1335 changequote(,)dnl
1336                 gcc_cv_gas_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
1337 changequote([,])dnl
1338                 if test x$gcc_cv_gas_version != x; then
1339                         break
1340                 fi
1341         done
1342 changequote(,)dnl
1343         gcc_cv_gas_major_version=`expr "$gcc_cv_gas_version" : "VERSION=\([0-9]*\)"`
1344         gcc_cv_gas_minor_version=`expr "$gcc_cv_gas_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1345         gcc_cv_gas_patch_version=`expr "$gcc_cv_gas_version" : "VERSION=[0-9]*\.[0-9]*\.\([0-9]*\)"`
1346 changequote([,])dnl
1347 fi
1348
1349 if test "x$gcc_cv_as" = x; then
1350         # Search the same directories that the installed compiler will
1351         # search.  Else we may find the wrong assembler and lose.  If we
1352         # do not find a suitable assembler binary, then try the user's
1353         # path.
1354         #
1355         # Also note we have to check MD_EXEC_PREFIX before checking the
1356         # user's path.  Unfortunately, there is no good way to get at the
1357         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1358         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1359         # to be fixed as part of the make/configure rewrite too.
1360
1361         if test "x$exec_prefix" = xNONE; then
1362                 if test "x$prefix" = xNONE; then
1363                         test_prefix=/usr/local
1364                 else
1365                         test_prefix=$prefix
1366                 fi
1367         else
1368                 test_prefix=$exec_prefix
1369         fi
1370
1371         # If the loop below does not find an assembler, then use whatever
1372         # one we can find in the users's path.
1373         # user's path.
1374         if test "x$program_prefix" != xNONE; then
1375                 gcc_cv_as=${program_prefix}as$host_exeext
1376         else
1377                 gcc_cv_as=`echo as | sed ${program_transform_name}`$host_exeext
1378         fi
1379
1380         test_dirs="$test_prefix/lib/gcc-lib/$target_alias/$gcc_version \
1381                    $test_prefix/lib/gcc-lib/$target_alias \
1382                    /usr/lib/gcc/$target_alias/$gcc_version \
1383                    /usr/lib/gcc/$target_alias \
1384                    $test_prefix/$target_alias/bin/$target_alias/$gcc_version \
1385                    $test_prefix/$target_alias/bin"
1386
1387         if test x$host = x$target; then
1388             test_dirs="$test_dirs \
1389                    /usr/libexec \
1390                    /usr/ccs/gcc \
1391                    /usr/ccs/bin \
1392                    /udk/usr/ccs/bin \
1393                    /bsd43/usr/lib/cmplrs/cc \
1394                    /usr/cross64/usr/bin \
1395                    /usr/lib/cmplrs/cc \
1396                    /sysv/usr/lib/cmplrs/cc \
1397                    /svr4/usr/lib/cmplrs/cc \
1398                    /usr/bin"
1399         fi
1400
1401         for dir in $test_dirs; do
1402                 if test -x $dir/as$host_exeext; then
1403                         gcc_cv_as=$dir/as$host_exeext
1404                         break;
1405                 fi
1406         done
1407 fi
1408 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1409   AC_MSG_RESULT("newly built gas")
1410 else
1411   AC_MSG_RESULT($gcc_cv_as)
1412 fi
1413
1414 # Figure out what linker we will be using.
1415 AC_MSG_CHECKING(what linker to use)
1416 gcc_cv_ld=
1417 gcc_cv_gld_major_version=
1418 gcc_cv_gld_minor_version=
1419 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1420 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1421 if test -x "$DEFAULT_LINKER"; then
1422         gcc_cv_ld="$DEFAULT_LINKER"
1423 elif test -x "$LD"; then
1424         gcc_cv_ld="$LD"
1425 elif test -x ld$host_exeext; then
1426         # Build using linker in the current directory.
1427         gcc_cv_ld=./ld$host_exeext
1428 elif test -f $gcc_cv_ld_gld_srcdir/configure.in -a -f ../ld/Makefile; then
1429         # Single tree build which includes ld.
1430         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
1431         do
1432 changequote(,)dnl
1433                 gcc_cv_gld_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
1434 changequote([,])dnl
1435                 if test x$gcc_cv_gld_version != x; then
1436                         break
1437                 fi
1438         done
1439 changequote(,)dnl
1440         gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
1441         gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1442 changequote([,])dnl
1443 fi
1444
1445 if test "x$gcc_cv_ld" = x; then
1446         # Search the same directories that the installed compiler will
1447         # search.  Else we may find the wrong linker and lose.  If we
1448         # do not find a suitable linker binary, then try the user's
1449         # path.
1450         #
1451         # Also note we have to check MD_EXEC_PREFIX before checking the
1452         # user's path.  Unfortunately, there is no good way to get at the
1453         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1454         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1455         # to be fixed as part of the make/configure rewrite too.
1456
1457         if test "x$exec_prefix" = xNONE; then
1458                 if test "x$prefix" = xNONE; then
1459                         test_prefix=/usr/local
1460                 else
1461                         test_prefix=$prefix
1462                 fi
1463         else
1464                 test_prefix=$exec_prefix
1465         fi
1466
1467         # If the loop below does not find an linker, then use whatever
1468         # one we can find in the users's path.
1469         # user's path.
1470         if test "x$program_prefix" != xNONE; then
1471                 gcc_cv_ld=${program_prefix}ld$host_exeext
1472         else
1473                 gcc_cv_ld=`echo ld | sed ${program_transform_name}`$host_exeext
1474         fi
1475
1476         test_dirs="$test_prefix/lib/gcc-lib/$target_alias/$gcc_version \
1477                    $test_prefix/lib/gcc-lib/$target_alias \
1478                    /usr/lib/gcc/$target_alias/$gcc_version \
1479                    /usr/lib/gcc/$target_alias \
1480                    $test_prefix/$target_alias/bin/$target_alias/$gcc_version \
1481                    $test_prefix/$target_alias/bin"
1482
1483         if test x$host = x$target; then
1484             test_dirs="$test_dirs \
1485                    /usr/libexec \
1486                    /usr/ccs/gcc \
1487                    /usr/ccs/bin \
1488                    /udk/usr/ccs/bin \
1489                    /bsd43/usr/lib/cmplrs/cc \
1490                    /usr/cross64/usr/bin \
1491                    /usr/lib/cmplrs/cc \
1492                    /sysv/usr/lib/cmplrs/cc \
1493                    /svr4/usr/lib/cmplrs/cc \
1494                    /usr/bin"
1495         fi
1496
1497         for dir in $test_dirs; do
1498                 if test -x $dir/ld$host_exeext; then
1499                         gcc_cv_ld=$dir/ld$host_exeext
1500                         break;
1501                 fi
1502         done
1503 fi
1504 if test x$gcc_cv_gld_major_version != x -a x$gcc_cv_gld_minor_version != x; then
1505   AC_MSG_RESULT("newly built ld")
1506 else
1507   AC_MSG_RESULT($gcc_cv_ld)
1508 fi
1509
1510 # Figure out what nm we will be using.
1511 AC_MSG_CHECKING(what nm to use)
1512 if test -x nm$host_exeext; then
1513         gcc_cv_nm=./nm$host_exeext
1514 elif test "x$program_prefix" != xNONE; then
1515         gcc_cv_nm=${program_prefix}nm$host_exeext
1516 else
1517         gcc_cv_nm=`echo nm | sed ${program_transform_name}`$host_exeext
1518 fi
1519 AC_MSG_RESULT($gcc_cv_nm)
1520
1521 # Figure out what objdump we will be using.
1522 AC_MSG_CHECKING(what objdump to use)
1523 if test -x objdump$host_exeext; then
1524         gcc_cv_objdump=./objdump$host_exeext
1525 elif test "x$program_prefix" != xNONE; then
1526         gcc_cv_objdump=${program_prefix}objdump$host_exeext
1527 else
1528         gcc_cv_objdump=`echo objdump | sed ${program_transform_name}`$host_exeext
1529 fi
1530 AC_MSG_RESULT($gcc_cv_objdump)
1531
1532 # Figure out what assembler alignment features are present.
1533 AC_MSG_CHECKING(assembler alignment features)
1534 gcc_cv_as_alignment_features=none
1535 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1536         # Gas version 2.6 and later support for .balign and .p2align.
1537         # bytes to skip when using .p2align.
1538         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
1539                 gcc_cv_as_alignment_features=".balign and .p2align"
1540                 AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN)
1541         fi
1542         # Gas version 2.8 and later support specifying the maximum
1543         # bytes to skip when using .p2align.
1544         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
1545                 gcc_cv_as_alignment_features=".p2align including maximum skip"
1546                 AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN)
1547         fi
1548 elif test x$gcc_cv_as != x; then
1549         # Check if we have .balign and .p2align
1550         echo ".balign  4" > conftest.s
1551         echo ".p2align  2" >> conftest.s
1552         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1553                 gcc_cv_as_alignment_features=".balign and .p2align"
1554                 AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN)
1555         fi
1556         rm -f conftest.s conftest.o
1557         # Check if specifying the maximum bytes to skip when
1558         # using .p2align is supported.
1559         echo ".p2align 4,,7" > conftest.s
1560         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1561                 gcc_cv_as_alignment_features=".p2align including maximum skip"
1562                 AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN)
1563         fi
1564         rm -f conftest.s conftest.o
1565 fi
1566 AC_MSG_RESULT($gcc_cv_as_alignment_features)
1567
1568 AC_MSG_CHECKING(assembler subsection support)
1569 gcc_cv_as_subsections=no
1570 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1571   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
1572     gcc_cv_as_subsections="working .subsection -1"
1573   fi
1574 elif test x$gcc_cv_as != x; then
1575         # Check if we have .subsection
1576         echo ".subsection 1" > conftest.s
1577         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1578                 gcc_cv_as_subsections=".subsection"
1579                 if test x$gcc_cv_nm != x; then
1580                         cat > conftest.s <<EOF
1581 conftest_label1: .word 0
1582 .subsection -1
1583 conftest_label2: .word 0
1584 .previous
1585 EOF
1586                         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1587                                 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
1588                                 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
1589                                 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1; then
1590                                         :
1591                                 else
1592                                         gcc_cv_as_subsections="working .subsection -1"
1593                                 fi
1594                         fi
1595                 fi
1596         fi
1597         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1598 fi
1599 if test x"$gcc_cv_as_subsections" = x"working .subsection -1"; then
1600         AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
1601 [Define if your assembler supports .subsection and .subsection -1 starts
1602    emitting at the beginning of your section.])
1603 fi
1604 AC_MSG_RESULT($gcc_cv_as_subsections)
1605
1606 AC_MSG_CHECKING(assembler weak support)
1607 gcc_cv_as_weak=no
1608 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1609   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
1610     gcc_cv_as_weak="yes"
1611   fi
1612 elif test x$gcc_cv_as != x; then
1613         # Check if we have .weak
1614         echo "  .weak foobar" > conftest.s
1615         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1616                 gcc_cv_as_weak="yes"
1617         fi
1618         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1619 fi
1620 if test x"$gcc_cv_as_weak" = xyes; then
1621         AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])
1622 fi
1623 AC_MSG_RESULT($gcc_cv_as_weak)
1624
1625 AC_MSG_CHECKING(assembler hidden support)
1626 gcc_cv_as_hidden=no
1627 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1628   if test "$gcc_cv_gas_major_version" -eq 2     \
1629           -a "$gcc_cv_gas_minor_version" -eq 12 \
1630           -a "$gcc_cv_gas_patch_version" -ge 1  \
1631           -o "$gcc_cv_gas_major_version" -eq 2  \
1632           -a "$gcc_cv_gas_minor_version" -gt 12 \
1633           -o "$gcc_cv_gas_major_version" -gt 2  \
1634     && grep 'obj_format = elf' ../gas/Makefile > /dev/null; then
1635     gcc_cv_as_hidden="yes"
1636   fi
1637 elif test x$gcc_cv_as != x; then
1638         # Check if we have .hidden
1639         echo "  .hidden foobar" > conftest.s
1640         echo "foobar:" >> conftest.s
1641         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1642                 gcc_cv_as_hidden="yes"
1643         fi
1644         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1645
1646         # GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
1647         # This is irritatingly difficult to feature test for.  Look for
1648         # the date string after the version number.
1649         ld_ver=`$gcc_cv_ld --version 2>/dev/null | head -1`
1650         if echo "$ld_ver" | grep GNU > /dev/null; then
1651 changequote(,)dnl
1652                 ld_vers=`echo $ld_ver | sed -n 's,^.*[  ]\([0-9][0-9]*\.[0-9][0-9]*\(\|\.[0-9][0-9]*\)\)\([     ].*\|\)$,\1,p'`
1653                 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'`
1654                 if test 0"$ld_date" -lt 20020404; then
1655                         if test -n "$ld_date"; then
1656                                 # If there was date string, but was earlier than 2002-04-04, fail
1657                                 gcc_cv_as_hidden="no"
1658                         elif test -z "$ld_vers"; then
1659                                 # If there was no date string nor ld version number, something is wrong
1660                                 gcc_cv_as_hidden="no"
1661                         else
1662                                 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
1663                                 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
1664                                 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
1665                                 test -z "$ld_vers_patch" && ld_vers_patch=0
1666                                 if test "$ld_vers_major" -lt 2; then
1667                                         gcc_cv_as_hidden="no"
1668                                 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
1669                                         gcc_cv_as_hidden="no"
1670                                 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 \
1671                                           -a "$ld_vers_patch" -eq 0; then
1672                                         gcc_cv_as_hidden="no"
1673                                 fi
1674                         fi
1675                 fi
1676 changequote([,])dnl
1677         fi
1678 fi
1679 if test x"$gcc_cv_as_hidden" = xyes; then
1680         AC_DEFINE(HAVE_GAS_HIDDEN, 1,
1681                 [Define if your assembler supports .hidden.])
1682 fi
1683 AC_MSG_RESULT($gcc_cv_as_hidden)
1684 libgcc_visibility=$gcc_cv_as_hidden
1685 case "$target" in
1686   mips-sgi-irix6*)
1687     if test x"$gnu_ld_flag" = x"no"; then
1688       # Even if using gas with .hidden support, the resulting object files
1689       # cannot be linked with the IRIX 6 O32 linker.  With the N32 and
1690       # N64 linkers, the problem is that the linker refuses to accept
1691       # -call_shared (passed by default to the linker) and -r (used to
1692       # link the object file generated without .hidden directives with
1693       # one that hides symbols), so we also lose.
1694       libgcc_visibility=no
1695     fi
1696     ;;
1697 esac
1698 AC_SUBST(libgcc_visibility)
1699
1700 AC_MSG_CHECKING(assembler leb128 support)
1701 gcc_cv_as_leb128=no
1702 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1703   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
1704     gcc_cv_as_leb128="yes"
1705   fi
1706 elif test x$gcc_cv_as != x; then
1707         # Check if we have .[us]leb128, and support symbol arithmetic with it.
1708         cat > conftest.s <<EOF
1709         .data
1710         .uleb128 L2 - L1
1711 L1:
1712         .uleb128 1280
1713         .sleb128 -1010
1714 L2:
1715 EOF
1716         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1717                 gcc_cv_as_leb128="yes"
1718
1719                 # GAS versions before 2.11 do not support uleb128,
1720                 # despite appearing to.
1721                 # ??? There exists an elf-specific test that will crash
1722                 # the assembler.  Perhaps it's better to figure out whether
1723                 # arbitrary sections are supported and try the test.
1724                 as_ver=`$gcc_cv_as --version 2>/dev/null | head -1`
1725                 if echo "$as_ver" | grep GNU > /dev/null; then
1726 changequote(,)dnl
1727                         as_ver=`echo $as_ver | sed -e 's/GNU assembler \([0-9.][0-9.]*\).*/\1/'`
1728                         as_major=`echo $as_ver | sed 's/\..*//'`
1729                         as_minor=`echo $as_ver | sed 's/[^.]*\.\([0-9]*\).*/\1/'`
1730 changequote([,])dnl
1731                         if test $as_major -eq 2 -a $as_minor -lt 11; then
1732                                 gcc_cv_as_leb128="no"
1733                         fi
1734                 fi
1735         fi
1736         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
1737 fi
1738 if test x"$gcc_cv_as_leb128" = xyes; then
1739         AC_DEFINE(HAVE_AS_LEB128, 1,
1740                 [Define if your assembler supports .uleb128.])
1741 fi
1742 AC_MSG_RESULT($gcc_cv_as_leb128)
1743
1744 AC_MSG_CHECKING(assembler eh_frame optimization)
1745 gcc_cv_as_eh_frame=no
1746 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1747   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
1748     gcc_cv_as_eh_frame="yes"
1749   fi
1750 elif test x$gcc_cv_as != x; then
1751         # Check if this is GAS.
1752         as_ver=`$gcc_cv_as --version < /dev/null 2> /dev/null | head -1`
1753         rm -f a.out 2> /dev/null
1754         if echo "$as_ver" | grep GNU > /dev/null; then
1755                 # Versions up to and including 2.11.0 may mis-optimize
1756                 # .eh_frame data.  Try something.
1757                 cat > conftest.s <<EOF
1758         .text
1759 .LFB1:
1760         .4byte  0
1761 .L1:
1762         .4byte  0
1763 .LFE1:
1764         .section        .eh_frame,"aw",@progbits
1765 __FRAME_BEGIN__:
1766         .4byte  .LECIE1-.LSCIE1
1767 .LSCIE1:
1768         .4byte  0x0
1769         .byte   0x1
1770         .ascii "z\0"
1771         .byte   0x1
1772         .byte   0x78
1773         .byte   0x1a
1774         .byte   0x0
1775         .byte   0x4
1776         .4byte  1
1777         .p2align 1
1778 .LECIE1:
1779 .LSFDE1:
1780         .4byte  .LEFDE1-.LASFDE1
1781 .LASFDE1:
1782         .4byte  .LASFDE1-__FRAME_BEGIN__
1783         .4byte  .LFB1
1784         .4byte  .LFE1-.LFB1
1785         .byte   0x4
1786         .4byte  .LFE1-.LFB1
1787         .byte   0x4
1788         .4byte  .L1-.LFB1
1789 .LEFDE1:
1790 EOF
1791                 cat > conftest.lit <<EOF
1792  0000 10000000 00000000 017a0001 781a0004  .........z..x...
1793  0010 01000000 12000000 18000000 00000000  ................
1794  0020 08000000 04080000 0044               .........D
1795 EOF
1796                 cat > conftest.big <<EOF
1797  0000 00000010 00000000 017a0001 781a0004  .........z..x...
1798  0010 00000001 00000012 00000018 00000000  ................
1799  0020 00000008 04000000 0844               .........D
1800 EOF
1801                 # If the assembler didn't choke, and we can objdump,
1802                 # and we got the correct data, then succeed.
1803                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
1804                    && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
1805                       | tail -3 > conftest.got \
1806                    && { cmp conftest.lit conftest.got > /dev/null 2>&1 \
1807                         || cmp conftest.big conftest.got > /dev/null 2>&1; }
1808                 then
1809                         gcc_cv_as_eh_frame="yes"
1810                 else
1811                         gcc_cv_as_eh_frame="bad"
1812                         if $gcc_cv_as -o conftest.o --traditional-format /dev/null; then
1813                                 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
1814         [Define if your assembler mis-optimizes .eh_frame data.])
1815                         fi
1816                 fi
1817         fi
1818         rm -f conftest.*
1819 fi
1820 AC_MSG_RESULT($gcc_cv_as_eh_frame)
1821
1822 AC_MSG_CHECKING(assembler section merging support)
1823 gcc_cv_as_shf_merge=no
1824 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
1825   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
1826     gcc_cv_as_shf_merge=yes
1827   fi
1828 elif test x$gcc_cv_as != x; then
1829         # Check if we support SHF_MERGE sections
1830         echo '.section .rodata.str, "aMS", @progbits, 1' > conftest.s
1831         if $gcc_cv_as --fatal-warnings -o conftest.o conftest.s > /dev/null 2>&1; then
1832                 gcc_cv_as_shf_merge=yes
1833         fi
1834         rm -f conftest.s conftest.o
1835 fi
1836 if test x"$gcc_cv_as_shf_merge" = xyes; then
1837         AC_DEFINE(HAVE_GAS_SHF_MERGE, 1,
1838 [Define if your assembler supports marking sections with SHF_MERGE flag.])
1839 fi
1840 AC_MSG_RESULT($gcc_cv_as_shf_merge)
1841
1842 AC_MSG_CHECKING(assembler thread-local storage support)
1843 gcc_cv_as_tls=no
1844 conftest_s=
1845 tls_first_major=
1846 tls_first_minor=
1847 case "$target" in
1848 changequote(,)dnl
1849   alpha*-*-*)
1850     conftest_s='
1851         .section ".tdata","awT",@progbits
1852 foo:    .long   25
1853         .text
1854         ldq     $27,__tls_get_addr($29)         !literal!1
1855         lda     $16,foo($29)                    !tlsgd!1
1856         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
1857         ldq     $27,__tls_get_addr($29)         !literal!2
1858         lda     $16,foo($29)                    !tlsldm!2
1859         jsr     $26,($27),__tls_get_addr        !lituse_tlsldm!2
1860         ldq     $1,foo($29)                     !gotdtprel
1861         ldah    $2,foo($29)                     !dtprelhi
1862         lda     $3,foo($2)                      !dtprello
1863         lda     $4,foo($29)                     !dtprel
1864         ldq     $1,foo($29)                     !gottprel
1865         ldah    $2,foo($29)                     !tprelhi
1866         lda     $3,foo($2)                      !tprello
1867         lda     $4,foo($29)                     !tprel'
1868         tls_first_major=2
1869         tls_first_minor=13
1870         ;;
1871   i[34567]86-*-*)
1872 changequote([,])dnl
1873     conftest_s='
1874         .section ".tdata","awT",@progbits
1875 foo:    .long   25
1876         .text
1877         movl    %gs:0, %eax
1878         leal    foo@TLSGD(,%ebx,1), %eax
1879         leal    foo@TLSLDM(%ebx), %eax
1880         leal    foo@DTPOFF(%eax), %edx
1881         movl    foo@GOTTPOFF(%ebx), %eax
1882         subl    foo@GOTTPOFF(%ebx), %eax
1883         addl    foo@GOTNTPOFF(%ebx), %eax
1884         movl    foo@INDNTPOFF, %eax
1885         movl    $foo@TPOFF, %eax
1886         subl    $foo@TPOFF, %eax
1887         leal    foo@NTPOFF(%ecx), %eax'
1888         tls_first_major=2
1889         tls_first_minor=14
1890         ;;
1891   x86_64-*-*)
1892     conftest_s='
1893         .section ".tdata","awT",@progbits
1894 foo:    .long   25
1895         .text
1896         movq    %fs:0, %rax
1897         leaq    foo@TLSGD(%rip), %rdi
1898         leaq    foo@TLSLD(%rip), %rdi
1899         leaq    foo@DTPOFF(%rax), %rdx
1900         movq    foo@GOTTPOFF(%rip), %rax
1901         movq    $foo@TPOFF, %rax'
1902         tls_first_major=2
1903         tls_first_minor=14
1904         ;;
1905   ia64-*-*)
1906     conftest_s='
1907         .section ".tdata","awT",@progbits
1908 foo:    data8   25
1909         .text
1910         addl    r16 = @ltoff(@dtpmod(foo#)), gp
1911         addl    r17 = @ltoff(@dtprel(foo#)), gp
1912         addl    r18 = @ltoff(@tprel(foo#)), gp
1913         addl    r19 = @dtprel(foo#), gp
1914         adds    r21 = @dtprel(foo#), r13
1915         movl    r23 = @dtprel(foo#)
1916         addl    r20 = @tprel(foo#), gp
1917         adds    r22 = @tprel(foo#), r13
1918         movl    r24 = @tprel(foo#)'
1919         tls_first_major=2
1920         tls_first_minor=13
1921         ;;
1922 esac
1923 if test -z "$tls_first_major"; then
1924   :
1925 elif test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x
1926 then
1927   if test "$gcc_cv_gas_major_version" -eq "$tls_first_major" \
1928           -a "$gcc_cv_gas_minor_version" -ge "$tls_first_minor" \
1929           -o "$gcc_cv_gas_major_version" -gt "$tls_first_major"; then
1930     gcc_cv_as_tls=yes
1931   fi
1932 elif test x$gcc_cv_as != x; then
1933   echo "$conftest_s" > conftest.s
1934   if $gcc_cv_as --fatal-warnings -o conftest.o conftest.s > /dev/null 2>&1
1935   then
1936     gcc_cv_as_tls=yes
1937   fi
1938   rm -f conftest.s conftest.o
1939 fi
1940 if test "$gcc_cv_as_tls" = yes; then
1941   AC_DEFINE(HAVE_AS_TLS, 1,
1942             [Define if your assembler supports thread-local storage.])
1943 fi
1944 AC_MSG_RESULT($gcc_cv_as_tls)
1945
1946 case "$target" in
1947   # All TARGET_ABI_OSF targets.
1948   alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
1949     AC_CACHE_CHECK([assembler supports explicit relocations],
1950         gcc_cv_as_explicit_relocs, [
1951         gcc_cv_as_explicit_relocs=unknown
1952         if test x$gcc_cv_gas_major_version != x \
1953                 -a x$gcc_cv_gas_minor_version != x
1954         then
1955            if test "$gcc_cv_gas_major_version" -eq 2 \
1956                    -a "$gcc_cv_gas_minor_version" -ge 12 \
1957                    -o "$gcc_cv_gas_major_version" -gt 2; then
1958               gcc_cv_as_explicit_relocs=yes
1959            fi
1960         elif test x$gcc_cv_as != x; then
1961             cat > conftest.s << 'EOF'
1962         .set nomacro
1963         .text
1964         extbl   $3, $2, $3      !lituse_bytoff!1
1965         ldq     $2, a($29)      !literal!1
1966         ldq     $4, b($29)      !literal!2
1967         ldq_u   $3, 0($2)       !lituse_base!1
1968         ldq     $27, f($29)     !literal!5
1969         jsr     $26, ($27), f   !lituse_jsr!5
1970         ldah    $29, 0($26)     !gpdisp!3
1971         lda     $0, c($29)      !gprel
1972         ldah    $1, d($29)      !gprelhigh
1973         lda     $1, d($1)       !gprellow
1974         lda     $29, 0($29)     !gpdisp!3
1975 EOF
1976             if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1977                 gcc_cv_as_explicit_relocs=yes
1978             else
1979                 gcc_cv_as_explicit_relocs=no
1980             fi
1981             rm -f conftest.s conftest.o
1982         fi
1983     ])
1984     if test "x$gcc_cv_as_explicit_relocs" = xyes; then
1985         AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
1986                 [Define if your assembler supports explicit relocations.])
1987     fi
1988     ;;
1989   sparc*-*-*)
1990     AC_CACHE_CHECK([assembler .register pseudo-op support],
1991         gcc_cv_as_register_pseudo_op, [
1992         gcc_cv_as_register_pseudo_op=unknown
1993         if test x$gcc_cv_as != x; then
1994             # Check if we have .register
1995             echo ".register %g2, #scratch" > conftest.s
1996             if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
1997                 gcc_cv_as_register_pseudo_op=yes
1998             else
1999                 gcc_cv_as_register_pseudo_op=no
2000             fi
2001             rm -f conftest.s conftest.o
2002         fi
2003     ])
2004     if test "x$gcc_cv_as_register_pseudo_op" = xyes; then
2005         AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
2006                 [Define if your assembler supports .register.])
2007     fi
2008
2009     AC_CACHE_CHECK([assembler supports -relax],
2010         gcc_cv_as_relax_opt, [
2011         gcc_cv_as_relax_opt=unknown
2012         if test x$gcc_cv_as != x; then
2013             # Check if gas supports -relax
2014             echo ".text" > conftest.s
2015             if $gcc_cv_as -relax -o conftest.o conftest.s > /dev/null 2>&1; then
2016                 gcc_cv_as_relax_opt=yes
2017             else
2018                 gcc_cv_as_relax_opt=no
2019             fi
2020             rm -f conftest.s conftest.o
2021         fi
2022     ])
2023     if test "x$gcc_cv_as_relax_opt" = xyes; then
2024         AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
2025                 [Define if your assembler supports -relax option.])
2026     fi
2027
2028     AC_CACHE_CHECK([assembler and linker support unaligned pc related relocs],
2029         gcc_cv_as_sparc_ua_pcrel, [
2030         gcc_cv_as_sparc_ua_pcrel=unknown
2031         if test x$gcc_cv_as != x -a x$gcc_cv_ld != x; then
2032             gcc_cv_as_sparc_ua_pcrel=no
2033             echo ".text; foo: nop; .data; .align 4; .byte 0; .uaword %r_disp32(foo)" > conftest.s
2034             if $gcc_cv_as -K PIC -o conftest.o conftest.s > /dev/null 2>&1 \
2035                && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
2036                 gcc_cv_as_sparc_ua_pcrel=yes
2037             fi
2038             rm -f conftest.s conftest.o conftest
2039         fi
2040     ])
2041     if test "x$gcc_cv_as_sparc_ua_pcrel" = xyes; then
2042         AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
2043                 [Define if your assembler and linker support unaligned PC relative relocs.])
2044     fi
2045
2046     AC_CACHE_CHECK([assembler and linker support unaligned pc related relocs against hidden symbols],
2047         gcc_cv_as_sparc_ua_pcrel_hidden, [
2048         if test "x$gcc_cv_as_sparc_ua_pcrel" = xyes; then
2049             gcc_cv_as_sparc_ua_pcrel_hidden=unknown
2050             if test x$gcc_cv_objdump != x; then
2051                 gcc_cv_as_sparc_ua_pcrel_hidden=no
2052                 echo ".data; .align 4; .byte 0x31; .uaword %r_disp32(foo)" > conftest.s
2053                 echo ".byte 0x32, 0x33, 0x34; .global foo; .hidden foo" >> conftest.s
2054                 echo "foo: .skip 4" >> conftest.s
2055                 if $gcc_cv_as -K PIC -o conftest.o conftest.s > /dev/null 2>&1 \
2056                    && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
2057                    && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
2058                       | grep ' 31000000 07323334' > /dev/null 2>&1; then
2059                     if $gcc_cv_objdump -R conftest 2> /dev/null \
2060                        | grep 'DISP32' > /dev/null 2>&1; then
2061                         :
2062                     else
2063                         gcc_cv_as_sparc_ua_pcrel_hidden=yes
2064                     fi
2065                 fi
2066             fi
2067             rm -f conftest.s conftest.o conftest
2068         else
2069             gcc_cv_as_sparc_ua_pcrel_hidden="$gcc_cv_as_sparc_ua_pcrel"
2070         fi
2071     ])
2072     if test "x$gcc_cv_as_sparc_ua_pcrel_hidden" = xyes; then
2073         AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
2074                 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])
2075     fi
2076
2077     AC_CACHE_CHECK([for assembler offsetable %lo() support],
2078         gcc_cv_as_offsetable_lo10, [
2079         gcc_cv_as_offsetable_lo10=unknown
2080         if test "x$gcc_cv_as" != x; then
2081             # Check if assembler has offsetable %lo()
2082             echo "or %g1, %lo(ab) + 12, %g1" > conftest.s
2083             echo "or %g1, %lo(ab + 12), %g1" > conftest1.s
2084             if $gcc_cv_as -xarch=v9 -o conftest.o conftest.s \
2085                     > /dev/null 2>&1 &&
2086                $gcc_cv_as -xarch=v9 -o conftest1.o conftest1.s \
2087                     > /dev/null 2>&1; then
2088                 if cmp conftest.o conftest1.o > /dev/null 2>&1; then
2089                     gcc_cv_as_offsetable_lo10=no
2090                 else
2091                     gcc_cv_as_offsetable_lo10=yes
2092                 fi
2093             else
2094                 gcc_cv_as_offsetable_lo10=no
2095             fi
2096             rm -f conftest.s conftest.o conftest1.s conftest1.o
2097         fi
2098     ])
2099     if test "x$gcc_cv_as_offsetable_lo10" = xyes; then
2100         AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
2101             [Define if your assembler supports offsetable %lo().])
2102     fi
2103
2104     ;;
2105
2106 changequote(,)dnl
2107   i[34567]86-*-* | x86_64-*-*)
2108 changequote([,])dnl
2109     AC_MSG_CHECKING(assembler instructions)
2110     gcc_cv_as_instructions=
2111     if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x; then
2112       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
2113         gcc_cv_as_instructions="filds fists"
2114       fi
2115     elif test x$gcc_cv_as != x; then
2116         set "filds fists" "filds mem; fists mem"
2117         while test $# -gt 0
2118         do
2119                 echo "$2" > conftest.s
2120                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2121                         gcc_cv_as_instructions=${gcc_cv_as_instructions}$1" "
2122                 fi
2123                 shift 2
2124         done
2125         rm -f conftest.s conftest.o
2126     fi
2127     if test x"$gcc_cv_as_instructions" != x; then
2128         AC_DEFINE_UNQUOTED(HAVE_GAS_`echo "$gcc_cv_as_instructions" | sed -e 's/ $//' | tr '[a-z ]' '[A-Z_]'`)
2129     fi
2130     AC_MSG_RESULT($gcc_cv_as_instructions)
2131
2132     AC_MSG_CHECKING(assembler GOTOFF in data directives)
2133     gcc_cv_as_gotoff_in_data=no
2134     if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x
2135     then
2136       if test "$gcc_cv_gas_major_version" -eq 2 \
2137          -a "$gcc_cv_gas_minor_version" -ge 11 \
2138          -o "$gcc_cv_gas_major_version" -gt 2; then
2139         gcc_cv_as_gotoff_in_data=yes
2140       fi
2141     elif test x$gcc_cv_as != x; then
2142         cat > conftest.s <<EOF
2143         .text
2144 .L0:
2145         nop
2146         .data
2147         .long .L0@GOTOFF
2148 EOF
2149         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
2150           gcc_cv_as_gotoff_in_data=yes
2151         fi
2152     fi
2153     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
2154       [`if test $gcc_cv_as_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
2155       [Define true if the assembler supports '.long foo@GOTOFF'.])
2156     AC_MSG_RESULT($gcc_cv_as_gotoff_in_data)
2157     ;;
2158 esac
2159
2160 AC_MSG_CHECKING(assembler dwarf2 debug_line support)
2161 gcc_cv_as_dwarf2_debug_line=no
2162 # ??? Not all targets support dwarf2 debug_line, even within a version
2163 # of gas.  Moreover, we need to emit a valid instruction to trigger any
2164 # info to the output file.  So, as supported targets are added to gas 2.11,
2165 # add some instruction here to (also) show we expect this might work.
2166 # ??? Once 2.11 is released, probably need to add first known working
2167 # version to the per-target configury.
2168 case "$target" in
2169   i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* \
2170   | x86_64*-*-* | hppa*-*-* | arm*-*-* | strongarm*-*-* | xscale*-*-*)
2171     insn="nop"
2172     ;;
2173   ia64*-*-*)
2174     insn="nop 0"
2175     ;;
2176   esac
2177 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x;
2178 then
2179   if test "$gcc_cv_gas_major_version" -eq 2 \
2180         -a "$gcc_cv_gas_minor_version" -ge 11 \
2181         -o "$gcc_cv_gas_major_version" -gt 2 \
2182      && grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2183      && test x"$insn" != x ; then
2184     gcc_cv_as_dwarf2_debug_line="yes"
2185   fi
2186 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2187         echo '  .file 1 "conftest.s"' > conftest.s
2188         echo '  .loc 1 3 0' >> conftest.s
2189         echo "  $insn" >> conftest.s
2190         # ??? This fails with non-gnu grep.
2191         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
2192            && grep debug_line conftest.o > /dev/null 2>&1 ; then
2193                 # The .debug_line file table must be in the exact order that
2194                 # we specified the files, since these indices are also used
2195                 # by DW_AT_decl_file.  Approximate this test by testing if
2196                 # the assembler bitches if the same index is assigned twice.
2197                 echo '  .file 1 "foo.s"' > conftest.s
2198                 echo '  .file 1 "bar.s"' >> conftest.s
2199                 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1
2200                 then
2201                   gcc_cv_as_dwarf2_debug_line="no"
2202                 else
2203                   gcc_cv_as_dwarf2_debug_line="yes"
2204                 fi
2205         fi
2206         rm -f conftest.s conftest.o conftest.nm1 conftest.nm2
2207 fi
2208 if test x"$gcc_cv_as_dwarf2_debug_line" = xyes; then
2209         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
2210 [Define if your assembler supports dwarf2 .file/.loc directives,
2211    and preserves file table indices exactly as given.])
2212 fi
2213 AC_MSG_RESULT($gcc_cv_as_dwarf2_debug_line)
2214
2215 AC_MSG_CHECKING(assembler --gdwarf2 support)
2216 gcc_cv_as_gdwarf2_flag=no
2217 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x;
2218 then
2219   if test "$gcc_cv_gas_major_version" -eq 2 \
2220         -a "$gcc_cv_gas_minor_version" -ge 11 \
2221         -o "$gcc_cv_gas_major_version" -gt 2 \
2222      && grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2223      && test x"$insn" != x ; then
2224     gcc_cv_as_gdwarf2_flag="yes"
2225   fi
2226 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2227         echo '' > conftest.s
2228         # ??? This fails with non-gnu grep.
2229         if $gcc_cv_as --gdwarf2 -o conftest.o conftest.s > /dev/null 2>&1
2230           then
2231           gcc_cv_as_gdwarf2_flag="yes"
2232         fi
2233         rm -f conftest.s conftest.o
2234 fi
2235 if test x"$gcc_cv_as_gdwarf2_flag" = xyes; then
2236         AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
2237 [Define if your assembler supports the --gdwarf2 option.])
2238 fi
2239 AC_MSG_RESULT($gcc_cv_as_gdwarf2_flag)
2240
2241 AC_MSG_CHECKING(assembler --gstabs support)
2242 gcc_cv_as_gstabs_flag=no
2243 if test x$gcc_cv_gas_major_version != x -a x$gcc_cv_gas_minor_version != x;
2244 then
2245   if test "$gcc_cv_gas_major_version" -eq 2 \
2246         -a "$gcc_cv_gas_minor_version" -ge 11 \
2247         -o "$gcc_cv_gas_major_version" -gt 2 \
2248      && grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2249      && test x"$insn" != x ; then
2250     gcc_cv_as_gstabs_flag="yes"
2251   fi
2252 elif test x$gcc_cv_as != x -a x"$insn" != x ; then
2253         echo '' > conftest.s
2254         # ??? This fails with non-gnu grep.
2255         if $gcc_cv_as --gstabs -o conftest.o conftest.s > /dev/null 2>&1 ; then
2256           gcc_cv_as_gstabs_flag="yes"
2257         fi
2258         rm -f conftest.s conftest.o
2259 fi
2260 if test x"$gcc_cv_as_gstabs_flag" = xyes; then
2261         AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
2262 [Define if your assembler supports the --gstabs option.])
2263 fi
2264 AC_MSG_RESULT($gcc_cv_as_gstabs_flag)
2265
2266 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2267 gcc_cv_ld_ro_rw_mix=unknown
2268 if test x$gcc_cv_gld_major_version != x -a x$gcc_cv_gld_minor_version != x; then
2269   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
2270     gcc_cv_ld_ro_rw_mix=read-write
2271   fi
2272 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2273   echo '.section "myfoosect", "a"' > conftest1.s
2274   echo '.section "myfoosect", "aw"' > conftest2.s
2275   echo '.byte 1' >> conftest2.s
2276   echo '.section "myfoosect", "a"' > conftest3.s
2277   echo '.byte 0' >> conftest3.s
2278   if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2279      && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2280      && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2281      && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2282         conftest2.o conftest3.o; then
2283     gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2284                          | grep -A1 myfoosect`
2285     if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2286       if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2287         gcc_cv_ld_ro_rw_mix=read-only
2288       else
2289         gcc_cv_ld_ro_rw_mix=read-write
2290       fi
2291     fi
2292   fi
2293 changequote(,)dnl
2294   rm -f conftest.* conftest[123].*
2295 changequote([,])dnl
2296 fi
2297 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2298         AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2299   [Define if your linker links a mix of read-only
2300    and read-write sections into a read-write section.])
2301 fi
2302 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2303
2304 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
2305 gcc_cv_ld_eh_frame_hdr=no
2306 if test x$gcc_cv_gld_major_version != x -a x$gcc_cv_gld_minor_version != x; then
2307   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
2308     gcc_cv_ld_eh_frame_hdr=yes
2309   fi
2310 elif test x$gcc_cv_ld != x; then
2311         # Check if linker supports --eh-frame-hdr option
2312         if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
2313                 gcc_cv_ld_eh_frame_hdr=yes
2314         fi
2315 fi
2316 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
2317         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
2318 [Define if your linker supports --eh-frame-hdr option.])
2319 fi
2320 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
2321
2322 # Miscellaneous target-specific checks.
2323 case "$target" in
2324   mips*-*-*)
2325     AC_MSG_CHECKING(whether libgloss uses STARTUP directives consistently)
2326     gcc_cv_mips_libgloss_startup=no
2327     gcc_cv_libgloss_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/libgloss
2328     if test "x$exec_prefix" = xNONE; then
2329       if test "x$prefix" = xNONE; then
2330         test_prefix=/usr/local
2331       else
2332         test_prefix=$prefix
2333       fi
2334     else
2335       test_prefix=$exec_prefix
2336     fi
2337     for f in $gcc_cv_libgloss_srcdir/mips/idt.ld $test_prefix/$target_alias/lib/idt.ld
2338     do
2339       if grep '^STARTUP' $f > /dev/null 2>&1; then
2340         gcc_cv_mips_libgloss_startup=yes
2341         break
2342       fi
2343     done
2344     if test x"$gcc_cv_mips_libgloss_startup" = xyes; then
2345       AC_DEFINE(HAVE_MIPS_LIBGLOSS_STARTUP_DIRECTIVES, 1,
2346         [Define if your MIPS libgloss linker scripts consistently include STARTUP directives.])
2347     fi
2348     AC_MSG_RESULT($gcc_cv_mips_libgloss_startup)
2349     ;;
2350 esac
2351
2352 if test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" ; then
2353   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include")
2354 fi
2355
2356 # Figure out what language subdirectories are present.
2357 # Look if the user specified --enable-languages="..."; if not, use
2358 # the environment variable $LANGUAGES if defined. $LANGUAGES might
2359 # go away some day.
2360 # NB:  embedded tabs in this IF block -- do not untabify
2361 if test x"${enable_languages+set}" != xset; then
2362         if test x"${LANGUAGES+set}" = xset; then
2363                 enable_languages="${LANGUAGES}"
2364                 AC_MSG_WARN([setting LANGUAGES is deprecated, use --enable-languages instead])
2365
2366         else
2367                 enable_languages=all
2368         fi
2369 else
2370         if test x"${enable_languages}" = x \
2371         || test x"${enable_languages}" = xyes;
2372         then
2373                 AC_MSG_ERROR([--enable-languages needs at least one language argument])
2374         fi
2375 fi
2376 enable_languages=`echo "${enable_languages}" | sed -e 's/[[     ,]][[   ,]]*/,/g' -e 's/,$//'`
2377
2378 # First scan to see if an enabled language requires some other language.
2379 # We assume that a given config-lang.in will list all the language
2380 # front ends it requires, even if some are required indirectly.
2381 for lang in ${srcdir}/*/config-lang.in ..
2382 do
2383    case $lang in
2384     ..)
2385        ;;
2386     # The odd quoting in the next line works around
2387     # an apparent bug in bash 1.12 on linux.
2388 changequote(,)dnl
2389     ${srcdir}/[*]/config-lang.in)
2390        ;;
2391     *)
2392        lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^      ]*\).*$,\1,p' $lang`
2393        this_lang_requires=`sed -n -e 's,^lang_requires=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^lang_requires=\([^    ]*\).*$,\1,p' $lang`
2394        for other in $this_lang_requires
2395        do
2396           case ,${enable_languages}, in
2397            *,$other,*)
2398               ;;
2399            *,all,*)
2400               ;;
2401            *,$lang_alias,*)
2402               enable_languages="$enable_languages,$other"
2403               ;;
2404           esac
2405        done
2406        ;;
2407 changequote([,])dnl
2408    esac
2409 done
2410
2411 expected_languages=`echo ,${enable_languages}, | sed -e 's:,: :g' -e 's:  *: :g' -e 's:  *: :g' -e 's:^ ::' -e 's: $::'`
2412 found_languages=
2413 subdirs=
2414 for lang in ${srcdir}/*/config-lang.in ..
2415 do
2416         case $lang in
2417         ..) ;;
2418         # The odd quoting in the next line works around
2419         # an apparent bug in bash 1.12 on linux.
2420 changequote(,)dnl
2421         ${srcdir}/[*]/config-lang.in) ;;
2422         *)
2423           lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
2424           this_lang_libs=`sed -n -e 's,^target_libs=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^target_libs=\([^         ]*\).*$,\1,p' $lang`
2425           build_by_default=`sed -n -e 's,^build_by_default=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^build_by_default=\([^     ]*\).*$,\1,p' $lang`
2426           if test "x$lang_alias" = x
2427           then
2428                 echo "$lang doesn't set \$language." 1>&2
2429                 exit 1
2430           fi
2431           case ${build_by_default},${enable_languages}, in
2432           *,$lang_alias,*) add_this_lang=yes ;;
2433           no,*) add_this_lang=no ;;
2434           *,all,*) add_this_lang=yes ;;
2435           *) add_this_lang=no ;;
2436           esac
2437           found_languages="${found_languages} ${lang_alias}"
2438           if test x"${add_this_lang}" = xyes; then
2439                 case $lang in
2440                     ${srcdir}/ada/config-lang.in)
2441                         if test x$have_gnat = xyes ; then
2442                                 subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2443                         fi
2444                         ;;
2445                     *)
2446                         subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2447                         ;;
2448                 esac
2449           fi
2450           ;;
2451 changequote([,])dnl
2452         esac
2453 done
2454
2455 missing_languages=
2456 for expected_language in ${expected_languages} ..
2457 do
2458     if test "${expected_language}" != ..; then
2459         missing_language="${expected_language}"
2460         if test "${expected_language}" = "c" \
2461            || test "${expected_language}" = "all"; then
2462                 missing_language=
2463         fi
2464         for found_language in ${found_languages} ..
2465         do
2466             if test "${found_language}" != ..; then
2467                 if test "${expected_language}" = "${found_language}"; then
2468                     missing_language=
2469                 fi
2470             fi
2471         done
2472         if test "x${missing_language}" != x; then
2473            missing_languages="${missing_languages} ${missing_language}"
2474         fi
2475     fi
2476 done
2477
2478 if test "x$missing_languages" != x; then
2479   AC_MSG_ERROR([
2480 The following requested languages were not found:${missing_languages}
2481 The following languages were available: c${found_languages}])
2482 fi
2483
2484 # Make gthr-default.h if we have a thread file.
2485 gthread_flags=
2486 if test $thread_file != single; then
2487     rm -f gthr-default.h
2488     echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h
2489     gthread_flags=-DHAVE_GTHR_DEFAULT
2490 fi
2491 AC_SUBST(gthread_flags)
2492
2493 # Find out what GC implementation we want, or may, use.
2494 AC_ARG_WITH(gc,
2495 [  --with-gc={simple,page} choose the garbage collection mechanism to use
2496                           with the compiler],
2497 [case "$withval" in
2498   simple | page)
2499     GGC=ggc-$withval
2500     ;;
2501   *)
2502     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
2503     ;;
2504 esac],
2505 [GGC=ggc-page])
2506 AC_SUBST(GGC)
2507 echo "Using $GGC for garbage collection."
2508
2509 # Use the system's zlib library.
2510 zlibdir=-L../zlib
2511 zlibinc="-I\$(srcdir)/../zlib"
2512 AC_ARG_WITH(system-zlib,
2513 [  --with-system-zlib      use installed libz],
2514 zlibdir=
2515 zlibinc=
2516 )
2517 AC_SUBST(zlibdir)
2518 AC_SUBST(zlibinc)
2519
2520 dnl Very limited version of automake's enable-maintainer-mode
2521
2522 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
2523   dnl maintainer-mode is disabled by default
2524   AC_ARG_ENABLE(maintainer-mode,
2525 [  --enable-maintainer-mode
2526                           enable make rules and dependencies not useful
2527                           (and sometimes confusing) to the casual installer],
2528       maintainer_mode=$enableval,
2529       maintainer_mode=no)
2530
2531 AC_MSG_RESULT($maintainer_mode)
2532
2533 if test "$maintainer_mode" = "yes"; then
2534   MAINT=''
2535 else
2536   MAINT='#'
2537 fi
2538 AC_SUBST(MAINT)dnl
2539
2540 # Make empty files to contain the specs and options for each language.
2541 # Then add #include lines to for a compiler that has specs and/or options.
2542
2543 lang_specs_files=
2544 lang_options_files=
2545 lang_tree_files=
2546 for subdir in . $subdirs
2547 do
2548         if test -f $srcdir/$subdir/lang-specs.h; then
2549             lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
2550         fi
2551         if test -f $srcdir/$subdir/lang-options.h; then
2552             lang_options_files="$lang_options_files $srcdir/$subdir/lang-options.h"
2553         fi
2554         if test -f $srcdir/$subdir/$subdir-tree.def; then
2555             lang_tree_files="$lang_tree_files $srcdir/$subdir/$subdir-tree.def"
2556         fi
2557 done
2558
2559 # These (without "all_") are set in each config-lang.in.
2560 # `language' must be a single word so is spelled singularly.
2561 all_languages=
2562 all_boot_languages=
2563 all_compilers=
2564 all_stagestuff=
2565 all_outputs='Makefile intl/Makefile fixinc/Makefile gccbug mklibgcc mkheaders'
2566 # List of language makefile fragments.
2567 all_lang_makefiles=
2568 # Files for gengtype
2569 all_gtfiles="$target_gtfiles"
2570 # Files for gengtype with language
2571 all_gtfiles_files_langs=
2572 all_gtfiles_files_files=
2573
2574 # Add the language fragments.
2575 # Languages are added via two mechanisms.  Some information must be
2576 # recorded in makefile variables, these are defined in config-lang.in.
2577 # We accumulate them and plug them into the main Makefile.
2578 # The other mechanism is a set of hooks for each of the main targets
2579 # like `clean', `install', etc.
2580
2581 language_fragments="Make-lang"
2582 language_hooks="Make-hooks"
2583
2584 for s in .. $subdirs
2585 do
2586         if test $s != ".."
2587         then
2588                 language=
2589                 boot_language=
2590                 compilers=
2591                 stagestuff=
2592                 outputs=
2593                 gtfiles=
2594                 . ${srcdir}/$s/config-lang.in
2595                 if test "x$language" = x
2596                 then
2597                         echo "${srcdir}/$s/config-lang.in doesn't set \$language." 1>&2
2598                         exit 1
2599                 fi
2600                 all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Make-lang.in"
2601                 if test -f ${srcdir}/$s/Makefile.in
2602                 then all_lang_makefiles="$all_lang_makefiles ${srcdir}/$s/Makefile.in"
2603                 fi
2604                 all_languages="$all_languages $language"
2605                 if test "x$boot_language" = xyes
2606                 then
2607                         all_boot_languages="$all_boot_languages $language"
2608                 fi
2609                 all_compilers="$all_compilers $compilers"
2610                 all_stagestuff="$all_stagestuff $stagestuff"
2611                 all_outputs="$all_outputs $outputs"
2612                 all_gtfiles="$all_gtfiles $gtfiles"
2613                 for f in .. $gtfiles
2614                 do
2615                      if test $f != ".."
2616                      then
2617                          all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2618                          all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2619                      fi
2620                 done
2621         fi
2622 done
2623
2624 # Pick up gtfiles for c
2625 gtfiles=
2626 s="c"
2627 . ${srcdir}/c-config-lang.in
2628 all_gtfiles="$all_gtfiles $gtfiles"
2629 for f in .. $gtfiles
2630 do
2631      if test $f != ".."
2632      then
2633         all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2634         all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2635      fi
2636 done
2637
2638 check_languages=
2639 for language in .. $all_languages
2640 do
2641         if test $language != ".."
2642         then
2643                 check_languages="$check_languages check-$language"
2644         fi
2645 done
2646
2647 # Since we can't use `::' targets, we link each language in
2648 # with a set of hooks, reached indirectly via lang.${target}.
2649
2650 rm -f Make-hooks
2651 touch Make-hooks
2652 target_list="all.build all.cross start.encap rest.encap \
2653         info dvi generated-manpages \
2654         install-normal install-common install-info install-man \
2655         uninstall \
2656         mostlyclean clean distclean extraclean maintainer-clean \
2657         stage1 stage2 stage3 stage4"
2658 for t in $target_list
2659 do
2660         x=
2661         for lang in .. $all_languages
2662         do
2663                 if test $lang != ".."; then
2664                         x="$x $lang.$t"
2665                 fi
2666         done
2667         echo "lang.$t: $x" >> Make-hooks
2668 done
2669
2670 # Create .gdbinit.
2671
2672 echo "dir ." > .gdbinit
2673 echo "dir ${srcdir}" >> .gdbinit
2674 if test x$gdb_needs_out_file_path = xyes
2675 then
2676         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
2677 fi
2678 if test "x$subdirs" != x; then
2679         for s in $subdirs
2680         do
2681                 echo "dir ${srcdir}/$s" >> .gdbinit
2682         done
2683 fi
2684 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
2685
2686 # Define variables host_canonical and build_canonical
2687 # because some Cygnus local changes in the Makefile depend on them.
2688 build_canonical=${build}
2689 host_canonical=${host}
2690 target_subdir=
2691 if test "${host}" != "${target}" ; then
2692     target_subdir=${target_alias}/
2693 fi
2694 AC_SUBST(build_canonical)
2695 AC_SUBST(host_canonical)
2696 AC_SUBST(target_subdir)
2697
2698 # If $(exec_prefix) exists and is not the same as $(prefix), then compute an
2699 # absolute path for gcc_tooldir based on inserting the number of up-directory
2700 # movements required to get from $(exec_prefix) to $(prefix) into the basic
2701 # $(libsubdir)/@(unlibsubdir) based path.
2702 # Don't set gcc_tooldir to tooldir since that's only passed in by the toplevel
2703 # make and thus we'd get different behavior depending on where we built the
2704 # sources.
2705 if test x$exec_prefix = xNONE -o x$exec_prefix = x$prefix; then
2706     gcc_tooldir='$(libsubdir)/$(unlibsubdir)/../$(target_alias)'
2707 else
2708 changequote(<<, >>)dnl
2709 # An explanation of the sed strings:
2710 #  -e 's|^\$(prefix)||'   matches and eliminates 'prefix' from 'exec_prefix'
2711 #  -e 's|/$||'            match a trailing forward slash and eliminates it
2712 #  -e 's|^[^/]|/|'        forces the string to start with a forward slash (*)
2713 #  -e 's|/[^/]*|../|g'    replaces each occurrence of /<directory> with ../
2714 #
2715 # (*) Note this pattern overwrites the first character of the string
2716 # with a forward slash if one is not already present.  This is not a
2717 # problem because the exact names of the sub-directories concerned is
2718 # unimportant, just the number of them matters.
2719 #
2720 # The practical upshot of these patterns is like this:
2721 #
2722 #  prefix     exec_prefix        result
2723 #  ------     -----------        ------
2724 #   /foo        /foo/bar          ../
2725 #   /foo/       /foo/bar          ../
2726 #   /foo        /foo/bar/         ../
2727 #   /foo/       /foo/bar/         ../
2728 #   /foo        /foo/bar/ugg      ../../
2729 #
2730     dollar='$$'
2731     gcc_tooldir="\$(libsubdir)/\$(unlibsubdir)/\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/\$(dollar)||' -e 's|^[^/]|/|' -e 's|/[^/]*|../|g'\`\$(target_alias)"
2732 changequote([, ])dnl
2733 fi
2734 AC_SUBST(gcc_tooldir)
2735 AC_SUBST(dollar)
2736
2737 # Find a directory in which to install a shared libgcc.
2738
2739 AC_ARG_ENABLE(version-specific-runtime-libs,
2740 [  --enable-version-specific-runtime-libs
2741                           specify that runtime libraries should be
2742                           installed in a compiler-specific directory])
2743
2744 AC_ARG_WITH(slibdir,
2745 [  --with-slibdir=DIR      shared libraries in DIR [LIBDIR]],
2746 slibdir="$with_slibdir",
2747 if test "${enable_version_specific_runtime_libs+set}" = set; then
2748   slibdir='$(libsubdir)'
2749 elif test "$host" != "$target"; then
2750   slibdir='$(build_tooldir)/lib'
2751 else
2752   slibdir='$(libdir)'
2753 fi)
2754 AC_SUBST(slibdir)
2755
2756 objdir=`${PWDCMD-pwd}`
2757 AC_SUBST(objdir)
2758
2759 # Process the language and host/target makefile fragments.
2760 ${CONFIG_SHELL-/bin/sh} $srcdir/configure.frag $srcdir "$subdirs" "$dep_host_xmake_file" "$dep_tmake_file"
2761
2762 # Substitute configuration variables
2763 AC_SUBST(subdirs)
2764 AC_SUBST(srcdir)
2765 AC_SUBST(all_boot_languages)
2766 AC_SUBST(all_compilers)
2767 AC_SUBST(all_gtfiles)
2768 AC_SUBST(all_gtfiles_files_langs)
2769 AC_SUBST(all_gtfiles_files_files)
2770 AC_SUBST(all_lang_makefiles)
2771 AC_SUBST(all_languages)
2772 AC_SUBST(all_stagestuff)
2773 AC_SUBST(build_exeext)
2774 AC_SUBST(build_install_headers_dir)
2775 AC_SUBST(build_xm_file_list)
2776 AC_SUBST(build_xm_file)
2777 AC_SUBST(build_xm_defines)
2778 AC_SUBST(check_languages)
2779 AC_SUBST(cc_set_by_configure)
2780 AC_SUBST(quoted_cc_set_by_configure)
2781 AC_SUBST(cpp_install_dir)
2782 AC_SUBST(dep_host_xmake_file)
2783 AC_SUBST(dep_tmake_file)
2784 AC_SUBST(extra_headers_list)
2785 AC_SUBST(extra_objs)
2786 AC_SUBST(extra_parts)
2787 AC_SUBST(extra_passes)
2788 AC_SUBST(extra_programs)
2789 AC_SUBST(float_h_file)
2790 AC_SUBST(gcc_config_arguments)
2791 AC_SUBST(gcc_gxx_include_dir)
2792 AC_SUBST(libstdcxx_incdir)
2793 AC_SUBST(gcc_version)
2794 AC_SUBST(gcc_version_full)
2795 AC_SUBST(gcc_version_trigger)
2796 AC_SUBST(host_exeext)
2797 AC_SUBST(host_extra_gcc_objs)
2798 AC_SUBST(host_xm_file_list)
2799 AC_SUBST(host_xm_file)
2800 AC_SUBST(host_xm_defines)
2801 AC_SUBST(install)
2802 AC_SUBST(lang_options_files)
2803 AC_SUBST(lang_specs_files)
2804 AC_SUBST(lang_tree_files)
2805 AC_SUBST(local_prefix)
2806 AC_SUBST(md_file)
2807 AC_SUBST(objc_boehm_gc)
2808 AC_SUBST(out_file)
2809 AC_SUBST(out_object_file)
2810 AC_SUBST(stage_prefix_set_by_configure)
2811 AC_SUBST(quoted_stage_prefix_set_by_configure)
2812 AC_SUBST(symbolic_link)
2813 AC_SUBST(thread_file)
2814 AC_SUBST(tm_file_list)
2815 AC_SUBST(tm_file)
2816 AC_SUBST(tm_defines)
2817 AC_SUBST(tm_p_file_list)
2818 AC_SUBST(tm_p_file)
2819 AC_SUBST(xm_file)
2820 AC_SUBST(xm_defines)
2821 AC_SUBST(target_alias)
2822 AC_SUBST(c_target_objs)
2823 AC_SUBST(cxx_target_objs)
2824 AC_SUBST(target_cpu_default)
2825
2826 AC_SUBST_FILE(target_overrides)
2827 AC_SUBST_FILE(host_overrides)
2828 AC_SUBST_FILE(language_fragments)
2829 AC_SUBST_FILE(language_hooks)
2830
2831 # Echo that links are built
2832 if test x$host = x$target
2833 then
2834         str1="native "
2835 else
2836         str1="cross-"
2837         str2=" from $host"
2838 fi
2839
2840 if test x$host != x$build
2841 then
2842         str3=" on a $build system"
2843 fi
2844
2845 if test "x$str2" != x || test "x$str3" != x
2846 then
2847         str4=
2848 fi
2849
2850 echo "Links are now set up to build a ${str1}compiler for ${target}$str4" 1>&2
2851
2852 if test "x$str2" != x || test "x$str3" != x
2853 then
2854         echo " ${str2}${str3}." 1>&2
2855 fi
2856
2857 # Truncate the target if necessary
2858 if test x$host_truncate_target != x; then
2859         target=`echo $target | sed -e 's/\(..............\).*/\1/'`
2860 fi
2861
2862 # Configure the subdirectories
2863 # AC_CONFIG_SUBDIRS($subdirs)
2864
2865 # Create the Makefile
2866 # and configure language subdirectories
2867 AC_OUTPUT($all_outputs,
2868 [
2869 case x$CONFIG_HEADERS in
2870 xauto-host.h:config.in)
2871 echo > cstamp-h ;;
2872 esac
2873 # If the host supports symlinks, point stage[1234] at ../stage[1234] so
2874 # bootstrapping and the installation procedure can still use
2875 # CC="stage1/xgcc -Bstage1/".  If the host doesn't support symlinks,
2876 # FLAGS_TO_PASS has been modified to solve the problem there.
2877 # This is virtually a duplicate of what happens in configure.lang; we do
2878 # an extra check to make sure this only happens if ln -s can be used.
2879 if test "$symbolic_link" = "ln -s"; then
2880  for d in .. ${subdirs} fixinc ; do
2881    if test $d != ..; then
2882         STARTDIR=`${PWDCMD-pwd}`
2883         cd $d
2884         for t in stage1 stage2 stage3 stage4 include
2885         do
2886                 rm -f $t
2887                 $symbolic_link ../$t $t 2>/dev/null
2888         done
2889         cd $STARTDIR
2890    fi
2891  done
2892 else true ; fi
2893 # Avoid having to add intl to our include paths.
2894 if test -f intl/libintl.h; then
2895   echo creating libintl.h
2896   echo '#include "intl/libintl.h"' >libintl.h
2897 fi
2898 ],
2899 [subdirs='$subdirs'
2900 symbolic_link='$symbolic_link'
2901 ])