Subversion Repositories or1k

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

   Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,

   1996, 1997, 1998, 1999, 2000, 2001

   Free Software Foundation, Inc.

   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 2 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, write to the Free Software

   Foundation, Inc., 59 Temple Place - Suite 330,

   Boston, MA 02111-1307, USA.  */

/* This module provides three functions: os9k_symfile_init,

   which initializes to read a symbol file; os9k_new_init, which

   discards existing cached information when all symbols are being

   discarded; and os9k_symfile_read, which reads a symbol table

   from a file.

   os9k_symfile_read only does the minimum work necessary for letting the

   user "name" things symbolically; it does not read the entire symtab.

   Instead, it reads the external and static symbols and puts them in partial

   symbol tables.  When more extensive information is requested of a

   file, the corresponding partial symbol table is mutated into a full

   fledged symbol table by going back and reading the symbols

   for real.  os9k_psymtab_to_symtab() is the function that does this */

#include "defs.h"

#include "gdb_string.h"

#include "gdb_assert.h"

#include <stdio.h>

#if defined(USG) || defined(__CYGNUSCLIB__)

#include <sys/types.h>

#include <fcntl.h>

#endif

#include "obstack.h"

#include "gdb_stat.h"

#include "symtab.h"

#include "breakpoint.h"

#include "command.h"

#include "target.h"

#include "gdbcore.h"            /* for bfd stuff */

#include "libaout.h"            /* FIXME Secret internal BFD stuff for a.out */

#include "symfile.h"

#include "objfiles.h"

#include "buildsym.h"

#include "gdb-stabs.h"

#include "demangle.h"

#include "language.h"           /* Needed inside partial-stab.h */

#include "complaints.h"

#include "os9k.h"

#include "stabsread.h"

extern void _initialize_os9kread (void);

/* Each partial symbol table entry contains a pointer to private data for the

   read_symtab() function to use when expanding a partial symbol table entry

   to a full symbol table entry.

   For dbxread this structure contains the offset within the file symbol table

   of first local symbol for this file, and count of the section

   of the symbol table devoted to this file's symbols (actually, the section

   bracketed may contain more than just this file's symbols).  It also contains

   further information needed to locate the symbols if they are in an ELF file.

   If ldsymcnt is 0, the only reason for this thing's existence is the

   dependency list.  Nothing else will happen when it is read in.  */

#define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)

#define LDSYMCNT(p) (((struct symloc *)((p)->read_symtab_private))->ldsymnum)

struct symloc

  {

    int ldsymoff;

    int ldsymnum;

  };

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

static enum language psymtab_language = language_unknown;

/* keep partial symbol table file nested depth */

static int psymfile_depth = 0;

/* keep symbol table file nested depth */

static int symfile_depth = 0;

/* Nonzero means give verbose info on gdb action.  From main.c.  */

extern int info_verbose;

extern int previous_stab_code;

/* Name of last function encountered.  Used in Solaris to approximate

   object file boundaries.  */

static char *last_function_name;

/* Complaints about the symbols we have encountered.  */

extern struct complaint lbrac_complaint;

extern struct complaint unknown_symtype_complaint;

extern struct complaint unknown_symchar_complaint;

extern struct complaint lbrac_rbrac_complaint;

extern struct complaint repeated_header_complaint;

extern struct complaint repeated_header_name_complaint;

#if 0

static struct complaint lbrac_unmatched_complaint =

{"unmatched Increment Block Entry before symtab pos %d", 0, 0};

static struct complaint lbrac_mismatch_complaint =

{"IBE/IDE symbol mismatch at symtab pos %d", 0, 0};

#endif

/* Local function prototypes */

static void read_minimal_symbols (struct objfile *);

static void os9k_read_ofile_symtab (struct partial_symtab *);

static void os9k_psymtab_to_symtab (struct partial_symtab *);

static void os9k_psymtab_to_symtab_1 (struct partial_symtab *);

static void read_os9k_psymtab (struct objfile *, CORE_ADDR, int);

static int fill_sym (FILE *, bfd *);

static void os9k_symfile_init (struct objfile *);

static void os9k_new_init (struct objfile *);

static void os9k_symfile_read (struct objfile *, int);

