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