/* Read coff symbol tables and convert to internal format, for GDB.
Copyright (C) 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
- 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
+ 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
Free Software Foundation, Inc.
Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu).
extern void stabsread_clear_cache (void);
-static struct type *coff_read_struct_type (int, int, int);
+static struct type *coff_read_struct_type (int, int, int,
+ struct objfile *);
static struct type *decode_base_type (struct coff_symbol *,
- unsigned int, union internal_auxent *);
+ unsigned int, union internal_auxent *,
+ struct objfile *);
static struct type *decode_type (struct coff_symbol *, unsigned int,
- union internal_auxent *);
+ union internal_auxent *,
+ struct objfile *);
static struct type *decode_function_type (struct coff_symbol *,
unsigned int,
- union internal_auxent *);
+ union internal_auxent *,
+ struct objfile *);
-static struct type *coff_read_enum_type (int, int, int);
+static struct type *coff_read_enum_type (int, int, int,
+ struct objfile *);
static struct symbol *process_coff_symbol (struct coff_symbol *,
union internal_auxent *,
csi = (struct coff_symfile_info *) csip;
name = bfd_get_section_name (abfd, sectp);
- if (DEPRECATED_STREQ (name, ".text"))
+ if (strcmp (name, ".text") == 0)
{
csi->textaddr = bfd_section_vma (abfd, sectp);
csi->textsize += bfd_section_size (abfd, sectp);
{
csi->textsize += bfd_section_size (abfd, sectp);
}
- else if (DEPRECATED_STREQ (name, ".stabstr"))
+ else if (strcmp (name, ".stabstr") == 0)
{
csi->stabstrsect = sectp;
}
this pointer into last_source_file and we put it in
subfiles->name, which end_symtab frees; that's why
it must be malloc'd. */
- savestring (name, strlen (name)),
+ xstrdup (name),
/* We never know the directory name for COFF. */
NULL,
/* The start address is irrelevant, since we set
{
if (last_source_file != NULL)
xfree (last_source_file);
- last_source_file = savestring (name, strlen (name));
+ last_source_file = xstrdup (name);
current_source_start_addr = start_addr;
current_source_end_addr = start_addr + size;
}
bfd_section = cs_to_bfd_section (cs, objfile);
return prim_record_minimal_symbol_and_info (cs->c_name, address, type,
- NULL, section, bfd_section, objfile);
+ section, bfd_section, objfile);
}
\f
/* coff_symfile_init ()
/* Let stabs reader clean up */
stabsread_clear_cache ();
+
+ dwarf2_free_objfile (objfile);
}
\f
coff_symtab_read (long symtab_offset, unsigned int nsyms,
struct objfile *objfile)
{
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
struct context_stack *new;
struct coff_symbol coff_symbol;
struct coff_symbol *cs = &coff_symbol;
coff_end_symtab (objfile);
coff_start_symtab ("_globals_");
+ /* coff_start_symtab will set the language of this symtab to
+ language_unknown, since such a ``file name'' is not
+ recognized. Override that with the minimal language to
+ allow printing values in this symtab. */
+ current_subfile->language = language_minimal;
complete_symtab ("_globals_", 0, 0);
/* done with all files, everything from here on out is globals */
}
case C_THUMBSTATFUNC:
if (cs->c_name[0] == '.')
{
- if (DEPRECATED_STREQ (cs->c_name, ".text"))
+ if (strcmp (cs->c_name, ".text") == 0)
{
/* FIXME: don't wire in ".text" as section name
or symbol name! */
cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC
|| cs->c_sclass == C_THUMBEXT ?
mst_text : mst_file_text;
- tmpaddr = gdbarch_smash_text_address
- (current_gdbarch, tmpaddr);
+ tmpaddr = gdbarch_smash_text_address (gdbarch, tmpaddr);
}
else if (bfd_section->flags & SEC_ALLOC
&& bfd_section->flags & SEC_LOAD)
msym = record_minimal_symbol (cs, tmpaddr, ms_type, sec, objfile);
if (msym)
- gdbarch_coff_make_msymbol_special
- (current_gdbarch, cs->c_sclass, msym);
+ gdbarch_coff_make_msymbol_special (gdbarch, cs->c_sclass, msym);
if (SDB_TYPE (cs->c_type))
{
break;
case C_FCN:
- if (DEPRECATED_STREQ (cs->c_name, ".bf"))
+ if (strcmp (cs->c_name, ".bf") == 0)
{
within_function = 1;
new->name =
process_coff_symbol (&fcn_cs_saved, &fcn_aux_saved, objfile);
}
- else if (DEPRECATED_STREQ (cs->c_name, ".ef"))
+ else if (strcmp (cs->c_name, ".ef") == 0)
{
if (!within_function)
error (_("Bad coff function information."));
finish_block (new->name, &local_symbols, new->old_blocks,
new->start_addr,
-#if defined (FUNCTION_EPILOGUE_SIZE)
- /* This macro should be defined only on
- machines where the
- fcn_aux_saved.x_sym.x_misc.x_fsize
- field is always zero.
- So use the .bf record information that
- points to the epilogue and add the size
- of the epilogue. */
- cs->c_value
- + FUNCTION_EPILOGUE_SIZE
- + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)),
-#else
fcn_cs_saved.c_value
+ fcn_aux_saved.x_sym.x_misc.x_fsize
+ ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)),
-#endif
objfile
);
within_function = 0;
break;
case C_BLOCK:
- if (DEPRECATED_STREQ (cs->c_name, ".bb"))
+ if (strcmp (cs->c_name, ".bb") == 0)
{
tmpaddr = cs->c_value;
tmpaddr += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
push_context (++depth, tmpaddr);
}
- else if (DEPRECATED_STREQ (cs->c_name, ".eb"))
+ else if (strcmp (cs->c_name, ".eb") == 0)
{
if (context_stack_depth <= 0)
{ /* We attempted to pop an empty context stack */
if ((nsyms == 0) && (pe_file))
{
- /* We've got no debugging symbols, but it's is a portable
+ /* We've got no debugging symbols, but it's a portable
executable, so try to read the export table */
read_pe_exported_syms (objfile);
}
union internal_auxent *aux)
{
int i;
+ bfd_size_type bytes;
cs->c_symnum = symnum;
- bfd_bread (temp_sym, local_symesz, nlist_bfd_global);
+ bytes = bfd_bread (temp_sym, local_symesz, nlist_bfd_global);
+ if (bytes != local_symesz)
+ error ("%s: error reading symbols", current_objfile->name);
bfd_coff_swap_sym_in (symfile_bfd, temp_sym, (char *) sym);
cs->c_naux = sym->n_numaux & 0xff;
if (cs->c_naux >= 1)
{
- bfd_bread (temp_aux, local_auxesz, nlist_bfd_global);
+ bytes = bfd_bread (temp_aux, local_auxesz, nlist_bfd_global);
+ if (bytes != local_auxesz)
+ error ("%s: error reading symbols", current_objfile->name);
bfd_coff_swap_aux_in (symfile_bfd, temp_aux, sym->n_type, sym->n_sclass,
0, cs->c_naux, (char *) aux);
/* If more than one aux entry, read past it (only the first aux
is important). */
for (i = 1; i < cs->c_naux; i++)
- bfd_bread (temp_aux, local_auxesz, nlist_bfd_global);
+ {
+ bytes = bfd_bread (temp_aux, local_auxesz, nlist_bfd_global);
+ if (bytes != local_auxesz)
+ error ("%s: error reading symbols", current_objfile->name);
+ }
}
cs->c_name = getsymname (sym);
cs->c_value = sym->n_value;
TYPE_CODE (SYMBOL_TYPE (real_sym)) == TYPE_CODE_PTR &&
TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym))) != 0)
{
- char *name = DEPRECATED_SYMBOL_NAME (real_sym);
+ char *name = SYMBOL_LINKAGE_NAME (real_sym);
int hash = hashname (name);
struct symbol *sym, *prev;
prev = 0;
for (sym = opaque_type_chain[hash]; sym;)
{
- if (name[0] == DEPRECATED_SYMBOL_NAME (sym)[0] &&
- strcmp (name + 1, DEPRECATED_SYMBOL_NAME (sym) + 1) == 0)
+ if (name[0] == SYMBOL_LINKAGE_NAME (sym)[0] &&
+ strcmp (name + 1, SYMBOL_LINKAGE_NAME (sym) + 1) == 0)
{
if (prev)
{
memset (sym, 0, sizeof (struct symbol));
name = cs->c_name;
name = EXTERNAL_NAME (name, objfile->obfd);
- SYMBOL_LANGUAGE (sym) = language_auto;
+ SYMBOL_LANGUAGE (sym) = current_subfile->language;
SYMBOL_SET_NAMES (sym, name, strlen (name), objfile);
/* default assumptions */
{
SYMBOL_VALUE (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
SYMBOL_TYPE (sym) =
- lookup_function_type (decode_function_type (cs, cs->c_type, aux));
+ lookup_function_type (decode_function_type (cs, cs->c_type, aux, objfile));
SYMBOL_CLASS (sym) = LOC_BLOCK;
if (cs->c_sclass == C_STAT || cs->c_sclass == C_THUMBSTAT
}
else
{
- SYMBOL_TYPE (sym) = decode_type (cs, cs->c_type, aux);
+ SYMBOL_TYPE (sym) = decode_type (cs, cs->c_type, aux, objfile);
switch (cs->c_sclass)
{
case C_NULL:
case C_ARG:
SYMBOL_CLASS (sym) = LOC_ARG;
+ SYMBOL_IS_ARGUMENT (sym) = 1;
add_symbol_to_list (sym, &local_symbols);
break;
case C_REGPARM:
- SYMBOL_CLASS (sym) = LOC_REGPARM;
+ SYMBOL_CLASS (sym) = LOC_REGISTER;
+ SYMBOL_IS_ARGUMENT (sym) = 1;
SYMBOL_VALUE (sym) = gdbarch_sdb_reg_to_regnum
(current_gdbarch, cs->c_value);
add_symbol_to_list (sym, &local_symbols);
}
else
TYPE_NAME (SYMBOL_TYPE (sym)) =
- concat (DEPRECATED_SYMBOL_NAME (sym), (char *)NULL);
+ concat (SYMBOL_LINKAGE_NAME (sym), (char *)NULL);
}
/* Keep track of any type which points to empty structured type,
TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) !=
TYPE_CODE_UNDEF)
{
- int i = hashname (DEPRECATED_SYMBOL_NAME (sym));
+ int i = hashname (SYMBOL_LINKAGE_NAME (sym));
SYMBOL_VALUE_CHAIN (sym) = opaque_type_chain[i];
opaque_type_chain[i] = sym;
names for anonymous enums, structures, and unions, like
"~0fake" or ".0fake". Thanks, but no thanks... */
if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)
- if (DEPRECATED_SYMBOL_NAME (sym) != NULL
- && *DEPRECATED_SYMBOL_NAME (sym) != '~'
- && *DEPRECATED_SYMBOL_NAME (sym) != '.')
+ if (SYMBOL_LINKAGE_NAME (sym) != NULL
+ && *SYMBOL_LINKAGE_NAME (sym) != '~'
+ && *SYMBOL_LINKAGE_NAME (sym) != '.')
TYPE_TAG_NAME (SYMBOL_TYPE (sym)) =
- concat (DEPRECATED_SYMBOL_NAME (sym), (char *)NULL);
+ concat (SYMBOL_LINKAGE_NAME (sym), (char *)NULL);
add_symbol_to_list (sym, &file_symbols);
break;
static struct type *
decode_type (struct coff_symbol *cs, unsigned int c_type,
- union internal_auxent *aux)
+ union internal_auxent *aux, struct objfile *objfile)
{
struct type *type = 0;
unsigned int new_c_type;
new_c_type = DECREF (c_type);
if (ISPTR (c_type))
{
- type = decode_type (cs, new_c_type, aux);
+ type = decode_type (cs, new_c_type, aux, objfile);
type = lookup_pointer_type (type);
}
else if (ISFCN (c_type))
{
- type = decode_type (cs, new_c_type, aux);
+ type = decode_type (cs, new_c_type, aux, objfile);
type = lookup_function_type (type);
}
else if (ISARY (c_type))
*dim = *(dim + 1);
*dim = 0;
- base_type = decode_type (cs, new_c_type, aux);
- index_type = lookup_fundamental_type (current_objfile, FT_INTEGER);
+ base_type = decode_type (cs, new_c_type, aux, objfile);
+ index_type = builtin_type_int32;
range_type =
create_range_type ((struct type *) NULL, index_type, 0, n - 1);
type =
}
}
- return decode_base_type (cs, BTYPE (c_type), aux);
+ return decode_base_type (cs, BTYPE (c_type), aux, objfile);
}
/* Decode a coff type specifier for function definition;
static struct type *
decode_function_type (struct coff_symbol *cs, unsigned int c_type,
- union internal_auxent *aux)
+ union internal_auxent *aux, struct objfile *objfile)
{
if (aux->x_sym.x_tagndx.l == 0)
cs->c_naux = 0; /* auxent refers to function, not base type */
- return decode_type (cs, DECREF (c_type), aux);
+ return decode_type (cs, DECREF (c_type), aux, objfile);
}
\f
/* basic C types */
static struct type *
decode_base_type (struct coff_symbol *cs, unsigned int c_type,
- union internal_auxent *aux)
+ union internal_auxent *aux, struct objfile *objfile)
{
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
struct type *type;
switch (c_type)
{
case T_NULL:
/* shows up with "void (*foo)();" structure members */
- return lookup_fundamental_type (current_objfile, FT_VOID);
+ return builtin_type (gdbarch)->builtin_void;
#ifdef T_VOID
case T_VOID:
/* Intel 960 COFF has this symbol and meaning. */
- return lookup_fundamental_type (current_objfile, FT_VOID);
+ return builtin_type (gdbarch)->builtin_void;
#endif
case T_CHAR:
- return lookup_fundamental_type (current_objfile, FT_CHAR);
+ return builtin_type (gdbarch)->builtin_char;
case T_SHORT:
- return lookup_fundamental_type (current_objfile, FT_SHORT);
+ return builtin_type (gdbarch)->builtin_short;
case T_INT:
- return lookup_fundamental_type (current_objfile, FT_INTEGER);
+ return builtin_type (gdbarch)->builtin_int;
case T_LONG:
if (cs->c_sclass == C_FIELD
&& aux->x_sym.x_misc.x_lnsz.x_size
- > gdbarch_long_bit (current_gdbarch))
- return lookup_fundamental_type (current_objfile, FT_LONG_LONG);
+ > gdbarch_long_bit (gdbarch))
+ return builtin_type (gdbarch)->builtin_long_long;
else
- return lookup_fundamental_type (current_objfile, FT_LONG);
+ return builtin_type (gdbarch)->builtin_long;
case T_FLOAT:
- return lookup_fundamental_type (current_objfile, FT_FLOAT);
+ return builtin_type (gdbarch)->builtin_float;
case T_DOUBLE:
- return lookup_fundamental_type (current_objfile, FT_DBL_PREC_FLOAT);
+ return builtin_type (gdbarch)->builtin_double;
case T_LNGDBL:
- return lookup_fundamental_type (current_objfile, FT_EXT_PREC_FLOAT);
+ return builtin_type (gdbarch)->builtin_long_double;
case T_STRUCT:
if (cs->c_naux != 1)
{
type = coff_read_struct_type (cs->c_symnum,
aux->x_sym.x_misc.x_lnsz.x_size,
- aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
+ aux->x_sym.x_fcnary.x_fcn.x_endndx.l,
+ objfile);
}
return type;
{
type = coff_read_struct_type (cs->c_symnum,
aux->x_sym.x_misc.x_lnsz.x_size,
- aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
+ aux->x_sym.x_fcnary.x_fcn.x_endndx.l,
+ objfile);
}
TYPE_CODE (type) = TYPE_CODE_UNION;
return type;
{
type = coff_read_enum_type (cs->c_symnum,
aux->x_sym.x_misc.x_lnsz.x_size,
- aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
+ aux->x_sym.x_fcnary.x_fcn.x_endndx.l,
+ objfile);
}
return type;
break;
case T_UCHAR:
- return lookup_fundamental_type (current_objfile, FT_UNSIGNED_CHAR);
+ return builtin_type (gdbarch)->builtin_unsigned_char;
case T_USHORT:
- return lookup_fundamental_type (current_objfile, FT_UNSIGNED_SHORT);
+ return builtin_type (gdbarch)->builtin_unsigned_short;
case T_UINT:
- return lookup_fundamental_type (current_objfile, FT_UNSIGNED_INTEGER);
+ return builtin_type (gdbarch)->builtin_unsigned_int;
case T_ULONG:
if (cs->c_sclass == C_FIELD
&& aux->x_sym.x_misc.x_lnsz.x_size
- > gdbarch_long_bit (current_gdbarch))
- return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG_LONG);
+ > gdbarch_long_bit (gdbarch))
+ return builtin_type (gdbarch)->builtin_unsigned_long_long;
else
- return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG);
+ return builtin_type (gdbarch)->builtin_unsigned_long;
}
complaint (&symfile_complaints, _("Unexpected type for symbol %s"), cs->c_name);
- return lookup_fundamental_type (current_objfile, FT_VOID);
+ return builtin_type (gdbarch)->builtin_void;
}
\f
/* This page contains subroutines of read_type. */
object describing the type. */
static struct type *
-coff_read_struct_type (int index, int length, int lastsym)
+coff_read_struct_type (int index, int length, int lastsym,
+ struct objfile *objfile)
{
struct nextfield
{
{
read_one_sym (ms, &sub_sym, &sub_aux);
name = ms->c_name;
- name = EXTERNAL_NAME (name, current_objfile->obfd);
+ name = EXTERNAL_NAME (name, objfile->obfd);
switch (ms->c_sclass)
{
/* Save the data. */
list->field.name =
- obsavestring (name,
- strlen (name),
- ¤t_objfile->objfile_obstack);
- FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux);
- FIELD_BITPOS (list->field) = 8 * ms->c_value;
+ obsavestring (name, strlen (name), &objfile->objfile_obstack);
+ FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux,
+ objfile);
+ SET_FIELD_BITPOS (list->field, 8 * ms->c_value);
FIELD_BITSIZE (list->field) = 0;
- FIELD_STATIC_KIND (list->field) = 0;
nfields++;
break;
/* Save the data. */
list->field.name =
- obsavestring (name,
- strlen (name),
- ¤t_objfile->objfile_obstack);
- FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux);
- FIELD_BITPOS (list->field) = ms->c_value;
+ obsavestring (name, strlen (name), &objfile->objfile_obstack);
+ FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux,
+ objfile);
+ SET_FIELD_BITPOS (list->field, ms->c_value);
FIELD_BITSIZE (list->field) = sub_aux.x_sym.x_misc.x_lnsz.x_size;
- FIELD_STATIC_KIND (list->field) = 0;
nfields++;
break;
Also defines the symbols that represent the values of the type. */
static struct type *
-coff_read_enum_type (int index, int length, int lastsym)
+coff_read_enum_type (int index, int length, int lastsym,
+ struct objfile *objfile)
{
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
struct symbol *sym;
struct type *type;
int nsyms = 0;
{
read_one_sym (ms, &sub_sym, &sub_aux);
name = ms->c_name;
- name = EXTERNAL_NAME (name, current_objfile->obfd);
+ name = EXTERNAL_NAME (name, objfile->obfd);
switch (ms->c_sclass)
{
case C_MOE:
sym = (struct symbol *) obstack_alloc
- (¤t_objfile->objfile_obstack,
- sizeof (struct symbol));
+ (&objfile->objfile_obstack, sizeof (struct symbol));
memset (sym, 0, sizeof (struct symbol));
- DEPRECATED_SYMBOL_NAME (sym) =
- obsavestring (name, strlen (name),
- ¤t_objfile->objfile_obstack);
+ SYMBOL_SET_LINKAGE_NAME (sym,
+ obsavestring (name, strlen (name),
+ &objfile->objfile_obstack));
SYMBOL_CLASS (sym) = LOC_CONST;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_VALUE (sym) = ms->c_value;
if (length > 0)
TYPE_LENGTH (type) = length;
else /* Assume ints. */
- TYPE_LENGTH (type) = gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT;
+ TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT;
TYPE_CODE (type) = TYPE_CODE_ENUM;
TYPE_NFIELDS (type) = nsyms;
TYPE_FIELDS (type) = (struct field *)
{
struct symbol *xsym = syms->symbol[j];
SYMBOL_TYPE (xsym) = type;
- TYPE_FIELD_NAME (type, n) = DEPRECATED_SYMBOL_NAME (xsym);
- TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
+ TYPE_FIELD_NAME (type, n) = SYMBOL_LINKAGE_NAME (xsym);
+ SET_FIELD_BITPOS (TYPE_FIELD (type, n), SYMBOL_VALUE (xsym));
if (SYMBOL_VALUE (xsym) < 0)
unsigned_enum = 0;
TYPE_FIELD_BITSIZE (type, n) = 0;
- TYPE_FIELD_STATIC_KIND (type, n) = 0;
}
if (syms == osyms)
break;
}
if (unsigned_enum)
- TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
+ TYPE_UNSIGNED (type) = 1;
return type;
}
default_symfile_offsets, /* sym_offsets: xlate external to internal form */
default_symfile_segments, /* sym_segments: Get segment information from
a file. */
+ NULL, /* sym_read_linetable */
NULL /* next: pointer to next struct sym_fns */
};
projects / deliverable / binutils-gdb.git / blobdiff