0
|
1 dnl See whether we need a declaration for a function.
|
|
2 dnl The result is highly dependent on the INCLUDES passed in, so make sure
|
|
3 dnl to use a different cache variable name in this macro if it is invoked
|
|
4 dnl in a different context somewhere else.
|
|
5 dnl gcc_AC_CHECK_DECL(SYMBOL,
|
|
6 dnl [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND [, INCLUDES]]])
|
|
7 AC_DEFUN([gcc_AC_CHECK_DECL],
|
|
8 [AC_MSG_CHECKING([whether $1 is declared])
|
|
9 AC_CACHE_VAL(gcc_cv_have_decl_$1,
|
|
10 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([$4],
|
|
11 [#ifndef $1
|
|
12 char *(*pfn) = (char *(*)) $1 ;
|
|
13 #endif])], eval "gcc_cv_have_decl_$1=yes", eval "gcc_cv_have_decl_$1=no")])
|
|
14 if eval "test \"`echo '$gcc_cv_have_decl_'$1`\" = yes"; then
|
|
15 AC_MSG_RESULT(yes) ; ifelse([$2], , :, [$2])
|
|
16 else
|
|
17 AC_MSG_RESULT(no) ; ifelse([$3], , :, [$3])
|
|
18 fi
|
|
19 ])dnl
|
|
20
|
|
21 dnl Check multiple functions to see whether each needs a declaration.
|
|
22 dnl Arrange to define HAVE_DECL_<FUNCTION> to 0 or 1 as appropriate.
|
|
23 dnl gcc_AC_CHECK_DECLS(SYMBOLS,
|
|
24 dnl [ACTION-IF-NEEDED [, ACTION-IF-NOT-NEEDED [, INCLUDES]]])
|
|
25 AC_DEFUN([gcc_AC_CHECK_DECLS],
|
|
26 [AC_FOREACH([gcc_AC_Func], [$1],
|
|
27 [AH_TEMPLATE(AS_TR_CPP(HAVE_DECL_[]gcc_AC_Func),
|
|
28 [Define to 1 if we found a declaration for ']gcc_AC_Func[', otherwise
|
|
29 define to 0.])])dnl
|
|
30 for ac_func in $1
|
|
31 do
|
|
32 ac_tr_decl=AS_TR_CPP([HAVE_DECL_$ac_func])
|
|
33 gcc_AC_CHECK_DECL($ac_func,
|
|
34 [AC_DEFINE_UNQUOTED($ac_tr_decl, 1) $2],
|
|
35 [AC_DEFINE_UNQUOTED($ac_tr_decl, 0) $3],
|
|
36 dnl It is possible that the include files passed in here are local headers
|
|
37 dnl which supply a backup declaration for the relevant prototype based on
|
|
38 dnl the definition of (or lack of) the HAVE_DECL_ macro. If so, this test
|
|
39 dnl will always return success. E.g. see libiberty.h's handling of
|
|
40 dnl `basename'. To avoid this, we define the relevant HAVE_DECL_ macro to
|
|
41 dnl 1 so that any local headers used do not provide their own prototype
|
|
42 dnl during this test.
|
|
43 #undef $ac_tr_decl
|
|
44 #define $ac_tr_decl 1
|
|
45 $4
|
|
46 )
|
|
47 done
|
|
48 ])
|
|
49
|
|
50 dnl 'make compare' can be significantly faster, if cmp itself can
|
|
51 dnl skip bytes instead of using tail. The test being performed is
|
|
52 dnl "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2"
|
|
53 dnl but we need to sink errors and handle broken shells. We also test
|
|
54 dnl for the parameter format "cmp file1 file2 skip1 skip2" which is
|
|
55 dnl accepted by cmp on some systems.
|
|
56 AC_DEFUN([gcc_AC_PROG_CMP_IGNORE_INITIAL],
|
|
57 [AC_CACHE_CHECK([for cmp's capabilities], gcc_cv_prog_cmp_skip,
|
|
58 [ echo abfoo >t1
|
|
59 echo cdfoo >t2
|
|
60 gcc_cv_prog_cmp_skip=slowcompare
|
|
61 if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
|
|
62 if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
|
|
63 :
|
|
64 else
|
|
65 gcc_cv_prog_cmp_skip=gnucompare
|
|
66 fi
|
|
67 fi
|
|
68 if test $gcc_cv_prog_cmp_skip = slowcompare ; then
|
|
69 if cmp t1 t2 2 2 > /dev/null 2>&1; then
|
|
70 if cmp t1 t2 1 1 > /dev/null 2>&1; then
|
|
71 :
|
|
72 else
|
|
73 gcc_cv_prog_cmp_skip=fastcompare
|
|
74 fi
|
|
75 fi
|
|
76 fi
|
|
77 rm t1 t2
|
|
78 ])
|
|
79 make_compare_target=$gcc_cv_prog_cmp_skip
|
|
80 AC_SUBST(make_compare_target)
|
|
81 ])
|
|
82
|
|
83 dnl See if symbolic links work and if not, try to substitute either hard links or simple copy.
|
|
84 AC_DEFUN([gcc_AC_PROG_LN_S],
|
|
85 [AC_MSG_CHECKING(whether ln -s works)
|
|
86 AC_CACHE_VAL(gcc_cv_prog_LN_S,
|
|
87 [rm -f conftestdata_t
|
|
88 echo >conftestdata_f
|
|
89 if ln -s conftestdata_f conftestdata_t 2>/dev/null
|
|
90 then
|
|
91 gcc_cv_prog_LN_S="ln -s"
|
|
92 else
|
|
93 if ln conftestdata_f conftestdata_t 2>/dev/null
|
|
94 then
|
|
95 gcc_cv_prog_LN_S=ln
|
|
96 else
|
|
97 if cp -p conftestdata_f conftestdata_t 2>/dev/null
|
|
98 then
|
|
99 gcc_cv_prog_LN_S="cp -p"
|
|
100 else
|
|
101 gcc_cv_prog_LN_S=cp
|
|
102 fi
|
|
103 fi
|
|
104 fi
|
|
105 rm -f conftestdata_f conftestdata_t
|
|
106 ])dnl
|
|
107 LN_S="$gcc_cv_prog_LN_S"
|
|
108 if test "$gcc_cv_prog_LN_S" = "ln -s"; then
|
|
109 AC_MSG_RESULT(yes)
|
|
110 else
|
|
111 if test "$gcc_cv_prog_LN_S" = "ln"; then
|
|
112 AC_MSG_RESULT([no, using ln])
|
|
113 else
|
|
114 AC_MSG_RESULT([no, and neither does ln, so using $gcc_cv_prog_LN_S])
|
|
115 fi
|
|
116 fi
|
|
117 AC_SUBST(LN_S)dnl
|
|
118 ])
|
|
119
|
|
120 dnl Define MKDIR_TAKES_ONE_ARG if mkdir accepts only one argument instead
|
|
121 dnl of the usual 2.
|
|
122 AC_DEFUN([gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG],
|
|
123 [AC_CACHE_CHECK([if mkdir takes one argument], gcc_cv_mkdir_takes_one_arg,
|
|
124 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
|
|
125 #include <sys/types.h>
|
|
126 #ifdef HAVE_SYS_STAT_H
|
|
127 # include <sys/stat.h>
|
|
128 #endif
|
|
129 #ifdef HAVE_UNISTD_H
|
|
130 # include <unistd.h>
|
|
131 #endif
|
|
132 #ifdef HAVE_DIRECT_H
|
|
133 # include <direct.h>
|
|
134 #endif], [mkdir ("foo", 0);])],
|
|
135 gcc_cv_mkdir_takes_one_arg=no, gcc_cv_mkdir_takes_one_arg=yes)])
|
|
136 if test $gcc_cv_mkdir_takes_one_arg = yes ; then
|
|
137 AC_DEFINE(MKDIR_TAKES_ONE_ARG, 1, [Define if host mkdir takes a single argument.])
|
|
138 fi
|
|
139 ])
|
|
140
|
|
141 AC_DEFUN([gcc_AC_PROG_INSTALL],
|
|
142 [AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
|
|
143 # Find a good install program. We prefer a C program (faster),
|
|
144 # so one script is as good as another. But avoid the broken or
|
|
145 # incompatible versions:
|
|
146 # SysV /etc/install, /usr/sbin/install
|
|
147 # SunOS /usr/etc/install
|
|
148 # IRIX /sbin/install
|
|
149 # AIX /bin/install
|
|
150 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
|
|
151 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
|
|
152 # ./install, which can be erroneously created by make from ./install.sh.
|
|
153 AC_MSG_CHECKING(for a BSD compatible install)
|
|
154 if test -z "$INSTALL"; then
|
|
155 AC_CACHE_VAL(ac_cv_path_install,
|
|
156 [ IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="${IFS}:"
|
|
157 for ac_dir in $PATH; do
|
|
158 # Account for people who put trailing slashes in PATH elements.
|
|
159 case "$ac_dir/" in
|
|
160 /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
|
|
161 *)
|
|
162 # OSF1 and SCO ODT 3.0 have their own names for install.
|
|
163 for ac_prog in ginstall scoinst install; do
|
|
164 if test -f $ac_dir/$ac_prog; then
|
|
165 if test $ac_prog = install &&
|
|
166 grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
|
|
167 # AIX install. It has an incompatible calling convention.
|
|
168 # OSF/1 installbsd also uses dspmsg, but is usable.
|
|
169 :
|
|
170 else
|
|
171 ac_cv_path_install="$ac_dir/$ac_prog -c"
|
|
172 break 2
|
|
173 fi
|
|
174 fi
|
|
175 done
|
|
176 ;;
|
|
177 esac
|
|
178 done
|
|
179 IFS="$ac_save_IFS"
|
|
180 ])dnl
|
|
181 if test "${ac_cv_path_install+set}" = set; then
|
|
182 INSTALL="$ac_cv_path_install"
|
|
183 else
|
|
184 # As a last resort, use the slow shell script. We don't cache a
|
|
185 # path for INSTALL within a source directory, because that will
|
|
186 # break other packages using the cache if that directory is
|
|
187 # removed, or if the path is relative.
|
|
188 INSTALL="$ac_install_sh"
|
|
189 fi
|
|
190 fi
|
|
191 dnl We do special magic for INSTALL instead of AC_SUBST, to get
|
|
192 dnl relative paths right.
|
|
193 AC_MSG_RESULT($INSTALL)
|
|
194 AC_SUBST(INSTALL)dnl
|
|
195
|
|
196 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
|
|
197 # It thinks the first close brace ends the variable substitution.
|
|
198 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
|
|
199 AC_SUBST(INSTALL_PROGRAM)dnl
|
|
200
|
|
201 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
|
|
202 AC_SUBST(INSTALL_DATA)dnl
|
|
203 ])
|
|
204
|
|
205 # mmap(2) blacklisting. Some platforms provide the mmap library routine
|
|
206 # but don't support all of the features we need from it.
|
|
207 AC_DEFUN([gcc_AC_FUNC_MMAP_BLACKLIST],
|
|
208 [
|
|
209 AC_CHECK_HEADER([sys/mman.h],
|
|
210 [gcc_header_sys_mman_h=yes], [gcc_header_sys_mman_h=no])
|
|
211 AC_CHECK_FUNC([mmap], [gcc_func_mmap=yes], [gcc_func_mmap=no])
|
|
212 if test "$gcc_header_sys_mman_h" != yes \
|
|
213 || test "$gcc_func_mmap" != yes; then
|
|
214 gcc_cv_func_mmap_file=no
|
|
215 gcc_cv_func_mmap_dev_zero=no
|
|
216 gcc_cv_func_mmap_anon=no
|
|
217 else
|
|
218 AC_CACHE_CHECK([whether read-only mmap of a plain file works],
|
|
219 gcc_cv_func_mmap_file,
|
|
220 [# Add a system to this blacklist if
|
|
221 # mmap(0, stat_size, PROT_READ, MAP_PRIVATE, fd, 0) doesn't return a
|
|
222 # memory area containing the same data that you'd get if you applied
|
|
223 # read() to the same fd. The only system known to have a problem here
|
|
224 # is VMS, where text files have record structure.
|
|
225 case "$host_os" in
|
|
226 vms* | ultrix*)
|
|
227 gcc_cv_func_mmap_file=no ;;
|
|
228 *)
|
|
229 gcc_cv_func_mmap_file=yes;;
|
|
230 esac])
|
|
231 AC_CACHE_CHECK([whether mmap from /dev/zero works],
|
|
232 gcc_cv_func_mmap_dev_zero,
|
|
233 [# Add a system to this blacklist if it has mmap() but /dev/zero
|
|
234 # does not exist, or if mmapping /dev/zero does not give anonymous
|
|
235 # zeroed pages with both the following properties:
|
|
236 # 1. If you map N consecutive pages in with one call, and then
|
|
237 # unmap any subset of those pages, the pages that were not
|
|
238 # explicitly unmapped remain accessible.
|
|
239 # 2. If you map two adjacent blocks of memory and then unmap them
|
|
240 # both at once, they must both go away.
|
|
241 # Systems known to be in this category are Windows (all variants),
|
|
242 # VMS, and Darwin.
|
|
243 case "$host_os" in
|
|
244 vms* | cygwin* | pe | mingw* | darwin* | ultrix* | hpux10* | hpux11.00)
|
|
245 gcc_cv_func_mmap_dev_zero=no ;;
|
|
246 *)
|
|
247 gcc_cv_func_mmap_dev_zero=yes;;
|
|
248 esac])
|
|
249
|
|
250 # Unlike /dev/zero, the MAP_ANON(YMOUS) defines can be probed for.
|
|
251 AC_CACHE_CHECK([for MAP_ANON(YMOUS)], gcc_cv_decl_map_anon,
|
|
252 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
|
|
253 [#include <sys/types.h>
|
|
254 #include <sys/mman.h>
|
|
255 #include <unistd.h>
|
|
256
|
|
257 #ifndef MAP_ANONYMOUS
|
|
258 #define MAP_ANONYMOUS MAP_ANON
|
|
259 #endif
|
|
260 ],
|
|
261 [int n = MAP_ANONYMOUS;])],
|
|
262 gcc_cv_decl_map_anon=yes,
|
|
263 gcc_cv_decl_map_anon=no)])
|
|
264
|
|
265 if test $gcc_cv_decl_map_anon = no; then
|
|
266 gcc_cv_func_mmap_anon=no
|
|
267 else
|
|
268 AC_CACHE_CHECK([whether mmap with MAP_ANON(YMOUS) works],
|
|
269 gcc_cv_func_mmap_anon,
|
|
270 [# Add a system to this blacklist if it has mmap() and MAP_ANON or
|
|
271 # MAP_ANONYMOUS, but using mmap(..., MAP_PRIVATE|MAP_ANONYMOUS, -1, 0)
|
|
272 # doesn't give anonymous zeroed pages with the same properties listed
|
|
273 # above for use of /dev/zero.
|
|
274 # Systems known to be in this category are Windows, VMS, and SCO Unix.
|
|
275 case "$host_os" in
|
|
276 vms* | cygwin* | pe | mingw* | sco* | udk* )
|
|
277 gcc_cv_func_mmap_anon=no ;;
|
|
278 *)
|
|
279 gcc_cv_func_mmap_anon=yes;;
|
|
280 esac])
|
|
281 fi
|
|
282 fi
|
|
283
|
|
284 if test $gcc_cv_func_mmap_file = yes; then
|
|
285 AC_DEFINE(HAVE_MMAP_FILE, 1,
|
|
286 [Define if read-only mmap of a plain file works.])
|
|
287 fi
|
|
288 if test $gcc_cv_func_mmap_dev_zero = yes; then
|
|
289 AC_DEFINE(HAVE_MMAP_DEV_ZERO, 1,
|
|
290 [Define if mmap of /dev/zero works.])
|
|
291 fi
|
|
292 if test $gcc_cv_func_mmap_anon = yes; then
|
|
293 AC_DEFINE(HAVE_MMAP_ANON, 1,
|
|
294 [Define if mmap with MAP_ANON(YMOUS) works.])
|
|
295 fi
|
|
296 ])
|
|
297
|
|
298 dnl Determine if enumerated bitfields are unsigned. ISO C says they can
|
|
299 dnl be either signed or unsigned.
|
|
300 dnl
|
|
301 AC_DEFUN([gcc_AC_C_ENUM_BF_UNSIGNED],
|
|
302 [AC_CACHE_CHECK(for unsigned enumerated bitfields, gcc_cv_enum_bf_unsigned,
|
|
303 [AC_RUN_IFELSE([AC_LANG_SOURCE([#include <stdlib.h>
|
|
304 enum t { BLAH = 128 } ;
|
|
305 struct s_t { enum t member : 8; } s ;
|
|
306 int main(void)
|
|
307 {
|
|
308 s.member = BLAH;
|
|
309 if (s.member < 0) exit(1);
|
|
310 exit(0);
|
|
311
|
|
312 }])], gcc_cv_enum_bf_unsigned=yes, gcc_cv_enum_bf_unsigned=no, gcc_cv_enum_bf_unsigned=yes)])
|
|
313 if test $gcc_cv_enum_bf_unsigned = yes; then
|
|
314 AC_DEFINE(ENUM_BITFIELDS_ARE_UNSIGNED, 1,
|
|
315 [Define if enumerated bitfields are treated as unsigned values.])
|
|
316 fi])
|
|
317
|
|
318 dnl Probe number of bits in a byte.
|
|
319 dnl Note C89 requires CHAR_BIT >= 8.
|
|
320 dnl
|
|
321 AC_DEFUN([gcc_AC_C_CHAR_BIT],
|
|
322 [AC_CACHE_CHECK(for CHAR_BIT, gcc_cv_decl_char_bit,
|
|
323 [AC_EGREP_CPP(found,
|
|
324 [#ifdef HAVE_LIMITS_H
|
|
325 #include <limits.h>
|
|
326 #endif
|
|
327 #ifdef CHAR_BIT
|
|
328 found
|
|
329 #endif], gcc_cv_decl_char_bit=yes, gcc_cv_decl_char_bit=no)
|
|
330 ])
|
|
331 if test $gcc_cv_decl_char_bit = no; then
|
|
332 AC_CACHE_CHECK(number of bits in a byte, gcc_cv_c_nbby,
|
|
333 [i=8
|
|
334 gcc_cv_c_nbby=
|
|
335 while test $i -lt 65; do
|
|
336 AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,
|
|
337 [switch(0) {
|
|
338 case (unsigned char)((unsigned long)1 << $i) == ((unsigned long)1 << $i):
|
|
339 case (unsigned char)((unsigned long)1<<($i-1)) == ((unsigned long)1<<($i-1)):
|
|
340 ; }])],
|
|
341 [gcc_cv_c_nbby=$i; break])
|
|
342 i=`expr $i + 1`
|
|
343 done
|
|
344 test -z "$gcc_cv_c_nbby" && gcc_cv_c_nbby=failed
|
|
345 ])
|
|
346 if test $gcc_cv_c_nbby = failed; then
|
|
347 AC_MSG_ERROR(cannot determine number of bits in a byte)
|
|
348 else
|
|
349 AC_DEFINE_UNQUOTED(CHAR_BIT, $gcc_cv_c_nbby,
|
|
350 [Define as the number of bits in a byte, if `limits.h' doesn't.])
|
|
351 fi
|
|
352 fi])
|
|
353
|
|
354 AC_DEFUN([gcc_AC_INITFINI_ARRAY],
|
|
355 [AC_ARG_ENABLE(initfini-array,
|
|
356 [ --enable-initfini-array use .init_array/.fini_array sections],
|
|
357 [], [
|
|
358 AC_CACHE_CHECK(for .preinit_array/.init_array/.fini_array support,
|
|
359 gcc_cv_initfini_array, [dnl
|
|
360 AC_RUN_IFELSE([AC_LANG_SOURCE([
|
|
361 static int x = -1;
|
|
362 int main (void) { return x; }
|
|
363 int foo (void) { x = 0; }
|
|
364 int (*fp) (void) __attribute__ ((section (".init_array"))) = foo;])],
|
|
365 [gcc_cv_initfini_array=yes], [gcc_cv_initfini_array=no],
|
|
366 [gcc_cv_initfini_array=no])])
|
|
367 enable_initfini_array=$gcc_cv_initfini_array
|
|
368 ])
|
|
369 if test $enable_initfini_array = yes; then
|
|
370 AC_DEFINE(HAVE_INITFINI_ARRAY, 1,
|
|
371 [Define .init_array/.fini_array sections are available and working.])
|
|
372 fi])
|
|
373
|
|
374 dnl # _gcc_COMPUTE_GAS_VERSION
|
|
375 dnl # Used by gcc_GAS_VERSION_GTE_IFELSE
|
|
376 dnl #
|
|
377 dnl # WARNING:
|
|
378 dnl # gcc_cv_as_gas_srcdir must be defined before this.
|
|
379 dnl # This gross requirement will go away eventually.
|
|
380 AC_DEFUN([_gcc_COMPUTE_GAS_VERSION],
|
|
381 [gcc_cv_as_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
|
|
382 for f in $gcc_cv_as_bfd_srcdir/configure \
|
|
383 $gcc_cv_as_gas_srcdir/configure \
|
|
384 $gcc_cv_as_gas_srcdir/configure.in \
|
|
385 $gcc_cv_as_gas_srcdir/Makefile.in ; do
|
|
386 gcc_cv_gas_version=`sed -n -e 's/^[[ ]]*\(VERSION=[[0-9]]*\.[[0-9]]*.*\)/\1/p' < $f`
|
|
387 if test x$gcc_cv_gas_version != x; then
|
|
388 break
|
|
389 fi
|
|
390 done
|
|
391 gcc_cv_gas_major_version=`expr "$gcc_cv_gas_version" : "VERSION=\([[0-9]]*\)"`
|
|
392 gcc_cv_gas_minor_version=`expr "$gcc_cv_gas_version" : "VERSION=[[0-9]]*\.\([[0-9]]*\)"`
|
|
393 gcc_cv_gas_patch_version=`expr "$gcc_cv_gas_version" : "VERSION=[[0-9]]*\.[[0-9]]*\.\([[0-9]]*\)"`
|
|
394 case $gcc_cv_gas_patch_version in
|
|
395 "") gcc_cv_gas_patch_version="0" ;;
|
|
396 esac
|
|
397 gcc_cv_gas_vers=`expr \( \( $gcc_cv_gas_major_version \* 1000 \) \
|
|
398 + $gcc_cv_gas_minor_version \) \* 1000 \
|
|
399 + $gcc_cv_gas_patch_version`
|
|
400 ]) []dnl # _gcc_COMPUTE_GAS_VERSION
|
|
401
|
|
402 dnl # gcc_GAS_VERSION_GTE_IFELSE([elf,] major, minor, patchlevel,
|
|
403 dnl # [command_if_true = :], [command_if_false = :])
|
|
404 dnl # Check to see if the version of GAS is greater than or
|
|
405 dnl # equal to the specified version.
|
|
406 dnl #
|
|
407 dnl # The first ifelse() shortens the shell code if the patchlevel
|
|
408 dnl # is unimportant (the usual case). The others handle missing
|
|
409 dnl # commands. Note that the tests are structured so that the most
|
|
410 dnl # common version number cases are tested first.
|
|
411 AC_DEFUN([_gcc_GAS_VERSION_GTE_IFELSE],
|
|
412 [ifelse([$1], elf,
|
|
413 [if test $in_tree_gas_is_elf = yes \
|
|
414 &&],
|
|
415 [if]) test $gcc_cv_gas_vers -ge `expr \( \( $2 \* 1000 \) + $3 \) \* 1000 + $4`
|
|
416 then dnl
|
|
417 ifelse([$5],,:,[$5])[]dnl
|
|
418 ifelse([$6],,,[
|
|
419 else $6])
|
|
420 fi])
|
|
421
|
|
422 AC_DEFUN([gcc_GAS_VERSION_GTE_IFELSE],
|
|
423 [AC_REQUIRE([_gcc_COMPUTE_GAS_VERSION])dnl
|
|
424 ifelse([$1], elf, [_gcc_GAS_VERSION_GTE_IFELSE($@)],
|
|
425 [_gcc_GAS_VERSION_GTE_IFELSE(,$@)])])
|
|
426
|
|
427 dnl gcc_GAS_CHECK_FEATURE(description, cv, [[elf,]major,minor,patchlevel],
|
|
428 dnl [extra switches to as], [assembler input],
|
|
429 dnl [extra testing logic], [command if feature available])
|
|
430 dnl
|
|
431 dnl Checks for an assembler feature. If we are building an in-tree
|
|
432 dnl gas, the feature is available if the associated assembler version
|
|
433 dnl is greater than or equal to major.minor.patchlevel. If not, then
|
|
434 dnl ASSEMBLER INPUT is fed to the assembler and the feature is available
|
|
435 dnl if assembly succeeds. If EXTRA TESTING LOGIC is not the empty string,
|
|
436 dnl then it is run instead of simply setting CV to "yes" - it is responsible
|
|
437 dnl for doing so, if appropriate.
|
|
438 AC_DEFUN([gcc_GAS_CHECK_FEATURE],
|
|
439 [AC_CACHE_CHECK([assembler for $1], [$2],
|
|
440 [[$2]=no
|
|
441 ifelse([$3],,,[dnl
|
|
442 if test $in_tree_gas = yes; then
|
|
443 gcc_GAS_VERSION_GTE_IFELSE($3, [[$2]=yes])
|
|
444 el])if test x$gcc_cv_as != x; then
|
|
445 echo ifelse(m4_substr([$5],0,1),[$], "[$5]", '[$5]') > conftest.s
|
|
446 if AC_TRY_COMMAND([$gcc_cv_as $4 -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD])
|
|
447 then
|
|
448 ifelse([$6],, [$2]=yes, [$6])
|
|
449 else
|
|
450 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
|
|
451 cat conftest.s >&AS_MESSAGE_LOG_FD
|
|
452 fi
|
|
453 rm -f conftest.o conftest.s
|
|
454 fi])
|
|
455 ifelse([$7],,,[dnl
|
|
456 if test $[$2] = yes; then
|
|
457 $7
|
|
458 fi])])
|
|
459
|
|
460 dnl GCC_TARGET_TEMPLATE(KEY)
|
|
461 dnl ------------------------
|
|
462 dnl Define KEY as a valid configure key on the target machine.
|
|
463
|
|
464 m4_define([GCC_TARGET_TEMPLATE],
|
|
465 [m4_define([GCC_TARGET_TEMPLATE($1)],[])])
|
|
466
|
|
467 dnl AH_TEMPLATE(KEY, DESCRIPTION)
|
|
468 dnl -----------------------------
|
|
469 dnl Issue an autoheader template for KEY, i.e., a comment composed of
|
|
470 dnl DESCRIPTION (properly wrapped), and then #undef KEY. Redefinition
|
|
471 dnl of the macro in autoheader.m4, to support definition of only a few
|
|
472 dnl keys while compiling target libraries.
|
|
473
|
|
474 m4_define([AH_TEMPLATE],
|
|
475 [AH_VERBATIM([$1],m4_text_wrap([$2 */], [ ], [/* ])
|
|
476 m4_ifdef([GCC_TARGET_TEMPLATE($1)],[],[#ifndef USED_FOR_TARGET
|
|
477 ])[#undef $1]m4_ifdef([GCC_TARGET_TEMPLATE($1)],[],[
|
|
478 #endif
|
|
479 ]))])
|
|
480
|
|
481 dnl Make sure that build_exeext is looked for
|
|
482 AC_DEFUN([gcc_AC_BUILD_EXEEXT], [
|
|
483 ac_executable_extensions="$build_exeext"])
|
|
484
|