• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 Copyright (C) 2022 Mark J. Wielaard <mark@klomp.org>
6dnl
7dnl This file is part of elfutils.
8dnl
9dnl  This file is free software; you can redistribute it and/or modify
10dnl  it under the terms of the GNU General Public License as published by
11dnl  the Free Software Foundation; either version 3 of the License, or
12dnl  (at your option) any later version.
13dnl
14dnl  elfutils is distributed in the hope that it will be useful, but
15dnl  WITHOUT ANY WARRANTY; without even the implied warranty of
16dnl  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17dnl  GNU General Public License for more details.
18dnl
19dnl  You should have received a copy of the GNU General Public License
20dnl  along with this program.  If not, see <http://www.gnu.org/licenses/>.
21AC_INIT([elfutils],[0.188],[https://sourceware.org/bugzilla],[elfutils],[http://elfutils.org/])
22
23dnl Workaround for older autoconf < 2.64
24m4_ifndef([AC_PACKAGE_URL],
25         [AC_DEFINE([PACKAGE_URL], ["http://elfutils.org/"],
26                    [Define to home page for this package])
27          AC_SUBST([PACKAGE_URL], ["http://elfutils.org/"])])
28
29LIBDEBUGINFOD_SONAME=libdebuginfod.so.1
30AC_SUBST([LIBDEBUGINFOD_SONAME])
31
32# We want eu- as default program prefix if none was given by the user.
33# But if the user explicitly provided --program-prefix="" then pretend
34# it wasn't set at all (NONE). We want to test this really early before
35# configure has a chance to use the value.
36
37if test "x$program_prefix" = "xNONE"; then
38  AC_MSG_NOTICE([No --program-prefix given, using "eu-"])
39  program_prefix="eu-"
40elif test "x$program_prefix" = "x"; then
41  AC_MSG_NOTICE([Using no program-prefix])
42  program_prefix=NONE
43fi
44
45AC_CONFIG_AUX_DIR([config])
46AC_CONFIG_FILES([config/Makefile])
47
48AC_COPYRIGHT([Copyright (C) 1996-2022 The elfutils developers.])
49AC_PREREQ(2.63)			dnl Minimum Autoconf version required.
50
51dnl We use GNU make extensions; automake 1.10 defaults to -Wportability.
52AM_INIT_AUTOMAKE([gnits 1.11 -Wno-portability dist-bzip2 no-dist-gzip parallel-tests])
53AM_MAINTAINER_MODE
54
55AM_SILENT_RULES([yes])
56
57AC_CONFIG_SRCDIR([libelf/libelf.h])
58AC_CONFIG_FILES([Makefile])
59AC_CONFIG_HEADERS([config.h])
60
61dnl The RPM spec file.  We substitute a few values in the file.
62AC_CONFIG_FILES([elfutils.spec:config/elfutils.spec.in])
63
64dnl debuginfo-server client & server parts.
65AC_CONFIG_FILES([debuginfod/Makefile debuginfod/debuginfod.h])
66
67AC_CANONICAL_HOST
68
69AC_ARG_ENABLE(deterministic-archives,
70[AS_HELP_STRING([--enable-deterministic-archives],
71		[ar and ranlib default to -D behavior])], [
72if test "${enableval}" = no; then
73  default_ar_deterministic=false
74else
75  default_ar_deterministic=true
76fi], [default_ar_deterministic=false])
77AC_DEFINE_UNQUOTED(DEFAULT_AR_DETERMINISTIC, $default_ar_deterministic,
78		   [Should ar and ranlib use -D behavior by default?])
79
80AC_ARG_ENABLE([thread-safety],
81AS_HELP_STRING([--enable-thread-safety],
82               [enable thread safety of libraries EXPERIMENTAL]),
83               use_locks=$enableval, use_locks=no)
84AM_CONDITIONAL(USE_LOCKS, test "$use_locks" = yes)
85AS_IF([test "$use_locks" = yes], [AC_DEFINE(USE_LOCKS)])
86AS_IF([test "$use_locks" = yes],
87      [AC_MSG_WARN([thread-safety is EXPERIMENTAL tests might fail.])])
88
89AH_TEMPLATE([USE_LOCKS], [Defined if libraries should be thread-safe.])
90
91m4_version_prereq([2.70], [AC_PROG_CC], [AC_PROG_CC_C99])
92AC_PROG_CXX
93AC_PROG_RANLIB
94AC_PROG_YACC
95AC_PROG_LEX([noyywrap])
96# Only available since automake 1.12
97m4_ifdef([AM_PROG_AR], [AM_PROG_AR])
98AC_CHECK_TOOL([READELF], [readelf])
99AC_CHECK_TOOL([NM], [nm])
100
101AC_CACHE_CHECK([whether gcc supports __attribute__((visibility()))],
102	ac_cv_visibility, [dnl
103save_CFLAGS="$CFLAGS"
104CFLAGS="$save_CFLAGS -Werror"
105AC_COMPILE_IFELSE([AC_LANG_SOURCE([dnl
106int __attribute__((visibility("hidden")))
107foo (int a)
108{
109  return a;
110}])], ac_cv_visibility=yes, ac_cv_visibility=no)
111CFLAGS="$save_CFLAGS"])
112if test "$ac_cv_visibility" = "yes"; then
113	AC_DEFINE([HAVE_VISIBILITY], [1],
114		  [Defined if __attribute__((visibility())) is supported])
115fi
116
117AC_CACHE_CHECK([whether gcc supports __attribute__((gcc_struct))],
118	ac_cv_gcc_struct, [dnl
119save_CFLAGS="$CFLAGS"
120CFLAGS="$save_CFLAGS -Werror"
121AC_COMPILE_IFELSE([AC_LANG_SOURCE([dnl
122struct test { int x; } __attribute__((gcc_struct));
123])], ac_cv_gcc_struct=yes, ac_cv_gcc_struct=no)
124CFLAGS="$save_CFLAGS"])
125if test "$ac_cv_gcc_struct" = "yes"; then
126	AC_DEFINE([HAVE_GCC_STRUCT], [1],
127		  [Defined if __attribute__((gcc_struct)) is supported])
128fi
129
130AC_CACHE_CHECK([whether gcc supports -fPIC], ac_cv_fpic, [dnl
131save_CFLAGS="$CFLAGS"
132CFLAGS="$save_CFLAGS -fPIC -Werror"
133AC_COMPILE_IFELSE([AC_LANG_SOURCE()], ac_cv_fpic=yes, ac_cv_fpic=no)
134CFLAGS="$save_CFLAGS"
135])
136if test "$ac_cv_fpic" = "yes"; then
137	fpic_CFLAGS="-fPIC"
138else
139	fpic_CFLAGS=""
140fi
141AC_SUBST([fpic_CFLAGS])
142
143AC_CACHE_CHECK([whether gcc supports -fPIE], ac_cv_fpie, [dnl
144save_CFLAGS="$CFLAGS"
145CFLAGS="$save_CFLAGS -fPIE -Werror"
146AC_COMPILE_IFELSE([AC_LANG_SOURCE()], ac_cv_fpie=yes, ac_cv_fpie=no)
147CFLAGS="$save_CFLAGS"
148])
149if test "$ac_cv_fpie" = "yes"; then
150	fpie_CFLAGS="-fPIE"
151else
152	fpie_CFLAGS=""
153fi
154AC_SUBST([fpie_CFLAGS])
155
156dso_LDFLAGS="-shared"
157
158ZDEFS_LDFLAGS="-Wl,-z,defs"
159AC_CACHE_CHECK([whether gcc supports $ZDEFS_LDFLAGS], ac_cv_zdefs, [dnl
160save_LDFLAGS="$LDFLAGS"
161LDFLAGS="$ZDEFS_LDFLAGS $save_LDFLAGS"
162AC_LINK_IFELSE([AC_LANG_PROGRAM()], ac_cv_zdefs=yes, ac_cv_zdefs=no)
163LDFLAGS="$save_LDFLAGS"
164])
165if test "$ac_cv_zdefs" = "yes"; then
166	dso_LDFLAGS="$dso_LDFLAGS $ZDEFS_LDFLAGS"
167fi
168
169# We really want build-ids. Warn and force generating them if gcc was
170# configure without --enable-linker-build-id
171AC_CACHE_CHECK([whether the compiler generates build-ids], ac_cv_buildid, [dnl
172AC_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]))])
173if test "$ac_cv_buildid" = "no"; then
174	AC_MSG_WARN([compiler doesn't generate build-id by default])
175	LDFLAGS="$LDFLAGS -Wl,--build-id"
176fi
177
178ZRELRO_LDFLAGS="-Wl,-z,relro"
179AC_CACHE_CHECK([whether gcc supports $ZRELRO_LDFLAGS], ac_cv_zrelro, [dnl
180save_LDFLAGS="$LDFLAGS"
181LDFLAGS="$ZRELRO_LDFLAGS $save_LDFLAGS"
182AC_LINK_IFELSE([AC_LANG_PROGRAM()], ac_cv_zrelro=yes, ac_cv_zrelro=no)
183LDFLAGS="$save_LDFLAGS"
184])
185if test "$ac_cv_zrelro" = "yes"; then
186	dso_LDFLAGS="$dso_LDFLAGS $ZRELRO_LDFLAGS"
187fi
188
189AC_SUBST([dso_LDFLAGS])
190
191AC_CACHE_CHECK([for __thread support], ac_cv_tls, [dnl
192# Use the same flags that we use for our DSOs, so the test is representative.
193# Some old compiler/linker/libc combinations fail some ways and not others.
194save_CFLAGS="$CFLAGS"
195save_LDFLAGS="$LDFLAGS"
196CFLAGS="$fpic_CFLAGS $CFLAGS"
197LDFLAGS="$dso_LDFLAGS $LDFLAGS"
198AC_LINK_IFELSE([dnl
199AC_LANG_PROGRAM([[#include <stdlib.h>
200#undef __thread
201static __thread int a; int foo (int b) { return a + b; }]],
202		[[exit (foo (0));]])],
203	       ac_cv_tls=yes, ac_cv_tls=no)
204CFLAGS="$save_CFLAGS"
205LDFLAGS="$save_LDFLAGS"])
206AS_IF([test "x$ac_cv_tls" != xyes],
207      AC_MSG_ERROR([__thread support required]))
208
209dnl Before 4.9 gcc doesn't ship stdatomic.h, but the necessary atomics are
210dnl available by (at least) 4.7. So if the system doesn't have a stdatomic.h we
211dnl fall back on one copied from FreeBSD that handles the difference.
212AC_CACHE_CHECK([whether gcc provides stdatomic.h], ac_cv_has_stdatomic,
213  [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[#include <stdatomic.h>]])],
214		     ac_cv_has_stdatomic=yes, ac_cv_has_stdatomic=no)])
215AM_CONDITIONAL(HAVE_STDATOMIC_H, test "x$ac_cv_has_stdatomic" = xyes)
216AS_IF([test "x$ac_cv_has_stdatomic" = xyes], [AC_DEFINE(HAVE_STDATOMIC_H)])
217
218AH_TEMPLATE([HAVE_STDATOMIC_H], [Define to 1 if `stdatomic.h` is provided by the
219                                 system, 0 otherwise.])
220
221dnl This test must come as early as possible after the compiler configuration
222dnl tests, because the choice of the file model can (in principle) affect
223dnl whether functions and headers are available, whether they work, etc.
224AC_SYS_LARGEFILE
225
226dnl Older glibc had a broken fts that didn't work with Large File Systems.
227dnl We want the version that can handler LFS, but include workaround if we
228dnl get a bad one. Add define to CFLAGS (not AC_DEFINE it) since we need to
229dnl check it before including config.h (which might define _FILE_OFFSET_BITS).
230AC_CACHE_CHECK([whether fts.h is bad when included (with LFS)], ac_cv_bad_fts,
231  [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[#include <fts.h>]])],
232		     ac_cv_bad_fts=no, ac_cv_bad_fts=yes)])
233AS_IF([test "x$ac_cv_bad_fts" = "xyes"],
234      [CFLAGS="$CFLAGS -DBAD_FTS=1" CXXFLAGS="$CXXFLAGS -DBAD_FTS=1"])
235
236# See if we can add -D_FORTIFY_SOURCE=2 or =3. Don't do it if it is already
237# (differently) defined or if it generates warnings/errors because we
238# don't use the right optimisation level (string.h will warn about that).
239AC_MSG_CHECKING([whether to add -D_FORTIFY_SOURCE=2 or =3 to CFLAGS])
240case "$CFLAGS" in
241  *-D_FORTIFY_SOURCE=*)
242    AC_MSG_RESULT([no, already there])
243    ;;
244  *)
245    save_CFLAGS="$CFLAGS"
246    # Try 3 first.
247    CFLAGS="-D_FORTIFY_SOURCE=3 $save_CFLAGS -Werror"
248    fortified_cflags=""
249    AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
250      #include <string.h>
251      int main() { return 0; }
252    ]])], [ AC_MSG_RESULT([yes -D_FORTIFY_SOURCE=3])
253            fortified_cflags="-D_FORTIFY_SOURCE=3" ], [])
254
255    # If that didn't work, try 2.
256    if test -z "$fortified_cflags"; then
257      CFLAGS="-D_FORTIFY_SOURCE=2 $save_CFLAGS -Werror"
258      AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
259        #include <string.h>
260        int main() { return 0; }
261      ]])], [ AC_MSG_RESULT([yes -D_FORTIFY_SOURCE=2])
262              fortified_cflags="-D_FORTIFY_SOURCE=2" ],
263              [ AC_MSG_RESULT([no, cannot be used])])
264    fi
265    CFLAGS="$fortified_cflags $save_CFLAGS"
266    CXXFLAGS="$fortified_cflags $CXXFLAGS"
267    ;;
268esac
269
270dnl enable debugging of branch prediction.
271AC_ARG_ENABLE([debugpred],
272AS_HELP_STRING([--enable-debugpred],[build binaries with support to debug branch prediction]),
273[use_debugpred=$enableval], [use_debugpred=no])
274case $use_debugpred in
275 yes) use_debugpred_val=1 ;;
276 *)   use_debugpred_val=0 ;;
277esac
278AC_SUBST([DEBUGPRED], $use_debugpred_val)
279
280dnl Enable gprof support.
281AC_ARG_ENABLE([gprof],
282AS_HELP_STRING([--enable-gprof],[build binaries with gprof support]), [use_gprof=$enableval], [use_gprof=no])
283if test "$use_gprof" = yes; then
284  CFLAGS="$CFLAGS -pg"
285  LDFLAGS="$LDFLAGS -pg"
286fi
287AM_CONDITIONAL(GPROF, test "$use_gprof" = yes)
288
289# Enable gcov support.
290AC_ARG_ENABLE([gcov],
291AS_HELP_STRING([--enable-gcov],[build binaries with gcov support]), [use_gcov=$enableval], [use_gcov=no])
292if test "$use_gcov" = yes; then
293  CFLAGS="$CFLAGS -fprofile-arcs -ftest-coverage"
294  CXXFLAGS="$CXXFLAGS -fprofile-arcs -ftest-coverage"
295  LDFLAGS="$LDFLAGS -fprofile-arcs"
296  AC_CHECK_PROG([GCOV], [gcov], [gcov])
297  AC_CHECK_PROG([LCOV], [lcov], [lcov])
298  AC_CHECK_PROG([GENHTML], [genhtml], [genhtml])
299fi
300AM_CONDITIONAL(GCOV, test "$use_gcov" = yes)
301
302AC_ARG_ENABLE([sanitize-undefined],
303              AS_HELP_STRING([--enable-sanitize-undefined],
304                             [Use gcc undefined behaviour sanitizer]),
305                             [use_undefined=$enableval], [use_undefined=no])
306if test "$use_undefined" = yes; then
307  old_CFLAGS="$CFLAGS"
308  old_CXXFLAGS="$CXXFLAGS"
309  # We explicitly use unaligned access when possible (see ALLOW_UNALIGNED)
310  # We want to fail immediately on first error, don't try to recover.
311  CFLAGS="$CFLAGS -fsanitize=undefined -fno-sanitize-recover"
312  CXXFLAGS="$CXXFLAGS -fsanitize=undefined -fno-sanitize-recover"
313  AC_LINK_IFELSE([AC_LANG_SOURCE([int main (int argc, char **argv) { return 0; }])], use_undefined=yes, use_undefined=no)
314  AS_IF([test "x$use_undefined" != xyes],
315        AC_MSG_WARN([gcc undefined behaviour sanitizer not available])
316        CFLAGS="$old_CFLAGS" CXXFLAGS="$old_CXXFLAGS")
317fi
318case $use_undefined in
319 yes) check_undefined_val=1 ;;
320 *)   check_undefined_val=0 ;;
321esac
322AC_DEFINE_UNQUOTED(CHECK_UNDEFINED, $check_undefined_val,
323		   [Building with -fsanitize=undefined or not])
324
325AC_ARG_ENABLE([sanitize-address],
326              AS_HELP_STRING([--enable-sanitize-address],
327                             [Use gcc address sanitizer]),
328                             [use_address=$enableval], [use_address=no])
329if test "$use_address" = yes; then
330  old_CFLAGS="$CFLAGS"
331  old_CXXFLAGS="$CXXFLAGS"
332  old_LDFLAGS="$LDFLAGS"
333  # We want to fail immediately on first error, don't try to recover.
334  CFLAGS="$CFLAGS -fsanitize=address -fno-sanitize-recover"
335  CXXFLAGS="$CXXFLAGS -fsanitize=address -fno-sanitize-recover"
336  # Some compilers don't handle -fsanatize=address correctly with --no-undefined
337  LDFLAGS="-Wl,-z,defs -shared"
338  AC_LINK_IFELSE([AC_LANG_SOURCE([int main (int argc, char **argv) { return 0; }])], use_address=yes, use_address=no)
339  AS_IF([test "x$use_address" != xyes],
340        AC_MSG_WARN([gcc address sanitizer not available])
341        CFLAGS="$old_CFLAGS" CXXFLAGS="$old_CXXFLAGS")
342  LDFLAGS="$old_LDFLAGS"
343fi
344AM_CONDITIONAL(USE_ADDRESS_SANITIZER, test "$use_address" = yes)
345
346AC_ARG_ENABLE([valgrind],
347AS_HELP_STRING([--enable-valgrind],[run all tests under valgrind]),
348[use_valgrind=$enableval], [use_valgrind=no])
349if test "$use_valgrind" = yes; then
350  if test "$use_address" = yes; then
351    AC_MSG_ERROR([cannot enable valgrind and sanitize address together])
352  fi
353  AC_CHECK_PROG(HAVE_VALGRIND, valgrind, yes, no)
354  if test "$HAVE_VALGRIND" = "no"; then
355    AC_MSG_ERROR([valgrind not found])
356  fi
357fi
358AM_CONDITIONAL(USE_VALGRIND, test "$use_valgrind" = yes)
359
360AC_ARG_WITH([valgrind],
361AS_HELP_STRING([--with-valgrind],[include directory for Valgrind headers]),
362[with_valgrind_headers=$withval], [with_valgrind_headers=no])
363if test "x$with_valgrind_headers" != xno; then
364    save_CFLAGS="$CFLAGS"
365    CFLAGS="$CFLAGS -I$with_valgrind_headers"
366    AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
367      #include <valgrind/valgrind.h>
368      int main() { return 0; }
369    ]])], [ HAVE_VALGRIND_HEADERS="yes"
370            CFLAGS="$save_CFLAGS -I$with_valgrind_headers" ],
371          [ AC_MSG_ERROR([invalid valgrind include directory: $with_valgrind_headers]) ])
372fi
373
374AC_ARG_ENABLE([valgrind-annotations],
375AS_HELP_STRING([--enable-valgrind-annotations],[insert extra annotations for better valgrind support]),
376[use_vg_annotations=$enableval], [use_vg_annotations=no])
377if test "$use_vg_annotations" = yes; then
378    if test "x$HAVE_VALGRIND_HEADERS" != "xyes"; then
379      AC_MSG_CHECKING([whether Valgrind headers are available])
380      AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
381        #include <valgrind/valgrind.h>
382        int main() { return 0; }
383      ]])], [ AC_MSG_RESULT([yes]) ],
384            [ AC_MSG_ERROR([valgrind annotations requested but no headers are available]) ])
385    fi
386fi
387AM_CONDITIONAL(USE_VG_ANNOTATIONS, test "$use_vg_annotations" = yes)
388
389AC_ARG_ENABLE([install-elfh],
390AS_HELP_STRING([--enable-install-elfh],[install elf.h in include dir]),
391               [install_elfh=$enableval], [install_elfh=no])
392AM_CONDITIONAL(INSTALL_ELFH, test "$install_elfh" = yes)
393
394AM_CONDITIONAL(BUILD_STATIC, [dnl
395test "$use_gprof" = yes -o "$use_gcov" = yes])
396
397AC_ARG_ENABLE([tests-rpath],
398AS_HELP_STRING([--enable-tests-rpath],[build $ORIGIN-using rpath into tests]),
399	       [tests_use_rpath=$enableval], [tests_use_rpath=no])
400AM_CONDITIONAL(TESTS_RPATH, test "$tests_use_rpath" = yes)
401
402dnl zlib is mandatory.
403save_LIBS="$LIBS"
404LIBS=
405eu_ZIPLIB(zlib,ZLIB,z,gzdirect,gzip)
406AS_IF([test "x$with_zlib" = xno], [AC_MSG_ERROR([zlib not found but is required])])
407LIBS="$save_LIBS"
408
409dnl Test for bzlib and xz/lzma/zstd, gives BZLIB/LZMALIB/ZSTD .am
410dnl conditional and config.h USE_BZLIB/USE_LZMALIB/USE_ZSTD #define.
411save_LIBS="$LIBS"
412LIBS=
413eu_ZIPLIB(bzlib,BZLIB,bz2,BZ2_bzdopen,bzip2)
414# We need this since bzip2 doesn't have a pkgconfig file.
415BZ2_LIB="$LIBS"
416AC_SUBST([BZ2_LIB])
417eu_ZIPLIB(lzma,LZMA,lzma,lzma_auto_decoder,[LZMA (xz)])
418AS_IF([test "x$with_lzma" = xyes], [LIBLZMA="liblzma"], [LIBLZMA=""])
419AC_SUBST([LIBLZMA])
420eu_ZIPLIB(zstd,ZSTD,zstd,ZSTD_decompress,[ZSTD (zst)])
421AS_IF([test "x$with_zstd" = xyes], [LIBZSTD="libzstd"], [LIBLZSTD=""])
422AC_SUBST([LIBZSTD])
423zip_LIBS="$LIBS"
424LIBS="$save_LIBS"
425AC_SUBST([zip_LIBS])
426
427AC_CHECK_DECLS([memrchr, rawmemchr],[],[],
428               [#define _GNU_SOURCE
429                #include <string.h>])
430AC_CHECK_DECLS([powerof2],[],[],[#include <sys/param.h>])
431AC_CHECK_DECLS([mempcpy],[],[],
432               [#define _GNU_SOURCE
433                #include <string.h>])
434AC_CHECK_DECLS([reallocarray],[],[],
435               [#define _GNU_SOURCE
436                #include <stdlib.h>])
437
438AC_CHECK_FUNCS([process_vm_readv mremap])
439
440AS_IF([test "x$ac_cv_func_mremap" = "xno"],
441      [AC_MSG_WARN([elf_update needs mremap to support ELF_C_RDWR_MMAP])])
442
443AC_CHECK_HEADERS([error.h])
444AC_CHECK_HEADERS([err.h])
445
446old_CFLAGS="$CFLAGS"
447CFLAGS="$CFLAGS -D_GNU_SOURCE"
448AC_FUNC_STRERROR_R()
449CFLAGS="$old_CFLAGS"
450
451AC_CHECK_LIB([stdc++], [__cxa_demangle], [dnl
452AC_DEFINE([USE_DEMANGLE], [1], [Defined if demangling is enabled])])
453AM_CONDITIONAL(DEMANGLE, test "x$ac_cv_lib_stdcpp___cxa_demangle" = "xyes")
454AS_IF([test "x$ac_cv_lib_stdcpp___cxa_demangle" = "xyes"],
455      [enable_demangler=yes],[enable_demangler=no])
456
457AC_ARG_ENABLE([textrelcheck],
458AS_HELP_STRING([--disable-textrelcheck],
459               [Disable textrelcheck being a fatal error]))
460AM_CONDITIONAL(FATAL_TEXTREL, [test "x$enable_textrelcheck" != "xno"])
461AS_IF([test "x$enable_textrelcheck" != "xno"],
462      [enable_textrelcheck=yes],[enable_textrelcheck=no])
463
464AC_ARG_ENABLE([symbol-versioning],
465AS_HELP_STRING([--disable-symbol-versioning],
466               [Disable symbol versioning in shared objects]))
467
468AC_CACHE_CHECK([whether symbol versioning is supported], ac_cv_symbol_versioning, [dnl
469AC_COMPILE_IFELSE([AC_LANG_SOURCE([dnl
470#define NEW_VERSION(name, version) \
471  asm (".symver " #name "," #name "@@@" #version);
472int foo(int x) { return x + 1; }
473NEW_VERSION (foo, ELFUTILS_12.12)
474])], ac_cv_symbol_versioning=yes, ac_cv_symbol_versioning=no)])
475if test "$ac_cv_symbol_versioning" = "no"; then
476    if test "x$enable_symbol_versioning" != "xno"; then
477        AC_MSG_ERROR([Symbol versioning is not supported.
478                      Use --disable-symbol-versioning to build without.])
479    fi
480fi
481
482AM_CONDITIONAL(SYMBOL_VERSIONING, [test "x$enable_symbol_versioning" != "xno"])
483AS_IF([test "x$enable_symbol_versioning" = "xno"],
484      [AC_MSG_WARN([Disabling symbol versioning breaks ABI compatibility.])
485       enable_symbol_versioning=no],[enable_symbol_versioning=yes])
486
487AC_CACHE_CHECK([whether gcc accepts -Wstack-usage], ac_cv_stack_usage, [dnl
488old_CFLAGS="$CFLAGS"
489CFLAGS="$CFLAGS -Wstack-usage=262144 -Werror"
490AC_COMPILE_IFELSE([AC_LANG_SOURCE([])],
491		  ac_cv_stack_usage=yes, ac_cv_stack_usage=no)
492CFLAGS="$old_CFLAGS"])
493AM_CONDITIONAL(ADD_STACK_USAGE_WARNING, [test "x$ac_cv_stack_usage" != "xno"])
494
495# -Wlogical-op was too fragile in the past, make sure we get a sane one.
496AC_CACHE_CHECK([whether gcc has a sane -Wlogical-op], ac_cv_logical_op, [dnl
497old_CFLAGS="$CFLAGS"
498CFLAGS="$CFLAGS -Wlogical-op -Werror"
499AC_COMPILE_IFELSE([AC_LANG_SOURCE(
500	[#define FLAG 1
501	int f (int r, int f) { return (r && (FLAG || (FLAG & f))); }])],
502		  ac_cv_logical_op=yes, ac_cv_logical_op=no)
503CFLAGS="$old_CFLAGS"])
504AM_CONDITIONAL(SANE_LOGICAL_OP_WARNING,
505	       [test "x$ac_cv_logical_op" != "xno"])
506
507# -Wduplicated-cond was added by GCC6
508AC_CACHE_CHECK([whether gcc accepts -Wduplicated-cond], ac_cv_duplicated_cond, [dnl
509old_CFLAGS="$CFLAGS"
510CFLAGS="$CFLAGS -Wduplicated-cond -Werror"
511AC_COMPILE_IFELSE([AC_LANG_SOURCE([])],
512		  ac_cv_duplicated_cond=yes, ac_cv_duplicated_cond=no)
513CFLAGS="$old_CFLAGS"])
514AM_CONDITIONAL(HAVE_DUPLICATED_COND_WARNING,
515	       [test "x$ac_cv_duplicated_cond" != "xno"])
516
517# -Wnull-dereference was added by GCC6
518AC_CACHE_CHECK([whether gcc accepts -Wnull-dereference], ac_cv_null_dereference, [dnl
519old_CFLAGS="$CFLAGS"
520CFLAGS="$CFLAGS -Wnull-dereference -Werror"
521AC_COMPILE_IFELSE([AC_LANG_SOURCE([])],
522		  ac_cv_null_dereference=yes, ac_cv_null_dereference=no)
523CFLAGS="$old_CFLAGS"])
524AM_CONDITIONAL(HAVE_NULL_DEREFERENCE_WARNING,
525	       [test "x$ac_cv_null_dereference" != "xno"])
526
527# -Wimplicit-fallthrough was added by GCC7
528AC_CACHE_CHECK([whether gcc accepts -Wimplicit-fallthrough], ac_cv_implicit_fallthrough, [dnl
529old_CFLAGS="$CFLAGS"
530CFLAGS="$CFLAGS -Wimplicit-fallthrough -Werror"
531AC_COMPILE_IFELSE([AC_LANG_SOURCE([])],
532		  ac_cv_implicit_fallthrough=yes, ac_cv_implicit_fallthrough=no)
533CFLAGS="$old_CFLAGS"])
534AM_CONDITIONAL(HAVE_IMPLICIT_FALLTHROUGH_WARNING,
535	       [test "x$ac_cv_implicit_fallthrough" != "xno"])
536
537# Check whether the compiler additionally accepts -Wimplicit-fallthrough=5
538# GCC accepts this and 5 means "don't parse any fallthrough comments and
539# only accept the fallthrough attribute"
540AC_CACHE_CHECK([whether the compiler accepts -Wimplicit-fallthrough=5], ac_cv_implicit_fallthrough_5, [dnl
541old_CFLAGS="$CFLAGS"
542CFLAGS="$CFLAGS -Wimplicit-fallthrough=5 -Werror"
543AC_COMPILE_IFELSE([AC_LANG_SOURCE([])],
544		  ac_cv_implicit_fallthrough_5=yes, ac_cv_implicit_fallthrough_5=no)
545CFLAGS="$old_CFLAGS"])
546AM_CONDITIONAL(HAVE_IMPLICIT_FALLTHROUGH_5_WARNING,
547	       [test "x$ac_cv_implicit_fallthrough_5" != "xno"])
548
549# Assume the fallthrough attribute is supported if -Wimplict-fallthrough is supported
550if test "$ac_cv_implicit_fallthrough" = "yes"; then
551	AC_DEFINE([HAVE_FALLTHROUGH], [1],
552		  [Defined if __attribute__((fallthrough)) is supported])
553fi
554
555AC_CACHE_CHECK([whether the compiler accepts -Wtrampolines], ac_cv_trampolines, [dnl
556old_CFLAGS="$CFLAGS"
557CFLAGS="$CFLAGS -Wtrampolines -Werror"
558AC_COMPILE_IFELSE([AC_LANG_SOURCE([])],
559		  ac_cv_trampolines=yes, ac_cv_trampolines=no)
560CFLAGS="$old_CFLAGS"])
561AM_CONDITIONAL(HAVE_TRAMPOLINES_WARNING,
562	       [test "x$ac_cv_trampolines" != "xno"])
563
564AC_CACHE_CHECK([whether the compiler accepts -Wno-packed-not-aligned], ac_cv_no_packed_not_aligned, [dnl
565old_CFLAGS="$CFLAGS"
566CFLAGS="$CFLAGS -Wno-packed-not-aligned -Werror"
567AC_COMPILE_IFELSE([AC_LANG_SOURCE([])],
568		  ac_cv_no_packed_not_aligned=yes, ac_cv_no_packed_not_aligned=no)
569CFLAGS="$old_CFLAGS"])
570AM_CONDITIONAL(HAVE_NO_PACKED_NOT_ALIGNED_WARNING,
571	       [test "x$ac_cv_no_packed_not_aligned" != "xno"])
572
573saved_LIBS="$LIBS"
574AC_SEARCH_LIBS([argp_parse], [argp])
575LIBS="$saved_LIBS"
576case "$ac_cv_search_argp_parse" in
577        no) AC_MSG_FAILURE([failed to find argp_parse]) ;;
578        -l*) argp_LDADD="$ac_cv_search_argp_parse" ;;
579        *) argp_LDADD= ;;
580esac
581AC_SUBST([argp_LDADD])
582
583saved_LIBS="$LIBS"
584AC_SEARCH_LIBS([fts_close], [fts])
585LIBS="$saved_LIBS"
586case "$ac_cv_search_fts_close" in
587        no) AC_MSG_FAILURE([failed to find fts_close]) ;;
588        -l*) fts_LIBS="$ac_cv_search_fts_close" ;;
589        *) fts_LIBS= ;;
590esac
591AC_SUBST([fts_LIBS])
592
593saved_LIBS="$LIBS"
594AC_SEARCH_LIBS([_obstack_free], [obstack])
595LIBS="$saved_LIBS"
596case "$ac_cv_search__obstack_free" in
597        no) AC_MSG_FAILURE([failed to find _obstack_free]) ;;
598        -l*) obstack_LIBS="$ac_cv_search__obstack_free" ;;
599        *) obstack_LIBS= ;;
600esac
601AC_SUBST([obstack_LIBS])
602
603dnl The directories with content.
604
605dnl Documentation.
606AC_CONFIG_FILES([doc/Makefile])
607
608dnl Support library.
609AC_CONFIG_FILES([lib/Makefile])
610
611dnl ELF library.
612AC_CONFIG_FILES([libelf/Makefile])
613
614dnl Higher-level ELF support library.
615AC_CONFIG_FILES([libebl/Makefile])
616
617dnl DWARF-ELF Lower-level Functions support library.
618AC_CONFIG_FILES([libdwelf/Makefile])
619
620dnl DWARF library.
621AC_CONFIG_FILES([libdw/Makefile])
622
623dnl Higher-level DWARF support library.
624AC_CONFIG_FILES([libdwfl/Makefile])
625
626dnl CPU handling library.
627AC_CONFIG_FILES([libcpu/Makefile])
628
629dnl Assembler library.
630AC_CONFIG_FILES([libasm/Makefile])
631
632dnl CPU-specific backend libraries.
633AC_CONFIG_FILES([backends/Makefile])
634
635dnl Tools.
636AC_CONFIG_FILES([src/Makefile po/Makefile.in])
637
638dnl Test suite.
639AC_CONFIG_FILES([tests/Makefile])
640
641dnl pkgconfig files
642AC_CONFIG_FILES([config/libelf.pc config/libdw.pc config/libdebuginfod.pc])
643
644dnl As long as "git grep 'PRI[diouxX]' po" reports matches in
645dnl translatable strings, we must use need-formatstring-macros here.
646AM_GNU_GETTEXT([external], [need-formatstring-macros])
647
648dnl AM_GNU_GETTEXT_VERSION is still needed for old versions
649dnl of autoreconf that do not recognize AM_GNU_GETTEXT_REQUIRE_VERSION.
650dnl 0.19.6 is the first version of gettext that provides
651dnl AM_GNU_GETTEXT_REQUIRE_VERSION support.
652AM_GNU_GETTEXT_VERSION([0.19.6])
653AM_GNU_GETTEXT_REQUIRE_VERSION([0.19.6])
654
655dnl Appended to the config.h file.
656dnl We hide all kinds of configuration magic in lib/eu-config.h.
657AH_BOTTOM([#include <eu-config.h>])
658
659dnl Version compatibility header.
660AC_CONFIG_FILES([version.h:config/version.h.in])
661AC_SUBST([eu_version])
662
663# 1.234<whatever> -> 1234<whatever>
664case "$PACKAGE_VERSION" in
665[[0-9]].*) eu_version=`echo "$PACKAGE_VERSION" | sed 's@\.@@'` ;;
666*)     	   AC_MSG_ERROR([confused by version number '$PACKAGE_VERSION']) ;;
667esac
668case "$eu_version" in
669*.*)
670  # 1234.567 -> "1234", "567"
671  eu_extra_version="${eu_version#*.}"
672  eu_version="${eu_version%%.*}"
673  case "$eu_extra_version" in
674  [[0-9]][[0-9]][[0-9]]) ;;
675  [[0-9]][[0-9]])	eu_extra_version="${eu_extra_version}0" ;;
676  [[0-9]])	   	eu_extra_version="${eu_extra_version}00" ;;
677  *) AC_MSG_ERROR([confused by version number '$PACKAGE_VERSION']) ;;
678  esac
679  ;;
680*)
681  eu_extra_version=000
682  ;;
683esac
684
685case "$eu_version" in
686      0[[0-9]][[0-9]][[0-9]]) eu_version="${eu_version#0}$eu_extra_version" ;;
687[[0-9]][[0-9]][[0-9]][[0-9]]) eu_version="${eu_version}$eu_extra_version" ;;
688[[0-9]][[0-9]][[0-9]])	      eu_version="${eu_version}0$eu_extra_version" ;;
689[[0-9]][[0-9]])	  	      eu_version="${eu_version}00$eu_extra_version";;
690*) AC_MSG_ERROR([confused by version number '$PACKAGE_VERSION']) ;;
691esac
692
693# Round up to the next release API (x.y) version.
694eu_version=$(( (eu_version + 999) / 1000 ))
695
696AC_CHECK_SIZEOF(long)
697
698# On aarch64 before glibc 2.20 we would get the kernel user_pt_regs instead
699# of the user_regs_struct from sys/user.h. They are structurally the same
700# but we get either one or the other.
701AC_CHECK_TYPE([struct user_regs_struct],
702              [sys_user_has_user_regs=yes], [sys_user_has_user_regs=no],
703              [[#include <sys/ptrace.h>]
704               [#include <sys/time.h>]
705               [#include <sys/user.h>]])
706if test "$sys_user_has_user_regs" = "yes"; then
707  AC_DEFINE(HAVE_SYS_USER_REGS, 1,
708            [Define to 1 if <sys/user.h> defines struct user_regs_struct])
709fi
710
711# On a 64-bit host where can can use $CC -m32, we'll run two sets of tests.
712utrace_BIARCH
713CC_BIARCH="$CC $utrace_biarch"
714AC_SUBST([CC_BIARCH])
715
716# In maintainer mode we really need flex and bison.
717# Otherwise we really need a release dir with maintainer files generated.
718if test "x$enable_maintainer_mode" = xyes; then
719  AC_CHECK_PROG(HAVE_FLEX, flex, yes, no)
720  if test "$HAVE_FLEX" = "no"; then
721    AC_MSG_ERROR([flex needed in maintainer mode])
722  fi
723  AC_CHECK_PROG(HAVE_BISON, bison, yes, no)
724  if test "$HAVE_BISON" = "no"; then
725    AC_MSG_ERROR([bison needed in maintainer mode])
726  fi
727  AC_CHECK_PROG(HAVE_GAWK, gawk, yes, no)
728  if test "$HAVE_GAWK" = "no"; then
729    AC_MSG_ERROR([gawk needed in maintainer mode])
730  fi
731else
732  if test ! -f ${srcdir}/libdw/known-dwarf.h; then
733    AC_MSG_ERROR([No libdw/known-dwarf.h. configure --enable-maintainer-mode])
734  fi
735fi
736
737# The testfiles are all compressed, we need bunzip2 when running make check
738AC_CHECK_PROG(HAVE_BUNZIP2, bunzip2, yes, no)
739if test "$HAVE_BUNZIP2" = "no"; then
740  AC_MSG_WARN([No bunzip2, needed to run make check])
741fi
742
743# For tests that need to use zstd compression
744AC_CHECK_PROG(HAVE_ZSTD, zstd, yes, no)
745AM_CONDITIONAL([HAVE_ZSTD],[test "x$HAVE_ZSTD" = "xyes"])
746
747# Look for libcurl for libdebuginfod minimum version as per rhel7.
748AC_ARG_ENABLE([libdebuginfod],AS_HELP_STRING([--enable-libdebuginfod], [Build debuginfod client library (can be =dummy)]))
749AS_IF([test "x$enable_libdebuginfod" != "xno"], [
750    if test "x$enable_libdebuginfod" != "xdummy"; then
751      AC_MSG_NOTICE([checking libdebuginfod dependencies, --disable-libdebuginfod or --enable-libdebuginfo=dummy to skip])
752      enable_libdebuginfod=yes # presume success
753      PKG_PROG_PKG_CONFIG
754      PKG_CHECK_MODULES([libcurl],[libcurl >= 7.29.0],[],[enable_libdebuginfod=no])
755      if test "x$enable_libdebuginfod" = "xno"; then
756        AC_MSG_ERROR([dependencies not found, use --disable-libdebuginfod to disable or --enable-libdebuginfod=dummy to build a (bootstrap) dummy library.])
757      fi
758    else
759      AC_MSG_NOTICE([building (bootstrap) dummy libdebuginfo library])
760    fi
761])
762
763AC_CHECK_LIB(pthread, pthread_setname_np, [
764                      AC_DEFINE([HAVE_PTHREAD_SETNAME_NP],[1],[Enable pthread_setname_np])])
765
766AS_IF([test "x$enable_libdebuginfod" = "xyes" || test "x$enable_libdebuginfod" = "xdummy"],
767      [AC_DEFINE([ENABLE_LIBDEBUGINFOD], [1], [Enable libdebuginfod])])
768AS_IF([test "x$enable_libdebuginfod" = "xdummy"],
769      [AC_DEFINE([DUMMY_LIBDEBUGINFOD], [1], [Build dummy libdebuginfod])])
770AM_CONDITIONAL([LIBDEBUGINFOD],[test "x$enable_libdebuginfod" = "xyes" || test "x$enable_libdebuginfod" = "xdummy"])
771AM_CONDITIONAL([DUMMY_LIBDEBUGINFOD],[test "x$enable_libdebuginfod" = "xdummy"])
772
773# Look for libmicrohttpd, libarchive, sqlite for debuginfo server
774# minimum versions as per rhel7.
775AC_ARG_ENABLE([debuginfod],AS_HELP_STRING([--enable-debuginfod], [Build debuginfod server]))
776AS_IF([test "x$enable_debuginfod" != "xno"], [
777    AC_MSG_NOTICE([checking debuginfod C++11 support, --disable-debuginfod to skip])
778    AX_CXX_COMPILE_STDCXX(11, noext, mandatory)
779    AC_MSG_NOTICE([checking debuginfod dependencies, --disable-debuginfod to skip])
780    if test "x$enable_libdebuginfod" = "xno"; then
781      AC_MSG_ERROR([need libdebuginfod (or dummy), use --disable-debuginfod to disable.])
782    fi
783    enable_debuginfod=yes # presume success
784    PKG_PROG_PKG_CONFIG
785    PKG_CHECK_MODULES([libmicrohttpd],[libmicrohttpd >= 0.9.33],[],[enable_debuginfod=no])
786    PKG_CHECK_MODULES([oldlibmicrohttpd],[libmicrohttpd < 0.9.51],[old_libmicrohttpd=yes],[old_libmicrohttpd=no])
787    PKG_CHECK_MODULES([sqlite3],[sqlite3 >= 3.7.17],[],[enable_debuginfod=no])
788    PKG_CHECK_MODULES([libarchive],[libarchive >= 3.1.2],[],[enable_debuginfod=no])
789    if test "x$enable_debuginfod" = "xno"; then
790      AC_MSG_ERROR([dependencies not found, use --disable-debuginfod to disable.])
791    fi
792])
793
794AS_IF([test "x$enable_debuginfod" != "xno"],AC_DEFINE([ENABLE_DEBUGINFOD],[1],[Build debuginfod]))
795AM_CONDITIONAL([DEBUGINFOD],[test "x$enable_debuginfod" = "xyes"])
796AM_CONDITIONAL([OLD_LIBMICROHTTPD],[test "x$old_libmicrohttpd" = "xyes"])
797
798dnl for /etc/profile.d/elfutils.{csh,sh}
799default_debuginfod_urls=""
800AC_ARG_ENABLE(debuginfod-urls,
801            [AS_HELP_STRING([--enable-debuginfod-urls@<:@=URLS@:>@],[add URLS to profile.d DEBUGINFOD_URLS])],
802            [if test "x${enableval}" = "xyes";
803             then default_debuginfod_urls="https://debuginfod.elfutils.org/";
804             elif test "x${enableval}" != "xno"; then
805             default_debuginfod_urls="${enableval}";
806             fi],
807            [default_debuginfod_urls=""])
808AC_SUBST(DEBUGINFOD_URLS, $default_debuginfod_urls)
809AC_CONFIG_FILES([config/profile.sh config/profile.csh])
810
811AC_OUTPUT
812
813AC_MSG_NOTICE([
814=====================================================================
815        elfutils: ${PACKAGE_VERSION} (eu_version: ${eu_version})
816=====================================================================
817
818    Prefix                             : ${prefix}
819    Program prefix ("eu-" recommended) : ${program_prefix}
820    Source code location               : ${srcdir}
821    Maintainer mode                    : ${enable_maintainer_mode}
822    build arch                         : ${ac_cv_build}
823
824    CFLAGS=${CFLAGS}
825    CXXFLAGS=${CXXFLAGS}
826
827  RECOMMENDED FEATURES (should all be yes)
828    gzip support                       : ${with_zlib}
829    bzip2 support                      : ${with_bzlib}
830    lzma/xz support                    : ${with_lzma}
831    zstd support                       : ${with_zstd}
832    libstdc++ demangle support         : ${enable_demangler}
833    File textrel check                 : ${enable_textrelcheck}
834    Symbol versioning                  : ${enable_symbol_versioning}
835
836  NOT RECOMMENDED FEATURES (should all be no)
837    Experimental thread safety         : ${use_locks}
838    install elf.h                      : ${install_elfh}
839
840  OTHER FEATURES
841    Deterministic archives by default  : ${default_ar_deterministic}
842    Native language support            : ${USE_NLS}
843    Extra Valgrind annotations         : ${use_vg_annotations}
844    libdebuginfod client support       : ${enable_libdebuginfod}
845    Debuginfod server support          : ${enable_debuginfod}
846    Default DEBUGINFOD_URLS            : ${default_debuginfod_urls}
847
848  EXTRA TEST FEATURES (used with make check)
849    have bunzip2 installed (required)  : ${HAVE_BUNZIP2}
850    have zstd installed                : ${HAVE_ZSTD}
851    debug branch prediction            : ${use_debugpred}
852    gprof support                      : ${use_gprof}
853    gcov support                       : ${use_gcov}
854    run all tests under valgrind       : ${use_valgrind}
855    gcc undefined behaviour sanitizer  : ${use_undefined}
856    gcc address sanitizer              : ${use_address}
857    use rpath in tests                 : ${tests_use_rpath}
858    test biarch                        : ${utrace_cv_cc_biarch}
859])
860
861if test "$install_elfh" = yes; then
862  if test "${prefix}" = "/usr/local" -o "${prefix}" = "/usr"; then
863    AC_MSG_WARN([installing elf.h in ${includedir} might conflict with glibc/system elf.h])
864  fi
865fi
866