gdb/mipsread.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  1. /* Read a symbol table in MIPS' format (Third-Eye).

  3.    Copyright (C) 1986-2015 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.

  8.    This file is part of GDB.

  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.

  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.

  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/>.  */

  23. /* Read symbols from an ECOFF file.  Most of the work is done in
  24.    mdebugread.c.  */

  26. #include "defs.h"
  27. #include "bfd.h"
  28. #include "symtab.h"
  29. #include "objfiles.h"
  30. #include "buildsym.h"
  31. #include "stabsread.h"

  33. #include "coff/sym.h"
  34. #include "coff/internal.h"
  35. #include "coff/ecoff.h"
  36. #include "libcoff.h"                /* Private BFD COFF information.  */
  37. #include "libecoff.h"                /* Private BFD ECOFF information.  */
  38. #include "elf/common.h"
  39. #include "elf/internal.h"
  40. #include "elf/mips.h"

  42. #include "psymtab.h"

  44. static void
  45. read_alphacoff_dynamic_symtab (struct section_offsets *,
  46.                                struct objfile *objfile);

  48. /* Initialize anything that needs initializing when a completely new
  49.    symbol file is specified (not just adding some symbols from another
  50.    file, e.g. a shared library).  */

  52. static void
  53. ‌mipscoff_new_init (struct objfile *ignore)
  54. {
  55.   stabsread_new_init ();
  56.   buildsym_new_init ();
  57. }

  59. /* Initialize to read a symbol file (nothing to do).  */

  61. static void
  62. ‌mipscoff_symfile_init (struct objfile *objfile)
  63. {
  64. }

  66. /* Read a symbol file from a file.  */

  68. static void
  69. ‌mipscoff_symfile_read (struct objfile *objfile, int symfile_flags)
  70. {
  71.   bfd *abfd = objfile->obfd;
  72.   struct cleanup *back_to;

  74.   init_minimal_symbol_collection ();
  75.   back_to = make_cleanup_discard_minimal_symbols ();

  77.   /* Now that the executable file is positioned at symbol table,
  78.      process it and define symbols accordingly.  */

  80.   if (!((*ecoff_backend (abfd)->debug_swap.read_debug_info)
  81.         (abfd, (asection *) NULL, &ecoff_data (abfd)->debug_info)))
  82.     error (_("Error reading symbol table: %s"), bfd_errmsg (bfd_get_error ()));

  84.   mdebug_build_psymtabs (objfile, &ecoff_backend (abfd)->debug_swap,
  85.                          &ecoff_data (abfd)->debug_info);

  87.   /* Add alpha coff dynamic symbols.  */

  89.   read_alphacoff_dynamic_symtab (objfile->section_offsets, objfile);

  91.   /* Install any minimal symbols that have been collected as the current
  92.      minimal symbols for this objfile.  */

  94.   install_minimal_symbols (objfile);
  95.   do_cleanups (back_to);
  96. }

  98. /* Perform any local cleanups required when we are done with a
  99.    particular objfile.  */

  101. static void
  102. ‌mipscoff_symfile_finish (struct objfile *objfile)
  103. {
  104. }

  106. /* Alpha OSF/1 encapsulates the dynamic symbols in ELF format in a
  107.    standard COFF section.  The ELF format for the symbols differs from
  108.    the format defined in elf/external.h.  It seems that a normal ELF
  109.    32-bit format is used, and the representation only changes because
  110.    longs are 64-bit on the alpha.  In addition, the handling of
  111.    text/data section indices for symbols is different from the ELF
  112.    ABI.  As the BFD linker currently does not support dynamic linking
  113.    on the alpha, there seems to be no reason to pollute BFD with
  114.    another mixture of object file formats for now.  */

  116. /* Format of an alpha external ELF symbol.  */

  118. typedef struct
  119. {
  120.   unsigned char st_name[4];        /* Symbol name, index in string table.  */
  121.   unsigned char st_pad[4];        /* Pad to long word boundary.  */
  122.   unsigned char st_value[8];        /* Value of the symbol.  */
  123.   unsigned char st_size[4];        /* Associated symbol size.  */
  124.   unsigned char st_info[1];        /* Type and binding attributes.  */
  125.   unsigned char st_other[1];        /* No defined meaning, 0.  */
  126.   unsigned char st_shndx[2];        /* Associated section index.  */
  127. ‌} Elfalpha_External_Sym;

  129. /* Format of an alpha external ELF dynamic info structure.  */

  131. typedef struct
  132. {
  133.   unsigned char d_tag[4];        /* Tag.  */
  134.   unsigned char d_pad[4];        /* Pad to long word boundary.  */
  135.   union
  136.   {
  137.     unsigned char d_ptr[8];        /* Pointer value.  */
  138.     unsigned char d_val[4];        /* Integer value.  */
  139.   }
  140.   d_un;
  141. ‌} Elfalpha_External_Dyn;

  143. /* Struct to obtain the section pointers for alpha dynamic symbol info.  */

  145. ‌struct alphacoff_dynsecinfo
  146. {
  147.   asection *sym_sect;                /* Section pointer for .dynsym section.  */
  148.   asection *str_sect;                /* Section pointer for .dynstr section.  */
  149.   asection *dyninfo_sect;        /* Section pointer for .dynamic section.  */
  150.   asection *got_sect;                /* Section pointer for .got section.  */
  151. };

  153. /* We are called once per section from read_alphacoff_dynamic_symtab.
  154.    We need to examine each section we are passed, check to see if it
  155.    is something we are interested in processing, and if so, stash away
  156.    some access information for the section.  */

  158. static void
  159. ‌alphacoff_locate_sections (bfd *ignore_abfd, asection *sectp, void *sip)
  160. {
  161.   struct alphacoff_dynsecinfo *si;

  163.   si = (struct alphacoff_dynsecinfo *) sip;

  165.   if (strcmp (sectp->name, ".dynsym") == 0)
  166.     si->sym_sect = sectp;
  167.   else if (strcmp (sectp->name, ".dynstr") == 0)
  168.     si->str_sect = sectp;
  169.   else if (strcmp (sectp->name, ".dynamic") == 0)
  170.     si->dyninfo_sect = sectp;
  171.   else if (strcmp (sectp->name, ".got") == 0)
  172.       si->got_sect = sectp;
  173. }

  175. /* Scan an alpha dynamic symbol table for symbols of interest and add
  176.    them to the minimal symbol table.  */

  178. static void
  179. ‌read_alphacoff_dynamic_symtab (struct section_offsets *section_offsets,
  180.                                struct objfile *objfile)
  181. {
  182.   bfd *abfd = objfile->obfd;
  183.   struct alphacoff_dynsecinfo si;
  184.   char *sym_secptr;
  185.   char *str_secptr;
  186.   char *dyninfo_secptr;
  187.   char *got_secptr;
  188.   bfd_size_type sym_secsize;
  189.   bfd_size_type str_secsize;
  190.   bfd_size_type dyninfo_secsize;
  191.   bfd_size_type got_secsize;
  192.   int sym_count;
  193.   int i;
  194.   int stripped;
  195.   Elfalpha_External_Sym *x_symp;
  196.   char *dyninfo_p;
  197.   char *dyninfo_end;
  198.   int got_entry_size = 8;
  199.   int dt_mips_local_gotno = -1;
  200.   int dt_mips_gotsym = -1;
  201.   struct cleanup *cleanups;

  203.   /* We currently only know how to handle alpha dynamic symbols.  */
  204.   if (bfd_get_arch (abfd) != bfd_arch_alpha)
  205.     return;

  207.   /* Locate the dynamic symbols sections and read them in.  */
  208.   memset ((char *) &si, 0, sizeof (si));
  209.   bfd_map_over_sections (abfd, alphacoff_locate_sections, (void *) & si);
  210.   if (si.sym_sect == NULL || si.str_sect == NULL
  211.       || si.dyninfo_sect == NULL || si.got_sect == NULL)
  212.     return;

  214.   sym_secsize = bfd_get_section_size (si.sym_sect);
  215.   str_secsize = bfd_get_section_size (si.str_sect);
  216.   dyninfo_secsize = bfd_get_section_size (si.dyninfo_sect);
  217.   got_secsize = bfd_get_section_size (si.got_sect);
  218.   sym_secptr = xmalloc (sym_secsize);
  219.   cleanups = make_cleanup (xfree, sym_secptr);
  220.   str_secptr = xmalloc (str_secsize);
  221.   make_cleanup (xfree, str_secptr);
  222.   dyninfo_secptr = xmalloc (dyninfo_secsize);
  223.   make_cleanup (xfree, dyninfo_secptr);
  224.   got_secptr = xmalloc (got_secsize);
  225.   make_cleanup (xfree, got_secptr);

  227.   if (!bfd_get_section_contents (abfd, si.sym_sect, sym_secptr,
  228.                                  (file_ptr) 0, sym_secsize))
  229.     {
  230.       do_cleanups (cleanups);
  231.       return;
  232.     }
  233.   if (!bfd_get_section_contents (abfd, si.str_sect, str_secptr,
  234.                                  (file_ptr) 0, str_secsize))
  235.     {
  236.       do_cleanups (cleanups);
  237.       return;
  238.     }
  239.   if (!bfd_get_section_contents (abfd, si.dyninfo_sect, dyninfo_secptr,
  240.                                  (file_ptr) 0, dyninfo_secsize))
  241.     {
  242.       do_cleanups (cleanups);
  243.       return;
  244.     }
  245.   if (!bfd_get_section_contents (abfd, si.got_sect, got_secptr,
  246.                                  (file_ptr) 0, got_secsize))
  247.     {
  248.       do_cleanups (cleanups);
  249.       return;
  250.     }

  252.   /* Find the number of local GOT entries and the index for the
  253.      first dynamic symbol in the GOT.  */
  254.   for (dyninfo_p = dyninfo_secptr, dyninfo_end = dyninfo_p + dyninfo_secsize;
  255.        dyninfo_p < dyninfo_end;
  256.        dyninfo_p += sizeof (Elfalpha_External_Dyn))
  257.     {
  258.       Elfalpha_External_Dyn *x_dynp = (Elfalpha_External_Dyn *) dyninfo_p;
  259.       long dyn_tag;

  261.       dyn_tag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_tag);
  262.       if (dyn_tag == DT_NULL)
  263.         break;
  264.       else if (dyn_tag == DT_MIPS_LOCAL_GOTNO)
  265.         {
  266.           if (dt_mips_local_gotno < 0)
  267.             dt_mips_local_gotno
  268.               = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_un.d_val);
  269.         }
  270.       else if (dyn_tag == DT_MIPS_GOTSYM)
  271.         {
  272.           if (dt_mips_gotsym < 0)
  273.             dt_mips_gotsym
  274.               = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_un.d_val);
  275.         }
  276.     }
  277.   if (dt_mips_local_gotno < 0 || dt_mips_gotsym < 0)
  278.     {
  279.       do_cleanups (cleanups);
  280.       return;
  281.     }

  283.   /* Scan all dynamic symbols and enter them into the minimal symbol
  284.      table if appropriate.  */
  285.   sym_count = sym_secsize / sizeof (Elfalpha_External_Sym);
  286.   stripped = (bfd_get_symcount (abfd) == 0);

  288.   /* Skip first symbol, which is a null dummy.  */
  289.   for (i = 1, x_symp = (Elfalpha_External_Sym *) sym_secptr + 1;
  290.        i < sym_count;
  291.        i++, x_symp++)
  292.     {
  293.       unsigned long strx;
  294.       char *name;
  295.       bfd_vma sym_value;
  296.       unsigned char sym_info;
  297.       unsigned int sym_shndx;
  298.       int isglobal;
  299.       enum minimal_symbol_type ms_type;

  301.       strx = bfd_h_get_32 (abfd, (bfd_byte *) x_symp->st_name);
  302.       if (strx >= str_secsize)
  303.         continue;
  304.       name = str_secptr + strx;
  305.       if (*name == '\0' || *name == '.')
  306.         continue;

  308.       sym_value = bfd_h_get_64 (abfd, (bfd_byte *) x_symp->st_value);
  309.       sym_info = bfd_h_get_8 (abfd, (bfd_byte *) x_symp->st_info);
  310.       sym_shndx = bfd_h_get_16 (abfd, (bfd_byte *) x_symp->st_shndx);
  311.       if (sym_shndx >= (SHN_LORESERVE & 0xffff))
  312.         sym_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
  313.       isglobal = (ELF_ST_BIND (sym_info) == STB_GLOBAL);

  315.       if (sym_shndx == SHN_UNDEF)
  316.         {
  317.           /* Handle undefined functions which are defined in a shared
  318.              library.  */
  319.           if (ELF_ST_TYPE (sym_info) != STT_FUNC
  320.               || ELF_ST_BIND (sym_info) != STB_GLOBAL)
  321.             continue;

  323.           ms_type = mst_solib_trampoline;

  325.           /* If sym_value is nonzero, it points to the shared library
  326.              trampoline entry, which is what we are looking for.

  328.              If sym_value is zero, then we have to get the GOT entry
  329.              for the symbol.

  331.              If the GOT entry is nonzero, it represents the quickstart
  332.              address of the function and we use that as the symbol
  333.              value.

  335.              If the GOT entry is zero, the function address has to be
  336.              resolved by the runtime loader before the executable is
  337.              started.  We are unable to find any meaningful address
  338.              for these functions in the executable file, so we skip
  339.              them.  */
  340.           if (sym_value == 0)
  341.             {
  342.               int got_entry_offset =
  343.                 (i - dt_mips_gotsym + dt_mips_local_gotno) * got_entry_size;

  345.               if (got_entry_offset < 0 || got_entry_offset >= got_secsize)
  346.                 continue;
  347.               sym_value =
  348.                 bfd_h_get_64 (abfd,
  349.                               (bfd_byte *) (got_secptr + got_entry_offset));
  350.               if (sym_value == 0)
  351.                 continue;
  352.             }
  353.         }
  354.       else
  355.         {
  356.           /* Symbols defined in the executable itself.  We only care
  357.              about them if this is a stripped executable, otherwise
  358.              they have been retrieved from the normal symbol table
  359.              already.  */
  360.           if (!stripped)
  361.             continue;

  363.           if (sym_shndx == SHN_MIPS_TEXT)
  364.             {
  365.               if (isglobal)
  366.                 ms_type = mst_text;
  367.               else
  368.                 ms_type = mst_file_text;
  369.             }
  370.           else if (sym_shndx == SHN_MIPS_DATA)
  371.             {
  372.               if (isglobal)
  373.                 ms_type = mst_data;
  374.               else
  375.                 ms_type = mst_file_data;
  376.             }
  377.           else if (sym_shndx == SHN_MIPS_ACOMMON)
  378.             {
  379.               if (isglobal)
  380.                 ms_type = mst_bss;
  381.               else
  382.                 ms_type = mst_file_bss;
  383.             }
  384.           else if (sym_shndx == SHN_ABS)
  385.             {
  386.               ms_type = mst_abs;
  387.             }
  388.           else
  389.             {
  390.               continue;
  391.             }
  392.         }

  394.       prim_record_minimal_symbol (name, sym_value, ms_type, objfile);
  395.     }

  397.   do_cleanups (cleanups);
  398. }

  400. /* Initialization.  */

  402. ‌static const struct sym_fns ecoff_sym_fns =
  403. {
  404.   mipscoff_new_init,                /* init anything gbl to entire symtab */
  405.   mipscoff_symfile_init,        /* read initial info, setup for sym_read() */
  406.   mipscoff_symfile_read,        /* read a symbol file into symtab */
  407.   NULL,                                /* sym_read_psymbols */
  408.   mipscoff_symfile_finish,        /* finished with file, cleanup */
  409.   default_symfile_offsets,        /* dummy FIXME til implem sym reloc */
  410.   default_symfile_segments,        /* Get segment information from a file.  */
  411.   NULL,
  412.   default_symfile_relocate,        /* Relocate a debug section.  */
  413.   NULL,                                /* sym_probe_fns */
  414.   &psym_functions
  415. };

  417. /* Provide a prototype to silence -Wmissing-prototypes.  */
  418. void _initialize_mipsread (void);

  420. void
  421. ‌_initialize_mipsread (void)
  422. {
  423.   add_symtab_fns (bfd_target_ecoff_flavour, &ecoff_sym_fns);
  424. }