/* 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
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., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, 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
static struct type *mdebug_type_float_dec;
static struct type *mdebug_type_string;
-/* Types for symbols from files compiled without debugging info. */
-
-static struct type *nodebug_func_symbol_type;
-static struct type *nodebug_var_symbol_type;
-
/* Nonzero if we have seen ecoff debugging info for a file. */
static int found_ecoff_debugging_info;
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;
/* 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) = nodebug_var_symbol_type;
+ SYMBOL_TYPE (s) = builtin_type (current_gdbarch)->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 */
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. */
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)
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) = nodebug_func_symbol_type;
+ SYMBOL_TYPE (s) = builtin_type (current_gdbarch)->nodebug_text_symbol;
}
/* Parse the external symbol ES. Just call parse_symbol() after
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;
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. */
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;
}
}
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);
"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);
-
- nodebug_func_symbol_type = init_type (TYPE_CODE_FUNC, 1, 0,
- "<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,
- "<variable, no debug info>", NULL);
}
projects / deliverable / binutils-gdb.git / blobdiff