gdb/osabi.c

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