projects
/
deliverable
/
binutils-gdb.git
/ blobdiff
commit
grep
author
committer
pickaxe
?
search:
re
summary
|
shortlog
|
log
|
commit
|
commitdiff
|
tree
raw
|
inline
| side by side
ubsan: bfin: left shift of negative value
[deliverable/binutils-gdb.git]
/
gdb
/
stabsread.c
diff --git
a/gdb/stabsread.c
b/gdb/stabsread.c
index 71b92330c80d8a7083ba9e35c0d807bef3085fa3..5828ddd2c5d77f32d62ad6b3e67ced3452cf97d4 100644
(file)
--- a/
gdb/stabsread.c
+++ b/
gdb/stabsread.c
@@
-1,8
+1,6
@@
/* Support routines for decoding "stabs" debugging information format.
/* Support routines for decoding "stabs" debugging information format.
- Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
- 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
- 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+ Copyright (C) 1986-2019 Free Software Foundation, Inc.
This file is part of GDB.
This file is part of GDB.
@@
-20,13
+18,13
@@
along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* Support routines for reading and decoding debugging information in
along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* Support routines for reading and decoding debugging information in
- the "stabs" format. This format is used with many systems that use
- the a.out object file format, as well as some systems that use
- COFF or ELF where the stabs data is placed in a special section.
- Avoid placing any object file format specific code in this file. */
+ the "stabs" format. This format is used by some systems that use
+ COFF or ELF where the stabs data is placed in a special section (as
+ well as with many old systems that used the a.out object file
+ format). Avoid placing any object file format specific code in
+ this file. */
#include "defs.h"
#include "defs.h"
-#include "gdb_string.h"
#include "bfd.h"
#include "gdb_obstack.h"
#include "symtab.h"
#include "bfd.h"
#include "gdb_obstack.h"
#include "symtab.h"
@@
-38,123
+36,136
@@
#include "libaout.h"
#include "aout/aout64.h"
#include "gdb-stabs.h"
#include "libaout.h"
#include "aout/aout64.h"
#include "gdb-stabs.h"
-#include "buildsym.h"
+#include "buildsym
-legacy
.h"
#include "complaints.h"
#include "demangle.h"
#include "complaints.h"
#include "demangle.h"
+#include "gdb-demangle.h"
#include "language.h"
#include "language.h"
-#include "doublest.h"
+#include "target-float.h"
+#include "c-lang.h"
#include "cp-abi.h"
#include "cp-support.h"
#include "cp-abi.h"
#include "cp-support.h"
-#include "gdb_assert.h"
-
#include <ctype.h>
#include <ctype.h>
-/* Ask stabsread.h to define the vars it normally declares `extern'. */
-#define EXTERN
-/**/
-#include "stabsread.h" /* Our own declarations */
-#undef EXTERN
+#include "stabsread.h"
+
+/* See stabsread.h for these globals. */
+unsigned int symnum;
+const char *(*next_symbol_text_func) (struct objfile *);
+unsigned char processing_gcc_compilation;
+int within_function;
+struct symbol *global_sym_chain[HASHSIZE];
+struct pending_stabs *global_stabs;
+int previous_stab_code;
+int *this_object_header_files;
+int n_this_object_header_files;
+int n_allocated_this_object_header_files;
+
+struct nextfield
+{
+ struct nextfield *next;
+
+ /* This is the raw visibility from the stab. It is not checked
+ for being one of the visibilities we recognize, so code which
+ examines this field better be able to deal. */
+ int visibility;
-extern void _initialize_stabsread (void);
+ struct field field;
+};
+
+struct next_fnfieldlist
+{
+ struct next_fnfieldlist *next;
+ struct fn_fieldlist fn_fieldlist;
+};
/* The routines that read and process a complete stabs for a C struct or
C++ class pass lists of data member fields and lists of member function
fields in an instance of a field_info structure, as defined below.
This is part of some reorganization of low level C++ support and is
/* The routines that read and process a complete stabs for a C struct or
C++ class pass lists of data member fields and lists of member function
fields in an instance of a field_info structure, as defined below.
This is part of some reorganization of low level C++ support and is
- expected to eventually go away... (FIXME) */
+ expected to eventually go away...
(FIXME) */
-struct field_info
+struct
stab_
field_info
{
{
- struct nextfield
- {
- struct nextfield *next;
-
- /* This is the raw visibility from the stab. It is not checked
- for being one of the visibilities we recognize, so code which
- examines this field better be able to deal. */
- int visibility;
+ struct nextfield *list = nullptr;
+ struct next_fnfieldlist *fnlist = nullptr;
- struct field field;
- }
- *list;
- struct next_fnfieldlist
- {
- struct next_fnfieldlist *next;
- struct fn_fieldlist fn_fieldlist;
- }
- *fnlist;
+ auto_obstack obstack;
};
static void
};
static void
-read_one_struct_field (struct
field_info *, char **,
char *,
+read_one_struct_field (struct
stab_field_info *, const char **, const
char *,
struct type *, struct objfile *);
static struct type *dbx_alloc_type (int[2], struct objfile *);
struct type *, struct objfile *);
static struct type *dbx_alloc_type (int[2], struct objfile *);
-static long read_huge_number (char **, int, int *, int);
+static long read_huge_number (c
onst c
har **, int, int *, int);
-static struct type *error_type (char **, struct objfile *);
+static struct type *error_type (c
onst c
har **, struct objfile *);
static void
patch_block_stabs (struct pending *, struct pending_stabs *,
struct objfile *);
static void
patch_block_stabs (struct pending *, struct pending_stabs *,
struct objfile *);
-static void fix_common_block (struct symbol *,
int
);
+static void fix_common_block (struct symbol *,
CORE_ADDR
);
-static int read_type_number (char **, int *);
+static int read_type_number (c
onst c
har **, int *);
-static struct type *read_type (char **, struct objfile *);
+static struct type *read_type (c
onst c
har **, struct objfile *);
-static struct type *read_range_type (char **, int[2], int, struct objfile *);
+static struct type *read_range_type (const char **, int[2],
+ int, struct objfile *);
-static struct type *read_sun_builtin_type (char **, int[2], struct objfile *);
+static struct type *read_sun_builtin_type (const char **,
+ int[2], struct objfile *);
-static struct type *read_sun_floating_type (char **, int[2],
+static struct type *read_sun_floating_type (c
onst c
har **, int[2],
struct objfile *);
struct objfile *);
-static struct type *read_enum_type (char **, struct type *, struct objfile *);
+static struct type *read_enum_type (c
onst c
har **, struct type *, struct objfile *);
static struct type *rs6000_builtin_type (int, struct objfile *);
static int
static struct type *rs6000_builtin_type (int, struct objfile *);
static int
-read_member_functions (struct
field_info *,
char **, struct type *,
+read_member_functions (struct
stab_field_info *, const
char **, struct type *,
struct objfile *);
static int
struct objfile *);
static int
-read_struct_fields (struct
field_info *,
char **, struct type *,
+read_struct_fields (struct
stab_field_info *, const
char **, struct type *,
struct objfile *);
static int
struct objfile *);
static int
-read_baseclasses (struct
field_info *,
char **, struct type *,
+read_baseclasses (struct
stab_field_info *, const
char **, struct type *,
struct objfile *);
static int
struct objfile *);
static int
-read_tilde_fields (struct
field_info *,
char **, struct type *,
+read_tilde_fields (struct
stab_field_info *, const
char **, struct type *,
struct objfile *);
struct objfile *);
-static int attach_fn_fields_to_type (struct field_info *, struct type *);
+static int attach_fn_fields_to_type (struct
stab_
field_info *, struct type *);
-static int attach_fields_to_type (struct field_info *, struct type *,
+static int attach_fields_to_type (struct
stab_
field_info *, struct type *,
struct objfile *);
struct objfile *);
-static struct type *read_struct_type (char **, struct type *,
+static struct type *read_struct_type (c
onst c
har **, struct type *,
enum type_code,
struct objfile *);
enum type_code,
struct objfile *);
-static struct type *read_array_type (char **, struct type *,
+static struct type *read_array_type (c
onst c
har **, struct type *,
struct objfile *);
struct objfile *);
-static struct field *read_args (char **, int, struct objfile *, int *, int *);
+static struct field *read_args (const char **, int, struct objfile *,
+ int *, int *);
static void add_undefined_type (struct type *, int[2]);
static int
static void add_undefined_type (struct type *, int[2]);
static int
-read_cpp_abbrev (struct
field_info *,
char **, struct type *,
+read_cpp_abbrev (struct
stab_field_info *, const
char **, struct type *,
struct objfile *);
struct objfile *);
-static c
har *find_name_end (
char *name);
+static c
onst char *find_name_end (const
char *name);
-static int process_reference (char **string);
+static int process_reference (c
onst c
har **string);
void stabsread_clear_cache (void);
void stabsread_clear_cache (void);
@@
-164,21
+175,20
@@
static const char vb_name[] = "_vb$";
static void
invalid_cpp_abbrev_complaint (const char *arg1)
{
static void
invalid_cpp_abbrev_complaint (const char *arg1)
{
- complaint (
&symfile_complaints,
_("invalid C++ abbreviation `%s'"), arg1);
+ complaint (_("invalid C++ abbreviation `%s'"), arg1);
}
static void
reg_value_complaint (int regnum, int num_regs, const char *sym)
{
}
static void
reg_value_complaint (int regnum, int num_regs, const char *sym)
{
- complaint (&symfile_complaints,
- _("register number %d too large (max %d) in symbol %s"),
+ complaint (_("bad register number %d (max %d) in symbol %s"),
regnum, num_regs - 1, sym);
}
static void
stabs_general_complaint (const char *arg1)
{
regnum, num_regs - 1, sym);
}
static void
stabs_general_complaint (const char *arg1)
{
- complaint (
&symfile_complaints,
"%s", arg1);
+ complaint ("%s", arg1);
}
/* Make a list of forward references which haven't been defined. */
}
/* Make a list of forward references which haven't been defined. */
@@
-190,7
+200,7
@@
static struct symbol *current_symbol = NULL;
/* Make a list of nameless types that are undefined.
This happens when another type is referenced by its number
/* Make a list of nameless types that are undefined.
This happens when another type is referenced by its number
- before this type is actually defined. For instance "t(0,1)=k(0,2)"
+ before this type is actually defined.
For instance "t(0,1)=k(0,2)"
and type (0,2) is defined only later. */
struct nat
and type (0,2) is defined only later. */
struct nat
@@
-208,6
+218,23
@@
static int noname_undefs_length;
if (**(pp) == '\\' || (**(pp) == '?' && (*(pp))[1] == '\0')) \
*(pp) = next_symbol_text (objfile); \
} while (0)
if (**(pp) == '\\' || (**(pp) == '?' && (*(pp))[1] == '\0')) \
*(pp) = next_symbol_text (objfile); \
} while (0)
+
+/* Vector of types defined so far, indexed by their type numbers.
+ (In newer sun systems, dbx uses a pair of numbers in parens,
+ as in "(SUBFILENUM,NUMWITHINSUBFILE)".
+ Then these numbers must be translated through the type_translations
+ hash table to get the index into the type vector.) */
+
+static struct type **type_vector;
+
+/* Number of elements allocated for type_vector currently. */
+
+static int type_vector_length;
+
+/* Initial size of type vector. Is realloc'd larger if needed, and
+ realloc'd down to the size actually used, when completed. */
+
+#define INITIAL_TYPE_VECTOR_LENGTH 160
\f
/* Look up a dbx type-number pair. Return the address of the slot
\f
/* Look up a dbx type-number pair. Return the address of the slot
@@
-232,8
+259,7
@@
dbx_lookup_type (int typenums[2], struct objfile *objfile)
if (filenum < 0 || filenum >= n_this_object_header_files)
{
if (filenum < 0 || filenum >= n_this_object_header_files)
{
- complaint (&symfile_complaints,
- _("Invalid symbol data: type number "
+ complaint (_("Invalid symbol data: type number "
"(%d,%d) out of range at symtab pos %d."),
filenum, index, symnum);
goto error_return;
"(%d,%d) out of range at symtab pos %d."),
filenum, index, symnum);
goto error_return;
@@
-262,8
+288,7
@@
dbx_lookup_type (int typenums[2], struct objfile *objfile)
if (old_len == 0)
{
type_vector_length = INITIAL_TYPE_VECTOR_LENGTH;
if (old_len == 0)
{
type_vector_length = INITIAL_TYPE_VECTOR_LENGTH;
- type_vector = (struct type **)
- xmalloc (type_vector_length * sizeof (struct type *));
+ type_vector = XNEWVEC (struct type *, type_vector_length);
}
while (index >= type_vector_length)
{
}
while (index >= type_vector_length)
{
@@
-314,7
+339,7
@@
dbx_lookup_type (int typenums[2], struct objfile *objfile)
and return the type object.
This can create an empty (zeroed) type object.
TYPENUMS may be (-1, -1) to return a new type object that is not
and return the type object.
This can create an empty (zeroed) type object.
TYPENUMS may be (-1, -1) to return a new type object that is not
- put into the type vector, and so may not be referred to by number. */
+ put into the type vector, and so may not be referred to by number.
*/
static struct type *
dbx_alloc_type (int typenums[2], struct objfile *objfile)
static struct type *
dbx_alloc_type (int typenums[2], struct objfile *objfile)
@@
-339,8
+364,26
@@
dbx_alloc_type (int typenums[2], struct objfile *objfile)
return (*type_addr);
}
return (*type_addr);
}
+/* Allocate a floating-point type of size BITS. */
+
+static struct type *
+dbx_init_float_type (struct objfile *objfile, int bits)
+{
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ const struct floatformat **format;
+ struct type *type;
+
+ format = gdbarch_floatformat_for_type (gdbarch, NULL, bits);
+ if (format)
+ type = init_float_type (objfile, bits, NULL, format);
+ else
+ type = init_type (objfile, TYPE_CODE_ERROR, bits, NULL);
+
+ return type;
+}
+
/* for all the stabs in a given stab vector, build appropriate types
/* for all the stabs in a given stab vector, build appropriate types
- and fix their symbols in given symbol vector. */
+ and fix their symbols in given symbol vector.
*/
static void
patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs,
static void
patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs,
@@
-348,13
+391,13
@@
patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs,
{
int ii;
char *name;
{
int ii;
char *name;
- char *pp;
+ c
onst c
har *pp;
struct symbol *sym;
if (stabs)
{
/* for all the stab entries, find their corresponding symbols and
struct symbol *sym;
if (stabs)
{
/* for all the stab entries, find their corresponding symbols and
- patch their types! */
+ patch their types!
*/
for (ii = 0; ii < stabs->count; ++ii)
{
for (ii = 0; ii < stabs->count; ++ii)
{
@@
-380,16
+423,11
@@
patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs,
/* On xcoff, if a global is defined and never referenced,
ld will remove it from the executable. There is then
a N_GSYM stab for it, but no regular (C_EXT) symbol. */
/* On xcoff, if a global is defined and never referenced,
ld will remove it from the executable. There is then
a N_GSYM stab for it, but no regular (C_EXT) symbol. */
- sym = (struct symbol *)
- obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct symbol));
-
- memset (sym, 0, sizeof (struct symbol));
+ sym = allocate_symbol (objfile);
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
- SYMBOL_SET_LINKAGE_NAME
- (sym, obsavestring (name, pp - name,
- &objfile->objfile_obstack));
+ SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
+ sym->set_linkage_name
+ (obstack_strndup (&objfile->objfile_obstack, name, pp - name));
pp += 2;
if (*(pp - 1) == 'F' || *(pp - 1) == 'f')
{
pp += 2;
if (*(pp - 1) == 'F' || *(pp - 1) == 'f')
{
@@
-403,7
+441,7
@@
patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs,
{
SYMBOL_TYPE (sym) = read_type (&pp, objfile);
}
{
SYMBOL_TYPE (sym) = read_type (&pp, objfile);
}
- add_symbol_to_list (sym,
&global_symbols
);
+ add_symbol_to_list (sym,
get_global_symbols ()
);
}
else
{
}
else
{
@@
-432,7
+470,7
@@
patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs,
Returns 0 for success, -1 for error. */
static int
Returns 0 for success, -1 for error. */
static int
-read_type_number (char **pp, int *typenums)
+read_type_number (c
onst c
har **pp, int *typenums)
{
int nbits;
{
int nbits;
@@
-463,11
+501,11
@@
read_type_number (char **pp, int *typenums)
#define VISIBILITY_IGNORE '9' /* Optimized out or zero length */
/* Structure for storing pointers to reference definitions for fast lookup
#define VISIBILITY_IGNORE '9' /* Optimized out or zero length */
/* Structure for storing pointers to reference definitions for fast lookup
- during "process_later". */
+ during "process_later".
*/
struct ref_map
{
struct ref_map
{
- char *stabs;
+ c
onst c
har *stabs;
CORE_ADDR value;
struct symbol *sym;
};
CORE_ADDR value;
struct symbol *sym;
};
@@
-478,15
+516,15
@@
struct ref_map
static struct ref_map *ref_map;
static struct ref_map *ref_map;
-/* Ptr to free cell in chunk's linked list. */
+/* Ptr to free cell in chunk's linked list.
*/
static int ref_count = 0;
static int ref_count = 0;
-/* Number of chunks malloced. */
+/* Number of chunks malloced.
*/
static int ref_chunk = 0;
/* This file maintains a cache of stabs aliases found in the symbol
static int ref_chunk = 0;
/* This file maintains a cache of stabs aliases found in the symbol
- table. If the symbol table changes, this cache must be cleared
- or we are left holding onto data in invalid obstacks. */
+ table.
If the symbol table changes, this cache must be cleared
+ or we are left holding onto data in invalid obstacks.
*/
void
stabsread_clear_cache (void)
{
void
stabsread_clear_cache (void)
{
@@
-496,10
+534,10
@@
stabsread_clear_cache (void)
/* Create array of pointers mapping refids to symbols and stab strings.
Add pointers to reference definition symbols and/or their values as we
/* Create array of pointers mapping refids to symbols and stab strings.
Add pointers to reference definition symbols and/or their values as we
- find them, using their reference numbers as our index.
- These will be used later when we resolve references. */
+ find them, using their reference numbers as our index.
+ These will be used later when we resolve references.
*/
void
void
-ref_add (int refnum, struct symbol *sym, char *stabs, CORE_ADDR value)
+ref_add (int refnum, struct symbol *sym, c
onst c
har *stabs, CORE_ADDR value)
{
if (ref_count == 0)
ref_chunk = 0;
{
if (ref_count == 0)
ref_chunk = 0;
@@
-534,9
+572,9
@@
ref_search (int refnum)
reference number. Move STRING beyond the reference id. */
static int
reference number. Move STRING beyond the reference id. */
static int
-process_reference (char **string)
+process_reference (c
onst c
har **string)
{
{
- char *p;
+ c
onst c
har *p;
int refnum = 0;
if (**string != '#')
int refnum = 0;
if (**string != '#')
@@
-545,7
+583,7
@@
process_reference (char **string)
/* Advance beyond the initial '#'. */
p = *string + 1;
/* Advance beyond the initial '#'. */
p = *string + 1;
- /* Read number as reference id. */
+ /* Read number as reference id.
*/
while (*p && isdigit (*p))
{
refnum = refnum * 10 + *p - '0';
while (*p && isdigit (*p))
{
refnum = refnum * 10 + *p - '0';
@@
-559,23
+597,23
@@
process_reference (char **string)
definition for later use. Return the reference number. */
int
definition for later use. Return the reference number. */
int
-symbol_reference_defined (char **string)
+symbol_reference_defined (c
onst c
har **string)
{
{
- char *p = *string;
+ c
onst c
har *p = *string;
int refnum = 0;
refnum = process_reference (&p);
int refnum = 0;
refnum = process_reference (&p);
- /* Defining symbols end in '=' */
+ /* Defining symbols end in '='
.
*/
if (*p == '=')
{
if (*p == '=')
{
- /* Symbol is being defined here. */
+ /* Symbol is being defined here.
*/
*string = p + 1;
return refnum;
}
else
{
*string = p + 1;
return refnum;
}
else
{
- /* Must be a reference.
Either the symbol has already been defined,
+ /* Must be a reference. Either the symbol has already been defined,
or this is a forward reference to it. */
*string = p;
return -1;
or this is a forward reference to it. */
*string = p;
return -1;
@@
-587,15
+625,12
@@
stab_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch)
{
int regno = gdbarch_stab_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
{
int regno = gdbarch_stab_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
- if (regno >= gdbarch_num_regs (gdbarch)
- + gdbarch_num_pseudo_regs (gdbarch))
+ if (regno < 0 || regno >= gdbarch_num_cooked_regs (gdbarch))
{
{
- reg_value_complaint (regno,
- gdbarch_num_regs (gdbarch)
- + gdbarch_num_pseudo_regs (gdbarch),
- SYMBOL_PRINT_NAME (sym));
+ reg_value_complaint (regno, gdbarch_num_cooked_regs (gdbarch),
+ sym->print_name ());
- regno = gdbarch_sp_regnum (gdbarch); /* Known safe, though useless */
+ regno = gdbarch_sp_regnum (gdbarch); /* Known safe, though useless
.
*/
}
return regno;
}
return regno;
@@
-605,22
+640,26
@@
static const struct symbol_register_ops stab_register_funcs = {
stab_reg_to_regnum
};
stab_reg_to_regnum
};
+/* The "aclass" indices for computed symbols. */
+
+static int stab_register_index;
+static int stab_regparm_index;
+
struct symbol *
struct symbol *
-define_symbol (CORE_ADDR valu, char *string, int desc, int type,
+define_symbol (CORE_ADDR valu, c
onst c
har *string, int desc, int type,
struct objfile *objfile)
{
struct gdbarch *gdbarch = get_objfile_arch (objfile);
struct symbol *sym;
struct objfile *objfile)
{
struct gdbarch *gdbarch = get_objfile_arch (objfile);
struct symbol *sym;
- c
har *p = (char *)
find_name_end (string);
+ c
onst char *p =
find_name_end (string);
int deftype;
int synonym = 0;
int i;
int deftype;
int synonym = 0;
int i;
- char *new_name = NULL;
/* We would like to eliminate nameless symbols, but keep their types.
E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
/* We would like to eliminate nameless symbols, but keep their types.
E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
- to type 2, but, should not create a symbol to address that type. Since
- the symbol will be nameless, there is no way any user can refer to it. */
+ to type 2, but, should not create a symbol to address that type.
Since
+ the symbol will be nameless, there is no way any user can refer to it.
*/
int nameless;
int nameless;
@@
-628,7
+667,7
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
if (string[0] == 0)
return 0;
if (string[0] == 0)
return 0;
- /* Ignore old-style symbols from cc -go */
+ /* Ignore old-style symbols from cc -go
.
*/
if (p == 0)
return 0;
if (p == 0)
return 0;
@@
-636,28
+675,19
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
{
p += 2;
p = strchr (p, ':');
{
p += 2;
p = strchr (p, ':');
+ if (p == NULL)
+ {
+ complaint (
+ _("Bad stabs string '%s'"), string);
+ return NULL;
+ }
}
/* If a nameless stab entry, all we need is the type, not the symbol.
e.g. ":t10=*2" or a nameless enum like " :T16=ered:0,green:1,blue:2,;" */
nameless = (p == string || ((string[0] == ' ') && (string[1] == ':')));
}
/* If a nameless stab entry, all we need is the type, not the symbol.
e.g. ":t10=*2" or a nameless enum like " :T16=ered:0,green:1,blue:2,;" */
nameless = (p == string || ((string[0] == ' ') && (string[1] == ':')));
- current_symbol = sym = (struct symbol *)
- obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol));
- memset (sym, 0, sizeof (struct symbol));
-
- switch (type & N_TYPE)
- {
- case N_TEXT:
- SYMBOL_SECTION (sym) = SECT_OFF_TEXT (objfile);
- break;
- case N_DATA:
- SYMBOL_SECTION (sym) = SECT_OFF_DATA (objfile);
- break;
- case N_BSS:
- SYMBOL_SECTION (sym) = SECT_OFF_BSS (objfile);
- break;
- }
+ current_symbol = sym = allocate_symbol (objfile);
if (processing_gcc_compilation)
{
if (processing_gcc_compilation)
{
@@
-670,20
+700,23
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
SYMBOL_LINE (sym) = 0; /* unknown */
}
SYMBOL_LINE (sym) = 0; /* unknown */
}
+ sym->set_language (get_current_subfile ()->language,
+ &objfile->objfile_obstack);
+
if (is_cplus_marker (string[0]))
{
/* Special GNU C++ names. */
switch (string[1])
{
case 't':
if (is_cplus_marker (string[0]))
{
/* Special GNU C++ names. */
switch (string[1])
{
case 't':
-
SYMBOL_SET_LINKAGE_NAME (sym,
"this");
+
sym->set_linkage_name (
"this");
break;
case 'v': /* $vtbl_ptr_type */
goto normal;
case 'e':
break;
case 'v': /* $vtbl_ptr_type */
goto normal;
case 'e':
-
SYMBOL_SET_LINKAGE_NAME (sym,
"eh_throw");
+
sym->set_linkage_name (
"eh_throw");
break;
case '_':
break;
case '_':
@@
-694,36
+727,40
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
/* SunPRO (3.0 at least) static variable encoding. */
if (gdbarch_static_transform_name_p (gdbarch))
goto normal;
/* SunPRO (3.0 at least) static variable encoding. */
if (gdbarch_static_transform_name_p (gdbarch))
goto normal;
- /*
... fall through ...
*/
+ /*
fall through
*/
default:
default:
- complaint (
&symfile_complaints,
_("Unknown C++ symbol name `%s'"),
+ complaint (_("Unknown C++ symbol name `%s'"),
string);
string);
- goto normal; /* Do *something* with it */
+ goto normal; /* Do *something* with it
.
*/
}
}
else
{
normal:
}
}
else
{
normal:
- SYMBOL_SET_LANGUAGE (sym, current_subfile->language);
- if (SYMBOL_LANGUAGE (sym) == language_cplus)
+ std::string new_name;
+
+ if (sym->language () == language_cplus)
{
{
- char *name = alloca (p - string + 1);
+ char *name =
(char *)
alloca (p - string + 1);
memcpy (name, string, p - string);
name[p - string] = '\0';
new_name = cp_canonicalize_string (name);
}
memcpy (name, string, p - string);
name[p - string] = '\0';
new_name = cp_canonicalize_string (name);
}
- if (
new_name != NULL
)
+ if (
!new_name.empty ()
)
{
{
- SYMBOL_SET_NAMES (sym, new_name, strlen (new_name), 1, objfile);
- xfree (new_name);
+ SYMBOL_SET_NAMES (sym,
+ new_name,
+ 1, objfile);
}
else
}
else
- SYMBOL_SET_NAMES (sym, string, p - string, 1, objfile);
+ SYMBOL_SET_NAMES (sym, gdb::string_view (string, p - string), true,
+ objfile);
- if (SYMBOL_LANGUAGE (sym) == language_cplus)
- cp_scan_for_anonymous_namespaces (sym);
+ if (sym->language () == language_cplus)
+ cp_scan_for_anonymous_namespaces (get_buildsym_compunit (), sym,
+ objfile);
}
p++;
}
p++;
@@
-756,10
+793,10
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
(where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
if (*p != '=')
{
(where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
if (*p != '=')
{
- SYMBOL_
CLASS
(sym) = LOC_CONST;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_CONST;
SYMBOL_TYPE (sym) = error_type (&p, objfile);
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_TYPE (sym) = error_type (&p, objfile);
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym,
&file_symbols
);
+ add_symbol_to_list (sym,
get_file_symbols ()
);
return sym;
}
++p;
return sym;
}
++p;
@@
-767,23
+804,19
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
{
case 'r':
{
{
case 'r':
{
- double d = atof (p);
gdb_byte *dbl_valu;
struct type *dbl_type;
gdb_byte *dbl_valu;
struct type *dbl_type;
- /* FIXME-if-picky-about-floating-accuracy: Should be using
- target arithmetic to get the value. real.c in GCC
- probably has the necessary code. */
-
dbl_type = objfile_type (objfile)->builtin_double;
dbl_type = objfile_type (objfile)->builtin_double;
- dbl_valu =
- obstack_alloc (&objfile->objfile_obstack,
- TYPE_LENGTH (dbl_type));
- store_typed_floating (dbl_valu, dbl_type, d);
+ dbl_valu
+ = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack,
+ TYPE_LENGTH (dbl_type));
+
+ target_float_from_string (dbl_valu, dbl_type, std::string (p));
SYMBOL_TYPE (sym) = dbl_type;
SYMBOL_VALUE_BYTES (sym) = dbl_valu;
SYMBOL_TYPE (sym) = dbl_type;
SYMBOL_VALUE_BYTES (sym) = dbl_valu;
- SYMBOL_
CLASS
(sym) = LOC_CONST_BYTES;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_CONST_BYTES;
}
break;
case 'i':
}
break;
case 'i':
@@
-797,7
+830,7
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_long;
SYMBOL_VALUE (sym) = atoi (p);
SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_long;
SYMBOL_VALUE (sym) = atoi (p);
- SYMBOL_
CLASS
(sym) = LOC_CONST;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_CONST;
}
break;
}
break;
@@
-805,7
+838,7
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
{
SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_char;
SYMBOL_VALUE (sym) = atoi (p);
{
SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_char;
SYMBOL_VALUE (sym) = atoi (p);
- SYMBOL_
CLASS
(sym) = LOC_CONST;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_CONST;
}
break;
}
break;
@@
-819,10
+852,10
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
if (quote != '\'' && quote != '"')
{
if (quote != '\'' && quote != '"')
{
- SYMBOL_
CLASS
(sym) = LOC_CONST;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_CONST;
SYMBOL_TYPE (sym) = error_type (&p, objfile);
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_TYPE (sym) = error_type (&p, objfile);
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym,
&file_symbols
);
+ add_symbol_to_list (sym,
get_file_symbols ()
);
return sym;
}
return sym;
}
@@
-844,28
+877,29
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
}
if (*p != quote)
{
}
if (*p != quote)
{
- SYMBOL_
CLASS
(sym) = LOC_CONST;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_CONST;
SYMBOL_TYPE (sym) = error_type (&p, objfile);
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_TYPE (sym) = error_type (&p, objfile);
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym,
&file_symbols
);
+ add_symbol_to_list (sym,
get_file_symbols ()
);
return sym;
}
/* NULL terminate the string. */
string_local[ind] = 0;
range_type
return sym;
}
/* NULL terminate the string. */
string_local[ind] = 0;
range_type
- = create_range_type (NULL,
- objfile_type (objfile)->builtin_int,
- 0, ind);
+ = create_
static_
range_type (NULL,
+
objfile_type (objfile)->builtin_int,
+
0, ind);
SYMBOL_TYPE (sym) = create_array_type (NULL,
objfile_type (objfile)->builtin_char,
range_type);
SYMBOL_TYPE (sym) = create_array_type (NULL,
objfile_type (objfile)->builtin_char,
range_type);
- string_value = obstack_alloc (&objfile->objfile_obstack, ind + 1);
+ string_value
+ = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, ind + 1);
memcpy (string_value, string_local, ind + 1);
p++;
SYMBOL_VALUE_BYTES (sym) = string_value;
memcpy (string_value, string_local, ind + 1);
p++;
SYMBOL_VALUE_BYTES (sym) = string_value;
- SYMBOL_
CLASS
(sym) = LOC_CONST_BYTES;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_CONST_BYTES;
}
break;
}
break;
@@
-875,7
+909,7
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
e.g. "b:c=e6,0" for "const b = blob1"
(where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
{
e.g. "b:c=e6,0" for "const b = blob1"
(where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
{
- SYMBOL_
CLASS
(sym) = LOC_CONST;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_CONST;
SYMBOL_TYPE (sym) = read_type (&p, objfile);
if (*p != ',')
SYMBOL_TYPE (sym) = read_type (&p, objfile);
if (*p != ',')
@@
-896,29
+930,29
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
break;
default:
{
break;
default:
{
- SYMBOL_
CLASS
(sym) = LOC_CONST;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_CONST;
SYMBOL_TYPE (sym) = error_type (&p, objfile);
}
}
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_TYPE (sym) = error_type (&p, objfile);
}
}
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym,
&file_symbols
);
+ add_symbol_to_list (sym,
get_file_symbols ()
);
return sym;
case 'C':
/* The name of a caught exception. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
return sym;
case 'C':
/* The name of a caught exception. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_
CLASS
(sym) = LOC_LABEL;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_LABEL;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- S
YMBOL_VALUE_ADDRESS (sym) = valu
;
- add_symbol_to_list (sym,
&local_symbols
);
+ S
ET_SYMBOL_VALUE_ADDRESS (sym, valu)
;
+ add_symbol_to_list (sym,
get_local_symbols ()
);
break;
case 'f':
/* A static function definition. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
break;
case 'f':
/* A static function definition. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_
CLASS
(sym) = LOC_BLOCK;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_BLOCK;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym,
&file_symbols
);
+ add_symbol_to_list (sym,
get_file_symbols ()
);
/* fall into process_function_types. */
process_function_types:
/* fall into process_function_types. */
process_function_types:
@@
-936,7
+970,7
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
primarily for promotion when calling the function from GDB. */
TYPE_PROTOTYPED (SYMBOL_TYPE (sym)) = 1;
primarily for promotion when calling the function from GDB. */
TYPE_PROTOTYPED (SYMBOL_TYPE (sym)) = 1;
- /* fall into process_prototype_types */
+ /* fall into process_prototype_types
.
*/
process_prototype_types:
/* Sun acc puts declared types of arguments here. */
process_prototype_types:
/* Sun acc puts declared types of arguments here. */
@@
-945,7
+979,7
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
struct type *ftype = SYMBOL_TYPE (sym);
int nsemi = 0;
int nparams = 0;
struct type *ftype = SYMBOL_TYPE (sym);
int nsemi = 0;
int nparams = 0;
- char *p1 = p;
+ c
onst c
har *p1 = p;
/* Obtain a worst case guess for the number of arguments
by counting the semicolons. */
/* Obtain a worst case guess for the number of arguments
by counting the semicolons. */
@@
-955,7
+989,7
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
nsemi++;
}
nsemi++;
}
- /* Allocate parameter information fields and fill them in. */
+ /* Allocate parameter information fields and fill them in.
*/
TYPE_FIELDS (ftype) = (struct field *)
TYPE_ALLOC (ftype, nsemi * sizeof (struct field));
while (*p++ == ';')
TYPE_FIELDS (ftype) = (struct field *)
TYPE_ALLOC (ftype, nsemi * sizeof (struct field));
while (*p++ == ';')
@@
-970,7
+1004,7
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
/* The Sun compilers mark integer arguments, which should
be promoted to the width of the calling conventions, with
/* The Sun compilers mark integer arguments, which should
be promoted to the width of the calling conventions, with
- a type which references itself. This type is turned into
+ a type which references itself.
This type is turned into
a TYPE_CODE_VOID type by read_type, and we have to turn
it back into builtin_int here.
FIXME: Do we need a new builtin_promoted_int_arg ? */
a TYPE_CODE_VOID type by read_type, and we have to turn
it back into builtin_int here.
FIXME: Do we need a new builtin_promoted_int_arg ? */
@@
-987,9
+1021,9
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
case 'F':
/* A global function definition. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
case 'F':
/* A global function definition. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_
CLASS
(sym) = LOC_BLOCK;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_BLOCK;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym,
&global_symbols
);
+ add_symbol_to_list (sym,
get_global_symbols ()
);
goto process_function_types;
case 'G':
goto process_function_types;
case 'G':
@@
-998,19
+1032,19
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
corresponding linker definition to find the value.
These definitions appear at the end of the namelist. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
corresponding linker definition to find the value.
These definitions appear at the end of the namelist. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_
CLASS
(sym) = LOC_STATIC;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_STATIC;
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. */
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_LINKAGE_NAME (sym) && SYMBOL_LINKAGE_NAME (sym
)[0] != '#')
+ if (
sym->linkage_name () && sym->linkage_name (
)[0] != '#')
{
{
- i = hashname (
SYMBOL_LINKAGE_NAME (sym
));
+ i = hashname (
sym->linkage_name (
));
SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
global_sym_chain[i] = sym;
}
SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
global_sym_chain[i] = sym;
}
- add_symbol_to_list (sym,
&global_symbols
);
+ add_symbol_to_list (sym,
get_global_symbols ()
);
break;
/* This case is faked by a conditional above,
break;
/* This case is faked by a conditional above,
@@
-1019,10
+1053,10
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
case 's':
case 'l':
SYMBOL_TYPE (sym) = read_type (&p, objfile);
case 's':
case 'l':
SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_
CLASS
(sym) = LOC_LOCAL;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_LOCAL;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym,
&local_symbols
);
+ add_symbol_to_list (sym,
get_local_symbols ()
);
break;
case 'p':
break;
case 'p':
@@
-1039,11
+1073,11
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
else
SYMBOL_TYPE (sym) = read_type (&p, objfile);
else
SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_
CLASS
(sym) = LOC_ARG;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_ARG;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_IS_ARGUMENT (sym) = 1;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_IS_ARGUMENT (sym) = 1;
- add_symbol_to_list (sym,
&local_symbols
);
+ add_symbol_to_list (sym,
get_local_symbols ()
);
if (gdbarch_byte_order (gdbarch) != BFD_ENDIAN_BIG)
{
if (gdbarch_byte_order (gdbarch) != BFD_ENDIAN_BIG)
{
@@
-1072,6
+1106,7
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
}
break;
}
}
break;
}
+ /* Fall through. */
case 'P':
/* acc seems to use P to declare the prototypes of functions that
case 'P':
/* acc seems to use P to declare the prototypes of functions that
@@
-1087,19
+1122,17
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
case 'R':
/* Parameter which is in a register. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
case 'R':
/* Parameter which is in a register. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_CLASS (sym) = LOC_REGISTER;
- SYMBOL_REGISTER_OPS (sym) = &stab_register_funcs;
+ SYMBOL_ACLASS_INDEX (sym) = stab_register_index;
SYMBOL_IS_ARGUMENT (sym) = 1;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_IS_ARGUMENT (sym) = 1;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym,
&local_symbols
);
+ add_symbol_to_list (sym,
get_local_symbols ()
);
break;
case 'r':
/* Register variable (either global or local). */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
break;
case 'r':
/* Register variable (either global or local). */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_CLASS (sym) = LOC_REGISTER;
- SYMBOL_REGISTER_OPS (sym) = &stab_register_funcs;
+ SYMBOL_ACLASS_INDEX (sym) = stab_register_index;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
if (within_function)
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
if (within_function)
@@
-1108,8
+1141,7
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
the same name to represent an argument passed in a
register. GCC uses 'P' for the same case. So if we find
such a symbol pair we combine it into one 'P' symbol.
the same name to represent an argument passed in a
register. GCC uses 'P' for the same case. So if we find
such a symbol pair we combine it into one 'P' symbol.
- For Sun cc we need to do this regardless of
- stabs_argument_has_addr, because the compiler puts out
+ For Sun cc we need to do this regardless of stabs_argument_has_addr, because the compiler puts out
the 'p' symbol even if it never saves the argument onto
the stack.
the 'p' symbol even if it never saves the argument onto
the stack.
@@
-1124,6
+1156,7
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
but this case is considered pathological and causes a warning
from a decent compiler. */
but this case is considered pathological and causes a warning
from a decent compiler. */
+ struct pending *local_symbols = *get_local_symbols ();
if (local_symbols
&& local_symbols->nsyms > 0
&& gdbarch_stabs_argument_has_addr (gdbarch, SYMBOL_TYPE (sym)))
if (local_symbols
&& local_symbols->nsyms > 0
&& gdbarch_stabs_argument_has_addr (gdbarch, SYMBOL_TYPE (sym)))
@@
-1133,11
+1166,10
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
prev_sym = local_symbols->symbol[local_symbols->nsyms - 1];
if ((SYMBOL_CLASS (prev_sym) == LOC_REF_ARG
|| SYMBOL_CLASS (prev_sym) == LOC_ARG)
prev_sym = local_symbols->symbol[local_symbols->nsyms - 1];
if ((SYMBOL_CLASS (prev_sym) == LOC_REF_ARG
|| SYMBOL_CLASS (prev_sym) == LOC_ARG)
- && strcmp (
SYMBOL_LINKAGE_NAME (prev_sym
),
-
SYMBOL_LINKAGE_NAME (sym
)) == 0)
+ && strcmp (
prev_sym->linkage_name (
),
+
sym->linkage_name (
)) == 0)
{
{
- SYMBOL_CLASS (prev_sym) = LOC_REGISTER;
- SYMBOL_REGISTER_OPS (prev_sym) = &stab_register_funcs;
+ SYMBOL_ACLASS_INDEX (prev_sym) = stab_register_index;
/* Use the type from the LOC_REGISTER; that is the type
that is actually in that register. */
SYMBOL_TYPE (prev_sym) = SYMBOL_TYPE (sym);
/* Use the type from the LOC_REGISTER; that is the type
that is actually in that register. */
SYMBOL_TYPE (prev_sym) = SYMBOL_TYPE (sym);
@@
-1146,43
+1178,42
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
break;
}
}
break;
}
}
- add_symbol_to_list (sym,
&local_symbols
);
+ add_symbol_to_list (sym,
get_local_symbols ()
);
}
else
}
else
- add_symbol_to_list (sym,
&file_symbols
);
+ add_symbol_to_list (sym,
get_file_symbols ()
);
break;
case 'S':
break;
case 'S':
- /* Static symbol at top level of file */
+ /* Static symbol at top level of file
.
*/
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_
CLASS
(sym) = LOC_STATIC;
- S
YMBOL_VALUE_ADDRESS (sym) = valu
;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_STATIC;
+ S
ET_SYMBOL_VALUE_ADDRESS (sym, valu)
;
if (gdbarch_static_transform_name_p (gdbarch)
if (gdbarch_static_transform_name_p (gdbarch)
- && gdbarch_static_transform_name (gdbarch,
- SYMBOL_LINKAGE_NAME (sym))
- != SYMBOL_LINKAGE_NAME (sym))
+ && gdbarch_static_transform_name (gdbarch, sym->linkage_name ())
+ != sym->linkage_name ())
{
{
- struct
minimal_symbol *
msym;
+ struct
bound_minimal_symbol
msym;
- msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
- NULL, objfile);
- if (msym != NULL)
+ msym = lookup_minimal_symbol (sym->linkage_name (), NULL, objfile);
+ if (msym.minsym != NULL)
{
{
- char *new_name = gdbarch_static_transform_name
- (gdbarch,
SYMBOL_LINKAGE_NAME (sym
));
+ c
onst c
har *new_name = gdbarch_static_transform_name
+ (gdbarch,
sym->linkage_name (
));
- SYMBOL_SET_LINKAGE_NAME (sym, new_name);
- SYMBOL_VALUE_ADDRESS (sym) = SYMBOL_VALUE_ADDRESS (msym);
+ sym->set_linkage_name (new_name);
+ SET_SYMBOL_VALUE_ADDRESS (sym,
+ BMSYMBOL_VALUE_ADDRESS (msym));
}
}
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
}
}
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym,
&file_symbols
);
+ add_symbol_to_list (sym,
get_file_symbols ()
);
break;
case 't':
/* In Ada, there is no distinction between typedef and non-typedef;
any type declaration implicitly has the equivalent of a typedef,
break;
case 't':
/* In Ada, there is no distinction between typedef and non-typedef;
any type declaration implicitly has the equivalent of a typedef,
- and thus 't' is in fact equivalent to 'Tt'.
+ and thus 't' is in fact equivalent to 'Tt'.
Therefore, for Ada units, we check the character immediately
before the 't', and if we do not find a 'T', then make sure to
Therefore, for Ada units, we check the character immediately
before the 't', and if we do not find a 'T', then make sure to
@@
-1194,17
+1225,17
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
This is important to do, because of forward references:
The cleanup of undefined types stored in undef_types only uses
STRUCT_DOMAIN symbols to perform the replacement. */
This is important to do, because of forward references:
The cleanup of undefined types stored in undef_types only uses
STRUCT_DOMAIN symbols to perform the replacement. */
- synonym = (
SYMBOL_LANGUAGE (sym
) == language_ada && p[-2] != 'T');
+ synonym = (
sym->language (
) == language_ada && p[-2] != 'T');
/* Typedef */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
/* For a nameless type, we don't want a create a symbol, thus we
/* Typedef */
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.
*/
+ did not use `sym'.
Return without further processing.
*/
if (nameless)
return NULL;
if (nameless)
return NULL;
- SYMBOL_
CLASS
(sym) = LOC_TYPEDEF;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_TYPEDEF;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
/* C++ vagaries: we may have a type which is derived from
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
/* C++ vagaries: we may have a type which is derived from
@@
-1221,18
+1252,13
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
for (j = TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)) - 1; j >= 0; j--)
if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) == 0)
TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) =
for (j = TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)) - 1; j >= 0; j--)
if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) == 0)
TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) =
-
type_name_no_tag
(TYPE_BASECLASS (SYMBOL_TYPE (sym), j));
+
TYPE_NAME
(TYPE_BASECLASS (SYMBOL_TYPE (sym), j));
}
if (TYPE_NAME (SYMBOL_TYPE (sym)) == NULL)
{
}
if (TYPE_NAME (SYMBOL_TYPE (sym)) == NULL)
{
- /* gcc-2.6 or later (when using -fvtable-thunks)
- emits a unique named type for a vtable entry.
- Some gdb code depends on that specific name. */
- extern const char vtbl_ptr_name[];
-
if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
- && strcmp (
SYMBOL_LINKAGE_NAME (sym
), vtbl_ptr_name))
+ && strcmp (
sym->linkage_name (
), vtbl_ptr_name))
|| TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
{
/* If we are giving a name to a type such as "pointer to
|| TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
{
/* If we are giving a name to a type such as "pointer to
@@
-1253,15
+1279,16
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
Fortunately, this check seems not to be necessary
for anything except pointers or functions. */
Fortunately, this check seems not to be necessary
for anything except pointers or functions. */
- /* ezannoni: 2000-10-26. This seems to apply for
- versions of gcc older than 2.8. This was the original
+ /* ezannoni: 2000-10-26.
This seems to apply for
+ versions of gcc older than 2.8.
This was the original
problem: with the following code gdb would tell that
problem: with the following code gdb would tell that
- the type for name1 is caddr_t, and func is char()
+ the type for name1 is caddr_t, and func is char().
+
typedef char *caddr_t;
char *name2;
struct x
{
typedef char *caddr_t;
char *name2;
struct x
{
- char *name1;
+
char *name1;
} xx;
char *func()
{
} xx;
char *func()
{
@@
-1269,34
+1296,32
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
main () {}
*/
main () {}
*/
- /* Pascal accepts names for pointer types. */
- if (
current_subfile
->language == language_pascal)
+ /* Pascal accepts names for pointer types.
*/
+ if (
get_current_subfile ()
->language == language_pascal)
{
{
- TYPE_NAME (SYMBOL_TYPE (sym)) =
SYMBOL_LINKAGE_NAME (sym
);
+ TYPE_NAME (SYMBOL_TYPE (sym)) =
sym->linkage_name (
);
}
}
else
}
}
else
- TYPE_NAME (SYMBOL_TYPE (sym)) =
SYMBOL_LINKAGE_NAME (sym
);
+ TYPE_NAME (SYMBOL_TYPE (sym)) =
sym->linkage_name (
);
}
}
- add_symbol_to_list (sym,
&file_symbols
);
+ add_symbol_to_list (sym,
get_file_symbols ()
);
if (synonym)
{
/* Create the STRUCT_DOMAIN clone. */
if (synonym)
{
/* Create the STRUCT_DOMAIN clone. */
- struct symbol *struct_sym = (struct symbol *)
- obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol));
+ struct symbol *struct_sym = allocate_symbol (objfile);
*struct_sym = *sym;
*struct_sym = *sym;
- SYMBOL_
CLASS
(struct_sym) = LOC_TYPEDEF;
+ SYMBOL_
ACLASS_INDEX
(struct_sym) = LOC_TYPEDEF;
SYMBOL_VALUE (struct_sym) = valu;
SYMBOL_DOMAIN (struct_sym) = STRUCT_DOMAIN;
if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
TYPE_NAME (SYMBOL_TYPE (sym))
SYMBOL_VALUE (struct_sym) = valu;
SYMBOL_DOMAIN (struct_sym) = STRUCT_DOMAIN;
if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
TYPE_NAME (SYMBOL_TYPE (sym))
- = obconcat (&objfile->objfile_obstack,
- SYMBOL_LINKAGE_NAME (sym),
+ = obconcat (&objfile->objfile_obstack, sym->linkage_name (),
(char *) NULL);
(char *) NULL);
- add_symbol_to_list (struct_sym,
&file_symbols
);
+ add_symbol_to_list (struct_sym,
get_file_symbols ()
);
}
break;
}
break;
@@
-1312,85
+1337,79
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
SYMBOL_TYPE (sym) = read_type (&p, objfile);
/* For a nameless type, we don't want a create a symbol, thus we
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.
*/
+ did not use `sym'.
Return without further processing.
*/
if (nameless)
return NULL;
if (nameless)
return NULL;
- SYMBOL_
CLASS
(sym) = LOC_TYPEDEF;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_TYPEDEF;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
- if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)
- TYPE_TAG_NAME (SYMBOL_TYPE (sym))
- = obconcat (&objfile->objfile_obstack,
- SYMBOL_LINKAGE_NAME (sym),
+ if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
+ TYPE_NAME (SYMBOL_TYPE (sym))
+ = obconcat (&objfile->objfile_obstack, sym->linkage_name (),
(char *) NULL);
(char *) NULL);
- add_symbol_to_list (sym,
&file_symbols
);
+ add_symbol_to_list (sym,
get_file_symbols ()
);
if (synonym)
{
if (synonym)
{
- /* Clone the sym and then modify it. */
- struct symbol *typedef_sym = (struct symbol *)
- obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol));
+ /* Clone the sym and then modify it. */
+ struct symbol *typedef_sym = allocate_symbol (objfile);
*typedef_sym = *sym;
*typedef_sym = *sym;
- SYMBOL_
CLASS
(typedef_sym) = LOC_TYPEDEF;
+ SYMBOL_
ACLASS_INDEX
(typedef_sym) = LOC_TYPEDEF;
SYMBOL_VALUE (typedef_sym) = valu;
SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
TYPE_NAME (SYMBOL_TYPE (sym))
SYMBOL_VALUE (typedef_sym) = valu;
SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
TYPE_NAME (SYMBOL_TYPE (sym))
- = obconcat (&objfile->objfile_obstack,
- SYMBOL_LINKAGE_NAME (sym),
+ = obconcat (&objfile->objfile_obstack, sym->linkage_name (),
(char *) NULL);
(char *) NULL);
- add_symbol_to_list (typedef_sym,
&file_symbols
);
+ add_symbol_to_list (typedef_sym,
get_file_symbols ()
);
}
break;
case 'V':
}
break;
case 'V':
- /* Static symbol of local scope */
+ /* Static symbol of local scope
.
*/
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_
CLASS
(sym) = LOC_STATIC;
- S
YMBOL_VALUE_ADDRESS (sym) = valu
;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_STATIC;
+ S
ET_SYMBOL_VALUE_ADDRESS (sym, valu)
;
if (gdbarch_static_transform_name_p (gdbarch)
if (gdbarch_static_transform_name_p (gdbarch)
- && gdbarch_static_transform_name (gdbarch,
- SYMBOL_LINKAGE_NAME (sym))
- != SYMBOL_LINKAGE_NAME (sym))
+ && gdbarch_static_transform_name (gdbarch, sym->linkage_name ())
+ != sym->linkage_name ())
{
{
- struct
minimal_symbol *
msym;
+ struct
bound_minimal_symbol
msym;
- msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
- NULL, objfile);
- if (msym != NULL)
+ msym = lookup_minimal_symbol (sym->linkage_name (), NULL, objfile);
+ if (msym.minsym != NULL)
{
{
- char *new_name = gdbarch_static_transform_name
- (gdbarch,
SYMBOL_LINKAGE_NAME (sym
));
+ c
onst c
har *new_name = gdbarch_static_transform_name
+ (gdbarch,
sym->linkage_name (
));
-
SYMBOL_SET_LINKAGE_NAME (sym,
new_name);
- S
YMBOL_VALUE_ADDRESS (sym) = SYMBOL_VALUE_ADDRESS (msym
);
+
sym->set_linkage_name (
new_name);
+ S
ET_SYMBOL_VALUE_ADDRESS (sym, BMSYMBOL_VALUE_ADDRESS (msym)
);
}
}
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
}
}
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym,
&local_symbols
);
+ add_symbol_to_list (sym,
get_local_symbols ()
);
break;
case 'v':
/* Reference parameter */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
break;
case 'v':
/* Reference parameter */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_
CLASS
(sym) = LOC_REF_ARG;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_REF_ARG;
SYMBOL_IS_ARGUMENT (sym) = 1;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_IS_ARGUMENT (sym) = 1;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym,
&local_symbols
);
+ add_symbol_to_list (sym,
get_local_symbols ()
);
break;
case 'a':
/* Reference parameter which is in a register. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
break;
case 'a':
/* Reference parameter which is in a register. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR;
- SYMBOL_REGISTER_OPS (sym) = &stab_register_funcs;
+ SYMBOL_ACLASS_INDEX (sym) = stab_regparm_index;
SYMBOL_IS_ARGUMENT (sym) = 1;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_IS_ARGUMENT (sym) = 1;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym,
&local_symbols
);
+ add_symbol_to_list (sym,
get_local_symbols ()
);
break;
case 'X':
break;
case 'X':
@@
-1399,18
+1418,18
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
that Pascal uses it too, but when I tried it Pascal used
"x:3" (local symbol) instead. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
that Pascal uses it too, but when I tried it Pascal used
"x:3" (local symbol) instead. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_
CLASS
(sym) = LOC_LOCAL;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_LOCAL;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym,
&local_symbols
);
+ add_symbol_to_list (sym,
get_local_symbols ()
);
break;
default:
SYMBOL_TYPE (sym) = error_type (&p, objfile);
break;
default:
SYMBOL_TYPE (sym) = error_type (&p, objfile);
- SYMBOL_
CLASS
(sym) = LOC_CONST;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_CONST;
SYMBOL_VALUE (sym) = 0;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_VALUE (sym) = 0;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym,
&file_symbols
);
+ add_symbol_to_list (sym,
get_file_symbols ()
);
break;
}
break;
}
@@
-1424,11
+1443,11
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
/* We have to convert LOC_REGISTER to LOC_REGPARM_ADDR (for
variables passed in a register). */
if (SYMBOL_CLASS (sym) == LOC_REGISTER)
/* We have to convert LOC_REGISTER to LOC_REGPARM_ADDR (for
variables passed in a register). */
if (SYMBOL_CLASS (sym) == LOC_REGISTER)
- SYMBOL_
CLASS
(sym) = LOC_REGPARM_ADDR;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_REGPARM_ADDR;
/* Likewise for converting LOC_ARG to LOC_REF_ARG (for the 7th
and subsequent arguments on SPARC, for example). */
else if (SYMBOL_CLASS (sym) == LOC_ARG)
/* Likewise for converting LOC_ARG to LOC_REF_ARG (for the 7th
and subsequent arguments on SPARC, for example). */
else if (SYMBOL_CLASS (sym) == LOC_ARG)
- SYMBOL_
CLASS
(sym) = LOC_REF_ARG;
+ SYMBOL_
ACLASS_INDEX
(sym) = LOC_REF_ARG;
}
return sym;
}
return sym;
@@
-1464,10
+1483,9
@@
define_symbol (CORE_ADDR valu, char *string, int desc, int type,
debugger will be able to read the new symbol tables. */
static struct type *
debugger will be able to read the new symbol tables. */
static struct type *
-error_type (char **pp, struct objfile *objfile)
+error_type (c
onst c
har **pp, struct objfile *objfile)
{
{
- complaint (&symfile_complaints,
- _("couldn't parse type; debugger out of date?"));
+ complaint (_("couldn't parse type; debugger out of date?"));
while (1)
{
/* Skip to end of symbol. */
while (1)
{
/* Skip to end of symbol. */
@@
-1497,7
+1515,7
@@
error_type (char **pp, struct objfile *objfile)
deciding whether to call read_type. */
static struct type *
deciding whether to call read_type. */
static struct type *
-read_type (char **pp, struct objfile *objfile)
+read_type (c
onst c
har **pp, struct objfile *objfile)
{
struct type *type = 0;
struct type *type1;
{
struct type *type = 0;
struct type *type1;
@@
-1508,10
+1526,10
@@
read_type (char **pp, struct objfile *objfile)
there is no size attribute. */
int type_size = -1;
there is no size attribute. */
int type_size = -1;
- /* Used to distinguish string and bitstring from char-array and set. */
+ /* Used to distinguish string and bitstring from char-array and set.
*/
int is_string = 0;
int is_string = 0;
- /* Used to distinguish vector from array. */
+ /* Used to distinguish vector from array.
*/
int is_vector = 0;
/* Read type number if present. The type number may be omitted.
int is_vector = 0;
/* Read type number if present. The type number may be omitted.
@@
-1569,7
+1587,7
@@
again:
char *type_name;
{
char *type_name;
{
- c
har *from, *to
, *p, *q1, *q2;
+ c
onst char *from
, *p, *q1, *q2;
/* Set the type code according to the following letter. */
switch ((*pp)[0])
/* Set the type code according to the following letter. */
switch ((*pp)[0])
@@
-1587,8
+1605,7
@@
again:
{
/* Complain and keep going, so compilers can invent new
cross-reference types. */
{
/* Complain and keep going, so compilers can invent new
cross-reference types. */
- complaint (&symfile_complaints,
- _("Unrecognized cross-reference type `%c'"),
+ complaint (_("Unrecognized cross-reference type `%c'"),
(*pp)[0]);
code = TYPE_CODE_STRUCT;
break;
(*pp)[0]);
code = TYPE_CODE_STRUCT;
break;
@@
-1617,23
+1634,21
@@
again:
return error_type (pp, objfile);
}
type_name = NULL;
return error_type (pp, objfile);
}
type_name = NULL;
- if (
current_subfile
->language == language_cplus)
+ if (
get_current_subfile ()
->language == language_cplus)
{
{
- char *n
ew_name, *name =
alloca (p - *pp + 1);
+ char *n
ame = (char *)
alloca (p - *pp + 1);
memcpy (name, *pp, p - *pp);
name[p - *pp] = '\0';
memcpy (name, *pp, p - *pp);
name[p - *pp] = '\0';
- new_name = cp_canonicalize_string (name);
- if (new_name != NULL)
- {
- type_name = obsavestring (new_name, strlen (new_name),
- &objfile->objfile_obstack);
- xfree (new_name);
- }
+
+ std::string new_name = cp_canonicalize_string (name);
+ if (!new_name.empty ())
+ type_name = obstack_strdup (&objfile->objfile_obstack,
+ new_name);
}
if (type_name == NULL)
{
}
if (type_name == NULL)
{
- to = type_name = (char *)
+
char *
to = type_name = (char *)
obstack_alloc (&objfile->objfile_obstack, p - *pp + 1);
/* Copy the name. */
obstack_alloc (&objfile->objfile_obstack, p - *pp + 1);
/* Copy the name. */
@@
-1652,7
+1667,7
@@
again:
type, rather than allocating a new one. This saves some
memory. */
type, rather than allocating a new one. This saves some
memory. */
- for (ppt =
file_symbols
; ppt; ppt = ppt->next)
+ for (ppt =
*get_file_symbols ()
; ppt; ppt = ppt->next)
for (i = 0; i < ppt->nsyms; i++)
{
struct symbol *sym = ppt->symbol[i];
for (i = 0; i < ppt->nsyms; i++)
{
struct symbol *sym = ppt->symbol[i];
@@
-1660,7
+1675,7
@@
again:
if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
&& SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
&& (TYPE_CODE (SYMBOL_TYPE (sym)) == code)
if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
&& SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
&& (TYPE_CODE (SYMBOL_TYPE (sym)) == code)
- && strcmp (
SYMBOL_LINKAGE_NAME (sym
), type_name) == 0)
+ && strcmp (
sym->linkage_name (
), type_name) == 0)
{
obstack_free (&objfile->objfile_obstack, type_name);
type = SYMBOL_TYPE (sym);
{
obstack_free (&objfile->objfile_obstack, type_name);
type = SYMBOL_TYPE (sym);
@@
-1677,7
+1692,7
@@
again:
type. */
type = dbx_alloc_type (typenums, objfile);
TYPE_CODE (type) = code;
type. */
type = dbx_alloc_type (typenums, objfile);
TYPE_CODE (type) = code;
- TYPE_
TAG_
NAME (type) = type_name;
+ TYPE_NAME (type) = type_name;
INIT_CPLUS_SPECIFIC (type);
TYPE_STUB (type) = 1;
INIT_CPLUS_SPECIFIC (type);
TYPE_STUB (type) = 1;
@@
-1700,10
+1715,10
@@
again:
(*pp)--;
/* We deal with something like t(1,2)=(3,4)=... which
(*pp)--;
/* We deal with something like t(1,2)=(3,4)=... which
- the Lucid compiler and recent gcc versions (post 2.7.3) use. */
+ the Lucid compiler and recent gcc versions (post 2.7.3) use.
*/
/* Allocate and enter the typedef type first.
/* Allocate and enter the typedef type first.
- This handles recursive types. */
+ This handles recursive types.
*/
type = dbx_alloc_type (typenums, objfile);
TYPE_CODE (type) = TYPE_CODE_TYPEDEF;
{
type = dbx_alloc_type (typenums, objfile);
TYPE_CODE (type) = TYPE_CODE_TYPEDEF;
{
@@
-1742,7
+1757,6
@@
again:
copies of a type otherwise. */
replace_type (type, xtype);
TYPE_NAME (type) = NULL;
copies of a type otherwise. */
replace_type (type, xtype);
TYPE_NAME (type) = NULL;
- TYPE_TAG_NAME (type) = NULL;
}
else
{
}
else
{
@@
-1766,7
+1780,8
@@
again:
case '&': /* Reference to another type */
type1 = read_type (pp, objfile);
case '&': /* Reference to another type */
type1 = read_type (pp, objfile);
- type = make_reference_type (type1, dbx_lookup_type (typenums, objfile));
+ type = make_reference_type (type1, dbx_lookup_type (typenums, objfile),
+ TYPE_CODE_REF);
break;
case 'f': /* Function returning another type */
break;
case 'f': /* Function returning another type */
@@
-1805,18
+1820,17
@@
again:
while (**pp && **pp != '#')
{
struct type *arg_type = read_type (pp, objfile);
while (**pp && **pp != '#')
{
struct type *arg_type = read_type (pp, objfile);
- struct type_list *new
= alloca (sizeof (*new)
);
- new->type = arg_type;
- new->next = arg_types;
- arg_types = new;
+ struct type_list *new
obj = XALLOCA (struct type_list
);
+ new
obj
->type = arg_type;
+ new
obj
->next = arg_types;
+ arg_types = new
obj
;
num_args++;
}
if (**pp == '#')
++*pp;
else
{
num_args++;
}
if (**pp == '#')
++*pp;
else
{
- complaint (&symfile_complaints,
- _("Prototyped function type didn't "
+ complaint (_("Prototyped function type didn't "
"end arguments with `#':\n%s"),
type_start);
}
"end arguments with `#':\n%s"),
type_start);
}
@@
-1881,7
+1895,7
@@
again:
else
/* type attribute */
{
else
/* type attribute */
{
- char *attr = *pp;
+ c
onst c
har *attr = *pp;
/* Skip to the semicolon. */
while (**pp != ';' && **pp != '\0')
/* Skip to the semicolon. */
while (**pp != ';' && **pp != '\0')
@@
-1900,12
+1914,12
@@
again:
break;
case 'S': /* String attribute */
break;
case 'S': /* String attribute */
- /* FIXME: check to see if following type is array? */
+ /* FIXME: check to see if following type is array?
*/
is_string = 1;
break;
case 'V': /* Vector attribute */
is_string = 1;
break;
case 'V': /* Vector attribute */
- /* FIXME: check to see if following type is array? */
+ /* FIXME: check to see if following type is array?
*/
is_vector = 1;
break;
is_vector = 1;
break;
@@
-1928,8
+1942,7
@@
again:
(*pp)++;
return_type = read_type (pp, objfile);
if (*(*pp)++ != ';')
(*pp)++;
return_type = read_type (pp, objfile);
if (*(*pp)++ != ';')
- complaint (&symfile_complaints,
- _("invalid (minimal) member type "
+ complaint (_("invalid (minimal) member type "
"data format at symtab pos %d."),
symnum);
type = allocate_stub_method (return_type);
"data format at symtab pos %d."),
symnum);
type = allocate_stub_method (return_type);
@@
-2018,18
+2031,16
@@
again:
make_vector_type (type);
break;
make_vector_type (type);
break;
- case 'S': /* Set
or bitstring
type */
+ case 'S': /* Set type */
type1 = read_type (pp, objfile);
type1 = read_type (pp, objfile);
- type = create_set_type ((struct type *) NULL, type1);
- if (is_string)
- TYPE_CODE (type) = TYPE_CODE_BITSTRING;
+ type = create_set_type (NULL, type1);
if (typenums[0] != -1)
*dbx_lookup_type (typenums, objfile) = type;
break;
default:
if (typenums[0] != -1)
*dbx_lookup_type (typenums, objfile) = type;
break;
default:
- --*pp; /* Go back to the symbol in error */
- /* Particularly important if it was \0! */
+ --*pp; /* Go back to the symbol in error
.
*/
+ /* Particularly important if it was \0!
*/
return error_type (pp, objfile);
}
return error_type (pp, objfile);
}
@@
-2047,15
+2058,16
@@
again:
}
\f
/* RS/6000 xlc/dbx combination uses a set of builtin types, starting from -1.
}
\f
/* RS/6000 xlc/dbx combination uses a set of builtin types, starting from -1.
- Return the proper type node for a given builtin type number. */
+ Return the proper type node for a given builtin type number.
*/
-static const struct objfile_data *rs6000_builtin_type_data;
+static const struct objfile_key<struct type *,
+ gdb::noop_deleter<struct type *>>
+ rs6000_builtin_type_data;
static struct type *
rs6000_builtin_type (int typenum, struct objfile *objfile)
{
static struct type *
rs6000_builtin_type (int typenum, struct objfile *objfile)
{
- struct type **negative_types = objfile_data (objfile,
- rs6000_builtin_type_data);
+ struct type **negative_types = rs6000_builtin_type_data.get (objfile);
/* We recognize types numbered from -NUMBER_RECOGNIZED to -1. */
#define NUMBER_RECOGNIZED 34
/* We recognize types numbered from -NUMBER_RECOGNIZED to -1. */
#define NUMBER_RECOGNIZED 34
@@
-2063,7
+2075,7
@@
rs6000_builtin_type (int typenum, struct objfile *objfile)
if (typenum >= 0 || typenum < -NUMBER_RECOGNIZED)
{
if (typenum >= 0 || typenum < -NUMBER_RECOGNIZED)
{
- complaint (
&symfile_complaints,
_("Unknown builtin type %d"), typenum);
+ complaint (_("Unknown builtin type %d"), typenum);
return objfile_type (objfile)->builtin_error;
}
return objfile_type (objfile)->builtin_error;
}
@@
-2072,7
+2084,7
@@
rs6000_builtin_type (int typenum, struct objfile *objfile)
/* This includes an empty slot for type number -0. */
negative_types = OBSTACK_CALLOC (&objfile->objfile_obstack,
NUMBER_RECOGNIZED + 1, struct type *);
/* This includes an empty slot for type number -0. */
negative_types = OBSTACK_CALLOC (&objfile->objfile_obstack,
NUMBER_RECOGNIZED + 1, struct type *);
-
set_objfile_data (objfile, rs6000_builtin_type_data
, negative_types);
+
rs6000_builtin_type_data.set (objfile
, negative_types);
}
if (negative_types[-typenum] != NULL)
}
if (negative_types[-typenum] != NULL)
@@
-2094,129
+2106,121
@@
rs6000_builtin_type (int typenum, struct objfile *objfile)
is other than 32 bits, then it should use a new negative type
number (or avoid negative type numbers for that case).
See stabs.texinfo. */
is other than 32 bits, then it should use a new negative type
number (or avoid negative type numbers for that case).
See stabs.texinfo. */
- rettype = init_
type (TYPE_CODE_INT, 4, 0, "int", objfile
);
+ rettype = init_
integer_type (objfile, 32, 0, "int"
);
break;
case 2:
break;
case 2:
- rettype = init_type (TYPE_CODE_INT, 1, 0, "char", objfile);
+ rettype = init_integer_type (objfile, 8, 0, "char");
+ TYPE_NOSIGN (rettype) = 1;
break;
case 3:
break;
case 3:
- rettype = init_
type (TYPE_CODE_INT, 2, 0, "short", objfile
);
+ rettype = init_
integer_type (objfile, 16, 0, "short"
);
break;
case 4:
break;
case 4:
- rettype = init_
type (TYPE_CODE_INT, 4, 0, "long", objfile
);
+ rettype = init_
integer_type (objfile, 32, 0, "long"
);
break;
case 5:
break;
case 5:
- rettype = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED,
- "unsigned char", objfile);
+ rettype = init_integer_type (objfile, 8, 1, "unsigned char");
break;
case 6:
break;
case 6:
- rettype = init_
type (TYPE_CODE_INT, 1, 0, "signed char", objfile
);
+ rettype = init_
integer_type (objfile, 8, 0, "signed char"
);
break;
case 7:
break;
case 7:
- rettype = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED,
- "unsigned short", objfile);
+ rettype = init_integer_type (objfile, 16, 1, "unsigned short");
break;
case 8:
break;
case 8:
- rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
- "unsigned int", objfile);
+ rettype = init_integer_type (objfile, 32, 1, "unsigned int");
break;
case 9:
break;
case 9:
- rettype = init_
type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
-
"unsigned", objfile)
;
+ rettype = init_
integer_type (objfile, 32, 1, "unsigned");
+
break
;
case 10:
case 10:
- rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
- "unsigned long", objfile);
+ rettype = init_integer_type (objfile, 32, 1, "unsigned long");
break;
case 11:
break;
case 11:
- rettype = init_type (
TYPE_CODE_VOID, 1, 0, "void", objfile
);
+ rettype = init_type (
objfile, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void"
);
break;
case 12:
/* IEEE single precision (32 bit). */
break;
case 12:
/* IEEE single precision (32 bit). */
- rettype = init_type (TYPE_CODE_FLT, 4, 0, "float", objfile);
+ rettype = init_float_type (objfile, 32, "float",
+ floatformats_ieee_single);
break;
case 13:
/* IEEE double precision (64 bit). */
break;
case 13:
/* IEEE double precision (64 bit). */
- rettype = init_type (TYPE_CODE_FLT, 8, 0, "double", objfile);
+ rettype = init_float_type (objfile, 64, "double",
+ floatformats_ieee_double);
break;
case 14:
/* This is an IEEE double on the RS/6000, and different machines with
different sizes for "long double" should use different negative
type numbers. See stabs.texinfo. */
break;
case 14:
/* This is an IEEE double on the RS/6000, and different machines with
different sizes for "long double" should use different negative
type numbers. See stabs.texinfo. */
- rettype = init_type (TYPE_CODE_FLT, 8, 0, "long double", objfile);
+ rettype = init_float_type (objfile, 64, "long double",
+ floatformats_ieee_double);
break;
case 15:
break;
case 15:
- rettype = init_
type (TYPE_CODE_INT, 4, 0, "integer", objfile
);
+ rettype = init_
integer_type (objfile, 32, 0, "integer"
);
break;
case 16:
break;
case 16:
- rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
- "boolean", objfile);
+ rettype = init_boolean_type (objfile, 32, 1, "boolean");
break;
case 17:
break;
case 17:
- rettype = init_type (TYPE_CODE_FLT, 4, 0, "short real", objfile);
+ rettype = init_float_type (objfile, 32, "short real",
+ floatformats_ieee_single);
break;
case 18:
break;
case 18:
- rettype = init_type (TYPE_CODE_FLT, 8, 0, "real", objfile);
+ rettype = init_float_type (objfile, 64, "real",
+ floatformats_ieee_double);
break;
case 19:
break;
case 19:
- rettype = init_type (
TYPE_CODE_ERROR, 0, 0, "stringptr", objfile
);
+ rettype = init_type (
objfile, TYPE_CODE_ERROR, 0, "stringptr"
);
break;
case 20:
break;
case 20:
- rettype = init_type (TYPE_CODE_CHAR, 1, TYPE_FLAG_UNSIGNED,
- "character", objfile);
+ rettype = init_character_type (objfile, 8, 1, "character");
break;
case 21:
break;
case 21:
- rettype = init_type (TYPE_CODE_BOOL, 1, TYPE_FLAG_UNSIGNED,
- "logical*1", objfile);
+ rettype = init_boolean_type (objfile, 8, 1, "logical*1");
break;
case 22:
break;
case 22:
- rettype = init_type (TYPE_CODE_BOOL, 2, TYPE_FLAG_UNSIGNED,
- "logical*2", objfile);
+ rettype = init_boolean_type (objfile, 16, 1, "logical*2");
break;
case 23:
break;
case 23:
- rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
- "logical*4", objfile);
+ rettype = init_boolean_type (objfile, 32, 1, "logical*4");
break;
case 24:
break;
case 24:
- rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
- "logical", objfile);
+ rettype = init_boolean_type (objfile, 32, 1, "logical");
break;
case 25:
/* Complex type consisting of two IEEE single precision values. */
break;
case 25:
/* Complex type consisting of two IEEE single precision values. */
- rettype = init_type (TYPE_CODE_COMPLEX, 8, 0, "complex", objfile);
- TYPE_TARGET_TYPE (rettype) = init_type (TYPE_CODE_FLT, 4, 0, "float",
- objfile);
+ rettype = init_complex_type (objfile, "complex",
+ rs6000_builtin_type (12, objfile));
break;
case 26:
/* Complex type consisting of two IEEE double precision values. */
break;
case 26:
/* Complex type consisting of two IEEE double precision values. */
- rettype = init_type (TYPE_CODE_COMPLEX, 16, 0, "double complex", NULL);
- TYPE_TARGET_TYPE (rettype) = init_type (TYPE_CODE_FLT, 8, 0, "double",
- objfile);
+ rettype = init_complex_type (objfile, "double complex",
+ rs6000_builtin_type (13, objfile));
break;
case 27:
break;
case 27:
- rettype = init_
type (TYPE_CODE_INT, 1, 0, "integer*1", objfile
);
+ rettype = init_
integer_type (objfile, 8, 0, "integer*1"
);
break;
case 28:
break;
case 28:
- rettype = init_
type (TYPE_CODE_INT, 2, 0, "integer*2", objfile
);
+ rettype = init_
integer_type (objfile, 16, 0, "integer*2"
);
break;
case 29:
break;
case 29:
- rettype = init_
type (TYPE_CODE_INT, 4, 0, "integer*4", objfile
);
+ rettype = init_
integer_type (objfile, 32, 0, "integer*4"
);
break;
case 30:
break;
case 30:
- rettype = init_
type (TYPE_CODE_CHAR, 2, 0, "wchar", objfile
);
+ rettype = init_
character_type (objfile, 16, 0, "wchar"
);
break;
case 31:
break;
case 31:
- rettype = init_
type (TYPE_CODE_INT, 8, 0, "long long", objfile
);
+ rettype = init_
integer_type (objfile, 64, 0, "long long"
);
break;
case 32:
break;
case 32:
- rettype = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
- "unsigned long long", objfile);
+ rettype = init_integer_type (objfile, 64, 1, "unsigned long long");
break;
case 33:
break;
case 33:
- rettype = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
- "logical*8", objfile);
+ rettype = init_integer_type (objfile, 64, 1, "logical*8");
break;
case 34:
break;
case 34:
- rettype = init_
type (TYPE_CODE_INT, 8, 0, "integer*8", objfile
);
+ rettype = init_
integer_type (objfile, 64, 0, "integer*8"
);
break;
}
negative_types[-typenum] = rettype;
break;
}
negative_types[-typenum] = rettype;
@@
-2225,10
+2229,11
@@
rs6000_builtin_type (int typenum, struct objfile *objfile)
\f
/* This page contains subroutines of read_type. */
\f
/* This page contains subroutines of read_type. */
-/* Replace *OLD_NAME with the method name portion of PHYSNAME. */
+/* Wrapper around method_name_from_physname to flag a complaint
+ if there is an error. */
-static
void
-
update_method_name_from_physname (char **old_name,
char *physname)
+static
char *
+
stabs_method_name_from_physname (const
char *physname)
{
char *method_name;
{
char *method_name;
@@
-2236,18
+2241,11
@@
update_method_name_from_physname (char **old_name, char *physname)
if (method_name == NULL)
{
if (method_name == NULL)
{
- complaint (&symfile_complaints,
- _("Method has bad physname %s\n"), physname);
- return;
+ complaint (_("Method has bad physname %s\n"), physname);
+ return NULL;
}
}
- if (strcmp (*old_name, method_name) != 0)
- {
- xfree (*old_name);
- *old_name = method_name;
- }
- else
- xfree (method_name);
+ return method_name;
}
/* Read member function stabs info for C++ classes. The form of each member
}
/* Read member function stabs info for C++ classes. The form of each member
@@
-2266,15
+2264,11
@@
update_method_name_from_physname (char **old_name, char *physname)
Returns 1 for success, 0 for failure. */
static int
Returns 1 for success, 0 for failure. */
static int
-read_member_functions (struct
field_info *fip, char **pp, struct type *type
,
- struct objfile *objfile)
+read_member_functions (struct
stab_field_info *fip, const char **pp
,
+ struct
type *type, struct
objfile *objfile)
{
int nfn_fields = 0;
int length = 0;
{
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
{
int i;
struct next_fnfield
{
@@
-2286,16
+2280,16
@@
read_member_functions (struct field_info *fip, char **pp, struct type *type,
struct next_fnfieldlist *new_fnlist;
struct next_fnfield *new_sublist;
char *main_fn_name;
struct next_fnfieldlist *new_fnlist;
struct next_fnfield *new_sublist;
char *main_fn_name;
- char *p;
+ c
onst c
har *p;
/* Process each list until we find something that is not a member function
/* Process each list until we find something that is not a member function
- or find the end of the functions. */
+ or find the end of the functions.
*/
while (**pp != ';')
{
/* We should be positioned at the start of the function name.
Scan forward to find the first ':' and if it is not the
while (**pp != ';')
{
/* We should be positioned at the start of the function name.
Scan forward to find the first ':' and if it is not the
- first of a "::" delimiter, then this is not a member function. */
+ first of a "::" delimiter, then this is not a member function.
*/
p = *pp;
while (*p != ':')
{
p = *pp;
while (*p != ':')
{
@@
-2310,10
+2304,7
@@
read_member_functions (struct field_info *fip, char **pp, struct type *type,
look_ahead_type = NULL;
length = 0;
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));
+ new_fnlist = OBSTACK_ZALLOC (&fip->obstack, struct next_fnfieldlist);
if ((*pp)[0] == 'o' && (*pp)[1] == 'p' && is_cplus_marker ((*pp)[2]))
{
if ((*pp)[0] == 'o' && (*pp)[1] == 'p' && is_cplus_marker ((*pp)[2]))
{
@@
-2352,15
+2343,12
@@
read_member_functions (struct field_info *fip, char **pp, struct type *type,
do
{
do
{
- new_sublist =
- (struct next_fnfield *) xmalloc (sizeof (struct next_fnfield));
- make_cleanup (xfree, new_sublist);
- memset (new_sublist, 0, sizeof (struct next_fnfield));
+ new_sublist = OBSTACK_ZALLOC (&fip->obstack, struct next_fnfield);
/* Check for and handle cretinous dbx symbol name continuation! */
if (look_ahead_type == NULL)
{
/* Check for and handle cretinous dbx symbol name continuation! */
if (look_ahead_type == NULL)
{
- /* Normal case. */
+ /* Normal case.
*/
STABS_CONTINUE (pp, objfile);
new_sublist->fn_field.type = read_type (pp, objfile);
STABS_CONTINUE (pp, objfile);
new_sublist->fn_field.type = read_type (pp, objfile);
@@
-2384,14
+2372,21
@@
read_member_functions (struct field_info *fip, char **pp, struct type *type,
p++;
}
p++;
}
- /* If this is just a stub, then we don't have the real name here. */
+ /* These are methods, not functions. */
+ if (TYPE_CODE (new_sublist->fn_field.type) == TYPE_CODE_FUNC)
+ TYPE_CODE (new_sublist->fn_field.type) = TYPE_CODE_METHOD;
+ else
+ gdb_assert (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_STUB (new_sublist->fn_field.type))
{
- if (!TYPE_
DOMAIN
_TYPE (new_sublist->fn_field.type))
-
TYPE_DOMAIN_TYPE (new_sublist->fn_field.type) = type
;
+ if (!TYPE_
SELF
_TYPE (new_sublist->fn_field.type))
+
set_type_self_type (new_sublist->fn_field.type, type)
;
new_sublist->fn_field.is_stub = 1;
}
new_sublist->fn_field.is_stub = 1;
}
+
new_sublist->fn_field.physname = savestring (*pp, p - *pp);
*pp = p + 1;
new_sublist->fn_field.physname = savestring (*pp, p - *pp);
*pp = p + 1;
@@
-2409,34
+2404,33
@@
read_member_functions (struct field_info *fip, char **pp, struct type *type,
STABS_CONTINUE (pp, objfile);
switch (**pp)
{
STABS_CONTINUE (pp, objfile);
switch (**pp)
{
- case 'A': /* Normal functions. */
+ case 'A': /* Normal functions.
*/
new_sublist->fn_field.is_const = 0;
new_sublist->fn_field.is_volatile = 0;
(*pp)++;
break;
new_sublist->fn_field.is_const = 0;
new_sublist->fn_field.is_volatile = 0;
(*pp)++;
break;
- case 'B': /* `const' member functions. */
+ case 'B': /* `const' member functions.
*/
new_sublist->fn_field.is_const = 1;
new_sublist->fn_field.is_volatile = 0;
(*pp)++;
break;
new_sublist->fn_field.is_const = 1;
new_sublist->fn_field.is_volatile = 0;
(*pp)++;
break;
- case 'C': /* `volatile' member function. */
+ case 'C': /* `volatile' member function.
*/
new_sublist->fn_field.is_const = 0;
new_sublist->fn_field.is_volatile = 1;
(*pp)++;
break;
new_sublist->fn_field.is_const = 0;
new_sublist->fn_field.is_volatile = 1;
(*pp)++;
break;
- case 'D': /* `const volatile' member function. */
+ case 'D': /* `const volatile' member function.
*/
new_sublist->fn_field.is_const = 1;
new_sublist->fn_field.is_volatile = 1;
(*pp)++;
break;
case '*': /* File compiled with g++ version 1 --
new_sublist->fn_field.is_const = 1;
new_sublist->fn_field.is_volatile = 1;
(*pp)++;
break;
case '*': /* File compiled with g++ version 1 --
- no info */
+ no info
.
*/
case '?':
case '.':
break;
default:
case '?':
case '.':
break;
default:
- complaint (&symfile_complaints,
- _("const/volatile indicator missing, got '%c'"),
+ complaint (_("const/volatile indicator missing, got '%c'"),
**pp);
break;
}
**pp);
break;
}
@@
-2472,7
+2466,7
@@
read_member_functions (struct field_info *fip, char **pp, struct type *type,
look_ahead_type = read_type (pp, objfile);
if (**pp == ':')
{
look_ahead_type = read_type (pp, objfile);
if (**pp == ':')
{
- /* g++ version 1 overloaded methods. */
+ /* g++ version 1 overloaded methods.
*/
}
else
{
}
else
{
@@
-2519,10
+2513,10
@@
read_member_functions (struct field_info *fip, char **pp, struct type *type,
default:
/* error */
default:
/* error */
- complaint (&symfile_complaints,
- _("member function type missing, got '%c'"),
+ complaint (_("member function type missing, got '%c'"),
(*pp)[-1]);
(*pp)[-1]);
- /* Fall through into normal member function. */
+ /* Normal member function. */
+ /* Fall through. */
case '.':
/* normal member function. */
case '.':
/* normal member function. */
@@
-2551,7
+2545,6
@@
read_member_functions (struct field_info *fip, char **pp, struct type *type,
}
else
{
}
else
{
- int has_stub = 0;
int has_destructor = 0, has_other = 0;
int is_v3 = 0;
struct next_fnfield *tmp_sublist;
int has_destructor = 0, has_other = 0;
int is_v3 = 0;
struct next_fnfield *tmp_sublist;
@@
-2615,8
+2608,6
@@
read_member_functions (struct field_info *fip, char **pp, struct type *type,
tmp_sublist = sublist;
while (tmp_sublist != NULL)
{
tmp_sublist = sublist;
while (tmp_sublist != NULL)
{
- if (tmp_sublist->fn_field.is_stub)
- has_stub = 1;
if (tmp_sublist->fn_field.physname[0] == '_'
&& tmp_sublist->fn_field.physname[1] == 'Z')
is_v3 = 1;
if (tmp_sublist->fn_field.physname[0] == '_'
&& tmp_sublist->fn_field.physname[1] == 'Z')
is_v3 = 1;
@@
-2636,17
+2627,16
@@
read_member_functions (struct field_info *fip, char **pp, struct type *type,
/* Create a new fn_fieldlist for the destructors. */
/* Create a new fn_fieldlist for the destructors. */
- destr_fnlist = (struct next_fnfieldlist *)
- xmalloc (sizeof (struct next_fnfieldlist));
- make_cleanup (xfree, destr_fnlist);
- memset (destr_fnlist, 0, sizeof (struct next_fnfieldlist));
+ destr_fnlist = OBSTACK_ZALLOC (&fip->obstack,
+ struct next_fnfieldlist);
+
destr_fnlist->fn_fieldlist.name
= obconcat (&objfile->objfile_obstack, "~",
new_fnlist->fn_fieldlist.name, (char *) NULL);
destr_fnlist->fn_fieldlist.name
= obconcat (&objfile->objfile_obstack, "~",
new_fnlist->fn_fieldlist.name, (char *) NULL);
- destr_fnlist->fn_fieldlist.fn_fields =
(struct fn_field *)
-
obstack_alloc
(&objfile->objfile_obstack,
-
sizeof (struct fn_field) *
has_destructor);
+ destr_fnlist->fn_fieldlist.fn_fields =
+
XOBNEWVEC
(&objfile->objfile_obstack,
+
struct fn_field,
has_destructor);
memset (destr_fnlist->fn_fieldlist.fn_fields, 0,
sizeof (struct fn_field) * has_destructor);
tmp_sublist = sublist;
memset (destr_fnlist->fn_fieldlist.fn_fields, 0,
sizeof (struct fn_field) * has_destructor);
tmp_sublist = sublist;
@@
-2674,7
+2664,6
@@
read_member_functions (struct field_info *fip, char **pp, struct type *type,
destr_fnlist->next = fip->fnlist;
fip->fnlist = destr_fnlist;
nfn_fields++;
destr_fnlist->next = fip->fnlist;
fip->fnlist = destr_fnlist;
nfn_fields++;
- total_length += has_destructor;
length -= has_destructor;
}
else if (is_v3)
length -= has_destructor;
}
else if (is_v3)
@@
-2685,37
+2674,29
@@
read_member_functions (struct field_info *fip, char **pp, struct type *type,
- in -gstabs instead of -gstabs+
- or for static methods, which are output as a function type
instead of a method type. */
- in -gstabs instead of -gstabs+
- or for static methods, which are output as a function type
instead of a method type. */
+ char *new_method_name =
+ stabs_method_name_from_physname (sublist->fn_field.physname);
- update_method_name_from_physname (&new_fnlist->fn_fieldlist.name,
- sublist->fn_field.physname);
+ if (new_method_name != NULL
+ && strcmp (new_method_name,
+ new_fnlist->fn_fieldlist.name) != 0)
+ {
+ new_fnlist->fn_fieldlist.name = new_method_name;
+ xfree (main_fn_name);
+ }
+ else
+ xfree (new_method_name);
}
else if (has_destructor && new_fnlist->fn_fieldlist.name[0] != '~')
{
new_fnlist->fn_fieldlist.name =
}
else if (has_destructor && new_fnlist->fn_fieldlist.name[0] != '~')
{
new_fnlist->fn_fieldlist.name =
- concat ("~", main_fn_name, (char *)NULL);
+ obconcat (&objfile->objfile_obstack,
+ "~", main_fn_name, (char *)NULL);
xfree (main_fn_name);
}
xfree (main_fn_name);
}
- else if (!has_stub)
- {
- char dem_opname[256];
- int ret;
-
- ret = cplus_demangle_opname (new_fnlist->fn_fieldlist.name,
- dem_opname, DMGL_ANSI);
- if (!ret)
- ret = cplus_demangle_opname (new_fnlist->fn_fieldlist.name,
- dem_opname, 0);
- if (ret)
- new_fnlist->fn_fieldlist.name
- = obsavestring (dem_opname, strlen (dem_opname),
- &objfile->objfile_obstack);
- }
- new_fnlist->fn_fieldlist.fn_fields = (struct fn_field *)
- obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct fn_field) * length);
- memset (new_fnlist->fn_fieldlist.fn_fields, 0,
- sizeof (struct fn_field) * length);
+ new_fnlist->fn_fieldlist.fn_fields
+ = OBSTACK_CALLOC (&objfile->objfile_obstack, length, fn_field);
for (i = length; (i--, sublist); sublist = sublist->next)
{
new_fnlist->fn_fieldlist.fn_fields[i] = sublist->fn_field;
for (i = length; (i--, sublist); sublist = sublist->next)
{
new_fnlist->fn_fieldlist.fn_fields[i] = sublist->fn_field;
@@
-2725,7
+2706,6
@@
read_member_functions (struct field_info *fip, char **pp, struct type *type,
new_fnlist->next = fip->fnlist;
fip->fnlist = new_fnlist;
nfn_fields++;
new_fnlist->next = fip->fnlist;
fip->fnlist = new_fnlist;
nfn_fields++;
- total_length += length;
}
}
}
}
@@
-2737,7
+2717,6
@@
read_member_functions (struct field_info *fip, char **pp, struct type *type,
memset (TYPE_FN_FIELDLISTS (type), 0,
sizeof (struct fn_fieldlist) * nfn_fields);
TYPE_NFN_FIELDS (type) = 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;
}
return 1;
}
return 1;
@@
-2749,11
+2728,11
@@
read_member_functions (struct field_info *fip, char **pp, struct type *type,
keep parsing and it's time for error_type(). */
static int
keep parsing and it's time for error_type(). */
static int
-read_cpp_abbrev (struct
field_info *fip, char **pp, struct type *type
,
- struct objfile *objfile)
+read_cpp_abbrev (struct
stab_field_info *fip, const char **pp
,
+ struct
type *type, struct
objfile *objfile)
{
{
- char *p;
- char *name;
+ c
onst c
har *p;
+ c
onst c
har *name;
char cpp_abbrev;
struct type *context;
char cpp_abbrev;
struct type *context;
@@
-2768,14
+2747,14
@@
read_cpp_abbrev (struct field_info *fip, char **pp, struct type *type,
/* At this point, *pp points to something like "22:23=*22...",
where the type number before the ':' is the "context" and
everything after is a regular type definition. Lookup the
/* At this point, *pp points to something like "22:23=*22...",
where the type number before the ':' is the "context" and
everything after is a regular type definition. Lookup the
- type, find it's name, and construct the field name. */
+ type, find it's name, and construct the field name.
*/
context = read_type (pp, objfile);
switch (cpp_abbrev)
{
case 'f': /* $vf -- a virtual function table pointer */
context = read_type (pp, objfile);
switch (cpp_abbrev)
{
case 'f': /* $vf -- a virtual function table pointer */
- name =
type_name_no_tag
(context);
+ name =
TYPE_NAME
(context);
if (name == NULL)
{
name = "";
if (name == NULL)
{
name = "";
@@
-2785,11
+2764,10
@@
read_cpp_abbrev (struct field_info *fip, char **pp, struct type *type,
break;
case 'b': /* $vb -- a virtual bsomethingorother */
break;
case 'b': /* $vb -- a virtual bsomethingorother */
- name =
type_name_no_tag
(context);
+ name =
TYPE_NAME
(context);
if (name == NULL)
{
if (name == NULL)
{
- complaint (&symfile_complaints,
- _("C++ abbreviated type name "
+ complaint (_("C++ abbreviated type name "
"unknown at symtab pos %d"),
symnum);
name = "FOO";
"unknown at symtab pos %d"),
symnum);
name = "FOO";
@@
-2807,7
+2785,7
@@
read_cpp_abbrev (struct field_info *fip, char **pp, struct type *type,
}
/* At this point, *pp points to the ':'. Skip it and read the
}
/* At this point, *pp points to the ':'. Skip it and read the
- field type. */
+ field type.
*/
p = ++(*pp);
if (p[-1] != ':')
p = ++(*pp);
if (p[-1] != ':')
@@
-2824,8
+2802,8
@@
read_cpp_abbrev (struct field_info *fip, char **pp, struct type *type,
{
int nbits;
{
int nbits;
-
FIELD_BITPOS (fip->list->field) = read_huge_number (pp, ';', &nbits
,
-
0
);
+
SET_FIELD_BITPOS (fip->list->field
,
+
read_huge_number (pp, ';', &nbits, 0)
);
if (nbits != 0)
return 0;
}
if (nbits != 0)
return 0;
}
@@
-2845,16
+2823,17
@@
read_cpp_abbrev (struct field_info *fip, char **pp, struct type *type,
}
static void
}
static void
-read_one_struct_field (struct field_info *fip, char **pp, char *p,
- struct type *type, struct objfile *objfile)
+read_one_struct_field (struct stab_field_info *fip, const char **pp,
+ const char *p, struct type *type,
+ struct objfile *objfile)
{
struct gdbarch *gdbarch = get_objfile_arch (objfile);
{
struct gdbarch *gdbarch = get_objfile_arch (objfile);
- fip->list->field.name
=
-
obsavestring (*pp, p - *pp, &objfile->objfile_obstack
);
+ fip->list->field.name
+
= obstack_strndup (&objfile->objfile_obstack, *pp, p - *pp
);
*pp = p + 1;
*pp = p + 1;
- /* This means we have a visibility for a field coming. */
+ /* This means we have a visibility for a field coming.
*/
if (**pp == '/')
{
(*pp)++;
if (**pp == '/')
{
(*pp)++;
@@
-2871,7
+2850,7
@@
read_one_struct_field (struct field_info *fip, char **pp, char *p,
{
p = ++(*pp);
#if 0
{
p = ++(*pp);
#if 0
- /* Possible future hook for nested types. */
+ /* Possible future hook for nested types.
*/
if (**pp == '!')
{
fip->list->field.bitpos = (long) -2; /* nested type */
if (**pp == '!')
{
fip->list->field.bitpos = (long) -2; /* nested type */
@@
-2901,7
+2880,8
@@
read_one_struct_field (struct field_info *fip, char **pp, char *p,
{
int nbits;
{
int nbits;
- FIELD_BITPOS (fip->list->field) = read_huge_number (pp, ',', &nbits, 0);
+ SET_FIELD_BITPOS (fip->list->field,
+ read_huge_number (pp, ',', &nbits, 0));
if (nbits != 0)
{
stabs_general_complaint ("bad structure-type format");
if (nbits != 0)
{
stabs_general_complaint ("bad structure-type format");
@@
-2987,11
+2967,11
@@
read_one_struct_field (struct field_info *fip, char **pp, char *p,
Returns 1 for success, 0 for failure. */
static int
Returns 1 for success, 0 for failure. */
static int
-read_struct_fields (struct
field_info *fip, char **pp, struct type *type
,
- struct objfile *objfile)
+read_struct_fields (struct
stab_field_info *fip, const char **pp
,
+ struct
type *type, struct
objfile *objfile)
{
{
- char *p;
- struct nextfield *new;
+ c
onst c
har *p;
+ struct nextfield *new
obj
;
/* We better set p right now, in case there are no fields at all... */
/* We better set p right now, in case there are no fields at all... */
@@
-2999,19
+2979,18
@@
read_struct_fields (struct field_info *fip, char **pp, struct type *type,
/* Read each data member type until we find the terminating ';' at the end of
the data member list, or break for some other reason such as finding the
/* Read each data member type until we find the terminating ';' at the end of
the data member list, or break for some other reason such as finding the
- start of the member function list. */
+ start of the member function list.
*/
/* Stab string for structure/union does not end with two ';' in
/* Stab string for structure/union does not end with two ';' in
- SUN C compiler 5.3 i.e. F6U2, hence check for end of string. */
+ SUN C compiler 5.3 i.e. F6U2, hence check for end of string.
*/
while (**pp != ';' && **pp != '\0')
{
STABS_CONTINUE (pp, objfile);
/* Get space to record the next field's data. */
while (**pp != ';' && **pp != '\0')
{
STABS_CONTINUE (pp, objfile);
/* Get space to record the next field's data. */
- new = (struct nextfield *) xmalloc (sizeof (struct nextfield));
- make_cleanup (xfree, new);
- memset (new, 0, sizeof (struct nextfield));
- new->next = fip->list;
- fip->list = new;
+ newobj = OBSTACK_ZALLOC (&fip->obstack, struct nextfield);
+
+ newobj->next = fip->list;
+ fip->list = newobj;
/* Get the field name. */
p = *pp;
/* Get the field name. */
p = *pp;
@@
-3031,7
+3010,7
@@
read_struct_fields (struct field_info *fip, char **pp, struct type *type,
/* Look for the ':' that separates the field name from the field
values. Data members are delimited by a single ':', while member
functions are delimited by a pair of ':'s. When we hit the member
/* Look for the ':' that separates the field name from the field
values. Data members are delimited by a single ':', while member
functions are delimited by a pair of ':'s. When we hit the member
- functions (if any), terminate scan loop and return. */
+ functions (if any), terminate scan loop and return.
*/
while (*p != ':' && *p != '\0')
{
while (*p != ':' && *p != '\0')
{
@@
-3051,7
+3030,7
@@
read_struct_fields (struct field_info *fip, char **pp, struct type *type,
{
/* (the deleted) chill the list of fields: the last entry (at
the head) is a partially constructed entry which we now
{
/* (the deleted) chill the list of fields: the last entry (at
the head) is a partially constructed entry which we now
- scrub. */
+ scrub.
*/
fip->list = fip->list->next;
}
return 1;
fip->list = fip->list->next;
}
return 1;
@@
-3085,11
+3064,11
@@
read_struct_fields (struct field_info *fip, char **pp, struct type *type,
static int
static int
-read_baseclasses (struct
field_info *fip, char **pp, struct type *type
,
- struct objfile *objfile)
+read_baseclasses (struct
stab_field_info *fip, const char **pp
,
+ struct
type *type, struct
objfile *objfile)
{
int i;
{
int i;
- struct nextfield *new;
+ struct nextfield *new
obj
;
if (**pp != '!')
{
if (**pp != '!')
{
@@
-3097,7
+3076,7
@@
read_baseclasses (struct field_info *fip, char **pp, struct type *type,
}
else
{
}
else
{
- /* Skip the '!' baseclass information marker. */
+ /* Skip the '!' baseclass information marker.
*/
(*pp)++;
}
(*pp)++;
}
@@
-3129,18
+3108,18
@@
read_baseclasses (struct field_info *fip, char **pp, struct type *type,
for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
{
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!
*/
+ new
obj = OBSTACK_ZALLOC (&fip->obstack, struct nextfield
);
+
+
newobj->next = fip->list
;
+
fip->list = newobj
;
+ FIELD_BITSIZE (newobj->field) = 0; /* This should be an unpacked
+
field!
*/
STABS_CONTINUE (pp, objfile);
switch (**pp)
{
case '0':
STABS_CONTINUE (pp, objfile);
switch (**pp)
{
case '0':
- /* Nothing to do. */
+ /* Nothing to do.
*/
break;
case '1':
SET_TYPE_FIELD_VIRTUAL (type, i);
break;
case '1':
SET_TYPE_FIELD_VIRTUAL (type, i);
@@
-3148,15
+3127,14
@@
read_baseclasses (struct field_info *fip, char **pp, struct type *type,
default:
/* Unknown character. Complain and treat it as non-virtual. */
{
default:
/* Unknown character. Complain and treat it as non-virtual. */
{
- complaint (&symfile_complaints,
- _("Unknown virtual character `%c' for baseclass"),
+ complaint (_("Unknown virtual character `%c' for baseclass"),
**pp);
}
}
++(*pp);
**pp);
}
}
++(*pp);
- new->visibility = *(*pp)++;
- switch (new->visibility)
+ new
obj
->visibility = *(*pp)++;
+ switch (new
obj
->visibility)
{
case VISIBILITY_PRIVATE:
case VISIBILITY_PROTECTED:
{
case VISIBILITY_PRIVATE:
case VISIBILITY_PROTECTED:
@@
-3166,10
+3144,9
@@
read_baseclasses (struct field_info *fip, char **pp, struct type *type,
/* Bad visibility format. Complain and treat it as
public. */
{
/* Bad visibility format. Complain and treat it as
public. */
{
- complaint (&symfile_complaints,
- _("Unknown visibility `%c' for baseclass"),
- new->visibility);
- new->visibility = VISIBILITY_PUBLIC;
+ complaint (_("Unknown visibility `%c' for baseclass"),
+ newobj->visibility);
+ newobj->visibility = VISIBILITY_PUBLIC;
}
}
}
}
@@
-3180,19
+3157,19
@@
read_baseclasses (struct field_info *fip, char **pp, struct type *type,
corresponding to this baseclass. Always zero in the absence of
multiple inheritance. */
corresponding to this baseclass. Always zero in the absence of
multiple inheritance. */
-
FIELD_BITPOS (new->field) = read_huge_number (pp, ',', &nbits, 0
);
+
SET_FIELD_BITPOS (newobj->field, read_huge_number (pp, ',', &nbits, 0)
);
if (nbits != 0)
return 0;
}
/* The last piece of baseclass information is the type of the
base class. Read it, and remember it's type name as this
if (nbits != 0)
return 0;
}
/* The last piece of baseclass information is the type of the
base class. Read it, and remember it's type name as this
- field's name. */
+ field's name.
*/
- new->field.type = read_type (pp, objfile);
- new
->field.name = type_name_no_tag (new
->field.type);
+ new
obj
->field.type = read_type (pp, objfile);
+ new
obj->field.name = TYPE_NAME (newobj
->field.type);
- /*
skip trailing ';' and bump count of number of fields seen
*/
+ /*
Skip trailing ';' and bump count of number of fields seen.
*/
if (**pp == ';')
(*pp)++;
else
if (**pp == ';')
(*pp)++;
else
@@
-3210,14
+3187,14
@@
read_baseclasses (struct field_info *fip, char **pp, struct type *type,
so we can look for the vptr base class info. */
static int
so we can look for the vptr base class info. */
static int
-read_tilde_fields (struct
field_info *fip, char **pp, struct type *type
,
- struct objfile *objfile)
+read_tilde_fields (struct
stab_field_info *fip, const char **pp
,
+ struct
type *type, struct
objfile *objfile)
{
{
- char *p;
+ c
onst c
har *p;
STABS_CONTINUE (pp, objfile);
STABS_CONTINUE (pp, objfile);
- /* If we are positioned at a ';', then skip it. */
+ /* If we are positioned at a ';', then skip it.
*/
if (**pp == ';')
{
(*pp)++;
if (**pp == ';')
{
(*pp)++;
@@
-3230,7
+3207,7
@@
read_tilde_fields (struct field_info *fip, char **pp, struct type *type,
if (**pp == '=' || **pp == '+' || **pp == '-')
{
/* Obsolete flags that used to indicate the presence
if (**pp == '=' || **pp == '+' || **pp == '-')
{
/* Obsolete flags that used to indicate the presence
- of constructors and/or destructors. */
+ of constructors and/or destructors.
*/
(*pp)++;
}
(*pp)++;
}
@@
-3258,32
+3235,31
@@
read_tilde_fields (struct field_info *fip, char **pp, struct type *type,
return 0;
}
return 0;
}
-
TYPE_VPTR_BASETYPE (type) = t
;
- if (type == t) /* Our own class provides vtbl ptr */
+
set_type_vptr_basetype (type, t)
;
+ if (type == t) /* Our own class provides vtbl ptr
.
*/
{
for (i = TYPE_NFIELDS (t) - 1;
i >= TYPE_N_BASECLASSES (t);
--i)
{
{
for (i = TYPE_NFIELDS (t) - 1;
i >= TYPE_N_BASECLASSES (t);
--i)
{
- char *name = TYPE_FIELD_NAME (t, i);
+ c
onst c
har *name = TYPE_FIELD_NAME (t, i);
if (!strncmp (name, vptr_name, sizeof (vptr_name) - 2)
&& is_cplus_marker (name[sizeof (vptr_name) - 2]))
{
if (!strncmp (name, vptr_name, sizeof (vptr_name) - 2)
&& is_cplus_marker (name[sizeof (vptr_name) - 2]))
{
-
TYPE_VPTR_FIELDNO (type) = i
;
+
set_type_vptr_fieldno (type, i)
;
goto gotit;
}
}
/* Virtual function table field not found. */
goto gotit;
}
}
/* Virtual function table field not found. */
- complaint (&symfile_complaints,
- _("virtual function table pointer "
+ complaint (_("virtual function table pointer "
"not found when defining class `%s'"),
TYPE_NAME (type));
return 0;
}
else
{
"not found when defining class `%s'"),
TYPE_NAME (type));
return 0;
}
else
{
-
TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t
);
+
set_type_vptr_fieldno (type, TYPE_VPTR_FIELDNO (t)
);
}
gotit:
}
gotit:
@@
-3294,7
+3270,7
@@
read_tilde_fields (struct field_info *fip, char **pp, struct type *type,
}
static int
}
static int
-attach_fn_fields_to_type (struct field_info *fip, struct type *type)
+attach_fn_fields_to_type (struct
stab_
field_info *fip, struct type *type)
{
int n;
{
int n;
@@
-3302,7
+3278,7
@@
attach_fn_fields_to_type (struct field_info *fip, struct type *type)
fip->fnlist != NULL;
fip->fnlist = fip->fnlist->next)
{
fip->fnlist != NULL;
fip->fnlist = fip->fnlist->next)
{
- --n; /* Circumvent Sun3 compiler bug */
+ --n; /* Circumvent Sun3 compiler bug
.
*/
TYPE_FN_FIELDLISTS (type)[n] = fip->fnlist->fn_fieldlist;
}
return 1;
TYPE_FN_FIELDLISTS (type)[n] = fip->fnlist->fn_fieldlist;
}
return 1;
@@
-3313,7
+3289,7
@@
attach_fn_fields_to_type (struct field_info *fip, struct type *type)
for this class's virtual functions. */
static int
for this class's virtual functions. */
static int
-attach_fields_to_type (struct field_info *fip, struct type *type,
+attach_fields_to_type (struct
stab_
field_info *fip, struct type *type,
struct objfile *objfile)
{
int nfields = 0;
struct objfile *objfile)
{
int nfields = 0;
@@
-3323,7
+3299,7
@@
attach_fields_to_type (struct field_info *fip, struct type *type,
/* Count up the number of fields that we have, as well as taking note of
whether or not there are any non-public fields, which requires us to
allocate and build the private_field_bits and protected_field_bits
/* Count up the number of fields that we have, as well as taking note of
whether or not there are any non-public fields, which requires us to
allocate and build the private_field_bits and protected_field_bits
- bitfields. */
+ bitfields.
*/
for (scan = fip->list; scan != NULL; scan = scan->next)
{
for (scan = fip->list; scan != NULL; scan = scan->next)
{
@@
-3336,7
+3312,7
@@
attach_fields_to_type (struct field_info *fip, struct type *type,
/* Now we know how many fields there are, and whether or not there are any
non-public fields. Record the field count, allocate space for the
/* Now we know how many fields there are, and whether or not there are any
non-public fields. Record the field count, allocate space for the
- array of fields, and create blank visibility bitfields if necessary. */
+ array of fields, and create blank visibility bitfields if necessary.
*/
TYPE_NFIELDS (type) = nfields;
TYPE_FIELDS (type) = (struct field *)
TYPE_NFIELDS (type) = nfields;
TYPE_FIELDS (type) = (struct field *)
@@
-3360,9
+3336,10
@@
attach_fields_to_type (struct field_info *fip, struct type *type,
B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
}
B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
}
- /* Copy the saved-up fields into the field vector. Start from the head
- of the list, adding to the tail of the field array, so that they end
- up in the same order in the array in which they were added to the list. */
+ /* Copy the saved-up fields into the field vector. Start from the
+ head of the list, adding to the tail of the field array, so that
+ they end up in the same order in the array in which they were
+ added to the list. */
while (nfields-- > 0)
{
while (nfields-- > 0)
{
@@
-3387,8
+3364,7
@@
attach_fields_to_type (struct field_info *fip, struct type *type,
default:
/* Unknown visibility. Complain and treat it as public. */
{
default:
/* Unknown visibility. Complain and treat it as public. */
{
- complaint (&symfile_complaints,
- _("Unknown visibility `%c' for field"),
+ complaint (_("Unknown visibility `%c' for field"),
fip->list->visibility);
}
break;
fip->list->visibility);
}
break;
@@
-3404,12
+3380,12
@@
attach_fields_to_type (struct field_info *fip, struct type *type,
static void
complain_about_struct_wipeout (struct type *type)
{
static void
complain_about_struct_wipeout (struct type *type)
{
- char *name = "";
- char *kind = "";
+ c
onst c
har *name = "";
+ c
onst c
har *kind = "";
- if (TYPE_
TAG_
NAME (type))
+ if (TYPE_NAME (type))
{
{
- name = TYPE_
TAG_
NAME (type);
+ name = TYPE_NAME (type);
switch (TYPE_CODE (type))
{
case TYPE_CODE_STRUCT: kind = "struct "; break;
switch (TYPE_CODE (type))
{
case TYPE_CODE_STRUCT: kind = "struct "; break;
@@
-3418,19
+3394,13
@@
complain_about_struct_wipeout (struct type *type)
default: kind = "";
}
}
default: kind = "";
}
}
- else if (TYPE_NAME (type))
- {
- name = TYPE_NAME (type);
- kind = "";
- }
else
{
name = "<unknown>";
kind = "";
}
else
{
name = "<unknown>";
kind = "";
}
- complaint (&symfile_complaints,
- _("struct/union type gets multiply defined: %s%s"), kind, name);
+ complaint (_("struct/union type gets multiply defined: %s%s"), kind, name);
}
/* Set the length for all variants of a same main_type, which are
}
/* Set the length for all variants of a same main_type, which are
@@
-3474,7
+3444,7
@@
set_length_in_type_chain (struct type *type)
describing the type.
PP points to a character pointer that points to the next unconsumed token
describing the type.
PP points to a character pointer that points to the next unconsumed token
- in the
the
stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
+ in the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
*PP will point to "4a:1,0,32;;".
TYPE points to an incomplete type that needs to be filled in.
*PP will point to "4a:1,0,32;;".
TYPE points to an incomplete type that needs to be filled in.
@@
-3485,14
+3455,10
@@
set_length_in_type_chain (struct type *type)
*/
static struct type *
*/
static struct type *
-read_struct_type (char **pp, struct type *type, enum type_code type_code,
+read_struct_type (c
onst c
har **pp, struct type *type, enum type_code type_code,
struct objfile *objfile)
{
struct objfile *objfile)
{
- struct cleanup *back_to;
- struct field_info fi;
-
- fi.list = NULL;
- fi.fnlist = NULL;
+ struct stab_field_info fi;
/* When describing struct/union/class types in stabs, G++ always drops
all qualifications from the name. So if you've got:
/* When describing struct/union/class types in stabs, G++ always drops
all qualifications from the name. So if you've got:
@@
-3514,8
+3480,6
@@
read_struct_type (char **pp, struct type *type, enum type_code type_code,
return type;
}
return type;
}
- back_to = make_cleanup (null_cleanup, 0);
-
INIT_CPLUS_SPECIFIC (type);
TYPE_CODE (type) = type_code;
TYPE_STUB (type) = 0;
INIT_CPLUS_SPECIFIC (type);
TYPE_CODE (type) = type_code;
TYPE_STUB (type) = 0;
@@
-3546,7
+3510,6
@@
read_struct_type (char **pp, struct type *type, enum type_code type_code,
type = error_type (pp, objfile);
}
type = error_type (pp, objfile);
}
- do_cleanups (back_to);
return (type);
}
return (type);
}
@@
-3556,7
+3519,7
@@
read_struct_type (char **pp, struct type *type, enum type_code type_code,
array. */
static struct type *
array. */
static struct type *
-read_array_type (char **pp, struct type *type,
+read_array_type (c
onst c
har **pp, struct type *type,
struct objfile *objfile)
{
struct type *index_type, *element_type, *range_type;
struct objfile *objfile)
{
struct type *index_type, *element_type, *range_type;
@@
-3607,7
+3570,7
@@
read_array_type (char **pp, struct type *type,
}
range_type =
}
range_type =
- create_
range_type ((struct type *)
NULL, index_type, lower, upper);
+ create_
static_range_type (
NULL, index_type, lower, upper);
type = create_array_type (type, element_type, range_type);
return type;
type = create_array_type (type, element_type, range_type);
return type;
@@
-3619,11
+3582,11
@@
read_array_type (char **pp, struct type *type,
Also defines the symbols that represent the values of the type. */
static struct type *
Also defines the symbols that represent the values of the type. */
static struct type *
-read_enum_type (char **pp, struct type *type,
+read_enum_type (c
onst c
har **pp, struct type *type,
struct objfile *objfile)
{
struct gdbarch *gdbarch = get_objfile_arch (objfile);
struct objfile *objfile)
{
struct gdbarch *gdbarch = get_objfile_arch (objfile);
- char *p;
+ c
onst c
har *p;
char *name;
long n;
struct symbol *sym;
char *name;
long n;
struct symbol *sym;
@@
-3639,10
+3602,10
@@
read_enum_type (char **pp, struct type *type,
to be file-scope, between N_FN entries, using N_LSYM. What's a mother
to do? For now, force all enum values to file scope. */
if (within_function)
to be file-scope, between N_FN entries, using N_LSYM. What's a mother
to do? For now, force all enum values to file scope. */
if (within_function)
- symlist =
&local_symbols
;
+ symlist =
get_local_symbols ()
;
else
#endif
else
#endif
- symlist =
&file_symbols
;
+ symlist =
get_file_symbols ()
;
osyms = *symlist;
o_nsyms = osyms ? osyms->nsyms : 0;
osyms = *symlist;
o_nsyms = osyms ? osyms->nsyms : 0;
@@
-3667,18
+3630,17
@@
read_enum_type (char **pp, struct type *type,
p = *pp;
while (*p != ':')
p++;
p = *pp;
while (*p != ':')
p++;
- name = obs
avestring (*pp, p - *pp, &objfile->objfile_obstack
);
+ name = obs
tack_strndup (&objfile->objfile_obstack, *pp, p - *pp
);
*pp = p + 1;
n = read_huge_number (pp, ',', &nbits, 0);
if (nbits != 0)
return error_type (pp, objfile);
*pp = p + 1;
n = read_huge_number (pp, ',', &nbits, 0);
if (nbits != 0)
return error_type (pp, objfile);
- sym = (struct symbol *)
- obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol));
- memset (sym, 0, sizeof (struct symbol));
- SYMBOL_SET_LINKAGE_NAME (sym, name);
- SYMBOL_SET_LANGUAGE (sym, current_subfile->language);
- SYMBOL_CLASS (sym) = LOC_CONST;
+ sym = allocate_symbol (objfile);
+ sym->set_linkage_name (name);
+ sym->set_language (get_current_subfile ()->language,
+ &objfile->objfile_obstack);
+ SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_VALUE (sym) = n;
if (n < 0)
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_VALUE (sym) = n;
if (n < 0)
@@
-3721,8
+3683,8
@@
read_enum_type (char **pp, struct type *type,
struct symbol *xsym = syms->symbol[j];
SYMBOL_TYPE (xsym) = type;
struct symbol *xsym = syms->symbol[j];
SYMBOL_TYPE (xsym) = type;
- TYPE_FIELD_NAME (type, n) =
SYMBOL_LINKAGE_NAME (xsym
);
-
TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym
);
+ TYPE_FIELD_NAME (type, n) =
xsym->linkage_name (
);
+
SET_FIELD_ENUMVAL (TYPE_FIELD (type, n), SYMBOL_VALUE (xsym)
);
TYPE_FIELD_BITSIZE (type, n) = 0;
}
if (syms == osyms)
TYPE_FIELD_BITSIZE (type, n) = 0;
}
if (syms == osyms)
@@
-3746,20
+3708,20
@@
read_enum_type (char **pp, struct type *type,
FIXME. */
static struct type *
FIXME. */
static struct type *
-read_sun_builtin_type (char **pp, int typenums[2], struct objfile *objfile)
+read_sun_builtin_type (c
onst c
har **pp, int typenums[2], struct objfile *objfile)
{
int type_bits;
int nbits;
{
int type_bits;
int nbits;
- int signed_type;
-
enum type_code code = TYPE_CODE_INT
;
+ int
un
signed_type;
+
int boolean_type = 0
;
switch (**pp)
{
case 's':
switch (**pp)
{
case 's':
-
signed_type = 1
;
+
unsigned_type = 0
;
break;
case 'u':
break;
case 'u':
-
signed_type = 0
;
+
unsigned_type = 1
;
break;
default:
return error_type (pp, objfile);
break;
default:
return error_type (pp, objfile);
@@
-3776,7
+3738,7
@@
read_sun_builtin_type (char **pp, int typenums[2], struct objfile *objfile)
(*pp)++;
else if (**pp == 'b')
{
(*pp)++;
else if (**pp == 'b')
{
-
code = TYPE_CODE_BOOL
;
+
boolean_type = 1
;
(*pp)++;
}
(*pp)++;
}
@@
-3788,12
+3750,12
@@
read_sun_builtin_type (char **pp, int typenums[2], struct objfile *objfile)
if (nbits != 0)
return error_type (pp, objfile);
if (nbits != 0)
return error_type (pp, objfile);
- /* The second number is always 0, so ignore it too. */
+ /* The second number is always 0, so ignore it too.
*/
read_huge_number (pp, ';', &nbits, 0);
if (nbits != 0)
return error_type (pp, objfile);
read_huge_number (pp, ';', &nbits, 0);
if (nbits != 0)
return error_type (pp, objfile);
- /* The third number is the number of bits for this type. */
+ /* The third number is the number of bits for this type.
*/
type_bits = read_huge_number (pp, 0, &nbits, 0);
if (nbits != 0)
return error_type (pp, objfile);
type_bits = read_huge_number (pp, 0, &nbits, 0);
if (nbits != 0)
return error_type (pp, objfile);
@@
-3807,18
+3769,23
@@
read_sun_builtin_type (char **pp, int typenums[2], struct objfile *objfile)
++(*pp);
if (type_bits == 0)
++(*pp);
if (type_bits == 0)
- return init_type (TYPE_CODE_VOID, 1,
- signed_type ? 0 : TYPE_FLAG_UNSIGNED, (char *) NULL,
- objfile);
+ {
+ struct type *type = init_type (objfile, TYPE_CODE_VOID,
+ TARGET_CHAR_BIT, NULL);
+ if (unsigned_type)
+ TYPE_UNSIGNED (type) = 1;
+ return type;
+ }
+
+ if (boolean_type)
+ return init_boolean_type (objfile, type_bits, unsigned_type, NULL);
else
else
- return init_type (code,
- type_bits / TARGET_CHAR_BIT,
- signed_type ? 0 : TYPE_FLAG_UNSIGNED, (char *) NULL,
- objfile);
+ return init_integer_type (objfile, type_bits, unsigned_type, NULL);
}
static struct type *
}
static struct type *
-read_sun_floating_type (char **pp, int typenums[2], struct objfile *objfile)
+read_sun_floating_type (const char **pp, int typenums[2],
+ struct objfile *objfile)
{
int nbits;
int details;
{
int nbits;
int details;
@@
-3831,21
+3798,21
@@
read_sun_floating_type (char **pp, int typenums[2], struct objfile *objfile)
if (nbits != 0)
return error_type (pp, objfile);
if (nbits != 0)
return error_type (pp, objfile);
- /* The second number is the number of bytes occupied by this type */
+ /* The second number is the number of bytes occupied by this type
.
*/
nbytes = read_huge_number (pp, ';', &nbits, 0);
if (nbits != 0)
return error_type (pp, objfile);
nbytes = read_huge_number (pp, ';', &nbits, 0);
if (nbits != 0)
return error_type (pp, objfile);
+ nbits = nbytes * TARGET_CHAR_BIT;
+
if (details == NF_COMPLEX || details == NF_COMPLEX16
|| details == NF_COMPLEX32)
{
if (details == NF_COMPLEX || details == NF_COMPLEX16
|| details == NF_COMPLEX32)
{
- rettype = init_type (TYPE_CODE_COMPLEX, nbytes, 0, NULL, objfile);
- TYPE_TARGET_TYPE (rettype)
- = init_type (TYPE_CODE_FLT, nbytes / 2, 0, NULL, objfile);
- return rettype;
+ rettype = dbx_init_float_type (objfile, nbits / 2);
+ return init_complex_type (objfile, NULL, rettype);
}
}
- return
init_type (TYPE_CODE_FLT, nbytes, 0, NULL, objfile
);
+ return
dbx_init_float_type (objfile, nbits
);
}
/* Read a number from the string pointed to by *PP.
}
/* Read a number from the string pointed to by *PP.
@@
-3866,9
+3833,10
@@
read_sun_floating_type (char **pp, int typenums[2], struct objfile *objfile)
If encounter garbage, set *BITS to -1 and return 0. */
static long
If encounter garbage, set *BITS to -1 and return 0. */
static long
-read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
+read_huge_number (const char **pp, int end, int *bits,
+ int twos_complement_bits)
{
{
- char *p = *pp;
+ c
onst c
har *p = *pp;
int sign = 1;
int sign_bit = 0;
long n = 0;
int sign = 1;
int sign_bit = 0;
long n = 0;
@@
-3903,7
+3871,7
@@
read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
negative number. */
size_t len;
negative number. */
size_t len;
- char *p1 = p;
+ c
onst c
har *p1 = p;
while ((c = *p1) >= '0' && c < '8')
p1++;
while ((c = *p1) >= '0' && c < '8')
p1++;
@@
-3914,7
+3882,7
@@
read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
&& len == twos_complement_bits / 3))
{
/* Ok, we have enough characters for a signed value, check
&& len == twos_complement_bits / 3))
{
/* Ok, we have enough characters for a signed value, check
- for signness by testing if the sign bit is set. */
+ for sign
ed
ness by testing if the sign bit is set. */
sign_bit = (twos_complement_bits % 3 + 2) % 3;
c = *p - '0';
if (c & (1 << sign_bit))
sign_bit = (twos_complement_bits % 3 + 2) % 3;
c = *p - '0';
if (c & (1 << sign_bit))
@@
-3952,14
+3920,14
@@
read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
{
/* unsigned representation */
n *= radix;
{
/* unsigned representation */
n *= radix;
- n += c - '0'; /* FIXME this overflows anyway */
+ n += c - '0'; /* FIXME this overflows anyway
.
*/
}
}
else
overflow = 1;
/* This depends on large values being output in octal, which is
}
}
else
overflow = 1;
/* This depends on large values being output in octal, which is
- what GCC does. */
+ what GCC does.
*/
if (radix == 8)
{
if (nbits == 0)
if (radix == 8)
{
if (nbits == 0)
@@
-4030,11
+3998,11
@@
read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
}
static struct type *
}
static struct type *
-read_range_type (char **pp, int typenums[2], int type_size,
+read_range_type (c
onst c
har **pp, int typenums[2], int type_size,
struct objfile *objfile)
{
struct gdbarch *gdbarch = get_objfile_arch (objfile);
struct objfile *objfile)
{
struct gdbarch *gdbarch = get_objfile_arch (objfile);
- char *orig_pp = *pp;
+ c
onst c
har *orig_pp = *pp;
int rangenums[2];
long n2, n3;
int n2bits, n3bits;
int rangenums[2];
long n2, n3;
int n2bits, n3bits;
@@
-4079,7
+4047,7
@@
read_range_type (char **pp, int typenums[2], int type_size,
int nbits = 0;
/* If a type size attribute has been specified, the bounds of
int nbits = 0;
/* If a type size attribute has been specified, the bounds of
- the range should fit in this size. If the lower bounds needs
+ the range should fit in this size.
If the lower bounds needs
more bits than the upper bound, then the type is signed. */
if (n2bits <= type_size && n3bits <= type_size)
{
more bits than the upper bound, then the type is signed. */
if (n2bits <= type_size && n3bits <= type_size)
{
@@
-4108,18
+4076,14
@@
read_range_type (char **pp, int typenums[2], int type_size,
}
if (got_signed || got_unsigned)
}
if (got_signed || got_unsigned)
- {
- return init_type (TYPE_CODE_INT, nbits / TARGET_CHAR_BIT,
- got_unsigned ? TYPE_FLAG_UNSIGNED : 0, NULL,
- objfile);
- }
+ return init_integer_type (objfile, nbits, got_unsigned, NULL);
else
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)
else
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
);
+ return init_type (
objfile, TYPE_CODE_VOID, TARGET_CHAR_BIT, NULL
);
/* If n3 is zero and n2 is positive, we want a floating type, and n2
is the width in bytes.
/* If n3 is zero and n2 is positive, we want a floating type, and n2
is the width in bytes.
@@
-4131,21
+4095,15
@@
read_range_type (char **pp, int typenums[2], int type_size,
Also note that for complexes, g77 sets n2 to the size of one of
the member floats, not the whole complex beast. My guess is that
Also note that for complexes, g77 sets n2 to the size of one of
the member floats, not the whole complex beast. My guess is that
- this was to work well with pre-COMPLEX versions of gdb. */
+ this was to work well with pre-COMPLEX versions of gdb.
*/
if (n3 == 0 && n2 > 0)
{
struct type *float_type
if (n3 == 0 && n2 > 0)
{
struct type *float_type
- =
init_type (TYPE_CODE_FLT, n2, 0, NULL, objfile
);
+ =
dbx_init_float_type (objfile, n2 * TARGET_CHAR_BIT
);
if (self_subrange)
if (self_subrange)
- {
- struct type *complex_type =
- init_type (TYPE_CODE_COMPLEX, 2 * n2, 0, NULL, objfile);
-
- TYPE_TARGET_TYPE (complex_type) = float_type;
- return complex_type;
- }
+ return init_complex_type (objfile, NULL, float_type);
else
return float_type;
}
else
return float_type;
}
@@
-4164,15
+4122,18
@@
read_range_type (char **pp, int typenums[2], int type_size,
bits = gdbarch_int_bit (gdbarch);
}
bits = gdbarch_int_bit (gdbarch);
}
- return init_type (TYPE_CODE_INT, bits / TARGET_CHAR_BIT,
- TYPE_FLAG_UNSIGNED, NULL, objfile);
+ return init_integer_type (objfile, bits, 1, NULL);
}
/* 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)
}
/* 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, TYPE_FLAG_NOSIGN, NULL, objfile);
-
+ {
+ struct type *type = init_integer_type (objfile, TARGET_CHAR_BIT,
+ 0, NULL);
+ TYPE_NOSIGN (type) = 1;
+ return type;
+ }
/* We used to do this only for subrange of self or subrange of int. */
else if (n2 == 0)
{
/* We used to do this only for subrange of self or subrange of int. */
else if (n2 == 0)
{
@@
-4182,8
+4143,7
@@
read_range_type (char **pp, int typenums[2], int type_size,
if (n3 < 0)
/* n3 actually gives the size. */
if (n3 < 0)
/* n3 actually gives the size. */
- return init_type (TYPE_CODE_INT, -n3, TYPE_FLAG_UNSIGNED,
- NULL, objfile);
+ return init_integer_type (objfile, -n3 * TARGET_CHAR_BIT, 1, NULL);
/* Is n3 == 2**(8n)-1 for some integer n? Then it's an
unsigned n-byte integer. But do require n to be a power of
/* Is n3 == 2**(8n)-1 for some integer n? Then it's an
unsigned n-byte integer. But do require n to be a power of
@@
-4197,8
+4157,7
@@
read_range_type (char **pp, int typenums[2], int type_size,
bits >>= 8;
if (bits == 0
&& ((bytes - 1) & bytes) == 0) /* "bytes is a power of two" */
bits >>= 8;
if (bits == 0
&& ((bytes - 1) & bytes) == 0) /* "bytes is a power of two" */
- return init_type (TYPE_CODE_INT, bytes, TYPE_FLAG_UNSIGNED, NULL,
- objfile);
+ return init_integer_type (objfile, bytes * TARGET_CHAR_BIT, 1, NULL);
}
}
/* I think this is for Convex "long long". Since I don't know whether
}
}
/* I think this is for Convex "long long". Since I don't know whether
@@
-4208,15
+4167,15
@@
read_range_type (char **pp, int typenums[2], int type_size,
&& (self_subrange
|| n2 == -gdbarch_long_long_bit
(gdbarch) / TARGET_CHAR_BIT))
&& (self_subrange
|| n2 == -gdbarch_long_long_bit
(gdbarch) / TARGET_CHAR_BIT))
- return init_
type (TYPE_CODE_INT, -n2, 0, NULL, objfile
);
+ return init_
integer_type (objfile, -n2 * TARGET_CHAR_BIT, 0, NULL
);
else if (n2 == -n3 - 1)
{
if (n3 == 0x7f)
else if (n2 == -n3 - 1)
{
if (n3 == 0x7f)
- return init_
type (TYPE_CODE_INT, 1, 0, NULL, objfile
);
+ return init_
integer_type (objfile, 8, 0, NULL
);
if (n3 == 0x7fff)
if (n3 == 0x7fff)
- return init_
type (TYPE_CODE_INT, 2, 0, NULL, objfile
);
+ return init_
integer_type (objfile, 16, 0, NULL
);
if (n3 == 0x7fffffff)
if (n3 == 0x7fffffff)
- return init_
type (TYPE_CODE_INT, 4, 0, NULL, objfile
);
+ return init_
integer_type (objfile, 32, 0, NULL
);
}
/* We have a real range type on our hands. Allocate space and
}
/* We have a real range type on our hands. Allocate space and
@@
-4232,13
+4191,13
@@
handle_true_range:
/* Does this actually ever happen? Is that why we are worrying
about dealing with it rather than just calling error_type? */
/* Does this actually ever happen? Is that why we are worrying
about dealing with it rather than just calling error_type? */
- complaint (&symfile_complaints,
- _("base type %d of range type is not defined"), rangenums[1]);
+ complaint (_("base type %d of range type is not defined"), rangenums[1]);
index_type = objfile_type (objfile)->builtin_int;
}
index_type = objfile_type (objfile)->builtin_int;
}
- result_type = create_range_type ((struct type *) NULL, index_type, n2, n3);
+ result_type
+ = create_static_range_type (NULL, index_type, n2, n3);
return (result_type);
}
return (result_type);
}
@@
-4247,11
+4206,11
@@
handle_true_range:
if there is an error. */
static struct field *
if there is an error. */
static struct field *
-read_args (char **pp, int end, struct objfile *objfile, int *nargsp,
+read_args (c
onst c
har **pp, int end, struct objfile *objfile, int *nargsp,
int *varargsp)
{
/* FIXME! Remove this arbitrary limit! */
int *varargsp)
{
/* FIXME! Remove this arbitrary limit! */
- struct type *types[1024]; /*
allow for fns of 1023 parameters
*/
+ struct type *types[1024]; /*
Allow for fns of 1023 parameters.
*/
int n = 0, i;
struct field *rval;
int n = 0, i;
struct field *rval;
@@
-4264,7
+4223,7
@@
read_args (char **pp, int end, struct objfile *objfile, int *nargsp,
STABS_CONTINUE (pp, objfile);
types[n++] = read_type (pp, objfile);
}
STABS_CONTINUE (pp, objfile);
types[n++] = read_type (pp, objfile);
}
- (*pp)++; /* get past `end' (the ':' character) */
+ (*pp)++; /* get past `end' (the ':' character)
.
*/
if (n == 0)
{
if (n == 0)
{
@@
-4273,7
+4232,7
@@
read_args (char **pp, int end, struct objfile *objfile, int *nargsp,
have been present ";-16,(0,43)" reference instead. This way the
excessive ";" marker prematurely stops the parameters parsing. */
have been present ";-16,(0,43)" reference instead. This way the
excessive ";" marker prematurely stops the parameters parsing. */
- complaint (
&symfile_complaints,
_("Invalid (empty) method arguments"));
+ complaint (_("Invalid (empty) method arguments"));
*varargsp = 0;
}
else if (TYPE_CODE (types[n - 1]) != TYPE_CODE_VOID)
*varargsp = 0;
}
else if (TYPE_CODE (types[n - 1]) != TYPE_CODE_VOID)
@@
-4284,8
+4243,7
@@
read_args (char **pp, int end, struct objfile *objfile, int *nargsp,
*varargsp = 0;
}
*varargsp = 0;
}
- rval = (struct field *) xmalloc (n * sizeof (struct field));
- memset (rval, 0, n * sizeof (struct field));
+ rval = XCNEWVEC (struct field, n);
for (i = 0; i < n; i++)
rval[i].type = types[i];
*nargsp = n;
for (i = 0; i < n; i++)
rval[i].type = types[i];
*nargsp = n;
@@
-4312,17
+4270,15
@@
static char *common_block_name;
to remain after this function returns. */
void
to remain after this function returns. */
void
-common_block_start (char *name, struct objfile *objfile)
+common_block_start (c
onst c
har *name, struct objfile *objfile)
{
if (common_block_name != NULL)
{
{
if (common_block_name != NULL)
{
- complaint (&symfile_complaints,
- _("Invalid symbol data: common block within common block"));
+ complaint (_("Invalid symbol data: common block within common block"));
}
}
- common_block = local_symbols;
- common_block_i = local_symbols ? local_symbols->nsyms : 0;
- common_block_name = obsavestring (name, strlen (name),
- &objfile->objfile_obstack);
+ common_block = *get_local_symbols ();
+ common_block_i = common_block ? common_block->nsyms : 0;
+ common_block_name = obstack_strdup (&objfile->objfile_obstack, name);
}
/* Process a N_ECOMM symbol. */
}
/* Process a N_ECOMM symbol. */
@@
-4337,32
+4293,30
@@
common_block_end (struct objfile *objfile)
symbol for the common block name for later fixup. */
int i;
struct symbol *sym;
symbol for the common block name for later fixup. */
int i;
struct symbol *sym;
- struct pending *new = 0;
+ struct pending *new
obj
= 0;
struct pending *next;
int j;
if (common_block_name == NULL)
{
struct pending *next;
int j;
if (common_block_name == NULL)
{
- complaint (
&symfile_complaints,
_("ECOMM symbol unmatched by BCOMM"));
+ complaint (_("ECOMM symbol unmatched by BCOMM"));
return;
}
return;
}
- sym = (struct symbol *)
- obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol));
- memset (sym, 0, sizeof (struct symbol));
- /* Note: common_block_name already saved on objfile_obstack */
- SYMBOL_SET_LINKAGE_NAME (sym, common_block_name);
- SYMBOL_CLASS (sym) = LOC_BLOCK;
+ sym = allocate_symbol (objfile);
+ /* Note: common_block_name already saved on objfile_obstack. */
+ sym->set_linkage_name (common_block_name);
+ SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
/* Now we copy all the symbols which have been defined since the BCOMM. */
/* Copy all the struct pendings before common_block. */
/* Now we copy all the symbols which have been defined since the BCOMM. */
/* Copy all the struct pendings before common_block. */
- for (next =
local_symbols
;
+ for (next =
*get_local_symbols ()
;
next != NULL && next != common_block;
next = next->next)
{
for (j = 0; j < next->nsyms; j++)
next != NULL && next != common_block;
next = next->next)
{
for (j = 0; j < next->nsyms; j++)
- add_symbol_to_list (next->symbol[j], &new);
+ add_symbol_to_list (next->symbol[j], &new
obj
);
}
/* Copy however much of COMMON_BLOCK we need. If COMMON_BLOCK is
}
/* Copy however much of COMMON_BLOCK we need. If COMMON_BLOCK is
@@
-4371,14
+4325,14
@@
common_block_end (struct objfile *objfile)
if (common_block != NULL)
for (j = common_block_i; j < common_block->nsyms; j++)
if (common_block != NULL)
for (j = common_block_i; j < common_block->nsyms; j++)
- add_symbol_to_list (common_block->symbol[j], &new);
+ add_symbol_to_list (common_block->symbol[j], &new
obj
);
- SYMBOL_TYPE (sym) = (struct type *) new;
+ SYMBOL_TYPE (sym) = (struct type *) new
obj
;
/* Should we be putting local_symbols back to what it was?
Does it matter? */
/* Should we be putting local_symbols back to what it was?
Does it matter? */
- i = hashname (
SYMBOL_LINKAGE_NAME (sym
));
+ i = hashname (
sym->linkage_name (
));
SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
global_sym_chain[i] = sym;
common_block_name = NULL;
SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
global_sym_chain[i] = sym;
common_block_name = NULL;
@@
-4389,7
+4343,7
@@
common_block_end (struct objfile *objfile)
the common block name). */
static void
the common block name). */
static void
-fix_common_block (struct symbol *sym,
int
valu)
+fix_common_block (struct symbol *sym,
CORE_ADDR
valu)
{
struct pending *next = (struct pending *) SYMBOL_TYPE (sym);
{
struct pending *next = (struct pending *) SYMBOL_TYPE (sym);
@@
-4398,7
+4352,9
@@
fix_common_block (struct symbol *sym, int valu)
int j;
for (j = next->nsyms - 1; j >= 0; j--)
int j;
for (j = next->nsyms - 1; j >= 0; j--)
- SYMBOL_VALUE_ADDRESS (next->symbol[j]) += valu;
+ SET_SYMBOL_VALUE_ADDRESS (next->symbol[j],
+ SYMBOL_VALUE_ADDRESS (next->symbol[j])
+ + valu);
}
}
\f
}
}
\f
@@
-4458,7
+4414,7
@@
add_undefined_type_1 (struct type *type)
static void
add_undefined_type (struct type *type, int typenums[2])
{
static void
add_undefined_type (struct type *type, int typenums[2])
{
- if (TYPE_
TAG_
NAME (type) == NULL)
+ if (TYPE_NAME (type) == NULL)
add_undefined_type_noname (type, typenums);
else
add_undefined_type_1 (type);
add_undefined_type_noname (type, typenums);
else
add_undefined_type_1 (type);
@@
-4542,15
+4498,15
@@
cleanup_undefined_types_1 (void)
{
struct pending *ppt;
int i;
{
struct pending *ppt;
int i;
- /* Name of the type, without "struct" or "union" */
- c
har *typename = TYPE_TAG
_NAME (*type);
+ /* Name of the type, without "struct" or "union"
.
*/
+ c
onst char *type_name = TYPE
_NAME (*type);
- if (typename == NULL)
+ if (type
_
name == NULL)
{
{
- complaint (
&symfile_complaints,
_("need a type name"));
+ complaint (_("need a type name"));
break;
}
break;
}
- for (ppt =
file_symbols
; ppt; ppt = ppt->next)
+ for (ppt =
*get_file_symbols ()
; ppt; ppt = ppt->next)
{
for (i = 0; i < ppt->nsyms; i++)
{
{
for (i = 0; i < ppt->nsyms; i++)
{
@@
-4562,8
+4518,7
@@
cleanup_undefined_types_1 (void)
TYPE_CODE (*type))
&& (TYPE_INSTANCE_FLAGS (*type) ==
TYPE_INSTANCE_FLAGS (SYMBOL_TYPE (sym)))
TYPE_CODE (*type))
&& (TYPE_INSTANCE_FLAGS (*type) ==
TYPE_INSTANCE_FLAGS (SYMBOL_TYPE (sym)))
- && strcmp (SYMBOL_LINKAGE_NAME (sym),
- typename) == 0)
+ && strcmp (sym->linkage_name (), type_name) == 0)
replace_type (*type, SYMBOL_TYPE (sym));
}
}
replace_type (*type, SYMBOL_TYPE (sym));
}
}
@@
-4573,8
+4528,7
@@
cleanup_undefined_types_1 (void)
default:
{
default:
{
- complaint (&symfile_complaints,
- _("forward-referenced types left unresolved, "
+ complaint (_("forward-referenced types left unresolved, "
"type code %d."),
TYPE_CODE (*type));
}
"type code %d."),
TYPE_CODE (*type));
}
@@
-4585,25
+4539,22
@@
cleanup_undefined_types_1 (void)
undef_types_length = 0;
}
undef_types_length = 0;
}
-/* Try to fix all the undefined types we ecountered while processing
+/* Try to fix all the undefined types we e
n
countered while processing
this unit. */
void
this unit. */
void
-cleanup_undefined_types (struct objfile *objfile)
+cleanup_undefined_
stabs_
types (struct objfile *objfile)
{
cleanup_undefined_types_1 ();
cleanup_undefined_types_noname (objfile);
}
{
cleanup_undefined_types_1 ();
cleanup_undefined_types_noname (objfile);
}
-/* 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. */
+/* See stabsread.h. */
void
scan_file_globals (struct objfile *objfile)
{
int hash;
void
scan_file_globals (struct objfile *objfile)
{
int hash;
- struct minimal_symbol *msymbol;
struct symbol *sym, *prev;
struct objfile *resolve_objfile;
struct symbol *sym, *prev;
struct objfile *resolve_objfile;
@@
-4629,7
+4580,7
@@
scan_file_globals (struct objfile *objfile)
if (hash >= HASHSIZE)
return;
if (hash >= HASHSIZE)
return;
-
ALL_OBJFILE_MSYMBOLS (resolve_objfile, msymbol
)
+
for (minimal_symbol *msymbol : resolve_objfile->msymbols ()
)
{
QUIT;
{
QUIT;
@@
-4647,17
+4598,16
@@
scan_file_globals (struct objfile *objfile)
prev = NULL;
/* Get the hash index and check all the symbols
prev = NULL;
/* Get the hash index and check all the symbols
- under that hash index. */
+ under that hash index.
*/
- hash = hashname (
SYMBOL_LINKAGE_NAME (msymbol
));
+ hash = hashname (
msymbol->linkage_name (
));
for (sym = global_sym_chain[hash]; sym;)
{
for (sym = global_sym_chain[hash]; sym;)
{
- if (strcmp (SYMBOL_LINKAGE_NAME (msymbol),
- SYMBOL_LINKAGE_NAME (sym)) == 0)
+ if (strcmp (msymbol->linkage_name (), sym->linkage_name ()) == 0)
{
/* Splice this symbol out of the hash chain and
{
/* Splice this symbol out of the hash chain and
- assign the value we have to it. */
+ assign the value we have to it.
*/
if (prev)
{
SYMBOL_VALUE_CHAIN (prev) = SYMBOL_VALUE_CHAIN (sym);
if (prev)
{
SYMBOL_VALUE_CHAIN (prev) = SYMBOL_VALUE_CHAIN (sym);
@@
-4675,14
+4625,16
@@
scan_file_globals (struct objfile *objfile)
if (SYMBOL_CLASS (sym) == LOC_BLOCK)
{
fix_common_block (sym,
if (SYMBOL_CLASS (sym) == LOC_BLOCK)
{
fix_common_block (sym,
- SYMBOL_VALUE_ADDRESS (msymbol));
+ MSYMBOL_VALUE_ADDRESS (resolve_objfile,
+ msymbol));
}
else
{
}
else
{
- SYMBOL_VALUE_ADDRESS (sym)
- = SYMBOL_VALUE_ADDRESS (msymbol);
+ SET_SYMBOL_VALUE_ADDRESS
+ (sym, MSYMBOL_VALUE_ADDRESS (resolve_objfile,
+ msymbol));
}
}
- SYMBOL_SECTION (sym) = SYMBOL_SECTION (msymbol);
+ SYMBOL_SECTION (sym) =
M
SYMBOL_SECTION (msymbol);
}
if (prev)
}
if (prev)
@@
-4718,16
+4670,15
@@
scan_file_globals (struct objfile *objfile)
/* Change the symbol address from the misleading chain value
to address zero. */
/* Change the symbol address from the misleading chain value
to address zero. */
- S
YMBOL_VALUE_ADDRESS (prev) = 0
;
+ S
ET_SYMBOL_VALUE_ADDRESS (prev, 0)
;
/* Complain about unresolved common block symbols. */
if (SYMBOL_CLASS (prev) == LOC_STATIC)
/* Complain about unresolved common block symbols. */
if (SYMBOL_CLASS (prev) == LOC_STATIC)
- SYMBOL_
CLASS
(prev) = LOC_UNRESOLVED;
+ SYMBOL_
ACLASS_INDEX
(prev) = LOC_UNRESOLVED;
else
else
- complaint (&symfile_complaints,
- _("%s: common block `%s' from "
+ complaint (_("%s: common block `%s' from "
"global_sym_chain unresolved"),
"global_sym_chain unresolved"),
- objfile
->name, SYMBOL_PRINT_NAME (prev
));
+ objfile
_name (objfile), prev->print_name (
));
}
}
memset (global_sym_chain, 0, sizeof (global_sym_chain));
}
}
memset (global_sym_chain, 0, sizeof (global_sym_chain));
@@
-4754,7
+4705,7
@@
stabsread_new_init (void)
}
/* Initialize anything that needs initializing at the same time as
}
/* Initialize anything that needs initializing at the same time as
- start_symtab() is called. */
+ start_symtab() is called.
*/
void
start_stabs (void)
void
start_stabs (void)
@@
-4764,12
+4715,13
@@
start_stabs (void)
n_this_object_header_files = 1;
type_vector_length = 0;
type_vector = (struct type **) 0;
n_this_object_header_files = 1;
type_vector_length = 0;
type_vector = (struct type **) 0;
+ within_function = 0;
/* FIXME: If common_block_name is not already NULL, we should complain(). */
common_block_name = NULL;
}
/* FIXME: If common_block_name is not already NULL, we should complain(). */
common_block_name = NULL;
}
-/* Call after end_symtab() */
+/* Call after end_symtab()
.
*/
void
end_stabs (void)
void
end_stabs (void)
@@
-4788,7
+4740,7
@@
finish_global_stabs (struct objfile *objfile)
{
if (global_stabs)
{
{
if (global_stabs)
{
- patch_block_stabs (
global_symbols
, global_stabs, objfile);
+ patch_block_stabs (
*get_global_symbols ()
, global_stabs, objfile);
xfree (global_stabs);
global_stabs = NULL;
}
xfree (global_stabs);
global_stabs = NULL;
}
@@
-4796,10
+4748,10
@@
finish_global_stabs (struct objfile *objfile)
/* Find the end of the name, delimited by a ':', but don't match
ObjC symbols which look like -[Foo bar::]:bla. */
/* Find the end of the name, delimited by a ':', but don't match
ObjC symbols which look like -[Foo bar::]:bla. */
-static char *
-find_name_end (char *name)
+static c
onst c
har *
+find_name_end (c
onst c
har *name)
{
{
- char *s = name;
+ c
onst c
har *s = name;
if (s[0] == '-' || *s == '+')
{
if (s[0] == '-' || *s == '+')
{
@@
-4821,20
+4773,29
@@
find_name_end (char *name)
}
}
}
}
-/* Initializer for this module */
+/* See stabsread.h. */
+
+int
+hashname (const char *name)
+{
+ return fast_hash (name, strlen (name)) % HASHSIZE;
+}
+
+/* Initializer for this module. */
void
_initialize_stabsread (void)
{
void
_initialize_stabsread (void)
{
- rs6000_builtin_type_data = register_objfile_data ();
-
undef_types_allocated = 20;
undef_types_length = 0;
undef_types_allocated = 20;
undef_types_length = 0;
- undef_types = (struct type **)
- xmalloc (undef_types_allocated * sizeof (struct type *));
+ undef_types = XNEWVEC (struct type *, undef_types_allocated);
noname_undefs_allocated = 20;
noname_undefs_length = 0;
noname_undefs_allocated = 20;
noname_undefs_length = 0;
- noname_undefs = (struct nat *)
- xmalloc (noname_undefs_allocated * sizeof (struct nat));
+ noname_undefs = XNEWVEC (struct nat, noname_undefs_allocated);
+
+ stab_register_index = register_symbol_register_impl (LOC_REGISTER,
+ &stab_register_funcs);
+ stab_regparm_index = register_symbol_register_impl (LOC_REGPARM_ADDR,
+ &stab_register_funcs);
}
}
This page took
0.076461 seconds
and
4
git commands to generate.