gdb/osabi.c

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