gdb/mipsread.c

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