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