]>
Commit | Line | Data |
---|---|---|
891c05b1 JJ |
1 | m4_include(../config/acx.m4) |
2 | m4_include(../config/no-executables.m4) | |
db9f46a9 | 3 | m4_include(../config/math.m4) |
7b32a8f6 | 4 | m4_include(../config/ax_check_define.m4) |
26724ef9 IT |
5 | m4_include(../config/enable.m4) |
6 | m4_include(../config/cet.m4) | |
891c05b1 | 7 | |
15e92535 FXC |
8 | dnl Check that we have a working GNU Fortran compiler |
9 | AC_DEFUN([LIBGFOR_WORKING_GFORTRAN], [ | |
10 | AC_MSG_CHECKING([whether the GNU Fortran compiler is working]) | |
11 | AC_LANG_PUSH([Fortran]) | |
12 | AC_COMPILE_IFELSE([[ | |
13 | program foo | |
14 | real, parameter :: bar = sin (12.34 / 2.5) | |
15 | end program foo]], | |
16 | [AC_MSG_RESULT([yes])], | |
17 | [AC_MSG_RESULT([no]) | |
18 | AC_MSG_ERROR([GNU Fortran is not working; please report a bug in http://gcc.gnu.org/bugzilla, attaching $PWD/config.log]) | |
19 | ]) | |
20 | AC_LANG_POP([Fortran]) | |
21 | ]) | |
22 | ||
23 | ||
6de9cd9a DN |
24 | sinclude(../libtool.m4) |
25 | dnl The lines below arrange for aclocal not to bring an installed | |
26 | dnl libtool.m4 into aclocal.m4, while still arranging for automake to | |
27 | dnl add a definition of LIBTOOL to Makefile.in. | |
28 | ifelse(,,,[AC_SUBST(LIBTOOL) | |
29 | AC_DEFUN([AM_PROG_LIBTOOL]) | |
30 | AC_DEFUN([AC_LIBTOOL_DLOPEN]) | |
31 | AC_DEFUN([AC_PROG_LD]) | |
32 | ]) | |
33 | ||
7d7b8bfe RH |
34 | dnl Check whether the target supports hidden visibility. |
35 | AC_DEFUN([LIBGFOR_CHECK_ATTRIBUTE_VISIBILITY], [ | |
36 | AC_CACHE_CHECK([whether the target supports hidden visibility], | |
6d26724a | 37 | libgfor_cv_have_attribute_visibility, [ |
7d7b8bfe RH |
38 | save_CFLAGS="$CFLAGS" |
39 | CFLAGS="$CFLAGS -Werror" | |
de15ea94 FXC |
40 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[void __attribute__((visibility("hidden"))) foo(void) { }]], [])], |
41 | libgfor_cv_have_attribute_visibility=yes, | |
42 | libgfor_cv_have_attribute_visibility=no) | |
7d7b8bfe | 43 | CFLAGS="$save_CFLAGS"]) |
6d26724a | 44 | if test $libgfor_cv_have_attribute_visibility = yes; then |
7d7b8bfe RH |
45 | AC_DEFINE(HAVE_ATTRIBUTE_VISIBILITY, 1, |
46 | [Define to 1 if the target supports __attribute__((visibility(...))).]) | |
47 | fi]) | |
48 | ||
7d7b8bfe RH |
49 | dnl Check whether the target supports symbol aliases. |
50 | AC_DEFUN([LIBGFOR_CHECK_ATTRIBUTE_ALIAS], [ | |
51 | AC_CACHE_CHECK([whether the target supports symbol aliases], | |
6d26724a | 52 | libgfor_cv_have_attribute_alias, [ |
de15ea94 | 53 | AC_LINK_IFELSE([AC_LANG_PROGRAM([[ |
7d7b8bfe | 54 | void foo(void) { } |
de15ea94 FXC |
55 | extern void bar(void) __attribute__((alias("foo")));]], |
56 | [[bar();]])], libgfor_cv_have_attribute_alias=yes, libgfor_cv_have_attribute_alias=no)]) | |
6d26724a | 57 | if test $libgfor_cv_have_attribute_alias = yes; then |
7d7b8bfe RH |
58 | AC_DEFINE(HAVE_ATTRIBUTE_ALIAS, 1, |
59 | [Define to 1 if the target supports __attribute__((alias(...))).]) | |
60 | fi]) | |
10c682a0 | 61 | |
0536d5b3 JB |
62 | dnl Check whether the target supports __atomic_fetch_add. |
63 | AC_DEFUN([LIBGFOR_CHECK_ATOMIC_FETCH_ADD], [ | |
64 | AC_CACHE_CHECK([whether the target supports __atomic_fetch_add], | |
65 | libgfor_cv_have_atomic_fetch_add, [ | |
de15ea94 | 66 | AC_LINK_IFELSE([AC_LANG_PROGRAM([[int foovar = 0;]], [[ |
0536d5b3 JB |
67 | if (foovar <= 0) return __atomic_fetch_add (&foovar, 1, __ATOMIC_ACQ_REL); |
68 | if (foovar > 10) return __atomic_add_fetch (&foovar, -1, __ATOMIC_ACQ_REL);]])], | |
69 | libgfor_cv_have_atomic_fetch_add=yes, libgfor_cv_have_atomic_fetch_add=no)]) | |
70 | if test $libgfor_cv_have_atomic_fetch_add = yes; then | |
71 | AC_DEFINE(HAVE_ATOMIC_FETCH_ADD, 1, | |
72 | [Define to 1 if the target supports __atomic_fetch_add]) | |
5e805e44 JJ |
73 | fi]) |
74 | ||
6a822a74 FXC |
75 | dnl Check for pragma weak. |
76 | AC_DEFUN([LIBGFOR_GTHREAD_WEAK], [ | |
77 | AC_CACHE_CHECK([whether pragma weak works], | |
78 | libgfor_cv_have_pragma_weak, [ | |
79 | gfor_save_CFLAGS="$CFLAGS" | |
80 | CFLAGS="$CFLAGS -Wunknown-pragmas" | |
81 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ | |
82 | void foo (void); | |
83 | #pragma weak foo | |
84 | ]], [[if (foo) foo ();]])], | |
85 | libgfor_cv_have_pragma_weak=yes, libgfor_cv_have_pragma_weak=no)]) | |
86 | if test $libgfor_cv_have_pragma_weak = yes; then | |
87 | AC_DEFINE(SUPPORTS_WEAK, 1, | |
88 | [Define to 1 if the target supports #pragma weak]) | |
89 | fi | |
90 | case "$host" in | |
91 | *-*-darwin* | *-*-hpux* | *-*-cygwin* | *-*-mingw* | *-*-musl* ) | |
92 | AC_DEFINE(GTHREAD_USE_WEAK, 0, | |
93 | [Define to 0 if the target shouldn't use #pragma weak]) | |
94 | ;; | |
95 | esac]) | |
96 | ||
e7854993 FXC |
97 | dnl Check whether target effectively supports weakref |
98 | AC_DEFUN([LIBGFOR_CHECK_WEAKREF], [ | |
99 | AC_CACHE_CHECK([whether the target supports weakref], | |
100 | libgfor_cv_have_weakref, [ | |
101 | save_CFLAGS="$CFLAGS" | |
102 | CFLAGS="$CFLAGS -Wunknown-pragmas -Werror" | |
103 | AC_LINK_IFELSE([AC_LANG_PROGRAM([[ | |
104 | static int mytoto (int) __attribute__((__weakref__("toto"))); | |
105 | ]], [[return (mytoto != 0);]])], | |
106 | libgfor_cv_have_weakref=yes, libgfor_cv_have_weakref=no) | |
107 | CFLAGS="$save_CFLAGS"]) | |
108 | if test $libgfor_cv_have_weakref = yes; then | |
109 | AC_DEFINE(SUPPORTS_WEAKREF, 1, | |
110 | [Define to 1 if the target supports weakref]) | |
111 | fi]) | |
5e805e44 | 112 | |
10c682a0 FXC |
113 | dnl Check whether target can unlink a file still open. |
114 | AC_DEFUN([LIBGFOR_CHECK_UNLINK_OPEN_FILE], [ | |
115 | AC_CACHE_CHECK([whether the target can unlink an open file], | |
6d26724a | 116 | libgfor_cv_have_unlink_open_file, [ |
de15ea94 | 117 | AC_RUN_IFELSE([AC_LANG_SOURCE([[ |
10c682a0 FXC |
118 | #include <errno.h> |
119 | #include <fcntl.h> | |
120 | #include <unistd.h> | |
121 | #include <sys/stat.h> | |
122 | ||
123 | int main () | |
124 | { | |
125 | int fd; | |
126 | ||
42dfafa9 | 127 | fd = open ("testfile", O_RDWR | O_CREAT, S_IWUSR | S_IRUSR); |
10c682a0 FXC |
128 | if (fd <= 0) |
129 | return 0; | |
130 | if (unlink ("testfile") == -1) | |
131 | return 1; | |
132 | write (fd, "This is a test\n", 15); | |
133 | close (fd); | |
134 | ||
42dfafa9 | 135 | if (open ("testfile", O_RDONLY) == -1 && errno == ENOENT) |
10c682a0 FXC |
136 | return 0; |
137 | else | |
138 | return 1; | |
de15ea94 | 139 | }]])], libgfor_cv_have_unlink_open_file=yes, libgfor_cv_have_unlink_open_file=no, [ |
10c682a0 | 140 | case "${target}" in |
6d26724a RW |
141 | *mingw*) libgfor_cv_have_unlink_open_file=no ;; |
142 | *) libgfor_cv_have_unlink_open_file=yes;; | |
10c682a0 | 143 | esac])]) |
6d26724a | 144 | if test x"$libgfor_cv_have_unlink_open_file" = xyes; then |
10c682a0 FXC |
145 | AC_DEFINE(HAVE_UNLINK_OPEN_FILE, 1, [Define if target can unlink open files.]) |
146 | fi]) | |
3c127520 FXC |
147 | |
148 | dnl Check whether CRLF is the line terminator | |
149 | AC_DEFUN([LIBGFOR_CHECK_CRLF], [ | |
150 | AC_CACHE_CHECK([whether the target has CRLF as line terminator], | |
6d26724a | 151 | libgfor_cv_have_crlf, [ |
de15ea94 | 152 | AC_RUN_IFELSE([AC_LANG_SOURCE([[ |
3c127520 FXC |
153 | /* This test program should exit with status 0 if system uses a CRLF as |
154 | line terminator, and status 1 otherwise. | |
155 | Since it is used to check for mingw systems, and should return 0 in any | |
156 | other case, in case of a failure we will not use CRLF. */ | |
157 | #include <sys/stat.h> | |
158 | #include <stdlib.h> | |
159 | #include <fcntl.h> | |
160 | #include <stdio.h> | |
161 | ||
162 | int main () | |
163 | { | |
164 | #ifndef O_BINARY | |
165 | exit(1); | |
166 | #else | |
167 | int fd, bytes; | |
168 | char buff[5]; | |
169 | ||
170 | fd = open ("foo", O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU); | |
171 | if (fd < 0) | |
172 | exit(1); | |
173 | if (write (fd, "\n", 1) < 0) | |
174 | perror ("write"); | |
175 | ||
176 | close (fd); | |
177 | ||
178 | if ((fd = open ("foo", O_RDONLY | O_BINARY, S_IRWXU)) < 0) | |
179 | exit(1); | |
180 | bytes = read (fd, buff, 5); | |
181 | if (bytes == 2 && buff[0] == '\r' && buff[1] == '\n') | |
182 | exit(0); | |
183 | else | |
184 | exit(1); | |
185 | #endif | |
de15ea94 | 186 | }]])], libgfor_cv_have_crlf=yes, libgfor_cv_have_crlf=no, [ |
3c127520 | 187 | case "${target}" in |
6d26724a RW |
188 | *mingw*) libgfor_cv_have_crlf=yes ;; |
189 | *) libgfor_cv_have_crlf=no;; | |
3c127520 | 190 | esac])]) |
6d26724a | 191 | if test x"$libgfor_cv_have_crlf" = xyes; then |
3c127520 FXC |
192 | AC_DEFINE(HAVE_CRLF, 1, [Define if CRLF is line terminator.]) |
193 | fi]) | |
118ea208 | 194 | |
ad238e4f FXC |
195 | dnl Check whether the st_ino and st_dev stat fields taken together uniquely |
196 | dnl identify the file within the system. This is should be true for POSIX | |
197 | dnl systems; it is known to be false on mingw32. | |
198 | AC_DEFUN([LIBGFOR_CHECK_WORKING_STAT], [ | |
199 | AC_CACHE_CHECK([whether the target stat is reliable], | |
6d26724a | 200 | libgfor_cv_have_working_stat, [ |
de15ea94 | 201 | AC_RUN_IFELSE([AC_LANG_SOURCE([[ |
ad238e4f FXC |
202 | #include <stdio.h> |
203 | #include <sys/types.h> | |
204 | #include <sys/stat.h> | |
205 | #include <unistd.h> | |
206 | ||
207 | int main () | |
208 | { | |
209 | FILE *f, *g; | |
210 | struct stat st1, st2; | |
211 | ||
212 | f = fopen ("foo", "w"); | |
213 | g = fopen ("bar", "w"); | |
214 | if (stat ("foo", &st1) != 0 || stat ("bar", &st2)) | |
215 | return 1; | |
216 | if (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino) | |
217 | return 1; | |
218 | fclose(f); | |
219 | fclose(g); | |
220 | return 0; | |
de15ea94 | 221 | }]])], libgfor_cv_have_working_stat=yes, libgfor_cv_have_working_stat=no, [ |
ad238e4f | 222 | case "${target}" in |
6d26724a RW |
223 | *mingw*) libgfor_cv_have_working_stat=no ;; |
224 | *) libgfor_cv_have_working_stat=yes;; | |
ad238e4f | 225 | esac])]) |
6d26724a | 226 | if test x"$libgfor_cv_have_working_stat" = xyes; then |
ad238e4f FXC |
227 | AC_DEFINE(HAVE_WORKING_STAT, 1, [Define if target has a reliable stat.]) |
228 | fi]) | |
3b14f664 FXC |
229 | |
230 | dnl Checks for fpsetmask function. | |
231 | AC_DEFUN([LIBGFOR_CHECK_FPSETMASK], [ | |
6d26724a | 232 | AC_CACHE_CHECK([whether fpsetmask is present], libgfor_cv_have_fpsetmask, [ |
de15ea94 | 233 | AC_LINK_IFELSE([AC_LANG_PROGRAM([[ |
3b14f664 FXC |
234 | #if HAVE_FLOATINGPOINT_H |
235 | # include <floatingpoint.h> | |
236 | #endif /* HAVE_FLOATINGPOINT_H */ | |
237 | #if HAVE_IEEEFP_H | |
238 | # include <ieeefp.h> | |
de15ea94 | 239 | #endif /* HAVE_IEEEFP_H */]],[[fpsetmask(0);]])], |
6d26724a | 240 | eval "libgfor_cv_have_fpsetmask=yes", eval "libgfor_cv_have_fpsetmask=no") |
3b14f664 | 241 | ]) |
6d26724a | 242 | if test x"$libgfor_cv_have_fpsetmask" = xyes; then |
1b9fef3e | 243 | have_fpsetmask=yes |
3b14f664 FXC |
244 | AC_DEFINE(HAVE_FPSETMASK, 1, [Define if you have fpsetmask.]) |
245 | fi | |
246 | ]) | |
db8092dc FXC |
247 | |
248 | dnl Check whether we have a mingw that provides a __mingw_snprintf function | |
249 | AC_DEFUN([LIBGFOR_CHECK_MINGW_SNPRINTF], [ | |
6d26724a | 250 | AC_CACHE_CHECK([whether __mingw_snprintf is present], libgfor_cv_have_mingw_snprintf, [ |
de15ea94 | 251 | AC_LINK_IFELSE([AC_LANG_PROGRAM([[ |
db8092dc FXC |
252 | #include <stdio.h> |
253 | extern int __mingw_snprintf (char *, size_t, const char *, ...); | |
de15ea94 | 254 | ]],[[ |
db8092dc | 255 | __mingw_snprintf (NULL, 0, "%d\n", 1); |
de15ea94 | 256 | ]])], |
6d26724a | 257 | eval "libgfor_cv_have_mingw_snprintf=yes", eval "libgfor_cv_have_mingw_snprintf=no") |
db8092dc | 258 | ]) |
6d26724a | 259 | if test x"$libgfor_cv_have_mingw_snprintf" = xyes; then |
db8092dc FXC |
260 | AC_DEFINE(HAVE_MINGW_SNPRINTF, 1, [Define if you have __mingw_snprintf.]) |
261 | fi | |
262 | ]) | |
c0c3c409 | 263 | |
c022c0de | 264 | dnl Check whether we have a __float128 and _Float128 type |
1ec601bf FXC |
265 | AC_DEFUN([LIBGFOR_CHECK_FLOAT128], [ |
266 | LIBQUADSPEC= | |
133d0d42 JJ |
267 | LIBQUADLIB= |
268 | LIBQUADLIB_DEP= | |
269 | LIBQUADINCLUDE= | |
270 | USE_IEC_60559=no | |
87e6d9dc TB |
271 | |
272 | if test "x$enable_libquadmath_support" != xno; then | |
273 | ||
133d0d42 | 274 | AC_CACHE_CHECK([whether we have a usable _Float128 type], |
1ec601bf | 275 | libgfor_cv_have_float128, [ |
69eb61d4 | 276 | GCC_TRY_COMPILE_OR_LINK([ |
133d0d42 | 277 | _Float128 foo (_Float128 x) |
69eb61d4 | 278 | { |
133d0d42 | 279 | _Complex _Float128 z1, z2; |
1ec601bf | 280 | |
69eb61d4 | 281 | z1 = x; |
133d0d42 | 282 | z2 = x / 7.F128; |
69eb61d4 TB |
283 | z2 /= z1; |
284 | ||
133d0d42 | 285 | return (_Float128) z2; |
69eb61d4 TB |
286 | } |
287 | ||
133d0d42 | 288 | _Float128 bar (_Float128 x) |
69eb61d4 | 289 | { |
133d0d42 | 290 | return x * __builtin_huge_valf128 (); |
69eb61d4 | 291 | } |
c022c0de JJ |
292 | |
293 | __float128 baz (__float128 x) | |
294 | { | |
295 | return x * __builtin_huge_valf128 (); | |
296 | } | |
69eb61d4 | 297 | ],[ |
133d0d42 JJ |
298 | foo (1.2F128); |
299 | bar (1.2F128); | |
c022c0de | 300 | baz (1.2F128); |
69eb61d4 TB |
301 | foo (1.2Q); |
302 | bar (1.2Q); | |
c022c0de | 303 | baz (1.2Q); |
69eb61d4 TB |
304 | ],[ |
305 | libgfor_cv_have_float128=yes | |
306 | ],[ | |
307 | libgfor_cv_have_float128=no | |
308 | ])]) | |
1ec601bf | 309 | |
133d0d42 JJ |
310 | if test "x$have_iec_60559_libc_support$enable_libquadmath_support$libgfor_cv_have_float128" = xyesdefaultyes; then |
311 | USE_IEC_60559=yes | |
312 | fi | |
313 | ||
314 | ||
1ec601bf | 315 | if test "x$libgfor_cv_have_float128" = xyes; then |
133d0d42 JJ |
316 | if test "x$USE_IEC_60559" = xyes; then |
317 | AC_DEFINE(USE_IEC_60559, 1, [Define if IEC 60559 *f128 APIs should be used for _Float128.]) | |
318 | fi | |
c022c0de | 319 | AC_DEFINE(HAVE_FLOAT128, 1, [Define if target has usable _Float128 and __float128 types.]) |
1ec601bf | 320 | |
828012a5 | 321 | dnl Check whether -Wl,--as-needed resp. -Wl,-zignore is supported |
1ec601bf FXC |
322 | dnl |
323 | dnl Turn warnings into error to avoid testsuite breakage. So enable | |
324 | dnl AC_LANG_WERROR, but there's currently (autoconf 2.64) no way to turn | |
325 | dnl it off again. As a workaround, save and restore werror flag like | |
326 | dnl AC_PATH_XTRA. | |
327 | dnl Cf. http://gcc.gnu.org/ml/gcc-patches/2010-05/msg01889.html | |
328 | ac_xsave_[]_AC_LANG_ABBREV[]_werror_flag=$ac_[]_AC_LANG_ABBREV[]_werror_flag | |
828012a5 | 329 | AC_CACHE_CHECK([whether --as-needed/-z ignore works], |
1ec601bf FXC |
330 | [libgfor_cv_have_as_needed], |
331 | [ | |
828012a5 RO |
332 | # Test for native Solaris options first. |
333 | # No whitespace after -z to pass it through -Wl. | |
334 | libgfor_cv_as_needed_option="-zignore" | |
335 | libgfor_cv_no_as_needed_option="-zrecord" | |
1ec601bf | 336 | save_LDFLAGS="$LDFLAGS" |
828012a5 | 337 | LDFLAGS="$LDFLAGS -Wl,$libgfor_cv_as_needed_option -lm -Wl,$libgfor_cv_no_as_needed_option" |
1ec601bf FXC |
338 | libgfor_cv_have_as_needed=no |
339 | AC_LANG_WERROR | |
340 | AC_LINK_IFELSE([AC_LANG_PROGRAM([])], | |
341 | [libgfor_cv_have_as_needed=yes], | |
342 | [libgfor_cv_have_as_needed=no]) | |
343 | LDFLAGS="$save_LDFLAGS" | |
828012a5 RO |
344 | if test "x$libgfor_cv_have_as_needed" = xno; then |
345 | libgfor_cv_as_needed_option="--as-needed" | |
346 | libgfor_cv_no_as_needed_option="--no-as-needed" | |
347 | save_LDFLAGS="$LDFLAGS" | |
348 | LDFLAGS="$LDFLAGS -Wl,$libgfor_cv_as_needed_option -lm -Wl,$libgfor_cv_no_as_needed_option" | |
349 | libgfor_cv_have_as_needed=no | |
350 | AC_LANG_WERROR | |
351 | AC_LINK_IFELSE([AC_LANG_PROGRAM([])], | |
352 | [libgfor_cv_have_as_needed=yes], | |
353 | [libgfor_cv_have_as_needed=no]) | |
354 | LDFLAGS="$save_LDFLAGS" | |
355 | fi | |
1ec601bf FXC |
356 | ac_[]_AC_LANG_ABBREV[]_werror_flag=$ac_xsave_[]_AC_LANG_ABBREV[]_werror_flag |
357 | ]) | |
358 | ||
745be54b JJ |
359 | dnl Determine -Bstatic ... -Bdynamic etc. support from gfortran -### stderr. |
360 | touch conftest1.$ac_objext conftest2.$ac_objext | |
361 | LQUADMATH=-lquadmath | |
362 | $FC -static-libgfortran -### -o conftest \ | |
363 | conftest1.$ac_objext -lgfortran conftest2.$ac_objext 2>&1 >/dev/null \ | |
364 | | grep "conftest1.$ac_objext.*conftest2.$ac_objext" > conftest.cmd | |
365 | if grep "conftest1.$ac_objext.* -Bstatic -lgfortran -Bdynamic .*conftest2.$ac_objext" \ | |
366 | conftest.cmd >/dev/null 2>&1; then | |
367 | LQUADMATH="%{static-libquadmath:-Bstatic} -lquadmath %{static-libquadmath:-Bdynamic}" | |
368 | elif grep "conftest1.$ac_objext.* -bstatic -lgfortran -bdynamic .*conftest2.$ac_objext" \ | |
369 | conftest.cmd >/dev/null 2>&1; then | |
370 | LQUADMATH="%{static-libquadmath:-bstatic} -lquadmath %{static-libquadmath:-bdynamic}" | |
371 | elif grep "conftest1.$ac_objext.* -aarchive_shared -lgfortran -adefault .*conftest2.$ac_objext" \ | |
372 | conftest.cmd >/dev/null 2>&1; then | |
373 | LQUADMATH="%{static-libquadmath:-aarchive_shared} -lquadmath %{static-libquadmath:-adefault}" | |
374 | elif grep "conftest1.$ac_objext.*libgfortran.a .*conftest2.$ac_objext" \ | |
375 | conftest.cmd >/dev/null 2>&1; then | |
376 | LQUADMATH="%{static-libquadmath:libquadmath.a%s;:-lquadmath}" | |
377 | fi | |
378 | rm -f conftest1.$ac_objext conftest2.$ac_objext conftest conftest.cmd | |
379 | ||
1ec601bf | 380 | dnl For static libgfortran linkage, depend on libquadmath only if needed. |
133d0d42 JJ |
381 | dnl If using *f128 APIs from libc/libm, depend on libquadmath only if needed |
382 | dnl even for dynamic libgfortran linkage, and don't link libgfortran against | |
383 | dnl -lquadmath. | |
1ec601bf | 384 | if test "x$libgfor_cv_have_as_needed" = xyes; then |
133d0d42 | 385 | if test "x$USE_IEC_60559" = xyes; then |
745be54b | 386 | LIBQUADSPEC="$libgfor_cv_as_needed_option $LQUADMATH $libgfor_cv_no_as_needed_option" |
133d0d42 | 387 | else |
745be54b | 388 | LIBQUADSPEC="%{static-libgfortran:$libgfor_cv_as_needed_option} $LQUADMATH %{static-libgfortran:$libgfor_cv_no_as_needed_option}" |
133d0d42 | 389 | fi |
1ec601bf | 390 | else |
745be54b | 391 | LIBQUADSPEC="$LQUADMATH" |
1ec601bf | 392 | fi |
133d0d42 JJ |
393 | if test "x$USE_IEC_60559" != xyes; then |
394 | if test -f ../libquadmath/libquadmath.la; then | |
395 | LIBQUADLIB=../libquadmath/libquadmath.la | |
396 | LIBQUADLIB_DEP=../libquadmath/libquadmath.la | |
397 | LIBQUADINCLUDE='-I$(srcdir)/../libquadmath' | |
398 | else | |
399 | LIBQUADLIB="-lquadmath" | |
400 | fi | |
1ec601bf | 401 | fi |
87e6d9dc | 402 | else |
133d0d42 JJ |
403 | USE_IEC_60559=no |
404 | fi | |
87e6d9dc | 405 | fi |
1ec601bf FXC |
406 | |
407 | dnl For the spec file | |
408 | AC_SUBST(LIBQUADSPEC) | |
409 | AC_SUBST(LIBQUADLIB) | |
410 | AC_SUBST(LIBQUADLIB_DEP) | |
411 | AC_SUBST(LIBQUADINCLUDE) | |
133d0d42 | 412 | AC_SUBST(USE_IEC_60559) |
1ec601bf | 413 | ]) |
4179e59a TB |
414 | |
415 | ||
416 | dnl Check whether we have strerror_r | |
417 | AC_DEFUN([LIBGFOR_CHECK_STRERROR_R], [ | |
418 | dnl Check for three-argument POSIX version of strerror_r | |
419 | ac_save_CFLAGS="$CFLAGS" | |
420 | CFLAGS="-Wimplicit-function-declaration -Werror" | |
421 | AC_TRY_COMPILE([#define _GNU_SOURCE 1 | |
422 | #include <string.h> | |
423 | #include <locale.h>], | |
424 | [char s[128]; strerror_r(5, s, 128);], | |
425 | AC_DEFINE(HAVE_STRERROR_R, 1, | |
426 | [Define if strerror_r is available in <string.h>.]),) | |
427 | CFLAGS="$ac_save_CFLAGS" | |
428 | ||
429 | dnl Check for two-argument version of strerror_r (e.g. for VxWorks) | |
430 | ac_save_CFLAGS="$CFLAGS" | |
431 | CFLAGS="-Wimplicit-function-declaration -Werror" | |
432 | AC_TRY_COMPILE([#define _GNU_SOURCE 1 | |
433 | #include <string.h> | |
434 | #include <locale.h>], | |
435 | [char s[128]; strerror_r(5, s);], | |
436 | AC_DEFINE(HAVE_STRERROR_R_2ARGS, 1, | |
437 | [Define if strerror_r takes two arguments and is available in <string.h>.]),) | |
438 | CFLAGS="$ac_save_CFLAGS" | |
439 | ]) | |
31cfd832 TK |
440 | |
441 | dnl Check for AVX | |
442 | ||
443 | AC_DEFUN([LIBGFOR_CHECK_AVX], [ | |
444 | ac_save_CFLAGS="$CFLAGS" | |
445 | CFLAGS="-O2 -mavx" | |
446 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ | |
447 | void _mm256_zeroall (void) | |
448 | { | |
449 | __builtin_ia32_vzeroall (); | |
450 | }]], [[]])], | |
451 | AC_DEFINE(HAVE_AVX, 1, | |
452 | [Define if AVX instructions can be compiled.]), | |
453 | []) | |
454 | CFLAGS="$ac_save_CFLAGS" | |
455 | ]) | |
456 | ||
457 | dnl Check for AVX2 | |
458 | ||
459 | AC_DEFUN([LIBGFOR_CHECK_AVX2], [ | |
460 | ac_save_CFLAGS="$CFLAGS" | |
461 | CFLAGS="-O2 -mavx2" | |
462 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ | |
463 | typedef long long __v4di __attribute__ ((__vector_size__ (32))); | |
464 | __v4di | |
465 | mm256_is32_andnotsi256 (__v4di __X, __v4di __Y) | |
466 | { | |
467 | return __builtin_ia32_andnotsi256 (__X, __Y); | |
468 | }]], [[]])], | |
469 | AC_DEFINE(HAVE_AVX2, 1, | |
470 | [Define if AVX2 instructions can be compiled.]), | |
471 | []) | |
472 | CFLAGS="$ac_save_CFLAGS" | |
473 | ]) | |
474 | ||
475 | dnl Check for AVX512f | |
476 | ||
477 | AC_DEFUN([LIBGFOR_CHECK_AVX512F], [ | |
478 | ac_save_CFLAGS="$CFLAGS" | |
479 | CFLAGS="-O2 -mavx512f" | |
480 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ | |
481 | typedef double __m512d __attribute__ ((__vector_size__ (64))); | |
482 | __m512d _mm512_add (__m512d a) | |
483 | { | |
9db0a8c2 JJ |
484 | __m512d b = __builtin_ia32_addpd512_mask (a, a, a, 1, 4); |
485 | /* For -m64/-mx32 also verify that code will work even if | |
486 | the target uses call saved zmm16+ and needs to emit | |
487 | unwind info for them (e.g. on mingw). See PR79127. */ | |
488 | #ifdef __x86_64__ | |
489 | asm volatile ("" : : : "zmm16", "zmm17", "zmm18", "zmm19"); | |
490 | #endif | |
491 | return b; | |
31cfd832 TK |
492 | }]], [[]])], |
493 | AC_DEFINE(HAVE_AVX512F, 1, | |
494 | [Define if AVX512f instructions can be compiled.]), | |
495 | []) | |
496 | CFLAGS="$ac_save_CFLAGS" | |
497 | ]) | |
1d5cf7fc TK |
498 | |
499 | dnl Check for FMA3 | |
500 | dnl | |
501 | AC_DEFUN([LIBGFOR_CHECK_FMA3], [ | |
502 | ac_save_CFLAGS="$CFLAGS" | |
503 | CFLAGS="-O2 -mfma -mno-fma4" | |
504 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ | |
9698e1bb RO |
505 | typedef float __m128 __attribute__ ((__vector_size__ (16))); |
506 | typedef float __v4sf __attribute__ ((__vector_size__ (16))); | |
507 | __m128 _mm_macc_ps(__m128 __A, __m128 __B, __m128 __C) | |
1d5cf7fc | 508 | { |
9698e1bb RO |
509 | return (__m128) __builtin_ia32_vfmaddps ((__v4sf)__A, |
510 | (__v4sf)__B, | |
511 | (__v4sf)__C); | |
1d5cf7fc TK |
512 | }]], [[]])], |
513 | AC_DEFINE(HAVE_FMA3, 1, | |
514 | [Define if FMA3 instructions can be compiled.]), | |
515 | []) | |
516 | CFLAGS="$ac_save_CFLAGS" | |
517 | ]) | |
518 | ||
519 | dnl Check for FMA4 | |
520 | dnl | |
521 | AC_DEFUN([LIBGFOR_CHECK_FMA4], [ | |
522 | ac_save_CFLAGS="$CFLAGS" | |
523 | CFLAGS="-O2 -mfma4 -mno-fma" | |
524 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ | |
9698e1bb RO |
525 | typedef float __m128 __attribute__ ((__vector_size__ (16))); |
526 | typedef float __v4sf __attribute__ ((__vector_size__ (16))); | |
527 | __m128 _mm_macc_ps(__m128 __A, __m128 __B, __m128 __C) | |
1d5cf7fc | 528 | { |
9698e1bb RO |
529 | return (__m128) __builtin_ia32_vfmaddps ((__v4sf)__A, |
530 | (__v4sf)__B, | |
531 | (__v4sf)__C); | |
1d5cf7fc TK |
532 | }]], [[]])], |
533 | AC_DEFINE(HAVE_FMA4, 1, | |
534 | [Define if FMA4 instructions can be compiled.]), | |
535 | []) | |
536 | CFLAGS="$ac_save_CFLAGS" | |
537 | ]) | |
538 | ||
539 | dnl Check for -mprefer-avx128 | |
540 | dnl This also defines an automake conditional. | |
541 | AC_DEFUN([LIBGFOR_CHECK_AVX128], [ | |
542 | ac_save_CFLAGS="$CFLAGS" | |
543 | CFLAGS="-O2 -mavx -mprefer-avx128" | |
544 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ | |
545 | void foo() | |
546 | { | |
547 | }]], [[]])], | |
548 | AC_DEFINE(HAVE_AVX128, 1, | |
549 | [Define if -mprefer-avx128 is supported.]) | |
550 | AM_CONDITIONAL([HAVE_AVX128],true), | |
5596d26a | 551 | [AM_CONDITIONAL([HAVE_AVX128],false)]) |
1d5cf7fc TK |
552 | CFLAGS="$ac_save_CFLAGS" |
553 | ]) | |
6f4977fc TK |
554 | |
555 | AC_DEFUN([LIBGFOR_CHECK_MATH_IEEE128], | |
556 | [ | |
557 | AC_REQUIRE([GCC_CHECK_LIBM]) | |
558 | AC_REQUIRE([GCC_CHECK_MATH_HEADERS]) | |
559 | AC_CACHE_CHECK([for $1], [gcc_cv_math_func_$1], | |
560 | [AC_LINK_IFELSE([AC_LANG_SOURCE([ | |
5097cdf9 JJ |
561 | _Float128 $1 (_Float128); |
562 | _Float128 (*ptr)(_Float128) = $1; | |
6f4977fc TK |
563 | |
564 | int | |
565 | main () | |
566 | { | |
567 | return 0; | |
568 | } | |
569 | ])], | |
570 | [gcc_cv_math_func_$1=yes], | |
571 | [gcc_cv_math_func_$1=no])]) | |
572 | if test $gcc_cv_math_func_$1 = yes; then | |
573 | AC_DEFINE_UNQUOTED(AS_TR_CPP(HAVE_$1),[1], | |
574 | [Define to 1 if you have the `$1' function.]) | |
575 | fi | |
576 | ]) |