Minor cleanup.
[deliverable/binutils-gdb.git] / gdb / gdbtypes.c
1 /* Support routines for manipulating internal types for GDB.
2 Copyright (C) 1992 Free Software Foundation, Inc.
3 Contributed by Cygnus Support, using pieces from other GDB modules.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
20
21 #include "defs.h"
22 #include <string.h>
23 #include "bfd.h"
24 #include "symtab.h"
25 #include "symfile.h"
26 #include "objfiles.h"
27 #include "gdbtypes.h"
28 #include "expression.h"
29 #include "language.h"
30 #include "target.h"
31 #include "value.h"
32 #include "demangle.h"
33 #include "complaints.h"
34
35 /* These variables point to the objects
36 representing the predefined C data types. */
37
38 struct type *builtin_type_void;
39 struct type *builtin_type_char;
40 struct type *builtin_type_short;
41 struct type *builtin_type_int;
42 struct type *builtin_type_long;
43 struct type *builtin_type_long_long;
44 struct type *builtin_type_signed_char;
45 struct type *builtin_type_unsigned_char;
46 struct type *builtin_type_unsigned_short;
47 struct type *builtin_type_unsigned_int;
48 struct type *builtin_type_unsigned_long;
49 struct type *builtin_type_unsigned_long_long;
50 struct type *builtin_type_float;
51 struct type *builtin_type_double;
52 struct type *builtin_type_long_double;
53 struct type *builtin_type_complex;
54 struct type *builtin_type_double_complex;
55 struct type *builtin_type_string;
56
57 /* Alloc a new type structure and fill it with some defaults. If
58 OBJFILE is non-NULL, then allocate the space for the type structure
59 in that objfile's type_obstack. */
60
61 struct type *
62 alloc_type (objfile)
63 struct objfile *objfile;
64 {
65 register struct type *type;
66
67 /* Alloc the structure and start off with all fields zeroed. */
68
69 if (objfile == NULL)
70 {
71 type = (struct type *) xmalloc (sizeof (struct type));
72 }
73 else
74 {
75 type = (struct type *) obstack_alloc (&objfile -> type_obstack,
76 sizeof (struct type));
77 }
78 memset ((char *) type, 0, sizeof (struct type));
79
80 /* Initialize the fields that might not be zero. */
81
82 TYPE_CODE (type) = TYPE_CODE_UNDEF;
83 TYPE_OBJFILE (type) = objfile;
84 TYPE_VPTR_FIELDNO (type) = -1;
85
86 return (type);
87 }
88
89 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
90 to a pointer to memory where the pointer type should be stored.
91 If *TYPEPTR is zero, update it to point to the pointer type we return.
92 We allocate new memory if needed. */
93
94 struct type *
95 make_pointer_type (type, typeptr)
96 struct type *type;
97 struct type **typeptr;
98 {
99 register struct type *ntype; /* New type */
100 struct objfile *objfile;
101
102 ntype = TYPE_POINTER_TYPE (type);
103
104 if (ntype)
105 if (typeptr == 0)
106 return ntype; /* Don't care about alloc, and have new type. */
107 else if (*typeptr == 0)
108 {
109 *typeptr = ntype; /* Tracking alloc, and we have new type. */
110 return ntype;
111 }
112
113 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
114 {
115 ntype = alloc_type (TYPE_OBJFILE (type));
116 if (typeptr)
117 *typeptr = ntype;
118 }
119 else /* We have storage, but need to reset it. */
120 {
121 ntype = *typeptr;
122 objfile = TYPE_OBJFILE (ntype);
123 memset ((char *) ntype, 0, sizeof (struct type));
124 TYPE_OBJFILE (ntype) = objfile;
125 }
126
127 TYPE_TARGET_TYPE (ntype) = type;
128 TYPE_POINTER_TYPE (type) = ntype;
129
130 /* FIXME! Assume the machine has only one representation for pointers! */
131
132 TYPE_LENGTH (ntype) = TARGET_PTR_BIT / TARGET_CHAR_BIT;
133 TYPE_CODE (ntype) = TYPE_CODE_PTR;
134
135 /* pointers are unsigned */
136 TYPE_FLAGS (ntype) |= TYPE_FLAG_UNSIGNED;
137
138 if (!TYPE_POINTER_TYPE (type)) /* Remember it, if don't have one. */
139 TYPE_POINTER_TYPE (type) = ntype;
140
141 return ntype;
142 }
143
144 /* Given a type TYPE, return a type of pointers to that type.
145 May need to construct such a type if this is the first use. */
146
147 struct type *
148 lookup_pointer_type (type)
149 struct type *type;
150 {
151 return make_pointer_type (type, (struct type **)0);
152 }
153
154 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero, points
155 to a pointer to memory where the reference type should be stored.
156 If *TYPEPTR is zero, update it to point to the reference type we return.
157 We allocate new memory if needed. */
158
159 struct type *
160 make_reference_type (type, typeptr)
161 struct type *type;
162 struct type **typeptr;
163 {
164 register struct type *ntype; /* New type */
165 struct objfile *objfile;
166
167 ntype = TYPE_REFERENCE_TYPE (type);
168
169 if (ntype)
170 if (typeptr == 0)
171 return ntype; /* Don't care about alloc, and have new type. */
172 else if (*typeptr == 0)
173 {
174 *typeptr = ntype; /* Tracking alloc, and we have new type. */
175 return ntype;
176 }
177
178 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
179 {
180 ntype = alloc_type (TYPE_OBJFILE (type));
181 if (typeptr)
182 *typeptr = ntype;
183 }
184 else /* We have storage, but need to reset it. */
185 {
186 ntype = *typeptr;
187 objfile = TYPE_OBJFILE (ntype);
188 memset ((char *) ntype, 0, sizeof (struct type));
189 TYPE_OBJFILE (ntype) = objfile;
190 }
191
192 TYPE_TARGET_TYPE (ntype) = type;
193 TYPE_REFERENCE_TYPE (type) = ntype;
194
195 /* FIXME! Assume the machine has only one representation for references,
196 and that it matches the (only) representation for pointers! */
197
198 TYPE_LENGTH (ntype) = TARGET_PTR_BIT / TARGET_CHAR_BIT;
199 TYPE_CODE (ntype) = TYPE_CODE_REF;
200
201 if (!TYPE_REFERENCE_TYPE (type)) /* Remember it, if don't have one. */
202 TYPE_REFERENCE_TYPE (type) = ntype;
203
204 return ntype;
205 }
206
207 /* Same as above, but caller doesn't care about memory allocation details. */
208
209 struct type *
210 lookup_reference_type (type)
211 struct type *type;
212 {
213 return make_reference_type (type, (struct type **)0);
214 }
215
216 /* Lookup a function type that returns type TYPE. TYPEPTR, if nonzero, points
217 to a pointer to memory where the function type should be stored.
218 If *TYPEPTR is zero, update it to point to the function type we return.
219 We allocate new memory if needed. */
220
221 struct type *
222 make_function_type (type, typeptr)
223 struct type *type;
224 struct type **typeptr;
225 {
226 register struct type *ntype; /* New type */
227 struct objfile *objfile;
228
229 ntype = TYPE_FUNCTION_TYPE (type);
230
231 if (ntype)
232 if (typeptr == 0)
233 return ntype; /* Don't care about alloc, and have new type. */
234 else if (*typeptr == 0)
235 {
236 *typeptr = ntype; /* Tracking alloc, and we have new type. */
237 return ntype;
238 }
239
240 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
241 {
242 ntype = alloc_type (TYPE_OBJFILE (type));
243 if (typeptr)
244 *typeptr = ntype;
245 }
246 else /* We have storage, but need to reset it. */
247 {
248 ntype = *typeptr;
249 objfile = TYPE_OBJFILE (ntype);
250 memset ((char *) ntype, 0, sizeof (struct type));
251 TYPE_OBJFILE (ntype) = objfile;
252 }
253
254 TYPE_TARGET_TYPE (ntype) = type;
255 TYPE_FUNCTION_TYPE (type) = ntype;
256
257 TYPE_LENGTH (ntype) = 1;
258 TYPE_CODE (ntype) = TYPE_CODE_FUNC;
259
260 if (!TYPE_FUNCTION_TYPE (type)) /* Remember it, if don't have one. */
261 TYPE_FUNCTION_TYPE (type) = ntype;
262
263 return ntype;
264 }
265
266
267 /* Given a type TYPE, return a type of functions that return that type.
268 May need to construct such a type if this is the first use. */
269
270 struct type *
271 lookup_function_type (type)
272 struct type *type;
273 {
274 return make_function_type (type, (struct type **)0);
275 }
276
277 /* Implement direct support for MEMBER_TYPE in GNU C++.
278 May need to construct such a type if this is the first use.
279 The TYPE is the type of the member. The DOMAIN is the type
280 of the aggregate that the member belongs to. */
281
282 struct type *
283 lookup_member_type (type, domain)
284 struct type *type;
285 struct type *domain;
286 {
287 register struct type *mtype;
288
289 mtype = alloc_type (TYPE_OBJFILE (type));
290 smash_to_member_type (mtype, domain, type);
291 return (mtype);
292 }
293
294 /* Allocate a stub method whose return type is TYPE.
295 This apparently happens for speed of symbol reading, since parsing
296 out the arguments to the method is cpu-intensive, the way we are doing
297 it. So, we will fill in arguments later.
298 This always returns a fresh type. */
299
300 struct type *
301 allocate_stub_method (type)
302 struct type *type;
303 {
304 struct type *mtype;
305
306 mtype = alloc_type (TYPE_OBJFILE (type));
307 TYPE_TARGET_TYPE (mtype) = type;
308 /* _DOMAIN_TYPE (mtype) = unknown yet */
309 /* _ARG_TYPES (mtype) = unknown yet */
310 TYPE_FLAGS (mtype) = TYPE_FLAG_STUB;
311 TYPE_CODE (mtype) = TYPE_CODE_METHOD;
312 TYPE_LENGTH (mtype) = 1;
313 return (mtype);
314 }
315
316 /* Create a range type using either a blank type supplied in RESULT_TYPE,
317 or creating a new type, inheriting the objfile from INDEX_TYPE.
318
319 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
320 HIGH_BOUND, inclusive.
321
322 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
323 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
324
325 struct type *
326 create_range_type (result_type, index_type, low_bound, high_bound)
327 struct type *result_type;
328 struct type *index_type;
329 int low_bound;
330 int high_bound;
331 {
332 if (result_type == NULL)
333 {
334 result_type = alloc_type (TYPE_OBJFILE (index_type));
335 }
336 TYPE_CODE (result_type) = TYPE_CODE_RANGE;
337 TYPE_TARGET_TYPE (result_type) = index_type;
338 TYPE_LENGTH (result_type) = TYPE_LENGTH (index_type);
339 TYPE_NFIELDS (result_type) = 2;
340 TYPE_FIELDS (result_type) = (struct field *)
341 TYPE_ALLOC (result_type, 2 * sizeof (struct field));
342 memset (TYPE_FIELDS (result_type), 0, 2 * sizeof (struct field));
343 TYPE_FIELD_BITPOS (result_type, 0) = low_bound;
344 TYPE_FIELD_BITPOS (result_type, 1) = high_bound;
345 TYPE_FIELD_TYPE (result_type, 0) = builtin_type_int; /* FIXME */
346 TYPE_FIELD_TYPE (result_type, 1) = builtin_type_int; /* FIXME */
347
348 return (result_type);
349 }
350
351
352 /* Create an array type using either a blank type supplied in RESULT_TYPE,
353 or creating a new type, inheriting the objfile from RANGE_TYPE.
354
355 Elements will be of type ELEMENT_TYPE, the indices will be of type
356 RANGE_TYPE.
357
358 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
359 sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
360
361 struct type *
362 create_array_type (result_type, element_type, range_type)
363 struct type *result_type;
364 struct type *element_type;
365 struct type *range_type;
366 {
367 int low_bound;
368 int high_bound;
369
370 if (TYPE_CODE (range_type) != TYPE_CODE_RANGE)
371 {
372 /* FIXME: We only handle range types at the moment. Complain and
373 create a dummy range type to use. */
374 warning ("internal error: array index type must be a range type");
375 range_type = lookup_fundamental_type (TYPE_OBJFILE (range_type),
376 FT_INTEGER);
377 range_type = create_range_type ((struct type *) NULL, range_type, 0, 0);
378 }
379 if (result_type == NULL)
380 {
381 result_type = alloc_type (TYPE_OBJFILE (range_type));
382 }
383 TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
384 TYPE_TARGET_TYPE (result_type) = element_type;
385 low_bound = TYPE_FIELD_BITPOS (range_type, 0);
386 high_bound = TYPE_FIELD_BITPOS (range_type, 1);
387 TYPE_LENGTH (result_type) =
388 TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
389 TYPE_NFIELDS (result_type) = 1;
390 TYPE_FIELDS (result_type) =
391 (struct field *) TYPE_ALLOC (result_type, sizeof (struct field));
392 memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
393 TYPE_FIELD_TYPE (result_type, 0) = range_type;
394 TYPE_VPTR_FIELDNO (result_type) = -1;
395
396 return (result_type);
397 }
398
399 /* Create a string type using either a blank type supplied in RESULT_TYPE,
400 or creating a new type. String types are similar enough to array of
401 char types that we can use create_array_type to build the basic type
402 and then bash it into a string type.
403
404 For fixed length strings, the range type contains 0 as the lower
405 bound and the length of the string minus one as the upper bound.
406
407 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
408 sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
409
410 struct type *
411 create_string_type (result_type, range_type)
412 struct type *result_type;
413 struct type *range_type;
414 {
415 result_type = create_array_type (result_type, builtin_type_char, range_type);
416 TYPE_CODE (result_type) = TYPE_CODE_STRING;
417 return (result_type);
418 }
419
420 /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
421 A MEMBER is a wierd thing -- it amounts to a typed offset into
422 a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
423 include the offset (that's the value of the MEMBER itself), but does
424 include the structure type into which it points (for some reason).
425
426 When "smashing" the type, we preserve the objfile that the
427 old type pointed to, since we aren't changing where the type is actually
428 allocated. */
429
430 void
431 smash_to_member_type (type, domain, to_type)
432 struct type *type;
433 struct type *domain;
434 struct type *to_type;
435 {
436 struct objfile *objfile;
437
438 objfile = TYPE_OBJFILE (type);
439
440 memset ((char *) type, 0, sizeof (struct type));
441 TYPE_OBJFILE (type) = objfile;
442 TYPE_TARGET_TYPE (type) = to_type;
443 TYPE_DOMAIN_TYPE (type) = domain;
444 TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */
445 TYPE_CODE (type) = TYPE_CODE_MEMBER;
446 }
447
448 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
449 METHOD just means `function that gets an extra "this" argument'.
450
451 When "smashing" the type, we preserve the objfile that the
452 old type pointed to, since we aren't changing where the type is actually
453 allocated. */
454
455 void
456 smash_to_method_type (type, domain, to_type, args)
457 struct type *type;
458 struct type *domain;
459 struct type *to_type;
460 struct type **args;
461 {
462 struct objfile *objfile;
463
464 objfile = TYPE_OBJFILE (type);
465
466 memset ((char *) type, 0, sizeof (struct type));
467 TYPE_OBJFILE (type) = objfile;
468 TYPE_TARGET_TYPE (type) = to_type;
469 TYPE_DOMAIN_TYPE (type) = domain;
470 TYPE_ARG_TYPES (type) = args;
471 TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */
472 TYPE_CODE (type) = TYPE_CODE_METHOD;
473 }
474
475 /* Return a typename for a struct/union/enum type
476 without the tag qualifier. If the type has a NULL name,
477 NULL is returned. */
478
479 char *
480 type_name_no_tag (type)
481 register const struct type *type;
482 {
483 register char *name;
484
485 if ((name = TYPE_NAME (type)) != NULL)
486 {
487 switch (TYPE_CODE (type))
488 {
489 case TYPE_CODE_STRUCT:
490 if(!strncmp (name, "struct ", 7))
491 {
492 name += 7;
493 }
494 break;
495 case TYPE_CODE_UNION:
496 if(!strncmp (name, "union ", 6))
497 {
498 name += 6;
499 }
500 break;
501 case TYPE_CODE_ENUM:
502 if(!strncmp (name, "enum ", 5))
503 {
504 name += 5;
505 }
506 break;
507 default: /* To avoid -Wall warnings */
508 break;
509 }
510 }
511 return (name);
512 }
513
514 /* Lookup a primitive type named NAME.
515 Return zero if NAME is not a primitive type.*/
516
517 struct type *
518 lookup_primitive_typename (name)
519 char *name;
520 {
521 struct type ** const *p;
522
523 for (p = current_language -> la_builtin_type_vector; *p != NULL; p++)
524 {
525 if (STREQ ((**p) -> name, name))
526 {
527 return (**p);
528 }
529 }
530 return (NULL);
531 }
532
533 /* Lookup a typedef or primitive type named NAME,
534 visible in lexical block BLOCK.
535 If NOERR is nonzero, return zero if NAME is not suitably defined. */
536
537 struct type *
538 lookup_typename (name, block, noerr)
539 char *name;
540 struct block *block;
541 int noerr;
542 {
543 register struct symbol *sym;
544 register struct type *tmp;
545
546 sym = lookup_symbol (name, block, VAR_NAMESPACE, 0, (struct symtab **) NULL);
547 if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
548 {
549 tmp = lookup_primitive_typename (name);
550 if (tmp)
551 {
552 return (tmp);
553 }
554 else if (!tmp && noerr)
555 {
556 return (NULL);
557 }
558 else
559 {
560 error ("No type named %s.", name);
561 }
562 }
563 return (SYMBOL_TYPE (sym));
564 }
565
566 struct type *
567 lookup_unsigned_typename (name)
568 char *name;
569 {
570 char *uns = alloca (strlen (name) + 10);
571
572 strcpy (uns, "unsigned ");
573 strcpy (uns + 9, name);
574 return (lookup_typename (uns, (struct block *) NULL, 0));
575 }
576
577 struct type *
578 lookup_signed_typename (name)
579 char *name;
580 {
581 struct type *t;
582 char *uns = alloca (strlen (name) + 8);
583
584 strcpy (uns, "signed ");
585 strcpy (uns + 7, name);
586 t = lookup_typename (uns, (struct block *) NULL, 1);
587 /* If we don't find "signed FOO" just try again with plain "FOO". */
588 if (t != NULL)
589 return t;
590 return lookup_typename (name, (struct block *) NULL, 0);
591 }
592
593 /* Lookup a structure type named "struct NAME",
594 visible in lexical block BLOCK. */
595
596 struct type *
597 lookup_struct (name, block)
598 char *name;
599 struct block *block;
600 {
601 register struct symbol *sym;
602
603 sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
604 (struct symtab **) NULL);
605
606 if (sym == NULL)
607 {
608 error ("No struct type named %s.", name);
609 }
610 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
611 {
612 error ("This context has class, union or enum %s, not a struct.", name);
613 }
614 return (SYMBOL_TYPE (sym));
615 }
616
617 /* Lookup a union type named "union NAME",
618 visible in lexical block BLOCK. */
619
620 struct type *
621 lookup_union (name, block)
622 char *name;
623 struct block *block;
624 {
625 register struct symbol *sym;
626
627 sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
628 (struct symtab **) NULL);
629
630 if (sym == NULL)
631 {
632 error ("No union type named %s.", name);
633 }
634 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_UNION)
635 {
636 error ("This context has class, struct or enum %s, not a union.", name);
637 }
638 return (SYMBOL_TYPE (sym));
639 }
640
641 /* Lookup an enum type named "enum NAME",
642 visible in lexical block BLOCK. */
643
644 struct type *
645 lookup_enum (name, block)
646 char *name;
647 struct block *block;
648 {
649 register struct symbol *sym;
650
651 sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
652 (struct symtab **) NULL);
653 if (sym == NULL)
654 {
655 error ("No enum type named %s.", name);
656 }
657 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
658 {
659 error ("This context has class, struct or union %s, not an enum.", name);
660 }
661 return (SYMBOL_TYPE (sym));
662 }
663
664 /* Lookup a template type named "template NAME<TYPE>",
665 visible in lexical block BLOCK. */
666
667 struct type *
668 lookup_template_type (name, type, block)
669 char *name;
670 struct type *type;
671 struct block *block;
672 {
673 struct symbol *sym;
674 char *nam = (char*) alloca(strlen(name) + strlen(type->name) + 4);
675 strcpy (nam, name);
676 strcat (nam, "<");
677 strcat (nam, type->name);
678 strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */
679
680 sym = lookup_symbol (nam, block, VAR_NAMESPACE, 0, (struct symtab **)NULL);
681
682 if (sym == NULL)
683 {
684 error ("No template type named %s.", name);
685 }
686 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
687 {
688 error ("This context has class, union or enum %s, not a struct.", name);
689 }
690 return (SYMBOL_TYPE (sym));
691 }
692
693 /* Given a type TYPE, lookup the type of the component of type named NAME.
694
695 TYPE can be either a struct or union, or a pointer or reference to a struct or
696 union. If it is a pointer or reference, its target type is automatically used.
697 Thus '.' and '->' are interchangable, as specified for the definitions of the
698 expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
699
700 If NOERR is nonzero, return zero if NAME is not suitably defined.
701 If NAME is the name of a baseclass type, return that type. */
702
703 struct type *
704 lookup_struct_elt_type (type, name, noerr)
705 struct type *type;
706 char *name;
707 int noerr;
708 {
709 int i;
710 char *typename;
711
712 if (TYPE_CODE (type) == TYPE_CODE_PTR ||
713 TYPE_CODE (type) == TYPE_CODE_REF)
714 type = TYPE_TARGET_TYPE (type);
715
716 if (TYPE_CODE (type) != TYPE_CODE_STRUCT &&
717 TYPE_CODE (type) != TYPE_CODE_UNION)
718 {
719 target_terminal_ours ();
720 fflush (stdout);
721 fprintf (stderr, "Type ");
722 type_print (type, "", stderr, -1);
723 error (" is not a structure or union type.");
724 }
725
726 check_stub_type (type);
727
728 #if 0
729 /* FIXME: This change put in by Michael seems incorrect for the case where
730 the structure tag name is the same as the member name. I.E. when doing
731 "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
732 Disabled by fnf. */
733 typename = type_name_no_tag (type);
734 if (typename != NULL && STREQ (typename, name))
735 return type;
736 #endif
737
738 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
739 {
740 char *t_field_name = TYPE_FIELD_NAME (type, i);
741
742 if (t_field_name && STREQ (t_field_name, name))
743 {
744 return TYPE_FIELD_TYPE (type, i);
745 }
746 }
747
748 /* OK, it's not in this class. Recursively check the baseclasses. */
749 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
750 {
751 struct type *t;
752
753 t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, noerr);
754 if (t != NULL)
755 {
756 return t;
757 }
758 }
759
760 if (noerr)
761 {
762 return NULL;
763 }
764
765 target_terminal_ours ();
766 fflush (stdout);
767 fprintf (stderr, "Type ");
768 type_print (type, "", stderr, -1);
769 fprintf (stderr, " has no component named ");
770 fputs_filtered (name, stderr);
771 error (".");
772 return (struct type *)-1; /* For lint */
773 }
774
775 /* This function is really horrible, but to avoid it, there would need
776 to be more filling in of forward references. */
777
778 void
779 fill_in_vptr_fieldno (type)
780 struct type *type;
781 {
782 if (TYPE_VPTR_FIELDNO (type) < 0)
783 {
784 int i;
785
786 /* We must start at zero in case the first (and only) baseclass is
787 virtual (and hence we cannot share the table pointer). */
788 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
789 {
790 fill_in_vptr_fieldno (TYPE_BASECLASS (type, i));
791 if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type, i)) >= 0)
792 {
793 TYPE_VPTR_FIELDNO (type)
794 = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type, i));
795 TYPE_VPTR_BASETYPE (type)
796 = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type, i));
797 break;
798 }
799 }
800 }
801 }
802
803 /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
804
805 If this is a stubbed struct (i.e. declared as struct foo *), see if
806 we can find a full definition in some other file. If so, copy this
807 definition, so we can use it in future. If not, set a flag so we
808 don't waste too much time in future. (FIXME, this doesn't seem
809 to be happening...)
810
811 This used to be coded as a macro, but I don't think it is called
812 often enough to merit such treatment.
813 */
814
815 struct complaint stub_noname_complaint =
816 {"stub type has NULL name", 0, 0};
817
818 void
819 check_stub_type (type)
820 struct type *type;
821 {
822 if (TYPE_FLAGS(type) & TYPE_FLAG_STUB)
823 {
824 char* name = type_name_no_tag (type);
825 struct symbol *sym;
826 if (name == NULL)
827 {
828 complain (&stub_noname_complaint);
829 return;
830 }
831 sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0,
832 (struct symtab **) NULL);
833 if (sym)
834 {
835 memcpy ((char *)type, (char *)SYMBOL_TYPE(sym), sizeof (struct type));
836 }
837 }
838 }
839
840 /* Ugly hack to convert method stubs into method types.
841
842 He ain't kiddin'. This demangles the name of the method into a string
843 including argument types, parses out each argument type, generates
844 a string casting a zero to that type, evaluates the string, and stuffs
845 the resulting type into an argtype vector!!! Then it knows the type
846 of the whole function (including argument types for overloading),
847 which info used to be in the stab's but was removed to hack back
848 the space required for them. */
849
850 void
851 check_stub_method (type, i, j)
852 struct type *type;
853 int i;
854 int j;
855 {
856 struct fn_field *f;
857 char *mangled_name = gdb_mangle_name (type, i, j);
858 char *demangled_name = cplus_demangle (mangled_name,
859 DMGL_PARAMS | DMGL_ANSI);
860 char *argtypetext, *p;
861 int depth = 0, argcount = 1;
862 struct type **argtypes;
863 struct type *mtype;
864
865 if (demangled_name == NULL)
866 {
867 error ("Internal: Cannot demangle mangled name `%s'.", mangled_name);
868 }
869
870 /* Now, read in the parameters that define this type. */
871 argtypetext = strchr (demangled_name, '(') + 1;
872 p = argtypetext;
873 while (*p)
874 {
875 if (*p == '(')
876 {
877 depth += 1;
878 }
879 else if (*p == ')')
880 {
881 depth -= 1;
882 }
883 else if (*p == ',' && depth == 0)
884 {
885 argcount += 1;
886 }
887
888 p += 1;
889 }
890
891 /* We need two more slots: one for the THIS pointer, and one for the
892 NULL [...] or void [end of arglist]. */
893
894 argtypes = (struct type **)
895 TYPE_ALLOC (type, (argcount + 2) * sizeof (struct type *));
896 p = argtypetext;
897 argtypes[0] = lookup_pointer_type (type);
898 argcount = 1;
899
900 if (*p != ')') /* () means no args, skip while */
901 {
902 depth = 0;
903 while (*p)
904 {
905 if (depth <= 0 && (*p == ',' || *p == ')'))
906 {
907 argtypes[argcount] =
908 parse_and_eval_type (argtypetext, p - argtypetext);
909 argcount += 1;
910 argtypetext = p + 1;
911 }
912
913 if (*p == '(')
914 {
915 depth += 1;
916 }
917 else if (*p == ')')
918 {
919 depth -= 1;
920 }
921
922 p += 1;
923 }
924 }
925
926 if (p[-2] != '.') /* Not '...' */
927 {
928 argtypes[argcount] = builtin_type_void; /* List terminator */
929 }
930 else
931 {
932 argtypes[argcount] = NULL; /* Ellist terminator */
933 }
934
935 free (demangled_name);
936
937 f = TYPE_FN_FIELDLIST1 (type, i);
938 TYPE_FN_FIELD_PHYSNAME (f, j) = mangled_name;
939
940 /* Now update the old "stub" type into a real type. */
941 mtype = TYPE_FN_FIELD_TYPE (f, j);
942 TYPE_DOMAIN_TYPE (mtype) = type;
943 TYPE_ARG_TYPES (mtype) = argtypes;
944 TYPE_FLAGS (mtype) &= ~TYPE_FLAG_STUB;
945 TYPE_FN_FIELD_STUB (f, j) = 0;
946 }
947
948 const struct cplus_struct_type cplus_struct_default;
949
950 void
951 allocate_cplus_struct_type (type)
952 struct type *type;
953 {
954 if (!HAVE_CPLUS_STRUCT (type))
955 {
956 TYPE_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
957 TYPE_ALLOC (type, sizeof (struct cplus_struct_type));
958 *(TYPE_CPLUS_SPECIFIC(type)) = cplus_struct_default;
959 }
960 }
961
962 /* Helper function to initialize the standard scalar types.
963
964 If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
965 of the string pointed to by name in the type_obstack for that objfile,
966 and initialize the type name to that copy. There are places (mipsread.c
967 in particular, where init_type is called with a NULL value for NAME). */
968
969 struct type *
970 init_type (code, length, flags, name, objfile)
971 enum type_code code;
972 int length;
973 int flags;
974 char *name;
975 struct objfile *objfile;
976 {
977 register struct type *type;
978
979 type = alloc_type (objfile);
980 TYPE_CODE (type) = code;
981 TYPE_LENGTH (type) = length;
982 TYPE_FLAGS (type) |= flags;
983 if ((name != NULL) && (objfile != NULL))
984 {
985 TYPE_NAME (type) =
986 obsavestring (name, strlen (name), &objfile -> type_obstack);
987 }
988 else
989 {
990 TYPE_NAME (type) = name;
991 }
992
993 /* C++ fancies. */
994
995 if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION)
996 {
997 INIT_CPLUS_SPECIFIC (type);
998 }
999 return (type);
1000 }
1001
1002 /* Look up a fundamental type for the specified objfile.
1003 May need to construct such a type if this is the first use.
1004
1005 Some object file formats (ELF, COFF, etc) do not define fundamental
1006 types such as "int" or "double". Others (stabs for example), do
1007 define fundamental types.
1008
1009 For the formats which don't provide fundamental types, gdb can create
1010 such types, using defaults reasonable for the current language and
1011 the current target machine.
1012
1013 NOTE: This routine is obsolescent. Each debugging format reader
1014 should manage it's own fundamental types, either creating them from
1015 suitable defaults or reading them from the debugging information,
1016 whichever is appropriate. The DWARF reader has already been
1017 fixed to do this. Once the other readers are fixed, this routine
1018 will go away. Also note that fundamental types should be managed
1019 on a compilation unit basis in a multi-language environment, not
1020 on a linkage unit basis as is done here. */
1021
1022
1023 struct type *
1024 lookup_fundamental_type (objfile, typeid)
1025 struct objfile *objfile;
1026 int typeid;
1027 {
1028 register struct type **typep;
1029 register int nbytes;
1030
1031 if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
1032 {
1033 error ("internal error - invalid fundamental type id %d", typeid);
1034 }
1035
1036 /* If this is the first time we need a fundamental type for this objfile
1037 then we need to initialize the vector of type pointers. */
1038
1039 if (objfile -> fundamental_types == NULL)
1040 {
1041 nbytes = FT_NUM_MEMBERS * sizeof (struct type *);
1042 objfile -> fundamental_types = (struct type **)
1043 obstack_alloc (&objfile -> type_obstack, nbytes);
1044 memset ((char *) objfile -> fundamental_types, 0, nbytes);
1045 }
1046
1047 /* Look for this particular type in the fundamental type vector. If one is
1048 not found, create and install one appropriate for the current language. */
1049
1050 typep = objfile -> fundamental_types + typeid;
1051 if (*typep == NULL)
1052 {
1053 *typep = create_fundamental_type (objfile, typeid);
1054 }
1055
1056 return (*typep);
1057 }
1058
1059 #if MAINTENANCE_CMDS
1060
1061 static void
1062 print_bit_vector (bits, nbits)
1063 B_TYPE *bits;
1064 int nbits;
1065 {
1066 int bitno;
1067
1068 for (bitno = 0; bitno < nbits; bitno++)
1069 {
1070 if ((bitno % 8) == 0)
1071 {
1072 puts_filtered (" ");
1073 }
1074 if (B_TST (bits, bitno))
1075 {
1076 printf_filtered ("1");
1077 }
1078 else
1079 {
1080 printf_filtered ("0");
1081 }
1082 }
1083 }
1084
1085 /* The args list is a strange beast. It is either terminated by a NULL
1086 pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
1087 type for normal fixed argcount functions. (FIXME someday)
1088 Also note the first arg should be the "this" pointer, we may not want to
1089 include it since we may get into a infinitely recursive situation. */
1090
1091 static void
1092 print_arg_types (args, spaces)
1093 struct type **args;
1094 int spaces;
1095 {
1096 if (args != NULL)
1097 {
1098 while (*args != NULL)
1099 {
1100 recursive_dump_type (*args, spaces + 2);
1101 if ((*args++) -> code == TYPE_CODE_VOID)
1102 {
1103 break;
1104 }
1105 }
1106 }
1107 }
1108
1109 static void
1110 dump_fn_fieldlists (type, spaces)
1111 struct type *type;
1112 int spaces;
1113 {
1114 int method_idx;
1115 int overload_idx;
1116 struct fn_field *f;
1117
1118 printfi_filtered (spaces, "fn_fieldlists 0x%x\n",
1119 TYPE_FN_FIELDLISTS (type));
1120 for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
1121 {
1122 f = TYPE_FN_FIELDLIST1 (type, method_idx);
1123 printfi_filtered (spaces + 2, "[%d] name '%s' (0x%x) length %d\n",
1124 method_idx,
1125 TYPE_FN_FIELDLIST_NAME (type, method_idx),
1126 TYPE_FN_FIELDLIST_NAME (type, method_idx),
1127 TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
1128 for (overload_idx = 0;
1129 overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
1130 overload_idx++)
1131 {
1132 printfi_filtered (spaces + 4, "[%d] physname '%s' (0x%x)\n",
1133 overload_idx,
1134 TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
1135 TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
1136 printfi_filtered (spaces + 8, "type 0x%x\n",
1137 TYPE_FN_FIELD_TYPE (f, overload_idx));
1138 recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
1139 spaces + 8 + 2);
1140 printfi_filtered (spaces + 8, "args 0x%x\n",
1141 TYPE_FN_FIELD_ARGS (f, overload_idx));
1142 print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx), spaces);
1143 printfi_filtered (spaces + 8, "fcontext 0x%x\n",
1144 TYPE_FN_FIELD_FCONTEXT (f, overload_idx));
1145 printfi_filtered (spaces + 8, "is_const %d\n",
1146 TYPE_FN_FIELD_CONST (f, overload_idx));
1147 printfi_filtered (spaces + 8, "is_volatile %d\n",
1148 TYPE_FN_FIELD_VOLATILE (f, overload_idx));
1149 printfi_filtered (spaces + 8, "is_private %d\n",
1150 TYPE_FN_FIELD_PRIVATE (f, overload_idx));
1151 printfi_filtered (spaces + 8, "is_protected %d\n",
1152 TYPE_FN_FIELD_PROTECTED (f, overload_idx));
1153 printfi_filtered (spaces + 8, "is_stub %d\n",
1154 TYPE_FN_FIELD_STUB (f, overload_idx));
1155 printfi_filtered (spaces + 8, "voffset %u\n",
1156 TYPE_FN_FIELD_VOFFSET (f, overload_idx));
1157 }
1158 }
1159 }
1160
1161 static void
1162 print_cplus_stuff (type, spaces)
1163 struct type *type;
1164 int spaces;
1165 {
1166 printfi_filtered (spaces, "n_baseclasses %d\n",
1167 TYPE_N_BASECLASSES (type));
1168 printfi_filtered (spaces, "nfn_fields %d\n",
1169 TYPE_NFN_FIELDS (type));
1170 printfi_filtered (spaces, "nfn_fields_total %d\n",
1171 TYPE_NFN_FIELDS_TOTAL (type));
1172 if (TYPE_N_BASECLASSES (type) > 0)
1173 {
1174 printfi_filtered (spaces, "virtual_field_bits (%d bits at *0x%x)",
1175 TYPE_N_BASECLASSES (type),
1176 TYPE_FIELD_VIRTUAL_BITS (type));
1177 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
1178 TYPE_N_BASECLASSES (type));
1179 puts_filtered ("\n");
1180 }
1181 if (TYPE_NFIELDS (type) > 0)
1182 {
1183 if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
1184 {
1185 printfi_filtered (spaces, "private_field_bits (%d bits at *0x%x)",
1186 TYPE_NFIELDS (type),
1187 TYPE_FIELD_PRIVATE_BITS (type));
1188 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
1189 TYPE_NFIELDS (type));
1190 puts_filtered ("\n");
1191 }
1192 if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
1193 {
1194 printfi_filtered (spaces, "protected_field_bits (%d bits at *0x%x)",
1195 TYPE_NFIELDS (type),
1196 TYPE_FIELD_PROTECTED_BITS (type));
1197 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
1198 TYPE_NFIELDS (type));
1199 puts_filtered ("\n");
1200 }
1201 }
1202 if (TYPE_NFN_FIELDS (type) > 0)
1203 {
1204 dump_fn_fieldlists (type, spaces);
1205 }
1206 }
1207
1208 void
1209 recursive_dump_type (type, spaces)
1210 struct type *type;
1211 int spaces;
1212 {
1213 int idx;
1214
1215 printfi_filtered (spaces, "type node 0x%x\n", type);
1216 printfi_filtered (spaces, "name '%s' (0x%x)\n", TYPE_NAME (type),
1217 TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
1218 printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
1219 switch (TYPE_CODE (type))
1220 {
1221 case TYPE_CODE_UNDEF:
1222 printf_filtered ("(TYPE_CODE_UNDEF)");
1223 break;
1224 case TYPE_CODE_PTR:
1225 printf_filtered ("(TYPE_CODE_PTR)");
1226 break;
1227 case TYPE_CODE_ARRAY:
1228 printf_filtered ("(TYPE_CODE_ARRAY)");
1229 break;
1230 case TYPE_CODE_STRUCT:
1231 printf_filtered ("(TYPE_CODE_STRUCT)");
1232 break;
1233 case TYPE_CODE_UNION:
1234 printf_filtered ("(TYPE_CODE_UNION)");
1235 break;
1236 case TYPE_CODE_ENUM:
1237 printf_filtered ("(TYPE_CODE_ENUM)");
1238 break;
1239 case TYPE_CODE_FUNC:
1240 printf_filtered ("(TYPE_CODE_FUNC)");
1241 break;
1242 case TYPE_CODE_INT:
1243 printf_filtered ("(TYPE_CODE_INT)");
1244 break;
1245 case TYPE_CODE_FLT:
1246 printf_filtered ("(TYPE_CODE_FLT)");
1247 break;
1248 case TYPE_CODE_VOID:
1249 printf_filtered ("(TYPE_CODE_VOID)");
1250 break;
1251 case TYPE_CODE_SET:
1252 printf_filtered ("(TYPE_CODE_SET)");
1253 break;
1254 case TYPE_CODE_RANGE:
1255 printf_filtered ("(TYPE_CODE_RANGE)");
1256 break;
1257 case TYPE_CODE_STRING:
1258 printf_filtered ("(TYPE_CODE_STRING)");
1259 break;
1260 case TYPE_CODE_ERROR:
1261 printf_filtered ("(TYPE_CODE_ERROR)");
1262 break;
1263 case TYPE_CODE_MEMBER:
1264 printf_filtered ("(TYPE_CODE_MEMBER)");
1265 break;
1266 case TYPE_CODE_METHOD:
1267 printf_filtered ("(TYPE_CODE_METHOD)");
1268 break;
1269 case TYPE_CODE_REF:
1270 printf_filtered ("(TYPE_CODE_REF)");
1271 break;
1272 case TYPE_CODE_CHAR:
1273 printf_filtered ("(TYPE_CODE_CHAR)");
1274 break;
1275 case TYPE_CODE_BOOL:
1276 printf_filtered ("(TYPE_CODE_BOOL)");
1277 break;
1278 default:
1279 printf_filtered ("(UNKNOWN TYPE CODE)");
1280 break;
1281 }
1282 puts_filtered ("\n");
1283 printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
1284 printfi_filtered (spaces, "objfile 0x%x\n", TYPE_OBJFILE (type));
1285 printfi_filtered (spaces, "target_type 0x%x\n", TYPE_TARGET_TYPE (type));
1286 if (TYPE_TARGET_TYPE (type) != NULL)
1287 {
1288 recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
1289 }
1290 printfi_filtered (spaces, "pointer_type 0x%x\n",
1291 TYPE_POINTER_TYPE (type));
1292 printfi_filtered (spaces, "reference_type 0x%x\n",
1293 TYPE_REFERENCE_TYPE (type));
1294 printfi_filtered (spaces, "function_type 0x%x\n",
1295 TYPE_FUNCTION_TYPE (type));
1296 printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type));
1297 if (TYPE_FLAGS (type) & TYPE_FLAG_UNSIGNED)
1298 {
1299 puts_filtered (" TYPE_FLAG_UNSIGNED");
1300 }
1301 if (TYPE_FLAGS (type) & TYPE_FLAG_SIGNED)
1302 {
1303 puts_filtered (" TYPE_FLAG_SIGNED");
1304 }
1305 if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
1306 {
1307 puts_filtered (" TYPE_FLAG_STUB");
1308 }
1309 puts_filtered ("\n");
1310 printfi_filtered (spaces, "nfields %d 0x%x\n", TYPE_NFIELDS (type),
1311 TYPE_FIELDS (type));
1312 for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
1313 {
1314 printfi_filtered (spaces + 2,
1315 "[%d] bitpos %d bitsize %d type 0x%x name '%s' (0x%x)\n",
1316 idx, TYPE_FIELD_BITPOS (type, idx),
1317 TYPE_FIELD_BITSIZE (type, idx),
1318 TYPE_FIELD_TYPE (type, idx),
1319 TYPE_FIELD_NAME (type, idx),
1320 TYPE_FIELD_NAME (type, idx) != NULL
1321 ? TYPE_FIELD_NAME (type, idx)
1322 : "<NULL>");
1323 if (TYPE_FIELD_TYPE (type, idx) != NULL)
1324 {
1325 recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
1326 }
1327 }
1328 printfi_filtered (spaces, "vptr_basetype 0x%x\n",
1329 TYPE_VPTR_BASETYPE (type));
1330 if (TYPE_VPTR_BASETYPE (type) != NULL)
1331 {
1332 recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
1333 }
1334 printfi_filtered (spaces, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type));
1335 switch (TYPE_CODE (type))
1336 {
1337 case TYPE_CODE_METHOD:
1338 case TYPE_CODE_FUNC:
1339 printfi_filtered (spaces, "arg_types 0x%x\n", TYPE_ARG_TYPES (type));
1340 print_arg_types (TYPE_ARG_TYPES (type), spaces);
1341 break;
1342
1343 case TYPE_CODE_STRUCT:
1344 printfi_filtered (spaces, "cplus_stuff 0x%x\n",
1345 TYPE_CPLUS_SPECIFIC (type));
1346 print_cplus_stuff (type, spaces);
1347 break;
1348
1349 default:
1350 /* We have to pick one of the union types to be able print and test
1351 the value. Pick cplus_struct_type, even though we know it isn't
1352 any particular one. */
1353 printfi_filtered (spaces, "type_specific 0x%x",
1354 TYPE_CPLUS_SPECIFIC (type));
1355 if (TYPE_CPLUS_SPECIFIC (type) != NULL)
1356 {
1357 printf_filtered (" (unknown data form)");
1358 }
1359 printf_filtered ("\n");
1360 break;
1361
1362 }
1363 }
1364
1365 #endif /* MAINTENANCE_CMDS */
1366
1367 void
1368 _initialize_gdbtypes ()
1369 {
1370 builtin_type_void =
1371 init_type (TYPE_CODE_VOID, 1,
1372 0,
1373 "void", (struct objfile *) NULL);
1374 builtin_type_char =
1375 init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
1376 0,
1377 "char", (struct objfile *) NULL);
1378 builtin_type_signed_char =
1379 init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
1380 TYPE_FLAG_SIGNED,
1381 "signed char", (struct objfile *) NULL);
1382 builtin_type_unsigned_char =
1383 init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
1384 TYPE_FLAG_UNSIGNED,
1385 "unsigned char", (struct objfile *) NULL);
1386 builtin_type_short =
1387 init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
1388 0,
1389 "short", (struct objfile *) NULL);
1390 builtin_type_unsigned_short =
1391 init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
1392 TYPE_FLAG_UNSIGNED,
1393 "unsigned short", (struct objfile *) NULL);
1394 builtin_type_int =
1395 init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
1396 0,
1397 "int", (struct objfile *) NULL);
1398 builtin_type_unsigned_int =
1399 init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
1400 TYPE_FLAG_UNSIGNED,
1401 "unsigned int", (struct objfile *) NULL);
1402 builtin_type_long =
1403 init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
1404 0,
1405 "long", (struct objfile *) NULL);
1406 builtin_type_unsigned_long =
1407 init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
1408 TYPE_FLAG_UNSIGNED,
1409 "unsigned long", (struct objfile *) NULL);
1410 builtin_type_long_long =
1411 init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
1412 0,
1413 "long long", (struct objfile *) NULL);
1414 builtin_type_unsigned_long_long =
1415 init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
1416 TYPE_FLAG_UNSIGNED,
1417 "unsigned long long", (struct objfile *) NULL);
1418 builtin_type_float =
1419 init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
1420 0,
1421 "float", (struct objfile *) NULL);
1422 builtin_type_double =
1423 init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
1424 0,
1425 "double", (struct objfile *) NULL);
1426 builtin_type_long_double =
1427 init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
1428 0,
1429 "long double", (struct objfile *) NULL);
1430 builtin_type_complex =
1431 init_type (TYPE_CODE_FLT, TARGET_COMPLEX_BIT / TARGET_CHAR_BIT,
1432 0,
1433 "complex", (struct objfile *) NULL);
1434 builtin_type_double_complex =
1435 init_type (TYPE_CODE_FLT, TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
1436 0,
1437 "double complex", (struct objfile *) NULL);
1438 builtin_type_string =
1439 init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
1440 0,
1441 "string", (struct objfile *) NULL);
1442 }
This page took 0.08432 seconds and 4 git commands to generate.