gdb/defs.h

   1 /* *INDENT-OFF* */ /* ATTRIBUTE_PRINTF confuses indent, avoid running it
   2                       for now.  */
   3 /* Basic, host-specific, and target-specific definitions for GDB.
   4    Copyright (C) 1986-2017 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #ifndef DEFS_H
  22 #define DEFS_H
  23
  24 #ifdef GDBSERVER
  25 #  error gdbserver should not include gdb/defs.h
  26 #endif
  27
  28 #include "common-defs.h"
  29
  30 #include <sys/types.h>
  31 #include <limits.h>
  32
  33 /* The libdecnumber library, on which GDB depends, includes a header file
  34    called gstdint.h instead of relying directly on stdint.h.  GDB, on the
  35    other hand, includes stdint.h directly, relying on the fact that gnulib
  36    generates a copy if the system doesn't provide one or if it is missing
  37    some features.  Unfortunately, gstdint.h and stdint.h cannot be included
  38    at the same time, which may happen when we include a file from
  39    libdecnumber.
  40
  41    The following macro definition effectively prevents the inclusion of
  42    gstdint.h, as all the definitions it provides are guarded against
  43    the GCC_GENERATED_STDINT_H macro.  We already have gnulib/stdint.h
  44    included, so it's ok to blank out gstdint.h.  */
  45 #define GCC_GENERATED_STDINT_H 1
  46
  47 #include <unistd.h>
  48
  49 #include <fcntl.h>
  50
  51 #include "gdb_wchar.h"
  52
  53 #include "ui-file.h"
  54
  55 #include "host-defs.h"
  56 #include "common/enum-flags.h"
  57
  58 /* Scope types enumerator.  List the types of scopes the compiler will
  59    accept.  */
  60
  61 enum compile_i_scope_types
  62   {
  63     COMPILE_I_INVALID_SCOPE,
  64
  65     /* A simple scope.  Wrap an expression into a simple scope that
  66        takes no arguments, returns no value, and uses the generic
  67        function name "_gdb_expr". */
  68
  69     COMPILE_I_SIMPLE_SCOPE,
  70
  71     /* Do not wrap the expression,
  72        it has to provide function "_gdb_expr" on its own.  */
  73     COMPILE_I_RAW_SCOPE,
  74
  75     /* A printable expression scope.  Wrap an expression into a scope
  76        suitable for the "compile print" command.  It uses the generic
  77        function name "_gdb_expr".  COMPILE_I_PRINT_ADDRESS_SCOPE variant
  78        is the usual one, taking address of the object.
  79        COMPILE_I_PRINT_VALUE_SCOPE is needed for arrays where the array
  80        name already specifies its address.  See get_out_value_type.  */
  81     COMPILE_I_PRINT_ADDRESS_SCOPE,
  82     COMPILE_I_PRINT_VALUE_SCOPE,
  83   };
  84
  85
  86 template<typename T>
  87 using RequireLongest = gdb::Requires<gdb::Or<std::is_same<T, LONGEST>,
  88                                              std::is_same<T, ULONGEST>>>;
  89
  90 /* Just in case they're not defined in stdio.h.  */
  91
  92 #ifndef SEEK_SET
  93 #define SEEK_SET 0
  94 #endif
  95 #ifndef SEEK_CUR
  96 #define SEEK_CUR 1
  97 #endif
  98
  99 /* The O_BINARY flag is defined in fcntl.h on some non-Posix platforms.
 100    It is used as an access modifier in calls to open(), where it acts
 101    similarly to the "b" character in fopen()'s MODE argument.  On Posix
 102    platforms it should be a no-op, so it is defined as 0 here.  This
 103    ensures that the symbol may be used freely elsewhere in gdb.  */
 104
 105 #ifndef O_BINARY
 106 #define O_BINARY 0
 107 #endif
 108
 109 #include "hashtab.h"
 110
 111 /* * Enable dbx commands if set.  */
 112 extern int dbx_commands;
 113
 114 /* * System root path, used to find libraries etc.  */
 115 extern char *gdb_sysroot;
 116
 117 /* * GDB datadir, used to store data files.  */
 118 extern char *gdb_datadir;
 119
 120 /* * If non-NULL, the possibly relocated path to python's "lib" directory
 121    specified with --with-python.  */
 122 extern char *python_libdir;
 123
 124 /* * Search path for separate debug files.  */
 125 extern char *debug_file_directory;
 126
 127 /* GDB's SIGINT handler basically sets a flag; code that might take a
 128    long time before it gets back to the event loop, and which ought to
 129    be interruptible, checks this flag using the QUIT macro, which, if
 130    GDB has the terminal, throws a quit exception.
 131
 132    In addition to setting a flag, the SIGINT handler also marks a
 133    select/poll-able file descriptor as read-ready.  That is used by
 134    interruptible_select in order to support interrupting blocking I/O
 135    in a race-free manner.
 136
 137    These functions use the extension_language_ops API to allow extension
 138    language(s) and GDB SIGINT handling to coexist seamlessly.  */
 139
 140 /* * Evaluate to non-zero if the quit flag is set, zero otherwise.  This
 141    will clear the quit flag as a side effect.  */
 142 extern int check_quit_flag (void);
 143 /* * Set the quit flag.  */
 144 extern void set_quit_flag (void);
 145
 146 /* The current quit handler (and its type).  This is called from the
 147    QUIT macro.  See default_quit_handler below for default behavior.
 148    Parts of GDB temporarily override this to e.g., completely suppress
 149    Ctrl-C because it would not be safe to throw.  E.g., normally, you
 150    wouldn't want to quit between a RSP command and its response, as
 151    that would break the communication with the target, but you may
 152    still want to intercept the Ctrl-C and offer to disconnect if the
 153    user presses Ctrl-C multiple times while the target is stuck
 154    waiting for the wedged remote stub.  */
 155 typedef void (quit_handler_ftype) (void);
 156 extern quit_handler_ftype *quit_handler;
 157
 158 /* Override the current quit handler.  Sets NEW_QUIT_HANDLER as
 159    current quit handler, and installs a cleanup that when run restores
 160    the previous quit handler.  */
 161 struct cleanup *
 162   make_cleanup_override_quit_handler (quit_handler_ftype *new_quit_handler);
 163
 164 /* The default quit handler.  Checks whether Ctrl-C was pressed, and
 165    if so:
 166
 167      - If GDB owns the terminal, throws a quit exception.
 168
 169      - If GDB does not own the terminal, forwards the Ctrl-C to the
 170        target.
 171 */
 172 extern void default_quit_handler (void);
 173
 174 /* Flag that function quit should call quit_force.  */
 175 extern volatile int sync_quit_force_run;
 176
 177 extern void quit (void);
 178
 179 /* Helper for the QUIT macro.  */
 180
 181 extern void maybe_quit (void);
 182
 183 /* Check whether a Ctrl-C was typed, and if so, call the current quit
 184    handler.  */
 185 #define QUIT maybe_quit ()
 186
 187 /* Set the serial event associated with the quit flag.  */
 188 extern void quit_serial_event_set (void);
 189
 190 /* Clear the serial event associated with the quit flag.  */
 191 extern void quit_serial_event_clear (void);
 192
 193 /* * Languages represented in the symbol table and elsewhere.
 194    This should probably be in language.h, but since enum's can't
 195    be forward declared to satisfy opaque references before their
 196    actual definition, needs to be here.
 197
 198    The constants here are in priority order.  In particular,
 199    demangling is attempted according to this order.
 200
 201    Note that there's ambiguity between the mangling schemes of some of
 202    these languages, so some symbols could be successfully demangled by
 203    several languages.  For that reason, the constants here are sorted
 204    in the order we'll attempt demangling them.  For example: Rust uses
 205    C++ mangling, so must come after C++; Ada must come last (see
 206    ada_sniff_from_mangled_name).  */
 207
 208 enum language
 209   {
 210     language_unknown,           /* Language not known */
 211     language_auto,              /* Placeholder for automatic setting */
 212     language_c,                 /* C */
 213     language_objc,              /* Objective-C */
 214     language_cplus,             /* C++ */
 215     language_d,                 /* D */
 216     language_go,                /* Go */
 217     language_fortran,           /* Fortran */
 218     language_m2,                /* Modula-2 */
 219     language_asm,               /* Assembly language */
 220     language_pascal,            /* Pascal */
 221     language_opencl,            /* OpenCL */
 222     language_rust,              /* Rust */
 223     language_minimal,           /* All other languages, minimal support only */
 224     language_ada,               /* Ada */
 225     nr_languages
 226   };
 227
 228 /* The number of bits needed to represent all languages, with enough
 229    padding to allow for reasonable growth.  */
 230 #define LANGUAGE_BITS 5
 231 gdb_static_assert (nr_languages <= (1 << LANGUAGE_BITS));
 232
 233 enum precision_type
 234   {
 235     single_precision,
 236     double_precision,
 237     unspecified_precision
 238   };
 239
 240 /* * A generic, not quite boolean, enumeration.  This is used for
 241    set/show commands in which the options are on/off/automatic.  */
 242 enum auto_boolean
 243 {
 244   AUTO_BOOLEAN_TRUE,
 245   AUTO_BOOLEAN_FALSE,
 246   AUTO_BOOLEAN_AUTO
 247 };
 248
 249 /* * Potential ways that a function can return a value of a given
 250    type.  */
 251
 252 enum return_value_convention
 253 {
 254   /* * Where the return value has been squeezed into one or more
 255      registers.  */
 256   RETURN_VALUE_REGISTER_CONVENTION,
 257   /* * Commonly known as the "struct return convention".  The caller
 258      passes an additional hidden first parameter to the caller.  That
 259      parameter contains the address at which the value being returned
 260      should be stored.  While typically, and historically, used for
 261      large structs, this is convention is applied to values of many
 262      different types.  */
 263   RETURN_VALUE_STRUCT_CONVENTION,
 264   /* * Like the "struct return convention" above, but where the ABI
 265      guarantees that the called function stores the address at which
 266      the value being returned is stored in a well-defined location,
 267      such as a register or memory slot in the stack frame.  Don't use
 268      this if the ABI doesn't explicitly guarantees this.  */
 269   RETURN_VALUE_ABI_RETURNS_ADDRESS,
 270   /* * Like the "struct return convention" above, but where the ABI
 271      guarantees that the address at which the value being returned is
 272      stored will be available in a well-defined location, such as a
 273      register or memory slot in the stack frame.  Don't use this if
 274      the ABI doesn't explicitly guarantees this.  */
 275   RETURN_VALUE_ABI_PRESERVES_ADDRESS,
 276 };
 277
 278 /* Needed for various prototypes */
 279
 280 struct symtab;
 281 struct breakpoint;
 282 struct frame_info;
 283 struct gdbarch;
 284 struct value;
 285
 286 /* From main.c.  */
 287
 288 /* This really belong in utils.c (path-utils.c?), but it references some
 289    globals that are currently only available to main.c.  */
 290 extern char *relocate_gdb_directory (const char *initial, int flag);
 291
 292 \f
 293 /* Annotation stuff.  */
 294
 295 extern int annotation_level;    /* in stack.c */
 296 \f
 297
 298 /* From regex.c or libc.  BSD 4.4 declares this with the argument type as
 299    "const char *" in unistd.h, so we can't declare the argument
 300    as "char *".  */
 301
 302 EXTERN_C char *re_comp (const char *);
 303
 304 /* From symfile.c */
 305
 306 extern void symbol_file_command (char *, int);
 307
 308 /* * Remote targets may wish to use this as their load function.  */
 309 extern void generic_load (const char *name, int from_tty);
 310
 311 /* From top.c */
 312
 313 typedef void initialize_file_ftype (void);
 314
 315 extern char *gdb_readline_wrapper (const char *);
 316
 317 extern char *command_line_input (const char *, int, const char *);
 318
 319 extern void print_prompt (void);
 320
 321 struct ui;
 322
 323 extern int input_interactive_p (struct ui *);
 324
 325 extern int info_verbose;
 326
 327 /* From printcmd.c */
 328
 329 extern void set_next_address (struct gdbarch *, CORE_ADDR);
 330
 331 extern int print_address_symbolic (struct gdbarch *, CORE_ADDR,
 332                                    struct ui_file *, int,
 333                                    const char *);
 334
 335 extern int build_address_symbolic (struct gdbarch *,
 336                                    CORE_ADDR addr,
 337                                    int do_demangle,
 338                                    char **name,
 339                                    int *offset,
 340                                    char **filename,
 341                                    int *line,
 342                                    int *unmapped);
 343
 344 extern void print_address (struct gdbarch *, CORE_ADDR, struct ui_file *);
 345 extern const char *pc_prefix (CORE_ADDR);
 346
 347 /* From source.c */
 348
 349 /* See openp function definition for their description.  */
 350 #define OPF_TRY_CWD_FIRST     0x01
 351 #define OPF_SEARCH_IN_PATH    0x02
 352 #define OPF_RETURN_REALPATH   0x04
 353
 354 extern int openp (const char *, int, const char *, int, char **);
 355
 356 extern int source_full_path_of (const char *, char **);
 357
 358 extern void mod_path (char *, char **);
 359
 360 extern void add_path (char *, char **, int);
 361
 362 extern void directory_switch (char *, int);
 363
 364 extern char *source_path;
 365
 366 extern void init_source_path (void);
 367
 368 /* From exec.c */
 369
 370 /* * Process memory area starting at ADDR with length SIZE.  Area is
 371    readable iff READ is non-zero, writable if WRITE is non-zero,
 372    executable if EXEC is non-zero.  Area is possibly changed against
 373    its original file based copy if MODIFIED is non-zero.  DATA is
 374    passed without changes from a caller.  */
 375
 376 typedef int (*find_memory_region_ftype) (CORE_ADDR addr, unsigned long size,
 377                                          int read, int write, int exec,
 378                                          int modified, void *data);
 379
 380 /* * Possible lvalue types.  Like enum language, this should be in
 381    value.h, but needs to be here for the same reason.  */
 382
 383 enum lval_type
 384   {
 385     /* * Not an lval.  */
 386     not_lval,
 387     /* * In memory.  */
 388     lval_memory,
 389     /* * In a register.  Registers are relative to a frame.  */
 390     lval_register,
 391     /* * In a gdb internal variable.  */
 392     lval_internalvar,
 393     /* * Value encapsulates a callable defined in an extension language.  */
 394     lval_xcallable,
 395     /* * Part of a gdb internal variable (structure field).  */
 396     lval_internalvar_component,
 397     /* * Value's bits are fetched and stored using functions provided
 398        by its creator.  */
 399     lval_computed
 400   };
 401
 402 /* * Control types for commands.  */
 403
 404 enum misc_command_type
 405   {
 406     ok_command,
 407     end_command,
 408     else_command,
 409     nop_command
 410   };
 411
 412 enum command_control_type
 413   {
 414     simple_control,
 415     break_control,
 416     continue_control,
 417     while_control,
 418     if_control,
 419     commands_control,
 420     python_control,
 421     compile_control,
 422     guile_control,
 423     while_stepping_control,
 424     invalid_control
 425   };
 426
 427 /* * Structure for saved commands lines (for breakpoints, defined
 428    commands, etc).  */
 429
 430 struct command_line
 431   {
 432     struct command_line *next;
 433     char *line;
 434     enum command_control_type control_type;
 435     union
 436       {
 437         struct
 438           {
 439             enum compile_i_scope_types scope;
 440             void *scope_data;
 441           }
 442         compile;
 443       }
 444     control_u;
 445     /* * The number of elements in body_list.  */
 446     int body_count;
 447     /* * For composite commands, the nested lists of commands.  For
 448        example, for "if" command this will contain the then branch and
 449        the else branch, if that is available.  */
 450     struct command_line **body_list;
 451   };
 452
 453 extern void free_command_lines (struct command_line **);
 454
 455 /* A deleter for command_line that calls free_command_lines.  */
 456
 457 struct command_lines_deleter
 458 {
 459   void operator() (command_line *lines) const
 460   {
 461     free_command_lines (&lines);
 462   }
 463 };
 464
 465 /* A unique pointer to a command_line.  */
 466
 467 typedef std::unique_ptr<command_line, command_lines_deleter> command_line_up;
 468
 469 extern command_line_up read_command_lines (char *, int, int,
 470                                            void (*)(char *, void *),
 471                                            void *);
 472 extern command_line_up read_command_lines_1 (char * (*) (void), int,
 473                                              void (*)(char *, void *),
 474                                              void *);
 475
 476 /* * Parameters of the "info proc" command.  */
 477
 478 enum info_proc_what
 479   {
 480     /* * Display the default cmdline, cwd and exe outputs.  */
 481     IP_MINIMAL,
 482
 483     /* * Display `info proc mappings'.  */
 484     IP_MAPPINGS,
 485
 486     /* * Display `info proc status'.  */
 487     IP_STATUS,
 488
 489     /* * Display `info proc stat'.  */
 490     IP_STAT,
 491
 492     /* * Display `info proc cmdline'.  */
 493     IP_CMDLINE,
 494
 495     /* * Display `info proc exe'.  */
 496     IP_EXE,
 497
 498     /* * Display `info proc cwd'.  */
 499     IP_CWD,
 500
 501     /* * Display all of the above.  */
 502     IP_ALL
 503   };
 504
 505 /* * String containing the current directory (what getwd would return).  */
 506
 507 extern char *current_directory;
 508
 509 /* * Default radixes for input and output.  Only some values supported.  */
 510 extern unsigned input_radix;
 511 extern unsigned output_radix;
 512
 513 /* * Possibilities for prettyformat parameters to routines which print
 514    things.  Like enum language, this should be in value.h, but needs
 515    to be here for the same reason.  FIXME:  If we can eliminate this
 516    as an arg to LA_VAL_PRINT, then we can probably move it back to
 517    value.h.  */
 518
 519 enum val_prettyformat
 520   {
 521     Val_no_prettyformat = 0,
 522     Val_prettyformat,
 523     /* * Use the default setting which the user has specified.  */
 524     Val_prettyformat_default
 525   };
 526
 527 /* * Optional native machine support.  Non-native (and possibly pure
 528    multi-arch) targets do not need a "nm.h" file.  This will be a
 529    symlink to one of the nm-*.h files, built by the `configure'
 530    script.  */
 531
 532 #ifdef GDB_NM_FILE
 533 #include "nm.h"
 534 #endif
 535
 536 /* Assume that fopen accepts the letter "b" in the mode string.
 537    It is demanded by ISO C9X, and should be supported on all
 538    platforms that claim to have a standard-conforming C library.  On
 539    true POSIX systems it will be ignored and have no effect.  There
 540    may still be systems without a standard-conforming C library where
 541    an ISO C9X compiler (GCC) is available.  Known examples are SunOS
 542    4.x and 4.3BSD.  This assumption means these systems are no longer
 543    supported.  */
 544 #ifndef FOPEN_RB
 545 # include "fopen-bin.h"
 546 #endif
 547
 548 /* Defaults for system-wide constants (if not defined by xm.h, we fake it).
 549    FIXME: Assumes 2's complement arithmetic.  */
 550
 551 #if !defined (UINT_MAX)
 552 #define UINT_MAX ((unsigned int)(~0))       /* 0xFFFFFFFF for 32-bits */
 553 #endif
 554
 555 #if !defined (INT_MAX)
 556 #define INT_MAX ((int)(UINT_MAX >> 1))      /* 0x7FFFFFFF for 32-bits */
 557 #endif
 558
 559 #if !defined (INT_MIN)
 560 #define INT_MIN ((int)((int) ~0 ^ INT_MAX)) /* 0x80000000 for 32-bits */
 561 #endif
 562
 563 #if !defined (ULONG_MAX)
 564 #define ULONG_MAX ((unsigned long)(~0L))    /* 0xFFFFFFFF for 32-bits */
 565 #endif
 566
 567 #if !defined (LONG_MAX)
 568 #define LONG_MAX ((long)(ULONG_MAX >> 1))   /* 0x7FFFFFFF for 32-bits */
 569 #endif
 570
 571 #if !defined (ULONGEST_MAX)
 572 #define ULONGEST_MAX (~(ULONGEST)0)        /* 0xFFFFFFFFFFFFFFFF for 64-bits */
 573 #endif
 574
 575 #if !defined (LONGEST_MAX)                 /* 0x7FFFFFFFFFFFFFFF for 64-bits */
 576 #define LONGEST_MAX ((LONGEST)(ULONGEST_MAX >> 1))
 577 #endif
 578
 579 /* * Convert a LONGEST to an int.  This is used in contexts (e.g. number of
 580    arguments to a function, number in a value history, register number, etc.)
 581    where the value must not be larger than can fit in an int.  */
 582
 583 extern int longest_to_int (LONGEST);
 584
 585 /* * List of known OS ABIs.  If you change this, make sure to update the
 586    table in osabi.c.  */
 587 enum gdb_osabi
 588 {
 589   GDB_OSABI_UNINITIALIZED = -1, /* For struct gdbarch_info.  */
 590
 591   GDB_OSABI_UNKNOWN = 0,        /* keep this zero */
 592
 593   GDB_OSABI_SVR4,
 594   GDB_OSABI_HURD,
 595   GDB_OSABI_SOLARIS,
 596   GDB_OSABI_LINUX,
 597   GDB_OSABI_FREEBSD,
 598   GDB_OSABI_NETBSD,
 599   GDB_OSABI_OPENBSD,
 600   GDB_OSABI_WINCE,
 601   GDB_OSABI_GO32,
 602   GDB_OSABI_QNXNTO,
 603   GDB_OSABI_CYGWIN,
 604   GDB_OSABI_AIX,
 605   GDB_OSABI_DICOS,
 606   GDB_OSABI_DARWIN,
 607   GDB_OSABI_SYMBIAN,
 608   GDB_OSABI_OPENVMS,
 609   GDB_OSABI_LYNXOS178,
 610   GDB_OSABI_NEWLIB,
 611   GDB_OSABI_SDE,
 612
 613   GDB_OSABI_INVALID             /* keep this last */
 614 };
 615
 616 /* Enumerate the requirements a symbol has in order to be evaluated.
 617    These are listed in order of "strength" -- a later entry subsumes
 618    earlier ones.  This fine-grained distinction is important because
 619    it allows for the evaluation of a TLS symbol during unwinding --
 620    when unwinding one has access to registers, but not the frame
 621    itself, because that is being constructed.  */
 622
 623 enum symbol_needs_kind
 624 {
 625   /* No special requirements -- just memory.  */
 626   SYMBOL_NEEDS_NONE,
 627
 628   /* The symbol needs registers.  */
 629   SYMBOL_NEEDS_REGISTERS,
 630
 631   /* The symbol needs a frame.  */
 632   SYMBOL_NEEDS_FRAME
 633 };
 634
 635 /* Dynamic target-system-dependent parameters for GDB.  */
 636 #include "gdbarch.h"
 637
 638 /* * Maximum size of a register.  Something small, but large enough for
 639    all known ISAs.  If it turns out to be too small, make it bigger.  */
 640
 641 enum { MAX_REGISTER_SIZE = 64 };
 642
 643 /* In findvar.c.  */
 644
 645 template<typename T, typename = RequireLongest<T>>
 646 T extract_integer (const gdb_byte *addr, int len, enum bfd_endian byte_order);
 647
 648 static inline LONGEST
 649 extract_signed_integer (const gdb_byte *addr, int len,
 650                         enum bfd_endian byte_order)
 651 {
 652   return extract_integer<LONGEST> (addr, len, byte_order);
 653 }
 654
 655 static inline ULONGEST
 656 extract_unsigned_integer (const gdb_byte *addr, int len,
 657                           enum bfd_endian byte_order)
 658 {
 659   return extract_integer<ULONGEST> (addr, len, byte_order);
 660 }
 661
 662 extern int extract_long_unsigned_integer (const gdb_byte *, int,
 663                                           enum bfd_endian, LONGEST *);
 664
 665 extern CORE_ADDR extract_typed_address (const gdb_byte *buf,
 666                                         struct type *type);
 667
 668 /* All 'store' functions accept a host-format integer and store a
 669    target-format integer at ADDR which is LEN bytes long.  */
 670
 671 template<typename T, typename = RequireLongest<T>>
 672 extern void store_integer (gdb_byte *addr, int len, enum bfd_endian byte_order,
 673                            T val);
 674
 675 static inline void
 676 store_signed_integer (gdb_byte *addr, int len,
 677                       enum bfd_endian byte_order, LONGEST val)
 678 {
 679   return store_integer (addr, len, byte_order, val);
 680 }
 681
 682 static inline void
 683 store_unsigned_integer (gdb_byte *addr, int len,
 684                         enum bfd_endian byte_order, ULONGEST val)
 685 {
 686   return store_integer (addr, len, byte_order, val);
 687 }
 688
 689 extern void store_typed_address (gdb_byte *buf, struct type *type,
 690                                  CORE_ADDR addr);
 691
 692 extern void copy_integer_to_size (gdb_byte *dest, int dest_size,
 693                                   const gdb_byte *source, int source_size,
 694                                   bool is_signed, enum bfd_endian byte_order);
 695
 696 /* From valops.c */
 697
 698 extern int watchdog;
 699
 700 /* From dwarf2read.c */
 701
 702 ULONGEST read_unsigned_leb128 (bfd *, const gdb_byte *, unsigned int *);
 703
 704 /* Hooks for alternate command interfaces.  */
 705
 706 /* * The name of the interpreter if specified on the command line.  */
 707 extern char *interpreter_p;
 708
 709 struct target_waitstatus;
 710 struct cmd_list_element;
 711
 712 extern void (*deprecated_pre_add_symbol_hook) (const char *);
 713 extern void (*deprecated_post_add_symbol_hook) (void);
 714 extern void (*selected_frame_level_changed_hook) (int);
 715 extern int (*deprecated_ui_loop_hook) (int signo);
 716 extern void (*deprecated_show_load_progress) (const char *section,
 717                                               unsigned long section_sent,
 718                                               unsigned long section_size,
 719                                               unsigned long total_sent,
 720                                               unsigned long total_size);
 721 extern void (*deprecated_print_frame_info_listing_hook) (struct symtab * s,
 722                                                          int line,
 723                                                          int stopline,
 724                                                          int noerror);
 725 extern int (*deprecated_query_hook) (const char *, va_list)
 726      ATTRIBUTE_FPTR_PRINTF(1,0);
 727 extern void (*deprecated_warning_hook) (const char *, va_list)
 728      ATTRIBUTE_FPTR_PRINTF(1,0);
 729 extern void (*deprecated_interactive_hook) (void);
 730 extern void (*deprecated_readline_begin_hook) (const char *, ...)
 731      ATTRIBUTE_FPTR_PRINTF_1;
 732 extern char *(*deprecated_readline_hook) (const char *);
 733 extern void (*deprecated_readline_end_hook) (void);
 734 extern void (*deprecated_context_hook) (int);
 735 extern ptid_t (*deprecated_target_wait_hook) (ptid_t ptid,
 736                                               struct target_waitstatus *status,
 737                                               int options);
 738
 739 extern void (*deprecated_attach_hook) (void);
 740 extern void (*deprecated_detach_hook) (void);
 741 extern void (*deprecated_call_command_hook) (struct cmd_list_element * c,
 742                                              char *cmd, int from_tty);
 743
 744 extern int (*deprecated_ui_load_progress_hook) (const char *section,
 745                                                 unsigned long num);
 746
 747 /* If this definition isn't overridden by the header files, assume
 748    that isatty and fileno exist on this system.  */
 749 #ifndef ISATTY
 750 #define ISATTY(FP)      (isatty (fileno (FP)))
 751 #endif
 752
 753 /* * A width that can achieve a better legibility for GDB MI mode.  */
 754 #define GDB_MI_MSG_WIDTH  80
 755
 756 /* From progspace.c */
 757
 758 extern void initialize_progspace (void);
 759 extern void initialize_inferiors (void);
 760
 761 /* * Special block numbers */
 762
 763 enum block_enum
 764 {
 765   GLOBAL_BLOCK = 0,
 766   STATIC_BLOCK = 1,
 767   FIRST_LOCAL_BLOCK = 2
 768 };
 769
 770 /* User selection used in observer.h and multiple print functions.  */
 771
 772 enum user_selected_what_flag
 773   {
 774     /* Inferior selected.  */
 775     USER_SELECTED_INFERIOR = 1 << 1,
 776
 777     /* Thread selected.  */
 778     USER_SELECTED_THREAD = 1 << 2,
 779
 780     /* Frame selected.  */
 781     USER_SELECTED_FRAME = 1 << 3
 782   };
 783 DEF_ENUM_FLAGS_TYPE (enum user_selected_what_flag, user_selected_what);
 784
 785 #include "utils.h"
 786
 787 #endif /* #ifndef DEFS_H */