Subversion Repositories openrisc_me

/* DWARF 2 debugging format support for GDB.

   Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,

                 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.

   Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,

   Inc.  with support from Florida State University (under contract

   with the Ada Joint Program Office), and Silicon Graphics, Inc.

   Initial contribution by Brent Benson, Harris Computer Systems, Inc.,

   based on Fred Fish's (Cygnus Support) implementation of DWARF 1

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

#include "defs.h"

#include "bfd.h"

#include "symtab.h"

#include "gdbtypes.h"

#include "objfiles.h"

#include "elf/dwarf2.h"

#include "buildsym.h"

#include "demangle.h"

#include "expression.h"

#include "filenames.h"  /* for DOSish file names */

#include "macrotab.h"

#include "language.h"

#include "complaints.h"

#include "bcache.h"

#include "dwarf2expr.h"

#include "dwarf2loc.h"

#include "cp-support.h"

#include "hashtab.h"

#include "command.h"

#include "gdbcmd.h"

#include <fcntl.h>

#include "gdb_string.h"

#include "gdb_assert.h"

#include <sys/types.h>

/* A note on memory usage for this file.

   At the present time, this code reads the debug info sections into

   the objfile's objfile_obstack.  A definite improvement for startup

   time, on platforms which do not emit relocations for debug

   sections, would be to use mmap instead.  The object's complete

   debug information is loaded into memory, partly to simplify

   absolute DIE references.

   Whether using obstacks or mmap, the sections should remain loaded

   until the objfile is released, and pointers into the section data

   can be used for any other data associated to the objfile (symbol

   names, type names, location expressions to name a few).  */

#if 0

/* .debug_info header for a compilation unit

   Because of alignment constraints, this structure has padding and cannot

   be mapped directly onto the beginning of the .debug_info section.  */

typedef struct comp_unit_header

  {

    unsigned int length;        /* length of the .debug_info

                                   contribution */

    unsigned short version;     /* version number -- 2 for DWARF

                                   version 2 */

    unsigned int abbrev_offset; /* offset into .debug_abbrev section */

    unsigned char addr_size;    /* byte size of an address -- 4 */

  }

_COMP_UNIT_HEADER;

#define _ACTUAL_COMP_UNIT_HEADER_SIZE 11

#endif

/* .debug_pubnames header

   Because of alignment constraints, this structure has padding and cannot

   be mapped directly onto the beginning of the .debug_info section.  */

typedef struct pubnames_header

  {

    unsigned int length;        /* length of the .debug_pubnames

                                   contribution  */

    unsigned char version;      /* version number -- 2 for DWARF

                                   version 2 */

    unsigned int info_offset;   /* offset into .debug_info section */

    unsigned int info_size;     /* byte size of .debug_info section

                                   portion */

  }

_PUBNAMES_HEADER;

#define _ACTUAL_PUBNAMES_HEADER_SIZE 13

/* .debug_pubnames header

   Because of alignment constraints, this structure has padding and cannot

   be mapped directly onto the beginning of the .debug_info section.  */

typedef struct aranges_header

  {

    unsigned int length;        /* byte len of the .debug_aranges

                                   contribution */

    unsigned short version;     /* version number -- 2 for DWARF

                                   version 2 */

    unsigned int info_offset;   /* offset into .debug_info section */

    unsigned char addr_size;    /* byte size of an address */

    unsigned char seg_size;     /* byte size of segment descriptor */

  }

_ARANGES_HEADER;

#define _ACTUAL_ARANGES_HEADER_SIZE 12

/* .debug_line statement program prologue

   Because of alignment constraints, this structure has padding and cannot

   be mapped directly onto the beginning of the .debug_info section.  */

