Subversion Repositories or1k

/* DWARF debugging format support for GDB.

   Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,

   2001

   Free Software Foundation, Inc.

   Written by Fred Fish at Cygnus Support.  Portions based on dbxread.c,

   mipsread.c, coffread.c, and dwarfread.c from a Data General SVR4 gdb port.

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

/*

   FIXME: Do we need to generate dependencies in partial symtabs?

   (Perhaps we don't need to).

   FIXME: Resolve minor differences between what information we put in the

   partial symbol table and what dbxread puts in.  For example, we don't yet

   put enum constants there.  And dbxread seems to invent a lot of typedefs

   we never see.  Use the new printpsym command to see the partial symbol table

   contents.

   FIXME: Figure out a better way to tell gdb about the name of the function

   contain the user's entry point (I.E. main())

   FIXME: See other FIXME's and "ifdef 0" scattered throughout the code for

   other things to work on, if you get bored. :-)

 */

#include "defs.h"

#include "symtab.h"

#include "gdbtypes.h"

#include "symfile.h"

#include "objfiles.h"

#include "elf/dwarf.h"

#include "buildsym.h"

#include "demangle.h"

#include "expression.h"         /* Needed for enum exp_opcode in language.h, sigh... */

#include "language.h"

#include "complaints.h"

#include <fcntl.h>

#include "gdb_string.h"

/* Some macros to provide DIE info for complaints. */

#define DIE_ID (curdie!=NULL ? curdie->die_ref : 0)

#define DIE_NAME (curdie!=NULL && curdie->at_name!=NULL) ? curdie->at_name : ""

/* Complaints that can be issued during DWARF debug info reading. */

struct complaint no_bfd_get_N =

{

  "DIE @ 0x%x \"%s\", no bfd support for %d byte data object", 0, 0

};

struct complaint malformed_die =

{

  "DIE @ 0x%x \"%s\", malformed DIE, bad length (%d bytes)", 0, 0

};

struct complaint bad_die_ref =

{

  "DIE @ 0x%x \"%s\", reference to DIE (0x%x) outside compilation unit", 0, 0

};

struct complaint unknown_attribute_form =

{

  "DIE @ 0x%x \"%s\", unknown attribute form (0x%x)", 0, 0

};

struct complaint unknown_attribute_length =

{

  "DIE @ 0x%x \"%s\", unknown attribute length, skipped remaining attributes", 0, 0

};

struct complaint unexpected_fund_type =

{

  "DIE @ 0x%x \"%s\", unexpected fundamental type 0x%x", 0, 0

};

struct complaint unknown_type_modifier =

{

  "DIE @ 0x%x \"%s\", unknown type modifier %u", 0, 0

};

struct complaint volatile_ignored =

{

  "DIE @ 0x%x \"%s\", type modifier 'volatile' ignored", 0, 0

};

struct complaint const_ignored =

{

  "DIE @ 0x%x \"%s\", type modifier 'const' ignored", 0, 0

};

struct complaint botched_modified_type =

{

  "DIE @ 0x%x \"%s\", botched modified type decoding (mtype 0x%x)", 0, 0

};

struct complaint op_deref2 =

{

  "DIE @ 0x%x \"%s\", OP_DEREF2 address 0x%x not handled", 0, 0

};

struct complaint op_deref4 =

{

  "DIE @ 0x%x \"%s\", OP_DEREF4 address 0x%x not handled", 0, 0

};

struct complaint basereg_not_handled =

{

  "DIE @ 0x%x \"%s\", BASEREG %d not handled", 0, 0

};

struct complaint dup_user_type_allocation =

{

  "DIE @ 0x%x \"%s\", internal error: duplicate user type allocation", 0, 0

};

struct complaint dup_user_type_definition =

{

  "DIE @ 0x%x \"%s\", internal error: duplicate user type definition", 0, 0

};

struct complaint missing_tag =

{

  "DIE @ 0x%x \"%s\", missing class, structure, or union tag", 0, 0

};

struct complaint bad_array_element_type =

{

