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