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