static void os9k_symfile_finish (struct objfile *);

static void

os9k_process_one_symbol (int, int, CORE_ADDR, char *,

                         struct section_offsets *, struct objfile *);

static struct partial_symtab *os9k_start_psymtab (struct objfile *, char *,

                                                  CORE_ADDR, int, int,

                                                  struct partial_symbol **,

                                                  struct partial_symbol **);

static struct partial_symtab *os9k_end_psymtab (struct partial_symtab *,

                                                char **, int, int, CORE_ADDR,

                                                struct partial_symtab **,

                                                int);

static void record_minimal_symbol (char *, CORE_ADDR, int, struct objfile *);

#define HANDLE_RBRAC(val) \

  if ((val) > pst->texthigh) pst->texthigh = (val);

#define SWAP_STBHDR(hdrp, abfd) \

  { \

    (hdrp)->fmtno = bfd_get_16(abfd, (unsigned char *)&(hdrp)->fmtno); \

    (hdrp)->crc = bfd_get_32(abfd, (unsigned char *)&(hdrp)->crc); \

    (hdrp)->offset = bfd_get_32(abfd, (unsigned char *)&(hdrp)->offset); \

    (hdrp)->nsym = bfd_get_32(abfd, (unsigned char *)&(hdrp)->nsym); \

  }

#define SWAP_STBSYM(symp, abfd) \

  { \

    (symp)->value = bfd_get_32(abfd, (unsigned char *)&(symp)->value); \

    (symp)->type = bfd_get_16(abfd, (unsigned char *)&(symp)->type); \

    (symp)->stroff = bfd_get_32(abfd, (unsigned char *)&(symp)->stroff); \

  }

#define N_DATA 0

#define N_BSS 1

#define N_RDATA 2

#define N_IDATA 3

#define N_TEXT 4

#define N_ABS 6

static void

record_minimal_symbol (char *name, CORE_ADDR address, int type,

                       struct objfile *objfile)

{

  enum minimal_symbol_type ms_type;

  switch (type)

    {

    case N_TEXT:

      ms_type = mst_text;

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

      break;

    case N_DATA:

      ms_type = mst_data;

      break;

    case N_BSS:

      ms_type = mst_bss;

      break;

    case N_RDATA:

      ms_type = mst_bss;

      break;

    case N_IDATA:

      ms_type = mst_data;

      break;

    case N_ABS:

      ms_type = mst_abs;

      break;

    default:

      ms_type = mst_unknown;

      break;

    }

  prim_record_minimal_symbol (name, address, ms_type, objfile);

}

/* read and process .stb file and store in minimal symbol table */

typedef char mhhdr[80];

struct stbhdr

  {

    mhhdr comhdr;

    char *name;

    short fmtno;

    int crc;

    int offset;

    int nsym;

    char *pad;

  };

struct stbsymbol

  {

    int value;

    short type;

    int stroff;

  };

#define STBSYMSIZE 10

static void

read_minimal_symbols (struct objfile *objfile)

{

  FILE *fp;

  bfd *abfd;

  struct stbhdr hdr;

  struct stbsymbol sym;

  int ch, i, j, off;

  char buf[64], buf1[128];

  fp = objfile->auxf1;

  if (fp == NULL)

    return;

  abfd = objfile->obfd;

  fread (&hdr.comhdr[0], sizeof (mhhdr), 1, fp);

  i = 0;

  ch = getc (fp);

  while (ch != -1)

    {

      buf[i] = (char) ch;

      i++;

      if (ch == 0)

        break;

      ch = getc (fp);

    };

  if (i % 2)

    ch = getc (fp);

  hdr.name = &buf[0];

  fread (&hdr.fmtno, sizeof (hdr.fmtno), 1, fp);

  fread (&hdr.crc, sizeof (hdr.crc), 1, fp);

  fread (&hdr.offset, sizeof (hdr.offset), 1, fp);

  fread (&hdr.nsym, sizeof (hdr.nsym), 1, fp);

  SWAP_STBHDR (&hdr, abfd);

  /* read symbols */

  init_minimal_symbol_collection ();

  off = hdr.offset;

  for (i = hdr.nsym; i > 0; i--)

    {

      fseek (fp, (long) off, 0);

      fread (&sym.value, sizeof (sym.value), 1, fp);

      fread (&sym.type, sizeof (sym.type), 1, fp);

      fread (&sym.stroff, sizeof (sym.stroff), 1, fp);

      SWAP_STBSYM (&sym, abfd);

      fseek (fp, (long) sym.stroff, 0);

      j = 0;

      ch = getc (fp);

      while (ch != -1)

        {

          buf1[j] = (char) ch;

          j++;

          if (ch == 0)

            break;

          ch = getc (fp);

        };

      record_minimal_symbol (buf1, sym.value, sym.type & 7, objfile);

      off += STBSYMSIZE;

    };

  install_minimal_symbols (objfile);

  return;

}

