gdb/defs.h

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