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