OSDN Git Service

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