gdb/osabi.c

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