  "DIE @ 0x%x \"%s\", bad array element type attribute 0x%x", 0, 0

};

struct complaint subscript_data_items =

{

  "DIE @ 0x%x \"%s\", can't decode subscript data items", 0, 0

};

struct complaint unhandled_array_subscript_format =

{

  "DIE @ 0x%x \"%s\", array subscript format 0x%x not handled yet", 0, 0

};

struct complaint unknown_array_subscript_format =

{

  "DIE @ 0x%x \"%s\", unknown array subscript format %x", 0, 0

};

struct complaint not_row_major =

{

  "DIE @ 0x%x \"%s\", array not row major; not handled correctly", 0, 0

};

struct complaint missing_at_name =

{

  "DIE @ 0x%x, AT_name tag missing", 0, 0

};

typedef unsigned int DIE_REF;   /* Reference to a DIE */

#ifndef GCC_PRODUCER

#define GCC_PRODUCER "GNU C "

#endif

#ifndef GPLUS_PRODUCER

#define GPLUS_PRODUCER "GNU C++ "

#endif

#ifndef LCC_PRODUCER

#define LCC_PRODUCER "NCR C/C++"

#endif

#ifndef CHILL_PRODUCER

#define CHILL_PRODUCER "GNU Chill "

#endif

/* Flags to target_to_host() that tell whether or not the data object is

   expected to be signed.  Used, for example, when fetching a signed

   integer in the target environment which is used as a signed integer

   in the host environment, and the two environments have different sized

   ints.  In this case, *somebody* has to sign extend the smaller sized

   int. */

#define GET_UNSIGNED    0        /* No sign extension required */

#define GET_SIGNED      1       /* Sign extension required */

/* Defines for things which are specified in the document "DWARF Debugging

   Information Format" published by UNIX International, Programming Languages

   SIG.  These defines are based on revision 1.0.0, Jan 20, 1992. */

#define SIZEOF_DIE_LENGTH       4

#define SIZEOF_DIE_TAG          2

#define SIZEOF_ATTRIBUTE        2

#define SIZEOF_FORMAT_SPECIFIER 1

#define SIZEOF_FMT_FT           2

#define SIZEOF_LINETBL_LENGTH   4

#define SIZEOF_LINETBL_LINENO   4

#define SIZEOF_LINETBL_STMT     2

#define SIZEOF_LINETBL_DELTA    4

#define SIZEOF_LOC_ATOM_CODE    1

#define FORM_FROM_ATTR(attr)    ((attr) & 0xF)  /* Implicitly specified */

/* Macros that return the sizes of various types of data in the target

   environment.

   FIXME:  Currently these are just compile time constants (as they are in

   other parts of gdb as well).  They need to be able to get the right size

   either from the bfd or possibly from the DWARF info.  It would be nice if

   the DWARF producer inserted DIES that describe the fundamental types in

   the target environment into the DWARF info, similar to the way dbx stabs

   producers produce information about their fundamental types. */

#define TARGET_FT_POINTER_SIZE(objfile) (TARGET_PTR_BIT / TARGET_CHAR_BIT)

#define TARGET_FT_LONG_SIZE(objfile)    (TARGET_LONG_BIT / TARGET_CHAR_BIT)

/* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a

   FORM_BLOCK2, and this is the value emitted by the AT&T compiler.

   However, the Issue 2 DWARF specification from AT&T defines it as

   a FORM_BLOCK4, as does the latest specification from UI/PLSIG.

   For backwards compatibility with the AT&T compiler produced executables

   we define AT_short_element_list for this variant. */

#define AT_short_element_list    (0x00f0|FORM_BLOCK2)

/* External variables referenced. */

extern int info_verbose;        /* From main.c; nonzero => verbose */

extern char *warning_pre_print; /* From utils.c */

