1 /* OS ABI variant handling for GDB.
3 Copyright (C) 2001-2014 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 /* This table matches the indices assigned to enum gdb_osabi. Keep
46 static const char * const gdb_osabi_names[] =
78 gdbarch_osabi_name (enum gdb_osabi osabi)
80 if (osabi >= GDB_OSABI_UNKNOWN && osabi < GDB_OSABI_INVALID)
81 return gdb_osabi_names[osabi];
83 return gdb_osabi_names[GDB_OSABI_INVALID];
86 /* Lookup the OS ABI corresponding to the specified target description
90 osabi_from_tdesc_string (const char *name)
94 for (i = 0; i < ARRAY_SIZE (gdb_osabi_names); i++)
95 if (strcmp (name, gdb_osabi_names[i]) == 0)
97 /* See note above: the name table matches the indices assigned
99 enum gdb_osabi osabi = (enum gdb_osabi) i;
101 if (osabi == GDB_OSABI_INVALID)
102 return GDB_OSABI_UNKNOWN;
107 return GDB_OSABI_UNKNOWN;
110 /* Handler for a given architecture/OS ABI pair. There should be only
111 one handler for a given OS ABI each architecture family. */
112 struct gdb_osabi_handler
114 struct gdb_osabi_handler *next;
115 const struct bfd_arch_info *arch_info;
116 enum gdb_osabi osabi;
117 void (*init_osabi)(struct gdbarch_info, struct gdbarch *);
120 static struct gdb_osabi_handler *gdb_osabi_handler_list;
123 gdbarch_register_osabi (enum bfd_architecture arch, unsigned long machine,
124 enum gdb_osabi osabi,
125 void (*init_osabi)(struct gdbarch_info,
128 struct gdb_osabi_handler **handler_p;
129 const struct bfd_arch_info *arch_info = bfd_lookup_arch (arch, machine);
130 const char **name_ptr;
132 /* Registering an OS ABI handler for "unknown" is not allowed. */
133 if (osabi == GDB_OSABI_UNKNOWN)
137 _("gdbarch_register_osabi: An attempt to register a handler for "
138 "OS ABI \"%s\" for architecture %s was made. The handler will "
139 "not be registered"),
140 gdbarch_osabi_name (osabi),
141 bfd_printable_arch_mach (arch, machine));
145 gdb_assert (arch_info);
147 for (handler_p = &gdb_osabi_handler_list; *handler_p != NULL;
148 handler_p = &(*handler_p)->next)
150 if ((*handler_p)->arch_info == arch_info
151 && (*handler_p)->osabi == osabi)
155 _("gdbarch_register_osabi: A handler for OS ABI \"%s\" "
156 "has already been registered for architecture %s"),
157 gdbarch_osabi_name (osabi),
158 arch_info->printable_name);
159 /* If user wants to continue, override previous definition. */
160 (*handler_p)->init_osabi = init_osabi;
166 = (struct gdb_osabi_handler *) xmalloc (sizeof (struct gdb_osabi_handler));
167 (*handler_p)->next = NULL;
168 (*handler_p)->arch_info = arch_info;
169 (*handler_p)->osabi = osabi;
170 (*handler_p)->init_osabi = init_osabi;
172 /* Add this OS ABI to the list of enum values for "set osabi", if it isn't
174 for (name_ptr = gdb_osabi_available_names; *name_ptr; name_ptr ++)
176 if (*name_ptr == gdbarch_osabi_name (osabi))
179 *name_ptr++ = gdbarch_osabi_name (osabi);
184 /* Sniffer to find the OS ABI for a given file's architecture and flavour.
185 It is legal to have multiple sniffers for each arch/flavour pair, to
186 disambiguate one OS's a.out from another, for example. The first sniffer
187 to return something other than GDB_OSABI_UNKNOWN wins, so a sniffer should
188 be careful to claim a file only if it knows for sure what it is. */
189 struct gdb_osabi_sniffer
191 struct gdb_osabi_sniffer *next;
192 enum bfd_architecture arch; /* bfd_arch_unknown == wildcard */
193 enum bfd_flavour flavour;
194 enum gdb_osabi (*sniffer)(bfd *);
197 static struct gdb_osabi_sniffer *gdb_osabi_sniffer_list;
200 gdbarch_register_osabi_sniffer (enum bfd_architecture arch,
201 enum bfd_flavour flavour,
202 enum gdb_osabi (*sniffer_fn)(bfd *))
204 struct gdb_osabi_sniffer *sniffer;
207 (struct gdb_osabi_sniffer *) xmalloc (sizeof (struct gdb_osabi_sniffer));
208 sniffer->arch = arch;
209 sniffer->flavour = flavour;
210 sniffer->sniffer = sniffer_fn;
212 sniffer->next = gdb_osabi_sniffer_list;
213 gdb_osabi_sniffer_list = sniffer;
218 gdbarch_lookup_osabi (bfd *abfd)
220 struct gdb_osabi_sniffer *sniffer;
221 enum gdb_osabi osabi, match;
224 /* If we aren't in "auto" mode, return the specified OS ABI. */
225 if (user_osabi_state == osabi_user)
226 return user_selected_osabi;
228 /* If we don't have a binary, just return unknown. The caller may
229 have other sources the OSABI can be extracted from, e.g., the
230 target description. */
232 return GDB_OSABI_UNKNOWN;
234 match = GDB_OSABI_UNKNOWN;
237 for (sniffer = gdb_osabi_sniffer_list; sniffer != NULL;
238 sniffer = sniffer->next)
240 if ((sniffer->arch == bfd_arch_unknown /* wildcard */
241 || sniffer->arch == bfd_get_arch (abfd))
242 && sniffer->flavour == bfd_get_flavour (abfd))
244 osabi = (*sniffer->sniffer) (abfd);
245 if (osabi < GDB_OSABI_UNKNOWN || osabi >= GDB_OSABI_INVALID)
249 _("gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer "
250 "for architecture %s flavour %d"),
252 bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
253 (int) bfd_get_flavour (abfd));
255 else if (osabi != GDB_OSABI_UNKNOWN)
257 /* A specific sniffer always overrides a generic sniffer.
258 Croak on multiple match if the two matches are of the
259 same class. If the user wishes to continue, we'll use
261 if (match != GDB_OSABI_UNKNOWN)
263 if ((match_specific && sniffer->arch != bfd_arch_unknown)
264 || (!match_specific && sniffer->arch == bfd_arch_unknown))
268 _("gdbarch_lookup_osabi: multiple %sspecific OS ABI "
269 "match for architecture %s flavour %d: first "
270 "match \"%s\", second match \"%s\""),
271 match_specific ? "" : "non-",
272 bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
273 (int) bfd_get_flavour (abfd),
274 gdbarch_osabi_name (match),
275 gdbarch_osabi_name (osabi));
277 else if (sniffer->arch != bfd_arch_unknown)
286 if (sniffer->arch != bfd_arch_unknown)
297 /* Return non-zero if architecture A can run code written for
300 can_run_code_for (const struct bfd_arch_info *a, const struct bfd_arch_info *b)
302 /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
303 incompatible. But if they are compatible, it returns the 'more
304 featureful' of the two arches. That is, if A can run code
305 written for B, but B can't run code written for A, then it'll
308 struct bfd_arch_info objects are singletons: that is, there's
309 supposed to be exactly one instance for a given machine. So you
310 can tell whether two are equivalent by comparing pointers. */
311 return (a == b || a->compatible (a, b) == a);
316 gdbarch_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
318 struct gdb_osabi_handler *handler;
320 if (info.osabi == GDB_OSABI_UNKNOWN)
322 /* Don't complain about an unknown OSABI. Assume the user knows
323 what they are doing. */
327 for (handler = gdb_osabi_handler_list; handler != NULL;
328 handler = handler->next)
330 if (handler->osabi != info.osabi)
333 /* If the architecture described by ARCH_INFO can run code for
334 the architcture we registered the handler for, then the
335 handler is applicable. Note, though, that if the handler is
336 for an architecture that is a superset of ARCH_INFO, we can't
337 use that --- it would be perfectly correct for it to install
338 gdbarch methods that refer to registers / instructions /
339 other facilities ARCH_INFO doesn't have.
341 NOTE: kettenis/20021027: There may be more than one machine
342 type that is compatible with the desired machine type. Right
343 now we simply return the first match, which is fine for now.
344 However, we might want to do something smarter in the future. */
345 /* NOTE: cagney/2003-10-23: The code for "a can_run_code_for b"
346 is implemented using BFD's compatible method (a->compatible
347 (b) == a -- the lowest common denominator between a and b is
348 a). That method's definition of compatible may not be as you
349 expect. For instance the test "amd64 can run code for i386"
350 (or more generally "64-bit ISA can run code for the 32-bit
351 ISA"). BFD doesn't normally consider 32-bit and 64-bit
352 "compatible" so it doesn't succeed. */
353 if (can_run_code_for (info.bfd_arch_info, handler->arch_info))
355 (*handler->init_osabi) (info, gdbarch);
361 ("A handler for the OS ABI \"%s\" is not built into this configuration\n"
362 "of GDB. Attempting to continue with the default %s settings.\n",
363 gdbarch_osabi_name (info.osabi),
364 info.bfd_arch_info->printable_name);
367 /* Limit on the amount of data to be read. */
368 #define MAX_NOTESZ 128
370 /* Return non-zero if NOTE matches NAME, DESCSZ and TYPE. If
371 *SECTSIZE is non-zero, then this reads that many bytes from
372 the start of the section and clears *SECTSIZE. */
375 check_note (bfd *abfd, asection *sect, char *note, unsigned int *sectsize,
376 const char *name, unsigned long descsz, unsigned long type)
378 unsigned long notesz;
382 if (!bfd_get_section_contents (abfd, sect, note, 0, *sectsize))
387 /* Calculate the size of this note. */
388 notesz = strlen (name) + 1;
389 notesz = ((notesz + 3) & ~3);
391 notesz = ((notesz + 3) & ~3);
393 /* If this assertion triggers, increase MAX_NOTESZ. */
394 gdb_assert (notesz <= MAX_NOTESZ);
396 /* Check whether SECT is big enough to comtain the complete note. */
397 if (notesz > bfd_section_size (abfd, sect))
400 /* Check the note name. */
401 if (bfd_h_get_32 (abfd, note) != (strlen (name) + 1)
402 || strcmp (note + 12, name) != 0)
405 /* Check the descriptor size. */
406 if (bfd_h_get_32 (abfd, note + 4) != descsz)
409 /* Check the note type. */
410 if (bfd_h_get_32 (abfd, note + 8) != type)
416 /* Generic sniffer for ELF flavoured files. */
419 generic_elf_osabi_sniff_abi_tag_sections (bfd *abfd, asection *sect, void *obj)
421 enum gdb_osabi *osabi = obj;
423 unsigned int sectsize;
426 name = bfd_get_section_name (abfd, sect);
427 sectsize = bfd_section_size (abfd, sect);
429 /* Limit the amount of data to read. */
430 if (sectsize > MAX_NOTESZ)
431 sectsize = MAX_NOTESZ;
433 /* We lazily read the section data here. Since we use
434 BFD_DECOMPRESS, we can't use bfd_get_section_contents on a
435 compressed section. But, since note sections are not compressed,
436 deferring the reading until we recognize the section avoids any
438 note = alloca (sectsize);
440 /* .note.ABI-tag notes, used by GNU/Linux and FreeBSD. */
441 if (strcmp (name, ".note.ABI-tag") == 0)
444 if (check_note (abfd, sect, note, §size, "GNU", 16, NT_GNU_ABI_TAG))
446 unsigned int abi_tag = bfd_h_get_32 (abfd, note + 16);
450 case GNU_ABI_TAG_LINUX:
451 *osabi = GDB_OSABI_LINUX;
454 case GNU_ABI_TAG_HURD:
455 *osabi = GDB_OSABI_HURD;
458 case GNU_ABI_TAG_SOLARIS:
459 *osabi = GDB_OSABI_SOLARIS;
462 case GNU_ABI_TAG_FREEBSD:
463 *osabi = GDB_OSABI_FREEBSD_ELF;
466 case GNU_ABI_TAG_NETBSD:
467 *osabi = GDB_OSABI_NETBSD_ELF;
471 internal_error (__FILE__, __LINE__,
472 _("generic_elf_osabi_sniff_abi_tag_sections: "
473 "unknown OS number %d"),
480 if (check_note (abfd, sect, note, §size, "FreeBSD", 4,
483 /* There is no need to check the version yet. */
484 *osabi = GDB_OSABI_FREEBSD_ELF;
491 /* .note.netbsd.ident notes, used by NetBSD. */
492 if (strcmp (name, ".note.netbsd.ident") == 0
493 && check_note (abfd, sect, note, §size, "NetBSD", 4, NT_NETBSD_IDENT))
495 /* There is no need to check the version yet. */
496 *osabi = GDB_OSABI_NETBSD_ELF;
500 /* .note.openbsd.ident notes, used by OpenBSD. */
501 if (strcmp (name, ".note.openbsd.ident") == 0
502 && check_note (abfd, sect, note, §size, "OpenBSD", 4,
505 /* There is no need to check the version yet. */
506 *osabi = GDB_OSABI_OPENBSD_ELF;
510 /* .note.netbsdcore.procinfo notes, used by NetBSD. */
511 if (strcmp (name, ".note.netbsdcore.procinfo") == 0)
513 *osabi = GDB_OSABI_NETBSD_ELF;
518 static enum gdb_osabi
519 generic_elf_osabi_sniffer (bfd *abfd)
521 unsigned int elfosabi;
522 enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
524 elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
530 /* When the EI_OSABI field in the ELF header is ELFOSABI_NONE
531 (0), then the ELF structures in the file are conforming to
532 the base specification for that machine (there are no
533 OS-specific extensions). In order to determine the real OS
534 in use, we must look for OS-specific notes.
536 The same applies for ELFOSABI_GNU: this can mean GNU/Hurd,
537 GNU/Linux, and possibly more. */
538 bfd_map_over_sections (abfd,
539 generic_elf_osabi_sniff_abi_tag_sections,
543 case ELFOSABI_FREEBSD:
544 osabi = GDB_OSABI_FREEBSD_ELF;
547 case ELFOSABI_NETBSD:
548 osabi = GDB_OSABI_NETBSD_ELF;
551 case ELFOSABI_SOLARIS:
552 osabi = GDB_OSABI_SOLARIS;
556 /* For some reason the default value for the EI_OSABI field is
557 ELFOSABI_HPUX for all PA-RISC targets (with the exception of
558 GNU/Linux). We use HP-UX ELF as the default, but let any
559 OS-specific notes override this. */
560 osabi = GDB_OSABI_HPUX_ELF;
561 bfd_map_over_sections (abfd,
562 generic_elf_osabi_sniff_abi_tag_sections,
566 case ELFOSABI_OPENVMS:
567 osabi = GDB_OSABI_OPENVMS;
571 if (osabi == GDB_OSABI_UNKNOWN)
573 /* The FreeBSD folks have been naughty; they stored the string
574 "FreeBSD" in the padding of the e_ident field of the ELF
575 header to "brand" their ELF binaries in FreeBSD 3.x. */
576 if (memcmp (&elf_elfheader (abfd)->e_ident[8],
577 "FreeBSD", sizeof ("FreeBSD")) == 0)
578 osabi = GDB_OSABI_FREEBSD_ELF;
585 set_osabi (char *args, int from_tty, struct cmd_list_element *c)
587 struct gdbarch_info info;
589 if (strcmp (set_osabi_string, "auto") == 0)
590 user_osabi_state = osabi_auto;
591 else if (strcmp (set_osabi_string, "default") == 0)
593 user_selected_osabi = GDB_OSABI_DEFAULT;
594 user_osabi_state = osabi_user;
596 else if (strcmp (set_osabi_string, "none") == 0)
598 user_selected_osabi = GDB_OSABI_UNKNOWN;
599 user_osabi_state = osabi_user;
605 for (i = 1; i < GDB_OSABI_INVALID; i++)
606 if (strcmp (set_osabi_string, gdbarch_osabi_name (i)) == 0)
608 user_selected_osabi = i;
609 user_osabi_state = osabi_user;
612 if (i == GDB_OSABI_INVALID)
613 internal_error (__FILE__, __LINE__,
614 _("Invalid OS ABI \"%s\" passed to command handler."),
618 /* NOTE: At some point (true multiple architectures) we'll need to be more
620 gdbarch_info_init (&info);
621 if (! gdbarch_update_p (info))
622 internal_error (__FILE__, __LINE__, _("Updating OS ABI failed."));
626 show_osabi (struct ui_file *file, int from_tty, struct cmd_list_element *c,
629 if (user_osabi_state == osabi_auto)
630 fprintf_filtered (file,
631 _("The current OS ABI is \"auto\" "
632 "(currently \"%s\").\n"),
633 gdbarch_osabi_name (gdbarch_osabi (get_current_arch ())));
635 fprintf_filtered (file, _("The current OS ABI is \"%s\".\n"),
636 gdbarch_osabi_name (user_selected_osabi));
638 if (GDB_OSABI_DEFAULT != GDB_OSABI_UNKNOWN)
639 fprintf_filtered (file, _("The default OS ABI is \"%s\".\n"),
640 gdbarch_osabi_name (GDB_OSABI_DEFAULT));
643 extern initialize_file_ftype _initialize_gdb_osabi; /* -Wmissing-prototype */
646 _initialize_gdb_osabi (void)
648 if (strcmp (gdb_osabi_names[GDB_OSABI_INVALID], "<invalid>") != 0)
651 _("_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent"));
653 /* Register a generic sniffer for ELF flavoured files. */
654 gdbarch_register_osabi_sniffer (bfd_arch_unknown,
655 bfd_target_elf_flavour,
656 generic_elf_osabi_sniffer);
658 /* Register the "set osabi" command. */
659 add_setshow_enum_cmd ("osabi", class_support, gdb_osabi_available_names,
661 _("Set OS ABI of target."),
662 _("Show OS ABI of target."),
663 NULL, set_osabi, show_osabi,
664 &setlist, &showlist);
665 user_osabi_state = osabi_auto;