gdb/mipsread.c

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