configure.ac

   1 dnl Process this file with autoconf to produce a configure script.
   2 dnl Configure input file for elfutils.                     -*-autoconf-*-
   3 dnl
   4 dnl Copyright (C) 1996-2018 Red Hat, Inc.
   5 dnl
   6 dnl This file is part of elfutils.
   7 dnl
   8 dnl  This file is free software; you can redistribute it and/or modify
   9 dnl  it under the terms of the GNU General Public License as published by
  10 dnl  the Free Software Foundation; either version 3 of the License, or
  11 dnl  (at your option) any later version.
  12 dnl
  13 dnl  elfutils is distributed in the hope that it will be useful, but
  14 dnl  WITHOUT ANY WARRANTY; without even the implied warranty of
  15 dnl  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 dnl  GNU General Public License for more details.
  17 dnl
  18 dnl  You should have received a copy of the GNU General Public License
  19 dnl  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 AC_INIT([elfutils],[0.176],[https://sourceware.org/bugzilla],[elfutils],[http://elfutils.org/])
  21
  22 dnl Workaround for older autoconf < 2.64
  23 m4_ifndef([AC_PACKAGE_URL],
  24          [AC_DEFINE([PACKAGE_URL], ["http://elfutils.org/"],
  25                     [Define to home page for this package])
  26           AC_SUBST([PACKAGE_URL], ["http://elfutils.org/"])])
  27
  28 # 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
  33 if test "x$program_prefix" = "xNONE"; then
  34   AC_MSG_NOTICE([No --program-prefix given, using "eu-"])
  35   program_prefix="eu-"
  36 elif test "x$program_prefix" = "x"; then
  37   AC_MSG_NOTICE([Using no program-prefix])
  38   program_prefix=NONE
  39 fi
  40
  41 AC_CONFIG_AUX_DIR([config])
  42 AC_CONFIG_FILES([config/Makefile])
  43
  44 AC_COPYRIGHT([Copyright (C) 1996-2018 The elfutils developers.])
  45 AC_PREREQ(2.63)                 dnl Minimum Autoconf version required.
  46
  47 dnl We use GNU make extensions; automake 1.10 defaults to -Wportability.
  48 AM_INIT_AUTOMAKE([gnits 1.11 -Wno-portability dist-bzip2 no-dist-gzip parallel-tests])
  49 AM_MAINTAINER_MODE
  50
  51 AM_SILENT_RULES([yes])
  52
  53 AC_CONFIG_SRCDIR([libelf/libelf.h])
  54 AC_CONFIG_FILES([Makefile])
  55 AC_CONFIG_HEADERS([config.h])
  56
  57 AC_CONFIG_MACRO_DIR([m4])
  58 AC_CONFIG_FILES([m4/Makefile])
  59
  60 dnl The RPM spec file.  We substitute a few values in the file.
  61 AC_CONFIG_FILES([elfutils.spec:config/elfutils.spec.in])
  62
  63
  64 AC_CANONICAL_HOST
  65
  66 AC_ARG_ENABLE(deterministic-archives,
  67 [AS_HELP_STRING([--enable-deterministic-archives],
  68                 [ar and ranlib default to -D behavior])], [
  69 if test "${enableval}" = no; then
  70   default_ar_deterministic=false
  71 else
  72   default_ar_deterministic=true
  73 fi], [default_ar_deterministic=false])
  74 AC_DEFINE_UNQUOTED(DEFAULT_AR_DETERMINISTIC, $default_ar_deterministic,
  75                    [Should ar and ranlib use -D behavior by default?])
  76
  77 AC_ARG_ENABLE([thread-safety],
  78 AS_HELP_STRING([--enable-thread-safety],
  79                [enable thread safety of libraries EXPERIMENTAL]),
  80                use_locks=$enableval, use_locks=no)
  81 AM_CONDITIONAL(USE_LOCKS, test "$use_locks" = yes)
  82 AS_IF([test "$use_locks" = yes], [AC_DEFINE(USE_LOCKS)])
  83 AS_IF([test "$use_locks" = yes],
  84       [AC_MSG_WARN([thread-safety is EXPERIMENTAL tests might fail.])])
  85
  86 AH_TEMPLATE([USE_LOCKS], [Defined if libraries should be thread-safe.])
  87
  88 AC_PROG_CC
  89 AC_PROG_RANLIB
  90 AC_PROG_YACC
  91 AM_PROG_LEX
  92 # Only available since automake 1.12
  93 m4_ifdef([AM_PROG_AR], [AM_PROG_AR])
  94 AC_CHECK_TOOL([READELF], [readelf])
  95 AC_CHECK_TOOL([NM], [nm])
  96
  97 # We use -std=gnu99 but have explicit checks for some language constructs
  98 # and GNU extensions since some compilers claim GNU99 support, but don't
  99 # really support all language extensions. In particular we need
 100 # Mixed Declarations and Code
 101 # https://gcc.gnu.org/onlinedocs/gcc/Mixed-Declarations.html
 102 # Nested Functions
 103 # https://gcc.gnu.org/onlinedocs/gcc/Nested-Functions.html
 104 # Arrays of Variable Length
 105 # https://gcc.gnu.org/onlinedocs/gcc/Variable-Length.html
 106 AC_CACHE_CHECK([for gcc with GNU99 support], ac_cv_c99, [dnl
 107 old_CFLAGS="$CFLAGS"
 108 CFLAGS="$CFLAGS -std=gnu99"
 109 AC_COMPILE_IFELSE([AC_LANG_SOURCE([dnl
 110 int foo (int a)
 111 {
 112   for (int i = 0; i < a; ++i) if (i % 4) break; int s = a; return s;
 113 }
 114
 115 double bar (double a, double b)
 116 {
 117   double square (double z) { return z * z; }
 118   return square (a) + square (b);
 119 }
 120
 121 void baz (int n)
 122 {
 123   struct S { int x[[n]]; };
 124 }])],
 125                   ac_cv_c99=yes, ac_cv_c99=no)
 126 CFLAGS="$old_CFLAGS"])
 127 AS_IF([test "x$ac_cv_c99" != xyes],
 128       AC_MSG_ERROR([gcc with GNU99 support required]))
 129
 130 AC_CACHE_CHECK([whether gcc supports __attribute__((visibility()))],
 131         ac_cv_visibility, [dnl
 132 save_CFLAGS="$CFLAGS"
 133 CFLAGS="$save_CFLAGS -Werror"
 134 AC_COMPILE_IFELSE([AC_LANG_SOURCE([dnl
 135 int __attribute__((visibility("hidden")))
 136 foo (int a)
 137 {
 138   return a;
 139 }])], ac_cv_visibility=yes, ac_cv_visibility=no)
 140 CFLAGS="$save_CFLAGS"])
 141 if test "$ac_cv_visibility" = "yes"; then
 142         AC_DEFINE([HAVE_VISIBILITY], [1],
 143                   [Defined if __attribute__((visibility())) is supported])
 144 fi
 145
 146 AC_CACHE_CHECK([whether gcc supports __attribute__((gcc_struct))],
 147         ac_cv_gcc_struct, [dnl
 148 save_CFLAGS="$CFLAGS"
 149 CFLAGS="$save_CFLAGS -Werror"
 150 AC_COMPILE_IFELSE([AC_LANG_SOURCE([dnl
 151 struct test { int x; } __attribute__((gcc_struct));
 152 ])], ac_cv_gcc_struct=yes, ac_cv_gcc_struct=no)
 153 CFLAGS="$save_CFLAGS"])
 154 if test "$ac_cv_gcc_struct" = "yes"; then
 155         AC_DEFINE([HAVE_GCC_STRUCT], [1],
 156                   [Defined if __attribute__((gcc_struct)) is supported])
 157 fi
 158
 159 AC_CACHE_CHECK([whether gcc supports -fPIC], ac_cv_fpic, [dnl
 160 save_CFLAGS="$CFLAGS"
 161 CFLAGS="$save_CFLAGS -fPIC -Werror"
 162 AC_COMPILE_IFELSE([AC_LANG_SOURCE()], ac_cv_fpic=yes, ac_cv_fpic=no)
 163 CFLAGS="$save_CFLAGS"
 164 ])
 165 if test "$ac_cv_fpic" = "yes"; then
 166         fpic_CFLAGS="-fPIC"
 167 else
 168         fpic_CFLAGS=""
 169 fi
 170 AC_SUBST([fpic_CFLAGS])
 171
 172 AC_CACHE_CHECK([whether gcc supports -fPIE], ac_cv_fpie, [dnl
 173 save_CFLAGS="$CFLAGS"
 174 CFLAGS="$save_CFLAGS -fPIE -Werror"
 175 AC_COMPILE_IFELSE([AC_LANG_SOURCE()], ac_cv_fpie=yes, ac_cv_fpie=no)
 176 CFLAGS="$save_CFLAGS"
 177 ])
 178 if test "$ac_cv_fpie" = "yes"; then
 179         fpie_CFLAGS="-fPIE"
 180 else
 181         fpie_CFLAGS=""
 182 fi
 183 AC_SUBST([fpie_CFLAGS])
 184
 185 dso_LDFLAGS="-shared"
 186
 187 ZDEFS_LDFLAGS="-Wl,-z,defs"
 188 AC_CACHE_CHECK([whether gcc supports $ZDEFS_LDFLAGS], ac_cv_zdefs, [dnl
 189 save_LDFLAGS="$LDFLAGS"
 190 LDFLAGS="$ZDEFS_LDFLAGS $save_LDFLAGS"
 191 AC_LINK_IFELSE([AC_LANG_PROGRAM()], ac_cv_zdefs=yes, ac_cv_zdefs=no)
 192 LDFLAGS="$save_LDFLAGS"
 193 ])
 194 if test "$ac_cv_zdefs" = "yes"; then
 195         dso_LDFLAGS="$dso_LDFLAGS $ZDEFS_LDFLAGS"
 196 fi
 197
 198 ZRELRO_LDFLAGS="-Wl,-z,relro"
 199 AC_CACHE_CHECK([whether gcc supports $ZRELRO_LDFLAGS], ac_cv_zrelro, [dnl
 200 save_LDFLAGS="$LDFLAGS"
 201 LDFLAGS="$ZRELRO_LDFLAGS $save_LDFLAGS"
 202 AC_LINK_IFELSE([AC_LANG_PROGRAM()], ac_cv_zrelro=yes, ac_cv_zrelro=no)
 203 LDFLAGS="$save_LDFLAGS"
 204 ])
 205 if test "$ac_cv_zrelro" = "yes"; then
 206         dso_LDFLAGS="$dso_LDFLAGS $ZRELRO_LDFLAGS"
 207 fi
 208
 209 AC_SUBST([dso_LDFLAGS])
 210
 211 AC_CACHE_CHECK([for __thread support], ac_cv_tls, [dnl
 212 # Use the same flags that we use for our DSOs, so the test is representative.
 213 # Some old compiler/linker/libc combinations fail some ways and not others.
 214 save_CFLAGS="$CFLAGS"
 215 save_LDFLAGS="$LDFLAGS"
 216 CFLAGS="$fpic_CFLAGS $CFLAGS"
 217 LDFLAGS="$dso_LDFLAGS $LDFLAGS"
 218 AC_LINK_IFELSE([dnl
 219 AC_LANG_PROGRAM([[#include <stdlib.h>
 220 #undef __thread
 221 static __thread int a; int foo (int b) { return a + b; }]],
 222                 [[exit (foo (0));]])],
 223                ac_cv_tls=yes, ac_cv_tls=no)
 224 CFLAGS="$save_CFLAGS"
 225 LDFLAGS="$save_LDFLAGS"])
 226 AS_IF([test "x$ac_cv_tls" != xyes],
 227       AC_MSG_ERROR([__thread support required]))
 228
 229 dnl This test must come as early as possible after the compiler configuration
 230 dnl tests, because the choice of the file model can (in principle) affect
 231 dnl whether functions and headers are available, whether they work, etc.
 232 AC_SYS_LARGEFILE
 233
 234 dnl Older glibc had a broken fts that didn't work with Large File Systems.
 235 dnl We want the version that can handler LFS, but include workaround if we
 236 dnl get a bad one. Add define to CFLAGS (not AC_DEFINE it) since we need to
 237 dnl check it before including config.h (which might define _FILE_OFFSET_BITS).
 238 AC_CACHE_CHECK([whether fts.h is bad when included (with LFS)], ac_cv_bad_fts,
 239   [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[#include <fts.h>]])],
 240                      ac_cv_bad_fts=no, ac_cv_bad_fts=yes)])
 241 AS_IF([test "x$ac_cv_bad_fts" = "xyes"], [CFLAGS="$CFLAGS -DBAD_FTS=1"])
 242
 243 # See if we can add -D_FORTIFY_SOURCE=2. Don't do it if it is already
 244 # (differently) defined or if it generates warnings/errors because we
 245 # don't use the right optimisation level (string.h will warn about that).
 246 AC_MSG_CHECKING([whether to add -D_FORTIFY_SOURCE=2 to CFLAGS])
 247 case "$CFLAGS" in
 248   *-D_FORTIFY_SOURCE=2*)
 249     AC_MSG_RESULT([no, already there])
 250     ;;
 251   *)
 252     save_CFLAGS="$CFLAGS"
 253     CFLAGS="-D_FORTIFY_SOURCE=2 -Werror $CFLAGS"
 254     AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
 255       #include <string.h>
 256       int main() { return 0; }
 257     ]])], [ AC_MSG_RESULT([yes])
 258             CFLAGS="-D_FORTIFY_SOURCE=2 $save_CFLAGS" ],
 259           [ AC_MSG_RESULT([no])
 260             CFLAGS="$save_CFLAGS"])
 261   ;;
 262 esac
 263
 264 dnl enable debugging of branch prediction.
 265 AC_ARG_ENABLE([debugpred],
 266 AS_HELP_STRING([--enable-debugpred],[build binaries with support to debug branch prediction]),
 267 [use_debugpred=$enableval], [use_debugpred=no])
 268 case $use_debugpred in
 269  yes) use_debugpred_val=1 ;;
 270  *)   use_debugpred_val=0 ;;
 271 esac
 272 AC_SUBST([DEBUGPRED], $use_debugpred_val)
 273
 274 dnl Enable gprof suport.
 275 AC_ARG_ENABLE([gprof],
 276 AS_HELP_STRING([--enable-gprof],[build binaries with gprof support]), [use_gprof=$enableval], [use_gprof=no])
 277 if test "$use_gprof" = yes; then
 278   CFLAGS="$CFLAGS -pg"
 279   LDFLAGS="$LDFLAGS -pg"
 280 fi
 281 AM_CONDITIONAL(GPROF, test "$use_gprof" = yes)
 282
 283 # Enable gcov suport.
 284 AC_ARG_ENABLE([gcov],
 285 AS_HELP_STRING([--enable-gcov],[build binaries with gcov support]), [use_gcov=$enableval], [use_gcov=no])
 286 if test "$use_gcov" = yes; then
 287   CFLAGS="$CFLAGS -fprofile-arcs -ftest-coverage"
 288   LDFLAGS="$LDFLAGS -fprofile-arcs"
 289 fi
 290 AM_CONDITIONAL(GCOV, test "$use_gcov" = yes)
 291
 292 AC_ARG_ENABLE([sanitize-undefined],
 293               AS_HELP_STRING([--enable-sanitize-undefined],
 294                              [Use gcc undefined behaviour sanitizer]),
 295                              [use_undefined=$enableval], [use_undefined=no])
 296 if test "$use_undefined" = yes; then
 297   old_CFLAGS="$CFLAGS"
 298   old_CXXFLAGS="$CXXFLAGS"
 299   # We explicitly use unaligned access when possible (see ALLOW_UNALIGNED)
 300   # We want to fail immediately on first error, don't try to recover.
 301   CFLAGS="$CFLAGS -fsanitize=undefined -fno-sanitize-recover"
 302   CXXFLAGS="$CXXFLAGS -fsanitize=undefined -fno-sanitize-recover"
 303   AC_LINK_IFELSE([AC_LANG_SOURCE([int main (int argc, char **argv) { return 0; }])], use_undefined=yes, use_undefined=no)
 304   AS_IF([test "x$use_undefined" != xyes],
 305         AC_MSG_WARN([gcc undefined behaviour sanitizer not available])
 306         CFLAGS="$old_CFLAGS" CXXFLAGS="$old_CXXFLAGS")
 307 fi
 308 case $use_undefined in
 309  yes) check_undefined_val=1 ;;
 310  *)   check_undefined_val=0 ;;
 311 esac
 312 AC_DEFINE_UNQUOTED(CHECK_UNDEFINED, $check_undefined_val,
 313                    [Building with -fsanitize=undefined or not])
 314
 315 AC_ARG_ENABLE([valgrind],
 316 AS_HELP_STRING([--enable-valgrind],[run all tests under valgrind]),
 317 [use_valgrind=$enableval], [use_valgrind=no])
 318 if test "$use_valgrind" = yes; then
 319   AC_CHECK_PROG(HAVE_VALGRIND, valgrind, yes, no)
 320   if test "$HAVE_VALGRIND" = "no"; then
 321     AC_MSG_ERROR([valgrind not found])
 322   fi
 323 fi
 324 AM_CONDITIONAL(USE_VALGRIND, test "$use_valgrind" = yes)
 325
 326 AC_ARG_ENABLE([install-elfh],
 327 AS_HELP_STRING([--enable-install-elfh],[install elf.h in include dir]),
 328                [install_elfh=$enableval], [install_elfh=no])
 329 AM_CONDITIONAL(INSTALL_ELFH, test "$install_elfh" = yes)
 330
 331 AM_CONDITIONAL(BUILD_STATIC, [dnl
 332 test "$use_gprof" = yes -o "$use_gcov" = yes])
 333
 334 AC_ARG_ENABLE([tests-rpath],
 335 AS_HELP_STRING([--enable-tests-rpath],[build $ORIGIN-using rpath into tests]),
 336                [tests_use_rpath=$enableval], [tests_use_rpath=no])
 337 AM_CONDITIONAL(TESTS_RPATH, test "$tests_use_rpath" = yes)
 338
 339 LIBEBL_SUBDIR="$PACKAGE"
 340 AC_ARG_ENABLE([libebl-subdir],
 341 AS_HELP_STRING([--enable-libebl-subdir=DIR],
 342 [install libebl_CPU modules in $(libdir)/DIR]), [dnl
 343 LIBEBL_SUBDIR="$enable_libebl_subdir"])
 344 AC_SUBST([LIBEBL_SUBDIR])
 345 AC_DEFINE_UNQUOTED(LIBEBL_SUBDIR, "$LIBEBL_SUBDIR")
 346 AH_TEMPLATE([LIBEBL_SUBDIR], [$libdir subdirectory containing libebl modules.])
 347
 348 dnl zlib is mandatory.
 349 save_LIBS="$LIBS"
 350 LIBS=
 351 eu_ZIPLIB(zlib,ZLIB,z,gzdirect,gzip)
 352 AS_IF([test "x$with_zlib" = xno], [AC_MSG_ERROR([zlib not found but is required])])
 353 LIBS="$save_LIBS"
 354
 355 dnl Test for bzlib and xz/lzma, gives BZLIB/LZMALIB .am
 356 dnl conditional and config.h USE_BZLIB/USE_LZMALIB #define.
 357 save_LIBS="$LIBS"
 358 LIBS=
 359 eu_ZIPLIB(bzlib,BZLIB,bz2,BZ2_bzdopen,bzip2)
 360 # We need this since bzip2 doesn't have a pkgconfig file.
 361 BZ2_LIB="$LIBS"
 362 AC_SUBST([BZ2_LIB])
 363 eu_ZIPLIB(lzma,LZMA,lzma,lzma_auto_decoder,[LZMA (xz)])
 364 AS_IF([test "x$with_lzma" = xyes], [LIBLZMA="liblzma"], [LIBLZMA=""])
 365 AC_SUBST([LIBLZMA])
 366 zip_LIBS="$LIBS"
 367 LIBS="$save_LIBS"
 368 AC_SUBST([zip_LIBS])
 369
 370 AC_CHECK_DECLS([memrchr, rawmemchr],[],[],
 371                [#define _GNU_SOURCE
 372                 #include <string.h>])
 373 AC_CHECK_DECLS([powerof2],[],[],[#include <sys/param.h>])
 374 AC_CHECK_DECLS([mempcpy],[],[],
 375                [#define _GNU_SOURCE
 376                 #include <string.h>])
 377
 378 AC_CHECK_FUNCS([process_vm_readv])
 379
 380 AC_CHECK_LIB([stdc++], [__cxa_demangle], [dnl
 381 AC_DEFINE([USE_DEMANGLE], [1], [Defined if demangling is enabled])])
 382 AM_CONDITIONAL(DEMANGLE, test "x$ac_cv_lib_stdcpp___cxa_demangle" = "xyes")
 383 AS_IF([test "x$ac_cv_lib_stdcpp___cxa_demangle" = "xyes"],
 384       [enable_demangler=yes],[enable_demangler=no])
 385
 386 AC_ARG_ENABLE([textrelcheck],
 387 AS_HELP_STRING([--disable-textrelcheck],
 388                [Disable textrelcheck being a fatal error]))
 389 AM_CONDITIONAL(FATAL_TEXTREL, [test "x$enable_textrelcheck" != "xno"])
 390 AS_IF([test "x$enable_textrelcheck" != "xno"],
 391       [enable_textrelcheck=yes],[enable_textrelcheck=no])
 392
 393 AC_ARG_ENABLE([symbol-versioning],
 394 AS_HELP_STRING([--disable-symbol-versioning],
 395                [Disable symbol versioning in shared objects]))
 396
 397 AC_CACHE_CHECK([whether symbol versioning is supported], ac_cv_symbol_versioning, [dnl
 398 AC_COMPILE_IFELSE([AC_LANG_SOURCE([dnl
 399 #define NEW_VERSION(name, version) \
 400   asm (".symver " #name "," #name "@@@" #version);
 401 int foo(int x) { return x + 1; }
 402 NEW_VERSION (foo, ELFUTILS_12.12)
 403 ])], ac_cv_symbol_versioning=yes, ac_cv_symbol_versioning=no)])
 404 if test "$ac_cv_symbol_versioning" = "no"; then
 405     if test "x$enable_symbol_versioning" != "xno"; then
 406         AC_MSG_ERROR([Symbol versioning is not supported.
 407                       Use --disable-symbol-versioning to build without.])
 408     fi
 409 fi
 410
 411 AM_CONDITIONAL(SYMBOL_VERSIONING, [test "x$enable_symbol_versioning" != "xno"])
 412 AS_IF([test "x$enable_symbol_versioning" = "xno"],
 413       [AC_MSG_WARN([Disabling symbol versioning breaks ABI compatibility.])
 414        enable_symbol_versioning=no],[enable_symbol_versioning=yes])
 415
 416 AC_CACHE_CHECK([whether gcc accepts -Wstack-usage], ac_cv_stack_usage, [dnl
 417 old_CFLAGS="$CFLAGS"
 418 CFLAGS="$CFLAGS -Wstack-usage=262144 -Werror"
 419 AC_COMPILE_IFELSE([AC_LANG_SOURCE([])],
 420                   ac_cv_stack_usage=yes, ac_cv_stack_usage=no)
 421 CFLAGS="$old_CFLAGS"])
 422 AM_CONDITIONAL(ADD_STACK_USAGE_WARNING, [test "x$ac_cv_stack_usage" != "xno"])
 423
 424 # -Wlogical-op was too fragile in the past, make sure we get a sane one.
 425 AC_CACHE_CHECK([whether gcc has a sane -Wlogical-op], ac_cv_logical_op, [dnl
 426 old_CFLAGS="$CFLAGS"
 427 CFLAGS="$CFLAGS -Wlogical-op -Werror"
 428 AC_COMPILE_IFELSE([AC_LANG_SOURCE(
 429         [#define FLAG 1
 430         int f (int r, int f) { return (r && (FLAG || (FLAG & f))); }])],
 431                   ac_cv_logical_op=yes, ac_cv_logical_op=no)
 432 CFLAGS="$old_CFLAGS"])
 433 AM_CONDITIONAL(SANE_LOGICAL_OP_WARNING,
 434                [test "x$ac_cv_logical_op" != "xno"])
 435
 436 # -Wduplicated-cond was added by GCC6
 437 AC_CACHE_CHECK([whether gcc accepts -Wduplicated-cond], ac_cv_duplicated_cond, [dnl
 438 old_CFLAGS="$CFLAGS"
 439 CFLAGS="$CFLAGS -Wduplicated-cond -Werror"
 440 AC_COMPILE_IFELSE([AC_LANG_SOURCE([])],
 441                   ac_cv_duplicated_cond=yes, ac_cv_duplicated_cond=no)
 442 CFLAGS="$old_CFLAGS"])
 443 AM_CONDITIONAL(HAVE_DUPLICATED_COND_WARNING,
 444                [test "x$ac_cv_duplicated_cond" != "xno"])
 445
 446 # -Wnull-dereference was added by GCC6
 447 AC_CACHE_CHECK([whether gcc accepts -Wnull-dereference], ac_cv_null_dereference, [dnl
 448 old_CFLAGS="$CFLAGS"
 449 CFLAGS="$CFLAGS -Wnull-dereference -Werror"
 450 AC_COMPILE_IFELSE([AC_LANG_SOURCE([])],
 451                   ac_cv_null_dereference=yes, ac_cv_null_dereference=no)
 452 CFLAGS="$old_CFLAGS"])
 453 AM_CONDITIONAL(HAVE_NULL_DEREFERENCE_WARNING,
 454                [test "x$ac_cv_null_dereference" != "xno"])
 455
 456 # -Wimplicit-fallthrough was added by GCC7
 457 AC_CACHE_CHECK([whether gcc accepts -Wimplicit-fallthrough], ac_cv_implicit_fallthrough, [dnl
 458 old_CFLAGS="$CFLAGS"
 459 CFLAGS="$CFLAGS -Wimplicit-fallthrough -Werror"
 460 AC_COMPILE_IFELSE([AC_LANG_SOURCE([])],
 461                   ac_cv_implicit_fallthrough=yes, ac_cv_implicit_fallthrough=no)
 462 CFLAGS="$old_CFLAGS"])
 463 AM_CONDITIONAL(HAVE_IMPLICIT_FALLTHROUGH_WARNING,
 464                [test "x$ac_cv_implicit_fallthrough" != "xno"])
 465
 466 # Assume the fallthrough attribute is supported if -Wimplict-fallthrough is supported
 467 if test "$ac_cv_implicit_fallthrough" = "yes"; then
 468         AC_DEFINE([HAVE_FALLTHROUGH], [1],
 469                   [Defined if __attribute__((fallthrough)) is supported])
 470 fi
 471
 472 dnl Check if we have argp available from our libc
 473 AC_LINK_IFELSE(
 474         [AC_LANG_PROGRAM(
 475                 [#include <argp.h>],
 476                 [int argc=1; char *argv[]={"test"}; argp_parse(0,argc,&argv,0,0,0); return 0;]
 477                 )],
 478         [libc_has_argp="true"],
 479         [libc_has_argp="false"]
 480 )
 481
 482 dnl If our libc doesn't provide argp, then test for libargp
 483 if test "$libc_has_argp" = "false" ; then
 484         AC_MSG_WARN("libc does not have argp")
 485         AC_CHECK_LIB([argp], [argp_parse], [have_argp="true"], [have_argp="false"])
 486
 487         if test "$have_argp" = "false"; then
 488                 AC_MSG_ERROR("no libargp found")
 489         else
 490                 argp_LDADD="-largp"
 491         fi
 492 else
 493         argp_LDADD=""
 494 fi
 495 AC_SUBST([argp_LDADD])
 496
 497 dnl The directories with content.
 498
 499 dnl Documentation.
 500 dnl Commented out for now.
 501 dnl AC_CONFIG_FILES([doc/Makefile])
 502
 503 dnl Support library.
 504 AC_CONFIG_FILES([lib/Makefile])
 505
 506 dnl ELF library.
 507 AC_CONFIG_FILES([libelf/Makefile])
 508
 509 dnl Higher-level ELF support library.
 510 AC_CONFIG_FILES([libebl/Makefile])
 511
 512 dnl DWARF-ELF Lower-level Functions support library.
 513 AC_CONFIG_FILES([libdwelf/Makefile])
 514
 515 dnl DWARF library.
 516 AC_CONFIG_FILES([libdw/Makefile])
 517
 518 dnl Higher-level DWARF support library.
 519 AC_CONFIG_FILES([libdwfl/Makefile])
 520
 521 dnl CPU handling library.
 522 AC_CONFIG_FILES([libcpu/Makefile])
 523
 524 dnl Assembler library.
 525 AM_CONDITIONAL(HAVE_LIBASM, true)dnl Used in tests/Makefile.am, which see.
 526 AC_CONFIG_FILES([libasm/Makefile])
 527
 528 dnl CPU-specific backend libraries.
 529 AC_CONFIG_FILES([backends/Makefile])
 530
 531 dnl Tools.
 532 AC_CONFIG_FILES([src/Makefile po/Makefile.in])
 533
 534 dnl Test suite.
 535 AM_CONDITIONAL(STANDALONE, false)dnl Used in tests/Makefile.am, which see.
 536 AC_CONFIG_FILES([tests/Makefile])
 537
 538 dnl pkgconfig files
 539 AC_CONFIG_FILES([config/libelf.pc config/libdw.pc])
 540
 541 # Get the definitions necessary to create the Makefiles in the po
 542 # subdirectories.  This is a small subset of the gettext rules.
 543 AC_SUBST(USE_NLS, yes)
 544 AM_PO_SUBDIRS
 545
 546 dnl Appended to the config.h file.
 547 dnl We hide all kinds of configuration magic in lib/eu-config.h.
 548 AH_BOTTOM([#include <eu-config.h>])
 549
 550 dnl Version compatibility header.
 551 AC_CONFIG_FILES([version.h:config/version.h.in])
 552 AC_SUBST([eu_version])
 553
 554 # 1.234<whatever> -> 1234<whatever>
 555 case "$PACKAGE_VERSION" in
 556 [[0-9]].*) eu_version=`echo "$PACKAGE_VERSION" | sed 's@\.@@'` ;;
 557 *)         AC_MSG_ERROR([confused by version number '$PACKAGE_VERSION']) ;;
 558 esac
 559 case "$eu_version" in
 560 *.*)
 561   # 1234.567 -> "1234", "567"
 562   eu_extra_version="${eu_version#*.}"
 563   eu_version="${eu_version%%.*}"
 564   case "$eu_extra_version" in
 565   [[0-9]][[0-9]][[0-9]]) ;;
 566   [[0-9]][[0-9]])       eu_extra_version="${eu_extra_version}0" ;;
 567   [[0-9]])              eu_extra_version="${eu_extra_version}00" ;;
 568   *) AC_MSG_ERROR([confused by version number '$PACKAGE_VERSION']) ;;
 569   esac
 570   ;;
 571 *)
 572   eu_extra_version=000
 573   ;;
 574 esac
 575
 576 case "$eu_version" in
 577       0[[0-9]][[0-9]][[0-9]]) eu_version="${eu_version#0}$eu_extra_version" ;;
 578 [[0-9]][[0-9]][[0-9]][[0-9]]) eu_version="${eu_version}$eu_extra_version" ;;
 579 [[0-9]][[0-9]][[0-9]])        eu_version="${eu_version}0$eu_extra_version" ;;
 580 [[0-9]][[0-9]])               eu_version="${eu_version}00$eu_extra_version";;
 581 *) AC_MSG_ERROR([confused by version number '$PACKAGE_VERSION']) ;;
 582 esac
 583
 584 # Round up to the next release API (x.y) version.
 585 eu_version=$(( (eu_version + 999) / 1000 ))
 586
 587 dnl Unique ID for this build.
 588 MODVERSION="Build for ${LIBEBL_SUBDIR} ${eu_version} ${ac_cv_build}"
 589 AC_SUBST([MODVERSION])
 590 AC_DEFINE_UNQUOTED(MODVERSION, "$MODVERSION")
 591 AH_TEMPLATE([MODVERSION], [Identifier for modules in the build.])
 592
 593 AC_CHECK_SIZEOF(long)
 594
 595 # On aarch64 before glibc 2.20 we would get the kernel user_pt_regs instead
 596 # of the user_regs_struct from sys/user.h. They are structurally the same
 597 # but we get either one or the other.
 598 AC_CHECK_TYPE([struct user_regs_struct],
 599               [sys_user_has_user_regs=yes], [sys_user_has_user_regs=no],
 600               [[#include <sys/ptrace.h>]
 601                [#include <sys/time.h>]
 602                [#include <sys/user.h>]])
 603 if test "$sys_user_has_user_regs" = "yes"; then
 604   AC_DEFINE(HAVE_SYS_USER_REGS, 1,
 605             [Define to 1 if <sys/user.h> defines struct user_regs_struct])
 606 fi
 607
 608 # On a 64-bit host where can can use $CC -m32, we'll run two sets of tests.
 609 # Likewise in a 32-bit build on a host where $CC -m64 works.
 610 utrace_BIARCH
 611 # `$utrace_biarch' will be `-m64' even on an uniarch i386 machine.
 612 CC_BIARCH="$CC $utrace_biarch"
 613 AC_SUBST([CC_BIARCH])
 614
 615 # In maintainer mode we really need flex and bison.
 616 # Otherwise we really need a release dir with maintainer files generated.
 617 if test "x$enable_maintainer_mode" = xyes; then
 618   AC_CHECK_PROG(HAVE_FLEX, flex, yes, no)
 619   if test "$HAVE_FLEX" = "no"; then
 620     AC_MSG_ERROR([flex needed in maintainer mode])
 621   fi
 622   AC_CHECK_PROG(HAVE_BISON, bison, yes, no)
 623   if test "$HAVE_BISON" = "no"; then
 624     AC_MSG_ERROR([bison needed in maintainer mode])
 625   fi
 626   AC_CHECK_PROG(HAVE_GAWK, gawk, yes, no)
 627   if test "$HAVE_GAWK" = "no"; then
 628     AC_MSG_ERROR([gawk needed in maintainer mode])
 629   fi
 630 else
 631   if test ! -f ${srcdir}/libdw/known-dwarf.h; then
 632     AC_MSG_ERROR([No libdw/known-dwarf.h. configure --enable-maintainer-mode])
 633   fi
 634 fi
 635
 636 # The testfiles are all compressed, we need bunzip2 when running make check
 637 AC_CHECK_PROG(HAVE_BUNZIP2, bunzip2, yes, no)
 638 if test "$HAVE_BUNZIP2" = "no"; then
 639   AC_MSG_WARN([No bunzip2, needed to run make check])
 640 fi
 641
 642 AC_OUTPUT
 643
 644 AC_MSG_NOTICE([
 645 =====================================================================
 646         elfutils: ${PACKAGE_VERSION} (eu_version: ${eu_version})
 647 =====================================================================
 648
 649     Prefix                             : ${prefix}
 650     Program prefix ("eu-" recommended) : ${program_prefix}
 651     Source code location               : ${srcdir}
 652     Maintainer mode                    : ${enable_maintainer_mode}
 653     libebl modules subdirectory        : ${LIBEBL_SUBDIR}
 654     build arch                         : ${ac_cv_build}
 655
 656   RECOMMENDED FEATURES (should all be yes)
 657     gzip support                       : ${with_zlib}
 658     bzip2 support                      : ${with_bzlib}
 659     lzma/xz support                    : ${with_lzma}
 660     libstdc++ demangle support         : ${enable_demangler}
 661     File textrel check                 : ${enable_textrelcheck}
 662     Symbol versioning                  : ${enable_symbol_versioning}
 663
 664   NOT RECOMMENDED FEATURES (should all be no)
 665     Experimental thread safety         : ${use_locks}
 666     install elf.h                      : ${install_elfh}
 667
 668   OTHER FEATURES
 669     Deterministic archives by default  : ${default_ar_deterministic}
 670     Native language support            : ${USE_NLS}
 671
 672   EXTRA TEST FEATURES (used with make check)
 673     have bunzip2 installed (required)  : ${HAVE_BUNZIP2}
 674     debug branch prediction            : ${use_debugpred}
 675     gprof support                      : ${use_gprof}
 676     gcov support                       : ${use_gcov}
 677     run all tests under valgrind       : ${use_valgrind}
 678     gcc undefined behaviour sanitizer  : ${use_undefined}
 679     use rpath in tests                 : ${tests_use_rpath}
 680     test biarch                        : ${utrace_cv_cc_biarch}
 681 ])
 682
 683 if test "$install_elfh" = yes; then
 684   if test "${prefix}" = "/usr/local" -o "${prefix}" = "/usr"; then
 685     AC_MSG_WARN([installing elf.h in ${includedir} might conflict with glibc/system elf.h])
 686   fi
 687 fi