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