-Fdnl See whether we can include both string.h and strings.h.
+dnl See if stdbool.h properly defines bool and true/false.
+AC_DEFUN(gcc_AC_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
+])
+
+dnl See whether we can include both string.h and strings.h.
AC_DEFUN(gcc_AC_HEADER_STRING,
[AC_CACHE_CHECK([whether string.h and strings.h may both be included],
gcc_cv_header_string,
gcc_AC_CHECK_DECL($ac_func,
[AC_DEFINE_UNQUOTED($ac_tr_decl, 1) $2],
[AC_DEFINE_UNQUOTED($ac_tr_decl, 0) $3],
+dnl It is possible that the include files passed in here are local headers
+dnl which supply a backup declaration for the relevant prototype based on
+dnl the definition of (or lack of) the HAVE_DECL_ macro. If so, this test
+dnl will always return success. E.g. see libiberty.h's handling of
+dnl `basename'. To avoid this, we define the relevant HAVE_DECL_ macro to
+dnl 1 so that any local headers used do not provide their own prototype
+dnl during this test.
+#undef $ac_tr_decl
+#define $ac_tr_decl 1
$4
)
done
dnl Automatically generate config.h entries via autoheader.
if test x = y ; then
patsubst(translit([$1], [a-z], [A-Z]), [\w+],
- AC_DEFINE([HAVE_DECL_\&], 1,
- [Define to 1 if we found this declaration otherwise define to 0.]))dnl
+ [AC_DEFINE([HAVE_DECL_\&], 1,
+ [Define to 1 if we found this declaration otherwise define to 0.])])dnl
fi
])
AC_SUBST(doprint)
])
+dnl Check if we have strstr.
+AC_DEFUN([gcc_AC_FUNC_STRSTR],
+ [AC_CHECK_FUNCS([strstr], [strstr=], [strstr=strstr.o])
+ AC_SUBST([strstr])])
+
dnl See if the printf functions in libc support %p in format strings.
AC_DEFUN(gcc_AC_FUNC_PRINTF_PTR,
[AC_CACHE_CHECK(whether the printf functions support %p,
gcc_cv_c_long_double=yes, gcc_cv_c_long_double=no)
fi])
if test $gcc_cv_c_long_double = yes; then
- AC_DEFINE(HAVE_LONG_DOUBLE)
+ AC_DEFINE(HAVE_LONG_DOUBLE, 1,
+ [Define if your compiler supports the \`long double' type.])
+fi
+])
+
+dnl Check whether _Bool is built-in.
+AC_DEFUN(gcc_AC_C__BOOL,
+[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
])
gt_cv_func_gettext_libintl=no)])
fi
+ if test "$gt_cv_func_gettext_libintl" = "yes"; then
+ LIBS="-lintl $LIBS"
+ fi
+
if test "$gt_cv_func_gettext_libc" = "yes" \
|| test "$gt_cv_func_gettext_libintl" = "yes"; then
AC_DEFINE(HAVE_GETTEXT)
AC_REQUIRE([AC_C_INLINE])dnl
AC_REQUIRE([AC_TYPE_OFF_T])dnl
AC_REQUIRE([AC_TYPE_SIZE_T])dnl
- AC_REQUIRE([AC_FUNC_ALLOCA])dnl
AC_CHECK_HEADERS([argz.h limits.h locale.h nl_types.h malloc.h string.h \
unistd.h sys/param.h])
AM_LC_MESSAGES
AM_WITH_NLS
- if test "x$create_catalogs" == "xno"; then
+ if test "x$create_catalogs" = "xno"; then
AC_MSG_WARN([No program for building catalogs found -> building disabled])
fi
# Check whether mmap can map an arbitrary page from /dev/zero or with
# MAP_ANONYMOUS, without MAP_FIXED.
AC_DEFUN([AC_FUNC_MMAP_ANYWHERE],
-[AC_CHECK_HEADERS(unistd.h)
-AC_CHECK_FUNCS(getpagesize)
-AC_CACHE_CHECK(for working mmap which provides zeroed pages anywhere,
- ac_cv_func_mmap_anywhere,
-[AC_TRY_RUN([
-/* Test by Richard Henderson and Alexandre Oliva.
- Check whether mmap MAP_ANONYMOUS or mmap from /dev/zero works. */
+[AC_CHECK_FUNCS(getpagesize)
+# The test program for the next two tests is the same except for one
+# set of ifdefs.
+changequote({{{,}}})dnl
+{{{cat >ct-mmap.inc <<'EOF'
#include <sys/types.h>
-#include <fcntl.h>
#include <sys/mman.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <setjmp.h>
+#include <stdio.h>
#if !defined (MAP_ANONYMOUS) && defined (MAP_ANON)
# define MAP_ANONYMOUS MAP_ANON
#endif /* no HAVE_GETPAGESIZE */
-int main()
-{
- char *x;
- int fd, pg;
-
-#ifndef MAP_ANONYMOUS
- fd = open("/dev/zero", O_RDWR);
- if (fd < 0)
- exit(1);
+#ifndef MAP_FAILED
+# define MAP_FAILED -1
#endif
- pg = getpagesize();
-#ifdef MAP_ANONYMOUS
- x = (char*)mmap(0, pg, PROT_READ|PROT_WRITE,
- MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+#undef perror_exit
+#define perror_exit(str, val) \
+ do { perror(str); exit(val); } while (0)
+
+/* Some versions of cygwin mmap require that munmap is called with the
+ same parameters as mmap. GCC expects that this is not the case.
+ Test for various forms of this problem. Warning - icky signal games. */
+
+static sigset_t unblock_sigsegv;
+static jmp_buf r;
+static size_t pg;
+static int devzero;
+
+static char *
+anonmap (size)
+ size_t size;
+{
+#ifdef USE_MAP_ANON
+ return (char *) mmap (0, size, PROT_READ|PROT_WRITE,
+ MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
#else
- x = (char*)mmap(0, pg, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
+ return (char *) mmap (0, size, PROT_READ|PROT_WRITE,
+ MAP_PRIVATE, devzero, 0);
#endif
- if (x == (char *) -1)
- exit(2);
+}
+
+static void
+sigsegv (unused)
+ int unused;
+{
+ sigprocmask (SIG_UNBLOCK, &unblock_sigsegv, 0);
+ longjmp (r, 1);
+}
+
+/* Basic functionality test. */
+void
+test_0 ()
+{
+ char *x = anonmap (pg);
+ if (x == (char *) MAP_FAILED)
+ perror_exit("test 0 mmap", 2);
*(int *)x += 1;
if (munmap(x, pg) < 0)
- exit(3);
+ perror_exit("test 0 munmap", 3);
+}
+
+/* 1. If we map a 2-page region and unmap its second page, the first page
+ must remain. */
+static void
+test_1 ()
+{
+ char *x = anonmap (pg * 2);
+ if (x == (char *)MAP_FAILED)
+ perror_exit ("test 1 mmap", 4);
+
+ signal (SIGSEGV, sigsegv);
+ if (setjmp (r))
+ perror_exit ("test 1 fault", 5);
+
+ x[0] = 1;
+ x[pg] = 1;
+
+ if (munmap (x + pg, pg) < 0)
+ perror_exit ("test 1 munmap 1", 6);
+ x[0] = 2;
+
+ if (setjmp (r) == 0)
+ {
+ x[pg] = 1;
+ perror_exit ("test 1 no fault", 7);
+ }
+ if (munmap (x, pg) < 0)
+ perror_exit ("test 1 munmap 2", 8);
+}
+
+/* 2. If we map a 2-page region and unmap its first page, the second
+ page must remain. */
+static void
+test_2 ()
+{
+ char *x = anonmap (pg * 2);
+ if (x == (char *)MAP_FAILED)
+ perror_exit ("test 2 mmap", 9);
+
+ signal (SIGSEGV, sigsegv);
+ if (setjmp (r))
+ perror_exit ("test 2 fault", 10);
+
+ x[0] = 1;
+ x[pg] = 1;
+
+ if (munmap (x, pg) < 0)
+ perror_exit ("test 2 munmap 1", 11);
+
+ x[pg] = 2;
+
+ if (setjmp (r) == 0)
+ {
+ x[0] = 1;
+ perror_exit ("test 2 no fault", 12);
+ }
+
+ if (munmap (x+pg, pg) < 0)
+ perror_exit ("test 2 munmap 2", 13);
+}
+
+/* 3. If we map two adjacent 1-page regions and unmap them both with
+ one munmap, both must go away.
+
+ Getting two adjacent 1-page regions with two mmap calls is slightly
+ tricky. All OS's tested skip over already-allocated blocks; therefore
+ we have been careful to unmap all allocated regions in previous tests.
+ HP/UX allocates pages backward in memory. No OS has yet been observed
+ to be so perverse as to leave unmapped space between consecutive calls
+ to mmap. */
+
+static void
+test_3 ()
+{
+ char *x, *y, *z;
+
+ x = anonmap (pg);
+ if (x == (char *)MAP_FAILED)
+ perror_exit ("test 3 mmap 1", 14);
+ y = anonmap (pg);
+ if (y == (char *)MAP_FAILED)
+ perror_exit ("test 3 mmap 2", 15);
+
+ if (y != x + pg)
+ {
+ if (y == x - pg)
+ z = y, y = x, x = z;
+ else
+ {
+ fprintf (stderr, "test 3 nonconsecutive pages - %lx, %lx\n",
+ (unsigned long)x, (unsigned long)y);
+ exit (16);
+ }
+ }
+
+ signal (SIGSEGV, sigsegv);
+ if (setjmp (r))
+ perror_exit ("test 3 fault", 17);
+
+ x[0] = 1;
+ y[0] = 1;
+
+ if (munmap (x, pg*2) < 0)
+ perror_exit ("test 3 munmap", 18);
+
+ if (setjmp (r) == 0)
+ {
+ x[0] = 1;
+ perror_exit ("test 3 no fault 1", 19);
+ }
+
+ signal (SIGSEGV, sigsegv);
+ if (setjmp (r) == 0)
+ {
+ y[0] = 1;
+ perror_exit ("test 3 no fault 2", 20);
+ }
+}
+
+int
+main ()
+{
+ sigemptyset (&unblock_sigsegv);
+ sigaddset (&unblock_sigsegv, SIGSEGV);
+ pg = getpagesize ();
+#ifndef USE_MAP_ANON
+ devzero = open ("/dev/zero", O_RDWR);
+ if (devzero < 0)
+ perror_exit ("open /dev/zero", 1);
+#endif
+
+ test_0();
+ test_1();
+ test_2();
+ test_3();
exit(0);
-}], ac_cv_func_mmap_anywhere=yes, ac_cv_func_mmap_anywhere=no,
-ac_cv_func_mmap_anywhere=no)])
-if test $ac_cv_func_mmap_anywhere = yes; then
- AC_DEFINE(HAVE_MMAP_ANYWHERE, 1,
- [Define if mmap can get us zeroed pages without MAP_FIXED.])
+}
+EOF}}}
+changequote([,])dnl
+
+AC_CACHE_CHECK(for working mmap from /dev/zero,
+ ac_cv_func_mmap_dev_zero,
+[AC_TRY_RUN(
+ [#include "ct-mmap.inc"],
+ ac_cv_func_mmap_dev_zero=yes,
+ [if test $? -lt 4
+ then ac_cv_func_mmap_dev_zero=no
+ else ac_cv_func_mmap_dev_zero=buggy
+ fi],
+ # If this is not cygwin, and /dev/zero is a character device, it's probably
+ # safe to assume it works.
+ [case "$host_os" in
+ cygwin* | win32 | pe | mingw* ) ac_cv_func_mmap_dev_zero=buggy ;;
+ * ) if test -c /dev/zero
+ then ac_cv_func_mmap_dev_zero=yes
+ else ac_cv_func_mmap_dev_zero=no
+ fi ;;
+ esac])
+])
+if test $ac_cv_func_mmap_dev_zero = yes; then
+ AC_DEFINE(HAVE_MMAP_DEV_ZERO, 1,
+ [Define if mmap can get us zeroed pages from /dev/zero.])
+fi
+
+AC_CACHE_CHECK([for working mmap with MAP_ANON(YMOUS)],
+ ac_cv_func_mmap_anon,
+[AC_TRY_RUN(
+ [#define USE_MAP_ANON
+#include "ct-mmap.inc"],
+ ac_cv_func_mmap_anon=yes,
+ [if test $? -lt 4
+ then ac_cv_func_mmap_anon=no
+ else ac_cv_func_mmap_anon=buggy
+ fi],
+ # Unlike /dev/zero, it is not safe to assume MAP_ANON(YMOUS) works
+ # just because it's there. Some SCO Un*xen define it but don't implement it.
+ ac_cv_func_mmap_anon=no)
+])
+if test $ac_cv_func_mmap_anon = yes; then
+ AC_DEFINE(HAVE_MMAP_ANON, 1,
+ [Define if mmap can get us zeroed pages using MAP_ANON(YMOUS).])
fi
+rm -f ct-mmap.inc
])
# Check whether mmap can map a plain file, without MAP_FIXED.
AC_DEFUN([AC_FUNC_MMAP_FILE],
-[AC_REQUIRE([AC_FUNC_MMAP_ANYWHERE])dnl
-AC_CACHE_CHECK(for working mmap of a file, ac_cv_func_mmap_file,
+[AC_CACHE_CHECK(for working mmap of a file, ac_cv_func_mmap_file,
[# Create a file one thousand bytes long.
for i in 1 2 3 4 5 6 7 8 9 0
do for j in 1 2 3 4 5 6 7 8 9 0
[changequote(<<,>>)dnl
ac_prog_version=`<<$>>$1 $3 2>&1 |
sed -n 's/^.*patsubst(<<$4>>,/,\/).*$/\1/p'`
+changequote([,])dnl
echo "configure:__oline__: version of $2 is $ac_prog_version" >&AC_FD_CC
+changequote(<<,>>)dnl
case $ac_prog_version in
'') gcc_cv_prog_$2_modern=no;;
<<$5>>)
gcc_cv_prog_$2_modern=no
fi
])
+
+dnl Determine if enumerated bitfields are unsigned. ISO C says they can
+dnl be either signed or unsigned.
+dnl
+AC_DEFUN(gcc_AC_C_ENUM_BF_UNSIGNED,
+[AC_CACHE_CHECK(for unsigned enumerated bitfields, gcc_cv_enum_bf_unsigned,
+[AC_TRY_RUN(#include <stdlib.h>
+enum t { BLAH = 128 } ;
+struct s_t { enum t member : 8; } s ;
+int main(void)
+{
+ s.member = BLAH;
+ if (s.member < 0) exit(1);
+ exit(0);
+
+}, gcc_cv_enum_bf_unsigned=yes, gcc_cv_enum_bf_unsigned=no, gcc_cv_enum_bf_unsigned=yes)])
+if test $gcc_cv_enum_bf_unsigned = yes; then
+ AC_DEFINE(ENUM_BITFIELDS_ARE_UNSIGNED, 1,
+ [Define if enumerated bitfields are treated as unsigned values.])
+fi])
+
+dnl Host type sizes probe.
+dnl By Kaveh R. Ghazi. One typo fixed since.
+dnl
+AC_DEFUN([gcc_AC_COMPILE_CHECK_SIZEOF],
+[changequote(<<, >>)dnl
+dnl The name to #define.
+define(<<AC_TYPE_NAME>>, translit(sizeof_$1, [a-z *], [A-Z_P]))dnl
+dnl The cache variable name.
+define(<<AC_CV_NAME>>, translit(ac_cv_sizeof_$1, [ *], [_p]))dnl
+changequote([, ])dnl
+AC_MSG_CHECKING(size of $1)
+AC_CACHE_VAL(AC_CV_NAME,
+[for ac_size in 4 8 1 2 16 $3 ; do # List sizes in rough order of prevalence.
+ AC_TRY_COMPILE([#include "confdefs.h"
+#include <sys/types.h>
+$2
+], [switch (0) case 0: case (sizeof ($1) == $ac_size):;], AC_CV_NAME=$ac_size)
+ if test x$AC_CV_NAME != x ; then break; fi
+done
+])
+if test x$AC_CV_NAME = x ; then
+ AC_MSG_ERROR([cannot determine a size for $1])
+fi
+AC_MSG_RESULT($AC_CV_NAME)
+AC_DEFINE_UNQUOTED(AC_TYPE_NAME, $AC_CV_NAME, [The number of bytes in type $1])
+undefine([AC_TYPE_NAME])dnl
+undefine([AC_CV_NAME])dnl
+])
+
+dnl Probe number of bits in a byte.
+dnl Note C89 requires CHAR_BIT >= 8.
+dnl
+AC_DEFUN(gcc_AC_C_CHAR_BIT,
+[AC_CACHE_CHECK(for CHAR_BIT, gcc_cv_decl_char_bit,
+[AC_EGREP_CPP(found,
+[#ifdef HAVE_LIMITS_H
+#include <limits.h>
+#endif
+#ifdef CHAR_BIT
+found
+#endif], gcc_cv_decl_char_bit=yes, gcc_cv_decl_char_bit=no)
+])
+if test $gcc_cv_decl_char_bit = no; then
+ AC_CACHE_CHECK(number of bits in a byte, gcc_cv_c_nbby,
+[i=8
+ gcc_cv_c_nbby=
+ while test $i -lt 65; do
+ AC_TRY_COMPILE(,
+ [switch(0) {
+ case (unsigned char)((unsigned long)1 << $i) == ((unsigned long)1 << $i):
+ case (unsigned char)((unsigned long)1<<($i-1)) == ((unsigned long)1<<($i-1)):
+ ; }],
+ [gcc_cv_c_nbby=$i; break])
+ i=`expr $i + 1`
+ done
+ test -z "$gcc_cv_c_nbby" && gcc_cv_c_nbby=failed
+])
+if test $gcc_cv_c_nbby = failed; then
+ AC_MSG_ERROR(cannot determine number of bits in a byte)
+else
+ AC_DEFINE_UNQUOTED(CHAR_BIT, $gcc_cv_c_nbby,
+ [Define as the number of bits in a byte, if \`limits.h' doesn't.])
+fi
+fi])
+
+dnl Checking for long long.
+dnl By Caolan McNamara <caolan@skynet.ie>
+dnl Added check for __int64, Zack Weinberg <zackw@stanford.edu>
+dnl
+AC_DEFUN([gcc_AC_C_LONG_LONG],
+[AC_CACHE_CHECK(for long long int, ac_cv_c_long_long,
+ [AC_TRY_COMPILE(,[long long int i;],
+ ac_cv_c_long_long=yes,
+ ac_cv_c_long_long=no)])
+ if test $ac_cv_c_long_long = yes; then
+ AC_DEFINE(HAVE_LONG_LONG, 1,
+ [Define if your compiler supports the \`long long' type.])
+ fi
+AC_CACHE_CHECK(for __int64, ac_cv_c___int64,
+ [AC_TRY_COMPILE(,[__int64 i;],
+ ac_cv_c___int64=yes,
+ ac_cv_c___int64=no)])
+ if test $ac_cv_c___int64 = yes; then
+ AC_DEFINE(HAVE___INT64, 1,
+ [Define if your compiler supports the \`__int64' type.])
+ fi
+])
+
+dnl Host character set probe.
+dnl The EBCDIC values match the table in config/i370/i370.c;
+dnl there are other versions of EBCDIC but GCC won't work with them.
+dnl
+AC_DEFUN([gcc_AC_C_CHARSET],
+[AC_CACHE_CHECK(execution character set, ac_cv_c_charset,
+ [AC_EGREP_CPP(ASCII,
+[#if '\n' == 0x0A && ' ' == 0x20 && '0' == 0x30 \
+ && 'A' == 0x41 && 'a' == 0x61 && '!' == 0x21
+ASCII
+#endif], ac_cv_c_charset=ASCII)
+ if test x${ac_cv_c_charset+set} != xset; then
+ AC_EGREP_CPP(EBCDIC,
+[#if '\n' == 0x15 && ' ' == 0x40 && '0' == 0xF0 \
+ && 'A' == 0xC1 && 'a' == 0x81 && '!' == 0x5A
+EBCDIC
+#endif], ac_cv_c_charset=EBCDIC)
+ fi
+ if test x${ac_cv_c_charset+set} != xset; then
+ ac_cv_c_charset=unknown
+ fi])
+if test $ac_cv_c_charset = unknown; then
+ AC_MSG_ERROR([*** Cannot determine host character set.])
+elif test $ac_cv_c_charset = EBCDIC; then
+ AC_DEFINE(HOST_EBCDIC, 1,
+ [Define if the host execution character set is EBCDIC.])
+fi])
+
+dnl Utility macro used by next two tests.
+dnl AC_EXAMINE_OBJECT(C source code,
+dnl commands examining object file,
+dnl [commands to run if compile failed]):
+dnl
+dnl Compile the source code to an object file; then convert it into a
+dnl printable representation. All unprintable characters and
+dnl asterisks (*) are replaced by dots (.). All white space is
+dnl deleted. Newlines (ASCII 0x10) in the input are preserved in the
+dnl output, but runs of newlines are compressed to a single newline.
+dnl Finally, line breaks are forcibly inserted so that no line is
+dnl longer than 80 columns and the file ends with a newline. The
+dnl result of all this processing is in the file conftest.dmp, which
+dnl may be examined by the commands in the second argument.
+dnl
+AC_DEFUN([gcc_AC_EXAMINE_OBJECT],
+[AC_LANG_SAVE
+AC_LANG_C
+dnl Next bit cribbed from AC_TRY_COMPILE.
+cat > conftest.$ac_ext <<EOF
+[#line __oline__ "configure"
+#include "confdefs.h"
+$1
+]EOF
+if AC_TRY_EVAL(ac_compile); then
+ od -c conftest.o |
+ sed ['s/^[0-7]*[ ]*/ /
+ s/\*/./g
+ s/ \\n/*/g
+ s/ [0-9][0-9][0-9]/./g
+ s/ \\[^ ]/./g'] |
+ tr -d '
+ ' | tr -s '*' '
+' | fold | sed '$a\
+' > conftest.dmp
+ $2
+ifelse($3, , , else
+ $3
+)dnl
+fi
+rm -rf conftest*
+AC_LANG_RESTORE])
+
+dnl Host endianness probe.
+dnl This tests byte-within-word endianness. GCC actually needs
+dnl to know word-within-larger-object endianness. They are the
+dnl same on all presently supported hosts.
+dnl Differs from AC_C_BIGENDIAN in that it does not require
+dnl running a program on the host, and it defines the macro we
+dnl want to see.
+dnl
+AC_DEFUN([gcc_AC_C_COMPILE_ENDIAN],
+[AC_CACHE_CHECK(byte ordering, ac_cv_c_compile_endian,
+[ac_cv_c_compile_endian=unknown
+gcc_AC_EXAMINE_OBJECT([
+#ifdef HAVE_LIMITS_H
+# include <limits.h>
+#endif
+/* This structure must have no internal padding. */
+ struct {
+ char prefix[sizeof "\nendian:" - 1];
+ short word;
+ char postfix[2];
+ } tester = {
+ "\nendian:",
+#if SIZEOF_SHORT == 4
+ ('A' << (CHAR_BIT * 3)) | ('B' << (CHAR_BIT * 2)) |
+#endif
+ ('A' << CHAR_BIT) | 'B',
+ 'X', '\n'
+};],
+ [if grep 'endian:AB' conftest.dmp >/dev/null 2>&1; then
+ ac_cv_c_compile_endian=big-endian
+ elif grep 'endian:BA' conftest.dmp >/dev/null 2>&1; then
+ ac_cv_c_compile_endian=little-endian
+ fi])
+])
+if test $ac_cv_c_compile_endian = unknown; then
+ AC_MSG_ERROR([*** unable to determine endianness])
+elif test $ac_cv_c_compile_endian = big-endian; then
+ AC_DEFINE(HOST_WORDS_BIG_ENDIAN, 1,
+ [Define if the host machine stores words of multi-word integers in
+ big-endian order.])
+fi
+])
+
+dnl Floating point format probe.
+dnl The basic concept is the same as the above: grep the object
+dnl file for an interesting string. We have to watch out for
+dnl rounding changing the values in the object, however; this is
+dnl handled by ignoring the least significant byte of the float.
+dnl
+dnl Does not know about VAX G-float or C4x idiosyncratic format.
+dnl It does know about PDP-10 idiosyncratic format, but this is
+dnl not presently supported by GCC. S/390 "binary floating point"
+dnl is in fact IEEE (but maybe we should have that in EBCDIC as well
+dnl as ASCII?)
+dnl
+AC_DEFUN([gcc_AC_C_FLOAT_FORMAT],
+[AC_CACHE_CHECK(floating point format, ac_cv_c_float_format,
+[gcc_AC_EXAMINE_OBJECT(
+[/* This will not work unless sizeof(double) == 8. */
+extern char sizeof_double_must_be_8 [sizeof(double) == 8 ? 1 : -1];
+
+/* This structure must have no internal padding. */
+struct possibility {
+ char prefix[8];
+ double candidate;
+ char postfix[8];
+};
+
+#define C(cand) { "\nformat:", cand, ":tamrof\n" }
+struct possibility table [] =
+{
+ C( 3.25724264705901305206e+01), /* @@IEEEFP - IEEE 754 */
+ C( 3.53802595280598432000e+18), /* D__float - VAX */
+ C( 5.32201830133125317057e-19), /* D.PDP-10 - PDP-10 - the dot is 0x13a */
+ C( 1.77977764695171661377e+10), /* IBMHEXFP - s/390 format, ascii */
+ C(-5.22995989424860458374e+10) /* IBMHEXFP - s/390 format, EBCDIC */
+};],
+ [if grep 'format:.@IEEEF.:tamrof' conftest.dmp >/dev/null 2>&1; then
+ ac_cv_c_float_format='IEEE (big-endian)'
+ elif grep 'format:.I@@PFE.:tamrof' conftest.dmp >/dev/null 2>&1; then
+ ac_cv_c_float_format='IEEE (big-endian)'
+ elif grep 'format:.FEEEI@.:tamrof' conftest.dmp >/dev/null 2>&1; then
+ ac_cv_c_float_format='IEEE (little-endian)'
+ elif grep 'format:.EFP@@I.:tamrof' conftest.dmp >/dev/null 2>&1; then
+ ac_cv_c_float_format='IEEE (little-endian)'
+ elif grep 'format:.__floa.:tamrof' conftest.dmp >/dev/null 2>&1; then
+ ac_cv_c_float_format='VAX D-float'
+ elif grep 'format:..PDP-1.:tamrof' conftest.dmp >/dev/null 2>&1; then
+ ac_cv_c_float_format='PDP-10'
+ elif grep 'format:.BMHEXF.:tamrof' conftest.dmp >/dev/null 2>&1; then
+ ac_cv_c_float_format='IBM 370 hex'
+ else
+ AC_MSG_ERROR(Unknown floating point format)
+ fi],
+ [AC_MSG_ERROR(compile failed)])
+])
+# IEEE is the default format. If the float endianness isn't the same
+# as the integer endianness, we have to set FLOAT_WORDS_BIG_ENDIAN
+# (which is a tristate: yes, no, default). This is only an issue with
+# IEEE; the other formats are only supported by a few machines each,
+# all with the same endianness.
+format=
+fbigend=
+case $ac_cv_c_float_format in
+ 'IEEE (big-endian)' )
+ if test $ac_cv_c_compile_endian = little-endian; then
+ fbigend=1
+ fi
+ ;;
+ 'IEEE (little-endian)' )
+ if test $ac_cv_c_compile_endian = big-endian; then
+ fbigend=0
+ fi
+ ;;
+ 'VAX D-float' )
+ format=VAX_FLOAT_FORMAT
+ ;;
+ 'PDP-10' )
+ format=PDP10_FLOAT_FORMAT
+ ;;
+ 'IBM 370 hex' )
+ format=IBM_FLOAT_FORMAT
+ ;;
+esac
+if test -n "$format"; then
+ AC_DEFINE_UNQUOTED(HOST_FLOAT_FORMAT, $format,
+ [Define to the floating point format of the host machine, if not IEEE.])
+fi
+if test -n "$fbigend"; then
+ AC_DEFINE_UNQUOTED(HOST_FLOAT_WORDS_BIG_ENDIAN, $fbigend,
+ [Define to 1 if the host machine stores floating point numbers in
+ memory with the word containing the sign bit at the lowest address,
+ or to 0 if it does it the other way around.
+
+ This macro should not be defined if the ordering is the same as for
+ multi-word integers.])
+fi
+])
+
+#serial AM2
+
+dnl From Bruno Haible.
+
+AC_DEFUN([AM_ICONV],
+[
+ dnl Some systems have iconv in libc, some have it in libiconv (OSF/1 and
+ dnl those with the standalone portable GNU libiconv installed).
+
+ AC_ARG_WITH([libiconv-prefix],
+[ --with-libiconv-prefix=DIR search for libiconv in DIR/include and DIR/lib], [
+ for dir in `echo "$withval" | tr : ' '`; do
+ if test -d $dir/include; then CPPFLAGS="$CPPFLAGS -I$dir/include"; fi
+ if test -d $dir/lib; then LDFLAGS="$LDFLAGS -L$dir/lib"; fi
+ done
+ ])
+
+ AC_CACHE_CHECK(for iconv, am_cv_func_iconv, [
+ am_cv_func_iconv="no, consider installing GNU libiconv"
+ am_cv_lib_iconv=no
+ AC_TRY_LINK([#include <stdlib.h>
+#include <iconv.h>],
+ [iconv_t cd = iconv_open("","");
+ iconv(cd,NULL,NULL,NULL,NULL);
+ iconv_close(cd);],
+ am_cv_func_iconv=yes)
+ if test "$am_cv_func_iconv" != yes; then
+ am_save_LIBS="$LIBS"
+ LIBS="$LIBS -liconv"
+ AC_TRY_LINK([#include <stdlib.h>
+#include <iconv.h>],
+ [iconv_t cd = iconv_open("","");
+ iconv(cd,NULL,NULL,NULL,NULL);
+ iconv_close(cd);],
+ am_cv_lib_iconv=yes
+ am_cv_func_iconv=yes)
+ LIBS="$am_save_LIBS"
+ fi
+ ])
+ if test "$am_cv_func_iconv" = yes; then
+ AC_DEFINE(HAVE_ICONV, 1, [Define if you have the iconv() function.])
+ AC_MSG_CHECKING([for iconv declaration])
+ AC_CACHE_VAL(am_cv_proto_iconv, [
+ AC_TRY_COMPILE([
+#include <stdlib.h>
+#include <iconv.h>
+extern
+#ifdef __cplusplus
+"C"
+#endif
+#if defined(__STDC__) || defined(__cplusplus)
+size_t iconv (iconv_t cd, char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);
+#else
+size_t iconv();
+#endif
+], [], am_cv_proto_iconv_arg1="", am_cv_proto_iconv_arg1="const")
+ am_cv_proto_iconv="extern size_t iconv (iconv_t cd, $am_cv_proto_iconv_arg1 char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);"])
+ am_cv_proto_iconv=`echo "[$]am_cv_proto_iconv" | tr -s ' ' | sed -e 's/( /(/'`
+ AC_MSG_RESULT([$]{ac_t:-
+ }[$]am_cv_proto_iconv)
+ AC_DEFINE_UNQUOTED(ICONV_CONST, $am_cv_proto_iconv_arg1,
+ [Define as const if the declaration of iconv() needs const.])
+ fi
+ LIBICONV=
+ if test "$am_cv_lib_iconv" = yes; then
+ LIBICONV="-liconv"
+ fi
+ AC_SUBST(LIBICONV)
+])
OSDN Git Service
