GDB (xrefs)
Loading...
Searching...
No Matches
osabi.c
Go to the documentation of this file.
1/* OS ABI variant handling for GDB.
2
3 Copyright (C) 2001-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20#include "defs.h"
21
22#include "osabi.h"
23#include "arch-utils.h"
24#include "gdbcmd.h"
25#include "command.h"
26#include "gdb_bfd.h"
27
28#include "elf-bfd.h"
29
30#ifndef GDB_OSABI_DEFAULT
31#define GDB_OSABI_DEFAULT GDB_OSABI_UNKNOWN
32#endif
33
34/* State for the "set osabi" command. */
38 "auto",
39 "default",
40 "none",
41 NULL
42};
43static const char *set_osabi_string;
44
45/* Names associated with each osabi. */
46
48{
49 /* The "pretty" name. */
50
51 const char *pretty;
52
53 /* The triplet regexp, or NULL if not known. */
54
55 const char *regexp;
56};
57
58/* This table matches the indices assigned to enum gdb_osabi. Keep
59 them in sync. */
60static const struct osabi_names gdb_osabi_names[] =
61{
62 { "unknown", NULL },
63 { "none", NULL },
64
65 { "SVR4", NULL },
66 { "GNU/Hurd", NULL },
67 { "Solaris", NULL },
68 { "GNU/Linux", "linux(-gnu[^-]*)?" },
69 { "FreeBSD", NULL },
70 { "NetBSD", NULL },
71 { "OpenBSD", NULL },
72 { "WindowsCE", NULL },
73 { "DJGPP", NULL },
74 { "QNX-Neutrino", NULL },
75 { "Cygwin", NULL },
76 { "Windows", NULL },
77 { "AIX", NULL },
78 { "DICOS", NULL },
79 { "Darwin", NULL },
80 { "OpenVMS", NULL },
81 { "LynxOS178", NULL },
82 { "Newlib", NULL },
83 { "SDE", NULL },
84 { "PikeOS", NULL },
85
86 { "<invalid>", NULL }
87};
88
89const char *
91{
92 if (osabi >= GDB_OSABI_UNKNOWN && osabi < GDB_OSABI_INVALID)
93 return gdb_osabi_names[osabi].pretty;
94
96}
97
98/* See osabi.h. */
99
100const char *
102{
103 if (osabi >= GDB_OSABI_UNKNOWN && osabi < GDB_OSABI_INVALID)
104 return gdb_osabi_names[osabi].regexp;
105
107}
108
109/* Lookup the OS ABI corresponding to the specified target description
110 string. */
111
112enum gdb_osabi
114{
115 int i;
116
117 for (i = 0; i < ARRAY_SIZE (gdb_osabi_names); i++)
118 if (strcmp (name, gdb_osabi_names[i].pretty) == 0)
119 {
120 /* See note above: the name table matches the indices assigned
121 to enum gdb_osabi. */
122 enum gdb_osabi osabi = (enum gdb_osabi) i;
123
124 if (osabi == GDB_OSABI_INVALID)
125 return GDB_OSABI_UNKNOWN;
126 else
127 return osabi;
128 }
129
130 return GDB_OSABI_UNKNOWN;
131}
132
133/* Handler for a given architecture/OS ABI pair. There should be only
134 one handler for a given OS ABI each architecture family. */
136{
138 const struct bfd_arch_info *arch_info;
140 void (*init_osabi)(struct gdbarch_info, struct gdbarch *);
141};
142
144
145void
146gdbarch_register_osabi (enum bfd_architecture arch, unsigned long machine,
147 enum gdb_osabi osabi,
148 void (*init_osabi)(struct gdbarch_info,
149 struct gdbarch *))
150{
151 struct gdb_osabi_handler **handler_p;
152 const struct bfd_arch_info *arch_info = bfd_lookup_arch (arch, machine);
153 const char **name_ptr;
154
155 /* Registering an OS ABI handler for "unknown" is not allowed. */
156 if (osabi == GDB_OSABI_UNKNOWN)
157 {
158 internal_error
159 (_("gdbarch_register_osabi: An attempt to register a handler for "
160 "OS ABI \"%s\" for architecture %s was made. The handler will "
161 "not be registered"),
162 gdbarch_osabi_name (osabi),
163 bfd_printable_arch_mach (arch, machine));
164 return;
165 }
166
167 gdb_assert (arch_info);
168
169 for (handler_p = &gdb_osabi_handler_list; *handler_p != NULL;
170 handler_p = &(*handler_p)->next)
171 {
172 if ((*handler_p)->arch_info == arch_info
173 && (*handler_p)->osabi == osabi)
174 {
175 internal_error
176 (_("gdbarch_register_osabi: A handler for OS ABI \"%s\" "
177 "has already been registered for architecture %s"),
178 gdbarch_osabi_name (osabi),
179 arch_info->printable_name);
180 /* If user wants to continue, override previous definition. */
181 (*handler_p)->init_osabi = init_osabi;
182 return;
183 }
184 }
185
186 (*handler_p) = XNEW (struct gdb_osabi_handler);
187 (*handler_p)->next = NULL;
188 (*handler_p)->arch_info = arch_info;
189 (*handler_p)->osabi = osabi;
190 (*handler_p)->init_osabi = init_osabi;
191
192 /* Add this OS ABI to the list of enum values for "set osabi", if it isn't
193 already there. */
194 for (name_ptr = gdb_osabi_available_names; *name_ptr; name_ptr ++)
195 {
196 if (*name_ptr == gdbarch_osabi_name (osabi))
197 return;
198 }
199 *name_ptr++ = gdbarch_osabi_name (osabi);
200 *name_ptr = NULL;
201}
202
203
204/* Sniffer to find the OS ABI for a given file's architecture and flavour.
205 It is legal to have multiple sniffers for each arch/flavour pair, to
206 disambiguate one OS's a.out from another, for example. The first sniffer
207 to return something other than GDB_OSABI_UNKNOWN wins, so a sniffer should
208 be careful to claim a file only if it knows for sure what it is. */
210{
212 enum bfd_architecture arch; /* bfd_arch_unknown == wildcard */
213 enum bfd_flavour flavour;
214 enum gdb_osabi (*sniffer)(bfd *);
215};
216
218
219void
221 enum bfd_flavour flavour,
222 enum gdb_osabi (*sniffer_fn)(bfd *))
223{
225
226 sniffer = XNEW (struct gdb_osabi_sniffer);
227 sniffer->arch = arch;
228 sniffer->flavour = flavour;
229 sniffer->sniffer = sniffer_fn;
230
233}
234
235
236enum gdb_osabi
238{
240 enum gdb_osabi osabi, match;
241 int match_specific;
242
243 /* If we aren't in "auto" mode, return the specified OS ABI. */
245 return user_selected_osabi;
246
247 /* If we don't have a binary, just return unknown. The caller may
248 have other sources the OSABI can be extracted from, e.g., the
249 target description. */
250 if (abfd == NULL)
251 return GDB_OSABI_UNKNOWN;
252
253 match = GDB_OSABI_UNKNOWN;
254 match_specific = 0;
255
256 for (sniffer = gdb_osabi_sniffer_list; sniffer != NULL;
257 sniffer = sniffer->next)
258 {
259 if ((sniffer->arch == bfd_arch_unknown /* wildcard */
260 || sniffer->arch == bfd_get_arch (abfd))
261 && sniffer->flavour == bfd_get_flavour (abfd))
262 {
263 osabi = (*sniffer->sniffer) (abfd);
264 if (osabi < GDB_OSABI_UNKNOWN || osabi >= GDB_OSABI_INVALID)
265 {
266 internal_error
267 (_("gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer "
268 "for architecture %s flavour %d"),
269 (int) osabi,
270 bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
271 (int) bfd_get_flavour (abfd));
272 }
273 else if (osabi != GDB_OSABI_UNKNOWN)
274 {
275 /* A specific sniffer always overrides a generic sniffer.
276 Croak on multiple match if the two matches are of the
277 same class. If the user wishes to continue, we'll use
278 the first match. */
279 if (match != GDB_OSABI_UNKNOWN)
280 {
281 if ((match_specific && sniffer->arch != bfd_arch_unknown)
282 || (!match_specific && sniffer->arch == bfd_arch_unknown))
283 {
284 internal_error
285 (_("gdbarch_lookup_osabi: multiple %sspecific OS ABI "
286 "match for architecture %s flavour %d: first "
287 "match \"%s\", second match \"%s\""),
288 match_specific ? "" : "non-",
289 bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
290 (int) bfd_get_flavour (abfd),
291 gdbarch_osabi_name (match),
292 gdbarch_osabi_name (osabi));
293 }
294 else if (sniffer->arch != bfd_arch_unknown)
295 {
296 match = osabi;
297 match_specific = 1;
298 }
299 }
300 else
301 {
302 match = osabi;
303 if (sniffer->arch != bfd_arch_unknown)
304 match_specific = 1;
305 }
306 }
307 }
308 }
309
310 return match;
311}
312
313
314/* Return non-zero if architecture A can run code written for
315 architecture B. */
316static int
317can_run_code_for (const struct bfd_arch_info *a, const struct bfd_arch_info *b)
318{
319 /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
320 incompatible. But if they are compatible, it returns the 'more
321 featureful' of the two arches. That is, if A can run code
322 written for B, but B can't run code written for A, then it'll
323 return A.
324
325 struct bfd_arch_info objects are singletons: that is, there's
326 supposed to be exactly one instance for a given machine. So you
327 can tell whether two are equivalent by comparing pointers. */
328 return (a == b || a->compatible (a, b) == a);
329}
330
331/* Return OS ABI handler for INFO. */
332
333static struct gdb_osabi_handler *
335{
336 struct gdb_osabi_handler *handler;
337
338 gdb_assert (info.osabi != GDB_OSABI_UNKNOWN);
339
340 for (handler = gdb_osabi_handler_list; handler != NULL;
341 handler = handler->next)
342 {
343 if (handler->osabi != info.osabi)
344 continue;
345
346 /* If the architecture described by ARCH_INFO can run code for
347 the architecture we registered the handler for, then the
348 handler is applicable. Note, though, that if the handler is
349 for an architecture that is a superset of ARCH_INFO, we can't
350 use that --- it would be perfectly correct for it to install
351 gdbarch methods that refer to registers / instructions /
352 other facilities ARCH_INFO doesn't have.
353
354 NOTE: kettenis/20021027: There may be more than one machine
355 type that is compatible with the desired machine type. Right
356 now we simply return the first match, which is fine for now.
357 However, we might want to do something smarter in the future. */
358 /* NOTE: cagney/2003-10-23: The code for "a can_run_code_for b"
359 is implemented using BFD's compatible method (a->compatible
360 (b) == a -- the lowest common denominator between a and b is
361 a). That method's definition of compatible may not be as you
362 expect. For instance the test "amd64 can run code for i386"
363 (or more generally "64-bit ISA can run code for the 32-bit
364 ISA"). BFD doesn't normally consider 32-bit and 64-bit
365 "compatible" so it doesn't succeed. */
366 if (can_run_code_for (info.bfd_arch_info, handler->arch_info))
367 return handler;
368 }
369
370 return nullptr;
371}
372
373/* See osabi.h. */
374
375bool
377{
378 return gdbarch_osabi_handler (info) != nullptr;
379}
380
381void
383{
384 struct gdb_osabi_handler *handler;
385
386 gdb_assert (info.osabi != GDB_OSABI_UNKNOWN);
387 handler = gdbarch_osabi_handler (info);
388
389 if (handler != nullptr)
390 {
391 (*handler->init_osabi) (info, gdbarch);
392 return;
393 }
394
395 if (info.osabi == GDB_OSABI_NONE)
396 {
397 /* Don't complain about no OSABI. Assume the user knows
398 what they are doing. */
399 return;
400 }
401
402 warning
403 ("A handler for the OS ABI \"%s\" is not built into this configuration\n"
404 "of GDB. Attempting to continue with the default %s settings.\n",
405 gdbarch_osabi_name (info.osabi),
406 info.bfd_arch_info->printable_name);
407}
408
409/* Limit on the amount of data to be read. */
410#define MAX_NOTESZ 128
411
412/* Return non-zero if NOTE matches NAME, DESCSZ and TYPE. If
413 *SECTSIZE is non-zero, then this reads that many bytes from
414 the start of the section and clears *SECTSIZE. */
415
416static int
417check_note (bfd *abfd, asection *sect, char *note, unsigned int *sectsize,
418 const char *name, unsigned long descsz, unsigned long type)
419{
420 unsigned long notesz;
421
422 if (*sectsize)
423 {
424 if (!bfd_get_section_contents (abfd, sect, note, 0, *sectsize))
425 return 0;
426 *sectsize = 0;
427 }
428
429 /* Calculate the size of this note. */
430 notesz = strlen (name) + 1;
431 notesz = ((notesz + 3) & ~3);
432 notesz += descsz;
433 notesz = ((notesz + 3) & ~3);
434
435 /* If this assertion triggers, increase MAX_NOTESZ. */
436 gdb_assert (notesz <= MAX_NOTESZ);
437
438 /* Check whether SECT is big enough to contain the complete note. */
439 if (notesz > bfd_section_size (sect))
440 return 0;
441
442 /* Check the note name. */
443 if (bfd_h_get_32 (abfd, note) != (strlen (name) + 1)
444 || strcmp (note + 12, name) != 0)
445 return 0;
446
447 /* Check the descriptor size. */
448 if (bfd_h_get_32 (abfd, note + 4) != descsz)
449 return 0;
450
451 /* Check the note type. */
452 if (bfd_h_get_32 (abfd, note + 8) != type)
453 return 0;
454
455 return 1;
456}
457
458/* Generic sniffer for ELF flavoured files. */
459
460void
462 enum gdb_osabi *osabi)
463{
464 const char *name;
465 unsigned int sectsize;
466
467 name = bfd_section_name (sect);
468 sectsize = bfd_section_size (sect);
469
470 /* Limit the amount of data to read. */
471 if (sectsize > MAX_NOTESZ)
472 sectsize = MAX_NOTESZ;
473
474 /* We lazily read the section data here. Since we use
475 BFD_DECOMPRESS, we can't use bfd_get_section_contents on a
476 compressed section. But, since note sections are not compressed,
477 deferring the reading until we recognize the section avoids any
478 error. */
479 char note[MAX_NOTESZ];
480
481 /* .note.ABI-tag notes, used by GNU/Linux and FreeBSD. */
482 if (strcmp (name, ".note.ABI-tag") == 0)
483 {
484 /* GNU. */
485 if (check_note (abfd, sect, note, &sectsize, "GNU", 16, NT_GNU_ABI_TAG))
486 {
487 unsigned int abi_tag = bfd_h_get_32 (abfd, note + 16);
488
489 switch (abi_tag)
490 {
491 case GNU_ABI_TAG_LINUX:
493 break;
494
495 case GNU_ABI_TAG_HURD:
497 break;
498
499 case GNU_ABI_TAG_SOLARIS:
501 break;
502
503 case GNU_ABI_TAG_FREEBSD:
505 break;
506
507 case GNU_ABI_TAG_NETBSD:
509 break;
510
511 default:
512 warning (_("GNU ABI tag value %u unrecognized."), abi_tag);
513 break;
514 }
515 return;
516 }
517
518 /* FreeBSD. */
519 if (check_note (abfd, sect, note, &sectsize, "FreeBSD", 4,
520 NT_FREEBSD_ABI_TAG))
521 {
522 /* There is no need to check the version yet. */
524 return;
525 }
526
527 return;
528 }
529
530 /* .note.netbsd.ident notes, used by NetBSD. */
531 if (strcmp (name, ".note.netbsd.ident") == 0
532 && check_note (abfd, sect, note, &sectsize, "NetBSD", 4, NT_NETBSD_IDENT))
533 {
534 /* There is no need to check the version yet. */
536 return;
537 }
538
539 /* .note.openbsd.ident notes, used by OpenBSD. */
540 if (strcmp (name, ".note.openbsd.ident") == 0
541 && check_note (abfd, sect, note, &sectsize, "OpenBSD", 4,
542 NT_OPENBSD_IDENT))
543 {
544 /* There is no need to check the version yet. */
546 return;
547 }
548
549 /* .note.netbsdcore.procinfo notes, used by NetBSD. */
550 if (strcmp (name, ".note.netbsdcore.procinfo") == 0)
551 {
553 return;
554 }
555}
556
557static enum gdb_osabi
559{
560 unsigned int elfosabi;
562
563 elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
564
565 switch (elfosabi)
566 {
567 case ELFOSABI_NONE:
568 case ELFOSABI_GNU:
569 case ELFOSABI_HPUX:
570 /* When the EI_OSABI field in the ELF header is ELFOSABI_NONE
571 (0), then the ELF structures in the file are conforming to
572 the base specification for that machine (there are no
573 OS-specific extensions). In order to determine the real OS
574 in use, we must look for OS-specific notes.
575
576 The same applies for ELFOSABI_GNU: this can mean GNU/Hurd,
577 GNU/Linux, and possibly more. */
578
579 /* And likewise ELFOSABI_HPUX. For some reason the default
580 value for the EI_OSABI field is ELFOSABI_HPUX for all PA-RISC
581 targets (with the exception of GNU/Linux). */
582 for (asection *sect : gdb_bfd_sections (abfd))
584 break;
585
586 case ELFOSABI_FREEBSD:
588 break;
589
590 case ELFOSABI_NETBSD:
592 break;
593
594 case ELFOSABI_SOLARIS:
596 break;
597
598 case ELFOSABI_OPENVMS:
600 break;
601 }
602
604 {
605 /* The FreeBSD folks have been naughty; they stored the string
606 "FreeBSD" in the padding of the e_ident field of the ELF
607 header to "brand" their ELF binaries in FreeBSD 3.x. */
608 if (memcmp (&elf_elfheader (abfd)->e_ident[8],
609 "FreeBSD", sizeof ("FreeBSD")) == 0)
611 }
612
613 return osabi;
614}
615
616static void
617set_osabi (const char *args, int from_tty, struct cmd_list_element *c)
618{
619 if (strcmp (set_osabi_string, "auto") == 0)
621 else if (strcmp (set_osabi_string, "default") == 0)
622 {
625 }
626 else
627 {
628 int i;
629
630 for (i = 1; i < GDB_OSABI_INVALID; i++)
631 {
632 enum gdb_osabi osabi = (enum gdb_osabi) i;
633
634 if (strcmp (set_osabi_string, gdbarch_osabi_name (osabi)) == 0)
635 {
638 break;
639 }
640 }
641 if (i == GDB_OSABI_INVALID)
642 internal_error (_("Invalid OS ABI \"%s\" passed to command handler."),
644 }
645
646 /* NOTE: At some point (true multiple architectures) we'll need to be more
647 graceful here. */
648 gdbarch_info info;
649 if (! gdbarch_update_p (info))
650 internal_error (_("Updating OS ABI failed."));
651}
652
653static void
654show_osabi (struct ui_file *file, int from_tty, struct cmd_list_element *c,
655 const char *value)
656{
658 gdb_printf (file,
659 _("The current OS ABI is \"auto\" "
660 "(currently \"%s\").\n"),
662 else
663 gdb_printf (file, _("The current OS ABI is \"%s\".\n"),
665
667 gdb_printf (file, _("The default OS ABI is \"%s\".\n"),
669}
670
672void
674{
675 if (strcmp (gdb_osabi_names[GDB_OSABI_INVALID].pretty, "<invalid>") != 0)
676 internal_error
677 (_("_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent"));
678
679 /* Register a generic sniffer for ELF flavoured files. */
680 gdbarch_register_osabi_sniffer (bfd_arch_unknown,
681 bfd_target_elf_flavour,
683
684 /* Register the "set osabi" command. */
687 gdb_assert (strcmp (set_osabi_string, "auto") == 0);
690 _("Set OS ABI of target."),
691 _("Show OS ABI of target."),
692 NULL, set_osabi, show_osabi,
693 &setlist, &showlist);
694}
const char *const name
int gdbarch_update_p(struct gdbarch_info info)
Definition arch-utils.c:585
struct gdbarch * get_current_arch(void)
Definition arch-utils.c:846
struct cmd_list_element * showlist
Definition cli-cmds.c:127
struct cmd_list_element * setlist
Definition cli-cmds.c:119
set_show_commands add_setshow_enum_cmd(const char *name, enum command_class theclass, const char *const *enumlist, const char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:688
@ class_support
Definition command.h:58
static gdb_bfd_section_range gdb_bfd_sections(bfd *abfd)
Definition gdb_bfd.h:234
enum gdb_osabi gdbarch_osabi(struct gdbarch *gdbarch)
Definition gdbarch.c:1414
static const char * set_osabi_string
Definition osabi.c:43
static void set_osabi(const char *args, int from_tty, struct cmd_list_element *c)
Definition osabi.c:617
void gdbarch_register_osabi(enum bfd_architecture arch, unsigned long machine, enum gdb_osabi osabi, void(*init_osabi)(struct gdbarch_info, struct gdbarch *))
Definition osabi.c:146
static struct gdb_osabi_handler * gdbarch_osabi_handler(struct gdbarch_info info)
Definition osabi.c:334
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition osabi.c:382
@ osabi_default
Definition osabi.c:35
@ osabi_auto
Definition osabi.c:35
@ osabi_user
Definition osabi.c:35
static enum gdb_osabi generic_elf_osabi_sniffer(bfd *abfd)
Definition osabi.c:558
static enum @145 user_osabi_state
void generic_elf_osabi_sniff_abi_tag_sections(bfd *abfd, asection *sect, enum gdb_osabi *osabi)
Definition osabi.c:461
const char * osabi_triplet_regexp(enum gdb_osabi osabi)
Definition osabi.c:101
static enum gdb_osabi user_selected_osabi
Definition osabi.c:36
bool has_gdb_osabi_handler(struct gdbarch_info info)
Definition osabi.c:376
void _initialize_gdb_osabi()
Definition osabi.c:673
#define GDB_OSABI_DEFAULT
Definition osabi.c:31
static struct gdb_osabi_handler * gdb_osabi_handler_list
Definition osabi.c:143
static void show_osabi(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition osabi.c:654
void gdbarch_register_osabi_sniffer(enum bfd_architecture arch, enum bfd_flavour flavour, enum gdb_osabi(*sniffer_fn)(bfd *))
Definition osabi.c:220
static const char * gdb_osabi_available_names[GDB_OSABI_INVALID+3]
Definition osabi.c:37
enum gdb_osabi gdbarch_lookup_osabi(bfd *abfd)
Definition osabi.c:237
const char * gdbarch_osabi_name(enum gdb_osabi osabi)
Definition osabi.c:90
static int can_run_code_for(const struct bfd_arch_info *a, const struct bfd_arch_info *b)
Definition osabi.c:317
static const struct osabi_names gdb_osabi_names[]
Definition osabi.c:60
enum gdb_osabi osabi_from_tdesc_string(const char *name)
Definition osabi.c:113
#define MAX_NOTESZ
Definition osabi.c:410
static struct gdb_osabi_sniffer * gdb_osabi_sniffer_list
Definition osabi.c:217
static int check_note(bfd *abfd, asection *sect, char *note, unsigned int *sectsize, const char *name, unsigned long descsz, unsigned long type)
Definition osabi.c:417
gdb_osabi
Definition osabi.h:25
@ GDB_OSABI_SOLARIS
Definition osabi.h:31
@ GDB_OSABI_NETBSD
Definition osabi.h:34
@ GDB_OSABI_FREEBSD
Definition osabi.h:33
@ GDB_OSABI_LINUX
Definition osabi.h:32
@ GDB_OSABI_OPENBSD
Definition osabi.h:35
@ GDB_OSABI_HURD
Definition osabi.h:30
@ GDB_OSABI_OPENVMS
Definition osabi.h:44
@ GDB_OSABI_INVALID
Definition osabi.h:50
@ GDB_OSABI_NONE
Definition osabi.h:27
@ GDB_OSABI_UNKNOWN
Definition osabi.h:26
enum gdb_osabi osabi
Definition osabi.c:139
const struct bfd_arch_info * arch_info
Definition osabi.c:138
struct gdb_osabi_handler * next
Definition osabi.c:137
void(* init_osabi)(struct gdbarch_info, struct gdbarch *)
Definition osabi.c:140
enum bfd_architecture arch
Definition osabi.c:212
struct gdb_osabi_sniffer * next
Definition osabi.c:211
enum bfd_flavour flavour
Definition osabi.c:213
enum gdb_osabi(* sniffer)(bfd *)
Definition osabi.c:214
const char * pretty
Definition osabi.c:51
const char * regexp
Definition osabi.c:55
Definition value.h:130
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886