]> Git Repo - binutils.git/blob - gdb/defs.h
gdb: remove SYMBOL_CLASS macro, add getter
[binutils.git] / 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 */
This page took 0.06013 seconds and 4 git commands to generate.