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