gdb/osabi.c

   1 /* OS ABI variant handling for GDB.
   2
   3    Copyright (C) 2001-2013 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   "Windows CE",
  64   "DJGPP",
  65   "Irix",
  66   "Interix",
  67   "HP/UX ELF",
  68   "HP/UX SOM",
  69   "QNX Neutrino",
  70   "Cygwin",
  71   "AIX",
  72   "DICOS",
  73   "Darwin",
  74   "Symbian",
  75   "OpenVMS",
  76   "LynxOS178",
  77   "Newlib",
  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.  If
 376    *SECTSIZE is non-zero, then this reads that many bytes from
 377    the start of the section and clears *SECTSIZE.  */
 378
 379 static int
 380 check_note (bfd *abfd, asection *sect, char *note, unsigned int *sectsize,
 381             const char *name, unsigned long descsz, unsigned long type)
 382 {
 383   unsigned long notesz;
 384
 385   if (*sectsize)
 386     {
 387       if (!bfd_get_section_contents (abfd, sect, note, 0, *sectsize))
 388         return 0;
 389       *sectsize = 0;
 390     }
 391
 392   /* Calculate the size of this note.  */
 393   notesz = strlen (name) + 1;
 394   notesz = ((notesz + 3) & ~3);
 395   notesz += descsz;
 396   notesz = ((notesz + 3) & ~3);
 397
 398   /* If this assertion triggers, increase MAX_NOTESZ.  */
 399   gdb_assert (notesz <= MAX_NOTESZ);
 400
 401   /* Check whether SECT is big enough to comtain the complete note.  */
 402   if (notesz > bfd_section_size (abfd, sect))
 403     return 0;
 404
 405   /* Check the note name.  */
 406   if (bfd_h_get_32 (abfd, note) != (strlen (name) + 1)
 407       || strcmp (note + 12, name) != 0)
 408     return 0;
 409
 410   /* Check the descriptor size.  */
 411   if (bfd_h_get_32 (abfd, note + 4) != descsz)
 412     return 0;
 413
 414   /* Check the note type.  */
 415   if (bfd_h_get_32 (abfd, note + 8) != type)
 416     return 0;
 417
 418   return 1;
 419 }
 420
 421 /* Generic sniffer for ELF flavoured files.  */
 422
 423 void
 424 generic_elf_osabi_sniff_abi_tag_sections (bfd *abfd, asection *sect, void *obj)
 425 {
 426   enum gdb_osabi *osabi = obj;
 427   const char *name;
 428   unsigned int sectsize;
 429   char *note;
 430
 431   name = bfd_get_section_name (abfd, sect);
 432   sectsize = bfd_section_size (abfd, sect);
 433
 434   /* Limit the amount of data to read.  */
 435   if (sectsize > MAX_NOTESZ)
 436     sectsize = MAX_NOTESZ;
 437
 438   /* We lazily read the section data here.  Since we use
 439      BFD_DECOMPRESS, we can't use bfd_get_section_contents on a
 440      compressed section.  But, since note sections are not compressed,
 441      deferring the reading until we recognize the section avoids any
 442      error.  */
 443   note = alloca (sectsize);
 444
 445   /* .note.ABI-tag notes, used by GNU/Linux and FreeBSD.  */
 446   if (strcmp (name, ".note.ABI-tag") == 0)
 447     {
 448       /* GNU.  */
 449       if (check_note (abfd, sect, note, &sectsize, "GNU", 16, NT_GNU_ABI_TAG))
 450         {
 451           unsigned int abi_tag = bfd_h_get_32 (abfd, note + 16);
 452
 453           switch (abi_tag)
 454             {
 455             case GNU_ABI_TAG_LINUX:
 456               *osabi = GDB_OSABI_LINUX;
 457               break;
 458
 459             case GNU_ABI_TAG_HURD:
 460               *osabi = GDB_OSABI_HURD;
 461               break;
 462
 463             case GNU_ABI_TAG_SOLARIS:
 464               *osabi = GDB_OSABI_SOLARIS;
 465               break;
 466
 467             case GNU_ABI_TAG_FREEBSD:
 468               *osabi = GDB_OSABI_FREEBSD_ELF;
 469               break;
 470
 471             case GNU_ABI_TAG_NETBSD:
 472               *osabi = GDB_OSABI_NETBSD_ELF;
 473               break;
 474
 475             default:
 476               internal_error (__FILE__, __LINE__,
 477                               _("generic_elf_osabi_sniff_abi_tag_sections: "
 478                                 "unknown OS number %d"),
 479                               abi_tag);
 480             }
 481           return;
 482         }
 483
 484       /* FreeBSD.  */
 485       if (check_note (abfd, sect, note, &sectsize, "FreeBSD", 4,
 486                       NT_FREEBSD_ABI_TAG))
 487         {
 488           /* There is no need to check the version yet.  */
 489           *osabi = GDB_OSABI_FREEBSD_ELF;
 490           return;
 491         }
 492
 493       return;
 494     }
 495
 496   /* .note.netbsd.ident notes, used by NetBSD.  */
 497   if (strcmp (name, ".note.netbsd.ident") == 0
 498       && check_note (abfd, sect, note, &sectsize, "NetBSD", 4, NT_NETBSD_IDENT))
 499     {
 500       /* There is no need to check the version yet.  */
 501       *osabi = GDB_OSABI_NETBSD_ELF;
 502       return;
 503     }
 504
 505   /* .note.openbsd.ident notes, used by OpenBSD.  */
 506   if (strcmp (name, ".note.openbsd.ident") == 0
 507       && check_note (abfd, sect, note, &sectsize, "OpenBSD", 4,
 508                      NT_OPENBSD_IDENT))
 509     {
 510       /* There is no need to check the version yet.  */
 511       *osabi = GDB_OSABI_OPENBSD_ELF;
 512       return;
 513     }
 514
 515   /* .note.netbsdcore.procinfo notes, used by NetBSD.  */
 516   if (strcmp (name, ".note.netbsdcore.procinfo") == 0)
 517     {
 518       *osabi = GDB_OSABI_NETBSD_ELF;
 519       return;
 520     }
 521 }
 522
 523 static enum gdb_osabi
 524 generic_elf_osabi_sniffer (bfd *abfd)
 525 {
 526   unsigned int elfosabi;
 527   enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
 528
 529   elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
 530
 531   switch (elfosabi)
 532     {
 533     case ELFOSABI_NONE:
 534     case ELFOSABI_GNU:
 535       /* When the EI_OSABI field in the ELF header is ELFOSABI_NONE
 536          (0), then the ELF structures in the file are conforming to
 537          the base specification for that machine (there are no
 538          OS-specific extensions).  In order to determine the real OS
 539          in use, we must look for OS-specific notes.
 540
 541          The same applies for ELFOSABI_GNU: this can mean GNU/Hurd,
 542          GNU/Linux, and possibly more.  */
 543       bfd_map_over_sections (abfd,
 544                              generic_elf_osabi_sniff_abi_tag_sections,
 545                              &osabi);
 546       break;
 547
 548     case ELFOSABI_FREEBSD:
 549       osabi = GDB_OSABI_FREEBSD_ELF;
 550       break;
 551
 552     case ELFOSABI_NETBSD:
 553       osabi = GDB_OSABI_NETBSD_ELF;
 554       break;
 555
 556     case ELFOSABI_SOLARIS:
 557       osabi = GDB_OSABI_SOLARIS;
 558       break;
 559
 560     case ELFOSABI_HPUX:
 561       /* For some reason the default value for the EI_OSABI field is
 562          ELFOSABI_HPUX for all PA-RISC targets (with the exception of
 563          GNU/Linux).  We use HP-UX ELF as the default, but let any
 564          OS-specific notes override this.  */
 565       osabi = GDB_OSABI_HPUX_ELF;
 566       bfd_map_over_sections (abfd,
 567                              generic_elf_osabi_sniff_abi_tag_sections,
 568                              &osabi);
 569       break;
 570
 571     case ELFOSABI_OPENVMS:
 572       osabi = GDB_OSABI_OPENVMS;
 573       break;
 574     }
 575
 576   if (osabi == GDB_OSABI_UNKNOWN)
 577     {
 578       /* The FreeBSD folks have been naughty; they stored the string
 579          "FreeBSD" in the padding of the e_ident field of the ELF
 580          header to "brand" their ELF binaries in FreeBSD 3.x.  */
 581       if (memcmp (&elf_elfheader (abfd)->e_ident[8],
 582                   "FreeBSD", sizeof ("FreeBSD")) == 0)
 583         osabi = GDB_OSABI_FREEBSD_ELF;
 584     }
 585
 586   return osabi;
 587 }
 588 \f
 589 static void
 590 set_osabi (char *args, int from_tty, struct cmd_list_element *c)
 591 {
 592   struct gdbarch_info info;
 593
 594   if (strcmp (set_osabi_string, "auto") == 0)
 595     user_osabi_state = osabi_auto;
 596   else if (strcmp (set_osabi_string, "default") == 0)
 597     {
 598       user_selected_osabi = GDB_OSABI_DEFAULT;
 599       user_osabi_state = osabi_user;
 600     }
 601   else if (strcmp (set_osabi_string, "none") == 0)
 602     {
 603       user_selected_osabi = GDB_OSABI_UNKNOWN;
 604       user_osabi_state = osabi_user;
 605     }
 606   else
 607     {
 608       int i;
 609
 610       for (i = 1; i < GDB_OSABI_INVALID; i++)
 611         if (strcmp (set_osabi_string, gdbarch_osabi_name (i)) == 0)
 612           {
 613             user_selected_osabi = i;
 614             user_osabi_state = osabi_user;
 615             break;
 616           }
 617       if (i == GDB_OSABI_INVALID)
 618         internal_error (__FILE__, __LINE__,
 619                         _("Invalid OS ABI \"%s\" passed to command handler."),
 620                         set_osabi_string);
 621     }
 622
 623   /* NOTE: At some point (true multiple architectures) we'll need to be more
 624      graceful here.  */
 625   gdbarch_info_init (&info);
 626   if (! gdbarch_update_p (info))
 627     internal_error (__FILE__, __LINE__, _("Updating OS ABI failed."));
 628 }
 629
 630 static void
 631 show_osabi (struct ui_file *file, int from_tty, struct cmd_list_element *c,
 632             const char *value)
 633 {
 634   if (user_osabi_state == osabi_auto)
 635     fprintf_filtered (file,
 636                       _("The current OS ABI is \"auto\" "
 637                         "(currently \"%s\").\n"),
 638                       gdbarch_osabi_name (gdbarch_osabi (get_current_arch ())));
 639   else
 640     fprintf_filtered (file, _("The current OS ABI is \"%s\".\n"),
 641                       gdbarch_osabi_name (user_selected_osabi));
 642
 643   if (GDB_OSABI_DEFAULT != GDB_OSABI_UNKNOWN)
 644     fprintf_filtered (file, _("The default OS ABI is \"%s\".\n"),
 645                       gdbarch_osabi_name (GDB_OSABI_DEFAULT));
 646 }
 647 \f
 648 extern initialize_file_ftype _initialize_gdb_osabi; /* -Wmissing-prototype */
 649
 650 void
 651 _initialize_gdb_osabi (void)
 652 {
 653   if (strcmp (gdb_osabi_names[GDB_OSABI_INVALID], "<invalid>") != 0)
 654     internal_error
 655       (__FILE__, __LINE__,
 656        _("_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent"));
 657
 658   /* Register a generic sniffer for ELF flavoured files.  */
 659   gdbarch_register_osabi_sniffer (bfd_arch_unknown,
 660                                   bfd_target_elf_flavour,
 661                                   generic_elf_osabi_sniffer);
 662
 663   /* Register the "set osabi" command.  */
 664   add_setshow_enum_cmd ("osabi", class_support, gdb_osabi_available_names,
 665                         &set_osabi_string,
 666                         _("Set OS ABI of target."),
 667                         _("Show OS ABI of target."),
 668                         NULL, set_osabi, show_osabi,
 669                         &setlist, &showlist);
 670   user_osabi_state = osabi_auto;
 671 }