Subversion Repositories openrisc_me

/* Read a symbol table in ECOFF format (Third-Eye).

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

   1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009, 2010

   Free Software Foundation, Inc.

   Original version contributed by Alessandro Forin (af@cs.cmu.edu) at

   CMU.  Major work by Per Bothner, John Gilmore and Ian Lance Taylor

   at Cygnus Support.

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

/* This module provides the function mdebug_build_psymtabs.  It reads

   ECOFF debugging information into partial symbol tables.  The

   debugging information is read from two structures.  A struct

   ecoff_debug_swap includes the sizes of each ECOFF structure and

   swapping routines; these are fixed for a particular target.  A

   struct ecoff_debug_info points to the debugging information for a

   particular object file.

   ECOFF symbol tables are mostly written in the byte order of the

   target machine.  However, one section of the table (the auxiliary

   symbol information) is written in the host byte order.  There is a

   bit in the other symbol info which describes which host byte order

   was used.  ECOFF thereby takes the trophy from Intel `b.out' for

   the most brain-dead adaptation of a file format to byte order.

   This module can read all four of the known byte-order combinations,

   on any type of host.  */

#include "defs.h"

#include "symtab.h"

#include "gdbtypes.h"

#include "gdbcore.h"

#include "objfiles.h"

#include "gdb_obstack.h"

#include "buildsym.h"

#include "stabsread.h"

#include "complaints.h"

#include "demangle.h"

#include "gdb_assert.h"

#include "block.h"

#include "dictionary.h"

#include "mdebugread.h"

#include "gdb_stat.h"

#include "gdb_string.h"

#include "psympriv.h"

#include "bfd.h"

#include "coff/ecoff.h"         /* COFF-like aspects of ecoff files */

#include "libaout.h"            /* Private BFD a.out information.  */

#include "aout/aout64.h"

#include "aout/stab_gnu.h"      /* STABS information */

#include "expression.h"

extern void _initialize_mdebugread (void);

/* Provide a way to test if we have both ECOFF and ELF symbol tables.

   We use this define in order to know whether we should override a

   symbol's ECOFF section with its ELF section.  This is necessary in

   case the symbol's ELF section could not be represented in ECOFF.  */

#define ECOFF_IN_ELF(bfd) (bfd_get_flavour (bfd) == bfd_target_elf_flavour \

                           && bfd_get_section_by_name (bfd, ".mdebug") != NULL)

/* We put a pointer to this structure in the read_symtab_private field

   of the psymtab.  */

struct symloc

  {

    /* Index of the FDR that this psymtab represents.  */

    int fdr_idx;

    /* The BFD that the psymtab was created from.  */

    bfd *cur_bfd;

    const struct ecoff_debug_swap *debug_swap;

    struct ecoff_debug_info *debug_info;

    struct mdebug_pending **pending_list;

    /* Pointer to external symbols for this file.  */

    EXTR *extern_tab;

    /* Size of extern_tab.  */

    int extern_count;

    enum language pst_language;

  };

#define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)

#define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)

#define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)

#define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)

#define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)

#define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)

#define SC_IS_TEXT(sc) ((sc) == scText \

                   || (sc) == scRConst \

                   || (sc) == scInit \

                   || (sc) == scFini)

#define SC_IS_DATA(sc) ((sc) == scData \

                   || (sc) == scSData \

                   || (sc) == scRData \

                   || (sc) == scPData \

                   || (sc) == scXData)

#define SC_IS_COMMON(sc) ((sc) == scCommon || (sc) == scSCommon)

#define SC_IS_BSS(sc) ((sc) == scBss)

#define SC_IS_SBSS(sc) ((sc) == scSBss)

#define SC_IS_UNDEF(sc) ((sc) == scUndefined || (sc) == scSUndefined)

/* Various complaints about symbol reading that don't abort the process */

static void

index_complaint (const char *arg1)

{

  complaint (&symfile_complaints, _("bad aux index at symbol %s"), arg1);

}

static void

unknown_ext_complaint (const char *arg1)

{

  complaint (&symfile_complaints, _("unknown external symbol %s"), arg1);

}

static void

basic_type_complaint (int arg1, const char *arg2)

