Subversion Repositories openrisc_2011-10-31

/* Read coff symbol tables and convert to internal format, for GDB.

   Copyright (C) 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,

   1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008

   Free Software Foundation, Inc.

   Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu).

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"

#include "symtab.h"

#include "gdbtypes.h"

#include "demangle.h"

#include "breakpoint.h"

#include "bfd.h"

#include "gdb_obstack.h"

#include "gdb_string.h"

#include <ctype.h>

#include "coff/internal.h"      /* Internal format of COFF symbols in BFD */

#include "libcoff.h"            /* FIXME secret internal data from BFD */

#include "objfiles.h"

#include "buildsym.h"

#include "gdb-stabs.h"

#include "stabsread.h"

#include "complaints.h"

#include "target.h"

#include "gdb_assert.h"

#include "block.h"

#include "dictionary.h"

#include "coff-pe-read.h"

extern void _initialize_coffread (void);

struct coff_symfile_info

  {

    file_ptr min_lineno_offset; /* Where in file lowest line#s are */

    file_ptr max_lineno_offset; /* 1+last byte of line#s in file */

    CORE_ADDR textaddr;         /* Addr of .text section. */

    unsigned int textsize;      /* Size of .text section. */

    struct stab_section_list *stabsects;        /* .stab sections.  */

    asection *stabstrsect;      /* Section pointer for .stab section */

    char *stabstrdata;

  };

/* Translate an external name string into a user-visible name.  */

#define EXTERNAL_NAME(string, abfd) \

        (string[0] == bfd_get_symbol_leading_char(abfd)? string+1: string)

/* To be an sdb debug type, type must have at least a basic or primary

   derived type.  Using this rather than checking against T_NULL is

   said to prevent core dumps if we try to operate on Michael Bloom

   dbx-in-coff file.  */

#define SDB_TYPE(type) (BTYPE(type) | (type & N_TMASK))

/* Core address of start and end of text of current source file.

   This comes from a ".text" symbol where x_nlinno > 0.  */

static CORE_ADDR current_source_start_addr;

static CORE_ADDR current_source_end_addr;

/* The addresses of the symbol table stream and number of symbols

   of the object file we are reading (as copied into core).  */

static bfd *nlist_bfd_global;

static int nlist_nsyms_global;

/* Pointers to scratch storage, used for reading raw symbols and auxents.  */

static char *temp_sym;

static char *temp_aux;

/* Local variables that hold the shift and mask values for the

   COFF file that we are currently reading.  These come back to us

   from BFD, and are referenced by their macro names, as well as

   internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF

   macros from include/coff/internal.h .  */

static unsigned local_n_btmask;

static unsigned local_n_btshft;

static unsigned local_n_tmask;

static unsigned local_n_tshift;

#define N_BTMASK        local_n_btmask

#define N_BTSHFT        local_n_btshft

#define N_TMASK         local_n_tmask

#define N_TSHIFT        local_n_tshift

/* Local variables that hold the sizes in the file of various COFF structures.

   (We only need to know this to read them from the file -- BFD will then

   translate the data in them, into `internal_xxx' structs in the right

   byte order, alignment, etc.)  */

static unsigned local_linesz;

static unsigned local_symesz;

static unsigned local_auxesz;

/* This is set if this is a PE format file.  */

static int pe_file;

/* Chain of typedefs of pointers to empty struct/union types.

   They are chained thru the SYMBOL_VALUE_CHAIN.  */

static struct symbol *opaque_type_chain[HASHSIZE];

/* Simplified internal version of coff symbol table information */

struct coff_symbol

  {

    char *c_name;

    int c_symnum;               /* symbol number of this entry */

    int c_naux;                 /* 0 if syment only, 1 if syment + auxent, etc */

    long c_value;

    int c_sclass;

    int c_secnum;

    unsigned int c_type;

  };

extern void stabsread_clear_cache (void);

static struct type *coff_read_struct_type (int, int, int);

static struct type *decode_base_type (struct coff_symbol *,

                                      unsigned int, union internal_auxent *);

static struct type *decode_type (struct coff_symbol *, unsigned int,

                                 union internal_auxent *);

static struct type *decode_function_type (struct coff_symbol *,

                                          unsigned int,

                                          union internal_auxent *);

static struct type *coff_read_enum_type (int, int, int);

static struct symbol *process_coff_symbol (struct coff_symbol *,

                                           union internal_auxent *,

                                           struct objfile *);

static void patch_opaque_types (struct symtab *);

static void enter_linenos (long, int, int, struct objfile *);

static void free_linetab (void);

