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