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/${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
 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 $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
 287 fi
 288 if test -z "$ac_cv_path_$1" ; then
 289   AC_PATH_PROG([$1], [$2], [], [$gcc_cv_tool_dirs])
 290 fi
 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
 295 fi
 296 ]) []dnl # ACX_CHECK_INSTALLED_TARGET_TOOL
 297
 298 ###
 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.
 307
 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
 312
 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.
 316 #
 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;
 327 EOF
 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
 340 fi
 341 rm -f conftest.*])
 342
 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
 347 fi
 348 ])
 349
 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
 376 ])
 377 do_compare="$gcc_cv_prog_cmp_skip"
 378 AC_SUBST(do_compare)
 379 ])
 380
 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>.])
 389 fi
 390 ])
 391
 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.])
 403 fi
 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)
 408 ])
 409 if test $gcc_cv_c__bool = yes; then
 410   AC_DEFINE(HAVE__BOOL, 1, [Define if the \`_Bool' type is built-in.])
 411 fi
 412 ])
 413
 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
 425 fi
 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)
 434 fi
 435 AC_SUBST(LN)dnl
 436 ])
 437
 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])