/* local data types */
-/* We hold several abbreviation tables in memory at the same time. */
+/* We hold several abbreviation tables in memory at the same time. */
#ifndef ABBREV_HASH_SIZE
#define ABBREV_HASH_SIZE 121
#endif
struct dwarf2_per_cu_data per_cu;
};
-/* Struct used to pass misc. parameters to read_die_and_children, et. al.
- which are used for both .debug_info and .debug_types dies.
- All parameters here are unchanging for the life of the call.
- This struct exists to abstract away the constant parameters of
- die reading. */
+/* Struct used to pass misc. parameters to read_die_and_children, et
+ al. which are used for both .debug_info and .debug_types dies.
+ All parameters here are unchanging for the life of the call. This
+ struct exists to abstract away the constant parameters of die
+ reading. */
struct die_reader_specs
{
};
/* When we construct a partial symbol table entry we only
- need this much information. */
+ need this much information. */
struct partial_die_info
{
/* Offset of this DIE. */
struct partial_die_info *die_parent, *die_child, *die_sibling;
};
-/* This data structure holds the information of an abbrev. */
+/* This data structure holds the information of an abbrev. */
struct abbrev_info
{
unsigned int number; /* number identifying abbrev */
ENUM_BITFIELD(dwarf_form) form : 16;
};
-/* Attributes have a name and a value */
+/* Attributes have a name and a value. */
struct attribute
{
ENUM_BITFIELD(dwarf_attribute) name : 16;
u;
};
-/* This data structure holds a complete die structure. */
+/* This data structure holds a complete die structure. */
struct die_info
{
/* DWARF-2 tag for this DIE. */
struct function_range *next;
};
-/* Get at parts of an attribute structure */
+/* Get at parts of an attribute structure. */
#define DW_STRING(attr) ((attr)->u.str)
#define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
#define DW_ADDR(attr) ((attr)->u.addr)
#define DW_SIGNATURED_TYPE(attr) ((attr)->u.signatured_type)
-/* Blocks are a bunch of untyped bytes. */
+/* Blocks are a bunch of untyped bytes. */
struct dwarf_block
{
unsigned int size;
in an instance of a field_info structure, as defined below. */
struct field_info
{
- /* List of data member and baseclasses fields. */
+ /* List of data member and baseclasses fields. */
struct nextfield
{
struct nextfield *next;
}
-/* Various complaints about symbol reading that don't abort the process */
+/* Various complaints about symbol reading that don't abort the process. */
static void
dwarf2_statement_list_fits_in_line_number_section_complaint (void)
#endif
}
+/* A helper function that decides whether a section is empty. */
+
+static int
+dwarf2_section_empty_p (struct dwarf2_section_info *info)
+{
+ return info->asection == NULL || info->size == 0;
+}
+
/* 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. */
info->was_mmapped = 0;
info->readin = 1;
- if (info->asection == NULL || info->size == 0)
+ if (dwarf2_section_empty_p (info))
return;
/* Check if the file has a 4-byte header indicating compression. */
bfd_get_filename (abfd));
}
+/* A helper function that returns the size of a section in a safe way.
+ If you are positive that the section has been read before using the
+ size, then it is safe to refer to the dwarf2_section_info object's
+ "size" field directly. In other cases, you must call this
+ function, because for compressed sections the size field is not set
+ correctly until the section has been read. */
+
+static bfd_size_type
+dwarf2_section_size (struct objfile *objfile,
+ struct dwarf2_section_info *info)
+{
+ if (!info->readin)
+ dwarf2_read_section (objfile, info);
+ return info->size;
+}
+
/* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
- SECTION_NAME. */
+ SECTION_NAME. */
void
dwarf2_get_section_info (struct objfile *objfile, const char *section_name,
else
gdb_assert_not_reached ("unexpected section");
- 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);
+ dwarf2_read_section (objfile, info);
*sectp = info->asection;
*bufp = info->buffer;
offset_type types_list_elements = 0;
int i;
- if (dwarf2_per_objfile->gdb_index.asection == NULL
- || dwarf2_per_objfile->gdb_index.size == 0)
+ if (dwarf2_section_empty_p (&dwarf2_per_objfile->gdb_index))
return 0;
/* Older elfutils strip versions could keep the section in the main
/* Version check. */
version = MAYBE_SWAP (*(offset_type *) addr);
/* Versions earlier than 3 emitted every copy of a psymbol. This
- causes the index to behave very poorly for certain requests. So,
- it seems better to just ignore such indices. */
- if (version < 3)
+ causes the index to behave very poorly for certain requests. Version 4
+ contained incomplete addrmap. So, it seems better to just ignore such
+ indices. */
+ if (version < 4)
return 0;
/* Indexes with higher version than the one supported by GDB may be no
longer backward compatible. */
- if (version > 3)
+ if (version > 4)
return 0;
map = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct mapped_index);
if (this_cu->from_debug_types)
info_ptr += 8 /*signature*/ + cu.header.offset_size;
init_cu_die_reader (&reader_specs, &cu);
- info_ptr = read_full_die (&reader_specs, &comp_unit_die, info_ptr,
- &has_children);
+ read_full_die (&reader_specs, &comp_unit_die, info_ptr,
+ &has_children);
lh = NULL;
slot = NULL;
if (dwarf2_read_index (objfile))
return 1;
- dwarf2_build_psymtabs (objfile);
return 0;
}
"(is %d, should be 2, 3, or 4) [in module %s]"), header->version,
bfd_get_filename (abfd));
- if (header->abbrev_offset >= dwarf2_per_objfile->abbrev.size)
+ if (header->abbrev_offset
+ >= dwarf2_section_size (dwarf2_per_objfile->objfile,
+ &dwarf2_per_objfile->abbrev))
error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
"(offset 0x%lx + 6) [in module %s]"),
(long) header->abbrev_offset,
struct attribute *attr;
CORE_ADDR best_lowpc = 0, best_highpc = 0;
struct die_reader_specs reader_specs;
+ const char *filename;
init_one_comp_unit (&cu, objfile);
back_to_inner = make_cleanup (free_stack_comp_unit, &cu);
/* Allocate a new partial symbol table structure. */
attr = dwarf2_attr (comp_unit_die, DW_AT_name, &cu);
+ if (attr == NULL || !DW_STRING (attr))
+ filename = "";
+ else
+ filename = DW_STRING (attr);
pst = start_psymtab_common (objfile, objfile->section_offsets,
- (attr != NULL) ? DW_STRING (attr) : "",
+ filename,
/* TEXTLOW and TEXTHIGH are set below. */
0,
objfile->global_psymbols.next,
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
- /* Store the function that reads in the rest of the symbol table */
+ /* Store the function that reads in the rest of the symbol table. */
pst->read_symtab = dwarf2_psymtab_to_symtab;
this_cu->v.psymtab = 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 not, there's no more debug_info for this comp unit. */
if (has_children)
{
struct partial_die_info *first_die;
/* 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 not, there's no more debug_info for this comp unit. */
if (has_children)
load_partial_dies (abfd, dwarf2_per_objfile->info.buffer, info_ptr, 0, cu);
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,
+ /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
mst_text, objfile); */
- psym = add_psymbol_to_list (actual_name, strlen (actual_name),
- built_actual_name,
- VAR_DOMAIN, LOC_BLOCK,
- &objfile->global_psymbols,
- 0, pdi->lowpc + baseaddr,
- cu->language, objfile);
+ add_psymbol_to_list (actual_name, strlen (actual_name),
+ built_actual_name,
+ VAR_DOMAIN, LOC_BLOCK,
+ &objfile->global_psymbols,
+ 0, pdi->lowpc + baseaddr,
+ cu->language, objfile);
}
else
{
- /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
+ /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
mst_file_text, objfile); */
- psym = add_psymbol_to_list (actual_name, strlen (actual_name),
- built_actual_name,
- VAR_DOMAIN, LOC_BLOCK,
- &objfile->static_psymbols,
- 0, pdi->lowpc + baseaddr,
- cu->language, objfile);
+ add_psymbol_to_list (actual_name, strlen (actual_name),
+ built_actual_name,
+ VAR_DOMAIN, LOC_BLOCK,
+ &objfile->static_psymbols,
+ 0, pdi->lowpc + baseaddr,
+ cu->language, objfile);
}
break;
case DW_TAG_constant:
list = &objfile->global_psymbols;
else
list = &objfile->static_psymbols;
- psym = add_psymbol_to_list (actual_name, strlen (actual_name),
- built_actual_name, VAR_DOMAIN, LOC_STATIC,
- list, 0, 0, cu->language, objfile);
-
+ add_psymbol_to_list (actual_name, strlen (actual_name),
+ built_actual_name, VAR_DOMAIN, LOC_STATIC,
+ list, 0, 0, cu->language, objfile);
}
break;
case DW_TAG_variable:
table building. */
if (pdi->locdesc || pdi->has_type)
- psym = add_psymbol_to_list (actual_name, strlen (actual_name),
- built_actual_name,
- VAR_DOMAIN, LOC_STATIC,
- &objfile->global_psymbols,
- 0, addr + baseaddr,
- cu->language, objfile);
+ add_psymbol_to_list (actual_name, strlen (actual_name),
+ built_actual_name,
+ VAR_DOMAIN, LOC_STATIC,
+ &objfile->global_psymbols,
+ 0, addr + baseaddr,
+ cu->language, objfile);
}
else
{
- /* Static Variable. Skip symbols without location descriptors. */
+ /* Static Variable. Skip symbols without location descriptors. */
if (pdi->locdesc == NULL)
{
if (built_actual_name)
xfree (actual_name);
return;
}
- /*prim_record_minimal_symbol (actual_name, addr + baseaddr,
+ /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
mst_file_data, objfile); */
- psym = add_psymbol_to_list (actual_name, strlen (actual_name),
- built_actual_name,
- VAR_DOMAIN, LOC_STATIC,
- &objfile->static_psymbols,
- 0, addr + baseaddr,
- cu->language, objfile);
+ add_psymbol_to_list (actual_name, strlen (actual_name),
+ built_actual_name,
+ VAR_DOMAIN, LOC_STATIC,
+ &objfile->static_psymbols,
+ 0, addr + baseaddr,
+ cu->language, objfile);
}
break;
case DW_TAG_typedef:
fputs_filtered ("and ", gdb_stdout);
wrap_here ("");
printf_filtered ("%s...", pst->dependencies[i]->filename);
- wrap_here (""); /* Flush output */
+ wrap_here (""); /* Flush output. */
gdb_flush (gdb_stdout);
}
psymtab_to_symtab_1 (pst->dependencies[i]);
xfree (prefixed_name);
}
else
- fputs_unfiltered (name ? name : "", buf);
+ fputs_unfiltered (name, buf);
/* Template parameters may be specified in the DIE's DW_AT_name, or
as children with DW_TAG_template_type_param or
if (cu->language == language_java)
{
/* For java, we must append the return type to method
- names. */
+ names. */
if (die->tag == DW_TAG_subprogram)
java_print_type (TYPE_TARGET_TYPE (type), "", buf,
0, 0);
not have a name. NAME may either be from a previous call to
dwarf2_name or NULL.
- The output string will be canonicalized (if C++/Java). */
+ The output string will be canonicalized (if C++/Java). */
static const char *
dwarf2_full_name (char *name, struct die_info *die, struct dwarf2_cu *cu)
if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL") != NULL)
cu->language = language_opencl;
- /* We assume that we're processing GCC output. */
+ /* We assume that we're processing GCC output. */
processing_gcc_compilation = 2;
processing_has_namespace_info = 0;
if (attr)
cu->producer = DW_STRING (attr);
- /* We assume that we're processing GCC output. */
+ /* We assume that we're processing GCC output. */
processing_gcc_compilation = 2;
processing_has_namespace_info = 0;
return 0;
}
+ if (range_beginning > range_end)
+ {
+ /* Inverted range entries are invalid. */
+ complaint (&symfile_complaints,
+ _("Invalid .debug_ranges data (inverted range)"));
+ return 0;
+ }
+
+ /* Empty range entries have no effect. */
+ if (range_beginning == range_end)
+ continue;
+
range_beginning += base;
range_end += base;
- if (ranges_pst != NULL && range_beginning < range_end)
+ if (ranges_pst != NULL)
addrmap_set_empty (objfile->psymtabs_addrmap,
range_beginning + baseaddr,
range_end - 1 + baseaddr,
}
}
- if (high < low)
+ /* read_partial_die has also the strict LOW < HIGH requirement. */
+ if (high <= low)
return 0;
/* When using the GNU linker, .gnu.linkonce. sections are used to
}
break;
default:
- /* Ignore. */
+ /* Ignore. */
break;
}
return;
}
+ if (start > end)
+ {
+ /* Inverted range entries are invalid. */
+ complaint (&symfile_complaints,
+ _("Invalid .debug_ranges data "
+ "(inverted range)"));
+ return;
+ }
+
+ /* Empty range entries have no effect. */
+ if (start == end)
+ continue;
+
record_block_range (block,
baseaddr + base + start,
baseaddr + base + end - 1);
struct dwarf2_cu *cu)
{
struct objfile *objfile = cu->objfile;
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
struct typedef_field_list *new_field;
struct attribute *attr;
struct typedef_field *fp;
case DW_VIRTUALITY_virtual:
case DW_VIRTUALITY_pure_virtual:
if (cu->language == language_ada)
- error ("unexpected virtuality in component of Ada type");
+ error (_("unexpected virtuality in component of Ada type"));
SET_TYPE_FIELD_VIRTUAL (type, nfields);
break;
}
struct type *this_type;
if (cu->language == language_ada)
- error ("unexpected member function in Ada type");
+ error (_("unexpected member function in Ada type"));
/* Get name of member function. */
fieldname = dwarf2_name (die, cu);
}
/* Create a new member function field and chain it to the field list
- entry. */
+ entry. */
new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
make_cleanup (xfree, new_fnfield);
memset (new_fnfield, 0, sizeof (struct nextfnfield));
/* Handle static member functions.
Dwarf2 has no clean way to discern C++ static and non-static
- member functions. G++ helps GDB by marking the first
- parameter for non-static member functions (which is the
- this pointer) as artificial. We obtain this information
- from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
+ member functions. G++ helps GDB by marking the first
+ parameter for non-static member functions (which is the this
+ pointer) as artificial. We obtain this information from
+ read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (this_type, 0) == 0)
fnp->voffset = VOFFSET_STATIC;
}
int i;
if (cu->language == language_ada)
- error ("unexpected member functions in Ada type");
+ error (_("unexpected member functions in Ada type"));
ALLOCATE_CPLUS_STRUCT_TYPE (type);
TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
/* We need to add the type field to the die immediately so we don't
infinitely recurse when dealing with pointers to the structure
- type within the structure itself. */
+ type within the structure itself. */
set_die_type (die, type, cu);
/* set_die_type should be already done. */
}
else if (child_die->tag == DW_TAG_subprogram)
{
- /* C++ member function. */
+ /* C++ member function. */
dwarf2_add_member_fn (&fi, child_die, type, cu);
}
else if (child_die->tag == DW_TAG_inheritance)
if (child_type != NULL)
{
- /* The range type was succesfully read. Save it for
- the array type creation. */
+ /* The range type was succesfully read. Save it for the
+ array type creation. */
if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
{
range_types = (struct type **)
if (name)
TYPE_NAME (type) = name;
- /* Install the type in the die. */
+ /* Install the type in the die. */
set_die_type (die, type, cu);
/* set_die_type should be already done. */
if (attr) return DW_SND (attr);
- /*
- GNU F77 is a special case, as at 08/2004 array type info is the
- opposite order to the dwarf2 specification, but data is still
- laid out as per normal fortran.
+ /* GNU F77 is a special case, as at 08/2004 array type info is the
+ opposite order to the dwarf2 specification, but data is still
+ laid out as per normal fortran.
- FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
- version checking.
- */
+ FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
+ version checking. */
if (cu->language == language_fortran
&& cu->producer && strstr (cu->producer, "GNU F77"))
}
/* Extract all information from a DW_TAG_set_type DIE and put it in
- the DIE's type field. */
+ the DIE's type field. */
static struct type *
read_set_type (struct die_info *die, struct dwarf2_cu *cu)
attr = dwarf2_attr (die, DW_AT_location, cu);
if (attr)
{
- /* Support the .debug_loc offsets */
+ /* Support the .debug_loc offsets. */
if (attr_form_is_block (attr))
{
base = decode_locdesc (DW_BLOCK (attr), cu);
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
type = read_type_die (die, cu);
new_symbol (die, type, cu);
- name = namespace_name (die, &is_anonymous, cu);
+ namespace_name (die, &is_anonymous, cu);
if (is_anonymous)
{
const char *previous_prefix = determine_prefix (die, cu);
}
else
{
- /* check for the DW_AT_byte_size attribute */
+ /* Check for the DW_AT_byte_size attribute. */
attr = dwarf2_attr (die, DW_AT_byte_size, cu);
if (attr)
{
int b;
};
- ('funcp' generates a DW_TAG_subroutine_type DIE)
- */
+ ('funcp' generates a DW_TAG_subroutine_type DIE). */
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 type *type; /* Type that this function returns. */
+ struct type *ftype; /* Function that returns above type. */
struct attribute *attr;
type = die_type (die, cu);
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 (attr)
+ TYPE_CALLING_CONVENTION (ftype) = DW_UNSND (attr);
+ else if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL"))
+ TYPE_CALLING_CONVENTION (ftype) = DW_CC_GDB_IBM_OpenCL;
+ else
+ TYPE_CALLING_CONVENTION (ftype) = DW_CC_normal;
/* We need to add the subroutine type to the die immediately so
we don't infinitely recurse when dealing with parameters
- declared as the same subroutine type. */
+ declared as the same subroutine type. */
set_die_type (die, ftype, cu);
if (die->child != NULL)
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;
int count = dwarf2_get_attr_constant_value (attr, 1);
high = low + count - 1;
}
+ else
+ {
+ /* Unspecified array length. */
+ high = low - 1;
+ }
}
/* Dwarf-2 specifications explicitly allows to create subrange types
For the following C code: `extern char gdb_int [];'
GCC produces an empty range DIE.
FIXME: muller/2010-05-28: Possible references to object for low bound,
- high bound or count are not yet handled by this code.
- */
+ high bound or count are not yet handled by this code. */
if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
{
struct objfile *objfile = cu->objfile;
if (attr && attr->form == DW_FORM_block1)
TYPE_HIGH_BOUND_UNDEFINED (range_type) = 1;
+ /* Ada expects an empty array on no boundary attributes. */
+ if (attr == NULL && cu->language != language_ada)
+ TYPE_HIGH_BOUND_UNDEFINED (range_type) = 1;
+
name = dwarf2_name (die, cu);
if (name)
TYPE_NAME (range_type) = name;
struct attr_abbrev *cur_attrs;
unsigned int allocated_attrs;
- /* Initialize dwarf2 abbrevs */
+ /* Initialize dwarf2 abbrevs. */
obstack_init (&cu->abbrev_obstack);
cu->dwarf2_abbrevs = obstack_alloc (&cu->abbrev_obstack,
(ABBREV_HASH_SIZE
allocated_attrs = ATTR_ALLOC_CHUNK;
cur_attrs = xmalloc (allocated_attrs * sizeof (struct attr_abbrev));
- /* loop until we reach an abbrev number of 0 */
+ /* Loop until we reach an abbrev number of 0. */
while (abbrev_number)
{
cur_abbrev = dwarf_alloc_abbrev (cu);
part_die->highpc = DW_ADDR (&attr);
break;
case DW_AT_location:
- /* Support the .debug_loc offsets */
+ /* Support the .debug_loc offsets. */
if (attr_form_is_block (&attr))
{
part_die->locdesc = DW_BLOCK (&attr);
}
}
- /* When using the GNU linker, .gnu.linkonce. sections are used to
- eliminate duplicate copies of functions and vtables and such.
- The linker will arbitrarily choose one and discard the others.
- The AT_*_pc values for such functions refer to local labels in
- these sections. If the section from that file was discarded, the
- labels are not in the output, so the relocs get a value of 0.
- If this is a discarded function, mark the pc bounds as invalid,
- so that GDB will ignore it. */
- if (has_low_pc_attr && has_high_pc_attr
- && part_die->lowpc < part_die->highpc
- && (part_die->lowpc != 0
- || dwarf2_per_objfile->has_section_at_zero))
- part_die->has_pc_info = 1;
+ if (has_low_pc_attr && has_high_pc_attr)
+ {
+ /* When using the GNU linker, .gnu.linkonce. sections are used to
+ eliminate duplicate copies of functions and vtables and such.
+ The linker will arbitrarily choose one and discard the others.
+ The AT_*_pc values for such functions refer to local labels in
+ these sections. If the section from that file was discarded, the
+ labels are not in the output, so the relocs get a value of 0.
+ If this is a discarded function, mark the pc bounds as invalid,
+ so that GDB will ignore it. */
+ if (part_die->lowpc == 0 && !dwarf2_per_objfile->has_section_at_zero)
+ {
+ struct gdbarch *gdbarch = get_objfile_arch (cu->objfile);
+
+ complaint (&symfile_complaints,
+ _("DW_AT_low_pc %s is zero "
+ "for DIE at 0x%x [in module %s]"),
+ paddress (gdbarch, part_die->lowpc),
+ part_die->offset, cu->objfile->name);
+ }
+ /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
+ else if (part_die->lowpc >= part_die->highpc)
+ {
+ struct gdbarch *gdbarch = get_objfile_arch (cu->objfile);
+
+ complaint (&symfile_complaints,
+ _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
+ "for DIE at 0x%x [in module %s]"),
+ paddress (gdbarch, part_die->lowpc),
+ paddress (gdbarch, part_die->highpc),
+ part_die->offset, cu->objfile->name);
+ }
+ else
+ part_die->has_pc_info = 1;
+ }
return info_ptr;
}
return read_attribute_value (attr, abbrev->form, abfd, info_ptr, cu);
}
-/* read dwarf information from a buffer */
+/* Read dwarf information from a buffer. */
static unsigned int
read_1_byte (bfd *abfd, gdb_byte *buf)
break;
default:
internal_error (__FILE__, __LINE__,
- _("read_address: bad switch, unsigned [in module %s]"),
+ _("read_address: bad switch, "
+ "unsigned [in module %s]"),
bfd_get_filename (abfd));
}
}
address increment value corresponding to special opcode
255. I.e., this value is scaled by the minimum
instruction length since special opcode 255 would have
- scaled the the increment. */
+ scaled the increment. */
case DW_LNS_const_add_pc:
{
CORE_ADDR adjust = (255 - lh->opcode_base) / lh->line_range;
case DW_TAG_constant:
case DW_TAG_variable:
case DW_TAG_member:
- /* Compilation with minimal debug info may result in variables
- with missing type entries. Change the misleading `void' type
- to something sensible. */
+ /* 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)
= objfile_type (objfile)->nodebug_data_symbol;
/* Not a tag we recognize. Hopefully we aren't processing
trash data, but since we must specifically ignore things
we don't recognize, there is nothing else we should do at
- this point. */
+ this point. */
complaint (&symfile_complaints, _("unsupported tag: '%s'"),
dwarf_tag_name (die->tag));
break;
/* Convert a DWARF stack opcode into its string name. */
const char *
-dwarf_stack_op_name (unsigned op, int def)
+dwarf_stack_op_name (unsigned op)
{
switch (op)
{
case DW_OP_GNU_implicit_pointer:
return "DW_OP_GNU_implicit_pointer";
default:
- return def ? "OP_<unknown>" : NULL;
+ return NULL;
}
}
}
}
-/* Convert a DWARF call frame info operation to its string name. */
+/* Convert a DWARF call frame info operation to its string name. */
#if 0
static char *
fprintf_unfiltered (f, "flag: TRUE");
break;
case DW_FORM_indirect:
- /* the reader will have reduced the indirect form to
- the "base form" so this form should not occur */
+ /* The reader will have reduced the indirect form to
+ the "base form" so this form should not occur. */
fprintf_unfiltered (f,
"unexpected attribute form: DW_FORM_indirect");
break;
break;
default:
- complaint (&symfile_complaints, _("unsupported stack op: '%s'"),
- dwarf_stack_op_name (op, 1));
+ {
+ const char *name = dwarf_stack_op_name (op);
+
+ if (name)
+ complaint (&symfile_complaints, _("unsupported stack op: '%s'"),
+ name);
+ else
+ complaint (&symfile_complaints, _("unsupported stack op: '%02x'"),
+ op);
+ }
+
return (stack[stacki]);
}
{
unsigned int bytes_read;
int constant;
- char *string;
constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
mac_ptr += bytes_read;
- string = read_direct_string (abfd, mac_ptr, &bytes_read);
+ read_direct_string (abfd, mac_ptr, &bytes_read);
mac_ptr += bytes_read;
/* We don't recognize any vendor extensions. */
}
/* Check if the attribute's form is a DW_FORM_block*
- if so return true else false. */
+ if so return true else false. */
static int
attr_form_is_block (struct attribute *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_section_size (dwarf2_per_objfile->objfile,
+ &dwarf2_per_objfile->loc))
{
struct dwarf2_loclist_baton *baton;
int previous_valid;
/* Index of the CU in the table of all CUs in the index file. */
unsigned int previous_cu_index;
- /* Start address of the CU. */
+ /* Start address of the CU. */
CORE_ADDR previous_cu_start;
};
total_len = size_of_contents;
/* The version number. */
- val = MAYBE_SWAP (3);
+ val = MAYBE_SWAP (4);
obstack_grow (&contents, &val, sizeof (val));
/* The offset of the CU list from the start of the file. */
1. The file header. This is a sequence of values, of offset_type
unless otherwise noted:
- [0] The version number, currently 3. Versions 1 and 2 are
+ [0] The version number, currently 4. Versions 1, 2 and 3 are
obsolete.
[1] The offset, from the start of the file, of the CU list.
[2] The offset, from the start of the file, of the types CU list.