/* Read a symbol table in ECOFF format (Third-Eye).
- Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
- 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
- Foundation, Inc.
+ Copyright (C) 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
+ 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007
+ Free Software Foundation, Inc.
Original version contributed by Alessandro Forin (af@cs.cmu.edu) at
CMU. Major work by Per Bothner, John Gilmore and Ian Lance Taylor
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., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
/* This module provides the function mdebug_build_psymtabs. It reads
ECOFF debugging information into partial symbol tables. The
static void
index_complaint (const char *arg1)
{
- complaint (&symfile_complaints, "bad aux index at symbol %s", arg1);
+ complaint (&symfile_complaints, _("bad aux index at symbol %s"), arg1);
}
static void
unknown_ext_complaint (const char *arg1)
{
- complaint (&symfile_complaints, "unknown external symbol %s", arg1);
+ complaint (&symfile_complaints, _("unknown external symbol %s"), arg1);
}
static void
basic_type_complaint (int arg1, const char *arg2)
{
- complaint (&symfile_complaints, "cannot map ECOFF basic type 0x%x for %s",
+ complaint (&symfile_complaints, _("cannot map ECOFF basic type 0x%x for %s"),
arg1, arg2);
}
static void
bad_tag_guess_complaint (const char *arg1)
{
- complaint (&symfile_complaints, "guessed tag type of %s incorrectly", arg1);
+ complaint (&symfile_complaints, _("guessed tag type of %s incorrectly"), arg1);
}
static void
bad_rfd_entry_complaint (const char *arg1, int arg2, int arg3)
{
- complaint (&symfile_complaints, "bad rfd entry for %s: file %d, index %d",
+ complaint (&symfile_complaints, _("bad rfd entry for %s: file %d, index %d"),
arg1, arg2, arg3);
}
static void
unexpected_type_code_complaint (const char *arg1)
{
- complaint (&symfile_complaints, "unexpected type code for %s", arg1);
+ complaint (&symfile_complaints, _("unexpected type code for %s"), arg1);
}
/* Macros and extra defs */
static char *mdebug_next_symbol_text (struct objfile *);
\f
-/* Allocate zeroed memory */
-
-static void *
-xzalloc (unsigned int size)
-{
- void *p = xmalloc (size);
-
- memset (p, 0, size);
- return p;
-}
-
/* Exported procedure: Builds a symtab from the PST partial one.
Restores the environment in effect when PST was created, delegates
most of the work to an ancillary procedure, and sorts
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);
}
scan_file_globals (pst->objfile);
if (info_verbose)
- printf_filtered ("done.\n");
+ printf_filtered (_("done.\n"));
}
\f
/* File-level interface functions */
if (compare_glevel (max_glevel, GLEVEL_2) < 0)
{
if (max_gdbinfo == 0)
- printf_unfiltered ("\n%s not compiled with -g, debugging support is limited.\n",
+ printf_unfiltered (_("\n%s not compiled with -g, debugging support is limited.\n"),
objfile->name);
- printf_unfiltered ("You should compile with -g2 or -g3 for best debugging support.\n");
+ printf_unfiltered (_("You should compile with -g2 or -g3 for best debugging support.\n"));
gdb_flush (gdb_stdout);
}
#endif
if (sh->sc == scRegister)
{
class = LOC_REGISTER;
- svalue = ECOFF_REG_TO_REGNUM (svalue);
+ svalue = gdbarch_ecoff_reg_to_regnum (current_gdbarch, svalue);
}
else
class = LOC_LOCAL;
case scRegister:
/* Pass by value in register. */
SYMBOL_CLASS (s) = LOC_REGPARM;
- svalue = ECOFF_REG_TO_REGNUM (svalue);
+ svalue = gdbarch_ecoff_reg_to_regnum (current_gdbarch, svalue);
break;
case scVar:
/* Pass by reference on stack. */
case scVarRegister:
/* Pass by reference in register. */
SYMBOL_CLASS (s) = LOC_REGPARM_ADDR;
- svalue = ECOFF_REG_TO_REGNUM (svalue);
+ svalue = gdbarch_ecoff_reg_to_regnum (current_gdbarch, svalue);
break;
default:
/* Pass by value on stack. */
break;
default:
complaint (&symfile_complaints,
- "unknown symbol type 0x%x", sh->st);
+ _("unknown symbol type 0x%x"), sh->st);
break;
}
}
default:
complaint (&symfile_complaints,
- "declaration block contains unhandled symbol type %d",
+ _("declaration block contains unhandled symbol type %d"),
tsym.st);
}
}
that too. */
if (TYPE_LENGTH (t) == TYPE_NFIELDS (t)
|| TYPE_LENGTH (t) == 0)
- TYPE_LENGTH (t) = TARGET_INT_BIT / HOST_CHAR_BIT;
+ TYPE_LENGTH (t) =
+ gdbarch_int_bit (current_gdbarch) / HOST_CHAR_BIT;
for (ext_tsym = ext_sh + external_sym_size;
;
ext_tsym += external_sym_size)
}
else
complaint (&symfile_complaints,
- "stEnd with storage class %d not handled", sh->sc);
+ _("stEnd with storage class %d not handled"), sh->sc);
pop_parse_stack (); /* restore previous lexical context */
break;
case stConstant:
break; /* constant */
default:
- complaint (&symfile_complaints, "unknown symbol type 0x%x", sh->st);
+ complaint (&symfile_complaints, _("unknown symbol type 0x%x"), sh->st);
break;
}
else if (t->bt == btEnum)
;
else
- complaint (&symfile_complaints, "can't handle TIR fBitfield for %s",
+ complaint (&symfile_complaints, _("can't handle TIR fBitfield for %s"),
sym_name);
}
else
if (rf == -1)
{
complaint (&symfile_complaints,
- "unable to cross ref btIndirect for %s", sym_name);
+ _("unable to cross ref btIndirect for %s"), sym_name);
return mdebug_type_int;
}
xref_fh = get_rfd (fd, rf);
if (tp == (struct type *) NULL)
{
complaint (&symfile_complaints,
- "unable to cross ref btTypedef for %s", sym_name);
+ _("unable to cross ref btTypedef for %s"), sym_name);
tp = mdebug_type_int;
}
}
/* Complain for illegal continuations due to corrupt aux entries. */
if (t->continued)
- complaint (&symfile_complaints, "illegal TIR continued for %s", sym_name);
+ complaint (&symfile_complaints, _("illegal TIR continued for %s"), sym_name);
return tp;
}
if (TYPE_CODE (indx) != TYPE_CODE_INT)
{
complaint (&symfile_complaints,
- "illegal array index type for %s, assuming int", sym_name);
+ _("illegal array index type for %s, assuming int"), sym_name);
indx = mdebug_type_int;
}
return 0;
default:
- complaint (&symfile_complaints, "unknown type qualifier 0x%x", tq);
+ complaint (&symfile_complaints, _("unknown type qualifier 0x%x"), tq);
return 0;
}
}
/* Static procedure at address pr->adr. Sigh. */
/* FIXME-32x64. assuming pr->adr fits in long. */
complaint (&symfile_complaints,
- "can't handle PDR for static proc at 0x%lx",
+ _("can't handle PDR for static proc at 0x%lx"),
(unsigned long) pr->adr);
return;
}
}
else
{
- complaint (&symfile_complaints, "PDR for %s, but no symbol", sh_name);
+ complaint (&symfile_complaints, _("PDR for %s, but no symbol"), sh_name);
#if 1
return;
#else
if (e->pdr.pcreg == 0
&& strcmp (sh_name, "setjmp") == 0)
{
- complaint (&symfile_complaints, "fixing bad setjmp PDR from libc");
+ complaint (&symfile_complaints, _("fixing bad setjmp PDR from libc"));
#ifdef RA_REGNUM
e->pdr.pcreg = RA_REGNUM;
#else
n_undef_symbols++;
/* FIXME: Turn this into a complaint? */
if (info_verbose)
- printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
+ printf_filtered (_("Warning: %s `%s' is undefined (in %s)\n"),
what, debug_info->ssext + es->asym.iss,
fdr_name (cur_fdr));
return;
if (lt->nitems >= maxlines)
{
complaint (&symfile_complaints,
- "guessed size of linetable for %s incorrectly",
+ _("guessed size of linetable for %s incorrectly"),
fdr_name (fh));
break;
}
function_outside_compilation_unit_complaint (const char *arg1)
{
complaint (&symfile_complaints,
- "function `%s' appears to be defined outside of all compilation units",
+ _("function `%s' appears to be defined outside of all compilation units"),
arg1);
}
+/* Use the STORAGE_CLASS to compute which section the given symbol
+ belongs to, and then records this new minimal symbol. */
+
+static void
+record_minimal_symbol (const char *name, const CORE_ADDR address,
+ enum minimal_symbol_type ms_type, int storage_class,
+ struct objfile *objfile)
+{
+ int section;
+ asection *bfd_section;
+
+ switch (storage_class)
+ {
+ case scText:
+ section = SECT_OFF_TEXT (objfile);
+ bfd_section = bfd_get_section_by_name (cur_bfd, ".text");
+ break;
+ case scData:
+ section = SECT_OFF_DATA (objfile);
+ bfd_section = bfd_get_section_by_name (cur_bfd, ".data");
+ break;
+ case scBss:
+ section = SECT_OFF_BSS (objfile);
+ bfd_section = bfd_get_section_by_name (cur_bfd, ".bss");
+ break;
+ case scSData:
+ section = get_section_index (objfile, ".sdata");
+ bfd_section = bfd_get_section_by_name (cur_bfd, ".sdata");
+ break;
+ case scSBss:
+ section = get_section_index (objfile, ".sbss");
+ bfd_section = bfd_get_section_by_name (cur_bfd, ".sbss");
+ break;
+ case scRData:
+ section = get_section_index (objfile, ".rdata");
+ bfd_section = bfd_get_section_by_name (cur_bfd, ".rdata");
+ break;
+ case scInit:
+ section = get_section_index (objfile, ".init");
+ bfd_section = bfd_get_section_by_name (cur_bfd, ".init");
+ break;
+ case scXData:
+ section = get_section_index (objfile, ".xdata");
+ bfd_section = bfd_get_section_by_name (cur_bfd, ".xdata");
+ break;
+ case scPData:
+ section = get_section_index (objfile, ".pdata");
+ bfd_section = bfd_get_section_by_name (cur_bfd, ".pdata");
+ break;
+ case scFini:
+ section = get_section_index (objfile, ".fini");
+ bfd_section = bfd_get_section_by_name (cur_bfd, ".fini");
+ break;
+ case scRConst:
+ section = get_section_index (objfile, ".rconst");
+ bfd_section = bfd_get_section_by_name (cur_bfd, ".rconst");
+ break;
+#ifdef scTlsData
+ case scTlsData:
+ section = get_section_index (objfile, ".tlsdata");
+ bfd_section = bfd_get_section_by_name (cur_bfd, ".tlsdata");
+ break;
+#endif
+#ifdef scTlsBss
+ case scTlsBss:
+ section = get_section_index (objfile, ".tlsbss");
+ bfd_section = bfd_get_section_by_name (cur_bfd, ".tlsbss");
+ break;
+#endif
+ default:
+ /* This kind of symbol is not associated to a section. */
+ section = -1;
+ bfd_section = NULL;
+ }
+
+ prim_record_minimal_symbol_and_info (name, address, ms_type, NULL,
+ section, bfd_section, objfile);
+}
+
/* Master parsing procedure for first-pass reading of file symbols
into a partial_symtab. */
if (ext_in->ifd < -1 || ext_in->ifd >= hdr->ifdMax)
{
complaint (&symfile_complaints,
- "bad ifd for external symbol: %d (max %ld)", ext_in->ifd,
+ _("bad ifd for external symbol: %d (max %ld)"), ext_in->ifd,
hdr->ifdMax);
continue;
}
if (ext_in->asym.iss < 0 || ext_in->asym.iss >= hdr->issExtMax)
{
complaint (&symfile_complaints,
- "bad iss for external symbol: %ld (max %ld)",
+ _("bad iss for external symbol: %ld (max %ld)"),
ext_in->asym.iss, hdr->issExtMax);
continue;
}
unknown_ext_complaint (name);
}
if (!ECOFF_IN_ELF (cur_bfd))
- prim_record_minimal_symbol (name, svalue, ms_type, objfile);
+ record_minimal_symbol (name, svalue, ms_type, ext_in->asym.sc,
+ objfile);
}
/* Pass 3 over files, over local syms: fill in static symbols */
if (sh.st == stStaticProc)
{
namestring = debug_info->ss + fh->issBase + sh.iss;
- prim_record_minimal_symbol_and_info (namestring,
- sh.value,
- mst_file_text,
- NULL,
- SECT_OFF_TEXT (objfile),
- NULL,
- objfile);
+ record_minimal_symbol (namestring, sh.value,
+ mst_file_text, sh.sc,
+ objfile);
}
procaddr = sh.value;
case scXData:
namestring = debug_info->ss + fh->issBase + sh.iss;
sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
- prim_record_minimal_symbol_and_info (namestring,
- sh.value,
- mst_file_data,
- NULL,
- SECT_OFF_DATA (objfile),
- NULL,
- objfile);
+ record_minimal_symbol (namestring, sh.value,
+ mst_file_data, sh.sc,
+ objfile);
break;
default:
then have the default be abs? */
namestring = debug_info->ss + fh->issBase + sh.iss;
sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
- prim_record_minimal_symbol_and_info (namestring,
- sh.value,
- mst_file_bss,
- NULL,
- SECT_OFF_BSS (objfile),
- NULL,
- objfile);
+ record_minimal_symbol (namestring, sh.value,
+ mst_file_bss, sh.sc,
+ objfile);
break;
}
}
a backslash. */
complaint (&symfile_complaints,
- "unknown symbol descriptor `%c'", p[1]);
+ _("unknown symbol descriptor `%c'"), p[1]);
/* Ignore it; perhaps it is an extension that we don't
know about. */
default:
/* If we haven't found it yet, ignore it. It's probably some
new type we don't know about yet. */
- complaint (&symfile_complaints, "unknown symbol type %s",
+ complaint (&symfile_complaints, _("unknown symbol type %s"),
hex_string (type_code)); /*CUR_SYMBOL_TYPE*/
continue;
}
{
/* This should not happen either... FIXME. */
complaint (&symfile_complaints,
- "bad proc end in aux found from symbol %s",
+ _("bad proc end in aux found from symbol %s"),
name);
new_sdx = cur_sdx + 1; /* Don't skip backward */
}
{
/* This happens with the Ultrix kernel. */
complaint (&symfile_complaints,
- "bad aux index at block symbol %s", name);
+ _("bad aux index at block symbol %s"), name);
new_sdx = cur_sdx + 1; /* Don't skip backward */
}
cur_sdx = new_sdx;
default:
/* Both complaints are valid: one gives symbol name,
the other the offending symbol type. */
- complaint (&symfile_complaints, "unknown local symbol %s",
+ complaint (&symfile_complaints, _("unknown local symbol %s"),
name);
- complaint (&symfile_complaints, "with type %d", sh.st);
+ complaint (&symfile_complaints, _("with type %d"), sh.st);
cur_sdx++;
continue;
}
CORE_ADDR svalue;
if (ext_ptr->ifd != f_idx)
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
psh = &ext_ptr->asym;
/* Do not add undefined symbols to the partial symbol table. */
&rh);
if (rh < 0 || rh >= hdr->ifdMax)
{
- complaint (&symfile_complaints, "bad file number %ld", rh);
+ complaint (&symfile_complaints, _("bad file number %ld"), rh);
continue;
}
/* These are generated by gcc-2.x, do not complain */
;
else
- complaint (&symfile_complaints, "unknown stabs symbol %s", name);
+ complaint (&symfile_complaints, _("unknown stabs symbol %s"), name);
}
if (! last_symtab_ended)
from a shared library, so tell the user only if verbose is on. */
if (info_verbose && n_undef_symbols)
{
- printf_filtered ("File %s contains %d unresolved references:",
+ printf_filtered (_("File %s contains %d unresolved references:"),
st->filename, n_undef_symbols);
printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
n_undef_vars, n_undef_procs, n_undef_labels);
&tir);
if (tir.tq0 != tqNil)
complaint (&symfile_complaints,
- "illegal tq0 in forward typedef for %s", sym_name);
+ _("illegal tq0 in forward typedef for %s"), sym_name);
switch (tir.bt)
{
case btVoid:
default:
complaint (&symfile_complaints,
- "illegal bt %d in forward typedef for %s", tir.bt,
+ _("illegal bt %d in forward typedef for %s"), tir.bt,
sym_name);
*tpp = init_type (type_code, 0, 0, (char *) NULL,
current_objfile);
sizeof (struct ecoff_debug_info)));
if (!(*swap->read_debug_info) (abfd, sec, info))
- error ("Error reading ECOFF debugging information: %s",
+ error (_("Error reading ECOFF debugging information: %s"),
bfd_errmsg (bfd_get_error ()));
mdebug_build_psymtabs (objfile, swap, info);
"adr_64", (struct objfile *) NULL);
TYPE_TARGET_TYPE (mdebug_type_adr_64) = mdebug_type_void;
mdebug_type_float =
- init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
- 0,
- "float", (struct objfile *) NULL);
+ 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, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
- 0,
- "double", (struct objfile *) NULL);
+ 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 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
- 0,
- "complex", (struct objfile *) NULL);
+ 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 * TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
- 0,
- "double complex", (struct objfile *) NULL);
+ 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?
TYPE_CODE_ERROR print things in hex if it knows the size? */
mdebug_type_fixed_dec =
init_type (TYPE_CODE_INT,
- TARGET_INT_BIT / TARGET_CHAR_BIT,
+ gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
0, "fixed decimal",
(struct objfile *) NULL);
mdebug_type_float_dec =
init_type (TYPE_CODE_ERROR,
- TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
+ gdbarch_double_bit (current_gdbarch) / TARGET_CHAR_BIT,
0, "floating decimal",
(struct objfile *) NULL);
"<function, no debug info>", NULL);
TYPE_TARGET_TYPE (nodebug_func_symbol_type) = mdebug_type_int;
nodebug_var_symbol_type =
- init_type (TYPE_CODE_INT, TARGET_INT_BIT / HOST_CHAR_BIT, 0,
+ init_type (TYPE_CODE_INT,
+ gdbarch_int_bit (current_gdbarch) / HOST_CHAR_BIT, 0,
"<variable, no debug info>", NULL);
}