gdb/osabi.c

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