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