/* The DWARF debugging information consists of two major pieces,

   one is a block of DWARF Information Entries (DIE's) and the other

   is a line number table.  The "struct dieinfo" structure contains

   the information for a single DIE, the one currently being processed.

   In order to make it easier to randomly access the attribute fields

   of the current DIE, which are specifically unordered within the DIE,

   each DIE is scanned and an instance of the "struct dieinfo"

   structure is initialized.

   Initialization is done in two levels.  The first, done by basicdieinfo(),

   just initializes those fields that are vital to deciding whether or not

   to use this DIE, how to skip past it, etc.  The second, done by the

   function completedieinfo(), fills in the rest of the information.

   Attributes which have block forms are not interpreted at the time

   the DIE is scanned, instead we just save pointers to the start

   of their value fields.

   Some fields have a flag <name>_p that is set when the value of the

   field is valid (I.E. we found a matching attribute in the DIE).  Since

   we may want to test for the presence of some attributes in the DIE,

   such as AT_low_pc, without restricting the values of the field,

   we need someway to note that we found such an attribute.

 */

typedef char BLOCK;

struct dieinfo

  {

    char *die;                  /* Pointer to the raw DIE data */

    unsigned long die_length;   /* Length of the raw DIE data */

    DIE_REF die_ref;            /* Offset of this DIE */

    unsigned short die_tag;     /* Tag for this DIE */

    unsigned long at_padding;

    unsigned long at_sibling;

    BLOCK *at_location;

    char *at_name;

    unsigned short at_fund_type;

    BLOCK *at_mod_fund_type;

    unsigned long at_user_def_type;

    BLOCK *at_mod_u_d_type;

    unsigned short at_ordering;

    BLOCK *at_subscr_data;

    unsigned long at_byte_size;

    unsigned short at_bit_offset;

    unsigned long at_bit_size;

    BLOCK *at_element_list;

    unsigned long at_stmt_list;

    CORE_ADDR at_low_pc;

    CORE_ADDR at_high_pc;

    unsigned long at_language;

    unsigned long at_member;

    unsigned long at_discr;

    BLOCK *at_discr_value;

    BLOCK *at_string_length;

    char *at_comp_dir;

    char *at_producer;

    unsigned long at_start_scope;

    unsigned long at_stride_size;

    unsigned long at_src_info;

    char *at_prototyped;

    unsigned int has_at_low_pc:1;

    unsigned int has_at_stmt_list:1;

    unsigned int has_at_byte_size:1;

    unsigned int short_element_list:1;

    /* Kludge to identify register variables */

    unsigned int isreg;

    /* Kludge to identify optimized out variables */

    unsigned int optimized_out;

    /* Kludge to identify basereg references.

       Nonzero if we have an offset relative to a basereg.  */

    unsigned int offreg;

    /* Kludge to identify which base register is it relative to.  */

    unsigned int basereg;

  };

static int diecount;            /* Approximate count of dies for compilation unit */

static struct dieinfo *curdie;  /* For warnings and such */

static char *dbbase;            /* Base pointer to dwarf info */

static int dbsize;              /* Size of dwarf info in bytes */

static int dbroff;              /* Relative offset from start of .debug section */

static char *lnbase;            /* Base pointer to line section */

/* This value is added to each symbol value.  FIXME:  Generalize to

   the section_offsets structure used by dbxread (once this is done,

   pass the appropriate section number to end_symtab).  */

static CORE_ADDR baseaddr;      /* Add to each symbol value */

/* The section offsets used in the current psymtab or symtab.  FIXME,

   only used to pass one value (baseaddr) at the moment.  */

static struct section_offsets *base_section_offsets;

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

   of the psymtab.  */

struct dwfinfo

  {

    /* Always the absolute file offset to the start of the ".debug"

       section for the file containing the DIE's being accessed.  */

    file_ptr dbfoff;

    /* Relative offset from the start of the ".debug" section to the

       first DIE to be accessed.  When building the partial symbol

       table, this value will be zero since we are accessing the

       entire ".debug" section.  When expanding a partial symbol

       table entry, this value will be the offset to the first

       DIE for the compilation unit containing the symbol that

       triggers the expansion.  */

    int dbroff;

    /* The size of the chunk of DIE's being examined, in bytes.  */

    int dblength;

    /* The absolute file offset to the line table fragment.  Ignored

       when building partial symbol tables, but used when expanding

       them, and contains the absolute file offset to the fragment

       of the ".line" section containing the line numbers for the

       current compilation unit.  */

    file_ptr lnfoff;

  };

