OSDN Git Service

f62500dc9aa12b300870eccea17c116c7a81c770
[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, 2005, 2006,
5 # 2007, 2008, 2009, 2010 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 3, 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 COPYING3.  If not see
21 #<http://www.gnu.org/licenses/>.
22
23 # --------------------------------
24 # Initialization and sanity checks
25 # --------------------------------
26
27 AC_PREREQ(2.64)
28 AC_INIT
29 AC_CONFIG_SRCDIR(tree.c)
30 AC_CONFIG_HEADER(auto-host.h:config.in)
31
32 gcc_version=`cat $srcdir/BASE-VER`
33
34 # Determine the host, build, and target systems
35 AC_CANONICAL_BUILD
36 AC_CANONICAL_HOST
37 AC_CANONICAL_TARGET
38
39 # Determine the noncanonical target name, for directory use.
40 ACX_NONCANONICAL_TARGET
41
42 # Determine the target- and build-specific subdirectories
43 GCC_TOPLEV_SUBDIRS
44
45 # Set program_transform_name
46 AC_ARG_PROGRAM
47
48 # Check for bogus environment variables.
49 # Test if LIBRARY_PATH contains the notation for the current directory
50 # since this would lead to problems installing/building glibc.
51 # LIBRARY_PATH contains the current directory if one of the following
52 # is true:
53 # - one of the terminals (":" and ";") is the first or last sign
54 # - two terminals occur directly after each other
55 # - the path contains an element with a dot in it
56 AC_MSG_CHECKING(LIBRARY_PATH variable)
57 changequote(,)dnl
58 case ${LIBRARY_PATH} in
59   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
60     library_path_setting="contains current directory"
61     ;;
62   *)
63     library_path_setting="ok"
64     ;;
65 esac
66 changequote([,])dnl
67 AC_MSG_RESULT($library_path_setting)
68 if test "$library_path_setting" != "ok"; then
69 AC_MSG_ERROR([
70 *** LIBRARY_PATH shouldn't contain the current directory when
71 *** building gcc. Please change the environment variable
72 *** and run configure again.])
73 fi
74
75 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
76 # since this would lead to problems installing/building glibc.
77 # GCC_EXEC_PREFIX contains the current directory if one of the following
78 # is true:
79 # - one of the terminals (":" and ";") is the first or last sign
80 # - two terminals occur directly after each other
81 # - the path contains an element with a dot in it
82 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
83 changequote(,)dnl
84 case ${GCC_EXEC_PREFIX} in
85   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
86     gcc_exec_prefix_setting="contains current directory"
87     ;;
88   *)
89     gcc_exec_prefix_setting="ok"
90     ;;
91 esac
92 changequote([,])dnl
93 AC_MSG_RESULT($gcc_exec_prefix_setting)
94 if test "$gcc_exec_prefix_setting" != "ok"; then
95 AC_MSG_ERROR([
96 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
97 *** building gcc. Please change the environment variable
98 *** and run configure again.])
99 fi
100
101 # -----------
102 # Directories
103 # -----------
104
105 # Specify the local prefix
106 local_prefix=
107 AC_ARG_WITH(local-prefix,
108 [  --with-local-prefix=DIR specifies directory to put local include],
109 [case "${withval}" in
110 yes)    AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
111 no)     ;;
112 *)      local_prefix=$with_local_prefix ;;
113 esac])
114
115 # Default local prefix if it is empty
116 if test x$local_prefix = x; then
117         local_prefix=/usr/local
118 fi
119
120 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
121 # passed in by the toplevel make and thus we'd get different behavior
122 # depending on where we built the sources.
123 gcc_gxx_include_dir=
124 # Specify the g++ header file directory
125 AC_ARG_WITH(gxx-include-dir,
126 [  --with-gxx-include-dir=DIR
127                           specifies directory to put g++ header files],
128 [case "${withval}" in
129 yes)    AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
130 no)     ;;
131 *)      gcc_gxx_include_dir=$with_gxx_include_dir ;;
132 esac])
133
134 # This logic must match libstdc++-v3/acinclude.m4:GLIBCXX_EXPORT_INSTALL_INFO.
135 if test x${gcc_gxx_include_dir} = x; then
136   if test x${enable_version_specific_runtime_libs} = xyes; then
137     gcc_gxx_include_dir='${libsubdir}/include/c++'
138   else
139     libstdcxx_incdir='include/c++/$(version)'
140     if test x$host != x$target; then
141        libstdcxx_incdir="$target_alias/$libstdcxx_incdir"
142     fi
143     gcc_gxx_include_dir="\$(libsubdir)/\$(libsubdir_to_prefix)$libstdcxx_incdir"
144   fi
145 fi
146
147 AC_ARG_WITH(cpp_install_dir,
148 [  --with-cpp-install-dir=DIR
149                           install the user visible C preprocessor in DIR
150                           (relative to PREFIX) as well as PREFIX/bin],
151 [if test x$withval = xyes; then
152   AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
153 elif test x$withval != xno; then
154   cpp_install_dir=$withval
155 fi])
156
157 # We would like to our source tree to be readonly.  However when releases or
158 # pre-releases are generated, the flex/bison generated files as well as the 
159 # various formats of manuals need to be included along with the rest of the
160 # sources.  Therefore we have --enable-generated-files-in-srcdir to do 
161 # just that.
162
163 AC_MSG_CHECKING([whether to place generated files in the source directory])
164   dnl generated-files-in-srcdir is disabled by default
165   AC_ARG_ENABLE(generated-files-in-srcdir, 
166 [  --enable-generated-files-in-srcdir
167                           put copies of generated files in source dir
168                           intended for creating source tarballs for users
169                           without texinfo bison or flex.],
170       generated_files_in_srcdir=$enableval,
171       generated_files_in_srcdir=no)
172
173 AC_MSG_RESULT($generated_files_in_srcdir)
174
175 if test "$generated_files_in_srcdir" = "yes"; then
176   GENINSRC=''
177 else
178   GENINSRC='#'
179 fi
180 AC_SUBST(GENINSRC)
181
182 # -------------------
183 # Find default linker
184 # -------------------
185
186 # With GNU ld
187 AC_ARG_WITH(gnu-ld,
188 [  --with-gnu-ld           arrange to work with GNU ld.],
189 gnu_ld_flag="$with_gnu_ld",
190 gnu_ld_flag=no)
191
192 # With pre-defined ld
193 AC_ARG_WITH(ld,
194 [  --with-ld               arrange to use the specified ld (full pathname)],
195 DEFAULT_LINKER="$with_ld")
196 if test x"${DEFAULT_LINKER+set}" = x"set"; then
197   if test ! -x "$DEFAULT_LINKER"; then
198     AC_MSG_ERROR([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
199   elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
200     gnu_ld_flag=yes
201   fi
202   AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
203         [Define to enable the use of a default linker.])
204 fi
205
206 gnu_ld=`if test x"$gnu_ld_flag" = x"yes"; then echo 1; else echo 0; fi`
207 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld, [Define if using GNU ld.])
208
209 AC_MSG_CHECKING([whether a default linker was specified])
210 if test x"${DEFAULT_LINKER+set}" = x"set"; then
211   if test x"$gnu_ld_flag" = x"no"; then
212     AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
213   else
214     AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
215   fi
216 else
217   AC_MSG_RESULT(no)
218 fi
219
220 # With demangler in GNU ld
221 AC_ARG_WITH(demangler-in-ld,
222 [  --with-demangler-in-ld  try to use demangler in GNU ld.],
223 demangler_in_ld="$with_demangler_in_ld",
224 demangler_in_ld=no)
225
226 # ----------------------
227 # Find default assembler
228 # ----------------------
229
230 # With GNU as
231 AC_ARG_WITH(gnu-as,
232 [  --with-gnu-as           arrange to work with GNU as],
233 gas_flag="$with_gnu_as",
234 gas_flag=no)
235
236 AC_ARG_WITH(as,
237 [  --with-as               arrange to use the specified as (full pathname)],
238 DEFAULT_ASSEMBLER="$with_as")
239 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
240   if test ! -x "$DEFAULT_ASSEMBLER"; then
241     AC_MSG_ERROR([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
242   elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
243     gas_flag=yes
244   fi
245   AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
246         [Define to enable the use of a default assembler.])
247 fi
248
249 gnu_as=`if test x"$gas_flag" = x"yes"; then echo 1; else echo 0; fi`
250 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as, [Define if using GNU as.])
251
252 AC_MSG_CHECKING([whether a default assembler was specified])
253 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
254   if test x"$gas_flag" = x"no"; then
255     AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
256   else
257     AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
258   fi
259 else
260   AC_MSG_RESULT(no)
261 fi
262
263 # ---------------
264 # Find C compiler
265 # ---------------
266
267 # If a non-executable a.out is present (e.g. created by GNU as above even if
268 # invoked with -v only), the IRIX 6 native ld just overwrites the existing
269 # file, even when creating an executable, so an execution test fails.
270 # Remove possible default executable files to avoid this.
271 #
272 # FIXME: This really belongs into AC_PROG_CC and can be removed once
273 # Autoconf includes it.
274 rm -f a.out a.exe b.out
275
276 # Find the native compiler
277 AC_PROG_CC
278 AM_PROG_CC_C_O
279 AC_PROG_CXX
280 ACX_PROG_GNAT([-I"$srcdir"/ada])
281
282 # autoconf is lame and doesn't give us any substitution variable for this.
283 if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = no"; then
284   NO_MINUS_C_MINUS_O=yes
285 else
286   OUTPUT_OPTION='-o $@'
287 fi
288 AC_SUBST(NO_MINUS_C_MINUS_O)
289 AC_SUBST(OUTPUT_OPTION)
290
291 # Remove the -O2: for historical reasons, unless bootstrapping we prefer
292 # optimizations to be activated explicitly by the toplevel.
293 case "$CC" in
294   */prev-gcc/xgcc*) ;;
295   *) CFLAGS=`echo $CFLAGS | sed "s/-O[[s0-9]]* *//" ` ;;
296 esac
297 AC_SUBST(CFLAGS)
298
299 # -------------------------
300 # Check C compiler features
301 # -------------------------
302
303 AC_USE_SYSTEM_EXTENSIONS
304 AC_PROG_CPP
305 AC_C_INLINE
306
307 AC_SYS_LARGEFILE
308
309 # sizeof(char) is 1 by definition.
310 AC_CHECK_SIZEOF(void *)
311 AC_CHECK_SIZEOF(short)
312 AC_CHECK_SIZEOF(int)
313 AC_CHECK_SIZEOF(long)
314 AC_CHECK_TYPES([long long], [AC_CHECK_SIZEOF(long long)])
315 AC_CHECK_TYPES([__int64], [AC_CHECK_SIZEOF(__int64)])
316 GCC_STDINT_TYPES
317
318 # ---------------------
319 # Warnings and checking
320 # ---------------------
321
322 # Check $CC warning features (if it's GCC).
323 # We want to use -pedantic, but we don't want warnings about
324 # * 'long long'
325 # * variadic macros
326 # * overlong strings
327 # So, we only use -pedantic if we can disable those warnings.
328
329 ACX_PROG_CC_WARNING_OPTS(
330         m4_quote(m4_do([-W -Wall -Wwrite-strings -Wcast-qual])), [loose_warn])
331 ACX_PROG_CC_WARNING_OPTS(
332         m4_quote(m4_do([-Wstrict-prototypes -Wmissing-prototypes])),
333         [c_loose_warn])
334 ACX_PROG_CC_WARNING_OPTS(
335         m4_quote(m4_do([-Wmissing-format-attribute])), [strict_warn])
336 ACX_PROG_CC_WARNING_OPTS(
337         m4_quote(m4_do([-Wold-style-definition -Wc++-compat])), [c_strict_warn])
338 ACX_PROG_CC_WARNING_ALMOST_PEDANTIC(
339         m4_quote(m4_do([-Wno-long-long -Wno-variadic-macros ], 
340                        [-Wno-overlength-strings])), [strict_warn])
341 ACX_PROG_CC_WARNINGS_ARE_ERRORS([manual], [strict_warn])
342
343 # The above macros do nothing if the compiler is not GCC.  However, the
344 # Makefile has more goo to add other flags, so these variables are used
345 # to enable warnings only for GCC.
346 warn_cflags=
347 warn_cxxflags=
348 if test "x$GCC" = "xyes"; then
349   warn_cflags='$(GCC_WARN_CFLAGS)'
350   warn_cxxflags='$(GCC_WARN_CXXFLAGS)'
351 fi
352 AC_SUBST(warn_cflags)
353 AC_SUBST(warn_cxxflags)
354
355 # Enable expensive internal checks
356 is_release=
357 if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then
358   is_release=yes
359 fi
360
361 AC_ARG_ENABLE(checking,
362 [  --enable-checking[=LIST]
363                           enable expensive run-time checks.  With LIST,
364                           enable only specific categories of checks.
365                           Categories are: yes,no,all,none,release.
366                           Flags are: assert,df,fold,gc,gcac,gimple,misc,
367                           rtlflag,rtl,runtime,tree,valgrind,types.],
368 [ac_checking_flags="${enableval}"],[
369 # Determine the default checks.
370 if test x$is_release = x ; then
371   ac_checking_flags=yes
372 else
373   ac_checking_flags=release
374 fi])
375 IFS="${IFS=     }"; ac_save_IFS="$IFS"; IFS="$IFS,"
376 for check in release $ac_checking_flags
377 do
378         case $check in
379         # these set all the flags to specific states
380         yes)            ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking= ;
381                         ac_fold_checking= ; ac_gc_checking=1 ;
382                         ac_gc_always_collect= ; ac_gimple_checking=1 ; ac_rtl_checking= ;
383                         ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
384                         ac_tree_checking=1 ; ac_valgrind_checking= ;
385                         ac_types_checking=1 ;;
386         no|none)        ac_assert_checking= ; ac_checking= ; ac_df_checking= ;
387                         ac_fold_checking= ; ac_gc_checking= ;
388                         ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
389                         ac_rtlflag_checking= ; ac_runtime_checking= ;
390                         ac_tree_checking= ; ac_valgrind_checking= ;
391                         ac_types_checking= ;;
392         all)            ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking=1 ;
393                         ac_fold_checking=1 ; ac_gc_checking=1 ;
394                         ac_gc_always_collect=1 ; ac_gimple_checking=1 ; ac_rtl_checking=1 ;
395                         ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
396                         ac_tree_checking=1 ; ac_valgrind_checking= ;
397                         ac_types_checking=1 ;;
398         release)        ac_assert_checking=1 ; ac_checking= ; ac_df_checking= ;
399                         ac_fold_checking= ; ac_gc_checking= ;
400                         ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
401                         ac_rtlflag_checking= ; ac_runtime_checking=1 ;
402                         ac_tree_checking= ; ac_valgrind_checking= ;
403                         ac_types_checking= ;;
404         # these enable particular checks
405         assert)         ac_assert_checking=1 ;;
406         df)             ac_df_checking=1 ;;
407         fold)           ac_fold_checking=1 ;;
408         gc)             ac_gc_checking=1 ;;
409         gcac)           ac_gc_always_collect=1 ;;
410         gimple)         ac_gimple_checking=1 ;;
411         misc)           ac_checking=1 ;;
412         rtl)            ac_rtl_checking=1 ;;
413         rtlflag)        ac_rtlflag_checking=1 ;;
414         runtime)        ac_runtime_checking=1 ;;
415         tree)           ac_tree_checking=1 ;;
416         types)          ac_types_checking=1 ;;
417         valgrind)       ac_valgrind_checking=1 ;;
418         *)      AC_MSG_ERROR(unknown check category $check) ;;
419         esac
420 done
421 IFS="$ac_save_IFS"
422
423 nocommon_flag=""
424 if test x$ac_checking != x ; then
425   AC_DEFINE(ENABLE_CHECKING, 1,
426 [Define if you want more run-time sanity checks.  This one gets a grab
427    bag of miscellaneous but relatively cheap checks.])
428   nocommon_flag=-fno-common
429 fi
430 AC_SUBST(nocommon_flag)
431 if test x$ac_df_checking != x ; then
432   AC_DEFINE(ENABLE_DF_CHECKING, 1,
433 [Define if you want more run-time sanity checks for dataflow.])
434 fi
435 if test x$ac_assert_checking != x ; then
436   AC_DEFINE(ENABLE_ASSERT_CHECKING, 1,
437 [Define if you want assertions enabled.  This is a cheap check.])
438 fi
439 if test x$ac_gimple_checking != x ; then
440   AC_DEFINE(ENABLE_GIMPLE_CHECKING, 1,
441 [Define if you want operations on GIMPLE (the basic data structure of
442 the high-level optimizers) to be checked for dynamic type safety at
443 runtime.  This is moderately expensive.])
444 fi
445 GCC_TARGET_TEMPLATE(ENABLE_RUNTIME_CHECKING)
446 if test x$ac_runtime_checking != x ; then
447   AC_DEFINE(ENABLE_RUNTIME_CHECKING, 1,
448 [Define if you want runtime assertions enabled.  This is a cheap check.])
449 fi
450 if test x$ac_tree_checking != x ; then
451   AC_DEFINE(ENABLE_TREE_CHECKING, 1,
452 [Define if you want all operations on trees (the basic data
453    structure of the front ends) to be checked for dynamic type safety
454    at runtime.  This is moderately expensive.  The tree browser debugging
455    routines will also be enabled by this option.
456    ])
457   TREEBROWSER=tree-browser.o
458 fi
459 if test x$ac_types_checking != x ; then
460   AC_DEFINE(ENABLE_TYPES_CHECKING, 1,
461 [Define if you want all gimple types to be verified after gimplifiation.
462    This is cheap.
463    ])
464 fi
465 AC_SUBST(TREEBROWSER)
466 if test x$ac_rtl_checking != x ; then
467   AC_DEFINE(ENABLE_RTL_CHECKING, 1,
468 [Define if you want all operations on RTL (the basic data structure
469    of the optimizer and back end) to be checked for dynamic type safety
470    at runtime.  This is quite expensive.])
471 fi
472 if test x$ac_rtlflag_checking != x ; then
473   AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
474 [Define if you want RTL flag accesses to be checked against the RTL
475    codes that are supported for each access macro.  This is relatively
476    cheap.])
477 fi
478 if test x$ac_gc_checking != x ; then
479   AC_DEFINE(ENABLE_GC_CHECKING, 1,
480 [Define if you want the garbage collector to do object poisoning and
481    other memory allocation checks.  This is quite expensive.])
482 fi
483 if test x$ac_gc_always_collect != x ; then
484   AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
485 [Define if you want the garbage collector to operate in maximally
486    paranoid mode, validating the entire heap and collecting garbage at
487    every opportunity.  This is extremely expensive.])
488 fi
489 if test x$ac_fold_checking != x ; then
490   AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
491 [Define if you want fold checked that it never destructs its argument.
492    This is quite expensive.])
493 fi
494 valgrind_path_defines=
495 valgrind_command=
496
497 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
498 dnl # an if statement.  This was the source of very frustrating bugs
499 dnl # in converting to autoconf 2.5x!
500 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
501
502 if test x$ac_valgrind_checking != x ; then
503   # It is certainly possible that there's valgrind but no valgrind.h.
504   # GCC relies on making annotations so we must have both.
505   AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
506   AC_PREPROC_IFELSE([AC_LANG_SOURCE(
507     [[#include <valgrind/memcheck.h>
508 #ifndef VALGRIND_DISCARD
509 #error VALGRIND_DISCARD not defined
510 #endif]])],
511   [gcc_cv_header_valgrind_memcheck_h=yes],
512   [gcc_cv_header_valgrind_memcheck_h=no])
513   AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
514   AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
515   AC_PREPROC_IFELSE([AC_LANG_SOURCE(
516     [[#include <memcheck.h>
517 #ifndef VALGRIND_DISCARD
518 #error VALGRIND_DISCARD not defined
519 #endif]])],
520   [gcc_cv_header_memcheck_h=yes],
521   [gcc_cv_header_memcheck_h=no])
522   AC_MSG_RESULT($gcc_cv_header_memcheck_h)
523   AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
524         [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
525   if test "x$valgrind_path" = "x" \
526     || (test $have_valgrind_h = no \
527         && test $gcc_cv_header_memcheck_h = no \
528         && test $gcc_cv_header_valgrind_memcheck_h = no); then
529         AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
530   fi
531   valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
532   valgrind_command="$valgrind_path -q"
533   AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
534 [Define if you want to run subprograms and generated programs
535    through valgrind (a memory checker).  This is extremely expensive.])
536   if test $gcc_cv_header_valgrind_memcheck_h = yes; then
537     AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
538         [Define if valgrind's valgrind/memcheck.h header is installed.])
539   fi
540   if test $gcc_cv_header_memcheck_h = yes; then
541     AC_DEFINE(HAVE_MEMCHECK_H, 1,
542         [Define if valgrind's memcheck.h header is installed.])
543   fi
544 fi
545 AC_SUBST(valgrind_path_defines)
546 AC_SUBST(valgrind_command)
547
548 # Enable code coverage collection
549 AC_ARG_ENABLE(coverage,
550 [  --enable-coverage[=LEVEL]
551                           enable compiler's code coverage collection.
552                           Use to measure compiler performance and locate
553                           unused parts of the compiler. With LEVEL, specify
554                           optimization. Values are opt, noopt,
555                           default is noopt],
556 [case "${enableval}" in
557   yes|noopt)
558     coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
559     ;;
560   opt)
561     coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
562     ;;
563   no)
564     # a.k.a. --disable-coverage
565     coverage_flags=""
566     ;;
567   *)
568     AC_MSG_ERROR(unknown coverage setting $enableval)
569     ;;
570 esac],
571 [coverage_flags=""])
572 AC_SUBST(coverage_flags)
573
574 AC_ARG_ENABLE(gather-detailed-mem-stats, 
575 [  --enable-gather-detailed-mem-stats         enable detailed memory allocation stats gathering], [],
576 [enable_gather_detailed_mem_stats=no])
577 if test x$enable_gather_detailed_mem_stats = xyes ; then
578   AC_DEFINE(GATHER_STATISTICS, 1,
579         [Define to enable detailed memory allocation stats gathering.])
580 fi
581
582 # -------------------------------
583 # Miscenalleous configure options
584 # -------------------------------
585
586 # See if we are building gcc with C++.
587 AC_ARG_ENABLE(build-with-cxx,
588 [  --enable-build-with-cxx build with C++ compiler instead of C compiler],
589 ENABLE_BUILD_WITH_CXX=$enableval,
590 ENABLE_BUILD_WITH_CXX=no)
591 AC_SUBST(ENABLE_BUILD_WITH_CXX)
592
593 # With stabs
594 AC_ARG_WITH(stabs,
595 [  --with-stabs            arrange to use stabs instead of host debug format],
596 stabs="$with_stabs",
597 stabs=no)
598
599 # Determine whether or not multilibs are enabled.
600 AC_ARG_ENABLE(multilib,
601 [  --enable-multilib       enable library support for multiple ABIs],
602 [], [enable_multilib=yes])
603 AC_SUBST(enable_multilib)
604
605 # Enable __cxa_atexit for C++.
606 AC_ARG_ENABLE(__cxa_atexit,
607 [  --enable-__cxa_atexit   enable __cxa_atexit for C++],
608 [], [])
609
610 # Enable C extension for decimal float if target supports it.
611 GCC_AC_ENABLE_DECIMAL_FLOAT([$target])
612
613 dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi`
614 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp,
615 [Define to 1 to enable decimal float extension to C.])
616
617 # Use default_decimal_float for dependency.
618 enable_decimal_float=$default_decimal_float
619
620 bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi`
621 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid,
622 [Define to 1 to specify that we are using the BID decimal floating
623 point format instead of DPD])
624
625 # Enable C extension for fixed-point arithmetic.
626 AC_ARG_ENABLE(fixed-point,
627 [  --enable-fixed-point    enable fixed-point arithmetic extension to C],
628 [
629 ],
630 [
631   case $target in
632     mips*-*-*)
633       case $host in
634         mips*-sgi-irix*)
635           AC_MSG_WARN([fixed-point is not supported on IRIX, ignored])
636           enable_fixed_point=no
637           ;;
638         *)
639           enable_fixed_point=yes
640           ;;
641       esac
642       ;;
643     *)
644       AC_MSG_WARN([fixed-point is not supported for this target, ignored])
645       enable_fixed_point=no
646       ;;
647   esac
648 ])
649 AC_SUBST(enable_fixed_point)
650
651 fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi`
652 AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint,
653 [Define to 1 to enable fixed-point arithmetic extension to C.])
654
655 # Enable threads
656 # Pass with no value to take the default
657 # Pass with a value to specify a thread package
658 AC_ARG_ENABLE(threads,
659 [  --enable-threads        enable thread usage for target GCC
660   --enable-threads=LIB    use LIB thread package for target GCC],,
661 [enable_threads=''])
662
663 AC_ARG_ENABLE(tls,
664 [  --enable-tls            enable or disable generation of tls code
665                           overriding the assembler check for tls support],
666 [
667   case $enable_tls in
668     yes | no) ;;
669     *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
670 Valid choices are 'yes' and 'no'.]) ;;
671   esac
672 ], [enable_tls=''])
673
674 AC_ARG_ENABLE(objc-gc,
675 [  --enable-objc-gc       enable the use of Boehm's garbage collector with
676                           the GNU Objective-C runtime],
677 if test x$enable_objc_gc = xno; then
678         objc_boehm_gc=''
679 else
680         objc_boehm_gc=1
681 fi,
682 objc_boehm_gc='')
683
684 AC_ARG_WITH(dwarf2,
685 [  --with-dwarf2           force the default debug format to be DWARF 2],
686 dwarf2="$with_dwarf2",
687 dwarf2=no)
688
689 AC_ARG_ENABLE(shared,
690 [  --disable-shared        don't provide a shared libgcc],
691 [
692   case $enable_shared in
693   yes | no) ;;
694   *)
695     enable_shared=no
696     IFS="${IFS=         }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
697     for pkg in $enableval; do
698       if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
699         enable_shared=yes
700       fi
701     done
702     IFS="$ac_save_ifs"
703     ;;
704   esac
705 ], [enable_shared=yes])
706 AC_SUBST(enable_shared)
707
708 AC_ARG_WITH(build-sysroot, 
709   [  --with-build-sysroot=sysroot
710                           use sysroot as the system root during the build])
711
712 AC_ARG_WITH(sysroot,
713 [  --with-sysroot[=DIR] Search for usr/lib, usr/include, et al, within DIR.],
714 [
715  case ${with_sysroot} in
716  yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
717  *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
718  esac
719    
720  TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
721  CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
722         
723  if test "x$prefix" = xNONE; then
724   test_prefix=/usr/local
725  else
726   test_prefix=$prefix
727  fi
728  if test "x$exec_prefix" = xNONE; then
729   test_exec_prefix=$test_prefix
730  else
731   test_exec_prefix=$exec_prefix
732  fi
733  case ${TARGET_SYSTEM_ROOT} in
734  "${test_prefix}"|"${test_prefix}/"*|\
735  "${test_exec_prefix}"|"${test_exec_prefix}/"*|\
736  '${prefix}'|'${prefix}/'*|\
737  '${exec_prefix}'|'${exec_prefix}/'*)
738    t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
739    TARGET_SYSTEM_ROOT_DEFINE="$t"
740    ;;
741  esac
742 ], [
743  TARGET_SYSTEM_ROOT=
744  TARGET_SYSTEM_ROOT_DEFINE=
745  CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
746 ])
747 AC_SUBST(TARGET_SYSTEM_ROOT)
748 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
749 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
750
751 AC_ARG_WITH(specs,
752   [AS_HELP_STRING([--with-specs=SPECS],
753                   [add SPECS to driver command-line processing])],
754   [CONFIGURE_SPECS=$withval],
755   [CONFIGURE_SPECS=]
756 )
757 AC_SUBST(CONFIGURE_SPECS)
758
759 ACX_PKGVERSION([GCC])
760 ACX_BUGURL([http://gcc.gnu.org/bugs.html])
761
762 # Sanity check enable_languages in case someone does not run the toplevel
763 # configure # script.
764 AC_ARG_ENABLE(languages,
765 [  --enable-languages=LIST specify which front-ends to build],
766 [case ,${enable_languages}, in
767        ,,|,yes,)
768                 # go safe -- we cannot be much sure without the toplevel
769                 # configure's
770                 # analysis of which target libs are present and usable
771                 enable_languages=c
772                 ;;
773          *,all,*)
774                 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
775                 ;;
776         *,c,*)
777                 ;;
778         *)
779                 enable_languages=c,${enable_languages}
780                 ;;
781 esac],
782 [enable_languages=c])
783
784 AC_ARG_WITH(multilib-list,
785 [  --with-multilib-list    Select multilibs (SH only)],
786 :,
787 with_multilib_list=default)
788
789 # -------------------------
790 # Checks for other programs
791 # -------------------------
792
793 AC_PROG_MAKE_SET
794
795 # Find some useful tools
796 AC_PROG_AWK
797 # We need awk to create options.c and options.h.
798 # Bail out if it's missing.
799 case ${AWK} in
800   "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
801 esac
802
803 gcc_AC_PROG_LN_S
804 ACX_PROG_LN($LN_S)
805 AC_PROG_RANLIB
806 case "${host}" in
807 *-*-darwin*)
808   # By default, the Darwin ranlib will not treat common symbols as
809   # definitions when  building the archive table of contents.  Other 
810   # ranlibs do that; pass an option to the Darwin ranlib that makes
811   # it behave similarly.
812   ranlib_flags="-c" 
813   ;;
814 *)
815   ranlib_flags=""
816 esac
817 AC_SUBST(ranlib_flags)
818      
819 gcc_AC_PROG_INSTALL
820
821 # See if cmp has --ignore-initial.
822 gcc_AC_PROG_CMP_IGNORE_INITIAL
823
824 # See if we have the mktemp command.
825 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
826
827 # See if makeinfo has been installed and is modern enough
828 # that we can use it.
829 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
830   [GNU texinfo.* \([0-9][0-9.]*\)],
831   [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
832 if test $gcc_cv_prog_makeinfo_modern = no; then
833   AC_MSG_WARN([
834 *** Makeinfo is missing or too old.
835 *** Info documentation will not be built.])
836   BUILD_INFO=
837 else
838   BUILD_INFO=info
839 fi
840 AC_SUBST(BUILD_INFO)
841
842 # Is pod2man recent enough to regenerate manpages?
843 AC_MSG_CHECKING([for recent Pod::Man])
844 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
845   AC_MSG_RESULT(yes)
846   GENERATED_MANPAGES=generated-manpages
847 else
848   AC_MSG_RESULT(no)
849   GENERATED_MANPAGES=
850 fi
851 AC_SUBST(GENERATED_MANPAGES)
852
853 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
854
855 # How about lex?
856 dnl Don't use AC_PROG_LEX; we insist on flex.
857 dnl LEXLIB is not useful in gcc.
858 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
859
860 # Bison?
861 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
862
863 # Binutils are not build modules, unlike bison/flex/makeinfo.  So we
864 # check for build == host before using them.
865
866 # NM
867 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
868   && test -d ../binutils ; then
869   NM='${objdir}/../binutils/nm-new'
870 else
871   AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
872 fi
873
874 # AR
875 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
876   && test -d ../binutils ; then
877   AR='${objdir}/../binutils/ar'
878 else
879   AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
880 fi
881
882
883 # --------------------
884 # Checks for C headers
885 # --------------------
886
887 # Need to reject headers which give warnings, so that the -Werror bootstrap
888 # works later. *sigh*  This needs to come before all header checks.
889 AC_PROG_CPP_WERROR
890
891 AC_HEADER_STDC
892 AC_HEADER_TIME
893 ACX_HEADER_STRING
894 AC_HEADER_SYS_WAIT
895 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
896                  fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
897                  sys/resource.h sys/param.h sys/times.h sys/stat.h \
898                  direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
899
900 # Check for thread headers.
901 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
902 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
903
904 # These tests can't be done till we know if we have limits.h.
905 gcc_AC_C_CHAR_BIT
906 AC_C_BIGENDIAN
907
908 # --------
909 # UNSORTED
910 # --------
911
912
913 # These libraries may be used by collect2.
914 # We may need a special search path to get them linked.
915 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
916 [save_LIBS="$LIBS"
917 for libs in '' -lld -lmld \
918                 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
919                 '-L/usr/lib/cmplrs/cc3.11 -lmld'
920 do
921         LIBS="$libs"
922         AC_TRY_LINK_FUNC(ldopen,
923                 [gcc_cv_collect2_libs="$libs"; break])
924 done
925 LIBS="$save_LIBS"
926 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
927 case $gcc_cv_collect2_libs in
928         "none required")        ;;
929         *)      COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
930 esac
931 AC_SUBST(COLLECT2_LIBS)
932
933 # When building Ada code on Alpha, we need exc_resume which is usually in
934 # -lexc.  So test for it.
935 save_LIBS="$LIBS"
936 LIBS=
937 AC_SEARCH_LIBS(exc_resume, exc)
938 GNAT_LIBEXC="$LIBS"
939 LIBS="$save_LIBS"
940 AC_SUBST(GNAT_LIBEXC)
941
942 # Some systems put ldexp and frexp in libm instead of libc; assume
943 # they're both in the same place.  jcf-dump needs them.
944 save_LIBS="$LIBS"
945 LIBS=
946 AC_SEARCH_LIBS(ldexp, m)
947 LDEXP_LIB="$LIBS"
948 LIBS="$save_LIBS"
949 AC_SUBST(LDEXP_LIB)
950
951 # Use <inttypes.h> only if it exists,
952 # doesn't clash with <sys/types.h>, and declares intmax_t.
953 AC_MSG_CHECKING(for inttypes.h)
954 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
955 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
956 [[#include <sys/types.h>
957 #include <inttypes.h>]],
958   [[intmax_t i = -1;]])],
959   [gcc_cv_header_inttypes_h=yes],
960   [gcc_cv_header_inttypes_h=no])])
961 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
962 if test $gcc_cv_header_inttypes_h = yes; then
963   AC_DEFINE(HAVE_INTTYPES_H, 1,
964         [Define if you have a working <inttypes.h> header file.])
965 fi
966
967 dnl Disabled until we have a complete test for buggy enum bitfields.
968 dnl gcc_AC_C_ENUM_BF_UNSIGNED
969
970 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
971   ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
972   fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
973   fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
974   putchar_unlocked putc_unlocked)
975 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoll atoq \
976         sysconf strsignal getrusage nl_langinfo \
977         gettimeofday mbstowcs wcswidth mmap mincore setlocale \
978         gcc_UNLOCKED_FUNCS)
979
980 if test x$ac_cv_func_mbstowcs = xyes; then
981   AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
982 [    AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
983 int main()
984 {
985   mbstowcs(0, "", 0);
986   return 0;
987 }]])],
988     [gcc_cv_func_mbstowcs_works=yes],
989     [gcc_cv_func_mbstowcs_works=no],
990     [gcc_cv_func_mbstowcs_works=yes])])
991   if test x$gcc_cv_func_mbstowcs_works = xyes; then
992     AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
993   [Define this macro if mbstowcs does not crash when its
994    first argument is NULL.])
995   fi
996 fi
997
998 AC_CHECK_TYPE(ssize_t, int)
999 AC_CHECK_TYPE(caddr_t, char *)
1000
1001 gcc_AC_FUNC_MMAP_BLACKLIST
1002
1003 case "${host}" in
1004 *-*-*vms*)
1005   # Under VMS, vfork works very differently than on Unix. The standard test 
1006   # won't work, and it isn't easily adaptable. It makes more sense to
1007   # just force it.
1008   ac_cv_func_vfork_works=yes
1009   ;;
1010 esac
1011 AC_FUNC_FORK
1012
1013 AM_ICONV
1014 # Until we have in-tree GNU iconv:
1015 LIBICONV_DEP=
1016 AC_SUBST(LIBICONV_DEP)
1017
1018 AM_LC_MESSAGES
1019
1020 AM_LANGINFO_CODESET
1021
1022 # We will need to find libiberty.h and ansidecl.h
1023 saved_CFLAGS="$CFLAGS"
1024 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include"
1025 gcc_AC_CHECK_DECLS(getenv atol asprintf sbrk abort atof getcwd getwd \
1026         strsignal strstr strverscmp \
1027         errno snprintf vsnprintf vasprintf malloc realloc calloc \
1028         free basename getopt clock getpagesize gcc_UNLOCKED_FUNCS, , ,[
1029 #include "ansidecl.h"
1030 #include "system.h"])
1031
1032 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1033 #include "ansidecl.h"
1034 #include "system.h"
1035 #ifdef HAVE_SYS_RESOURCE_H
1036 #include <sys/resource.h>
1037 #endif
1038 ])
1039
1040 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1041 #include "ansidecl.h"
1042 #include "system.h"
1043 #ifdef HAVE_SYS_RESOURCE_H
1044 #include <sys/resource.h>
1045 #endif
1046 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1047 [Define to `long' if <sys/resource.h> doesn't define.])])
1048
1049 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1050 # FREAD and FWRITE macros.  Fortunately, for GCC's single usage of ldgetname
1051 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1052 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1053 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1054 #include "ansidecl.h"
1055 #include "system.h"
1056 #ifdef HAVE_LDFCN_H
1057 #undef FREAD
1058 #undef FWRITE
1059 #include <ldfcn.h>
1060 #endif
1061 ])
1062
1063 gcc_AC_CHECK_DECLS(times, , ,[
1064 #include "ansidecl.h"
1065 #include "system.h"
1066 #ifdef HAVE_SYS_TIMES_H
1067 #include <sys/times.h>
1068 #endif
1069 ])
1070
1071 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1072 #include "ansidecl.h"
1073 #include "system.h"
1074 #include <signal.h>
1075 ])
1076
1077 # More time-related stuff.
1078 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1079 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1080 #include "ansidecl.h"
1081 #include "system.h"
1082 #ifdef HAVE_SYS_TIMES_H
1083 #include <sys/times.h>
1084 #endif
1085 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1086 if test $ac_cv_struct_tms = yes; then
1087   AC_DEFINE(HAVE_STRUCT_TMS, 1,
1088   [Define if <sys/times.h> defines struct tms.])
1089 fi
1090
1091 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1092 # revisit after autoconf 2.50.
1093 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1094 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1095 #include "ansidecl.h"
1096 #include "system.h"
1097 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1098 if test $gcc_cv_type_clock_t = yes; then
1099   AC_DEFINE(HAVE_CLOCK_T, 1,
1100   [Define if <time.h> defines clock_t.])
1101 fi
1102
1103 # Restore CFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1104 CFLAGS="$saved_CFLAGS"
1105
1106 gcc_AC_INITFINI_ARRAY
1107
1108 # mkdir takes a single argument on some systems. 
1109 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1110
1111 # File extensions
1112 manext='.1'
1113 objext='.o'
1114 AC_SUBST(manext)
1115 AC_SUBST(objext)
1116
1117 # With Setjmp/Longjmp based exception handling.
1118 AC_ARG_ENABLE(sjlj-exceptions,
1119 [  --enable-sjlj-exceptions
1120                           arrange to use setjmp/longjmp exception handling],
1121 [case $target in
1122   *-*-hpux10*)
1123     if test $enableval != yes; then
1124       AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1125       enableval=yes
1126     fi
1127     ;;
1128 esac
1129 force_sjlj_exceptions=yes],
1130 [case $target in
1131   *-*-hpux10*)
1132     force_sjlj_exceptions=yes
1133     enableval=yes
1134     ;;
1135   *)
1136     force_sjlj_exceptions=no
1137     ;;
1138 esac])
1139 if test $force_sjlj_exceptions = yes; then
1140   sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1141   AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1142     [Define 0/1 to force the choice for exception handling model.])
1143 fi
1144
1145 # For platforms with the unwind ABI which includes an unwind library,
1146 # libunwind, we can choose to use the system libunwind.
1147 # config.gcc also contains tests of with_system_libunwind.
1148 GCC_CHECK_UNWIND_GETIPINFO
1149
1150 # --------------------------------------------------------
1151 # Build, host, and target specific configuration fragments
1152 # --------------------------------------------------------
1153
1154 # Collect build-machine-specific information.
1155 . ${srcdir}/config.build
1156
1157 # Collect host-machine-specific information.
1158 . ${srcdir}/config.host
1159
1160 target_gtfiles=
1161
1162 # Collect target-machine-specific information.
1163 . ${srcdir}/config.gcc
1164
1165 extra_objs="${host_extra_objs} ${extra_objs}"
1166 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1167
1168 # Default the target-machine variables that were not explicitly set.
1169 if test x"$tm_file" = x
1170 then tm_file=$cpu_type/$cpu_type.h; fi
1171
1172 if test x"$extra_headers" = x
1173 then extra_headers=; fi
1174
1175 if test x$md_file = x
1176 then md_file=$cpu_type/$cpu_type.md; fi
1177
1178 if test x$out_file = x
1179 then out_file=$cpu_type/$cpu_type.c; fi
1180
1181 if test x"$tmake_file" = x
1182 then tmake_file=$cpu_type/t-$cpu_type
1183 fi
1184
1185 if test x"$dwarf2" = xyes
1186 then tm_file="$tm_file tm-dwarf2.h"
1187 fi
1188
1189 # Say what files are being used for the output code and MD file.
1190 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1191 echo "Using \`$srcdir/config/$md_file' as machine description file."
1192
1193 # If any of the xm_file variables contain nonexistent files, warn
1194 # about them and drop them.
1195
1196 bx=
1197 for x in $build_xm_file; do
1198   if    test -f $srcdir/config/$x
1199   then      bx="$bx $x"
1200   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1201   fi
1202 done
1203 build_xm_file="$bx"
1204
1205 hx=
1206 for x in $host_xm_file; do
1207   if    test -f $srcdir/config/$x
1208   then      hx="$hx $x"
1209   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1210   fi
1211 done
1212 host_xm_file="$hx"
1213
1214 tx=
1215 for x in $xm_file; do
1216   if    test -f $srcdir/config/$x
1217   then      tx="$tx $x"
1218   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1219   fi
1220 done
1221 xm_file="$tx"
1222
1223 count=a
1224 for f in $tm_file; do
1225         count=${count}x
1226 done
1227 if test $count = ax; then
1228         echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1229 else
1230         echo "Using the following target machine macro files:"
1231         for f in $tm_file; do
1232                 echo "  $srcdir/config/$f"
1233         done
1234 fi
1235
1236 if test x$need_64bit_hwint = xyes; then
1237         AC_DEFINE(NEED_64BIT_HOST_WIDE_INT, 1,
1238 [Define to 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h).])
1239 fi
1240
1241 if test x$use_long_long_for_widest_fast_int = xyes; then
1242         AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1243 [Define to 1 if the 'long long' (or '__int64') is wider than 'long' but still
1244 efficiently supported by the host hardware.])
1245 fi
1246
1247 count=a
1248 for f in $host_xm_file; do
1249         count=${count}x
1250 done
1251 if test $count = a; then
1252         :
1253 elif test $count = ax; then
1254         echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1255 else
1256         echo "Using the following host machine macro files:"
1257         for f in $host_xm_file; do
1258                 echo "  $srcdir/config/$f"
1259         done
1260 fi
1261 echo "Using ${out_host_hook_obj} for host machine hooks."
1262
1263 if test "$host_xm_file" != "$build_xm_file"; then
1264         count=a
1265         for f in $build_xm_file; do
1266                 count=${count}x
1267         done
1268         if test $count = a; then
1269                 :
1270         elif test $count = ax; then
1271                 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1272         else
1273                 echo "Using the following build machine macro files:"
1274                 for f in $build_xm_file; do
1275                         echo "  $srcdir/config/$f"
1276                 done
1277         fi
1278 fi
1279
1280 case ${host} in
1281   powerpc*-*-darwin*)
1282     AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1283       gcc_cv_mcontext_underscores,
1284       AC_COMPILE_IFELSE([
1285 #include <sys/cdefs.h>
1286 #include <sys/signal.h>
1287 #include <ucontext.h>
1288 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1289 ],
1290         gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1291       if test $gcc_cv_mcontext_underscores = yes; then
1292         AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1293           [mcontext_t fields start with __])
1294       fi
1295     ;;
1296 esac
1297
1298 # ---------
1299 # Threading
1300 # ---------
1301
1302 # Check if a valid thread package
1303 case ${enable_threads} in
1304   "" | no)
1305     # No threads
1306     target_thread_file='single'
1307     ;;
1308   yes)
1309     # default
1310     target_thread_file='single'
1311     ;;
1312   aix | dce | gnat | irix | posix | posix95 | rtems | \
1313   single | solaris | vxworks | win32 | mipssde)
1314     target_thread_file=${enable_threads}
1315     ;;
1316   *)
1317     echo "${enable_threads} is an unknown thread package" 1>&2
1318     exit 1
1319     ;;
1320 esac
1321
1322 if test x${thread_file} = x; then
1323   # No thread file set by target-specific clauses in config.gcc,
1324   # so use file chosen by default logic above
1325   thread_file=${target_thread_file}
1326 fi
1327
1328 # Make gthr-default.h if we have a thread file.
1329 gthread_flags=
1330 if test $thread_file != single; then
1331   echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h-t
1332   if diff gthr-default.h-t gthr-default.h 2>/dev/null; then
1333     rm -f gthr-default.h-t
1334   else
1335     mv -f gthr-default.h-t gthr-default.h
1336   fi
1337   gthread_flags=-DHAVE_GTHR_DEFAULT
1338 fi
1339 AC_SUBST(gthread_flags)
1340
1341 # --------
1342 # UNSORTED
1343 # --------
1344
1345 use_cxa_atexit=no
1346 if test x$enable___cxa_atexit = xyes || \
1347    test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1348   if test x$host = x$target; then
1349     case $host in
1350       # mingw32 doesn't have __cxa_atexit but uses atexit registration
1351       # keyed to flag_use_cxa_atexit
1352       *-*-mingw32*)
1353         use_cxa_atexit=yes
1354         ;;
1355       *)
1356         AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1357           [echo "__cxa_atexit can't be enabled on this target"])
1358         ;;
1359     esac
1360   else
1361     # We can't check for __cxa_atexit when building a cross, so assume
1362     # it is available 
1363     use_cxa_atexit=yes
1364   fi
1365   if test x$use_cxa_atexit = xyes; then
1366     AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1367       [Define if you want to use __cxa_atexit, rather than atexit, to
1368       register C++ destructors for local statics and global objects.
1369       This is essential for fully standards-compliant handling of
1370       destructors, but requires __cxa_atexit in libc.])
1371   fi
1372 fi
1373
1374 # Look for a file containing extra machine modes.
1375 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1376   extra_modes_file='$(srcdir)'/config/${extra_modes}
1377   AC_SUBST(extra_modes_file)
1378   AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1379   [Define to the name of a file containing a list of extra machine modes
1380    for this architecture.])
1381 fi
1382
1383 # Convert extra_options into a form suitable for Makefile use.
1384 extra_opt_files=
1385 for f in $extra_options; do
1386   extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1387 done
1388 AC_SUBST(extra_opt_files)
1389
1390 # auto-host.h is the file containing items generated by autoconf and is
1391 # the first file included by config.h.
1392 # If host=build, it is correct to have bconfig include auto-host.h
1393 # as well.  If host!=build, we are in error and need to do more 
1394 # work to find out the build config parameters.
1395 if test x$host = x$build
1396 then
1397         build_auto=auto-host.h
1398 else
1399         # We create a subdir, then run autoconf in the subdir.
1400         # To prevent recursion we set host and build for the new
1401         # invocation of configure to the build for this invocation
1402         # of configure. 
1403         tempdir=build.$$
1404         rm -rf $tempdir
1405         mkdir $tempdir
1406         cd $tempdir
1407         case ${srcdir} in
1408         /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1409         *) realsrcdir=../${srcdir};;
1410         esac
1411         saved_CFLAGS="${CFLAGS}"
1412         CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1413         LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1414         ${realsrcdir}/configure \
1415                 --enable-languages=${enable_languages-all} \
1416                 --target=$target_alias --host=$build_alias --build=$build_alias
1417         CFLAGS="${saved_CFLAGS}"
1418
1419         # We just finished tests for the build machine, so rename
1420         # the file auto-build.h in the gcc directory.
1421         mv auto-host.h ../auto-build.h
1422         cd ..
1423         rm -rf $tempdir
1424         build_auto=auto-build.h
1425 fi
1426 AC_SUBST(build_subdir)
1427
1428 tm_file="${tm_file} defaults.h"
1429 tm_p_file="${tm_p_file} tm-preds.h"
1430 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1431 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1432 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1433 # put this back in temporarily.
1434 xm_file="auto-host.h ansidecl.h ${xm_file}"
1435
1436 # --------
1437 # UNSORTED
1438 # --------
1439
1440 changequote(,)dnl
1441 # Compile in configure arguments.
1442 if test -f configargs.h ; then
1443         # Being re-configured.
1444         gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1445         gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1446 else
1447         gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1448 fi
1449
1450 # Double all backslashes and backslash all quotes to turn
1451 # gcc_config_arguments into a C string.
1452 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1453 $gcc_config_arguments
1454 EOF
1455 gcc_config_arguments_str=`cat conftest.out`
1456 rm -f conftest.out
1457
1458 cat > configargs.h <<EOF
1459 /* Generated automatically. */
1460 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1461 static const char thread_model[] = "$thread_file";
1462
1463 static const struct {
1464   const char *name, *value;
1465 } configure_default_options[] = $configure_default_options;
1466 EOF
1467 changequote([,])dnl
1468
1469 changequote(,)dnl
1470 gcc_BASEVER=`cat $srcdir/BASE-VER`
1471 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
1472 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
1473 if test -f $srcdir/REVISION ; then
1474         gcc_REVISION=`cat $srcdir/REVISION`
1475 else
1476         gcc_REVISION=""
1477 fi
1478 cat > plugin-version.h <<EOF
1479 #include "configargs.h"
1480
1481 static char basever[] = "$gcc_BASEVER";
1482 static char datestamp[] = "$gcc_DATESTAMP";
1483 static char devphase[] = "$gcc_DEVPHASE";
1484 static char revision[] = "$gcc_REVISION";
1485
1486 /* FIXME plugins: We should make the version information more precise.
1487    One way to do is to add a checksum. */
1488
1489 static struct plugin_gcc_version gcc_version = {basever, datestamp,
1490                                                 devphase, revision,
1491                                                 configuration_arguments};
1492 EOF
1493 changequote([,])dnl
1494
1495 # Internationalization
1496 ZW_GNU_GETTEXT_SISTER_DIR
1497
1498 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1499 # -liconv on the link line twice.
1500 case "$LIBINTL" in *$LIBICONV*)
1501         LIBICONV= ;;
1502 esac
1503
1504 AC_ARG_ENABLE(secureplt,
1505 [  --enable-secureplt      enable -msecure-plt by default for PowerPC],
1506 [], [])
1507
1508 AC_ARG_ENABLE(leading-mingw64-underscores,
1509   AS_HELP_STRING([--enable-leading-mingw64-underscores],
1510                  [Enable leading underscores on 64 bit mingw targets]),
1511   [],[])
1512 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
1513   [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
1514     [Define if we should use leading underscore on 64 bit mingw targets])])
1515
1516 AC_ARG_ENABLE(cld,
1517 [  --enable-cld            enable -mcld by default for 32bit x86], [],
1518 [enable_cld=no])
1519
1520 AC_ARG_ENABLE(frame-pointer,
1521 [  --enable-frame-pointer  enable -fno-omit-frame-pointer by default for 32bit x86], [],
1522 [
1523 case $target_os in
1524 linux* | darwin[[8912]]*)
1525   # Enable -fomit-frame-pointer by default for Linux and Darwin with
1526   # DWARF2.
1527   enable_frame_pointer=no
1528   ;;
1529 *)
1530   enable_frame_pointer=yes
1531   ;;
1532 esac
1533 ])
1534
1535 # Windows32 Registry support for specifying GCC installation paths.
1536 AC_ARG_ENABLE(win32-registry,
1537 [  --disable-win32-registry
1538                           disable lookup of installation paths in the
1539                           Registry on Windows hosts
1540   --enable-win32-registry enable registry lookup (default)
1541   --enable-win32-registry=KEY
1542                           use KEY instead of GCC version as the last portion
1543                           of the registry key],,)
1544
1545 case $host_os in
1546   win32 | pe | cygwin* | mingw32* | uwin*)
1547     if test "x$enable_win32_registry" != xno; then
1548       AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1549     fi
1550
1551     if test "x$enable_win32_registry" != xno; then
1552       AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1553   [Define to 1 if installation paths should be looked up in the Windows
1554    Registry. Ignored on non-Windows hosts.])
1555
1556       if test "x$enable_win32_registry" != xyes \
1557          && test "x$enable_win32_registry" != x; then
1558         AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1559   [Define to be the last component of the Windows registry key under which
1560    to look for installation paths.  The full key used will be 
1561    HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1562    The default is the GCC version number.])
1563       fi
1564     fi
1565   ;;
1566 esac
1567
1568 # Get an absolute path to the GCC top-level source directory
1569 holddir=`${PWDCMD-pwd}`
1570 cd $srcdir
1571 topdir=`${PWDCMD-pwd}`
1572 cd $holddir
1573
1574 # Conditionalize the makefile for this host machine.
1575 xmake_file=
1576 for f in ${host_xmake_file}
1577 do
1578         if test -f ${srcdir}/config/$f
1579         then
1580                 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1581         fi
1582 done
1583
1584 # Conditionalize the makefile for this target machine.
1585 tmake_file_=
1586 for f in ${tmake_file}
1587 do
1588         if test -f ${srcdir}/config/$f
1589         then
1590                 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1591         fi
1592 done
1593 tmake_file="${tmake_file_}"
1594
1595 out_object_file=`basename $out_file .c`.o
1596
1597 tm_file_list="options.h"
1598 tm_include_list="options.h insn-constants.h"
1599 for f in $tm_file; do
1600   case $f in
1601     ./* )
1602        f=`echo $f | sed 's/^..//'`
1603        tm_file_list="${tm_file_list} $f"
1604        tm_include_list="${tm_include_list} $f"
1605        ;;
1606     defaults.h )
1607        tm_file_list="${tm_file_list} \$(srcdir)/$f"
1608        tm_include_list="${tm_include_list} $f"
1609        ;;
1610     * )
1611        tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1612        tm_include_list="${tm_include_list} config/$f"
1613        ;;
1614   esac
1615 done
1616
1617 tm_p_file_list=
1618 tm_p_include_list=
1619 for f in $tm_p_file; do
1620   case $f in
1621     tm-preds.h )
1622        tm_p_file_list="${tm_p_file_list} $f"
1623        tm_p_include_list="${tm_p_include_list} $f"
1624        ;;
1625     * )
1626        tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1627        tm_p_include_list="${tm_p_include_list} config/$f"
1628   esac
1629 done
1630
1631 xm_file_list=
1632 xm_include_list=
1633 for f in $xm_file; do
1634   case $f in
1635     ansidecl.h )
1636        xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1637        xm_include_list="${xm_include_list} $f"
1638        ;;
1639     auto-host.h )
1640        xm_file_list="${xm_file_list} $f"
1641        xm_include_list="${xm_include_list} $f"
1642        ;;
1643     * )
1644        xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1645        xm_include_list="${xm_include_list} config/$f"
1646        ;;
1647   esac
1648 done
1649
1650 host_xm_file_list=
1651 host_xm_include_list=
1652 for f in $host_xm_file; do
1653   case $f in
1654     ansidecl.h )
1655        host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1656        host_xm_include_list="${host_xm_include_list} $f"
1657        ;;
1658     auto-host.h )
1659        host_xm_file_list="${host_xm_file_list} $f"
1660        host_xm_include_list="${host_xm_include_list} $f"
1661        ;;
1662     * )
1663        host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1664        host_xm_include_list="${host_xm_include_list} config/$f"
1665        ;;
1666   esac
1667 done
1668
1669 build_xm_file_list=
1670 for f in $build_xm_file; do
1671   case $f in
1672     ansidecl.h )
1673        build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1674        build_xm_include_list="${build_xm_include_list} $f"
1675        ;;
1676     auto-build.h | auto-host.h )
1677        build_xm_file_list="${build_xm_file_list} $f"
1678        build_xm_include_list="${build_xm_include_list} $f"
1679        ;;
1680     * )
1681        build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1682        build_xm_include_list="${build_xm_include_list} config/$f"
1683        ;;
1684   esac
1685 done
1686
1687 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1688 # cross-compiler which does not use the native headers and libraries.
1689 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1690 CROSS=                                          AC_SUBST(CROSS)
1691 ALL=all.internal                                AC_SUBST(ALL)
1692 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1693
1694 if test "x$with_build_sysroot" != x; then
1695   build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1696 else
1697   # This value is used, even on a native system, because 
1698   # CROSS_SYSTEM_HEADER_DIR is just 
1699   # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1700   build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1701 fi
1702
1703 if test x$host != x$target
1704 then
1705         CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1706         ALL=all.cross
1707         SYSTEM_HEADER_DIR=$build_system_header_dir
1708         case "$host","$target" in
1709         # Darwin crosses can use the host system's libraries and headers,
1710         # because of the fat library support.  Of course, it must be the
1711         # same version of Darwin on both sides.  Allow the user to
1712         # just say --target=foo-darwin without a version number to mean
1713         # "the version on this system".
1714             *-*-darwin*,*-*-darwin*)
1715                 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1716                 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1717                 if test $hostos = $targetos -o $targetos = darwin ; then
1718                     CROSS=
1719                     SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1720                     with_headers=yes
1721                 fi
1722                 ;;
1723
1724             i?86-*-*,x86_64-*-* \
1725             | powerpc*-*-*,powerpc64*-*-*)
1726                 CROSS="$CROSS -DNATIVE_CROSS" ;;
1727         esac
1728
1729         case $target in
1730                 *-*-mingw*)
1731                         if test "x$with_headers" = x; then
1732                                 with_headers=yes
1733                         fi
1734                         ;;
1735                 *)
1736                         ;;
1737         esac
1738 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1739         SYSTEM_HEADER_DIR=$build_system_header_dir 
1740 fi
1741
1742 # If this is a cross-compiler that does not
1743 # have its own set of headers then define
1744 # inhibit_libc
1745
1746 # If this is using newlib, without having the headers available now,
1747 # then define inhibit_libc in LIBGCC2_CFLAGS.
1748 # This prevents libgcc2 from containing any code which requires libc
1749 # support.
1750 : ${inhibit_libc=false}
1751 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1752        test x$with_newlib = xyes ; } &&
1753      { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1754        inhibit_libc=true
1755 fi
1756 AC_SUBST(inhibit_libc)
1757
1758 # When building gcc with a cross-compiler, we need to adjust things so
1759 # that the generator programs are still built with the native compiler.
1760 # Also, we cannot run fixincludes.
1761
1762 # These are the normal (build=host) settings:
1763 CC_FOR_BUILD='$(CC)'            AC_SUBST(CC_FOR_BUILD)
1764 BUILD_CFLAGS='$(ALL_CFLAGS)'    AC_SUBST(BUILD_CFLAGS)
1765 BUILD_LDFLAGS='$(LDFLAGS)'      AC_SUBST(BUILD_LDFLAGS)
1766 STMP_FIXINC=stmp-fixinc         AC_SUBST(STMP_FIXINC)
1767
1768 # And these apply if build != host, or we are generating coverage data
1769 if test x$build != x$host || test "x$coverage_flags" != x
1770 then
1771     BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1772     BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
1773 fi
1774
1775 # Expand extra_headers to include complete path.
1776 # This substitutes for lots of t-* files.
1777 extra_headers_list=
1778 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1779 for file in ${extra_headers} ; do
1780   extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1781 done
1782
1783 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
1784 if test x"$use_gcc_tgmath" = xyes
1785 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
1786 fi
1787
1788 # Define collect2 in Makefile.
1789 case $host_can_use_collect2 in
1790   no) collect2= ;;
1791   *) collect2='collect2$(exeext)' ;;
1792 esac
1793 AC_SUBST([collect2])
1794
1795 # Add a definition of USE_COLLECT2 if system wants one.
1796 case $use_collect2 in
1797   no) use_collect2= ;;
1798   "") ;;
1799   *) 
1800     host_xm_defines="${host_xm_defines} USE_COLLECT2"
1801     xm_defines="${xm_defines} USE_COLLECT2"
1802     case $host_can_use_collect2 in
1803       no)
1804         AC_MSG_ERROR([collect2 is required but cannot be built on this system])
1805         ;;
1806     esac
1807     ;;
1808 esac
1809
1810 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
1811 [Define to the name of the LTO plugin DSO that must be
1812   passed to the linker's -plugin=LIB option.])
1813
1814 # ---------------------------
1815 # Assembler & linker features
1816 # ---------------------------
1817
1818 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
1819 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
1820 # However when ld-new is first executed from the build tree, libtool will
1821 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
1822 # to the build tree.  While doing this we need to use the previous-stage
1823 # linker, or we have an infinite loop.  The presence of a shell script as
1824 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
1825 # the gcc/collect-ld script.  So we need to know how libtool works, or
1826 # exec-tool will fail.
1827
1828 m4_defun([_LT_CONFIG_COMMANDS], [])
1829 AC_PROG_LIBTOOL
1830 AC_SUBST(objdir)
1831 AC_SUBST(enable_fast_install)
1832
1833 # Identify the assembler which will work hand-in-glove with the newly
1834 # built GCC, so that we can examine its features.  This is the assembler
1835 # which will be driven by the driver program.
1836 #
1837 # If build != host, and we aren't building gas in-tree, we identify a
1838 # build->target assembler and hope that it will have the same features
1839 # as the host->target assembler we'll be using.
1840 gcc_cv_gas_major_version=
1841 gcc_cv_gas_minor_version=
1842 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1843
1844 m4_pattern_allow([AS_FOR_TARGET])dnl
1845 AS_VAR_SET_IF(gcc_cv_as,, [
1846 if test -x "$DEFAULT_ASSEMBLER"; then
1847         gcc_cv_as="$DEFAULT_ASSEMBLER"
1848 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
1849      && test -f ../gas/Makefile \
1850      && test x$build = x$host; then
1851         gcc_cv_as=../gas/as-new$build_exeext
1852 elif test -x as$build_exeext; then
1853         # Build using assembler in the current directory.
1854         gcc_cv_as=./as$build_exeext
1855 elif test -x $AS_FOR_TARGET; then
1856         gcc_cv_as="$AS_FOR_TARGET"
1857 else
1858         AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
1859 fi])
1860
1861 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
1862 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
1863 case "$ORIGINAL_AS_FOR_TARGET" in
1864   ./as | ./as$build_exeext) ;;
1865   *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
1866 esac 
1867
1868 AC_MSG_CHECKING(what assembler to use)
1869 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
1870   # Single tree build which includes gas.  We want to prefer it
1871   # over whatever linker top-level may have detected, since
1872   # we'll use what we're building after installation anyway.
1873   AC_MSG_RESULT(newly built gas)
1874   in_tree_gas=yes
1875   _gcc_COMPUTE_GAS_VERSION
1876   in_tree_gas_is_elf=no
1877   if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
1878      || (grep 'obj_format = multi' ../gas/Makefile \
1879          && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
1880   then
1881     in_tree_gas_is_elf=yes
1882   fi
1883 else
1884   AC_MSG_RESULT($gcc_cv_as)
1885   in_tree_gas=no
1886 fi
1887
1888 # Identify the linker which will work hand-in-glove with the newly
1889 # built GCC, so that we can examine its features.  This is the linker
1890 # which will be driven by the driver program.
1891 #
1892 # If build != host, and we aren't building gas in-tree, we identify a
1893 # build->target linker and hope that it will have the same features
1894 # as the host->target linker we'll be using.
1895 gcc_cv_gld_major_version=
1896 gcc_cv_gld_minor_version=
1897 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1898 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1899
1900 AS_VAR_SET_IF(gcc_cv_ld,, [
1901 if test -x "$DEFAULT_LINKER"; then
1902         gcc_cv_ld="$DEFAULT_LINKER"
1903 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
1904      && test -f ../ld/Makefile \
1905      && test x$build = x$host; then
1906         gcc_cv_ld=../ld/ld-new$build_exeext
1907 elif test -x collect-ld$build_exeext; then
1908         # Build using linker in the current directory.
1909         gcc_cv_ld=./collect-ld$build_exeext
1910 elif test -x $LD_FOR_TARGET; then
1911         gcc_cv_ld="$LD_FOR_TARGET"
1912 else
1913         AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
1914 fi])
1915
1916 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
1917 PLUGIN_LD=`basename $gcc_cv_ld`
1918 AC_ARG_WITH(plugin-ld,
1919 [  --with-plugin-ld=[[ARG]]  specify the plugin linker],
1920 [if test x"$withval" != x; then
1921    ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
1922    PLUGIN_LD="$withval"
1923  fi])
1924 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
1925 AC_DEFINE_UNQUOTED(PLUGIN_LD, "$PLUGIN_LD", [Specify plugin linker])
1926
1927 # Check to see if we are using gold instead of ld
1928 AC_MSG_CHECKING(whether we are using gold)
1929 ld_is_gold=no
1930 if test x$gcc_cv_ld != x; then
1931   if $gcc_cv_ld --version 2>/dev/null | sed 1q \
1932      | grep "GNU gold" > /dev/null; then
1933     ld_is_gold=yes
1934   fi
1935 fi
1936 AC_MSG_RESULT($ld_is_gold)
1937
1938 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
1939 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
1940 case "$ORIGINAL_LD_FOR_TARGET" in
1941   ./collect-ld | ./collect-ld$build_exeext) ;;
1942   *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
1943 esac 
1944
1945 AC_MSG_CHECKING(what linker to use)
1946 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext; then
1947         # Single tree build which includes ld.  We want to prefer it
1948         # over whatever linker top-level may have detected, since
1949         # we'll use what we're building after installation anyway.
1950         AC_MSG_RESULT(newly built ld)
1951         in_tree_ld=yes
1952         in_tree_ld_is_elf=no
1953         if (grep 'EMUL = .*elf' ../ld/Makefile \
1954             || grep 'EMUL = .*linux' ../ld/Makefile \
1955             || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
1956           in_tree_ld_is_elf=yes
1957         fi
1958         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
1959         do
1960 changequote(,)dnl
1961                 gcc_cv_gld_version=`sed -n -e 's/^[     ]*\(VERSION=[0-9]*\.[0-9]*.*\)/\1/p' < $f`
1962                 if test x$gcc_cv_gld_version != x; then
1963                         break
1964                 fi
1965         done
1966         gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
1967         gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1968 changequote([,])dnl
1969 else
1970         AC_MSG_RESULT($gcc_cv_ld)
1971         in_tree_ld=no
1972 fi
1973
1974 # Figure out what nm we will be using.
1975 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
1976 AS_VAR_SET_IF(gcc_cv_nm,, [
1977 if test -f $gcc_cv_binutils_srcdir/configure.in \
1978      && test -f ../binutils/Makefile \
1979      && test x$build = x$host; then
1980         gcc_cv_nm=../binutils/nm-new$build_exeext
1981 elif test -x nm$build_exeext; then
1982         gcc_cv_nm=./nm$build_exeext
1983 elif test -x $NM_FOR_TARGET; then
1984         gcc_cv_nm="$NM_FOR_TARGET"
1985 else
1986         AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
1987 fi])
1988
1989 AC_MSG_CHECKING(what nm to use)
1990 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
1991         # Single tree build which includes binutils.
1992         AC_MSG_RESULT(newly built nm)
1993         in_tree_nm=yes
1994 else
1995         AC_MSG_RESULT($gcc_cv_nm)
1996         in_tree_nm=no
1997 fi
1998
1999 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2000 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2001 case "$ORIGINAL_NM_FOR_TARGET" in
2002   ./nm | ./nm$build_exeext) ;;
2003   *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2004 esac
2005
2006
2007 # Figure out what objdump we will be using.
2008 AS_VAR_SET_IF(gcc_cv_objdump,, [
2009 if test -f $gcc_cv_binutils_srcdir/configure.in \
2010      && test -f ../binutils/Makefile \
2011      && test x$build = x$host; then
2012         # Single tree build which includes binutils.
2013         gcc_cv_objdump=../binutils/objdump$build_exeext
2014 elif test -x objdump$build_exeext; then
2015         gcc_cv_objdump=./objdump$build_exeext
2016 elif test -x $OBJDUMP_FOR_TARGET; then
2017         gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2018 else
2019         AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2020 fi])
2021
2022 AC_MSG_CHECKING(what objdump to use)
2023 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2024         # Single tree build which includes binutils.
2025         AC_MSG_RESULT(newly built objdump)
2026 elif test x$gcc_cv_objdump = x; then
2027         AC_MSG_RESULT(not found)
2028 else
2029         AC_MSG_RESULT($gcc_cv_objdump)
2030 fi
2031
2032 # Figure out what readelf we will be using.
2033 AS_VAR_SET_IF(gcc_cv_readelf,, [
2034 if test -f $gcc_cv_binutils_srcdir/configure.in \
2035      && test -f ../binutils/Makefile \
2036      && test x$build = x$host; then
2037         # Single tree build which includes binutils.
2038         gcc_cv_readelf=../binutils/readelf$build_exeext
2039 elif test -x readelf$build_exeext; then
2040         gcc_cv_readelf=./readelf$build_exeext
2041 else
2042         AC_PATH_PROG(gcc_cv_readelf, readelf)
2043 fi])
2044
2045 AC_MSG_CHECKING(what readelf to use)
2046 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2047         # Single tree build which includes binutils.
2048         AC_MSG_RESULT(newly built readelf)
2049 elif test x$gcc_cv_readelf = x; then
2050         AC_MSG_RESULT(not found)
2051 else
2052         AC_MSG_RESULT($gcc_cv_readelf)
2053 fi
2054
2055 # Figure out what assembler alignment features are present.
2056 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2057  [2,6,0],,
2058 [.balign 4
2059 .p2align 2],,
2060 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2061   [Define if your assembler supports .balign and .p2align.])])
2062
2063 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2064  [2,8,0],,
2065  [.p2align 4,,7],,
2066 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2067   [Define if your assembler supports specifying the maximum number
2068    of bytes to skip when using the GAS .p2align command.])])
2069
2070 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2071  [2,8,0],,
2072  [.literal16],,
2073 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2074   [Define if your assembler supports .literal16.])])
2075
2076 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2077  [elf,2,9,0],,
2078  [conftest_label1: .word 0
2079 .subsection -1
2080 conftest_label2: .word 0
2081 .previous],
2082  [if test x$gcc_cv_nm != x; then
2083     $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2084     $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2085     if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2086     then :
2087     else gcc_cv_as_subsection_m1=yes
2088     fi
2089     rm -f conftest.nm1 conftest.nm2
2090   fi],
2091  [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2092   [Define if your assembler supports .subsection and .subsection -1 starts
2093    emitting at the beginning of your section.])])
2094
2095 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2096  [2,2,0],,
2097  [      .weak foobar],,
2098 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2099
2100 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2101  [2,17,0],,
2102  [      .weakref foobar, barfnot],,
2103 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2104
2105 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2106  [2,15,91],,
2107  [      .SPACE $TEXT$
2108         .NSUBSPA $CODE$,COMDAT],,
2109 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2110
2111 # .hidden needs to be supported in both the assembler and the linker,
2112 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2113 # This is irritatingly difficult to feature test for; we have to check the
2114 # date string after the version number.  If we've got an in-tree
2115 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2116 # to be safe.
2117 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2118 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2119  [elf,2,13,0],,
2120 [       .hidden foobar
2121 foobar:],[
2122 # Solaris 9/x86 as incorrectly emits an alias for a hidden symbol with
2123 # STV_HIDDEN, so disable .hidden support if so.
2124 case "${target}" in
2125   i?86-*-solaris2*)
2126     if test x$gcc_cv_as != x && test x$gcc_cv_objdump != x; then
2127       cat > conftest.s <<EOF
2128 .globl hidden
2129         .hidden hidden
2130 hidden:
2131 .globl default
2132         .set    default,hidden
2133 EOF
2134       if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
2135         && $gcc_cv_objdump -t conftest.o 2>/dev/null | \
2136         grep '\.hidden default' > /dev/null; then
2137         gcc_cv_as_hidden=no
2138       else
2139         gcc_cv_as_hidden=yes
2140       fi
2141     else
2142       # Assume bug is present if objdump is missing.
2143       gcc_cv_as_hidden=no
2144     fi
2145     ;;
2146   *)
2147     gcc_cv_as_hidden=yes
2148     ;;
2149 esac])
2150
2151 # gnu_indirect_function type is an extension proposed at
2152 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2153 # selection of function implementation
2154 AC_ARG_ENABLE(gnu-indirect-function,
2155  [AS_HELP_STRING([--enable-gnu-indirect-function],
2156                  [enable the use of the @gnu_indirect_function to glibc systems])],
2157  [case $enable_gnu_indirect_function in
2158     yes | no) ;;
2159     *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2160 Valid choices are 'yes' and 'no'.]) ;;
2161   esac],
2162  [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2163 if test x$enable_gnu_indirect_function = xyes; then
2164   AC_DEFINE(HAVE_GNU_INDIRECT_FUNCTION, 1,
2165    [Define if your system supports gnu indirect functions.])
2166 fi
2167
2168 changequote(,)dnl
2169 if test $in_tree_ld != yes ; then
2170   ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2171   if test x"$ld_is_gold" = xyes; then
2172     gcc_cv_ld_hidden=yes
2173   elif echo "$ld_ver" | grep GNU > /dev/null; then
2174     ld_vers=`echo $ld_ver | sed -n \
2175         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2176     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'`
2177     ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2178     ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2179     ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2180   else
2181     case "${target}" in
2182       *-*-solaris2*)
2183         #
2184         # Solaris 2 ld -V output looks like this for a regular version:
2185         #
2186         # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1699
2187         #
2188         # but test versions add stuff at the end:
2189         #
2190         # ld: Software Generation Utilities - Solaris Link Editors: 5.11-1.1701:onnv-ab196087-6931056-03/25/10
2191         #
2192         ld_ver=`$gcc_cv_ld -V 2>&1`
2193         if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2194           ld_vers=`echo $ld_ver | sed -n \
2195             -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2196           ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2197           ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2198         fi
2199         ;;
2200     esac
2201   fi
2202 fi
2203 changequote([,])dnl
2204
2205 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2206 [[if test $in_tree_ld = yes ; then
2207   gcc_cv_ld_hidden=no
2208   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 \
2209      && test $in_tree_ld_is_elf = yes; then
2210      gcc_cv_ld_hidden=yes
2211   fi
2212 else
2213   gcc_cv_ld_hidden=yes
2214   if echo "$ld_ver" | grep GNU > /dev/null; then
2215     if test 0"$ld_date" -lt 20020404; then
2216       if test -n "$ld_date"; then
2217         # If there was date string, but was earlier than 2002-04-04, fail
2218         gcc_cv_ld_hidden=no
2219       elif test -z "$ld_vers"; then
2220         # If there was no date string nor ld version number, something is wrong
2221         gcc_cv_ld_hidden=no
2222       else
2223         test -z "$ld_vers_patch" && ld_vers_patch=0
2224         if test "$ld_vers_major" -lt 2; then
2225           gcc_cv_ld_hidden=no
2226         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2227           gcc_cv_ld_hidden="no"
2228         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2229           gcc_cv_ld_hidden=no
2230         fi
2231       fi
2232     fi
2233   else
2234     case "${target}" in
2235       hppa64*-*-hpux* | ia64*-*-hpux*)
2236         gcc_cv_ld_hidden=yes
2237         ;;
2238       *-*-solaris2.8*)
2239         # .hidden support was backported to Solaris 8, starting with ld
2240         # version 1.276.
2241         if test "$ld_vers_minor" -ge 276; then
2242           gcc_cv_ld_hidden=yes
2243         else
2244           gcc_cv_ld_hidden=no
2245         fi
2246         ;;
2247       *-*-solaris2.9* | *-*-solaris2.1[0-9]*)
2248         # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2249         # .symbolic was only added in Solaris 9 12/02.
2250         gcc_cv_ld_hidden=yes
2251         ;;
2252       *)
2253         gcc_cv_ld_hidden=no
2254         ;;
2255     esac
2256   fi
2257 fi]])
2258 libgcc_visibility=no
2259 AC_SUBST(libgcc_visibility)
2260 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2261 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2262   libgcc_visibility=yes
2263   AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2264   [Define if your assembler and linker support .hidden.])
2265 fi
2266
2267 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2268 gcc_cv_ld_ro_rw_mix=unknown
2269 if test $in_tree_ld = yes ; then
2270   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 \
2271      && test $in_tree_ld_is_elf = yes; then
2272     gcc_cv_ld_ro_rw_mix=read-write
2273   fi
2274 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2275   echo '.section myfoosect, "a"' > conftest1.s
2276   echo '.section myfoosect, "aw"' > conftest2.s
2277   echo '.byte 1' >> conftest2.s
2278   echo '.section myfoosect, "a"' > conftest3.s
2279   echo '.byte 0' >> conftest3.s
2280   if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2281      && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2282      && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2283      && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2284         conftest2.o conftest3.o > /dev/null 2>&1; then
2285     gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2286                          | sed -e '/myfoosect/!d' -e N`
2287     if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2288       if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2289         gcc_cv_ld_ro_rw_mix=read-only
2290       else
2291         gcc_cv_ld_ro_rw_mix=read-write
2292       fi
2293     fi
2294   fi
2295 changequote(,)dnl
2296   rm -f conftest.* conftest[123].*
2297 changequote([,])dnl
2298 fi
2299 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2300         AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2301   [Define if your linker links a mix of read-only
2302    and read-write sections into a read-write section.])
2303 fi
2304 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2305
2306 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2307 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2308   [elf,2,11,0],,
2309 [       .data
2310         .uleb128 L2 - L1
2311 L1:
2312         .uleb128 1280
2313         .sleb128 -1010
2314 L2:],
2315 [[# GAS versions before 2.11 do not support uleb128,
2316   # despite appearing to.
2317   # ??? There exists an elf-specific test that will crash
2318   # the assembler.  Perhaps it's better to figure out whether
2319   # arbitrary sections are supported and try the test.
2320   as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2321   if echo "$as_ver" | grep GNU > /dev/null; then
2322     as_vers=`echo $as_ver | sed -n \
2323         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2324     as_major=`expr "$as_vers" : '\([0-9]*\)'`
2325     as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2326     if test $as_major -eq 2 && test $as_minor -lt 11
2327     then :
2328     else gcc_cv_as_leb128=yes
2329     fi
2330   fi]],
2331   [AC_DEFINE(HAVE_AS_LEB128, 1,
2332     [Define if your assembler supports .sleb128 and .uleb128.])])
2333
2334 # Check if we have assembler support for unwind directives.
2335 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2336   ,,
2337 [       .text
2338         .cfi_startproc
2339         .cfi_offset 0, 0
2340         .cfi_same_value 1
2341         .cfi_def_cfa 1, 2
2342         .cfi_escape 1, 2, 3, 4, 5
2343         .cfi_endproc],
2344 [case "$target" in
2345   *-*-solaris*)
2346     # If the linker used on Solaris (like Sun ld) isn't capable of merging
2347     # read-only and read-write sections, we need to make sure that the
2348     # assembler used emits read-write .eh_frame sections.
2349     if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2350       if test "x$gcc_cv_objdump" != x; then
2351         if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2352                 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2353           gcc_cv_as_cfi_directive=no
2354         else
2355           case "$target" in
2356             i?86-*-solaris2.1[[0-9]]*)
2357               # On Solaris/x86, make sure that GCC and gas agree on using
2358               # read-only .eh_frame sections for 64-bit.
2359               if $gcc_cv_as --64 -o conftest.o conftest.s > /dev/null 2>&1 && \
2360                 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2361                         sed -e /.eh_frame/!d -e N | \
2362                         grep READONLY > /dev/null; then
2363                 gcc_cv_as_cfi_directive=yes
2364               else
2365                 gcc_cv_as_cfi_directive=no
2366               fi
2367               ;;
2368             *)
2369               gcc_cv_as_cfi_directive=yes
2370               ;;
2371           esac 
2372         fi
2373       else
2374         # no objdump, err on the side of caution
2375         gcc_cv_as_cfi_directive=no
2376       fi
2377     else
2378       gcc_cv_as_cfi_directive=yes
2379     fi
2380     ;;
2381   *-*-*)
2382     gcc_cv_as_cfi_directive=yes
2383     ;;
2384 esac])
2385 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
2386 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2387   ,,
2388 [       .text
2389         .cfi_startproc
2390         .cfi_adjust_cfa_offset 64
2391         .skip 75040, 0
2392         .cfi_adjust_cfa_offset 128
2393         .cfi_endproc],
2394 [[
2395 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
2396     | grep 'DW_CFA_advance_loc[24]:[    ][      ]*75040[        ]' >/dev/null; then
2397    gcc_cv_as_cfi_advance_working=yes
2398 fi
2399 ]])
2400 else
2401   # no objdump, err on the side of caution
2402   gcc_cv_as_cfi_advance_working=no
2403 fi
2404 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
2405 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2406   [`if test $gcc_cv_as_cfi_directive = yes \
2407        && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2408   [Define 0/1 if your assembler supports CFI directives.])
2409
2410 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
2411 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2412   gcc_cv_as_cfi_personality_directive, ,,
2413 [       .text
2414         .cfi_startproc
2415         .cfi_personality 0, symbol
2416         .cfi_endproc])
2417 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2418   [`if test $gcc_cv_as_cfi_personality_directive = yes;
2419     then echo 1; else echo 0; fi`],
2420   [Define 0/1 if your assembler supports .cfi_personality.])
2421
2422 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2423   gcc_cv_as_cfi_sections_directive, ,,
2424 [       .text
2425         .cfi_sections .debug_frame, .eh_frame
2426         .cfi_startproc
2427         .cfi_endproc],
2428 [case $target_os in
2429   win32 | pe | cygwin* | mingw32* | uwin*)
2430     # Need to check that we generated the correct relocation for the
2431     # .debug_frame section.  This was fixed for binutils 2.21.
2432     gcc_cv_as_cfi_sections_directive=no
2433     if test "x$gcc_cv_objdump" != x; then
2434      if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
2435         grep secrel > /dev/null; then
2436       gcc_cv_as_cfi_sections_directive=yes
2437      fi
2438     fi
2439     ;;
2440   *)
2441     gcc_cv_as_cfi_sections_directive=yes
2442     ;;
2443 esac])
2444 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
2445 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2446   [`if test $gcc_cv_as_cfi_sections_directive = yes;
2447     then echo 1; else echo 0; fi`],
2448   [Define 0/1 if your assembler supports .cfi_sections.])
2449
2450 # GAS versions up to and including 2.11.0 may mis-optimize
2451 # .eh_frame data.
2452 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2453   [elf,2,12,0],,
2454 [       .text
2455 .LFB1:
2456         .4byte  0
2457 .L1:
2458         .4byte  0
2459 .LFE1:
2460         .section        .eh_frame,"aw",@progbits
2461 __FRAME_BEGIN__:
2462         .4byte  .LECIE1-.LSCIE1
2463 .LSCIE1:
2464         .4byte  0x0
2465         .byte   0x1
2466         .ascii "z\0"
2467         .byte   0x1
2468         .byte   0x78
2469         .byte   0x1a
2470         .byte   0x0
2471         .byte   0x4
2472         .4byte  1
2473         .p2align 1
2474 .LECIE1:
2475 .LSFDE1:
2476         .4byte  .LEFDE1-.LASFDE1
2477 .LASFDE1:
2478         .4byte  .LASFDE1-__FRAME_BEGIN__
2479         .4byte  .LFB1
2480         .4byte  .LFE1-.LFB1
2481         .byte   0x4
2482         .4byte  .LFE1-.LFB1
2483         .byte   0x4
2484         .4byte  .L1-.LFB1
2485 .LEFDE1:],
2486 [  dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2487 cat > conftest.lit <<EOF
2488  0000 10000000 00000000 017a0001 781a0004  .........z..x...
2489  0010 01000000 12000000 18000000 00000000  ................
2490  0020 08000000 04080000 0044               .........D      @&t@
2491 EOF
2492 cat > conftest.big <<EOF
2493  0000 00000010 00000000 017a0001 781a0004  .........z..x...
2494  0010 00000001 00000012 00000018 00000000  ................
2495  0020 00000008 04000000 0844               .........D      @&t@
2496 EOF
2497   # If the assembler didn't choke, and we can objdump,
2498   # and we got the correct data, then succeed.
2499   # The text in the here-document typically retains its unix-style line
2500   # endings, while the output of objdump will use host line endings.
2501   # Therefore, use diff -b for the comparisons.
2502   if test x$gcc_cv_objdump != x \
2503   && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2504      | tail -3 > conftest.got \
2505   && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2506     || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2507   then
2508     gcc_cv_as_eh_frame=yes
2509   elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2510     gcc_cv_as_eh_frame=buggy
2511   else
2512     # Uh oh, what do we do now?
2513     gcc_cv_as_eh_frame=no
2514   fi])
2515
2516 if test $gcc_cv_as_eh_frame = buggy; then
2517   AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2518   [Define if your assembler mis-optimizes .eh_frame data.])
2519 fi
2520
2521 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2522  [elf,2,12,0], [--fatal-warnings],
2523  [.section .rodata.str, "aMS", @progbits, 1])
2524 if test $gcc_cv_as_shf_merge = no; then
2525   gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2526     [elf,2,12,0], [--fatal-warnings],
2527     [.section .rodata.str, "aMS", %progbits, 1])
2528 fi
2529 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2530   [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2531 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2532
2533 gcc_GAS_CHECK_FEATURE(COMDAT group support, gcc_cv_as_comdat_group,
2534  [elf,2,16,0], [--fatal-warnings],
2535  [.section .text,"axG",@progbits,.foo,comdat])
2536 if test $gcc_cv_as_comdat_group = yes; then
2537   gcc_cv_as_comdat_group_percent=no
2538 else
2539  gcc_GAS_CHECK_FEATURE(COMDAT group support, gcc_cv_as_comdat_group_percent,
2540    [elf,2,16,0], [--fatal-warnings],
2541    [.section .text,"axG",%progbits,.foo,comdat])
2542 fi
2543 if test x"$ld_is_gold" = xyes; then
2544   comdat_group=yes
2545 elif test $in_tree_ld = yes ; then
2546   comdat_group=no
2547   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 \
2548      && test $in_tree_ld_is_elf = yes; then
2549      comdat_group=yes
2550   fi
2551 elif echo "$ld_ver" | grep GNU > /dev/null; then
2552   comdat_group=yes
2553   if test 0"$ld_date" -lt 20050308; then
2554     if test -n "$ld_date"; then
2555       # If there was date string, but was earlier than 2005-03-08, fail
2556       comdat_group=no
2557     elif test "$ld_vers_major" -lt 2; then
2558       comdat_group=no
2559     elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2560       comdat_group=no
2561     fi
2562   fi
2563 else
2564 changequote(,)dnl
2565   case "${target}" in
2566     *-*-solaris2.1[1-9]*)
2567       # Sun ld has COMDAT group support since Solaris 9, but it doesn't
2568       # interoperate with GNU as until Solaris 11 build 130, i.e. ld
2569       # version 1.688.
2570       #
2571       # FIXME: Maybe need to refine later when COMDAT group support with
2572       # Sun as is implemented.
2573       if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 1688; then
2574         comdat_group=yes
2575       else
2576         comdat_group=no
2577       fi
2578       ;;
2579     *)
2580       # Assume linkers other than GNU ld don't support COMDAT group.
2581       comdat_group=no
2582       ;;
2583   esac
2584 changequote([,])dnl
2585 fi
2586 # Allow overriding the automatic COMDAT group tests above.
2587 AC_ARG_ENABLE(comdat,
2588   [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
2589   [comdat_group="$enable_comdat"])
2590 if test $comdat_group = no; then
2591   gcc_cv_as_comdat_group=no
2592   gcc_cv_as_comdat_group_percent=no
2593 fi
2594 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2595   [`if test $gcc_cv_as_comdat_group = yes || test $gcc_cv_as_comdat_group_percent = yes; then echo 1; else echo 0; fi`],
2596 [Define 0/1 if your assembler and linker support COMDAT groups.])
2597
2598 gcc_GAS_CHECK_FEATURE([line table discriminator support],
2599  gcc_cv_as_discriminator,
2600  [2,19,51],,
2601 [       .text
2602         .file 1 "conf.c"
2603         .loc 1 1 0 discriminator 1],,
2604 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
2605   [Define if your assembler supports the .loc discriminator sub-directive.])])
2606
2607 # Thread-local storage - the check is heavily parameterized.
2608 conftest_s=
2609 tls_first_major=
2610 tls_first_minor=
2611 tls_as_opt=
2612 case "$target" in
2613 changequote(,)dnl
2614   alpha*-*-*)
2615     conftest_s='
2616         .section ".tdata","awT",@progbits
2617 foo:    .long   25
2618         .text
2619         ldq     $27,__tls_get_addr($29)         !literal!1
2620         lda     $16,foo($29)                    !tlsgd!1
2621         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
2622         ldq     $27,__tls_get_addr($29)         !literal!2
2623         lda     $16,foo($29)                    !tlsldm!2
2624         jsr     $26,($27),__tls_get_addr        !lituse_tlsldm!2
2625         ldq     $1,foo($29)                     !gotdtprel
2626         ldah    $2,foo($29)                     !dtprelhi
2627         lda     $3,foo($2)                      !dtprello
2628         lda     $4,foo($29)                     !dtprel
2629         ldq     $1,foo($29)                     !gottprel
2630         ldah    $2,foo($29)                     !tprelhi
2631         lda     $3,foo($2)                      !tprello
2632         lda     $4,foo($29)                     !tprel'
2633         tls_first_major=2
2634         tls_first_minor=13
2635         tls_as_opt=--fatal-warnings
2636         ;;
2637   cris-*-*|crisv32-*-*)
2638     conftest_s='
2639         .section ".tdata","awT",@progbits
2640 x:      .long   25
2641         .text
2642         move.d x:IE,$r10
2643         nop'
2644         tls_first_major=2
2645         tls_first_minor=20
2646         tls_as_opt=--fatal-warnings
2647         ;;
2648   frv*-*-*)
2649     conftest_s='
2650         .section ".tdata","awT",@progbits
2651 x:      .long   25
2652         .text
2653         call    #gettlsoff(x)'
2654         tls_first_major=2
2655         tls_first_minor=14
2656         ;;
2657   hppa*-*-linux*)
2658     conftest_s='
2659 t1:     .reg    %r20
2660 t2:     .reg    %r21
2661 gp:     .reg    %r19
2662         .section ".tdata","awT",@progbits
2663 foo:    .long   25
2664         .text
2665         .align  4
2666         addil LT%foo-$tls_gdidx$,gp
2667         ldo RT%foo-$tls_gdidx$(%r1),%arg0
2668         b __tls_get_addr
2669         nop             
2670         addil LT%foo-$tls_ldidx$,gp
2671         b __tls_get_addr
2672         ldo RT%foo-$tls_ldidx$(%r1),%arg0
2673         addil LR%foo-$tls_dtpoff$,%ret0
2674         ldo RR%foo-$tls_dtpoff$(%r1),%t1
2675         mfctl %cr27,%t1                 
2676         addil LT%foo-$tls_ieoff$,gp
2677         ldw RT%foo-$tls_ieoff$(%r1),%t2
2678         add %t1,%t2,%t3                 
2679         mfctl %cr27,%t1                 
2680         addil LR%foo-$tls_leoff$,%t1
2681         ldo RR%foo-$tls_leoff$(%r1),%t2'
2682         tls_first_major=2
2683         tls_first_minor=15
2684         tls_as_opt=--fatal-warnings
2685         ;;
2686   arm*-*-*)
2687     conftest_s='
2688         .section ".tdata","awT",%progbits
2689 foo:    .long   25
2690         .text
2691 .word foo(gottpoff)
2692 .word foo(tpoff)
2693 .word foo(tlsgd)
2694 .word foo(tlsldm)
2695 .word foo(tlsldo)'
2696         tls_first_major=2
2697         tls_first_minor=17
2698         ;;
2699   i[34567]86-*-*)
2700     case "$target" in
2701       i[34567]86-*-solaris2.*)
2702         on_solaris=yes
2703         tga_func=___tls_get_addr
2704         ;;
2705       *)
2706         on_solaris=no
2707         ;;
2708     esac
2709     if test x$on_solaris = xyes && test x$gas_flag = xno; then
2710       conftest_s='
2711         .section .tdata,"awt",@progbits'
2712       tls_first_major=0
2713       tls_first_minor=0
2714 changequote([,])dnl
2715       AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
2716 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
2717 changequote(,)dnl
2718     else
2719       conftest_s='
2720         .section ".tdata","awT",@progbits'
2721       tls_first_major=2
2722       tls_first_minor=14
2723       tls_as_opt="--fatal-warnings"
2724     fi
2725     conftest_s="$conftest_s
2726 foo:    .long   25
2727         .text
2728         movl    %gs:0, %eax
2729         leal    foo@tlsgd(,%ebx,1), %eax
2730         leal    foo@tlsldm(%ebx), %eax
2731         leal    foo@dtpoff(%eax), %edx
2732         movl    foo@gottpoff(%ebx), %eax
2733         subl    foo@gottpoff(%ebx), %eax
2734         addl    foo@gotntpoff(%ebx), %eax
2735         movl    foo@indntpoff, %eax
2736         movl    \$foo@tpoff, %eax
2737         subl    \$foo@tpoff, %eax
2738         leal    foo@ntpoff(%ecx), %eax"
2739     ;;
2740   x86_64-*-*)
2741     conftest_s='
2742         .section ".tdata","awT",@progbits
2743 foo:    .long   25
2744         .text
2745         movq    %fs:0, %rax
2746         leaq    foo@TLSGD(%rip), %rdi
2747         leaq    foo@TLSLD(%rip), %rdi
2748         leaq    foo@DTPOFF(%rax), %rdx
2749         movq    foo@GOTTPOFF(%rip), %rax
2750         movq    $foo@TPOFF, %rax'
2751         tls_first_major=2
2752         tls_first_minor=14
2753         tls_as_opt=--fatal-warnings
2754         ;;
2755   ia64-*-*)
2756     conftest_s='
2757         .section ".tdata","awT",@progbits
2758 foo:    data8   25
2759         .text
2760         addl    r16 = @ltoff(@dtpmod(foo#)), gp
2761         addl    r17 = @ltoff(@dtprel(foo#)), gp
2762         addl    r18 = @ltoff(@tprel(foo#)), gp
2763         addl    r19 = @dtprel(foo#), gp
2764         adds    r21 = @dtprel(foo#), r13
2765         movl    r23 = @dtprel(foo#)
2766         addl    r20 = @tprel(foo#), gp
2767         adds    r22 = @tprel(foo#), r13
2768         movl    r24 = @tprel(foo#)'
2769         tls_first_major=2
2770         tls_first_minor=13
2771         tls_as_opt=--fatal-warnings
2772         ;;
2773   mips*-*-*)
2774     conftest_s='
2775         .section .tdata,"awT",@progbits
2776 x:
2777         .word 2
2778         .text
2779         addiu $4, $28, %tlsgd(x)
2780         addiu $4, $28, %tlsldm(x)
2781         lui $4, %dtprel_hi(x)
2782         addiu $4, $4, %dtprel_lo(x)
2783         lw $4, %gottprel(x)($28)
2784         lui $4, %tprel_hi(x)
2785         addiu $4, $4, %tprel_lo(x)'
2786         tls_first_major=2
2787         tls_first_minor=16
2788         tls_as_opt='-32 --fatal-warnings'
2789         ;;
2790   m68k-*-*)
2791     conftest_s='
2792         .section .tdata,"awT",@progbits
2793 x:
2794         .word 2
2795         .text
2796 foo:
2797         move.l x@TLSGD(%a5),%a0
2798         move.l x@TLSLDM(%a5),%a0
2799         move.l x@TLSLDO(%a5),%a0
2800         move.l x@TLSIE(%a5),%a0
2801         move.l x@TLSLE(%a5),%a0'
2802         tls_first_major=2
2803         tls_first_minor=19
2804         tls_as_opt='--fatal-warnings'
2805         ;;
2806   powerpc-*-*)
2807     conftest_s='
2808         .section ".tdata","awT",@progbits
2809         .align 2
2810 ld0:    .space 4
2811 ld1:    .space 4
2812 x1:     .space 4
2813 x2:     .space 4
2814 x3:     .space 4
2815         .text
2816         addi 3,31,ld0@got@tlsgd
2817         bl __tls_get_addr
2818         addi 3,31,x1@got@tlsld
2819         bl __tls_get_addr
2820         addi 9,3,x1@dtprel
2821         addis 9,3,x2@dtprel@ha
2822         addi 9,9,x2@dtprel@l
2823         lwz 9,x3@got@tprel(31)
2824         add 9,9,x@tls
2825         addi 9,2,x1@tprel
2826         addis 9,2,x2@tprel@ha
2827         addi 9,9,x2@tprel@l'
2828         tls_first_major=2
2829         tls_first_minor=14
2830         tls_as_opt="-a32 --fatal-warnings"
2831         ;;
2832   powerpc64-*-*)
2833     conftest_s='
2834         .section ".tdata","awT",@progbits
2835         .align 3
2836 ld0:    .space 8
2837 ld1:    .space 8
2838 x1:     .space 8
2839 x2:     .space 8
2840 x3:     .space 8
2841         .text
2842         addi 3,2,ld0@got@tlsgd
2843         bl .__tls_get_addr
2844         nop
2845         addi 3,2,ld1@toc
2846         bl .__tls_get_addr
2847         nop
2848         addi 3,2,x1@got@tlsld
2849         bl .__tls_get_addr
2850         nop
2851         addi 9,3,x1@dtprel
2852         bl .__tls_get_addr
2853         nop
2854         addis 9,3,x2@dtprel@ha
2855         addi 9,9,x2@dtprel@l
2856         bl .__tls_get_addr
2857         nop
2858         ld 9,x3@got@dtprel(2)
2859         add 9,9,3
2860         bl .__tls_get_addr
2861         nop'
2862         tls_first_major=2
2863         tls_first_minor=14
2864         tls_as_opt="-a64 --fatal-warnings"
2865         ;;
2866   s390-*-*)
2867     conftest_s='
2868         .section ".tdata","awT",@progbits
2869 foo:    .long   25
2870         .text
2871         .long   foo@TLSGD
2872         .long   foo@TLSLDM
2873         .long   foo@DTPOFF
2874         .long   foo@NTPOFF
2875         .long   foo@GOTNTPOFF
2876         .long   foo@INDNTPOFF
2877         l       %r1,foo@GOTNTPOFF(%r12)
2878         l       %r1,0(%r1):tls_load:foo
2879         bas     %r14,0(%r1,%r13):tls_gdcall:foo
2880         bas     %r14,0(%r1,%r13):tls_ldcall:foo'
2881         tls_first_major=2
2882         tls_first_minor=14
2883         tls_as_opt="-m31 --fatal-warnings"
2884         ;;
2885   s390x-*-*)
2886     conftest_s='
2887         .section ".tdata","awT",@progbits
2888 foo:    .long   25
2889         .text
2890         .quad   foo@TLSGD
2891         .quad   foo@TLSLDM
2892         .quad   foo@DTPOFF
2893         .quad   foo@NTPOFF
2894         .quad   foo@GOTNTPOFF
2895         lg      %r1,foo@GOTNTPOFF(%r12)
2896         larl    %r1,foo@INDNTPOFF
2897         brasl   %r14,__tls_get_offset@PLT:tls_gdcall:foo
2898         brasl   %r14,__tls_get_offset@PLT:tls_ldcall:foo'
2899         tls_first_major=2
2900         tls_first_minor=14
2901         tls_as_opt="-m64 -Aesame --fatal-warnings"
2902         ;;
2903   sh-*-* | sh[34]-*-*)
2904     conftest_s='
2905         .section ".tdata","awT",@progbits
2906 foo:    .long   25
2907         .text
2908         .long   foo@TLSGD
2909         .long   foo@TLSLDM
2910         .long   foo@DTPOFF
2911         .long   foo@GOTTPOFF
2912         .long   foo@TPOFF'
2913         tls_first_major=2
2914         tls_first_minor=13
2915         tls_as_opt=--fatal-warnings
2916         ;;
2917   sparc*-*-*)
2918     case "$target" in
2919       sparc*-sun-solaris2.*)
2920         on_solaris=yes
2921         tga_func=__tls_get_addr
2922         ;;
2923       *)
2924         on_solaris=no
2925         ;;
2926     esac
2927     if test x$on_solaris = xyes && test x$gas_flag = xno; then
2928       conftest_s='
2929         .section ".tdata",#alloc,#write,#tls'
2930         tls_first_major=0
2931         tls_first_minor=0
2932     else
2933       conftest_s='
2934         .section ".tdata","awT",@progbits'
2935         tls_first_major=2
2936         tls_first_minor=14
2937         tls_as_opt="-32 --fatal-warnings"
2938     fi
2939     conftest_s="$conftest_s
2940 foo:    .long   25
2941         .text
2942         sethi   %tgd_hi22(foo), %o0
2943         add     %o0, %tgd_lo10(foo), %o1
2944         add     %l7, %o1, %o0, %tgd_add(foo)
2945         call    __tls_get_addr, %tgd_call(foo)
2946         sethi   %tldm_hi22(foo), %l1
2947         add     %l1, %tldm_lo10(foo), %l2
2948         add     %l7, %l2, %o0, %tldm_add(foo)
2949         call    __tls_get_addr, %tldm_call(foo)
2950         sethi   %tldo_hix22(foo), %l3
2951         xor     %l3, %tldo_lox10(foo), %l4
2952         add     %o0, %l4, %l5, %tldo_add(foo)
2953         sethi   %tie_hi22(foo), %o3
2954         add     %o3, %tie_lo10(foo), %o3
2955         ld      [%l7 + %o3], %o2, %tie_ld(foo)
2956         add     %g7, %o2, %o4, %tie_add(foo)
2957         sethi   %tle_hix22(foo), %l1
2958         xor     %l1, %tle_lox10(foo), %o5
2959         ld      [%g7 + %o5], %o1"
2960         ;;
2961   xtensa*-*-*)
2962     conftest_s='
2963         .section ".tdata","awT",@progbits
2964 foo:    .long   25
2965         .text
2966         movi    a8, foo@TLSFUNC
2967         movi    a10, foo@TLSARG
2968         callx8.tls a8, foo@TLSCALL'
2969         tls_first_major=2
2970         tls_first_minor=19
2971         ;;
2972 changequote([,])dnl
2973 esac
2974 set_have_as_tls=no
2975 if test "x$enable_tls" = xno ; then
2976   : # TLS explicitly disabled.
2977 elif test "x$enable_tls" = xyes ; then
2978   set_have_as_tls=yes # TLS explicitly enabled.
2979 elif test -z "$tls_first_major"; then
2980   : # If we don't have a check, assume no support.
2981 else
2982   gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
2983   [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
2984   [set_have_as_tls=yes])
2985 fi
2986 case "$target" in
2987   *-*-irix6*)
2988     # IRIX 6.5 rld and libc.so lack TLS support, so even if gas and gld
2989     # with TLS support are in use, native TLS cannot work.
2990     set_have_as_tls=no
2991     ;;
2992   *-*-osf*)
2993     # Tru64 UNIX loader and libc.so lack TLS support, so even if gas and
2994     # gld with TLS support are in use, native TLS cannot work.
2995     set_have_as_tls=no
2996     ;;
2997   # TLS was introduced in the Solaris 9 FCS release and backported to
2998   # Solaris 8 patches.  Support for GNU-style TLS on x86 was only
2999   # introduced in Solaris 9 4/04, replacing the earlier Sun style that Sun
3000   # ld and GCC don't support any longer.
3001   *-*-solaris2.*)
3002     AC_MSG_CHECKING(linker and ld.so.1 TLS support)
3003     ld_tls_support=no
3004     # Check ld and ld.so.1 TLS support.
3005     if echo "$ld_ver" | grep GNU > /dev/null; then
3006       # Assume all interesting versions of GNU ld have TLS support.
3007       # FIXME: still need ld.so.1 support, i.e. ld version checks below.
3008       ld_tls_support=yes
3009     else
3010       case "$target" in
3011         # Solaris 8/x86 ld has GNU style TLS support since version 1.280.
3012         i?86-*-solaris2.8)
3013           min_tls_ld_vers_minor=280
3014           ;;
3015         # Solaris 8/SPARC ld has TLS support since version 1.272.
3016         sparc*-*-solaris2.8)
3017           min_tls_ld_vers_minor=272
3018           ;;
3019         # Solaris 9/x86 ld has GNU style TLS support since version 1.374.
3020         i?86-*-solaris2.9)
3021           min_tls_ld_vers_minor=374
3022           ;;
3023         # Solaris 9/SPARC and Solaris 10+ ld have TLS support since FCS.
3024         sparc*-*-solaris2.9 | *-*-solaris2.1[[0-9]]*)
3025           min_tls_ld_vers_minor=343
3026           ;;
3027       esac
3028       if test "$ld_vers_major" -gt 1 || \
3029         test "$ld_vers_minor" -ge "$min_tls_ld_vers_minor"; then
3030         ld_tls_support=yes
3031       else
3032         set_have_as_tls=no
3033       fi
3034     fi
3035     AC_MSG_RESULT($ld_tls_support)
3036
3037     save_LIBS="$LIBS"
3038     save_LDFLAGS="$LDFLAGS"
3039     LIBS=
3040     LDFLAGS=
3041
3042     AC_MSG_CHECKING(alternate thread library)
3043     case "$target" in
3044       # TLS support was backported to Solaris 8 patches, but only lives in
3045       # the alternate thread library which became the default in Solaris 9. 
3046       # We want to always use that, irrespective of TLS support.
3047       *-*-solaris2.8)
3048         # Take multilib subdir into account.  There's no spec to handle
3049         # this.  The 64 symlink exists since Solaris 8.
3050         lwp_dir=/usr/lib/lwp
3051         lwp_spec="-L$lwp_dir%{m64:/64} -R$lwp_dir%{m64:/64}"
3052         LDFLAGS="-L$lwp_dir -R$lwp_dir"
3053         ;;
3054       *-*-solaris2*)
3055         lwp_dir="none"
3056         lwp_spec=""
3057         ;;
3058     esac    
3059     # Always define LIB_THREAD_LDFLAGS_SPEC, even without TLS support.
3060     AC_DEFINE_UNQUOTED(LIB_THREAD_LDFLAGS_SPEC, "$lwp_spec",
3061         [Define to the linker flags to use for -pthread.])
3062     AC_MSG_RESULT($lwp_dir)
3063
3064     AC_MSG_CHECKING(library containing $tga_func)
3065     # Before Solaris 10, __tls_get_addr (SPARC/x64) resp. ___tls_get_addr
3066     # (32-bit x86) only lived in libthread, so check for that.  Keep
3067     # set_have_as_tls if found, disable if not.
3068     AC_SEARCH_LIBS([$tga_func], [thread],, [set_have_as_tls=no])
3069     # Clear LIBS if we cannot support TLS.
3070     if test $set_have_as_tls = no; then
3071       LIBS=
3072     fi
3073     # Always define LIB_TLS_SPEC, even without TLS support.
3074     AC_DEFINE_UNQUOTED(LIB_TLS_SPEC, "$LIBS",
3075         [Define to the library containing __tls_get_addr/___tls_get_addr.])
3076     AC_MSG_RESULT($LIBS)
3077
3078     LIBS="$save_LIBS"
3079     LDFLAGS="$save_LDFLAGS"
3080     ;;
3081 esac
3082 if test $set_have_as_tls = yes ; then
3083   AC_DEFINE(HAVE_AS_TLS, 1,
3084             [Define if your assembler and linker support thread-local storage.])
3085 fi
3086
3087 # Target-specific assembler checks.
3088
3089 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3090 gcc_cv_ld_static_dynamic=no
3091 if test $in_tree_ld = yes ; then
3092   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; then
3093     gcc_cv_ld_static_dynamic=yes
3094   fi
3095 elif test x$gcc_cv_ld != x; then
3096         # Check if linker supports -Bstatic/-Bdynamic option
3097         if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
3098           && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
3099                 gcc_cv_ld_static_dynamic=yes
3100         fi
3101 fi
3102 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3103         AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3104 [Define if your linker supports -Bstatic/-Bdynamic option.])
3105 fi
3106 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3107
3108 if test x"$demangler_in_ld" = xyes; then
3109   AC_MSG_CHECKING(linker --demangle support)
3110   gcc_cv_ld_demangle=no
3111   if test $in_tree_ld = yes; then
3112     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 \
3113       gcc_cv_ld_demangle=yes
3114     fi
3115   elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3116     # Check if the GNU linker supports --demangle option
3117     if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3118       gcc_cv_ld_demangle=yes
3119     fi
3120   fi
3121   if test x"$gcc_cv_ld_demangle" = xyes; then
3122     AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3123 [Define if your linker supports --demangle option.])
3124   fi
3125   AC_MSG_RESULT($gcc_cv_ld_demangle)
3126 fi
3127
3128 case "$target" in
3129   # All TARGET_ABI_OSF targets.
3130   alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
3131     gcc_GAS_CHECK_FEATURE([explicit relocation support],
3132         gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3133 [       .set nomacro
3134         .text
3135         extbl   $3, $2, $3      !lituse_bytoff!1
3136         ldq     $2, a($29)      !literal!1
3137         ldq     $4, b($29)      !literal!2
3138         ldq_u   $3, 0($2)       !lituse_base!1
3139         ldq     $27, f($29)     !literal!5
3140         jsr     $26, ($27), f   !lituse_jsr!5
3141         ldah    $29, 0($26)     !gpdisp!3
3142         lda     $0, c($29)      !gprel
3143         ldah    $1, d($29)      !gprelhigh
3144         lda     $1, d($1)       !gprellow
3145         lda     $29, 0($29)     !gpdisp!3],,
3146     [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3147   [Define if your assembler supports explicit relocations.])])
3148     gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3149         gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3150 [       .set nomacro
3151         .text
3152         ldq     $27, a($29)     !literal!1
3153         jsr     $26, ($27), a   !lituse_jsrdirect!1],,
3154     [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3155   [Define if your assembler supports the lituse_jsrdirect relocation.])])
3156     ;;
3157
3158   cris-*-*)
3159     gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3160       gcc_cv_as_cris_no_mul_bug,[2,15,91],
3161       [-no-mul-bug-abort], [.text],,
3162       [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3163                 [Define if your assembler supports the -no-mul-bug-abort option.])])
3164     ;;
3165
3166   sparc*-*-*)
3167     gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3168       [.register %g2, #scratch],,
3169       [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3170                 [Define if your assembler supports .register.])])
3171
3172     gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3173       [-relax], [.text],,
3174       [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3175                 [Define if your assembler supports -relax option.])])
3176
3177     gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3178       gcc_cv_as_sparc_gotdata_op,,
3179       [-K PIC],
3180 [.text
3181 foo:
3182         nop
3183 bar:
3184         sethi %gdop_hix22(foo), %g1
3185         xor    %g1, %gdop_lox10(foo), %g1
3186         ld    [[%l7 + %g1]], %g2, %gdop(foo)],
3187       [if test x$gcc_cv_ld != x \
3188        && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3189          if $gcc_cv_ld -v | grep GNU >/dev/null 2>&1; then
3190            if test x$gcc_cv_objdump != x; then
3191              if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3192                 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3193                gcc_cv_as_sparc_gotdata_op=no
3194              else
3195                gcc_cv_as_sparc_gotdata_op=yes
3196              fi
3197            fi
3198          else
3199            gcc_cv_as_sparc_gotdata_op=yes
3200          fi
3201        fi
3202        rm -f conftest],
3203       [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3204                 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3205
3206     gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3207       gcc_cv_as_sparc_ua_pcrel,,
3208       [-K PIC],
3209 [.text
3210 foo:
3211         nop
3212 .data
3213 .align 4
3214 .byte 0
3215 .uaword %r_disp32(foo)],
3216       [if test x$gcc_cv_ld != x \
3217        && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3218          gcc_cv_as_sparc_ua_pcrel=yes
3219        fi
3220        rm -f conftest],
3221       [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3222                 [Define if your assembler and linker support unaligned PC relative relocs.])
3223
3224       gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3225         gcc_cv_as_sparc_ua_pcrel_hidden,,
3226         [-K PIC],
3227 [.data
3228 .align 4
3229 .byte 0x31
3230 .uaword %r_disp32(foo)
3231 .byte 0x32, 0x33, 0x34
3232 .global foo
3233 .hidden foo
3234 foo:
3235 .skip 4],
3236         [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3237          && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3238          && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3239             | grep ' 31000000 07323334' > /dev/null 2>&1; then
3240             if $gcc_cv_objdump -R conftest 2> /dev/null \
3241                | grep 'DISP32' > /dev/null 2>&1; then
3242                 :
3243             else
3244                 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3245             fi
3246          fi
3247          rm -f conftest],
3248          [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3249                    [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3250     ]) # unaligned pcrel relocs
3251
3252     gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3253       gcc_cv_as_sparc_offsetable_lo10,,
3254       [-xarch=v9],
3255 [.text
3256         or %g1, %lo(ab) + 12, %g1
3257         or %g1, %lo(ab + 12), %g1],
3258       [if test x$gcc_cv_objdump != x \
3259        && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3260           | grep ' 82106000 82106000' > /dev/null 2>&1; then
3261          gcc_cv_as_sparc_offsetable_lo10=yes
3262        fi],
3263        [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3264                  [Define if your assembler supports offsetable %lo().])])
3265     ;;
3266
3267 changequote(,)dnl
3268   i[34567]86-*-* | x86_64-*-*)
3269 changequote([,])dnl
3270     case $target_os in
3271       cygwin*)
3272         # Full C++ conformance when using a shared libstdc++-v3 requires some
3273         # support from the Cygwin DLL, which in more recent versions exports
3274         # wrappers to aid in interposing and redirecting operators new, delete,
3275         # etc., as per n2800 #17.6.4.6 [replacement.functions].  Check if we
3276         # are configuring for a version of Cygwin that exports the wrappers.
3277         if test x$host = x$target; then
3278           AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3279         else
3280           # Can't check presence of libc functions during cross-compile, so
3281           # we just have to assume we're building for an up-to-date target.
3282           gcc_ac_cygwin_dll_wrappers=yes
3283         fi
3284         AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3285           [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3286           [Define if you want to generate code by default that assumes that the
3287            Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3288     esac
3289     case $target_os in
3290       cygwin* | pe | mingw32*)
3291         # Recent binutils allows the three-operand form of ".comm" on PE.  This
3292         # definition is used unconditionally to initialise the default state of
3293         # the target option variable that governs usage of the feature.
3294         gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3295          [2,19,52],,[.comm foo,1,32])
3296         AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3297           [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3298           [Define if your assembler supports specifying the alignment
3299            of objects allocated using the GAS .comm command.])
3300         # Used for DWARF 2 in PE
3301         gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3302           gcc_cv_as_ix86_pe_secrel32,
3303           [2,15,91],,
3304 [.text
3305 foo:    nop
3306 .data
3307         .secrel32 foo],
3308           [if test x$gcc_cv_ld != x \
3309            && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3310              gcc_cv_as_ix86_pe_secrel32=yes
3311            fi
3312            rm -f conftest],
3313           [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3314             [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3315         # Test if the assembler supports the extended form of the .section
3316         # directive that specifies section alignment.  LTO support uses this,
3317         # but normally only after installation, so we warn but don't fail the
3318         # configure if LTO is enabled but the assembler does not support it.
3319         gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3320           [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3321         if test x$gcc_cv_as_section_has_align != xyes; then
3322           case ",$enable_languages," in
3323             *,lto,*)
3324               AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3325               ;;
3326           esac
3327         fi
3328         ;;
3329     esac
3330
3331     gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3332        gcc_cv_as_ix86_filds,,,
3333        [filds mem; fists mem],,
3334        [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3335          [Define if your assembler uses filds and fists mnemonics.])])
3336
3337     gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3338        gcc_cv_as_ix86_fildq,,,
3339        [fildq mem; fistpq mem],,
3340        [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3341          [Define if your assembler uses fildq and fistq mnemonics.])])
3342
3343     gcc_GAS_CHECK_FEATURE([cmov syntax],
3344       gcc_cv_as_ix86_cmov_sun_syntax,,,
3345       [cmovl.l %edx, %eax],,
3346       [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3347         [Define if your assembler supports the Sun syntax for cmov.])])
3348
3349     gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3350       gcc_cv_as_ix86_ffreep,,,
3351       [ffreep %st(1)],,
3352       [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3353         [Define if your assembler supports the ffreep mnemonic.])])
3354
3355     gcc_GAS_CHECK_FEATURE([.quad directive],
3356       gcc_cv_as_ix86_quad,,,
3357       [.quad 0],,
3358       [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
3359         [Define if your assembler supports the .quad directive.])])
3360
3361     gcc_GAS_CHECK_FEATURE([sahf mnemonic],
3362       gcc_cv_as_ix86_sahf,,,
3363       [.code64
3364        sahf],,
3365       [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
3366         [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
3367
3368     gcc_GAS_CHECK_FEATURE([swap suffix],
3369       gcc_cv_as_ix86_swap,,,
3370       [movl.s %esp, %ebp],,
3371       [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
3372         [Define if your assembler supports the swap suffix.])])
3373
3374     gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
3375       gcc_cv_as_ix86_diff_sect_delta,,,
3376       [.section .rodata
3377 .L1:
3378         .long .L2-.L1
3379         .long .L3-.L1
3380         .text
3381 .L3:    nop
3382 .L2:    nop],,
3383       [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
3384         [Define if your assembler supports the subtraction of symbols in different sections.])])
3385
3386     # These two are used unconditionally by i386.[ch]; it is to be defined
3387     # to 1 if the feature is present, 0 otherwise.
3388     gcc_GAS_CHECK_FEATURE([GOTOFF in data],
3389         gcc_cv_as_ix86_gotoff_in_data, [2,11,0],,
3390 [       .text
3391 .L0:
3392         nop
3393         .data
3394         .long .L0@GOTOFF])
3395     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
3396       [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
3397       [Define true if the assembler supports '.long foo@GOTOFF'.])
3398
3399     gcc_GAS_CHECK_FEATURE([rep and lock prefix],
3400         gcc_cv_as_ix86_rep_lock_prefix,,,
3401         [rep movsl
3402          lock addl %edi, (%eax,%esi)
3403          lock orl $0, (%esp)],,
3404         [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
3405           [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
3406
3407     ;;
3408
3409   ia64*-*-*)
3410     gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
3411         gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
3412 [       .text
3413         addl r15 = @ltoffx(x#), gp
3414         ;;
3415         ld8.mov r16 = [[r15]], x#],,
3416     [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
3417           [Define if your assembler supports ltoffx and ldxmov relocations.])])
3418
3419     ;;
3420
3421   powerpc*-*-*)
3422     case $target in
3423       *-*-aix*) conftest_s='    .machine "pwr5"
3424         .csect .text[[PR]]
3425         mfcr 3,128';;
3426       *-*-darwin*)
3427         gcc_GAS_CHECK_FEATURE([.machine directive support],
3428           gcc_cv_as_machine_directive,,,
3429           [     .machine ppc7400])
3430         if test x$gcc_cv_as_machine_directive != xyes; then
3431           echo "*** This target requires an assembler supporting \".machine\"" >&2
3432           echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
3433           test x$build = x$target && exit 1
3434         fi
3435         conftest_s='    .text
3436         mfcr r3,128';;
3437       *) conftest_s='   .machine power4
3438         .text
3439         mfcr 3,128';;
3440     esac
3441
3442     gcc_GAS_CHECK_FEATURE([mfcr field support],
3443       gcc_cv_as_powerpc_mfcrf, [2,14,0],,
3444       [$conftest_s],,
3445       [AC_DEFINE(HAVE_AS_MFCRF, 1,
3446           [Define if your assembler supports mfcr field.])])
3447
3448     case $target in
3449       *-*-aix*) conftest_s='    .machine "pwr5"
3450         .csect .text[[PR]]
3451         popcntb 3,3';;
3452       *) conftest_s='   .machine power5
3453         .text
3454         popcntb 3,3';;
3455     esac
3456
3457     gcc_GAS_CHECK_FEATURE([popcntb support],
3458       gcc_cv_as_powerpc_popcntb, [2,17,0],,
3459       [$conftest_s],,
3460       [AC_DEFINE(HAVE_AS_POPCNTB, 1,
3461           [Define if your assembler supports popcntb field.])])
3462
3463     case $target in
3464       *-*-aix*) conftest_s='    .machine "pwr5x"
3465         .csect .text[[PR]]
3466         frin 1,1';;
3467       *) conftest_s='   .machine power5
3468         .text
3469         frin 1,1';;
3470     esac
3471
3472     gcc_GAS_CHECK_FEATURE([fp round support],
3473       gcc_cv_as_powerpc_fprnd, [2,17,0],,
3474       [$conftest_s],,
3475       [AC_DEFINE(HAVE_AS_FPRND, 1,
3476           [Define if your assembler supports fprnd.])])
3477
3478     case $target in
3479       *-*-aix*) conftest_s='    .machine "pwr6"
3480         .csect .text[[PR]]
3481         mffgpr 1,3';;
3482       *) conftest_s='   .machine power6
3483         .text
3484         mffgpr 1,3';;
3485     esac
3486
3487     gcc_GAS_CHECK_FEATURE([move fp gpr support],
3488       gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
3489       [$conftest_s],,
3490       [AC_DEFINE(HAVE_AS_MFPGPR, 1,
3491           [Define if your assembler supports mffgpr and mftgpr.])])
3492
3493     case $target in
3494       *-*-aix*) conftest_s='    .csect .text[[PR]]
3495 LCF..0:
3496         addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
3497       *-*-darwin*)
3498         conftest_s='    .text
3499 LCF0:
3500         addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
3501       *) conftest_s='   .text
3502 .LCF0:
3503         addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
3504     esac
3505
3506     gcc_GAS_CHECK_FEATURE([rel16 relocs],
3507       gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
3508       [$conftest_s],,
3509       [AC_DEFINE(HAVE_AS_REL16, 1,
3510           [Define if your assembler supports R_PPC_REL16 relocs.])])
3511
3512     case $target in
3513       *-*-aix*) conftest_s='    .machine "pwr6"
3514         .csect .text[[PR]]
3515         cmpb 3,4,5';;
3516       *) conftest_s='   .machine power6
3517         .text
3518         cmpb 3,4,5';;
3519     esac
3520
3521     gcc_GAS_CHECK_FEATURE([compare bytes support],
3522       gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
3523       [$conftest_s],,
3524       [AC_DEFINE(HAVE_AS_CMPB, 1,
3525           [Define if your assembler supports cmpb.])])
3526
3527     case $target in
3528       *-*-aix*) conftest_s='    .machine "pwr6"
3529         .csect .text[[PR]]
3530         dadd 1,2,3';;
3531       *) conftest_s='   .machine power6
3532         .text
3533         dadd 1,2,3';;
3534     esac
3535
3536     gcc_GAS_CHECK_FEATURE([decimal float support],
3537       gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
3538       [$conftest_s],,
3539       [AC_DEFINE(HAVE_AS_DFP, 1,
3540           [Define if your assembler supports DFP instructions.])])
3541
3542     case $target in
3543       *-*-aix*) conftest_s='    .machine "pwr7"
3544         .csect .text[[PR]]
3545         lxvd2x 1,2,3';;
3546       *) conftest_s='   .machine power7
3547         .text
3548         lxvd2x 1,2,3';;
3549     esac
3550
3551     gcc_GAS_CHECK_FEATURE([vector-scalar support],
3552       gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
3553       [$conftest_s],,
3554       [AC_DEFINE(HAVE_AS_VSX, 1,
3555           [Define if your assembler supports VSX instructions.])])
3556
3557     case $target in
3558       *-*-aix*) conftest_s='    .machine "pwr7"
3559         .csect .text[[PR]]
3560         popcntd 3,3';;
3561       *) conftest_s='   .machine power7
3562         .text
3563         popcntd 3,3';;
3564     esac
3565
3566     gcc_GAS_CHECK_FEATURE([popcntd support],
3567       gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
3568       [$conftest_s],,
3569       [AC_DEFINE(HAVE_AS_POPCNTD, 1,
3570           [Define if your assembler supports POPCNTD instructions.])])
3571
3572     case $target in
3573       *-*-aix*) conftest_s='    .csect .text[[PR]]
3574         lwsync';;
3575       *) conftest_s='   .text
3576         lwsync';;
3577     esac
3578
3579     gcc_GAS_CHECK_FEATURE([lwsync support],
3580       gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
3581       [$conftest_s],,
3582       [AC_DEFINE(HAVE_AS_LWSYNC, 1,
3583           [Define if your assembler supports LWSYNC instructions.])])
3584
3585     case $target in
3586       *-*-aix*) conftest_s='    .machine "476"
3587         .csect .text[[PR]]
3588         dci 0';;
3589       *) conftest_s='   .machine "476"
3590         .text
3591         dci 0';;
3592     esac
3593
3594     gcc_GAS_CHECK_FEATURE([data cache invalidate support],
3595       gcc_cv_as_powerpc_dci, [9,99,0], -a32,
3596       [$conftest_s],,
3597       [AC_DEFINE(HAVE_AS_DCI, 1,
3598           [Define if your assembler supports the DCI/ICI instructions.])])
3599
3600     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3601       gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
3602       [.gnu_attribute 4,1],,
3603       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3604           [Define if your assembler supports .gnu_attribute.])])
3605
3606     gcc_GAS_CHECK_FEATURE([tls marker support],
3607       gcc_cv_as_powerpc_tls_markers, [2,20,0],,
3608       [ bl __tls_get_addr(x@tlsgd)],,
3609       [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
3610           [Define if your assembler supports arg info for __tls_get_addr.])])
3611
3612     case $target in
3613       *-*-aix*)
3614         gcc_GAS_CHECK_FEATURE([.ref support],
3615           gcc_cv_as_aix_ref, [2.21.0],,
3616           [     .csect stuff[[rw]]
3617              stuff:
3618                 .long 1
3619                 .extern sym
3620                 .ref sym
3621           ],,
3622           [AC_DEFINE(HAVE_AS_REF, 1,
3623             [Define if your assembler supports .ref])])
3624         ;;
3625     esac
3626     ;;
3627
3628   mips*-*-*)
3629     gcc_GAS_CHECK_FEATURE([explicit relocation support],
3630       gcc_cv_as_mips_explicit_relocs, [2,14,0],,
3631 [       lw $4,%gp_rel(foo)($4)],,
3632       [if test x$target_cpu_default = x
3633        then target_cpu_default=MASK_EXPLICIT_RELOCS
3634        else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
3635        fi])
3636     gcc_GAS_CHECK_FEATURE([-mno-shared support],
3637       gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
3638       [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
3639                  [Define if the assembler understands -mno-shared.])])
3640
3641     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3642       gcc_cv_as_mips_gnu_attribute, [2,18,0],,
3643       [.gnu_attribute 4,1],,
3644       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3645           [Define if your assembler supports .gnu_attribute.])])
3646
3647     gcc_GAS_CHECK_FEATURE([.dtprelword support],
3648       gcc_cv_as_mips_dtprelword, [2,18,0],,
3649       [.section .tdata,"awT",@progbits
3650 x:
3651         .word 2
3652         .text
3653         .dtprelword x+0x8000],,
3654       [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
3655           [Define if your assembler supports .dtprelword.])])
3656
3657     AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
3658     gcc_cv_as_ld_jalr_reloc=no
3659     if test $gcc_cv_as_mips_explicit_relocs = yes; then
3660       if test $in_tree_ld = yes ; then
3661         if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 20 -o "$gcc_cv_gld_major_version" -gt 2 \
3662            && test $in_tree_ld_is_elf = yes; then
3663           gcc_cv_as_ld_jalr_reloc=yes
3664         fi
3665       elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
3666         echo '  .ent x' > conftest.s
3667         echo 'x:        ld $2,%got_disp(y)($3)' >> conftest.s
3668         echo '  ld $25,%call16(y)($28)' >> conftest.s
3669         echo '  .reloc  1f,R_MIPS_JALR,y' >> conftest.s
3670         echo '1:        jalr $25' >> conftest.s
3671         echo '  .reloc  1f,R_MIPS_JALR,x' >> conftest.s
3672         echo '1:        jalr $25' >> conftest.s
3673         echo '  .end x' >> conftest.s
3674         if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
3675            && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
3676           if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
3677              && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
3678             gcc_cv_as_ld_jalr_reloc=yes
3679           fi
3680         fi
3681         rm -f conftest.*
3682       fi
3683     fi
3684     if test $gcc_cv_as_ld_jalr_reloc = yes; then
3685       if test x$target_cpu_default = x; then
3686         target_cpu_default=MASK_RELAX_PIC_CALLS
3687       else
3688         target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
3689       fi
3690     fi
3691     AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
3692
3693     AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
3694       [gcc_cv_ld_mips_personality_relaxation],
3695       [gcc_cv_ld_mips_personality_relaxation=no
3696        if test $in_tree_ld = yes ; then
3697          if test "$gcc_cv_gld_major_version" -eq 2 \
3698                  -a "$gcc_cv_gld_minor_version" -ge 21 \
3699                  -o "$gcc_cv_gld_major_version" -gt 2; then
3700            gcc_cv_ld_mips_personality_relaxation=yes
3701          fi
3702        elif test x$gcc_cv_as != x \
3703                  -a x$gcc_cv_ld != x \
3704                  -a x$gcc_cv_readelf != x ; then
3705          cat > conftest.s <<EOF
3706         .cfi_startproc
3707         .cfi_personality 0x80,indirect_ptr
3708         .ent test
3709 test:
3710         nop
3711         .end test
3712         .cfi_endproc
3713
3714         .section .data,"aw",@progbits
3715 indirect_ptr:
3716         .dc.a personality
3717 EOF
3718          if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
3719             && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
3720            if $gcc_cv_readelf -d conftest 2>&1 \
3721               | grep TEXTREL > /dev/null 2>&1; then
3722              :
3723            elif $gcc_cv_readelf --relocs conftest 2>&1 \
3724                 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
3725              :
3726            else
3727              gcc_cv_ld_mips_personality_relaxation=yes
3728            fi
3729          fi
3730        fi
3731        rm -f conftest.s conftest.o conftest])
3732     if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
3733             AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
3734       [Define if your linker can relax absolute .eh_frame personality
3735 pointers into PC-relative form.])
3736     fi
3737     ;;
3738 esac
3739
3740 # Mips and HP-UX need the GNU assembler.
3741 # Linux on IA64 might be able to use the Intel assembler.
3742
3743 case "$target" in
3744   mips*-*-* | *-*-hpux* )
3745     if test x$gas_flag = xyes \
3746        || test x"$host" != x"$build" \
3747        || test ! -x "$gcc_cv_as" \
3748        || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
3749       :
3750     else
3751       echo "*** This configuration requires the GNU assembler" >&2
3752       exit 1
3753     fi
3754     ;;
3755 esac
3756
3757 # ??? Not all targets support dwarf2 debug_line, even within a version
3758 # of gas.  Moreover, we need to emit a valid instruction to trigger any
3759 # info to the output file.  So, as supported targets are added to gas 2.11,
3760 # add some instruction here to (also) show we expect this might work.
3761 # ??? Once 2.11 is released, probably need to add first known working
3762 # version to the per-target configury.
3763 case "$cpu_type" in
3764   alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze | mips \
3765   | pa | rs6000 | score | sparc | spu | xstormy16 | xtensa)
3766     insn="nop"
3767     ;;
3768   ia64 | s390)
3769     insn="nop 0"
3770     ;;
3771   mmix)
3772     insn="swym 0"
3773     ;;
3774 esac
3775 if test x"$insn" != x; then
3776  conftest_s="\
3777         .file 1 \"conftest.s\"
3778         .loc 1 3 0
3779         $insn"
3780  gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
3781   gcc_cv_as_dwarf2_debug_line,
3782   [elf,2,11,0],, [$conftest_s],
3783   [if test x$gcc_cv_objdump != x \
3784    && $gcc_cv_objdump -h conftest.o 2> /dev/null \
3785       | grep debug_line > /dev/null 2>&1; then
3786      gcc_cv_as_dwarf2_debug_line=yes
3787    fi])
3788
3789 # The .debug_line file table must be in the exact order that
3790 # we specified the files, since these indices are also used
3791 # by DW_AT_decl_file.  Approximate this test by testing if
3792 # the assembler bitches if the same index is assigned twice.
3793  gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
3794   gcc_cv_as_dwarf2_file_buggy,,,
3795 [       .file 1 "foo.s"
3796         .file 1 "bar.s"])
3797
3798  if test $gcc_cv_as_dwarf2_debug_line = yes \
3799  && test $gcc_cv_as_dwarf2_file_buggy = no; then
3800         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
3801   [Define if your assembler supports dwarf2 .file/.loc directives,
3802    and preserves file table indices exactly as given.])
3803  fi
3804
3805  gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
3806   gcc_cv_as_gdwarf2_flag,
3807   [elf,2,11,0], [--gdwarf2], [$insn],,
3808   [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
3809 [Define if your assembler supports the --gdwarf2 option.])])
3810
3811  gcc_GAS_CHECK_FEATURE([--gstabs option],
3812   gcc_cv_as_gstabs_flag,
3813   [elf,2,11,0], [--gstabs], [$insn],
3814   [# The native Solaris 9/Intel assembler doesn't understand --gstabs
3815    # and warns about it, but still exits successfully.  So check for
3816    # this.
3817    if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
3818    then :
3819    else gcc_cv_as_gstabs_flag=yes
3820    fi],
3821   [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
3822 [Define if your assembler supports the --gstabs option.])])
3823
3824  gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
3825   gcc_cv_as_debug_prefix_map_flag,
3826   [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
3827   [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
3828 [Define if your assembler supports the --debug-prefix-map option.])])
3829 fi
3830
3831 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
3832  ,,
3833 [.lcomm bar,4,16],,
3834 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
3835   [Define if your assembler supports .lcomm with an alignment field.])])
3836
3837 AC_ARG_ENABLE(gnu-unique-object,
3838  [  --enable-gnu-unique-object  enable the use of the @gnu_unique_object ELF extension on
3839                                 glibc systems],
3840  [case $enable_gnu_unique_object in
3841     yes | no) ;;
3842     *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
3843 Valid choices are 'yes' and 'no'.]) ;;
3844   esac],
3845  [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
3846    [elf,2,19,52],,
3847    [.type foo, @gnu_unique_object],,
3848 # Also check for ld.so support, i.e. glibc 2.11 or higher.
3849    [[if test x$host = x$build -a x$host = x$target &&
3850        glibcver=`ldd --version 2>/dev/null | sed 's/.* //;q'`; then
3851       glibcmajor=`expr "$glibcver" : "\([0-9]*\)"`
3852       glibcminor=`expr "$glibcver" : "[2-9]*\.\([0-9]*\)"`
3853       glibcnum=`expr $glibcmajor \* 1000 + $glibcminor`
3854       if test "$glibcnum" -ge 2011 ; then
3855         enable_gnu_unique_object=yes
3856       fi
3857     fi]])])
3858 if test x$enable_gnu_unique_object = xyes; then
3859   AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
3860    [Define if your assembler supports @gnu_unique_object.])
3861 fi
3862
3863 AC_CACHE_CHECK([assembler for tolerance to line number 0],
3864  [gcc_cv_as_line_zero],
3865  [gcc_cv_as_line_zero=no
3866   if test $in_tree_gas = yes; then
3867     gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
3868   elif test "x$gcc_cv_as" != x; then
3869     { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
3870     if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
3871        test "x`cat conftest.out`" = x
3872     then
3873       gcc_cv_as_line_zero=yes
3874     else
3875       echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
3876       cat conftest.s >&AS_MESSAGE_LOG_FD
3877       echo "configure: error output was" >&AS_MESSAGE_LOG_FD
3878       cat conftest.out >&AS_MESSAGE_LOG_FD
3879     fi
3880     rm -f conftest.o conftest.s conftest.out
3881   fi])
3882 if test "x$gcc_cv_as_line_zero" = xyes; then
3883   AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
3884 [Define if the assembler won't complain about a line such as # 0 "" 2.])
3885 fi
3886
3887 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
3888 gcc_cv_ld_eh_frame_hdr=no
3889 if test $in_tree_ld = yes ; then
3890   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 \
3891      && test $in_tree_ld_is_elf = yes; then
3892     gcc_cv_ld_eh_frame_hdr=yes
3893   fi
3894 elif test x$gcc_cv_ld != x; then
3895         # Check if linker supports --eh-frame-hdr option
3896         if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
3897                 gcc_cv_ld_eh_frame_hdr=yes
3898         fi
3899 fi
3900 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
3901 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
3902         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
3903 [Define if your linker supports --eh-frame-hdr option.])
3904 fi
3905 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
3906
3907 AC_MSG_CHECKING(linker position independent executable support)
3908 gcc_cv_ld_pie=no
3909 if test $in_tree_ld = yes ; then
3910   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 \
3911      && test $in_tree_ld_is_elf = yes; then
3912     gcc_cv_ld_pie=yes
3913   fi
3914 elif test x$gcc_cv_ld != x; then
3915         # Check if linker supports -pie option
3916         if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
3917                 gcc_cv_ld_pie=yes
3918         fi
3919 fi
3920 if test x"$gcc_cv_ld_pie" = xyes; then
3921         AC_DEFINE(HAVE_LD_PIE, 1,
3922 [Define if your linker supports -pie option.])
3923 fi
3924 AC_MSG_RESULT($gcc_cv_ld_pie)
3925
3926 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
3927 gcc_cv_ld_eh_gc_sections=no
3928 if test $in_tree_ld = yes ; then
3929   if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 17 -o "$gcc_cv_gld_major_version" -gt 2 \
3930      && test $in_tree_ld_is_elf = yes; then
3931     gcc_cv_ld_eh_gc_sections=yes
3932   fi
3933 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
3934   cat > conftest.s <<EOF
3935         .section        .text
3936 .globl _start
3937         .type _start, @function
3938 _start:
3939         .long foo
3940         .size _start, .-_start
3941         .section        .text.foo,"ax",@progbits
3942         .type foo, @function
3943 foo:
3944         .long 0
3945         .size foo, .-foo
3946         .section        .gcc_except_table.foo,"a",@progbits
3947 .L0:
3948         .long 0
3949         .section        .eh_frame,"a",@progbits
3950         .long .L0
3951 EOF
3952   if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
3953     if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
3954          | grep "gc-sections option ignored" > /dev/null; then
3955       gcc_cv_ld_eh_gc_sections=no
3956     elif $gcc_cv_objdump -h conftest 2> /dev/null \
3957          | grep gcc_except_table > /dev/null; then
3958       gcc_cv_ld_eh_gc_sections=yes
3959       # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
3960       if test x$gcc_cv_as_comdat_group != xyes; then
3961         gcc_cv_ld_eh_gc_sections=no
3962         cat > conftest.s <<EOF
3963         .section        .text
3964 .globl _start
3965         .type _start, @function
3966 _start:
3967         .long foo
3968         .size _start, .-_start
3969         .section        .gnu.linkonce.t.foo,"ax",@progbits
3970         .type foo, @function
3971 foo:
3972         .long 0
3973         .size foo, .-foo
3974         .section        .gcc_except_table.foo,"a",@progbits
3975 .L0:
3976         .long 0
3977         .section        .eh_frame,"a",@progbits
3978         .long .L0
3979 EOF
3980         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
3981           if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
3982                | grep "gc-sections option ignored" > /dev/null; then
3983             gcc_cv_ld_eh_gc_sections=no
3984           elif $gcc_cv_objdump -h conftest 2> /dev/null \
3985                | grep gcc_except_table > /dev/null; then
3986             gcc_cv_ld_eh_gc_sections=yes
3987           fi
3988         fi
3989       fi
3990     fi
3991   fi
3992   rm -f conftest.s conftest.o conftest
3993 fi
3994 case "$target" in
3995   hppa*-*-linux*)
3996     # ??? This apparently exposes a binutils bug with PC-relative relocations.
3997     gcc_cv_ld_eh_gc_sections=no
3998     ;;
3999 esac
4000 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
4001         AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
4002   [Define if your linker supports garbage collection of
4003    sections in presence of EH frames.])
4004 fi
4005 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
4006
4007 # --------
4008 # UNSORTED
4009 # --------
4010
4011 AC_CACHE_CHECK(linker --as-needed support,
4012 gcc_cv_ld_as_needed,
4013 [gcc_cv_ld_as_needed=no
4014 if test $in_tree_ld = yes ; then
4015   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 \
4016      && test $in_tree_ld_is_elf = yes; then
4017     gcc_cv_ld_as_needed=yes
4018   fi
4019 elif test x$gcc_cv_ld != x; then
4020         # Check if linker supports --as-needed and --no-as-needed options
4021         if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
4022                 gcc_cv_ld_as_needed=yes
4023         fi
4024 fi
4025 ])
4026 if test x"$gcc_cv_ld_as_needed" = xyes; then
4027         AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
4028 [Define if your linker supports --as-needed and --no-as-needed options.])
4029 fi
4030
4031 case "$target:$tm_file" in
4032   powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
4033     AC_CACHE_CHECK(linker support for omitting dot symbols,
4034     gcc_cv_ld_no_dot_syms,
4035     [gcc_cv_ld_no_dot_syms=no
4036     if test $in_tree_ld = yes ; then
4037       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; then
4038         gcc_cv_ld_no_dot_syms=yes
4039       fi
4040     elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4041       cat > conftest1.s <<EOF
4042         .text
4043         bl .foo
4044 EOF
4045       cat > conftest2.s <<EOF
4046         .section ".opd","aw"
4047         .align 3
4048         .globl foo
4049         .type foo,@function
4050 foo:
4051         .quad .LEfoo,.TOC.@tocbase,0
4052         .text
4053 .LEfoo:
4054         blr
4055         .size foo,.-.LEfoo
4056 EOF
4057       if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4058          && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4059          && $gcc_cv_ld -melf64ppc -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
4060         gcc_cv_ld_no_dot_syms=yes
4061       fi
4062       rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
4063     fi
4064     ])
4065     if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
4066       AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
4067     [Define if your PowerPC64 linker only needs function descriptor syms.])
4068     fi
4069
4070     AC_CACHE_CHECK(linker large toc support,
4071     gcc_cv_ld_large_toc,
4072     [gcc_cv_ld_large_toc=no
4073     if test $in_tree_ld = yes ; then
4074       if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 21 -o "$gcc_cv_gld_major_version" -gt 2; then
4075         gcc_cv_ld_large_toc=yes
4076       fi
4077     elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4078       cat > conftest.s <<EOF
4079         .section ".tbss","awT",@nobits
4080         .align 3
4081 ie0:    .space 8
4082         .global _start
4083         .text
4084 _start:
4085         addis 9,13,ie0@got@tprel@ha
4086         ld 9,ie0@got@tprel@l(9)
4087 EOF
4088       if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
4089          && $gcc_cv_ld -melf64ppc --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
4090         gcc_cv_ld_large_toc=yes
4091       fi
4092       rm -f conftest conftest.o conftest.s
4093     fi
4094     ])
4095     if test x"$gcc_cv_ld_large_toc" = xyes; then
4096       AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4097     [Define if your PowerPC64 linker supports a large TOC.])
4098     fi
4099     ;;
4100 esac
4101
4102 AC_CACHE_CHECK(linker --build-id support,
4103   gcc_cv_ld_buildid,
4104   [gcc_cv_ld_buildid=no
4105   if test $in_tree_ld = yes ; then
4106     if test "$gcc_cv_gld_major_version" -eq 2 -a \
4107        "$gcc_cv_gld_minor_version" -ge 18 -o \
4108        "$gcc_cv_gld_major_version" -gt 2 \
4109        && test $in_tree_ld_is_elf = yes; then
4110       gcc_cv_ld_buildid=yes
4111     fi
4112   elif test x$gcc_cv_ld != x; then
4113     if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
4114       gcc_cv_ld_buildid=yes
4115     fi
4116   fi])
4117 if test x"$gcc_cv_ld_buildid" = xyes; then
4118   AC_DEFINE(HAVE_LD_BUILDID, 1,
4119   [Define if your linker supports --build-id.])
4120 fi
4121
4122 AC_ARG_ENABLE(linker-build-id,
4123 [  --enable-linker-build-id
4124                           compiler will always pass --build-id to linker],
4125 [],
4126 enable_linker_build_id=no)
4127
4128 if test x"$enable_linker_build_id" = xyes; then
4129   if test x"$gcc_cv_ld_buildid" = xyes; then
4130     AC_DEFINE(ENABLE_LD_BUILDID, 1,
4131     [Define if gcc should always pass --build-id to linker.])
4132   else
4133     AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
4134   fi
4135 fi
4136
4137 # In binutils 2.21, GNU ld gained support for new emulations fully
4138 # supporting the Solaris 2 ABI.  Detect their presence in the linker used.
4139 AC_CACHE_CHECK(linker *_sol2 emulation support,
4140   gcc_cv_ld_sol2_emulation,
4141   [gcc_cv_ld_sol2_emulation=no
4142   if test $in_tree_ld = yes ; then
4143     if test "$gcc_cv_gld_major_version" -eq 2 -a \
4144        "$gcc_cv_gld_minor_version" -ge 21 -o \
4145        "$gcc_cv_gld_major_version" -gt 2 \
4146        && test $in_tree_ld_is_elf = yes; then
4147       gcc_cv_ld_sol2_emulation=yes
4148     fi
4149   elif test x$gcc_cv_ld != x; then
4150     if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
4151        grep _sol2 > /dev/null; then
4152       gcc_cv_ld_sol2_emulation=yes
4153     fi
4154   fi])
4155 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
4156   AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
4157   [Define if your linker supports the *_sol2 emulations.])
4158 fi
4159
4160 AC_CACHE_CHECK(linker --sysroot support,
4161   gcc_cv_ld_sysroot,
4162   [gcc_cv_ld_sysroot=no
4163   if test $in_tree_ld = yes ; then
4164       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 ; then
4165         gcc_cv_ld_sysroot=yes
4166       fi
4167   elif test x$gcc_cv_ld != x; then 
4168     if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
4169       gcc_cv_ld_sysroot=yes
4170     fi
4171   fi])
4172 if test x"$gcc_cv_ld_sysroot" = xyes; then
4173   AC_DEFINE(HAVE_LD_SYSROOT, 1,
4174   [Define if your linker supports --sysroot.])
4175 fi        
4176
4177 if test x$with_sysroot = x && test x$host = x$target \
4178    && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4179    && test "$prefix" != "NONE"; then
4180   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4181 [Define to PREFIX/include if cpp should also search that directory.])
4182 fi
4183
4184 # Test for stack protector support in target C library.
4185 AC_CACHE_CHECK(__stack_chk_fail in target C library,
4186       gcc_cv_libc_provides_ssp,
4187       [gcc_cv_libc_provides_ssp=no
4188     case "$target" in
4189        *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
4190       if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4191         if test "x$with_headers" != x; then
4192           glibc_header_dir=$with_headers
4193         elif test "x$with_sysroot" = x; then
4194           glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-include"
4195         elif test "x$with_build_sysroot" != "x"; then
4196           glibc_header_dir="${with_build_sysroot}/usr/include"
4197         elif test "x$with_sysroot" = xyes; then
4198           glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-root/usr/include"
4199         else
4200           glibc_header_dir="${with_sysroot}/usr/include"
4201         fi
4202       else
4203         glibc_header_dir=/usr/include
4204       fi
4205       [# glibc 2.4 and later provides __stack_chk_fail and
4206       # either __stack_chk_guard, or TLS access to stack guard canary.
4207       if test -f $glibc_header_dir/features.h \
4208          && $EGREP '^[  ]*#[    ]*define[       ]+__GNU_LIBRARY__[      ]+([1-9][0-9]|[6-9])' \
4209             $glibc_header_dir/features.h > /dev/null; then
4210         if $EGREP '^[   ]*#[    ]*define[       ]+__GLIBC__[    ]+([1-9][0-9]|[3-9])' \
4211            $glibc_header_dir/features.h > /dev/null; then
4212           gcc_cv_libc_provides_ssp=yes
4213         elif $EGREP '^[         ]*#[    ]*define[       ]+__GLIBC__[    ]+2' \
4214              $glibc_header_dir/features.h > /dev/null \
4215              && $EGREP '^[      ]*#[    ]*define[       ]+__GLIBC_MINOR__[      ]+([1-9][0-9]|[4-9])' \
4216              $glibc_header_dir/features.h > /dev/null; then
4217           gcc_cv_libc_provides_ssp=yes
4218         elif $EGREP '^[         ]*#[    ]*define[       ]+__UCLIBC__[   ]+1' \
4219              $glibc_header_dir/features.h > /dev/null && \
4220              test -f $glibc_header_dir/bits/uClibc_config.h && \
4221              $EGREP '^[         ]*#[    ]*define[       ]+__UCLIBC_HAS_SSP__[   ]+1' \
4222              $glibc_header_dir/bits/uClibc_config.h > /dev/null; then
4223           gcc_cv_libc_provides_ssp=yes
4224         fi
4225       fi]
4226         ;;
4227        *-*-gnu*)
4228          # Avoid complicated tests (see
4229          # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
4230          # simply assert that glibc does provide this, which is true for all
4231          # realistically usable GNU/Hurd configurations.
4232          gcc_cv_libc_provides_ssp=yes;;
4233        *-*-darwin* | *-*-freebsd*)
4234          AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
4235            [echo "no __stack_chk_fail on this target"])
4236         ;;
4237   *) gcc_cv_libc_provides_ssp=no ;;
4238     esac])
4239
4240 if test x$gcc_cv_libc_provides_ssp = xyes; then
4241   AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
4242             [Define if your target C library provides stack protector support])
4243 fi
4244
4245 # Check if TFmode long double should be used by default or not.
4246 # Some glibc targets used DFmode long double, but with glibc 2.4
4247 # and later they can use TFmode.
4248 case "$target" in
4249   powerpc*-*-linux* | \
4250   powerpc*-*-gnu* | \
4251   sparc*-*-linux* | \
4252   s390*-*-linux* | \
4253   alpha*-*-linux*)
4254     AC_ARG_WITH(long-double-128,