/* ARGSUSED */
struct symbol *
define_symbol (valu, string, desc, type, objfile)
- unsigned int valu;
+ CORE_ADDR valu;
char *string;
int desc;
int type;
int xtypenums[2];
char type_descriptor;
+ /* Size in bits of type if specified by a type attribute, or -1 if
+ there is no size attribute. */
+ int type_size = -1;
+
/* Read type number if present. The type number may be omitted.
for instance in a two-dimensional array declared with type
"ar1;1;10;ar1;1;10;4". */
break;
else
{
- /* Type attributes; skip to the semicolon. */
+ /* Type attributes. */
+ char *attr = p;
+
+ /* Skip to the semicolon. */
while (*p != ';' && *p != '\0')
++p;
*pp = p;
else
/* Skip the semicolon. */
++*pp;
+
+ switch (*attr)
+ {
+ case 's':
+ type_size = atoi (attr + 1);
+ if (type_size <= 0)
+ type_size = -1;
+ break;
+ default:
+ /* Ignore unrecognized type attributes, so future compilers
+ can invent new ones. */
+ break;
+ }
}
}
/* Skip the type descriptor, we get it below with (*pp)[-1]. */
case '9':
case '(':
- /* The type is being defined to another type. When we support
- Ada (and arguably for C, so "whatis foo" can give "size_t",
- "wchar_t", or whatever it was declared as) we'll need to
- allocate a distinct type here rather than returning the
- existing one. GCC is currently (deliberately) incapable of
- putting out the debugging information to do that, however. */
-
(*pp)--;
if (read_type_number (pp, xtypenums) != 0)
return error_type (pp);
+
if (typenums[0] == xtypenums[0] && typenums[1] == xtypenums[1])
/* It's being defined as itself. That means it is "void". */
type = init_type (TYPE_CODE_VOID, 0, 0, NULL, objfile);
else
- type = *dbx_lookup_type (xtypenums);
+ {
+ struct type *xtype = *dbx_lookup_type (xtypenums);
+
+ /* This can happen if we had '-' followed by a garbage character,
+ for example. */
+ if (xtype == NULL)
+ return error_type (pp);
+
+ /* The type is being defined to another type. So we copy the type.
+ This loses if we copy a C++ class and so we lose track of how
+ the names are mangled (but g++ doesn't output stabs like this
+ now anyway). */
+
+ type = alloc_type (objfile);
+ memcpy (type, xtype, sizeof (struct type));
+
+ /* The idea behind clearing the names is that the only purpose
+ for defining a type to another type is so that the name of
+ one can be different. So we probably don't need to worry much
+ about the case where the compiler doesn't give a name to the
+ new type. */
+ TYPE_NAME (type) = NULL;
+ TYPE_TAG_NAME (type) = NULL;
+ }
if (typenums[0] != -1)
*dbx_lookup_type (typenums) = type;
- /* This can happen if we had '-' followed by a garbage character,
- for example. */
- if (type == NULL)
- return error_type (pp);
break;
/* In the following types, we must be sure to overwrite any existing
return error_type (pp);
}
+ /* Size specified in a type attribute overrides any other size. */
+ if (type_size != -1)
+ TYPE_LENGTH (type) = type_size / TARGET_CHAR_BIT;
+
return type;
}
\f
#define NUMBER_RECOGNIZED 30
/* This includes an empty slot for type number -0. */
static struct type *negative_types[NUMBER_RECOGNIZED + 1];
- struct type *rettype;
+ struct type *rettype = NULL;
if (typenum >= 0 || typenum < -NUMBER_RECOGNIZED)
{
char got_signed = 0;
char got_unsigned = 0;
/* Number of bits in the type. */
- int nbits;
+ int nbits = 0;
/* Range from 0 to <large number> is an unsigned large integral type. */
if ((n2bits == 0 && n2 == 0) && n3bits != 0)
nbits = n3bits;
}
/* Range from <large number> to <large number>-1 is a large signed
- integral type. */
- else if (n2bits != 0 && n3bits != 0 && n2bits == n3bits + 1)
+ integral type. Take care of the case where <large number> doesn't
+ fit in a long but <large number>-1 does. */
+ else if ((n2bits != 0 && n3bits != 0 && n2bits == n3bits + 1)
+ || (n2bits != 0 && n3bits == 0
+ && (n2bits == sizeof (long) * HOST_CHAR_BIT)
+ && n3 == LONG_MAX))
{
got_signed = 1;
nbits = n2bits;
GDB does not have complex types.
Just return the complex as a float of that size. It won't work right
- for the complex values, but at least it makes the file loadable.
-
- FIXME, we may be able to distinguish these by their names. FIXME. */
+ for the complex values, but at least it makes the file loadable. */
if (n3 == 0 && n2 > 0)
{