OSDN Git Service

Fix NM/AR propagation from toplevel for recursive makes.
[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_SUBST(PACKAGE)
1396 AC_SUBST(VERSION)
1397
1398 ZW_GNU_GETTEXT_SISTER_DIR
1399
1400 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1401 # -liconv on the link line twice.
1402 case "$LIBINTL" in *$LIBICONV*)
1403         LIBICONV= ;;
1404 esac
1405
1406 # Windows32 Registry support for specifying GCC installation paths.
1407 AC_ARG_ENABLE(win32-registry,
1408 [  --disable-win32-registry
1409                           disable lookup of installation paths in the
1410                           Registry on Windows hosts
1411   --enable-win32-registry enable registry lookup (default)
1412   --enable-win32-registry=KEY
1413                           use KEY instead of GCC version as the last portion
1414                           of the registry key],,)
1415 case $host_os in
1416         win32 | pe | cygwin* | mingw32* | uwin*)
1417 AC_MSG_CHECKING(whether windows registry support is requested)
1418 if test "x$enable_win32_registry" != xno; then
1419   AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1420 [Define to 1 if installation paths should be looked up in Windows32
1421    Registry. Ignored on non windows32 hosts.])
1422   AC_MSG_RESULT(yes)
1423   AC_SEARCH_LIBS(RegOpenKeyExA, advapi32)
1424 else
1425   AC_MSG_RESULT(no)
1426 fi
1427
1428 # Check if user specified a different registry key.
1429 case "x${enable_win32_registry}" in
1430 x | xyes)
1431   # default.
1432   gcc_cv_win32_registry_key="$VERSION"
1433   ;;
1434 xno)
1435   # no registry lookup.
1436   gcc_cv_win32_registry_key=''
1437   ;;
1438 *)
1439   # user-specified key.
1440   gcc_cv_win32_registry_key="$enable_win32_registry"
1441   ;;
1442 esac
1443
1444 if test "x$enable_win32_registry" != xno; then
1445   AC_MSG_CHECKING(registry key on windows hosts)
1446   AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$gcc_cv_win32_registry_key",
1447         [Define to be the last portion of registry key on windows hosts.])
1448   AC_MSG_RESULT($gcc_cv_win32_registry_key)
1449 fi
1450 ;;
1451 esac
1452
1453 # Get an absolute path to the GCC top-level source directory
1454 holddir=`${PWDCMD-pwd}`
1455 cd $srcdir
1456 topdir=`${PWDCMD-pwd}`
1457 cd $holddir
1458
1459 # Conditionalize the makefile for this host machine.
1460 xmake_file=
1461 for f in ${host_xmake_file}
1462 do
1463         if test -f ${srcdir}/config/$f
1464         then
1465                 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1466         fi
1467 done
1468
1469 # Conditionalize the makefile for this target machine.
1470 tmake_file_=
1471 for f in ${tmake_file}
1472 do
1473         if test -f ${srcdir}/config/$f
1474         then
1475                 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1476         fi
1477 done
1478 tmake_file="${tmake_file_}"
1479
1480 symbolic_link='ln -s'
1481
1482 # If the host doesn't support symlinks, modify CC in
1483 # FLAGS_TO_PASS so CC="stage1/xgcc -Bstage1/" works.
1484 # Otherwise, we can use "CC=$(CC)".
1485 rm -f symtest.tem
1486 if $symbolic_link $srcdir/gcc.c symtest.tem 2>/dev/null
1487 then
1488         cc_set_by_configure="\$(CC)"
1489         quoted_cc_set_by_configure="\$(CC)"
1490         stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1491         quoted_stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1492 else
1493         rm -f symtest.tem
1494         if cp -p $srcdir/gcc.c symtest.tem 2>/dev/null
1495         then
1496                 symbolic_link="cp -p"
1497         else
1498                 symbolic_link="cp"
1499         fi
1500         cc_set_by_configure="\`case '\$(CC)' in stage*) echo '\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\$(CC)';; esac\`"
1501         quoted_cc_set_by_configure="\\\`case '\\\$(CC)' in stage*) echo '\\\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(CC)';; esac\\\`"
1502         stage_prefix_set_by_configure="\`case '\$(STAGE_PREFIX)' in stage*) echo '\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\$(STAGE_PREFIX)';; esac\`"
1503         quoted_stage_prefix_set_by_configure="\\\`case '\\\$(STAGE_PREFIX)' in stage*) echo '\\\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(STAGE_PREFIX)';; esac\\\`"
1504 fi
1505 rm -f symtest.tem
1506
1507 out_object_file=`basename $out_file .c`.o
1508
1509 tm_file_list=
1510 tm_include_list=
1511 for f in $tm_file; do
1512   case $f in
1513     defaults.h )
1514        tm_file_list="${tm_file_list} \$(srcdir)/$f"
1515        tm_include_list="${tm_include_list} $f"
1516        ;;
1517     * )
1518        tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1519        tm_include_list="${tm_include_list} config/$f"
1520        ;;
1521   esac
1522 done
1523
1524 tm_p_file_list=
1525 tm_p_include_list=
1526 for f in $tm_p_file; do
1527   case $f in
1528     tm-preds.h )
1529        tm_p_file_list="${tm_p_file_list} $f"
1530        tm_p_include_list="${tm_p_include_list} $f"
1531        ;;
1532     * )
1533        tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1534        tm_p_include_list="${tm_p_include_list} config/$f"
1535   esac
1536 done
1537
1538 xm_file_list=
1539 xm_include_list=
1540 for f in $xm_file; do
1541   case $f in
1542     ansidecl.h )
1543        xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1544        xm_include_list="${xm_include_list} $f"
1545        ;;
1546     auto-host.h )
1547        xm_file_list="${xm_file_list} $f"
1548        xm_include_list="${xm_include_list} $f"
1549        ;;
1550     * )
1551        xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1552        xm_include_list="${xm_include_list} config/$f"
1553        ;;
1554   esac
1555 done
1556
1557 host_xm_file_list=
1558 host_xm_include_list=
1559 for f in $host_xm_file; do
1560   case $f in
1561     ansidecl.h )
1562        host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1563        host_xm_include_list="${host_xm_include_list} $f"
1564        ;;
1565     auto-host.h )
1566        host_xm_file_list="${host_xm_file_list} $f"
1567        host_xm_include_list="${host_xm_include_list} $f"
1568        ;;
1569     * )
1570        host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1571        host_xm_include_list="${host_xm_include_list} config/$f"
1572        ;;
1573   esac
1574 done
1575
1576 build_xm_file_list=
1577 for f in $build_xm_file; do
1578   case $f in
1579     ansidecl.h )
1580        build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1581        build_xm_include_list="${build_xm_include_list} $f"
1582        ;;
1583     auto-build.h | auto-host.h )
1584        build_xm_file_list="${build_xm_file_list} $f"
1585        build_xm_include_list="${build_xm_include_list} $f"
1586        ;;
1587     * )
1588        build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1589        build_xm_include_list="${build_xm_include_list} config/$f"
1590        ;;
1591   esac
1592 done
1593
1594 # Define macro CROSS_COMPILE in compilation if this is a cross-compiler.
1595 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1596 CROSS=                                          AC_SUBST(CROSS)
1597 ALL=all.internal                                AC_SUBST(ALL)
1598 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1599 if test x$host != x$target
1600 then
1601         CROSS="-DCROSS_COMPILE"
1602         ALL=all.cross
1603         SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1604         case "$host","$target" in
1605         # Darwin crosses can use the host system's libraries and headers,
1606         # because of the fat library support.  Of course, it must be the
1607         # same version of Darwin on both sides.  Allow the user to
1608         # just say --target=foo-darwin without a version number to mean
1609         # "the version on this system".
1610             *-*-darwin*,*-*-darwin*)
1611                 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1612                 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1613                 if test $hostos = $targetos -o $targetos = darwin ; then
1614                     CROSS=
1615                     SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1616                     with_headers=yes
1617                 fi
1618                 ;;
1619
1620             i?86-*-*,x86_64-*-* \
1621             | powerpc*-*-*,powerpc64*-*-*)
1622                 CROSS="$CROSS -DNATIVE_CROSS" ;;
1623         esac
1624 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1625         # This is just $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR)
1626         SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1627 fi
1628
1629 # If this is a cross-compiler that does not
1630 # have its own set of headers then define
1631 # inhibit_libc
1632
1633 # If this is using newlib, without having the headers available now,
1634 # then define inhibit_libc in LIBGCC2_CFLAGS.
1635 # This prevents libgcc2 from containing any code which requires libc
1636 # support.
1637 inhibit_libc=
1638 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1639        test x$with_newlib = xyes ; } &&
1640      { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1641        inhibit_libc=-Dinhibit_libc
1642 fi
1643 AC_SUBST(inhibit_libc)
1644
1645 # When building gcc with a cross-compiler, we need to adjust things so
1646 # that the generator programs are still built with the native compiler.
1647 # Also, we cannot run fixincludes or fix-header.
1648
1649 # These are the normal (build=host) settings:
1650 BUILD_PREFIX=                   AC_SUBST(BUILD_PREFIX)
1651 BUILD_PREFIX_1=ignore-          AC_SUBST(BUILD_PREFIX_1)
1652 CC_FOR_BUILD='$(CC)'            AC_SUBST(CC_FOR_BUILD)
1653 BUILD_CFLAGS='$(ALL_CFLAGS)'    AC_SUBST(BUILD_CFLAGS)
1654
1655 STMP_FIXINC=stmp-fixinc         AC_SUBST(STMP_FIXINC)
1656
1657 # Possibly disable fixproto, on a per-target basis.
1658 case ${use_fixproto} in
1659   no)
1660     STMP_FIXPROTO=
1661     ;;
1662   yes)
1663     STMP_FIXPROTO=stmp-fixproto
1664     ;;
1665 esac
1666 AC_SUBST(STMP_FIXPROTO)
1667
1668 # And these apply if build != host, or we are generating coverage data
1669 if test x$build != x$host || test "x$coverage_flags" != x
1670 then
1671     BUILD_PREFIX=build-
1672     BUILD_PREFIX_1=build-
1673     BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1674
1675     if test "x$TARGET_SYSTEM_ROOT" = x; then
1676         STMP_FIXINC=
1677         STMP_FIXPROTO=
1678     fi
1679 fi
1680
1681 # Expand extra_headers to include complete path.
1682 # This substitutes for lots of t-* files.
1683 extra_headers_list=
1684 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1685 for file in ${extra_headers} ; do
1686   extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1687 done
1688
1689 # Define collect2 in Makefile.
1690 case $host_can_use_collect2 in
1691   no) collect2= ;;
1692   *) collect2='collect2$(exeext)' ;;
1693 esac
1694 AC_SUBST([collect2])
1695
1696 # Add a definition of USE_COLLECT2 if system wants one.
1697 case $use_collect2 in
1698   no) use_collect2= ;;
1699   "") ;;
1700   *) 
1701     host_xm_defines="${host_xm_defines} USE_COLLECT2"
1702     xm_defines="${xm_defines} USE_COLLECT2"
1703     case $host_can_use_collect2 in
1704       no)
1705         AC_MSG_ERROR([collect2 is required but cannot be built on this system])
1706         ;;
1707     esac
1708     ;;
1709 esac
1710
1711 # ---------------------------
1712 # Assembler & linker features
1713 # ---------------------------
1714
1715 # Identify the assembler which will work hand-in-glove with the newly
1716 # built GCC, so that we can examine its features.  This is the assembler
1717 # which will be driven by the driver program.
1718 #
1719 # If build != host, and we aren't building gas in-tree, we identify a
1720 # build->target assembler and hope that it will have the same features
1721 # as the host->target assembler we'll be using.
1722 AC_MSG_CHECKING(what assembler to use)
1723 in_tree_gas=no
1724 gcc_cv_as=
1725 gcc_cv_gas_major_version=
1726 gcc_cv_gas_minor_version=
1727 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1728 if test -x "$DEFAULT_ASSEMBLER"; then
1729         gcc_cv_as="$DEFAULT_ASSEMBLER"
1730 elif test -x as$host_exeext; then
1731         # Build using assembler in the current directory.
1732         gcc_cv_as=./as$host_exeext
1733 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
1734      && test -f ../gas/Makefile \
1735      && test x$build = x$host; then
1736   # Single tree build which includes gas.  We want to prefer it
1737   # over whatever linker top-level may have detected, since
1738   # we'll use what we're building after installation anyway.
1739   in_tree_gas=yes
1740   _gcc_COMPUTE_GAS_VERSION
1741   rm -f as$host_exeext
1742   $symbolic_link ../gas/as-new$host_exeext as$host_exeext 2>/dev/null
1743   in_tree_gas_is_elf=no
1744   if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
1745      || (grep 'obj_format = multi' ../gas/Makefile \
1746          && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
1747   then
1748     in_tree_gas_is_elf=yes
1749   fi
1750 m4_pattern_allow([AS_FOR_TARGET])dnl
1751 elif test -x "$AS_FOR_TARGET"; then
1752         gcc_cv_as="$AS_FOR_TARGET"
1753 elif test -x "$AS" && test x$host = x$target; then
1754         gcc_cv_as="$AS"
1755 fi
1756
1757 if test "x$gcc_cv_as" = x; then
1758         # Search the same directories that the installed compiler will
1759         # search.  Else we may find the wrong assembler and lose.  If we
1760         # do not find a suitable assembler binary, then try the user's
1761         # path.
1762         #
1763         # Also note we have to check MD_EXEC_PREFIX before checking the
1764         # user's path.  Unfortunately, there is no good way to get at the
1765         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1766         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1767         # to be fixed as part of the make/configure rewrite too.
1768
1769         if test "x$exec_prefix" = xNONE; then
1770                 if test "x$prefix" = xNONE; then
1771                         test_prefix=/usr/local
1772                 else
1773                         test_prefix=$prefix
1774                 fi
1775         else
1776                 test_prefix=$exec_prefix
1777         fi
1778
1779         # If the loop below does not find an assembler, then use whatever
1780         # one we can find in the users's path.
1781         # user's path.
1782         if test "x$program_prefix" != xNONE; then
1783                 gcc_cv_as=${program_prefix}as$host_exeext
1784         else
1785                 gcc_cv_as=`echo as | sed "${program_transform_name}"`$host_exeext
1786         fi
1787
1788         test_dirs="$test_prefix/libexec/gcc/$target_noncanonical/$gcc_version \
1789                    $test_prefix/libexec/gcc/$target_noncanonical \
1790                    /usr/lib/gcc/$target_noncanonical/$gcc_version \
1791                    /usr/lib/gcc/$target_noncanonical \
1792                    $test_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version \
1793                    $test_prefix/$target_noncanonical/bin"
1794
1795         if test x$host = x$target; then
1796             test_dirs="$test_dirs \
1797                    /usr/libexec \
1798                    /usr/ccs/gcc \
1799                    /usr/ccs/bin \
1800                    /udk/usr/ccs/bin \
1801                    /bsd43/usr/lib/cmplrs/cc \
1802                    /usr/cross64/usr/bin \
1803                    /usr/lib/cmplrs/cc \
1804                    /sysv/usr/lib/cmplrs/cc \
1805                    /svr4/usr/lib/cmplrs/cc \
1806                    /usr/bin"
1807         fi
1808
1809         for dir in $test_dirs; do
1810                 if test -x $dir/as$host_exeext; then
1811                         gcc_cv_as=$dir/as$host_exeext
1812                         break;
1813                 fi
1814         done
1815 fi
1816 case $in_tree_gas in
1817   yes)
1818     AC_MSG_RESULT("newly built gas")
1819     ;;
1820   no)
1821     AC_MSG_RESULT($gcc_cv_as)
1822     ;;
1823 esac
1824
1825 # Identify the linker which will work hand-in-glove with the newly
1826 # built GCC, so that we can examine its features.  This is the linker
1827 # which will be driven by the driver program.
1828 #
1829 # If build != host, and we aren't building gas in-tree, we identify a
1830 # build->target linker and hope that it will have the same features
1831 # as the host->target linker we'll be using.
1832 AC_MSG_CHECKING(what linker to use)
1833 in_tree_ld=no
1834 gcc_cv_ld=
1835 gcc_cv_gld_major_version=
1836 gcc_cv_gld_minor_version=
1837 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1838 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1839 if test -x "$DEFAULT_LINKER"; then
1840         gcc_cv_ld="$DEFAULT_LINKER"
1841 elif test -x collect-ld$host_exeext; then
1842         # Build using linker in the current directory.
1843         gcc_cv_ld=./collect-ld$host_exeext
1844 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
1845      && test -f ../ld/Makefile \
1846      && test x$build = x$host; then
1847         # Single tree build which includes ld.  We want to prefer it
1848         # over whatever linker top-level may have detected, since
1849         # we'll use what we're building after installation anyway.
1850         in_tree_ld=yes
1851         in_tree_ld_is_elf=no
1852         if (grep 'EMUL = .*elf' ../ld/Makefile \
1853             || grep 'EMUL = .*linux' ../ld/Makefile) > /dev/null; then
1854           in_tree_ld_is_elf=yes
1855         fi
1856         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
1857         do
1858 changequote(,)dnl
1859                 gcc_cv_gld_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
1860 changequote([,])dnl
1861                 if test x$gcc_cv_gld_version != x; then
1862                         break
1863                 fi
1864         done
1865 changequote(,)dnl
1866         gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
1867         gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1868 changequote([,])dnl
1869         rm -f collect-ld$host_exeext
1870         $symbolic_link ../ld/ld-new$host_exeext collect-ld$host_exeext \
1871                 2>/dev/null
1872 elif test -x "$LD_FOR_TARGET"; then
1873         gcc_cv_ld="$LD_FOR_TARGET"
1874 elif test -x "$LD" && test x$host = x$target; then
1875         gcc_cv_ld="$LD"
1876 fi
1877
1878 if test "x$gcc_cv_ld" = x; then
1879         # Search the same directories that the installed compiler will
1880         # search.  Else we may find the wrong linker and lose.  If we
1881         # do not find a suitable linker binary, then try the user's
1882         # path.
1883         #
1884         # Also note we have to check MD_EXEC_PREFIX before checking the
1885         # user's path.  Unfortunately, there is no good way to get at the
1886         # value of MD_EXEC_PREFIX here.  So we do a brute force search
1887         # through all the known MD_EXEC_PREFIX values.  Ugh.  This needs
1888         # to be fixed as part of the make/configure rewrite too.
1889
1890         if test "x$exec_prefix" = xNONE; then
1891                 if test "x$prefix" = xNONE; then
1892                         test_prefix=/usr/local
1893                 else
1894                         test_prefix=$prefix
1895                 fi
1896         else
1897                 test_prefix=$exec_prefix
1898         fi
1899
1900         # If the loop below does not find an linker, then use whatever
1901         # one we can find in the users's path.
1902         # user's path.
1903         if test "x$program_prefix" != xNONE; then
1904                 gcc_cv_ld=${program_prefix}ld$host_exeext
1905         else
1906                 gcc_cv_ld=`echo ld | sed "${program_transform_name}"`$host_exeext
1907         fi
1908
1909         test_dirs="$test_prefix/libexec/gcc/$target_noncanonical/$gcc_version \
1910                    $test_prefix/libexec/gcc/$target_noncanonical \
1911                    /usr/lib/gcc/$target_noncanonical/$gcc_version \
1912                    /usr/lib/gcc/$target_noncanonical \
1913                    $test_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version \
1914                    $test_prefix/$target_noncanonical/bin"
1915
1916         if test x$host = x$target; then
1917             test_dirs="$test_dirs \
1918                    /usr/libexec \
1919                    /usr/ccs/gcc \
1920                    /usr/ccs/bin \
1921                    /udk/usr/ccs/bin \
1922                    /bsd43/usr/lib/cmplrs/cc \
1923                    /usr/cross64/usr/bin \
1924                    /usr/lib/cmplrs/cc \
1925                    /sysv/usr/lib/cmplrs/cc \
1926                    /svr4/usr/lib/cmplrs/cc \
1927                    /usr/bin"
1928         fi
1929
1930         for dir in $test_dirs; do
1931                 if test -x $dir/ld$host_exeext; then
1932                         gcc_cv_ld=$dir/ld$host_exeext
1933                         break;
1934                 fi
1935         done
1936 fi
1937 case $in_tree_ld in
1938   yes)
1939     AC_MSG_RESULT("newly built ld")
1940     ;;
1941   no)
1942     AC_MSG_RESULT($gcc_cv_ld)
1943     ;;
1944 esac
1945
1946 # Figure out what nm we will be using.
1947 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
1948 AC_MSG_CHECKING(what nm to use)
1949 in_tree_nm=no
1950 if test -x nm$host_exeext; then
1951         gcc_cv_nm=./nm$host_exeext
1952 elif test -f $gcc_cv_binutils_srcdir/configure.in \
1953      && test -f ../binutils/Makefile; then
1954         # Single tree build which includes binutils.
1955         in_tree_nm=yes
1956         gcc_cv_nm=./nm$host_exeext
1957         rm -f nm$host_exeext
1958         $symbolic_link ../binutils/nm-new$host_exeext nm$host_exeext 2>/dev/null
1959 elif test "x$program_prefix" != xNONE; then
1960         gcc_cv_nm=${program_prefix}nm$host_exeext
1961 else
1962         gcc_cv_nm=`echo nm | sed "${program_transform_name}"`$host_exeext
1963 fi
1964 case $in_tree_nm in
1965   yes) AC_MSG_RESULT("newly built nm") ;;
1966   no)  AC_MSG_RESULT($gcc_cv_nm) ;;
1967 esac
1968
1969 # Figure out what objdump we will be using.
1970 AC_MSG_CHECKING(what objdump to use)
1971 in_tree_objdump=no
1972 if test -x objdump$host_exeext; then
1973         gcc_cv_objdump=./objdump$host_exeext
1974 elif test -f $gcc_cv_binutils_srcdir/configure.in \
1975      && test -f ../binutils/Makefile; then
1976         # Single tree build which includes binutils.
1977         in_tree_objdump=yes
1978         gcc_cv_objdump=./objdump$host_exeext
1979         rm -f objdump$host_exeext
1980         $symbolic_link ../binutils/objdump$host_exeext \
1981                 objdump$host_exeext 2>/dev/null
1982 elif test "x$program_prefix" != xNONE; then
1983         gcc_cv_objdump=${program_prefix}objdump$host_exeext
1984 else
1985         gcc_cv_objdump=`echo objdump | \
1986                 sed "${program_transform_name}"`$host_exeext
1987 fi
1988 case $in_tree_objdump in
1989   yes) AC_MSG_RESULT("newly built objdump") ;;
1990   no)  AC_MSG_RESULT($gcc_cv_objdump) ;;
1991 esac
1992
1993 # Figure out what assembler alignment features are present.
1994 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
1995  [2,6,0],,
1996 [.balign 4
1997 .p2align 2],,
1998 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
1999   [Define if your assembler supports .balign and .p2align.])])
2000
2001 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2002  [2,8,0],,
2003  [.p2align 4,,7],,
2004 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2005   [Define if your assembler supports specifying the maximum number
2006    of bytes to skip when using the GAS .p2align command.])])
2007
2008 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2009  [elf,2,9,0],,
2010  [conftest_label1: .word 0
2011 .subsection -1
2012 conftest_label2: .word 0
2013 .previous],
2014  [if test x$gcc_cv_nm != x; then
2015     $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2016     $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2017     if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2018     then :
2019     else gcc_cv_as_subsection_m1=yes
2020     fi
2021     rm -f conftest.nm1 conftest.nm2
2022   fi],
2023  [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2024   [Define if your assembler supports .subsection and .subsection -1 starts
2025    emitting at the beginning of your section.])])
2026
2027 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2028  [2,2,0],,
2029  [      .weak foobar],,
2030 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2031
2032 # .hidden needs to be supported in both the assembler and the linker,
2033 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2034 # This is irritatingly difficult to feature test for; we have to check the
2035 # date string after the version number.  If we've got an in-tree
2036 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2037 # to be safe.
2038 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2039 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2040  [elf,2,13,0],,
2041 [       .hidden foobar
2042 foobar:])
2043
2044 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2045 [if test $in_tree_ld = yes ; then
2046   gcc_cv_ld_hidden=no
2047   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 \
2048      && test $in_tree_ld_is_elf = yes; then
2049      gcc_cv_ld_hidden=yes
2050   fi
2051 else
2052   gcc_cv_ld_hidden=yes
2053   ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2054   if echo "$ld_ver" | grep GNU > /dev/null; then
2055 changequote(,)dnl
2056     ld_vers=`echo $ld_ver | sed -n \
2057         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
2058         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
2059         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
2060         -e 's,^.*[       ]\([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]*\)[     ].*$,\1,p' \
2062         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)[        ].*$,\1,p'`
2063     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'`
2064     if test 0"$ld_date" -lt 20020404; then
2065       if test -n "$ld_date"; then
2066         # If there was date string, but was earlier than 2002-04-04, fail
2067         gcc_cv_ld_hidden=no
2068       elif test -z "$ld_vers"; then
2069         # If there was no date string nor ld version number, something is wrong
2070         gcc_cv_ld_hidden=no
2071       else
2072         ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2073         ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2074         ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2075         test -z "$ld_vers_patch" && ld_vers_patch=0
2076         if test "$ld_vers_major" -lt 2; then
2077           gcc_cv_ld_hidden=no
2078         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2079           gcc_cv_ld_hidden="no"
2080         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2081           gcc_cv_ld_hidden=no
2082         fi
2083       fi
2084 changequote([,])dnl
2085     fi
2086   else
2087     case "${target}" in
2088       hppa64*-*-hpux* | ia64*-*-hpux*)
2089         gcc_cv_ld_hidden=yes
2090         ;;
2091       *)
2092         gcc_cv_ld_hidden=no
2093         ;;
2094     esac
2095   fi
2096 fi])
2097 libgcc_visibility=no
2098 AC_SUBST(libgcc_visibility)
2099 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2100   libgcc_visibility=yes
2101   AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2102   [Define if your assembler and linker support .hidden.])
2103 fi
2104
2105 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2106 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2107   [elf,2,11,0],,
2108 [       .data
2109         .uleb128 L2 - L1
2110 L1:
2111         .uleb128 1280
2112         .sleb128 -1010
2113 L2:],
2114  [# GAS versions before 2.11 do not support uleb128,
2115   # despite appearing to.
2116   # ??? There exists an elf-specific test that will crash
2117   # the assembler.  Perhaps it's better to figure out whether
2118   # arbitrary sections are supported and try the test.
2119   as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2120   if echo "$as_ver" | grep GNU > /dev/null; then
2121 changequote(,)dnl
2122     as_ver=`echo $as_ver | sed -e 's/GNU assembler \([0-9.][0-9.]*\).*/\1/'`
2123     as_major=`echo $as_ver | sed 's/\..*//'`
2124     as_minor=`echo $as_ver | sed 's/[^.]*\.\([0-9]*\).*/\1/'`
2125 changequote([,])dnl
2126     if test $as_major -eq 2 && test $as_minor -lt 11
2127     then :
2128     else gcc_cv_as_leb128=yes
2129     fi
2130   fi],
2131   [AC_DEFINE(HAVE_AS_LEB128, 1,
2132     [Define if your assembler supports .sleb128 and .uleb128.])])
2133
2134 # GAS versions up to and including 2.11.0 may mis-optimize
2135 # .eh_frame data.
2136 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2137   [elf,2,12,0],,
2138 [       .text
2139 .LFB1:
2140         .4byte  0
2141 .L1:
2142         .4byte  0
2143 .LFE1:
2144         .section        .eh_frame,"aw",@progbits
2145 __FRAME_BEGIN__:
2146         .4byte  .LECIE1-.LSCIE1
2147 .LSCIE1:
2148         .4byte  0x0
2149         .byte   0x1
2150         .ascii "z\0"
2151         .byte   0x1
2152         .byte   0x78
2153         .byte   0x1a
2154         .byte   0x0
2155         .byte   0x4
2156         .4byte  1
2157         .p2align 1
2158 .LECIE1:
2159 .LSFDE1:
2160         .4byte  .LEFDE1-.LASFDE1
2161 .LASFDE1:
2162         .4byte  .LASFDE1-__FRAME_BEGIN__
2163         .4byte  .LFB1
2164         .4byte  .LFE1-.LFB1
2165         .byte   0x4
2166         .4byte  .LFE1-.LFB1
2167         .byte   0x4
2168         .4byte  .L1-.LFB1
2169 .LEFDE1:],
2170 [  dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2171 cat > conftest.lit <<EOF
2172  0000 10000000 00000000 017a0001 781a0004  .........z..x...
2173  0010 01000000 12000000 18000000 00000000  ................
2174  0020 08000000 04080000 0044               .........D      @&t@
2175 EOF
2176 cat > conftest.big <<EOF
2177  0000 00000010 00000000 017a0001 781a0004  .........z..x...
2178  0010 00000001 00000012 00000018 00000000  ................
2179  0020 00000008 04000000 0844               .........D      @&t@
2180 EOF
2181   # If the assembler didn't choke, and we can objdump,
2182   # and we got the correct data, then succeed.
2183   if test x$gcc_cv_objdump != x \
2184   && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2185      | tail -3 > conftest.got \
2186   && { cmp conftest.lit conftest.got > /dev/null 2>&1 \
2187     || cmp conftest.big conftest.got > /dev/null 2>&1; }
2188   then
2189     gcc_cv_as_eh_frame=yes
2190   elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2191     gcc_cv_as_eh_frame=buggy
2192   else
2193     # Uh oh, what do we do now?
2194     gcc_cv_as_eh_frame=no
2195   fi])
2196
2197 if test $gcc_cv_as_eh_frame = buggy; then
2198   AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2199   [Define if your assembler mis-optimizes .eh_frame data.])
2200 fi
2201
2202 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2203  [elf,2,12,0], [--fatal-warnings],
2204  [.section .rodata.str, "aMS", @progbits, 1])
2205 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2206   [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2207 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2208
2209 # Thread-local storage - the check is heavily parametrized.
2210 conftest_s=
2211 tls_first_major=
2212 tls_first_minor=
2213 tls_as_opt=
2214 case "$target" in
2215 changequote(,)dnl
2216   alpha*-*-*)
2217     conftest_s='
2218         .section ".tdata","awT",@progbits
2219 foo:    .long   25
2220         .text
2221         ldq     $27,__tls_get_addr($29)         !literal!1
2222         lda     $16,foo($29)                    !tlsgd!1
2223         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
2224         ldq     $27,__tls_get_addr($29)         !literal!2
2225         lda     $16,foo($29)                    !tlsldm!2
2226         jsr     $26,($27),__tls_get_addr        !lituse_tlsldm!2
2227         ldq     $1,foo($29)                     !gotdtprel
2228         ldah    $2,foo($29)                     !dtprelhi
2229         lda     $3,foo($2)                      !dtprello
2230         lda     $4,foo($29)                     !dtprel
2231         ldq     $1,foo($29)                     !gottprel
2232         ldah    $2,foo($29)                     !tprelhi
2233         lda     $3,foo($2)                      !tprello
2234         lda     $4,foo($29)                     !tprel'
2235         tls_first_major=2
2236         tls_first_minor=13
2237         tls_as_opt=--fatal-warnings
2238         ;;
2239   i[34567]86-*-*)
2240     conftest_s='
2241         .section ".tdata","awT",@progbits
2242 foo:    .long   25
2243         .text
2244         movl    %gs:0, %eax
2245         leal    foo@TLSGD(,%ebx,1), %eax
2246         leal    foo@TLSLDM(%ebx), %eax
2247         leal    foo@DTPOFF(%eax), %edx
2248         movl    foo@GOTTPOFF(%ebx), %eax
2249         subl    foo@GOTTPOFF(%ebx), %eax
2250         addl    foo@GOTNTPOFF(%ebx), %eax
2251         movl    foo@INDNTPOFF, %eax
2252         movl    $foo@TPOFF, %eax
2253         subl    $foo@TPOFF, %eax
2254         leal    foo@NTPOFF(%ecx), %eax'
2255         tls_first_major=2
2256         tls_first_minor=14
2257         tls_as_opt=--fatal-warnings
2258         ;;
2259   x86_64-*-*)
2260     conftest_s='
2261         .section ".tdata","awT",@progbits
2262 foo:    .long   25
2263         .text
2264         movq    %fs:0, %rax
2265         leaq    foo@TLSGD(%rip), %rdi
2266         leaq    foo@TLSLD(%rip), %rdi
2267         leaq    foo@DTPOFF(%rax), %rdx
2268         movq    foo@GOTTPOFF(%rip), %rax
2269         movq    $foo@TPOFF, %rax'
2270         tls_first_major=2
2271         tls_first_minor=14
2272         tls_as_opt=--fatal-warnings
2273         ;;
2274   ia64-*-*)
2275     conftest_s='
2276         .section ".tdata","awT",@progbits
2277 foo:    data8   25
2278         .text
2279         addl    r16 = @ltoff(@dtpmod(foo#)), gp
2280         addl    r17 = @ltoff(@dtprel(foo#)), gp
2281         addl    r18 = @ltoff(@tprel(foo#)), gp
2282         addl    r19 = @dtprel(foo#), gp
2283         adds    r21 = @dtprel(foo#), r13
2284         movl    r23 = @dtprel(foo#)
2285         addl    r20 = @tprel(foo#), gp
2286         adds    r22 = @tprel(foo#), r13
2287         movl    r24 = @tprel(foo#)'
2288         tls_first_major=2
2289         tls_first_minor=13
2290         tls_as_opt=--fatal-warnings
2291         ;;
2292   powerpc-*-*)
2293     conftest_s='
2294         .section ".tdata","awT",@progbits
2295         .align 2
2296 ld0:    .space 4
2297 ld1:    .space 4
2298 x1:     .space 4
2299 x2:     .space 4
2300 x3:     .space 4
2301         .text
2302         addi 3,31,ld0@got@tlsgd
2303         bl __tls_get_addr
2304         addi 3,31,x1@got@tlsld
2305         bl __tls_get_addr
2306         addi 9,3,x1@dtprel
2307         addis 9,3,x2@dtprel@ha
2308         addi 9,9,x2@dtprel@l
2309         lwz 9,x3@got@tprel(31)
2310         add 9,9,x@tls
2311         addi 9,2,x1@tprel
2312         addis 9,2,x2@tprel@ha
2313         addi 9,9,x2@tprel@l'
2314         tls_first_major=2
2315         tls_first_minor=14
2316         tls_as_opt="-a32 --fatal-warnings"
2317         ;;
2318   powerpc64-*-*)
2319     conftest_s='
2320         .section ".tdata","awT",@progbits
2321         .align 3
2322 ld0:    .space 8
2323 ld1:    .space 8
2324 x1:     .space 8
2325 x2:     .space 8
2326 x3:     .space 8
2327         .text
2328         addi 3,2,ld0@got@tlsgd
2329         bl .__tls_get_addr
2330         nop
2331         addi 3,2,ld1@toc
2332         bl .__tls_get_addr
2333         nop
2334         addi 3,2,x1@got@tlsld
2335         bl .__tls_get_addr
2336         nop
2337         addi 9,3,x1@dtprel
2338         bl .__tls_get_addr
2339         nop
2340         addis 9,3,x2@dtprel@ha
2341         addi 9,9,x2@dtprel@l
2342         bl .__tls_get_addr
2343         nop
2344         ld 9,x3@got@dtprel(2)
2345         add 9,9,3
2346         bl .__tls_get_addr
2347         nop'
2348         tls_first_major=2
2349         tls_first_minor=14
2350         tls_as_opt="-a64 --fatal-warnings"
2351         ;;
2352   s390-*-*)
2353     conftest_s='
2354         .section ".tdata","awT",@progbits
2355 foo:    .long   25
2356         .text
2357         .long   foo@TLSGD
2358         .long   foo@TLSLDM
2359         .long   foo@DTPOFF
2360         .long   foo@NTPOFF
2361         .long   foo@GOTNTPOFF
2362         .long   foo@INDNTPOFF
2363         l       %r1,foo@GOTNTPOFF(%r12)
2364         l       %r1,0(%r1):tls_load:foo
2365         bas     %r14,0(%r1,%r13):tls_gdcall:foo
2366         bas     %r14,0(%r1,%r13):tls_ldcall:foo'
2367         tls_first_major=2
2368         tls_first_minor=14
2369         tls_as_opt="-m31 --fatal-warnings"
2370         ;;
2371   s390x-*-*)
2372     conftest_s='
2373         .section ".tdata","awT",@progbits
2374 foo:    .long   25
2375         .text
2376         .quad   foo@TLSGD
2377         .quad   foo@TLSLDM
2378         .quad   foo@DTPOFF
2379         .quad   foo@NTPOFF
2380         .quad   foo@GOTNTPOFF
2381         lg      %r1,foo@GOTNTPOFF(%r12)
2382         larl    %r1,foo@INDNTPOFF
2383         brasl   %r14,__tls_get_offset@PLT:tls_gdcall:foo
2384         brasl   %r14,__tls_get_offset@PLT:tls_ldcall:foo'
2385         tls_first_major=2
2386         tls_first_minor=14
2387         tls_as_opt="-m64 -Aesame --fatal-warnings"
2388         ;;
2389   sh-*-* | sh[34]-*-*)
2390     conftest_s='
2391         .section ".tdata","awT",@progbits
2392 foo:    .long   25
2393         .text
2394         .long   foo@TLSGD
2395         .long   foo@TLSLDM
2396         .long   foo@DTPOFF
2397         .long   foo@GOTTPOFF
2398         .long   foo@TPOFF'
2399         tls_first_major=2
2400         tls_first_minor=13
2401         tls_as_opt=--fatal-warnings
2402         ;;
2403   sparc*-*-*)
2404     case "$target" in
2405       sparc*-sun-solaris2.*)
2406         on_solaris=yes
2407         ;;
2408       *)
2409         on_solaris=no
2410         ;;
2411     esac
2412     if test x$on_solaris = xyes && test x$gas_flag = xno; then
2413       conftest_s='
2414         .section ".tdata",#alloc,#write,#tls
2415 foo:    .long   25
2416         .text
2417         sethi   %tgd_hi22(foo), %o0
2418         add     %o0, %tgd_lo10(foo), %o1
2419         add     %l7, %o1, %o0, %tgd_add(foo)
2420         call    __tls_get_addr, %tgd_call(foo)
2421         sethi   %tldm_hi22(foo), %l1
2422         add     %l1, %tldm_lo10(foo), %l2
2423         add     %l7, %l2, %o0, %tldm_add(foo)
2424         call    __tls_get_addr, %tldm_call(foo)
2425         sethi   %tldo_hix22(foo), %l3
2426         xor     %l3, %tldo_lox10(foo), %l4
2427         add     %o0, %l4, %l5, %tldo_add(foo)
2428         sethi   %tie_hi22(foo), %o3
2429         add     %o3, %tie_lo10(foo), %o3
2430         ld      [%l7 + %o3], %o2, %tie_ld(foo)
2431         add     %g7, %o2, %o4, %tie_add(foo)
2432         sethi   %tle_hix22(foo), %l1
2433         xor     %l1, %tle_lox10(foo), %o5
2434         ld      [%g7 + %o5], %o1'
2435         tls_first_major=0
2436         tls_first_minor=0
2437     else
2438       conftest_s='
2439         .section ".tdata","awT",@progbits
2440 foo:    .long   25
2441         .text
2442         sethi   %tgd_hi22(foo), %o0
2443         add     %o0, %tgd_lo10(foo), %o1
2444         add     %l7, %o1, %o0, %tgd_add(foo)
2445         call    __tls_get_addr, %tgd_call(foo)
2446         sethi   %tldm_hi22(foo), %l1
2447         add     %l1, %tldm_lo10(foo), %l2
2448         add     %l7, %l2, %o0, %tldm_add(foo)
2449         call    __tls_get_addr, %tldm_call(foo)
2450         sethi   %tldo_hix22(foo), %l3
2451         xor     %l3, %tldo_lox10(foo), %l4
2452         add     %o0, %l4, %l5, %tldo_add(foo)
2453         sethi   %tie_hi22(foo), %o3
2454         add     %o3, %tie_lo10(foo), %o3
2455         ld      [%l7 + %o3], %o2, %tie_ld(foo)
2456         add     %g7, %o2, %o4, %tie_add(foo)
2457         sethi   %tle_hix22(foo), %l1
2458         xor     %l1, %tle_lox10(foo), %o5
2459         ld      [%g7 + %o5], %o1'
2460         tls_first_major=2
2461         tls_first_minor=14
2462         tls_as_opt="-32 --fatal-warnings"
2463       fi
2464         ;;
2465 changequote([,])dnl
2466 esac
2467 if test -z "$tls_first_major"; then
2468   : # If we don't have a check, assume no support.
2469 else
2470   gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
2471   [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
2472   [AC_DEFINE(HAVE_AS_TLS, 1,
2473             [Define if your assembler supports thread-local storage.])])
2474 fi
2475
2476 # Target-specific assembler checks.
2477
2478 if test x"$demangler_in_ld" = xyes; then
2479   AC_MSG_CHECKING(linker --demangle support)
2480   gcc_cv_ld_demangle=no
2481   if test $in_tree_ld = yes; then
2482     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 \
2483       gcc_cv_ld_demangle=yes
2484     fi
2485   elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
2486     # Check if the GNU linker supports --demangle option
2487     if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
2488       gcc_cv_ld_demangle=yes
2489     fi
2490   fi
2491   if test x"$gcc_cv_ld_demangle" = xyes; then
2492     AC_DEFINE(HAVE_LD_DEMANGLE, 1,
2493 [Define if your linker supports --demangle option.])
2494   fi
2495   AC_MSG_RESULT($gcc_cv_ld_demangle)
2496 fi
2497
2498 case "$target" in
2499   # All TARGET_ABI_OSF targets.
2500   alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
2501     gcc_GAS_CHECK_FEATURE([explicit relocation support],
2502         gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
2503 [       .set nomacro
2504         .text
2505         extbl   $3, $2, $3      !lituse_bytoff!1
2506         ldq     $2, a($29)      !literal!1
2507         ldq     $4, b($29)      !literal!2
2508         ldq_u   $3, 0($2)       !lituse_base!1
2509         ldq     $27, f($29)     !literal!5
2510         jsr     $26, ($27), f   !lituse_jsr!5
2511         ldah    $29, 0($26)     !gpdisp!3
2512         lda     $0, c($29)      !gprel
2513         ldah    $1, d($29)      !gprelhigh
2514         lda     $1, d($1)       !gprellow
2515         lda     $29, 0($29)     !gpdisp!3],,
2516     [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
2517   [Define if your assembler supports explicit relocations.])])
2518     ;;
2519
2520   cris-*-*)
2521     gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
2522       gcc_cv_as_cris_no_mul_bug,[2,15,91],
2523       [-no-mul-bug-abort], [.text],,
2524       [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
2525                 [Define if your assembler supports the -no-mul-bug-abort option.])])
2526     ;;
2527
2528   sparc*-*-*)
2529     gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
2530       [.register %g2, #scratch],,
2531       [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
2532                 [Define if your assembler supports .register.])])
2533
2534     gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
2535       [-relax], [.text],,
2536       [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
2537                 [Define if your assembler supports -relax option.])])
2538
2539     gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
2540       gcc_cv_as_sparc_ua_pcrel,,
2541       [-K PIC],
2542 [.text
2543 foo:
2544         nop
2545 .data
2546 .align 4
2547 .byte 0
2548 .uaword %r_disp32(foo)],
2549       [if test x$gcc_cv_ld != x \
2550        && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
2551          gcc_cv_as_sparc_ua_pcrel=yes
2552        fi
2553        rm -f conftest],
2554       [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
2555                 [Define if your assembler and linker support unaligned PC relative relocs.])
2556
2557       gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
2558         gcc_cv_as_sparc_ua_pcrel_hidden,,
2559         [-K PIC],
2560 [.data
2561 .align 4
2562 .byte 0x31
2563 .uaword %r_disp32(foo)
2564 .byte 0x32, 0x33, 0x34
2565 .global foo
2566 .hidden foo
2567 foo:
2568 .skip 4],
2569         [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
2570          && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
2571          && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
2572             | grep ' 31000000 07323334' > /dev/null 2>&1; then
2573             if $gcc_cv_objdump -R conftest 2> /dev/null \
2574                | grep 'DISP32' > /dev/null 2>&1; then
2575                 :
2576             else
2577                 gcc_cv_as_sparc_ua_pcrel_hidden=yes
2578             fi
2579          fi
2580          rm -f conftest],
2581          [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
2582                    [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
2583     ]) # unaligned pcrel relocs
2584
2585     gcc_GAS_CHECK_FEATURE([offsetable %lo()],
2586       gcc_cv_as_sparc_offsetable_lo10,,
2587       [-xarch=v9],
2588 [.text
2589         or %g1, %lo(ab) + 12, %g1
2590         or %g1, %lo(ab + 12), %g1],
2591       [if test x$gcc_cv_objdump != x \
2592        && %gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
2593           | grep ' 82106000 82106000' > /dev/null 2>&1; then
2594          gcc_cv_as_offsetable_lo10=yes
2595        fi],
2596        [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
2597                  [Define if your assembler supports offsetable %lo().])])
2598     ;;
2599
2600 changequote(,)dnl
2601   i[34567]86-*-* | x86_64-*-*)
2602 changequote([,])dnl
2603     case $target_os in
2604       cygwin* | pe | mingw32*)
2605         # Used for DWARF 2 in PE
2606         gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
2607           gcc_cv_as_ix86_pe_secrel32,
2608           [2,15,91],,
2609 [.text
2610 foo:    nop
2611 .data
2612         .secrel32 foo],
2613           [if test x$gcc_cv_ld != x \
2614            && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
2615              gcc_cv_as_ix86_pe_secrel32=yes
2616            fi
2617            rm -f conftest],
2618           [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
2619             [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
2620         ;;
2621     esac
2622
2623     gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
2624        gcc_cv_as_ix86_filds_fists,
2625       [2,9,0],, [filds mem; fists mem],,
2626       [AC_DEFINE(HAVE_GAS_FILDS_FISTS, 1,
2627         [Define if your assembler uses the new HImode fild and fist notation.])])
2628
2629     gcc_GAS_CHECK_FEATURE([cmov syntax],
2630       gcc_cv_as_ix86_cmov_sun_syntax,,,
2631       [cmovl.l %edx, %eax],,
2632       [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
2633         [Define if your assembler supports the Sun syntax for cmov.])])
2634
2635     # This one is used unconditionally by i386.[ch]; it is to be defined
2636     # to 1 if the feature is present, 0 otherwise.
2637     gcc_GAS_CHECK_FEATURE([GOTOFF in data],
2638         gcc_cv_as_ix86_gotoff_in_data, [2,11,0],,
2639 [       .text
2640 .L0:
2641         nop
2642         .data
2643         .long .L0@GOTOFF])
2644     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
2645       [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
2646       [Define true if the assembler supports '.long foo@GOTOFF'.])
2647     ;;
2648
2649   ia64*-*-*)
2650     gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
2651         gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
2652 [       .text
2653         addl r15 = @ltoffx(x#), gp
2654         ;;
2655         ld8.mov r16 = [[r15]], x#],,
2656     [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
2657           [Define if your assembler supports ltoffx and ldxmov relocations.])])
2658
2659     ;;
2660
2661   powerpc*-*-*)
2662     case $target in
2663       *-*-aix*) conftest_s='    .csect .text[[PR]]
2664         mfcr 3,128';;
2665       *-*-darwin*) conftest_s=' .text
2666         mfcr r3,128';;
2667       *)       conftest_s='     .text
2668         mfcr 3,128';;
2669     esac
2670
2671     gcc_GAS_CHECK_FEATURE([mfcr field support],
2672       gcc_cv_as_powerpc_mfcrf, [2,14,0],,
2673       [$conftest_s],,
2674       [AC_DEFINE(HAVE_AS_MFCRF, 1,
2675           [Define if your assembler supports mfcr field.])])
2676     ;;
2677
2678   mips*-*-*)
2679     gcc_GAS_CHECK_FEATURE([explicit relocation support],
2680       gcc_cv_as_mips_explicit_relocs, [2,14,0],,
2681 [       lw $4,%gp_rel(foo)($4)],,
2682       [if test x$target_cpu_default = x
2683        then target_cpu_default=MASK_EXPLICIT_RELOCS
2684        else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
2685        fi])
2686
2687     ;;
2688 esac
2689 # ??? Not all targets support dwarf2 debug_line, even within a version
2690 # of gas.  Moreover, we need to emit a valid instruction to trigger any
2691 # info to the output file.  So, as supported targets are added to gas 2.11,
2692 # add some instruction here to (also) show we expect this might work.
2693 # ??? Once 2.11 is released, probably need to add first known working
2694 # version to the per-target configury.
2695 case "$target" in
2696   i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* \
2697   | x86_64*-*-* | hppa*-*-* | arm*-*-* | strongarm*-*-* | xscale*-*-* \
2698   | xstormy16*-*-* | cris-*-* | xtensa-*-*)
2699     insn="nop"
2700     ;;
2701   ia64*-*-* | s390*-*-*)
2702     insn="nop 0"
2703     ;;
2704   mmix-*-*)
2705     insn="swym 0"
2706     ;;
2707 esac
2708 if test x"$insn" != x; then
2709  conftest_s="\
2710         .file 1 \"conftest.s\"
2711         .loc 1 3 0
2712         $insn"
2713  gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
2714   gcc_cv_as_dwarf2_debug_line,
2715   [elf,2,11,0],, [$conftest_s],
2716   [# ??? This fails with non-gnu grep.  Maybe use objdump?
2717    if grep debug_line conftest.o > /dev/null 2>&1; then
2718      gcc_cv_as_dwarf2_debug_line=yes
2719    fi])
2720
2721 # The .debug_line file table must be in the exact order that
2722 # we specified the files, since these indices are also used
2723 # by DW_AT_decl_file.  Approximate this test by testing if
2724 # the assembler bitches if the same index is assigned twice.
2725  gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
2726   gcc_cv_as_dwarf2_file_buggy,,,
2727 [       .file 1 "foo.s"
2728         .file 1 "bar.s"])
2729
2730  if test $gcc_cv_as_dwarf2_debug_line = yes \
2731  && test $gcc_cv_as_dwarf2_file_buggy = no; then
2732         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
2733   [Define if your assembler supports dwarf2 .file/.loc directives,
2734    and preserves file table indices exactly as given.])
2735  fi
2736
2737  gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
2738   gcc_cv_as_gdwarf2_flag,
2739   [elf,2,11,0], [--gdwarf2], [$insn],,
2740   [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
2741 [Define if your assembler supports the --gdwarf2 option.])])
2742
2743  gcc_GAS_CHECK_FEATURE([--gstabs option],
2744   gcc_cv_as_gstabs_flag,
2745   [elf,2,11,0], [--gstabs], [$insn],
2746   [# The native Solaris 9/Intel assembler doesn't understand --gstabs
2747    # and warns about it, but still exits successfully.  So check for
2748    # this.
2749    if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
2750    then :
2751    else gcc_cv_as_gstabs_flag=yes
2752    fi],
2753   [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
2754 [Define if your assembler supports the --gstabs option.])])
2755 fi
2756
2757 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2758 gcc_cv_ld_ro_rw_mix=unknown
2759 if test $in_tree_ld = yes ; then
2760   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 \
2761      && test $in_tree_ld_is_elf = yes; then
2762     gcc_cv_ld_ro_rw_mix=read-write
2763   fi
2764 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2765   echo '.section myfoosect, "a"' > conftest1.s
2766   echo '.section myfoosect, "aw"' > conftest2.s
2767   echo '.byte 1' >> conftest2.s
2768   echo '.section myfoosect, "a"' > conftest3.s
2769   echo '.byte 0' >> conftest3.s
2770   if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2771      && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2772      && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2773      && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2774         conftest2.o conftest3.o > /dev/null 2>&1; then
2775     gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2776                          | sed -e '/myfoosect/!d' -e N`
2777     if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2778       if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2779         gcc_cv_ld_ro_rw_mix=read-only
2780       else
2781         gcc_cv_ld_ro_rw_mix=read-write
2782       fi
2783     fi
2784   fi
2785 changequote(,)dnl
2786   rm -f conftest.* conftest[123].*
2787 changequote([,])dnl
2788 fi
2789 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2790         AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2791   [Define if your linker links a mix of read-only
2792    and read-write sections into a read-write section.])
2793 fi
2794 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2795
2796 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
2797 gcc_cv_ld_eh_frame_hdr=no
2798 if test $in_tree_ld = yes ; then
2799   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 \
2800      && test $in_tree_ld_is_elf = yes; then
2801     gcc_cv_ld_eh_frame_hdr=yes
2802   fi
2803 elif test x$gcc_cv_ld != x; then
2804         # Check if linker supports --eh-frame-hdr option
2805         if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
2806                 gcc_cv_ld_eh_frame_hdr=yes
2807         fi
2808 fi
2809 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
2810         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
2811 [Define if your linker supports --eh-frame-hdr option.])
2812 fi
2813 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
2814
2815 AC_MSG_CHECKING(linker position independent executable support)
2816 gcc_cv_ld_pie=no
2817 if test $in_tree_ld = yes ; then
2818   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 \
2819      && test $in_tree_ld_is_elf = yes; then
2820     gcc_cv_ld_pie=yes
2821   fi
2822 elif test x$gcc_cv_ld != x; then
2823         # Check if linker supports -pie option
2824         if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
2825                 gcc_cv_ld_pie=yes
2826         fi
2827 fi
2828 if test x"$gcc_cv_ld_pie" = xyes; then
2829         AC_DEFINE(HAVE_LD_PIE, 1,
2830 [Define if your linker supports -pie option.])
2831 fi
2832 AC_MSG_RESULT($gcc_cv_ld_pie)
2833
2834 # --------
2835 # UNSORTED
2836 # --------
2837
2838 AC_CACHE_CHECK(linker --as-needed support,
2839 gcc_cv_ld_as_needed,
2840 [gcc_cv_ld_as_needed=no
2841 if test $in_tree_ld = yes ; then
2842   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 \
2843      && test $in_tree_ld_is_elf = yes; then
2844     gcc_cv_ld_as_needed=yes
2845   fi
2846 elif test x$gcc_cv_ld != x; then
2847         # Check if linker supports --as-needed and --no-as-needed options
2848         if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
2849                 gcc_cv_ld_as_needed=yes
2850         fi
2851 fi
2852 ])
2853 if test x"$gcc_cv_ld_as_needed" = xyes; then
2854         AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
2855 [Define if your linker supports --as-needed and --no-as-needed options.])
2856 fi
2857
2858 if test x$with_sysroot = x && test x$host = x$target \
2859    && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" ; then
2860   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
2861 [Define to PREFIX/include if cpp should also search that directory.])
2862 fi
2863
2864 # Find out what GC implementation we want, or may, use.
2865 AC_ARG_WITH(gc,
2866 [  --with-gc={page,zone}   choose the garbage collection mechanism to use
2867                           with the compiler],
2868 [case "$withval" in
2869   page | zone)
2870     GGC=ggc-$withval
2871     ;;
2872   *)
2873     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
2874     ;;
2875 esac],
2876 [GGC=ggc-page])
2877 AC_SUBST(GGC)
2878 echo "Using $GGC for garbage collection."
2879
2880 # Use the system's zlib library.
2881 zlibdir=-L../zlib
2882 zlibinc="-I\$(srcdir)/../zlib"
2883 AC_ARG_WITH(system-zlib,
2884 [  --with-system-zlib      use installed libz],
2885 zlibdir=
2886 zlibinc=
2887 )
2888 AC_SUBST(zlibdir)
2889 AC_SUBST(zlibinc)
2890
2891 dnl Very limited version of automake's enable-maintainer-mode
2892
2893 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
2894   dnl maintainer-mode is disabled by default
2895   AC_ARG_ENABLE(maintainer-mode,
2896 [  --enable-maintainer-mode
2897                           enable make rules and dependencies not useful
2898                           (and sometimes confusing) to the casual installer],
2899       maintainer_mode=$enableval,
2900       maintainer_mode=no)
2901
2902 AC_MSG_RESULT($maintainer_mode)
2903
2904 if test "$maintainer_mode" = "yes"; then
2905   MAINT=''
2906 else
2907   MAINT='#'
2908 fi
2909 AC_SUBST(MAINT)dnl
2910
2911 AC_MSG_CHECKING([whether to use libbanshee for points-to alias analysis])
2912 AC_ARG_WITH(libbanshee,
2913 [  --with-libbanshee      enable libbanshee],
2914 libbanshee="$with_libbanshee",
2915 libbanshee=no)
2916
2917 if test x"$libbanshee" = xyes; then
2918         BANSHEELIB="../libbanshee/points-to/libandersen.a ../libbanshee/engine/libbansheeengine.a ../libbanshee/libcompat/libbansheecompat.a "
2919         BANSHEEINC="-I\$(srcdir)/../libbanshee/libcompat -I\$(srcdir)/../libbanshee -I\$(srcdir)/../libbanshee/points-to"
2920         ANDER="tree-alias-ander.o"
2921         AC_DEFINE(HAVE_BANSHEE, 1, [Define if BANSHEE is available])
2922 else
2923         BANSHEELIB=""
2924         BANSHEEINC=""
2925         ANDER=""
2926 fi
2927 AC_MSG_RESULT($with_libbanshee)
2928
2929 AC_SUBST(ANDER)
2930 AC_SUBST(BANSHEEINC)
2931 AC_SUBST(BANSHEELIB)
2932
2933 # --------------
2934 # Language hooks
2935 # --------------
2936
2937 # Make empty files to contain the specs and options for each language.
2938 # Then add #include lines to for a compiler that has specs and/or options.
2939
2940 lang_opt_files=
2941 lang_specs_files=
2942 lang_tree_files=
2943 for subdir in . $subdirs
2944 do
2945         if test -f $srcdir/$subdir/lang.opt; then
2946             lang_opt_files="$lang_opt_files $srcdir/$subdir/lang.opt"
2947         fi
2948         if test -f $srcdir/$subdir/lang-specs.h; then
2949             lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
2950         fi
2951         if test -f $srcdir/$subdir/$subdir-tree.def; then
2952             lang_tree_files="$lang_tree_files $srcdir/$subdir/$subdir-tree.def"
2953         fi
2954 done
2955
2956 # These (without "all_") are set in each config-lang.in.
2957 # `language' must be a single word so is spelled singularly.
2958 all_languages=
2959 all_boot_languages=
2960 all_compilers=
2961 all_stagestuff=
2962 all_outputs='Makefile fixinc/Makefile gccbug mklibgcc mkheaders libada-mk'
2963 # List of language makefile fragments.
2964 all_lang_makefrags=
2965 # List of language subdirectory makefiles.  Deprecated.
2966 all_lang_makefiles=
2967 # Files for gengtype
2968 all_gtfiles="$target_gtfiles"
2969 # Files for gengtype with language
2970 all_gtfiles_files_langs=
2971 all_gtfiles_files_files=
2972
2973 # Add the language fragments.
2974 # Languages are added via two mechanisms.  Some information must be
2975 # recorded in makefile variables, these are defined in config-lang.in.
2976 # We accumulate them and plug them into the main Makefile.
2977 # The other mechanism is a set of hooks for each of the main targets
2978 # like `clean', `install', etc.
2979
2980 language_hooks="Make-hooks"
2981
2982 for s in $subdirs
2983 do
2984                 language=
2985                 boot_language=
2986                 compilers=
2987                 stagestuff=
2988                 outputs=
2989                 gtfiles=
2990                 . ${srcdir}/$s/config-lang.in
2991                 if test "x$language" = x
2992                 then
2993                         echo "${srcdir}/$s/config-lang.in doesn't set \$language." 1>&2
2994                         exit 1
2995                 fi
2996                 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$s/Make-lang.in"
2997                 if test -f ${srcdir}/$s/Makefile.in
2998                 then all_lang_makefiles="$s/Makefile"
2999                 fi
3000                 all_languages="$all_languages $language"
3001                 if test "x$boot_language" = xyes
3002                 then
3003                         all_boot_languages="$all_boot_languages $language"
3004                 fi
3005                 all_compilers="$all_compilers $compilers"
3006                 all_stagestuff="$all_stagestuff $stagestuff"
3007                 all_outputs="$all_outputs $outputs"
3008                 all_gtfiles="$all_gtfiles $gtfiles"
3009                 for f in $gtfiles
3010                 do
3011                          all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
3012                          all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
3013                 done
3014 done
3015
3016 # Pick up gtfiles for c
3017 gtfiles=
3018 s="c"
3019 . ${srcdir}/c-config-lang.in
3020 all_gtfiles="$all_gtfiles $gtfiles"
3021 for f in $gtfiles
3022 do
3023         all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
3024         all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
3025 done
3026
3027 check_languages=
3028 for language in $all_languages
3029 do
3030                 check_languages="$check_languages check-$language"
3031 done
3032
3033 # We link each language in with a set of hooks, reached indirectly via
3034 # lang.${target}.
3035
3036 rm -f Make-hooks
3037 touch Make-hooks
3038 target_list="all.build all.cross start.encap rest.encap tags \
3039         install-normal install-common install-man \
3040         uninstall info man srcextra srcman srcinfo \
3041         mostlyclean clean distclean maintainer-clean \
3042         stage1 stage2 stage3 stage4 stageprofile stagefeedback"
3043 for t in $target_list
3044 do
3045         x=
3046         for lang in $all_languages
3047         do
3048                         x="$x $lang.$t"
3049         done
3050         echo "lang.$t: $x" >> Make-hooks
3051 done
3052
3053 # --------
3054 # UNSORTED
3055 # --------
3056
3057 # Create .gdbinit.
3058
3059 echo "dir ." > .gdbinit
3060 echo "dir ${srcdir}" >> .gdbinit
3061 if test x$gdb_needs_out_file_path = xyes
3062 then
3063         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
3064 fi
3065 if test "x$subdirs" != x; then
3066         for s in $subdirs
3067         do
3068                 echo "dir ${srcdir}/$s" >> .gdbinit
3069         done
3070 fi
3071 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
3072
3073 # If $(exec_prefix) exists and is not the same as $(prefix), then compute an
3074 # absolute path for gcc_tooldir based on inserting the number of up-directory
3075 # movements required to get from $(exec_prefix) to $(prefix) into the basic
3076 # $(libsubdir)/@(unlibsubdir) based path.
3077 # Don't set gcc_tooldir to tooldir since that's only passed in by the toplevel
3078 # make and thus we'd get different behavior depending on where we built the
3079 # sources.
3080 if test x$exec_prefix = xNONE -o x$exec_prefix = x$prefix; then
3081     gcc_tooldir='$(libsubdir)/$(unlibsubdir)/../$(target_noncanonical)'
3082 else
3083 changequote(<<, >>)dnl
3084 # An explanation of the sed strings:
3085 #  -e 's|^\$(prefix)||'   matches and eliminates 'prefix' from 'exec_prefix'
3086 #  -e 's|/$||'            match a trailing forward slash and eliminates it
3087 #  -e 's|^[^/]|/|'        forces the string to start with a forward slash (*)
3088 #  -e 's|/[^/]*|../|g'    replaces each occurrence of /<directory> with ../
3089 #
3090 # (*) Note this pattern overwrites the first character of the string
3091 # with a forward slash if one is not already present.  This is not a
3092 # problem because the exact names of the sub-directories concerned is
3093 # unimportant, just the number of them matters.
3094 #
3095 # The practical upshot of these patterns is like this:
3096 #
3097 #  prefix     exec_prefix        result
3098 #  ------     -----------        ------
3099 #   /foo        /foo/bar          ../
3100 #   /foo/       /foo/bar          ../
3101 #   /foo        /foo/bar/         ../
3102 #   /foo/       /foo/bar/         ../
3103 #   /foo        /foo/bar/ugg      ../../
3104 #
3105     dollar='$$'
3106     gcc_tooldir="\$(libsubdir)/\$(unlibsubdir)/\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/\$(dollar)||' -e 's|^[^/]|/|' -e 's|/[^/]*|../|g'\`\$(target_noncanonical)"
3107 changequote([, ])dnl
3108 fi
3109 AC_SUBST(gcc_tooldir)
3110 AC_SUBST(dollar)
3111
3112 # Find a directory in which to install a shared libgcc.
3113
3114 AC_ARG_ENABLE(version-specific-runtime-libs,
3115 [  --enable-version-specific-runtime-libs
3116                           specify that runtime libraries should be
3117                           installed in a compiler-specific directory])
3118
3119 AC_ARG_WITH(slibdir,
3120 [  --with-slibdir=DIR      shared libraries in DIR [LIBDIR]],
3121 slibdir="$with_slibdir",
3122 if test "${enable_version_specific_runtime_libs+set}" = set; then
3123   slibdir='$(libsubdir)'
3124 elif test "$host" != "$target"; then
3125   slibdir='$(build_tooldir)/lib'
3126 else
3127   slibdir='$(libdir)'
3128 fi)
3129 AC_SUBST(slibdir)
3130
3131 objdir=`${PWDCMD-pwd}`
3132 AC_SUBST(objdir)
3133
3134 # Substitute configuration variables
3135 AC_SUBST(subdirs)
3136 AC_SUBST(srcdir)
3137 AC_SUBST(all_boot_languages)
3138 AC_SUBST(all_compilers)
3139 AC_SUBST(all_gtfiles)
3140 AC_SUBST(all_gtfiles_files_langs)
3141 AC_SUBST(all_gtfiles_files_files)
3142 AC_SUBST(all_lang_makefrags)
3143 AC_SUBST(all_lang_makefiles)
3144 AC_SUBST(all_languages)
3145 AC_SUBST(all_stagestuff)
3146 AC_SUBST(build_exeext)
3147 AC_SUBST(build_install_headers_dir)
3148 AC_SUBST(build_xm_file_list)
3149 AC_SUBST(build_xm_include_list)
3150 AC_SUBST(build_xm_defines)
3151 AC_SUBST(check_languages)
3152 AC_SUBST(cc_set_by_configure)
3153 AC_SUBST(quoted_cc_set_by_configure)
3154 AC_SUBST(cpp_install_dir)
3155 AC_SUBST(xmake_file)
3156 AC_SUBST(tmake_file)
3157 AC_SUBST(extra_gcc_objs)
3158 AC_SUBST(extra_headers_list)
3159 AC_SUBST(extra_objs)
3160 AC_SUBST(extra_parts)
3161 AC_SUBST(extra_passes)
3162 AC_SUBST(extra_programs)
3163 AC_SUBST(float_h_file)
3164 AC_SUBST(gcc_config_arguments)
3165 AC_SUBST(gcc_gxx_include_dir)
3166 AC_SUBST(libstdcxx_incdir)
3167 AC_SUBST(gcc_version)
3168 AC_SUBST(gcc_version_full)
3169 AC_SUBST(gcc_version_trigger)
3170 AC_SUBST(host_exeext)
3171 AC_SUBST(host_xm_file_list)
3172 AC_SUBST(host_xm_include_list)
3173 AC_SUBST(host_xm_defines)
3174 AC_SUBST(out_host_hook_obj)
3175 AC_SUBST(install)
3176 AC_SUBST(lang_opt_files)
3177 AC_SUBST(lang_specs_files)
3178 AC_SUBST(lang_tree_files)
3179 AC_SUBST(local_prefix)
3180 AC_SUBST(md_file)
3181 AC_SUBST(objc_boehm_gc)
3182 AC_SUBST(out_file)
3183 AC_SUBST(out_object_file)
3184 AC_SUBST(stage_prefix_set_by_configure)
3185 AC_SUBST(quoted_stage_prefix_set_by_configure)
3186 AC_SUBST(symbolic_link)
3187 AC_SUBST(thread_file)
3188 AC_SUBST(tm_file_list)
3189 AC_SUBST(tm_include_list)
3190 AC_SUBST(tm_defines)
3191 AC_SUBST(tm_p_file_list)
3192 AC_SUBST(tm_p_include_list)
3193 AC_SUBST(xm_file_list)
3194 AC_SUBST(xm_include_list)
3195 AC_SUBST(xm_defines)
3196 AC_SUBST(target_noncanonical)
3197 AC_SUBST(c_target_objs)
3198 AC_SUBST(cxx_target_objs)
3199 AC_SUBST(target_cpu_default)
3200
3201 AC_SUBST_FILE(language_hooks)
3202
3203 # If it doesn't already exist, create document directory
3204 echo "checking for the document directory." 1>&2
3205 if test -d doc ; then
3206   true
3207 else
3208   mkdir doc 
3209 fi
3210
3211 # Echo link setup.
3212 if test x${build} = x${host} ; then
3213   if test x${host} = x${target} ; then
3214     echo "Links are now set up to build a native compiler for ${target}." 1>&2
3215   else
3216     echo "Links are now set up to build a cross-compiler" 1>&2
3217     echo " from ${host} to ${target}." 1>&2
3218   fi
3219 else
3220   if test x${host} = x${target} ; then
3221     echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
3222     echo " for ${target}." 1>&2
3223   else
3224     echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
3225     echo " from ${host} to ${target}." 1>&2
3226   fi
3227 fi
3228
3229 AC_ARG_VAR(GMPLIBS,[How to link GMP])
3230 AC_ARG_VAR(GMPINC,[How to find GMP include files])
3231
3232 # Configure the subdirectories
3233 # AC_CONFIG_SUBDIRS($subdirs)
3234
3235 # Create the Makefile
3236 # and configure language subdirectories
3237 AC_CONFIG_FILES($all_outputs)
3238
3239 AC_CONFIG_COMMANDS([default],
3240 [
3241 case ${CONFIG_HEADERS} in
3242   *auto-host.h:config.in*)
3243   echo > cstamp-h ;;
3244 esac
3245 # Make sure all the subdirs exist.
3246 for d in $subdirs
3247 do
3248     test -d $d || mkdir $d
3249 done
3250 # If the host supports symlinks, point stage[1234] at ../stage[1234] so
3251 # bootstrapping and the installation procedure can still use
3252 # CC="stage1/xgcc -Bstage1/".  If the host doesn't support symlinks,
3253 # FLAGS_TO_PASS has been modified to solve the problem there.
3254 # This is virtually a duplicate of what happens in configure.lang; we do
3255 # an extra check to make sure this only happens if ln -s can be used.
3256 if test "$symbolic_link" = "ln -s"; then
3257  for d in ${subdirs} fixinc ; do
3258         STARTDIR=`${PWDCMD-pwd}`
3259         cd $d
3260         for t in stage1 stage2 stage3 stage4 stageprofile stagefeedback include
3261         do
3262                 rm -f $t
3263                 $symbolic_link ../$t $t 2>/dev/null
3264         done
3265         cd $STARTDIR
3266  done
3267 else true ; fi
3268 ], 
3269 [subdirs='$subdirs'
3270 symbolic_link='$symbolic_link'
3271 ])
3272 AC_OUTPUT