* hppa.h (pa_opcodes): Reorder bb opcodes so that pa10 opcodes come
[binutils.git] / config / acx.m4
blob7c4c21386f18e7d7a8c0559de33e7af789a35f39
1 # Autoconf M4 include file defining utility macros for complex Canadian
2 # cross builds.
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
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
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
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
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
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
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}"
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=.
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
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
105 ####
106 # NCN_STRICT_CHECK_TOOLS(variable, progs-to-check-for,[value-if-not-found],[path])
107 # Like plain AC_CHECK_TOOLS, but require prefix if build!=host.
109 AC_DEFUN([NCN_STRICT_CHECK_TOOLS],
110 [AC_REQUIRE([_NCN_TOOL_PREFIXES]) []dnl
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
122 if test -z "$ac_cv_prog_$1" ; then
123   ifelse([$3],[], [set dummy $2
124   if test $build = $host ; then
125     $1="[$]2"
126   else
127     $1="${ncn_tool_prefix}[$]2"
128   fi], [$1="$3"])
130 ]) []dnl # NCN_STRICT_CHECK_TOOLS
132 ####
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.
136 AC_DEFUN([NCN_STRICT_CHECK_TARGET_TOOLS],
137 [AC_REQUIRE([_NCN_TOOL_PREFIXES]) []dnl
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/${ncn_progname}; then
142       ac_cv_prog_$1=$with_build_time_tools/${ncn_progname}
143       AC_MSG_RESULT(yes)
144       break
145     else
146       AC_MSG_RESULT(no)
147     fi
148   done
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
163   
164 if test -z "$ac_cv_prog_$1" ; then
165   ifelse([$3],[], [set dummy $2
166   if test $build = $target ; then
167     $1="[$]2"
168   else
169     $1="${ncn_target_tool_prefix}[$]2"
170   fi], [$1="$3"])
172 ]) []dnl # NCN_STRICT_CHECK_TARGET_TOOLS
173   
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
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
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=
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"
224 ]) []dnl # ACX_TOOL_DIRS
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
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
240 rm conftest.c
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.
247 # First try --with-build-time-tools, if specified.
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.
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.
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.
267 # If we do not find a suitable binary, then try the user's path.
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 $2 in $with_build_time_tools])
275     if test -x $with_build_time_tools/$2; then
276       $1=`cd $with_build_time_tools && pwd`/$2
277       ac_cv_path_$1=[$]$1
278       AC_MSG_RESULT([$ac_cv_path_$1])
279     else
280       AC_MSG_RESULT(no)
281     fi
282   elif test $build != $host && test $have_gcc_for_target = yes; then
283     $1=`$GCC_FOR_TARGET --print-prog-name=$2`
284     test [$]$1=$2 && $1=
285     ac_cv_path_$1=[$]$1
286   fi
288 if test -z "$ac_cv_path_$1" ; then
289   AC_PATH_PROG([$1], [$2], [], [$gcc_cv_tool_dirs])
291 if test -z "$ac_cv_path_$1" ; then
292   NCN_STRICT_CHECK_TARGET_TOOLS([$1], [$2])
293 else
294   $1=$ac_cv_path_$1
296 ]) []dnl # ACX_CHECK_INSTALLED_TARGET_TOOL
299 # AC_PROG_CPP_WERROR
300 # Used for autoconf 2.5x to force AC_PREPROC_IFELSE to reject code which
301 # triggers warnings from the preprocessor.  Will be in autoconf 2.58.
302 # For now, using this also overrides header checks to use only the
303 # preprocessor (matches 2.13 behavior; matching 2.58's behavior is a
304 # bit harder from here).
305 # Eventually autoconf will default to checking headers with the compiler
306 # instead, and we'll have to do this differently.
308 AC_DEFUN([AC_PROG_CPP_WERROR],
309 [AC_REQUIRE([AC_PROG_CPP])dnl
310 m4_define([AC_CHECK_HEADER],m4_defn([_AC_CHECK_HEADER_OLD]))
311 ac_c_preproc_warn_flag=yes])# AC_PROG_CPP_WERROR
313 # Test for GNAT.
314 # We require the gnatbind program, and a compiler driver that
315 # understands Ada.  We use the user's CC setting, already found.
317 # Sets the shell variable have_gnat to yes or no as appropriate, and
318 # substitutes GNATBIND.
319 AC_DEFUN([ACX_PROG_GNAT],
320 [AC_REQUIRE([AC_CHECK_TOOL_PREFIX])
321 AC_REQUIRE([AC_PROG_CC])
322 AC_CHECK_TOOL(GNATBIND, gnatbind, no)
323 AC_CACHE_CHECK([whether compiler driver understands Ada],
324                  acx_cv_cc_gcc_supports_ada,
325 [cat >conftest.adb <<EOF
326 procedure conftest is begin null; end conftest;
328 acx_cv_cc_gcc_supports_ada=no
329 # There is a bug in old released versions of GCC which causes the
330 # driver to exit successfully when the appropriate language module
331 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
332 # Therefore we must check for the error message as well as an
333 # unsuccessful exit.
334 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
335 # given a .adb file, but produce no object file.  So we must check
336 # if an object file was really produced to guard against this.
337 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
338 if test x"$errors" = x && test -f conftest.$ac_objext; then
339   acx_cv_cc_gcc_supports_ada=yes
341 rm -f conftest.*])
343 if test x$GNATBIND != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
344   have_gnat=yes
345 else
346   have_gnat=no
350 dnl 'make compare' can be significantly faster, if cmp itself can
351 dnl skip bytes instead of using tail.  The test being performed is
352 dnl "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2"
353 dnl but we need to sink errors and handle broken shells.  We also test
354 dnl for the parameter format "cmp file1 file2 skip1 skip2" which is
355 dnl accepted by cmp on some systems.
356 AC_DEFUN([ACX_PROG_CMP_IGNORE_INITIAL],
357 [AC_CACHE_CHECK([how to compare bootstrapped objects], gcc_cv_prog_cmp_skip,
358 [ echo abfoo >t1
359   echo cdfoo >t2
360   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
361   if cmp t1 t2 2 2 > /dev/null 2>&1; then
362     if cmp t1 t2 1 1 > /dev/null 2>&1; then
363       :
364     else
365       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
366     fi
367   fi
368   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
369     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
370       :
371     else
372       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
373     fi
374   fi
375   rm t1 t2
377 do_compare="$gcc_cv_prog_cmp_skip"
378 AC_SUBST(do_compare)
381 dnl See whether we can include both string.h and strings.h.
382 AC_DEFUN([ACX_HEADER_STRING],
383 [AC_CACHE_CHECK([whether string.h and strings.h may both be included],
384   gcc_cv_header_string,
385 [AC_TRY_COMPILE([#include <string.h>
386 #include <strings.h>], , gcc_cv_header_string=yes, gcc_cv_header_string=no)])
387 if test $gcc_cv_header_string = yes; then
388   AC_DEFINE(STRING_WITH_STRINGS, 1, [Define if you can safely include both <string.h> and <strings.h>.])
392 dnl See if stdbool.h properly defines bool and true/false.
393 dnl Check whether _Bool is built-in.
394 AC_DEFUN([ACX_HEADER_STDBOOL],
395 [AC_CACHE_CHECK([for working stdbool.h],
396   ac_cv_header_stdbool_h,
397 [AC_TRY_COMPILE([#include <stdbool.h>],
398 [bool foo = false;],
399 ac_cv_header_stdbool_h=yes, ac_cv_header_stdbool_h=no)])
400 if test $ac_cv_header_stdbool_h = yes; then
401   AC_DEFINE(HAVE_STDBOOL_H, 1,
402   [Define if you have a working <stdbool.h> header file.])
404 AC_CACHE_CHECK(for built-in _Bool, gcc_cv_c__bool,
405 [AC_TRY_COMPILE(,
406 [_Bool foo;],
407 gcc_cv_c__bool=yes, gcc_cv_c__bool=no)
409 if test $gcc_cv_c__bool = yes; then
410   AC_DEFINE(HAVE__BOOL, 1, [Define if the \`_Bool' type is built-in.])
414 dnl See if hard links work and if not, try to substitute $1 or simple copy.
415 AC_DEFUN([ACX_PROG_LN],
416 [AC_MSG_CHECKING(whether ln works)
417 AC_CACHE_VAL(acx_cv_prog_LN,
418 [rm -f conftestdata_t
419 echo >conftestdata_f
420 if ln conftestdata_f conftestdata_t 2>/dev/null
421 then
422   acx_cv_prog_LN=ln
423 else
424   acx_cv_prog_LN=no
426 rm -f conftestdata_f conftestdata_t
427 ])dnl
428 if test $acx_cv_prog_LN = no; then
429   LN="ifelse([$1],,cp,[$1])"
430   AC_MSG_RESULT([no, using $LN])
431 else
432   LN="$acx_cv_prog_LN"
433   AC_MSG_RESULT(yes)
435 AC_SUBST(LN)dnl
438 dnl GCC_TARGET_TOOL(PROGRAM, TARGET-VAR, HOST-VAR, IN-TREE-TOOL, LANGUAGE)
439 AC_DEFUN([GCC_TARGET_TOOL],
440 [AC_MSG_CHECKING(where to find the target $1)
441 if test "x${build}" != "x${host}" ; then
442   if expr "x[$]$2" : "x/" > /dev/null; then
443     # We already found the complete path
444     AC_MSG_RESULT(pre-installed in `dirname [$]$2`)
445   else
446     # Canadian cross, just use what we found
447     AC_MSG_RESULT(pre-installed)
448   fi
449 else
450   ifelse([$4],,,
451   [ok=yes
452   case " ${configdirs} " in
453     *" patsubst([$4], [/.*], []) "*) ;;
454     *) ok=no ;;
455   esac
456   ifelse([$5],,, 
457   [case ,${enable_languages}, in
458     *,$5,*) ;;
459     *) ok=no ;;
460   esac])
461   if test $ok = yes; then
462     # An in-tree tool is available and we can use it
463     $2='$$r/$(HOST_SUBDIR)/$4'
464     AC_MSG_RESULT(just compiled)
465   el])if expr "x[$]$2" : "x/" > /dev/null; then
466     # We already found the complete path
467     AC_MSG_RESULT(pre-installed in `dirname [$]$2`)
468   elif test "x$target" = "x$host"; then
469     # We can use an host tool
470     $2='$($3)'
471     AC_MSG_RESULT(host tool)
472   else
473     # We need a cross tool
474     AC_MSG_RESULT(pre-installed)
475   fi
476 fi])