{

  complaint (&symfile_complaints, _("cannot map ECOFF basic type 0x%x for %s"),

             arg1, arg2);

}

static void

bad_tag_guess_complaint (const char *arg1)

{

  complaint (&symfile_complaints, _("guessed tag type of %s incorrectly"), arg1);

}

static void

bad_rfd_entry_complaint (const char *arg1, int arg2, int arg3)

{

  complaint (&symfile_complaints, _("bad rfd entry for %s: file %d, index %d"),

             arg1, arg2, arg3);

}

static void

unexpected_type_code_complaint (const char *arg1)

{

  complaint (&symfile_complaints, _("unexpected type code for %s"), arg1);

}

/* Macros and extra defs */

/* Puns: hard to find whether -g was used and how */

#define MIN_GLEVEL GLEVEL_0

#define compare_glevel(a,b)                                     \

        (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) :                 \

         ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))

/* Things that really are local to this module */

/* Remember what we deduced to be the source language of this psymtab. */

static enum language psymtab_language = language_unknown;

/* Current BFD.  */

static bfd *cur_bfd;

/* How to parse debugging information for CUR_BFD.  */

static const struct ecoff_debug_swap *debug_swap;

/* Pointers to debugging information for CUR_BFD.  */

static struct ecoff_debug_info *debug_info;

/* Pointer to current file decriptor record, and its index */

static FDR *cur_fdr;

static int cur_fd;

/* Index of current symbol */

static int cur_sdx;

/* Note how much "debuggable" this image is.  We would like

   to see at least one FDR with full symbols */

static int max_gdbinfo;

static int max_glevel;

/* When examining .o files, report on undefined symbols */

static int n_undef_symbols, n_undef_labels, n_undef_vars, n_undef_procs;

/* Pseudo symbol to use when putting stabs into the symbol table.  */

static char stabs_symbol[] = STABS_SYMBOL;

/* Nonzero if we have seen ecoff debugging info for a file.  */

static int found_ecoff_debugging_info;

/* Forward declarations */

static int upgrade_type (int, struct type **, int, union aux_ext *,

                         int, char *);

static void parse_partial_symbols (struct objfile *);

static int has_opaque_xref (FDR *, SYMR *);

static int cross_ref (int, union aux_ext *, struct type **, enum type_code,

                      char **, int, char *);

static struct symbol *new_symbol (char *);

static struct type *new_type (char *);

enum block_type { FUNCTION_BLOCK, NON_FUNCTION_BLOCK };

static struct block *new_block (enum block_type);

static struct symtab *new_symtab (char *, int, struct objfile *);

static struct linetable *new_linetable (int);

static struct blockvector *new_bvect (int);

static struct type *parse_type (int, union aux_ext *, unsigned int, int *,

                                int, char *);

static struct symbol *mylookup_symbol (char *, struct block *, domain_enum,

                                       enum address_class);

static void sort_blocks (struct symtab *);

static struct partial_symtab *new_psymtab (char *, struct objfile *);

static void psymtab_to_symtab_1 (struct partial_symtab *, char *);

static void add_block (struct block *, struct symtab *);

static void add_symbol (struct symbol *, struct symtab *, struct block *);

static int add_line (struct linetable *, int, CORE_ADDR, int);

static struct linetable *shrink_linetable (struct linetable *);

static void handle_psymbol_enumerators (struct objfile *, FDR *, int,

                                        CORE_ADDR);

static char *mdebug_next_symbol_text (struct objfile *);

/* Exported procedure: Builds a symtab from the PST partial one.

   Restores the environment in effect when PST was created, delegates

   most of the work to an ancillary procedure, and sorts

   and reorders the symtab list at the end */

static void

mdebug_psymtab_to_symtab (struct partial_symtab *pst)

{

  if (!pst)

    return;

  if (info_verbose)

    {

      printf_filtered (_("Reading in symbols for %s..."), pst->filename);

      gdb_flush (gdb_stdout);

    }

  next_symbol_text_func = mdebug_next_symbol_text;

  psymtab_to_symtab_1 (pst, pst->filename);

  /* Match with global symbols.  This only needs to be done once,

     after all of the symtabs and dependencies have been read in.   */

  scan_file_globals (pst->objfile);

  if (info_verbose)

    printf_filtered (_("done.\n"));

}

