X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;ds=sidebyside;f=gdb%2Fstabsread.c;h=a56702aa1d2386d177fdee2d1687f86bf4cb5940;hb=8727de56b0dbe25b7b4a3bd04f72ac41992463ed;hp=678b3cfc0823b1dd94be8fec3cbc5d2a6efe7d58;hpb=6aef78af044573aa92d16b989b73a959cb97773f;p=deliverable%2Fbinutils-gdb.git
diff --git a/gdb/stabsread.c b/gdb/stabsread.c
index 678b3cfc08..a56702aa1d 100644
--- a/gdb/stabsread.c
+++ b/gdb/stabsread.c
@@ -1,14 +1,12 @@
/* 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
- Free Software Foundation, Inc.
+ Copyright (C) 1986-2018 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
@@ -17,18 +15,16 @@
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see . */
/* 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 "gdb_string.h"
#include "bfd.h"
#include "gdb_obstack.h"
#include "symtab.h"
@@ -36,18 +32,18 @@
#include "expression.h"
#include "symfile.h"
#include "objfiles.h"
-#include "aout/stab_gnu.h" /* We always use GNU stabs, not native */
+#include "aout/stab_gnu.h" /* We always use GNU stabs, not native. */
#include "libaout.h"
#include "aout/aout64.h"
#include "gdb-stabs.h"
#include "buildsym.h"
#include "complaints.h"
#include "demangle.h"
+#include "gdb-demangle.h"
#include "language.h"
-#include "doublest.h"
+#include "target-float.h"
#include "cp-abi.h"
#include "cp-support.h"
-
#include
/* Ask stabsread.h to define the vars it normally declares `extern'. */
@@ -56,81 +52,83 @@
#include "stabsread.h" /* Our own declarations */
#undef EXTERN
-extern void _initialize_stabsread (void);
+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 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
- expected to eventually go away... (FIXME) */
+ expected to eventually go away... (FIXME) */
struct 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 field field;
- }
- *list;
- struct next_fnfieldlist
- {
- struct next_fnfieldlist *next;
- struct fn_fieldlist fn_fieldlist;
- }
- *fnlist;
+ struct nextfield *list;
+ struct next_fnfieldlist *fnlist;
};
static void
-read_one_struct_field (struct field_info *, char **, char *,
+read_one_struct_field (struct field_info *, const char **, const char *,
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 (const char **, int, int *, int);
-static struct type *error_type (char **, struct objfile *);
+static struct type *error_type (const char **, 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 (const char **, int *);
-static struct type *read_type (char **, struct objfile *);
+static struct type *read_type (const char **, 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 (const char **, int[2],
struct objfile *);
-static struct type *read_enum_type (char **, struct type *, struct objfile *);
+static struct type *read_enum_type (const char **, struct type *, struct objfile *);
-static struct type *rs6000_builtin_type (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 field_info *, const char **, struct type *,
struct objfile *);
static int
-read_struct_fields (struct field_info *, char **, struct type *,
+read_struct_fields (struct field_info *, const char **, struct type *,
struct objfile *);
static int
-read_baseclasses (struct field_info *, char **, struct type *,
+read_baseclasses (struct field_info *, const char **, struct type *,
struct objfile *);
static int
-read_tilde_fields (struct field_info *, char **, struct type *,
+read_tilde_fields (struct field_info *, const char **, struct type *,
struct objfile *);
static int attach_fn_fields_to_type (struct field_info *, struct type *);
@@ -138,24 +136,25 @@ static int attach_fn_fields_to_type (struct field_info *, struct type *);
static int attach_fields_to_type (struct field_info *, struct type *,
struct objfile *);
-static struct type *read_struct_type (char **, struct type *,
+static struct type *read_struct_type (const char **, struct type *,
enum type_code,
struct objfile *);
-static struct type *read_array_type (char **, struct type *,
+static struct type *read_array_type (const char **, struct type *,
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
-read_cpp_abbrev (struct field_info *, char **, struct type *,
+read_cpp_abbrev (struct field_info *, const char **, struct type *,
struct objfile *);
-static char *find_name_end (char *name);
+static const char *find_name_end (const char *name);
-static int process_reference (char **string);
+static int process_reference (const char **string);
void stabsread_clear_cache (void);
@@ -172,7 +171,7 @@ 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"),
+ _("bad register number %d (max %d) in symbol %s"),
regnum, num_regs - 1, sym);
}
@@ -191,7 +190,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
- 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
@@ -209,6 +208,23 @@ static int noname_undefs_length;
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
/* Look up a dbx type-number pair. Return the address of the slot
@@ -219,7 +235,7 @@ static int noname_undefs_length;
or for associating a new type with the pair. */
static struct type **
-dbx_lookup_type (int typenums[2])
+dbx_lookup_type (int typenums[2], struct objfile *objfile)
{
int filenum = typenums[0];
int index = typenums[1];
@@ -234,7 +250,8 @@ dbx_lookup_type (int typenums[2])
if (filenum < 0 || filenum >= n_this_object_header_files)
{
complaint (&symfile_complaints,
- _("Invalid symbol data: type number (%d,%d) out of range at symtab pos %d."),
+ _("Invalid symbol data: type number "
+ "(%d,%d) out of range at symtab pos %d."),
filenum, index, symnum);
goto error_return;
}
@@ -250,7 +267,7 @@ dbx_lookup_type (int typenums[2])
this will do the right thing. */
static struct type *temp_type;
- temp_type = rs6000_builtin_type (index);
+ temp_type = rs6000_builtin_type (index, objfile);
return &temp_type;
}
@@ -262,8 +279,7 @@ dbx_lookup_type (int typenums[2])
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)
{
@@ -281,21 +297,18 @@ dbx_lookup_type (int typenums[2])
{
real_filenum = this_object_header_files[filenum];
- if (real_filenum >= N_HEADER_FILES (current_objfile))
+ if (real_filenum >= N_HEADER_FILES (objfile))
{
- struct type *temp_type;
- struct type **temp_type_p;
+ static struct type *temp_type;
warning (_("GDB internal error: bad real_filenum"));
error_return:
- temp_type = init_type (TYPE_CODE_ERROR, 0, 0, NULL, NULL);
- temp_type_p = (struct type **) xmalloc (sizeof (struct type *));
- *temp_type_p = temp_type;
- return temp_type_p;
+ temp_type = objfile_type (objfile)->builtin_error;
+ return &temp_type;
}
- f = HEADER_FILES (current_objfile) + real_filenum;
+ f = HEADER_FILES (objfile) + real_filenum;
f_orig_length = f->length;
if (index >= f_orig_length)
@@ -317,7 +330,7 @@ dbx_lookup_type (int typenums[2])
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)
@@ -329,7 +342,7 @@ dbx_alloc_type (int typenums[2], struct objfile *objfile)
return (alloc_type (objfile));
}
- type_addr = dbx_lookup_type (typenums);
+ type_addr = dbx_lookup_type (typenums, objfile);
/* If we are referring to a type not known at all yet,
allocate an empty type for it.
@@ -342,8 +355,26 @@ dbx_alloc_type (int typenums[2], struct objfile *objfile)
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
- 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,
@@ -351,19 +382,19 @@ patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs,
{
int ii;
char *name;
- char *pp;
+ const char *pp;
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)
{
name = stabs->stab[ii];
pp = (char *) strchr (name, ':');
+ gdb_assert (pp); /* Must find a ':' or game's over. */
while (pp[1] == ':')
{
pp += 2;
@@ -383,15 +414,12 @@ 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. */
- 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_CLASS (sym) = LOC_OPTIMIZED_OUT;
- DEPRECATED_SYMBOL_NAME (sym) =
- obsavestring (name, pp - name, &objfile->objfile_obstack);
+ SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
+ SYMBOL_SET_LINKAGE_NAME
+ (sym, (char *) obstack_copy0 (&objfile->objfile_obstack,
+ name, pp - name));
pp += 2;
if (*(pp - 1) == 'F' || *(pp - 1) == 'f')
{
@@ -434,9 +462,10 @@ patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs,
Returns 0 for success, -1 for error. */
static int
-read_type_number (char **pp, int *typenums)
+read_type_number (const char **pp, int *typenums)
{
int nbits;
+
if (**pp == '(')
{
(*pp)++;
@@ -464,11 +493,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
- during "process_later". */
+ during "process_later". */
struct ref_map
{
- char *stabs;
+ const char *stabs;
CORE_ADDR value;
struct symbol *sym;
};
@@ -479,15 +508,15 @@ struct 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;
-/* 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
- 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)
{
@@ -497,10 +526,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
- 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
-ref_add (int refnum, struct symbol *sym, char *stabs, CORE_ADDR value)
+ref_add (int refnum, struct symbol *sym, const char *stabs, CORE_ADDR value)
{
if (ref_count == 0)
ref_chunk = 0;
@@ -510,9 +539,11 @@ ref_add (int refnum, struct symbol *sym, char *stabs, CORE_ADDR value)
{
int new_slots = ref_count - ref_chunk * MAX_CHUNK_REFS;
int new_chunks = new_slots / MAX_CHUNK_REFS + 1;
+
ref_map = (struct ref_map *)
xrealloc (ref_map, REF_MAP_SIZE (ref_chunk + new_chunks));
- memset (ref_map + ref_chunk * MAX_CHUNK_REFS, 0, new_chunks * REF_CHUNK_SIZE);
+ memset (ref_map + ref_chunk * MAX_CHUNK_REFS, 0,
+ new_chunks * REF_CHUNK_SIZE);
ref_chunk += new_chunks;
}
ref_map[refnum].stabs = stabs;
@@ -533,9 +564,9 @@ ref_search (int refnum)
reference number. Move STRING beyond the reference id. */
static int
-process_reference (char **string)
+process_reference (const char **string)
{
- char *p;
+ const char *p;
int refnum = 0;
if (**string != '#')
@@ -544,7 +575,7 @@ process_reference (char **string)
/* 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';
@@ -558,43 +589,73 @@ process_reference (char **string)
definition for later use. Return the reference number. */
int
-symbol_reference_defined (char **string)
+symbol_reference_defined (const char **string)
{
- char *p = *string;
+ const char *p = *string;
int refnum = 0;
refnum = process_reference (&p);
- /* Defining symbols end in '=' */
+ /* Defining symbols end in '='. */
if (*p == '=')
{
- /* Symbol is being defined here. */
+ /* Symbol is being defined here. */
*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;
}
}
+static int
+stab_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch)
+{
+ int regno = gdbarch_stab_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
+
+ if (regno < 0
+ || regno >= (gdbarch_num_regs (gdbarch)
+ + gdbarch_num_pseudo_regs (gdbarch)))
+ {
+ reg_value_complaint (regno,
+ gdbarch_num_regs (gdbarch)
+ + gdbarch_num_pseudo_regs (gdbarch),
+ SYMBOL_PRINT_NAME (sym));
+
+ regno = gdbarch_sp_regnum (gdbarch); /* Known safe, though useless. */
+ }
+
+ return regno;
+}
+
+static const struct symbol_register_ops stab_register_funcs = {
+ stab_reg_to_regnum
+};
+
+/* The "aclass" indices for computed symbols. */
+
+static int stab_register_index;
+static int stab_regparm_index;
+
struct symbol *
-define_symbol (CORE_ADDR valu, char *string, int desc, int type,
+define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
struct objfile *objfile)
{
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
struct symbol *sym;
- char *p = (char *) find_name_end (string);
+ const char *p = find_name_end (string);
int deftype;
int synonym = 0;
int i;
/* 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;
@@ -602,7 +663,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
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;
@@ -610,28 +671,19 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
{
p += 2;
p = strchr (p, ':');
+ if (p == NULL)
+ {
+ complaint (&symfile_complaints,
+ _("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] == ':')));
- 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)
{
@@ -644,46 +696,66 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
SYMBOL_LINE (sym) = 0; /* unknown */
}
+ SYMBOL_SET_LANGUAGE (sym, current_subfile->language,
+ &objfile->objfile_obstack);
+
if (is_cplus_marker (string[0]))
{
/* Special GNU C++ names. */
switch (string[1])
{
case 't':
- DEPRECATED_SYMBOL_NAME (sym) = obsavestring ("this", strlen ("this"),
- &objfile->objfile_obstack);
+ SYMBOL_SET_LINKAGE_NAME (sym, "this");
break;
case 'v': /* $vtbl_ptr_type */
- /* Was: DEPRECATED_SYMBOL_NAME (sym) = "vptr"; */
goto normal;
case 'e':
- DEPRECATED_SYMBOL_NAME (sym) = obsavestring ("eh_throw", strlen ("eh_throw"),
- &objfile->objfile_obstack);
+ SYMBOL_SET_LINKAGE_NAME (sym, "eh_throw");
break;
case '_':
/* This was an anonymous type that was never fixed up. */
goto normal;
-#ifdef STATIC_TRANSFORM_NAME
case 'X':
/* SunPRO (3.0 at least) static variable encoding. */
- goto normal;
-#endif
+ if (gdbarch_static_transform_name_p (gdbarch))
+ goto normal;
+ /* fall through */
default:
complaint (&symfile_complaints, _("Unknown C++ symbol name `%s'"),
string);
- goto normal; /* Do *something* with it */
+ goto normal; /* Do *something* with it. */
}
}
else
{
normal:
- SYMBOL_LANGUAGE (sym) = current_subfile->language;
- SYMBOL_SET_NAMES (sym, string, p - string, objfile);
+ std::string new_name;
+
+ if (SYMBOL_LANGUAGE (sym) == language_cplus)
+ {
+ char *name = (char *) alloca (p - string + 1);
+
+ memcpy (name, string, p - string);
+ name[p - string] = '\0';
+ new_name = cp_canonicalize_string (name);
+ }
+ if (!new_name.empty ())
+ {
+ SYMBOL_SET_NAMES (sym,
+ new_name.c_str (), new_name.length (),
+ 1, objfile);
+ }
+ else
+ SYMBOL_SET_NAMES (sym, string, p - string, 1, objfile);
+
+ if (SYMBOL_LANGUAGE (sym) == language_cplus)
+ cp_scan_for_anonymous_namespaces (sym, objfile);
+
}
p++;
@@ -715,7 +787,7 @@ 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 != '=')
{
- SYMBOL_CLASS (sym) = LOC_CONST;
+ SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
SYMBOL_TYPE (sym) = error_type (&p, objfile);
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
add_symbol_to_list (sym, &file_symbols);
@@ -726,28 +798,19 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
{
case 'r':
{
- double d = atof (p);
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_valu
+ = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack,
+ TYPE_LENGTH (dbl_type));
- /* FIXME: lookup_fundamental_type is a hack. We should be
- creating a type especially for the type of float constants.
- Problem is, what type should it be?
+ target_float_from_string (dbl_valu, dbl_type, std::string (p));
- Also, what should the name of this type be? Should we
- be using 'S' constants (see stabs.texinfo) instead? */
-
- SYMBOL_TYPE (sym) = lookup_fundamental_type (objfile,
- FT_DBL_PREC_FLOAT);
- dbl_valu =
- obstack_alloc (&objfile->objfile_obstack,
- TYPE_LENGTH (SYMBOL_TYPE (sym)));
- store_typed_floating (dbl_valu, SYMBOL_TYPE (sym), d);
+ 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':
@@ -759,33 +822,88 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
types; other languages probably should have at least
unsigned as well as signed constants. */
- /* We just need one int constant type for all objfiles.
- It doesn't depend on languages or anything (arguably its
- name should be a language-specific name for a type of
- that size, but I'm inclined to say that if the compiler
- wants a nice name for the type, it can use 'e'). */
- static struct type *int_const_type;
-
- /* Yes, this is as long as a *host* int. That is because we
- use atoi. */
- if (int_const_type == NULL)
- int_const_type =
- init_type (TYPE_CODE_INT,
- sizeof (int) * HOST_CHAR_BIT / TARGET_CHAR_BIT, 0,
- "integer constant",
- (struct objfile *) NULL);
- SYMBOL_TYPE (sym) = int_const_type;
+ 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;
+
+ case 'c':
+ {
+ SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_char;
+ SYMBOL_VALUE (sym) = atoi (p);
+ SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
+ }
+ break;
+
+ case 's':
+ {
+ struct type *range_type;
+ int ind = 0;
+ char quote = *p++;
+ gdb_byte *string_local = (gdb_byte *) alloca (strlen (p));
+ gdb_byte *string_value;
+
+ if (quote != '\'' && quote != '"')
+ {
+ SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
+ SYMBOL_TYPE (sym) = error_type (&p, objfile);
+ SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
+ add_symbol_to_list (sym, &file_symbols);
+ return sym;
+ }
+
+ /* Find matching quote, rejecting escaped quotes. */
+ while (*p && *p != quote)
+ {
+ if (*p == '\\' && p[1] == quote)
+ {
+ string_local[ind] = (gdb_byte) quote;
+ ind++;
+ p += 2;
+ }
+ else if (*p)
+ {
+ string_local[ind] = (gdb_byte) (*p);
+ ind++;
+ p++;
+ }
+ }
+ if (*p != quote)
+ {
+ SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
+ SYMBOL_TYPE (sym) = error_type (&p, objfile);
+ SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
+ add_symbol_to_list (sym, &file_symbols);
+ return sym;
+ }
+
+ /* NULL terminate the string. */
+ string_local[ind] = 0;
+ range_type
+ = 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);
+ 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;
+ SYMBOL_ACLASS_INDEX (sym) = LOC_CONST_BYTES;
}
break;
+
case 'e':
/* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
can be represented as integral.
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 != ',')
@@ -806,7 +924,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
break;
default:
{
- SYMBOL_CLASS (sym) = LOC_CONST;
+ SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
SYMBOL_TYPE (sym) = error_type (&p, objfile);
}
}
@@ -817,7 +935,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
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_VALUE_ADDRESS (sym) = valu;
add_symbol_to_list (sym, &local_symbols);
@@ -826,7 +944,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
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;
add_symbol_to_list (sym, &file_symbols);
/* fall into process_function_types. */
@@ -844,9 +962,9 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
than the "declared-as" type for unprototyped functions, so
we treat all functions as if they were prototyped. This is used
primarily for promotion when calling the function from GDB. */
- TYPE_FLAGS (SYMBOL_TYPE (sym)) |= TYPE_FLAG_PROTOTYPED;
+ 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. */
@@ -855,7 +973,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
struct type *ftype = SYMBOL_TYPE (sym);
int nsemi = 0;
int nparams = 0;
- char *p1 = p;
+ const char *p1 = p;
/* Obtain a worst case guess for the number of arguments
by counting the semicolons. */
@@ -865,7 +983,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
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++ == ';')
@@ -880,24 +998,24 @@ 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
- 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_type_int here.
- FIXME: Do we need a new builtin_type_promoted_int_arg ? */
+ it back into builtin_int here.
+ FIXME: Do we need a new builtin_promoted_int_arg ? */
if (TYPE_CODE (ptype) == TYPE_CODE_VOID)
- ptype = builtin_type_int;
+ ptype = objfile_type (objfile)->builtin_int;
TYPE_FIELD_TYPE (ftype, nparams) = ptype;
TYPE_FIELD_ARTIFICIAL (ftype, nparams++) = 0;
}
TYPE_NFIELDS (ftype) = nparams;
- TYPE_FLAGS (ftype) |= TYPE_FLAG_PROTOTYPED;
+ TYPE_PROTOTYPED (ftype) = 1;
}
break;
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;
add_symbol_to_list (sym, &global_symbols);
goto process_function_types;
@@ -908,15 +1026,15 @@ 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);
- 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. */
- if (DEPRECATED_SYMBOL_NAME (sym) && DEPRECATED_SYMBOL_NAME (sym)[0] != '#')
+ if (SYMBOL_LINKAGE_NAME (sym) && SYMBOL_LINKAGE_NAME (sym)[0] != '#')
{
- i = hashname (DEPRECATED_SYMBOL_NAME (sym));
+ i = hashname (SYMBOL_LINKAGE_NAME (sym));
SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
global_sym_chain[i] = sym;
}
@@ -929,7 +1047,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
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;
add_symbol_to_list (sym, &local_symbols);
@@ -949,12 +1067,13 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
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;
add_symbol_to_list (sym, &local_symbols);
- if (gdbarch_byte_order (current_gdbarch) != BFD_ENDIAN_BIG)
+ if (gdbarch_byte_order (gdbarch) != BFD_ENDIAN_BIG)
{
/* On little-endian machines, this crud is never necessary,
and, if the extra bytes contain garbage, is harmful. */
@@ -963,41 +1082,25 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
/* If it's gcc-compiled, if it says `short', believe it. */
if (processing_gcc_compilation
- || gdbarch_believe_pcc_promotion (current_gdbarch))
+ || gdbarch_believe_pcc_promotion (gdbarch))
break;
- if (!gdbarch_believe_pcc_promotion (current_gdbarch))
+ if (!gdbarch_believe_pcc_promotion (gdbarch))
{
- /* This is the signed type which arguments get promoted to. */
- static struct type *pcc_promotion_type;
- /* This is the unsigned type which arguments get promoted to. */
- static struct type *pcc_unsigned_promotion_type;
-
- /* Call it "int" because this is mainly C lossage. */
- if (pcc_promotion_type == NULL)
- pcc_promotion_type =
- init_type (TYPE_CODE_INT,
- gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
- 0, "int", NULL);
-
- if (pcc_unsigned_promotion_type == NULL)
- pcc_unsigned_promotion_type =
- init_type (TYPE_CODE_INT,
- gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
- TYPE_FLAG_UNSIGNED, "unsigned int", NULL);
-
/* If PCC says a parameter is a short or a char, it is
really an int. */
- if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (pcc_promotion_type)
+ if (TYPE_LENGTH (SYMBOL_TYPE (sym))
+ < gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT
&& TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT)
{
SYMBOL_TYPE (sym) =
TYPE_UNSIGNED (SYMBOL_TYPE (sym))
- ? pcc_unsigned_promotion_type
- : pcc_promotion_type;
+ ? objfile_type (objfile)->builtin_unsigned_int
+ : objfile_type (objfile)->builtin_int;
}
break;
}
+ /* Fall through. */
case 'P':
/* acc seems to use P to declare the prototypes of functions that
@@ -1013,18 +1116,9 @@ 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);
- SYMBOL_CLASS (sym) = LOC_REGPARM;
- SYMBOL_VALUE (sym) = gdbarch_stab_reg_to_regnum (current_gdbarch, valu);
- if (SYMBOL_VALUE (sym) >= gdbarch_num_regs (current_gdbarch)
- + gdbarch_num_pseudo_regs (current_gdbarch))
- {
- reg_value_complaint (SYMBOL_VALUE (sym),
- gdbarch_num_regs (current_gdbarch)
- + gdbarch_num_pseudo_regs (current_gdbarch),
- SYMBOL_PRINT_NAME (sym));
- SYMBOL_VALUE (sym) = gdbarch_sp_regnum (current_gdbarch);
- /* Known safe, though useless */
- }
+ SYMBOL_ACLASS_INDEX (sym) = stab_register_index;
+ SYMBOL_IS_ARGUMENT (sym) = 1;
+ SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
add_symbol_to_list (sym, &local_symbols);
break;
@@ -1032,18 +1126,8 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
case 'r':
/* Register variable (either global or local). */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_CLASS (sym) = LOC_REGISTER;
- SYMBOL_VALUE (sym) = gdbarch_stab_reg_to_regnum (current_gdbarch, valu);
- if (SYMBOL_VALUE (sym) >= gdbarch_num_regs (current_gdbarch)
- + gdbarch_num_pseudo_regs (current_gdbarch))
- {
- reg_value_complaint (SYMBOL_VALUE (sym),
- gdbarch_num_regs (current_gdbarch)
- + gdbarch_num_pseudo_regs (current_gdbarch),
- SYMBOL_PRINT_NAME (sym));
- SYMBOL_VALUE (sym) = gdbarch_sp_regnum (current_gdbarch);
- /* Known safe, though useless */
- }
+ SYMBOL_ACLASS_INDEX (sym) = stab_register_index;
+ SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
if (within_function)
{
@@ -1069,17 +1153,17 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
if (local_symbols
&& local_symbols->nsyms > 0
- && gdbarch_stabs_argument_has_addr (current_gdbarch,
- SYMBOL_TYPE (sym)))
+ && gdbarch_stabs_argument_has_addr (gdbarch, SYMBOL_TYPE (sym)))
{
struct symbol *prev_sym;
+
prev_sym = local_symbols->symbol[local_symbols->nsyms - 1];
if ((SYMBOL_CLASS (prev_sym) == LOC_REF_ARG
|| SYMBOL_CLASS (prev_sym) == LOC_ARG)
- && strcmp (DEPRECATED_SYMBOL_NAME (prev_sym),
- DEPRECATED_SYMBOL_NAME (sym)) == 0)
+ && strcmp (SYMBOL_LINKAGE_NAME (prev_sym),
+ SYMBOL_LINKAGE_NAME (sym)) == 0)
{
- SYMBOL_CLASS (prev_sym) = LOC_REGPARM;
+ 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);
@@ -1095,22 +1179,28 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
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_CLASS (sym) = LOC_STATIC;
+ SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
SYMBOL_VALUE_ADDRESS (sym) = valu;
-#ifdef STATIC_TRANSFORM_NAME
- if (IS_STATIC_TRANSFORM_NAME (DEPRECATED_SYMBOL_NAME (sym)))
+ if (gdbarch_static_transform_name_p (gdbarch)
+ && gdbarch_static_transform_name (gdbarch,
+ SYMBOL_LINKAGE_NAME (sym))
+ != SYMBOL_LINKAGE_NAME (sym))
{
- struct minimal_symbol *msym;
- msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym), NULL, objfile);
- if (msym != NULL)
+ struct bound_minimal_symbol msym;
+
+ msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
+ NULL, objfile);
+ if (msym.minsym != NULL)
{
- DEPRECATED_SYMBOL_NAME (sym) = STATIC_TRANSFORM_NAME (DEPRECATED_SYMBOL_NAME (sym));
- SYMBOL_VALUE_ADDRESS (sym) = SYMBOL_VALUE_ADDRESS (msym);
+ const char *new_name = gdbarch_static_transform_name
+ (gdbarch, SYMBOL_LINKAGE_NAME (sym));
+
+ SYMBOL_SET_LINKAGE_NAME (sym, new_name);
+ SYMBOL_VALUE_ADDRESS (sym) = BMSYMBOL_VALUE_ADDRESS (msym);
}
}
-#endif
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
add_symbol_to_list (sym, &file_symbols);
break;
@@ -1118,7 +1208,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
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
@@ -1136,11 +1226,11 @@ 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
- did not use `sym'. Return without further processing. */
+ did not use `sym'. Return without further processing. */
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
@@ -1153,6 +1243,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
&& TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)))
{
int 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) =
@@ -1163,11 +1254,11 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
{
/* 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. */
+ Some gdb code depends on that specific name. */
extern const char vtbl_ptr_name[];
if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
- && strcmp (DEPRECATED_SYMBOL_NAME (sym), vtbl_ptr_name))
+ && strcmp (SYMBOL_LINKAGE_NAME (sym), vtbl_ptr_name))
|| TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
{
/* If we are giving a name to a type such as "pointer to
@@ -1188,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. */
- /* 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
- 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
{
- char *name1;
+ char *name1;
} xx;
char *func()
{
@@ -1204,14 +1296,14 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
main () {}
*/
- /* Pascal accepts names for pointer types. */
+ /* Pascal accepts names for pointer types. */
if (current_subfile->language == language_pascal)
{
- TYPE_NAME (SYMBOL_TYPE (sym)) = DEPRECATED_SYMBOL_NAME (sym);
+ TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_LINKAGE_NAME (sym);
}
}
else
- TYPE_NAME (SYMBOL_TYPE (sym)) = DEPRECATED_SYMBOL_NAME (sym);
+ TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_LINKAGE_NAME (sym);
}
add_symbol_to_list (sym, &file_symbols);
@@ -1219,17 +1311,17 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
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;
- 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))
- = obconcat (&objfile->objfile_obstack, "", "",
- DEPRECATED_SYMBOL_NAME (sym));
+ = obconcat (&objfile->objfile_obstack,
+ SYMBOL_LINKAGE_NAME (sym),
+ (char *) NULL);
add_symbol_to_list (struct_sym, &file_symbols);
}
@@ -1246,51 +1338,61 @@ 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
- did not use `sym'. Return without further processing. */
+ did not use `sym'. Return without further processing. */
if (nameless)
return NULL;
- SYMBOL_CLASS (sym) = LOC_TYPEDEF;
+ SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
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, "", "", DEPRECATED_SYMBOL_NAME (sym));
+ = obconcat (&objfile->objfile_obstack,
+ SYMBOL_LINKAGE_NAME (sym),
+ (char *) NULL);
add_symbol_to_list (sym, &file_symbols);
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;
- 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))
- = obconcat (&objfile->objfile_obstack, "", "", DEPRECATED_SYMBOL_NAME (sym));
+ = obconcat (&objfile->objfile_obstack,
+ SYMBOL_LINKAGE_NAME (sym),
+ (char *) NULL);
add_symbol_to_list (typedef_sym, &file_symbols);
}
break;
case 'V':
- /* Static symbol of local scope */
+ /* Static symbol of local scope. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_CLASS (sym) = LOC_STATIC;
+ SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
SYMBOL_VALUE_ADDRESS (sym) = valu;
-#ifdef STATIC_TRANSFORM_NAME
- if (IS_STATIC_TRANSFORM_NAME (DEPRECATED_SYMBOL_NAME (sym)))
+ if (gdbarch_static_transform_name_p (gdbarch)
+ && gdbarch_static_transform_name (gdbarch,
+ SYMBOL_LINKAGE_NAME (sym))
+ != SYMBOL_LINKAGE_NAME (sym))
{
- struct minimal_symbol *msym;
- msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym), NULL, objfile);
- if (msym != NULL)
+ struct bound_minimal_symbol msym;
+
+ msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
+ NULL, objfile);
+ if (msym.minsym != NULL)
{
- DEPRECATED_SYMBOL_NAME (sym) = STATIC_TRANSFORM_NAME (DEPRECATED_SYMBOL_NAME (sym));
- SYMBOL_VALUE_ADDRESS (sym) = SYMBOL_VALUE_ADDRESS (msym);
+ const char *new_name = gdbarch_static_transform_name
+ (gdbarch, SYMBOL_LINKAGE_NAME (sym));
+
+ SYMBOL_SET_LINKAGE_NAME (sym, new_name);
+ SYMBOL_VALUE_ADDRESS (sym) = BMSYMBOL_VALUE_ADDRESS (msym);
}
}
-#endif
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
add_symbol_to_list (sym, &local_symbols);
break;
@@ -1298,7 +1400,8 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
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;
add_symbol_to_list (sym, &local_symbols);
@@ -1307,18 +1410,9 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
case 'a':
/* Reference parameter which is in a register. */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR;
- SYMBOL_VALUE (sym) = gdbarch_stab_reg_to_regnum (current_gdbarch, valu);
- if (SYMBOL_VALUE (sym) >= gdbarch_num_regs (current_gdbarch)
- + gdbarch_num_pseudo_regs (current_gdbarch))
- {
- reg_value_complaint (SYMBOL_VALUE (sym),
- gdbarch_num_regs (current_gdbarch)
- + gdbarch_num_pseudo_regs (current_gdbarch),
- SYMBOL_PRINT_NAME (sym));
- SYMBOL_VALUE (sym) = gdbarch_sp_regnum (current_gdbarch);
- /* Known safe, though useless */
- }
+ SYMBOL_ACLASS_INDEX (sym) = stab_regparm_index;
+ SYMBOL_IS_ARGUMENT (sym) = 1;
+ SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
add_symbol_to_list (sym, &local_symbols);
break;
@@ -1329,7 +1423,7 @@ 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);
- SYMBOL_CLASS (sym) = LOC_LOCAL;
+ SYMBOL_ACLASS_INDEX (sym) = LOC_LOCAL;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
add_symbol_to_list (sym, &local_symbols);
@@ -1337,7 +1431,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
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;
add_symbol_to_list (sym, &file_symbols);
@@ -1348,17 +1442,17 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
of by value, i.e. they will pass the address of a structure (in a
register or on the stack) instead of the structure itself. */
- if (gdbarch_stabs_argument_has_addr (current_gdbarch, SYMBOL_TYPE (sym))
- && (SYMBOL_CLASS (sym) == LOC_REGPARM || SYMBOL_CLASS (sym) == LOC_ARG))
+ if (gdbarch_stabs_argument_has_addr (gdbarch, SYMBOL_TYPE (sym))
+ && SYMBOL_IS_ARGUMENT (sym))
{
- /* We have to convert LOC_REGPARM to LOC_REGPARM_ADDR (for
+ /* We have to convert LOC_REGISTER to LOC_REGPARM_ADDR (for
variables passed in a register). */
- if (SYMBOL_CLASS (sym) == LOC_REGPARM)
- SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR;
+ if (SYMBOL_CLASS (sym) == LOC_REGISTER)
+ 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)
- SYMBOL_CLASS (sym) = LOC_REF_ARG;
+ SYMBOL_ACLASS_INDEX (sym) = LOC_REF_ARG;
}
return sym;
@@ -1394,9 +1488,10 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
debugger will be able to read the new symbol tables. */
static struct type *
-error_type (char **pp, struct objfile *objfile)
+error_type (const char **pp, struct objfile *objfile)
{
- complaint (&symfile_complaints, _("couldn't parse type; debugger out of date?"));
+ complaint (&symfile_complaints,
+ _("couldn't parse type; debugger out of date?"));
while (1)
{
/* Skip to end of symbol. */
@@ -1415,7 +1510,7 @@ error_type (char **pp, struct objfile *objfile)
break;
}
}
- return (builtin_type_error);
+ return objfile_type (objfile)->builtin_error;
}
@@ -1426,7 +1521,7 @@ error_type (char **pp, struct objfile *objfile)
deciding whether to call read_type. */
static struct type *
-read_type (char **pp, struct objfile *objfile)
+read_type (const char **pp, struct objfile *objfile)
{
struct type *type = 0;
struct type *type1;
@@ -1437,10 +1532,10 @@ read_type (char **pp, struct objfile *objfile)
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;
- /* 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.
@@ -1498,7 +1593,7 @@ again:
char *type_name;
{
- char *from, *to, *p, *q1, *q2;
+ const char *from, *p, *q1, *q2;
/* Set the type code according to the following letter. */
switch ((*pp)[0])
@@ -1517,7 +1612,8 @@ again:
/* Complain and keep going, so compilers can invent new
cross-reference types. */
complaint (&symfile_complaints,
- _("Unrecognized cross-reference type `%c'"), (*pp)[0]);
+ _("Unrecognized cross-reference type `%c'"),
+ (*pp)[0]);
code = TYPE_CODE_STRUCT;
break;
}
@@ -1530,6 +1626,7 @@ again:
if (q1 && p > q1 && p[1] == ':')
{
int nesting_level = 0;
+
for (q2 = q1; *q2; q2++)
{
if (*q2 == '<')
@@ -1543,18 +1640,38 @@ again:
if (*p != ':')
return error_type (pp, objfile);
}
- to = type_name =
- (char *) obstack_alloc (&objfile->objfile_obstack, p - *pp + 1);
+ type_name = NULL;
+ if (current_subfile->language == language_cplus)
+ {
+ char *name = (char *) alloca (p - *pp + 1);
- /* Copy the name. */
- from = *pp + 1;
- while (from < p)
- *to++ = *from++;
- *to = '\0';
+ memcpy (name, *pp, p - *pp);
+ name[p - *pp] = '\0';
+
+ std::string new_name = cp_canonicalize_string (name);
+ if (!new_name.empty ())
+ {
+ type_name
+ = (char *) obstack_copy0 (&objfile->objfile_obstack,
+ new_name.c_str (),
+ new_name.length ());
+ }
+ }
+ if (type_name == NULL)
+ {
+ char *to = type_name = (char *)
+ obstack_alloc (&objfile->objfile_obstack, p - *pp + 1);
+
+ /* Copy the name. */
+ from = *pp + 1;
+ while (from < p)
+ *to++ = *from++;
+ *to = '\0';
+ }
/* Set the pointer ahead of the name which we just read, and
the colon. */
- *pp = from + 1;
+ *pp = p + 1;
}
/* If this type has already been declared, then reuse the same
@@ -1569,12 +1686,12 @@ again:
if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
&& SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
&& (TYPE_CODE (SYMBOL_TYPE (sym)) == code)
- && strcmp (DEPRECATED_SYMBOL_NAME (sym), type_name) == 0)
+ && strcmp (SYMBOL_LINKAGE_NAME (sym), type_name) == 0)
{
obstack_free (&objfile->objfile_obstack, type_name);
type = SYMBOL_TYPE (sym);
if (typenums[0] != -1)
- *dbx_lookup_type (typenums) = type;
+ *dbx_lookup_type (typenums, objfile) = type;
return type;
}
}
@@ -1588,7 +1705,7 @@ again:
TYPE_CODE (type) = code;
TYPE_TAG_NAME (type) = type_name;
INIT_CPLUS_SPECIFIC (type);
- TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
+ TYPE_STUB (type) = 1;
add_undefined_type (type, typenums);
return type;
@@ -1609,14 +1726,15 @@ again:
(*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.
- This handles recursive types. */
+ This handles recursive types. */
type = dbx_alloc_type (typenums, objfile);
TYPE_CODE (type) = TYPE_CODE_TYPEDEF;
{
struct type *xtype = read_type (pp, objfile);
+
if (type == xtype)
{
/* It's being defined as itself. That means it is "void". */
@@ -1654,7 +1772,7 @@ again:
}
else
{
- TYPE_FLAGS (type) |= TYPE_FLAG_TARGET_STUB;
+ TYPE_TARGET_STUB (type) = 1;
TYPE_TARGET_TYPE (type) = xtype;
}
}
@@ -1669,17 +1787,18 @@ again:
case '*': /* Pointer to another type */
type1 = read_type (pp, objfile);
- type = make_pointer_type (type1, dbx_lookup_type (typenums));
+ type = make_pointer_type (type1, dbx_lookup_type (typenums, objfile));
break;
case '&': /* Reference to another type */
type1 = read_type (pp, objfile);
- type = make_reference_type (type1, dbx_lookup_type (typenums));
+ type = make_reference_type (type1, dbx_lookup_type (typenums, objfile),
+ TYPE_CODE_REF);
break;
case 'f': /* Function returning another type */
type1 = read_type (pp, objfile);
- type = make_function_type (type1, dbx_lookup_type (typenums));
+ type = make_function_type (type1, dbx_lookup_type (typenums, objfile));
break;
case 'g': /* Prototyped function. (Sun) */
@@ -1702,7 +1821,8 @@ again:
const char *type_start = (*pp) - 1;
struct type *return_type = read_type (pp, objfile);
struct type *func_type
- = make_function_type (return_type, dbx_lookup_type (typenums));
+ = make_function_type (return_type,
+ dbx_lookup_type (typenums, objfile));
struct type_list {
struct type *type;
struct type_list *next;
@@ -1712,10 +1832,10 @@ again:
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 *newobj = XALLOCA (struct type_list);
+ newobj->type = arg_type;
+ newobj->next = arg_types;
+ arg_types = newobj;
num_args++;
}
if (**pp == '#')
@@ -1723,7 +1843,8 @@ again:
else
{
complaint (&symfile_complaints,
- _("Prototyped function type didn't end arguments with `#':\n%s"),
+ _("Prototyped function type didn't "
+ "end arguments with `#':\n%s"),
type_start);
}
@@ -1749,7 +1870,7 @@ again:
TYPE_FIELD_TYPE (func_type, i) = t->type;
}
TYPE_NFIELDS (func_type) = num_args;
- TYPE_FLAGS (func_type) |= TYPE_FLAG_PROTOTYPED;
+ TYPE_PROTOTYPED (func_type) = 1;
type = func_type;
break;
@@ -1758,13 +1879,13 @@ again:
case 'k': /* Const qualifier on some type (Sun) */
type = read_type (pp, objfile);
type = make_cv_type (1, TYPE_VOLATILE (type), type,
- dbx_lookup_type (typenums));
+ dbx_lookup_type (typenums, objfile));
break;
case 'B': /* Volatile qual on some type (Sun) */
type = read_type (pp, objfile);
type = make_cv_type (TYPE_CONST (type), 1, type,
- dbx_lookup_type (typenums));
+ dbx_lookup_type (typenums, objfile));
break;
case '@':
@@ -1787,7 +1908,8 @@ again:
else
/* type attribute */
{
- char *attr = *pp;
+ const char *attr = *pp;
+
/* Skip to the semicolon. */
while (**pp != ';' && **pp != '\0')
++(*pp);
@@ -1805,12 +1927,12 @@ again:
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 */
- /* FIXME: check to see if following type is array? */
+ /* FIXME: check to see if following type is array? */
is_vector = 1;
break;
@@ -1834,11 +1956,12 @@ again:
return_type = read_type (pp, objfile);
if (*(*pp)++ != ';')
complaint (&symfile_complaints,
- _("invalid (minimal) member type data format at symtab pos %d."),
+ _("invalid (minimal) member type "
+ "data format at symtab pos %d."),
symnum);
type = allocate_stub_method (return_type);
if (typenums[0] != -1)
- *dbx_lookup_type (typenums) = type;
+ *dbx_lookup_type (typenums, objfile) = type;
}
else
{
@@ -1866,7 +1989,7 @@ again:
case 'r': /* Range type */
type = read_range_type (pp, typenums, type_size, objfile);
if (typenums[0] != -1)
- *dbx_lookup_type (typenums) = type;
+ *dbx_lookup_type (typenums, objfile) = type;
break;
case 'b':
@@ -1874,21 +1997,21 @@ again:
/* Sun ACC builtin int type */
type = read_sun_builtin_type (pp, typenums, objfile);
if (typenums[0] != -1)
- *dbx_lookup_type (typenums) = type;
+ *dbx_lookup_type (typenums, objfile) = type;
}
break;
case 'R': /* Sun ACC builtin float type */
type = read_sun_floating_type (pp, typenums, objfile);
if (typenums[0] != -1)
- *dbx_lookup_type (typenums) = type;
+ *dbx_lookup_type (typenums, objfile) = type;
break;
case 'e': /* Enumeration type */
type = dbx_alloc_type (typenums, objfile);
type = read_enum_type (pp, type, objfile);
if (typenums[0] != -1)
- *dbx_lookup_type (typenums) = type;
+ *dbx_lookup_type (typenums, objfile) = type;
break;
case 's': /* Struct type */
@@ -1919,21 +2042,19 @@ again:
if (is_string)
TYPE_CODE (type) = TYPE_CODE_STRING;
if (is_vector)
- TYPE_FLAGS (type) |= TYPE_FLAG_VECTOR;
+ make_vector_type (type);
break;
- case 'S': /* Set or bitstring type */
+ case 'S': /* Set type */
type1 = read_type (pp, objfile);
type = create_set_type ((struct type *) NULL, type1);
- if (is_string)
- TYPE_CODE (type) = TYPE_CODE_BITSTRING;
if (typenums[0] != -1)
- *dbx_lookup_type (typenums) = type;
+ *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);
}
@@ -1951,22 +2072,34 @@ again:
}
/* 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 struct type *
-rs6000_builtin_type (int typenum)
+rs6000_builtin_type (int typenum, struct objfile *objfile)
{
+ struct type **negative_types
+ = (struct type **) objfile_data (objfile, rs6000_builtin_type_data);
+
/* We recognize types numbered from -NUMBER_RECOGNIZED to -1. */
#define NUMBER_RECOGNIZED 34
- /* This includes an empty slot for type number -0. */
- static struct type *negative_types[NUMBER_RECOGNIZED + 1];
struct type *rettype = NULL;
if (typenum >= 0 || typenum < -NUMBER_RECOGNIZED)
{
complaint (&symfile_complaints, _("Unknown builtin type %d"), typenum);
- return builtin_type_error;
+ return objfile_type (objfile)->builtin_error;
+ }
+
+ if (!negative_types)
+ {
+ /* 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);
}
+
if (negative_types[-typenum] != NULL)
return negative_types[-typenum];
@@ -1986,129 +2119,121 @@ rs6000_builtin_type (int typenum)
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", NULL);
+ rettype = init_integer_type (objfile, 32, 0, "int");
break;
case 2:
- rettype = init_type (TYPE_CODE_INT, 1, 0, "char", NULL);
+ rettype = init_integer_type (objfile, 8, 0, "char");
+ TYPE_NOSIGN (rettype) = 1;
break;
case 3:
- rettype = init_type (TYPE_CODE_INT, 2, 0, "short", NULL);
+ rettype = init_integer_type (objfile, 16, 0, "short");
break;
case 4:
- rettype = init_type (TYPE_CODE_INT, 4, 0, "long", NULL);
+ rettype = init_integer_type (objfile, 32, 0, "long");
break;
case 5:
- rettype = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED,
- "unsigned char", NULL);
+ rettype = init_integer_type (objfile, 8, 1, "unsigned char");
break;
case 6:
- rettype = init_type (TYPE_CODE_INT, 1, 0, "signed char", NULL);
+ rettype = init_integer_type (objfile, 8, 0, "signed char");
break;
case 7:
- rettype = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED,
- "unsigned short", NULL);
+ rettype = init_integer_type (objfile, 16, 1, "unsigned short");
break;
case 8:
- rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
- "unsigned int", NULL);
+ rettype = init_integer_type (objfile, 32, 1, "unsigned int");
break;
case 9:
- rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
- "unsigned", NULL);
+ rettype = init_integer_type (objfile, 32, 1, "unsigned");
+ break;
case 10:
- rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
- "unsigned long", NULL);
+ rettype = init_integer_type (objfile, 32, 1, "unsigned long");
break;
case 11:
- rettype = init_type (TYPE_CODE_VOID, 1, 0, "void", NULL);
+ rettype = init_type (objfile, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
break;
case 12:
/* IEEE single precision (32 bit). */
- rettype = init_type (TYPE_CODE_FLT, 4, 0, "float", NULL);
+ rettype = init_float_type (objfile, 32, "float",
+ floatformats_ieee_single);
break;
case 13:
/* IEEE double precision (64 bit). */
- rettype = init_type (TYPE_CODE_FLT, 8, 0, "double", NULL);
+ 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. */
- rettype = init_type (TYPE_CODE_FLT, 8, 0, "long double", NULL);
+ rettype = init_float_type (objfile, 64, "long double",
+ floatformats_ieee_double);
break;
case 15:
- rettype = init_type (TYPE_CODE_INT, 4, 0, "integer", NULL);
+ rettype = init_integer_type (objfile, 32, 0, "integer");
break;
case 16:
- rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
- "boolean", NULL);
+ rettype = init_boolean_type (objfile, 32, 1, "boolean");
break;
case 17:
- rettype = init_type (TYPE_CODE_FLT, 4, 0, "short real", NULL);
+ rettype = init_float_type (objfile, 32, "short real",
+ floatformats_ieee_single);
break;
case 18:
- rettype = init_type (TYPE_CODE_FLT, 8, 0, "real", NULL);
+ rettype = init_float_type (objfile, 64, "real",
+ floatformats_ieee_double);
break;
case 19:
- rettype = init_type (TYPE_CODE_ERROR, 0, 0, "stringptr", NULL);
+ rettype = init_type (objfile, TYPE_CODE_ERROR, 0, "stringptr");
break;
case 20:
- rettype = init_type (TYPE_CODE_CHAR, 1, TYPE_FLAG_UNSIGNED,
- "character", NULL);
+ rettype = init_character_type (objfile, 8, 1, "character");
break;
case 21:
- rettype = init_type (TYPE_CODE_BOOL, 1, TYPE_FLAG_UNSIGNED,
- "logical*1", NULL);
+ rettype = init_boolean_type (objfile, 8, 1, "logical*1");
break;
case 22:
- rettype = init_type (TYPE_CODE_BOOL, 2, TYPE_FLAG_UNSIGNED,
- "logical*2", NULL);
+ rettype = init_boolean_type (objfile, 16, 1, "logical*2");
break;
case 23:
- rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
- "logical*4", NULL);
+ rettype = init_boolean_type (objfile, 32, 1, "logical*4");
break;
case 24:
- rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
- "logical", NULL);
+ rettype = init_boolean_type (objfile, 32, 1, "logical");
break;
case 25:
/* Complex type consisting of two IEEE single precision values. */
- rettype = init_type (TYPE_CODE_COMPLEX, 8, 0, "complex", NULL);
- TYPE_TARGET_TYPE (rettype) = init_type (TYPE_CODE_FLT, 4, 0, "float",
- NULL);
+ rettype = init_complex_type (objfile, "complex",
+ rs6000_builtin_type (12, objfile));
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",
- NULL);
+ rettype = init_complex_type (objfile, "double complex",
+ rs6000_builtin_type (13, objfile));
break;
case 27:
- rettype = init_type (TYPE_CODE_INT, 1, 0, "integer*1", NULL);
+ rettype = init_integer_type (objfile, 8, 0, "integer*1");
break;
case 28:
- rettype = init_type (TYPE_CODE_INT, 2, 0, "integer*2", NULL);
+ rettype = init_integer_type (objfile, 16, 0, "integer*2");
break;
case 29:
- rettype = init_type (TYPE_CODE_INT, 4, 0, "integer*4", NULL);
+ rettype = init_integer_type (objfile, 32, 0, "integer*4");
break;
case 30:
- rettype = init_type (TYPE_CODE_CHAR, 2, 0, "wchar", NULL);
+ rettype = init_character_type (objfile, 16, 0, "wchar");
break;
case 31:
- rettype = init_type (TYPE_CODE_INT, 8, 0, "long long", NULL);
+ rettype = init_integer_type (objfile, 64, 0, "long long");
break;
case 32:
- rettype = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
- "unsigned long long", NULL);
+ rettype = init_integer_type (objfile, 64, 1, "unsigned long long");
break;
case 33:
- rettype = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
- "logical*8", NULL);
+ rettype = init_integer_type (objfile, 64, 1, "logical*8");
break;
case 34:
- rettype = init_type (TYPE_CODE_INT, 8, 0, "integer*8", NULL);
+ rettype = init_integer_type (objfile, 64, 0, "integer*8");
break;
}
negative_types[-typenum] = rettype;
@@ -2117,10 +2242,11 @@ rs6000_builtin_type (int typenum)
/* 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;
@@ -2130,16 +2256,10 @@ update_method_name_from_physname (char **old_name, char *physname)
{
complaint (&symfile_complaints,
_("Method has bad physname %s\n"), physname);
- return;
+ 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
@@ -2158,15 +2278,11 @@ update_method_name_from_physname (char **old_name, char *physname)
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 field_info *fip, const char **pp,
+ struct type *type, struct objfile *objfile)
{
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
{
@@ -2178,16 +2294,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;
- char *p;
+ const char *p;
/* 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
- 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 != ':')
{
@@ -2202,10 +2318,8 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
look_ahead_type = NULL;
length = 0;
- new_fnlist = (struct next_fnfieldlist *)
- xmalloc (sizeof (struct next_fnfieldlist));
+ new_fnlist = XCNEW (struct next_fnfieldlist);
make_cleanup (xfree, new_fnlist);
- memset (new_fnlist, 0, sizeof (struct next_fnfieldlist));
if ((*pp)[0] == 'o' && (*pp)[1] == 'p' && is_cplus_marker ((*pp)[2]))
{
@@ -2244,15 +2358,13 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
do
{
- new_sublist =
- (struct next_fnfield *) xmalloc (sizeof (struct next_fnfield));
+ new_sublist = XCNEW (struct next_fnfield);
make_cleanup (xfree, new_sublist);
- memset (new_sublist, 0, sizeof (struct next_fnfield));
/* 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);
@@ -2276,14 +2388,21 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
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_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.physname = savestring (*pp, p - *pp);
*pp = p + 1;
@@ -2301,33 +2420,35 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
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;
- 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;
- 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;
- 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 -- no info */
+ case '*': /* File compiled with g++ version 1 --
+ no info. */
case '?':
case '.':
break;
default:
complaint (&symfile_complaints,
- _("const/volatile indicator missing, got '%c'"), **pp);
+ _("const/volatile indicator missing, got '%c'"),
+ **pp);
break;
}
@@ -2362,7 +2483,7 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
look_ahead_type = read_type (pp, objfile);
if (**pp == ':')
{
- /* g++ version 1 overloaded methods. */
+ /* g++ version 1 overloaded methods. */
}
else
{
@@ -2410,8 +2531,10 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
default:
/* error */
complaint (&symfile_complaints,
- _("member function type missing, got '%c'"), (*pp)[-1]);
- /* Fall through into normal member function. */
+ _("member function type missing, got '%c'"),
+ (*pp)[-1]);
+ /* Normal member function. */
+ /* Fall through. */
case '.':
/* normal member function. */
@@ -2432,8 +2555,8 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
/* Skip GCC 3.X member functions which are duplicates of the callable
constructor/destructor. */
- if (strcmp (main_fn_name, "__base_ctor") == 0
- || strcmp (main_fn_name, "__base_dtor") == 0
+ if (strcmp_iw (main_fn_name, "__base_ctor ") == 0
+ || strcmp_iw (main_fn_name, "__base_dtor ") == 0
|| strcmp (main_fn_name, "__deleting_dtor") == 0)
{
xfree (main_fn_name);
@@ -2494,8 +2617,8 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
method name physname physname method name
__opi [none] __opi__3Foo operator int opname
- [now or later]
- Foo _._3Foo _._3Foo ~Foo separate and
+ [now or later]
+ Foo _._3Foo _._3Foo ~Foo separate and
rename
operator i _ZN3FoocviEv _ZN3FoocviEv operator int demangle
__comp_ctor _ZN3FooC1ERKS_ _ZN3FooC1ERKS_ Foo demangle
@@ -2525,17 +2648,16 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
/* Create a new fn_fieldlist for the destructors. */
- destr_fnlist = (struct next_fnfieldlist *)
- xmalloc (sizeof (struct next_fnfieldlist));
+ destr_fnlist = XCNEW (struct next_fnfieldlist);
make_cleanup (xfree, destr_fnlist);
- memset (destr_fnlist, 0, sizeof (struct next_fnfieldlist));
+
destr_fnlist->fn_fieldlist.name
- = obconcat (&objfile->objfile_obstack, "", "~",
- new_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;
@@ -2563,7 +2685,6 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
destr_fnlist->next = fip->fnlist;
fip->fnlist = destr_fnlist;
nfn_fields++;
- total_length += has_destructor;
length -= has_destructor;
}
else if (is_v3)
@@ -2574,20 +2695,31 @@ 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. */
+ 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 =
- concat ("~", main_fn_name, (char *)NULL);
+ obconcat (&objfile->objfile_obstack,
+ "~", main_fn_name, (char *)NULL);
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)
@@ -2595,8 +2727,10 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
dem_opname, 0);
if (ret)
new_fnlist->fn_fieldlist.name
- = obsavestring (dem_opname, strlen (dem_opname),
- &objfile->objfile_obstack);
+ = ((const char *)
+ obstack_copy0 (&objfile->objfile_obstack, dem_opname,
+ strlen (dem_opname)));
+ xfree (main_fn_name);
}
new_fnlist->fn_fieldlist.fn_fields = (struct fn_field *)
@@ -2613,7 +2747,6 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
new_fnlist->next = fip->fnlist;
fip->fnlist = new_fnlist;
nfn_fields++;
- total_length += length;
}
}
@@ -2625,7 +2758,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;
- TYPE_NFN_FIELDS_TOTAL (type) = total_length;
}
return 1;
@@ -2637,11 +2769,11 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
keep parsing and it's time for error_type(). */
static int
-read_cpp_abbrev (struct field_info *fip, char **pp, struct type *type,
+read_cpp_abbrev (struct field_info *fip, const char **pp, struct type *type,
struct objfile *objfile)
{
- char *p;
- char *name;
+ const char *p;
+ const char *name;
char cpp_abbrev;
struct type *context;
@@ -2656,7 +2788,7 @@ 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
- 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);
@@ -2665,11 +2797,11 @@ read_cpp_abbrev (struct field_info *fip, char **pp, struct type *type,
case 'f': /* $vf -- a virtual function table pointer */
name = type_name_no_tag (context);
if (name == NULL)
- {
- name = "";
- }
- fip->list->field.name =
- obconcat (&objfile->objfile_obstack, vptr_name, name, "");
+ {
+ name = "";
+ }
+ fip->list->field.name = obconcat (&objfile->objfile_obstack,
+ vptr_name, name, (char *) NULL);
break;
case 'b': /* $vb -- a virtual bsomethingorother */
@@ -2677,24 +2809,25 @@ read_cpp_abbrev (struct field_info *fip, char **pp, struct type *type,
if (name == NULL)
{
complaint (&symfile_complaints,
- _("C++ abbreviated type name unknown at symtab pos %d"),
+ _("C++ abbreviated type name "
+ "unknown at symtab pos %d"),
symnum);
name = "FOO";
}
- fip->list->field.name =
- obconcat (&objfile->objfile_obstack, vb_name, name, "");
+ fip->list->field.name = obconcat (&objfile->objfile_obstack, vb_name,
+ name, (char *) NULL);
break;
default:
invalid_cpp_abbrev_complaint (*pp);
- fip->list->field.name =
- obconcat (&objfile->objfile_obstack,
- "INVALID_CPLUSPLUS_ABBREV", "", "");
+ fip->list->field.name = obconcat (&objfile->objfile_obstack,
+ "INVALID_CPLUSPLUS_ABBREV",
+ (char *) NULL);
break;
}
/* At this point, *pp points to the ':'. Skip it and read the
- field type. */
+ field type. */
p = ++(*pp);
if (p[-1] != ':')
@@ -2710,8 +2843,9 @@ read_cpp_abbrev (struct field_info *fip, char **pp, struct type *type,
{
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;
}
@@ -2731,14 +2865,16 @@ read_cpp_abbrev (struct field_info *fip, char **pp, struct type *type,
}
static void
-read_one_struct_field (struct field_info *fip, char **pp, char *p,
+read_one_struct_field (struct field_info *fip, const char **pp, const char *p,
struct type *type, struct objfile *objfile)
{
- fip->list->field.name =
- obsavestring (*pp, p - *pp, &objfile->objfile_obstack);
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
+
+ fip->list->field.name
+ = (const char *) obstack_copy0 (&objfile->objfile_obstack, *pp, p - *pp);
*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)++;
@@ -2755,7 +2891,7 @@ read_one_struct_field (struct field_info *fip, char **pp, char *p,
{
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 */
@@ -2784,7 +2920,9 @@ read_one_struct_field (struct field_info *fip, char **pp, char *p,
{
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");
@@ -2838,7 +2976,7 @@ read_one_struct_field (struct field_info *fip, char **pp, char *p,
== TARGET_CHAR_BIT * TYPE_LENGTH (field_type)
|| (TYPE_CODE (field_type) == TYPE_CODE_ENUM
&& FIELD_BITSIZE (fip->list->field)
- == gdbarch_int_bit (current_gdbarch))
+ == gdbarch_int_bit (gdbarch))
)
&&
FIELD_BITPOS (fip->list->field) % 8 == 0)
@@ -2870,11 +3008,11 @@ read_one_struct_field (struct field_info *fip, char **pp, char *p,
Returns 1 for success, 0 for failure. */
static int
-read_struct_fields (struct field_info *fip, char **pp, struct type *type,
+read_struct_fields (struct field_info *fip, const char **pp, struct type *type,
struct objfile *objfile)
{
- char *p;
- struct nextfield *new;
+ const char *p;
+ struct nextfield *newobj;
/* We better set p right now, in case there are no fields at all... */
@@ -2882,19 +3020,19 @@ 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
- start of the member function list. */
+ start of the member function list. */
/* 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. */
- 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 = XCNEW (struct nextfield);
+ make_cleanup (xfree, newobj);
+
+ newobj->next = fip->list;
+ fip->list = newobj;
/* Get the field name. */
p = *pp;
@@ -2914,7 +3052,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
- functions (if any), terminate scan loop and return. */
+ functions (if any), terminate scan loop and return. */
while (*p != ':' && *p != '\0')
{
@@ -2934,7 +3072,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
- scrub. */
+ scrub. */
fip->list = fip->list->next;
}
return 1;
@@ -2968,11 +3106,11 @@ read_struct_fields (struct field_info *fip, char **pp, struct type *type,
static int
-read_baseclasses (struct field_info *fip, char **pp, struct type *type,
+read_baseclasses (struct field_info *fip, const char **pp, struct type *type,
struct objfile *objfile)
{
int i;
- struct nextfield *new;
+ struct nextfield *newobj;
if (**pp != '!')
{
@@ -2980,13 +3118,14 @@ read_baseclasses (struct field_info *fip, char **pp, struct type *type,
}
else
{
- /* Skip the '!' baseclass information marker. */
+ /* Skip the '!' baseclass information marker. */
(*pp)++;
}
ALLOCATE_CPLUS_STRUCT_TYPE (type);
{
int nbits;
+
TYPE_N_BASECLASSES (type) = read_huge_number (pp, ',', &nbits, 0);
if (nbits != 0)
return 0;
@@ -3011,18 +3150,19 @@ read_baseclasses (struct field_info *fip, char **pp, struct type *type,
for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
{
- new = (struct nextfield *) xmalloc (sizeof (struct nextfield));
- make_cleanup (xfree, new);
- memset (new, 0, sizeof (struct nextfield));
- new->next = fip->list;
- fip->list = new;
- FIELD_BITSIZE (new->field) = 0; /* this should be an unpacked field! */
+ newobj = XCNEW (struct nextfield);
+ make_cleanup (xfree, newobj);
+
+ 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':
- /* Nothing to do. */
+ /* Nothing to do. */
break;
case '1':
SET_TYPE_FIELD_VIRTUAL (type, i);
@@ -3031,13 +3171,14 @@ read_baseclasses (struct field_info *fip, char **pp, struct type *type,
/* Unknown character. Complain and treat it as non-virtual. */
{
complaint (&symfile_complaints,
- _("Unknown virtual character `%c' for baseclass"), **pp);
+ _("Unknown virtual character `%c' for baseclass"),
+ **pp);
}
}
++(*pp);
- new->visibility = *(*pp)++;
- switch (new->visibility)
+ newobj->visibility = *(*pp)++;
+ switch (newobj->visibility)
{
case VISIBILITY_PRIVATE:
case VISIBILITY_PROTECTED:
@@ -3049,8 +3190,8 @@ read_baseclasses (struct field_info *fip, char **pp, struct type *type,
{
complaint (&symfile_complaints,
_("Unknown visibility `%c' for baseclass"),
- new->visibility);
- new->visibility = VISIBILITY_PUBLIC;
+ newobj->visibility);
+ newobj->visibility = VISIBILITY_PUBLIC;
}
}
@@ -3061,19 +3202,19 @@ read_baseclasses (struct field_info *fip, char **pp, struct type *type,
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
- field's name. */
+ field's name. */
- new->field.type = read_type (pp, objfile);
- new->field.name = type_name_no_tag (new->field.type);
+ newobj->field.type = read_type (pp, objfile);
+ newobj->field.name = type_name_no_tag (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
@@ -3091,14 +3232,14 @@ read_baseclasses (struct field_info *fip, char **pp, struct type *type,
so we can look for the vptr base class info. */
static int
-read_tilde_fields (struct field_info *fip, char **pp, struct type *type,
+read_tilde_fields (struct field_info *fip, const char **pp, struct type *type,
struct objfile *objfile)
{
- char *p;
+ const char *p;
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)++;
@@ -3111,7 +3252,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
- of constructors and/or destructors. */
+ of constructors and/or destructors. */
(*pp)++;
}
@@ -3139,30 +3280,32 @@ read_tilde_fields (struct field_info *fip, char **pp, struct type *type,
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)
{
- char *name = TYPE_FIELD_NAME (t, i);
+ const char *name = TYPE_FIELD_NAME (t, i);
+
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. */
complaint (&symfile_complaints,
- _("virtual function table pointer not found when defining class `%s'"),
+ _("virtual function table pointer "
+ "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:
@@ -3181,7 +3324,7 @@ attach_fn_fields_to_type (struct field_info *fip, struct type *type)
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;
@@ -3202,7 +3345,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
- bitfields. */
+ bitfields. */
for (scan = fip->list; scan != NULL; scan = scan->next)
{
@@ -3215,7 +3358,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
- 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 *)
@@ -3239,9 +3382,10 @@ attach_fields_to_type (struct field_info *fip, struct type *type,
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)
{
@@ -3266,7 +3410,8 @@ attach_fields_to_type (struct field_info *fip, struct type *type,
default:
/* Unknown visibility. Complain and treat it as public. */
{
- complaint (&symfile_complaints, _("Unknown visibility `%c' for field"),
+ complaint (&symfile_complaints,
+ _("Unknown visibility `%c' for field"),
fip->list->visibility);
}
break;
@@ -3282,8 +3427,8 @@ attach_fields_to_type (struct field_info *fip, struct type *type,
static void
complain_about_struct_wipeout (struct type *type)
{
- char *name = "";
- char *kind = "";
+ const char *name = "";
+ const char *kind = "";
if (TYPE_TAG_NAME (type))
{
@@ -3311,12 +3456,48 @@ complain_about_struct_wipeout (struct type *type)
_("struct/union type gets multiply defined: %s%s"), kind, name);
}
+/* Set the length for all variants of a same main_type, which are
+ connected in the closed chain.
+
+ This is something that needs to be done when a type is defined *after*
+ some cross references to this type have already been read. Consider
+ for instance the following scenario where we have the following two
+ stabs entries:
+
+ .stabs "t:p(0,21)=*(0,22)=k(0,23)=xsdummy:",160,0,28,-24
+ .stabs "dummy:T(0,23)=s16x:(0,1),0,3[...]"
+
+ A stubbed version of type dummy is created while processing the first
+ stabs entry. The length of that type is initially set to zero, since
+ it is unknown at this point. Also, a "constant" variation of type
+ "dummy" is created as well (this is the "(0,22)=k(0,23)" section of
+ the stabs line).
+
+ The second stabs entry allows us to replace the stubbed definition
+ with the real definition. However, we still need to adjust the length
+ of the "constant" variation of that type, as its length was left
+ untouched during the main type replacement... */
+
+static void
+set_length_in_type_chain (struct type *type)
+{
+ struct type *ntype = TYPE_CHAIN (type);
+
+ while (ntype != type)
+ {
+ if (TYPE_LENGTH(ntype) == 0)
+ TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
+ else
+ complain_about_struct_wipeout (ntype);
+ ntype = TYPE_CHAIN (ntype);
+ }
+}
/* Read the description of a structure (or union type) and return an object
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.
@@ -3327,7 +3508,7 @@ complain_about_struct_wipeout (struct type *type)
*/
static struct type *
-read_struct_type (char **pp, struct type *type, enum type_code type_code,
+read_struct_type (const char **pp, struct type *type, enum type_code type_code,
struct objfile *objfile)
{
struct cleanup *back_to;
@@ -3360,21 +3541,26 @@ read_struct_type (char **pp, struct type *type, enum type_code type_code,
INIT_CPLUS_SPECIFIC (type);
TYPE_CODE (type) = type_code;
- TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB;
+ TYPE_STUB (type) = 0;
/* First comes the total size in bytes. */
{
int nbits;
+
TYPE_LENGTH (type) = read_huge_number (pp, 0, &nbits, 0);
if (nbits != 0)
- return error_type (pp, objfile);
+ {
+ do_cleanups (back_to);
+ return error_type (pp, objfile);
+ }
+ set_length_in_type_chain (type);
}
/* Now read the baseclasses, if any, read the regular C struct or C++
class member fields, attach the fields to the type, read the C++
member functions, attach them to the type, and then read any tilde
- field (baseclass specifier for the class holding the main vtable). */
+ field (baseclass specifier for the class holding the main vtable). */
if (!read_baseclasses (&fi, pp, type, objfile)
|| !read_struct_fields (&fi, pp, type, objfile)
@@ -3396,7 +3582,7 @@ read_struct_type (char **pp, struct type *type, enum type_code type_code,
array. */
static struct type *
-read_array_type (char **pp, struct type *type,
+read_array_type (const char **pp, struct type *type,
struct objfile *objfile)
{
struct type *index_type, *element_type, *range_type;
@@ -3447,7 +3633,7 @@ read_array_type (char **pp, struct type *type,
}
range_type =
- create_range_type ((struct type *) NULL, index_type, lower, upper);
+ create_static_range_type ((struct type *) NULL, index_type, lower, upper);
type = create_array_type (type, element_type, range_type);
return type;
@@ -3459,10 +3645,11 @@ read_array_type (char **pp, struct type *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 (const char **pp, struct type *type,
struct objfile *objfile)
{
- char *p;
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ const char *p;
char *name;
long n;
struct symbol *sym;
@@ -3506,18 +3693,17 @@ read_enum_type (char **pp, struct type *type,
p = *pp;
while (*p != ':')
p++;
- name = obsavestring (*pp, p - *pp, &objfile->objfile_obstack);
+ name = (char *) obstack_copy0 (&objfile->objfile_obstack, *pp, p - *pp);
*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));
- DEPRECATED_SYMBOL_NAME (sym) = name;
- SYMBOL_LANGUAGE (sym) = current_subfile->language;
- SYMBOL_CLASS (sym) = LOC_CONST;
+ sym = allocate_symbol (objfile);
+ SYMBOL_SET_LINKAGE_NAME (sym, name);
+ SYMBOL_SET_LANGUAGE (sym, current_subfile->language,
+ &objfile->objfile_obstack);
+ SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_VALUE (sym) = n;
if (n < 0)
@@ -3531,11 +3717,12 @@ read_enum_type (char **pp, struct type *type,
/* Now fill in the fields of the type-structure. */
- TYPE_LENGTH (type) = gdbarch_int_bit (current_gdbarch) / HOST_CHAR_BIT;
+ TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
+ set_length_in_type_chain (type);
TYPE_CODE (type) = TYPE_CODE_ENUM;
- TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB;
+ TYPE_STUB (type) = 0;
if (unsigned_enum)
- TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
+ TYPE_UNSIGNED (type) = 1;
TYPE_NFIELDS (type) = nsyms;
TYPE_FIELDS (type) = (struct field *)
TYPE_ALLOC (type, sizeof (struct field) * nsyms);
@@ -3553,12 +3740,14 @@ read_enum_type (char **pp, struct type *type,
{
int last = syms == osyms ? o_nsyms : 0;
int j = syms->nsyms;
+
for (; --j >= last; --n)
{
struct symbol *xsym = syms->symbol[j];
+
SYMBOL_TYPE (xsym) = type;
- TYPE_FIELD_NAME (type, n) = DEPRECATED_SYMBOL_NAME (xsym);
- TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
+ TYPE_FIELD_NAME (type, n) = SYMBOL_LINKAGE_NAME (xsym);
+ SET_FIELD_ENUMVAL (TYPE_FIELD (type, n), SYMBOL_VALUE (xsym));
TYPE_FIELD_BITSIZE (type, n) = 0;
}
if (syms == osyms)
@@ -3582,20 +3771,20 @@ read_enum_type (char **pp, struct type *type,
FIXME. */
static struct type *
-read_sun_builtin_type (char **pp, int typenums[2], struct objfile *objfile)
+read_sun_builtin_type (const char **pp, int typenums[2], struct objfile *objfile)
{
int type_bits;
int nbits;
- int signed_type;
- enum type_code code = TYPE_CODE_INT;
+ int unsigned_type;
+ int boolean_type = 0;
switch (**pp)
{
case 's':
- signed_type = 1;
+ unsigned_type = 0;
break;
case 'u':
- signed_type = 0;
+ unsigned_type = 1;
break;
default:
return error_type (pp, objfile);
@@ -3612,7 +3801,7 @@ read_sun_builtin_type (char **pp, int typenums[2], struct objfile *objfile)
(*pp)++;
else if (**pp == 'b')
{
- code = TYPE_CODE_BOOL;
+ boolean_type = 1;
(*pp)++;
}
@@ -3624,12 +3813,12 @@ read_sun_builtin_type (char **pp, int typenums[2], struct objfile *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);
- /* 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);
@@ -3643,18 +3832,23 @@ read_sun_builtin_type (char **pp, int typenums[2], struct objfile *objfile)
++(*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
- 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 *
-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;
@@ -3667,21 +3861,21 @@ read_sun_floating_type (char **pp, int typenums[2], struct objfile *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);
+ nbits = nbytes * TARGET_CHAR_BIT;
+
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.
@@ -3702,19 +3896,19 @@ read_sun_floating_type (char **pp, int typenums[2], struct objfile *objfile)
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;
+ const char *p = *pp;
int sign = 1;
- int sign_bit;
+ int sign_bit = 0;
long n = 0;
- long sn = 0;
int radix = 10;
char overflow = 0;
int nbits = 0;
int c;
long upper_limit;
- int twos_complement_representation;
+ int twos_complement_representation = 0;
if (*p == '-')
{
@@ -3730,7 +3924,39 @@ read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
p++;
}
- twos_complement_representation = radix == 8 && twos_complement_bits > 0;
+ /* Skip extra zeros. */
+ while (*p == '0')
+ p++;
+
+ if (sign > 0 && radix == 8 && twos_complement_bits > 0)
+ {
+ /* Octal, possibly signed. Check if we have enough chars for a
+ negative number. */
+
+ size_t len;
+ const char *p1 = p;
+
+ while ((c = *p1) >= '0' && c < '8')
+ p1++;
+
+ len = p1 - p;
+ if (len > twos_complement_bits / 3
+ || (twos_complement_bits % 3 == 0
+ && 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. */
+ sign_bit = (twos_complement_bits % 3 + 2) % 3;
+ c = *p - '0';
+ if (c & (1 << sign_bit))
+ {
+ /* Definitely signed. */
+ twos_complement_representation = 1;
+ sign = -1;
+ }
+ }
+ }
+
upper_limit = LONG_MAX / radix;
while ((c = *p++) >= '0' && c < ('0' + radix))
@@ -3739,36 +3965,32 @@ read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
{
if (twos_complement_representation)
{
- /* Octal, signed, twos complement representation. In this case,
- sn is the signed value, n is the corresponding absolute
- value. signed_bit is the position of the sign bit in the
- first three bits. */
- if (sn == 0)
- {
- sign_bit = (twos_complement_bits % 3 + 2) % 3;
- sn = c - '0' - ((2 * (c - '0')) | (2 << sign_bit));
- }
+ /* Octal, signed, twos complement representation. In
+ this case, n is the corresponding absolute value. */
+ if (n == 0)
+ {
+ long sn = c - '0' - ((2 * (c - '0')) | (2 << sign_bit));
+
+ n = -sn;
+ }
else
{
- sn *= radix;
- sn += c - '0';
+ n *= radix;
+ n -= c - '0';
}
-
- if (sn < 0)
- n = -sn;
}
else
{
/* 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
- what GCC does. */
+ what GCC does. */
if (radix == 8)
{
if (nbits == 0)
@@ -3799,6 +4021,15 @@ read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
else
--p;
+ if (radix == 8 && twos_complement_bits > 0 && nbits > twos_complement_bits)
+ {
+ /* We were supposed to parse a number with maximum
+ TWOS_COMPLEMENT_BITS bits, but something went wrong. */
+ if (bits != NULL)
+ *bits = -1;
+ return 0;
+ }
+
*pp = p;
if (overflow)
{
@@ -3812,8 +4043,9 @@ read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
}
/* -0x7f is the same as 0x80. So deal with it by adding one to
- the number of bits. */
- if (sign == -1)
+ the number of bits. Two's complement represention octals
+ can't have a '-' in front. */
+ if (sign == -1 && !twos_complement_representation)
++nbits;
if (bits)
*bits = nbits;
@@ -3822,20 +4054,18 @@ read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
{
if (bits)
*bits = 0;
- if (twos_complement_representation)
- return sn;
- else
- return n * sign;
+ return n * sign;
}
/* It's *BITS which has the interesting information. */
return 0;
}
static struct type *
-read_range_type (char **pp, int typenums[2], int type_size,
+read_range_type (const char **pp, int typenums[2], int type_size,
struct objfile *objfile)
{
- char *orig_pp = *pp;
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ const char *orig_pp = *pp;
int rangenums[2];
long n2, n3;
int n2bits, n3bits;
@@ -3880,7 +4110,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
- 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)
{
@@ -3909,18 +4139,14 @@ read_range_type (char **pp, int typenums[2], int type_size,
}
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)
- 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.
@@ -3932,41 +4158,45 @@ 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
- 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
- = init_type (TYPE_CODE_FLT, n2, 0, NULL, objfile);
+ = dbx_init_float_type (objfile, n2 * TARGET_CHAR_BIT);
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;
}
- /* If the upper bound is -1, it must really be an unsigned int. */
+ /* If the upper bound is -1, it must really be an unsigned integral. */
else if (n2 == 0 && n3 == -1)
{
- /* It is unsigned int or unsigned long. */
- /* GCC 2.3.3 uses this for long long too, but that is just a GDB 3.5
- compatibility hack. */
- return init_type (TYPE_CODE_INT,
- gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
- TYPE_FLAG_UNSIGNED, NULL, objfile);
+ int bits = type_size;
+
+ if (bits <= 0)
+ {
+ /* We don't know its size. It is unsigned int or unsigned
+ long. GCC 2.3.3 uses this for long long too, but that is
+ just a GDB 3.5 compatibility hack. */
+ bits = gdbarch_int_bit (gdbarch);
+ }
+
+ 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)
- 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)
{
@@ -3976,8 +4206,7 @@ read_range_type (char **pp, int typenums[2], int type_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
@@ -3991,8 +4220,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" */
- 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
@@ -4001,16 +4229,16 @@ read_range_type (char **pp, int typenums[2], int type_size,
else if (n3 == 0 && n2 < 0
&& (self_subrange
|| n2 == -gdbarch_long_long_bit
- (current_gdbarch) / TARGET_CHAR_BIT))
- return init_type (TYPE_CODE_INT, -n2, 0, NULL, objfile);
+ (gdbarch) / TARGET_CHAR_BIT))
+ return init_integer_type (objfile, -n2 * TARGET_CHAR_BIT, 0, NULL);
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)
- return init_type (TYPE_CODE_INT, 2, 0, NULL, objfile);
+ return init_integer_type (objfile, 16, 0, NULL);
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
@@ -4018,27 +4246,22 @@ read_range_type (char **pp, int typenums[2], int type_size,
handle_true_range:
if (self_subrange)
- index_type = builtin_type_int;
+ index_type = objfile_type (objfile)->builtin_int;
else
- index_type = *dbx_lookup_type (rangenums);
+ index_type = *dbx_lookup_type (rangenums, objfile);
if (index_type == NULL)
{
/* Does this actually ever happen? Is that why we are worrying
about dealing with it rather than just calling error_type? */
- static struct type *range_type_index;
-
complaint (&symfile_complaints,
_("base type %d of range type is not defined"), rangenums[1]);
- if (range_type_index == NULL)
- range_type_index =
- init_type (TYPE_CODE_INT,
- gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
- 0, "range type index type", NULL);
- index_type = range_type_index;
+
+ 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 ((struct type *) NULL, index_type, n2, n3);
return (result_type);
}
@@ -4047,11 +4270,11 @@ handle_true_range:
if there is an error. */
static struct field *
-read_args (char **pp, int end, struct objfile *objfile, int *nargsp,
+read_args (const char **pp, int end, struct objfile *objfile, int *nargsp,
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;
@@ -4064,9 +4287,19 @@ read_args (char **pp, int end, struct objfile *objfile, int *nargsp,
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)
+ {
+ /* We should read at least the THIS parameter here. Some broken stabs
+ output contained `(0,41),(0,42)=@s8;-16;,(0,43),(0,1);' where should
+ have been present ";-16,(0,43)" reference instead. This way the
+ excessive ";" marker prematurely stops the parameters parsing. */
- if (TYPE_CODE (types[n - 1]) != TYPE_CODE_VOID)
+ complaint (&symfile_complaints, _("Invalid (empty) method arguments"));
+ *varargsp = 0;
+ }
+ else if (TYPE_CODE (types[n - 1]) != TYPE_CODE_VOID)
*varargsp = 1;
else
{
@@ -4074,8 +4307,7 @@ read_args (char **pp, int end, struct objfile *objfile, int *nargsp,
*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;
@@ -4102,7 +4334,7 @@ static char *common_block_name;
to remain after this function returns. */
void
-common_block_start (char *name, struct objfile *objfile)
+common_block_start (const char *name, struct objfile *objfile)
{
if (common_block_name != NULL)
{
@@ -4111,8 +4343,8 @@ common_block_start (char *name, struct objfile *objfile)
}
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_name = (char *) obstack_copy0 (&objfile->objfile_obstack, name,
+ strlen (name));
}
/* Process a N_ECOMM symbol. */
@@ -4127,7 +4359,7 @@ common_block_end (struct objfile *objfile)
symbol for the common block name for later fixup. */
int i;
struct symbol *sym;
- struct pending *new = 0;
+ struct pending *newobj = 0;
struct pending *next;
int j;
@@ -4137,12 +4369,10 @@ common_block_end (struct objfile *objfile)
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 */
- DEPRECATED_SYMBOL_NAME (sym) = common_block_name;
- SYMBOL_CLASS (sym) = LOC_BLOCK;
+ sym = allocate_symbol (objfile);
+ /* Note: common_block_name already saved on objfile_obstack. */
+ SYMBOL_SET_LINKAGE_NAME (sym, common_block_name);
+ SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
/* Now we copy all the symbols which have been defined since the BCOMM. */
@@ -4152,7 +4382,7 @@ common_block_end (struct objfile *objfile)
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], &newobj);
}
/* Copy however much of COMMON_BLOCK we need. If COMMON_BLOCK is
@@ -4161,14 +4391,14 @@ common_block_end (struct objfile *objfile)
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], &newobj);
- SYMBOL_TYPE (sym) = (struct type *) new;
+ SYMBOL_TYPE (sym) = (struct type *) newobj;
/* Should we be putting local_symbols back to what it was?
Does it matter? */
- i = hashname (DEPRECATED_SYMBOL_NAME (sym));
+ i = hashname (SYMBOL_LINKAGE_NAME (sym));
SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
global_sym_chain[i] = sym;
common_block_name = NULL;
@@ -4179,12 +4409,14 @@ common_block_end (struct objfile *objfile)
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);
+
for (; next; next = next->next)
{
int j;
+
for (j = next->nsyms - 1; j >= 0; j--)
SYMBOL_VALUE_ADDRESS (next->symbol[j]) += valu;
}
@@ -4254,8 +4486,8 @@ add_undefined_type (struct type *type, int typenums[2])
/* Try to fix all undefined types pushed on the UNDEF_TYPES vector. */
-void
-cleanup_undefined_types_noname (void)
+static void
+cleanup_undefined_types_noname (struct objfile *objfile)
{
int i;
@@ -4264,9 +4496,16 @@ cleanup_undefined_types_noname (void)
struct nat nat = noname_undefs[i];
struct type **type;
- type = dbx_lookup_type (nat.typenums);
+ type = dbx_lookup_type (nat.typenums, objfile);
if (nat.type != *type && TYPE_CODE (*type) != TYPE_CODE_UNDEF)
- replace_type (nat.type, *type);
+ {
+ /* The instance flags of the undefined type are still unset,
+ and needs to be copied over from the reference type.
+ Since replace_type expects them to be identical, we need
+ to set these flags manually before hand. */
+ TYPE_INSTANCE_FLAGS (nat.type) = TYPE_INSTANCE_FLAGS (*type);
+ replace_type (nat.type, *type);
+ }
}
noname_undefs_length = 0;
@@ -4282,11 +4521,30 @@ cleanup_undefined_types_noname (void)
yet defined at the time a pointer to it was made.
Fix: Do a full lookup on the struct/union tag. */
-void
+static void
cleanup_undefined_types_1 (void)
{
struct type **type;
+ /* Iterate over every undefined type, and look for a symbol whose type
+ matches our undefined type. The symbol matches if:
+ 1. It is a typedef in the STRUCT domain;
+ 2. It has the same name, and same type code;
+ 3. The instance flags are identical.
+
+ It is important to check the instance flags, because we have seen
+ examples where the debug info contained definitions such as:
+
+ "foo_t:t30=B31=xefoo_t:"
+
+ In this case, we have created an undefined type named "foo_t" whose
+ instance flags is null (when processing "xefoo_t"), and then created
+ another type with the same name, but with different instance flags
+ ('B' means volatile). I think that the definition above is wrong,
+ since the same type cannot be volatile and non-volatile at the same
+ time, but we need to be able to cope with it when it happens. The
+ approach taken here is to treat these two types as different. */
+
for (type = undef_types; type < undef_types + undef_types_length; type++)
{
switch (TYPE_CODE (*type))
@@ -4304,10 +4562,10 @@ cleanup_undefined_types_1 (void)
{
struct pending *ppt;
int i;
- /* Name of the type, without "struct" or "union" */
- char *typename = TYPE_TAG_NAME (*type);
+ /* Name of the type, without "struct" or "union". */
+ const char *type_name = TYPE_TAG_NAME (*type);
- if (typename == NULL)
+ if (type_name == NULL)
{
complaint (&symfile_complaints, _("need a type name"));
break;
@@ -4322,7 +4580,10 @@ cleanup_undefined_types_1 (void)
&& SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
&& (TYPE_CODE (SYMBOL_TYPE (sym)) ==
TYPE_CODE (*type))
- && strcmp (DEPRECATED_SYMBOL_NAME (sym), typename) == 0)
+ && (TYPE_INSTANCE_FLAGS (*type) ==
+ TYPE_INSTANCE_FLAGS (SYMBOL_TYPE (sym)))
+ && strcmp (SYMBOL_LINKAGE_NAME (sym),
+ type_name) == 0)
replace_type (*type, SYMBOL_TYPE (sym));
}
}
@@ -4348,10 +4609,10 @@ cleanup_undefined_types_1 (void)
this unit. */
void
-cleanup_undefined_types (void)
+cleanup_undefined_stabs_types (struct objfile *objfile)
{
cleanup_undefined_types_1 ();
- cleanup_undefined_types_noname ();
+ cleanup_undefined_types_noname (objfile);
}
/* Scan through all of the global symbols defined in the object file,
@@ -4388,9 +4649,7 @@ scan_file_globals (struct objfile *objfile)
if (hash >= HASHSIZE)
return;
- for (msymbol = resolve_objfile->msymbols;
- msymbol && DEPRECATED_SYMBOL_NAME (msymbol) != NULL;
- msymbol++)
+ ALL_OBJFILE_MSYMBOLS (resolve_objfile, msymbol)
{
QUIT;
@@ -4408,17 +4667,17 @@ scan_file_globals (struct objfile *objfile)
prev = NULL;
/* Get the hash index and check all the symbols
- under that hash index. */
+ under that hash index. */
- hash = hashname (DEPRECATED_SYMBOL_NAME (msymbol));
+ hash = hashname (MSYMBOL_LINKAGE_NAME (msymbol));
for (sym = global_sym_chain[hash]; sym;)
{
- if (DEPRECATED_SYMBOL_NAME (msymbol)[0] == DEPRECATED_SYMBOL_NAME (sym)[0] &&
- strcmp (DEPRECATED_SYMBOL_NAME (msymbol) + 1, DEPRECATED_SYMBOL_NAME (sym) + 1) == 0)
+ if (strcmp (MSYMBOL_LINKAGE_NAME (msymbol),
+ SYMBOL_LINKAGE_NAME (sym)) == 0)
{
/* 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);
@@ -4436,14 +4695,15 @@ scan_file_globals (struct objfile *objfile)
if (SYMBOL_CLASS (sym) == LOC_BLOCK)
{
fix_common_block (sym,
- SYMBOL_VALUE_ADDRESS (msymbol));
+ MSYMBOL_VALUE_ADDRESS (resolve_objfile,
+ msymbol));
}
else
{
SYMBOL_VALUE_ADDRESS (sym)
- = SYMBOL_VALUE_ADDRESS (msymbol);
+ = MSYMBOL_VALUE_ADDRESS (resolve_objfile, msymbol);
}
- SYMBOL_SECTION (sym) = SYMBOL_SECTION (msymbol);
+ SYMBOL_SECTION (sym) = MSYMBOL_SECTION (msymbol);
}
if (prev)
@@ -4483,11 +4743,12 @@ scan_file_globals (struct objfile *objfile)
/* Complain about unresolved common block symbols. */
if (SYMBOL_CLASS (prev) == LOC_STATIC)
- SYMBOL_CLASS (prev) = LOC_UNRESOLVED;
+ SYMBOL_ACLASS_INDEX (prev) = LOC_UNRESOLVED;
else
complaint (&symfile_complaints,
- _("%s: common block `%s' from global_sym_chain unresolved"),
- objfile->name, DEPRECATED_SYMBOL_NAME (prev));
+ _("%s: common block `%s' from "
+ "global_sym_chain unresolved"),
+ objfile_name (objfile), SYMBOL_PRINT_NAME (prev));
}
}
memset (global_sym_chain, 0, sizeof (global_sym_chain));
@@ -4514,7 +4775,7 @@ stabsread_new_init (void)
}
/* Initialize anything that needs initializing at the same time as
- start_symtab() is called. */
+ start_symtab() is called. */
void
start_stabs (void)
@@ -4529,7 +4790,7 @@ start_stabs (void)
common_block_name = NULL;
}
-/* Call after end_symtab() */
+/* Call after end_symtab(). */
void
end_stabs (void)
@@ -4556,10 +4817,11 @@ 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. */
-static char *
-find_name_end (char *name)
+static const char *
+find_name_end (const char *name)
{
- char *s = name;
+ const char *s = name;
+
if (s[0] == '-' || *s == '+')
{
/* Must be an ObjC method symbol. */
@@ -4580,18 +4842,23 @@ find_name_end (char *name)
}
}
-/* Initializer for this module */
+/* Initializer for this module. */
void
_initialize_stabsread (void)
{
+ rs6000_builtin_type_data = register_objfile_data ();
+
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 = (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);
}