| # Autoconf M4 include file defining utility macros for complex Canadian |
| # cross builds. |
| |
| dnl #### |
| dnl # _GCC_TOPLEV_NONCANONICAL_BUILD |
| dnl # $build_alias or canonical $build if blank. |
| dnl # Used when we would use $build_alias, but empty is not OK. |
| AC_DEFUN([_GCC_TOPLEV_NONCANONICAL_BUILD], |
| [AC_REQUIRE([AC_CANONICAL_BUILD]) []dnl |
| case ${build_alias} in |
| "") build_noncanonical=${build} ;; |
| *) build_noncanonical=${build_alias} ;; |
| esac |
| ]) []dnl # _GCC_TOPLEV_NONCANONICAL_BUILD |
| |
| dnl #### |
| dnl # _GCC_TOPLEV_NONCANONICAL_HOST |
| dnl # $host_alias, or $build_noncanonical if blank. |
| dnl # Used when we would use $host_alias, but empty is not OK. |
| AC_DEFUN([_GCC_TOPLEV_NONCANONICAL_HOST], |
| [AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_BUILD]) []dnl |
| case ${host_alias} in |
| "") host_noncanonical=${build_noncanonical} ;; |
| *) host_noncanonical=${host_alias} ;; |
| esac |
| ]) []dnl # _GCC_TOPLEV_NONCANONICAL_HOST |
| |
| dnl #### |
| dnl # _GCC_TOPLEV_NONCANONICAL_TARGET |
| dnl # $target_alias or $host_noncanonical if blank. |
| dnl # Used when we would use $target_alias, but empty is not OK. |
| AC_DEFUN([_GCC_TOPLEV_NONCANONICAL_TARGET], |
| [AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_HOST]) []dnl |
| case ${target_alias} in |
| "") target_noncanonical=${host_noncanonical} ;; |
| *) target_noncanonical=${target_alias} ;; |
| esac |
| ]) []dnl # _GCC_TOPLEV_NONCANONICAL_TARGET |
| |
| dnl #### |
| dnl # ACX_NONCANONICAL_BUILD |
| dnl # Like underscored version, but AC_SUBST's. |
| AC_DEFUN([ACX_NONCANONICAL_BUILD], |
| [AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_BUILD]) []dnl |
| AC_SUBST(build_noncanonical) |
| ]) []dnl # ACX_NONCANONICAL_BUILD |
| |
| dnl #### |
| dnl # ACX_NONCANONICAL_HOST |
| dnl # Like underscored version, but AC_SUBST's. |
| AC_DEFUN([ACX_NONCANONICAL_HOST], |
| [AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_HOST]) []dnl |
| AC_SUBST(host_noncanonical) |
| ]) []dnl # ACX_NONCANONICAL_HOST |
| |
| dnl #### |
| dnl # ACX_NONCANONICAL_TARGET |
| dnl # Like underscored version, but AC_SUBST's. |
| AC_DEFUN([ACX_NONCANONICAL_TARGET], |
| [AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_TARGET]) []dnl |
| AC_SUBST(target_noncanonical) |
| ]) []dnl # ACX_NONCANONICAL_TARGET |
| |
| dnl #### |
| dnl # GCC_TOPLEV_SUBDIRS |
| dnl # GCC & friends build 'build', 'host', and 'target' tools. These must |
| dnl # be separated into three well-known subdirectories of the build directory: |
| dnl # build_subdir, host_subdir, and target_subdir. The values are determined |
| dnl # here so that they can (theoretically) be changed in the future. They |
| dnl # were previously reproduced across many different files. |
| dnl # |
| dnl # This logic really amounts to very little with autoconf 2.13; it will |
| dnl # amount to a lot more with autoconf 2.5x. |
| AC_DEFUN([GCC_TOPLEV_SUBDIRS], |
| [AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_TARGET]) []dnl |
| AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_BUILD]) []dnl |
| # Prefix 'build-' so this never conflicts with target_subdir. |
| build_subdir="build-${build_noncanonical}" |
| # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories |
| if ( test $srcdir = . && test -d gcc ) \ |
| || test -d $srcdir/../host-${host_noncanonical}; then |
| host_subdir="host-${host_noncanonical}" |
| else |
| host_subdir=. |
| fi |
| # No prefix. |
| target_subdir=${target_noncanonical} |
| AC_SUBST([build_subdir]) []dnl |
| AC_SUBST([host_subdir]) []dnl |
| AC_SUBST([target_subdir]) []dnl |
| ]) []dnl # GCC_TOPLEV_SUBDIRS |
| |
| |
| #### |
| # _NCN_TOOL_PREFIXES: Some stuff that oughtta be done in AC_CANONICAL_SYSTEM |
| # or AC_INIT. |
| # These demand that AC_CANONICAL_SYSTEM be called beforehand. |
| AC_DEFUN([_NCN_TOOL_PREFIXES], |
| [ncn_tool_prefix= |
| test -n "$host_alias" && ncn_tool_prefix=$host_alias- |
| ncn_target_tool_prefix= |
| test -n "$target_alias" && ncn_target_tool_prefix=$target_alias- |
| ]) []dnl # _NCN_TOOL_PREFIXES |
| |
| #### |
| # NCN_STRICT_CHECK_TOOLS(variable, progs-to-check-for,[value-if-not-found],[path]) |
| # Like plain AC_CHECK_TOOLS, but require prefix if build!=host. |
| |
| AC_DEFUN([NCN_STRICT_CHECK_TOOLS], |
| [AC_REQUIRE([_NCN_TOOL_PREFIXES]) []dnl |
| for ncn_progname in $2; do |
| if test -n "$ncn_tool_prefix"; then |
| AC_CHECK_PROG([$1], [${ncn_tool_prefix}${ncn_progname}], |
| [${ncn_tool_prefix}${ncn_progname}], , [$4]) |
| fi |
| if test -z "$ac_cv_prog_$1" && test $build = $host ; then |
| AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4]) |
| fi |
| test -n "$ac_cv_prog_$1" && break |
| done |
| |
| if test -z "$ac_cv_prog_$1" ; then |
| ifelse([$3],[], [set dummy $2 |
| if test $build = $host ; then |
| $1="[$]2" |
| else |
| $1="${ncn_tool_prefix}[$]2" |
| fi], [$1="$3"]) |
| fi |
| ]) []dnl # NCN_STRICT_CHECK_TOOLS |
| |
| #### |
| # NCN_STRICT_CHECK_TARGET_TOOLS(variable, progs-to-check-for,[value-if-not-found],[path]) |
| # Like CVS Autoconf AC_CHECK_TARGET_TOOLS, but require prefix if build!=target. |
| |
| AC_DEFUN([NCN_STRICT_CHECK_TARGET_TOOLS], |
| [AC_REQUIRE([_NCN_TOOL_PREFIXES]) []dnl |
| if test -n "$with_build_time_tools"; then |
| for ncn_progname in $2; do |
| AC_MSG_CHECKING([for ${ncn_progname} in $with_build_time_tools]) |
| if test -x $with_build_time_tools/${ncn_progname}; then |
| ac_cv_prog_$1=$with_build_time_tools/${ncn_progname} |
| AC_MSG_RESULT(yes) |
| break |
| else |
| AC_MSG_RESULT(no) |
| fi |
| done |
| fi |
| |
| if test -z "$ac_cv_prog_$1"; then |
| for ncn_progname in $2; do |
| if test -n "$ncn_target_tool_prefix"; then |
| AC_CHECK_PROG([$1], [${ncn_target_tool_prefix}${ncn_progname}], |
| [${ncn_target_tool_prefix}${ncn_progname}], , [$4]) |
| fi |
| if test -z "$ac_cv_prog_$1" && test $build = $target ; then |
| AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4]) |
| fi |
| test -n "$ac_cv_prog_$1" && break |
| done |
| fi |
| |
| if test -z "$ac_cv_prog_$1" ; then |
| ifelse([$3],[], [set dummy $2 |
| if test $build = $target ; then |
| $1="[$]2" |
| else |
| $1="${ncn_target_tool_prefix}[$]2" |
| fi], [$1="$3"]) |
| fi |
| ]) []dnl # NCN_STRICT_CHECK_TARGET_TOOLS |
| |
| |
| # Backported from Autoconf 2.5x; can go away when and if |
| # we switch. Put the OS path separator in $PATH_SEPARATOR. |
| AC_DEFUN([ACX_PATH_SEP], [ |
| # The user is always right. |
| if test "${PATH_SEPARATOR+set}" != set; then |
| echo "#! /bin/sh" >conf$$.sh |
| echo "exit 0" >>conf$$.sh |
| chmod +x conf$$.sh |
| if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then |
| PATH_SEPARATOR=';' |
| else |
| PATH_SEPARATOR=: |
| fi |
| rm -f conf$$.sh |
| fi |
| ]) |
| |
| |
| AC_DEFUN([ACX_TOOL_DIRS], [ |
| AC_REQUIRE([ACX_PATH_SEP]) |
| if test "x$exec_prefix" = xNONE; then |
| if test "x$prefix" = xNONE; then |
| gcc_cv_tool_prefix=$ac_default_prefix |
| else |
| gcc_cv_tool_prefix=$prefix |
| fi |
| else |
| gcc_cv_tool_prefix=$exec_prefix |
| fi |
| |
| # If there is no compiler in the tree, use the PATH only. In any |
| # case, if there is no compiler in the tree nobody should use |
| # AS_FOR_TARGET and LD_FOR_TARGET. |
| if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then |
| gcc_version=`cat $srcdir/gcc/BASE-VER` |
| gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR" |
| gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR" |
| gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR" |
| gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR" |
| gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR" |
| gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR" |
| else |
| gcc_cv_tool_dirs= |
| fi |
| |
| if test x$build = x$target && test -n "$md_exec_prefix"; then |
| gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR" |
| fi |
| |
| ]) []dnl # ACX_TOOL_DIRS |
| |
| # ACX_HAVE_GCC_FOR_TARGET |
| # Check if the variable GCC_FOR_TARGET really points to a GCC binary. |
| AC_DEFUN([ACX_HAVE_GCC_FOR_TARGET], [ |
| cat > conftest.c << \EOF |
| #ifdef __GNUC__ |
| gcc_yay; |
| #endif |
| EOF |
| if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then |
| have_gcc_for_target=yes |
| else |
| GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc |
| have_gcc_for_target=no |
| fi |
| rm conftest.c |
| ]) |
| |
| # ACX_CHECK_INSTALLED_TARGET_TOOL(VAR, PROG) |
| # Searching for installed target binutils. We need to take extra care, |
| # else we may find the wrong assembler, linker, etc., and lose. |
| # |
| # First try --with-build-time-tools, if specified. |
| # |
| # For build != host, we ask the installed GCC for the name of the tool it |
| # uses, and accept it if it is an absolute path. This is because the |
| # only good choice for a compiler is the same GCC version that is being |
| # installed (or we couldn't make target libraries), and we assume that |
| # on the host system we'll have not only the same GCC version, but also |
| # the same binutils version. |
| # |
| # For build == host, search the same directories that the installed |
| # compiler will search. We used to do this for the assembler, linker, |
| # and nm only; for simplicity of configuration, however, we extend this |
| # criterion to tools (such as ar and ranlib) that are never invoked by |
| # the compiler, to avoid mismatches. |
| # |
| # Also note we have to check MD_EXEC_PREFIX before checking the user's path |
| # if build == target. This makes the most sense only when bootstrapping, |
| # but we also do so when build != host. In this case, we hope that the |
| # build and host systems will have similar contents of MD_EXEC_PREFIX. |
| # |
| # If we do not find a suitable binary, then try the user's path. |
| |
| AC_DEFUN([ACX_CHECK_INSTALLED_TARGET_TOOL], [ |
| AC_REQUIRE([ACX_TOOL_DIRS]) |
| AC_REQUIRE([ACX_HAVE_GCC_FOR_TARGET]) |
| if test -z "$ac_cv_path_$1" ; then |
| if test -n "$with_build_time_tools"; then |
| AC_MSG_CHECKING([for $2 in $with_build_time_tools]) |
| if test -x $with_build_time_tools/$2; then |
| $1=`cd $with_build_time_tools && pwd`/$2 |
| ac_cv_path_$1=[$]$1 |
| AC_MSG_RESULT([$ac_cv_path_$1]) |
| else |
| AC_MSG_RESULT(no) |
| fi |
| elif test $build != $host && test $have_gcc_for_target = yes; then |
| $1=`$GCC_FOR_TARGET --print-prog-name=$2` |
| test [$]$1=$2 && $1= |
| ac_cv_path_$1=[$]$1 |
| fi |
| fi |
| if test -z "$ac_cv_path_$1" ; then |
| AC_PATH_PROG([$1], [$2], [], [$gcc_cv_tool_dirs]) |
| fi |
| if test -z "$ac_cv_path_$1" ; then |
| NCN_STRICT_CHECK_TARGET_TOOLS([$1], [$2]) |
| else |
| $1=$ac_cv_path_$1 |
| fi |
| ]) []dnl # ACX_CHECK_INSTALLED_TARGET_TOOL |
| |
| ### |
| # AC_PROG_CPP_WERROR |
| # Used for autoconf 2.5x to force AC_PREPROC_IFELSE to reject code which |
| # triggers warnings from the preprocessor. Will be in autoconf 2.58. |
| # For now, using this also overrides header checks to use only the |
| # preprocessor (matches 2.13 behavior; matching 2.58's behavior is a |
| # bit harder from here). |
| # Eventually autoconf will default to checking headers with the compiler |
| # instead, and we'll have to do this differently. |
| |
| AC_DEFUN([AC_PROG_CPP_WERROR], |
| [AC_REQUIRE([AC_PROG_CPP])dnl |
| m4_define([AC_CHECK_HEADER],m4_defn([_AC_CHECK_HEADER_OLD])) |
| ac_c_preproc_warn_flag=yes])# AC_PROG_CPP_WERROR |
| |
| # Test for GNAT. |
| # We require the gnatbind program, and a compiler driver that |
| # understands Ada. We use the user's CC setting, already found. |
| # |
| # Sets the shell variable have_gnat to yes or no as appropriate, and |
| # substitutes GNATBIND. |
| AC_DEFUN([ACX_PROG_GNAT], |
| [AC_REQUIRE([AC_CHECK_TOOL_PREFIX]) |
| AC_REQUIRE([AC_PROG_CC]) |
| AC_CHECK_TOOL(GNATBIND, gnatbind, no) |
| AC_CACHE_CHECK([whether compiler driver understands Ada], |
| acx_cv_cc_gcc_supports_ada, |
| [cat >conftest.adb <<EOF |
| procedure conftest is begin null; end conftest; |
| EOF |
| acx_cv_cc_gcc_supports_ada=no |
| # There is a bug in old released versions of GCC which causes the |
| # driver to exit successfully when the appropriate language module |
| # has not been installed. This is fixed in 2.95.4, 3.0.2, and 3.1. |
| # Therefore we must check for the error message as well as an |
| # unsuccessful exit. |
| # Other compilers, like HP Tru64 UNIX cc, exit successfully when |
| # given a .adb file, but produce no object file. So we must check |
| # if an object file was really produced to guard against this. |
| errors=`(${CC} -c conftest.adb) 2>&1 || echo failure` |
| if test x"$errors" = x && test -f conftest.$ac_objext; then |
| acx_cv_cc_gcc_supports_ada=yes |
| fi |
| rm -f conftest.*]) |
| |
| if test x$GNATBIND != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then |
| have_gnat=yes |
| else |
| have_gnat=no |
| fi |
| ]) |
| |
| dnl 'make compare' can be significantly faster, if cmp itself can |
| dnl skip bytes instead of using tail. The test being performed is |
| dnl "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2" |
| dnl but we need to sink errors and handle broken shells. We also test |
| dnl for the parameter format "cmp file1 file2 skip1 skip2" which is |
| dnl accepted by cmp on some systems. |
| AC_DEFUN([ACX_PROG_CMP_IGNORE_INITIAL], |
| [AC_CACHE_CHECK([how to compare bootstrapped objects], gcc_cv_prog_cmp_skip, |
| [ echo abfoo >t1 |
| echo cdfoo >t2 |
| gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2' |
| if cmp t1 t2 2 2 > /dev/null 2>&1; then |
| if cmp t1 t2 1 1 > /dev/null 2>&1; then |
| : |
| else |
| gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16' |
| fi |
| fi |
| if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then |
| if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then |
| : |
| else |
| gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2' |
| fi |
| fi |
| rm t1 t2 |
| ]) |
| do_compare="$gcc_cv_prog_cmp_skip" |
| AC_SUBST(do_compare) |
| ]) |
| |
| dnl See whether we can include both string.h and strings.h. |
| AC_DEFUN([ACX_HEADER_STRING], |
| [AC_CACHE_CHECK([whether string.h and strings.h may both be included], |
| gcc_cv_header_string, |
| [AC_TRY_COMPILE([#include <string.h> |
| #include <strings.h>], , gcc_cv_header_string=yes, gcc_cv_header_string=no)]) |
| if test $gcc_cv_header_string = yes; then |
| AC_DEFINE(STRING_WITH_STRINGS, 1, [Define if you can safely include both <string.h> and <strings.h>.]) |
| fi |
| ]) |
| |
| dnl See if stdbool.h properly defines bool and true/false. |
| dnl Check whether _Bool is built-in. |
| AC_DEFUN([ACX_HEADER_STDBOOL], |
| [AC_CACHE_CHECK([for working stdbool.h], |
| ac_cv_header_stdbool_h, |
| [AC_TRY_COMPILE([#include <stdbool.h>], |
| [bool foo = false;], |
| ac_cv_header_stdbool_h=yes, ac_cv_header_stdbool_h=no)]) |
| if test $ac_cv_header_stdbool_h = yes; then |
| AC_DEFINE(HAVE_STDBOOL_H, 1, |
| [Define if you have a working <stdbool.h> header file.]) |
| fi |
| AC_CACHE_CHECK(for built-in _Bool, gcc_cv_c__bool, |
| [AC_TRY_COMPILE(, |
| [_Bool foo;], |
| gcc_cv_c__bool=yes, gcc_cv_c__bool=no) |
| ]) |
| if test $gcc_cv_c__bool = yes; then |
| AC_DEFINE(HAVE__BOOL, 1, [Define if the \`_Bool' type is built-in.]) |
| fi |
| ]) |
| |
| dnl See if hard links work and if not, try to substitute $1 or simple copy. |
| AC_DEFUN([ACX_PROG_LN], |
| [AC_MSG_CHECKING(whether ln works) |
| AC_CACHE_VAL(acx_cv_prog_LN, |
| [rm -f conftestdata_t |
| echo >conftestdata_f |
| if ln conftestdata_f conftestdata_t 2>/dev/null |
| then |
| acx_cv_prog_LN=ln |
| else |
| acx_cv_prog_LN=no |
| fi |
| rm -f conftestdata_f conftestdata_t |
| ])dnl |
| if test $acx_cv_prog_LN = no; then |
| LN="ifelse([$1],,cp,[$1])" |
| AC_MSG_RESULT([no, using $LN]) |
| else |
| LN="$acx_cv_prog_LN" |
| AC_MSG_RESULT(yes) |
| fi |
| AC_SUBST(LN)dnl |
| ]) |
| |
| dnl GCC_TARGET_TOOL(PROGRAM, TARGET-VAR, HOST-VAR, IN-TREE-TOOL, LANGUAGE) |
| AC_DEFUN([GCC_TARGET_TOOL], |
| [AC_MSG_CHECKING(where to find the target $1) |
| if test "x${build}" != "x${host}" ; then |
| if expr "x[$]$2" : "x/" > /dev/null; then |
| # We already found the complete path |
| AC_MSG_RESULT(pre-installed in `dirname [$]$2`) |
| else |
| # Canadian cross, just use what we found |
| AC_MSG_RESULT(pre-installed) |
| fi |
| else |
| ifelse([$4],,, |
| [ok=yes |
| case " ${configdirs} " in |
| *" patsubst([$4], [/.*], []) "*) ;; |
| *) ok=no ;; |
| esac |
| ifelse([$5],,, |
| [case ,${enable_languages}, in |
| *,$5,*) ;; |
| *) ok=no ;; |
| esac]) |
| if test $ok = yes; then |
| # An in-tree tool is available and we can use it |
| $2='$$r/$(HOST_SUBDIR)/$4' |
| AC_MSG_RESULT(just compiled) |
| el])if expr "x[$]$2" : "x/" > /dev/null; then |
| # We already found the complete path |
| AC_MSG_RESULT(pre-installed in `dirname [$]$2`) |
| elif test "x$target" = "x$host"; then |
| # We can use an host tool |
| $2='$($3)' |
| AC_MSG_RESULT(host tool) |
| else |
| # We need a cross tool |
| AC_MSG_RESULT(pre-installed) |
| fi |
| fi]) |