gdb/configure.ac

   1 dnl Autoconf configure script for GDB, the GNU debugger.
   2 dnl Copyright (C) 1995-2023 Free Software Foundation, Inc.
   3 dnl
   4 dnl This file is part of GDB.
   5 dnl
   6 dnl This program is free software; you can redistribute it and/or modify
   7 dnl it under the terms of the GNU General Public License as published by
   8 dnl the Free Software Foundation; either version 3 of the License, or
   9 dnl (at your option) any later version.
  10 dnl
  11 dnl This program is distributed in the hope that it will be useful,
  12 dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 dnl GNU General Public License for more details.
  15 dnl
  16 dnl You should have received a copy of the GNU General Public License
  17 dnl along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 dnl Process this file with autoconf to produce a configure script.
  20
  21 AC_INIT
  22 AC_CONFIG_MACRO_DIRS([.. ../config])
  23 AC_CONFIG_SRCDIR([main.c])
  24 AC_CONFIG_HEADERS(config.h:config.in, [echo > stamp-h])
  25 AM_MAINTAINER_MODE
  26
  27 AC_PROG_CC
  28 AC_PROG_CXX
  29
  30 AC_USE_SYSTEM_EXTENSIONS
  31 ACX_LARGEFILE
  32 AM_PROG_INSTALL_STRIP
  33
  34 AC_CONFIG_AUX_DIR(..)
  35
  36 # Set build, build_cpu, build_vendor and build_os.
  37 AC_CANONICAL_BUILD
  38
  39 # Set host, host_cpu, host_vendor, and host_os.
  40 AC_CANONICAL_HOST
  41
  42 # Set target, target_cpu, target_vendor, and target_os.
  43 AC_CANONICAL_TARGET
  44
  45 ACX_NONCANONICAL_TARGET
  46
  47 AC_ARG_PROGRAM
  48
  49 # We require libtool to link with the in-tree libtool libraries
  50 # the proper way.
  51 LT_INIT
  52 # ... and we need it soon, since it is used by some of the
  53 # link tests in the configure script.
  54 LT_OUTPUT
  55
  56 # We require a C++17 compiler.  Check if one is available, and if
  57 # necessary, set CXX_DIALECT to some -std=xxx switch.
  58 AX_CXX_COMPILE_STDCXX(17, , mandatory)
  59
  60 GDB_AC_COMMON
  61
  62 # Dependency checking.
  63 ZW_CREATE_DEPDIR
  64 ZW_PROG_COMPILER_DEPENDENCIES([CC])
  65
  66 # Since the first call to PKG_CHECK_MODULES may not happen (is guarded by
  67 # a condition), we must call PKG_PROG_PKG_CONFIG explicitly to probe for
  68 # pkg-config.
  69 PKG_PROG_PKG_CONFIG
  70
  71 dnl List of object files and targets accumulated by configure.
  72
  73 CONFIG_OBS=
  74 CONFIG_DEPS=
  75 CONFIG_SRCS=
  76 ENABLE_CFLAGS=
  77
  78 CONFIG_ALL=
  79 CONFIG_CLEAN=
  80 CONFIG_INSTALL=
  81 CONFIG_UNINSTALL=
  82
  83 dnl Set up for gettext.
  84 ZW_GNU_GETTEXT_SISTER_DIR
  85
  86 localedir='${datadir}/locale'
  87 AC_SUBST(localedir)
  88
  89 if test x"$USE_NLS" = xyes; then
  90    CONFIG_ALL="$CONFIG_ALL all-po"
  91    CONFIG_CLEAN="$CONFIG_CLEAN clean-po"
  92    CONFIG_INSTALL="$CONFIG_INSTALL install-po"
  93    CONFIG_UNINSTALL="$CONFIG_UNINSTALL uninstall-po"
  94 fi
  95
  96 PACKAGE=gdb
  97 AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of this package. ])
  98 AC_SUBST(PACKAGE)
  99
 100 # We never need to detect it in this sub-configure.
 101 # But preserve it for config.status --recheck.
 102 AC_ARG_VAR(MAKEINFO,
 103   [Parent configure detects if it is of sufficient version.])
 104 AC_ARG_VAR(MAKEINFOFLAGS,
 105   [Parameters for MAKEINFO.])
 106
 107 MAKEINFO_EXTRA_FLAGS=""
 108 AC_CACHE_CHECK([whether $MAKEINFO supports @click], gdb_cv_have_makeinfo_click,
 109   [echo '@clicksequence{a @click{} b}' >conftest.texinfo
 110   if eval "$MAKEINFO conftest.texinfo >&5 2>&5"; then
 111     gdb_cv_have_makeinfo_click=yes
 112   else
 113     gdb_cv_have_makeinfo_click=no
 114   fi])
 115 if test x"$gdb_cv_have_makeinfo_click" = xyes; then
 116   MAKEINFO_EXTRA_FLAGS="$MAKEINFO_EXTRA_FLAGS -DHAVE_MAKEINFO_CLICK"
 117 fi
 118 AC_SUBST(MAKEINFO_EXTRA_FLAGS)
 119
 120 GDB_AC_WITH_DIR(DEBUGDIR, separate-debug-dir,
 121     [look for global separate debug info in this path @<:@LIBDIR/debug@:>@],
 122     [${libdir}/debug])
 123
 124 AC_ARG_WITH(additional-debug-dirs,
 125             AS_HELP_STRING([--with-additional-debug-dirs=PATHs],
 126                            [colon-separated list of additional directories to
 127                             search for separate debug info]),
 128             [AC_DEFINE_UNQUOTED(ADDITIONAL_DEBUG_DIRS, "${withval}",
 129                                 Additional directories to look for separate
 130                                 debug info.)])
 131
 132 # We can't pass paths as command line arguments.
 133 # Mingw32 tries to be clever and will convert the paths for us.
 134 # For example -DBINDIR="/usr/local/bin" passed on the command line may get
 135 # converted to -DBINDIR="E:/msys/mingw32/msys/1.0/local/bin".
 136 # This breaks GDB's relocatable path conversions since paths passed in
 137 # config.h would not get so translated, the path prefixes no longer match.
 138 AC_DEFINE_DIR(BINDIR, bindir, [Directory of programs.])
 139
 140 # GDB's datadir relocation
 141
 142 GDB_AC_WITH_DIR(GDB_DATADIR, gdb-datadir,
 143     [look for global separate data files in this path @<:@DATADIR/gdb@:>@],
 144     [${datadir}/gdb])
 145
 146 AC_ARG_WITH(relocated-sources,
 147 AS_HELP_STRING([--with-relocated-sources=PATH], [automatically relocate this path for source files]),
 148 [reloc_srcdir="${withval}"
 149  AC_DEFINE_DIR(RELOC_SRCDIR, reloc_srcdir,
 150               [Relocated directory for source files. ])
 151 ])
 152
 153 AC_MSG_CHECKING([for default auto-load directory])
 154 AC_ARG_WITH(auto-load-dir,
 155 AS_HELP_STRING([--with-auto-load-dir=PATH],
 156   [directories from which to load auto-loaded scripts @<:@$debugdir:$datadir/auto-load@:>@]),,
 157   [with_auto_load_dir='$debugdir:$datadir/auto-load'])
 158 escape_dir=`echo $with_auto_load_dir | sed -e 's/[[$]]datadir\>/\\\\\\\\\\\\&/g' -e 's/[[$]]debugdir\>/\\\\\\\\\\\\&/g'`
 159 AC_DEFINE_DIR(AUTO_LOAD_DIR, escape_dir,
 160               [Directories from which to load auto-loaded scripts.])
 161 AC_MSG_RESULT([$with_auto_load_dir])
 162
 163 AC_MSG_CHECKING([for default auto-load safe-path])
 164 AC_ARG_WITH(auto-load-safe-path,
 165 AS_HELP_STRING([--with-auto-load-safe-path=PATH],
 166   [directories safe to hold auto-loaded files @<:@--with-auto-load-dir@:>@])
 167 AS_HELP_STRING([--without-auto-load-safe-path],
 168                [do not restrict auto-loaded files locations]),
 169     [if test "$with_auto_load_safe_path" = "no"; then
 170      with_auto_load_safe_path="/"
 171      fi],
 172 [with_auto_load_safe_path="$with_auto_load_dir"])
 173 escape_dir=`echo $with_auto_load_safe_path | sed -e 's/[[$]]datadir\>/\\\\\\\\\\\\&/g' -e 's/[[$]]debugdir\>/\\\\\\\\\\\\&/g'`
 174 AC_DEFINE_DIR(AUTO_LOAD_SAFE_PATH, escape_dir,
 175               [Directories safe to hold auto-loaded files.])
 176 AC_MSG_RESULT([$with_auto_load_safe_path])
 177
 178 AC_CONFIG_SUBDIRS(testsuite)
 179
 180 # Check whether to support alternative target configurations
 181 AC_ARG_ENABLE(targets,
 182 AS_HELP_STRING([--enable-targets=TARGETS], [alternative target configurations]),
 183 [case "${enableval}" in
 184   yes | "") AC_MSG_ERROR(enable-targets option must specify target names or 'all')
 185             ;;
 186   no)       enable_targets= ;;
 187   *)        enable_targets=$enableval ;;
 188 esac])
 189
 190 BFD_64_BIT
 191
 192 # Provide defaults for some variables set by the per-host and per-target
 193 # configuration.
 194 gdb_host_obs=posix-hdep.o
 195
 196 if test "${target}" = "${host}"; then
 197   gdb_native=yes
 198 else
 199   gdb_native=no
 200 fi
 201
 202 . $srcdir/configure.host
 203
 204 # Accumulate some settings from configure.tgt over all enabled targets
 205
 206 TARGET_OBS=
 207 all_targets=
 208 HAVE_NATIVE_GCORE_TARGET=
 209
 210 for targ_alias in `echo $target_alias $enable_targets | sed 's/,/ /g'`
 211 do
 212   if test "$targ_alias" = "all"; then
 213     all_targets=true
 214   else
 215     # Canonicalize the secondary target names.
 216     result=`$ac_config_sub $targ_alias 2>/dev/null`
 217     if test -n "$result"; then
 218         targ=$result
 219     else
 220         targ=$targ_alias
 221     fi
 222
 223     . ${srcdir}/configure.tgt
 224
 225     AS_IF([test -z "${gdb_target_obs}"],
 226       [AC_MSG_ERROR([configuration ${targ} is unsupported.])])
 227
 228     # Target-specific object files
 229     for i in ${gdb_target_obs}; do
 230         case " $TARGET_OBS " in
 231         *" ${i} "*) ;;
 232         *)
 233           TARGET_OBS="$TARGET_OBS ${i}"
 234           ;;
 235         esac
 236     done
 237
 238     # Check whether this target needs 64-bit CORE_ADDR
 239     if test x${enable_64_bit_bfd} = xno; then
 240       . ${srcdir}/../bfd/config.bfd
 241     fi
 242
 243     # Check whether this target is native and supports gcore.
 244     if test $gdb_native = yes -a "$targ_alias" = "$target_alias" \
 245        && $gdb_have_gcore; then
 246       HAVE_NATIVE_GCORE_TARGET=1
 247     fi
 248   fi
 249 done
 250
 251 if test x${all_targets} = xtrue; then
 252   if test x${enable_64_bit_bfd} = xyes; then
 253     TARGET_OBS='$(ALL_TARGET_OBS) $(ALL_64_TARGET_OBS)'
 254   else
 255     TARGET_OBS='$(ALL_TARGET_OBS)'
 256   fi
 257 fi
 258
 259 # AMD debugger API support.
 260
 261 AC_ARG_WITH([amd-dbgapi],
 262             [AS_HELP_STRING([--with-amd-dbgapi],
 263                             [support for the amd-dbgapi target (yes / no / auto)])],
 264             [GDB_CHECK_YES_NO_AUTO_VAL([$withval], [--with-amd-dbgapi])],
 265             [with_amd_dbgapi=auto])
 266
 267 # If the user passes --without-amd-dbgapi but also explicitly enables a target
 268 # that requires amd-dbgapi, it is an error.
 269 if test "$with_amd_dbgapi" = no -a "$gdb_require_amd_dbgapi" = true; then
 270   AC_MSG_ERROR([an explicitly enabled target requires amd-dbgapi, but amd-dbgapi is explicitly disabled])
 271 fi
 272
 273 # Look for amd-dbgapi if:
 274 #
 275 #   - a target architecture requiring it has explicitly been enabled, or
 276 #   - --enable-targets=all was provided and the user did not explicitly disable
 277 #     amd-dbgapi support
 278 if test "$gdb_require_amd_dbgapi" = true \
 279      -o \( "$all_targets" = true -a "$with_amd_dbgapi" != no \); then
 280   # amd-dbgapi version 0.68 is part of ROCm 5.4.  There is no guarantee of API
 281   # stability until amd-dbgapi hits 1.0, but for convenience, still check for
 282   # greater or equal that version.  It can be handy when testing with a newer
 283   # version of the library.
 284   PKG_CHECK_MODULES([AMD_DBGAPI], [amd-dbgapi >= 0.68.0],
 285                     [has_amd_dbgapi=yes], [has_amd_dbgapi=no])
 286
 287   if test "$has_amd_dbgapi" = "yes"; then
 288     AC_DEFINE(HAVE_AMD_DBGAPI, 1, [Define if amd-dbgapi is being linked in.])
 289     TARGET_OBS="$TARGET_OBS amd-dbgapi-target.o"
 290
 291     # If --enable-targets=all was provided, use the list of all files depending
 292     # on amd-dbgapi that is hardcoded in the Makefile.  Else, the appropriate
 293     # architecture entry in configure.tgt will have added the files to
 294     # gdb_target_obs.
 295     if test "$all_targets" = true; then
 296       TARGET_OBS="$TARGET_OBS \$(ALL_AMD_DBGAPI_TARGET_OBS)"
 297     fi
 298   elif test "$gdb_require_amd_dbgapi" = true -o "$with_amd_dbgapi" = yes; then
 299     # amd-dbgapi was not found and...
 300     #
 301     #   - a target requiring it was explicitly enabled, or
 302     #   - the user explicitly wants to enable amd-dbgapi
 303     AC_MSG_ERROR([amd-dbgapi is required, but cannot find an appropriate version: $AMD_DBGAPI_PKG_ERRORS])
 304   fi
 305 fi
 306
 307 AC_SUBST(TARGET_OBS)
 308 AC_SUBST(HAVE_NATIVE_GCORE_TARGET)
 309
 310 # For other settings, only the main target counts.
 311 gdb_sim=
 312 gdb_osabi=
 313 targ=$target; . ${srcdir}/configure.tgt
 314
 315 # Fetch the default architecture and default target vector from BFD.
 316 targ=$target; . $srcdir/../bfd/config.bfd
 317
 318 # We only want the first architecture, so strip off the others if
 319 # there is more than one.
 320 targ_archs=`echo $targ_archs | sed 's/ .*//'`
 321
 322 if test "x$targ_archs" != x; then
 323   AC_DEFINE_UNQUOTED(DEFAULT_BFD_ARCH, $targ_archs,
 324     [Define to BFD's default architecture. ])
 325 fi
 326 if test "x$targ_defvec" != x; then
 327   AC_DEFINE_UNQUOTED(DEFAULT_BFD_VEC, $targ_defvec,
 328     [Define to BFD's default target vector. ])
 329 fi
 330
 331 # Enable TUI.
 332 AC_ARG_ENABLE(tui,
 333 AS_HELP_STRING([--enable-tui],
 334                [enable full-screen terminal user interface (TUI)]),
 335                [GDB_CHECK_YES_NO_AUTO_VAL([$enableval], [--enable-tui])],
 336                [enable_tui=auto])
 337
 338 # Enable gdbtk.
 339 AC_ARG_ENABLE([gdbtk],
 340               [AS_HELP_STRING([--enable-gdbtk], [enable gdbtk graphical user interface (GUI)])],
 341               [GDB_CHECK_YES_NO_VAL([$enableval], [--enable-gdbtk])],
 342               [if test -d "$srcdir/gdbtk"; then
 343                  enable_gdbtk=yes
 344                else
 345                  enable_gdbtk=no
 346                fi])
 347 # We unconditionally disable gdbtk tests on selected platforms.
 348 case $host_os in
 349   go32* | windows*)
 350     AC_MSG_WARN([gdbtk isn't supported on $host; disabling])
 351     enable_gdbtk=no ;;
 352 esac
 353
 354 # Handle optional debuginfod support
 355 AC_DEBUGINFOD
 356
 357 # Libunwind support for ia64.
 358 AC_ARG_WITH(libunwind-ia64,
 359 AS_HELP_STRING([--with-libunwind-ia64],
 360                [use libunwind frame unwinding for ia64 targets]),,
 361             [with_libunwind_ia64=auto])
 362
 363 # Backward compatibility option.
 364 if test "${with_libunwind+set}" = set; then
 365   if test x"$with_libunwind_ia64" != xauto; then
 366     AC_MSG_ERROR(
 367       [option --with-libunwind is deprecated, use --with-libunwind-ia64])
 368   fi
 369   AC_MSG_WARN([option --with-libunwind is deprecated, use --with-libunwind-ia64])
 370   with_libunwind_ia64="$with_libunwind"
 371 fi
 372
 373 case "$with_libunwind_ia64" in
 374   yes | no)
 375     ;;
 376   auto)
 377     AC_CHECK_HEADERS(libunwind-ia64.h)
 378     with_libunwind_ia64=$ac_cv_header_libunwind_ia64_h
 379     ;;
 380   *)
 381     AC_MSG_ERROR(
 382       [bad value $with_libunwind_ia64 for GDB --with-libunwind-ia64 option])
 383     ;;
 384 esac
 385
 386 if test x"$with_libunwind_ia64" = xyes; then
 387   AC_CHECK_HEADERS(libunwind-ia64.h)
 388   if test x"$ac_cv_header_libunwind_ia64_h" != xyes; then
 389     AC_MSG_ERROR([GDB option --with-libunwind-ia64 requires libunwind-ia64.h])
 390   fi
 391   CONFIG_OBS="$CONFIG_OBS ia64-libunwind-tdep.o"
 392   CONFIG_DEPS="$CONFIG_DEPS ia64-libunwind-tdep.o"
 393   CONFIG_SRCS="$CONFIG_SRCS ia64-libunwind-tdep.c"
 394 fi
 395
 396 opt_curses=no
 397 AC_ARG_WITH(curses, AS_HELP_STRING([--with-curses], [use the curses library instead of the termcap library]), opt_curses=$withval)
 398
 399 prefer_curses=no
 400 if test "$opt_curses" = "yes"; then
 401   prefer_curses=yes
 402 fi
 403
 404 # Profiling support.
 405 AC_ARG_ENABLE([profiling],
 406               [AS_HELP_STRING([--enable-profiling], [enable profiling of GDB])],
 407               [GDB_CHECK_YES_NO_VAL([$enableval], [--enable-profiling])],
 408               [enable_profiling=no])
 409
 410 AC_CHECK_FUNCS(monstartup _mcleanup)
 411 AC_CACHE_CHECK(
 412   [for _etext],
 413   [ac_cv_var__etext],
 414   [AC_LINK_IFELSE(
 415      [AC_LANG_PROGRAM(
 416         [#include <stdlib.h>
 417          extern char _etext;],
 418         [free (&_etext);]
 419       )],
 420      [ac_cv_var__etext=yes],
 421      [ac_cv_var__etext=no]
 422    )]
 423 )
 424 if test "$ac_cv_var__etext" = yes; then
 425   AC_DEFINE(HAVE__ETEXT, 1,
 426             [Define to 1 if your system has the _etext variable. ])
 427 fi
 428 AC_CACHE_CHECK(
 429   [for etext],
 430   [ac_cv_var_etext],
 431   [AC_LINK_IFELSE(
 432      [AC_LANG_PROGRAM(
 433         [#include <stdlib.h>
 434          extern char etext;],
 435         [free (&etext);]
 436       )],
 437      [ac_cv_var_etext=yes],
 438      [ac_cv_var_etext=no]
 439    )]
 440 )
 441 if test "$ac_cv_var_etext" = yes; then
 442   AC_DEFINE(HAVE_ETEXT, 1,
 443             [Define to 1 if your system has the etext variable. ])
 444 fi
 445 if test "$enable_profiling" = yes ; then
 446   if test "$ac_cv_func_monstartup" = no || test "$ac_cv_func__mcleanup" = no; then
 447     AC_MSG_ERROR(--enable-profiling requires monstartup and _mcleanup)
 448   fi
 449   PROFILE_CFLAGS=-pg
 450   OLD_CFLAGS="$CFLAGS"
 451   CFLAGS="$CFLAGS $PROFILE_CFLAGS"
 452
 453   AC_CACHE_CHECK(
 454     [whether $CC supports -pg],
 455     [ac_cv_cc_supports_pg],
 456     [AC_COMPILE_IFELSE(
 457        [AC_LANG_PROGRAM([], [int x;])],
 458        [ac_cv_cc_supports_pg=yes],
 459        [ac_cv_cc_supports_pg=no]
 460      )]
 461   )
 462
 463   if test "$ac_cv_cc_supports_pg" = no; then
 464     AC_MSG_ERROR(--enable-profiling requires a compiler which supports -pg)
 465   fi
 466
 467   CFLAGS="$OLD_CFLAGS"
 468 fi
 469
 470 CODESIGN_CERT=
 471 AC_ARG_ENABLE([codesign],
 472   AS_HELP_STRING([--enable-codesign=CERT],
 473                  [sign gdb with 'codesign -s CERT']),
 474   [CODESIGN_CERT=$enableval])
 475 AC_SUBST([CODESIGN_CERT])
 476
 477 ACX_PKGVERSION([GDB])
 478 ACX_BUGURL([https://www.gnu.org/software/gdb/bugs/])
 479 AC_DEFINE_UNQUOTED([PKGVERSION], ["$PKGVERSION"], [Additional package description])
 480 AC_DEFINE_UNQUOTED([REPORT_BUGS_TO], ["$REPORT_BUGS_TO"], [Bug reporting address])
 481
 482 # --------------------- #
 483 # Checks for programs.  #
 484 # --------------------- #
 485
 486 AC_PROG_AWK
 487 AC_PROG_INSTALL
 488 AC_PROG_LN_S
 489 AC_PROG_RANLIB
 490 AC_PROG_YACC
 491
 492 AC_CHECK_TOOL(AR, ar)
 493 AC_CHECK_TOOL(DLLTOOL, dlltool)
 494 AC_CHECK_TOOL(WINDRES, windres)
 495
 496 case $host_os in
 497   gnu*)
 498     # Needed for GNU Hurd hosts.
 499     AC_CHECK_TOOL(MIG, mig)
 500     if test x"$MIG" = x; then
 501       AC_MSG_ERROR([MIG not found but required for $host hosts])
 502     fi
 503     ;;
 504 esac
 505
 506 # ---------------------- #
 507 # Checks for libraries.  #
 508 # ---------------------- #
 509
 510 # We might need to link with -lm; most simulators need it.
 511 AC_CHECK_LIB(m, main)
 512
 513 # Some systems (e.g. Solaris) have `gethostbyname' in libnsl.
 514 AC_SEARCH_LIBS(gethostbyname, nsl)
 515
 516 # Link in zlib/zstd if we can.  This allows us to read compressed debug
 517 # sections.
 518 AM_ZLIB
 519 AC_ZSTD
 520
 521 AM_ICONV
 522
 523 # GDB may fork/exec the iconv program to get the list of supported character
 524 # sets.  Allow the user to specify where to find it.
 525 # There are several factors affecting the choice of option name:
 526 # - There is already --with-libiconv-prefix but we can't use it, it specifies
 527 #   the build-time location of libiconv files.
 528 # - The program we need to find is iconv, which comes with glibc.  The user
 529 #   doesn't necessarily have libiconv installed.  Therefore naming this
 530 #   --with-libiconv-foo feels wrong.
 531 # - We want the path to be relocatable, but GDB_AC_DEFINE_RELOCATABLE is
 532 #   defined to work on directories not files (though it really doesn't know
 533 #   the difference).
 534 # - Calling this --with-iconv-prefix is perceived to cause too much confusion
 535 #   with --with-libiconv-prefix.
 536 # Putting these together is why the option name is --with-iconv-bin.
 537
 538 AC_ARG_WITH(iconv-bin,
 539 AS_HELP_STRING([--with-iconv-bin=PATH], [specify where to find the iconv program]),
 540 [iconv_bin="${withval}"
 541  AC_DEFINE_UNQUOTED([ICONV_BIN], ["${iconv_bin}"],
 542                     [Path of directory of iconv program.])
 543  GDB_AC_DEFINE_RELOCATABLE(ICONV_BIN, iconv, ${iconv_bin})
 544 ])
 545
 546 # For the TUI, we need enhanced curses functionality.
 547 if test x"$enable_tui" != xno; then
 548   prefer_curses=yes
 549 fi
 550
 551 curses_found=no
 552 if test x"$prefer_curses" = xyes; then
 553   # FIXME: kettenis/20040905: We prefer ncurses over the vendor-supplied
 554   # curses library because the latter might not provide all the
 555   # functionality we need.  However, this leads to problems on systems
 556   # where the linker searches /usr/local/lib, but the compiler doesn't
 557   # search /usr/local/include, if ncurses is installed in /usr/local.  A
 558   # default installation of ncurses on alpha*-dec-osf* will lead to such
 559   # a situation.
 560   AC_SEARCH_LIBS(waddstr, [ncursesw ncurses cursesX curses],
 561                  [curses_found=yes
 562                   AC_DEFINE([HAVE_LIBCURSES], [1],
 563                             [Define to 1 if curses is enabled.])
 564                  ])
 565 fi
 566
 567 # Check whether we should enable the TUI, but only do so if we really
 568 # can.
 569 if test x"$enable_tui" != xno; then
 570   if test "$curses_found" != no; then
 571     CONFIG_OBS="$CONFIG_OBS \$(SUBDIR_TUI_OBS)"
 572     CONFIG_DEPS="$CONFIG_DEPS \$(SUBDIR_TUI_DEPS)"
 573     CONFIG_SRCS="$CONFIG_SRCS \$(SUBDIR_TUI_SRCS)"
 574     ENABLE_CFLAGS="$ENABLE_CFLAGS \$(SUBDIR_TUI_CFLAGS)"
 575   else
 576     if test x"$enable_tui" = xyes; then
 577       AC_MSG_ERROR([no enhanced curses library found; disable TUI])
 578     else
 579       AC_MSG_WARN([no enhanced curses library found; disabling TUI])
 580     fi
 581   fi
 582 fi
 583
 584 # Since GDB uses Readline, we need termcap functionality.  In many
 585 # cases this will be provided by the curses library, but some systems
 586 # have a separate termcap library, or no curses library at all.
 587
 588 case $host_os in
 589   cygwin*)
 590     if test -d "$srcdir/libtermcap"; then
 591       LIBS="../libtermcap/libtermcap.a $LIBS"
 592       ac_cv_search_tgetent="../libtermcap/libtermcap.a"
 593     fi ;;
 594   go32* | *djgpp*)
 595     ac_cv_search_tgetent="none required"
 596     ;;
 597 esac
 598
 599 # These are the libraries checked by Readline.
 600 AC_SEARCH_LIBS(tgetent, [termcap tinfow tinfo curses ncursesw ncurses])
 601
 602 if test "$ac_cv_search_tgetent" = no; then
 603   CONFIG_OBS="$CONFIG_OBS stub-termcap.o"
 604 fi
 605
 606 AC_ARG_WITH([system-readline],
 607   [AS_HELP_STRING([--with-system-readline],
 608                   [use installed readline library])])
 609
 610 if test "$with_system_readline" = yes; then
 611   AC_CHECK_HEADERS(readline/readline.h, [readline_h=yes], [readline_h=no])
 612   if test "$readline_h" = "no"; then
 613     AC_MSG_ERROR([readline development packages are probably missing])
 614   fi
 615   AC_CACHE_CHECK(
 616     [whether system readline is new enough],
 617     [gdb_cv_readline_ok],
 618     [AC_COMPILE_IFELSE(
 619        [AC_LANG_PROGRAM(
 620           [#include <stdio.h>
 621            #include <readline/readline.h>],
 622           [#if RL_VERSION_MAJOR < 7
 623            # error "readline version 7 required"
 624            #endif]
 625         )],
 626        [gdb_cv_readline_ok=yes],
 627        [gdb_cv_readline_ok=no]
 628      )]
 629   )
 630   if test "$gdb_cv_readline_ok" != yes; then
 631     AC_MSG_ERROR([system readline is not new enough])
 632   fi
 633
 634   READLINE=-lreadline
 635   READLINE_DEPS=
 636   READLINE_CFLAGS=
 637   READLINE_TEXI_INCFLAG=
 638   READLINE_DOC_SOURCE_INCLUDES='$(READLINE_SYSTEM_DOC_INCLUDES)'
 639 else
 640   READLINE='$(READLINE_DIR)/libreadline.a'
 641   READLINE_DEPS='$(READLINE)'
 642   READLINE_CFLAGS='-I$(READLINE_SRC)/..'
 643   READLINE_TEXI_INCFLAG='-I $(READLINE_DIR)'
 644   READLINE_DOC_SOURCE_INCLUDES='$(READLINE_INTREE_DOC_INCLUDES)'
 645 fi
 646 AC_SUBST(READLINE)
 647 AC_SUBST(READLINE_DEPS)
 648 AC_SUBST(READLINE_CFLAGS)
 649 AC_SUBST(READLINE_TEXI_INCFLAG)
 650 AC_SUBST(READLINE_DOC_SOURCE_INCLUDES)
 651
 652 # Generate jit-reader.h
 653
 654 # This is typedeffed to GDB_CORE_ADDR in jit-reader.h
 655 TARGET_PTR=
 656
 657 AC_CHECK_SIZEOF(unsigned long long)
 658 AC_CHECK_SIZEOF(unsigned long)
 659 AC_CHECK_SIZEOF(unsigned __int128)
 660
 661 if test "x${ac_cv_sizeof_unsigned_long}" = "x8"; then
 662   TARGET_PTR="unsigned long"
 663 elif test "x${ac_cv_sizeof_unsigned_long_long}" = "x8"; then
 664   TARGET_PTR="unsigned long long"
 665 elif test "x${ac_cv_sizeof_unsigned___int128}" = "x16"; then
 666   TARGET_PTR="unsigned __int128"
 667 else
 668   TARGET_PTR="unsigned long"
 669 fi
 670
 671 AC_SUBST(TARGET_PTR)
 672 AC_CONFIG_FILES([jit-reader.h:jit-reader.in])
 673
 674 AC_SEARCH_LIBS(dlopen, dl)
 675
 676 GDB_AC_WITH_DIR([JIT_READER_DIR], [jit-reader-dir],
 677                 [directory to load the JIT readers from],
 678                 [${libdir}/gdb])
 679
 680 AC_ARG_WITH(expat,
 681   AS_HELP_STRING([--with-expat], [include expat support (auto/yes/no)]),
 682   [], [with_expat=auto])
 683 AC_MSG_CHECKING([whether to use expat])
 684 AC_MSG_RESULT([$with_expat])
 685
 686 if test "${with_expat}" = no; then
 687   AC_MSG_WARN([expat support disabled; some features may be unavailable.])
 688   HAVE_LIBEXPAT=no
 689 else
 690   AC_LIB_HAVE_LINKFLAGS([expat], [], [#include "expat.h"],
 691                         [XML_Parser p = XML_ParserCreate (0);])
 692   if test "$HAVE_LIBEXPAT" != yes; then
 693     if test "$with_expat" = yes; then
 694       AC_MSG_ERROR([expat is missing or unusable])
 695     else
 696       AC_MSG_WARN([expat is missing or unusable; some features may be unavailable.])
 697     fi
 698   else
 699     save_LIBS=$LIBS
 700     LIBS="$LIBS $LIBEXPAT"
 701     AC_CHECK_FUNCS(XML_StopParser)
 702     LIBS=$save_LIBS
 703   fi
 704 fi
 705
 706 AC_ARG_VAR(GMPLIBS,[How to link GMP])
 707 AC_ARG_VAR(GMPINC,[How to find GMP include files])
 708
 709 # --------------------- #
 710 # Check for libpython.  #
 711 # --------------------- #
 712
 713 dnl Utility to simplify finding libpython.
 714 dnl $1 = the shell variable to assign the result to
 715 dnl      If libpython is found we store $version here.
 716 dnl $2 = additional flags to add to CPPFLAGS
 717 dnl $3 = additional flags to add to LIBS
 718
 719 AC_DEFUN([AC_TRY_LIBPYTHON],
 720 [
 721   define([have_libpython_var],$1)
 722   new_CPPFLAGS=$2
 723   new_LIBS=$3
 724   AC_MSG_CHECKING([for python])
 725   save_CPPFLAGS=$CPPFLAGS
 726   save_LIBS=$LIBS
 727   CPPFLAGS="$CPPFLAGS $new_CPPFLAGS"
 728   LIBS="$new_LIBS $LIBS"
 729   found_usable_python=no
 730   AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include "Python.h"]],
 731                                  [[
 732                                     #if PY_MAJOR_VERSION != 3
 733                                     # error "We only support Python 3"
 734                                     #endif
 735                                     Py_Initialize ();
 736                                  ]])],
 737                  [have_libpython_var=yes
 738                   found_usable_python=yes
 739                   PYTHON_CPPFLAGS=$new_CPPFLAGS
 740                   PYTHON_LIBS=$new_LIBS])
 741   CPPFLAGS=$save_CPPFLAGS
 742   LIBS=$save_LIBS
 743   AC_MSG_RESULT([${found_usable_python}])
 744 ])
 745
 746 dnl There are several different values for --with-python:
 747 dnl
 748 dnl no -   Don't include python support.
 749 dnl yes -  Include python support, error if it's missing.
 750 dnl        If we find python in $PATH, use it to fetch configure options,
 751 dnl        otherwise assume the compiler can find it with no help from us.
 752 dnl auto - Same as "yes", but if python is missing from the system,
 753 dnl        fall back to "no".
 754 dnl /path/to/python/exec-prefix -
 755 dnl        Use the python located in this directory.
 756 dnl        If /path/to/python/exec-prefix/bin/python exists, use it to find
 757 dnl        the compilation parameters.  Otherwise use
 758 dnl        -I/path/to/python/exec-prefix/include,
 759 dnl        -L/path/to/python/exec-prefix/lib.
 760 dnl        NOTE: This case is historical.  It is what was done for 7.0/7.1
 761 dnl        but is deprecated.
 762 dnl /path/to/python/executable -
 763 dnl        Run python-config.py with this version of python to fetch the
 764 dnl        compilation parameters.
 765 dnl        NOTE: This needn't be the real python executable.
 766 dnl        In a cross-compilation scenario (build != host), this could be
 767 dnl        a shell script that provides what python-config.py provides for
 768 dnl        --ldflags, --includes, --exec-prefix.
 769 dnl python-executable -
 770 dnl        Find python-executable in $PATH, and then handle the same as
 771 dnl        /path/to/python/executable.
 772 dnl
 773 dnl If a python program is specified, it is used to run python-config.py and
 774 dnl is passed --ldflags, --includes, --exec-prefix.
 775
 776 AC_ARG_WITH(python,
 777   AS_HELP_STRING([--with-python@<:@=PYTHON@:>@], [include python support (auto/yes/no/<python-program>)]),
 778   [], [with_python=auto])
 779 AC_MSG_CHECKING([whether to use python])
 780 AC_MSG_RESULT([$with_python])
 781
 782 if test "${with_python}" = no; then
 783   AC_MSG_WARN([python support disabled; some features may be unavailable.])
 784   have_libpython=no
 785 else
 786   case "${with_python}" in
 787   [[\\/]]* | ?:[[\\/]]*)
 788     if test -d "${with_python}"; then
 789       # Assume the python binary is ${with_python}/bin/python.
 790       python_prog="${with_python}/bin/python"
 791       python_prefix=
 792       # If python does not exit ${with_python}/bin, then try in
 793       # ${with_python}.  On Windows/MinGW, this is where the Python
 794       # executable is.
 795       if test ! -x "${python_prog}"; then
 796         python_prog="${with_python}/python"
 797         python_prefix=
 798       fi
 799       if test ! -x "${python_prog}"; then
 800         # Fall back to gdb 7.0/7.1 behaviour.
 801         python_prog=missing
 802         python_prefix=${with_python}
 803       fi
 804     elif test -x "${with_python}"; then
 805       # While we can't run python compiled for $host (unless host == build),
 806       # the user could write a script that provides the needed information,
 807       # so we support that.
 808       python_prog=${with_python}
 809       python_prefix=
 810     else
 811       AC_MSG_ERROR(invalid value for --with-python)
 812     fi
 813     ;;
 814   */*)
 815     # Disallow --with-python=foo/bar.
 816     AC_MSG_ERROR(invalid value for --with-python)
 817     ;;
 818   *)
 819     # The user has either specified auto, yes, or the name of the python
 820     # program assumed to be in $PATH.
 821     python_prefix=
 822     case "${with_python}" in
 823     yes | auto)
 824       if test "${build}" = "${host}"; then
 825         # Look first for 'python', then 'python3'.
 826         AC_PATH_PROGS(python_prog_path, [python python3], missing)
 827         if test "${python_prog_path}" = missing; then
 828           python_prog=missing
 829         else
 830           python_prog=${python_prog_path}
 831         fi
 832       else
 833         # Not much we can do except assume the cross-compiler will find the
 834         # right files.
 835         python_prog=missing
 836       fi
 837       ;;
 838     *)
 839       # While we can't run python compiled for $host (unless host == build),
 840       # the user could write a script that provides the needed information,
 841       # so we support that.
 842       python_prog="${with_python}"
 843       AC_PATH_PROG(python_prog_path, ${python_prog}, missing)
 844       if test "${python_prog_path}" = missing; then
 845         AC_MSG_ERROR(unable to find python program ${python_prog})
 846       fi
 847       ;;
 848     esac
 849   esac
 850
 851   if test "${python_prog}" != missing; then
 852     # We have a python program to use, but it may be too old.
 853     # Don't flag an error for --with-python=auto (the default).
 854     have_python_config=yes
 855     python_includes=`${python_prog} ${srcdir}/python/python-config.py --includes`
 856     if test $? != 0; then
 857       have_python_config=failed
 858       if test "${with_python}" != auto; then
 859         AC_MSG_ERROR(failure running python-config --includes)
 860       fi
 861     fi
 862     python_libs=`${python_prog} ${srcdir}/python/python-config.py --ldflags`
 863     if test $? != 0; then
 864       have_python_config=failed
 865       if test "${with_python}" != auto; then
 866         AC_MSG_ERROR(failure running python-config --ldflags)
 867       fi
 868     fi
 869     python_prefix=`${python_prog} ${srcdir}/python/python-config.py --exec-prefix`
 870     if test $? != 0; then
 871       have_python_config=failed
 872       if test "${with_python}" != auto; then
 873         AC_MSG_ERROR(failure running python-config --exec-prefix)
 874       fi
 875     fi
 876   else
 877     # We do not have a python executable we can use to determine where
 878     # to find the Python headers and libs.  We cannot guess the include
 879     # path from the python_prefix either, because that include path
 880     # depends on the Python version.  So, there is nothing much we can
 881     # do except assume that the compiler will be able to find those files.
 882     python_includes=
 883     python_libs=
 884     have_python_config=no
 885   fi
 886
 887   # If we have python-config, only try the configuration it provides.
 888   # Otherwise fallback on the old way of trying different versions of
 889   # python in turn.
 890
 891   have_libpython=no
 892   if test "${have_python_config}" = yes; then
 893     AC_TRY_LIBPYTHON(have_libpython,
 894                      ${python_includes}, ${python_libs})
 895   fi
 896
 897   if test "${have_libpython}" = no; then
 898     case "${with_python}" in
 899     yes)
 900       AC_MSG_ERROR([python is missing or unusable])
 901       ;;
 902     auto)
 903       AC_MSG_WARN([python is missing or unusable; some features may be unavailable.])
 904       ;;
 905     *)
 906       AC_MSG_ERROR([no usable python found at ${with_python}])
 907       ;;
 908     esac
 909   else
 910     if test -n "${python_prefix}"; then
 911       AC_DEFINE_UNQUOTED(WITH_PYTHON_PATH, "${python_prefix}",
 912                          [Define if --with-python provides a path, either directly or via python-config.py --exec-prefix.])
 913       GDB_AC_DEFINE_RELOCATABLE(PYTHON_PATH, python, ${python_prefix})
 914     fi
 915   fi
 916 fi
 917
 918 dnl Use --with-python-libdir to control where GDB looks for the Python
 919 dnl libraries.
 920 dnl
 921 dnl If this is not given then the default will be based on the value
 922 dnl passed to --with-python, which is in the python_prefix variable.
 923 dnl If the --with-python option wasn't given then the default value in
 924 dnl python_prefix is based on running the 'gdb/python/python-config
 925 dnl --exec-prefix' script.
 926 AC_ARG_WITH(python-libdir,
 927   AS_HELP_STRING([--with-python-libdir@<:@=DIR@:>@], [search for python's libraries in DIR]),
 928   [],[
 929     # If no python libdir is specified then select one based on
 930     # python's prefix path.
 931     if test -n "${python_prefix}"; then
 932       with_python_libdir=${python_prefix}/lib
 933     fi
 934   ])
 935
 936 if test "${have_libpython}" != no; then
 937   AC_DEFINE(HAVE_PYTHON, 1, [Define if Python interpreter is being linked in.])
 938   CONFIG_OBS="$CONFIG_OBS \$(SUBDIR_PYTHON_OBS)"
 939   CONFIG_DEPS="$CONFIG_DEPS \$(SUBDIR_PYTHON_DEPS)"
 940   CONFIG_SRCS="$CONFIG_SRCS \$(SUBDIR_PYTHON_SRCS)"
 941   CONFIG_INSTALL="$CONFIG_INSTALL install-python"
 942   ENABLE_CFLAGS="$ENABLE_CFLAGS \$(SUBDIR_PYTHON_CFLAGS)"
 943
 944   if test -n "${with_python_libdir}"; then
 945     AC_DEFINE_UNQUOTED(WITH_PYTHON_LIBDIR, "${with_python_libdir}",
 946                        [Directory containing Python's standard libraries from --with-python-libdir.])
 947     GDB_AC_DEFINE_RELOCATABLE(PYTHON_LIBDIR, [python lib], ${with_python_libdir})
 948   fi
 949
 950   # Flags needed to compile Python code (taken from python-config --cflags).
 951   # We cannot call python-config directly because it will output whatever was
 952   # used when compiling the Python interpreter itself, including flags which
 953   # would make the python-related objects be compiled differently from the
 954   # rest of GDB (e.g., -O2 and -fPIC).
 955   if test "${GCC}" = yes; then
 956     tentative_python_cflags="-fno-strict-aliasing -fwrapv"
 957     # Python headers recommend -DNDEBUG, but it's unclear if that just
 958     # refers to building Python itself.  In release mode, though, it
 959     # doesn't hurt for the Python code in gdb to follow.
 960     $development || tentative_python_cflags="$tentative_python_cflags -DNDEBUG"
 961   fi
 962
 963   if test "x${tentative_python_cflags}" != x; then
 964     AC_MSG_CHECKING(compiler flags for python code)
 965     for flag in ${tentative_python_cflags}; do
 966       # Check that the compiler accepts it
 967       saved_CFLAGS="$CFLAGS"
 968       CFLAGS="$CFLAGS $flag"
 969       AC_COMPILE_IFELSE(
 970         [AC_LANG_PROGRAM([], [])],
 971         [PYTHON_CFLAGS="${PYTHON_CFLAGS} $flag"],
 972         []
 973       )
 974       CFLAGS="$saved_CFLAGS"
 975     done
 976     AC_MSG_RESULT(${PYTHON_CFLAGS})
 977   fi
 978
 979   # On x64 Windows, Python's include headers, and pyconfig.h in
 980   # particular, rely on MS_WIN64 macro to detect that it's a 64bit
 981   # version of Windows.  Unfortunately, MS_WIN64 is only defined if
 982   # _MSC_VER, a Microsoft-specific macro, is defined.  So, when
 983   # building on x64 Windows with GCC, we define MS_WIN64 ourselves.
 984   # The issue was reported to the Python community, but still isn't
 985   # solved as of 2012-10-02 (http://bugs.python.org/issue4709).
 986
 987   case "$gdb_host" in
 988     mingw64)
 989            if test "${GCC}" = yes; then
 990              CPPFLAGS="$CPPFLAGS -DMS_WIN64"
 991            fi
 992            ;;
 993   esac
 994 else
 995   # Even if Python support is not compiled in, we need to have this file
 996   # included so that the "python" command, et.al., still exists.
 997   CONFIG_OBS="$CONFIG_OBS python/python.o"
 998   CONFIG_SRCS="$CONFIG_SRCS python/python.c"
 999 fi
1000
1001 # Work around Python http://bugs.python.org/issue10112.  See also
1002 # http://bugs.python.org/issue11410, otherwise -Wl,--dynamic-list has
1003 # no effect.  Note that the only test after this that uses Python is
1004 # the -rdynamic/-Wl,--dynamic-list test, and we do want that one to be
1005 # run without -export-dynamic too.
1006 PYTHON_LIBS=`echo $PYTHON_LIBS | sed -e 's/-Xlinker -export-dynamic//'`
1007
1008 AC_SUBST(PYTHON_CFLAGS)
1009 AC_SUBST(PYTHON_CPPFLAGS)
1010 AC_SUBST(PYTHON_LIBS)
1011 AM_CONDITIONAL(HAVE_PYTHON, test "${have_libpython}" != no)
1012
1013 # -------------------- #
1014 # Check for libguile.  #
1015 # -------------------- #
1016
1017 dnl Utility to simplify finding libguile.
1018 dnl $1 = pkg-config-program
1019 dnl $2 = space-separate list of guile versions to try
1020 dnl $3 = yes|no, indicating whether to flag errors or ignore them
1021 dnl $4 = the shell variable to assign the result to
1022 dnl      If libguile is found we store "yes" here.
1023
1024 AC_DEFUN([AC_TRY_LIBGUILE],
1025 [
1026   pkg_config=$1
1027   guile_version_list=$2
1028   flag_errors=$3
1029   define([have_libguile_var],$4)
1030   found_usable_guile=checking
1031   AC_MSG_CHECKING([for usable guile from ${pkg_config}])
1032   for guile_version in ${guile_version_list}; do
1033     ${pkg_config} --exists ${guile_version} 2>/dev/null
1034     if test $? != 0; then
1035       continue
1036     fi
1037     dnl pkg-config says the package exists, so if we get an error now,
1038     dnl that's bad.
1039     new_CPPFLAGS=`${pkg_config} --cflags ${guile_version}`
1040     if test $? != 0; then
1041       AC_MSG_ERROR([failure running pkg-config --cflags ${guile_version}])
1042     fi
1043     new_LIBS=`${pkg_config} --libs ${guile_version}`
1044     if test $? != 0; then
1045       AC_MSG_ERROR([failure running pkg-config --libs ${guile_version}])
1046     fi
1047     dnl If we get this far, great.
1048     found_usable_guile=${guile_version}
1049     break
1050   done
1051   if test "${found_usable_guile}" = "checking"; then
1052     if test "${flag_errors}" = "yes"; then
1053       AC_MSG_ERROR([unable to find usable guile version from "${guile_version_list}"])
1054     else
1055       found_usable_guile=no
1056     fi
1057   fi
1058   dnl One final sanity check.
1059   dnl The user could have said --with-guile=python-2.7.
1060   if test "${found_usable_guile}" != no; then
1061     save_CPPFLAGS=$CPPFLAGS
1062     save_LIBS=$LIBS
1063     CPPFLAGS="$CPPFLAGS $new_CPPFLAGS"
1064     LIBS="$LIBS $new_LIBS"
1065     AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include "libguile.h"]],
1066                                    [[scm_init_guile ();]])],
1067                    [have_libguile_var=yes
1068                     GUILE_CPPFLAGS=$new_CPPFLAGS
1069                     GUILE_LIBS=$new_LIBS],
1070                    [found_usable_guile=no])
1071     dnl scm_set_automatic_finalization_enabled added in Guile 2.2.
1072     AC_CHECK_FUNC(scm_set_automatic_finalization_enabled,
1073       AC_DEFINE(HAVE_GUILE_MANUAL_FINALIZATION, 1,
1074                 [Define if Guile supports manual finalization.])
1075     )
1076     CPPFLAGS=$save_CPPFLAGS
1077     LIBS=$save_LIBS
1078     if test "${found_usable_guile}" = no; then
1079       if test "${flag_errors}" = yes; then
1080         AC_MSG_FAILURE([linking guile version ${guile_version} test program failed])
1081       fi
1082     fi
1083   fi
1084   AC_MSG_RESULT([${found_usable_guile}])
1085 ])
1086
1087 dnl There are several different values for --with-guile:
1088 dnl
1089 dnl no -   Don't include guile support.
1090 dnl yes -  Include guile support, error if it's missing.
1091 dnl        The pkg-config program must be in $PATH.
1092 dnl auto - Same as "yes", but if guile is missing from the system,
1093 dnl        fall back to "no".
1094 dnl guile-version [guile-version-choice-2 ...] -
1095 dnl        A space-separated list of guile package versions to try.
1096 dnl        These are passed to pkg-config as-is.
1097 dnl        E.g., guile-2.0 or guile-2.2-uninstalled
1098 dnl        This requires making sure PKG_CONFIG_PATH is set appropriately.
1099 dnl /path/to/pkg-config -
1100 dnl        Use this pkg-config program.
1101 dnl        NOTE: This needn't be the "real" pkg-config program.
1102 dnl        It could be a shell script.  It is invoked as:
1103 dnl        pkg-config --exists $version
1104 dnl        pkg-config --cflags $version
1105 dnl        pkg-config --libs $version
1106 dnl        pkg-config --variable guild $version
1107 dnl        The script will be called with $version having each value in
1108 dnl        $try_guile_versions until --exists indicates success.
1109
1110 AC_ARG_WITH(guile,
1111   AS_HELP_STRING([--with-guile@<:@=GUILE@:>@], [include guile support (auto/yes/no/<guile-version>/<pkg-config-program>)]),
1112   [], [with_guile=auto])
1113 AC_MSG_CHECKING([whether to use guile])
1114 AC_MSG_RESULT([$with_guile])
1115
1116 dnl We check guile with pkg-config.
1117 AC_PATH_PROG(pkg_config_prog_path, pkg-config, missing)
1118
1119 try_guile_versions="guile-3.0 guile-2.2 guile-2.0"
1120 have_libguile=no
1121 case "${with_guile}" in
1122 no)
1123   AC_MSG_WARN([guile support disabled; some features will be unavailable.])
1124   ;;
1125 auto)
1126   if test "${pkg_config_prog_path}" = "missing"; then
1127     AC_MSG_WARN([pkg-config not found, guile support disabled])
1128   else
1129     AC_TRY_LIBGUILE(${pkg_config_prog_path}, ${try_guile_versions}, no, have_libguile)
1130   fi
1131   ;;
1132 yes)
1133   if test "${pkg_config_prog_path}" = "missing"; then
1134     AC_MSG_ERROR([pkg-config not found])
1135   fi
1136   AC_TRY_LIBGUILE(${pkg_config_prog_path}, ${try_guile_versions}, yes, have_libguile)
1137   ;;
1138 [[\\/]]* | ?:[[\\/]]*)
1139   if test -x "${with_guile}"; then
1140     AC_TRY_LIBGUILE(${with_guile}, ${try_guile_versions}, yes, have_libguile)
1141   else
1142     AC_MSG_ERROR([Guile config program not executable: ${with_guile}])
1143   fi
1144   ;;
1145 "" | */*)
1146   # Disallow --with=guile="" and --with-guile=foo/bar.
1147   AC_MSG_ERROR([invalid value for --with-guile])
1148   ;;
1149 *)
1150   # A space separate list of guile versions to try, in order.
1151   if test "${pkg_config_prog_path}" = "missing"; then
1152     AC_MSG_ERROR([pkg-config not found])
1153   fi
1154   AC_TRY_LIBGUILE(${pkg_config_prog_path}, ${with_guile}, yes, have_libguile)
1155   ;;
1156 esac
1157
1158 if test "${have_libguile}" != no; then
1159   dnl Get the name of the 'guild' program.
1160   case "${with_guile}" in
1161   [[\\/]]* | ?:[[\\/]]*)
1162     GDB_GUILE_PROGRAM_NAMES(["${with_guile}"], ["${guile_version}"])
1163     ;;
1164   *)
1165     GDB_GUILE_PROGRAM_NAMES(["${pkg_config_prog_path}"], ["${guile_version}"])
1166     ;;
1167   esac
1168
1169   dnl Make sure guild can handle this host.
1170   GDB_TRY_GUILD([$srcdir/guile/lib/gdb/support.scm])
1171   dnl If not, disable guile support.
1172   if test "$ac_cv_guild_ok" = no; then
1173     have_libguile=no
1174     AC_MSG_WARN(disabling guile support, $GUILD fails compiling for $host)
1175   fi
1176 fi
1177
1178 if test "${have_libguile}" != no; then
1179   AC_DEFINE(HAVE_GUILE, 1, [Define if Guile interpreter is being linked in.])
1180   CONFIG_OBS="$CONFIG_OBS \$(SUBDIR_GUILE_OBS)"
1181   CONFIG_DEPS="$CONFIG_DEPS \$(SUBDIR_GUILE_DEPS)"
1182   CONFIG_SRCS="$CONFIG_SRCS \$(SUBDIR_GUILE_SRCS)"
1183   CONFIG_INSTALL="$CONFIG_INSTALL install-guile"
1184   ENABLE_CFLAGS="$ENABLE_CFLAGS \$(SUBDIR_GUILE_CFLAGS)"
1185
1186   dnl The 'scm_new_smob' function appeared in Guile 2.0.6.
1187   save_LIBS="$LIBS"
1188   save_CPPFLAGS="$CPPFLAGS"
1189   LIBS="$GUILE_LIBS"
1190   CPPFLAGS="$GUILE_CPPFLAGS"
1191   AC_CHECK_FUNCS([scm_new_smob])
1192   LIBS="$save_LIBS"
1193   CPPFLAGS="$save_CPPFLAGS"
1194 else
1195   # Even if Guile support is not compiled in, we need to have these files
1196   # included.
1197   CONFIG_OBS="$CONFIG_OBS guile/guile.o"
1198   CONFIG_SRCS="$CONFIG_SRCS guile/guile.c"
1199 fi
1200 AC_SUBST(GUILE_CPPFLAGS)
1201 AC_SUBST(GUILE_LIBS)
1202 AM_CONDITIONAL(HAVE_GUILE, test "${have_libguile}" != no)
1203
1204 # ---------------------------- #
1205 # Check for source highlight.  #
1206 # ---------------------------- #
1207
1208 SRCHIGH_LIBS=
1209 SRCHIGH_CFLAGS=
1210
1211 AC_ARG_ENABLE([source-highlight],
1212               [AS_HELP_STRING([--enable-source-highlight],
1213                               [enable source-highlight for source listings])],
1214               [GDB_CHECK_YES_NO_AUTO_VAL([$enableval], [--enable-source-highlight])],
1215               [enable_source_highlight=auto])
1216
1217 if test "${enable_source_highlight}" != "no"; then
1218   AC_MSG_CHECKING([for the source-highlight library])
1219   if test "${pkg_config_prog_path}" = "missing"; then
1220     AC_MSG_RESULT([no - pkg-config not found])
1221     if test "${enable_source_highlight}" = "yes"; then
1222       AC_MSG_ERROR([pkg-config was not found in your system])
1223     fi
1224   else
1225     if ${pkg_config_prog_path} --exists source-highlight; then
1226       case "$LDFLAGS" in
1227         *static-libstdc*)
1228           AC_MSG_ERROR([source highlight is incompatible with -static-libstdc++; dnl
1229 either use --disable-source-highlight or dnl
1230 --without-static-standard-libraries])
1231           ;;
1232       esac
1233
1234       srchigh_pkg_cflags=`${pkg_config_prog_path} --cflags source-highlight`
1235       srchigh_pkg_libs=`${pkg_config_prog_path} --libs source-highlight`
1236
1237       # Now that we have found a source-highlight library, check if we can use
1238       # it.  In particular, we're trying to detect the situation that the
1239       # library is using the new libstdc++ library abi ( see
1240       # https://gcc.gnu.org/onlinedocs/libstdc++/manual/using_dual_abi.html )
1241       # while the compiler being used to compile gdb is using the old abi.
1242       # Such a situation will result in an undefined reference to
1243       # srchilite::SourceHighlight::SourceHighlight(std::string const&).
1244       # This situation can occur for instance when using a source highlight
1245       # library compiled with g++ 7.5.0 while building gdb with g++ 4.8.5.
1246       AC_LANG_PUSH(C++)
1247       save_CXXFLAGS="$CXXFLAGS"
1248       save_LIBS="$LIBS"
1249       CXXFLAGS="$CXXFLAGS $srchigh_pkg_cflags"
1250       LIBS="$LIBS $srchigh_pkg_libs"
1251       AC_LINK_IFELSE(
1252         [AC_LANG_PROGRAM(
1253           [#include <srchilite/sourcehighlight.h>],
1254           [std::string outlang = "esc.outlang";
1255            new srchilite::SourceHighlight (outlang);]
1256         )],
1257         [have_usable_source_highlight=yes],
1258         [have_usable_source_highlight=no]
1259       )
1260       CXXFLAGS="$save_CXXFLAGS"
1261       LIBS="$save_LIBS"
1262       AC_LANG_POP(C++)
1263
1264       if test "${have_usable_source_highlight}" = "yes"; then
1265         AC_DEFINE([HAVE_SOURCE_HIGHLIGHT], 1,
1266                   [Define to 1 if the source-highlight library is available])
1267         AC_MSG_RESULT([yes])
1268         SRCHIGH_CFLAGS="$srchigh_pkg_cflags"
1269         SRCHIGH_LIBS="$srchigh_pkg_libs"
1270       else
1271         AC_MSG_RESULT([no])
1272         if test "${enable_source_highlight}" = "yes"; then
1273           AC_MSG_ERROR([source-highlight in your system could not be used])
1274         fi
1275       fi
1276     else
1277       AC_MSG_RESULT([no])
1278       if test "${enable_source_highlight}" = "yes"; then
1279         AC_MSG_ERROR([source-highlight was not found in your system])
1280       fi
1281     fi
1282   fi
1283 fi
1284 AC_SUBST(SRCHIGH_LIBS)
1285 AC_SUBST(SRCHIGH_CFLAGS)
1286
1287 # ------------------------- #
1288 # Checks for header files.  #
1289 # ------------------------- #
1290
1291 AC_HEADER_STDC
1292 # elf_hp.h is for HP/UX 64-bit shared library support.
1293 AC_CHECK_HEADERS([nlist.h machine/reg.h \
1294                   thread_db.h \
1295                   sys/file.h sys/filio.h sys/ioctl.h sys/param.h \
1296                   sys/procctl.h sys/resource.h sys/ptrace.h ptrace.h \
1297                   sys/reg.h sys/debugreg.h \
1298                   termios.h elf_hp.h])
1299 AC_CHECK_HEADERS(sys/user.h, [], [],
1300 [#if HAVE_SYS_PARAM_H
1301 # include <sys/param.h>
1302 #endif
1303 ])
1304
1305 AC_CHECK_HEADERS(curses.h cursesX.h ncurses.h ncursesw/ncurses.h ncurses/ncurses.h ncurses/term.h)
1306 AC_CHECK_HEADERS(term.h, [], [],
1307 [#if HAVE_CURSES_H
1308 # include <curses.h>
1309 #endif
1310 ])
1311
1312 AC_CHECK_HEADERS([sys/socket.h])
1313 AC_CHECK_HEADERS([ws2tcpip.h])
1314 AC_CHECK_HEADERS([execinfo.h])
1315
1316 # ------------------------- #
1317 # Checks for declarations.  #
1318 # ------------------------- #
1319
1320 libiberty_INIT
1321
1322 AC_CHECK_DECLS([snprintf])
1323 AM_LC_MESSAGES
1324
1325 # ------------------ #
1326 # Checks for types.  #
1327 # ------------------ #
1328
1329 AC_CHECK_TYPES(socklen_t, [], [],
1330 [#include <sys/types.h>
1331 #if HAVE_SYS_SOCKET_H
1332 # include <sys/socket.h>
1333 #elif HAVE_WS2TCPIP_H
1334 # include <ws2tcpip.h>
1335 #endif
1336 ])
1337
1338 # ------------------------------------- #
1339 # Checks for compiler characteristics.  #
1340 # ------------------------------------- #
1341
1342 AC_C_CONST
1343 AC_C_INLINE
1344 AC_C_BIGENDIAN
1345
1346 # ------------------------------ #
1347 # Checks for library functions.  #
1348 # ------------------------------ #
1349
1350 AC_CHECK_FUNCS([getuid getgid \
1351                 pread pread64 pwrite resize_term \
1352                 getpgid setsid \
1353                 sigsetmask \
1354                 ttrace wresize setlocale iconvlist libiconvlist btowc \
1355                 setrlimit getrlimit posix_madvise waitpid \
1356                 use_default_colors])
1357 AM_LANGINFO_CODESET
1358
1359 # Check the return and argument types of ptrace.
1360 GDB_AC_PTRACE
1361
1362 dnl AC_FUNC_SETPGRP does not work when cross compiling
1363 dnl Instead, assume we will have a prototype for setpgrp if cross compiling.
1364 if test "$cross_compiling" = no; then
1365   AC_FUNC_SETPGRP
1366 else
1367   AC_CACHE_CHECK(
1368     [whether setpgrp takes no argument],
1369     [ac_cv_func_setpgrp_void],
1370     [AC_COMPILE_IFELSE(
1371        [AC_LANG_PROGRAM(
1372           [#include <unistd.h>],
1373           [if (setpgrp(1,1) == -1)
1374              exit (0);
1375            else
1376              exit (1);]
1377         )],
1378        [ac_cv_func_setpgrp_void=no],
1379        [ac_cv_func_setpgrp_void=yes]
1380      )]
1381   )
1382 if test "$ac_cv_func_setpgrp_void" = yes; then
1383   AC_DEFINE(SETPGRP_VOID, 1)
1384 fi
1385 fi
1386
1387 # Check if <sys/proc.h> defines `struct thread' with a td_pcb member.
1388 AC_CHECK_MEMBERS([struct thread.td_pcb], [], [],
1389 [#include <sys/param.h>
1390 #include <sys/proc.h>
1391 ])
1392
1393 # See if <sys/lwp.h> defines `struct lwp`.
1394 AC_CACHE_CHECK(
1395   [for struct lwp],
1396   [gdb_cv_struct_lwp],
1397   [AC_COMPILE_IFELSE(
1398      [AC_LANG_PROGRAM(
1399         [#include <sys/param.h>
1400          #define _KMEMUSER
1401          #include <sys/lwp.h>],
1402         [struct lwp l;]
1403       )],
1404      [gdb_cv_struct_lwp=yes],
1405      [gdb_cv_struct_lwp=no]
1406    )]
1407 )
1408 if test "$gdb_cv_struct_lwp" = yes; then
1409   AC_DEFINE(HAVE_STRUCT_LWP, 1,
1410             [Define to 1 if your system has struct lwp.])
1411 fi
1412
1413 # See if <machine/reg.h> degines `struct reg'.
1414 AC_CACHE_CHECK(
1415   [for struct reg in machine/reg.h],
1416   [gdb_cv_struct_reg],
1417   [AC_COMPILE_IFELSE(
1418      [AC_LANG_PROGRAM(
1419         [#include <sys/types.h>
1420          #include <machine/reg.h>],
1421         [struct reg r;]
1422       )],
1423      [gdb_cv_struct_reg=yes],
1424      [gdb_cv_struct_reg=no]
1425    )]
1426 )
1427 if test "$gdb_cv_struct_reg" = yes; then
1428   AC_DEFINE(HAVE_STRUCT_REG, 1,
1429             [Define to 1 if your system has struct reg in <machine/reg.h>.])
1430 fi
1431
1432 # See if <machine/reg.h> supports the %fs and %gs i386 segment registers.
1433 # Older i386 BSD's don't have the r_fs and r_gs members of `struct reg'.
1434 AC_CHECK_MEMBERS([struct reg.r_fs, struct reg.r_gs], [], [],
1435                  [#include <sys/types.h>
1436 #include <machine/reg.h>])
1437
1438 # See if <sys/ptrace.h> provides the PTRACE_GETREGS request.
1439 AC_MSG_CHECKING(for PTRACE_GETREGS)
1440 AC_CACHE_VAL(
1441   [gdb_cv_have_ptrace_getregs],
1442   [AC_COMPILE_IFELSE(
1443     [AC_LANG_PROGRAM([#include <sys/ptrace.h>], [PTRACE_GETREGS;])],
1444     [gdb_cv_have_ptrace_getregs=yes],
1445     [gdb_cv_have_ptrace_getregs=no]
1446    )]
1447 )
1448 AC_MSG_RESULT($gdb_cv_have_ptrace_getregs)
1449 if test "$gdb_cv_have_ptrace_getregs" = yes; then
1450   AC_DEFINE(HAVE_PTRACE_GETREGS, 1,
1451   [Define if sys/ptrace.h defines the PTRACE_GETREGS request.])
1452 fi
1453
1454 # See if <sys/ptrace.h> provides the PTRACE_GETFPXREGS request.
1455 AC_MSG_CHECKING(for PTRACE_GETFPXREGS)
1456 AC_CACHE_VAL(
1457   [gdb_cv_have_ptrace_getfpxregs],
1458   [AC_COMPILE_IFELSE(
1459      [AC_LANG_PROGRAM([#include <sys/ptrace.h>], [PTRACE_GETFPXREGS;])],
1460      [gdb_cv_have_ptrace_getfpxregs=yes],
1461      [gdb_cv_have_ptrace_getfpxregs=no]
1462    )]
1463 )
1464 AC_MSG_RESULT($gdb_cv_have_ptrace_getfpxregs)
1465 if test "$gdb_cv_have_ptrace_getfpxregs" = yes; then
1466   AC_DEFINE(HAVE_PTRACE_GETFPXREGS, 1,
1467   [Define if sys/ptrace.h defines the PTRACE_GETFPXREGS request.])
1468 fi
1469
1470 # See if <sys/ptrace.h> provides the PT_GETDBREGS request.
1471 AC_MSG_CHECKING(for PT_GETDBREGS)
1472 AC_CACHE_VAL(
1473   [gdb_cv_have_pt_getdbregs],
1474   [AC_COMPILE_IFELSE(
1475      [AC_LANG_PROGRAM(
1476         [#include <sys/types.h>
1477          #include <sys/ptrace.h>],
1478         [PT_GETDBREGS;]
1479       )],
1480      [gdb_cv_have_pt_getdbregs=yes],
1481      [gdb_cv_have_pt_getdbregs=no]
1482    )]
1483 )
1484 AC_MSG_RESULT($gdb_cv_have_pt_getdbregs)
1485 if test "$gdb_cv_have_pt_getdbregs" = yes; then
1486   AC_DEFINE(HAVE_PT_GETDBREGS, 1,
1487   [Define if sys/ptrace.h defines the PT_GETDBREGS request.])
1488 fi
1489
1490 # See if <sys/ptrace.h> supports LWP names on FreeBSD
1491 # Older FreeBSD versions don't have the pl_tdname member of
1492 # `struct ptrace_lwpinfo'.
1493 AC_CHECK_MEMBERS([struct ptrace_lwpinfo.pl_tdname], [], [],
1494                  [#include <sys/ptrace.h>])
1495
1496 # See if <sys/ptrace.h> supports syscall fields on FreeBSD.  The
1497 # pl_syscall_code member of `struct ptrace_lwpinfo' was added in
1498 # FreeBSD 10.3.
1499 AC_CHECK_MEMBERS([struct ptrace_lwpinfo.pl_syscall_code], [], [],
1500                  [#include <sys/ptrace.h>])
1501
1502 # Check if the compiler supports the `long long' type.
1503
1504 AC_CACHE_CHECK([for long long support in compiler], gdb_cv_c_long_long,
1505                [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1506 [[extern long long foo;]],
1507 [[switch (foo & 2) { case 0: return 1; }]])],
1508                                   gdb_cv_c_long_long=yes,
1509                                   gdb_cv_c_long_long=no)])
1510 if test "$gdb_cv_c_long_long" != yes; then
1511   # libdecnumber requires long long.
1512   AC_MSG_ERROR([Compiler must support long long for GDB.])
1513 fi
1514
1515 # Check if the compiler and runtime support printing decfloats.
1516
1517 AC_CACHE_CHECK([for decfloat support in printf],
1518                gdb_cv_printf_has_decfloat,
1519                [AC_RUN_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT],
1520 [[char buf[64];
1521   _Decimal32 d32 = 1.2345df;
1522   _Decimal64 d64 = 1.2345dd;
1523   _Decimal128 d128 = 1.2345dl;
1524   sprintf (buf, "Decimal32: %H\nDecimal64: %D\nDecimal128: %DD", d32, d64, d128);
1525   return (strcmp ("Decimal32: 1.2345\nDecimal64: 1.2345\nDecimal128: 1.2345", buf));]])],
1526                               gdb_cv_printf_has_decfloat=yes,
1527                               gdb_cv_printf_has_decfloat=no,
1528                               gdb_cv_printf_has_decfloat=no)])
1529 if test "$gdb_cv_printf_has_decfloat" = yes; then
1530   AC_DEFINE(PRINTF_HAS_DECFLOAT, 1,
1531             [Define to 1 if the "%H, %D and %DD" formats work to print decfloats.])
1532 fi
1533
1534 # Check if the compiler supports the `long double' type.  We can't use
1535 # AC_C_LONG_DOUBLE because that one does additional checks on the
1536 # constants defined in <float.h> that fail on some systems,
1537 # e.g. FreeBSD/i386 4.7 and OpenBSD/i386 3.6.
1538
1539 AC_CACHE_CHECK([for long double support in compiler], gdb_cv_c_long_double,
1540                [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[long double foo;]])],
1541                                   gdb_cv_c_long_double=yes,
1542                                   gdb_cv_c_long_double=no)])
1543 if test "$gdb_cv_c_long_double" = yes; then
1544   AC_DEFINE(HAVE_LONG_DOUBLE, 1,
1545            [Define to 1 if the compiler supports long double.])
1546 fi
1547
1548 # Check if the compiler and runtime support printing long doubles.
1549
1550 AC_CACHE_CHECK([for long double support in printf],
1551                gdb_cv_printf_has_long_double,
1552                [AC_RUN_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT],
1553 [[char buf[16];
1554   long double f = 3.141592653;
1555   sprintf (buf, "%Lg", f);
1556   return (strncmp ("3.14159", buf, 7));]])],
1557                               gdb_cv_printf_has_long_double=yes,
1558                               gdb_cv_printf_has_long_double=no,
1559                               gdb_cv_printf_has_long_double=no)])
1560 if test "$gdb_cv_printf_has_long_double" = yes; then
1561   AC_DEFINE(PRINTF_HAS_LONG_DOUBLE, 1,
1562             [Define to 1 if the "%Lg" format works to print long doubles.])
1563 fi
1564
1565 # Check if the compiler and runtime support scanning long doubles.
1566
1567 AC_CACHE_CHECK([for long double support in scanf],
1568                gdb_cv_scanf_has_long_double,
1569                [AC_RUN_IFELSE([AC_LANG_PROGRAM(
1570 [[#include <stdio.h>]],
1571 [[char *buf = "3.141592653";
1572   long double f = 0;
1573   sscanf (buf, "%Lg", &f);
1574   return !(f > 3.14159 && f < 3.14160);]])],
1575                               gdb_cv_scanf_has_long_double=yes,
1576                               gdb_cv_scanf_has_long_double=no,
1577                               gdb_cv_scanf_has_long_double=no)])
1578 if test "$gdb_cv_scanf_has_long_double" = yes; then
1579   AC_DEFINE(SCANF_HAS_LONG_DOUBLE, 1,
1580             [Define to 1 if the "%Lg" format works to scan long doubles.])
1581 fi
1582
1583 case ${host_os} in
1584 aix*)
1585   AC_CACHE_CHECK(
1586     [for -bbigtoc option], [gdb_cv_bigtoc],
1587     [SAVE_LDFLAGS=$LDFLAGS
1588
1589      case $GCC in
1590        yes) gdb_cv_bigtoc=-Wl,-bbigtoc ;;
1591        *) gdb_cv_bigtoc=-bbigtoc ;;
1592      esac
1593
1594      LDFLAGS=$LDFLAGS\ $gdb_cv_bigtoc
1595      AC_LINK_IFELSE(
1596        [AC_LANG_PROGRAM([], [int i;])],
1597        [],
1598        [gdb_cv_bigtoc=]
1599      )
1600      LDFLAGS="${SAVE_LDFLAGS}"]
1601   )
1602   CONFIG_LDFLAGS="${CONFIG_LDFLAGS} ${gdb_cv_bigtoc}"
1603   ;;
1604 esac
1605
1606 AC_MSG_CHECKING(for the dynamic export flag)
1607 dynamic_list=false
1608 if test "${gdb_native}" = yes; then
1609    # The dynamically loaded libthread_db needs access to symbols in the gdb
1610    # executable.  Older GNU ld supports --export-dynamic but --dynamic-list
1611    # may not be supported there.
1612    old_LDFLAGS="$LDFLAGS"
1613    # Older GNU ld supports --export-dynamic but --dynamic-list it does not.
1614    RDYNAMIC="-Wl,--dynamic-list=${srcdir}/proc-service.list"
1615    LDFLAGS="$LDFLAGS $RDYNAMIC"
1616    if test "${have_libpython}" = no; then
1617      AC_LINK_IFELSE(
1618        [AC_LANG_PROGRAM([], [])],
1619        [dynamic_list=true],
1620        []
1621      )
1622    else
1623      # Workaround http://bugs.python.org/issue4434 where static
1624      # libpythonX.Y.a would get its symbols required for
1625      # pythonX.Y/lib-dynload/*.so modules hidden by -Wl,--dynamic-list.
1626      # Problem does not happen for the recommended libpythonX.Y.so linkage.
1627
1628      # Note the workaround for Python
1629      # http://bugs.python.org/issue10112 earlier has removed
1630      # -export-dynamic from PYTHON_LIBS.  That's exactly what we want
1631      # here too, as otherwise it'd make this -Wl,--dynamic-list test
1632      # always pass.
1633      old_CFLAGS="$CFLAGS"
1634      CFLAGS="$CFLAGS $PYTHON_CFLAGS"
1635      old_LIBS="$LIBS"
1636      LIBS="$LIBS $PYTHON_LIBS"
1637      old_CPPFLAGS="$CPPFLAGS"
1638      CPPFLAGS="$CPPFLAGS $PYTHON_CPPFLAGS"
1639      AC_RUN_IFELSE(
1640        [AC_LANG_PROGRAM(
1641          [#include "Python.h"],
1642          [int err;
1643           Py_Initialize ();
1644           err = PyRun_SimpleString ("import ctypes\n");
1645           Py_Finalize ();
1646           return err == 0 ? 0 : 1;])],
1647        [dynamic_list=true], [], [true])
1648      LIBS="$old_LIBS"
1649      CFLAGS="$old_CFLAGS"
1650      CPPFLAGS="$old_CPPFLAGS"
1651    fi
1652    LDFLAGS="$old_LDFLAGS"
1653 fi
1654 if $dynamic_list; then
1655   found="-Wl,--dynamic-list"
1656   RDYNAMIC='-Wl,--dynamic-list=$(srcdir)/proc-service.list'
1657 else
1658   found="-rdynamic"
1659   RDYNAMIC="-rdynamic"
1660 fi
1661 AC_SUBST(RDYNAMIC)
1662 AC_MSG_RESULT($found)
1663
1664 AC_CACHE_CHECK(
1665   [whether execinfo.h backtrace is available],
1666   gdb_cv_execinfo_backtrace,
1667   [AC_LINK_IFELSE(
1668      [AC_LANG_PROGRAM(
1669         [
1670          #include <execinfo.h>
1671         ],
1672         [
1673          int f;
1674          void *b[[2]];
1675          f = backtrace (b, 2);
1676          backtrace_symbols_fd (b, f, 2);
1677         ])],
1678    [gdb_cv_execinfo_backtrace=yes],
1679    [gdb_cv_execinfo_backtrace=no])])
1680 if test "$gdb_cv_execinfo_backtrace" = yes; then
1681   AC_DEFINE(HAVE_EXECINFO_BACKTRACE, 1,
1682             [Define to 1 if execinfo.h backtrace functions are available.])
1683 fi
1684
1685 dnl For certain native configurations, we need to check whether thread
1686 dnl support can be built in or not.
1687 dnl
1688 dnl Note that we only want this if we are both native (host == target),
1689 dnl and not doing a canadian cross build (build == host).
1690
1691 if test "${build}" = "${host}" -a "${host}" = "${target}" ; then
1692    case ${host_os} in
1693    aix*)
1694       AC_MSG_CHECKING(for AiX thread debugging library)
1695       AC_CACHE_VAL(
1696         [gdb_cv_have_aix_thread_debug],
1697         [AC_COMPILE_IFELSE(
1698            [AC_LANG_PROGRAM(
1699               [#include <sys/pthdebug.h>],
1700               [#ifndef PTHDB_VERSION_3
1701                #error
1702                #endif]
1703             )],
1704            [gdb_cv_have_aix_thread_debug=yes],
1705            [gdb_cv_have_aix_thread_debug=no]
1706          )]
1707       )
1708       AC_MSG_RESULT($gdb_cv_have_aix_thread_debug)
1709       if test "$gdb_cv_have_aix_thread_debug" = yes; then
1710          CONFIG_SRCS="${CONFIG_SRCS} aix-thread.c"
1711          CONFIG_OBS="${CONFIG_OBS} aix-thread.o"
1712          LIBS="$LIBS -lpthdebug"
1713
1714          # Older versions of AIX do not provide the declaration for
1715          # the getthrds function (it appears that it was introduced
1716          # with AIX 6.x).
1717          AC_CHECK_DECLS(getthrds, [], [], [[#include <procinfo.h>]])
1718       fi
1719       ;;
1720    esac
1721    AC_SUBST(CONFIG_LDFLAGS)
1722 fi
1723
1724 dnl See if we have a thread_db header file that has TD_NOTALLOC and
1725 dnl other error codes.
1726 if test "x$ac_cv_header_thread_db_h" = "xyes"; then
1727   AC_CACHE_CHECK(
1728     [whether <thread_db.h> has TD_NOTALLOC],
1729     [gdb_cv_thread_db_h_has_td_notalloc],
1730     [AC_COMPILE_IFELSE(
1731        [AC_LANG_PROGRAM(
1732           [#include <thread_db.h>],
1733           [int i = TD_NOTALLOC;]
1734         )],
1735        [gdb_cv_thread_db_h_has_td_notalloc=yes],
1736        [gdb_cv_thread_db_h_has_td_notalloc=no]
1737      )]
1738   )
1739
1740   AC_CACHE_CHECK(
1741     [whether <thread_db.h> has TD_VERSION],
1742     [gdb_cv_thread_db_h_has_td_version],
1743     [AC_COMPILE_IFELSE(
1744        [AC_LANG_PROGRAM(
1745           [#include <thread_db.h>],
1746           [int i = TD_VERSION;]
1747         )],
1748        [gdb_cv_thread_db_h_has_td_version=yes],
1749        [gdb_cv_thread_db_h_has_td_version=no]
1750      )]
1751   )
1752
1753   AC_CACHE_CHECK(
1754     [whether <thread_db.h> has TD_NOTLS],
1755     [gdb_cv_thread_db_h_has_td_notls],
1756     [AC_COMPILE_IFELSE(
1757        [AC_LANG_PROGRAM(
1758           [#include <thread_db.h>],
1759           [int i = TD_NOTLS;]
1760         )],
1761        [gdb_cv_thread_db_h_has_td_notls=yes],
1762        [gdb_cv_thread_db_h_has_td_notls=no]
1763      )]
1764   )
1765 fi
1766 if test "x$gdb_cv_thread_db_h_has_td_notalloc" = "xyes"; then
1767   AC_DEFINE(THREAD_DB_HAS_TD_NOTALLOC, 1,
1768             [Define if <thread_db.h> has the TD_NOTALLOC error code.])
1769 fi
1770 if test "x$gdb_cv_thread_db_h_has_td_version" = "xyes"; then
1771   AC_DEFINE(THREAD_DB_HAS_TD_VERSION, 1,
1772             [Define if <thread_db.h> has the TD_VERSION error code.])
1773 fi
1774 if test "x$gdb_cv_thread_db_h_has_td_notls" = "xyes"; then
1775   AC_DEFINE(THREAD_DB_HAS_TD_NOTLS, 1,
1776             [Define if <thread_db.h> has the TD_NOTLS error code.])
1777 fi
1778
1779 dnl Set the host's .gdbinit filename.
1780 case $host_os in
1781   go32* | *djgpp*)
1782     gdbinit=gdb.ini
1783     ;;
1784   *)
1785     gdbinit=.gdbinit
1786     ;;
1787 esac
1788 AC_DEFINE_UNQUOTED(GDBINIT,"$gdbinit",[The .gdbinit filename.])
1789
1790 dnl Set the host's .gdbearlyinit filename
1791 AC_DEFINE_UNQUOTED(GDBEARLYINIT,".gdbearlyinit",[The .gdbearlyinit filename.])
1792
1793 dnl Handle optional features that can be enabled.
1794
1795 # Support for --with-sysroot is a copy of GDB_AC_WITH_DIR,
1796 # except that the argument to --with-sysroot is optional.
1797 # --with-sysroot (or --with-sysroot=yes) sets the default sysroot path.
1798 if test "x$with_sysroot" = xyes; then
1799   with_sysroot="${exec_prefix}/${target_alias}/sys-root"
1800 fi
1801 AC_ARG_WITH(sysroot,
1802   AS_HELP_STRING([--with-sysroot@<:@=DIR@:>@],
1803                  [search for usr/lib et al within DIR]),
1804   [TARGET_SYSTEM_ROOT=$withval], [TARGET_SYSTEM_ROOT=])
1805 AC_DEFINE_DIR(TARGET_SYSTEM_ROOT, TARGET_SYSTEM_ROOT,
1806               [search for usr/lib et al within DIR])
1807 AC_SUBST(TARGET_SYSTEM_ROOT)
1808 GDB_AC_DEFINE_RELOCATABLE(TARGET_SYSTEM_ROOT, sysroot, ${ac_define_dir})
1809
1810 GDB_AC_WITH_DIR(SYSTEM_GDBINIT, system-gdbinit,
1811     [automatically load a system-wide gdbinit file],
1812     [])
1813 GDB_AC_WITH_DIR(SYSTEM_GDBINIT_DIR, system-gdbinit-dir,
1814     [automatically load system-wide gdbinit files from this directory],
1815     [])
1816
1817 AM_GDB_COMPILER_TYPE
1818 AM_GDB_WARNINGS
1819 AM_GDB_UBSAN
1820
1821 # In the Cygwin environment, we need some additional flags.
1822 AC_CACHE_CHECK([for cygwin], gdb_cv_os_cygwin,
1823 [AC_EGREP_CPP(^lose$, [
1824 #if defined (__CYGWIN__) || defined (__CYGWIN32__)
1825 lose
1826 #endif],[gdb_cv_os_cygwin=yes],[gdb_cv_os_cygwin=no])])
1827
1828
1829 dnl Figure out which of the many generic ser-*.c files the _host_ supports.
1830 SER_HARDWIRE="ser-base.o ser-unix.o ser-pipe.o ser-tcp.o"
1831 case ${host} in
1832   *go32* ) SER_HARDWIRE=ser-go32.o ;;
1833   *djgpp* ) SER_HARDWIRE=ser-go32.o ;;
1834   *mingw32*) SER_HARDWIRE="ser-base.o ser-tcp.o ser-mingw.o" ;;
1835   *) SER_HARDWIRE="$SER_HARDWIRE ser-uds.o" ;;
1836 esac
1837 AC_SUBST(SER_HARDWIRE)
1838
1839 # libreadline needs libuser32.a in a cygwin environment
1840 WIN32LIBS=
1841 if test x"$gdb_cv_os_cygwin" = xyes; then
1842     WIN32LIBS="-luser32"
1843     case "${target}" in
1844         *cygwin*) WIN32LIBS="$WIN32LIBS -limagehlp"
1845         ;;
1846     esac
1847 fi
1848
1849 # The ser-tcp.c module requires sockets.
1850 # Note that WIN32APILIBS is set by GDB_AC_COMMON.
1851 WIN32LIBS="$WIN32LIBS $WIN32APILIBS"
1852
1853 # Add ELF support to GDB, but only if BFD includes ELF support.
1854 GDB_AC_CHECK_BFD([for ELF support in BFD], gdb_cv_var_elf,
1855                  [bfd_get_elf_phdr_upper_bound (NULL)], elf-bfd.h)
1856 if test "$gdb_cv_var_elf" = yes; then
1857   CONFIG_OBS="$CONFIG_OBS elfread.o stap-probe.o dtrace-probe.o \
1858                 gcore-elf.o elf-none-tdep.o"
1859   AC_DEFINE(HAVE_ELF, 1,
1860             [Define if ELF support should be included.])
1861   # -ldl is provided by bfd/Makfile.am (LIBDL) <PLUGINS>.
1862   if test "$plugins" = "yes"; then
1863     AC_SEARCH_LIBS(dlopen, dl)
1864   fi
1865 fi
1866
1867 # Add macho support to GDB, but only if BFD includes it.
1868 GDB_AC_CHECK_BFD([for Mach-O support in BFD], gdb_cv_var_macho,
1869                  [bfd_mach_o_lookup_command (NULL, 0, NULL)], mach-o.h)
1870 if test "$gdb_cv_var_macho" = yes; then
1871   CONFIG_OBS="$CONFIG_OBS machoread.o"
1872 fi
1873
1874 # Add any host-specific objects to GDB.
1875 CONFIG_OBS="${CONFIG_OBS} ${gdb_host_obs}"
1876
1877 # If building on ELF, look for lzma support for embedded compressed debug info.
1878 if test "$gdb_cv_var_elf" = yes; then
1879   AC_ARG_WITH(lzma,
1880     AS_HELP_STRING([--with-lzma], [support lzma compression (auto/yes/no)]),
1881     [], [with_lzma=auto])
1882   AC_MSG_CHECKING([whether to use lzma])
1883   AC_MSG_RESULT([$with_lzma])
1884
1885   if test "${with_lzma}" != no; then
1886     AC_LIB_HAVE_LINKFLAGS([lzma], [], [#include "lzma.h"],
1887                           [lzma_index_iter iter;
1888                            lzma_index_iter_init (&iter, 0);
1889                            lzma_mf_is_supported (LZMA_MF_HC3);])
1890     if test "$HAVE_LIBLZMA" != yes; then
1891       if test "$with_lzma" = yes; then
1892         AC_MSG_ERROR([missing liblzma for --with-lzma])
1893       fi
1894     fi
1895   fi
1896 fi
1897
1898 LIBGUI="../libgui/src/libgui.a"
1899 GUI_CFLAGS_X="-I${srcdir}/../libgui/src"
1900 AC_SUBST(LIBGUI)
1901 AC_SUBST(GUI_CFLAGS_X)
1902
1903 WIN32LDAPP=
1904 AC_SUBST(WIN32LIBS)
1905 AC_SUBST(WIN32LDAPP)
1906
1907 case "${host}" in
1908 *-*-cygwin* | *-*-mingw* )
1909     configdir="win"
1910     ;;
1911 *)
1912     configdir="unix"
1913     ;;
1914 esac
1915
1916 GDBTKLIBS=
1917 if test "${enable_gdbtk}" = "yes"; then
1918
1919     # Gdbtk must have an absolute path to srcdir in order to run
1920     # properly when not installed.
1921     here=`pwd`
1922     cd ${srcdir}
1923     GDBTK_SRC_DIR=`pwd`
1924     cd $here
1925
1926     SC_PATH_TCLCONFIG
1927
1928     # If $no_tk is nonempty, then we can't do Tk, and there is no
1929     # point to doing Tcl.
1930     SC_PATH_TKCONFIG
1931
1932     if test -z "${no_tcl}" -a -z "${no_tk}"; then
1933         SC_LOAD_TCLCONFIG
1934
1935         # Check for in-tree tcl
1936         here=`pwd`
1937         cd ${srcdir}/..
1938         topdir=`pwd`
1939         cd ${here}
1940
1941         intree="no"
1942         if test "${TCL_SRC_DIR}" = "${topdir}/tcl"; then
1943           intree="yes"
1944         fi
1945
1946         # Find Tcl private headers
1947         if test x"${intree}" = xno; then
1948           CY_AC_TCL_PRIVATE_HEADERS
1949           TCL_INCLUDE="${TCL_INCLUDE_SPEC} ${TCL_PRIVATE_INCLUDE}"
1950           TCL_LIBRARY="${TCL_LIB_SPEC}"
1951           TCL_DEPS=""
1952         else
1953           # If building tcl in the same src tree, private headers
1954           # are not needed, but we need to be sure to use the right
1955           # headers library
1956           TCL_INCLUDE="-I${TCL_SRC_DIR}/generic"
1957           TCL_LIBRARY="${TCL_BUILD_LIB_SPEC}"
1958           TCL_DEPS="../tcl/${configdir}${TCL_LIB_FILE}"
1959         fi
1960         AC_SUBST(TCL_INCLUDE)
1961         AC_SUBST(TCL_LIBRARY)
1962         AC_SUBST(TCL_DEPS)
1963
1964         SC_LOAD_TKCONFIG
1965
1966         # Check for in-tree Tk
1967         intree="no"
1968         if test "${TK_SRC_DIR}" = "${topdir}/tk"; then
1969           intree="yes"
1970         fi
1971
1972         # Find Tk private headers
1973         if test x"${intree}" = xno; then
1974           CY_AC_TK_PRIVATE_HEADERS
1975           TK_INCLUDE="${TK_INCLUDE_SPEC} ${TK_PRIVATE_INCLUDE}"
1976           TK_LIBRARY=${TK_LIB_SPEC}
1977           TK_DEPS=""
1978         else
1979           TK_INCLUDE="-I${TK_SRC_DIR}/generic"
1980           TK_LIBRARY="${TK_BUILD_LIB_SPEC}"
1981           TK_DEPS="../tk/${configdir}/${TK_LIB_FILE}"
1982         fi
1983         AC_SUBST(TK_INCLUDE)
1984         AC_SUBST(TK_LIBRARY)
1985         AC_SUBST(TK_DEPS)
1986         AC_SUBST(TK_XINCLUDES)
1987
1988         ENABLE_CFLAGS="${ENABLE_CFLAGS} \$(SUBDIR_GDBTK_CFLAGS)"
1989
1990         # Include some libraries that Tcl and Tk want.
1991         TCL_LIBS='$(LIBGUI) $(TK) $(TCL) $(X11_LDFLAGS) $(X11_LIBS)'
1992         # Yes, the ordering seems wrong here.  But it isn't.
1993         # TK_LIBS is the list of libraries that need to be linked
1994         # after Tcl/Tk.  Note that this isn't put into LIBS.  If it
1995         # were in LIBS then any link tests after this point would
1996         # try to include things like `$(LIBGUI)', which wouldn't work.
1997         GDBTKLIBS="${TCL_LIBS} ${TK_LIBS}"
1998
1999         CONFIG_OBS="${CONFIG_OBS} \$(SUBDIR_GDBTK_OBS)"
2000         CONFIG_DEPS="${CONFIG_DEPS} \$(SUBDIR_GDBTK_DEPS)"
2001         CONFIG_SRCS="${CONFIG_SRCS} \$(SUBDIR_GDBTK_SRCS)"
2002         CONFIG_ALL="${CONFIG_ALL} all-gdbtk"
2003         CONFIG_CLEAN="${CONFIG_CLEAN} clean-gdbtk"
2004         CONFIG_INSTALL="${CONFIG_INSTALL} install-gdbtk"
2005         CONFIG_UNINSTALL="${CONFIG_UNINSTALL} uninstall-gdbtk"
2006
2007         if test x"$gdb_cv_os_cygwin" = xyes; then
2008           WIN32LIBS="${WIN32LIBS} -lshell32 -lgdi32 -lcomdlg32 -ladvapi32"
2009           WIN32LDAPP="-Wl,--subsystem,console"
2010           CONFIG_OBS="${CONFIG_OBS} gdbres.o"
2011         fi
2012
2013         AC_CONFIG_SUBDIRS(gdbtk)
2014     fi
2015 fi
2016
2017 AC_SUBST(X_CFLAGS)
2018 AC_SUBST(X_LDFLAGS)
2019 AC_SUBST(X_LIBS)
2020 AC_SUBST(GDBTKLIBS)
2021 AC_SUBST(GDBTK_CFLAGS)
2022 AC_SUBST(GDBTK_SRC_DIR)
2023
2024 AC_PATH_X
2025
2026 # Unlike the sim directory, whether a simulator is linked is controlled by
2027 # presence of a gdb_sim definition in the target configure.tgt entry.
2028 # This code just checks for a few cases where we'd like to ignore those
2029 # definitions, even when they're present in the '.mt' file.  These cases
2030 # are when --disable-sim is specified, or if the simulator directory is
2031 # not part of the source tree.
2032 #
2033 AC_ARG_ENABLE(sim,
2034 AS_HELP_STRING([--enable-sim], [link gdb with simulator]),
2035 [echo "enable_sim = $enable_sim";
2036  echo "enableval = ${enableval}";
2037  case "${enableval}" in
2038   yes) ignore_sim=false ;;
2039   no)  ignore_sim=true ;;
2040   *)   ignore_sim=false ;;
2041  esac],
2042 [ignore_sim=false])
2043
2044 if test ! -d "${srcdir}/../sim"; then
2045   ignore_sim=true
2046 fi
2047
2048 SIM=
2049 SIM_OBS=
2050 if test "${ignore_sim}" = "false"; then
2051   if test x"${gdb_sim}" != x ; then
2052     SIM="${gdb_sim}"
2053     SIM_OBS="remote-sim.o"
2054
2055     # Some tdep code should only be compiled in when the ppc sim is
2056     # built.  PR sim/13418.
2057     case $target in
2058       powerpc*-*-*)
2059         AC_DEFINE(WITH_PPC_SIM, 1, [Define if the PPC simulator is being linked in.])
2060         ;;
2061     esac
2062   fi
2063 fi
2064 AC_SUBST(SIM)
2065 AC_SUBST(SIM_OBS)
2066
2067 AC_SUBST(ENABLE_CFLAGS)
2068 AC_SUBST(PROFILE_CFLAGS)
2069
2070 AC_SUBST(CONFIG_OBS)
2071 AC_SUBST(CONFIG_DEPS)
2072 AC_SUBST(CONFIG_SRCS)
2073 AC_SUBST(CONFIG_ALL)
2074 AC_SUBST(CONFIG_CLEAN)
2075 AC_SUBST(CONFIG_INSTALL)
2076 AC_SUBST(CONFIG_UNINSTALL)
2077
2078 # List of host floatformats.
2079 AC_DEFINE_UNQUOTED(GDB_HOST_FLOAT_FORMAT,$gdb_host_float_format,[Host float floatformat])
2080 AC_DEFINE_UNQUOTED(GDB_HOST_DOUBLE_FORMAT,$gdb_host_double_format,[Host double floatformat])
2081 AC_DEFINE_UNQUOTED(GDB_HOST_LONG_DOUBLE_FORMAT,$gdb_host_long_double_format,[Host long double floatformat])
2082
2083 # target_subdir is used by the testsuite to find the target libraries.
2084 target_subdir=
2085 if test "${host}" != "${target}"; then
2086     target_subdir="${target_alias}/"
2087 fi
2088 AC_SUBST(target_subdir)
2089
2090 # Import nat definitions.
2091 nat_makefile_frag=/dev/null
2092 if test "${gdb_native}" = "yes"; then
2093   . ${srcdir}/configure.nat
2094   nativefile=$NAT_FILE
2095 fi
2096
2097 AC_SUBST(NAT_FILE)
2098 AC_SUBST(NATDEPFILES)
2099 AC_SUBST(NAT_CDEPS)
2100 AC_SUBST(LOADLIBES)
2101 AC_SUBST(MH_CFLAGS)
2102 AC_SUBST(XM_CLIBS)
2103 AC_SUBST(NAT_GENERATED_FILES)
2104 AC_SUBST(HAVE_NATIVE_GCORE_HOST)
2105 AC_SUBST_FILE(nat_makefile_frag)
2106
2107 if test x"${gdb_osabi}" != x ; then
2108     AC_DEFINE_UNQUOTED(GDB_OSABI_DEFAULT, $gdb_osabi,
2109                        [Define to the default OS ABI for this configuration.])
2110 fi
2111
2112 # Setup possible use of libbacktrace.
2113 AC_ARG_ENABLE([libbacktrace],
2114               [AS_HELP_STRING([--enable-libbacktrace],
2115                               [use libbacktrace to write a backtrace after a fatal signal.])],
2116               [GDB_CHECK_YES_NO_VAL([$enableval], [--enable-libbacktrace])],
2117               [enable_libbacktrace=yes])
2118
2119 if test "${enable_libbacktrace}" = "yes"; then
2120   LIBBACKTRACE_INC="-I$srcdir/../libbacktrace/ -I../libbacktrace/"
2121   LIBBACKTRACE_LIB=../libbacktrace/libbacktrace.la
2122   AC_DEFINE(HAVE_LIBBACKTRACE, 1, [Define if libbacktrace is being used.])
2123 else
2124   LIBBACKTRACE_INC=
2125   LIBBACKTRACE_LIB=
2126 fi
2127
2128 AC_SUBST(LIBBACKTRACE_INC)
2129 AC_SUBST(LIBBACKTRACE_LIB)
2130
2131 # Check for babeltrace and babeltrace-ctf
2132 AC_ARG_WITH(babeltrace,
2133   AS_HELP_STRING([--with-babeltrace], [include babeltrace support (auto/yes/no)]),
2134   [], [with_babeltrace=auto])
2135 AC_MSG_CHECKING([whether to use babeltrace])
2136 AC_MSG_RESULT([$with_babeltrace])
2137
2138 if test "x$with_babeltrace" = "xno"; then
2139   AC_MSG_WARN([babletrace support disabled; GDB is unable to read CTF data.])
2140 else
2141   # Append -Werror to CFLAGS so that configure can catch the warning
2142   # "assignment from incompatible pointer type", which is related to
2143   # the babeltrace change from 1.0.3 to 1.1.0.  Babeltrace 1.1.0 works
2144   # in GDB, while babeltrace 1.0.3 is broken.
2145   # AC_LIB_HAVE_LINKFLAGS may modify CPPFLAGS in it, so it should be
2146   # safe to save and restore CFLAGS here.
2147   saved_CFLAGS=$CFLAGS
2148   CFLAGS="$CFLAGS -Werror"
2149   AC_LIB_HAVE_LINKFLAGS([babeltrace], [babeltrace-ctf],
2150                         [#include <babeltrace/babeltrace.h>
2151                          #include <babeltrace/ctf/events.h>
2152                          #include <babeltrace/ctf/iterator.h>],
2153                         [struct bt_iter_pos *pos = bt_iter_get_pos (bt_ctf_get_iter (NULL));
2154                         struct bt_ctf_event *event = NULL;
2155                         const struct bt_definition *scope;
2156
2157                         pos->type = BT_SEEK_BEGIN;
2158                         bt_iter_set_pos (bt_ctf_get_iter (NULL), pos);
2159                         scope = bt_ctf_get_top_level_scope (event,
2160                                                            BT_STREAM_EVENT_HEADER);
2161                         bt_ctf_get_uint64 (bt_ctf_get_field (event, scope, "id"));
2162                         ])
2163   CFLAGS=$saved_CFLAGS
2164
2165   if test "$HAVE_LIBBABELTRACE" != yes; then
2166      if test "$with_babeltrace" = yes; then
2167        AC_MSG_ERROR([babeltrace is missing or unusable])
2168      else
2169        AC_MSG_WARN([babeltrace is missing or unusable; GDB is unable to read CTF data.])
2170      fi
2171   fi
2172 fi
2173
2174 GCC_ENABLE([libctf], [yes], [], [Handle .ctf type-info sections])
2175 if test "${enable_libctf}" = yes; then
2176   AC_DEFINE(ENABLE_LIBCTF, 1, [Handle .ctf type-info sections])
2177   LIBCTF="../libctf/libctf.la"
2178   CTF_DEPS="../libctf/libctf.la"
2179 else
2180   LIBCTF=
2181   CTF_DEPS=
2182 fi
2183 AC_SUBST(LIBCTF)
2184 AC_SUBST(CTF_DEPS)
2185
2186 # If nativefile (NAT_FILE) is not set in configure.nat, we link to an
2187 # empty version.
2188
2189 NM_H=
2190 rm -f nm.h
2191 if test "${nativefile}" != ""; then
2192     case "${nativefile}" in
2193       nm-*.h ) GDB_NM_FILE="config/${gdb_host_cpu}/${nativefile}" ;;
2194       * ) GDB_NM_FILE="${nativefile}"
2195     esac
2196     AC_CONFIG_LINKS([nm.h:$GDB_NM_FILE], [echo > stamp-nmh],
2197                     [GDB_NM_FILE=$GDB_NM_FILE])
2198     AC_DEFINE_UNQUOTED(GDB_NM_FILE, "${GDB_NM_FILE}", [nativefile])
2199     NM_H=nm.h
2200 fi
2201 AC_SUBST(GDB_NM_FILE)
2202 AC_SUBST(NM_H)
2203
2204 dnl Add dependency for xsltproc if building with maintainer-mode enabled.
2205 AC_PATH_PROGS(XSLTPROC, xsltproc, missing)
2206 if test "x$USE_MAINTAINER_MODE" = xyes; then
2207   if test "${XSLTPROC}" = missing; then
2208     AC_MSG_ERROR(unable to find xsltproc.  maintainer-mode requires xsltproc.)
2209   fi
2210 fi
2211 AC_SUBST(XSLTPROC)
2212
2213 dnl Check for exe extension set on certain hosts (e.g. Win32)
2214 AC_EXEEXT
2215
2216 dnl  Detect the character set used by this host.
2217 dnl  At the moment, we just assume it's UTF-8.
2218 AC_DEFINE(GDB_DEFAULT_HOST_CHARSET, "UTF-8",
2219           [Define to be a string naming the default host character set.])
2220
2221 GDB_AC_SELFTEST([
2222   CONFIG_OBS="$CONFIG_OBS \$(SELFTESTS_OBS)"
2223   CONFIG_SRCS="$CONFIG_SRCS \$(SELFTESTS_SRCS)"
2224 ])
2225
2226 GDB_AC_TRANSFORM([gdb], [GDB_TRANSFORM_NAME])
2227 GDB_AC_TRANSFORM([gcore], [GCORE_TRANSFORM_NAME])
2228 AC_CONFIG_FILES([gcore], [chmod +x gcore])
2229 AC_CONFIG_FILES([Makefile gdb-gdb.gdb gdb-gdb.py doc/Makefile data-directory/Makefile])
2230
2231 AC_OUTPUT