typedef struct statement_prologue

  {

    unsigned int total_length;  /* byte length of the statement

                                   information */

    unsigned short version;     /* version number -- 2 for DWARF

                                   version 2 */

    unsigned int prologue_length;       /* # bytes between prologue &

                                           stmt program */

    unsigned char minimum_instruction_length;   /* byte size of

                                                   smallest instr */

    unsigned char default_is_stmt;      /* initial value of is_stmt

                                           register */

    char line_base;

    unsigned char line_range;

    unsigned char opcode_base;  /* number assigned to first special

                                   opcode */

    unsigned char *standard_opcode_lengths;

  }

_STATEMENT_PROLOGUE;

static const struct objfile_data *dwarf2_objfile_data_key;

struct dwarf2_per_objfile

{

  /* Sizes of debugging sections.  */

  unsigned int info_size;

  unsigned int abbrev_size;

  unsigned int line_size;

  unsigned int pubnames_size;

  unsigned int aranges_size;

  unsigned int loc_size;

  unsigned int macinfo_size;

  unsigned int str_size;

  unsigned int ranges_size;

  unsigned int frame_size;

  unsigned int eh_frame_size;

  /* Loaded data from the sections.  */

  gdb_byte *info_buffer;

  gdb_byte *abbrev_buffer;

  gdb_byte *line_buffer;

  gdb_byte *str_buffer;

  gdb_byte *macinfo_buffer;

  gdb_byte *ranges_buffer;

  gdb_byte *loc_buffer;

  /* A list of all the compilation units.  This is used to locate

     the target compilation unit of a particular reference.  */

  struct dwarf2_per_cu_data **all_comp_units;

  /* The number of compilation units in ALL_COMP_UNITS.  */

  int n_comp_units;

  /* A chain of compilation units that are currently read in, so that

     they can be freed later.  */

  struct dwarf2_per_cu_data *read_in_chain;

  /* A flag indicating wether this objfile has a section loaded at a

     VMA of 0.  */

  int has_section_at_zero;

};

static struct dwarf2_per_objfile *dwarf2_per_objfile;

static asection *dwarf_info_section;

static asection *dwarf_abbrev_section;

static asection *dwarf_line_section;

static asection *dwarf_pubnames_section;

static asection *dwarf_aranges_section;

static asection *dwarf_loc_section;

static asection *dwarf_macinfo_section;

static asection *dwarf_str_section;

static asection *dwarf_ranges_section;

asection *dwarf_frame_section;

asection *dwarf_eh_frame_section;

/* names of the debugging sections */

#define INFO_SECTION     ".debug_info"

#define ABBREV_SECTION   ".debug_abbrev"

#define LINE_SECTION     ".debug_line"

#define PUBNAMES_SECTION ".debug_pubnames"

#define ARANGES_SECTION  ".debug_aranges"

#define LOC_SECTION      ".debug_loc"

#define MACINFO_SECTION  ".debug_macinfo"

#define STR_SECTION      ".debug_str"

#define RANGES_SECTION   ".debug_ranges"

#define FRAME_SECTION    ".debug_frame"

#define EH_FRAME_SECTION ".eh_frame"

/* local data types */

/* We hold several abbreviation tables in memory at the same time. */

#ifndef ABBREV_HASH_SIZE

#define ABBREV_HASH_SIZE 121

#endif

/* The data in a compilation unit header, after target2host

   translation, looks like this.  */

struct comp_unit_head

{

  unsigned long length;

  short version;

  unsigned int abbrev_offset;

  unsigned char addr_size;

  unsigned char signed_addr_p;

  /* Size of file offsets; either 4 or 8.  */

  unsigned int offset_size;

  /* Size of the length field; either 4 or 12.  */

  unsigned int initial_length_size;

  /* Offset to the first byte of this compilation unit header in the

     .debug_info section, for resolving relative reference dies.  */

  unsigned int offset;

  /* Pointer to this compilation unit header in the .debug_info

     section.  */

  gdb_byte *cu_head_ptr;

  /* Pointer to the first die of this compilation unit.  This will be

     the first byte following the compilation unit header.  */

  gdb_byte *first_die_ptr;

  /* Pointer to the next compilation unit header in the program.  */