static void free_linetab_cleanup (void *ignore);

static int init_lineno (bfd *, long, int);

static char *getsymname (struct internal_syment *);

static char *coff_getfilename (union internal_auxent *);

static void free_stringtab (void);

static void free_stringtab_cleanup (void *ignore);

static int init_stringtab (bfd *, long);

static void read_one_sym (struct coff_symbol *,

                          struct internal_syment *, union internal_auxent *);

static void coff_symtab_read (long, unsigned int, struct objfile *);

/* We are called once per section from coff_symfile_read.  We

   need to examine each section we are passed, check to see

   if it is something we are interested in processing, and

   if so, stash away some access information for the section.

   FIXME: The section names should not be hardwired strings (what

   should they be?  I don't think most object file formats have enough

   section flags to specify what kind of debug section it is

   -kingdon).  */

static void

coff_locate_sections (bfd *abfd, asection *sectp, void *csip)

{

  struct coff_symfile_info *csi;

  const char *name;

  csi = (struct coff_symfile_info *) csip;

  name = bfd_get_section_name (abfd, sectp);

  if (strcmp (name, ".text") == 0)

    {

      csi->textaddr = bfd_section_vma (abfd, sectp);

      csi->textsize += bfd_section_size (abfd, sectp);

    }

  else if (strncmp (name, ".text", sizeof ".text" - 1) == 0)

    {

      csi->textsize += bfd_section_size (abfd, sectp);

    }

  else if (strcmp (name, ".stabstr") == 0)

    {

      csi->stabstrsect = sectp;

    }

  else if (strncmp (name, ".stab", sizeof ".stab" - 1) == 0)

    {

      const char *s;

      /* We can have multiple .stab sections if linked with

         --split-by-reloc.  */

      for (s = name + sizeof ".stab" - 1; *s != '\0'; s++)

        if (!isdigit (*s))

          break;

      if (*s == '\0')

        {

          struct stab_section_list *n, **pn;

          n = ((struct stab_section_list *)

               xmalloc (sizeof (struct stab_section_list)));

          n->section = sectp;

          n->next = NULL;

          for (pn = &csi->stabsects; *pn != NULL; pn = &(*pn)->next)

            ;

          *pn = n;

          /* This will be run after coffstab_build_psymtabs is called

             in coff_symfile_read, at which point we no longer need

             the information.  */

          make_cleanup (xfree, n);

        }

    }

}

/* Return the section_offsets* that CS points to.  */

static int cs_to_section (struct coff_symbol *, struct objfile *);

struct find_targ_sec_arg

  {

    int targ_index;

    asection **resultp;

  };

static void

find_targ_sec (bfd *abfd, asection *sect, void *obj)

{

  struct find_targ_sec_arg *args = (struct find_targ_sec_arg *) obj;

  if (sect->target_index == args->targ_index)

    *args->resultp = sect;

}

/* Return the bfd_section that CS points to.  */

static struct bfd_section*

cs_to_bfd_section (struct coff_symbol *cs, struct objfile *objfile)

{

  asection *sect = NULL;

  struct find_targ_sec_arg args;

  args.targ_index = cs->c_secnum;

  args.resultp = §

  bfd_map_over_sections (objfile->obfd, find_targ_sec, &args);

  return sect;

}

/* Return the section number (SECT_OFF_*) that CS points to.  */

static int

cs_to_section (struct coff_symbol *cs, struct objfile *objfile)

{

  asection *sect = cs_to_bfd_section (cs, objfile);

  if (sect == NULL)

    return SECT_OFF_TEXT (objfile);

  return sect->index;

}

/* Return the address of the section of a COFF symbol.  */

static CORE_ADDR cs_section_address (struct coff_symbol *, bfd *);

static CORE_ADDR

cs_section_address (struct coff_symbol *cs, bfd *abfd)

{

  asection *sect = NULL;

  struct find_targ_sec_arg args;

  CORE_ADDR addr = 0;

  args.targ_index = cs->c_secnum;

  args.resultp = §

  bfd_map_over_sections (abfd, find_targ_sec, &args);

  if (sect != NULL)

    addr = bfd_get_section_vma (objfile->obfd, sect);

  return addr;

}

/* Look up a coff type-number index.  Return the address of the slot

   where the type for that index is stored.

   The type-number is in INDEX.

   This can be used for finding the type associated with that index

   or for associating a new type with the index.  */

static struct type **

coff_lookup_type (int index)

