gdb/osabi.c

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