Subversion Repositories openrisc

/* DWARF 2 debugging format support for GDB.

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

                 2004, 2005, 2006, 2007, 2008, 2009, 2010

                 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 "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 "block.h"

#include "addrmap.h"

#include <fcntl.h>

#include "gdb_string.h"

#include "gdb_assert.h"

#include <sys/types.h>

#ifdef HAVE_ZLIB_H

#include <zlib.h>

#endif

#ifdef HAVE_MMAP

#include <sys/mman.h>

#ifndef MAP_FAILED

#define MAP_FAILED ((void *) -1)

#endif

#endif

#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;

/* When non-zero, dump DIEs after they are read in.  */

static int dwarf2_die_debug = 0;

static int pagesize;

/* When set, the file that we're processing is known to have debugging

   info for C++ namespaces.  GCC 3.3.x did not produce this information,

   but later versions do.  */

static int processing_has_namespace_info;

static const struct objfile_data *dwarf2_objfile_data_key;

struct dwarf2_section_info

{

  asection *asection;

  gdb_byte *buffer;

  bfd_size_type size;

  int was_mmapped;

};

struct dwarf2_per_objfile

{

  struct dwarf2_section_info info;

  struct dwarf2_section_info abbrev;

  struct dwarf2_section_info line;

  struct dwarf2_section_info pubnames;

  struct dwarf2_section_info aranges;

  struct dwarf2_section_info loc;

  struct dwarf2_section_info macinfo;

  struct dwarf2_section_info str;

  struct dwarf2_section_info ranges;

  struct dwarf2_section_info types;

  struct dwarf2_section_info frame;

  struct dwarf2_section_info eh_frame;

  /* 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 table mapping .debug_types signatures to its signatured_type entry.

     This is NULL if the .debug_types section hasn't been read in yet.  */

  htab_t signatured_types;

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

/* names of the debugging sections */

/* Note that if the debugging section has been compressed, it might

   have a name like .zdebug_info.  */

#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 TYPES_SECTION    "debug_types"

#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 int length;

  short version;

  unsigned char addr_size;

  unsigned char signed_addr_p;

  unsigned int abbrev_offset;

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

  /* Offset to first die in this cu from the start of the cu.

     This will be the first byte following the compilation unit header.  */

  unsigned int first_die_offset;

};

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

  struct comp_unit_head header;

  /* Base address of this compilation unit.  */

  CORE_ADDR base_address;

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

  int base_known;

  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;

  /* Pointer to the die -> type map.  Although it is stored

     permanently in per_cu, we copy it here to avoid double

     indirection.  */

  htab_t type_hash;

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

  int last_used;

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

  htab_t die_hash;

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

     bytes should suffice to store the length of any compilation unit

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

     NOTE: Unlike comp_unit_head.length, this length includes

     initial_length_size.  */

  unsigned int offset;

  unsigned int length : 29;

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

     any of the current compilation units are processed.  */

  unsigned int 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;

  /* Non-zero if this CU is from .debug_types.

     Otherwise it's from .debug_info.  */

  unsigned int from_debug_types : 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;

};

/* Entry in the signatured_types hash table.  */

struct signatured_type

{

  ULONGEST signature;

  /* Offset in .debug_types of the TU (type_unit) for this type.  */

  unsigned int offset;

  /* Offset in .debug_types of the type defined by this TU.  */

  unsigned int type_offset;

  /* The CU(/TU) of this type.  */

  struct dwarf2_per_cu_data per_cu;

};

/* Struct used to pass misc. parameters to read_die_and_children, et. al.

   which are used for both .debug_info and .debug_types dies.

   All parameters here are unchanging for the life of the call.

   This struct exists to abstract away the constant parameters of

   die reading.  */

struct die_reader_specs

{

  /* The bfd of this objfile.  */

  bfd* abfd;

  /* The CU of the DIE we are parsing.  */

  struct dwarf2_cu *cu;

  /* Pointer to start of section buffer.

     This is either the start of .debug_info or .debug_types.  */

  const gdb_byte *buffer;

};

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

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

    /* 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 (or types_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;

    /* 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_BITFIELD(dwarf_attribute) name : 16;

    ENUM_BITFIELD(dwarf_form) form : 16;

  };

/* Attributes have a name and a value */

struct attribute

  {

    ENUM_BITFIELD(dwarf_attribute) name : 16;

    ENUM_BITFIELD(dwarf_form) form : 15;

    /* Has DW_STRING already been updated by dwarf2_canonicalize_name?  This

       field should be in u.str (existing only for DW_STRING) but it is kept

       here for better struct attribute alignment.  */

    unsigned int string_is_canonical : 1;

    union

      {

        char *str;

        struct dwarf_block *blk;

        ULONGEST unsnd;

        LONGEST snd;

        CORE_ADDR addr;

        struct signatured_type *signatured_type;

      }

    u;

  };

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

struct die_info

  {

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

    ENUM_BITFIELD(dwarf_tag) tag : 16;

    /* Number of attributes */

    unsigned short num_attrs;

    /* Abbrev number */

    unsigned int abbrev;

    /* Offset in .debug_info or .debug_types section.  */

    unsigned int offset;

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

    /* An array of attributes, with NUM_ATTRS elements.  There may be

       zero, but it's not common and zero-sized arrays are not

       sufficiently portable C.  */

    struct attribute attrs[1];

  };

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_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)

#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)

#define DW_SIGNATURED_TYPE(attr) ((attr)->u.signatured_type)

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

    /* Number of fields (including baseclasses).  */

    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_debug_line_missing_end_sequence_complaint (void)

{

  complaint (&symfile_complaints,

             _(".debug_line section has line program sequence without an end"));

}

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

#endif

static void dwarf2_create_include_psymtab (char *, struct partial_symtab *,

                                           struct objfile *);

static void dwarf2_build_include_psymtabs (struct dwarf2_cu *,

                                           struct die_info *,

                                           struct partial_symtab *);

static void dwarf2_build_psymtabs_hard (struct objfile *);

static void scan_partial_symbols (struct partial_die_info *,