gdb/osabi.c

   1 /* OS ABI variant handling for GDB.
   2
   3    Copyright (C) 2001-2024 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
  21 #include "osabi.h"
  22 #include "arch-utils.h"
  23 #include "cli/cli-cmds.h"
  24 #include "command.h"
  25 #include "gdb_bfd.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   { "Windows", NULL },
  76   { "AIX", NULL },
  77   { "DICOS", NULL },
  78   { "Darwin", 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         (_("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             (_("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                 (_("gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer "
 267                  "for architecture %s flavour %d"),
 268                  (int) osabi,
 269                  bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
 270                  (int) bfd_get_flavour (abfd));
 271             }
 272           else if (osabi != GDB_OSABI_UNKNOWN)
 273             {
 274               /* A specific sniffer always overrides a generic sniffer.
 275                  Croak on multiple match if the two matches are of the
 276                  same class.  If the user wishes to continue, we'll use
 277                  the first match.  */
 278               if (match != GDB_OSABI_UNKNOWN)
 279                 {
 280                   if ((match_specific && sniffer->arch != bfd_arch_unknown)
 281                    || (!match_specific && sniffer->arch == bfd_arch_unknown))
 282                     {
 283                       internal_error
 284                         (_("gdbarch_lookup_osabi: multiple %sspecific OS ABI "
 285                          "match for architecture %s flavour %d: first "
 286                          "match \"%s\", second match \"%s\""),
 287                          match_specific ? "" : "non-",
 288                          bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
 289                          (int) bfd_get_flavour (abfd),
 290                          gdbarch_osabi_name (match),
 291                          gdbarch_osabi_name (osabi));
 292                     }
 293                   else if (sniffer->arch != bfd_arch_unknown)
 294                     {
 295                       match = osabi;
 296                       match_specific = 1;
 297                     }
 298                 }
 299               else
 300                 {
 301                   match = osabi;
 302                   if (sniffer->arch != bfd_arch_unknown)
 303                     match_specific = 1;
 304                 }
 305             }
 306         }
 307     }
 308
 309   return match;
 310 }
 311
 312
 313 /* Return non-zero if architecture A can run code written for
 314    architecture B.  */
 315 static int
 316 can_run_code_for (const struct bfd_arch_info *a, const struct bfd_arch_info *b)
 317 {
 318   /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
 319      incompatible.  But if they are compatible, it returns the 'more
 320      featureful' of the two arches.  That is, if A can run code
 321      written for B, but B can't run code written for A, then it'll
 322      return A.
 323
 324      struct bfd_arch_info objects are singletons: that is, there's
 325      supposed to be exactly one instance for a given machine.  So you
 326      can tell whether two are equivalent by comparing pointers.  */
 327   return (a == b || a->compatible (a, b) == a);
 328 }
 329
 330 /* Return OS ABI handler for INFO.  */
 331
 332 static struct gdb_osabi_handler *
 333 gdbarch_osabi_handler (struct gdbarch_info info)
 334 {
 335   struct gdb_osabi_handler *handler;
 336
 337   gdb_assert (info.osabi != GDB_OSABI_UNKNOWN);
 338
 339   for (handler = gdb_osabi_handler_list; handler != NULL;
 340        handler = handler->next)
 341     {
 342       if (handler->osabi != info.osabi)
 343         continue;
 344
 345       /* If the architecture described by ARCH_INFO can run code for
 346          the architecture we registered the handler for, then the
 347          handler is applicable.  Note, though, that if the handler is
 348          for an architecture that is a superset of ARCH_INFO, we can't
 349          use that --- it would be perfectly correct for it to install
 350          gdbarch methods that refer to registers / instructions /
 351          other facilities ARCH_INFO doesn't have.
 352
 353          NOTE: kettenis/20021027: There may be more than one machine
 354          type that is compatible with the desired machine type.  Right
 355          now we simply return the first match, which is fine for now.
 356          However, we might want to do something smarter in the future.  */
 357       /* NOTE: cagney/2003-10-23: The code for "a can_run_code_for b"
 358          is implemented using BFD's compatible method (a->compatible
 359          (b) == a -- the lowest common denominator between a and b is
 360          a).  That method's definition of compatible may not be as you
 361          expect.  For instance the test "amd64 can run code for i386"
 362          (or more generally "64-bit ISA can run code for the 32-bit
 363          ISA").  BFD doesn't normally consider 32-bit and 64-bit
 364          "compatible" so it doesn't succeed.  */
 365       if (can_run_code_for (info.bfd_arch_info, handler->arch_info))
 366         return handler;
 367     }
 368
 369   return nullptr;
 370 }
 371
 372 /* See osabi.h.  */
 373
 374 bool
 375 has_gdb_osabi_handler (struct gdbarch_info info)
 376 {
 377   return gdbarch_osabi_handler (info) != nullptr;
 378 }
 379
 380 void
 381 gdbarch_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
 382 {
 383   struct gdb_osabi_handler *handler;
 384
 385   gdb_assert (info.osabi != GDB_OSABI_UNKNOWN);
 386   handler = gdbarch_osabi_handler (info);
 387
 388   if (handler != nullptr)
 389     {
 390       (*handler->init_osabi) (info, gdbarch);
 391       return;
 392     }
 393
 394   if (info.osabi == GDB_OSABI_NONE)
 395     {
 396       /* Don't complain about no OSABI.  Assume the user knows
 397          what they are doing.  */
 398       return;
 399     }
 400
 401   warning
 402     ("A handler for the OS ABI \"%s\" is not built into this configuration\n"
 403      "of GDB.  Attempting to continue with the default %s settings.\n",
 404      gdbarch_osabi_name (info.osabi),
 405      info.bfd_arch_info->printable_name);
 406 }
 407 \f
 408 /* Limit on the amount of data to be read.  */
 409 #define MAX_NOTESZ      128
 410
 411 /* Return non-zero if NOTE matches NAME, DESCSZ and TYPE.  If
 412    *SECTSIZE is non-zero, then this reads that many bytes from
 413    the start of the section and clears *SECTSIZE.  */
 414
 415 static int
 416 check_note (bfd *abfd, asection *sect, char *note, unsigned int *sectsize,
 417             const char *name, unsigned long descsz, unsigned long type)
 418 {
 419   unsigned long notesz;
 420
 421   if (*sectsize)
 422     {
 423       if (!bfd_get_section_contents (abfd, sect, note, 0, *sectsize))
 424         return 0;
 425       *sectsize = 0;
 426     }
 427
 428   /* Calculate the size of this note.  */
 429   notesz = strlen (name) + 1;
 430   notesz = ((notesz + 3) & ~3);
 431   notesz += descsz;
 432   notesz = ((notesz + 3) & ~3);
 433
 434   /* If this assertion triggers, increase MAX_NOTESZ.  */
 435   gdb_assert (notesz <= MAX_NOTESZ);
 436
 437   /* Check whether SECT is big enough to contain the complete note.  */
 438   if (notesz > bfd_section_size (sect))
 439     return 0;
 440
 441   /* Check the note name.  */
 442   if (bfd_h_get_32 (abfd, note) != (strlen (name) + 1)
 443       || strcmp (note + 12, name) != 0)
 444     return 0;
 445
 446   /* Check the descriptor size.  */
 447   if (bfd_h_get_32 (abfd, note + 4) != descsz)
 448     return 0;
 449
 450   /* Check the note type.  */
 451   if (bfd_h_get_32 (abfd, note + 8) != type)
 452     return 0;
 453
 454   return 1;
 455 }
 456
 457 /* Generic sniffer for ELF flavoured files.  */
 458
 459 void
 460 generic_elf_osabi_sniff_abi_tag_sections (bfd *abfd, asection *sect,
 461                                           enum gdb_osabi *osabi)
 462 {
 463   const char *name;
 464   unsigned int sectsize;
 465
 466   name = bfd_section_name (sect);
 467   sectsize = bfd_section_size (sect);
 468
 469   /* Limit the amount of data to read.  */
 470   if (sectsize > MAX_NOTESZ)
 471     sectsize = MAX_NOTESZ;
 472
 473   /* We lazily read the section data here.  Since we use
 474      BFD_DECOMPRESS, we can't use bfd_get_section_contents on a
 475      compressed section.  But, since note sections are not compressed,
 476      deferring the reading until we recognize the section avoids any
 477      error.  */
 478   char note[MAX_NOTESZ];
 479
 480   /* .note.ABI-tag notes, used by GNU/Linux and FreeBSD.  */
 481   if (strcmp (name, ".note.ABI-tag") == 0)
 482     {
 483       /* GNU.  */
 484       if (check_note (abfd, sect, note, &sectsize, "GNU", 16, NT_GNU_ABI_TAG))
 485         {
 486           unsigned int abi_tag = bfd_h_get_32 (abfd, note + 16);
 487
 488           switch (abi_tag)
 489             {
 490             case GNU_ABI_TAG_LINUX:
 491               *osabi = GDB_OSABI_LINUX;
 492               break;
 493
 494             case GNU_ABI_TAG_HURD:
 495               *osabi = GDB_OSABI_HURD;
 496               break;
 497
 498             case GNU_ABI_TAG_SOLARIS:
 499               *osabi = GDB_OSABI_SOLARIS;
 500               break;
 501
 502             case GNU_ABI_TAG_FREEBSD:
 503               *osabi = GDB_OSABI_FREEBSD;
 504               break;
 505
 506             case GNU_ABI_TAG_NETBSD:
 507               *osabi = GDB_OSABI_NETBSD;
 508               break;
 509
 510             default:
 511               warning (_("GNU ABI tag value %u unrecognized."), abi_tag);
 512               break;
 513             }
 514           return;
 515         }
 516
 517       /* FreeBSD.  */
 518       if (check_note (abfd, sect, note, &sectsize, "FreeBSD", 4,
 519                       NT_FREEBSD_ABI_TAG))
 520         {
 521           /* There is no need to check the version yet.  */
 522           *osabi = GDB_OSABI_FREEBSD;
 523           return;
 524         }
 525
 526       return;
 527     }
 528
 529   /* .note.netbsd.ident notes, used by NetBSD.  */
 530   if (strcmp (name, ".note.netbsd.ident") == 0
 531       && check_note (abfd, sect, note, &sectsize, "NetBSD", 4, NT_NETBSD_IDENT))
 532     {
 533       /* There is no need to check the version yet.  */
 534       *osabi = GDB_OSABI_NETBSD;
 535       return;
 536     }
 537
 538   /* .note.openbsd.ident notes, used by OpenBSD.  */
 539   if (strcmp (name, ".note.openbsd.ident") == 0
 540       && check_note (abfd, sect, note, &sectsize, "OpenBSD", 4,
 541                      NT_OPENBSD_IDENT))
 542     {
 543       /* There is no need to check the version yet.  */
 544       *osabi = GDB_OSABI_OPENBSD;
 545       return;
 546     }
 547
 548   /* .note.netbsdcore.procinfo notes, used by NetBSD.  */
 549   if (strcmp (name, ".note.netbsdcore.procinfo") == 0)
 550     {
 551       *osabi = GDB_OSABI_NETBSD;
 552       return;
 553     }
 554 }
 555
 556 static enum gdb_osabi
 557 generic_elf_osabi_sniffer (bfd *abfd)
 558 {
 559   unsigned int elfosabi;
 560   enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
 561
 562   elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
 563
 564   switch (elfosabi)
 565     {
 566     case ELFOSABI_NONE:
 567     case ELFOSABI_GNU:
 568     case ELFOSABI_HPUX:
 569       /* When the EI_OSABI field in the ELF header is ELFOSABI_NONE
 570          (0), then the ELF structures in the file are conforming to
 571          the base specification for that machine (there are no
 572          OS-specific extensions).  In order to determine the real OS
 573          in use, we must look for OS-specific notes.
 574
 575          The same applies for ELFOSABI_GNU: this can mean GNU/Hurd,
 576          GNU/Linux, and possibly more.  */
 577
 578       /* And likewise ELFOSABI_HPUX.  For some reason the default
 579          value for the EI_OSABI field is ELFOSABI_HPUX for all PA-RISC
 580          targets (with the exception of GNU/Linux).  */
 581       for (asection *sect : gdb_bfd_sections (abfd))
 582         generic_elf_osabi_sniff_abi_tag_sections (abfd, sect, &osabi);
 583       break;
 584
 585     case ELFOSABI_FREEBSD:
 586       osabi = GDB_OSABI_FREEBSD;
 587       break;
 588
 589     case ELFOSABI_NETBSD:
 590       osabi = GDB_OSABI_NETBSD;
 591       break;
 592
 593     case ELFOSABI_SOLARIS:
 594       osabi = GDB_OSABI_SOLARIS;
 595       break;
 596
 597     case ELFOSABI_OPENVMS:
 598       osabi = GDB_OSABI_OPENVMS;
 599       break;
 600     }
 601
 602   if (osabi == GDB_OSABI_UNKNOWN)
 603     {
 604       /* The FreeBSD folks have been naughty; they stored the string
 605          "FreeBSD" in the padding of the e_ident field of the ELF
 606          header to "brand" their ELF binaries in FreeBSD 3.x.  */
 607       if (memcmp (&elf_elfheader (abfd)->e_ident[8],
 608                   "FreeBSD", sizeof ("FreeBSD")) == 0)
 609         osabi = GDB_OSABI_FREEBSD;
 610     }
 611
 612   return osabi;
 613 }
 614 \f
 615 static void
 616 set_osabi (const char *args, int from_tty, struct cmd_list_element *c)
 617 {
 618   if (strcmp (set_osabi_string, "auto") == 0)
 619     user_osabi_state = osabi_auto;
 620   else if (strcmp (set_osabi_string, "default") == 0)
 621     {
 622       user_selected_osabi = GDB_OSABI_DEFAULT;
 623       user_osabi_state = osabi_user;
 624     }
 625   else
 626     {
 627       int i;
 628
 629       for (i = 1; i < GDB_OSABI_INVALID; i++)
 630         {
 631           enum gdb_osabi osabi = (enum gdb_osabi) i;
 632
 633           if (strcmp (set_osabi_string, gdbarch_osabi_name (osabi)) == 0)
 634             {
 635               user_selected_osabi = osabi;
 636               user_osabi_state = osabi_user;
 637               break;
 638             }
 639         }
 640       if (i == GDB_OSABI_INVALID)
 641         internal_error (_("Invalid OS ABI \"%s\" passed to command handler."),
 642                         set_osabi_string);
 643     }
 644
 645   /* NOTE: At some point (true multiple architectures) we'll need to be more
 646      graceful here.  */
 647   gdbarch_info info;
 648   if (! gdbarch_update_p (info))
 649     internal_error (_("Updating OS ABI failed."));
 650 }
 651
 652 static void
 653 show_osabi (struct ui_file *file, int from_tty, struct cmd_list_element *c,
 654             const char *value)
 655 {
 656   if (user_osabi_state == osabi_auto)
 657     gdb_printf (file,
 658                 _("The current OS ABI is \"auto\" "
 659                   "(currently \"%s\").\n"),
 660                 gdbarch_osabi_name (gdbarch_osabi (get_current_arch ())));
 661   else
 662     gdb_printf (file, _("The current OS ABI is \"%s\".\n"),
 663                 gdbarch_osabi_name (user_selected_osabi));
 664
 665   if (GDB_OSABI_DEFAULT != GDB_OSABI_UNKNOWN)
 666     gdb_printf (file, _("The default OS ABI is \"%s\".\n"),
 667                 gdbarch_osabi_name (GDB_OSABI_DEFAULT));
 668 }
 669
 670 void _initialize_gdb_osabi ();
 671 void
 672 _initialize_gdb_osabi ()
 673 {
 674   if (strcmp (gdb_osabi_names[GDB_OSABI_INVALID].pretty, "<invalid>") != 0)
 675     internal_error
 676       (_("_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent"));
 677
 678   /* Register a generic sniffer for ELF flavoured files.  */
 679   gdbarch_register_osabi_sniffer (bfd_arch_unknown,
 680                                   bfd_target_elf_flavour,
 681                                   generic_elf_osabi_sniffer);
 682
 683   /* Register the "set osabi" command.  */
 684   user_osabi_state = osabi_auto;
 685   set_osabi_string = gdb_osabi_available_names[0];
 686   gdb_assert (strcmp (set_osabi_string, "auto") == 0);
 687   add_setshow_enum_cmd ("osabi", class_support, gdb_osabi_available_names,
 688                         &set_osabi_string,
 689                         _("Set OS ABI of target."),
 690                         _("Show OS ABI of target."),
 691                         NULL, set_osabi, show_osabi,
 692                         &setlist, &showlist);
 693 }