/* File-level interface functions */

/* Find a file descriptor given its index RF relative to a file CF */

static FDR *

get_rfd (int cf, int rf)

{

  FDR *fdrs;

  FDR *f;

  RFDT rfd;

  fdrs = debug_info->fdr;

  f = fdrs + cf;

  /* Object files do not have the RFD table, all refs are absolute */

  if (f->rfdBase == 0)

    return fdrs + rf;

  (*debug_swap->swap_rfd_in) (cur_bfd,

                              ((char *) debug_info->external_rfd

                               + ((f->rfdBase + rf)

                                  * debug_swap->external_rfd_size)),

                              &rfd);

  return fdrs + rfd;

}

/* Return a safer print NAME for a file descriptor */

static char *

fdr_name (FDR *f)

{

  if (f->rss == -1)

    return "<stripped file>";

  if (f->rss == 0)

    return "<NFY>";

  return debug_info->ss + f->issBase + f->rss;

}

/* Read in and parse the symtab of the file OBJFILE.  Symbols from

   different sections are relocated via the SECTION_OFFSETS.  */

void

mdebug_build_psymtabs (struct objfile *objfile,

                       const struct ecoff_debug_swap *swap,

                       struct ecoff_debug_info *info)

{

  cur_bfd = objfile->obfd;

  debug_swap = swap;

  debug_info = info;

  stabsread_new_init ();

  buildsym_new_init ();

  free_header_files ();

  init_header_files ();

  /* Make sure all the FDR information is swapped in.  */

  if (info->fdr == (FDR *) NULL)

    {

      char *fdr_src;

      char *fdr_end;

      FDR *fdr_ptr;

      info->fdr = (FDR *) obstack_alloc (&objfile->objfile_obstack,

                                         (info->symbolic_header.ifdMax

                                          * sizeof (FDR)));

      fdr_src = info->external_fdr;

      fdr_end = (fdr_src

                 + info->symbolic_header.ifdMax * swap->external_fdr_size);

      fdr_ptr = info->fdr;

      for (; fdr_src < fdr_end; fdr_src += swap->external_fdr_size, fdr_ptr++)

        (*swap->swap_fdr_in) (objfile->obfd, fdr_src, fdr_ptr);

    }

  parse_partial_symbols (objfile);

#if 0

  /* Check to make sure file was compiled with -g.  If not, warn the

     user of this limitation.  */

  if (compare_glevel (max_glevel, GLEVEL_2) < 0)

    {

      if (max_gdbinfo == 0)

        printf_unfiltered (_("\n%s not compiled with -g, debugging support is limited.\n"),

                           objfile->name);

      printf_unfiltered (_("You should compile with -g2 or -g3 for best debugging support.\n"));

      gdb_flush (gdb_stdout);

    }

#endif

}

/* Local utilities */

/* Map of FDR indexes to partial symtabs */

struct pst_map

{

  struct partial_symtab *pst;   /* the psymtab proper */

  long n_globals;               /* exported globals (external symbols) */

  long globals_offset;          /* cumulative */

};

/* Utility stack, used to nest procedures and blocks properly.

   It is a doubly linked list, to avoid too many alloc/free.

   Since we might need it quite a few times it is NOT deallocated

   after use. */

static struct parse_stack

  {

    struct parse_stack *next, *prev;

    struct symtab *cur_st;      /* Current symtab. */

    struct block *cur_block;    /* Block in it. */

    /* What are we parsing.  stFile, or stBlock are for files and

       blocks.  stProc or stStaticProc means we have seen the start of a

       procedure, but not the start of the block within in.  When we see

       the start of that block, we change it to stNil, without pushing a

       new block, i.e. stNil means both a procedure and a block.  */

    int blocktype;

    struct type *cur_type;      /* Type we parse fields for. */

    int cur_field;              /* Field number in cur_type. */

    CORE_ADDR procadr;          /* Start addres of this procedure */

    int numargs;                /* Its argument count */

  }

 *top_stack;                    /* Top stack ptr */

/* Enter a new lexical context */

static void

push_parse_stack (void)

