gdb/osabi.c

   1 /* OS ABI variant handling for GDB.
   2
   3    Copyright (C) 2001-2014 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   { "Windows CE", 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
  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)
 190     = (struct gdb_osabi_handler *) xmalloc (sizeof (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 =
 231     (struct gdb_osabi_sniffer *) xmalloc (sizeof (struct gdb_osabi_sniffer));
 232   sniffer->arch = arch;
 233   sniffer->flavour = flavour;
 234   sniffer->sniffer = sniffer_fn;
 235
 236   sniffer->next = gdb_osabi_sniffer_list;
 237   gdb_osabi_sniffer_list = sniffer;
 238 }
 239 \f
 240
 241 enum gdb_osabi
 242 gdbarch_lookup_osabi (bfd *abfd)
 243 {
 244   struct gdb_osabi_sniffer *sniffer;
 245   enum gdb_osabi osabi, match;
 246   int match_specific;
 247
 248   /* If we aren't in "auto" mode, return the specified OS ABI.  */
 249   if (user_osabi_state == osabi_user)
 250     return user_selected_osabi;
 251
 252   /* If we don't have a binary, just return unknown.  The caller may
 253      have other sources the OSABI can be extracted from, e.g., the
 254      target description.  */
 255   if (abfd == NULL)
 256     return GDB_OSABI_UNKNOWN;
 257
 258   match = GDB_OSABI_UNKNOWN;
 259   match_specific = 0;
 260
 261   for (sniffer = gdb_osabi_sniffer_list; sniffer != NULL;
 262        sniffer = sniffer->next)
 263     {
 264       if ((sniffer->arch == bfd_arch_unknown /* wildcard */
 265            || sniffer->arch == bfd_get_arch (abfd))
 266           && sniffer->flavour == bfd_get_flavour (abfd))
 267         {
 268           osabi = (*sniffer->sniffer) (abfd);
 269           if (osabi < GDB_OSABI_UNKNOWN || osabi >= GDB_OSABI_INVALID)
 270             {
 271               internal_error
 272                 (__FILE__, __LINE__,
 273                  _("gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer "
 274                  "for architecture %s flavour %d"),
 275                  (int) osabi,
 276                  bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
 277                  (int) bfd_get_flavour (abfd));
 278             }
 279           else if (osabi != GDB_OSABI_UNKNOWN)
 280             {
 281               /* A specific sniffer always overrides a generic sniffer.
 282                  Croak on multiple match if the two matches are of the
 283                  same class.  If the user wishes to continue, we'll use
 284                  the first match.  */
 285               if (match != GDB_OSABI_UNKNOWN)
 286                 {
 287                   if ((match_specific && sniffer->arch != bfd_arch_unknown)
 288                    || (!match_specific && sniffer->arch == bfd_arch_unknown))
 289                     {
 290                       internal_error
 291                         (__FILE__, __LINE__,
 292                          _("gdbarch_lookup_osabi: multiple %sspecific OS ABI "
 293                          "match for architecture %s flavour %d: first "
 294                          "match \"%s\", second match \"%s\""),
 295                          match_specific ? "" : "non-",
 296                          bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
 297                          (int) bfd_get_flavour (abfd),
 298                          gdbarch_osabi_name (match),
 299                          gdbarch_osabi_name (osabi));
 300                     }
 301                   else if (sniffer->arch != bfd_arch_unknown)
 302                     {
 303                       match = osabi;
 304                       match_specific = 1;
 305                     }
 306                 }
 307               else
 308                 {
 309                   match = osabi;
 310                   if (sniffer->arch != bfd_arch_unknown)
 311                     match_specific = 1;
 312                 }
 313             }
 314         }
 315     }
 316
 317   return match;
 318 }
 319
 320
 321 /* Return non-zero if architecture A can run code written for
 322    architecture B.  */
 323 static int
 324 can_run_code_for (const struct bfd_arch_info *a, const struct bfd_arch_info *b)
 325 {
 326   /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
 327      incompatible.  But if they are compatible, it returns the 'more
 328      featureful' of the two arches.  That is, if A can run code
 329      written for B, but B can't run code written for A, then it'll
 330      return A.
 331
 332      struct bfd_arch_info objects are singletons: that is, there's
 333      supposed to be exactly one instance for a given machine.  So you
 334      can tell whether two are equivalent by comparing pointers.  */
 335   return (a == b || a->compatible (a, b) == a);
 336 }
 337
 338
 339 void
 340 gdbarch_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
 341 {
 342   struct gdb_osabi_handler *handler;
 343
 344   if (info.osabi == GDB_OSABI_UNKNOWN)
 345     {
 346       /* Don't complain about an unknown OSABI.  Assume the user knows
 347          what they are doing.  */
 348       return;
 349     }
 350
 351   for (handler = gdb_osabi_handler_list; handler != NULL;
 352        handler = handler->next)
 353     {
 354       if (handler->osabi != info.osabi)
 355         continue;
 356
 357       /* If the architecture described by ARCH_INFO can run code for
 358          the architcture we registered the handler for, then the
 359          handler is applicable.  Note, though, that if the handler is
 360          for an architecture that is a superset of ARCH_INFO, we can't
 361          use that --- it would be perfectly correct for it to install
 362          gdbarch methods that refer to registers / instructions /
 363          other facilities ARCH_INFO doesn't have.
 364
 365          NOTE: kettenis/20021027: There may be more than one machine
 366          type that is compatible with the desired machine type.  Right
 367          now we simply return the first match, which is fine for now.
 368          However, we might want to do something smarter in the future.  */
 369       /* NOTE: cagney/2003-10-23: The code for "a can_run_code_for b"
 370          is implemented using BFD's compatible method (a->compatible
 371          (b) == a -- the lowest common denominator between a and b is
 372          a).  That method's definition of compatible may not be as you
 373          expect.  For instance the test "amd64 can run code for i386"
 374          (or more generally "64-bit ISA can run code for the 32-bit
 375          ISA").  BFD doesn't normally consider 32-bit and 64-bit
 376          "compatible" so it doesn't succeed.  */
 377       if (can_run_code_for (info.bfd_arch_info, handler->arch_info))
 378         {
 379           (*handler->init_osabi) (info, gdbarch);
 380           return;
 381         }
 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 comtain the complete note.  */
 421   if (notesz > bfd_section_size (abfd, 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, void *obj)
 444 {
 445   enum gdb_osabi *osabi = obj;
 446   const char *name;
 447   unsigned int sectsize;
 448   char *note;
 449
 450   name = bfd_get_section_name (abfd, sect);
 451   sectsize = bfd_section_size (abfd, 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 = 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_ELF;
 488               break;
 489
 490             case GNU_ABI_TAG_NETBSD:
 491               *osabi = GDB_OSABI_NETBSD_ELF;
 492               break;
 493
 494             default:
 495               internal_error (__FILE__, __LINE__,
 496                               _("generic_elf_osabi_sniff_abi_tag_sections: "
 497                                 "unknown OS number %d"),
 498                               abi_tag);
 499             }
 500           return;
 501         }
 502
 503       /* FreeBSD.  */
 504       if (check_note (abfd, sect, note, &sectsize, "FreeBSD", 4,
 505                       NT_FREEBSD_ABI_TAG))
 506         {
 507           /* There is no need to check the version yet.  */
 508           *osabi = GDB_OSABI_FREEBSD_ELF;
 509           return;
 510         }
 511
 512       return;
 513     }
 514
 515   /* .note.netbsd.ident notes, used by NetBSD.  */
 516   if (strcmp (name, ".note.netbsd.ident") == 0
 517       && check_note (abfd, sect, note, &sectsize, "NetBSD", 4, NT_NETBSD_IDENT))
 518     {
 519       /* There is no need to check the version yet.  */
 520       *osabi = GDB_OSABI_NETBSD_ELF;
 521       return;
 522     }
 523
 524   /* .note.openbsd.ident notes, used by OpenBSD.  */
 525   if (strcmp (name, ".note.openbsd.ident") == 0
 526       && check_note (abfd, sect, note, &sectsize, "OpenBSD", 4,
 527                      NT_OPENBSD_IDENT))
 528     {
 529       /* There is no need to check the version yet.  */
 530       *osabi = GDB_OSABI_OPENBSD_ELF;
 531       return;
 532     }
 533
 534   /* .note.netbsdcore.procinfo notes, used by NetBSD.  */
 535   if (strcmp (name, ".note.netbsdcore.procinfo") == 0)
 536     {
 537       *osabi = GDB_OSABI_NETBSD_ELF;
 538       return;
 539     }
 540 }
 541
 542 static enum gdb_osabi
 543 generic_elf_osabi_sniffer (bfd *abfd)
 544 {
 545   unsigned int elfosabi;
 546   enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
 547
 548   elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
 549
 550   switch (elfosabi)
 551     {
 552     case ELFOSABI_NONE:
 553     case ELFOSABI_GNU:
 554       /* When the EI_OSABI field in the ELF header is ELFOSABI_NONE
 555          (0), then the ELF structures in the file are conforming to
 556          the base specification for that machine (there are no
 557          OS-specific extensions).  In order to determine the real OS
 558          in use, we must look for OS-specific notes.
 559
 560          The same applies for ELFOSABI_GNU: this can mean GNU/Hurd,
 561          GNU/Linux, and possibly more.  */
 562       bfd_map_over_sections (abfd,
 563                              generic_elf_osabi_sniff_abi_tag_sections,
 564                              &osabi);
 565       break;
 566
 567     case ELFOSABI_FREEBSD:
 568       osabi = GDB_OSABI_FREEBSD_ELF;
 569       break;
 570
 571     case ELFOSABI_NETBSD:
 572       osabi = GDB_OSABI_NETBSD_ELF;
 573       break;
 574
 575     case ELFOSABI_SOLARIS:
 576       osabi = GDB_OSABI_SOLARIS;
 577       break;
 578
 579     case ELFOSABI_HPUX:
 580       /* For some reason the default value for the EI_OSABI field is
 581          ELFOSABI_HPUX for all PA-RISC targets (with the exception of
 582          GNU/Linux).  We use HP-UX ELF as the default, but let any
 583          OS-specific notes override this.  */
 584       osabi = GDB_OSABI_HPUX_ELF;
 585       bfd_map_over_sections (abfd,
 586                              generic_elf_osabi_sniff_abi_tag_sections,
 587                              &osabi);
 588       break;
 589
 590     case ELFOSABI_OPENVMS:
 591       osabi = GDB_OSABI_OPENVMS;
 592       break;
 593     }
 594
 595   if (osabi == GDB_OSABI_UNKNOWN)
 596     {
 597       /* The FreeBSD folks have been naughty; they stored the string
 598          "FreeBSD" in the padding of the e_ident field of the ELF
 599          header to "brand" their ELF binaries in FreeBSD 3.x.  */
 600       if (memcmp (&elf_elfheader (abfd)->e_ident[8],
 601                   "FreeBSD", sizeof ("FreeBSD")) == 0)
 602         osabi = GDB_OSABI_FREEBSD_ELF;
 603     }
 604
 605   return osabi;
 606 }
 607 \f
 608 static void
 609 set_osabi (char *args, int from_tty, struct cmd_list_element *c)
 610 {
 611   struct gdbarch_info info;
 612
 613   if (strcmp (set_osabi_string, "auto") == 0)
 614     user_osabi_state = osabi_auto;
 615   else if (strcmp (set_osabi_string, "default") == 0)
 616     {
 617       user_selected_osabi = GDB_OSABI_DEFAULT;
 618       user_osabi_state = osabi_user;
 619     }
 620   else if (strcmp (set_osabi_string, "none") == 0)
 621     {
 622       user_selected_osabi = GDB_OSABI_UNKNOWN;
 623       user_osabi_state = osabi_user;
 624     }
 625   else
 626     {
 627       int i;
 628
 629       for (i = 1; i < GDB_OSABI_INVALID; i++)
 630         if (strcmp (set_osabi_string, gdbarch_osabi_name (i)) == 0)
 631           {
 632             user_selected_osabi = i;
 633             user_osabi_state = osabi_user;
 634             break;
 635           }
 636       if (i == GDB_OSABI_INVALID)
 637         internal_error (__FILE__, __LINE__,
 638                         _("Invalid OS ABI \"%s\" passed to command handler."),
 639                         set_osabi_string);
 640     }
 641
 642   /* NOTE: At some point (true multiple architectures) we'll need to be more
 643      graceful here.  */
 644   gdbarch_info_init (&info);
 645   if (! gdbarch_update_p (info))
 646     internal_error (__FILE__, __LINE__, _("Updating OS ABI failed."));
 647 }
 648
 649 static void
 650 show_osabi (struct ui_file *file, int from_tty, struct cmd_list_element *c,
 651             const char *value)
 652 {
 653   if (user_osabi_state == osabi_auto)
 654     fprintf_filtered (file,
 655                       _("The current OS ABI is \"auto\" "
 656                         "(currently \"%s\").\n"),
 657                       gdbarch_osabi_name (gdbarch_osabi (get_current_arch ())));
 658   else
 659     fprintf_filtered (file, _("The current OS ABI is \"%s\".\n"),
 660                       gdbarch_osabi_name (user_selected_osabi));
 661
 662   if (GDB_OSABI_DEFAULT != GDB_OSABI_UNKNOWN)
 663     fprintf_filtered (file, _("The default OS ABI is \"%s\".\n"),
 664                       gdbarch_osabi_name (GDB_OSABI_DEFAULT));
 665 }
 666 \f
 667 extern initialize_file_ftype _initialize_gdb_osabi; /* -Wmissing-prototype */
 668
 669 void
 670 _initialize_gdb_osabi (void)
 671 {
 672   if (strcmp (gdb_osabi_names[GDB_OSABI_INVALID].pretty, "<invalid>") != 0)
 673     internal_error
 674       (__FILE__, __LINE__,
 675        _("_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent"));
 676
 677   /* Register a generic sniffer for ELF flavoured files.  */
 678   gdbarch_register_osabi_sniffer (bfd_arch_unknown,
 679                                   bfd_target_elf_flavour,
 680                                   generic_elf_osabi_sniffer);
 681
 682   /* Register the "set osabi" command.  */
 683   add_setshow_enum_cmd ("osabi", class_support, gdb_osabi_available_names,
 684                         &set_osabi_string,
 685                         _("Set OS ABI of target."),
 686                         _("Show OS ABI of target."),
 687                         NULL, set_osabi, show_osabi,
 688                         &setlist, &showlist);
 689   user_osabi_state = osabi_auto;
 690 }