GDB (xrefs)

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