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