darkkirb/old-cross-binutils
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

2003-10-06 Andrew Cagney <cagney@redhat.com>

Browse source 
* breakpoint.c, breakpoint.h: Remove obsolete code and comments.
	* buildsym.c, dbxread.c, gdbtypes.c, mdebugread.c: Ditto.
	* monitor.c, sparc-tdep.c, stabsread.c: Ditto.
	* stabsread.h, xcoffread.c: Ditto.
This commit is contained in:
Andrew Cagney 2003-10-06 19:27:13 +00:00
parent 28a86f5cc0
commit 41989fcd80
12 changed files with 14 additions and 1332 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
gdb/ChangeLog
View file

@ -1,5 +1,10 @@
2003-10-06 Andrew Cagney <cagney@redhat.com>
* breakpoint.c, breakpoint.h: Remove obsolete code.
* buildsym.c, dbxread.c, gdbtypes.c, mdebugread.c: Ditto.
* monitor.c, sparc-tdep.c, stabsread.c: Ditto.
* stabsread.h, xcoffread.c: Ditto.
* z8k-tdep.c, symm-tdep.c, symm-nat.c: Delete obsolete file.
* sparclet-stub.c, sparclet-rom.c: Delete obsolete file.
* sparcl-tdep.c, sparcl-stub.c, h8500-tdep.c: Delete obsolete file.

10
gdb/breakpoint.c
View file

@ -1245,11 +1245,11 @@ update_breakpoints_after_exec (void)
automagically. Certainly on HP-UX that's true.
Jim Blandy <jimb@redhat.com>: Actually, zero is a perfectly
valid code address on some platforms (like the OBSOLETE mn10200
and mn10300 simulators). We shouldn't assign any special
interpretation to a breakpoint with a zero address. And in
fact, GDB doesn't --- I can't see what that comment above is
talking about. As far as I can tell, setting the address of a
valid code address on some platforms (like the mn10300
simulators). We shouldn't assign any special interpretation to
a breakpoint with a zero address. And in fact, GDB doesn't ---
I can't see what that comment above is talking about. As far
as I can tell, setting the address of a
bp_catch_exec/bp_catch_vfork/bp_catch_fork breakpoint to zero
is meaningless, since those are implemented with HP-UX kernel
hackery, not by storing breakpoint instructions somewhere. */

5
gdb/breakpoint.h
View file

@ -223,9 +223,8 @@ struct breakpoint
int number;
/* Address to break at. Note that zero is a perfectly valid code
address on some platforms (for example, the OBSOLETE mn10200
and mn10300 simulators). NULL is not a special value for this
field. */
address on some platforms (for example, the and mn10300
simulators). NULL is not a special value for this field. */
CORE_ADDR address;
/* Line number of this address. */

8
gdb/buildsym.c
View file

@ -592,17 +592,9 @@ start_subfile (char *name, char *dirname)
later via a call to record_debugformat. */
subfile->debugformat = NULL;
#if 0 /* OBSOLETE CFront */
// OBSOLETE /* cfront output is a C program, so in most ways it looks like a C
// OBSOLETE program. But to demangle we need to set the language to C++. We
// OBSOLETE can distinguish cfront code by the fact that it has #line
// OBSOLETE directives which specify a file name ending in .C. */
#endif /* OBSOLETE CFront */
/* If the filename of this subfile ends in .C, then change the
language of any pending subfiles from C to C++. We also accept
any other C++ suffixes accepted by deduce_language_from_filename. */
/* OBSOLETE (in particular, some people use .cxx with cfront). */
/* Likewise for f2c. */
if (subfile->name)

131
gdb/dbxread.c
View file

@ -258,10 +258,6 @@ static int bincls_allocated;
extern void _initialize_dbxread (void);
#if 0 /* OBSOLETE CFront */
// OBSOLETE static void process_now (struct objfile *);
#endif /* OBSOLETE CFront */
static void read_ofile_symtab (struct partial_symtab *);
static void dbx_psymtab_to_symtab (struct partial_symtab *);
@ -773,107 +769,6 @@ static struct external_nlist symbuf[4096];
static int symbuf_idx;
static int symbuf_end;
#if 0 /* OBSOLETE CFront */
// OBSOLETE /* cont_elem is used for continuing information in cfront.
// OBSOLETE It saves information about which types need to be fixed up and
// OBSOLETE completed after all the stabs are read. */
// OBSOLETE struct cont_elem
// OBSOLETE {
// OBSOLETE /* sym and stabstring for continuing information in cfront */
// OBSOLETE struct symbol *sym;
// OBSOLETE char *stabs;
// OBSOLETE /* state dependencies (statics that must be preserved) */
// OBSOLETE int sym_idx;
// OBSOLETE int sym_end;
// OBSOLETE int symnum;
// OBSOLETE int (*func) (struct objfile *, struct symbol *, char *);
// OBSOLETE /* other state dependencies include:
// OBSOLETE (assumption is that these will not change since process_now FIXME!!)
// OBSOLETE stringtab_global
// OBSOLETE n_stabs
// OBSOLETE objfile
// OBSOLETE symfile_bfd */
// OBSOLETE };
// OBSOLETE static struct cont_elem *cont_list = 0;
// OBSOLETE static int cont_limit = 0;
// OBSOLETE static int cont_count = 0;
// OBSOLETE /* Arrange for function F to be called with arguments SYM and P later
// OBSOLETE in the stabs reading process. */
// OBSOLETE void
// OBSOLETE process_later (struct symbol *sym, char *p,
// OBSOLETE int (*f) (struct objfile *, struct symbol *, char *))
// OBSOLETE {
// OBSOLETE /* Allocate more space for the deferred list. */
// OBSOLETE if (cont_count >= cont_limit - 1)
// OBSOLETE {
// OBSOLETE cont_limit += 32; /* chunk size */
// OBSOLETE cont_list
// OBSOLETE = (struct cont_elem *) xrealloc (cont_list,
// OBSOLETE (cont_limit
// OBSOLETE * sizeof (struct cont_elem)));
// OBSOLETE if (!cont_list)
// OBSOLETE error ("Virtual memory exhausted\n");
// OBSOLETE }
// OBSOLETE /* Save state variables so we can process these stabs later. */
// OBSOLETE cont_list[cont_count].sym_idx = symbuf_idx;
// OBSOLETE cont_list[cont_count].sym_end = symbuf_end;
// OBSOLETE cont_list[cont_count].symnum = symnum;
// OBSOLETE cont_list[cont_count].sym = sym;
// OBSOLETE cont_list[cont_count].stabs = p;
// OBSOLETE cont_list[cont_count].func = f;
// OBSOLETE cont_count++;
// OBSOLETE }
// OBSOLETE /* Call deferred funtions in CONT_LIST. */
// OBSOLETE static void
// OBSOLETE process_now (struct objfile *objfile)
// OBSOLETE {
// OBSOLETE int i;
// OBSOLETE int save_symbuf_idx;
// OBSOLETE int save_symbuf_end;
// OBSOLETE int save_symnum;
// OBSOLETE struct symbol *sym;
// OBSOLETE char *stabs;
// OBSOLETE int err;
// OBSOLETE int (*func) (struct objfile *, struct symbol *, char *);
// OBSOLETE /* Save the state of our caller, we'll want to restore it before
// OBSOLETE returning. */
// OBSOLETE save_symbuf_idx = symbuf_idx;
// OBSOLETE save_symbuf_end = symbuf_end;
// OBSOLETE save_symnum = symnum;
// OBSOLETE /* Iterate over all the deferred stabs. */
// OBSOLETE for (i = 0; i < cont_count; i++)
// OBSOLETE {
// OBSOLETE /* Restore the state for this deferred stab. */
// OBSOLETE symbuf_idx = cont_list[i].sym_idx;
// OBSOLETE symbuf_end = cont_list[i].sym_end;
// OBSOLETE symnum = cont_list[i].symnum;
// OBSOLETE sym = cont_list[i].sym;
// OBSOLETE stabs = cont_list[i].stabs;
// OBSOLETE func = cont_list[i].func;
// OBSOLETE /* Call the function to handle this deferrd stab. */
// OBSOLETE err = (*func) (objfile, sym, stabs);
// OBSOLETE if (err)
// OBSOLETE error ("Internal error: unable to resolve stab.\n");
// OBSOLETE }
// OBSOLETE /* Restore our caller's state. */
// OBSOLETE symbuf_idx = save_symbuf_idx;
// OBSOLETE symbuf_end = save_symbuf_end;
// OBSOLETE symnum = save_symnum;
// OBSOLETE cont_count = 0;
// OBSOLETE }
#endif /* OBSOLETE CFront */
/* Name of last function encountered. Used in Solaris to approximate
object file boundaries. */
static char *last_function_name;
@ -1838,22 +1733,6 @@ read_dbx_symtab (struct objfile *objfile)
psymtab_language, objfile);
p += 1;
}
#if 0 /* OBSOLETE CFront */
// OBSOLETE /* The semantics of C++ state that "struct foo { ... }"
// OBSOLETE also defines a typedef for "foo". Unfortuantely, cfront
// OBSOLETE never makes the typedef when translating from C++ to C.
// OBSOLETE We make the typedef here so that "ptype foo" works as
// OBSOLETE expected for cfront translated code. */
// OBSOLETE else if (psymtab_language == language_cplus)
// OBSOLETE {
// OBSOLETE /* Also a typedef with the same name. */
// OBSOLETE add_psymbol_to_list (namestring, p - namestring,
// OBSOLETE VAR_DOMAIN, LOC_TYPEDEF,
// OBSOLETE &objfile->static_psymbols,
// OBSOLETE nlist.n_value, 0,
// OBSOLETE psymtab_language, objfile);
// OBSOLETE }
#endif /* OBSOLETE CFront */
}
goto check_enum;
case 't':
@ -2088,11 +1967,6 @@ read_dbx_symtab (struct objfile *objfile)
case '9':
case '-':
case '#': /* for symbol identification (used in live ranges) */
#if 0 /* OBSOLETE CFront */
// OBSOLETE /* added to support cfront stabs strings */
// OBSOLETE case 'Z': /* for definition continuations */
// OBSOLETE case 'P': /* for prototypes */
#endif /* OBSOLETE CFront */
continue;
case ':':
@ -2764,11 +2638,6 @@ read_ofile_symtab (struct partial_symtab *pst)
pst->symtab = end_symtab (text_offset + text_size, objfile, SECT_OFF_TEXT (objfile));
#if 0 /* OBSOLETE CFront */
// OBSOLETE /* Process items which we had to "process_later" due to dependencies
// OBSOLETE on other stabs. */
// OBSOLETE process_now (objfile);
#endif /* OBSOLETE CFront */
end_stabs ();
}

