gdb/
[deliverable/binutils-gdb.git] / gdb / gdbtypes.c
1 /* Support routines for manipulating internal types for GDB.
2
3 Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
4
5 Contributed by Cygnus Support, using pieces from other GDB modules.
6
7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21
22 #include "defs.h"
23 #include "gdb_string.h"
24 #include "bfd.h"
25 #include "symtab.h"
26 #include "symfile.h"
27 #include "objfiles.h"
28 #include "gdbtypes.h"
29 #include "expression.h"
30 #include "language.h"
31 #include "target.h"
32 #include "value.h"
33 #include "demangle.h"
34 #include "complaints.h"
35 #include "gdbcmd.h"
36 #include "cp-abi.h"
37 #include "gdb_assert.h"
38 #include "hashtab.h"
39 #include "exceptions.h"
40
41 /* Initialize BADNESS constants. */
42
43 const struct rank LENGTH_MISMATCH_BADNESS = {100,0};
44
45 const struct rank TOO_FEW_PARAMS_BADNESS = {100,0};
46 const struct rank INCOMPATIBLE_TYPE_BADNESS = {100,0};
47
48 const struct rank EXACT_MATCH_BADNESS = {0,0};
49
50 const struct rank INTEGER_PROMOTION_BADNESS = {1,0};
51 const struct rank FLOAT_PROMOTION_BADNESS = {1,0};
52 const struct rank BASE_PTR_CONVERSION_BADNESS = {1,0};
53 const struct rank INTEGER_CONVERSION_BADNESS = {2,0};
54 const struct rank FLOAT_CONVERSION_BADNESS = {2,0};
55 const struct rank INT_FLOAT_CONVERSION_BADNESS = {2,0};
56 const struct rank VOID_PTR_CONVERSION_BADNESS = {2,0};
57 const struct rank BOOL_PTR_CONVERSION_BADNESS = {3,0};
58 const struct rank BASE_CONVERSION_BADNESS = {2,0};
59 const struct rank REFERENCE_CONVERSION_BADNESS = {2,0};
60 const struct rank NULL_POINTER_CONVERSION_BADNESS = {2,0};
61 const struct rank NS_POINTER_CONVERSION_BADNESS = {10,0};
62
63 /* Floatformat pairs. */
64 const struct floatformat *floatformats_ieee_half[BFD_ENDIAN_UNKNOWN] = {
65 &floatformat_ieee_half_big,
66 &floatformat_ieee_half_little
67 };
68 const struct floatformat *floatformats_ieee_single[BFD_ENDIAN_UNKNOWN] = {
69 &floatformat_ieee_single_big,
70 &floatformat_ieee_single_little
71 };
72 const struct floatformat *floatformats_ieee_double[BFD_ENDIAN_UNKNOWN] = {
73 &floatformat_ieee_double_big,
74 &floatformat_ieee_double_little
75 };
76 const struct floatformat *floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN] = {
77 &floatformat_ieee_double_big,
78 &floatformat_ieee_double_littlebyte_bigword
79 };
80 const struct floatformat *floatformats_i387_ext[BFD_ENDIAN_UNKNOWN] = {
81 &floatformat_i387_ext,
82 &floatformat_i387_ext
83 };
84 const struct floatformat *floatformats_m68881_ext[BFD_ENDIAN_UNKNOWN] = {
85 &floatformat_m68881_ext,
86 &floatformat_m68881_ext
87 };
88 const struct floatformat *floatformats_arm_ext[BFD_ENDIAN_UNKNOWN] = {
89 &floatformat_arm_ext_big,
90 &floatformat_arm_ext_littlebyte_bigword
91 };
92 const struct floatformat *floatformats_ia64_spill[BFD_ENDIAN_UNKNOWN] = {
93 &floatformat_ia64_spill_big,
94 &floatformat_ia64_spill_little
95 };
96 const struct floatformat *floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN] = {
97 &floatformat_ia64_quad_big,
98 &floatformat_ia64_quad_little
99 };
100 const struct floatformat *floatformats_vax_f[BFD_ENDIAN_UNKNOWN] = {
101 &floatformat_vax_f,
102 &floatformat_vax_f
103 };
104 const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN] = {
105 &floatformat_vax_d,
106 &floatformat_vax_d
107 };
108 const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN] = {
109 &floatformat_ibm_long_double,
110 &floatformat_ibm_long_double
111 };
112
113
114 int opaque_type_resolution = 1;
115 static void
116 show_opaque_type_resolution (struct ui_file *file, int from_tty,
117 struct cmd_list_element *c,
118 const char *value)
119 {
120 fprintf_filtered (file, _("Resolution of opaque struct/class/union types "
121 "(if set before loading symbols) is %s.\n"),
122 value);
123 }
124
125 int overload_debug = 0;
126 static void
127 show_overload_debug (struct ui_file *file, int from_tty,
128 struct cmd_list_element *c, const char *value)
129 {
130 fprintf_filtered (file, _("Debugging of C++ overloading is %s.\n"),
131 value);
132 }
133
134 struct extra
135 {
136 char str[128];
137 int len;
138 }; /* Maximum extension is 128! FIXME */
139
140 static void print_bit_vector (B_TYPE *, int);
141 static void print_arg_types (struct field *, int, int);
142 static void dump_fn_fieldlists (struct type *, int);
143 static void print_cplus_stuff (struct type *, int);
144
145
146 /* Allocate a new OBJFILE-associated type structure and fill it
147 with some defaults. Space for the type structure is allocated
148 on the objfile's objfile_obstack. */
149
150 struct type *
151 alloc_type (struct objfile *objfile)
152 {
153 struct type *type;
154
155 gdb_assert (objfile != NULL);
156
157 /* Alloc the structure and start off with all fields zeroed. */
158 type = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct type);
159 TYPE_MAIN_TYPE (type) = OBSTACK_ZALLOC (&objfile->objfile_obstack,
160 struct main_type);
161 OBJSTAT (objfile, n_types++);
162
163 TYPE_OBJFILE_OWNED (type) = 1;
164 TYPE_OWNER (type).objfile = objfile;
165
166 /* Initialize the fields that might not be zero. */
167
168 TYPE_CODE (type) = TYPE_CODE_UNDEF;
169 TYPE_VPTR_FIELDNO (type) = -1;
170 TYPE_CHAIN (type) = type; /* Chain back to itself. */
171
172 return type;
173 }
174
175 /* Allocate a new GDBARCH-associated type structure and fill it
176 with some defaults. Space for the type structure is allocated
177 on the heap. */
178
179 struct type *
180 alloc_type_arch (struct gdbarch *gdbarch)
181 {
182 struct type *type;
183
184 gdb_assert (gdbarch != NULL);
185
186 /* Alloc the structure and start off with all fields zeroed. */
187
188 type = XZALLOC (struct type);
189 TYPE_MAIN_TYPE (type) = XZALLOC (struct main_type);
190
191 TYPE_OBJFILE_OWNED (type) = 0;
192 TYPE_OWNER (type).gdbarch = gdbarch;
193
194 /* Initialize the fields that might not be zero. */
195
196 TYPE_CODE (type) = TYPE_CODE_UNDEF;
197 TYPE_VPTR_FIELDNO (type) = -1;
198 TYPE_CHAIN (type) = type; /* Chain back to itself. */
199
200 return type;
201 }
202
203 /* If TYPE is objfile-associated, allocate a new type structure
204 associated with the same objfile. If TYPE is gdbarch-associated,
205 allocate a new type structure associated with the same gdbarch. */
206
207 struct type *
208 alloc_type_copy (const struct type *type)
209 {
210 if (TYPE_OBJFILE_OWNED (type))
211 return alloc_type (TYPE_OWNER (type).objfile);
212 else
213 return alloc_type_arch (TYPE_OWNER (type).gdbarch);
214 }
215
216 /* If TYPE is gdbarch-associated, return that architecture.
217 If TYPE is objfile-associated, return that objfile's architecture. */
218
219 struct gdbarch *
220 get_type_arch (const struct type *type)
221 {
222 if (TYPE_OBJFILE_OWNED (type))
223 return get_objfile_arch (TYPE_OWNER (type).objfile);
224 else
225 return TYPE_OWNER (type).gdbarch;
226 }
227
228
229 /* Alloc a new type instance structure, fill it with some defaults,
230 and point it at OLDTYPE. Allocate the new type instance from the
231 same place as OLDTYPE. */
232
233 static struct type *
234 alloc_type_instance (struct type *oldtype)
235 {
236 struct type *type;
237
238 /* Allocate the structure. */
239
240 if (! TYPE_OBJFILE_OWNED (oldtype))
241 type = XZALLOC (struct type);
242 else
243 type = OBSTACK_ZALLOC (&TYPE_OBJFILE (oldtype)->objfile_obstack,
244 struct type);
245
246 TYPE_MAIN_TYPE (type) = TYPE_MAIN_TYPE (oldtype);
247
248 TYPE_CHAIN (type) = type; /* Chain back to itself for now. */
249
250 return type;
251 }
252
253 /* Clear all remnants of the previous type at TYPE, in preparation for
254 replacing it with something else. Preserve owner information. */
255 static void
256 smash_type (struct type *type)
257 {
258 int objfile_owned = TYPE_OBJFILE_OWNED (type);
259 union type_owner owner = TYPE_OWNER (type);
260
261 memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type));
262
263 /* Restore owner information. */
264 TYPE_OBJFILE_OWNED (type) = objfile_owned;
265 TYPE_OWNER (type) = owner;
266
267 /* For now, delete the rings. */
268 TYPE_CHAIN (type) = type;
269
270 /* For now, leave the pointer/reference types alone. */
271 }
272
273 /* Lookup a pointer to a type TYPE. TYPEPTR, if nonzero, points
274 to a pointer to memory where the pointer type should be stored.
275 If *TYPEPTR is zero, update it to point to the pointer type we return.
276 We allocate new memory if needed. */
277
278 struct type *
279 make_pointer_type (struct type *type, struct type **typeptr)
280 {
281 struct type *ntype; /* New type */
282 struct type *chain;
283
284 ntype = TYPE_POINTER_TYPE (type);
285
286 if (ntype)
287 {
288 if (typeptr == 0)
289 return ntype; /* Don't care about alloc,
290 and have new type. */
291 else if (*typeptr == 0)
292 {
293 *typeptr = ntype; /* Tracking alloc, and have new type. */
294 return ntype;
295 }
296 }
297
298 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
299 {
300 ntype = alloc_type_copy (type);
301 if (typeptr)
302 *typeptr = ntype;
303 }
304 else /* We have storage, but need to reset it. */
305 {
306 ntype = *typeptr;
307 chain = TYPE_CHAIN (ntype);
308 smash_type (ntype);
309 TYPE_CHAIN (ntype) = chain;
310 }
311
312 TYPE_TARGET_TYPE (ntype) = type;
313 TYPE_POINTER_TYPE (type) = ntype;
314
315 /* FIXME! Assume the machine has only one representation for
316 pointers! */
317
318 TYPE_LENGTH (ntype)
319 = gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
320 TYPE_CODE (ntype) = TYPE_CODE_PTR;
321
322 /* Mark pointers as unsigned. The target converts between pointers
323 and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
324 gdbarch_address_to_pointer. */
325 TYPE_UNSIGNED (ntype) = 1;
326
327 if (!TYPE_POINTER_TYPE (type)) /* Remember it, if don't have one. */
328 TYPE_POINTER_TYPE (type) = ntype;
329
330 /* Update the length of all the other variants of this type. */
331 chain = TYPE_CHAIN (ntype);
332 while (chain != ntype)
333 {
334 TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
335 chain = TYPE_CHAIN (chain);
336 }
337
338 return ntype;
339 }
340
341 /* Given a type TYPE, return a type of pointers to that type.
342 May need to construct such a type if this is the first use. */
343
344 struct type *
345 lookup_pointer_type (struct type *type)
346 {
347 return make_pointer_type (type, (struct type **) 0);
348 }
349
350 /* Lookup a C++ `reference' to a type TYPE. TYPEPTR, if nonzero,
351 points to a pointer to memory where the reference type should be
352 stored. If *TYPEPTR is zero, update it to point to the reference
353 type we return. We allocate new memory if needed. */
354
355 struct type *
356 make_reference_type (struct type *type, struct type **typeptr)
357 {
358 struct type *ntype; /* New type */
359 struct type *chain;
360
361 ntype = TYPE_REFERENCE_TYPE (type);
362
363 if (ntype)
364 {
365 if (typeptr == 0)
366 return ntype; /* Don't care about alloc,
367 and have new type. */
368 else if (*typeptr == 0)
369 {
370 *typeptr = ntype; /* Tracking alloc, and have new type. */
371 return ntype;
372 }
373 }
374
375 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
376 {
377 ntype = alloc_type_copy (type);
378 if (typeptr)
379 *typeptr = ntype;
380 }
381 else /* We have storage, but need to reset it. */
382 {
383 ntype = *typeptr;
384 chain = TYPE_CHAIN (ntype);
385 smash_type (ntype);
386 TYPE_CHAIN (ntype) = chain;
387 }
388
389 TYPE_TARGET_TYPE (ntype) = type;
390 TYPE_REFERENCE_TYPE (type) = ntype;
391
392 /* FIXME! Assume the machine has only one representation for
393 references, and that it matches the (only) representation for
394 pointers! */
395
396 TYPE_LENGTH (ntype) =
397 gdbarch_ptr_bit (get_type_arch (type)) / TARGET_CHAR_BIT;
398 TYPE_CODE (ntype) = TYPE_CODE_REF;
399
400 if (!TYPE_REFERENCE_TYPE (type)) /* Remember it, if don't have one. */
401 TYPE_REFERENCE_TYPE (type) = ntype;
402
403 /* Update the length of all the other variants of this type. */
404 chain = TYPE_CHAIN (ntype);
405 while (chain != ntype)
406 {
407 TYPE_LENGTH (chain) = TYPE_LENGTH (ntype);
408 chain = TYPE_CHAIN (chain);
409 }
410
411 return ntype;
412 }
413
414 /* Same as above, but caller doesn't care about memory allocation
415 details. */
416
417 struct type *
418 lookup_reference_type (struct type *type)
419 {
420 return make_reference_type (type, (struct type **) 0);
421 }
422
423 /* Lookup a function type that returns type TYPE. TYPEPTR, if
424 nonzero, points to a pointer to memory where the function type
425 should be stored. If *TYPEPTR is zero, update it to point to the
426 function type we return. We allocate new memory if needed. */
427
428 struct type *
429 make_function_type (struct type *type, struct type **typeptr)
430 {
431 struct type *ntype; /* New type */
432
433 if (typeptr == 0 || *typeptr == 0) /* We'll need to allocate one. */
434 {
435 ntype = alloc_type_copy (type);
436 if (typeptr)
437 *typeptr = ntype;
438 }
439 else /* We have storage, but need to reset it. */
440 {
441 ntype = *typeptr;
442 smash_type (ntype);
443 }
444
445 TYPE_TARGET_TYPE (ntype) = type;
446
447 TYPE_LENGTH (ntype) = 1;
448 TYPE_CODE (ntype) = TYPE_CODE_FUNC;
449
450 INIT_FUNC_SPECIFIC (ntype);
451
452 return ntype;
453 }
454
455
456 /* Given a type TYPE, return a type of functions that return that type.
457 May need to construct such a type if this is the first use. */
458
459 struct type *
460 lookup_function_type (struct type *type)
461 {
462 return make_function_type (type, (struct type **) 0);
463 }
464
465 /* Identify address space identifier by name --
466 return the integer flag defined in gdbtypes.h. */
467 extern int
468 address_space_name_to_int (struct gdbarch *gdbarch, char *space_identifier)
469 {
470 int type_flags;
471
472 /* Check for known address space delimiters. */
473 if (!strcmp (space_identifier, "code"))
474 return TYPE_INSTANCE_FLAG_CODE_SPACE;
475 else if (!strcmp (space_identifier, "data"))
476 return TYPE_INSTANCE_FLAG_DATA_SPACE;
477 else if (gdbarch_address_class_name_to_type_flags_p (gdbarch)
478 && gdbarch_address_class_name_to_type_flags (gdbarch,
479 space_identifier,
480 &type_flags))
481 return type_flags;
482 else
483 error (_("Unknown address space specifier: \"%s\""), space_identifier);
484 }
485
486 /* Identify address space identifier by integer flag as defined in
487 gdbtypes.h -- return the string version of the adress space name. */
488
489 const char *
490 address_space_int_to_name (struct gdbarch *gdbarch, int space_flag)
491 {
492 if (space_flag & TYPE_INSTANCE_FLAG_CODE_SPACE)
493 return "code";
494 else if (space_flag & TYPE_INSTANCE_FLAG_DATA_SPACE)
495 return "data";
496 else if ((space_flag & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
497 && gdbarch_address_class_type_flags_to_name_p (gdbarch))
498 return gdbarch_address_class_type_flags_to_name (gdbarch, space_flag);
499 else
500 return NULL;
501 }
502
503 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
504
505 If STORAGE is non-NULL, create the new type instance there.
506 STORAGE must be in the same obstack as TYPE. */
507
508 static struct type *
509 make_qualified_type (struct type *type, int new_flags,
510 struct type *storage)
511 {
512 struct type *ntype;
513
514 ntype = type;
515 do
516 {
517 if (TYPE_INSTANCE_FLAGS (ntype) == new_flags)
518 return ntype;
519 ntype = TYPE_CHAIN (ntype);
520 }
521 while (ntype != type);
522
523 /* Create a new type instance. */
524 if (storage == NULL)
525 ntype = alloc_type_instance (type);
526 else
527 {
528 /* If STORAGE was provided, it had better be in the same objfile
529 as TYPE. Otherwise, we can't link it into TYPE's cv chain:
530 if one objfile is freed and the other kept, we'd have
531 dangling pointers. */
532 gdb_assert (TYPE_OBJFILE (type) == TYPE_OBJFILE (storage));
533
534 ntype = storage;
535 TYPE_MAIN_TYPE (ntype) = TYPE_MAIN_TYPE (type);
536 TYPE_CHAIN (ntype) = ntype;
537 }
538
539 /* Pointers or references to the original type are not relevant to
540 the new type. */
541 TYPE_POINTER_TYPE (ntype) = (struct type *) 0;
542 TYPE_REFERENCE_TYPE (ntype) = (struct type *) 0;
543
544 /* Chain the new qualified type to the old type. */
545 TYPE_CHAIN (ntype) = TYPE_CHAIN (type);
546 TYPE_CHAIN (type) = ntype;
547
548 /* Now set the instance flags and return the new type. */
549 TYPE_INSTANCE_FLAGS (ntype) = new_flags;
550
551 /* Set length of new type to that of the original type. */
552 TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
553
554 return ntype;
555 }
556
557 /* Make an address-space-delimited variant of a type -- a type that
558 is identical to the one supplied except that it has an address
559 space attribute attached to it (such as "code" or "data").
560
561 The space attributes "code" and "data" are for Harvard
562 architectures. The address space attributes are for architectures
563 which have alternately sized pointers or pointers with alternate
564 representations. */
565
566 struct type *
567 make_type_with_address_space (struct type *type, int space_flag)
568 {
569 int new_flags = ((TYPE_INSTANCE_FLAGS (type)
570 & ~(TYPE_INSTANCE_FLAG_CODE_SPACE
571 | TYPE_INSTANCE_FLAG_DATA_SPACE
572 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL))
573 | space_flag);
574
575 return make_qualified_type (type, new_flags, NULL);
576 }
577
578 /* Make a "c-v" variant of a type -- a type that is identical to the
579 one supplied except that it may have const or volatile attributes
580 CNST is a flag for setting the const attribute
581 VOLTL is a flag for setting the volatile attribute
582 TYPE is the base type whose variant we are creating.
583
584 If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
585 storage to hold the new qualified type; *TYPEPTR and TYPE must be
586 in the same objfile. Otherwise, allocate fresh memory for the new
587 type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
588 new type we construct. */
589 struct type *
590 make_cv_type (int cnst, int voltl,
591 struct type *type,
592 struct type **typeptr)
593 {
594 struct type *ntype; /* New type */
595
596 int new_flags = (TYPE_INSTANCE_FLAGS (type)
597 & ~(TYPE_INSTANCE_FLAG_CONST
598 | TYPE_INSTANCE_FLAG_VOLATILE));
599
600 if (cnst)
601 new_flags |= TYPE_INSTANCE_FLAG_CONST;
602
603 if (voltl)
604 new_flags |= TYPE_INSTANCE_FLAG_VOLATILE;
605
606 if (typeptr && *typeptr != NULL)
607 {
608 /* TYPE and *TYPEPTR must be in the same objfile. We can't have
609 a C-V variant chain that threads across objfiles: if one
610 objfile gets freed, then the other has a broken C-V chain.
611
612 This code used to try to copy over the main type from TYPE to
613 *TYPEPTR if they were in different objfiles, but that's
614 wrong, too: TYPE may have a field list or member function
615 lists, which refer to types of their own, etc. etc. The
616 whole shebang would need to be copied over recursively; you
617 can't have inter-objfile pointers. The only thing to do is
618 to leave stub types as stub types, and look them up afresh by
619 name each time you encounter them. */
620 gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type));
621 }
622
623 ntype = make_qualified_type (type, new_flags,
624 typeptr ? *typeptr : NULL);
625
626 if (typeptr != NULL)
627 *typeptr = ntype;
628
629 return ntype;
630 }
631
632 /* Replace the contents of ntype with the type *type. This changes the
633 contents, rather than the pointer for TYPE_MAIN_TYPE (ntype); thus
634 the changes are propogated to all types in the TYPE_CHAIN.
635
636 In order to build recursive types, it's inevitable that we'll need
637 to update types in place --- but this sort of indiscriminate
638 smashing is ugly, and needs to be replaced with something more
639 controlled. TYPE_MAIN_TYPE is a step in this direction; it's not
640 clear if more steps are needed. */
641 void
642 replace_type (struct type *ntype, struct type *type)
643 {
644 struct type *chain;
645
646 /* These two types had better be in the same objfile. Otherwise,
647 the assignment of one type's main type structure to the other
648 will produce a type with references to objects (names; field
649 lists; etc.) allocated on an objfile other than its own. */
650 gdb_assert (TYPE_OBJFILE (ntype) == TYPE_OBJFILE (ntype));
651
652 *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type);
653
654 /* The type length is not a part of the main type. Update it for
655 each type on the variant chain. */
656 chain = ntype;
657 do
658 {
659 /* Assert that this element of the chain has no address-class bits
660 set in its flags. Such type variants might have type lengths
661 which are supposed to be different from the non-address-class
662 variants. This assertion shouldn't ever be triggered because
663 symbol readers which do construct address-class variants don't
664 call replace_type(). */
665 gdb_assert (TYPE_ADDRESS_CLASS_ALL (chain) == 0);
666
667 TYPE_LENGTH (chain) = TYPE_LENGTH (type);
668 chain = TYPE_CHAIN (chain);
669 }
670 while (ntype != chain);
671
672 /* Assert that the two types have equivalent instance qualifiers.
673 This should be true for at least all of our debug readers. */
674 gdb_assert (TYPE_INSTANCE_FLAGS (ntype) == TYPE_INSTANCE_FLAGS (type));
675 }
676
677 /* Implement direct support for MEMBER_TYPE in GNU C++.
678 May need to construct such a type if this is the first use.
679 The TYPE is the type of the member. The DOMAIN is the type
680 of the aggregate that the member belongs to. */
681
682 struct type *
683 lookup_memberptr_type (struct type *type, struct type *domain)
684 {
685 struct type *mtype;
686
687 mtype = alloc_type_copy (type);
688 smash_to_memberptr_type (mtype, domain, type);
689 return mtype;
690 }
691
692 /* Return a pointer-to-method type, for a method of type TO_TYPE. */
693
694 struct type *
695 lookup_methodptr_type (struct type *to_type)
696 {
697 struct type *mtype;
698
699 mtype = alloc_type_copy (to_type);
700 smash_to_methodptr_type (mtype, to_type);
701 return mtype;
702 }
703
704 /* Allocate a stub method whose return type is TYPE. This apparently
705 happens for speed of symbol reading, since parsing out the
706 arguments to the method is cpu-intensive, the way we are doing it.
707 So, we will fill in arguments later. This always returns a fresh
708 type. */
709
710 struct type *
711 allocate_stub_method (struct type *type)
712 {
713 struct type *mtype;
714
715 mtype = alloc_type_copy (type);
716 TYPE_CODE (mtype) = TYPE_CODE_METHOD;
717 TYPE_LENGTH (mtype) = 1;
718 TYPE_STUB (mtype) = 1;
719 TYPE_TARGET_TYPE (mtype) = type;
720 /* _DOMAIN_TYPE (mtype) = unknown yet */
721 return mtype;
722 }
723
724 /* Create a range type using either a blank type supplied in
725 RESULT_TYPE, or creating a new type, inheriting the objfile from
726 INDEX_TYPE.
727
728 Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
729 to HIGH_BOUND, inclusive.
730
731 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
732 sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
733
734 struct type *
735 create_range_type (struct type *result_type, struct type *index_type,
736 LONGEST low_bound, LONGEST high_bound)
737 {
738 if (result_type == NULL)
739 result_type = alloc_type_copy (index_type);
740 TYPE_CODE (result_type) = TYPE_CODE_RANGE;
741 TYPE_TARGET_TYPE (result_type) = index_type;
742 if (TYPE_STUB (index_type))
743 TYPE_TARGET_STUB (result_type) = 1;
744 else
745 TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type));
746 TYPE_RANGE_DATA (result_type) = (struct range_bounds *)
747 TYPE_ZALLOC (result_type, sizeof (struct range_bounds));
748 TYPE_LOW_BOUND (result_type) = low_bound;
749 TYPE_HIGH_BOUND (result_type) = high_bound;
750
751 if (low_bound >= 0)
752 TYPE_UNSIGNED (result_type) = 1;
753
754 return result_type;
755 }
756
757 /* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
758 TYPE. Return 1 if type is a range type, 0 if it is discrete (and
759 bounds will fit in LONGEST), or -1 otherwise. */
760
761 int
762 get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
763 {
764 CHECK_TYPEDEF (type);
765 switch (TYPE_CODE (type))
766 {
767 case TYPE_CODE_RANGE:
768 *lowp = TYPE_LOW_BOUND (type);
769 *highp = TYPE_HIGH_BOUND (type);
770 return 1;
771 case TYPE_CODE_ENUM:
772 if (TYPE_NFIELDS (type) > 0)
773 {
774 /* The enums may not be sorted by value, so search all
775 entries. */
776 int i;
777
778 *lowp = *highp = TYPE_FIELD_ENUMVAL (type, 0);
779 for (i = 0; i < TYPE_NFIELDS (type); i++)
780 {
781 if (TYPE_FIELD_ENUMVAL (type, i) < *lowp)
782 *lowp = TYPE_FIELD_ENUMVAL (type, i);
783 if (TYPE_FIELD_ENUMVAL (type, i) > *highp)
784 *highp = TYPE_FIELD_ENUMVAL (type, i);
785 }
786
787 /* Set unsigned indicator if warranted. */
788 if (*lowp >= 0)
789 {
790 TYPE_UNSIGNED (type) = 1;
791 }
792 }
793 else
794 {
795 *lowp = 0;
796 *highp = -1;
797 }
798 return 0;
799 case TYPE_CODE_BOOL:
800 *lowp = 0;
801 *highp = 1;
802 return 0;
803 case TYPE_CODE_INT:
804 if (TYPE_LENGTH (type) > sizeof (LONGEST)) /* Too big */
805 return -1;
806 if (!TYPE_UNSIGNED (type))
807 {
808 *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1));
809 *highp = -*lowp - 1;
810 return 0;
811 }
812 /* ... fall through for unsigned ints ... */
813 case TYPE_CODE_CHAR:
814 *lowp = 0;
815 /* This round-about calculation is to avoid shifting by
816 TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
817 if TYPE_LENGTH (type) == sizeof (LONGEST). */
818 *highp = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1);
819 *highp = (*highp - 1) | *highp;
820 return 0;
821 default:
822 return -1;
823 }
824 }
825
826 /* Assuming TYPE is a simple, non-empty array type, compute its upper
827 and lower bound. Save the low bound into LOW_BOUND if not NULL.
828 Save the high bound into HIGH_BOUND if not NULL.
829
830 Return 1 if the operation was successful. Return zero otherwise,
831 in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
832
833 We now simply use get_discrete_bounds call to get the values
834 of the low and high bounds.
835 get_discrete_bounds can return three values:
836 1, meaning that index is a range,
837 0, meaning that index is a discrete type,
838 or -1 for failure. */
839
840 int
841 get_array_bounds (struct type *type, LONGEST *low_bound, LONGEST *high_bound)
842 {
843 struct type *index = TYPE_INDEX_TYPE (type);
844 LONGEST low = 0;
845 LONGEST high = 0;
846 int res;
847
848 if (index == NULL)
849 return 0;
850
851 res = get_discrete_bounds (index, &low, &high);
852 if (res == -1)
853 return 0;
854
855 /* Check if the array bounds are undefined. */
856 if (res == 1
857 && ((low_bound && TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED (type))
858 || (high_bound && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))))
859 return 0;
860
861 if (low_bound)
862 *low_bound = low;
863
864 if (high_bound)
865 *high_bound = high;
866
867 return 1;
868 }
869
870 /* Create an array type using either a blank type supplied in
871 RESULT_TYPE, or creating a new type, inheriting the objfile from
872 RANGE_TYPE.
873
874 Elements will be of type ELEMENT_TYPE, the indices will be of type
875 RANGE_TYPE.
876
877 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
878 sure it is TYPE_CODE_UNDEF before we bash it into an array
879 type? */
880
881 struct type *
882 create_array_type (struct type *result_type,
883 struct type *element_type,
884 struct type *range_type)
885 {
886 LONGEST low_bound, high_bound;
887
888 if (result_type == NULL)
889 result_type = alloc_type_copy (range_type);
890
891 TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
892 TYPE_TARGET_TYPE (result_type) = element_type;
893 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
894 low_bound = high_bound = 0;
895 CHECK_TYPEDEF (element_type);
896 /* Be careful when setting the array length. Ada arrays can be
897 empty arrays with the high_bound being smaller than the low_bound.
898 In such cases, the array length should be zero. */
899 if (high_bound < low_bound)
900 TYPE_LENGTH (result_type) = 0;
901 else
902 TYPE_LENGTH (result_type) =
903 TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
904 TYPE_NFIELDS (result_type) = 1;
905 TYPE_FIELDS (result_type) =
906 (struct field *) TYPE_ZALLOC (result_type, sizeof (struct field));
907 TYPE_INDEX_TYPE (result_type) = range_type;
908 TYPE_VPTR_FIELDNO (result_type) = -1;
909
910 /* TYPE_FLAG_TARGET_STUB will take care of zero length arrays. */
911 if (TYPE_LENGTH (result_type) == 0)
912 TYPE_TARGET_STUB (result_type) = 1;
913
914 return result_type;
915 }
916
917 struct type *
918 lookup_array_range_type (struct type *element_type,
919 int low_bound, int high_bound)
920 {
921 struct gdbarch *gdbarch = get_type_arch (element_type);
922 struct type *index_type = builtin_type (gdbarch)->builtin_int;
923 struct type *range_type
924 = create_range_type (NULL, index_type, low_bound, high_bound);
925
926 return create_array_type (NULL, element_type, range_type);
927 }
928
929 /* Create a string type using either a blank type supplied in
930 RESULT_TYPE, or creating a new type. String types are similar
931 enough to array of char types that we can use create_array_type to
932 build the basic type and then bash it into a string type.
933
934 For fixed length strings, the range type contains 0 as the lower
935 bound and the length of the string minus one as the upper bound.
936
937 FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
938 sure it is TYPE_CODE_UNDEF before we bash it into a string
939 type? */
940
941 struct type *
942 create_string_type (struct type *result_type,
943 struct type *string_char_type,
944 struct type *range_type)
945 {
946 result_type = create_array_type (result_type,
947 string_char_type,
948 range_type);
949 TYPE_CODE (result_type) = TYPE_CODE_STRING;
950 return result_type;
951 }
952
953 struct type *
954 lookup_string_range_type (struct type *string_char_type,
955 int low_bound, int high_bound)
956 {
957 struct type *result_type;
958
959 result_type = lookup_array_range_type (string_char_type,
960 low_bound, high_bound);
961 TYPE_CODE (result_type) = TYPE_CODE_STRING;
962 return result_type;
963 }
964
965 struct type *
966 create_set_type (struct type *result_type, struct type *domain_type)
967 {
968 if (result_type == NULL)
969 result_type = alloc_type_copy (domain_type);
970
971 TYPE_CODE (result_type) = TYPE_CODE_SET;
972 TYPE_NFIELDS (result_type) = 1;
973 TYPE_FIELDS (result_type) = TYPE_ZALLOC (result_type, sizeof (struct field));
974
975 if (!TYPE_STUB (domain_type))
976 {
977 LONGEST low_bound, high_bound, bit_length;
978
979 if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0)
980 low_bound = high_bound = 0;
981 bit_length = high_bound - low_bound + 1;
982 TYPE_LENGTH (result_type)
983 = (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
984 if (low_bound >= 0)
985 TYPE_UNSIGNED (result_type) = 1;
986 }
987 TYPE_FIELD_TYPE (result_type, 0) = domain_type;
988
989 return result_type;
990 }
991
992 /* Convert ARRAY_TYPE to a vector type. This may modify ARRAY_TYPE
993 and any array types nested inside it. */
994
995 void
996 make_vector_type (struct type *array_type)
997 {
998 struct type *inner_array, *elt_type;
999 int flags;
1000
1001 /* Find the innermost array type, in case the array is
1002 multi-dimensional. */
1003 inner_array = array_type;
1004 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
1005 inner_array = TYPE_TARGET_TYPE (inner_array);
1006
1007 elt_type = TYPE_TARGET_TYPE (inner_array);
1008 if (TYPE_CODE (elt_type) == TYPE_CODE_INT)
1009 {
1010 flags = TYPE_INSTANCE_FLAGS (elt_type) | TYPE_INSTANCE_FLAG_NOTTEXT;
1011 elt_type = make_qualified_type (elt_type, flags, NULL);
1012 TYPE_TARGET_TYPE (inner_array) = elt_type;
1013 }
1014
1015 TYPE_VECTOR (array_type) = 1;
1016 }
1017
1018 struct type *
1019 init_vector_type (struct type *elt_type, int n)
1020 {
1021 struct type *array_type;
1022
1023 array_type = lookup_array_range_type (elt_type, 0, n - 1);
1024 make_vector_type (array_type);
1025 return array_type;
1026 }
1027
1028 /* Smash TYPE to be a type of pointers to members of DOMAIN with type
1029 TO_TYPE. A member pointer is a wierd thing -- it amounts to a
1030 typed offset into a struct, e.g. "an int at offset 8". A MEMBER
1031 TYPE doesn't include the offset (that's the value of the MEMBER
1032 itself), but does include the structure type into which it points
1033 (for some reason).
1034
1035 When "smashing" the type, we preserve the objfile that the old type
1036 pointed to, since we aren't changing where the type is actually
1037 allocated. */
1038
1039 void
1040 smash_to_memberptr_type (struct type *type, struct type *domain,
1041 struct type *to_type)
1042 {
1043 smash_type (type);
1044 TYPE_TARGET_TYPE (type) = to_type;
1045 TYPE_DOMAIN_TYPE (type) = domain;
1046 /* Assume that a data member pointer is the same size as a normal
1047 pointer. */
1048 TYPE_LENGTH (type)
1049 = gdbarch_ptr_bit (get_type_arch (to_type)) / TARGET_CHAR_BIT;
1050 TYPE_CODE (type) = TYPE_CODE_MEMBERPTR;
1051 }
1052
1053 /* Smash TYPE to be a type of pointer to methods type TO_TYPE.
1054
1055 When "smashing" the type, we preserve the objfile that the old type
1056 pointed to, since we aren't changing where the type is actually
1057 allocated. */
1058
1059 void
1060 smash_to_methodptr_type (struct type *type, struct type *to_type)
1061 {
1062 smash_type (type);
1063 TYPE_TARGET_TYPE (type) = to_type;
1064 TYPE_DOMAIN_TYPE (type) = TYPE_DOMAIN_TYPE (to_type);
1065 TYPE_LENGTH (type) = cplus_method_ptr_size (to_type);
1066 TYPE_CODE (type) = TYPE_CODE_METHODPTR;
1067 }
1068
1069 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
1070 METHOD just means `function that gets an extra "this" argument'.
1071
1072 When "smashing" the type, we preserve the objfile that the old type
1073 pointed to, since we aren't changing where the type is actually
1074 allocated. */
1075
1076 void
1077 smash_to_method_type (struct type *type, struct type *domain,
1078 struct type *to_type, struct field *args,
1079 int nargs, int varargs)
1080 {
1081 smash_type (type);
1082 TYPE_TARGET_TYPE (type) = to_type;
1083 TYPE_DOMAIN_TYPE (type) = domain;
1084 TYPE_FIELDS (type) = args;
1085 TYPE_NFIELDS (type) = nargs;
1086 if (varargs)
1087 TYPE_VARARGS (type) = 1;
1088 TYPE_LENGTH (type) = 1; /* In practice, this is never needed. */
1089 TYPE_CODE (type) = TYPE_CODE_METHOD;
1090 }
1091
1092 /* Return a typename for a struct/union/enum type without "struct ",
1093 "union ", or "enum ". If the type has a NULL name, return NULL. */
1094
1095 const char *
1096 type_name_no_tag (const struct type *type)
1097 {
1098 if (TYPE_TAG_NAME (type) != NULL)
1099 return TYPE_TAG_NAME (type);
1100
1101 /* Is there code which expects this to return the name if there is
1102 no tag name? My guess is that this is mainly used for C++ in
1103 cases where the two will always be the same. */
1104 return TYPE_NAME (type);
1105 }
1106
1107 /* A wrapper of type_name_no_tag which calls error if the type is anonymous.
1108 Since GCC PR debug/47510 DWARF provides associated information to detect the
1109 anonymous class linkage name from its typedef.
1110
1111 Parameter TYPE should not yet have CHECK_TYPEDEF applied, this function will
1112 apply it itself. */
1113
1114 const char *
1115 type_name_no_tag_or_error (struct type *type)
1116 {
1117 struct type *saved_type = type;
1118 const char *name;
1119 struct objfile *objfile;
1120
1121 CHECK_TYPEDEF (type);
1122
1123 name = type_name_no_tag (type);
1124 if (name != NULL)
1125 return name;
1126
1127 name = type_name_no_tag (saved_type);
1128 objfile = TYPE_OBJFILE (saved_type);
1129 error (_("Invalid anonymous type %s [in module %s], GCC PR debug/47510 bug?"),
1130 name ? name : "<anonymous>", objfile ? objfile->name : "<arch>");
1131 }
1132
1133 /* Lookup a typedef or primitive type named NAME, visible in lexical
1134 block BLOCK. If NOERR is nonzero, return zero if NAME is not
1135 suitably defined. */
1136
1137 struct type *
1138 lookup_typename (const struct language_defn *language,
1139 struct gdbarch *gdbarch, const char *name,
1140 const struct block *block, int noerr)
1141 {
1142 struct symbol *sym;
1143 struct type *tmp;
1144
1145 sym = lookup_symbol (name, block, VAR_DOMAIN, 0);
1146 if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
1147 {
1148 tmp = language_lookup_primitive_type_by_name (language, gdbarch, name);
1149 if (tmp)
1150 {
1151 return tmp;
1152 }
1153 else if (!tmp && noerr)
1154 {
1155 return NULL;
1156 }
1157 else
1158 {
1159 error (_("No type named %s."), name);
1160 }
1161 }
1162 return (SYMBOL_TYPE (sym));
1163 }
1164
1165 struct type *
1166 lookup_unsigned_typename (const struct language_defn *language,
1167 struct gdbarch *gdbarch, const char *name)
1168 {
1169 char *uns = alloca (strlen (name) + 10);
1170
1171 strcpy (uns, "unsigned ");
1172 strcpy (uns + 9, name);
1173 return lookup_typename (language, gdbarch, uns, (struct block *) NULL, 0);
1174 }
1175
1176 struct type *
1177 lookup_signed_typename (const struct language_defn *language,
1178 struct gdbarch *gdbarch, const char *name)
1179 {
1180 struct type *t;
1181 char *uns = alloca (strlen (name) + 8);
1182
1183 strcpy (uns, "signed ");
1184 strcpy (uns + 7, name);
1185 t = lookup_typename (language, gdbarch, uns, (struct block *) NULL, 1);
1186 /* If we don't find "signed FOO" just try again with plain "FOO". */
1187 if (t != NULL)
1188 return t;
1189 return lookup_typename (language, gdbarch, name, (struct block *) NULL, 0);
1190 }
1191
1192 /* Lookup a structure type named "struct NAME",
1193 visible in lexical block BLOCK. */
1194
1195 struct type *
1196 lookup_struct (const char *name, struct block *block)
1197 {
1198 struct symbol *sym;
1199
1200 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
1201
1202 if (sym == NULL)
1203 {
1204 error (_("No struct type named %s."), name);
1205 }
1206 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1207 {
1208 error (_("This context has class, union or enum %s, not a struct."),
1209 name);
1210 }
1211 return (SYMBOL_TYPE (sym));
1212 }
1213
1214 /* Lookup a union type named "union NAME",
1215 visible in lexical block BLOCK. */
1216
1217 struct type *
1218 lookup_union (const char *name, struct block *block)
1219 {
1220 struct symbol *sym;
1221 struct type *t;
1222
1223 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
1224
1225 if (sym == NULL)
1226 error (_("No union type named %s."), name);
1227
1228 t = SYMBOL_TYPE (sym);
1229
1230 if (TYPE_CODE (t) == TYPE_CODE_UNION)
1231 return t;
1232
1233 /* If we get here, it's not a union. */
1234 error (_("This context has class, struct or enum %s, not a union."),
1235 name);
1236 }
1237
1238
1239 /* Lookup an enum type named "enum NAME",
1240 visible in lexical block BLOCK. */
1241
1242 struct type *
1243 lookup_enum (const char *name, struct block *block)
1244 {
1245 struct symbol *sym;
1246
1247 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
1248 if (sym == NULL)
1249 {
1250 error (_("No enum type named %s."), name);
1251 }
1252 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
1253 {
1254 error (_("This context has class, struct or union %s, not an enum."),
1255 name);
1256 }
1257 return (SYMBOL_TYPE (sym));
1258 }
1259
1260 /* Lookup a template type named "template NAME<TYPE>",
1261 visible in lexical block BLOCK. */
1262
1263 struct type *
1264 lookup_template_type (char *name, struct type *type,
1265 struct block *block)
1266 {
1267 struct symbol *sym;
1268 char *nam = (char *)
1269 alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4);
1270
1271 strcpy (nam, name);
1272 strcat (nam, "<");
1273 strcat (nam, TYPE_NAME (type));
1274 strcat (nam, " >"); /* FIXME, extra space still introduced in gcc? */
1275
1276 sym = lookup_symbol (nam, block, VAR_DOMAIN, 0);
1277
1278 if (sym == NULL)
1279 {
1280 error (_("No template type named %s."), name);
1281 }
1282 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
1283 {
1284 error (_("This context has class, union or enum %s, not a struct."),
1285 name);
1286 }
1287 return (SYMBOL_TYPE (sym));
1288 }
1289
1290 /* Given a type TYPE, lookup the type of the component of type named
1291 NAME.
1292
1293 TYPE can be either a struct or union, or a pointer or reference to
1294 a struct or union. If it is a pointer or reference, its target
1295 type is automatically used. Thus '.' and '->' are interchangable,
1296 as specified for the definitions of the expression element types
1297 STRUCTOP_STRUCT and STRUCTOP_PTR.
1298
1299 If NOERR is nonzero, return zero if NAME is not suitably defined.
1300 If NAME is the name of a baseclass type, return that type. */
1301
1302 struct type *
1303 lookup_struct_elt_type (struct type *type, char *name, int noerr)
1304 {
1305 int i;
1306 char *typename;
1307
1308 for (;;)
1309 {
1310 CHECK_TYPEDEF (type);
1311 if (TYPE_CODE (type) != TYPE_CODE_PTR
1312 && TYPE_CODE (type) != TYPE_CODE_REF)
1313 break;
1314 type = TYPE_TARGET_TYPE (type);
1315 }
1316
1317 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1318 && TYPE_CODE (type) != TYPE_CODE_UNION)
1319 {
1320 typename = type_to_string (type);
1321 make_cleanup (xfree, typename);
1322 error (_("Type %s is not a structure or union type."), typename);
1323 }
1324
1325 #if 0
1326 /* FIXME: This change put in by Michael seems incorrect for the case
1327 where the structure tag name is the same as the member name.
1328 I.e. when doing "ptype bell->bar" for "struct foo { int bar; int
1329 foo; } bell;" Disabled by fnf. */
1330 {
1331 char *typename;
1332
1333 typename = type_name_no_tag (type);
1334 if (typename != NULL && strcmp (typename, name) == 0)
1335 return type;
1336 }
1337 #endif
1338
1339 for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1340 {
1341 const char *t_field_name = TYPE_FIELD_NAME (type, i);
1342
1343 if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1344 {
1345 return TYPE_FIELD_TYPE (type, i);
1346 }
1347 else if (!t_field_name || *t_field_name == '\0')
1348 {
1349 struct type *subtype
1350 = lookup_struct_elt_type (TYPE_FIELD_TYPE (type, i), name, 1);
1351
1352 if (subtype != NULL)
1353 return subtype;
1354 }
1355 }
1356
1357 /* OK, it's not in this class. Recursively check the baseclasses. */
1358 for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1359 {
1360 struct type *t;
1361
1362 t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, 1);
1363 if (t != NULL)
1364 {
1365 return t;
1366 }
1367 }
1368
1369 if (noerr)
1370 {
1371 return NULL;
1372 }
1373
1374 typename = type_to_string (type);
1375 make_cleanup (xfree, typename);
1376 error (_("Type %s has no component named %s."), typename, name);
1377 }
1378
1379 /* Lookup the vptr basetype/fieldno values for TYPE.
1380 If found store vptr_basetype in *BASETYPEP if non-NULL, and return
1381 vptr_fieldno. Also, if found and basetype is from the same objfile,
1382 cache the results.
1383 If not found, return -1 and ignore BASETYPEP.
1384 Callers should be aware that in some cases (for example,
1385 the type or one of its baseclasses is a stub type and we are
1386 debugging a .o file, or the compiler uses DWARF-2 and is not GCC),
1387 this function will not be able to find the
1388 virtual function table pointer, and vptr_fieldno will remain -1 and
1389 vptr_basetype will remain NULL or incomplete. */
1390
1391 int
1392 get_vptr_fieldno (struct type *type, struct type **basetypep)
1393 {
1394 CHECK_TYPEDEF (type);
1395
1396 if (TYPE_VPTR_FIELDNO (type) < 0)
1397 {
1398 int i;
1399
1400 /* We must start at zero in case the first (and only) baseclass
1401 is virtual (and hence we cannot share the table pointer). */
1402 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1403 {
1404 struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
1405 int fieldno;
1406 struct type *basetype;
1407
1408 fieldno = get_vptr_fieldno (baseclass, &basetype);
1409 if (fieldno >= 0)
1410 {
1411 /* If the type comes from a different objfile we can't cache
1412 it, it may have a different lifetime. PR 2384 */
1413 if (TYPE_OBJFILE (type) == TYPE_OBJFILE (basetype))
1414 {
1415 TYPE_VPTR_FIELDNO (type) = fieldno;
1416 TYPE_VPTR_BASETYPE (type) = basetype;
1417 }
1418 if (basetypep)
1419 *basetypep = basetype;
1420 return fieldno;
1421 }
1422 }
1423
1424 /* Not found. */
1425 return -1;
1426 }
1427 else
1428 {
1429 if (basetypep)
1430 *basetypep = TYPE_VPTR_BASETYPE (type);
1431 return TYPE_VPTR_FIELDNO (type);
1432 }
1433 }
1434
1435 static void
1436 stub_noname_complaint (void)
1437 {
1438 complaint (&symfile_complaints, _("stub type has NULL name"));
1439 }
1440
1441 /* Find the real type of TYPE. This function returns the real type,
1442 after removing all layers of typedefs, and completing opaque or stub
1443 types. Completion changes the TYPE argument, but stripping of
1444 typedefs does not.
1445
1446 Instance flags (e.g. const/volatile) are preserved as typedefs are
1447 stripped. If necessary a new qualified form of the underlying type
1448 is created.
1449
1450 NOTE: This will return a typedef if TYPE_TARGET_TYPE for the typedef has
1451 not been computed and we're either in the middle of reading symbols, or
1452 there was no name for the typedef in the debug info.
1453
1454 NOTE: Lookup of opaque types can throw errors for invalid symbol files.
1455 QUITs in the symbol reading code can also throw.
1456 Thus this function can throw an exception.
1457
1458 If TYPE is a TYPE_CODE_TYPEDEF, its length is updated to the length of
1459 the target type.
1460
1461 If this is a stubbed struct (i.e. declared as struct foo *), see if
1462 we can find a full definition in some other file. If so, copy this
1463 definition, so we can use it in future. There used to be a comment
1464 (but not any code) that if we don't find a full definition, we'd
1465 set a flag so we don't spend time in the future checking the same
1466 type. That would be a mistake, though--we might load in more
1467 symbols which contain a full definition for the type. */
1468
1469 struct type *
1470 check_typedef (struct type *type)
1471 {
1472 struct type *orig_type = type;
1473 /* While we're removing typedefs, we don't want to lose qualifiers.
1474 E.g., const/volatile. */
1475 int instance_flags = TYPE_INSTANCE_FLAGS (type);
1476
1477 gdb_assert (type);
1478
1479 while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1480 {
1481 if (!TYPE_TARGET_TYPE (type))
1482 {
1483 const char *name;
1484 struct symbol *sym;
1485
1486 /* It is dangerous to call lookup_symbol if we are currently
1487 reading a symtab. Infinite recursion is one danger. */
1488 if (currently_reading_symtab)
1489 return make_qualified_type (type, instance_flags, NULL);
1490
1491 name = type_name_no_tag (type);
1492 /* FIXME: shouldn't we separately check the TYPE_NAME and
1493 the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
1494 VAR_DOMAIN as appropriate? (this code was written before
1495 TYPE_NAME and TYPE_TAG_NAME were separate). */
1496 if (name == NULL)
1497 {
1498 stub_noname_complaint ();
1499 return make_qualified_type (type, instance_flags, NULL);
1500 }
1501 sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
1502 if (sym)
1503 TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
1504 else /* TYPE_CODE_UNDEF */
1505 TYPE_TARGET_TYPE (type) = alloc_type_arch (get_type_arch (type));
1506 }
1507 type = TYPE_TARGET_TYPE (type);
1508
1509 /* Preserve the instance flags as we traverse down the typedef chain.
1510
1511 Handling address spaces/classes is nasty, what do we do if there's a
1512 conflict?
1513 E.g., what if an outer typedef marks the type as class_1 and an inner
1514 typedef marks the type as class_2?
1515 This is the wrong place to do such error checking. We leave it to
1516 the code that created the typedef in the first place to flag the
1517 error. We just pick the outer address space (akin to letting the
1518 outer cast in a chain of casting win), instead of assuming
1519 "it can't happen". */
1520 {
1521 const int ALL_SPACES = (TYPE_INSTANCE_FLAG_CODE_SPACE
1522 | TYPE_INSTANCE_FLAG_DATA_SPACE);
1523 const int ALL_CLASSES = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL;
1524 int new_instance_flags = TYPE_INSTANCE_FLAGS (type);
1525
1526 /* Treat code vs data spaces and address classes separately. */
1527 if ((instance_flags & ALL_SPACES) != 0)
1528 new_instance_flags &= ~ALL_SPACES;
1529 if ((instance_flags & ALL_CLASSES) != 0)
1530 new_instance_flags &= ~ALL_CLASSES;
1531
1532 instance_flags |= new_instance_flags;
1533 }
1534 }
1535
1536 /* If this is a struct/class/union with no fields, then check
1537 whether a full definition exists somewhere else. This is for
1538 systems where a type definition with no fields is issued for such
1539 types, instead of identifying them as stub types in the first
1540 place. */
1541
1542 if (TYPE_IS_OPAQUE (type)
1543 && opaque_type_resolution
1544 && !currently_reading_symtab)
1545 {
1546 const char *name = type_name_no_tag (type);
1547 struct type *newtype;
1548
1549 if (name == NULL)
1550 {
1551 stub_noname_complaint ();
1552 return make_qualified_type (type, instance_flags, NULL);
1553 }
1554 newtype = lookup_transparent_type (name);
1555
1556 if (newtype)
1557 {
1558 /* If the resolved type and the stub are in the same
1559 objfile, then replace the stub type with the real deal.
1560 But if they're in separate objfiles, leave the stub
1561 alone; we'll just look up the transparent type every time
1562 we call check_typedef. We can't create pointers between
1563 types allocated to different objfiles, since they may
1564 have different lifetimes. Trying to copy NEWTYPE over to
1565 TYPE's objfile is pointless, too, since you'll have to
1566 move over any other types NEWTYPE refers to, which could
1567 be an unbounded amount of stuff. */
1568 if (TYPE_OBJFILE (newtype) == TYPE_OBJFILE (type))
1569 type = make_qualified_type (newtype,
1570 TYPE_INSTANCE_FLAGS (type),
1571 type);
1572 else
1573 type = newtype;
1574 }
1575 }
1576 /* Otherwise, rely on the stub flag being set for opaque/stubbed
1577 types. */
1578 else if (TYPE_STUB (type) && !currently_reading_symtab)
1579 {
1580 const char *name = type_name_no_tag (type);
1581 /* FIXME: shouldn't we separately check the TYPE_NAME and the
1582 TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
1583 as appropriate? (this code was written before TYPE_NAME and
1584 TYPE_TAG_NAME were separate). */
1585 struct symbol *sym;
1586
1587 if (name == NULL)
1588 {
1589 stub_noname_complaint ();
1590 return make_qualified_type (type, instance_flags, NULL);
1591 }
1592 sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0);
1593 if (sym)
1594 {
1595 /* Same as above for opaque types, we can replace the stub
1596 with the complete type only if they are in the same
1597 objfile. */
1598 if (TYPE_OBJFILE (SYMBOL_TYPE(sym)) == TYPE_OBJFILE (type))
1599 type = make_qualified_type (SYMBOL_TYPE (sym),
1600 TYPE_INSTANCE_FLAGS (type),
1601 type);
1602 else
1603 type = SYMBOL_TYPE (sym);
1604 }
1605 }
1606
1607 if (TYPE_TARGET_STUB (type))
1608 {
1609 struct type *range_type;
1610 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1611
1612 if (TYPE_STUB (target_type) || TYPE_TARGET_STUB (target_type))
1613 {
1614 /* Nothing we can do. */
1615 }
1616 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY
1617 && TYPE_NFIELDS (type) == 1
1618 && (TYPE_CODE (range_type = TYPE_INDEX_TYPE (type))
1619 == TYPE_CODE_RANGE))
1620 {
1621 /* Now recompute the length of the array type, based on its
1622 number of elements and the target type's length.
1623 Watch out for Ada null Ada arrays where the high bound
1624 is smaller than the low bound. */
1625 const LONGEST low_bound = TYPE_LOW_BOUND (range_type);
1626 const LONGEST high_bound = TYPE_HIGH_BOUND (range_type);
1627 ULONGEST len;
1628
1629 if (high_bound < low_bound)
1630 len = 0;
1631 else
1632 {
1633 /* For now, we conservatively take the array length to be 0
1634 if its length exceeds UINT_MAX. The code below assumes
1635 that for x < 0, (ULONGEST) x == -x + ULONGEST_MAX + 1,
1636 which is technically not guaranteed by C, but is usually true
1637 (because it would be true if x were unsigned with its
1638 high-order bit on). It uses the fact that
1639 high_bound-low_bound is always representable in
1640 ULONGEST and that if high_bound-low_bound+1 overflows,
1641 it overflows to 0. We must change these tests if we
1642 decide to increase the representation of TYPE_LENGTH
1643 from unsigned int to ULONGEST. */
1644 ULONGEST ulow = low_bound, uhigh = high_bound;
1645 ULONGEST tlen = TYPE_LENGTH (target_type);
1646
1647 len = tlen * (uhigh - ulow + 1);
1648 if (tlen == 0 || (len / tlen - 1 + ulow) != uhigh
1649 || len > UINT_MAX)
1650 len = 0;
1651 }
1652 TYPE_LENGTH (type) = len;
1653 TYPE_TARGET_STUB (type) = 0;
1654 }
1655 else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
1656 {
1657 TYPE_LENGTH (type) = TYPE_LENGTH (target_type);
1658 TYPE_TARGET_STUB (type) = 0;
1659 }
1660 }
1661
1662 type = make_qualified_type (type, instance_flags, NULL);
1663
1664 /* Cache TYPE_LENGTH for future use. */
1665 TYPE_LENGTH (orig_type) = TYPE_LENGTH (type);
1666
1667 return type;
1668 }
1669
1670 /* Parse a type expression in the string [P..P+LENGTH). If an error
1671 occurs, silently return a void type. */
1672
1673 static struct type *
1674 safe_parse_type (struct gdbarch *gdbarch, char *p, int length)
1675 {
1676 struct ui_file *saved_gdb_stderr;
1677 struct type *type = NULL; /* Initialize to keep gcc happy. */
1678 volatile struct gdb_exception except;
1679
1680 /* Suppress error messages. */
1681 saved_gdb_stderr = gdb_stderr;
1682 gdb_stderr = ui_file_new ();
1683
1684 /* Call parse_and_eval_type() without fear of longjmp()s. */
1685 TRY_CATCH (except, RETURN_MASK_ERROR)
1686 {
1687 type = parse_and_eval_type (p, length);
1688 }
1689
1690 if (except.reason < 0)
1691 type = builtin_type (gdbarch)->builtin_void;
1692
1693 /* Stop suppressing error messages. */
1694 ui_file_delete (gdb_stderr);
1695 gdb_stderr = saved_gdb_stderr;
1696
1697 return type;
1698 }
1699
1700 /* Ugly hack to convert method stubs into method types.
1701
1702 He ain't kiddin'. This demangles the name of the method into a
1703 string including argument types, parses out each argument type,
1704 generates a string casting a zero to that type, evaluates the
1705 string, and stuffs the resulting type into an argtype vector!!!
1706 Then it knows the type of the whole function (including argument
1707 types for overloading), which info used to be in the stab's but was
1708 removed to hack back the space required for them. */
1709
1710 static void
1711 check_stub_method (struct type *type, int method_id, int signature_id)
1712 {
1713 struct gdbarch *gdbarch = get_type_arch (type);
1714 struct fn_field *f;
1715 char *mangled_name = gdb_mangle_name (type, method_id, signature_id);
1716 char *demangled_name = cplus_demangle (mangled_name,
1717 DMGL_PARAMS | DMGL_ANSI);
1718 char *argtypetext, *p;
1719 int depth = 0, argcount = 1;
1720 struct field *argtypes;
1721 struct type *mtype;
1722
1723 /* Make sure we got back a function string that we can use. */
1724 if (demangled_name)
1725 p = strchr (demangled_name, '(');
1726 else
1727 p = NULL;
1728
1729 if (demangled_name == NULL || p == NULL)
1730 error (_("Internal: Cannot demangle mangled name `%s'."),
1731 mangled_name);
1732
1733 /* Now, read in the parameters that define this type. */
1734 p += 1;
1735 argtypetext = p;
1736 while (*p)
1737 {
1738 if (*p == '(' || *p == '<')
1739 {
1740 depth += 1;
1741 }
1742 else if (*p == ')' || *p == '>')
1743 {
1744 depth -= 1;
1745 }
1746 else if (*p == ',' && depth == 0)
1747 {
1748 argcount += 1;
1749 }
1750
1751 p += 1;
1752 }
1753
1754 /* If we read one argument and it was ``void'', don't count it. */
1755 if (strncmp (argtypetext, "(void)", 6) == 0)
1756 argcount -= 1;
1757
1758 /* We need one extra slot, for the THIS pointer. */
1759
1760 argtypes = (struct field *)
1761 TYPE_ALLOC (type, (argcount + 1) * sizeof (struct field));
1762 p = argtypetext;
1763
1764 /* Add THIS pointer for non-static methods. */
1765 f = TYPE_FN_FIELDLIST1 (type, method_id);
1766 if (TYPE_FN_FIELD_STATIC_P (f, signature_id))
1767 argcount = 0;
1768 else
1769 {
1770 argtypes[0].type = lookup_pointer_type (type);
1771 argcount = 1;
1772 }
1773
1774 if (*p != ')') /* () means no args, skip while. */
1775 {
1776 depth = 0;
1777 while (*p)
1778 {
1779 if (depth <= 0 && (*p == ',' || *p == ')'))
1780 {
1781 /* Avoid parsing of ellipsis, they will be handled below.
1782 Also avoid ``void'' as above. */
1783 if (strncmp (argtypetext, "...", p - argtypetext) != 0
1784 && strncmp (argtypetext, "void", p - argtypetext) != 0)
1785 {
1786 argtypes[argcount].type =
1787 safe_parse_type (gdbarch, argtypetext, p - argtypetext);
1788 argcount += 1;
1789 }
1790 argtypetext = p + 1;
1791 }
1792
1793 if (*p == '(' || *p == '<')
1794 {
1795 depth += 1;
1796 }
1797 else if (*p == ')' || *p == '>')
1798 {
1799 depth -= 1;
1800 }
1801
1802 p += 1;
1803 }
1804 }
1805
1806 TYPE_FN_FIELD_PHYSNAME (f, signature_id) = mangled_name;
1807
1808 /* Now update the old "stub" type into a real type. */
1809 mtype = TYPE_FN_FIELD_TYPE (f, signature_id);
1810 TYPE_DOMAIN_TYPE (mtype) = type;
1811 TYPE_FIELDS (mtype) = argtypes;
1812 TYPE_NFIELDS (mtype) = argcount;
1813 TYPE_STUB (mtype) = 0;
1814 TYPE_FN_FIELD_STUB (f, signature_id) = 0;
1815 if (p[-2] == '.')
1816 TYPE_VARARGS (mtype) = 1;
1817
1818 xfree (demangled_name);
1819 }
1820
1821 /* This is the external interface to check_stub_method, above. This
1822 function unstubs all of the signatures for TYPE's METHOD_ID method
1823 name. After calling this function TYPE_FN_FIELD_STUB will be
1824 cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
1825 correct.
1826
1827 This function unfortunately can not die until stabs do. */
1828
1829 void
1830 check_stub_method_group (struct type *type, int method_id)
1831 {
1832 int len = TYPE_FN_FIELDLIST_LENGTH (type, method_id);
1833 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id);
1834 int j, found_stub = 0;
1835
1836 for (j = 0; j < len; j++)
1837 if (TYPE_FN_FIELD_STUB (f, j))
1838 {
1839 found_stub = 1;
1840 check_stub_method (type, method_id, j);
1841 }
1842
1843 /* GNU v3 methods with incorrect names were corrected when we read
1844 in type information, because it was cheaper to do it then. The
1845 only GNU v2 methods with incorrect method names are operators and
1846 destructors; destructors were also corrected when we read in type
1847 information.
1848
1849 Therefore the only thing we need to handle here are v2 operator
1850 names. */
1851 if (found_stub && strncmp (TYPE_FN_FIELD_PHYSNAME (f, 0), "_Z", 2) != 0)
1852 {
1853 int ret;
1854 char dem_opname[256];
1855
1856 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type,
1857 method_id),
1858 dem_opname, DMGL_ANSI);
1859 if (!ret)
1860 ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type,
1861 method_id),
1862 dem_opname, 0);
1863 if (ret)
1864 TYPE_FN_FIELDLIST_NAME (type, method_id) = xstrdup (dem_opname);
1865 }
1866 }
1867
1868 /* Ensure it is in .rodata (if available) by workarounding GCC PR 44690. */
1869 const struct cplus_struct_type cplus_struct_default = { };
1870
1871 void
1872 allocate_cplus_struct_type (struct type *type)
1873 {
1874 if (HAVE_CPLUS_STRUCT (type))
1875 /* Structure was already allocated. Nothing more to do. */
1876 return;
1877
1878 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_CPLUS_STUFF;
1879 TYPE_RAW_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
1880 TYPE_ALLOC (type, sizeof (struct cplus_struct_type));
1881 *(TYPE_RAW_CPLUS_SPECIFIC (type)) = cplus_struct_default;
1882 }
1883
1884 const struct gnat_aux_type gnat_aux_default =
1885 { NULL };
1886
1887 /* Set the TYPE's type-specific kind to TYPE_SPECIFIC_GNAT_STUFF,
1888 and allocate the associated gnat-specific data. The gnat-specific
1889 data is also initialized to gnat_aux_default. */
1890 void
1891 allocate_gnat_aux_type (struct type *type)
1892 {
1893 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_GNAT_STUFF;
1894 TYPE_GNAT_SPECIFIC (type) = (struct gnat_aux_type *)
1895 TYPE_ALLOC (type, sizeof (struct gnat_aux_type));
1896 *(TYPE_GNAT_SPECIFIC (type)) = gnat_aux_default;
1897 }
1898
1899
1900 /* Helper function to initialize the standard scalar types.
1901
1902 If NAME is non-NULL, then we make a copy of the string pointed
1903 to by name in the objfile_obstack for that objfile, and initialize
1904 the type name to that copy. There are places (mipsread.c in particular),
1905 where init_type is called with a NULL value for NAME). */
1906
1907 struct type *
1908 init_type (enum type_code code, int length, int flags,
1909 char *name, struct objfile *objfile)
1910 {
1911 struct type *type;
1912
1913 type = alloc_type (objfile);
1914 TYPE_CODE (type) = code;
1915 TYPE_LENGTH (type) = length;
1916
1917 gdb_assert (!(flags & (TYPE_FLAG_MIN - 1)));
1918 if (flags & TYPE_FLAG_UNSIGNED)
1919 TYPE_UNSIGNED (type) = 1;
1920 if (flags & TYPE_FLAG_NOSIGN)
1921 TYPE_NOSIGN (type) = 1;
1922 if (flags & TYPE_FLAG_STUB)
1923 TYPE_STUB (type) = 1;
1924 if (flags & TYPE_FLAG_TARGET_STUB)
1925 TYPE_TARGET_STUB (type) = 1;
1926 if (flags & TYPE_FLAG_STATIC)
1927 TYPE_STATIC (type) = 1;
1928 if (flags & TYPE_FLAG_PROTOTYPED)
1929 TYPE_PROTOTYPED (type) = 1;
1930 if (flags & TYPE_FLAG_INCOMPLETE)
1931 TYPE_INCOMPLETE (type) = 1;
1932 if (flags & TYPE_FLAG_VARARGS)
1933 TYPE_VARARGS (type) = 1;
1934 if (flags & TYPE_FLAG_VECTOR)
1935 TYPE_VECTOR (type) = 1;
1936 if (flags & TYPE_FLAG_STUB_SUPPORTED)
1937 TYPE_STUB_SUPPORTED (type) = 1;
1938 if (flags & TYPE_FLAG_FIXED_INSTANCE)
1939 TYPE_FIXED_INSTANCE (type) = 1;
1940 if (flags & TYPE_FLAG_GNU_IFUNC)
1941 TYPE_GNU_IFUNC (type) = 1;
1942
1943 if (name)
1944 TYPE_NAME (type) = obsavestring (name, strlen (name),
1945 &objfile->objfile_obstack);
1946
1947 /* C++ fancies. */
1948
1949 if (name && strcmp (name, "char") == 0)
1950 TYPE_NOSIGN (type) = 1;
1951
1952 switch (code)
1953 {
1954 case TYPE_CODE_STRUCT:
1955 case TYPE_CODE_UNION:
1956 case TYPE_CODE_NAMESPACE:
1957 INIT_CPLUS_SPECIFIC (type);
1958 break;
1959 case TYPE_CODE_FLT:
1960 TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FLOATFORMAT;
1961 break;
1962 case TYPE_CODE_FUNC:
1963 INIT_FUNC_SPECIFIC (type);
1964 break;
1965 }
1966 return type;
1967 }
1968
1969 int
1970 can_dereference (struct type *t)
1971 {
1972 /* FIXME: Should we return true for references as well as
1973 pointers? */
1974 CHECK_TYPEDEF (t);
1975 return
1976 (t != NULL
1977 && TYPE_CODE (t) == TYPE_CODE_PTR
1978 && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID);
1979 }
1980
1981 int
1982 is_integral_type (struct type *t)
1983 {
1984 CHECK_TYPEDEF (t);
1985 return
1986 ((t != NULL)
1987 && ((TYPE_CODE (t) == TYPE_CODE_INT)
1988 || (TYPE_CODE (t) == TYPE_CODE_ENUM)
1989 || (TYPE_CODE (t) == TYPE_CODE_FLAGS)
1990 || (TYPE_CODE (t) == TYPE_CODE_CHAR)
1991 || (TYPE_CODE (t) == TYPE_CODE_RANGE)
1992 || (TYPE_CODE (t) == TYPE_CODE_BOOL)));
1993 }
1994
1995 /* Return true if TYPE is scalar. */
1996
1997 static int
1998 is_scalar_type (struct type *type)
1999 {
2000 CHECK_TYPEDEF (type);
2001
2002 switch (TYPE_CODE (type))
2003 {
2004 case TYPE_CODE_ARRAY:
2005 case TYPE_CODE_STRUCT:
2006 case TYPE_CODE_UNION:
2007 case TYPE_CODE_SET:
2008 case TYPE_CODE_STRING:
2009 case TYPE_CODE_BITSTRING:
2010 return 0;
2011 default:
2012 return 1;
2013 }
2014 }
2015
2016 /* Return true if T is scalar, or a composite type which in practice has
2017 the memory layout of a scalar type. E.g., an array or struct with only
2018 one scalar element inside it, or a union with only scalar elements. */
2019
2020 int
2021 is_scalar_type_recursive (struct type *t)
2022 {
2023 CHECK_TYPEDEF (t);
2024
2025 if (is_scalar_type (t))
2026 return 1;
2027 /* Are we dealing with an array or string of known dimensions? */
2028 else if ((TYPE_CODE (t) == TYPE_CODE_ARRAY
2029 || TYPE_CODE (t) == TYPE_CODE_STRING) && TYPE_NFIELDS (t) == 1
2030 && TYPE_CODE (TYPE_INDEX_TYPE (t)) == TYPE_CODE_RANGE)
2031 {
2032 LONGEST low_bound, high_bound;
2033 struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (t));
2034
2035 get_discrete_bounds (TYPE_INDEX_TYPE (t), &low_bound, &high_bound);
2036
2037 return high_bound == low_bound && is_scalar_type_recursive (elt_type);
2038 }
2039 /* Are we dealing with a struct with one element? */
2040 else if (TYPE_CODE (t) == TYPE_CODE_STRUCT && TYPE_NFIELDS (t) == 1)
2041 return is_scalar_type_recursive (TYPE_FIELD_TYPE (t, 0));
2042 else if (TYPE_CODE (t) == TYPE_CODE_UNION)
2043 {
2044 int i, n = TYPE_NFIELDS (t);
2045
2046 /* If all elements of the union are scalar, then the union is scalar. */
2047 for (i = 0; i < n; i++)
2048 if (!is_scalar_type_recursive (TYPE_FIELD_TYPE (t, i)))
2049 return 0;
2050
2051 return 1;
2052 }
2053
2054 return 0;
2055 }
2056
2057 /* A helper function which returns true if types A and B represent the
2058 "same" class type. This is true if the types have the same main
2059 type, or the same name. */
2060
2061 int
2062 class_types_same_p (const struct type *a, const struct type *b)
2063 {
2064 return (TYPE_MAIN_TYPE (a) == TYPE_MAIN_TYPE (b)
2065 || (TYPE_NAME (a) && TYPE_NAME (b)
2066 && !strcmp (TYPE_NAME (a), TYPE_NAME (b))));
2067 }
2068
2069 /* If BASE is an ancestor of DCLASS return the distance between them.
2070 otherwise return -1;
2071 eg:
2072
2073 class A {};
2074 class B: public A {};
2075 class C: public B {};
2076 class D: C {};
2077
2078 distance_to_ancestor (A, A, 0) = 0
2079 distance_to_ancestor (A, B, 0) = 1
2080 distance_to_ancestor (A, C, 0) = 2
2081 distance_to_ancestor (A, D, 0) = 3
2082
2083 If PUBLIC is 1 then only public ancestors are considered,
2084 and the function returns the distance only if BASE is a public ancestor
2085 of DCLASS.
2086 Eg:
2087
2088 distance_to_ancestor (A, D, 1) = -1. */
2089
2090 static int
2091 distance_to_ancestor (struct type *base, struct type *dclass, int public)
2092 {
2093 int i;
2094 int d;
2095
2096 CHECK_TYPEDEF (base);
2097 CHECK_TYPEDEF (dclass);
2098
2099 if (class_types_same_p (base, dclass))
2100 return 0;
2101
2102 for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
2103 {
2104 if (public && ! BASETYPE_VIA_PUBLIC (dclass, i))
2105 continue;
2106
2107 d = distance_to_ancestor (base, TYPE_BASECLASS (dclass, i), public);
2108 if (d >= 0)
2109 return 1 + d;
2110 }
2111
2112 return -1;
2113 }
2114
2115 /* Check whether BASE is an ancestor or base class or DCLASS
2116 Return 1 if so, and 0 if not.
2117 Note: If BASE and DCLASS are of the same type, this function
2118 will return 1. So for some class A, is_ancestor (A, A) will
2119 return 1. */
2120
2121 int
2122 is_ancestor (struct type *base, struct type *dclass)
2123 {
2124 return distance_to_ancestor (base, dclass, 0) >= 0;
2125 }
2126
2127 /* Like is_ancestor, but only returns true when BASE is a public
2128 ancestor of DCLASS. */
2129
2130 int
2131 is_public_ancestor (struct type *base, struct type *dclass)
2132 {
2133 return distance_to_ancestor (base, dclass, 1) >= 0;
2134 }
2135
2136 /* A helper function for is_unique_ancestor. */
2137
2138 static int
2139 is_unique_ancestor_worker (struct type *base, struct type *dclass,
2140 int *offset,
2141 const gdb_byte *valaddr, int embedded_offset,
2142 CORE_ADDR address, struct value *val)
2143 {
2144 int i, count = 0;
2145
2146 CHECK_TYPEDEF (base);
2147 CHECK_TYPEDEF (dclass);
2148
2149 for (i = 0; i < TYPE_N_BASECLASSES (dclass) && count < 2; ++i)
2150 {
2151 struct type *iter;
2152 int this_offset;
2153
2154 iter = check_typedef (TYPE_BASECLASS (dclass, i));
2155
2156 this_offset = baseclass_offset (dclass, i, valaddr, embedded_offset,
2157 address, val);
2158
2159 if (class_types_same_p (base, iter))
2160 {
2161 /* If this is the first subclass, set *OFFSET and set count
2162 to 1. Otherwise, if this is at the same offset as
2163 previous instances, do nothing. Otherwise, increment
2164 count. */
2165 if (*offset == -1)
2166 {
2167 *offset = this_offset;
2168 count = 1;
2169 }
2170 else if (this_offset == *offset)
2171 {
2172 /* Nothing. */
2173 }
2174 else
2175 ++count;
2176 }
2177 else
2178 count += is_unique_ancestor_worker (base, iter, offset,
2179 valaddr,
2180 embedded_offset + this_offset,
2181 address, val);
2182 }
2183
2184 return count;
2185 }
2186
2187 /* Like is_ancestor, but only returns true if BASE is a unique base
2188 class of the type of VAL. */
2189
2190 int
2191 is_unique_ancestor (struct type *base, struct value *val)
2192 {
2193 int offset = -1;
2194
2195 return is_unique_ancestor_worker (base, value_type (val), &offset,
2196 value_contents_for_printing (val),
2197 value_embedded_offset (val),
2198 value_address (val), val) == 1;
2199 }
2200
2201 \f
2202
2203 /* Return the sum of the rank of A with the rank of B. */
2204
2205 struct rank
2206 sum_ranks (struct rank a, struct rank b)
2207 {
2208 struct rank c;
2209 c.rank = a.rank + b.rank;
2210 c.subrank = a.subrank + b.subrank;
2211 return c;
2212 }
2213
2214 /* Compare rank A and B and return:
2215 0 if a = b
2216 1 if a is better than b
2217 -1 if b is better than a. */
2218
2219 int
2220 compare_ranks (struct rank a, struct rank b)
2221 {
2222 if (a.rank == b.rank)
2223 {
2224 if (a.subrank == b.subrank)
2225 return 0;
2226 if (a.subrank < b.subrank)
2227 return 1;
2228 if (a.subrank > b.subrank)
2229 return -1;
2230 }
2231
2232 if (a.rank < b.rank)
2233 return 1;
2234
2235 /* a.rank > b.rank */
2236 return -1;
2237 }
2238
2239 /* Functions for overload resolution begin here. */
2240
2241 /* Compare two badness vectors A and B and return the result.
2242 0 => A and B are identical
2243 1 => A and B are incomparable
2244 2 => A is better than B
2245 3 => A is worse than B */
2246
2247 int
2248 compare_badness (struct badness_vector *a, struct badness_vector *b)
2249 {
2250 int i;
2251 int tmp;
2252 short found_pos = 0; /* any positives in c? */
2253 short found_neg = 0; /* any negatives in c? */
2254
2255 /* differing lengths => incomparable */
2256 if (a->length != b->length)
2257 return 1;
2258
2259 /* Subtract b from a */
2260 for (i = 0; i < a->length; i++)
2261 {
2262 tmp = compare_ranks (b->rank[i], a->rank[i]);
2263 if (tmp > 0)
2264 found_pos = 1;
2265 else if (tmp < 0)
2266 found_neg = 1;
2267 }
2268
2269 if (found_pos)
2270 {
2271 if (found_neg)
2272 return 1; /* incomparable */
2273 else
2274 return 3; /* A > B */
2275 }
2276 else
2277 /* no positives */
2278 {
2279 if (found_neg)
2280 return 2; /* A < B */
2281 else
2282 return 0; /* A == B */
2283 }
2284 }
2285
2286 /* Rank a function by comparing its parameter types (PARMS, length
2287 NPARMS), to the types of an argument list (ARGS, length NARGS).
2288 Return a pointer to a badness vector. This has NARGS + 1
2289 entries. */
2290
2291 struct badness_vector *
2292 rank_function (struct type **parms, int nparms,
2293 struct value **args, int nargs)
2294 {
2295 int i;
2296 struct badness_vector *bv;
2297 int min_len = nparms < nargs ? nparms : nargs;
2298
2299 bv = xmalloc (sizeof (struct badness_vector));
2300 bv->length = nargs + 1; /* add 1 for the length-match rank. */
2301 bv->rank = xmalloc ((nargs + 1) * sizeof (int));
2302
2303 /* First compare the lengths of the supplied lists.
2304 If there is a mismatch, set it to a high value. */
2305
2306 /* pai/1997-06-03 FIXME: when we have debug info about default
2307 arguments and ellipsis parameter lists, we should consider those
2308 and rank the length-match more finely. */
2309
2310 LENGTH_MATCH (bv) = (nargs != nparms)
2311 ? LENGTH_MISMATCH_BADNESS
2312 : EXACT_MATCH_BADNESS;
2313
2314 /* Now rank all the parameters of the candidate function. */
2315 for (i = 1; i <= min_len; i++)
2316 bv->rank[i] = rank_one_type (parms[i - 1], value_type (args[i - 1]),
2317 args[i - 1]);
2318
2319 /* If more arguments than parameters, add dummy entries. */
2320 for (i = min_len + 1; i <= nargs; i++)
2321 bv->rank[i] = TOO_FEW_PARAMS_BADNESS;
2322
2323 return bv;
2324 }
2325
2326 /* Compare the names of two integer types, assuming that any sign
2327 qualifiers have been checked already. We do it this way because
2328 there may be an "int" in the name of one of the types. */
2329
2330 static int
2331 integer_types_same_name_p (const char *first, const char *second)
2332 {
2333 int first_p, second_p;
2334
2335 /* If both are shorts, return 1; if neither is a short, keep
2336 checking. */
2337 first_p = (strstr (first, "short") != NULL);
2338 second_p = (strstr (second, "short") != NULL);
2339 if (first_p && second_p)
2340 return 1;
2341 if (first_p || second_p)
2342 return 0;
2343
2344 /* Likewise for long. */
2345 first_p = (strstr (first, "long") != NULL);
2346 second_p = (strstr (second, "long") != NULL);
2347 if (first_p && second_p)
2348 return 1;
2349 if (first_p || second_p)
2350 return 0;
2351
2352 /* Likewise for char. */
2353 first_p = (strstr (first, "char") != NULL);
2354 second_p = (strstr (second, "char") != NULL);
2355 if (first_p && second_p)
2356 return 1;
2357 if (first_p || second_p)
2358 return 0;
2359
2360 /* They must both be ints. */
2361 return 1;
2362 }
2363
2364 /* Compares type A to type B returns 1 if the represent the same type
2365 0 otherwise. */
2366
2367 static int
2368 types_equal (struct type *a, struct type *b)
2369 {
2370 /* Identical type pointers. */
2371 /* However, this still doesn't catch all cases of same type for b
2372 and a. The reason is that builtin types are different from
2373 the same ones constructed from the object. */
2374 if (a == b)
2375 return 1;
2376
2377 /* Resolve typedefs */
2378 if (TYPE_CODE (a) == TYPE_CODE_TYPEDEF)
2379 a = check_typedef (a);
2380 if (TYPE_CODE (b) == TYPE_CODE_TYPEDEF)
2381 b = check_typedef (b);
2382
2383 /* If after resolving typedefs a and b are not of the same type
2384 code then they are not equal. */
2385 if (TYPE_CODE (a) != TYPE_CODE (b))
2386 return 0;
2387
2388 /* If a and b are both pointers types or both reference types then
2389 they are equal of the same type iff the objects they refer to are
2390 of the same type. */
2391 if (TYPE_CODE (a) == TYPE_CODE_PTR
2392 || TYPE_CODE (a) == TYPE_CODE_REF)
2393 return types_equal (TYPE_TARGET_TYPE (a),
2394 TYPE_TARGET_TYPE (b));
2395
2396 /* Well, damnit, if the names are exactly the same, I'll say they
2397 are exactly the same. This happens when we generate method
2398 stubs. The types won't point to the same address, but they
2399 really are the same. */
2400
2401 if (TYPE_NAME (a) && TYPE_NAME (b)
2402 && strcmp (TYPE_NAME (a), TYPE_NAME (b)) == 0)
2403 return 1;
2404
2405 /* Check if identical after resolving typedefs. */
2406 if (a == b)
2407 return 1;
2408
2409 return 0;
2410 }
2411
2412 /* Compare one type (PARM) for compatibility with another (ARG).
2413 * PARM is intended to be the parameter type of a function; and
2414 * ARG is the supplied argument's type. This function tests if
2415 * the latter can be converted to the former.
2416 * VALUE is the argument's value or NULL if none (or called recursively)
2417 *
2418 * Return 0 if they are identical types;
2419 * Otherwise, return an integer which corresponds to how compatible
2420 * PARM is to ARG. The higher the return value, the worse the match.
2421 * Generally the "bad" conversions are all uniformly assigned a 100. */
2422
2423 struct rank
2424 rank_one_type (struct type *parm, struct type *arg, struct value *value)
2425 {
2426 struct rank rank = {0,0};
2427
2428 if (types_equal (parm, arg))
2429 return EXACT_MATCH_BADNESS;
2430
2431 /* Resolve typedefs */
2432 if (TYPE_CODE (parm) == TYPE_CODE_TYPEDEF)
2433 parm = check_typedef (parm);
2434 if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF)
2435 arg = check_typedef (arg);
2436
2437 /* See through references, since we can almost make non-references
2438 references. */
2439 if (TYPE_CODE (arg) == TYPE_CODE_REF)
2440 return (sum_ranks (rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL),
2441 REFERENCE_CONVERSION_BADNESS));
2442 if (TYPE_CODE (parm) == TYPE_CODE_REF)
2443 return (sum_ranks (rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL),
2444 REFERENCE_CONVERSION_BADNESS));
2445 if (overload_debug)
2446 /* Debugging only. */
2447 fprintf_filtered (gdb_stderr,
2448 "------ Arg is %s [%d], parm is %s [%d]\n",
2449 TYPE_NAME (arg), TYPE_CODE (arg),
2450 TYPE_NAME (parm), TYPE_CODE (parm));
2451
2452 /* x -> y means arg of type x being supplied for parameter of type y. */
2453
2454 switch (TYPE_CODE (parm))
2455 {
2456 case TYPE_CODE_PTR:
2457 switch (TYPE_CODE (arg))
2458 {
2459 case TYPE_CODE_PTR:
2460
2461 /* Allowed pointer conversions are:
2462 (a) pointer to void-pointer conversion. */
2463 if (TYPE_CODE (TYPE_TARGET_TYPE (parm)) == TYPE_CODE_VOID)
2464 return VOID_PTR_CONVERSION_BADNESS;
2465
2466 /* (b) pointer to ancestor-pointer conversion. */
2467 rank.subrank = distance_to_ancestor (TYPE_TARGET_TYPE (parm),
2468 TYPE_TARGET_TYPE (arg),
2469 0);
2470 if (rank.subrank >= 0)
2471 return sum_ranks (BASE_PTR_CONVERSION_BADNESS, rank);
2472
2473 return INCOMPATIBLE_TYPE_BADNESS;
2474 case TYPE_CODE_ARRAY:
2475 if (types_equal (TYPE_TARGET_TYPE (parm),
2476 TYPE_TARGET_TYPE (arg)))
2477 return EXACT_MATCH_BADNESS;
2478 return INCOMPATIBLE_TYPE_BADNESS;
2479 case TYPE_CODE_FUNC:
2480 return rank_one_type (TYPE_TARGET_TYPE (parm), arg, NULL);
2481 case TYPE_CODE_INT:
2482 if (value != NULL && TYPE_CODE (value_type (value)) == TYPE_CODE_INT
2483 && value_as_long (value) == 0)
2484 {
2485 /* Null pointer conversion: allow it to be cast to a pointer.
2486 [4.10.1 of C++ standard draft n3290] */
2487 return NULL_POINTER_CONVERSION_BADNESS;
2488 }
2489 /* fall through */
2490 case TYPE_CODE_ENUM:
2491 case TYPE_CODE_FLAGS:
2492 case TYPE_CODE_CHAR:
2493 case TYPE_CODE_RANGE:
2494 case TYPE_CODE_BOOL:
2495 default:
2496 return INCOMPATIBLE_TYPE_BADNESS;
2497 }
2498 case TYPE_CODE_ARRAY:
2499 switch (TYPE_CODE (arg))
2500 {
2501 case TYPE_CODE_PTR:
2502 case TYPE_CODE_ARRAY:
2503 return rank_one_type (TYPE_TARGET_TYPE (parm),
2504 TYPE_TARGET_TYPE (arg), NULL);
2505 default:
2506 return INCOMPATIBLE_TYPE_BADNESS;
2507 }
2508 case TYPE_CODE_FUNC:
2509 switch (TYPE_CODE (arg))
2510 {
2511 case TYPE_CODE_PTR: /* funcptr -> func */
2512 return rank_one_type (parm, TYPE_TARGET_TYPE (arg), NULL);
2513 default:
2514 return INCOMPATIBLE_TYPE_BADNESS;
2515 }
2516 case TYPE_CODE_INT:
2517 switch (TYPE_CODE (arg))
2518 {
2519 case TYPE_CODE_INT:
2520 if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
2521 {
2522 /* Deal with signed, unsigned, and plain chars and
2523 signed and unsigned ints. */
2524 if (TYPE_NOSIGN (parm))
2525 {
2526 /* This case only for character types. */
2527 if (TYPE_NOSIGN (arg))
2528 return EXACT_MATCH_BADNESS; /* plain char -> plain char */
2529 else /* signed/unsigned char -> plain char */
2530 return INTEGER_CONVERSION_BADNESS;
2531 }
2532 else if (TYPE_UNSIGNED (parm))
2533 {
2534 if (TYPE_UNSIGNED (arg))
2535 {
2536 /* unsigned int -> unsigned int, or
2537 unsigned long -> unsigned long */
2538 if (integer_types_same_name_p (TYPE_NAME (parm),
2539 TYPE_NAME (arg)))
2540 return EXACT_MATCH_BADNESS;
2541 else if (integer_types_same_name_p (TYPE_NAME (arg),
2542 "int")
2543 && integer_types_same_name_p (TYPE_NAME (parm),
2544 "long"))
2545 /* unsigned int -> unsigned long */
2546 return INTEGER_PROMOTION_BADNESS;
2547 else
2548 /* unsigned long -> unsigned int */
2549 return INTEGER_CONVERSION_BADNESS;
2550 }
2551 else
2552 {
2553 if (integer_types_same_name_p (TYPE_NAME (arg),
2554 "long")
2555 && integer_types_same_name_p (TYPE_NAME (parm),
2556 "int"))
2557 /* signed long -> unsigned int */
2558 return INTEGER_CONVERSION_BADNESS;
2559 else
2560 /* signed int/long -> unsigned int/long */
2561 return INTEGER_CONVERSION_BADNESS;
2562 }
2563 }
2564 else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
2565 {
2566 if (integer_types_same_name_p (TYPE_NAME (parm),
2567 TYPE_NAME (arg)))
2568 return EXACT_MATCH_BADNESS;
2569 else if (integer_types_same_name_p (TYPE_NAME (arg),
2570 "int")
2571 && integer_types_same_name_p (TYPE_NAME (parm),
2572 "long"))
2573 return INTEGER_PROMOTION_BADNESS;
2574 else
2575 return INTEGER_CONVERSION_BADNESS;
2576 }
2577 else
2578 return INTEGER_CONVERSION_BADNESS;
2579 }
2580 else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2581 return INTEGER_PROMOTION_BADNESS;
2582 else
2583 return INTEGER_CONVERSION_BADNESS;
2584 case TYPE_CODE_ENUM:
2585 case TYPE_CODE_FLAGS:
2586 case TYPE_CODE_CHAR:
2587 case TYPE_CODE_RANGE:
2588 case TYPE_CODE_BOOL:
2589 return INTEGER_PROMOTION_BADNESS;
2590 case TYPE_CODE_FLT:
2591 return INT_FLOAT_CONVERSION_BADNESS;
2592 case TYPE_CODE_PTR:
2593 return NS_POINTER_CONVERSION_BADNESS;
2594 default:
2595 return INCOMPATIBLE_TYPE_BADNESS;
2596 }
2597 break;
2598 case TYPE_CODE_ENUM:
2599 switch (TYPE_CODE (arg))
2600 {
2601 case TYPE_CODE_INT:
2602 case TYPE_CODE_CHAR:
2603 case TYPE_CODE_RANGE:
2604 case TYPE_CODE_BOOL:
2605 case TYPE_CODE_ENUM:
2606 return INTEGER_CONVERSION_BADNESS;
2607 case TYPE_CODE_FLT:
2608 return INT_FLOAT_CONVERSION_BADNESS;
2609 default:
2610 return INCOMPATIBLE_TYPE_BADNESS;
2611 }
2612 break;
2613 case TYPE_CODE_CHAR:
2614 switch (TYPE_CODE (arg))
2615 {
2616 case TYPE_CODE_RANGE:
2617 case TYPE_CODE_BOOL:
2618 case TYPE_CODE_ENUM:
2619 return INTEGER_CONVERSION_BADNESS;
2620 case TYPE_CODE_FLT:
2621 return INT_FLOAT_CONVERSION_BADNESS;
2622 case TYPE_CODE_INT:
2623 if (TYPE_LENGTH (arg) > TYPE_LENGTH (parm))
2624 return INTEGER_CONVERSION_BADNESS;
2625 else if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2626 return INTEGER_PROMOTION_BADNESS;
2627 /* >>> !! else fall through !! <<< */
2628 case TYPE_CODE_CHAR:
2629 /* Deal with signed, unsigned, and plain chars for C++ and
2630 with int cases falling through from previous case. */
2631 if (TYPE_NOSIGN (parm))
2632 {
2633 if (TYPE_NOSIGN (arg))
2634 return EXACT_MATCH_BADNESS;
2635 else
2636 return INTEGER_CONVERSION_BADNESS;
2637 }
2638 else if (TYPE_UNSIGNED (parm))
2639 {
2640 if (TYPE_UNSIGNED (arg))
2641 return EXACT_MATCH_BADNESS;
2642 else
2643 return INTEGER_PROMOTION_BADNESS;
2644 }
2645 else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
2646 return EXACT_MATCH_BADNESS;
2647 else
2648 return INTEGER_CONVERSION_BADNESS;
2649 default:
2650 return INCOMPATIBLE_TYPE_BADNESS;
2651 }
2652 break;
2653 case TYPE_CODE_RANGE:
2654 switch (TYPE_CODE (arg))
2655 {
2656 case TYPE_CODE_INT:
2657 case TYPE_CODE_CHAR:
2658 case TYPE_CODE_RANGE:
2659 case TYPE_CODE_BOOL:
2660 case TYPE_CODE_ENUM:
2661 return INTEGER_CONVERSION_BADNESS;
2662 case TYPE_CODE_FLT:
2663 return INT_FLOAT_CONVERSION_BADNESS;
2664 default:
2665 return INCOMPATIBLE_TYPE_BADNESS;
2666 }
2667 break;
2668 case TYPE_CODE_BOOL:
2669 switch (TYPE_CODE (arg))
2670 {
2671 case TYPE_CODE_INT:
2672 case TYPE_CODE_CHAR:
2673 case TYPE_CODE_RANGE:
2674 case TYPE_CODE_ENUM:
2675 case TYPE_CODE_FLT:
2676 return INCOMPATIBLE_TYPE_BADNESS;
2677 case TYPE_CODE_PTR:
2678 return BOOL_PTR_CONVERSION_BADNESS;
2679 case TYPE_CODE_BOOL:
2680 return EXACT_MATCH_BADNESS;
2681 default:
2682 return INCOMPATIBLE_TYPE_BADNESS;
2683 }
2684 break;
2685 case TYPE_CODE_FLT:
2686 switch (TYPE_CODE (arg))
2687 {
2688 case TYPE_CODE_FLT:
2689 if (TYPE_LENGTH (arg) < TYPE_LENGTH (parm))
2690 return FLOAT_PROMOTION_BADNESS;
2691 else if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
2692 return EXACT_MATCH_BADNESS;
2693 else
2694 return FLOAT_CONVERSION_BADNESS;
2695 case TYPE_CODE_INT:
2696 case TYPE_CODE_BOOL:
2697 case TYPE_CODE_ENUM:
2698 case TYPE_CODE_RANGE:
2699 case TYPE_CODE_CHAR:
2700 return INT_FLOAT_CONVERSION_BADNESS;
2701 default:
2702 return INCOMPATIBLE_TYPE_BADNESS;
2703 }
2704 break;
2705 case TYPE_CODE_COMPLEX:
2706 switch (TYPE_CODE (arg))
2707 { /* Strictly not needed for C++, but... */
2708 case TYPE_CODE_FLT:
2709 return FLOAT_PROMOTION_BADNESS;
2710 case TYPE_CODE_COMPLEX:
2711 return EXACT_MATCH_BADNESS;
2712 default:
2713 return INCOMPATIBLE_TYPE_BADNESS;
2714 }
2715 break;
2716 case TYPE_CODE_STRUCT:
2717 /* currently same as TYPE_CODE_CLASS. */
2718 switch (TYPE_CODE (arg))
2719 {
2720 case TYPE_CODE_STRUCT:
2721 /* Check for derivation */
2722 rank.subrank = distance_to_ancestor (parm, arg, 0);
2723 if (rank.subrank >= 0)
2724 return sum_ranks (BASE_CONVERSION_BADNESS, rank);
2725 /* else fall through */
2726 default:
2727 return INCOMPATIBLE_TYPE_BADNESS;
2728 }
2729 break;
2730 case TYPE_CODE_UNION:
2731 switch (TYPE_CODE (arg))
2732 {
2733 case TYPE_CODE_UNION:
2734 default:
2735 return INCOMPATIBLE_TYPE_BADNESS;
2736 }
2737 break;
2738 case TYPE_CODE_MEMBERPTR:
2739 switch (TYPE_CODE (arg))
2740 {
2741 default:
2742 return INCOMPATIBLE_TYPE_BADNESS;
2743 }
2744 break;
2745 case TYPE_CODE_METHOD:
2746 switch (TYPE_CODE (arg))
2747 {
2748
2749 default:
2750 return INCOMPATIBLE_TYPE_BADNESS;
2751 }
2752 break;
2753 case TYPE_CODE_REF:
2754 switch (TYPE_CODE (arg))
2755 {
2756
2757 default:
2758 return INCOMPATIBLE_TYPE_BADNESS;
2759 }
2760
2761 break;
2762 case TYPE_CODE_SET:
2763 switch (TYPE_CODE (arg))
2764 {
2765 /* Not in C++ */
2766 case TYPE_CODE_SET:
2767 return rank_one_type (TYPE_FIELD_TYPE (parm, 0),
2768 TYPE_FIELD_TYPE (arg, 0), NULL);
2769 default:
2770 return INCOMPATIBLE_TYPE_BADNESS;
2771 }
2772 break;
2773 case TYPE_CODE_VOID:
2774 default:
2775 return INCOMPATIBLE_TYPE_BADNESS;
2776 } /* switch (TYPE_CODE (arg)) */
2777 }
2778
2779
2780 /* End of functions for overload resolution. */
2781
2782 static void
2783 print_bit_vector (B_TYPE *bits, int nbits)
2784 {
2785 int bitno;
2786
2787 for (bitno = 0; bitno < nbits; bitno++)
2788 {
2789 if ((bitno % 8) == 0)
2790 {
2791 puts_filtered (" ");
2792 }
2793 if (B_TST (bits, bitno))
2794 printf_filtered (("1"));
2795 else
2796 printf_filtered (("0"));
2797 }
2798 }
2799
2800 /* Note the first arg should be the "this" pointer, we may not want to
2801 include it since we may get into a infinitely recursive
2802 situation. */
2803
2804 static void
2805 print_arg_types (struct field *args, int nargs, int spaces)
2806 {
2807 if (args != NULL)
2808 {
2809 int i;
2810
2811 for (i = 0; i < nargs; i++)
2812 recursive_dump_type (args[i].type, spaces + 2);
2813 }
2814 }
2815
2816 int
2817 field_is_static (struct field *f)
2818 {
2819 /* "static" fields are the fields whose location is not relative
2820 to the address of the enclosing struct. It would be nice to
2821 have a dedicated flag that would be set for static fields when
2822 the type is being created. But in practice, checking the field
2823 loc_kind should give us an accurate answer. */
2824 return (FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSNAME
2825 || FIELD_LOC_KIND (*f) == FIELD_LOC_KIND_PHYSADDR);
2826 }
2827
2828 static void
2829 dump_fn_fieldlists (struct type *type, int spaces)
2830 {
2831 int method_idx;
2832 int overload_idx;
2833 struct fn_field *f;
2834
2835 printfi_filtered (spaces, "fn_fieldlists ");
2836 gdb_print_host_address (TYPE_FN_FIELDLISTS (type), gdb_stdout);
2837 printf_filtered ("\n");
2838 for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
2839 {
2840 f = TYPE_FN_FIELDLIST1 (type, method_idx);
2841 printfi_filtered (spaces + 2, "[%d] name '%s' (",
2842 method_idx,
2843 TYPE_FN_FIELDLIST_NAME (type, method_idx));
2844 gdb_print_host_address (TYPE_FN_FIELDLIST_NAME (type, method_idx),
2845 gdb_stdout);
2846 printf_filtered (_(") length %d\n"),
2847 TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
2848 for (overload_idx = 0;
2849 overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
2850 overload_idx++)
2851 {
2852 printfi_filtered (spaces + 4, "[%d] physname '%s' (",
2853 overload_idx,
2854 TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
2855 gdb_print_host_address (TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
2856 gdb_stdout);
2857 printf_filtered (")\n");
2858 printfi_filtered (spaces + 8, "type ");
2859 gdb_print_host_address (TYPE_FN_FIELD_TYPE (f, overload_idx),
2860 gdb_stdout);
2861 printf_filtered ("\n");
2862
2863 recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
2864 spaces + 8 + 2);
2865
2866 printfi_filtered (spaces + 8, "args ");
2867 gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx),
2868 gdb_stdout);
2869 printf_filtered ("\n");
2870
2871 print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx),
2872 TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f,
2873 overload_idx)),
2874 spaces);
2875 printfi_filtered (spaces + 8, "fcontext ");
2876 gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
2877 gdb_stdout);
2878 printf_filtered ("\n");
2879
2880 printfi_filtered (spaces + 8, "is_const %d\n",
2881 TYPE_FN_FIELD_CONST (f, overload_idx));
2882 printfi_filtered (spaces + 8, "is_volatile %d\n",
2883 TYPE_FN_FIELD_VOLATILE (f, overload_idx));
2884 printfi_filtered (spaces + 8, "is_private %d\n",
2885 TYPE_FN_FIELD_PRIVATE (f, overload_idx));
2886 printfi_filtered (spaces + 8, "is_protected %d\n",
2887 TYPE_FN_FIELD_PROTECTED (f, overload_idx));
2888 printfi_filtered (spaces + 8, "is_stub %d\n",
2889 TYPE_FN_FIELD_STUB (f, overload_idx));
2890 printfi_filtered (spaces + 8, "voffset %u\n",
2891 TYPE_FN_FIELD_VOFFSET (f, overload_idx));
2892 }
2893 }
2894 }
2895
2896 static void
2897 print_cplus_stuff (struct type *type, int spaces)
2898 {
2899 printfi_filtered (spaces, "n_baseclasses %d\n",
2900 TYPE_N_BASECLASSES (type));
2901 printfi_filtered (spaces, "nfn_fields %d\n",
2902 TYPE_NFN_FIELDS (type));
2903 if (TYPE_N_BASECLASSES (type) > 0)
2904 {
2905 printfi_filtered (spaces, "virtual_field_bits (%d bits at *",
2906 TYPE_N_BASECLASSES (type));
2907 gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type),
2908 gdb_stdout);
2909 printf_filtered (")");
2910
2911 print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
2912 TYPE_N_BASECLASSES (type));
2913 puts_filtered ("\n");
2914 }
2915 if (TYPE_NFIELDS (type) > 0)
2916 {
2917 if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
2918 {
2919 printfi_filtered (spaces,
2920 "private_field_bits (%d bits at *",
2921 TYPE_NFIELDS (type));
2922 gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type),
2923 gdb_stdout);
2924 printf_filtered (")");
2925 print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
2926 TYPE_NFIELDS (type));
2927 puts_filtered ("\n");
2928 }
2929 if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
2930 {
2931 printfi_filtered (spaces,
2932 "protected_field_bits (%d bits at *",
2933 TYPE_NFIELDS (type));
2934 gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type),
2935 gdb_stdout);
2936 printf_filtered (")");
2937 print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
2938 TYPE_NFIELDS (type));
2939 puts_filtered ("\n");
2940 }
2941 }
2942 if (TYPE_NFN_FIELDS (type) > 0)
2943 {
2944 dump_fn_fieldlists (type, spaces);
2945 }
2946 }
2947
2948 /* Print the contents of the TYPE's type_specific union, assuming that
2949 its type-specific kind is TYPE_SPECIFIC_GNAT_STUFF. */
2950
2951 static void
2952 print_gnat_stuff (struct type *type, int spaces)
2953 {
2954 struct type *descriptive_type = TYPE_DESCRIPTIVE_TYPE (type);
2955
2956 recursive_dump_type (descriptive_type, spaces + 2);
2957 }
2958
2959 static struct obstack dont_print_type_obstack;
2960
2961 void
2962 recursive_dump_type (struct type *type, int spaces)
2963 {
2964 int idx;
2965
2966 if (spaces == 0)
2967 obstack_begin (&dont_print_type_obstack, 0);
2968
2969 if (TYPE_NFIELDS (type) > 0
2970 || (HAVE_CPLUS_STRUCT (type) && TYPE_NFN_FIELDS (type) > 0))
2971 {
2972 struct type **first_dont_print
2973 = (struct type **) obstack_base (&dont_print_type_obstack);
2974
2975 int i = (struct type **)
2976 obstack_next_free (&dont_print_type_obstack) - first_dont_print;
2977
2978 while (--i >= 0)
2979 {
2980 if (type == first_dont_print[i])
2981 {
2982 printfi_filtered (spaces, "type node ");
2983 gdb_print_host_address (type, gdb_stdout);
2984 printf_filtered (_(" <same as already seen type>\n"));
2985 return;
2986 }
2987 }
2988
2989 obstack_ptr_grow (&dont_print_type_obstack, type);
2990 }
2991
2992 printfi_filtered (spaces, "type node ");
2993 gdb_print_host_address (type, gdb_stdout);
2994 printf_filtered ("\n");
2995 printfi_filtered (spaces, "name '%s' (",
2996 TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>");
2997 gdb_print_host_address (TYPE_NAME (type), gdb_stdout);
2998 printf_filtered (")\n");
2999 printfi_filtered (spaces, "tagname '%s' (",
3000 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) : "<NULL>");
3001 gdb_print_host_address (TYPE_TAG_NAME (type), gdb_stdout);
3002 printf_filtered (")\n");
3003 printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
3004 switch (TYPE_CODE (type))
3005 {
3006 case TYPE_CODE_UNDEF:
3007 printf_filtered ("(TYPE_CODE_UNDEF)");
3008 break;
3009 case TYPE_CODE_PTR:
3010 printf_filtered ("(TYPE_CODE_PTR)");
3011 break;
3012 case TYPE_CODE_ARRAY:
3013 printf_filtered ("(TYPE_CODE_ARRAY)");
3014 break;
3015 case TYPE_CODE_STRUCT:
3016 printf_filtered ("(TYPE_CODE_STRUCT)");
3017 break;
3018 case TYPE_CODE_UNION:
3019 printf_filtered ("(TYPE_CODE_UNION)");
3020 break;
3021 case TYPE_CODE_ENUM:
3022 printf_filtered ("(TYPE_CODE_ENUM)");
3023 break;
3024 case TYPE_CODE_FLAGS:
3025 printf_filtered ("(TYPE_CODE_FLAGS)");
3026 break;
3027 case TYPE_CODE_FUNC:
3028 printf_filtered ("(TYPE_CODE_FUNC)");
3029 break;
3030 case TYPE_CODE_INT:
3031 printf_filtered ("(TYPE_CODE_INT)");
3032 break;
3033 case TYPE_CODE_FLT:
3034 printf_filtered ("(TYPE_CODE_FLT)");
3035 break;
3036 case TYPE_CODE_VOID:
3037 printf_filtered ("(TYPE_CODE_VOID)");
3038 break;
3039 case TYPE_CODE_SET:
3040 printf_filtered ("(TYPE_CODE_SET)");
3041 break;
3042 case TYPE_CODE_RANGE:
3043 printf_filtered ("(TYPE_CODE_RANGE)");
3044 break;
3045 case TYPE_CODE_STRING:
3046 printf_filtered ("(TYPE_CODE_STRING)");
3047 break;
3048 case TYPE_CODE_BITSTRING:
3049 printf_filtered ("(TYPE_CODE_BITSTRING)");
3050 break;
3051 case TYPE_CODE_ERROR:
3052 printf_filtered ("(TYPE_CODE_ERROR)");
3053 break;
3054 case TYPE_CODE_MEMBERPTR:
3055 printf_filtered ("(TYPE_CODE_MEMBERPTR)");
3056 break;
3057 case TYPE_CODE_METHODPTR:
3058 printf_filtered ("(TYPE_CODE_METHODPTR)");
3059 break;
3060 case TYPE_CODE_METHOD:
3061 printf_filtered ("(TYPE_CODE_METHOD)");
3062 break;
3063 case TYPE_CODE_REF:
3064 printf_filtered ("(TYPE_CODE_REF)");
3065 break;
3066 case TYPE_CODE_CHAR:
3067 printf_filtered ("(TYPE_CODE_CHAR)");
3068 break;
3069 case TYPE_CODE_BOOL:
3070 printf_filtered ("(TYPE_CODE_BOOL)");
3071 break;
3072 case TYPE_CODE_COMPLEX:
3073 printf_filtered ("(TYPE_CODE_COMPLEX)");
3074 break;
3075 case TYPE_CODE_TYPEDEF:
3076 printf_filtered ("(TYPE_CODE_TYPEDEF)");
3077 break;
3078 case TYPE_CODE_NAMESPACE:
3079 printf_filtered ("(TYPE_CODE_NAMESPACE)");
3080 break;
3081 default:
3082 printf_filtered ("(UNKNOWN TYPE CODE)");
3083 break;
3084 }
3085 puts_filtered ("\n");
3086 printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
3087 if (TYPE_OBJFILE_OWNED (type))
3088 {
3089 printfi_filtered (spaces, "objfile ");
3090 gdb_print_host_address (TYPE_OWNER (type).objfile, gdb_stdout);
3091 }
3092 else
3093 {
3094 printfi_filtered (spaces, "gdbarch ");
3095 gdb_print_host_address (TYPE_OWNER (type).gdbarch, gdb_stdout);
3096 }
3097 printf_filtered ("\n");
3098 printfi_filtered (spaces, "target_type ");
3099 gdb_print_host_address (TYPE_TARGET_TYPE (type), gdb_stdout);
3100 printf_filtered ("\n");
3101 if (TYPE_TARGET_TYPE (type) != NULL)
3102 {
3103 recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
3104 }
3105 printfi_filtered (spaces, "pointer_type ");
3106 gdb_print_host_address (TYPE_POINTER_TYPE (type), gdb_stdout);
3107 printf_filtered ("\n");
3108 printfi_filtered (spaces, "reference_type ");
3109 gdb_print_host_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
3110 printf_filtered ("\n");
3111 printfi_filtered (spaces, "type_chain ");
3112 gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout);
3113 printf_filtered ("\n");
3114 printfi_filtered (spaces, "instance_flags 0x%x",
3115 TYPE_INSTANCE_FLAGS (type));
3116 if (TYPE_CONST (type))
3117 {
3118 puts_filtered (" TYPE_FLAG_CONST");
3119 }
3120 if (TYPE_VOLATILE (type))
3121 {
3122 puts_filtered (" TYPE_FLAG_VOLATILE");
3123 }
3124 if (TYPE_CODE_SPACE (type))
3125 {
3126 puts_filtered (" TYPE_FLAG_CODE_SPACE");
3127 }
3128 if (TYPE_DATA_SPACE (type))
3129 {
3130 puts_filtered (" TYPE_FLAG_DATA_SPACE");
3131 }
3132 if (TYPE_ADDRESS_CLASS_1 (type))
3133 {
3134 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_1");
3135 }
3136 if (TYPE_ADDRESS_CLASS_2 (type))
3137 {
3138 puts_filtered (" TYPE_FLAG_ADDRESS_CLASS_2");
3139 }
3140 puts_filtered ("\n");
3141
3142 printfi_filtered (spaces, "flags");
3143 if (TYPE_UNSIGNED (type))
3144 {
3145 puts_filtered (" TYPE_FLAG_UNSIGNED");
3146 }
3147 if (TYPE_NOSIGN (type))
3148 {
3149 puts_filtered (" TYPE_FLAG_NOSIGN");
3150 }
3151 if (TYPE_STUB (type))
3152 {
3153 puts_filtered (" TYPE_FLAG_STUB");
3154 }
3155 if (TYPE_TARGET_STUB (type))
3156 {
3157 puts_filtered (" TYPE_FLAG_TARGET_STUB");
3158 }
3159 if (TYPE_STATIC (type))
3160 {
3161 puts_filtered (" TYPE_FLAG_STATIC");
3162 }
3163 if (TYPE_PROTOTYPED (type))
3164 {
3165 puts_filtered (" TYPE_FLAG_PROTOTYPED");
3166 }
3167 if (TYPE_INCOMPLETE (type))
3168 {
3169 puts_filtered (" TYPE_FLAG_INCOMPLETE");
3170 }
3171 if (TYPE_VARARGS (type))
3172 {
3173 puts_filtered (" TYPE_FLAG_VARARGS");
3174 }
3175 /* This is used for things like AltiVec registers on ppc. Gcc emits
3176 an attribute for the array type, which tells whether or not we
3177 have a vector, instead of a regular array. */
3178 if (TYPE_VECTOR (type))
3179 {
3180 puts_filtered (" TYPE_FLAG_VECTOR");
3181 }
3182 if (TYPE_FIXED_INSTANCE (type))
3183 {
3184 puts_filtered (" TYPE_FIXED_INSTANCE");
3185 }
3186 if (TYPE_STUB_SUPPORTED (type))
3187 {
3188 puts_filtered (" TYPE_STUB_SUPPORTED");
3189 }
3190 if (TYPE_NOTTEXT (type))
3191 {
3192 puts_filtered (" TYPE_NOTTEXT");
3193 }
3194 puts_filtered ("\n");
3195 printfi_filtered (spaces, "nfields %d ", TYPE_NFIELDS (type));
3196 gdb_print_host_address (TYPE_FIELDS (type), gdb_stdout);
3197 puts_filtered ("\n");
3198 for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
3199 {
3200 if (TYPE_CODE (type) == TYPE_CODE_ENUM)
3201 printfi_filtered (spaces + 2,
3202 "[%d] enumval %s type ",
3203 idx, plongest (TYPE_FIELD_ENUMVAL (type, idx)));
3204 else
3205 printfi_filtered (spaces + 2,
3206 "[%d] bitpos %d bitsize %d type ",
3207 idx, TYPE_FIELD_BITPOS (type, idx),
3208 TYPE_FIELD_BITSIZE (type, idx));
3209 gdb_print_host_address (TYPE_FIELD_TYPE (type, idx), gdb_stdout);
3210 printf_filtered (" name '%s' (",
3211 TYPE_FIELD_NAME (type, idx) != NULL
3212 ? TYPE_FIELD_NAME (type, idx)
3213 : "<NULL>");
3214 gdb_print_host_address (TYPE_FIELD_NAME (type, idx), gdb_stdout);
3215 printf_filtered (")\n");
3216 if (TYPE_FIELD_TYPE (type, idx) != NULL)
3217 {
3218 recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
3219 }
3220 }
3221 if (TYPE_CODE (type) == TYPE_CODE_RANGE)
3222 {
3223 printfi_filtered (spaces, "low %s%s high %s%s\n",
3224 plongest (TYPE_LOW_BOUND (type)),
3225 TYPE_LOW_BOUND_UNDEFINED (type) ? " (undefined)" : "",
3226 plongest (TYPE_HIGH_BOUND (type)),
3227 TYPE_HIGH_BOUND_UNDEFINED (type)
3228 ? " (undefined)" : "");
3229 }
3230 printfi_filtered (spaces, "vptr_basetype ");
3231 gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
3232 puts_filtered ("\n");
3233 if (TYPE_VPTR_BASETYPE (type) != NULL)
3234 {
3235 recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
3236 }
3237 printfi_filtered (spaces, "vptr_fieldno %d\n",
3238 TYPE_VPTR_FIELDNO (type));
3239
3240 switch (TYPE_SPECIFIC_FIELD (type))
3241 {
3242 case TYPE_SPECIFIC_CPLUS_STUFF:
3243 printfi_filtered (spaces, "cplus_stuff ");
3244 gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type),
3245 gdb_stdout);
3246 puts_filtered ("\n");
3247 print_cplus_stuff (type, spaces);
3248 break;
3249
3250 case TYPE_SPECIFIC_GNAT_STUFF:
3251 printfi_filtered (spaces, "gnat_stuff ");
3252 gdb_print_host_address (TYPE_GNAT_SPECIFIC (type), gdb_stdout);
3253 puts_filtered ("\n");
3254 print_gnat_stuff (type, spaces);
3255 break;
3256
3257 case TYPE_SPECIFIC_FLOATFORMAT:
3258 printfi_filtered (spaces, "floatformat ");
3259 if (TYPE_FLOATFORMAT (type) == NULL)
3260 puts_filtered ("(null)");
3261 else
3262 {
3263 puts_filtered ("{ ");
3264 if (TYPE_FLOATFORMAT (type)[0] == NULL
3265 || TYPE_FLOATFORMAT (type)[0]->name == NULL)
3266 puts_filtered ("(null)");
3267 else
3268 puts_filtered (TYPE_FLOATFORMAT (type)[0]->name);
3269
3270 puts_filtered (", ");
3271 if (TYPE_FLOATFORMAT (type)[1] == NULL
3272 || TYPE_FLOATFORMAT (type)[1]->name == NULL)
3273 puts_filtered ("(null)");
3274 else
3275 puts_filtered (TYPE_FLOATFORMAT (type)[1]->name);
3276
3277 puts_filtered (" }");
3278 }
3279 puts_filtered ("\n");
3280 break;
3281
3282 case TYPE_SPECIFIC_FUNC:
3283 printfi_filtered (spaces, "calling_convention %d\n",
3284 TYPE_CALLING_CONVENTION (type));
3285 /* tail_call_list is not printed. */
3286 break;
3287 }
3288
3289 if (spaces == 0)
3290 obstack_free (&dont_print_type_obstack, NULL);
3291 }
3292
3293 /* Trivial helpers for the libiberty hash table, for mapping one
3294 type to another. */
3295
3296 struct type_pair
3297 {
3298 struct type *old, *new;
3299 };
3300
3301 static hashval_t
3302 type_pair_hash (const void *item)
3303 {
3304 const struct type_pair *pair = item;
3305
3306 return htab_hash_pointer (pair->old);
3307 }
3308
3309 static int
3310 type_pair_eq (const void *item_lhs, const void *item_rhs)
3311 {
3312 const struct type_pair *lhs = item_lhs, *rhs = item_rhs;
3313
3314 return lhs->old == rhs->old;
3315 }
3316
3317 /* Allocate the hash table used by copy_type_recursive to walk
3318 types without duplicates. We use OBJFILE's obstack, because
3319 OBJFILE is about to be deleted. */
3320
3321 htab_t
3322 create_copied_types_hash (struct objfile *objfile)
3323 {
3324 return htab_create_alloc_ex (1, type_pair_hash, type_pair_eq,
3325 NULL, &objfile->objfile_obstack,
3326 hashtab_obstack_allocate,
3327 dummy_obstack_deallocate);
3328 }
3329
3330 /* Recursively copy (deep copy) TYPE, if it is associated with
3331 OBJFILE. Return a new type allocated using malloc, a saved type if
3332 we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
3333 not associated with OBJFILE. */
3334
3335 struct type *
3336 copy_type_recursive (struct objfile *objfile,
3337 struct type *type,
3338 htab_t copied_types)
3339 {
3340 struct type_pair *stored, pair;
3341 void **slot;
3342 struct type *new_type;
3343
3344 if (! TYPE_OBJFILE_OWNED (type))
3345 return type;
3346
3347 /* This type shouldn't be pointing to any types in other objfiles;
3348 if it did, the type might disappear unexpectedly. */
3349 gdb_assert (TYPE_OBJFILE (type) == objfile);
3350
3351 pair.old = type;
3352 slot = htab_find_slot (copied_types, &pair, INSERT);
3353 if (*slot != NULL)
3354 return ((struct type_pair *) *slot)->new;
3355
3356 new_type = alloc_type_arch (get_type_arch (type));
3357
3358 /* We must add the new type to the hash table immediately, in case
3359 we encounter this type again during a recursive call below. */
3360 stored
3361 = obstack_alloc (&objfile->objfile_obstack, sizeof (struct type_pair));
3362 stored->old = type;
3363 stored->new = new_type;
3364 *slot = stored;
3365
3366 /* Copy the common fields of types. For the main type, we simply
3367 copy the entire thing and then update specific fields as needed. */
3368 *TYPE_MAIN_TYPE (new_type) = *TYPE_MAIN_TYPE (type);
3369 TYPE_OBJFILE_OWNED (new_type) = 0;
3370 TYPE_OWNER (new_type).gdbarch = get_type_arch (type);
3371
3372 if (TYPE_NAME (type))
3373 TYPE_NAME (new_type) = xstrdup (TYPE_NAME (type));
3374 if (TYPE_TAG_NAME (type))
3375 TYPE_TAG_NAME (new_type) = xstrdup (TYPE_TAG_NAME (type));
3376
3377 TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
3378 TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
3379
3380 /* Copy the fields. */
3381 if (TYPE_NFIELDS (type))
3382 {
3383 int i, nfields;
3384
3385 nfields = TYPE_NFIELDS (type);
3386 TYPE_FIELDS (new_type) = XCALLOC (nfields, struct field);
3387 for (i = 0; i < nfields; i++)
3388 {
3389 TYPE_FIELD_ARTIFICIAL (new_type, i) =
3390 TYPE_FIELD_ARTIFICIAL (type, i);
3391 TYPE_FIELD_BITSIZE (new_type, i) = TYPE_FIELD_BITSIZE (type, i);
3392 if (TYPE_FIELD_TYPE (type, i))
3393 TYPE_FIELD_TYPE (new_type, i)
3394 = copy_type_recursive (objfile, TYPE_FIELD_TYPE (type, i),
3395 copied_types);
3396 if (TYPE_FIELD_NAME (type, i))
3397 TYPE_FIELD_NAME (new_type, i) =
3398 xstrdup (TYPE_FIELD_NAME (type, i));
3399 switch (TYPE_FIELD_LOC_KIND (type, i))
3400 {
3401 case FIELD_LOC_KIND_BITPOS:
3402 SET_FIELD_BITPOS (TYPE_FIELD (new_type, i),
3403 TYPE_FIELD_BITPOS (type, i));
3404 break;
3405 case FIELD_LOC_KIND_ENUMVAL:
3406 SET_FIELD_ENUMVAL (TYPE_FIELD (new_type, i),
3407 TYPE_FIELD_ENUMVAL (type, i));
3408 break;
3409 case FIELD_LOC_KIND_PHYSADDR:
3410 SET_FIELD_PHYSADDR (TYPE_FIELD (new_type, i),
3411 TYPE_FIELD_STATIC_PHYSADDR (type, i));
3412 break;
3413 case FIELD_LOC_KIND_PHYSNAME:
3414 SET_FIELD_PHYSNAME (TYPE_FIELD (new_type, i),
3415 xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type,
3416 i)));
3417 break;
3418 default:
3419 internal_error (__FILE__, __LINE__,
3420 _("Unexpected type field location kind: %d"),
3421 TYPE_FIELD_LOC_KIND (type, i));
3422 }
3423 }
3424 }
3425
3426 /* For range types, copy the bounds information. */
3427 if (TYPE_CODE (type) == TYPE_CODE_RANGE)
3428 {
3429 TYPE_RANGE_DATA (new_type) = xmalloc (sizeof (struct range_bounds));
3430 *TYPE_RANGE_DATA (new_type) = *TYPE_RANGE_DATA (type);
3431 }
3432
3433 /* Copy pointers to other types. */
3434 if (TYPE_TARGET_TYPE (type))
3435 TYPE_TARGET_TYPE (new_type) =
3436 copy_type_recursive (objfile,
3437 TYPE_TARGET_TYPE (type),
3438 copied_types);
3439 if (TYPE_VPTR_BASETYPE (type))
3440 TYPE_VPTR_BASETYPE (new_type) =
3441 copy_type_recursive (objfile,
3442 TYPE_VPTR_BASETYPE (type),
3443 copied_types);
3444 /* Maybe copy the type_specific bits.
3445
3446 NOTE drow/2005-12-09: We do not copy the C++-specific bits like
3447 base classes and methods. There's no fundamental reason why we
3448 can't, but at the moment it is not needed. */
3449
3450 if (TYPE_CODE (type) == TYPE_CODE_FLT)
3451 TYPE_FLOATFORMAT (new_type) = TYPE_FLOATFORMAT (type);
3452 else if (TYPE_CODE (type) == TYPE_CODE_STRUCT
3453 || TYPE_CODE (type) == TYPE_CODE_UNION
3454 || TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
3455 INIT_CPLUS_SPECIFIC (new_type);
3456
3457 return new_type;
3458 }
3459
3460 /* Make a copy of the given TYPE, except that the pointer & reference
3461 types are not preserved.
3462
3463 This function assumes that the given type has an associated objfile.
3464 This objfile is used to allocate the new type. */
3465
3466 struct type *
3467 copy_type (const struct type *type)
3468 {
3469 struct type *new_type;
3470
3471 gdb_assert (TYPE_OBJFILE_OWNED (type));
3472
3473 new_type = alloc_type_copy (type);
3474 TYPE_INSTANCE_FLAGS (new_type) = TYPE_INSTANCE_FLAGS (type);
3475 TYPE_LENGTH (new_type) = TYPE_LENGTH (type);
3476 memcpy (TYPE_MAIN_TYPE (new_type), TYPE_MAIN_TYPE (type),
3477 sizeof (struct main_type));
3478
3479 return new_type;
3480 }
3481
3482
3483 /* Helper functions to initialize architecture-specific types. */
3484
3485 /* Allocate a type structure associated with GDBARCH and set its
3486 CODE, LENGTH, and NAME fields. */
3487 struct type *
3488 arch_type (struct gdbarch *gdbarch,
3489 enum type_code code, int length, char *name)
3490 {
3491 struct type *type;
3492
3493 type = alloc_type_arch (gdbarch);
3494 TYPE_CODE (type) = code;
3495 TYPE_LENGTH (type) = length;
3496
3497 if (name)
3498 TYPE_NAME (type) = xstrdup (name);
3499
3500 return type;
3501 }
3502
3503 /* Allocate a TYPE_CODE_INT type structure associated with GDBARCH.
3504 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3505 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3506 struct type *
3507 arch_integer_type (struct gdbarch *gdbarch,
3508 int bit, int unsigned_p, char *name)
3509 {
3510 struct type *t;
3511
3512 t = arch_type (gdbarch, TYPE_CODE_INT, bit / TARGET_CHAR_BIT, name);
3513 if (unsigned_p)
3514 TYPE_UNSIGNED (t) = 1;
3515 if (name && strcmp (name, "char") == 0)
3516 TYPE_NOSIGN (t) = 1;
3517
3518 return t;
3519 }
3520
3521 /* Allocate a TYPE_CODE_CHAR type structure associated with GDBARCH.
3522 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3523 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3524 struct type *
3525 arch_character_type (struct gdbarch *gdbarch,
3526 int bit, int unsigned_p, char *name)
3527 {
3528 struct type *t;
3529
3530 t = arch_type (gdbarch, TYPE_CODE_CHAR, bit / TARGET_CHAR_BIT, name);
3531 if (unsigned_p)
3532 TYPE_UNSIGNED (t) = 1;
3533
3534 return t;
3535 }
3536
3537 /* Allocate a TYPE_CODE_BOOL type structure associated with GDBARCH.
3538 BIT is the type size in bits. If UNSIGNED_P is non-zero, set
3539 the type's TYPE_UNSIGNED flag. NAME is the type name. */
3540 struct type *
3541 arch_boolean_type (struct gdbarch *gdbarch,
3542 int bit, int unsigned_p, char *name)
3543 {
3544 struct type *t;
3545
3546 t = arch_type (gdbarch, TYPE_CODE_BOOL, bit / TARGET_CHAR_BIT, name);
3547 if (unsigned_p)
3548 TYPE_UNSIGNED (t) = 1;
3549
3550 return t;
3551 }
3552
3553 /* Allocate a TYPE_CODE_FLT type structure associated with GDBARCH.
3554 BIT is the type size in bits; if BIT equals -1, the size is
3555 determined by the floatformat. NAME is the type name. Set the
3556 TYPE_FLOATFORMAT from FLOATFORMATS. */
3557 struct type *
3558 arch_float_type (struct gdbarch *gdbarch,
3559 int bit, char *name, const struct floatformat **floatformats)
3560 {
3561 struct type *t;
3562
3563 if (bit == -1)
3564 {
3565 gdb_assert (floatformats != NULL);
3566 gdb_assert (floatformats[0] != NULL && floatformats[1] != NULL);
3567 bit = floatformats[0]->totalsize;
3568 }
3569 gdb_assert (bit >= 0);
3570
3571 t = arch_type (gdbarch, TYPE_CODE_FLT, bit / TARGET_CHAR_BIT, name);
3572 TYPE_FLOATFORMAT (t) = floatformats;
3573 return t;
3574 }
3575
3576 /* Allocate a TYPE_CODE_COMPLEX type structure associated with GDBARCH.
3577 NAME is the type name. TARGET_TYPE is the component float type. */
3578 struct type *
3579 arch_complex_type (struct gdbarch *gdbarch,
3580 char *name, struct type *target_type)
3581 {
3582 struct type *t;
3583
3584 t = arch_type (gdbarch, TYPE_CODE_COMPLEX,
3585 2 * TYPE_LENGTH (target_type), name);
3586 TYPE_TARGET_TYPE (t) = target_type;
3587 return t;
3588 }
3589
3590 /* Allocate a TYPE_CODE_FLAGS type structure associated with GDBARCH.
3591 NAME is the type name. LENGTH is the size of the flag word in bytes. */
3592 struct type *
3593 arch_flags_type (struct gdbarch *gdbarch, char *name, int length)
3594 {
3595 int nfields = length * TARGET_CHAR_BIT;
3596 struct type *type;
3597
3598 type = arch_type (gdbarch, TYPE_CODE_FLAGS, length, name);
3599 TYPE_UNSIGNED (type) = 1;
3600 TYPE_NFIELDS (type) = nfields;
3601 TYPE_FIELDS (type) = TYPE_ZALLOC (type, nfields * sizeof (struct field));
3602
3603 return type;
3604 }
3605
3606 /* Add field to TYPE_CODE_FLAGS type TYPE to indicate the bit at
3607 position BITPOS is called NAME. */
3608 void
3609 append_flags_type_flag (struct type *type, int bitpos, char *name)
3610 {
3611 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLAGS);
3612 gdb_assert (bitpos < TYPE_NFIELDS (type));
3613 gdb_assert (bitpos >= 0);
3614
3615 if (name)
3616 {
3617 TYPE_FIELD_NAME (type, bitpos) = xstrdup (name);
3618 SET_FIELD_BITPOS (TYPE_FIELD (type, bitpos), bitpos);
3619 }
3620 else
3621 {
3622 /* Don't show this field to the user. */
3623 SET_FIELD_BITPOS (TYPE_FIELD (type, bitpos), -1);
3624 }
3625 }
3626
3627 /* Allocate a TYPE_CODE_STRUCT or TYPE_CODE_UNION type structure (as
3628 specified by CODE) associated with GDBARCH. NAME is the type name. */
3629 struct type *
3630 arch_composite_type (struct gdbarch *gdbarch, char *name, enum type_code code)
3631 {
3632 struct type *t;
3633
3634 gdb_assert (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION);
3635 t = arch_type (gdbarch, code, 0, NULL);
3636 TYPE_TAG_NAME (t) = name;
3637 INIT_CPLUS_SPECIFIC (t);
3638 return t;
3639 }
3640
3641 /* Add new field with name NAME and type FIELD to composite type T.
3642 Do not set the field's position or adjust the type's length;
3643 the caller should do so. Return the new field. */
3644 struct field *
3645 append_composite_type_field_raw (struct type *t, char *name,
3646 struct type *field)
3647 {
3648 struct field *f;
3649
3650 TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1;
3651 TYPE_FIELDS (t) = xrealloc (TYPE_FIELDS (t),
3652 sizeof (struct field) * TYPE_NFIELDS (t));
3653 f = &(TYPE_FIELDS (t)[TYPE_NFIELDS (t) - 1]);
3654 memset (f, 0, sizeof f[0]);
3655 FIELD_TYPE (f[0]) = field;
3656 FIELD_NAME (f[0]) = name;
3657 return f;
3658 }
3659
3660 /* Add new field with name NAME and type FIELD to composite type T.
3661 ALIGNMENT (if non-zero) specifies the minimum field alignment. */
3662 void
3663 append_composite_type_field_aligned (struct type *t, char *name,
3664 struct type *field, int alignment)
3665 {
3666 struct field *f = append_composite_type_field_raw (t, name, field);
3667
3668 if (TYPE_CODE (t) == TYPE_CODE_UNION)
3669 {
3670 if (TYPE_LENGTH (t) < TYPE_LENGTH (field))
3671 TYPE_LENGTH (t) = TYPE_LENGTH (field);
3672 }
3673 else if (TYPE_CODE (t) == TYPE_CODE_STRUCT)
3674 {
3675 TYPE_LENGTH (t) = TYPE_LENGTH (t) + TYPE_LENGTH (field);
3676 if (TYPE_NFIELDS (t) > 1)
3677 {
3678 SET_FIELD_BITPOS (f[0],
3679 (FIELD_BITPOS (f[-1])
3680 + (TYPE_LENGTH (FIELD_TYPE (f[-1]))
3681 * TARGET_CHAR_BIT)));
3682
3683 if (alignment)
3684 {
3685 int left;
3686
3687 alignment *= TARGET_CHAR_BIT;
3688 left = FIELD_BITPOS (f[0]) % alignment;
3689
3690 if (left)
3691 {
3692 SET_FIELD_BITPOS (f[0], FIELD_BITPOS (f[0]) + (alignment - left));
3693 TYPE_LENGTH (t) += (alignment - left) / TARGET_CHAR_BIT;
3694 }
3695 }
3696 }
3697 }
3698 }
3699
3700 /* Add new field with name NAME and type FIELD to composite type T. */
3701 void
3702 append_composite_type_field (struct type *t, char *name,
3703 struct type *field)
3704 {
3705 append_composite_type_field_aligned (t, name, field, 0);
3706 }
3707
3708
3709 static struct gdbarch_data *gdbtypes_data;
3710
3711 const struct builtin_type *
3712 builtin_type (struct gdbarch *gdbarch)
3713 {
3714 return gdbarch_data (gdbarch, gdbtypes_data);
3715 }
3716
3717 static void *
3718 gdbtypes_post_init (struct gdbarch *gdbarch)
3719 {
3720 struct builtin_type *builtin_type
3721 = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_type);
3722
3723 /* Basic types. */
3724 builtin_type->builtin_void
3725 = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
3726 builtin_type->builtin_char
3727 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
3728 !gdbarch_char_signed (gdbarch), "char");
3729 builtin_type->builtin_signed_char
3730 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
3731 0, "signed char");
3732 builtin_type->builtin_unsigned_char
3733 = arch_integer_type (gdbarch, TARGET_CHAR_BIT,
3734 1, "unsigned char");
3735 builtin_type->builtin_short
3736 = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
3737 0, "short");
3738 builtin_type->builtin_unsigned_short
3739 = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch),
3740 1, "unsigned short");
3741 builtin_type->builtin_int
3742 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
3743 0, "int");
3744 builtin_type->builtin_unsigned_int
3745 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch),
3746 1, "unsigned int");
3747 builtin_type->builtin_long
3748 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
3749 0, "long");
3750 builtin_type->builtin_unsigned_long
3751 = arch_integer_type (gdbarch, gdbarch_long_bit (gdbarch),
3752 1, "unsigned long");
3753 builtin_type->builtin_long_long
3754 = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
3755 0, "long long");
3756 builtin_type->builtin_unsigned_long_long
3757 = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch),
3758 1, "unsigned long long");
3759 builtin_type->builtin_float
3760 = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
3761 "float", gdbarch_float_format (gdbarch));
3762 builtin_type->builtin_double
3763 = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
3764 "double", gdbarch_double_format (gdbarch));
3765 builtin_type->builtin_long_double
3766 = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
3767 "long double", gdbarch_long_double_format (gdbarch));
3768 builtin_type->builtin_complex
3769 = arch_complex_type (gdbarch, "complex",
3770 builtin_type->builtin_float);
3771 builtin_type->builtin_double_complex
3772 = arch_complex_type (gdbarch, "double complex",
3773 builtin_type->builtin_double);
3774 builtin_type->builtin_string
3775 = arch_type (gdbarch, TYPE_CODE_STRING, 1, "string");
3776 builtin_type->builtin_bool
3777 = arch_type (gdbarch, TYPE_CODE_BOOL, 1, "bool");
3778
3779 /* The following three are about decimal floating point types, which
3780 are 32-bits, 64-bits and 128-bits respectively. */
3781 builtin_type->builtin_decfloat
3782 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 32 / 8, "_Decimal32");
3783 builtin_type->builtin_decdouble
3784 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 64 / 8, "_Decimal64");
3785 builtin_type->builtin_declong
3786 = arch_type (gdbarch, TYPE_CODE_DECFLOAT, 128 / 8, "_Decimal128");
3787
3788 /* "True" character types. */
3789 builtin_type->builtin_true_char
3790 = arch_character_type (gdbarch, TARGET_CHAR_BIT, 0, "true character");
3791 builtin_type->builtin_true_unsigned_char
3792 = arch_character_type (gdbarch, TARGET_CHAR_BIT, 1, "true character");
3793
3794 /* Fixed-size integer types. */
3795 builtin_type->builtin_int0
3796 = arch_integer_type (gdbarch, 0, 0, "int0_t");
3797 builtin_type->builtin_int8
3798 = arch_integer_type (gdbarch, 8, 0, "int8_t");
3799 builtin_type->builtin_uint8
3800 = arch_integer_type (gdbarch, 8, 1, "uint8_t");
3801 builtin_type->builtin_int16
3802 = arch_integer_type (gdbarch, 16, 0, "int16_t");
3803 builtin_type->builtin_uint16
3804 = arch_integer_type (gdbarch, 16, 1, "uint16_t");
3805 builtin_type->builtin_int32
3806 = arch_integer_type (gdbarch, 32, 0, "int32_t");
3807 builtin_type->builtin_uint32
3808 = arch_integer_type (gdbarch, 32, 1, "uint32_t");
3809 builtin_type->builtin_int64
3810 = arch_integer_type (gdbarch, 64, 0, "int64_t");
3811 builtin_type->builtin_uint64
3812 = arch_integer_type (gdbarch, 64, 1, "uint64_t");
3813 builtin_type->builtin_int128
3814 = arch_integer_type (gdbarch, 128, 0, "int128_t");
3815 builtin_type->builtin_uint128
3816 = arch_integer_type (gdbarch, 128, 1, "uint128_t");
3817 TYPE_INSTANCE_FLAGS (builtin_type->builtin_int8) |=
3818 TYPE_INSTANCE_FLAG_NOTTEXT;
3819 TYPE_INSTANCE_FLAGS (builtin_type->builtin_uint8) |=
3820 TYPE_INSTANCE_FLAG_NOTTEXT;
3821
3822 /* Wide character types. */
3823 builtin_type->builtin_char16
3824 = arch_integer_type (gdbarch, 16, 0, "char16_t");
3825 builtin_type->builtin_char32
3826 = arch_integer_type (gdbarch, 32, 0, "char32_t");
3827
3828
3829 /* Default data/code pointer types. */
3830 builtin_type->builtin_data_ptr
3831 = lookup_pointer_type (builtin_type->builtin_void);
3832 builtin_type->builtin_func_ptr
3833 = lookup_pointer_type (lookup_function_type (builtin_type->builtin_void));
3834 builtin_type->builtin_func_func
3835 = lookup_function_type (builtin_type->builtin_func_ptr);
3836
3837 /* This type represents a GDB internal function. */
3838 builtin_type->internal_fn
3839 = arch_type (gdbarch, TYPE_CODE_INTERNAL_FUNCTION, 0,
3840 "<internal function>");
3841
3842 return builtin_type;
3843 }
3844
3845
3846 /* This set of objfile-based types is intended to be used by symbol
3847 readers as basic types. */
3848
3849 static const struct objfile_data *objfile_type_data;
3850
3851 const struct objfile_type *
3852 objfile_type (struct objfile *objfile)
3853 {
3854 struct gdbarch *gdbarch;
3855 struct objfile_type *objfile_type
3856 = objfile_data (objfile, objfile_type_data);
3857
3858 if (objfile_type)
3859 return objfile_type;
3860
3861 objfile_type = OBSTACK_CALLOC (&objfile->objfile_obstack,
3862 1, struct objfile_type);
3863
3864 /* Use the objfile architecture to determine basic type properties. */
3865 gdbarch = get_objfile_arch (objfile);
3866
3867 /* Basic types. */
3868 objfile_type->builtin_void
3869 = init_type (TYPE_CODE_VOID, 1,
3870 0,
3871 "void", objfile);
3872
3873 objfile_type->builtin_char
3874 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3875 (TYPE_FLAG_NOSIGN
3876 | (gdbarch_char_signed (gdbarch) ? 0 : TYPE_FLAG_UNSIGNED)),
3877 "char", objfile);
3878 objfile_type->builtin_signed_char
3879 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3880 0,
3881 "signed char", objfile);
3882 objfile_type->builtin_unsigned_char
3883 = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
3884 TYPE_FLAG_UNSIGNED,
3885 "unsigned char", objfile);
3886 objfile_type->builtin_short
3887 = init_type (TYPE_CODE_INT,
3888 gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT,
3889 0, "short", objfile);
3890 objfile_type->builtin_unsigned_short
3891 = init_type (TYPE_CODE_INT,
3892 gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT,
3893 TYPE_FLAG_UNSIGNED, "unsigned short", objfile);
3894 objfile_type->builtin_int
3895 = init_type (TYPE_CODE_INT,
3896 gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT,
3897 0, "int", objfile);
3898 objfile_type->builtin_unsigned_int
3899 = init_type (TYPE_CODE_INT,
3900 gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT,
3901 TYPE_FLAG_UNSIGNED, "unsigned int", objfile);
3902 objfile_type->builtin_long
3903 = init_type (TYPE_CODE_INT,
3904 gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT,
3905 0, "long", objfile);
3906 objfile_type->builtin_unsigned_long
3907 = init_type (TYPE_CODE_INT,
3908 gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT,
3909 TYPE_FLAG_UNSIGNED, "unsigned long", objfile);
3910 objfile_type->builtin_long_long
3911 = init_type (TYPE_CODE_INT,
3912 gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT,
3913 0, "long long", objfile);
3914 objfile_type->builtin_unsigned_long_long
3915 = init_type (TYPE_CODE_INT,
3916 gdbarch_long_long_bit (gdbarch) / TARGET_CHAR_BIT,
3917 TYPE_FLAG_UNSIGNED, "unsigned long long", objfile);
3918
3919 objfile_type->builtin_float
3920 = init_type (TYPE_CODE_FLT,
3921 gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT,
3922 0, "float", objfile);
3923 TYPE_FLOATFORMAT (objfile_type->builtin_float)
3924 = gdbarch_float_format (gdbarch);
3925 objfile_type->builtin_double
3926 = init_type (TYPE_CODE_FLT,
3927 gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT,
3928 0, "double", objfile);
3929 TYPE_FLOATFORMAT (objfile_type->builtin_double)
3930 = gdbarch_double_format (gdbarch);
3931 objfile_type->builtin_long_double
3932 = init_type (TYPE_CODE_FLT,
3933 gdbarch_long_double_bit (gdbarch) / TARGET_CHAR_BIT,
3934 0, "long double", objfile);
3935 TYPE_FLOATFORMAT (objfile_type->builtin_long_double)
3936 = gdbarch_long_double_format (gdbarch);
3937
3938 /* This type represents a type that was unrecognized in symbol read-in. */
3939 objfile_type->builtin_error
3940 = init_type (TYPE_CODE_ERROR, 0, 0, "<unknown type>", objfile);
3941
3942 /* The following set of types is used for symbols with no
3943 debug information. */
3944 objfile_type->nodebug_text_symbol
3945 = init_type (TYPE_CODE_FUNC, 1, 0,
3946 "<text variable, no debug info>", objfile);
3947 TYPE_TARGET_TYPE (objfile_type->nodebug_text_symbol)
3948 = objfile_type->builtin_int;
3949 objfile_type->nodebug_text_gnu_ifunc_symbol
3950 = init_type (TYPE_CODE_FUNC, 1, TYPE_FLAG_GNU_IFUNC,
3951 "<text gnu-indirect-function variable, no debug info>",
3952 objfile);
3953 TYPE_TARGET_TYPE (objfile_type->nodebug_text_gnu_ifunc_symbol)
3954 = objfile_type->nodebug_text_symbol;
3955 objfile_type->nodebug_got_plt_symbol
3956 = init_type (TYPE_CODE_PTR, gdbarch_addr_bit (gdbarch) / 8, 0,
3957 "<text from jump slot in .got.plt, no debug info>",
3958 objfile);
3959 TYPE_TARGET_TYPE (objfile_type->nodebug_got_plt_symbol)
3960 = objfile_type->nodebug_text_symbol;
3961 objfile_type->nodebug_data_symbol
3962 = init_type (TYPE_CODE_INT,
3963 gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
3964 "<data variable, no debug info>", objfile);
3965 objfile_type->nodebug_unknown_symbol
3966 = init_type (TYPE_CODE_INT, 1, 0,
3967 "<variable (not text or data), no debug info>", objfile);
3968 objfile_type->nodebug_tls_symbol
3969 = init_type (TYPE_CODE_INT,
3970 gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
3971 "<thread local variable, no debug info>", objfile);
3972
3973 /* NOTE: on some targets, addresses and pointers are not necessarily
3974 the same --- for example, on the D10V, pointers are 16 bits long,
3975 but addresses are 32 bits long. See doc/gdbint.texinfo,
3976 ``Pointers Are Not Always Addresses''.
3977
3978 The upshot is:
3979 - gdb's `struct type' always describes the target's
3980 representation.
3981 - gdb's `struct value' objects should always hold values in
3982 target form.
3983 - gdb's CORE_ADDR values are addresses in the unified virtual
3984 address space that the assembler and linker work with. Thus,
3985 since target_read_memory takes a CORE_ADDR as an argument, it
3986 can access any memory on the target, even if the processor has
3987 separate code and data address spaces.
3988
3989 So, for example:
3990 - If v is a value holding a D10V code pointer, its contents are
3991 in target form: a big-endian address left-shifted two bits.
3992 - If p is a D10V pointer type, TYPE_LENGTH (p) == 2, just as
3993 sizeof (void *) == 2 on the target.
3994
3995 In this context, objfile_type->builtin_core_addr is a bit odd:
3996 it's a target type for a value the target will never see. It's
3997 only used to hold the values of (typeless) linker symbols, which
3998 are indeed in the unified virtual address space. */
3999
4000 objfile_type->builtin_core_addr
4001 = init_type (TYPE_CODE_INT,
4002 gdbarch_addr_bit (gdbarch) / 8,
4003 TYPE_FLAG_UNSIGNED, "__CORE_ADDR", objfile);
4004
4005 set_objfile_data (objfile, objfile_type_data, objfile_type);
4006 return objfile_type;
4007 }
4008
4009
4010 extern void _initialize_gdbtypes (void);
4011 void
4012 _initialize_gdbtypes (void)
4013 {
4014 gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init);
4015 objfile_type_data = register_objfile_data ();
4016
4017 add_setshow_zinteger_cmd ("overload", no_class, &overload_debug,
4018 _("Set debugging of C++ overloading."),
4019 _("Show debugging of C++ overloading."),
4020 _("When enabled, ranking of the "
4021 "functions is displayed."),
4022 NULL,
4023 show_overload_debug,
4024 &setdebuglist, &showdebuglist);
4025
4026 /* Add user knob for controlling resolution of opaque types. */
4027 add_setshow_boolean_cmd ("opaque-type-resolution", class_support,
4028 &opaque_type_resolution,
4029 _("Set resolution of opaque struct/class/union"
4030 " types (if set before loading symbols)."),
4031 _("Show resolution of opaque struct/class/union"
4032 " types (if set before loading symbols)."),
4033 NULL, NULL,
4034 show_opaque_type_resolution,
4035 &setlist, &showlist);
4036 }
This page took 0.23823 seconds and 4 git commands to generate.