/* DWARF 2 debugging format support for GDB. Copyright 1994, 1995, 1996, 1997, 1998 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 "language.h" #include "complaints.h" #include "bcache.h" #include #include "gdb_string.h" #include #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; 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; /* 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" /* local data types */ /* The data in a compilation unit header, after target2host translation, looks like this. */ struct comp_unit_head { unsigned int length; short version; unsigned int abbrev_offset; unsigned char addr_size; unsigned char signed_addr_p; }; /* 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; 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]; #ifndef TYPE_HASH_SIZE #define TYPE_HASH_SIZE 4096 #endif static struct type *dwarf2_cached_types[TYPE_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; /* 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; }; #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) /* 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_ 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; }; /* FIXME: Kludge to mark a varargs function type for C++ member function argument processing. */ #define TYPE_FLAG_VARARGS (1 << 10) /* 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 between dwarf2_add_member_fn and read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */ #define TYPE_FIELD_ARTIFICIAL TYPE_FIELD_BITPOS /* 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 }; /* Externals references. */ extern int info_verbose; /* From main.c; nonzero => verbose */ /* 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 *); static 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 *, int *, 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 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 char *read_n_bytes (bfd *, char *, unsigned int); static char *read_string (bfd *, char *, 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 *); 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 struct die_info *sibling_die (struct die_info *); void dump_die (struct die_info *); void dump_die_list (struct die_info *); 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 *); 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; 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); } } /* 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 (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) { entry_length = read_4_bytes (abfd, pubnames_ptr); pubnames_ptr += 4; 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; cu_header->length = read_4_bytes (abfd, info_ptr); info_ptr += 4; cu_header->version = read_2_bytes (abfd, info_ptr); info_ptr += 2; cu_header->abbrev_offset = read_4_bytes (abfd, info_ptr); info_ptr += 4; 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 ("dwarf2_build_psymtabs_hard: 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; int comp_unit_has_pc_info; CORE_ADDR lowpc, highpc; info_ptr = dwarf_info_buffer; abbrev_ptr = dwarf_abbrev_buffer; obstack_init (&dwarf2_tmp_obstack); back_to = make_cleanup (dwarf2_free_tmp_obstack, NULL); while ((unsigned int) (info_ptr - dwarf_info_buffer) + ((info_ptr - dwarf_info_buffer) % 4) < 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 + 4 > 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, &comp_unit_has_pc_info, &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; baseaddr = ANOFFSET (objfile->section_offsets, 0); /* 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_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 + 4; } 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; int has_pc_info; *lowpc = ((CORE_ADDR) -1); *highpc = ((CORE_ADDR) 0); while (nesting_level) { info_ptr = read_partial_die (&pdi, abfd, info_ptr, &has_pc_info, cu_header); if (pdi.name) { switch (pdi.tag) { case DW_TAG_subprogram: if (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); baseaddr = ANOFFSET (pst->section_offsets, 0); 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, 0); /* 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 = ""; 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 .: 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 (free, 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 (free, 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_FLAGS (die->type) & TYPE_FLAG_VARARGS) 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; } } /* 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; } die->type = 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); free (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) { if (die->type) { return; } complain (&dwarf2_const_ignored); die->type = die_type (die, objfile, cu_header); } static void read_tag_volatile_type (struct die_info *die, struct objfile *objfile, const struct comp_unit_head *cu_header) { if (die->type) { return; } complain (&dwarf2_volatile_ignored); die->type = die_type (die, objfile, cu_header); } /* 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 { length = 1; } index_type = dwarf2_fundamental_type (objfile, FT_INTEGER); range_type = create_range_type (NULL, index_type, 1, length); 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 type *type; if (!die->type) { struct attribute *attr; struct type *xtype; xtype = die_type (die, objfile, cu_header); type = alloc_type (objfile); TYPE_CODE (type) = TYPE_CODE_TYPEDEF; TYPE_FLAGS (type) |= TYPE_FLAG_TARGET_STUB; TYPE_TARGET_TYPE (type) = xtype; attr = dwarf_attr (die, DW_AT_name); if (attr && DW_STRING (attr)) TYPE_NAME (type) = obsavestring (DW_STRING (attr), strlen (DW_STRING (attr)), &objfile->type_obstack); die->type = type; } } /* 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 is_unsigned = 0; switch (encoding) { case DW_ATE_address: /* Turn DW_ATE_address into a void * pointer. */ code = TYPE_CODE_PTR; is_unsigned = 1; break; case DW_ATE_boolean: code = TYPE_CODE_BOOL; is_unsigned = 1; 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: is_unsigned = 1; break; default: complain (&dwarf2_unsupported_at_encoding, dwarf_type_encoding_name (encoding)); break; } type = init_type (code, size, is_unsigned, 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. */ 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 and cached types 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; free (die->attrs); free (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. */ static 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_read (buf, size, 1, 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; free (abbrev->attrs); free (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, int *has_pc_info, 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; *has_pc_info = 0; 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, &dummy, 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))) *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 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) { unsigned int bytes_read; struct dwarf_block *blk; attr->name = abbrev->name; attr->form = abbrev->form; switch (abbrev->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_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_ref_udata: DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); info_ptr += bytes_read; break; case DW_FORM_strp: case DW_FORM_indirect: default: error ("Dwarf Error: Cannot handle %s in DWARF reader.", dwarf_form_name (abbrev->form)); } return info_ptr; } /* 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 ("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 ("read_address: bad switch, unsigned"); } } *bytes_read = cu_header->addr_size; 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. */ #if HOST_CHAR_BIT == 8 return buf; #else char *ret; unsigned int i; ret = obstack_alloc (&dwarf2_tmp_obstack, size); for (i = 0; i < size; ++i) { ret[i] = bfd_get_8 (abfd, (bfd_byte *) buf); buf++; } return ret; #endif } 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. */ #if HOST_CHAR_BIT == 8 if (*buf == '\0') { *bytes_read_ptr = 1; return NULL; } *bytes_read_ptr = strlen (buf) + 1; return buf; #else int byte; unsigned int i = 0; while ((byte = bfd_get_8 (abfd, (bfd_byte *) buf)) != 0) { obstack_1grow (&dwarf2_tmp_obstack, byte); i++; buf++; } if (i == 0) { *bytes_read_ptr = 1; return NULL; } obstack_1grow (&dwarf2_tmp_obstack, '\0'); *bytes_read_ptr = i + 1; return obstack_finish (&dwarf2_tmp_obstack); #endif } 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: cu_language = language_fortran; break; case DW_LANG_Mips_Assembler: cu_language = language_asm; 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_4_bytes (abfd, line_ptr); line_ptr += 4; line_end = line_ptr + lh.total_length; lh.version = read_2_bytes (abfd, line_ptr); line_ptr += 2; lh.prologue_length = read_4_bytes (abfd, line_ptr); line_ptr += 4; 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; 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: /* 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; } } } 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 (*filename != '/' && dirname != NULL) { struct subfile *subfile; char *fullname = concat (dirname, "/", filename, NULL); for (subfile = subfiles; subfile; subfile = subfile->next) { if (STREQ (subfile->name, fullname)) { current_subfile = subfile; free (fullname); return; } } free (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, "", 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)) { SYMBOL_VALUE_ADDRESS (sym) += baseaddr; 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; } else if (offreg) { SYMBOL_CLASS (sym) = LOC_BASEREG; SYMBOL_BASEREG (sym) = basereg; } else if (islocal) { SYMBOL_CLASS (sym) = LOC_LOCAL; } else { SYMBOL_CLASS (sym) = LOC_STATIC; SYMBOL_VALUE_ADDRESS (sym) = addr + baseaddr; } } } 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; } 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) = 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 { struct attribute *attr; attr = dwarf_attr (die, DW_AT_name); if (attr && DW_STRING (attr)) { char *attrname=DW_STRING (attr); unsigned long hashval=hash(attrname, strlen(attrname)) % TYPE_HASH_SIZE; if (dwarf2_cached_types[hashval] != NULL) { const char *nameoftype; nameoftype = TYPE_NAME(dwarf2_cached_types[hashval]) == NULL ? TYPE_TAG_NAME(dwarf2_cached_types[hashval]) : TYPE_NAME(dwarf2_cached_types[hashval]); if (strcmp(attrname, nameoftype) == 0) { die->type=dwarf2_cached_types[hashval]; } else { read_type_die (die, objfile, cu_header); dwarf2_cached_types[hashval] = die->type; } } else { read_type_die (die, objfile, cu_header); dwarf2_cached_types[hashval] = 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. */ 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_"; } } /* 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_"; } } /* 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_"; } } /* 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_"; } } 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_"; } } /* 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_"; } } #endif 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: 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_strp: /* we do not support separate string section yet */ case DW_FORM_indirect: /* we do not handle indirect yet */ default: fprintf (stderr, "unsupported attribute form: %d.", die->attrs[i].form); } fprintf (stderr, "\n"); } } void dump_die_list (struct die_info *die) { while (die) { dump_die (die); die = die->next; } } 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)); memset (dwarf2_cached_types, 0, sizeof(dwarf2_cached_types)); } 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_ref_udata: result = cu_header_offset + DW_UNSND (attr); break; default: complain (&dwarf2_unsupported_die_ref_attr, dwarf_form_name (attr->form)); } return result; } 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_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_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] - stack[stacki - 1]; 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); }