{

  struct parse_stack *new;

  /* Reuse frames if possible */

  if (top_stack && top_stack->prev)

    new = top_stack->prev;

  else

    new = (struct parse_stack *) xzalloc (sizeof (struct parse_stack));

  /* Initialize new frame with previous content */

  if (top_stack)

    {

      struct parse_stack *prev = new->prev;

      *new = *top_stack;

      top_stack->prev = new;

      new->prev = prev;

      new->next = top_stack;

    }

  top_stack = new;

}

/* Exit a lexical context */

static void

pop_parse_stack (void)

{

  if (!top_stack)

    return;

  if (top_stack->next)

    top_stack = top_stack->next;

}

/* Cross-references might be to things we haven't looked at

   yet, e.g. type references.  To avoid too many type

   duplications we keep a quick fixup table, an array

   of lists of references indexed by file descriptor */

struct mdebug_pending

{

  struct mdebug_pending *next;  /* link */

  char *s;                      /* the unswapped symbol */

  struct type *t;               /* its partial type descriptor */

};

/* The pending information is kept for an entire object file, and used

   to be in the deprecated_sym_private field.  I took it out when I

   split mdebugread from mipsread, because this might not be the only

   type of symbols read from an object file.  Instead, we allocate the

   pending information table when we create the partial symbols, and

   we store a pointer to the single table in each psymtab.  */

static struct mdebug_pending **pending_list;

/* Check whether we already saw symbol SH in file FH */

static struct mdebug_pending *

is_pending_symbol (FDR *fh, char *sh)

{

  int f_idx = fh - debug_info->fdr;

  struct mdebug_pending *p;

  /* Linear search is ok, list is typically no more than 10 deep */

  for (p = pending_list[f_idx]; p; p = p->next)

    if (p->s == sh)

      break;

  return p;

}

/* Add a new symbol SH of type T */

static void

add_pending (FDR *fh, char *sh, struct type *t)

{

  int f_idx = fh - debug_info->fdr;

  struct mdebug_pending *p = is_pending_symbol (fh, sh);

  /* Make sure we do not make duplicates */

  if (!p)

    {

      p = ((struct mdebug_pending *)

           obstack_alloc (&current_objfile->objfile_obstack,

                          sizeof (struct mdebug_pending)));

      p->s = sh;

      p->t = t;

      p->next = pending_list[f_idx];

      pending_list[f_idx] = p;

    }

}

/* Parsing Routines proper. */

/* Parse a single symbol. Mostly just make up a GDB symbol for it.

   For blocks, procedures and types we open a new lexical context.

   This is basically just a big switch on the symbol's type.  Argument

   AX is the base pointer of aux symbols for this file (fh->iauxBase).

   EXT_SH points to the unswapped symbol, which is needed for struct,

   union, etc., types; it is NULL for an EXTR.  BIGEND says whether

   aux symbols are big-endian or little-endian.  Return count of

   SYMR's handled (normally one).  */

static int

mdebug_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch)

{

  return gdbarch_ecoff_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));

}

static const struct symbol_register_ops mdebug_register_funcs = {

  mdebug_reg_to_regnum

};

static int

parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,

              struct section_offsets *section_offsets, struct objfile *objfile)

{

  struct gdbarch *gdbarch = get_objfile_arch (objfile);

  const bfd_size_type external_sym_size = debug_swap->external_sym_size;

  void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;

  char *name;

  struct symbol *s;

  struct block *b;

  struct mdebug_pending *pend;

  struct type *t;

  struct field *f;

  int count = 1;

  enum address_class class;

  TIR tir;

  long svalue = sh->value;

  int bitsize;

  if (ext_sh == (char *) NULL)

    name = debug_info->ssext + sh->iss;

  else

    name = debug_info->ss + cur_fdr->issBase + sh->iss;

  switch (sh->sc)

