contrib/gdb/gdb/osabi.c

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