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   { "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               internal_error (__FILE__, __LINE__,
 497                               _("generic_elf_osabi_sniff_abi_tag_sections: "
 498                                 "unknown OS number %d"),
 499                               abi_tag);
 500             }
 501           return;
 502         }
 503
 504       /* FreeBSD.  */
 505       if (check_note (abfd, sect, note, &sectsize, "FreeBSD", 4,
 506                       NT_FREEBSD_ABI_TAG))
 507         {
 508           /* There is no need to check the version yet.  */
 509           *osabi = GDB_OSABI_FREEBSD_ELF;
 510           return;
 511         }
 512
 513       return;
 514     }
 515
 516   /* .note.netbsd.ident notes, used by NetBSD.  */
 517   if (strcmp (name, ".note.netbsd.ident") == 0
 518       && check_note (abfd, sect, note, &sectsize, "NetBSD", 4, NT_NETBSD_IDENT))
 519     {
 520       /* There is no need to check the version yet.  */
 521       *osabi = GDB_OSABI_NETBSD_ELF;
 522       return;
 523     }
 524
 525   /* .note.openbsd.ident notes, used by OpenBSD.  */
 526   if (strcmp (name, ".note.openbsd.ident") == 0
 527       && check_note (abfd, sect, note, &sectsize, "OpenBSD", 4,
 528                      NT_OPENBSD_IDENT))
 529     {
 530       /* There is no need to check the version yet.  */
 531       *osabi = GDB_OSABI_OPENBSD_ELF;
 532       return;
 533     }
 534
 535   /* .note.netbsdcore.procinfo notes, used by NetBSD.  */
 536   if (strcmp (name, ".note.netbsdcore.procinfo") == 0)
 537     {
 538       *osabi = GDB_OSABI_NETBSD_ELF;
 539       return;
 540     }
 541 }
 542
 543 static enum gdb_osabi
 544 generic_elf_osabi_sniffer (bfd *abfd)
 545 {
 546   unsigned int elfosabi;
 547   enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
 548
 549   elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
 550
 551   switch (elfosabi)
 552     {
 553     case ELFOSABI_NONE:
 554     case ELFOSABI_GNU:
 555       /* When the EI_OSABI field in the ELF header is ELFOSABI_NONE
 556          (0), then the ELF structures in the file are conforming to
 557          the base specification for that machine (there are no
 558          OS-specific extensions).  In order to determine the real OS
 559          in use, we must look for OS-specific notes.
 560
 561          The same applies for ELFOSABI_GNU: this can mean GNU/Hurd,
 562          GNU/Linux, and possibly more.  */
 563       bfd_map_over_sections (abfd,
 564                              generic_elf_osabi_sniff_abi_tag_sections,
 565                              &osabi);
 566       break;
 567
 568     case ELFOSABI_FREEBSD:
 569       osabi = GDB_OSABI_FREEBSD_ELF;
 570       break;
 571
 572     case ELFOSABI_NETBSD:
 573       osabi = GDB_OSABI_NETBSD_ELF;
 574       break;
 575
 576     case ELFOSABI_SOLARIS:
 577       osabi = GDB_OSABI_SOLARIS;
 578       break;
 579
 580     case ELFOSABI_HPUX:
 581       /* For some reason the default value for the EI_OSABI field is
 582          ELFOSABI_HPUX for all PA-RISC targets (with the exception of
 583          GNU/Linux).  We use HP-UX ELF as the default, but let any
 584          OS-specific notes override this.  */
 585       osabi = GDB_OSABI_HPUX_ELF;
 586       bfd_map_over_sections (abfd,
 587                              generic_elf_osabi_sniff_abi_tag_sections,
 588                              &osabi);
 589       break;
 590
 591     case ELFOSABI_OPENVMS:
 592       osabi = GDB_OSABI_OPENVMS;
 593       break;
 594     }
 595
 596   if (osabi == GDB_OSABI_UNKNOWN)
 597     {
 598       /* The FreeBSD folks have been naughty; they stored the string
 599          "FreeBSD" in the padding of the e_ident field of the ELF
 600          header to "brand" their ELF binaries in FreeBSD 3.x.  */
 601       if (memcmp (&elf_elfheader (abfd)->e_ident[8],
 602                   "FreeBSD", sizeof ("FreeBSD")) == 0)
 603         osabi = GDB_OSABI_FREEBSD_ELF;
 604     }
 605
 606   return osabi;
 607 }
 608 \f
 609 static void
 610 set_osabi (char *args, int from_tty, struct cmd_list_element *c)
 611 {
 612   struct gdbarch_info info;
 613
 614   if (strcmp (set_osabi_string, "auto") == 0)
 615     user_osabi_state = osabi_auto;
 616   else if (strcmp (set_osabi_string, "default") == 0)
 617     {
 618       user_selected_osabi = GDB_OSABI_DEFAULT;
 619       user_osabi_state = osabi_user;
 620     }
 621   else if (strcmp (set_osabi_string, "none") == 0)
 622     {
 623       user_selected_osabi = GDB_OSABI_UNKNOWN;
 624       user_osabi_state = osabi_user;
 625     }
 626   else
 627     {
 628       int i;
 629
 630       for (i = 1; i < GDB_OSABI_INVALID; i++)
 631         if (strcmp (set_osabi_string, gdbarch_osabi_name (i)) == 0)
 632           {
 633             user_selected_osabi = i;
 634             user_osabi_state = osabi_user;
 635             break;
 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 }