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