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