/* DWARF 2 debugging format support for GDB.
Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
- 2004, 2005, 2006, 2007, 2008, 2009, 2010
+ 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
/* 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;
show_dwarf2_max_cache_age (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("\
-The upper bound on the age of cached dwarf2 compilation units is %s.\n"),
+ fprintf_filtered (file, _("The upper bound on the age of cached "
+ "dwarf2 compilation units is %s.\n"),
value);
}
-/* 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)
dwarf2_debug_line_missing_end_sequence_complaint (void)
{
complaint (&symfile_complaints,
- _(".debug_line section has line program sequence without an end"));
+ _(".debug_line section has line "
+ "program sequence without an end"));
}
static void
int arg3)
{
complaint (&symfile_complaints,
- _("const value length mismatch for '%s', got %d, expected %d"), arg1,
- arg2, arg3);
+ _("const value length mismatch for '%s', got %d, expected %d"),
+ arg1, arg2, arg3);
}
static void
dwarf2_macro_malformed_definition_complaint (const char *arg1)
{
complaint (&symfile_complaints,
- _("macro debug info contains a malformed macro definition:\n`%s'"),
+ _("macro debug info contains a "
+ "malformed macro definition:\n`%s'"),
arg1);
}
dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
{
complaint (&symfile_complaints,
- _("invalid attribute class or form for '%s' in '%s'"), arg1, arg2);
+ _("invalid attribute class or form for '%s' in '%s'"),
+ arg1, arg2);
}
/* local function prototypes */
static int need_gnat_info (struct dwarf2_cu *);
-static struct type *die_descriptive_type (struct die_info *, struct dwarf2_cu *);
+static struct type *die_descriptive_type (struct die_info *,
+ struct dwarf2_cu *);
static void set_descriptive_type (struct type *, struct die_info *,
struct dwarf2_cu *);
struct dwarf2_cu *);
static void dwarf2_attach_fn_fields_to_type (struct field_info *,
- struct type *, struct dwarf2_cu *);
+ struct type *,
+ struct dwarf2_cu *);
static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
int header_size = 12;
if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
- || bfd_bread (compressed_buffer, compressed_size, abfd) != compressed_size)
+ || bfd_bread (compressed_buffer,
+ compressed_size, abfd) != compressed_size)
error (_("Dwarf Error: Can't read DWARF data from '%s'"),
bfd_get_filename (abfd));
#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,
if (dwarf2_die_debug)
fprintf_unfiltered (gdb_stdlog, "Signatured types:\n");
- while (info_ptr < dwarf2_per_objfile->types.buffer + dwarf2_per_objfile->types.size)
+ while (info_ptr < dwarf2_per_objfile->types.buffer
+ + dwarf2_per_objfile->types.size)
{
unsigned int offset;
unsigned int offset_size;
> dwarf2_per_objfile->types.buffer + dwarf2_per_objfile->types.size)
{
complaint (&symfile_complaints,
- _("debug type entry runs off end of `.debug_types' section, ignored"));
+ _("debug type entry runs off end "
+ "of `.debug_types' section, ignored"));
break;
}
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;
{
struct dwarf2_per_cu_data *this_cu;
- this_cu = dwarf2_find_comp_unit (info_ptr - dwarf2_per_objfile->info.buffer,
+ this_cu = dwarf2_find_comp_unit (info_ptr
+ - dwarf2_per_objfile->info.buffer,
objfile);
info_ptr = process_psymtab_comp_unit (objfile, this_cu,
/* 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);
all_comp_units = xmalloc (n_allocated
* sizeof (struct dwarf2_per_cu_data *));
- while (info_ptr < dwarf2_per_objfile->info.buffer + dwarf2_per_objfile->info.size)
+ while (info_ptr < dwarf2_per_objfile->info.buffer
+ + dwarf2_per_objfile->info.size)
{
unsigned int length, initial_length_size;
struct dwarf2_per_cu_data *this_cu;
if (grandparent_scope == NULL)
parent->scope = parent->name;
else
- parent->scope = typename_concat (&cu->comp_unit_obstack, grandparent_scope,
+ parent->scope = typename_concat (&cu->comp_unit_obstack,
+ grandparent_scope,
parent->name, 0, cu);
}
else if (parent->tag == DW_TAG_enumerator)
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:
abbrev = dwarf2_lookup_abbrev (abbrev_number, cu);
if (!abbrev)
{
- error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"), abbrev_number,
- bfd_get_filename (abfd));
+ error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"),
+ abbrev_number, bfd_get_filename (abfd));
}
return abbrev;
read_attribute (&attr, &abbrev->attrs[i],
abfd, info_ptr, cu);
if (attr.form == DW_FORM_ref_addr)
- complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling"));
+ complaint (&symfile_complaints,
+ _("ignoring absolute DW_AT_sibling"));
else
return buffer + dwarf2_get_ref_die_offset (&attr);
}
goto skip_attribute;
default:
- error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
+ error (_("Dwarf Error: Cannot handle %s "
+ "in DWARF reader [in module %s]"),
dwarf_form_name (form),
bfd_get_filename (abfd));
}
{
if (pst->readin)
{
- warning (_("bug: psymtab for %s is already read in."), pst->filename);
+ warning (_("bug: psymtab for %s is already read in."),
+ pst->filename);
}
else
{
if (info_verbose)
{
- printf_filtered (_("Reading in symbols for %s..."), pst->filename);
+ printf_filtered (_("Reading in symbols for %s..."),
+ pst->filename);
gdb_flush (gdb_stdout);
}
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]);
/* Load the DIEs associated with PER_CU into memory. */
static void
-load_full_comp_unit (struct dwarf2_per_cu_data *per_cu, struct objfile *objfile)
+load_full_comp_unit (struct dwarf2_per_cu_data *per_cu,
+ struct objfile *objfile)
{
bfd *abfd = objfile->obfd;
struct dwarf2_cu *cu;
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 (attr == NULL)
{
complaint (&symfile_complaints,
- _("template parameter missing DW_AT_const_value"));
+ _("template parameter missing "
+ "DW_AT_const_value"));
fputs_unfiltered ("UNKNOWN_VALUE", buf);
continue;
}
else
v = value_from_longest (type, value);
- /* Specify decimal so that we do not depend on the radix. */
+ /* Specify decimal so that we do not depend on
+ the radix. */
get_formatted_print_options (&opts, 'd');
opts.raw = 1;
value_print (v, buf, &opts);
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);
if (TYPE_NFIELDS (type) > 0
&& TYPE_FIELD_ARTIFICIAL (type, 0)
&& TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_PTR
- && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0))))
+ && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type,
+ 0))))
fputs_unfiltered (" const", buf);
}
}
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;
}
/* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
- Inherit only the children of the DW_AT_abstract_origin DIE not being already
- referenced by DW_AT_abstract_origin from the children of the current DIE. */
+ Inherit only the children of the DW_AT_abstract_origin DIE not being
+ already referenced by DW_AT_abstract_origin from the children of the
+ current DIE. */
static void
inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu)
unsigned_int_compar);
for (offsetp = offsets + 1; offsetp < offsets_end; offsetp++)
if (offsetp[-1] == *offsetp)
- complaint (&symfile_complaints, _("Multiple children of DIE 0x%x refer "
- "to DIE 0x%x as their abstract origin"),
+ complaint (&symfile_complaints,
+ _("Multiple children of DIE 0x%x refer "
+ "to DIE 0x%x as their abstract origin"),
die->offset, *offsetp);
offsetp = offsets;
attr = dwarf2_attr (die, DW_AT_external, cu);
if (!attr || !DW_UNSND (attr))
complaint (&symfile_complaints,
- _("cannot get low and high bounds for subprogram DIE at %d"),
+ _("cannot get low and high bounds "
+ "for subprogram DIE at %d"),
die->offset);
return;
}
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,
+ range_beginning + baseaddr,
+ range_end - 1 + baseaddr,
ranges_pst);
/* FIXME: This is recording everything as a low-high
}
}
- 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;
}
if (!base_known)
{
complaint (&symfile_complaints,
- _("Invalid .debug_ranges data (no base address)"));
+ _("Invalid .debug_ranges data "
+ "(no base address)"));
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;
TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
}
- /* Copy the saved-up fields into the field vector. Start from the head
- of the list, adding to the tail of the field array, so that they end
- up in the same order in the array in which they were added to the list. */
+ /* Copy the saved-up fields into the field vector. Start from the head of
+ the list, adding to the tail of the field array, so that they end up in
+ the same order in the array in which they were added to the list. */
while (nfields-- > 0)
{
struct nextfield *fieldp;
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;
}
if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
fnp->fcontext = die_containing_type (die, cu);
- /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
- and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
+ /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
+ is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
/* Get accessibility. */
attr = dwarf2_attr (die, DW_AT_accessibility, cu);
{
/* GCC does this, as of 2008-08-25; PR debug/37237. */
complaint (&symfile_complaints,
- _("Member function \"%s\" (offset %d) is virtual but the vtable offset is not specified"),
+ _("Member function \"%s\" (offset %d) is virtual "
+ "but the vtable offset is not specified"),
fieldname, die->offset);
ALLOCATE_CPLUS_STRUCT_TYPE (type);
TYPE_CPLUS_DYNAMIC (type) = 1;
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)
/* Complain if virtual function table field not found. */
if (i < TYPE_N_BASECLASSES (t))
complaint (&symfile_complaints,
- _("virtual function table pointer not found when defining class '%s'"),
+ _("virtual function table pointer "
+ "not found when defining class '%s'"),
TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
"");
}
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 (DW_UNSND (attr) >= TYPE_LENGTH (type))
TYPE_LENGTH (type) = DW_UNSND (attr);
else
- complaint (&symfile_complaints, _("\
-DW_AT_byte_size for array type smaller than the total size of elements"));
+ complaint (&symfile_complaints,
+ _("DW_AT_byte_size for array type smaller "
+ "than the total size of elements"));
}
name = dwarf2_name (die, cu);
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);
module_name = dwarf2_name (die, cu);
if (!module_name)
- complaint (&symfile_complaints, _("DW_TAG_module has no name, offset 0x%x"),
+ complaint (&symfile_complaints,
+ _("DW_TAG_module has no name, offset 0x%x"),
die->offset);
type = init_type (TYPE_CODE_MODULE, 0, 0, module_name, objfile);
}
else if (TYPE_LENGTH (type) != byte_size)
{
- complaint (&symfile_complaints, _("invalid pointer size %d"), byte_size);
+ complaint (&symfile_complaints,
+ _("invalid pointer size %d"), byte_size);
}
else
{
}
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);
&& parent_die->has_specification == 0)
{
if (part_die->name == NULL)
- complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
+ complaint (&symfile_complaints,
+ _("malformed enumerator DIE ignored"));
else if (building_psymtab)
add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
VAR_DOMAIN, LOC_CONST,
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);
/* Ignore absolute siblings, they might point outside of
the current compile unit. */
if (attr.form == DW_FORM_ref_addr)
- complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling"));
+ complaint (&symfile_complaints,
+ _("ignoring absolute DW_AT_sibling"));
else
part_die->sibling = buffer + dwarf2_get_ref_die_offset (&attr);
break;
}
}
- /* 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;
}
if (pd == NULL)
internal_error (__FILE__, __LINE__,
- _("could not find partial DIE 0x%x 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;
}
if (cu->header.version == 2)
DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
else
- DW_ADDR (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
+ DW_ADDR (attr) = read_offset (abfd, info_ptr,
+ &cu->header, &bytes_read);
info_ptr += bytes_read;
break;
case DW_FORM_addr:
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));
}
}
}
if (str_offset >= dwarf2_per_objfile->str.size)
{
- error (_("DW_FORM_strp pointing outside of .debug_str section [in module %s]"),
- bfd_get_filename (abfd));
+ error (_("DW_FORM_strp pointing outside of "
+ ".debug_str section [in module %s]"),
+ bfd_get_filename (abfd));
return NULL;
}
gdb_assert (HOST_CHAR_BIT == 8);
{
lh->maximum_ops_per_instruction = 1;
complaint (&symfile_complaints,
- _("invalid maximum_ops_per_instruction in `.debug_line' section"));
+ _("invalid maximum_ops_per_instruction "
+ "in `.debug_line' section"));
}
lh->default_is_stmt = read_1_byte (abfd, line_ptr);
if (line_ptr > (dwarf2_per_objfile->line.buffer
+ dwarf2_per_objfile->line.size))
complaint (&symfile_complaints,
- _("line number info header doesn't fit in `.debug_line' section"));
+ _("line number info header doesn't "
+ "fit in `.debug_line' section"));
discard_cleanups (back_to);
return lh;
return include_name;
}
+/* Ignore this record_line request. */
+
+static void
+noop_record_line (struct subfile *subfile, int line, CORE_ADDR pc)
+{
+ return;
+}
+
/* Decode the Line Number Program (LNP) for the given line_header
structure and CU. The actual information extracted and the type
of structures created from the LNP depends on the value of PST.
struct gdbarch *gdbarch = get_objfile_arch (objfile);
const int decode_for_pst_p = (pst != NULL);
struct subfile *last_subfile = NULL, *first_subfile = current_subfile;
+ void (*p_record_line) (struct subfile *subfile, int line, CORE_ADDR pc)
+ = record_line;
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
{
addr = gdbarch_addr_bits_remove (gdbarch, address);
if (last_subfile)
- record_line (last_subfile, 0, addr);
+ (*p_record_line) (last_subfile, 0, addr);
last_subfile = current_subfile;
}
/* Append row to matrix using current values. */
addr = check_cu_functions (address, cu);
addr = gdbarch_addr_bits_remove (gdbarch, addr);
- record_line (current_subfile, line, addr);
+ (*p_record_line) (current_subfile, line, addr);
}
}
basic_block = 0;
else switch (op_code)
{
case DW_LNS_extended_op:
- extended_len = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
+ extended_len = read_unsigned_leb128 (abfd, line_ptr,
+ &bytes_read);
line_ptr += bytes_read;
extended_end = line_ptr + extended_len;
extended_op = read_1_byte (abfd, line_ptr);
switch (extended_op)
{
case DW_LNE_end_sequence:
+ p_record_line = record_line;
end_sequence = 1;
break;
case DW_LNE_set_address:
address = read_address (abfd, line_ptr, cu, &bytes_read);
+
+ if (address == 0 && !dwarf2_per_objfile->has_section_at_zero)
+ {
+ /* This line table is for a function which has been
+ GCd by the linker. Ignore it. PR gdb/12528 */
+
+ long line_offset
+ = line_ptr - dwarf2_per_objfile->line.buffer;
+
+ complaint (&symfile_complaints,
+ _(".debug_line address at offset 0x%lx is 0 "
+ "[in module %s]"),
+ line_offset, cu->objfile->name);
+ p_record_line = noop_record_line;
+ }
+
op_index = 0;
line_ptr += bytes_read;
address += baseaddr;
char *cur_file;
unsigned int dir_index, mod_time, length;
- cur_file = read_direct_string (abfd, line_ptr, &bytes_read);
+ cur_file = read_direct_string (abfd, line_ptr,
+ &bytes_read);
line_ptr += bytes_read;
dir_index =
read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
{
addr = gdbarch_addr_bits_remove (gdbarch, address);
if (last_subfile)
- record_line (last_subfile, 0, addr);
+ (*p_record_line) (last_subfile, 0, addr);
last_subfile = current_subfile;
}
addr = check_cu_functions (address, cu);
addr = gdbarch_addr_bits_remove (gdbarch, addr);
- record_line (current_subfile, line, addr);
+ (*p_record_line) (current_subfile, line, addr);
}
}
basic_block = 0;
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;
if (!decode_for_pst_p)
{
addr = gdbarch_addr_bits_remove (gdbarch, address);
- record_line (current_subfile, 0, addr);
+ (*p_record_line) (current_subfile, 0, addr);
}
}
}
subfile's name. */
static void
-dwarf2_start_subfile (char *filename, const char *dirname, const char *comp_dir)
+dwarf2_start_subfile (char *filename, const char *dirname,
+ const char *comp_dir)
{
char *fullname;
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;
converted to host endianness, so we just need to sign- or
zero-extend it as appropriate. */
case DW_FORM_data1:
- *bytes = dwarf2_const_value_data (attr, type, name, obstack, cu, value, 8);
+ *bytes = dwarf2_const_value_data (attr, type, name,
+ obstack, cu, value, 8);
break;
case DW_FORM_data2:
- *bytes = dwarf2_const_value_data (attr, type, name, obstack, cu, value, 16);
+ *bytes = dwarf2_const_value_data (attr, type, name,
+ obstack, cu, value, 16);
break;
case DW_FORM_data4:
- *bytes = dwarf2_const_value_data (attr, type, name, obstack, cu, value, 32);
+ *bytes = dwarf2_const_value_data (attr, type, name,
+ obstack, cu, value, 32);
break;
case DW_FORM_data8:
- *bytes = dwarf2_const_value_data (attr, type, name, obstack, cu, value, 64);
+ *bytes = dwarf2_const_value_data (attr, type, name,
+ obstack, cu, value, 64);
break;
case DW_FORM_sdata:
this_type = read_module_type (die, cu);
break;
default:
- complaint (&symfile_complaints, _("unexpected tag in read_type_die: '%s'"),
+ complaint (&symfile_complaints,
+ _("unexpected tag in read_type_die: '%s'"),
dwarf_tag_name (die->tag));
break;
}
/* Test for '::' as a sanity check. */
if (actual_name_len > die_name_len + 2
- && actual_name[actual_name_len - die_name_len - 1] == ':')
+ && actual_name[actual_name_len
+ - die_name_len - 1] == ':')
name =
obsavestring (actual_name,
actual_name_len - die_name_len - 2,
}
}
-/* Return a newly-allocated string formed by concatenating PREFIX and
- SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
- simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null,
- perform an obconcat, otherwise allocate storage for the result. The CU argument
- is used to determine the language and hence, the appropriate separator. */
+/* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
+ with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
+ simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
+ an obconcat, otherwise allocate storage for the result. The CU argument is
+ used to determine the language and hence, the appropriate separator. */
#define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
const char *lead = "";
const char *sep;
- if (suffix == NULL || suffix[0] == '\0' || prefix == NULL || prefix[0] == '\0')
+ if (suffix == NULL || suffix[0] == '\0'
+ || prefix == NULL || prefix[0] == '\0')
sep = "";
else if (cu->language == language_java)
sep = ".";
if (obs == NULL)
{
- char *retval = xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1);
+ char *retval
+ = xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1);
strcpy (retval, lead);
strcat (retval, prefix);
/* 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 *
case DW_FORM_block4:
case DW_FORM_block:
case DW_FORM_block1:
- fprintf_unfiltered (f, "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_exprloc:
fprintf_unfiltered (f, "expression: size %u",
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 */
- fprintf_unfiltered (f, "unexpected attribute form: DW_FORM_indirect");
+ /* 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;
default:
fprintf_unfiltered (f, "unsupported attribute form: %d.",
}
else
{
- fprintf_unfiltered (f, " [not printed, max nesting level reached]\n");
+ fprintf_unfiltered (f,
+ " [not printed, max nesting level reached]\n");
}
}
return DW_UNSND (attr);
else
{
- complaint (&symfile_complaints, _("Attribute value is not a constant (%s)"),
+ complaint (&symfile_complaints,
+ _("Attribute value is not a constant (%s)"),
dwarf_form_name (attr->form));
return default_value;
}
return die;
}
- error (_("Dwarf Error: Cannot find signatured DIE at 0x%x referenced from DIE "
- "at 0x%x [in module %s]"),
+ error (_("Dwarf Error: Cannot find signatured DIE at 0x%x referenced "
+ "from DIE at 0x%x [in module %s]"),
sig_type->type_offset, src_die->offset, objfile->name);
}
break;
case DW_OP_plus_uconst:
- stack[stacki] += read_unsigned_leb128 (NULL, (data + i), &bytes_read);
+ stack[stacki] += read_unsigned_leb128 (NULL, (data + i),
+ &bytes_read);
i += bytes_read;
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]);
}
if (*p == ' ')
{
complaint (&symfile_complaints,
- _("macro definition contains spaces in formal argument list:\n`%s'"),
+ _("macro definition contains spaces "
+ "in formal argument list:\n`%s'"),
body);
while (*p == ' ')
if (mac_ptr >= mac_end)
{
/* Complaint is printed during the second pass as GDB will probably
- stop the first pass earlier upon finding DW_MACINFO_start_file. */
+ stop the first pass earlier upon finding
+ DW_MACINFO_start_file. */
break;
}
file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
mac_ptr += bytes_read;
- current_file = macro_start_file (file, line, current_file, comp_dir,
- lh, cu->objfile);
+ current_file = macro_start_file (file, line, current_file,
+ comp_dir, lh, cu->objfile);
}
break;
_("something-or-other"), line, body);
break;
}
- if ((line == 0 && !at_commandline) || (line != 0 && at_commandline))
+ if ((line == 0 && !at_commandline)
+ || (line != 0 && at_commandline))
complaint (&symfile_complaints,
_("debug info gives %s macro %s with %s line %d: %s"),
at_commandline ? _("command-line") : _("in-file"),
file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
mac_ptr += bytes_read;
- if ((line == 0 && !at_commandline) || (line != 0 && at_commandline))
+ if ((line == 0 && !at_commandline)
+ || (line != 0 && at_commandline))
complaint (&symfile_complaints,
_("debug info gives source %d included "
"from %s at %s line %d"),
case DW_MACINFO_end_file:
if (! current_file)
complaint (&symfile_complaints,
- _("macro debug info has an unmatched `close_file' directive"));
+ _("macro debug info has an unmatched "
+ "`close_file' directive"));
else
{
current_file = current_file->included_by;
next_type = read_1_byte (abfd, mac_ptr);
if (next_type != 0)
complaint (&symfile_complaints,
- _("no terminating 0-type entry for macros in `.debug_macinfo' section"));
+ _("no terminating 0-type entry for "
+ "macros in `.debug_macinfo' section"));
return;
}
{
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;
if (cu->base_known == 0)
complaint (&symfile_complaints,
- _("Location list used without specifying the CU base address."));
+ _("Location list used without "
+ "specifying the CU base address."));
SYMBOL_COMPUTED_OPS (sym) = &dwarf2_loclist_funcs;
SYMBOL_LOCATION_BATON (sym) = 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;
};
write_psymbols (info->symtab,
info->psyms_seen,
- info->objfile->global_psymbols.list + psymtab->globals_offset,
+ info->objfile->global_psymbols.list
+ + psymtab->globals_offset,
psymtab->n_global_syms, info->cu_index,
0);
write_psymbols (info->symtab,
info->psyms_seen,
- info->objfile->static_psymbols.list + psymtab->statics_offset,
+ info->objfile->static_psymbols.list
+ + psymtab->statics_offset,
psymtab->n_static_syms, info->cu_index,
1);
all_comp_units, but only in their own hash table. */
for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
{
- struct dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->all_comp_units[i];
+ struct dwarf2_per_cu_data *per_cu
+ = dwarf2_per_objfile->all_comp_units[i];
struct partial_symtab *psymtab = per_cu->v.psymtab;
gdb_byte val[8];
struct psymtab_cu_index_map *map;
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.
show_dwarf2_always_disassemble (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("\
-Whether to always disassemble DWARF expressions is %s.\n"),
+ fprintf_filtered (file,
+ _("Whether to always disassemble "
+ "DWARF expressions is %s.\n"),
value);
}