gdb/osabi.c

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