configure.ac

   1 dnl Process this file with autoconf to produce a configure script.
   2 dnl Configure input file for elfutils.                     -*-autoconf-*-
   3 dnl
   4 dnl Copyright (C) 1996-2019 Red Hat, Inc.
   5 dnl
   6 dnl This file is part of elfutils.
   7 dnl
   8 dnl  This file is free software; you can redistribute it and/or modify
   9 dnl  it under the terms of the GNU General Public License as published by
  10 dnl  the Free Software Foundation; either version 3 of the License, or
  11 dnl  (at your option) any later version.
  12 dnl
  13 dnl  elfutils is distributed in the hope that it will be useful, but
  14 dnl  WITHOUT ANY WARRANTY; without even the implied warranty of
  15 dnl  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 dnl  GNU General Public License for more details.
  17 dnl
  18 dnl  You should have received a copy of the GNU General Public License
  19 dnl  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 AC_INIT([elfutils],[0.185],[https://sourceware.org/bugzilla],[elfutils],[http://elfutils.org/])
  21
  22 dnl Workaround for older autoconf < 2.64
  23 m4_ifndef([AC_PACKAGE_URL],
  24          [AC_DEFINE([PACKAGE_URL], ["http://elfutils.org/"],
  25                     [Define to home page for this package])
  26           AC_SUBST([PACKAGE_URL], ["http://elfutils.org/"])])
  27
  28 LIBDEBUGINFOD_SONAME=libdebuginfod.so.1
  29 AC_SUBST([LIBDEBUGINFOD_SONAME])
  30
  31 # We want eu- as default program prefix if none was given by the user.
  32 # But if the user explicitly provided --program-prefix="" then pretend
  33 # it wasn't set at all (NONE). We want to test this really early before
  34 # configure has a chance to use the value.
  35
  36 if test "x$program_prefix" = "xNONE"; then
  37   AC_MSG_NOTICE([No --program-prefix given, using "eu-"])
  38   program_prefix="eu-"
  39 elif test "x$program_prefix" = "x"; then
  40   AC_MSG_NOTICE([Using no program-prefix])
  41   program_prefix=NONE
  42 fi
  43
  44 AC_CONFIG_AUX_DIR([config])
  45 AC_CONFIG_FILES([config/Makefile])
  46
  47 AC_COPYRIGHT([Copyright (C) 1996-2021 The elfutils developers.])
  48 AC_PREREQ(2.63)                 dnl Minimum Autoconf version required.
  49
  50 dnl We use GNU make extensions; automake 1.10 defaults to -Wportability.
  51 AM_INIT_AUTOMAKE([gnits 1.11 -Wno-portability dist-bzip2 no-dist-gzip parallel-tests])
  52 AM_MAINTAINER_MODE
  53
  54 AM_SILENT_RULES([yes])
  55
  56 AC_CONFIG_SRCDIR([libelf/libelf.h])
  57 AC_CONFIG_FILES([Makefile])
  58 AC_CONFIG_HEADERS([config.h])
  59
  60 dnl The RPM spec file.  We substitute a few values in the file.
  61 AC_CONFIG_FILES([elfutils.spec:config/elfutils.spec.in])
  62
  63 dnl debuginfo-server client & server parts.
  64 AC_CONFIG_FILES([debuginfod/Makefile debuginfod/debuginfod.h])
  65
  66 AC_CANONICAL_HOST
  67
  68 AC_ARG_ENABLE(deterministic-archives,
  69 [AS_HELP_STRING([--enable-deterministic-archives],
  70                 [ar and ranlib default to -D behavior])], [
  71 if test "${enableval}" = no; then
  72   default_ar_deterministic=false
  73 else
  74   default_ar_deterministic=true
  75 fi], [default_ar_deterministic=false])
  76 AC_DEFINE_UNQUOTED(DEFAULT_AR_DETERMINISTIC, $default_ar_deterministic,
  77                    [Should ar and ranlib use -D behavior by default?])
  78
  79 AC_ARG_ENABLE([thread-safety],
  80 AS_HELP_STRING([--enable-thread-safety],
  81                [enable thread safety of libraries EXPERIMENTAL]),
  82                use_locks=$enableval, use_locks=no)
  83 AM_CONDITIONAL(USE_LOCKS, test "$use_locks" = yes)
  84 AS_IF([test "$use_locks" = yes], [AC_DEFINE(USE_LOCKS)])
  85 AS_IF([test "$use_locks" = yes],
  86       [AC_MSG_WARN([thread-safety is EXPERIMENTAL tests might fail.])])
  87
  88 AH_TEMPLATE([USE_LOCKS], [Defined if libraries should be thread-safe.])
  89
  90 AC_PROG_CC_C99
  91 AC_PROG_RANLIB
  92 AC_PROG_YACC
  93 AM_PROG_LEX
  94 # Only available since automake 1.12
  95 m4_ifdef([AM_PROG_AR], [AM_PROG_AR])
  96 AC_CHECK_TOOL([READELF], [readelf])
  97 AC_CHECK_TOOL([NM], [nm])
  98
  99 AC_CACHE_CHECK([whether gcc supports __attribute__((visibility()))],
 100         ac_cv_visibility, [dnl
 101 save_CFLAGS="$CFLAGS"
 102 CFLAGS="$save_CFLAGS -Werror"
 103 AC_COMPILE_IFELSE([AC_LANG_SOURCE([dnl
 104 int __attribute__((visibility("hidden")))
 105 foo (int a)
 106 {
 107   return a;
 108 }])], ac_cv_visibility=yes, ac_cv_visibility=no)
 109 CFLAGS="$save_CFLAGS"])
 110 if test "$ac_cv_visibility" = "yes"; then
 111         AC_DEFINE([HAVE_VISIBILITY], [1],
 112                   [Defined if __attribute__((visibility())) is supported])
 113 fi
 114
 115 AC_CACHE_CHECK([whether gcc supports __attribute__((gcc_struct))],
 116         ac_cv_gcc_struct, [dnl
 117 save_CFLAGS="$CFLAGS"
 118 CFLAGS="$save_CFLAGS -Werror"
 119 AC_COMPILE_IFELSE([AC_LANG_SOURCE([dnl
 120 struct test { int x; } __attribute__((gcc_struct));
 121 ])], ac_cv_gcc_struct=yes, ac_cv_gcc_struct=no)
 122 CFLAGS="$save_CFLAGS"])
 123 if test "$ac_cv_gcc_struct" = "yes"; then
 124         AC_DEFINE([HAVE_GCC_STRUCT], [1],
 125                   [Defined if __attribute__((gcc_struct)) is supported])
 126 fi
 127
 128 AC_CACHE_CHECK([whether gcc supports -fPIC], ac_cv_fpic, [dnl
 129 save_CFLAGS="$CFLAGS"
 130 CFLAGS="$save_CFLAGS -fPIC -Werror"
 131 AC_COMPILE_IFELSE([AC_LANG_SOURCE()], ac_cv_fpic=yes, ac_cv_fpic=no)
 132 CFLAGS="$save_CFLAGS"
 133 ])
 134 if test "$ac_cv_fpic" = "yes"; then
 135         fpic_CFLAGS="-fPIC"
 136 else
 137         fpic_CFLAGS=""
 138 fi
 139 AC_SUBST([fpic_CFLAGS])
 140
 141 AC_CACHE_CHECK([whether gcc supports -fPIE], ac_cv_fpie, [dnl
 142 save_CFLAGS="$CFLAGS"
 143 CFLAGS="$save_CFLAGS -fPIE -Werror"
 144 AC_COMPILE_IFELSE([AC_LANG_SOURCE()], ac_cv_fpie=yes, ac_cv_fpie=no)
 145 CFLAGS="$save_CFLAGS"
 146 ])
 147 if test "$ac_cv_fpie" = "yes"; then
 148         fpie_CFLAGS="-fPIE"
 149 else
 150         fpie_CFLAGS=""
 151 fi
 152 AC_SUBST([fpie_CFLAGS])
 153
 154 dso_LDFLAGS="-shared"
 155
 156 ZDEFS_LDFLAGS="-Wl,-z,defs"
 157 AC_CACHE_CHECK([whether gcc supports $ZDEFS_LDFLAGS], ac_cv_zdefs, [dnl
 158 save_LDFLAGS="$LDFLAGS"
 159 LDFLAGS="$ZDEFS_LDFLAGS $save_LDFLAGS"
 160 AC_LINK_IFELSE([AC_LANG_PROGRAM()], ac_cv_zdefs=yes, ac_cv_zdefs=no)
 161 LDFLAGS="$save_LDFLAGS"
 162 ])
 163 if test "$ac_cv_zdefs" = "yes"; then
 164         dso_LDFLAGS="$dso_LDFLAGS $ZDEFS_LDFLAGS"
 165 fi
 166
 167 # We really want build-ids. Warn and force generating them if gcc was
 168 # configure without --enable-linker-build-id
 169 AC_CACHE_CHECK([whether the compiler generates build-ids], ac_cv_buildid, [dnl
 170 AC_LINK_IFELSE([AC_LANG_PROGRAM()],[ac_cv_buildid=yes; $READELF -n conftest$EXEEXT | grep -q NT_GNU_BUILD_ID || ac_cv_buildid=no],AC_MSG_FAILURE([unexpected compile failure]))])
 171 if test "$ac_cv_buildid" = "no"; then
 172         AC_MSG_WARN([compiler doesn't generate build-id by default])
 173         LDFLAGS="$LDFLAGS -Wl,--build-id"
 174 fi
 175
 176 ZRELRO_LDFLAGS="-Wl,-z,relro"
 177 AC_CACHE_CHECK([whether gcc supports $ZRELRO_LDFLAGS], ac_cv_zrelro, [dnl
 178 save_LDFLAGS="$LDFLAGS"
 179 LDFLAGS="$ZRELRO_LDFLAGS $save_LDFLAGS"
 180 AC_LINK_IFELSE([AC_LANG_PROGRAM()], ac_cv_zrelro=yes, ac_cv_zrelro=no)
 181 LDFLAGS="$save_LDFLAGS"
 182 ])
 183 if test "$ac_cv_zrelro" = "yes"; then
 184         dso_LDFLAGS="$dso_LDFLAGS $ZRELRO_LDFLAGS"
 185 fi
 186
 187 AC_SUBST([dso_LDFLAGS])
 188
 189 AC_CACHE_CHECK([for __thread support], ac_cv_tls, [dnl
 190 # Use the same flags that we use for our DSOs, so the test is representative.
 191 # Some old compiler/linker/libc combinations fail some ways and not others.
 192 save_CFLAGS="$CFLAGS"
 193 save_LDFLAGS="$LDFLAGS"
 194 CFLAGS="$fpic_CFLAGS $CFLAGS"
 195 LDFLAGS="$dso_LDFLAGS $LDFLAGS"
 196 AC_LINK_IFELSE([dnl
 197 AC_LANG_PROGRAM([[#include <stdlib.h>
 198 #undef __thread
 199 static __thread int a; int foo (int b) { return a + b; }]],
 200                 [[exit (foo (0));]])],
 201                ac_cv_tls=yes, ac_cv_tls=no)
 202 CFLAGS="$save_CFLAGS"
 203 LDFLAGS="$save_LDFLAGS"])
 204 AS_IF([test "x$ac_cv_tls" != xyes],
 205       AC_MSG_ERROR([__thread support required]))
 206
 207 dnl Before 4.9 gcc doesn't ship stdatomic.h, but the necessary atomics are
 208 dnl available by (at least) 4.7. So if the system doesn't have a stdatomic.h we
 209 dnl fall back on one copied from FreeBSD that handles the difference.
 210 AC_CACHE_CHECK([whether gcc provides stdatomic.h], ac_cv_has_stdatomic,
 211   [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[#include <stdatomic.h>]])],
 212                      ac_cv_has_stdatomic=yes, ac_cv_has_stdatomic=no)])
 213 AM_CONDITIONAL(HAVE_STDATOMIC_H, test "x$ac_cv_has_stdatomic" = xyes)
 214 AS_IF([test "x$ac_cv_has_stdatomic" = xyes], [AC_DEFINE(HAVE_STDATOMIC_H)])
 215
 216 AH_TEMPLATE([HAVE_STDATOMIC_H], [Define to 1 if `stdatomic.h` is provided by the
 217                                  system, 0 otherwise.])
 218
 219 dnl This test must come as early as possible after the compiler configuration
 220 dnl tests, because the choice of the file model can (in principle) affect
 221 dnl whether functions and headers are available, whether they work, etc.
 222 AC_SYS_LARGEFILE
 223
 224 dnl Older glibc had a broken fts that didn't work with Large File Systems.
 225 dnl We want the version that can handler LFS, but include workaround if we
 226 dnl get a bad one. Add define to CFLAGS (not AC_DEFINE it) since we need to
 227 dnl check it before including config.h (which might define _FILE_OFFSET_BITS).
 228 AC_CACHE_CHECK([whether fts.h is bad when included (with LFS)], ac_cv_bad_fts,
 229   [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[#include <fts.h>]])],
 230                      ac_cv_bad_fts=no, ac_cv_bad_fts=yes)])
 231 AS_IF([test "x$ac_cv_bad_fts" = "xyes"],
 232       [CFLAGS="$CFLAGS -DBAD_FTS=1" CXXFLAGS="$CXXFLAGS -DBAD_FTS=1"])
 233
 234 # See if we can add -D_FORTIFY_SOURCE=2. Don't do it if it is already
 235 # (differently) defined or if it generates warnings/errors because we
 236 # don't use the right optimisation level (string.h will warn about that).
 237 AC_MSG_CHECKING([whether to add -D_FORTIFY_SOURCE=2 to CFLAGS])
 238 case "$CFLAGS" in
 239   *-D_FORTIFY_SOURCE=2*)
 240     AC_MSG_RESULT([no, already there])
 241     ;;
 242   *)
 243     save_CFLAGS="$CFLAGS"
 244     CFLAGS="-D_FORTIFY_SOURCE=2 $CFLAGS -Werror"
 245     AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
 246       #include <string.h>
 247       int main() { return 0; }
 248     ]])], [ AC_MSG_RESULT([yes])
 249             CFLAGS="-D_FORTIFY_SOURCE=2 $save_CFLAGS" ],
 250           [ AC_MSG_RESULT([no])
 251             CFLAGS="$save_CFLAGS"])
 252   ;;
 253 esac
 254
 255 dnl enable debugging of branch prediction.
 256 AC_ARG_ENABLE([debugpred],
 257 AS_HELP_STRING([--enable-debugpred],[build binaries with support to debug branch prediction]),
 258 [use_debugpred=$enableval], [use_debugpred=no])
 259 case $use_debugpred in
 260  yes) use_debugpred_val=1 ;;
 261  *)   use_debugpred_val=0 ;;
 262 esac
 263 AC_SUBST([DEBUGPRED], $use_debugpred_val)
 264
 265 dnl Enable gprof support.
 266 AC_ARG_ENABLE([gprof],
 267 AS_HELP_STRING([--enable-gprof],[build binaries with gprof support]), [use_gprof=$enableval], [use_gprof=no])
 268 if test "$use_gprof" = yes; then
 269   CFLAGS="$CFLAGS -pg"
 270   LDFLAGS="$LDFLAGS -pg"
 271 fi
 272 AM_CONDITIONAL(GPROF, test "$use_gprof" = yes)
 273
 274 # Enable gcov support.
 275 AC_ARG_ENABLE([gcov],
 276 AS_HELP_STRING([--enable-gcov],[build binaries with gcov support]), [use_gcov=$enableval], [use_gcov=no])
 277 if test "$use_gcov" = yes; then
 278   CFLAGS="$CFLAGS -fprofile-arcs -ftest-coverage"
 279   CXXFLAGS="$CXXFLAGS -fprofile-arcs -ftest-coverage"
 280   LDFLAGS="$LDFLAGS -fprofile-arcs"
 281   AC_CHECK_PROG([GCOV], [gcov], [gcov])
 282   AC_CHECK_PROG([LCOV], [lcov], [lcov])
 283   AC_CHECK_PROG([GENHTML], [genhtml], [genhtml])
 284 fi
 285 AM_CONDITIONAL(GCOV, test "$use_gcov" = yes)
 286
 287 AC_ARG_ENABLE([sanitize-undefined],
 288               AS_HELP_STRING([--enable-sanitize-undefined],
 289                              [Use gcc undefined behaviour sanitizer]),
 290                              [use_undefined=$enableval], [use_undefined=no])
 291 if test "$use_undefined" = yes; then
 292   old_CFLAGS="$CFLAGS"
 293   old_CXXFLAGS="$CXXFLAGS"
 294   # We explicitly use unaligned access when possible (see ALLOW_UNALIGNED)
 295   # We want to fail immediately on first error, don't try to recover.
 296   CFLAGS="$CFLAGS -fsanitize=undefined -fno-sanitize-recover"
 297   CXXFLAGS="$CXXFLAGS -fsanitize=undefined -fno-sanitize-recover"
 298   AC_LINK_IFELSE([AC_LANG_SOURCE([int main (int argc, char **argv) { return 0; }])], use_undefined=yes, use_undefined=no)
 299   AS_IF([test "x$use_undefined" != xyes],
 300         AC_MSG_WARN([gcc undefined behaviour sanitizer not available])
 301         CFLAGS="$old_CFLAGS" CXXFLAGS="$old_CXXFLAGS")
 302 fi
 303 case $use_undefined in
 304  yes) check_undefined_val=1 ;;
 305  *)   check_undefined_val=0 ;;
 306 esac
 307 AC_DEFINE_UNQUOTED(CHECK_UNDEFINED, $check_undefined_val,
 308                    [Building with -fsanitize=undefined or not])
 309
 310 AC_ARG_ENABLE([valgrind],
 311 AS_HELP_STRING([--enable-valgrind],[run all tests under valgrind]),
 312 [use_valgrind=$enableval], [use_valgrind=no])
 313 if test "$use_valgrind" = yes; then
 314   AC_CHECK_PROG(HAVE_VALGRIND, valgrind, yes, no)
 315   if test "$HAVE_VALGRIND" = "no"; then
 316     AC_MSG_ERROR([valgrind not found])
 317   fi
 318 fi
 319 AM_CONDITIONAL(USE_VALGRIND, test "$use_valgrind" = yes)
 320
 321 AC_ARG_WITH([valgrind],
 322 AS_HELP_STRING([--with-valgrind],[include directory for Valgrind headers]),
 323 [with_valgrind_headers=$withval], [with_valgrind_headers=no])
 324 if test "x$with_valgrind_headers" != xno; then
 325     save_CFLAGS="$CFLAGS"
 326     CFLAGS="$CFLAGS -I$with_valgrind_headers"
 327     AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
 328       #include <valgrind/valgrind.h>
 329       int main() { return 0; }
 330     ]])], [ HAVE_VALGRIND_HEADERS="yes"
 331             CFLAGS="$save_CFLAGS -I$with_valgrind_headers" ],
 332           [ AC_MSG_ERROR([invalid valgrind include directory: $with_valgrind_headers]) ])
 333 fi
 334
 335 AC_ARG_ENABLE([valgrind-annotations],
 336 AS_HELP_STRING([--enable-valgrind-annotations],[insert extra annotations for better valgrind support]),
 337 [use_vg_annotations=$enableval], [use_vg_annotations=no])
 338 if test "$use_vg_annotations" = yes; then
 339     if test "x$HAVE_VALGRIND_HEADERS" != "xyes"; then
 340       AC_MSG_CHECKING([whether Valgrind headers are available])
 341       AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
 342         #include <valgrind/valgrind.h>
 343         int main() { return 0; }
 344       ]])], [ AC_MSG_RESULT([yes]) ],
 345             [ AC_MSG_ERROR([valgrind annotations requested but no headers are available]) ])
 346     fi
 347 fi
 348 AM_CONDITIONAL(USE_VG_ANNOTATIONS, test "$use_vg_annotations" = yes)
 349
 350 AC_ARG_ENABLE([install-elfh],
 351 AS_HELP_STRING([--enable-install-elfh],[install elf.h in include dir]),
 352                [install_elfh=$enableval], [install_elfh=no])
 353 AM_CONDITIONAL(INSTALL_ELFH, test "$install_elfh" = yes)
 354
 355 AM_CONDITIONAL(BUILD_STATIC, [dnl
 356 test "$use_gprof" = yes -o "$use_gcov" = yes])
 357
 358 AC_ARG_ENABLE([tests-rpath],
 359 AS_HELP_STRING([--enable-tests-rpath],[build $ORIGIN-using rpath into tests]),
 360                [tests_use_rpath=$enableval], [tests_use_rpath=no])
 361 AM_CONDITIONAL(TESTS_RPATH, test "$tests_use_rpath" = yes)
 362
 363 dnl zlib is mandatory.
 364 save_LIBS="$LIBS"
 365 LIBS=
 366 eu_ZIPLIB(zlib,ZLIB,z,gzdirect,gzip)
 367 AS_IF([test "x$with_zlib" = xno], [AC_MSG_ERROR([zlib not found but is required])])
 368 LIBS="$save_LIBS"
 369
 370 dnl Test for bzlib and xz/lzma/zstd, gives BZLIB/LZMALIB/ZSTD .am
 371 dnl conditional and config.h USE_BZLIB/USE_LZMALIB/USE_ZSTD #define.
 372 save_LIBS="$LIBS"
 373 LIBS=
 374 eu_ZIPLIB(bzlib,BZLIB,bz2,BZ2_bzdopen,bzip2)
 375 # We need this since bzip2 doesn't have a pkgconfig file.
 376 BZ2_LIB="$LIBS"
 377 AC_SUBST([BZ2_LIB])
 378 eu_ZIPLIB(lzma,LZMA,lzma,lzma_auto_decoder,[LZMA (xz)])
 379 AS_IF([test "x$with_lzma" = xyes], [LIBLZMA="liblzma"], [LIBLZMA=""])
 380 AC_SUBST([LIBLZMA])
 381 eu_ZIPLIB(zstd,ZSTD,zstd,ZSTD_decompress,[ZSTD (zst)])
 382 AS_IF([test "x$with_zstd" = xyes], [LIBZSTD="libzstd"], [LIBLZSTD=""])
 383 AC_SUBST([LIBZSTD])
 384 zip_LIBS="$LIBS"
 385 LIBS="$save_LIBS"
 386 AC_SUBST([zip_LIBS])
 387
 388 AC_CHECK_DECLS([memrchr, rawmemchr],[],[],
 389                [#define _GNU_SOURCE
 390                 #include <string.h>])
 391 AC_CHECK_DECLS([powerof2],[],[],[#include <sys/param.h>])
 392 AC_CHECK_DECLS([mempcpy],[],[],
 393                [#define _GNU_SOURCE
 394                 #include <string.h>])
 395 AC_CHECK_DECLS([reallocarray],[],[],
 396                [#define _GNU_SOURCE
 397                 #include <stdlib.h>])
 398
 399 AC_CHECK_FUNCS([process_vm_readv])
 400
 401 AC_CHECK_HEADERS([error.h])
 402 AC_CHECK_HEADERS([err.h])
 403
 404 old_CFLAGS="$CFLAGS"
 405 CFLAGS="$CFLAGS -D_GNU_SOURCE"
 406 AC_FUNC_STRERROR_R()
 407 CFLAGS="$old_CFLAGS"
 408
 409 AC_CHECK_LIB([stdc++], [__cxa_demangle], [dnl
 410 AC_DEFINE([USE_DEMANGLE], [1], [Defined if demangling is enabled])])
 411 AM_CONDITIONAL(DEMANGLE, test "x$ac_cv_lib_stdcpp___cxa_demangle" = "xyes")
 412 AS_IF([test "x$ac_cv_lib_stdcpp___cxa_demangle" = "xyes"],
 413       [enable_demangler=yes],[enable_demangler=no])
 414
 415 AC_ARG_ENABLE([textrelcheck],
 416 AS_HELP_STRING([--disable-textrelcheck],
 417                [Disable textrelcheck being a fatal error]))
 418 AM_CONDITIONAL(FATAL_TEXTREL, [test "x$enable_textrelcheck" != "xno"])
 419 AS_IF([test "x$enable_textrelcheck" != "xno"],
 420       [enable_textrelcheck=yes],[enable_textrelcheck=no])
 421
 422 AC_ARG_ENABLE([symbol-versioning],
 423 AS_HELP_STRING([--disable-symbol-versioning],
 424                [Disable symbol versioning in shared objects]))
 425
 426 AC_CACHE_CHECK([whether symbol versioning is supported], ac_cv_symbol_versioning, [dnl
 427 AC_COMPILE_IFELSE([AC_LANG_SOURCE([dnl
 428 #define NEW_VERSION(name, version) \
 429   asm (".symver " #name "," #name "@@@" #version);
 430 int foo(int x) { return x + 1; }
 431 NEW_VERSION (foo, ELFUTILS_12.12)
 432 ])], ac_cv_symbol_versioning=yes, ac_cv_symbol_versioning=no)])
 433 if test "$ac_cv_symbol_versioning" = "no"; then
 434     if test "x$enable_symbol_versioning" != "xno"; then
 435         AC_MSG_ERROR([Symbol versioning is not supported.
 436                       Use --disable-symbol-versioning to build without.])
 437     fi
 438 fi
 439
 440 AM_CONDITIONAL(SYMBOL_VERSIONING, [test "x$enable_symbol_versioning" != "xno"])
 441 AS_IF([test "x$enable_symbol_versioning" = "xno"],
 442       [AC_MSG_WARN([Disabling symbol versioning breaks ABI compatibility.])
 443        enable_symbol_versioning=no],[enable_symbol_versioning=yes])
 444
 445 AC_CACHE_CHECK([whether gcc accepts -Wstack-usage], ac_cv_stack_usage, [dnl
 446 old_CFLAGS="$CFLAGS"
 447 CFLAGS="$CFLAGS -Wstack-usage=262144 -Werror"
 448 AC_COMPILE_IFELSE([AC_LANG_SOURCE([])],
 449                   ac_cv_stack_usage=yes, ac_cv_stack_usage=no)
 450 CFLAGS="$old_CFLAGS"])
 451 AM_CONDITIONAL(ADD_STACK_USAGE_WARNING, [test "x$ac_cv_stack_usage" != "xno"])
 452
 453 # -Wlogical-op was too fragile in the past, make sure we get a sane one.
 454 AC_CACHE_CHECK([whether gcc has a sane -Wlogical-op], ac_cv_logical_op, [dnl
 455 old_CFLAGS="$CFLAGS"
 456 CFLAGS="$CFLAGS -Wlogical-op -Werror"
 457 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
 458         [#define FLAG 1
 459         int f (int r, int f) { return (r && (FLAG || (FLAG & f))); }])],
 460                   ac_cv_logical_op=yes, ac_cv_logical_op=no)
 461 CFLAGS="$old_CFLAGS"])
 462 AM_CONDITIONAL(SANE_LOGICAL_OP_WARNING,
 463                [test "x$ac_cv_logical_op" != "xno"])
 464
 465 # -Wduplicated-cond was added by GCC6
 466 AC_CACHE_CHECK([whether gcc accepts -Wduplicated-cond], ac_cv_duplicated_cond, [dnl
 467 old_CFLAGS="$CFLAGS"
 468 CFLAGS="$CFLAGS -Wduplicated-cond -Werror"
 469 AC_COMPILE_IFELSE([AC_LANG_SOURCE([])],
 470                   ac_cv_duplicated_cond=yes, ac_cv_duplicated_cond=no)
 471 CFLAGS="$old_CFLAGS"])
 472 AM_CONDITIONAL(HAVE_DUPLICATED_COND_WARNING,
 473                [test "x$ac_cv_duplicated_cond" != "xno"])
 474
 475 # -Wnull-dereference was added by GCC6
 476 AC_CACHE_CHECK([whether gcc accepts -Wnull-dereference], ac_cv_null_dereference, [dnl
 477 old_CFLAGS="$CFLAGS"
 478 CFLAGS="$CFLAGS -Wnull-dereference -Werror"
 479 AC_COMPILE_IFELSE([AC_LANG_SOURCE([])],
 480                   ac_cv_null_dereference=yes, ac_cv_null_dereference=no)
 481 CFLAGS="$old_CFLAGS"])
 482 AM_CONDITIONAL(HAVE_NULL_DEREFERENCE_WARNING,
 483                [test "x$ac_cv_null_dereference" != "xno"])
 484
 485 # -Wimplicit-fallthrough was added by GCC7
 486 AC_CACHE_CHECK([whether gcc accepts -Wimplicit-fallthrough], ac_cv_implicit_fallthrough, [dnl
 487 old_CFLAGS="$CFLAGS"
 488 CFLAGS="$CFLAGS -Wimplicit-fallthrough -Werror"
 489 AC_COMPILE_IFELSE([AC_LANG_SOURCE([])],
 490                   ac_cv_implicit_fallthrough=yes, ac_cv_implicit_fallthrough=no)
 491 CFLAGS="$old_CFLAGS"])
 492 AM_CONDITIONAL(HAVE_IMPLICIT_FALLTHROUGH_WARNING,
 493                [test "x$ac_cv_implicit_fallthrough" != "xno"])
 494
 495 # Check whether the compiler additionally accepts -Wimplicit-fallthrough=5
 496 # GCC accepts this and 5 means "don't parse any fallthrough comments and
 497 # only accept the fallthrough attribute"
 498 AC_CACHE_CHECK([whether the compiler accepts -Wimplicit-fallthrough=5], ac_cv_implicit_fallthrough_5, [dnl
 499 old_CFLAGS="$CFLAGS"
 500 CFLAGS="$CFLAGS -Wimplicit-fallthrough=5 -Werror"
 501 AC_COMPILE_IFELSE([AC_LANG_SOURCE([])],
 502                   ac_cv_implicit_fallthrough_5=yes, ac_cv_implicit_fallthrough_5=no)
 503 CFLAGS="$old_CFLAGS"])
 504 AM_CONDITIONAL(HAVE_IMPLICIT_FALLTHROUGH_5_WARNING,
 505                [test "x$ac_cv_implicit_fallthrough_5" != "xno"])
 506
 507 # Assume the fallthrough attribute is supported if -Wimplict-fallthrough is supported
 508 if test "$ac_cv_implicit_fallthrough" = "yes"; then
 509         AC_DEFINE([HAVE_FALLTHROUGH], [1],
 510                   [Defined if __attribute__((fallthrough)) is supported])
 511 fi
 512
 513 AC_CACHE_CHECK([whether the compiler accepts -Wtrampolines], ac_cv_trampolines, [dnl
 514 old_CFLAGS="$CFLAGS"
 515 CFLAGS="$CFLAGS -Wtrampolines -Werror"
 516 AC_COMPILE_IFELSE([AC_LANG_SOURCE([])],
 517                   ac_cv_trampolines=yes, ac_cv_trampolines=no)
 518 CFLAGS="$old_CFLAGS"])
 519 AM_CONDITIONAL(HAVE_TRAMPOLINES_WARNING,
 520                [test "x$ac_cv_trampolines" != "xno"])
 521
 522 AC_CACHE_CHECK([whether the compiler accepts -Wno-packed-not-aligned], ac_cv_no_packed_not_aligned, [dnl
 523 old_CFLAGS="$CFLAGS"
 524 CFLAGS="$CFLAGS -Wno-packed-not-aligned -Werror"
 525 AC_COMPILE_IFELSE([AC_LANG_SOURCE([])],
 526                   ac_cv_no_packed_not_aligned=yes, ac_cv_no_packed_not_aligned=no)
 527 CFLAGS="$old_CFLAGS"])
 528 AM_CONDITIONAL(HAVE_NO_PACKED_NOT_ALIGNED_WARNING,
 529                [test "x$ac_cv_no_packed_not_aligned" != "xno"])
 530
 531 saved_LIBS="$LIBS"
 532 AC_SEARCH_LIBS([argp_parse], [argp])
 533 LIBS="$saved_LIBS"
 534 case "$ac_cv_search_argp_parse" in
 535         no) AC_MSG_FAILURE([failed to find argp_parse]) ;;
 536         -l*) argp_LDADD="$ac_cv_search_argp_parse" ;;
 537         *) argp_LDADD= ;;
 538 esac
 539 AC_SUBST([argp_LDADD])
 540
 541 saved_LIBS="$LIBS"
 542 AC_SEARCH_LIBS([fts_close], [fts])
 543 LIBS="$saved_LIBS"
 544 case "$ac_cv_search_fts_close" in
 545         no) AC_MSG_FAILURE([failed to find fts_close]) ;;
 546         -l*) fts_LIBS="$ac_cv_search_fts_close" ;;
 547         *) fts_LIBS= ;;
 548 esac
 549 AC_SUBST([fts_LIBS])
 550
 551 saved_LIBS="$LIBS"
 552 AC_SEARCH_LIBS([_obstack_free], [obstack])
 553 LIBS="$saved_LIBS"
 554 case "$ac_cv_search__obstack_free" in
 555         no) AC_MSG_FAILURE([failed to find _obstack_free]) ;;
 556         -l*) obstack_LIBS="$ac_cv_search__obstack_free" ;;
 557         *) obstack_LIBS= ;;
 558 esac
 559 AC_SUBST([obstack_LIBS])
 560
 561 dnl The directories with content.
 562
 563 dnl Documentation.
 564 AC_CONFIG_FILES([doc/Makefile])
 565
 566 dnl Support library.
 567 AC_CONFIG_FILES([lib/Makefile])
 568
 569 dnl ELF library.
 570 AC_CONFIG_FILES([libelf/Makefile])
 571
 572 dnl Higher-level ELF support library.
 573 AC_CONFIG_FILES([libebl/Makefile])
 574
 575 dnl DWARF-ELF Lower-level Functions support library.
 576 AC_CONFIG_FILES([libdwelf/Makefile])
 577
 578 dnl DWARF library.
 579 AC_CONFIG_FILES([libdw/Makefile])
 580
 581 dnl Higher-level DWARF support library.
 582 AC_CONFIG_FILES([libdwfl/Makefile])
 583
 584 dnl CPU handling library.
 585 AC_CONFIG_FILES([libcpu/Makefile])
 586
 587 dnl Assembler library.
 588 AC_CONFIG_FILES([libasm/Makefile])
 589
 590 dnl CPU-specific backend libraries.
 591 AC_CONFIG_FILES([backends/Makefile])
 592
 593 dnl Tools.
 594 AC_CONFIG_FILES([src/Makefile po/Makefile.in])
 595
 596 dnl Test suite.
 597 AC_CONFIG_FILES([tests/Makefile])
 598
 599 dnl pkgconfig files
 600 AC_CONFIG_FILES([config/libelf.pc config/libdw.pc config/libdebuginfod.pc])
 601
 602 dnl As long as "git grep 'PRI[diouxX]' po" reports matches in
 603 dnl translatable strings, we must use need-formatstring-macros here.
 604 AM_GNU_GETTEXT([external], [need-formatstring-macros])
 605
 606 dnl AM_GNU_GETTEXT_VERSION is still needed for old versions
 607 dnl of autoreconf that do not recognize AM_GNU_GETTEXT_REQUIRE_VERSION.
 608 dnl 0.19.6 is the first version of gettext that provides
 609 dnl AM_GNU_GETTEXT_REQUIRE_VERSION support.
 610 AM_GNU_GETTEXT_VERSION([0.19.6])
 611 AM_GNU_GETTEXT_REQUIRE_VERSION([0.19.6])
 612
 613 dnl Appended to the config.h file.
 614 dnl We hide all kinds of configuration magic in lib/eu-config.h.
 615 AH_BOTTOM([#include <eu-config.h>])
 616
 617 dnl Version compatibility header.
 618 AC_CONFIG_FILES([version.h:config/version.h.in])
 619 AC_SUBST([eu_version])
 620
 621 # 1.234<whatever> -> 1234<whatever>
 622 case "$PACKAGE_VERSION" in
 623 [[0-9]].*) eu_version=`echo "$PACKAGE_VERSION" | sed 's@\.@@'` ;;
 624 *)         AC_MSG_ERROR([confused by version number '$PACKAGE_VERSION']) ;;
 625 esac
 626 case "$eu_version" in
 627 *.*)
 628   # 1234.567 -> "1234", "567"
 629   eu_extra_version="${eu_version#*.}"
 630   eu_version="${eu_version%%.*}"
 631   case "$eu_extra_version" in
 632   [[0-9]][[0-9]][[0-9]]) ;;
 633   [[0-9]][[0-9]])       eu_extra_version="${eu_extra_version}0" ;;
 634   [[0-9]])              eu_extra_version="${eu_extra_version}00" ;;
 635   *) AC_MSG_ERROR([confused by version number '$PACKAGE_VERSION']) ;;
 636   esac
 637   ;;
 638 *)
 639   eu_extra_version=000
 640   ;;
 641 esac
 642
 643 case "$eu_version" in
 644       0[[0-9]][[0-9]][[0-9]]) eu_version="${eu_version#0}$eu_extra_version" ;;
 645 [[0-9]][[0-9]][[0-9]][[0-9]]) eu_version="${eu_version}$eu_extra_version" ;;
 646 [[0-9]][[0-9]][[0-9]])        eu_version="${eu_version}0$eu_extra_version" ;;
 647 [[0-9]][[0-9]])               eu_version="${eu_version}00$eu_extra_version";;
 648 *) AC_MSG_ERROR([confused by version number '$PACKAGE_VERSION']) ;;
 649 esac
 650
 651 # Round up to the next release API (x.y) version.
 652 eu_version=$(( (eu_version + 999) / 1000 ))
 653
 654 AC_CHECK_SIZEOF(long)
 655
 656 # On aarch64 before glibc 2.20 we would get the kernel user_pt_regs instead
 657 # of the user_regs_struct from sys/user.h. They are structurally the same
 658 # but we get either one or the other.
 659 AC_CHECK_TYPE([struct user_regs_struct],
 660               [sys_user_has_user_regs=yes], [sys_user_has_user_regs=no],
 661               [[#include <sys/ptrace.h>]
 662                [#include <sys/time.h>]
 663                [#include <sys/user.h>]])
 664 if test "$sys_user_has_user_regs" = "yes"; then
 665   AC_DEFINE(HAVE_SYS_USER_REGS, 1,
 666             [Define to 1 if <sys/user.h> defines struct user_regs_struct])
 667 fi
 668
 669 # On a 64-bit host where can can use $CC -m32, we'll run two sets of tests.
 670 # Likewise in a 32-bit build on a host where $CC -m64 works.
 671 utrace_BIARCH
 672 # `$utrace_biarch' will be `-m64' even on an uniarch i386 machine.
 673 CC_BIARCH="$CC $utrace_biarch"
 674 AC_SUBST([CC_BIARCH])
 675
 676 # In maintainer mode we really need flex and bison.
 677 # Otherwise we really need a release dir with maintainer files generated.
 678 if test "x$enable_maintainer_mode" = xyes; then
 679   AC_CHECK_PROG(HAVE_FLEX, flex, yes, no)
 680   if test "$HAVE_FLEX" = "no"; then
 681     AC_MSG_ERROR([flex needed in maintainer mode])
 682   fi
 683   AC_CHECK_PROG(HAVE_BISON, bison, yes, no)
 684   if test "$HAVE_BISON" = "no"; then
 685     AC_MSG_ERROR([bison needed in maintainer mode])
 686   fi
 687   AC_CHECK_PROG(HAVE_GAWK, gawk, yes, no)
 688   if test "$HAVE_GAWK" = "no"; then
 689     AC_MSG_ERROR([gawk needed in maintainer mode])
 690   fi
 691 else
 692   if test ! -f ${srcdir}/libdw/known-dwarf.h; then
 693     AC_MSG_ERROR([No libdw/known-dwarf.h. configure --enable-maintainer-mode])
 694   fi
 695 fi
 696
 697 # The testfiles are all compressed, we need bunzip2 when running make check
 698 AC_CHECK_PROG(HAVE_BUNZIP2, bunzip2, yes, no)
 699 if test "$HAVE_BUNZIP2" = "no"; then
 700   AC_MSG_WARN([No bunzip2, needed to run make check])
 701 fi
 702
 703 # For tests that need to use zstd compression
 704 AC_CHECK_PROG(HAVE_ZSTD, zstd, yes, no)
 705 AM_CONDITIONAL([HAVE_ZSTD],[test "x$HAVE_ZSTD" = "xyes"])
 706
 707 # Look for libcurl for libdebuginfod minimum version as per rhel7.
 708 AC_ARG_ENABLE([libdebuginfod],AC_HELP_STRING([--enable-libdebuginfod], [Build debuginfod client library (can be =dummy)]))
 709 AS_IF([test "x$enable_libdebuginfod" != "xno"], [
 710     if test "x$enable_libdebuginfod" != "xdummy"; then
 711       AC_MSG_NOTICE([checking libdebuginfod dependencies, --disable-libdebuginfod or --enable-libdebuginfo=dummy to skip])
 712       enable_libdebuginfod=yes # presume success
 713       PKG_PROG_PKG_CONFIG
 714       PKG_CHECK_MODULES([libcurl],[libcurl >= 7.29.0],[],[enable_libdebuginfod=no])
 715       if test "x$enable_libdebuginfod" = "xno"; then
 716         AC_MSG_ERROR([dependencies not found, use --disable-libdebuginfod to disable or --enable-libdebuginfod=dummy to build a (bootstrap) dummy library.])
 717       fi
 718     else
 719       AC_MSG_NOTICE([building (bootstrap) dummy libdebuginfo library])
 720     fi
 721 ])
 722
 723 AC_CHECK_LIB(pthread, pthread_setname_np, [
 724                       AC_DEFINE([HAVE_PTHREAD_SETNAME_NP],[1],[Enable pthread_setname_np])])
 725
 726 AS_IF([test "x$enable_libdebuginfod" = "xyes" || test "x$enable_libdebuginfod" = "xdummy"],
 727       [AC_DEFINE([ENABLE_LIBDEBUGINFOD], [1], [Enable libdebuginfod])])
 728 AS_IF([test "x$enable_libdebuginfod" = "xdummy"],
 729       [AC_DEFINE([DUMMY_LIBDEBUGINFOD], [1], [Build dummy libdebuginfod])])
 730 AM_CONDITIONAL([LIBDEBUGINFOD],[test "x$enable_libdebuginfod" = "xyes" || test "x$enable_libdebuginfod" = "xdummy"])
 731 AM_CONDITIONAL([DUMMY_LIBDEBUGINFOD],[test "x$enable_libdebuginfod" = "xdummy"])
 732
 733 # Look for libmicrohttpd, libarchive, sqlite for debuginfo server
 734 # minimum versions as per rhel7.
 735 AC_ARG_ENABLE([debuginfod],AC_HELP_STRING([--enable-debuginfod], [Build debuginfod server]))
 736 AC_PROG_CXX
 737 AS_IF([test "x$enable_debuginfod" != "xno"], [
 738     AC_MSG_NOTICE([checking debuginfod C++11 support, --disable-debuginfod to skip])
 739     AX_CXX_COMPILE_STDCXX(11, noext, mandatory)
 740     AC_MSG_NOTICE([checking debuginfod dependencies, --disable-debuginfod to skip])
 741     if test "x$enable_libdebuginfod" = "xno"; then
 742       AC_MSG_ERROR([need libdebuginfod (or dummy), use --disable-debuginfod to disable.])
 743     fi
 744     enable_debuginfod=yes # presume success
 745     PKG_PROG_PKG_CONFIG
 746     PKG_CHECK_MODULES([libmicrohttpd],[libmicrohttpd >= 0.9.33],[],[enable_debuginfod=no])
 747     PKG_CHECK_MODULES([sqlite3],[sqlite3 >= 3.7.17],[],[enable_debuginfod=no])
 748     PKG_CHECK_MODULES([libarchive],[libarchive >= 3.1.2],[],[enable_debuginfod=no])
 749     if test "x$enable_debuginfod" = "xno"; then
 750       AC_MSG_ERROR([dependencies not found, use --disable-debuginfod to disable.])
 751     fi
 752 ])
 753
 754 AS_IF([test "x$enable_debuginfod" != "xno"],AC_DEFINE([ENABLE_DEBUGINFOD],[1],[Build debuginfod]))
 755 AM_CONDITIONAL([DEBUGINFOD],[test "x$enable_debuginfod" = "xyes"])
 756
 757 dnl for /etc/profile.d/elfutils.{csh,sh}
 758 default_debuginfod_urls=""
 759 AC_ARG_ENABLE(debuginfod-urls,
 760             [AS_HELP_STRING([--enable-debuginfod-urls@<:@=URLS@:>@],[add URLS to profile.d DEBUGINFOD_URLS])],
 761             [if test "x${enableval}" = "xyes";
 762              then default_debuginfod_urls="https://debuginfod.elfutils.org/";
 763              elif test "x${enableval}" != "xno"; then
 764              default_debuginfod_urls="${enableval}";
 765              fi],
 766             [default_debuginfod_urls=""])
 767 AC_SUBST(DEBUGINFOD_URLS, $default_debuginfod_urls)
 768 AC_CONFIG_FILES([config/profile.sh config/profile.csh])
 769
 770 AC_OUTPUT
 771
 772 AC_MSG_NOTICE([
 773 =====================================================================
 774         elfutils: ${PACKAGE_VERSION} (eu_version: ${eu_version})
 775 =====================================================================
 776
 777     Prefix                             : ${prefix}
 778     Program prefix ("eu-" recommended) : ${program_prefix}
 779     Source code location               : ${srcdir}
 780     Maintainer mode                    : ${enable_maintainer_mode}
 781     build arch                         : ${ac_cv_build}
 782
 783   RECOMMENDED FEATURES (should all be yes)
 784     gzip support                       : ${with_zlib}
 785     bzip2 support                      : ${with_bzlib}
 786     lzma/xz support                    : ${with_lzma}
 787     zstd support                       : ${with_zstd}
 788     libstdc++ demangle support         : ${enable_demangler}
 789     File textrel check                 : ${enable_textrelcheck}
 790     Symbol versioning                  : ${enable_symbol_versioning}
 791
 792   NOT RECOMMENDED FEATURES (should all be no)
 793     Experimental thread safety         : ${use_locks}
 794     install elf.h                      : ${install_elfh}
 795
 796   OTHER FEATURES
 797     Deterministic archives by default  : ${default_ar_deterministic}
 798     Native language support            : ${USE_NLS}
 799     Extra Valgrind annotations         : ${use_vg_annotations}
 800     libdebuginfod client support       : ${enable_libdebuginfod}
 801     Debuginfod server support          : ${enable_debuginfod}
 802     Default DEBUGINFOD_URLS            : ${default_debuginfod_urls}
 803
 804   EXTRA TEST FEATURES (used with make check)
 805     have bunzip2 installed (required)  : ${HAVE_BUNZIP2}
 806     have zstd installed                : ${HAVE_ZSTD}
 807     debug branch prediction            : ${use_debugpred}
 808     gprof support                      : ${use_gprof}
 809     gcov support                       : ${use_gcov}
 810     run all tests under valgrind       : ${use_valgrind}
 811     gcc undefined behaviour sanitizer  : ${use_undefined}
 812     use rpath in tests                 : ${tests_use_rpath}
 813     test biarch                        : ${utrace_cv_cc_biarch}
 814 ])
 815
 816 if test "$install_elfh" = yes; then
 817   if test "${prefix}" = "/usr/local" -o "${prefix}" = "/usr"; then
 818     AC_MSG_WARN([installing elf.h in ${includedir} might conflict with glibc/system elf.h])
 819   fi
 820 fi