  struct comp_unit_head *next;

  /* Base address of this compilation unit.  */

  CORE_ADDR base_address;

  /* Non-zero if base_address has been set.  */

  int base_known;

};

/* Fixed size for the DIE hash table.  */

#ifndef REF_HASH_SIZE

#define REF_HASH_SIZE 1021

#endif

/* Internal state when decoding a particular compilation unit.  */

struct dwarf2_cu

{

  /* The objfile containing this compilation unit.  */

  struct objfile *objfile;

  /* The header of the compilation unit.

     FIXME drow/2003-11-10: Some of the things from the comp_unit_head

     should logically be moved to the dwarf2_cu structure.  */

  struct comp_unit_head header;

  struct function_range *first_fn, *last_fn, *cached_fn;

  /* The language we are debugging.  */

  enum language language;

  const struct language_defn *language_defn;

  const char *producer;

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

  /* DWARF abbreviation table associated with this compilation unit.  */

  struct abbrev_info **dwarf2_abbrevs;

  /* Storage for the abbrev table.  */

  struct obstack abbrev_obstack;

  /* Hash table holding all the loaded partial DIEs.  */

  htab_t partial_dies;

  /* Storage for things with the same lifetime as this read-in compilation

     unit, including partial DIEs.  */

  struct obstack comp_unit_obstack;

  /* When multiple dwarf2_cu structures are living in memory, this field

     chains them all together, so that they can be released efficiently.

     We will probably also want a generation counter so that most-recently-used

     compilation units are cached...  */

  struct dwarf2_per_cu_data *read_in_chain;

  /* Backchain to our per_cu entry if the tree has been built.  */

  struct dwarf2_per_cu_data *per_cu;

  /* How many compilation units ago was this CU last referenced?  */

  int last_used;

  /* A hash table of die offsets for following references.  */

  struct die_info *die_ref_table[REF_HASH_SIZE];

  /* Full DIEs if read in.  */

  struct die_info *dies;

  /* A set of pointers to dwarf2_per_cu_data objects for compilation

     units referenced by this one.  Only set during full symbol processing;

     partial symbol tables do not have dependencies.  */

  htab_t dependencies;

  /* Header data from the line table, during full symbol processing.  */

  struct line_header *line_header;

  /* Mark used when releasing cached dies.  */

  unsigned int mark : 1;

  /* This flag will be set if this compilation unit might include

     inter-compilation-unit references.  */

  unsigned int has_form_ref_addr : 1;

  /* This flag will be set if this compilation unit includes any

     DW_TAG_namespace DIEs.  If we know that there are explicit

     DIEs for namespaces, we don't need to try to infer them

     from mangled names.  */

  unsigned int has_namespace_info : 1;

};

/* Persistent data held for a compilation unit, even when not

   processing it.  We put a pointer to this structure in the

   read_symtab_private field of the psymtab.  If we encounter

   inter-compilation-unit references, we also maintain a sorted

   list of all compilation units.  */

struct dwarf2_per_cu_data

{

  /* The start offset and length of this compilation unit.  2**30-1

     bytes should suffice to store the length of any compilation unit

     - if it doesn't, GDB will fall over anyway.  */

  unsigned long offset;

  unsigned long length : 30;

  /* Flag indicating this compilation unit will be read in before

     any of the current compilation units are processed.  */

  unsigned long queued : 1;

  /* This flag will be set if we need to load absolutely all DIEs

     for this compilation unit, instead of just the ones we think

     are interesting.  It gets set if we look for a DIE in the

     hash table and don't find it.  */

  unsigned int load_all_dies : 1;

  /* Set iff currently read in.  */

  struct dwarf2_cu *cu;

  /* If full symbols for this CU have been read in, then this field

     holds a map of DIE offsets to types.  It isn't always possible

     to reconstruct this information later, so we have to preserve

     it.  */

  htab_t type_hash;

  /* The partial symbol table associated with this compilation unit,

     or NULL for partial units (which do not have an associated

     symtab).  */

