gdb/osabi.c

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