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