#define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)

#define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)

#define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)

#define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)

/* The generic symbol table building routines have separate lists for

   file scope symbols and all all other scopes (local scopes).  So

   we need to select the right one to pass to add_symbol_to_list().

   We do it by keeping a pointer to the correct list in list_in_scope.

   FIXME:  The original dwarf code just treated the file scope as the first

   local scope, and all other local scopes as nested local scopes, and worked

   fine.  Check to see if we really need to distinguish these in buildsym.c */

struct pending **list_in_scope = &file_symbols;

/* DIES which have user defined types or modified user defined types refer to

   other DIES for the type information.  Thus we need to associate the offset

   of a DIE for a user defined type with a pointer to the type information.

   Originally this was done using a simple but expensive algorithm, with an

   array of unsorted structures, each containing an offset/type-pointer pair.

   This array was scanned linearly each time a lookup was done.  The result

   was that gdb was spending over half it's startup time munging through this

   array of pointers looking for a structure that had the right offset member.

   The second attempt used the same array of structures, but the array was

   sorted using qsort each time a new offset/type was recorded, and a binary

   search was used to find the type pointer for a given DIE offset.  This was

   even slower, due to the overhead of sorting the array each time a new

   offset/type pair was entered.

   The third attempt uses a fixed size array of type pointers, indexed by a

   value derived from the DIE offset.  Since the minimum DIE size is 4 bytes,

   we can divide any DIE offset by 4 to obtain a unique index into this fixed

   size array.  Since each element is a 4 byte pointer, it takes exactly as

   much memory to hold this array as to hold the DWARF info for a given

   compilation unit.  But it gets freed as soon as we are done with it.

   This has worked well in practice, as a reasonable tradeoff between memory

   consumption and speed, without having to resort to much more complicated

   algorithms. */

static struct type **utypes;    /* Pointer to array of user type pointers */

static int numutypes;           /* Max number of user type pointers */

/* Maintain an array of referenced fundamental types for the current

   compilation unit being read.  For DWARF version 1, we have to construct

   the fundamental types on the fly, since no information about the

   fundamental types is supplied.  Each such fundamental type is created by

   calling a language dependent routine to create the type, and then a

   pointer to that type is then placed in the array at the index specified

   by it's FT_<TYPENAME> value.  The array has a fixed size set by the

   FT_NUM_MEMBERS compile time constant, which is the number of predefined

   fundamental types gdb knows how to construct. */

static struct type *ftypes[FT_NUM_MEMBERS];     /* Fundamental types */

/* Record the language for the compilation unit which is currently being

   processed.  We know it once we have seen the TAG_compile_unit DIE,

   and we need it while processing the DIE's for that compilation unit.

   It is eventually saved in the symtab structure, but we don't finalize

   the symtab struct until we have processed all the DIE's for the

   compilation unit.  We also need to get and save a pointer to the

   language struct for this language, so we can call the language

   dependent routines for doing things such as creating fundamental

   types. */

static enum language cu_language;

static const struct language_defn *cu_language_defn;

/* Forward declarations of static functions so we don't have to worry

   about ordering within this file.  */

static void free_utypes (PTR);

static int attribute_size (unsigned int);

static CORE_ADDR target_to_host (char *, int, int, struct objfile *);

static void add_enum_psymbol (struct dieinfo *, struct objfile *);

static void handle_producer (char *);

static void

read_file_scope (struct dieinfo *, char *, char *, struct objfile *);

static void

read_func_scope (struct dieinfo *, char *, char *, struct objfile *);

static void

read_lexical_block_scope (struct dieinfo *, char *, char *, struct objfile *);

static void scan_partial_symbols (char *, char *, struct objfile *);

static void

scan_compilation_units (char *, char *, file_ptr, file_ptr, struct objfile *);