  struct partial_symtab *psymtab;

};

/* The line number information for a compilation unit (found in the

   .debug_line section) begins with a "statement program header",

   which contains the following information.  */

struct line_header

{

  unsigned int total_length;

  unsigned short version;

  unsigned int header_length;

  unsigned char minimum_instruction_length;

  unsigned char default_is_stmt;

  int line_base;

  unsigned char line_range;

  unsigned char opcode_base;

  /* standard_opcode_lengths[i] is the number of operands for the

     standard opcode whose value is i.  This means that

     standard_opcode_lengths[0] is unused, and the last meaningful

     element is standard_opcode_lengths[opcode_base - 1].  */

  unsigned char *standard_opcode_lengths;

  /* The include_directories table.  NOTE!  These strings are not

     allocated with xmalloc; instead, they are pointers into

     debug_line_buffer.  If you try to free them, `free' will get

     indigestion.  */

  unsigned int num_include_dirs, include_dirs_size;

  char **include_dirs;

  /* The file_names table.  NOTE!  These strings are not allocated

     with xmalloc; instead, they are pointers into debug_line_buffer.

     Don't try to free them directly.  */

  unsigned int num_file_names, file_names_size;

  struct file_entry

  {

    char *name;

    unsigned int dir_index;

    unsigned int mod_time;

    unsigned int length;

    int included_p; /* Non-zero if referenced by the Line Number Program.  */

    struct symtab *symtab; /* The associated symbol table, if any.  */

  } *file_names;

  /* The start and end of the statement program following this

     header.  These point into dwarf2_per_objfile->line_buffer.  */

  gdb_byte *statement_program_start, *statement_program_end;

};

/* When we construct a partial symbol table entry we only

   need this much information. */

struct partial_die_info

  {

    /* Offset of this DIE.  */

    unsigned int offset;

    /* DWARF-2 tag for this DIE.  */

    ENUM_BITFIELD(dwarf_tag) tag : 16;

    /* Language code associated with this DIE.  This is only used

       for the compilation unit DIE.  */

    unsigned int language : 8;

    /* Assorted flags describing the data found in this DIE.  */

    unsigned int has_children : 1;

    unsigned int is_external : 1;

    unsigned int is_declaration : 1;

    unsigned int has_type : 1;

    unsigned int has_specification : 1;

    unsigned int has_stmt_list : 1;

    unsigned int has_pc_info : 1;

    /* Flag set if the SCOPE field of this structure has been

       computed.  */

    unsigned int scope_set : 1;

    /* Flag set if the DIE has a byte_size attribute.  */

    unsigned int has_byte_size : 1;

    /* The name of this DIE.  Normally the value of DW_AT_name, but

       sometimes DW_TAG_MIPS_linkage_name or a string computed in some

       other fashion.  */

    char *name;

    char *dirname;

    /* The scope to prepend to our children.  This is generally

       allocated on the comp_unit_obstack, so will disappear

       when this compilation unit leaves the cache.  */

    char *scope;

    /* The location description associated with this DIE, if any.  */

    struct dwarf_block *locdesc;

    /* If HAS_PC_INFO, the PC range associated with this DIE.  */

    CORE_ADDR lowpc;

    CORE_ADDR highpc;

    /* Pointer into the info_buffer pointing at the target of

       DW_AT_sibling, if any.  */

    gdb_byte *sibling;

    /* If HAS_SPECIFICATION, the offset of the DIE referred to by

       DW_AT_specification (or DW_AT_abstract_origin or

       DW_AT_extension).  */

    unsigned int spec_offset;

    /* If HAS_STMT_LIST, the offset of the Line Number Information data.  */

    unsigned int line_offset;

    /* Pointers to this DIE's parent, first child, and next sibling,

       if any.  */

    struct partial_die_info *die_parent, *die_child, *die_sibling;

  };

/* This data structure holds the information of an abbrev. */