{

  if (index >= type_vector_length)

    {

      int old_vector_length = type_vector_length;

      type_vector_length *= 2;

      if (index /* is still */  >= type_vector_length)

        type_vector_length = index * 2;

      type_vector = (struct type **)

        xrealloc ((char *) type_vector,

                  type_vector_length * sizeof (struct type *));

      memset (&type_vector[old_vector_length], 0,

         (type_vector_length - old_vector_length) * sizeof (struct type *));

    }

  return &type_vector[index];

}

/* Make sure there is a type allocated for type number index

   and return the type object.

   This can create an empty (zeroed) type object.  */

static struct type *

coff_alloc_type (int index)

{

  struct type **type_addr = coff_lookup_type (index);

  struct type *type = *type_addr;

  /* If we are referring to a type not known at all yet,

     allocate an empty type for it.

     We will fill it in later if we find out how.  */

  if (type == NULL)

    {

      type = alloc_type (current_objfile);

      *type_addr = type;

    }

  return type;

}

/* Start a new symtab for a new source file.

   This is called when a COFF ".file" symbol is seen;

   it indicates the start of data for one original source file.  */

static void

coff_start_symtab (char *name)

{

  start_symtab (

  /* We fill in the filename later.  start_symtab puts

     this pointer into last_source_file and we put it in

     subfiles->name, which end_symtab frees; that's why

     it must be malloc'd.  */

                 savestring (name, strlen (name)),

  /* We never know the directory name for COFF.  */

                 NULL,

  /* The start address is irrelevant, since we set

     last_source_start_addr in coff_end_symtab.  */

                 0);

  record_debugformat ("COFF");

}

/* Save the vital information from when starting to read a file,

   for use when closing off the current file.

   NAME is the file name the symbols came from, START_ADDR is the first

   text address for the file, and SIZE is the number of bytes of text.  */

static void

complete_symtab (char *name, CORE_ADDR start_addr, unsigned int size)

{

  if (last_source_file != NULL)

    xfree (last_source_file);

  last_source_file = savestring (name, strlen (name));

  current_source_start_addr = start_addr;

  current_source_end_addr = start_addr + size;

}

/* Finish the symbol definitions for one main source file,

   close off all the lexical contexts for that file

   (creating struct block's for them), then make the

   struct symtab for that file and put it in the list of all such. */

static void

coff_end_symtab (struct objfile *objfile)

{

  struct symtab *symtab;

  last_source_start_addr = current_source_start_addr;

  symtab = end_symtab (current_source_end_addr, objfile, SECT_OFF_TEXT (objfile));

  if (symtab != NULL)

    free_named_symtabs (symtab->filename);

  /* Reinitialize for beginning of new file. */

  last_source_file = NULL;

}

static struct minimal_symbol *

record_minimal_symbol (struct coff_symbol *cs, CORE_ADDR address,

                       enum minimal_symbol_type type, int section,

                       struct objfile *objfile)

{

  struct bfd_section *bfd_section;

  /* We don't want TDESC entry points in the minimal symbol table */

  if (cs->c_name[0] == '@')

    return NULL;

  bfd_section = cs_to_bfd_section (cs, objfile);

  return prim_record_minimal_symbol_and_info (cs->c_name, address, type,

    NULL, section, bfd_section, objfile);

}

/* coff_symfile_init ()

   is the coff-specific initialization routine for reading symbols.

   It is passed a struct objfile which contains, among other things,

   the BFD for the file whose symbols are being read, and a slot for

   a pointer to "private data" which we fill with cookies and other

   treats for coff_symfile_read ().

   We will only be called if this is a COFF or COFF-like file.

   BFD handles figuring out the format of the file, and code in symtab.c

   uses BFD's determination to vector to us.

   The ultimate result is a new symtab (or, FIXME, eventually a psymtab).  */

static void

coff_symfile_init (struct objfile *objfile)

{

  /* Allocate struct to keep track of stab reading. */

  objfile->deprecated_sym_stab_info = (struct dbx_symfile_info *)

    xmalloc (sizeof (struct dbx_symfile_info));

  memset (objfile->deprecated_sym_stab_info, 0,

          sizeof (struct dbx_symfile_info));

  /* Allocate struct to keep track of the symfile */

  objfile->deprecated_sym_private = xmalloc (sizeof (struct coff_symfile_info));

  memset (objfile->deprecated_sym_private, 0, sizeof (struct coff_symfile_info));

  /* COFF objects may be reordered, so set OBJF_REORDERED.  If we

     find this causes a significant slowdown in gdb then we could

     set it in the debug symbol readers only when necessary.  */

  objfile->flags |= OBJF_REORDERED;

  init_entry_point_info (objfile);

}

