1 /* OS ABI variant handling for GDB.
2 Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
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[] =
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 /* Handler for a given architecture/OS ABI pair. There should be only
93 one handler for a given OS ABI each architecture family. */
94 struct gdb_osabi_handler
96 struct gdb_osabi_handler *next;
97 const struct bfd_arch_info *arch_info;
99 void (*init_osabi)(struct gdbarch_info, struct gdbarch *);
102 static struct gdb_osabi_handler *gdb_osabi_handler_list;
105 gdbarch_register_osabi (enum bfd_architecture arch, unsigned long machine,
106 enum gdb_osabi osabi,
107 void (*init_osabi)(struct gdbarch_info,
110 struct gdb_osabi_handler **handler_p;
111 const struct bfd_arch_info *arch_info = bfd_lookup_arch (arch, machine);
112 const char **name_ptr;
114 /* Registering an OS ABI handler for "unknown" is not allowed. */
115 if (osabi == GDB_OSABI_UNKNOWN)
119 "gdbarch_register_osabi: An attempt to register a handler for "
120 "OS ABI \"%s\" for architecture %s was made. The handler will "
122 gdbarch_osabi_name (osabi),
123 bfd_printable_arch_mach (arch, machine));
127 gdb_assert (arch_info);
129 for (handler_p = &gdb_osabi_handler_list; *handler_p != NULL;
130 handler_p = &(*handler_p)->next)
132 if ((*handler_p)->arch_info == arch_info
133 && (*handler_p)->osabi == osabi)
137 "gdbarch_register_osabi: A handler for OS ABI \"%s\" "
138 "has already been registered for architecture %s",
139 gdbarch_osabi_name (osabi),
140 arch_info->printable_name);
141 /* If user wants to continue, override previous definition. */
142 (*handler_p)->init_osabi = init_osabi;
148 = (struct gdb_osabi_handler *) xmalloc (sizeof (struct gdb_osabi_handler));
149 (*handler_p)->next = NULL;
150 (*handler_p)->arch_info = arch_info;
151 (*handler_p)->osabi = osabi;
152 (*handler_p)->init_osabi = init_osabi;
154 /* Add this OS ABI to the list of enum values for "set osabi", if it isn't
156 for (name_ptr = gdb_osabi_available_names; *name_ptr; name_ptr ++)
158 if (*name_ptr == gdbarch_osabi_name (osabi))
161 *name_ptr++ = gdbarch_osabi_name (osabi);
166 /* Sniffer to find the OS ABI for a given file's architecture and flavour.
167 It is legal to have multiple sniffers for each arch/flavour pair, to
168 disambiguate one OS's a.out from another, for example. The first sniffer
169 to return something other than GDB_OSABI_UNKNOWN wins, so a sniffer should
170 be careful to claim a file only if it knows for sure what it is. */
171 struct gdb_osabi_sniffer
173 struct gdb_osabi_sniffer *next;
174 enum bfd_architecture arch; /* bfd_arch_unknown == wildcard */
175 enum bfd_flavour flavour;
176 enum gdb_osabi (*sniffer)(bfd *);
179 static struct gdb_osabi_sniffer *gdb_osabi_sniffer_list;
182 gdbarch_register_osabi_sniffer (enum bfd_architecture arch,
183 enum bfd_flavour flavour,
184 enum gdb_osabi (*sniffer_fn)(bfd *))
186 struct gdb_osabi_sniffer *sniffer;
189 (struct gdb_osabi_sniffer *) xmalloc (sizeof (struct gdb_osabi_sniffer));
190 sniffer->arch = arch;
191 sniffer->flavour = flavour;
192 sniffer->sniffer = sniffer_fn;
194 sniffer->next = gdb_osabi_sniffer_list;
195 gdb_osabi_sniffer_list = sniffer;
200 gdbarch_lookup_osabi (bfd *abfd)
202 struct gdb_osabi_sniffer *sniffer;
203 enum gdb_osabi osabi, match;
206 /* If we aren't in "auto" mode, return the specified OS ABI. */
207 if (user_osabi_state == osabi_user)
208 return user_selected_osabi;
210 /* If we don't have a binary, return the default OS ABI (if set) or
211 an inconclusive result (otherwise). */
214 if (GDB_OSABI_DEFAULT != GDB_OSABI_UNKNOWN)
215 return GDB_OSABI_DEFAULT;
217 return GDB_OSABI_UNINITIALIZED;
220 match = GDB_OSABI_UNKNOWN;
223 for (sniffer = gdb_osabi_sniffer_list; sniffer != NULL;
224 sniffer = sniffer->next)
226 if ((sniffer->arch == bfd_arch_unknown /* wildcard */
227 || sniffer->arch == bfd_get_arch (abfd))
228 && sniffer->flavour == bfd_get_flavour (abfd))
230 osabi = (*sniffer->sniffer) (abfd);
231 if (osabi < GDB_OSABI_UNKNOWN || osabi >= GDB_OSABI_INVALID)
235 "gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer "
236 "for architecture %s flavour %d",
238 bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
239 (int) bfd_get_flavour (abfd));
241 else if (osabi != GDB_OSABI_UNKNOWN)
243 /* A specific sniffer always overrides a generic sniffer.
244 Croak on multiple match if the two matches are of the
245 same class. If the user wishes to continue, we'll use
247 if (match != GDB_OSABI_UNKNOWN)
249 if ((match_specific && sniffer->arch != bfd_arch_unknown)
250 || (!match_specific && sniffer->arch == bfd_arch_unknown))
254 "gdbarch_lookup_osabi: multiple %sspecific OS ABI "
255 "match for architecture %s flavour %d: first "
256 "match \"%s\", second match \"%s\"",
257 match_specific ? "" : "non-",
258 bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
259 (int) bfd_get_flavour (abfd),
260 gdbarch_osabi_name (match),
261 gdbarch_osabi_name (osabi));
263 else if (sniffer->arch != bfd_arch_unknown)
272 if (sniffer->arch != bfd_arch_unknown)
279 /* If we didn't find a match, but a default was specified at configure
280 time, return the default. */
281 if (GDB_OSABI_DEFAULT != GDB_OSABI_UNKNOWN && match == GDB_OSABI_UNKNOWN)
282 return GDB_OSABI_DEFAULT;
288 /* Return non-zero if architecture A can run code written for
291 can_run_code_for (const struct bfd_arch_info *a, const struct bfd_arch_info *b)
293 /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
294 incompatible. But if they are compatible, it returns the 'more
295 featureful' of the two arches. That is, if A can run code
296 written for B, but B can't run code written for A, then it'll
299 struct bfd_arch_info objects are singletons: that is, there's
300 supposed to be exactly one instance for a given machine. So you
301 can tell whether two are equivalent by comparing pointers. */
302 return (a == b || a->compatible (a, b) == a);
307 gdbarch_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
309 struct gdb_osabi_handler *handler;
311 if (info.osabi == GDB_OSABI_UNKNOWN)
313 /* Don't complain about an unknown OSABI. Assume the user knows
314 what they are doing. */
318 for (handler = gdb_osabi_handler_list; handler != NULL;
319 handler = handler->next)
321 if (handler->osabi != info.osabi)
324 /* If the architecture described by ARCH_INFO can run code for
325 the architcture we registered the handler for, then the
326 handler is applicable. Note, though, that if the handler is
327 for an architecture that is a superset of ARCH_INFO, we can't
328 use that --- it would be perfectly correct for it to install
329 gdbarch methods that refer to registers / instructions /
330 other facilities ARCH_INFO doesn't have.
332 NOTE: kettenis/20021027: There may be more than one machine
333 type that is compatible with the desired machine type. Right
334 now we simply return the first match, which is fine for now.
335 However, we might want to do something smarter in the future. */
336 /* NOTE: cagney/2003-10-23: The code for "a can_run_code_for b"
337 is implemented using BFD's compatible method (a->compatible
338 (b) == a -- the lowest common denominator between a and b is
339 a). That method's definition of compatible may not be as you
340 expect. For instance the test "amd64 can run code for i386"
341 (or more generally "64-bit ISA can run code for the 32-bit
342 ISA"). BFD doesn't normally consider 32-bit and 64-bit
343 "compatible" so it doesn't succeed. */
344 if (can_run_code_for (info.bfd_arch_info, handler->arch_info))
346 (*handler->init_osabi) (info, gdbarch);
352 ("A handler for the OS ABI \"%s\" is not built into this configuration\n"
353 "of GDB. Attempting to continue with the default %s settings.\n",
354 gdbarch_osabi_name (info.osabi),
355 info.bfd_arch_info->printable_name);
358 /* Limit on the amount of data to be read. */
359 #define MAX_NOTESZ 128
361 /* Return non-zero if NOTE matches NAME, DESCSZ and TYPE. */
364 check_note (bfd *abfd, asection *sect, const char *note,
365 const char *name, unsigned long descsz, unsigned long type)
367 unsigned long notesz;
369 /* Calculate the size of this note. */
370 notesz = strlen (name) + 1;
371 notesz = ((notesz + 3) & ~3);
373 notesz = ((notesz + 3) & ~3);
375 /* If this assertion triggers, increase MAX_NOTESZ. */
376 gdb_assert (notesz <= MAX_NOTESZ);
378 /* Check whether SECT is big enough to comtain the complete note. */
379 if (notesz > bfd_section_size (abfd, sect))
382 /* Check the note name. */
383 if (bfd_h_get_32 (abfd, note) != (strlen (name) + 1)
384 || strcmp (note + 12, name) != 0)
387 /* Check the descriptor size. */
388 if (bfd_h_get_32 (abfd, note + 4) != descsz)
391 /* Check the note type. */
392 if (bfd_h_get_32 (abfd, note + 8) != type)
398 /* Generic sniffer for ELF flavoured files. */
401 generic_elf_osabi_sniff_abi_tag_sections (bfd *abfd, asection *sect, void *obj)
403 enum gdb_osabi *osabi = obj;
405 unsigned int sectsize;
408 name = bfd_get_section_name (abfd, sect);
409 sectsize = bfd_section_size (abfd, sect);
411 /* Limit the amount of data to read. */
412 if (sectsize > MAX_NOTESZ)
413 sectsize = MAX_NOTESZ;
415 note = alloca (sectsize);
416 bfd_get_section_contents (abfd, sect, note, 0, sectsize);
418 /* .note.ABI-tag notes, used by GNU/Linux and FreeBSD. */
419 if (strcmp (name, ".note.ABI-tag") == 0)
422 if (check_note (abfd, sect, note, "GNU", 16, NT_GNU_ABI_TAG))
424 unsigned int abi_tag = bfd_h_get_32 (abfd, note + 16);
428 case GNU_ABI_TAG_LINUX:
429 *osabi = GDB_OSABI_LINUX;
432 case GNU_ABI_TAG_HURD:
433 *osabi = GDB_OSABI_HURD;
436 case GNU_ABI_TAG_SOLARIS:
437 *osabi = GDB_OSABI_SOLARIS;
440 case GNU_ABI_TAG_FREEBSD:
441 *osabi = GDB_OSABI_FREEBSD_ELF;
444 case GNU_ABI_TAG_NETBSD:
445 *osabi = GDB_OSABI_NETBSD_ELF;
449 internal_error (__FILE__, __LINE__, "\
450 generic_elf_osabi_sniff_abi_tag_sections: unknown OS number %d",
457 if (check_note (abfd, sect, note, "FreeBSD", 4, NT_FREEBSD_ABI_TAG))
459 /* There is no need to check the version yet. */
460 *osabi = GDB_OSABI_FREEBSD_ELF;
467 /* .note.tag notes, used by FreeBSD. */
468 if (strcmp (name, ".note.tag") == 0)
471 if (check_note (abfd, sect, note, "FreeBSD", 4, NT_FREEBSD_TAG))
473 /* There is no need to check the version yet. */
474 *osabi = GDB_OSABI_FREEBSD_ELF;
481 /* .note.netbsd.ident notes, used by NetBSD. */
482 if (strcmp (name, ".note.netbsd.ident") == 0
483 && check_note (abfd, sect, note, "NetBSD", 4, NT_NETBSD_IDENT))
485 /* There is no need to check the version yet. */
486 *osabi = GDB_OSABI_NETBSD_ELF;
490 /* .note.openbsd.ident notes, used by OpenBSD. */
491 if (strcmp (name, ".note.openbsd.ident") == 0
492 && check_note (abfd, sect, note, "OpenBSD", 4, NT_OPENBSD_IDENT))
494 /* There is no need to check the version yet. */
495 *osabi = GDB_OSABI_OPENBSD_ELF;
499 /* .note.netbsdcore.procinfo notes, used by NetBSD. */
500 if (strcmp (name, ".note.netbsdcore.procinfo") == 0)
502 *osabi = GDB_OSABI_NETBSD_ELF;
507 static enum gdb_osabi
508 generic_elf_osabi_sniffer (bfd *abfd)
510 unsigned int elfosabi;
511 enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
513 elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
518 /* When elfosabi is ELFOSABI_NONE (0), then the ELF structures in the
519 file are conforming to the base specification for that machine
520 (there are no OS-specific extensions). In order to determine the
521 real OS in use we must look for OS notes that have been added. */
522 bfd_map_over_sections (abfd,
523 generic_elf_osabi_sniff_abi_tag_sections,
527 case ELFOSABI_FREEBSD:
528 osabi = GDB_OSABI_FREEBSD_ELF;
531 case ELFOSABI_NETBSD:
532 osabi = GDB_OSABI_NETBSD_ELF;
536 osabi = GDB_OSABI_LINUX;
540 osabi = GDB_OSABI_HURD;
543 case ELFOSABI_SOLARIS:
544 osabi = GDB_OSABI_SOLARIS;
548 osabi = GDB_OSABI_HPUX_ELF;
552 if (osabi == GDB_OSABI_UNKNOWN)
554 /* The FreeBSD folks have been naughty; they stored the string
555 "FreeBSD" in the padding of the e_ident field of the ELF
556 header to "brand" their ELF binaries in FreeBSD 3.x. */
557 if (strcmp (&elf_elfheader (abfd)->e_ident[8], "FreeBSD") == 0)
558 osabi = GDB_OSABI_FREEBSD_ELF;
565 set_osabi (char *args, int from_tty, struct cmd_list_element *c)
567 struct gdbarch_info info;
569 if (strcmp (set_osabi_string, "auto") == 0)
570 user_osabi_state = osabi_auto;
571 else if (strcmp (set_osabi_string, "default") == 0)
573 user_selected_osabi = GDB_OSABI_DEFAULT;
574 user_osabi_state = osabi_user;
576 else if (strcmp (set_osabi_string, "none") == 0)
578 user_selected_osabi = GDB_OSABI_UNKNOWN;
579 user_osabi_state = osabi_user;
584 for (i = 1; i < GDB_OSABI_INVALID; i++)
585 if (strcmp (set_osabi_string, gdbarch_osabi_name (i)) == 0)
587 user_selected_osabi = i;
588 user_osabi_state = osabi_user;
591 if (i == GDB_OSABI_INVALID)
592 internal_error (__FILE__, __LINE__,
593 "Invalid OS ABI \"%s\" passed to command handler.",
597 /* NOTE: At some point (true multiple architectures) we'll need to be more
599 gdbarch_info_init (&info);
600 if (! gdbarch_update_p (info))
601 internal_error (__FILE__, __LINE__, "Updating OS ABI failed.");
605 show_osabi (char *args, int from_tty)
607 if (user_osabi_state == osabi_auto)
608 printf_filtered ("The current OS ABI is \"auto\" (currently \"%s\").\n",
609 gdbarch_osabi_name (gdbarch_osabi (current_gdbarch)));
611 printf_filtered ("The current OS ABI is \"%s\".\n",
612 gdbarch_osabi_name (user_selected_osabi));
614 if (GDB_OSABI_DEFAULT != GDB_OSABI_UNKNOWN)
615 printf_filtered ("The default OS ABI is \"%s\".\n",
616 gdbarch_osabi_name (GDB_OSABI_DEFAULT));
619 extern initialize_file_ftype _initialize_gdb_osabi; /* -Wmissing-prototype */
622 _initialize_gdb_osabi (void)
624 struct cmd_list_element *c;
626 if (strcmp (gdb_osabi_names[GDB_OSABI_INVALID], "<invalid>") != 0)
629 "_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent");
631 /* Register a generic sniffer for ELF flavoured files. */
632 gdbarch_register_osabi_sniffer (bfd_arch_unknown,
633 bfd_target_elf_flavour,
634 generic_elf_osabi_sniffer);
636 /* Register the "set osabi" command. */
637 c = add_set_enum_cmd ("osabi", class_support, gdb_osabi_available_names,
638 &set_osabi_string, "Set OS ABI of target.", &setlist);
640 set_cmd_sfunc (c, set_osabi);
641 add_cmd ("osabi", class_support, show_osabi, "Show OS/ABI of target.",
643 user_osabi_state = osabi_auto;