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