config/acx.m4

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