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