/* Read AIX xcoff symbol tables and convert to internal format, for GDB.
- Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995
- Free Software Foundation, Inc.
+ Copyright 1986, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 1997
+ Free Software Foundation, Inc.
Derived from coffread.c, dbxread.c, and a lot of hacking.
Contributed by IBM Corporation.
-This file is part of GDB.
+ This file is part of GDB.
-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
-(at your option) any later version.
+ 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
+ (at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ 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. */
-
-/* Native only: Need struct tbtable in <sys/debug.h> from host, and
- need xcoff_add_toc_to_loadinfo in rs6000-tdep.c from target.
- need xcoff_init_loadinfo ditto.
- However, if you grab <sys/debug.h> and make it available on your
- host, and define FAKING_RS6000, then this code will compile. */
+ 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. */
#include "defs.h"
#include "bfd.h"
#include <ctype.h>
#include "gdb_string.h"
-#include "obstack.h"
#include <sys/param.h>
#ifndef NO_SYS_FILE
#include <sys/file.h>
#endif
#include "gdb_stat.h"
-#include <sys/debug.h>
#include "coff/internal.h"
#include "libcoff.h" /* FIXME, internal data from BFD */
#include "objfiles.h"
#include "buildsym.h"
#include "stabsread.h"
+#include "expression.h"
+#include "language.h" /* Needed inside partial-stab.h */
#include "complaints.h"
#include "gdb-stabs.h"
#include "aout/stab_gnu.h"
/* For interface with partial-stab.h. */
-#define N_UNDF 0 /* Undefined symbol */
+#define N_UNDF 0 /* Undefined symbol */
#undef N_ABS
#define N_ABS 2
-#define N_TEXT 4 /* Text sym -- defined at offset in text seg */
-#define N_DATA 6 /* Data sym -- defined at offset in data seg */
-#define N_BSS 8 /* BSS sym -- defined at offset in zero'd seg */
-#define N_COMM 0x12 /* Common symbol (visible after shared lib dynlink) */
-#define N_FN 0x1f /* File name of .o file */
-#define N_FN_SEQ 0x0C /* N_FN from Sequent compilers (sigh) */
+#define N_TEXT 4 /* Text sym -- defined at offset in text seg */
+#define N_DATA 6 /* Data sym -- defined at offset in data seg */
+#define N_BSS 8 /* BSS sym -- defined at offset in zero'd seg */
+#define N_COMM 0x12 /* Common symbol (visible after shared lib dynlink) */
+#define N_FN 0x1f /* File name of .o file */
+#define N_FN_SEQ 0x0C /* N_FN from Sequent compilers (sigh) */
/* Note: N_EXT can only be usefully OR-ed with N_UNDF, N_ABS, N_TEXT,
N_DATA, or N_BSS. When the low-order bit of other types is set,
(e.g. N_WARNING versus N_FN), they are two different types. */
-#define N_EXT 1 /* External symbol (as opposed to local-to-this-file) */
+#define N_EXT 1 /* External symbol (as opposed to local-to-this-file) */
#define N_INDR 0x0a
/* The following symbols refer to set elements.
/* We put a pointer to this structure in the read_symtab_private field
of the psymtab. */
-struct symloc {
+struct symloc
+ {
- /* First symbol number for this file. */
+ /* First symbol number for this file. */
- int first_symnum;
+ int first_symnum;
- /* Number of symbols in the section of the symbol table devoted to
- this file's symbols (actually, the section bracketed may contain
- more than just this file's symbols). If numsyms is 0, the only
- reason for this thing's existence is the dependency list. Nothing
- else will happen when it is read in. */
+ /* Number of symbols in the section of the symbol table devoted to
+ this file's symbols (actually, the section bracketed may contain
+ more than just this file's symbols). If numsyms is 0, the only
+ reason for this thing's existence is the dependency list. Nothing
+ else will happen when it is read in. */
- int numsyms;
+ int numsyms;
- /* Position of the start of the line number information for this psymtab. */
- unsigned int lineno_off;
-};
+ /* Position of the start of the line number information for this psymtab. */
+ unsigned int lineno_off;
+ };
/* Remember what we deduced to be the source language of this psymtab. */
static enum language psymtab_language = language_unknown;
-
\f
-/* Simplified internal version of coff symbol table information */
-struct coff_symbol {
- char *c_name;
- int c_symnum; /* symbol number of this entry */
- int c_naux; /* 0 if syment only, 1 if syment + auxent */
- long c_value;
- unsigned char c_sclass;
- int c_secnum;
- unsigned int c_type;
-};
+/* Simplified internal version of coff symbol table information */
-/* The COFF line table, in raw form. */
-static char *linetab = NULL; /* Its actual contents */
-static long linetab_offset; /* Its offset in the file */
-static unsigned long linetab_size; /* Its size */
+struct coff_symbol
+ {
+ char *c_name;
+ int c_symnum; /* symbol number of this entry */
+ int c_naux; /* 0 if syment only, 1 if syment + auxent */
+ long c_value;
+ unsigned char c_sclass;
+ int c_secnum;
+ unsigned int c_type;
+ };
/* last function's saved coff symbol `cs' */
there is any reason not to just use a #define, but might as well
ask BFD for the size and store it here, I guess. */
-static unsigned local_symesz;
+static unsigned local_symesz;
-struct coff_symfile_info {
- file_ptr min_lineno_offset; /* Where in file lowest line#s are */
- file_ptr max_lineno_offset; /* 1+last byte of line#s in file */
+struct coff_symfile_info
+ {
+ file_ptr min_lineno_offset; /* Where in file lowest line#s are */
+ file_ptr max_lineno_offset; /* 1+last byte of line#s in file */
- /* Pointer to the string table. */
- char *strtbl;
+ /* Pointer to the string table. */
+ char *strtbl;
- /* Pointer to debug section. */
- char *debugsec;
+ /* Pointer to debug section. */
+ char *debugsec;
- /* Pointer to the a.out symbol table. */
- char *symtbl;
+ /* Pointer to the a.out symbol table. */
+ char *symtbl;
- /* Number of symbols in symtbl. */
- int symtbl_num_syms;
-};
+ /* Number of symbols in symtbl. */
+ int symtbl_num_syms;
-static struct complaint rsym_complaint =
- {"Non-stab C_RSYM `%s' needs special handling", 0, 0};
+ /* Offset in data section to TOC anchor. */
+ CORE_ADDR toc_offset;
+ };
static struct complaint storclass_complaint =
- {"Unexpected storage class: %d", 0, 0};
+{"Unexpected storage class: %d", 0, 0};
static struct complaint bf_notfound_complaint =
- {"line numbers off, `.bf' symbol not found", 0, 0};
+{"line numbers off, `.bf' symbol not found", 0, 0};
+
+static struct complaint ef_complaint =
+{"Mismatched .ef symbol ignored starting at symnum %d", 0, 0};
+
+static struct complaint eb_complaint =
+{"Mismatched .eb symbol ignored starting at symnum %d", 0, 0};
-extern struct complaint ef_complaint;
-extern struct complaint eb_complaint;
+static void
+xcoff_initial_scan PARAMS ((struct objfile *, int));
+
+static void
+scan_xcoff_symtab PARAMS ((struct objfile *));
+
+static char *
+ xcoff_next_symbol_text PARAMS ((struct objfile *));
+
+static void
+record_include_begin PARAMS ((struct coff_symbol *));
static void
enter_line_range PARAMS ((struct subfile *, unsigned, unsigned,
static void
xcoff_symfile_finish PARAMS ((struct objfile *));
-static struct section_offsets *
-xcoff_symfile_offsets PARAMS ((struct objfile *, CORE_ADDR));
+static void
+ xcoff_symfile_offsets PARAMS ((struct objfile *, struct section_addr_info *addrs));
static void
find_linenos PARAMS ((bfd *, sec_ptr, PTR));
static char *
-coff_getfilename PARAMS ((union internal_auxent *, struct objfile *));
+ coff_getfilename PARAMS ((union internal_auxent *, struct objfile *));
static void
read_symbol PARAMS ((struct internal_syment *, int));
read_symbol_nvalue PARAMS ((int));
static struct symbol *
-process_xcoff_symbol PARAMS ((struct coff_symbol *, struct objfile *));
+ process_xcoff_symbol PARAMS ((struct coff_symbol *, struct objfile *));
static void
read_xcoff_symtab PARAMS ((struct partial_symtab *));
+#if 0
static void
add_stab_to_list PARAMS ((char *, struct pending_stabs **));
+#endif
+
+static int
+compare_lte PARAMS ((const void *, const void *));
+static struct linetable *
+ arrange_linetable PARAMS ((struct linetable *));
+
+static void
+record_include_end PARAMS ((struct coff_symbol *));
+
+static void
+process_linenos PARAMS ((CORE_ADDR, CORE_ADDR));
\f
+
/* Translate from a COFF section number (target_index) to a SECT_OFF_*
code. */
static int secnum_to_section PARAMS ((int, struct objfile *));
+static asection *secnum_to_bfd_section PARAMS ((int, struct objfile *));
-struct find_targ_sec_arg {
- int targ_index;
- int *resultp;
-};
+struct find_targ_sec_arg
+ {
+ int targ_index;
+ int *resultp;
+ asection **bfd_sect;
+ };
static void find_targ_sec PARAMS ((bfd *, asection *, void *));
-static void find_targ_sec (abfd, sect, obj)
+static void
+find_targ_sec (abfd, sect, obj)
bfd *abfd;
asection *sect;
PTR obj;
{
- struct find_targ_sec_arg *args = (struct find_targ_sec_arg *)obj;
+ struct find_targ_sec_arg *args = (struct find_targ_sec_arg *) obj;
if (sect->target_index == args->targ_index)
{
/* This is the section. Figure out what SECT_OFF_* code it is. */
*args->resultp = SECT_OFF_DATA;
else
*args->resultp = SECT_OFF_BSS;
+ *args->bfd_sect = sect;
}
}
struct objfile *objfile;
{
int off = SECT_OFF_TEXT;
+ asection *sect = NULL;
struct find_targ_sec_arg args;
args.targ_index = secnum;
args.resultp = &off;
+ args.bfd_sect = §
bfd_map_over_sections (objfile->obfd, find_targ_sec, &args);
return off;
}
+
+/* Return the BFD section that CS points to. */
+static asection *
+secnum_to_bfd_section (secnum, objfile)
+ int secnum;
+ struct objfile *objfile;
+{
+ int off = SECT_OFF_TEXT;
+ asection *sect = NULL;
+ struct find_targ_sec_arg args;
+ args.targ_index = secnum;
+ args.resultp = &off;
+ args.bfd_sect = §
+ bfd_map_over_sections (objfile->obfd, find_targ_sec, &args);
+ return sect;
+}
\f
/* add a given stab string into given stab vector. */
+#if 0
+
static void
add_stab_to_list (stabname, stabvector)
-char *stabname;
-struct pending_stabs **stabvector;
+ char *stabname;
+ struct pending_stabs **stabvector;
{
- if ( *stabvector == NULL) {
- *stabvector = (struct pending_stabs *)
- xmalloc (sizeof (struct pending_stabs) +
- INITIAL_STABVECTOR_LENGTH * sizeof (char*));
- (*stabvector)->count = 0;
- (*stabvector)->length = INITIAL_STABVECTOR_LENGTH;
- }
- else if ((*stabvector)->count >= (*stabvector)->length) {
- (*stabvector)->length += INITIAL_STABVECTOR_LENGTH;
- *stabvector = (struct pending_stabs *)
- xrealloc ((char *) *stabvector, sizeof (struct pending_stabs) +
- (*stabvector)->length * sizeof (char*));
- }
- (*stabvector)->stab [(*stabvector)->count++] = stabname;
+ if (*stabvector == NULL)
+ {
+ *stabvector = (struct pending_stabs *)
+ xmalloc (sizeof (struct pending_stabs) +
+ INITIAL_STABVECTOR_LENGTH * sizeof (char *));
+ (*stabvector)->count = 0;
+ (*stabvector)->length = INITIAL_STABVECTOR_LENGTH;
+ }
+ else if ((*stabvector)->count >= (*stabvector)->length)
+ {
+ (*stabvector)->length += INITIAL_STABVECTOR_LENGTH;
+ *stabvector = (struct pending_stabs *)
+ xrealloc ((char *) *stabvector, sizeof (struct pending_stabs) +
+ (*stabvector)->length * sizeof (char *));
+ }
+ (*stabvector)->stab[(*stabvector)->count++] = stabname;
}
-\f
+
+#endif
+\f/* *INDENT-OFF* */
/* 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.
-
- 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. */
+ 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.
+
+ 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. */
+/* *INDENT-ON* */
+
+
/* compare line table entry addresses. */
static int
-compare_lte (lte1, lte2)
- struct linetable_entry *lte1, *lte2;
+compare_lte (lte1p, lte2p)
+ const void *lte1p;
+ const void *lte2p;
{
+ struct linetable_entry *lte1 = (struct linetable_entry *) lte1p;
+ struct linetable_entry *lte2 = (struct linetable_entry *) lte2p;
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
+/* Given a line table with function entries are marked, arrange its functions
+ in ascending 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)
- struct linetable *oldLineTb; /* old linetable */
+ struct linetable *oldLineTb; /* old linetable */
{
- int ii, jj,
- newline, /* new line count */
- function_count; /* # of functions */
+ int ii, jj, newline, /* new line count */
+ function_count; /* # of functions */
- struct linetable_entry *fentry; /* function entry vector */
- int fentry_size; /* # of function entries */
- struct linetable *newLineTb; /* new line table */
+ struct linetable_entry *fentry; /* function entry vector */
+ int fentry_size; /* # of function entries */
+ struct linetable *newLineTb; /* new line table */
#define NUM_OF_FUNCTIONS 20
fentry_size = NUM_OF_FUNCTIONS;
- fentry = (struct linetable_entry*)
+ fentry = (struct linetable_entry *)
xmalloc (fentry_size * sizeof (struct linetable_entry));
- for (function_count=0, ii=0; ii <oldLineTb->nitems; ++ii) {
+ for (function_count = 0, ii = 0; ii < oldLineTb->nitems; ++ii)
+ {
- if (oldLineTb->item[ii].line == 0) { /* function entry found. */
+ if (oldLineTb->item[ii].line == 0)
+ { /* function entry found. */
- if (function_count >= fentry_size) { /* make sure you have room. */
- fentry_size *= 2;
- fentry = (struct linetable_entry*)
- xrealloc (fentry, fentry_size * sizeof (struct linetable_entry));
- }
- fentry[function_count].line = ii;
- fentry[function_count].pc = oldLineTb->item[ii].pc;
- ++function_count;
+ if (function_count >= fentry_size)
+ { /* make sure you have room. */
+ fentry_size *= 2;
+ fentry = (struct linetable_entry *)
+ xrealloc (fentry, fentry_size * sizeof (struct linetable_entry));
+ }
+ fentry[function_count].line = ii;
+ fentry[function_count].pc = oldLineTb->item[ii].pc;
+ ++function_count;
+ }
}
- }
- if (function_count == 0) {
- free (fentry);
- return oldLineTb;
- }
+ if (function_count == 0)
+ {
+ free (fentry);
+ return oldLineTb;
+ }
else if (function_count > 1)
- qsort (fentry, function_count, sizeof(struct linetable_entry), compare_lte);
+ qsort (fentry, function_count, sizeof (struct linetable_entry), compare_lte);
/* allocate a new line table. */
newLineTb = (struct linetable *)
xmalloc
- (sizeof (struct linetable) +
- (oldLineTb->nitems - function_count) * sizeof (struct linetable_entry));
+ (sizeof (struct linetable) +
+ (oldLineTb->nitems - function_count) * sizeof (struct linetable_entry));
/* if line table does not start with a function beginning, copy up until
a function begin. */
newline = 0;
if (oldLineTb->item[0].line != 0)
- for (newline=0;
- newline < oldLineTb->nitems && oldLineTb->item[newline].line; ++newline)
+ for (newline = 0;
+ newline < oldLineTb->nitems && oldLineTb->item[newline].line; ++newline)
newLineTb->item[newline] = oldLineTb->item[newline];
/* Now copy function lines one by one. */
- for (ii=0; ii < function_count; ++ii) {
- for (jj = fentry[ii].line + 1;
- jj < oldLineTb->nitems && oldLineTb->item[jj].line != 0;
- ++jj, ++newline)
- newLineTb->item[newline] = oldLineTb->item[jj];
- }
+ for (ii = 0; ii < function_count; ++ii)
+ {
+ for (jj = fentry[ii].line + 1;
+ jj < oldLineTb->nitems && oldLineTb->item[jj].line != 0;
+ ++jj, ++newline)
+ newLineTb->item[newline] = oldLineTb->item[jj];
+ }
free (fentry);
newLineTb->nitems = oldLineTb->nitems - function_count;
- return newLineTb;
-}
+ return newLineTb;
+}
/* include file support: C_BINCL/C_EINCL pairs will be kept in the
following `IncludeChain'. At the end of each symtab (end_symtab),
represent if (the include files. */
-typedef struct _inclTable {
- char *name; /* include filename */
+typedef struct _inclTable
+{
+ char *name; /* include filename */
/* Offsets to the line table. end points to the last entry which is
part of this include file. */
- int begin, end;
-
+ int begin, end;
+
struct subfile *subfile;
- unsigned funStartLine; /* start line # of its function */
-} InclTable;
+ unsigned funStartLine; /* start line # of its function */
+}
+InclTable;
#define INITIAL_INCLUDE_TABLE_LENGTH 20
-static InclTable *inclTable; /* global include table */
-static int inclIndx; /* last entry to table */
-static int inclLength; /* table length */
-static int inclDepth; /* nested include depth */
+static InclTable *inclTable; /* global include table */
+static int inclIndx; /* last entry to table */
+static int inclLength; /* table length */
+static int inclDepth; /* nested include depth */
static void allocate_include_entry PARAMS ((void));
static void
record_include_begin (cs)
-struct coff_symbol *cs;
+ struct coff_symbol *cs;
{
if (inclDepth)
{
/* In xcoff, we assume include files cannot be nested (not in .c files
- of course, but in corresponding .s 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};
+ 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_include_entry ();
- inclTable [inclIndx].name = cs->c_name;
- inclTable [inclIndx].begin = cs->c_value;
+ inclTable[inclIndx].name = cs->c_name;
+ inclTable[inclIndx].begin = cs->c_value;
}
static void
record_include_end (cs)
-struct coff_symbol *cs;
+ struct coff_symbol *cs;
{
- InclTable *pTbl;
+ InclTable *pTbl;
if (inclDepth == 0)
{
- static struct complaint msg = {"Mismatched C_BINCL/C_EINCL pair", 0, 0};
+ static struct complaint msg =
+ {"Mismatched C_BINCL/C_EINCL pair", 0, 0};
complain (&msg);
}
allocate_include_entry ();
- pTbl = &inclTable [inclIndx];
+ pTbl = &inclTable[inclIndx];
pTbl->end = cs->c_value;
--inclDepth;
{
if (inclTable == NULL)
{
- inclTable = (InclTable *)
+ inclTable = (InclTable *)
xmalloc (sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
memset (inclTable,
'\0', sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
else if (inclIndx >= inclLength)
{
inclLength += INITIAL_INCLUDE_TABLE_LENGTH;
- inclTable = (InclTable *)
+ inclTable = (InclTable *)
xrealloc (inclTable, sizeof (InclTable) * inclLength);
- memset (inclTable + inclLength - INITIAL_INCLUDE_TABLE_LENGTH,
- '\0', sizeof (InclTable)*INITIAL_INCLUDE_TABLE_LENGTH);
+ memset (inclTable + inclLength - INITIAL_INCLUDE_TABLE_LENGTH,
+ '\0', sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
}
}
process_linenos (start, end)
CORE_ADDR start, end;
{
- char *pp;
int offset, ii;
file_ptr max_offset =
- ((struct coff_symfile_info *)this_symtab_psymtab->objfile->sym_private)
- ->max_lineno_offset;
+ ((struct coff_symfile_info *) this_symtab_psymtab->objfile->sym_private)
+ ->max_lineno_offset;
/* subfile structure for the main compilation unit. */
struct subfile main_subfile;
All the following line numbers in the function are relative to
this, and we record absolute line numbers in record_line(). */
- int main_source_baseline = 0;
+ unsigned int main_source_baseline = 0;
unsigned *firstLine;
- CORE_ADDR addr;
offset =
- ((struct symloc *)this_symtab_psymtab->read_symtab_private)->lineno_off;
+ ((struct symloc *) this_symtab_psymtab->read_symtab_private)->lineno_off;
if (offset == 0)
goto return_after_cleanup;
if (inclIndx == 0)
/* All source lines were in the main source file. None in include files. */
- enter_line_range (&main_subfile, offset, 0, start, end,
- &main_source_baseline);
+ enter_line_range (&main_subfile, offset, 0, start, end,
+ &main_source_baseline);
else
{
/* There was source with line numbers in include files. */
main_source_baseline = 0;
- for (ii=0; ii < inclIndx; ++ii)
+ for (ii = 0; ii < inclIndx; ++ii)
{
struct subfile *tmpSubfile;
firstLine = &(inclTable[ii].funStartLine);
/* Enter include file's lines now. */
- enter_line_range (tmpSubfile, inclTable[ii].begin,
+ enter_line_range (tmpSubfile, inclTable[ii].begin,
inclTable[ii].end, start, 0, firstLine);
- if (offset < = inclTable[ii].end)
+ if (offset <= inclTable[ii].end)
offset = inclTable[ii].end + LINESZ;
}
/* All the include files' line have been processed at this point. Now,
- enter remaining lines of the main file, if any left. */
+ enter remaining lines of the main file, if any left. */
if (offset < max_offset + 1 - LINESZ)
{
- enter_line_range (&main_subfile, offset, 0, start, end,
+ enter_line_range (&main_subfile, offset, 0, start, end,
&main_source_baseline);
}
}
lv = main_subfile.line_vector;
/* Line numbers are not necessarily ordered. xlc compilation will
- put static function to the end. */
+ put static function to the end. */
lineTb = arrange_linetable (lv);
if (lv == lineTb)
current_subfile->line_vector = lineTb;
}
- current_subfile->line_vector_length =
+ current_subfile->line_vector_length =
current_subfile->line_vector->nitems;
}
/* Now, process included files' line numbers. */
- for (ii=0; ii < inclIndx; ++ii)
+ for (ii = 0; ii < inclIndx; ++ii)
{
- if ((inclTable[ii].subfile)->line_vector) /* Useless if!!! FIXMEmgo */
+ if ((inclTable[ii].subfile)->line_vector) /* Useless if!!! FIXMEmgo */
{
struct linetable *lineTb, *lv;
/* For the same include file, we might want to have more than one
subfile. This happens if we have something like:
- ......
- #include "foo.h"
- ......
- #include "foo.h"
- ......
+ ......
+ #include "foo.h"
+ ......
+ #include "foo.h"
+ ......
while foo.h including code in it. (stupid but possible)
Since start_subfile() looks at the name and uses an
fool it. */
#if 0
- start_subfile (inclTable[ii].name, (char*)0);
+ start_subfile (inclTable[ii].name, (char *) 0);
#else
{
/* Pick a fake name that will produce the same results as this
char *fakename = strrchr (inclTable[ii].name, '.');
if (fakename == NULL)
fakename = " ?";
- start_subfile (fakename, (char*)0);
+ start_subfile (fakename, (char *) 0);
free (current_subfile->name);
}
- current_subfile->name = strdup (inclTable[ii].name);
+ current_subfile->name = xstrdup (inclTable[ii].name);
#endif
if (lv == lineTb)
{
current_subfile->line_vector =
(struct linetable *) xrealloc
- (lv, (sizeof (struct linetable)
- + lv->nitems * sizeof (struct linetable_entry)));
+ (lv, (sizeof (struct linetable)
+ + lv->nitems * sizeof (struct linetable_entry)));
}
else
current_subfile->line_vector = lineTb;
}
- current_subfile->line_vector_length =
+ current_subfile->line_vector_length =
current_subfile->line_vector->nitems;
- start_subfile (pop_subfile (), (char*)0);
+ start_subfile (pop_subfile (), (char *) 0);
}
}
- return_after_cleanup:
+return_after_cleanup:
/* We don't want to keep alloc/free'ing the global include file table. */
inclIndx = 0;
/* Enter a given range of lines into the line vector.
can be called in the following two ways:
- enter_line_range (subfile, beginoffset, endoffset, startaddr, 0, firstLine) or
- enter_line_range (subfile, beginoffset, 0, startaddr, endaddr, firstLine)
+ enter_line_range (subfile, beginoffset, endoffset, startaddr, 0, firstLine) or
+ enter_line_range (subfile, beginoffset, 0, startaddr, endaddr, firstLine)
endoffset points to the last line table entry that we should pay
attention to. */
enter_line_range (subfile, beginoffset, endoffset, startaddr, endaddr,
firstLine)
struct subfile *subfile;
- unsigned beginoffset, endoffset; /* offsets to line table */
- CORE_ADDR startaddr, endaddr;
- unsigned *firstLine;
+ unsigned beginoffset, endoffset; /* offsets to line table */
+ CORE_ADDR startaddr, endaddr;
+ unsigned *firstLine;
{
unsigned int curoffset;
CORE_ADDR addr;
return;
curoffset = beginoffset;
limit_offset =
- ((struct coff_symfile_info *)this_symtab_psymtab->objfile->sym_private)
- ->max_lineno_offset;
+ ((struct coff_symfile_info *) this_symtab_psymtab->objfile->sym_private)
+ ->max_lineno_offset;
if (endoffset != 0)
{
if (endoffset >= limit_offset)
{
static struct complaint msg =
- {"Bad line table offset in C_EINCL directive", 0, 0};
+ {"Bad line table offset in C_EINCL directive", 0, 0};
complain (&msg);
return;
}
}
}
-typedef struct {
- int fsize; /* file size */
- int fixedparms; /* number of fixed parms */
- int floatparms; /* number of float parms */
- unsigned int parminfo; /* parameter info.
- See /usr/include/sys/debug.h
- tbtable_ext.parminfo */
- int framesize; /* function frame size */
-} TracebackInfo;
-
-static TracebackInfo *retrieve_tracebackinfo
- PARAMS ((bfd *, struct coff_symbol *));
-
-/* Given a function symbol, return its traceback information. */
-
-static TracebackInfo *
-retrieve_tracebackinfo (abfd, cs)
- bfd *abfd;
- struct coff_symbol *cs;
-{
-#define TBTABLE_BUFSIZ 2000
-
- static TracebackInfo tbInfo;
- struct tbtable *ptb;
-
- static char buffer [TBTABLE_BUFSIZ];
-
- int *pinsn;
- int bytesread=0; /* total # of bytes read so far */
- int bufferbytes; /* number of bytes in the buffer */
- int functionstart;
-
- asection *textsec;
-
- /* FIXME: Should be looking through all sections, based on the
- address we are considering. Just using ".text" loses if more
- than one section has code in it. */
- textsec = bfd_get_section_by_name (abfd, ".text");
- if (!textsec)
- {
-#if 0
- /* If there is only data, no text, that is OK. */
- printf_unfiltered ("Unable to locate text section!\n");
-#endif
- return;
- }
-
- functionstart = cs->c_value - textsec->vma;
-
- memset (&tbInfo, '\0', sizeof (tbInfo));
-
- /* keep reading blocks of data from the text section, until finding a zero
- word and a traceback table. */
-
- /* Note: The logical thing way to write this code would be to assign
- to bufferbytes within the while condition. But that triggers a
- compiler (xlc in AIX 3.2) bug, so simplify it... */
- bufferbytes =
- (TBTABLE_BUFSIZ < (textsec->_raw_size - functionstart - bytesread) ?
- TBTABLE_BUFSIZ : (textsec->_raw_size - functionstart - bytesread));
- while (bufferbytes
- && (bfd_get_section_contents
- (abfd, textsec, buffer,
- (file_ptr)(functionstart + bytesread), bufferbytes)))
- {
- bytesread += bufferbytes;
- pinsn = (int*) buffer;
-
- /* If this is the first time we filled the buffer, retrieve function
- framesize info. */
-
- if (bytesread == bufferbytes) {
-
- /* skip over unrelated instructions */
-
- if (*pinsn == 0x7c0802a6) /* mflr r0 */
- ++pinsn;
- if ((*pinsn & 0xfc00003e) == 0x7c000026) /* mfcr Rx */
- ++pinsn;
- if ((*pinsn & 0xfc000000) == 0x48000000) /* bl foo, save fprs */
- ++pinsn;
- if ((*pinsn & 0xfc1f0000) == 0xbc010000) /* stm Rx, NUM(r1) */
- ++pinsn;
-
- do {
- int tmp = (*pinsn >> 16) & 0xffff;
-
- if (tmp == 0x9421) { /* stu r1, NUM(r1) */
- tbInfo.framesize = 0x10000 - (*pinsn & 0xffff);
- break;
- }
- else if ((*pinsn == 0x93e1fffc) || /* st r31,-4(r1) */
- (tmp == 0x9001)) /* st r0, NUM(r1) */
- ;
- /* else, could not find a frame size. */
- else
- return NULL;
-
- } while (++pinsn && *pinsn);
-
- if (!tbInfo.framesize)
- return NULL;
-
- }
-
- /* look for a zero word. */
-
- while (*pinsn && (pinsn < (int*)(buffer + bufferbytes - sizeof(int))))
- ++pinsn;
-
- if (pinsn >= (int*)(buffer + bufferbytes))
- continue;
-
- if (*pinsn == 0) {
-
- /* function size is the amount of bytes we have skipped so far. */
- tbInfo.fsize = bytesread - (buffer + bufferbytes - (char*)pinsn);
-
- ++pinsn;
-
- /* if we don't have the whole traceback table in the buffer, re-read
- the whole thing. */
-
- /* This is how much to read to get the traceback table.
- 8 bytes of the traceback table are always present, plus we
- look at parminfo. */
-#define MIN_TBTABSIZ 12
-
- if ((char*)pinsn > (buffer + bufferbytes - MIN_TBTABSIZ)) {
-
- /* In case if we are *very* close to the end of the text section
- and cannot read properly from that point on, abort by returning
- NULL.
-
- This could happen if the traceback table is only 8 bytes,
- but we try to read 12 bytes of it.
- Handle this case more graciously -- FIXME */
-
- if (!bfd_get_section_contents (
- abfd, textsec, buffer,
- (file_ptr)(functionstart +
- bytesread - (buffer + bufferbytes - (char*)pinsn)),MIN_TBTABSIZ))
- { printf_unfiltered ("Abnormal return!..\n"); return NULL; }
-
- ptb = (struct tbtable *)buffer;
- }
- else
- ptb = (struct tbtable *)pinsn;
-
- tbInfo.fixedparms = ptb->tb.fixedparms;
- tbInfo.floatparms = ptb->tb.floatparms;
- tbInfo.parminfo = ptb->tb_ext.parminfo;
- return &tbInfo;
- }
- bufferbytes =
- (TBTABLE_BUFSIZ < (textsec->_raw_size - functionstart - bytesread) ?
- TBTABLE_BUFSIZ : (textsec->_raw_size - functionstart - bytesread));
- }
- return NULL;
-}
/* Save the vital information for use when closing off the current file.
NAME is the file name the symbols came from, START_ADDR is the first
namestr = (NAME); \
if (namestr[0] == '.') ++namestr; \
prim_record_minimal_symbol_and_info (namestr, (ADDR), (TYPE), \
- (char *)NULL, (SECTION), (OBJFILE)); \
+ (char *)NULL, (SECTION), (asection *)NULL, (OBJFILE)); \
misc_func_recorded = 1; \
}
-/* A parameter template, used by ADD_PARM_TO_PENDING. It is initialized
- in our initializer function at the bottom of the file, to avoid
- dependencies on the exact "struct symbol" format. */
-
-static struct symbol parmsym;
-
-/* Add a parameter to a given pending symbol list. */
-
-#define ADD_PARM_TO_PENDING(PARM, VALUE, PTYPE, PENDING_SYMBOLS) \
-{ \
- PARM = (struct symbol *) \
- obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol)); \
- *(PARM) = parmsym; \
- SYMBOL_TYPE (PARM) = PTYPE; \
- SYMBOL_VALUE (PARM) = VALUE; \
- add_symbol_to_list (PARM, &PENDING_SYMBOLS); \
-}
-
-
/* xcoff has static blocks marked in `.bs', `.es' pairs. They cannot be
nested. At any given time, a symbol can only be in one static block.
This is the base address of current static block, zero if non exists. */
-
+
static int static_block_base = 0;
/* Section number for the current static block. */
/* This is the function which stabsread.c calls to get symbol
continuations. */
+
static char *
-xcoff_next_symbol_text ()
+xcoff_next_symbol_text (objfile)
+ struct objfile *objfile;
{
struct internal_syment symbol;
static struct complaint msg =
- {"Unexpected symbol continuation", 0, 0};
+ {"Unexpected symbol continuation", 0, 0};
char *retval;
- struct objfile *objfile = this_symtab_psymtab->objfile;
+ /* FIXME: is this the same as the passed arg? */
+ objfile = this_symtab_psymtab->objfile;
bfd_coff_swap_sym_in (objfile->obfd, raw_symbol, &symbol);
if (symbol.n_zeroes)
complain (&msg);
/* Return something which points to '\0' and hope the symbol reading
- code does something reasonable. */
+ code does something reasonable. */
retval = "";
}
else if (symbol.n_sclass & 0x80)
{
retval =
- ((struct coff_symfile_info *)objfile->sym_private)->debugsec
- + symbol.n_offset;
+ ((struct coff_symfile_info *) objfile->sym_private)->debugsec
+ + symbol.n_offset;
raw_symbol +=
coff_data (objfile->obfd)->local_symesz;
++symnum;
complain (&msg);
/* Return something which points to '\0' and hope the symbol reading
- code does something reasonable. */
+ code does something reasonable. */
retval = "";
}
return retval;
struct objfile *objfile = pst->objfile;
bfd *abfd = objfile->obfd;
char *raw_auxptr; /* Pointer to first raw aux entry for sym */
- TracebackInfo *ptb; /* Pointer to traceback table */
- char *strtbl = ((struct coff_symfile_info *)objfile->sym_private)->strtbl;
+ char *strtbl = ((struct coff_symfile_info *) objfile->sym_private)->strtbl;
char *debugsec =
- ((struct coff_symfile_info *)objfile->sym_private)->debugsec;
+ ((struct coff_symfile_info *) objfile->sym_private)->debugsec;
struct internal_syment symbol[1];
union internal_auxent main_aux;
unsigned int max_symnum;
int just_started = 1;
int depth = 0;
- int val;
- int fcn_start_addr;
- size_t size;
+ int fcn_start_addr = 0;
struct coff_symbol fcn_stab_saved;
/* fcn_cs_saved is global because process_xcoff_symbol needs it. */
union internal_auxent fcn_aux_saved;
- struct type *fcn_type_saved = NULL;
struct context_stack *new;
char *filestring = " _start_ "; /* Name of the current file. */
- char *last_csect_name; /* last seen csect's name and value */
+ char *last_csect_name; /* last seen csect's name and value */
CORE_ADDR last_csect_val;
int last_csect_sec;
- int misc_func_recorded; /* true if any misc. function */
this_symtab_psymtab = pst;
last_source_file = NULL;
last_csect_name = 0;
last_csect_val = 0;
- misc_func_recorded = 0;
start_stabs ();
- start_symtab (filestring, (char *)NULL, file_start_addr);
- symnum = ((struct symloc *)pst->read_symtab_private)->first_symnum;
+ start_symtab (filestring, (char *) NULL, file_start_addr);
+ record_debugformat ("XCOFF");
+ symnum = ((struct symloc *) pst->read_symtab_private)->first_symnum;
max_symnum =
- symnum + ((struct symloc *)pst->read_symtab_private)->numsyms;
+ symnum + ((struct symloc *) pst->read_symtab_private)->numsyms;
first_object_file_end = 0;
raw_symbol =
((struct coff_symfile_info *) objfile->sym_private)->symtbl
- + symnum * local_symesz;
+ + symnum * local_symesz;
while (symnum < max_symnum)
{
/* READ_ONE_SYMBOL (symbol, cs, symname_alloced); */
/* read one symbol into `cs' structure. After processing the
- whole symbol table, only string table will be kept in memory,
- symbol table and debug section of xcoff will be freed. Thus
- we can mark symbols with names in string table as
- `alloced'. */
+ whole symbol table, only string table will be kept in memory,
+ symbol table and debug section of xcoff will be freed. Thus
+ we can mark symbols with names in string table as
+ `alloced'. */
{
int ii;
/* We must use the original, unswapped, name here so the name field
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;
+ cs->c_name = ((struct external_syment *) raw_symbol)->e.e_name;
/* If it's exactly E_SYMNMLEN characters long it isn't
'\0'-terminated. */
if (cs->c_name[E_SYMNMLEN - 1] != '\0')
else
{
/* in string table */
- cs->c_name = strtbl + (int)symbol->n_offset;
+ cs->c_name = strtbl + (int) symbol->n_offset;
symname_alloced = 1;
}
cs->c_value = symbol->n_value;
cs->c_sclass = symbol->n_sclass;
cs->c_secnum = symbol->n_scnum;
- cs->c_type = (unsigned)symbol->n_type;
+ cs->c_type = (unsigned) symbol->n_type;
raw_symbol += coff_data (abfd)->local_symesz;
++symnum;
if (last_source_file)
{
pst->symtab =
- end_symtab (cur_src_end_addr, 1, 0, objfile, SECT_OFF_TEXT);
+ end_symtab (cur_src_end_addr, objfile, SECT_OFF_TEXT);
end_stabs ();
}
start_stabs ();
- start_symtab ("_globals_", (char *)NULL, (CORE_ADDR)0);
+ start_symtab ("_globals_", (char *) NULL, (CORE_ADDR) 0);
+ record_debugformat ("XCOFF");
cur_src_end_addr = first_object_file_end;
/* done with all files, everything from here on is globals */
}
/* if explicitly specified as a function, treat is as one. */
- if (ISFCN(cs->c_type) && cs->c_sclass != C_TPDEF)
+ if (ISFCN (cs->c_type) && cs->c_sclass != C_TPDEF)
{
bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
0, cs->c_naux, &main_aux);
{
/* 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. */
+ 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)
{
complete_symtab (filestring, file_start_addr);
cur_src_end_addr = file_end_addr;
- end_symtab (file_end_addr, 1, 0, objfile,
- SECT_OFF_TEXT);
+ end_symtab (file_end_addr, objfile, SECT_OFF_TEXT);
end_stabs ();
start_stabs ();
/* Give all csects for this source file the same
name. */
- start_symtab (filestring, NULL, (CORE_ADDR)0);
+ start_symtab (filestring, NULL, (CORE_ADDR) 0);
+ record_debugformat ("XCOFF");
}
/* If this is the very first csect seen,
- basically `__start'. */
+ basically `__start'. */
if (just_started)
{
first_object_file_end
last_csect_sec = secnum_to_section (cs->c_secnum, objfile);
}
}
- misc_func_recorded = 0;
continue;
- case XMC_RW :
- break;
+ /* All other symbols are put into the minimal symbol
+ table only. */
- /* If the section is not a data description,
- ignore it. Note that uninitialized data will
- show up as XTY_CM/XMC_RW pair. */
+ case XMC_RW:
+ continue;
case XMC_TC0:
continue;
when `.bf' is seen. */
fcn_cs_saved = *cs;
fcn_aux_saved = main_aux;
-
- ptb = NULL;
-
- /* If function has two auxent, then debugging information is
- already available for it. Process traceback table for
- functions with only one auxent. */
-
- if (cs->c_naux == 1)
- ptb = retrieve_tracebackinfo (abfd, cs);
-
- else if (cs->c_naux != 2)
- {
- static struct complaint msg =
- {"Expected one or two auxents for function", 0, 0};
- complain (&msg);
- }
-
- /* If there is traceback info, create and add parameters
- for it. */
-
- if (ptb && (ptb->fixedparms || ptb->floatparms))
- {
-
- int parmcnt = ptb->fixedparms + ptb->floatparms;
- char *parmcode = (char*) &ptb->parminfo;
-
- /* The link area is 0x18 bytes. */
- int parmvalue = ptb->framesize + 0x18;
- unsigned int ii, mask;
-
- for (ii=0, mask = 0x80000000; ii <parmcnt; ++ii)
- {
- struct symbol *parm;
-
- if (ptb->parminfo & mask)
- {
- /* float or double */
- mask = mask >> 1;
- if (ptb->parminfo & mask)
- {
- /* double parm */
- ADD_PARM_TO_PENDING
- (parm, parmvalue, builtin_type_double,
- local_symbols);
- parmvalue += sizeof (double);
- }
- else
- {
- /* float parm */
- ADD_PARM_TO_PENDING
- (parm, parmvalue, builtin_type_float,
- local_symbols);
- parmvalue += sizeof (float);
- }
- }
- else
- {
- static struct type *intparm_type;
- if (intparm_type == NULL)
- {
-
- /* Create a type, which is a pointer
- type (a kludge to make it print
- in hex), but which has a name
- indicating we don't know the real
- type. */
-
- intparm_type =
- init_type
- (TYPE_CODE_PTR,
- TARGET_PTR_BIT / HOST_CHAR_BIT,
- 0,
- "<non-float parameter>",
- NULL);
- TYPE_TARGET_TYPE (intparm_type) =
- builtin_type_void;
- }
- ADD_PARM_TO_PENDING
- (parm, parmvalue,
- intparm_type,
- local_symbols);
- parmvalue += sizeof (int);
- }
- mask = mask >> 1;
- }
-
- /* Fake this as a function. Needed in
- process_xcoff_symbol(). */
- cs->c_type = 32;
-
- finish_block
- (process_xcoff_symbol (cs, objfile), &local_symbols,
- pending_blocks, cs->c_value,
- cs->c_value + ptb->fsize, objfile);
- }
continue;
case XMC_GL:
/* xlc puts each variable in a separate csect, so we get
an XTY_SD for each variable. But gcc puts several
variables in a csect, so that each variable only gets
- an XTY_LD. We still need to record them. This will
- typically be XMC_RW; I suspect XMC_RO and XMC_BS might
- be possible too. */
- break;
+ an XTY_LD. This will typically be XMC_RW; I suspect
+ XMC_RO and XMC_BS might be possible too.
+ These variables are put in the minimal symbol table
+ only. */
+ continue;
}
+ break;
+
+ case XTY_CM:
+ /* Common symbols are put into the minimal symbol table only. */
+ continue;
default:
break;
complete_symtab (filestring, file_start_addr);
cur_src_end_addr = file_end_addr;
- end_symtab (file_end_addr, 1, 0, objfile, SECT_OFF_TEXT);
+ end_symtab (file_end_addr, objfile, SECT_OFF_TEXT);
end_stabs ();
/* XCOFF, according to the AIX 3.2 documentation, puts the filename
filestring = cs->c_name;
start_stabs ();
- start_symtab (filestring, (char *)NULL, (CORE_ADDR)0);
+ start_symtab (filestring, (char *) NULL, (CORE_ADDR) 0);
+ record_debugformat ("XCOFF");
last_csect_name = 0;
/* reset file start and end addresses. A compilation unit with no text
new = push_context (0, fcn_start_addr + off);
- new->name = define_symbol
+ new->name = define_symbol
(fcn_cs_saved.c_value + off,
fcn_stab_saved.c_name, 0, 0, objfile);
if (new->name != NULL)
0, cs->c_naux, &main_aux);
/* The value of .ef is the address of epilogue code;
- not useful for gdb. */
+ not useful for gdb. */
/* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
- contains number of lines to '}' */
+ contains number of lines to '}' */
+ if (context_stack_depth <= 0)
+ { /* We attempted to pop an empty context stack */
+ complain (&ef_complaint, cs->c_symnum);
+ within_function = 0;
+ break;
+ }
new = pop_context ();
/* Stack must be empty now. */
if (context_stack_depth > 0 || new == NULL)
case C_ENTAG:
{
static struct complaint msg =
- {"Unrecognized storage class %d.", 0, 0};
+ {"Unrecognized storage class %d.", 0, 0};
complain (&msg, cs->c_sclass);
}
break;
break;
case C_HIDEXT:
+ case C_STAT:
break;
case C_BINCL:
}
else if (STREQ (cs->c_name, ".eb"))
{
+ if (context_stack_depth <= 0)
+ { /* We attempted to pop an empty context stack */
+ complain (&eb_complaint, cs->c_symnum);
+ break;
+ }
new = pop_context ();
if (depth-- != new->depth)
{
- complain (&eb_complaint, symnum);
+ complain (&eb_complaint, cs->c_symnum);
break;
}
if (local_symbols && context_stack_depth > 0)
complete_symtab (filestring, file_start_addr);
cur_src_end_addr = file_end_addr;
- s = end_symtab (file_end_addr, 1, 0, objfile, SECT_OFF_TEXT);
+ s = end_symtab (file_end_addr, objfile, SECT_OFF_TEXT);
/* When reading symbols for the last C_FILE of the objfile, try
to make sure that we set pst->symtab to the symtab for the
file, not to the _globals_ symtab. I'm not sure whether this
(SYMBOL2) = (struct symbol *) \
obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol)); \
*(SYMBOL2) = *(SYMBOL1);
-
-
+
+
#define SYMNAME_ALLOC(NAME, ALLOCED) \
- (ALLOCED) ? (NAME) : obstack_copy0 (&objfile->symbol_obstack, (NAME), strlen (NAME));
+ (ALLOCED) ? (NAME) : obsavestring ((NAME), strlen (NAME), &objfile->symbol_obstack);
static struct type *func_symbol_type;
static struct symbol *
process_xcoff_symbol (cs, objfile)
- register struct coff_symbol *cs;
- struct objfile *objfile;
+ register struct coff_symbol *cs;
+ struct objfile *objfile;
{
struct symbol onesymbol;
register struct symbol *sym = &onesymbol;
struct symbol *sym2 = NULL;
- struct type *ttype;
- char *name, *pp, *qq;
- int struct_and_type_combined;
- int nameless;
+ char *name, *pp;
int sec;
CORE_ADDR off;
if (cs->c_secnum < 0)
{
/* The value is a register number, offset within a frame, etc.,
- and does not get relocated. */
+ and does not get relocated. */
off = 0;
sec = -1;
}
if (ISFCN (cs->c_type))
{
/* At this point, we don't know the type of the function. This
- will be patched with the type from its stab entry later on in
- patch_block_stabs (), unless the file was compiled without -g. */
+ will be patched with the type from its stab entry later on in
+ patch_block_stabs (), unless the file was compiled without -g. */
SYMBOL_NAME (sym) = SYMNAME_ALLOC (name, symname_alloced);
SYMBOL_TYPE (sym) = func_symbol_type;
switch (cs->c_sclass)
{
#if 0
+ /* The values of functions and global symbols are now resolved
+ via the global_sym_chain in stabsread.c. */
case C_FUN:
if (fcn_cs_saved.c_sclass == C_EXT)
add_stab_to_list (name, &global_stabs);
else
add_stab_to_list (name, &file_stabs);
break;
-#endif
case C_GSYM:
add_stab_to_list (name, &global_stabs);
break;
+#endif
case C_BCOMM:
common_block_start (cs->c_name, objfile);
case C_ECOML:
case C_LSYM:
case C_RSYM:
+ case C_GSYM:
{
sym = define_symbol (cs->c_value + off, cs->c_name, 0, 0, objfile);
where we need to, which is not necessarily super-clean,
but seems workable enough. */
- if (*name == ':' || (pp = (char *) strchr(name, ':')) == NULL)
+ if (*name == ':' || (pp = (char *) strchr (name, ':')) == NULL)
return NULL;
++pp;
}
return sym;
-#if 0
- /* These appear to be vestigial remnants of coffread.c; I don't
- think any of them are used for xcoff. */
-
- case C_AUTO:
- SYMBOL_CLASS (sym) = LOC_LOCAL;
- SYMBOL_NAME (sym) = SYMNAME_ALLOC (name, symname_alloced);
- SYMBOL_SECTION (sym) = secnum_to_section (cs->c_secnum, objfile);
- SYMBOL_DUP (sym, sym2);
- add_symbol_to_list (sym2, &local_symbols);
- break;
-
- case C_STAT:
- SYMBOL_CLASS (sym) = LOC_STATIC;
- SYMBOL_NAME (sym) = SYMNAME_ALLOC (name, symname_alloced);
- SYMBOL_SECTION (sym) = secnum_to_section (cs->c_secnum, objfile);
- SYMBOL_DUP (sym, sym2);
- add_symbol_to_list
- (sym2, within_function ? &local_symbols : &file_symbols);
- break;
-
- case C_RSYM:
- pp = (char*) strchr (name, ':');
- if (pp)
- {
- sym = define_symbol (cs->c_value, cs->c_name, 0, 0, objfile);
- if (sym != NULL)
- SYMBOL_SECTION (sym) = secnum_to_section (cs->c_secnum, objfile);
- return sym;
- }
- else
- {
- complain (&rsym_complaint, name);
- return NULL;
- }
-#endif /* 0 */
-
- /* I think this one is used (dubious, I think, shouldn't
- it go into the msyms only?). */
- case C_EXT:
- SYMBOL_CLASS (sym) = LOC_STATIC;
- SYMBOL_NAME (sym) = SYMNAME_ALLOC (name, symname_alloced);
- SYMBOL_SECTION (sym) = secnum_to_section (cs->c_secnum, objfile);
- SYMBOL_DUP (sym, sym2);
- add_symbol_to_list (sym2, &global_symbols);
- break;
-
}
}
return sym2;
}
-/* Extract the file name from the aux entry of a C_FILE symbol. Return
- only the last component of the name. Result is in static storage and
- is only good for temporary use. */
+/* Extract the file name from the aux entry of a C_FILE symbol.
+ Result is in static storage and is only good for temporary use. */
static char *
coff_getfilename (aux_entry, objfile)
struct objfile *objfile;
{
static char buffer[BUFSIZ];
- register char *temp;
- char *result;
if (aux_entry->x_file.x_n.x_zeroes == 0)
strcpy (buffer,
- ((struct coff_symfile_info *)objfile->sym_private)->strtbl
+ ((struct coff_symfile_info *) objfile->sym_private)->strtbl
+ aux_entry->x_file.x_n.x_offset);
else
{
strncpy (buffer, aux_entry->x_file.x_fname, FILNMLEN);
buffer[FILNMLEN] = '\0';
}
- result = buffer;
-
- /* FIXME: We should not be throwing away the information about what
- directory. It should go into dirname of the symtab, or some such
- place. */
- if ((temp = strrchr (result, '/')) != NULL)
- result = temp + 1;
- return (result);
+ return (buffer);
}
/* Set *SYMBOL to symbol number symno in symtbl. */
int symno;
{
int nsyms =
- ((struct coff_symfile_info *)this_symtab_psymtab->objfile->sym_private)
- ->symtbl_num_syms;
- char *stbl =
- ((struct coff_symfile_info *)this_symtab_psymtab->objfile->sym_private)
- ->symtbl;
+ ((struct coff_symfile_info *) this_symtab_psymtab->objfile->sym_private)
+ ->symtbl_num_syms;
+ char *stbl =
+ ((struct coff_symfile_info *) this_symtab_psymtab->objfile->sym_private)
+ ->symtbl;
if (symno < 0 || symno >= nsyms)
{
static struct complaint msg =
- {"Invalid symbol offset", 0, 0};
+ {"Invalid symbol offset", 0, 0};
complain (&msg);
symbol->n_value = 0;
symbol->n_scnum = -1;
return;
}
bfd_coff_swap_sym_in (this_symtab_psymtab->objfile->obfd,
- stbl + (symno*local_symesz),
+ stbl + (symno * local_symesz),
symbol);
}
-
+
/* Get value corresponding to symbol number symno in symtbl. */
static int
struct internal_syment symbol[1];
read_symbol (symbol, symno);
- return symbol->n_value;
+ return symbol->n_value;
}
int symno;
{
int nsyms =
- ((struct coff_symfile_info *)this_symtab_psymtab->objfile->sym_private)
- ->symtbl_num_syms;
- char *stbl =
- ((struct coff_symfile_info *)this_symtab_psymtab->objfile->sym_private)
- ->symtbl;
+ ((struct coff_symfile_info *) this_symtab_psymtab->objfile->sym_private)
+ ->symtbl_num_syms;
+ char *stbl =
+ ((struct coff_symfile_info *) this_symtab_psymtab->objfile->sym_private)
+ ->symtbl;
struct internal_syment symbol[1];
union internal_auxent main_aux[1];
find_linenos (abfd, asect, vpinfo)
bfd *abfd;
sec_ptr asect;
- PTR vpinfo;
+ PTR vpinfo;
{
struct coff_symfile_info *info;
int size, count;
return;
size = count * coff_data (abfd)->local_linesz;
- info = (struct coff_symfile_info *)vpinfo;
+ info = (struct coff_symfile_info *) vpinfo;
offset = asect->line_filepos;
maxoff = offset + size;
{
struct cleanup *old_chain;
int i;
-
+
if (!pst)
return;
fputs_filtered ("and ", gdb_stdout);
wrap_here ("");
printf_filtered ("%s...", pst->dependencies[i]->filename);
- wrap_here (""); /* Flush output */
+ wrap_here (""); /* Flush output */
gdb_flush (gdb_stdout);
}
xcoff_psymtab_to_symtab_1 (pst->dependencies[i]);
}
- if (((struct symloc *)pst->read_symtab_private)->numsyms != 0)
+ if (((struct symloc *) pst->read_symtab_private)->numsyms != 0)
{
/* Init stuff necessary for reading in symbols. */
stabsread_init ();
return;
}
- if (((struct symloc *)pst->read_symtab_private)->numsyms != 0
+ if (((struct symloc *) pst->read_symtab_private)->numsyms != 0
|| pst->number_of_dependencies)
{
/* Print the message now, before reading the string table,
- to avoid disconcerting pauses. */
+ to avoid disconcerting pauses. */
if (info_verbose)
{
printf_filtered ("Reading in symbols for %s...", pst->filename);
xcoff_new_init (objfile)
struct objfile *objfile;
{
+ stabsread_new_init ();
+ buildsym_new_init ();
}
/* Do initialization in preparation for reading symbols from OBJFILE.
-
+
We will only be called if this is an XCOFF or XCOFF-like file.
BFD handles figuring out the format of the file, and code in symfile.c
uses BFD's determination to vector to us. */
struct objfile *objfile;
{
/* Allocate struct to keep track of the symfile */
- objfile -> sym_private = xmmalloc (objfile -> md,
- sizeof (struct coff_symfile_info));
+ objfile->sym_private = xmmalloc (objfile->md,
+ sizeof (struct coff_symfile_info));
+
+ /* XCOFF objects may be reordered, so set OBJF_REORDERED. If we
+ find this causes a significant slowdown in gdb then we could
+ set it in the debug symbol readers only when necessary. */
+ objfile->flags |= OBJF_REORDERED;
+
init_entry_point_info (objfile);
}
xcoff_symfile_finish (objfile)
struct objfile *objfile;
{
- if (objfile -> sym_private != NULL)
+ if (objfile->sym_private != NULL)
{
- mfree (objfile -> md, objfile -> sym_private);
+ mfree (objfile->md, objfile->sym_private);
}
/* Start with a fresh include table for the next objfile. */
unsigned char lengthbuf[4];
char *strtbl;
- ((struct coff_symfile_info *)objfile->sym_private)->strtbl = NULL;
+ ((struct coff_symfile_info *) objfile->sym_private)->strtbl = NULL;
- if (bfd_seek (abfd, offset, L_SET) < 0)
+ if (bfd_seek (abfd, offset, SEEK_SET) < 0)
error ("cannot seek to string table in %s: %s",
bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
- val = bfd_read ((char *)lengthbuf, 1, sizeof lengthbuf, abfd);
+ val = bfd_read ((char *) lengthbuf, 1, sizeof lengthbuf, abfd);
length = bfd_h_get_32 (abfd, lengthbuf);
/* If no string table is needed, then the file may end immediately
as long as we have its symbol table around. */
strtbl = (char *) obstack_alloc (&objfile->symbol_obstack, length);
- ((struct coff_symfile_info *)objfile->sym_private)->strtbl = strtbl;
+ ((struct coff_symfile_info *) objfile->sym_private)->strtbl = strtbl;
+ /* Copy length buffer, the first byte is usually zero and is
+ used for stabs with a name length of zero. */
+ memcpy (strtbl, lengthbuf, sizeof lengthbuf);
if (length == sizeof lengthbuf)
return;
static unsigned int first_fun_line_offset;
static struct partial_symtab *xcoff_start_psymtab
- PARAMS ((struct objfile *, struct section_offsets *, char *, int,
- struct partial_symbol *, struct partial_symbol *));
+ PARAMS ((struct objfile *, char *, int,
+ struct partial_symbol **, struct partial_symbol **));
/* Allocate and partially fill a partial symtab. It will be
completely filled at the end of the symbol list.
(normal). */
static struct partial_symtab *
-xcoff_start_psymtab (objfile, section_offsets,
- filename, first_symnum, global_syms, static_syms)
+xcoff_start_psymtab (objfile, filename, first_symnum, global_syms,
+ static_syms)
struct objfile *objfile;
- struct section_offsets *section_offsets;
char *filename;
int first_symnum;
- struct partial_symbol *global_syms;
- struct partial_symbol *static_syms;
+ struct partial_symbol **global_syms;
+ struct partial_symbol **static_syms;
{
struct partial_symtab *result =
- start_psymtab_common (objfile, section_offsets,
- filename,
- /* We fill in textlow later. */
- 0,
- global_syms, static_syms);
+ start_psymtab_common (objfile, objfile->section_offsets,
+ filename,
+ /* We fill in textlow later. */
+ 0,
+ global_syms, static_syms);
result->read_symtab_private = (char *)
- obstack_alloc (&objfile -> psymbol_obstack, sizeof (struct symloc));
- ((struct symloc *)result->read_symtab_private)->first_symnum = first_symnum;
+ obstack_alloc (&objfile->psymbol_obstack, sizeof (struct symloc));
+ ((struct symloc *) result->read_symtab_private)->first_symnum = first_symnum;
result->read_symtab = xcoff_psymtab_to_symtab;
/* Deduce the source language from the filename for this psymtab. */
static struct partial_symtab *xcoff_end_psymtab
PARAMS ((struct partial_symtab *, char **, int, int,
- struct partial_symtab **, int));
+ struct partial_symtab **, int, int));
/* Close off the current usage of PST.
Returns PST, or NULL if the partial symtab was empty and thrown away.
static struct partial_symtab *
xcoff_end_psymtab (pst, include_list, num_includes, capping_symbol_number,
- dependency_list, number_dependencies)
+ dependency_list, number_dependencies, textlow_not_set)
struct partial_symtab *pst;
char **include_list;
int num_includes;
int capping_symbol_number;
struct partial_symtab **dependency_list;
int number_dependencies;
+ int textlow_not_set;
{
int i;
- struct objfile *objfile = pst -> objfile;
+ struct objfile *objfile = pst->objfile;
if (capping_symbol_number != -1)
- ((struct symloc *)pst->read_symtab_private)->numsyms =
+ ((struct symloc *) pst->read_symtab_private)->numsyms =
capping_symbol_number
- - ((struct symloc *)pst->read_symtab_private)->first_symnum;
- ((struct symloc *)pst->read_symtab_private)->lineno_off =
+ - ((struct symloc *) pst->read_symtab_private)->first_symnum;
+ ((struct symloc *) pst->read_symtab_private)->lineno_off =
first_fun_line_offset;
first_fun_line_offset = 0;
pst->n_global_syms =
{
pst->dependencies = (struct partial_symtab **)
obstack_alloc (&objfile->psymbol_obstack,
- number_dependencies * sizeof (struct partial_symtab *));
+ number_dependencies * sizeof (struct partial_symtab *));
memcpy (pst->dependencies, dependency_list,
- number_dependencies * sizeof (struct partial_symtab *));
+ number_dependencies * sizeof (struct partial_symtab *));
}
else
pst->dependencies = 0;
for (i = 0; i < num_includes; i++)
{
struct partial_symtab *subpst =
- allocate_psymtab (include_list[i], objfile);
+ allocate_psymtab (include_list[i], objfile);
subpst->section_offsets = pst->section_offsets;
subpst->read_symtab_private =
- (char *) obstack_alloc (&objfile->psymbol_obstack,
- sizeof (struct symloc));
- ((struct symloc *)subpst->read_symtab_private)->first_symnum = 0;
- ((struct symloc *)subpst->read_symtab_private)->numsyms = 0;
+ (char *) obstack_alloc (&objfile->psymbol_obstack,
+ sizeof (struct symloc));
+ ((struct symloc *) subpst->read_symtab_private)->first_symnum = 0;
+ ((struct symloc *) subpst->read_symtab_private)->numsyms = 0;
subpst->textlow = 0;
subpst->texthigh = 0;
/* We could save slight bits of space by only making one of these,
- shared by the entire set of include files. FIXME-someday. */
+ shared by the entire set of include files. FIXME-someday. */
subpst->dependencies = (struct partial_symtab **)
obstack_alloc (&objfile->psymbol_obstack,
sizeof (struct partial_symtab *));
subpst->globals_offset =
subpst->n_global_syms =
- subpst->statics_offset =
- subpst->n_static_syms = 0;
+ subpst->statics_offset =
+ subpst->n_static_syms = 0;
subpst->readin = 0;
subpst->symtab = 0;
&& pst->n_static_syms == 0)
{
/* Throw away this psymtab, it's empty. We can't deallocate it, since
- it is on the obstack, but we can forget to chain it on the list. */
+ it is on the obstack, but we can forget to chain it on the list. */
/* Empty psymtabs happen as a result of header files which don't have
- any symbols in them. There can be a lot of them. But this check
- is wrong, in that a psymtab with N_SLINE entries but nothing else
- is not empty, but we don't realize that. Fixing that without slowing
- things down might be tricky. (FIXME: For XCOFF, it shouldn't be
- tricky at all). */
- struct partial_symtab *prev_pst;
+ any symbols in them. There can be a lot of them. */
- /* First, snip it out of the psymtab chain */
-
- if (pst->objfile->psymtabs == pst)
- pst->objfile->psymtabs = pst->next;
- else
- for (prev_pst = pst->objfile->psymtabs; prev_pst; prev_pst = pst->next)
- if (prev_pst->next == pst)
- prev_pst->next = pst->next;
-
- /* Next, put it on a free list for recycling */
-
- pst->next = pst->objfile->free_psymtabs;
- pst->objfile->free_psymtabs = pst;
+ discard_psymtab (pst);
/* Indicate that psymtab was thrown away. */
- pst = (struct partial_symtab *)NULL;
+ pst = (struct partial_symtab *) NULL;
}
return pst;
}
if (symbol->n_zeroes)
{
/* If it's exactly E_SYMNMLEN characters long it isn't
- '\0'-terminated. */
+ '\0'-terminated. */
if (symbol->n_name[E_SYMNMLEN - 1] != '\0')
{
/* FIXME: wastes memory for symbols which we don't end up putting
else
/* Point to the unswapped name as that persists as long as the
objfile does. */
- *name = ((struct external_syment *)*raw)->e.e_name;
+ *name = ((struct external_syment *) *raw)->e.e_name;
}
else if (symbol->n_sclass & 0x80)
{
- *name = ((struct coff_symfile_info *)objfile->sym_private)->debugsec
+ *name = ((struct coff_symfile_info *) objfile->sym_private)->debugsec
+ symbol->n_offset;
}
else
{
- *name = ((struct coff_symfile_info *)objfile->sym_private)->strtbl
+ *name = ((struct coff_symfile_info *) objfile->sym_private)->strtbl
+ symbol->n_offset;
}
++*symnump;
}
static void
-scan_xcoff_symtab (section_offsets, objfile)
- struct section_offsets *section_offsets;
+scan_xcoff_symtab (objfile)
struct objfile *objfile;
{
- int toc_offset = 0; /* toc offset value in data section. */
- char *filestring;
+ CORE_ADDR toc_offset = 0; /* toc offset value in data section. */
+ char *filestring = NULL;
char *namestring;
- int nsl;
int past_first_source_file = 0;
- CORE_ADDR last_o_file_start = 0;
- struct cleanup *back_to;
bfd *abfd;
+ asection *bfd_sect;
unsigned int nsyms;
/* Current partial symtab */
char *sraw_symbol;
struct internal_syment symbol;
- union internal_auxent main_aux;
+ union internal_auxent main_aux[5];
unsigned int ssymnum;
- char *last_csect_name = NULL; /* last seen csect's name and value */
- CORE_ADDR last_csect_val;
- int last_csect_sec;
- int misc_func_recorded; /* true if any misc. function */
+ char *last_csect_name = NULL; /* last seen csect's name and value */
+ CORE_ADDR last_csect_val = 0;
+ int last_csect_sec = 0;
+ int misc_func_recorded = 0; /* true if any misc. function */
+ int textlow_not_set = 1;
pst = (struct partial_symtab *) 0;
abfd = objfile->obfd;
- sraw_symbol = ((struct coff_symfile_info *)objfile->sym_private)->symtbl;
- nsyms = ((struct coff_symfile_info *)objfile->sym_private)->symtbl_num_syms;
+ sraw_symbol = ((struct coff_symfile_info *) objfile->sym_private)->symtbl;
+ nsyms = ((struct coff_symfile_info *) objfile->sym_private)->symtbl_num_syms;
ssymnum = 0;
while (ssymnum < nsyms)
{
- int sclass = ((struct external_syment *)sraw_symbol)->e_sclass[0];
+ int sclass = ((struct external_syment *) sraw_symbol)->e_sclass[0] & 0xff;
/* This is the type we pass to partial-stab.h. A less kludgy solution
- would be to break out partial-stab.h into its various parts--shuffle
- off the DBXREAD_ONLY stuff to dbxread.c, and make separate
- pstab-norm.h (for most types), pstab-sol.h (for N_SOL), etc. */
+ would be to break out partial-stab.h into its various parts--shuffle
+ off the DBXREAD_ONLY stuff to dbxread.c, and make separate
+ pstab-norm.h (for most types), pstab-sol.h (for N_SOL), etc. */
int stype;
QUIT;
union internal_auxent csect_aux;
unsigned int symnum_before = ssymnum;
- swap_sym (&symbol, &main_aux, &namestring, &sraw_symbol,
+ swap_sym (&symbol, &main_aux[0], &namestring, &sraw_symbol,
&ssymnum, objfile);
if (symbol.n_numaux > 1)
{
bfd_coff_swap_aux_in
(objfile->obfd,
- sraw_symbol - coff_data(abfd)->local_symesz,
+ sraw_symbol - coff_data (abfd)->local_symesz,
symbol.n_type,
symbol.n_sclass,
symbol.n_numaux - 1,
&csect_aux);
}
else
- csect_aux = main_aux;
+ csect_aux = main_aux[0];
+
+ /* If symbol name starts with ".$" or "$", ignore it. */
+ if (namestring[0] == '$'
+ || (namestring[0] == '.' && namestring[1] == '$'))
+ break;
switch (csect_aux.x_csect.x_smtyp & 0x7)
{
each program csect, because their text
sections need not be adjacent. */
xcoff_end_psymtab
- (pst, psymtab_include_list,
- includes_used,
- symnum_before,
- dependency_list, dependencies_used);
+ (pst, psymtab_include_list, includes_used,
+ symnum_before, dependency_list,
+ dependencies_used, textlow_not_set);
includes_used = 0;
dependencies_used = 0;
/* Give all psymtabs for this source file the same
name. */
pst = xcoff_start_psymtab
- (objfile, section_offsets,
+ (objfile,
filestring,
symnum_before,
objfile->global_psymbols.next,
if (pst != NULL)
{
CORE_ADDR highval =
- symbol.n_value + csect_aux.x_csect.x_scnlen.l;
+ symbol.n_value + csect_aux.x_csect.x_scnlen.l;
if (highval > pst->texthigh)
pst->texthigh = highval;
if (pst->textlow == 0 || symbol.n_value < pst->textlow)
}
misc_func_recorded = 0;
break;
+
case XMC_RW:
+ /* Data variables are recorded in the minimal symbol
+ table, except for section symbols. */
+ if (*namestring != '.')
+ prim_record_minimal_symbol_and_info
+ (namestring, symbol.n_value,
+ sclass == C_HIDEXT ? mst_file_data : mst_data,
+ NULL, secnum_to_section (symbol.n_scnum, objfile),
+ NULL, objfile);
break;
+
case XMC_TC0:
if (toc_offset)
warning ("More than one XMC_TC0 symbol found.");
toc_offset = symbol.n_value;
+
+ /* Make TOC offset relative to start address of section. */
+ bfd_sect = secnum_to_bfd_section (symbol.n_scnum, objfile);
+ if (bfd_sect)
+ toc_offset -= bfd_section_vma (objfile->obfd, bfd_sect);
break;
+
case XMC_TC:
/* These symbols tell us where the TOC entry for a
variable is, not the variable itself. */
break;
+
default:
break;
}
switch (csect_aux.x_csect.x_smclas)
{
case XMC_PR:
- {
- /* A function entry point. */
- char *namestr = namestring;
-
- if (first_fun_line_offset == 0)
- first_fun_line_offset =
- main_aux.x_sym.x_fcnary.x_fcn.x_lnnoptr;
- if (namestr[0] == '.')
- ++namestr;
- prim_record_minimal_symbol_and_info
- (namestr, symbol.n_value, mst_text,
- NULL, secnum_to_section (symbol.n_scnum, objfile),
- objfile);
- misc_func_recorded = 1;
-
- /* We also create full symbols for these, so
- better make a partial symbol. This seems bogus
- to me, but I'm not going to try to fix it now.
- (Note that allocate_space_in_inferior can't
- yet deal with a minimal symbol for malloc on xcoff
- because it doesn't understand the fact that
- function pointers don't just contain the address of
- the function). */
- ADD_PSYMBOL_ADDR_TO_LIST (namestr, strlen (namestr),
- VAR_NAMESPACE, LOC_BLOCK,
- objfile->global_psymbols,
- symbol.n_value,
- psymtab_language, objfile);
- }
+ /* A function entry point. */
+
+ if (first_fun_line_offset == 0 && symbol.n_numaux > 1)
+ first_fun_line_offset =
+ main_aux[0].x_sym.x_fcnary.x_fcn.x_lnnoptr;
+ RECORD_MINIMAL_SYMBOL
+ (namestring, symbol.n_value,
+ sclass == C_HIDEXT ? mst_file_text : mst_text,
+ secnum_to_section (symbol.n_scnum, objfile),
+ objfile);
break;
+
case XMC_GL:
/* shared library function trampoline code entry
point. */
still need to record them. This will
typically be XMC_RW; I suspect XMC_RO and
XMC_BS might be possible too. */
+ if (*namestring != '.')
+ prim_record_minimal_symbol_and_info
+ (namestring, symbol.n_value,
+ sclass == C_HIDEXT ? mst_file_data : mst_data,
+ NULL, secnum_to_section (symbol.n_scnum, objfile),
+ NULL, objfile);
+ break;
+ }
+ break;
- /* FIXME: Shouldn't these be going into the minimal
- symbols instead of partial/full symbols? */
-
- ADD_PSYMBOL_ADDR_TO_LIST (namestring, strlen (namestring),
- VAR_NAMESPACE, LOC_STATIC,
- objfile->global_psymbols,
- symbol.n_value,
- psymtab_language, objfile);
+ case XTY_CM:
+ switch (csect_aux.x_csect.x_smclas)
+ {
+ case XMC_RW:
+ case XMC_BS:
+ /* Common variables are recorded in the minimal symbol
+ table, except for section symbols. */
+ if (*namestring != '.')
+ prim_record_minimal_symbol_and_info
+ (namestring, symbol.n_value,
+ sclass == C_HIDEXT ? mst_file_bss : mst_bss,
+ NULL, secnum_to_section (symbol.n_scnum, objfile),
+ NULL, objfile);
break;
}
+ break;
+
default:
break;
}
unsigned int symnum_before;
symnum_before = ssymnum;
- swap_sym (&symbol, &main_aux, &namestring, &sraw_symbol,
+ swap_sym (&symbol, &main_aux[0], &namestring, &sraw_symbol,
&ssymnum, objfile);
/* See if the last csect needs to be recorded. */
if (pst)
{
xcoff_end_psymtab (pst, psymtab_include_list, includes_used,
- symnum_before,
- dependency_list, dependencies_used);
+ symnum_before, dependency_list,
+ dependencies_used, textlow_not_set);
includes_used = 0;
dependencies_used = 0;
}
exists, otherwise use the symbol itself. */
if (!strcmp (namestring, ".file") && symbol.n_numaux > 0)
{
- filestring = coff_getfilename (&main_aux, objfile);
+ filestring = coff_getfilename (&main_aux[0], objfile);
}
else
filestring = namestring;
- pst = xcoff_start_psymtab (objfile, section_offsets,
+ pst = xcoff_start_psymtab (objfile,
filestring,
symnum_before,
objfile->global_psymbols.next,
default:
{
static struct complaint msg =
- {"Storage class %d not recognized during scan", 0, 0};
+ {"Storage class %d not recognized during scan", 0, 0};
complain (&msg, sclass);
}
/* FALLTHROUGH */
/* We probably could save a few instructions by assuming that
C_LSYM, C_PSYM, etc., never have auxents. */
int naux1 =
- ((struct external_syment *)sraw_symbol)->e_numaux[0] + 1;
+ ((struct external_syment *) sraw_symbol)->e_numaux[0] + 1;
ssymnum += naux1;
sraw_symbol += sizeof (struct external_syment) * naux1;
}
case C_STSYM:
stype = N_LSYM;
pstab:;
- swap_sym (&symbol, &main_aux, &namestring, &sraw_symbol,
+ swap_sym (&symbol, &main_aux[0], &namestring, &sraw_symbol,
&ssymnum, objfile);
#define CUR_SYMBOL_TYPE stype
#define CUR_SYMBOL_VALUE symbol.n_value
/* START_PSYMTAB and END_PSYMTAB are never used, because they are only
called from DBXREAD_ONLY or N_SO code. Likewise for the symnum
variable. */
-#define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms) 0
-#define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
+#define START_PSYMTAB(ofile,fname,low,symoff,global_syms,static_syms) 0
+#define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)\
do {} while (0)
/* We have already set the namestring. */
-#define SET_NAMESTRING() 0
+#define SET_NAMESTRING() /* */
#include "partial-stab.h"
}
}
-#if 0
- /* What is this? */
- /* If there's stuff to be cleaned up, clean it up. */
- if (DBX_SYMCOUNT (objfile) > 0 /* We have some syms */
-/*FIXME, does this have a bug at start address 0? */
- && last_o_file_start
- && objfile -> ei.entry_point < bufp->n_value
- && objfile -> ei.entry_point >= last_o_file_start)
- {
- objfile -> ei.entry_file_lowpc = last_o_file_start;
- objfile -> ei.entry_file_highpc = bufp->n_value;
- }
-#endif
if (pst)
{
xcoff_end_psymtab (pst, psymtab_include_list, includes_used,
- ssymnum,
- dependency_list, dependencies_used);
+ ssymnum, dependency_list,
+ dependencies_used, textlow_not_set);
}
- /* Record the toc offset value of this symbol table into ldinfo structure.
+ /* Record the toc offset value of this symbol table into objfile structure.
If no XMC_TC0 is found, toc_offset should be zero. Another place to obtain
this information would be file auxiliary header. */
-#ifndef FAKING_RS6000
- xcoff_add_toc_to_loadinfo (toc_offset);
-#endif
+ ((struct coff_symfile_info *) objfile->sym_private)->toc_offset = toc_offset;
+}
+
+/* Return the toc offset value for a given objfile. */
+
+CORE_ADDR
+get_toc_offset (objfile)
+ struct objfile *objfile;
+{
+ if (objfile)
+ return ((struct coff_symfile_info *) objfile->sym_private)->toc_offset;
+ return 0;
}
/* Scan and build partial symbols for a symbol file.
table (as opposed to a shared lib or dynamically loaded file). */
static void
-xcoff_initial_scan (objfile, section_offsets, mainline)
+xcoff_initial_scan (objfile, mainline)
struct objfile *objfile;
- struct section_offsets *section_offsets;
- int mainline; /* FIXME comments above */
+ int mainline; /* FIXME comments above */
{
bfd *abfd;
int val;
struct cleanup *back_to;
- int num_symbols; /* # of symbols */
- file_ptr symtab_offset; /* symbol table and */
- file_ptr stringtab_offset; /* string table file offsets */
+ int num_symbols; /* # of symbols */
+ file_ptr symtab_offset; /* symbol table and */
+ file_ptr stringtab_offset; /* string table file offsets */
struct coff_symfile_info *info;
char *name;
unsigned int size;
-#ifndef FAKING_RS6000
- /* Initialize load info structure. */
- if (mainline)
- xcoff_init_loadinfo ();
-#endif
-
- info = (struct coff_symfile_info *) objfile -> sym_private;
+ info = (struct coff_symfile_info *) objfile->sym_private;
symfile_bfd = abfd = objfile->obfd;
name = objfile->name;
num_symbols = bfd_get_symcount (abfd); /* # of symbols */
symtab_offset = obj_sym_filepos (abfd); /* symbol table file offset */
stringtab_offset = symtab_offset +
- num_symbols * coff_data(abfd)->local_symesz;
+ num_symbols * coff_data (abfd)->local_symesz;
info->min_lineno_offset = 0;
info->max_lineno_offset = 0;
}
}
}
- ((struct coff_symfile_info *)objfile->sym_private)->debugsec =
+ ((struct coff_symfile_info *) objfile->sym_private)->debugsec =
debugsec;
}
}
/* Read the symbols. We keep them in core because we will want to
access them randomly in read_symbol*. */
- val = bfd_seek (abfd, symtab_offset, L_SET);
+ val = bfd_seek (abfd, symtab_offset, SEEK_SET);
if (val < 0)
error ("Error reading symbols from %s: %s",
name, bfd_errmsg (bfd_get_error ()));
size = coff_data (abfd)->local_symesz * num_symbols;
- ((struct coff_symfile_info *)objfile->sym_private)->symtbl =
+ ((struct coff_symfile_info *) objfile->sym_private)->symtbl =
obstack_alloc (&objfile->symbol_obstack, size);
- ((struct coff_symfile_info *)objfile->sym_private)->symtbl_num_syms =
+ ((struct coff_symfile_info *) objfile->sym_private)->symtbl_num_syms =
num_symbols;
- val = bfd_read (((struct coff_symfile_info *)objfile->sym_private)->symtbl,
+ val = bfd_read (((struct coff_symfile_info *) objfile->sym_private)->symtbl,
size, 1, abfd);
if (val != size)
perror_with_name ("reading symbol table");
include N_SLINE. */
init_psymbol_list (objfile, num_symbols);
- pending_blocks = 0;
+ free_pending_blocks ();
back_to = make_cleanup (really_free_pendings, 0);
init_minimal_symbol_collection ();
- make_cleanup (discard_minimal_symbols, 0);
+ make_cleanup ((make_cleanup_func) discard_minimal_symbols, 0);
/* Now that the symbol table data of the executable file are all in core,
process them and define symbols accordingly. */
- scan_xcoff_symtab (section_offsets, objfile);
+ scan_xcoff_symtab (objfile);
/* Install any minimal symbols that have been collected as the current
minimal symbols for this objfile. */
do_cleanups (back_to);
}
\f
-static struct section_offsets *
-xcoff_symfile_offsets (objfile, addr)
+static void
+xcoff_symfile_offsets (objfile, addrs)
struct objfile *objfile;
- CORE_ADDR addr;
+ struct section_addr_info *addrs;
{
- struct section_offsets *section_offsets;
int i;
objfile->num_sections = SECT_OFF_MAX;
- section_offsets = (struct section_offsets *)
- obstack_alloc
- (&objfile -> psymbol_obstack,
- sizeof (struct section_offsets)
- + sizeof (section_offsets->offsets) * objfile->num_sections);
+ objfile->section_offsets = (struct section_offsets *)
+ obstack_alloc (&objfile->psymbol_obstack, SIZEOF_SECTION_OFFSETS);
/* syms_from_objfile kindly subtracts from addr the bfd_section_vma
of the .text section. This strikes me as wrong--whether the
parameter and use 0. rs6000-nat.c will set the correct section
offsets via objfile_relocate. */
for (i = 0; i < objfile->num_sections; ++i)
- ANOFFSET (section_offsets, i) = addr;
-
- return section_offsets;
+ ANOFFSET (objfile->section_offsets, i) = 0;
}
/* Register our ability to parse symbols for xcoff BFD files. */
xcoffread.c reads all the symbols and does in fact randomly access them
(in C_BSTAT and line number processing). */
- (enum bfd_flavour)-1,
+ (enum bfd_flavour) -1,
- xcoff_new_init, /* sym_new_init: init anything gbl to entire symtab */
- xcoff_symfile_init, /* sym_init: read initial info, setup for sym_read() */
- xcoff_initial_scan, /* sym_read: read a symbol file into symtab */
- xcoff_symfile_finish, /* sym_finish: finished with file, cleanup */
- xcoff_symfile_offsets, /* sym_offsets: xlate offsets ext->int form */
- NULL /* next: pointer to next struct sym_fns */
+ xcoff_new_init, /* sym_new_init: init anything gbl to entire symtab */
+ xcoff_symfile_init, /* sym_init: read initial info, setup for sym_read() */
+ xcoff_initial_scan, /* sym_read: read a symbol file into symtab */
+ xcoff_symfile_finish, /* sym_finish: finished with file, cleanup */
+ xcoff_symfile_offsets, /* sym_offsets: xlate offsets ext->int form */
+ NULL /* next: pointer to next struct sym_fns */
};
void
_initialize_xcoffread ()
{
- add_symtab_fns(&xcoff_sym_fns);
-
- /* Initialize symbol template later used for arguments. Its other
- fields are zero, or are filled in later. */
- SYMBOL_NAME (&parmsym) = "";
- SYMBOL_INIT_LANGUAGE_SPECIFIC (&parmsym, language_c);
- SYMBOL_NAMESPACE (&parmsym) = VAR_NAMESPACE;
- SYMBOL_CLASS (&parmsym) = LOC_ARG;
+ add_symtab_fns (&xcoff_sym_fns);
func_symbol_type = init_type (TYPE_CODE_FUNC, 1, 0,
"<function, no debug info>", NULL);