    {

    case scText:

    case scRConst:

      /* Do not relocate relative values.

         The value of a stEnd symbol is the displacement from the

         corresponding start symbol value.

         The value of a stBlock symbol is the displacement from the

         procedure address.  */

      if (sh->st != stEnd && sh->st != stBlock)

        sh->value += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));

      break;

    case scData:

    case scSData:

    case scRData:

    case scPData:

    case scXData:

      sh->value += ANOFFSET (section_offsets, SECT_OFF_DATA (objfile));

      break;

    case scBss:

    case scSBss:

      sh->value += ANOFFSET (section_offsets, SECT_OFF_BSS (objfile));

      break;

    }

  switch (sh->st)

    {

    case stNil:

      break;

    case stGlobal:              /* external symbol, goes into global block */

      class = LOC_STATIC;

      b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),

                             GLOBAL_BLOCK);

      s = new_symbol (name);

      SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;

      goto data;

    case stStatic:              /* static data, goes into current block. */

      class = LOC_STATIC;

      b = top_stack->cur_block;

      s = new_symbol (name);

      if (SC_IS_COMMON (sh->sc))

        {

          /* It is a FORTRAN common block.  At least for SGI Fortran the

             address is not in the symbol; we need to fix it later in

             scan_file_globals.  */

          int bucket = hashname (SYMBOL_LINKAGE_NAME (s));

          SYMBOL_VALUE_CHAIN (s) = global_sym_chain[bucket];

          global_sym_chain[bucket] = s;

        }

      else

        SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;

      goto data;

    case stLocal:               /* local variable, goes into current block */

      b = top_stack->cur_block;

      s = new_symbol (name);

      SYMBOL_VALUE (s) = svalue;

      if (sh->sc == scRegister)

        {

          class = LOC_REGISTER;

          SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;

        }

      else

        class = LOC_LOCAL;

    data:                       /* Common code for symbols describing data */

      SYMBOL_DOMAIN (s) = VAR_DOMAIN;

      SYMBOL_CLASS (s) = class;

      add_symbol (s, top_stack->cur_st, b);

      /* Type could be missing if file is compiled without debugging info.  */

      if (SC_IS_UNDEF (sh->sc)

          || sh->sc == scNil || sh->index == indexNil)

        SYMBOL_TYPE (s) = objfile_type (objfile)->nodebug_data_symbol;

      else

        SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);

      /* Value of a data symbol is its memory address */

      break;

    case stParam:               /* arg to procedure, goes into current block */

      max_gdbinfo++;

      found_ecoff_debugging_info = 1;

      top_stack->numargs++;

      /* Special GNU C++ name.  */

      if (is_cplus_marker (name[0]) && name[1] == 't' && name[2] == 0)

        name = "this";          /* FIXME, not alloc'd in obstack */

      s = new_symbol (name);

      SYMBOL_DOMAIN (s) = VAR_DOMAIN;

      SYMBOL_IS_ARGUMENT (s) = 1;

      switch (sh->sc)

        {

        case scRegister:

          /* Pass by value in register.  */

          SYMBOL_CLASS (s) = LOC_REGISTER;

          SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;

          break;

        case scVar:

          /* Pass by reference on stack.  */

          SYMBOL_CLASS (s) = LOC_REF_ARG;

          break;

        case scVarRegister:

          /* Pass by reference in register.  */

          SYMBOL_CLASS (s) = LOC_REGPARM_ADDR;

          SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;

          break;

        default:

          /* Pass by value on stack.  */

          SYMBOL_CLASS (s) = LOC_ARG;

          break;

        }

      SYMBOL_VALUE (s) = svalue;

      SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);

      add_symbol (s, top_stack->cur_st, top_stack->cur_block);

      break;

    case stLabel:               /* label, goes into current block */

      s = new_symbol (name);

      SYMBOL_DOMAIN (s) = VAR_DOMAIN;   /* so that it can be used */

      SYMBOL_CLASS (s) = LOC_LABEL;     /* but not misused */

      SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;

      SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_int;

      add_symbol (s, top_stack->cur_st, top_stack->cur_block);

      break;

    case stProc:                /* Procedure, usually goes into global block */

    case stStaticProc:          /* Static procedure, goes into current block */

      /* For stProc symbol records, we need to check the storage class

         as well, as only (stProc, scText) entries represent "real"

         procedures - See the Compaq document titled "Object File /

         Symbol Table Format Specification" for more information.

         If the storage class is not scText, we discard the whole block

         of symbol records for this stProc.  */

      if (sh->st == stProc && sh->sc != scText)

        {

          char *ext_tsym = ext_sh;

          int keep_counting = 1;

          SYMR tsym;