/* DWARF 2 debugging format support for GDB.
- Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
- 2004, 2005, 2006
+ Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+ 2002, 2003, 2004, 2005, 2006
Free Software Foundation, Inc.
Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
/* A chain of compilation units that are currently read in, so that
they can be freed later. */
struct dwarf2_per_cu_data *read_in_chain;
+
+ /* A flag indicating wether this objfile has a section loaded at a
+ VMA of 0. */
+ int has_section_at_zero;
};
static struct dwarf2_per_objfile *dwarf2_per_objfile;
it. */
htab_t type_hash;
- /* The partial symbol table associated with this compilation unit. */
+ /* The partial symbol table associated with this compilation unit,
+ or NULL for partial units (which do not have an associated
+ symtab). */
struct partial_symtab *psymtab;
};
static void create_all_comp_units (struct objfile *);
-static struct dwarf2_cu *load_full_comp_unit (struct dwarf2_per_cu_data *);
+static struct dwarf2_cu *load_full_comp_unit (struct dwarf2_per_cu_data *,
+ struct objfile *);
static void process_full_comp_unit (struct dwarf2_per_cu_data *);
static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
+static void read_set_type (struct die_info *, struct dwarf2_cu *);
+
+
/* Try to locate the sections we need for DWARF 2 debugging
information and return true if we have enough to do something. */
in. */
static void
-dwarf2_locate_sections (bfd *ignore_abfd, asection *sectp, void *ignore_ptr)
+dwarf2_locate_sections (bfd *abfd, asection *sectp, void *ignore_ptr)
{
if (strcmp (sectp->name, INFO_SECTION) == 0)
{
dwarf2_per_objfile->ranges_size = bfd_get_section_size (sectp);
dwarf_ranges_section = 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. */
info_ptr = read_comp_unit_head (header, info_ptr, abfd);
- if (header->version != 2)
+ if (header->version != 2 && header->version != 3)
error (_("Dwarf Error: wrong version in compilation unit header "
"(is %d, should be %d) [in module %s]"), header->version,
2, bfd_get_filename (abfd));
info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read,
abfd, info_ptr, &cu);
+ if (comp_unit_die.tag == DW_TAG_partial_unit)
+ {
+ info_ptr = (beg_of_comp_unit + cu.header.length
+ + cu.header.initial_length_size);
+ do_cleanups (back_to_inner);
+ continue;
+ }
+
/* Set the language we're debugging */
set_cu_language (comp_unit_die.language, &cu);
{
/* Read in this compilation unit. This may add new items to
the end of the queue. */
- load_full_comp_unit (item->per_cu);
+ 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->psymtab->readin)
+ if (item->per_cu->type_hash)
reset_die_and_siblings_types (item->per_cu->cu->dies,
item->per_cu->cu);
}
them, one at a time, removing from the queue as we finish. */
for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
{
- if (!item->per_cu->psymtab->readin)
+ if (item->per_cu->psymtab && !item->per_cu->psymtab->readin)
process_full_comp_unit (item->per_cu);
item->per_cu->queued = 0;
/* Load the DIEs associated with PST and PER_CU into memory. */
static struct dwarf2_cu *
-load_full_comp_unit (struct dwarf2_per_cu_data *per_cu)
+load_full_comp_unit (struct dwarf2_per_cu_data *per_cu, struct objfile *objfile)
{
- struct partial_symtab *pst = per_cu->psymtab;
- bfd *abfd = pst->objfile->obfd;
+ bfd *abfd = objfile->obfd;
struct dwarf2_cu *cu;
unsigned long offset;
gdb_byte *info_ptr;
/* If an error occurs while loading, release our storage. */
free_cu_cleanup = make_cleanup (free_one_comp_unit, cu);
- cu->objfile = pst->objfile;
+ cu->objfile = objfile;
/* read in the comp_unit header */
info_ptr = read_comp_unit_head (&cu->header, info_ptr, abfd);
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;
labels are not in the output, so the relocs get a value of 0.
If this is a discarded function, mark the pc bounds as invalid,
so that GDB will ignore it. */
- if (low == 0 && (bfd_get_file_flags (obfd) & HAS_RELOC) == 0)
+ if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
return 0;
*lowpc = low;
return 0;
}
+/* GCC outputs unnamed structures that are really pointers to member
+ functions, with the ABI-specified layout. If DIE (from CU) describes
+ such a structure, set its type, and return nonzero. Otherwise return
+ zero.
+
+ GCC shouldn't do this; it should just output pointer to member DIEs.
+ This is GCC PR debug/28767. */
+
+static int
+quirk_gcc_member_function_pointer (struct die_info *die, struct dwarf2_cu *cu)
+{
+ struct objfile *objfile = cu->objfile;
+ struct type *type;
+ struct die_info *pfn_die, *delta_die;
+ struct attribute *pfn_name, *delta_name;
+ struct type *pfn_type, *domain_type;
+
+ /* Check for a structure with no name and two children. */
+ if (die->tag != DW_TAG_structure_type
+ || dwarf2_attr (die, DW_AT_name, cu) != NULL
+ || die->child == NULL
+ || die->child->sibling == NULL
+ || (die->child->sibling->sibling != NULL
+ && die->child->sibling->sibling->tag != DW_TAG_padding))
+ return 0;
+
+ /* Check for __pfn and __delta members. */
+ pfn_die = die->child;
+ pfn_name = dwarf2_attr (pfn_die, DW_AT_name, cu);
+ if (pfn_die->tag != DW_TAG_member
+ || pfn_name == NULL
+ || DW_STRING (pfn_name) == NULL
+ || strcmp ("__pfn", DW_STRING (pfn_name)) != 0)
+ return 0;
+
+ delta_die = pfn_die->sibling;
+ delta_name = dwarf2_attr (delta_die, DW_AT_name, cu);
+ if (delta_die->tag != DW_TAG_member
+ || delta_name == NULL
+ || DW_STRING (delta_name) == NULL
+ || strcmp ("__delta", DW_STRING (delta_name)) != 0)
+ return 0;
+
+ /* 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;
+
+ /* 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;
+
+ 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_pointer_type (type);
+ set_die_type (die, type, cu);
+
+ return 1;
+}
/* Called when we find the DIE that starts a structure or union scope
(definition) to process all dies that define the members of the
if (die->type)
return;
- type = alloc_type (objfile);
+ if (quirk_gcc_member_function_pointer (die, cu))
+ return;
+ type = alloc_type (objfile);
INIT_CPLUS_SPECIFIC (type);
attr = dwarf2_attr (die, DW_AT_name, cu);
if (attr && DW_STRING (attr))
if (attr)
TYPE_FLAGS (type) |= TYPE_FLAG_VECTOR;
+ attr = dwarf2_attr (die, DW_AT_name, cu);
+ if (attr && DW_STRING (attr))
+ TYPE_NAME (type) = DW_STRING (attr);
+
do_cleanups (back_to);
/* Install the type in the die. */
};
}
+/* Extract all information from a DW_TAG_set_type DIE and put it in
+ the DIE's type field. */
+
+static void
+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));
+}
/* First cut: install each common block member as a global variable. */
code = TYPE_CODE_FLT;
break;
case DW_ATE_signed:
- case DW_ATE_signed_char:
break;
case DW_ATE_unsigned:
- case DW_ATE_unsigned_char:
+ type_flags |= TYPE_FLAG_UNSIGNED;
+ break;
+ 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:
set_die_type (die, range_type, cu);
}
+static void
+read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
+{
+ struct type *type;
+ struct attribute *attr;
+
+ if (die->type)
+ return;
+
+ /* For now, we only support the C meaning of an unspecified type: void. */
+
+ attr = dwarf2_attr (die, DW_AT_name, cu);
+ type = init_type (TYPE_CODE_VOID, 0, 0, attr ? DW_STRING (attr) : "",
+ cu->objfile);
+
+ set_die_type (die, type, cu);
+}
/* Read a whole compilation unit into a linked list of dies. */
if (has_low_pc_attr && has_high_pc_attr
&& part_die->lowpc < part_die->highpc
&& (part_die->lowpc != 0
- || (bfd_get_file_flags (abfd) & HAS_RELOC)))
+ || dwarf2_per_objfile->has_section_at_zero))
part_die->has_pc_info = 1;
return info_ptr;
}
case DW_LANG_Ada95:
cu->language = language_ada;
break;
+ case DW_LANG_Modula2:
+ cu->language = language_m2;
+ break;
case DW_LANG_Cobol74:
case DW_LANG_Cobol85:
case DW_LANG_Pascal83:
- case DW_LANG_Modula2:
default:
cu->language = language_minimal;
break;
CORE_ADDR baseaddr;
struct objfile *objfile = cu->objfile;
const int decode_for_pst_p = (pst != NULL);
+ struct subfile *last_subfile = NULL;
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
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;
+ }
/* Append row to matrix using current values. */
record_line (current_subfile, line,
check_cu_functions (address, cu));
case DW_LNS_copy:
lh->file_names[file - 1].included_p = 1;
if (!decode_for_pst_p)
- record_line (current_subfile, line,
- check_cu_functions (address, cu));
+ {
+ 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));
+ }
basic_block = 0;
break;
case DW_LNS_advance_pc:
dir = lh->include_dirs[fe->dir_index - 1];
if (!decode_for_pst_p)
- dwarf2_start_subfile (fe->name, dir, comp_dir);
+ {
+ last_subfile = current_subfile;
+ dwarf2_start_subfile (fe->name, dir, comp_dir);
+ }
}
break;
case DW_LNS_set_column:
case DW_TAG_class_type:
case DW_TAG_structure_type:
case DW_TAG_union_type:
+ case DW_TAG_set_type:
case DW_TAG_enumeration_type:
SYMBOL_CLASS (sym) = LOC_TYPEDEF;
SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
case DW_TAG_array_type:
read_array_type (die, cu);
break;
+ case DW_TAG_set_type:
+ read_set_type (die, cu);
+ break;
case DW_TAG_pointer_type:
read_tag_pointer_type (die, cu);
break;
case DW_TAG_base_type:
read_base_type (die, cu);
break;
+ case DW_TAG_unspecified_type:
+ read_unspecified_type (die, cu);
+ break;
default:
- complaint (&symfile_complaints, _("unexepected tag in read_type_die: '%s'"),
+ complaint (&symfile_complaints, _("unexpected tag in read_type_die: '%s'"),
dwarf_tag_name (die->tag));
break;
}
dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
struct dwarf2_cu *cu)
{
- if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
+ if ((attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
+ /* ".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)
{
struct dwarf2_loclist_baton *baton;
projects / deliverable / binutils-gdb.git / blobdiff