191
gdb/gdbtypes.c
View file

@ -129,9 +129,6 @@ struct extra
static void add_name (struct extra *, char *);
static void add_mangled_type (struct extra *, struct type *);
#if 0 /* OBSOLETE CFront */
// OBSOLETE static void cfront_mangle_name (struct type *, int, int);
#endif /* OBSOLETE CFront */
static void print_bit_vector (B_TYPE *, int);
static void print_arg_types (struct field *, int, int);
static void dump_fn_fieldlists (struct type *, int);
@ -1478,194 +1475,6 @@ check_typedef (struct type *type)
return type;
}
#if 0 /* OBSOLETE CFront */
// OBSOLETE /* New code added to support parsing of Cfront stabs strings */
// OBSOLETE #define INIT_EXTRA { pextras->len=0; pextras->str[0]='\0'; }
// OBSOLETE #define ADD_EXTRA(c) { pextras->str[pextras->len++]=c; }
// OBSOLETE static void
// OBSOLETE add_name (struct extra *pextras, char *n)
// OBSOLETE {
// OBSOLETE int nlen;
// OBSOLETE if ((nlen = (n ? strlen (n) : 0)) == 0)
// OBSOLETE return;
// OBSOLETE sprintf (pextras->str + pextras->len, "%d%s", nlen, n);
// OBSOLETE pextras->len = strlen (pextras->str);
// OBSOLETE }
// OBSOLETE static void
// OBSOLETE add_mangled_type (struct extra *pextras, struct type *t)
// OBSOLETE {
// OBSOLETE enum type_code tcode;
// OBSOLETE int tlen, tflags;
// OBSOLETE char *tname;
// OBSOLETE tcode = TYPE_CODE (t);
// OBSOLETE tlen = TYPE_LENGTH (t);
// OBSOLETE tflags = TYPE_FLAGS (t);
// OBSOLETE tname = TYPE_NAME (t);
// OBSOLETE /* args of "..." seem to get mangled as "e" */
// OBSOLETE switch (tcode)
// OBSOLETE {
// OBSOLETE case TYPE_CODE_INT:
// OBSOLETE if (tflags == 1)
// OBSOLETE ADD_EXTRA ('U');
// OBSOLETE switch (tlen)
// OBSOLETE {
// OBSOLETE case 1:
// OBSOLETE ADD_EXTRA ('c');
// OBSOLETE break;
// OBSOLETE case 2:
// OBSOLETE ADD_EXTRA ('s');
// OBSOLETE break;
// OBSOLETE case 4:
// OBSOLETE {
// OBSOLETE char *pname;
// OBSOLETE if ((pname = strrchr (tname, 'l'), pname) && !strcmp (pname, "long"))
// OBSOLETE {
// OBSOLETE ADD_EXTRA ('l');
// OBSOLETE }
// OBSOLETE else
// OBSOLETE {
// OBSOLETE ADD_EXTRA ('i');
// OBSOLETE }
// OBSOLETE }
// OBSOLETE break;
// OBSOLETE default:
// OBSOLETE {
// OBSOLETE complaint (&symfile_complaints, "Bad int type code length x%x",
// OBSOLETE tlen);
// OBSOLETE }
// OBSOLETE }
// OBSOLETE break;
// OBSOLETE case TYPE_CODE_FLT:
// OBSOLETE switch (tlen)
// OBSOLETE {
// OBSOLETE case 4:
// OBSOLETE ADD_EXTRA ('f');
// OBSOLETE break;
// OBSOLETE case 8:
// OBSOLETE ADD_EXTRA ('d');
// OBSOLETE break;
// OBSOLETE case 16:
// OBSOLETE ADD_EXTRA ('r');
// OBSOLETE break;
// OBSOLETE default:
// OBSOLETE {
// OBSOLETE complaint (&symfile_complaints, "Bad float type code length x%x",
// OBSOLETE tlen);
// OBSOLETE }
// OBSOLETE }
// OBSOLETE break;
// OBSOLETE case TYPE_CODE_REF:
// OBSOLETE ADD_EXTRA ('R');
// OBSOLETE /* followed by what it's a ref to */
// OBSOLETE break;
// OBSOLETE case TYPE_CODE_PTR:
// OBSOLETE ADD_EXTRA ('P');
// OBSOLETE /* followed by what it's a ptr to */
// OBSOLETE break;
// OBSOLETE case TYPE_CODE_TYPEDEF:
// OBSOLETE {
// OBSOLETE complaint (&symfile_complaints,
// OBSOLETE "Typedefs in overloaded functions not yet supported");
// OBSOLETE }
// OBSOLETE /* followed by type bytes & name */
// OBSOLETE break;
// OBSOLETE case TYPE_CODE_FUNC:
// OBSOLETE ADD_EXTRA ('F');
// OBSOLETE /* followed by func's arg '_' & ret types */
// OBSOLETE break;
// OBSOLETE case TYPE_CODE_VOID:
// OBSOLETE ADD_EXTRA ('v');
// OBSOLETE break;
// OBSOLETE case TYPE_CODE_METHOD:
// OBSOLETE ADD_EXTRA ('M');
// OBSOLETE /* followed by name of class and func's arg '_' & ret types */
// OBSOLETE add_name (pextras, tname);
// OBSOLETE ADD_EXTRA ('F'); /* then mangle function */
// OBSOLETE break;
// OBSOLETE case TYPE_CODE_STRUCT: /* C struct */
// OBSOLETE case TYPE_CODE_UNION: /* C union */
// OBSOLETE case TYPE_CODE_ENUM: /* Enumeration type */
// OBSOLETE /* followed by name of type */
// OBSOLETE add_name (pextras, tname);
// OBSOLETE break;
// OBSOLETE /* errors possible types/not supported */
// OBSOLETE case TYPE_CODE_CHAR:
// OBSOLETE case TYPE_CODE_ARRAY: /* Array type */
// OBSOLETE case TYPE_CODE_MEMBER: /* Member type */
// OBSOLETE case TYPE_CODE_BOOL:
// OBSOLETE case TYPE_CODE_COMPLEX: /* Complex float */
// OBSOLETE case TYPE_CODE_UNDEF:
// OBSOLETE case TYPE_CODE_SET: /* Pascal sets */
// OBSOLETE case TYPE_CODE_RANGE:
// OBSOLETE case TYPE_CODE_STRING:
// OBSOLETE case TYPE_CODE_BITSTRING:
// OBSOLETE case TYPE_CODE_ERROR:
// OBSOLETE default:
// OBSOLETE {
// OBSOLETE complaint (&symfile_complaints, "Unknown type code x%x", tcode);
// OBSOLETE }
// OBSOLETE }
// OBSOLETE if (TYPE_TARGET_TYPE (t))
// OBSOLETE add_mangled_type (pextras, TYPE_TARGET_TYPE (t));
// OBSOLETE }
// OBSOLETE void
// OBSOLETE cfront_mangle_name (struct type *type, int i, int j)
// OBSOLETE {
// OBSOLETE struct fn_field *f;
// OBSOLETE char *mangled_name = gdb_mangle_name (type, i, j);
// OBSOLETE f = TYPE_FN_FIELDLIST1 (type, i); /* moved from below */
// OBSOLETE /* kludge to support cfront methods - gdb expects to find "F" for
// OBSOLETE ARM_mangled names, so when we mangle, we have to add it here */
// OBSOLETE if (ARM_DEMANGLING)
// OBSOLETE {
// OBSOLETE int k;
// OBSOLETE char *arm_mangled_name;
// OBSOLETE struct fn_field *method = &f[j];
// OBSOLETE char *field_name = TYPE_FN_FIELDLIST_NAME (type, i);
// OBSOLETE char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
// OBSOLETE char *newname = type_name_no_tag (type);
// OBSOLETE struct type *ftype = TYPE_FN_FIELD_TYPE (f, j);
// OBSOLETE int nargs = TYPE_NFIELDS (ftype); /* number of args */
// OBSOLETE struct extra extras, *pextras = &extras;
// OBSOLETE INIT_EXTRA
// OBSOLETE if (TYPE_FN_FIELD_STATIC_P (f, j)) /* j for sublist within this list */
// OBSOLETE ADD_EXTRA ('S')
// OBSOLETE ADD_EXTRA ('F')
// OBSOLETE /* add args here! */
// OBSOLETE if (nargs <= 1) /* no args besides this */
// OBSOLETE ADD_EXTRA ('v')
// OBSOLETE else
// OBSOLETE {
// OBSOLETE for (k = 1; k < nargs; k++)
// OBSOLETE {
// OBSOLETE struct type *t;
// OBSOLETE t = TYPE_FIELD_TYPE (ftype, k);
// OBSOLETE add_mangled_type (pextras, t);
// OBSOLETE }
// OBSOLETE }
// OBSOLETE ADD_EXTRA ('\0')
// OBSOLETE printf ("add_mangled_type: %s\n", extras.str); /* FIXME */
// OBSOLETE xasprintf (&arm_mangled_name, "%s%s", mangled_name, extras.str);
// OBSOLETE xfree (mangled_name);
// OBSOLETE mangled_name = arm_mangled_name;
// OBSOLETE }
// OBSOLETE }
// OBSOLETE #undef ADD_EXTRA
// OBSOLETE /* End of new code added to support parsing of Cfront stabs strings */
#endif /* OBSOLETE CFront */
/* Parse a type expression in the string [P..P+LENGTH). If an error occurs,
silently return builtin_type_void. */

