gdb/osabi.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* OS ABI variant handling for GDB.

  3.    Copyright (C) 2001-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  20. #include "defs.h"

  22. #include "osabi.h"
  23. #include "arch-utils.h"
  24. #include "gdbcmd.h"
  25. #include "command.h"

  27. #include "elf-bfd.h"

  29. #ifndef GDB_OSABI_DEFAULT
  30. ‌#define GDB_OSABI_DEFAULT GDB_OSABI_UNKNOWN
  31. #endif

  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;

  44. /* Names associated with each osabi.  */

  46. ‌struct osabi_names
  47. {
  48.   /* The "pretty" name.  */

  50.   const char *pretty;

  52.   /* The triplet regexp, or NULL if not known.  */

  54.   const char *regexp;
  55. };

  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 },

  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.   { "Windows CE", NULL },
  73.   { "DJGPP", NULL },
  74.   { "Irix", NULL },
  75.   { "HP/UX ELF", NULL },
  76.   { "HP/UX SOM", NULL },
  77.   { "QNX Neutrino", NULL },
  78.   { "Cygwin", NULL },
  79.   { "AIX", NULL },
  80.   { "DICOS", NULL },
  81.   { "Darwin", NULL },
  82.   { "Symbian", NULL },
  83.   { "OpenVMS", NULL },
  84.   { "LynxOS178", NULL },
  85.   { "Newlib", NULL },
  86.   { "SDE", NULL },

  88.   { "<invalid>", NULL }
  89. };

  91. const char *
  92. ‌gdbarch_osabi_name (enum gdb_osabi osabi)
  93. {
  94.   if (osabi >= GDB_OSABI_UNKNOWN && osabi < GDB_OSABI_INVALID)
  95.     return gdb_osabi_names[osabi].pretty;

  97.   return gdb_osabi_names[GDB_OSABI_INVALID].pretty;
  98. }

  100. /* See osabi.h.  */

  102. const char *
  103. ‌osabi_triplet_regexp (enum gdb_osabi osabi)
  104. {
  105.   if (osabi >= GDB_OSABI_UNKNOWN && osabi < GDB_OSABI_INVALID)
  106.     return gdb_osabi_names[osabi].regexp;

  108.   return gdb_osabi_names[GDB_OSABI_INVALID].regexp;
  109. }

  111. /* Lookup the OS ABI corresponding to the specified target description
  112.    string.  */

  114. enum gdb_osabi
  115. ‌osabi_from_tdesc_string (const char *name)
  116. {
  117.   int i;

  119.   for (i = 0; i < ARRAY_SIZE (gdb_osabi_names); i++)
  120.     if (strcmp (name, gdb_osabi_names[i].pretty) == 0)
  121.       {
  122.         /* See note above: the name table matches the indices assigned
  123.            to enum gdb_osabi.  */
  124.         enum gdb_osabi osabi = (enum gdb_osabi) i;

  126.         if (osabi == GDB_OSABI_INVALID)
  127.           return GDB_OSABI_UNKNOWN;
  128.         else
  129.           return osabi;
  130.       }

  132.   return GDB_OSABI_UNKNOWN;
  133. }

  135. /* Handler for a given architecture/OS ABI pair.  There should be only
  136.    one handler for a given OS ABI each architecture family.  */
  137. ‌struct gdb_osabi_handler
  138. {
  139.   struct gdb_osabi_handler *next;
  140.   const struct bfd_arch_info *arch_info;
  141.   enum gdb_osabi osabi;
  142.   void (*init_osabi)(struct gdbarch_info, struct gdbarch *);
  143. };

  145. ‌static struct gdb_osabi_handler *gdb_osabi_handler_list;

  147. void
  148. ‌gdbarch_register_osabi (enum bfd_architecture arch, unsigned long machine,
  149.                         enum gdb_osabi osabi,
  150.                         void (*init_osabi)(struct gdbarch_info,
  151.                                            struct gdbarch *))
  152. {
  153.   struct gdb_osabi_handler **handler_p;
  154.   const struct bfd_arch_info *arch_info = bfd_lookup_arch (arch, machine);
  155.   const char **name_ptr;

  157.   /* Registering an OS ABI handler for "unknown" is not allowed.  */
  158.   if (osabi == GDB_OSABI_UNKNOWN)
  159.     {
  160.       internal_error
  161.         (__FILE__, __LINE__,
  162.          _("gdbarch_register_osabi: An attempt to register a handler for "
  163.          "OS ABI \"%s\" for architecture %s was made.  The handler will "
  164.          "not be registered"),
  165.          gdbarch_osabi_name (osabi),
  166.          bfd_printable_arch_mach (arch, machine));
  167.       return;
  168.     }

  170.   gdb_assert (arch_info);

  172.   for (handler_p = &gdb_osabi_handler_list; *handler_p != NULL;
  173.        handler_p = &(*handler_p)->next)
  174.     {
  175.       if ((*handler_p)->arch_info == arch_info
  176.           && (*handler_p)->osabi == osabi)
  177.         {
  178.           internal_error
  179.             (__FILE__, __LINE__,
  180.              _("gdbarch_register_osabi: A handler for OS ABI \"%s\" "
  181.              "has already been registered for architecture %s"),
  182.              gdbarch_osabi_name (osabi),
  183.              arch_info->printable_name);
  184.           /* If user wants to continue, override previous definition.  */
  185.           (*handler_p)->init_osabi = init_osabi;
  186.           return;
  187.         }
  188.     }

  190.   (*handler_p)
  191.     = (struct gdb_osabi_handler *) xmalloc (sizeof (struct gdb_osabi_handler));
  192.   (*handler_p)->next = NULL;
  193.   (*handler_p)->arch_info = arch_info;
  194.   (*handler_p)->osabi = osabi;
  195.   (*handler_p)->init_osabi = init_osabi;

  197.   /* Add this OS ABI to the list of enum values for "set osabi", if it isn't
  198.      already there.  */
  199.   for (name_ptr = gdb_osabi_available_names; *name_ptr; name_ptr ++)
  200.     {
  201.       if (*name_ptr == gdbarch_osabi_name (osabi))
  202.         return;
  203.     }
  204.   *name_ptr++ = gdbarch_osabi_name (osabi);
  205.   *name_ptr = NULL;
  206. }


  209. /* Sniffer to find the OS ABI for a given file's architecture and flavour.
  210.    It is legal to have multiple sniffers for each arch/flavour pair, to
  211.    disambiguate one OS's a.out from another, for example.  The first sniffer
  212.    to return something other than GDB_OSABI_UNKNOWN wins, so a sniffer should
  213.    be careful to claim a file only if it knows for sure what it is.  */
  214. ‌struct gdb_osabi_sniffer
  215. {
  216.   struct gdb_osabi_sniffer *next;
  217.   enum bfd_architecture arch;   /* bfd_arch_unknown == wildcard */
  218.   enum bfd_flavour flavour;
  219.   enum gdb_osabi (*sniffer)(bfd *);
  220. };

  222. ‌static struct gdb_osabi_sniffer *gdb_osabi_sniffer_list;

  224. void
  225. ‌gdbarch_register_osabi_sniffer (enum bfd_architecture arch,
  226.                                 enum bfd_flavour flavour,
  227.                                 enum gdb_osabi (*sniffer_fn)(bfd *))
  228. {
  229.   struct gdb_osabi_sniffer *sniffer;

  231.   sniffer =
  232.     (struct gdb_osabi_sniffer *) xmalloc (sizeof (struct gdb_osabi_sniffer));
  233.   sniffer->arch = arch;
  234.   sniffer->flavour = flavour;
  235.   sniffer->sniffer = sniffer_fn;

  237.   sniffer->next = gdb_osabi_sniffer_list;
  238.   gdb_osabi_sniffer_list = sniffer;
  239. }


  242. enum gdb_osabi
  243. ‌gdbarch_lookup_osabi (bfd *abfd)
  244. {
  245.   struct gdb_osabi_sniffer *sniffer;
  246.   enum gdb_osabi osabi, match;
  247.   int match_specific;

  249.   /* If we aren't in "auto" mode, return the specified OS ABI.  */
  250.   if (user_osabi_state == osabi_user)
  251.     return user_selected_osabi;

  253.   /* If we don't have a binary, just return unknown.  The caller may
  254.      have other sources the OSABI can be extracted from, e.g., the
  255.      target description.  */
  256.   if (abfd == NULL)
  257.     return GDB_OSABI_UNKNOWN;

  259.   match = GDB_OSABI_UNKNOWN;
  260.   match_specific = 0;

  262.   for (sniffer = gdb_osabi_sniffer_list; sniffer != NULL;
  263.        sniffer = sniffer->next)
  264.     {
  265.       if ((sniffer->arch == bfd_arch_unknown /* wildcard */
  266.            || sniffer->arch == bfd_get_arch (abfd))
  267.           && sniffer->flavour == bfd_get_flavour (abfd))
  268.         {
  269.           osabi = (*sniffer->sniffer) (abfd);
  270.           if (osabi < GDB_OSABI_UNKNOWN || osabi >= GDB_OSABI_INVALID)
  271.             {
  272.               internal_error
  273.                 (__FILE__, __LINE__,
  274.                  _("gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer "
  275.                  "for architecture %s flavour %d"),
  276.                  (int) osabi,
  277.                  bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
  278.                  (int) bfd_get_flavour (abfd));
  279.             }
  280.           else if (osabi != GDB_OSABI_UNKNOWN)
  281.             {
  282.               /* A specific sniffer always overrides a generic sniffer.
  283.                  Croak on multiple match if the two matches are of the
  284.                  same class.  If the user wishes to continue, we'll use
  285.                  the first match.  */
  286.               if (match != GDB_OSABI_UNKNOWN)
  287.                 {
  288.                   if ((match_specific && sniffer->arch != bfd_arch_unknown)
  289.                    || (!match_specific && sniffer->arch == bfd_arch_unknown))
  290.                     {
  291.                       internal_error
  292.                         (__FILE__, __LINE__,
  293.                          _("gdbarch_lookup_osabi: multiple %sspecific OS ABI "
  294.                          "match for architecture %s flavour %d: first "
  295.                          "match \"%s\", second match \"%s\""),
  296.                          match_specific ? "" : "non-",
  297.                          bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
  298.                          (int) bfd_get_flavour (abfd),
  299.                          gdbarch_osabi_name (match),
  300.                          gdbarch_osabi_name (osabi));
  301.                     }
  302.                   else if (sniffer->arch != bfd_arch_unknown)
  303.                     {
  304.                       match = osabi;
  305.                       match_specific = 1;
  306.                     }
  307.                 }
  308.               else
  309.                 {
  310.                   match = osabi;
  311.                   if (sniffer->arch != bfd_arch_unknown)
  312.                     match_specific = 1;
  313.                 }
  314.             }
  315.         }
  316.     }

  318.   return match;
  319. }


  322. /* Return non-zero if architecture A can run code written for
  323.    architecture B.  */
  324. static int
  325. ‌can_run_code_for (const struct bfd_arch_info *a, const struct bfd_arch_info *b)
  326. {
  327.   /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
  328.      incompatible.  But if they are compatible, it returns the 'more
  329.      featureful' of the two arches.  That is, if A can run code
  330.      written for B, but B can't run code written for A, then it'll
  331.      return A.

  333.      struct bfd_arch_info objects are singletons: that is, there's
  334.      supposed to be exactly one instance for a given machine.  So you
  335.      can tell whether two are equivalent by comparing pointers.  */
  336.   return (a == b || a->compatible (a, b) == a);
  337. }


  340. void
  341. ‌gdbarch_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
  342. {
  343.   struct gdb_osabi_handler *handler;

  345.   if (info.osabi == GDB_OSABI_UNKNOWN)
  346.     {
  347.       /* Don't complain about an unknown OSABI.  Assume the user knows
  348.          what they are doing.  */
  349.       return;
  350.     }

  352.   for (handler = gdb_osabi_handler_list; handler != NULL;
  353.        handler = handler->next)
  354.     {
  355.       if (handler->osabi != info.osabi)
  356.         continue;

  358.       /* If the architecture described by ARCH_INFO can run code for
  359.          the architcture we registered the handler for, then the
  360.          handler is applicable.  Note, though, that if the handler is
  361.          for an architecture that is a superset of ARCH_INFO, we can't
  362.          use that --- it would be perfectly correct for it to install
  363.          gdbarch methods that refer to registers / instructions /
  364.          other facilities ARCH_INFO doesn't have.

  366.          NOTE: kettenis/20021027: There may be more than one machine
  367.          type that is compatible with the desired machine type.  Right
  368.          now we simply return the first match, which is fine for now.
  369.          However, we might want to do something smarter in the future.  */
  370.       /* NOTE: cagney/2003-10-23: The code for "a can_run_code_for b"
  371.          is implemented using BFD's compatible method (a->compatible
  372.          (b) == a -- the lowest common denominator between a and b is
  373.          a).  That method's definition of compatible may not be as you
  374.          expect.  For instance the test "amd64 can run code for i386"
  375.          (or more generally "64-bit ISA can run code for the 32-bit
  376.          ISA").  BFD doesn't normally consider 32-bit and 64-bit
  377.          "compatible" so it doesn't succeed.  */
  378.       if (can_run_code_for (info.bfd_arch_info, handler->arch_info))
  379.         {
  380.           (*handler->init_osabi) (info, gdbarch);
  381.           return;
  382.         }
  383.     }

  385.   warning
  386.     ("A handler for the OS ABI \"%s\" is not built into this configuration\n"
  387.      "of GDB.  Attempting to continue with the default %s settings.\n",
  388.      gdbarch_osabi_name (info.osabi),
  389.      info.bfd_arch_info->printable_name);
  390. }

  392. /* Limit on the amount of data to be read.  */
  393. ‌#define MAX_NOTESZ        128

  395. /* Return non-zero if NOTE matches NAME, DESCSZ and TYPE.  If
  396.    *SECTSIZE is non-zero, then this reads that many bytes from
  397.    the start of the section and clears *SECTSIZE.  */

  399. static int
  400. ‌check_note (bfd *abfd, asection *sect, char *note, unsigned int *sectsize,
  401.             const char *name, unsigned long descsz, unsigned long type)
  402. {
  403.   unsigned long notesz;

  405.   if (*sectsize)
  406.     {
  407.       if (!bfd_get_section_contents (abfd, sect, note, 0, *sectsize))
  408.         return 0;
  409.       *sectsize = 0;
  410.     }

  412.   /* Calculate the size of this note.  */
  413.   notesz = strlen (name) + 1;
  414.   notesz = ((notesz + 3) & ~3);
  415.   notesz += descsz;
  416.   notesz = ((notesz + 3) & ~3);

  418.   /* If this assertion triggers, increase MAX_NOTESZ.  */
  419.   gdb_assert (notesz <= MAX_NOTESZ);

  421.   /* Check whether SECT is big enough to comtain the complete note.  */
  422.   if (notesz > bfd_section_size (abfd, sect))
  423.     return 0;

  425.   /* Check the note name.  */
  426.   if (bfd_h_get_32 (abfd, note) != (strlen (name) + 1)
  427.       || strcmp (note + 12, name) != 0)
  428.     return 0;

  430.   /* Check the descriptor size.  */
  431.   if (bfd_h_get_32 (abfd, note + 4) != descsz)
  432.     return 0;

  434.   /* Check the note type.  */
  435.   if (bfd_h_get_32 (abfd, note + 8) != type)
  436.     return 0;

  438.   return 1;
  439. }

  441. /* Generic sniffer for ELF flavoured files.  */

  443. void
  444. ‌generic_elf_osabi_sniff_abi_tag_sections (bfd *abfd, asection *sect, void *obj)
  445. {
  446.   enum gdb_osabi *osabi = obj;
  447.   const char *name;
  448.   unsigned int sectsize;
  449.   char *note;

  451.   name = bfd_get_section_name (abfd, sect);
  452.   sectsize = bfd_section_size (abfd, sect);

  454.   /* Limit the amount of data to read.  */
  455.   if (sectsize > MAX_NOTESZ)
  456.     sectsize = MAX_NOTESZ;

  458.   /* We lazily read the section data here.  Since we use
  459.      BFD_DECOMPRESS, we can't use bfd_get_section_contents on a
  460.      compressed section.  But, since note sections are not compressed,
  461.      deferring the reading until we recognize the section avoids any
  462.      error.  */
  463.   note = alloca (sectsize);

  465.   /* .note.ABI-tag notes, used by GNU/Linux and FreeBSD.  */
  466.   if (strcmp (name, ".note.ABI-tag") == 0)
  467.     {
  468.       /* GNU.  */
  469.       if (check_note (abfd, sect, note, &sectsize, "GNU", 16, NT_GNU_ABI_TAG))
  470.         {
  471.           unsigned int abi_tag = bfd_h_get_32 (abfd, note + 16);

  473.           switch (abi_tag)
  474.             {
  475.             case GNU_ABI_TAG_LINUX:
  476.               *osabi = GDB_OSABI_LINUX;
  477.               break;

  479.             case GNU_ABI_TAG_HURD:
  480.               *osabi = GDB_OSABI_HURD;
  481.               break;

  483.             case GNU_ABI_TAG_SOLARIS:
  484.               *osabi = GDB_OSABI_SOLARIS;
  485.               break;

  487.             case GNU_ABI_TAG_FREEBSD:
  488.               *osabi = GDB_OSABI_FREEBSD_ELF;
  489.               break;

  491.             case GNU_ABI_TAG_NETBSD:
  492.               *osabi = GDB_OSABI_NETBSD_ELF;
  493.               break;

  495.             default:
  496.               internal_error (__FILE__, __LINE__,
  497.                               _("generic_elf_osabi_sniff_abi_tag_sections: "
  498.                                 "unknown OS number %d"),
  499.                               abi_tag);
  500.             }
  501.           return;
  502.         }

  504.       /* FreeBSD.  */
  505.       if (check_note (abfd, sect, note, &sectsize, "FreeBSD", 4,
  506.                       NT_FREEBSD_ABI_TAG))
  507.         {
  508.           /* There is no need to check the version yet.  */
  509.           *osabi = GDB_OSABI_FREEBSD_ELF;
  510.           return;
  511.         }

  513.       return;
  514.     }

  516.   /* .note.netbsd.ident notes, used by NetBSD.  */
  517.   if (strcmp (name, ".note.netbsd.ident") == 0
  518.       && check_note (abfd, sect, note, &sectsize, "NetBSD", 4, NT_NETBSD_IDENT))
  519.     {
  520.       /* There is no need to check the version yet.  */
  521.       *osabi = GDB_OSABI_NETBSD_ELF;
  522.       return;
  523.     }

  525.   /* .note.openbsd.ident notes, used by OpenBSD.  */
  526.   if (strcmp (name, ".note.openbsd.ident") == 0
  527.       && check_note (abfd, sect, note, &sectsize, "OpenBSD", 4,
  528.                      NT_OPENBSD_IDENT))
  529.     {
  530.       /* There is no need to check the version yet.  */
  531.       *osabi = GDB_OSABI_OPENBSD_ELF;
  532.       return;
  533.     }

  535.   /* .note.netbsdcore.procinfo notes, used by NetBSD.  */
  536.   if (strcmp (name, ".note.netbsdcore.procinfo") == 0)
  537.     {
  538.       *osabi = GDB_OSABI_NETBSD_ELF;
  539.       return;
  540.     }
  541. }

  543. static enum gdb_osabi
  544. ‌generic_elf_osabi_sniffer (bfd *abfd)
  545. {
  546.   unsigned int elfosabi;
  547.   enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;

  549.   elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];

  551.   switch (elfosabi)
  552.     {
  553.     case ELFOSABI_NONE:
  554.     case ELFOSABI_GNU:
  555.       /* When the EI_OSABI field in the ELF header is ELFOSABI_NONE
  556.          (0), then the ELF structures in the file are conforming to
  557.          the base specification for that machine (there are no
  558.          OS-specific extensions).  In order to determine the real OS
  559.          in use, we must look for OS-specific notes.

  561.          The same applies for ELFOSABI_GNU: this can mean GNU/Hurd,
  562.          GNU/Linux, and possibly more.  */
  563.       bfd_map_over_sections (abfd,
  564.                              generic_elf_osabi_sniff_abi_tag_sections,
  565.                              &osabi);
  566.       break;

  568.     case ELFOSABI_FREEBSD:
  569.       osabi = GDB_OSABI_FREEBSD_ELF;
  570.       break;

  572.     case ELFOSABI_NETBSD:
  573.       osabi = GDB_OSABI_NETBSD_ELF;
  574.       break;

  576.     case ELFOSABI_SOLARIS:
  577.       osabi = GDB_OSABI_SOLARIS;
  578.       break;

  580.     case ELFOSABI_HPUX:
  581.       /* For some reason the default value for the EI_OSABI field is
  582.          ELFOSABI_HPUX for all PA-RISC targets (with the exception of
  583.          GNU/Linux).  We use HP-UX ELF as the default, but let any
  584.          OS-specific notes override this.  */
  585.       osabi = GDB_OSABI_HPUX_ELF;
  586.       bfd_map_over_sections (abfd,
  587.                              generic_elf_osabi_sniff_abi_tag_sections,
  588.                              &osabi);
  589.       break;

  591.     case ELFOSABI_OPENVMS:
  592.       osabi = GDB_OSABI_OPENVMS;
  593.       break;
  594.     }

  596.   if (osabi == GDB_OSABI_UNKNOWN)
  597.     {
  598.       /* The FreeBSD folks have been naughty; they stored the string
  599.          "FreeBSD" in the padding of the e_ident field of the ELF
  600.          header to "brand" their ELF binaries in FreeBSD 3.x.  */
  601.       if (memcmp (&elf_elfheader (abfd)->e_ident[8],
  602.                   "FreeBSD", sizeof ("FreeBSD")) == 0)
  603.         osabi = GDB_OSABI_FREEBSD_ELF;
  604.     }

  606.   return osabi;
  607. }

  609. static void
  610. ‌set_osabi (char *args, int from_tty, struct cmd_list_element *c)
  611. {
  612.   struct gdbarch_info info;

  614.   if (strcmp (set_osabi_string, "auto") == 0)
  615.     user_osabi_state = osabi_auto;
  616.   else if (strcmp (set_osabi_string, "default") == 0)
  617.     {
  618.       user_selected_osabi = GDB_OSABI_DEFAULT;
  619.       user_osabi_state = osabi_user;
  620.     }
  621.   else if (strcmp (set_osabi_string, "none") == 0)
  622.     {
  623.       user_selected_osabi = GDB_OSABI_UNKNOWN;
  624.       user_osabi_state = osabi_user;
  625.     }
  626.   else
  627.     {
  628.       int i;

  630.       for (i = 1; i < GDB_OSABI_INVALID; i++)
  631.         if (strcmp (set_osabi_string, gdbarch_osabi_name (i)) == 0)
  632.           {
  633.             user_selected_osabi = i;
  634.             user_osabi_state = osabi_user;
  635.             break;
  636.           }
  637.       if (i == GDB_OSABI_INVALID)
  638.         internal_error (__FILE__, __LINE__,
  639.                         _("Invalid OS ABI \"%s\" passed to command handler."),
  640.                         set_osabi_string);
  641.     }

  643.   /* NOTE: At some point (true multiple architectures) we'll need to be more
  644.      graceful here.  */
  645.   gdbarch_info_init (&info);
  646.   if (! gdbarch_update_p (info))
  647.     internal_error (__FILE__, __LINE__, _("Updating OS ABI failed."));
  648. }

  650. static void
  651. ‌show_osabi (struct ui_file *file, int from_tty, struct cmd_list_element *c,
  652.             const char *value)
  653. {
  654.   if (user_osabi_state == osabi_auto)
  655.     fprintf_filtered (file,
  656.                       _("The current OS ABI is \"auto\" "
  657.                         "(currently \"%s\").\n"),
  658.                       gdbarch_osabi_name (gdbarch_osabi (get_current_arch ())));
  659.   else
  660.     fprintf_filtered (file, _("The current OS ABI is \"%s\".\n"),
  661.                       gdbarch_osabi_name (user_selected_osabi));

  663.   if (GDB_OSABI_DEFAULT != GDB_OSABI_UNKNOWN)
  664.     fprintf_filtered (file, _("The default OS ABI is \"%s\".\n"),
  665.                       gdbarch_osabi_name (GDB_OSABI_DEFAULT));
  666. }

  668. extern initialize_file_ftype _initialize_gdb_osabi; /* -Wmissing-prototype */

  670. void
  671. ‌_initialize_gdb_osabi (void)
  672. {
  673.   if (strcmp (gdb_osabi_names[GDB_OSABI_INVALID].pretty, "<invalid>") != 0)
  674.     internal_error
  675.       (__FILE__, __LINE__,
  676.        _("_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent"));

  678.   /* Register a generic sniffer for ELF flavoured files.  */
  679.   gdbarch_register_osabi_sniffer (bfd_arch_unknown,
  680.                                   bfd_target_elf_flavour,
  681.                                   generic_elf_osabi_sniffer);

  683.   /* Register the "set osabi" command.  */
  684.   add_setshow_enum_cmd ("osabi", class_support, gdb_osabi_available_names,
  685.                         &set_osabi_string,
  686.                         _("Set OS ABI of target."),
  687.                         _("Show OS ABI of target."),
  688.                         NULL, set_osabi, show_osabi,
  689.                         &setlist, &showlist);
  690.   user_osabi_state = osabi_auto;
  691. }