gdb/osabi.c

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