X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fstabsread.c;h=8c03a6f7de764dc1f55f946964a02710f3376641;hb=cb74cc240dfca14768005cd4ba34dc06283c2a7c;hp=5221c44b18604b75c2cf1893c44ef8a85e9d9c44;hpb=b6a40d0cf1b28902c6996c35afd20572f9871f0e;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/stabsread.c b/gdb/stabsread.c index 5221c44b18..8c03a6f7de 100644 --- a/gdb/stabsread.c +++ b/gdb/stabsread.c @@ -1,5 +1,5 @@ /* Support routines for decoding "stabs" debugging information format. - Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995 + Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996 Free Software Foundation, Inc. This file is part of GDB. @@ -30,6 +30,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "obstack.h" #include "symtab.h" #include "gdbtypes.h" +#include "expression.h" #include "symfile.h" #include "objfiles.h" #include "aout/stab_gnu.h" /* We always use GNU stabs, not native */ @@ -39,6 +40,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "buildsym.h" #include "complaints.h" #include "demangle.h" +#include "language.h" #include @@ -73,12 +75,19 @@ struct field_info } *fnlist; }; +static void +read_one_struct_field PARAMS ((struct field_info *, char **, char *, + struct type *, struct objfile *)); + +static char * +get_substring PARAMS ((char **, int)); + static struct type * dbx_alloc_type PARAMS ((int [2], struct objfile *)); static long read_huge_number PARAMS ((char **, int, int *)); -static struct type *error_type PARAMS ((char **)); +static struct type *error_type PARAMS ((char **, struct objfile *)); static void patch_block_stabs PARAMS ((struct pending *, struct pending_stabs *, @@ -141,6 +150,30 @@ static int read_cpp_abbrev PARAMS ((struct field_info *, char **, struct type *, struct objfile *)); +/* new functions added for cfront support */ + +static int +copy_cfront_struct_fields PARAMS ((struct field_info *, struct type *, + struct objfile *)); + +static char * +get_cfront_method_physname PARAMS ((char *)); + +static int +read_cfront_baseclasses PARAMS ((struct field_info *, char **, + struct type *, struct objfile *)); + +static int +read_cfront_static_fields PARAMS ((struct field_info *, char**, + struct type *, struct objfile *)); +static int +read_cfront_member_functions PARAMS ((struct field_info *, char **, + struct type *, struct objfile *)); + +/* end new functions added for cfront support */ + + + static const char vptr_name[] = { '_','v','p','t','r',CPLUS_MARKER,'\0' }; static const char vb_name[] = { '_','v','b',CPLUS_MARKER,'\0' }; @@ -175,7 +208,7 @@ struct complaint range_type_base_complaint = {"base type %d of range type is not defined", 0, 0}; struct complaint reg_value_complaint = - {"register number too large in symbol %s", 0, 0}; + {"register number %d too large (max %d) in symbol %s", 0, 0}; struct complaint vtbl_notfound_complaint = {"virtual function table pointer not found when defining class `%s'", 0, 0}; @@ -187,7 +220,7 @@ struct complaint rs6000_builtin_complaint = {"Unknown builtin type %d", 0, 0}; struct complaint unresolved_sym_chain_complaint = - {"%s: `%s' from global_sym_chain unresolved", 0, 0}; + {"%s: common block `%s' from global_sym_chain unresolved", 0, 0}; struct complaint stabs_general_complaint = {"%s", 0, 0}; @@ -197,12 +230,13 @@ struct complaint stabs_general_complaint = static struct type **undef_types; static int undef_types_allocated; static int undef_types_length; +static struct symbol *current_symbol = NULL; /* Check for and handle cretinous stabs symbol name continuation! */ -#define STABS_CONTINUE(pp) \ +#define STABS_CONTINUE(pp,objfile) \ do { \ if (**(pp) == '\\' || (**(pp) == '?' && (*(pp))[1] == '\0')) \ - *(pp) = next_symbol_text (); \ + *(pp) = next_symbol_text (objfile); \ } while (0) /* FIXME: These probably should be our own types (like rs6000_builtin_type @@ -288,7 +322,7 @@ Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.", { type_vector_length = INITIAL_TYPE_VECTOR_LENGTH; type_vector = (struct type **) - malloc (type_vector_length * sizeof (struct type *)); + xmalloc (type_vector_length * sizeof (struct type *)); } while (index >= type_vector_length) { @@ -424,7 +458,7 @@ patch_block_stabs (symbols, stabs, objfile) SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT; SYMBOL_NAME (sym) = - obstack_copy0 (&objfile->symbol_obstack, name, pp - name); + obsavestring (name, pp - name, &objfile->symbol_obstack); pp += 2; if (*(pp-1) == 'F' || *(pp-1) == 'f') { @@ -490,18 +524,505 @@ read_type_number (pp, typenums) } -/* To handle GNU C++ typename abbreviation, we need to be able to - fill in a type's name as soon as space for that type is allocated. - `type_synonym_name' is the name of the type being allocated. - It is cleared as soon as it is used (lest all allocated types - get this name). */ - -static char *type_synonym_name; - #if !defined (REG_STRUCT_HAS_ADDR) #define REG_STRUCT_HAS_ADDR(gcc_p,type) 0 #endif +#define VISIBILITY_PRIVATE '0' /* Stabs character for private field */ +#define VISIBILITY_PROTECTED '1' /* Stabs character for protected fld */ +#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 (p, c) + 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 (fname) + 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 && ((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; +} + +/* 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 (fip, pp, type, objfile) + struct field_info *fip; + struct objfile *objfile; + char ** pp; + struct type *type; +{ + static struct complaint msg_unknown = {"\ + Unsupported token in stabs string %s.\n", + 0, 0}; + static struct complaint msg_notfound = {"\ + Unable to find base type for %s.\n", + 0, 0}; + 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 (free, new); + memset (new, 0, sizeof (struct nextfield)); + new -> next = fip -> list; + fip -> list = new; + new -> field.bitsize = 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. */ + { + static struct complaint msg = { + "Unknown visibility `%c' for baseclass", 0, 0}; + complain (&msg, new -> visibility); + new -> visibility = VISIBILITY_PUBLIC; + } + } + + /* "@" comes next - eg: @Bvir */ + if (**pp!='@') + { + complain (&msg_unknown, *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 */ + new -> field.bitpos = 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 field.type = SYMBOL_TYPE(bsym); + new -> field.name = type_name_no_tag (new -> field.type); + } + else + { + complain (&msg_notfound, *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(fip, pp, type, objfile) + 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 something that is not a member function + or find the end of the 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) + { + static struct complaint msg = {"\ + Unable to find function symbol for %s\n", + 0, 0}; + complain (&msg, fname); + continue; + } + sublist = NULL; + look_ahead_type = NULL; + length = 0; + + new_fnlist = (struct next_fnfieldlist *) + xmalloc (sizeof (struct next_fnfieldlist)); + make_cleanup (free, 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 (free, 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_FLAGS (new_sublist -> fn_field.type) & TYPE_FLAG_STUB) + { + 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 function */ + + 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 ;;;" */ +void +resolve_cfront_continuation(objfile, sym, p) + 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; /* 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 */ + ref_sym = lookup_symbol (SYMBOL_NAME(sym), 0, STRUCT_NAMESPACE, 0, 0); /*demangled_name*/ + /* This is the real sym that we want; + sym was a temp hack to make debugger happy */ + /* ref_sym should already have space */ + 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); +} +/* End of code added to support parsing of ARM/Cfront stabs strings */ + + /* ARGSUSED */ struct symbol * define_symbol (valu, string, desc, type, objfile) @@ -542,7 +1063,7 @@ define_symbol (valu, string, desc, type, objfile) e.g. ":t10=*2" or a nameless enum like " :T16=ered:0,green:1,blue:2,;" */ nameless = (p == string || ((string[0] == ' ') && (string[1] == ':'))); - sym = (struct symbol *) + current_symbol = sym = (struct symbol *) obstack_alloc (&objfile -> symbol_obstack, sizeof (struct symbol)); memset (sym, 0, sizeof (struct symbol)); @@ -570,7 +1091,7 @@ define_symbol (valu, string, desc, type, objfile) SYMBOL_LINE(sym) = 0; /* unknown */ } - if (string[0] == CPLUS_MARKER) + if (is_cplus_marker (string[0])) { /* Special GNU C++ names. */ switch (string[1]) @@ -663,7 +1184,7 @@ define_symbol (valu, string, desc, type, objfile) if (*p != '=') { SYMBOL_CLASS (sym) = LOC_CONST; - SYMBOL_TYPE (sym) = error_type (&p); + SYMBOL_TYPE (sym) = error_type (&p, objfile); SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; add_symbol_to_list (sym, &file_symbols); return sym; @@ -737,7 +1258,7 @@ define_symbol (valu, string, desc, type, objfile) if (*p != ',') { - SYMBOL_TYPE (sym) = error_type (&p); + SYMBOL_TYPE (sym) = error_type (&p, objfile); break; } ++p; @@ -754,7 +1275,7 @@ define_symbol (valu, string, desc, type, objfile) default: { SYMBOL_CLASS (sym) = LOC_CONST; - SYMBOL_TYPE (sym) = error_type (&p); + SYMBOL_TYPE (sym) = error_type (&p, objfile); } } SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; @@ -943,12 +1464,12 @@ define_symbol (valu, string, desc, type, objfile) #endif /* !BELIEVE_PCC_PROMOTION. */ case 'P': - /* acc seems to use P to delare the prototypes of functions that + /* acc seems to use P to declare the prototypes of functions that are referenced by this file. gdb is not prepared to deal with this extra information. FIXME, it ought to. */ if (type == N_FUN) { - read_type (&p, objfile); + SYMBOL_TYPE (sym) = read_type (&p, objfile); goto process_prototype_types; } /*FALLTHROUGH*/ @@ -960,7 +1481,8 @@ define_symbol (valu, string, desc, type, objfile) SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (valu); if (SYMBOL_VALUE (sym) >= NUM_REGS) { - complain (®_value_complaint, SYMBOL_SOURCE_NAME (sym)); + complain (®_value_complaint, SYMBOL_VALUE (sym), NUM_REGS, + SYMBOL_SOURCE_NAME (sym)); SYMBOL_VALUE (sym) = SP_REGNUM; /* Known safe, though useless */ } SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; @@ -974,7 +1496,8 @@ define_symbol (valu, string, desc, type, objfile) SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (valu); if (SYMBOL_VALUE (sym) >= NUM_REGS) { - complain (®_value_complaint, SYMBOL_SOURCE_NAME (sym)); + complain (®_value_complaint, SYMBOL_VALUE (sym), NUM_REGS, + SYMBOL_SOURCE_NAME (sym)); SYMBOL_VALUE (sym) = SP_REGNUM; /* Known safe, though useless */ } SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; @@ -1003,7 +1526,9 @@ define_symbol (valu, string, desc, type, objfile) && REG_STRUCT_HAS_ADDR (processing_gcc_compilation, SYMBOL_TYPE (sym)) && (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT - || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_UNION) + || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_UNION + || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_SET + || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_BITSTRING) #endif ) { @@ -1118,23 +1643,13 @@ define_symbol (valu, string, desc, type, objfile) synonym = *p == 't'; if (synonym) - { - p++; - type_synonym_name = obsavestring (SYMBOL_NAME (sym), - strlen (SYMBOL_NAME (sym)), - &objfile -> symbol_obstack); - } + 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) - { - synonym = 1; - type_synonym_name = obsavestring (SYMBOL_NAME (sym), - strlen (SYMBOL_NAME (sym)), - &objfile -> symbol_obstack); - } + synonym = 1; SYMBOL_TYPE (sym) = read_type (&p, objfile); @@ -1206,7 +1721,8 @@ define_symbol (valu, string, desc, type, objfile) SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (valu); if (SYMBOL_VALUE (sym) >= NUM_REGS) { - complain (®_value_complaint, SYMBOL_SOURCE_NAME (sym)); + complain (®_value_complaint, SYMBOL_VALUE (sym), NUM_REGS, + SYMBOL_SOURCE_NAME (sym)); SYMBOL_VALUE (sym) = SP_REGNUM; /* Known safe, though useless */ } SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; @@ -1225,8 +1741,32 @@ define_symbol (valu, string, desc, type, objfile) 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 clloned 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. */ + /* can't lookup symbol yet 'cuz symbols not read yet + so we save it for processing later */ + process_later(sym,p); + 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 */ + default: - SYMBOL_TYPE (sym) = error_type (&p); + SYMBOL_TYPE (sym) = error_type (&p, objfile); SYMBOL_CLASS (sym) = LOC_CONST; SYMBOL_VALUE (sym) = 0; SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; @@ -1235,26 +1775,24 @@ define_symbol (valu, string, desc, type, objfile) } /* When passing structures to a function, some systems sometimes pass - the address in a register, not the structure itself. - - If REG_STRUCT_HAS_ADDR yields non-zero we have to convert LOC_REGPARM - to LOC_REGPARM_ADDR for structures and unions. */ - - if (SYMBOL_CLASS (sym) == LOC_REGPARM - && REG_STRUCT_HAS_ADDR (processing_gcc_compilation, - SYMBOL_TYPE (sym)) - && ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT) - || (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_UNION))) - SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR; + the address in a register, not the structure itself. */ - /* Likewise for converting LOC_ARG to LOC_REF_ARG (for the 7th and - subsequent arguments on the sparc, for example). */ - if (SYMBOL_CLASS (sym) == LOC_ARG - && REG_STRUCT_HAS_ADDR (processing_gcc_compilation, + if (REG_STRUCT_HAS_ADDR (processing_gcc_compilation, SYMBOL_TYPE (sym)) && ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT) - || (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_UNION))) - SYMBOL_CLASS (sym) = LOC_REF_ARG; + || (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_UNION) + || (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_BITSTRING) + || (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_SET))) + { + /* If REG_STRUCT_HAS_ADDR yields non-zero we have to + convert LOC_REGPARM to LOC_REGPARM_ADDR for structures and unions. */ + if (SYMBOL_CLASS (sym) == LOC_REGPARM) + SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR; + /* Likewise for converting LOC_ARG to LOC_REF_ARG (for the 7th and + subsequent arguments on the sparc, for example). */ + else if (SYMBOL_CLASS (sym) == LOC_ARG) + SYMBOL_CLASS (sym) = LOC_REF_ARG; + } return sym; } @@ -1267,7 +1805,7 @@ define_symbol (valu, string, desc, type, objfile) Thus code like this: if (*(*pp)++ != ';') - return error_type (pp); + return error_type (pp, objfile); is wrong because if *pp starts out pointing at '\0' (typically as the result of an earlier error), it will be incremented to point to the @@ -1275,13 +1813,13 @@ define_symbol (valu, string, desc, type, objfile) if you run off the end of the string table. Instead use if (**pp != ';') - return error_type (pp); + return error_type (pp, objfile); ++*pp; or if (**pp != ';') - foo = error_type (pp); + foo = error_type (pp, objfile); else ++*pp; @@ -1290,8 +1828,9 @@ define_symbol (valu, string, desc, type, objfile) debugger will be able to read the new symbol tables. */ static struct type * -error_type (pp) +error_type (pp, objfile) char **pp; + struct objfile *objfile; { complain (&error_type_complaint); while (1) @@ -1305,7 +1844,7 @@ error_type (pp) /* Check for and handle cretinous dbx symbol name continuation! */ if ((*pp)[-1] == '\\' || (*pp)[-1] == '?') { - *pp = next_symbol_text (); + *pp = next_symbol_text (objfile); } else { @@ -1330,7 +1869,6 @@ read_type (pp, objfile) register struct type *type = 0; struct type *type1; int typenums[2]; - int xtypenums[2]; char type_descriptor; /* Size in bits of type if specified by a type attribute, or -1 if @@ -1348,7 +1886,7 @@ read_type (pp, objfile) || **pp == '-') { if (read_type_number (pp, typenums) != 0) - return error_type (pp); + return error_type (pp, objfile); /* Type is not being defined here. Either it already exists, or this is a forward reference to it. dbx_alloc_type handles @@ -1357,52 +1895,9 @@ read_type (pp, objfile) return dbx_alloc_type (typenums, objfile); /* Type is being defined here. */ - /* Skip the '='. */ - ++(*pp); - - while (**pp == '@') - { - char *p = *pp + 1; - /* It might be a type attribute or a member type. */ - if (isdigit (*p) || *p == '(' || *p == '-') - /* Member type. */ - break; - else - { - /* Type attributes. */ - char *attr = p; - - /* Skip to the semicolon. */ - while (*p != ';' && *p != '\0') - ++p; - *pp = p; - if (*p == '\0') - return error_type (pp); - else - /* Skip the semicolon. */ - ++*pp; - - switch (*attr) - { - case 's': - type_size = atoi (attr + 1); - if (type_size <= 0) - type_size = -1; - break; - - case 'S': - is_string = 1; - break; - - default: - /* Ignore unrecognized type attributes, so future compilers - can invent new ones. */ - break; - } - } - } - /* Skip the type descriptor, we get it below with (*pp)[-1]. */ - ++(*pp); + /* Skip the '='. + Also skip the type descriptor - we get it below with (*pp)[-1]. */ + (*pp)+=2; } else { @@ -1412,6 +1907,7 @@ read_type (pp, objfile) (*pp)++; } + again: type_descriptor = (*pp)[-1]; switch (type_descriptor) { @@ -1456,7 +1952,7 @@ read_type (pp, objfile) q1 = strchr(*pp, '<'); p = strchr(*pp, ':'); if (p == NULL) - return error_type (pp); + return error_type (pp, objfile); while (q1 && p > q1 && p[1] == ':') { q2 = strchr(q1, '>'); @@ -1465,7 +1961,7 @@ read_type (pp, objfile) p += 2; p = strchr(p, ':'); if (p == NULL) - return error_type (pp); + return error_type (pp, objfile); } to = type_name = (char *)obstack_alloc (&objfile->type_obstack, p - *pp + 1); @@ -1530,50 +2026,35 @@ read_type (pp, objfile) case '8': case '9': case '(': + (*pp)--; - { - char *pp_saved; - - (*pp)--; - pp_saved = *pp; - - /* Peek ahead at the number to detect void. */ - if (read_type_number (pp, xtypenums) != 0) - return error_type (pp); + /* We deal with something like t(1,2)=(3,4)=... which + the Lucid compiler and recent gcc versions (post 2.7.3) use. */ - if (typenums[0] == xtypenums[0] && typenums[1] == xtypenums[1]) - /* It's being defined as itself. That means it is "void". */ - type = init_type (TYPE_CODE_VOID, 1, 0, NULL, objfile); - else + /* Allocate and enter the typedef type first. + This handles recursive types. */ + type = dbx_alloc_type (typenums, objfile); + TYPE_CODE (type) = TYPE_CODE_TYPEDEF; + { struct type *xtype = read_type (pp, objfile); + if (type == xtype) + { + /* It's being defined as itself. That means it is "void". */ + TYPE_CODE (type) = TYPE_CODE_VOID; + TYPE_LENGTH (type) = 1; + } + else if (type_size >= 0 || is_string) { - struct type *xtype; - - /* Go back to the number and have read_type get it. This means - that we can deal with something like t(1,2)=(3,4)=... which - the Lucid compiler uses. */ - *pp = pp_saved; - xtype = read_type (pp, objfile); - - /* The type is being defined to another type. So we copy the type. - This loses if we copy a C++ class and so we lose track of how - the names are mangled (but g++ doesn't output stabs like this - now anyway). */ - - type = alloc_type (objfile); - memcpy (type, xtype, sizeof (struct type)); - - /* The idea behind clearing the names is that the only purpose - for defining a type to another type is so that the name of - one can be different. So we probably don't need to worry much - about the case where the compiler doesn't give a name to the - new type. */ + *type = *xtype; TYPE_NAME (type) = NULL; TYPE_TAG_NAME (type) = NULL; } - if (typenums[0] != -1) - *dbx_lookup_type (typenums) = type; - break; + else + { + TYPE_FLAGS (type) |= TYPE_FLAG_TARGET_STUB; + TYPE_TARGET_TYPE (type) = xtype; + } } + break; /* In the following types, we must be sure to overwrite any existing type that the typenums refer to, rather than allocating a new one @@ -1616,7 +2097,7 @@ read_type (pp, objfile) /* Because 'c' means other things to AIX and 'k' is perfectly good, only accept 'c' in the os9k_stabs case. */ if (type_descriptor == 'c' && !os9k_stabs) - return error_type (pp); + return error_type (pp, objfile); type = read_type (pp, objfile); /* FIXME! For now, we ignore const and volatile qualifiers. */ break; @@ -1626,26 +2107,59 @@ read_type (pp, objfile) /* Because 'i' means other things to AIX and 'B' is perfectly good, only accept 'i' in the os9k_stabs case. */ if (type_descriptor == 'i' && !os9k_stabs) - return error_type (pp); + return error_type (pp, objfile); type = read_type (pp, objfile); /* FIXME! For now, we ignore const and volatile qualifiers. */ break; -/* FIXME -- we should be doing smash_to_XXX types here. */ - case '@': /* Member (class & variable) type */ - { - struct type *domain = read_type (pp, objfile); - struct type *memtype; + case '@': + if (isdigit (**pp) || **pp == '(' || **pp == '-') + { /* Member (class & variable) type */ + /* FIXME -- we should be doing smash_to_XXX types here. */ - if (**pp != ',') - /* Invalid member type data format. */ - return error_type (pp); - ++*pp; + struct type *domain = read_type (pp, objfile); + struct type *memtype; - memtype = read_type (pp, objfile); - type = dbx_alloc_type (typenums, objfile); - smash_to_member_type (type, domain, memtype); - } + if (**pp != ',') + /* Invalid member type data format. */ + return error_type (pp, objfile); + ++*pp; + + memtype = read_type (pp, objfile); + type = dbx_alloc_type (typenums, objfile); + smash_to_member_type (type, domain, memtype); + } + else /* type attribute */ + { + char *attr = *pp; + /* Skip to the semicolon. */ + while (**pp != ';' && **pp != '\0') + ++(*pp); + if (**pp == '\0') + return error_type (pp, objfile); + else + ++*pp; /* Skip the semicolon. */ + + switch (*attr) + { + case 's': + type_size = atoi (attr + 1); + if (type_size <= 0) + type_size = -1; + break; + + case 'S': + is_string = 1; + break; + + default: + /* Ignore unrecognized type attributes, so future compilers + can invent new ones. */ + break; + } + ++*pp; + goto again; + } break; case '#': /* Method (class & fn) type */ @@ -1670,7 +2184,7 @@ read_type (pp, objfile) if (**pp != ',') /* Invalid member type data format. */ - return error_type (pp); + return error_type (pp, objfile); else ++(*pp); @@ -1716,11 +2230,6 @@ read_type (pp, objfile) case 's': /* Struct type */ case 'u': /* Union type */ type = dbx_alloc_type (typenums, objfile); - if (!TYPE_NAME (type)) - { - TYPE_NAME (type) = type_synonym_name; - } - type_synonym_name = NULL; switch (type_descriptor) { case 's': @@ -1735,7 +2244,7 @@ read_type (pp, objfile) case 'a': /* Array type */ if (**pp != 'r') - return error_type (pp); + return error_type (pp, objfile); ++*pp; type = dbx_alloc_type (typenums, objfile); @@ -1756,13 +2265,13 @@ read_type (pp, objfile) default: --*pp; /* Go back to the symbol in error */ /* Particularly important if it was \0! */ - return error_type (pp); + return error_type (pp, objfile); } if (type == 0) { warning ("GDB internal error, type is NULL in stabsread.c\n"); - return error_type (pp); + return error_type (pp, objfile); } /* Size specified in a type attribute overrides any other size. */ @@ -1863,7 +2372,8 @@ rs6000_builtin_type (typenum) rettype = init_type (TYPE_CODE_INT, 4, 0, "integer", NULL); break; case 16: - rettype = init_type (TYPE_CODE_BOOL, 4, 0, "boolean", NULL); + rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED, + "boolean", NULL); break; case 17: rettype = init_type (TYPE_CODE_FLT, 4, 0, "short real", NULL); @@ -1935,11 +2445,6 @@ rs6000_builtin_type (typenum) /* This page contains subroutines of read_type. */ -#define VISIBILITY_PRIVATE '0' /* Stabs character for private field */ -#define VISIBILITY_PROTECTED '1' /* Stabs character for protected fld */ -#define VISIBILITY_PUBLIC '2' /* Stabs character for public field */ -#define VISIBILITY_IGNORE '9' /* Optimized out or zero length */ - /* Read member function stabs info for C++ classes. The form of each member function data is: @@ -2007,7 +2512,7 @@ read_member_functions (fip, pp, type, objfile) make_cleanup (free, new_fnlist); memset (new_fnlist, 0, sizeof (struct next_fnfieldlist)); - if ((*pp)[0] == 'o' && (*pp)[1] == 'p' && (*pp)[2] == CPLUS_MARKER) + if ((*pp)[0] == 'o' && (*pp)[1] == 'p' && is_cplus_marker ((*pp)[2])) { /* This is a completely wierd case. In order to stuff in the names that might contain colons (the usual name delimiter), @@ -2024,7 +2529,7 @@ read_member_functions (fip, pp, type, objfile) /* Skip past '::'. */ *pp = p + 2; - STABS_CONTINUE (pp); + STABS_CONTINUE (pp, objfile); p = *pp; while (*p != '.') { @@ -2053,7 +2558,7 @@ read_member_functions (fip, pp, type, objfile) if (look_ahead_type == NULL) { /* Normal case. */ - STABS_CONTINUE (pp); + STABS_CONTINUE (pp, objfile); new_sublist -> fn_field.type = read_type (pp, objfile); if (**pp != ':') @@ -2098,7 +2603,7 @@ read_member_functions (fip, pp, type, objfile) break; } - STABS_CONTINUE (pp); + STABS_CONTINUE (pp, objfile); switch (**pp) { case 'A': /* Normal functions. */ @@ -2147,7 +2652,7 @@ read_member_functions (fip, pp, type, objfile) if (nbits != 0) return 0; - STABS_CONTINUE (pp); + STABS_CONTINUE (pp, objfile); if (**pp == ';' || **pp == '\0') { /* Must be g++ version 1. */ @@ -2204,7 +2709,7 @@ read_member_functions (fip, pp, type, objfile) new_sublist -> next = sublist; sublist = new_sublist; length++; - STABS_CONTINUE (pp); + STABS_CONTINUE (pp, objfile); } while (**pp != ';' && **pp != '\0'); @@ -2225,7 +2730,7 @@ read_member_functions (fip, pp, type, objfile) fip -> fnlist = new_fnlist; nfn_fields++; total_length += length; - STABS_CONTINUE (pp); + STABS_CONTINUE (pp, objfile); } if (nfn_fields) @@ -2344,7 +2849,36 @@ read_one_struct_field (fip, pp, p, type, objfile) struct type *type; struct objfile *objfile; { - fip -> list -> field.name = + /* 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++; + fip->list->field.name = + obsavestring (dem_p, strlen(dem_p), &objfile -> type_obstack); + } + else + { + fip->list->field.name = + obsavestring (*pp, p - *pp, &objfile -> type_obstack); + } + *p = save_p; + } + /* end of code for cfront work around */ + + else + fip -> list -> field.name = obsavestring (*pp, p - *pp, &objfile -> type_obstack); *pp = p + 1; @@ -2437,6 +2971,7 @@ read_one_struct_field (fip, pp, p, type, objfile) and treat enums as if they had the width of ints. */ if (TYPE_CODE (fip -> list -> field.type) != TYPE_CODE_INT + && TYPE_CODE (fip -> list -> field.type) != TYPE_CODE_BOOL && TYPE_CODE (fip -> list -> field.type) != TYPE_CODE_ENUM) { fip -> list -> field.bitsize = 0; @@ -2498,7 +3033,7 @@ read_struct_fields (fip, pp, type, objfile) while (**pp != ';') { if (os9k_stabs && **pp == ',') break; - STABS_CONTINUE (pp); + STABS_CONTINUE (pp, objfile); /* Get space to record the next field's data. */ new = (struct nextfield *) xmalloc (sizeof (struct nextfield)); make_cleanup (free, new); @@ -2512,12 +3047,9 @@ read_struct_fields (fip, pp, type, objfile) /* If is starts with CPLUS_MARKER it is a special abbreviation, unless the CPLUS_MARKER is followed by an underscore, in which case it is just the name of an anonymous type, which we - should handle like any other type name. We accept either '$' - or '.', because a field name can never contain one of these - characters except as a CPLUS_MARKER (we probably should be - doing that in most parts of GDB). */ + should handle like any other type name. */ - if ((*p == '$' || *p == '.') && p[1] != '_') + if (is_cplus_marker (p[0]) && p[1] != '_') { if (!read_cpp_abbrev (fip, pp, type, objfile)) return 0; @@ -2630,7 +3162,7 @@ read_baseclasses (fip, pp, type, objfile) fip -> list = new; new -> field.bitsize = 0; /* this should be an unpacked field! */ - STABS_CONTINUE (pp); + STABS_CONTINUE (pp, objfile); switch (**pp) { case '0': @@ -2712,7 +3244,7 @@ read_tilde_fields (fip, pp, type, objfile) { register char *p; - STABS_CONTINUE (pp); + STABS_CONTINUE (pp, objfile); /* If we are positioned at a ';', then skip it. */ if (**pp == ';') @@ -2802,6 +3334,145 @@ attach_fn_fields_to_type (fip, 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(fip, pp, type, objfile) + 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) + { + static struct complaint msg = {"\ + Unable to find symbol for static data field %s\n", + 0, 0}; + complain (&msg, sname); + continue; + } + stype = SYMBOL_TYPE(ref_static); + + /* allocate a new fip */ + new = (struct nextfield *) xmalloc (sizeof (struct nextfield)); + make_cleanup (free, 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 */ + fip -> list -> field.bitpos = (long) -1; /* -1 signifies a static member */ + /* YUK! what a hack! bitsize used for physname when field is static */ + fip -> list -> field.bitsize = (long) 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(fip, type, objfile) + 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 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; +} + /* 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. */ @@ -2931,7 +3602,7 @@ read_struct_type (pp, type, objfile) int nbits; TYPE_LENGTH (type) = read_huge_number (pp, 0, &nbits); if (nbits != 0) - return error_type (pp); + return error_type (pp, objfile); } /* Now read the baseclasses, if any, read the regular C struct or C++ @@ -2946,8 +3617,7 @@ read_struct_type (pp, type, objfile) || !attach_fn_fields_to_type (&fi, type) || !read_tilde_fields (&fi, pp, type, objfile)) { - do_cleanups (back_to); - return (error_type (pp)); + type = error_type (pp, objfile); } do_cleanups (back_to); @@ -2984,7 +3654,7 @@ read_array_type (pp, type, objfile) index_type = read_type (pp, objfile); if (**pp != ';') /* Improper format of array type decl. */ - return error_type (pp); + return error_type (pp, objfile); ++*pp; } @@ -2995,7 +3665,7 @@ read_array_type (pp, type, objfile) } lower = read_huge_number (pp, os9k_stabs ? ',' : ';', &nbits); if (nbits != 0) - return error_type (pp); + return error_type (pp, objfile); if (!(**pp >= '0' && **pp <= '9') && **pp != '-') { @@ -3004,7 +3674,7 @@ read_array_type (pp, type, objfile) } upper = read_huge_number (pp, ';', &nbits); if (nbits != 0) - return error_type (pp); + return error_type (pp, objfile); element_type = read_type (pp, objfile); @@ -3018,15 +3688,6 @@ read_array_type (pp, type, objfile) create_range_type ((struct type *) NULL, index_type, lower, upper); type = create_array_type (type, element_type, range_type); - /* If we have an array whose element type is not yet known, but whose - bounds *are* known, record it to be adjusted at the end of the file. */ - - if ((TYPE_FLAGS (element_type) & TYPE_FLAG_STUB) && !adjustable) - { - TYPE_FLAGS (type) |= TYPE_FLAG_TARGET_STUB; - add_undefined_type (type); - } - return type; } @@ -3071,7 +3732,7 @@ read_enum_type (pp, type, objfile) with a digit). */ read_huge_number (pp, 0, &nbits); if (nbits != 0) - return error_type (pp); + return error_type (pp, objfile); } /* The aix4 compiler emits an extra field before the enum members; @@ -3091,14 +3752,14 @@ read_enum_type (pp, type, objfile) A semicolon or comma instead of a NAME means the end. */ while (**pp && **pp != ';' && **pp != ',') { - STABS_CONTINUE (pp); + STABS_CONTINUE (pp, objfile); p = *pp; while (*p != ':') p++; name = obsavestring (*pp, p - *pp, &objfile -> symbol_obstack); *pp = p + 1; n = read_huge_number (pp, ',', &nbits); if (nbits != 0) - return error_type (pp); + return error_type (pp, objfile); sym = (struct symbol *) obstack_alloc (&objfile -> symbol_obstack, sizeof (struct symbol)); @@ -3188,7 +3849,7 @@ read_sun_builtin_type (pp, typenums, objfile) signed_type = 0; break; default: - return error_type (pp); + return error_type (pp, objfile); } (*pp)++; @@ -3206,17 +3867,17 @@ read_sun_builtin_type (pp, typenums, objfile) we will ignore it. */ read_huge_number (pp, ';', &nbits); if (nbits != 0) - return error_type (pp); + return error_type (pp, objfile); /* The second number is always 0, so ignore it too. */ read_huge_number (pp, ';', &nbits); if (nbits != 0) - return error_type (pp); + return error_type (pp, objfile); /* The third number is the number of bits for this type. */ type_bits = read_huge_number (pp, 0, &nbits); if (nbits != 0) - return error_type (pp); + return error_type (pp, objfile); /* The type *should* end with a semicolon. If it are embedded in a larger type the semicolon may be the only way to know where the type ends. If this type is at the end of the stabstring we @@ -3251,12 +3912,12 @@ read_sun_floating_type (pp, typenums, objfile) FN_COMPLEX. */ details = read_huge_number (pp, ';', &nbits); if (nbits != 0) - return error_type (pp); + return error_type (pp, objfile); /* The second number is the number of bytes occupied by this type */ nbytes = read_huge_number (pp, ';', &nbits); if (nbits != 0) - return error_type (pp); + return error_type (pp, objfile); if (details == NF_COMPLEX || details == NF_COMPLEX16 || details == NF_COMPLEX32) @@ -3401,7 +4062,7 @@ read_range_type (pp, typenums, objfile) /* First comes a type we are a subrange of. In C it is usually 0, 1 or the type being defined. */ if (read_type_number (pp, rangenums) != 0) - return error_type (pp); + return error_type (pp, objfile); self_subrange = (rangenums[0] == typenums[0] && rangenums[1] == typenums[1]); @@ -3421,7 +4082,7 @@ read_range_type (pp, typenums, objfile) n3 = read_huge_number (pp, ';', &n3bits); if (n2bits == -1 || n3bits == -1) - return error_type (pp); + return error_type (pp, objfile); if (index_type) goto handle_true_range; @@ -3459,14 +4120,14 @@ read_range_type (pp, typenums, objfile) objfile); } else - return error_type (pp); + return error_type (pp, objfile); } /* A type defined as a subrange of itself, with bounds both 0, is void. */ if (self_subrange && n2 == 0 && n3 == 0) return init_type (TYPE_CODE_VOID, 1, 0, NULL, objfile); - /* If n3 is zero and n2 is not, we want a floating type, + /* If n3 is zero and n2 is positive, we want a floating type, and n2 is the width in bytes. Fortran programs appear to use this for complex types also, @@ -3498,6 +4159,10 @@ read_range_type (pp, typenums, objfile) else if (self_subrange && n2 == 0 && n3 == 127) return init_type (TYPE_CODE_INT, 1, 0, NULL, objfile); + else if (current_symbol && SYMBOL_LANGUAGE (current_symbol) == language_chill + && !self_subrange) + goto handle_true_range; + /* We used to do this only for subrange of self or subrange of int. */ else if (n2 == 0) { @@ -3535,13 +4200,10 @@ read_range_type (pp, typenums, objfile) return a real pointer. */ handle_true_range: - /* At this point I don't have the faintest idea how to deal with - a self_subrange type; I'm going to assume that this is used - as an idiom, and that all of them are special cases. So . . . */ if (self_subrange) - return error_type (pp); - - index_type = *dbx_lookup_type (rangenums); + index_type = builtin_type_int; + else + index_type = *dbx_lookup_type (rangenums); if (index_type == NULL) { /* Does this actually ever happen? Is that why we are worrying @@ -3581,7 +4243,7 @@ read_args (pp, end, objfile) /* Invalid argument list: no ','. */ return (struct type **)-1; (*pp)++; - STABS_CONTINUE (pp); + STABS_CONTINUE (pp, objfile); types[n++] = read_type (pp, objfile); } (*pp)++; /* get past `end' (the ':' character) */ @@ -3667,6 +4329,7 @@ common_block_end (objfile) sym = (struct symbol *) obstack_alloc (&objfile -> symbol_obstack, sizeof (struct symbol)); memset (sym, 0, sizeof (struct symbol)); + /* Note: common_block_name already saved on symbol_obstack */ SYMBOL_NAME (sym) = common_block_name; SYMBOL_CLASS (sym) = LOC_BLOCK; @@ -3763,7 +4426,7 @@ cleanup_undefined_types () case TYPE_CODE_ENUM: { /* Check if it has been defined since. Need to do this here - as well as in check_stub_type to deal with the (legitimate in + as well as in check_typedef to deal with the (legitimate in C though not C++) case of several types with the same name in different source files. */ if (TYPE_FLAGS (*type) & TYPE_FLAG_STUB) @@ -3800,45 +4463,7 @@ cleanup_undefined_types () } break; - case TYPE_CODE_ARRAY: - { - /* This is a kludge which is here for historical reasons - because I suspect that check_stub_type does not get - called everywhere it needs to be called for arrays. Even - with this kludge, those places are broken for the case - where the stub type is defined in another compilation - unit, but this kludge at least deals with it for the case - in which it is the same compilation unit. - - Don't try to do this by calling check_stub_type; it might - cause symbols to be read in lookup_symbol, and the symbol - reader is not reentrant. */ - - struct type *range_type; - int lower, upper; - - if (TYPE_LENGTH (*type) != 0) /* Better be unknown */ - goto badtype; - if (TYPE_NFIELDS (*type) != 1) - goto badtype; - range_type = TYPE_FIELD_TYPE (*type, 0); - if (TYPE_CODE (range_type) != TYPE_CODE_RANGE) - goto badtype; - - /* Now recompute the length of the array type, based on its - number of elements and the target type's length. */ - lower = TYPE_FIELD_BITPOS (range_type, 0); - upper = TYPE_FIELD_BITPOS (range_type, 1); - TYPE_LENGTH (*type) = (upper - lower + 1) - * TYPE_LENGTH (TYPE_TARGET_TYPE (*type)); - - /* If the target type is not a stub, we could be clearing - TYPE_FLAG_TARGET_STUB for *type. */ - } - break; - default: - badtype: { static struct complaint msg = {"\ GDB internal error. cleanup_undefined_types with bad type %d.", 0, 0}; @@ -3853,13 +4478,10 @@ GDB internal error. cleanup_undefined_types with bad type %d.", 0, 0}; /* Scan through all of the global symbols defined in the object file, assigning values to the debugging symbols that need to be assigned - to. Get these symbols from the minimal symbol table. - Return 1 if there might still be unresolved debugging symbols, else 0. */ - -static int scan_file_globals_1 PARAMS ((struct objfile *)); + to. Get these symbols from the minimal symbol table. */ -static int -scan_file_globals_1 (objfile) +void +scan_file_globals (objfile) struct objfile *objfile; { int hash; @@ -3874,12 +4496,11 @@ scan_file_globals_1 (objfile) break; } if (hash >= HASHSIZE) - return 0; - - if (objfile->msymbols == 0) /* Beware the null file. */ - return 1; + return; - for (msymbol = objfile -> msymbols; SYMBOL_NAME (msymbol) != NULL; msymbol++) + for (msymbol = objfile -> msymbols; + msymbol && SYMBOL_NAME (msymbol) != NULL; + msymbol++) { QUIT; @@ -3948,39 +4569,27 @@ scan_file_globals_1 (objfile) } } } - return 1; -} - -/* Assign values to global debugging symbols. - Search the passed objfile first, then try the runtime common symbols. - Complain about any remaining unresolved symbols and remove them - from the chain. */ - -void -scan_file_globals (objfile) - struct objfile *objfile; -{ - int hash; - struct symbol *sym, *prev; - - if (scan_file_globals_1 (objfile) == 0) - return; - if (rt_common_objfile && scan_file_globals_1 (rt_common_objfile) == 0) - return; + /* Change the storage class of any remaining unresolved globals to + LOC_UNRESOLVED and remove them from the chain. */ for (hash = 0; hash < HASHSIZE; hash++) { sym = global_sym_chain[hash]; while (sym) { - complain (&unresolved_sym_chain_complaint, - objfile->name, SYMBOL_NAME (sym)); + prev = sym; + sym = SYMBOL_VALUE_CHAIN (sym); /* Change the symbol address from the misleading chain value to address zero. */ - prev = sym; - sym = SYMBOL_VALUE_CHAIN (sym); SYMBOL_VALUE_ADDRESS (prev) = 0; + + /* Complain about unresolved common block symbols. */ + if (SYMBOL_CLASS (prev) == LOC_STATIC) + SYMBOL_CLASS (prev) = LOC_UNRESOLVED; + else + complain (&unresolved_sym_chain_complaint, + objfile->name, SYMBOL_NAME (prev)); } } memset (global_sym_chain, 0, sizeof (global_sym_chain));