Mercurial > hg > CbC > CbC_gcc
annotate config/acx.m4 @ 111:04ced10e8804
gcc 7
author | kono |
---|---|
date | Fri, 27 Oct 2017 22:46:09 +0900 |
parents | 77e2b8dfacca |
children | 84e7813d76e9 |
rev | line source |
---|---|
0 | 1 # Autoconf M4 include file defining utility macros for complex Canadian |
2 # cross builds. | |
3 | |
4 dnl #### | |
5 dnl # _GCC_TOPLEV_NONCANONICAL_BUILD | |
6 dnl # $build_alias or canonical $build if blank. | |
7 dnl # Used when we would use $build_alias, but empty is not OK. | |
8 AC_DEFUN([_GCC_TOPLEV_NONCANONICAL_BUILD], | |
9 [AC_REQUIRE([AC_CANONICAL_BUILD]) []dnl | |
10 case ${build_alias} in | |
11 "") build_noncanonical=${build} ;; | |
12 *) build_noncanonical=${build_alias} ;; | |
13 esac | |
14 ]) []dnl # _GCC_TOPLEV_NONCANONICAL_BUILD | |
15 | |
16 dnl #### | |
17 dnl # _GCC_TOPLEV_NONCANONICAL_HOST | |
18 dnl # $host_alias, or $build_noncanonical if blank. | |
19 dnl # Used when we would use $host_alias, but empty is not OK. | |
20 AC_DEFUN([_GCC_TOPLEV_NONCANONICAL_HOST], | |
21 [AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_BUILD]) []dnl | |
22 case ${host_alias} in | |
23 "") host_noncanonical=${build_noncanonical} ;; | |
24 *) host_noncanonical=${host_alias} ;; | |
25 esac | |
26 ]) []dnl # _GCC_TOPLEV_NONCANONICAL_HOST | |
27 | |
28 dnl #### | |
29 dnl # _GCC_TOPLEV_NONCANONICAL_TARGET | |
30 dnl # $target_alias or $host_noncanonical if blank. | |
31 dnl # Used when we would use $target_alias, but empty is not OK. | |
32 AC_DEFUN([_GCC_TOPLEV_NONCANONICAL_TARGET], | |
33 [AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_HOST]) []dnl | |
34 case ${target_alias} in | |
35 "") target_noncanonical=${host_noncanonical} ;; | |
36 *) target_noncanonical=${target_alias} ;; | |
37 esac | |
38 ]) []dnl # _GCC_TOPLEV_NONCANONICAL_TARGET | |
39 | |
40 dnl #### | |
41 dnl # ACX_NONCANONICAL_BUILD | |
42 dnl # Like underscored version, but AC_SUBST's. | |
43 AC_DEFUN([ACX_NONCANONICAL_BUILD], | |
44 [AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_BUILD]) []dnl | |
45 AC_SUBST(build_noncanonical) | |
46 ]) []dnl # ACX_NONCANONICAL_BUILD | |
47 | |
48 dnl #### | |
49 dnl # ACX_NONCANONICAL_HOST | |
50 dnl # Like underscored version, but AC_SUBST's. | |
51 AC_DEFUN([ACX_NONCANONICAL_HOST], | |
52 [AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_HOST]) []dnl | |
53 AC_SUBST(host_noncanonical) | |
54 ]) []dnl # ACX_NONCANONICAL_HOST | |
55 | |
56 dnl #### | |
57 dnl # ACX_NONCANONICAL_TARGET | |
58 dnl # Like underscored version, but AC_SUBST's. | |
59 AC_DEFUN([ACX_NONCANONICAL_TARGET], | |
60 [AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_TARGET]) []dnl | |
61 AC_SUBST(target_noncanonical) | |
62 ]) []dnl # ACX_NONCANONICAL_TARGET | |
63 | |
64 dnl #### | |
65 dnl # GCC_TOPLEV_SUBDIRS | |
66 dnl # GCC & friends build 'build', 'host', and 'target' tools. These must | |
67 dnl # be separated into three well-known subdirectories of the build directory: | |
68 dnl # build_subdir, host_subdir, and target_subdir. The values are determined | |
69 dnl # here so that they can (theoretically) be changed in the future. They | |
70 dnl # were previously reproduced across many different files. | |
71 dnl # | |
72 dnl # This logic really amounts to very little with autoconf 2.13; it will | |
73 dnl # amount to a lot more with autoconf 2.5x. | |
74 AC_DEFUN([GCC_TOPLEV_SUBDIRS], | |
75 [AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_TARGET]) []dnl | |
76 AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_BUILD]) []dnl | |
77 | |
78 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to | |
79 # have matching libraries, they should use host libraries: Makefile.tpl | |
80 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR). | |
81 # However, they still use the build modules, because the corresponding | |
82 # host modules (e.g. bison) are only built for the host when bootstrap | |
83 # finishes. So: | |
84 # - build_subdir is where we find build modules, and never changes. | |
85 # - build_libsubdir is where we find build libraries, and can be overridden. | |
86 | |
87 # Prefix 'build-' so this never conflicts with target_subdir. | |
88 build_subdir="build-${build_noncanonical}" | |
89 AC_ARG_WITH(build-libsubdir, | |
90 [ --with-build-libsubdir=[DIR] Directory where to find libraries for build system], | |
91 build_libsubdir="$withval", | |
92 build_libsubdir="$build_subdir") | |
93 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories | |
94 if ( test $srcdir = . && test -d gcc ) \ | |
95 || test -d $srcdir/../host-${host_noncanonical}; then | |
96 host_subdir="host-${host_noncanonical}" | |
97 else | |
98 host_subdir=. | |
99 fi | |
100 # No prefix. | |
101 target_subdir=${target_noncanonical} | |
102 AC_SUBST([build_libsubdir]) []dnl | |
103 AC_SUBST([build_subdir]) []dnl | |
104 AC_SUBST([host_subdir]) []dnl | |
105 AC_SUBST([target_subdir]) []dnl | |
106 ]) []dnl # GCC_TOPLEV_SUBDIRS | |
107 | |
108 | |
109 #### | |
110 # _NCN_TOOL_PREFIXES: Some stuff that oughtta be done in AC_CANONICAL_SYSTEM | |
111 # or AC_INIT. | |
112 # These demand that AC_CANONICAL_SYSTEM be called beforehand. | |
113 AC_DEFUN([_NCN_TOOL_PREFIXES], | |
114 [ncn_tool_prefix= | |
115 test -n "$host_alias" && ncn_tool_prefix=$host_alias- | |
116 ncn_target_tool_prefix= | |
117 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias- | |
118 ]) []dnl # _NCN_TOOL_PREFIXES | |
119 | |
120 #### | |
121 # NCN_STRICT_CHECK_TOOLS(variable, progs-to-check-for,[value-if-not-found],[path]) | |
122 # Like plain AC_CHECK_TOOLS, but require prefix if build!=host. | |
123 | |
124 AC_DEFUN([NCN_STRICT_CHECK_TOOLS], | |
125 [AC_REQUIRE([_NCN_TOOL_PREFIXES]) []dnl | |
126 AC_ARG_VAR([$1], [$1 for the host]) | |
127 | |
128 if test -n "[$]$1"; then | |
129 ac_cv_prog_$1=[$]$1 | |
130 elif test -n "$ac_cv_prog_$1"; then | |
131 $1=$ac_cv_prog_$1 | |
132 fi | |
133 | |
134 if test -n "$ac_cv_prog_$1"; then | |
135 for ncn_progname in $2; do | |
136 AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4]) | |
137 done | |
138 fi | |
139 | |
140 for ncn_progname in $2; do | |
141 if test -n "$ncn_tool_prefix"; then | |
142 AC_CHECK_PROG([$1], [${ncn_tool_prefix}${ncn_progname}], | |
143 [${ncn_tool_prefix}${ncn_progname}], , [$4]) | |
144 fi | |
145 if test -z "$ac_cv_prog_$1" && test $build = $host ; then | |
146 AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4]) | |
147 fi | |
148 test -n "$ac_cv_prog_$1" && break | |
149 done | |
150 | |
151 if test -z "$ac_cv_prog_$1" ; then | |
152 ifelse([$3],[], [set dummy $2 | |
153 if test $build = $host ; then | |
154 $1="[$]2" | |
155 else | |
156 $1="${ncn_tool_prefix}[$]2" | |
157 fi], [$1="$3"]) | |
158 fi | |
159 ]) []dnl # NCN_STRICT_CHECK_TOOLS | |
160 | |
161 #### | |
162 # NCN_STRICT_CHECK_TARGET_TOOLS(variable, progs-to-check-for,[value-if-not-found],[path]) | |
163 # Like CVS Autoconf AC_CHECK_TARGET_TOOLS, but require prefix if build!=target. | |
164 | |
165 AC_DEFUN([NCN_STRICT_CHECK_TARGET_TOOLS], | |
166 [AC_REQUIRE([_NCN_TOOL_PREFIXES]) []dnl | |
167 AC_ARG_VAR([$1], patsubst([$1], [_FOR_TARGET$], [])[ for the target]) | |
168 | |
169 if test -n "[$]$1"; then | |
170 ac_cv_prog_$1=[$]$1 | |
171 elif test -n "$ac_cv_prog_$1"; then | |
172 $1=$ac_cv_prog_$1 | |
173 fi | |
174 | |
175 if test -n "$ac_cv_prog_$1"; then | |
176 for ncn_progname in $2; do | |
177 AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4]) | |
178 done | |
179 fi | |
180 | |
181 if test -z "$ac_cv_prog_$1" && test -n "$with_build_time_tools"; then | |
182 for ncn_progname in $2; do | |
183 AC_MSG_CHECKING([for ${ncn_progname} in $with_build_time_tools]) | |
184 if test -x $with_build_time_tools/${ncn_progname}; then | |
185 ac_cv_prog_$1=$with_build_time_tools/${ncn_progname} | |
186 AC_MSG_RESULT(yes) | |
187 break | |
188 else | |
189 AC_MSG_RESULT(no) | |
190 fi | |
191 done | |
192 fi | |
193 | |
194 if test -z "$ac_cv_prog_$1"; then | |
195 for ncn_progname in $2; do | |
196 if test -n "$ncn_target_tool_prefix"; then | |
197 AC_CHECK_PROG([$1], [${ncn_target_tool_prefix}${ncn_progname}], | |
198 [${ncn_target_tool_prefix}${ncn_progname}], , [$4]) | |
199 fi | |
200 if test -z "$ac_cv_prog_$1" && test $build = $target ; then | |
201 AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4]) | |
202 fi | |
203 test -n "$ac_cv_prog_$1" && break | |
204 done | |
205 fi | |
206 | |
207 if test -z "$ac_cv_prog_$1" ; then | |
208 ifelse([$3],[], [set dummy $2 | |
209 if test $build = $target ; then | |
210 $1="[$]2" | |
211 else | |
212 $1="${ncn_target_tool_prefix}[$]2" | |
213 fi], [$1="$3"]) | |
214 else | |
215 $1="$ac_cv_prog_$1" | |
216 fi | |
217 ]) []dnl # NCN_STRICT_CHECK_TARGET_TOOLS | |
218 | |
219 | |
220 # Backported from Autoconf 2.5x; can go away when and if | |
221 # we switch. Put the OS path separator in $PATH_SEPARATOR. | |
222 AC_DEFUN([ACX_PATH_SEP], [ | |
223 # The user is always right. | |
224 if test "${PATH_SEPARATOR+set}" != set; then | |
225 echo "#! /bin/sh" >conf$$.sh | |
226 echo "exit 0" >>conf$$.sh | |
227 chmod +x conf$$.sh | |
228 if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then | |
229 PATH_SEPARATOR=';' | |
230 else | |
231 PATH_SEPARATOR=: | |
232 fi | |
233 rm -f conf$$.sh | |
234 fi | |
235 ]) | |
236 | |
237 | |
111 | 238 dnl #### |
239 dnl # GCC_BASE_VER | |
240 dnl # Determine GCC version number to use in compiler directories. | |
241 | |
242 AC_DEFUN([GCC_BASE_VER], | |
243 [ | |
244 get_gcc_base_ver="cat" | |
245 AC_ARG_WITH(gcc-major-version-only, | |
246 [AS_HELP_STRING([--with-gcc-major-version-only], [use only GCC major number in filesystem paths])], | |
247 [if test x$with_gcc_major_version_only = xyes ; then | |
248 changequote(,)dnl | |
249 get_gcc_base_ver="sed -e 's/^\([0-9]*\).*\$\$/\1/'" | |
250 changequote([,])dnl | |
251 fi | |
252 ]) | |
253 AC_SUBST(get_gcc_base_ver) | |
254 ]) | |
255 | |
256 | |
0 | 257 AC_DEFUN([ACX_TOOL_DIRS], [ |
258 AC_REQUIRE([ACX_PATH_SEP]) | |
111 | 259 AC_REQUIRE([GCC_BASE_VER]) |
0 | 260 if test "x$exec_prefix" = xNONE; then |
261 if test "x$prefix" = xNONE; then | |
262 gcc_cv_tool_prefix=$ac_default_prefix | |
263 else | |
264 gcc_cv_tool_prefix=$prefix | |
265 fi | |
266 else | |
267 gcc_cv_tool_prefix=$exec_prefix | |
268 fi | |
269 | |
270 # If there is no compiler in the tree, use the PATH only. In any | |
271 # case, if there is no compiler in the tree nobody should use | |
272 # AS_FOR_TARGET and LD_FOR_TARGET. | |
273 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then | |
111 | 274 if test x$with_gcc_major_version_only = xyes ; then |
275 changequote(,)dnl | |
276 gcc_version=`sed -e 's/^\([0-9]*\).*$/\1/' $srcdir/gcc/BASE-VER` | |
277 changequote([,])dnl | |
278 else | |
279 gcc_version=`cat $srcdir/gcc/BASE-VER` | |
280 fi | |
0 | 281 gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR" |
282 gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR" | |
283 gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR" | |
284 gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR" | |
285 gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR" | |
286 gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR" | |
287 else | |
288 gcc_cv_tool_dirs= | |
289 fi | |
290 | |
291 if test x$build = x$target && test -n "$md_exec_prefix"; then | |
292 gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR" | |
293 fi | |
294 | |
295 ]) []dnl # ACX_TOOL_DIRS | |
296 | |
297 # ACX_HAVE_GCC_FOR_TARGET | |
298 # Check if the variable GCC_FOR_TARGET really points to a GCC binary. | |
299 AC_DEFUN([ACX_HAVE_GCC_FOR_TARGET], [ | |
300 cat > conftest.c << \EOF | |
301 #ifdef __GNUC__ | |
302 gcc_yay; | |
303 #endif | |
304 EOF | |
305 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then | |
306 have_gcc_for_target=yes | |
307 else | |
308 GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc | |
309 have_gcc_for_target=no | |
310 fi | |
311 rm conftest.c | |
312 ]) | |
313 | |
314 # ACX_CHECK_INSTALLED_TARGET_TOOL(VAR, PROG) | |
315 # Searching for installed target binutils. We need to take extra care, | |
316 # else we may find the wrong assembler, linker, etc., and lose. | |
317 # | |
318 # First try --with-build-time-tools, if specified. | |
319 # | |
320 # For build != host, we ask the installed GCC for the name of the tool it | |
321 # uses, and accept it if it is an absolute path. This is because the | |
322 # only good choice for a compiler is the same GCC version that is being | |
323 # installed (or we couldn't make target libraries), and we assume that | |
324 # on the host system we'll have not only the same GCC version, but also | |
325 # the same binutils version. | |
326 # | |
327 # For build == host, search the same directories that the installed | |
328 # compiler will search. We used to do this for the assembler, linker, | |
329 # and nm only; for simplicity of configuration, however, we extend this | |
330 # criterion to tools (such as ar and ranlib) that are never invoked by | |
331 # the compiler, to avoid mismatches. | |
332 # | |
333 # Also note we have to check MD_EXEC_PREFIX before checking the user's path | |
334 # if build == target. This makes the most sense only when bootstrapping, | |
335 # but we also do so when build != host. In this case, we hope that the | |
336 # build and host systems will have similar contents of MD_EXEC_PREFIX. | |
337 # | |
338 # If we do not find a suitable binary, then try the user's path. | |
339 | |
340 AC_DEFUN([ACX_CHECK_INSTALLED_TARGET_TOOL], [ | |
341 AC_REQUIRE([ACX_TOOL_DIRS]) | |
342 AC_REQUIRE([ACX_HAVE_GCC_FOR_TARGET]) | |
343 if test -z "$ac_cv_path_$1" ; then | |
344 if test -n "$with_build_time_tools"; then | |
345 AC_MSG_CHECKING([for $2 in $with_build_time_tools]) | |
346 if test -x $with_build_time_tools/$2; then | |
347 $1=`cd $with_build_time_tools && pwd`/$2 | |
348 ac_cv_path_$1=[$]$1 | |
349 AC_MSG_RESULT([$ac_cv_path_$1]) | |
350 else | |
351 AC_MSG_RESULT(no) | |
352 fi | |
353 elif test $build != $host && test $have_gcc_for_target = yes; then | |
354 $1=`$GCC_FOR_TARGET --print-prog-name=$2` | |
355 test [$]$1 = $2 && $1= | |
356 test -n "[$]$1" && ac_cv_path_$1=[$]$1 | |
357 fi | |
358 fi | |
359 if test -z "$ac_cv_path_$1" && test -n "$gcc_cv_tool_dirs"; then | |
360 AC_PATH_PROG([$1], [$2], [], [$gcc_cv_tool_dirs]) | |
361 fi | |
362 if test -z "$ac_cv_path_$1" ; then | |
363 NCN_STRICT_CHECK_TARGET_TOOLS([$1], [$2]) | |
364 else | |
365 $1=$ac_cv_path_$1 | |
366 fi | |
367 ]) []dnl # ACX_CHECK_INSTALLED_TARGET_TOOL | |
368 | |
369 ### | |
370 # AC_PROG_CPP_WERROR | |
371 # Used for autoconf 2.5x to force AC_PREPROC_IFELSE to reject code which | |
372 # triggers warnings from the preprocessor. Will be in autoconf 2.58. | |
373 # For now, using this also overrides header checks to use only the | |
374 # preprocessor (matches 2.13 behavior; matching 2.58's behavior is a | |
375 # bit harder from here). | |
376 # Eventually autoconf will default to checking headers with the compiler | |
377 # instead, and we'll have to do this differently. | |
378 | |
379 AC_DEFUN([AC_PROG_CPP_WERROR], | |
380 [AC_REQUIRE([AC_PROG_CPP])dnl | |
381 m4_define([AC_CHECK_HEADER],m4_defn([_AC_CHECK_HEADER_OLD])) | |
382 ac_c_preproc_warn_flag=yes])# AC_PROG_CPP_WERROR | |
383 | |
384 # Test for GNAT. | |
111 | 385 # We require the gnatbind & gnatmake programs, as well as a compiler driver |
386 # that understands Ada. We use the user's CC setting, already found, and | |
387 # possibly add $1 to the command-line parameters. | |
0 | 388 # |
389 # Sets the shell variable have_gnat to yes or no as appropriate, and | |
390 # substitutes GNATBIND and GNATMAKE. | |
391 AC_DEFUN([ACX_PROG_GNAT], | |
392 [AC_REQUIRE([AC_CHECK_TOOL_PREFIX]) | |
393 AC_REQUIRE([AC_PROG_CC]) | |
394 AC_CHECK_TOOL(GNATBIND, gnatbind, no) | |
395 AC_CHECK_TOOL(GNATMAKE, gnatmake, no) | |
396 AC_CACHE_CHECK([whether compiler driver understands Ada], | |
397 acx_cv_cc_gcc_supports_ada, | |
398 [cat >conftest.adb <<EOF | |
399 procedure conftest is begin null; end conftest; | |
400 EOF | |
401 acx_cv_cc_gcc_supports_ada=no | |
402 # There is a bug in old released versions of GCC which causes the | |
403 # driver to exit successfully when the appropriate language module | |
404 # has not been installed. This is fixed in 2.95.4, 3.0.2, and 3.1. | |
405 # Therefore we must check for the error message as well as an | |
406 # unsuccessful exit. | |
407 # Other compilers, like HP Tru64 UNIX cc, exit successfully when | |
408 # given a .adb file, but produce no object file. So we must check | |
409 # if an object file was really produced to guard against this. | |
410 errors=`(${CC} $1[]m4_ifval([$1], [ ])-c conftest.adb) 2>&1 || echo failure` | |
411 if test x"$errors" = x && test -f conftest.$ac_objext; then | |
412 acx_cv_cc_gcc_supports_ada=yes | |
413 fi | |
414 rm -f conftest.*]) | |
415 | |
111 | 416 if test "x$GNATBIND" != xno && test "x$GNATMAKE" != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then |
0 | 417 have_gnat=yes |
418 else | |
419 have_gnat=no | |
420 fi | |
421 ]) | |
422 | |
423 dnl 'make compare' can be significantly faster, if cmp itself can | |
424 dnl skip bytes instead of using tail. The test being performed is | |
425 dnl "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2" | |
426 dnl but we need to sink errors and handle broken shells. We also test | |
427 dnl for the parameter format "cmp file1 file2 skip1 skip2" which is | |
428 dnl accepted by cmp on some systems. | |
429 AC_DEFUN([ACX_PROG_CMP_IGNORE_INITIAL], | |
430 [AC_CACHE_CHECK([how to compare bootstrapped objects], gcc_cv_prog_cmp_skip, | |
431 [ echo abfoo >t1 | |
432 echo cdfoo >t2 | |
111 | 433 gcc_cv_prog_cmp_skip='tail -c +17 $$f1 > tmp-foo1; tail -c +17 $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2' |
0 | 434 if cmp t1 t2 2 2 > /dev/null 2>&1; then |
435 if cmp t1 t2 1 1 > /dev/null 2>&1; then | |
436 : | |
437 else | |
438 gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16' | |
439 fi | |
440 fi | |
441 if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then | |
442 if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then | |
443 : | |
444 else | |
445 gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2' | |
446 fi | |
447 fi | |
448 rm t1 t2 | |
449 ]) | |
450 do_compare="$gcc_cv_prog_cmp_skip" | |
451 AC_SUBST(do_compare) | |
452 ]) | |
453 | |
454 dnl See whether we can include both string.h and strings.h. | |
455 AC_DEFUN([ACX_HEADER_STRING], | |
456 [AC_CACHE_CHECK([whether string.h and strings.h may both be included], | |
457 gcc_cv_header_string, | |
458 [AC_TRY_COMPILE([#include <string.h> | |
459 #include <strings.h>], , gcc_cv_header_string=yes, gcc_cv_header_string=no)]) | |
460 if test $gcc_cv_header_string = yes; then | |
461 AC_DEFINE(STRING_WITH_STRINGS, 1, [Define if you can safely include both <string.h> and <strings.h>.]) | |
462 fi | |
463 ]) | |
464 | |
465 dnl See if stdbool.h properly defines bool and true/false. | |
466 dnl Check whether _Bool is built-in. | |
467 AC_DEFUN([ACX_HEADER_STDBOOL], | |
468 [AC_CACHE_CHECK([for working stdbool.h], | |
469 ac_cv_header_stdbool_h, | |
470 [AC_TRY_COMPILE([#include <stdbool.h>], | |
471 [bool foo = false;], | |
472 ac_cv_header_stdbool_h=yes, ac_cv_header_stdbool_h=no)]) | |
473 if test $ac_cv_header_stdbool_h = yes; then | |
474 AC_DEFINE(HAVE_STDBOOL_H, 1, | |
475 [Define if you have a working <stdbool.h> header file.]) | |
476 fi | |
477 AC_CACHE_CHECK(for built-in _Bool, gcc_cv_c__bool, | |
478 [AC_TRY_COMPILE(, | |
479 [_Bool foo;], | |
480 gcc_cv_c__bool=yes, gcc_cv_c__bool=no) | |
481 ]) | |
482 if test $gcc_cv_c__bool = yes; then | |
483 AC_DEFINE(HAVE__BOOL, 1, [Define if the \`_Bool' type is built-in.]) | |
484 fi | |
485 ]) | |
486 | |
487 dnl See if hard links work and if not, try to substitute $1 or simple copy. | |
488 AC_DEFUN([ACX_PROG_LN], | |
489 [AC_MSG_CHECKING(whether ln works) | |
490 AC_CACHE_VAL(acx_cv_prog_LN, | |
491 [rm -f conftestdata_t | |
492 echo >conftestdata_f | |
493 if ln conftestdata_f conftestdata_t 2>/dev/null | |
494 then | |
495 acx_cv_prog_LN=ln | |
496 else | |
497 acx_cv_prog_LN=no | |
498 fi | |
499 rm -f conftestdata_f conftestdata_t | |
500 ])dnl | |
501 if test $acx_cv_prog_LN = no; then | |
502 LN="ifelse([$1],,cp,[$1])" | |
503 AC_MSG_RESULT([no, using $LN]) | |
504 else | |
505 LN="$acx_cv_prog_LN" | |
506 AC_MSG_RESULT(yes) | |
507 fi | |
508 AC_SUBST(LN)dnl | |
509 ]) | |
510 | |
511 dnl GCC_TARGET_TOOL(PROGRAM, TARGET-VAR, HOST-VAR, IN-TREE-TOOL, LANGUAGE) | |
512 AC_DEFUN([GCC_TARGET_TOOL], | |
513 [AC_MSG_CHECKING(where to find the target $1) | |
514 if test "x${build}" != "x${host}" ; then | |
515 if expr "x[$]$2" : "x/" > /dev/null; then | |
516 # We already found the complete path | |
517 ac_dir=`dirname [$]$2` | |
518 AC_MSG_RESULT(pre-installed in $ac_dir) | |
519 else | |
520 # Canadian cross, just use what we found | |
521 AC_MSG_RESULT(pre-installed) | |
522 fi | |
523 else | |
524 ifelse([$4],,, | |
525 [ok=yes | |
526 case " ${configdirs} " in | |
527 *" patsubst([$4], [/.*], []) "*) ;; | |
528 *) ok=no ;; | |
529 esac | |
530 ifelse([$5],,, | |
531 [case ,${enable_languages}, in | |
532 *,$5,*) ;; | |
533 *) ok=no ;; | |
534 esac]) | |
535 if test $ok = yes; then | |
536 # An in-tree tool is available and we can use it | |
537 $2='$$r/$(HOST_SUBDIR)/$4' | |
538 AC_MSG_RESULT(just compiled) | |
539 el])if expr "x[$]$2" : "x/" > /dev/null; then | |
540 # We already found the complete path | |
541 ac_dir=`dirname [$]$2` | |
542 AC_MSG_RESULT(pre-installed in $ac_dir) | |
543 elif test "x$target" = "x$host"; then | |
544 # We can use an host tool | |
545 $2='$($3)' | |
546 AC_MSG_RESULT(host tool) | |
547 else | |
548 # We need a cross tool | |
549 AC_MSG_RESULT(pre-installed) | |
550 fi | |
551 fi | |
552 AC_SUBST($2)]) | |
553 | |
554 | |
555 dnl Locate a program and check that its version is acceptable. | |
556 dnl ACX_PROG_CHECK_VER(var, name, version-switch, | |
557 dnl version-extract-regexp, version-glob) | |
558 AC_DEFUN([ACX_CHECK_PROG_VER],[ | |
559 AC_CHECK_PROG([$1], [$2], [$2]) | |
560 if test -n "[$]$1"; then | |
561 # Found it, now check the version. | |
562 AC_CACHE_CHECK([for modern $2], | |
563 [gcc_cv_prog_$2_modern], | |
564 [ac_prog_version=`eval [$]$1 $3 2>&1 | | |
565 sed -n 's/^.*patsubst([[$4]],/,\/).*$/\1/p'` | |
566 | |
567 [case $ac_prog_version in | |
568 '') gcc_cv_prog_$2_modern=no;; | |
569 $5) gcc_cv_prog_$2_modern=yes;; | |
570 *) gcc_cv_prog_$2_modern=no;; | |
571 esac] | |
572 ]) | |
573 else | |
574 gcc_cv_prog_$2_modern=no | |
575 fi | |
576 if test $gcc_cv_prog_$2_modern = no; then | |
577 $1="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing $2" | |
578 fi | |
579 ]) | |
580 | |
581 dnl Support the --with-pkgversion configure option. | |
582 dnl ACX_PKGVERSION(default-pkgversion) | |
583 AC_DEFUN([ACX_PKGVERSION],[ | |
584 AC_ARG_WITH(pkgversion, | |
585 AS_HELP_STRING([--with-pkgversion=PKG], | |
586 [Use PKG in the version string in place of "$1"]), | |
587 [case "$withval" in | |
588 yes) AC_MSG_ERROR([package version not specified]) ;; | |
589 no) PKGVERSION= ;; | |
590 *) PKGVERSION="($withval) " ;; | |
591 esac], | |
592 PKGVERSION="($1) " | |
593 ) | |
594 AC_SUBST(PKGVERSION) | |
595 ]) | |
596 | |
597 dnl Support the --with-bugurl configure option. | |
598 dnl ACX_BUGURL(default-bugurl) | |
599 AC_DEFUN([ACX_BUGURL],[ | |
600 AC_ARG_WITH(bugurl, | |
601 AS_HELP_STRING([--with-bugurl=URL], | |
602 [Direct users to URL to report a bug]), | |
603 [case "$withval" in | |
604 yes) AC_MSG_ERROR([bug URL not specified]) ;; | |
605 no) BUGURL= | |
606 ;; | |
607 *) BUGURL="$withval" | |
608 ;; | |
609 esac], | |
610 BUGURL="$1" | |
611 ) | |
612 case ${BUGURL} in | |
613 "") | |
614 REPORT_BUGS_TO= | |
615 REPORT_BUGS_TEXI= | |
616 ;; | |
617 *) | |
618 REPORT_BUGS_TO="<$BUGURL>" | |
619 REPORT_BUGS_TEXI=@uref{`echo "$BUGURL" | sed 's/@/@@/g'`} | |
620 ;; | |
621 esac; | |
622 AC_SUBST(REPORT_BUGS_TO) | |
623 AC_SUBST(REPORT_BUGS_TEXI) | |
624 ]) | |
625 | |
626 dnl #### | |
627 dnl # ACX_CHECK_CYGWIN_CAT_WORKS | |
628 dnl # On Cygwin hosts, check that the cat command ignores | |
629 dnl # carriage returns as otherwise builds will not work. | |
630 dnl # See binutils PR 4334 for more details. | |
631 AC_DEFUN([ACX_CHECK_CYGWIN_CAT_WORKS],[ | |
632 AC_MSG_CHECKING([to see if cat works as expected]) | |
633 echo a >cygwin-cat-check | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
634 if test `cat cygwin-cat-check` = a ; then |
0 | 635 rm cygwin-cat-check |
636 AC_MSG_RESULT(yes) | |
637 else | |
638 rm cygwin-cat-check | |
639 AC_MSG_RESULT(no) | |
640 AC_MSG_ERROR([The cat command does not ignore carriage return characters. | |
641 Please either mount the build directory in binary mode or run the following | |
642 commands before running any configure script: | |
643 set -o igncr | |
644 export SHELLOPTS | |
645 ]) | |
646 fi | |
647 ]) |