1 /* OS ABI variant handling for GDB.
3 Copyright (C) 2001-2013 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/>. */
22 #include "gdb_assert.h"
23 #include "gdb_string.h"
26 #include "arch-utils.h"
32 #ifndef GDB_OSABI_DEFAULT
33 #define GDB_OSABI_DEFAULT GDB_OSABI_UNKNOWN
36 /* State for the "set osabi" command. */
37 static enum { osabi_auto, osabi_default, osabi_user } user_osabi_state;
38 static enum gdb_osabi user_selected_osabi;
39 static const char *gdb_osabi_available_names[GDB_OSABI_INVALID + 3] = {
45 static const char *set_osabi_string;
47 /* This table matches the indices assigned to enum gdb_osabi. Keep
49 static const char * const gdb_osabi_names[] =
84 gdbarch_osabi_name (enum gdb_osabi osabi)
86 if (osabi >= GDB_OSABI_UNKNOWN && osabi < GDB_OSABI_INVALID)
87 return gdb_osabi_names[osabi];
89 return gdb_osabi_names[GDB_OSABI_INVALID];
92 /* Lookup the OS ABI corresponding to the specified target description
96 osabi_from_tdesc_string (const char *name)
100 for (i = 0; i < ARRAY_SIZE (gdb_osabi_names); i++)
101 if (strcmp (name, gdb_osabi_names[i]) == 0)
103 /* See note above: the name table matches the indices assigned
104 to enum gdb_osabi. */
105 enum gdb_osabi osabi = (enum gdb_osabi) i;
107 if (osabi == GDB_OSABI_INVALID)
108 return GDB_OSABI_UNKNOWN;
113 return GDB_OSABI_UNKNOWN;
116 /* Handler for a given architecture/OS ABI pair. There should be only
117 one handler for a given OS ABI each architecture family. */
118 struct gdb_osabi_handler
120 struct gdb_osabi_handler *next;
121 const struct bfd_arch_info *arch_info;
122 enum gdb_osabi osabi;
123 void (*init_osabi)(struct gdbarch_info, struct gdbarch *);
126 static struct gdb_osabi_handler *gdb_osabi_handler_list;
129 gdbarch_register_osabi (enum bfd_architecture arch, unsigned long machine,
130 enum gdb_osabi osabi,
131 void (*init_osabi)(struct gdbarch_info,
134 struct gdb_osabi_handler **handler_p;
135 const struct bfd_arch_info *arch_info = bfd_lookup_arch (arch, machine);
136 const char **name_ptr;
138 /* Registering an OS ABI handler for "unknown" is not allowed. */
139 if (osabi == GDB_OSABI_UNKNOWN)
143 _("gdbarch_register_osabi: An attempt to register a handler for "
144 "OS ABI \"%s\" for architecture %s was made. The handler will "
145 "not be registered"),
146 gdbarch_osabi_name (osabi),
147 bfd_printable_arch_mach (arch, machine));
151 gdb_assert (arch_info);
153 for (handler_p = &gdb_osabi_handler_list; *handler_p != NULL;
154 handler_p = &(*handler_p)->next)
156 if ((*handler_p)->arch_info == arch_info
157 && (*handler_p)->osabi == osabi)
161 _("gdbarch_register_osabi: A handler for OS ABI \"%s\" "
162 "has already been registered for architecture %s"),
163 gdbarch_osabi_name (osabi),
164 arch_info->printable_name);
165 /* If user wants to continue, override previous definition. */
166 (*handler_p)->init_osabi = init_osabi;
172 = (struct gdb_osabi_handler *) xmalloc (sizeof (struct gdb_osabi_handler));
173 (*handler_p)->next = NULL;
174 (*handler_p)->arch_info = arch_info;
175 (*handler_p)->osabi = osabi;
176 (*handler_p)->init_osabi = init_osabi;
178 /* Add this OS ABI to the list of enum values for "set osabi", if it isn't
180 for (name_ptr = gdb_osabi_available_names; *name_ptr; name_ptr ++)
182 if (*name_ptr == gdbarch_osabi_name (osabi))
185 *name_ptr++ = gdbarch_osabi_name (osabi);
190 /* Sniffer to find the OS ABI for a given file's architecture and flavour.
191 It is legal to have multiple sniffers for each arch/flavour pair, to
192 disambiguate one OS's a.out from another, for example. The first sniffer
193 to return something other than GDB_OSABI_UNKNOWN wins, so a sniffer should
194 be careful to claim a file only if it knows for sure what it is. */
195 struct gdb_osabi_sniffer
197 struct gdb_osabi_sniffer *next;
198 enum bfd_architecture arch; /* bfd_arch_unknown == wildcard */
199 enum bfd_flavour flavour;
200 enum gdb_osabi (*sniffer)(bfd *);
203 static struct gdb_osabi_sniffer *gdb_osabi_sniffer_list;
206 gdbarch_register_osabi_sniffer (enum bfd_architecture arch,
207 enum bfd_flavour flavour,
208 enum gdb_osabi (*sniffer_fn)(bfd *))
210 struct gdb_osabi_sniffer *sniffer;
213 (struct gdb_osabi_sniffer *) xmalloc (sizeof (struct gdb_osabi_sniffer));
214 sniffer->arch = arch;
215 sniffer->flavour = flavour;
216 sniffer->sniffer = sniffer_fn;
218 sniffer->next = gdb_osabi_sniffer_list;
219 gdb_osabi_sniffer_list = sniffer;
224 gdbarch_lookup_osabi (bfd *abfd)
226 struct gdb_osabi_sniffer *sniffer;
227 enum gdb_osabi osabi, match;
230 /* If we aren't in "auto" mode, return the specified OS ABI. */
231 if (user_osabi_state == osabi_user)
232 return user_selected_osabi;
234 /* If we don't have a binary, just return unknown. The caller may
235 have other sources the OSABI can be extracted from, e.g., the
236 target description. */
238 return GDB_OSABI_UNKNOWN;
240 match = GDB_OSABI_UNKNOWN;
243 for (sniffer = gdb_osabi_sniffer_list; sniffer != NULL;
244 sniffer = sniffer->next)
246 if ((sniffer->arch == bfd_arch_unknown /* wildcard */
247 || sniffer->arch == bfd_get_arch (abfd))
248 && sniffer->flavour == bfd_get_flavour (abfd))
250 osabi = (*sniffer->sniffer) (abfd);
251 if (osabi < GDB_OSABI_UNKNOWN || osabi >= GDB_OSABI_INVALID)
255 _("gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer "
256 "for architecture %s flavour %d"),
258 bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
259 (int) bfd_get_flavour (abfd));
261 else if (osabi != GDB_OSABI_UNKNOWN)
263 /* A specific sniffer always overrides a generic sniffer.
264 Croak on multiple match if the two matches are of the
265 same class. If the user wishes to continue, we'll use
267 if (match != GDB_OSABI_UNKNOWN)
269 if ((match_specific && sniffer->arch != bfd_arch_unknown)
270 || (!match_specific && sniffer->arch == bfd_arch_unknown))
274 _("gdbarch_lookup_osabi: multiple %sspecific OS ABI "
275 "match for architecture %s flavour %d: first "
276 "match \"%s\", second match \"%s\""),
277 match_specific ? "" : "non-",
278 bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
279 (int) bfd_get_flavour (abfd),
280 gdbarch_osabi_name (match),
281 gdbarch_osabi_name (osabi));
283 else if (sniffer->arch != bfd_arch_unknown)
292 if (sniffer->arch != bfd_arch_unknown)
303 /* Return non-zero if architecture A can run code written for
306 can_run_code_for (const struct bfd_arch_info *a, const struct bfd_arch_info *b)
308 /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
309 incompatible. But if they are compatible, it returns the 'more
310 featureful' of the two arches. That is, if A can run code
311 written for B, but B can't run code written for A, then it'll
314 struct bfd_arch_info objects are singletons: that is, there's
315 supposed to be exactly one instance for a given machine. So you
316 can tell whether two are equivalent by comparing pointers. */
317 return (a == b || a->compatible (a, b) == a);
322 gdbarch_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
324 struct gdb_osabi_handler *handler;
326 if (info.osabi == GDB_OSABI_UNKNOWN)
328 /* Don't complain about an unknown OSABI. Assume the user knows
329 what they are doing. */
333 for (handler = gdb_osabi_handler_list; handler != NULL;
334 handler = handler->next)
336 if (handler->osabi != info.osabi)
339 /* If the architecture described by ARCH_INFO can run code for
340 the architcture we registered the handler for, then the
341 handler is applicable. Note, though, that if the handler is
342 for an architecture that is a superset of ARCH_INFO, we can't
343 use that --- it would be perfectly correct for it to install
344 gdbarch methods that refer to registers / instructions /
345 other facilities ARCH_INFO doesn't have.
347 NOTE: kettenis/20021027: There may be more than one machine
348 type that is compatible with the desired machine type. Right
349 now we simply return the first match, which is fine for now.
350 However, we might want to do something smarter in the future. */
351 /* NOTE: cagney/2003-10-23: The code for "a can_run_code_for b"
352 is implemented using BFD's compatible method (a->compatible
353 (b) == a -- the lowest common denominator between a and b is
354 a). That method's definition of compatible may not be as you
355 expect. For instance the test "amd64 can run code for i386"
356 (or more generally "64-bit ISA can run code for the 32-bit
357 ISA"). BFD doesn't normally consider 32-bit and 64-bit
358 "compatible" so it doesn't succeed. */
359 if (can_run_code_for (info.bfd_arch_info, handler->arch_info))
361 (*handler->init_osabi) (info, gdbarch);
367 ("A handler for the OS ABI \"%s\" is not built into this configuration\n"
368 "of GDB. Attempting to continue with the default %s settings.\n",
369 gdbarch_osabi_name (info.osabi),
370 info.bfd_arch_info->printable_name);
373 /* Limit on the amount of data to be read. */
374 #define MAX_NOTESZ 128
376 /* Return non-zero if NOTE matches NAME, DESCSZ and TYPE. If
377 *SECTSIZE is non-zero, then this reads that many bytes from
378 the start of the section and clears *SECTSIZE. */
381 check_note (bfd *abfd, asection *sect, char *note, unsigned int *sectsize,
382 const char *name, unsigned long descsz, unsigned long type)
384 unsigned long notesz;
388 if (!bfd_get_section_contents (abfd, sect, note, 0, *sectsize))
393 /* Calculate the size of this note. */
394 notesz = strlen (name) + 1;
395 notesz = ((notesz + 3) & ~3);
397 notesz = ((notesz + 3) & ~3);
399 /* If this assertion triggers, increase MAX_NOTESZ. */
400 gdb_assert (notesz <= MAX_NOTESZ);
402 /* Check whether SECT is big enough to comtain the complete note. */
403 if (notesz > bfd_section_size (abfd, sect))
406 /* Check the note name. */
407 if (bfd_h_get_32 (abfd, note) != (strlen (name) + 1)
408 || strcmp (note + 12, name) != 0)
411 /* Check the descriptor size. */
412 if (bfd_h_get_32 (abfd, note + 4) != descsz)
415 /* Check the note type. */
416 if (bfd_h_get_32 (abfd, note + 8) != type)
422 /* Generic sniffer for ELF flavoured files. */
425 generic_elf_osabi_sniff_abi_tag_sections (bfd *abfd, asection *sect, void *obj)
427 enum gdb_osabi *osabi = obj;
429 unsigned int sectsize;
432 name = bfd_get_section_name (abfd, sect);
433 sectsize = bfd_section_size (abfd, sect);
435 /* Limit the amount of data to read. */
436 if (sectsize > MAX_NOTESZ)
437 sectsize = MAX_NOTESZ;
439 /* We lazily read the section data here. Since we use
440 BFD_DECOMPRESS, we can't use bfd_get_section_contents on a
441 compressed section. But, since note sections are not compressed,
442 deferring the reading until we recognize the section avoids any
444 note = alloca (sectsize);
446 /* .note.ABI-tag notes, used by GNU/Linux and FreeBSD. */
447 if (strcmp (name, ".note.ABI-tag") == 0)
450 if (check_note (abfd, sect, note, §size, "GNU", 16, NT_GNU_ABI_TAG))
452 unsigned int abi_tag = bfd_h_get_32 (abfd, note + 16);
456 case GNU_ABI_TAG_LINUX:
457 *osabi = GDB_OSABI_LINUX;
460 case GNU_ABI_TAG_HURD:
461 *osabi = GDB_OSABI_HURD;
464 case GNU_ABI_TAG_SOLARIS:
465 *osabi = GDB_OSABI_SOLARIS;
468 case GNU_ABI_TAG_FREEBSD:
469 *osabi = GDB_OSABI_FREEBSD_ELF;
472 case GNU_ABI_TAG_NETBSD:
473 *osabi = GDB_OSABI_NETBSD_ELF;
477 internal_error (__FILE__, __LINE__,
478 _("generic_elf_osabi_sniff_abi_tag_sections: "
479 "unknown OS number %d"),
486 if (check_note (abfd, sect, note, §size, "FreeBSD", 4,
489 /* There is no need to check the version yet. */
490 *osabi = GDB_OSABI_FREEBSD_ELF;
495 if (check_note (abfd, sect, note, "DragonFly", 4, NT_DRAGONFLY_ABI_TAG))
497 /* There is no need to check the version yet. */
498 *osabi = GDB_OSABI_DRAGONFLY;
505 /* .note.netbsd.ident notes, used by NetBSD. */
506 if (strcmp (name, ".note.netbsd.ident") == 0
507 && check_note (abfd, sect, note, §size, "NetBSD", 4, NT_NETBSD_IDENT))
509 /* There is no need to check the version yet. */
510 *osabi = GDB_OSABI_NETBSD_ELF;
514 /* .note.openbsd.ident notes, used by OpenBSD. */
515 if (strcmp (name, ".note.openbsd.ident") == 0
516 && check_note (abfd, sect, note, §size, "OpenBSD", 4,
519 /* There is no need to check the version yet. */
520 *osabi = GDB_OSABI_OPENBSD_ELF;
524 /* .note.netbsdcore.procinfo notes, used by NetBSD. */
525 if (strcmp (name, ".note.netbsdcore.procinfo") == 0)
527 *osabi = GDB_OSABI_NETBSD_ELF;
532 static enum gdb_osabi
533 generic_elf_osabi_sniffer (bfd *abfd)
535 unsigned int elfosabi;
536 enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
538 elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
544 /* When the EI_OSABI field in the ELF header is ELFOSABI_NONE
545 (0), then the ELF structures in the file are conforming to
546 the base specification for that machine (there are no
547 OS-specific extensions). In order to determine the real OS
548 in use, we must look for OS-specific notes.
550 The same applies for ELFOSABI_GNU: this can mean GNU/Hurd,
551 GNU/Linux, and possibly more. */
552 bfd_map_over_sections (abfd,
553 generic_elf_osabi_sniff_abi_tag_sections,
557 case ELFOSABI_FREEBSD:
558 osabi = GDB_OSABI_FREEBSD_ELF;
561 case ELFOSABI_NETBSD:
562 osabi = GDB_OSABI_NETBSD_ELF;
565 case ELFOSABI_SOLARIS:
566 osabi = GDB_OSABI_SOLARIS;
570 /* For some reason the default value for the EI_OSABI field is
571 ELFOSABI_HPUX for all PA-RISC targets (with the exception of
572 GNU/Linux). We use HP-UX ELF as the default, but let any
573 OS-specific notes override this. */
574 osabi = GDB_OSABI_HPUX_ELF;
575 bfd_map_over_sections (abfd,
576 generic_elf_osabi_sniff_abi_tag_sections,
580 case ELFOSABI_OPENVMS:
581 osabi = GDB_OSABI_OPENVMS;
585 if (osabi == GDB_OSABI_UNKNOWN)
587 /* The FreeBSD folks have been naughty; they stored the string
588 "FreeBSD" in the padding of the e_ident field of the ELF
589 header to "brand" their ELF binaries in FreeBSD 3.x. */
590 if (memcmp (&elf_elfheader (abfd)->e_ident[8],
591 "FreeBSD", sizeof ("FreeBSD")) == 0)
592 osabi = GDB_OSABI_FREEBSD_ELF;
599 set_osabi (char *args, int from_tty, struct cmd_list_element *c)
601 struct gdbarch_info info;
603 if (strcmp (set_osabi_string, "auto") == 0)
604 user_osabi_state = osabi_auto;
605 else if (strcmp (set_osabi_string, "default") == 0)
607 user_selected_osabi = GDB_OSABI_DEFAULT;
608 user_osabi_state = osabi_user;
610 else if (strcmp (set_osabi_string, "none") == 0)
612 user_selected_osabi = GDB_OSABI_UNKNOWN;
613 user_osabi_state = osabi_user;
619 for (i = 1; i < GDB_OSABI_INVALID; i++)
620 if (strcmp (set_osabi_string, gdbarch_osabi_name (i)) == 0)
622 user_selected_osabi = i;
623 user_osabi_state = osabi_user;
626 if (i == GDB_OSABI_INVALID)
627 internal_error (__FILE__, __LINE__,
628 _("Invalid OS ABI \"%s\" passed to command handler."),
632 /* NOTE: At some point (true multiple architectures) we'll need to be more
634 gdbarch_info_init (&info);
635 if (! gdbarch_update_p (info))
636 internal_error (__FILE__, __LINE__, _("Updating OS ABI failed."));
640 show_osabi (struct ui_file *file, int from_tty, struct cmd_list_element *c,
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 ())));
649 fprintf_filtered (file, _("The current OS ABI is \"%s\".\n"),
650 gdbarch_osabi_name (user_selected_osabi));
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));
657 extern initialize_file_ftype _initialize_gdb_osabi; /* -Wmissing-prototype */
660 _initialize_gdb_osabi (void)
662 if (strcmp (gdb_osabi_names[GDB_OSABI_INVALID], "<invalid>") != 0)
665 _("_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent"));
667 /* Register a generic sniffer for ELF flavoured files. */
668 gdbarch_register_osabi_sniffer (bfd_arch_unknown,
669 bfd_target_elf_flavour,
670 generic_elf_osabi_sniffer);
672 /* Register the "set osabi" command. */
673 add_setshow_enum_cmd ("osabi", class_support, gdb_osabi_available_names,
675 _("Set OS ABI of target."),
676 _("Show OS ABI of target."),
677 NULL, set_osabi, show_osabi,
678 &setlist, &showlist);
679 user_osabi_state = osabi_auto;