gdb/osabi.c

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