Commit | Line | Data |
---|---|---|
5212e868 NN |
1 | # Autoconf M4 include file defining utility macros for complex Canadian |
2 | # cross builds. | |
3 | ||
dd12c3a8 NN |
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 | ||
118c4fba NN |
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 | ||
dd12c3a8 NN |
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 | # Prefix 'build-' so this never conflicts with target_subdir. | |
78 | build_subdir="build-${build_noncanonical}" | |
b00612cc PB |
79 | # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories |
80 | if ( test $srcdir = . && test -d gcc ) \ | |
81 | || test -d $srcdir/../host-${host_noncanonical}; then | |
82 | host_subdir="host-${host_noncanonical}" | |
83 | else | |
84 | host_subdir=. | |
85 | fi | |
dd12c3a8 NN |
86 | # No prefix. |
87 | target_subdir=${target_noncanonical} | |
88 | AC_SUBST([build_subdir]) []dnl | |
89 | AC_SUBST([host_subdir]) []dnl | |
90 | AC_SUBST([target_subdir]) []dnl | |
91 | ]) []dnl # GCC_TOPLEV_SUBDIRS | |
92 | ||
93 | ||
5212e868 NN |
94 | #### |
95 | # _NCN_TOOL_PREFIXES: Some stuff that oughtta be done in AC_CANONICAL_SYSTEM | |
96 | # or AC_INIT. | |
97 | # These demand that AC_CANONICAL_SYSTEM be called beforehand. | |
98 | AC_DEFUN([_NCN_TOOL_PREFIXES], | |
99 | [ncn_tool_prefix= | |
100 | test -n "$host_alias" && ncn_tool_prefix=$host_alias- | |
101 | ncn_target_tool_prefix= | |
102 | test -n "$target_alias" && ncn_target_tool_prefix=$target_alias- | |
103 | ]) []dnl # _NCN_TOOL_PREFIXES | |
104 | ||
105 | #### | |
05cbd757 | 106 | # NCN_STRICT_CHECK_TOOLS(variable, progs-to-check-for,[value-if-not-found],[path]) |
2429c060 | 107 | # Like plain AC_CHECK_TOOLS, but require prefix if build!=host. |
5212e868 | 108 | |
05cbd757 | 109 | AC_DEFUN([NCN_STRICT_CHECK_TOOLS], |
5212e868 | 110 | [AC_REQUIRE([_NCN_TOOL_PREFIXES]) []dnl |
05cbd757 PB |
111 | for ncn_progname in $2; do |
112 | if test -n "$ncn_tool_prefix"; then | |
113 | AC_CHECK_PROG([$1], [${ncn_tool_prefix}${ncn_progname}], | |
114 | [${ncn_tool_prefix}${ncn_progname}], , [$4]) | |
115 | fi | |
116 | if test -z "$ac_cv_prog_$1" && test $build = $host ; then | |
117 | AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4]) | |
118 | fi | |
119 | test -n "$ac_cv_prog_$1" && break | |
120 | done | |
5212e868 | 121 | |
5212e868 | 122 | if test -z "$ac_cv_prog_$1" ; then |
05cbd757 | 123 | ifelse([$3],[], [set dummy $2 |
5212e868 | 124 | if test $build = $host ; then |
05cbd757 | 125 | $1="[$]2" |
5212e868 | 126 | else |
05cbd757 PB |
127 | $1="${ncn_tool_prefix}[$]2" |
128 | fi], [$1="$3"]) | |
5212e868 | 129 | fi |
05cbd757 | 130 | ]) []dnl # NCN_STRICT_CHECK_TOOLS |
5212e868 NN |
131 | |
132 | #### | |
05cbd757 PB |
133 | # NCN_STRICT_CHECK_TARGET_TOOLS(variable, progs-to-check-for,[value-if-not-found],[path]) |
134 | # Like CVS Autoconf AC_CHECK_TARGET_TOOLS, but require prefix if build!=target. | |
5212e868 | 135 | |
05cbd757 | 136 | AC_DEFUN([NCN_STRICT_CHECK_TARGET_TOOLS], |
5212e868 | 137 | [AC_REQUIRE([_NCN_TOOL_PREFIXES]) []dnl |
2429c060 PB |
138 | if test -n "$with_build_time_tools"; then |
139 | for ncn_progname in $2; do | |
140 | AC_MSG_CHECKING([for ${ncn_progname} in $with_build_time_tools]) | |
141 | if test -x $with_build_time_tools/$1; then | |
142 | ac_cv_prog_$1=$with_build_time_tools/$1 | |
143 | AC_MSG_RESULT(yes) | |
144 | break | |
145 | else | |
146 | AC_MSG_RESULT(no) | |
147 | fi | |
148 | done | |
149 | fi | |
05cbd757 | 150 | |
2429c060 PB |
151 | if test -z "$ac_cv_prog_$1"; then |
152 | for ncn_progname in $2; do | |
153 | if test -n "$ncn_target_tool_prefix"; then | |
154 | AC_CHECK_PROG([$1], [${ncn_target_tool_prefix}${ncn_progname}], | |
155 | [${ncn_target_tool_prefix}${ncn_progname}], , [$4]) | |
156 | fi | |
157 | if test -z "$ac_cv_prog_$1" && test $build = $target ; then | |
158 | AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4]) | |
159 | fi | |
160 | test -n "$ac_cv_prog_$1" && break | |
161 | done | |
162 | fi | |
163 | ||
5212e868 | 164 | if test -z "$ac_cv_prog_$1" ; then |
05cbd757 | 165 | ifelse([$3],[], [set dummy $2 |
5212e868 | 166 | if test $build = $target ; then |
05cbd757 | 167 | $1="[$]2" |
5212e868 | 168 | else |
05cbd757 PB |
169 | $1="${ncn_target_tool_prefix}[$]2" |
170 | fi], [$1="$3"]) | |
5212e868 | 171 | fi |
05cbd757 | 172 | ]) []dnl # NCN_STRICT_CHECK_TARGET_TOOLS |
2429c060 PB |
173 | |
174 | ||
175 | # Backported from Autoconf 2.5x; can go away when and if | |
176 | # we switch. Put the OS path separator in $PATH_SEPARATOR. | |
177 | AC_DEFUN([ACX_PATH_SEP], [ | |
178 | # The user is always right. | |
179 | if test "${PATH_SEPARATOR+set}" != set; then | |
180 | echo "#! /bin/sh" >conf$$.sh | |
181 | echo "exit 0" >>conf$$.sh | |
182 | chmod +x conf$$.sh | |
183 | if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then | |
184 | PATH_SEPARATOR=';' | |
185 | else | |
186 | PATH_SEPARATOR=: | |
187 | fi | |
188 | rm -f conf$$.sh | |
189 | fi | |
190 | ]) | |
191 | ||
192 | ||
193 | AC_DEFUN([ACX_TOOL_DIRS], [ | |
194 | AC_REQUIRE([ACX_PATH_SEP]) | |
195 | if test "x$exec_prefix" = xNONE; then | |
196 | if test "x$prefix" = xNONE; then | |
197 | gcc_cv_tool_prefix=$ac_default_prefix | |
198 | else | |
199 | gcc_cv_tool_prefix=$prefix | |
200 | fi | |
201 | else | |
202 | gcc_cv_tool_prefix=$exec_prefix | |
203 | fi | |
204 | ||
205 | # If there is no compiler in the tree, use the PATH only. In any | |
206 | # case, if there is no compiler in the tree nobody should use | |
207 | # AS_FOR_TARGET and LD_FOR_TARGET. | |
208 | if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then | |
209 | gcc_version=`cat $srcdir/gcc/BASE-VER` | |
210 | gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR" | |
211 | gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR" | |
212 | gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR" | |
213 | gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR" | |
214 | gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR" | |
215 | gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR" | |
216 | else | |
217 | gcc_cv_tool_dirs= | |
218 | fi | |
219 | ||
220 | if test x$build = x$target && test -n "$md_exec_prefix"; then | |
221 | gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR" | |
222 | fi | |
223 | ||
224 | ]) []dnl # ACX_TOOL_DIRS | |
225 | ||
226 | # ACX_HAVE_GCC_FOR_TARGET | |
227 | # Check if the variable GCC_FOR_TARGET really points to a GCC binary. | |
228 | AC_DEFUN([ACX_HAVE_GCC_FOR_TARGET], [ | |
229 | cat > conftest.c << \EOF | |
230 | #ifdef __GNUC__ | |
231 | gcc_yay; | |
232 | #endif | |
233 | EOF | |
234 | if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then | |
235 | have_gcc_for_target=yes | |
236 | else | |
237 | GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc | |
238 | have_gcc_for_target=no | |
239 | fi | |
240 | rm conftest.c | |
241 | ]) | |
242 | ||
243 | # ACX_CHECK_INSTALLED_TARGET_TOOL(VAR, PROG) | |
244 | # Searching for installed target binutils. We need to take extra care, | |
245 | # else we may find the wrong assembler, linker, etc., and lose. | |
246 | # | |
247 | # First try --with-build-time-tools, if specified. | |
248 | # | |
249 | # For build != host, we ask the installed GCC for the name of the tool it | |
250 | # uses, and accept it if it is an absolute path. This is because the | |
251 | # only good choice for a compiler is the same GCC version that is being | |
252 | # installed (or we couldn't make target libraries), and we assume that | |
253 | # on the host system we'll have not only the same GCC version, but also | |
254 | # the same binutils version. | |
255 | # | |
256 | # For build == host, search the same directories that the installed | |
257 | # compiler will search. We used to do this for the assembler, linker, | |
258 | # and nm only; for simplicity of configuration, however, we extend this | |
259 | # criterion to tools (such as ar and ranlib) that are never invoked by | |
260 | # the compiler, to avoid mismatches. | |
261 | # | |
262 | # Also note we have to check MD_EXEC_PREFIX before checking the user's path | |
263 | # if build == target. This makes the most sense only when bootstrapping, | |
264 | # but we also do so when build != host. In this case, we hope that the | |
265 | # build and host systems will have similar contents of MD_EXEC_PREFIX. | |
266 | # | |
267 | # If we do not find a suitable binary, then try the user's path. | |
268 | ||
269 | AC_DEFUN([ACX_CHECK_INSTALLED_TARGET_TOOL], [ | |
270 | AC_REQUIRE([ACX_TOOL_DIRS]) | |
271 | AC_REQUIRE([ACX_HAVE_GCC_FOR_TARGET]) | |
272 | if test -z "$ac_cv_path_$1" ; then | |
273 | if test -n "$with_build_time_tools"; then | |
274 | AC_MSG_CHECKING([for ${ncn_target_tool_prefix}${ncn_progname} in $with_build_time_tools]) | |
275 | $1=`cd $with_build_time_tools && pwd`/$1 | |
276 | ac_cv_path_$1=[$]$1 | |
277 | AC_MSG_RESULT([$ac_cv_path_$1]) | |
278 | elif test $build != $host && test $have_gcc_for_target = yes; then | |
279 | $1=`$GCC_FOR_TARGET --print-prog-name=$2` | |
280 | test [$]$1=$2 && $1= | |
281 | ac_cv_path_$1=[$]$1 | |
282 | fi | |
283 | fi | |
284 | if test -z "$ac_cv_path_$1" ; then | |
285 | AC_PATH_PROG([$1], [$2], [], [$gcc_cv_tool_dirs]) | |
286 | fi | |
287 | if test -z "$ac_cv_path_$1" ; then | |
288 | NCN_STRICT_CHECK_TARGET_TOOLS([$1], [$2]) | |
289 | fi | |
290 | ]) []dnl # ACX_CHECK_INSTALLED_TARGET_TOOL | |
394559cb DJ |
291 | |
292 | ### | |
293 | # AC_PROG_CPP_WERROR | |
294 | # Used for autoconf 2.5x to force AC_PREPROC_IFELSE to reject code which | |
295 | # triggers warnings from the preprocessor. Will be in autoconf 2.58. | |
296 | # For now, using this also overrides header checks to use only the | |
297 | # preprocessor (matches 2.13 behavior; matching 2.58's behavior is a | |
298 | # bit harder from here). | |
299 | # Eventually autoconf will default to checking headers with the compiler | |
300 | # instead, and we'll have to do this differently. | |
301 | ||
302 | AC_DEFUN([AC_PROG_CPP_WERROR], | |
303 | [AC_REQUIRE([AC_PROG_CPP])dnl | |
304 | m4_define([AC_CHECK_HEADER],m4_defn([_AC_CHECK_HEADER_OLD])) | |
305 | ac_c_preproc_warn_flag=yes])# AC_PROG_CPP_WERROR | |
9e07f89d NN |
306 | |
307 | # Test for GNAT. | |
308 | # We require the gnatbind program, and a compiler driver that | |
309 | # understands Ada. We use the user's CC setting, already found. | |
310 | # | |
311 | # Sets the shell variable have_gnat to yes or no as appropriate, and | |
312 | # substitutes GNATBIND. | |
313 | AC_DEFUN([ACX_PROG_GNAT], | |
314 | [AC_REQUIRE([AC_CHECK_TOOL_PREFIX]) | |
315 | AC_REQUIRE([AC_PROG_CC]) | |
316 | AC_CHECK_TOOL(GNATBIND, gnatbind, no) | |
317 | AC_CACHE_CHECK([whether compiler driver understands Ada], | |
318 | acx_cv_cc_gcc_supports_ada, | |
319 | [cat >conftest.adb <<EOF | |
320 | procedure conftest is begin null; end conftest; | |
321 | EOF | |
322 | acx_cv_cc_gcc_supports_ada=no | |
323 | # There is a bug in old released versions of GCC which causes the | |
324 | # driver to exit successfully when the appropriate language module | |
325 | # has not been installed. This is fixed in 2.95.4, 3.0.2, and 3.1. | |
326 | # Therefore we must check for the error message as well as an | |
327 | # unsuccessful exit. | |
b8908782 DD |
328 | # Other compilers, like HP Tru64 UNIX cc, exit successfully when |
329 | # given a .adb file, but produce no object file. So we must check | |
330 | # if an object file was really produced to guard against this. | |
9e07f89d | 331 | errors=`(${CC} -c conftest.adb) 2>&1 || echo failure` |
b8908782 | 332 | if test x"$errors" = x && test -f conftest.$ac_objext; then |
9e07f89d | 333 | acx_cv_cc_gcc_supports_ada=yes |
9e07f89d NN |
334 | fi |
335 | rm -f conftest.*]) | |
336 | ||
b8908782 | 337 | if test x$GNATBIND != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then |
9e07f89d NN |
338 | have_gnat=yes |
339 | else | |
340 | have_gnat=no | |
341 | fi | |
342 | ]) | |
4b1cb4fe DD |
343 | |
344 | dnl 'make compare' can be significantly faster, if cmp itself can | |
345 | dnl skip bytes instead of using tail. The test being performed is | |
346 | dnl "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2" | |
347 | dnl but we need to sink errors and handle broken shells. We also test | |
348 | dnl for the parameter format "cmp file1 file2 skip1 skip2" which is | |
349 | dnl accepted by cmp on some systems. | |
350 | AC_DEFUN([ACX_PROG_CMP_IGNORE_INITIAL], | |
351 | [AC_CACHE_CHECK([how to compare bootstrapped objects], gcc_cv_prog_cmp_skip, | |
352 | [ echo abfoo >t1 | |
353 | echo cdfoo >t2 | |
354 | gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2' | |
355 | if cmp t1 t2 2 2 > /dev/null 2>&1; then | |
356 | if cmp t1 t2 1 1 > /dev/null 2>&1; then | |
357 | : | |
358 | else | |
359 | gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16' | |
360 | fi | |
361 | fi | |
362 | if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then | |
363 | if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then | |
364 | : | |
365 | else | |
366 | gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2' | |
367 | fi | |
368 | fi | |
369 | rm t1 t2 | |
370 | ]) | |
371 | do_compare="$gcc_cv_prog_cmp_skip" | |
372 | AC_SUBST(do_compare) | |
373 | ]) | |
04cf1b77 PB |
374 | |
375 | dnl See whether we can include both string.h and strings.h. | |
376 | AC_DEFUN([ACX_HEADER_STRING], | |
377 | [AC_CACHE_CHECK([whether string.h and strings.h may both be included], | |
378 | gcc_cv_header_string, | |
379 | [AC_TRY_COMPILE([#include <string.h> | |
380 | #include <strings.h>], , gcc_cv_header_string=yes, gcc_cv_header_string=no)]) | |
381 | if test $gcc_cv_header_string = yes; then | |
382 | AC_DEFINE(STRING_WITH_STRINGS, 1, [Define if you can safely include both <string.h> and <strings.h>.]) | |
383 | fi | |
384 | ]) | |
385 | ||
386 | dnl See if stdbool.h properly defines bool and true/false. | |
387 | dnl Check whether _Bool is built-in. | |
388 | AC_DEFUN([ACX_HEADER_STDBOOL], | |
389 | [AC_CACHE_CHECK([for working stdbool.h], | |
390 | ac_cv_header_stdbool_h, | |
391 | [AC_TRY_COMPILE([#include <stdbool.h>], | |
392 | [bool foo = false;], | |
393 | ac_cv_header_stdbool_h=yes, ac_cv_header_stdbool_h=no)]) | |
394 | if test $ac_cv_header_stdbool_h = yes; then | |
395 | AC_DEFINE(HAVE_STDBOOL_H, 1, | |
396 | [Define if you have a working <stdbool.h> header file.]) | |
397 | fi | |
398 | AC_CACHE_CHECK(for built-in _Bool, gcc_cv_c__bool, | |
399 | [AC_TRY_COMPILE(, | |
400 | [_Bool foo;], | |
401 | gcc_cv_c__bool=yes, gcc_cv_c__bool=no) | |
402 | ]) | |
403 | if test $gcc_cv_c__bool = yes; then | |
404 | AC_DEFINE(HAVE__BOOL, 1, [Define if the \`_Bool' type is built-in.]) | |
405 | fi | |
406 | ]) | |
407 | ||
656fdd47 PB |
408 | dnl See if hard links work and if not, try to substitute $1 or simple copy. |
409 | AC_DEFUN([ACX_PROG_LN], | |
410 | [AC_MSG_CHECKING(whether ln works) | |
411 | AC_CACHE_VAL(acx_cv_prog_LN, | |
412 | [rm -f conftestdata_t | |
413 | echo >conftestdata_f | |
414 | if ln conftestdata_f conftestdata_t 2>/dev/null | |
415 | then | |
416 | acx_cv_prog_LN=ln | |
417 | else | |
418 | acx_cv_prog_LN=no | |
419 | fi | |
420 | rm -f conftestdata_f conftestdata_t | |
421 | ])dnl | |
422 | if test $acx_cv_prog_LN = no; then | |
423 | LN="ifelse([$1],,cp,[$1])" | |
424 | AC_MSG_RESULT([no, using $LN]) | |
425 | else | |
426 | LN="$acx_cv_prog_LN" | |
427 | AC_MSG_RESULT(yes) | |
428 | fi | |
429 | AC_SUBST(LN)dnl | |
430 | ]) | |
431 | ||
be01d343 PB |
432 | dnl GCC_TARGET_TOOL(PROGRAM, TARGET-VAR, HOST-VAR, IN-TREE-TOOL, LANGUAGE) |
433 | AC_DEFUN([GCC_TARGET_TOOL], | |
434 | [AC_MSG_CHECKING(where to find the target $1) | |
435 | if test "x${build}" != "x${host}" ; then | |
2429c060 PB |
436 | if expr "x[$]$2" : "x/" > /dev/null; then |
437 | # We already found the complete path | |
438 | AC_MSG_RESULT(pre-installed in `dirname [$]$2`) | |
439 | else | |
440 | # Canadian cross, just use what we found | |
441 | AC_MSG_RESULT(pre-installed) | |
442 | fi | |
be01d343 PB |
443 | else |
444 | ifelse([$4],,, | |
445 | [ok=yes | |
446 | case " ${configdirs} " in | |
447 | *" patsubst([$4], [/.*], []) "*) ;; | |
448 | *) ok=no ;; | |
449 | esac | |
450 | ifelse([$5],,, | |
451 | [case ,${enable_languages}, in | |
452 | *,$5,*) ;; | |
453 | *) ok=no ;; | |
454 | esac]) | |
455 | if test $ok = yes; then | |
456 | # An in-tree tool is available and we can use it | |
457 | $2='$$r/$(HOST_SUBDIR)/$4' | |
458 | AC_MSG_RESULT(just compiled) | |
2429c060 PB |
459 | el])if expr "x[$]$2" : "x/" > /dev/null; then |
460 | # We already found the complete path | |
461 | AC_MSG_RESULT(pre-installed in `dirname [$]$2`) | |
462 | elif test "x$target" = "x$host"; then | |
be01d343 PB |
463 | # We can use an host tool |
464 | $2='$($3)' | |
465 | AC_MSG_RESULT(host tool) | |
466 | else | |
467 | # We need a cross tool | |
468 | AC_MSG_RESULT(pre-installed) | |
469 | fi | |
470 | fi]) |