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