/* DWARF debugging format support for GDB.
- Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1998
- Free Software Foundation, Inc.
+
+ Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+ 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+
Written by Fred Fish at Cygnus Support. Portions based on dbxread.c,
mipsread.c, coffread.c, and dwarfread.c from a Data General SVR4 gdb port.
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+/*
+ If you are looking for DWARF-2 support, you are in the wrong file.
+ Go look in dwarf2read.c. This file is for the original DWARF.
+
+ DWARF (also known as DWARF-1) is headed for obsoletion.
+
+ In gcc 3.2.1, these targets prefer dwarf-1:
+
+ i[34567]86-sequent-ptx4* # TD-R2
+ i[34567]86-sequent-sysv4* # TD-R2
+ i[34567]86-dg-dgux* # obsolete in gcc 3.2.1, to be removed in 3.3
+ m88k-dg-dgux* # TD-R2
+ mips-sni-sysv4 # TD-R2
+ sparc-hal-solaris2* # TD-R2
+
+ Configurations marked with "# TD-R2" are on Zach Weinberg's list
+ of "Target Deprecation, Round 2". This is a candidate list of
+ targets to be deprecated in gcc 3.3 and removed in gcc 3.4.
+
+ http://gcc.gnu.org/ml/gcc/2002-12/msg00702.html
+
+ gcc 2.95.3 had many configurations which prefer dwarf-1.
+ We may have to support dwarf-1 as long as we support gcc 2.95.3.
+ This could use more analysis.
+
+ DG/UX (Data General Unix) used dwarf-1 for its native format.
+ DG/UX uses gcc for its system C compiler, but they have their
+ own linker and their own debuggers.
+
+ Takis Psarogiannakopoulos has a complete gnu toolchain for DG/UX
+ with gcc 2.95.3, gdb 5.1, and debug formats of dwarf-2 and stabs.
+ For more info, see PR gdb/979 and PR gdb/1013; also:
+
+ http://sources.redhat.com/ml/gdb/2003-02/msg00074.html
+
+ There may be non-gcc compilers that still emit dwarf-1.
+
+ -- chastain 2003-02-04
+*/
+
/*
FIXME: Do we need to generate dependencies in partial symtabs?
/* Complaints that can be issued during DWARF debug info reading. */
-struct complaint no_bfd_get_N =
-{
- "DIE @ 0x%x \"%s\", no bfd support for %d byte data object", 0, 0
-};
-
-struct complaint malformed_die =
-{
- "DIE @ 0x%x \"%s\", malformed DIE, bad length (%d bytes)", 0, 0
-};
-
-struct complaint bad_die_ref =
-{
- "DIE @ 0x%x \"%s\", reference to DIE (0x%x) outside compilation unit", 0, 0
-};
-
-struct complaint unknown_attribute_form =
-{
- "DIE @ 0x%x \"%s\", unknown attribute form (0x%x)", 0, 0
-};
-
-struct complaint unknown_attribute_length =
-{
- "DIE @ 0x%x \"%s\", unknown attribute length, skipped remaining attributes", 0, 0
-};
-
-struct complaint unexpected_fund_type =
-{
- "DIE @ 0x%x \"%s\", unexpected fundamental type 0x%x", 0, 0
-};
-
-struct complaint unknown_type_modifier =
-{
- "DIE @ 0x%x \"%s\", unknown type modifier %u", 0, 0
-};
-
-struct complaint volatile_ignored =
-{
- "DIE @ 0x%x \"%s\", type modifier 'volatile' ignored", 0, 0
-};
-
-struct complaint const_ignored =
-{
- "DIE @ 0x%x \"%s\", type modifier 'const' ignored", 0, 0
-};
-
-struct complaint botched_modified_type =
-{
- "DIE @ 0x%x \"%s\", botched modified type decoding (mtype 0x%x)", 0, 0
-};
-
-struct complaint op_deref2 =
-{
- "DIE @ 0x%x \"%s\", OP_DEREF2 address 0x%x not handled", 0, 0
-};
-
-struct complaint op_deref4 =
-{
- "DIE @ 0x%x \"%s\", OP_DEREF4 address 0x%x not handled", 0, 0
-};
-
-struct complaint basereg_not_handled =
-{
- "DIE @ 0x%x \"%s\", BASEREG %d not handled", 0, 0
-};
-
-struct complaint dup_user_type_allocation =
-{
- "DIE @ 0x%x \"%s\", internal error: duplicate user type allocation", 0, 0
-};
-
-struct complaint dup_user_type_definition =
-{
- "DIE @ 0x%x \"%s\", internal error: duplicate user type definition", 0, 0
-};
-
-struct complaint missing_tag =
-{
- "DIE @ 0x%x \"%s\", missing class, structure, or union tag", 0, 0
-};
-
-struct complaint bad_array_element_type =
-{
- "DIE @ 0x%x \"%s\", bad array element type attribute 0x%x", 0, 0
-};
-
-struct complaint subscript_data_items =
-{
- "DIE @ 0x%x \"%s\", can't decode subscript data items", 0, 0
-};
-
-struct complaint unhandled_array_subscript_format =
+static void
+bad_die_ref_complaint (int arg1, const char *arg2, int arg3)
{
- "DIE @ 0x%x \"%s\", array subscript format 0x%x not handled yet", 0, 0
-};
+ complaint (&symfile_complaints,
+ "DIE @ 0x%x \"%s\", reference to DIE (0x%x) outside compilation unit",
+ arg1, arg2, arg3);
+}
-struct complaint unknown_array_subscript_format =
+static void
+unknown_attribute_form_complaint (int arg1, const char *arg2, int arg3)
{
- "DIE @ 0x%x \"%s\", unknown array subscript format %x", 0, 0
-};
+ complaint (&symfile_complaints,
+ "DIE @ 0x%x \"%s\", unknown attribute form (0x%x)", arg1, arg2,
+ arg3);
+}
-struct complaint not_row_major =
+static void
+dup_user_type_definition_complaint (int arg1, const char *arg2)
{
- "DIE @ 0x%x \"%s\", array not row major; not handled correctly", 0, 0
-};
+ complaint (&symfile_complaints,
+ "DIE @ 0x%x \"%s\", internal error: duplicate user type definition",
+ arg1, arg2);
+}
-struct complaint missing_at_name =
+static void
+bad_array_element_type_complaint (int arg1, const char *arg2, int arg3)
{
- "DIE @ 0x%x, AT_name tag missing", 0, 0
-};
+ complaint (&symfile_complaints,
+ "DIE @ 0x%x \"%s\", bad array element type attribute 0x%x", arg1,
+ arg2, arg3);
+}
typedef unsigned int DIE_REF; /* Reference to a DIE */
#define LCC_PRODUCER "NCR C/C++"
#endif
-#ifndef CHILL_PRODUCER
-#define CHILL_PRODUCER "GNU Chill "
-#endif
-
-/* Provide a default mapping from a DWARF register number to a gdb REGNUM. */
-#ifndef DWARF_REG_TO_REGNUM
-#define DWARF_REG_TO_REGNUM(num) (num)
-#endif
-
/* Flags to target_to_host() that tell whether or not the data object is
expected to be signed. Used, for example, when fetching a signed
integer in the target environment which is used as a signed integer
#define AT_short_element_list (0x00f0|FORM_BLOCK2)
-/* External variables referenced. */
-
-extern int info_verbose; /* From main.c; nonzero => verbose */
-extern char *warning_pre_print; /* From utils.c */
-
/* The DWARF debugging information consists of two major pieces,
one is a block of DWARF Information Entries (DIE's) and the other
is a line number table. The "struct dieinfo" structure contains
/* Forward declarations of static functions so we don't have to worry
about ordering within this file. */
-static void
-free_utypes PARAMS ((PTR));
+static void free_utypes (void *);
-static int
-attribute_size PARAMS ((unsigned int));
+static int attribute_size (unsigned int);
-static CORE_ADDR
- target_to_host PARAMS ((char *, int, int, struct objfile *));
+static CORE_ADDR target_to_host (char *, int, int, struct objfile *);
-static void
-add_enum_psymbol PARAMS ((struct dieinfo *, struct objfile *));
+static void add_enum_psymbol (struct dieinfo *, struct objfile *);
-static void
-handle_producer PARAMS ((char *));
+static void handle_producer (char *);
-static void
-read_file_scope PARAMS ((struct dieinfo *, char *, char *, struct objfile *));
+static void read_file_scope (struct dieinfo *, char *, char *,
+ struct objfile *);
-static void
-read_func_scope PARAMS ((struct dieinfo *, char *, char *, struct objfile *));
+static void read_func_scope (struct dieinfo *, char *, char *,
+ struct objfile *);
-static void
-read_lexical_block_scope PARAMS ((struct dieinfo *, char *, char *,
- struct objfile *));
+static void read_lexical_block_scope (struct dieinfo *, char *, char *,
+ struct objfile *);
-static void
-scan_partial_symbols PARAMS ((char *, char *, struct objfile *));
+static void scan_partial_symbols (char *, char *, struct objfile *);
-static void
-scan_compilation_units PARAMS ((char *, char *, file_ptr,
- file_ptr, struct objfile *));
+static void scan_compilation_units (char *, char *, file_ptr, file_ptr,
+ struct objfile *);
-static void
-add_partial_symbol PARAMS ((struct dieinfo *, struct objfile *));
+static void add_partial_symbol (struct dieinfo *, struct objfile *);
-static void
-basicdieinfo PARAMS ((struct dieinfo *, char *, struct objfile *));
+static void basicdieinfo (struct dieinfo *, char *, struct objfile *);
-static void
-completedieinfo PARAMS ((struct dieinfo *, struct objfile *));
+static void completedieinfo (struct dieinfo *, struct objfile *);
-static void
-dwarf_psymtab_to_symtab PARAMS ((struct partial_symtab *));
+static void dwarf_psymtab_to_symtab (struct partial_symtab *);
-static void
-psymtab_to_symtab_1 PARAMS ((struct partial_symtab *));
+static void psymtab_to_symtab_1 (struct partial_symtab *);
-static void
-read_ofile_symtab PARAMS ((struct partial_symtab *));
+static void read_ofile_symtab (struct partial_symtab *);
-static void
-process_dies PARAMS ((char *, char *, struct objfile *));
+static void process_dies (char *, char *, struct objfile *);
-static void
-read_structure_scope PARAMS ((struct dieinfo *, char *, char *,
- struct objfile *));
+static void read_structure_scope (struct dieinfo *, char *, char *,
+ struct objfile *);
-static struct type *
- decode_array_element_type PARAMS ((char *));
+static struct type *decode_array_element_type (char *);
-static struct type *
- decode_subscript_data_item PARAMS ((char *, char *));
+static struct type *decode_subscript_data_item (char *, char *);
-static void
-dwarf_read_array_type PARAMS ((struct dieinfo *));
+static void dwarf_read_array_type (struct dieinfo *);
-static void
-read_tag_pointer_type PARAMS ((struct dieinfo * dip));
+static void read_tag_pointer_type (struct dieinfo *dip);
-static void
-read_tag_string_type PARAMS ((struct dieinfo * dip));
+static void read_tag_string_type (struct dieinfo *dip);
-static void
-read_subroutine_type PARAMS ((struct dieinfo *, char *, char *));
+static void read_subroutine_type (struct dieinfo *, char *, char *);
-static void
-read_enumeration PARAMS ((struct dieinfo *, char *, char *, struct objfile *));
+static void read_enumeration (struct dieinfo *, char *, char *,
+ struct objfile *);
-static struct type *
- struct_type PARAMS ((struct dieinfo *, char *, char *, struct objfile *));
+static struct type *struct_type (struct dieinfo *, char *, char *,
+ struct objfile *);
-static struct type *
- enum_type PARAMS ((struct dieinfo *, struct objfile *));
+static struct type *enum_type (struct dieinfo *, struct objfile *);
-static void
-decode_line_numbers PARAMS ((char *));
+static void decode_line_numbers (char *);
-static struct type *
- decode_die_type PARAMS ((struct dieinfo *));
+static struct type *decode_die_type (struct dieinfo *);
-static struct type *
- decode_mod_fund_type PARAMS ((char *));
+static struct type *decode_mod_fund_type (char *);
-static struct type *
- decode_mod_u_d_type PARAMS ((char *));
+static struct type *decode_mod_u_d_type (char *);
-static struct type *
- decode_modified_type PARAMS ((char *, unsigned int, int));
+static struct type *decode_modified_type (char *, unsigned int, int);
-static struct type *
- decode_fund_type PARAMS ((unsigned int));
+static struct type *decode_fund_type (unsigned int);
-static char *
- create_name PARAMS ((char *, struct obstack *));
+static char *create_name (char *, struct obstack *);
-static struct type *
- lookup_utype PARAMS ((DIE_REF));
+static struct type *lookup_utype (DIE_REF);
-static struct type *
- alloc_utype PARAMS ((DIE_REF, struct type *));
+static struct type *alloc_utype (DIE_REF, struct type *);
-static struct symbol *
- new_symbol PARAMS ((struct dieinfo *, struct objfile *));
+static struct symbol *new_symbol (struct dieinfo *, struct objfile *);
-static void
-synthesize_typedef PARAMS ((struct dieinfo *, struct objfile *,
- struct type *));
+static void synthesize_typedef (struct dieinfo *, struct objfile *,
+ struct type *);
-static int
-locval PARAMS ((struct dieinfo *));
+static int locval (struct dieinfo *);
-static void
-set_cu_language PARAMS ((struct dieinfo *));
+static void set_cu_language (struct dieinfo *);
-static struct type *
- dwarf_fundamental_type PARAMS ((struct objfile *, int));
+static struct type *dwarf_fundamental_type (struct objfile *, int);
/*
*/
static struct type *
-dwarf_fundamental_type (objfile, typeid)
- struct objfile *objfile;
- int typeid;
+dwarf_fundamental_type (struct objfile *objfile, int typeid)
{
if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
{
*/
static void
-set_cu_language (dip)
- struct dieinfo *dip;
+set_cu_language (struct dieinfo *dip)
{
switch (dip->at_language)
{
case LANG_C_PLUS_PLUS:
cu_language = language_cplus;
break;
- case LANG_CHILL:
- cu_language = language_chill;
- break;
case LANG_MODULA2:
cu_language = language_m2;
break;
*/
void
-dwarf_build_psymtabs (objfile, mainline, dbfoff, dbfsize,
- lnoffset, lnsize)
- struct objfile *objfile;
- int mainline;
- file_ptr dbfoff;
- unsigned int dbfsize;
- file_ptr lnoffset;
- unsigned int lnsize;
+dwarf_build_psymtabs (struct objfile *objfile, int mainline, file_ptr dbfoff,
+ unsigned int dbfsize, file_ptr lnoffset,
+ unsigned int lnsize)
{
bfd *abfd = objfile->obfd;
struct cleanup *back_to;
dbbase = xmalloc (dbsize);
dbroff = 0;
if ((bfd_seek (abfd, dbfoff, SEEK_SET) != 0) ||
- (bfd_read (dbbase, dbsize, 1, abfd) != dbsize))
+ (bfd_bread (dbbase, dbsize, abfd) != dbsize))
{
- free (dbbase);
+ xfree (dbbase);
error ("can't read DWARF data from '%s'", bfd_get_filename (abfd));
}
- back_to = make_cleanup (free, dbbase);
+ back_to = make_cleanup (xfree, dbbase);
/* If we are reinitializing, or if we have never loaded syms yet, init.
Since we have no idea how many DIES we are looking at, we just guess
some arbitrary value. */
- if (mainline || objfile->global_psymbols.size == 0 ||
- objfile->static_psymbols.size == 0)
+ if (mainline
+ || (objfile->global_psymbols.size == 0
+ && objfile->static_psymbols.size == 0))
{
init_psymbol_list (objfile, 1024);
}
*/
static void
-read_lexical_block_scope (dip, thisdie, enddie, objfile)
- struct dieinfo *dip;
- char *thisdie;
- char *enddie;
- struct objfile *objfile;
+read_lexical_block_scope (struct dieinfo *dip, char *thisdie, char *enddie,
+ struct objfile *objfile)
{
register struct context_stack *new;
*/
static struct type *
-lookup_utype (die_ref)
- DIE_REF die_ref;
+lookup_utype (DIE_REF die_ref)
{
struct type *type = NULL;
int utypeidx;
utypeidx = (die_ref - dbroff) / 4;
if ((utypeidx < 0) || (utypeidx >= numutypes))
{
- complain (&bad_die_ref, DIE_ID, DIE_NAME);
+ bad_die_ref_complaint (DIE_ID, DIE_NAME, die_ref);
}
else
{
*/
static struct type *
-alloc_utype (die_ref, utypep)
- DIE_REF die_ref;
- struct type *utypep;
+alloc_utype (DIE_REF die_ref, struct type *utypep)
{
struct type **typep;
int utypeidx;
if ((utypeidx < 0) || (utypeidx >= numutypes))
{
utypep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
- complain (&bad_die_ref, DIE_ID, DIE_NAME);
+ bad_die_ref_complaint (DIE_ID, DIE_NAME, die_ref);
}
else if (*typep != NULL)
{
utypep = *typep;
- complain (&dup_user_type_allocation, DIE_ID, DIE_NAME);
+ complaint (&symfile_complaints,
+ "DIE @ 0x%x \"%s\", internal error: duplicate user type allocation",
+ DIE_ID, DIE_NAME);
}
else
{
SYNOPSIS
- static void free_utypes (PTR dummy)
+ static void free_utypes (void *dummy)
DESCRIPTION
*/
static void
-free_utypes (dummy)
- PTR dummy;
+free_utypes (void *dummy)
{
- free (utypes);
+ xfree (utypes);
utypes = NULL;
numutypes = 0;
}
*/
static struct type *
-decode_die_type (dip)
- struct dieinfo *dip;
+decode_die_type (struct dieinfo *dip)
{
struct type *type = NULL;
*/
static struct type *
-struct_type (dip, thisdie, enddie, objfile)
- struct dieinfo *dip;
- char *thisdie;
- char *enddie;
- struct objfile *objfile;
+struct_type (struct dieinfo *dip, char *thisdie, char *enddie,
+ struct objfile *objfile)
{
struct type *type;
struct nextfield
default:
/* Should never happen */
TYPE_CODE (type) = TYPE_CODE_UNDEF;
- complain (&missing_tag, DIE_ID, DIE_NAME);
+ complaint (&symfile_complaints,
+ "DIE @ 0x%x \"%s\", missing class, structure, or union tag",
+ DIE_ID, DIE_NAME);
break;
}
/* Some compilers try to be helpful by inventing "fake" names for
&objfile->type_obstack);
FIELD_TYPE (list->field) = decode_die_type (&mbr);
FIELD_BITPOS (list->field) = 8 * locval (&mbr);
+ FIELD_STATIC_KIND (list->field) = 0;
/* Handle bit fields. */
FIELD_BITSIZE (list->field) = mbr.at_bit_size;
if (BITS_BIG_ENDIAN)
*/
static void
-read_structure_scope (dip, thisdie, enddie, objfile)
- struct dieinfo *dip;
- char *thisdie;
- char *enddie;
- struct objfile *objfile;
+read_structure_scope (struct dieinfo *dip, char *thisdie, char *enddie,
+ struct objfile *objfile)
{
struct type *type;
struct symbol *sym;
type = struct_type (dip, thisdie, enddie, objfile);
- if (!(TYPE_FLAGS (type) & TYPE_FLAG_STUB))
+ if (!TYPE_STUB (type))
{
sym = new_symbol (dip, objfile);
if (sym != NULL)
*/
static struct type *
-decode_array_element_type (scan)
- char *scan;
+decode_array_element_type (char *scan)
{
struct type *typep;
DIE_REF die_ref;
scan += SIZEOF_ATTRIBUTE;
if ((nbytes = attribute_size (attribute)) == -1)
{
- complain (&bad_array_element_type, DIE_ID, DIE_NAME, attribute);
+ bad_array_element_type_complaint (DIE_ID, DIE_NAME, attribute);
typep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
}
else
typep = decode_mod_u_d_type (scan);
break;
default:
- complain (&bad_array_element_type, DIE_ID, DIE_NAME, attribute);
+ bad_array_element_type_complaint (DIE_ID, DIE_NAME, attribute);
typep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
break;
}
*/
static struct type *
-decode_subscript_data_item (scan, end)
- char *scan;
- char *end;
+decode_subscript_data_item (char *scan, char *end)
{
struct type *typep = NULL; /* Array type we are building */
struct type *nexttype; /* Type of each element (may be array) */
if (nexttype == NULL)
{
/* Munged subscript data or other problem, fake it. */
- complain (&subscript_data_items, DIE_ID, DIE_NAME);
+ complaint (&symfile_complaints,
+ "DIE @ 0x%x \"%s\", can't decode subscript data items",
+ DIE_ID, DIE_NAME);
nexttype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
}
rangetype = create_range_type ((struct type *) NULL, indextype,
case FMT_UT_C_X:
case FMT_UT_X_C:
case FMT_UT_X_X:
- complain (&unhandled_array_subscript_format, DIE_ID, DIE_NAME, format);
+ complaint (&symfile_complaints,
+ "DIE @ 0x%x \"%s\", array subscript format 0x%x not handled yet",
+ DIE_ID, DIE_NAME, format);
nexttype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
rangetype = create_range_type ((struct type *) NULL, nexttype, 0, 0);
typep = create_array_type ((struct type *) NULL, nexttype, rangetype);
break;
default:
- complain (&unknown_array_subscript_format, DIE_ID, DIE_NAME, format);
+ complaint (&symfile_complaints,
+ "DIE @ 0x%x \"%s\", unknown array subscript format %x", DIE_ID,
+ DIE_NAME, format);
nexttype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
rangetype = create_range_type ((struct type *) NULL, nexttype, 0, 0);
typep = create_array_type ((struct type *) NULL, nexttype, rangetype);
*/
static void
-dwarf_read_array_type (dip)
- struct dieinfo *dip;
+dwarf_read_array_type (struct dieinfo *dip)
{
struct type *type;
struct type *utype;
if (dip->at_ordering != ORD_row_major)
{
/* FIXME: Can gdb even handle column major arrays? */
- complain (¬_row_major, DIE_ID, DIE_NAME);
+ complaint (&symfile_complaints,
+ "DIE @ 0x%x \"%s\", array not row major; not handled correctly",
+ DIE_ID, DIE_NAME);
}
if ((sub = dip->at_subscr_data) != NULL)
{
{
/* Double ick! Not only is a type already in our slot, but
someone has decorated it. Complain and leave it alone. */
- complain (&dup_user_type_definition, DIE_ID, DIE_NAME);
+ dup_user_type_definition_complaint (DIE_ID, DIE_NAME);
}
}
}
*/
static void
-read_tag_pointer_type (dip)
- struct dieinfo *dip;
+read_tag_pointer_type (struct dieinfo *dip)
{
struct type *type;
struct type *utype;
*/
static void
-read_tag_string_type (dip)
- struct dieinfo *dip;
+read_tag_string_type (struct dieinfo *dip)
{
struct type *utype;
struct type *indextype;
is a blank one. If not, complain and leave it alone. */
if (TYPE_CODE (utype) != TYPE_CODE_UNDEF)
{
- complain (&dup_user_type_definition, DIE_ID, DIE_NAME);
+ dup_user_type_definition_complaint (DIE_ID, DIE_NAME);
return;
}
}
*/
static void
-read_subroutine_type (dip, thisdie, enddie)
- struct dieinfo *dip;
- char *thisdie;
- char *enddie;
+read_subroutine_type (struct dieinfo *dip, char *thisdie, char *enddie)
{
struct type *type; /* Type that this function returns */
struct type *ftype; /* Function that returns above type */
}
else
{
- complain (&dup_user_type_definition, DIE_ID, DIE_NAME);
+ dup_user_type_definition_complaint (DIE_ID, DIE_NAME);
}
}
*/
static void
-read_enumeration (dip, thisdie, enddie, objfile)
- struct dieinfo *dip;
- char *thisdie;
- char *enddie;
- struct objfile *objfile;
+read_enumeration (struct dieinfo *dip, char *thisdie, char *enddie,
+ struct objfile *objfile)
{
struct type *type;
struct symbol *sym;
*/
static struct type *
-enum_type (dip, objfile)
- struct dieinfo *dip;
- struct objfile *objfile;
+enum_type (struct dieinfo *dip, struct objfile *objfile)
{
struct type *type;
struct nextfield
list = new;
FIELD_TYPE (list->field) = NULL;
FIELD_BITSIZE (list->field) = 0;
+ FIELD_STATIC_KIND (list->field) = 0;
FIELD_BITPOS (list->field) =
target_to_host (scan, TARGET_FT_LONG_SIZE (objfile), GET_SIGNED,
objfile);
sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
sizeof (struct symbol));
memset (sym, 0, sizeof (struct symbol));
- SYMBOL_NAME (sym) = create_name (list->field.name,
+ DEPRECATED_SYMBOL_NAME (sym) = create_name (list->field.name,
&objfile->symbol_obstack);
SYMBOL_INIT_LANGUAGE_SPECIFIC (sym, cu_language);
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
*/
static void
-read_func_scope (dip, thisdie, enddie, objfile)
- struct dieinfo *dip;
- char *thisdie;
- char *enddie;
- struct objfile *objfile;
+read_func_scope (struct dieinfo *dip, char *thisdie, char *enddie,
+ struct objfile *objfile)
{
register struct context_stack *new;
FIXME: Add code to handle AT_abstract_origin tags properly. */
if (dip->at_name == NULL)
{
- complain (&missing_at_name, DIE_ID);
+ complaint (&symfile_complaints, "DIE @ 0x%x, AT_name tag missing",
+ DIE_ID);
return;
}
*/
static void
-handle_producer (producer)
- char *producer;
+handle_producer (char *producer)
{
/* If this compilation unit was compiled with g++ or gcc, then set the
else
{
processing_gcc_compilation =
- STREQN (producer, GPLUS_PRODUCER, strlen (GPLUS_PRODUCER))
- || STREQN (producer, CHILL_PRODUCER, strlen (CHILL_PRODUCER));
+ STREQN (producer, GPLUS_PRODUCER, strlen (GPLUS_PRODUCER));
}
/* Select a demangling style if we can identify the producer and if
{
if (STREQN (producer, GPLUS_PRODUCER, strlen (GPLUS_PRODUCER)))
{
+#if 0
+ /* For now, stay with AUTO_DEMANGLING for g++ output, as we don't
+ know whether it will use the old style or v3 mangling. */
set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
+#endif
}
else if (STREQN (producer, LCC_PRODUCER, strlen (LCC_PRODUCER)))
{
*/
static void
-read_file_scope (dip, thisdie, enddie, objfile)
- struct dieinfo *dip;
- char *thisdie;
- char *enddie;
- struct objfile *objfile;
+read_file_scope (struct dieinfo *dip, char *thisdie, char *enddie,
+ struct objfile *objfile)
{
struct cleanup *back_to;
struct symtab *symtab;
*/
static void
-process_dies (thisdie, enddie, objfile)
- char *thisdie;
- char *enddie;
- struct objfile *objfile;
+process_dies (char *thisdie, char *enddie, struct objfile *objfile)
{
char *nextdie;
struct dieinfo di;
{
nextdie = thisdie + di.die_length;
}
-#ifdef SMASH_TEXT_ADDRESS
/* I think that these are always text, not data, addresses. */
- SMASH_TEXT_ADDRESS (di.at_low_pc);
- SMASH_TEXT_ADDRESS (di.at_high_pc);
-#endif
+ di.at_low_pc = SMASH_TEXT_ADDRESS (di.at_low_pc);
+ di.at_high_pc = SMASH_TEXT_ADDRESS (di.at_high_pc);
switch (di.die_tag)
{
case TAG_compile_unit:
*/
static void
-decode_line_numbers (linetable)
- char *linetable;
+decode_line_numbers (char *linetable)
{
char *tblscan;
char *tblend;
*/
static int
-locval (dip)
- struct dieinfo *dip;
+locval (struct dieinfo *dip)
{
unsigned short nbytes;
unsigned short locsize;
break;
case OP_DEREF2:
/* pop, deref and push 2 bytes (as a long) */
- complain (&op_deref2, DIE_ID, DIE_NAME, stack[stacki]);
+ complaint (&symfile_complaints,
+ "DIE @ 0x%x \"%s\", OP_DEREF2 address 0x%lx not handled",
+ DIE_ID, DIE_NAME, stack[stacki]);
break;
case OP_DEREF4: /* pop, deref and push 4 bytes (as a long) */
- complain (&op_deref4, DIE_ID, DIE_NAME, stack[stacki]);
+ complaint (&symfile_complaints,
+ "DIE @ 0x%x \"%s\", OP_DEREF4 address 0x%lx not handled",
+ DIE_ID, DIE_NAME, stack[stacki]);
break;
case OP_ADD: /* pop top 2 items, add, push result */
stack[stacki - 1] += stack[stacki];
*/
static void
-read_ofile_symtab (pst)
- struct partial_symtab *pst;
+read_ofile_symtab (struct partial_symtab *pst)
{
struct cleanup *back_to;
unsigned long lnsize;
base_section_offsets = pst->section_offsets;
baseaddr = ANOFFSET (pst->section_offsets, 0);
if (bfd_seek (abfd, foffset, SEEK_SET) ||
- (bfd_read (dbbase, dbsize, 1, abfd) != dbsize))
+ (bfd_bread (dbbase, dbsize, abfd) != dbsize))
{
- free (dbbase);
+ xfree (dbbase);
error ("can't read DWARF data");
}
- back_to = make_cleanup (free, dbbase);
+ back_to = make_cleanup (xfree, dbbase);
/* If there is a line number table associated with this compilation unit
then read the size of this fragment in bytes, from the fragment itself.
if (LNFOFF (pst))
{
if (bfd_seek (abfd, LNFOFF (pst), SEEK_SET) ||
- (bfd_read ((PTR) lnsizedata, sizeof (lnsizedata), 1, abfd) !=
- sizeof (lnsizedata)))
+ (bfd_bread (lnsizedata, sizeof (lnsizedata), abfd)
+ != sizeof (lnsizedata)))
{
error ("can't read DWARF line number table size");
}
GET_UNSIGNED, pst->objfile);
lnbase = xmalloc (lnsize);
if (bfd_seek (abfd, LNFOFF (pst), SEEK_SET) ||
- (bfd_read (lnbase, lnsize, 1, abfd) != lnsize))
+ (bfd_bread (lnbase, lnsize, abfd) != lnsize))
{
- free (lnbase);
+ xfree (lnbase);
error ("can't read DWARF line numbers");
}
- make_cleanup (free, lnbase);
+ make_cleanup (xfree, lnbase);
}
process_dies (dbbase, dbbase + dbsize, pst->objfile);
*/
static void
-psymtab_to_symtab_1 (pst)
- struct partial_symtab *pst;
+psymtab_to_symtab_1 (struct partial_symtab *pst)
{
int i;
struct cleanup *old_chain;
*/
static void
-dwarf_psymtab_to_symtab (pst)
- struct partial_symtab *pst;
+dwarf_psymtab_to_symtab (struct partial_symtab *pst)
{
if (pst != NULL)
*/
static void
-add_enum_psymbol (dip, objfile)
- struct dieinfo *dip;
- struct objfile *objfile;
+add_enum_psymbol (struct dieinfo *dip, struct objfile *objfile)
{
char *scan;
char *listend;
*/
static void
-add_partial_symbol (dip, objfile)
- struct dieinfo *dip;
- struct objfile *objfile;
+add_partial_symbol (struct dieinfo *dip, struct objfile *objfile)
{
switch (dip->die_tag)
{
static void
-scan_partial_symbols (thisdie, enddie, objfile)
- char *thisdie;
- char *enddie;
- struct objfile *objfile;
+scan_partial_symbols (char *thisdie, char *enddie, struct objfile *objfile)
{
char *nextdie;
char *temp;
temp = dbbase + di.at_sibling - dbroff;
if ((temp < thisdie) || (temp >= enddie))
{
- complain (&bad_die_ref, DIE_ID, DIE_NAME,
- di.at_sibling);
+ bad_die_ref_complaint (DIE_ID, DIE_NAME,
+ di.at_sibling);
}
else
{
*/
static void
-scan_compilation_units (thisdie, enddie, dbfoff, lnoffset, objfile)
- char *thisdie;
- char *enddie;
- file_ptr dbfoff;
- file_ptr lnoffset;
- struct objfile *objfile;
+scan_compilation_units (char *thisdie, char *enddie, file_ptr dbfoff,
+ file_ptr lnoffset, struct objfile *objfile)
{
char *nextdie;
struct dieinfo di;
*/
static struct symbol *
-new_symbol (dip, objfile)
- struct dieinfo *dip;
- struct objfile *objfile;
+new_symbol (struct dieinfo *dip, struct objfile *objfile)
{
struct symbol *sym = NULL;
sizeof (struct symbol));
OBJSTAT (objfile, n_syms++);
memset (sym, 0, sizeof (struct symbol));
- SYMBOL_NAME (sym) = create_name (dip->at_name,
- &objfile->symbol_obstack);
/* default assumptions */
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
SYMBOL_CLASS (sym) = LOC_STATIC;
C++ symbol lookups by a factor of about 20. */
SYMBOL_LANGUAGE (sym) = cu_language;
- SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->symbol_obstack);
+ SYMBOL_SET_NAMES (sym, dip->at_name, strlen (dip->at_name), objfile);
switch (dip->die_tag)
{
case TAG_label:
*/
static void
-synthesize_typedef (dip, objfile, type)
- struct dieinfo *dip;
- struct objfile *objfile;
- struct type *type;
+synthesize_typedef (struct dieinfo *dip, struct objfile *objfile,
+ struct type *type)
{
struct symbol *sym = NULL;
obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol));
OBJSTAT (objfile, n_syms++);
memset (sym, 0, sizeof (struct symbol));
- SYMBOL_NAME (sym) = create_name (dip->at_name,
+ DEPRECATED_SYMBOL_NAME (sym) = create_name (dip->at_name,
&objfile->symbol_obstack);
SYMBOL_INIT_LANGUAGE_SPECIFIC (sym, cu_language);
SYMBOL_TYPE (sym) = type;
*/
static struct type *
-decode_mod_fund_type (typedata)
- char *typedata;
+decode_mod_fund_type (char *typedata)
{
struct type *typep = NULL;
unsigned short modcount;
*/
static struct type *
-decode_mod_u_d_type (typedata)
- char *typedata;
+decode_mod_u_d_type (char *typedata)
{
struct type *typep = NULL;
unsigned short modcount;
*/
static struct type *
-decode_modified_type (modifiers, modcount, mtype)
- char *modifiers;
- unsigned int modcount;
- int mtype;
+decode_modified_type (char *modifiers, unsigned int modcount, int mtype)
{
struct type *typep = NULL;
unsigned short fundtype;
}
break;
default:
- complain (&botched_modified_type, DIE_ID, DIE_NAME, mtype);
+ complaint (&symfile_complaints,
+ "DIE @ 0x%x \"%s\", botched modified type decoding (mtype 0x%x)",
+ DIE_ID, DIE_NAME, mtype);
typep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
break;
}
typep = lookup_reference_type (typep);
break;
case MOD_const:
- complain (&const_ignored, DIE_ID, DIE_NAME); /* FIXME */
+ complaint (&symfile_complaints,
+ "DIE @ 0x%x \"%s\", type modifier 'const' ignored", DIE_ID,
+ DIE_NAME); /* FIXME */
break;
case MOD_volatile:
- complain (&volatile_ignored, DIE_ID, DIE_NAME); /* FIXME */
+ complaint (&symfile_complaints,
+ "DIE @ 0x%x \"%s\", type modifier 'volatile' ignored",
+ DIE_ID, DIE_NAME); /* FIXME */
break;
default:
if (!(MOD_lo_user <= (unsigned char) modifier
&& (unsigned char) modifier <= MOD_hi_user))
{
- complain (&unknown_type_modifier, DIE_ID, DIE_NAME, modifier);
+ complaint (&symfile_complaints,
+ "DIE @ 0x%x \"%s\", unknown type modifier %u", DIE_ID,
+ DIE_NAME, modifier);
}
break;
}
*/
static struct type *
-decode_fund_type (fundtype)
- unsigned int fundtype;
+decode_fund_type (unsigned int fundtype)
{
struct type *typep = NULL;
typep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
if (!(FT_lo_user <= fundtype && fundtype <= FT_hi_user))
{
- complain (&unexpected_fund_type, DIE_ID, DIE_NAME, fundtype);
+ complaint (&symfile_complaints,
+ "DIE @ 0x%x \"%s\", unexpected fundamental type 0x%x",
+ DIE_ID, DIE_NAME, fundtype);
}
}
*/
static char *
-create_name (name, obstackp)
- char *name;
- struct obstack *obstackp;
+create_name (char *name, struct obstack *obstackp)
{
int length;
char *newname;
*/
static void
-basicdieinfo (dip, diep, objfile)
- struct dieinfo *dip;
- char *diep;
- struct objfile *objfile;
+basicdieinfo (struct dieinfo *dip, char *diep, struct objfile *objfile)
{
curdie = dip;
memset (dip, 0, sizeof (struct dieinfo));
if ((dip->die_length < SIZEOF_DIE_LENGTH) ||
((diep + dip->die_length) > (dbbase + dbsize)))
{
- complain (&malformed_die, DIE_ID, DIE_NAME, dip->die_length);
+ complaint (&symfile_complaints,
+ "DIE @ 0x%x \"%s\", malformed DIE, bad length (%ld bytes)",
+ DIE_ID, DIE_NAME, dip->die_length);
dip->die_length = 0;
}
else if (dip->die_length < (SIZEOF_DIE_LENGTH + SIZEOF_DIE_TAG))
*/
static void
-completedieinfo (dip, objfile)
- struct dieinfo *dip;
- struct objfile *objfile;
+completedieinfo (struct dieinfo *dip, struct objfile *objfile)
{
char *diep; /* Current pointer into raw DIE data */
char *end; /* Terminate DIE scan here */
diep += SIZEOF_ATTRIBUTE;
if ((nbytes = attribute_size (attr)) == -1)
{
- complain (&unknown_attribute_length, DIE_ID, DIE_NAME);
+ complaint (&symfile_complaints,
+ "DIE @ 0x%x \"%s\", unknown attribute length, skipped remaining attributes",
+ DIE_ID, DIE_NAME);
diep = end;
continue;
}
diep += strlen (diep) + 1;
break;
default:
- complain (&unknown_attribute_form, DIE_ID, DIE_NAME, form);
+ unknown_attribute_form_complaint (DIE_ID, DIE_NAME, form);
diep = end;
break;
}
*/
static CORE_ADDR
-target_to_host (from, nbytes, signextend, objfile)
- char *from;
- int nbytes;
- int signextend; /* FIXME: Unused */
- struct objfile *objfile;
+target_to_host (char *from, int nbytes, int signextend, /* FIXME: Unused */
+ struct objfile *objfile)
{
CORE_ADDR rtnval;
rtnval = bfd_get_8 (objfile->obfd, (bfd_byte *) from);
break;
default:
- complain (&no_bfd_get_N, DIE_ID, DIE_NAME, nbytes);
+ complaint (&symfile_complaints,
+ "DIE @ 0x%x \"%s\", no bfd support for %d byte data object",
+ DIE_ID, DIE_NAME, nbytes);
rtnval = 0;
break;
}
*/
static int
-attribute_size (attr)
- unsigned int attr;
+attribute_size (unsigned int attr)
{
int nbytes; /* Size of next data for this attribute */
unsigned short form; /* Form of the attribute */
nbytes = TARGET_FT_POINTER_SIZE (objfile);
break;
default:
- complain (&unknown_attribute_form, DIE_ID, DIE_NAME, form);
+ unknown_attribute_form_complaint (DIE_ID, DIE_NAME, form);
nbytes = -1;
break;
}
projects / deliverable / binutils-gdb.git / blobdiff