if (**(pp) == '\\') *(pp) = next_symbol_text (); \
} while (0)
-\f
-/* This is used by other symbol readers besides stabs, so for cleanliness
- should probably be in buildsym.c. */
-
-int
-hashname (name)
- char *name;
-{
- register char *p = name;
- register int total = p[0];
- register int c;
-
- c = p[1];
- total += c << 2;
- if (c)
- {
- c = p[2];
- total += c << 4;
- if (c)
- {
- total += p[3] << 6;
- }
- }
-
- /* Ensure result is positive. */
- if (total < 0)
- {
- total += (1000 << 6);
- }
- return (total % HASHSIZE);
-}
-
\f
/* Look up a dbx type-number pair. Return the address of the slot
where the type for that number-pair is stored.
/* ARGSUSED */
struct symbol *
define_symbol (valu, string, desc, type, objfile)
- unsigned int valu;
+ CORE_ADDR valu;
char *string;
int desc;
int type;
SYMBOL_LANGUAGE (sym) = current_subfile -> language;
SYMBOL_NAME (sym) = (char *)
obstack_alloc (&objfile -> symbol_obstack, ((p - string) + 1));
- /* Open-coded bcopy--saves function call time. */
+ /* Open-coded memcpy--saves function call time. */
/* FIXME: Does it really? Try replacing with simple strcpy and
try it on an executable with a large symbol table. */
+ /* FIXME: considering that gcc can open code memcpy anyway, I
+ doubt it. xoxorich. */
{
register char *p1 = string;
register char *p2 = SYMBOL_NAME (sym);
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]. */
/* Name including "struct", etc. */
char *type_name;
- /* Name without "struct", etc. */
- char *type_name_only;
-
{
- char *prefix;
char *from, *to;
/* Set the type code according to the following letter. */
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)
{
"character", NULL);
break;
case 21:
- rettype = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED,
+ rettype = init_type (TYPE_CODE_BOOL, 1, TYPE_FLAG_UNSIGNED,
"logical*1", NULL);
break;
case 22:
- rettype = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED,
+ rettype = init_type (TYPE_CODE_BOOL, 2, TYPE_FLAG_UNSIGNED,
"logical*2", NULL);
break;
case 23:
- rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
+ rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
"logical*4", NULL);
break;
case 24:
- rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
+ rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
"logical", NULL);
break;
case 25:
struct objfile *objfile;
{
register char *p;
- const char *prefix;
char *name;
char cpp_abbrev;
struct type *context;
{
if (bits != NULL)
*bits = -1;
- return;
+ return 0;
}
}
else
count how many bits are in them). */
if (bits != NULL)
*bits = -1;
- return;
+ return 0;
}
/* -0x7f is the same as 0x80. So deal with it by adding one to
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)
{
projects / deliverable / binutils-gdb.git / blobdiff