/* This function is called for every section; it finds the outer limits

   of the line table (minimum and maximum file offset) so that the

   mainline code can read the whole thing for efficiency.  */

static void

find_linenos (bfd *abfd, struct bfd_section *asect, void *vpinfo)

{

  struct coff_symfile_info *info;

  int size, count;

  file_ptr offset, maxoff;

/* WARNING WILL ROBINSON!  ACCESSING BFD-PRIVATE DATA HERE!  FIXME!  */

  count = asect->lineno_count;

/* End of warning */

  if (count == 0)

    return;

  size = count * local_linesz;

  info = (struct coff_symfile_info *) vpinfo;

/* WARNING WILL ROBINSON!  ACCESSING BFD-PRIVATE DATA HERE!  FIXME!  */

  offset = asect->line_filepos;

/* End of warning */

  if (offset < info->min_lineno_offset || info->min_lineno_offset == 0)

    info->min_lineno_offset = offset;

  maxoff = offset + size;

  if (maxoff > info->max_lineno_offset)

    info->max_lineno_offset = maxoff;

}

/* The BFD for this file -- only good while we're actively reading

   symbols into a psymtab or a symtab.  */

static bfd *symfile_bfd;

/* Read a symbol file, after initialization by coff_symfile_init.  */

static void

coff_symfile_read (struct objfile *objfile, int mainline)

{

  struct coff_symfile_info *info;

  struct dbx_symfile_info *dbxinfo;

  bfd *abfd = objfile->obfd;

  coff_data_type *cdata = coff_data (abfd);

  char *name = bfd_get_filename (abfd);

  int val;

  unsigned int num_symbols;

  int symtab_offset;

  int stringtab_offset;

  struct cleanup *back_to, *cleanup_minimal_symbols;

  int stabstrsize;

  int len;

  char * target;

  info = (struct coff_symfile_info *) objfile->deprecated_sym_private;

  dbxinfo = objfile->deprecated_sym_stab_info;

  symfile_bfd = abfd;           /* Kludge for swap routines */

/* WARNING WILL ROBINSON!  ACCESSING BFD-PRIVATE DATA HERE!  FIXME!  */

  num_symbols = bfd_get_symcount (abfd);        /* How many syms */

  symtab_offset = cdata->sym_filepos;   /* Symbol table file offset */

  stringtab_offset = symtab_offset +    /* String table file offset */

    num_symbols * cdata->local_symesz;

  /* Set a few file-statics that give us specific information about

     the particular COFF file format we're reading.  */

  local_n_btmask = cdata->local_n_btmask;

  local_n_btshft = cdata->local_n_btshft;

  local_n_tmask = cdata->local_n_tmask;

  local_n_tshift = cdata->local_n_tshift;

  local_linesz = cdata->local_linesz;

  local_symesz = cdata->local_symesz;

  local_auxesz = cdata->local_auxesz;

  /* Allocate space for raw symbol and aux entries, based on their

     space requirements as reported by BFD.  */

  temp_sym = (char *) xmalloc

    (cdata->local_symesz + cdata->local_auxesz);

  temp_aux = temp_sym + cdata->local_symesz;

  back_to = make_cleanup (free_current_contents, &temp_sym);

  /* We need to know whether this is a PE file, because in PE files,

     unlike standard COFF files, symbol values are stored as offsets

     from the section address, rather than as absolute addresses.

     FIXME: We should use BFD to read the symbol table, and thus avoid

     this problem.  */

  pe_file =

    strncmp (bfd_get_target (objfile->obfd), "pe", 2) == 0

    || strncmp (bfd_get_target (objfile->obfd), "epoc-pe", 7) == 0;

/* End of warning */

  info->min_lineno_offset = 0;

  info->max_lineno_offset = 0;

  /* Only read line number information if we have symbols.

     On Windows NT, some of the system's DLL's have sections with

     PointerToLinenumbers fields that are non-zero, but point at

     random places within the image file.  (In the case I found,

     KERNEL32.DLL's .text section has a line number info pointer that

     points into the middle of the string `lib\\i386\kernel32.dll'.)

     However, these DLL's also have no symbols.  The line number

     tables are meaningless without symbols.  And in fact, GDB never

     uses the line number information unless there are symbols.  So we

     can avoid spurious error messages (and maybe run a little

     faster!) by not even reading the line number table unless we have

     symbols.  */

  if (num_symbols > 0)

    {

      /* Read the line number table, all at once.  */

      bfd_map_over_sections (abfd, find_linenos, (void *) info);

      make_cleanup (free_linetab_cleanup, 0 /*ignore*/);

      val = init_lineno (abfd, info->min_lineno_offset,

                         info->max_lineno_offset - info->min_lineno_offset);

      if (val < 0)

        error (_("\"%s\": error reading line numbers."), name);

    }

  /* Now read the string table, all at once.  */

  make_cleanup (free_stringtab_cleanup, 0 /*ignore*/);

  val = init_stringtab (abfd, stringtab_offset);

  if (val < 0)

    error (_("\"%s\": can't get string table"), name);

  init_minimal_symbol_collection ();

  cleanup_minimal_symbols = make_cleanup_discard_minimal_symbols ();

  /* Now that the executable file is positioned at symbol table,

     process it and define symbols accordingly.  */

  coff_symtab_read ((long) symtab_offset, num_symbols, objfile);

  /* Install any minimal symbols that have been collected as the current

     minimal symbols for this objfile.  */

  install_minimal_symbols (objfile);

  /* Free the installed minimal symbol data.  */

  do_cleanups (cleanup_minimal_symbols);

  /* If we are reinitializing, or if we have not loaded syms yet,

     empty the psymtab.  "mainline" is cleared so the *_read_psymtab

     functions do not all re-initialize it.  */

  if (mainline)

    {

      init_psymbol_list (objfile, 0);

      mainline = 0;

    }

  bfd_map_over_sections (abfd, coff_locate_sections, (void *) info);

  if (info->stabsects)

    {

      if (!info->stabstrsect)

        {

          error (_("The debugging information in `%s' is corrupted.\n"

                   "The file has a `.stabs' section, but no `.stabstr' section."),

                 name);

        }

      /* FIXME: dubious.  Why can't we use something normal like

         bfd_get_section_contents?  */

      bfd_seek (abfd, abfd->where, 0);

      stabstrsize = bfd_section_size (abfd, info->stabstrsect);

      coffstab_build_psymtabs (objfile,

                               mainline,

                               info->textaddr, info->textsize,

                               info->stabsects,

                               info->stabstrsect->filepos, stabstrsize);

    }

  if (dwarf2_has_info (objfile))

    {

      /* DWARF2 sections.  */

      dwarf2_build_psymtabs (objfile, mainline);

    }

  dwarf2_build_frame_info (objfile);

  do_cleanups (back_to);

}

