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