gdb/mipsread.c

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