gdb/mipsread.c

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