X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fdwarf2read.c;h=ba863fef1d1beff62641816cdbb2c449162727c3;hb=74531fed1f2d662debc2c209b8b3faddceb55960;hp=1deadf1196ed9ce1818946cf686fe10044f1e291;hpb=03dd20cc6c4739481dc1cfc5549dd63961e66181;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c index 1deadf1196..ba863fef1d 100644 --- a/gdb/dwarf2read.c +++ b/gdb/dwarf2read.c @@ -141,6 +141,15 @@ typedef struct statement_prologue } _STATEMENT_PROLOGUE; +/* When non-zero, dump DIEs after they are read in. */ +static int dwarf2_die_debug = 0; + +/* 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_per_objfile @@ -225,11 +234,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; @@ -241,22 +250,9 @@ 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; }; /* Internal state when decoding a particular compilation unit. */ @@ -265,12 +261,15 @@ 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. */ @@ -300,7 +299,7 @@ struct dwarf2_cu htab_t partial_dies; /* `.debug_ranges' offset for this `DW_TAG_compile_unit' DIE. */ - unsigned long ranges_offset; + unsigned int ranges_offset; /* Storage for things with the same lifetime as this read-in compilation unit, including partial DIEs. */ @@ -364,13 +363,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 @@ -517,15 +518,15 @@ 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; }; /* 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; @@ -540,10 +541,17 @@ struct attribute /* This data structure holds a complete die structure. */ struct die_info { - enum dwarf_tag tag; /* Tag indicating type of die */ - unsigned int abbrev; /* Abbrev number */ - unsigned int offset; /* Offset in .debug_info section */ - unsigned int num_attrs; /* Number of attributes */ + /* 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 @@ -761,6 +769,10 @@ static void add_partial_namespace (struct partial_die_info *pdi, 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, + struct dwarf2_cu *cu); + static gdb_byte *locate_pdi_sibling (struct partial_die_info *orig_pdi, gdb_byte *info_ptr, bfd *abfd, @@ -789,7 +801,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 *, @@ -817,11 +829,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); @@ -848,7 +865,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); @@ -924,7 +941,8 @@ static void dwarf2_attach_fn_fields_to_type (struct field_info *, 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 *); @@ -942,6 +960,11 @@ static enum dwarf_array_dim_ordering read_array_order (struct die_info *, 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, @@ -959,7 +982,7 @@ static char *dwarf2_linkage_name (struct die_info *, struct dwarf2_cu *); 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); @@ -979,21 +1002,25 @@ static char *dwarf_cfi_name (unsigned int); 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 (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 *); + struct dwarf2_cu **); /* memory allocation interface */ @@ -1031,10 +1058,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 *); @@ -1286,11 +1313,9 @@ dwarf2_build_psymtabs_easy (struct objfile *objfile, int mainline) pubnames_ptr = pubnames_buffer; 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; @@ -1306,6 +1331,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. */ @@ -1315,13 +1352,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; @@ -1330,6 +1369,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; } @@ -1486,8 +1526,7 @@ dwarf2_build_psymtabs_hard (struct objfile *objfile, int mainline) /* 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.first_die_offset = info_ptr - beg_of_comp_unit; cu.list_in_scope = &file_symbols; @@ -1522,7 +1561,9 @@ dwarf2_build_psymtabs_hard (struct objfile *objfile, int mainline) 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; @@ -1651,8 +1692,7 @@ load_comp_unit (struct dwarf2_per_cu_data *this_cu, struct objfile *objfile) /* 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.first_die_offset = info_ptr - beg_of_comp_unit; /* Read the abbrevs for this compilation unit into a table. */ dwarf2_read_abbrevs (abfd, cu); @@ -1700,26 +1740,24 @@ create_all_comp_units (struct objfile *objfile) 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; /* 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) { @@ -1774,21 +1812,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, cu); break; case DW_TAG_variable: case DW_TAG_typedef: @@ -2138,6 +2162,51 @@ add_partial_namespace (struct partial_die_info *pdi, scan_partial_symbols (pdi->die_child, lowpc, highpc, 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, + 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 (!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, cu); + pdi = pdi->die_sibling; + } + } +} + /* See if we can figure out if the class lives in a namespace. We do this by looking for a member function; its demangled name will contain namespace info, if there is any. */ @@ -2292,7 +2361,7 @@ skip_one_die (gdb_byte *info_ptr, struct abbrev_info *abbrev, complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling")); else return dwarf2_per_objfile->info_buffer - + dwarf2_get_ref_die_offset (&attr, cu); + + dwarf2_get_ref_die_offset (&attr); } /* If it isn't DW_AT_sibling, skip this attribute. */ @@ -2555,7 +2624,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; @@ -2629,9 +2698,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); @@ -2643,22 +2709,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; } } @@ -2754,10 +2820,10 @@ process_die (struct die_info *die, struct dwarf2_cu *cu) 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. */ + Fortran case. */ processing_has_namespace_info = 1; - gdb_assert (die->child == NULL); + complaint (&symfile_complaints, _("unsupported tag: '%s'"), + dwarf_tag_name (die->tag)); break; default: new_symbol (die, NULL, cu); @@ -2765,6 +2831,44 @@ 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; +} + static void initialize_cu_func_list (struct dwarf2_cu *cu) { @@ -2850,6 +2954,8 @@ read_file_scope (struct die_info *die, struct dwarf2_cu *cu) /* We assume that we're processing GCC output. */ processing_gcc_compilation = 2; + processing_has_namespace_info = 0; + start_symtab (name, comp_dir, lowpc); record_debugformat ("DWARF 2"); record_producer (cu->producer); @@ -2929,8 +3035,6 @@ read_func_scope (struct die_info *die, struct dwarf2_cu *cu) struct die_info *child_die; struct attribute *attr; char *name; - const char *previous_prefix = processing_current_prefix; - struct cleanup *back_to = NULL; CORE_ADDR baseaddr; struct block *block; @@ -2943,41 +3047,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; @@ -3019,6 +3088,12 @@ read_func_scope (struct die_info *die, struct dwarf2_cu *cu) 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); @@ -3033,10 +3108,6 @@ read_func_scope (struct die_info *die, struct dwarf2_cu *cu) 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 @@ -3121,8 +3192,8 @@ dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return, CORE_ADDR high = 0; CORE_ADDR baseaddr; - found_base = cu_header->base_known; - base = cu_header->base_address; + found_base = cu->base_known; + base = cu->base_address; if (offset >= dwarf2_per_objfile->ranges_size) { @@ -3283,6 +3354,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. */ @@ -3309,11 +3417,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 @@ -3389,8 +3493,8 @@ dwarf2_record_block_ranges (struct die_info *die, struct block *block, '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->header.base_address; - int base_known = cu->header.base_known; + CORE_ADDR base = cu->base_address; + int base_known = cu->base_known; if (offset >= dwarf2_per_objfile->ranges_size) { @@ -3487,7 +3591,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); @@ -3516,10 +3620,8 @@ dwarf2_add_field (struct field_info *fip, struct die_info *die, else byte_offset = decode_locdesc (DW_BLOCK (attr), cu); - FIELD_BITPOS (*fp) = byte_offset * bits_per_byte; + 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) { @@ -3611,10 +3713,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++; @@ -3988,9 +4089,8 @@ 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); type = quirk_gcc_member_function_pointer (die, cu); if (type) @@ -4004,12 +4104,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 { @@ -4044,9 +4140,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 @@ -4057,7 +4153,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)); @@ -4157,14 +4252,9 @@ 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; } @@ -4172,15 +4262,12 @@ 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; this_type = get_die_type (die, cu); if (this_type == NULL) this_type = read_structure_type (die, cu); - if (TYPE_TAG_NAME (this_type) != NULL) - processing_current_prefix = TYPE_TAG_NAME (this_type); /* 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 @@ -4209,8 +4296,6 @@ process_structure_scope (struct die_info *die, struct dwarf2_cu *cu) if (dwarf2_attr (die, DW_AT_byte_size, cu) != NULL || !die_is_declaration (die, cu)) new_symbol (die, this_type, cu); - - processing_current_prefix = previous_prefix; } /* Given a DW_AT_enumeration_type die, set its type. We do not @@ -4222,27 +4307,14 @@ read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu) struct objfile *objfile = cu->objfile; struct type *type; struct attribute *attr; - char *name; + 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) @@ -4260,31 +4332,19 @@ read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu) Types. When another package uses such a type, an incomplete DIE may be generated by the compiler. */ if (die_is_declaration (die, cu)) - TYPE_FLAGS (type) |= TYPE_FLAG_STUB; + 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 @@ -4299,27 +4359,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; } @@ -4373,11 +4431,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++; } @@ -4396,7 +4453,7 @@ process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu) xfree (fields); } if (unsigned_enum) - TYPE_FLAGS (this_type) |= TYPE_FLAG_UNSIGNED; + TYPE_UNSIGNED (this_type) = 1; } new_symbol (die, this_type, cu); @@ -4584,55 +4641,74 @@ 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 (TYPE_NAME (type), + strlen (previous_prefix), + strlen (TYPE_NAME (type))); + } } if (die->child != NULL) @@ -4645,9 +4721,6 @@ 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); } /* Return the name of the namespace represented by DIE. Set @@ -4664,7 +4737,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) @@ -4718,7 +4791,8 @@ read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu) type_flags = gdbarch_address_class_type_flags (gdbarch, byte_size, addr_class); - gdb_assert ((type_flags & ~TYPE_FLAG_ADDRESS_CLASS_ALL) == 0); + 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) @@ -4865,7 +4939,7 @@ 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 @@ -4888,7 +4962,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); } @@ -4927,12 +5001,13 @@ 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; - name = dwarf2_name (die, cu); + name = dwarf2_full_name (die, cu); this_type = init_type (TYPE_CODE_TYPEDEF, 0, - TYPE_FLAG_TARGET_STUB, name, objfile); + 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; @@ -5012,9 +5087,13 @@ read_base_type (struct die_info *die, struct dwarf2_cu *cu) break; } - type = init_type (code, size, type_flags, name, objfile); + 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); } @@ -5096,8 +5175,8 @@ read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu) /* 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); return set_die_type (die, type, cu); } @@ -5140,6 +5219,27 @@ read_comp_unit (gdb_byte *info_ptr, bfd *abfd, struct dwarf2_cu *cu) 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 @@ -5147,10 +5247,10 @@ 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; @@ -5199,7 +5299,7 @@ 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 (die == NULL) { @@ -5577,6 +5677,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) @@ -5699,9 +5800,14 @@ 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 @@ -5710,7 +5816,10 @@ load_partial_dies (bfd *abfd, gdb_byte *info_ptr, int building_psymtab, && (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; @@ -5840,7 +5949,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 @@ -5849,7 +5958,7 @@ read_partial_die (struct partial_die_info *part_die, complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling")); else part_die->sibling = dwarf2_per_objfile->info_buffer - + dwarf2_get_ref_die_offset (&attr, cu); + + dwarf2_get_ref_die_offset (&attr); break; case DW_AT_stmt_list: part_die->has_stmt_list = 1; @@ -5896,11 +6005,11 @@ read_partial_die (struct partial_die_info *part_die, || dwarf2_per_objfile->has_section_at_zero)) part_die->has_pc_info = 1; - if (base_address_type != base_address_none && !cu->header.base_known) + if (base_address_type != base_address_none && !cu->base_known) { gdb_assert (part_die->tag == DW_TAG_compile_unit); - cu->header.base_known = 1; - cu->header.base_address = base_address; + cu->base_known = 1; + cu->base_address = base_address; } return info_ptr; @@ -5909,7 +6018,7 @@ read_partial_die (struct partial_die_info *part_die, /* 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; @@ -5923,13 +6032,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) @@ -5965,7 +6073,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, @@ -5979,7 +6089,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; } @@ -6337,12 +6447,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 @@ -6360,8 +6465,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); @@ -6381,22 +6485,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; } @@ -6406,22 +6522,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)); } @@ -6459,8 +6583,7 @@ 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) { @@ -6616,7 +6739,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; } @@ -6648,17 +6774,19 @@ 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. */ 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) 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 @@ -6754,7 +6882,7 @@ 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; @@ -6781,7 +6909,8 @@ dwarf_decode_line_header (unsigned int offset, bfd *abfd, /* 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)) @@ -6792,8 +6921,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); @@ -7542,13 +7671,7 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu) } 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); @@ -7560,13 +7683,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) { @@ -7599,6 +7716,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); } @@ -7617,7 +7741,7 @@ dwarf2_const_value (struct attribute *attr, struct symbol *sym, { 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))); @@ -7641,7 +7765,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))); @@ -7729,12 +7853,12 @@ die_type (struct die_info *die, struct dwarf2_cu *cu) return builtin_type (gdbarch)->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); } @@ -7754,13 +7878,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); } @@ -7775,7 +7899,7 @@ tag_type_to_type (struct die_info *die, struct dwarf2_cu *cu) this_type = read_type_die (die, cu); if (!this_type) { - dump_die (die); + dump_die_for_error (die); error (_("Dwarf Error: Cannot find type of die [in module %s]"), cu->objfile->name); } @@ -7785,20 +7909,12 @@ tag_type_to_type (struct die_info *die, struct dwarf2_cu *cu) static struct type * read_type_die (struct die_info *die, struct dwarf2_cu *cu) { - char *prefix; - const char *old_prefix; - struct cleanup *back_to; struct type *this_type; this_type = get_die_type (die, cu); if (this_type) return this_type; - prefix = determine_prefix (die, cu); - old_prefix = processing_current_prefix; - back_to = make_cleanup (xfree, prefix); - processing_current_prefix = prefix; - switch (die->tag) { case DW_TAG_class_type: @@ -7850,91 +7966,98 @@ read_type_die (struct die_info *die, struct dwarf2_cu *cu) case DW_TAG_unspecified_type: 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'"), dwarf_tag_name (die->tag)); 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. + + For example, if we're within the method foo() in the following + code: + + namespace N { + class C { + void foo () { + } + }; + } -/* 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. */ + 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; - - parent = die->parent; - - if (parent == NULL) + return ""; + + /* 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. */ + 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? */ - struct type *parent_type = get_die_type (parent, cu); - 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: - { - struct type *parent_type = get_die_type (parent, cu); - 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 @@ -7958,19 +8081,17 @@ 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 @@ -8018,18 +8139,19 @@ dwarf2_name (struct die_info *die, struct dwarf2_cu *cu) } /* 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. */ @@ -8370,10 +8492,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: @@ -8394,10 +8517,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: @@ -8993,38 +9117,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: "); - fputs_filtered (paddress (DW_ADDR (&die->attrs[i])), gdb_stderr); + fprintf_unfiltered (f, "address: "); + fputs_filtered (paddress (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: @@ -9033,46 +9171,82 @@ 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\"", + 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) { - dump_die (die); - if (die->child != NULL) - dump_die_list (die->child); - if (die->sibling != NULL) - dump_die_list (die->sibling); + 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_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 (struct die_info *die, struct dwarf2_cu *cu) { @@ -9084,7 +9258,7 @@ store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu) } 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; @@ -9157,21 +9331,19 @@ maybe_queue_comp_unit (struct dwarf2_cu *this_cu, 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; 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); @@ -9181,6 +9353,7 @@ follow_die_ref (struct die_info *src_die, struct attribute *attr, else target_cu = cu; + *ref_cu = target_cu; temp_die.offset = offset; die = htab_find_with_hash (target_cu->die_hash, &temp_die, offset); if (die) @@ -9925,8 +10098,8 @@ dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym, 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->base_address = cu->base_address; + if (cu->base_known == 0) complaint (&symfile_complaints, _("Location list used without specifying the CU base address.")); @@ -10006,7 +10179,7 @@ dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data *per_cu) 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; @@ -10038,7 +10211,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; } @@ -10048,12 +10221,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; } @@ -10415,4 +10588,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); }