contrib/gdb-6/gdb/osabi.c

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