1dnl Process this file with autoconf to produce a configure script. 2dnl Configure input file for elfutils. -*-autoconf-*- 3dnl 4dnl Copyright (C) 1996-2019 Red Hat, Inc. 5dnl 6dnl This file is part of elfutils. 7dnl 8dnl This file is free software; you can redistribute it and/or modify 9dnl it under the terms of the GNU General Public License as published by 10dnl the Free Software Foundation; either version 3 of the License, or 11dnl (at your option) any later version. 12dnl 13dnl elfutils is distributed in the hope that it will be useful, but 14dnl WITHOUT ANY WARRANTY; without even the implied warranty of 15dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16dnl GNU General Public License for more details. 17dnl 18dnl You should have received a copy of the GNU General Public License 19dnl along with this program. If not, see <http://www.gnu.org/licenses/>. 20AC_INIT([elfutils],[0.186],[https://sourceware.org/bugzilla],[elfutils],[http://elfutils.org/]) 21 22dnl Workaround for older autoconf < 2.64 23m4_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 28LIBDEBUGINFOD_SONAME=libdebuginfod.so.1 29AC_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 36if test "x$program_prefix" = "xNONE"; then 37 AC_MSG_NOTICE([No --program-prefix given, using "eu-"]) 38 program_prefix="eu-" 39elif test "x$program_prefix" = "x"; then 40 AC_MSG_NOTICE([Using no program-prefix]) 41 program_prefix=NONE 42fi 43 44AC_CONFIG_AUX_DIR([config]) 45AC_CONFIG_FILES([config/Makefile]) 46 47AC_COPYRIGHT([Copyright (C) 1996-2021 The elfutils developers.]) 48AC_PREREQ(2.63) dnl Minimum Autoconf version required. 49 50dnl We use GNU make extensions; automake 1.10 defaults to -Wportability. 51AM_INIT_AUTOMAKE([gnits 1.11 -Wno-portability dist-bzip2 no-dist-gzip parallel-tests]) 52AM_MAINTAINER_MODE 53 54AM_SILENT_RULES([yes]) 55 56AC_CONFIG_SRCDIR([libelf/libelf.h]) 57AC_CONFIG_FILES([Makefile]) 58AC_CONFIG_HEADERS([config.h]) 59 60dnl The RPM spec file. We substitute a few values in the file. 61AC_CONFIG_FILES([elfutils.spec:config/elfutils.spec.in]) 62 63dnl debuginfo-server client & server parts. 64AC_CONFIG_FILES([debuginfod/Makefile debuginfod/debuginfod.h]) 65 66AC_CANONICAL_HOST 67 68AC_ARG_ENABLE(deterministic-archives, 69[AS_HELP_STRING([--enable-deterministic-archives], 70 [ar and ranlib default to -D behavior])], [ 71if test "${enableval}" = no; then 72 default_ar_deterministic=false 73else 74 default_ar_deterministic=true 75fi], [default_ar_deterministic=false]) 76AC_DEFINE_UNQUOTED(DEFAULT_AR_DETERMINISTIC, $default_ar_deterministic, 77 [Should ar and ranlib use -D behavior by default?]) 78 79AC_ARG_ENABLE([thread-safety], 80AS_HELP_STRING([--enable-thread-safety], 81 [enable thread safety of libraries EXPERIMENTAL]), 82 use_locks=$enableval, use_locks=no) 83AM_CONDITIONAL(USE_LOCKS, test "$use_locks" = yes) 84AS_IF([test "$use_locks" = yes], [AC_DEFINE(USE_LOCKS)]) 85AS_IF([test "$use_locks" = yes], 86 [AC_MSG_WARN([thread-safety is EXPERIMENTAL tests might fail.])]) 87 88AH_TEMPLATE([USE_LOCKS], [Defined if libraries should be thread-safe.]) 89 90AC_PROG_CC_C99 91AC_PROG_RANLIB 92AC_PROG_YACC 93AM_PROG_LEX 94# Only available since automake 1.12 95m4_ifdef([AM_PROG_AR], [AM_PROG_AR]) 96AC_CHECK_TOOL([READELF], [readelf]) 97AC_CHECK_TOOL([NM], [nm]) 98 99AC_CACHE_CHECK([whether gcc supports __attribute__((visibility()))], 100 ac_cv_visibility, [dnl 101save_CFLAGS="$CFLAGS" 102CFLAGS="$save_CFLAGS -Werror" 103AC_COMPILE_IFELSE([AC_LANG_SOURCE([dnl 104int __attribute__((visibility("hidden"))) 105foo (int a) 106{ 107 return a; 108}])], ac_cv_visibility=yes, ac_cv_visibility=no) 109CFLAGS="$save_CFLAGS"]) 110if test "$ac_cv_visibility" = "yes"; then 111 AC_DEFINE([HAVE_VISIBILITY], [1], 112 [Defined if __attribute__((visibility())) is supported]) 113fi 114 115AC_CACHE_CHECK([whether gcc supports __attribute__((gcc_struct))], 116 ac_cv_gcc_struct, [dnl 117save_CFLAGS="$CFLAGS" 118CFLAGS="$save_CFLAGS -Werror" 119AC_COMPILE_IFELSE([AC_LANG_SOURCE([dnl 120struct test { int x; } __attribute__((gcc_struct)); 121])], ac_cv_gcc_struct=yes, ac_cv_gcc_struct=no) 122CFLAGS="$save_CFLAGS"]) 123if test "$ac_cv_gcc_struct" = "yes"; then 124 AC_DEFINE([HAVE_GCC_STRUCT], [1], 125 [Defined if __attribute__((gcc_struct)) is supported]) 126fi 127 128AC_CACHE_CHECK([whether gcc supports -fPIC], ac_cv_fpic, [dnl 129save_CFLAGS="$CFLAGS" 130CFLAGS="$save_CFLAGS -fPIC -Werror" 131AC_COMPILE_IFELSE([AC_LANG_SOURCE()], ac_cv_fpic=yes, ac_cv_fpic=no) 132CFLAGS="$save_CFLAGS" 133]) 134if test "$ac_cv_fpic" = "yes"; then 135 fpic_CFLAGS="-fPIC" 136else 137 fpic_CFLAGS="" 138fi 139AC_SUBST([fpic_CFLAGS]) 140 141AC_CACHE_CHECK([whether gcc supports -fPIE], ac_cv_fpie, [dnl 142save_CFLAGS="$CFLAGS" 143CFLAGS="$save_CFLAGS -fPIE -Werror" 144AC_COMPILE_IFELSE([AC_LANG_SOURCE()], ac_cv_fpie=yes, ac_cv_fpie=no) 145CFLAGS="$save_CFLAGS" 146]) 147if test "$ac_cv_fpie" = "yes"; then 148 fpie_CFLAGS="-fPIE" 149else 150 fpie_CFLAGS="" 151fi 152AC_SUBST([fpie_CFLAGS]) 153 154dso_LDFLAGS="-shared" 155 156ZDEFS_LDFLAGS="-Wl,-z,defs" 157AC_CACHE_CHECK([whether gcc supports $ZDEFS_LDFLAGS], ac_cv_zdefs, [dnl 158save_LDFLAGS="$LDFLAGS" 159LDFLAGS="$ZDEFS_LDFLAGS $save_LDFLAGS" 160AC_LINK_IFELSE([AC_LANG_PROGRAM()], ac_cv_zdefs=yes, ac_cv_zdefs=no) 161LDFLAGS="$save_LDFLAGS" 162]) 163if test "$ac_cv_zdefs" = "yes"; then 164 dso_LDFLAGS="$dso_LDFLAGS $ZDEFS_LDFLAGS" 165fi 166 167# We really want build-ids. Warn and force generating them if gcc was 168# configure without --enable-linker-build-id 169AC_CACHE_CHECK([whether the compiler generates build-ids], ac_cv_buildid, [dnl 170AC_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]))]) 171if test "$ac_cv_buildid" = "no"; then 172 AC_MSG_WARN([compiler doesn't generate build-id by default]) 173 LDFLAGS="$LDFLAGS -Wl,--build-id" 174fi 175 176ZRELRO_LDFLAGS="-Wl,-z,relro" 177AC_CACHE_CHECK([whether gcc supports $ZRELRO_LDFLAGS], ac_cv_zrelro, [dnl 178save_LDFLAGS="$LDFLAGS" 179LDFLAGS="$ZRELRO_LDFLAGS $save_LDFLAGS" 180AC_LINK_IFELSE([AC_LANG_PROGRAM()], ac_cv_zrelro=yes, ac_cv_zrelro=no) 181LDFLAGS="$save_LDFLAGS" 182]) 183if test "$ac_cv_zrelro" = "yes"; then 184 dso_LDFLAGS="$dso_LDFLAGS $ZRELRO_LDFLAGS" 185fi 186 187AC_SUBST([dso_LDFLAGS]) 188 189AC_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. 192save_CFLAGS="$CFLAGS" 193save_LDFLAGS="$LDFLAGS" 194CFLAGS="$fpic_CFLAGS $CFLAGS" 195LDFLAGS="$dso_LDFLAGS $LDFLAGS" 196AC_LINK_IFELSE([dnl 197AC_LANG_PROGRAM([[#include <stdlib.h> 198#undef __thread 199static __thread int a; int foo (int b) { return a + b; }]], 200 [[exit (foo (0));]])], 201 ac_cv_tls=yes, ac_cv_tls=no) 202CFLAGS="$save_CFLAGS" 203LDFLAGS="$save_LDFLAGS"]) 204AS_IF([test "x$ac_cv_tls" != xyes], 205 AC_MSG_ERROR([__thread support required])) 206 207dnl Before 4.9 gcc doesn't ship stdatomic.h, but the necessary atomics are 208dnl available by (at least) 4.7. So if the system doesn't have a stdatomic.h we 209dnl fall back on one copied from FreeBSD that handles the difference. 210AC_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)]) 213AM_CONDITIONAL(HAVE_STDATOMIC_H, test "x$ac_cv_has_stdatomic" = xyes) 214AS_IF([test "x$ac_cv_has_stdatomic" = xyes], [AC_DEFINE(HAVE_STDATOMIC_H)]) 215 216AH_TEMPLATE([HAVE_STDATOMIC_H], [Define to 1 if `stdatomic.h` is provided by the 217 system, 0 otherwise.]) 218 219dnl This test must come as early as possible after the compiler configuration 220dnl tests, because the choice of the file model can (in principle) affect 221dnl whether functions and headers are available, whether they work, etc. 222AC_SYS_LARGEFILE 223 224dnl Older glibc had a broken fts that didn't work with Large File Systems. 225dnl We want the version that can handler LFS, but include workaround if we 226dnl get a bad one. Add define to CFLAGS (not AC_DEFINE it) since we need to 227dnl check it before including config.h (which might define _FILE_OFFSET_BITS). 228AC_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)]) 231AS_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). 237AC_MSG_CHECKING([whether to add -D_FORTIFY_SOURCE=2 to CFLAGS]) 238case "$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 ;; 253esac 254 255dnl enable debugging of branch prediction. 256AC_ARG_ENABLE([debugpred], 257AS_HELP_STRING([--enable-debugpred],[build binaries with support to debug branch prediction]), 258[use_debugpred=$enableval], [use_debugpred=no]) 259case $use_debugpred in 260 yes) use_debugpred_val=1 ;; 261 *) use_debugpred_val=0 ;; 262esac 263AC_SUBST([DEBUGPRED], $use_debugpred_val) 264 265dnl Enable gprof support. 266AC_ARG_ENABLE([gprof], 267AS_HELP_STRING([--enable-gprof],[build binaries with gprof support]), [use_gprof=$enableval], [use_gprof=no]) 268if test "$use_gprof" = yes; then 269 CFLAGS="$CFLAGS -pg" 270 LDFLAGS="$LDFLAGS -pg" 271fi 272AM_CONDITIONAL(GPROF, test "$use_gprof" = yes) 273 274# Enable gcov support. 275AC_ARG_ENABLE([gcov], 276AS_HELP_STRING([--enable-gcov],[build binaries with gcov support]), [use_gcov=$enableval], [use_gcov=no]) 277if 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]) 284fi 285AM_CONDITIONAL(GCOV, test "$use_gcov" = yes) 286 287AC_ARG_ENABLE([sanitize-undefined], 288 AS_HELP_STRING([--enable-sanitize-undefined], 289 [Use gcc undefined behaviour sanitizer]), 290 [use_undefined=$enableval], [use_undefined=no]) 291if 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") 302fi 303case $use_undefined in 304 yes) check_undefined_val=1 ;; 305 *) check_undefined_val=0 ;; 306esac 307AC_DEFINE_UNQUOTED(CHECK_UNDEFINED, $check_undefined_val, 308 [Building with -fsanitize=undefined or not]) 309 310AC_ARG_ENABLE([valgrind], 311AS_HELP_STRING([--enable-valgrind],[run all tests under valgrind]), 312[use_valgrind=$enableval], [use_valgrind=no]) 313if 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 318fi 319AM_CONDITIONAL(USE_VALGRIND, test "$use_valgrind" = yes) 320 321AC_ARG_WITH([valgrind], 322AS_HELP_STRING([--with-valgrind],[include directory for Valgrind headers]), 323[with_valgrind_headers=$withval], [with_valgrind_headers=no]) 324if 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]) ]) 333fi 334 335AC_ARG_ENABLE([valgrind-annotations], 336AS_HELP_STRING([--enable-valgrind-annotations],[insert extra annotations for better valgrind support]), 337[use_vg_annotations=$enableval], [use_vg_annotations=no]) 338if 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 347fi 348AM_CONDITIONAL(USE_VG_ANNOTATIONS, test "$use_vg_annotations" = yes) 349 350AC_ARG_ENABLE([install-elfh], 351AS_HELP_STRING([--enable-install-elfh],[install elf.h in include dir]), 352 [install_elfh=$enableval], [install_elfh=no]) 353AM_CONDITIONAL(INSTALL_ELFH, test "$install_elfh" = yes) 354 355AM_CONDITIONAL(BUILD_STATIC, [dnl 356test "$use_gprof" = yes -o "$use_gcov" = yes]) 357 358AC_ARG_ENABLE([tests-rpath], 359AS_HELP_STRING([--enable-tests-rpath],[build $ORIGIN-using rpath into tests]), 360 [tests_use_rpath=$enableval], [tests_use_rpath=no]) 361AM_CONDITIONAL(TESTS_RPATH, test "$tests_use_rpath" = yes) 362 363dnl zlib is mandatory. 364save_LIBS="$LIBS" 365LIBS= 366eu_ZIPLIB(zlib,ZLIB,z,gzdirect,gzip) 367AS_IF([test "x$with_zlib" = xno], [AC_MSG_ERROR([zlib not found but is required])]) 368LIBS="$save_LIBS" 369 370dnl Test for bzlib and xz/lzma/zstd, gives BZLIB/LZMALIB/ZSTD .am 371dnl conditional and config.h USE_BZLIB/USE_LZMALIB/USE_ZSTD #define. 372save_LIBS="$LIBS" 373LIBS= 374eu_ZIPLIB(bzlib,BZLIB,bz2,BZ2_bzdopen,bzip2) 375# We need this since bzip2 doesn't have a pkgconfig file. 376BZ2_LIB="$LIBS" 377AC_SUBST([BZ2_LIB]) 378eu_ZIPLIB(lzma,LZMA,lzma,lzma_auto_decoder,[LZMA (xz)]) 379AS_IF([test "x$with_lzma" = xyes], [LIBLZMA="liblzma"], [LIBLZMA=""]) 380AC_SUBST([LIBLZMA]) 381eu_ZIPLIB(zstd,ZSTD,zstd,ZSTD_decompress,[ZSTD (zst)]) 382AS_IF([test "x$with_zstd" = xyes], [LIBZSTD="libzstd"], [LIBLZSTD=""]) 383AC_SUBST([LIBZSTD]) 384zip_LIBS="$LIBS" 385LIBS="$save_LIBS" 386AC_SUBST([zip_LIBS]) 387 388AC_CHECK_DECLS([memrchr, rawmemchr],[],[], 389 [#define _GNU_SOURCE 390 #include <string.h>]) 391AC_CHECK_DECLS([powerof2],[],[],[#include <sys/param.h>]) 392AC_CHECK_DECLS([mempcpy],[],[], 393 [#define _GNU_SOURCE 394 #include <string.h>]) 395AC_CHECK_DECLS([reallocarray],[],[], 396 [#define _GNU_SOURCE 397 #include <stdlib.h>]) 398 399AC_CHECK_FUNCS([process_vm_readv]) 400 401AC_CHECK_HEADERS([error.h]) 402AC_CHECK_HEADERS([err.h]) 403 404old_CFLAGS="$CFLAGS" 405CFLAGS="$CFLAGS -D_GNU_SOURCE" 406AC_FUNC_STRERROR_R() 407CFLAGS="$old_CFLAGS" 408 409AC_CHECK_LIB([stdc++], [__cxa_demangle], [dnl 410AC_DEFINE([USE_DEMANGLE], [1], [Defined if demangling is enabled])]) 411AM_CONDITIONAL(DEMANGLE, test "x$ac_cv_lib_stdcpp___cxa_demangle" = "xyes") 412AS_IF([test "x$ac_cv_lib_stdcpp___cxa_demangle" = "xyes"], 413 [enable_demangler=yes],[enable_demangler=no]) 414 415AC_ARG_ENABLE([textrelcheck], 416AS_HELP_STRING([--disable-textrelcheck], 417 [Disable textrelcheck being a fatal error])) 418AM_CONDITIONAL(FATAL_TEXTREL, [test "x$enable_textrelcheck" != "xno"]) 419AS_IF([test "x$enable_textrelcheck" != "xno"], 420 [enable_textrelcheck=yes],[enable_textrelcheck=no]) 421 422AC_ARG_ENABLE([symbol-versioning], 423AS_HELP_STRING([--disable-symbol-versioning], 424 [Disable symbol versioning in shared objects])) 425 426AC_CACHE_CHECK([whether symbol versioning is supported], ac_cv_symbol_versioning, [dnl 427AC_COMPILE_IFELSE([AC_LANG_SOURCE([dnl 428#define NEW_VERSION(name, version) \ 429 asm (".symver " #name "," #name "@@@" #version); 430int foo(int x) { return x + 1; } 431NEW_VERSION (foo, ELFUTILS_12.12) 432])], ac_cv_symbol_versioning=yes, ac_cv_symbol_versioning=no)]) 433if 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 438fi 439 440AM_CONDITIONAL(SYMBOL_VERSIONING, [test "x$enable_symbol_versioning" != "xno"]) 441AS_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 445AC_CACHE_CHECK([whether gcc accepts -Wstack-usage], ac_cv_stack_usage, [dnl 446old_CFLAGS="$CFLAGS" 447CFLAGS="$CFLAGS -Wstack-usage=262144 -Werror" 448AC_COMPILE_IFELSE([AC_LANG_SOURCE([])], 449 ac_cv_stack_usage=yes, ac_cv_stack_usage=no) 450CFLAGS="$old_CFLAGS"]) 451AM_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. 454AC_CACHE_CHECK([whether gcc has a sane -Wlogical-op], ac_cv_logical_op, [dnl 455old_CFLAGS="$CFLAGS" 456CFLAGS="$CFLAGS -Wlogical-op -Werror" 457AC_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) 461CFLAGS="$old_CFLAGS"]) 462AM_CONDITIONAL(SANE_LOGICAL_OP_WARNING, 463 [test "x$ac_cv_logical_op" != "xno"]) 464 465# -Wduplicated-cond was added by GCC6 466AC_CACHE_CHECK([whether gcc accepts -Wduplicated-cond], ac_cv_duplicated_cond, [dnl 467old_CFLAGS="$CFLAGS" 468CFLAGS="$CFLAGS -Wduplicated-cond -Werror" 469AC_COMPILE_IFELSE([AC_LANG_SOURCE([])], 470 ac_cv_duplicated_cond=yes, ac_cv_duplicated_cond=no) 471CFLAGS="$old_CFLAGS"]) 472AM_CONDITIONAL(HAVE_DUPLICATED_COND_WARNING, 473 [test "x$ac_cv_duplicated_cond" != "xno"]) 474 475# -Wnull-dereference was added by GCC6 476AC_CACHE_CHECK([whether gcc accepts -Wnull-dereference], ac_cv_null_dereference, [dnl 477old_CFLAGS="$CFLAGS" 478CFLAGS="$CFLAGS -Wnull-dereference -Werror" 479AC_COMPILE_IFELSE([AC_LANG_SOURCE([])], 480 ac_cv_null_dereference=yes, ac_cv_null_dereference=no) 481CFLAGS="$old_CFLAGS"]) 482AM_CONDITIONAL(HAVE_NULL_DEREFERENCE_WARNING, 483 [test "x$ac_cv_null_dereference" != "xno"]) 484 485# -Wimplicit-fallthrough was added by GCC7 486AC_CACHE_CHECK([whether gcc accepts -Wimplicit-fallthrough], ac_cv_implicit_fallthrough, [dnl 487old_CFLAGS="$CFLAGS" 488CFLAGS="$CFLAGS -Wimplicit-fallthrough -Werror" 489AC_COMPILE_IFELSE([AC_LANG_SOURCE([])], 490 ac_cv_implicit_fallthrough=yes, ac_cv_implicit_fallthrough=no) 491CFLAGS="$old_CFLAGS"]) 492AM_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" 498AC_CACHE_CHECK([whether the compiler accepts -Wimplicit-fallthrough=5], ac_cv_implicit_fallthrough_5, [dnl 499old_CFLAGS="$CFLAGS" 500CFLAGS="$CFLAGS -Wimplicit-fallthrough=5 -Werror" 501AC_COMPILE_IFELSE([AC_LANG_SOURCE([])], 502 ac_cv_implicit_fallthrough_5=yes, ac_cv_implicit_fallthrough_5=no) 503CFLAGS="$old_CFLAGS"]) 504AM_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 508if test "$ac_cv_implicit_fallthrough" = "yes"; then 509 AC_DEFINE([HAVE_FALLTHROUGH], [1], 510 [Defined if __attribute__((fallthrough)) is supported]) 511fi 512 513AC_CACHE_CHECK([whether the compiler accepts -Wtrampolines], ac_cv_trampolines, [dnl 514old_CFLAGS="$CFLAGS" 515CFLAGS="$CFLAGS -Wtrampolines -Werror" 516AC_COMPILE_IFELSE([AC_LANG_SOURCE([])], 517 ac_cv_trampolines=yes, ac_cv_trampolines=no) 518CFLAGS="$old_CFLAGS"]) 519AM_CONDITIONAL(HAVE_TRAMPOLINES_WARNING, 520 [test "x$ac_cv_trampolines" != "xno"]) 521 522AC_CACHE_CHECK([whether the compiler accepts -Wno-packed-not-aligned], ac_cv_no_packed_not_aligned, [dnl 523old_CFLAGS="$CFLAGS" 524CFLAGS="$CFLAGS -Wno-packed-not-aligned -Werror" 525AC_COMPILE_IFELSE([AC_LANG_SOURCE([])], 526 ac_cv_no_packed_not_aligned=yes, ac_cv_no_packed_not_aligned=no) 527CFLAGS="$old_CFLAGS"]) 528AM_CONDITIONAL(HAVE_NO_PACKED_NOT_ALIGNED_WARNING, 529 [test "x$ac_cv_no_packed_not_aligned" != "xno"]) 530 531saved_LIBS="$LIBS" 532AC_SEARCH_LIBS([argp_parse], [argp]) 533LIBS="$saved_LIBS" 534case "$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= ;; 538esac 539AC_SUBST([argp_LDADD]) 540 541saved_LIBS="$LIBS" 542AC_SEARCH_LIBS([fts_close], [fts]) 543LIBS="$saved_LIBS" 544case "$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= ;; 548esac 549AC_SUBST([fts_LIBS]) 550 551saved_LIBS="$LIBS" 552AC_SEARCH_LIBS([_obstack_free], [obstack]) 553LIBS="$saved_LIBS" 554case "$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= ;; 558esac 559AC_SUBST([obstack_LIBS]) 560 561dnl The directories with content. 562 563dnl Documentation. 564AC_CONFIG_FILES([doc/Makefile]) 565 566dnl Support library. 567AC_CONFIG_FILES([lib/Makefile]) 568 569dnl ELF library. 570AC_CONFIG_FILES([libelf/Makefile]) 571 572dnl Higher-level ELF support library. 573AC_CONFIG_FILES([libebl/Makefile]) 574 575dnl DWARF-ELF Lower-level Functions support library. 576AC_CONFIG_FILES([libdwelf/Makefile]) 577 578dnl DWARF library. 579AC_CONFIG_FILES([libdw/Makefile]) 580 581dnl Higher-level DWARF support library. 582AC_CONFIG_FILES([libdwfl/Makefile]) 583 584dnl CPU handling library. 585AC_CONFIG_FILES([libcpu/Makefile]) 586 587dnl Assembler library. 588AC_CONFIG_FILES([libasm/Makefile]) 589 590dnl CPU-specific backend libraries. 591AC_CONFIG_FILES([backends/Makefile]) 592 593dnl Tools. 594AC_CONFIG_FILES([src/Makefile po/Makefile.in]) 595 596dnl Test suite. 597AC_CONFIG_FILES([tests/Makefile]) 598 599dnl pkgconfig files 600AC_CONFIG_FILES([config/libelf.pc config/libdw.pc config/libdebuginfod.pc]) 601 602dnl As long as "git grep 'PRI[diouxX]' po" reports matches in 603dnl translatable strings, we must use need-formatstring-macros here. 604AM_GNU_GETTEXT([external], [need-formatstring-macros]) 605 606dnl AM_GNU_GETTEXT_VERSION is still needed for old versions 607dnl of autoreconf that do not recognize AM_GNU_GETTEXT_REQUIRE_VERSION. 608dnl 0.19.6 is the first version of gettext that provides 609dnl AM_GNU_GETTEXT_REQUIRE_VERSION support. 610AM_GNU_GETTEXT_VERSION([0.19.6]) 611AM_GNU_GETTEXT_REQUIRE_VERSION([0.19.6]) 612 613dnl Appended to the config.h file. 614dnl We hide all kinds of configuration magic in lib/eu-config.h. 615AH_BOTTOM([#include <eu-config.h>]) 616 617dnl Version compatibility header. 618AC_CONFIG_FILES([version.h:config/version.h.in]) 619AC_SUBST([eu_version]) 620 621# 1.234<whatever> -> 1234<whatever> 622case "$PACKAGE_VERSION" in 623[[0-9]].*) eu_version=`echo "$PACKAGE_VERSION" | sed 's@\.@@'` ;; 624*) AC_MSG_ERROR([confused by version number '$PACKAGE_VERSION']) ;; 625esac 626case "$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 ;; 641esac 642 643case "$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']) ;; 649esac 650 651# Round up to the next release API (x.y) version. 652eu_version=$(( (eu_version + 999) / 1000 )) 653 654AC_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. 659AC_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>]]) 664if 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]) 667fi 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. 671utrace_BIARCH 672# `$utrace_biarch' will be `-m64' even on an uniarch i386 machine. 673CC_BIARCH="$CC $utrace_biarch" 674AC_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. 678if 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 691else 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 695fi 696 697# The testfiles are all compressed, we need bunzip2 when running make check 698AC_CHECK_PROG(HAVE_BUNZIP2, bunzip2, yes, no) 699if test "$HAVE_BUNZIP2" = "no"; then 700 AC_MSG_WARN([No bunzip2, needed to run make check]) 701fi 702 703# For tests that need to use zstd compression 704AC_CHECK_PROG(HAVE_ZSTD, zstd, yes, no) 705AM_CONDITIONAL([HAVE_ZSTD],[test "x$HAVE_ZSTD" = "xyes"]) 706 707# Look for libcurl for libdebuginfod minimum version as per rhel7. 708AC_ARG_ENABLE([libdebuginfod],AC_HELP_STRING([--enable-libdebuginfod], [Build debuginfod client library (can be =dummy)])) 709AS_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 723AC_CHECK_LIB(pthread, pthread_setname_np, [ 724 AC_DEFINE([HAVE_PTHREAD_SETNAME_NP],[1],[Enable pthread_setname_np])]) 725 726AS_IF([test "x$enable_libdebuginfod" = "xyes" || test "x$enable_libdebuginfod" = "xdummy"], 727 [AC_DEFINE([ENABLE_LIBDEBUGINFOD], [1], [Enable libdebuginfod])]) 728AS_IF([test "x$enable_libdebuginfod" = "xdummy"], 729 [AC_DEFINE([DUMMY_LIBDEBUGINFOD], [1], [Build dummy libdebuginfod])]) 730AM_CONDITIONAL([LIBDEBUGINFOD],[test "x$enable_libdebuginfod" = "xyes" || test "x$enable_libdebuginfod" = "xdummy"]) 731AM_CONDITIONAL([DUMMY_LIBDEBUGINFOD],[test "x$enable_libdebuginfod" = "xdummy"]) 732 733# Look for libmicrohttpd, libarchive, sqlite for debuginfo server 734# minimum versions as per rhel7. 735AC_ARG_ENABLE([debuginfod],AC_HELP_STRING([--enable-debuginfod], [Build debuginfod server])) 736AC_PROG_CXX 737AS_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 754AS_IF([test "x$enable_debuginfod" != "xno"],AC_DEFINE([ENABLE_DEBUGINFOD],[1],[Build debuginfod])) 755AM_CONDITIONAL([DEBUGINFOD],[test "x$enable_debuginfod" = "xyes"]) 756 757dnl for /etc/profile.d/elfutils.{csh,sh} 758default_debuginfod_urls="" 759AC_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=""]) 767AC_SUBST(DEBUGINFOD_URLS, $default_debuginfod_urls) 768AC_CONFIG_FILES([config/profile.sh config/profile.csh]) 769 770AC_OUTPUT 771 772AC_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 816if 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 820fi 821