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.179],[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 28# We want eu- as default program prefix if none was given by the user. 29# But if the user explicitly provided --program-prefix="" then pretend 30# it wasn't set at all (NONE). We want to test this really early before 31# configure has a chance to use the value. 32 33if test "x$program_prefix" = "xNONE"; then 34 AC_MSG_NOTICE([No --program-prefix given, using "eu-"]) 35 program_prefix="eu-" 36elif test "x$program_prefix" = "x"; then 37 AC_MSG_NOTICE([Using no program-prefix]) 38 program_prefix=NONE 39fi 40 41AC_CONFIG_AUX_DIR([config]) 42AC_CONFIG_FILES([config/Makefile]) 43 44AC_COPYRIGHT([Copyright (C) 1996-2018 The elfutils developers.]) 45AC_PREREQ(2.63) dnl Minimum Autoconf version required. 46 47dnl We use GNU make extensions; automake 1.10 defaults to -Wportability. 48AM_INIT_AUTOMAKE([gnits 1.11 -Wno-portability dist-bzip2 no-dist-gzip parallel-tests]) 49AM_MAINTAINER_MODE 50 51AM_SILENT_RULES([yes]) 52 53AC_CONFIG_SRCDIR([libelf/libelf.h]) 54AC_CONFIG_FILES([Makefile]) 55AC_CONFIG_HEADERS([config.h]) 56 57AC_CONFIG_MACRO_DIR([m4]) 58AC_CONFIG_FILES([m4/Makefile]) 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]) 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 nessesary 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"], [CFLAGS="$CFLAGS -DBAD_FTS=1"]) 265 266# See if we can add -D_FORTIFY_SOURCE=2. Don't do it if it is already 267# (differently) defined or if it generates warnings/errors because we 268# don't use the right optimisation level (string.h will warn about that). 269AC_MSG_CHECKING([whether to add -D_FORTIFY_SOURCE=2 to CFLAGS]) 270case "$CFLAGS" in 271 *-D_FORTIFY_SOURCE=2*) 272 AC_MSG_RESULT([no, already there]) 273 ;; 274 *) 275 save_CFLAGS="$CFLAGS" 276 CFLAGS="-D_FORTIFY_SOURCE=2 $CFLAGS -Werror" 277 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[ 278 #include <string.h> 279 int main() { return 0; } 280 ]])], [ AC_MSG_RESULT([yes]) 281 CFLAGS="-D_FORTIFY_SOURCE=2 $save_CFLAGS" ], 282 [ AC_MSG_RESULT([no]) 283 CFLAGS="$save_CFLAGS"]) 284 ;; 285esac 286 287dnl enable debugging of branch prediction. 288AC_ARG_ENABLE([debugpred], 289AS_HELP_STRING([--enable-debugpred],[build binaries with support to debug branch prediction]), 290[use_debugpred=$enableval], [use_debugpred=no]) 291case $use_debugpred in 292 yes) use_debugpred_val=1 ;; 293 *) use_debugpred_val=0 ;; 294esac 295AC_SUBST([DEBUGPRED], $use_debugpred_val) 296 297dnl Enable gprof suport. 298AC_ARG_ENABLE([gprof], 299AS_HELP_STRING([--enable-gprof],[build binaries with gprof support]), [use_gprof=$enableval], [use_gprof=no]) 300if test "$use_gprof" = yes; then 301 CFLAGS="$CFLAGS -pg" 302 LDFLAGS="$LDFLAGS -pg" 303fi 304AM_CONDITIONAL(GPROF, test "$use_gprof" = yes) 305 306# Enable gcov suport. 307AC_ARG_ENABLE([gcov], 308AS_HELP_STRING([--enable-gcov],[build binaries with gcov support]), [use_gcov=$enableval], [use_gcov=no]) 309if test "$use_gcov" = yes; then 310 CFLAGS="$CFLAGS -fprofile-arcs -ftest-coverage" 311 CXXFLAGS="$CXXFLAGS -fprofile-arcs -ftest-coverage" 312 LDFLAGS="$LDFLAGS -fprofile-arcs" 313fi 314AM_CONDITIONAL(GCOV, test "$use_gcov" = yes) 315 316AC_ARG_ENABLE([sanitize-undefined], 317 AS_HELP_STRING([--enable-sanitize-undefined], 318 [Use gcc undefined behaviour sanitizer]), 319 [use_undefined=$enableval], [use_undefined=no]) 320if test "$use_undefined" = yes; then 321 old_CFLAGS="$CFLAGS" 322 old_CXXFLAGS="$CXXFLAGS" 323 # We explicitly use unaligned access when possible (see ALLOW_UNALIGNED) 324 # We want to fail immediately on first error, don't try to recover. 325 CFLAGS="$CFLAGS -fsanitize=undefined -fno-sanitize-recover" 326 CXXFLAGS="$CXXFLAGS -fsanitize=undefined -fno-sanitize-recover" 327 AC_LINK_IFELSE([AC_LANG_SOURCE([int main (int argc, char **argv) { return 0; }])], use_undefined=yes, use_undefined=no) 328 AS_IF([test "x$use_undefined" != xyes], 329 AC_MSG_WARN([gcc undefined behaviour sanitizer not available]) 330 CFLAGS="$old_CFLAGS" CXXFLAGS="$old_CXXFLAGS") 331fi 332case $use_undefined in 333 yes) check_undefined_val=1 ;; 334 *) check_undefined_val=0 ;; 335esac 336AC_DEFINE_UNQUOTED(CHECK_UNDEFINED, $check_undefined_val, 337 [Building with -fsanitize=undefined or not]) 338 339AC_ARG_ENABLE([valgrind], 340AS_HELP_STRING([--enable-valgrind],[run all tests under valgrind]), 341[use_valgrind=$enableval], [use_valgrind=no]) 342if test "$use_valgrind" = yes; then 343 AC_CHECK_PROG(HAVE_VALGRIND, valgrind, yes, no) 344 if test "$HAVE_VALGRIND" = "no"; then 345 AC_MSG_ERROR([valgrind not found]) 346 fi 347fi 348AM_CONDITIONAL(USE_VALGRIND, test "$use_valgrind" = yes) 349 350AC_ARG_WITH([valgrind], 351AS_HELP_STRING([--with-valgrind],[include directory for Valgrind headers]), 352[with_valgrind_headers=$withval], [with_valgrind_headers=no]) 353if test "x$with_valgrind_headers" != xno; then 354 save_CFLAGS="$CFLAGS" 355 CFLAGS="$CFLAGS -I$with_valgrind_headers" 356 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[ 357 #include <valgrind/valgrind.h> 358 int main() { return 0; } 359 ]])], [ HAVE_VALGRIND_HEADERS="yes" 360 CFLAGS="$save_CFLAGS -I$with_valgrind_headers" ], 361 [ AC_MSG_ERROR([invalid valgrind include directory: $with_valgrind_headers]) ]) 362fi 363 364AC_ARG_ENABLE([valgrind-annotations], 365AS_HELP_STRING([--enable-valgrind-annotations],[insert extra annotations for better valgrind support]), 366[use_vg_annotations=$enableval], [use_vg_annotations=no]) 367if test "$use_vg_annotations" = yes; then 368 if test "x$HAVE_VALGRIND_HEADERS" != "xyes"; then 369 AC_MSG_CHECKING([whether Valgrind headers are available]) 370 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[ 371 #include <valgrind/valgrind.h> 372 int main() { return 0; } 373 ]])], [ AC_MSG_RESULT([yes]) ], 374 [ AC_MSG_ERROR([valgrind annotations requested but no headers are available]) ]) 375 fi 376fi 377AM_CONDITIONAL(USE_VG_ANNOTATIONS, test "$use_vg_annotations" = yes) 378 379AC_ARG_ENABLE([install-elfh], 380AS_HELP_STRING([--enable-install-elfh],[install elf.h in include dir]), 381 [install_elfh=$enableval], [install_elfh=no]) 382AM_CONDITIONAL(INSTALL_ELFH, test "$install_elfh" = yes) 383 384AM_CONDITIONAL(BUILD_STATIC, [dnl 385test "$use_gprof" = yes -o "$use_gcov" = yes]) 386 387AC_ARG_ENABLE([tests-rpath], 388AS_HELP_STRING([--enable-tests-rpath],[build $ORIGIN-using rpath into tests]), 389 [tests_use_rpath=$enableval], [tests_use_rpath=no]) 390AM_CONDITIONAL(TESTS_RPATH, test "$tests_use_rpath" = yes) 391 392dnl zlib is mandatory. 393save_LIBS="$LIBS" 394LIBS= 395eu_ZIPLIB(zlib,ZLIB,z,gzdirect,gzip) 396AS_IF([test "x$with_zlib" = xno], [AC_MSG_ERROR([zlib not found but is required])]) 397LIBS="$save_LIBS" 398 399dnl Test for bzlib and xz/lzma, gives BZLIB/LZMALIB .am 400dnl conditional and config.h USE_BZLIB/USE_LZMALIB #define. 401save_LIBS="$LIBS" 402LIBS= 403eu_ZIPLIB(bzlib,BZLIB,bz2,BZ2_bzdopen,bzip2) 404# We need this since bzip2 doesn't have a pkgconfig file. 405BZ2_LIB="$LIBS" 406AC_SUBST([BZ2_LIB]) 407eu_ZIPLIB(lzma,LZMA,lzma,lzma_auto_decoder,[LZMA (xz)]) 408AS_IF([test "x$with_lzma" = xyes], [LIBLZMA="liblzma"], [LIBLZMA=""]) 409AC_SUBST([LIBLZMA]) 410zip_LIBS="$LIBS" 411LIBS="$save_LIBS" 412AC_SUBST([zip_LIBS]) 413 414AC_CHECK_DECLS([memrchr, rawmemchr],[],[], 415 [#define _GNU_SOURCE 416 #include <string.h>]) 417AC_CHECK_DECLS([powerof2],[],[],[#include <sys/param.h>]) 418AC_CHECK_DECLS([mempcpy],[],[], 419 [#define _GNU_SOURCE 420 #include <string.h>]) 421 422AC_CHECK_FUNCS([process_vm_readv]) 423 424AC_CHECK_LIB([stdc++], [__cxa_demangle], [dnl 425AC_DEFINE([USE_DEMANGLE], [1], [Defined if demangling is enabled])]) 426AM_CONDITIONAL(DEMANGLE, test "x$ac_cv_lib_stdcpp___cxa_demangle" = "xyes") 427AS_IF([test "x$ac_cv_lib_stdcpp___cxa_demangle" = "xyes"], 428 [enable_demangler=yes],[enable_demangler=no]) 429 430AC_ARG_ENABLE([textrelcheck], 431AS_HELP_STRING([--disable-textrelcheck], 432 [Disable textrelcheck being a fatal error])) 433AM_CONDITIONAL(FATAL_TEXTREL, [test "x$enable_textrelcheck" != "xno"]) 434AS_IF([test "x$enable_textrelcheck" != "xno"], 435 [enable_textrelcheck=yes],[enable_textrelcheck=no]) 436 437AC_ARG_ENABLE([symbol-versioning], 438AS_HELP_STRING([--disable-symbol-versioning], 439 [Disable symbol versioning in shared objects])) 440 441AC_CACHE_CHECK([whether symbol versioning is supported], ac_cv_symbol_versioning, [dnl 442AC_COMPILE_IFELSE([AC_LANG_SOURCE([dnl 443#define NEW_VERSION(name, version) \ 444 asm (".symver " #name "," #name "@@@" #version); 445int foo(int x) { return x + 1; } 446NEW_VERSION (foo, ELFUTILS_12.12) 447])], ac_cv_symbol_versioning=yes, ac_cv_symbol_versioning=no)]) 448if test "$ac_cv_symbol_versioning" = "no"; then 449 if test "x$enable_symbol_versioning" != "xno"; then 450 AC_MSG_ERROR([Symbol versioning is not supported. 451 Use --disable-symbol-versioning to build without.]) 452 fi 453fi 454 455AM_CONDITIONAL(SYMBOL_VERSIONING, [test "x$enable_symbol_versioning" != "xno"]) 456AS_IF([test "x$enable_symbol_versioning" = "xno"], 457 [AC_MSG_WARN([Disabling symbol versioning breaks ABI compatibility.]) 458 enable_symbol_versioning=no],[enable_symbol_versioning=yes]) 459 460AC_CACHE_CHECK([whether gcc accepts -Wstack-usage], ac_cv_stack_usage, [dnl 461old_CFLAGS="$CFLAGS" 462CFLAGS="$CFLAGS -Wstack-usage=262144 -Werror" 463AC_COMPILE_IFELSE([AC_LANG_SOURCE([])], 464 ac_cv_stack_usage=yes, ac_cv_stack_usage=no) 465CFLAGS="$old_CFLAGS"]) 466AM_CONDITIONAL(ADD_STACK_USAGE_WARNING, [test "x$ac_cv_stack_usage" != "xno"]) 467 468# -Wlogical-op was too fragile in the past, make sure we get a sane one. 469AC_CACHE_CHECK([whether gcc has a sane -Wlogical-op], ac_cv_logical_op, [dnl 470old_CFLAGS="$CFLAGS" 471CFLAGS="$CFLAGS -Wlogical-op -Werror" 472AC_COMPILE_IFELSE([AC_LANG_SOURCE( 473 [#define FLAG 1 474 int f (int r, int f) { return (r && (FLAG || (FLAG & f))); }])], 475 ac_cv_logical_op=yes, ac_cv_logical_op=no) 476CFLAGS="$old_CFLAGS"]) 477AM_CONDITIONAL(SANE_LOGICAL_OP_WARNING, 478 [test "x$ac_cv_logical_op" != "xno"]) 479 480# -Wduplicated-cond was added by GCC6 481AC_CACHE_CHECK([whether gcc accepts -Wduplicated-cond], ac_cv_duplicated_cond, [dnl 482old_CFLAGS="$CFLAGS" 483CFLAGS="$CFLAGS -Wduplicated-cond -Werror" 484AC_COMPILE_IFELSE([AC_LANG_SOURCE([])], 485 ac_cv_duplicated_cond=yes, ac_cv_duplicated_cond=no) 486CFLAGS="$old_CFLAGS"]) 487AM_CONDITIONAL(HAVE_DUPLICATED_COND_WARNING, 488 [test "x$ac_cv_duplicated_cond" != "xno"]) 489 490# -Wnull-dereference was added by GCC6 491AC_CACHE_CHECK([whether gcc accepts -Wnull-dereference], ac_cv_null_dereference, [dnl 492old_CFLAGS="$CFLAGS" 493CFLAGS="$CFLAGS -Wnull-dereference -Werror" 494AC_COMPILE_IFELSE([AC_LANG_SOURCE([])], 495 ac_cv_null_dereference=yes, ac_cv_null_dereference=no) 496CFLAGS="$old_CFLAGS"]) 497AM_CONDITIONAL(HAVE_NULL_DEREFERENCE_WARNING, 498 [test "x$ac_cv_null_dereference" != "xno"]) 499 500# -Wimplicit-fallthrough was added by GCC7 501AC_CACHE_CHECK([whether gcc accepts -Wimplicit-fallthrough], ac_cv_implicit_fallthrough, [dnl 502old_CFLAGS="$CFLAGS" 503CFLAGS="$CFLAGS -Wimplicit-fallthrough -Werror" 504AC_COMPILE_IFELSE([AC_LANG_SOURCE([])], 505 ac_cv_implicit_fallthrough=yes, ac_cv_implicit_fallthrough=no) 506CFLAGS="$old_CFLAGS"]) 507AM_CONDITIONAL(HAVE_IMPLICIT_FALLTHROUGH_WARNING, 508 [test "x$ac_cv_implicit_fallthrough" != "xno"]) 509 510# Assume the fallthrough attribute is supported if -Wimplict-fallthrough is supported 511if test "$ac_cv_implicit_fallthrough" = "yes"; then 512 AC_DEFINE([HAVE_FALLTHROUGH], [1], 513 [Defined if __attribute__((fallthrough)) is supported]) 514fi 515 516dnl Check if we have argp available from our libc 517AC_LINK_IFELSE( 518 [AC_LANG_PROGRAM( 519 [#include <argp.h>], 520 [int argc=1; char *argv[]={"test"}; argp_parse(0,argc,&argv,0,0,0); return 0;] 521 )], 522 [libc_has_argp="true"], 523 [libc_has_argp="false"] 524) 525 526dnl If our libc doesn't provide argp, then test for libargp 527if test "$libc_has_argp" = "false" ; then 528 AC_MSG_WARN("libc does not have argp") 529 AC_CHECK_LIB([argp], [argp_parse], [have_argp="true"], [have_argp="false"]) 530 531 if test "$have_argp" = "false"; then 532 AC_MSG_ERROR("no libargp found") 533 else 534 argp_LDADD="-largp" 535 fi 536else 537 argp_LDADD="" 538fi 539AC_SUBST([argp_LDADD]) 540 541dnl The directories with content. 542 543dnl Documentation. 544AC_CONFIG_FILES([doc/Makefile]) 545 546dnl Support library. 547AC_CONFIG_FILES([lib/Makefile]) 548 549dnl ELF library. 550AC_CONFIG_FILES([libelf/Makefile]) 551 552dnl Higher-level ELF support library. 553AC_CONFIG_FILES([libebl/Makefile]) 554 555dnl DWARF-ELF Lower-level Functions support library. 556AC_CONFIG_FILES([libdwelf/Makefile]) 557 558dnl DWARF library. 559AC_CONFIG_FILES([libdw/Makefile]) 560 561dnl Higher-level DWARF support library. 562AC_CONFIG_FILES([libdwfl/Makefile]) 563 564dnl CPU handling library. 565AC_CONFIG_FILES([libcpu/Makefile]) 566 567dnl Assembler library. 568AM_CONDITIONAL(HAVE_LIBASM, true)dnl Used in tests/Makefile.am, which see. 569AC_CONFIG_FILES([libasm/Makefile]) 570 571dnl CPU-specific backend libraries. 572AC_CONFIG_FILES([backends/Makefile]) 573 574dnl Tools. 575AC_CONFIG_FILES([src/Makefile po/Makefile.in]) 576 577dnl Test suite. 578AM_CONDITIONAL(STANDALONE, false)dnl Used in tests/Makefile.am, which see. 579AC_CONFIG_FILES([tests/Makefile]) 580 581dnl pkgconfig files 582AC_CONFIG_FILES([config/libelf.pc config/libdw.pc config/libdebuginfod.pc]) 583 584# Get the definitions necessary to create the Makefiles in the po 585# subdirectories. This is a small subset of the gettext rules. 586AC_SUBST(USE_NLS, yes) 587AM_PO_SUBDIRS 588 589dnl Appended to the config.h file. 590dnl We hide all kinds of configuration magic in lib/eu-config.h. 591AH_BOTTOM([#include <eu-config.h>]) 592 593dnl Version compatibility header. 594AC_CONFIG_FILES([version.h:config/version.h.in]) 595AC_SUBST([eu_version]) 596 597# 1.234<whatever> -> 1234<whatever> 598case "$PACKAGE_VERSION" in 599[[0-9]].*) eu_version=`echo "$PACKAGE_VERSION" | sed 's@\.@@'` ;; 600*) AC_MSG_ERROR([confused by version number '$PACKAGE_VERSION']) ;; 601esac 602case "$eu_version" in 603*.*) 604 # 1234.567 -> "1234", "567" 605 eu_extra_version="${eu_version#*.}" 606 eu_version="${eu_version%%.*}" 607 case "$eu_extra_version" in 608 [[0-9]][[0-9]][[0-9]]) ;; 609 [[0-9]][[0-9]]) eu_extra_version="${eu_extra_version}0" ;; 610 [[0-9]]) eu_extra_version="${eu_extra_version}00" ;; 611 *) AC_MSG_ERROR([confused by version number '$PACKAGE_VERSION']) ;; 612 esac 613 ;; 614*) 615 eu_extra_version=000 616 ;; 617esac 618 619case "$eu_version" in 620 0[[0-9]][[0-9]][[0-9]]) eu_version="${eu_version#0}$eu_extra_version" ;; 621[[0-9]][[0-9]][[0-9]][[0-9]]) eu_version="${eu_version}$eu_extra_version" ;; 622[[0-9]][[0-9]][[0-9]]) eu_version="${eu_version}0$eu_extra_version" ;; 623[[0-9]][[0-9]]) eu_version="${eu_version}00$eu_extra_version";; 624*) AC_MSG_ERROR([confused by version number '$PACKAGE_VERSION']) ;; 625esac 626 627# Round up to the next release API (x.y) version. 628eu_version=$(( (eu_version + 999) / 1000 )) 629 630dnl Unique ID for this build. 631MODVERSION="Build for ${eu_version} ${ac_cv_build}" 632AC_SUBST([MODVERSION]) 633AC_DEFINE_UNQUOTED(MODVERSION, "$MODVERSION") 634AH_TEMPLATE([MODVERSION], [Identifier for modules in the build.]) 635 636AC_CHECK_SIZEOF(long) 637 638# On aarch64 before glibc 2.20 we would get the kernel user_pt_regs instead 639# of the user_regs_struct from sys/user.h. They are structurally the same 640# but we get either one or the other. 641AC_CHECK_TYPE([struct user_regs_struct], 642 [sys_user_has_user_regs=yes], [sys_user_has_user_regs=no], 643 [[#include <sys/ptrace.h>] 644 [#include <sys/time.h>] 645 [#include <sys/user.h>]]) 646if test "$sys_user_has_user_regs" = "yes"; then 647 AC_DEFINE(HAVE_SYS_USER_REGS, 1, 648 [Define to 1 if <sys/user.h> defines struct user_regs_struct]) 649fi 650 651# On a 64-bit host where can can use $CC -m32, we'll run two sets of tests. 652# Likewise in a 32-bit build on a host where $CC -m64 works. 653utrace_BIARCH 654# `$utrace_biarch' will be `-m64' even on an uniarch i386 machine. 655CC_BIARCH="$CC $utrace_biarch" 656AC_SUBST([CC_BIARCH]) 657 658# In maintainer mode we really need flex and bison. 659# Otherwise we really need a release dir with maintainer files generated. 660if test "x$enable_maintainer_mode" = xyes; then 661 AC_CHECK_PROG(HAVE_FLEX, flex, yes, no) 662 if test "$HAVE_FLEX" = "no"; then 663 AC_MSG_ERROR([flex needed in maintainer mode]) 664 fi 665 AC_CHECK_PROG(HAVE_BISON, bison, yes, no) 666 if test "$HAVE_BISON" = "no"; then 667 AC_MSG_ERROR([bison needed in maintainer mode]) 668 fi 669 AC_CHECK_PROG(HAVE_GAWK, gawk, yes, no) 670 if test "$HAVE_GAWK" = "no"; then 671 AC_MSG_ERROR([gawk needed in maintainer mode]) 672 fi 673else 674 if test ! -f ${srcdir}/libdw/known-dwarf.h; then 675 AC_MSG_ERROR([No libdw/known-dwarf.h. configure --enable-maintainer-mode]) 676 fi 677fi 678 679# The testfiles are all compressed, we need bunzip2 when running make check 680AC_CHECK_PROG(HAVE_BUNZIP2, bunzip2, yes, no) 681if test "$HAVE_BUNZIP2" = "no"; then 682 AC_MSG_WARN([No bunzip2, needed to run make check]) 683fi 684 685# Look for libmicrohttpd, libcurl, libarchive, sqlite for debuginfo server 686# minimum versions as per rhel7. Single --enable-* option arranges to build 687# both client and server. 688AC_ARG_ENABLE([debuginfod],AC_HELP_STRING([--enable-debuginfod], [Build debuginfod server and client])) 689AC_PROG_CXX 690AS_IF([test "x$enable_debuginfod" != "xno"], [ 691 AC_MSG_NOTICE([checking debuginfod C++11 support, --disable-debuginfod to skip]) 692 AX_CXX_COMPILE_STDCXX(11, noext, mandatory) 693 AC_MSG_NOTICE([checking debuginfod dependencies, --disable-debuginfod to skip]) 694 enable_debuginfod=yes # presume success 695 PKG_PROG_PKG_CONFIG 696 PKG_CHECK_MODULES([libmicrohttpd],[libmicrohttpd >= 0.9.33],[],[enable_debuginfod=no]) 697 PKG_CHECK_MODULES([libcurl],[libcurl >= 7.29.0],[],[enable_debuginfod=no]) 698 PKG_CHECK_MODULES([sqlite3],[sqlite3 >= 3.7.17],[],[enable_debuginfod=no]) 699 PKG_CHECK_MODULES([libarchive],[libarchive >= 3.1.2],[],[enable_debuginfod=no]) 700 if test "x$enable_debuginfod" = "xno"; then 701 AC_MSG_ERROR([dependencies not found, use --disable-debuginfod to disable.]) 702 fi 703]) 704 705AS_IF([test "x$enable_debuginfod" != "xno"],AC_DEFINE([ENABLE_DEBUGINFOD],[1],[Build debuginfod])) 706AM_CONDITIONAL([DEBUGINFOD],[test "x$enable_debuginfod" = "xyes"]) 707 708 709AC_OUTPUT 710 711AC_MSG_NOTICE([ 712===================================================================== 713 elfutils: ${PACKAGE_VERSION} (eu_version: ${eu_version}) 714===================================================================== 715 716 Prefix : ${prefix} 717 Program prefix ("eu-" recommended) : ${program_prefix} 718 Source code location : ${srcdir} 719 Maintainer mode : ${enable_maintainer_mode} 720 build arch : ${ac_cv_build} 721 722 RECOMMENDED FEATURES (should all be yes) 723 gzip support : ${with_zlib} 724 bzip2 support : ${with_bzlib} 725 lzma/xz support : ${with_lzma} 726 libstdc++ demangle support : ${enable_demangler} 727 File textrel check : ${enable_textrelcheck} 728 Symbol versioning : ${enable_symbol_versioning} 729 730 NOT RECOMMENDED FEATURES (should all be no) 731 Experimental thread safety : ${use_locks} 732 install elf.h : ${install_elfh} 733 734 OTHER FEATURES 735 Deterministic archives by default : ${default_ar_deterministic} 736 Native language support : ${USE_NLS} 737 Extra Valgrind annotations : ${use_vg_annotations} 738 Debuginfod client/server support : ${enable_debuginfod} 739 740 EXTRA TEST FEATURES (used with make check) 741 have bunzip2 installed (required) : ${HAVE_BUNZIP2} 742 debug branch prediction : ${use_debugpred} 743 gprof support : ${use_gprof} 744 gcov support : ${use_gcov} 745 run all tests under valgrind : ${use_valgrind} 746 gcc undefined behaviour sanitizer : ${use_undefined} 747 use rpath in tests : ${tests_use_rpath} 748 test biarch : ${utrace_cv_cc_biarch} 749]) 750 751if test "$install_elfh" = yes; then 752 if test "${prefix}" = "/usr/local" -o "${prefix}" = "/usr"; then 753 AC_MSG_WARN([installing elf.h in ${includedir} might conflict with glibc/system elf.h]) 754 fi 755fi 756