Annotation of embedaddon/curl/m4/curl-compilers.m4, revision 1.1.1.1
1.1 misho 1: #***************************************************************************
2: # _ _ ____ _
3: # Project ___| | | | _ \| |
4: # / __| | | | |_) | |
5: # | (__| |_| | _ <| |___
6: # \___|\___/|_| \_\_____|
7: #
8: # Copyright (C) 1998 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
9: #
10: # This software is licensed as described in the file COPYING, which
11: # you should have received as part of this distribution. The terms
12: # are also available at https://curl.haxx.se/docs/copyright.html.
13: #
14: # You may opt to use, copy, modify, merge, publish, distribute and/or sell
15: # copies of the Software, and permit persons to whom the Software is
16: # furnished to do so, under the terms of the COPYING file.
17: #
18: # This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19: # KIND, either express or implied.
20: #
21: #***************************************************************************
22:
23: # File version for 'aclocal' use. Keep it a single number.
24: # serial 67
25:
26:
27: dnl CURL_CHECK_COMPILER
28: dnl -------------------------------------------------
29: dnl Verify if the C compiler being used is known.
30:
31: AC_DEFUN([CURL_CHECK_COMPILER], [
32: #
33: compiler_id="unknown"
34: compiler_num="0"
35: #
36: flags_dbg_all="unknown"
37: flags_dbg_yes="unknown"
38: flags_dbg_off="unknown"
39: flags_opt_all="unknown"
40: flags_opt_yes="unknown"
41: flags_opt_off="unknown"
42: #
43: flags_prefer_cppflags="no"
44: #
45: CURL_CHECK_COMPILER_DEC_C
46: CURL_CHECK_COMPILER_HPUX_C
47: CURL_CHECK_COMPILER_IBM_C
48: CURL_CHECK_COMPILER_INTEL_C
49: CURL_CHECK_COMPILER_CLANG
50: CURL_CHECK_COMPILER_GNU_C
51: CURL_CHECK_COMPILER_LCC
52: CURL_CHECK_COMPILER_SGI_MIPSPRO_C
53: CURL_CHECK_COMPILER_SGI_MIPS_C
54: CURL_CHECK_COMPILER_SUNPRO_C
55: CURL_CHECK_COMPILER_TINY_C
56: CURL_CHECK_COMPILER_WATCOM_C
57: #
58: if test "$compiler_id" = "unknown"; then
59: cat <<_EOF 1>&2
60: ***
61: *** Warning: This configure script does not have information about the
62: *** compiler you are using, relative to the flags required to enable or
63: *** disable generation of debug info, optimization options or warnings.
64: ***
65: *** Whatever settings are present in CFLAGS will be used for this run.
66: ***
67: *** If you wish to help the curl project to better support your compiler
68: *** you can report this and the required info on the libcurl development
69: *** mailing list: https://cool.haxx.se/mailman/listinfo/curl-library/
70: ***
71: _EOF
72: fi
73: ])
74:
75:
76: dnl CURL_CHECK_COMPILER_CLANG
77: dnl -------------------------------------------------
78: dnl Verify if compiler being used is clang.
79:
80: AC_DEFUN([CURL_CHECK_COMPILER_CLANG], [
81: AC_BEFORE([$0],[CURL_CHECK_COMPILER_GNU_C])dnl
82: AC_MSG_CHECKING([if compiler is clang])
83: CURL_CHECK_DEF([__clang__], [], [silent])
84: if test "$curl_cv_have_def___clang__" = "yes"; then
85: AC_MSG_RESULT([yes])
86: AC_MSG_CHECKING([if compiler is xlclang])
87: CURL_CHECK_DEF([__ibmxl__], [], [silent])
88: if test "$curl_cv_have_def___ibmxl__" = "yes" ; then
89: dnl IBM's almost-compatible clang version
90: AC_MSG_RESULT([yes])
91: compiler_id="XLCLANG"
92: else
93: AC_MSG_RESULT([no])
94: compiler_id="CLANG"
95: fi
96: fullclangver=`$CC -v 2>&1 | grep version`
97: clangver=`echo $fullclangver | grep "based on LLVM " | "$SED" 's/.*(based on LLVM \(@<:@0-9@:>@*\.@<:@0-9@:>@*\).*)/\1/'`
98: if test -z "$clangver"; then
99: if echo $fullclangver | grep "Apple LLVM version " >/dev/null; then
100: dnl Starting with XCode 7 / clang 3.7, Apple clang won't tell its upstream version
101: clangver="3.7"
102: else
103: clangver=`echo $fullclangver | "$SED" 's/.*version \(@<:@0-9@:>@*\.@<:@0-9@:>@*\).*/\1/'`
104: fi
105: fi
106: clangvhi=`echo $clangver | cut -d . -f1`
107: clangvlo=`echo $clangver | cut -d . -f2`
108: compiler_num=`(expr $clangvhi "*" 100 + $clangvlo) 2>/dev/null`
109: flags_dbg_all="-g -g0 -g1 -g2 -g3"
110: flags_dbg_all="$flags_dbg_all -ggdb"
111: flags_dbg_all="$flags_dbg_all -gstabs"
112: flags_dbg_all="$flags_dbg_all -gstabs+"
113: flags_dbg_all="$flags_dbg_all -gcoff"
114: flags_dbg_all="$flags_dbg_all -gxcoff"
115: flags_dbg_all="$flags_dbg_all -gdwarf-2"
116: flags_dbg_all="$flags_dbg_all -gvms"
117: flags_dbg_yes="-g"
118: flags_dbg_off=""
119: flags_opt_all="-O -O0 -O1 -O2 -Os -O3 -O4"
120: flags_opt_yes="-Os"
121: flags_opt_off="-O0"
122: else
123: AC_MSG_RESULT([no])
124: fi
125: ])
126:
127:
128: dnl CURL_CHECK_COMPILER_DEC_C
129: dnl -------------------------------------------------
130: dnl Verify if compiler being used is DEC C.
131:
132: AC_DEFUN([CURL_CHECK_COMPILER_DEC_C], [
133: AC_MSG_CHECKING([if compiler is DEC/Compaq/HP C])
134: CURL_CHECK_DEF([__DECC], [], [silent])
135: CURL_CHECK_DEF([__DECC_VER], [], [silent])
136: if test "$curl_cv_have_def___DECC" = "yes" &&
137: test "$curl_cv_have_def___DECC_VER" = "yes"; then
138: AC_MSG_RESULT([yes])
139: compiler_id="DEC_C"
140: flags_dbg_all="-g -g0 -g1 -g2 -g3"
141: flags_dbg_yes="-g2"
142: flags_dbg_off=""
143: flags_opt_all="-O -O0 -O1 -O2 -O3 -O4"
144: flags_opt_yes="-O1"
145: flags_opt_off="-O0"
146: else
147: AC_MSG_RESULT([no])
148: fi
149: ])
150:
151:
152: dnl CURL_CHECK_COMPILER_GNU_C
153: dnl -------------------------------------------------
154: dnl Verify if compiler being used is GNU C
155: dnl
156: dnl $compiler_num will be set to MAJOR * 100 + MINOR for gcc less than version
157: dnl 7 and just $MAJOR * 100 for gcc version 7 and later.
158: dnl
159: dnl Examples:
160: dnl Version 1.2.3 => 102
161: dnl Version 2.95 => 295
162: dnl Version 4.7 => 407
163: dnl Version 9.2.1 => 900
164: dnl
165: AC_DEFUN([CURL_CHECK_COMPILER_GNU_C], [
166: AC_REQUIRE([CURL_CHECK_COMPILER_INTEL_C])dnl
167: AC_REQUIRE([CURL_CHECK_COMPILER_CLANG])dnl
168: AC_MSG_CHECKING([if compiler is GNU C])
169: CURL_CHECK_DEF([__GNUC__], [], [silent])
170: if test "$curl_cv_have_def___GNUC__" = "yes" &&
171: test "$compiler_id" = "unknown"; then
172: AC_MSG_RESULT([yes])
173: compiler_id="GNU_C"
174: gccver=`$CC -dumpversion`
175: gccvhi=`echo $gccver | cut -d . -f1`
176: gccvlo=`echo $gccver | cut -d . -f2`
177: compiler_num=`(expr $gccvhi "*" 100 + $gccvlo) 2>/dev/null`
178: flags_dbg_all="-g -g0 -g1 -g2 -g3"
179: flags_dbg_all="$flags_dbg_all -ggdb"
180: flags_dbg_all="$flags_dbg_all -gstabs"
181: flags_dbg_all="$flags_dbg_all -gstabs+"
182: flags_dbg_all="$flags_dbg_all -gcoff"
183: flags_dbg_all="$flags_dbg_all -gxcoff"
184: flags_dbg_all="$flags_dbg_all -gdwarf-2"
185: flags_dbg_all="$flags_dbg_all -gvms"
186: flags_dbg_yes="-g"
187: flags_dbg_off=""
188: flags_opt_all="-O -O0 -O1 -O2 -O3 -Os -Og -Ofast"
189: flags_opt_yes="-O2"
190: flags_opt_off="-O0"
191: CURL_CHECK_DEF([_WIN32], [], [silent])
192: else
193: AC_MSG_RESULT([no])
194: fi
195: ])
196:
197:
198: dnl CURL_CHECK_COMPILER_HPUX_C
199: dnl -------------------------------------------------
200: dnl Verify if compiler being used is HP-UX C.
201:
202: AC_DEFUN([CURL_CHECK_COMPILER_HPUX_C], [
203: AC_MSG_CHECKING([if compiler is HP-UX C])
204: CURL_CHECK_DEF([__HP_cc], [], [silent])
205: if test "$curl_cv_have_def___HP_cc" = "yes"; then
206: AC_MSG_RESULT([yes])
207: compiler_id="HP_UX_C"
208: flags_dbg_all="-g -s"
209: flags_dbg_yes="-g"
210: flags_dbg_off="-s"
211: flags_opt_all="-O +O0 +O1 +O2 +O3 +O4"
212: flags_opt_yes="+O2"
213: flags_opt_off="+O0"
214: else
215: AC_MSG_RESULT([no])
216: fi
217: ])
218:
219:
220: dnl CURL_CHECK_COMPILER_IBM_C
221: dnl -------------------------------------------------
222: dnl Verify if compiler being used is IBM C.
223:
224: AC_DEFUN([CURL_CHECK_COMPILER_IBM_C], [
225: AC_MSG_CHECKING([if compiler is IBM C])
226: CURL_CHECK_DEF([__IBMC__], [], [silent])
227: if test "$curl_cv_have_def___IBMC__" = "yes"; then
228: AC_MSG_RESULT([yes])
229: compiler_id="IBM_C"
230: flags_dbg_all="-g -g0 -g1 -g2 -g3"
231: flags_dbg_yes="-g"
232: flags_dbg_off=""
233: flags_opt_all="-O -O0 -O1 -O2 -O3 -O4 -O5"
234: flags_opt_all="$flags_opt_all -qnooptimize"
235: flags_opt_all="$flags_opt_all -qoptimize=0"
236: flags_opt_all="$flags_opt_all -qoptimize=1"
237: flags_opt_all="$flags_opt_all -qoptimize=2"
238: flags_opt_all="$flags_opt_all -qoptimize=3"
239: flags_opt_all="$flags_opt_all -qoptimize=4"
240: flags_opt_all="$flags_opt_all -qoptimize=5"
241: flags_opt_yes="-O2"
242: flags_opt_off="-qnooptimize"
243: flags_prefer_cppflags="yes"
244: else
245: AC_MSG_RESULT([no])
246: fi
247: ])
248:
249:
250: dnl CURL_CHECK_COMPILER_INTEL_C
251: dnl -------------------------------------------------
252: dnl Verify if compiler being used is Intel C.
253:
254: AC_DEFUN([CURL_CHECK_COMPILER_INTEL_C], [
255: AC_BEFORE([$0],[CURL_CHECK_COMPILER_GNU_C])dnl
256: AC_MSG_CHECKING([if compiler is Intel C])
257: CURL_CHECK_DEF([__INTEL_COMPILER], [], [silent])
258: if test "$curl_cv_have_def___INTEL_COMPILER" = "yes"; then
259: AC_MSG_RESULT([yes])
260: compiler_num="$curl_cv_def___INTEL_COMPILER"
261: CURL_CHECK_DEF([__unix__], [], [silent])
262: if test "$curl_cv_have_def___unix__" = "yes"; then
263: compiler_id="INTEL_UNIX_C"
264: flags_dbg_all="-g -g0"
265: flags_dbg_yes="-g"
266: flags_dbg_off=""
267: flags_opt_all="-O -O0 -O1 -O2 -O3 -Os"
268: flags_opt_yes="-O2"
269: flags_opt_off="-O0"
270: else
271: compiler_id="INTEL_WINDOWS_C"
272: flags_dbg_all="/ZI /Zi /zI /zi /ZD /Zd /zD /zd /Z7 /z7 /Oy /Oy-"
273: flags_dbg_all="$flags_dbg_all /debug"
274: flags_dbg_all="$flags_dbg_all /debug:none"
275: flags_dbg_all="$flags_dbg_all /debug:minimal"
276: flags_dbg_all="$flags_dbg_all /debug:partial"
277: flags_dbg_all="$flags_dbg_all /debug:full"
278: flags_dbg_all="$flags_dbg_all /debug:semantic_stepping"
279: flags_dbg_all="$flags_dbg_all /debug:extended"
280: flags_dbg_yes="/Zi /Oy-"
281: flags_dbg_off="/debug:none /Oy-"
282: flags_opt_all="/O /O0 /O1 /O2 /O3 /Od /Og /Og- /Oi /Oi-"
283: flags_opt_yes="/O2"
284: flags_opt_off="/Od"
285: fi
286: else
287: AC_MSG_RESULT([no])
288: fi
289: ])
290:
291:
292: dnl CURL_CHECK_COMPILER_LCC
293: dnl -------------------------------------------------
294: dnl Verify if compiler being used is LCC.
295:
296: AC_DEFUN([CURL_CHECK_COMPILER_LCC], [
297: AC_MSG_CHECKING([if compiler is LCC])
298: CURL_CHECK_DEF([__LCC__], [], [silent])
299: if test "$curl_cv_have_def___LCC__" = "yes"; then
300: AC_MSG_RESULT([yes])
301: compiler_id="LCC"
302: flags_dbg_all="-g"
303: flags_dbg_yes="-g"
304: flags_dbg_off=""
305: flags_opt_all=""
306: flags_opt_yes=""
307: flags_opt_off=""
308: else
309: AC_MSG_RESULT([no])
310: fi
311: ])
312:
313:
314: dnl CURL_CHECK_COMPILER_SGI_MIPS_C
315: dnl -------------------------------------------------
316: dnl Verify if compiler being used is SGI MIPS C.
317:
318: AC_DEFUN([CURL_CHECK_COMPILER_SGI_MIPS_C], [
319: AC_REQUIRE([CURL_CHECK_COMPILER_SGI_MIPSPRO_C])dnl
320: AC_MSG_CHECKING([if compiler is SGI MIPS C])
321: CURL_CHECK_DEF([__GNUC__], [], [silent])
322: CURL_CHECK_DEF([__sgi], [], [silent])
323: if test "$curl_cv_have_def___GNUC__" = "no" &&
324: test "$curl_cv_have_def___sgi" = "yes" &&
325: test "$compiler_id" = "unknown"; then
326: AC_MSG_RESULT([yes])
327: compiler_id="SGI_MIPS_C"
328: flags_dbg_all="-g -g0 -g1 -g2 -g3"
329: flags_dbg_yes="-g"
330: flags_dbg_off=""
331: flags_opt_all="-O -O0 -O1 -O2 -O3 -Ofast"
332: flags_opt_yes="-O2"
333: flags_opt_off="-O0"
334: else
335: AC_MSG_RESULT([no])
336: fi
337: ])
338:
339:
340: dnl CURL_CHECK_COMPILER_SGI_MIPSPRO_C
341: dnl -------------------------------------------------
342: dnl Verify if compiler being used is SGI MIPSpro C.
343:
344: AC_DEFUN([CURL_CHECK_COMPILER_SGI_MIPSPRO_C], [
345: AC_BEFORE([$0],[CURL_CHECK_COMPILER_SGI_MIPS_C])dnl
346: AC_MSG_CHECKING([if compiler is SGI MIPSpro C])
347: CURL_CHECK_DEF([__GNUC__], [], [silent])
348: CURL_CHECK_DEF([_COMPILER_VERSION], [], [silent])
349: CURL_CHECK_DEF([_SGI_COMPILER_VERSION], [], [silent])
350: if test "$curl_cv_have_def___GNUC__" = "no" &&
351: (test "$curl_cv_have_def__SGI_COMPILER_VERSION" = "yes" ||
352: test "$curl_cv_have_def__COMPILER_VERSION" = "yes"); then
353: AC_MSG_RESULT([yes])
354: compiler_id="SGI_MIPSPRO_C"
355: flags_dbg_all="-g -g0 -g1 -g2 -g3"
356: flags_dbg_yes="-g"
357: flags_dbg_off=""
358: flags_opt_all="-O -O0 -O1 -O2 -O3 -Ofast"
359: flags_opt_yes="-O2"
360: flags_opt_off="-O0"
361: else
362: AC_MSG_RESULT([no])
363: fi
364: ])
365:
366:
367: dnl CURL_CHECK_COMPILER_SUNPRO_C
368: dnl -------------------------------------------------
369: dnl Verify if compiler being used is SunPro C.
370:
371: AC_DEFUN([CURL_CHECK_COMPILER_SUNPRO_C], [
372: AC_MSG_CHECKING([if compiler is SunPro C])
373: CURL_CHECK_DEF([__SUNPRO_C], [], [silent])
374: if test "$curl_cv_have_def___SUNPRO_C" = "yes"; then
375: AC_MSG_RESULT([yes])
376: compiler_id="SUNPRO_C"
377: flags_dbg_all="-g -s"
378: flags_dbg_yes="-g"
379: flags_dbg_off="-s"
380: flags_opt_all="-O -xO -xO1 -xO2 -xO3 -xO4 -xO5"
381: flags_opt_yes="-xO2"
382: flags_opt_off=""
383: else
384: AC_MSG_RESULT([no])
385: fi
386: ])
387:
388:
389: dnl CURL_CHECK_COMPILER_TINY_C
390: dnl -------------------------------------------------
391: dnl Verify if compiler being used is Tiny C.
392:
393: AC_DEFUN([CURL_CHECK_COMPILER_TINY_C], [
394: AC_MSG_CHECKING([if compiler is Tiny C])
395: CURL_CHECK_DEF([__TINYC__], [], [silent])
396: if test "$curl_cv_have_def___TINYC__" = "yes"; then
397: AC_MSG_RESULT([yes])
398: compiler_id="TINY_C"
399: flags_dbg_all="-g -b"
400: flags_dbg_yes="-g"
401: flags_dbg_off=""
402: flags_opt_all=""
403: flags_opt_yes=""
404: flags_opt_off=""
405: else
406: AC_MSG_RESULT([no])
407: fi
408: ])
409:
410:
411: dnl CURL_CHECK_COMPILER_WATCOM_C
412: dnl -------------------------------------------------
413: dnl Verify if compiler being used is Watcom C.
414:
415: AC_DEFUN([CURL_CHECK_COMPILER_WATCOM_C], [
416: AC_MSG_CHECKING([if compiler is Watcom C])
417: CURL_CHECK_DEF([__WATCOMC__], [], [silent])
418: if test "$curl_cv_have_def___WATCOMC__" = "yes"; then
419: AC_MSG_RESULT([yes])
420: CURL_CHECK_DEF([__UNIX__], [], [silent])
421: if test "$curl_cv_have_def___UNIX__" = "yes"; then
422: compiler_id="WATCOM_UNIX_C"
423: flags_dbg_all="-g1 -g1+ -g2 -g3"
424: flags_dbg_yes="-g2"
425: flags_dbg_off=""
426: flags_opt_all="-O0 -O1 -O2 -O3"
427: flags_opt_yes="-O2"
428: flags_opt_off="-O0"
429: else
430: compiler_id="WATCOM_WINDOWS_C"
431: flags_dbg_all=""
432: flags_dbg_yes=""
433: flags_dbg_off=""
434: flags_opt_all=""
435: flags_opt_yes=""
436: flags_opt_off=""
437: fi
438: else
439: AC_MSG_RESULT([no])
440: fi
441: ])
442:
443:
444: dnl CURL_CONVERT_INCLUDE_TO_ISYSTEM
445: dnl -------------------------------------------------
446: dnl Changes standard include paths present in CFLAGS
447: dnl and CPPFLAGS into isystem include paths. This is
448: dnl done to prevent GNUC from generating warnings on
449: dnl headers from these locations, although on ancient
450: dnl GNUC versions these warnings are not silenced.
451:
452: AC_DEFUN([CURL_CONVERT_INCLUDE_TO_ISYSTEM], [
453: AC_REQUIRE([CURL_SHFUNC_SQUEEZE])dnl
454: AC_REQUIRE([CURL_CHECK_COMPILER])dnl
455: AC_MSG_CHECKING([convert -I options to -isystem])
456: if test "$compiler_id" = "GNU_C" ||
457: test "$compiler_id" = "CLANG"; then
458: AC_MSG_RESULT([yes])
459: tmp_has_include="no"
460: tmp_chg_FLAGS="$CFLAGS"
461: for word1 in $tmp_chg_FLAGS; do
462: case "$word1" in
463: -I*)
464: tmp_has_include="yes"
465: ;;
466: esac
467: done
468: if test "$tmp_has_include" = "yes"; then
469: tmp_chg_FLAGS=`echo "$tmp_chg_FLAGS" | "$SED" 's/^-I/ -isystem /g'`
470: tmp_chg_FLAGS=`echo "$tmp_chg_FLAGS" | "$SED" 's/ -I/ -isystem /g'`
471: CFLAGS="$tmp_chg_FLAGS"
472: squeeze CFLAGS
473: fi
474: tmp_has_include="no"
475: tmp_chg_FLAGS="$CPPFLAGS"
476: for word1 in $tmp_chg_FLAGS; do
477: case "$word1" in
478: -I*)
479: tmp_has_include="yes"
480: ;;
481: esac
482: done
483: if test "$tmp_has_include" = "yes"; then
484: tmp_chg_FLAGS=`echo "$tmp_chg_FLAGS" | "$SED" 's/^-I/ -isystem /g'`
485: tmp_chg_FLAGS=`echo "$tmp_chg_FLAGS" | "$SED" 's/ -I/ -isystem /g'`
486: CPPFLAGS="$tmp_chg_FLAGS"
487: squeeze CPPFLAGS
488: fi
489: else
490: AC_MSG_RESULT([no])
491: fi
492: ])
493:
494:
495: dnl CURL_COMPILER_WORKS_IFELSE ([ACTION-IF-WORKS], [ACTION-IF-NOT-WORKS])
496: dnl -------------------------------------------------
497: dnl Verify if the C compiler seems to work with the
498: dnl settings that are 'active' at the time the test
499: dnl is performed.
500:
501: AC_DEFUN([CURL_COMPILER_WORKS_IFELSE], [
502: dnl compilation capability verification
503: tmp_compiler_works="unknown"
504: AC_COMPILE_IFELSE([
505: AC_LANG_PROGRAM([[
506: ]],[[
507: int i = 1;
508: return i;
509: ]])
510: ],[
511: tmp_compiler_works="yes"
512: ],[
513: tmp_compiler_works="no"
514: echo " " >&6
515: sed 's/^/cc-fail: /' conftest.err >&6
516: echo " " >&6
517: ])
518: dnl linking capability verification
519: if test "$tmp_compiler_works" = "yes"; then
520: AC_LINK_IFELSE([
521: AC_LANG_PROGRAM([[
522: ]],[[
523: int i = 1;
524: return i;
525: ]])
526: ],[
527: tmp_compiler_works="yes"
528: ],[
529: tmp_compiler_works="no"
530: echo " " >&6
531: sed 's/^/link-fail: /' conftest.err >&6
532: echo " " >&6
533: ])
534: fi
535: dnl only do runtime verification when not cross-compiling
536: if test "x$cross_compiling" != "xyes" &&
537: test "$tmp_compiler_works" = "yes"; then
538: CURL_RUN_IFELSE([
539: AC_LANG_PROGRAM([[
540: # ifdef __STDC__
541: # include <stdlib.h>
542: # endif
543: ]],[[
544: int i = 0;
545: exit(i);
546: ]])
547: ],[
548: tmp_compiler_works="yes"
549: ],[
550: tmp_compiler_works="no"
551: echo " " >&6
552: echo "run-fail: test program exited with status $ac_status" >&6
553: echo " " >&6
554: ])
555: fi
556: dnl branch upon test result
557: if test "$tmp_compiler_works" = "yes"; then
558: ifelse($1,,:,[$1])
559: ifelse($2,,,[else
560: $2])
561: fi
562: ])
563:
564:
565: dnl CURL_SET_COMPILER_BASIC_OPTS
566: dnl -------------------------------------------------
567: dnl Sets compiler specific options/flags which do not
568: dnl depend on configure's debug, optimize or warnings
569: dnl options.
570:
571: AC_DEFUN([CURL_SET_COMPILER_BASIC_OPTS], [
572: AC_REQUIRE([CURL_CHECK_COMPILER])dnl
573: AC_REQUIRE([CURL_SHFUNC_SQUEEZE])dnl
574: #
575: if test "$compiler_id" != "unknown"; then
576: #
577: tmp_save_CPPFLAGS="$CPPFLAGS"
578: tmp_save_CFLAGS="$CFLAGS"
579: tmp_CPPFLAGS=""
580: tmp_CFLAGS=""
581: #
582: case "$compiler_id" in
583: #
584: CLANG)
585: #
586: dnl Disable warnings for unused arguments, otherwise clang will
587: dnl warn about compile-time arguments used during link-time, like
588: dnl -O and -g and -pedantic.
589: tmp_CFLAGS="$tmp_CFLAGS -Qunused-arguments"
590: ;;
591: #
592: DEC_C)
593: #
594: dnl Select strict ANSI C compiler mode
595: tmp_CFLAGS="$tmp_CFLAGS -std1"
596: dnl Turn off optimizer ANSI C aliasing rules
597: tmp_CFLAGS="$tmp_CFLAGS -noansi_alias"
598: dnl Generate warnings for missing function prototypes
599: tmp_CFLAGS="$tmp_CFLAGS -warnprotos"
600: dnl Change some warnings into fatal errors
601: tmp_CFLAGS="$tmp_CFLAGS -msg_fatal toofewargs,toomanyargs"
602: ;;
603: #
604: GNU_C)
605: #
606: dnl turn implicit-function-declaration warning into error,
607: dnl at least gcc 2.95 and later support this
608: if test "$compiler_num" -ge "295"; then
609: tmp_CFLAGS="$tmp_CFLAGS -Werror-implicit-function-declaration"
610: fi
611: ;;
612: #
613: HP_UX_C)
614: #
615: dnl Disallow run-time dereferencing of null pointers
616: tmp_CFLAGS="$tmp_CFLAGS -z"
617: dnl Disable some remarks
618: dnl #4227: padding struct with n bytes to align member
619: dnl #4255: padding size of struct with n bytes to alignment boundary
620: tmp_CFLAGS="$tmp_CFLAGS +W 4227,4255"
621: ;;
622: #
623: IBM_C)
624: #
625: dnl Ensure that compiler optimizations are always thread-safe.
626: tmp_CPPFLAGS="$tmp_CPPFLAGS -qthreaded"
627: dnl Disable type based strict aliasing optimizations, using worst
628: dnl case aliasing assumptions when compiling. Type based aliasing
629: dnl would restrict the lvalues that could be safely used to access
630: dnl a data object.
631: tmp_CPPFLAGS="$tmp_CPPFLAGS -qnoansialias"
632: dnl Force compiler to stop after the compilation phase, without
633: dnl generating an object code file when compilation has errors.
634: tmp_CPPFLAGS="$tmp_CPPFLAGS -qhalt=e"
635: ;;
636: #
637: INTEL_UNIX_C)
638: #
639: dnl On unix this compiler uses gcc's header files, so
640: dnl we select ANSI C89 dialect plus GNU extensions.
641: tmp_CFLAGS="$tmp_CFLAGS -std=gnu89"
642: dnl Change some warnings into errors
643: dnl #140: too many arguments in function call
644: dnl #147: declaration is incompatible with 'previous one'
645: dnl #165: too few arguments in function call
646: dnl #266: function declared implicitly
647: tmp_CPPFLAGS="$tmp_CPPFLAGS -we140,147,165,266"
648: dnl Disable some remarks
649: dnl #279: controlling expression is constant
650: dnl #981: operands are evaluated in unspecified order
651: dnl #1469: "cc" clobber ignored
652: tmp_CPPFLAGS="$tmp_CPPFLAGS -wd279,981,1469"
653: ;;
654: #
655: INTEL_WINDOWS_C)
656: #
657: dnl Placeholder
658: tmp_CFLAGS="$tmp_CFLAGS"
659: ;;
660: #
661: LCC)
662: #
663: dnl Disallow run-time dereferencing of null pointers
664: tmp_CFLAGS="$tmp_CFLAGS -n"
665: ;;
666: #
667: SGI_MIPS_C)
668: #
669: dnl Placeholder
670: tmp_CFLAGS="$tmp_CFLAGS"
671: ;;
672: #
673: SGI_MIPSPRO_C)
674: #
675: dnl Placeholder
676: tmp_CFLAGS="$tmp_CFLAGS"
677: ;;
678: #
679: SUNPRO_C)
680: #
681: dnl Placeholder
682: tmp_CFLAGS="$tmp_CFLAGS"
683: ;;
684: #
685: TINY_C)
686: #
687: dnl Placeholder
688: tmp_CFLAGS="$tmp_CFLAGS"
689: ;;
690: #
691: WATCOM_UNIX_C)
692: #
693: dnl Placeholder
694: tmp_CFLAGS="$tmp_CFLAGS"
695: ;;
696: #
697: WATCOM_WINDOWS_C)
698: #
699: dnl Placeholder
700: tmp_CFLAGS="$tmp_CFLAGS"
701: ;;
702: #
703: esac
704: #
705: squeeze tmp_CPPFLAGS
706: squeeze tmp_CFLAGS
707: #
708: if test ! -z "$tmp_CFLAGS" || test ! -z "$tmp_CPPFLAGS"; then
709: AC_MSG_CHECKING([if compiler accepts some basic options])
710: CPPFLAGS="$tmp_save_CPPFLAGS $tmp_CPPFLAGS"
711: CFLAGS="$tmp_save_CFLAGS $tmp_CFLAGS"
712: squeeze CPPFLAGS
713: squeeze CFLAGS
714: CURL_COMPILER_WORKS_IFELSE([
715: AC_MSG_RESULT([yes])
716: AC_MSG_NOTICE([compiler options added: $tmp_CFLAGS $tmp_CPPFLAGS])
717: ],[
718: AC_MSG_RESULT([no])
719: AC_MSG_WARN([compiler options rejected: $tmp_CFLAGS $tmp_CPPFLAGS])
720: dnl restore initial settings
721: CPPFLAGS="$tmp_save_CPPFLAGS"
722: CFLAGS="$tmp_save_CFLAGS"
723: ])
724: fi
725: #
726: fi
727: ])
728:
729:
730: dnl CURL_SET_COMPILER_DEBUG_OPTS
731: dnl -------------------------------------------------
732: dnl Sets compiler specific options/flags which depend
733: dnl on configure's debug option.
734:
735: AC_DEFUN([CURL_SET_COMPILER_DEBUG_OPTS], [
736: AC_REQUIRE([CURL_CHECK_OPTION_DEBUG])dnl
737: AC_REQUIRE([CURL_CHECK_COMPILER])dnl
738: AC_REQUIRE([CURL_SHFUNC_SQUEEZE])dnl
739: #
740: if test "$compiler_id" != "unknown"; then
741: #
742: tmp_save_CFLAGS="$CFLAGS"
743: tmp_save_CPPFLAGS="$CPPFLAGS"
744: #
745: tmp_options=""
746: tmp_CFLAGS="$CFLAGS"
747: tmp_CPPFLAGS="$CPPFLAGS"
748: CURL_VAR_STRIP([tmp_CFLAGS],[$flags_dbg_all])
749: CURL_VAR_STRIP([tmp_CPPFLAGS],[$flags_dbg_all])
750: #
751: if test "$want_debug" = "yes"; then
752: AC_MSG_CHECKING([if compiler accepts debug enabling options])
753: tmp_options="$flags_dbg_yes"
754: fi
755: if test "$want_debug" = "no"; then
756: AC_MSG_CHECKING([if compiler accepts debug disabling options])
757: tmp_options="$flags_dbg_off"
758: fi
759: #
760: if test "$flags_prefer_cppflags" = "yes"; then
761: CPPFLAGS="$tmp_CPPFLAGS $tmp_options"
762: CFLAGS="$tmp_CFLAGS"
763: else
764: CPPFLAGS="$tmp_CPPFLAGS"
765: CFLAGS="$tmp_CFLAGS $tmp_options"
766: fi
767: squeeze CPPFLAGS
768: squeeze CFLAGS
769: CURL_COMPILER_WORKS_IFELSE([
770: AC_MSG_RESULT([yes])
771: AC_MSG_NOTICE([compiler options added: $tmp_options])
772: ],[
773: AC_MSG_RESULT([no])
774: AC_MSG_WARN([compiler options rejected: $tmp_options])
775: dnl restore initial settings
776: CPPFLAGS="$tmp_save_CPPFLAGS"
777: CFLAGS="$tmp_save_CFLAGS"
778: ])
779: #
780: fi
781: ])
782:
783:
784: dnl CURL_SET_COMPILER_OPTIMIZE_OPTS
785: dnl -------------------------------------------------
786: dnl Sets compiler specific options/flags which depend
787: dnl on configure's optimize option.
788:
789: AC_DEFUN([CURL_SET_COMPILER_OPTIMIZE_OPTS], [
790: AC_REQUIRE([CURL_CHECK_OPTION_OPTIMIZE])dnl
791: AC_REQUIRE([CURL_CHECK_COMPILER])dnl
792: AC_REQUIRE([CURL_SHFUNC_SQUEEZE])dnl
793: #
794: if test "$compiler_id" != "unknown"; then
795: #
796: tmp_save_CFLAGS="$CFLAGS"
797: tmp_save_CPPFLAGS="$CPPFLAGS"
798: #
799: tmp_options=""
800: tmp_CFLAGS="$CFLAGS"
801: tmp_CPPFLAGS="$CPPFLAGS"
802: honor_optimize_option="yes"
803: #
804: dnl If optimization request setting has not been explicitly specified,
805: dnl it has been derived from the debug setting and initially assumed.
806: dnl This initially assumed optimizer setting will finally be ignored
807: dnl if CFLAGS or CPPFLAGS already hold optimizer flags. This implies
808: dnl that an initially assumed optimizer setting might not be honored.
809: #
810: if test "$want_optimize" = "assume_no" ||
811: test "$want_optimize" = "assume_yes"; then
812: AC_MSG_CHECKING([if compiler optimizer assumed setting might be used])
813: CURL_VAR_MATCH_IFELSE([tmp_CFLAGS],[$flags_opt_all],[
814: honor_optimize_option="no"
815: ])
816: CURL_VAR_MATCH_IFELSE([tmp_CPPFLAGS],[$flags_opt_all],[
817: honor_optimize_option="no"
818: ])
819: AC_MSG_RESULT([$honor_optimize_option])
820: if test "$honor_optimize_option" = "yes"; then
821: if test "$want_optimize" = "assume_yes"; then
822: want_optimize="yes"
823: fi
824: if test "$want_optimize" = "assume_no"; then
825: want_optimize="no"
826: fi
827: fi
828: fi
829: #
830: if test "$honor_optimize_option" = "yes"; then
831: CURL_VAR_STRIP([tmp_CFLAGS],[$flags_opt_all])
832: CURL_VAR_STRIP([tmp_CPPFLAGS],[$flags_opt_all])
833: if test "$want_optimize" = "yes"; then
834: AC_MSG_CHECKING([if compiler accepts optimizer enabling options])
835: tmp_options="$flags_opt_yes"
836: fi
837: if test "$want_optimize" = "no"; then
838: AC_MSG_CHECKING([if compiler accepts optimizer disabling options])
839: tmp_options="$flags_opt_off"
840: fi
841: if test "$flags_prefer_cppflags" = "yes"; then
842: CPPFLAGS="$tmp_CPPFLAGS $tmp_options"
843: CFLAGS="$tmp_CFLAGS"
844: else
845: CPPFLAGS="$tmp_CPPFLAGS"
846: CFLAGS="$tmp_CFLAGS $tmp_options"
847: fi
848: squeeze CPPFLAGS
849: squeeze CFLAGS
850: CURL_COMPILER_WORKS_IFELSE([
851: AC_MSG_RESULT([yes])
852: AC_MSG_NOTICE([compiler options added: $tmp_options])
853: ],[
854: AC_MSG_RESULT([no])
855: AC_MSG_WARN([compiler options rejected: $tmp_options])
856: dnl restore initial settings
857: CPPFLAGS="$tmp_save_CPPFLAGS"
858: CFLAGS="$tmp_save_CFLAGS"
859: ])
860: fi
861: #
862: fi
863: ])
864:
865:
866: dnl CURL_SET_COMPILER_WARNING_OPTS
867: dnl -------------------------------------------------
868: dnl Sets compiler options/flags which depend on
869: dnl configure's warnings given option.
870:
871: AC_DEFUN([CURL_SET_COMPILER_WARNING_OPTS], [
872: AC_REQUIRE([CURL_CHECK_OPTION_WARNINGS])dnl
873: AC_REQUIRE([CURL_CHECK_COMPILER])dnl
874: AC_REQUIRE([CURL_SHFUNC_SQUEEZE])dnl
875: #
876: if test "$compiler_id" != "unknown"; then
877: #
878: tmp_save_CPPFLAGS="$CPPFLAGS"
879: tmp_save_CFLAGS="$CFLAGS"
880: tmp_CPPFLAGS=""
881: tmp_CFLAGS=""
882: #
883: case "$compiler_id" in
884: #
885: CLANG)
886: #
887: if test "$want_warnings" = "yes"; then
888: tmp_CFLAGS="$tmp_CFLAGS -pedantic"
889: tmp_CFLAGS="$tmp_CFLAGS -Wall -Wextra"
890: tmp_CFLAGS="$tmp_CFLAGS -Wpointer-arith -Wwrite-strings"
891: tmp_CFLAGS="$tmp_CFLAGS -Wshadow"
892: tmp_CFLAGS="$tmp_CFLAGS -Winline -Wnested-externs"
893: tmp_CFLAGS="$tmp_CFLAGS -Wmissing-declarations"
894: tmp_CFLAGS="$tmp_CFLAGS -Wmissing-prototypes"
895: tmp_CFLAGS="$tmp_CFLAGS -Wno-long-long"
896: tmp_CFLAGS="$tmp_CFLAGS -Wfloat-equal"
897: tmp_CFLAGS="$tmp_CFLAGS -Wno-multichar -Wsign-compare"
898: tmp_CFLAGS="$tmp_CFLAGS -Wundef"
899: tmp_CFLAGS="$tmp_CFLAGS -Wno-format-nonliteral"
900: tmp_CFLAGS="$tmp_CFLAGS -Wendif-labels -Wstrict-prototypes"
901: tmp_CFLAGS="$tmp_CFLAGS -Wdeclaration-after-statement"
902: tmp_CFLAGS="$tmp_CFLAGS -Wcast-align"
903: tmp_CFLAGS="$tmp_CFLAGS -Wno-system-headers"
904: tmp_CFLAGS="$tmp_CFLAGS -Wshorten-64-to-32"
905: #
906: dnl Only clang 1.1 or later
907: if test "$compiler_num" -ge "101"; then
908: tmp_CFLAGS="$tmp_CFLAGS -Wunused"
909: fi
910: #
911: dnl Only clang 2.8 or later
912: if test "$compiler_num" -ge "208"; then
913: tmp_CFLAGS="$tmp_CFLAGS -Wvla"
914: fi
915: #
916: dnl Only clang 2.9 or later
917: if test "$compiler_num" -ge "209"; then
918: tmp_CFLAGS="$tmp_CFLAGS -Wshift-sign-overflow"
919: fi
920: #
921: dnl Only clang 3.2 or later
922: if test "$compiler_num" -ge "302"; then
923: case $host_os in
924: cygwin* | mingw*)
925: dnl skip missing-variable-declarations warnings for cygwin and
926: dnl mingw because the libtool wrapper executable causes them
927: ;;
928: *)
929: tmp_CFLAGS="$tmp_CFLAGS -Wmissing-variable-declarations"
930: ;;
931: esac
932: fi
933: #
934: dnl Only clang 3.6 or later
935: if test "$compiler_num" -ge "306"; then
936: tmp_CFLAGS="$tmp_CFLAGS -Wdouble-promotion"
937: fi
938: #
939: dnl Only clang 3.9 or later
940: if test "$compiler_num" -ge "309"; then
941: tmp_CFLAGS="$tmp_CFLAGS -Wcomma"
942: # avoid the varargs warning, fixed in 4.0
943: # https://bugs.llvm.org/show_bug.cgi?id=29140
944: if test "$compiler_num" -lt "400"; then
945: tmp_CFLAGS="$tmp_CFLAGS -Wno-varargs"
946: fi
947: fi
948: fi
949: ;;
950: #
951: DEC_C)
952: #
953: if test "$want_warnings" = "yes"; then
954: dnl Select a higher warning level than default level2
955: tmp_CFLAGS="$tmp_CFLAGS -msg_enable level3"
956: fi
957: ;;
958: #
959: GNU_C)
960: #
961: if test "$want_warnings" = "yes"; then
962: #
963: dnl Do not enable -pedantic when cross-compiling with a gcc older
964: dnl than 3.0, to avoid warnings from third party system headers.
965: if test "x$cross_compiling" != "xyes" ||
966: test "$compiler_num" -ge "300"; then
967: tmp_CFLAGS="$tmp_CFLAGS -pedantic"
968: fi
969: #
970: dnl Set of options we believe *ALL* gcc versions support:
971: tmp_CFLAGS="$tmp_CFLAGS -Wall -W"
972: #
973: dnl Only gcc 1.4 or later
974: if test "$compiler_num" -ge "104"; then
975: tmp_CFLAGS="$tmp_CFLAGS -Wpointer-arith -Wwrite-strings"
976: dnl If not cross-compiling with a gcc older than 3.0
977: if test "x$cross_compiling" != "xyes" ||
978: test "$compiler_num" -ge "300"; then
979: tmp_CFLAGS="$tmp_CFLAGS -Wunused -Wshadow"
980: fi
981: fi
982: #
983: dnl Only gcc 2.7 or later
984: if test "$compiler_num" -ge "207"; then
985: tmp_CFLAGS="$tmp_CFLAGS -Winline -Wnested-externs"
986: dnl If not cross-compiling with a gcc older than 3.0
987: if test "x$cross_compiling" != "xyes" ||
988: test "$compiler_num" -ge "300"; then
989: tmp_CFLAGS="$tmp_CFLAGS -Wmissing-declarations"
990: tmp_CFLAGS="$tmp_CFLAGS -Wmissing-prototypes"
991: fi
992: fi
993: #
994: dnl Only gcc 2.95 or later
995: if test "$compiler_num" -ge "295"; then
996: tmp_CFLAGS="$tmp_CFLAGS -Wno-long-long"
997: tmp_CFLAGS="$tmp_CFLAGS -Wbad-function-cast"
998: fi
999: #
1000: dnl Only gcc 2.96 or later
1001: if test "$compiler_num" -ge "296"; then
1002: tmp_CFLAGS="$tmp_CFLAGS -Wfloat-equal"
1003: tmp_CFLAGS="$tmp_CFLAGS -Wno-multichar -Wsign-compare"
1004: dnl -Wundef used only if gcc is 2.96 or later since we get
1005: dnl lots of "`_POSIX_C_SOURCE' is not defined" in system
1006: dnl headers with gcc 2.95.4 on FreeBSD 4.9
1007: tmp_CFLAGS="$tmp_CFLAGS -Wundef"
1008: fi
1009: #
1010: dnl Only gcc 2.97 or later
1011: if test "$compiler_num" -ge "297"; then
1012: tmp_CFLAGS="$tmp_CFLAGS -Wno-format-nonliteral"
1013: fi
1014: #
1015: dnl Only gcc 3.0 or later
1016: if test "$compiler_num" -ge "300"; then
1017: dnl -Wunreachable-code seems totally unreliable on my gcc 3.3.2 on
1018: dnl on i686-Linux as it gives us heaps with false positives.
1019: dnl Also, on gcc 4.0.X it is totally unbearable and complains all
1020: dnl over making it unusable for generic purposes. Let's not use it.
1021: tmp_CFLAGS="$tmp_CFLAGS"
1022: fi
1023: #
1024: dnl Only gcc 3.3 or later
1025: if test "$compiler_num" -ge "303"; then
1026: tmp_CFLAGS="$tmp_CFLAGS -Wendif-labels -Wstrict-prototypes"
1027: fi
1028: #
1029: dnl Only gcc 3.4 or later
1030: if test "$compiler_num" -ge "304"; then
1031: tmp_CFLAGS="$tmp_CFLAGS -Wdeclaration-after-statement"
1032: tmp_CFLAGS="$tmp_CFLAGS -Wold-style-definition"
1033: fi
1034: #
1035: dnl Only gcc 4.0 or later
1036: if test "$compiler_num" -ge "400"; then
1037: tmp_CFLAGS="$tmp_CFLAGS -Wstrict-aliasing=3"
1038: fi
1039: #
1040: dnl Only gcc 4.2 or later
1041: if test "$compiler_num" -ge "402"; then
1042: tmp_CFLAGS="$tmp_CFLAGS -Wcast-align"
1043: fi
1044: #
1045: dnl Only gcc 4.3 or later
1046: if test "$compiler_num" -ge "403"; then
1047: tmp_CFLAGS="$tmp_CFLAGS -Wtype-limits -Wold-style-declaration"
1048: tmp_CFLAGS="$tmp_CFLAGS -Wmissing-parameter-type -Wempty-body"
1049: tmp_CFLAGS="$tmp_CFLAGS -Wclobbered -Wignored-qualifiers"
1050: tmp_CFLAGS="$tmp_CFLAGS -Wconversion -Wno-sign-conversion -Wvla"
1051: dnl required for -Warray-bounds, included in -Wall
1052: tmp_CFLAGS="$tmp_CFLAGS -ftree-vrp"
1053: fi
1054: #
1055: dnl Only gcc 4.5 or later
1056: if test "$compiler_num" -ge "405"; then
1057: dnl Only windows targets
1058: if test "$curl_cv_have_def__WIN32" = "yes"; then
1059: tmp_CFLAGS="$tmp_CFLAGS -Wno-pedantic-ms-format"
1060: fi
1061: fi
1062: #
1063: dnl Only gcc 4.6 or later
1064: if test "$compiler_num" -ge "406"; then
1065: tmp_CFLAGS="$tmp_CFLAGS -Wdouble-promotion"
1066: fi
1067: #
1068: dnl only gcc 4.8 or later
1069: if test "$compiler_num" -ge "408"; then
1070: tmp_CFLAGS="$tmp_CFLAGS -Wformat=2"
1071: fi
1072: #
1073: dnl Only gcc 5 or later
1074: if test "$compiler_num" -ge "500"; then
1075: tmp_CFLAGS="$tmp_CFLAGS -Warray-bounds=2"
1076: fi
1077: #
1078: dnl Only gcc 6 or later
1079: if test "$compiler_num" -ge "600"; then
1080: tmp_CFLAGS="$tmp_CFLAGS -Wshift-negative-value"
1081: tmp_CFLAGS="$tmp_CFLAGS -Wshift-overflow=2"
1082: tmp_CFLAGS="$tmp_CFLAGS -Wnull-dereference -fdelete-null-pointer-checks"
1083: tmp_CFLAGS="$tmp_CFLAGS -Wduplicated-cond"
1084: tmp_CFLAGS="$tmp_CFLAGS -Wunused-const-variable"
1085: fi
1086: #
1087: dnl Only gcc 7 or later
1088: if test "$compiler_num" -ge "700"; then
1089: tmp_CFLAGS="$tmp_CFLAGS -Wduplicated-branches"
1090: tmp_CFLAGS="$tmp_CFLAGS -Wrestrict"
1091: tmp_CFLAGS="$tmp_CFLAGS -Walloc-zero"
1092: tmp_CFLAGS="$tmp_CFLAGS -Wformat-overflow=2"
1093: tmp_CFLAGS="$tmp_CFLAGS -Wformat-truncation=2"
1094: tmp_CFLAGS="$tmp_CFLAGS -Wimplicit-fallthrough=4"
1095: fi
1096: #
1097: fi
1098: #
1099: dnl Do not issue warnings for code in system include paths.
1100: if test "$compiler_num" -ge "300"; then
1101: tmp_CFLAGS="$tmp_CFLAGS -Wno-system-headers"
1102: else
1103: dnl When cross-compiling with a gcc older than 3.0, disable
1104: dnl some warnings triggered on third party system headers.
1105: if test "x$cross_compiling" = "xyes"; then
1106: if test "$compiler_num" -ge "104"; then
1107: dnl gcc 1.4 or later
1108: tmp_CFLAGS="$tmp_CFLAGS -Wno-unused -Wno-shadow"
1109: fi
1110: if test "$compiler_num" -ge "207"; then
1111: dnl gcc 2.7 or later
1112: tmp_CFLAGS="$tmp_CFLAGS -Wno-missing-declarations"
1113: tmp_CFLAGS="$tmp_CFLAGS -Wno-missing-prototypes"
1114: fi
1115: fi
1116: fi
1117: ;;
1118: #
1119: HP_UX_C)
1120: #
1121: if test "$want_warnings" = "yes"; then
1122: dnl Issue all warnings
1123: tmp_CFLAGS="$tmp_CFLAGS +w1"
1124: fi
1125: ;;
1126: #
1127: IBM_C)
1128: #
1129: dnl Placeholder
1130: tmp_CFLAGS="$tmp_CFLAGS"
1131: ;;
1132: #
1133: INTEL_UNIX_C)
1134: #
1135: if test "$want_warnings" = "yes"; then
1136: if test "$compiler_num" -gt "600"; then
1137: dnl Show errors, warnings, and remarks
1138: tmp_CPPFLAGS="$tmp_CPPFLAGS -Wall -w2"
1139: dnl Perform extra compile-time code checking
1140: tmp_CPPFLAGS="$tmp_CPPFLAGS -Wcheck"
1141: dnl Warn on nested comments
1142: tmp_CPPFLAGS="$tmp_CPPFLAGS -Wcomment"
1143: dnl Show warnings relative to deprecated features
1144: tmp_CPPFLAGS="$tmp_CPPFLAGS -Wdeprecated"
1145: dnl Enable warnings for missing prototypes
1146: tmp_CPPFLAGS="$tmp_CPPFLAGS -Wmissing-prototypes"
1147: dnl Enable warnings for 64-bit portability issues
1148: tmp_CPPFLAGS="$tmp_CPPFLAGS -Wp64"
1149: dnl Enable warnings for questionable pointer arithmetic
1150: tmp_CPPFLAGS="$tmp_CPPFLAGS -Wpointer-arith"
1151: dnl Check for function return typw issues
1152: tmp_CPPFLAGS="$tmp_CPPFLAGS -Wreturn-type"
1153: dnl Warn on variable declarations hiding a previous one
1154: tmp_CPPFLAGS="$tmp_CPPFLAGS -Wshadow"
1155: dnl Warn when a variable is used before initialized
1156: tmp_CPPFLAGS="$tmp_CPPFLAGS -Wuninitialized"
1157: dnl Warn if a declared function is not used
1158: tmp_CPPFLAGS="$tmp_CPPFLAGS -Wunused-function"
1159: fi
1160: fi
1161: dnl Disable using EBP register in optimizations
1162: tmp_CFLAGS="$tmp_CFLAGS -fno-omit-frame-pointer"
1163: dnl Disable use of ANSI C aliasing rules in optimizations
1164: tmp_CFLAGS="$tmp_CFLAGS -fno-strict-aliasing"
1165: dnl Value-safe optimizations on floating-point data
1166: tmp_CFLAGS="$tmp_CFLAGS -fp-model precise"
1167: ;;
1168: #
1169: INTEL_WINDOWS_C)
1170: #
1171: dnl Placeholder
1172: tmp_CFLAGS="$tmp_CFLAGS"
1173: ;;
1174: #
1175: LCC)
1176: #
1177: if test "$want_warnings" = "yes"; then
1178: dnl Highest warning level is double -A, next is single -A.
1179: dnl Due to the big number of warnings these trigger on third
1180: dnl party header files it is impractical for us to use any of
1181: dnl them here. If you want them simply define it in CPPFLAGS.
1182: tmp_CFLAGS="$tmp_CFLAGS"
1183: fi
1184: ;;
1185: #
1186: SGI_MIPS_C)
1187: #
1188: if test "$want_warnings" = "yes"; then
1189: dnl Perform stricter semantic and lint-like checks
1190: tmp_CFLAGS="$tmp_CFLAGS -fullwarn"
1191: fi
1192: ;;
1193: #
1194: SGI_MIPSPRO_C)
1195: #
1196: if test "$want_warnings" = "yes"; then
1197: dnl Perform stricter semantic and lint-like checks
1198: tmp_CFLAGS="$tmp_CFLAGS -fullwarn"
1199: dnl Disable some remarks
1200: dnl #1209: controlling expression is constant
1201: tmp_CFLAGS="$tmp_CFLAGS -woff 1209"
1202: fi
1203: ;;
1204: #
1205: SUNPRO_C)
1206: #
1207: if test "$want_warnings" = "yes"; then
1208: dnl Perform stricter semantic and lint-like checks
1209: tmp_CFLAGS="$tmp_CFLAGS -v"
1210: fi
1211: ;;
1212: #
1213: TINY_C)
1214: #
1215: if test "$want_warnings" = "yes"; then
1216: dnl Activate all warnings
1217: tmp_CFLAGS="$tmp_CFLAGS -Wall"
1218: dnl Make string constants be of type const char *
1219: tmp_CFLAGS="$tmp_CFLAGS -Wwrite-strings"
1220: dnl Warn use of unsupported GCC features ignored by TCC
1221: tmp_CFLAGS="$tmp_CFLAGS -Wunsupported"
1222: fi
1223: ;;
1224: #
1225: WATCOM_UNIX_C)
1226: #
1227: if test "$want_warnings" = "yes"; then
1228: dnl Issue all warnings
1229: tmp_CFLAGS="$tmp_CFLAGS -Wall -Wextra"
1230: fi
1231: ;;
1232: #
1233: WATCOM_WINDOWS_C)
1234: #
1235: dnl Placeholder
1236: tmp_CFLAGS="$tmp_CFLAGS"
1237: ;;
1238: #
1239: esac
1240: #
1241: squeeze tmp_CPPFLAGS
1242: squeeze tmp_CFLAGS
1243: #
1244: if test ! -z "$tmp_CFLAGS" || test ! -z "$tmp_CPPFLAGS"; then
1245: AC_MSG_CHECKING([if compiler accepts strict warning options])
1246: CPPFLAGS="$tmp_save_CPPFLAGS $tmp_CPPFLAGS"
1247: CFLAGS="$tmp_save_CFLAGS $tmp_CFLAGS"
1248: squeeze CPPFLAGS
1249: squeeze CFLAGS
1250: CURL_COMPILER_WORKS_IFELSE([
1251: AC_MSG_RESULT([yes])
1252: AC_MSG_NOTICE([compiler options added: $tmp_CFLAGS $tmp_CPPFLAGS])
1253: ],[
1254: AC_MSG_RESULT([no])
1255: AC_MSG_WARN([compiler options rejected: $tmp_CFLAGS $tmp_CPPFLAGS])
1256: dnl restore initial settings
1257: CPPFLAGS="$tmp_save_CPPFLAGS"
1258: CFLAGS="$tmp_save_CFLAGS"
1259: ])
1260: fi
1261: #
1262: fi
1263: ])
1264:
1265:
1266: dnl CURL_SHFUNC_SQUEEZE
1267: dnl -------------------------------------------------
1268: dnl Declares a shell function squeeze() which removes
1269: dnl redundant whitespace out of a shell variable.
1270:
1271: AC_DEFUN([CURL_SHFUNC_SQUEEZE], [
1272: squeeze() {
1273: _sqz_result=""
1274: eval _sqz_input=\[$][$]1
1275: for _sqz_token in $_sqz_input; do
1276: if test -z "$_sqz_result"; then
1277: _sqz_result="$_sqz_token"
1278: else
1279: _sqz_result="$_sqz_result $_sqz_token"
1280: fi
1281: done
1282: eval [$]1=\$_sqz_result
1283: return 0
1284: }
1285: ])
1286:
1287:
1288: dnl CURL_CHECK_CURLDEBUG
1289: dnl -------------------------------------------------
1290: dnl Settings which depend on configure's curldebug given
1291: dnl option, and other additional configure pre-requisites.
1292: dnl Actually the curl debug memory tracking feature can
1293: dnl only be used/enabled when libcurl is built as a static
1294: dnl library or as a shared one on those systems on which
1295: dnl shared libraries support undefined symbols.
1296:
1297: AC_DEFUN([CURL_CHECK_CURLDEBUG], [
1298: AC_REQUIRE([XC_LIBTOOL])dnl
1299: AC_REQUIRE([CURL_SHFUNC_SQUEEZE])dnl
1300: supports_curldebug="unknown"
1301: if test "$want_curldebug" = "yes"; then
1302: if test "x$enable_shared" != "xno" &&
1303: test "x$enable_shared" != "xyes"; then
1304: AC_MSG_WARN([unknown enable_shared setting.])
1305: supports_curldebug="no"
1306: fi
1307: if test "x$enable_static" != "xno" &&
1308: test "x$enable_static" != "xyes"; then
1309: AC_MSG_WARN([unknown enable_static setting.])
1310: supports_curldebug="no"
1311: fi
1312: if test "$supports_curldebug" != "no"; then
1313: if test "$enable_shared" = "yes" &&
1314: test "x$xc_lt_shlib_use_no_undefined" = 'xyes'; then
1315: supports_curldebug="no"
1316: AC_MSG_WARN([shared library does not support undefined symbols.])
1317: fi
1318: fi
1319: fi
1320: #
1321: if test "$want_curldebug" = "yes"; then
1322: AC_MSG_CHECKING([if curl debug memory tracking can be enabled])
1323: test "$supports_curldebug" = "no" || supports_curldebug="yes"
1324: AC_MSG_RESULT([$supports_curldebug])
1325: if test "$supports_curldebug" = "no"; then
1326: AC_MSG_WARN([cannot enable curl debug memory tracking.])
1327: want_curldebug="no"
1328: fi
1329: fi
1330: ])
1331:
1332:
1333:
1334: dnl CURL_CHECK_COMPILER_HALT_ON_ERROR
1335: dnl -------------------------------------------------
1336: dnl Verifies if the compiler actually halts after the
1337: dnl compilation phase without generating any object
1338: dnl code file, when the source compiles with errors.
1339:
1340: AC_DEFUN([CURL_CHECK_COMPILER_HALT_ON_ERROR], [
1341: AC_MSG_CHECKING([if compiler halts on compilation errors])
1342: AC_COMPILE_IFELSE([
1343: AC_LANG_PROGRAM([[
1344: ]],[[
1345: force compilation error
1346: ]])
1347: ],[
1348: AC_MSG_RESULT([no])
1349: AC_MSG_ERROR([compiler does not halt on compilation errors.])
1350: ],[
1351: AC_MSG_RESULT([yes])
1352: ])
1353: ])
1354:
1355:
1356: dnl CURL_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE
1357: dnl -------------------------------------------------
1358: dnl Verifies if the compiler actually halts after the
1359: dnl compilation phase without generating any object
1360: dnl code file, when the source code tries to define a
1361: dnl type for a constant array with negative dimension.
1362:
1363: AC_DEFUN([CURL_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE], [
1364: AC_REQUIRE([CURL_CHECK_COMPILER_HALT_ON_ERROR])dnl
1365: AC_MSG_CHECKING([if compiler halts on negative sized arrays])
1366: AC_COMPILE_IFELSE([
1367: AC_LANG_PROGRAM([[
1368: typedef char bad_t[sizeof(char) == sizeof(int) ? -1 : -1 ];
1369: ]],[[
1370: bad_t dummy;
1371: ]])
1372: ],[
1373: AC_MSG_RESULT([no])
1374: AC_MSG_ERROR([compiler does not halt on negative sized arrays.])
1375: ],[
1376: AC_MSG_RESULT([yes])
1377: ])
1378: ])
1379:
1380:
1381: dnl CURL_CHECK_COMPILER_STRUCT_MEMBER_SIZE
1382: dnl -------------------------------------------------
1383: dnl Verifies if the compiler is capable of handling the
1384: dnl size of a struct member, struct which is a function
1385: dnl result, as a compilation-time condition inside the
1386: dnl type definition of a constant array.
1387:
1388: AC_DEFUN([CURL_CHECK_COMPILER_STRUCT_MEMBER_SIZE], [
1389: AC_REQUIRE([CURL_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE])dnl
1390: AC_MSG_CHECKING([if compiler struct member size checking works])
1391: tst_compiler_check_one_works="unknown"
1392: AC_COMPILE_IFELSE([
1393: AC_LANG_PROGRAM([[
1394: struct mystruct {
1395: int mi;
1396: char mc;
1397: struct mystruct *next;
1398: };
1399: struct mystruct myfunc();
1400: typedef char good_t1[sizeof(myfunc().mi) == sizeof(int) ? 1 : -1 ];
1401: typedef char good_t2[sizeof(myfunc().mc) == sizeof(char) ? 1 : -1 ];
1402: ]],[[
1403: good_t1 dummy1;
1404: good_t2 dummy2;
1405: ]])
1406: ],[
1407: tst_compiler_check_one_works="yes"
1408: ],[
1409: tst_compiler_check_one_works="no"
1410: sed 's/^/cc-src: /' conftest.$ac_ext >&6
1411: sed 's/^/cc-err: /' conftest.err >&6
1412: ])
1413: tst_compiler_check_two_works="unknown"
1414: AC_COMPILE_IFELSE([
1415: AC_LANG_PROGRAM([[
1416: struct mystruct {
1417: int mi;
1418: char mc;
1419: struct mystruct *next;
1420: };
1421: struct mystruct myfunc();
1422: typedef char bad_t1[sizeof(myfunc().mi) != sizeof(int) ? 1 : -1 ];
1423: typedef char bad_t2[sizeof(myfunc().mc) != sizeof(char) ? 1 : -1 ];
1424: ]],[[
1425: bad_t1 dummy1;
1426: bad_t2 dummy2;
1427: ]])
1428: ],[
1429: tst_compiler_check_two_works="no"
1430: ],[
1431: tst_compiler_check_two_works="yes"
1432: ])
1433: if test "$tst_compiler_check_one_works" = "yes" &&
1434: test "$tst_compiler_check_two_works" = "yes"; then
1435: AC_MSG_RESULT([yes])
1436: else
1437: AC_MSG_RESULT([no])
1438: AC_MSG_ERROR([compiler fails struct member size checking.])
1439: fi
1440: ])
1441:
1442:
1443: dnl CURL_CHECK_COMPILER_SYMBOL_HIDING
1444: dnl -------------------------------------------------
1445: dnl Verify if compiler supports hiding library internal symbols, setting
1446: dnl shell variable supports_symbol_hiding value as appropriate, as well as
1447: dnl variables symbol_hiding_CFLAGS and symbol_hiding_EXTERN when supported.
1448:
1449: AC_DEFUN([CURL_CHECK_COMPILER_SYMBOL_HIDING], [
1450: AC_REQUIRE([CURL_CHECK_COMPILER])dnl
1451: AC_BEFORE([$0],[CURL_CONFIGURE_SYMBOL_HIDING])dnl
1452: AC_MSG_CHECKING([if compiler supports hiding library internal symbols])
1453: supports_symbol_hiding="no"
1454: symbol_hiding_CFLAGS=""
1455: symbol_hiding_EXTERN=""
1456: tmp_CFLAGS=""
1457: tmp_EXTERN=""
1458: case "$compiler_id" in
1459: CLANG)
1460: dnl All versions of clang support -fvisibility=
1461: tmp_EXTERN="__attribute__ ((__visibility__ (\"default\")))"
1462: tmp_CFLAGS="-fvisibility=hidden"
1463: supports_symbol_hiding="yes"
1464: ;;
1465: GNU_C)
1466: dnl Only gcc 3.4 or later
1467: if test "$compiler_num" -ge "304"; then
1468: if $CC --help --verbose 2>/dev/null | grep fvisibility= >/dev/null ; then
1469: tmp_EXTERN="__attribute__ ((__visibility__ (\"default\")))"
1470: tmp_CFLAGS="-fvisibility=hidden"
1471: supports_symbol_hiding="yes"
1472: fi
1473: fi
1474: ;;
1475: INTEL_UNIX_C)
1476: dnl Only icc 9.0 or later
1477: if test "$compiler_num" -ge "900"; then
1478: if $CC --help --verbose 2>&1 | grep fvisibility= > /dev/null ; then
1479: tmp_save_CFLAGS="$CFLAGS"
1480: CFLAGS="$CFLAGS -fvisibility=hidden"
1481: AC_LINK_IFELSE([
1482: AC_LANG_PROGRAM([[
1483: # include <stdio.h>
1484: ]],[[
1485: printf("icc fvisibility bug test");
1486: ]])
1487: ],[
1488: tmp_EXTERN="__attribute__ ((__visibility__ (\"default\")))"
1489: tmp_CFLAGS="-fvisibility=hidden"
1490: supports_symbol_hiding="yes"
1491: ])
1492: CFLAGS="$tmp_save_CFLAGS"
1493: fi
1494: fi
1495: ;;
1496: SUNPRO_C)
1497: if $CC 2>&1 | grep flags >/dev/null && $CC -flags | grep xldscope= >/dev/null ; then
1498: tmp_EXTERN="__global"
1499: tmp_CFLAGS="-xldscope=hidden"
1500: supports_symbol_hiding="yes"
1501: fi
1502: ;;
1503: esac
1504: if test "$supports_symbol_hiding" = "yes"; then
1505: tmp_save_CFLAGS="$CFLAGS"
1506: CFLAGS="$tmp_save_CFLAGS $tmp_CFLAGS"
1507: squeeze CFLAGS
1508: AC_COMPILE_IFELSE([
1509: AC_LANG_PROGRAM([[
1510: $tmp_EXTERN char *dummy(char *buff);
1511: char *dummy(char *buff)
1512: {
1513: if(buff)
1514: return ++buff;
1515: else
1516: return buff;
1517: }
1518: ]],[[
1519: char b[16];
1520: char *r = dummy(&b[0]);
1521: if(r)
1522: return (int)*r;
1523: ]])
1524: ],[
1525: supports_symbol_hiding="yes"
1526: if test -f conftest.err; then
1527: grep 'visibility' conftest.err >/dev/null
1528: if test "$?" -eq "0"; then
1529: supports_symbol_hiding="no"
1530: fi
1531: fi
1532: ],[
1533: supports_symbol_hiding="no"
1534: echo " " >&6
1535: sed 's/^/cc-src: /' conftest.$ac_ext >&6
1536: sed 's/^/cc-err: /' conftest.err >&6
1537: echo " " >&6
1538: ])
1539: CFLAGS="$tmp_save_CFLAGS"
1540: fi
1541: if test "$supports_symbol_hiding" = "yes"; then
1542: AC_MSG_RESULT([yes])
1543: symbol_hiding_CFLAGS="$tmp_CFLAGS"
1544: symbol_hiding_EXTERN="$tmp_EXTERN"
1545: else
1546: AC_MSG_RESULT([no])
1547: fi
1548: ])
1549:
1550:
1551: dnl CURL_CHECK_COMPILER_PROTOTYPE_MISMATCH
1552: dnl -------------------------------------------------
1553: dnl Verifies if the compiler actually halts after the
1554: dnl compilation phase without generating any object
1555: dnl code file, when the source code tries to redefine
1556: dnl a prototype which does not match previous one.
1557:
1558: AC_DEFUN([CURL_CHECK_COMPILER_PROTOTYPE_MISMATCH], [
1559: AC_REQUIRE([CURL_CHECK_COMPILER_HALT_ON_ERROR])dnl
1560: AC_MSG_CHECKING([if compiler halts on function prototype mismatch])
1561: AC_COMPILE_IFELSE([
1562: AC_LANG_PROGRAM([[
1563: # include <stdlib.h>
1564: int rand(int n);
1565: int rand(int n)
1566: {
1567: if(n)
1568: return ++n;
1569: else
1570: return n;
1571: }
1572: ]],[[
1573: int i[2]={0,0};
1574: int j = rand(i[0]);
1575: if(j)
1576: return j;
1577: ]])
1578: ],[
1579: AC_MSG_RESULT([no])
1580: AC_MSG_ERROR([compiler does not halt on function prototype mismatch.])
1581: ],[
1582: AC_MSG_RESULT([yes])
1583: ])
1584: ])
1585:
1586:
1587: dnl CURL_VAR_MATCH (VARNAME, VALUE)
1588: dnl -------------------------------------------------
1589: dnl Verifies if shell variable VARNAME contains VALUE.
1590: dnl Contents of variable VARNAME and VALUE are handled
1591: dnl as whitespace separated lists of words. If at least
1592: dnl one word of VALUE is present in VARNAME the match
1593: dnl is considered positive, otherwise false.
1594:
1595: AC_DEFUN([CURL_VAR_MATCH], [
1596: ac_var_match_word="no"
1597: for word1 in $[$1]; do
1598: for word2 in [$2]; do
1599: if test "$word1" = "$word2"; then
1600: ac_var_match_word="yes"
1601: fi
1602: done
1603: done
1604: ])
1605:
1606:
1607: dnl CURL_VAR_MATCH_IFELSE (VARNAME, VALUE,
1608: dnl [ACTION-IF-MATCH], [ACTION-IF-NOT-MATCH])
1609: dnl -------------------------------------------------
1610: dnl This performs a CURL_VAR_MATCH check and executes
1611: dnl first branch if the match is positive, otherwise
1612: dnl the second branch is executed.
1613:
1614: AC_DEFUN([CURL_VAR_MATCH_IFELSE], [
1615: CURL_VAR_MATCH([$1],[$2])
1616: if test "$ac_var_match_word" = "yes"; then
1617: ifelse($3,,:,[$3])
1618: ifelse($4,,,[else
1619: $4])
1620: fi
1621: ])
1622:
1623:
1624: dnl CURL_VAR_STRIP (VARNAME, VALUE)
1625: dnl -------------------------------------------------
1626: dnl Contents of variable VARNAME and VALUE are handled
1627: dnl as whitespace separated lists of words. Each word
1628: dnl from VALUE is removed from VARNAME when present.
1629:
1630: AC_DEFUN([CURL_VAR_STRIP], [
1631: AC_REQUIRE([CURL_SHFUNC_SQUEEZE])dnl
1632: ac_var_stripped=""
1633: for word1 in $[$1]; do
1634: ac_var_strip_word="no"
1635: for word2 in [$2]; do
1636: if test "$word1" = "$word2"; then
1637: ac_var_strip_word="yes"
1638: fi
1639: done
1640: if test "$ac_var_strip_word" = "no"; then
1641: ac_var_stripped="$ac_var_stripped $word1"
1642: fi
1643: done
1644: dnl squeeze whitespace out of result
1645: [$1]="$ac_var_stripped"
1646: squeeze [$1]
1647: ])
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to curl-compilers.m4 CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / m4