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