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