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[] =
81 gdbarch_osabi_name (enum gdb_osabi osabi)
83 if (osabi >= GDB_OSABI_UNKNOWN && osabi < GDB_OSABI_INVALID)
84 return gdb_osabi_names[osabi];
86 return gdb_osabi_names[GDB_OSABI_INVALID];
89 /* Handler for a given architecture/OS ABI pair. There should be only
90 one handler for a given OS ABI each architecture family. */
91 struct gdb_osabi_handler
93 struct gdb_osabi_handler *next;
94 const struct bfd_arch_info *arch_info;
96 void (*init_osabi)(struct gdbarch_info, struct gdbarch *);
99 static struct gdb_osabi_handler *gdb_osabi_handler_list;
102 gdbarch_register_osabi (enum bfd_architecture arch, unsigned long machine,
103 enum gdb_osabi osabi,
104 void (*init_osabi)(struct gdbarch_info,
107 struct gdb_osabi_handler **handler_p;
108 const struct bfd_arch_info *arch_info = bfd_lookup_arch (arch, machine);
109 const char **name_ptr;
111 /* Registering an OS ABI handler for "unknown" is not allowed. */
112 if (osabi == GDB_OSABI_UNKNOWN)
116 "gdbarch_register_osabi: An attempt to register a handler for "
117 "OS ABI \"%s\" for architecture %s was made. The handler will "
119 gdbarch_osabi_name (osabi),
120 bfd_printable_arch_mach (arch, machine));
124 gdb_assert (arch_info);
126 for (handler_p = &gdb_osabi_handler_list; *handler_p != NULL;
127 handler_p = &(*handler_p)->next)
129 if ((*handler_p)->arch_info == arch_info
130 && (*handler_p)->osabi == osabi)
134 "gdbarch_register_osabi: A handler for OS ABI \"%s\" "
135 "has already been registered for architecture %s",
136 gdbarch_osabi_name (osabi),
137 arch_info->printable_name);
138 /* If user wants to continue, override previous definition. */
139 (*handler_p)->init_osabi = init_osabi;
145 = (struct gdb_osabi_handler *) xmalloc (sizeof (struct gdb_osabi_handler));
146 (*handler_p)->next = NULL;
147 (*handler_p)->arch_info = arch_info;
148 (*handler_p)->osabi = osabi;
149 (*handler_p)->init_osabi = init_osabi;
151 /* Add this OS ABI to the list of enum values for "set osabi", if it isn't
153 for (name_ptr = gdb_osabi_available_names; *name_ptr; name_ptr ++)
155 if (*name_ptr == gdbarch_osabi_name (osabi))
158 *name_ptr++ = gdbarch_osabi_name (osabi);
163 /* Sniffer to find the OS ABI for a given file's architecture and flavour.
164 It is legal to have multiple sniffers for each arch/flavour pair, to
165 disambiguate one OS's a.out from another, for example. The first sniffer
166 to return something other than GDB_OSABI_UNKNOWN wins, so a sniffer should
167 be careful to claim a file only if it knows for sure what it is. */
168 struct gdb_osabi_sniffer
170 struct gdb_osabi_sniffer *next;
171 enum bfd_architecture arch; /* bfd_arch_unknown == wildcard */
172 enum bfd_flavour flavour;
173 enum gdb_osabi (*sniffer)(bfd *);
176 static struct gdb_osabi_sniffer *gdb_osabi_sniffer_list;
179 gdbarch_register_osabi_sniffer (enum bfd_architecture arch,
180 enum bfd_flavour flavour,
181 enum gdb_osabi (*sniffer_fn)(bfd *))
183 struct gdb_osabi_sniffer *sniffer;
186 (struct gdb_osabi_sniffer *) xmalloc (sizeof (struct gdb_osabi_sniffer));
187 sniffer->arch = arch;
188 sniffer->flavour = flavour;
189 sniffer->sniffer = sniffer_fn;
191 sniffer->next = gdb_osabi_sniffer_list;
192 gdb_osabi_sniffer_list = sniffer;
197 gdbarch_lookup_osabi (bfd *abfd)
199 struct gdb_osabi_sniffer *sniffer;
200 enum gdb_osabi osabi, match;
203 /* If we aren't in "auto" mode, return the specified OS ABI. */
204 if (user_osabi_state == osabi_user)
205 return user_selected_osabi;
207 /* If we don't have a binary, return the default OS ABI (if set) or
208 an inconclusive result (otherwise). */
211 if (GDB_OSABI_DEFAULT != GDB_OSABI_UNKNOWN)
212 return GDB_OSABI_DEFAULT;
214 return GDB_OSABI_UNINITIALIZED;
217 match = GDB_OSABI_UNKNOWN;
220 for (sniffer = gdb_osabi_sniffer_list; sniffer != NULL;
221 sniffer = sniffer->next)
223 if ((sniffer->arch == bfd_arch_unknown /* wildcard */
224 || sniffer->arch == bfd_get_arch (abfd))
225 && sniffer->flavour == bfd_get_flavour (abfd))
227 osabi = (*sniffer->sniffer) (abfd);
228 if (osabi < GDB_OSABI_UNKNOWN || osabi >= GDB_OSABI_INVALID)
232 "gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer "
233 "for architecture %s flavour %d",
235 bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
236 (int) bfd_get_flavour (abfd));
238 else if (osabi != GDB_OSABI_UNKNOWN)
240 /* A specific sniffer always overrides a generic sniffer.
241 Croak on multiple match if the two matches are of the
242 same class. If the user wishes to continue, we'll use
244 if (match != GDB_OSABI_UNKNOWN)
246 if ((match_specific && sniffer->arch != bfd_arch_unknown)
247 || (!match_specific && sniffer->arch == bfd_arch_unknown))
251 "gdbarch_lookup_osabi: multiple %sspecific OS ABI "
252 "match for architecture %s flavour %d: first "
253 "match \"%s\", second match \"%s\"",
254 match_specific ? "" : "non-",
255 bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
256 (int) bfd_get_flavour (abfd),
257 gdbarch_osabi_name (match),
258 gdbarch_osabi_name (osabi));
260 else if (sniffer->arch != bfd_arch_unknown)
269 if (sniffer->arch != bfd_arch_unknown)
276 /* If we didn't find a match, but a default was specified at configure
277 time, return the default. */
278 if (GDB_OSABI_DEFAULT != GDB_OSABI_UNKNOWN && match == GDB_OSABI_UNKNOWN)
279 return GDB_OSABI_DEFAULT;
285 gdbarch_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
287 const struct bfd_arch_info *arch_info = gdbarch_bfd_arch_info (gdbarch);
288 const struct bfd_arch_info *compatible;
289 struct gdb_osabi_handler *handler;
291 if (info.osabi == GDB_OSABI_UNKNOWN)
293 /* Don't complain about an unknown OSABI. Assume the user knows
294 what they are doing. */
298 for (handler = gdb_osabi_handler_list; handler != NULL;
299 handler = handler->next)
301 if (handler->osabi != info.osabi)
304 /* Check whether the machine type and architecture of the
305 handler are compatible with the desired machine type and
308 NOTE: kettenis/20021027: There may be more than one machine
309 type that is compatible with the desired machine type. Right
310 now we simply return the first match, which is fine for now.
311 However, we might want to do something smarter in the future. */
312 compatible = arch_info->compatible (arch_info, handler->arch_info);
313 if (compatible == handler->arch_info)
315 (*handler->init_osabi) (info, gdbarch);
320 /* We assume that if GDB_MULTI_ARCH is less than GDB_MULTI_ARCH_TM
321 that an ABI variant can be supported by overriding definitions in
323 if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
326 "A handler for the OS ABI \"%s\" is not built into this "
327 "configuration of GDB. "
328 "Attempting to continue with the default %s settings",
329 gdbarch_osabi_name (info.osabi),
330 bfd_printable_arch_mach (arch_info->arch, arch_info->mach));
334 /* Generic sniffer for ELF flavoured files. */
337 generic_elf_osabi_sniff_abi_tag_sections (bfd *abfd, asection *sect, void *obj)
339 enum gdb_osabi *os_ident_ptr = obj;
341 unsigned int sectsize;
343 name = bfd_get_section_name (abfd, sect);
344 sectsize = bfd_section_size (abfd, sect);
346 /* .note.ABI-tag notes, used by GNU/Linux and FreeBSD. */
347 if (strcmp (name, ".note.ABI-tag") == 0 && sectsize > 0)
349 unsigned int name_length, data_length, note_type;
352 /* If the section is larger than this, it's probably not what we are
357 note = alloca (sectsize);
359 bfd_get_section_contents (abfd, sect, note,
360 (file_ptr) 0, (bfd_size_type) sectsize);
362 name_length = bfd_h_get_32 (abfd, note);
363 data_length = bfd_h_get_32 (abfd, note + 4);
364 note_type = bfd_h_get_32 (abfd, note + 8);
366 if (name_length == 4 && data_length == 16 && note_type == NT_GNU_ABI_TAG
367 && strcmp (note + 12, "GNU") == 0)
369 int os_number = bfd_h_get_32 (abfd, note + 16);
373 case GNU_ABI_TAG_LINUX:
374 *os_ident_ptr = GDB_OSABI_LINUX;
377 case GNU_ABI_TAG_HURD:
378 *os_ident_ptr = GDB_OSABI_HURD;
381 case GNU_ABI_TAG_SOLARIS:
382 *os_ident_ptr = GDB_OSABI_SOLARIS;
388 "generic_elf_osabi_sniff_abi_tag_sections: unknown OS number %d",
393 else if (name_length == 8 && data_length == 4
394 && note_type == NT_FREEBSD_ABI_TAG
395 && strcmp (note + 12, "FreeBSD") == 0)
397 /* XXX Should we check the version here? Probably not
399 *os_ident_ptr = GDB_OSABI_FREEBSD_ELF;
404 /* .note.netbsd.ident notes, used by NetBSD. */
405 if (strcmp (name, ".note.netbsd.ident") == 0 && sectsize > 0)
407 unsigned int name_length, data_length, note_type;
410 /* If the section is larger than this, it's probably not what we are
415 note = alloca (sectsize);
417 bfd_get_section_contents (abfd, sect, note,
418 (file_ptr) 0, (bfd_size_type) sectsize);
420 name_length = bfd_h_get_32 (abfd, note);
421 data_length = bfd_h_get_32 (abfd, note + 4);
422 note_type = bfd_h_get_32 (abfd, note + 8);
424 if (name_length == 7 && data_length == 4 && note_type == NT_NETBSD_IDENT
425 && strcmp (note + 12, "NetBSD") == 0)
427 /* XXX Should we check the version here? Probably not
429 *os_ident_ptr = GDB_OSABI_NETBSD_ELF;
435 static enum gdb_osabi
436 generic_elf_osabi_sniffer (bfd *abfd)
438 unsigned int elfosabi;
439 enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
441 elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
446 /* When elfosabi is ELFOSABI_NONE (0), then the ELF structures in the
447 file are conforming to the base specification for that machine
448 (there are no OS-specific extensions). In order to determine the
449 real OS in use we must look for OS notes that have been added. */
450 bfd_map_over_sections (abfd,
451 generic_elf_osabi_sniff_abi_tag_sections,
455 case ELFOSABI_FREEBSD:
456 osabi = GDB_OSABI_FREEBSD_ELF;
459 case ELFOSABI_NETBSD:
460 osabi = GDB_OSABI_NETBSD_ELF;
464 osabi = GDB_OSABI_LINUX;
468 osabi = GDB_OSABI_HURD;
471 case ELFOSABI_SOLARIS:
472 osabi = GDB_OSABI_SOLARIS;
476 osabi = GDB_OSABI_HPUX_ELF;
480 if (osabi == GDB_OSABI_UNKNOWN)
482 /* The FreeBSD folks have been naughty; they stored the string
483 "FreeBSD" in the padding of the e_ident field of the ELF
484 header to "brand" their ELF binaries in FreeBSD 3.x. */
485 if (strcmp (&elf_elfheader (abfd)->e_ident[8], "FreeBSD") == 0)
486 osabi = GDB_OSABI_FREEBSD_ELF;
493 set_osabi (char *args, int from_tty, struct cmd_list_element *c)
495 struct gdbarch_info info;
497 if (strcmp (set_osabi_string, "auto") == 0)
498 user_osabi_state = osabi_auto;
499 else if (strcmp (set_osabi_string, "default") == 0)
501 user_selected_osabi = GDB_OSABI_DEFAULT;
502 user_osabi_state = osabi_user;
504 else if (strcmp (set_osabi_string, "none") == 0)
506 user_selected_osabi = GDB_OSABI_UNKNOWN;
507 user_osabi_state = osabi_user;
512 for (i = 1; i < GDB_OSABI_INVALID; i++)
513 if (strcmp (set_osabi_string, gdbarch_osabi_name (i)) == 0)
515 user_selected_osabi = i;
516 user_osabi_state = osabi_user;
519 if (i == GDB_OSABI_INVALID)
520 internal_error (__FILE__, __LINE__,
521 "Invalid OS ABI \"%s\" passed to command handler.",
525 /* NOTE: At some point (true multiple architectures) we'll need to be more
527 gdbarch_info_init (&info);
528 if (! gdbarch_update_p (info))
529 internal_error (__FILE__, __LINE__, "Updating OS ABI failed.");
533 show_osabi (char *args, int from_tty)
535 if (user_osabi_state == osabi_auto)
536 printf_filtered ("The current OS ABI is \"auto\" (currently \"%s\").\n",
537 gdbarch_osabi_name (gdbarch_osabi (current_gdbarch)));
539 printf_filtered ("The current OS ABI is \"%s\".\n",
540 gdbarch_osabi_name (user_selected_osabi));
542 if (GDB_OSABI_DEFAULT != GDB_OSABI_UNKNOWN)
543 printf_filtered ("The default OS ABI is \"%s\".\n",
544 gdbarch_osabi_name (GDB_OSABI_DEFAULT));
548 _initialize_gdb_osabi (void)
550 struct cmd_list_element *c;
552 if (strcmp (gdb_osabi_names[GDB_OSABI_INVALID], "<invalid>") != 0)
555 "_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent");
557 /* Register a generic sniffer for ELF flavoured files. */
558 gdbarch_register_osabi_sniffer (bfd_arch_unknown,
559 bfd_target_elf_flavour,
560 generic_elf_osabi_sniffer);
565 /* Register the "set osabi" command. */
566 c = add_set_enum_cmd ("osabi", class_support, gdb_osabi_available_names,
567 &set_osabi_string, "Set OS ABI of target.", &setlist);
569 set_cmd_sfunc (c, set_osabi);
570 add_cmd ("osabi", class_support, show_osabi, "Show OS/ABI of target.",
572 user_osabi_state = osabi_auto;