gdb/osabi.c

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