1 /* OS ABI variant handling for GDB.
3 Copyright (C) 2001, 2002, 2003, 2004 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 2 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, write to the Free Software
19 Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
24 #include "gdb_assert.h"
25 #include "gdb_string.h"
28 #include "arch-utils.h"
34 #ifndef GDB_OSABI_DEFAULT
35 #define GDB_OSABI_DEFAULT GDB_OSABI_UNKNOWN
38 /* State for the "set osabi" command. */
39 static enum { osabi_auto
, osabi_default
, osabi_user
} user_osabi_state
;
40 static enum gdb_osabi user_selected_osabi
;
41 static const char *gdb_osabi_available_names
[GDB_OSABI_INVALID
+ 3] = {
47 static const char *set_osabi_string
;
49 /* This table matches the indices assigned to enum gdb_osabi. Keep
51 static const char * const gdb_osabi_names
[] =
83 gdbarch_osabi_name (enum gdb_osabi osabi
)
85 if (osabi
>= GDB_OSABI_UNKNOWN
&& osabi
< GDB_OSABI_INVALID
)
86 return gdb_osabi_names
[osabi
];
88 return gdb_osabi_names
[GDB_OSABI_INVALID
];
91 /* Handler for a given architecture/OS ABI pair. There should be only
92 one handler for a given OS ABI each architecture family. */
93 struct gdb_osabi_handler
95 struct gdb_osabi_handler
*next
;
96 const struct bfd_arch_info
*arch_info
;
98 void (*init_osabi
)(struct gdbarch_info
, struct gdbarch
*);
101 static struct gdb_osabi_handler
*gdb_osabi_handler_list
;
104 gdbarch_register_osabi (enum bfd_architecture arch
, unsigned long machine
,
105 enum gdb_osabi osabi
,
106 void (*init_osabi
)(struct gdbarch_info
,
109 struct gdb_osabi_handler
**handler_p
;
110 const struct bfd_arch_info
*arch_info
= bfd_lookup_arch (arch
, machine
);
111 const char **name_ptr
;
113 /* Registering an OS ABI handler for "unknown" is not allowed. */
114 if (osabi
== GDB_OSABI_UNKNOWN
)
118 _("gdbarch_register_osabi: An attempt to register a handler for "
119 "OS ABI \"%s\" for architecture %s was made. The handler will "
120 "not be registered"),
121 gdbarch_osabi_name (osabi
),
122 bfd_printable_arch_mach (arch
, machine
));
126 gdb_assert (arch_info
);
128 for (handler_p
= &gdb_osabi_handler_list
; *handler_p
!= NULL
;
129 handler_p
= &(*handler_p
)->next
)
131 if ((*handler_p
)->arch_info
== arch_info
132 && (*handler_p
)->osabi
== osabi
)
136 _("gdbarch_register_osabi: A handler for OS ABI \"%s\" "
137 "has already been registered for architecture %s"),
138 gdbarch_osabi_name (osabi
),
139 arch_info
->printable_name
);
140 /* If user wants to continue, override previous definition. */
141 (*handler_p
)->init_osabi
= init_osabi
;
147 = (struct gdb_osabi_handler
*) xmalloc (sizeof (struct gdb_osabi_handler
));
148 (*handler_p
)->next
= NULL
;
149 (*handler_p
)->arch_info
= arch_info
;
150 (*handler_p
)->osabi
= osabi
;
151 (*handler_p
)->init_osabi
= init_osabi
;
153 /* Add this OS ABI to the list of enum values for "set osabi", if it isn't
155 for (name_ptr
= gdb_osabi_available_names
; *name_ptr
; name_ptr
++)
157 if (*name_ptr
== gdbarch_osabi_name (osabi
))
160 *name_ptr
++ = gdbarch_osabi_name (osabi
);
165 /* Sniffer to find the OS ABI for a given file's architecture and flavour.
166 It is legal to have multiple sniffers for each arch/flavour pair, to
167 disambiguate one OS's a.out from another, for example. The first sniffer
168 to return something other than GDB_OSABI_UNKNOWN wins, so a sniffer should
169 be careful to claim a file only if it knows for sure what it is. */
170 struct gdb_osabi_sniffer
172 struct gdb_osabi_sniffer
*next
;
173 enum bfd_architecture arch
; /* bfd_arch_unknown == wildcard */
174 enum bfd_flavour flavour
;
175 enum gdb_osabi (*sniffer
)(bfd
*);
178 static struct gdb_osabi_sniffer
*gdb_osabi_sniffer_list
;
181 gdbarch_register_osabi_sniffer (enum bfd_architecture arch
,
182 enum bfd_flavour flavour
,
183 enum gdb_osabi (*sniffer_fn
)(bfd
*))
185 struct gdb_osabi_sniffer
*sniffer
;
188 (struct gdb_osabi_sniffer
*) xmalloc (sizeof (struct gdb_osabi_sniffer
));
189 sniffer
->arch
= arch
;
190 sniffer
->flavour
= flavour
;
191 sniffer
->sniffer
= sniffer_fn
;
193 sniffer
->next
= gdb_osabi_sniffer_list
;
194 gdb_osabi_sniffer_list
= sniffer
;
199 gdbarch_lookup_osabi (bfd
*abfd
)
201 struct gdb_osabi_sniffer
*sniffer
;
202 enum gdb_osabi osabi
, match
;
205 /* If we aren't in "auto" mode, return the specified OS ABI. */
206 if (user_osabi_state
== osabi_user
)
207 return user_selected_osabi
;
209 /* If we don't have a binary, return the default OS ABI (if set) or
210 unknown (otherwise). */
212 return GDB_OSABI_DEFAULT
;
214 match
= GDB_OSABI_UNKNOWN
;
217 for (sniffer
= gdb_osabi_sniffer_list
; sniffer
!= NULL
;
218 sniffer
= sniffer
->next
)
220 if ((sniffer
->arch
== bfd_arch_unknown
/* wildcard */
221 || sniffer
->arch
== bfd_get_arch (abfd
))
222 && sniffer
->flavour
== bfd_get_flavour (abfd
))
224 osabi
= (*sniffer
->sniffer
) (abfd
);
225 if (osabi
< GDB_OSABI_UNKNOWN
|| osabi
>= GDB_OSABI_INVALID
)
229 _("gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer "
230 "for architecture %s flavour %d"),
232 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0),
233 (int) bfd_get_flavour (abfd
));
235 else if (osabi
!= GDB_OSABI_UNKNOWN
)
237 /* A specific sniffer always overrides a generic sniffer.
238 Croak on multiple match if the two matches are of the
239 same class. If the user wishes to continue, we'll use
241 if (match
!= GDB_OSABI_UNKNOWN
)
243 if ((match_specific
&& sniffer
->arch
!= bfd_arch_unknown
)
244 || (!match_specific
&& sniffer
->arch
== bfd_arch_unknown
))
248 _("gdbarch_lookup_osabi: multiple %sspecific OS ABI "
249 "match for architecture %s flavour %d: first "
250 "match \"%s\", second match \"%s\""),
251 match_specific
? "" : "non-",
252 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0),
253 (int) bfd_get_flavour (abfd
),
254 gdbarch_osabi_name (match
),
255 gdbarch_osabi_name (osabi
));
257 else if (sniffer
->arch
!= bfd_arch_unknown
)
266 if (sniffer
->arch
!= bfd_arch_unknown
)
273 /* If we didn't find a match, but a default was specified at configure
274 time, return the default. */
275 if (GDB_OSABI_DEFAULT
!= GDB_OSABI_UNKNOWN
&& match
== GDB_OSABI_UNKNOWN
)
276 return GDB_OSABI_DEFAULT
;
282 /* Return non-zero if architecture A can run code written for
285 can_run_code_for (const struct bfd_arch_info
*a
, const struct bfd_arch_info
*b
)
287 /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
288 incompatible. But if they are compatible, it returns the 'more
289 featureful' of the two arches. That is, if A can run code
290 written for B, but B can't run code written for A, then it'll
293 struct bfd_arch_info objects are singletons: that is, there's
294 supposed to be exactly one instance for a given machine. So you
295 can tell whether two are equivalent by comparing pointers. */
296 return (a
== b
|| a
->compatible (a
, b
) == a
);
301 gdbarch_init_osabi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
303 struct gdb_osabi_handler
*handler
;
305 if (info
.osabi
== GDB_OSABI_UNKNOWN
)
307 /* Don't complain about an unknown OSABI. Assume the user knows
308 what they are doing. */
312 for (handler
= gdb_osabi_handler_list
; handler
!= NULL
;
313 handler
= handler
->next
)
315 if (handler
->osabi
!= info
.osabi
)
318 /* If the architecture described by ARCH_INFO can run code for
319 the architcture we registered the handler for, then the
320 handler is applicable. Note, though, that if the handler is
321 for an architecture that is a superset of ARCH_INFO, we can't
322 use that --- it would be perfectly correct for it to install
323 gdbarch methods that refer to registers / instructions /
324 other facilities ARCH_INFO doesn't have.
326 NOTE: kettenis/20021027: There may be more than one machine
327 type that is compatible with the desired machine type. Right
328 now we simply return the first match, which is fine for now.
329 However, we might want to do something smarter in the future. */
330 /* NOTE: cagney/2003-10-23: The code for "a can_run_code_for b"
331 is implemented using BFD's compatible method (a->compatible
332 (b) == a -- the lowest common denominator between a and b is
333 a). That method's definition of compatible may not be as you
334 expect. For instance the test "amd64 can run code for i386"
335 (or more generally "64-bit ISA can run code for the 32-bit
336 ISA"). BFD doesn't normally consider 32-bit and 64-bit
337 "compatible" so it doesn't succeed. */
338 if (can_run_code_for (info
.bfd_arch_info
, handler
->arch_info
))
340 (*handler
->init_osabi
) (info
, gdbarch
);
346 ("A handler for the OS ABI \"%s\" is not built into this configuration\n"
347 "of GDB. Attempting to continue with the default %s settings.\n",
348 gdbarch_osabi_name (info
.osabi
),
349 info
.bfd_arch_info
->printable_name
);
352 /* Limit on the amount of data to be read. */
353 #define MAX_NOTESZ 128
355 /* Return non-zero if NOTE matches NAME, DESCSZ and TYPE. */
358 check_note (bfd
*abfd
, asection
*sect
, const char *note
,
359 const char *name
, unsigned long descsz
, unsigned long type
)
361 unsigned long notesz
;
363 /* Calculate the size of this note. */
364 notesz
= strlen (name
) + 1;
365 notesz
= ((notesz
+ 3) & ~3);
367 notesz
= ((notesz
+ 3) & ~3);
369 /* If this assertion triggers, increase MAX_NOTESZ. */
370 gdb_assert (notesz
<= MAX_NOTESZ
);
372 /* Check whether SECT is big enough to comtain the complete note. */
373 if (notesz
> bfd_section_size (abfd
, sect
))
376 /* Check the note name. */
377 if (bfd_h_get_32 (abfd
, note
) != (strlen (name
) + 1)
378 || strcmp (note
+ 12, name
) != 0)
381 /* Check the descriptor size. */
382 if (bfd_h_get_32 (abfd
, note
+ 4) != descsz
)
385 /* Check the note type. */
386 if (bfd_h_get_32 (abfd
, note
+ 8) != type
)
392 /* Generic sniffer for ELF flavoured files. */
395 generic_elf_osabi_sniff_abi_tag_sections (bfd
*abfd
, asection
*sect
, void *obj
)
397 enum gdb_osabi
*osabi
= obj
;
399 unsigned int sectsize
;
402 name
= bfd_get_section_name (abfd
, sect
);
403 sectsize
= bfd_section_size (abfd
, sect
);
405 /* Limit the amount of data to read. */
406 if (sectsize
> MAX_NOTESZ
)
407 sectsize
= MAX_NOTESZ
;
409 note
= alloca (sectsize
);
410 bfd_get_section_contents (abfd
, sect
, note
, 0, sectsize
);
412 /* .note.ABI-tag notes, used by GNU/Linux and FreeBSD. */
413 if (strcmp (name
, ".note.ABI-tag") == 0)
416 if (check_note (abfd
, sect
, note
, "GNU", 16, NT_GNU_ABI_TAG
))
418 unsigned int abi_tag
= bfd_h_get_32 (abfd
, note
+ 16);
422 case GNU_ABI_TAG_LINUX
:
423 *osabi
= GDB_OSABI_LINUX
;
426 case GNU_ABI_TAG_HURD
:
427 *osabi
= GDB_OSABI_HURD
;
430 case GNU_ABI_TAG_SOLARIS
:
431 *osabi
= GDB_OSABI_SOLARIS
;
434 case GNU_ABI_TAG_FREEBSD
:
435 *osabi
= GDB_OSABI_FREEBSD_ELF
;
438 case GNU_ABI_TAG_NETBSD
:
439 *osabi
= GDB_OSABI_NETBSD_ELF
;
443 internal_error (__FILE__
, __LINE__
, _("\
444 generic_elf_osabi_sniff_abi_tag_sections: unknown OS number %d"),
451 if (check_note (abfd
, sect
, note
, "FreeBSD", 4, NT_FREEBSD_ABI_TAG
))
453 /* There is no need to check the version yet. */
454 *osabi
= GDB_OSABI_FREEBSD_ELF
;
461 /* .note.netbsd.ident notes, used by NetBSD. */
462 if (strcmp (name
, ".note.netbsd.ident") == 0
463 && check_note (abfd
, sect
, note
, "NetBSD", 4, NT_NETBSD_IDENT
))
465 /* There is no need to check the version yet. */
466 *osabi
= GDB_OSABI_NETBSD_ELF
;
470 /* .note.openbsd.ident notes, used by OpenBSD. */
471 if (strcmp (name
, ".note.openbsd.ident") == 0
472 && check_note (abfd
, sect
, note
, "OpenBSD", 4, NT_OPENBSD_IDENT
))
474 /* There is no need to check the version yet. */
475 *osabi
= GDB_OSABI_OPENBSD_ELF
;
479 /* .note.netbsdcore.procinfo notes, used by NetBSD. */
480 if (strcmp (name
, ".note.netbsdcore.procinfo") == 0)
482 *osabi
= GDB_OSABI_NETBSD_ELF
;
487 static enum gdb_osabi
488 generic_elf_osabi_sniffer (bfd
*abfd
)
490 unsigned int elfosabi
;
491 enum gdb_osabi osabi
= GDB_OSABI_UNKNOWN
;
493 elfosabi
= elf_elfheader (abfd
)->e_ident
[EI_OSABI
];
498 /* When the EI_OSABI field in the ELF header is ELFOSABI_NONE
499 (0), then the ELF structures in the file are conforming to
500 the base specification for that machine (there are no
501 OS-specific extensions). In order to determine the real OS
502 in use we must look for OS-specific notes. */
503 bfd_map_over_sections (abfd
,
504 generic_elf_osabi_sniff_abi_tag_sections
,
508 case ELFOSABI_FREEBSD
:
509 osabi
= GDB_OSABI_FREEBSD_ELF
;
512 case ELFOSABI_NETBSD
:
513 osabi
= GDB_OSABI_NETBSD_ELF
;
517 osabi
= GDB_OSABI_LINUX
;
521 osabi
= GDB_OSABI_HURD
;
524 case ELFOSABI_SOLARIS
:
525 osabi
= GDB_OSABI_SOLARIS
;
529 /* For some reason the default value for the EI_OSABI field is
530 ELFOSABI_HPUX for all PA-RISC targets (with the exception of
531 GNU/Linux). We use HP-UX ELF as the default, but let any
532 OS-specific notes override this. */
533 osabi
= GDB_OSABI_HPUX_ELF
;
534 bfd_map_over_sections (abfd
,
535 generic_elf_osabi_sniff_abi_tag_sections
,
540 if (osabi
== GDB_OSABI_UNKNOWN
)
542 /* The FreeBSD folks have been naughty; they stored the string
543 "FreeBSD" in the padding of the e_ident field of the ELF
544 header to "brand" their ELF binaries in FreeBSD 3.x. */
545 if (memcmp (&elf_elfheader (abfd
)->e_ident
[8],
546 "FreeBSD", sizeof ("FreeBSD")) == 0)
547 osabi
= GDB_OSABI_FREEBSD_ELF
;
554 set_osabi (char *args
, int from_tty
, struct cmd_list_element
*c
)
556 struct gdbarch_info info
;
558 if (strcmp (set_osabi_string
, "auto") == 0)
559 user_osabi_state
= osabi_auto
;
560 else if (strcmp (set_osabi_string
, "default") == 0)
562 user_selected_osabi
= GDB_OSABI_DEFAULT
;
563 user_osabi_state
= osabi_user
;
565 else if (strcmp (set_osabi_string
, "none") == 0)
567 user_selected_osabi
= GDB_OSABI_UNKNOWN
;
568 user_osabi_state
= osabi_user
;
573 for (i
= 1; i
< GDB_OSABI_INVALID
; i
++)
574 if (strcmp (set_osabi_string
, gdbarch_osabi_name (i
)) == 0)
576 user_selected_osabi
= i
;
577 user_osabi_state
= osabi_user
;
580 if (i
== GDB_OSABI_INVALID
)
581 internal_error (__FILE__
, __LINE__
,
582 _("Invalid OS ABI \"%s\" passed to command handler."),
586 /* NOTE: At some point (true multiple architectures) we'll need to be more
588 gdbarch_info_init (&info
);
589 if (! gdbarch_update_p (info
))
590 internal_error (__FILE__
, __LINE__
, _("Updating OS ABI failed."));
594 show_osabi (struct ui_file
*file
, int from_tty
, struct cmd_list_element
*c
,
597 if (user_osabi_state
== osabi_auto
)
598 fprintf_filtered (file
,
599 _("The current OS ABI is \"auto\" (currently \"%s\").\n"),
600 gdbarch_osabi_name (gdbarch_osabi (current_gdbarch
)));
602 fprintf_filtered (file
, _("The current OS ABI is \"%s\".\n"),
603 gdbarch_osabi_name (user_selected_osabi
));
605 if (GDB_OSABI_DEFAULT
!= GDB_OSABI_UNKNOWN
)
606 fprintf_filtered (file
, _("The default OS ABI is \"%s\".\n"),
607 gdbarch_osabi_name (GDB_OSABI_DEFAULT
));
610 extern initialize_file_ftype _initialize_gdb_osabi
; /* -Wmissing-prototype */
613 _initialize_gdb_osabi (void)
615 struct cmd_list_element
*c
;
617 if (strcmp (gdb_osabi_names
[GDB_OSABI_INVALID
], "<invalid>") != 0)
620 _("_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent"));
622 /* Register a generic sniffer for ELF flavoured files. */
623 gdbarch_register_osabi_sniffer (bfd_arch_unknown
,
624 bfd_target_elf_flavour
,
625 generic_elf_osabi_sniffer
);
627 /* Register the "set osabi" command. */
628 add_setshow_enum_cmd ("osabi", class_support
, gdb_osabi_available_names
,
629 &set_osabi_string
, _("\
630 Set OS ABI of target."), _("\
631 Show OS ABI of target."), NULL
,
634 &setlist
, &showlist
);
635 user_osabi_state
= osabi_auto
;