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 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 #
 362 # Sets the shell variable have_gnat to yes or no as appropriate, and
 363 # substitutes GNATBIND and GNATMAKE.
 364 AC_DEFUN([ACX_PROG_GNAT],
 365 [AC_REQUIRE([AC_CHECK_TOOL_PREFIX])
 366 AC_REQUIRE([AC_PROG_CC])
 367 AC_CHECK_TOOL(GNATBIND, gnatbind, no)
 368 AC_CHECK_TOOL(GNATMAKE, gnatmake, no)
 369 AC_CACHE_CHECK([whether compiler driver understands Ada],
 370                  acx_cv_cc_gcc_supports_ada,
 371 [cat >conftest.adb <<EOF
 372 procedure conftest is begin null; end conftest;
 373 EOF
 374 acx_cv_cc_gcc_supports_ada=no
 375 # There is a bug in old released versions of GCC which causes the
 376 # driver to exit successfully when the appropriate language module
 377 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
 378 # Therefore we must check for the error message as well as an
 379 # unsuccessful exit.
 380 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
 381 # given a .adb file, but produce no object file.  So we must check
 382 # if an object file was really produced to guard against this.
 383 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
 384 if test x"$errors" = x && test -f conftest.$ac_objext; then
 385   acx_cv_cc_gcc_supports_ada=yes
 386 fi
 387 rm -f conftest.*])
 388
 389 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
 390   have_gnat=yes
 391 else
 392   have_gnat=no
 393 fi
 394 ])
 395
 396 dnl 'make compare' can be significantly faster, if cmp itself can
 397 dnl skip bytes instead of using tail.  The test being performed is
 398 dnl "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2"
 399 dnl but we need to sink errors and handle broken shells.  We also test
 400 dnl for the parameter format "cmp file1 file2 skip1 skip2" which is
 401 dnl accepted by cmp on some systems.
 402 AC_DEFUN([ACX_PROG_CMP_IGNORE_INITIAL],
 403 [AC_CACHE_CHECK([how to compare bootstrapped objects], gcc_cv_prog_cmp_skip,
 404 [ echo abfoo >t1
 405   echo cdfoo >t2
 406   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
 407   if cmp t1 t2 2 2 > /dev/null 2>&1; then
 408     if cmp t1 t2 1 1 > /dev/null 2>&1; then
 409       :
 410     else
 411       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
 412     fi
 413   fi
 414   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
 415     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
 416       :
 417     else
 418       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
 419     fi
 420   fi
 421   rm t1 t2
 422 ])
 423 do_compare="$gcc_cv_prog_cmp_skip"
 424 AC_SUBST(do_compare)
 425 ])
 426
 427 dnl See whether we can include both string.h and strings.h.
 428 AC_DEFUN([ACX_HEADER_STRING],
 429 [AC_CACHE_CHECK([whether string.h and strings.h may both be included],
 430   gcc_cv_header_string,
 431 [AC_TRY_COMPILE([#include <string.h>
 432 #include <strings.h>], , gcc_cv_header_string=yes, gcc_cv_header_string=no)])
 433 if test $gcc_cv_header_string = yes; then
 434   AC_DEFINE(STRING_WITH_STRINGS, 1, [Define if you can safely include both <string.h> and <strings.h>.])
 435 fi
 436 ])
 437
 438 dnl See if stdbool.h properly defines bool and true/false.
 439 dnl Check whether _Bool is built-in.
 440 AC_DEFUN([ACX_HEADER_STDBOOL],
 441 [AC_CACHE_CHECK([for working stdbool.h],
 442   ac_cv_header_stdbool_h,
 443 [AC_TRY_COMPILE([#include <stdbool.h>],
 444 [bool foo = false;],
 445 ac_cv_header_stdbool_h=yes, ac_cv_header_stdbool_h=no)])
 446 if test $ac_cv_header_stdbool_h = yes; then
 447   AC_DEFINE(HAVE_STDBOOL_H, 1,
 448   [Define if you have a working <stdbool.h> header file.])
 449 fi
 450 AC_CACHE_CHECK(for built-in _Bool, gcc_cv_c__bool,
 451 [AC_TRY_COMPILE(,
 452 [_Bool foo;],
 453 gcc_cv_c__bool=yes, gcc_cv_c__bool=no)
 454 ])
 455 if test $gcc_cv_c__bool = yes; then
 456   AC_DEFINE(HAVE__BOOL, 1, [Define if the \`_Bool' type is built-in.])
 457 fi
 458 ])
 459
 460 dnl See if hard links work and if not, try to substitute $1 or simple copy.
 461 AC_DEFUN([ACX_PROG_LN],
 462 [AC_MSG_CHECKING(whether ln works)
 463 AC_CACHE_VAL(acx_cv_prog_LN,
 464 [rm -f conftestdata_t
 465 echo >conftestdata_f
 466 if ln conftestdata_f conftestdata_t 2>/dev/null
 467 then
 468   acx_cv_prog_LN=ln
 469 else
 470   acx_cv_prog_LN=no
 471 fi
 472 rm -f conftestdata_f conftestdata_t
 473 ])dnl
 474 if test $acx_cv_prog_LN = no; then
 475   LN="ifelse([$1],,cp,[$1])"
 476   AC_MSG_RESULT([no, using $LN])
 477 else
 478   LN="$acx_cv_prog_LN"
 479   AC_MSG_RESULT(yes)
 480 fi
 481 AC_SUBST(LN)dnl
 482 ])
 483
 484 dnl GCC_TARGET_TOOL(PROGRAM, TARGET-VAR, HOST-VAR, IN-TREE-TOOL, LANGUAGE)
 485 AC_DEFUN([GCC_TARGET_TOOL],
 486 [AC_MSG_CHECKING(where to find the target $1)
 487 if test "x${build}" != "x${host}" ; then
 488   if expr "x[$]$2" : "x/" > /dev/null; then
 489     # We already found the complete path
 490     ac_dir=`dirname [$]$2`
 491     AC_MSG_RESULT(pre-installed in $ac_dir)
 492   else
 493     # Canadian cross, just use what we found
 494     AC_MSG_RESULT(pre-installed)
 495   fi
 496 else
 497   ifelse([$4],,,
 498   [ok=yes
 499   case " ${configdirs} " in
 500     *" patsubst([$4], [/.*], []) "*) ;;
 501     *) ok=no ;;
 502   esac
 503   ifelse([$5],,,
 504   [case ,${enable_languages}, in
 505     *,$5,*) ;;
 506     *) ok=no ;;
 507   esac])
 508   if test $ok = yes; then
 509     # An in-tree tool is available and we can use it
 510     $2='$$r/$(HOST_SUBDIR)/$4'
 511     AC_MSG_RESULT(just compiled)
 512   el])if expr "x[$]$2" : "x/" > /dev/null; then
 513     # We already found the complete path
 514     ac_dir=`dirname [$]$2`
 515     AC_MSG_RESULT(pre-installed in $ac_dir)
 516   elif test "x$target" = "x$host"; then
 517     # We can use an host tool
 518     $2='$($3)'
 519     AC_MSG_RESULT(host tool)
 520   else
 521     # We need a cross tool
 522     AC_MSG_RESULT(pre-installed)
 523   fi
 524 fi
 525 AC_SUBST($2)])
 526
 527
 528 dnl Locate a program and check that its version is acceptable.
 529 dnl ACX_PROG_CHECK_VER(var, name, version-switch,
 530 dnl                    version-extract-regexp, version-glob)
 531 AC_DEFUN([ACX_CHECK_PROG_VER],[
 532   AC_CHECK_PROG([$1], [$2], [$2])
 533   if test -n "[$]$1"; then
 534     # Found it, now check the version.
 535     AC_CACHE_CHECK([for modern $2],
 536                    [gcc_cv_prog_$2_modern],
 537                    [ac_prog_version=`eval [$]$1 $3 2>&1 |
 538                                      sed -n 's/^.*patsubst([[$4]],/,\/).*$/\1/p'`
 539
 540                     [case $ac_prog_version in
 541                       '')  gcc_cv_prog_$2_modern=no;;
 542                       $5)  gcc_cv_prog_$2_modern=yes;;
 543                       *)   gcc_cv_prog_$2_modern=no;;
 544                     esac]
 545                    ])
 546   else
 547     gcc_cv_prog_$2_modern=no
 548   fi
 549   if test $gcc_cv_prog_$2_modern = no; then
 550     $1="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing $2"
 551   fi
 552 ])
 553
 554 dnl Support the --with-pkgversion configure option.
 555 dnl ACX_PKGVERSION(default-pkgversion)
 556 AC_DEFUN([ACX_PKGVERSION],[
 557   AC_ARG_WITH(pkgversion,
 558     AS_HELP_STRING([--with-pkgversion=PKG],
 559                    [Use PKG in the version string in place of "$1"]),
 560     [case "$withval" in
 561       yes) AC_MSG_ERROR([package version not specified]) ;;
 562       no)  PKGVERSION= ;;
 563       *)   PKGVERSION="($withval) " ;;
 564      esac],
 565     PKGVERSION="($1) "
 566   )
 567   AC_SUBST(PKGVERSION)
 568 ])
 569
 570 dnl Support the --with-bugurl configure option.
 571 dnl ACX_BUGURL(default-bugurl)
 572 AC_DEFUN([ACX_BUGURL],[
 573   AC_ARG_WITH(bugurl,
 574     AS_HELP_STRING([--with-bugurl=URL],
 575                    [Direct users to URL to report a bug]),
 576     [case "$withval" in
 577       yes) AC_MSG_ERROR([bug URL not specified]) ;;
 578       no)  BUGURL=
 579            ;;
 580       *)   BUGURL="$withval"
 581            ;;
 582      esac],
 583      BUGURL="$1"
 584   )
 585   case ${BUGURL} in
 586   "")
 587     REPORT_BUGS_TO=
 588     REPORT_BUGS_TEXI=
 589     ;;
 590   *)
 591     REPORT_BUGS_TO="<$BUGURL>"
 592     REPORT_BUGS_TEXI=@uref{`echo "$BUGURL" | sed 's/@/@@/g'`}
 593     ;;
 594   esac;
 595   AC_SUBST(REPORT_BUGS_TO)
 596   AC_SUBST(REPORT_BUGS_TEXI)
 597 ])