OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [configure.ac] - Blame information for rev 280

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.