25
gdb/mdebugread.c
View file

@ -1522,10 +1522,6 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
if (t->fBitfield)
{
int width = AUX_GET_WIDTH (bigend, ax);
#if 0 /* OBSOLETE CFront */
// OBSOLETE /* Inhibit core dumps with some cfront generated objects that
// OBSOLETE corrupt the TIR. */
#endif /* OBSOLETE CFront */
/* Inhibit core dumps if TIR is corrupted. */
if (bs == (int *) NULL)
{
@ -3043,22 +3039,6 @@ parse_partial_symbols (struct objfile *objfile)
psymtab_language, objfile);
p += 1;
}
#if 0 /* OBSOLETE CFront */
// OBSOLETE /* The semantics of C++ state that "struct foo { ... }"
// OBSOLETE also defines a typedef for "foo". Unfortuantely, cfront
// OBSOLETE never makes the typedef when translating from C++ to C.
// OBSOLETE We make the typedef here so that "ptype foo" works as
// OBSOLETE expected for cfront translated code. */
// OBSOLETE else if (psymtab_language == language_cplus)
// OBSOLETE {
// OBSOLETE /* Also a typedef with the same name. */
// OBSOLETE add_psymbol_to_list (namestring, p - namestring,
// OBSOLETE VAR_DOMAIN, LOC_TYPEDEF,
// OBSOLETE &objfile->static_psymbols,
// OBSOLETE sh.value, 0,
// OBSOLETE psymtab_language, objfile);
// OBSOLETE }
#endif /* OBSOLETE CFront */
}
goto check_enum;
case 't':
@ -3205,11 +3185,6 @@ parse_partial_symbols (struct objfile *objfile)
case '9':
case '-':
case '#': /* for symbol identification (used in live ranges) */
#if 0 /* OBSOLETE CFront */
// OBSOLETE /* added to support cfront stabs strings */
// OBSOLETE case 'Z': /* for definition continuations */
// OBSOLETE case 'P': /* for prototypes */
#endif /* OBSOLETE CFront */
continue;
case ':':

8
gdb/monitor.c
View file

