contrib/gdb-7/gdb/osabi.c

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