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