gdb/osabi.c

   1 /* OS ABI variant handling for GDB.
   2    Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22
  23 #include "gdb_assert.h"
  24 #include "gdb_string.h"
  25
  26 #include "osabi.h"
  27
  28 #include "elf-bfd.h"
  29
  30
  31 /* This table matches the indices assigned to enum gdb_osabi.  Keep
  32    them in sync.  */
  33 static const char * const gdb_osabi_names[] =
  34 {
  35   "<unknown>",
  36
  37   "SVR4",
  38   "GNU/Hurd",
  39   "Solaris",
  40   "OSF/1",
  41   "GNU/Linux",
  42   "FreeBSD a.out",
  43   "FreeBSD ELF",
  44   "NetBSD a.out",
  45   "NetBSD ELF",
  46   "Windows CE",
  47   "DJGPP",
  48   "NetWare",
  49   "Irix",
  50   "LynxOS",
  51   "Interix",
  52   "HP/UX ELF",
  53   "HP/UX SOM",
  54
  55   "ARM EABI v1",
  56   "ARM EABI v2",
  57   "ARM APCS",
  58
  59   "<invalid>"
  60 };
  61
  62 const char *
  63 gdbarch_osabi_name (enum gdb_osabi osabi)
  64 {
  65   if (osabi >= GDB_OSABI_UNKNOWN && osabi < GDB_OSABI_INVALID)
  66     return gdb_osabi_names[osabi];
  67
  68   return gdb_osabi_names[GDB_OSABI_INVALID];
  69 }
  70
  71 /* Handler for a given architecture/OS ABI pair.  There should be only
  72    one handler for a given OS ABI each architecture family.  */
  73 struct gdb_osabi_handler
  74 {
  75   struct gdb_osabi_handler *next;
  76   const struct bfd_arch_info *arch_info;
  77   enum gdb_osabi osabi;
  78   void (*init_osabi)(struct gdbarch_info, struct gdbarch *);
  79 };
  80
  81 static struct gdb_osabi_handler *gdb_osabi_handler_list;
  82
  83 void
  84 gdbarch_register_osabi (enum bfd_architecture arch, unsigned long machine,
  85                         enum gdb_osabi osabi,
  86                         void (*init_osabi)(struct gdbarch_info,
  87                                            struct gdbarch *))
  88 {
  89   struct gdb_osabi_handler **handler_p;
  90   const struct bfd_arch_info *arch_info = bfd_lookup_arch (arch, machine);
  91
  92   /* Registering an OS ABI handler for "unknown" is not allowed.  */
  93   if (osabi == GDB_OSABI_UNKNOWN)
  94     {
  95       internal_error
  96         (__FILE__, __LINE__,
  97          "gdbarch_register_osabi: An attempt to register a handler for "
  98          "OS ABI \"%s\" for architecture %s was made.  The handler will "
  99          "not be registered",
 100          gdbarch_osabi_name (osabi),
 101          bfd_printable_arch_mach (arch, machine));
 102       return;
 103     }
 104
 105   gdb_assert (arch_info);
 106
 107   for (handler_p = &gdb_osabi_handler_list; *handler_p != NULL;
 108        handler_p = &(*handler_p)->next)
 109     {
 110       if ((*handler_p)->arch_info == arch_info
 111           && (*handler_p)->osabi == osabi)
 112         {
 113           internal_error
 114             (__FILE__, __LINE__,
 115              "gdbarch_register_osabi: A handler for OS ABI \"%s\" "
 116              "has already been registered for architecture %s",
 117              gdbarch_osabi_name (osabi),
 118              arch_info->printable_name);
 119           /* If user wants to continue, override previous definition.  */
 120           (*handler_p)->init_osabi = init_osabi;
 121           return;
 122         }
 123     }
 124
 125   (*handler_p)
 126     = (struct gdb_osabi_handler *) xmalloc (sizeof (struct gdb_osabi_handler));
 127   (*handler_p)->next = NULL;
 128   (*handler_p)->arch_info = arch_info;
 129   (*handler_p)->osabi = osabi;
 130   (*handler_p)->init_osabi = init_osabi;
 131 }
 132 \f
 133
 134 /* Sniffer to find the OS ABI for a given file's architecture and flavour.
 135    It is legal to have multiple sniffers for each arch/flavour pair, to
 136    disambiguate one OS's a.out from another, for example.  The first sniffer
 137    to return something other than GDB_OSABI_UNKNOWN wins, so a sniffer should
 138    be careful to claim a file only if it knows for sure what it is.  */
 139 struct gdb_osabi_sniffer
 140 {
 141   struct gdb_osabi_sniffer *next;
 142   enum bfd_architecture arch;   /* bfd_arch_unknown == wildcard */
 143   enum bfd_flavour flavour;
 144   enum gdb_osabi (*sniffer)(bfd *);
 145 };
 146
 147 static struct gdb_osabi_sniffer *gdb_osabi_sniffer_list;
 148
 149 void
 150 gdbarch_register_osabi_sniffer (enum bfd_architecture arch,
 151                                 enum bfd_flavour flavour,
 152                                 enum gdb_osabi (*sniffer_fn)(bfd *))
 153 {
 154   struct gdb_osabi_sniffer *sniffer;
 155
 156   sniffer =
 157     (struct gdb_osabi_sniffer *) xmalloc (sizeof (struct gdb_osabi_sniffer));
 158   sniffer->arch = arch;
 159   sniffer->flavour = flavour;
 160   sniffer->sniffer = sniffer_fn;
 161
 162   sniffer->next = gdb_osabi_sniffer_list;
 163   gdb_osabi_sniffer_list = sniffer;
 164 }
 165 \f
 166
 167 enum gdb_osabi
 168 gdbarch_lookup_osabi (bfd *abfd)
 169 {
 170   struct gdb_osabi_sniffer *sniffer;
 171   enum gdb_osabi osabi, match;
 172   int match_specific;
 173
 174   if (abfd == NULL)
 175     return GDB_OSABI_UNINITIALIZED;
 176
 177   match = GDB_OSABI_UNKNOWN;
 178   match_specific = 0;
 179
 180   for (sniffer = gdb_osabi_sniffer_list; sniffer != NULL;
 181        sniffer = sniffer->next)
 182     {
 183       if ((sniffer->arch == bfd_arch_unknown /* wildcard */
 184            || sniffer->arch == bfd_get_arch (abfd))
 185           && sniffer->flavour == bfd_get_flavour (abfd))
 186         {
 187           osabi = (*sniffer->sniffer) (abfd);
 188           if (osabi < GDB_OSABI_UNKNOWN || osabi >= GDB_OSABI_INVALID)
 189             {
 190               internal_error
 191                 (__FILE__, __LINE__,
 192                  "gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer "
 193                  "for architecture %s flavour %d",
 194                  (int) osabi,
 195                  bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
 196                  (int) bfd_get_flavour (abfd));
 197             }
 198           else if (osabi != GDB_OSABI_UNKNOWN)
 199             {
 200               /* A specific sniffer always overrides a generic sniffer.
 201                  Croak on multiple match if the two matches are of the
 202                  same class.  If the user wishes to continue, we'll use
 203                  the first match.  */
 204               if (match != GDB_OSABI_UNKNOWN)
 205                 {
 206                   if ((match_specific && sniffer->arch != bfd_arch_unknown)
 207                    || (!match_specific && sniffer->arch == bfd_arch_unknown))
 208                     {
 209                       internal_error
 210                         (__FILE__, __LINE__,
 211                          "gdbarch_lookup_osabi: multiple %sspecific OS ABI "
 212                          "match for architecture %s flavour %d: first "
 213                          "match \"%s\", second match \"%s\"",
 214                          match_specific ? "" : "non-",
 215                          bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
 216                          (int) bfd_get_flavour (abfd),
 217                          gdbarch_osabi_name (match),
 218                          gdbarch_osabi_name (osabi));
 219                     }
 220                   else if (sniffer->arch != bfd_arch_unknown)
 221                     {
 222                       match = osabi;
 223                       match_specific = 1;
 224                     }
 225                 }
 226               else
 227                 {
 228                   match = osabi;
 229                   if (sniffer->arch != bfd_arch_unknown)
 230                     match_specific = 1;
 231                 }
 232             }
 233         }
 234     }
 235
 236   return match;
 237 }
 238
 239 void
 240 gdbarch_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
 241 {
 242   const struct bfd_arch_info *arch_info = gdbarch_bfd_arch_info (gdbarch);
 243   const struct bfd_arch_info *compatible;
 244   struct gdb_osabi_handler *handler;
 245
 246   if (info.osabi == GDB_OSABI_UNKNOWN)
 247     {
 248       /* Don't complain about an unknown OSABI.  Assume the user knows
 249          what they are doing.  */
 250       return;
 251     }
 252
 253   for (handler = gdb_osabi_handler_list; handler != NULL;
 254        handler = handler->next)
 255     {
 256       if (handler->osabi != info.osabi)
 257         continue;
 258
 259       /* Check whether the machine type and architecture of the
 260          handler are compatible with the desired machine type and
 261          architecture.
 262
 263          NOTE: kettenis/20021027: There may be more than one machine
 264          type that is compatible with the desired machine type.  Right
 265          now we simply return the first match, which is fine for now.
 266          However, we might want to do something smarter in the future.  */
 267       compatible = arch_info->compatible (arch_info, handler->arch_info);
 268       if (compatible == handler->arch_info)
 269         {
 270           (*handler->init_osabi) (info, gdbarch);
 271           return;
 272         }
 273     }
 274
 275   /* We assume that if GDB_MULTI_ARCH is less than GDB_MULTI_ARCH_TM
 276      that an ABI variant can be supported by overriding definitions in
 277      the tm-file.  */
 278   if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
 279     fprintf_filtered
 280       (gdb_stderr,
 281        "A handler for the OS ABI \"%s\" is not built into this "
 282        "configuration of GDB.  "
 283        "Attempting to continue with the default %s settings",
 284        gdbarch_osabi_name (info.osabi),
 285        bfd_printable_arch_mach (arch_info->arch, arch_info->mach));
 286 }
 287 \f
 288
 289 /* Generic sniffer for ELF flavoured files.  */
 290
 291 void
 292 generic_elf_osabi_sniff_abi_tag_sections (bfd *abfd, asection *sect, void *obj)
 293 {
 294   enum gdb_osabi *os_ident_ptr = obj;
 295   const char *name;
 296   unsigned int sectsize;
 297
 298   name = bfd_get_section_name (abfd, sect);
 299   sectsize = bfd_section_size (abfd, sect);
 300
 301   /* .note.ABI-tag notes, used by GNU/Linux and FreeBSD.  */
 302   if (strcmp (name, ".note.ABI-tag") == 0 && sectsize > 0)
 303     {
 304       unsigned int name_length, data_length, note_type;
 305       char *note;
 306
 307       /* If the section is larger than this, it's probably not what we are
 308          looking for.  */
 309       if (sectsize > 128)
 310         sectsize = 128;
 311
 312       note = alloca (sectsize);
 313
 314       bfd_get_section_contents (abfd, sect, note,
 315                                 (file_ptr) 0, (bfd_size_type) sectsize);
 316
 317       name_length = bfd_h_get_32 (abfd, note);
 318       data_length = bfd_h_get_32 (abfd, note + 4);
 319       note_type   = bfd_h_get_32 (abfd, note + 8);
 320
 321       if (name_length == 4 && data_length == 16 && note_type == NT_GNU_ABI_TAG
 322           && strcmp (note + 12, "GNU") == 0)
 323         {
 324           int os_number = bfd_h_get_32 (abfd, note + 16);
 325
 326           switch (os_number)
 327             {
 328             case GNU_ABI_TAG_LINUX:
 329               *os_ident_ptr = GDB_OSABI_LINUX;
 330               break;
 331
 332             case GNU_ABI_TAG_HURD:
 333               *os_ident_ptr = GDB_OSABI_HURD;
 334               break;
 335
 336             case GNU_ABI_TAG_SOLARIS:
 337               *os_ident_ptr = GDB_OSABI_SOLARIS;
 338               break;
 339
 340             default:
 341               internal_error
 342                 (__FILE__, __LINE__,
 343                  "generic_elf_osabi_sniff_abi_tag_sections: unknown OS number %d",
 344                  os_number);
 345             }
 346           return;
 347         }
 348       else if (name_length == 8 && data_length == 4
 349                && note_type == NT_FREEBSD_ABI_TAG
 350                && strcmp (note + 12, "FreeBSD") == 0)
 351         {
 352           /* XXX Should we check the version here?  Probably not
 353              necessary yet.  */
 354           *os_ident_ptr = GDB_OSABI_FREEBSD_ELF;
 355         }
 356       return;
 357     }
 358
 359   /* .note.netbsd.ident notes, used by NetBSD.  */
 360   if (strcmp (name, ".note.netbsd.ident") == 0 && sectsize > 0)
 361     {
 362       unsigned int name_length, data_length, note_type;
 363       char *note;
 364
 365       /* If the section is larger than this, it's probably not what we are
 366          looking for.  */
 367       if (sectsize > 128)
 368         sectsize = 128;
 369
 370       note = alloca (sectsize);
 371
 372       bfd_get_section_contents (abfd, sect, note,
 373                                 (file_ptr) 0, (bfd_size_type) sectsize);
 374
 375       name_length = bfd_h_get_32 (abfd, note);
 376       data_length = bfd_h_get_32 (abfd, note + 4);
 377       note_type   = bfd_h_get_32 (abfd, note + 8);
 378
 379       if (name_length == 7 && data_length == 4 && note_type == NT_NETBSD_IDENT
 380           && strcmp (note + 12, "NetBSD") == 0)
 381         {
 382           /* XXX Should we check the version here?  Probably not
 383              necessary yet.  */
 384           *os_ident_ptr = GDB_OSABI_NETBSD_ELF;
 385         }
 386       return;
 387     }
 388 }
 389
 390 static enum gdb_osabi
 391 generic_elf_osabi_sniffer (bfd *abfd)
 392 {
 393   unsigned int elfosabi;
 394   enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
 395
 396   elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
 397
 398   switch (elfosabi)
 399     {
 400     case ELFOSABI_NONE:
 401       /* When elfosabi is ELFOSABI_NONE (0), then the ELF structures in the
 402          file are conforming to the base specification for that machine
 403          (there are no OS-specific extensions).  In order to determine the
 404          real OS in use we must look for OS notes that have been added.  */
 405       bfd_map_over_sections (abfd,
 406                              generic_elf_osabi_sniff_abi_tag_sections,
 407                              &osabi);
 408       break;
 409
 410     case ELFOSABI_FREEBSD:
 411       osabi = GDB_OSABI_FREEBSD_ELF;
 412       break;
 413
 414     case ELFOSABI_NETBSD:
 415       osabi = GDB_OSABI_NETBSD_ELF;
 416       break;
 417
 418     case ELFOSABI_LINUX:
 419       osabi = GDB_OSABI_LINUX;
 420       break;
 421
 422     case ELFOSABI_HURD:
 423       osabi = GDB_OSABI_HURD;
 424       break;
 425
 426     case ELFOSABI_SOLARIS:
 427       osabi = GDB_OSABI_SOLARIS;
 428       break;
 429
 430     case ELFOSABI_HPUX:
 431       osabi = GDB_OSABI_HPUX_ELF;
 432       break;
 433     }
 434
 435   if (osabi == GDB_OSABI_UNKNOWN)
 436     {
 437       /* The FreeBSD folks have been naughty; they stored the string
 438          "FreeBSD" in the padding of the e_ident field of the ELF
 439          header to "brand" their ELF binaries in FreeBSD 3.x.  */
 440       if (strcmp (&elf_elfheader (abfd)->e_ident[8], "FreeBSD") == 0)
 441         osabi = GDB_OSABI_FREEBSD_ELF;
 442     }
 443
 444   return osabi;
 445 }
 446 \f
 447
 448 void
 449 _initialize_gdb_osabi (void)
 450 {
 451   if (strcmp (gdb_osabi_names[GDB_OSABI_INVALID], "<invalid>") != 0)
 452     internal_error
 453       (__FILE__, __LINE__,
 454        "_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent");
 455
 456   /* Register a generic sniffer for ELF flavoured files.  */
 457   gdbarch_register_osabi_sniffer (bfd_arch_unknown,
 458                                   bfd_target_elf_flavour,
 459                                   generic_elf_osabi_sniffer);
 460 }