gdb/osabi.c

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