Lines Matching refs:type
91 struct type *, struct objfile *);
93 static struct type *dbx_alloc_type (int[2], struct objfile *);
97 static struct type *error_type (char **, struct objfile *);
107 static struct type *read_type (char **, struct objfile *);
109 static struct type *read_range_type (char **, int[2], struct objfile *);
111 static struct type *read_sun_builtin_type (char **, int[2], struct objfile *);
113 static struct type *read_sun_floating_type (char **, int[2],
116 static struct type *read_enum_type (char **, struct type *, struct objfile *);
118 static struct type *rs6000_builtin_type (int);
121 read_member_functions (struct field_info *, char **, struct type *,
125 read_struct_fields (struct field_info *, char **, struct type *,
129 read_baseclasses (struct field_info *, char **, struct type *,
133 read_tilde_fields (struct field_info *, char **, struct type *,
136 static int attach_fn_fields_to_type (struct field_info *, struct type *);
138 static int attach_fields_to_type (struct field_info *, struct type *,
141 static struct type *read_struct_type (char **, struct type *,
145 static struct type *read_array_type (char **, struct type *,
150 static void add_undefined_type (struct type *);
153 read_cpp_abbrev (struct field_info *, char **, struct type *,
196 static struct type **undef_types;
210 /* Look up a dbx type-number pair. Return the address of the slot
211 where the type for that number-pair is stored.
214 This can be used for finding the type associated with that pair
215 or for associating a new type with the pair. */
217 static struct type **
233 "Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.",
242 /* Caller wants address of address of type. We think
244 "lvalues", (nor should they), so we stuff the real type
247 static struct type *temp_type;
254 Find it in this object file's type vector. */
261 type_vector = (struct type **)
262 xmalloc (type_vector_length * sizeof (struct type *));
268 type_vector = (struct type **)
270 (type_vector_length * sizeof (struct type *)));
272 (type_vector_length - old_len) * sizeof (struct type *));
282 struct type *temp_type;
283 struct type **temp_type_p;
289 temp_type_p = (struct type **) xmalloc (sizeof (struct type *));
303 f->vector = (struct type **)
304 xrealloc ((char *) f->vector, f->length * sizeof (struct type *));
306 (f->length - f_orig_length) * sizeof (struct type *));
312 /* Make sure there is a type allocated for type numbers TYPENUMS
313 and return the type object.
314 This can create an empty (zeroed) type object.
315 TYPENUMS may be (-1, -1) to return a new type object that is not
316 put into the type vector, and so may not be referred to by number. */
318 static struct type *
321 struct type **type_addr;
330 /* If we are referring to a type not known at all yet,
331 allocate an empty type for it.
425 /* Read a number by which a type is referred to in dbx data,
583 define_symbol (CORE_ADDR valu, char *string, int desc, int type,
593 E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
594 to type 2, but, should not create a symbol to address that type. Since
613 /* If a nameless stab entry, all we need is the type, not the symbol.
621 switch (type & N_TYPE)
637 number of bytes occupied by a type or object, which we ignore. */
665 /* This was an anonymous type that was never fixed up. */
688 /* Determine the type of name being defined. */
708 /* c is a special case, not followed by a type-number.
713 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
735 creating a type especially for the type of float constants.
736 Problem is, what type should it be?
738 Also, what should the name of this type be? Should we
755 only the value, but the type as well. C has at least
760 /* We just need one int constant type for all objfiles.
762 name should be a language-specific name for a type of
764 wants a nice name for the type, it can use 'e'). */
765 static struct type *int_const_type;
784 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
798 a bogus value. The type and everything else about it is
833 /* Function result types are described as the result type in stabs.
834 We need to convert this to the function-returning-type-X type
841 but both GCC and Sun CC emit stabs for the "call-as" type rather
842 than the "declared-as" type for unprototyped functions, so
853 struct type *ftype = SYMBOL_TYPE (sym);
871 struct type *ptype;
873 /* A type number of zero indicates the start of varargs.
881 a type which references itself. This type is turned into
882 a TYPE_CODE_VOID type by read_type, and we have to turn
939 The type-number specifies the type of the return value.
940 Translate it into a pointer-to-function type. */
968 /* This is the signed type which arguments get promoted to. */
969 static struct type *pcc_promotion_type;
970 /* This is the unsigned type which arguments get promoted to. */
971 static struct type *pcc_unsigned_promotion_type;
987 should believe the type of a PCC 'short' argument,
1045 if (type == N_FUN)
1116 /* Use the type from the LOC_REGISTER; that is the type
1155 /* For a nameless type, we don't want a create a symbol, thus we
1163 /* C++ vagaries: we may have a type which is derived from
1164 a base type which did not have its name defined when the
1182 emits a unique named type for a vtable entry.
1190 /* If we are giving a name to a type such as "pointer to
1193 *caddr_t;", we don't want all variables of type char
1195 consequence of GDB's type management; PCC and GCC (at
1197 either type char * or caddr_t with the type number
1211 the type for name1 is caddr_t, and func is char()
1247 /* For a nameless type, we don't want a create a symbol, thus we
1363 /* Skip rest of this symbol and return an error type.
1392 static struct type *
1395 complaint (&symfile_complaints, "couldn't parse type; debugger out of date?");
1419 /* Read type information or a type definition; return the type. Even
1420 though this routine accepts either type information or a type
1422 assume that type information starts with a digit, '-', or '(' in
1425 static struct type *
1428 struct type *type = 0;
1429 struct type *type1;
1433 /* Size in bits of type if specified by a type attribute, or -1 if
1443 /* Read type number if present. The type number may be omitted.
1444 for instance in a two-dimensional array declared with type
1458 type = dbx_alloc_type (typenums, objfile);
1463 if (TYPE_CODE (type) == TYPE_CODE_UNDEF)
1464 add_undefined_type (type);
1466 return type;
1471 Also skip the type descriptor - we get it below with (*pp)[-1]. */
1476 /* 'typenums=' not present, type is anonymous. Read and return
1477 the definition, but don't put it in the type vector. */
1500 /* Set the type code according to the following letter. */
1517 "Unrecognized cross-reference type `%c'", (*pp)[0]);
1557 /* If this type has already been declared, then reuse the same
1558 type, rather than allocating a new one. This saves some
1572 type = SYMBOL_TYPE (sym);
1574 *dbx_lookup_type (typenums) = type;
1575 return type;
1579 /* Didn't find the type to which this refers, so we must
1580 be dealing with a forward reference. Allocate a type
1583 type. */
1584 type = dbx_alloc_type (typenums, objfile);
1585 TYPE_CODE (type) = code;
1586 TYPE_TAG_NAME (type) = type_name;
1587 INIT_CPLUS_SPECIFIC (type);
1588 TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
1590 add_undefined_type (type);
1591 return type;
1594 case '-': /* RS/6000 built-in type */
1611 /* Allocate and enter the typedef type first.
1613 type = dbx_alloc_type (typenums, objfile);
1614 TYPE_CODE (type) = TYPE_CODE_TYPEDEF;
1616 struct type *xtype = read_type (pp, objfile);
1617 if (type == xtype)
1620 TYPE_CODE (type) = TYPE_CODE_VOID;
1621 TYPE_LENGTH (type) = 1;
1629 here as well. Once a type pointed to has been created it
1637 instance of a type object, so it doesn't have to copy type
1638 objects wholesale), but it still mutates type objects after
1644 limit GDB's type smashing to match exactly those required
1647 copies of a type otherwise. */
1648 replace_type (type, xtype);
1649 TYPE_NAME (type) = NULL;
1650 TYPE_TAG_NAME (type) = NULL;
1654 TYPE_FLAGS (type) |= TYPE_FLAG_TARGET_STUB;
1655 TYPE_TARGET_TYPE (type) = xtype;
1661 type that the typenums refer to, rather than allocating a new one
1663 may already be pointers to the existing type (if it had been
1667 case '*': /* Pointer to another type */
1669 type = make_pointer_type (type1, dbx_lookup_type (typenums));
1672 case '&': /* Reference to another type */
1674 type = make_reference_type (type1, dbx_lookup_type (typenums));
1677 case 'f': /* Function returning another type */
1679 type = make_function_type (type1, dbx_lookup_type (typenums));
1687 and 'F' symbol descriptors, a `0' in the argument type list
1689 type descriptors represent that info. Someone with access
1700 struct type *return_type = read_type (pp, objfile);
1701 struct type *func_type
1704 struct type *type;
1711 struct type *arg_type = read_type (pp, objfile);
1713 new->type = arg_type;
1723 "Prototyped function type didn't end arguments with `#':\n%s",
1727 /* If there is just one argument whose type is `void', then
1731 && TYPE_CODE (arg_types->type) == TYPE_CODE_VOID)
1742 /* We stuck each argument type onto the front of the list
1746 TYPE_FIELD_TYPE (func_type, i) = t->type;
1751 type = func_type;
1755 case 'k': /* Const qualifier on some type (Sun) */
1756 type = read_type (pp, objfile);
1757 type = make_cvr_type (1, TYPE_VOLATILE (type), TYPE_RESTRICT(type), type,
1761 case 'B': /* Volatile qual on some type (Sun) */
1762 type = read_type (pp, objfile);
1763 type = make_cvr_type (TYPE_CONST (type), 1, TYPE_RESTRICT(type), type,
1769 { /* Member (class & variable) type */
1772 struct type *domain = read_type (pp, objfile);
1773 struct type *memtype;
1776 /* Invalid member type data format. */
1781 type = dbx_alloc_type (typenums, objfile);
1782 smash_to_member_type (type, domain, memtype);
1785 /* type attribute */
1805 /* FIXME: check to see if following type is array? */
1810 /* FIXME: check to see if following type is array? */
1815 /* Ignore unrecognized type attributes, so future compilers
1824 case '#': /* Method (class & fn) type */
1828 struct type *return_type;
1834 "invalid (minimal) member type data format at symtab pos %d.",
1836 type = allocate_stub_method (return_type);
1838 *dbx_lookup_type (typenums) = type;
1842 struct type *domain = read_type (pp, objfile);
1843 struct type *return_type;
1848 /* Invalid member type data format. */
1855 type = dbx_alloc_type (typenums, objfile);
1856 smash_to_method_type (type, domain, return_type, args,
1861 case 'r': /* Range type */
1862 type = read_range_type (pp, typenums, objfile);
1864 *dbx_lookup_type (typenums) = type;
1869 /* Sun ACC builtin int type */
1870 type = read_sun_builtin_type (pp, typenums, objfile);
1872 *dbx_lookup_type (typenums) = type;
1876 case 'R': /* Sun ACC builtin float type */
1877 type = read_sun_floating_type (pp, typenums, objfile);
1879 *dbx_lookup_type (typenums) = type;
1882 case 'e': /* Enumeration type */
1883 type = dbx_alloc_type (typenums, objfile);
1884 type = read_enum_type (pp, type, objfile);
1886 *dbx_lookup_type (typenums) = type;
1889 case 's': /* Struct type */
1890 case 'u': /* Union type */
1893 type = dbx_alloc_type (typenums, objfile);
1903 type = read_struct_type (pp, type, type_code, objfile);
1907 case 'a': /* Array type */
1912 type = dbx_alloc_type (typenums, objfile);
1913 type = read_array_type (pp, type, objfile);
1915 TYPE_CODE (type) = TYPE_CODE_STRING;
1917 TYPE_FLAGS (type) |= TYPE_FLAG_VECTOR;
1920 case 'S': /* Set or bitstring type */
1922 type = create_set_type ((struct type *) NULL, type1);
1924 TYPE_CODE (type) = TYPE_CODE_BITSTRING;
1926 *dbx_lookup_type (typenums) = type;
1935 if (type == 0)
1937 warning ("GDB internal error, type is NULL in stabsread.c\n");
1941 /* Size specified in a type attribute overrides any other size. */
1943 TYPE_LENGTH (type) = (type_size + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
1945 return type;
1950 Return the proper type node for a given builtin type number. */
1952 static struct type *
1957 /* This includes an empty slot for type number -0. */
1958 static struct type *negative_types[NUMBER_RECOGNIZED + 1];
1959 struct type *rettype = NULL;
1963 complaint (&symfile_complaints, "Unknown builtin type %d", typenum);
1973 make the size in the struct type to be in bits, not in units of
1981 by the debugging format. If there is a type called "int" which
1982 is other than 32 bits, then it should use a new negative type
1983 number (or avoid negative type numbers for that case).
2032 type numbers. See stabs.texinfo. */
2072 /* Complex type consisting of two IEEE single precision values. */
2078 /* Complex type consisting of two IEEE double precision values. */
2145 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2158 read_member_functions (struct field_info *fip, char **pp, struct type *type,
2174 struct type *look_ahead_type;
2215 /* This lets the user type "break operator+".
2255 new_sublist->fn_field.type = read_type (pp, objfile);
2265 new_sublist->fn_field.type = look_ahead_type;
2278 if (TYPE_STUB (new_sublist->fn_field.type))
2280 if (!TYPE_DOMAIN_TYPE (new_sublist->fn_field.type))
2281 TYPE_DOMAIN_TYPE (new_sublist->fn_field.type) = type;
2410 "member function type missing, got '%c'", (*pp)[-1]);
2459 "operator int" will be named "operator i" (i.e. the type is
2572 - or for static methods, which are output as a function type
2573 instead of a method type. */
2618 ALLOCATE_CPLUS_STRUCT_TYPE (type);
2619 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
2620 TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * nfn_fields);
2621 memset (TYPE_FN_FIELDLISTS (type), 0,
2623 TYPE_NFN_FIELDS (type) = nfn_fields;
2624 TYPE_NFN_FIELDS_TOTAL (type) = total_length;
2636 read_cpp_abbrev (struct field_info *fip, char **pp, struct type *type,
2642 struct type *context;
2653 where the type number before the ':' is the "context" and
2654 everything after is a regular type definition. Lookup the
2655 type, find it's name, and construct the field name. */
2676 "C++ abbreviated type name unknown at symtab pos %d",
2693 field type. */
2701 fip->list->field.type = read_type (pp, objfile);
2730 struct type *type, struct objfile *objfile)
2748 fip->list->field.type = read_type (pp, objfile);
2756 fip->list->field.bitpos = (long) -2; /* nested type */
2773 /* Bad structure-type format. */
2774 stabs_general_complaint ("bad structure-type format");
2785 stabs_general_complaint ("bad structure-type format");
2791 stabs_general_complaint ("bad structure-type format");
2823 struct type *field_type = check_typedef (FIELD_TYPE (fip->list->field));
2867 read_struct_fields (struct field_info *fip, char **pp, struct type *type,
2877 /* Read each data member type until we find the terminating ';' at the end of
2898 which case it is just the name of an anonymous type, which we
2899 should handle like any other type name. */
2903 if (!read_cpp_abbrev (fip, pp, type, objfile))
2925 read_one_struct_field (fip, pp, p, type, objfile);
2946 the type for the base class, and a terminating semicolon.
2959 Return 1 for success, 0 for (error-type-inducing) failure. */
2965 read_baseclasses (struct field_info *fip, char **pp, struct type *type,
2981 ALLOCATE_CPLUS_STRUCT_TYPE (type);
2984 TYPE_N_BASECLASSES (type) = read_huge_number (pp, ',', &nbits);
2992 TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *)
2993 TYPE_ALLOC (type, B_BYTES (TYPE_N_BASECLASSES (type)));
2996 int num_bytes = B_BYTES (TYPE_N_BASECLASSES (type));
2999 pointer = (char *) TYPE_ALLOC (type, num_bytes);
3000 TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *) pointer;
3004 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), TYPE_N_BASECLASSES (type));
3006 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
3022 SET_TYPE_FIELD_VIRTUAL (type, i);
3063 /* The last piece of baseclass information is the type of the
3064 base class. Read it, and remember it's type name as this
3067 new->field.type = read_type (pp, objfile);
3068 new->field.name = type_name_no_tag (new->field.type);
3080 pointer contains a tilde, a %, and a type number.
3081 The type number refers to the base class (possibly this class itself) which
3088 read_tilde_fields (struct field_info *fip, char **pp, struct type *type,
3115 /* The next number is the type number of the base class
3121 struct type *t;
3136 TYPE_VPTR_BASETYPE (type) = t;
3137 if (type == t) /* Our own class provides vtbl ptr */
3147 TYPE_VPTR_FIELDNO (type) = i;
3154 TYPE_NAME (type));
3159 TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
3170 attach_fn_fields_to_type (struct field_info *fip, struct type *type)
3174 for (n = TYPE_NFN_FIELDS (type);
3179 TYPE_FN_FIELDLISTS (type)[n] = fip->fnlist->fn_fieldlist;
3189 attach_fields_to_type (struct field_info *fip, struct type *type,
3214 TYPE_NFIELDS (type) = nfields;
3215 TYPE_FIELDS (type) = (struct field *)
3216 TYPE_ALLOC (type, sizeof (struct field) * nfields);
3217 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
3221 ALLOCATE_CPLUS_STRUCT_TYPE (type);
3223 TYPE_FIELD_PRIVATE_BITS (type) =
3224 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3225 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
3227 TYPE_FIELD_PROTECTED_BITS (type) =
3228 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3229 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
3231 TYPE_FIELD_IGNORE_BITS (type) =
3232 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
3233 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
3242 TYPE_FIELD (type, nfields) = fip->list->field;
3246 SET_TYPE_FIELD_PRIVATE (type, nfields);
3250 SET_TYPE_FIELD_PROTECTED (type, nfields);
3254 SET_TYPE_FIELD_IGNORE (type, nfields);
3275 structure type TYPE. */
3277 complain_about_struct_wipeout (struct type *type)
3282 if (TYPE_TAG_NAME (type))
3284 name = TYPE_TAG_NAME (type);
3285 switch (TYPE_CODE (type))
3293 else if (TYPE_NAME (type))
3295 name = TYPE_NAME (type);
3305 "struct/union type gets multiply defined: %s%s", kind, name);
3309 /* Read the description of a structure (or union type) and return an object
3310 describing the type.
3316 TYPE points to an incomplete type that needs to be filled in.
3323 static struct type *
3324 read_struct_type (char **pp, struct type *type, enum type_code type_code,
3342 scribbling on existing structure type objects when new definitions
3344 if (! (TYPE_CODE (type) == TYPE_CODE_UNDEF
3345 || TYPE_STUB (type)))
3347 complain_about_struct_wipeout (type);
3349 /* It's probably best to return the type unchanged. */
3350 return type;
3355 INIT_CPLUS_SPECIFIC (type);
3356 TYPE_CODE (type) = type_code;
3357 TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB;
3363 TYPE_LENGTH (type) = read_huge_number (pp, 0, &nbits);
3369 class member fields, attach the fields to the type, read the C++
3370 member functions, attach them to the type, and then read any tilde
3373 if (!read_baseclasses (&fi, pp, type, objfile)
3374 || !read_struct_fields (&fi, pp, type, objfile)
3375 || !attach_fields_to_type (&fi, type, objfile)
3376 || !read_member_functions (&fi, pp, type, objfile)
3377 || !attach_fn_fields_to_type (&fi, type)
3378 || !read_tilde_fields (&fi, pp, type, objfile))
3380 type = error_type (pp, objfile);
3384 return (type);
3387 /* Read a definition of an array type,
3388 and create and return a suitable type object.
3389 Also creates a range type which represents the bounds of that
3392 static struct type *
3393 read_array_type (char **pp, struct type *type,
3396 struct type *index_type, *element_type, *range_type;
3401 /* Format of an array type:
3402 "ar<index type>;lower;upper;<array_contents_type>".
3406 for these, produce a type like float[][]. */
3411 /* Improper format of array type decl. */
3444 create_range_type ((struct type *) NULL, index_type, lower, upper);
3445 type = create_array_type (type, element_type, range_type);
3447 return type;
3451 /* Read a definition of an enumeration type,
3452 and create and return a suitable type object.
3453 Also defines the symbols that represent the values of the type. */
3455 static struct type *
3456 read_enum_type (char **pp, struct type *type,
3483 my guess is it's a type of some sort. Just ignore it. */
3486 /* Skip over the type. */
3526 /* Now fill in the fields of the type-structure. */
3528 TYPE_LENGTH (type) = TARGET_INT_BIT / HOST_CHAR_BIT;
3529 TYPE_CODE (type) = TYPE_CODE_ENUM;
3530 TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB;
3532 TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
3533 TYPE_NFIELDS (type) = nsyms;
3534 TYPE_FIELDS (type) = (struct field *)
3535 TYPE_ALLOC (type, sizeof (struct field) * nsyms);
3536 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nsyms);
3538 /* Find the symbols for the values and put them into the type.
3553 SYMBOL_TYPE (xsym) = type;
3554 TYPE_FIELD_NAME (type, n) = DEPRECATED_SYMBOL_NAME (xsym);
3555 TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
3556 TYPE_FIELD_BITSIZE (type, n) = 0;
3562 return type;
3568 type = b <signed> <width> <format type>; <offset>; <nbits>
3570 optional format type = c or b for char or boolean.
3571 offset = offset from high order bit to start bit of type.
3572 width is # bytes in object of this type, nbits is # bits in type.
3578 static struct type *
3600 because no other type has this honor. We can safely ignore this because
3614 by this type, except that unsigned short is 4 instead of 2.
3626 /* The third number is the number of bits for this type. */
3630 /* The type *should* end with a semicolon. If it are embedded
3631 in a larger type the semicolon may be the only way to know where
3632 the type ends. If this type is at the end of the stabstring we
3650 static struct type *
3656 struct type *rettype;
3658 /* The first number has more details about the type, for example
3664 /* The second number is the number of bytes occupied by this type */
3792 static struct type *
3800 struct type *result_type;
3801 struct type *index_type = NULL;
3803 /* First comes a type we are a subrange of.
3804 In C it is usually 0, 1 or the type being defined. */
3831 /* If limits are huge, must be large integral type. */
3836 /* Number of bits in the type. */
3839 /* Range from 0 to <large number> is an unsigned large integral type. */
3846 integral type. Take care of the case where <large number> doesn't
3867 /* A type defined as a subrange of itself, with bounds both 0, is void. */
3871 /* If n3 is zero and n2 is positive, we want a floating type, and n2
3885 struct type *float_type
3890 struct type *complex_type =
3960 /* We have a real range type on our hands. Allocate space and
3973 static struct type *range_type_index;
3976 "base type %d of range type is not defined", rangenums[1]);
3980 0, "range type index type", NULL);
3984 result_type = create_range_type ((struct type *) NULL, index_type, n2, n3);
3989 and terminated with END. Return the list of types read in, or (struct type
3997 struct type *types[1024]; /* allow for fns of 1023 parameters */
4023 rval[i].type = types[i];
4110 SYMBOL_TYPE (sym) = (struct type *) new;
4142 /* Add a type to the list of undefined types to be checked through
4146 add_undefined_type (struct type *type)
4151 undef_types = (struct type **)
4153 undef_types_allocated * sizeof (struct type *));
4155 undef_types[undef_types_length++] = type;
4158 /* Go through each undefined type, see if it's still undefined, and fix it
4161 TYPE_CODE_ARRAY: Array whose target type wasn't defined yet.
4163 and the target type's length.
4170 struct type **type;
4172 for (type = undef_types; type < undef_types + undef_types_length; type++)
4174 switch (TYPE_CODE (*type))
4185 if (TYPE_STUB (*type))
4189 /* Name of the type, without "struct" or "union" */
4190 char *typename = TYPE_TAG_NAME (*type);
4194 complaint (&symfile_complaints, "need a type name");
4206 TYPE_CODE (*type))
4208 replace_type (*type, SYMBOL_TYPE (sym));
4219 "type code %d.",
4220 TYPE_CODE (*type));
4398 type_vector = (struct type **) 0;
4462 undef_types = (struct type **)
4463 xmalloc (undef_types_allocated * sizeof (struct type *));