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