| dnl MPFR specific autoconf macros |
| |
| dnl Copyright 2000, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. |
| dnl Contributed by the Arenaire and Cacao projects, INRIA. |
| dnl |
| dnl This file is part of the GNU MPFR Library. |
| dnl |
| dnl The GNU MPFR Library is free software; you can redistribute it and/or modify |
| dnl it under the terms of the GNU Lesser General Public License as published |
| dnl by the Free Software Foundation; either version 2.1 of the License, or (at |
| dnl your option) any later version. |
| dnl |
| dnl The GNU MPFR Library is distributed in the hope that it will be useful, but |
| dnl WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY |
| dnl or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public |
| dnl License for more details. |
| dnl |
| dnl You should have received a copy of the GNU Lesser General Public License |
| dnl along with the GNU MPFR Library; see the file COPYING.LIB. If not, write to |
| dnl the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, |
| dnl MA 02110-1301, USA. |
| |
| dnl autoconf 2.60 is necessary because of the use of AC_PROG_SED. |
| dnl The following line allows the autoconf wrapper (when installed) |
| dnl to work as expected. |
| AC_PREREQ(2.60) |
| |
| dnl ------------------------------------------------------------ |
| dnl You must put in MPFR_CONFIGS everything which configure MPFR |
| dnl except: |
| dnl -everything dealing with CC and CFLAGS in particular the ABI |
| dnl but the IEEE-754 specific flags must be set here. |
| dnl -GMP's linkage. |
| dnl -Libtool stuff. |
| dnl -Handling of special arguments of MPFR's configure. |
| AC_DEFUN([MPFR_CONFIGS], |
| [ |
| AC_REQUIRE([AC_OBJEXT]) |
| AC_REQUIRE([MPFR_CHECK_LIBM]) |
| AC_REQUIRE([AC_HEADER_TIME]) |
| AC_REQUIRE([AC_CANONICAL_HOST]) |
| |
| AC_CHECK_HEADER([limits.h],, AC_MSG_ERROR([limits.h not found])) |
| AC_CHECK_HEADER([float.h],, AC_MSG_ERROR([float.h not found])) |
| AC_CHECK_HEADER([string.h],, AC_MSG_ERROR([string.h not found])) |
| |
| dnl Check for locales |
| AC_CHECK_HEADERS([locale.h]) |
| |
| dnl Check for wide characters (wchar_t and wint_t) |
| AC_CHECK_HEADERS([wchar.h]) |
| |
| dnl Check for stdargs |
| AC_CHECK_HEADER([stdarg.h],[AC_DEFINE([HAVE_STDARG],1,[Define if stdarg])], |
| [AC_CHECK_HEADER([varargs.h],, |
| AC_MSG_ERROR([stdarg.h or varargs.h not found]))]) |
| |
| dnl sys/fpu.h - MIPS specific |
| AC_CHECK_HEADERS([sys/time.h sys/fpu.h]) |
| |
| dnl SIZE_MAX macro |
| gl_SIZE_MAX |
| |
| dnl va_copy macro |
| AC_MSG_CHECKING([how to copy va_list]) |
| AC_LINK_IFELSE([AC_LANG_PROGRAM([[ |
| #include <stdarg.h> |
| ]], [[ |
| va_list ap1, ap2; |
| va_copy(ap1, ap2); |
| ]])], AC_MSG_RESULT([va_copy]), |
| [AC_LINK_IFELSE([AC_LANG_PROGRAM([[ |
| #include <stdarg.h> |
| ]], [[ |
| va_list ap1, ap2; |
| __va_copy(ap1, ap2); |
| ]])], [AC_DEFINE([va_copy], [__va_copy]) AC_MSG_RESULT([__va_copy])], |
| [AC_DEFINE([va_copy(dest,src)], [memcpy(&dest,&src,sizeof(va_list))]) |
| AC_MSG_RESULT([memcpy])]) |
| ]) |
| |
| dnl FIXME: The functions memmove, memset and strtol are really needed by |
| dnl MPFR, but if they are implemented as macros, this is also OK (in our |
| dnl case). So, we do not return an error, but their tests are currently |
| dnl useless. |
| dnl gettimeofday is not defined for MinGW |
| AC_CHECK_FUNCS([memmove memset setlocale strtol gettimeofday]) |
| |
| dnl Check for IEEE-754 switches on Alpha |
| case $host in |
| alpha*-*-*) |
| saved_CFLAGS="$CFLAGS" |
| AC_CACHE_CHECK([for IEEE-754 switches], mpfr_cv_ieee_switches, [ |
| if test -n "$GCC"; then |
| mpfr_cv_ieee_switches="-mfp-rounding-mode=d -mieee-with-inexact" |
| else |
| mpfr_cv_ieee_switches="-fprm d -ieee_with_inexact" |
| fi |
| CFLAGS="$CFLAGS $mpfr_cv_ieee_switches" |
| AC_TRY_COMPILE(,,, mpfr_cv_ieee_switches="none") |
| ]) |
| if test "$mpfr_cv_ieee_switches" = "none"; then |
| CFLAGS="$saved_CFLAGS" |
| else |
| CFLAGS="$saved_CFLAGS $mpfr_cv_ieee_switches" |
| fi |
| esac |
| |
| dnl Check for Core2 processor |
| case $host in |
| x86_64-*linux*) |
| case `sed -n '/^vendor_id/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in |
| *Intel*) AC_DEFINE(HAVE_HOST_CORE2,1,[Define if processor is Core 2]) ;; |
| esac |
| esac |
| |
| dnl check for long long |
| AC_CHECK_TYPE([long long int], |
| AC_DEFINE(HAVE_LONG_LONG, 1, [Define if compiler supports long long]),,) |
| |
| dnl intmax_t is C99 |
| AC_CHECK_TYPES([intmax_t]) |
| |
| AC_CHECK_TYPE( [union fpc_csr], |
| AC_DEFINE(HAVE_FPC_CSR,1,[Define if union fpc_csr is available]), , |
| [ |
| #if HAVE_SYS_FPU_H |
| # include <sys/fpu.h> |
| #endif |
| ]) |
| |
| dnl Check for fesetround |
| AC_CACHE_CHECK([for fesetround], mpfr_cv_have_fesetround, [ |
| saved_LIBS="$LIBS" |
| LIBS="$LIBS $MPFR_LIBM" |
| AC_TRY_LINK([#include <fenv.h>], [fesetround(FE_TONEAREST);], |
| mpfr_cv_have_fesetround=yes, mpfr_cv_have_fesetround=no) |
| LIBS="$saved_LIBS" |
| ]) |
| if test "$mpfr_cv_have_fesetround" = "yes"; then |
| AC_DEFINE(MPFR_HAVE_FESETROUND,1,[Define if you have the `fesetround' function via the <fenv.h> header file.]) |
| fi |
| |
| dnl Check for gcc float-conversion bug; if need be, -ffloat-store is used to |
| dnl force the conversion to the destination type when a value is stored to |
| dnl a variable (see ISO C99 standard 5.1.2.3#13, 6.3.1.5#2, 6.3.1.8#2). This |
| dnl is important concerning the exponent range. Note that this doesn't solve |
| dnl the double-rounding problem. |
| if test -n "$GCC"; then |
| AC_CACHE_CHECK([for gcc float-conversion bug], mpfr_cv_gcc_floatconv_bug, [ |
| saved_LIBS="$LIBS" |
| LIBS="$LIBS $MPFR_LIBM" |
| AC_TRY_RUN([ |
| #include <float.h> |
| #ifdef MPFR_HAVE_FESETROUND |
| #include <fenv.h> |
| #endif |
| static double get_max (void); |
| int main() { |
| double x = 0.5; |
| int i; |
| for (i = 1; i <= 11; i++) |
| x *= x; |
| if (x != 0) |
| return 1; |
| #ifdef MPFR_HAVE_FESETROUND |
| /* Useful test for the G4 PowerPC */ |
| fesetround(FE_TOWARDZERO); |
| x = get_max (); |
| x *= 2.0; |
| if (x != get_max ()) |
| return 1; |
| #endif |
| return 0; |
| } |
| static double get_max (void) { return DBL_MAX; } |
| ], [mpfr_cv_gcc_floatconv_bug="no"], |
| [mpfr_cv_gcc_floatconv_bug="yes, use -ffloat-store"], |
| [mpfr_cv_gcc_floatconv_bug="cannot test, use -ffloat-store"]) |
| LIBS="$saved_LIBS" |
| ]) |
| if test "$mpfr_cv_gcc_floatconv_bug" != "no"; then |
| CFLAGS="$CFLAGS -ffloat-store" |
| fi |
| fi |
| |
| dnl Check if denormalized numbers are supported |
| AC_CACHE_CHECK([for denormalized numbers], mpfr_cv_have_denorms, [ |
| AC_TRY_RUN([ |
| #include <math.h> |
| #include <stdio.h> |
| int main() { |
| double x = 2.22507385850720138309e-308; |
| fprintf (stderr, "%e\n", x / 2.0); |
| return 2.0 * (x / 2.0) != x; |
| } |
| ], mpfr_cv_have_denorms=yes, mpfr_cv_have_denorms=no, mpfr_cv_have_denorms=no) |
| ]) |
| if test "$mpfr_cv_have_denorms" = "yes"; then |
| AC_DEFINE(HAVE_DENORMS,1,[Define if denormalized floats work.]) |
| fi |
| |
| dnl Check whether NAN != NAN (as required by the IEEE-754 standard, |
| dnl but not by the ISO C standard). For instance, this is false with |
| dnl MIPSpro 7.3.1.3m under IRIX64. By default, assume this is true. |
| AC_CACHE_CHECK([if NAN == NAN], mpfr_cv_nanisnan, [ |
| AC_TRY_RUN([ |
| #include <stdio.h> |
| #include <math.h> |
| #ifndef NAN |
| # define NAN (0.0/0.0) |
| #endif |
| int main() { |
| double d; |
| d = NAN; |
| return d != d; |
| } |
| ], [mpfr_cv_nanisnan="yes"], |
| [mpfr_cv_nanisnan="no"], |
| [mpfr_cv_nanisnan="cannot test, assume no"]) |
| ]) |
| if test "$mpfr_cv_nanisnan" = "yes"; then |
| AC_DEFINE(MPFR_NANISNAN,1,[Define if NAN == NAN.]) |
| AC_MSG_WARN([The test NAN != NAN is false. The probable reason is that]) |
| AC_MSG_WARN([your compiler optimizes floating-point expressions in an]) |
| AC_MSG_WARN([unsafe way because some option, such as -ffast-math or]) |
| AC_MSG_WARN([-fast (depending on the compiler), has been used. You]) |
| AC_MSG_WARN([should NOT use such an option, otherwise MPFR functions]) |
| AC_MSG_WARN([such as mpfr_get_d and mpfr_set_d may return incorrect]) |
| AC_MSG_WARN([results on special FP numbers (e.g. NaN or signed zeros).]) |
| AC_MSG_WARN([If you did not use such an option, please send us a bug]) |
| AC_MSG_WARN([report so that we can try to find a workaround for your]) |
| AC_MSG_WARN([platform and/or document the behavior.]) |
| fi |
| |
| dnl Check if the chars '0' to '9' are consecutive values |
| AC_MSG_CHECKING([if charset has consecutive values]) |
| AC_RUN_IFELSE(AC_LANG_PROGRAM([[ |
| char *number = "0123456789"; |
| char *lower = "abcdefghijklmnopqrstuvwxyz"; |
| char *upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; |
| ]],[[ |
| int i; |
| unsigned char *p; |
| for (p = (unsigned char*) number, i = 0; i < 9; i++) |
| if ( (*p)+1 != *(p+1) ) return 1; |
| for (p = (unsigned char*) lower, i = 0; i < 25; i++) |
| if ( (*p)+1 != *(p+1) ) return 1; |
| for (p = (unsigned char*) upper, i = 0; i < 25; i++) |
| if ( (*p)+1 != *(p+1) ) return 1; |
| ]]), [AC_MSG_RESULT(yes)],[ |
| AC_MSG_RESULT(no) |
| AC_DEFINE(MPFR_NO_CONSECUTIVE_CHARSET,1,[Charset is not consecutive]) |
| ], [AC_MSG_RESULT(can not test)]) |
| |
| dnl Must be checked with the LIBM |
| dnl but we don't want to add the LIBM to MPFR dependency. |
| dnl Can't use AC_CHECK_FUNCS since the function may be in LIBM but |
| dnl not exported in math.h |
| saved_LIBS="$LIBS" |
| LIBS="$LIBS $MPFR_LIBM" |
| dnl AC_CHECK_FUNCS([round trunc floor ceil nearbyint]) |
| AC_MSG_CHECKING(for math/round) |
| AC_LINK_IFELSE([AC_LANG_PROGRAM([[ |
| #include <math.h> |
| int f (double (*func)(double)) { return 0;} |
| ]], [[ |
| double a = 17.42; |
| a = f (round); |
| return 0; |
| ]])], [ |
| AC_MSG_RESULT(yes) |
| AC_DEFINE(HAVE_ROUND, 1,[Have ISO-C99 round function]) |
| ],[AC_MSG_RESULT(no)]) |
| |
| AC_MSG_CHECKING(for math/trunc) |
| AC_LINK_IFELSE([AC_LANG_PROGRAM([[ |
| #include <math.h> |
| int f (double (*func)(double)) { return 0;} |
| ]], [[ |
| double a = 17.42; |
| a = f(trunc); |
| return 0; |
| ]])], [ |
| AC_MSG_RESULT(yes) |
| AC_DEFINE(HAVE_TRUNC, 1,[Have ISO-C99 trunc function]) |
| ],[AC_MSG_RESULT(no)]) |
| |
| AC_MSG_CHECKING(for math/floor) |
| AC_LINK_IFELSE([AC_LANG_PROGRAM([[ |
| #include <math.h> |
| int f (double (*func)(double)) { return 0;} |
| ]], [[ |
| double a = 17.42; |
| a = f(floor); |
| return 0; |
| ]])], [ |
| AC_MSG_RESULT(yes) |
| AC_DEFINE(HAVE_FLOOR, 1,[Have ISO-C99 floor function]) |
| ],[AC_MSG_RESULT(no)]) |
| |
| AC_MSG_CHECKING(for math/ceil) |
| AC_LINK_IFELSE([AC_LANG_PROGRAM([[ |
| #include <math.h> |
| int f (double (*func)(double)) { return 0;} |
| ]], [[ |
| double a = 17.42; |
| a = f(ceil); |
| return 0; |
| ]])], [ |
| AC_MSG_RESULT(yes) |
| AC_DEFINE(HAVE_CEIL, 1,[Have ISO-C99 ceil function]) |
| ],[AC_MSG_RESULT(no)]) |
| |
| AC_MSG_CHECKING(for math/rint) |
| AC_LINK_IFELSE([AC_LANG_PROGRAM([[ |
| #include <math.h> |
| int f (double (*func)(double)) { return 0;} |
| ]], [[ |
| double a = 17.42; |
| a = f(nearbyint); |
| return 0; |
| ]])], [ |
| AC_MSG_RESULT(yes) |
| AC_DEFINE(HAVE_NEARBYINT, 1,[Have ISO-C99 rint function]) |
| ],[AC_MSG_RESULT(no)]) |
| |
| LIBS="$saved_LIBS" |
| |
| dnl Now try to check the long double format |
| MPFR_C_LONG_DOUBLE_FORMAT |
| |
| dnl Check if thread-local variables are supported. |
| dnl At least two problems can occur in practice: |
| dnl 1. The compilation fails, e.g. because the compiler doesn't know |
| dnl about the __thread keyword. |
| dnl 2. The compilation succeeds, but the system doesn't support TLS or |
| dnl there is some ld configuration problem. One of the effects can |
| dnl be that thread-local variables always evaluate to 0. So, it is |
| dnl important to run the test below. |
| if test "$enable_thread_safe" = yes; then |
| AC_CACHE_CHECK([for TLS support], mpfr_cv_working_tls, [ |
| saved_CPPFLAGS="$CPPFLAGS" |
| # The -I$srcdir is necessary when objdir is different from srcdir. |
| CPPFLAGS="$CPPFLAGS -I$srcdir" |
| AC_RUN_IFELSE([ |
| #define MPFR_USE_THREAD_SAFE 1 |
| #include "mpfr-thread.h" |
| MPFR_THREAD_ATTR int x = 17; |
| int main() { |
| return x != 17; |
| } |
| ], [mpfr_cv_working_tls="yes"], |
| [AC_MSG_RESULT(no) |
| AC_MSG_ERROR([please configure with --disable-thread-safe])], |
| [mpfr_cv_working_tls="cannot test, assume yes"]) |
| CPPFLAGS="$saved_CPPFLAGS" |
| ]) |
| fi |
| ]) |
| |
| |
| dnl MPFR_C_LONG_DOUBLE_FORMAT |
| dnl ------------------------- |
| dnl Determine the format of a long double. |
| dnl |
| dnl The object file is grepped, so as to work when cross compiling. A |
| dnl start and end sequence is included to avoid false matches, and |
| dnl allowance is made for the desired data crossing an "od -b" line |
| dnl boundary. The test number is a small integer so it should appear |
| dnl exactly, no rounding or truncation etc. |
| dnl |
| dnl "od -b" is supported even by Unix V7, and the awk script used doesn't |
| dnl have functions or anything, so even an "old" awk should suffice. |
| dnl |
| dnl The 10-byte IEEE extended format is generally padded to either 12 or 16 |
| dnl bytes for alignment purposes. The SVR4 i386 ABI is 12 bytes, or i386 |
| dnl gcc -m128bit-long-double selects 16 bytes. IA-64 is 16 bytes in LP64 |
| dnl mode, or 12 bytes in ILP32 mode. The first 10 bytes is the relevant |
| dnl part in all cases (big and little endian). |
| dnl |
| dnl Enhancements: |
| dnl |
| dnl Could match more formats, but no need to worry until there's code |
| dnl wanting to use them. |
| dnl |
| dnl Don't want to duplicate the double matching from GMP_C_DOUBLE_FORMAT, |
| dnl perhaps we should merge with that macro, to match data formats |
| dnl irrespective of the C type in question. Or perhaps just let the code |
| dnl use DOUBLE macros when sizeof(double)==sizeof(long double). |
| |
| AC_DEFUN([MPFR_C_LONG_DOUBLE_FORMAT], |
| [AC_REQUIRE([AC_PROG_CC]) |
| AC_REQUIRE([AC_PROG_AWK]) |
| AC_REQUIRE([AC_OBJEXT]) |
| AC_CHECK_TYPES([long double]) |
| AC_CACHE_CHECK([format of `long double' floating point], |
| mpfr_cv_c_long_double_format, |
| [mpfr_cv_c_long_double_format=unknown |
| if test "$ac_cv_type_long_double" != yes; then |
| mpfr_cv_c_long_double_format="not available" |
| else |
| cat >conftest.c <<\EOF |
| [ |
| /* "before" is 16 bytes to ensure there's no padding between it and "x". |
| We're not expecting any "long double" bigger than 16 bytes or with |
| alignment requirements stricter than 16 bytes. */ |
| struct { |
| char before[16]; |
| long double x; |
| char after[8]; |
| } foo = { |
| { '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', |
| '\001', '\043', '\105', '\147', '\211', '\253', '\315', '\357' }, |
| -123456789.0, |
| { '\376', '\334', '\272', '\230', '\166', '\124', '\062', '\020' } |
| }; |
| ] |
| EOF |
| mpfr_compile="$CC $CFLAGS $CPPFLAGS -c conftest.c >&AC_FD_CC 2>&1" |
| if AC_TRY_EVAL(mpfr_compile); then |
| cat >conftest.awk <<\EOF |
| [ |
| BEGIN { |
| found = 0 |
| } |
| |
| # got[] holds a sliding window of bytes read the input. got[0] is the most |
| # recent byte read, and got[31] the oldest byte read, so when looking to |
| # match some data the indices are "reversed". |
| # |
| { |
| for (f = 2; f <= NF; f++) |
| { |
| # new byte, shift others up |
| for (i = 31; i >= 0; i--) |
| got[i+1] = got[i]; |
| got[0] = $f; |
| |
| # end sequence |
| if (got[7] != "376") continue |
| if (got[6] != "334") continue |
| if (got[5] != "272") continue |
| if (got[4] != "230") continue |
| if (got[3] != "166") continue |
| if (got[2] != "124") continue |
| if (got[1] != "062") continue |
| if (got[0] != "020") continue |
| |
| # start sequence, with 12-byte body |
| if (got[27] == "001" && \ |
| got[26] == "043" && \ |
| got[25] == "105" && \ |
| got[24] == "147" && \ |
| got[23] == "211" && \ |
| got[22] == "253" && \ |
| got[21] == "315" && \ |
| got[20] == "357") |
| { |
| saw = " (" got[19] \ |
| " " got[18] \ |
| " " got[17] \ |
| " " got[16] \ |
| " " got[15] \ |
| " " got[14] \ |
| " " got[13] \ |
| " " got[12] \ |
| " " got[11] \ |
| " " got[10] \ |
| " " got[9] \ |
| " " got[8] ")" |
| |
| if (got[19] == "000" && \ |
| got[18] == "000" && \ |
| got[17] == "000" && \ |
| got[16] == "000" && \ |
| got[15] == "240" && \ |
| got[14] == "242" && \ |
| got[13] == "171" && \ |
| got[12] == "353" && \ |
| got[11] == "031" && \ |
| got[10] == "300") |
| { |
| print "IEEE extended, little endian" |
| found = 1 |
| exit |
| } |
| } |
| |
| # start sequence, with 16-byte body |
| if (got[31] == "001" && \ |
| got[30] == "043" && \ |
| got[29] == "105" && \ |
| got[28] == "147" && \ |
| got[27] == "211" && \ |
| got[26] == "253" && \ |
| got[25] == "315" && \ |
| got[24] == "357") |
| { |
| saw = " (" got[23] \ |
| " " got[22] \ |
| " " got[21] \ |
| " " got[20] \ |
| " " got[19] \ |
| " " got[18] \ |
| " " got[17] \ |
| " " got[16] \ |
| " " got[15] \ |
| " " got[14] \ |
| " " got[13] \ |
| " " got[12] \ |
| " " got[11] \ |
| " " got[10] \ |
| " " got[9] \ |
| " " got[8] ")" |
| |
| if (got[23] == "000" && \ |
| got[22] == "000" && \ |
| got[21] == "000" && \ |
| got[20] == "000" && \ |
| got[19] == "240" && \ |
| got[18] == "242" && \ |
| got[17] == "171" && \ |
| got[16] == "353" && \ |
| got[15] == "031" && \ |
| got[14] == "300") |
| { |
| print "IEEE extended, little endian" |
| found = 1 |
| exit |
| } |
| |
| if (got[23] == "300" && \ |
| got[22] == "031" && \ |
| got[21] == "326" && \ |
| got[20] == "363" && \ |
| got[19] == "105" && \ |
| got[18] == "100" && \ |
| got[17] == "000" && \ |
| got[16] == "000" && \ |
| got[15] == "000" && \ |
| got[14] == "000" && \ |
| got[13] == "000" && \ |
| got[12] == "000" && \ |
| got[11] == "000" && \ |
| got[10] == "000" && \ |
| got[9] == "000" && \ |
| got[8] == "000") |
| { |
| print "IEEE quad, big endian" |
| found = 1 |
| exit |
| } |
| } |
| } |
| } |
| |
| END { |
| if (! found) |
| print "unknown", saw |
| } |
| ] |
| EOF |
| mpfr_cv_c_long_double_format=`od -b conftest.$OBJEXT | $AWK -f conftest.awk` |
| case $mpfr_cv_c_long_double_format in |
| unknown*) |
| echo "cannot match anything, conftest.$OBJEXT contains" >&AC_FD_CC |
| od -b conftest.$OBJEXT >&AC_FD_CC |
| ;; |
| esac |
| else |
| AC_MSG_WARN([oops, cannot compile test program]) |
| fi |
| fi |
| rm -f conftest* |
| ]) |
| |
| AH_VERBATIM([HAVE_LDOUBLE], |
| [/* Define one of the following to 1 for the format of a `long double'. |
| If your format is not among these choices, or you don't know what it is, |
| then leave all undefined. |
| IEEE_EXT is the 10-byte IEEE extended precision format. |
| IEEE_QUAD is the 16-byte IEEE quadruple precision format. |
| LITTLE or BIG is the endianness. */ |
| #undef HAVE_LDOUBLE_IEEE_EXT_LITTLE |
| #undef HAVE_LDOUBLE_IEEE_QUAD_BIG]) |
| |
| case $mpfr_cv_c_long_double_format in |
| "IEEE extended, little endian") |
| AC_DEFINE(HAVE_LDOUBLE_IEEE_EXT_LITTLE, 1) |
| ;; |
| "IEEE quad, big endian") |
| AC_DEFINE(HAVE_LDOUBLE_IEEE_QUAD_BIG, 1) |
| ;; |
| unknown* | "not available") |
| ;; |
| *) |
| AC_MSG_WARN([oops, unrecognised float format: $mpfr_cv_c_long_double_format]) |
| ;; |
| esac |
| ]) |
| |
| |
| dnl MPFR_CHECK_LIBM |
| dnl --------------- |
| dnl Determine a math library -lm to use. |
| |
| AC_DEFUN([MPFR_CHECK_LIBM], |
| [AC_REQUIRE([AC_CANONICAL_HOST]) |
| AC_SUBST(MPFR_LIBM,'') |
| case $host in |
| *-*-beos* | *-*-cygwin* | *-*-pw32*) |
| # According to libtool AC CHECK LIBM, these systems don't have libm |
| ;; |
| *-*-hpux*) |
| # -lM means something subtly different to -lm, SVID style error handling |
| # or something. FIXME: Why exactly do we want this? |
| AC_CHECK_LIB(M, main, MPFR_LIBM="-lM") |
| ;; |
| *-*-solaris*) |
| # On Solaris the math functions new in C99 are in -lm9x. |
| # FIXME: Do we need -lm9x as well as -lm, or just instead of? |
| AC_CHECK_LIB(m9x, main, MPFR_LIBM="-lm9x") |
| AC_CHECK_LIB(m, main, MPFR_LIBM="$MPFR_LIBM -lm") |
| ;; |
| *-ncr-sysv4.3*) |
| # FIXME: What does -lmw mean? Libtool AC CHECK LIBM does it this way. |
| AC_CHECK_LIB(mw, _mwvalidcheckl, MPFR_LIBM="-lmw") |
| AC_CHECK_LIB(m, main, MPFR_LIBM="$MPFR_LIBM -lm") |
| ;; |
| *) |
| AC_CHECK_LIB(m, main, MPFR_LIBM="-lm") |
| ;; |
| esac |
| ]) |
| |
| |
| dnl MPFR_LD_SEARCH_PATHS_FIRST |
| dnl -------------------------- |
| |
| AC_DEFUN([MPFR_LD_SEARCH_PATHS_FIRST], |
| [case "$LD $LDFLAGS" in |
| *-Wl,-search_paths_first*) ;; |
| *) AC_MSG_CHECKING([if the compiler understands -Wl,-search_paths_first]) |
| saved_LDFLAGS="$LDFLAGS" |
| LDFLAGS="-Wl,-search_paths_first $LDFLAGS" |
| AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[]])], |
| [AC_MSG_RESULT(yes)], |
| [AC_MSG_RESULT(no)] |
| LDFLAGS="$saved_LDFLAGS") |
| ;; |
| esac |
| ]) |
| |
| |
| dnl GMP_C_ATTRIBUTE_MODE |
| dnl -------------------- |
| dnl Introduced in gcc 2.2, but perhaps not in all Apple derived versions. |
| dnl Needed for mpfr-longlong.h; this is currently necessary for s390. |
| dnl |
| dnl TODO: Replace this with a cleaner type size detection, as this |
| dnl solution only works with gcc and assumes CHAR_BIT == 8. Probably use |
| dnl <stdint.h>, and <http://gcc.gnu.org/viewcvs/trunk/config/stdint.m4> |
| dnl as a fallback. |
| |
| AC_DEFUN([GMP_C_ATTRIBUTE_MODE], |
| [AC_CACHE_CHECK([whether gcc __attribute__ ((mode (XX))) works], |
| gmp_cv_c_attribute_mode, |
| [AC_TRY_COMPILE([typedef int SItype __attribute__ ((mode (SI)));], , |
| gmp_cv_c_attribute_mode=yes, gmp_cv_c_attribute_mode=no) |
| ]) |
| if test $gmp_cv_c_attribute_mode = yes; then |
| AC_DEFINE(HAVE_ATTRIBUTE_MODE, 1, |
| [Define to 1 if the compiler accepts gcc style __attribute__ ((mode (XX)))]) |
| fi |
| ]) |
| |
| |
| dnl MPFR_FUNC_PRINTF_SPEC |
| dnl ------------------------------------ |
| dnl MPFR_FUNC_PRINTF_SPEC(spec, type, [includes], [lib-prefix], [if-true], [if-false]) |
| dnl Check if printf supports the conversion specification 'spec' |
| dnl with type 'type'. |
| dnl Expand 'if-true' if printf supports 'spec', 'if-false' otherwise. |
| |
| AC_DEFUN([MPFR_FUNC_PRINTF_SPEC],[ |
| AC_MSG_CHECKING(if $4printf supports "$1") |
| AC_RUN_IFELSE([AC_LANG_PROGRAM([[ |
| #include <stdio.h> |
| $3 |
| ]], [[ |
| char s[256]; |
| $2 a = 0; |
| return ($4sprintf (s, "$1", a) != 1) ? 1 : 0; |
| ]])], |
| [AC_MSG_RESULT(yes) |
| $5], |
| [AC_MSG_RESULT(no) |
| $6]) |
| ]) |
| |
| |
| dnl MPFR_CHECK_PRINTF_SPEC |
| dnl ---------------------- |
| dnl Check if libc printf and gmp_printf support some optional length |
| dnl modifiers. |
| dnl Defined symbols are negative to shorten the gcc command line. |
| |
| AC_DEFUN([MPFR_CHECK_PRINTF_SPEC], [ |
| AC_REQUIRE([MPFR_CONFIGS])dnl |
| if test "$ac_cv_type_intmax_t" == yes; then |
| MPFR_FUNC_PRINTF_SPEC([%jd], [intmax_t], [ |
| #ifdef HAVE_STDINT_H |
| # include <stdint.h> |
| #endif |
| #ifdef HAVE_INTTYPES_H |
| # include <inttypes.h> |
| #endif |
| |
| #include <gmp.h> |
| ], [gmp_],, |
| [AC_DEFINE([NPRINTF_J], 1, [gmp_printf cannot read intmax_t])]) |
| fi |
| |
| MPFR_FUNC_PRINTF_SPEC([%hhd], [char], [ |
| #include <gmp.h> |
| ], [gmp_],, |
| [AC_DEFINE([NPRINTF_HH], 1, [gmp_printf cannot use 'hh' length modifier])]) |
| |
| MPFR_FUNC_PRINTF_SPEC([%lld], [long long int], [ |
| #include <gmp.h> |
| ], [gmp_],, |
| [AC_DEFINE([NPRINTF_LL], 1, [gmp_printf cannot read long long int])]) |
| |
| MPFR_FUNC_PRINTF_SPEC([%.0Lf], [long double], [ |
| #include <gmp.h> |
| ], [gmp_],, |
| [AC_DEFINE([NPRINTF_L], 1, [gmp_printf cannot read long double])]) |
| |
| MPFR_FUNC_PRINTF_SPEC([%td], [ptrdiff_t], [ |
| #if defined (__cplusplus) |
| #include <cstddef> |
| #else |
| #include <stddef.h> |
| #endif |
| #include "gmp.h" |
| ], [gmp_],, |
| [AC_DEFINE([NPRINTF_T], 1, [gmp_printf cannot read ptrdiff_t])]) |
| ]) |