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/>. */
25 #include "arch-utils.h"
31 #ifndef GDB_OSABI_DEFAULT
32 #define GDB_OSABI_DEFAULT GDB_OSABI_UNKNOWN
35 /* State for the "set osabi" command. */
36 static enum { osabi_auto
, osabi_default
, osabi_user
} user_osabi_state
;
37 static enum gdb_osabi user_selected_osabi
;
38 static const char *gdb_osabi_available_names
[GDB_OSABI_INVALID
+ 3] = {
44 static const char *set_osabi_string
;
46 /* This table matches the indices assigned to enum gdb_osabi. Keep
48 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 /* Lookup the OS ABI corresponding to the specified target description
93 osabi_from_tdesc_string (const char *name
)
97 for (i
= 0; i
< ARRAY_SIZE (gdb_osabi_names
); i
++)
98 if (strcmp (name
, gdb_osabi_names
[i
]) == 0)
100 /* See note above: the name table matches the indices assigned
101 to enum gdb_osabi. */
102 enum gdb_osabi osabi
= (enum gdb_osabi
) i
;
104 if (osabi
== GDB_OSABI_INVALID
)
105 return GDB_OSABI_UNKNOWN
;
110 return GDB_OSABI_UNKNOWN
;
113 /* Handler for a given architecture/OS ABI pair. There should be only
114 one handler for a given OS ABI each architecture family. */
115 struct gdb_osabi_handler
117 struct gdb_osabi_handler
*next
;
118 const struct bfd_arch_info
*arch_info
;
119 enum gdb_osabi osabi
;
120 void (*init_osabi
)(struct gdbarch_info
, struct gdbarch
*);
123 static struct gdb_osabi_handler
*gdb_osabi_handler_list
;
126 gdbarch_register_osabi (enum bfd_architecture arch
, unsigned long machine
,
127 enum gdb_osabi osabi
,
128 void (*init_osabi
)(struct gdbarch_info
,
131 struct gdb_osabi_handler
**handler_p
;
132 const struct bfd_arch_info
*arch_info
= bfd_lookup_arch (arch
, machine
);
133 const char **name_ptr
;
135 /* Registering an OS ABI handler for "unknown" is not allowed. */
136 if (osabi
== GDB_OSABI_UNKNOWN
)
140 _("gdbarch_register_osabi: An attempt to register a handler for "
141 "OS ABI \"%s\" for architecture %s was made. The handler will "
142 "not be registered"),
143 gdbarch_osabi_name (osabi
),
144 bfd_printable_arch_mach (arch
, machine
));
148 gdb_assert (arch_info
);
150 for (handler_p
= &gdb_osabi_handler_list
; *handler_p
!= NULL
;
151 handler_p
= &(*handler_p
)->next
)
153 if ((*handler_p
)->arch_info
== arch_info
154 && (*handler_p
)->osabi
== osabi
)
158 _("gdbarch_register_osabi: A handler for OS ABI \"%s\" "
159 "has already been registered for architecture %s"),
160 gdbarch_osabi_name (osabi
),
161 arch_info
->printable_name
);
162 /* If user wants to continue, override previous definition. */
163 (*handler_p
)->init_osabi
= init_osabi
;
169 = (struct gdb_osabi_handler
*) xmalloc (sizeof (struct gdb_osabi_handler
));
170 (*handler_p
)->next
= NULL
;
171 (*handler_p
)->arch_info
= arch_info
;
172 (*handler_p
)->osabi
= osabi
;
173 (*handler_p
)->init_osabi
= init_osabi
;
175 /* Add this OS ABI to the list of enum values for "set osabi", if it isn't
177 for (name_ptr
= gdb_osabi_available_names
; *name_ptr
; name_ptr
++)
179 if (*name_ptr
== gdbarch_osabi_name (osabi
))
182 *name_ptr
++ = gdbarch_osabi_name (osabi
);
187 /* Sniffer to find the OS ABI for a given file's architecture and flavour.
188 It is legal to have multiple sniffers for each arch/flavour pair, to
189 disambiguate one OS's a.out from another, for example. The first sniffer
190 to return something other than GDB_OSABI_UNKNOWN wins, so a sniffer should
191 be careful to claim a file only if it knows for sure what it is. */
192 struct gdb_osabi_sniffer
194 struct gdb_osabi_sniffer
*next
;
195 enum bfd_architecture arch
; /* bfd_arch_unknown == wildcard */
196 enum bfd_flavour flavour
;
197 enum gdb_osabi (*sniffer
)(bfd
*);
200 static struct gdb_osabi_sniffer
*gdb_osabi_sniffer_list
;
203 gdbarch_register_osabi_sniffer (enum bfd_architecture arch
,
204 enum bfd_flavour flavour
,
205 enum gdb_osabi (*sniffer_fn
)(bfd
*))
207 struct gdb_osabi_sniffer
*sniffer
;
210 (struct gdb_osabi_sniffer
*) xmalloc (sizeof (struct gdb_osabi_sniffer
));
211 sniffer
->arch
= arch
;
212 sniffer
->flavour
= flavour
;
213 sniffer
->sniffer
= sniffer_fn
;
215 sniffer
->next
= gdb_osabi_sniffer_list
;
216 gdb_osabi_sniffer_list
= sniffer
;
221 gdbarch_lookup_osabi (bfd
*abfd
)
223 struct gdb_osabi_sniffer
*sniffer
;
224 enum gdb_osabi osabi
, match
;
227 /* If we aren't in "auto" mode, return the specified OS ABI. */
228 if (user_osabi_state
== osabi_user
)
229 return user_selected_osabi
;
231 /* If we don't have a binary, just return unknown. The caller may
232 have other sources the OSABI can be extracted from, e.g., the
233 target description. */
235 return GDB_OSABI_UNKNOWN
;
237 match
= GDB_OSABI_UNKNOWN
;
240 for (sniffer
= gdb_osabi_sniffer_list
; sniffer
!= NULL
;
241 sniffer
= sniffer
->next
)
243 if ((sniffer
->arch
== bfd_arch_unknown
/* wildcard */
244 || sniffer
->arch
== bfd_get_arch (abfd
))
245 && sniffer
->flavour
== bfd_get_flavour (abfd
))
247 osabi
= (*sniffer
->sniffer
) (abfd
);
248 if (osabi
< GDB_OSABI_UNKNOWN
|| osabi
>= GDB_OSABI_INVALID
)
252 _("gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer "
253 "for architecture %s flavour %d"),
255 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0),
256 (int) bfd_get_flavour (abfd
));
258 else if (osabi
!= GDB_OSABI_UNKNOWN
)
260 /* A specific sniffer always overrides a generic sniffer.
261 Croak on multiple match if the two matches are of the
262 same class. If the user wishes to continue, we'll use
264 if (match
!= GDB_OSABI_UNKNOWN
)
266 if ((match_specific
&& sniffer
->arch
!= bfd_arch_unknown
)
267 || (!match_specific
&& sniffer
->arch
== bfd_arch_unknown
))
271 _("gdbarch_lookup_osabi: multiple %sspecific OS ABI "
272 "match for architecture %s flavour %d: first "
273 "match \"%s\", second match \"%s\""),
274 match_specific
? "" : "non-",
275 bfd_printable_arch_mach (bfd_get_arch (abfd
), 0),
276 (int) bfd_get_flavour (abfd
),
277 gdbarch_osabi_name (match
),
278 gdbarch_osabi_name (osabi
));
280 else if (sniffer
->arch
!= bfd_arch_unknown
)
289 if (sniffer
->arch
!= bfd_arch_unknown
)
300 /* Return non-zero if architecture A can run code written for
303 can_run_code_for (const struct bfd_arch_info
*a
, const struct bfd_arch_info
*b
)
305 /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
306 incompatible. But if they are compatible, it returns the 'more
307 featureful' of the two arches. That is, if A can run code
308 written for B, but B can't run code written for A, then it'll
311 struct bfd_arch_info objects are singletons: that is, there's
312 supposed to be exactly one instance for a given machine. So you
313 can tell whether two are equivalent by comparing pointers. */
314 return (a
== b
|| a
->compatible (a
, b
) == a
);
319 gdbarch_init_osabi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
321 struct gdb_osabi_handler
*handler
;
323 if (info
.osabi
== GDB_OSABI_UNKNOWN
)
325 /* Don't complain about an unknown OSABI. Assume the user knows
326 what they are doing. */
330 for (handler
= gdb_osabi_handler_list
; handler
!= NULL
;
331 handler
= handler
->next
)
333 if (handler
->osabi
!= info
.osabi
)
336 /* If the architecture described by ARCH_INFO can run code for
337 the architcture we registered the handler for, then the
338 handler is applicable. Note, though, that if the handler is
339 for an architecture that is a superset of ARCH_INFO, we can't
340 use that --- it would be perfectly correct for it to install
341 gdbarch methods that refer to registers / instructions /
342 other facilities ARCH_INFO doesn't have.
344 NOTE: kettenis/20021027: There may be more than one machine
345 type that is compatible with the desired machine type. Right
346 now we simply return the first match, which is fine for now.
347 However, we might want to do something smarter in the future. */
348 /* NOTE: cagney/2003-10-23: The code for "a can_run_code_for b"
349 is implemented using BFD's compatible method (a->compatible
350 (b) == a -- the lowest common denominator between a and b is
351 a). That method's definition of compatible may not be as you
352 expect. For instance the test "amd64 can run code for i386"
353 (or more generally "64-bit ISA can run code for the 32-bit
354 ISA"). BFD doesn't normally consider 32-bit and 64-bit
355 "compatible" so it doesn't succeed. */
356 if (can_run_code_for (info
.bfd_arch_info
, handler
->arch_info
))
358 (*handler
->init_osabi
) (info
, gdbarch
);
364 ("A handler for the OS ABI \"%s\" is not built into this configuration\n"
365 "of GDB. Attempting to continue with the default %s settings.\n",
366 gdbarch_osabi_name (info
.osabi
),
367 info
.bfd_arch_info
->printable_name
);
370 /* Limit on the amount of data to be read. */
371 #define MAX_NOTESZ 128
373 /* Return non-zero if NOTE matches NAME, DESCSZ and TYPE. If
374 *SECTSIZE is non-zero, then this reads that many bytes from
375 the start of the section and clears *SECTSIZE. */
378 check_note (bfd
*abfd
, asection
*sect
, char *note
, unsigned int *sectsize
,
379 const char *name
, unsigned long descsz
, unsigned long type
)
381 unsigned long notesz
;
385 if (!bfd_get_section_contents (abfd
, sect
, note
, 0, *sectsize
))
390 /* Calculate the size of this note. */
391 notesz
= strlen (name
) + 1;
392 notesz
= ((notesz
+ 3) & ~3);
394 notesz
= ((notesz
+ 3) & ~3);
396 /* If this assertion triggers, increase MAX_NOTESZ. */
397 gdb_assert (notesz
<= MAX_NOTESZ
);
399 /* Check whether SECT is big enough to comtain the complete note. */
400 if (notesz
> bfd_section_size (abfd
, sect
))
403 /* Check the note name. */
404 if (bfd_h_get_32 (abfd
, note
) != (strlen (name
) + 1)
405 || strcmp (note
+ 12, name
) != 0)
408 /* Check the descriptor size. */
409 if (bfd_h_get_32 (abfd
, note
+ 4) != descsz
)
412 /* Check the note type. */
413 if (bfd_h_get_32 (abfd
, note
+ 8) != type
)
419 /* Generic sniffer for ELF flavoured files. */
422 generic_elf_osabi_sniff_abi_tag_sections (bfd
*abfd
, asection
*sect
, void *obj
)
424 enum gdb_osabi
*osabi
= obj
;
426 unsigned int sectsize
;
429 name
= bfd_get_section_name (abfd
, sect
);
430 sectsize
= bfd_section_size (abfd
, sect
);
432 /* Limit the amount of data to read. */
433 if (sectsize
> MAX_NOTESZ
)
434 sectsize
= MAX_NOTESZ
;
436 /* We lazily read the section data here. Since we use
437 BFD_DECOMPRESS, we can't use bfd_get_section_contents on a
438 compressed section. But, since note sections are not compressed,
439 deferring the reading until we recognize the section avoids any
441 note
= alloca (sectsize
);
443 /* .note.ABI-tag notes, used by GNU/Linux and FreeBSD. */
444 if (strcmp (name
, ".note.ABI-tag") == 0)
447 if (check_note (abfd
, sect
, note
, §size
, "GNU", 16, NT_GNU_ABI_TAG
))
449 unsigned int abi_tag
= bfd_h_get_32 (abfd
, note
+ 16);
453 case GNU_ABI_TAG_LINUX
:
454 *osabi
= GDB_OSABI_LINUX
;
457 case GNU_ABI_TAG_HURD
:
458 *osabi
= GDB_OSABI_HURD
;
461 case GNU_ABI_TAG_SOLARIS
:
462 *osabi
= GDB_OSABI_SOLARIS
;
465 case GNU_ABI_TAG_FREEBSD
:
466 *osabi
= GDB_OSABI_FREEBSD_ELF
;
469 case GNU_ABI_TAG_NETBSD
:
470 *osabi
= GDB_OSABI_NETBSD_ELF
;
474 internal_error (__FILE__
, __LINE__
,
475 _("generic_elf_osabi_sniff_abi_tag_sections: "
476 "unknown OS number %d"),
483 if (check_note (abfd
, sect
, note
, §size
, "FreeBSD", 4,
486 /* There is no need to check the version yet. */
487 *osabi
= GDB_OSABI_FREEBSD_ELF
;
494 /* .note.netbsd.ident notes, used by NetBSD. */
495 if (strcmp (name
, ".note.netbsd.ident") == 0
496 && check_note (abfd
, sect
, note
, §size
, "NetBSD", 4, NT_NETBSD_IDENT
))
498 /* There is no need to check the version yet. */
499 *osabi
= GDB_OSABI_NETBSD_ELF
;
503 /* .note.openbsd.ident notes, used by OpenBSD. */
504 if (strcmp (name
, ".note.openbsd.ident") == 0
505 && check_note (abfd
, sect
, note
, §size
, "OpenBSD", 4,
508 /* There is no need to check the version yet. */
509 *osabi
= GDB_OSABI_OPENBSD_ELF
;
513 /* .note.netbsdcore.procinfo notes, used by NetBSD. */
514 if (strcmp (name
, ".note.netbsdcore.procinfo") == 0)
516 *osabi
= GDB_OSABI_NETBSD_ELF
;
521 static enum gdb_osabi
522 generic_elf_osabi_sniffer (bfd
*abfd
)
524 unsigned int elfosabi
;
525 enum gdb_osabi osabi
= GDB_OSABI_UNKNOWN
;
527 elfosabi
= elf_elfheader (abfd
)->e_ident
[EI_OSABI
];
533 /* When the EI_OSABI field in the ELF header is ELFOSABI_NONE
534 (0), then the ELF structures in the file are conforming to
535 the base specification for that machine (there are no
536 OS-specific extensions). In order to determine the real OS
537 in use, we must look for OS-specific notes.
539 The same applies for ELFOSABI_GNU: this can mean GNU/Hurd,
540 GNU/Linux, and possibly more. */
541 bfd_map_over_sections (abfd
,
542 generic_elf_osabi_sniff_abi_tag_sections
,
546 case ELFOSABI_FREEBSD
:
547 osabi
= GDB_OSABI_FREEBSD_ELF
;
550 case ELFOSABI_NETBSD
:
551 osabi
= GDB_OSABI_NETBSD_ELF
;
554 case ELFOSABI_SOLARIS
:
555 osabi
= GDB_OSABI_SOLARIS
;
559 /* For some reason the default value for the EI_OSABI field is
560 ELFOSABI_HPUX for all PA-RISC targets (with the exception of
561 GNU/Linux). We use HP-UX ELF as the default, but let any
562 OS-specific notes override this. */
563 osabi
= GDB_OSABI_HPUX_ELF
;
564 bfd_map_over_sections (abfd
,
565 generic_elf_osabi_sniff_abi_tag_sections
,
569 case ELFOSABI_OPENVMS
:
570 osabi
= GDB_OSABI_OPENVMS
;
574 if (osabi
== GDB_OSABI_UNKNOWN
)
576 /* The FreeBSD folks have been naughty; they stored the string
577 "FreeBSD" in the padding of the e_ident field of the ELF
578 header to "brand" their ELF binaries in FreeBSD 3.x. */
579 if (memcmp (&elf_elfheader (abfd
)->e_ident
[8],
580 "FreeBSD", sizeof ("FreeBSD")) == 0)
581 osabi
= GDB_OSABI_FREEBSD_ELF
;
588 set_osabi (char *args
, int from_tty
, struct cmd_list_element
*c
)
590 struct gdbarch_info info
;
592 if (strcmp (set_osabi_string
, "auto") == 0)
593 user_osabi_state
= osabi_auto
;
594 else if (strcmp (set_osabi_string
, "default") == 0)
596 user_selected_osabi
= GDB_OSABI_DEFAULT
;
597 user_osabi_state
= osabi_user
;
599 else if (strcmp (set_osabi_string
, "none") == 0)
601 user_selected_osabi
= GDB_OSABI_UNKNOWN
;
602 user_osabi_state
= osabi_user
;
608 for (i
= 1; i
< GDB_OSABI_INVALID
; i
++)
609 if (strcmp (set_osabi_string
, gdbarch_osabi_name (i
)) == 0)
611 user_selected_osabi
= i
;
612 user_osabi_state
= osabi_user
;
615 if (i
== GDB_OSABI_INVALID
)
616 internal_error (__FILE__
, __LINE__
,
617 _("Invalid OS ABI \"%s\" passed to command handler."),
621 /* NOTE: At some point (true multiple architectures) we'll need to be more
623 gdbarch_info_init (&info
);
624 if (! gdbarch_update_p (info
))
625 internal_error (__FILE__
, __LINE__
, _("Updating OS ABI failed."));
629 show_osabi (struct ui_file
*file
, int from_tty
, struct cmd_list_element
*c
,
632 if (user_osabi_state
== osabi_auto
)
633 fprintf_filtered (file
,
634 _("The current OS ABI is \"auto\" "
635 "(currently \"%s\").\n"),
636 gdbarch_osabi_name (gdbarch_osabi (get_current_arch ())));
638 fprintf_filtered (file
, _("The current OS ABI is \"%s\".\n"),
639 gdbarch_osabi_name (user_selected_osabi
));
641 if (GDB_OSABI_DEFAULT
!= GDB_OSABI_UNKNOWN
)
642 fprintf_filtered (file
, _("The default OS ABI is \"%s\".\n"),
643 gdbarch_osabi_name (GDB_OSABI_DEFAULT
));
646 extern initialize_file_ftype _initialize_gdb_osabi
; /* -Wmissing-prototype */
649 _initialize_gdb_osabi (void)
651 if (strcmp (gdb_osabi_names
[GDB_OSABI_INVALID
], "<invalid>") != 0)
654 _("_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent"));
656 /* Register a generic sniffer for ELF flavoured files. */
657 gdbarch_register_osabi_sniffer (bfd_arch_unknown
,
658 bfd_target_elf_flavour
,
659 generic_elf_osabi_sniffer
);
661 /* Register the "set osabi" command. */
662 add_setshow_enum_cmd ("osabi", class_support
, gdb_osabi_available_names
,
664 _("Set OS ABI of target."),
665 _("Show OS ABI of target."),
666 NULL
, set_osabi
, show_osabi
,
667 &setlist
, &showlist
);
668 user_osabi_state
= osabi_auto
;