/* Scan and build partial symbols for a symbol file.

   We have been initialized by a call to os9k_symfile_init, which

   put all the relevant info into a "struct os9k_symfile_info",

   hung off the objfile structure.

   MAINLINE is true if we are reading the main symbol

   table (as opposed to a shared lib or dynamically loaded file).  */

static void

os9k_symfile_read (struct objfile *objfile, int mainline)

{

  bfd *sym_bfd;

  struct cleanup *back_to;

  sym_bfd = objfile->obfd;

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

  if (mainline || objfile->global_psymbols.size == 0 ||

      objfile->static_psymbols.size == 0)

    init_psymbol_list (objfile, DBX_SYMCOUNT (objfile));

  free_pending_blocks ();

  back_to = make_cleanup (really_free_pendings, 0);

  make_cleanup_discard_minimal_symbols ();

  read_minimal_symbols (objfile);

  /* Now that the symbol table data of the executable file are all in core,

     process them and define symbols accordingly.  */

  read_os9k_psymtab (objfile,

                     DBX_TEXT_ADDR (objfile),

                     DBX_TEXT_SIZE (objfile));

  do_cleanups (back_to);

}

/* Initialize anything that needs initializing when a completely new

   symbol file is specified (not just adding some symbols from another

   file, e.g. a shared library).  */

static void

os9k_new_init (struct objfile *ignore)

{

  stabsread_new_init ();

  buildsym_new_init ();

  psymfile_depth = 0;

/*

   init_header_files ();

 */

}

/* os9k_symfile_init ()

   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 goodies.

   Since BFD doesn't know how to read debug symbols in a format-independent

   way (and may never do so...), we have to do it ourselves.  We will never

   be called unless this is an a.out (or very similar) file.

   FIXME, there should be a cleaner peephole into the BFD environment here.  */

static void

os9k_symfile_init (struct objfile *objfile)

{

  bfd *sym_bfd = objfile->obfd;

  char *name = bfd_get_filename (sym_bfd);

  char dbgname[512], stbname[512];

  FILE *symfile = 0;

  FILE *minfile = 0;

  asection *text_sect;

  strcpy (dbgname, name);

  strcat (dbgname, ".dbg");

  strcpy (stbname, name);

  strcat (stbname, ".stb");

  if ((symfile = fopen (dbgname, "r")) == NULL)

    {

      warning ("Symbol file %s not found", dbgname);

    }

  objfile->auxf2 = symfile;

  if ((minfile = fopen (stbname, "r")) == NULL)

    {

      warning ("Symbol file %s not found", stbname);

    }

  objfile->auxf1 = minfile;

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

  objfile->sym_stab_info = (struct dbx_symfile_info *)

    xmmalloc (objfile->md, sizeof (struct dbx_symfile_info));

  DBX_SYMFILE_INFO (objfile)->stab_section_info = NULL;

  text_sect = bfd_get_section_by_name (sym_bfd, ".text");

  if (!text_sect)

    error ("Can't find .text section in file");

  DBX_TEXT_ADDR (objfile) = bfd_section_vma (sym_bfd, text_sect);

  DBX_TEXT_SIZE (objfile) = bfd_section_size (sym_bfd, text_sect);

  DBX_SYMBOL_SIZE (objfile) = 0; /* variable size symbol */

  DBX_SYMCOUNT (objfile) = 0;    /* used to be bfd_get_symcount(sym_bfd) */

  DBX_SYMTAB_OFFSET (objfile) = 0;       /* used to be SYMBOL_TABLE_OFFSET */

}

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

