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 /* 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 },
91 gdbarch_osabi_name (enum gdb_osabi osabi)
93 if (osabi >= GDB_OSABI_UNKNOWN && osabi < GDB_OSABI_INVALID)
94 return gdb_osabi_names[osabi].pretty;
96 return gdb_osabi_names[GDB_OSABI_INVALID].pretty;
102 osabi_triplet_regexp (enum gdb_osabi osabi)
104 if (osabi >= GDB_OSABI_UNKNOWN && osabi < GDB_OSABI_INVALID)
105 return gdb_osabi_names[osabi].regexp;
107 return gdb_osabi_names[GDB_OSABI_INVALID].regexp;
110 /* Lookup the OS ABI corresponding to the specified target description
114 osabi_from_tdesc_string (const char *name)
118 for (i = 0; i < ARRAY_SIZE (gdb_osabi_names); i++)
119 if (strcmp (name, gdb_osabi_names[i].pretty) == 0)
121 /* See note above: the name table matches the indices assigned
122 to enum gdb_osabi. */
123 enum gdb_osabi osabi = (enum gdb_osabi) i;
125 if (osabi == GDB_OSABI_INVALID)
126 return GDB_OSABI_UNKNOWN;
131 return GDB_OSABI_UNKNOWN;
134 /* Handler for a given architecture/OS ABI pair. There should be only
135 one handler for a given OS ABI each architecture family. */
136 struct gdb_osabi_handler
138 struct gdb_osabi_handler *next;
139 const struct bfd_arch_info *arch_info;
140 enum gdb_osabi osabi;
141 void (*init_osabi)(struct gdbarch_info, struct gdbarch *);
144 static struct gdb_osabi_handler *gdb_osabi_handler_list;
147 gdbarch_register_osabi (enum bfd_architecture arch, unsigned long machine,
148 enum gdb_osabi osabi,
149 void (*init_osabi)(struct gdbarch_info,
152 struct gdb_osabi_handler **handler_p;
153 const struct bfd_arch_info *arch_info = bfd_lookup_arch (arch, machine);
154 const char **name_ptr;
156 /* Registering an OS ABI handler for "unknown" is not allowed. */
157 if (osabi == GDB_OSABI_UNKNOWN)
161 _("gdbarch_register_osabi: An attempt to register a handler for "
162 "OS ABI \"%s\" for architecture %s was made. The handler will "
163 "not be registered"),
164 gdbarch_osabi_name (osabi),
165 bfd_printable_arch_mach (arch, machine));
169 gdb_assert (arch_info);
171 for (handler_p = &gdb_osabi_handler_list; *handler_p != NULL;
172 handler_p = &(*handler_p)->next)
174 if ((*handler_p)->arch_info == arch_info
175 && (*handler_p)->osabi == osabi)
179 _("gdbarch_register_osabi: A handler for OS ABI \"%s\" "
180 "has already been registered for architecture %s"),
181 gdbarch_osabi_name (osabi),
182 arch_info->printable_name);
183 /* If user wants to continue, override previous definition. */
184 (*handler_p)->init_osabi = init_osabi;
190 = (struct gdb_osabi_handler *) xmalloc (sizeof (struct gdb_osabi_handler));
191 (*handler_p)->next = NULL;
192 (*handler_p)->arch_info = arch_info;
193 (*handler_p)->osabi = osabi;
194 (*handler_p)->init_osabi = init_osabi;
196 /* Add this OS ABI to the list of enum values for "set osabi", if it isn't
198 for (name_ptr = gdb_osabi_available_names; *name_ptr; name_ptr ++)
200 if (*name_ptr == gdbarch_osabi_name (osabi))
203 *name_ptr++ = gdbarch_osabi_name (osabi);
208 /* Sniffer to find the OS ABI for a given file's architecture and flavour.
209 It is legal to have multiple sniffers for each arch/flavour pair, to
210 disambiguate one OS's a.out from another, for example. The first sniffer
211 to return something other than GDB_OSABI_UNKNOWN wins, so a sniffer should
212 be careful to claim a file only if it knows for sure what it is. */
213 struct gdb_osabi_sniffer
215 struct gdb_osabi_sniffer *next;
216 enum bfd_architecture arch; /* bfd_arch_unknown == wildcard */
217 enum bfd_flavour flavour;
218 enum gdb_osabi (*sniffer)(bfd *);
221 static struct gdb_osabi_sniffer *gdb_osabi_sniffer_list;
224 gdbarch_register_osabi_sniffer (enum bfd_architecture arch,
225 enum bfd_flavour flavour,
226 enum gdb_osabi (*sniffer_fn)(bfd *))
228 struct gdb_osabi_sniffer *sniffer;
231 (struct gdb_osabi_sniffer *) xmalloc (sizeof (struct gdb_osabi_sniffer));
232 sniffer->arch = arch;
233 sniffer->flavour = flavour;
234 sniffer->sniffer = sniffer_fn;
236 sniffer->next = gdb_osabi_sniffer_list;
237 gdb_osabi_sniffer_list = sniffer;
242 gdbarch_lookup_osabi (bfd *abfd)
244 struct gdb_osabi_sniffer *sniffer;
245 enum gdb_osabi osabi, match;
248 /* If we aren't in "auto" mode, return the specified OS ABI. */
249 if (user_osabi_state == osabi_user)
250 return user_selected_osabi;
252 /* If we don't have a binary, just return unknown. The caller may
253 have other sources the OSABI can be extracted from, e.g., the
254 target description. */
256 return GDB_OSABI_UNKNOWN;
258 match = GDB_OSABI_UNKNOWN;
261 for (sniffer = gdb_osabi_sniffer_list; sniffer != NULL;
262 sniffer = sniffer->next)
264 if ((sniffer->arch == bfd_arch_unknown /* wildcard */
265 || sniffer->arch == bfd_get_arch (abfd))
266 && sniffer->flavour == bfd_get_flavour (abfd))
268 osabi = (*sniffer->sniffer) (abfd);
269 if (osabi < GDB_OSABI_UNKNOWN || osabi >= GDB_OSABI_INVALID)
273 _("gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer "
274 "for architecture %s flavour %d"),
276 bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
277 (int) bfd_get_flavour (abfd));
279 else if (osabi != GDB_OSABI_UNKNOWN)
281 /* A specific sniffer always overrides a generic sniffer.
282 Croak on multiple match if the two matches are of the
283 same class. If the user wishes to continue, we'll use
285 if (match != GDB_OSABI_UNKNOWN)
287 if ((match_specific && sniffer->arch != bfd_arch_unknown)
288 || (!match_specific && sniffer->arch == bfd_arch_unknown))
292 _("gdbarch_lookup_osabi: multiple %sspecific OS ABI "
293 "match for architecture %s flavour %d: first "
294 "match \"%s\", second match \"%s\""),
295 match_specific ? "" : "non-",
296 bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
297 (int) bfd_get_flavour (abfd),
298 gdbarch_osabi_name (match),
299 gdbarch_osabi_name (osabi));
301 else if (sniffer->arch != bfd_arch_unknown)
310 if (sniffer->arch != bfd_arch_unknown)
321 /* Return non-zero if architecture A can run code written for
324 can_run_code_for (const struct bfd_arch_info *a, const struct bfd_arch_info *b)
326 /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
327 incompatible. But if they are compatible, it returns the 'more
328 featureful' of the two arches. That is, if A can run code
329 written for B, but B can't run code written for A, then it'll
332 struct bfd_arch_info objects are singletons: that is, there's
333 supposed to be exactly one instance for a given machine. So you
334 can tell whether two are equivalent by comparing pointers. */
335 return (a == b || a->compatible (a, b) == a);
340 gdbarch_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
342 struct gdb_osabi_handler *handler;
344 if (info.osabi == GDB_OSABI_UNKNOWN)
346 /* Don't complain about an unknown OSABI. Assume the user knows
347 what they are doing. */
351 for (handler = gdb_osabi_handler_list; handler != NULL;
352 handler = handler->next)
354 if (handler->osabi != info.osabi)
357 /* If the architecture described by ARCH_INFO can run code for
358 the architcture we registered the handler for, then the
359 handler is applicable. Note, though, that if the handler is
360 for an architecture that is a superset of ARCH_INFO, we can't
361 use that --- it would be perfectly correct for it to install
362 gdbarch methods that refer to registers / instructions /
363 other facilities ARCH_INFO doesn't have.
365 NOTE: kettenis/20021027: There may be more than one machine
366 type that is compatible with the desired machine type. Right
367 now we simply return the first match, which is fine for now.
368 However, we might want to do something smarter in the future. */
369 /* NOTE: cagney/2003-10-23: The code for "a can_run_code_for b"
370 is implemented using BFD's compatible method (a->compatible
371 (b) == a -- the lowest common denominator between a and b is
372 a). That method's definition of compatible may not be as you
373 expect. For instance the test "amd64 can run code for i386"
374 (or more generally "64-bit ISA can run code for the 32-bit
375 ISA"). BFD doesn't normally consider 32-bit and 64-bit
376 "compatible" so it doesn't succeed. */
377 if (can_run_code_for (info.bfd_arch_info, handler->arch_info))
379 (*handler->init_osabi) (info, gdbarch);
385 ("A handler for the OS ABI \"%s\" is not built into this configuration\n"
386 "of GDB. Attempting to continue with the default %s settings.\n",
387 gdbarch_osabi_name (info.osabi),
388 info.bfd_arch_info->printable_name);
391 /* Limit on the amount of data to be read. */
392 #define MAX_NOTESZ 128
394 /* Return non-zero if NOTE matches NAME, DESCSZ and TYPE. If
395 *SECTSIZE is non-zero, then this reads that many bytes from
396 the start of the section and clears *SECTSIZE. */
399 check_note (bfd *abfd, asection *sect, char *note, unsigned int *sectsize,
400 const char *name, unsigned long descsz, unsigned long type)
402 unsigned long notesz;
406 if (!bfd_get_section_contents (abfd, sect, note, 0, *sectsize))
411 /* Calculate the size of this note. */
412 notesz = strlen (name) + 1;
413 notesz = ((notesz + 3) & ~3);
415 notesz = ((notesz + 3) & ~3);
417 /* If this assertion triggers, increase MAX_NOTESZ. */
418 gdb_assert (notesz <= MAX_NOTESZ);
420 /* Check whether SECT is big enough to comtain the complete note. */
421 if (notesz > bfd_section_size (abfd, sect))
424 /* Check the note name. */
425 if (bfd_h_get_32 (abfd, note) != (strlen (name) + 1)
426 || strcmp (note + 12, name) != 0)
429 /* Check the descriptor size. */
430 if (bfd_h_get_32 (abfd, note + 4) != descsz)
433 /* Check the note type. */
434 if (bfd_h_get_32 (abfd, note + 8) != type)
440 /* Generic sniffer for ELF flavoured files. */
443 generic_elf_osabi_sniff_abi_tag_sections (bfd *abfd, asection *sect, void *obj)
445 enum gdb_osabi *osabi = obj;
447 unsigned int sectsize;
450 name = bfd_get_section_name (abfd, sect);
451 sectsize = bfd_section_size (abfd, sect);
453 /* Limit the amount of data to read. */
454 if (sectsize > MAX_NOTESZ)
455 sectsize = MAX_NOTESZ;
457 /* We lazily read the section data here. Since we use
458 BFD_DECOMPRESS, we can't use bfd_get_section_contents on a
459 compressed section. But, since note sections are not compressed,
460 deferring the reading until we recognize the section avoids any
462 note = alloca (sectsize);
464 /* .note.ABI-tag notes, used by GNU/Linux and FreeBSD. */
465 if (strcmp (name, ".note.ABI-tag") == 0)
468 if (check_note (abfd, sect, note, §size, "GNU", 16, NT_GNU_ABI_TAG))
470 unsigned int abi_tag = bfd_h_get_32 (abfd, note + 16);
474 case GNU_ABI_TAG_LINUX:
475 *osabi = GDB_OSABI_LINUX;
478 case GNU_ABI_TAG_HURD:
479 *osabi = GDB_OSABI_HURD;
482 case GNU_ABI_TAG_SOLARIS:
483 *osabi = GDB_OSABI_SOLARIS;
486 case GNU_ABI_TAG_FREEBSD:
487 *osabi = GDB_OSABI_FREEBSD_ELF;
490 case GNU_ABI_TAG_NETBSD:
491 *osabi = GDB_OSABI_NETBSD_ELF;
495 internal_error (__FILE__, __LINE__,
496 _("generic_elf_osabi_sniff_abi_tag_sections: "
497 "unknown OS number %d"),
504 if (check_note (abfd, sect, note, §size, "FreeBSD", 4,
507 /* There is no need to check the version yet. */
508 *osabi = GDB_OSABI_FREEBSD_ELF;
515 /* .note.netbsd.ident notes, used by NetBSD. */
516 if (strcmp (name, ".note.netbsd.ident") == 0
517 && check_note (abfd, sect, note, §size, "NetBSD", 4, NT_NETBSD_IDENT))
519 /* There is no need to check the version yet. */
520 *osabi = GDB_OSABI_NETBSD_ELF;
524 /* .note.openbsd.ident notes, used by OpenBSD. */
525 if (strcmp (name, ".note.openbsd.ident") == 0
526 && check_note (abfd, sect, note, §size, "OpenBSD", 4,
529 /* There is no need to check the version yet. */
530 *osabi = GDB_OSABI_OPENBSD_ELF;
534 /* .note.netbsdcore.procinfo notes, used by NetBSD. */
535 if (strcmp (name, ".note.netbsdcore.procinfo") == 0)
537 *osabi = GDB_OSABI_NETBSD_ELF;
542 static enum gdb_osabi
543 generic_elf_osabi_sniffer (bfd *abfd)
545 unsigned int elfosabi;
546 enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
548 elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
554 /* When the EI_OSABI field in the ELF header is ELFOSABI_NONE
555 (0), then the ELF structures in the file are conforming to
556 the base specification for that machine (there are no
557 OS-specific extensions). In order to determine the real OS
558 in use, we must look for OS-specific notes.
560 The same applies for ELFOSABI_GNU: this can mean GNU/Hurd,
561 GNU/Linux, and possibly more. */
562 bfd_map_over_sections (abfd,
563 generic_elf_osabi_sniff_abi_tag_sections,
567 case ELFOSABI_FREEBSD:
568 osabi = GDB_OSABI_FREEBSD_ELF;
571 case ELFOSABI_NETBSD:
572 osabi = GDB_OSABI_NETBSD_ELF;
575 case ELFOSABI_SOLARIS:
576 osabi = GDB_OSABI_SOLARIS;
580 /* For some reason the default value for the EI_OSABI field is
581 ELFOSABI_HPUX for all PA-RISC targets (with the exception of
582 GNU/Linux). We use HP-UX ELF as the default, but let any
583 OS-specific notes override this. */
584 osabi = GDB_OSABI_HPUX_ELF;
585 bfd_map_over_sections (abfd,
586 generic_elf_osabi_sniff_abi_tag_sections,
590 case ELFOSABI_OPENVMS:
591 osabi = GDB_OSABI_OPENVMS;
595 if (osabi == GDB_OSABI_UNKNOWN)
597 /* The FreeBSD folks have been naughty; they stored the string
598 "FreeBSD" in the padding of the e_ident field of the ELF
599 header to "brand" their ELF binaries in FreeBSD 3.x. */
600 if (memcmp (&elf_elfheader (abfd)->e_ident[8],
601 "FreeBSD", sizeof ("FreeBSD")) == 0)
602 osabi = GDB_OSABI_FREEBSD_ELF;
609 set_osabi (char *args, int from_tty, struct cmd_list_element *c)
611 struct gdbarch_info info;
613 if (strcmp (set_osabi_string, "auto") == 0)
614 user_osabi_state = osabi_auto;
615 else if (strcmp (set_osabi_string, "default") == 0)
617 user_selected_osabi = GDB_OSABI_DEFAULT;
618 user_osabi_state = osabi_user;
620 else if (strcmp (set_osabi_string, "none") == 0)
622 user_selected_osabi = GDB_OSABI_UNKNOWN;
623 user_osabi_state = osabi_user;
629 for (i = 1; i < GDB_OSABI_INVALID; i++)
630 if (strcmp (set_osabi_string, gdbarch_osabi_name (i)) == 0)
632 user_selected_osabi = i;
633 user_osabi_state = osabi_user;
636 if (i == GDB_OSABI_INVALID)
637 internal_error (__FILE__, __LINE__,
638 _("Invalid OS ABI \"%s\" passed to command handler."),
642 /* NOTE: At some point (true multiple architectures) we'll need to be more
644 gdbarch_info_init (&info);
645 if (! gdbarch_update_p (info))
646 internal_error (__FILE__, __LINE__, _("Updating OS ABI failed."));
650 show_osabi (struct ui_file *file, int from_tty, struct cmd_list_element *c,
653 if (user_osabi_state == osabi_auto)
654 fprintf_filtered (file,
655 _("The current OS ABI is \"auto\" "
656 "(currently \"%s\").\n"),
657 gdbarch_osabi_name (gdbarch_osabi (get_current_arch ())));
659 fprintf_filtered (file, _("The current OS ABI is \"%s\".\n"),
660 gdbarch_osabi_name (user_selected_osabi));
662 if (GDB_OSABI_DEFAULT != GDB_OSABI_UNKNOWN)
663 fprintf_filtered (file, _("The default OS ABI is \"%s\".\n"),
664 gdbarch_osabi_name (GDB_OSABI_DEFAULT));
667 extern initialize_file_ftype _initialize_gdb_osabi; /* -Wmissing-prototype */
670 _initialize_gdb_osabi (void)
672 if (strcmp (gdb_osabi_names[GDB_OSABI_INVALID].pretty, "<invalid>") != 0)
675 _("_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent"));
677 /* Register a generic sniffer for ELF flavoured files. */
678 gdbarch_register_osabi_sniffer (bfd_arch_unknown,
679 bfd_target_elf_flavour,
680 generic_elf_osabi_sniffer);
682 /* Register the "set osabi" command. */
683 add_setshow_enum_cmd ("osabi", class_support, gdb_osabi_available_names,
685 _("Set OS ABI of target."),
686 _("Show OS ABI of target."),
687 NULL, set_osabi, show_osabi,
688 &setlist, &showlist);
689 user_osabi_state = osabi_auto;