OSDN Git Service

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