os9k_symfile_finish (struct objfile *objfile)

{

  if (objfile->sym_stab_info != NULL)

    {

      mfree (objfile->md, objfile->sym_stab_info);

    }

/*

   free_header_files ();

 */

}

struct st_dbghdr

{

  int sync;

  short rev;

  int crc;

  short os;

  short cpu;

};

#define SYNC            (int)0xefbefeca

#define SWAP_DBGHDR(hdrp, abfd) \

  { \

    (hdrp)->sync = bfd_get_32(abfd, (unsigned char *)&(hdrp)->sync); \

    (hdrp)->rev = bfd_get_16(abfd, (unsigned char *)&(hdrp)->rev); \

    (hdrp)->crc = bfd_get_32(abfd, (unsigned char *)&(hdrp)->crc); \

    (hdrp)->os = bfd_get_16(abfd, (unsigned char *)&(hdrp)->os); \

    (hdrp)->cpu = bfd_get_16(abfd, (unsigned char *)&(hdrp)->cpu); \

  }

#define N_SYM_CMPLR     0

#define N_SYM_SLINE     1

#define N_SYM_SYM       2

#define N_SYM_LBRAC     3

#define N_SYM_RBRAC     4

#define N_SYM_SE        5

struct internal_symstruct

  {

    short n_type;

    short n_desc;

    long n_value;

    char *n_strx;

  };

static struct internal_symstruct symbol;

static struct internal_symstruct *symbuf = &symbol;

static char strbuf[4096];

static struct st_dbghdr dbghdr;

static short cmplrid;

#define VER_PRE_ULTRAC  ((short)4)

#define VER_ULTRAC      ((short)5)

static int

fill_sym (FILE *dbg_file, bfd *abfd)

{

  short si, nmask;

  long li;

  int ii;

  char *p;

  int nbytes = fread (&si, sizeof (si), 1, dbg_file);

  if (nbytes == 0)

    return 0;

  if (nbytes < 0)

    perror_with_name ("reading .dbg file.");

  symbuf->n_desc = 0;

  symbuf->n_value = 0;

  symbuf->n_strx = NULL;

  symbuf->n_type = bfd_get_16 (abfd, (unsigned char *) &si);

  symbuf->n_type = 0xf & symbuf->n_type;

  switch (symbuf->n_type)

    {

    case N_SYM_CMPLR:

      fread (&si, sizeof (si), 1, dbg_file);

      symbuf->n_desc = bfd_get_16 (abfd, (unsigned char *) &si);

      cmplrid = symbuf->n_desc & 0xff;

      break;

    case N_SYM_SLINE:

      fread (&li, sizeof (li), 1, dbg_file);

      symbuf->n_value = bfd_get_32 (abfd, (unsigned char *) &li);

      fread (&li, sizeof (li), 1, dbg_file);

      li = bfd_get_32 (abfd, (unsigned char *) &li);

      symbuf->n_strx = (char *) (li >> 12);

      symbuf->n_desc = li & 0xfff;

      break;

    case N_SYM_SYM:

      fread (&li, sizeof (li), 1, dbg_file);

      symbuf->n_value = bfd_get_32 (abfd, (unsigned char *) &li);

      si = 0;

      do

        {

          ii = getc (dbg_file);

          strbuf[si++] = (char) ii;

        }

      while (ii != 0 || si % 2 != 0);

      symbuf->n_strx = strbuf;

      p = (char *) strchr (strbuf, ':');

      if (!p)

        break;

      if ((p[1] == 'F' || p[1] == 'f') && cmplrid == VER_PRE_ULTRAC)

        {

          fread (&si, sizeof (si), 1, dbg_file);

          nmask = bfd_get_16 (abfd, (unsigned char *) &si);

          for (ii = 0; ii < nmask; ii++)

            fread (&si, sizeof (si), 1, dbg_file);

        }

      break;

    case N_SYM_LBRAC:

      fread (&li, sizeof (li), 1, dbg_file);

      symbuf->n_value = bfd_get_32 (abfd, (unsigned char *) &li);

      break;

    case N_SYM_RBRAC:

      fread (&li, sizeof (li), 1, dbg_file);

      symbuf->n_value = bfd_get_32 (abfd, (unsigned char *) &li);

      break;

    case N_SYM_SE:

      break;

    }

  return 1;

}

