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