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