/* Given pointers to an a.out symbol table in core containing dbx

   style data, setup partial_symtab's describing each source file for

   which debugging information is available.

   SYMFILE_NAME is the name of the file we are reading from. */

static void

read_os9k_psymtab (struct objfile *objfile, CORE_ADDR text_addr, int text_size)

{

  register struct internal_symstruct *bufp = 0;          /* =0 avoids gcc -Wall glitch */

  register char *namestring;

  int past_first_source_file = 0;

  CORE_ADDR last_o_file_start = 0;

#if 0

  struct cleanup *back_to;

#endif

  bfd *abfd;

  FILE *fp;

  /* End of the text segment of the executable file.  */

  static CORE_ADDR end_of_text_addr;

  /* Current partial symtab */

  static struct partial_symtab *pst = 0;

  /* List of current psymtab's include files */

  char **psymtab_include_list;

  int includes_allocated;

  int includes_used;

  /* Index within current psymtab dependency list */

  struct partial_symtab **dependency_list;

  int dependencies_used, dependencies_allocated;

  includes_allocated = 30;

  includes_used = 0;

  psymtab_include_list = (char **) alloca (includes_allocated *

                                           sizeof (char *));

  dependencies_allocated = 30;

  dependencies_used = 0;

  dependency_list =

    (struct partial_symtab **) alloca (dependencies_allocated *

                                       sizeof (struct partial_symtab *));

  last_source_file = NULL;

#ifdef END_OF_TEXT_DEFAULT

  end_of_text_addr = END_OF_TEXT_DEFAULT;

#else

  end_of_text_addr = text_addr + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile))

    + text_size;                /* Relocate */

#endif

  abfd = objfile->obfd;

  fp = objfile->auxf2;

  if (!fp)

    return;

  fread (&dbghdr.sync, sizeof (dbghdr.sync), 1, fp);

  fread (&dbghdr.rev, sizeof (dbghdr.rev), 1, fp);

  fread (&dbghdr.crc, sizeof (dbghdr.crc), 1, fp);

  fread (&dbghdr.os, sizeof (dbghdr.os), 1, fp);

  fread (&dbghdr.cpu, sizeof (dbghdr.cpu), 1, fp);

  SWAP_DBGHDR (&dbghdr, abfd);

  symnum = 0;

  while (1)

    {

      int ret;

      long cursymoffset;

      /* Get the symbol for this run and pull out some info */

      QUIT;                     /* allow this to be interruptable */

      cursymoffset = ftell (objfile->auxf2);

      ret = fill_sym (objfile->auxf2, abfd);

      if (ret <= 0)

        break;

      else

        symnum++;

      bufp = symbuf;

      /* Special case to speed up readin. */

      if (bufp->n_type == (short) N_SYM_SLINE)

        continue;

#define CUR_SYMBOL_VALUE bufp->n_value

      /* partial-stab.h */

      switch (bufp->n_type)

        {

          char *p;

        case N_SYM_CMPLR:

          continue;

        case N_SYM_SE:

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

          if (psymfile_depth == 1 && pst)

            {

              os9k_end_psymtab (pst, psymtab_include_list, includes_used,

                                symnum, CUR_SYMBOL_VALUE,

                                dependency_list, dependencies_used);

              pst = (struct partial_symtab *) 0;

              includes_used = 0;

              dependencies_used = 0;

            }

          psymfile_depth--;

          continue;

        case N_SYM_SYM: /* Typedef or automatic variable. */

          namestring = bufp->n_strx;

          p = (char *) strchr (namestring, ':');

          if (!p)

            continue;           /* Not a debugging symbol.   */

          /* Main processing section for debugging symbols which

             the initial read through the symbol tables needs to worry

             about.  If we reach this point, the symbol which we are

             considering is definitely one we are interested in.

             p must also contain the (valid) index into the namestring

             which indicates the debugging type symbol.  */