gdb/osabi.c

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