static void add_partial_symbol (struct dieinfo *, struct objfile *);

static void basicdieinfo (struct dieinfo *, char *, struct objfile *);

static void completedieinfo (struct dieinfo *, struct objfile *);

static void dwarf_psymtab_to_symtab (struct partial_symtab *);

static void psymtab_to_symtab_1 (struct partial_symtab *);

static void read_ofile_symtab (struct partial_symtab *);

static void process_dies (char *, char *, struct objfile *);

static void

read_structure_scope (struct dieinfo *, char *, char *, struct objfile *);

static struct type *decode_array_element_type (char *);

static struct type *decode_subscript_data_item (char *, char *);

static void dwarf_read_array_type (struct dieinfo *);

static void read_tag_pointer_type (struct dieinfo *dip);

static void read_tag_string_type (struct dieinfo *dip);

static void read_subroutine_type (struct dieinfo *, char *, char *);

static void

read_enumeration (struct dieinfo *, char *, char *, struct objfile *);

static struct type *struct_type (struct dieinfo *, char *, char *,

                                 struct objfile *);

static struct type *enum_type (struct dieinfo *, struct objfile *);

static void decode_line_numbers (char *);

static struct type *decode_die_type (struct dieinfo *);

static struct type *decode_mod_fund_type (char *);

static struct type *decode_mod_u_d_type (char *);

static struct type *decode_modified_type (char *, unsigned int, int);

static struct type *decode_fund_type (unsigned int);

static char *create_name (char *, struct obstack *);

static struct type *lookup_utype (DIE_REF);

static struct type *alloc_utype (DIE_REF, struct type *);

static struct symbol *new_symbol (struct dieinfo *, struct objfile *);

static void

synthesize_typedef (struct dieinfo *, struct objfile *, struct type *);

static int locval (struct dieinfo *);

static void set_cu_language (struct dieinfo *);

static struct type *dwarf_fundamental_type (struct objfile *, int);

/*

   LOCAL FUNCTION

   dwarf_fundamental_type -- lookup or create a fundamental type

   SYNOPSIS

   struct type *

   dwarf_fundamental_type (struct objfile *objfile, int typeid)

   DESCRIPTION

   DWARF version 1 doesn't supply any fundamental type information,

   so gdb has to construct such types.  It has a fixed number of

   fundamental types that it knows how to construct, which is the

   union of all types that it knows how to construct for all languages

   that it knows about.  These are enumerated in gdbtypes.h.

   As an example, assume we find a DIE that references a DWARF

   fundamental type of FT_integer.  We first look in the ftypes

   array to see if we already have such a type, indexed by the

   gdb internal value of FT_INTEGER.  If so, we simply return a

   pointer to that type.  If not, then we ask an appropriate

   language dependent routine to create a type FT_INTEGER, using

   defaults reasonable for the current target machine, and install

   that type in ftypes for future reference.

   RETURNS

   Pointer to a fundamental type.

 */

static struct type *

dwarf_fundamental_type (struct objfile *objfile, int typeid)

{

  if (typeid < 0 || typeid >= FT_NUM_MEMBERS)

    {

      error ("internal error - invalid fundamental type id %d", typeid);

    }

  /* Look for this particular type in the fundamental type vector.  If one is

     not found, create and install one appropriate for the current language

     and the current target machine. */

  if (ftypes[typeid] == NULL)

    {

      ftypes[typeid] = cu_language_defn->la_fund_type (objfile, typeid);

    }

  return (ftypes[typeid]);

}

/*

   LOCAL FUNCTION

   set_cu_language -- set local copy of language for compilation unit

   SYNOPSIS

   void

   set_cu_language (struct dieinfo *dip)

   DESCRIPTION

   Decode the language attribute for a compilation unit DIE and

   remember what the language was.  We use this at various times

   when processing DIE's for a given compilation unit.

   RETURNS

   No return value.

 */

static void

set_cu_language (struct dieinfo *dip)

