#include "libcoff.h" /* FIXME, internal data from BFD */
#include "coff/rs6000.h" /* FIXME, raw file-format guts of xcoff */
-
-/* Define this if you want gdb use the old xcoff symbol processing. This
- way it won't use common `define_symbol()' function and Sun dbx stab
- string grammar. And likely it won't be able to do G++ debugging. */
-
-/* #define NO_DEFINE_SYMBOL 1 */
-
-/* Define this if you want gdb to ignore typdef stabs. This was needed for
- one of Transarc, to reduce the size of the symbol table. Types won't be
- recognized, but tag names will be. */
-
-/* #define NO_TYPEDEFS 1 */
+/* For interface with stabsread.c. */
+#include "aout/stab_gnu.h"
/* Simplified internal version of coff symbol table information */
int c_symnum; /* symbol number of this entry */
int c_nsyms; /* 0 if syment only, 1 if syment + auxent */
long c_value;
- int c_sclass;
+ unsigned char c_sclass;
int c_secnum;
unsigned int c_type;
};
static int
init_lineno PARAMS ((bfd *, file_ptr, int));
+static void
+free_linetab PARAMS ((void));
+
static void
find_linenos PARAMS ((bfd *, sec_ptr, PTR));
}
(*stabvector)->stab [(*stabvector)->count++] = stabname;
}
+\f
+/* Linenos are processed on a file-by-file basis.
+
+ Two reasons:
+
+ 1) xlc (IBM's native c compiler) postpones static function code
+ emission to the end of a compilation unit. This way it can
+ determine if those functions (statics) are needed or not, and
+ can do some garbage collection (I think). This makes line
+ numbers and corresponding addresses unordered, and we end up
+ with a line table like:
+
+
+ lineno addr
+ foo() 10 0x100
+ 20 0x200
+ 30 0x300
+
+ foo3() 70 0x400
+ 80 0x500
+ 90 0x600
+
+ static foo2()
+ 40 0x700
+ 50 0x800
+ 60 0x900
+
+ and that breaks gdb's binary search on line numbers, if the
+ above table is not sorted on line numbers. And that sort
+ should be on function based, since gcc can emit line numbers
+ like:
+
+ 10 0x100 - for the init/test part of a for stmt.
+ 20 0x200
+ 30 0x300
+ 10 0x400 - for the increment part of a for stmt.
+ arrange_linetable() will do this sorting.
-#if 0
-/* for all the stabs in a given stab vector, build appropriate types
- and fix their symbols in given symbol vector. */
-
-void
-patch_block_stabs (symbols, stabs)
-struct pending *symbols;
-struct pending_stabs *stabs;
-{
- int ii;
-
- if (!stabs)
- return;
-
- /* for all the stab entries, find their corresponding symbols and
- patch their types! */
-
- for (ii=0; ii < stabs->count; ++ii) {
- char *name = stabs->stab[ii];
- char *pp = (char*) index (name, ':');
- struct symbol *sym = find_symbol_in_list (symbols, name, pp-name);
- if (!sym) {
- ;
- /* printf ("ERROR! stab symbol not found!\n"); */ /* FIXME */
- /* The above is a false alarm. There are cases the we can have
- a stab, without its symbol. xlc generates this for the extern
- definitions in inner blocks. */
- }
- else {
- pp += 2;
+ 2) aix symbol table might look like:
- if (*(pp-1) == 'F' || *(pp-1) == 'f')
- SYMBOL_TYPE (sym) = lookup_function_type (read_type (&pp, objfile));
- else
- SYMBOL_TYPE (sym) = read_type (&pp, objfile);
- }
- }
-}
-#endif
+ c_file // beginning of a new file
+ .bi // beginning of include file
+ .ei // end of include file
+ .bi
+ .ei
+ basically, .bi/.ei pairs do not necessarily encapsulate
+ their scope. They need to be recorded, and processed later
+ on when we come the end of the compilation unit.
+ Include table (inclTable) and process_linenos() handle
+ that. */
/* compare line table entry addresses. */
- static int
+static int
compare_lte (lte1, lte2)
- struct linetable_entry *lte1, *lte2;
+ struct linetable_entry *lte1, *lte2;
{
return lte1->pc - lte2->pc;
}
/* Give a line table with function entries are marked, arrange its functions
in assending order and strip off function entry markers and return it in
a newly created table. If the old one is good enough, return the old one. */
+/* FIXME: I think all this stuff can be replaced by just passing
+ sort_linevec = 1 to end_symtab. */
static struct linetable *
arrange_linetable (oldLineTb)
record_include_begin (cs)
struct coff_symbol *cs;
{
- /* In xcoff, we assume include files cannot be nested (not in .c files
- of course, but in corresponding .s files.) */
-
if (inclDepth)
- fatal ("xcoff internal: pending include file exists.");
+ {
+ /* In xcoff, we assume include files cannot be nested (not in .c files
+ of course, but in corresponding .s files.). */
+ /* This can happen with old versions of GCC.
+ GCC 2.3.3-930426 does not exhibit this on a test case which
+ a user said produced the message for him. */
+ static struct complaint msg = {"Nested C_BINCL symbols", 0, 0};
+ complain (&msg);
+ }
++inclDepth;
/* allocate an include file, or make room for the new entry */
if (inclLength == 0) {
inclTable = (InclTable*)
xmalloc (sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
- bzero (inclTable, sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
+ memset (inclTable, '\0', sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
inclLength = INITIAL_INCLUDE_TABLE_LENGTH;
inclIndx = 0;
}
inclLength += INITIAL_INCLUDE_TABLE_LENGTH;
inclTable = (InclTable*)
xrealloc (inclTable, sizeof (InclTable) * inclLength);
- bzero (inclTable+inclLength-INITIAL_INCLUDE_TABLE_LENGTH,
- sizeof (InclTable)*INITIAL_INCLUDE_TABLE_LENGTH);
+ memset (inclTable+inclLength-INITIAL_INCLUDE_TABLE_LENGTH,
+ '\0', sizeof (InclTable)*INITIAL_INCLUDE_TABLE_LENGTH);
}
inclTable [inclIndx].name = cs->c_name;
InclTable *pTbl;
if (inclDepth == 0)
- fatal ("xcoff internal: Mismatch C_BINCL/C_EINCL pair found.");
+ {
+ static struct complaint msg = {"Mismatched C_BINCL/C_EINCL pair", 0, 0};
+ complain (&msg);
+ }
pTbl = &inclTable [inclIndx];
pTbl->end = cs->c_value;
if (!(offset = first_fun_line_offset))
goto return_after_cleanup;
- bzero (&main_subfile, sizeof (main_subfile));
+ memset (&main_subfile, '\0', sizeof (main_subfile));
first_fun_line_offset = 0;
if (inclIndx == 0)
tmpSubfile = inclTable[ii].subfile = (struct subfile*)
xmalloc (sizeof (struct subfile));
- bzero (tmpSubfile, sizeof (struct subfile));
+ memset (tmpSubfile, '\0', sizeof (struct subfile));
firstLine = &(inclTable[ii].funStartLine);
/* enter include file's lines now. */
inclIndx = 0;
/* start with a fresh subfile structure for the next file. */
- bzero (&main_subfile, sizeof (struct subfile));
+ memset (&main_subfile, '\0', sizeof (struct subfile));
}
void
int functionstart = cs->c_value - textsec->vma;
- bzero (&tbInfo, sizeof (tbInfo));
+ memset (&tbInfo, '\0', sizeof (tbInfo));
/* keep reading blocks of data from the text section, until finding a zero
word and a traceback table. */
pointed to by cs->c_name will persist throughout xcoffread. If
we use the new field, it gets overwritten for each symbol. */
cs->c_name = ((struct external_syment *)raw_symbol)->e.e_name;
- /* If it's exactly 8 characters long it isn't '\0'-terminated. */
- if (cs->c_name[7] != '\0')
+ /* If it's exactly E_SYMNMLEN characters long it isn't
+ '\0'-terminated. */
+ if (cs->c_name[E_SYMNMLEN - 1] != '\0')
{
char *p;
- p = obstack_alloc (&objfile->symbol_obstack, 9);
- strncpy (p, cs->c_name, 8);
- p[8] = '\0';
+ p = obstack_alloc (&objfile->symbol_obstack, E_SYMNMLEN + 1);
+ strncpy (p, cs->c_name, E_SYMNMLEN);
+ p[E_SYMNMLEN] = '\0';
cs->c_name = p;
symname_alloced = 1;
}
symname_alloced = 1;
}
cs->c_value = symbol->n_value;
- /* n_sclass is signed (FIXME), so we had better not mask off any
- high bits it contains, since the values we will be comparing
- it to are also signed (FIXME). Defined in <coff/internal.h>.
- At this point (3Jun92, gnu@cygnus.com) I think the fix is to
- make the fields and values unsigned chars, but changing the next
- line is a simple patch late in the release cycle, for now. */
- cs->c_sclass = symbol->n_sclass /* & 0xff */;
+ cs->c_sclass = symbol->n_sclass;
cs->c_secnum = symbol->n_scnum;
cs->c_type = (unsigned)symbol->n_type;
case XMC_PR : /* a `.text' csect. */
{
- /* A program csect is seen.
-
- We have to allocate one symbol table for each program csect. Normally
- gdb prefers one symtab for each compilation unit (CU). In case of AIX, one
- CU might include more than one prog csect, and they don't have to be
- adjacent in terms of the space they occupy in memory. Thus, one single
- CU might get fragmented in the memory and gdb's file start and end address
- approach does not work! */
+ /* A program csect is seen. We have to allocate one
+ symbol table for each program csect. Normally gdb
+ prefers one symtab for each source file. In case
+ of AIX, one source file might include more than one
+ [PR] csect, and they don't have to be adjacent in
+ terms of the space they occupy in memory. Thus, one
+ single source file might get fragmented in the
+ memory and gdb's file start and end address
+ approach does not work! GCC (and I think xlc) seem
+ to put all the code in the unnamed program csect. */
if (last_csect_name) {
textsec->target_index);
end_stabs ();
start_stabs ();
- start_symtab ((char *)NULL, (char *)NULL, (CORE_ADDR)0);
+ /* Give all csects for this source file the same
+ name. */
+ start_symtab (filestring, (char *)NULL, (CORE_ADDR)0);
}
/* If this is the very first csect seen, basically `__start'. */
case C_FUN:
-
-#ifdef NO_DEFINE_SYMBOL
- /* For a function stab, just save its type in `fcn_type_saved', and leave
- it for the `.bf' processing. */
- {
- char *pp = (char*) index (cs->c_name, ':');
-
- if (!pp || ( *(pp+1) != 'F' && *(pp+1) != 'f'))
- fatal ("Unrecognized stab");
- pp += 2;
-
- if (fcn_type_saved)
- fatal ("Unprocessed function type");
-
- fcn_type_saved = lookup_function_type (read_type (&pp, objfile));
- }
-#else
fcn_stab_saved = *cs;
-#endif
break;
within_function = 1;
- /* Linenos are now processed on a file-by-file, not fn-by-fn, basis.
- Metin did it, I'm not sure why. FIXME. -- gnu@cygnus.com */
-
- /* Two reasons:
-
- 1) xlc (IBM's native c compiler) postpones static function code
- emission to the end of a compilation unit. This way it can
- determine if those functions (statics) are needed or not, and
- can do some garbage collection (I think). This makes line
- numbers and corresponding addresses unordered, and we end up
- with a line table like:
-
-
- lineno addr
- foo() 10 0x100
- 20 0x200
- 30 0x300
-
- foo3() 70 0x400
- 80 0x500
- 90 0x600
-
- static foo2()
- 40 0x700
- 50 0x800
- 60 0x900
-
- and that breaks gdb's binary search on line numbers, if the
- above table is not sorted on line numbers. And that sort
- should be on function based, since gcc can emit line numbers
- like:
-
- 10 0x100 - for the init/test part of a for stmt.
- 20 0x200
- 30 0x300
- 10 0x400 - for the increment part of a for stmt.
-
- arrange_linenos() will do this sorting.
-
-
- 2) aix symbol table might look like:
-
- c_file // beginning of a new file
- .bi // beginning of include file
- .ei // end of include file
- .bi
- .ei
-
- basically, .bi/.ei pairs do not necessarily encapsulate
- their scope. They need to be recorded, and processed later
- on when we come the end of the compilation unit.
- Include table (inclTable) and process_linenos() handle
- that.
- */
mark_first_line (fcn_line_offset, cs->c_symnum);
new = push_context (0, fcn_start_addr);
-#ifdef NO_DEFINE_SYMBOL
- new->name = process_xcoff_symbol (&fcn_cs_saved, objfile);
-
- /* Between a function symbol and `.bf', there always will be a function
- stab. We save function type when processing that stab. */
-
- if (fcn_type_saved == NULL) {
- printf ("Unknown function type: symbol 0x%x\n", cs->c_symnum);
- SYMBOL_TYPE (new->name) = lookup_function_type (builtin_type_int);
- }
- else {
- SYMBOL_TYPE (new->name) = fcn_type_saved;
- fcn_type_saved = NULL;
- }
-#else
new->name = define_symbol
(fcn_cs_saved.c_value, fcn_stab_saved.c_name, 0, 0, objfile);
if (new->name != NULL)
SYMBOL_SECTION (new->name) = cs->c_secnum;
-#endif
}
else if (STREQ (cs->c_name, ".ef")) {
if (name[0] == '.')
++name;
- bzero (sym, sizeof (struct symbol));
+ memset (sym, '\0', sizeof (struct symbol));
/* default assumptions */
SYMBOL_VALUE (sym) = cs->c_value;
case C_DECL: /* a type decleration?? */
-#if defined(NO_TYPEDEFS) || defined(NO_DEFINE_SYMBOL)
- qq = (char*) strchr (name, ':');
- if (!qq) /* skip if there is no ':' */
- return NULL;
-
- nameless = (qq == name);
-
- struct_and_type_combined = (qq[1] == 'T' && qq[2] == 't');
- pp = qq + (struct_and_type_combined ? 3 : 2);
-
-
- /* To handle GNU C++ typename abbreviation, we need to be able to fill
- in a type's name as soon as space for that type is allocated. */
-
- if (struct_and_type_combined && name != qq) {
-
- int typenums[2];
- struct type *tmp_type;
- char *tmp_pp = pp;
-
- read_type_number (&tmp_pp, typenums);
- tmp_type = dbx_alloc_type (typenums, objfile);
-
- if (tmp_type && !TYPE_NAME (tmp_type) && !nameless)
- TYPE_NAME (tmp_type) = SYMBOL_NAME (sym) =
- obsavestring (name, qq-name,
- &objfile->symbol_obstack);
- }
- ttype = SYMBOL_TYPE (sym) = read_type (&pp, objfile);
-
- /* if there is no name for this typedef, you don't have to keep its
- symbol, since nobody could ask for it. Otherwise, build a symbol
- and add it into symbol_list. */
-
- if (nameless)
- return;
-
-#ifdef NO_TYPEDEFS
- /* Transarc wants to eliminate type definitions from the symbol table.
- Limited debugging capabilities, but faster symbol table processing
- and less memory usage. Note that tag definitions (starting with
- 'T') will remain intact. */
-
- if (qq[1] != 'T' && (!TYPE_NAME (ttype) || *(TYPE_NAME (ttype)) == '\0')) {
-
- if (SYMBOL_NAME (sym))
- TYPE_NAME (ttype) = SYMBOL_NAME (sym);
- else
- TYPE_NAME (ttype) = obsavestring (name, qq-name);
-
- return;
- }
-
-#endif /* !NO_TYPEDEFS */
-
- /* read_type() will return null if type (or tag) definition was
- unnnecessarily duplicated. Also, if the symbol doesn't have a name,
- there is no need to keep it in symbol table. */
- /* The above argument no longer valid. read_type() never returns NULL. */
-
- if (!ttype)
- return NULL;
-
- /* if there is no name for this typedef, you don't have to keep its
- symbol, since nobody could ask for it. Otherwise, build a symbol
- and add it into symbol_list. */
-
- if (qq[1] == 'T')
- SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
- else if (qq[1] == 't')
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
- else {
- warning ("Unrecognized stab string.\n");
- return NULL;
- }
-
- SYMBOL_CLASS (sym) = LOC_TYPEDEF;
- if (!SYMBOL_NAME (sym))
- SYMBOL_NAME (sym) = obsavestring (name, qq-name);
-
- SYMBOL_DUP (sym, sym2);
- add_symbol_to_list
- (sym2, within_function ? &local_symbols : &file_symbols);
-
- /* For a combination of struct and type, add one more symbol
- for the type. */
-
- if (struct_and_type_combined) {
- SYMBOL_DUP (sym, sym2);
- SYMBOL_NAMESPACE (sym2) = VAR_NAMESPACE;
- add_symbol_to_list
- (sym2, within_function ? &local_symbols : &file_symbols);
- }
-
- /* assign a name to the type node. */
-
- if (!TYPE_NAME (ttype) || *(TYPE_NAME (ttype)) == '\0') {
- if (struct_and_type_combined)
- TYPE_NAME (ttype) = SYMBOL_NAME (sym);
- else if (qq[1] == 'T') /* struct namespace */
- TYPE_NAME (ttype) = concat (
- TYPE_CODE (ttype) == TYPE_CODE_UNION ? "union " :
- TYPE_CODE (ttype) == TYPE_CODE_STRUCT? "struct " : "enum ",
- SYMBOL_NAME (sym), NULL);
- }
- break;
-
-#else /* !NO_DEFINE_SYMBOL */
sym = define_symbol (cs->c_value, cs->c_name, 0, 0, objfile);
if (sym != NULL)
SYMBOL_SECTION (sym) = cs->c_secnum;
return sym;
-#endif
case C_GSYM:
add_stab_to_list (name, &global_stabs);
case C_PSYM:
case C_RPSYM:
-#ifdef NO_DEFINE_SYMBOL
- if (*name == ':' || (pp = (char *) strchr (name, ':')) == NULL)
- return NULL;
- SYMBOL_NAME (sym) = obsavestring (name, pp-name, &objfile -> symbol_obstack);
- SYMBOL_CLASS (sym) = (cs->c_sclass == C_PSYM) ? LOC_ARG : LOC_REGPARM;
- pp += 2;
- SYMBOL_TYPE (sym) = read_type (&pp, objfile);
- SYMBOL_DUP (sym, sym2);
- add_symbol_to_list (sym2, &local_symbols);
- break;
-#else
sym = define_symbol (cs->c_value, cs->c_name, 0, 0, objfile);
if (sym != NULL)
{
- SYMBOL_CLASS (sym) =
- (cs->c_sclass == C_PSYM) ? LOC_ARG : LOC_REGPARM;
SYMBOL_SECTION (sym) = cs->c_secnum;
}
return sym;
-#endif
case C_STSYM:
-#ifdef NO_DEFINE_SYMBOL
- if (*name == ':' || (pp = (char *) strchr (name, ':')) == NULL)
- return NULL;
- SYMBOL_NAME (sym) = obsavestring (name, pp-name, &objfile -> symbol_obstack);
- SYMBOL_CLASS (sym) = LOC_STATIC;
- SYMBOL_VALUE (sym) += static_block_base;
- pp += 2;
- SYMBOL_TYPE (sym) = read_type (&pp, objfile);
- SYMBOL_DUP (sym, sym2);
- add_symbol_to_list
- (sym2, within_function ? &local_symbols : &file_symbols);
- break;
-#else
/* If we are going to use Sun dbx's define_symbol(), we need to
massage our stab string a little. Change 'V' type to 'S' to be
comparible with Sun. */
+ /* FIXME: I believe this is to avoid a Sun-specific hack somewhere.
+ Needs more investigation. */
- if (*name == ':' || (pp = (char *) index (name, ':')) == NULL)
+ if (*name == ':' || (pp = (char *) strchr(name, ':')) == NULL)
return NULL;
++pp;
SYMBOL_SECTION (sym) = static_block_section;
}
return sym;
-#endif
case C_LSYM:
- if (*name == ':' || (pp = (char *) strchr (name, ':')) == NULL)
- return NULL;
- SYMBOL_NAME (sym) = obsavestring (name, pp-name, &objfile -> symbol_obstack);
- SYMBOL_CLASS (sym) = LOC_LOCAL;
- pp += 1;
- SYMBOL_TYPE (sym) = read_type (&pp, objfile);
- SYMBOL_SECTION (sym) = cs->c_secnum;
- SYMBOL_DUP (sym, sym2);
- add_symbol_to_list (sym2, &local_symbols);
- break;
+ sym = define_symbol (cs->c_value, cs->c_name, 0, N_LSYM, objfile);
+ if (sym != NULL)
+ {
+ SYMBOL_SECTION (sym) = cs->c_secnum;
+ }
+ return sym;
case C_AUTO:
SYMBOL_CLASS (sym) = LOC_LOCAL;
case C_RSYM:
pp = (char*) strchr (name, ':');
-#ifdef NO_DEFINE_SYMBOL
- SYMBOL_CLASS (sym) = LOC_REGISTER;
- SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (cs->c_value);
- if (pp) {
- SYMBOL_NAME (sym) = obsavestring (name, pp-name, &objfile -> symbol_obstack);
- pp += 2;
- if (*pp)
- SYMBOL_TYPE (sym) = read_type (&pp, objfile);
- }
- else
- /* else this is not a stab entry, suppose the type is either
- `int' or `float', depending on the register class. */
-
- SYMBOL_TYPE (sym) = (SYMBOL_VALUE (sym) < 32)
- ? lookup_fundamental_type (objfile, FT_INTEGER)
- : lookup_fundamental_type (objfile, FT_FLOAT);
-
- SYMBOL_DUP (sym, sym2);
- add_symbol_to_list (sym2, &local_symbols);
- break;
-#else
if (pp) {
sym = define_symbol (cs->c_value, cs->c_name, 0, 0, objfile);
if (sym != NULL)
complain (&rsym_complaint, name);
return NULL;
}
-#endif
default :
complain (&storclass_complaint, cs->c_sclass);
{
if (symno < 0 || symno >= symtbl_num_syms)
{
- struct complaint msg =
+ static struct complaint msg =
{"Invalid symbol offset", 0, 0};
complain (&msg);
symbol->n_value = 0;
{
int val;
+ free_linetab ();
+
if (bfd_seek(abfd, offset, L_SET) < 0)
return -1;
linetab_offset = offset;
linetab_size = size;
- make_cleanup (free, linetab); /* Be sure it gets de-allocated. */
return 0;
}
+
+static void
+free_linetab ()
+{
+ if (linetab)
+ free (linetab);
+ linetab = NULL;
+}
\f
/* dbx allows the text of a symbol name to be continued into the
next symbol name! When such a continuation is encountered
if (strtbl == NULL)
return -1;
- bcopy(&length, strtbl, sizeof length);
+ memcpy(strtbl, &length, sizeof length);
if (length == sizeof length)
return 0;
bfd *abfd;
struct coff_symfile_info *info;
char *name;
+ struct cleanup *back_to = make_cleanup (null_cleanup, 0);
info = (struct coff_symfile_info *) objfile -> sym_private;
symfile_bfd = abfd = objfile->obfd;
&& info->max_lineno_offset > info->min_lineno_offset) {
/* only read in the line # table if one exists */
+ make_cleanup (free_linetab, 0);
val = init_lineno(abfd, info->min_lineno_offset,
(int) (info->max_lineno_offset - info->min_lineno_offset));
install_minimal_symbols (objfile);
- /* Make a default for file to list. */
- select_source_symtab (0);
+ do_cleanups (back_to);
}
/* XCOFF-specific parsing routine for section offsets. */