gdb/osabi.c

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