/* Support routines for decoding "stabs" debugging information format.
- Copyright (C) 1986-2015 Free Software Foundation, Inc.
+ Copyright (C) 1986-2016 Free Software Foundation, Inc.
This file is part of GDB.
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);
}
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)
{
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 / TARGET_CHAR_BIT, NULL);
+
+ return type;
+}
+
/* for all the stabs in a given stab vector, build appropriate types
and fix their symbols in given symbol vector. */
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
SYMBOL_SET_LINKAGE_NAME
- (sym, obstack_copy0 (&objfile->objfile_obstack,
- name, pp - name));
+ (sym, (char *) obstack_copy0 (&objfile->objfile_obstack,
+ name, pp - name));
pp += 2;
if (*(pp - 1) == 'F' || *(pp - 1) == 'f')
{
{
int regno = gdbarch_stab_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
- if (regno >= gdbarch_num_regs (gdbarch)
- + gdbarch_num_pseudo_regs (gdbarch))
+ if (regno < 0
+ || regno >= (gdbarch_num_regs (gdbarch)
+ + gdbarch_num_pseudo_regs (gdbarch)))
{
reg_value_complaint (regno,
gdbarch_num_regs (gdbarch)
int deftype;
int synonym = 0;
int i;
- char *new_name = NULL;
/* We would like to eliminate nameless symbols, but keep their types.
E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
else
{
normal:
+ std::string new_name;
+
if (SYMBOL_LANGUAGE (sym) == language_cplus)
{
- char *name = alloca (p - string + 1);
+ char *name = (char *) alloca (p - string + 1);
memcpy (name, string, p - string);
name[p - string] = '\0';
new_name = cp_canonicalize_string (name);
}
- if (new_name != NULL)
+ if (!new_name.empty ())
{
- SYMBOL_SET_NAMES (sym, new_name, strlen (new_name), 1, objfile);
- xfree (new_name);
+ SYMBOL_SET_NAMES (sym,
+ new_name.c_str (), new_name.length (),
+ 1, objfile);
}
else
SYMBOL_SET_NAMES (sym, string, p - string, 1, objfile);
probably has the necessary code. */
dbl_type = objfile_type (objfile)->builtin_double;
- dbl_valu =
- obstack_alloc (&objfile->objfile_obstack,
- TYPE_LENGTH (dbl_type));
+ dbl_valu
+ = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack,
+ TYPE_LENGTH (dbl_type));
store_typed_floating (dbl_valu, dbl_type, d);
SYMBOL_TYPE (sym) = dbl_type;
SYMBOL_TYPE (sym) = create_array_type (NULL,
objfile_type (objfile)->builtin_char,
range_type);
- string_value = obstack_alloc (&objfile->objfile_obstack, ind + 1);
+ string_value
+ = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, ind + 1);
memcpy (string_value, string_local, ind + 1);
p++;
type_name = NULL;
if (current_subfile->language == language_cplus)
{
- char *new_name, *name = alloca (p - *pp + 1);
+ char *name = (char *) alloca (p - *pp + 1);
memcpy (name, *pp, p - *pp);
name[p - *pp] = '\0';
- new_name = cp_canonicalize_string (name);
- if (new_name != NULL)
+
+ std::string new_name = cp_canonicalize_string (name);
+ if (!new_name.empty ())
{
- type_name = obstack_copy0 (&objfile->objfile_obstack,
- new_name, strlen (new_name));
- xfree (new_name);
+ type_name
+ = (char *) obstack_copy0 (&objfile->objfile_obstack,
+ new_name.c_str (),
+ new_name.length ());
}
}
if (type_name == NULL)
while (**pp && **pp != '#')
{
struct type *arg_type = read_type (pp, objfile);
- struct type_list *newobj = alloca (sizeof (*newobj));
+ struct type_list *newobj = XALLOCA (struct type_list);
newobj->type = arg_type;
newobj->next = arg_types;
arg_types = newobj;
static struct type *
rs6000_builtin_type (int typenum, struct objfile *objfile)
{
- struct type **negative_types = objfile_data (objfile,
- rs6000_builtin_type_data);
+ struct type **negative_types
+ = (struct type **) objfile_data (objfile, rs6000_builtin_type_data);
/* We recognize types numbered from -NUMBER_RECOGNIZED to -1. */
#define NUMBER_RECOGNIZED 34
is other than 32 bits, then it should use a new negative type
number (or avoid negative type numbers for that case).
See stabs.texinfo. */
- rettype = init_type (TYPE_CODE_INT, 4, 0, "int", objfile);
+ rettype = init_integer_type (objfile, 32, 0, "int");
break;
case 2:
- rettype = init_type (TYPE_CODE_INT, 1, 0, "char", objfile);
+ rettype = init_integer_type (objfile, 8, 0, "char");
+ TYPE_NOSIGN (rettype) = 1;
break;
case 3:
- rettype = init_type (TYPE_CODE_INT, 2, 0, "short", objfile);
+ rettype = init_integer_type (objfile, 16, 0, "short");
break;
case 4:
- rettype = init_type (TYPE_CODE_INT, 4, 0, "long", objfile);
+ rettype = init_integer_type (objfile, 32, 0, "long");
break;
case 5:
- rettype = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED,
- "unsigned char", objfile);
+ rettype = init_integer_type (objfile, 8, 1, "unsigned char");
break;
case 6:
- rettype = init_type (TYPE_CODE_INT, 1, 0, "signed char", objfile);
+ rettype = init_integer_type (objfile, 8, 0, "signed char");
break;
case 7:
- rettype = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED,
- "unsigned short", objfile);
+ rettype = init_integer_type (objfile, 16, 1, "unsigned short");
break;
case 8:
- rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
- "unsigned int", objfile);
+ rettype = init_integer_type (objfile, 32, 1, "unsigned int");
break;
case 9:
- rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
- "unsigned", objfile);
+ rettype = init_integer_type (objfile, 32, 1, "unsigned");
break;
case 10:
- rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
- "unsigned long", objfile);
+ rettype = init_integer_type (objfile, 32, 1, "unsigned long");
break;
case 11:
- rettype = init_type (TYPE_CODE_VOID, 1, 0, "void", objfile);
+ rettype = init_type (objfile, TYPE_CODE_VOID, 1, "void");
break;
case 12:
/* IEEE single precision (32 bit). */
- rettype = init_type (TYPE_CODE_FLT, 4, 0, "float", objfile);
+ rettype = init_float_type (objfile, 32, "float",
+ floatformats_ieee_single);
break;
case 13:
/* IEEE double precision (64 bit). */
- rettype = init_type (TYPE_CODE_FLT, 8, 0, "double", objfile);
+ rettype = init_float_type (objfile, 64, "double",
+ floatformats_ieee_double);
break;
case 14:
/* This is an IEEE double on the RS/6000, and different machines with
different sizes for "long double" should use different negative
type numbers. See stabs.texinfo. */
- rettype = init_type (TYPE_CODE_FLT, 8, 0, "long double", objfile);
+ rettype = init_float_type (objfile, 64, "long double",
+ floatformats_ieee_double);
break;
case 15:
- rettype = init_type (TYPE_CODE_INT, 4, 0, "integer", objfile);
+ rettype = init_integer_type (objfile, 32, 0, "integer");
break;
case 16:
- rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
- "boolean", objfile);
+ rettype = init_boolean_type (objfile, 32, 1, "boolean");
break;
case 17:
- rettype = init_type (TYPE_CODE_FLT, 4, 0, "short real", objfile);
+ rettype = init_float_type (objfile, 32, "short real",
+ floatformats_ieee_single);
break;
case 18:
- rettype = init_type (TYPE_CODE_FLT, 8, 0, "real", objfile);
+ rettype = init_float_type (objfile, 64, "real",
+ floatformats_ieee_double);
break;
case 19:
- rettype = init_type (TYPE_CODE_ERROR, 0, 0, "stringptr", objfile);
+ rettype = init_type (objfile, TYPE_CODE_ERROR, 0, "stringptr");
break;
case 20:
- rettype = init_type (TYPE_CODE_CHAR, 1, TYPE_FLAG_UNSIGNED,
- "character", objfile);
+ rettype = init_character_type (objfile, 8, 1, "character");
break;
case 21:
- rettype = init_type (TYPE_CODE_BOOL, 1, TYPE_FLAG_UNSIGNED,
- "logical*1", objfile);
+ rettype = init_boolean_type (objfile, 8, 1, "logical*1");
break;
case 22:
- rettype = init_type (TYPE_CODE_BOOL, 2, TYPE_FLAG_UNSIGNED,
- "logical*2", objfile);
+ rettype = init_boolean_type (objfile, 16, 1, "logical*2");
break;
case 23:
- rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
- "logical*4", objfile);
+ rettype = init_boolean_type (objfile, 32, 1, "logical*4");
break;
case 24:
- rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
- "logical", objfile);
+ rettype = init_boolean_type (objfile, 32, 1, "logical");
break;
case 25:
/* Complex type consisting of two IEEE single precision values. */
- rettype = init_type (TYPE_CODE_COMPLEX, 8, 0, "complex", objfile);
- TYPE_TARGET_TYPE (rettype) = init_type (TYPE_CODE_FLT, 4, 0, "float",
- objfile);
+ rettype = init_complex_type (objfile, "complex",
+ rs6000_builtin_type (12, objfile));
break;
case 26:
/* Complex type consisting of two IEEE double precision values. */
- rettype = init_type (TYPE_CODE_COMPLEX, 16, 0, "double complex", NULL);
- TYPE_TARGET_TYPE (rettype) = init_type (TYPE_CODE_FLT, 8, 0, "double",
- objfile);
+ rettype = init_complex_type (objfile, "double complex",
+ rs6000_builtin_type (13, objfile));
break;
case 27:
- rettype = init_type (TYPE_CODE_INT, 1, 0, "integer*1", objfile);
+ rettype = init_integer_type (objfile, 8, 0, "integer*1");
break;
case 28:
- rettype = init_type (TYPE_CODE_INT, 2, 0, "integer*2", objfile);
+ rettype = init_integer_type (objfile, 16, 0, "integer*2");
break;
case 29:
- rettype = init_type (TYPE_CODE_INT, 4, 0, "integer*4", objfile);
+ rettype = init_integer_type (objfile, 32, 0, "integer*4");
break;
case 30:
- rettype = init_type (TYPE_CODE_CHAR, 2, 0, "wchar", objfile);
+ rettype = init_character_type (objfile, 16, 0, "wchar");
break;
case 31:
- rettype = init_type (TYPE_CODE_INT, 8, 0, "long long", objfile);
+ rettype = init_integer_type (objfile, 64, 0, "long long");
break;
case 32:
- rettype = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
- "unsigned long long", objfile);
+ rettype = init_integer_type (objfile, 64, 1, "unsigned long long");
break;
case 33:
- rettype = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
- "logical*8", objfile);
+ rettype = init_integer_type (objfile, 64, 1, "logical*8");
break;
case 34:
- rettype = init_type (TYPE_CODE_INT, 8, 0, "integer*8", objfile);
+ rettype = init_integer_type (objfile, 64, 0, "integer*8");
break;
}
negative_types[-typenum] = rettype;
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]))
{
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)
/* 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, (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;
dem_opname, 0);
if (ret)
new_fnlist->fn_fieldlist.name
- = obstack_copy0 (&objfile->objfile_obstack,
- dem_opname, strlen (dem_opname));
+ = ((const char *)
+ obstack_copy0 (&objfile->objfile_obstack, dem_opname,
+ strlen (dem_opname)));
xfree (main_fn_name);
}
{
struct gdbarch *gdbarch = get_objfile_arch (objfile);
- fip->list->field.name =
- obstack_copy0 (&objfile->objfile_obstack, *pp, p - *pp);
+ 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. */
{
STABS_CONTINUE (pp, objfile);
/* Get space to record the next field's data. */
- newobj = (struct nextfield *) xmalloc (sizeof (struct nextfield));
+ newobj = XCNEW (struct nextfield);
make_cleanup (xfree, newobj);
- memset (newobj, 0, sizeof (struct nextfield));
+
newobj->next = fip->list;
fip->list = newobj;
for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
{
- newobj = (struct nextfield *) xmalloc (sizeof (struct nextfield));
+ newobj = XCNEW (struct nextfield);
make_cleanup (xfree, newobj);
- memset (newobj, 0, sizeof (struct nextfield));
+
newobj->next = fip->list;
fip->list = newobj;
FIELD_BITSIZE (newobj->field) = 0; /* This should be an unpacked
p = *pp;
while (*p != ':')
p++;
- name = obstack_copy0 (&objfile->objfile_obstack, *pp, p - *pp);
+ name = (char *) obstack_copy0 (&objfile->objfile_obstack, *pp, p - *pp);
*pp = p + 1;
n = read_huge_number (pp, ',', &nbits, 0);
if (nbits != 0)
{
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);
(*pp)++;
else if (**pp == 'b')
{
- code = TYPE_CODE_BOOL;
+ boolean_type = 1;
(*pp)++;
}
++(*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, 1, 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 *
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.
}
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, 1, NULL);
/* If n3 is zero and n2 is positive, we want a floating type, and n2
is the width in bytes.
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;
}
bits = gdbarch_int_bit (gdbarch);
}
- return init_type (TYPE_CODE_INT, bits / TARGET_CHAR_BIT,
- TYPE_FLAG_UNSIGNED, NULL, objfile);
+ return init_integer_type (objfile, bits, 1, NULL);
}
/* Special case: char is defined (Who knows why) as a subrange of
itself with range 0-127. */
else if (self_subrange && n2 == 0 && n3 == 127)
- return init_type (TYPE_CODE_INT, 1, TYPE_FLAG_NOSIGN, NULL, objfile);
-
+ {
+ struct type *type = init_integer_type (objfile, 1, 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)
{
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
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
&& (self_subrange
|| n2 == -gdbarch_long_long_bit
(gdbarch) / TARGET_CHAR_BIT))
- return init_type (TYPE_CODE_INT, -n2, 0, NULL, objfile);
+ return init_integer_type (objfile, -n2 * TARGET_CHAR_BIT, 0, NULL);
else if (n2 == -n3 - 1)
{
if (n3 == 0x7f)
- 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
*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;
}
common_block = local_symbols;
common_block_i = local_symbols ? local_symbols->nsyms : 0;
- common_block_name = obstack_copy0 (&objfile->objfile_obstack,
- name, strlen (name));
+ common_block_name = (char *) obstack_copy0 (&objfile->objfile_obstack, name,
+ strlen (name));
}
/* Process a N_ECOMM symbol. */
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);