1 /* OS ABI variant handling for GDB.
3 Copyright (C) 2001-2015 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
23 #include "arch-utils.h"
29 #ifndef GDB_OSABI_DEFAULT
30 #define GDB_OSABI_DEFAULT GDB_OSABI_UNKNOWN
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] = {
42 static const char *set_osabi_string;
44 /* Names associated with each osabi. */
48 /* The "pretty" name. */
52 /* The triplet regexp, or NULL if not known. */
57 /* This table matches the indices assigned to enum gdb_osabi. Keep
59 static const struct osabi_names gdb_osabi_names[] =
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 },
75 { "HP/UX ELF", NULL },
76 { "HP/UX SOM", NULL },
77 { "QNX Neutrino", NULL },
84 { "LynxOS178", NULL },
92 gdbarch_osabi_name (enum gdb_osabi osabi)
94 if (osabi >= GDB_OSABI_UNKNOWN && osabi < GDB_OSABI_INVALID)
95 return gdb_osabi_names[osabi].pretty;
97 return gdb_osabi_names[GDB_OSABI_INVALID].pretty;
103 osabi_triplet_regexp (enum gdb_osabi osabi)
105 if (osabi >= GDB_OSABI_UNKNOWN && osabi < GDB_OSABI_INVALID)
106 return gdb_osabi_names[osabi].regexp;
108 return gdb_osabi_names[GDB_OSABI_INVALID].regexp;
111 /* Lookup the OS ABI corresponding to the specified target description
115 osabi_from_tdesc_string (const char *name)
119 for (i = 0; i < ARRAY_SIZE (gdb_osabi_names); i++)
120 if (strcmp (name, gdb_osabi_names[i].pretty) == 0)
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;
126 if (osabi == GDB_OSABI_INVALID)
127 return GDB_OSABI_UNKNOWN;
132 return GDB_OSABI_UNKNOWN;
135 /* Handler for a given architecture/OS ABI pair. There should be only
136 one handler for a given OS ABI each architecture family. */
137 struct gdb_osabi_handler
139 struct gdb_osabi_handler *next;
140 const struct bfd_arch_info *arch_info;
141 enum gdb_osabi osabi;
142 void (*init_osabi)(struct gdbarch_info, struct gdbarch *);
145 static struct gdb_osabi_handler *gdb_osabi_handler_list;
148 gdbarch_register_osabi (enum bfd_architecture arch, unsigned long machine,
149 enum gdb_osabi osabi,
150 void (*init_osabi)(struct gdbarch_info,
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;
157 /* Registering an OS ABI handler for "unknown" is not allowed. */
158 if (osabi == GDB_OSABI_UNKNOWN)
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));
170 gdb_assert (arch_info);
172 for (handler_p = &gdb_osabi_handler_list; *handler_p != NULL;
173 handler_p = &(*handler_p)->next)
175 if ((*handler_p)->arch_info == arch_info
176 && (*handler_p)->osabi == osabi)
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;
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;
197 /* Add this OS ABI to the list of enum values for "set osabi", if it isn't
199 for (name_ptr = gdb_osabi_available_names; *name_ptr; name_ptr ++)
201 if (*name_ptr == gdbarch_osabi_name (osabi))
204 *name_ptr++ = gdbarch_osabi_name (osabi);
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. */
214 struct gdb_osabi_sniffer
216 struct gdb_osabi_sniffer *next;
217 enum bfd_architecture arch; /* bfd_arch_unknown == wildcard */
218 enum bfd_flavour flavour;
219 enum gdb_osabi (*sniffer)(bfd *);
222 static struct gdb_osabi_sniffer *gdb_osabi_sniffer_list;
225 gdbarch_register_osabi_sniffer (enum bfd_architecture arch,
226 enum bfd_flavour flavour,
227 enum gdb_osabi (*sniffer_fn)(bfd *))
229 struct gdb_osabi_sniffer *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;
237 sniffer->next = gdb_osabi_sniffer_list;
238 gdb_osabi_sniffer_list = sniffer;
243 gdbarch_lookup_osabi (bfd *abfd)
245 struct gdb_osabi_sniffer *sniffer;
246 enum gdb_osabi osabi, match;
249 /* If we aren't in "auto" mode, return the specified OS ABI. */
250 if (user_osabi_state == osabi_user)
251 return user_selected_osabi;
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. */
257 return GDB_OSABI_UNKNOWN;
259 match = GDB_OSABI_UNKNOWN;
262 for (sniffer = gdb_osabi_sniffer_list; sniffer != NULL;
263 sniffer = sniffer->next)
265 if ((sniffer->arch == bfd_arch_unknown /* wildcard */
266 || sniffer->arch == bfd_get_arch (abfd))
267 && sniffer->flavour == bfd_get_flavour (abfd))
269 osabi = (*sniffer->sniffer) (abfd);
270 if (osabi < GDB_OSABI_UNKNOWN || osabi >= GDB_OSABI_INVALID)
274 _("gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer "
275 "for architecture %s flavour %d"),
277 bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
278 (int) bfd_get_flavour (abfd));
280 else if (osabi != GDB_OSABI_UNKNOWN)
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
286 if (match != GDB_OSABI_UNKNOWN)
288 if ((match_specific && sniffer->arch != bfd_arch_unknown)
289 || (!match_specific && sniffer->arch == bfd_arch_unknown))
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));
302 else if (sniffer->arch != bfd_arch_unknown)
311 if (sniffer->arch != bfd_arch_unknown)
322 /* Return non-zero if architecture A can run code written for
325 can_run_code_for (const struct bfd_arch_info *a, const struct bfd_arch_info *b)
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
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);
341 gdbarch_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
343 struct gdb_osabi_handler *handler;
345 if (info.osabi == GDB_OSABI_UNKNOWN)
347 /* Don't complain about an unknown OSABI. Assume the user knows
348 what they are doing. */
352 for (handler = gdb_osabi_handler_list; handler != NULL;
353 handler = handler->next)
355 if (handler->osabi != info.osabi)
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.
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))
380 (*handler->init_osabi) (info, gdbarch);
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);
392 /* Limit on the amount of data to be read. */
393 #define MAX_NOTESZ 128
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. */
400 check_note (bfd *abfd, asection *sect, char *note, unsigned int *sectsize,
401 const char *name, unsigned long descsz, unsigned long type)
403 unsigned long notesz;
407 if (!bfd_get_section_contents (abfd, sect, note, 0, *sectsize))
412 /* Calculate the size of this note. */
413 notesz = strlen (name) + 1;
414 notesz = ((notesz + 3) & ~3);
416 notesz = ((notesz + 3) & ~3);
418 /* If this assertion triggers, increase MAX_NOTESZ. */
419 gdb_assert (notesz <= MAX_NOTESZ);
421 /* Check whether SECT is big enough to comtain the complete note. */
422 if (notesz > bfd_section_size (abfd, sect))
425 /* Check the note name. */
426 if (bfd_h_get_32 (abfd, note) != (strlen (name) + 1)
427 || strcmp (note + 12, name) != 0)
430 /* Check the descriptor size. */
431 if (bfd_h_get_32 (abfd, note + 4) != descsz)
434 /* Check the note type. */
435 if (bfd_h_get_32 (abfd, note + 8) != type)
441 /* Generic sniffer for ELF flavoured files. */
444 generic_elf_osabi_sniff_abi_tag_sections (bfd *abfd, asection *sect, void *obj)
446 enum gdb_osabi *osabi = obj;
448 unsigned int sectsize;
451 name = bfd_get_section_name (abfd, sect);
452 sectsize = bfd_section_size (abfd, sect);
454 /* Limit the amount of data to read. */
455 if (sectsize > MAX_NOTESZ)
456 sectsize = MAX_NOTESZ;
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
463 note = alloca (sectsize);
465 /* .note.ABI-tag notes, used by GNU/Linux and FreeBSD. */
466 if (strcmp (name, ".note.ABI-tag") == 0)
469 if (check_note (abfd, sect, note, §size, "GNU", 16, NT_GNU_ABI_TAG))
471 unsigned int abi_tag = bfd_h_get_32 (abfd, note + 16);
475 case GNU_ABI_TAG_LINUX:
476 *osabi = GDB_OSABI_LINUX;
479 case GNU_ABI_TAG_HURD:
480 *osabi = GDB_OSABI_HURD;
483 case GNU_ABI_TAG_SOLARIS:
484 *osabi = GDB_OSABI_SOLARIS;
487 case GNU_ABI_TAG_FREEBSD:
488 *osabi = GDB_OSABI_FREEBSD_ELF;
491 case GNU_ABI_TAG_NETBSD:
492 *osabi = GDB_OSABI_NETBSD_ELF;
496 internal_error (__FILE__, __LINE__,
497 _("generic_elf_osabi_sniff_abi_tag_sections: "
498 "unknown OS number %d"),
505 if (check_note (abfd, sect, note, §size, "FreeBSD", 4,
508 /* There is no need to check the version yet. */
509 *osabi = GDB_OSABI_FREEBSD_ELF;
516 /* .note.netbsd.ident notes, used by NetBSD. */
517 if (strcmp (name, ".note.netbsd.ident") == 0
518 && check_note (abfd, sect, note, §size, "NetBSD", 4, NT_NETBSD_IDENT))
520 /* There is no need to check the version yet. */
521 *osabi = GDB_OSABI_NETBSD_ELF;
525 /* .note.openbsd.ident notes, used by OpenBSD. */
526 if (strcmp (name, ".note.openbsd.ident") == 0
527 && check_note (abfd, sect, note, §size, "OpenBSD", 4,
530 /* There is no need to check the version yet. */
531 *osabi = GDB_OSABI_OPENBSD_ELF;
535 /* .note.netbsdcore.procinfo notes, used by NetBSD. */
536 if (strcmp (name, ".note.netbsdcore.procinfo") == 0)
538 *osabi = GDB_OSABI_NETBSD_ELF;
543 static enum gdb_osabi
544 generic_elf_osabi_sniffer (bfd *abfd)
546 unsigned int elfosabi;
547 enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
549 elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
555 /* When the EI_OSABI field in the ELF header is ELFOSABI_NONE
556 (0), then the ELF structures in the file are conforming to
557 the base specification for that machine (there are no
558 OS-specific extensions). In order to determine the real OS
559 in use, we must look for OS-specific notes.
561 The same applies for ELFOSABI_GNU: this can mean GNU/Hurd,
562 GNU/Linux, and possibly more. */
563 bfd_map_over_sections (abfd,
564 generic_elf_osabi_sniff_abi_tag_sections,
568 case ELFOSABI_FREEBSD:
569 osabi = GDB_OSABI_FREEBSD_ELF;
572 case ELFOSABI_NETBSD:
573 osabi = GDB_OSABI_NETBSD_ELF;
576 case ELFOSABI_SOLARIS:
577 osabi = GDB_OSABI_SOLARIS;
581 /* For some reason the default value for the EI_OSABI field is
582 ELFOSABI_HPUX for all PA-RISC targets (with the exception of
583 GNU/Linux). We use HP-UX ELF as the default, but let any
584 OS-specific notes override this. */
585 osabi = GDB_OSABI_HPUX_ELF;
586 bfd_map_over_sections (abfd,
587 generic_elf_osabi_sniff_abi_tag_sections,
591 case ELFOSABI_OPENVMS:
592 osabi = GDB_OSABI_OPENVMS;
596 if (osabi == GDB_OSABI_UNKNOWN)
598 /* The FreeBSD folks have been naughty; they stored the string
599 "FreeBSD" in the padding of the e_ident field of the ELF
600 header to "brand" their ELF binaries in FreeBSD 3.x. */
601 if (memcmp (&elf_elfheader (abfd)->e_ident[8],
602 "FreeBSD", sizeof ("FreeBSD")) == 0)
603 osabi = GDB_OSABI_FREEBSD_ELF;
610 set_osabi (char *args, int from_tty, struct cmd_list_element *c)
612 struct gdbarch_info info;
614 if (strcmp (set_osabi_string, "auto") == 0)
615 user_osabi_state = osabi_auto;
616 else if (strcmp (set_osabi_string, "default") == 0)
618 user_selected_osabi = GDB_OSABI_DEFAULT;
619 user_osabi_state = osabi_user;
621 else if (strcmp (set_osabi_string, "none") == 0)
623 user_selected_osabi = GDB_OSABI_UNKNOWN;
624 user_osabi_state = osabi_user;
630 for (i = 1; i < GDB_OSABI_INVALID; i++)
631 if (strcmp (set_osabi_string, gdbarch_osabi_name (i)) == 0)
633 user_selected_osabi = i;
634 user_osabi_state = osabi_user;
637 if (i == GDB_OSABI_INVALID)
638 internal_error (__FILE__, __LINE__,
639 _("Invalid OS ABI \"%s\" passed to command handler."),
643 /* NOTE: At some point (true multiple architectures) we'll need to be more
645 gdbarch_info_init (&info);
646 if (! gdbarch_update_p (info))
647 internal_error (__FILE__, __LINE__, _("Updating OS ABI failed."));
651 show_osabi (struct ui_file *file, int from_tty, struct cmd_list_element *c,
654 if (user_osabi_state == osabi_auto)
655 fprintf_filtered (file,
656 _("The current OS ABI is \"auto\" "
657 "(currently \"%s\").\n"),
658 gdbarch_osabi_name (gdbarch_osabi (get_current_arch ())));
660 fprintf_filtered (file, _("The current OS ABI is \"%s\".\n"),
661 gdbarch_osabi_name (user_selected_osabi));
663 if (GDB_OSABI_DEFAULT != GDB_OSABI_UNKNOWN)
664 fprintf_filtered (file, _("The default OS ABI is \"%s\".\n"),
665 gdbarch_osabi_name (GDB_OSABI_DEFAULT));
668 extern initialize_file_ftype _initialize_gdb_osabi; /* -Wmissing-prototype */
671 _initialize_gdb_osabi (void)
673 if (strcmp (gdb_osabi_names[GDB_OSABI_INVALID].pretty, "<invalid>") != 0)
676 _("_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent"));
678 /* Register a generic sniffer for ELF flavoured files. */
679 gdbarch_register_osabi_sniffer (bfd_arch_unknown,
680 bfd_target_elf_flavour,
681 generic_elf_osabi_sniffer);
683 /* Register the "set osabi" command. */
684 add_setshow_enum_cmd ("osabi", class_support, gdb_osabi_available_names,
686 _("Set OS ABI of target."),
687 _("Show OS ABI of target."),
688 NULL, set_osabi, show_osabi,
689 &setlist, &showlist);
690 user_osabi_state = osabi_auto;