1 /* OS ABI variant handling for GDB.
3 Copyright (C) 2001, 2002, 2003, 2004, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_assert.h"
24 #include "gdb_string.h"
27 #include "arch-utils.h"
33 #ifndef GDB_OSABI_DEFAULT
34 #define GDB_OSABI_DEFAULT GDB_OSABI_UNKNOWN
37 /* State for the "set osabi" command. */
38 static enum { osabi_auto, osabi_default, osabi_user } user_osabi_state;
39 static enum gdb_osabi user_selected_osabi;
40 static const char *gdb_osabi_available_names[GDB_OSABI_INVALID + 3] = {
46 static const char *set_osabi_string;
48 /* This table matches the indices assigned to enum gdb_osabi. Keep
50 static const char * const gdb_osabi_names[] =
82 gdbarch_osabi_name (enum gdb_osabi osabi)
84 if (osabi >= GDB_OSABI_UNKNOWN && osabi < GDB_OSABI_INVALID)
85 return gdb_osabi_names[osabi];
87 return gdb_osabi_names[GDB_OSABI_INVALID];
90 /* Lookup the OS ABI corresponding to the specified target description
94 osabi_from_tdesc_string (const char *name)
98 for (i = 0; i < ARRAY_SIZE (gdb_osabi_names); i++)
99 if (strcmp (name, gdb_osabi_names[i]) == 0)
101 /* See note above: the name table matches the indices assigned
102 to enum gdb_osabi. */
103 enum gdb_osabi osabi = (enum gdb_osabi) i;
105 if (osabi == GDB_OSABI_INVALID)
106 return GDB_OSABI_UNKNOWN;
111 return GDB_OSABI_UNKNOWN;
114 /* Handler for a given architecture/OS ABI pair. There should be only
115 one handler for a given OS ABI each architecture family. */
116 struct gdb_osabi_handler
118 struct gdb_osabi_handler *next;
119 const struct bfd_arch_info *arch_info;
120 enum gdb_osabi osabi;
121 void (*init_osabi)(struct gdbarch_info, struct gdbarch *);
124 static struct gdb_osabi_handler *gdb_osabi_handler_list;
127 gdbarch_register_osabi (enum bfd_architecture arch, unsigned long machine,
128 enum gdb_osabi osabi,
129 void (*init_osabi)(struct gdbarch_info,
132 struct gdb_osabi_handler **handler_p;
133 const struct bfd_arch_info *arch_info = bfd_lookup_arch (arch, machine);
134 const char **name_ptr;
136 /* Registering an OS ABI handler for "unknown" is not allowed. */
137 if (osabi == GDB_OSABI_UNKNOWN)
141 _("gdbarch_register_osabi: An attempt to register a handler for "
142 "OS ABI \"%s\" for architecture %s was made. The handler will "
143 "not be registered"),
144 gdbarch_osabi_name (osabi),
145 bfd_printable_arch_mach (arch, machine));
149 gdb_assert (arch_info);
151 for (handler_p = &gdb_osabi_handler_list; *handler_p != NULL;
152 handler_p = &(*handler_p)->next)
154 if ((*handler_p)->arch_info == arch_info
155 && (*handler_p)->osabi == osabi)
159 _("gdbarch_register_osabi: A handler for OS ABI \"%s\" "
160 "has already been registered for architecture %s"),
161 gdbarch_osabi_name (osabi),
162 arch_info->printable_name);
163 /* If user wants to continue, override previous definition. */
164 (*handler_p)->init_osabi = init_osabi;
170 = (struct gdb_osabi_handler *) xmalloc (sizeof (struct gdb_osabi_handler));
171 (*handler_p)->next = NULL;
172 (*handler_p)->arch_info = arch_info;
173 (*handler_p)->osabi = osabi;
174 (*handler_p)->init_osabi = init_osabi;
176 /* Add this OS ABI to the list of enum values for "set osabi", if it isn't
178 for (name_ptr = gdb_osabi_available_names; *name_ptr; name_ptr ++)
180 if (*name_ptr == gdbarch_osabi_name (osabi))
183 *name_ptr++ = gdbarch_osabi_name (osabi);
188 /* Sniffer to find the OS ABI for a given file's architecture and flavour.
189 It is legal to have multiple sniffers for each arch/flavour pair, to
190 disambiguate one OS's a.out from another, for example. The first sniffer
191 to return something other than GDB_OSABI_UNKNOWN wins, so a sniffer should
192 be careful to claim a file only if it knows for sure what it is. */
193 struct gdb_osabi_sniffer
195 struct gdb_osabi_sniffer *next;
196 enum bfd_architecture arch; /* bfd_arch_unknown == wildcard */
197 enum bfd_flavour flavour;
198 enum gdb_osabi (*sniffer)(bfd *);
201 static struct gdb_osabi_sniffer *gdb_osabi_sniffer_list;
204 gdbarch_register_osabi_sniffer (enum bfd_architecture arch,
205 enum bfd_flavour flavour,
206 enum gdb_osabi (*sniffer_fn)(bfd *))
208 struct gdb_osabi_sniffer *sniffer;
211 (struct gdb_osabi_sniffer *) xmalloc (sizeof (struct gdb_osabi_sniffer));
212 sniffer->arch = arch;
213 sniffer->flavour = flavour;
214 sniffer->sniffer = sniffer_fn;
216 sniffer->next = gdb_osabi_sniffer_list;
217 gdb_osabi_sniffer_list = sniffer;
222 gdbarch_lookup_osabi (bfd *abfd)
224 struct gdb_osabi_sniffer *sniffer;
225 enum gdb_osabi osabi, match;
228 /* If we aren't in "auto" mode, return the specified OS ABI. */
229 if (user_osabi_state == osabi_user)
230 return user_selected_osabi;
232 /* If we don't have a binary, just return unknown. The caller may
233 have other sources the OSABI can be extracted from, e.g., the
234 target description. */
236 return GDB_OSABI_UNKNOWN;
238 match = GDB_OSABI_UNKNOWN;
241 for (sniffer = gdb_osabi_sniffer_list; sniffer != NULL;
242 sniffer = sniffer->next)
244 if ((sniffer->arch == bfd_arch_unknown /* wildcard */
245 || sniffer->arch == bfd_get_arch (abfd))
246 && sniffer->flavour == bfd_get_flavour (abfd))
248 osabi = (*sniffer->sniffer) (abfd);
249 if (osabi < GDB_OSABI_UNKNOWN || osabi >= GDB_OSABI_INVALID)
253 _("gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer "
254 "for architecture %s flavour %d"),
256 bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
257 (int) bfd_get_flavour (abfd));
259 else if (osabi != GDB_OSABI_UNKNOWN)
261 /* A specific sniffer always overrides a generic sniffer.
262 Croak on multiple match if the two matches are of the
263 same class. If the user wishes to continue, we'll use
265 if (match != GDB_OSABI_UNKNOWN)
267 if ((match_specific && sniffer->arch != bfd_arch_unknown)
268 || (!match_specific && sniffer->arch == bfd_arch_unknown))
272 _("gdbarch_lookup_osabi: multiple %sspecific OS ABI "
273 "match for architecture %s flavour %d: first "
274 "match \"%s\", second match \"%s\""),
275 match_specific ? "" : "non-",
276 bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
277 (int) bfd_get_flavour (abfd),
278 gdbarch_osabi_name (match),
279 gdbarch_osabi_name (osabi));
281 else if (sniffer->arch != bfd_arch_unknown)
290 if (sniffer->arch != bfd_arch_unknown)
301 /* Return non-zero if architecture A can run code written for
304 can_run_code_for (const struct bfd_arch_info *a, const struct bfd_arch_info *b)
306 /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
307 incompatible. But if they are compatible, it returns the 'more
308 featureful' of the two arches. That is, if A can run code
309 written for B, but B can't run code written for A, then it'll
312 struct bfd_arch_info objects are singletons: that is, there's
313 supposed to be exactly one instance for a given machine. So you
314 can tell whether two are equivalent by comparing pointers. */
315 return (a == b || a->compatible (a, b) == a);
320 gdbarch_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
322 struct gdb_osabi_handler *handler;
324 if (info.osabi == GDB_OSABI_UNKNOWN)
326 /* Don't complain about an unknown OSABI. Assume the user knows
327 what they are doing. */
331 for (handler = gdb_osabi_handler_list; handler != NULL;
332 handler = handler->next)
334 if (handler->osabi != info.osabi)
337 /* If the architecture described by ARCH_INFO can run code for
338 the architcture we registered the handler for, then the
339 handler is applicable. Note, though, that if the handler is
340 for an architecture that is a superset of ARCH_INFO, we can't
341 use that --- it would be perfectly correct for it to install
342 gdbarch methods that refer to registers / instructions /
343 other facilities ARCH_INFO doesn't have.
345 NOTE: kettenis/20021027: There may be more than one machine
346 type that is compatible with the desired machine type. Right
347 now we simply return the first match, which is fine for now.
348 However, we might want to do something smarter in the future. */
349 /* NOTE: cagney/2003-10-23: The code for "a can_run_code_for b"
350 is implemented using BFD's compatible method (a->compatible
351 (b) == a -- the lowest common denominator between a and b is
352 a). That method's definition of compatible may not be as you
353 expect. For instance the test "amd64 can run code for i386"
354 (or more generally "64-bit ISA can run code for the 32-bit
355 ISA"). BFD doesn't normally consider 32-bit and 64-bit
356 "compatible" so it doesn't succeed. */
357 if (can_run_code_for (info.bfd_arch_info, handler->arch_info))
359 (*handler->init_osabi) (info, gdbarch);
365 ("A handler for the OS ABI \"%s\" is not built into this configuration\n"
366 "of GDB. Attempting to continue with the default %s settings.\n",
367 gdbarch_osabi_name (info.osabi),
368 info.bfd_arch_info->printable_name);
371 /* Limit on the amount of data to be read. */
372 #define MAX_NOTESZ 128
374 /* Return non-zero if NOTE matches NAME, DESCSZ and TYPE. */
377 check_note (bfd *abfd, asection *sect, const char *note,
378 const char *name, unsigned long descsz, unsigned long type)
380 unsigned long notesz;
382 /* Calculate the size of this note. */
383 notesz = strlen (name) + 1;
384 notesz = ((notesz + 3) & ~3);
386 notesz = ((notesz + 3) & ~3);
388 /* If this assertion triggers, increase MAX_NOTESZ. */
389 gdb_assert (notesz <= MAX_NOTESZ);
391 /* Check whether SECT is big enough to comtain the complete note. */
392 if (notesz > bfd_section_size (abfd, sect))
395 /* Check the note name. */
396 if (bfd_h_get_32 (abfd, note) != (strlen (name) + 1)
397 || strcmp (note + 12, name) != 0)
400 /* Check the descriptor size. */
401 if (bfd_h_get_32 (abfd, note + 4) != descsz)
404 /* Check the note type. */
405 if (bfd_h_get_32 (abfd, note + 8) != type)
411 /* Generic sniffer for ELF flavoured files. */
414 generic_elf_osabi_sniff_abi_tag_sections (bfd *abfd, asection *sect, void *obj)
416 enum gdb_osabi *osabi = obj;
418 unsigned int sectsize;
421 name = bfd_get_section_name (abfd, sect);
422 sectsize = bfd_section_size (abfd, sect);
424 /* Limit the amount of data to read. */
425 if (sectsize > MAX_NOTESZ)
426 sectsize = MAX_NOTESZ;
428 note = alloca (sectsize);
429 bfd_get_section_contents (abfd, sect, note, 0, sectsize);
431 /* .note.ABI-tag notes, used by GNU/Linux and FreeBSD. */
432 if (strcmp (name, ".note.ABI-tag") == 0)
435 if (check_note (abfd, sect, note, "GNU", 16, NT_GNU_ABI_TAG))
437 unsigned int abi_tag = bfd_h_get_32 (abfd, note + 16);
441 case GNU_ABI_TAG_LINUX:
442 *osabi = GDB_OSABI_LINUX;
445 case GNU_ABI_TAG_HURD:
446 *osabi = GDB_OSABI_HURD;
449 case GNU_ABI_TAG_SOLARIS:
450 *osabi = GDB_OSABI_SOLARIS;
453 case GNU_ABI_TAG_FREEBSD:
454 *osabi = GDB_OSABI_FREEBSD_ELF;
457 case GNU_ABI_TAG_NETBSD:
458 *osabi = GDB_OSABI_NETBSD_ELF;
462 internal_error (__FILE__, __LINE__,
463 _("generic_elf_osabi_sniff_abi_tag_sections: "
464 "unknown OS number %d"),
471 if (check_note (abfd, sect, note, "FreeBSD", 4, NT_FREEBSD_ABI_TAG))
473 /* There is no need to check the version yet. */
474 *osabi = GDB_OSABI_FREEBSD_ELF;
479 if (check_note (abfd, sect, note, "DragonFly", 4, NT_DRAGONFLY_ABI_TAG))
481 /* There is no need to check the version yet. */
482 *osabi = GDB_OSABI_DRAGONFLY;
489 /* .note.netbsd.ident notes, used by NetBSD. */
490 if (strcmp (name, ".note.netbsd.ident") == 0
491 && check_note (abfd, sect, note, "NetBSD", 4, NT_NETBSD_IDENT))
493 /* There is no need to check the version yet. */
494 *osabi = GDB_OSABI_NETBSD_ELF;
498 /* .note.openbsd.ident notes, used by OpenBSD. */
499 if (strcmp (name, ".note.openbsd.ident") == 0
500 && check_note (abfd, sect, note, "OpenBSD", 4, NT_OPENBSD_IDENT))
502 /* There is no need to check the version yet. */
503 *osabi = GDB_OSABI_OPENBSD_ELF;
507 /* .note.netbsdcore.procinfo notes, used by NetBSD. */
508 if (strcmp (name, ".note.netbsdcore.procinfo") == 0)
510 *osabi = GDB_OSABI_NETBSD_ELF;
515 static enum gdb_osabi
516 generic_elf_osabi_sniffer (bfd *abfd)
518 unsigned int elfosabi;
519 enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
521 elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
526 /* When the EI_OSABI field in the ELF header is ELFOSABI_NONE
527 (0), then the ELF structures in the file are conforming to
528 the base specification for that machine (there are no
529 OS-specific extensions). In order to determine the real OS
530 in use we must look for OS-specific notes. */
531 bfd_map_over_sections (abfd,
532 generic_elf_osabi_sniff_abi_tag_sections,
536 case ELFOSABI_FREEBSD:
537 osabi = GDB_OSABI_FREEBSD_ELF;
540 case ELFOSABI_NETBSD:
541 osabi = GDB_OSABI_NETBSD_ELF;
545 osabi = GDB_OSABI_LINUX;
549 osabi = GDB_OSABI_HURD;
552 case ELFOSABI_SOLARIS:
553 osabi = GDB_OSABI_SOLARIS;
557 /* For some reason the default value for the EI_OSABI field is
558 ELFOSABI_HPUX for all PA-RISC targets (with the exception of
559 GNU/Linux). We use HP-UX ELF as the default, but let any
560 OS-specific notes override this. */
561 osabi = GDB_OSABI_HPUX_ELF;
562 bfd_map_over_sections (abfd,
563 generic_elf_osabi_sniff_abi_tag_sections,
568 if (osabi == GDB_OSABI_UNKNOWN)
570 /* The FreeBSD folks have been naughty; they stored the string
571 "FreeBSD" in the padding of the e_ident field of the ELF
572 header to "brand" their ELF binaries in FreeBSD 3.x. */
573 if (memcmp (&elf_elfheader (abfd)->e_ident[8],
574 "FreeBSD", sizeof ("FreeBSD")) == 0)
575 osabi = GDB_OSABI_FREEBSD_ELF;
582 set_osabi (char *args, int from_tty, struct cmd_list_element *c)
584 struct gdbarch_info info;
586 if (strcmp (set_osabi_string, "auto") == 0)
587 user_osabi_state = osabi_auto;
588 else if (strcmp (set_osabi_string, "default") == 0)
590 user_selected_osabi = GDB_OSABI_DEFAULT;
591 user_osabi_state = osabi_user;
593 else if (strcmp (set_osabi_string, "none") == 0)
595 user_selected_osabi = GDB_OSABI_UNKNOWN;
596 user_osabi_state = osabi_user;
602 for (i = 1; i < GDB_OSABI_INVALID; i++)
603 if (strcmp (set_osabi_string, gdbarch_osabi_name (i)) == 0)
605 user_selected_osabi = i;
606 user_osabi_state = osabi_user;
609 if (i == GDB_OSABI_INVALID)
610 internal_error (__FILE__, __LINE__,
611 _("Invalid OS ABI \"%s\" passed to command handler."),
615 /* NOTE: At some point (true multiple architectures) we'll need to be more
617 gdbarch_info_init (&info);
618 if (! gdbarch_update_p (info))
619 internal_error (__FILE__, __LINE__, _("Updating OS ABI failed."));
623 show_osabi (struct ui_file *file, int from_tty, struct cmd_list_element *c,
626 if (user_osabi_state == osabi_auto)
627 fprintf_filtered (file,
628 _("The current OS ABI is \"auto\" "
629 "(currently \"%s\").\n"),
630 gdbarch_osabi_name (gdbarch_osabi (get_current_arch ())));
632 fprintf_filtered (file, _("The current OS ABI is \"%s\".\n"),
633 gdbarch_osabi_name (user_selected_osabi));
635 if (GDB_OSABI_DEFAULT != GDB_OSABI_UNKNOWN)
636 fprintf_filtered (file, _("The default OS ABI is \"%s\".\n"),
637 gdbarch_osabi_name (GDB_OSABI_DEFAULT));
640 extern initialize_file_ftype _initialize_gdb_osabi; /* -Wmissing-prototype */
643 _initialize_gdb_osabi (void)
645 if (strcmp (gdb_osabi_names[GDB_OSABI_INVALID], "<invalid>") != 0)
648 _("_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent"));
650 /* Register a generic sniffer for ELF flavoured files. */
651 gdbarch_register_osabi_sniffer (bfd_arch_unknown,
652 bfd_target_elf_flavour,
653 generic_elf_osabi_sniffer);
655 /* Register the "set osabi" command. */
656 add_setshow_enum_cmd ("osabi", class_support, gdb_osabi_available_names,
658 _("Set OS ABI of target."),
659 _("Show OS ABI of target."),
660 NULL, set_osabi, show_osabi,
661 &setlist, &showlist);
662 user_osabi_state = osabi_auto;