/* Read a symbol table in ECOFF format (Third-Eye).
Copyright (C) 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
- 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007
+ 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009, 2010
Free Software Foundation, Inc.
Original version contributed by Alessandro Forin (af@cs.cmu.edu) at
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* This module provides the function mdebug_build_psymtabs. It reads
ECOFF debugging information into partial symbol tables. The
#include "mdebugread.h"
#include "gdb_stat.h"
#include "gdb_string.h"
+#include "psympriv.h"
#include "bfd.h"
static char stabs_symbol[] = STABS_SYMBOL;
-/* Types corresponding to mdebug format bt* basic types. */
-
-static struct type *mdebug_type_void;
-static struct type *mdebug_type_char;
-static struct type *mdebug_type_short;
-static struct type *mdebug_type_int_32;
-#define mdebug_type_int mdebug_type_int_32
-static struct type *mdebug_type_int_64;
-static struct type *mdebug_type_long_32;
-static struct type *mdebug_type_long_64;
-static struct type *mdebug_type_long_long_64;
-static struct type *mdebug_type_unsigned_char;
-static struct type *mdebug_type_unsigned_short;
-static struct type *mdebug_type_unsigned_int_32;
-static struct type *mdebug_type_unsigned_int_64;
-static struct type *mdebug_type_unsigned_long_32;
-static struct type *mdebug_type_unsigned_long_64;
-static struct type *mdebug_type_unsigned_long_long_64;
-static struct type *mdebug_type_adr_32;
-static struct type *mdebug_type_adr_64;
-static struct type *mdebug_type_float;
-static struct type *mdebug_type_double;
-static struct type *mdebug_type_complex;
-static struct type *mdebug_type_double_complex;
-static struct type *mdebug_type_fixed_dec;
-static struct type *mdebug_type_float_dec;
-static struct type *mdebug_type_string;
-
/* Nonzero if we have seen ecoff debugging info for a file. */
static int found_ecoff_debugging_info;
static void add_block (struct block *, struct symtab *);
-static void add_symbol (struct symbol *, struct block *);
+static void add_symbol (struct symbol *, struct symtab *, struct block *);
static int add_line (struct linetable *, int, CORE_ADDR, int);
static void
mdebug_psymtab_to_symtab (struct partial_symtab *pst)
{
-
if (!pst)
return;
aux symbols are big-endian or little-endian. Return count of
SYMR's handled (normally one). */
+static int
+mdebug_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch)
+{
+ return gdbarch_ecoff_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
+}
+
+static const struct symbol_register_ops mdebug_register_funcs = {
+ mdebug_reg_to_regnum
+};
+
static int
parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
struct section_offsets *section_offsets, struct objfile *objfile)
{
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
const bfd_size_type external_sym_size = debug_swap->external_sym_size;
void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
char *name;
/* It is a FORTRAN common block. At least for SGI Fortran the
address is not in the symbol; we need to fix it later in
scan_file_globals. */
- int bucket = hashname (DEPRECATED_SYMBOL_NAME (s));
+ int bucket = hashname (SYMBOL_LINKAGE_NAME (s));
SYMBOL_VALUE_CHAIN (s) = global_sym_chain[bucket];
global_sym_chain[bucket] = s;
}
goto data;
case stLocal: /* local variable, goes into current block */
+ b = top_stack->cur_block;
+ s = new_symbol (name);
+ SYMBOL_VALUE (s) = svalue;
if (sh->sc == scRegister)
{
class = LOC_REGISTER;
- svalue = gdbarch_ecoff_reg_to_regnum (current_gdbarch, svalue);
+ SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
}
else
class = LOC_LOCAL;
- b = top_stack->cur_block;
- s = new_symbol (name);
- SYMBOL_VALUE (s) = svalue;
data: /* Common code for symbols describing data */
SYMBOL_DOMAIN (s) = VAR_DOMAIN;
SYMBOL_CLASS (s) = class;
- add_symbol (s, b);
+ add_symbol (s, top_stack->cur_st, b);
/* Type could be missing if file is compiled without debugging info. */
if (SC_IS_UNDEF (sh->sc)
|| sh->sc == scNil || sh->index == indexNil)
- SYMBOL_TYPE (s) = builtin_type (current_gdbarch)->nodebug_data_symbol;
+ SYMBOL_TYPE (s) = objfile_type (objfile)->nodebug_data_symbol;
else
SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
/* Value of a data symbol is its memory address */
s = new_symbol (name);
SYMBOL_DOMAIN (s) = VAR_DOMAIN;
+ SYMBOL_IS_ARGUMENT (s) = 1;
switch (sh->sc)
{
case scRegister:
/* Pass by value in register. */
- SYMBOL_CLASS (s) = LOC_REGPARM;
- svalue = gdbarch_ecoff_reg_to_regnum (current_gdbarch, svalue);
+ SYMBOL_CLASS (s) = LOC_REGISTER;
+ SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
break;
case scVar:
/* Pass by reference on stack. */
case scVarRegister:
/* Pass by reference in register. */
SYMBOL_CLASS (s) = LOC_REGPARM_ADDR;
- svalue = gdbarch_ecoff_reg_to_regnum (current_gdbarch, svalue);
+ SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
break;
default:
/* Pass by value on stack. */
}
SYMBOL_VALUE (s) = svalue;
SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
- add_symbol (s, top_stack->cur_block);
+ add_symbol (s, top_stack->cur_st, top_stack->cur_block);
break;
case stLabel: /* label, goes into current block */
SYMBOL_DOMAIN (s) = VAR_DOMAIN; /* so that it can be used */
SYMBOL_CLASS (s) = LOC_LABEL; /* but not misused */
SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
- SYMBOL_TYPE (s) = mdebug_type_int;
- add_symbol (s, top_stack->cur_block);
+ SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_int;
+ add_symbol (s, top_stack->cur_st, top_stack->cur_block);
break;
case stProc: /* Procedure, usually goes into global block */
SYMBOL_CLASS (s) = LOC_BLOCK;
/* Type of the return value */
if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil)
- t = mdebug_type_int;
+ t = objfile_type (objfile)->builtin_int;
else
{
t = parse_type (cur_fd, ax, sh->index + 1, 0, bigend, name);
if (sh->st == stProc)
{
struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
+
/* The next test should normally be true, but provides a
hook for nested functions (which we don't want to make
global). */
else if (sh->value == top_stack->procadr)
b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
}
- add_symbol (s, b);
+ add_symbol (s, top_stack->cur_st, b);
/* Make a type for the procedure itself */
SYMBOL_TYPE (s) = lookup_function_type (t);
/* All functions in C++ have prototypes. For C we don't have enough
information in the debug info. */
if (SYMBOL_LANGUAGE (s) == language_cplus)
- TYPE_FLAGS (SYMBOL_TYPE (s)) |= TYPE_FLAG_PROTOTYPED;
+ TYPE_PROTOTYPED (SYMBOL_TYPE (s)) = 1;
/* Create and enter a new lexical context */
b = new_block (FUNCTION_BLOCK);
if (sh->iss == 0 || name[0] == '.' || name[0] == '\0')
TYPE_TAG_NAME (t) = NULL;
else
- TYPE_TAG_NAME (t) = obconcat (¤t_objfile->objfile_obstack,
- "", "", name);
+ TYPE_TAG_NAME (t) = obconcat (¤t_objfile->objfile_obstack, name,
+ (char *) NULL);
TYPE_CODE (t) = type_code;
TYPE_LENGTH (t) = sh->value;
that too. */
if (TYPE_LENGTH (t) == TYPE_NFIELDS (t)
|| TYPE_LENGTH (t) == 0)
- TYPE_LENGTH (t) =
- gdbarch_int_bit (current_gdbarch) / HOST_CHAR_BIT;
+ TYPE_LENGTH (t) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
for (ext_tsym = ext_sh + external_sym_size;
;
ext_tsym += external_sym_size)
if (tsym.st != stMember)
break;
- FIELD_BITPOS (*f) = tsym.value;
+ SET_FIELD_BITPOS (*f, tsym.value);
FIELD_TYPE (*f) = t;
FIELD_NAME (*f) = debug_info->ss + cur_fdr->issBase + tsym.iss;
FIELD_BITSIZE (*f) = 0;
- FIELD_STATIC_KIND (*f) = 0;
enum_sym = ((struct symbol *)
obstack_alloc (¤t_objfile->objfile_obstack,
sizeof (struct symbol)));
memset (enum_sym, 0, sizeof (struct symbol));
- DEPRECATED_SYMBOL_NAME (enum_sym) =
- obsavestring (f->name, strlen (f->name),
- ¤t_objfile->objfile_obstack);
+ SYMBOL_SET_LINKAGE_NAME
+ (enum_sym, obsavestring (f->name, strlen (f->name),
+ ¤t_objfile->objfile_obstack));
SYMBOL_CLASS (enum_sym) = LOC_CONST;
SYMBOL_TYPE (enum_sym) = t;
SYMBOL_DOMAIN (enum_sym) = VAR_DOMAIN;
SYMBOL_VALUE (enum_sym) = tsym.value;
if (SYMBOL_VALUE (enum_sym) < 0)
unsigned_enum = 0;
- add_symbol (enum_sym, top_stack->cur_block);
+ add_symbol (enum_sym, top_stack->cur_st, top_stack->cur_block);
/* Skip the stMembers that we've handled. */
count++;
f++;
}
if (unsigned_enum)
- TYPE_FLAGS (t) |= TYPE_FLAG_UNSIGNED;
+ TYPE_UNSIGNED (t) = 1;
}
/* make this the current type */
top_stack->cur_type = t;
do not create a symbol for it either. */
if (TYPE_NFIELDS (t) == 0)
{
- TYPE_FLAGS (t) |= TYPE_FLAG_STUB;
+ TYPE_STUB (t) = 1;
break;
}
SYMBOL_CLASS (s) = LOC_TYPEDEF;
SYMBOL_VALUE (s) = 0;
SYMBOL_TYPE (s) = t;
- add_symbol (s, top_stack->cur_block);
+ add_symbol (s, top_stack->cur_st, top_stack->cur_block);
break;
/* End of local variables shared by struct, union, enum, and
s = new_symbol (MDEBUG_EFI_SYMBOL_NAME);
SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
SYMBOL_CLASS (s) = LOC_CONST;
- SYMBOL_TYPE (s) = mdebug_type_void;
+ SYMBOL_TYPE (s) = objfile_type (current_objfile)->builtin_void;
e = ((struct mdebug_extra_func_info *)
obstack_alloc (¤t_objfile->objfile_obstack,
sizeof (struct mdebug_extra_func_info)));
memset (e, 0, sizeof (struct mdebug_extra_func_info));
- SYMBOL_VALUE (s) = (long) e;
+ SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e;
e->numargs = top_stack->numargs;
e->pdr.framereg = -1;
- add_symbol (s, top_stack->cur_block);
+ add_symbol (s, top_stack->cur_st, top_stack->cur_block);
/* f77 emits proc-level with address bounds==[0,0],
So look for such child blocks, and patch them. */
for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++)
{
struct block *b_bad = BLOCKVECTOR_BLOCK (bv, i);
+
if (BLOCK_SUPERBLOCK (b_bad) == b
&& BLOCK_START (b_bad) == top_stack->procadr
&& BLOCK_END (b_bad) == top_stack->procadr)
if (nparams > 0)
{
struct dict_iterator iter;
+
TYPE_NFIELDS (ftype) = nparams;
TYPE_FIELDS (ftype) = (struct field *)
TYPE_ALLOC (ftype, nparams * sizeof (struct field));
if (iparams == nparams)
break;
- switch (SYMBOL_CLASS (sym))
+ if (SYMBOL_IS_ARGUMENT (sym))
{
- case LOC_ARG:
- case LOC_REF_ARG:
- case LOC_REGPARM:
- case LOC_REGPARM_ADDR:
TYPE_FIELD_TYPE (ftype, iparams) = SYMBOL_TYPE (sym);
TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
iparams++;
- break;
- default:
- break;
}
}
}
case stMember: /* member of struct or union */
f = &TYPE_FIELDS (top_stack->cur_type)[top_stack->cur_field++];
FIELD_NAME (*f) = name;
- FIELD_BITPOS (*f) = sh->value;
+ SET_FIELD_BITPOS (*f, sh->value);
bitsize = 0;
FIELD_TYPE (*f) = parse_type (cur_fd, ax, sh->index, &bitsize, bigend, name);
FIELD_BITSIZE (*f) = bitsize;
- FIELD_STATIC_KIND (*f) = 0;
break;
case stIndirect: /* forward declaration on Irix5 */
SYMBOL_CLASS (s) = LOC_TYPEDEF;
SYMBOL_BLOCK_VALUE (s) = top_stack->cur_block;
SYMBOL_TYPE (s) = t;
- add_symbol (s, top_stack->cur_block);
+ add_symbol (s, top_stack->cur_st, top_stack->cur_block);
/* Incomplete definitions of structs should not get a name. */
if (TYPE_NAME (SYMBOL_TYPE (s)) == NULL
for anything except pointers or functions. */
}
else
- TYPE_NAME (SYMBOL_TYPE (s)) = DEPRECATED_SYMBOL_NAME (s);
+ TYPE_NAME (SYMBOL_TYPE (s)) = SYMBOL_LINKAGE_NAME (s);
}
break;
return count;
}
+/* Basic types. */
+
+static const struct objfile_data *basic_type_data;
+
+static struct type *
+basic_type (int bt, struct objfile *objfile)
+{
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ struct type **map_bt = objfile_data (objfile, basic_type_data);
+ struct type *tp;
+
+ if (bt >= btMax)
+ return NULL;
+
+ if (!map_bt)
+ {
+ map_bt = OBSTACK_CALLOC (&objfile->objfile_obstack,
+ btMax, struct type *);
+ set_objfile_data (objfile, basic_type_data, map_bt);
+ }
+
+ if (map_bt[bt])
+ return map_bt[bt];
+
+ switch (bt)
+ {
+ case btNil:
+ tp = objfile_type (objfile)->builtin_void;
+ break;
+
+ case btAdr:
+ tp = init_type (TYPE_CODE_PTR, 4, TYPE_FLAG_UNSIGNED,
+ "adr_32", objfile);
+ TYPE_TARGET_TYPE (tp) = objfile_type (objfile)->builtin_void;
+ break;
+
+ case btChar:
+ tp = init_type (TYPE_CODE_INT, 1, 0,
+ "char", objfile);
+ break;
+
+ case btUChar:
+ tp = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED,
+ "unsigned char", objfile);
+ break;
+
+ case btShort:
+ tp = init_type (TYPE_CODE_INT, 2, 0,
+ "short", objfile);
+ break;
+
+ case btUShort:
+ tp = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED,
+ "unsigned short", objfile);
+ break;
+
+ case btInt:
+ tp = init_type (TYPE_CODE_INT, 4, 0,
+ "int", objfile);
+ break;
+
+ case btUInt:
+ tp = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
+ "unsigned int", objfile);
+ break;
+
+ case btLong:
+ tp = init_type (TYPE_CODE_INT, 4, 0,
+ "long", objfile);
+ break;
+
+ case btULong:
+ tp = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
+ "unsigned long", objfile);
+ break;
+
+ case btFloat:
+ tp = init_type (TYPE_CODE_FLT,
+ gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0,
+ "float", objfile);
+ break;
+
+ case btDouble:
+ tp = init_type (TYPE_CODE_FLT,
+ gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
+ "double", objfile);
+ break;
+
+ case btComplex:
+ tp = init_type (TYPE_CODE_COMPLEX,
+ 2 * gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0,
+ "complex", objfile);
+ TYPE_TARGET_TYPE (tp) = basic_type (btFloat, objfile);
+ break;
+
+ case btDComplex:
+ tp = init_type (TYPE_CODE_COMPLEX,
+ 2 * gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
+ "double complex", objfile);
+ TYPE_TARGET_TYPE (tp) = basic_type (btDouble, objfile);
+ break;
+
+ case btFixedDec:
+ /* We use TYPE_CODE_INT to print these as integers. Does this do any
+ good? Would we be better off with TYPE_CODE_ERROR? Should
+ TYPE_CODE_ERROR print things in hex if it knows the size? */
+ tp = init_type (TYPE_CODE_INT,
+ gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, 0,
+ "fixed decimal", objfile);
+ break;
+
+ case btFloatDec:
+ tp = init_type (TYPE_CODE_ERROR,
+ gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
+ "floating decimal", objfile);
+ break;
+
+ case btString:
+ /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
+ FIXME. */
+ tp = init_type (TYPE_CODE_STRING, 1, 0,
+ "string", objfile);
+ break;
+
+ case btVoid:
+ tp = objfile_type (objfile)->builtin_void;
+ break;
+
+ case btLong64:
+ tp = init_type (TYPE_CODE_INT, 8, 0,
+ "long", objfile);
+ break;
+
+ case btULong64:
+ tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
+ "unsigned long", objfile);
+ break;
+
+ case btLongLong64:
+ tp = init_type (TYPE_CODE_INT, 8, 0,
+ "long long", objfile);
+ break;
+
+ case btULongLong64:
+ tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
+ "unsigned long long", objfile);
+ break;
+
+ case btAdr64:
+ tp = init_type (TYPE_CODE_PTR, 8, TYPE_FLAG_UNSIGNED,
+ "adr_64", objfile);
+ TYPE_TARGET_TYPE (tp) = objfile_type (objfile)->builtin_void;
+ break;
+
+ case btInt64:
+ tp = init_type (TYPE_CODE_INT, 8, 0,
+ "int", objfile);
+ break;
+
+ case btUInt64:
+ tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
+ "unsigned int", objfile);
+ break;
+
+ default:
+ tp = NULL;
+ break;
+ }
+
+ map_bt[bt] = tp;
+ return tp;
+}
+
/* Parse the type information provided in the raw AX entries for
the symbol SH. Return the bitfield size in BS, in case.
We must byte-swap the AX entries before we use them; BIGEND says whether
parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
int bigend, char *sym_name)
{
- /* Null entries in this map are treated specially */
- static struct type **map_bt[] =
- {
- &mdebug_type_void, /* btNil */
- &mdebug_type_adr_32, /* btAdr */
- &mdebug_type_char, /* btChar */
- &mdebug_type_unsigned_char, /* btUChar */
- &mdebug_type_short, /* btShort */
- &mdebug_type_unsigned_short, /* btUShort */
- &mdebug_type_int_32, /* btInt */
- &mdebug_type_unsigned_int_32, /* btUInt */
- &mdebug_type_long_32, /* btLong */
- &mdebug_type_unsigned_long_32, /* btULong */
- &mdebug_type_float, /* btFloat */
- &mdebug_type_double, /* btDouble */
- 0, /* btStruct */
- 0, /* btUnion */
- 0, /* btEnum */
- 0, /* btTypedef */
- 0, /* btRange */
- 0, /* btSet */
- &mdebug_type_complex, /* btComplex */
- &mdebug_type_double_complex, /* btDComplex */
- 0, /* btIndirect */
- &mdebug_type_fixed_dec, /* btFixedDec */
- &mdebug_type_float_dec, /* btFloatDec */
- &mdebug_type_string, /* btString */
- 0, /* btBit */
- 0, /* btPicture */
- &mdebug_type_void, /* btVoid */
- 0, /* DEC C++: Pointer to member */
- 0, /* DEC C++: Virtual function table */
- 0, /* DEC C++: Class (Record) */
- &mdebug_type_long_64, /* btLong64 */
- &mdebug_type_unsigned_long_64, /* btULong64 */
- &mdebug_type_long_long_64, /* btLongLong64 */
- &mdebug_type_unsigned_long_long_64, /* btULongLong64 */
- &mdebug_type_adr_64, /* btAdr64 */
- &mdebug_type_int_64, /* btInt64 */
- &mdebug_type_unsigned_int_64, /* btUInt64 */
- };
-
TIR t[1];
struct type *tp = 0;
enum type_code type_code = TYPE_CODE_UNDEF;
/* Handle undefined types, they have indexNil. */
if (aux_index == indexNil)
- return mdebug_type_int;
+ return basic_type (btInt, current_objfile);
/* Handle corrupt aux indices. */
if (aux_index >= (debug_info->fdr + fd)->caux)
{
index_complaint (sym_name);
- return mdebug_type_int;
+ return basic_type (btInt, current_objfile);
}
ax += aux_index;
/* Use aux as a type information record, map its basic type. */
(*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t);
- if (t->bt >= (sizeof (map_bt) / sizeof (*map_bt)))
- {
- basic_type_complaint (t->bt, sym_name);
- return mdebug_type_int;
- }
- if (map_bt[t->bt])
+ tp = basic_type (t->bt, current_objfile);
+ if (tp == NULL)
{
- tp = *map_bt[t->bt];
- }
- else
- {
- tp = NULL;
/* Cannot use builtin types -- build our own */
switch (t->bt)
{
break;
default:
basic_type_complaint (t->bt, sym_name);
- return mdebug_type_int;
+ return basic_type (btInt, current_objfile);
}
}
if (t->fBitfield)
{
int width = AUX_GET_WIDTH (bigend, ax);
+
/* Inhibit core dumps if TIR is corrupted. */
if (bs == (int *) NULL)
{
as short and unsigned short types with a field width of 8.
Enum types also have a field width which we ignore for now. */
if (t->bt == btShort && width == 8)
- tp = mdebug_type_char;
+ tp = basic_type (btChar, current_objfile);
else if (t->bt == btUShort && width == 8)
- tp = mdebug_type_unsigned_char;
+ tp = basic_type (btUChar, current_objfile);
else if (t->bt == btEnum)
;
else
{
complaint (&symfile_complaints,
_("unable to cross ref btIndirect for %s"), sym_name);
- return mdebug_type_int;
+ return basic_type (btInt, current_objfile);
}
xref_fh = get_rfd (fd, rf);
xref_fd = xref_fh - debug_info->fdr;
}
else
{
-
/* Usually, TYPE_CODE(tp) is already type_code. The main
exception is if we guessed wrong re struct/union/enum.
But for struct vs. union a wrong guess is harmless, so
{
complaint (&symfile_complaints,
_("unable to cross ref btTypedef for %s"), sym_name);
- tp = mdebug_type_int;
+ tp = basic_type (btInt, current_objfile);
}
}
/* Deal with range types */
if (t->bt == btRange)
{
- TYPE_NFIELDS (tp) = 2;
- TYPE_FIELDS (tp) = ((struct field *)
- TYPE_ALLOC (tp, 2 * sizeof (struct field)));
- TYPE_FIELD_NAME (tp, 0) = obsavestring ("Low", strlen ("Low"),
- ¤t_objfile->objfile_obstack);
- TYPE_FIELD_BITPOS (tp, 0) = AUX_GET_DNLOW (bigend, ax);
+ TYPE_NFIELDS (tp) = 0;
+ TYPE_RANGE_DATA (tp) = ((struct range_bounds *)
+ TYPE_ZALLOC (tp, sizeof (struct range_bounds)));
+ TYPE_LOW_BOUND (tp) = AUX_GET_DNLOW (bigend, ax);
ax++;
- TYPE_FIELD_NAME (tp, 1) = obsavestring ("High", strlen ("High"),
- ¤t_objfile->objfile_obstack);
- TYPE_FIELD_BITPOS (tp, 1) = AUX_GET_DNHIGH (bigend, ax);
+ TYPE_HIGH_BOUND (tp) = AUX_GET_DNHIGH (bigend, ax);
ax++;
}
{
complaint (&symfile_complaints,
_("illegal array index type for %s, assuming int"), sym_name);
- indx = mdebug_type_int;
+ indx = objfile_type (current_objfile)->builtin_int;
}
/* Get the bounds, and create the array type. */
ignore the erroneous bitsize from the auxiliary entry safely.
dbx seems to ignore it too. */
- /* TYPE_FLAG_TARGET_STUB now takes care of the zero TYPE_LENGTH
- problem. */
+ /* TYPE_TARGET_STUB now takes care of the zero TYPE_LENGTH problem. */
if (TYPE_LENGTH (*tpp) == 0)
- {
- TYPE_FLAGS (t) |= TYPE_FLAG_TARGET_STUB;
- }
+ TYPE_TARGET_STUB (t) = 1;
*tpp = t;
return 4 + off;
{
struct symbol *s, *i;
struct block *b;
- struct mdebug_extra_func_info *e;
char *sh_name;
/* Simple rule to find files linked "-x" */
the same name exists, lookup_symbol will eventually read in the symtab
for the global function and clobber cur_fdr. */
FDR *save_cur_fdr = cur_fdr;
- s = lookup_symbol (sh_name, NULL, VAR_DOMAIN, 0, NULL);
+
+ s = lookup_symbol (sh_name, NULL, VAR_DOMAIN, 0);
cur_fdr = save_cur_fdr;
#else
s = mylookup_symbol
SYMBOL_DOMAIN (s) = VAR_DOMAIN;
SYMBOL_CLASS (s) = LOC_BLOCK;
/* Donno its type, hope int is ok */
- SYMBOL_TYPE (s) = lookup_function_type (mdebug_type_int);
- add_symbol (s, top_stack->cur_block);
+ SYMBOL_TYPE (s)
+ = lookup_function_type (objfile_type (pst->objfile)->builtin_int);
+ add_symbol (s, top_stack->cur_st, top_stack->cur_block);
/* Wont have symbols for this one */
b = new_block (2);
SYMBOL_BLOCK_VALUE (s) = b;
if (i)
{
- e = (struct mdebug_extra_func_info *) SYMBOL_VALUE (i);
+ struct mdebug_extra_func_info *e;
+
+ e = (struct mdebug_extra_func_info *) SYMBOL_VALUE_BYTES (i);
e->pdr = *pr;
- e->pdr.isym = (long) s;
/* GDB expects the absolute function start address for the
procedure descriptor in e->pdr.adr.
To work around these problems, we replace e->pdr.adr with
the start address of the function. */
e->pdr.adr = BLOCK_START (b);
-
- /* Correct incorrect setjmp procedure descriptor from the library
- to make backtrace through setjmp work. */
- if (e->pdr.pcreg == 0
- && strcmp (sh_name, "setjmp") == 0)
- {
- complaint (&symfile_complaints, _("fixing bad setjmp PDR from libc"));
-#ifdef RA_REGNUM
- e->pdr.pcreg = RA_REGNUM;
-#else
- e->pdr.pcreg = 0;
-#endif
- e->pdr.regmask = 0x80000000;
- e->pdr.regoffset = -4;
- }
}
/* It would be reasonable that functions that have been compiled
if (processing_gcc_compilation == 0
&& found_ecoff_debugging_info == 0
&& TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s))) == TYPE_CODE_VOID)
- SYMBOL_TYPE (s) = builtin_type (current_gdbarch)->nodebug_text_symbol;
+ SYMBOL_TYPE (s) = objfile_type (pst->objfile)->nodebug_text_symbol;
}
/* Parse the external symbol ES. Just call parse_symbol() after
bfd_section = NULL;
}
- prim_record_minimal_symbol_and_info (name, address, ms_type, NULL,
+ prim_record_minimal_symbol_and_info (name, address, ms_type,
section, bfd_section, objfile);
}
static void
parse_partial_symbols (struct objfile *objfile)
{
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
const bfd_size_type external_sym_size = debug_swap->external_sym_size;
const bfd_size_type external_rfd_size = debug_swap->external_rfd_size;
const bfd_size_type external_ext_size = debug_swap->external_ext_size;
fdr_to_pst++;
{
struct partial_symtab *pst = new_psymtab ("", objfile);
+
fdr_to_pst[-1].pst = pst;
FDR_IDX (pst) = -1;
}
textlow,
objfile->global_psymbols.next,
objfile->static_psymbols.next);
- pst->read_symtab_private = ((char *)
- obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct symloc)));
+ pst->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
+ sizeof (struct symloc));
memset (pst->read_symtab_private, 0, sizeof (struct symloc));
save_pst = pst;
{
char *stabstring = debug_info->ss + fh->issBase + sh.iss;
int len = strlen (stabstring);
+
while (stabstring[len - 1] == '\\')
{
SYMR sh2;
switch (type_code)
{
char *p;
+
/*
* Standard, external, non-debugger, symbols
*/
prev_textlow_not_set = textlow_not_set;
-#ifdef SOFUN_ADDRESS_MAYBE_MISSING
/* A zero value is probably an indication for the SunPRO 3.0
compiler. end_psymtab explicitly tests for zero, so
don't relocate it. */
- if (sh.value == 0)
+ if (sh.value == 0
+ && gdbarch_sofun_address_maybe_missing (gdbarch))
{
textlow_not_set = 1;
valu = 0;
}
else
textlow_not_set = 0;
-#else
- textlow_not_set = 0;
-#endif
+
past_first_source_file = 1;
if (prev_so_symnum != symnum - 1)
- { /* Here if prev stab wasn't N_SO */
+ { /* Here if prev stab wasn't N_SO */
first_so_symnum = symnum;
if (pst)
case N_SOL:
{
enum language tmp_language;
+
/* Mark down an include file in the current psymtab */
/* SET_NAMESTRING ();*/
in a binary tree, if profiling shows this is a major hog). */
if (pst && strcmp (namestring, pst->filename) == 0)
continue;
+
{
int i;
+
for (i = 0; i < includes_used; i++)
if (strcmp (namestring,
psymtab_include_list[i]) == 0)
{
case 'S':
sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
-#ifdef STATIC_TRANSFORM_NAME
- namestring = STATIC_TRANSFORM_NAME (namestring);
-#endif
- add_psymbol_to_list (namestring, p - namestring,
+
+ if (gdbarch_static_transform_name_p (gdbarch))
+ namestring = gdbarch_static_transform_name
+ (gdbarch, namestring);
+
+ add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_STATIC,
&objfile->static_psymbols,
0, sh.value,
sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
/* The addresses in these entries are reported to be
wrong. See the code that reads 'G's for symtabs. */
- add_psymbol_to_list (namestring, p - namestring,
+ add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_STATIC,
&objfile->global_psymbols,
0, sh.value,
|| (p == namestring + 1
&& namestring[0] != ' '))
{
- add_psymbol_to_list (namestring, p - namestring,
+ add_psymbol_to_list (namestring, p - namestring, 1,
STRUCT_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
sh.value, 0,
{
/* Also a typedef with the same name. */
add_psymbol_to_list (namestring, p - namestring,
+ 1,
VAR_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
sh.value, 0,
case 't':
if (p != namestring) /* a name is there, not just :T... */
{
- add_psymbol_to_list (namestring, p - namestring,
+ add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
sh.value, 0,
;
/* Note that the value doesn't matter for
enum constants in psymtabs, just in symtabs. */
- add_psymbol_to_list (p, q - p,
+ add_psymbol_to_list (p, q - p, 1,
VAR_DOMAIN, LOC_CONST,
&objfile->static_psymbols, 0,
0, psymtab_language, objfile);
continue;
case 'c':
/* Constant, e.g. from "const" in Pascal. */
- add_psymbol_to_list (namestring, p - namestring,
+ add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_CONST,
&objfile->static_psymbols, sh.value,
0, psymtab_language, objfile);
{
int name_len = p - namestring;
char *name = xmalloc (name_len + 1);
+
memcpy (name, namestring, name_len);
name[name_len] = '\0';
function_outside_compilation_unit_complaint (name);
xfree (name);
}
sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
- add_psymbol_to_list (namestring, p - namestring,
+ add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_BLOCK,
&objfile->static_psymbols,
0, sh.value,
{
int name_len = p - namestring;
char *name = xmalloc (name_len + 1);
+
memcpy (name, namestring, name_len);
name[name_len] = '\0';
function_outside_compilation_unit_complaint (name);
xfree (name);
}
sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
- add_psymbol_to_list (namestring, p - namestring,
+ add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_BLOCK,
&objfile->global_psymbols,
0, sh.value,
continue;
case N_ENDM:
-#ifdef SOFUN_ADDRESS_MAYBE_MISSING
/* Solaris 2 end of module, finish current partial
symbol table. END_PSYMTAB will set
pst->texthigh to the proper value, which is
necessary if a module compiled without
debugging info follows this module. */
- if (pst)
+ if (pst
+ && gdbarch_sofun_address_maybe_missing (gdbarch))
{
pst = (struct partial_symtab *) 0;
includes_used = 0;
dependencies_used = 0;
}
-#endif
continue;
case N_RBRAC:
case stStaticProc:
prim_record_minimal_symbol_and_info (name, sh.value,
- mst_file_text, NULL,
+ mst_file_text,
SECT_OFF_TEXT (objfile), NULL,
objfile);
symbol table, and the MAIN__ symbol via the minimal
symbol table. */
if (sh.st == stProc)
- add_psymbol_to_list (name, strlen (name),
+ add_psymbol_to_list (name, strlen (name), 1,
VAR_DOMAIN, LOC_BLOCK,
&objfile->global_psymbols,
0, sh.value, psymtab_language, objfile);
else
- add_psymbol_to_list (name, strlen (name),
+ add_psymbol_to_list (name, strlen (name), 1,
VAR_DOMAIN, LOC_BLOCK,
&objfile->static_psymbols,
0, sh.value, psymtab_language, objfile);
case stStatic: /* Variable */
if (SC_IS_DATA (sh.sc))
prim_record_minimal_symbol_and_info (name, sh.value,
- mst_file_data, NULL,
+ mst_file_data,
SECT_OFF_DATA (objfile),
NULL,
objfile);
else
prim_record_minimal_symbol_and_info (name, sh.value,
- mst_file_bss, NULL,
+ mst_file_bss,
SECT_OFF_BSS (objfile),
NULL,
objfile);
&& sh.iss != 0
&& sh.index != cur_sdx + 2)
{
- add_psymbol_to_list (name, strlen (name),
+ add_psymbol_to_list (name, strlen (name), 1,
STRUCT_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
0, (CORE_ADDR) 0,
continue;
}
/* Use this gdb symbol */
- add_psymbol_to_list (name, strlen (name),
+ add_psymbol_to_list (name, strlen (name), 1,
VAR_DOMAIN, class,
&objfile->static_psymbols,
0, sh.value, psymtab_language, objfile);
break;
}
name = debug_info->ssext + psh->iss;
- add_psymbol_to_list (name, strlen (name),
+ add_psymbol_to_list (name, strlen (name), 1,
VAR_DOMAIN, class,
&objfile->global_psymbols,
0, svalue,
/* Note that the value doesn't matter for enum constants
in psymtabs, just in symtabs. */
- add_psymbol_to_list (name, strlen (name),
+ add_psymbol_to_list (name, strlen (name), 1,
VAR_DOMAIN, LOC_CONST,
&objfile->static_psymbols, 0,
(CORE_ADDR) 0, psymtab_language, objfile);
if (processing_gcc_compilation != 0)
{
+ struct gdbarch *gdbarch = get_objfile_arch (pst->objfile);
/* This symbol table contains stabs-in-ecoff entries. */
/* Make up special symbol to contain
procedure specific info */
struct mdebug_extra_func_info *e =
- ((struct mdebug_extra_func_info *)
- obstack_alloc (¤t_objfile->objfile_obstack,
- sizeof (struct mdebug_extra_func_info)));
+ ((struct mdebug_extra_func_info *)
+ obstack_alloc (¤t_objfile->objfile_obstack,
+ sizeof (struct mdebug_extra_func_info)));
struct symbol *s = new_symbol (MDEBUG_EFI_SYMBOL_NAME);
memset (e, 0, sizeof (struct mdebug_extra_func_info));
SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
SYMBOL_CLASS (s) = LOC_CONST;
- SYMBOL_TYPE (s) = mdebug_type_void;
- SYMBOL_VALUE (s) = (long) e;
+ SYMBOL_TYPE (s) = objfile_type (pst->objfile)->builtin_void;
+ SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e;
e->pdr.framereg = -1;
add_symbol_to_list (s, &local_symbols);
}
{
/* Handle encoded stab line number. */
valu += ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile));
- record_line (current_subfile, sh.index, valu);
+ record_line (current_subfile, sh.index,
+ gdbarch_addr_bits_remove (gdbarch, valu));
}
}
else if (sh.st == stProc || sh.st == stStaticProc
{
/* This symbol table contains ordinary ecoff entries. */
- int f_max;
int maxlines;
EXTR *ext_ptr;
inc = name[0];
ALL_BLOCK_SYMBOLS (block, iter, sym)
{
- if (DEPRECATED_SYMBOL_NAME (sym)[0] == inc
+ if (SYMBOL_LINKAGE_NAME (sym)[0] == inc
&& SYMBOL_DOMAIN (sym) == domain
&& SYMBOL_CLASS (sym) == class
- && strcmp (DEPRECATED_SYMBOL_NAME (sym), name) == 0)
+ && strcmp (SYMBOL_LINKAGE_NAME (sym), name) == 0)
return sym;
}
/* Add a new symbol S to a block B. */
static void
-add_symbol (struct symbol *s, struct block *b)
+add_symbol (struct symbol *s, struct symtab *symtab, struct block *b)
{
+ SYMBOL_SYMTAB (s) = symtab;
dict_add_symbol (BLOCK_DICT (b), s);
}
BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
s->free_code = free_linetable;
- s->debugformat = obsavestring ("ECOFF", 5,
- &objfile->objfile_obstack);
+ s->debugformat = "ECOFF";
return (s);
}
/* Keep a backpointer to the file's symbols */
- psymtab->read_symtab_private = ((char *)
- obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct symloc)));
+ psymtab->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
+ sizeof (struct symloc));
memset (psymtab->read_symtab_private, 0, sizeof (struct symloc));
CUR_BFD (psymtab) = cur_bfd;
DEBUG_SWAP (psymtab) = debug_swap;
static struct linetable *
shrink_linetable (struct linetable *lt)
{
-
return (struct linetable *) xrealloc ((void *) lt,
(sizeof (struct linetable)
+ ((lt->nitems - 1)
memset (s, 0, sizeof (*s));
SYMBOL_LANGUAGE (s) = psymtab_language;
- SYMBOL_SET_NAMES (s, name, strlen (name), current_objfile);
+ SYMBOL_SET_NAMES (s, name, strlen (name), 1, current_objfile);
return s;
}
t = alloc_type (current_objfile);
TYPE_NAME (t) = name;
- TYPE_CPLUS_SPECIFIC (t) = (struct cplus_struct_type *) &cplus_struct_default;
+ INIT_CPLUS_SPECIFIC (t);
return t;
}
\f
void
_initialize_mdebugread (void)
{
- mdebug_type_void =
- init_type (TYPE_CODE_VOID, 1,
- 0,
- "void", (struct objfile *) NULL);
- mdebug_type_char =
- init_type (TYPE_CODE_INT, 1,
- 0,
- "char", (struct objfile *) NULL);
- mdebug_type_unsigned_char =
- init_type (TYPE_CODE_INT, 1,
- TYPE_FLAG_UNSIGNED,
- "unsigned char", (struct objfile *) NULL);
- mdebug_type_short =
- init_type (TYPE_CODE_INT, 2,
- 0,
- "short", (struct objfile *) NULL);
- mdebug_type_unsigned_short =
- init_type (TYPE_CODE_INT, 2,
- TYPE_FLAG_UNSIGNED,
- "unsigned short", (struct objfile *) NULL);
- mdebug_type_int_32 =
- init_type (TYPE_CODE_INT, 4,
- 0,
- "int", (struct objfile *) NULL);
- mdebug_type_unsigned_int_32 =
- init_type (TYPE_CODE_INT, 4,
- TYPE_FLAG_UNSIGNED,
- "unsigned int", (struct objfile *) NULL);
- mdebug_type_int_64 =
- init_type (TYPE_CODE_INT, 8,
- 0,
- "int", (struct objfile *) NULL);
- mdebug_type_unsigned_int_64 =
- init_type (TYPE_CODE_INT, 8,
- TYPE_FLAG_UNSIGNED,
- "unsigned int", (struct objfile *) NULL);
- mdebug_type_long_32 =
- init_type (TYPE_CODE_INT, 4,
- 0,
- "long", (struct objfile *) NULL);
- mdebug_type_unsigned_long_32 =
- init_type (TYPE_CODE_INT, 4,
- TYPE_FLAG_UNSIGNED,
- "unsigned long", (struct objfile *) NULL);
- mdebug_type_long_64 =
- init_type (TYPE_CODE_INT, 8,
- 0,
- "long", (struct objfile *) NULL);
- mdebug_type_unsigned_long_64 =
- init_type (TYPE_CODE_INT, 8,
- TYPE_FLAG_UNSIGNED,
- "unsigned long", (struct objfile *) NULL);
- mdebug_type_long_long_64 =
- init_type (TYPE_CODE_INT, 8,
- 0,
- "long long", (struct objfile *) NULL);
- mdebug_type_unsigned_long_long_64 =
- init_type (TYPE_CODE_INT, 8,
- TYPE_FLAG_UNSIGNED,
- "unsigned long long", (struct objfile *) NULL);
- mdebug_type_adr_32 =
- init_type (TYPE_CODE_PTR, 4,
- TYPE_FLAG_UNSIGNED,
- "adr_32", (struct objfile *) NULL);
- TYPE_TARGET_TYPE (mdebug_type_adr_32) = mdebug_type_void;
- mdebug_type_adr_64 =
- init_type (TYPE_CODE_PTR, 8,
- TYPE_FLAG_UNSIGNED,
- "adr_64", (struct objfile *) NULL);
- TYPE_TARGET_TYPE (mdebug_type_adr_64) = mdebug_type_void;
- mdebug_type_float =
- init_type (TYPE_CODE_FLT,
- gdbarch_float_bit (current_gdbarch) / TARGET_CHAR_BIT,
- 0, "float", (struct objfile *) NULL);
- mdebug_type_double =
- init_type (TYPE_CODE_FLT,
- gdbarch_double_bit (current_gdbarch) / TARGET_CHAR_BIT,
- 0, "double", (struct objfile *) NULL);
- mdebug_type_complex =
- init_type (TYPE_CODE_COMPLEX,
- 2 * gdbarch_float_bit (current_gdbarch) / TARGET_CHAR_BIT,
- 0, "complex", (struct objfile *) NULL);
- TYPE_TARGET_TYPE (mdebug_type_complex) = mdebug_type_float;
- mdebug_type_double_complex =
- init_type (TYPE_CODE_COMPLEX,
- 2 * gdbarch_double_bit (current_gdbarch) / TARGET_CHAR_BIT,
- 0, "double complex", (struct objfile *) NULL);
- TYPE_TARGET_TYPE (mdebug_type_double_complex) = mdebug_type_double;
-
- /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
- FIXME. */
- mdebug_type_string =
- init_type (TYPE_CODE_STRING,
- TARGET_CHAR_BIT / TARGET_CHAR_BIT,
- 0, "string",
- (struct objfile *) NULL);
-
- /* We use TYPE_CODE_INT to print these as integers. Does this do any
- good? Would we be better off with TYPE_CODE_ERROR? Should
- TYPE_CODE_ERROR print things in hex if it knows the size? */
- mdebug_type_fixed_dec =
- init_type (TYPE_CODE_INT,
- gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
- 0, "fixed decimal",
- (struct objfile *) NULL);
-
- mdebug_type_float_dec =
- init_type (TYPE_CODE_ERROR,
- gdbarch_double_bit (current_gdbarch) / TARGET_CHAR_BIT,
- 0, "floating decimal",
- (struct objfile *) NULL);
+ basic_type_data = register_objfile_data ();
}