diff options
Diffstat (limited to 'gdb/dwarf2read.c')
| -rw-r--r-- | gdb/dwarf2read.c | 6093 |
1 files changed, 0 insertions, 6093 deletions
diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c deleted file mode 100644 index 1aae8fcd91a..00000000000 --- a/gdb/dwarf2read.c +++ /dev/null @@ -1,6093 +0,0 @@ -/* DWARF 2 debugging format support for GDB. - Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 - 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 in dwarfread.c - - 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. */ - -#include "defs.h" -#include "bfd.h" -#include "symtab.h" -#include "gdbtypes.h" -#include "symfile.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 "language.h" -#include "complaints.h" -#include "bcache.h" -#include <fcntl.h> -#include "gdb_string.h" -#include "gdb_assert.h" -#include <sys/types.h> - -#ifndef DWARF2_REG_TO_REGNUM -#define DWARF2_REG_TO_REGNUM(REG) (REG) -#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; - -/* offsets and sizes of debugging sections */ - -static file_ptr dwarf_info_offset; -static file_ptr dwarf_abbrev_offset; -static file_ptr dwarf_line_offset; -static file_ptr dwarf_pubnames_offset; -static file_ptr dwarf_aranges_offset; -static file_ptr dwarf_loc_offset; -static file_ptr dwarf_macinfo_offset; -static file_ptr dwarf_str_offset; -file_ptr dwarf_frame_offset; -file_ptr dwarf_eh_frame_offset; - -static unsigned int dwarf_info_size; -static unsigned int dwarf_abbrev_size; -static unsigned int dwarf_line_size; -static unsigned int dwarf_pubnames_size; -static unsigned int dwarf_aranges_size; -static unsigned int dwarf_loc_size; -static unsigned int dwarf_macinfo_size; -static unsigned int dwarf_str_size; -unsigned int dwarf_frame_size; -unsigned int dwarf_eh_frame_size; - -/* 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 FRAME_SECTION ".debug_frame" -#define EH_FRAME_SECTION ".eh_frame" - -/* local data types */ - -/* 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; - unsigned int offset_size; /* size of file offsets; either 4 or 8 */ - unsigned int initial_length_size; /* size of the length field; either - 4 or 12 */ - }; - -/* The data in the .debug_line statement prologue looks like this. */ -struct line_head - { - unsigned int total_length; - unsigned short version; - unsigned int prologue_length; - unsigned char minimum_instruction_length; - unsigned char default_is_stmt; - int line_base; - unsigned char line_range; - unsigned char opcode_base; - unsigned char *standard_opcode_lengths; - }; - -/* When we construct a partial symbol table entry we only - need this much information. */ -struct partial_die_info - { - enum dwarf_tag tag; - unsigned char has_children; - unsigned char is_external; - unsigned char is_declaration; - unsigned char has_type; - unsigned int offset; - unsigned int abbrev; - char *name; - int has_pc_info; - CORE_ADDR lowpc; - CORE_ADDR highpc; - struct dwarf_block *locdesc; - unsigned int language; - char *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 */ - int has_children; /* boolean */ - unsigned int 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 short has_children; /* Does the die have children */ - 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 */ - struct die_info *next; /* Next die in linked list */ - 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; - }; - -/* 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; - char *data; - }; - -/* We only hold one compilation unit's abbrevs in - memory at any one time. */ -#ifndef ABBREV_HASH_SIZE -#define ABBREV_HASH_SIZE 121 -#endif -#ifndef ATTR_ALLOC_CHUNK -#define ATTR_ALLOC_CHUNK 4 -#endif - -static struct abbrev_info *dwarf2_abbrevs[ABBREV_HASH_SIZE]; - -/* A hash table of die offsets for following references. */ -#ifndef REF_HASH_SIZE -#define REF_HASH_SIZE 1021 -#endif - -static struct die_info *die_ref_table[REF_HASH_SIZE]; - -/* Obstack for allocating temporary storage used during symbol reading. */ -static struct obstack dwarf2_tmp_obstack; - -/* Offset to the first byte of the current compilation unit header, - for resolving relative reference dies. */ -static unsigned int cu_header_offset; - -/* Allocate fields for structs, unions and enums in this size. */ -#ifndef DW_FIELD_ALLOC_CHUNK -#define DW_FIELD_ALLOC_CHUNK 4 -#endif - -/* The language we are debugging. */ -static enum language cu_language; -static const struct language_defn *cu_language_defn; - -/* Actually data from the sections. */ -static char *dwarf_info_buffer; -static char *dwarf_abbrev_buffer; -static char *dwarf_line_buffer; -static char *dwarf_str_buffer; - -/* A zeroed version of a partial die for initialization purposes. */ -static struct partial_die_info zeroed_partial_die; - -/* 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. */ -static struct pending **list_in_scope = &file_symbols; - -/* FIXME: decode_locdesc sets these variables to describe the location - to the caller. These ought to be a structure or something. If - none of the flags are set, the object lives at the address returned - by decode_locdesc. */ - -static int optimized_out; /* No ops in location in expression, - so object was optimized out. */ -static int isreg; /* Object lives in register. - decode_locdesc's return value is - the register number. */ -static int offreg; /* Object's address is the sum of the - register specified by basereg, plus - the offset returned. */ -static int basereg; /* See `offreg'. */ -static int isderef; /* Value described by flags above is - the address of a pointer to the object. */ -static int islocal; /* Variable is at the returned offset - from the frame start, but there's - no identified frame pointer for - this function, so we can't say - which register it's relative to; - use LOC_LOCAL. */ - -/* DW_AT_frame_base values for the current function. - frame_base_reg is -1 if DW_AT_frame_base is missing, otherwise it - contains the register number for the frame register. - frame_base_offset is the offset from the frame register to the - virtual stack frame. */ -static int frame_base_reg; -static CORE_ADDR frame_base_offset; - -/* 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 */ - -/* We put a pointer to this structure in the read_symtab_private field - of the psymtab. - The complete dwarf information for an objfile is kept in the - psymbol_obstack, so that absolute die references can be handled. - Most of the information in this structure is related to an entire - object file and could be passed via the sym_private field of the objfile. - It is however conceivable that dwarf2 might not be the only type - of symbols read from an object file. */ - -struct dwarf2_pinfo - { - /* Pointer to start of dwarf info buffer for the objfile. */ - - char *dwarf_info_buffer; - - /* Offset in dwarf_info_buffer for this compilation unit. */ - - unsigned long dwarf_info_offset; - - /* Pointer to start of dwarf abbreviation buffer for the objfile. */ - - char *dwarf_abbrev_buffer; - - /* Size of dwarf abbreviation section for the objfile. */ - - unsigned int dwarf_abbrev_size; - - /* Pointer to start of dwarf line buffer for the objfile. */ - - char *dwarf_line_buffer; - - /* Pointer to start of dwarf string buffer for the objfile. */ - - char *dwarf_str_buffer; - - /* Size of dwarf string section for the objfile. */ - - unsigned int dwarf_str_size; - }; - -#define PST_PRIVATE(p) ((struct dwarf2_pinfo *)(p)->read_symtab_private) -#define DWARF_INFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_info_buffer) -#define DWARF_INFO_OFFSET(p) (PST_PRIVATE(p)->dwarf_info_offset) -#define DWARF_ABBREV_BUFFER(p) (PST_PRIVATE(p)->dwarf_abbrev_buffer) -#define DWARF_ABBREV_SIZE(p) (PST_PRIVATE(p)->dwarf_abbrev_size) -#define DWARF_LINE_BUFFER(p) (PST_PRIVATE(p)->dwarf_line_buffer) -#define DWARF_STR_BUFFER(p) (PST_PRIVATE(p)->dwarf_str_buffer) -#define DWARF_STR_SIZE(p) (PST_PRIVATE(p)->dwarf_str_size) - -/* 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 */ - -/* 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; - }; - -/* Various complaints about symbol reading that don't abort the process */ - -static struct complaint dwarf2_const_ignored = -{ - "type qualifier 'const' ignored", 0, 0 -}; -static struct complaint dwarf2_volatile_ignored = -{ - "type qualifier 'volatile' ignored", 0, 0 -}; -static struct complaint dwarf2_non_const_array_bound_ignored = -{ - "non-constant array bounds form '%s' ignored", 0, 0 -}; -static struct complaint dwarf2_missing_line_number_section = -{ - "missing .debug_line section", 0, 0 -}; -static struct complaint dwarf2_mangled_line_number_section = -{ - "mangled .debug_line section", 0, 0 -}; -static struct complaint dwarf2_unsupported_die_ref_attr = -{ - "unsupported die ref attribute form: '%s'", 0, 0 -}; -static struct complaint dwarf2_unsupported_stack_op = -{ - "unsupported stack op: '%s'", 0, 0 -}; -static struct complaint dwarf2_complex_location_expr = -{ - "location expression too complex", 0, 0 -}; -static struct complaint dwarf2_unsupported_tag = -{ - "unsupported tag: '%s'", 0, 0 -}; -static struct complaint dwarf2_unsupported_at_encoding = -{ - "unsupported DW_AT_encoding: '%s'", 0, 0 -}; -static struct complaint dwarf2_unsupported_at_frame_base = -{ - "unsupported DW_AT_frame_base for function '%s'", 0, 0 -}; -static struct complaint dwarf2_unexpected_tag = -{ - "unexepected tag in read_type_die: '%s'", 0, 0 -}; -static struct complaint dwarf2_missing_at_frame_base = -{ - "DW_AT_frame_base missing for DW_OP_fbreg", 0, 0 -}; -static struct complaint dwarf2_bad_static_member_name = -{ - "unrecognized static data member name '%s'", 0, 0 -}; -static struct complaint dwarf2_unsupported_accessibility = -{ - "unsupported accessibility %d", 0, 0 -}; -static struct complaint dwarf2_bad_member_name_complaint = -{ - "cannot extract member name from '%s'", 0, 0 -}; -static struct complaint dwarf2_missing_member_fn_type_complaint = -{ - "member function type missing for '%s'", 0, 0 -}; -static struct complaint dwarf2_vtbl_not_found_complaint = -{ - "virtual function table pointer not found when defining class '%s'", 0, 0 -}; -static struct complaint dwarf2_absolute_sibling_complaint = -{ - "ignoring absolute DW_AT_sibling", 0, 0 -}; -static struct complaint dwarf2_const_value_length_mismatch = -{ - "const value length mismatch for '%s', got %d, expected %d", 0, 0 -}; -static struct complaint dwarf2_unsupported_const_value_attr = -{ - "unsupported const value attribute form: '%s'", 0, 0 -}; - -/* local function prototypes */ - -static void dwarf2_locate_sections (bfd *, asection *, PTR); - -#if 0 -static void dwarf2_build_psymtabs_easy (struct objfile *, int); -#endif - -static void dwarf2_build_psymtabs_hard (struct objfile *, int); - -static char *scan_partial_symbols (char *, struct objfile *, - CORE_ADDR *, CORE_ADDR *, - const struct comp_unit_head *); - -static void add_partial_symbol (struct partial_die_info *, struct objfile *, - const struct comp_unit_head *); - -static void dwarf2_psymtab_to_symtab (struct partial_symtab *); - -static void psymtab_to_symtab_1 (struct partial_symtab *); - -char *dwarf2_read_section (struct objfile *, file_ptr, unsigned int); - -static void dwarf2_read_abbrevs (bfd *, unsigned int); - -static void dwarf2_empty_abbrev_table (PTR); - -static struct abbrev_info *dwarf2_lookup_abbrev (unsigned int); - -static char *read_partial_die (struct partial_die_info *, - bfd *, char *, - const struct comp_unit_head *); - -static char *read_full_die (struct die_info **, bfd *, char *, - const struct comp_unit_head *); - -static char *read_attribute (struct attribute *, struct attr_abbrev *, - bfd *, char *, const struct comp_unit_head *); - -static char *read_attribute_value (struct attribute *, unsigned, - bfd *, char *, const struct comp_unit_head *); - -static unsigned int read_1_byte (bfd *, char *); - -static int read_1_signed_byte (bfd *, char *); - -static unsigned int read_2_bytes (bfd *, char *); - -static unsigned int read_4_bytes (bfd *, char *); - -static unsigned long read_8_bytes (bfd *, char *); - -static CORE_ADDR read_address (bfd *, char *ptr, const struct comp_unit_head *, - int *bytes_read); - -static LONGEST read_initial_length (bfd *, char *, - struct comp_unit_head *, int *bytes_read); - -static LONGEST read_offset (bfd *, char *, const struct comp_unit_head *, - int *bytes_read); - -static char *read_n_bytes (bfd *, char *, unsigned int); - -static char *read_string (bfd *, char *, unsigned int *); - -static char *read_indirect_string (bfd *, char *, const struct comp_unit_head *, - unsigned int *); - -static unsigned long read_unsigned_leb128 (bfd *, char *, unsigned int *); - -static long read_signed_leb128 (bfd *, char *, unsigned int *); - -static void set_cu_language (unsigned int); - -static struct attribute *dwarf_attr (struct die_info *, unsigned int); - -static int die_is_declaration (struct die_info *); - -static void dwarf_decode_lines (unsigned int, char *, bfd *, - const struct comp_unit_head *); - -static void dwarf2_start_subfile (char *, char *); - -static struct symbol *new_symbol (struct die_info *, struct type *, - struct objfile *, const struct comp_unit_head *); - -static void dwarf2_const_value (struct attribute *, struct symbol *, - struct objfile *, const struct comp_unit_head *); - -static void dwarf2_const_value_data (struct attribute *attr, - struct symbol *sym, - int bits); - -static struct type *die_type (struct die_info *, struct objfile *, - const struct comp_unit_head *); - -static struct type *die_containing_type (struct die_info *, struct objfile *, - const struct comp_unit_head *); - -#if 0 -static struct type *type_at_offset (unsigned int, struct objfile *); -#endif - -static struct type *tag_type_to_type (struct die_info *, struct objfile *, - const struct comp_unit_head *); - -static void read_type_die (struct die_info *, struct objfile *, - const struct comp_unit_head *); - -static void read_typedef (struct die_info *, struct objfile *, - const struct comp_unit_head *); - -static void read_base_type (struct die_info *, struct objfile *); - -static void read_file_scope (struct die_info *, struct objfile *, - const struct comp_unit_head *); - -static void read_func_scope (struct die_info *, struct objfile *, - const struct comp_unit_head *); - -static void read_lexical_block_scope (struct die_info *, struct objfile *, - const struct comp_unit_head *); - -static int dwarf2_get_pc_bounds (struct die_info *, - CORE_ADDR *, CORE_ADDR *, struct objfile *); - -static void dwarf2_add_field (struct field_info *, struct die_info *, - struct objfile *, const struct comp_unit_head *); - -static void dwarf2_attach_fields_to_type (struct field_info *, - struct type *, struct objfile *); - -static void dwarf2_add_member_fn (struct field_info *, - struct die_info *, struct type *, - struct objfile *objfile, - const struct comp_unit_head *); - -static void dwarf2_attach_fn_fields_to_type (struct field_info *, - struct type *, struct objfile *); - -static void read_structure_scope (struct die_info *, struct objfile *, - const struct comp_unit_head *); - -static void read_common_block (struct die_info *, struct objfile *, - const struct comp_unit_head *); - -static void read_enumeration (struct die_info *, struct objfile *, - const struct comp_unit_head *); - -static struct type *dwarf_base_type (int, int, struct objfile *); - -static CORE_ADDR decode_locdesc (struct dwarf_block *, struct objfile *, - const struct comp_unit_head *); - -static void read_array_type (struct die_info *, struct objfile *, - const struct comp_unit_head *); - -static void read_tag_pointer_type (struct die_info *, struct objfile *, - const struct comp_unit_head *); - -static void read_tag_ptr_to_member_type (struct die_info *, struct objfile *, - const struct comp_unit_head *); - -static void read_tag_reference_type (struct die_info *, struct objfile *, - const struct comp_unit_head *); - -static void read_tag_const_type (struct die_info *, struct objfile *, - const struct comp_unit_head *); - -static void read_tag_volatile_type (struct die_info *, struct objfile *, - const struct comp_unit_head *); - -static void read_tag_string_type (struct die_info *, struct objfile *); - -static void read_subroutine_type (struct die_info *, struct objfile *, - const struct comp_unit_head *); - -static struct die_info *read_comp_unit (char *, bfd *, - const struct comp_unit_head *); - -static void free_die_list (struct die_info *); - -static struct cleanup *make_cleanup_free_die_list (struct die_info *); - -static void process_die (struct die_info *, struct objfile *, - const struct comp_unit_head *); - -static char *dwarf2_linkage_name (struct die_info *); - -static char *dwarf_tag_name (unsigned int); - -static char *dwarf_attr_name (unsigned int); - -static char *dwarf_form_name (unsigned int); - -static char *dwarf_stack_op_name (unsigned int); - -static char *dwarf_bool_name (unsigned int); - -static char *dwarf_type_encoding_name (unsigned int); - -#if 0 -static char *dwarf_cfi_name (unsigned int); - -struct die_info *copy_die (struct die_info *); -#endif - -static struct die_info *sibling_die (struct die_info *); - -static void dump_die (struct die_info *); - -static void dump_die_list (struct die_info *); - -static void store_in_ref_table (unsigned int, struct die_info *); - -static void dwarf2_empty_hash_tables (void); - -static unsigned int dwarf2_get_ref_die_offset (struct attribute *); - -static struct die_info *follow_die_ref (unsigned int); - -static struct type *dwarf2_fundamental_type (struct objfile *, int); - -/* memory allocation interface */ - -static void dwarf2_free_tmp_obstack (PTR); - -static struct dwarf_block *dwarf_alloc_block (void); - -static struct abbrev_info *dwarf_alloc_abbrev (void); - -static struct die_info *dwarf_alloc_die (void); - -/* Try to locate the sections we need for DWARF 2 debugging - information and return true if we have enough to do something. */ - -int -dwarf2_has_info (bfd *abfd) -{ - dwarf_info_offset = dwarf_abbrev_offset = dwarf_line_offset = 0; - dwarf_str_offset = 0; - dwarf_frame_offset = dwarf_eh_frame_offset = 0; - bfd_map_over_sections (abfd, dwarf2_locate_sections, NULL); - if (dwarf_info_offset && dwarf_abbrev_offset) - { - return 1; - } - else - { - return 0; - } -} - -/* This function is mapped across the sections and remembers the - offset and size of each of the debugging sections we are interested - in. */ - -static void -dwarf2_locate_sections (bfd *ignore_abfd, asection *sectp, PTR ignore_ptr) -{ - if (STREQ (sectp->name, INFO_SECTION)) - { - dwarf_info_offset = sectp->filepos; - dwarf_info_size = bfd_get_section_size_before_reloc (sectp); - } - else if (STREQ (sectp->name, ABBREV_SECTION)) - { - dwarf_abbrev_offset = sectp->filepos; - dwarf_abbrev_size = bfd_get_section_size_before_reloc (sectp); - } - else if (STREQ (sectp->name, LINE_SECTION)) - { - dwarf_line_offset = sectp->filepos; - dwarf_line_size = bfd_get_section_size_before_reloc (sectp); - } - else if (STREQ (sectp->name, PUBNAMES_SECTION)) - { - dwarf_pubnames_offset = sectp->filepos; - dwarf_pubnames_size = bfd_get_section_size_before_reloc (sectp); - } - else if (STREQ (sectp->name, ARANGES_SECTION)) - { - dwarf_aranges_offset = sectp->filepos; - dwarf_aranges_size = bfd_get_section_size_before_reloc (sectp); - } - else if (STREQ (sectp->name, LOC_SECTION)) - { - dwarf_loc_offset = sectp->filepos; - dwarf_loc_size = bfd_get_section_size_before_reloc (sectp); - } - else if (STREQ (sectp->name, MACINFO_SECTION)) - { - dwarf_macinfo_offset = sectp->filepos; - dwarf_macinfo_size = bfd_get_section_size_before_reloc (sectp); - } - else if (STREQ (sectp->name, STR_SECTION)) - { - dwarf_str_offset = sectp->filepos; - dwarf_str_size = bfd_get_section_size_before_reloc (sectp); - } - else if (STREQ (sectp->name, FRAME_SECTION)) - { - dwarf_frame_offset = sectp->filepos; - dwarf_frame_size = bfd_get_section_size_before_reloc (sectp); - } - else if (STREQ (sectp->name, EH_FRAME_SECTION)) - { - dwarf_eh_frame_offset = sectp->filepos; - dwarf_eh_frame_size = bfd_get_section_size_before_reloc (sectp); - } -} - -/* Build a partial symbol table. */ - -void -dwarf2_build_psymtabs (struct objfile *objfile, int mainline) -{ - - /* We definitely need the .debug_info and .debug_abbrev sections */ - - dwarf_info_buffer = dwarf2_read_section (objfile, - dwarf_info_offset, - dwarf_info_size); - dwarf_abbrev_buffer = dwarf2_read_section (objfile, - dwarf_abbrev_offset, - dwarf_abbrev_size); - dwarf_line_buffer = dwarf2_read_section (objfile, - dwarf_line_offset, - dwarf_line_size); - - if (dwarf_str_offset) - dwarf_str_buffer = dwarf2_read_section (objfile, - dwarf_str_offset, - dwarf_str_size); - else - dwarf_str_buffer = NULL; - - if (mainline - || (objfile->global_psymbols.size == 0 - && objfile->static_psymbols.size == 0)) - { - init_psymbol_list (objfile, 1024); - } - -#if 0 - if (dwarf_aranges_offset && dwarf_pubnames_offset) - { - /* Things are significantly easier if we have .debug_aranges and - .debug_pubnames sections */ - - dwarf2_build_psymtabs_easy (objfile, mainline); - } - else -#endif - /* only test this case for now */ - { - /* In this case we have to work a bit harder */ - dwarf2_build_psymtabs_hard (objfile, mainline); - } -} - -#if 0 -/* Build the partial symbol table from the information in the - .debug_pubnames and .debug_aranges sections. */ - -static void -dwarf2_build_psymtabs_easy (struct objfile *objfile, int mainline) -{ - bfd *abfd = objfile->obfd; - char *aranges_buffer, *pubnames_buffer; - char *aranges_ptr, *pubnames_ptr; - unsigned int entry_length, version, info_offset, info_size; - - pubnames_buffer = dwarf2_read_section (objfile, - dwarf_pubnames_offset, - dwarf_pubnames_size); - pubnames_ptr = pubnames_buffer; - while ((pubnames_ptr - pubnames_buffer) < dwarf_pubnames_size) - { - struct comp_unit_head cu_header; - int bytes_read; - - entry_length = read_initial_length (abfd, pubnames_ptr, &cu_header, - &bytes_read); - pubnames_ptr += bytes_read; - version = read_1_byte (abfd, pubnames_ptr); - pubnames_ptr += 1; - info_offset = read_4_bytes (abfd, pubnames_ptr); - pubnames_ptr += 4; - info_size = read_4_bytes (abfd, pubnames_ptr); - pubnames_ptr += 4; - } - - aranges_buffer = dwarf2_read_section (objfile, - dwarf_aranges_offset, - dwarf_aranges_size); - -} -#endif - -/* Read in the comp unit header information from the debug_info at - info_ptr. */ - -static char * -read_comp_unit_head (struct comp_unit_head *cu_header, - char *info_ptr, bfd *abfd) -{ - int signed_addr; - int bytes_read; - cu_header->length = read_initial_length (abfd, info_ptr, cu_header, - &bytes_read); - info_ptr += bytes_read; - cu_header->version = read_2_bytes (abfd, info_ptr); - info_ptr += 2; - cu_header->abbrev_offset = read_offset (abfd, info_ptr, cu_header, - &bytes_read); - info_ptr += bytes_read; - cu_header->addr_size = read_1_byte (abfd, info_ptr); - info_ptr += 1; - signed_addr = bfd_get_sign_extend_vma (abfd); - if (signed_addr < 0) - internal_error (__FILE__, __LINE__, - "read_comp_unit_head: dwarf from non elf file"); - cu_header->signed_addr_p = signed_addr; - return info_ptr; -} - -/* Build the partial symbol table by doing a quick pass through the - .debug_info and .debug_abbrev sections. */ - -static void -dwarf2_build_psymtabs_hard (struct objfile *objfile, int mainline) -{ - /* Instead of reading this into a big buffer, we should probably use - mmap() on architectures that support it. (FIXME) */ - bfd *abfd = objfile->obfd; - char *info_ptr, *abbrev_ptr; - char *beg_of_comp_unit; - struct partial_die_info comp_unit_die; - struct partial_symtab *pst; - struct cleanup *back_to; - CORE_ADDR lowpc, highpc; - - info_ptr = dwarf_info_buffer; - abbrev_ptr = dwarf_abbrev_buffer; - - /* We use dwarf2_tmp_obstack for objects that don't need to survive - the partial symbol scan, like attribute values. - - We could reduce our peak memory consumption during partial symbol - table construction by freeing stuff from this obstack more often - --- say, after processing each compilation unit, or each die --- - but it turns out that this saves almost nothing. For an - executable with 11Mb of Dwarf 2 data, I found about 64k allocated - on dwarf2_tmp_obstack. Some investigation showed: - - 1) 69% of the attributes used forms DW_FORM_addr, DW_FORM_data*, - DW_FORM_flag, DW_FORM_[su]data, and DW_FORM_ref*. These are - all fixed-length values not requiring dynamic allocation. - - 2) 30% of the attributes used the form DW_FORM_string. For - DW_FORM_string, read_attribute simply hands back a pointer to - the null-terminated string in dwarf_info_buffer, so no dynamic - allocation is needed there either. - - 3) The remaining 1% of the attributes all used DW_FORM_block1. - 75% of those were DW_AT_frame_base location lists for - functions; the rest were DW_AT_location attributes, probably - for the global variables. - - Anyway, what this all means is that the memory the dwarf2 - reader uses as temporary space reading partial symbols is about - 0.5% as much as we use for dwarf_*_buffer. That's noise. */ - - obstack_init (&dwarf2_tmp_obstack); - back_to = make_cleanup (dwarf2_free_tmp_obstack, NULL); - - /* Since the objects we're extracting from dwarf_info_buffer vary in - length, only the individual functions to extract them (like - read_comp_unit_head and read_partial_die) can really know whether - the buffer is large enough to hold another complete object. - - At the moment, they don't actually check that. If - dwarf_info_buffer holds just one extra byte after the last - compilation unit's dies, then read_comp_unit_head will happily - read off the end of the buffer. read_partial_die is similarly - casual. Those functions should be fixed. - - For this loop condition, simply checking whether there's any data - left at all should be sufficient. */ - while (info_ptr < dwarf_info_buffer + dwarf_info_size) - { - struct comp_unit_head cu_header; - beg_of_comp_unit = info_ptr; - info_ptr = read_comp_unit_head (&cu_header, info_ptr, abfd); - - if (cu_header.version != 2) - { - error ("Dwarf Error: wrong version in compilation unit header."); - return; - } - if (cu_header.abbrev_offset >= dwarf_abbrev_size) - { - error ("Dwarf Error: bad offset (0x%lx) in compilation unit header (offset 0x%lx + 6).", - (long) cu_header.abbrev_offset, - (long) (beg_of_comp_unit - dwarf_info_buffer)); - return; - } - if (beg_of_comp_unit + cu_header.length + cu_header.initial_length_size - > dwarf_info_buffer + dwarf_info_size) - { - error ("Dwarf Error: bad length (0x%lx) in compilation unit header (offset 0x%lx + 0).", - (long) cu_header.length, - (long) (beg_of_comp_unit - dwarf_info_buffer)); - return; - } - /* Read the abbrevs for this compilation unit into a table */ - dwarf2_read_abbrevs (abfd, cu_header.abbrev_offset); - make_cleanup (dwarf2_empty_abbrev_table, NULL); - - /* Read the compilation unit die */ - info_ptr = read_partial_die (&comp_unit_die, abfd, info_ptr, - &cu_header); - - /* Set the language we're debugging */ - set_cu_language (comp_unit_die.language); - - /* Allocate a new partial symbol table structure */ - pst = start_psymtab_common (objfile, objfile->section_offsets, - comp_unit_die.name ? comp_unit_die.name : "", - comp_unit_die.lowpc, - objfile->global_psymbols.next, - objfile->static_psymbols.next); - - pst->read_symtab_private = (char *) - obstack_alloc (&objfile->psymbol_obstack, sizeof (struct dwarf2_pinfo)); - cu_header_offset = beg_of_comp_unit - dwarf_info_buffer; - DWARF_INFO_BUFFER (pst) = dwarf_info_buffer; - DWARF_INFO_OFFSET (pst) = beg_of_comp_unit - dwarf_info_buffer; - DWARF_ABBREV_BUFFER (pst) = dwarf_abbrev_buffer; - DWARF_ABBREV_SIZE (pst) = dwarf_abbrev_size; - DWARF_LINE_BUFFER (pst) = dwarf_line_buffer; - DWARF_STR_BUFFER (pst) = dwarf_str_buffer; - DWARF_STR_SIZE (pst) = dwarf_str_size; - baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); - - /* Store the function that reads in the rest of the symbol table */ - pst->read_symtab = dwarf2_psymtab_to_symtab; - - /* Check if comp unit has_children. - If so, read the rest of the partial symbols from this comp unit. - If not, there's no more debug_info for this comp unit. */ - if (comp_unit_die.has_children) - { - info_ptr = scan_partial_symbols (info_ptr, objfile, &lowpc, &highpc, - &cu_header); - - /* If the compilation unit didn't have an explicit address range, - then use the information extracted from its child dies. */ - if (! comp_unit_die.has_pc_info) - { - comp_unit_die.lowpc = lowpc; - comp_unit_die.highpc = highpc; - } - } - pst->textlow = comp_unit_die.lowpc + baseaddr; - pst->texthigh = comp_unit_die.highpc + baseaddr; - - pst->n_global_syms = objfile->global_psymbols.next - - (objfile->global_psymbols.list + pst->globals_offset); - pst->n_static_syms = objfile->static_psymbols.next - - (objfile->static_psymbols.list + pst->statics_offset); - sort_pst_symbols (pst); - - /* If there is already a psymtab or symtab for a file of this - name, remove it. (If there is a symtab, more drastic things - also happen.) This happens in VxWorks. */ - free_named_symtabs (pst->filename); - - info_ptr = beg_of_comp_unit + cu_header.length - + cu_header.initial_length_size; - } - do_cleanups (back_to); -} - -/* Read in all interesting dies to the end of the compilation unit. */ - -static char * -scan_partial_symbols (char *info_ptr, struct objfile *objfile, - CORE_ADDR *lowpc, CORE_ADDR *highpc, - const struct comp_unit_head *cu_header) -{ - bfd *abfd = objfile->obfd; - struct partial_die_info pdi; - - /* This function is called after we've read in the comp_unit_die in - order to read its children. We start the nesting level at 1 since - we have pushed 1 level down in order to read the comp unit's children. - The comp unit itself is at level 0, so we stop reading when we pop - back to that level. */ - - int nesting_level = 1; - - *lowpc = ((CORE_ADDR) -1); - *highpc = ((CORE_ADDR) 0); - - while (nesting_level) - { - info_ptr = read_partial_die (&pdi, abfd, info_ptr, cu_header); - - if (pdi.name) - { - switch (pdi.tag) - { - case DW_TAG_subprogram: - if (pdi.has_pc_info) - { - if (pdi.lowpc < *lowpc) - { - *lowpc = pdi.lowpc; - } - if (pdi.highpc > *highpc) - { - *highpc = pdi.highpc; - } - if ((pdi.is_external || nesting_level == 1) - && !pdi.is_declaration) - { - add_partial_symbol (&pdi, objfile, cu_header); - } - } - break; - case DW_TAG_variable: - case DW_TAG_typedef: - case DW_TAG_class_type: - case DW_TAG_structure_type: - case DW_TAG_union_type: - case DW_TAG_enumeration_type: - if ((pdi.is_external || nesting_level == 1) - && !pdi.is_declaration) - { - add_partial_symbol (&pdi, objfile, cu_header); - } - break; - case DW_TAG_enumerator: - /* File scope enumerators are added to the partial symbol - table. */ - if (nesting_level == 2) - add_partial_symbol (&pdi, objfile, cu_header); - break; - case DW_TAG_base_type: - /* File scope base type definitions are added to the partial - symbol table. */ - if (nesting_level == 1) - add_partial_symbol (&pdi, objfile, cu_header); - break; - default: - break; - } - } - - /* If the die has a sibling, skip to the sibling. - Do not skip enumeration types, we want to record their - enumerators. */ - if (pdi.sibling && pdi.tag != DW_TAG_enumeration_type) - { - info_ptr = pdi.sibling; - } - else if (pdi.has_children) - { - /* Die has children, but the optional DW_AT_sibling attribute - is missing. */ - nesting_level++; - } - - if (pdi.tag == 0) - { - nesting_level--; - } - } - - /* If we didn't find a lowpc, set it to highpc to avoid complaints - from `maint check'. */ - if (*lowpc == ((CORE_ADDR) -1)) - *lowpc = *highpc; - return info_ptr; -} - -static void -add_partial_symbol (struct partial_die_info *pdi, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - CORE_ADDR addr = 0; - - switch (pdi->tag) - { - case DW_TAG_subprogram: - if (pdi->is_external) - { - /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr, - mst_text, objfile); */ - add_psymbol_to_list (pdi->name, strlen (pdi->name), - VAR_NAMESPACE, LOC_BLOCK, - &objfile->global_psymbols, - 0, pdi->lowpc + baseaddr, cu_language, objfile); - } - else - { - /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr, - mst_file_text, objfile); */ - add_psymbol_to_list (pdi->name, strlen (pdi->name), - VAR_NAMESPACE, LOC_BLOCK, - &objfile->static_psymbols, - 0, pdi->lowpc + baseaddr, cu_language, objfile); - } - break; - case DW_TAG_variable: - if (pdi->is_external) - { - /* Global Variable. - Don't enter into the minimal symbol tables as there is - a minimal symbol table entry from the ELF symbols already. - Enter into partial symbol table if it has a location - descriptor or a type. - If the location descriptor is missing, new_symbol will create - a LOC_UNRESOLVED symbol, the address of the variable will then - be determined from the minimal symbol table whenever the variable - is referenced. - The address for the partial symbol table entry is not - used by GDB, but it comes in handy for debugging partial symbol - table building. */ - - if (pdi->locdesc) - addr = decode_locdesc (pdi->locdesc, objfile, cu_header); - if (pdi->locdesc || pdi->has_type) - add_psymbol_to_list (pdi->name, strlen (pdi->name), - VAR_NAMESPACE, LOC_STATIC, - &objfile->global_psymbols, - 0, addr + baseaddr, cu_language, objfile); - } - else - { - /* Static Variable. Skip symbols without location descriptors. */ - if (pdi->locdesc == NULL) - return; - addr = decode_locdesc (pdi->locdesc, objfile, cu_header); - /*prim_record_minimal_symbol (pdi->name, addr + baseaddr, - mst_file_data, objfile); */ - add_psymbol_to_list (pdi->name, strlen (pdi->name), - VAR_NAMESPACE, LOC_STATIC, - &objfile->static_psymbols, - 0, addr + baseaddr, cu_language, objfile); - } - break; - case DW_TAG_typedef: - case DW_TAG_base_type: - add_psymbol_to_list (pdi->name, strlen (pdi->name), - VAR_NAMESPACE, LOC_TYPEDEF, - &objfile->static_psymbols, - 0, (CORE_ADDR) 0, cu_language, objfile); - break; - case DW_TAG_class_type: - case DW_TAG_structure_type: - case DW_TAG_union_type: - case DW_TAG_enumeration_type: - /* Skip aggregate types without children, these are external - references. */ - if (pdi->has_children == 0) - return; - add_psymbol_to_list (pdi->name, strlen (pdi->name), - STRUCT_NAMESPACE, LOC_TYPEDEF, - &objfile->static_psymbols, - 0, (CORE_ADDR) 0, cu_language, objfile); - - if (cu_language == language_cplus) - { - /* For C++, these implicitly act as typedefs as well. */ - add_psymbol_to_list (pdi->name, strlen (pdi->name), - VAR_NAMESPACE, LOC_TYPEDEF, - &objfile->static_psymbols, - 0, (CORE_ADDR) 0, cu_language, objfile); - } - break; - case DW_TAG_enumerator: - add_psymbol_to_list (pdi->name, strlen (pdi->name), - VAR_NAMESPACE, LOC_CONST, - &objfile->static_psymbols, - 0, (CORE_ADDR) 0, cu_language, objfile); - break; - default: - break; - } -} - -/* Expand this partial symbol table into a full symbol table. */ - -static void -dwarf2_psymtab_to_symtab (struct partial_symtab *pst) -{ - /* FIXME: This is barely more than a stub. */ - if (pst != NULL) - { - if (pst->readin) - { - warning ("bug: psymtab for %s is already read in.", pst->filename); - } - else - { - if (info_verbose) - { - printf_filtered ("Reading in symbols for %s...", pst->filename); - gdb_flush (gdb_stdout); - } - - psymtab_to_symtab_1 (pst); - - /* Finish up the debug error message. */ - if (info_verbose) - printf_filtered ("done.\n"); - } - } -} - -static void -psymtab_to_symtab_1 (struct partial_symtab *pst) -{ - struct objfile *objfile = pst->objfile; - bfd *abfd = objfile->obfd; - struct comp_unit_head cu_header; - struct die_info *dies; - unsigned long offset; - CORE_ADDR lowpc, highpc; - struct die_info *child_die; - char *info_ptr; - struct symtab *symtab; - struct cleanup *back_to; - - /* Set local variables from the partial symbol table info. */ - offset = DWARF_INFO_OFFSET (pst); - dwarf_info_buffer = DWARF_INFO_BUFFER (pst); - dwarf_abbrev_buffer = DWARF_ABBREV_BUFFER (pst); - dwarf_abbrev_size = DWARF_ABBREV_SIZE (pst); - dwarf_line_buffer = DWARF_LINE_BUFFER (pst); - dwarf_str_buffer = DWARF_STR_BUFFER (pst); - dwarf_str_size = DWARF_STR_SIZE (pst); - baseaddr = ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (objfile)); - cu_header_offset = offset; - info_ptr = dwarf_info_buffer + offset; - - obstack_init (&dwarf2_tmp_obstack); - back_to = make_cleanup (dwarf2_free_tmp_obstack, NULL); - - buildsym_init (); - make_cleanup (really_free_pendings, NULL); - - /* read in the comp_unit header */ - info_ptr = read_comp_unit_head (&cu_header, info_ptr, abfd); - - /* Read the abbrevs for this compilation unit */ - dwarf2_read_abbrevs (abfd, cu_header.abbrev_offset); - make_cleanup (dwarf2_empty_abbrev_table, NULL); - - dies = read_comp_unit (info_ptr, abfd, &cu_header); - - make_cleanup_free_die_list (dies); - - /* Do line number decoding in read_file_scope () */ - process_die (dies, objfile, &cu_header); - - if (!dwarf2_get_pc_bounds (dies, &lowpc, &highpc, objfile)) - { - /* Some compilers don't define a DW_AT_high_pc attribute for - the compilation unit. If the DW_AT_high_pc is missing, - synthesize it, by scanning the DIE's below the compilation unit. */ - highpc = 0; - if (dies->has_children) - { - child_die = dies->next; - while (child_die && child_die->tag) - { - if (child_die->tag == DW_TAG_subprogram) - { - CORE_ADDR low, high; - - if (dwarf2_get_pc_bounds (child_die, &low, &high, objfile)) - { - highpc = max (highpc, high); - } - } - child_die = sibling_die (child_die); - } - } - } - symtab = end_symtab (highpc + baseaddr, objfile, SECT_OFF_TEXT (objfile)); - - /* Set symtab language to language from DW_AT_language. - If the compilation is from a C file generated by language preprocessors, - do not set the language if it was already deduced by start_subfile. */ - if (symtab != NULL - && !(cu_language == language_c && symtab->language != language_c)) - { - symtab->language = cu_language; - } - pst->symtab = symtab; - pst->readin = 1; - sort_symtab_syms (pst->symtab); - - do_cleanups (back_to); -} - -/* Process a die and its children. */ - -static void -process_die (struct die_info *die, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - switch (die->tag) - { - case DW_TAG_padding: - break; - case DW_TAG_compile_unit: - read_file_scope (die, objfile, cu_header); - break; - case DW_TAG_subprogram: - read_subroutine_type (die, objfile, cu_header); - read_func_scope (die, objfile, cu_header); - break; - case DW_TAG_inlined_subroutine: - /* FIXME: These are ignored for now. - They could be used to set breakpoints on all inlined instances - of a function and make GDB `next' properly over inlined functions. */ - break; - case DW_TAG_lexical_block: - read_lexical_block_scope (die, objfile, cu_header); - break; - case DW_TAG_class_type: - case DW_TAG_structure_type: - case DW_TAG_union_type: - read_structure_scope (die, objfile, cu_header); - break; - case DW_TAG_enumeration_type: - read_enumeration (die, objfile, cu_header); - break; - case DW_TAG_subroutine_type: - read_subroutine_type (die, objfile, cu_header); - break; - case DW_TAG_array_type: - read_array_type (die, objfile, cu_header); - break; - case DW_TAG_pointer_type: - read_tag_pointer_type (die, objfile, cu_header); - break; - case DW_TAG_ptr_to_member_type: - read_tag_ptr_to_member_type (die, objfile, cu_header); - break; - case DW_TAG_reference_type: - read_tag_reference_type (die, objfile, cu_header); - break; - case DW_TAG_string_type: - read_tag_string_type (die, objfile); - break; - case DW_TAG_base_type: - read_base_type (die, objfile); - if (dwarf_attr (die, DW_AT_name)) - { - /* Add a typedef symbol for the base type definition. */ - new_symbol (die, die->type, objfile, cu_header); - } - break; - case DW_TAG_common_block: - read_common_block (die, objfile, cu_header); - break; - case DW_TAG_common_inclusion: - break; - default: - new_symbol (die, NULL, objfile, cu_header); - break; - } -} - -static void -read_file_scope (struct die_info *die, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - unsigned int line_offset = 0; - CORE_ADDR lowpc = ((CORE_ADDR) -1); - CORE_ADDR highpc = ((CORE_ADDR) 0); - struct attribute *attr; - char *name = "<unknown>"; - char *comp_dir = NULL; - struct die_info *child_die; - bfd *abfd = objfile->obfd; - - if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, objfile)) - { - if (die->has_children) - { - child_die = die->next; - while (child_die && child_die->tag) - { - if (child_die->tag == DW_TAG_subprogram) - { - CORE_ADDR low, high; - - if (dwarf2_get_pc_bounds (child_die, &low, &high, objfile)) - { - lowpc = min (lowpc, low); - highpc = max (highpc, high); - } - } - child_die = sibling_die (child_die); - } - } - } - - /* If we didn't find a lowpc, set it to highpc to avoid complaints - from finish_block. */ - if (lowpc == ((CORE_ADDR) -1)) - lowpc = highpc; - lowpc += baseaddr; - highpc += baseaddr; - - attr = dwarf_attr (die, DW_AT_name); - if (attr) - { - name = DW_STRING (attr); - } - attr = dwarf_attr (die, DW_AT_comp_dir); - if (attr) - { - comp_dir = DW_STRING (attr); - if (comp_dir) - { - /* Irix 6.2 native cc prepends <machine>.: to the compilation - directory, get rid of it. */ - char *cp = strchr (comp_dir, ':'); - - if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/') - comp_dir = cp + 1; - } - } - - if (objfile->ei.entry_point >= lowpc && - objfile->ei.entry_point < highpc) - { - objfile->ei.entry_file_lowpc = lowpc; - objfile->ei.entry_file_highpc = highpc; - } - - attr = dwarf_attr (die, DW_AT_language); - if (attr) - { - set_cu_language (DW_UNSND (attr)); - } - - /* We assume that we're processing GCC output. */ - processing_gcc_compilation = 2; -#if 0 - /* FIXME:Do something here. */ - if (dip->at_producer != NULL) - { - handle_producer (dip->at_producer); - } -#endif - - /* The compilation unit may be in a different language or objfile, - zero out all remembered fundamental types. */ - memset (ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *)); - - start_symtab (name, comp_dir, lowpc); - record_debugformat ("DWARF 2"); - - /* Decode line number information if present. */ - attr = dwarf_attr (die, DW_AT_stmt_list); - if (attr) - { - line_offset = DW_UNSND (attr); - dwarf_decode_lines (line_offset, comp_dir, abfd, cu_header); - } - - /* Process all dies in compilation unit. */ - if (die->has_children) - { - child_die = die->next; - while (child_die && child_die->tag) - { - process_die (child_die, objfile, cu_header); - child_die = sibling_die (child_die); - } - } -} - -static void -read_func_scope (struct die_info *die, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - register struct context_stack *new; - CORE_ADDR lowpc; - CORE_ADDR highpc; - struct die_info *child_die; - struct attribute *attr; - char *name; - - name = dwarf2_linkage_name (die); - - /* Ignore functions with missing or empty names and functions with - missing or invalid low and high pc attributes. */ - if (name == NULL || !dwarf2_get_pc_bounds (die, &lowpc, &highpc, objfile)) - return; - - lowpc += baseaddr; - highpc += baseaddr; - - if (objfile->ei.entry_point >= lowpc && - objfile->ei.entry_point < highpc) - { - objfile->ei.entry_func_lowpc = lowpc; - objfile->ei.entry_func_highpc = highpc; - } - - /* Decode DW_AT_frame_base location descriptor if present, keep result - for DW_OP_fbreg operands in decode_locdesc. */ - frame_base_reg = -1; - frame_base_offset = 0; - attr = dwarf_attr (die, DW_AT_frame_base); - if (attr) - { - CORE_ADDR addr = decode_locdesc (DW_BLOCK (attr), objfile, cu_header); - if (isderef) - complain (&dwarf2_unsupported_at_frame_base, name); - else if (isreg) - frame_base_reg = addr; - else if (offreg) - { - frame_base_reg = basereg; - frame_base_offset = addr; - } - else - complain (&dwarf2_unsupported_at_frame_base, name); - } - - new = push_context (0, lowpc); - new->name = new_symbol (die, die->type, objfile, cu_header); - list_in_scope = &local_symbols; - - if (die->has_children) - { - child_die = die->next; - while (child_die && child_die->tag) - { - process_die (child_die, objfile, cu_header); - child_die = sibling_die (child_die); - } - } - - new = pop_context (); - /* Make a block for the local symbols within. */ - finish_block (new->name, &local_symbols, new->old_blocks, - lowpc, highpc, objfile); - list_in_scope = &file_symbols; -} - -/* 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 die_info *die, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - register struct context_stack *new; - CORE_ADDR lowpc, highpc; - struct die_info *child_die; - - /* Ignore blocks with missing or invalid low and high pc attributes. */ - if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, objfile)) - return; - lowpc += baseaddr; - highpc += baseaddr; - - push_context (0, lowpc); - if (die->has_children) - { - child_die = die->next; - while (child_die && child_die->tag) - { - process_die (child_die, objfile, cu_header); - child_die = sibling_die (child_die); - } - } - new = pop_context (); - - if (local_symbols != NULL) - { - finish_block (0, &local_symbols, new->old_blocks, new->start_addr, - highpc, objfile); - } - local_symbols = new->locals; -} - -/* Get low and high pc attributes from a die. - Return 1 if the attributes are present and valid, otherwise, return 0. */ - -static int -dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc, CORE_ADDR *highpc, - struct objfile *objfile) -{ - struct attribute *attr; - CORE_ADDR low; - CORE_ADDR high; - - attr = dwarf_attr (die, DW_AT_low_pc); - if (attr) - low = DW_ADDR (attr); - else - return 0; - attr = dwarf_attr (die, DW_AT_high_pc); - if (attr) - high = DW_ADDR (attr); - else - return 0; - - if (high < low) - return 0; - - /* When using the GNU linker, .gnu.linkonce. sections are used to - eliminate duplicate copies of functions and vtables and such. - The linker will arbitrarily choose one and discard the others. - The AT_*_pc values for such functions refer to local labels in - these sections. If the section from that file was discarded, the - labels are not in the output, so the relocs get a value of 0. - If this is a discarded function, mark the pc bounds as invalid, - so that GDB will ignore it. */ - if (low == 0 && (bfd_get_file_flags (objfile->obfd) & HAS_RELOC) == 0) - return 0; - - *lowpc = low; - *highpc = high; - return 1; -} - -/* Add an aggregate field to the field list. */ - -static void -dwarf2_add_field (struct field_info *fip, struct die_info *die, - struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - struct nextfield *new_field; - struct attribute *attr; - struct field *fp; - char *fieldname = ""; - - /* Allocate a new field list entry and link it in. */ - new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield)); - make_cleanup (xfree, new_field); - memset (new_field, 0, sizeof (struct nextfield)); - new_field->next = fip->fields; - fip->fields = new_field; - fip->nfields++; - - /* Handle accessibility and virtuality of field. - The default accessibility for members is public, the default - accessibility for inheritance is private. */ - if (die->tag != DW_TAG_inheritance) - new_field->accessibility = DW_ACCESS_public; - else - new_field->accessibility = DW_ACCESS_private; - new_field->virtuality = DW_VIRTUALITY_none; - - attr = dwarf_attr (die, DW_AT_accessibility); - if (attr) - new_field->accessibility = DW_UNSND (attr); - if (new_field->accessibility != DW_ACCESS_public) - fip->non_public_fields = 1; - attr = dwarf_attr (die, DW_AT_virtuality); - if (attr) - new_field->virtuality = DW_UNSND (attr); - - fp = &new_field->field; - if (die->tag == DW_TAG_member) - { - /* Get type of field. */ - fp->type = die_type (die, objfile, cu_header); - - /* Get bit size of field (zero if none). */ - attr = dwarf_attr (die, DW_AT_bit_size); - if (attr) - { - FIELD_BITSIZE (*fp) = DW_UNSND (attr); - } - else - { - FIELD_BITSIZE (*fp) = 0; - } - - /* Get bit offset of field. */ - attr = dwarf_attr (die, DW_AT_data_member_location); - if (attr) - { - FIELD_BITPOS (*fp) = - decode_locdesc (DW_BLOCK (attr), objfile, cu_header) * bits_per_byte; - } - else - FIELD_BITPOS (*fp) = 0; - attr = dwarf_attr (die, DW_AT_bit_offset); - if (attr) - { - if (BITS_BIG_ENDIAN) - { - /* For big endian bits, the DW_AT_bit_offset gives the - additional bit offset from the MSB of the containing - anonymous object to the MSB of the field. We don't - have to do anything special since we don't need to - know the size of the anonymous object. */ - FIELD_BITPOS (*fp) += DW_UNSND (attr); - } - else - { - /* For little endian bits, compute the bit offset to the - MSB of the anonymous object, subtract off the number of - bits from the MSB of the field to the MSB of the - object, and then subtract off the number of bits of - the field itself. The result is the bit offset of - the LSB of the field. */ - int anonymous_size; - int bit_offset = DW_UNSND (attr); - - attr = dwarf_attr (die, DW_AT_byte_size); - if (attr) - { - /* The size of the anonymous object containing - the bit field is explicit, so use the - indicated size (in bytes). */ - anonymous_size = DW_UNSND (attr); - } - else - { - /* The size of the anonymous object containing - the bit field must be inferred from the type - attribute of the data member containing the - bit field. */ - anonymous_size = TYPE_LENGTH (fp->type); - } - FIELD_BITPOS (*fp) += anonymous_size * bits_per_byte - - bit_offset - FIELD_BITSIZE (*fp); - } - } - - /* Get name of field. */ - attr = dwarf_attr (die, DW_AT_name); - if (attr && DW_STRING (attr)) - fieldname = DW_STRING (attr); - fp->name = obsavestring (fieldname, strlen (fieldname), - &objfile->type_obstack); - - /* Change accessibility for artificial fields (e.g. virtual table - pointer or virtual base class pointer) to private. */ - if (dwarf_attr (die, DW_AT_artificial)) - { - new_field->accessibility = DW_ACCESS_private; - fip->non_public_fields = 1; - } - } - else if (die->tag == DW_TAG_variable) - { - char *physname; - - /* C++ static member. - Get name of field. */ - attr = dwarf_attr (die, DW_AT_name); - if (attr && DW_STRING (attr)) - fieldname = DW_STRING (attr); - else - return; - - /* Get physical name. */ - physname = dwarf2_linkage_name (die); - - SET_FIELD_PHYSNAME (*fp, obsavestring (physname, strlen (physname), - &objfile->type_obstack)); - FIELD_TYPE (*fp) = die_type (die, objfile, cu_header); - FIELD_NAME (*fp) = obsavestring (fieldname, strlen (fieldname), - &objfile->type_obstack); - } - else if (die->tag == DW_TAG_inheritance) - { - /* C++ base class field. */ - attr = dwarf_attr (die, DW_AT_data_member_location); - if (attr) - FIELD_BITPOS (*fp) = (decode_locdesc (DW_BLOCK (attr), objfile, cu_header) - * bits_per_byte); - FIELD_BITSIZE (*fp) = 0; - FIELD_TYPE (*fp) = die_type (die, objfile, cu_header); - FIELD_NAME (*fp) = type_name_no_tag (fp->type); - fip->nbaseclasses++; - } -} - -/* Create the vector of fields, and attach it to the type. */ - -static void -dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type, - struct objfile *objfile) -{ - int nfields = fip->nfields; - - /* Record the field count, allocate space for the array of fields, - and create blank accessibility bitfields if necessary. */ - TYPE_NFIELDS (type) = nfields; - TYPE_FIELDS (type) = (struct field *) - TYPE_ALLOC (type, sizeof (struct field) * nfields); - memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields); - - if (fip->non_public_fields) - { - ALLOCATE_CPLUS_STRUCT_TYPE (type); - - TYPE_FIELD_PRIVATE_BITS (type) = - (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields)); - B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields); - - TYPE_FIELD_PROTECTED_BITS (type) = - (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields)); - B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields); - - TYPE_FIELD_IGNORE_BITS (type) = - (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields)); - B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields); - } - - /* If the type has baseclasses, allocate and clear a bit vector for - TYPE_FIELD_VIRTUAL_BITS. */ - if (fip->nbaseclasses) - { - int num_bytes = B_BYTES (fip->nbaseclasses); - char *pointer; - - ALLOCATE_CPLUS_STRUCT_TYPE (type); - pointer = (char *) TYPE_ALLOC (type, num_bytes); - TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *) pointer; - B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses); - TYPE_N_BASECLASSES (type) = fip->nbaseclasses; - } - - /* Copy the saved-up fields into the field vector. Start from the head - of the list, adding to the tail of the field array, so that they end - up in the same order in the array in which they were added to the list. */ - while (nfields-- > 0) - { - TYPE_FIELD (type, nfields) = fip->fields->field; - switch (fip->fields->accessibility) - { - case DW_ACCESS_private: - SET_TYPE_FIELD_PRIVATE (type, nfields); - break; - - case DW_ACCESS_protected: - SET_TYPE_FIELD_PROTECTED (type, nfields); - break; - - case DW_ACCESS_public: - break; - - default: - /* Unknown accessibility. Complain and treat it as public. */ - { - complain (&dwarf2_unsupported_accessibility, - fip->fields->accessibility); - } - break; - } - if (nfields < fip->nbaseclasses) - { - switch (fip->fields->virtuality) - { - case DW_VIRTUALITY_virtual: - case DW_VIRTUALITY_pure_virtual: - SET_TYPE_FIELD_VIRTUAL (type, nfields); - break; - } - } - fip->fields = fip->fields->next; - } -} - -/* Add a member function to the proper fieldlist. */ - -static void -dwarf2_add_member_fn (struct field_info *fip, struct die_info *die, - struct type *type, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - struct attribute *attr; - struct fnfieldlist *flp; - int i; - struct fn_field *fnp; - char *fieldname; - char *physname; - struct nextfnfield *new_fnfield; - - /* Get name of member function. */ - attr = dwarf_attr (die, DW_AT_name); - if (attr && DW_STRING (attr)) - fieldname = DW_STRING (attr); - else - return; - - /* Get the mangled name. */ - physname = dwarf2_linkage_name (die); - - /* Look up member function name in fieldlist. */ - for (i = 0; i < fip->nfnfields; i++) - { - if (STREQ (fip->fnfieldlists[i].name, fieldname)) - break; - } - - /* Create new list element if necessary. */ - if (i < fip->nfnfields) - flp = &fip->fnfieldlists[i]; - else - { - if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0) - { - fip->fnfieldlists = (struct fnfieldlist *) - xrealloc (fip->fnfieldlists, - (fip->nfnfields + DW_FIELD_ALLOC_CHUNK) - * sizeof (struct fnfieldlist)); - if (fip->nfnfields == 0) - make_cleanup (free_current_contents, &fip->fnfieldlists); - } - flp = &fip->fnfieldlists[fip->nfnfields]; - flp->name = fieldname; - flp->length = 0; - flp->head = NULL; - fip->nfnfields++; - } - - /* Create a new member function field and chain it to the field list - entry. */ - new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield)); - make_cleanup (xfree, new_fnfield); - memset (new_fnfield, 0, sizeof (struct nextfnfield)); - new_fnfield->next = flp->head; - flp->head = new_fnfield; - flp->length++; - - /* Fill in the member function field info. */ - fnp = &new_fnfield->fnfield; - fnp->physname = obsavestring (physname, strlen (physname), - &objfile->type_obstack); - fnp->type = alloc_type (objfile); - if (die->type && TYPE_CODE (die->type) == TYPE_CODE_FUNC) - { - struct type *return_type = TYPE_TARGET_TYPE (die->type); - struct type **arg_types; - int nparams = TYPE_NFIELDS (die->type); - int iparams; - - /* Copy argument types from the subroutine type. */ - arg_types = (struct type **) - TYPE_ALLOC (fnp->type, (nparams + 1) * sizeof (struct type *)); - for (iparams = 0; iparams < nparams; iparams++) - arg_types[iparams] = TYPE_FIELD_TYPE (die->type, iparams); - - /* Set last entry in argument type vector. */ - if (TYPE_VARARGS (die->type)) - arg_types[nparams] = NULL; - else - arg_types[nparams] = dwarf2_fundamental_type (objfile, FT_VOID); - - smash_to_method_type (fnp->type, type, return_type, arg_types); - - /* Handle static member functions. - Dwarf2 has no clean way to discern C++ static and non-static - member functions. G++ helps GDB by marking the first - parameter for non-static member functions (which is the - this pointer) as artificial. We obtain this information - from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */ - if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (die->type, 0) == 0) - fnp->voffset = VOFFSET_STATIC; - } - else - complain (&dwarf2_missing_member_fn_type_complaint, physname); - - /* Get fcontext from DW_AT_containing_type if present. */ - if (dwarf_attr (die, DW_AT_containing_type) != NULL) - fnp->fcontext = die_containing_type (die, objfile, cu_header); - - /* dwarf2 doesn't have stubbed physical names, so the setting of is_const - and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */ - - /* Get accessibility. */ - attr = dwarf_attr (die, DW_AT_accessibility); - if (attr) - { - switch (DW_UNSND (attr)) - { - case DW_ACCESS_private: - fnp->is_private = 1; - break; - case DW_ACCESS_protected: - fnp->is_protected = 1; - break; - } - } - - /* Check for artificial methods. */ - attr = dwarf_attr (die, DW_AT_artificial); - if (attr && DW_UNSND (attr) != 0) - fnp->is_artificial = 1; - - /* Get index in virtual function table if it is a virtual member function. */ - attr = dwarf_attr (die, DW_AT_vtable_elem_location); - if (attr) - fnp->voffset = decode_locdesc (DW_BLOCK (attr), objfile, cu_header) + 2; -} - -/* Create the vector of member function fields, and attach it to the type. */ - -static void -dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type, - struct objfile *objfile) -{ - struct fnfieldlist *flp; - int total_length = 0; - int i; - - ALLOCATE_CPLUS_STRUCT_TYPE (type); - TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *) - TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields); - - for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++) - { - struct nextfnfield *nfp = flp->head; - struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i); - int k; - - TYPE_FN_FIELDLIST_NAME (type, i) = flp->name; - TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length; - fn_flp->fn_fields = (struct fn_field *) - TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length); - for (k = flp->length; (k--, nfp); nfp = nfp->next) - fn_flp->fn_fields[k] = nfp->fnfield; - - total_length += flp->length; - } - - TYPE_NFN_FIELDS (type) = fip->nfnfields; - TYPE_NFN_FIELDS_TOTAL (type) = total_length; -} - -/* Called when we find the DIE that starts a structure or union scope - (definition) to process all dies that define the members of the - structure or union. - - NOTE: we need to call struct_type regardless of whether or not the - DIE has an at_name attribute, since it might be an anonymous - structure or union. This gets the type entered into our set of - user defined types. - - However, if the structure is incomplete (an opaque struct/union) - then suppress creating a symbol table entry for it since gdb only - wants to find the one with the complete definition. Note that if - it is complete, we just call new_symbol, which does it's own - checking about whether the struct/union is anonymous or not (and - suppresses creating a symbol table entry itself). */ - -static void -read_structure_scope (struct die_info *die, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - struct type *type; - struct attribute *attr; - - type = alloc_type (objfile); - - INIT_CPLUS_SPECIFIC (type); - attr = dwarf_attr (die, DW_AT_name); - if (attr && DW_STRING (attr)) - { - TYPE_TAG_NAME (type) = obsavestring (DW_STRING (attr), - strlen (DW_STRING (attr)), - &objfile->type_obstack); - } - - if (die->tag == DW_TAG_structure_type) - { - TYPE_CODE (type) = TYPE_CODE_STRUCT; - } - else if (die->tag == DW_TAG_union_type) - { - TYPE_CODE (type) = TYPE_CODE_UNION; - } - else - { - /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT - in gdbtypes.h. */ - TYPE_CODE (type) = TYPE_CODE_CLASS; - } - - attr = dwarf_attr (die, DW_AT_byte_size); - if (attr) - { - TYPE_LENGTH (type) = DW_UNSND (attr); - } - else - { - TYPE_LENGTH (type) = 0; - } - - /* We need to add the type field to the die immediately so we don't - infinitely recurse when dealing with pointers to the structure - type within the structure itself. */ - die->type = type; - - if (die->has_children && ! die_is_declaration (die)) - { - struct field_info fi; - struct die_info *child_die; - struct cleanup *back_to = make_cleanup (null_cleanup, NULL); - - memset (&fi, 0, sizeof (struct field_info)); - - child_die = die->next; - - while (child_die && child_die->tag) - { - if (child_die->tag == DW_TAG_member) - { - dwarf2_add_field (&fi, child_die, objfile, cu_header); - } - else if (child_die->tag == DW_TAG_variable) - { - /* C++ static member. */ - dwarf2_add_field (&fi, child_die, objfile, cu_header); - } - else if (child_die->tag == DW_TAG_subprogram) - { - /* C++ member function. */ - process_die (child_die, objfile, cu_header); - dwarf2_add_member_fn (&fi, child_die, type, objfile, cu_header); - } - else if (child_die->tag == DW_TAG_inheritance) - { - /* C++ base class field. */ - dwarf2_add_field (&fi, child_die, objfile, cu_header); - } - else - { - process_die (child_die, objfile, cu_header); - } - child_die = sibling_die (child_die); - } - - /* Attach fields and member functions to the type. */ - if (fi.nfields) - dwarf2_attach_fields_to_type (&fi, type, objfile); - if (fi.nfnfields) - { - dwarf2_attach_fn_fields_to_type (&fi, type, objfile); - - /* Get the type which refers to the base class (possibly this - class itself) which contains the vtable pointer for the current - class from the DW_AT_containing_type attribute. */ - - if (dwarf_attr (die, DW_AT_containing_type) != NULL) - { - struct type *t = die_containing_type (die, objfile, cu_header); - - TYPE_VPTR_BASETYPE (type) = t; - if (type == t) - { - static const char vptr_name[] = - {'_', 'v', 'p', 't', 'r', '\0'}; - int i; - - /* Our own class provides vtbl ptr. */ - for (i = TYPE_NFIELDS (t) - 1; - i >= TYPE_N_BASECLASSES (t); - --i) - { - char *fieldname = TYPE_FIELD_NAME (t, i); - - if (STREQN (fieldname, vptr_name, strlen (vptr_name) - 1) - && is_cplus_marker (fieldname[strlen (vptr_name)])) - { - TYPE_VPTR_FIELDNO (type) = i; - break; - } - } - - /* Complain if virtual function table field not found. */ - if (i < TYPE_N_BASECLASSES (t)) - complain (&dwarf2_vtbl_not_found_complaint, - TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) : ""); - } - else - { - TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t); - } - } - } - - new_symbol (die, type, objfile, cu_header); - - do_cleanups (back_to); - } - else - { - /* No children, must be stub. */ - TYPE_FLAGS (type) |= TYPE_FLAG_STUB; - } - - finish_cv_type (die->type); -} - -/* Given a pointer to a die which begins an enumeration, process all - the dies that define the members of the enumeration. - - This will be much nicer in draft 6 of the DWARF spec when our - members will be dies instead squished into the DW_AT_element_list - attribute. - - NOTE: We reverse the order of the element list. */ - -static void -read_enumeration (struct die_info *die, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - struct die_info *child_die; - struct type *type; - struct field *fields; - struct attribute *attr; - struct symbol *sym; - int num_fields; - int unsigned_enum = 1; - - type = alloc_type (objfile); - - TYPE_CODE (type) = TYPE_CODE_ENUM; - attr = dwarf_attr (die, DW_AT_name); - if (attr && DW_STRING (attr)) - { - TYPE_TAG_NAME (type) = obsavestring (DW_STRING (attr), - strlen (DW_STRING (attr)), - &objfile->type_obstack); - } - - attr = dwarf_attr (die, DW_AT_byte_size); - if (attr) - { - TYPE_LENGTH (type) = DW_UNSND (attr); - } - else - { - TYPE_LENGTH (type) = 0; - } - - num_fields = 0; - fields = NULL; - if (die->has_children) - { - child_die = die->next; - while (child_die && child_die->tag) - { - if (child_die->tag != DW_TAG_enumerator) - { - process_die (child_die, objfile, cu_header); - } - else - { - attr = dwarf_attr (child_die, DW_AT_name); - if (attr) - { - sym = new_symbol (child_die, type, objfile, cu_header); - if (SYMBOL_VALUE (sym) < 0) - unsigned_enum = 0; - - if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0) - { - fields = (struct field *) - xrealloc (fields, - (num_fields + DW_FIELD_ALLOC_CHUNK) - * sizeof (struct field)); - } - - FIELD_NAME (fields[num_fields]) = SYMBOL_NAME (sym); - FIELD_TYPE (fields[num_fields]) = NULL; - FIELD_BITPOS (fields[num_fields]) = SYMBOL_VALUE (sym); - FIELD_BITSIZE (fields[num_fields]) = 0; - - num_fields++; - } - } - - child_die = sibling_die (child_die); - } - - if (num_fields) - { - TYPE_NFIELDS (type) = num_fields; - TYPE_FIELDS (type) = (struct field *) - TYPE_ALLOC (type, sizeof (struct field) * num_fields); - memcpy (TYPE_FIELDS (type), fields, - sizeof (struct field) * num_fields); - xfree (fields); - } - if (unsigned_enum) - TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED; - } - die->type = type; - new_symbol (die, type, objfile, cu_header); -} - -/* Extract all information from a DW_TAG_array_type DIE and put it in - the DIE's type field. For now, this only handles one dimensional - arrays. */ - -static void -read_array_type (struct die_info *die, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - struct die_info *child_die; - struct type *type = NULL; - struct type *element_type, *range_type, *index_type; - struct type **range_types = NULL; - struct attribute *attr; - int ndim = 0; - struct cleanup *back_to; - - /* Return if we've already decoded this type. */ - if (die->type) - { - return; - } - - element_type = die_type (die, objfile, cu_header); - - /* Irix 6.2 native cc creates array types without children for - arrays with unspecified length. */ - if (die->has_children == 0) - { - index_type = dwarf2_fundamental_type (objfile, FT_INTEGER); - range_type = create_range_type (NULL, index_type, 0, -1); - die->type = create_array_type (NULL, element_type, range_type); - return; - } - - back_to = make_cleanup (null_cleanup, NULL); - child_die = die->next; - while (child_die && child_die->tag) - { - if (child_die->tag == DW_TAG_subrange_type) - { - unsigned int low, high; - - /* Default bounds to an array with unspecified length. */ - low = 0; - high = -1; - if (cu_language == language_fortran) - { - /* FORTRAN implies a lower bound of 1, if not given. */ - low = 1; - } - - index_type = die_type (child_die, objfile, cu_header); - attr = dwarf_attr (child_die, DW_AT_lower_bound); - if (attr) - { - if (attr->form == DW_FORM_sdata) - { - low = DW_SND (attr); - } - else if (attr->form == DW_FORM_udata - || attr->form == DW_FORM_data1 - || attr->form == DW_FORM_data2 - || attr->form == DW_FORM_data4) - { - low = DW_UNSND (attr); - } - else - { - complain (&dwarf2_non_const_array_bound_ignored, - dwarf_form_name (attr->form)); -#ifdef FORTRAN_HACK - die->type = lookup_pointer_type (element_type); - return; -#else - low = 0; -#endif - } - } - attr = dwarf_attr (child_die, DW_AT_upper_bound); - if (attr) - { - if (attr->form == DW_FORM_sdata) - { - high = DW_SND (attr); - } - else if (attr->form == DW_FORM_udata - || attr->form == DW_FORM_data1 - || attr->form == DW_FORM_data2 - || attr->form == DW_FORM_data4) - { - high = DW_UNSND (attr); - } - else if (attr->form == DW_FORM_block1) - { - /* GCC encodes arrays with unspecified or dynamic length - with a DW_FORM_block1 attribute. - FIXME: GDB does not yet know how to handle dynamic - arrays properly, treat them as arrays with unspecified - length for now. */ - high = -1; - } - else - { - complain (&dwarf2_non_const_array_bound_ignored, - dwarf_form_name (attr->form)); -#ifdef FORTRAN_HACK - die->type = lookup_pointer_type (element_type); - return; -#else - high = 1; -#endif - } - } - - /* Create a range type and save it for array type creation. */ - if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0) - { - range_types = (struct type **) - xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK) - * sizeof (struct type *)); - if (ndim == 0) - make_cleanup (free_current_contents, &range_types); - } - range_types[ndim++] = create_range_type (NULL, index_type, low, high); - } - child_die = sibling_die (child_die); - } - - /* Dwarf2 dimensions are output from left to right, create the - necessary array types in backwards order. */ - type = element_type; - while (ndim-- > 0) - type = create_array_type (NULL, type, range_types[ndim]); - - do_cleanups (back_to); - - /* Install the type in the die. */ - die->type = type; -} - -/* First cut: install each common block member as a global variable. */ - -static void -read_common_block (struct die_info *die, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - struct die_info *child_die; - struct attribute *attr; - struct symbol *sym; - CORE_ADDR base = (CORE_ADDR) 0; - - attr = dwarf_attr (die, DW_AT_location); - if (attr) - { - base = decode_locdesc (DW_BLOCK (attr), objfile, cu_header); - } - if (die->has_children) - { - child_die = die->next; - while (child_die && child_die->tag) - { - sym = new_symbol (child_die, NULL, objfile, cu_header); - attr = dwarf_attr (child_die, DW_AT_data_member_location); - if (attr) - { - SYMBOL_VALUE_ADDRESS (sym) = - base + decode_locdesc (DW_BLOCK (attr), objfile, cu_header); - add_symbol_to_list (sym, &global_symbols); - } - child_die = sibling_die (child_die); - } - } -} - -/* Extract all information from a DW_TAG_pointer_type DIE and add to - the user defined type vector. */ - -static void -read_tag_pointer_type (struct die_info *die, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - struct type *type; - struct attribute *attr; - - if (die->type) - { - return; - } - - type = lookup_pointer_type (die_type (die, objfile, cu_header)); - attr = dwarf_attr (die, DW_AT_byte_size); - if (attr) - { - TYPE_LENGTH (type) = DW_UNSND (attr); - } - else - { - TYPE_LENGTH (type) = cu_header->addr_size; - } - die->type = type; -} - -/* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to - the user defined type vector. */ - -static void -read_tag_ptr_to_member_type (struct die_info *die, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - struct type *type; - struct type *to_type; - struct type *domain; - - if (die->type) - { - return; - } - - type = alloc_type (objfile); - to_type = die_type (die, objfile, cu_header); - domain = die_containing_type (die, objfile, cu_header); - smash_to_member_type (type, domain, to_type); - - die->type = type; -} - -/* Extract all information from a DW_TAG_reference_type DIE and add to - the user defined type vector. */ - -static void -read_tag_reference_type (struct die_info *die, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - struct type *type; - struct attribute *attr; - - if (die->type) - { - return; - } - - type = lookup_reference_type (die_type (die, objfile, cu_header)); - attr = dwarf_attr (die, DW_AT_byte_size); - if (attr) - { - TYPE_LENGTH (type) = DW_UNSND (attr); - } - else - { - TYPE_LENGTH (type) = cu_header->addr_size; - } - die->type = type; -} - -static void -read_tag_const_type (struct die_info *die, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - struct type *base_type; - - if (die->type) - { - return; - } - - base_type = die_type (die, objfile, cu_header); - die->type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0); -} - -static void -read_tag_volatile_type (struct die_info *die, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - struct type *base_type; - - if (die->type) - { - return; - } - - base_type = die_type (die, objfile, cu_header); - die->type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0); -} - -/* Extract all information from a DW_TAG_string_type DIE and add to - the user defined type vector. It isn't really a user defined type, - but it behaves like one, with other DIE's using an AT_user_def_type - attribute to reference it. */ - -static void -read_tag_string_type (struct die_info *die, struct objfile *objfile) -{ - struct type *type, *range_type, *index_type, *char_type; - struct attribute *attr; - unsigned int length; - - if (die->type) - { - return; - } - - attr = dwarf_attr (die, DW_AT_string_length); - if (attr) - { - length = DW_UNSND (attr); - } - else - { - /* check for the DW_AT_byte_size attribute */ - attr = dwarf_attr (die, DW_AT_byte_size); - if (attr) - { - length = DW_UNSND (attr); - } - else - { - length = 1; - } - } - index_type = dwarf2_fundamental_type (objfile, FT_INTEGER); - range_type = create_range_type (NULL, index_type, 1, length); - if (cu_language == language_fortran) - { - /* Need to create a unique string type for bounds - information */ - type = create_string_type (0, range_type); - } - else - { - char_type = dwarf2_fundamental_type (objfile, FT_CHAR); - type = create_string_type (char_type, range_type); - } - die->type = type; -} - -/* Handle DIES due to C code like: - - struct foo - { - int (*funcp)(int a, long l); - int b; - }; - - ('funcp' generates a DW_TAG_subroutine_type DIE) - */ - -static void -read_subroutine_type (struct die_info *die, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - struct type *type; /* Type that this function returns */ - struct type *ftype; /* Function that returns above type */ - struct attribute *attr; - - /* Decode the type that this subroutine returns */ - if (die->type) - { - return; - } - type = die_type (die, objfile, cu_header); - ftype = lookup_function_type (type); - - /* All functions in C++ have prototypes. */ - attr = dwarf_attr (die, DW_AT_prototyped); - if ((attr && (DW_UNSND (attr) != 0)) - || cu_language == language_cplus) - TYPE_FLAGS (ftype) |= TYPE_FLAG_PROTOTYPED; - - if (die->has_children) - { - struct die_info *child_die; - int nparams = 0; - int iparams = 0; - - /* Count the number of parameters. - FIXME: GDB currently ignores vararg functions, but knows about - vararg member functions. */ - child_die = die->next; - while (child_die && child_die->tag) - { - if (child_die->tag == DW_TAG_formal_parameter) - nparams++; - else if (child_die->tag == DW_TAG_unspecified_parameters) - TYPE_FLAGS (ftype) |= TYPE_FLAG_VARARGS; - child_die = sibling_die (child_die); - } - - /* Allocate storage for parameters and fill them in. */ - TYPE_NFIELDS (ftype) = nparams; - TYPE_FIELDS (ftype) = (struct field *) - TYPE_ALLOC (ftype, nparams * sizeof (struct field)); - - child_die = die->next; - while (child_die && child_die->tag) - { - if (child_die->tag == DW_TAG_formal_parameter) - { - /* Dwarf2 has no clean way to discern C++ static and non-static - member functions. G++ helps GDB by marking the first - parameter for non-static member functions (which is the - this pointer) as artificial. We pass this information - to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */ - attr = dwarf_attr (child_die, DW_AT_artificial); - if (attr) - TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr); - else - TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0; - TYPE_FIELD_TYPE (ftype, iparams) = die_type (child_die, objfile, - cu_header); - iparams++; - } - child_die = sibling_die (child_die); - } - } - - die->type = ftype; -} - -static void -read_typedef (struct die_info *die, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - struct attribute *attr; - char *name = NULL; - - if (!die->type) - { - attr = dwarf_attr (die, DW_AT_name); - if (attr && DW_STRING (attr)) - { - name = DW_STRING (attr); - } - die->type = init_type (TYPE_CODE_TYPEDEF, 0, TYPE_FLAG_TARGET_STUB, name, objfile); - TYPE_TARGET_TYPE (die->type) = die_type (die, objfile, cu_header); - } -} - -/* Find a representation of a given base type and install - it in the TYPE field of the die. */ - -static void -read_base_type (struct die_info *die, struct objfile *objfile) -{ - struct type *type; - struct attribute *attr; - int encoding = 0, size = 0; - - /* If we've already decoded this die, this is a no-op. */ - if (die->type) - { - return; - } - - attr = dwarf_attr (die, DW_AT_encoding); - if (attr) - { - encoding = DW_UNSND (attr); - } - attr = dwarf_attr (die, DW_AT_byte_size); - if (attr) - { - size = DW_UNSND (attr); - } - attr = dwarf_attr (die, DW_AT_name); - if (attr && DW_STRING (attr)) - { - enum type_code code = TYPE_CODE_INT; - int type_flags = 0; - - switch (encoding) - { - case DW_ATE_address: - /* Turn DW_ATE_address into a void * pointer. */ - code = TYPE_CODE_PTR; - type_flags |= TYPE_FLAG_UNSIGNED; - break; - case DW_ATE_boolean: - code = TYPE_CODE_BOOL; - type_flags |= TYPE_FLAG_UNSIGNED; - break; - case DW_ATE_complex_float: - code = TYPE_CODE_COMPLEX; - break; - case DW_ATE_float: - code = TYPE_CODE_FLT; - break; - case DW_ATE_signed: - case DW_ATE_signed_char: - break; - case DW_ATE_unsigned: - case DW_ATE_unsigned_char: - type_flags |= TYPE_FLAG_UNSIGNED; - break; - default: - complain (&dwarf2_unsupported_at_encoding, - dwarf_type_encoding_name (encoding)); - break; - } - type = init_type (code, size, type_flags, DW_STRING (attr), objfile); - if (encoding == DW_ATE_address) - TYPE_TARGET_TYPE (type) = dwarf2_fundamental_type (objfile, FT_VOID); - } - else - { - type = dwarf_base_type (encoding, size, objfile); - } - die->type = type; -} - -/* Read a whole compilation unit into a linked list of dies. */ - -static struct die_info * -read_comp_unit (char *info_ptr, bfd *abfd, - const struct comp_unit_head *cu_header) -{ - struct die_info *first_die, *last_die, *die; - char *cur_ptr; - int nesting_level; - - /* Reset die reference table; we are - building new ones now. */ - dwarf2_empty_hash_tables (); - - cur_ptr = info_ptr; - nesting_level = 0; - first_die = last_die = NULL; - do - { - cur_ptr = read_full_die (&die, abfd, cur_ptr, cu_header); - if (die->has_children) - { - nesting_level++; - } - if (die->tag == 0) - { - nesting_level--; - } - - die->next = NULL; - - /* Enter die in reference hash table */ - store_in_ref_table (die->offset, die); - - if (!first_die) - { - first_die = last_die = die; - } - else - { - last_die->next = die; - last_die = die; - } - } - while (nesting_level > 0); - return first_die; -} - -/* Free a linked list of dies. */ - -static void -free_die_list (struct die_info *dies) -{ - struct die_info *die, *next; - - die = dies; - while (die) - { - next = die->next; - xfree (die->attrs); - xfree (die); - die = next; - } -} - -static void -do_free_die_list_cleanup (void *dies) -{ - free_die_list (dies); -} - -static struct cleanup * -make_cleanup_free_die_list (struct die_info *dies) -{ - return make_cleanup (do_free_die_list_cleanup, dies); -} - - -/* Read the contents of the section at OFFSET and of size SIZE from the - object file specified by OBJFILE into the psymbol_obstack and return it. */ - -char * -dwarf2_read_section (struct objfile *objfile, file_ptr offset, - unsigned int size) -{ - bfd *abfd = objfile->obfd; - char *buf; - - if (size == 0) - return NULL; - - buf = (char *) obstack_alloc (&objfile->psymbol_obstack, size); - if ((bfd_seek (abfd, offset, SEEK_SET) != 0) || - (bfd_bread (buf, size, abfd) != size)) - { - buf = NULL; - error ("Dwarf Error: Can't read DWARF data from '%s'", - bfd_get_filename (abfd)); - } - return buf; -} - -/* In DWARF version 2, the description of the debugging information is - stored in a separate .debug_abbrev section. Before we read any - dies from a section we read in all abbreviations and install them - in a hash table. */ - -static void -dwarf2_read_abbrevs (bfd *abfd, unsigned int offset) -{ - char *abbrev_ptr; - struct abbrev_info *cur_abbrev; - unsigned int abbrev_number, bytes_read, abbrev_name; - unsigned int abbrev_form, hash_number; - - /* empty the table */ - dwarf2_empty_abbrev_table (NULL); - - abbrev_ptr = dwarf_abbrev_buffer + offset; - abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); - abbrev_ptr += bytes_read; - - /* loop until we reach an abbrev number of 0 */ - while (abbrev_number) - { - cur_abbrev = dwarf_alloc_abbrev (); - - /* read in abbrev header */ - cur_abbrev->number = abbrev_number; - cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); - abbrev_ptr += bytes_read; - cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr); - abbrev_ptr += 1; - - /* now read in declarations */ - abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); - abbrev_ptr += bytes_read; - abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); - abbrev_ptr += bytes_read; - while (abbrev_name) - { - if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0) - { - cur_abbrev->attrs = (struct attr_abbrev *) - xrealloc (cur_abbrev->attrs, - (cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK) - * sizeof (struct attr_abbrev)); - } - cur_abbrev->attrs[cur_abbrev->num_attrs].name = abbrev_name; - cur_abbrev->attrs[cur_abbrev->num_attrs++].form = abbrev_form; - abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); - abbrev_ptr += bytes_read; - abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); - abbrev_ptr += bytes_read; - } - - hash_number = abbrev_number % ABBREV_HASH_SIZE; - cur_abbrev->next = dwarf2_abbrevs[hash_number]; - dwarf2_abbrevs[hash_number] = cur_abbrev; - - /* Get next abbreviation. - Under Irix6 the abbreviations for a compilation unit are not - always properly terminated with an abbrev number of 0. - Exit loop if we encounter an abbreviation which we have - already read (which means we are about to read the abbreviations - for the next compile unit) or if the end of the abbreviation - table is reached. */ - if ((unsigned int) (abbrev_ptr - dwarf_abbrev_buffer) - >= dwarf_abbrev_size) - break; - abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); - abbrev_ptr += bytes_read; - if (dwarf2_lookup_abbrev (abbrev_number) != NULL) - break; - } -} - -/* Empty the abbrev table for a new compilation unit. */ - -/* ARGSUSED */ -static void -dwarf2_empty_abbrev_table (PTR ignore) -{ - int i; - struct abbrev_info *abbrev, *next; - - for (i = 0; i < ABBREV_HASH_SIZE; ++i) - { - next = NULL; - abbrev = dwarf2_abbrevs[i]; - while (abbrev) - { - next = abbrev->next; - xfree (abbrev->attrs); - xfree (abbrev); - abbrev = next; - } - dwarf2_abbrevs[i] = NULL; - } -} - -/* Lookup an abbrev_info structure in the abbrev hash table. */ - -static struct abbrev_info * -dwarf2_lookup_abbrev (unsigned int number) -{ - unsigned int hash_number; - struct abbrev_info *abbrev; - - hash_number = number % ABBREV_HASH_SIZE; - abbrev = dwarf2_abbrevs[hash_number]; - - while (abbrev) - { - if (abbrev->number == number) - return abbrev; - else - abbrev = abbrev->next; - } - return NULL; -} - -/* Read a minimal amount of information into the minimal die structure. */ - -static char * -read_partial_die (struct partial_die_info *part_die, bfd *abfd, - char *info_ptr, const struct comp_unit_head *cu_header) -{ - unsigned int abbrev_number, bytes_read, i; - struct abbrev_info *abbrev; - struct attribute attr; - struct attribute spec_attr; - int found_spec_attr = 0; - int has_low_pc_attr = 0; - int has_high_pc_attr = 0; - - *part_die = zeroed_partial_die; - abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); - info_ptr += bytes_read; - if (!abbrev_number) - return info_ptr; - - abbrev = dwarf2_lookup_abbrev (abbrev_number); - if (!abbrev) - { - error ("Dwarf Error: Could not find abbrev number %d.", abbrev_number); - } - part_die->offset = info_ptr - dwarf_info_buffer; - part_die->tag = abbrev->tag; - part_die->has_children = abbrev->has_children; - part_die->abbrev = abbrev_number; - - for (i = 0; i < abbrev->num_attrs; ++i) - { - info_ptr = read_attribute (&attr, &abbrev->attrs[i], abfd, - info_ptr, cu_header); - - /* Store the data if it is of an attribute we want to keep in a - partial symbol table. */ - switch (attr.name) - { - case DW_AT_name: - - /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */ - if (part_die->name == NULL) - part_die->name = DW_STRING (&attr); - break; - case DW_AT_MIPS_linkage_name: - part_die->name = DW_STRING (&attr); - break; - case DW_AT_low_pc: - has_low_pc_attr = 1; - part_die->lowpc = DW_ADDR (&attr); - break; - case DW_AT_high_pc: - has_high_pc_attr = 1; - part_die->highpc = DW_ADDR (&attr); - break; - case DW_AT_location: - part_die->locdesc = DW_BLOCK (&attr); - break; - case DW_AT_language: - part_die->language = DW_UNSND (&attr); - break; - case DW_AT_external: - part_die->is_external = DW_UNSND (&attr); - break; - case DW_AT_declaration: - part_die->is_declaration = DW_UNSND (&attr); - break; - case DW_AT_type: - part_die->has_type = 1; - break; - case DW_AT_abstract_origin: - case DW_AT_specification: - found_spec_attr = 1; - spec_attr = attr; - break; - case DW_AT_sibling: - /* Ignore absolute siblings, they might point outside of - the current compile unit. */ - if (attr.form == DW_FORM_ref_addr) - complain (&dwarf2_absolute_sibling_complaint); - else - part_die->sibling = - dwarf_info_buffer + dwarf2_get_ref_die_offset (&attr); - break; - default: - break; - } - } - - /* If we found a reference attribute and the die has no name, try - to find a name in the referred to die. */ - - if (found_spec_attr && part_die->name == NULL) - { - struct partial_die_info spec_die; - char *spec_ptr; - int dummy; - - spec_ptr = dwarf_info_buffer + dwarf2_get_ref_die_offset (&spec_attr); - read_partial_die (&spec_die, abfd, spec_ptr, cu_header); - if (spec_die.name) - { - part_die->name = spec_die.name; - - /* Copy DW_AT_external attribute if it is set. */ - if (spec_die.is_external) - part_die->is_external = spec_die.is_external; - } - } - - /* When using the GNU linker, .gnu.linkonce. sections are used to - eliminate duplicate copies of functions and vtables and such. - The linker will arbitrarily choose one and discard the others. - The AT_*_pc values for such functions refer to local labels in - these sections. If the section from that file was discarded, the - labels are not in the output, so the relocs get a value of 0. - If this is a discarded function, mark the pc bounds as invalid, - so that GDB will ignore it. */ - if (has_low_pc_attr && has_high_pc_attr - && part_die->lowpc < part_die->highpc - && (part_die->lowpc != 0 - || (bfd_get_file_flags (abfd) & HAS_RELOC))) - part_die->has_pc_info = 1; - return info_ptr; -} - -/* Read the die from the .debug_info section buffer. And set diep to - point to a newly allocated die with its information. */ - -static char * -read_full_die (struct die_info **diep, bfd *abfd, char *info_ptr, - const struct comp_unit_head *cu_header) -{ - unsigned int abbrev_number, bytes_read, i, offset; - struct abbrev_info *abbrev; - struct die_info *die; - - offset = info_ptr - dwarf_info_buffer; - abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); - info_ptr += bytes_read; - if (!abbrev_number) - { - die = dwarf_alloc_die (); - die->tag = 0; - die->abbrev = abbrev_number; - die->type = NULL; - *diep = die; - return info_ptr; - } - - abbrev = dwarf2_lookup_abbrev (abbrev_number); - if (!abbrev) - { - error ("Dwarf Error: could not find abbrev number %d.", abbrev_number); - } - die = dwarf_alloc_die (); - die->offset = offset; - die->tag = abbrev->tag; - die->has_children = abbrev->has_children; - die->abbrev = abbrev_number; - die->type = NULL; - - die->num_attrs = abbrev->num_attrs; - die->attrs = (struct attribute *) - xmalloc (die->num_attrs * sizeof (struct attribute)); - - for (i = 0; i < abbrev->num_attrs; ++i) - { - info_ptr = read_attribute (&die->attrs[i], &abbrev->attrs[i], - abfd, info_ptr, cu_header); - } - - *diep = die; - return info_ptr; -} - -/* Read an attribute value described by an attribute form. */ - -static char * -read_attribute_value (struct attribute *attr, unsigned form, - bfd *abfd, char *info_ptr, - const struct comp_unit_head *cu_header) -{ - unsigned int bytes_read; - struct dwarf_block *blk; - - attr->form = form; - switch (form) - { - case DW_FORM_addr: - case DW_FORM_ref_addr: - DW_ADDR (attr) = read_address (abfd, info_ptr, cu_header, &bytes_read); - info_ptr += bytes_read; - break; - case DW_FORM_block2: - blk = dwarf_alloc_block (); - blk->size = read_2_bytes (abfd, info_ptr); - info_ptr += 2; - blk->data = read_n_bytes (abfd, info_ptr, blk->size); - info_ptr += blk->size; - DW_BLOCK (attr) = blk; - break; - case DW_FORM_block4: - blk = dwarf_alloc_block (); - blk->size = read_4_bytes (abfd, info_ptr); - info_ptr += 4; - blk->data = read_n_bytes (abfd, info_ptr, blk->size); - info_ptr += blk->size; - DW_BLOCK (attr) = blk; - break; - case DW_FORM_data2: - DW_UNSND (attr) = read_2_bytes (abfd, info_ptr); - info_ptr += 2; - break; - case DW_FORM_data4: - DW_UNSND (attr) = read_4_bytes (abfd, info_ptr); - info_ptr += 4; - break; - case DW_FORM_data8: - DW_UNSND (attr) = read_8_bytes (abfd, info_ptr); - info_ptr += 8; - break; - case DW_FORM_string: - DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read); - info_ptr += bytes_read; - break; - case DW_FORM_strp: - DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header, - &bytes_read); - info_ptr += bytes_read; - break; - case DW_FORM_block: - blk = dwarf_alloc_block (); - blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); - info_ptr += bytes_read; - blk->data = read_n_bytes (abfd, info_ptr, blk->size); - info_ptr += blk->size; - DW_BLOCK (attr) = blk; - break; - case DW_FORM_block1: - blk = dwarf_alloc_block (); - blk->size = read_1_byte (abfd, info_ptr); - info_ptr += 1; - blk->data = read_n_bytes (abfd, info_ptr, blk->size); - info_ptr += blk->size; - DW_BLOCK (attr) = blk; - break; - case DW_FORM_data1: - DW_UNSND (attr) = read_1_byte (abfd, info_ptr); - info_ptr += 1; - break; - case DW_FORM_flag: - DW_UNSND (attr) = read_1_byte (abfd, info_ptr); - info_ptr += 1; - break; - case DW_FORM_sdata: - DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read); - info_ptr += bytes_read; - break; - case DW_FORM_udata: - DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); - info_ptr += bytes_read; - break; - case DW_FORM_ref1: - DW_UNSND (attr) = read_1_byte (abfd, info_ptr); - info_ptr += 1; - break; - case DW_FORM_ref2: - DW_UNSND (attr) = read_2_bytes (abfd, info_ptr); - info_ptr += 2; - break; - case DW_FORM_ref4: - DW_UNSND (attr) = read_4_bytes (abfd, info_ptr); - info_ptr += 4; - break; - case DW_FORM_ref8: - DW_UNSND (attr) = read_8_bytes (abfd, info_ptr); - info_ptr += 8; - break; - case DW_FORM_ref_udata: - DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); - info_ptr += bytes_read; - break; - case DW_FORM_indirect: - form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); - info_ptr += bytes_read; - info_ptr = read_attribute_value (attr, form, abfd, info_ptr, cu_header); - break; - default: - error ("Dwarf Error: Cannot handle %s in DWARF reader.", - dwarf_form_name (form)); - } - return info_ptr; -} - -/* Read an attribute described by an abbreviated attribute. */ - -static char * -read_attribute (struct attribute *attr, struct attr_abbrev *abbrev, - bfd *abfd, char *info_ptr, - const struct comp_unit_head *cu_header) -{ - attr->name = abbrev->name; - return read_attribute_value (attr, abbrev->form, abfd, info_ptr, cu_header); -} - -/* read dwarf information from a buffer */ - -static unsigned int -read_1_byte (bfd *abfd, char *buf) -{ - return bfd_get_8 (abfd, (bfd_byte *) buf); -} - -static int -read_1_signed_byte (bfd *abfd, char *buf) -{ - return bfd_get_signed_8 (abfd, (bfd_byte *) buf); -} - -static unsigned int -read_2_bytes (bfd *abfd, char *buf) -{ - return bfd_get_16 (abfd, (bfd_byte *) buf); -} - -static int -read_2_signed_bytes (bfd *abfd, char *buf) -{ - return bfd_get_signed_16 (abfd, (bfd_byte *) buf); -} - -static unsigned int -read_4_bytes (bfd *abfd, char *buf) -{ - return bfd_get_32 (abfd, (bfd_byte *) buf); -} - -static int -read_4_signed_bytes (bfd *abfd, char *buf) -{ - return bfd_get_signed_32 (abfd, (bfd_byte *) buf); -} - -static unsigned long -read_8_bytes (bfd *abfd, char *buf) -{ - return bfd_get_64 (abfd, (bfd_byte *) buf); -} - -static CORE_ADDR -read_address (bfd *abfd, char *buf, const struct comp_unit_head *cu_header, - int *bytes_read) -{ - CORE_ADDR retval = 0; - - if (cu_header->signed_addr_p) - { - switch (cu_header->addr_size) - { - case 2: - retval = bfd_get_signed_16 (abfd, (bfd_byte *) buf); - break; - case 4: - retval = bfd_get_signed_32 (abfd, (bfd_byte *) buf); - break; - case 8: - retval = bfd_get_signed_64 (abfd, (bfd_byte *) buf); - break; - default: - internal_error (__FILE__, __LINE__, - "read_address: bad switch, signed"); - } - } - else - { - switch (cu_header->addr_size) - { - case 2: - retval = bfd_get_16 (abfd, (bfd_byte *) buf); - break; - case 4: - retval = bfd_get_32 (abfd, (bfd_byte *) buf); - break; - case 8: - retval = bfd_get_64 (abfd, (bfd_byte *) buf); - break; - default: - internal_error (__FILE__, __LINE__, - "read_address: bad switch, unsigned"); - } - } - - *bytes_read = cu_header->addr_size; - return retval; -} - -/* Reads the initial length from a section. The (draft) DWARF 2.1 - specification allows the initial length to take up either 4 bytes - or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8 - bytes describe the length and all offsets will be 8 bytes in length - instead of 4. - - The value returned via bytes_read should be used to increment - the relevant pointer after calling read_initial_length(). - - As a side effect, this function sets the fields initial_length_size - and offset_size in cu_header to the values appropriate for the - length field. (The format of the initial length field determines - the width of file offsets to be fetched later with fetch_offset().) - - [ Note: read_initial_length() and read_offset() are based on the - document entitled "DWARF Debugging Information Format", revision - 2.1, draft 4, dated July 20, 2000. This document was obtained - from: - - http://reality.sgi.com/dehnert_engr/dwarf/dwarf2p1-draft4-000720.pdf - - This document is only a draft and is subject to change. (So beware.) - - - Kevin, Aug 4, 2000 - ] */ - -static LONGEST -read_initial_length (bfd *abfd, char *buf, struct comp_unit_head *cu_header, - int *bytes_read) -{ - LONGEST retval = 0; - - retval = bfd_get_32 (abfd, (bfd_byte *) buf); - - if (retval == 0xffffffff) - { - retval = bfd_get_64 (abfd, (bfd_byte *) buf + 4); - *bytes_read = 12; - if (cu_header != NULL) - { - cu_header->initial_length_size = 12; - cu_header->offset_size = 8; - } - } - else - { - *bytes_read = 4; - if (cu_header != NULL) - { - cu_header->initial_length_size = 4; - cu_header->offset_size = 4; - } - } - - return retval; -} - -/* Read an offset from the data stream. The size of the offset is - given by cu_header->offset_size. */ - -static LONGEST -read_offset (bfd *abfd, char *buf, const struct comp_unit_head *cu_header, - int *bytes_read) -{ - LONGEST retval = 0; - - switch (cu_header->offset_size) - { - case 4: - retval = bfd_get_32 (abfd, (bfd_byte *) buf); - *bytes_read = 4; - break; - case 8: - retval = bfd_get_64 (abfd, (bfd_byte *) buf); - *bytes_read = 8; - break; - default: - internal_error (__FILE__, __LINE__, - "read_offset: bad switch"); - } - - return retval; -} - -static char * -read_n_bytes (bfd *abfd, char *buf, unsigned int size) -{ - /* If the size of a host char is 8 bits, we can return a pointer - to the buffer, otherwise we have to copy the data to a buffer - allocated on the temporary obstack. */ - gdb_assert (HOST_CHAR_BIT == 8); - return buf; -} - -static char * -read_string (bfd *abfd, char *buf, unsigned int *bytes_read_ptr) -{ - /* If the size of a host char is 8 bits, we can return a pointer - to the string, otherwise we have to copy the string to a buffer - allocated on the temporary obstack. */ - gdb_assert (HOST_CHAR_BIT == 8); - if (*buf == '\0') - { - *bytes_read_ptr = 1; - return NULL; - } - *bytes_read_ptr = strlen (buf) + 1; - return buf; -} - -static char * -read_indirect_string (bfd *abfd, char *buf, - const struct comp_unit_head *cu_header, - unsigned int *bytes_read_ptr) -{ - LONGEST str_offset = read_offset (abfd, buf, cu_header, - (int *) bytes_read_ptr); - - if (dwarf_str_buffer == NULL) - { - error ("DW_FORM_strp used without .debug_str section"); - return NULL; - } - if (str_offset >= dwarf_str_size) - { - error ("DW_FORM_strp pointing outside of .debug_str section"); - return NULL; - } - gdb_assert (HOST_CHAR_BIT == 8); - if (dwarf_str_buffer[str_offset] == '\0') - return NULL; - return dwarf_str_buffer + str_offset; -} - -static unsigned long -read_unsigned_leb128 (bfd *abfd, char *buf, unsigned int *bytes_read_ptr) -{ - unsigned long result; - unsigned int num_read; - int i, shift; - unsigned char byte; - - result = 0; - shift = 0; - num_read = 0; - i = 0; - while (1) - { - byte = bfd_get_8 (abfd, (bfd_byte *) buf); - buf++; - num_read++; - result |= ((unsigned long)(byte & 127) << shift); - if ((byte & 128) == 0) - { - break; - } - shift += 7; - } - *bytes_read_ptr = num_read; - return result; -} - -static long -read_signed_leb128 (bfd *abfd, char *buf, unsigned int *bytes_read_ptr) -{ - long result; - int i, shift, size, num_read; - unsigned char byte; - - result = 0; - shift = 0; - size = 32; - num_read = 0; - i = 0; - while (1) - { - byte = bfd_get_8 (abfd, (bfd_byte *) buf); - buf++; - num_read++; - result |= ((long)(byte & 127) << shift); - shift += 7; - if ((byte & 128) == 0) - { - break; - } - } - if ((shift < size) && (byte & 0x40)) - { - result |= -(1 << shift); - } - *bytes_read_ptr = num_read; - return result; -} - -static void -set_cu_language (unsigned int lang) -{ - switch (lang) - { - case DW_LANG_C89: - case DW_LANG_C: - cu_language = language_c; - break; - case DW_LANG_C_plus_plus: - cu_language = language_cplus; - break; - case DW_LANG_Fortran77: - case DW_LANG_Fortran90: - case DW_LANG_Fortran95: - cu_language = language_fortran; - break; - case DW_LANG_Mips_Assembler: - cu_language = language_asm; - break; - case DW_LANG_Java: - cu_language = language_java; - break; - case DW_LANG_Ada83: - case DW_LANG_Cobol74: - case DW_LANG_Cobol85: - case DW_LANG_Pascal83: - case DW_LANG_Modula2: - default: - cu_language = language_unknown; - break; - } - cu_language_defn = language_def (cu_language); -} - -/* Return the named attribute or NULL if not there. */ - -static struct attribute * -dwarf_attr (struct die_info *die, unsigned int name) -{ - unsigned int i; - struct attribute *spec = NULL; - - for (i = 0; i < die->num_attrs; ++i) - { - if (die->attrs[i].name == name) - { - return &die->attrs[i]; - } - if (die->attrs[i].name == DW_AT_specification - || die->attrs[i].name == DW_AT_abstract_origin) - spec = &die->attrs[i]; - } - if (spec) - { - struct die_info *ref_die = - follow_die_ref (dwarf2_get_ref_die_offset (spec)); - - if (ref_die) - return dwarf_attr (ref_die, name); - } - - return NULL; -} - -static int -die_is_declaration (struct die_info *die) -{ - return (dwarf_attr (die, DW_AT_declaration) - && ! dwarf_attr (die, DW_AT_specification)); -} - -/* Decode the line number information for the compilation unit whose - line number info is at OFFSET in the .debug_line section. - The compilation directory of the file is passed in COMP_DIR. */ - -struct filenames -{ - unsigned int num_files; - struct fileinfo - { - char *name; - unsigned int dir; - unsigned int time; - unsigned int size; - } - *files; -}; - -struct directories - { - unsigned int num_dirs; - char **dirs; - }; - -static void -dwarf_decode_lines (unsigned int offset, char *comp_dir, bfd *abfd, - const struct comp_unit_head *cu_header) -{ - char *line_ptr; - char *line_end; - struct line_head lh; - struct cleanup *back_to; - unsigned int i, bytes_read; - char *cur_file, *cur_dir; - unsigned char op_code, extended_op, adj_opcode; - -#define FILE_ALLOC_CHUNK 5 -#define DIR_ALLOC_CHUNK 5 - - struct filenames files; - struct directories dirs; - - if (dwarf_line_buffer == NULL) - { - complain (&dwarf2_missing_line_number_section); - return; - } - - files.num_files = 0; - files.files = NULL; - - dirs.num_dirs = 0; - dirs.dirs = NULL; - - line_ptr = dwarf_line_buffer + offset; - - /* read in the prologue */ - lh.total_length = read_initial_length (abfd, line_ptr, NULL, &bytes_read); - line_ptr += bytes_read; - line_end = line_ptr + lh.total_length; - lh.version = read_2_bytes (abfd, line_ptr); - line_ptr += 2; - lh.prologue_length = read_offset (abfd, line_ptr, cu_header, &bytes_read); - line_ptr += bytes_read; - lh.minimum_instruction_length = read_1_byte (abfd, line_ptr); - line_ptr += 1; - lh.default_is_stmt = read_1_byte (abfd, line_ptr); - line_ptr += 1; - lh.line_base = read_1_signed_byte (abfd, line_ptr); - line_ptr += 1; - lh.line_range = read_1_byte (abfd, line_ptr); - line_ptr += 1; - lh.opcode_base = read_1_byte (abfd, line_ptr); - line_ptr += 1; - lh.standard_opcode_lengths = (unsigned char *) - xmalloc (lh.opcode_base * sizeof (unsigned char)); - back_to = make_cleanup (free_current_contents, &lh.standard_opcode_lengths); - - lh.standard_opcode_lengths[0] = 1; - for (i = 1; i < lh.opcode_base; ++i) - { - lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr); - line_ptr += 1; - } - - /* Read directory table */ - while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL) - { - line_ptr += bytes_read; - if ((dirs.num_dirs % DIR_ALLOC_CHUNK) == 0) - { - dirs.dirs = (char **) - xrealloc (dirs.dirs, - (dirs.num_dirs + DIR_ALLOC_CHUNK) * sizeof (char *)); - if (dirs.num_dirs == 0) - make_cleanup (free_current_contents, &dirs.dirs); - } - dirs.dirs[dirs.num_dirs++] = cur_dir; - } - line_ptr += bytes_read; - - /* Read file name table */ - while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL) - { - line_ptr += bytes_read; - if ((files.num_files % FILE_ALLOC_CHUNK) == 0) - { - files.files = (struct fileinfo *) - xrealloc (files.files, - (files.num_files + FILE_ALLOC_CHUNK) - * sizeof (struct fileinfo)); - if (files.num_files == 0) - make_cleanup (free_current_contents, &files.files); - } - files.files[files.num_files].name = cur_file; - files.files[files.num_files].dir = - read_unsigned_leb128 (abfd, line_ptr, &bytes_read); - line_ptr += bytes_read; - files.files[files.num_files].time = - read_unsigned_leb128 (abfd, line_ptr, &bytes_read); - line_ptr += bytes_read; - files.files[files.num_files].size = - read_unsigned_leb128 (abfd, line_ptr, &bytes_read); - line_ptr += bytes_read; - files.num_files++; - } - line_ptr += bytes_read; - - /* Read the statement sequences until there's nothing left. */ - while (line_ptr < line_end) - { - /* state machine registers */ - CORE_ADDR address = 0; - unsigned int file = 1; - unsigned int line = 1; - unsigned int column = 0; - int is_stmt = lh.default_is_stmt; - int basic_block = 0; - int end_sequence = 0; - - /* Start a subfile for the current file of the state machine. */ - if (files.num_files >= file) - { - /* The file and directory tables are 0 based, the references - are 1 based. */ - dwarf2_start_subfile (files.files[file - 1].name, - (files.files[file - 1].dir - ? dirs.dirs[files.files[file - 1].dir - 1] - : comp_dir)); - } - - /* Decode the table. */ - while (!end_sequence) - { - op_code = read_1_byte (abfd, line_ptr); - line_ptr += 1; - - if (op_code >= lh.opcode_base) - { /* Special operand. */ - adj_opcode = op_code - lh.opcode_base; - address += (adj_opcode / lh.line_range) - * lh.minimum_instruction_length; - line += lh.line_base + (adj_opcode % lh.line_range); - /* append row to matrix using current values */ - record_line (current_subfile, line, address); - basic_block = 1; - } - else switch (op_code) - { - case DW_LNS_extended_op: - line_ptr += 1; /* ignore length */ - extended_op = read_1_byte (abfd, line_ptr); - line_ptr += 1; - switch (extended_op) - { - case DW_LNE_end_sequence: - end_sequence = 1; - /* Don't call record_line here. The end_sequence - instruction provides the address of the first byte - *after* the last line in the sequence; it's not the - address of any real source line. However, the GDB - linetable structure only records the starts of lines, - not the ends. This is a weakness of GDB. */ - break; - case DW_LNE_set_address: - address = read_address (abfd, line_ptr, cu_header, &bytes_read); - line_ptr += bytes_read; - address += baseaddr; - break; - case DW_LNE_define_file: - cur_file = read_string (abfd, line_ptr, &bytes_read); - line_ptr += bytes_read; - if ((files.num_files % FILE_ALLOC_CHUNK) == 0) - { - files.files = (struct fileinfo *) - xrealloc (files.files, - (files.num_files + FILE_ALLOC_CHUNK) - * sizeof (struct fileinfo)); - if (files.num_files == 0) - make_cleanup (free_current_contents, &files.files); - } - files.files[files.num_files].name = cur_file; - files.files[files.num_files].dir = - read_unsigned_leb128 (abfd, line_ptr, &bytes_read); - line_ptr += bytes_read; - files.files[files.num_files].time = - read_unsigned_leb128 (abfd, line_ptr, &bytes_read); - line_ptr += bytes_read; - files.files[files.num_files].size = - read_unsigned_leb128 (abfd, line_ptr, &bytes_read); - line_ptr += bytes_read; - files.num_files++; - break; - default: - complain (&dwarf2_mangled_line_number_section); - goto done; - } - break; - case DW_LNS_copy: - record_line (current_subfile, line, address); - basic_block = 0; - break; - case DW_LNS_advance_pc: - address += lh.minimum_instruction_length - * read_unsigned_leb128 (abfd, line_ptr, &bytes_read); - line_ptr += bytes_read; - break; - case DW_LNS_advance_line: - line += read_signed_leb128 (abfd, line_ptr, &bytes_read); - line_ptr += bytes_read; - break; - case DW_LNS_set_file: - /* The file and directory tables are 0 based, the references - are 1 based. */ - file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read); - line_ptr += bytes_read; - dwarf2_start_subfile - (files.files[file - 1].name, - (files.files[file - 1].dir - ? dirs.dirs[files.files[file - 1].dir - 1] - : comp_dir)); - break; - case DW_LNS_set_column: - column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read); - line_ptr += bytes_read; - break; - case DW_LNS_negate_stmt: - is_stmt = (!is_stmt); - break; - case DW_LNS_set_basic_block: - basic_block = 1; - break; - /* Add to the address register of the state machine the - address increment value corresponding to special opcode - 255. Ie, this value is scaled by the minimum instruction - length since special opcode 255 would have scaled the - the increment. */ - case DW_LNS_const_add_pc: - address += (lh.minimum_instruction_length - * ((255 - lh.opcode_base) / lh.line_range)); - break; - case DW_LNS_fixed_advance_pc: - address += read_2_bytes (abfd, line_ptr); - line_ptr += 2; - break; - default: - { /* Unknown standard opcode, ignore it. */ - int i; - for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++) - { - (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read); - line_ptr += bytes_read; - } - } - } - } - } -done: - do_cleanups (back_to); -} - -/* Start a subfile for DWARF. FILENAME is the name of the file and - DIRNAME the name of the source directory which contains FILENAME - or NULL if not known. - This routine tries to keep line numbers from identical absolute and - relative file names in a common subfile. - - Using the `list' example from the GDB testsuite, which resides in - /srcdir and compiling it with Irix6.2 cc in /compdir using a filename - of /srcdir/list0.c yields the following debugging information for list0.c: - - DW_AT_name: /srcdir/list0.c - DW_AT_comp_dir: /compdir - files.files[0].name: list0.h - files.files[0].dir: /srcdir - files.files[1].name: list0.c - files.files[1].dir: /srcdir - - The line number information for list0.c has to end up in a single - subfile, so that `break /srcdir/list0.c:1' works as expected. */ - -static void -dwarf2_start_subfile (char *filename, char *dirname) -{ - /* If the filename isn't absolute, try to match an existing subfile - with the full pathname. */ - - if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL) - { - struct subfile *subfile; - char *fullname = concat (dirname, "/", filename, NULL); - - for (subfile = subfiles; subfile; subfile = subfile->next) - { - if (FILENAME_CMP (subfile->name, fullname) == 0) - { - current_subfile = subfile; - xfree (fullname); - return; - } - } - xfree (fullname); - } - start_subfile (filename, dirname); -} - -/* Given a pointer to a DWARF information entry, figure out if we need - to make a symbol table entry for it, and if so, create a new entry - and return a pointer to it. - If TYPE is NULL, determine symbol type from the die, otherwise - used the passed type. */ - -static struct symbol * -new_symbol (struct die_info *die, struct type *type, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - struct symbol *sym = NULL; - char *name; - struct attribute *attr = NULL; - struct attribute *attr2 = NULL; - CORE_ADDR addr; - - name = dwarf2_linkage_name (die); - if (name) - { - sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack, - sizeof (struct symbol)); - OBJSTAT (objfile, n_syms++); - memset (sym, 0, sizeof (struct symbol)); - SYMBOL_NAME (sym) = obsavestring (name, strlen (name), - &objfile->symbol_obstack); - - /* Default assumptions. - Use the passed type or decode it from the die. */ - SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; - SYMBOL_CLASS (sym) = LOC_STATIC; - if (type != NULL) - SYMBOL_TYPE (sym) = type; - else - SYMBOL_TYPE (sym) = die_type (die, objfile, cu_header); - attr = dwarf_attr (die, DW_AT_decl_line); - if (attr) - { - SYMBOL_LINE (sym) = DW_UNSND (attr); - } - - /* If this symbol is from a C++ compilation, then attempt to - cache the demangled form for future reference. This is a - typical time versus space tradeoff, that was decided in favor - of time because it sped up C++ symbol lookups by a factor of - about 20. */ - - SYMBOL_LANGUAGE (sym) = cu_language; - SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->symbol_obstack); - switch (die->tag) - { - case DW_TAG_label: - attr = dwarf_attr (die, DW_AT_low_pc); - if (attr) - { - SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr) + baseaddr; - } - SYMBOL_CLASS (sym) = LOC_LABEL; - break; - case DW_TAG_subprogram: - /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by - finish_block. */ - SYMBOL_CLASS (sym) = LOC_BLOCK; - attr2 = dwarf_attr (die, DW_AT_external); - if (attr2 && (DW_UNSND (attr2) != 0)) - { - add_symbol_to_list (sym, &global_symbols); - } - else - { - add_symbol_to_list (sym, list_in_scope); - } - break; - case DW_TAG_variable: - /* Compilation with minimal debug info may result in variables - with missing type entries. Change the misleading `void' type - to something sensible. */ - if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID) - SYMBOL_TYPE (sym) = init_type (TYPE_CODE_INT, - TARGET_INT_BIT / HOST_CHAR_BIT, 0, - "<variable, no debug info>", - objfile); - attr = dwarf_attr (die, DW_AT_const_value); - if (attr) - { - dwarf2_const_value (attr, sym, objfile, cu_header); - attr2 = dwarf_attr (die, DW_AT_external); - if (attr2 && (DW_UNSND (attr2) != 0)) - add_symbol_to_list (sym, &global_symbols); - else - add_symbol_to_list (sym, list_in_scope); - break; - } - attr = dwarf_attr (die, DW_AT_location); - if (attr) - { - attr2 = dwarf_attr (die, DW_AT_external); - if (attr2 && (DW_UNSND (attr2) != 0)) - { - SYMBOL_VALUE_ADDRESS (sym) = - decode_locdesc (DW_BLOCK (attr), objfile, cu_header); - add_symbol_to_list (sym, &global_symbols); - - /* In shared libraries the address of the variable - in the location descriptor might still be relocatable, - so its value could be zero. - Enter the symbol as a LOC_UNRESOLVED symbol, if its - value is zero, the address of the variable will then - be determined from the minimal symbol table whenever - the variable is referenced. */ - if (SYMBOL_VALUE_ADDRESS (sym)) - { - fixup_symbol_section (sym, objfile); - SYMBOL_VALUE_ADDRESS (sym) += - ANOFFSET (objfile->section_offsets, - SYMBOL_SECTION (sym)); - SYMBOL_CLASS (sym) = LOC_STATIC; - } - else - SYMBOL_CLASS (sym) = LOC_UNRESOLVED; - } - else - { - SYMBOL_VALUE (sym) = addr = - decode_locdesc (DW_BLOCK (attr), objfile, cu_header); - add_symbol_to_list (sym, list_in_scope); - if (optimized_out) - { - SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT; - } - else if (isreg) - { - SYMBOL_CLASS (sym) = LOC_REGISTER; - SYMBOL_VALUE (sym) = - DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym)); - } - else if (offreg) - { - SYMBOL_CLASS (sym) = LOC_BASEREG; - SYMBOL_BASEREG (sym) = DWARF2_REG_TO_REGNUM (basereg); - } - else if (islocal) - { - SYMBOL_CLASS (sym) = LOC_LOCAL; - } - else - { - fixup_symbol_section (sym, objfile); - SYMBOL_VALUE_ADDRESS (sym) = - addr + ANOFFSET (objfile->section_offsets, - SYMBOL_SECTION (sym)); - SYMBOL_CLASS (sym) = LOC_STATIC; - } - } - } - else - { - /* We do not know the address of this symbol. - If it is an external symbol and we have type information - for it, enter the symbol as a LOC_UNRESOLVED symbol. - The address of the variable will then be determined from - the minimal symbol table whenever the variable is - referenced. */ - attr2 = dwarf_attr (die, DW_AT_external); - if (attr2 && (DW_UNSND (attr2) != 0) - && dwarf_attr (die, DW_AT_type) != NULL) - { - SYMBOL_CLASS (sym) = LOC_UNRESOLVED; - add_symbol_to_list (sym, &global_symbols); - } - } - break; - case DW_TAG_formal_parameter: - attr = dwarf_attr (die, DW_AT_location); - if (attr) - { - SYMBOL_VALUE (sym) = - decode_locdesc (DW_BLOCK (attr), objfile, cu_header); - if (isreg) - { - SYMBOL_CLASS (sym) = LOC_REGPARM; - SYMBOL_VALUE (sym) = - DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym)); - } - else if (offreg) - { - if (isderef) - { - if (basereg != frame_base_reg) - complain (&dwarf2_complex_location_expr); - SYMBOL_CLASS (sym) = LOC_REF_ARG; - } - else - { - SYMBOL_CLASS (sym) = LOC_BASEREG_ARG; - SYMBOL_BASEREG (sym) = DWARF2_REG_TO_REGNUM (basereg); - } - } - else - { - SYMBOL_CLASS (sym) = LOC_ARG; - } - } - attr = dwarf_attr (die, DW_AT_const_value); - if (attr) - { - dwarf2_const_value (attr, sym, objfile, cu_header); - } - add_symbol_to_list (sym, list_in_scope); - break; - case DW_TAG_unspecified_parameters: - /* From varargs functions; gdb doesn't seem to have any - interest in this information, so just ignore it for now. - (FIXME?) */ - break; - case DW_TAG_class_type: - case DW_TAG_structure_type: - case DW_TAG_union_type: - case DW_TAG_enumeration_type: - SYMBOL_CLASS (sym) = LOC_TYPEDEF; - SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE; - add_symbol_to_list (sym, list_in_scope); - - /* The semantics of C++ state that "struct foo { ... }" also - defines a typedef for "foo". Synthesize a typedef symbol so - that "ptype foo" works as expected. */ - if (cu_language == language_cplus) - { - struct symbol *typedef_sym = (struct symbol *) - obstack_alloc (&objfile->symbol_obstack, - sizeof (struct symbol)); - *typedef_sym = *sym; - SYMBOL_NAMESPACE (typedef_sym) = VAR_NAMESPACE; - if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0) - TYPE_NAME (SYMBOL_TYPE (sym)) = - obsavestring (SYMBOL_NAME (sym), - strlen (SYMBOL_NAME (sym)), - &objfile->type_obstack); - add_symbol_to_list (typedef_sym, list_in_scope); - } - break; - case DW_TAG_typedef: - case DW_TAG_base_type: - SYMBOL_CLASS (sym) = LOC_TYPEDEF; - SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; - add_symbol_to_list (sym, list_in_scope); - break; - case DW_TAG_enumerator: - attr = dwarf_attr (die, DW_AT_const_value); - if (attr) - { - dwarf2_const_value (attr, sym, objfile, cu_header); - } - add_symbol_to_list (sym, list_in_scope); - break; - default: - /* Not a tag we recognize. Hopefully we aren't processing - trash data, but since we must specifically ignore things - we don't recognize, there is nothing else we should do at - this point. */ - complain (&dwarf2_unsupported_tag, dwarf_tag_name (die->tag)); - break; - } - } - return (sym); -} - -/* Copy constant value from an attribute to a symbol. */ - -static void -dwarf2_const_value (struct attribute *attr, struct symbol *sym, - struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - struct dwarf_block *blk; - - switch (attr->form) - { - case DW_FORM_addr: - if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != cu_header->addr_size) - complain (&dwarf2_const_value_length_mismatch, SYMBOL_NAME (sym), - cu_header->addr_size, TYPE_LENGTH (SYMBOL_TYPE (sym))); - SYMBOL_VALUE_BYTES (sym) = (char *) - obstack_alloc (&objfile->symbol_obstack, cu_header->addr_size); - store_address (SYMBOL_VALUE_BYTES (sym), cu_header->addr_size, - DW_ADDR (attr)); - SYMBOL_CLASS (sym) = LOC_CONST_BYTES; - break; - case DW_FORM_block1: - case DW_FORM_block2: - case DW_FORM_block4: - case DW_FORM_block: - blk = DW_BLOCK (attr); - if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != blk->size) - complain (&dwarf2_const_value_length_mismatch, SYMBOL_NAME (sym), - blk->size, TYPE_LENGTH (SYMBOL_TYPE (sym))); - SYMBOL_VALUE_BYTES (sym) = (char *) - obstack_alloc (&objfile->symbol_obstack, blk->size); - memcpy (SYMBOL_VALUE_BYTES (sym), blk->data, blk->size); - SYMBOL_CLASS (sym) = LOC_CONST_BYTES; - break; - - /* The DW_AT_const_value attributes are supposed to carry the - symbol's value "represented as it would be on the target - architecture." By the time we get here, it's already been - converted to host endianness, so we just need to sign- or - zero-extend it as appropriate. */ - case DW_FORM_data1: - dwarf2_const_value_data (attr, sym, 8); - break; - case DW_FORM_data2: - dwarf2_const_value_data (attr, sym, 16); - break; - case DW_FORM_data4: - dwarf2_const_value_data (attr, sym, 32); - break; - case DW_FORM_data8: - dwarf2_const_value_data (attr, sym, 64); - break; - - case DW_FORM_sdata: - SYMBOL_VALUE (sym) = DW_SND (attr); - SYMBOL_CLASS (sym) = LOC_CONST; - break; - - case DW_FORM_udata: - SYMBOL_VALUE (sym) = DW_UNSND (attr); - SYMBOL_CLASS (sym) = LOC_CONST; - break; - - default: - complain (&dwarf2_unsupported_const_value_attr, - dwarf_form_name (attr->form)); - SYMBOL_VALUE (sym) = 0; - SYMBOL_CLASS (sym) = LOC_CONST; - break; - } -} - - -/* Given an attr with a DW_FORM_dataN value in host byte order, sign- - or zero-extend it as appropriate for the symbol's type. */ -static void -dwarf2_const_value_data (struct attribute *attr, - struct symbol *sym, - int bits) -{ - LONGEST l = DW_UNSND (attr); - - if (bits < sizeof (l) * 8) - { - if (TYPE_UNSIGNED (SYMBOL_TYPE (sym))) - l &= ((LONGEST) 1 << bits) - 1; - else - l = (l << (sizeof (l) * 8 - bits)) >> (sizeof (l) * 8 - bits); - } - - SYMBOL_VALUE (sym) = l; - SYMBOL_CLASS (sym) = LOC_CONST; -} - - -/* Return the type of the die in question using its DW_AT_type attribute. */ - -static struct type * -die_type (struct die_info *die, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - struct type *type; - struct attribute *type_attr; - struct die_info *type_die; - unsigned int ref; - - type_attr = dwarf_attr (die, DW_AT_type); - if (!type_attr) - { - /* A missing DW_AT_type represents a void type. */ - return dwarf2_fundamental_type (objfile, FT_VOID); - } - else - { - ref = dwarf2_get_ref_die_offset (type_attr); - type_die = follow_die_ref (ref); - if (!type_die) - { - error ("Dwarf Error: Cannot find referent at offset %d.", ref); - return NULL; - } - } - type = tag_type_to_type (type_die, objfile, cu_header); - if (!type) - { - dump_die (type_die); - error ("Dwarf Error: Problem turning type die at offset into gdb type."); - } - return type; -} - -/* Return the containing type of the die in question using its - DW_AT_containing_type attribute. */ - -static struct type * -die_containing_type (struct die_info *die, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - struct type *type = NULL; - struct attribute *type_attr; - struct die_info *type_die = NULL; - unsigned int ref; - - type_attr = dwarf_attr (die, DW_AT_containing_type); - if (type_attr) - { - ref = dwarf2_get_ref_die_offset (type_attr); - type_die = follow_die_ref (ref); - if (!type_die) - { - error ("Dwarf Error: Cannot find referent at offset %d.", ref); - return NULL; - } - type = tag_type_to_type (type_die, objfile, cu_header); - } - if (!type) - { - if (type_die) - dump_die (type_die); - error ("Dwarf Error: Problem turning containing type into gdb type."); - } - return type; -} - -#if 0 -static struct type * -type_at_offset (unsigned int offset, struct objfile *objfile) -{ - struct die_info *die; - struct type *type; - - die = follow_die_ref (offset); - if (!die) - { - error ("Dwarf Error: Cannot find type referent at offset %d.", offset); - return NULL; - } - type = tag_type_to_type (die, objfile); - return type; -} -#endif - -static struct type * -tag_type_to_type (struct die_info *die, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - if (die->type) - { - return die->type; - } - else - { - read_type_die (die, objfile, cu_header); - if (!die->type) - { - dump_die (die); - error ("Dwarf Error: Cannot find type of die."); - } - return die->type; - } -} - -static void -read_type_die (struct die_info *die, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - switch (die->tag) - { - case DW_TAG_class_type: - case DW_TAG_structure_type: - case DW_TAG_union_type: - read_structure_scope (die, objfile, cu_header); - break; - case DW_TAG_enumeration_type: - read_enumeration (die, objfile, cu_header); - break; - case DW_TAG_subprogram: - case DW_TAG_subroutine_type: - read_subroutine_type (die, objfile, cu_header); - break; - case DW_TAG_array_type: - read_array_type (die, objfile, cu_header); - break; - case DW_TAG_pointer_type: - read_tag_pointer_type (die, objfile, cu_header); - break; - case DW_TAG_ptr_to_member_type: - read_tag_ptr_to_member_type (die, objfile, cu_header); - break; - case DW_TAG_reference_type: - read_tag_reference_type (die, objfile, cu_header); - break; - case DW_TAG_const_type: - read_tag_const_type (die, objfile, cu_header); - break; - case DW_TAG_volatile_type: - read_tag_volatile_type (die, objfile, cu_header); - break; - case DW_TAG_string_type: - read_tag_string_type (die, objfile); - break; - case DW_TAG_typedef: - read_typedef (die, objfile, cu_header); - break; - case DW_TAG_base_type: - read_base_type (die, objfile); - break; - default: - complain (&dwarf2_unexpected_tag, dwarf_tag_name (die->tag)); - break; - } -} - -static struct type * -dwarf_base_type (int encoding, int size, struct objfile *objfile) -{ - /* FIXME - this should not produce a new (struct type *) - every time. It should cache base types. */ - struct type *type; - switch (encoding) - { - case DW_ATE_address: - type = dwarf2_fundamental_type (objfile, FT_VOID); - return type; - case DW_ATE_boolean: - type = dwarf2_fundamental_type (objfile, FT_BOOLEAN); - return type; - case DW_ATE_complex_float: - if (size == 16) - { - type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_COMPLEX); - } - else - { - type = dwarf2_fundamental_type (objfile, FT_COMPLEX); - } - return type; - case DW_ATE_float: - if (size == 8) - { - type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT); - } - else - { - type = dwarf2_fundamental_type (objfile, FT_FLOAT); - } - return type; - case DW_ATE_signed: - switch (size) - { - case 1: - type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR); - break; - case 2: - type = dwarf2_fundamental_type (objfile, FT_SIGNED_SHORT); - break; - default: - case 4: - type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER); - break; - } - return type; - case DW_ATE_signed_char: - type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR); - return type; - case DW_ATE_unsigned: - switch (size) - { - case 1: - type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR); - break; - case 2: - type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_SHORT); - break; - default: - case 4: - type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_INTEGER); - break; - } - return type; - case DW_ATE_unsigned_char: - type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR); - return type; - default: - type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER); - return type; - } -} - -#if 0 -struct die_info * -copy_die (struct die_info *old_die) -{ - struct die_info *new_die; - int i, num_attrs; - - new_die = (struct die_info *) xmalloc (sizeof (struct die_info)); - memset (new_die, 0, sizeof (struct die_info)); - - new_die->tag = old_die->tag; - new_die->has_children = old_die->has_children; - new_die->abbrev = old_die->abbrev; - new_die->offset = old_die->offset; - new_die->type = NULL; - - num_attrs = old_die->num_attrs; - new_die->num_attrs = num_attrs; - new_die->attrs = (struct attribute *) - xmalloc (num_attrs * sizeof (struct attribute)); - - for (i = 0; i < old_die->num_attrs; ++i) - { - new_die->attrs[i].name = old_die->attrs[i].name; - new_die->attrs[i].form = old_die->attrs[i].form; - new_die->attrs[i].u.addr = old_die->attrs[i].u.addr; - } - - new_die->next = NULL; - return new_die; -} -#endif - -/* Return sibling of die, NULL if no sibling. */ - -static struct die_info * -sibling_die (struct die_info *die) -{ - int nesting_level = 0; - - if (!die->has_children) - { - if (die->next && (die->next->tag == 0)) - { - return NULL; - } - else - { - return die->next; - } - } - else - { - do - { - if (die->has_children) - { - nesting_level++; - } - if (die->tag == 0) - { - nesting_level--; - } - die = die->next; - } - while (nesting_level); - if (die && (die->tag == 0)) - { - return NULL; - } - else - { - return die; - } - } -} - -/* Get linkage name of a die, return NULL if not found. */ - -static char * -dwarf2_linkage_name (struct die_info *die) -{ - struct attribute *attr; - - attr = dwarf_attr (die, DW_AT_MIPS_linkage_name); - if (attr && DW_STRING (attr)) - return DW_STRING (attr); - attr = dwarf_attr (die, DW_AT_name); - if (attr && DW_STRING (attr)) - return DW_STRING (attr); - return NULL; -} - -/* Convert a DIE tag into its string name. */ - -static char * -dwarf_tag_name (register unsigned tag) -{ - switch (tag) - { - case DW_TAG_padding: - return "DW_TAG_padding"; - case DW_TAG_array_type: - return "DW_TAG_array_type"; - case DW_TAG_class_type: - return "DW_TAG_class_type"; - case DW_TAG_entry_point: - return "DW_TAG_entry_point"; - case DW_TAG_enumeration_type: - return "DW_TAG_enumeration_type"; - case DW_TAG_formal_parameter: - return "DW_TAG_formal_parameter"; - case DW_TAG_imported_declaration: - return "DW_TAG_imported_declaration"; - case DW_TAG_label: - return "DW_TAG_label"; - case DW_TAG_lexical_block: - return "DW_TAG_lexical_block"; - case DW_TAG_member: - return "DW_TAG_member"; - case DW_TAG_pointer_type: - return "DW_TAG_pointer_type"; - case DW_TAG_reference_type: - return "DW_TAG_reference_type"; - case DW_TAG_compile_unit: - return "DW_TAG_compile_unit"; - case DW_TAG_string_type: - return "DW_TAG_string_type"; - case DW_TAG_structure_type: - return "DW_TAG_structure_type"; - case DW_TAG_subroutine_type: - return "DW_TAG_subroutine_type"; - case DW_TAG_typedef: - return "DW_TAG_typedef"; - case DW_TAG_union_type: - return "DW_TAG_union_type"; - case DW_TAG_unspecified_parameters: - return "DW_TAG_unspecified_parameters"; - case DW_TAG_variant: - return "DW_TAG_variant"; - case DW_TAG_common_block: - return "DW_TAG_common_block"; - case DW_TAG_common_inclusion: - return "DW_TAG_common_inclusion"; - case DW_TAG_inheritance: - return "DW_TAG_inheritance"; - case DW_TAG_inlined_subroutine: - return "DW_TAG_inlined_subroutine"; - case DW_TAG_module: - return "DW_TAG_module"; - case DW_TAG_ptr_to_member_type: - return "DW_TAG_ptr_to_member_type"; - case DW_TAG_set_type: - return "DW_TAG_set_type"; - case DW_TAG_subrange_type: - return "DW_TAG_subrange_type"; - case DW_TAG_with_stmt: - return "DW_TAG_with_stmt"; - case DW_TAG_access_declaration: - return "DW_TAG_access_declaration"; - case DW_TAG_base_type: - return "DW_TAG_base_type"; - case DW_TAG_catch_block: - return "DW_TAG_catch_block"; - case DW_TAG_const_type: - return "DW_TAG_const_type"; - case DW_TAG_constant: - return "DW_TAG_constant"; - case DW_TAG_enumerator: - return "DW_TAG_enumerator"; - case DW_TAG_file_type: - return "DW_TAG_file_type"; - case DW_TAG_friend: - return "DW_TAG_friend"; - case DW_TAG_namelist: - return "DW_TAG_namelist"; - case DW_TAG_namelist_item: - return "DW_TAG_namelist_item"; - case DW_TAG_packed_type: - return "DW_TAG_packed_type"; - case DW_TAG_subprogram: - return "DW_TAG_subprogram"; - case DW_TAG_template_type_param: - return "DW_TAG_template_type_param"; - case DW_TAG_template_value_param: - return "DW_TAG_template_value_param"; - case DW_TAG_thrown_type: - return "DW_TAG_thrown_type"; - case DW_TAG_try_block: - return "DW_TAG_try_block"; - case DW_TAG_variant_part: - return "DW_TAG_variant_part"; - case DW_TAG_variable: - return "DW_TAG_variable"; - case DW_TAG_volatile_type: - return "DW_TAG_volatile_type"; - case DW_TAG_MIPS_loop: - return "DW_TAG_MIPS_loop"; - case DW_TAG_format_label: - return "DW_TAG_format_label"; - case DW_TAG_function_template: - return "DW_TAG_function_template"; - case DW_TAG_class_template: - return "DW_TAG_class_template"; - default: - return "DW_TAG_<unknown>"; - } -} - -/* Convert a DWARF attribute code into its string name. */ - -static char * -dwarf_attr_name (register unsigned attr) -{ - switch (attr) - { - case DW_AT_sibling: - return "DW_AT_sibling"; - case DW_AT_location: - return "DW_AT_location"; - case DW_AT_name: - return "DW_AT_name"; - case DW_AT_ordering: - return "DW_AT_ordering"; - case DW_AT_subscr_data: - return "DW_AT_subscr_data"; - case DW_AT_byte_size: - return "DW_AT_byte_size"; - case DW_AT_bit_offset: - return "DW_AT_bit_offset"; - case DW_AT_bit_size: - return "DW_AT_bit_size"; - case DW_AT_element_list: - return "DW_AT_element_list"; - case DW_AT_stmt_list: - return "DW_AT_stmt_list"; - case DW_AT_low_pc: - return "DW_AT_low_pc"; - case DW_AT_high_pc: - return "DW_AT_high_pc"; - case DW_AT_language: - return "DW_AT_language"; - case DW_AT_member: - return "DW_AT_member"; - case DW_AT_discr: - return "DW_AT_discr"; - case DW_AT_discr_value: - return "DW_AT_discr_value"; - case DW_AT_visibility: - return "DW_AT_visibility"; - case DW_AT_import: - return "DW_AT_import"; - case DW_AT_string_length: - return "DW_AT_string_length"; - case DW_AT_common_reference: - return "DW_AT_common_reference"; - case DW_AT_comp_dir: - return "DW_AT_comp_dir"; - case DW_AT_const_value: - return "DW_AT_const_value"; - case DW_AT_containing_type: - return "DW_AT_containing_type"; - case DW_AT_default_value: - return "DW_AT_default_value"; - case DW_AT_inline: - return "DW_AT_inline"; - case DW_AT_is_optional: - return "DW_AT_is_optional"; - case DW_AT_lower_bound: - return "DW_AT_lower_bound"; - case DW_AT_producer: - return "DW_AT_producer"; - case DW_AT_prototyped: - return "DW_AT_prototyped"; - case DW_AT_return_addr: - return "DW_AT_return_addr"; - case DW_AT_start_scope: - return "DW_AT_start_scope"; - case DW_AT_stride_size: - return "DW_AT_stride_size"; - case DW_AT_upper_bound: - return "DW_AT_upper_bound"; - case DW_AT_abstract_origin: - return "DW_AT_abstract_origin"; - case DW_AT_accessibility: - return "DW_AT_accessibility"; - case DW_AT_address_class: - return "DW_AT_address_class"; - case DW_AT_artificial: - return "DW_AT_artificial"; - case DW_AT_base_types: - return "DW_AT_base_types"; - case DW_AT_calling_convention: - return "DW_AT_calling_convention"; - case DW_AT_count: - return "DW_AT_count"; - case DW_AT_data_member_location: - return "DW_AT_data_member_location"; - case DW_AT_decl_column: - return "DW_AT_decl_column"; - case DW_AT_decl_file: - return "DW_AT_decl_file"; - case DW_AT_decl_line: - return "DW_AT_decl_line"; - case DW_AT_declaration: - return "DW_AT_declaration"; - case DW_AT_discr_list: - return "DW_AT_discr_list"; - case DW_AT_encoding: - return "DW_AT_encoding"; - case DW_AT_external: - return "DW_AT_external"; - case DW_AT_frame_base: - return "DW_AT_frame_base"; - case DW_AT_friend: - return "DW_AT_friend"; - case DW_AT_identifier_case: - return "DW_AT_identifier_case"; - case DW_AT_macro_info: - return "DW_AT_macro_info"; - case DW_AT_namelist_items: - return "DW_AT_namelist_items"; - case DW_AT_priority: - return "DW_AT_priority"; - case DW_AT_segment: - return "DW_AT_segment"; - case DW_AT_specification: - return "DW_AT_specification"; - case DW_AT_static_link: - return "DW_AT_static_link"; - case DW_AT_type: - return "DW_AT_type"; - case DW_AT_use_location: - return "DW_AT_use_location"; - case DW_AT_variable_parameter: - return "DW_AT_variable_parameter"; - case DW_AT_virtuality: - return "DW_AT_virtuality"; - case DW_AT_vtable_elem_location: - return "DW_AT_vtable_elem_location"; - -#ifdef MIPS - case DW_AT_MIPS_fde: - return "DW_AT_MIPS_fde"; - case DW_AT_MIPS_loop_begin: - return "DW_AT_MIPS_loop_begin"; - case DW_AT_MIPS_tail_loop_begin: - return "DW_AT_MIPS_tail_loop_begin"; - case DW_AT_MIPS_epilog_begin: - return "DW_AT_MIPS_epilog_begin"; - case DW_AT_MIPS_loop_unroll_factor: - return "DW_AT_MIPS_loop_unroll_factor"; - case DW_AT_MIPS_software_pipeline_depth: - return "DW_AT_MIPS_software_pipeline_depth"; - case DW_AT_MIPS_linkage_name: - return "DW_AT_MIPS_linkage_name"; -#endif - - case DW_AT_sf_names: - return "DW_AT_sf_names"; - case DW_AT_src_info: - return "DW_AT_src_info"; - case DW_AT_mac_info: - return "DW_AT_mac_info"; - case DW_AT_src_coords: - return "DW_AT_src_coords"; - case DW_AT_body_begin: - return "DW_AT_body_begin"; - case DW_AT_body_end: - return "DW_AT_body_end"; - default: - return "DW_AT_<unknown>"; - } -} - -/* Convert a DWARF value form code into its string name. */ - -static char * -dwarf_form_name (register unsigned form) -{ - switch (form) - { - case DW_FORM_addr: - return "DW_FORM_addr"; - case DW_FORM_block2: - return "DW_FORM_block2"; - case DW_FORM_block4: - return "DW_FORM_block4"; - case DW_FORM_data2: - return "DW_FORM_data2"; - case DW_FORM_data4: - return "DW_FORM_data4"; - case DW_FORM_data8: - return "DW_FORM_data8"; - case DW_FORM_string: - return "DW_FORM_string"; - case DW_FORM_block: - return "DW_FORM_block"; - case DW_FORM_block1: - return "DW_FORM_block1"; - case DW_FORM_data1: - return "DW_FORM_data1"; - case DW_FORM_flag: - return "DW_FORM_flag"; - case DW_FORM_sdata: - return "DW_FORM_sdata"; - case DW_FORM_strp: - return "DW_FORM_strp"; - case DW_FORM_udata: - return "DW_FORM_udata"; - case DW_FORM_ref_addr: - return "DW_FORM_ref_addr"; - case DW_FORM_ref1: - return "DW_FORM_ref1"; - case DW_FORM_ref2: - return "DW_FORM_ref2"; - case DW_FORM_ref4: - return "DW_FORM_ref4"; - case DW_FORM_ref8: - return "DW_FORM_ref8"; - case DW_FORM_ref_udata: - return "DW_FORM_ref_udata"; - case DW_FORM_indirect: - return "DW_FORM_indirect"; - default: - return "DW_FORM_<unknown>"; - } -} - -/* Convert a DWARF stack opcode into its string name. */ - -static char * -dwarf_stack_op_name (register unsigned op) -{ - switch (op) - { - case DW_OP_addr: - return "DW_OP_addr"; - case DW_OP_deref: - return "DW_OP_deref"; - case DW_OP_const1u: - return "DW_OP_const1u"; - case DW_OP_const1s: - return "DW_OP_const1s"; - case DW_OP_const2u: - return "DW_OP_const2u"; - case DW_OP_const2s: - return "DW_OP_const2s"; - case DW_OP_const4u: - return "DW_OP_const4u"; - case DW_OP_const4s: - return "DW_OP_const4s"; - case DW_OP_const8u: - return "DW_OP_const8u"; - case DW_OP_const8s: - return "DW_OP_const8s"; - case DW_OP_constu: - return "DW_OP_constu"; - case DW_OP_consts: - return "DW_OP_consts"; - case DW_OP_dup: - return "DW_OP_dup"; - case DW_OP_drop: - return "DW_OP_drop"; - case DW_OP_over: - return "DW_OP_over"; - case DW_OP_pick: - return "DW_OP_pick"; - case DW_OP_swap: - return "DW_OP_swap"; - case DW_OP_rot: - return "DW_OP_rot"; - case DW_OP_xderef: - return "DW_OP_xderef"; - case DW_OP_abs: - return "DW_OP_abs"; - case DW_OP_and: - return "DW_OP_and"; - case DW_OP_div: - return "DW_OP_div"; - case DW_OP_minus: - return "DW_OP_minus"; - case DW_OP_mod: - return "DW_OP_mod"; - case DW_OP_mul: - return "DW_OP_mul"; - case DW_OP_neg: - return "DW_OP_neg"; - case DW_OP_not: - return "DW_OP_not"; - case DW_OP_or: - return "DW_OP_or"; - case DW_OP_plus: - return "DW_OP_plus"; - case DW_OP_plus_uconst: - return "DW_OP_plus_uconst"; - case DW_OP_shl: - return "DW_OP_shl"; - case DW_OP_shr: - return "DW_OP_shr"; - case DW_OP_shra: - return "DW_OP_shra"; - case DW_OP_xor: - return "DW_OP_xor"; - case DW_OP_bra: - return "DW_OP_bra"; - case DW_OP_eq: - return "DW_OP_eq"; - case DW_OP_ge: - return "DW_OP_ge"; - case DW_OP_gt: - return "DW_OP_gt"; - case DW_OP_le: - return "DW_OP_le"; - case DW_OP_lt: - return "DW_OP_lt"; - case DW_OP_ne: - return "DW_OP_ne"; - case DW_OP_skip: - return "DW_OP_skip"; - case DW_OP_lit0: - return "DW_OP_lit0"; - case DW_OP_lit1: - return "DW_OP_lit1"; - case DW_OP_lit2: - return "DW_OP_lit2"; - case DW_OP_lit3: - return "DW_OP_lit3"; - case DW_OP_lit4: - return "DW_OP_lit4"; - case DW_OP_lit5: - return "DW_OP_lit5"; - case DW_OP_lit6: - return "DW_OP_lit6"; - case DW_OP_lit7: - return "DW_OP_lit7"; - case DW_OP_lit8: - return "DW_OP_lit8"; - case DW_OP_lit9: - return "DW_OP_lit9"; - case DW_OP_lit10: - return "DW_OP_lit10"; - case DW_OP_lit11: - return "DW_OP_lit11"; - case DW_OP_lit12: - return "DW_OP_lit12"; - case DW_OP_lit13: - return "DW_OP_lit13"; - case DW_OP_lit14: - return "DW_OP_lit14"; - case DW_OP_lit15: - return "DW_OP_lit15"; - case DW_OP_lit16: - return "DW_OP_lit16"; - case DW_OP_lit17: - return "DW_OP_lit17"; - case DW_OP_lit18: - return "DW_OP_lit18"; - case DW_OP_lit19: - return "DW_OP_lit19"; - case DW_OP_lit20: - return "DW_OP_lit20"; - case DW_OP_lit21: - return "DW_OP_lit21"; - case DW_OP_lit22: - return "DW_OP_lit22"; - case DW_OP_lit23: - return "DW_OP_lit23"; - case DW_OP_lit24: - return "DW_OP_lit24"; - case DW_OP_lit25: - return "DW_OP_lit25"; - case DW_OP_lit26: - return "DW_OP_lit26"; - case DW_OP_lit27: - return "DW_OP_lit27"; - case DW_OP_lit28: - return "DW_OP_lit28"; - case DW_OP_lit29: - return "DW_OP_lit29"; - case DW_OP_lit30: - return "DW_OP_lit30"; - case DW_OP_lit31: - return "DW_OP_lit31"; - case DW_OP_reg0: - return "DW_OP_reg0"; - case DW_OP_reg1: - return "DW_OP_reg1"; - case DW_OP_reg2: - return "DW_OP_reg2"; - case DW_OP_reg3: - return "DW_OP_reg3"; - case DW_OP_reg4: - return "DW_OP_reg4"; - case DW_OP_reg5: - return "DW_OP_reg5"; - case DW_OP_reg6: - return "DW_OP_reg6"; - case DW_OP_reg7: - return "DW_OP_reg7"; - case DW_OP_reg8: - return "DW_OP_reg8"; - case DW_OP_reg9: - return "DW_OP_reg9"; - case DW_OP_reg10: - return "DW_OP_reg10"; - case DW_OP_reg11: - return "DW_OP_reg11"; - case DW_OP_reg12: - return "DW_OP_reg12"; - case DW_OP_reg13: - return "DW_OP_reg13"; - case DW_OP_reg14: - return "DW_OP_reg14"; - case DW_OP_reg15: - return "DW_OP_reg15"; - case DW_OP_reg16: - return "DW_OP_reg16"; - case DW_OP_reg17: - return "DW_OP_reg17"; - case DW_OP_reg18: - return "DW_OP_reg18"; - case DW_OP_reg19: - return "DW_OP_reg19"; - case DW_OP_reg20: - return "DW_OP_reg20"; - case DW_OP_reg21: - return "DW_OP_reg21"; - case DW_OP_reg22: - return "DW_OP_reg22"; - case DW_OP_reg23: - return "DW_OP_reg23"; - case DW_OP_reg24: - return "DW_OP_reg24"; - case DW_OP_reg25: - return "DW_OP_reg25"; - case DW_OP_reg26: - return "DW_OP_reg26"; - case DW_OP_reg27: - return "DW_OP_reg27"; - case DW_OP_reg28: - return "DW_OP_reg28"; - case DW_OP_reg29: - return "DW_OP_reg29"; - case DW_OP_reg30: - return "DW_OP_reg30"; - case DW_OP_reg31: - return "DW_OP_reg31"; - case DW_OP_breg0: - return "DW_OP_breg0"; - case DW_OP_breg1: - return "DW_OP_breg1"; - case DW_OP_breg2: - return "DW_OP_breg2"; - case DW_OP_breg3: - return "DW_OP_breg3"; - case DW_OP_breg4: - return "DW_OP_breg4"; - case DW_OP_breg5: - return "DW_OP_breg5"; - case DW_OP_breg6: - return "DW_OP_breg6"; - case DW_OP_breg7: - return "DW_OP_breg7"; - case DW_OP_breg8: - return "DW_OP_breg8"; - case DW_OP_breg9: - return "DW_OP_breg9"; - case DW_OP_breg10: - return "DW_OP_breg10"; - case DW_OP_breg11: - return "DW_OP_breg11"; - case DW_OP_breg12: - return "DW_OP_breg12"; - case DW_OP_breg13: - return "DW_OP_breg13"; - case DW_OP_breg14: - return "DW_OP_breg14"; - case DW_OP_breg15: - return "DW_OP_breg15"; - case DW_OP_breg16: - return "DW_OP_breg16"; - case DW_OP_breg17: - return "DW_OP_breg17"; - case DW_OP_breg18: - return "DW_OP_breg18"; - case DW_OP_breg19: - return "DW_OP_breg19"; - case DW_OP_breg20: - return "DW_OP_breg20"; - case DW_OP_breg21: - return "DW_OP_breg21"; - case DW_OP_breg22: - return "DW_OP_breg22"; - case DW_OP_breg23: - return "DW_OP_breg23"; - case DW_OP_breg24: - return "DW_OP_breg24"; - case DW_OP_breg25: - return "DW_OP_breg25"; - case DW_OP_breg26: - return "DW_OP_breg26"; - case DW_OP_breg27: - return "DW_OP_breg27"; - case DW_OP_breg28: - return "DW_OP_breg28"; - case DW_OP_breg29: - return "DW_OP_breg29"; - case DW_OP_breg30: - return "DW_OP_breg30"; - case DW_OP_breg31: - return "DW_OP_breg31"; - case DW_OP_regx: - return "DW_OP_regx"; - case DW_OP_fbreg: - return "DW_OP_fbreg"; - case DW_OP_bregx: - return "DW_OP_bregx"; - case DW_OP_piece: - return "DW_OP_piece"; - case DW_OP_deref_size: - return "DW_OP_deref_size"; - case DW_OP_xderef_size: - return "DW_OP_xderef_size"; - case DW_OP_nop: - return "DW_OP_nop"; - default: - return "OP_<unknown>"; - } -} - -static char * -dwarf_bool_name (unsigned mybool) -{ - if (mybool) - return "TRUE"; - else - return "FALSE"; -} - -/* Convert a DWARF type code into its string name. */ - -static char * -dwarf_type_encoding_name (register unsigned enc) -{ - switch (enc) - { - case DW_ATE_address: - return "DW_ATE_address"; - case DW_ATE_boolean: - return "DW_ATE_boolean"; - case DW_ATE_complex_float: - return "DW_ATE_complex_float"; - case DW_ATE_float: - return "DW_ATE_float"; - case DW_ATE_signed: - return "DW_ATE_signed"; - case DW_ATE_signed_char: - return "DW_ATE_signed_char"; - case DW_ATE_unsigned: - return "DW_ATE_unsigned"; - case DW_ATE_unsigned_char: - return "DW_ATE_unsigned_char"; - default: - return "DW_ATE_<unknown>"; - } -} - -/* Convert a DWARF call frame info operation to its string name. */ - -#if 0 -static char * -dwarf_cfi_name (register unsigned cfi_opc) -{ - switch (cfi_opc) - { - case DW_CFA_advance_loc: - return "DW_CFA_advance_loc"; - case DW_CFA_offset: - return "DW_CFA_offset"; - case DW_CFA_restore: - return "DW_CFA_restore"; - case DW_CFA_nop: - return "DW_CFA_nop"; - case DW_CFA_set_loc: - return "DW_CFA_set_loc"; - case DW_CFA_advance_loc1: - return "DW_CFA_advance_loc1"; - case DW_CFA_advance_loc2: - return "DW_CFA_advance_loc2"; - case DW_CFA_advance_loc4: - return "DW_CFA_advance_loc4"; - case DW_CFA_offset_extended: - return "DW_CFA_offset_extended"; - case DW_CFA_restore_extended: - return "DW_CFA_restore_extended"; - case DW_CFA_undefined: - return "DW_CFA_undefined"; - case DW_CFA_same_value: - return "DW_CFA_same_value"; - case DW_CFA_register: - return "DW_CFA_register"; - case DW_CFA_remember_state: - return "DW_CFA_remember_state"; - case DW_CFA_restore_state: - return "DW_CFA_restore_state"; - case DW_CFA_def_cfa: - return "DW_CFA_def_cfa"; - case DW_CFA_def_cfa_register: - return "DW_CFA_def_cfa_register"; - case DW_CFA_def_cfa_offset: - return "DW_CFA_def_cfa_offset"; - /* SGI/MIPS specific */ - case DW_CFA_MIPS_advance_loc8: - return "DW_CFA_MIPS_advance_loc8"; - default: - return "DW_CFA_<unknown>"; - } -} -#endif - -static void -dump_die (struct die_info *die) -{ - unsigned int i; - - fprintf (stderr, "Die: %s (abbrev = %d, offset = %d)\n", - dwarf_tag_name (die->tag), die->abbrev, die->offset); - fprintf (stderr, "\thas children: %s\n", - dwarf_bool_name (die->has_children)); - - fprintf (stderr, "\tattributes:\n"); - for (i = 0; i < die->num_attrs; ++i) - { - fprintf (stderr, "\t\t%s (%s) ", - dwarf_attr_name (die->attrs[i].name), - dwarf_form_name (die->attrs[i].form)); - switch (die->attrs[i].form) - { - case DW_FORM_ref_addr: - case DW_FORM_addr: - fprintf (stderr, "address: "); - print_address_numeric (DW_ADDR (&die->attrs[i]), 1, gdb_stderr); - break; - case DW_FORM_block2: - case DW_FORM_block4: - case DW_FORM_block: - case DW_FORM_block1: - fprintf (stderr, "block: size %d", DW_BLOCK (&die->attrs[i])->size); - break; - case DW_FORM_data1: - case DW_FORM_data2: - case DW_FORM_data4: - case DW_FORM_data8: - case DW_FORM_ref1: - case DW_FORM_ref2: - case DW_FORM_ref4: - case DW_FORM_udata: - case DW_FORM_sdata: - fprintf (stderr, "constant: %ld", DW_UNSND (&die->attrs[i])); - break; - case DW_FORM_string: - case DW_FORM_strp: - fprintf (stderr, "string: \"%s\"", - DW_STRING (&die->attrs[i]) - ? DW_STRING (&die->attrs[i]) : ""); - break; - case DW_FORM_flag: - if (DW_UNSND (&die->attrs[i])) - fprintf (stderr, "flag: TRUE"); - else - fprintf (stderr, "flag: FALSE"); - break; - case DW_FORM_indirect: - /* the reader will have reduced the indirect form to - the "base form" so this form should not occur */ - fprintf (stderr, "unexpected attribute form: DW_FORM_indirect"); - break; - default: - fprintf (stderr, "unsupported attribute form: %d.", - die->attrs[i].form); - } - fprintf (stderr, "\n"); - } -} - -static void -dump_die_list (struct die_info *die) -{ - while (die) - { - dump_die (die); - die = die->next; - } -} - -static void -store_in_ref_table (unsigned int offset, struct die_info *die) -{ - int h; - struct die_info *old; - - h = (offset % REF_HASH_SIZE); - old = die_ref_table[h]; - die->next_ref = old; - die_ref_table[h] = die; -} - - -static void -dwarf2_empty_hash_tables (void) -{ - memset (die_ref_table, 0, sizeof (die_ref_table)); -} - -static unsigned int -dwarf2_get_ref_die_offset (struct attribute *attr) -{ - unsigned int result = 0; - - switch (attr->form) - { - case DW_FORM_ref_addr: - result = DW_ADDR (attr); - break; - case DW_FORM_ref1: - case DW_FORM_ref2: - case DW_FORM_ref4: - case DW_FORM_ref8: - case DW_FORM_ref_udata: - result = cu_header_offset + DW_UNSND (attr); - break; - default: - complain (&dwarf2_unsupported_die_ref_attr, dwarf_form_name (attr->form)); - } - return result; -} - -static struct die_info * -follow_die_ref (unsigned int offset) -{ - struct die_info *die; - int h; - - h = (offset % REF_HASH_SIZE); - die = die_ref_table[h]; - while (die) - { - if (die->offset == offset) - { - return die; - } - die = die->next_ref; - } - return NULL; -} - -static struct type * -dwarf2_fundamental_type (struct objfile *objfile, int typeid) -{ - if (typeid < 0 || typeid >= FT_NUM_MEMBERS) - { - error ("Dwarf 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]); -} - -/* Decode simple location descriptions. - Given a pointer to a dwarf block that defines a location, compute - the location and return the value. - - FIXME: This is a kludge until we figure out a better - way to handle the location descriptions. - Gdb's design does not mesh well with the DWARF2 notion of a location - computing interpreter, which is a shame because the flexibility goes unused. - FIXME: Implement more operations as necessary. - - A location description containing no operations indicates that the - object is optimized out. The global optimized_out flag is set for - those, the return value is meaningless. - - When the result is a register number, the global isreg flag is set, - otherwise it is cleared. - - When the result is a base register offset, the global offreg flag is set - and the register number is returned in basereg, otherwise it is cleared. - - When the DW_OP_fbreg operation is encountered without a corresponding - DW_AT_frame_base attribute, the global islocal flag is set. - Hopefully the machine dependent code knows how to set up a virtual - frame pointer for the local references. - - Note that stack[0] is unused except as a default error return. - Note that stack overflow is not yet handled. */ - -static CORE_ADDR -decode_locdesc (struct dwarf_block *blk, struct objfile *objfile, - const struct comp_unit_head *cu_header) -{ - int i; - int size = blk->size; - char *data = blk->data; - CORE_ADDR stack[64]; - int stacki; - unsigned int bytes_read, unsnd; - unsigned char op; - - i = 0; - stacki = 0; - stack[stacki] = 0; - isreg = 0; - offreg = 0; - isderef = 0; - islocal = 0; - optimized_out = 1; - - while (i < size) - { - optimized_out = 0; - op = data[i++]; - switch (op) - { - case DW_OP_lit0: - case DW_OP_lit1: - case DW_OP_lit2: - case DW_OP_lit3: - case DW_OP_lit4: - case DW_OP_lit5: - case DW_OP_lit6: - case DW_OP_lit7: - case DW_OP_lit8: - case DW_OP_lit9: - case DW_OP_lit10: - case DW_OP_lit11: - case DW_OP_lit12: - case DW_OP_lit13: - case DW_OP_lit14: - case DW_OP_lit15: - case DW_OP_lit16: - case DW_OP_lit17: - case DW_OP_lit18: - case DW_OP_lit19: - case DW_OP_lit20: - case DW_OP_lit21: - case DW_OP_lit22: - case DW_OP_lit23: - case DW_OP_lit24: - case DW_OP_lit25: - case DW_OP_lit26: - case DW_OP_lit27: - case DW_OP_lit28: - case DW_OP_lit29: - case DW_OP_lit30: - case DW_OP_lit31: - stack[++stacki] = op - DW_OP_lit0; - break; - - case DW_OP_reg0: - case DW_OP_reg1: - case DW_OP_reg2: - case DW_OP_reg3: - case DW_OP_reg4: - case DW_OP_reg5: - case DW_OP_reg6: - case DW_OP_reg7: - case DW_OP_reg8: - case DW_OP_reg9: - case DW_OP_reg10: - case DW_OP_reg11: - case DW_OP_reg12: - case DW_OP_reg13: - case DW_OP_reg14: - case DW_OP_reg15: - case DW_OP_reg16: - case DW_OP_reg17: - case DW_OP_reg18: - case DW_OP_reg19: - case DW_OP_reg20: - case DW_OP_reg21: - case DW_OP_reg22: - case DW_OP_reg23: - case DW_OP_reg24: - case DW_OP_reg25: - case DW_OP_reg26: - case DW_OP_reg27: - case DW_OP_reg28: - case DW_OP_reg29: - case DW_OP_reg30: - case DW_OP_reg31: - isreg = 1; - stack[++stacki] = op - DW_OP_reg0; - break; - - case DW_OP_regx: - isreg = 1; - unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read); - i += bytes_read; -#if defined(HARRIS_TARGET) && defined(_M88K) - /* The Harris 88110 gdb ports have long kept their special reg - numbers between their gp-regs and their x-regs. This is - not how our dwarf is generated. Punt. */ - unsnd += 6; -#endif - stack[++stacki] = unsnd; - break; - - case DW_OP_breg0: - case DW_OP_breg1: - case DW_OP_breg2: - case DW_OP_breg3: - case DW_OP_breg4: - case DW_OP_breg5: - case DW_OP_breg6: - case DW_OP_breg7: - case DW_OP_breg8: - case DW_OP_breg9: - case DW_OP_breg10: - case DW_OP_breg11: - case DW_OP_breg12: - case DW_OP_breg13: - case DW_OP_breg14: - case DW_OP_breg15: - case DW_OP_breg16: - case DW_OP_breg17: - case DW_OP_breg18: - case DW_OP_breg19: - case DW_OP_breg20: - case DW_OP_breg21: - case DW_OP_breg22: - case DW_OP_breg23: - case DW_OP_breg24: - case DW_OP_breg25: - case DW_OP_breg26: - case DW_OP_breg27: - case DW_OP_breg28: - case DW_OP_breg29: - case DW_OP_breg30: - case DW_OP_breg31: - offreg = 1; - basereg = op - DW_OP_breg0; - stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read); - i += bytes_read; - break; - - case DW_OP_bregx: - offreg = 1; - basereg = read_unsigned_leb128 (NULL, (data + i), &bytes_read); - i += bytes_read; - stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read); - i += bytes_read; - break; - - case DW_OP_fbreg: - stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read); - i += bytes_read; - if (frame_base_reg >= 0) - { - offreg = 1; - basereg = frame_base_reg; - stack[stacki] += frame_base_offset; - } - else - { - complain (&dwarf2_missing_at_frame_base); - islocal = 1; - } - break; - - case DW_OP_addr: - stack[++stacki] = read_address (objfile->obfd, &data[i], - cu_header, &bytes_read); - i += bytes_read; - break; - - case DW_OP_const1u: - stack[++stacki] = read_1_byte (objfile->obfd, &data[i]); - i += 1; - break; - - case DW_OP_const1s: - stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]); - i += 1; - break; - - case DW_OP_const2u: - stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]); - i += 2; - break; - - case DW_OP_const2s: - stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]); - i += 2; - break; - - case DW_OP_const4u: - stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]); - i += 4; - break; - - case DW_OP_const4s: - stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]); - i += 4; - break; - - case DW_OP_constu: - stack[++stacki] = read_unsigned_leb128 (NULL, (data + i), - &bytes_read); - i += bytes_read; - break; - - case DW_OP_consts: - stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read); - i += bytes_read; - break; - - case DW_OP_dup: - stack[stacki + 1] = stack[stacki]; - stacki++; - break; - - case DW_OP_plus: - stack[stacki - 1] += stack[stacki]; - stacki--; - break; - - case DW_OP_plus_uconst: - stack[stacki] += read_unsigned_leb128 (NULL, (data + i), &bytes_read); - i += bytes_read; - break; - - case DW_OP_minus: - stack[stacki - 1] -= stack[stacki]; - stacki--; - break; - - case DW_OP_deref: - isderef = 1; - /* If we're not the last op, then we definitely can't encode - this using GDB's address_class enum. */ - if (i < size) - complain (&dwarf2_complex_location_expr); - break; - - default: - complain (&dwarf2_unsupported_stack_op, dwarf_stack_op_name (op)); - return (stack[stacki]); - } - } - return (stack[stacki]); -} - -/* memory allocation interface */ - -/* ARGSUSED */ -static void -dwarf2_free_tmp_obstack (PTR ignore) -{ - obstack_free (&dwarf2_tmp_obstack, NULL); -} - -static struct dwarf_block * -dwarf_alloc_block (void) -{ - struct dwarf_block *blk; - - blk = (struct dwarf_block *) - obstack_alloc (&dwarf2_tmp_obstack, sizeof (struct dwarf_block)); - return (blk); -} - -static struct abbrev_info * -dwarf_alloc_abbrev (void) -{ - struct abbrev_info *abbrev; - - abbrev = (struct abbrev_info *) xmalloc (sizeof (struct abbrev_info)); - memset (abbrev, 0, sizeof (struct abbrev_info)); - return (abbrev); -} - -static struct die_info * -dwarf_alloc_die (void) -{ - struct die_info *die; - - die = (struct die_info *) xmalloc (sizeof (struct die_info)); - memset (die, 0, sizeof (struct die_info)); - return (die); -} |