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