gdb/osabi.c

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