struct abbrev_info

  {

    unsigned int number;        /* number identifying abbrev */

    enum dwarf_tag tag;         /* dwarf tag */

    unsigned short has_children;                /* boolean */

    unsigned short num_attrs;   /* number of attributes */

    struct attr_abbrev *attrs;  /* an array of attribute descriptions */

    struct abbrev_info *next;   /* next in chain */

  };

struct attr_abbrev

  {

    enum dwarf_attribute name;

    enum dwarf_form form;

  };

/* This data structure holds a complete die structure. */

struct die_info

  {

    enum dwarf_tag tag;         /* Tag indicating type of die */

    unsigned int abbrev;        /* Abbrev number */

    unsigned int offset;        /* Offset in .debug_info section */

    unsigned int num_attrs;     /* Number of attributes */

    struct attribute *attrs;    /* An array of attributes */

    struct die_info *next_ref;  /* Next die in ref hash table */

    /* The dies in a compilation unit form an n-ary tree.  PARENT

       points to this die's parent; CHILD points to the first child of

       this node; and all the children of a given node are chained

       together via their SIBLING fields, terminated by a die whose

       tag is zero.  */

    struct die_info *child;     /* Its first child, if any.  */

    struct die_info *sibling;   /* Its next sibling, if any.  */

    struct die_info *parent;    /* Its parent, if any.  */

    struct type *type;          /* Cached type information */

  };

/* Attributes have a name and a value */

struct attribute

  {

    enum dwarf_attribute name;

    enum dwarf_form form;

    union

      {

        char *str;

        struct dwarf_block *blk;

        unsigned long unsnd;

        long int snd;

        CORE_ADDR addr;

      }

    u;

  };

struct function_range

{

  const char *name;

  CORE_ADDR lowpc, highpc;

  int seen_line;

  struct function_range *next;

};

/* Get at parts of an attribute structure */

#define DW_STRING(attr)    ((attr)->u.str)

#define DW_UNSND(attr)     ((attr)->u.unsnd)

#define DW_BLOCK(attr)     ((attr)->u.blk)

#define DW_SND(attr)       ((attr)->u.snd)

#define DW_ADDR(attr)      ((attr)->u.addr)

/* Blocks are a bunch of untyped bytes. */

struct dwarf_block

  {

    unsigned int size;

    gdb_byte *data;

  };

#ifndef ATTR_ALLOC_CHUNK

#define ATTR_ALLOC_CHUNK 4

#endif

/* Allocate fields for structs, unions and enums in this size.  */

#ifndef DW_FIELD_ALLOC_CHUNK

#define DW_FIELD_ALLOC_CHUNK 4

#endif

/* A zeroed version of a partial die for initialization purposes.  */

static struct partial_die_info zeroed_partial_die;

/* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,

   but this would require a corresponding change in unpack_field_as_long

   and friends.  */

static int bits_per_byte = 8;

/* The routines that read and process dies for a C struct or C++ class

   pass lists of data member fields and lists of member function fields

   in an instance of a field_info structure, as defined below.  */

struct field_info

  {

    /* List of data member and baseclasses fields. */

    struct nextfield

      {

        struct nextfield *next;

        int accessibility;

        int virtuality;

        struct field field;

      }

     *fields;

    /* Number of fields.  */

    int nfields;

    /* Number of baseclasses.  */

    int nbaseclasses;

    /* Set if the accesibility of one of the fields is not public.  */

    int non_public_fields;

    /* Member function fields array, entries are allocated in the order they

       are encountered in the object file.  */

    struct nextfnfield

      {

        struct nextfnfield *next;

        struct fn_field fnfield;

      }

     *fnfields;

    /* Member function fieldlist array, contains name of possibly overloaded

       member function, number of overloaded member functions and a pointer

       to the head of the member function field chain.  */

    struct fnfieldlist

      {

        char *name;

        int length;

        struct nextfnfield *head;

      }

     *fnfieldlists;

    /* Number of entries in the fnfieldlists array.  */

    int nfnfields;

  };

