libgfortran/acinclude.m4

   1 dnl Check:
   2 dnl * If we have gettimeofday;
   3 dnl * If we have struct timezone for use in calling it;
   4 dnl * If calling it with a timezone pointer actually works -- this is deemed
   5 dnl   obsolete or undefined on some systems which say you should use a null
   6 dnl   pointer -- and undefine HAVE_TIMEZONE if so;
   7 dnl * Whether it only takes one arg.
   8 AC_DEFUN([LIBGFOR_GETTIMEOFDAY], [
   9   AC_CHECK_FUNCS(gettimeofday)
  10   if test "$ac_cv_func_gettimeofday" = yes; then
  11     AC_CACHE_CHECK([for struct timezone], gfor_cv_struct_timezone,
  12       [AC_TRY_COMPILE([#include <sys/time.h>],
  13       [struct timezone tz;],
  14       gfor_cv_struct_timezone=yes, gfor_cv_struct_timezone=no)])
  15     if test $gfor_cv_struct_timezone = yes; then
  16       dnl It may be that we can't call gettimeofday with a non-null pointer.
  17       dnl In that case we'll lie about struct timezone.
  18       AC_TRY_RUN([
  19 #ifdef TIME_WITH_SYS_TIME
  20 #include <sys/time.h>
  21 #include <time.h>
  22 #else
  23 #ifdef HAVE_SYS_TIME_H
  24 #include <sys/time.h>
  25 #else
  26 #include <time.h>
  27 #endif
  28 #endif
  29 main ()
  30 {
  31   struct timeval time;
  32   struct timezone dummy;
  33   if (gettimeofday (&time, &dummy))
  34     exit (1);
  35   else
  36     exit (0);
  37 }],
  38         [gfor_have_struct_timezone=yes], [gfor_have_struct_timezone=no],
  39         [gfor_have_struct_timezone=yes])
  40       if test $gfor_have_struct_timezone = yes; then
  41         AC_DEFINE(HAVE_TIMEZONE, 1, [Do we have struct timezone])
  42       fi
  43     fi
  44     AC_REQUIRE([AC_HEADER_TIME])
  45     AC_CACHE_CHECK([whether gettimeofday can accept two arguments],
  46       emacs_cv_gettimeofday_two_arguments,
  47       [AC_TRY_LINK([
  48 #ifdef TIME_WITH_SYS_TIME
  49 #include <sys/time.h>
  50 #include <time.h>
  51 #else
  52 #ifdef HAVE_SYS_TIME_H
  53 #include <sys/time.h>
  54 #else
  55 #include <time.h>
  56 #endif
  57 #endif
  58       ],
  59       [
  60       struct timeval time;
  61 #ifdef HAVE_TIMEZONE
  62       struct timezone dummy;
  63 #define DUMMY &dummy
  64 #else
  65 #define DUMMY NULL
  66 #endif
  67       gettimeofday (&time, DUMMY);],
  68       emacs_cv_gettimeofday_two_arguments=yes,
  69       emacs_cv_gettimeofday_two_arguments=no)])
  70     if test $emacs_cv_gettimeofday_two_arguments = no; then
  71       AC_DEFINE(GETTIMEOFDAY_ONE_ARGUMENT, 1,
  72         [Does gettimeofday take a single argument])
  73     fi
  74   fi])
  75
  76 sinclude(../libtool.m4)
  77 dnl The lines below arrange for aclocal not to bring an installed
  78 dnl libtool.m4 into aclocal.m4, while still arranging for automake to
  79 dnl add a definition of LIBTOOL to Makefile.in.
  80 ifelse(,,,[AC_SUBST(LIBTOOL)
  81 AC_DEFUN([AM_PROG_LIBTOOL])
  82 AC_DEFUN([AC_LIBTOOL_DLOPEN])
  83 AC_DEFUN([AC_PROG_LD])
  84 ])
  85
  86 dnl Check whether the target is ILP32.
  87 AC_DEFUN([LIBGFOR_TARGET_ILP32], [
  88   AC_CACHE_CHECK([whether the target is ILP32], target_ilp32, [
  89   save_CFLAGS="$CFLAGS"
  90   CFLAGS="-O2"
  91   AC_TRY_LINK(,[
  92 if (sizeof(int) == 4 && sizeof(long) == 4 && sizeof(void *) == 4)
  93   ;
  94 else
  95   undefined_function ();
  96                ],
  97                target_ilp32=yes,
  98                target_ilp32=no)
  99   CFLAGS="$save_CFLAGS"])
 100   if test $target_ilp32 = yes; then
 101     AC_DEFINE(TARGET_ILP32, 1,
 102       [Define to 1 if the target is ILP32.])
 103   fi
 104   ])
 105
 106 dnl Check whether the target supports hidden visibility.
 107 AC_DEFUN([LIBGFOR_CHECK_ATTRIBUTE_VISIBILITY], [
 108   AC_CACHE_CHECK([whether the target supports hidden visibility],
 109                  have_attribute_visibility, [
 110   save_CFLAGS="$CFLAGS"
 111   CFLAGS="$CFLAGS -Werror"
 112   AC_TRY_COMPILE([void __attribute__((visibility("hidden"))) foo(void) { }],
 113                  [], have_attribute_visibility=yes,
 114                  have_attribute_visibility=no)
 115   CFLAGS="$save_CFLAGS"])
 116   if test $have_attribute_visibility = yes; then
 117     AC_DEFINE(HAVE_ATTRIBUTE_VISIBILITY, 1,
 118       [Define to 1 if the target supports __attribute__((visibility(...))).])
 119   fi])
 120
 121 dnl Check whether the target supports dllexport
 122 AC_DEFUN([LIBGFOR_CHECK_ATTRIBUTE_DLLEXPORT], [
 123   AC_CACHE_CHECK([whether the target supports dllexport],
 124                  have_attribute_dllexport, [
 125   save_CFLAGS="$CFLAGS"
 126   CFLAGS="$CFLAGS -Werror"
 127   AC_TRY_COMPILE([void __attribute__((dllexport)) foo(void) { }],
 128                  [], have_attribute_dllexport=yes,
 129                  have_attribute_dllexport=no)
 130   CFLAGS="$save_CFLAGS"])
 131   if test $have_attribute_dllexport = yes; then
 132     AC_DEFINE(HAVE_ATTRIBUTE_DLLEXPORT, 1,
 133       [Define to 1 if the target supports __attribute__((dllexport)).])
 134   fi])
 135
 136 dnl Check whether the target supports symbol aliases.
 137 AC_DEFUN([LIBGFOR_CHECK_ATTRIBUTE_ALIAS], [
 138   AC_CACHE_CHECK([whether the target supports symbol aliases],
 139                  have_attribute_alias, [
 140   AC_TRY_LINK([
 141 #define ULP     STR1(__USER_LABEL_PREFIX__)
 142 #define STR1(x) STR2(x)
 143 #define STR2(x) #x
 144 void foo(void) { }
 145 extern void bar(void) __attribute__((alias(ULP "foo")));],
 146     [bar();], have_attribute_alias=yes, have_attribute_alias=no)])
 147   if test $have_attribute_alias = yes; then
 148     AC_DEFINE(HAVE_ATTRIBUTE_ALIAS, 1,
 149       [Define to 1 if the target supports __attribute__((alias(...))).])
 150   fi])
 151
 152 dnl Check whether target can unlink a file still open.
 153 AC_DEFUN([LIBGFOR_CHECK_UNLINK_OPEN_FILE], [
 154   AC_CACHE_CHECK([whether the target can unlink an open file],
 155                   have_unlink_open_file, [
 156   AC_TRY_RUN([
 157 #include <errno.h>
 158 #include <fcntl.h>
 159 #include <unistd.h>
 160 #include <sys/stat.h>
 161
 162 int main ()
 163 {
 164   int fd;
 165
 166   fd = open ("testfile", O_RDWR | O_CREAT, S_IWRITE | S_IREAD);
 167   if (fd <= 0)
 168     return 0;
 169   if (unlink ("testfile") == -1)
 170     return 1;
 171   write (fd, "This is a test\n", 15);
 172   close (fd);
 173
 174   if (open ("testfile", O_RDONLY, S_IWRITE | S_IREAD) == -1 && errno == ENOENT)
 175     return 0;
 176   else
 177     return 1;
 178 }], have_unlink_open_file=yes, have_unlink_open_file=no, [
 179 case "${target}" in
 180   *mingw*) have_unlink_open_file=no ;;
 181   *) have_unlink_open_file=yes;;
 182 esac])])
 183 if test x"$have_unlink_open_file" = xyes; then
 184   AC_DEFINE(HAVE_UNLINK_OPEN_FILE, 1, [Define if target can unlink open files.])
 185 fi])
 186
 187 dnl Check whether CRLF is the line terminator
 188 AC_DEFUN([LIBGFOR_CHECK_CRLF], [
 189   AC_CACHE_CHECK([whether the target has CRLF as line terminator],
 190                   have_crlf, [
 191   AC_TRY_RUN([
 192 /* This test program should exit with status 0 if system uses a CRLF as
 193    line terminator, and status 1 otherwise.
 194    Since it is used to check for mingw systems, and should return 0 in any
 195    other case, in case of a failure we will not use CRLF.  */
 196 #include <sys/stat.h>
 197 #include <stdlib.h>
 198 #include <fcntl.h>
 199 #include <stdio.h>
 200
 201 int main ()
 202 {
 203 #ifndef O_BINARY
 204   exit(1);
 205 #else
 206   int fd, bytes;
 207   char buff[5];
 208
 209   fd = open ("foo", O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
 210   if (fd < 0)
 211     exit(1);
 212   if (write (fd, "\n", 1) < 0)
 213     perror ("write");
 214
 215   close (fd);
 216
 217   if ((fd = open ("foo", O_RDONLY | O_BINARY, S_IRWXU)) < 0)
 218     exit(1);
 219   bytes = read (fd, buff, 5);
 220   if (bytes == 2 && buff[0] == '\r' && buff[1] == '\n')
 221     exit(0);
 222   else
 223     exit(1);
 224 #endif
 225 }], have_crlf=yes, have_crlf=no, [
 226 case "${target}" in
 227   *mingw*) have_crlf=yes ;;
 228   *) have_crlf=no;;
 229 esac])])
 230 if test x"$have_crlf" = xyes; then
 231   AC_DEFINE(HAVE_CRLF, 1, [Define if CRLF is line terminator.])
 232 fi])
 233
 234 dnl Check whether isfinite is broken.
 235 dnl The most common problem is that it does not work on long doubles.
 236 AC_DEFUN([LIBGFOR_CHECK_FOR_BROKEN_ISFINITE], [
 237   AC_CACHE_CHECK([whether isfinite is broken],
 238                   have_broken_isfinite, [
 239   libgfor_check_for_broken_isfinite_save_LIBS=$LIBS
 240   LIBS="$LIBS -lm"
 241   AC_TRY_RUN([
 242 #ifdef HAVE_MATH_H
 243 #include <math.h>
 244 #endif
 245 #include <float.h>
 246 int main ()
 247 {
 248 #ifdef isfinite
 249 #ifdef LDBL_MAX
 250   if (!isfinite(LDBL_MAX)) return 1;
 251 #endif
 252 #ifdef DBL_MAX
 253   if (!isfinite(DBL_MAX)) return 1;
 254 #endif
 255 #endif
 256 return 0;
 257 }], have_broken_isfinite=no, have_broken_isfinite=yes, [
 258 case "${target}" in
 259   hppa*-*-hpux*) have_broken_isfinite=yes ;;
 260   *) have_broken_isfinite=no ;;
 261 esac])]
 262   LIBS=$libgfor_check_for_broken_isfinite_save_LIBS)
 263 if test x"$have_broken_isfinite" = xyes; then
 264   AC_DEFINE(HAVE_BROKEN_ISFINITE, 1, [Define if isfinite is broken.])
 265 fi])
 266
 267 dnl Check whether isnan is broken.
 268 dnl The most common problem is that it does not work on long doubles.
 269 AC_DEFUN([LIBGFOR_CHECK_FOR_BROKEN_ISNAN], [
 270   AC_CACHE_CHECK([whether isnan is broken],
 271                   have_broken_isnan, [
 272   libgfor_check_for_broken_isnan_save_LIBS=$LIBS
 273   LIBS="$LIBS -lm"
 274   AC_TRY_RUN([
 275 #ifdef HAVE_MATH_H
 276 #include <math.h>
 277 #endif
 278 #include <float.h>
 279 int main ()
 280 {
 281 #ifdef isnan
 282 #ifdef LDBL_MAX
 283   {
 284     long double x;
 285     x = __builtin_nanl ("");
 286     if (!isnan(x)) return 1;
 287     if (isnan(LDBL_MAX)) return 1;
 288 #ifdef NAN
 289     x = (long double) NAN;
 290     if (!isnan(x)) return 1;
 291 #endif
 292   }
 293 #endif
 294 #ifdef DBL_MAX
 295   {
 296     double y;
 297     y = __builtin_nan ("");
 298     if (!isnan(y)) return 1;
 299     if (isnan(DBL_MAX)) return 1;
 300 #ifdef NAN
 301     y = (double) NAN;
 302     if (!isnan(y)) return 1;
 303 #endif
 304   }
 305 #endif
 306 #endif
 307 return 0;
 308 }], have_broken_isnan=no, have_broken_isnan=yes, [
 309 case "${target}" in
 310   hppa*-*-hpux*) have_broken_isnan=yes ;;
 311   *) have_broken_isnan=no ;;
 312 esac])]
 313   LIBS=$libgfor_check_for_broken_isnan_save_LIBS)
 314 if test x"$have_broken_isnan" = xyes; then
 315   AC_DEFINE(HAVE_BROKEN_ISNAN, 1, [Define if isnan is broken.])
 316 fi])
 317
 318 dnl Check whether fpclassify is broken.
 319 dnl The most common problem is that it does not work on long doubles.
 320 AC_DEFUN([LIBGFOR_CHECK_FOR_BROKEN_FPCLASSIFY], [
 321   AC_CACHE_CHECK([whether fpclassify is broken],
 322                   have_broken_fpclassify, [
 323   libgfor_check_for_broken_fpclassify_save_LIBS=$LIBS
 324   LIBS="$LIBS -lm"
 325   AC_TRY_RUN([
 326 #ifdef HAVE_MATH_H
 327 #include <math.h>
 328 #endif
 329 #include <float.h>
 330 int main ()
 331 {
 332 #ifdef fpclassify
 333 #ifdef LDBL_MAX
 334         if (fpclassify(LDBL_MAX) == FP_NAN
 335             || fpclassify(LDBL_MAX) == FP_INFINITE) return 1;
 336 #endif
 337 #ifdef DBL_MAX
 338         if (fpclassify(DBL_MAX) == FP_NAN
 339             || fpclassify(DBL_MAX) == FP_INFINITE) return 1;
 340 #endif
 341 #endif
 342 return 0;
 343 }], have_broken_fpclassify=no, have_broken_fpclassify=yes, [
 344 case "${target}" in
 345   hppa*-*-hpux*) have_broken_fpclassify=yes ;;
 346   *) have_broken_fpclassify=no ;;
 347 esac])]
 348   LIBS=$libgfor_check_for_broken_fpclassify_save_LIBS)
 349 if test x"$have_broken_fpclassify" = xyes; then
 350   AC_DEFINE(HAVE_BROKEN_FPCLASSIFY, 1, [Define if fpclassify is broken.])
 351 fi])
 352
 353 dnl Check whether the st_ino and st_dev stat fields taken together uniquely
 354 dnl identify the file within the system. This is should be true for POSIX
 355 dnl systems; it is known to be false on mingw32.
 356 AC_DEFUN([LIBGFOR_CHECK_WORKING_STAT], [
 357   AC_CACHE_CHECK([whether the target stat is reliable],
 358                   have_working_stat, [
 359   AC_TRY_RUN([
 360 #include <stdio.h>
 361 #include <sys/types.h>
 362 #include <sys/stat.h>
 363 #include <unistd.h>
 364
 365 int main ()
 366 {
 367   FILE *f, *g;
 368   struct stat st1, st2;
 369
 370   f = fopen ("foo", "w");
 371   g = fopen ("bar", "w");
 372   if (stat ("foo", &st1) != 0 || stat ("bar", &st2))
 373     return 1;
 374   if (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino)
 375     return 1;
 376   fclose(f);
 377   fclose(g);
 378   return 0;
 379 }], have_working_stat=yes, have_working_stat=no, [
 380 case "${target}" in
 381   *mingw*) have_working_stat=no ;;
 382   *) have_working_stat=yes;;
 383 esac])])
 384 if test x"$have_working_stat" = xyes; then
 385   AC_DEFINE(HAVE_WORKING_STAT, 1, [Define if target has a reliable stat.])
 386 fi])
 387
 388 dnl Checks for fpsetmask function.
 389 AC_DEFUN([LIBGFOR_CHECK_FPSETMASK], [
 390   AC_CACHE_CHECK([whether fpsetmask is present], have_fpsetmask, [
 391     AC_TRY_LINK([
 392 #if HAVE_FLOATINGPOINT_H
 393 # include <floatingpoint.h>
 394 #endif /* HAVE_FLOATINGPOINT_H */
 395 #if HAVE_IEEEFP_H
 396 # include <ieeefp.h>
 397 #endif /* HAVE_IEEEFP_H */],[fpsetmask(0);],
 398     eval "have_fpsetmask=yes", eval "have_fpsetmask=no")
 399   ])
 400   if test x"$have_fpsetmask" = xyes; then
 401     AC_DEFINE(HAVE_FPSETMASK, 1, [Define if you have fpsetmask.])
 402   fi
 403 ])