contrib/gdb-7/gdb/osabi.c

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