static void

coff_new_init (struct objfile *ignore)

{

}

/* Perform any local cleanups required when we are done with a particular

   objfile.  I.E, we are in the process of discarding all symbol information

   for an objfile, freeing up all memory held for it, and unlinking the

   objfile struct from the global list of known objfiles. */

static void

coff_symfile_finish (struct objfile *objfile)

{

  if (objfile->deprecated_sym_private != NULL)

    {

      xfree (objfile->deprecated_sym_private);

    }

  /* Let stabs reader clean up */

  stabsread_clear_cache ();

  dwarf2_free_objfile (objfile);

}

/* Given pointers to a symbol table in coff style exec file,

   analyze them and create struct symtab's describing the symbols.

   NSYMS is the number of symbols in the symbol table.

   We read them one at a time using read_one_sym ().  */

static void

coff_symtab_read (long symtab_offset, unsigned int nsyms,

                  struct objfile *objfile)

{

  struct context_stack *new;

  struct coff_symbol coff_symbol;

  struct coff_symbol *cs = &coff_symbol;

  static struct internal_syment main_sym;

  static union internal_auxent main_aux;

  struct coff_symbol fcn_cs_saved;

  static struct internal_syment fcn_sym_saved;

  static union internal_auxent fcn_aux_saved;

  struct symtab *s;

  /* A .file is open.  */

  int in_source_file = 0;

  int next_file_symnum = -1;

  /* Name of the current file.  */

  char *filestring = "";

  int depth = 0;

  int fcn_first_line = 0;

  CORE_ADDR fcn_first_line_addr = 0;

  int fcn_last_line = 0;

  int fcn_start_addr = 0;

  long fcn_line_ptr = 0;

  int val;

  CORE_ADDR tmpaddr;

  struct minimal_symbol *msym;

  /* Work around a stdio bug in SunOS4.1.1 (this makes me nervous....

     it's hard to know I've really worked around it.  The fix should be

     harmless, anyway).  The symptom of the bug is that the first

     fread (in read_one_sym), will (in my example) actually get data

     from file offset 268, when the fseek was to 264 (and ftell shows

     264).  This causes all hell to break loose.  I was unable to

     reproduce this on a short test program which operated on the same

     file, performing (I think) the same sequence of operations.

     It stopped happening when I put in this (former) rewind().