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 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/mips.h"
  42
  43 static void
  44 read_alphacoff_dynamic_symtab (struct section_offsets *,
  45                                struct objfile *objfile);
  46
  47 /* Initialize anything that needs initializing when a completely new
  48    symbol file is specified (not just adding some symbols from another
  49    file, e.g. a shared library).  */
  50
  51 static void
  52 mipscoff_new_init (struct objfile *ignore)
  53 {
  54   stabsread_new_init ();
  55   buildsym_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, int mainline)
  69 {
  70   bfd *abfd = objfile->obfd;
  71   struct cleanup *back_to;
  72
  73   init_minimal_symbol_collection ();
  74   back_to = make_cleanup_discard_minimal_symbols ();
  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 (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 (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   install_minimal_symbols (objfile);
  94   do_cleanups (back_to);
  95 }
  96
  97 /* Perform any local cleanups required when we are done with a
  98    particular objfile.  */
  99
 100 static void
 101 mipscoff_symfile_finish (struct objfile *objfile)
 102 {
 103 }
 104
 105 /* Alpha OSF/1 encapsulates the dynamic symbols in ELF format in a
 106    standard COFF section.  The ELF format for the symbols differs from
 107    the format defined in elf/external.h.  It seems that a normal ELF
 108    32-bit format is used, and the representation only changes because
 109    longs are 64-bit on the alpha. In addition, the handling of
 110    text/data section indices for symbols is different from the ELF
 111    ABI.  As the BFD linker currently does not support dynamic linking
 112    on the alpha, there seems to be no reason to pollute BFD with
 113    another mixture of object file formats for now.  */
 114
 115 /* Format of an alpha external ELF symbol.  */
 116
 117 typedef struct
 118 {
 119   unsigned char st_name[4];     /* Symbol name, index in string table.  */
 120   unsigned char st_pad[4];      /* Pad to long word boundary.  */
 121   unsigned char st_value[8];    /* Value of the symbol.  */
 122   unsigned char st_size[4];     /* Associated symbol size.  */
 123   unsigned char st_info[1];     /* Type and binding attributes.  */
 124   unsigned char st_other[1];    /* No defined meaning, 0.  */
 125   unsigned char st_shndx[2];    /* Associated section index.  */
 126 } Elfalpha_External_Sym;
 127
 128 /* Format of an alpha external ELF dynamic info structure.  */
 129
 130 typedef struct
 131 {
 132   unsigned char d_tag[4];       /* Tag.  */
 133   unsigned char d_pad[4];       /* Pad to long word boundary.  */
 134   union
 135   {
 136     unsigned char d_ptr[8];     /* Pointer value.  */
 137     unsigned char d_val[4];     /* Integer value.  */
 138   }
 139   d_un;
 140 } Elfalpha_External_Dyn;
 141
 142 /* Struct to obtain the section pointers for alpha dynamic symbol info.  */
 143
 144 struct alphacoff_dynsecinfo
 145 {
 146   asection *sym_sect;           /* Section pointer for .dynsym section.  */
 147   asection *str_sect;           /* Section pointer for .dynstr section.  */
 148   asection *dyninfo_sect;       /* Section pointer for .dynamic section.  */
 149   asection *got_sect;           /* Section pointer for .got section.  */
 150 };
 151
 152 /* We are called once per section from read_alphacoff_dynamic_symtab.
 153    We need to examine each section we are passed, check to see if it
 154    is something we are interested in processing, and if so, stash away
 155    some access information for the section.  */
 156
 157 static void
 158 alphacoff_locate_sections (bfd *ignore_abfd, asection *sectp, void *sip)
 159 {
 160   struct alphacoff_dynsecinfo *si;
 161
 162   si = (struct alphacoff_dynsecinfo *) sip;
 163
 164   if (strcmp (sectp->name, ".dynsym") == 0)
 165     si->sym_sect = sectp;
 166   else if (strcmp (sectp->name, ".dynstr") == 0)
 167     si->str_sect = sectp;
 168   else if (strcmp (sectp->name, ".dynamic") == 0)
 169     si->dyninfo_sect = sectp;
 170   else if (strcmp (sectp->name, ".got") == 0)
 171       si->got_sect = sectp;
 172 }
 173
 174 /* Scan an alpha dynamic symbol table for symbols of interest and add
 175    them to the minimal symbol table.  */
 176
 177 static void
 178 read_alphacoff_dynamic_symtab (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 = xmalloc (sym_secsize);
 218   cleanups = make_cleanup (free, sym_secptr);
 219   str_secptr = xmalloc (str_secsize);
 220   make_cleanup (free, str_secptr);
 221   dyninfo_secptr = xmalloc (dyninfo_secsize);
 222   make_cleanup (free, dyninfo_secptr);
 223   got_secptr = xmalloc (got_secsize);
 224   make_cleanup (free, got_secptr);
 225
 226   if (!bfd_get_section_contents (abfd, si.sym_sect, sym_secptr,
 227                                  (file_ptr) 0, sym_secsize))
 228     return;
 229   if (!bfd_get_section_contents (abfd, si.str_sect, str_secptr,
 230                                  (file_ptr) 0, str_secsize))
 231     return;
 232   if (!bfd_get_section_contents (abfd, si.dyninfo_sect, dyninfo_secptr,
 233                                  (file_ptr) 0, dyninfo_secsize))
 234     return;
 235   if (!bfd_get_section_contents (abfd, si.got_sect, got_secptr,
 236                                  (file_ptr) 0, got_secsize))
 237     return;
 238
 239   /* Find the number of local GOT entries and the index for the the
 240      first dynamic symbol in the GOT.  */
 241   for (dyninfo_p = dyninfo_secptr, dyninfo_end = dyninfo_p + dyninfo_secsize;
 242        dyninfo_p < dyninfo_end;
 243        dyninfo_p += sizeof (Elfalpha_External_Dyn))
 244     {
 245       Elfalpha_External_Dyn *x_dynp = (Elfalpha_External_Dyn *) dyninfo_p;
 246       long dyn_tag;
 247
 248       dyn_tag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_tag);
 249       if (dyn_tag == DT_NULL)
 250         break;
 251       else if (dyn_tag == DT_MIPS_LOCAL_GOTNO)
 252         {
 253           if (dt_mips_local_gotno < 0)
 254             dt_mips_local_gotno
 255               = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_un.d_val);
 256         }
 257       else if (dyn_tag == DT_MIPS_GOTSYM)
 258         {
 259           if (dt_mips_gotsym < 0)
 260             dt_mips_gotsym
 261               = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_un.d_val);
 262         }
 263     }
 264   if (dt_mips_local_gotno < 0 || dt_mips_gotsym < 0)
 265     return;
 266
 267   /* Scan all dynamic symbols and enter them into the minimal symbol
 268      table if appropriate.  */
 269   sym_count = sym_secsize / sizeof (Elfalpha_External_Sym);
 270   stripped = (bfd_get_symcount (abfd) == 0);
 271
 272   /* Skip first symbol, which is a null dummy.  */
 273   for (i = 1, x_symp = (Elfalpha_External_Sym *) sym_secptr + 1;
 274        i < sym_count;
 275        i++, x_symp++)
 276     {
 277       unsigned long strx;
 278       char *name;
 279       bfd_vma sym_value;
 280       unsigned char sym_info;
 281       unsigned int sym_shndx;
 282       int isglobal;
 283       enum minimal_symbol_type ms_type;
 284
 285       strx = bfd_h_get_32 (abfd, (bfd_byte *) x_symp->st_name);
 286       if (strx >= str_secsize)
 287         continue;
 288       name = str_secptr + strx;
 289       if (*name == '\0' || *name == '.')
 290         continue;
 291
 292       sym_value = bfd_h_get_64 (abfd, (bfd_byte *) x_symp->st_value);
 293       sym_info = bfd_h_get_8 (abfd, (bfd_byte *) x_symp->st_info);
 294       sym_shndx = bfd_h_get_16 (abfd, (bfd_byte *) x_symp->st_shndx);
 295       isglobal = (ELF_ST_BIND (sym_info) == STB_GLOBAL);
 296
 297       if (sym_shndx == SHN_UNDEF)
 298         {
 299           /* Handle undefined functions which are defined in a shared
 300              library.  */
 301           if (ELF_ST_TYPE (sym_info) != STT_FUNC
 302               || ELF_ST_BIND (sym_info) != STB_GLOBAL)
 303             continue;
 304
 305           ms_type = mst_solib_trampoline;
 306
 307           /* If sym_value is nonzero, it points to the shared library
 308              trampoline entry, which is what we are looking for.
 309
 310              If sym_value is zero, then we have to get the GOT entry
 311              for the symbol.
 312
 313              If the GOT entry is nonzero, it represents the quickstart
 314              address of the function and we use that as the symbol
 315              value.
 316
 317              If the GOT entry is zero, the function address has to be
 318              resolved by the runtime loader before the executable is
 319              started.  We are unable to find any meaningful address
 320              for these functions in the executable file, so we skip
 321              them.  */
 322           if (sym_value == 0)
 323             {
 324               int got_entry_offset =
 325                 (i - dt_mips_gotsym + dt_mips_local_gotno) * got_entry_size;
 326
 327               if (got_entry_offset < 0 || got_entry_offset >= got_secsize)
 328                 continue;
 329               sym_value =
 330                 bfd_h_get_64 (abfd,
 331                               (bfd_byte *) (got_secptr + got_entry_offset));
 332               if (sym_value == 0)
 333                 continue;
 334             }
 335         }
 336       else
 337         {
 338           /* Symbols defined in the executable itself. We only care
 339              about them if this is a stripped executable, otherwise
 340              they have been retrieved from the normal symbol table
 341              already.  */
 342           if (!stripped)
 343             continue;
 344
 345           if (sym_shndx == SHN_MIPS_TEXT)
 346             {
 347               if (isglobal)
 348                 ms_type = mst_text;
 349               else
 350                 ms_type = mst_file_text;
 351               sym_value += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
 352             }
 353           else if (sym_shndx == SHN_MIPS_DATA)
 354             {
 355               if (isglobal)
 356                 ms_type = mst_data;
 357               else
 358                 ms_type = mst_file_data;
 359               sym_value += ANOFFSET (section_offsets, SECT_OFF_DATA (objfile));
 360             }
 361           else if (sym_shndx == SHN_MIPS_ACOMMON)
 362             {
 363               if (isglobal)
 364                 ms_type = mst_bss;
 365               else
 366                 ms_type = mst_file_bss;
 367               sym_value += ANOFFSET (section_offsets, SECT_OFF_BSS (objfile));
 368             }
 369           else if (sym_shndx == SHN_ABS)
 370             {
 371               ms_type = mst_abs;
 372             }
 373           else
 374             {
 375               continue;
 376             }
 377         }
 378
 379       prim_record_minimal_symbol (name, sym_value, ms_type, objfile);
 380     }
 381
 382   do_cleanups (cleanups);
 383 }
 384
 385 /* Initialization.  */
 386
 387 static struct sym_fns ecoff_sym_fns =
 388 {
 389   bfd_target_ecoff_flavour,
 390   mipscoff_new_init,            /* sym_new_init: init anything gbl to entire symtab */
 391   mipscoff_symfile_init,        /* sym_init: read initial info, setup for sym_read() */
 392   mipscoff_symfile_read,        /* sym_read: read a symbol file into symtab */
 393   mipscoff_symfile_finish,      /* sym_finish: finished with file, cleanup */
 394   default_symfile_offsets,      /* sym_offsets: dummy FIXME til implem sym reloc */
 395   default_symfile_segments,     /* sym_segments: Get segment information from
 396                                    a file.  */
 397   NULL                          /* next: pointer to next struct sym_fns */
 398 };
 399
 400 /* Provide a prototype to silence -Wmissing-prototypes.  */
 401 void _initialize_mipsread (void);
 402
 403 void
 404 _initialize_mipsread (void)
 405 {
 406   add_symtab_fns (&ecoff_sym_fns);
 407 }