gdb/mipsread.c

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