From: Elena Zannoni Date: Tue, 14 Jan 2003 00:15:05 +0000 (+0000) Subject: 2003-01-13 Elena Zannoni X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=25caa7a88bd2a350f5b93c30b18be0e13cb31906;p=binutils-gdb.git 2003-01-13 Elena Zannoni * stabsread.h (process_later, resolve_cfront_continuation): Obsolete. Update copyright years. * buildsym.c (start_subfile): Obsolete comment pertinent to Cfront. Update copyright year. * dbxread.c(struct cont_elem): Obsolete. (process_later, process_now): Obsolete functions. (read_dbx_symtab, read_ofile_symtab): Obsolete cfront support. Update copyright year. * gdbtypes.c (INIT_EXTRA, ADD_EXTRA): Obsolete macros. (add_name, add_mangled_type, cfront_mangle_name): Obsolete functions. * mdebugread.c (parse_type): Obsolete comment pertinent to Cfront. (parse_partial_symbols): Obsolete cfront support. * stabsread.c (CFRONT_VISIBILITY_PRIVATE,CFRONT_VISIBILITY_PUBLIC): Obsolete macros. (get_substring, get_cfront_method_physname, msg_unknown_complaint, read_cfront_baseclasses, read_cfront_member_functions, resolve_cfront_continuation,read_cfront_static_fields, copy_cfront_struct_fields): Obsolete functions. (define_symbol, read_one_struct_field): Obsolete cfront support. * xcoffread.c (scan_xcoff_symtab): Obsolete CFront support. Update Copyright year. --- diff --git a/gdb/ChangeLog b/gdb/ChangeLog index e3cc093f6ec..eb43b38b4ae 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,29 @@ +2003-01-13 Elena Zannoni + + * stabsread.h (process_later, resolve_cfront_continuation): + Obsolete. + Update copyright years. + * buildsym.c (start_subfile): Obsolete comment pertinent to Cfront. + Update copyright year. + * dbxread.c(struct cont_elem): Obsolete. + (process_later, process_now): Obsolete functions. + (read_dbx_symtab, read_ofile_symtab): Obsolete cfront support. + Update copyright year. + * gdbtypes.c (INIT_EXTRA, ADD_EXTRA): Obsolete macros. + (add_name, add_mangled_type, cfront_mangle_name): Obsolete functions. + * mdebugread.c (parse_type): Obsolete comment pertinent to Cfront. + (parse_partial_symbols): Obsolete cfront support. + * stabsread.c + (CFRONT_VISIBILITY_PRIVATE,CFRONT_VISIBILITY_PUBLIC): Obsolete + macros. + (get_substring, get_cfront_method_physname, msg_unknown_complaint, + read_cfront_baseclasses, read_cfront_member_functions, + resolve_cfront_continuation,read_cfront_static_fields, + copy_cfront_struct_fields): Obsolete functions. + (define_symbol, read_one_struct_field): Obsolete cfront support. + * xcoffread.c (scan_xcoff_symtab): Obsolete CFront support. + Update Copyright year. + 2003-01-13 Elena Zannoni * stack.c (print_frame_info, print_stack_frame_base_stub, diff --git a/gdb/buildsym.c b/gdb/buildsym.c index eabf8a83670..5e9ac84b4e3 100644 --- a/gdb/buildsym.c +++ b/gdb/buildsym.c @@ -1,6 +1,7 @@ /* Support routines for building symbol tables in GDB's internal format. Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, - 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc. + 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 + Free Software Foundation, Inc. This file is part of GDB. @@ -609,15 +610,17 @@ start_subfile (char *name, char *dirname) later via a call to record_debugformat. */ subfile->debugformat = NULL; - /* cfront output is a C program, so in most ways it looks like a C - program. But to demangle we need to set the language to C++. We - can distinguish cfront code by the fact that it has #line - directives which specify a file name ending in .C. - - So if the filename of this subfile ends in .C, then change the +#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 - (in particular, some people use .cxx with cfront). */ + 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) diff --git a/gdb/dbxread.c b/gdb/dbxread.c index 4fcb96889ed..3e6e034b829 100644 --- a/gdb/dbxread.c +++ b/gdb/dbxread.c @@ -1,6 +1,6 @@ /* Read dbx symbol tables and convert to internal format, for GDB. Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, - 1996, 1997, 1998, 1999, 2000, 2001, 2002 + 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003. Free Software Foundation, Inc. This file is part of GDB. @@ -257,7 +257,9 @@ static int bincls_allocated; extern void _initialize_dbxread (void); -static void process_now (struct objfile *); +#if 0 /* OBSOLETE CFront */ +// OBSOLETE static void process_now (struct objfile *); +#endif /* OBSOLETE CFront */ static void read_ofile_symtab (struct partial_symtab *); @@ -770,105 +772,106 @@ static struct external_nlist symbuf[4096]; static int symbuf_idx; static int symbuf_end; -/* cont_elem is used for continuing information in cfront. - It saves information about which types need to be fixed up and - completed after all the stabs are read. */ -struct cont_elem - { - /* sym and stabstring for continuing information in cfront */ - struct symbol *sym; - char *stabs; - /* state dependencies (statics that must be preserved) */ - int sym_idx; - int sym_end; - int symnum; - int (*func) (struct objfile *, struct symbol *, char *); - /* other state dependencies include: - (assumption is that these will not change since process_now FIXME!!) - stringtab_global - n_stabs - objfile - symfile_bfd */ - }; - -static struct cont_elem *cont_list = 0; -static int cont_limit = 0; -static int cont_count = 0; - -/* Arrange for function F to be called with arguments SYM and P later - in the stabs reading process. */ -void -process_later (struct symbol *sym, char *p, - int (*f) (struct objfile *, struct symbol *, char *)) -{ - - /* Allocate more space for the deferred list. */ - if (cont_count >= cont_limit - 1) - { - cont_limit += 32; /* chunk size */ - - cont_list - = (struct cont_elem *) xrealloc (cont_list, - (cont_limit - * sizeof (struct cont_elem))); - if (!cont_list) - error ("Virtual memory exhausted\n"); - } - - /* Save state variables so we can process these stabs later. */ - cont_list[cont_count].sym_idx = symbuf_idx; - cont_list[cont_count].sym_end = symbuf_end; - cont_list[cont_count].symnum = symnum; - cont_list[cont_count].sym = sym; - cont_list[cont_count].stabs = p; - cont_list[cont_count].func = f; - cont_count++; -} - -/* Call deferred funtions in CONT_LIST. */ - -static void -process_now (struct objfile *objfile) -{ - int i; - int save_symbuf_idx; - int save_symbuf_end; - int save_symnum; - struct symbol *sym; - char *stabs; - int err; - int (*func) (struct objfile *, struct symbol *, char *); - - /* Save the state of our caller, we'll want to restore it before - returning. */ - save_symbuf_idx = symbuf_idx; - save_symbuf_end = symbuf_end; - save_symnum = symnum; - - /* Iterate over all the deferred stabs. */ - for (i = 0; i < cont_count; i++) - { - /* Restore the state for this deferred stab. */ - symbuf_idx = cont_list[i].sym_idx; - symbuf_end = cont_list[i].sym_end; - symnum = cont_list[i].symnum; - sym = cont_list[i].sym; - stabs = cont_list[i].stabs; - func = cont_list[i].func; - - /* Call the function to handle this deferrd stab. */ - err = (*func) (objfile, sym, stabs); - if (err) - error ("Internal error: unable to resolve stab.\n"); - } - - /* Restore our caller's state. */ - symbuf_idx = save_symbuf_idx; - symbuf_end = save_symbuf_end; - symnum = save_symnum; - cont_count = 0; -} - +#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. */ @@ -1775,20 +1778,22 @@ read_dbx_symtab (struct objfile *objfile) psymtab_language, objfile); p += 1; } - /* The semantics of C++ state that "struct foo { ... }" - also defines a typedef for "foo". Unfortuantely, cfront - never makes the typedef when translating from C++ to C. - We make the typedef here so that "ptype foo" works as - expected for cfront translated code. */ - else if (psymtab_language == language_cplus) - { - /* Also a typedef with the same name. */ - add_psymbol_to_list (namestring, p - namestring, - VAR_NAMESPACE, LOC_TYPEDEF, - &objfile->static_psymbols, - nlist.n_value, 0, - psymtab_language, objfile); - } +#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_NAMESPACE, LOC_TYPEDEF, +// OBSOLETE &objfile->static_psymbols, +// OBSOLETE nlist.n_value, 0, +// OBSOLETE psymtab_language, objfile); +// OBSOLETE } +#endif /* OBSOLETE CFront */ } goto check_enum; case 't': @@ -2023,9 +2028,11 @@ read_dbx_symtab (struct objfile *objfile) case '9': case '-': case '#': /* for symbol identification (used in live ranges) */ - /* added to support cfront stabs strings */ - case 'Z': /* for definition continuations */ - case 'P': /* for prototypes */ +#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 ':': @@ -2682,10 +2689,11 @@ read_ofile_symtab (struct partial_symtab *pst) pst->symtab = end_symtab (text_offset + text_size, objfile, SECT_OFF_TEXT (objfile)); - /* Process items which we had to "process_later" due to dependencies - on other stabs. */ - process_now (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 (); } diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index 0250c1208ce..7ef423a240a 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -128,9 +128,9 @@ struct extra static void add_name (struct extra *, char *); static void add_mangled_type (struct extra *, struct type *); -#if 0 -static void cfront_mangle_name (struct type *, int, int); -#endif +#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); @@ -1458,193 +1458,193 @@ check_typedef (struct type *type) return type; } -/* New code added to support parsing of Cfront stabs strings */ -#define INIT_EXTRA { pextras->len=0; pextras->str[0]='\0'; } -#define ADD_EXTRA(c) { pextras->str[pextras->len++]=c; } - -static void -add_name (struct extra *pextras, char *n) -{ - int nlen; - - if ((nlen = (n ? strlen (n) : 0)) == 0) - return; - sprintf (pextras->str + pextras->len, "%d%s", nlen, n); - pextras->len = strlen (pextras->str); -} - -static void -add_mangled_type (struct extra *pextras, struct type *t) -{ - enum type_code tcode; - int tlen, tflags; - char *tname; - - tcode = TYPE_CODE (t); - tlen = TYPE_LENGTH (t); - tflags = TYPE_FLAGS (t); - tname = TYPE_NAME (t); - /* args of "..." seem to get mangled as "e" */ - - switch (tcode) - { - case TYPE_CODE_INT: - if (tflags == 1) - ADD_EXTRA ('U'); - switch (tlen) - { - case 1: - ADD_EXTRA ('c'); - break; - case 2: - ADD_EXTRA ('s'); - break; - case 4: - { - char *pname; - if ((pname = strrchr (tname, 'l'), pname) && !strcmp (pname, "long")) - { - ADD_EXTRA ('l'); - } - else - { - ADD_EXTRA ('i'); - } - } - break; - default: - { - complaint (&symfile_complaints, "Bad int type code length x%x", - tlen); - } - } - break; - case TYPE_CODE_FLT: - switch (tlen) - { - case 4: - ADD_EXTRA ('f'); - break; - case 8: - ADD_EXTRA ('d'); - break; - case 16: - ADD_EXTRA ('r'); - break; - default: - { - complaint (&symfile_complaints, "Bad float type code length x%x", - tlen); - } - } - break; - case TYPE_CODE_REF: - ADD_EXTRA ('R'); - /* followed by what it's a ref to */ - break; - case TYPE_CODE_PTR: - ADD_EXTRA ('P'); - /* followed by what it's a ptr to */ - break; - case TYPE_CODE_TYPEDEF: - { - complaint (&symfile_complaints, - "Typedefs in overloaded functions not yet supported"); - } - /* followed by type bytes & name */ - break; - case TYPE_CODE_FUNC: - ADD_EXTRA ('F'); - /* followed by func's arg '_' & ret types */ - break; - case TYPE_CODE_VOID: - ADD_EXTRA ('v'); - break; - case TYPE_CODE_METHOD: - ADD_EXTRA ('M'); - /* followed by name of class and func's arg '_' & ret types */ - add_name (pextras, tname); - ADD_EXTRA ('F'); /* then mangle function */ - break; - case TYPE_CODE_STRUCT: /* C struct */ - case TYPE_CODE_UNION: /* C union */ - case TYPE_CODE_ENUM: /* Enumeration type */ - /* followed by name of type */ - add_name (pextras, tname); - break; - - /* errors possible types/not supported */ - case TYPE_CODE_CHAR: - case TYPE_CODE_ARRAY: /* Array type */ - case TYPE_CODE_MEMBER: /* Member type */ - case TYPE_CODE_BOOL: - case TYPE_CODE_COMPLEX: /* Complex float */ - case TYPE_CODE_UNDEF: - case TYPE_CODE_SET: /* Pascal sets */ - case TYPE_CODE_RANGE: - case TYPE_CODE_STRING: - case TYPE_CODE_BITSTRING: - case TYPE_CODE_ERROR: - default: - { - complaint (&symfile_complaints, "Unknown type code x%x", tcode); - } - } - if (TYPE_TARGET_TYPE (t)) - add_mangled_type (pextras, TYPE_TARGET_TYPE (t)); -} - -#if 0 -void -cfront_mangle_name (struct type *type, int i, int j) -{ - struct fn_field *f; - char *mangled_name = gdb_mangle_name (type, i, j); - - f = TYPE_FN_FIELDLIST1 (type, i); /* moved from below */ - - /* kludge to support cfront methods - gdb expects to find "F" for - ARM_mangled names, so when we mangle, we have to add it here */ - if (ARM_DEMANGLING) - { - int k; - char *arm_mangled_name; - struct fn_field *method = &f[j]; - char *field_name = TYPE_FN_FIELDLIST_NAME (type, i); - char *physname = TYPE_FN_FIELD_PHYSNAME (f, j); - char *newname = type_name_no_tag (type); - - struct type *ftype = TYPE_FN_FIELD_TYPE (f, j); - int nargs = TYPE_NFIELDS (ftype); /* number of args */ - struct extra extras, *pextras = &extras; - INIT_EXTRA - - if (TYPE_FN_FIELD_STATIC_P (f, j)) /* j for sublist within this list */ - ADD_EXTRA ('S') - ADD_EXTRA ('F') - /* add args here! */ - if (nargs <= 1) /* no args besides this */ - ADD_EXTRA ('v') - else - { - for (k = 1; k < nargs; k++) - { - struct type *t; - t = TYPE_FIELD_TYPE (ftype, k); - add_mangled_type (pextras, t); - } - } - ADD_EXTRA ('\0') - printf ("add_mangled_type: %s\n", extras.str); /* FIXME */ - xasprintf (&arm_mangled_name, "%s%s", mangled_name, extras.str); - xfree (mangled_name); - mangled_name = arm_mangled_name; - } -} -#endif /* 0 */ - -#undef ADD_EXTRA -/* End of new code added to support parsing of Cfront stabs strings */ +#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. */ diff --git a/gdb/mdebugread.c b/gdb/mdebugread.c index bd0e124bc0d..ee731bb0864 100644 --- a/gdb/mdebugread.c +++ b/gdb/mdebugread.c @@ -1517,9 +1517,11 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs, if (t->fBitfield) { int width = AUX_GET_WIDTH (bigend, ax); - - /* Inhibit core dumps with some cfront generated objects that - corrupt the TIR. */ +#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) { /* Alpha cc -migrate encodes char and unsigned char types @@ -3036,20 +3038,22 @@ parse_partial_symbols (struct objfile *objfile) psymtab_language, objfile); p += 1; } - /* The semantics of C++ state that "struct foo { ... }" - also defines a typedef for "foo". Unfortuantely, cfront - never makes the typedef when translating from C++ to C. - We make the typedef here so that "ptype foo" works as - expected for cfront translated code. */ - else if (psymtab_language == language_cplus) - { - /* Also a typedef with the same name. */ - add_psymbol_to_list (namestring, p - namestring, - VAR_NAMESPACE, LOC_TYPEDEF, - &objfile->static_psymbols, - sh.value, 0, - psymtab_language, objfile); - } +#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_NAMESPACE, LOC_TYPEDEF, +// OBSOLETE &objfile->static_psymbols, +// OBSOLETE sh.value, 0, +// OBSOLETE psymtab_language, objfile); +// OBSOLETE } +#endif /* OBSOLETE CFront */ } goto check_enum; case 't': @@ -3196,9 +3200,11 @@ parse_partial_symbols (struct objfile *objfile) case '9': case '-': case '#': /* for symbol identification (used in live ranges) */ - /* added to support cfront stabs strings */ - case 'Z': /* for definition continuations */ - case 'P': /* for prototypes */ +#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 ':': diff --git a/gdb/stabsread.c b/gdb/stabsread.c index 135ff83468c..aeae862f712 100644 --- a/gdb/stabsread.c +++ b/gdb/stabsread.c @@ -149,30 +149,31 @@ static struct field *read_args (char **, int, struct objfile *, int *, int *); static int read_cpp_abbrev (struct field_info *, char **, struct type *, struct objfile *); +#if 0 /* OBSOLETE CFront */ +// OBSOLETE /* new functions added for cfront support */ -/* new functions added for cfront support */ +// OBSOLETE static int +// OBSOLETE copy_cfront_struct_fields (struct field_info *, struct type *, +// OBSOLETE struct objfile *); -static int -copy_cfront_struct_fields (struct field_info *, struct type *, - struct objfile *); +// OBSOLETE static char *get_cfront_method_physname (char *); -static char *get_cfront_method_physname (char *); +// OBSOLETE static int +// OBSOLETE read_cfront_baseclasses (struct field_info *, char **, +// OBSOLETE struct type *, struct objfile *); -static int -read_cfront_baseclasses (struct field_info *, char **, - 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 *); -static int -read_cfront_static_fields (struct field_info *, char **, - struct type *, struct objfile *); -static int -read_cfront_member_functions (struct field_info *, char **, - struct type *, struct objfile *); +// OBSOLETE /* end new functions added for cfront support */ +#endif /* OBSOLETE CFront */ static char *find_name_end (char *name); -/* end new functions added for cfront support */ - static void add_live_range (struct objfile *, struct symbol *, CORE_ADDR, CORE_ADDR); @@ -495,487 +496,488 @@ read_type_number (register char **pp, register int *typenums) #define VISIBILITY_PUBLIC '2' /* Stabs character for public field */ #define VISIBILITY_IGNORE '9' /* Optimized out or zero length */ -#define CFRONT_VISIBILITY_PRIVATE '2' /* Stabs character for private field */ -#define CFRONT_VISIBILITY_PUBLIC '1' /* Stabs character for public field */ - -/* This code added to support parsing of ARM/Cfront stabs strings */ - -/* Get substring from string up to char c, advance string pointer past - suibstring. */ - -static char * -get_substring (char **p, int c) -{ - char *str; - str = *p; - *p = strchr (*p, c); - if (*p) - { - **p = 0; - (*p)++; - } - else - str = 0; - return str; -} - -/* Physname gets strcat'd onto sname in order to recreate the mangled - name (see funtion gdb_mangle_name in gdbtypes.c). For cfront, make - the physname look like that of g++ - take out the initial mangling - eg: for sname="a" and fname="foo__1aFPFs_i" return "FPFs_i" */ - -static char * -get_cfront_method_physname (char *fname) -{ - int len = 0; - /* FIXME would like to make this generic for g++ too, but - that is already handled in read_member_funcctions */ - char *p = fname; - - /* search ahead to find the start of the mangled suffix */ - if (*p == '_' && *(p + 1) == '_') /* compiler generated; probably a ctor/dtor */ - p += 2; - while (p && (unsigned) ((p + 1) - fname) < strlen (fname) && *(p + 1) != '_') - p = strchr (p, '_'); - if (!(p && *p == '_' && *(p + 1) == '_')) - error ("Invalid mangled function name %s", fname); - p += 2; /* advance past '__' */ - - /* struct name length and name of type should come next; advance past it */ - while (isdigit (*p)) - { - len = len * 10 + (*p - '0'); - p++; - } - p += len; - - return p; -} - -static void -msg_unknown_complaint (const char *arg1) -{ - complaint (&symfile_complaints, "Unsupported token in stabs string %s", arg1); -} - -/* Read base classes within cfront class definition. - eg: A:ZcA;1@Bpub v2@Bvirpri;__ct__1AFv func__1AFv *sfunc__1AFv ;as__1A ;; - ^^^^^^^^^^^^^^^^^^ - - A:ZcA;;foopri__1AFv foopro__1AFv __ct__1AFv __ct__1AFRC1A foopub__1AFv ;;; - ^ - */ - -static int -read_cfront_baseclasses (struct field_info *fip, char **pp, struct type *type, - struct objfile *objfile) -{ - int bnum = 0; - char *p; - int i; - struct nextfield *new; - - if (**pp == ';') /* no base classes; return */ - { - ++(*pp); - return 1; - } - - /* first count base classes so we can allocate space before parsing */ - for (p = *pp; p && *p && *p != ';'; p++) - { - if (*p == ' ') - bnum++; - } - bnum++; /* add one more for last one */ - - /* now parse the base classes until we get to the start of the methods - (code extracted and munged from read_baseclasses) */ - ALLOCATE_CPLUS_STRUCT_TYPE (type); - TYPE_N_BASECLASSES (type) = bnum; - - /* allocate space */ - { - int num_bytes = B_BYTES (TYPE_N_BASECLASSES (type)); - char *pointer; - - pointer = (char *) TYPE_ALLOC (type, num_bytes); - TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *) pointer; - } - B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), TYPE_N_BASECLASSES (type)); - - for (i = 0; i < TYPE_N_BASECLASSES (type); i++) - { - new = (struct nextfield *) xmalloc (sizeof (struct nextfield)); - make_cleanup (xfree, new); - memset (new, 0, sizeof (struct nextfield)); - new->next = fip->list; - fip->list = new; - FIELD_BITSIZE (new->field) = 0; /* this should be an unpacked field! */ - - STABS_CONTINUE (pp, objfile); - - /* virtual? eg: v2@Bvir */ - if (**pp == 'v') - { - SET_TYPE_FIELD_VIRTUAL (type, i); - ++(*pp); - } - - /* access? eg: 2@Bvir */ - /* Note: protected inheritance not supported in cfront */ - switch (*(*pp)++) - { - case CFRONT_VISIBILITY_PRIVATE: - new->visibility = VISIBILITY_PRIVATE; - break; - case CFRONT_VISIBILITY_PUBLIC: - new->visibility = VISIBILITY_PUBLIC; - break; - default: - /* Bad visibility format. Complain and treat it as - public. */ - { - complaint (&symfile_complaints, - "Unknown visibility `%c' for baseclass", - new->visibility); - new->visibility = VISIBILITY_PUBLIC; - } - } - - /* "@" comes next - eg: @Bvir */ - if (**pp != '@') - { - msg_unknown_complaint (*pp); - return 1; - } - ++(*pp); - - - /* Set the bit offset of the portion of the object corresponding - to this baseclass. Always zero in the absence of - multiple inheritance. */ - /* Unable to read bit position from stabs; - Assuming no multiple inheritance for now FIXME! */ - /* We may have read this in the structure definition; - now we should fixup the members to be the actual base classes */ - FIELD_BITPOS (new->field) = 0; - - /* Get the base class name and type */ - { - char *bname; /* base class name */ - struct symbol *bsym; /* base class */ - char *p1, *p2; - p1 = strchr (*pp, ' '); - p2 = strchr (*pp, ';'); - if (p1 < p2) - bname = get_substring (pp, ' '); - else - bname = get_substring (pp, ';'); - if (!bname || !*bname) - { - msg_unknown_complaint (*pp); - return 1; - } - /* FIXME! attach base info to type */ - bsym = lookup_symbol (bname, 0, STRUCT_NAMESPACE, 0, 0); /*demangled_name */ - if (bsym) - { - new->field.type = SYMBOL_TYPE (bsym); - new->field.name = type_name_no_tag (new->field.type); - } - else - { - complaint (&symfile_complaints, "Unable to find base type for %s", - *pp); - return 1; - } - } - - /* If more base classes to parse, loop again. - We ate the last ' ' or ';' in get_substring, - so on exit we will have skipped the trailing ';' */ - /* if invalid, return 0; add code to detect - FIXME! */ - } - return 1; -} - -/* read cfront member functions. - pp points to string starting with list of functions - eg: A:ZcA;1@Bpub v2@Bvirpri;__ct__1AFv func__1AFv *sfunc__1AFv ;as__1A ;; - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - A:ZcA;;foopri__1AFv foopro__1AFv __ct__1AFv __ct__1AFRC1A foopub__1AFv ;;; - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - */ - -static int -read_cfront_member_functions (struct field_info *fip, char **pp, - struct type *type, struct objfile *objfile) -{ - /* This code extracted from read_member_functions - so as to do the similar thing for our funcs */ - - int nfn_fields = 0; - int length = 0; - /* Total number of member functions defined in this class. If the class - defines two `f' functions, and one `g' function, then this will have - the value 3. */ - int total_length = 0; - int i; - struct next_fnfield - { - struct next_fnfield *next; - struct fn_field fn_field; - } - *sublist; - struct type *look_ahead_type; - struct next_fnfieldlist *new_fnlist; - struct next_fnfield *new_sublist; - char *main_fn_name; - char *fname; - struct symbol *ref_func = 0; - - /* Process each list until we find the end of the member functions. - eg: p = "__ct__1AFv foo__1AFv ;;;" */ - - STABS_CONTINUE (pp, objfile); /* handle \\ */ - - while (**pp != ';' && (fname = get_substring (pp, ' '), fname)) - { - int is_static = 0; - int sublist_count = 0; - char *pname; - if (fname[0] == '*') /* static member */ - { - is_static = 1; - sublist_count++; - fname++; - } - ref_func = lookup_symbol (fname, 0, VAR_NAMESPACE, 0, 0); /* demangled name */ - if (!ref_func) - { - complaint (&symfile_complaints, - "Unable to find function symbol for %s", fname); - continue; - } - sublist = NULL; - look_ahead_type = NULL; - length = 0; - - new_fnlist = (struct next_fnfieldlist *) - xmalloc (sizeof (struct next_fnfieldlist)); - make_cleanup (xfree, new_fnlist); - memset (new_fnlist, 0, sizeof (struct next_fnfieldlist)); - - /* The following is code to work around cfront generated stabs. - The stabs contains full mangled name for each field. - We try to demangle the name and extract the field name out of it. */ - { - char *dem, *dem_p, *dem_args; - int dem_len; - dem = cplus_demangle (fname, DMGL_ANSI | DMGL_PARAMS); - if (dem != NULL) - { - dem_p = strrchr (dem, ':'); - if (dem_p != 0 && *(dem_p - 1) == ':') - dem_p++; - /* get rid of args */ - dem_args = strchr (dem_p, '('); - if (dem_args == NULL) - dem_len = strlen (dem_p); - else - dem_len = dem_args - dem_p; - main_fn_name = - obsavestring (dem_p, dem_len, &objfile->type_obstack); - } - else - { - main_fn_name = - obsavestring (fname, strlen (fname), &objfile->type_obstack); - } - } /* end of code for cfront work around */ - - new_fnlist->fn_fieldlist.name = main_fn_name; - -/*-------------------------------------------------*/ - /* Set up the sublists - Sublists are stuff like args, static, visibility, etc. - so in ARM, we have to set that info some other way. - Multiple sublists happen if overloading - eg: foo::26=##1;:;2A.; - In g++, we'd loop here thru all the sublists... */ - - new_sublist = - (struct next_fnfield *) xmalloc (sizeof (struct next_fnfield)); - make_cleanup (xfree, new_sublist); - memset (new_sublist, 0, sizeof (struct next_fnfield)); - - /* eat 1; from :;2A.; */ - new_sublist->fn_field.type = SYMBOL_TYPE (ref_func); /* normally takes a read_type */ - /* Make this type look like a method stub for gdb */ - TYPE_FLAGS (new_sublist->fn_field.type) |= TYPE_FLAG_STUB; - TYPE_CODE (new_sublist->fn_field.type) = TYPE_CODE_METHOD; - - /* If this is just a stub, then we don't have the real name here. */ - if (TYPE_STUB (new_sublist->fn_field.type)) - { - if (!TYPE_DOMAIN_TYPE (new_sublist->fn_field.type)) - TYPE_DOMAIN_TYPE (new_sublist->fn_field.type) = type; - new_sublist->fn_field.is_stub = 1; - } - - /* physname used later in mangling; eg PFs_i,5 for foo__1aFPFs_i - physname gets strcat'd in order to recreate the onto mangled name */ - pname = get_cfront_method_physname (fname); - new_sublist->fn_field.physname = savestring (pname, strlen (pname)); - - - /* Set this member function's visibility fields. - Unable to distinguish access from stabs definition! - Assuming public for now. FIXME! - (for private, set new_sublist->fn_field.is_private = 1, - for public, set new_sublist->fn_field.is_protected = 1) */ - - /* Unable to distinguish const/volatile from stabs definition! - Assuming normal for now. FIXME! */ - - new_sublist->fn_field.is_const = 0; - new_sublist->fn_field.is_volatile = 0; /* volatile not implemented in cfront */ - - /* Set virtual/static function info - How to get vtable offsets ? - Assuming normal for now FIXME!! - For vtables, figure out from whence this virtual function came. - It may belong to virtual function table of - one of its baseclasses. - set: - new_sublist -> fn_field.voffset = vtable offset, - new_sublist -> fn_field.fcontext = look_ahead_type; - where look_ahead_type is type of baseclass */ - if (is_static) - new_sublist->fn_field.voffset = VOFFSET_STATIC; - else /* normal member function. */ - new_sublist->fn_field.voffset = 0; - new_sublist->fn_field.fcontext = 0; - - - /* Prepare new sublist */ - new_sublist->next = sublist; - sublist = new_sublist; - length++; - - /* In g++, we loop thu sublists - now we set from functions. */ - new_fnlist->fn_fieldlist.fn_fields = (struct fn_field *) - obstack_alloc (&objfile->type_obstack, - sizeof (struct fn_field) * length); - memset (new_fnlist->fn_fieldlist.fn_fields, 0, - sizeof (struct fn_field) * length); - for (i = length; (i--, sublist); sublist = sublist->next) - { - new_fnlist->fn_fieldlist.fn_fields[i] = sublist->fn_field; - } - - new_fnlist->fn_fieldlist.length = length; - new_fnlist->next = fip->fnlist; - fip->fnlist = new_fnlist; - nfn_fields++; - total_length += length; - STABS_CONTINUE (pp, objfile); /* handle \\ */ - } /* end of loop */ - - if (nfn_fields) - { - /* type should already have space */ - TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *) - TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * nfn_fields); - memset (TYPE_FN_FIELDLISTS (type), 0, - sizeof (struct fn_fieldlist) * nfn_fields); - TYPE_NFN_FIELDS (type) = nfn_fields; - TYPE_NFN_FIELDS_TOTAL (type) = total_length; - } - - /* end of scope for reading member func */ - - /* eg: ";;" */ - - /* Skip trailing ';' and bump count of number of fields seen */ - if (**pp == ';') - (*pp)++; - else - return 0; - return 1; -} - -/* This routine fixes up partial cfront types that were created - while parsing the stabs. The main need for this function is - to add information such as methods to classes. - Examples of "p": "sA;;__ct__1AFv foo__1AFv ;;;" */ -int -resolve_cfront_continuation (struct objfile *objfile, struct symbol *sym, - char *p) -{ - struct symbol *ref_sym = 0; - char *sname; - /* snarfed from read_struct_type */ - struct field_info fi; - struct type *type; - struct cleanup *back_to; - - /* Need to make sure that fi isn't gunna conflict with struct - in case struct already had some fnfs */ - fi.list = NULL; - fi.fnlist = NULL; - back_to = make_cleanup (null_cleanup, 0); - - /* We only accept structs, classes and unions at the moment. - Other continuation types include t (typedef), r (long dbl), ... - We may want to add support for them as well; - right now they are handled by duplicating the symbol information - into the type information (see define_symbol) */ - if (*p != 's' /* structs */ - && *p != 'c' /* class */ - && *p != 'u') /* union */ - return 0; /* only handle C++ types */ - p++; - - /* Get symbol typs name and validate - eg: p = "A;;__ct__1AFv foo__1AFv ;;;" */ - sname = get_substring (&p, ';'); - if (!sname || strcmp (sname, SYMBOL_NAME (sym))) - error ("Internal error: base symbol type name does not match\n"); - - /* Find symbol's internal gdb reference using demangled_name. - This is the real sym that we want; - sym was a temp hack to make debugger happy */ - ref_sym = lookup_symbol (SYMBOL_NAME (sym), 0, STRUCT_NAMESPACE, 0, 0); - type = SYMBOL_TYPE (ref_sym); - - - /* Now read the baseclasses, if any, read the regular C struct or C++ - class member fields, attach the fields to the type, read the C++ - member functions, attach them to the type, and then read any tilde - field (baseclass specifier for the class holding the main vtable). */ - - if (!read_cfront_baseclasses (&fi, &p, type, objfile) - /* g++ does this next, but cfront already did this: - || !read_struct_fields (&fi, &p, type, objfile) */ - || !copy_cfront_struct_fields (&fi, type, objfile) - || !read_cfront_member_functions (&fi, &p, type, objfile) - || !read_cfront_static_fields (&fi, &p, type, objfile) - || !attach_fields_to_type (&fi, type, objfile) - || !attach_fn_fields_to_type (&fi, type) - /* g++ does this next, but cfront doesn't seem to have this: - || !read_tilde_fields (&fi, &p, type, objfile) */ - ) - { - type = error_type (&p, objfile); - } - - do_cleanups (back_to); - return 0; -} -/* End of code added to support parsing of ARM/Cfront stabs strings */ - +#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_NAMESPACE, 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_NAMESPACE, 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, 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 (SYMBOL_NAME (sym), 0, STRUCT_NAMESPACE, 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. */ @@ -1948,16 +1950,18 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type, if (synonym) p++; - /* The semantics of C++ state that "struct foo { ... }" also defines - a typedef for "foo". Unfortunately, cfront never makes the typedef - when translating C++ into C. We make the typedef here so that - "ptype foo" works as expected for cfront translated code. */ - else if ((current_subfile->language == language_cplus) - || (current_subfile->language == language_objc)) - synonym = 1; +#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); - + /* For a nameless type, we don't want a create a symbol, thus we did not use `sym'. Return without further processing. */ if (nameless) @@ -2044,31 +2048,32 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type, SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; add_symbol_to_list (sym, &local_symbols); break; - - /* New code added to support cfront stabs strings. - Note: case 'P' already handled above */ - case 'Z': - /* Cfront type continuation coming up! - Find the original definition and add to it. - We'll have to do this for the typedef too, - since we cloned the symbol to define a type in read_type. - Stabs info examples: - __1C :Ztl - foo__1CFv :ZtF (first def foo__1CFv:F(0,3);(0,24)) - C:ZsC;;__ct__1CFv func1__1CFv func2__1CFv ... ;;; - where C is the name of the class. - Unfortunately, we can't lookup the original symbol yet 'cuz - we haven't finished reading all the symbols. - Instead, we save it for processing later */ - process_later (sym, p, resolve_cfront_continuation); - SYMBOL_TYPE (sym) = error_type (&p, objfile); /* FIXME! change later */ - SYMBOL_CLASS (sym) = LOC_CONST; - SYMBOL_VALUE (sym) = 0; - SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; - /* Don't add to list - we'll delete it later when - we add the continuation to the real sym */ - return sym; - /* End of new code added to support cfront stabs strings */ +#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_NAMESPACE (sym) = VAR_NAMESPACE; +// 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); @@ -3590,35 +3595,37 @@ static void read_one_struct_field (struct field_info *fip, char **pp, char *p, struct type *type, struct objfile *objfile) { - /* The following is code to work around cfront generated stabs. - The stabs contains full mangled name for each field. - We try to demangle the name and extract the field name out of it. - */ - if (ARM_DEMANGLING && current_subfile->language == language_cplus) - { - char save_p; - char *dem, *dem_p; - save_p = *p; - *p = '\0'; - dem = cplus_demangle (*pp, DMGL_ANSI | DMGL_PARAMS); - if (dem != NULL) - { - dem_p = strrchr (dem, ':'); - if (dem_p != 0 && *(dem_p - 1) == ':') - dem_p++; - FIELD_NAME (fip->list->field) = - obsavestring (dem_p, strlen (dem_p), &objfile->type_obstack); - } - else - { - FIELD_NAME (fip->list->field) = - obsavestring (*pp, p - *pp, &objfile->type_obstack); - } - *p = save_p; - } - /* end of code for cfront work around */ - - else +#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); *pp = p + 1; @@ -4071,135 +4078,137 @@ attach_fn_fields_to_type (struct field_info *fip, register struct type *type) return 1; } -/* read cfront class static data. - pp points to string starting with the list of static data - eg: A:ZcA;1@Bpub v2@Bvirpri;__ct__1AFv func__1AFv *sfunc__1AFv ;as__1A ;; - ^^^^^^^^ - - A:ZcA;;foopri__1AFv foopro__1AFv __ct__1AFv __ct__1AFRC1A foopub__1AFv ;;; - ^ - */ - -static int -read_cfront_static_fields (struct field_info *fip, char **pp, struct type *type, - struct objfile *objfile) -{ - struct nextfield *new; - struct type *stype; - char *sname; - struct symbol *ref_static = 0; - - if (**pp == ';') /* no static data; return */ - { - ++(*pp); - return 1; - } - - /* Process each field in the list until we find the terminating ";" */ - - /* eg: p = "as__1A ;;;" */ - STABS_CONTINUE (pp, objfile); /* handle \\ */ - while (**pp != ';' && (sname = get_substring (pp, ' '), sname)) - { - ref_static = lookup_symbol (sname, 0, VAR_NAMESPACE, 0, 0); /*demangled_name */ - if (!ref_static) - { - complaint (&symfile_complaints, - "Unable to find symbol for static data field %s", sname); - continue; - } - stype = SYMBOL_TYPE (ref_static); - - /* allocate a new fip */ - new = (struct nextfield *) xmalloc (sizeof (struct nextfield)); - make_cleanup (xfree, new); - memset (new, 0, sizeof (struct nextfield)); - new->next = fip->list; - fip->list = new; - - /* set visibility */ - /* FIXME! no way to tell visibility from stabs??? */ - new->visibility = VISIBILITY_PUBLIC; - - /* set field info into fip */ - fip->list->field.type = stype; - - /* set bitpos & bitsize */ - SET_FIELD_PHYSNAME (fip->list->field, savestring (sname, strlen (sname))); - - /* set name field */ - /* The following is code to work around cfront generated stabs. - The stabs contains full mangled name for each field. - We try to demangle the name and extract the field name out of it. - */ - if (ARM_DEMANGLING) - { - char *dem, *dem_p; - dem = cplus_demangle (sname, DMGL_ANSI | DMGL_PARAMS); - if (dem != NULL) - { - dem_p = strrchr (dem, ':'); - if (dem_p != 0 && *(dem_p - 1) == ':') - dem_p++; - fip->list->field.name = - obsavestring (dem_p, strlen (dem_p), &objfile->type_obstack); - } - else - { - fip->list->field.name = - obsavestring (sname, strlen (sname), &objfile->type_obstack); - } - } /* end of code for cfront work around */ - } /* loop again for next static field */ - return 1; -} - -/* Copy structure fields to fip so attach_fields_to_type will work. - type has already been created with the initial instance data fields. - Now we want to be able to add the other members to the class, - so we want to add them back to the fip and reattach them again - once we have collected all the class members. */ - -static int -copy_cfront_struct_fields (struct field_info *fip, struct type *type, - struct objfile *objfile) -{ - int nfields = TYPE_NFIELDS (type); - int i; - struct nextfield *new; - - /* Copy the fields into the list of fips and reset the types - to remove the old fields */ - - for (i = 0; i < nfields; i++) - { - /* allocate a new fip */ - new = (struct nextfield *) xmalloc (sizeof (struct nextfield)); - make_cleanup (xfree, new); - memset (new, 0, sizeof (struct nextfield)); - new->next = fip->list; - fip->list = new; - - /* copy field info into fip */ - new->field = TYPE_FIELD (type, i); - /* set visibility */ - if (TYPE_FIELD_PROTECTED (type, i)) - new->visibility = VISIBILITY_PROTECTED; - else if (TYPE_FIELD_PRIVATE (type, i)) - new->visibility = VISIBILITY_PRIVATE; - else - new->visibility = VISIBILITY_PUBLIC; - } - /* Now delete the fields from the type since we will be - allocing new space once we get the rest of the fields - in attach_fields_to_type. - The pointer TYPE_FIELDS(type) is left dangling but should - be freed later by objstack_free */ - TYPE_FIELDS (type) = 0; - TYPE_NFIELDS (type) = 0; - - 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_NAMESPACE, 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 diff --git a/gdb/stabsread.h b/gdb/stabsread.h index e959e7ac654..9f15642f241 100644 --- a/gdb/stabsread.h +++ b/gdb/stabsread.h @@ -1,6 +1,6 @@ /* Include file for stabs debugging format support functions. Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, - 1996, 1997, 1999, 2000 Free Software Foundation, Inc. + 1996, 1997, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. This file is part of GDB. @@ -198,10 +198,11 @@ extern void stabsect_build_psymtabs extern void elfstab_offset_sections (struct objfile *, struct partial_symtab *); - -extern void process_later - (struct symbol *, char *, - int (*f) (struct objfile *, struct symbol *, char *)); +#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 **); @@ -209,9 +210,10 @@ extern void ref_add (int, struct symbol *, char *, CORE_ADDR); extern struct symbol *ref_search (int); -extern int resolve_cfront_continuation - (struct objfile *objfile, struct symbol *sym, char *p); - +#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); diff --git a/gdb/xcoffread.c b/gdb/xcoffread.c index 5bdb88c7ad2..56fb9524448 100644 --- a/gdb/xcoffread.c +++ b/gdb/xcoffread.c @@ -1,6 +1,6 @@ /* Read AIX xcoff symbol tables and convert to internal format, for GDB. Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, - 1996, 1997, 1998, 1999, 2000, 2001 + 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. Derived from coffread.c, dbxread.c, and a lot of hacking. Contributed by IBM Corporation. @@ -2636,20 +2636,22 @@ scan_xcoff_symtab (struct objfile *objfile) psymtab_language, objfile); p += 1; } - /* The semantics of C++ state that "struct foo { ... }" - also defines a typedef for "foo". Unfortuantely, cfront - never makes the typedef when translating from C++ to C. - We make the typedef here so that "ptype foo" works as - expected for cfront translated code. */ - else if (psymtab_language == language_cplus) - { - /* Also a typedef with the same name. */ - add_psymbol_to_list (namestring, p - namestring, - VAR_NAMESPACE, LOC_TYPEDEF, - &objfile->static_psymbols, - symbol.n_value, 0, - psymtab_language, objfile); - } +#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_NAMESPACE, LOC_TYPEDEF, +// OBSOLETE &objfile->static_psymbols, +// OBSOLETE symbol.n_value, 0, +// OBSOLETE psymtab_language, objfile); +// OBSOLETE } +#endif /* OBSOLETE CFront */ } goto check_enum; @@ -2798,9 +2800,11 @@ scan_xcoff_symtab (struct objfile *objfile) case '9': case '-': case '#': /* for symbol identification (used in live ranges) */ - /* added to support cfront stabs strings */ - case 'Z': /* for definition continuations */ - case 'P': /* for prototypes */ +#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 ':':