/* Support routines for decoding "stabs" debugging information format.
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.
static int attach_fn_fields_to_type (struct field_info *, struct type *);
-static int
-attach_fields_to_type (struct field_info *, struct type *, struct objfile *);
+static int attach_fields_to_type (struct field_info *, struct type *,
+ struct objfile *);
static struct type *read_struct_type (char **, struct type *,
enum type_code,
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);
+static void add_live_range (struct objfile *, struct symbol *, CORE_ADDR,
+ CORE_ADDR);
static int resolve_live_range (struct objfile *, struct symbol *, char *);
static CORE_ADDR ref_search_value (int refnum);
-static int
-resolve_symbol_reference (struct objfile *, struct symbol *, char *);
+static int resolve_symbol_reference (struct objfile *, struct symbol *,
+ char *);
void stabsread_clear_cache (void);
#if !defined (BELIEVE_PCC_PROMOTION)
#define BELIEVE_PCC_PROMOTION 0
#endif
-#if !defined (BELIEVE_PCC_PROMOTION_TYPE)
-#define BELIEVE_PCC_PROMOTION_TYPE 0
-#endif
static void
invalid_cpp_abbrev_complaint (const char *arg1)
*(pp) = next_symbol_text (objfile); \
} while (0)
\f
-#if 0 /* OBSOLETE OS9K */
-// OBSOLETE /* FIXME: These probably should be our own types (like rs6000_builtin_type
-// OBSOLETE has its own types) rather than builtin_type_*. */
-// OBSOLETE static struct type **os9k_type_vector[] =
-// OBSOLETE {
-// OBSOLETE 0,
-// OBSOLETE &builtin_type_int,
-// OBSOLETE &builtin_type_char,
-// OBSOLETE &builtin_type_long,
-// OBSOLETE &builtin_type_short,
-// OBSOLETE &builtin_type_unsigned_char,
-// OBSOLETE &builtin_type_unsigned_short,
-// OBSOLETE &builtin_type_unsigned_long,
-// OBSOLETE &builtin_type_unsigned_int,
-// OBSOLETE &builtin_type_float,
-// OBSOLETE &builtin_type_double,
-// OBSOLETE &builtin_type_void,
-// OBSOLETE &builtin_type_long_double
-// OBSOLETE };
-// OBSOLETE
-// OBSOLETE static void os9k_init_type_vector (struct type **);
-// OBSOLETE
-// OBSOLETE static void
-// OBSOLETE os9k_init_type_vector (struct type **tv)
-// OBSOLETE {
-// OBSOLETE unsigned int i;
-// OBSOLETE for (i = 0; i < sizeof (os9k_type_vector) / sizeof (struct type **); i++)
-// OBSOLETE tv[i] = (os9k_type_vector[i] == 0 ? 0 : *(os9k_type_vector[i]));
-// OBSOLETE }
-#endif /* OBSOLETE OS9K */
/* Look up a dbx type-number pair. Return the address of the slot
where the type for that number-pair is stored.
(type_vector_length * sizeof (struct type *)));
memset (&type_vector[old_len], 0,
(type_vector_length - old_len) * sizeof (struct type *));
-
-#if 0 /* OBSOLETE OS9K */
-// OBSOLETE if (os9k_stabs)
-// OBSOLETE /* Deal with OS9000 fundamental types. */
-// OBSOLETE os9k_init_type_vector (type_vector);
-#endif /* OBSOLETE OS9K */
}
return (&type_vector[index]);
}
sizeof (struct symbol));
memset (sym, 0, sizeof (struct symbol));
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
- SYMBOL_NAME (sym) =
+ DEPRECATED_SYMBOL_NAME (sym) =
obsavestring (name, pp - name, &objfile->symbol_obstack);
pp += 2;
if (*(pp - 1) == 'F' || *(pp - 1) == 'f')
#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_DOMAIN, 0, 0); /*demangled_name */
+// OBSOLETE if (bsym)
+// OBSOLETE {
+// OBSOLETE new->field.type = SYMBOL_TYPE (bsym);
+// OBSOLETE new->field.name = type_name_no_tag (new->field.type);
+// OBSOLETE }
+// OBSOLETE else
+// OBSOLETE {
+// OBSOLETE complaint (&symfile_complaints, "Unable to find base type for %s",
+// OBSOLETE *pp);
+// OBSOLETE return 1;
+// OBSOLETE }
+// OBSOLETE }
+
+// OBSOLETE /* If more base classes to parse, loop again.
+// OBSOLETE We ate the last ' ' or ';' in get_substring,
+// OBSOLETE so on exit we will have skipped the trailing ';' */
+// OBSOLETE /* if invalid, return 0; add code to detect - FIXME! */
+// OBSOLETE }
+// OBSOLETE return 1;
+// OBSOLETE }
+
+// OBSOLETE /* read cfront member functions.
+// OBSOLETE pp points to string starting with list of functions
+// OBSOLETE eg: A:ZcA;1@Bpub v2@Bvirpri;__ct__1AFv func__1AFv *sfunc__1AFv ;as__1A ;;
+// OBSOLETE ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+// OBSOLETE A:ZcA;;foopri__1AFv foopro__1AFv __ct__1AFv __ct__1AFRC1A foopub__1AFv ;;;
+// OBSOLETE ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+// OBSOLETE */
+
+// OBSOLETE static int
+// OBSOLETE read_cfront_member_functions (struct field_info *fip, char **pp,
+// OBSOLETE struct type *type, struct objfile *objfile)
+// OBSOLETE {
+// OBSOLETE /* This code extracted from read_member_functions
+// OBSOLETE so as to do the similar thing for our funcs */
+
+// OBSOLETE int nfn_fields = 0;
+// OBSOLETE int length = 0;
+// OBSOLETE /* Total number of member functions defined in this class. If the class
+// OBSOLETE defines two `f' functions, and one `g' function, then this will have
+// OBSOLETE the value 3. */
+// OBSOLETE int total_length = 0;
+// OBSOLETE int i;
+// OBSOLETE struct next_fnfield
+// OBSOLETE {
+// OBSOLETE struct next_fnfield *next;
+// OBSOLETE struct fn_field fn_field;
+// OBSOLETE }
+// OBSOLETE *sublist;
+// OBSOLETE struct type *look_ahead_type;
+// OBSOLETE struct next_fnfieldlist *new_fnlist;
+// OBSOLETE struct next_fnfield *new_sublist;
+// OBSOLETE char *main_fn_name;
+// OBSOLETE char *fname;
+// OBSOLETE struct symbol *ref_func = 0;
+
+// OBSOLETE /* Process each list until we find the end of the member functions.
+// OBSOLETE eg: p = "__ct__1AFv foo__1AFv ;;;" */
+
+// OBSOLETE STABS_CONTINUE (pp, objfile); /* handle \\ */
+
+// OBSOLETE while (**pp != ';' && (fname = get_substring (pp, ' '), fname))
+// OBSOLETE {
+// OBSOLETE int is_static = 0;
+// OBSOLETE int sublist_count = 0;
+// OBSOLETE char *pname;
+// OBSOLETE if (fname[0] == '*') /* static member */
+// OBSOLETE {
+// OBSOLETE is_static = 1;
+// OBSOLETE sublist_count++;
+// OBSOLETE fname++;
+// OBSOLETE }
+// OBSOLETE ref_func = lookup_symbol (fname, 0, VAR_DOMAIN, 0, 0); /* demangled name */
+// OBSOLETE if (!ref_func)
+// OBSOLETE {
+// OBSOLETE complaint (&symfile_complaints,
+// OBSOLETE "Unable to find function symbol for %s", fname);
+// OBSOLETE continue;
+// OBSOLETE }
+// OBSOLETE sublist = NULL;
+// OBSOLETE look_ahead_type = NULL;
+// OBSOLETE length = 0;
+
+// OBSOLETE new_fnlist = (struct next_fnfieldlist *)
+// OBSOLETE xmalloc (sizeof (struct next_fnfieldlist));
+// OBSOLETE make_cleanup (xfree, new_fnlist);
+// OBSOLETE memset (new_fnlist, 0, sizeof (struct next_fnfieldlist));
+
+// OBSOLETE /* The following is code to work around cfront generated stabs.
+// OBSOLETE The stabs contains full mangled name for each field.
+// OBSOLETE We try to demangle the name and extract the field name out of it. */
+// OBSOLETE {
+// OBSOLETE char *dem, *dem_p, *dem_args;
+// OBSOLETE int dem_len;
+// OBSOLETE dem = cplus_demangle (fname, DMGL_ANSI | DMGL_PARAMS);
+// OBSOLETE if (dem != NULL)
+// OBSOLETE {
+// OBSOLETE dem_p = strrchr (dem, ':');
+// OBSOLETE if (dem_p != 0 && *(dem_p - 1) == ':')
+// OBSOLETE dem_p++;
+// OBSOLETE /* get rid of args */
+// OBSOLETE dem_args = strchr (dem_p, '(');
+// OBSOLETE if (dem_args == NULL)
+// OBSOLETE dem_len = strlen (dem_p);
+// OBSOLETE else
+// OBSOLETE dem_len = dem_args - dem_p;
+// OBSOLETE main_fn_name =
+// OBSOLETE obsavestring (dem_p, dem_len, &objfile->type_obstack);
+// OBSOLETE }
+// OBSOLETE else
+// OBSOLETE {
+// OBSOLETE main_fn_name =
+// OBSOLETE obsavestring (fname, strlen (fname), &objfile->type_obstack);
+// OBSOLETE }
+// OBSOLETE } /* end of code for cfront work around */
+
+// OBSOLETE new_fnlist->fn_fieldlist.name = main_fn_name;
+
+// OBSOLETE /*-------------------------------------------------*/
+// OBSOLETE /* Set up the sublists
+// OBSOLETE Sublists are stuff like args, static, visibility, etc.
+// OBSOLETE so in ARM, we have to set that info some other way.
+// OBSOLETE Multiple sublists happen if overloading
+// OBSOLETE eg: foo::26=##1;:;2A.;
+// OBSOLETE In g++, we'd loop here thru all the sublists... */
+
+// OBSOLETE new_sublist =
+// OBSOLETE (struct next_fnfield *) xmalloc (sizeof (struct next_fnfield));
+// OBSOLETE make_cleanup (xfree, new_sublist);
+// OBSOLETE memset (new_sublist, 0, sizeof (struct next_fnfield));
+
+// OBSOLETE /* eat 1; from :;2A.; */
+// OBSOLETE new_sublist->fn_field.type = SYMBOL_TYPE (ref_func); /* normally takes a read_type */
+// OBSOLETE /* Make this type look like a method stub for gdb */
+// OBSOLETE TYPE_FLAGS (new_sublist->fn_field.type) |= TYPE_FLAG_STUB;
+// OBSOLETE TYPE_CODE (new_sublist->fn_field.type) = TYPE_CODE_METHOD;
+
+// OBSOLETE /* If this is just a stub, then we don't have the real name here. */
+// OBSOLETE if (TYPE_STUB (new_sublist->fn_field.type))
+// OBSOLETE {
+// OBSOLETE if (!TYPE_DOMAIN_TYPE (new_sublist->fn_field.type))
+// OBSOLETE TYPE_DOMAIN_TYPE (new_sublist->fn_field.type) = type;
+// OBSOLETE new_sublist->fn_field.is_stub = 1;
+// OBSOLETE }
+
+// OBSOLETE /* physname used later in mangling; eg PFs_i,5 for foo__1aFPFs_i
+// OBSOLETE physname gets strcat'd in order to recreate the onto mangled name */
+// OBSOLETE pname = get_cfront_method_physname (fname);
+// OBSOLETE new_sublist->fn_field.physname = savestring (pname, strlen (pname));
+
+
+// OBSOLETE /* Set this member function's visibility fields.
+// OBSOLETE Unable to distinguish access from stabs definition!
+// OBSOLETE Assuming public for now. FIXME!
+// OBSOLETE (for private, set new_sublist->fn_field.is_private = 1,
+// OBSOLETE for public, set new_sublist->fn_field.is_protected = 1) */
+
+// OBSOLETE /* Unable to distinguish const/volatile from stabs definition!
+// OBSOLETE Assuming normal for now. FIXME! */
+
+// OBSOLETE new_sublist->fn_field.is_const = 0;
+// OBSOLETE new_sublist->fn_field.is_volatile = 0; /* volatile not implemented in cfront */
+
+// OBSOLETE /* Set virtual/static function info
+// OBSOLETE How to get vtable offsets ?
+// OBSOLETE Assuming normal for now FIXME!!
+// OBSOLETE For vtables, figure out from whence this virtual function came.
+// OBSOLETE It may belong to virtual function table of
+// OBSOLETE one of its baseclasses.
+// OBSOLETE set:
+// OBSOLETE new_sublist -> fn_field.voffset = vtable offset,
+// OBSOLETE new_sublist -> fn_field.fcontext = look_ahead_type;
+// OBSOLETE where look_ahead_type is type of baseclass */
+// OBSOLETE if (is_static)
+// OBSOLETE new_sublist->fn_field.voffset = VOFFSET_STATIC;
+// OBSOLETE else /* normal member function. */
+// OBSOLETE new_sublist->fn_field.voffset = 0;
+// OBSOLETE new_sublist->fn_field.fcontext = 0;
+
+
+// OBSOLETE /* Prepare new sublist */
+// OBSOLETE new_sublist->next = sublist;
+// OBSOLETE sublist = new_sublist;
+// OBSOLETE length++;
+
+// OBSOLETE /* In g++, we loop thu sublists - now we set from functions. */
+// OBSOLETE new_fnlist->fn_fieldlist.fn_fields = (struct fn_field *)
+// OBSOLETE obstack_alloc (&objfile->type_obstack,
+// OBSOLETE sizeof (struct fn_field) * length);
+// OBSOLETE memset (new_fnlist->fn_fieldlist.fn_fields, 0,
+// OBSOLETE sizeof (struct fn_field) * length);
+// OBSOLETE for (i = length; (i--, sublist); sublist = sublist->next)
+// OBSOLETE {
+// OBSOLETE new_fnlist->fn_fieldlist.fn_fields[i] = sublist->fn_field;
+// OBSOLETE }
+
+// OBSOLETE new_fnlist->fn_fieldlist.length = length;
+// OBSOLETE new_fnlist->next = fip->fnlist;
+// OBSOLETE fip->fnlist = new_fnlist;
+// OBSOLETE nfn_fields++;
+// OBSOLETE total_length += length;
+// OBSOLETE STABS_CONTINUE (pp, objfile); /* handle \\ */
+// OBSOLETE } /* end of loop */
+
+// OBSOLETE if (nfn_fields)
+// OBSOLETE {
+// OBSOLETE /* type should already have space */
+// OBSOLETE TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
+// OBSOLETE TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * nfn_fields);
+// OBSOLETE memset (TYPE_FN_FIELDLISTS (type), 0,
+// OBSOLETE sizeof (struct fn_fieldlist) * nfn_fields);
+// OBSOLETE TYPE_NFN_FIELDS (type) = nfn_fields;
+// OBSOLETE TYPE_NFN_FIELDS_TOTAL (type) = total_length;
+// OBSOLETE }
+
+// OBSOLETE /* end of scope for reading member func */
+
+// OBSOLETE /* eg: ";;" */
+
+// OBSOLETE /* Skip trailing ';' and bump count of number of fields seen */
+// OBSOLETE if (**pp == ';')
+// OBSOLETE (*pp)++;
+// OBSOLETE else
+// OBSOLETE return 0;
+// OBSOLETE return 1;
+// OBSOLETE }
+
+// OBSOLETE /* This routine fixes up partial cfront types that were created
+// OBSOLETE while parsing the stabs. The main need for this function is
+// OBSOLETE to add information such as methods to classes.
+// OBSOLETE Examples of "p": "sA;;__ct__1AFv foo__1AFv ;;;" */
+// OBSOLETE int
+// OBSOLETE resolve_cfront_continuation (struct objfile *objfile, struct symbol *sym,
+// OBSOLETE char *p)
+// OBSOLETE {
+// OBSOLETE struct symbol *ref_sym = 0;
+// OBSOLETE char *sname;
+// OBSOLETE /* snarfed from read_struct_type */
+// OBSOLETE struct field_info fi;
+// OBSOLETE struct type *type;
+// OBSOLETE struct cleanup *back_to;
+
+// OBSOLETE /* Need to make sure that fi isn't gunna conflict with struct
+// OBSOLETE in case struct already had some fnfs */
+// OBSOLETE fi.list = NULL;
+// OBSOLETE fi.fnlist = NULL;
+// OBSOLETE back_to = make_cleanup (null_cleanup, 0);
+
+// OBSOLETE /* We only accept structs, classes and unions at the moment.
+// OBSOLETE Other continuation types include t (typedef), r (long dbl), ...
+// OBSOLETE We may want to add support for them as well;
+// OBSOLETE right now they are handled by duplicating the symbol information
+// OBSOLETE into the type information (see define_symbol) */
+// OBSOLETE if (*p != 's' /* structs */
+// OBSOLETE && *p != 'c' /* class */
+// OBSOLETE && *p != 'u') /* union */
+// OBSOLETE return 0; /* only handle C++ types */
+// OBSOLETE p++;
+
+// OBSOLETE /* Get symbol typs name and validate
+// OBSOLETE eg: p = "A;;__ct__1AFv foo__1AFv ;;;" */
+// OBSOLETE sname = get_substring (&p, ';');
+// OBSOLETE if (!sname || strcmp (sname, DEPRECATED_SYMBOL_NAME (sym)))
+// OBSOLETE error ("Internal error: base symbol type name does not match\n");
+
+// OBSOLETE /* Find symbol's internal gdb reference using demangled_name.
+// OBSOLETE This is the real sym that we want;
+// OBSOLETE sym was a temp hack to make debugger happy */
+// OBSOLETE ref_sym = lookup_symbol (DEPRECATED_SYMBOL_NAME (sym), 0, STRUCT_DOMAIN, 0, 0);
+// OBSOLETE type = SYMBOL_TYPE (ref_sym);
+
+
+// OBSOLETE /* Now read the baseclasses, if any, read the regular C struct or C++
+// OBSOLETE class member fields, attach the fields to the type, read the C++
+// OBSOLETE member functions, attach them to the type, and then read any tilde
+// OBSOLETE field (baseclass specifier for the class holding the main vtable). */
+
+// OBSOLETE if (!read_cfront_baseclasses (&fi, &p, type, objfile)
+// OBSOLETE /* g++ does this next, but cfront already did this:
+// OBSOLETE || !read_struct_fields (&fi, &p, type, objfile) */
+// OBSOLETE || !copy_cfront_struct_fields (&fi, type, objfile)
+// OBSOLETE || !read_cfront_member_functions (&fi, &p, type, objfile)
+// OBSOLETE || !read_cfront_static_fields (&fi, &p, type, objfile)
+// OBSOLETE || !attach_fields_to_type (&fi, type, objfile)
+// OBSOLETE || !attach_fn_fields_to_type (&fi, type)
+// OBSOLETE /* g++ does this next, but cfront doesn't seem to have this:
+// OBSOLETE || !read_tilde_fields (&fi, &p, type, objfile) */
+// OBSOLETE )
+// OBSOLETE {
+// OBSOLETE type = error_type (&p, objfile);
+// OBSOLETE }
+
+// OBSOLETE do_cleanups (back_to);
+// OBSOLETE return 0;
+// OBSOLETE }
+// OBSOLETE /* End of code added to support parsing of ARM/Cfront stabs strings */
+#endif /* OBSOLETE CFront */
/* This routine fixes up symbol references/aliases to point to the original
symbol definition. Returns 0 on failure, non-zero on success. */
will correctly print the name.
Don't add_symbol_to_list so that lookup_symbol won't find it.
nope... needed for fixups. */
- SYMBOL_NAME (sym) = SYMBOL_NAME (ref_sym);
+ DEPRECATED_SYMBOL_NAME (sym) = DEPRECATED_SYMBOL_NAME (ref_sym);
/* Done! */
return 1;
switch (string[1])
{
case 't':
- SYMBOL_NAME (sym) = obsavestring ("this", strlen ("this"),
+ DEPRECATED_SYMBOL_NAME (sym) = obsavestring ("this", strlen ("this"),
&objfile->symbol_obstack);
break;
case 'v': /* $vtbl_ptr_type */
- /* Was: SYMBOL_NAME (sym) = "vptr"; */
+ /* Was: DEPRECATED_SYMBOL_NAME (sym) = "vptr"; */
goto normal;
case 'e':
- SYMBOL_NAME (sym) = obsavestring ("eh_throw", strlen ("eh_throw"),
+ DEPRECATED_SYMBOL_NAME (sym) = obsavestring ("eh_throw", strlen ("eh_throw"),
&objfile->symbol_obstack);
break;
return NULL;
/* S..P contains the name of the symbol. We need to store
- the correct name into SYMBOL_NAME. */
+ the correct name into DEPRECATED_SYMBOL_NAME. */
nlen = p - s;
if (refnum >= 0)
{
if (nlen > 0)
- {
- SYMBOL_NAME (sym) = (char *)
- obstack_alloc (&objfile->symbol_obstack, nlen);
- strncpy (SYMBOL_NAME (sym), s, nlen);
- SYMBOL_NAME (sym)[nlen] = '\0';
- SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->symbol_obstack);
- }
+ SYMBOL_SET_NAMES (sym, s, nlen, objfile);
else
- /* FIXME! Want SYMBOL_NAME (sym) = 0;
+ /* FIXME! Want DEPRECATED_SYMBOL_NAME (sym) = 0;
Get error if leave name 0. So give it something. */
{
nlen = p - string;
- SYMBOL_NAME (sym) = (char *)
- obstack_alloc (&objfile->symbol_obstack, nlen);
- strncpy (SYMBOL_NAME (sym), string, nlen);
- SYMBOL_NAME (sym)[nlen] = '\0';
- SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->symbol_obstack);
+ SYMBOL_SET_NAMES (sym, string, nlen, objfile);
}
}
/* Advance STRING beyond the reference id. */
{
normal:
SYMBOL_LANGUAGE (sym) = current_subfile->language;
- SYMBOL_NAME (sym) = (char *)
- obstack_alloc (&objfile->symbol_obstack, ((p - string) + 1));
- /* Open-coded memcpy--saves function call time. */
- /* FIXME: Does it really? Try replacing with simple strcpy and
- try it on an executable with a large symbol table. */
- /* FIXME: considering that gcc can open code memcpy anyway, I
- doubt it. xoxorich. */
- {
- register char *p1 = string;
- register char *p2 = SYMBOL_NAME (sym);
- while (p1 != p)
- {
- *p2++ = *p1++;
- }
- *p2++ = '\0';
- }
-
- /* If this symbol is from a C++ compilation, then attempt to cache the
- demangled form for future reference. This is a typical time versus
- space tradeoff, that was decided in favor of time because it sped up
- C++ symbol lookups by a factor of about 20. */
-
- SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->symbol_obstack);
+ SYMBOL_SET_NAMES (sym, string, p - string, objfile);
}
p++;
{
SYMBOL_CLASS (sym) = LOC_CONST;
SYMBOL_TYPE (sym) = error_type (&p, objfile);
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
add_symbol_to_list (sym, &file_symbols);
return sym;
}
SYMBOL_TYPE (sym) = error_type (&p, objfile);
}
}
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
add_symbol_to_list (sym, &file_symbols);
return sym;
/* The name of a caught exception. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_CLASS (sym) = LOC_LABEL;
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_VALUE_ADDRESS (sym) = valu;
add_symbol_to_list (sym, &local_symbols);
break;
/* A static function definition. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_CLASS (sym) = LOC_BLOCK;
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
add_symbol_to_list (sym, &file_symbols);
/* fall into process_function_types. */
if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_FUNC)
SYMBOL_TYPE (sym) = lookup_function_type (SYMBOL_TYPE (sym));
- /* All functions in C++ have prototypes. */
- if (SYMBOL_LANGUAGE (sym) == language_cplus)
- TYPE_FLAGS (SYMBOL_TYPE (sym)) |= TYPE_FLAG_PROTOTYPED;
+ /* All functions in C++ have prototypes. Stabs does not offer an
+ explicit way to identify prototyped or unprototyped functions,
+ but both GCC and Sun CC emit stabs for the "call-as" type rather
+ than the "declared-as" type for unprototyped functions, so
+ we treat all functions as if they were prototyped. This is used
+ primarily for promotion when calling the function from GDB. */
+ TYPE_FLAGS (SYMBOL_TYPE (sym)) |= TYPE_FLAG_PROTOTYPED;
/* fall into process_prototype_types */
/* A global function definition. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_CLASS (sym) = LOC_BLOCK;
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
add_symbol_to_list (sym, &global_symbols);
goto process_function_types;
These definitions appear at the end of the namelist. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_CLASS (sym) = LOC_STATIC;
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
/* Don't add symbol references to global_sym_chain.
Symbol references don't have valid names and wont't match up with
minimal symbols when the global_sym_chain is relocated.
We'll fixup symbol references when we fixup the defining symbol. */
- if (SYMBOL_NAME (sym) && SYMBOL_NAME (sym)[0] != '#')
+ if (DEPRECATED_SYMBOL_NAME (sym) && DEPRECATED_SYMBOL_NAME (sym)[0] != '#')
{
- i = hashname (SYMBOL_NAME (sym));
+ i = hashname (DEPRECATED_SYMBOL_NAME (sym));
SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
global_sym_chain[i] = sym;
}
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_CLASS (sym) = LOC_LOCAL;
SYMBOL_VALUE (sym) = valu;
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
add_symbol_to_list (sym, &local_symbols);
break;
else
SYMBOL_TYPE (sym) = read_type (&p, objfile);
- /* Normally this is a parameter, a LOC_ARG. On the i960, it
- can also be a LOC_LOCAL_ARG depending on symbol type. */
-#ifndef DBX_PARM_SYMBOL_CLASS
-#define DBX_PARM_SYMBOL_CLASS(type) LOC_ARG
-#endif
-
- SYMBOL_CLASS (sym) = DBX_PARM_SYMBOL_CLASS (type);
+ SYMBOL_CLASS (sym) = LOC_ARG;
SYMBOL_VALUE (sym) = valu;
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
add_symbol_to_list (sym, &local_symbols);
if (TARGET_BYTE_ORDER != BFD_ENDIAN_BIG)
{
reg_value_complaint (SYMBOL_VALUE (sym),
NUM_REGS + NUM_PSEUDO_REGS,
- SYMBOL_SOURCE_NAME (sym));
+ SYMBOL_PRINT_NAME (sym));
SYMBOL_VALUE (sym) = SP_REGNUM; /* Known safe, though useless */
}
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
add_symbol_to_list (sym, &local_symbols);
break;
{
reg_value_complaint (SYMBOL_VALUE (sym),
NUM_REGS + NUM_PSEUDO_REGS,
- SYMBOL_SOURCE_NAME (sym));
+ SYMBOL_PRINT_NAME (sym));
SYMBOL_VALUE (sym) = SP_REGNUM; /* Known safe, though useless */
}
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
if (within_function)
{
/* Sun cc uses a pair of symbols, one 'p' and one 'r' with the same
prev_sym = local_symbols->symbol[local_symbols->nsyms - 1];
if ((SYMBOL_CLASS (prev_sym) == LOC_REF_ARG
|| SYMBOL_CLASS (prev_sym) == LOC_ARG)
- && STREQ (SYMBOL_NAME (prev_sym), SYMBOL_NAME (sym)))
+ && STREQ (DEPRECATED_SYMBOL_NAME (prev_sym), DEPRECATED_SYMBOL_NAME (sym)))
{
SYMBOL_CLASS (prev_sym) = LOC_REGPARM;
/* Use the type from the LOC_REGISTER; that is the type
SYMBOL_CLASS (sym) = LOC_STATIC;
SYMBOL_VALUE_ADDRESS (sym) = valu;
#ifdef STATIC_TRANSFORM_NAME
- if (IS_STATIC_TRANSFORM_NAME (SYMBOL_NAME (sym)))
+ if (IS_STATIC_TRANSFORM_NAME (DEPRECATED_SYMBOL_NAME (sym)))
{
struct minimal_symbol *msym;
- msym = lookup_minimal_symbol (SYMBOL_NAME (sym), NULL, objfile);
+ msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym), NULL, objfile);
if (msym != NULL)
{
- SYMBOL_NAME (sym) = STATIC_TRANSFORM_NAME (SYMBOL_NAME (sym));
+ DEPRECATED_SYMBOL_NAME (sym) = STATIC_TRANSFORM_NAME (DEPRECATED_SYMBOL_NAME (sym));
SYMBOL_VALUE_ADDRESS (sym) = SYMBOL_VALUE_ADDRESS (msym);
}
}
#endif
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
add_symbol_to_list (sym, &file_symbols);
break;
SYMBOL_CLASS (sym) = LOC_TYPEDEF;
SYMBOL_VALUE (sym) = valu;
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
/* C++ vagaries: we may have a type which is derived from
a base type which did not have its name defined when the
derived class was output. We fill in the derived class's
extern const char vtbl_ptr_name[];
if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
- && strcmp (SYMBOL_NAME (sym), vtbl_ptr_name))
+ && strcmp (DEPRECATED_SYMBOL_NAME (sym), vtbl_ptr_name))
|| TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
{
/* If we are giving a name to a type such as "pointer to
/* Pascal accepts names for pointer types. */
if (current_subfile->language == language_pascal)
{
- TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_NAME (sym);
+ TYPE_NAME (SYMBOL_TYPE (sym)) = DEPRECATED_SYMBOL_NAME (sym);
}
}
else
- TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_NAME (sym);
+ TYPE_NAME (SYMBOL_TYPE (sym)) = DEPRECATED_SYMBOL_NAME (sym);
}
add_symbol_to_list (sym, &file_symbols);
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)
SYMBOL_CLASS (sym) = LOC_TYPEDEF;
SYMBOL_VALUE (sym) = valu;
- SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
+ SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)
TYPE_TAG_NAME (SYMBOL_TYPE (sym))
- = obconcat (&objfile->type_obstack, "", "", SYMBOL_NAME (sym));
+ = obconcat (&objfile->type_obstack, "", "", DEPRECATED_SYMBOL_NAME (sym));
add_symbol_to_list (sym, &file_symbols);
if (synonym)
*typedef_sym = *sym;
SYMBOL_CLASS (typedef_sym) = LOC_TYPEDEF;
SYMBOL_VALUE (typedef_sym) = valu;
- SYMBOL_NAMESPACE (typedef_sym) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
TYPE_NAME (SYMBOL_TYPE (sym))
- = obconcat (&objfile->type_obstack, "", "", SYMBOL_NAME (sym));
+ = obconcat (&objfile->type_obstack, "", "", DEPRECATED_SYMBOL_NAME (sym));
add_symbol_to_list (typedef_sym, &file_symbols);
}
break;
SYMBOL_CLASS (sym) = LOC_STATIC;
SYMBOL_VALUE_ADDRESS (sym) = valu;
#ifdef STATIC_TRANSFORM_NAME
- if (IS_STATIC_TRANSFORM_NAME (SYMBOL_NAME (sym)))
+ if (IS_STATIC_TRANSFORM_NAME (DEPRECATED_SYMBOL_NAME (sym)))
{
struct minimal_symbol *msym;
- msym = lookup_minimal_symbol (SYMBOL_NAME (sym), NULL, objfile);
+ msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym), NULL, objfile);
if (msym != NULL)
{
- SYMBOL_NAME (sym) = STATIC_TRANSFORM_NAME (SYMBOL_NAME (sym));
+ DEPRECATED_SYMBOL_NAME (sym) = STATIC_TRANSFORM_NAME (DEPRECATED_SYMBOL_NAME (sym));
SYMBOL_VALUE_ADDRESS (sym) = SYMBOL_VALUE_ADDRESS (msym);
}
}
#endif
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
-#if 0 /* OBSOLETE OS9K */
-// OBSOLETE if (os9k_stabs)
-// OBSOLETE add_symbol_to_list (sym, &global_symbols);
-// OBSOLETE else
-#endif /* OBSOLETE OS9K */
+ SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
add_symbol_to_list (sym, &local_symbols);
break;
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_CLASS (sym) = LOC_REF_ARG;
SYMBOL_VALUE (sym) = valu;
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
add_symbol_to_list (sym, &local_symbols);
break;
{
reg_value_complaint (SYMBOL_VALUE (sym),
NUM_REGS + NUM_PSEUDO_REGS,
- SYMBOL_SOURCE_NAME (sym));
+ SYMBOL_PRINT_NAME (sym));
SYMBOL_VALUE (sym) = SP_REGNUM; /* Known safe, though useless */
}
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
add_symbol_to_list (sym, &local_symbols);
break;
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_CLASS (sym) = LOC_LOCAL;
SYMBOL_VALUE (sym) = valu;
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
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_DOMAIN (sym) = VAR_DOMAIN;
+// OBSOLETE /* Don't add to list - we'll delete it later when
+// OBSOLETE we add the continuation to the real sym */
+// OBSOLETE return sym;
+// OBSOLETE /* End of new code added to support cfront stabs strings */
+#endif /* OBSOLETE CFront */
default:
SYMBOL_TYPE (sym) = error_type (&p, objfile);
SYMBOL_CLASS (sym) = LOC_CONST;
SYMBOL_VALUE (sym) = 0;
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
add_symbol_to_list (sym, &file_symbols);
break;
}
struct symbol *sym = ppt->symbol[i];
if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
- && SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE
+ && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
&& (TYPE_CODE (SYMBOL_TYPE (sym)) == code)
- && STREQ (SYMBOL_NAME (sym), type_name))
+ && STREQ (DEPRECATED_SYMBOL_NAME (sym), type_name))
{
obstack_free (&objfile->type_obstack, type_name);
type = SYMBOL_TYPE (sym);
break;
case 'f': /* Function returning another type */
-#if 0 /* OBSOLETE OS9K */
-// OBSOLETE if (os9k_stabs && **pp == '(')
-// OBSOLETE {
-// OBSOLETE /* Function prototype; parse it.
-// OBSOLETE We must conditionalize this on os9k_stabs because otherwise
-// OBSOLETE it could be confused with a Sun-style (1,3) typenumber
-// OBSOLETE (I think). */
-// OBSOLETE struct type *t;
-// OBSOLETE ++*pp;
-// OBSOLETE while (**pp != ')')
-// OBSOLETE {
-// OBSOLETE t = read_type (pp, objfile);
-// OBSOLETE if (**pp == ',')
-// OBSOLETE ++ * pp;
-// OBSOLETE }
-// OBSOLETE }
-#endif /* OBSOLETE OS9K */
-
type1 = read_type (pp, objfile);
type = make_function_type (type1, dbx_lookup_type (typenums));
break;
}
case 'k': /* Const qualifier on some type (Sun) */
-#if 0 /* OBSOLETE OS9K */
-// OBSOLETE /* ezannoni 2002-07-16: This can be safely deleted, because 'c'
-// OBSOLETE means complex type in AIX stabs, while it means const qualifier
-// OBSOLETE in os9k stabs. Obviously we were supporting only the os9k meaning.
-// OBSOLETE We were erroring out if we were reading AIX stabs. Right now the
-// OBSOLETE erroring out will happen in the default clause of the switch. */
-// OBSOLETE case 'c': /* Const qualifier on some type (OS9000) */
-// OBSOLETE /* Because 'c' means other things to AIX and 'k' is perfectly good,
-// OBSOLETE only accept 'c' in the os9k_stabs case. */
-// OBSOLETE if (type_descriptor == 'c' && !os9k_stabs)
-// OBSOLETE return error_type (pp, objfile);
-#endif /* OBSOLETE OS9K */
type = read_type (pp, objfile);
type = make_cv_type (1, TYPE_VOLATILE (type), type,
dbx_lookup_type (typenums));
break;
case 'B': /* Volatile qual on some type (Sun) */
-#if 0 /* OBSOLETE OS9K */
-// OBSOLETE /* ezannoni 2002-07-16: This can be safely deleted, because 'i'
-// OBSOLETE means imported type in AIX stabs, while it means volatile qualifier
-// OBSOLETE in os9k stabs. Obviously we were supporting only the os9k meaning.
-// OBSOLETE We were erroring out if we were reading AIX stabs. Right now the
-// OBSOLETE erroring out will happen in the default clause of the switch. */
-// OBSOLETE case 'i': /* Volatile qual on some type (OS9000) */
-// OBSOLETE /* Because 'i' means other things to AIX and 'B' is perfectly good,
-// OBSOLETE only accept 'i' in the os9k_stabs case. */
-// OBSOLETE if (type_descriptor == 'i' && !os9k_stabs)
-// OBSOLETE return error_type (pp, objfile);
-#endif /* OBSOLETE OS9K */
type = read_type (pp, objfile);
type = make_cv_type (TYPE_CONST (type), 1, type,
dbx_lookup_type (typenums));
break;
case 'b':
-#if 0 /* OBSOLETE OS9K */
-// OBSOLETE if (os9k_stabs)
-// OBSOLETE /* Const and volatile qualified type. */
-// OBSOLETE type = read_type (pp, objfile);
-// OBSOLETE else
-#endif /* OBSOLETE OS9K */
{
/* Sun ACC builtin int type */
type = read_sun_builtin_type (pp, typenums, objfile);
method_name = method_name_from_physname (physname);
if (method_name == NULL)
- error ("bad physname %s\n", physname);
+ {
+ complaint (&symfile_complaints,
+ "Method has bad physname %s\n", physname);
+ return;
+ }
if (strcmp (*old_name, method_name) != 0)
{
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 */
+#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 */
- else
+// OBSOLETE else
+#endif /* OBSOLETE CFront */
fip->list->field.name =
obsavestring (*pp, p - *pp, &objfile->type_obstack);
*pp = p + 1;
while (**pp != ';' && **pp != '\0')
{
-#if 0 /* OBSOLETE OS9K */
-// OBSOLETE if (os9k_stabs && **pp == ',')
-// OBSOLETE break;
-#endif /* OBSOLETE OS9K */
STABS_CONTINUE (pp, objfile);
/* Get space to record the next field's data. */
new = (struct nextfield *) xmalloc (sizeof (struct nextfield));
}
if (p[0] == ':' && p[1] == ':')
{
- /* (OBSOLETE) chill (OBSOLETE) the list of fields: the last
- entry (at the head) is a partially constructed entry which we
- now scrub. */
+ /* (the deleted) chill the list of fields: the last entry (at
+ the head) is a partially constructed entry which we now
+ scrub. */
fip->list = fip->list->next;
}
return 1;
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_DOMAIN, 0, 0); /*demangled_name */
+// OBSOLETE if (!ref_static)
+// OBSOLETE {
+// OBSOLETE complaint (&symfile_complaints,
+// OBSOLETE "Unable to find symbol for static data field %s", sname);
+// OBSOLETE continue;
+// OBSOLETE }
+// OBSOLETE stype = SYMBOL_TYPE (ref_static);
+
+// OBSOLETE /* allocate a new fip */
+// OBSOLETE new = (struct nextfield *) xmalloc (sizeof (struct nextfield));
+// OBSOLETE make_cleanup (xfree, new);
+// OBSOLETE memset (new, 0, sizeof (struct nextfield));
+// OBSOLETE new->next = fip->list;
+// OBSOLETE fip->list = new;
+
+// OBSOLETE /* set visibility */
+// OBSOLETE /* FIXME! no way to tell visibility from stabs??? */
+// OBSOLETE new->visibility = VISIBILITY_PUBLIC;
+
+// OBSOLETE /* set field info into fip */
+// OBSOLETE fip->list->field.type = stype;
+
+// OBSOLETE /* set bitpos & bitsize */
+// OBSOLETE SET_FIELD_PHYSNAME (fip->list->field, savestring (sname, strlen (sname)));
+
+// OBSOLETE /* set name field */
+// OBSOLETE /* The following is code to work around cfront generated stabs.
+// OBSOLETE The stabs contains full mangled name for each field.
+// OBSOLETE We try to demangle the name and extract the field name out of it.
+// OBSOLETE */
+// OBSOLETE if (ARM_DEMANGLING)
+// OBSOLETE {
+// OBSOLETE char *dem, *dem_p;
+// OBSOLETE dem = cplus_demangle (sname, DMGL_ANSI | DMGL_PARAMS);
+// OBSOLETE if (dem != NULL)
+// OBSOLETE {
+// OBSOLETE dem_p = strrchr (dem, ':');
+// OBSOLETE if (dem_p != 0 && *(dem_p - 1) == ':')
+// OBSOLETE dem_p++;
+// OBSOLETE fip->list->field.name =
+// OBSOLETE obsavestring (dem_p, strlen (dem_p), &objfile->type_obstack);
+// OBSOLETE }
+// OBSOLETE else
+// OBSOLETE {
+// OBSOLETE fip->list->field.name =
+// OBSOLETE obsavestring (sname, strlen (sname), &objfile->type_obstack);
+// OBSOLETE }
+// OBSOLETE } /* end of code for cfront work around */
+// OBSOLETE } /* loop again for next static field */
+// OBSOLETE return 1;
+// OBSOLETE }
+
+// OBSOLETE /* Copy structure fields to fip so attach_fields_to_type will work.
+// OBSOLETE type has already been created with the initial instance data fields.
+// OBSOLETE Now we want to be able to add the other members to the class,
+// OBSOLETE so we want to add them back to the fip and reattach them again
+// OBSOLETE once we have collected all the class members. */
+
+// OBSOLETE static int
+// OBSOLETE copy_cfront_struct_fields (struct field_info *fip, struct type *type,
+// OBSOLETE struct objfile *objfile)
+// OBSOLETE {
+// OBSOLETE int nfields = TYPE_NFIELDS (type);
+// OBSOLETE int i;
+// OBSOLETE struct nextfield *new;
+
+// OBSOLETE /* Copy the fields into the list of fips and reset the types
+// OBSOLETE to remove the old fields */
+
+// OBSOLETE for (i = 0; i < nfields; i++)
+// OBSOLETE {
+// OBSOLETE /* allocate a new fip */
+// OBSOLETE new = (struct nextfield *) xmalloc (sizeof (struct nextfield));
+// OBSOLETE make_cleanup (xfree, new);
+// OBSOLETE memset (new, 0, sizeof (struct nextfield));
+// OBSOLETE new->next = fip->list;
+// OBSOLETE fip->list = new;
+
+// OBSOLETE /* copy field info into fip */
+// OBSOLETE new->field = TYPE_FIELD (type, i);
+// OBSOLETE /* set visibility */
+// OBSOLETE if (TYPE_FIELD_PROTECTED (type, i))
+// OBSOLETE new->visibility = VISIBILITY_PROTECTED;
+// OBSOLETE else if (TYPE_FIELD_PRIVATE (type, i))
+// OBSOLETE new->visibility = VISIBILITY_PRIVATE;
+// OBSOLETE else
+// OBSOLETE new->visibility = VISIBILITY_PUBLIC;
+// OBSOLETE }
+// OBSOLETE /* Now delete the fields from the type since we will be
+// OBSOLETE allocing new space once we get the rest of the fields
+// OBSOLETE in attach_fields_to_type.
+// OBSOLETE The pointer TYPE_FIELDS(type) is left dangling but should
+// OBSOLETE be freed later by objstack_free */
+// OBSOLETE TYPE_FIELDS (type) = 0;
+// OBSOLETE TYPE_NFIELDS (type) = 0;
+
+// OBSOLETE return 1;
+// OBSOLETE }
+#endif /* OBSOLETE CFront */
/* Create the vector of fields, and record how big it is.
We need this info to record proper virtual function table information
Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
for these, produce a type like float[][]. */
-#if 0 /* OBSOLETE OS9K */
-// OBSOLETE if (os9k_stabs)
-// OBSOLETE index_type = builtin_type_int;
-// OBSOLETE else
-#endif /* OBSOLETE OS9K */
{
index_type = read_type (pp, objfile);
if (**pp != ';')
(*pp)++;
adjustable = 1;
}
-#if 0 /* OBSOLETE OS9K */
-// OBSOLETE lower = read_huge_number (pp, os9k_stabs ? ',' : ';', &nbits);
-#else /* OBSOLETE OS9K */
lower = read_huge_number (pp, ';', &nbits);
-#endif /* OBSOLETE OS9K */
if (nbits != 0)
return error_type (pp, objfile);
osyms = *symlist;
o_nsyms = osyms ? osyms->nsyms : 0;
-#if 0 /* OBSOLETE OS9K */
-// OBSOLETE if (os9k_stabs)
-// OBSOLETE {
-// OBSOLETE /* Size. Perhaps this does not have to be conditionalized on
-// OBSOLETE os9k_stabs (assuming the name of an enum constant can't start
-// OBSOLETE with a digit). */
-// OBSOLETE read_huge_number (pp, 0, &nbits);
-// OBSOLETE if (nbits != 0)
-// OBSOLETE return error_type (pp, objfile);
-// OBSOLETE }
-#endif /* OBSOLETE OS9K */
-
/* The aix4 compiler emits an extra field before the enum members;
my guess is it's a type of some sort. Just ignore it. */
if (**pp == '-')
sym = (struct symbol *)
obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol));
memset (sym, 0, sizeof (struct symbol));
- SYMBOL_NAME (sym) = name;
+ DEPRECATED_SYMBOL_NAME (sym) = name;
SYMBOL_LANGUAGE (sym) = current_subfile->language;
SYMBOL_CLASS (sym) = LOC_CONST;
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_VALUE (sym) = n;
if (n < 0)
unsigned_enum = 0;
{
struct symbol *xsym = syms->symbol[j];
SYMBOL_TYPE (xsym) = type;
- TYPE_FIELD_NAME (type, n) = SYMBOL_NAME (xsym);
+ TYPE_FIELD_NAME (type, n) = DEPRECATED_SYMBOL_NAME (xsym);
TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
TYPE_FIELD_BITSIZE (type, n) = 0;
}
p++;
}
-#if 0 /* OBSOLETE OS9K */
-// OBSOLETE if (os9k_stabs)
-// OBSOLETE upper_limit = ULONG_MAX / radix;
-// OBSOLETE else
-#endif /* OBSOLETE OS9K */
- upper_limit = LONG_MAX / radix;
+ upper_limit = LONG_MAX / radix;
while ((c = *p++) >= '0' && c < ('0' + radix))
{
/* Special case: char is defined (Who knows why) as a subrange of
itself with range 0-127. */
else if (self_subrange && n2 == 0 && n3 == 127)
- return init_type (TYPE_CODE_INT, 1, 0, NULL, objfile);
-
-#if 0
- /* OBSOLETE else if (current_symbol && SYMBOL_LANGUAGE (current_symbol) == language_chill */
- /* OBSOLETE && !self_subrange) */
- /* OBSOLETE goto handle_true_range; */
-#endif
+ return init_type (TYPE_CODE_INT, 1, TYPE_FLAG_NOSIGN, NULL, objfile);
/* We used to do this only for subrange of self or subrange of int. */
else if (n2 == 0)
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;
+ DEPRECATED_SYMBOL_NAME (sym) = common_block_name;
SYMBOL_CLASS (sym) = LOC_BLOCK;
/* Now we copy all the symbols which have been defined since the BCOMM. */
/* Should we be putting local_symbols back to what it was?
Does it matter? */
- i = hashname (SYMBOL_NAME (sym));
+ i = hashname (DEPRECATED_SYMBOL_NAME (sym));
SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
global_sym_chain[i] = sym;
common_block_name = NULL;
struct symbol *sym = ppt->symbol[i];
if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
- && SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE
+ && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
&& (TYPE_CODE (SYMBOL_TYPE (sym)) ==
TYPE_CODE (*type))
- && STREQ (SYMBOL_NAME (sym), typename))
+ && STREQ (DEPRECATED_SYMBOL_NAME (sym), typename))
replace_type (*type, SYMBOL_TYPE (sym));
}
}
return;
for (msymbol = resolve_objfile->msymbols;
- msymbol && SYMBOL_NAME (msymbol) != NULL;
+ msymbol && DEPRECATED_SYMBOL_NAME (msymbol) != NULL;
msymbol++)
{
QUIT;
/* Get the hash index and check all the symbols
under that hash index. */
- hash = hashname (SYMBOL_NAME (msymbol));
+ hash = hashname (DEPRECATED_SYMBOL_NAME (msymbol));
for (sym = global_sym_chain[hash]; sym;)
{
- if (SYMBOL_NAME (msymbol)[0] == SYMBOL_NAME (sym)[0] &&
- STREQ (SYMBOL_NAME (msymbol) + 1, SYMBOL_NAME (sym) + 1))
+ if (DEPRECATED_SYMBOL_NAME (msymbol)[0] == DEPRECATED_SYMBOL_NAME (sym)[0] &&
+ STREQ (DEPRECATED_SYMBOL_NAME (msymbol) + 1, DEPRECATED_SYMBOL_NAME (sym) + 1))
{
struct alias_list *aliases;
else
complaint (&symfile_complaints,
"%s: common block `%s' from global_sym_chain unresolved",
- objfile->name, SYMBOL_NAME (prev));
+ objfile->name, DEPRECATED_SYMBOL_NAME (prev));
}
}
memset (global_sym_chain, 0, sizeof (global_sym_chain));
/* FIXME: If common_block_name is not already NULL, we should complain(). */
common_block_name = NULL;
-
-#if 0 /* OBSOLETE OS9K */
-// OBSOLETE os9k_stabs = 0;
-#endif /* OBSOLETE OS9K */
}
/* Call after end_symtab() */
projects / binutils.git / blobdiff