/* One item on the queue of compilation units to read in full symbols

   for.  */

struct dwarf2_queue_item

{

  struct dwarf2_per_cu_data *per_cu;

  struct dwarf2_queue_item *next;

};

/* The current queue.  */

static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;

/* Loaded secondary compilation units are kept in memory until they

   have not been referenced for the processing of this many

   compilation units.  Set this to zero to disable caching.  Cache

   sizes of up to at least twenty will improve startup time for

   typical inter-CU-reference binaries, at an obvious memory cost.  */

static int dwarf2_max_cache_age = 5;

static void

show_dwarf2_max_cache_age (struct ui_file *file, int from_tty,

                           struct cmd_list_element *c, const char *value)

{

  fprintf_filtered (file, _("\

The upper bound on the age of cached dwarf2 compilation units is %s.\n"),

                    value);

}

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

static void

dwarf2_statement_list_fits_in_line_number_section_complaint (void)

{

  complaint (&symfile_complaints,

             _("statement list doesn't fit in .debug_line section"));

}

static void

dwarf2_debug_line_missing_file_complaint (void)

{

  complaint (&symfile_complaints,

             _(".debug_line section has line data without a file"));

}

static void

dwarf2_complex_location_expr_complaint (void)

{

  complaint (&symfile_complaints, _("location expression too complex"));

}

static void

dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,

                                              int arg3)

{

  complaint (&symfile_complaints,

             _("const value length mismatch for '%s', got %d, expected %d"), arg1,

             arg2, arg3);

}

static void

dwarf2_macros_too_long_complaint (void)

{

  complaint (&symfile_complaints,

             _("macro info runs off end of `.debug_macinfo' section"));

}

static void

dwarf2_macro_malformed_definition_complaint (const char *arg1)

{

  complaint (&symfile_complaints,

             _("macro debug info contains a malformed macro definition:\n`%s'"),

             arg1);

}

static void

dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)

{

  complaint (&symfile_complaints,

             _("invalid attribute class or form for '%s' in '%s'"), arg1, arg2);

}

/* local function prototypes */

static void dwarf2_locate_sections (bfd *, asection *, void *);

#if 0

static void dwarf2_build_psymtabs_easy (struct objfile *, int);

#endif

static void dwarf2_create_include_psymtab (char *, struct partial_symtab *,

                                           struct objfile *);

static void dwarf2_build_include_psymtabs (struct dwarf2_cu *,

                                           struct partial_die_info *,

                                           struct partial_symtab *);

static void dwarf2_build_psymtabs_hard (struct objfile *, int);

static void scan_partial_symbols (struct partial_die_info *,

                                  CORE_ADDR *, CORE_ADDR *,

                                  struct dwarf2_cu *);

static void add_partial_symbol (struct partial_die_info *,

                                struct dwarf2_cu *);

static int pdi_needs_namespace (enum dwarf_tag tag);

static void add_partial_namespace (struct partial_die_info *pdi,

                                   CORE_ADDR *lowpc, CORE_ADDR *highpc,

                                   struct dwarf2_cu *cu);

static void add_partial_enumeration (struct partial_die_info *enum_pdi,

                                     struct dwarf2_cu *cu);

static gdb_byte *locate_pdi_sibling (struct partial_die_info *orig_pdi,

                                     gdb_byte *info_ptr,

                                     bfd *abfd,

                                     struct dwarf2_cu *cu);

static void dwarf2_psymtab_to_symtab (struct partial_symtab *);

static void psymtab_to_symtab_1 (struct partial_symtab *);

gdb_byte *dwarf2_read_section (struct objfile *, asection *);

static void dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu);

static void dwarf2_free_abbrev_table (void *);

static struct abbrev_info *peek_die_abbrev (gdb_byte *, unsigned int *,

                                            struct dwarf2_cu *);

static struct abbrev_info *dwarf2_lookup_abbrev (unsigned int,

                                                 struct dwarf2_cu *);