summaryrefslogtreecommitdiff
path: root/gdb/coffread.c
diff options
context:
space:
mode:
Diffstat (limited to 'gdb/coffread.c')
-rw-r--r--gdb/coffread.c1490
1 files changed, 750 insertions, 740 deletions
diff --git a/gdb/coffread.c b/gdb/coffread.c
index 1a63cfb7552..1a923ebff66 100644
--- a/gdb/coffread.c
+++ b/gdb/coffread.c
@@ -1,23 +1,24 @@
/* Read coff symbol tables and convert to internal format, for GDB.
Copyright 1987, 88, 89, 90, 91, 92, 93, 94, 96, 97, 1998
- Free Software Foundation, Inc.
+ Free Software Foundation, Inc.
Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu).
-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. */
+ 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 "symtab.h"
@@ -44,16 +45,17 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
extern void _initialize_coffread PARAMS ((void));
-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 */
- CORE_ADDR textaddr; /* Addr of .text section. */
- unsigned int textsize; /* Size of .text section. */
- struct stab_section_list *stabsects; /* .stab sections. */
- asection *stabstrsect; /* Section pointer for .stab section */
- char *stabstrdata;
-};
+ CORE_ADDR textaddr; /* Addr of .text section. */
+ unsigned int textsize; /* Size of .text section. */
+ struct stab_section_list *stabsects; /* .stab sections. */
+ asection *stabstrsect; /* Section pointer for .stab section */
+ char *stabstrdata;
+ };
/* Translate an external name string into a user-visible name. */
#define EXTERNAL_NAME(string, abfd) \
@@ -71,7 +73,7 @@ struct coff_symfile_info {
to map one to one onto the sdb register numbers. */
#ifndef SDB_REG_TO_REGNUM
-# define SDB_REG_TO_REGNUM(value) (value)
+#define SDB_REG_TO_REGNUM(value) (value)
#endif
/* Core address of start and end of text of current source file.
@@ -98,24 +100,24 @@ static char *temp_aux;
internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF
macros from include/coff/internal.h . */
-static unsigned local_n_btmask;
-static unsigned local_n_btshft;
-static unsigned local_n_tmask;
-static unsigned local_n_tshift;
+static unsigned local_n_btmask;
+static unsigned local_n_btshft;
+static unsigned local_n_tmask;
+static unsigned local_n_tshift;
#define N_BTMASK local_n_btmask
#define N_BTSHFT local_n_btshft
#define N_TMASK local_n_tmask
#define N_TSHIFT local_n_tshift
-
+
/* Local variables that hold the sizes in the file of various COFF structures.
(We only need to know this to read them from the file -- BFD will then
translate the data in them, into `internal_xxx' structs in the right
byte order, alignment, etc.) */
-static unsigned local_linesz;
-static unsigned local_symesz;
-static unsigned local_auxesz;
+static unsigned local_linesz;
+static unsigned local_symesz;
+static unsigned local_auxesz;
/* This is set if this is a PE format file. */
@@ -128,50 +130,51 @@ static struct symbol *opaque_type_chain[HASHSIZE];
/* Complaints about various problems in the file being read */
-struct complaint ef_complaint =
- {"Unmatched .ef symbol(s) ignored starting at symnum %d", 0, 0};
+struct complaint ef_complaint =
+{"Unmatched .ef symbol(s) ignored starting at symnum %d", 0, 0};
-struct complaint ef_stack_complaint =
- {"`.ef' symbol without matching `.bf' symbol ignored starting at symnum %d", 0, 0};
+struct complaint ef_stack_complaint =
+{"`.ef' symbol without matching `.bf' symbol ignored starting at symnum %d", 0, 0};
-struct complaint eb_stack_complaint =
- {"`.eb' symbol without matching `.bb' symbol ignored starting at symnum %d", 0, 0};
+struct complaint eb_stack_complaint =
+{"`.eb' symbol without matching `.bb' symbol ignored starting at symnum %d", 0, 0};
struct complaint bf_no_aux_complaint =
- {"`.bf' symbol %d has no aux entry", 0, 0};
+{"`.bf' symbol %d has no aux entry", 0, 0};
struct complaint ef_no_aux_complaint =
- {"`.ef' symbol %d has no aux entry", 0, 0};
+{"`.ef' symbol %d has no aux entry", 0, 0};
struct complaint lineno_complaint =
- {"Line number pointer %d lower than start of line numbers", 0, 0};
+{"Line number pointer %d lower than start of line numbers", 0, 0};
struct complaint unexpected_type_complaint =
- {"Unexpected type for symbol %s", 0, 0};
+{"Unexpected type for symbol %s", 0, 0};
struct complaint bad_sclass_complaint =
- {"Bad n_sclass for symbol %s", 0, 0};
+{"Bad n_sclass for symbol %s", 0, 0};
struct complaint misordered_blocks_complaint =
- {"Blocks out of order at address %x", 0, 0};
+{"Blocks out of order at address %x", 0, 0};
struct complaint tagndx_bad_complaint =
- {"Symbol table entry for %s has bad tagndx value", 0, 0};
+{"Symbol table entry for %s has bad tagndx value", 0, 0};
-struct complaint eb_complaint =
- {"Mismatched .eb symbol ignored starting at symnum %d", 0, 0};
+struct complaint eb_complaint =
+{"Mismatched .eb symbol ignored starting at symnum %d", 0, 0};
/* 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, etc */
- long c_value;
- int c_sclass;
- int c_secnum;
- unsigned int c_type;
-};
+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, etc */
+ long c_value;
+ int c_sclass;
+ int c_secnum;
+ unsigned int c_type;
+ };
static struct type *coff_read_struct_type PARAMS ((int, int, int));
@@ -286,7 +289,7 @@ coff_locate_sections (abfd, sectp, csip)
/* We can have multiple .stab sections if linked with
--split-by-reloc. */
for (s = name + sizeof ".stab" - 1; *s != '\0'; s++)
- if (! isdigit (*s))
+ if (!isdigit (*s))
break;
if (*s == '\0')
{
@@ -301,8 +304,8 @@ coff_locate_sections (abfd, sectp, csip)
*pn = n;
/* This will be run after coffstab_build_psymtabs is called
- in coff_symfile_read, at which point we no longer need
- the information. */
+ in coff_symfile_read, at which point we no longer need
+ the information. */
make_cleanup (free, n);
}
}
@@ -311,19 +314,21 @@ coff_locate_sections (abfd, sectp, csip)
/* Return the section_offsets* that CS points to. */
static int cs_to_section PARAMS ((struct coff_symbol *, struct objfile *));
-struct find_targ_sec_arg {
- int targ_index;
- asection **resultp;
-};
+struct find_targ_sec_arg
+ {
+ int targ_index;
+ asection **resultp;
+ };
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)
*args->resultp = sect;
}
@@ -391,14 +396,14 @@ coff_lookup_type (index)
int old_vector_length = type_vector_length;
type_vector_length *= 2;
- if (index /* is still */ >= type_vector_length)
+ if (index /* is still */ >= type_vector_length)
type_vector_length = index * 2;
type_vector = (struct type **)
xrealloc ((char *) type_vector,
type_vector_length * sizeof (struct type *));
memset (&type_vector[old_vector_length], 0,
- (type_vector_length - old_vector_length) * sizeof(struct type *));
+ (type_vector_length - old_vector_length) * sizeof (struct type *));
}
return &type_vector[index];
}
@@ -431,19 +436,19 @@ coff_alloc_type (index)
static void
coff_start_symtab (name)
- char *name;
+ char *name;
{
start_symtab (
- /* We fill in the filename later. start_symtab puts
- this pointer into last_source_file and we put it in
- subfiles->name, which end_symtab frees; that's why
- it must be malloc'd. */
- savestring (name, strlen(name)),
- /* We never know the directory name for COFF. */
- NULL,
- /* The start address is irrelevant, since we set
- last_source_start_addr in coff_end_symtab. */
- 0);
+ /* We fill in the filename later. start_symtab puts
+ this pointer into last_source_file and we put it in
+ subfiles->name, which end_symtab frees; that's why
+ it must be malloc'd. */
+ savestring (name, strlen (name)),
+ /* We never know the directory name for COFF. */
+ NULL,
+ /* The start address is irrelevant, since we set
+ last_source_start_addr in coff_end_symtab. */
+ 0);
record_debugformat ("COFF");
}
@@ -454,9 +459,9 @@ coff_start_symtab (name)
static void
complete_symtab (name, start_addr, size)
- char *name;
- CORE_ADDR start_addr;
- unsigned int size;
+ char *name;
+ CORE_ADDR start_addr;
+ unsigned int size;
{
if (last_source_file != NULL)
free (last_source_file);
@@ -464,11 +469,11 @@ complete_symtab (name, start_addr, size)
current_source_start_addr = start_addr;
current_source_end_addr = start_addr + size;
- if (current_objfile -> ei.entry_point >= current_source_start_addr &&
- current_objfile -> ei.entry_point < current_source_end_addr)
+ if (current_objfile->ei.entry_point >= current_source_start_addr &&
+ current_objfile->ei.entry_point < current_source_end_addr)
{
- current_objfile -> ei.entry_file_lowpc = current_source_start_addr;
- current_objfile -> ei.entry_file_highpc = current_source_end_addr;
+ current_objfile->ei.entry_file_lowpc = current_source_start_addr;
+ current_objfile->ei.entry_file_highpc = current_source_end_addr;
}
}
@@ -502,7 +507,8 @@ record_minimal_symbol (name, address, type, objfile)
struct objfile *objfile;
{
/* We don't want TDESC entry points in the minimal symbol table */
- if (name[0] == '@') return;
+ if (name[0] == '@')
+ return;
prim_record_minimal_symbol (name, address, type, objfile);
}
@@ -567,7 +573,7 @@ find_linenos (abfd, asect, vpinfo)
return;
size = count * local_linesz;
- info = (struct coff_symfile_info *)vpinfo;
+ info = (struct coff_symfile_info *) vpinfo;
/* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
offset = asect->line_filepos;
/* End of warning */
@@ -607,30 +613,30 @@ coff_symfile_read (objfile, section_offsets, mainline)
struct cleanup *back_to;
int stabstrsize;
- info = (struct coff_symfile_info *) objfile -> sym_private;
+ info = (struct coff_symfile_info *) objfile->sym_private;
dbxinfo = objfile->sym_stab_info;
- symfile_bfd = abfd; /* Kludge for swap routines */
+ symfile_bfd = abfd; /* Kludge for swap routines */
/* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
- num_symbols = bfd_get_symcount (abfd); /* How many syms */
- symtab_offset = cdata->sym_filepos; /* Symbol table file offset */
- stringtab_offset = symtab_offset + /* String table file offset */
- num_symbols * cdata->local_symesz;
+ num_symbols = bfd_get_symcount (abfd); /* How many syms */
+ symtab_offset = cdata->sym_filepos; /* Symbol table file offset */
+ stringtab_offset = symtab_offset + /* String table file offset */
+ num_symbols * cdata->local_symesz;
/* Set a few file-statics that give us specific information about
the particular COFF file format we're reading. */
local_n_btmask = cdata->local_n_btmask;
local_n_btshft = cdata->local_n_btshft;
- local_n_tmask = cdata->local_n_tmask;
+ local_n_tmask = cdata->local_n_tmask;
local_n_tshift = cdata->local_n_tshift;
- local_linesz = cdata->local_linesz;
- local_symesz = cdata->local_symesz;
- local_auxesz = cdata->local_auxesz;
+ local_linesz = cdata->local_linesz;
+ local_symesz = cdata->local_symesz;
+ local_auxesz = cdata->local_auxesz;
/* Allocate space for raw symbol and aux entries, based on their
space requirements as reported by BFD. */
temp_sym = (char *) xmalloc
- (cdata->local_symesz + cdata->local_auxesz);
+ (cdata->local_symesz + cdata->local_auxesz);
temp_aux = temp_sym + cdata->local_symesz;
back_to = make_cleanup ((make_cleanup_func) free_current_contents, &temp_sym);
@@ -649,7 +655,7 @@ coff_symfile_read (objfile, section_offsets, mainline)
bfd_map_over_sections (abfd, find_linenos, (PTR) info);
make_cleanup ((make_cleanup_func) free_linetab, 0);
- val = init_lineno (abfd, info->min_lineno_offset,
+ val = init_lineno (abfd, info->min_lineno_offset,
info->max_lineno_offset - info->min_lineno_offset);
if (val < 0)
error ("\"%s\": error reading line numbers\n", name);
@@ -675,7 +681,7 @@ coff_symfile_read (objfile, section_offsets, mainline)
{
struct symtab *s;
- for (s = objfile -> symtabs; s != NULL; s = s -> next)
+ for (s = objfile->symtabs; s != NULL; s = s->next)
sort_symtab_syms (s);
}
@@ -688,19 +694,19 @@ coff_symfile_read (objfile, section_offsets, mainline)
if (info->stabsects)
{
- if (! info->stabstrsect)
+ if (!info->stabstrsect)
{
error_begin ();
fprintf_filtered
(gdb_stderr,
("The debugging information in `%s' is corrupted.\n"
- "The file has a `.stabs' section, but no `.stabstr' section.\n"),
+ "The file has a `.stabs' section, but no `.stabstr' section.\n"),
name);
return_to_top_level (RETURN_ERROR);
}
/* FIXME: dubious. Why can't we use something normal like
- bfd_get_section_contents? */
+ bfd_get_section_contents? */
bfd_seek (abfd, abfd->where, 0);
stabstrsize = bfd_section_size (abfd, info->stabstrsect);
@@ -731,13 +737,13 @@ static void
coff_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);
}
}
-
+
/* Given pointers to a symbol table in coff style exec file,
analyze them and create struct symtab's describing the symbols.
NSYMS is the number of symbols in the symbol table.
@@ -800,7 +806,7 @@ coff_symtab_read (symtab_offset, nsyms, section_offsets, objfile)
last_source_file = NULL;
memset (opaque_type_chain, 0, sizeof opaque_type_chain);
- if (type_vector) /* Get rid of previous one */
+ if (type_vector) /* Get rid of previous one */
free ((PTR) type_vector);
type_vector_length = 160;
type_vector = (struct type **)
@@ -848,50 +854,51 @@ coff_symtab_read (symtab_offset, nsyms, section_offsets, objfile)
switch (cs->c_sclass)
{
- case C_EFCN:
- case C_EXTDEF:
- case C_ULABEL:
- case C_USTATIC:
- case C_LINE:
- case C_ALIAS:
- case C_HIDDEN:
- complain (&bad_sclass_complaint, cs->c_name);
- break;
-
- case C_FILE:
- /* c_value field contains symnum of next .file entry in table
- or symnum of first global after last .file. */
- next_file_symnum = cs->c_value;
- if (cs->c_naux > 0)
- filestring = coff_getfilename (&main_aux);
- else
- filestring = "";
+ case C_EFCN:
+ case C_EXTDEF:
+ case C_ULABEL:
+ case C_USTATIC:
+ case C_LINE:
+ case C_ALIAS:
+ case C_HIDDEN:
+ complain (&bad_sclass_complaint, cs->c_name);
+ break;
- /* Complete symbol table for last object file
- containing debugging information. */
- if (last_source_file)
- {
- coff_end_symtab (objfile);
- coff_start_symtab (filestring);
- }
- in_source_file = 1;
- break;
+ case C_FILE:
+ /* c_value field contains symnum of next .file entry in table
+ or symnum of first global after last .file. */
+ next_file_symnum = cs->c_value;
+ if (cs->c_naux > 0)
+ filestring = coff_getfilename (&main_aux);
+ else
+ filestring = "";
+
+ /* Complete symbol table for last object file
+ containing debugging information. */
+ if (last_source_file)
+ {
+ coff_end_symtab (objfile);
+ coff_start_symtab (filestring);
+ }
+ in_source_file = 1;
+ break;
/* C_LABEL is used for labels and static functions. Including
it here allows gdb to see static functions when no debug
info is available. */
- case C_LABEL:
- /* However, labels within a function can make weird backtraces,
- so filter them out (from phdm@macqel.be). */
- if (within_function)
- break;
- case C_STAT:
- case C_THUMBLABEL:
- case C_THUMBSTAT:
- case C_THUMBSTATFUNC:
- if (cs->c_name[0] == '.')
- {
- if (STREQ (cs->c_name, ".text")) {
+ case C_LABEL:
+ /* However, labels within a function can make weird backtraces,
+ so filter them out (from phdm@macqel.be). */
+ if (within_function)
+ break;
+ case C_STAT:
+ case C_THUMBLABEL:
+ case C_THUMBSTAT:
+ case C_THUMBSTATFUNC:
+ if (cs->c_name[0] == '.')
+ {
+ if (STREQ (cs->c_name, ".text"))
+ {
/* FIXME: don't wire in ".text" as section name
or symbol name! */
/* Check for in_source_file deals with case of
@@ -899,247 +906,247 @@ coff_symtab_read (symtab_offset, nsyms, section_offsets, objfile)
followed by a later file with no symbols. */
if (in_source_file)
complete_symtab (filestring,
- cs->c_value + ANOFFSET (section_offsets, SECT_OFF_TEXT),
+ cs->c_value + ANOFFSET (section_offsets, SECT_OFF_TEXT),
main_aux.x_scn.x_scnlen);
in_source_file = 0;
}
- /* flush rest of '.' symbols */
- break;
- }
- else if (!SDB_TYPE (cs->c_type)
- && cs->c_name[0] == 'L'
- && (strncmp (cs->c_name, "LI%", 3) == 0
- || strncmp (cs->c_name, "LF%", 3) == 0
- || strncmp (cs->c_name,"LC%",3) == 0
- || strncmp (cs->c_name,"LP%",3) == 0
- || strncmp (cs->c_name,"LPB%",4) == 0
- || strncmp (cs->c_name,"LBB%",4) == 0
- || strncmp (cs->c_name,"LBE%",4) == 0
- || strncmp (cs->c_name,"LPBX%",5) == 0))
- /* At least on a 3b1, gcc generates swbeg and string labels
- that look like this. Ignore them. */
+ /* flush rest of '.' symbols */
break;
- /* fall in for static symbols that don't start with '.' */
- case C_THUMBEXT:
- case C_THUMBEXTFUNC:
- case C_EXT:
- {
- /* Record it in the minimal symbols regardless of
- SDB_TYPE. This parallels what we do for other debug
- formats, and probably is needed to make
- print_address_symbolic work right without the (now
- gone) "set fast-symbolic-addr off" kludge. */
+ }
+ else if (!SDB_TYPE (cs->c_type)
+ && cs->c_name[0] == 'L'
+ && (strncmp (cs->c_name, "LI%", 3) == 0
+ || strncmp (cs->c_name, "LF%", 3) == 0
+ || strncmp (cs->c_name, "LC%", 3) == 0
+ || strncmp (cs->c_name, "LP%", 3) == 0
+ || strncmp (cs->c_name, "LPB%", 4) == 0
+ || strncmp (cs->c_name, "LBB%", 4) == 0
+ || strncmp (cs->c_name, "LBE%", 4) == 0
+ || strncmp (cs->c_name, "LPBX%", 5) == 0))
+ /* At least on a 3b1, gcc generates swbeg and string labels
+ that look like this. Ignore them. */
+ break;
+ /* fall in for static symbols that don't start with '.' */
+ case C_THUMBEXT:
+ case C_THUMBEXTFUNC:
+ case C_EXT:
+ {
+ /* Record it in the minimal symbols regardless of
+ SDB_TYPE. This parallels what we do for other debug
+ formats, and probably is needed to make
+ print_address_symbolic work right without the (now
+ gone) "set fast-symbolic-addr off" kludge. */
- /* FIXME: should use mst_abs, and not relocate, if absolute. */
- enum minimal_symbol_type ms_type;
- int sec;
+ /* FIXME: should use mst_abs, and not relocate, if absolute. */
+ enum minimal_symbol_type ms_type;
+ int sec;
- if (cs->c_secnum == N_UNDEF)
- {
- /* This is a common symbol. See if the target
- environment knows where it has been relocated to. */
- CORE_ADDR reladdr;
- if (target_lookup_symbol (cs->c_name, &reladdr))
- {
- /* Error in lookup; ignore symbol. */
- break;
- }
- tmpaddr = reladdr;
- /* The address has already been relocated; make sure that
- objfile_relocate doesn't relocate it again. */
- sec = -2;
- ms_type = cs->c_sclass == C_EXT
- || cs->c_sclass == C_THUMBEXT ?
- mst_bss : mst_file_bss;
- }
- else
- {
- sec = cs_to_section (cs, objfile);
- tmpaddr = cs->c_value;
- if (cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC
- || cs->c_sclass == C_THUMBEXT)
- tmpaddr += ANOFFSET (section_offsets, sec);
+ if (cs->c_secnum == N_UNDEF)
+ {
+ /* This is a common symbol. See if the target
+ environment knows where it has been relocated to. */
+ CORE_ADDR reladdr;
+ if (target_lookup_symbol (cs->c_name, &reladdr))
+ {
+ /* Error in lookup; ignore symbol. */
+ break;
+ }
+ tmpaddr = reladdr;
+ /* The address has already been relocated; make sure that
+ objfile_relocate doesn't relocate it again. */
+ sec = -2;
+ ms_type = cs->c_sclass == C_EXT
+ || cs->c_sclass == C_THUMBEXT ?
+ mst_bss : mst_file_bss;
+ }
+ else
+ {
+ sec = cs_to_section (cs, objfile);
+ tmpaddr = cs->c_value;
+ if (cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC
+ || cs->c_sclass == C_THUMBEXT)
+ tmpaddr += ANOFFSET (section_offsets, sec);
- switch (sec)
- {
- case SECT_OFF_TEXT:
- case SECT_OFF_RODATA:
- ms_type =
- cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC
- || cs->c_sclass == C_THUMBEXT ?
- mst_text : mst_file_text;
+ switch (sec)
+ {
+ case SECT_OFF_TEXT:
+ case SECT_OFF_RODATA:
+ ms_type =
+ cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC
+ || cs->c_sclass == C_THUMBEXT ?
+ mst_text : mst_file_text;
#ifdef SMASH_TEXT_ADDRESS
- if (tmpaddr & 1) /* FIXME: delete this line */
- SMASH_TEXT_ADDRESS (tmpaddr);
+ if (tmpaddr & 1) /* FIXME: delete this line */
+ SMASH_TEXT_ADDRESS (tmpaddr);
#endif
- break;
- case SECT_OFF_DATA:
- ms_type =
- cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ?
- mst_data : mst_file_data;
- break;
- case SECT_OFF_BSS:
- ms_type =
- cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ?
- mst_data : mst_file_data;
- break;
- default:
- ms_type = mst_unknown;
- break;
- }
- }
+ break;
+ case SECT_OFF_DATA:
+ ms_type =
+ cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ?
+ mst_data : mst_file_data;
+ break;
+ case SECT_OFF_BSS:
+ ms_type =
+ cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ?
+ mst_data : mst_file_data;
+ break;
+ default:
+ ms_type = mst_unknown;
+ break;
+ }
+ }
- if (cs->c_name[0] != '@' /* Skip tdesc symbols */)
- {
- struct minimal_symbol *msym;
+ if (cs->c_name[0] != '@' /* Skip tdesc symbols */ )
+ {
+ struct minimal_symbol *msym;
- msym = prim_record_minimal_symbol_and_info
- (cs->c_name, tmpaddr, ms_type, (char *)cs->c_sclass, sec,
+ msym = prim_record_minimal_symbol_and_info
+ (cs->c_name, tmpaddr, ms_type, (char *) cs->c_sclass, sec,
NULL, objfile);
#ifdef COFF_MAKE_MSYMBOL_SPECIAL
- if(msym)
- COFF_MAKE_MSYMBOL_SPECIAL(cs->c_sclass, msym);
+ if (msym)
+ COFF_MAKE_MSYMBOL_SPECIAL (cs->c_sclass, msym);
#endif
+ }
+ if (SDB_TYPE (cs->c_type))
+ {
+ struct symbol *sym;
+ sym = process_coff_symbol
+ (cs, &main_aux, section_offsets, objfile);
+ SYMBOL_VALUE (sym) = tmpaddr;
+ SYMBOL_SECTION (sym) = sec;
+ }
+ }
+ break;
+
+ case C_FCN:
+ if (STREQ (cs->c_name, ".bf"))
+ {
+ within_function = 1;
+
+ /* value contains address of first non-init type code */
+ /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
+ contains line number of '{' } */
+ if (cs->c_naux != 1)
+ complain (&bf_no_aux_complaint, cs->c_symnum);
+ fcn_first_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
+ fcn_first_line_addr = cs->c_value;
+
+ /* Might want to check that locals are 0 and
+ context_stack_depth is zero, and complain if not. */
+
+ depth = 0;
+ new = push_context (depth, fcn_start_addr);
+ fcn_cs_saved.c_name = getsymname (&fcn_sym_saved);
+ new->name =
+ process_coff_symbol (&fcn_cs_saved, &fcn_aux_saved,
+ section_offsets, objfile);
+ }
+ else if (STREQ (cs->c_name, ".ef"))
+ {
+ /* the value of .ef is the address of epilogue code;
+ not useful for gdb. */
+ /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
+ contains number of lines to '}' */
+
+ if (context_stack_depth <= 0)
+ { /* We attempted to pop an empty context stack */
+ complain (&ef_stack_complaint, cs->c_symnum);
+ within_function = 0;
+ break;
}
- if (SDB_TYPE (cs->c_type))
+
+ new = pop_context ();
+ /* Stack must be empty now. */
+ if (context_stack_depth > 0 || new == NULL)
{
- struct symbol *sym;
- sym = process_coff_symbol
- (cs, &main_aux, section_offsets, objfile);
- SYMBOL_VALUE (sym) = tmpaddr;
- SYMBOL_SECTION (sym) = sec;
+ complain (&ef_complaint, cs->c_symnum);
+ within_function = 0;
+ break;
}
- }
- break;
-
- case C_FCN:
- if (STREQ (cs->c_name, ".bf"))
- {
- within_function = 1;
-
- /* value contains address of first non-init type code */
- /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
- contains line number of '{' } */
- if (cs->c_naux != 1)
- complain (&bf_no_aux_complaint, cs->c_symnum);
- fcn_first_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
- fcn_first_line_addr = cs->c_value;
-
- /* Might want to check that locals are 0 and
- context_stack_depth is zero, and complain if not. */
-
- depth = 0;
- new = push_context (depth, fcn_start_addr);
- fcn_cs_saved.c_name = getsymname (&fcn_sym_saved);
- new->name =
- process_coff_symbol (&fcn_cs_saved, &fcn_aux_saved,
- section_offsets, objfile);
- }
- else if (STREQ (cs->c_name, ".ef"))
- {
- /* the value of .ef is the address of epilogue code;
- not useful for gdb. */
- /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
- contains number of lines to '}' */
-
- if (context_stack_depth <= 0)
- { /* We attempted to pop an empty context stack */
- complain (&ef_stack_complaint, cs->c_symnum);
- within_function = 0;
- break;
- }
+ if (cs->c_naux != 1)
+ {
+ complain (&ef_no_aux_complaint, cs->c_symnum);
+ fcn_last_line = 0x7FFFFFFF;
+ }
+ else
+ {
+ fcn_last_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
+ }
+ /* fcn_first_line is the line number of the opening '{'.
+ Do not record it - because it would affect gdb's idea
+ of the line number of the first statement of the function -
+ except for one-line functions, for which it is also the line
+ number of all the statements and of the closing '}', and
+ for which we do not have any other statement-line-number. */
+ if (fcn_last_line == 1)
+ record_line (current_subfile, fcn_first_line,
+ fcn_first_line_addr);
+ else
+ enter_linenos (fcn_line_ptr, fcn_first_line, fcn_last_line,
+ section_offsets);
- new = pop_context ();
- /* Stack must be empty now. */
- if (context_stack_depth > 0 || new == NULL)
- {
- complain (&ef_complaint, cs->c_symnum);
- within_function = 0;
- break;
- }
- if (cs->c_naux != 1)
- {
- complain (&ef_no_aux_complaint, cs->c_symnum);
- fcn_last_line = 0x7FFFFFFF;
- }
- else
- {
- fcn_last_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
- }
- /* fcn_first_line is the line number of the opening '{'.
- Do not record it - because it would affect gdb's idea
- of the line number of the first statement of the function -
- except for one-line functions, for which it is also the line
- number of all the statements and of the closing '}', and
- for which we do not have any other statement-line-number. */
- if (fcn_last_line == 1)
- record_line (current_subfile, fcn_first_line,
- fcn_first_line_addr);
- else
- enter_linenos (fcn_line_ptr, fcn_first_line, fcn_last_line,
- section_offsets);
-
- finish_block (new->name, &local_symbols, new->old_blocks,
- new->start_addr,
+ finish_block (new->name, &local_symbols, new->old_blocks,
+ new->start_addr,
#if defined (FUNCTION_EPILOGUE_SIZE)
- /* This macro should be defined only on
- machines where the
- fcn_aux_saved.x_sym.x_misc.x_fsize
- field is always zero.
- So use the .bf record information that
- points to the epilogue and add the size
- of the epilogue. */
- cs->c_value
- + FUNCTION_EPILOGUE_SIZE
- + ANOFFSET (section_offsets, SECT_OFF_TEXT),
+ /* This macro should be defined only on
+ machines where the
+ fcn_aux_saved.x_sym.x_misc.x_fsize
+ field is always zero.
+ So use the .bf record information that
+ points to the epilogue and add the size
+ of the epilogue. */
+ cs->c_value
+ + FUNCTION_EPILOGUE_SIZE
+ + ANOFFSET (section_offsets, SECT_OFF_TEXT),
#else
- fcn_cs_saved.c_value
- + fcn_aux_saved.x_sym.x_misc.x_fsize
- + ANOFFSET (section_offsets, SECT_OFF_TEXT),
+ fcn_cs_saved.c_value
+ + fcn_aux_saved.x_sym.x_misc.x_fsize
+ + ANOFFSET (section_offsets, SECT_OFF_TEXT),
#endif
- objfile
- );
- within_function = 0;
- }
- break;
+ objfile
+ );
+ within_function = 0;
+ }
+ break;
- case C_BLOCK:
- if (STREQ (cs->c_name, ".bb"))
- {
- tmpaddr = cs->c_value;
- tmpaddr += ANOFFSET (section_offsets, SECT_OFF_TEXT);
- push_context (++depth, tmpaddr);
- }
- else if (STREQ (cs->c_name, ".eb"))
- {
- if (context_stack_depth <= 0)
- { /* We attempted to pop an empty context stack */
- complain (&eb_stack_complaint, cs->c_symnum);
- break;
- }
+ case C_BLOCK:
+ if (STREQ (cs->c_name, ".bb"))
+ {
+ tmpaddr = cs->c_value;
+ tmpaddr += ANOFFSET (section_offsets, SECT_OFF_TEXT);
+ push_context (++depth, tmpaddr);
+ }
+ else if (STREQ (cs->c_name, ".eb"))
+ {
+ if (context_stack_depth <= 0)
+ { /* We attempted to pop an empty context stack */
+ complain (&eb_stack_complaint, cs->c_symnum);
+ break;
+ }
- new = pop_context ();
- if (depth-- != new->depth)
- {
- complain (&eb_complaint, symnum);
- break;
- }
- if (local_symbols && context_stack_depth > 0)
- {
- tmpaddr =
- cs->c_value + ANOFFSET (section_offsets, SECT_OFF_TEXT);
- /* Make a block for the local symbols within. */
- finish_block (0, &local_symbols, new->old_blocks,
- new->start_addr, tmpaddr, objfile);
- }
- /* Now pop locals of block just finished. */
- local_symbols = new->locals;
- }
- break;
+ new = pop_context ();
+ if (depth-- != new->depth)
+ {
+ complain (&eb_complaint, symnum);
+ break;
+ }
+ if (local_symbols && context_stack_depth > 0)
+ {
+ tmpaddr =
+ cs->c_value + ANOFFSET (section_offsets, SECT_OFF_TEXT);
+ /* Make a block for the local symbols within. */
+ finish_block (0, &local_symbols, new->old_blocks,
+ new->start_addr, tmpaddr, objfile);
+ }
+ /* Now pop locals of block just finished. */
+ local_symbols = new->locals;
+ }
+ break;
- default:
- process_coff_symbol (cs, &main_aux, section_offsets, objfile);
- break;
+ default:
+ process_coff_symbol (cs, &main_aux, section_offsets, objfile);
+ break;
}
}
@@ -1162,25 +1169,25 @@ coff_symtab_read (symtab_offset, nsyms, section_offsets, objfile)
static void
read_one_sym (cs, sym, aux)
- register struct coff_symbol *cs;
- register struct internal_syment *sym;
- register union internal_auxent *aux;
+ register struct coff_symbol *cs;
+ register struct internal_syment *sym;
+ register union internal_auxent *aux;
{
int i;
cs->c_symnum = symnum;
bfd_read (temp_sym, local_symesz, 1, nlist_bfd_global);
- bfd_coff_swap_sym_in (symfile_bfd, temp_sym, (char *)sym);
+ bfd_coff_swap_sym_in (symfile_bfd, temp_sym, (char *) sym);
cs->c_naux = sym->n_numaux & 0xff;
if (cs->c_naux >= 1)
{
- bfd_read (temp_aux, local_auxesz, 1, nlist_bfd_global);
- bfd_coff_swap_aux_in (symfile_bfd, temp_aux, sym->n_type, sym->n_sclass,
- 0, cs->c_naux, (char *)aux);
- /* If more than one aux entry, read past it (only the first aux
- is important). */
- for (i = 1; i < cs->c_naux; i++)
bfd_read (temp_aux, local_auxesz, 1, nlist_bfd_global);
+ bfd_coff_swap_aux_in (symfile_bfd, temp_aux, sym->n_type, sym->n_sclass,
+ 0, cs->c_naux, (char *) aux);
+ /* If more than one aux entry, read past it (only the first aux
+ is important). */
+ for (i = 1; i < cs->c_naux; i++)
+ bfd_read (temp_aux, local_auxesz, 1, nlist_bfd_global);
}
cs->c_name = getsymname (sym);
cs->c_value = sym->n_value;
@@ -1192,7 +1199,7 @@ read_one_sym (cs, sym, aux)
#if 0
if (cs->c_sclass & 128)
- printf("thumb symbol %s, class 0x%x\n", cs->c_name, cs->c_sclass);
+ printf ("thumb symbol %s, class 0x%x\n", cs->c_name, cs->c_sclass);
#endif
symnum += 1 + cs->c_naux;
@@ -1232,8 +1239,8 @@ static char *stringtab = NULL;
static int
init_stringtab (abfd, offset)
- bfd *abfd;
- long offset;
+ bfd *abfd;
+ long offset;
{
long length;
int val;
@@ -1249,9 +1256,9 @@ init_stringtab (abfd, offset)
if (bfd_seek (abfd, offset, 0) < 0)
return -1;
- val = bfd_read ((char *)lengthbuf, sizeof lengthbuf, 1, abfd);
+ val = bfd_read ((char *) lengthbuf, sizeof lengthbuf, 1, abfd);
length = bfd_h_get_32 (symfile_bfd, lengthbuf);
-
+
/* If no string table is needed, then the file may end immediately
after the symbols. Just return with `stringtab' set to null. */
if (val != sizeof lengthbuf || length < sizeof lengthbuf)
@@ -1261,7 +1268,7 @@ init_stringtab (abfd, offset)
/* This is in target format (probably not very useful, and not currently
used), not host format. */
memcpy (stringtab, lengthbuf, sizeof lengthbuf);
- if (length == sizeof length) /* Empty table -- just the count */
+ if (length == sizeof length) /* Empty table -- just the count */
return 0;
val = bfd_read (stringtab + sizeof lengthbuf, length - sizeof lengthbuf, 1, abfd);
@@ -1281,15 +1288,15 @@ free_stringtab ()
static char *
getsymname (symbol_entry)
- struct internal_syment *symbol_entry;
+ struct internal_syment *symbol_entry;
{
- static char buffer[SYMNMLEN+1];
+ static char buffer[SYMNMLEN + 1];
char *result;
if (symbol_entry->_n._n_n._n_zeroes == 0)
{
/* FIXME: Probably should be detecting corrupt symbol files by
- seeing whether offset points to within the stringtab. */
+ seeing whether offset points to within the stringtab. */
result = stringtab + symbol_entry->_n._n_n._n_offset;
}
else
@@ -1307,7 +1314,7 @@ getsymname (symbol_entry)
static char *
coff_getfilename (aux_entry)
- union internal_auxent *aux_entry;
+ union internal_auxent *aux_entry;
{
static char buffer[BUFSIZ];
register char *temp;
@@ -1339,26 +1346,26 @@ static unsigned long linetab_size;
/* Read in all the line numbers for fast lookups later. Leave them in
external (unswapped) format in memory; we'll swap them as we enter
them into GDB's data structures. */
-
+
static int
init_lineno (abfd, offset, size)
- bfd *abfd;
- long offset;
- int size;
+ bfd *abfd;
+ long offset;
+ int size;
{
int val;
linetab_offset = offset;
linetab_size = size;
- free_linetab();
+ free_linetab ();
if (size == 0)
return 0;
if (bfd_seek (abfd, offset, 0) < 0)
return -1;
-
+
/* Allocate the desired table, plus a sentinel */
linetab = (char *) xmalloc (size + local_linesz);
@@ -1395,15 +1402,15 @@ enter_linenos (file_offset, first_line, last_line, section_offsets)
struct internal_lineno lptr;
if (!linetab)
- return ;
+ return;
if (file_offset < linetab_offset)
{
complain (&lineno_complaint, file_offset);
if (file_offset > linetab_size) /* Too big to be an offset? */
return;
- file_offset += linetab_offset; /* Try reading at that linetab offset */
+ file_offset += linetab_offset; /* Try reading at that linetab offset */
}
-
+
rawptr = &linetab[file_offset - linetab_offset];
/* skip first line entry for each function */
@@ -1411,23 +1418,24 @@ enter_linenos (file_offset, first_line, last_line, section_offsets)
/* line numbers start at one for the first line of the function */
first_line--;
- for (;;) {
- bfd_coff_swap_lineno_in (symfile_bfd, rawptr, &lptr);
- rawptr += local_linesz;
- /* The next function, or the sentinel, will have L_LNNO32 zero; we exit. */
- if (L_LNNO32 (&lptr) && L_LNNO32 (&lptr) <= last_line)
- record_line (current_subfile, first_line + L_LNNO32 (&lptr),
- lptr.l_addr.l_paddr
- + ANOFFSET (section_offsets, SECT_OFF_TEXT));
- else
- break;
- }
+ for (;;)
+ {
+ bfd_coff_swap_lineno_in (symfile_bfd, rawptr, &lptr);
+ rawptr += local_linesz;
+ /* The next function, or the sentinel, will have L_LNNO32 zero; we exit. */
+ if (L_LNNO32 (&lptr) && L_LNNO32 (&lptr) <= last_line)
+ record_line (current_subfile, first_line + L_LNNO32 (&lptr),
+ lptr.l_addr.l_paddr
+ + ANOFFSET (section_offsets, SECT_OFF_TEXT));
+ else
+ break;
+ }
}
static void
patch_type (type, real_type)
- struct type *type;
- struct type *real_type;
+ struct type *type;
+ struct type *real_type;
{
register struct type *target = TYPE_TARGET_TYPE (type);
register struct type *real_target = TYPE_TARGET_TYPE (real_type);
@@ -1457,15 +1465,15 @@ patch_opaque_types (s)
register struct block *b;
register int i;
register struct symbol *real_sym;
-
+
/* Go through the per-file symbols only */
b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
for (i = BLOCK_NSYMS (b) - 1; i >= 0; i--)
{
/* Find completed typedefs to use to fix opaque ones.
- Remove syms from the chain when their types are stored,
- but search the whole chain, as there may be several syms
- from different files with the same name. */
+ Remove syms from the chain when their types are stored,
+ but search the whole chain, as there may be several syms
+ from different files with the same name. */
real_sym = BLOCK_SYM (b, i);
if (SYMBOL_CLASS (real_sym) == LOC_TYPEDEF &&
SYMBOL_NAMESPACE (real_sym) == VAR_NAMESPACE &&
@@ -1475,7 +1483,7 @@ patch_opaque_types (s)
register char *name = SYMBOL_NAME (real_sym);
register int hash = hashname (name);
register struct symbol *sym, *prev;
-
+
prev = 0;
for (sym = opaque_type_chain[hash]; sym;)
{
@@ -1490,9 +1498,9 @@ patch_opaque_types (s)
{
opaque_type_chain[hash] = SYMBOL_VALUE_CHAIN (sym);
}
-
+
patch_type (SYMBOL_TYPE (sym), SYMBOL_TYPE (real_sym));
-
+
if (prev)
{
sym = SYMBOL_VALUE_CHAIN (prev);
@@ -1520,8 +1528,8 @@ process_coff_symbol (cs, aux, section_offsets, objfile)
struct objfile *objfile;
{
register struct symbol *sym
- = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
- sizeof (struct symbol));
+ = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
+ sizeof (struct symbol));
char *name;
memset (sym, 0, sizeof (struct symbol));
@@ -1540,8 +1548,8 @@ process_coff_symbol (cs, aux, section_offsets, objfile)
if (ISFCN (cs->c_type))
{
SYMBOL_VALUE (sym) += ANOFFSET (section_offsets, SECT_OFF_TEXT);
- SYMBOL_TYPE(sym) =
- lookup_function_type (decode_function_type (cs, cs->c_type, aux));
+ SYMBOL_TYPE (sym) =
+ lookup_function_type (decode_function_type (cs, cs->c_type, aux));
SYMBOL_CLASS (sym) = LOC_BLOCK;
if (cs->c_sclass == C_STAT || cs->c_sclass == C_THUMBSTAT
@@ -1556,181 +1564,183 @@ process_coff_symbol (cs, aux, section_offsets, objfile)
SYMBOL_TYPE (sym) = decode_type (cs, cs->c_type, aux);
switch (cs->c_sclass)
{
- case C_NULL:
- break;
+ case C_NULL:
+ break;
- case C_AUTO:
- SYMBOL_CLASS (sym) = LOC_LOCAL;
- add_symbol_to_list (sym, &local_symbols);
- break;
+ case C_AUTO:
+ SYMBOL_CLASS (sym) = LOC_LOCAL;
+ add_symbol_to_list (sym, &local_symbols);
+ break;
- case C_THUMBEXT:
- case C_THUMBEXTFUNC:
- case C_EXT:
- SYMBOL_CLASS (sym) = LOC_STATIC;
- SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
- SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (section_offsets, SECT_OFF_TEXT);
- add_symbol_to_list (sym, &global_symbols);
- break;
+ case C_THUMBEXT:
+ case C_THUMBEXTFUNC:
+ case C_EXT:
+ SYMBOL_CLASS (sym) = LOC_STATIC;
+ SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
+ SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (section_offsets, SECT_OFF_TEXT);
+ add_symbol_to_list (sym, &global_symbols);
+ break;
- case C_THUMBSTAT:
- case C_THUMBSTATFUNC:
- case C_STAT:
- SYMBOL_CLASS (sym) = LOC_STATIC;
- SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
- SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (section_offsets, SECT_OFF_TEXT);
- if (within_function) {
+ case C_THUMBSTAT:
+ case C_THUMBSTATFUNC:
+ case C_STAT:
+ SYMBOL_CLASS (sym) = LOC_STATIC;
+ SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
+ SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (section_offsets, SECT_OFF_TEXT);
+ if (within_function)
+ {
/* Static symbol of local scope */
add_symbol_to_list (sym, &local_symbols);
}
- else {
+ else
+ {
/* Static symbol at top level of file */
add_symbol_to_list (sym, &file_symbols);
}
- break;
+ break;
#ifdef C_GLBLREG /* AMD coff */
- case C_GLBLREG:
+ case C_GLBLREG:
#endif
- case C_REG:
- SYMBOL_CLASS (sym) = LOC_REGISTER;
- SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM(cs->c_value);
- add_symbol_to_list (sym, &local_symbols);
- break;
+ case C_REG:
+ SYMBOL_CLASS (sym) = LOC_REGISTER;
+ SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM (cs->c_value);
+ add_symbol_to_list (sym, &local_symbols);
+ break;
- case C_THUMBLABEL:
- case C_LABEL:
- break;
+ case C_THUMBLABEL:
+ case C_LABEL:
+ break;
- case C_ARG:
- SYMBOL_CLASS (sym) = LOC_ARG;
- add_symbol_to_list (sym, &local_symbols);
+ case C_ARG:
+ SYMBOL_CLASS (sym) = LOC_ARG;
+ add_symbol_to_list (sym, &local_symbols);
#if !defined (BELIEVE_PCC_PROMOTION)
- if (TARGET_BYTE_ORDER == BIG_ENDIAN)
- {
- /* If PCC says a parameter is a short or a char,
- aligned on an int boundary, realign it to the
- "little end" of the int. */
- struct type *temptype;
- temptype = lookup_fundamental_type (current_objfile,
- FT_INTEGER);
- if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype)
- && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT
- && 0 == SYMBOL_VALUE (sym) % TYPE_LENGTH (temptype))
- {
- SYMBOL_VALUE (sym) +=
- TYPE_LENGTH (temptype)
- - TYPE_LENGTH (SYMBOL_TYPE (sym));
- }
- }
+ if (TARGET_BYTE_ORDER == BIG_ENDIAN)
+ {
+ /* If PCC says a parameter is a short or a char,
+ aligned on an int boundary, realign it to the
+ "little end" of the int. */
+ struct type *temptype;
+ temptype = lookup_fundamental_type (current_objfile,
+ FT_INTEGER);
+ if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype)
+ && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT
+ && 0 == SYMBOL_VALUE (sym) % TYPE_LENGTH (temptype))
+ {
+ SYMBOL_VALUE (sym) +=
+ TYPE_LENGTH (temptype)
+ - TYPE_LENGTH (SYMBOL_TYPE (sym));
+ }
+ }
#endif
- break;
+ break;
- case C_REGPARM:
- SYMBOL_CLASS (sym) = LOC_REGPARM;
- SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM(cs->c_value);
- add_symbol_to_list (sym, &local_symbols);
+ case C_REGPARM:
+ SYMBOL_CLASS (sym) = LOC_REGPARM;
+ SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM (cs->c_value);
+ add_symbol_to_list (sym, &local_symbols);
#if !defined (BELIEVE_PCC_PROMOTION)
- /* FIXME: This should retain the current type, since it's just
- a register value. gnu@adobe, 26Feb93 */
+ /* FIXME: This should retain the current type, since it's just
+ a register value. gnu@adobe, 26Feb93 */
+ {
+ /* If PCC says a parameter is a short or a char,
+ it is really an int. */
+ struct type *temptype;
+ temptype =
+ lookup_fundamental_type (current_objfile, FT_INTEGER);
+ if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype)
+ && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT)
{
- /* If PCC says a parameter is a short or a char,
- it is really an int. */
- struct type *temptype;
- temptype =
- lookup_fundamental_type (current_objfile, FT_INTEGER);
- if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype)
- && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT)
- {
- SYMBOL_TYPE (sym) =
- (TYPE_UNSIGNED (SYMBOL_TYPE (sym))
- ? lookup_fundamental_type (current_objfile,
- FT_UNSIGNED_INTEGER)
- : temptype);
- }
+ SYMBOL_TYPE (sym) =
+ (TYPE_UNSIGNED (SYMBOL_TYPE (sym))
+ ? lookup_fundamental_type (current_objfile,
+ FT_UNSIGNED_INTEGER)
+ : temptype);
}
+ }
#endif
- break;
-
- case C_TPDEF:
- SYMBOL_CLASS (sym) = LOC_TYPEDEF;
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+ break;
- /* If type has no name, give it one */
- if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
- {
- if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
- || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
- {
- /* If we are giving a name to a type such as "pointer to
- foo" or "function returning foo", we better not set
- the TYPE_NAME. If the program contains "typedef char
- *caddr_t;", we don't want all variables of type char
- * to print as caddr_t. This is not just a
- consequence of GDB's type management; CC and GCC (at
- least through version 2.4) both output variables of
- either type char * or caddr_t with the type
- refering to the C_TPDEF symbol for caddr_t. If a future
- compiler cleans this up it GDB is not ready for it
- yet, but if it becomes ready we somehow need to
- disable this check (without breaking the PCC/GCC2.4
- case).
-
- Sigh.
-
- Fortunately, this check seems not to be necessary
- for anything except pointers or functions. */
- ;
- }
- else
- TYPE_NAME (SYMBOL_TYPE (sym)) =
- concat (SYMBOL_NAME (sym), NULL);
- }
+ case C_TPDEF:
+ SYMBOL_CLASS (sym) = LOC_TYPEDEF;
+ SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+
+ /* If type has no name, give it one */
+ if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
+ {
+ if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
+ || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
+ {
+ /* If we are giving a name to a type such as "pointer to
+ foo" or "function returning foo", we better not set
+ the TYPE_NAME. If the program contains "typedef char
+ *caddr_t;", we don't want all variables of type char
+ * to print as caddr_t. This is not just a
+ consequence of GDB's type management; CC and GCC (at
+ least through version 2.4) both output variables of
+ either type char * or caddr_t with the type
+ refering to the C_TPDEF symbol for caddr_t. If a future
+ compiler cleans this up it GDB is not ready for it
+ yet, but if it becomes ready we somehow need to
+ disable this check (without breaking the PCC/GCC2.4
+ case).
+
+ Sigh.
+
+ Fortunately, this check seems not to be necessary
+ for anything except pointers or functions. */
+ ;
+ }
+ else
+ TYPE_NAME (SYMBOL_TYPE (sym)) =
+ concat (SYMBOL_NAME (sym), NULL);
+ }
#ifdef CXUX_TARGET
- /* Ignore vendor section for Harris CX/UX targets. */
- else if (cs->c_name[0] == '$')
- break;
+ /* Ignore vendor section for Harris CX/UX targets. */
+ else if (cs->c_name[0] == '$')
+ break;
#endif /* CXUX_TARGET */
- /* Keep track of any type which points to empty structured type,
- so it can be filled from a definition from another file. A
- simple forward reference (TYPE_CODE_UNDEF) is not an
- empty structured type, though; the forward references
- work themselves out via the magic of coff_lookup_type. */
- if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR &&
- TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) == 0 &&
- TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) !=
- TYPE_CODE_UNDEF)
- {
- register int i = hashname (SYMBOL_NAME (sym));
-
- SYMBOL_VALUE_CHAIN (sym) = opaque_type_chain[i];
- opaque_type_chain[i] = sym;
- }
- add_symbol_to_list (sym, &file_symbols);
- break;
+ /* Keep track of any type which points to empty structured type,
+ so it can be filled from a definition from another file. A
+ simple forward reference (TYPE_CODE_UNDEF) is not an
+ empty structured type, though; the forward references
+ work themselves out via the magic of coff_lookup_type. */
+ if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR &&
+ TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) == 0 &&
+ TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) !=
+ TYPE_CODE_UNDEF)
+ {
+ register int i = hashname (SYMBOL_NAME (sym));
- case C_STRTAG:
- case C_UNTAG:
- case C_ENTAG:
- SYMBOL_CLASS (sym) = LOC_TYPEDEF;
- SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
-
- /* Some compilers try to be helpful by inventing "fake"
- names for anonymous enums, structures, and unions, like
- "~0fake" or ".0fake". Thanks, but no thanks... */
- if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)
- if (SYMBOL_NAME(sym) != NULL
- && *SYMBOL_NAME(sym) != '~'
- && *SYMBOL_NAME(sym) != '.')
- TYPE_TAG_NAME (SYMBOL_TYPE (sym)) =
- concat (SYMBOL_NAME (sym), NULL);
+ SYMBOL_VALUE_CHAIN (sym) = opaque_type_chain[i];
+ opaque_type_chain[i] = sym;
+ }
+ add_symbol_to_list (sym, &file_symbols);
+ break;
- add_symbol_to_list (sym, &file_symbols);
- break;
+ case C_STRTAG:
+ case C_UNTAG:
+ case C_ENTAG:
+ SYMBOL_CLASS (sym) = LOC_TYPEDEF;
+ SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
+
+ /* Some compilers try to be helpful by inventing "fake"
+ names for anonymous enums, structures, and unions, like
+ "~0fake" or ".0fake". Thanks, but no thanks... */
+ if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)
+ if (SYMBOL_NAME (sym) != NULL
+ && *SYMBOL_NAME (sym) != '~'
+ && *SYMBOL_NAME (sym) != '.')
+ TYPE_TAG_NAME (SYMBOL_TYPE (sym)) =
+ concat (SYMBOL_NAME (sym), NULL);
+
+ add_symbol_to_list (sym, &file_symbols);
+ break;
- default:
- break;
+ default:
+ break;
}
}
return sym;
@@ -1826,7 +1836,7 @@ decode_function_type (cs, c_type, aux)
register union internal_auxent *aux;
{
if (aux->x_sym.x_tagndx.l == 0)
- cs->c_naux = 0; /* auxent refers to function, not base type */
+ cs->c_naux = 0; /* auxent refers to function, not base type */
return decode_type (cs, DECREF (c_type), aux);
}
@@ -1843,140 +1853,140 @@ decode_base_type (cs, c_type, aux)
switch (c_type)
{
- case T_NULL:
- /* shows up with "void (*foo)();" structure members */
- return lookup_fundamental_type (current_objfile, FT_VOID);
+ case T_NULL:
+ /* shows up with "void (*foo)();" structure members */
+ return lookup_fundamental_type (current_objfile, FT_VOID);
#if 0
/* DGUX actually defines both T_ARG and T_VOID to the same value. */
#ifdef T_ARG
- case T_ARG:
- /* Shows up in DGUX, I think. Not sure where. */
- return lookup_fundamental_type (current_objfile, FT_VOID); /* shouldn't show up here */
+ case T_ARG:
+ /* Shows up in DGUX, I think. Not sure where. */
+ return lookup_fundamental_type (current_objfile, FT_VOID); /* shouldn't show up here */
#endif
#endif /* 0 */
#ifdef T_VOID
- case T_VOID:
- /* Intel 960 COFF has this symbol and meaning. */
- return lookup_fundamental_type (current_objfile, FT_VOID);
+ case T_VOID:
+ /* Intel 960 COFF has this symbol and meaning. */
+ return lookup_fundamental_type (current_objfile, FT_VOID);
#endif
- case T_CHAR:
- return lookup_fundamental_type (current_objfile, FT_CHAR);
-
- case T_SHORT:
- return lookup_fundamental_type (current_objfile, FT_SHORT);
+ case T_CHAR:
+ return lookup_fundamental_type (current_objfile, FT_CHAR);
- case T_INT:
- return lookup_fundamental_type (current_objfile, FT_INTEGER);
+ case T_SHORT:
+ return lookup_fundamental_type (current_objfile, FT_SHORT);
- case T_LONG:
- if (cs->c_sclass == C_FIELD
- && aux->x_sym.x_misc.x_lnsz.x_size > TARGET_LONG_BIT)
- return lookup_fundamental_type (current_objfile, FT_LONG_LONG);
- else
- return lookup_fundamental_type (current_objfile, FT_LONG);
+ case T_INT:
+ return lookup_fundamental_type (current_objfile, FT_INTEGER);
- case T_FLOAT:
- return lookup_fundamental_type (current_objfile, FT_FLOAT);
+ case T_LONG:
+ if (cs->c_sclass == C_FIELD
+ && aux->x_sym.x_misc.x_lnsz.x_size > TARGET_LONG_BIT)
+ return lookup_fundamental_type (current_objfile, FT_LONG_LONG);
+ else
+ return lookup_fundamental_type (current_objfile, FT_LONG);
- case T_DOUBLE:
- return lookup_fundamental_type (current_objfile, FT_DBL_PREC_FLOAT);
+ case T_FLOAT:
+ return lookup_fundamental_type (current_objfile, FT_FLOAT);
- case T_LNGDBL:
- return lookup_fundamental_type (current_objfile, FT_EXT_PREC_FLOAT);
+ case T_DOUBLE:
+ return lookup_fundamental_type (current_objfile, FT_DBL_PREC_FLOAT);
- case T_STRUCT:
- if (cs->c_naux != 1)
- {
- /* anonymous structure type */
- type = coff_alloc_type (cs->c_symnum);
- TYPE_CODE (type) = TYPE_CODE_STRUCT;
- TYPE_NAME (type) = NULL;
- /* This used to set the tag to "<opaque>". But I think setting it
- to NULL is right, and the printing code can print it as
- "struct {...}". */
- TYPE_TAG_NAME (type) = NULL;
- INIT_CPLUS_SPECIFIC(type);
- TYPE_LENGTH (type) = 0;
- TYPE_FIELDS (type) = 0;
- TYPE_NFIELDS (type) = 0;
- }
- else
- {
- type = coff_read_struct_type (cs->c_symnum,
- aux->x_sym.x_misc.x_lnsz.x_size,
- aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
- }
- return type;
+ case T_LNGDBL:
+ return lookup_fundamental_type (current_objfile, FT_EXT_PREC_FLOAT);
- case T_UNION:
- if (cs->c_naux != 1)
- {
- /* anonymous union type */
- type = coff_alloc_type (cs->c_symnum);
- TYPE_NAME (type) = NULL;
- /* This used to set the tag to "<opaque>". But I think setting it
- to NULL is right, and the printing code can print it as
- "union {...}". */
- TYPE_TAG_NAME (type) = NULL;
- INIT_CPLUS_SPECIFIC(type);
- TYPE_LENGTH (type) = 0;
- TYPE_FIELDS (type) = 0;
- TYPE_NFIELDS (type) = 0;
- }
- else
- {
- type = coff_read_struct_type (cs->c_symnum,
- aux->x_sym.x_misc.x_lnsz.x_size,
- aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
- }
- TYPE_CODE (type) = TYPE_CODE_UNION;
- return type;
+ case T_STRUCT:
+ if (cs->c_naux != 1)
+ {
+ /* anonymous structure type */
+ type = coff_alloc_type (cs->c_symnum);
+ TYPE_CODE (type) = TYPE_CODE_STRUCT;
+ TYPE_NAME (type) = NULL;
+ /* This used to set the tag to "<opaque>". But I think setting it
+ to NULL is right, and the printing code can print it as
+ "struct {...}". */
+ TYPE_TAG_NAME (type) = NULL;
+ INIT_CPLUS_SPECIFIC (type);
+ TYPE_LENGTH (type) = 0;
+ TYPE_FIELDS (type) = 0;
+ TYPE_NFIELDS (type) = 0;
+ }
+ else
+ {
+ type = coff_read_struct_type (cs->c_symnum,
+ aux->x_sym.x_misc.x_lnsz.x_size,
+ aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
+ }
+ return type;
- case T_ENUM:
- if (cs->c_naux != 1)
- {
- /* anonymous enum type */
- type = coff_alloc_type (cs->c_symnum);
- TYPE_CODE (type) = TYPE_CODE_ENUM;
- TYPE_NAME (type) = NULL;
- /* This used to set the tag to "<opaque>". But I think setting it
- to NULL is right, and the printing code can print it as
- "enum {...}". */
- TYPE_TAG_NAME (type) = NULL;
- TYPE_LENGTH (type) = 0;
- TYPE_FIELDS (type) = 0;
- TYPE_NFIELDS(type) = 0;
- }
- else
- {
- type = coff_read_enum_type (cs->c_symnum,
+ case T_UNION:
+ if (cs->c_naux != 1)
+ {
+ /* anonymous union type */
+ type = coff_alloc_type (cs->c_symnum);
+ TYPE_NAME (type) = NULL;
+ /* This used to set the tag to "<opaque>". But I think setting it
+ to NULL is right, and the printing code can print it as
+ "union {...}". */
+ TYPE_TAG_NAME (type) = NULL;
+ INIT_CPLUS_SPECIFIC (type);
+ TYPE_LENGTH (type) = 0;
+ TYPE_FIELDS (type) = 0;
+ TYPE_NFIELDS (type) = 0;
+ }
+ else
+ {
+ type = coff_read_struct_type (cs->c_symnum,
aux->x_sym.x_misc.x_lnsz.x_size,
- aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
- }
- return type;
+ aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
+ }
+ TYPE_CODE (type) = TYPE_CODE_UNION;
+ return type;
- case T_MOE:
- /* shouldn't show up here */
- break;
+ case T_ENUM:
+ if (cs->c_naux != 1)
+ {
+ /* anonymous enum type */
+ type = coff_alloc_type (cs->c_symnum);
+ TYPE_CODE (type) = TYPE_CODE_ENUM;
+ TYPE_NAME (type) = NULL;
+ /* This used to set the tag to "<opaque>". But I think setting it
+ to NULL is right, and the printing code can print it as
+ "enum {...}". */
+ TYPE_TAG_NAME (type) = NULL;
+ TYPE_LENGTH (type) = 0;
+ TYPE_FIELDS (type) = 0;
+ TYPE_NFIELDS (type) = 0;
+ }
+ else
+ {
+ type = coff_read_enum_type (cs->c_symnum,
+ aux->x_sym.x_misc.x_lnsz.x_size,
+ aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
+ }
+ return type;
+
+ case T_MOE:
+ /* shouldn't show up here */
+ break;
- case T_UCHAR:
- return lookup_fundamental_type (current_objfile, FT_UNSIGNED_CHAR);
+ case T_UCHAR:
+ return lookup_fundamental_type (current_objfile, FT_UNSIGNED_CHAR);
- case T_USHORT:
- return lookup_fundamental_type (current_objfile, FT_UNSIGNED_SHORT);
+ case T_USHORT:
+ return lookup_fundamental_type (current_objfile, FT_UNSIGNED_SHORT);
- case T_UINT:
- return lookup_fundamental_type (current_objfile, FT_UNSIGNED_INTEGER);
+ case T_UINT:
+ return lookup_fundamental_type (current_objfile, FT_UNSIGNED_INTEGER);
- case T_ULONG:
- if (cs->c_sclass == C_FIELD
- && aux->x_sym.x_misc.x_lnsz.x_size > TARGET_LONG_BIT)
- return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG_LONG);
- else
- return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG);
+ case T_ULONG:
+ if (cs->c_sclass == C_FIELD
+ && aux->x_sym.x_misc.x_lnsz.x_size > TARGET_LONG_BIT)
+ return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG_LONG);
+ else
+ return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG);
}
complain (&unexpected_type_complaint, cs->c_name);
return lookup_fundamental_type (current_objfile, FT_VOID);
@@ -2013,7 +2023,7 @@ coff_read_struct_type (index, length, lastsym)
type = coff_alloc_type (index);
TYPE_CODE (type) = TYPE_CODE_STRUCT;
- INIT_CPLUS_SPECIFIC(type);
+ INIT_CPLUS_SPECIFIC (type);
TYPE_LENGTH (type) = length;
while (!done && symnum < lastsym && symnum < nlist_nsyms_global)
@@ -2024,46 +2034,46 @@ coff_read_struct_type (index, length, lastsym)
switch (ms->c_sclass)
{
- case C_MOS:
- case C_MOU:
-
- /* Get space to record the next field's data. */
- new = (struct nextfield *) alloca (sizeof (struct nextfield));
- new->next = list;
- list = new;
-
- /* Save the data. */
- list->field.name =
- obsavestring (name,
- strlen (name),
- &current_objfile->symbol_obstack);
- FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux);
- FIELD_BITPOS (list->field) = 8 * ms->c_value;
- FIELD_BITSIZE (list->field) = 0;
- nfields++;
- break;
+ case C_MOS:
+ case C_MOU:
+
+ /* Get space to record the next field's data. */
+ new = (struct nextfield *) alloca (sizeof (struct nextfield));
+ new->next = list;
+ list = new;
+
+ /* Save the data. */
+ list->field.name =
+ obsavestring (name,
+ strlen (name),
+ &current_objfile->symbol_obstack);
+ FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux);
+ FIELD_BITPOS (list->field) = 8 * ms->c_value;
+ FIELD_BITSIZE (list->field) = 0;
+ nfields++;
+ break;
- case C_FIELD:
-
- /* Get space to record the next field's data. */
- new = (struct nextfield *) alloca (sizeof (struct nextfield));
- new->next = list;
- list = new;
-
- /* Save the data. */
- list->field.name =
- obsavestring (name,
- strlen (name),
- &current_objfile->symbol_obstack);
- FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux);
- FIELD_BITPOS (list->field) = ms->c_value;
- FIELD_BITSIZE (list->field) = sub_aux.x_sym.x_misc.x_lnsz.x_size;
- nfields++;
- break;
+ case C_FIELD:
+
+ /* Get space to record the next field's data. */
+ new = (struct nextfield *) alloca (sizeof (struct nextfield));
+ new->next = list;
+ list = new;
+
+ /* Save the data. */
+ list->field.name =
+ obsavestring (name,
+ strlen (name),
+ &current_objfile->symbol_obstack);
+ FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux);
+ FIELD_BITPOS (list->field) = ms->c_value;
+ FIELD_BITSIZE (list->field) = sub_aux.x_sym.x_misc.x_lnsz.x_size;
+ nfields++;
+ break;
- case C_EOS:
- done = 1;
- break;
+ case C_EOS:
+ done = 1;
+ break;
}
}
/* Now create the vector of fields, and record how big it is. */
@@ -2122,28 +2132,28 @@ coff_read_enum_type (index, length, lastsym)
switch (ms->c_sclass)
{
- case C_MOE:
- sym = (struct symbol *) obstack_alloc
- (&current_objfile->symbol_obstack,
- sizeof (struct symbol));
- memset (sym, 0, sizeof (struct symbol));
-
- SYMBOL_NAME (sym) =
- obsavestring (name, strlen (name),
- &current_objfile->symbol_obstack);
- SYMBOL_CLASS (sym) = LOC_CONST;
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
- SYMBOL_VALUE (sym) = ms->c_value;
- add_symbol_to_list (sym, symlist);
- nsyms++;
- break;
+ case C_MOE:
+ sym = (struct symbol *) obstack_alloc
+ (&current_objfile->symbol_obstack,
+ sizeof (struct symbol));
+ memset (sym, 0, sizeof (struct symbol));
+
+ SYMBOL_NAME (sym) =
+ obsavestring (name, strlen (name),
+ &current_objfile->symbol_obstack);
+ SYMBOL_CLASS (sym) = LOC_CONST;
+ SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+ SYMBOL_VALUE (sym) = ms->c_value;
+ add_symbol_to_list (sym, symlist);
+ nsyms++;
+ break;
- case C_EOS:
- /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
- up the count of how many symbols to read. So stop
- on .eos. */
- done = 1;
- break;
+ case C_EOS:
+ /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
+ up the count of how many symbols to read. So stop
+ on .eos. */
+ done = 1;
+ break;
}
}
@@ -2152,7 +2162,7 @@ coff_read_enum_type (index, length, lastsym)
if (length > 0)
TYPE_LENGTH (type) = length;
else
- TYPE_LENGTH (type) = TARGET_INT_BIT / TARGET_CHAR_BIT; /* Assume ints */
+ TYPE_LENGTH (type) = TARGET_INT_BIT / TARGET_CHAR_BIT; /* Assume ints */
TYPE_CODE (type) = TYPE_CODE_ENUM;
TYPE_NFIELDS (type) = nsyms;
TYPE_FIELDS (type) = (struct field *)
@@ -2172,7 +2182,7 @@ coff_read_enum_type (index, length, lastsym)
if (syms == osyms)
j = o_nsyms;
- for (; j < syms->nsyms; j++,n++)
+ for (; j < syms->nsyms; j++, n++)
{
struct symbol *xsym = syms->symbol[j];
SYMBOL_TYPE (xsym) = type;
@@ -2197,13 +2207,13 @@ coff_read_enum_type (index, length, lastsym)
static struct sym_fns coff_sym_fns =
{
bfd_target_coff_flavour,
- coff_new_init, /* sym_new_init: init anything gbl to entire symtab */
- coff_symfile_init, /* sym_init: read initial info, setup for sym_read() */
- coff_symfile_read, /* sym_read: read a symbol file into symtab */
- coff_symfile_finish, /* sym_finish: finished with file, cleanup */
+ coff_new_init, /* sym_new_init: init anything gbl to entire symtab */
+ coff_symfile_init, /* sym_init: read initial info, setup for sym_read() */
+ coff_symfile_read, /* sym_read: read a symbol file into symtab */
+ coff_symfile_finish, /* sym_finish: finished with file, cleanup */
default_symfile_offsets,
/* sym_offsets: xlate external to internal form */
- NULL /* next: pointer to next struct sym_fns */
+ NULL /* next: pointer to next struct sym_fns */
};
void