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