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
|
|
238 AC_DEFUN([ACX_TOOL_DIRS], [
|
|
239 AC_REQUIRE([ACX_PATH_SEP])
|
|
240 if test "x$exec_prefix" = xNONE; then
|
|
241 if test "x$prefix" = xNONE; then
|
|
242 gcc_cv_tool_prefix=$ac_default_prefix
|
|
243 else
|
|
244 gcc_cv_tool_prefix=$prefix
|
|
245 fi
|
|
246 else
|
|
247 gcc_cv_tool_prefix=$exec_prefix
|
|
248 fi
|
|
249
|
|
250 # If there is no compiler in the tree, use the PATH only. In any
|
|
251 # case, if there is no compiler in the tree nobody should use
|
|
252 # AS_FOR_TARGET and LD_FOR_TARGET.
|
|
253 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
|
|
254 gcc_version=`cat $srcdir/gcc/BASE-VER`
|
|
255 gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
|
|
256 gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
|
|
257 gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
|
|
258 gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
|
|
259 gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
|
|
260 gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
|
|
261 else
|
|
262 gcc_cv_tool_dirs=
|
|
263 fi
|
|
264
|
|
265 if test x$build = x$target && test -n "$md_exec_prefix"; then
|
|
266 gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
|
|
267 fi
|
|
268
|
|
269 ]) []dnl # ACX_TOOL_DIRS
|
|
270
|
|
271 # ACX_HAVE_GCC_FOR_TARGET
|
|
272 # Check if the variable GCC_FOR_TARGET really points to a GCC binary.
|
|
273 AC_DEFUN([ACX_HAVE_GCC_FOR_TARGET], [
|
|
274 cat > conftest.c << \EOF
|
|
275 #ifdef __GNUC__
|
|
276 gcc_yay;
|
|
277 #endif
|
|
278 EOF
|
|
279 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
|
|
280 have_gcc_for_target=yes
|
|
281 else
|
|
282 GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
|
|
283 have_gcc_for_target=no
|
|
284 fi
|
|
285 rm conftest.c
|
|
286 ])
|
|
287
|
|
288 # ACX_CHECK_INSTALLED_TARGET_TOOL(VAR, PROG)
|
|
289 # Searching for installed target binutils. We need to take extra care,
|
|
290 # else we may find the wrong assembler, linker, etc., and lose.
|
|
291 #
|
|
292 # First try --with-build-time-tools, if specified.
|
|
293 #
|
|
294 # For build != host, we ask the installed GCC for the name of the tool it
|
|
295 # uses, and accept it if it is an absolute path. This is because the
|
|
296 # only good choice for a compiler is the same GCC version that is being
|
|
297 # installed (or we couldn't make target libraries), and we assume that
|
|
298 # on the host system we'll have not only the same GCC version, but also
|
|
299 # the same binutils version.
|
|
300 #
|
|
301 # For build == host, search the same directories that the installed
|
|
302 # compiler will search. We used to do this for the assembler, linker,
|
|
303 # and nm only; for simplicity of configuration, however, we extend this
|
|
304 # criterion to tools (such as ar and ranlib) that are never invoked by
|
|
305 # the compiler, to avoid mismatches.
|
|
306 #
|
|
307 # Also note we have to check MD_EXEC_PREFIX before checking the user's path
|
|
308 # if build == target. This makes the most sense only when bootstrapping,
|
|
309 # but we also do so when build != host. In this case, we hope that the
|
|
310 # build and host systems will have similar contents of MD_EXEC_PREFIX.
|
|
311 #
|
|
312 # If we do not find a suitable binary, then try the user's path.
|
|
313
|
|
314 AC_DEFUN([ACX_CHECK_INSTALLED_TARGET_TOOL], [
|
|
315 AC_REQUIRE([ACX_TOOL_DIRS])
|
|
316 AC_REQUIRE([ACX_HAVE_GCC_FOR_TARGET])
|
|
317 if test -z "$ac_cv_path_$1" ; then
|
|
318 if test -n "$with_build_time_tools"; then
|
|
319 AC_MSG_CHECKING([for $2 in $with_build_time_tools])
|
|
320 if test -x $with_build_time_tools/$2; then
|
|
321 $1=`cd $with_build_time_tools && pwd`/$2
|
|
322 ac_cv_path_$1=[$]$1
|
|
323 AC_MSG_RESULT([$ac_cv_path_$1])
|
|
324 else
|
|
325 AC_MSG_RESULT(no)
|
|
326 fi
|
|
327 elif test $build != $host && test $have_gcc_for_target = yes; then
|
|
328 $1=`$GCC_FOR_TARGET --print-prog-name=$2`
|
|
329 test [$]$1 = $2 && $1=
|
|
330 test -n "[$]$1" && ac_cv_path_$1=[$]$1
|
|
331 fi
|
|
332 fi
|
|
333 if test -z "$ac_cv_path_$1" && test -n "$gcc_cv_tool_dirs"; then
|
|
334 AC_PATH_PROG([$1], [$2], [], [$gcc_cv_tool_dirs])
|
|
335 fi
|
|
336 if test -z "$ac_cv_path_$1" ; then
|
|
337 NCN_STRICT_CHECK_TARGET_TOOLS([$1], [$2])
|
|
338 else
|
|
339 $1=$ac_cv_path_$1
|
|
340 fi
|
|
341 ]) []dnl # ACX_CHECK_INSTALLED_TARGET_TOOL
|
|
342
|
|
343 ###
|
|
344 # AC_PROG_CPP_WERROR
|
|
345 # Used for autoconf 2.5x to force AC_PREPROC_IFELSE to reject code which
|
|
346 # triggers warnings from the preprocessor. Will be in autoconf 2.58.
|
|
347 # For now, using this also overrides header checks to use only the
|
|
348 # preprocessor (matches 2.13 behavior; matching 2.58's behavior is a
|
|
349 # bit harder from here).
|
|
350 # Eventually autoconf will default to checking headers with the compiler
|
|
351 # instead, and we'll have to do this differently.
|
|
352
|
|
353 AC_DEFUN([AC_PROG_CPP_WERROR],
|
|
354 [AC_REQUIRE([AC_PROG_CPP])dnl
|
|
355 m4_define([AC_CHECK_HEADER],m4_defn([_AC_CHECK_HEADER_OLD]))
|
|
356 ac_c_preproc_warn_flag=yes])# AC_PROG_CPP_WERROR
|
|
357
|
|
358 # Test for GNAT.
|
|
359 # We require the gnatbind program, and a compiler driver that
|
|
360 # understands Ada. We use the user's CC setting, already found,
|
|
361 # and possibly add $1 to the command-line parameters.
|
|
362 #
|
|
363 # Sets the shell variable have_gnat to yes or no as appropriate, and
|
|
364 # substitutes GNATBIND and GNATMAKE.
|
|
365 AC_DEFUN([ACX_PROG_GNAT],
|
|
366 [AC_REQUIRE([AC_CHECK_TOOL_PREFIX])
|
|
367 AC_REQUIRE([AC_PROG_CC])
|
|
368 AC_CHECK_TOOL(GNATBIND, gnatbind, no)
|
|
369 AC_CHECK_TOOL(GNATMAKE, gnatmake, no)
|
|
370 AC_CACHE_CHECK([whether compiler driver understands Ada],
|
|
371 acx_cv_cc_gcc_supports_ada,
|
|
372 [cat >conftest.adb <<EOF
|
|
373 procedure conftest is begin null; end conftest;
|
|
374 EOF
|
|
375 acx_cv_cc_gcc_supports_ada=no
|
|
376 # There is a bug in old released versions of GCC which causes the
|
|
377 # driver to exit successfully when the appropriate language module
|
|
378 # has not been installed. This is fixed in 2.95.4, 3.0.2, and 3.1.
|
|
379 # Therefore we must check for the error message as well as an
|
|
380 # unsuccessful exit.
|
|
381 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
|
|
382 # given a .adb file, but produce no object file. So we must check
|
|
383 # if an object file was really produced to guard against this.
|
|
384 errors=`(${CC} $1[]m4_ifval([$1], [ ])-c conftest.adb) 2>&1 || echo failure`
|
|
385 if test x"$errors" = x && test -f conftest.$ac_objext; then
|
|
386 acx_cv_cc_gcc_supports_ada=yes
|
|
387 fi
|
|
388 rm -f conftest.*])
|
|
389
|
|
390 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
|
|
391 have_gnat=yes
|
|
392 else
|
|
393 have_gnat=no
|
|
394 fi
|
|
395 ])
|
|
396
|
|
397 dnl 'make compare' can be significantly faster, if cmp itself can
|
|
398 dnl skip bytes instead of using tail. The test being performed is
|
|
399 dnl "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2"
|
|
400 dnl but we need to sink errors and handle broken shells. We also test
|
|
401 dnl for the parameter format "cmp file1 file2 skip1 skip2" which is
|
|
402 dnl accepted by cmp on some systems.
|
|
403 AC_DEFUN([ACX_PROG_CMP_IGNORE_INITIAL],
|
|
404 [AC_CACHE_CHECK([how to compare bootstrapped objects], gcc_cv_prog_cmp_skip,
|
|
405 [ echo abfoo >t1
|
|
406 echo cdfoo >t2
|
|
407 gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
|
|
408 if cmp t1 t2 2 2 > /dev/null 2>&1; then
|
|
409 if cmp t1 t2 1 1 > /dev/null 2>&1; then
|
|
410 :
|
|
411 else
|
|
412 gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
|
|
413 fi
|
|
414 fi
|
|
415 if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
|
|
416 if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
|
|
417 :
|
|
418 else
|
|
419 gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
|
|
420 fi
|
|
421 fi
|
|
422 rm t1 t2
|
|
423 ])
|
|
424 do_compare="$gcc_cv_prog_cmp_skip"
|
|
425 AC_SUBST(do_compare)
|
|
426 ])
|
|
427
|
|
428 dnl See whether we can include both string.h and strings.h.
|
|
429 AC_DEFUN([ACX_HEADER_STRING],
|
|
430 [AC_CACHE_CHECK([whether string.h and strings.h may both be included],
|
|
431 gcc_cv_header_string,
|
|
432 [AC_TRY_COMPILE([#include <string.h>
|
|
433 #include <strings.h>], , gcc_cv_header_string=yes, gcc_cv_header_string=no)])
|
|
434 if test $gcc_cv_header_string = yes; then
|
|
435 AC_DEFINE(STRING_WITH_STRINGS, 1, [Define if you can safely include both <string.h> and <strings.h>.])
|
|
436 fi
|
|
437 ])
|
|
438
|
|
439 dnl See if stdbool.h properly defines bool and true/false.
|
|
440 dnl Check whether _Bool is built-in.
|
|
441 AC_DEFUN([ACX_HEADER_STDBOOL],
|
|
442 [AC_CACHE_CHECK([for working stdbool.h],
|
|
443 ac_cv_header_stdbool_h,
|
|
444 [AC_TRY_COMPILE([#include <stdbool.h>],
|
|
445 [bool foo = false;],
|
|
446 ac_cv_header_stdbool_h=yes, ac_cv_header_stdbool_h=no)])
|
|
447 if test $ac_cv_header_stdbool_h = yes; then
|
|
448 AC_DEFINE(HAVE_STDBOOL_H, 1,
|
|
449 [Define if you have a working <stdbool.h> header file.])
|
|
450 fi
|
|
451 AC_CACHE_CHECK(for built-in _Bool, gcc_cv_c__bool,
|
|
452 [AC_TRY_COMPILE(,
|
|
453 [_Bool foo;],
|
|
454 gcc_cv_c__bool=yes, gcc_cv_c__bool=no)
|
|
455 ])
|
|
456 if test $gcc_cv_c__bool = yes; then
|
|
457 AC_DEFINE(HAVE__BOOL, 1, [Define if the \`_Bool' type is built-in.])
|
|
458 fi
|
|
459 ])
|
|
460
|
|
461 dnl See if hard links work and if not, try to substitute $1 or simple copy.
|
|
462 AC_DEFUN([ACX_PROG_LN],
|
|
463 [AC_MSG_CHECKING(whether ln works)
|
|
464 AC_CACHE_VAL(acx_cv_prog_LN,
|
|
465 [rm -f conftestdata_t
|
|
466 echo >conftestdata_f
|
|
467 if ln conftestdata_f conftestdata_t 2>/dev/null
|
|
468 then
|
|
469 acx_cv_prog_LN=ln
|
|
470 else
|
|
471 acx_cv_prog_LN=no
|
|
472 fi
|
|
473 rm -f conftestdata_f conftestdata_t
|
|
474 ])dnl
|
|
475 if test $acx_cv_prog_LN = no; then
|
|
476 LN="ifelse([$1],,cp,[$1])"
|
|
477 AC_MSG_RESULT([no, using $LN])
|
|
478 else
|
|
479 LN="$acx_cv_prog_LN"
|
|
480 AC_MSG_RESULT(yes)
|
|
481 fi
|
|
482 AC_SUBST(LN)dnl
|
|
483 ])
|
|
484
|
|
485 dnl GCC_TARGET_TOOL(PROGRAM, TARGET-VAR, HOST-VAR, IN-TREE-TOOL, LANGUAGE)
|
|
486 AC_DEFUN([GCC_TARGET_TOOL],
|
|
487 [AC_MSG_CHECKING(where to find the target $1)
|
|
488 if test "x${build}" != "x${host}" ; then
|
|
489 if expr "x[$]$2" : "x/" > /dev/null; then
|
|
490 # We already found the complete path
|
|
491 ac_dir=`dirname [$]$2`
|
|
492 AC_MSG_RESULT(pre-installed in $ac_dir)
|
|
493 else
|
|
494 # Canadian cross, just use what we found
|
|
495 AC_MSG_RESULT(pre-installed)
|
|
496 fi
|
|
497 else
|
|
498 ifelse([$4],,,
|
|
499 [ok=yes
|
|
500 case " ${configdirs} " in
|
|
501 *" patsubst([$4], [/.*], []) "*) ;;
|
|
502 *) ok=no ;;
|
|
503 esac
|
|
504 ifelse([$5],,,
|
|
505 [case ,${enable_languages}, in
|
|
506 *,$5,*) ;;
|
|
507 *) ok=no ;;
|
|
508 esac])
|
|
509 if test $ok = yes; then
|
|
510 # An in-tree tool is available and we can use it
|
|
511 $2='$$r/$(HOST_SUBDIR)/$4'
|
|
512 AC_MSG_RESULT(just compiled)
|
|
513 el])if expr "x[$]$2" : "x/" > /dev/null; then
|
|
514 # We already found the complete path
|
|
515 ac_dir=`dirname [$]$2`
|
|
516 AC_MSG_RESULT(pre-installed in $ac_dir)
|
|
517 elif test "x$target" = "x$host"; then
|
|
518 # We can use an host tool
|
|
519 $2='$($3)'
|
|
520 AC_MSG_RESULT(host tool)
|
|
521 else
|
|
522 # We need a cross tool
|
|
523 AC_MSG_RESULT(pre-installed)
|
|
524 fi
|
|
525 fi
|
|
526 AC_SUBST($2)])
|
|
527
|
|
528
|
|
529 dnl Locate a program and check that its version is acceptable.
|
|
530 dnl ACX_PROG_CHECK_VER(var, name, version-switch,
|
|
531 dnl version-extract-regexp, version-glob)
|
|
532 AC_DEFUN([ACX_CHECK_PROG_VER],[
|
|
533 AC_CHECK_PROG([$1], [$2], [$2])
|
|
534 if test -n "[$]$1"; then
|
|
535 # Found it, now check the version.
|
|
536 AC_CACHE_CHECK([for modern $2],
|
|
537 [gcc_cv_prog_$2_modern],
|
|
538 [ac_prog_version=`eval [$]$1 $3 2>&1 |
|
|
539 sed -n 's/^.*patsubst([[$4]],/,\/).*$/\1/p'`
|
|
540
|
|
541 [case $ac_prog_version in
|
|
542 '') gcc_cv_prog_$2_modern=no;;
|
|
543 $5) gcc_cv_prog_$2_modern=yes;;
|
|
544 *) gcc_cv_prog_$2_modern=no;;
|
|
545 esac]
|
|
546 ])
|
|
547 else
|
|
548 gcc_cv_prog_$2_modern=no
|
|
549 fi
|
|
550 if test $gcc_cv_prog_$2_modern = no; then
|
|
551 $1="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing $2"
|
|
552 fi
|
|
553 ])
|
|
554
|
|
555 dnl Support the --with-pkgversion configure option.
|
|
556 dnl ACX_PKGVERSION(default-pkgversion)
|
|
557 AC_DEFUN([ACX_PKGVERSION],[
|
|
558 AC_ARG_WITH(pkgversion,
|
|
559 AS_HELP_STRING([--with-pkgversion=PKG],
|
|
560 [Use PKG in the version string in place of "$1"]),
|
|
561 [case "$withval" in
|
|
562 yes) AC_MSG_ERROR([package version not specified]) ;;
|
|
563 no) PKGVERSION= ;;
|
|
564 *) PKGVERSION="($withval) " ;;
|
|
565 esac],
|
|
566 PKGVERSION="($1) "
|
|
567 )
|
|
568 AC_SUBST(PKGVERSION)
|
|
569 ])
|
|
570
|
|
571 dnl Support the --with-bugurl configure option.
|
|
572 dnl ACX_BUGURL(default-bugurl)
|
|
573 AC_DEFUN([ACX_BUGURL],[
|
|
574 AC_ARG_WITH(bugurl,
|
|
575 AS_HELP_STRING([--with-bugurl=URL],
|
|
576 [Direct users to URL to report a bug]),
|
|
577 [case "$withval" in
|
|
578 yes) AC_MSG_ERROR([bug URL not specified]) ;;
|
|
579 no) BUGURL=
|
|
580 ;;
|
|
581 *) BUGURL="$withval"
|
|
582 ;;
|
|
583 esac],
|
|
584 BUGURL="$1"
|
|
585 )
|
|
586 case ${BUGURL} in
|
|
587 "")
|
|
588 REPORT_BUGS_TO=
|
|
589 REPORT_BUGS_TEXI=
|
|
590 ;;
|
|
591 *)
|
|
592 REPORT_BUGS_TO="<$BUGURL>"
|
|
593 REPORT_BUGS_TEXI=@uref{`echo "$BUGURL" | sed 's/@/@@/g'`}
|
|
594 ;;
|
|
595 esac;
|
|
596 AC_SUBST(REPORT_BUGS_TO)
|
|
597 AC_SUBST(REPORT_BUGS_TEXI)
|
|
598 ])
|
|
599
|
|
600 dnl ####
|
|
601 dnl # ACX_CHECK_CYGWIN_CAT_WORKS
|
|
602 dnl # On Cygwin hosts, check that the cat command ignores
|
|
603 dnl # carriage returns as otherwise builds will not work.
|
|
604 dnl # See binutils PR 4334 for more details.
|
|
605 AC_DEFUN([ACX_CHECK_CYGWIN_CAT_WORKS],[
|
|
606 AC_MSG_CHECKING([to see if cat works as expected])
|
|
607 echo a >cygwin-cat-check
|
|
608 if test `cat cygwin-cat-check` == a ; then
|
|
609 rm cygwin-cat-check
|
|
610 AC_MSG_RESULT(yes)
|
|
611 else
|
|
612 rm cygwin-cat-check
|
|
613 AC_MSG_RESULT(no)
|
|
614 AC_MSG_ERROR([The cat command does not ignore carriage return characters.
|
|
615 Please either mount the build directory in binary mode or run the following
|
|
616 commands before running any configure script:
|
|
617 set -o igncr
|
|
618 export SHELLOPTS
|
|
619 ])
|
|
620 fi
|
|
621 ])
|