{

  switch (dip->at_language)

    {

    case LANG_C89:

    case LANG_C:

      cu_language = language_c;

      break;

    case LANG_C_PLUS_PLUS:

      cu_language = language_cplus;

      break;

    case LANG_CHILL:

      cu_language = language_chill;

      break;

    case LANG_MODULA2:

      cu_language = language_m2;

      break;

    case LANG_FORTRAN77:

    case LANG_FORTRAN90:

      cu_language = language_fortran;

      break;

    case LANG_ADA83:

    case LANG_COBOL74:

    case LANG_COBOL85:

    case LANG_PASCAL83:

      /* We don't know anything special about these yet. */

      cu_language = language_unknown;

      break;

    default:

      /* If no at_language, try to deduce one from the filename */

      cu_language = deduce_language_from_filename (dip->at_name);

      break;

    }

  cu_language_defn = language_def (cu_language);

}

/*

   GLOBAL FUNCTION

   dwarf_build_psymtabs -- build partial symtabs from DWARF debug info

   SYNOPSIS

   void dwarf_build_psymtabs (struct objfile *objfile,

   int mainline, file_ptr dbfoff, unsigned int dbfsize,

   file_ptr lnoffset, unsigned int lnsize)

   DESCRIPTION

   This function is called upon to build partial symtabs from files

   containing DIE's (Dwarf Information Entries) and DWARF line numbers.

   It is passed a bfd* containing the DIES

   and line number information, the corresponding filename for that

   file, a base address for relocating the symbols, a flag indicating

   whether or not this debugging information is from a "main symbol

   table" rather than a shared library or dynamically linked file,

   and file offset/size pairs for the DIE information and line number

   information.

   RETURNS

   No return value.

 */

void

dwarf_build_psymtabs (struct objfile *objfile, int mainline, file_ptr dbfoff,

                      unsigned int dbfsize, file_ptr lnoffset,

                      unsigned int lnsize)

{

  bfd *abfd = objfile->obfd;

  struct cleanup *back_to;

  current_objfile = objfile;

  dbsize = dbfsize;

  dbbase = xmalloc (dbsize);

  dbroff = 0;

  if ((bfd_seek (abfd, dbfoff, SEEK_SET) != 0) ||

      (bfd_read (dbbase, dbsize, 1, abfd) != dbsize))

    {

      xfree (dbbase);

      error ("can't read DWARF data from '%s'", bfd_get_filename (abfd));

    }

  back_to = make_cleanup (xfree, dbbase);

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

     Since we have no idea how many DIES we are looking at, we just guess

     some arbitrary value. */

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

      objfile->static_psymbols.size == 0)

    {

      init_psymbol_list (objfile, 1024);

    }

  /* Save the relocation factor where everybody can see it.  */

  base_section_offsets = objfile->section_offsets;

  baseaddr = ANOFFSET (objfile->section_offsets, 0);

  /* Follow the compilation unit sibling chain, building a partial symbol

     table entry for each one.  Save enough information about each compilation

     unit to locate the full DWARF information later. */

  scan_compilation_units (dbbase, dbbase + dbsize, dbfoff, lnoffset, objfile);

  do_cleanups (back_to);

  current_objfile = NULL;

}

/*

   LOCAL FUNCTION

   read_lexical_block_scope -- process all dies in a lexical block

   SYNOPSIS

   static void read_lexical_block_scope (struct dieinfo *dip,

   char *thisdie, char *enddie)

   DESCRIPTION

   Process all the DIES contained within a lexical block scope.

   Start a new scope, process the dies, and then close the scope.

 */

static void

read_lexical_block_scope (struct dieinfo *dip, char *thisdie, char *enddie,

                          struct objfile *objfile)

{

  register struct context_stack *new;

  push_context (0, dip->at_low_pc);

  process_dies (thisdie + dip->die_length, enddie, objfile);

  new = pop_context ();

  if (local_symbols != NULL)

    {

      finish_block (0, &local_symbols, new->old_blocks, new->start_addr,

                    dip->at_high_pc, objfile);

    }

  local_symbols = new->locals;

}