gdb/mipsread.c

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