1 /* OS ABI variant handling for GDB. 2 3 Copyright (C) 2001-2004, 2007-2012 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 77 "<invalid>" 78 }; 79 80 const char * 81 gdbarch_osabi_name (enum gdb_osabi osabi) 82 { 83 if (osabi >= GDB_OSABI_UNKNOWN && osabi < GDB_OSABI_INVALID) 84 return gdb_osabi_names[osabi]; 85 86 return gdb_osabi_names[GDB_OSABI_INVALID]; 87 } 88 89 /* Lookup the OS ABI corresponding to the specified target description 90 string. */ 91 92 enum gdb_osabi 93 osabi_from_tdesc_string (const char *name) 94 { 95 int i; 96 97 for (i = 0; i < ARRAY_SIZE (gdb_osabi_names); i++) 98 if (strcmp (name, gdb_osabi_names[i]) == 0) 99 { 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; 103 104 if (osabi == GDB_OSABI_INVALID) 105 return GDB_OSABI_UNKNOWN; 106 else 107 return osabi; 108 } 109 110 return GDB_OSABI_UNKNOWN; 111 } 112 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 116 { 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 *); 121 }; 122 123 static struct gdb_osabi_handler *gdb_osabi_handler_list; 124 125 void 126 gdbarch_register_osabi (enum bfd_architecture arch, unsigned long machine, 127 enum gdb_osabi osabi, 128 void (*init_osabi)(struct gdbarch_info, 129 struct gdbarch *)) 130 { 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; 134 135 /* Registering an OS ABI handler for "unknown" is not allowed. */ 136 if (osabi == GDB_OSABI_UNKNOWN) 137 { 138 internal_error 139 (__FILE__, __LINE__, 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)); 145 return; 146 } 147 148 gdb_assert (arch_info); 149 150 for (handler_p = &gdb_osabi_handler_list; *handler_p != NULL; 151 handler_p = &(*handler_p)->next) 152 { 153 if ((*handler_p)->arch_info == arch_info 154 && (*handler_p)->osabi == osabi) 155 { 156 internal_error 157 (__FILE__, __LINE__, 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; 164 return; 165 } 166 } 167 168 (*handler_p) 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; 174 175 /* Add this OS ABI to the list of enum values for "set osabi", if it isn't 176 already there. */ 177 for (name_ptr = gdb_osabi_available_names; *name_ptr; name_ptr ++) 178 { 179 if (*name_ptr == gdbarch_osabi_name (osabi)) 180 return; 181 } 182 *name_ptr++ = gdbarch_osabi_name (osabi); 183 *name_ptr = NULL; 184 } 185 186 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 193 { 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 *); 198 }; 199 200 static struct gdb_osabi_sniffer *gdb_osabi_sniffer_list; 201 202 void 203 gdbarch_register_osabi_sniffer (enum bfd_architecture arch, 204 enum bfd_flavour flavour, 205 enum gdb_osabi (*sniffer_fn)(bfd *)) 206 { 207 struct gdb_osabi_sniffer *sniffer; 208 209 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; 214 215 sniffer->next = gdb_osabi_sniffer_list; 216 gdb_osabi_sniffer_list = sniffer; 217 } 218 219 220 enum gdb_osabi 221 gdbarch_lookup_osabi (bfd *abfd) 222 { 223 struct gdb_osabi_sniffer *sniffer; 224 enum gdb_osabi osabi, match; 225 int match_specific; 226 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; 230 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. */ 234 if (abfd == NULL) 235 return GDB_OSABI_UNKNOWN; 236 237 match = GDB_OSABI_UNKNOWN; 238 match_specific = 0; 239 240 for (sniffer = gdb_osabi_sniffer_list; sniffer != NULL; 241 sniffer = sniffer->next) 242 { 243 if ((sniffer->arch == bfd_arch_unknown /* wildcard */ 244 || sniffer->arch == bfd_get_arch (abfd)) 245 && sniffer->flavour == bfd_get_flavour (abfd)) 246 { 247 osabi = (*sniffer->sniffer) (abfd); 248 if (osabi < GDB_OSABI_UNKNOWN || osabi >= GDB_OSABI_INVALID) 249 { 250 internal_error 251 (__FILE__, __LINE__, 252 _("gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer " 253 "for architecture %s flavour %d"), 254 (int) osabi, 255 bfd_printable_arch_mach (bfd_get_arch (abfd), 0), 256 (int) bfd_get_flavour (abfd)); 257 } 258 else if (osabi != GDB_OSABI_UNKNOWN) 259 { 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 263 the first match. */ 264 if (match != GDB_OSABI_UNKNOWN) 265 { 266 if ((match_specific && sniffer->arch != bfd_arch_unknown) 267 || (!match_specific && sniffer->arch == bfd_arch_unknown)) 268 { 269 internal_error 270 (__FILE__, __LINE__, 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)); 279 } 280 else if (sniffer->arch != bfd_arch_unknown) 281 { 282 match = osabi; 283 match_specific = 1; 284 } 285 } 286 else 287 { 288 match = osabi; 289 if (sniffer->arch != bfd_arch_unknown) 290 match_specific = 1; 291 } 292 } 293 } 294 } 295 296 return match; 297 } 298 299 300 /* Return non-zero if architecture A can run code written for 301 architecture B. */ 302 static int 303 can_run_code_for (const struct bfd_arch_info *a, const struct bfd_arch_info *b) 304 { 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 309 return A. 310 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); 315 } 316 317 318 void 319 gdbarch_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch) 320 { 321 struct gdb_osabi_handler *handler; 322 323 if (info.osabi == GDB_OSABI_UNKNOWN) 324 { 325 /* Don't complain about an unknown OSABI. Assume the user knows 326 what they are doing. */ 327 return; 328 } 329 330 for (handler = gdb_osabi_handler_list; handler != NULL; 331 handler = handler->next) 332 { 333 if (handler->osabi != info.osabi) 334 continue; 335 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. 343 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)) 357 { 358 (*handler->init_osabi) (info, gdbarch); 359 return; 360 } 361 } 362 363 warning 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); 368 } 369 370 /* Limit on the amount of data to be read. */ 371 #define MAX_NOTESZ 128 372 373 /* Return non-zero if NOTE matches NAME, DESCSZ and TYPE. */ 374 375 static int 376 check_note (bfd *abfd, asection *sect, const char *note, 377 const char *name, unsigned long descsz, unsigned long type) 378 { 379 unsigned long notesz; 380 381 /* Calculate the size of this note. */ 382 notesz = strlen (name) + 1; 383 notesz = ((notesz + 3) & ~3); 384 notesz += descsz; 385 notesz = ((notesz + 3) & ~3); 386 387 /* If this assertion triggers, increase MAX_NOTESZ. */ 388 gdb_assert (notesz <= MAX_NOTESZ); 389 390 /* Check whether SECT is big enough to comtain the complete note. */ 391 if (notesz > bfd_section_size (abfd, sect)) 392 return 0; 393 394 /* Check the note name. */ 395 if (bfd_h_get_32 (abfd, note) != (strlen (name) + 1) 396 || strcmp (note + 12, name) != 0) 397 return 0; 398 399 /* Check the descriptor size. */ 400 if (bfd_h_get_32 (abfd, note + 4) != descsz) 401 return 0; 402 403 /* Check the note type. */ 404 if (bfd_h_get_32 (abfd, note + 8) != type) 405 return 0; 406 407 return 1; 408 } 409 410 /* Generic sniffer for ELF flavoured files. */ 411 412 void 413 generic_elf_osabi_sniff_abi_tag_sections (bfd *abfd, asection *sect, void *obj) 414 { 415 enum gdb_osabi *osabi = obj; 416 const char *name; 417 unsigned int sectsize; 418 char *note; 419 420 name = bfd_get_section_name (abfd, sect); 421 sectsize = bfd_section_size (abfd, sect); 422 423 /* Limit the amount of data to read. */ 424 if (sectsize > MAX_NOTESZ) 425 sectsize = MAX_NOTESZ; 426 427 note = alloca (sectsize); 428 bfd_get_section_contents (abfd, sect, note, 0, sectsize); 429 430 /* .note.ABI-tag notes, used by GNU/Linux and FreeBSD. */ 431 if (strcmp (name, ".note.ABI-tag") == 0) 432 { 433 /* GNU. */ 434 if (check_note (abfd, sect, note, "GNU", 16, NT_GNU_ABI_TAG)) 435 { 436 unsigned int abi_tag = bfd_h_get_32 (abfd, note + 16); 437 438 switch (abi_tag) 439 { 440 case GNU_ABI_TAG_LINUX: 441 *osabi = GDB_OSABI_LINUX; 442 break; 443 444 case GNU_ABI_TAG_HURD: 445 *osabi = GDB_OSABI_HURD; 446 break; 447 448 case GNU_ABI_TAG_SOLARIS: 449 *osabi = GDB_OSABI_SOLARIS; 450 break; 451 452 case GNU_ABI_TAG_FREEBSD: 453 *osabi = GDB_OSABI_FREEBSD_ELF; 454 break; 455 456 case GNU_ABI_TAG_NETBSD: 457 *osabi = GDB_OSABI_NETBSD_ELF; 458 break; 459 460 default: 461 internal_error (__FILE__, __LINE__, 462 _("generic_elf_osabi_sniff_abi_tag_sections: " 463 "unknown OS number %d"), 464 abi_tag); 465 } 466 return; 467 } 468 469 /* FreeBSD. */ 470 if (check_note (abfd, sect, note, "FreeBSD", 4, NT_FREEBSD_ABI_TAG)) 471 { 472 /* There is no need to check the version yet. */ 473 *osabi = GDB_OSABI_FREEBSD_ELF; 474 return; 475 } 476 477 /* DragonFly. */ 478 if (check_note (abfd, sect, note, "DragonFly", 4, NT_DRAGONFLY_ABI_TAG)) 479 { 480 /* There is no need to check the version yet. */ 481 *osabi = GDB_OSABI_DRAGONFLY; 482 return; 483 } 484 485 return; 486 } 487 488 /* .note.netbsd.ident notes, used by NetBSD. */ 489 if (strcmp (name, ".note.netbsd.ident") == 0 490 && check_note (abfd, sect, note, "NetBSD", 4, NT_NETBSD_IDENT)) 491 { 492 /* There is no need to check the version yet. */ 493 *osabi = GDB_OSABI_NETBSD_ELF; 494 return; 495 } 496 497 /* .note.openbsd.ident notes, used by OpenBSD. */ 498 if (strcmp (name, ".note.openbsd.ident") == 0 499 && check_note (abfd, sect, note, "OpenBSD", 4, NT_OPENBSD_IDENT)) 500 { 501 /* There is no need to check the version yet. */ 502 *osabi = GDB_OSABI_OPENBSD_ELF; 503 return; 504 } 505 506 /* .note.netbsdcore.procinfo notes, used by NetBSD. */ 507 if (strcmp (name, ".note.netbsdcore.procinfo") == 0) 508 { 509 *osabi = GDB_OSABI_NETBSD_ELF; 510 return; 511 } 512 } 513 514 static enum gdb_osabi 515 generic_elf_osabi_sniffer (bfd *abfd) 516 { 517 unsigned int elfosabi; 518 enum gdb_osabi osabi = GDB_OSABI_UNKNOWN; 519 520 elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI]; 521 522 switch (elfosabi) 523 { 524 case ELFOSABI_NONE: 525 case ELFOSABI_GNU: 526 /* When the EI_OSABI field in the ELF header is ELFOSABI_NONE 527 (0), then the ELF structures in the file are conforming to 528 the base specification for that machine (there are no 529 OS-specific extensions). In order to determine the real OS 530 in use, we must look for OS-specific notes. 531 532 The same applies for ELFOSABI_GNU: this can mean GNU/Hurd, 533 GNU/Linux, and possibly more. */ 534 bfd_map_over_sections (abfd, 535 generic_elf_osabi_sniff_abi_tag_sections, 536 &osabi); 537 break; 538 539 case ELFOSABI_FREEBSD: 540 osabi = GDB_OSABI_FREEBSD_ELF; 541 break; 542 543 case ELFOSABI_NETBSD: 544 osabi = GDB_OSABI_NETBSD_ELF; 545 break; 546 547 case ELFOSABI_SOLARIS: 548 osabi = GDB_OSABI_SOLARIS; 549 break; 550 551 case ELFOSABI_HPUX: 552 /* For some reason the default value for the EI_OSABI field is 553 ELFOSABI_HPUX for all PA-RISC targets (with the exception of 554 GNU/Linux). We use HP-UX ELF as the default, but let any 555 OS-specific notes override this. */ 556 osabi = GDB_OSABI_HPUX_ELF; 557 bfd_map_over_sections (abfd, 558 generic_elf_osabi_sniff_abi_tag_sections, 559 &osabi); 560 break; 561 } 562 563 if (osabi == GDB_OSABI_UNKNOWN) 564 { 565 /* The FreeBSD folks have been naughty; they stored the string 566 "FreeBSD" in the padding of the e_ident field of the ELF 567 header to "brand" their ELF binaries in FreeBSD 3.x. */ 568 if (memcmp (&elf_elfheader (abfd)->e_ident[8], 569 "FreeBSD", sizeof ("FreeBSD")) == 0) 570 osabi = GDB_OSABI_FREEBSD_ELF; 571 } 572 573 return osabi; 574 } 575 576 static void 577 set_osabi (char *args, int from_tty, struct cmd_list_element *c) 578 { 579 struct gdbarch_info info; 580 581 if (strcmp (set_osabi_string, "auto") == 0) 582 user_osabi_state = osabi_auto; 583 else if (strcmp (set_osabi_string, "default") == 0) 584 { 585 user_selected_osabi = GDB_OSABI_DEFAULT; 586 user_osabi_state = osabi_user; 587 } 588 else if (strcmp (set_osabi_string, "none") == 0) 589 { 590 user_selected_osabi = GDB_OSABI_UNKNOWN; 591 user_osabi_state = osabi_user; 592 } 593 else 594 { 595 int i; 596 597 for (i = 1; i < GDB_OSABI_INVALID; i++) 598 if (strcmp (set_osabi_string, gdbarch_osabi_name (i)) == 0) 599 { 600 user_selected_osabi = i; 601 user_osabi_state = osabi_user; 602 break; 603 } 604 if (i == GDB_OSABI_INVALID) 605 internal_error (__FILE__, __LINE__, 606 _("Invalid OS ABI \"%s\" passed to command handler."), 607 set_osabi_string); 608 } 609 610 /* NOTE: At some point (true multiple architectures) we'll need to be more 611 graceful here. */ 612 gdbarch_info_init (&info); 613 if (! gdbarch_update_p (info)) 614 internal_error (__FILE__, __LINE__, _("Updating OS ABI failed.")); 615 } 616 617 static void 618 show_osabi (struct ui_file *file, int from_tty, struct cmd_list_element *c, 619 const char *value) 620 { 621 if (user_osabi_state == osabi_auto) 622 fprintf_filtered (file, 623 _("The current OS ABI is \"auto\" " 624 "(currently \"%s\").\n"), 625 gdbarch_osabi_name (gdbarch_osabi (get_current_arch ()))); 626 else 627 fprintf_filtered (file, _("The current OS ABI is \"%s\".\n"), 628 gdbarch_osabi_name (user_selected_osabi)); 629 630 if (GDB_OSABI_DEFAULT != GDB_OSABI_UNKNOWN) 631 fprintf_filtered (file, _("The default OS ABI is \"%s\".\n"), 632 gdbarch_osabi_name (GDB_OSABI_DEFAULT)); 633 } 634 635 extern initialize_file_ftype _initialize_gdb_osabi; /* -Wmissing-prototype */ 636 637 void 638 _initialize_gdb_osabi (void) 639 { 640 if (strcmp (gdb_osabi_names[GDB_OSABI_INVALID], "<invalid>") != 0) 641 internal_error 642 (__FILE__, __LINE__, 643 _("_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent")); 644 645 /* Register a generic sniffer for ELF flavoured files. */ 646 gdbarch_register_osabi_sniffer (bfd_arch_unknown, 647 bfd_target_elf_flavour, 648 generic_elf_osabi_sniffer); 649 650 /* Register the "set osabi" command. */ 651 add_setshow_enum_cmd ("osabi", class_support, gdb_osabi_available_names, 652 &set_osabi_string, 653 _("Set OS ABI of target."), 654 _("Show OS ABI of target."), 655 NULL, set_osabi, show_osabi, 656 &setlist, &showlist); 657 user_osabi_state = osabi_auto; 658 } 659