X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fdwarf2read.c;h=7ed425397b79a2a7feacb32750689b706f87b305;hb=e17a4113357102b55cfa5b80557d590a46a43300;hp=5d8551956755cef5e740d237e43c44daf4053848;hpb=7678ef8fb055dd4853c7c6b25f739a8d74650899;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c index 5d85519567..7ed425397b 100644 --- a/gdb/dwarf2read.c +++ b/gdb/dwarf2read.c @@ -1,7 +1,8 @@ /* DWARF 2 debugging format support for GDB. Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, - 2004, 2005, 2006, 2007 Free Software Foundation, Inc. + 2004, 2005, 2006, 2007, 2008, 2009 + Free Software Foundation, Inc. Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology, Inc. with support from Florida State University (under contract @@ -45,25 +46,19 @@ #include "hashtab.h" #include "command.h" #include "gdbcmd.h" +#include "block.h" +#include "addrmap.h" #include #include "gdb_string.h" #include "gdb_assert.h" #include - -/* A note on memory usage for this file. - - At the present time, this code reads the debug info sections into - the objfile's objfile_obstack. A definite improvement for startup - time, on platforms which do not emit relocations for debug - sections, would be to use mmap instead. The object's complete - debug information is loaded into memory, partly to simplify - absolute DIE references. - - Whether using obstacks or mmap, the sections should remain loaded - until the objfile is released, and pointers into the section data - can be used for any other data associated to the objfile (symbol - names, type names, location expressions to name a few). */ +#ifdef HAVE_ZLIB_H +#include +#endif +#ifdef HAVE_MMAP +#include +#endif #if 0 /* .debug_info header for a compilation unit @@ -137,31 +132,40 @@ typedef struct statement_prologue } _STATEMENT_PROLOGUE; +/* When non-zero, dump DIEs after they are read in. */ +static int dwarf2_die_debug = 0; + +static int pagesize; + +/* When set, the file that we're processing is known to have debugging + info for C++ namespaces. GCC 3.3.x did not produce this information, + but later versions do. */ + +static int processing_has_namespace_info; + static const struct objfile_data *dwarf2_objfile_data_key; +struct dwarf2_section_info +{ + asection *asection; + gdb_byte *buffer; + bfd_size_type size; + int was_mmapped; +}; + struct dwarf2_per_objfile { - /* Sizes of debugging sections. */ - unsigned int info_size; - unsigned int abbrev_size; - unsigned int line_size; - unsigned int pubnames_size; - unsigned int aranges_size; - unsigned int loc_size; - unsigned int macinfo_size; - unsigned int str_size; - unsigned int ranges_size; - unsigned int frame_size; - unsigned int eh_frame_size; - - /* Loaded data from the sections. */ - gdb_byte *info_buffer; - gdb_byte *abbrev_buffer; - gdb_byte *line_buffer; - gdb_byte *str_buffer; - gdb_byte *macinfo_buffer; - gdb_byte *ranges_buffer; - gdb_byte *loc_buffer; + struct dwarf2_section_info info; + struct dwarf2_section_info abbrev; + struct dwarf2_section_info line; + struct dwarf2_section_info pubnames; + struct dwarf2_section_info aranges; + struct dwarf2_section_info loc; + struct dwarf2_section_info macinfo; + struct dwarf2_section_info str; + struct dwarf2_section_info ranges; + struct dwarf2_section_info frame; + struct dwarf2_section_info eh_frame; /* A list of all the compilation units. This is used to locate the target compilation unit of a particular reference. */ @@ -181,31 +185,22 @@ struct dwarf2_per_objfile static struct dwarf2_per_objfile *dwarf2_per_objfile; -static asection *dwarf_info_section; -static asection *dwarf_abbrev_section; -static asection *dwarf_line_section; -static asection *dwarf_pubnames_section; -static asection *dwarf_aranges_section; -static asection *dwarf_loc_section; -static asection *dwarf_macinfo_section; -static asection *dwarf_str_section; -static asection *dwarf_ranges_section; -asection *dwarf_frame_section; -asection *dwarf_eh_frame_section; - /* names of the debugging sections */ -#define INFO_SECTION ".debug_info" -#define ABBREV_SECTION ".debug_abbrev" -#define LINE_SECTION ".debug_line" -#define PUBNAMES_SECTION ".debug_pubnames" -#define ARANGES_SECTION ".debug_aranges" -#define LOC_SECTION ".debug_loc" -#define MACINFO_SECTION ".debug_macinfo" -#define STR_SECTION ".debug_str" -#define RANGES_SECTION ".debug_ranges" -#define FRAME_SECTION ".debug_frame" -#define EH_FRAME_SECTION ".eh_frame" +/* Note that if the debugging section has been compressed, it might + have a name like .zdebug_info. */ + +#define INFO_SECTION "debug_info" +#define ABBREV_SECTION "debug_abbrev" +#define LINE_SECTION "debug_line" +#define PUBNAMES_SECTION "debug_pubnames" +#define ARANGES_SECTION "debug_aranges" +#define LOC_SECTION "debug_loc" +#define MACINFO_SECTION "debug_macinfo" +#define STR_SECTION "debug_str" +#define RANGES_SECTION "debug_ranges" +#define FRAME_SECTION "debug_frame" +#define EH_FRAME_SECTION "eh_frame" /* local data types */ @@ -218,11 +213,11 @@ asection *dwarf_eh_frame_section; translation, looks like this. */ struct comp_unit_head { - unsigned long length; + unsigned int length; short version; - unsigned int abbrev_offset; unsigned char addr_size; unsigned char signed_addr_p; + unsigned int abbrev_offset; /* Size of file offsets; either 4 or 8. */ unsigned int offset_size; @@ -234,41 +229,26 @@ struct comp_unit_head .debug_info section, for resolving relative reference dies. */ unsigned int offset; - /* Pointer to this compilation unit header in the .debug_info - section. */ - gdb_byte *cu_head_ptr; - - /* Pointer to the first die of this compilation unit. This will be - the first byte following the compilation unit header. */ - gdb_byte *first_die_ptr; - - /* Pointer to the next compilation unit header in the program. */ - struct comp_unit_head *next; - - /* Base address of this compilation unit. */ - CORE_ADDR base_address; - - /* Non-zero if base_address has been set. */ - int base_known; + /* Offset to first die in this cu from the start of the cu. + This will be the first byte following the compilation unit header. */ + unsigned int first_die_offset; }; -/* Fixed size for the DIE hash table. */ -#ifndef REF_HASH_SIZE -#define REF_HASH_SIZE 1021 -#endif - /* Internal state when decoding a particular compilation unit. */ struct dwarf2_cu { /* The objfile containing this compilation unit. */ struct objfile *objfile; - /* The header of the compilation unit. - - FIXME drow/2003-11-10: Some of the things from the comp_unit_head - should logically be moved to the dwarf2_cu structure. */ + /* The header of the compilation unit. */ struct comp_unit_head header; + /* Base address of this compilation unit. */ + CORE_ADDR base_address; + + /* Non-zero if base_address has been set. */ + int base_known; + struct function_range *first_fn, *last_fn, *cached_fn; /* The language we are debugging. */ @@ -288,17 +268,6 @@ struct dwarf2_cu distinguish these in buildsym.c. */ struct pending **list_in_scope; - /* 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. */ - struct type *ftypes[FT_NUM_MEMBERS]; /* Fundamental types */ - /* DWARF abbreviation table associated with this compilation unit. */ struct abbrev_info **dwarf2_abbrevs; @@ -308,6 +277,9 @@ struct dwarf2_cu /* Hash table holding all the loaded partial DIEs. */ htab_t partial_dies; + /* `.debug_ranges' offset for this `DW_TAG_compile_unit' DIE. */ + unsigned int ranges_offset; + /* Storage for things with the same lifetime as this read-in compilation unit, including partial DIEs. */ struct obstack comp_unit_obstack; @@ -321,11 +293,16 @@ struct dwarf2_cu /* Backchain to our per_cu entry if the tree has been built. */ struct dwarf2_per_cu_data *per_cu; + /* Pointer to the die -> type map. Although it is stored + permanently in per_cu, we copy it here to avoid double + indirection. */ + htab_t type_hash; + /* How many compilation units ago was this CU last referenced? */ int last_used; /* A hash table of die offsets for following references. */ - struct die_info *die_ref_table[REF_HASH_SIZE]; + htab_t die_hash; /* Full DIEs if read in. */ struct die_info *dies; @@ -350,6 +327,9 @@ struct dwarf2_cu DIEs for namespaces, we don't need to try to infer them from mangled names. */ unsigned int has_namespace_info : 1; + + /* Field `ranges_offset' is filled in; flag as the value may be zero. */ + unsigned int has_ranges_offset : 1; }; /* Persistent data held for a compilation unit, even when not @@ -362,13 +342,15 @@ struct dwarf2_per_cu_data { /* The start offset and length of this compilation unit. 2**30-1 bytes should suffice to store the length of any compilation unit - - if it doesn't, GDB will fall over anyway. */ - unsigned long offset; - unsigned long length : 30; + - if it doesn't, GDB will fall over anyway. + NOTE: Unlike comp_unit_head.length, this length includes + initial_length_size. */ + unsigned int offset; + unsigned int length : 30; /* Flag indicating this compilation unit will be read in before any of the current compilation units are processed. */ - unsigned long queued : 1; + unsigned int queued : 1; /* This flag will be set if we need to load absolutely all DIEs for this compilation unit, instead of just the ones we think @@ -515,37 +497,24 @@ struct abbrev_info struct attr_abbrev { - enum dwarf_attribute name; - enum dwarf_form form; + ENUM_BITFIELD(dwarf_attribute) name : 16; + ENUM_BITFIELD(dwarf_form) form : 16; }; -/* This data structure holds a complete die structure. */ -struct die_info +/* Additional GDB-specific attribute forms. */ +enum { - enum dwarf_tag tag; /* Tag indicating type of die */ - unsigned int abbrev; /* Abbrev number */ - unsigned int offset; /* Offset in .debug_info section */ - unsigned int num_attrs; /* Number of attributes */ - struct attribute *attrs; /* An array of attributes */ - struct die_info *next_ref; /* Next die in ref hash table */ - - /* The dies in a compilation unit form an n-ary tree. PARENT - points to this die's parent; CHILD points to the first child of - this node; and all the children of a given node are chained - together via their SIBLING fields, terminated by a die whose - tag is zero. */ - struct die_info *child; /* Its first child, if any. */ - struct die_info *sibling; /* Its next sibling, if any. */ - struct die_info *parent; /* Its parent, if any. */ - - struct type *type; /* Cached type information */ + /* A string which has been updated to GDB's internal + representation (e.g. converted to canonical form) and does not + need to be updated again. */ + GDB_FORM_cached_string = 0xff }; /* Attributes have a name and a value */ struct attribute { - enum dwarf_attribute name; - enum dwarf_form form; + ENUM_BITFIELD(dwarf_attribute) name : 16; + ENUM_BITFIELD(dwarf_form) form : 16; union { char *str; @@ -557,6 +526,36 @@ struct attribute u; }; +/* This data structure holds a complete die structure. */ +struct die_info + { + /* DWARF-2 tag for this DIE. */ + ENUM_BITFIELD(dwarf_tag) tag : 16; + + /* Number of attributes */ + unsigned short num_attrs; + + /* Abbrev number */ + unsigned int abbrev; + + /* Offset in .debug_info section */ + unsigned int offset; + + /* The dies in a compilation unit form an n-ary tree. PARENT + points to this die's parent; CHILD points to the first child of + this node; and all the children of a given node are chained + together via their SIBLING fields, terminated by a die whose + tag is zero. */ + struct die_info *child; /* Its first child, if any. */ + struct die_info *sibling; /* Its next sibling, if any. */ + struct die_info *parent; /* Its parent, if any. */ + + /* An array of attributes, with NUM_ATTRS elements. There may be + zero, but it's not common and zero-sized arrays are not + sufficiently portable C. */ + struct attribute attrs[1]; + }; + struct function_range { const char *name; @@ -688,6 +687,13 @@ dwarf2_debug_line_missing_file_complaint (void) _(".debug_line section has line data without a file")); } +static void +dwarf2_debug_line_missing_end_sequence_complaint (void) +{ + complaint (&symfile_complaints, + _(".debug_line section has line program sequence without an end")); +} + static void dwarf2_complex_location_expr_complaint (void) { @@ -744,7 +750,7 @@ static void dwarf2_build_psymtabs_hard (struct objfile *, int); static void scan_partial_symbols (struct partial_die_info *, CORE_ADDR *, CORE_ADDR *, - struct dwarf2_cu *); + int, struct dwarf2_cu *); static void add_partial_symbol (struct partial_die_info *, struct dwarf2_cu *); @@ -753,11 +759,19 @@ static int pdi_needs_namespace (enum dwarf_tag tag); static void add_partial_namespace (struct partial_die_info *pdi, CORE_ADDR *lowpc, CORE_ADDR *highpc, - struct dwarf2_cu *cu); + int need_pc, struct dwarf2_cu *cu); + +static void add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc, + CORE_ADDR *highpc, int need_pc, + struct dwarf2_cu *cu); static void add_partial_enumeration (struct partial_die_info *enum_pdi, struct dwarf2_cu *cu); +static void add_partial_subprogram (struct partial_die_info *pdi, + CORE_ADDR *lowpc, CORE_ADDR *highpc, + int need_pc, struct dwarf2_cu *cu); + static gdb_byte *locate_pdi_sibling (struct partial_die_info *orig_pdi, gdb_byte *info_ptr, bfd *abfd, @@ -767,8 +781,6 @@ static void dwarf2_psymtab_to_symtab (struct partial_symtab *); static void psymtab_to_symtab_1 (struct partial_symtab *); -gdb_byte *dwarf2_read_section (struct objfile *, asection *); - static void dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu); static void dwarf2_free_abbrev_table (void *); @@ -786,7 +798,7 @@ static gdb_byte *read_partial_die (struct partial_die_info *, struct abbrev_info *abbrev, unsigned int, bfd *, gdb_byte *, struct dwarf2_cu *); -static struct partial_die_info *find_partial_die (unsigned long, +static struct partial_die_info *find_partial_die (unsigned int, struct dwarf2_cu *); static void fixup_partial_die (struct partial_die_info *, @@ -814,11 +826,16 @@ static unsigned long read_8_bytes (bfd *, gdb_byte *); static CORE_ADDR read_address (bfd *, gdb_byte *ptr, struct dwarf2_cu *, unsigned int *); -static LONGEST read_initial_length (bfd *, gdb_byte *, - struct comp_unit_head *, unsigned int *); +static LONGEST read_initial_length (bfd *, gdb_byte *, unsigned int *); + +static LONGEST read_checked_initial_length_and_offset + (bfd *, gdb_byte *, const struct comp_unit_head *, + unsigned int *, unsigned int *); static LONGEST read_offset (bfd *, gdb_byte *, const struct comp_unit_head *, - unsigned int *); + unsigned int *); + +static LONGEST read_offset_1 (bfd *, gdb_byte *, unsigned int); static gdb_byte *read_n_bytes (bfd *, gdb_byte *, unsigned int); @@ -845,7 +862,7 @@ static int dwarf2_flag_true_p (struct die_info *die, unsigned name, static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu); static struct die_info *die_specification (struct die_info *die, - struct dwarf2_cu *); + struct dwarf2_cu **); static void free_line_header (struct line_header *lh); @@ -878,7 +895,7 @@ static struct type *die_containing_type (struct die_info *, static struct type *tag_type_to_type (struct die_info *, struct dwarf2_cu *); -static void read_type_die (struct die_info *, struct dwarf2_cu *); +static struct type *read_type_die (struct die_info *, struct dwarf2_cu *); static char *determine_prefix (struct die_info *die, struct dwarf2_cu *); @@ -887,18 +904,15 @@ static char *typename_concat (struct obstack *, const char *suffix, struct dwarf2_cu *); -static void read_typedef (struct die_info *, struct dwarf2_cu *); - -static void read_base_type (struct die_info *, struct dwarf2_cu *); - -static void read_subrange_type (struct die_info *die, struct dwarf2_cu *cu); - static void read_file_scope (struct die_info *, struct dwarf2_cu *); static void read_func_scope (struct die_info *, struct dwarf2_cu *); static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *); +static int dwarf2_ranges_read (unsigned, CORE_ADDR *, CORE_ADDR *, + struct dwarf2_cu *, struct partial_symtab *); + static int dwarf2_get_pc_bounds (struct die_info *, CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *); @@ -906,6 +920,9 @@ static void get_scope_pc_bounds (struct die_info *, CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *); +static void dwarf2_record_block_ranges (struct die_info *, struct block *, + CORE_ADDR, struct dwarf2_cu *); + static void dwarf2_add_field (struct field_info *, struct die_info *, struct dwarf2_cu *); @@ -919,49 +936,36 @@ static void dwarf2_add_member_fn (struct field_info *, static void dwarf2_attach_fn_fields_to_type (struct field_info *, struct type *, struct dwarf2_cu *); -static void read_structure_type (struct die_info *, struct dwarf2_cu *); - static void process_structure_scope (struct die_info *, struct dwarf2_cu *); -static char *determine_class_name (struct die_info *die, struct dwarf2_cu *cu); +static const char *determine_class_name (struct die_info *die, + struct dwarf2_cu *cu); static void read_common_block (struct die_info *, struct dwarf2_cu *); static void read_namespace (struct die_info *die, struct dwarf2_cu *); +static void read_module (struct die_info *die, struct dwarf2_cu *cu); + +static void read_import_statement (struct die_info *die, struct dwarf2_cu *); + static const char *namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *); -static void read_enumeration_type (struct die_info *, struct dwarf2_cu *); - static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *); -static struct type *dwarf_base_type (int, int, struct dwarf2_cu *); - static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *); -static void read_array_type (struct die_info *, struct dwarf2_cu *); - static enum dwarf_array_dim_ordering read_array_order (struct die_info *, struct dwarf2_cu *); -static void read_tag_pointer_type (struct die_info *, struct dwarf2_cu *); - -static void read_tag_ptr_to_member_type (struct die_info *, - struct dwarf2_cu *); - -static void read_tag_reference_type (struct die_info *, struct dwarf2_cu *); - -static void read_tag_const_type (struct die_info *, struct dwarf2_cu *); - -static void read_tag_volatile_type (struct die_info *, struct dwarf2_cu *); - -static void read_tag_string_type (struct die_info *, struct dwarf2_cu *); - -static void read_subroutine_type (struct die_info *, struct dwarf2_cu *); - static struct die_info *read_comp_unit (gdb_byte *, bfd *, struct dwarf2_cu *); +static struct die_info *read_die_and_children_1 (gdb_byte *info_ptr, bfd *abfd, + struct dwarf2_cu *, + gdb_byte **new_info_ptr, + struct die_info *parent); + static struct die_info *read_die_and_children (gdb_byte *info_ptr, bfd *abfd, struct dwarf2_cu *, gdb_byte **new_info_ptr, @@ -972,16 +976,17 @@ static struct die_info *read_die_and_siblings (gdb_byte *info_ptr, bfd *abfd, gdb_byte **new_info_ptr, struct die_info *parent); -static void free_die_list (struct die_info *); - static void process_die (struct die_info *, struct dwarf2_cu *); static char *dwarf2_linkage_name (struct die_info *, struct dwarf2_cu *); +static char *dwarf2_canonicalize_name (char *, struct dwarf2_cu *, + struct obstack *); + static char *dwarf2_name (struct die_info *die, struct dwarf2_cu *); static struct die_info *dwarf2_extension (struct die_info *die, - struct dwarf2_cu *); + struct dwarf2_cu **); static char *dwarf_tag_name (unsigned int); @@ -997,30 +1002,29 @@ static char *dwarf_type_encoding_name (unsigned int); #if 0 static char *dwarf_cfi_name (unsigned int); - -struct die_info *copy_die (struct die_info *); #endif static struct die_info *sibling_die (struct die_info *); -static void dump_die (struct die_info *); +static void dump_die_shallow (struct ui_file *, int indent, struct die_info *); + +static void dump_die_for_error (struct die_info *); + +static void dump_die_1 (struct ui_file *, int level, int max_level, + struct die_info *); -static void dump_die_list (struct die_info *); +/*static*/ void dump_die (struct die_info *, int max_level); -static void store_in_ref_table (unsigned int, struct die_info *, +static void store_in_ref_table (struct die_info *, struct dwarf2_cu *); -static unsigned int dwarf2_get_ref_die_offset (struct attribute *, - struct dwarf2_cu *); +static unsigned int dwarf2_get_ref_die_offset (struct attribute *); static int dwarf2_get_attr_constant_value (struct attribute *, int); static struct die_info *follow_die_ref (struct die_info *, struct attribute *, - struct dwarf2_cu *); - -static struct type *dwarf2_fundamental_type (struct objfile *, int, - struct dwarf2_cu *); + struct dwarf2_cu **); /* memory allocation interface */ @@ -1028,7 +1032,7 @@ static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *); static struct abbrev_info *dwarf_alloc_abbrev (struct dwarf2_cu *); -static struct die_info *dwarf_alloc_die (void); +static struct die_info *dwarf_alloc_die (struct dwarf2_cu *, int); static void initialize_cu_func_list (struct dwarf2_cu *); @@ -1040,6 +1044,10 @@ static void dwarf_decode_macros (struct line_header *, unsigned int, static int attr_form_is_block (struct attribute *); +static int attr_form_is_section_offset (struct attribute *); + +static int attr_form_is_constant (struct attribute *); + static void dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym, struct dwarf2_cu *cu); @@ -1054,10 +1062,10 @@ static hashval_t partial_die_hash (const void *item); static int partial_die_eq (const void *item_lhs, const void *item_rhs); static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit - (unsigned long offset, struct objfile *objfile); + (unsigned int offset, struct objfile *objfile); static struct dwarf2_per_cu_data *dwarf2_find_comp_unit - (unsigned long offset, struct objfile *objfile); + (unsigned int offset, struct objfile *objfile); static void free_one_comp_unit (void *); @@ -1067,11 +1075,8 @@ static void age_cached_comp_units (void); static void free_one_cached_comp_unit (void *); -static void set_die_type (struct die_info *, struct type *, - struct dwarf2_cu *); - -static void reset_die_and_siblings_types (struct die_info *, - struct dwarf2_cu *); +static struct type *set_die_type (struct die_info *, struct type *, + struct dwarf2_cu *); static void create_all_comp_units (struct objfile *); @@ -1087,8 +1092,7 @@ static void dwarf2_mark (struct dwarf2_cu *); static void dwarf2_clear_marks (struct dwarf2_per_cu_data *); -static void read_set_type (struct die_info *, struct dwarf2_cu *); - +static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu); /* Try to locate the sections we need for DWARF 2 debugging information and return true if we have enough to do something. */ @@ -1104,18 +1108,20 @@ dwarf2_has_info (struct objfile *objfile) set_objfile_data (objfile, dwarf2_objfile_data_key, data); dwarf2_per_objfile = data; - dwarf_info_section = 0; - dwarf_abbrev_section = 0; - dwarf_line_section = 0; - dwarf_str_section = 0; - dwarf_macinfo_section = 0; - dwarf_frame_section = 0; - dwarf_eh_frame_section = 0; - dwarf_ranges_section = 0; - dwarf_loc_section = 0; - bfd_map_over_sections (objfile->obfd, dwarf2_locate_sections, NULL); - return (dwarf_info_section != NULL && dwarf_abbrev_section != NULL); + return (data->info.asection != NULL && data->abbrev.asection != NULL); +} + +/* When loading sections, we can either look for ".", or for + * ".z", which indicates a compressed section. */ + +static int +section_is_p (const char *section_name, const char *name) +{ + return (section_name[0] == '.' + && (strcmp (section_name + 1, name) == 0 + || (section_name[1] == 'z' + && strcmp (section_name + 2, name) == 0))); } /* This function is mapped across the sections and remembers the @@ -1125,106 +1131,267 @@ dwarf2_has_info (struct objfile *objfile) static void dwarf2_locate_sections (bfd *abfd, asection *sectp, void *ignore_ptr) { - if (strcmp (sectp->name, INFO_SECTION) == 0) + if (section_is_p (sectp->name, INFO_SECTION)) { - dwarf2_per_objfile->info_size = bfd_get_section_size (sectp); - dwarf_info_section = sectp; + dwarf2_per_objfile->info.asection = sectp; + dwarf2_per_objfile->info.size = bfd_get_section_size (sectp); } - else if (strcmp (sectp->name, ABBREV_SECTION) == 0) + else if (section_is_p (sectp->name, ABBREV_SECTION)) { - dwarf2_per_objfile->abbrev_size = bfd_get_section_size (sectp); - dwarf_abbrev_section = sectp; + dwarf2_per_objfile->abbrev.asection = sectp; + dwarf2_per_objfile->abbrev.size = bfd_get_section_size (sectp); } - else if (strcmp (sectp->name, LINE_SECTION) == 0) + else if (section_is_p (sectp->name, LINE_SECTION)) { - dwarf2_per_objfile->line_size = bfd_get_section_size (sectp); - dwarf_line_section = sectp; + dwarf2_per_objfile->line.asection = sectp; + dwarf2_per_objfile->line.size = bfd_get_section_size (sectp); } - else if (strcmp (sectp->name, PUBNAMES_SECTION) == 0) + else if (section_is_p (sectp->name, PUBNAMES_SECTION)) { - dwarf2_per_objfile->pubnames_size = bfd_get_section_size (sectp); - dwarf_pubnames_section = sectp; + dwarf2_per_objfile->pubnames.asection = sectp; + dwarf2_per_objfile->pubnames.size = bfd_get_section_size (sectp); } - else if (strcmp (sectp->name, ARANGES_SECTION) == 0) + else if (section_is_p (sectp->name, ARANGES_SECTION)) { - dwarf2_per_objfile->aranges_size = bfd_get_section_size (sectp); - dwarf_aranges_section = sectp; + dwarf2_per_objfile->aranges.asection = sectp; + dwarf2_per_objfile->aranges.size = bfd_get_section_size (sectp); } - else if (strcmp (sectp->name, LOC_SECTION) == 0) + else if (section_is_p (sectp->name, LOC_SECTION)) { - dwarf2_per_objfile->loc_size = bfd_get_section_size (sectp); - dwarf_loc_section = sectp; + dwarf2_per_objfile->loc.asection = sectp; + dwarf2_per_objfile->loc.size = bfd_get_section_size (sectp); } - else if (strcmp (sectp->name, MACINFO_SECTION) == 0) + else if (section_is_p (sectp->name, MACINFO_SECTION)) { - dwarf2_per_objfile->macinfo_size = bfd_get_section_size (sectp); - dwarf_macinfo_section = sectp; + dwarf2_per_objfile->macinfo.asection = sectp; + dwarf2_per_objfile->macinfo.size = bfd_get_section_size (sectp); } - else if (strcmp (sectp->name, STR_SECTION) == 0) + else if (section_is_p (sectp->name, STR_SECTION)) { - dwarf2_per_objfile->str_size = bfd_get_section_size (sectp); - dwarf_str_section = sectp; + dwarf2_per_objfile->str.asection = sectp; + dwarf2_per_objfile->str.size = bfd_get_section_size (sectp); } - else if (strcmp (sectp->name, FRAME_SECTION) == 0) + else if (section_is_p (sectp->name, FRAME_SECTION)) { - dwarf2_per_objfile->frame_size = bfd_get_section_size (sectp); - dwarf_frame_section = sectp; + dwarf2_per_objfile->frame.asection = sectp; + dwarf2_per_objfile->frame.size = bfd_get_section_size (sectp); } - else if (strcmp (sectp->name, EH_FRAME_SECTION) == 0) + else if (section_is_p (sectp->name, EH_FRAME_SECTION)) { flagword aflag = bfd_get_section_flags (ignore_abfd, sectp); if (aflag & SEC_HAS_CONTENTS) { - dwarf2_per_objfile->eh_frame_size = bfd_get_section_size (sectp); - dwarf_eh_frame_section = sectp; + dwarf2_per_objfile->eh_frame.asection = sectp; + dwarf2_per_objfile->eh_frame.size = bfd_get_section_size (sectp); } } - else if (strcmp (sectp->name, RANGES_SECTION) == 0) + else if (section_is_p (sectp->name, RANGES_SECTION)) { - dwarf2_per_objfile->ranges_size = bfd_get_section_size (sectp); - dwarf_ranges_section = sectp; + dwarf2_per_objfile->ranges.asection = sectp; + dwarf2_per_objfile->ranges.size = bfd_get_section_size (sectp); } - + if ((bfd_get_section_flags (abfd, sectp) & SEC_LOAD) && bfd_section_vma (abfd, sectp) == 0) dwarf2_per_objfile->has_section_at_zero = 1; } -/* Build a partial symbol table. */ +/* Decompress a section that was compressed using zlib. Store the + decompressed buffer, and its size, in OUTBUF and OUTSIZE. */ -void -dwarf2_build_psymtabs (struct objfile *objfile, int mainline) +static void +zlib_decompress_section (struct objfile *objfile, asection *sectp, + gdb_byte **outbuf, bfd_size_type *outsize) +{ + bfd *abfd = objfile->obfd; +#ifndef HAVE_ZLIB_H + error (_("Support for zlib-compressed DWARF data (from '%s') " + "is disabled in this copy of GDB"), + bfd_get_filename (abfd)); +#else + bfd_size_type compressed_size = bfd_get_section_size (sectp); + gdb_byte *compressed_buffer = xmalloc (compressed_size); + struct cleanup *cleanup = make_cleanup (xfree, compressed_buffer); + bfd_size_type uncompressed_size; + gdb_byte *uncompressed_buffer; + z_stream strm; + int rc; + int header_size = 12; + + if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0 + || bfd_bread (compressed_buffer, compressed_size, abfd) != compressed_size) + error (_("Dwarf Error: Can't read DWARF data from '%s'"), + bfd_get_filename (abfd)); + + /* Read the zlib header. In this case, it should be "ZLIB" followed + by the uncompressed section size, 8 bytes in big-endian order. */ + if (compressed_size < header_size + || strncmp (compressed_buffer, "ZLIB", 4) != 0) + error (_("Dwarf Error: Corrupt DWARF ZLIB header from '%s'"), + bfd_get_filename (abfd)); + uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8; + uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8; + uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8; + uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8; + uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8; + uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8; + uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8; + uncompressed_size += compressed_buffer[11]; + + /* It is possible the section consists of several compressed + buffers concatenated together, so we uncompress in a loop. */ + strm.zalloc = NULL; + strm.zfree = NULL; + strm.opaque = NULL; + strm.avail_in = compressed_size - header_size; + strm.next_in = (Bytef*) compressed_buffer + header_size; + strm.avail_out = uncompressed_size; + uncompressed_buffer = obstack_alloc (&objfile->objfile_obstack, + uncompressed_size); + rc = inflateInit (&strm); + while (strm.avail_in > 0) + { + if (rc != Z_OK) + error (_("Dwarf Error: setting up DWARF uncompression in '%s': %d"), + bfd_get_filename (abfd), rc); + strm.next_out = ((Bytef*) uncompressed_buffer + + (uncompressed_size - strm.avail_out)); + rc = inflate (&strm, Z_FINISH); + if (rc != Z_STREAM_END) + error (_("Dwarf Error: zlib error uncompressing from '%s': %d"), + bfd_get_filename (abfd), rc); + rc = inflateReset (&strm); + } + rc = inflateEnd (&strm); + if (rc != Z_OK + || strm.avail_out != 0) + error (_("Dwarf Error: concluding DWARF uncompression in '%s': %d"), + bfd_get_filename (abfd), rc); + + do_cleanups (cleanup); + *outbuf = uncompressed_buffer; + *outsize = uncompressed_size; +#endif +} + +/* Read the contents of the section SECTP from object file specified by + OBJFILE, store info about the section into INFO. + If the section is compressed, uncompress it before returning. */ + +static void +dwarf2_read_section (struct objfile *objfile, struct dwarf2_section_info *info) { - /* We definitely need the .debug_info and .debug_abbrev sections */ + bfd *abfd = objfile->obfd; + asection *sectp = info->asection; + gdb_byte *buf, *retbuf; + unsigned char header[4]; - dwarf2_per_objfile->info_buffer = dwarf2_read_section (objfile, dwarf_info_section); - dwarf2_per_objfile->abbrev_buffer = dwarf2_read_section (objfile, dwarf_abbrev_section); + info->buffer = NULL; + info->was_mmapped = 0; - if (dwarf_line_section) - dwarf2_per_objfile->line_buffer = dwarf2_read_section (objfile, dwarf_line_section); - else - dwarf2_per_objfile->line_buffer = NULL; + if (info->asection == NULL || info->size == 0) + return; - if (dwarf_str_section) - dwarf2_per_objfile->str_buffer = dwarf2_read_section (objfile, dwarf_str_section); - else - dwarf2_per_objfile->str_buffer = NULL; + /* Check if the file has a 4-byte header indicating compression. */ + if (info->size > sizeof (header) + && bfd_seek (abfd, sectp->filepos, SEEK_SET) == 0 + && bfd_bread (header, sizeof (header), abfd) == sizeof (header)) + { + /* Upon decompression, update the buffer and its size. */ + if (strncmp (header, "ZLIB", sizeof (header)) == 0) + { + zlib_decompress_section (objfile, sectp, &info->buffer, + &info->size); + return; + } + } - if (dwarf_macinfo_section) - dwarf2_per_objfile->macinfo_buffer = dwarf2_read_section (objfile, - dwarf_macinfo_section); - else - dwarf2_per_objfile->macinfo_buffer = NULL; +#ifdef HAVE_MMAP + if (pagesize == 0) + pagesize = getpagesize (); - if (dwarf_ranges_section) - dwarf2_per_objfile->ranges_buffer = dwarf2_read_section (objfile, dwarf_ranges_section); - else - dwarf2_per_objfile->ranges_buffer = NULL; + /* Only try to mmap sections which are large enough: we don't want to + waste space due to fragmentation. Also, only try mmap for sections + without relocations. */ + + if (info->size > 4 * pagesize && (sectp->flags & SEC_RELOC) == 0) + { + off_t pg_offset = sectp->filepos & ~(pagesize - 1); + size_t map_length = info->size + sectp->filepos - pg_offset; + caddr_t retbuf = bfd_mmap (abfd, 0, map_length, PROT_READ, + MAP_PRIVATE, pg_offset); + + if (retbuf != MAP_FAILED) + { + info->was_mmapped = 1; + info->buffer = retbuf + (sectp->filepos & (pagesize - 1)) ; + return; + } + } +#endif + + /* If we get here, we are a normal, not-compressed section. */ + info->buffer = buf + = obstack_alloc (&objfile->objfile_obstack, info->size); + + /* When debugging .o files, we may need to apply relocations; see + http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html . + We never compress sections in .o files, so we only need to + try this when the section is not compressed. */ + retbuf = symfile_relocate_debug_section (abfd, sectp, buf); + if (retbuf != NULL) + { + info->buffer = retbuf; + return; + } + + if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0 + || bfd_bread (buf, info->size, abfd) != info->size) + error (_("Dwarf Error: Can't read DWARF data from '%s'"), + bfd_get_filename (abfd)); +} - if (dwarf_loc_section) - dwarf2_per_objfile->loc_buffer = dwarf2_read_section (objfile, dwarf_loc_section); +/* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and + SECTION_NAME. */ + +void +dwarf2_get_section_info (struct objfile *objfile, const char *section_name, + asection **sectp, gdb_byte **bufp, + bfd_size_type *sizep) +{ + struct dwarf2_per_objfile *data + = objfile_data (objfile, dwarf2_objfile_data_key); + struct dwarf2_section_info *info; + if (section_is_p (section_name, EH_FRAME_SECTION)) + info = &data->eh_frame; + else if (section_is_p (section_name, FRAME_SECTION)) + info = &data->frame; else - dwarf2_per_objfile->loc_buffer = NULL; + gdb_assert (0); + + if (info->asection != NULL && info->size != 0 && info->buffer == NULL) + /* We haven't read this section in yet. Do it now. */ + dwarf2_read_section (objfile, info); + + *sectp = info->asection; + *bufp = info->buffer; + *sizep = info->size; +} + +/* Build a partial symbol table. */ + +void +dwarf2_build_psymtabs (struct objfile *objfile, int mainline) +{ + dwarf2_read_section (objfile, &dwarf2_per_objfile->info); + dwarf2_read_section (objfile, &dwarf2_per_objfile->abbrev); + dwarf2_read_section (objfile, &dwarf2_per_objfile->line); + dwarf2_read_section (objfile, &dwarf2_per_objfile->str); + dwarf2_read_section (objfile, &dwarf2_per_objfile->macinfo); + dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges); + dwarf2_read_section (objfile, &dwarf2_per_objfile->loc); + dwarf2_read_section (objfile, &dwarf2_per_objfile->eh_frame); + dwarf2_read_section (objfile, &dwarf2_per_objfile->frame); if (mainline || (objfile->global_psymbols.size == 0 @@ -1265,13 +1432,11 @@ dwarf2_build_psymtabs_easy (struct objfile *objfile, int mainline) pubnames_buffer = dwarf2_read_section (objfile, dwarf_pubnames_section); pubnames_ptr = pubnames_buffer; - while ((pubnames_ptr - pubnames_buffer) < dwarf2_per_objfile->pubnames_size) + while ((pubnames_ptr - pubnames_buffer) < dwarf2_per_objfile->pubnames.size) { - struct comp_unit_head cu_header; unsigned int bytes_read; - entry_length = read_initial_length (abfd, pubnames_ptr, &cu_header, - &bytes_read); + entry_length = read_initial_length (abfd, pubnames_ptr, &bytes_read); pubnames_ptr += bytes_read; version = read_1_byte (abfd, pubnames_ptr); pubnames_ptr += 1; @@ -1287,6 +1452,18 @@ dwarf2_build_psymtabs_easy (struct objfile *objfile, int mainline) } #endif +/* Return TRUE if OFFSET is within CU_HEADER. */ + +static inline int +offset_in_cu_p (const struct comp_unit_head *cu_header, unsigned int offset) +{ + unsigned int bottom = cu_header->offset; + unsigned int top = (cu_header->offset + + cu_header->length + + cu_header->initial_length_size); + return (offset >= bottom && offset < top); +} + /* Read in the comp unit header information from the debug_info at info_ptr. */ @@ -1296,13 +1473,15 @@ read_comp_unit_head (struct comp_unit_head *cu_header, { int signed_addr; unsigned int bytes_read; - cu_header->length = read_initial_length (abfd, info_ptr, cu_header, - &bytes_read); + + cu_header->length = read_initial_length (abfd, info_ptr, &bytes_read); + cu_header->initial_length_size = bytes_read; + cu_header->offset_size = (bytes_read == 4) ? 4 : 8; info_ptr += bytes_read; cu_header->version = read_2_bytes (abfd, info_ptr); info_ptr += 2; cu_header->abbrev_offset = read_offset (abfd, info_ptr, cu_header, - &bytes_read); + &bytes_read); info_ptr += bytes_read; cu_header->addr_size = read_1_byte (abfd, info_ptr); info_ptr += 1; @@ -1311,6 +1490,7 @@ read_comp_unit_head (struct comp_unit_head *cu_header, internal_error (__FILE__, __LINE__, _("read_comp_unit_head: dwarf from non elf file")); cu_header->signed_addr_p = signed_addr; + return info_ptr; } @@ -1327,19 +1507,19 @@ partial_read_comp_unit_head (struct comp_unit_head *header, gdb_byte *info_ptr, "(is %d, should be %d) [in module %s]"), header->version, 2, bfd_get_filename (abfd)); - if (header->abbrev_offset >= dwarf2_per_objfile->abbrev_size) + if (header->abbrev_offset >= dwarf2_per_objfile->abbrev.size) error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header " "(offset 0x%lx + 6) [in module %s]"), (long) header->abbrev_offset, - (long) (beg_of_comp_unit - dwarf2_per_objfile->info_buffer), + (long) (beg_of_comp_unit - dwarf2_per_objfile->info.buffer), bfd_get_filename (abfd)); if (beg_of_comp_unit + header->length + header->initial_length_size - > dwarf2_per_objfile->info_buffer + dwarf2_per_objfile->info_size) + > dwarf2_per_objfile->info.buffer + dwarf2_per_objfile->info.size) error (_("Dwarf Error: bad length (0x%lx) in compilation unit header " "(offset 0x%lx + 0) [in module %s]"), (long) header->length, - (long) (beg_of_comp_unit - dwarf2_per_objfile->info_buffer), + (long) (beg_of_comp_unit - dwarf2_per_objfile->info.buffer), bfd_get_filename (abfd)); return info_ptr; @@ -1419,9 +1599,9 @@ dwarf2_build_psymtabs_hard (struct objfile *objfile, int mainline) struct partial_die_info comp_unit_die; struct partial_symtab *pst; struct cleanup *back_to; - CORE_ADDR lowpc, highpc, baseaddr; + CORE_ADDR baseaddr; - info_ptr = dwarf2_per_objfile->info_buffer; + info_ptr = dwarf2_per_objfile->info.buffer; /* Any cached compilation units will be linked by the per-objfile read_in_chain. Make sure to free them when we're done. */ @@ -1429,6 +1609,9 @@ dwarf2_build_psymtabs_hard (struct objfile *objfile, int mainline) create_all_comp_units (objfile); + objfile->psymtabs_addrmap = addrmap_create_mutable + (&objfile->objfile_obstack); + /* Since the objects we're extracting from .debug_info vary in length, only the individual functions to extract them (like read_comp_unit_head and load_partial_die) can really know whether @@ -1442,8 +1625,8 @@ dwarf2_build_psymtabs_hard (struct objfile *objfile, int mainline) For this loop condition, simply checking whether there's any data left at all should be sufficient. */ - while (info_ptr < (dwarf2_per_objfile->info_buffer - + dwarf2_per_objfile->info_size)) + while (info_ptr < (dwarf2_per_objfile->info.buffer + + dwarf2_per_objfile->info.size)) { struct cleanup *back_to_inner; struct dwarf2_cu cu; @@ -1463,9 +1646,8 @@ dwarf2_build_psymtabs_hard (struct objfile *objfile, int mainline) info_ptr = partial_read_comp_unit_head (&cu.header, info_ptr, abfd); /* Complete the cu_header */ - cu.header.offset = beg_of_comp_unit - dwarf2_per_objfile->info_buffer; - cu.header.first_die_ptr = info_ptr; - cu.header.cu_head_ptr = beg_of_comp_unit; + cu.header.offset = beg_of_comp_unit - dwarf2_per_objfile->info.buffer; + cu.header.first_die_offset = info_ptr - beg_of_comp_unit; cu.list_in_scope = &file_symbols; @@ -1494,12 +1676,15 @@ dwarf2_build_psymtabs_hard (struct objfile *objfile, int mainline) /* 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, + /* TEXTLOW and TEXTHIGH are set below. */ + 0, objfile->global_psymbols.next, objfile->static_psymbols.next); if (comp_unit_die.dirname) - pst->dirname = xstrdup (comp_unit_die.dirname); + pst->dirname = obsavestring (comp_unit_die.dirname, + strlen (comp_unit_die.dirname), + &objfile->objfile_obstack); pst->read_symtab_private = (char *) this_cu; @@ -1527,19 +1712,37 @@ dwarf2_build_psymtabs_hard (struct objfile *objfile, int mainline) this_cu->psymtab = pst; + /* Possibly set the default values of LOWPC and HIGHPC from + `DW_AT_ranges'. */ + if (cu.has_ranges_offset) + { + if (dwarf2_ranges_read (cu.ranges_offset, &comp_unit_die.lowpc, + &comp_unit_die.highpc, &cu, pst)) + comp_unit_die.has_pc_info = 1; + } + else if (comp_unit_die.has_pc_info + && comp_unit_die.lowpc < comp_unit_die.highpc) + /* Store the contiguous range if it is not empty; it can be empty for + CUs with no code. */ + addrmap_set_empty (objfile->psymtabs_addrmap, + comp_unit_die.lowpc + baseaddr, + comp_unit_die.highpc + baseaddr - 1, pst); + /* 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) { struct partial_die_info *first_die; + CORE_ADDR lowpc, highpc; lowpc = ((CORE_ADDR) -1); highpc = ((CORE_ADDR) 0); first_die = load_partial_dies (abfd, info_ptr, 1, &cu); - scan_partial_symbols (first_die, &lowpc, &highpc, &cu); + scan_partial_symbols (first_die, &lowpc, &highpc, + ! comp_unit_die.has_pc_info, &cu); /* If we didn't find a lowpc, set it to highpc to avoid complaints from `maint check'. */ @@ -1580,6 +1783,10 @@ dwarf2_build_psymtabs_hard (struct objfile *objfile, int mainline) do_cleanups (back_to_inner); } + + objfile->psymtabs_addrmap = addrmap_create_fixed (objfile->psymtabs_addrmap, + &objfile->objfile_obstack); + do_cleanups (back_to); } @@ -1596,7 +1803,7 @@ load_comp_unit (struct dwarf2_per_cu_data *this_cu, struct objfile *objfile) unsigned int bytes_read; struct cleanup *back_to; - info_ptr = dwarf2_per_objfile->info_buffer + this_cu->offset; + info_ptr = dwarf2_per_objfile->info.buffer + this_cu->offset; beg_of_comp_unit = info_ptr; cu = xmalloc (sizeof (struct dwarf2_cu)); @@ -1608,9 +1815,8 @@ load_comp_unit (struct dwarf2_per_cu_data *this_cu, struct objfile *objfile) info_ptr = partial_read_comp_unit_head (&cu->header, info_ptr, abfd); /* Complete the cu_header. */ - cu->header.offset = beg_of_comp_unit - dwarf2_per_objfile->info_buffer; - cu->header.first_die_ptr = info_ptr; - cu->header.cu_head_ptr = beg_of_comp_unit; + cu->header.offset = beg_of_comp_unit - dwarf2_per_objfile->info.buffer; + cu->header.first_die_offset = info_ptr - beg_of_comp_unit; /* Read the abbrevs for this compilation unit into a table. */ dwarf2_read_abbrevs (abfd, cu); @@ -1627,6 +1833,7 @@ load_comp_unit (struct dwarf2_per_cu_data *this_cu, struct objfile *objfile) /* Link this compilation unit into the compilation unit tree. */ this_cu->cu = cu; cu->per_cu = this_cu; + cu->type_hash = cu->per_cu->type_hash; /* Check if comp unit has_children. If so, read the rest of the partial symbols from this comp unit. @@ -1648,35 +1855,33 @@ create_all_comp_units (struct objfile *objfile) int n_allocated; int n_comp_units; struct dwarf2_per_cu_data **all_comp_units; - gdb_byte *info_ptr = dwarf2_per_objfile->info_buffer; + gdb_byte *info_ptr = dwarf2_per_objfile->info.buffer; n_comp_units = 0; n_allocated = 10; all_comp_units = xmalloc (n_allocated * sizeof (struct dwarf2_per_cu_data *)); - while (info_ptr < dwarf2_per_objfile->info_buffer + dwarf2_per_objfile->info_size) + while (info_ptr < dwarf2_per_objfile->info.buffer + dwarf2_per_objfile->info.size) { - struct comp_unit_head cu_header; + unsigned int length, initial_length_size; gdb_byte *beg_of_comp_unit; struct dwarf2_per_cu_data *this_cu; - unsigned long offset; - unsigned int bytes_read; + unsigned int offset; - offset = info_ptr - dwarf2_per_objfile->info_buffer; + offset = info_ptr - dwarf2_per_objfile->info.buffer; /* Read just enough information to find out where the next compilation unit is. */ - cu_header.initial_length_size = 0; - cu_header.length = read_initial_length (objfile->obfd, info_ptr, - &cu_header, &bytes_read); + length = read_initial_length (objfile->obfd, info_ptr, + &initial_length_size); /* Save the compilation unit for later lookup. */ this_cu = obstack_alloc (&objfile->objfile_obstack, sizeof (struct dwarf2_per_cu_data)); memset (this_cu, 0, sizeof (*this_cu)); this_cu->offset = offset; - this_cu->length = cu_header.length + cu_header.initial_length_size; + this_cu->length = length + initial_length_size; if (n_comp_units == n_allocated) { @@ -1699,13 +1904,16 @@ create_all_comp_units (struct objfile *objfile) dwarf2_per_objfile->n_comp_units = n_comp_units; } -/* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE. - Also set *LOWPC and *HIGHPC to the lowest and highest PC values found - in CU. */ +/* Process all loaded DIEs for compilation unit CU, starting at + FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation + unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or + DW_AT_ranges). If NEED_PC is set, then this function will set + *LOWPC and *HIGHPC to the lowest and highest PC values found in CU + and record the covered ranges in the addrmap. */ static void scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc, - CORE_ADDR *highpc, struct dwarf2_cu *cu) + CORE_ADDR *highpc, int need_pc, struct dwarf2_cu *cu) { struct objfile *objfile = cu->objfile; bfd *abfd = objfile->obfd; @@ -1731,21 +1939,7 @@ scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc, switch (pdi->tag) { case DW_TAG_subprogram: - if (pdi->has_pc_info) - { - if (pdi->lowpc < *lowpc) - { - *lowpc = pdi->lowpc; - } - if (pdi->highpc > *highpc) - { - *highpc = pdi->highpc; - } - if (!pdi->is_declaration) - { - add_partial_symbol (pdi, cu); - } - } + add_partial_subprogram (pdi, lowpc, highpc, need_pc, cu); break; case DW_TAG_variable: case DW_TAG_typedef: @@ -1756,6 +1950,7 @@ scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc, } break; case DW_TAG_class_type: + case DW_TAG_interface_type: case DW_TAG_structure_type: if (!pdi->is_declaration) { @@ -1773,7 +1968,10 @@ scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc, add_partial_symbol (pdi, cu); break; case DW_TAG_namespace: - add_partial_namespace (pdi, lowpc, highpc, cu); + add_partial_namespace (pdi, lowpc, highpc, need_pc, cu); + break; + case DW_TAG_module: + add_partial_module (pdi, lowpc, highpc, need_pc, cu); break; default: break; @@ -1838,6 +2036,7 @@ partial_die_parent_scope (struct partial_die_info *pdi, if (parent->tag == DW_TAG_namespace || parent->tag == DW_TAG_structure_type || parent->tag == DW_TAG_class_type + || parent->tag == DW_TAG_interface_type || parent->tag == DW_TAG_union_type) { if (grandparent_scope == NULL) @@ -1905,8 +2104,12 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) switch (pdi->tag) { case DW_TAG_subprogram: - if (pdi->is_external) + if (pdi->is_external || cu->language == language_ada) { + /* brobecker/2007-12-26: Normally, only "external" DIEs are part + of the global scope. But in Ada, we want to be able to access + nested procedures globally. So all Ada subprograms are stored + in the global scope. */ /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr, mst_text, objfile); */ psym = add_psymbol_to_list (actual_name, strlen (actual_name), @@ -1985,6 +2188,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) 0, (CORE_ADDR) 0, cu->language, objfile); break; case DW_TAG_class_type: + case DW_TAG_interface_type: case DW_TAG_structure_type: case DW_TAG_union_type: case DW_TAG_enumeration_type: @@ -2010,16 +2214,6 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) : &objfile->static_psymbols, 0, (CORE_ADDR) 0, cu->language, objfile); - if (cu->language == language_cplus - || cu->language == language_java - || cu->language == language_ada) - { - /* For C++ and Java, these implicitly act as typedefs as well. */ - add_psymbol_to_list (actual_name, strlen (actual_name), - VAR_DOMAIN, LOC_TYPEDEF, - &objfile->global_psymbols, - 0, (CORE_ADDR) 0, cu->language, objfile); - } break; case DW_TAG_enumerator: add_psymbol_to_list (actual_name, strlen (actual_name), @@ -2066,6 +2260,7 @@ pdi_needs_namespace (enum dwarf_tag tag) case DW_TAG_namespace: case DW_TAG_typedef: case DW_TAG_class_type: + case DW_TAG_interface_type: case DW_TAG_structure_type: case DW_TAG_union_type: case DW_TAG_enumeration_type: @@ -2083,7 +2278,7 @@ pdi_needs_namespace (enum dwarf_tag tag) static void add_partial_namespace (struct partial_die_info *pdi, CORE_ADDR *lowpc, CORE_ADDR *highpc, - struct dwarf2_cu *cu) + int need_pc, struct dwarf2_cu *cu) { struct objfile *objfile = cu->objfile; @@ -2094,7 +2289,77 @@ add_partial_namespace (struct partial_die_info *pdi, /* Now scan partial symbols in that namespace. */ if (pdi->has_children) - scan_partial_symbols (pdi->die_child, lowpc, highpc, cu); + scan_partial_symbols (pdi->die_child, lowpc, highpc, need_pc, cu); +} + +/* Read a partial die corresponding to a Fortran module. */ + +static void +add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc, + CORE_ADDR *highpc, int need_pc, struct dwarf2_cu *cu) +{ + /* Now scan partial symbols in that module. + + FIXME: Support the separate Fortran module namespaces. */ + + if (pdi->has_children) + scan_partial_symbols (pdi->die_child, lowpc, highpc, need_pc, cu); +} + +/* Read a partial die corresponding to a subprogram and create a partial + symbol for that subprogram. When the CU language allows it, this + routine also defines a partial symbol for each nested subprogram + that this subprogram contains. + + DIE my also be a lexical block, in which case we simply search + recursively for suprograms defined inside that lexical block. + Again, this is only performed when the CU language allows this + type of definitions. */ + +static void +add_partial_subprogram (struct partial_die_info *pdi, + CORE_ADDR *lowpc, CORE_ADDR *highpc, + int need_pc, struct dwarf2_cu *cu) +{ + if (pdi->tag == DW_TAG_subprogram) + { + if (pdi->has_pc_info) + { + if (pdi->lowpc < *lowpc) + *lowpc = pdi->lowpc; + if (pdi->highpc > *highpc) + *highpc = pdi->highpc; + if (need_pc) + { + CORE_ADDR baseaddr; + struct objfile *objfile = cu->objfile; + + baseaddr = ANOFFSET (objfile->section_offsets, + SECT_OFF_TEXT (objfile)); + addrmap_set_empty (objfile->psymtabs_addrmap, + pdi->lowpc, pdi->highpc - 1, + cu->per_cu->psymtab); + } + if (!pdi->is_declaration) + add_partial_symbol (pdi, cu); + } + } + + if (! pdi->has_children) + return; + + if (cu->language == language_ada) + { + pdi = pdi->die_child; + while (pdi != NULL) + { + fixup_partial_die (pdi, cu); + if (pdi->tag == DW_TAG_subprogram + || pdi->tag == DW_TAG_lexical_block) + add_partial_subprogram (pdi, lowpc, highpc, need_pc, cu); + pdi = pdi->die_sibling; + } + } } /* See if we can figure out if the class lives in a namespace. We do @@ -2250,8 +2515,8 @@ skip_one_die (gdb_byte *info_ptr, struct abbrev_info *abbrev, if (attr.form == DW_FORM_ref_addr) complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling")); else - return dwarf2_per_objfile->info_buffer - + dwarf2_get_ref_die_offset (&attr, cu); + return dwarf2_per_objfile->info.buffer + + dwarf2_get_ref_die_offset (&attr); } /* If it isn't DW_AT_sibling, skip this attribute. */ @@ -2371,6 +2636,19 @@ dwarf2_psymtab_to_symtab (struct partial_symtab *pst) dwarf2_per_objfile = objfile_data (pst->objfile, dwarf2_objfile_data_key); + /* If this psymtab is constructed from a debug-only objfile, the + has_section_at_zero flag will not necessarily be correct. We + can get the correct value for this flag by looking at the data + associated with the (presumably stripped) associated objfile. */ + if (pst->objfile->separate_debug_objfile_backlink) + { + struct dwarf2_per_objfile *dpo_backlink + = objfile_data (pst->objfile->separate_debug_objfile_backlink, + dwarf2_objfile_data_key); + dwarf2_per_objfile->has_section_at_zero + = dpo_backlink->has_section_at_zero; + } + psymtab_to_symtab_1 (pst); /* Finish up the debug error message. */ @@ -2383,7 +2661,7 @@ dwarf2_psymtab_to_symtab (struct partial_symtab *pst) /* Add PER_CU to the queue. */ static void -queue_comp_unit (struct dwarf2_per_cu_data *per_cu) +queue_comp_unit (struct dwarf2_per_cu_data *per_cu, struct objfile *objfile) { struct dwarf2_queue_item *item; @@ -2398,6 +2676,12 @@ queue_comp_unit (struct dwarf2_per_cu_data *per_cu) dwarf2_queue_tail->next = item; dwarf2_queue_tail = item; + + /* Either PER_CU is the CU we want to process, or we're following a reference + pointing into PER_CU. Either way, we need its DIEs now. */ + load_full_comp_unit (item->per_cu, objfile); + item->per_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain; + dwarf2_per_objfile->read_in_chain = item->per_cu; } /* Process the queue. */ @@ -2407,28 +2691,8 @@ process_queue (struct objfile *objfile) { struct dwarf2_queue_item *item, *next_item; - /* Initially, there is just one item on the queue. Load its DIEs, - and the DIEs of any other compilation units it requires, - transitively. */ - - for (item = dwarf2_queue; item != NULL; item = item->next) - { - /* Read in this compilation unit. This may add new items to - the end of the queue. */ - load_full_comp_unit (item->per_cu, objfile); - - item->per_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain; - dwarf2_per_objfile->read_in_chain = item->per_cu; - - /* If this compilation unit has already had full symbols created, - reset the TYPE fields in each DIE. */ - if (item->per_cu->type_hash) - reset_die_and_siblings_types (item->per_cu->cu->dies, - item->per_cu->cu); - } - - /* Now everything left on the queue needs to be read in. Process - them, one at a time, removing from the queue as we finish. */ + /* The queue starts out with one item, but following a DIE reference + may load a new CU, adding it to the end of the queue. */ for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item) { if (item->per_cu->psymtab && !item->per_cu->psymtab->readin) @@ -2510,7 +2774,7 @@ psymtab_to_symtab_1 (struct partial_symtab *pst) back_to = make_cleanup (dwarf2_release_queue, NULL); - queue_comp_unit (per_cu); + queue_comp_unit (per_cu, pst->objfile); process_queue (pst->objfile); @@ -2528,7 +2792,7 @@ load_full_comp_unit (struct dwarf2_per_cu_data *per_cu, struct objfile *objfile) { bfd *abfd = objfile->obfd; struct dwarf2_cu *cu; - unsigned long offset; + unsigned int offset; gdb_byte *info_ptr; struct cleanup *back_to, *free_cu_cleanup; struct attribute *attr; @@ -2537,7 +2801,7 @@ load_full_comp_unit (struct dwarf2_per_cu_data *per_cu, struct objfile *objfile) /* Set local variables from the partial symbol table info. */ offset = per_cu->offset; - info_ptr = dwarf2_per_objfile->info_buffer + offset; + info_ptr = dwarf2_per_objfile->info.buffer + offset; cu = xmalloc (sizeof (struct dwarf2_cu)); memset (cu, 0, sizeof (struct dwarf2_cu)); @@ -2558,6 +2822,7 @@ load_full_comp_unit (struct dwarf2_per_cu_data *per_cu, struct objfile *objfile) cu->per_cu = per_cu; per_cu->cu = cu; + cu->type_hash = per_cu->type_hash; /* We use this obstack for block values in dwarf_alloc_block. */ obstack_init (&cu->comp_unit_obstack); @@ -2601,9 +2866,6 @@ process_full_comp_unit (struct dwarf2_per_cu_data *per_cu) baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); - /* We're in the global namespace. */ - processing_current_prefix = ""; - buildsym_init (); back_to = make_cleanup (really_free_pendings, NULL); @@ -2615,22 +2877,22 @@ process_full_comp_unit (struct dwarf2_per_cu_data *per_cu) DW_AT_entry_pc. It's been removed, but GCC still uses this for compilation units with discontinuous ranges. */ - cu->header.base_known = 0; - cu->header.base_address = 0; + cu->base_known = 0; + cu->base_address = 0; attr = dwarf2_attr (cu->dies, DW_AT_entry_pc, cu); if (attr) { - cu->header.base_address = DW_ADDR (attr); - cu->header.base_known = 1; + cu->base_address = DW_ADDR (attr); + cu->base_known = 1; } else { attr = dwarf2_attr (cu->dies, DW_AT_low_pc, cu); if (attr) { - cu->header.base_address = DW_ADDR (attr); - cu->header.base_known = 1; + cu->base_address = DW_ADDR (attr); + cu->base_known = 1; } } @@ -2671,13 +2933,8 @@ process_die (struct die_info *die, struct dwarf2_cu *cu) read_file_scope (die, cu); break; case DW_TAG_subprogram: - read_subroutine_type (die, cu); - read_func_scope (die, cu); - 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. */ + read_func_scope (die, cu); break; case DW_TAG_lexical_block: case DW_TAG_try_block: @@ -2685,53 +2942,33 @@ process_die (struct die_info *die, struct dwarf2_cu *cu) read_lexical_block_scope (die, cu); break; case DW_TAG_class_type: + case DW_TAG_interface_type: case DW_TAG_structure_type: case DW_TAG_union_type: - read_structure_type (die, cu); process_structure_scope (die, cu); break; case DW_TAG_enumeration_type: - read_enumeration_type (die, cu); process_enumeration_scope (die, cu); break; - /* FIXME drow/2004-03-14: These initialize die->type, but do not create - a symbol or process any children. Therefore it doesn't do anything - that won't be done on-demand by read_type_die. */ + /* These dies have a type, but processing them does not create + a symbol or recurse to process the children. Therefore we can + read them on-demand through read_type_die. */ case DW_TAG_subroutine_type: - read_subroutine_type (die, cu); - break; case DW_TAG_set_type: - read_set_type (die, cu); - break; case DW_TAG_array_type: - read_array_type (die, cu); - break; case DW_TAG_pointer_type: - read_tag_pointer_type (die, cu); - break; case DW_TAG_ptr_to_member_type: - read_tag_ptr_to_member_type (die, cu); - break; case DW_TAG_reference_type: - read_tag_reference_type (die, cu); - break; case DW_TAG_string_type: - read_tag_string_type (die, cu); break; - /* END FIXME */ case DW_TAG_base_type: - read_base_type (die, cu); - /* Add a typedef symbol for the type definition, if it has a - DW_AT_name. */ - new_symbol (die, die->type, cu); - break; case DW_TAG_subrange_type: - read_subrange_type (die, cu); + case DW_TAG_typedef: /* Add a typedef symbol for the type definition, if it has a DW_AT_name. */ - new_symbol (die, die->type, cu); + new_symbol (die, read_type_die (die, cu), cu); break; case DW_TAG_common_block: read_common_block (die, cu); @@ -2742,16 +2979,17 @@ process_die (struct die_info *die, struct dwarf2_cu *cu) processing_has_namespace_info = 1; read_namespace (die, cu); break; + case DW_TAG_module: + read_module (die, cu); + break; case DW_TAG_imported_declaration: case DW_TAG_imported_module: - /* FIXME: carlton/2002-10-16: Eventually, we should use the - information contained in these. DW_TAG_imported_declaration - dies shouldn't have children; DW_TAG_imported_module dies - shouldn't in the C++ case, but conceivably could in the - Fortran case, so we'll have to replace this gdb_assert if - Fortran compilers start generating that info. */ processing_has_namespace_info = 1; - gdb_assert (die->child == NULL); + if (die->child != NULL && (die->tag == DW_TAG_imported_declaration + || cu->language != language_fortran)) + complaint (&symfile_complaints, _("Tag '%s' has unexpected children"), + dwarf_tag_name (die->tag)); + read_import_statement (die, cu); break; default: new_symbol (die, NULL, cu); @@ -2759,6 +2997,128 @@ process_die (struct die_info *die, struct dwarf2_cu *cu) } } +/* Return the fully qualified name of DIE, based on its DW_AT_name. + If scope qualifiers are appropriate they will be added. The result + will be allocated on the objfile_obstack, or NULL if the DIE does + not have a name. */ + +static const char * +dwarf2_full_name (struct die_info *die, struct dwarf2_cu *cu) +{ + struct attribute *attr; + char *prefix, *name; + struct ui_file *buf = NULL; + + name = dwarf2_name (die, cu); + if (!name) + return NULL; + + /* These are the only languages we know how to qualify names in. */ + if (cu->language != language_cplus + && cu->language != language_java) + return name; + + /* If no prefix is necessary for this type of DIE, return the + unqualified name. The other three tags listed could be handled + in pdi_needs_namespace, but that requires broader changes. */ + if (!pdi_needs_namespace (die->tag) + && die->tag != DW_TAG_subprogram + && die->tag != DW_TAG_variable + && die->tag != DW_TAG_member) + return name; + + prefix = determine_prefix (die, cu); + if (*prefix != '\0') + name = typename_concat (&cu->objfile->objfile_obstack, prefix, + name, cu); + + return name; +} + +/* Read the import statement specified by the given die and record it. */ + +static void +read_import_statement (struct die_info *die, struct dwarf2_cu *cu) +{ + struct attribute *import_attr; + struct die_info *imported_die; + const char *imported_name; + const char *imported_name_prefix; + const char *import_prefix; + char *canonical_name; + + import_attr = dwarf2_attr (die, DW_AT_import, cu); + if (import_attr == NULL) + { + complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"), + dwarf_tag_name (die->tag)); + return; + } + + imported_die = follow_die_ref (die, import_attr, &cu); + imported_name = dwarf2_name (imported_die, cu); + if (imported_name == NULL) + { + /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524 + + The import in the following code: + namespace A + { + typedef int B; + } + + int main () + { + using A::B; + B b; + return b; + } + + ... + <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration) + <52> DW_AT_decl_file : 1 + <53> DW_AT_decl_line : 6 + <54> DW_AT_import : <0x75> + <2><58>: Abbrev Number: 4 (DW_TAG_typedef) + <59> DW_AT_name : B + <5b> DW_AT_decl_file : 1 + <5c> DW_AT_decl_line : 2 + <5d> DW_AT_type : <0x6e> + ... + <1><75>: Abbrev Number: 7 (DW_TAG_base_type) + <76> DW_AT_byte_size : 4 + <77> DW_AT_encoding : 5 (signed) + + imports the wrong die ( 0x75 instead of 0x58 ). + This case will be ignored until the gcc bug is fixed. */ + return; + } + + /* FIXME: dwarf2_name (die); for the local name after import. */ + + /* Figure out where the statement is being imported to. */ + import_prefix = determine_prefix (die, cu); + + /* Figure out what the scope of the imported die is and prepend it + to the name of the imported die. */ + imported_name_prefix = determine_prefix (imported_die, cu); + + if (strlen (imported_name_prefix) > 0) + { + canonical_name = alloca (strlen (imported_name_prefix) + 2 + strlen (imported_name) + 1); + strcpy (canonical_name, imported_name_prefix); + strcat (canonical_name, "::"); + strcat (canonical_name, imported_name); + } + else + { + canonical_name = alloca (strlen (imported_name) + 1); + strcpy (canonical_name, imported_name); + } + + using_directives = cp_add_using (import_prefix,canonical_name, using_directives); +} + static void initialize_cu_func_list (struct dwarf2_cu *cu) { @@ -2844,9 +3204,7 @@ read_file_scope (struct die_info *die, struct dwarf2_cu *cu) /* We assume that we're processing GCC output. */ processing_gcc_compilation = 2; - /* The compilation unit may be in a different language or objfile, - zero out all remembered fundamental types. */ - memset (cu->ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *)); + processing_has_namespace_info = 0; start_symtab (name, comp_dir, lowpc); record_debugformat ("DWARF 2"); @@ -2917,6 +3275,123 @@ add_to_cu_func_list (const char *name, CORE_ADDR lowpc, CORE_ADDR highpc, cu->last_fn = thisfn; } +/* qsort helper for inherit_abstract_dies. */ + +static int +unsigned_int_compar (const void *ap, const void *bp) +{ + unsigned int a = *(unsigned int *) ap; + unsigned int b = *(unsigned int *) bp; + + return (a > b) - (b > a); +} + +/* DW_AT_abstract_origin inherits whole DIEs (not just their attributes). + Inherit only the children of the DW_AT_abstract_origin DIE not being already + referenced by DW_AT_abstract_origin from the children of the current DIE. */ + +static void +inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu) +{ + struct die_info *child_die; + unsigned die_children_count; + /* CU offsets which were referenced by children of the current DIE. */ + unsigned *offsets; + unsigned *offsets_end, *offsetp; + /* Parent of DIE - referenced by DW_AT_abstract_origin. */ + struct die_info *origin_die; + /* Iterator of the ORIGIN_DIE children. */ + struct die_info *origin_child_die; + struct cleanup *cleanups; + struct attribute *attr; + + attr = dwarf2_attr (die, DW_AT_abstract_origin, cu); + if (!attr) + return; + + origin_die = follow_die_ref (die, attr, &cu); + if (die->tag != origin_die->tag + && !(die->tag == DW_TAG_inlined_subroutine + && origin_die->tag == DW_TAG_subprogram)) + complaint (&symfile_complaints, + _("DIE 0x%x and its abstract origin 0x%x have different tags"), + die->offset, origin_die->offset); + + child_die = die->child; + die_children_count = 0; + while (child_die && child_die->tag) + { + child_die = sibling_die (child_die); + die_children_count++; + } + offsets = xmalloc (sizeof (*offsets) * die_children_count); + cleanups = make_cleanup (xfree, offsets); + + offsets_end = offsets; + child_die = die->child; + while (child_die && child_die->tag) + { + /* For each CHILD_DIE, find the corresponding child of + ORIGIN_DIE. If there is more than one layer of + DW_AT_abstract_origin, follow them all; there shouldn't be, + but GCC versions at least through 4.4 generate this (GCC PR + 40573). */ + struct die_info *child_origin_die = child_die; + while (1) + { + attr = dwarf2_attr (child_origin_die, DW_AT_abstract_origin, cu); + if (attr == NULL) + break; + child_origin_die = follow_die_ref (child_origin_die, attr, &cu); + } + + /* According to DWARF3 3.3.8.2 #3 new entries without their abstract + counterpart may exist. */ + if (child_origin_die != child_die) + { + if (child_die->tag != child_origin_die->tag + && !(child_die->tag == DW_TAG_inlined_subroutine + && child_origin_die->tag == DW_TAG_subprogram)) + complaint (&symfile_complaints, + _("Child DIE 0x%x and its abstract origin 0x%x have " + "different tags"), child_die->offset, + child_origin_die->offset); + if (child_origin_die->parent != origin_die) + complaint (&symfile_complaints, + _("Child DIE 0x%x and its abstract origin 0x%x have " + "different parents"), child_die->offset, + child_origin_die->offset); + else + *offsets_end++ = child_origin_die->offset; + } + child_die = sibling_die (child_die); + } + qsort (offsets, offsets_end - offsets, sizeof (*offsets), + unsigned_int_compar); + for (offsetp = offsets + 1; offsetp < offsets_end; offsetp++) + if (offsetp[-1] == *offsetp) + complaint (&symfile_complaints, _("Multiple children of DIE 0x%x refer " + "to DIE 0x%x as their abstract origin"), + die->offset, *offsetp); + + offsetp = offsets; + origin_child_die = origin_die->child; + while (origin_child_die && origin_child_die->tag) + { + /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */ + while (offsetp < offsets_end && *offsetp < origin_child_die->offset) + offsetp++; + if (offsetp >= offsets_end || *offsetp > origin_child_die->offset) + { + /* Found that ORIGIN_CHILD_DIE is really not referenced. */ + process_die (origin_child_die, cu); + } + origin_child_die = sibling_die (origin_child_die); + } + + do_cleanups (cleanups); +} + static void read_func_scope (struct die_info *die, struct dwarf2_cu *cu) { @@ -2925,11 +3400,25 @@ read_func_scope (struct die_info *die, struct dwarf2_cu *cu) CORE_ADDR lowpc; CORE_ADDR highpc; struct die_info *child_die; - struct attribute *attr; + struct attribute *attr, *call_line, *call_file; char *name; - const char *previous_prefix = processing_current_prefix; - struct cleanup *back_to = NULL; CORE_ADDR baseaddr; + struct block *block; + int inlined_func = (die->tag == DW_TAG_inlined_subroutine); + + if (inlined_func) + { + /* If we do not have call site information, we can't show the + caller of this inlined function. That's too confusing, so + only use the scope for local variables. */ + call_line = dwarf2_attr (die, DW_AT_call_line, cu); + call_file = dwarf2_attr (die, DW_AT_call_file, cu); + if (call_line == NULL || call_file == NULL) + { + read_lexical_block_scope (die, cu); + return; + } + } baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); @@ -2940,41 +3429,6 @@ read_func_scope (struct die_info *die, struct dwarf2_cu *cu) if (name == NULL || !dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu)) return; - if (cu->language == language_cplus - || cu->language == language_java) - { - struct die_info *spec_die = die_specification (die, cu); - - /* NOTE: carlton/2004-01-23: We have to be careful in the - presence of DW_AT_specification. For example, with GCC 3.4, - given the code - - namespace N { - void foo() { - // Definition of N::foo. - } - } - - then we'll have a tree of DIEs like this: - - 1: DW_TAG_compile_unit - 2: DW_TAG_namespace // N - 3: DW_TAG_subprogram // declaration of N::foo - 4: DW_TAG_subprogram // definition of N::foo - DW_AT_specification // refers to die #3 - - Thus, when processing die #4, we have to pretend that we're - in the context of its DW_AT_specification, namely the contex - of die #3. */ - - if (spec_die != NULL) - { - char *specification_prefix = determine_prefix (spec_die, cu); - processing_current_prefix = specification_prefix; - back_to = make_cleanup (xfree, specification_prefix); - } - } - lowpc += baseaddr; highpc += baseaddr; @@ -2982,7 +3436,7 @@ read_func_scope (struct die_info *die, struct dwarf2_cu *cu) add_to_cu_func_list (name, lowpc, highpc, cu); new = push_context (0, lowpc); - new->name = new_symbol (die, die->type, cu); + new->name = new_symbol (die, read_type_die (die, cu), cu); /* If there is a location expression for DW_AT_frame_base, record it. */ @@ -3011,10 +3465,21 @@ read_func_scope (struct die_info *die, struct dwarf2_cu *cu) } } + inherit_abstract_dies (die, cu); + new = pop_context (); /* Make a block for the local symbols within. */ - finish_block (new->name, &local_symbols, new->old_blocks, - lowpc, highpc, objfile); + block = finish_block (new->name, &local_symbols, new->old_blocks, + lowpc, highpc, objfile); + + /* For C++, set the block's scope. */ + if (cu->language == language_cplus) + cp_set_block_scope (new->name, block, &objfile->objfile_obstack, + determine_prefix (die, cu), + processing_has_namespace_info); + + /* If we have address ranges, record them. */ + dwarf2_record_block_ranges (die, block, baseaddr, cu); /* In C++, we can have functions nested inside functions (e.g., when a function declares a class that has methods). This means that @@ -3022,15 +3487,12 @@ read_func_scope (struct die_info *die, struct dwarf2_cu *cu) back to building a containing block's symbol lists. */ local_symbols = new->locals; param_symbols = new->params; + using_directives = new->using_directives; /* If we've finished processing a top-level function, subsequent symbols go in the file symbol list. */ if (outermost_context_p ()) cu->list_in_scope = &file_symbols; - - processing_current_prefix = previous_prefix; - if (back_to != NULL) - do_cleanups (back_to); } /* Process all the DIES contained within a lexical block scope. Start @@ -3071,10 +3533,152 @@ read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu) if (local_symbols != NULL) { - finish_block (0, &local_symbols, new->old_blocks, new->start_addr, - highpc, objfile); + struct block *block + = finish_block (0, &local_symbols, new->old_blocks, new->start_addr, + highpc, objfile); + + /* Note that recording ranges after traversing children, as we + do here, means that recording a parent's ranges entails + walking across all its children's ranges as they appear in + the address map, which is quadratic behavior. + + It would be nicer to record the parent's ranges before + traversing its children, simply overriding whatever you find + there. But since we don't even decide whether to create a + block until after we've traversed its children, that's hard + to do. */ + dwarf2_record_block_ranges (die, block, baseaddr, cu); } local_symbols = new->locals; + using_directives = new->using_directives; +} + +/* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET. + Return 1 if the attributes are present and valid, otherwise, return 0. + If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */ + +static int +dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return, + CORE_ADDR *high_return, struct dwarf2_cu *cu, + struct partial_symtab *ranges_pst) +{ + struct objfile *objfile = cu->objfile; + struct comp_unit_head *cu_header = &cu->header; + bfd *obfd = objfile->obfd; + unsigned int addr_size = cu_header->addr_size; + CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1)); + /* Base address selection entry. */ + CORE_ADDR base; + int found_base; + unsigned int dummy; + gdb_byte *buffer; + CORE_ADDR marker; + int low_set; + CORE_ADDR low = 0; + CORE_ADDR high = 0; + CORE_ADDR baseaddr; + + found_base = cu->base_known; + base = cu->base_address; + + if (offset >= dwarf2_per_objfile->ranges.size) + { + complaint (&symfile_complaints, + _("Offset %d out of bounds for DW_AT_ranges attribute"), + offset); + return 0; + } + buffer = dwarf2_per_objfile->ranges.buffer + offset; + + /* Read in the largest possible address. */ + marker = read_address (obfd, buffer, cu, &dummy); + if ((marker & mask) == mask) + { + /* If we found the largest possible address, then + read the base address. */ + base = read_address (obfd, buffer + addr_size, cu, &dummy); + buffer += 2 * addr_size; + offset += 2 * addr_size; + found_base = 1; + } + + low_set = 0; + + baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); + + while (1) + { + CORE_ADDR range_beginning, range_end; + + range_beginning = read_address (obfd, buffer, cu, &dummy); + buffer += addr_size; + range_end = read_address (obfd, buffer, cu, &dummy); + buffer += addr_size; + offset += 2 * addr_size; + + /* An end of list marker is a pair of zero addresses. */ + if (range_beginning == 0 && range_end == 0) + /* Found the end of list entry. */ + break; + + /* Each base address selection entry is a pair of 2 values. + The first is the largest possible address, the second is + the base address. Check for a base address here. */ + if ((range_beginning & mask) == mask) + { + /* If we found the largest possible address, then + read the base address. */ + base = read_address (obfd, buffer + addr_size, cu, &dummy); + found_base = 1; + continue; + } + + if (!found_base) + { + /* We have no valid base address for the ranges + data. */ + complaint (&symfile_complaints, + _("Invalid .debug_ranges data (no base address)")); + return 0; + } + + range_beginning += base; + range_end += base; + + if (ranges_pst != NULL && range_beginning < range_end) + addrmap_set_empty (objfile->psymtabs_addrmap, + range_beginning + baseaddr, range_end - 1 + baseaddr, + ranges_pst); + + /* FIXME: This is recording everything as a low-high + segment of consecutive addresses. We should have a + data structure for discontiguous block ranges + instead. */ + if (! low_set) + { + low = range_beginning; + high = range_end; + low_set = 1; + } + else + { + if (range_beginning < low) + low = range_beginning; + if (range_end > high) + high = range_end; + } + } + + if (! low_set) + /* If the first entry is an end-of-list marker, the range + describes an empty scope, i.e. no instructions. */ + return 0; + + if (low_return) + *low_return = low; + if (high_return) + *high_return = high; + return 1; } /* Get low and high pc attributes from a die. Return 1 if the attributes @@ -3084,10 +3688,7 @@ static int dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc, CORE_ADDR *highpc, struct dwarf2_cu *cu) { - struct objfile *objfile = cu->objfile; - struct comp_unit_head *cu_header = &cu->header; struct attribute *attr; - bfd *obfd = objfile->obfd; CORE_ADDR low = 0; CORE_ADDR high = 0; int ret = 0; @@ -3111,108 +3712,11 @@ dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc, attr = dwarf2_attr (die, DW_AT_ranges, cu); if (attr != NULL) { - unsigned int addr_size = cu_header->addr_size; - CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1)); /* Value of the DW_AT_ranges attribute is the offset in the .debug_ranges section. */ - unsigned int offset = DW_UNSND (attr); - /* Base address selection entry. */ - CORE_ADDR base; - int found_base; - unsigned int dummy; - gdb_byte *buffer; - CORE_ADDR marker; - int low_set; - - found_base = cu_header->base_known; - base = cu_header->base_address; - - if (offset >= dwarf2_per_objfile->ranges_size) - { - complaint (&symfile_complaints, - _("Offset %d out of bounds for DW_AT_ranges attribute"), - offset); - return 0; - } - buffer = dwarf2_per_objfile->ranges_buffer + offset; - - /* Read in the largest possible address. */ - marker = read_address (obfd, buffer, cu, &dummy); - if ((marker & mask) == mask) - { - /* If we found the largest possible address, then - read the base address. */ - base = read_address (obfd, buffer + addr_size, cu, &dummy); - buffer += 2 * addr_size; - offset += 2 * addr_size; - found_base = 1; - } - - low_set = 0; - - while (1) - { - CORE_ADDR range_beginning, range_end; - - range_beginning = read_address (obfd, buffer, cu, &dummy); - buffer += addr_size; - range_end = read_address (obfd, buffer, cu, &dummy); - buffer += addr_size; - offset += 2 * addr_size; - - /* An end of list marker is a pair of zero addresses. */ - if (range_beginning == 0 && range_end == 0) - /* Found the end of list entry. */ - break; - - /* Each base address selection entry is a pair of 2 values. - The first is the largest possible address, the second is - the base address. Check for a base address here. */ - if ((range_beginning & mask) == mask) - { - /* If we found the largest possible address, then - read the base address. */ - base = read_address (obfd, buffer + addr_size, cu, &dummy); - found_base = 1; - continue; - } - - if (!found_base) - { - /* We have no valid base address for the ranges - data. */ - complaint (&symfile_complaints, - _("Invalid .debug_ranges data (no base address)")); - return 0; - } - - range_beginning += base; - range_end += base; - - /* FIXME: This is recording everything as a low-high - segment of consecutive addresses. We should have a - data structure for discontiguous block ranges - instead. */ - if (! low_set) - { - low = range_beginning; - high = range_end; - low_set = 1; - } - else - { - if (range_beginning < low) - low = range_beginning; - if (range_end > high) - high = range_end; - } - } - - if (! low_set) - /* If the first entry is an end-of-list marker, the range - describes an empty scope, i.e. no instructions. */ + if (!dwarf2_ranges_read (DW_UNSND (attr), &low, &high, cu, NULL)) return 0; - + /* Found discontinuous range of addresses. */ ret = -1; } } @@ -3236,6 +3740,43 @@ dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc, return ret; } +/* Assuming that DIE represents a subprogram DIE or a lexical block, get + its low and high PC addresses. Do nothing if these addresses could not + be determined. Otherwise, set LOWPC to the low address if it is smaller, + and HIGHPC to the high address if greater than HIGHPC. */ + +static void +dwarf2_get_subprogram_pc_bounds (struct die_info *die, + CORE_ADDR *lowpc, CORE_ADDR *highpc, + struct dwarf2_cu *cu) +{ + CORE_ADDR low, high; + struct die_info *child = die->child; + + if (dwarf2_get_pc_bounds (die, &low, &high, cu)) + { + *lowpc = min (*lowpc, low); + *highpc = max (*highpc, high); + } + + /* If the language does not allow nested subprograms (either inside + subprograms or lexical blocks), we're done. */ + if (cu->language != language_ada) + return; + + /* Check all the children of the given DIE. If it contains nested + subprograms, then check their pc bounds. Likewise, we need to + check lexical blocks as well, as they may also contain subprogram + definitions. */ + while (child && child->tag) + { + if (child->tag == DW_TAG_subprogram + || child->tag == DW_TAG_lexical_block) + dwarf2_get_subprogram_pc_bounds (child, lowpc, highpc, cu); + child = sibling_die (child); + } +} + /* Get the low and high pc's represented by the scope DIE, and store them in *LOWPC and *HIGHPC. If the correct values can't be determined, set *LOWPC to -1 and *HIGHPC to 0. */ @@ -3262,11 +3803,7 @@ get_scope_pc_bounds (struct die_info *die, { switch (child->tag) { case DW_TAG_subprogram: - if (dwarf2_get_pc_bounds (child, ¤t_low, ¤t_high, cu)) - { - best_low = min (best_low, current_low); - best_high = max (best_high, current_high); - } + dwarf2_get_subprogram_pc_bounds (child, &best_low, &best_high, cu); break; case DW_TAG_namespace: /* FIXME: carlton/2004-01-16: Should we do this for @@ -3298,6 +3835,100 @@ get_scope_pc_bounds (struct die_info *die, *highpc = best_high; } +/* Record the address ranges for BLOCK, offset by BASEADDR, as given + in DIE. */ +static void +dwarf2_record_block_ranges (struct die_info *die, struct block *block, + CORE_ADDR baseaddr, struct dwarf2_cu *cu) +{ + struct attribute *attr; + + attr = dwarf2_attr (die, DW_AT_high_pc, cu); + if (attr) + { + CORE_ADDR high = DW_ADDR (attr); + attr = dwarf2_attr (die, DW_AT_low_pc, cu); + if (attr) + { + CORE_ADDR low = DW_ADDR (attr); + record_block_range (block, baseaddr + low, baseaddr + high - 1); + } + } + + attr = dwarf2_attr (die, DW_AT_ranges, cu); + if (attr) + { + bfd *obfd = cu->objfile->obfd; + + /* The value of the DW_AT_ranges attribute is the offset of the + address range list in the .debug_ranges section. */ + unsigned long offset = DW_UNSND (attr); + gdb_byte *buffer = dwarf2_per_objfile->ranges.buffer + offset; + + /* For some target architectures, but not others, the + read_address function sign-extends the addresses it returns. + To recognize base address selection entries, we need a + mask. */ + unsigned int addr_size = cu->header.addr_size; + CORE_ADDR base_select_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1)); + + /* The base address, to which the next pair is relative. Note + that this 'base' is a DWARF concept: most entries in a range + list are relative, to reduce the number of relocs against the + debugging information. This is separate from this function's + 'baseaddr' argument, which GDB uses to relocate debugging + information from a shared library based on the address at + which the library was loaded. */ + CORE_ADDR base = cu->base_address; + int base_known = cu->base_known; + + if (offset >= dwarf2_per_objfile->ranges.size) + { + complaint (&symfile_complaints, + _("Offset %lu out of bounds for DW_AT_ranges attribute"), + offset); + return; + } + + for (;;) + { + unsigned int bytes_read; + CORE_ADDR start, end; + + start = read_address (obfd, buffer, cu, &bytes_read); + buffer += bytes_read; + end = read_address (obfd, buffer, cu, &bytes_read); + buffer += bytes_read; + + /* Did we find the end of the range list? */ + if (start == 0 && end == 0) + break; + + /* Did we find a base address selection entry? */ + else if ((start & base_select_mask) == base_select_mask) + { + base = end; + base_known = 1; + } + + /* We found an ordinary address range. */ + else + { + if (!base_known) + { + complaint (&symfile_complaints, + _("Invalid .debug_ranges data (no base address)")); + return; + } + + record_block_range (block, + baseaddr + base + start, + baseaddr + base + end - 1); + } + } + } +} + /* Add an aggregate field to the field list. */ static void @@ -3305,6 +3936,7 @@ dwarf2_add_field (struct field_info *fip, struct die_info *die, struct dwarf2_cu *cu) { struct objfile *objfile = cu->objfile; + struct gdbarch *gdbarch = get_objfile_arch (objfile); struct nextfield *new_field; struct attribute *attr; struct field *fp; @@ -3345,7 +3977,7 @@ dwarf2_add_field (struct field_info *fip, struct die_info *die, /* Get type of field. */ fp->type = die_type (die, cu); - FIELD_STATIC_KIND (*fp) = 0; + SET_FIELD_BITPOS (*fp, 0); /* Get bit size of field (zero if none). */ attr = dwarf2_attr (die, DW_AT_bit_size, cu); @@ -3362,15 +3994,24 @@ dwarf2_add_field (struct field_info *fip, struct die_info *die, attr = dwarf2_attr (die, DW_AT_data_member_location, cu); if (attr) { - FIELD_BITPOS (*fp) = - decode_locdesc (DW_BLOCK (attr), cu) * bits_per_byte; + int byte_offset; + + if (attr_form_is_section_offset (attr)) + { + dwarf2_complex_location_expr_complaint (); + byte_offset = 0; + } + else if (attr_form_is_constant (attr)) + byte_offset = dwarf2_get_attr_constant_value (attr, 0); + else + byte_offset = decode_locdesc (DW_BLOCK (attr), cu); + + SET_FIELD_BITPOS (*fp, byte_offset * bits_per_byte); } - else - FIELD_BITPOS (*fp) = 0; attr = dwarf2_attr (die, DW_AT_bit_offset, cu); if (attr) { - if (BITS_BIG_ENDIAN) + if (gdbarch_bits_big_endian (gdbarch)) { /* For big endian bits, the DW_AT_bit_offset gives the additional bit offset from the MSB of the containing @@ -3458,10 +4099,9 @@ dwarf2_add_field (struct field_info *fip, struct die_info *die, /* C++ base class field. */ attr = dwarf2_attr (die, DW_AT_data_member_location, cu); if (attr) - FIELD_BITPOS (*fp) = (decode_locdesc (DW_BLOCK (attr), cu) - * bits_per_byte); + SET_FIELD_BITPOS (*fp, decode_locdesc (DW_BLOCK (attr), cu) + * bits_per_byte); FIELD_BITSIZE (*fp) = 0; - FIELD_STATIC_KIND (*fp) = 0; FIELD_TYPE (*fp) = die_type (die, cu); FIELD_NAME (*fp) = type_name_no_tag (fp->type); fip->nbaseclasses++; @@ -3569,6 +4209,7 @@ dwarf2_add_member_fn (struct field_info *fip, struct die_info *die, char *fieldname; char *physname; struct nextfnfield *new_fnfield; + struct type *this_type; /* Get name of member function. */ fieldname = dwarf2_name (die, cu); @@ -3621,17 +4262,18 @@ dwarf2_add_member_fn (struct field_info *fip, struct die_info *die, need to duplicate it for the type. */ fnp->physname = physname ? physname : ""; fnp->type = alloc_type (objfile); - if (die->type && TYPE_CODE (die->type) == TYPE_CODE_FUNC) + this_type = read_type_die (die, cu); + if (this_type && TYPE_CODE (this_type) == TYPE_CODE_FUNC) { - int nparams = TYPE_NFIELDS (die->type); + int nparams = TYPE_NFIELDS (this_type); - /* TYPE is the domain of this method, and DIE->TYPE is the type + /* TYPE is the domain of this method, and THIS_TYPE is the type of the method itself (TYPE_CODE_METHOD). */ smash_to_method_type (fnp->type, type, - TYPE_TARGET_TYPE (die->type), - TYPE_FIELDS (die->type), - TYPE_NFIELDS (die->type), - TYPE_VARARGS (die->type)); + TYPE_TARGET_TYPE (this_type), + TYPE_FIELDS (this_type), + TYPE_NFIELDS (this_type), + TYPE_VARARGS (this_type)); /* Handle static member functions. Dwarf2 has no clean way to discern C++ static and non-static @@ -3639,7 +4281,7 @@ dwarf2_add_member_fn (struct field_info *fip, struct die_info *die, 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) + if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (this_type, 0) == 0) fnp->voffset = VOFFSET_STATIC; } else @@ -3682,7 +4324,7 @@ dwarf2_add_member_fn (struct field_info *fip, struct die_info *die, { fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2; } - else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8) + else if (attr_form_is_section_offset (attr)) { dwarf2_complex_location_expr_complaint (); } @@ -3754,7 +4396,7 @@ is_vtable_name (const char *name, struct dwarf2_cu *cu) GCC shouldn't do this; it should just output pointer to member DIEs. This is GCC PR debug/28767. */ -static int +static struct type * quirk_gcc_member_function_pointer (struct die_info *die, struct dwarf2_cu *cu) { struct objfile *objfile = cu->objfile; @@ -3770,7 +4412,7 @@ quirk_gcc_member_function_pointer (struct die_info *die, struct dwarf2_cu *cu) || die->child->sibling == NULL || (die->child->sibling->sibling != NULL && die->child->sibling->sibling->tag != DW_TAG_padding)) - return 0; + return NULL; /* Check for __pfn and __delta members. */ pfn_die = die->child; @@ -3779,7 +4421,7 @@ quirk_gcc_member_function_pointer (struct die_info *die, struct dwarf2_cu *cu) || pfn_name == NULL || DW_STRING (pfn_name) == NULL || strcmp ("__pfn", DW_STRING (pfn_name)) != 0) - return 0; + return NULL; delta_die = pfn_die->sibling; delta_name = dwarf2_attr (delta_die, DW_AT_name, cu); @@ -3787,30 +4429,28 @@ quirk_gcc_member_function_pointer (struct die_info *die, struct dwarf2_cu *cu) || delta_name == NULL || DW_STRING (delta_name) == NULL || strcmp ("__delta", DW_STRING (delta_name)) != 0) - return 0; + return NULL; /* Find the type of the method. */ pfn_type = die_type (pfn_die, cu); if (pfn_type == NULL || TYPE_CODE (pfn_type) != TYPE_CODE_PTR || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC) - return 0; + return NULL; /* Look for the "this" argument. */ pfn_type = TYPE_TARGET_TYPE (pfn_type); if (TYPE_NFIELDS (pfn_type) == 0 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR) - return 0; + return NULL; domain_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0)); type = alloc_type (objfile); smash_to_method_type (type, domain_type, TYPE_TARGET_TYPE (pfn_type), TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type), - TYPE_VARARGS (pfn_type)); - type = lookup_methodptr_type (type); - set_die_type (die, type, cu); - - return 1; + TYPE_VARARGS (pfn_type)); + type = lookup_methodptr_type (type); + return set_die_type (die, type, cu); } /* Called when we find the DIE that starts a structure or union scope @@ -3829,21 +4469,18 @@ quirk_gcc_member_function_pointer (struct die_info *die, struct dwarf2_cu *cu) checking about whether the struct/union is anonymous or not (and suppresses creating a symbol table entry itself). */ -static void +static struct type * read_structure_type (struct die_info *die, struct dwarf2_cu *cu) { struct objfile *objfile = cu->objfile; struct type *type; struct attribute *attr; - const char *previous_prefix = processing_current_prefix; - struct cleanup *back_to = NULL; char *name; + struct cleanup *back_to = make_cleanup (null_cleanup, 0); - if (die->type) - return; - - if (quirk_gcc_member_function_pointer (die, cu)) - return; + type = quirk_gcc_member_function_pointer (die, cu); + if (type) + return type; type = alloc_type (objfile); INIT_CPLUS_SPECIFIC (type); @@ -3853,12 +4490,8 @@ read_structure_type (struct die_info *die, struct dwarf2_cu *cu) if (cu->language == language_cplus || cu->language == language_java) { - char *new_prefix = determine_class_name (die, cu); - TYPE_TAG_NAME (type) = obsavestring (new_prefix, - strlen (new_prefix), - &objfile->objfile_obstack); - back_to = make_cleanup (xfree, new_prefix); - processing_current_prefix = new_prefix; + const char *new_prefix = determine_class_name (die, cu); + TYPE_TAG_NAME (type) = (char *) new_prefix; } else { @@ -3893,9 +4526,9 @@ read_structure_type (struct die_info *die, struct dwarf2_cu *cu) TYPE_LENGTH (type) = 0; } - TYPE_FLAGS (type) |= TYPE_FLAG_STUB_SUPPORTED; + TYPE_STUB_SUPPORTED (type) = 1; if (die_is_declaration (die, cu)) - TYPE_FLAGS (type) |= TYPE_FLAG_STUB; + TYPE_STUB (type) = 1; /* We need to add the type field to the die immediately so we don't infinitely recurse when dealing with pointers to the structure @@ -3906,7 +4539,6 @@ read_structure_type (struct die_info *die, struct dwarf2_cu *cu) { 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)); @@ -3927,7 +4559,6 @@ read_structure_type (struct die_info *die, struct dwarf2_cu *cu) else if (child_die->tag == DW_TAG_subprogram) { /* C++ member function. */ - read_type_die (child_die, cu); dwarf2_add_member_fn (&fi, child_die, type, cu); } else if (child_die->tag == DW_TAG_inheritance) @@ -4007,24 +4638,22 @@ read_structure_type (struct die_info *die, struct dwarf2_cu *cu) } } } - - do_cleanups (back_to); } - processing_current_prefix = previous_prefix; - if (back_to != NULL) - do_cleanups (back_to); + do_cleanups (back_to); + return type; } static void process_structure_scope (struct die_info *die, struct dwarf2_cu *cu) { struct objfile *objfile = cu->objfile; - const char *previous_prefix = processing_current_prefix; struct die_info *child_die = die->child; + struct type *this_type; - if (TYPE_TAG_NAME (die->type) != NULL) - processing_current_prefix = TYPE_TAG_NAME (die->type); + this_type = get_die_type (die, cu); + if (this_type == NULL) + this_type = read_structure_type (die, cu); /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its snapshots) has been known to create a die giving a declaration @@ -4052,44 +4681,26 @@ process_structure_scope (struct die_info *die, struct dwarf2_cu *cu) attribute, and a declaration attribute. */ if (dwarf2_attr (die, DW_AT_byte_size, cu) != NULL || !die_is_declaration (die, cu)) - new_symbol (die, die->type, cu); - - processing_current_prefix = previous_prefix; + new_symbol (die, this_type, cu); } /* Given a DW_AT_enumeration_type die, set its type. We do not complete the type's fields yet, or create any symbols. */ -static void +static struct type * read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu) { struct objfile *objfile = cu->objfile; struct type *type; struct attribute *attr; - char *name; - - if (die->type) - return; + const char *name; type = alloc_type (objfile); TYPE_CODE (type) = TYPE_CODE_ENUM; - name = dwarf2_name (die, cu); + name = dwarf2_full_name (die, cu); if (name != NULL) - { - if (processing_has_namespace_info) - { - TYPE_TAG_NAME (type) = typename_concat (&objfile->objfile_obstack, - processing_current_prefix, - name, cu); - } - else - { - /* The name is already allocated along with this objfile, so - we don't need to duplicate it for the type. */ - TYPE_TAG_NAME (type) = name; - } - } + TYPE_TAG_NAME (type) = (char *) name; attr = dwarf2_attr (die, DW_AT_byte_size, cu); if (attr) @@ -4101,29 +4712,25 @@ read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu) TYPE_LENGTH (type) = 0; } - set_die_type (die, type, cu); + /* The enumeration DIE can be incomplete. In Ada, any type can be + declared as private in the package spec, and then defined only + inside the package body. Such types are known as Taft Amendment + Types. When another package uses such a type, an incomplete DIE + may be generated by the compiler. */ + if (die_is_declaration (die, cu)) + TYPE_STUB (type) = 1; + + return set_die_type (die, type, cu); } /* Determine the name of the type represented by DIE, which should be - a named C++ or Java compound type. Return the name in question; the caller - is responsible for xfree()'ing it. */ + a named C++ or Java compound type. Return the name in question, + allocated on the objfile obstack. */ -static char * +static const char * determine_class_name (struct die_info *die, struct dwarf2_cu *cu) { - struct cleanup *back_to = NULL; - struct die_info *spec_die = die_specification (die, cu); - char *new_prefix = NULL; - - /* If this is the definition of a class that is declared by another - die, then processing_current_prefix may not be accurate; see - read_func_scope for a similar example. */ - if (spec_die != NULL) - { - char *specification_prefix = determine_prefix (spec_die, cu); - processing_current_prefix = specification_prefix; - back_to = make_cleanup (xfree, specification_prefix); - } + const char *new_prefix = NULL; /* If we don't have namespace debug info, guess the name by trying to demangle the names of members, just like we did in @@ -4138,27 +4745,25 @@ determine_class_name (struct die_info *die, struct dwarf2_cu *cu) { if (child->tag == DW_TAG_subprogram) { - new_prefix + char *phys_prefix = language_class_name_from_physname (cu->language_defn, dwarf2_linkage_name (child, cu)); - if (new_prefix != NULL) - break; + if (phys_prefix != NULL) + { + new_prefix + = obsavestring (phys_prefix, strlen (phys_prefix), + &cu->objfile->objfile_obstack); + xfree (phys_prefix); + break; + } } } } if (new_prefix == NULL) - { - const char *name = dwarf2_name (die, cu); - new_prefix = typename_concat (NULL, processing_current_prefix, - name ? name : "<>", - cu); - } - - if (back_to != NULL) - do_cleanups (back_to); + new_prefix = dwarf2_full_name (die, cu); return new_prefix; } @@ -4179,9 +4784,13 @@ process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu) int num_fields; int unsigned_enum = 1; char *name; + struct type *this_type; num_fields = 0; fields = NULL; + this_type = get_die_type (die, cu); + if (this_type == NULL) + this_type = read_enumeration_type (die, cu); if (die->child != NULL) { child_die = die->child; @@ -4196,7 +4805,7 @@ process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu) name = dwarf2_name (child_die, cu); if (name) { - sym = new_symbol (child_die, die->type, cu); + sym = new_symbol (child_die, this_type, cu); if (SYMBOL_VALUE (sym) < 0) unsigned_enum = 0; @@ -4208,11 +4817,10 @@ process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu) * sizeof (struct field)); } - FIELD_NAME (fields[num_fields]) = DEPRECATED_SYMBOL_NAME (sym); + FIELD_NAME (fields[num_fields]) = SYMBOL_LINKAGE_NAME (sym); FIELD_TYPE (fields[num_fields]) = NULL; - FIELD_BITPOS (fields[num_fields]) = SYMBOL_VALUE (sym); + SET_FIELD_BITPOS (fields[num_fields], SYMBOL_VALUE (sym)); FIELD_BITSIZE (fields[num_fields]) = 0; - FIELD_STATIC_KIND (fields[num_fields]) = 0; num_fields++; } @@ -4223,25 +4831,25 @@ process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu) if (num_fields) { - TYPE_NFIELDS (die->type) = num_fields; - TYPE_FIELDS (die->type) = (struct field *) - TYPE_ALLOC (die->type, sizeof (struct field) * num_fields); - memcpy (TYPE_FIELDS (die->type), fields, + TYPE_NFIELDS (this_type) = num_fields; + TYPE_FIELDS (this_type) = (struct field *) + TYPE_ALLOC (this_type, sizeof (struct field) * num_fields); + memcpy (TYPE_FIELDS (this_type), fields, sizeof (struct field) * num_fields); xfree (fields); } if (unsigned_enum) - TYPE_FLAGS (die->type) |= TYPE_FLAG_UNSIGNED; + TYPE_UNSIGNED (this_type) = 1; } - new_symbol (die, die->type, cu); + new_symbol (die, this_type, cu); } /* 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 +static struct type * read_array_type (struct die_info *die, struct dwarf2_cu *cu) { struct objfile *objfile = cu->objfile; @@ -4254,23 +4862,16 @@ read_array_type (struct die_info *die, struct dwarf2_cu *cu) struct cleanup *back_to; char *name; - /* Return if we've already decoded this type. */ - if (die->type) - { - return; - } - element_type = die_type (die, cu); /* Irix 6.2 native cc creates array types without children for arrays with unspecified length. */ if (die->child == NULL) { - index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu); + index_type = objfile_type (objfile)->builtin_int; range_type = create_range_type (NULL, index_type, 0, -1); - set_die_type (die, create_array_type (NULL, element_type, range_type), - cu); - return; + type = create_array_type (NULL, element_type, range_type); + return set_die_type (die, type, cu); } back_to = make_cleanup (null_cleanup, NULL); @@ -4279,9 +4880,8 @@ read_array_type (struct die_info *die, struct dwarf2_cu *cu) { if (child_die->tag == DW_TAG_subrange_type) { - read_subrange_type (child_die, cu); - - if (child_die->type != NULL) + struct type *child_type = read_type_die (child_die, cu); + if (child_type != NULL) { /* The range type was succesfully read. Save it for the array type creation. */ @@ -4293,7 +4893,7 @@ read_array_type (struct die_info *die, struct dwarf2_cu *cu) if (ndim == 0) make_cleanup (free_current_contents, &range_types); } - range_types[ndim++] = child_die->type; + range_types[ndim++] = child_type; } } child_die = sibling_die (child_die); @@ -4333,7 +4933,7 @@ read_array_type (struct die_info *die, struct dwarf2_cu *cu) do_cleanups (back_to); /* Install the type in the die. */ - set_die_type (die, type, cu); + return set_die_type (die, type, cu); } static enum dwarf_array_dim_ordering @@ -4373,11 +4973,12 @@ read_array_order (struct die_info *die, struct dwarf2_cu *cu) /* Extract all information from a DW_TAG_set_type DIE and put it in the DIE's type field. */ -static void +static struct type * read_set_type (struct die_info *die, struct dwarf2_cu *cu) { - if (die->type == NULL) - die->type = create_set_type ((struct type *) NULL, die_type (die, cu)); + struct type *set_type = create_set_type (NULL, die_type (die, cu)); + + return set_die_type (die, set_type, cu); } /* First cut: install each common block member as a global variable. */ @@ -4398,7 +4999,7 @@ read_common_block (struct die_info *die, struct dwarf2_cu *cu) { base = decode_locdesc (DW_BLOCK (attr), cu); } - else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8) + else if (attr_form_is_section_offset (attr)) { dwarf2_complex_location_expr_complaint (); } @@ -4426,55 +5027,72 @@ read_common_block (struct die_info *die, struct dwarf2_cu *cu) } } -/* Read a C++ namespace. */ +/* Create a type for a C++ namespace. */ -static void -read_namespace (struct die_info *die, struct dwarf2_cu *cu) +static struct type * +read_namespace_type (struct die_info *die, struct dwarf2_cu *cu) { struct objfile *objfile = cu->objfile; - const char *previous_prefix = processing_current_prefix; - const char *name; + const char *previous_prefix, *name; int is_anonymous; - struct die_info *current_die; - struct cleanup *back_to = make_cleanup (null_cleanup, 0); + struct type *type; + + /* For extensions, reuse the type of the original namespace. */ + if (dwarf2_attr (die, DW_AT_extension, cu) != NULL) + { + struct die_info *ext_die; + struct dwarf2_cu *ext_cu = cu; + ext_die = dwarf2_extension (die, &ext_cu); + type = read_type_die (ext_die, ext_cu); + return set_die_type (die, type, cu); + } name = namespace_name (die, &is_anonymous, cu); /* Now build the name of the current namespace. */ - if (previous_prefix[0] == '\0') - { - processing_current_prefix = name; - } - else - { - char *temp_name = typename_concat (NULL, previous_prefix, name, cu); - make_cleanup (xfree, temp_name); - processing_current_prefix = temp_name; - } + previous_prefix = determine_prefix (die, cu); + if (previous_prefix[0] != '\0') + name = typename_concat (&objfile->objfile_obstack, + previous_prefix, name, cu); + + /* Create the type. */ + type = init_type (TYPE_CODE_NAMESPACE, 0, 0, NULL, + objfile); + TYPE_NAME (type) = (char *) name; + TYPE_TAG_NAME (type) = TYPE_NAME (type); + + set_die_type (die, type, cu); + + return type; +} + +/* Read a C++ namespace. */ + +static void +read_namespace (struct die_info *die, struct dwarf2_cu *cu) +{ + struct objfile *objfile = cu->objfile; + const char *name; + int is_anonymous; /* Add a symbol associated to this if we haven't seen the namespace before. Also, add a using directive if it's an anonymous namespace. */ - if (dwarf2_extension (die, cu) == NULL) + if (dwarf2_attr (die, DW_AT_extension, cu) == NULL) { struct type *type; - /* FIXME: carlton/2003-06-27: Once GDB is more const-correct, - this cast will hopefully become unnecessary. */ - type = init_type (TYPE_CODE_NAMESPACE, 0, 0, - (char *) processing_current_prefix, - objfile); - TYPE_TAG_NAME (type) = TYPE_NAME (type); - + type = read_type_die (die, cu); new_symbol (die, type, cu); - set_die_type (die, type, cu); + name = namespace_name (die, &is_anonymous, cu); if (is_anonymous) - cp_add_using_directive (processing_current_prefix, - strlen (previous_prefix), - strlen (processing_current_prefix)); + { + const char *previous_prefix = determine_prefix (die, cu); + cp_add_using_directive (previous_prefix, TYPE_NAME (type)); + } } if (die->child != NULL) @@ -4487,9 +5105,22 @@ read_namespace (struct die_info *die, struct dwarf2_cu *cu) child_die = sibling_die (child_die); } } +} - processing_current_prefix = previous_prefix; - do_cleanups (back_to); +/* Read a Fortran module. */ + +static void +read_module (struct die_info *die, struct dwarf2_cu *cu) +{ + struct die_info *child_die = die->child; + + /* FIXME: Support the separate Fortran module namespaces. */ + + while (child_die && child_die->tag) + { + process_die (child_die, cu); + child_die = sibling_die (child_die); + } } /* Return the name of the namespace represented by DIE. Set @@ -4506,7 +5137,7 @@ namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu) for (current_die = die; current_die != NULL; - current_die = dwarf2_extension (die, cu)) + current_die = dwarf2_extension (die, &cu)) { name = dwarf2_name (current_die, cu); if (name != NULL) @@ -4525,20 +5156,16 @@ namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu) /* Extract all information from a DW_TAG_pointer_type DIE and add to the user defined type vector. */ -static void +static struct type * read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu) { + struct gdbarch *gdbarch = get_objfile_arch (cu->objfile); struct comp_unit_head *cu_header = &cu->header; struct type *type; struct attribute *attr_byte_size; struct attribute *attr_address_class; int byte_size, addr_class; - if (die->type) - { - return; - } - type = lookup_pointer_type (die_type (die, cu)); attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu); @@ -4558,13 +5185,14 @@ read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu) length accordingly. */ if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none) { - if (gdbarch_address_class_type_flags_p (current_gdbarch)) + if (gdbarch_address_class_type_flags_p (gdbarch)) { int type_flags; type_flags = gdbarch_address_class_type_flags - (current_gdbarch, byte_size, addr_class); - gdb_assert ((type_flags & ~TYPE_FLAG_ADDRESS_CLASS_ALL) == 0); + (gdbarch, byte_size, addr_class); + gdb_assert ((type_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL) + == 0); type = make_type_with_address_space (type, type_flags); } else if (TYPE_LENGTH (type) != byte_size) @@ -4577,13 +5205,13 @@ read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu) } TYPE_LENGTH (type) = byte_size; - set_die_type (die, type, cu); + return set_die_type (die, type, cu); } /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to the user defined type vector. */ -static void +static struct type * read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu) { struct objfile *objfile = cu->objfile; @@ -4591,11 +5219,6 @@ read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu) struct type *to_type; struct type *domain; - if (die->type) - { - return; - } - to_type = die_type (die, cu); domain = die_containing_type (die, cu); @@ -4604,24 +5227,19 @@ read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu) else type = lookup_memberptr_type (to_type, domain); - set_die_type (die, type, cu); + return set_die_type (die, type, cu); } /* Extract all information from a DW_TAG_reference_type DIE and add to the user defined type vector. */ -static void +static struct type * read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu) { struct comp_unit_head *cu_header = &cu->header; struct type *type; struct attribute *attr; - if (die->type) - { - return; - } - type = lookup_reference_type (die_type (die, cu)); attr = dwarf2_attr (die, DW_AT_byte_size, cu); if (attr) @@ -4632,37 +5250,27 @@ read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu) { TYPE_LENGTH (type) = cu_header->addr_size; } - set_die_type (die, type, cu); + return set_die_type (die, type, cu); } -static void +static struct type * read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu) { - struct type *base_type; - - if (die->type) - { - return; - } + struct type *base_type, *cv_type; base_type = die_type (die, cu); - set_die_type (die, make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0), - cu); + cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0); + return set_die_type (die, cv_type, cu); } -static void +static struct type * read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu) { - struct type *base_type; - - if (die->type) - { - return; - } + struct type *base_type, *cv_type; base_type = die_type (die, cu); - set_die_type (die, make_cv_type (TYPE_CONST (base_type), 1, base_type, 0), - cu); + cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0); + return set_die_type (die, cv_type, cu); } /* Extract all information from a DW_TAG_string_type DIE and add to @@ -4670,19 +5278,15 @@ read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu) but it behaves like one, with other DIE's using an AT_user_def_type attribute to reference it. */ -static void +static struct type * read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu) { struct objfile *objfile = cu->objfile; + struct gdbarch *gdbarch = get_objfile_arch (objfile); struct type *type, *range_type, *index_type, *char_type; struct attribute *attr; unsigned int length; - if (die->type) - { - return; - } - attr = dwarf2_attr (die, DW_AT_string_length, cu); if (attr) { @@ -4701,20 +5305,13 @@ read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu) length = 1; } } - index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu); + + index_type = objfile_type (objfile)->builtin_int; range_type = create_range_type (NULL, index_type, 1, length); - if (cu->language == language_fortran) - { - /* Need to create a unique string type for bounds - information */ - type = create_string_type (0, range_type); - } - else - { - char_type = dwarf2_fundamental_type (objfile, FT_CHAR, cu); - type = create_string_type (char_type, range_type); - } - set_die_type (die, type, cu); + char_type = language_string_char_type (cu->language_defn, gdbarch); + type = create_string_type (NULL, char_type, range_type); + + return set_die_type (die, type, cu); } /* Handle DIES due to C code like: @@ -4728,20 +5325,15 @@ read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu) ('funcp' generates a DW_TAG_subroutine_type DIE) */ -static void +static struct type * read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu) { 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, cu); - ftype = make_function_type (type, (struct type **) 0); + ftype = lookup_function_type (type); /* All functions in C++, Pascal and Java have prototypes. */ attr = dwarf2_attr (die, DW_AT_prototyped, cu); @@ -4749,8 +5341,14 @@ read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu) || cu->language == language_cplus || cu->language == language_java || cu->language == language_pascal) - TYPE_FLAGS (ftype) |= TYPE_FLAG_PROTOTYPED; + TYPE_PROTOTYPED (ftype) = 1; + /* Store the calling convention in the type if it's available in + the subroutine die. Otherwise set the calling convention to + the default value DW_CC_normal. */ + attr = dwarf2_attr (die, DW_AT_calling_convention, cu); + TYPE_CALLING_CONVENTION (ftype) = attr ? DW_UNSND (attr) : DW_CC_normal; + if (die->child != NULL) { struct die_info *child_die; @@ -4766,7 +5364,7 @@ read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu) if (child_die->tag == DW_TAG_formal_parameter) nparams++; else if (child_die->tag == DW_TAG_unspecified_parameters) - TYPE_FLAGS (ftype) |= TYPE_FLAG_VARARGS; + TYPE_VARARGS (ftype) = 1; child_die = sibling_die (child_die); } @@ -4797,30 +5395,30 @@ read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu) } } - set_die_type (die, ftype, cu); + return set_die_type (die, ftype, cu); } -static void +static struct type * read_typedef (struct die_info *die, struct dwarf2_cu *cu) { struct objfile *objfile = cu->objfile; struct attribute *attr; - char *name = NULL; + const char *name = NULL; + struct type *this_type; - if (!die->type) - { - name = dwarf2_name (die, cu); - set_die_type (die, init_type (TYPE_CODE_TYPEDEF, 0, - TYPE_FLAG_TARGET_STUB, name, objfile), - cu); - TYPE_TARGET_TYPE (die->type) = die_type (die, cu); - } + name = dwarf2_full_name (die, cu); + this_type = init_type (TYPE_CODE_TYPEDEF, 0, + TYPE_FLAG_TARGET_STUB, NULL, objfile); + TYPE_NAME (this_type) = (char *) name; + set_die_type (die, this_type, cu); + TYPE_TARGET_TYPE (this_type) = die_type (die, cu); + return this_type; } /* Find a representation of a given base type and install it in the TYPE field of the die. */ -static void +static struct type * read_base_type (struct die_info *die, struct dwarf2_cu *cu) { struct objfile *objfile = cu->objfile; @@ -4828,12 +5426,9 @@ read_base_type (struct die_info *die, struct dwarf2_cu *cu) struct attribute *attr; int encoding = 0, size = 0; char *name; - - /* If we've already decoded this die, this is a no-op. */ - if (die->type) - { - return; - } + enum type_code code = TYPE_CODE_INT; + int type_flags = 0; + struct type *target_type = NULL; attr = dwarf2_attr (die, DW_AT_encoding, cu); if (attr) @@ -4846,79 +5441,72 @@ read_base_type (struct die_info *die, struct dwarf2_cu *cu) size = DW_UNSND (attr); } name = dwarf2_name (die, cu); - if (name) + if (!name) { - enum type_code code = TYPE_CODE_INT; - int type_flags = 0; - - switch (encoding) - { - case DW_ATE_address: - /* Turn DW_ATE_address into a void * pointer. */ - code = TYPE_CODE_PTR; - type_flags |= TYPE_FLAG_UNSIGNED; - break; - case DW_ATE_boolean: - code = TYPE_CODE_BOOL; - type_flags |= TYPE_FLAG_UNSIGNED; - break; - case DW_ATE_complex_float: - code = TYPE_CODE_COMPLEX; - break; - case DW_ATE_decimal_float: - code = TYPE_CODE_DECFLOAT; - break; - case DW_ATE_float: - code = TYPE_CODE_FLT; - break; - case DW_ATE_signed: - break; - case DW_ATE_unsigned: - type_flags |= TYPE_FLAG_UNSIGNED; - break; - case DW_ATE_signed_char: - if (cu->language == language_m2) - code = TYPE_CODE_CHAR; - break; - case DW_ATE_unsigned_char: - if (cu->language == language_m2) - code = TYPE_CODE_CHAR; - type_flags |= TYPE_FLAG_UNSIGNED; - break; - default: - complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"), - dwarf_type_encoding_name (encoding)); - break; - } - type = init_type (code, size, type_flags, name, objfile); - if (encoding == DW_ATE_address) - TYPE_TARGET_TYPE (type) = dwarf2_fundamental_type (objfile, FT_VOID, - cu); - else if (encoding == DW_ATE_complex_float) - { - if (size == 32) - TYPE_TARGET_TYPE (type) - = dwarf2_fundamental_type (objfile, FT_EXT_PREC_FLOAT, cu); - else if (size == 16) - TYPE_TARGET_TYPE (type) - = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu); - else if (size == 8) - TYPE_TARGET_TYPE (type) - = dwarf2_fundamental_type (objfile, FT_FLOAT, cu); - } + complaint (&symfile_complaints, + _("DW_AT_name missing from DW_TAG_base_type")); } - else + + switch (encoding) { - type = dwarf_base_type (encoding, size, cu); + case DW_ATE_address: + /* Turn DW_ATE_address into a void * pointer. */ + code = TYPE_CODE_PTR; + type_flags |= TYPE_FLAG_UNSIGNED; + target_type = init_type (TYPE_CODE_VOID, 1, 0, NULL, objfile); + break; + case DW_ATE_boolean: + code = TYPE_CODE_BOOL; + type_flags |= TYPE_FLAG_UNSIGNED; + break; + case DW_ATE_complex_float: + code = TYPE_CODE_COMPLEX; + target_type = init_type (TYPE_CODE_FLT, size / 2, 0, NULL, objfile); + break; + case DW_ATE_decimal_float: + code = TYPE_CODE_DECFLOAT; + break; + case DW_ATE_float: + code = TYPE_CODE_FLT; + break; + case DW_ATE_signed: + break; + case DW_ATE_unsigned: + type_flags |= TYPE_FLAG_UNSIGNED; + break; + case DW_ATE_signed_char: + if (cu->language == language_ada || cu->language == language_m2 + || cu->language == language_pascal) + code = TYPE_CODE_CHAR; + break; + case DW_ATE_unsigned_char: + if (cu->language == language_ada || cu->language == language_m2 + || cu->language == language_pascal) + code = TYPE_CODE_CHAR; + type_flags |= TYPE_FLAG_UNSIGNED; + break; + default: + complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"), + dwarf_type_encoding_name (encoding)); + break; } - set_die_type (die, type, cu); + + type = init_type (code, size, type_flags, NULL, objfile); + TYPE_NAME (type) = name; + TYPE_TARGET_TYPE (type) = target_type; + + if (name && strcmp (name, "char") == 0) + TYPE_NOSIGN (type) = 1; + + return set_die_type (die, type, cu); } /* Read the given DW_AT_subrange DIE. */ -static void +static struct type * read_subrange_type (struct die_info *die, struct dwarf2_cu *cu) { + struct gdbarch *gdbarch = get_objfile_arch (cu->objfile); struct type *base_type; struct type *range_type; struct attribute *attr; @@ -4926,18 +5514,14 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu) int high = -1; char *name; - /* If we have already decoded this die, then nothing more to do. */ - if (die->type) - return; - base_type = die_type (die, cu); if (TYPE_CODE (base_type) == TYPE_CODE_VOID) { complaint (&symfile_complaints, _("DW_AT_type missing from DW_TAG_subrange_type")); base_type - = dwarf_base_type (DW_ATE_signed, - gdbarch_addr_bit (current_gdbarch) / 8, cu); + = init_type (TYPE_CODE_INT, gdbarch_addr_bit (gdbarch) / 8, + 0, NULL, cu->objfile); } if (cu->language == language_fortran) @@ -4985,23 +5569,41 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu) if (attr) TYPE_LENGTH (range_type) = DW_UNSND (attr); - set_die_type (die, range_type, cu); + return set_die_type (die, range_type, cu); } -static void +static struct type * read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu) { struct type *type; - if (die->type) - return; - /* For now, we only support the C meaning of an unspecified type: void. */ - type = init_type (TYPE_CODE_VOID, 0, 0, dwarf2_name (die, cu), - cu->objfile); + type = init_type (TYPE_CODE_VOID, 0, 0, NULL, cu->objfile); + TYPE_NAME (type) = dwarf2_name (die, cu); - set_die_type (die, type, cu); + return set_die_type (die, type, cu); +} + +/* Trivial hash function for die_info: the hash value of a DIE + is its offset in .debug_info for this objfile. */ + +static hashval_t +die_hash (const void *item) +{ + const struct die_info *die = item; + return die->offset; +} + +/* Trivial comparison function for die_info structures: two DIEs + are equal if they have the same offset. */ + +static int +die_eq (const void *item_lhs, const void *item_rhs) +{ + const struct die_info *die_lhs = item_lhs; + const struct die_info *die_rhs = item_rhs; + return die_lhs->offset == die_rhs->offset; } /* Read a whole compilation unit into a linked list of dies. */ @@ -5009,9 +5611,39 @@ read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu) static struct die_info * read_comp_unit (gdb_byte *info_ptr, bfd *abfd, struct dwarf2_cu *cu) { + cu->die_hash + = htab_create_alloc_ex (cu->header.length / 12, + die_hash, + die_eq, + NULL, + &cu->comp_unit_obstack, + hashtab_obstack_allocate, + dummy_obstack_deallocate); + return read_die_and_children (info_ptr, abfd, cu, &info_ptr, NULL); } +/* Main entry point for reading a DIE and all children. + Read the DIE and dump it if requested. */ + +static struct die_info * +read_die_and_children (gdb_byte *info_ptr, bfd *abfd, + struct dwarf2_cu *cu, + gdb_byte **new_info_ptr, + struct die_info *parent) +{ + struct die_info *result = read_die_and_children_1 (info_ptr, abfd, cu, + new_info_ptr, parent); + + if (dwarf2_die_debug) + { + fprintf_unfiltered (gdb_stdlog, "Read die from .debug_info:\n"); + dump_die (result, dwarf2_die_debug); + } + + return result; +} + /* Read a single die and all its descendents. Set the die's sibling field to NULL; set other fields in the die correctly, and set all of the descendents' fields correctly. Set *NEW_INFO_PTR to the @@ -5019,17 +5651,22 @@ read_comp_unit (gdb_byte *info_ptr, bfd *abfd, struct dwarf2_cu *cu) is the parent of the die in question. */ static struct die_info * -read_die_and_children (gdb_byte *info_ptr, bfd *abfd, - struct dwarf2_cu *cu, - gdb_byte **new_info_ptr, - struct die_info *parent) +read_die_and_children_1 (gdb_byte *info_ptr, bfd *abfd, + struct dwarf2_cu *cu, + gdb_byte **new_info_ptr, + struct die_info *parent) { struct die_info *die; gdb_byte *cur_ptr; int has_children; cur_ptr = read_full_die (&die, abfd, info_ptr, cu, &has_children); - store_in_ref_table (die->offset, die, cu); + if (die == NULL) + { + *new_info_ptr = cur_ptr; + return NULL; + } + store_in_ref_table (die, cu); if (has_children) { @@ -5066,74 +5703,23 @@ read_die_and_siblings (gdb_byte *info_ptr, bfd *abfd, while (1) { struct die_info *die - = read_die_and_children (cur_ptr, abfd, cu, &cur_ptr, parent); + = read_die_and_children_1 (cur_ptr, abfd, cu, &cur_ptr, parent); - if (!first_die) - { - first_die = die; - } - else - { - last_sibling->sibling = die; - } - - if (die->tag == 0) + if (die == NULL) { *new_info_ptr = cur_ptr; return first_die; } - else - { - last_sibling = die; - } - } -} -/* Free a linked list of dies. */ - -static void -free_die_list (struct die_info *dies) -{ - struct die_info *die, *next; + if (!first_die) + first_die = die; + else + last_sibling->sibling = die; - die = dies; - while (die) - { - if (die->child != NULL) - free_die_list (die->child); - next = die->sibling; - xfree (die->attrs); - xfree (die); - die = next; + last_sibling = die; } } -/* Read the contents of the section at OFFSET and of size SIZE from the - object file specified by OBJFILE into the objfile_obstack and return it. */ - -gdb_byte * -dwarf2_read_section (struct objfile *objfile, asection *sectp) -{ - bfd *abfd = objfile->obfd; - gdb_byte *buf, *retbuf; - bfd_size_type size = bfd_get_section_size (sectp); - - if (size == 0) - return NULL; - - buf = obstack_alloc (&objfile->objfile_obstack, size); - retbuf = symfile_relocate_debug_section (abfd, sectp, buf); - if (retbuf != NULL) - return retbuf; - - if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0 - || bfd_bread (buf, size, abfd) != size) - 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 @@ -5159,7 +5745,7 @@ dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu) memset (cu->dwarf2_abbrevs, 0, ABBREV_HASH_SIZE * sizeof (struct abbrev_info *)); - abbrev_ptr = dwarf2_per_objfile->abbrev_buffer + cu_header->abbrev_offset; + abbrev_ptr = dwarf2_per_objfile->abbrev.buffer + cu_header->abbrev_offset; abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); abbrev_ptr += bytes_read; @@ -5231,8 +5817,8 @@ dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu) 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 - dwarf2_per_objfile->abbrev_buffer) - >= dwarf2_per_objfile->abbrev_size) + if ((unsigned int) (abbrev_ptr - dwarf2_per_objfile->abbrev.buffer) + >= dwarf2_per_objfile->abbrev.size) break; abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); abbrev_ptr += bytes_read; @@ -5295,6 +5881,7 @@ is_type_tag_for_partial (int tag) #endif case DW_TAG_base_type: case DW_TAG_class_type: + case DW_TAG_interface_type: case DW_TAG_enumeration_type: case DW_TAG_structure_type: case DW_TAG_subrange_type: @@ -5369,6 +5956,7 @@ load_partial_dies (bfd *abfd, gdb_byte *info_ptr, int building_psymtab, && !is_type_tag_for_partial (abbrev->tag) && abbrev->tag != DW_TAG_enumerator && abbrev->tag != DW_TAG_subprogram + && abbrev->tag != DW_TAG_lexical_block && abbrev->tag != DW_TAG_variable && abbrev->tag != DW_TAG_namespace && abbrev->tag != DW_TAG_member) @@ -5491,17 +6079,26 @@ load_partial_dies (bfd *abfd, gdb_byte *info_ptr, int building_psymtab, sizeof (struct partial_die_info)); /* For some DIEs we want to follow their children (if any). For C - we have no reason to follow the children of structures; for other + we have no reason to follow the children of structures; for other languages we have to, both so that we can get at method physnames - to infer fully qualified class names, and for DW_AT_specification. */ + to infer fully qualified class names, and for DW_AT_specification. + + For Ada, we need to scan the children of subprograms and lexical + blocks as well because Ada allows the definition of nested + entities that could be interesting for the debugger, such as + nested subprograms for instance. */ if (last_die->has_children && (load_all || last_die->tag == DW_TAG_namespace || last_die->tag == DW_TAG_enumeration_type || (cu->language != language_c && (last_die->tag == DW_TAG_class_type + || last_die->tag == DW_TAG_interface_type || last_die->tag == DW_TAG_structure_type - || last_die->tag == DW_TAG_union_type)))) + || last_die->tag == DW_TAG_union_type)) + || (cu->language == language_ada + && (last_die->tag == DW_TAG_subprogram + || last_die->tag == DW_TAG_lexical_block)))) { nesting_level++; parent_die = last_die; @@ -5527,10 +6124,19 @@ read_partial_die (struct partial_die_info *part_die, struct attribute attr; int has_low_pc_attr = 0; int has_high_pc_attr = 0; + CORE_ADDR base_address = 0; + enum + { + base_address_none, + base_address_low_pc, + /* Overrides BASE_ADDRESS_LOW_PC. */ + base_address_entry_pc + } + base_address_type = base_address_none; memset (part_die, 0, sizeof (struct partial_die_info)); - part_die->offset = info_ptr - dwarf2_per_objfile->info_buffer; + part_die->offset = info_ptr - dwarf2_per_objfile->info.buffer; info_ptr += abbrev_len; @@ -5549,10 +6155,23 @@ read_partial_die (struct partial_die_info *part_die, 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); + switch (part_die->tag) + { + case DW_TAG_compile_unit: + /* Compilation units have a DW_AT_name that is a filename, not + a source language identifier. */ + case DW_TAG_enumeration_type: + case DW_TAG_enumerator: + /* These tags always have simple identifiers already; no need + to canonicalize them. */ + part_die->name = DW_STRING (&attr); + break; + default: + part_die->name + = dwarf2_canonicalize_name (DW_STRING (&attr), cu, + &cu->comp_unit_obstack); + break; + } break; case DW_AT_comp_dir: if (part_die->dirname == NULL) @@ -5564,18 +6183,39 @@ read_partial_die (struct partial_die_info *part_die, case DW_AT_low_pc: has_low_pc_attr = 1; part_die->lowpc = DW_ADDR (&attr); + if (part_die->tag == DW_TAG_compile_unit + && base_address_type < base_address_low_pc) + { + base_address = DW_ADDR (&attr); + base_address_type = base_address_low_pc; + } break; case DW_AT_high_pc: has_high_pc_attr = 1; part_die->highpc = DW_ADDR (&attr); break; + case DW_AT_entry_pc: + if (part_die->tag == DW_TAG_compile_unit + && base_address_type < base_address_entry_pc) + { + base_address = DW_ADDR (&attr); + base_address_type = base_address_entry_pc; + } + break; + case DW_AT_ranges: + if (part_die->tag == DW_TAG_compile_unit) + { + cu->ranges_offset = DW_UNSND (&attr); + cu->has_ranges_offset = 1; + } + break; case DW_AT_location: /* Support the .debug_loc offsets */ if (attr_form_is_block (&attr)) { part_die->locdesc = DW_BLOCK (&attr); } - else if (attr.form == DW_FORM_data4 || attr.form == DW_FORM_data8) + else if (attr_form_is_section_offset (&attr)) { dwarf2_complex_location_expr_complaint (); } @@ -5601,7 +6241,7 @@ read_partial_die (struct partial_die_info *part_die, case DW_AT_specification: case DW_AT_extension: part_die->has_specification = 1; - part_die->spec_offset = dwarf2_get_ref_die_offset (&attr, cu); + part_die->spec_offset = dwarf2_get_ref_die_offset (&attr); break; case DW_AT_sibling: /* Ignore absolute siblings, they might point outside of @@ -5609,8 +6249,8 @@ read_partial_die (struct partial_die_info *part_die, if (attr.form == DW_FORM_ref_addr) complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling")); else - part_die->sibling = dwarf2_per_objfile->info_buffer - + dwarf2_get_ref_die_offset (&attr, cu); + part_die->sibling = dwarf2_per_objfile->info.buffer + + dwarf2_get_ref_die_offset (&attr); break; case DW_AT_stmt_list: part_die->has_stmt_list = 1; @@ -5619,6 +6259,25 @@ read_partial_die (struct partial_die_info *part_die, case DW_AT_byte_size: part_die->has_byte_size = 1; break; + case DW_AT_calling_convention: + /* DWARF doesn't provide a way to identify a program's source-level + entry point. DW_AT_calling_convention attributes are only meant + to describe functions' calling conventions. + + However, because it's a necessary piece of information in + Fortran, and because DW_CC_program is the only piece of debugging + information whose definition refers to a 'main program' at all, + several compilers have begun marking Fortran main programs with + DW_CC_program --- even when those functions use the standard + calling conventions. + + So until DWARF specifies a way to provide this information and + compilers pick up the new representation, we'll support this + practice. */ + if (DW_UNSND (&attr) == DW_CC_program + && cu->language == language_fortran) + set_main_name (part_die->name); + break; default: break; } @@ -5637,13 +6296,21 @@ read_partial_die (struct partial_die_info *part_die, && (part_die->lowpc != 0 || dwarf2_per_objfile->has_section_at_zero)) part_die->has_pc_info = 1; + + if (base_address_type != base_address_none && !cu->base_known) + { + gdb_assert (part_die->tag == DW_TAG_compile_unit); + cu->base_known = 1; + cu->base_address = base_address; + } + return info_ptr; } /* Find a cached partial DIE at OFFSET in CU. */ static struct partial_die_info * -find_partial_die_in_comp_unit (unsigned long offset, struct dwarf2_cu *cu) +find_partial_die_in_comp_unit (unsigned int offset, struct dwarf2_cu *cu) { struct partial_die_info *lookup_die = NULL; struct partial_die_info part_die; @@ -5657,13 +6324,12 @@ find_partial_die_in_comp_unit (unsigned long offset, struct dwarf2_cu *cu) /* Find a partial DIE at OFFSET, which may or may not be in CU. */ static struct partial_die_info * -find_partial_die (unsigned long offset, struct dwarf2_cu *cu) +find_partial_die (unsigned int offset, struct dwarf2_cu *cu) { struct dwarf2_per_cu_data *per_cu = NULL; struct partial_die_info *pd = NULL; - if (offset >= cu->header.offset - && offset < cu->header.offset + cu->header.length) + if (offset_in_cu_p (&cu->header, offset)) { pd = find_partial_die_in_comp_unit (offset, cu); if (pd != NULL) @@ -5699,7 +6365,9 @@ find_partial_die (unsigned long offset, struct dwarf2_cu *cu) dwarf2_read_abbrevs (per_cu->cu->objfile->obfd, per_cu->cu); back_to = make_cleanup (dwarf2_free_abbrev_table, per_cu->cu); } - info_ptr = per_cu->cu->header.first_die_ptr; + info_ptr = (dwarf2_per_objfile->info.buffer + + per_cu->cu->header.offset + + per_cu->cu->header.first_die_offset); abbrev = peek_die_abbrev (info_ptr, &bytes_read, per_cu->cu); info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read, per_cu->cu->objfile->obfd, info_ptr, @@ -5713,7 +6381,7 @@ find_partial_die (unsigned long offset, struct dwarf2_cu *cu) if (pd == NULL) internal_error (__FILE__, __LINE__, - _("could not find partial DIE 0x%lx in cache [from module %s]\n"), + _("could not find partial DIE 0x%x in cache [from module %s]\n"), offset, bfd_get_filename (cu->objfile->obfd)); return pd; } @@ -5773,16 +6441,12 @@ read_full_die (struct die_info **diep, bfd *abfd, gdb_byte *info_ptr, struct abbrev_info *abbrev; struct die_info *die; - offset = info_ptr - dwarf2_per_objfile->info_buffer; + offset = info_ptr - dwarf2_per_objfile->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; + *diep = NULL; *has_children = 0; return info_ptr; } @@ -5794,53 +6458,16 @@ read_full_die (struct die_info **diep, bfd *abfd, gdb_byte *info_ptr, abbrev_number, bfd_get_filename (abfd)); } - die = dwarf_alloc_die (); + die = dwarf_alloc_die (cu, abbrev->num_attrs); die->offset = offset; die->tag = abbrev->tag; 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); - - /* If this attribute is an absolute reference to a different - compilation unit, make sure that compilation unit is loaded - also. */ - if (die->attrs[i].form == DW_FORM_ref_addr - && (DW_ADDR (&die->attrs[i]) < cu->header.offset - || (DW_ADDR (&die->attrs[i]) - >= cu->header.offset + cu->header.length))) - { - struct dwarf2_per_cu_data *per_cu; - per_cu = dwarf2_find_containing_comp_unit (DW_ADDR (&die->attrs[i]), - cu->objfile); - - /* Mark the dependence relation so that we don't flush PER_CU - too early. */ - dwarf2_add_dependence (cu, per_cu); - - /* If it's already on the queue, we have nothing to do. */ - if (per_cu->queued) - continue; - - /* If the compilation unit is already loaded, just mark it as - used. */ - if (per_cu->cu != NULL) - { - per_cu->cu->last_used = 0; - continue; - } - - /* Add it to the queue. */ - queue_comp_unit (per_cu); - } - } + info_ptr = read_attribute (&die->attrs[i], &abbrev->attrs[i], + abfd, info_ptr, cu); *diep = die; *has_children = abbrev->has_children; @@ -5966,6 +6593,24 @@ read_attribute_value (struct attribute *attr, unsigned form, dwarf_form_name (form), bfd_get_filename (abfd)); } + + /* We have seen instances where the compiler tried to emit a byte + size attribute of -1 which ended up being encoded as an unsigned + 0xffffffff. Although 0xffffffff is technically a valid size value, + an object of this size seems pretty unlikely so we can relatively + safely treat these cases as if the size attribute was invalid and + treat them as zero by default. */ + if (attr->name == DW_AT_byte_size + && form == DW_FORM_data4 + && DW_UNSND (attr) >= 0xffffffff) + { + complaint + (&symfile_complaints, + _("Suspicious DW_AT_byte_size value treated as zero instead of 0x%lx"), + DW_UNSND (attr)); + DW_UNSND (attr) = 0; + } + return info_ptr; } @@ -6094,12 +6739,7 @@ read_address (bfd *abfd, gdb_byte *buf, struct dwarf2_cu *cu, The value returned via bytes_read should be used to increment the relevant pointer after calling read_initial_length(). - - As a side effect, this function sets the fields initial_length_size - and offset_size in cu_header to the values appropriate for the - length field. (The format of the initial length field determines - the width of file offsets to be fetched later with read_offset().) - + [ Note: read_initial_length() and read_offset() are based on the document entitled "DWARF Debugging Information Format", revision 3, draft 8, dated November 19, 2001. This document was obtained @@ -6117,8 +6757,7 @@ read_address (bfd *abfd, gdb_byte *buf, struct dwarf2_cu *cu, ] */ static LONGEST -read_initial_length (bfd *abfd, gdb_byte *buf, struct comp_unit_head *cu_header, - unsigned int *bytes_read) +read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read) { LONGEST length = bfd_get_32 (abfd, buf); @@ -6138,22 +6777,34 @@ read_initial_length (bfd *abfd, gdb_byte *buf, struct comp_unit_head *cu_header, *bytes_read = 4; } - if (cu_header) - { - gdb_assert (cu_header->initial_length_size == 0 - || cu_header->initial_length_size == 4 - || cu_header->initial_length_size == 8 - || cu_header->initial_length_size == 12); + return length; +} - if (cu_header->initial_length_size != 0 - && cu_header->initial_length_size != *bytes_read) - complaint (&symfile_complaints, - _("intermixed 32-bit and 64-bit DWARF sections")); +/* Cover function for read_initial_length. + Returns the length of the object at BUF, and stores the size of the + initial length in *BYTES_READ and stores the size that offsets will be in + *OFFSET_SIZE. + If the initial length size is not equivalent to that specified in + CU_HEADER then issue a complaint. + This is useful when reading non-comp-unit headers. */ - cu_header->initial_length_size = *bytes_read; - cu_header->offset_size = (*bytes_read == 4) ? 4 : 8; - } +static LONGEST +read_checked_initial_length_and_offset (bfd *abfd, gdb_byte *buf, + const struct comp_unit_head *cu_header, + unsigned int *bytes_read, + unsigned int *offset_size) +{ + LONGEST length = read_initial_length (abfd, buf, bytes_read); + + gdb_assert (cu_header->initial_length_size == 4 + || cu_header->initial_length_size == 8 + || cu_header->initial_length_size == 12); + if (cu_header->initial_length_size != *bytes_read) + complaint (&symfile_complaints, + _("intermixed 32-bit and 64-bit DWARF sections")); + + *offset_size = (*bytes_read == 4) ? 4 : 8; return length; } @@ -6163,22 +6814,30 @@ read_initial_length (bfd *abfd, gdb_byte *buf, struct comp_unit_head *cu_header, static LONGEST read_offset (bfd *abfd, gdb_byte *buf, const struct comp_unit_head *cu_header, unsigned int *bytes_read) +{ + LONGEST offset = read_offset_1 (abfd, buf, cu_header->offset_size); + *bytes_read = cu_header->offset_size; + return offset; +} + +/* Read an offset from the data stream. */ + +static LONGEST +read_offset_1 (bfd *abfd, gdb_byte *buf, unsigned int offset_size) { LONGEST retval = 0; - switch (cu_header->offset_size) + switch (offset_size) { case 4: retval = bfd_get_32 (abfd, buf); - *bytes_read = 4; break; case 8: retval = bfd_get_64 (abfd, buf); - *bytes_read = 8; break; default: internal_error (__FILE__, __LINE__, - _("read_offset: bad switch [in module %s]"), + _("read_offset_1: bad switch [in module %s]"), bfd_get_filename (abfd)); } @@ -6216,25 +6875,24 @@ read_indirect_string (bfd *abfd, gdb_byte *buf, const struct comp_unit_head *cu_header, unsigned int *bytes_read_ptr) { - LONGEST str_offset = read_offset (abfd, buf, cu_header, - bytes_read_ptr); + LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr); - if (dwarf2_per_objfile->str_buffer == NULL) + if (dwarf2_per_objfile->str.buffer == NULL) { error (_("DW_FORM_strp used without .debug_str section [in module %s]"), bfd_get_filename (abfd)); return NULL; } - if (str_offset >= dwarf2_per_objfile->str_size) + if (str_offset >= dwarf2_per_objfile->str.size) { error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"), bfd_get_filename (abfd)); return NULL; } gdb_assert (HOST_CHAR_BIT == 8); - if (dwarf2_per_objfile->str_buffer[str_offset] == '\0') + if (dwarf2_per_objfile->str.buffer[str_offset] == '\0') return NULL; - return (char *) (dwarf2_per_objfile->str_buffer + str_offset); + return (char *) (dwarf2_per_objfile->str.buffer + str_offset); } static unsigned long @@ -6316,6 +6974,7 @@ set_cu_language (unsigned int lang, struct dwarf2_cu *cu) switch (lang) { case DW_LANG_C89: + case DW_LANG_C99: case DW_LANG_C: cu->language = language_c; break; @@ -6343,6 +7002,9 @@ set_cu_language (unsigned int lang, struct dwarf2_cu *cu) case DW_LANG_Pascal83: cu->language = language_pascal; break; + case DW_LANG_ObjC: + cu->language = language_objc; + break; case DW_LANG_Cobol74: case DW_LANG_Cobol85: default: @@ -6370,7 +7032,10 @@ dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu) } if (spec) - return dwarf2_attr (follow_die_ref (die, spec, cu), name, cu); + { + die = follow_die_ref (die, spec, &cu); + return dwarf2_attr (die, name, cu); + } return NULL; } @@ -6402,17 +7067,24 @@ die_is_declaration (struct die_info *die, struct dwarf2_cu *cu) } /* Return the die giving the specification for DIE, if there is - one. */ + one. *SPEC_CU is the CU containing DIE on input, and the CU + containing the return value on output. If there is no + specification, but there is an abstract origin, that is + returned. */ static struct die_info * -die_specification (struct die_info *die, struct dwarf2_cu *cu) +die_specification (struct die_info *die, struct dwarf2_cu **spec_cu) { - struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification, cu); + struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification, + *spec_cu); + + if (spec_attr == NULL) + spec_attr = dwarf2_attr (die, DW_AT_abstract_origin, *spec_cu); if (spec_attr == NULL) return NULL; else - return follow_die_ref (die, spec_attr, cu); + return follow_die_ref (die, spec_attr, spec_cu); } /* Free the line_header structure *LH, and any arrays and strings it @@ -6508,11 +7180,11 @@ dwarf_decode_line_header (unsigned int offset, bfd *abfd, struct cleanup *back_to; struct line_header *lh; gdb_byte *line_ptr; - unsigned int bytes_read; + unsigned int bytes_read, offset_size; int i; char *cur_dir, *cur_file; - if (dwarf2_per_objfile->line_buffer == NULL) + if (dwarf2_per_objfile->line.buffer == NULL) { complaint (&symfile_complaints, _("missing .debug_line section")); return 0; @@ -6520,7 +7192,7 @@ dwarf_decode_line_header (unsigned int offset, bfd *abfd, /* Make sure that at least there's room for the total_length field. That could be 12 bytes long, but we're just going to fudge that. */ - if (offset + 4 >= dwarf2_per_objfile->line_size) + if (offset + 4 >= dwarf2_per_objfile->line.size) { dwarf2_statement_list_fits_in_line_number_section_complaint (); return 0; @@ -6531,14 +7203,15 @@ dwarf_decode_line_header (unsigned int offset, bfd *abfd, back_to = make_cleanup ((make_cleanup_ftype *) free_line_header, (void *) lh); - line_ptr = dwarf2_per_objfile->line_buffer + offset; + line_ptr = dwarf2_per_objfile->line.buffer + offset; /* Read in the header. */ lh->total_length = - read_initial_length (abfd, line_ptr, &cu->header, &bytes_read); + read_checked_initial_length_and_offset (abfd, line_ptr, &cu->header, + &bytes_read, &offset_size); line_ptr += bytes_read; - if (line_ptr + lh->total_length > (dwarf2_per_objfile->line_buffer - + dwarf2_per_objfile->line_size)) + if (line_ptr + lh->total_length > (dwarf2_per_objfile->line.buffer + + dwarf2_per_objfile->line.size)) { dwarf2_statement_list_fits_in_line_number_section_complaint (); return 0; @@ -6546,8 +7219,8 @@ dwarf_decode_line_header (unsigned int offset, bfd *abfd, lh->statement_program_end = line_ptr + lh->total_length; lh->version = read_2_bytes (abfd, line_ptr); line_ptr += 2; - lh->header_length = read_offset (abfd, line_ptr, &cu->header, &bytes_read); - line_ptr += bytes_read; + lh->header_length = read_offset_1 (abfd, line_ptr, offset_size); + line_ptr += offset_size; lh->minimum_instruction_length = read_1_byte (abfd, line_ptr); line_ptr += 1; lh->default_is_stmt = read_1_byte (abfd, line_ptr); @@ -6594,8 +7267,8 @@ dwarf_decode_line_header (unsigned int offset, bfd *abfd, line_ptr += bytes_read; lh->statement_program_start = line_ptr; - if (line_ptr > (dwarf2_per_objfile->line_buffer - + dwarf2_per_objfile->line_size)) + if (line_ptr > (dwarf2_per_objfile->line.buffer + + dwarf2_per_objfile->line.size)) complaint (&symfile_complaints, _("line number info header doesn't fit in `.debug_line' section")); @@ -6677,6 +7350,7 @@ dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd, unsigned char op_code, extended_op, adj_opcode; CORE_ADDR baseaddr; struct objfile *objfile = cu->objfile; + struct gdbarch *gdbarch = get_objfile_arch (objfile); const int decode_for_pst_p = (pst != NULL); struct subfile *last_subfile = NULL, *first_subfile = current_subfile; @@ -6696,6 +7370,7 @@ dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd, int is_stmt = lh->default_is_stmt; int basic_block = 0; int end_sequence = 0; + CORE_ADDR addr; if (!decode_for_pst_p && lh->num_file_names >= file) { @@ -6717,6 +7392,11 @@ dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd, { op_code = read_1_byte (abfd, line_ptr); line_ptr += 1; + if (line_ptr > line_end) + { + dwarf2_debug_line_missing_end_sequence_complaint (); + break; + } if (op_code >= lh->opcode_base) { @@ -6725,25 +7405,27 @@ dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd, address += (adj_opcode / lh->line_range) * lh->minimum_instruction_length; line += lh->line_base + (adj_opcode % lh->line_range); - if (lh->num_file_names < file) + if (lh->num_file_names < file || file == 0) dwarf2_debug_line_missing_file_complaint (); else { lh->file_names[file - 1].included_p = 1; - if (!decode_for_pst_p) - { - if (last_subfile != current_subfile) - { - if (last_subfile) - record_line (last_subfile, 0, address); - last_subfile = current_subfile; - } + if (!decode_for_pst_p && is_stmt) + { + if (last_subfile != current_subfile) + { + addr = gdbarch_addr_bits_remove (gdbarch, address); + if (last_subfile) + record_line (last_subfile, 0, addr); + last_subfile = current_subfile; + } /* Append row to matrix using current values. */ - record_line (current_subfile, line, - check_cu_functions (address, cu)); + addr = check_cu_functions (address, cu); + addr = gdbarch_addr_bits_remove (gdbarch, addr); + record_line (current_subfile, line, addr); } } - basic_block = 1; + basic_block = 0; } else switch (op_code) { @@ -6757,15 +7439,6 @@ dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd, { case DW_LNE_end_sequence: end_sequence = 1; - - if (lh->num_file_names < file) - dwarf2_debug_line_missing_file_complaint (); - else - { - lh->file_names[file - 1].included_p = 1; - if (!decode_for_pst_p) - record_line (current_subfile, 0, address); - } break; case DW_LNE_set_address: address = read_address (abfd, line_ptr, cu, &bytes_read); @@ -6791,6 +7464,11 @@ dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd, add_file_name (lh, cur_file, dir_index, mod_time, length); } break; + case DW_LNE_set_discriminator: + /* The discriminator is not interesting to the debugger; + just ignore it. */ + line_ptr = extended_end; + break; default: complaint (&symfile_complaints, _("mangled .debug_line section")); @@ -6807,22 +7485,24 @@ dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd, } break; case DW_LNS_copy: - if (lh->num_file_names < file) + if (lh->num_file_names < file || file == 0) dwarf2_debug_line_missing_file_complaint (); else { lh->file_names[file - 1].included_p = 1; - if (!decode_for_pst_p) - { - if (last_subfile != current_subfile) - { - if (last_subfile) - record_line (last_subfile, 0, address); - last_subfile = current_subfile; - } - record_line (current_subfile, line, - check_cu_functions (address, cu)); - } + if (!decode_for_pst_p && is_stmt) + { + if (last_subfile != current_subfile) + { + addr = gdbarch_addr_bits_remove (gdbarch, address); + if (last_subfile) + record_line (last_subfile, 0, addr); + last_subfile = current_subfile; + } + addr = check_cu_functions (address, cu); + addr = gdbarch_addr_bits_remove (gdbarch, addr); + record_line (current_subfile, line, addr); + } } basic_block = 0; break; @@ -6845,7 +7525,7 @@ dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd, file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read); line_ptr += bytes_read; - if (lh->num_file_names < file) + if (lh->num_file_names < file || file == 0) dwarf2_debug_line_missing_file_complaint (); else { @@ -6896,6 +7576,17 @@ dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd, } } } + if (lh->num_file_names < file || file == 0) + dwarf2_debug_line_missing_file_complaint (); + else + { + lh->file_names[file - 1].included_p = 1; + if (!decode_for_pst_p) + { + addr = gdbarch_addr_bits_remove (gdbarch, address); + record_line (current_subfile, 0, addr); + } + } } if (decode_for_pst_p) @@ -7052,10 +7743,10 @@ var_decode_location (struct attribute *attr, struct symbol *sym, SYMBOL_VALUE_ADDRESS (sym) = read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy); + SYMBOL_CLASS (sym) = LOC_STATIC; fixup_symbol_section (sym, objfile); SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets, SYMBOL_SECTION (sym)); - SYMBOL_CLASS (sym) = LOC_STATIC; return; } @@ -7085,6 +7776,7 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu) struct attribute *attr = NULL; struct attribute *attr2 = NULL; CORE_ADDR baseaddr; + int inlined_func = (die->tag == DW_TAG_inlined_subroutine); baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); @@ -7112,13 +7804,17 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu) SYMBOL_TYPE (sym) = type; else SYMBOL_TYPE (sym) = die_type (die, cu); - attr = dwarf2_attr (die, DW_AT_decl_line, cu); + attr = dwarf2_attr (die, + inlined_func ? DW_AT_call_line : DW_AT_decl_line, + cu); if (attr) { SYMBOL_LINE (sym) = DW_UNSND (attr); } - attr = dwarf2_attr (die, DW_AT_decl_file, cu); + attr = dwarf2_attr (die, + inlined_func ? DW_AT_call_file : DW_AT_decl_file, + cu); if (attr) { int file_index = DW_UNSND (attr); @@ -7149,8 +7845,15 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu) finish_block. */ SYMBOL_CLASS (sym) = LOC_BLOCK; attr2 = dwarf2_attr (die, DW_AT_external, cu); - if (attr2 && (DW_UNSND (attr2) != 0)) + if ((attr2 && (DW_UNSND (attr2) != 0)) + || cu->language == language_ada) { + /* Subprograms marked external are stored as a global symbol. + Ada subprograms, whether marked external or not, are always + stored as a global symbol, because we want to be able to + access them globally. For instance, we want to be able + to break on a nested subprogram without having to + specify the context. */ add_symbol_to_list (sym, &global_symbols); } else @@ -7158,13 +7861,21 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu) add_symbol_to_list (sym, cu->list_in_scope); } break; + case DW_TAG_inlined_subroutine: + /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by + finish_block. */ + SYMBOL_CLASS (sym) = LOC_BLOCK; + SYMBOL_INLINED (sym) = 1; + /* Do not add the symbol to any lists. It will be found via + BLOCK_FUNCTION from the blockvector. */ + 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) - = builtin_type (current_gdbarch)->nodebug_data_symbol; + = objfile_type (objfile)->nodebug_data_symbol; attr = dwarf2_attr (die, DW_AT_const_value, cu); if (attr) @@ -7200,18 +7911,29 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu) && dwarf2_attr (die, DW_AT_type, cu) != NULL) { SYMBOL_CLASS (sym) = LOC_UNRESOLVED; - add_symbol_to_list (sym, &global_symbols); + add_symbol_to_list (sym, cu->list_in_scope); + } + else if (!die_is_declaration (die, cu)) + { + /* Use the default LOC_OPTIMIZED_OUT class. */ + gdb_assert (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT); + add_symbol_to_list (sym, cu->list_in_scope); } } break; case DW_TAG_formal_parameter: + /* If we are inside a function, mark this as an argument. If + not, we might be looking at an argument to an inlined function + when we do not have enough information to show inlined frames; + pretend it's a local variable in that case so that the user can + still see it. */ + if (context_stack_depth > 0 + && context_stack[context_stack_depth - 1].name != NULL) + SYMBOL_IS_ARGUMENT (sym) = 1; attr = dwarf2_attr (die, DW_AT_location, cu); if (attr) { var_decode_location (attr, sym, cu); - /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */ - if (SYMBOL_CLASS (sym) == LOC_COMPUTED) - SYMBOL_CLASS (sym) = LOC_COMPUTED_ARG; } attr = dwarf2_attr (die, DW_AT_const_value, cu); if (attr) @@ -7226,6 +7948,7 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu) (FIXME?) */ break; case DW_TAG_class_type: + case DW_TAG_interface_type: case DW_TAG_structure_type: case DW_TAG_union_type: case DW_TAG_set_type: @@ -7275,34 +7998,21 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu) /* The semantics of C++ state that "struct foo { ... }" also defines a typedef for "foo". A Java class declaration also - defines a typedef for the class. Synthesize a typedef symbol - so that "ptype foo" works as expected. */ + defines a typedef for the class. */ if (cu->language == language_cplus || cu->language == language_java || cu->language == language_ada) { - struct symbol *typedef_sym = (struct symbol *) - obstack_alloc (&objfile->objfile_obstack, - sizeof (struct symbol)); - *typedef_sym = *sym; - SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN; /* The symbol's name is already allocated along with this objfile, so we don't need to duplicate it for the type. */ if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0) TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym); - add_symbol_to_list (typedef_sym, list_to_add); } } break; case DW_TAG_typedef: - if (processing_has_namespace_info - && processing_current_prefix[0] != '\0') - { - SYMBOL_LINKAGE_NAME (sym) = typename_concat (&objfile->objfile_obstack, - processing_current_prefix, - name, cu); - } + SYMBOL_LINKAGE_NAME (sym) = (char *) dwarf2_full_name (die, cu); SYMBOL_CLASS (sym) = LOC_TYPEDEF; SYMBOL_DOMAIN (sym) = VAR_DOMAIN; add_symbol_to_list (sym, cu->list_in_scope); @@ -7314,13 +8024,7 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu) add_symbol_to_list (sym, cu->list_in_scope); break; case DW_TAG_enumerator: - if (processing_has_namespace_info - && processing_current_prefix[0] != '\0') - { - SYMBOL_LINKAGE_NAME (sym) = typename_concat (&objfile->objfile_obstack, - processing_current_prefix, - name, cu); - } + SYMBOL_LINKAGE_NAME (sym) = (char *) dwarf2_full_name (die, cu); attr = dwarf2_attr (die, DW_AT_const_value, cu); if (attr) { @@ -7353,6 +8057,13 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu) dwarf_tag_name (die->tag)); break; } + + /* For the benefit of old versions of GCC, check for anonymous + namespaces based on the demangled name. */ + if (!processing_has_namespace_info + && cu->language == language_cplus + && dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu) != NULL) + cp_scan_for_anonymous_namespaces (sym); } return (sym); } @@ -7365,13 +8076,15 @@ dwarf2_const_value (struct attribute *attr, struct symbol *sym, { struct objfile *objfile = cu->objfile; struct comp_unit_head *cu_header = &cu->header; + enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ? + BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE; struct dwarf_block *blk; switch (attr->form) { case DW_FORM_addr: if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != cu_header->addr_size) - dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym), + dwarf2_const_value_length_mismatch_complaint (SYMBOL_PRINT_NAME (sym), cu_header->addr_size, TYPE_LENGTH (SYMBOL_TYPE (sym))); @@ -7380,7 +8093,14 @@ dwarf2_const_value (struct attribute *attr, struct symbol *sym, /* NOTE: cagney/2003-05-09: In-lined store_address call with it's body - store_unsigned_integer. */ store_unsigned_integer (SYMBOL_VALUE_BYTES (sym), cu_header->addr_size, - DW_ADDR (attr)); + DW_ADDR (attr), byte_order); + SYMBOL_CLASS (sym) = LOC_CONST_BYTES; + break; + case DW_FORM_string: + case DW_FORM_strp: + /* DW_STRING is already allocated on the obstack, point directly + to it. */ + SYMBOL_VALUE_BYTES (sym) = (gdb_byte *) DW_STRING (attr); SYMBOL_CLASS (sym) = LOC_CONST_BYTES; break; case DW_FORM_block1: @@ -7389,7 +8109,7 @@ dwarf2_const_value (struct attribute *attr, struct symbol *sym, case DW_FORM_block: blk = DW_BLOCK (attr); if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != blk->size) - dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym), + dwarf2_const_value_length_mismatch_complaint (SYMBOL_PRINT_NAME (sym), blk->size, TYPE_LENGTH (SYMBOL_TYPE (sym))); @@ -7473,15 +8193,15 @@ die_type (struct die_info *die, struct dwarf2_cu *cu) if (!type_attr) { /* A missing DW_AT_type represents a void type. */ - return dwarf2_fundamental_type (cu->objfile, FT_VOID, cu); + return objfile_type (cu->objfile)->builtin_void; } else - type_die = follow_die_ref (die, type_attr, cu); + type_die = follow_die_ref (die, type_attr, &cu); type = tag_type_to_type (type_die, cu); if (!type) { - dump_die (type_die); + dump_die_for_error (type_die); error (_("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]"), cu->objfile->name); } @@ -7501,13 +8221,13 @@ die_containing_type (struct die_info *die, struct dwarf2_cu *cu) type_attr = dwarf2_attr (die, DW_AT_containing_type, cu); if (type_attr) { - type_die = follow_die_ref (die, type_attr, cu); + type_die = follow_die_ref (die, type_attr, &cu); type = tag_type_to_type (type_die, cu); } if (!type) { if (type_die) - dump_die (type_die); + dump_die_for_error (type_die); error (_("Dwarf Error: Problem turning containing type into gdb type [in module %s]"), cu->objfile->name); } @@ -7517,80 +8237,81 @@ die_containing_type (struct die_info *die, struct dwarf2_cu *cu) static struct type * tag_type_to_type (struct die_info *die, struct dwarf2_cu *cu) { - if (die->type) - { - return die->type; - } - else + struct type *this_type; + + this_type = read_type_die (die, cu); + if (!this_type) { - read_type_die (die, cu); - if (!die->type) - { - dump_die (die); - error (_("Dwarf Error: Cannot find type of die [in module %s]"), - cu->objfile->name); - } - return die->type; + dump_die_for_error (die); + error (_("Dwarf Error: Cannot find type of die [in module %s]"), + cu->objfile->name); } + return this_type; } -static void +static struct type * read_type_die (struct die_info *die, struct dwarf2_cu *cu) { - char *prefix = determine_prefix (die, cu); - const char *old_prefix = processing_current_prefix; - struct cleanup *back_to = make_cleanup (xfree, prefix); - processing_current_prefix = prefix; - + struct type *this_type; + + this_type = get_die_type (die, cu); + if (this_type) + return this_type; + switch (die->tag) { case DW_TAG_class_type: + case DW_TAG_interface_type: case DW_TAG_structure_type: case DW_TAG_union_type: - read_structure_type (die, cu); + this_type = read_structure_type (die, cu); break; case DW_TAG_enumeration_type: - read_enumeration_type (die, cu); + this_type = read_enumeration_type (die, cu); break; case DW_TAG_subprogram: case DW_TAG_subroutine_type: - read_subroutine_type (die, cu); + case DW_TAG_inlined_subroutine: + this_type = read_subroutine_type (die, cu); break; case DW_TAG_array_type: - read_array_type (die, cu); + this_type = read_array_type (die, cu); break; case DW_TAG_set_type: - read_set_type (die, cu); + this_type = read_set_type (die, cu); break; case DW_TAG_pointer_type: - read_tag_pointer_type (die, cu); + this_type = read_tag_pointer_type (die, cu); break; case DW_TAG_ptr_to_member_type: - read_tag_ptr_to_member_type (die, cu); + this_type = read_tag_ptr_to_member_type (die, cu); break; case DW_TAG_reference_type: - read_tag_reference_type (die, cu); + this_type = read_tag_reference_type (die, cu); break; case DW_TAG_const_type: - read_tag_const_type (die, cu); + this_type = read_tag_const_type (die, cu); break; case DW_TAG_volatile_type: - read_tag_volatile_type (die, cu); + this_type = read_tag_volatile_type (die, cu); break; case DW_TAG_string_type: - read_tag_string_type (die, cu); + this_type = read_tag_string_type (die, cu); break; case DW_TAG_typedef: - read_typedef (die, cu); + this_type = read_typedef (die, cu); break; case DW_TAG_subrange_type: - read_subrange_type (die, cu); + this_type = read_subrange_type (die, cu); break; case DW_TAG_base_type: - read_base_type (die, cu); + this_type = read_base_type (die, cu); break; case DW_TAG_unspecified_type: - read_unspecified_type (die, cu); + this_type = read_unspecified_type (die, cu); + break; + case DW_TAG_namespace: + this_type = read_namespace_type (die, cu); break; default: complaint (&symfile_complaints, _("unexpected tag in read_type_die: '%s'"), @@ -7598,81 +8319,89 @@ read_type_die (struct die_info *die, struct dwarf2_cu *cu) break; } - processing_current_prefix = old_prefix; - do_cleanups (back_to); + return this_type; } /* Return the name of the namespace/class that DIE is defined within, - or "" if we can't tell. The caller should xfree the result. */ + or "" if we can't tell. The caller should not xfree the result. -/* NOTE: carlton/2004-01-23: See read_func_scope (and the comment - therein) for an example of how to use this function to deal with - DW_AT_specification. */ + For example, if we're within the method foo() in the following + code: + + namespace N { + class C { + void foo () { + } + }; + } + + then determine_prefix on foo's die will return "N::C". */ static char * determine_prefix (struct die_info *die, struct dwarf2_cu *cu) { - struct die_info *parent; + struct die_info *parent, *spec_die; + struct dwarf2_cu *spec_cu; + struct type *parent_type; if (cu->language != language_cplus && cu->language != language_java) - return NULL; + return ""; - parent = die->parent; + /* We have to be careful in the presence of DW_AT_specification. + For example, with GCC 3.4, given the code - if (parent == NULL) + namespace N { + void foo() { + // Definition of N::foo. + } + } + + then we'll have a tree of DIEs like this: + + 1: DW_TAG_compile_unit + 2: DW_TAG_namespace // N + 3: DW_TAG_subprogram // declaration of N::foo + 4: DW_TAG_subprogram // definition of N::foo + DW_AT_specification // refers to die #3 + + Thus, when processing die #4, we have to pretend that we're in + the context of its DW_AT_specification, namely the contex of die + #3. */ + spec_cu = cu; + spec_die = die_specification (die, &spec_cu); + if (spec_die == NULL) + parent = die->parent; + else { - return xstrdup (""); + parent = spec_die->parent; + cu = spec_cu; } + + if (parent == NULL) + return ""; else - { - switch (parent->tag) { + switch (parent->tag) + { case DW_TAG_namespace: - { - /* FIXME: carlton/2004-03-05: Should I follow extension dies - before doing this check? */ - if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL) - { - return xstrdup (TYPE_TAG_NAME (parent->type)); - } - else - { - int dummy; - char *parent_prefix = determine_prefix (parent, cu); - char *retval = typename_concat (NULL, parent_prefix, - namespace_name (parent, &dummy, - cu), - cu); - xfree (parent_prefix); - return retval; - } - } - break; + parent_type = read_type_die (parent, cu); + /* We give a name to even anonymous namespaces. */ + return TYPE_TAG_NAME (parent_type); case DW_TAG_class_type: + case DW_TAG_interface_type: case DW_TAG_structure_type: - { - if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL) - { - return xstrdup (TYPE_TAG_NAME (parent->type)); - } - else - { - const char *old_prefix = processing_current_prefix; - char *new_prefix = determine_prefix (parent, cu); - char *retval; - - processing_current_prefix = new_prefix; - retval = determine_class_name (parent, cu); - processing_current_prefix = old_prefix; - - xfree (new_prefix); - return retval; - } - } + case DW_TAG_union_type: + parent_type = read_type_die (parent, cu); + if (TYPE_TAG_NAME (parent_type) != NULL) + return TYPE_TAG_NAME (parent_type); + else + /* An anonymous structure is only allowed non-static data + members; no typedefs, no member functions, et cetera. + So it does not need a prefix. */ + return ""; default: return determine_prefix (parent, cu); } - } } /* Return a newly-allocated string formed by concatenating PREFIX and @@ -7696,146 +8425,25 @@ typename_concat (struct obstack *obs, const char *prefix, const char *suffix, else sep = "::"; + if (prefix == NULL) + prefix = ""; + if (suffix == NULL) + suffix = ""; + if (obs == NULL) { char *retval = xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1); - retval[0] = '\0'; - - if (prefix) - { - strcpy (retval, prefix); - strcat (retval, sep); - } - if (suffix) - strcat (retval, suffix); - + strcpy (retval, prefix); + strcat (retval, sep); + strcat (retval, suffix); return retval; - } - else - { - /* We have an obstack. */ - return obconcat (obs, prefix, sep, suffix); - } -} - -static struct type * -dwarf_base_type (int encoding, int size, struct dwarf2_cu *cu) -{ - struct objfile *objfile = cu->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, cu); - return type; - case DW_ATE_boolean: - type = dwarf2_fundamental_type (objfile, FT_BOOLEAN, cu); - return type; - case DW_ATE_complex_float: - if (size == 16) - { - type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_COMPLEX, cu); - } - else - { - type = dwarf2_fundamental_type (objfile, FT_COMPLEX, cu); - } - return type; - case DW_ATE_float: - if (size == 8) - { - type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu); - } - else - { - type = dwarf2_fundamental_type (objfile, FT_FLOAT, cu); - } - return type; - case DW_ATE_decimal_float: - if (size == 16) - type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_DECFLOAT, cu); - else if (size == 8) - type = dwarf2_fundamental_type (objfile, FT_EXT_PREC_DECFLOAT, cu); - else - type = dwarf2_fundamental_type (objfile, FT_DECFLOAT, cu); - return type; - case DW_ATE_signed: - switch (size) - { - case 1: - type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu); - break; - case 2: - type = dwarf2_fundamental_type (objfile, FT_SIGNED_SHORT, cu); - break; - default: - case 4: - type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu); - break; - } - return type; - case DW_ATE_signed_char: - type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu); - return type; - case DW_ATE_unsigned: - switch (size) - { - case 1: - type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu); - break; - case 2: - type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_SHORT, cu); - break; - default: - case 4: - type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_INTEGER, cu); - break; - } - return type; - case DW_ATE_unsigned_char: - type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu); - return type; - default: - type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu); - 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) + } + else { - 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; + /* We have an obstack. */ + return obconcat (obs, prefix, sep, suffix); } - - new_die->next = NULL; - return new_die; } -#endif /* Return sibling of die, NULL if no sibling. */ @@ -7855,10 +8463,29 @@ dwarf2_linkage_name (struct die_info *die, struct dwarf2_cu *cu) attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu); if (attr && DW_STRING (attr)) return DW_STRING (attr); - attr = dwarf2_attr (die, DW_AT_name, cu); - if (attr && DW_STRING (attr)) - return DW_STRING (attr); - return NULL; + return dwarf2_name (die, cu); +} + +/* Get name of a die, return NULL if not found. */ + +static char * +dwarf2_canonicalize_name (char *name, struct dwarf2_cu *cu, + struct obstack *obstack) +{ + if (name && cu->language == language_cplus) + { + char *canon_name = cp_canonicalize_string (name); + + if (canon_name != NULL) + { + if (strcmp (canon_name, name) != 0) + name = obsavestring (canon_name, strlen (canon_name), + obstack); + xfree (canon_name); + } + } + + return name; } /* Get name of a die, return NULL if not found. */ @@ -7869,24 +8496,45 @@ dwarf2_name (struct die_info *die, struct dwarf2_cu *cu) struct attribute *attr; attr = dwarf2_attr (die, DW_AT_name, cu); - if (attr && DW_STRING (attr)) - return DW_STRING (attr); - return NULL; + if (!attr || !DW_STRING (attr)) + return NULL; + + switch (die->tag) + { + case DW_TAG_compile_unit: + /* Compilation units have a DW_AT_name that is a filename, not + a source language identifier. */ + case DW_TAG_enumeration_type: + case DW_TAG_enumerator: + /* These tags always have simple identifiers already; no need + to canonicalize them. */ + return DW_STRING (attr); + default: + if (attr->form != GDB_FORM_cached_string) + { + DW_STRING (attr) + = dwarf2_canonicalize_name (DW_STRING (attr), cu, + &cu->objfile->objfile_obstack); + attr->form = GDB_FORM_cached_string; + } + return DW_STRING (attr); + } } /* Return the die that this die in an extension of, or NULL if there - is none. */ + is none. *EXT_CU is the CU containing DIE on input, and the CU + containing the return value on output. */ static struct die_info * -dwarf2_extension (struct die_info *die, struct dwarf2_cu *cu) +dwarf2_extension (struct die_info *die, struct dwarf2_cu **ext_cu) { struct attribute *attr; - attr = dwarf2_attr (die, DW_AT_extension, cu); + attr = dwarf2_attr (die, DW_AT_extension, *ext_cu); if (attr == NULL) return NULL; - return follow_die_ref (die, attr, cu); + return follow_die_ref (die, attr, ext_cu); } /* Convert a DIE tag into its string name. */ @@ -8110,8 +8758,8 @@ dwarf_attr_name (unsigned attr) 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_bit_stride: + return "DW_AT_bit_stride"; case DW_AT_upper_bound: return "DW_AT_upper_bound"; case DW_AT_abstract_origin: @@ -8179,8 +8827,8 @@ dwarf_attr_name (unsigned attr) return "DW_AT_associated"; case DW_AT_data_location: return "DW_AT_data_location"; - case DW_AT_stride: - return "DW_AT_stride"; + case DW_AT_byte_stride: + return "DW_AT_byte_stride"; case DW_AT_entry_pc: return "DW_AT_entry_pc"; case DW_AT_use_UTF8: @@ -8227,10 +8875,11 @@ dwarf_attr_name (unsigned attr) return "DW_AT_pure"; case DW_AT_recursive: return "DW_AT_recursive"; -#ifdef MIPS /* SGI/MIPS extensions. */ +#ifdef MIPS /* collides with DW_AT_HP_block_index */ case DW_AT_MIPS_fde: return "DW_AT_MIPS_fde"; +#endif case DW_AT_MIPS_loop_begin: return "DW_AT_MIPS_loop_begin"; case DW_AT_MIPS_tail_loop_begin: @@ -8251,10 +8900,11 @@ dwarf_attr_name (unsigned attr) return "DW_AT_MIPS_clone_origin"; case DW_AT_MIPS_has_inlines: return "DW_AT_MIPS_has_inlines"; -#endif /* HP extensions. */ +#ifndef MIPS /* collides with DW_AT_MIPS_fde */ case DW_AT_HP_block_index: return "DW_AT_HP_block_index"; +#endif case DW_AT_HP_unmodifiable: return "DW_AT_HP_unmodifiable"; case DW_AT_HP_actuals_stmt_list: @@ -8363,6 +9013,8 @@ dwarf_form_name (unsigned form) return "DW_FORM_ref_udata"; case DW_FORM_indirect: return "DW_FORM_indirect"; + case GDB_FORM_cached_string: + return "GDB_FORM_cached_string"; default: return "DW_FORM_"; } @@ -8850,38 +9502,52 @@ dwarf_cfi_name (unsigned cfi_opc) #endif static void -dump_die (struct die_info *die) +dump_die_shallow (struct ui_file *f, int indent, struct die_info *die) { unsigned int i; - fprintf_unfiltered (gdb_stderr, "Die: %s (abbrev = %d, offset = %d)\n", + print_spaces (indent, f); + fprintf_unfiltered (f, "Die: %s (abbrev %d, offset 0x%x)\n", dwarf_tag_name (die->tag), die->abbrev, die->offset); - fprintf_unfiltered (gdb_stderr, "\thas children: %s\n", + + if (die->parent != NULL) + { + print_spaces (indent, f); + fprintf_unfiltered (f, " parent at offset: 0x%x\n", + die->parent->offset); + } + + print_spaces (indent, f); + fprintf_unfiltered (f, " has children: %s\n", dwarf_bool_name (die->child != NULL)); - fprintf_unfiltered (gdb_stderr, "\tattributes:\n"); + print_spaces (indent, f); + fprintf_unfiltered (f, " attributes:\n"); + for (i = 0; i < die->num_attrs; ++i) { - fprintf_unfiltered (gdb_stderr, "\t\t%s (%s) ", + print_spaces (indent, f); + fprintf_unfiltered (f, " %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_unfiltered (gdb_stderr, "address: "); - deprecated_print_address_numeric (DW_ADDR (&die->attrs[i]), 1, gdb_stderr); + fprintf_unfiltered (f, "address: "); + fputs_filtered (hex_string (DW_ADDR (&die->attrs[i])), f); break; case DW_FORM_block2: case DW_FORM_block4: case DW_FORM_block: case DW_FORM_block1: - fprintf_unfiltered (gdb_stderr, "block: size %d", DW_BLOCK (&die->attrs[i])->size); + fprintf_unfiltered (f, "block: size %d", DW_BLOCK (&die->attrs[i])->size); break; case DW_FORM_ref1: case DW_FORM_ref2: case DW_FORM_ref4: - fprintf_unfiltered (gdb_stderr, "constant ref: %ld (adjusted)", + fprintf_unfiltered (f, "constant ref: 0x%lx (adjusted)", (long) (DW_ADDR (&die->attrs[i]))); break; case DW_FORM_data1: @@ -8890,61 +9556,95 @@ dump_die (struct die_info *die) case DW_FORM_data8: case DW_FORM_udata: case DW_FORM_sdata: - fprintf_unfiltered (gdb_stderr, "constant: %ld", DW_UNSND (&die->attrs[i])); + fprintf_unfiltered (f, "constant: %ld", DW_UNSND (&die->attrs[i])); break; case DW_FORM_string: case DW_FORM_strp: - fprintf_unfiltered (gdb_stderr, "string: \"%s\"", + case GDB_FORM_cached_string: + fprintf_unfiltered (f, "string: \"%s\"", DW_STRING (&die->attrs[i]) ? DW_STRING (&die->attrs[i]) : ""); break; case DW_FORM_flag: if (DW_UNSND (&die->attrs[i])) - fprintf_unfiltered (gdb_stderr, "flag: TRUE"); + fprintf_unfiltered (f, "flag: TRUE"); else - fprintf_unfiltered (gdb_stderr, "flag: FALSE"); + fprintf_unfiltered (f, "flag: FALSE"); break; case DW_FORM_indirect: /* the reader will have reduced the indirect form to the "base form" so this form should not occur */ - fprintf_unfiltered (gdb_stderr, "unexpected attribute form: DW_FORM_indirect"); + fprintf_unfiltered (f, "unexpected attribute form: DW_FORM_indirect"); break; default: - fprintf_unfiltered (gdb_stderr, "unsupported attribute form: %d.", + fprintf_unfiltered (f, "unsupported attribute form: %d.", die->attrs[i].form); + break; } - fprintf_unfiltered (gdb_stderr, "\n"); + fprintf_unfiltered (f, "\n"); } } static void -dump_die_list (struct die_info *die) +dump_die_for_error (struct die_info *die) +{ + dump_die_shallow (gdb_stderr, 0, die); +} + +static void +dump_die_1 (struct ui_file *f, int level, int max_level, struct die_info *die) { - while (die) + int indent = level * 4; + + gdb_assert (die != NULL); + + if (level >= max_level) + return; + + dump_die_shallow (f, indent, die); + + if (die->child != NULL) + { + print_spaces (indent, f); + fprintf_unfiltered (f, " Children:"); + if (level + 1 < max_level) + { + fprintf_unfiltered (f, "\n"); + dump_die_1 (f, level + 1, max_level, die->child); + } + else + { + fprintf_unfiltered (f, " [not printed, max nesting level reached]\n"); + } + } + + if (die->sibling != NULL && level > 0) { - dump_die (die); - if (die->child != NULL) - dump_die_list (die->child); - if (die->sibling != NULL) - dump_die_list (die->sibling); + dump_die_1 (f, level, max_level, die->sibling); } } +/* This is called from the pdie macro in gdbinit.in. + It's not static so gcc will keep a copy callable from gdb. */ + +void +dump_die (struct die_info *die, int max_level) +{ + dump_die_1 (gdb_stdlog, 0, max_level, die); +} + static void -store_in_ref_table (unsigned int offset, struct die_info *die, - struct dwarf2_cu *cu) +store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu) { - int h; - struct die_info *old; + void **slot; - h = (offset % REF_HASH_SIZE); - old = cu->die_ref_table[h]; - die->next_ref = old; - cu->die_ref_table[h] = die; + slot = htab_find_slot_with_hash (cu->die_hash, die, die->offset, INSERT); + + *slot = die; } static unsigned int -dwarf2_get_ref_die_offset (struct attribute *attr, struct dwarf2_cu *cu) +dwarf2_get_ref_die_offset (struct attribute *attr) { unsigned int result = 0; @@ -8988,65 +9688,70 @@ dwarf2_get_attr_constant_value (struct attribute *attr, int default_value) } } +/* THIS_CU has a reference to PER_CU. If necessary, load the new compilation + unit and add it to our queue. */ + +static void +maybe_queue_comp_unit (struct dwarf2_cu *this_cu, + struct dwarf2_per_cu_data *per_cu) +{ + /* Mark the dependence relation so that we don't flush PER_CU + too early. */ + dwarf2_add_dependence (this_cu, per_cu); + + /* If it's already on the queue, we have nothing to do. */ + if (per_cu->queued) + return; + + /* If the compilation unit is already loaded, just mark it as + used. */ + if (per_cu->cu != NULL) + { + per_cu->cu->last_used = 0; + return; + } + + /* Add it to the queue. */ + queue_comp_unit (per_cu, this_cu->objfile); +} + +/* Follow reference attribute ATTR of SRC_DIE. + On entry *REF_CU is the CU of SRC_DIE. + On exit *REF_CU is the CU of the result. */ + static struct die_info * follow_die_ref (struct die_info *src_die, struct attribute *attr, - struct dwarf2_cu *cu) + struct dwarf2_cu **ref_cu) { struct die_info *die; unsigned int offset; - int h; struct die_info temp_die; - struct dwarf2_cu *target_cu; + struct dwarf2_cu *target_cu, *cu = *ref_cu; - offset = dwarf2_get_ref_die_offset (attr, cu); + offset = dwarf2_get_ref_die_offset (attr); - if (DW_ADDR (attr) < cu->header.offset - || DW_ADDR (attr) >= cu->header.offset + cu->header.length) + if (! offset_in_cu_p (&cu->header, offset)) { struct dwarf2_per_cu_data *per_cu; - per_cu = dwarf2_find_containing_comp_unit (DW_ADDR (attr), - cu->objfile); + per_cu = dwarf2_find_containing_comp_unit (offset, cu->objfile); + + /* If necessary, add it to the queue and load its DIEs. */ + maybe_queue_comp_unit (cu, per_cu); + target_cu = per_cu->cu; } else target_cu = cu; - h = (offset % REF_HASH_SIZE); - die = target_cu->die_ref_table[h]; - while (die) - { - if (die->offset == offset) - return die; - die = die->next_ref; - } + *ref_cu = target_cu; + temp_die.offset = offset; + die = htab_find_with_hash (target_cu->die_hash, &temp_die, offset); + if (die) + return die; error (_("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE " "at 0x%lx [in module %s]"), - (long) src_die->offset, (long) offset, cu->objfile->name); - - return NULL; -} - -static struct type * -dwarf2_fundamental_type (struct objfile *objfile, int typeid, - struct dwarf2_cu *cu) -{ - if (typeid < 0 || typeid >= FT_NUM_MEMBERS) - { - error (_("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]"), - typeid, objfile->name); - } - - /* 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 (cu->ftypes[typeid] == NULL) - { - cu->ftypes[typeid] = cu->language_defn->la_fund_type (objfile, typeid); - } - - return (cu->ftypes[typeid]); + (long) offset, (long) src_die->offset, cu->objfile->name); } /* Decode simple location descriptions. @@ -9296,11 +10001,15 @@ dwarf_alloc_abbrev (struct dwarf2_cu *cu) } static struct die_info * -dwarf_alloc_die (void) +dwarf_alloc_die (struct dwarf2_cu *cu, int num_attrs) { struct die_info *die; + size_t size = sizeof (struct die_info); - die = (struct die_info *) xmalloc (sizeof (struct die_info)); + if (num_attrs > 1) + size += (num_attrs - 1) * sizeof (struct attribute); + + die = (struct die_info *) obstack_alloc (&cu->comp_unit_obstack, size); memset (die, 0, sizeof (struct die_info)); return (die); } @@ -9571,26 +10280,38 @@ dwarf_decode_macros (struct line_header *lh, unsigned int offset, { gdb_byte *mac_ptr, *mac_end; struct macro_source_file *current_file = 0; + enum dwarf_macinfo_record_type macinfo_type; + int at_commandline; - if (dwarf2_per_objfile->macinfo_buffer == NULL) + if (dwarf2_per_objfile->macinfo.buffer == NULL) { complaint (&symfile_complaints, _("missing .debug_macinfo section")); return; } - mac_ptr = dwarf2_per_objfile->macinfo_buffer + offset; - mac_end = dwarf2_per_objfile->macinfo_buffer - + dwarf2_per_objfile->macinfo_size; + /* First pass: Find the name of the base filename. + This filename is needed in order to process all macros whose definition + (or undefinition) comes from the command line. These macros are defined + before the first DW_MACINFO_start_file entry, and yet still need to be + associated to the base file. - for (;;) - { - enum dwarf_macinfo_record_type macinfo_type; + To determine the base file name, we scan the macro definitions until we + reach the first DW_MACINFO_start_file entry. We then initialize + CURRENT_FILE accordingly so that any macro definition found before the + first DW_MACINFO_start_file can still be associated to the base file. */ + mac_ptr = dwarf2_per_objfile->macinfo.buffer + offset; + mac_end = dwarf2_per_objfile->macinfo.buffer + + dwarf2_per_objfile->macinfo.size; + + do + { /* Do we at least have room for a macinfo type byte? */ if (mac_ptr >= mac_end) { - dwarf2_macros_too_long_complaint (); - return; + /* Complaint is printed during the second pass as GDB will probably + stop the first pass earlier upon finding DW_MACINFO_start_file. */ + break; } macinfo_type = read_1_byte (abfd, mac_ptr); @@ -9601,7 +10322,92 @@ dwarf_decode_macros (struct line_header *lh, unsigned int offset, /* A zero macinfo type indicates the end of the macro information. */ case 0: - return; + break; + + case DW_MACINFO_define: + case DW_MACINFO_undef: + /* Only skip the data by MAC_PTR. */ + { + unsigned int bytes_read; + + read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); + mac_ptr += bytes_read; + read_string (abfd, mac_ptr, &bytes_read); + mac_ptr += bytes_read; + } + break; + + case DW_MACINFO_start_file: + { + unsigned int bytes_read; + int line, file; + + line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); + mac_ptr += bytes_read; + file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); + mac_ptr += bytes_read; + + current_file = macro_start_file (file, line, current_file, comp_dir, + lh, cu->objfile); + } + break; + + case DW_MACINFO_end_file: + /* No data to skip by MAC_PTR. */ + break; + + case DW_MACINFO_vendor_ext: + /* Only skip the data by MAC_PTR. */ + { + unsigned int bytes_read; + + read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); + mac_ptr += bytes_read; + read_string (abfd, mac_ptr, &bytes_read); + mac_ptr += bytes_read; + } + break; + + default: + break; + } + } while (macinfo_type != 0 && current_file == NULL); + + /* Second pass: Process all entries. + + Use the AT_COMMAND_LINE flag to determine whether we are still processing + command-line macro definitions/undefinitions. This flag is unset when we + reach the first DW_MACINFO_start_file entry. */ + + mac_ptr = dwarf2_per_objfile->macinfo.buffer + offset; + + /* Determines if GDB is still before first DW_MACINFO_start_file. If true + GDB is still reading the definitions from command line. First + DW_MACINFO_start_file will need to be ignored as it was already executed + to create CURRENT_FILE for the main source holding also the command line + definitions. On first met DW_MACINFO_start_file this flag is reset to + normally execute all the remaining DW_MACINFO_start_file macinfos. */ + + at_commandline = 1; + + do + { + /* Do we at least have room for a macinfo type byte? */ + if (mac_ptr >= mac_end) + { + dwarf2_macros_too_long_complaint (); + break; + } + + macinfo_type = read_1_byte (abfd, mac_ptr); + mac_ptr++; + + switch (macinfo_type) + { + /* A zero macinfo type indicates the end of the macro + information. */ + case 0: + break; case DW_MACINFO_define: case DW_MACINFO_undef: @@ -9616,19 +10422,31 @@ dwarf_decode_macros (struct line_header *lh, unsigned int offset, mac_ptr += bytes_read; if (! current_file) + { + /* DWARF violation as no main source is present. */ + complaint (&symfile_complaints, + _("debug info with no main source gives macro %s " + "on line %d: %s"), + macinfo_type == + DW_MACINFO_define ? _("definition") : macinfo_type == + DW_MACINFO_undef ? _("undefinition") : + "something-or-other", line, body); + break; + } + if ((line == 0 && !at_commandline) || (line != 0 && at_commandline)) complaint (&symfile_complaints, - _("debug info gives macro %s outside of any file: %s"), + _("debug info gives %s macro %s with %s line %d: %s"), + at_commandline ? _("command-line") : _("in-file"), macinfo_type == - DW_MACINFO_define ? "definition" : macinfo_type == - DW_MACINFO_undef ? "undefinition" : - "something-or-other", body); - else - { - if (macinfo_type == DW_MACINFO_define) - parse_macro_definition (current_file, line, body); - else if (macinfo_type == DW_MACINFO_undef) - macro_undef (current_file, line, body); - } + DW_MACINFO_define ? _("definition") : macinfo_type == + DW_MACINFO_undef ? _("undefinition") : + "something-or-other", + line == 0 ? _("zero") : _("non-zero"), line, body); + + if (macinfo_type == DW_MACINFO_define) + parse_macro_definition (current_file, line, body); + else if (macinfo_type == DW_MACINFO_undef) + macro_undef (current_file, line, body); } break; @@ -9642,9 +10460,22 @@ dwarf_decode_macros (struct line_header *lh, unsigned int offset, file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); mac_ptr += bytes_read; - current_file = macro_start_file (file, line, - current_file, comp_dir, - lh, cu->objfile); + if ((line == 0 && !at_commandline) || (line != 0 && at_commandline)) + complaint (&symfile_complaints, + _("debug info gives source %d included " + "from %s at %s line %d"), + file, at_commandline ? _("command-line") : _("file"), + line == 0 ? _("zero") : _("non-zero"), line); + + if (at_commandline) + { + /* This DW_MACINFO_start_file was executed in the pass one. */ + at_commandline = 0; + } + else + current_file = macro_start_file (file, line, + current_file, comp_dir, + lh, cu->objfile); } break; @@ -9698,7 +10529,7 @@ dwarf_decode_macros (struct line_header *lh, unsigned int offset, } break; } - } + } while (macinfo_type != 0); } /* Check if the attribute's form is a DW_FORM_block* @@ -9713,39 +10544,78 @@ attr_form_is_block (struct attribute *attr) || attr->form == DW_FORM_block); } +/* Return non-zero if ATTR's value is a section offset --- classes + lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise. + You may use DW_UNSND (attr) to retrieve such offsets. + + Section 7.5.4, "Attribute Encodings", explains that no attribute + may have a value that belongs to more than one of these classes; it + would be ambiguous if we did, because we use the same forms for all + of them. */ +static int +attr_form_is_section_offset (struct attribute *attr) +{ + return (attr->form == DW_FORM_data4 + || attr->form == DW_FORM_data8); +} + + +/* Return non-zero if ATTR's value falls in the 'constant' class, or + zero otherwise. When this function returns true, you can apply + dwarf2_get_attr_constant_value to it. + + However, note that for some attributes you must check + attr_form_is_section_offset before using this test. DW_FORM_data4 + and DW_FORM_data8 are members of both the constant class, and of + the classes that contain offsets into other debug sections + (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says + that, if an attribute's can be either a constant or one of the + section offset classes, DW_FORM_data4 and DW_FORM_data8 should be + taken as section offsets, not constants. */ +static int +attr_form_is_constant (struct attribute *attr) +{ + switch (attr->form) + { + case DW_FORM_sdata: + case DW_FORM_udata: + case DW_FORM_data1: + case DW_FORM_data2: + case DW_FORM_data4: + case DW_FORM_data8: + return 1; + default: + return 0; + } +} + static void dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym, struct dwarf2_cu *cu) { - struct objfile *objfile = cu->objfile; - - /* Save the master objfile, so that we can report and look up the - correct file containing this variable. */ - if (objfile->separate_debug_objfile_backlink) - objfile = objfile->separate_debug_objfile_backlink; - - if ((attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8) + if (attr_form_is_section_offset (attr) /* ".debug_loc" may not exist at all, or the offset may be outside the section. If so, fall through to the complaint in the other branch. */ - && DW_UNSND (attr) < dwarf2_per_objfile->loc_size) + && DW_UNSND (attr) < dwarf2_per_objfile->loc.size) { struct dwarf2_loclist_baton *baton; baton = obstack_alloc (&cu->objfile->objfile_obstack, sizeof (struct dwarf2_loclist_baton)); - baton->objfile = objfile; + baton->per_cu = cu->per_cu; + gdb_assert (baton->per_cu); /* We don't know how long the location list is, but make sure we don't run off the edge of the section. */ - baton->size = dwarf2_per_objfile->loc_size - DW_UNSND (attr); - baton->data = dwarf2_per_objfile->loc_buffer + DW_UNSND (attr); - baton->base_address = cu->header.base_address; - if (cu->header.base_known == 0) + baton->size = dwarf2_per_objfile->loc.size - DW_UNSND (attr); + baton->data = dwarf2_per_objfile->loc.buffer + DW_UNSND (attr); + baton->base_address = cu->base_address; + if (cu->base_known == 0) complaint (&symfile_complaints, _("Location list used without specifying the CU base address.")); - SYMBOL_OPS (sym) = &dwarf2_loclist_funcs; + SYMBOL_COMPUTED_OPS (sym) = &dwarf2_loclist_funcs; SYMBOL_LOCATION_BATON (sym) = baton; } else @@ -9754,7 +10624,8 @@ dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym, baton = obstack_alloc (&cu->objfile->objfile_obstack, sizeof (struct dwarf2_locexpr_baton)); - baton->objfile = objfile; + baton->per_cu = cu->per_cu; + gdb_assert (baton->per_cu); if (attr_form_is_block (attr)) { @@ -9774,16 +10645,53 @@ dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym, baton->data = NULL; } - SYMBOL_OPS (sym) = &dwarf2_locexpr_funcs; + SYMBOL_COMPUTED_OPS (sym) = &dwarf2_locexpr_funcs; SYMBOL_LOCATION_BATON (sym) = baton; } } +/* Return the OBJFILE associated with the compilation unit CU. */ + +struct objfile * +dwarf2_per_cu_objfile (struct dwarf2_per_cu_data *per_cu) +{ + struct objfile *objfile = per_cu->psymtab->objfile; + + /* Return the master objfile, so that we can report and look up the + correct file containing this variable. */ + if (objfile->separate_debug_objfile_backlink) + objfile = objfile->separate_debug_objfile_backlink; + + return objfile; +} + +/* Return the address size given in the compilation unit header for CU. */ + +CORE_ADDR +dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data *per_cu) +{ + if (per_cu->cu) + return per_cu->cu->header.addr_size; + else + { + /* If the CU is not currently read in, we re-read its header. */ + struct objfile *objfile = per_cu->psymtab->objfile; + struct dwarf2_per_objfile *per_objfile + = objfile_data (objfile, dwarf2_objfile_data_key); + gdb_byte *info_ptr = per_objfile->info.buffer + per_cu->offset; + + struct comp_unit_head cu_header; + memset (&cu_header, 0, sizeof cu_header); + read_comp_unit_head (&cu_header, info_ptr, objfile->obfd); + return cu_header.addr_size; + } +} + /* Locate the compilation unit from CU's objfile which contains the DIE at OFFSET. Raises an error on failure. */ static struct dwarf2_per_cu_data * -dwarf2_find_containing_comp_unit (unsigned long offset, +dwarf2_find_containing_comp_unit (unsigned int offset, struct objfile *objfile) { struct dwarf2_per_cu_data *this_cu; @@ -9815,7 +10723,7 @@ dwarf2_find_containing_comp_unit (unsigned long offset, this_cu = dwarf2_per_objfile->all_comp_units[low]; if (low == dwarf2_per_objfile->n_comp_units - 1 && offset >= this_cu->offset + this_cu->length) - error (_("invalid dwarf2 offset %ld"), offset); + error (_("invalid dwarf2 offset %u"), offset); gdb_assert (offset < this_cu->offset + this_cu->length); return this_cu; } @@ -9825,12 +10733,12 @@ dwarf2_find_containing_comp_unit (unsigned long offset, OFFSET. Raises an error on failure. */ static struct dwarf2_per_cu_data * -dwarf2_find_comp_unit (unsigned long offset, struct objfile *objfile) +dwarf2_find_comp_unit (unsigned int offset, struct objfile *objfile) { struct dwarf2_per_cu_data *this_cu; this_cu = dwarf2_find_containing_comp_unit (offset, objfile); if (this_cu->offset != offset) - error (_("no compilation unit with offset %ld."), offset); + error (_("no compilation unit with offset %u."), offset); return this_cu; } @@ -9848,8 +10756,6 @@ free_one_comp_unit (void *data) cu->per_cu = NULL; obstack_free (&cu->comp_unit_obstack, NULL); - if (cu->dies) - free_die_list (cu->dies); xfree (cu); } @@ -10016,43 +10922,47 @@ offset_and_type_eq (const void *item_lhs, const void *item_rhs) } /* Set the type associated with DIE to TYPE. Save it in CU's hash - table if necessary. */ + table if necessary. For convenience, return TYPE. */ -static void +static struct type * set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu) { struct dwarf2_offset_and_type **slot, ofs; - die->type = type; - - if (cu->per_cu == NULL) - return; - - if (cu->per_cu->type_hash == NULL) - cu->per_cu->type_hash - = htab_create_alloc_ex (cu->header.length / 24, - offset_and_type_hash, - offset_and_type_eq, - NULL, - &cu->objfile->objfile_obstack, - hashtab_obstack_allocate, - dummy_obstack_deallocate); + if (cu->type_hash == NULL) + { + gdb_assert (cu->per_cu != NULL); + cu->per_cu->type_hash + = htab_create_alloc_ex (cu->header.length / 24, + offset_and_type_hash, + offset_and_type_eq, + NULL, + &cu->objfile->objfile_obstack, + hashtab_obstack_allocate, + dummy_obstack_deallocate); + cu->type_hash = cu->per_cu->type_hash; + } ofs.offset = die->offset; ofs.type = type; slot = (struct dwarf2_offset_and_type **) - htab_find_slot_with_hash (cu->per_cu->type_hash, &ofs, ofs.offset, INSERT); + htab_find_slot_with_hash (cu->type_hash, &ofs, ofs.offset, INSERT); *slot = obstack_alloc (&cu->objfile->objfile_obstack, sizeof (**slot)); **slot = ofs; + return type; } -/* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not - have a saved type. */ +/* Find the type for DIE in CU's type_hash, or return NULL if DIE does + not have a saved type. */ static struct type * -get_die_type (struct die_info *die, htab_t type_hash) +get_die_type (struct die_info *die, struct dwarf2_cu *cu) { struct dwarf2_offset_and_type *slot, ofs; + htab_t type_hash = cu->type_hash; + + if (type_hash == NULL) + return NULL; ofs.offset = die->offset; slot = htab_find_with_hash (type_hash, &ofs, ofs.offset); @@ -10062,28 +10972,6 @@ get_die_type (struct die_info *die, htab_t type_hash) return NULL; } -/* Restore the types of the DIE tree starting at START_DIE from the hash - table saved in CU. */ - -static void -reset_die_and_siblings_types (struct die_info *start_die, struct dwarf2_cu *cu) -{ - struct die_info *die; - - if (cu->per_cu->type_hash == NULL) - return; - - for (die = start_die; die != NULL; die = die->sibling) - { - die->type = get_die_type (die, cu->per_cu->type_hash); - if (die->child != NULL) - reset_die_and_siblings_types (die->child, cu); - } -} - -/* Set the mark field in CU and in every other compilation unit in the - cache that we must keep because we are keeping CU. */ - /* Add a dependence relationship from CU to REF_PER_CU. */ static void @@ -10104,7 +10992,8 @@ dwarf2_add_dependence (struct dwarf2_cu *cu, *slot = ref_per_cu; } -/* Set the mark field in CU and in every other compilation unit in the +/* Subroutine of dwarf2_mark to pass to htab_traverse. + Set the mark field in every compilation unit in the cache that we must keep because we are keeping CU. */ static int @@ -10123,6 +11012,9 @@ dwarf2_mark_helper (void **slot, void *data) return 1; } +/* Set the mark field in CU and in every other compilation unit in the + cache that we must keep because we are keeping CU. */ + static void dwarf2_mark (struct dwarf2_cu *cu) { @@ -10179,12 +11071,49 @@ show_dwarf2_cmd (char *args, int from_tty) cmd_show_list (show_dwarf2_cmdlist, from_tty, ""); } +/* If section described by INFO was mmapped, munmap it now. */ + +static void +munmap_section_buffer (struct dwarf2_section_info *info) +{ + if (info->was_mmapped) + { +#ifdef HAVE_MMAP + intptr_t begin = (intptr_t) info->buffer; + intptr_t map_begin = begin & ~(pagesize - 1); + size_t map_length = info->size + begin - map_begin; + gdb_assert (munmap ((void *) map_begin, map_length) == 0); +#else + /* Without HAVE_MMAP, we should never be here to begin with. */ + gdb_assert (0); +#endif + } +} + +/* munmap debug sections for OBJFILE, if necessary. */ + +static void +dwarf2_per_objfile_cleanup (struct objfile *objfile, void *d) +{ + struct dwarf2_per_objfile *data = d; + munmap_section_buffer (&data->info); + munmap_section_buffer (&data->abbrev); + munmap_section_buffer (&data->line); + munmap_section_buffer (&data->str); + munmap_section_buffer (&data->macinfo); + munmap_section_buffer (&data->ranges); + munmap_section_buffer (&data->loc); + munmap_section_buffer (&data->frame); + munmap_section_buffer (&data->eh_frame); +} + void _initialize_dwarf2_read (void); void _initialize_dwarf2_read (void) { - dwarf2_objfile_data_key = register_objfile_data (); + dwarf2_objfile_data_key + = register_objfile_data_with_cleanup (dwarf2_per_objfile_cleanup); add_prefix_cmd ("dwarf2", class_maintenance, set_dwarf2_cmd, _("\ Set DWARF 2 specific variables.\n\ @@ -10209,4 +11138,13 @@ caching, which can slow down startup."), show_dwarf2_max_cache_age, &set_dwarf2_cmdlist, &show_dwarf2_cmdlist); + + add_setshow_zinteger_cmd ("dwarf2-die", no_class, &dwarf2_die_debug, _("\ +Set debugging of the dwarf2 DIE reader."), _("\ +Show debugging of the dwarf2 DIE reader."), _("\ +When enabled (non-zero), DIEs are dumped after they are read in.\n\ +The value is the maximum depth to print."), + NULL, + NULL, + &setdebuglist, &showdebuglist); }