1 /* OS ABI variant handling for GDB. 2 3 Copyright (C) 2001-2013 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 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. 11 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. 16 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/>. */ 19 20 #include "defs.h" 21 22 #include "gdb_assert.h" 23 #include "gdb_string.h" 24 25 #include "osabi.h" 26 #include "arch-utils.h" 27 #include "gdbcmd.h" 28 #include "command.h" 29 30 #include "elf-bfd.h" 31 32 #ifndef GDB_OSABI_DEFAULT 33 #define GDB_OSABI_DEFAULT GDB_OSABI_UNKNOWN 34 #endif 35 36 /* State for the "set osabi" command. */ 37 static enum { osabi_auto, osabi_default, osabi_user } user_osabi_state; 38 static enum gdb_osabi user_selected_osabi; 39 static const char *gdb_osabi_available_names[GDB_OSABI_INVALID + 3] = { 40 "auto", 41 "default", 42 "none", 43 NULL 44 }; 45 static const char *set_osabi_string; 46 47 /* This table matches the indices assigned to enum gdb_osabi. Keep 48 them in sync. */ 49 static const char * const gdb_osabi_names[] = 50 { 51 "none", 52 53 "SVR4", 54 "GNU/Hurd", 55 "Solaris", 56 "OSF/1", 57 "GNU/Linux", 58 "FreeBSD a.out", 59 "FreeBSD ELF", 60 "NetBSD a.out", 61 "NetBSD ELF", 62 "OpenBSD ELF", 63 "Windows CE", 64 "DJGPP", 65 "Irix", 66 "Interix", 67 "HP/UX ELF", 68 "HP/UX SOM", 69 "QNX Neutrino", 70 "Cygwin", 71 "AIX", 72 "DICOS", 73 "Darwin", 74 "Symbian", 75 "OpenVMS", 76 "LynxOS178", 77 "Newlib", 78 79 "<invalid>" 80 }; 81 82 const char * 83 gdbarch_osabi_name (enum gdb_osabi osabi) 84 { 85 if (osabi >= GDB_OSABI_UNKNOWN && osabi < GDB_OSABI_INVALID) 86 return gdb_osabi_names[osabi]; 87 88 return gdb_osabi_names[GDB_OSABI_INVALID]; 89 } 90 91 /* Lookup the OS ABI corresponding to the specified target description 92 string. */ 93 94 enum gdb_osabi 95 osabi_from_tdesc_string (const char *name) 96 { 97 int i; 98 99 for (i = 0; i < ARRAY_SIZE (gdb_osabi_names); i++) 100 if (strcmp (name, gdb_osabi_names[i]) == 0) 101 { 102 /* See note above: the name table matches the indices assigned 103 to enum gdb_osabi. */ 104 enum gdb_osabi osabi = (enum gdb_osabi) i; 105 106 if (osabi == GDB_OSABI_INVALID) 107 return GDB_OSABI_UNKNOWN; 108 else 109 return osabi; 110 } 111 112 return GDB_OSABI_UNKNOWN; 113 } 114 115 /* Handler for a given architecture/OS ABI pair. There should be only 116 one handler for a given OS ABI each architecture family. */ 117 struct gdb_osabi_handler 118 { 119 struct gdb_osabi_handler *next; 120 const struct bfd_arch_info *arch_info; 121 enum gdb_osabi osabi; 122 void (*init_osabi)(struct gdbarch_info, struct gdbarch *); 123 }; 124 125 static struct gdb_osabi_handler *gdb_osabi_handler_list; 126 127 void 128 gdbarch_register_osabi (enum bfd_architecture arch, unsigned long machine, 129 enum gdb_osabi osabi, 130 void (*init_osabi)(struct gdbarch_info, 131 struct gdbarch *)) 132 { 133 struct gdb_osabi_handler **handler_p; 134 const struct bfd_arch_info *arch_info = bfd_lookup_arch (arch, machine); 135 const char **name_ptr; 136 137 /* Registering an OS ABI handler for "unknown" is not allowed. */ 138 if (osabi == GDB_OSABI_UNKNOWN) 139 { 140 internal_error 141 (__FILE__, __LINE__, 142 _("gdbarch_register_osabi: An attempt to register a handler for " 143 "OS ABI \"%s\" for architecture %s was made. The handler will " 144 "not be registered"), 145 gdbarch_osabi_name (osabi), 146 bfd_printable_arch_mach (arch, machine)); 147 return; 148 } 149 150 gdb_assert (arch_info); 151 152 for (handler_p = &gdb_osabi_handler_list; *handler_p != NULL; 153 handler_p = &(*handler_p)->next) 154 { 155 if ((*handler_p)->arch_info == arch_info 156 && (*handler_p)->osabi == osabi) 157 { 158 internal_error 159 (__FILE__, __LINE__, 160 _("gdbarch_register_osabi: A handler for OS ABI \"%s\" " 161 "has already been registered for architecture %s"), 162 gdbarch_osabi_name (osabi), 163 arch_info->printable_name); 164 /* If user wants to continue, override previous definition. */ 165 (*handler_p)->init_osabi = init_osabi; 166 return; 167 } 168 } 169 170 (*handler_p) 171 = (struct gdb_osabi_handler *) xmalloc (sizeof (struct gdb_osabi_handler)); 172 (*handler_p)->next = NULL; 173 (*handler_p)->arch_info = arch_info; 174 (*handler_p)->osabi = osabi; 175 (*handler_p)->init_osabi = init_osabi; 176 177 /* Add this OS ABI to the list of enum values for "set osabi", if it isn't 178 already there. */ 179 for (name_ptr = gdb_osabi_available_names; *name_ptr; name_ptr ++) 180 { 181 if (*name_ptr == gdbarch_osabi_name (osabi)) 182 return; 183 } 184 *name_ptr++ = gdbarch_osabi_name (osabi); 185 *name_ptr = NULL; 186 } 187 188 189 /* Sniffer to find the OS ABI for a given file's architecture and flavour. 190 It is legal to have multiple sniffers for each arch/flavour pair, to 191 disambiguate one OS's a.out from another, for example. The first sniffer 192 to return something other than GDB_OSABI_UNKNOWN wins, so a sniffer should 193 be careful to claim a file only if it knows for sure what it is. */ 194 struct gdb_osabi_sniffer 195 { 196 struct gdb_osabi_sniffer *next; 197 enum bfd_architecture arch; /* bfd_arch_unknown == wildcard */ 198 enum bfd_flavour flavour; 199 enum gdb_osabi (*sniffer)(bfd *); 200 }; 201 202 static struct gdb_osabi_sniffer *gdb_osabi_sniffer_list; 203 204 void 205 gdbarch_register_osabi_sniffer (enum bfd_architecture arch, 206 enum bfd_flavour flavour, 207 enum gdb_osabi (*sniffer_fn)(bfd *)) 208 { 209 struct gdb_osabi_sniffer *sniffer; 210 211 sniffer = 212 (struct gdb_osabi_sniffer *) xmalloc (sizeof (struct gdb_osabi_sniffer)); 213 sniffer->arch = arch; 214 sniffer->flavour = flavour; 215 sniffer->sniffer = sniffer_fn; 216 217 sniffer->next = gdb_osabi_sniffer_list; 218 gdb_osabi_sniffer_list = sniffer; 219 } 220 221 222 enum gdb_osabi 223 gdbarch_lookup_osabi (bfd *abfd) 224 { 225 struct gdb_osabi_sniffer *sniffer; 226 enum gdb_osabi osabi, match; 227 int match_specific; 228 229 /* If we aren't in "auto" mode, return the specified OS ABI. */ 230 if (user_osabi_state == osabi_user) 231 return user_selected_osabi; 232 233 /* If we don't have a binary, just return unknown. The caller may 234 have other sources the OSABI can be extracted from, e.g., the 235 target description. */ 236 if (abfd == NULL) 237 return GDB_OSABI_UNKNOWN; 238 239 match = GDB_OSABI_UNKNOWN; 240 match_specific = 0; 241 242 for (sniffer = gdb_osabi_sniffer_list; sniffer != NULL; 243 sniffer = sniffer->next) 244 { 245 if ((sniffer->arch == bfd_arch_unknown /* wildcard */ 246 || sniffer->arch == bfd_get_arch (abfd)) 247 && sniffer->flavour == bfd_get_flavour (abfd)) 248 { 249 osabi = (*sniffer->sniffer) (abfd); 250 if (osabi < GDB_OSABI_UNKNOWN || osabi >= GDB_OSABI_INVALID) 251 { 252 internal_error 253 (__FILE__, __LINE__, 254 _("gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer " 255 "for architecture %s flavour %d"), 256 (int) osabi, 257 bfd_printable_arch_mach (bfd_get_arch (abfd), 0), 258 (int) bfd_get_flavour (abfd)); 259 } 260 else if (osabi != GDB_OSABI_UNKNOWN) 261 { 262 /* A specific sniffer always overrides a generic sniffer. 263 Croak on multiple match if the two matches are of the 264 same class. If the user wishes to continue, we'll use 265 the first match. */ 266 if (match != GDB_OSABI_UNKNOWN) 267 { 268 if ((match_specific && sniffer->arch != bfd_arch_unknown) 269 || (!match_specific && sniffer->arch == bfd_arch_unknown)) 270 { 271 internal_error 272 (__FILE__, __LINE__, 273 _("gdbarch_lookup_osabi: multiple %sspecific OS ABI " 274 "match for architecture %s flavour %d: first " 275 "match \"%s\", second match \"%s\""), 276 match_specific ? "" : "non-", 277 bfd_printable_arch_mach (bfd_get_arch (abfd), 0), 278 (int) bfd_get_flavour (abfd), 279 gdbarch_osabi_name (match), 280 gdbarch_osabi_name (osabi)); 281 } 282 else if (sniffer->arch != bfd_arch_unknown) 283 { 284 match = osabi; 285 match_specific = 1; 286 } 287 } 288 else 289 { 290 match = osabi; 291 if (sniffer->arch != bfd_arch_unknown) 292 match_specific = 1; 293 } 294 } 295 } 296 } 297 298 return match; 299 } 300 301 302 /* Return non-zero if architecture A can run code written for 303 architecture B. */ 304 static int 305 can_run_code_for (const struct bfd_arch_info *a, const struct bfd_arch_info *b) 306 { 307 /* BFD's 'A->compatible (A, B)' functions return zero if A and B are 308 incompatible. But if they are compatible, it returns the 'more 309 featureful' of the two arches. That is, if A can run code 310 written for B, but B can't run code written for A, then it'll 311 return A. 312 313 struct bfd_arch_info objects are singletons: that is, there's 314 supposed to be exactly one instance for a given machine. So you 315 can tell whether two are equivalent by comparing pointers. */ 316 return (a == b || a->compatible (a, b) == a); 317 } 318 319 320 void 321 gdbarch_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch) 322 { 323 struct gdb_osabi_handler *handler; 324 325 if (info.osabi == GDB_OSABI_UNKNOWN) 326 { 327 /* Don't complain about an unknown OSABI. Assume the user knows 328 what they are doing. */ 329 return; 330 } 331 332 for (handler = gdb_osabi_handler_list; handler != NULL; 333 handler = handler->next) 334 { 335 if (handler->osabi != info.osabi) 336 continue; 337 338 /* If the architecture described by ARCH_INFO can run code for 339 the architcture we registered the handler for, then the 340 handler is applicable. Note, though, that if the handler is 341 for an architecture that is a superset of ARCH_INFO, we can't 342 use that --- it would be perfectly correct for it to install 343 gdbarch methods that refer to registers / instructions / 344 other facilities ARCH_INFO doesn't have. 345 346 NOTE: kettenis/20021027: There may be more than one machine 347 type that is compatible with the desired machine type. Right 348 now we simply return the first match, which is fine for now. 349 However, we might want to do something smarter in the future. */ 350 /* NOTE: cagney/2003-10-23: The code for "a can_run_code_for b" 351 is implemented using BFD's compatible method (a->compatible 352 (b) == a -- the lowest common denominator between a and b is 353 a). That method's definition of compatible may not be as you 354 expect. For instance the test "amd64 can run code for i386" 355 (or more generally "64-bit ISA can run code for the 32-bit 356 ISA"). BFD doesn't normally consider 32-bit and 64-bit 357 "compatible" so it doesn't succeed. */ 358 if (can_run_code_for (info.bfd_arch_info, handler->arch_info)) 359 { 360 (*handler->init_osabi) (info, gdbarch); 361 return; 362 } 363 } 364 365 warning 366 ("A handler for the OS ABI \"%s\" is not built into this configuration\n" 367 "of GDB. Attempting to continue with the default %s settings.\n", 368 gdbarch_osabi_name (info.osabi), 369 info.bfd_arch_info->printable_name); 370 } 371 372 /* Limit on the amount of data to be read. */ 373 #define MAX_NOTESZ 128 374 375 /* Return non-zero if NOTE matches NAME, DESCSZ and TYPE. If 376 *SECTSIZE is non-zero, then this reads that many bytes from 377 the start of the section and clears *SECTSIZE. */ 378 379 static int 380 check_note (bfd *abfd, asection *sect, char *note, unsigned int *sectsize, 381 const char *name, unsigned long descsz, unsigned long type) 382 { 383 unsigned long notesz; 384 385 if (*sectsize) 386 { 387 if (!bfd_get_section_contents (abfd, sect, note, 0, *sectsize)) 388 return 0; 389 *sectsize = 0; 390 } 391 392 /* Calculate the size of this note. */ 393 notesz = strlen (name) + 1; 394 notesz = ((notesz + 3) & ~3); 395 notesz += descsz; 396 notesz = ((notesz + 3) & ~3); 397 398 /* If this assertion triggers, increase MAX_NOTESZ. */ 399 gdb_assert (notesz <= MAX_NOTESZ); 400 401 /* Check whether SECT is big enough to comtain the complete note. */ 402 if (notesz > bfd_section_size (abfd, sect)) 403 return 0; 404 405 /* Check the note name. */ 406 if (bfd_h_get_32 (abfd, note) != (strlen (name) + 1) 407 || strcmp (note + 12, name) != 0) 408 return 0; 409 410 /* Check the descriptor size. */ 411 if (bfd_h_get_32 (abfd, note + 4) != descsz) 412 return 0; 413 414 /* Check the note type. */ 415 if (bfd_h_get_32 (abfd, note + 8) != type) 416 return 0; 417 418 return 1; 419 } 420 421 /* Generic sniffer for ELF flavoured files. */ 422 423 void 424 generic_elf_osabi_sniff_abi_tag_sections (bfd *abfd, asection *sect, void *obj) 425 { 426 enum gdb_osabi *osabi = obj; 427 const char *name; 428 unsigned int sectsize; 429 char *note; 430 431 name = bfd_get_section_name (abfd, sect); 432 sectsize = bfd_section_size (abfd, sect); 433 434 /* Limit the amount of data to read. */ 435 if (sectsize > MAX_NOTESZ) 436 sectsize = MAX_NOTESZ; 437 438 /* We lazily read the section data here. Since we use 439 BFD_DECOMPRESS, we can't use bfd_get_section_contents on a 440 compressed section. But, since note sections are not compressed, 441 deferring the reading until we recognize the section avoids any 442 error. */ 443 note = alloca (sectsize); 444 445 /* .note.ABI-tag notes, used by GNU/Linux and FreeBSD. */ 446 if (strcmp (name, ".note.ABI-tag") == 0) 447 { 448 /* GNU. */ 449 if (check_note (abfd, sect, note, §size, "GNU", 16, NT_GNU_ABI_TAG)) 450 { 451 unsigned int abi_tag = bfd_h_get_32 (abfd, note + 16); 452 453 switch (abi_tag) 454 { 455 case GNU_ABI_TAG_LINUX: 456 *osabi = GDB_OSABI_LINUX; 457 break; 458 459 case GNU_ABI_TAG_HURD: 460 *osabi = GDB_OSABI_HURD; 461 break; 462 463 case GNU_ABI_TAG_SOLARIS: 464 *osabi = GDB_OSABI_SOLARIS; 465 break; 466 467 case GNU_ABI_TAG_FREEBSD: 468 *osabi = GDB_OSABI_FREEBSD_ELF; 469 break; 470 471 case GNU_ABI_TAG_NETBSD: 472 *osabi = GDB_OSABI_NETBSD_ELF; 473 break; 474 475 default: 476 internal_error (__FILE__, __LINE__, 477 _("generic_elf_osabi_sniff_abi_tag_sections: " 478 "unknown OS number %d"), 479 abi_tag); 480 } 481 return; 482 } 483 484 /* FreeBSD. */ 485 if (check_note (abfd, sect, note, §size, "FreeBSD", 4, 486 NT_FREEBSD_ABI_TAG)) 487 { 488 /* There is no need to check the version yet. */ 489 *osabi = GDB_OSABI_FREEBSD_ELF; 490 return; 491 } 492 493 return; 494 } 495 496 /* .note.netbsd.ident notes, used by NetBSD. */ 497 if (strcmp (name, ".note.netbsd.ident") == 0 498 && check_note (abfd, sect, note, §size, "NetBSD", 4, NT_NETBSD_IDENT)) 499 { 500 /* There is no need to check the version yet. */ 501 *osabi = GDB_OSABI_NETBSD_ELF; 502 return; 503 } 504 505 /* .note.openbsd.ident notes, used by OpenBSD. */ 506 if (strcmp (name, ".note.openbsd.ident") == 0 507 && check_note (abfd, sect, note, §size, "OpenBSD", 4, 508 NT_OPENBSD_IDENT)) 509 { 510 /* There is no need to check the version yet. */ 511 *osabi = GDB_OSABI_OPENBSD_ELF; 512 return; 513 } 514 515 /* .note.netbsdcore.procinfo notes, used by NetBSD. */ 516 if (strcmp (name, ".note.netbsdcore.procinfo") == 0) 517 { 518 *osabi = GDB_OSABI_NETBSD_ELF; 519 return; 520 } 521 } 522 523 static enum gdb_osabi 524 generic_elf_osabi_sniffer (bfd *abfd) 525 { 526 unsigned int elfosabi; 527 enum gdb_osabi osabi = GDB_OSABI_UNKNOWN; 528 529 elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI]; 530 531 switch (elfosabi) 532 { 533 case ELFOSABI_NONE: 534 case ELFOSABI_GNU: 535 /* When the EI_OSABI field in the ELF header is ELFOSABI_NONE 536 (0), then the ELF structures in the file are conforming to 537 the base specification for that machine (there are no 538 OS-specific extensions). In order to determine the real OS 539 in use, we must look for OS-specific notes. 540 541 The same applies for ELFOSABI_GNU: this can mean GNU/Hurd, 542 GNU/Linux, and possibly more. */ 543 bfd_map_over_sections (abfd, 544 generic_elf_osabi_sniff_abi_tag_sections, 545 &osabi); 546 break; 547 548 case ELFOSABI_FREEBSD: 549 osabi = GDB_OSABI_FREEBSD_ELF; 550 break; 551 552 case ELFOSABI_NETBSD: 553 osabi = GDB_OSABI_NETBSD_ELF; 554 break; 555 556 case ELFOSABI_SOLARIS: 557 osabi = GDB_OSABI_SOLARIS; 558 break; 559 560 case ELFOSABI_HPUX: 561 /* For some reason the default value for the EI_OSABI field is 562 ELFOSABI_HPUX for all PA-RISC targets (with the exception of 563 GNU/Linux). We use HP-UX ELF as the default, but let any 564 OS-specific notes override this. */ 565 osabi = GDB_OSABI_HPUX_ELF; 566 bfd_map_over_sections (abfd, 567 generic_elf_osabi_sniff_abi_tag_sections, 568 &osabi); 569 break; 570 571 case ELFOSABI_OPENVMS: 572 osabi = GDB_OSABI_OPENVMS; 573 break; 574 } 575 576 if (osabi == GDB_OSABI_UNKNOWN) 577 { 578 /* The FreeBSD folks have been naughty; they stored the string 579 "FreeBSD" in the padding of the e_ident field of the ELF 580 header to "brand" their ELF binaries in FreeBSD 3.x. */ 581 if (memcmp (&elf_elfheader (abfd)->e_ident[8], 582 "FreeBSD", sizeof ("FreeBSD")) == 0) 583 osabi = GDB_OSABI_FREEBSD_ELF; 584 } 585 586 return osabi; 587 } 588 589 static void 590 set_osabi (char *args, int from_tty, struct cmd_list_element *c) 591 { 592 struct gdbarch_info info; 593 594 if (strcmp (set_osabi_string, "auto") == 0) 595 user_osabi_state = osabi_auto; 596 else if (strcmp (set_osabi_string, "default") == 0) 597 { 598 user_selected_osabi = GDB_OSABI_DEFAULT; 599 user_osabi_state = osabi_user; 600 } 601 else if (strcmp (set_osabi_string, "none") == 0) 602 { 603 user_selected_osabi = GDB_OSABI_UNKNOWN; 604 user_osabi_state = osabi_user; 605 } 606 else 607 { 608 int i; 609 610 for (i = 1; i < GDB_OSABI_INVALID; i++) 611 if (strcmp (set_osabi_string, gdbarch_osabi_name (i)) == 0) 612 { 613 user_selected_osabi = i; 614 user_osabi_state = osabi_user; 615 break; 616 } 617 if (i == GDB_OSABI_INVALID) 618 internal_error (__FILE__, __LINE__, 619 _("Invalid OS ABI \"%s\" passed to command handler."), 620 set_osabi_string); 621 } 622 623 /* NOTE: At some point (true multiple architectures) we'll need to be more 624 graceful here. */ 625 gdbarch_info_init (&info); 626 if (! gdbarch_update_p (info)) 627 internal_error (__FILE__, __LINE__, _("Updating OS ABI failed.")); 628 } 629 630 static void 631 show_osabi (struct ui_file *file, int from_tty, struct cmd_list_element *c, 632 const char *value) 633 { 634 if (user_osabi_state == osabi_auto) 635 fprintf_filtered (file, 636 _("The current OS ABI is \"auto\" " 637 "(currently \"%s\").\n"), 638 gdbarch_osabi_name (gdbarch_osabi (get_current_arch ()))); 639 else 640 fprintf_filtered (file, _("The current OS ABI is \"%s\".\n"), 641 gdbarch_osabi_name (user_selected_osabi)); 642 643 if (GDB_OSABI_DEFAULT != GDB_OSABI_UNKNOWN) 644 fprintf_filtered (file, _("The default OS ABI is \"%s\".\n"), 645 gdbarch_osabi_name (GDB_OSABI_DEFAULT)); 646 } 647 648 extern initialize_file_ftype _initialize_gdb_osabi; /* -Wmissing-prototype */ 649 650 void 651 _initialize_gdb_osabi (void) 652 { 653 if (strcmp (gdb_osabi_names[GDB_OSABI_INVALID], "<invalid>") != 0) 654 internal_error 655 (__FILE__, __LINE__, 656 _("_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent")); 657 658 /* Register a generic sniffer for ELF flavoured files. */ 659 gdbarch_register_osabi_sniffer (bfd_arch_unknown, 660 bfd_target_elf_flavour, 661 generic_elf_osabi_sniffer); 662 663 /* Register the "set osabi" command. */ 664 add_setshow_enum_cmd ("osabi", class_support, gdb_osabi_available_names, 665 &set_osabi_string, 666 _("Set OS ABI of target."), 667 _("Show OS ABI of target."), 668 NULL, set_osabi, show_osabi, 669 &setlist, &showlist); 670 user_osabi_state = osabi_auto; 671 } 672