1 |
9 |
jlechner |
# 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 |
|
|
])
|