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