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
   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 2 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, write to the Free Software
  24    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  25    Boston, MA 02110-1301, USA.  */
  26
  27 /* Read symbols from an ECOFF file.  Most of the work is done in
  28    mdebugread.c.  */
  29
  30 #include "defs.h"
  31 #include "gdb_string.h"
  32 #include "bfd.h"
  33 #include "symtab.h"
  34 #include "objfiles.h"
  35 #include "buildsym.h"
  36 #include "stabsread.h"
  37
  38 #include "coff/sym.h"
  39 #include "coff/internal.h"
  40 #include "coff/ecoff.h"
  41 #include "libcoff.h"            /* Private BFD COFF information.  */
  42 #include "libecoff.h"           /* Private BFD ECOFF information.  */
  43 #include "elf/common.h"
  44 #include "elf/mips.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 mainline)
  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 (free, sym_secptr);
 222   str_secptr = xmalloc (str_secsize);
 223   make_cleanup (free, str_secptr);
 224   dyninfo_secptr = xmalloc (dyninfo_secsize);
 225   make_cleanup (free, dyninfo_secptr);
 226   got_secptr = xmalloc (got_secsize);
 227   make_cleanup (free, 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 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       isglobal = (ELF_ST_BIND (sym_info) == STB_GLOBAL);
 299
 300       if (sym_shndx == SHN_UNDEF)
 301         {
 302           /* Handle undefined functions which are defined in a shared
 303              library.  */
 304           if (ELF_ST_TYPE (sym_info) != STT_FUNC
 305               || ELF_ST_BIND (sym_info) != STB_GLOBAL)
 306             continue;
 307
 308           ms_type = mst_solib_trampoline;
 309
 310           /* If sym_value is nonzero, it points to the shared library
 311              trampoline entry, which is what we are looking for.
 312
 313              If sym_value is zero, then we have to get the GOT entry
 314              for the symbol.
 315
 316              If the GOT entry is nonzero, it represents the quickstart
 317              address of the function and we use that as the symbol
 318              value.
 319
 320              If the GOT entry is zero, the function address has to be
 321              resolved by the runtime loader before the executable is
 322              started.  We are unable to find any meaningful address
 323              for these functions in the executable file, so we skip
 324              them.  */
 325           if (sym_value == 0)
 326             {
 327               int got_entry_offset =
 328                 (i - dt_mips_gotsym + dt_mips_local_gotno) * got_entry_size;
 329
 330               if (got_entry_offset < 0 || got_entry_offset >= got_secsize)
 331                 continue;
 332               sym_value =
 333                 bfd_h_get_64 (abfd,
 334                               (bfd_byte *) (got_secptr + got_entry_offset));
 335               if (sym_value == 0)
 336                 continue;
 337             }
 338         }
 339       else
 340         {
 341           /* Symbols defined in the executable itself. We only care
 342              about them if this is a stripped executable, otherwise
 343              they have been retrieved from the normal symbol table
 344              already.  */
 345           if (!stripped)
 346             continue;
 347
 348           if (sym_shndx == SHN_MIPS_TEXT)
 349             {
 350               if (isglobal)
 351                 ms_type = mst_text;
 352               else
 353                 ms_type = mst_file_text;
 354               sym_value += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
 355             }
 356           else if (sym_shndx == SHN_MIPS_DATA)
 357             {
 358               if (isglobal)
 359                 ms_type = mst_data;
 360               else
 361                 ms_type = mst_file_data;
 362               sym_value += ANOFFSET (section_offsets, SECT_OFF_DATA (objfile));
 363             }
 364           else if (sym_shndx == SHN_MIPS_ACOMMON)
 365             {
 366               if (isglobal)
 367                 ms_type = mst_bss;
 368               else
 369                 ms_type = mst_file_bss;
 370               sym_value += ANOFFSET (section_offsets, SECT_OFF_BSS (objfile));
 371             }
 372           else if (sym_shndx == SHN_ABS)
 373             {
 374               ms_type = mst_abs;
 375             }
 376           else
 377             {
 378               continue;
 379             }
 380         }
 381
 382       prim_record_minimal_symbol (name, sym_value, ms_type, objfile);
 383     }
 384
 385   do_cleanups (cleanups);
 386 }
 387
 388 /* Initialization.  */
 389
 390 static struct sym_fns ecoff_sym_fns =
 391 {
 392   bfd_target_ecoff_flavour,
 393   mipscoff_new_init,            /* sym_new_init: init anything gbl to entire symtab */
 394   mipscoff_symfile_init,        /* sym_init: read initial info, setup for sym_read() */
 395   mipscoff_symfile_read,        /* sym_read: read a symbol file into symtab */
 396   mipscoff_symfile_finish,      /* sym_finish: finished with file, cleanup */
 397   default_symfile_offsets,      /* sym_offsets: dummy FIXME til implem sym reloc */
 398   NULL                          /* next: pointer to next struct sym_fns */
 399 };
 400
 401 /* Provide a prototype to silence -Wmissing-prototypes.  */
 402 void _initialize_mipsread (void);
 403
 404 void
 405 _initialize_mipsread (void)
 406 {
 407   add_symtab_fns (&ecoff_sym_fns);
 408 }