luna - curl/m4/curl-compilers.m4

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