gdb/mipsread.c

   1 /* Read a symbol table in MIPS' format (Third-Eye).
   2
   3    Copyright (C) 1986-2024 Free Software Foundation, Inc.
   4
   5    Contributed by Alessandro Forin (af@cs.cmu.edu) at CMU.  Major work
   6    by Per Bothner, John Gilmore and Ian Lance Taylor at Cygnus Support.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 /* Read symbols from an ECOFF file.  Most of the work is done in
  24    mdebugread.c.  */
  25
  26 #include "bfd.h"
  27 #include "symtab.h"
  28 #include "objfiles.h"
  29 #include "stabsread.h"
  30 #include "mdebugread.h"
  31
  32 #include "coff/sym.h"
  33 #include "coff/internal.h"
  34 #include "coff/ecoff.h"
  35 #include "libcoff.h"
  36 #include "libecoff.h"
  37 #include "elf/common.h"
  38 #include "elf/internal.h"
  39 #include "elf/mips.h"
  40
  41 static void
  42 read_alphacoff_dynamic_symtab (minimal_symbol_reader &,
  43                                struct objfile *objfile);
  44
  45 /* Initialize anything that needs initializing when a completely new
  46    symbol file is specified (not just adding some symbols from another
  47    file, e.g. a shared library).  */
  48
  49 static void
  50 mipscoff_new_init (struct objfile *ignore)
  51 {
  52   stabsread_new_init ();
  53 }
  54
  55 /* Initialize to read a symbol file (nothing to do).  */
  56
  57 static void
  58 mipscoff_symfile_init (struct objfile *objfile)
  59 {
  60 }
  61
  62 /* Read a symbol file from a file.  */
  63
  64 static void
  65 mipscoff_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags)
  66 {
  67   bfd *abfd = objfile->obfd.get ();
  68
  69   minimal_symbol_reader reader (objfile);
  70
  71   /* Now that the executable file is positioned at symbol table,
  72      process it and define symbols accordingly.  */
  73
  74   if (!((*ecoff_backend (abfd)->debug_swap.read_debug_info)
  75         (abfd, NULL, &ecoff_data (abfd)->debug_info)))
  76     error (_("Error reading symbol table: %s"), bfd_errmsg (bfd_get_error ()));
  77
  78   mdebug_build_psymtabs (reader, objfile, &ecoff_backend (abfd)->debug_swap,
  79                          &ecoff_data (abfd)->debug_info);
  80
  81   /* Add alpha coff dynamic symbols.  */
  82
  83   read_alphacoff_dynamic_symtab (reader, objfile);
  84
  85   /* Install any minimal symbols that have been collected as the current
  86      minimal symbols for this objfile.  */
  87
  88   reader.install ();
  89 }
  90
  91 /* Perform any local cleanups required when we are done with a
  92    particular objfile.  */
  93
  94 static void
  95 mipscoff_symfile_finish (struct objfile *objfile)
  96 {
  97 }
  98
  99 /* Alpha OSF/1 encapsulates the dynamic symbols in ELF format in a
 100    standard COFF section.  The ELF format for the symbols differs from
 101    the format defined in elf/external.h.  It seems that a normal ELF
 102    32-bit format is used, and the representation only changes because
 103    longs are 64-bit on the alpha.  In addition, the handling of
 104    text/data section indices for symbols is different from the ELF
 105    ABI.  As the BFD linker currently does not support dynamic linking
 106    on the alpha, there seems to be no reason to pollute BFD with
 107    another mixture of object file formats for now.  */
 108
 109 /* Format of an alpha external ELF symbol.  */
 110
 111 typedef struct
 112 {
 113   unsigned char st_name[4];     /* Symbol name, index in string table.  */
 114   unsigned char st_pad[4];      /* Pad to long word boundary.  */
 115   unsigned char st_value[8];    /* Value of the symbol.  */
 116   unsigned char st_size[4];     /* Associated symbol size.  */
 117   unsigned char st_info[1];     /* Type and binding attributes.  */
 118   unsigned char st_other[1];    /* No defined meaning, 0.  */
 119   unsigned char st_shndx[2];    /* Associated section index.  */
 120 } Elfalpha_External_Sym;
 121
 122 /* Format of an alpha external ELF dynamic info structure.  */
 123
 124 typedef struct
 125 {
 126   unsigned char d_tag[4];       /* Tag.  */
 127   unsigned char d_pad[4];       /* Pad to long word boundary.  */
 128   union
 129   {
 130     unsigned char d_ptr[8];     /* Pointer value.  */
 131     unsigned char d_val[4];     /* Integer value.  */
 132   }
 133   d_un;
 134 } Elfalpha_External_Dyn;
 135
 136 /* Struct to obtain the section pointers for alpha dynamic symbol info.  */
 137
 138 struct alphacoff_dynsecinfo
 139 {
 140   asection *sym_sect;           /* Section pointer for .dynsym section.  */
 141   asection *str_sect;           /* Section pointer for .dynstr section.  */
 142   asection *dyninfo_sect;       /* Section pointer for .dynamic section.  */
 143   asection *got_sect;           /* Section pointer for .got section.  */
 144 };
 145
 146 /* We are called once per section from read_alphacoff_dynamic_symtab.
 147    We need to examine each section we are passed, check to see if it
 148    is something we are interested in processing, and if so, stash away
 149    some access information for the section.  */
 150
 151 static void
 152 alphacoff_locate_sections (bfd *ignore_abfd, asection *sectp, void *sip)
 153 {
 154   struct alphacoff_dynsecinfo *si;
 155
 156   si = (struct alphacoff_dynsecinfo *) sip;
 157
 158   if (strcmp (sectp->name, ".dynsym") == 0)
 159     si->sym_sect = sectp;
 160   else if (strcmp (sectp->name, ".dynstr") == 0)
 161     si->str_sect = sectp;
 162   else if (strcmp (sectp->name, ".dynamic") == 0)
 163     si->dyninfo_sect = sectp;
 164   else if (strcmp (sectp->name, ".got") == 0)
 165       si->got_sect = sectp;
 166 }
 167
 168 /* Scan an alpha dynamic symbol table for symbols of interest and add
 169    them to the minimal symbol table.  */
 170
 171 static void
 172 read_alphacoff_dynamic_symtab (minimal_symbol_reader &reader,
 173                                struct objfile *objfile)
 174 {
 175   bfd *abfd = objfile->obfd.get ();
 176   struct alphacoff_dynsecinfo si;
 177   int sym_count;
 178   int i;
 179   int stripped;
 180   Elfalpha_External_Sym *x_symp;
 181   gdb_byte *dyninfo_p;
 182   gdb_byte *dyninfo_end;
 183   int got_entry_size = 8;
 184   int dt_mips_local_gotno = -1;
 185   int dt_mips_gotsym = -1;
 186
 187   /* We currently only know how to handle alpha dynamic symbols.  */
 188   if (bfd_get_arch (abfd) != bfd_arch_alpha)
 189     return;
 190
 191   /* Locate the dynamic symbols sections and read them in.  */
 192   memset ((char *) &si, 0, sizeof (si));
 193   bfd_map_over_sections (abfd, alphacoff_locate_sections, (void *) & si);
 194   if (si.sym_sect == NULL || si.str_sect == NULL
 195       || si.dyninfo_sect == NULL || si.got_sect == NULL)
 196     return;
 197
 198   gdb::byte_vector sym_sec (bfd_section_size (si.sym_sect));
 199   gdb::byte_vector str_sec (bfd_section_size (si.str_sect));
 200   gdb::byte_vector dyninfo_sec (bfd_section_size (si.dyninfo_sect));
 201   gdb::byte_vector got_sec (bfd_section_size (si.got_sect));
 202
 203   if (!bfd_get_section_contents (abfd, si.sym_sect, sym_sec.data (),
 204                                  (file_ptr) 0, sym_sec.size ()))
 205     return;
 206   if (!bfd_get_section_contents (abfd, si.str_sect, str_sec.data (),
 207                                  (file_ptr) 0, str_sec.size ()))
 208     return;
 209   if (!bfd_get_section_contents (abfd, si.dyninfo_sect, dyninfo_sec.data (),
 210                                  (file_ptr) 0, dyninfo_sec.size ()))
 211     return;
 212   if (!bfd_get_section_contents (abfd, si.got_sect, got_sec.data (),
 213                                  (file_ptr) 0, got_sec.size ()))
 214     return;
 215
 216   /* Find the number of local GOT entries and the index for the
 217      first dynamic symbol in the GOT.  */
 218   for ((dyninfo_p = dyninfo_sec.data (),
 219         dyninfo_end = dyninfo_p + dyninfo_sec.size ());
 220        dyninfo_p < dyninfo_end;
 221        dyninfo_p += sizeof (Elfalpha_External_Dyn))
 222     {
 223       Elfalpha_External_Dyn *x_dynp = (Elfalpha_External_Dyn *) dyninfo_p;
 224       long dyn_tag;
 225
 226       dyn_tag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_tag);
 227       if (dyn_tag == DT_NULL)
 228         break;
 229       else if (dyn_tag == DT_MIPS_LOCAL_GOTNO)
 230         {
 231           if (dt_mips_local_gotno < 0)
 232             dt_mips_local_gotno
 233               = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_un.d_val);
 234         }
 235       else if (dyn_tag == DT_MIPS_GOTSYM)
 236         {
 237           if (dt_mips_gotsym < 0)
 238             dt_mips_gotsym
 239               = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_un.d_val);
 240         }
 241     }
 242   if (dt_mips_local_gotno < 0 || dt_mips_gotsym < 0)
 243     return;
 244
 245   /* Scan all dynamic symbols and enter them into the minimal symbol
 246      table if appropriate.  */
 247   sym_count = sym_sec.size () / sizeof (Elfalpha_External_Sym);
 248   stripped = (bfd_get_symcount (abfd) == 0);
 249
 250   /* Skip first symbol, which is a null dummy.  */
 251   for (i = 1, x_symp = (Elfalpha_External_Sym *) sym_sec.data () + 1;
 252        i < sym_count;
 253        i++, x_symp++)
 254     {
 255       unsigned long strx;
 256       char *name;
 257       bfd_vma sym_value;
 258       unsigned char sym_info;
 259       unsigned int sym_shndx;
 260       int isglobal;
 261       enum minimal_symbol_type ms_type;
 262
 263       strx = bfd_h_get_32 (abfd, (bfd_byte *) x_symp->st_name);
 264       if (strx >= str_sec.size ())
 265         continue;
 266       name = (char *) (str_sec.data () + strx);
 267       if (*name == '\0' || *name == '.')
 268         continue;
 269
 270       sym_value = bfd_h_get_64 (abfd, (bfd_byte *) x_symp->st_value);
 271       sym_info = bfd_h_get_8 (abfd, (bfd_byte *) x_symp->st_info);
 272       sym_shndx = bfd_h_get_16 (abfd, (bfd_byte *) x_symp->st_shndx);
 273       if (sym_shndx >= (SHN_LORESERVE & 0xffff))
 274         sym_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
 275       isglobal = (ELF_ST_BIND (sym_info) == STB_GLOBAL);
 276
 277       if (sym_shndx == SHN_UNDEF)
 278         {
 279           /* Handle undefined functions which are defined in a shared
 280              library.  */
 281           if (ELF_ST_TYPE (sym_info) != STT_FUNC
 282               || ELF_ST_BIND (sym_info) != STB_GLOBAL)
 283             continue;
 284
 285           ms_type = mst_solib_trampoline;
 286
 287           /* If sym_value is nonzero, it points to the shared library
 288              trampoline entry, which is what we are looking for.
 289
 290              If sym_value is zero, then we have to get the GOT entry
 291              for the symbol.
 292
 293              If the GOT entry is nonzero, it represents the quickstart
 294              address of the function and we use that as the symbol
 295              value.
 296
 297              If the GOT entry is zero, the function address has to be
 298              resolved by the runtime loader before the executable is
 299              started.  We are unable to find any meaningful address
 300              for these functions in the executable file, so we skip
 301              them.  */
 302           if (sym_value == 0)
 303             {
 304               int got_entry_offset =
 305                 (i - dt_mips_gotsym + dt_mips_local_gotno) * got_entry_size;
 306
 307               if (got_entry_offset < 0
 308                   || got_entry_offset >= got_sec.size ())
 309                 continue;
 310               sym_value =
 311                 bfd_h_get_64 (abfd,
 312                               (bfd_byte *) (got_sec.data ()
 313                                             + got_entry_offset));
 314               if (sym_value == 0)
 315                 continue;
 316             }
 317         }
 318       else
 319         {
 320           /* Symbols defined in the executable itself.  We only care
 321              about them if this is a stripped executable, otherwise
 322              they have been retrieved from the normal symbol table
 323              already.  */
 324           if (!stripped)
 325             continue;
 326
 327           if (sym_shndx == SHN_MIPS_TEXT)
 328             {
 329               if (isglobal)
 330                 ms_type = mst_text;
 331               else
 332                 ms_type = mst_file_text;
 333             }
 334           else if (sym_shndx == SHN_MIPS_DATA)
 335             {
 336               if (isglobal)
 337                 ms_type = mst_data;
 338               else
 339                 ms_type = mst_file_data;
 340             }
 341           else if (sym_shndx == SHN_MIPS_ACOMMON)
 342             {
 343               if (isglobal)
 344                 ms_type = mst_bss;
 345               else
 346                 ms_type = mst_file_bss;
 347             }
 348           else if (sym_shndx == SHN_ABS)
 349             {
 350               ms_type = mst_abs;
 351             }
 352           else
 353             {
 354               continue;
 355             }
 356         }
 357
 358       reader.record (name, unrelocated_addr (sym_value), ms_type);
 359     }
 360 }
 361
 362 /* Initialization.  */
 363
 364 static const struct sym_fns ecoff_sym_fns =
 365 {
 366   mipscoff_new_init,            /* init anything gbl to entire symtab */
 367   mipscoff_symfile_init,        /* read initial info, setup for sym_read() */
 368   mipscoff_symfile_read,        /* read a symbol file into symtab */
 369   mipscoff_symfile_finish,      /* finished with file, cleanup */
 370   default_symfile_offsets,      /* dummy FIXME til implem sym reloc */
 371   default_symfile_segments,     /* Get segment information from a file.  */
 372   NULL,
 373   default_symfile_relocate,     /* Relocate a debug section.  */
 374   NULL,                         /* sym_probe_fns */
 375 };
 376
 377 void _initialize_mipsread ();
 378 void
 379 _initialize_mipsread ()
 380 {
 381   add_symtab_fns (bfd_target_ecoff_flavour, &ecoff_sym_fns);
 382 }