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
27dnl CURL_CHECK_COMPILER
28dnl -------------------------------------------------
29dnl Verify if the C compiler being used is known.
30
31AC_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
76dnl CURL_CHECK_COMPILER_CLANG
77dnl -------------------------------------------------
78dnl Verify if compiler being used is clang.
79
80AC_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
128dnl CURL_CHECK_COMPILER_DEC_C
129dnl -------------------------------------------------
130dnl Verify if compiler being used is DEC C.
131
132AC_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
152dnl CURL_CHECK_COMPILER_GNU_C
153dnl -------------------------------------------------
154dnl Verify if compiler being used is GNU C
155dnl
156dnl $compiler_num will be set to MAJOR * 100 + MINOR for gcc less than version
157dnl 7 and just $MAJOR * 100 for gcc version 7 and later.
158dnl
159dnl Examples:
160dnl Version 1.2.3 => 102
161dnl Version 2.95  => 295
162dnl Version 4.7 =>   407
163dnl Version 9.2.1 => 900
164dnl
165AC_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
198dnl CURL_CHECK_COMPILER_HPUX_C
199dnl -------------------------------------------------
200dnl Verify if compiler being used is HP-UX C.
201
202AC_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
220dnl CURL_CHECK_COMPILER_IBM_C
221dnl -------------------------------------------------
222dnl Verify if compiler being used is IBM C.
223
224AC_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
250dnl CURL_CHECK_COMPILER_INTEL_C
251dnl -------------------------------------------------
252dnl Verify if compiler being used is Intel C.
253
254AC_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
292dnl CURL_CHECK_COMPILER_LCC
293dnl -------------------------------------------------
294dnl Verify if compiler being used is LCC.
295
296AC_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
314dnl CURL_CHECK_COMPILER_SGI_MIPS_C
315dnl -------------------------------------------------
316dnl Verify if compiler being used is SGI MIPS C.
317
318AC_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
340dnl CURL_CHECK_COMPILER_SGI_MIPSPRO_C
341dnl -------------------------------------------------
342dnl Verify if compiler being used is SGI MIPSpro C.
343
344AC_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
367dnl CURL_CHECK_COMPILER_SUNPRO_C
368dnl -------------------------------------------------
369dnl Verify if compiler being used is SunPro C.
370
371AC_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
389dnl CURL_CHECK_COMPILER_TINY_C
390dnl -------------------------------------------------
391dnl Verify if compiler being used is Tiny C.
392
393AC_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
411dnl CURL_CHECK_COMPILER_WATCOM_C
412dnl -------------------------------------------------
413dnl Verify if compiler being used is Watcom C.
414
415AC_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
444dnl CURL_CONVERT_INCLUDE_TO_ISYSTEM
445dnl -------------------------------------------------
446dnl Changes standard include paths present in CFLAGS
447dnl and CPPFLAGS into isystem include paths. This is
448dnl done to prevent GNUC from generating warnings on
449dnl headers from these locations, although on ancient
450dnl GNUC versions these warnings are not silenced.
451
452AC_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
495dnl CURL_COMPILER_WORKS_IFELSE ([ACTION-IF-WORKS], [ACTION-IF-NOT-WORKS])
496dnl -------------------------------------------------
497dnl Verify if the C compiler seems to work with the
498dnl settings that are 'active' at the time the test
499dnl is performed.
500
501AC_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
565dnl CURL_SET_COMPILER_BASIC_OPTS
566dnl -------------------------------------------------
567dnl Sets compiler specific options/flags which do not
568dnl depend on configure's debug, optimize or warnings
569dnl options.
570
571AC_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
730dnl CURL_SET_COMPILER_DEBUG_OPTS
731dnl -------------------------------------------------
732dnl Sets compiler specific options/flags which depend
733dnl on configure's debug option.
734
735AC_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
784dnl CURL_SET_COMPILER_OPTIMIZE_OPTS
785dnl -------------------------------------------------
786dnl Sets compiler specific options/flags which depend
787dnl on configure's optimize option.
788
789AC_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
866dnl CURL_SET_COMPILER_WARNING_OPTS
867dnl -------------------------------------------------
868dnl Sets compiler options/flags which depend on
869dnl configure's warnings given option.
870
871AC_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
1266dnl CURL_SHFUNC_SQUEEZE
1267dnl -------------------------------------------------
1268dnl Declares a shell function squeeze() which removes
1269dnl redundant whitespace out of a shell variable.
1270
1271AC_DEFUN([CURL_SHFUNC_SQUEEZE], [
1272squeeze() {
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
1288dnl CURL_CHECK_CURLDEBUG
1289dnl -------------------------------------------------
1290dnl Settings which depend on configure's curldebug given
1291dnl option, and other additional configure pre-requisites.
1292dnl Actually the curl debug memory tracking feature can
1293dnl only be used/enabled when libcurl is built as a static
1294dnl library or as a shared one on those systems on which
1295dnl shared libraries support undefined symbols.
1296
1297AC_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
1334dnl CURL_CHECK_COMPILER_HALT_ON_ERROR
1335dnl -------------------------------------------------
1336dnl Verifies if the compiler actually halts after the
1337dnl compilation phase without generating any object
1338dnl code file, when the source compiles with errors.
1339
1340AC_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
1356dnl CURL_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE
1357dnl -------------------------------------------------
1358dnl Verifies if the compiler actually halts after the
1359dnl compilation phase without generating any object
1360dnl code file, when the source code tries to define a
1361dnl type for a constant array with negative dimension.
1362
1363AC_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
1381dnl CURL_CHECK_COMPILER_STRUCT_MEMBER_SIZE
1382dnl -------------------------------------------------
1383dnl Verifies if the compiler is capable of handling the
1384dnl size of a struct member, struct which is a function
1385dnl result, as a compilation-time condition inside the
1386dnl type definition of a constant array.
1387
1388AC_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
1443dnl CURL_CHECK_COMPILER_SYMBOL_HIDING
1444dnl -------------------------------------------------
1445dnl Verify if compiler supports hiding library internal symbols, setting
1446dnl shell variable supports_symbol_hiding value as appropriate, as well as
1447dnl variables symbol_hiding_CFLAGS and symbol_hiding_EXTERN when supported.
1448
1449AC_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
1551dnl CURL_CHECK_COMPILER_PROTOTYPE_MISMATCH
1552dnl -------------------------------------------------
1553dnl Verifies if the compiler actually halts after the
1554dnl compilation phase without generating any object
1555dnl code file, when the source code tries to redefine
1556dnl a prototype which does not match previous one.
1557
1558AC_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
1587dnl CURL_VAR_MATCH (VARNAME, VALUE)
1588dnl -------------------------------------------------
1589dnl Verifies if shell variable VARNAME contains VALUE.
1590dnl Contents of variable VARNAME and VALUE are handled
1591dnl as whitespace separated lists of words. If at least
1592dnl one word of VALUE is present in VARNAME the match
1593dnl is considered positive, otherwise false.
1594
1595AC_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
1607dnl CURL_VAR_MATCH_IFELSE (VARNAME, VALUE,
1608dnl                        [ACTION-IF-MATCH], [ACTION-IF-NOT-MATCH])
1609dnl -------------------------------------------------
1610dnl This performs a CURL_VAR_MATCH check and executes
1611dnl first branch if the match is positive, otherwise
1612dnl the second branch is executed.
1613
1614AC_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
1624dnl CURL_VAR_STRIP (VARNAME, VALUE)
1625dnl -------------------------------------------------
1626dnl Contents of variable VARNAME and VALUE are handled
1627dnl as whitespace separated lists of words. Each word
1628dnl from VALUE is removed from VARNAME when present.
1629
1630AC_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])
1648