@ -568,14 +568,6 @@ monitor_expect (char *string, char *buf, int buflen)
return 0;
}
}
#if 0
// OBSOLETE else if ((c == '\021' || c == '\023') &&
// OBSOLETE (STREQ (targ_ops->to_shortname, "m32r")
// OBSOLETE || STREQ (targ_ops->to_shortname, "mon2000")))
// OBSOLETE { /* m32r monitor emits random DC1/DC3 chars */
// OBSOLETE continue;
// OBSOLETE }
#endif
else
{
/* We got a character that doesn't match the string. We need to

225
gdb/sparc-tdep.c
View file

@ -52,10 +52,6 @@
* Some local macros that have multi-arch and non-multi-arch versions:
*/
#if 0
// OBSOLETE /* Does the target have Floating Point registers? */
// OBSOLETE #define SPARC_HAS_FPU (gdbarch_tdep (current_gdbarch)->has_fpu)
#endif
#define SPARC_HAS_FPU 1
/* Number of bytes devoted to Floating Point registers: */
#define FP_REGISTER_BYTES (gdbarch_tdep (current_gdbarch)->fp_register_bytes)
@ -68,9 +64,6 @@
struct gdbarch_tdep
{
#if 0
// OBSOLETE int has_fpu;
#endif
int fp_register_bytes;
int y_regnum;
int fp_max_regnum;
@ -97,15 +90,6 @@ struct gdbarch_tdep
int deferred_stores = 0; /* Accumulated stores we want to do eventually. */
#if 0
// OBSOLETE /* Some machines, such as Fujitsu SPARClite 86x, have a bi-endian mode
// OBSOLETE where instructions are big-endian and data are little-endian.
// OBSOLETE This flag is set when we detect that the target is of this type. */
// OBSOLETE
// OBSOLETE int bi_endian = 0;
#endif
const unsigned char *
sparc_breakpoint_from_pc (CORE_ADDR *pc, int *len)
{
@ -2122,24 +2106,6 @@ sparc_do_registers_info (int regnum, int all)
regnum, all);
}
#if 0
// OBSOLETE static void
// OBSOLETE sparclet_print_registers_info (struct gdbarch *gdbarch,
// OBSOLETE struct ui_file *file,
// OBSOLETE struct frame_info *frame,
// OBSOLETE int regnum, int print_all)
// OBSOLETE {
// OBSOLETE sparc_print_registers (gdbarch, file, frame, regnum, print_all, NULL);
// OBSOLETE }
// OBSOLETE
// OBSOLETE void
// OBSOLETE sparclet_do_registers_info (int regnum, int all)
// OBSOLETE {
// OBSOLETE sparclet_print_registers_info (current_gdbarch, gdb_stdout,
// OBSOLETE deprecated_selected_frame, regnum, all);
// OBSOLETE }
#endif
#define SPARC_F0_REGNUM FP0_REGNUM /* %f0 */
#define SPARC_F1_REGNUM (FP0_REGNUM + 1)/* %f1 */
#define SPARC_O0_REGNUM O0_REGNUM /* %o0 */
@ -2420,17 +2386,6 @@ sparc_store_return_value (struct type *type, char *valbuf)
TYPE_LENGTH (type));
}
#if 0
// OBSOLETE extern void
// OBSOLETE sparclet_store_return_value (struct type *type, char *valbuf)
// OBSOLETE {
// OBSOLETE /* Other values are returned in register %o0. */
// OBSOLETE deprecated_write_register_bytes (REGISTER_BYTE (O0_REGNUM), valbuf,
// OBSOLETE TYPE_LENGTH (type));
// OBSOLETE }
#endif
#ifndef CALL_DUMMY_CALL_OFFSET
#define CALL_DUMMY_CALL_OFFSET \
(gdbarch_tdep (current_gdbarch)->call_dummy_call_offset)
@ -2495,45 +2450,8 @@ sparc_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun,
store_unsigned_integer (dummy + (i * 4), 4, 0x01000000);
}
}
#if 0
// OBSOLETE /* If this is a bi-endian target, GDB has written the call dummy
// OBSOLETE in little-endian order. We must byte-swap it back to big-endian. */
// OBSOLETE if (bi_endian)
// OBSOLETE {
// OBSOLETE for (i = 0; i < CALL_DUMMY_LENGTH; i += 4)
// OBSOLETE {
// OBSOLETE char tmp = dummy[i];
// OBSOLETE dummy[i] = dummy[i + 3];
// OBSOLETE dummy[i + 3] = tmp;
// OBSOLETE tmp = dummy[i + 1];
// OBSOLETE dummy[i + 1] = dummy[i + 2];
// OBSOLETE dummy[i + 2] = tmp;
// OBSOLETE }
// OBSOLETE }
#endif
}
#if 0
// OBSOLETE /* Set target byte order based on machine type. */
// OBSOLETE
// OBSOLETE static int
// OBSOLETE sparc_target_architecture_hook (const bfd_arch_info_type *ap)
// OBSOLETE {
// OBSOLETE int i, j;
// OBSOLETE
// OBSOLETE if (ap->mach == bfd_mach_sparc_sparclite_le)
// OBSOLETE {
// OBSOLETE target_byte_order = BFD_ENDIAN_LITTLE;
// OBSOLETE bi_endian = 1;
// OBSOLETE }
// OBSOLETE else
// OBSOLETE bi_endian = 0;
// OBSOLETE return 1;
// OBSOLETE }
#endif
/*
* Module "constructor" function.
*/
@ -2549,8 +2467,6 @@ _initialize_sparc_tdep (void)
{
/* Hook us into the gdbarch mechanism. */
gdbarch_register (bfd_arch_sparc, sparc_gdbarch_init, sparc_dump_tdep);
/* OBSOLETE target_architecture_hook = sparc_target_architecture_hook; */
}
/* Compensate for stack bias. Note that we currently don't handle
@ -2780,20 +2696,6 @@ sparc64_extract_return_value (struct type *type, char *regbuf, char *valbuf)
sp64_extract_return_value (type, regbuf, valbuf, 0);
}
#if 0
// OBSOLETE extern void
// OBSOLETE sparclet_extract_return_value (struct type *type,
// OBSOLETE char *regbuf,
// OBSOLETE char *valbuf)
// OBSOLETE {
// OBSOLETE regbuf += REGISTER_RAW_SIZE (O0_REGNUM) * 8;
// OBSOLETE if (TYPE_LENGTH (type) < REGISTER_RAW_SIZE (O0_REGNUM))
// OBSOLETE regbuf += REGISTER_RAW_SIZE (O0_REGNUM) - TYPE_LENGTH (type);
// OBSOLETE
// OBSOLETE memcpy ((void *) valbuf, regbuf, TYPE_LENGTH (type));
// OBSOLETE }
#endif
extern CORE_ADDR
sparc32_stack_align (CORE_ADDR addr)
{
@ -2871,71 +2773,6 @@ sparc64_register_name (int regno)
return register_names[regno];
}
#if 0
// OBSOLETE static const char *
// OBSOLETE sparclite_register_name (int regno)
// OBSOLETE {
// OBSOLETE static char *register_names[] =
// OBSOLETE { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
// OBSOLETE "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
// OBSOLETE "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
// OBSOLETE "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
// OBSOLETE
// OBSOLETE "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
// OBSOLETE "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
// OBSOLETE "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
// OBSOLETE "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
// OBSOLETE
// OBSOLETE "y", "psr", "wim", "tbr", "pc", "npc", "fpsr", "cpsr",
// OBSOLETE "dia1", "dia2", "dda1", "dda2", "ddv1", "ddv2", "dcr", "dsr"
// OBSOLETE };
// OBSOLETE
// OBSOLETE if (regno < 0 ||
// OBSOLETE regno >= (sizeof (register_names) / sizeof (register_names[0])))
// OBSOLETE return NULL;
// OBSOLETE else
// OBSOLETE return register_names[regno];
// OBSOLETE }
#endif
#if 0
// OBSOLETE static const char *
// OBSOLETE sparclet_register_name (int regno)
// OBSOLETE {
// OBSOLETE static char *register_names[] =
// OBSOLETE { "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7",
// OBSOLETE "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7",
// OBSOLETE "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
// OBSOLETE "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7",
// OBSOLETE
// OBSOLETE "", "", "", "", "", "", "", "", /* no floating point registers */
// OBSOLETE "", "", "", "", "", "", "", "",
// OBSOLETE "", "", "", "", "", "", "", "",
// OBSOLETE "", "", "", "", "", "", "", "",
// OBSOLETE
// OBSOLETE "y", "psr", "wim", "tbr", "pc", "npc", "", "", /* no FPSR or CPSR */
// OBSOLETE "ccsr", "ccpr", "cccrcr", "ccor", "ccobr", "ccibr", "ccir", "",
// OBSOLETE
// OBSOLETE /* ASR15 ASR19 (don't display them) */
// OBSOLETE "asr1", "", "asr17", "asr18", "", "asr20", "asr21", "asr22"
// OBSOLETE /* None of the rest get displayed */
// OBSOLETE #if 0
// OBSOLETE "awr0", "awr1", "awr2", "awr3", "awr4", "awr5", "awr6", "awr7",
// OBSOLETE "awr8", "awr9", "awr10", "awr11", "awr12", "awr13", "awr14", "awr15",
// OBSOLETE "awr16", "awr17", "awr18", "awr19", "awr20", "awr21", "awr22", "awr23",
// OBSOLETE "awr24", "awr25", "awr26", "awr27", "awr28", "awr29", "awr30", "awr31",
// OBSOLETE "apsr"
// OBSOLETE #endif /* 0 */
// OBSOLETE };
// OBSOLETE
// OBSOLETE if (regno < 0 ||
// OBSOLETE regno >= (sizeof (register_names) / sizeof (register_names[0])))
// OBSOLETE return NULL;
// OBSOLETE else
// OBSOLETE return register_names[regno];
// OBSOLETE }
#endif
static CORE_ADDR
sparc_push_return_address (CORE_ADDR pc_unused, CORE_ADDR sp)
{
@ -3288,15 +3125,8 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
switch (info.bfd_arch_info->mach)
{
case bfd_mach_sparc:
#if 0
// OBSOLETE case bfd_mach_sparc_sparclet:
// OBSOLETE case bfd_mach_sparc_sparclite:
#endif
case bfd_mach_sparc_v8plus:
case bfd_mach_sparc_v8plusa:
#if 0
// OBSOLETE case bfd_mach_sparc_sparclite_le:
#endif
/* 32-bit machine types: */
#ifdef SPARC32_CALL_DUMMY_ON_STACK
@ -3460,36 +3290,9 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_num_regs (gdbarch, 72);
set_gdbarch_deprecated_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
set_gdbarch_register_name (gdbarch, sparc32_register_name);
#if 0
// OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
#endif
tdep->fp_register_bytes = 32 * 4;
tdep->print_insn_mach = bfd_mach_sparc;
break;
#if 0
// OBSOLETE case bfd_mach_sparc_sparclet:
// OBSOLETE set_gdbarch_deprecated_extract_return_value (gdbarch, sparclet_extract_return_value);
// OBSOLETE set_gdbarch_num_regs (gdbarch, 32 + 32 + 8 + 8 + 8);
// OBSOLETE set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4 + 8*4);
// OBSOLETE set_gdbarch_register_name (gdbarch, sparclet_register_name);
// OBSOLETE set_gdbarch_deprecated_store_return_value (gdbarch, sparclet_store_return_value);
// OBSOLETE tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
// OBSOLETE tdep->fp_register_bytes = 0;
// OBSOLETE tdep->print_insn_mach = bfd_mach_sparc_sparclet;
// OBSOLETE break;
#endif
#if 0
// OBSOLETE case bfd_mach_sparc_sparclite:
// OBSOLETE set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
// OBSOLETE set_gdbarch_num_regs (gdbarch, 80);
// OBSOLETE set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4);
// OBSOLETE set_gdbarch_register_name (gdbarch, sparclite_register_name);
// OBSOLETE set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
// OBSOLETE tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
// OBSOLETE tdep->fp_register_bytes = 0;
// OBSOLETE tdep->print_insn_mach = bfd_mach_sparc_sparclite;
// OBSOLETE break;
#endif
case bfd_mach_sparc_v8plus:
set_gdbarch_extract_return_value (gdbarch, sparc32_extract_return_value);
set_gdbarch_store_return_value (gdbarch, sparc32_store_return_value);
@ -3498,9 +3301,6 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_register_name (gdbarch, sparc32_register_name);
tdep->print_insn_mach = bfd_mach_sparc;
tdep->fp_register_bytes = 32 * 4;
#if 0
// OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
#endif
break;
case bfd_mach_sparc_v8plusa:
set_gdbarch_extract_return_value (gdbarch, sparc32_extract_return_value);
@ -3508,33 +3308,15 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_num_regs (gdbarch, 72);
set_gdbarch_deprecated_register_bytes (gdbarch, 32*4 + 32*4 + 8*4);
set_gdbarch_register_name (gdbarch, sparc32_register_name);
#if 0
// OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
#endif
tdep->fp_register_bytes = 32 * 4;
tdep->print_insn_mach = bfd_mach_sparc;
break;
#if 0
// OBSOLETE case bfd_mach_sparc_sparclite_le:
// OBSOLETE set_gdbarch_deprecated_extract_return_value (gdbarch, sparc32_extract_return_value);
// OBSOLETE set_gdbarch_num_regs (gdbarch, 80);
// OBSOLETE set_gdbarch_register_bytes (gdbarch, 32*4 + 32*4 + 8*4 + 8*4);
// OBSOLETE set_gdbarch_register_name (gdbarch, sparclite_register_name);
// OBSOLETE set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
// OBSOLETE tdep->has_fpu = 0; /* (all but sparclet and sparclite) */
// OBSOLETE tdep->fp_register_bytes = 0;
// OBSOLETE tdep->print_insn_mach = bfd_mach_sparc_sparclite;
// OBSOLETE break;
#endif
case bfd_mach_sparc_v9:
set_gdbarch_deprecated_extract_return_value (gdbarch, sparc64_extract_return_value);
set_gdbarch_num_regs (gdbarch, 125);
set_gdbarch_deprecated_register_bytes (gdbarch, 32*8 + 32*8 + 45*8);
set_gdbarch_register_name (gdbarch, sparc64_register_name);
set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
#if 0
// OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
#endif
tdep->fp_register_bytes = 64 * 4;
tdep->print_insn_mach = bfd_mach_sparc_v9a;
break;
@ -3544,9 +3326,6 @@ sparc_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
set_gdbarch_deprecated_register_bytes (gdbarch, 32*8 + 32*8 + 45*8);
set_gdbarch_register_name (gdbarch, sparc64_register_name);
set_gdbarch_deprecated_store_return_value (gdbarch, sparc_store_return_value);
#if 0
// OBSOLETE tdep->has_fpu = 1; /* (all but sparclet and sparclite) */
#endif
tdep->fp_register_bytes = 64 * 4;
tdep->print_insn_mach = bfd_mach_sparc_v9a;
break;
@ -3568,10 +3347,6 @@ sparc_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
if (tdep == NULL)
return;
#if 0
// OBSOLETE fprintf_unfiltered (file, "sparc_dump_tdep: has_fpu = %d\n",
// OBSOLETE tdep->has_fpu);
#endif
fprintf_unfiltered (file, "sparc_dump_tdep: fp_register_bytes = %d\n",
tdep->fp_register_bytes);
fprintf_unfiltered (file, "sparc_dump_tdep: y_regnum = %d\n",

707
gdb/stabsread.c
View file

@ -153,28 +153,6 @@ static void add_undefined_type (struct type *);
static int
read_cpp_abbrev (struct field_info *, char **, struct type *,
struct objfile *);
#if 0 /* OBSOLETE CFront */
// OBSOLETE /* new functions added for cfront support */
// OBSOLETE static int
// OBSOLETE copy_cfront_struct_fields (struct field_info *, struct type *,
// OBSOLETE struct objfile *);
// OBSOLETE static char *get_cfront_method_physname (char *);
// OBSOLETE static int
// OBSOLETE read_cfront_baseclasses (struct field_info *, char **,
// OBSOLETE struct type *, struct objfile *);
// OBSOLETE static int
// OBSOLETE read_cfront_static_fields (struct field_info *, char **,
// OBSOLETE struct type *, struct objfile *);
// OBSOLETE static int
// OBSOLETE read_cfront_member_functions (struct field_info *, char **,
// OBSOLETE struct type *, struct objfile *);
// OBSOLETE /* end new functions added for cfront support */
#endif /* OBSOLETE CFront */
static char *find_name_end (char *name);
@ -497,489 +475,6 @@ read_type_number (char **pp, int *typenums)
#define VISIBILITY_PUBLIC '2' /* Stabs character for public field */
#define VISIBILITY_IGNORE '9' /* Optimized out or zero length */
#if 0 /* OBSOLETE CFront */
// OBSOLETE #define CFRONT_VISIBILITY_PRIVATE '2' /* Stabs character for private field */
// OBSOLETE #define CFRONT_VISIBILITY_PUBLIC '1' /* Stabs character for public field */
// OBSOLETE /* This code added to support parsing of ARM/Cfront stabs strings */
// OBSOLETE /* Get substring from string up to char c, advance string pointer past
// OBSOLETE suibstring. */
// OBSOLETE static char *
// OBSOLETE get_substring (char **p, int c)
// OBSOLETE {
// OBSOLETE char *str;
// OBSOLETE str = *p;
// OBSOLETE *p = strchr (*p, c);
// OBSOLETE if (*p)
// OBSOLETE {
// OBSOLETE **p = 0;
// OBSOLETE (*p)++;
// OBSOLETE }
// OBSOLETE else
// OBSOLETE str = 0;
// OBSOLETE return str;
// OBSOLETE }
// OBSOLETE /* Physname gets strcat'd onto sname in order to recreate the mangled
// OBSOLETE name (see funtion gdb_mangle_name in gdbtypes.c). For cfront, make
// OBSOLETE the physname look like that of g++ - take out the initial mangling
// OBSOLETE eg: for sname="a" and fname="foo__1aFPFs_i" return "FPFs_i" */
// OBSOLETE static char *
// OBSOLETE get_cfront_method_physname (char *fname)
// OBSOLETE {
// OBSOLETE int len = 0;
// OBSOLETE /* FIXME would like to make this generic for g++ too, but
// OBSOLETE that is already handled in read_member_funcctions */
// OBSOLETE char *p = fname;
// OBSOLETE /* search ahead to find the start of the mangled suffix */
// OBSOLETE if (*p == '_' && *(p + 1) == '_') /* compiler generated; probably a ctor/dtor */
// OBSOLETE p += 2;
// OBSOLETE while (p && (unsigned) ((p + 1) - fname) < strlen (fname) && *(p + 1) != '_')
// OBSOLETE p = strchr (p, '_');
// OBSOLETE if (!(p && *p == '_' && *(p + 1) == '_'))
// OBSOLETE error ("Invalid mangled function name %s", fname);
// OBSOLETE p += 2; /* advance past '__' */
// OBSOLETE /* struct name length and name of type should come next; advance past it */
// OBSOLETE while (isdigit (*p))
// OBSOLETE {
// OBSOLETE len = len * 10 + (*p - '0');
// OBSOLETE p++;
// OBSOLETE }
// OBSOLETE p += len;
// OBSOLETE return p;
// OBSOLETE }
// OBSOLETE static void
// OBSOLETE msg_unknown_complaint (const char *arg1)
// OBSOLETE {
// OBSOLETE complaint (&symfile_complaints, "Unsupported token in stabs string %s", arg1);
// OBSOLETE }
// OBSOLETE /* Read base classes within cfront class definition.
// OBSOLETE eg: A:ZcA;1@Bpub v2@Bvirpri;__ct__1AFv func__1AFv *sfunc__1AFv ;as__1A ;;
// OBSOLETE ^^^^^^^^^^^^^^^^^^
// OBSOLETE A:ZcA;;foopri__1AFv foopro__1AFv __ct__1AFv __ct__1AFRC1A foopub__1AFv ;;;
// OBSOLETE ^
// OBSOLETE */
// OBSOLETE static int
// OBSOLETE read_cfront_baseclasses (struct field_info *fip, char **pp, struct type *type,
// OBSOLETE struct objfile *objfile)
// OBSOLETE {
// OBSOLETE int bnum = 0;
// OBSOLETE char *p;
// OBSOLETE int i;
// OBSOLETE struct nextfield *new;
// OBSOLETE if (**pp == ';') /* no base classes; return */
// OBSOLETE {
// OBSOLETE ++(*pp);
// OBSOLETE return 1;
// OBSOLETE }
// OBSOLETE /* first count base classes so we can allocate space before parsing */
// OBSOLETE for (p = *pp; p && *p && *p != ';'; p++)
// OBSOLETE {
// OBSOLETE if (*p == ' ')
// OBSOLETE bnum++;
// OBSOLETE }
// OBSOLETE bnum++; /* add one more for last one */
// OBSOLETE /* now parse the base classes until we get to the start of the methods
// OBSOLETE (code extracted and munged from read_baseclasses) */
// OBSOLETE ALLOCATE_CPLUS_STRUCT_TYPE (type);
// OBSOLETE TYPE_N_BASECLASSES (type) = bnum;
// OBSOLETE /* allocate space */
// OBSOLETE {
// OBSOLETE int num_bytes = B_BYTES (TYPE_N_BASECLASSES (type));
// OBSOLETE char *pointer;
// OBSOLETE pointer = (char *) TYPE_ALLOC (type, num_bytes);
// OBSOLETE TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *) pointer;
// OBSOLETE }
// OBSOLETE B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), TYPE_N_BASECLASSES (type));
// OBSOLETE for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
// OBSOLETE {
// OBSOLETE new = (struct nextfield *) xmalloc (sizeof (struct nextfield));
// OBSOLETE make_cleanup (xfree, new);
// OBSOLETE memset (new, 0, sizeof (struct nextfield));
// OBSOLETE new->next = fip->list;
// OBSOLETE fip->list = new;
// OBSOLETE FIELD_BITSIZE (new->field) = 0; /* this should be an unpacked field! */
// OBSOLETE STABS_CONTINUE (pp, objfile);
// OBSOLETE /* virtual? eg: v2@Bvir */
// OBSOLETE if (**pp == 'v')
// OBSOLETE {
// OBSOLETE SET_TYPE_FIELD_VIRTUAL (type, i);
// OBSOLETE ++(*pp);
// OBSOLETE }
// OBSOLETE /* access? eg: 2@Bvir */
// OBSOLETE /* Note: protected inheritance not supported in cfront */
// OBSOLETE switch (*(*pp)++)
// OBSOLETE {
// OBSOLETE case CFRONT_VISIBILITY_PRIVATE:
// OBSOLETE new->visibility = VISIBILITY_PRIVATE;
// OBSOLETE break;
// OBSOLETE case CFRONT_VISIBILITY_PUBLIC:
// OBSOLETE new->visibility = VISIBILITY_PUBLIC;
// OBSOLETE break;
// OBSOLETE default:
// OBSOLETE /* Bad visibility format. Complain and treat it as
// OBSOLETE public. */
// OBSOLETE {
// OBSOLETE complaint (&symfile_complaints,
// OBSOLETE "Unknown visibility `%c' for baseclass",
// OBSOLETE new->visibility);
// OBSOLETE new->visibility = VISIBILITY_PUBLIC;
// OBSOLETE }
// OBSOLETE }
// OBSOLETE /* "@" comes next - eg: @Bvir */
// OBSOLETE if (**pp != '@')
// OBSOLETE {
// OBSOLETE msg_unknown_complaint (*pp);
// OBSOLETE return 1;
// OBSOLETE }
// OBSOLETE ++(*pp);
// OBSOLETE /* Set the bit offset of the portion of the object corresponding
// OBSOLETE to this baseclass. Always zero in the absence of
// OBSOLETE multiple inheritance. */
// OBSOLETE /* Unable to read bit position from stabs;
// OBSOLETE Assuming no multiple inheritance for now FIXME! */
// OBSOLETE /* We may have read this in the structure definition;
// OBSOLETE now we should fixup the members to be the actual base classes */
// OBSOLETE FIELD_BITPOS (new->field) = 0;
// OBSOLETE /* Get the base class name and type */
// OBSOLETE {
// OBSOLETE char *bname; /* base class name */
// OBSOLETE struct symbol *bsym; /* base class */
// OBSOLETE char *p1, *p2;
// OBSOLETE p1 = strchr (*pp, ' ');
// OBSOLETE p2 = strchr (*pp, ';');
// OBSOLETE if (p1 < p2)
// OBSOLETE bname = get_substring (pp, ' ');
// OBSOLETE else
// OBSOLETE bname = get_substring (pp, ';');
// OBSOLETE if (!bname || !*bname)
// OBSOLETE {
// OBSOLETE msg_unknown_complaint (*pp);
// OBSOLETE return 1;
// OBSOLETE }
// OBSOLETE /* FIXME! attach base info to type */
// OBSOLETE bsym = lookup_symbol (bname, 0, STRUCT_DOMAIN, 0, 0); /*demangled_name */
// OBSOLETE if (bsym)
// OBSOLETE {
// OBSOLETE new->field.type = SYMBOL_TYPE (bsym);
// OBSOLETE new->field.name = type_name_no_tag (new->field.type);
// OBSOLETE }
// OBSOLETE else
// OBSOLETE {
// OBSOLETE complaint (&symfile_complaints, "Unable to find base type for %s",
// OBSOLETE *pp);
// OBSOLETE return 1;
// OBSOLETE }
// OBSOLETE }
// OBSOLETE /* If more base classes to parse, loop again.
// OBSOLETE We ate the last ' ' or ';' in get_substring,
// OBSOLETE so on exit we will have skipped the trailing ';' */
// OBSOLETE /* if invalid, return 0; add code to detect - FIXME! */
// OBSOLETE }
// OBSOLETE return 1;
// OBSOLETE }
// OBSOLETE /* read cfront member functions.
// OBSOLETE pp points to string starting with list of functions
// OBSOLETE eg: A:ZcA;1@Bpub v2@Bvirpri;__ct__1AFv func__1AFv *sfunc__1AFv ;as__1A ;;
// OBSOLETE ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// OBSOLETE A:ZcA;;foopri__1AFv foopro__1AFv __ct__1AFv __ct__1AFRC1A foopub__1AFv ;;;
// OBSOLETE ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// OBSOLETE */
// OBSOLETE static int
// OBSOLETE read_cfront_member_functions (struct field_info *fip, char **pp,
// OBSOLETE struct type *type, struct objfile *objfile)
// OBSOLETE {
// OBSOLETE /* This code extracted from read_member_functions
// OBSOLETE so as to do the similar thing for our funcs */
// OBSOLETE int nfn_fields = 0;
// OBSOLETE int length = 0;
// OBSOLETE /* Total number of member functions defined in this class. If the class
// OBSOLETE defines two `f' functions, and one `g' function, then this will have
// OBSOLETE the value 3. */
// OBSOLETE int total_length = 0;
// OBSOLETE int i;
// OBSOLETE struct next_fnfield
// OBSOLETE {
// OBSOLETE struct next_fnfield *next;
// OBSOLETE struct fn_field fn_field;
// OBSOLETE }
// OBSOLETE *sublist;
// OBSOLETE struct type *look_ahead_type;
// OBSOLETE struct next_fnfieldlist *new_fnlist;
// OBSOLETE struct next_fnfield *new_sublist;
// OBSOLETE char *main_fn_name;
// OBSOLETE char *fname;
// OBSOLETE struct symbol *ref_func = 0;
// OBSOLETE /* Process each list until we find the end of the member functions.
// OBSOLETE eg: p = "__ct__1AFv foo__1AFv ;;;" */
// OBSOLETE STABS_CONTINUE (pp, objfile); /* handle \\ */
// OBSOLETE while (**pp != ';' && (fname = get_substring (pp, ' '), fname))
// OBSOLETE {
// OBSOLETE int is_static = 0;
// OBSOLETE int sublist_count = 0;
// OBSOLETE char *pname;
// OBSOLETE if (fname[0] == '*') /* static member */
// OBSOLETE {
// OBSOLETE is_static = 1;
// OBSOLETE sublist_count++;
// OBSOLETE fname++;
// OBSOLETE }
// OBSOLETE ref_func = lookup_symbol (fname, 0, VAR_DOMAIN, 0, 0); /* demangled name */
// OBSOLETE if (!ref_func)
// OBSOLETE {
// OBSOLETE complaint (&symfile_complaints,
// OBSOLETE "Unable to find function symbol for %s", fname);
// OBSOLETE continue;
// OBSOLETE }
// OBSOLETE sublist = NULL;
// OBSOLETE look_ahead_type = NULL;
// OBSOLETE length = 0;
// OBSOLETE new_fnlist = (struct next_fnfieldlist *)
// OBSOLETE xmalloc (sizeof (struct next_fnfieldlist));
// OBSOLETE make_cleanup (xfree, new_fnlist);
// OBSOLETE memset (new_fnlist, 0, sizeof (struct next_fnfieldlist));
// OBSOLETE /* The following is code to work around cfront generated stabs.
// OBSOLETE The stabs contains full mangled name for each field.
// OBSOLETE We try to demangle the name and extract the field name out of it. */
// OBSOLETE {
// OBSOLETE char *dem, *dem_p, *dem_args;
// OBSOLETE int dem_len;
// OBSOLETE dem = cplus_demangle (fname, DMGL_ANSI | DMGL_PARAMS);
// OBSOLETE if (dem != NULL)
// OBSOLETE {
// OBSOLETE dem_p = strrchr (dem, ':');
// OBSOLETE if (dem_p != 0 && *(dem_p - 1) == ':')
// OBSOLETE dem_p++;
// OBSOLETE /* get rid of args */
// OBSOLETE dem_args = strchr (dem_p, '(');
// OBSOLETE if (dem_args == NULL)
// OBSOLETE dem_len = strlen (dem_p);
// OBSOLETE else
// OBSOLETE dem_len = dem_args - dem_p;
// OBSOLETE main_fn_name =
// OBSOLETE obsavestring (dem_p, dem_len, &objfile->type_obstack);
// OBSOLETE }
// OBSOLETE else
// OBSOLETE {
// OBSOLETE main_fn_name =
// OBSOLETE obsavestring (fname, strlen (fname), &objfile->type_obstack);
// OBSOLETE }
// OBSOLETE } /* end of code for cfront work around */
// OBSOLETE new_fnlist->fn_fieldlist.name = main_fn_name;
// OBSOLETE /*-------------------------------------------------*/
// OBSOLETE /* Set up the sublists
// OBSOLETE Sublists are stuff like args, static, visibility, etc.
// OBSOLETE so in ARM, we have to set that info some other way.
// OBSOLETE Multiple sublists happen if overloading
// OBSOLETE eg: foo::26=##1;:;2A.;
// OBSOLETE In g++, we'd loop here thru all the sublists... */
// OBSOLETE new_sublist =
// OBSOLETE (struct next_fnfield *) xmalloc (sizeof (struct next_fnfield));
// OBSOLETE make_cleanup (xfree, new_sublist);
// OBSOLETE memset (new_sublist, 0, sizeof (struct next_fnfield));
// OBSOLETE /* eat 1; from :;2A.; */
// OBSOLETE new_sublist->fn_field.type = SYMBOL_TYPE (ref_func); /* normally takes a read_type */
// OBSOLETE /* Make this type look like a method stub for gdb */
// OBSOLETE TYPE_FLAGS (new_sublist->fn_field.type) |= TYPE_FLAG_STUB;
// OBSOLETE TYPE_CODE (new_sublist->fn_field.type) = TYPE_CODE_METHOD;
// OBSOLETE /* If this is just a stub, then we don't have the real name here. */
// OBSOLETE if (TYPE_STUB (new_sublist->fn_field.type))
// OBSOLETE {
// OBSOLETE if (!TYPE_DOMAIN_TYPE (new_sublist->fn_field.type))
// OBSOLETE TYPE_DOMAIN_TYPE (new_sublist->fn_field.type) = type;
// OBSOLETE new_sublist->fn_field.is_stub = 1;
// OBSOLETE }
// OBSOLETE /* physname used later in mangling; eg PFs_i,5 for foo__1aFPFs_i
// OBSOLETE physname gets strcat'd in order to recreate the onto mangled name */
// OBSOLETE pname = get_cfront_method_physname (fname);
// OBSOLETE new_sublist->fn_field.physname = savestring (pname, strlen (pname));
// OBSOLETE /* Set this member function's visibility fields.
// OBSOLETE Unable to distinguish access from stabs definition!
// OBSOLETE Assuming public for now. FIXME!
// OBSOLETE (for private, set new_sublist->fn_field.is_private = 1,
// OBSOLETE for public, set new_sublist->fn_field.is_protected = 1) */
// OBSOLETE /* Unable to distinguish const/volatile from stabs definition!
// OBSOLETE Assuming normal for now. FIXME! */
// OBSOLETE new_sublist->fn_field.is_const = 0;
// OBSOLETE new_sublist->fn_field.is_volatile = 0; /* volatile not implemented in cfront */
// OBSOLETE /* Set virtual/static function info
// OBSOLETE How to get vtable offsets ?
// OBSOLETE Assuming normal for now FIXME!!
// OBSOLETE For vtables, figure out from whence this virtual function came.
// OBSOLETE It may belong to virtual function table of
// OBSOLETE one of its baseclasses.
// OBSOLETE set:
// OBSOLETE new_sublist -> fn_field.voffset = vtable offset,
// OBSOLETE new_sublist -> fn_field.fcontext = look_ahead_type;
// OBSOLETE where look_ahead_type is type of baseclass */
// OBSOLETE if (is_static)
// OBSOLETE new_sublist->fn_field.voffset = VOFFSET_STATIC;
// OBSOLETE else /* normal member function. */
// OBSOLETE new_sublist->fn_field.voffset = 0;
// OBSOLETE new_sublist->fn_field.fcontext = 0;
// OBSOLETE /* Prepare new sublist */
// OBSOLETE new_sublist->next = sublist;
// OBSOLETE sublist = new_sublist;
// OBSOLETE length++;
// OBSOLETE /* In g++, we loop thu sublists - now we set from functions. */
// OBSOLETE new_fnlist->fn_fieldlist.fn_fields = (struct fn_field *)
// OBSOLETE obstack_alloc (&objfile->type_obstack,
// OBSOLETE sizeof (struct fn_field) * length);
// OBSOLETE memset (new_fnlist->fn_fieldlist.fn_fields, 0,
// OBSOLETE sizeof (struct fn_field) * length);
// OBSOLETE for (i = length; (i--, sublist); sublist = sublist->next)
// OBSOLETE {
// OBSOLETE new_fnlist->fn_fieldlist.fn_fields[i] = sublist->fn_field;
// OBSOLETE }
// OBSOLETE new_fnlist->fn_fieldlist.length = length;
// OBSOLETE new_fnlist->next = fip->fnlist;
// OBSOLETE fip->fnlist = new_fnlist;
// OBSOLETE nfn_fields++;
// OBSOLETE total_length += length;
// OBSOLETE STABS_CONTINUE (pp, objfile); /* handle \\ */
// OBSOLETE } /* end of loop */
// OBSOLETE if (nfn_fields)
// OBSOLETE {
// OBSOLETE /* type should already have space */
// OBSOLETE TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
// OBSOLETE TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * nfn_fields);
// OBSOLETE memset (TYPE_FN_FIELDLISTS (type), 0,
// OBSOLETE sizeof (struct fn_fieldlist) * nfn_fields);
// OBSOLETE TYPE_NFN_FIELDS (type) = nfn_fields;
// OBSOLETE TYPE_NFN_FIELDS_TOTAL (type) = total_length;
// OBSOLETE }
// OBSOLETE /* end of scope for reading member func */
// OBSOLETE /* eg: ";;" */
// OBSOLETE /* Skip trailing ';' and bump count of number of fields seen */
// OBSOLETE if (**pp == ';')
// OBSOLETE (*pp)++;
// OBSOLETE else
// OBSOLETE return 0;
// OBSOLETE return 1;
// OBSOLETE }
// OBSOLETE /* This routine fixes up partial cfront types that were created
// OBSOLETE while parsing the stabs. The main need for this function is
// OBSOLETE to add information such as methods to classes.
// OBSOLETE Examples of "p": "sA;;__ct__1AFv foo__1AFv ;;;" */
// OBSOLETE int
// OBSOLETE resolve_cfront_continuation (struct objfile *objfile, struct symbol *sym,
// OBSOLETE char *p)
// OBSOLETE {
// OBSOLETE struct symbol *ref_sym = 0;
// OBSOLETE char *sname;
// OBSOLETE /* snarfed from read_struct_type */
// OBSOLETE struct field_info fi;
// OBSOLETE struct type *type;
// OBSOLETE struct cleanup *back_to;
// OBSOLETE /* Need to make sure that fi isn't gunna conflict with struct
// OBSOLETE in case struct already had some fnfs */
// OBSOLETE fi.list = NULL;
// OBSOLETE fi.fnlist = NULL;
// OBSOLETE back_to = make_cleanup (null_cleanup, 0);
// OBSOLETE /* We only accept structs, classes and unions at the moment.
// OBSOLETE Other continuation types include t (typedef), r (long dbl), ...
// OBSOLETE We may want to add support for them as well;
// OBSOLETE right now they are handled by duplicating the symbol information
// OBSOLETE into the type information (see define_symbol) */
// OBSOLETE if (*p != 's' /* structs */
// OBSOLETE && *p != 'c' /* class */
// OBSOLETE && *p != 'u') /* union */
// OBSOLETE return 0; /* only handle C++ types */
// OBSOLETE p++;
// OBSOLETE /* Get symbol typs name and validate
// OBSOLETE eg: p = "A;;__ct__1AFv foo__1AFv ;;;" */
// OBSOLETE sname = get_substring (&p, ';');
// OBSOLETE if (!sname || strcmp (sname, DEPRECATED_SYMBOL_NAME (sym)))
// OBSOLETE error ("Internal error: base symbol type name does not match\n");
// OBSOLETE /* Find symbol's internal gdb reference using demangled_name.
// OBSOLETE This is the real sym that we want;
// OBSOLETE sym was a temp hack to make debugger happy */
// OBSOLETE ref_sym = lookup_symbol (DEPRECATED_SYMBOL_NAME (sym), 0, STRUCT_DOMAIN, 0, 0);
// OBSOLETE type = SYMBOL_TYPE (ref_sym);
// OBSOLETE /* Now read the baseclasses, if any, read the regular C struct or C++
// OBSOLETE class member fields, attach the fields to the type, read the C++
// OBSOLETE member functions, attach them to the type, and then read any tilde
// OBSOLETE field (baseclass specifier for the class holding the main vtable). */
// OBSOLETE if (!read_cfront_baseclasses (&fi, &p, type, objfile)
// OBSOLETE /* g++ does this next, but cfront already did this:
// OBSOLETE || !read_struct_fields (&fi, &p, type, objfile) */
// OBSOLETE || !copy_cfront_struct_fields (&fi, type, objfile)
// OBSOLETE || !read_cfront_member_functions (&fi, &p, type, objfile)
// OBSOLETE || !read_cfront_static_fields (&fi, &p, type, objfile)
// OBSOLETE || !attach_fields_to_type (&fi, type, objfile)
// OBSOLETE || !attach_fn_fields_to_type (&fi, type)
// OBSOLETE /* g++ does this next, but cfront doesn't seem to have this:
// OBSOLETE || !read_tilde_fields (&fi, &p, type, objfile) */
// OBSOLETE )
// OBSOLETE {
// OBSOLETE type = error_type (&p, objfile);
// OBSOLETE }
// OBSOLETE do_cleanups (back_to);
// OBSOLETE return 0;
// OBSOLETE }
// OBSOLETE /* End of code added to support parsing of ARM/Cfront stabs strings */
#endif /* OBSOLETE CFront */
/* This routine fixes up symbol references/aliases to point to the original
symbol definition. Returns 0 on failure, non-zero on success. */
@ -1910,15 +1405,6 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
if (synonym)
p++;
#if 0 /* OBSOLETE CFront */
// OBSOLETE /* The semantics of C++ state that "struct foo { ... }" also defines
// OBSOLETE a typedef for "foo". Unfortunately, cfront never makes the typedef
// OBSOLETE when translating C++ into C. We make the typedef here so that
// OBSOLETE "ptype foo" works as expected for cfront translated code. */
// OBSOLETE else if ((current_subfile->language == language_cplus)
// OBSOLETE || (current_subfile->language == language_objc))
// OBSOLETE synonym = 1;
#endif /* OBSOLETE CFront */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
@ -2008,32 +1494,6 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
add_symbol_to_list (sym, &local_symbols);
break;
#if 0 /* OBSOLETE CFront */
// OBSOLETE /* New code added to support cfront stabs strings.
// OBSOLETE Note: case 'P' already handled above */
// OBSOLETE case 'Z':
// OBSOLETE /* Cfront type continuation coming up!
// OBSOLETE Find the original definition and add to it.
// OBSOLETE We'll have to do this for the typedef too,
// OBSOLETE since we cloned the symbol to define a type in read_type.
// OBSOLETE Stabs info examples:
// OBSOLETE __1C :Ztl
// OBSOLETE foo__1CFv :ZtF (first def foo__1CFv:F(0,3);(0,24))
// OBSOLETE C:ZsC;;__ct__1CFv func1__1CFv func2__1CFv ... ;;;
// OBSOLETE where C is the name of the class.
// OBSOLETE Unfortunately, we can't lookup the original symbol yet 'cuz
// OBSOLETE we haven't finished reading all the symbols.
// OBSOLETE Instead, we save it for processing later */
// OBSOLETE process_later (sym, p, resolve_cfront_continuation);
// OBSOLETE SYMBOL_TYPE (sym) = error_type (&p, objfile); /* FIXME! change later */
// OBSOLETE SYMBOL_CLASS (sym) = LOC_CONST;
// OBSOLETE SYMBOL_VALUE (sym) = 0;
// OBSOLETE SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
// OBSOLETE /* Don't add to list - we'll delete it later when
// OBSOLETE we add the continuation to the real sym */
// OBSOLETE return sym;
// OBSOLETE /* End of new code added to support cfront stabs strings */
#endif /* OBSOLETE CFront */
default:
SYMBOL_TYPE (sym) = error_type (&p, objfile);
@ -3547,39 +3007,8 @@ static void
read_one_struct_field (struct field_info *fip, char **pp, char *p,
struct type *type, struct objfile *objfile)
{
#if 0 /* OBSOLETE CFront */
// OBSOLETE /* The following is code to work around cfront generated stabs.
// OBSOLETE The stabs contains full mangled name for each field.
// OBSOLETE We try to demangle the name and extract the field name out of it.
// OBSOLETE */
// OBSOLETE if (ARM_DEMANGLING && current_subfile->language == language_cplus)
// OBSOLETE {
// OBSOLETE char save_p;
// OBSOLETE char *dem, *dem_p;
// OBSOLETE save_p = *p;
// OBSOLETE *p = '\0';
// OBSOLETE dem = cplus_demangle (*pp, DMGL_ANSI | DMGL_PARAMS);
// OBSOLETE if (dem != NULL)
// OBSOLETE {
// OBSOLETE dem_p = strrchr (dem, ':');
// OBSOLETE if (dem_p != 0 && *(dem_p - 1) == ':')
// OBSOLETE dem_p++;
// OBSOLETE FIELD_NAME (fip->list->field) =
// OBSOLETE obsavestring (dem_p, strlen (dem_p), &objfile->type_obstack);
// OBSOLETE }
// OBSOLETE else
// OBSOLETE {
// OBSOLETE FIELD_NAME (fip->list->field) =
// OBSOLETE obsavestring (*pp, p - *pp, &objfile->type_obstack);
// OBSOLETE }
// OBSOLETE *p = save_p;
// OBSOLETE }
// OBSOLETE /* end of code for cfront work around */
// OBSOLETE else
#endif /* OBSOLETE CFront */
fip->list->field.name =
obsavestring (*pp, p - *pp, &objfile->type_obstack);
fip->list->field.name =
obsavestring (*pp, p - *pp, &objfile->type_obstack);
*pp = p + 1;
/* This means we have a visibility for a field coming. */
@ -4030,138 +3459,6 @@ attach_fn_fields_to_type (struct field_info *fip, struct type *type)
return 1;
}
#if 0 /* OBSOLETE CFront */
// OBSOLETE /* read cfront class static data.
// OBSOLETE pp points to string starting with the list of static data
// OBSOLETE eg: A:ZcA;1@Bpub v2@Bvirpri;__ct__1AFv func__1AFv *sfunc__1AFv ;as__1A ;;
// OBSOLETE ^^^^^^^^
// OBSOLETE A:ZcA;;foopri__1AFv foopro__1AFv __ct__1AFv __ct__1AFRC1A foopub__1AFv ;;;
// OBSOLETE ^
// OBSOLETE */
// OBSOLETE static int
// OBSOLETE read_cfront_static_fields (struct field_info *fip, char **pp, struct type *type,
// OBSOLETE struct objfile *objfile)
// OBSOLETE {
// OBSOLETE struct nextfield *new;
// OBSOLETE struct type *stype;
// OBSOLETE char *sname;
// OBSOLETE struct symbol *ref_static = 0;
// OBSOLETE if (**pp == ';') /* no static data; return */
// OBSOLETE {
// OBSOLETE ++(*pp);
// OBSOLETE return 1;
// OBSOLETE }
// OBSOLETE /* Process each field in the list until we find the terminating ";" */
// OBSOLETE /* eg: p = "as__1A ;;;" */
// OBSOLETE STABS_CONTINUE (pp, objfile); /* handle \\ */
// OBSOLETE while (**pp != ';' && (sname = get_substring (pp, ' '), sname))
// OBSOLETE {
// OBSOLETE ref_static = lookup_symbol (sname, 0, VAR_DOMAIN, 0, 0); /*demangled_name */
// OBSOLETE if (!ref_static)
// OBSOLETE {
// OBSOLETE complaint (&symfile_complaints,
// OBSOLETE "Unable to find symbol for static data field %s", sname);
// OBSOLETE continue;
// OBSOLETE }
// OBSOLETE stype = SYMBOL_TYPE (ref_static);
// OBSOLETE /* allocate a new fip */
// OBSOLETE new = (struct nextfield *) xmalloc (sizeof (struct nextfield));
// OBSOLETE make_cleanup (xfree, new);
// OBSOLETE memset (new, 0, sizeof (struct nextfield));
// OBSOLETE new->next = fip->list;
// OBSOLETE fip->list = new;
// OBSOLETE /* set visibility */
// OBSOLETE /* FIXME! no way to tell visibility from stabs??? */
// OBSOLETE new->visibility = VISIBILITY_PUBLIC;
// OBSOLETE /* set field info into fip */
// OBSOLETE fip->list->field.type = stype;
// OBSOLETE /* set bitpos & bitsize */
// OBSOLETE SET_FIELD_PHYSNAME (fip->list->field, savestring (sname, strlen (sname)));
// OBSOLETE /* set name field */
// OBSOLETE /* The following is code to work around cfront generated stabs.
// OBSOLETE The stabs contains full mangled name for each field.
// OBSOLETE We try to demangle the name and extract the field name out of it.
// OBSOLETE */
// OBSOLETE if (ARM_DEMANGLING)
// OBSOLETE {
// OBSOLETE char *dem, *dem_p;
// OBSOLETE dem = cplus_demangle (sname, DMGL_ANSI | DMGL_PARAMS);
// OBSOLETE if (dem != NULL)
// OBSOLETE {
// OBSOLETE dem_p = strrchr (dem, ':');
// OBSOLETE if (dem_p != 0 && *(dem_p - 1) == ':')
// OBSOLETE dem_p++;
// OBSOLETE fip->list->field.name =
// OBSOLETE obsavestring (dem_p, strlen (dem_p), &objfile->type_obstack);
// OBSOLETE }
// OBSOLETE else
// OBSOLETE {
// OBSOLETE fip->list->field.name =
// OBSOLETE obsavestring (sname, strlen (sname), &objfile->type_obstack);
// OBSOLETE }
// OBSOLETE } /* end of code for cfront work around */
// OBSOLETE } /* loop again for next static field */
// OBSOLETE return 1;
// OBSOLETE }
// OBSOLETE /* Copy structure fields to fip so attach_fields_to_type will work.
// OBSOLETE type has already been created with the initial instance data fields.
// OBSOLETE Now we want to be able to add the other members to the class,
// OBSOLETE so we want to add them back to the fip and reattach them again
// OBSOLETE once we have collected all the class members. */
// OBSOLETE static int
// OBSOLETE copy_cfront_struct_fields (struct field_info *fip, struct type *type,
// OBSOLETE struct objfile *objfile)
// OBSOLETE {
// OBSOLETE int nfields = TYPE_NFIELDS (type);
// OBSOLETE int i;
// OBSOLETE struct nextfield *new;
// OBSOLETE /* Copy the fields into the list of fips and reset the types
// OBSOLETE to remove the old fields */
// OBSOLETE for (i = 0; i < nfields; i++)
// OBSOLETE {
// OBSOLETE /* allocate a new fip */
// OBSOLETE new = (struct nextfield *) xmalloc (sizeof (struct nextfield));
// OBSOLETE make_cleanup (xfree, new);
// OBSOLETE memset (new, 0, sizeof (struct nextfield));
// OBSOLETE new->next = fip->list;
// OBSOLETE fip->list = new;
// OBSOLETE /* copy field info into fip */
// OBSOLETE new->field = TYPE_FIELD (type, i);
// OBSOLETE /* set visibility */
// OBSOLETE if (TYPE_FIELD_PROTECTED (type, i))
// OBSOLETE new->visibility = VISIBILITY_PROTECTED;
// OBSOLETE else if (TYPE_FIELD_PRIVATE (type, i))
// OBSOLETE new->visibility = VISIBILITY_PRIVATE;
// OBSOLETE else
// OBSOLETE new->visibility = VISIBILITY_PUBLIC;
// OBSOLETE }
// OBSOLETE /* Now delete the fields from the type since we will be
// OBSOLETE allocing new space once we get the rest of the fields
// OBSOLETE in attach_fields_to_type.
// OBSOLETE The pointer TYPE_FIELDS(type) is left dangling but should
// OBSOLETE be freed later by objstack_free */
// OBSOLETE TYPE_FIELDS (type) = 0;
// OBSOLETE TYPE_NFIELDS (type) = 0;
// OBSOLETE return 1;
// OBSOLETE }
#endif /* OBSOLETE CFront */
/* Create the vector of fields, and record how big it is.
We need this info to record proper virtual function table information
for this class's virtual functions. */

10
gdb/stabsread.h
View file

@ -194,22 +194,12 @@ extern void stabsect_build_psymtabs
extern void elfstab_offset_sections (struct objfile *,
struct partial_symtab *);
#if 0 /* OBSOLETE CFront */
// OBSOLETE extern void process_later
// OBSOLETE (struct symbol *, char *,
// OBSOLETE int (*f) (struct objfile *, struct symbol *, char *));
#endif /* OBSOLETE CFront */
extern int symbol_reference_defined (char **);
extern void ref_add (int, struct symbol *, char *, CORE_ADDR);
extern struct symbol *ref_search (int);
#if 0 /* OBSOLETE CFront */
// OBSOLETE extern int resolve_cfront_continuation
// OBSOLETE (struct objfile *objfile, struct symbol *sym, char *p);
#endif /* OBSOLETE CFront */
extern void free_header_files (void);
extern void init_header_files (void);

21
gdb/xcoffread.c
View file

@ -2635,22 +2635,6 @@ scan_xcoff_symtab (struct objfile *objfile)
psymtab_language, objfile);
p += 1;
}
#if 0 /* OBSOLETE CFront */
// OBSOLETE /* The semantics of C++ state that "struct foo { ... }"
// OBSOLETE also defines a typedef for "foo". Unfortuantely, cfront
// OBSOLETE never makes the typedef when translating from C++ to C.
// OBSOLETE We make the typedef here so that "ptype foo" works as
// OBSOLETE expected for cfront translated code. */
// OBSOLETE else if (psymtab_language == language_cplus)
// OBSOLETE {
// OBSOLETE /* Also a typedef with the same name. */
// OBSOLETE add_psymbol_to_list (namestring, p - namestring,
// OBSOLETE VAR_DOMAIN, LOC_TYPEDEF,
// OBSOLETE &objfile->static_psymbols,
// OBSOLETE symbol.n_value, 0,
// OBSOLETE psymtab_language, objfile);
// OBSOLETE }
#endif /* OBSOLETE CFront */
}
goto check_enum;
@ -2799,11 +2783,6 @@ scan_xcoff_symtab (struct objfile *objfile)
case '9':
case '-':
case '#': /* for symbol identification (used in live ranges) */
#if 0 /* OBSOLETE CFront */
// OBSOLETE /* added to support cfront stabs strings */
// OBSOLETE case 'Z': /* for definition continuations */
// OBSOLETE case 'P': /* for prototypes */
#endif /* OBSOLETE CFront */
continue;
case ':':