GDB (API)
Loading...
Searching...
No Matches
/tmp/gdb-13.1/gdb/gdbtypes.h
Go to the documentation of this file.
1
2/* Internal type definitions for GDB.
3
4 Copyright (C) 1992-2023 Free Software Foundation, Inc.
5
6 Contributed by Cygnus Support, using pieces from other GDB modules.
7
8 This file is part of GDB.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22
23#if !defined (GDBTYPES_H)
24#define GDBTYPES_H 1
25
26/* * \page gdbtypes GDB Types
27
28 GDB represents all the different kinds of types in programming
29 languages using a common representation defined in gdbtypes.h.
30
31 The main data structure is main_type; it consists of a code (such
32 as #TYPE_CODE_ENUM for enumeration types), a number of
33 generally-useful fields such as the printable name, and finally a
34 field main_type::type_specific that is a union of info specific to
35 particular languages or other special cases (such as calling
36 convention).
37
38 The available type codes are defined in enum #type_code. The enum
39 includes codes both for types that are common across a variety
40 of languages, and for types that are language-specific.
41
42 Most accesses to type fields go through macros such as
43 #TYPE_CODE(thistype) and #TYPE_FN_FIELD_CONST(thisfn, n). These are
44 written such that they can be used as both rvalues and lvalues.
45 */
46
47#include "hashtab.h"
48#include "gdbsupport/array-view.h"
49#include "gdbsupport/gdb-hashtab.h"
50#include "gdbsupport/gdb_optional.h"
51#include "gdbsupport/offset-type.h"
52#include "gdbsupport/enum-flags.h"
53#include "gdbsupport/underlying.h"
54#include "gdbsupport/print-utils.h"
55#include "gdbsupport/function-view.h"
56#include "dwarf2.h"
57#include "gdbsupport/gdb_obstack.h"
58#include "gmp-utils.h"
59#include "frame-info.h"
60
61/* Forward declarations for prototypes. */
62struct field;
63struct block;
64struct value_print_options;
65struct language_defn;
66struct dwarf2_per_cu_data;
67struct dwarf2_per_objfile;
68
69/* These declarations are DWARF-specific as some of the gdbtypes.h data types
70 are already DWARF-specific. */
71
72/* * Offset relative to the start of its containing CU (compilation
73 unit). */
74DEFINE_OFFSET_TYPE (cu_offset, unsigned int);
75
76/* * Offset relative to the start of its .debug_info or .debug_types
77 section. */
78DEFINE_OFFSET_TYPE (sect_offset, uint64_t);
79
80static inline char *
81sect_offset_str (sect_offset offset)
82{
83 return hex_string (to_underlying (offset));
84}
85
86/* Some macros for char-based bitfields. */
87
88#define B_SET(a,x) ((a)[(x)>>3] |= (1 << ((x)&7)))
89#define B_CLR(a,x) ((a)[(x)>>3] &= ~(1 << ((x)&7)))
90#define B_TST(a,x) ((a)[(x)>>3] & (1 << ((x)&7)))
91#define B_TYPE unsigned char
92#define B_BYTES(x) ( 1 + ((x)>>3) )
93#define B_CLRALL(a,x) memset ((a), 0, B_BYTES(x))
94
95/* * Different kinds of data types are distinguished by the `code'
96 field. */
97
99 {
102#define OP(X) X,
103#include "type-codes.def"
104#undef OP
105
106 };
107
108/* * Some bits for the type's instance_flags word. See the macros
109 below for documentation on each bit. */
110
112{
123
125
126/* * Not textual. By default, GDB treats all single byte integers as
127 characters (or elements of strings) unless this flag is set. */
128
129#define TYPE_NOTTEXT(t) (((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_NOTTEXT)
130
131/* * Constant type. If this is set, the corresponding type has a
132 const modifier. */
133
134#define TYPE_CONST(t) ((((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_CONST) != 0)
135
136/* * Volatile type. If this is set, the corresponding type has a
137 volatile modifier. */
138
139#define TYPE_VOLATILE(t) \
140 ((((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_VOLATILE) != 0)
141
142/* * Restrict type. If this is set, the corresponding type has a
143 restrict modifier. */
144
145#define TYPE_RESTRICT(t) \
146 ((((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_RESTRICT) != 0)
147
148/* * Atomic type. If this is set, the corresponding type has an
149 _Atomic modifier. */
150
151#define TYPE_ATOMIC(t) \
152 ((((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_ATOMIC) != 0)
153
154/* * True if this type represents either an lvalue or lvalue reference type. */
155
156#define TYPE_IS_REFERENCE(t) \
157 ((t)->code () == TYPE_CODE_REF || (t)->code () == TYPE_CODE_RVALUE_REF)
158
159/* * True if this type is allocatable. */
160#define TYPE_IS_ALLOCATABLE(t) \
161 ((t)->dyn_prop (DYN_PROP_ALLOCATED) != NULL)
162
163/* * True if this type has variant parts. */
164#define TYPE_HAS_VARIANT_PARTS(t) \
165 ((t)->dyn_prop (DYN_PROP_VARIANT_PARTS) != nullptr)
166
167/* * True if this type has a dynamic length. */
168#define TYPE_HAS_DYNAMIC_LENGTH(t) \
169 ((t)->dyn_prop (DYN_PROP_BYTE_SIZE) != nullptr)
170
171/* * Instruction-space delimited type. This is for Harvard architectures
172 which have separate instruction and data address spaces (and perhaps
173 others).
174
175 GDB usually defines a flat address space that is a superset of the
176 architecture's two (or more) address spaces, but this is an extension
177 of the architecture's model.
178
179 If TYPE_INSTANCE_FLAG_CODE_SPACE is set, an object of the corresponding type
180 resides in instruction memory, even if its address (in the extended
181 flat address space) does not reflect this.
182
183 Similarly, if TYPE_INSTANCE_FLAG_DATA_SPACE is set, then an object of the
184 corresponding type resides in the data memory space, even if
185 this is not indicated by its (flat address space) address.
186
187 If neither flag is set, the default space for functions / methods
188 is instruction space, and for data objects is data memory. */
189
190#define TYPE_CODE_SPACE(t) \
191 ((((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_CODE_SPACE) != 0)
192
193#define TYPE_DATA_SPACE(t) \
194 ((((t)->instance_flags ()) & TYPE_INSTANCE_FLAG_DATA_SPACE) != 0)
195
196/* * Address class flags. Some environments provide for pointers
197 whose size is different from that of a normal pointer or address
198 types where the bits are interpreted differently than normal
199 addresses. The TYPE_INSTANCE_FLAG_ADDRESS_CLASS_n flags may be used in
200 target specific ways to represent these different types of address
201 classes. */
202
203#define TYPE_ADDRESS_CLASS_1(t) (((t)->instance_flags ()) \
204 & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1)
205#define TYPE_ADDRESS_CLASS_2(t) (((t)->instance_flags ()) \
206 & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_2)
207#define TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL \
208 (TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1 | TYPE_INSTANCE_FLAG_ADDRESS_CLASS_2)
209#define TYPE_ADDRESS_CLASS_ALL(t) (((t)->instance_flags ()) \
210 & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
211
212/* * Information about a single discriminant. */
213
215{
216 /* * The range of values for the variant. This is an inclusive
217 range. */
218 ULONGEST low, high;
219
220 /* * Return true if VALUE is contained in this range. IS_UNSIGNED
221 is true if this should be an unsigned comparison; false for
222 signed. */
223 bool contains (ULONGEST value, bool is_unsigned) const
224 {
225 if (is_unsigned)
226 return value >= low && value <= high;
227 LONGEST valuel = (LONGEST) value;
228 return valuel >= (LONGEST) low && valuel <= (LONGEST) high;
229 }
230};
231
232struct variant_part;
233
234/* * A single variant. A variant has a list of discriminant values.
235 When the discriminator matches one of these, the variant is
236 enabled. Each variant controls zero or more fields; and may also
237 control other variant parts as well. This struct corresponds to
238 DW_TAG_variant in DWARF. */
239
240struct variant : allocate_on_obstack
241{
242 /* * The discriminant ranges for this variant. */
243 gdb::array_view<discriminant_range> discriminants;
244
245 /* * The fields controlled by this variant. This is inclusive on
246 the low end and exclusive on the high end. A variant may not
247 control any fields, in which case the two values will be equal.
248 These are indexes into the type's array of fields. */
251
252 /* * Variant parts controlled by this variant. */
253 gdb::array_view<variant_part> parts;
254
255 /* * Return true if this is the default variant. The default
256 variant can be recognized because it has no associated
257 discriminants. */
258 bool is_default () const
259 {
260 return discriminants.empty ();
261 }
262
263 /* * Return true if this variant matches VALUE. IS_UNSIGNED is true
264 if this should be an unsigned comparison; false for signed. */
265 bool matches (ULONGEST value, bool is_unsigned) const;
266};
267
268/* * A variant part. Each variant part has an optional discriminant
269 and holds an array of variants. This struct corresponds to
270 DW_TAG_variant_part in DWARF. */
271
272struct variant_part : allocate_on_obstack
273{
274 /* * The index of the discriminant field in the outer type. This is
275 an index into the type's array of fields. If this is -1, there
276 is no discriminant, and only the default variant can be
277 considered to be selected. */
279
280 /* * True if this discriminant is unsigned; false if signed. This
281 comes from the type of the discriminant. */
283
284 /* * The variants that are controlled by this variant part. Note
285 that these will always be sorted by field number. */
286 gdb::array_view<variant> variants;
287};
288
289
291{
292 PROP_UNDEFINED, /* Not defined. */
293 PROP_CONST, /* Constant. */
294 PROP_ADDR_OFFSET, /* Address offset. */
295 PROP_LOCEXPR, /* Location expression. */
296 PROP_LOCLIST, /* Location list. */
297 PROP_VARIANT_PARTS, /* Variant parts. */
298 PROP_TYPE, /* Type. */
299 PROP_VARIABLE_NAME, /* Variable name. */
300};
301
303{
304 /* Storage for constant property. */
305
306 LONGEST const_val;
307
308 /* Storage for dynamic property. */
309
310 void *baton;
311
312 /* Storage of variant parts for a type. A type with variant parts
313 has all its fields "linearized" -- stored in a single field
314 array, just as if they had all been declared that way. The
315 variant parts are attached via a dynamic property, and then are
316 used to control which fields end up in the final type during
317 dynamic type resolution. */
318
319 const gdb::array_view<variant_part> *variant_parts;
320
321 /* Once a variant type is resolved, we may want to be able to go
322 from the resolved type to the original type. In this case we
323 rewrite the property's kind and set this field. */
324
326
327 /* Name of a variable to look up; the variable holds the value of
328 this property. */
329
330 const char *variable_name;
331};
332
333/* * Used to store a dynamic property. */
334
336{
338 {
339 return m_kind;
340 }
341
343 {
345 }
346
347 LONGEST const_val () const
348 {
349 gdb_assert (m_kind == PROP_CONST);
350
351 return m_data.const_val;
352 }
353
355 {
358 }
359
360 void *baton () const
361 {
362 gdb_assert (m_kind == PROP_LOCEXPR
363 || m_kind == PROP_LOCLIST
365
366 return m_data.baton;
367 }
368
369 void set_locexpr (void *baton)
370 {
373 }
374
375 void set_loclist (void *baton)
376 {
379 }
380
382 {
385 }
386
387 const gdb::array_view<variant_part> *variant_parts () const
388 {
389 gdb_assert (m_kind == PROP_VARIANT_PARTS);
390
391 return m_data.variant_parts;
392 }
393
394 void set_variant_parts (gdb::array_view<variant_part> *variant_parts)
395 {
398 }
399
400 struct type *original_type () const
401 {
402 gdb_assert (m_kind == PROP_TYPE);
403
404 return m_data.original_type;
405 }
406
408 {
411 }
412
413 /* Return the name of the variable that holds this property's value.
414 Only valid for PROP_VARIABLE_NAME. */
415 const char *variable_name () const
416 {
417 gdb_assert (m_kind == PROP_VARIABLE_NAME);
418 return m_data.variable_name;
419 }
420
421 /* Set the name of the variable that holds this property's value,
422 and set this property to be of kind PROP_VARIABLE_NAME. */
423 void set_variable_name (const char *name)
424 {
426 m_data.variable_name = name;
427 }
428
429 /* Determine which field of the union dynamic_prop.data is used. */
431
432 /* Storage for dynamic or static value. */
434};
435
436/* Compare two dynamic_prop objects for equality. dynamic_prop
437 instances are equal iff they have the same type and storage. */
438extern bool operator== (const dynamic_prop &l, const dynamic_prop &r);
439
440/* Compare two dynamic_prop objects for inequality. */
441static inline bool operator!= (const dynamic_prop &l, const dynamic_prop &r)
442{
443 return !(l == r);
444}
445
446/* * Define a type's dynamic property node kind. */
448{
449 /* A property providing a type's data location.
450 Evaluating this field yields to the location of an object's data. */
452
453 /* A property representing DW_AT_allocated. The presence of this attribute
454 indicates that the object of the type can be allocated/deallocated. */
456
457 /* A property representing DW_AT_associated. The presence of this attribute
458 indicated that the object of the type can be associated. */
460
461 /* A property providing an array's byte stride. */
463
464 /* A property holding variant parts. */
466
467 /* A property representing DW_AT_rank. The presence of this attribute
468 indicates that the object is of assumed rank array type. */
470
471 /* A property holding the size of the type. */
473};
474
475/* * List for dynamic type attributes. */
477{
478 /* The kind of dynamic prop in this node. */
480
481 /* The dynamic property itself. */
483
484 /* A pointer to the next dynamic property. */
486};
487
488/* * Determine which field of the union main_type.fields[x].loc is
489 used. */
490
492 {
498 };
499
500/* * A discriminant to determine which field in the
501 main_type.type_specific union is being used, if any.
502
503 For types such as TYPE_CODE_FLT, the use of this
504 discriminant is really redundant, as we know from the type code
505 which field is going to be used. As such, it would be possible to
506 reduce the size of this enum in order to save a bit or two for
507 other fields of struct main_type. But, since we still have extra
508 room , and for the sake of clarity and consistency, we treat all fields
509 of the union the same way. */
510
512{
517 /* Note: This is used by TYPE_CODE_FUNC and TYPE_CODE_METHOD. */
522};
523
525{
528};
529
531{
532 /* * Position of this field, counting in bits from start of
533 containing structure. For big-endian targets, it is the bit
534 offset to the MSB. For little-endian targets, it is the bit
535 offset to the LSB. */
536
537 LONGEST bitpos;
538
539 /* * Enum value. */
540 LONGEST enumval;
541
542 /* * For a static field, if TYPE_FIELD_STATIC_HAS_ADDR then
543 physaddr is the location (in the target) of the static
544 field. Otherwise, physname is the mangled label of the
545 static field. */
546
547 CORE_ADDR physaddr;
548 const char *physname;
549
550 /* * The field location can be computed by evaluating the
551 following DWARF block. Its DATA is allocated on
552 objfile_obstack - no CU load is needed to access it. */
553
554 struct dwarf2_locexpr_baton *dwarf_block;
555};
556
557struct field
558{
559 struct type *type () const
560 {
561 return this->m_type;
562 }
563
564 void set_type (struct type *type)
565 {
566 this->m_type = type;
567 }
568
569 const char *name () const
570 {
571 return m_name;
572 }
573
574 void set_name (const char *name)
575 {
576 m_name = name;
577 }
578
579 /* Location getters / setters. */
580
582 {
583 return m_loc_kind;
584 }
585
586 LONGEST loc_bitpos () const
587 {
588 gdb_assert (m_loc_kind == FIELD_LOC_KIND_BITPOS);
589 return m_loc.bitpos;
590 }
591
592 void set_loc_bitpos (LONGEST bitpos)
593 {
595 m_loc.bitpos = bitpos;
596 }
597
598 LONGEST loc_enumval () const
599 {
600 gdb_assert (m_loc_kind == FIELD_LOC_KIND_ENUMVAL);
601 return m_loc.enumval;
602 }
603
604 void set_loc_enumval (LONGEST enumval)
605 {
607 m_loc.enumval = enumval;
608 }
609
610 CORE_ADDR loc_physaddr () const
611 {
612 gdb_assert (m_loc_kind == FIELD_LOC_KIND_PHYSADDR);
613 return m_loc.physaddr;
614 }
615
616 void set_loc_physaddr (CORE_ADDR physaddr)
617 {
619 m_loc.physaddr = physaddr;
620 }
621
622 const char *loc_physname () const
623 {
624 gdb_assert (m_loc_kind == FIELD_LOC_KIND_PHYSNAME);
625 return m_loc.physname;
626 }
627
628 void set_loc_physname (const char *physname)
629 {
631 m_loc.physname = physname;
632 }
633
634 dwarf2_locexpr_baton *loc_dwarf_block () const
635 {
637 return m_loc.dwarf_block;
638 }
639
640 void set_loc_dwarf_block (dwarf2_locexpr_baton *dwarf_block)
641 {
643 m_loc.dwarf_block = dwarf_block;
644 }
645
647
648 /* * For a function or member type, this is 1 if the argument is
649 marked artificial. Artificial arguments should not be shown
650 to the user. For TYPE_CODE_RANGE it is set if the specific
651 bound is not defined. */
652
653 unsigned int artificial : 1;
654
655 /* * Discriminant for union field_location. */
656
657 ENUM_BITFIELD(field_loc_kind) m_loc_kind : 3;
658
659 /* * Size of this field, in bits, or zero if not packed.
660 If non-zero in an array type, indicates the element size in
661 bits (used only in Ada at the moment).
662 For an unpacked field, the field's type's length
663 says how many bytes the field occupies. */
664
665 unsigned int bitsize : 28;
666
667 /* * In a struct or union type, type of this field.
668 - In a function or member type, type of this argument.
669 - In an array type, the domain-type of the array. */
670
671 struct type *m_type;
672
673 /* * Name of field, value or argument.
674 NULL for range bounds, array domains, and member function
675 arguments. */
676
677 const char *m_name;
678};
679
681{
682 ULONGEST bit_stride () const
683 {
684 if (this->flag_is_byte_stride)
685 return this->stride.const_val () * 8;
686 else
687 return this->stride.const_val ();
688 }
689
690 /* * Low bound of range. */
691
693
694 /* * High bound of range. */
695
697
698 /* The stride value for this range. This can be stored in bits or bytes
699 based on the value of BYTE_STRIDE_P. It is optional to have a stride
700 value, if this range has no stride value defined then this will be set
701 to the constant zero. */
702
704
705 /* * The bias. Sometimes a range value is biased before storage.
706 The bias is added to the stored bits to form the true value. */
707
708 LONGEST bias;
709
710 /* True if HIGH range bound contains the number of elements in the
711 subrange. This affects how the final high bound is computed. */
712
714
715 /* True if LOW or/and HIGH are resolved into a static bound from
716 a dynamic one. */
717
718 unsigned int flag_bound_evaluated : 1;
719
720 /* If this is true this STRIDE is in bytes, otherwise STRIDE is in bits. */
721
722 unsigned int flag_is_byte_stride : 1;
723};
724
725/* Compare two range_bounds objects for equality. Simply does
726 memberwise comparison. */
727extern bool operator== (const range_bounds &l, const range_bounds &r);
728
729/* Compare two range_bounds objects for inequality. */
730static inline bool operator!= (const range_bounds &l, const range_bounds &r)
731{
732 return !(l == r);
733}
734
736{
737 /* * CPLUS_STUFF is for TYPE_CODE_STRUCT. It is initialized to
738 point to cplus_struct_default, a default static instance of a
739 struct cplus_struct_type. */
740
742
743 /* * GNAT_STUFF is for types for which the GNAT Ada compiler
744 provides additional information. */
745
747
748 /* * FLOATFORMAT is for TYPE_CODE_FLT. It is a pointer to a
749 floatformat object that describes the floating-point value
750 that resides within the type. */
751
753
754 /* * For TYPE_CODE_FUNC and TYPE_CODE_METHOD types. */
755
757
758 /* * For types that are pointer to member types (TYPE_CODE_METHODPTR,
759 TYPE_CODE_MEMBERPTR), SELF_TYPE is the type that this pointer
760 is a member of. */
761
763
764 /* * For TYPE_CODE_FIXED_POINT types, the info necessary to decode
765 values of that type. */
767
768 /* * An integer-like scalar type may be stored in just part of its
769 enclosing storage bytes. This structure describes this
770 situation. */
771 struct
772 {
773 /* * The bit size of the integer. This can be 0. For integers
774 that fill their storage (the ordinary case), this field holds
775 the byte size times 8. */
776 unsigned short bit_size;
777 /* * The bit offset of the integer. This is ordinarily 0, and can
778 only be non-zero if the bit size is less than the storage
779 size. */
780 unsigned short bit_offset;
782};
783
784/* * Main structure representing a type in GDB.
785
786 This structure is space-critical. Its layout has been tweaked to
787 reduce the space used. */
788
790{
791 /* * Code for kind of type. */
792
793 ENUM_BITFIELD(type_code) code : 8;
794
795 /* * Flags about this type. These fields appear at this location
796 because they packs nicely here. See the TYPE_* macros for
797 documentation about these fields. */
798
799 unsigned int m_flag_unsigned : 1;
800 unsigned int m_flag_nosign : 1;
801 unsigned int m_flag_stub : 1;
802 unsigned int m_flag_target_stub : 1;
803 unsigned int m_flag_prototyped : 1;
804 unsigned int m_flag_varargs : 1;
805 unsigned int m_flag_vector : 1;
806 unsigned int m_flag_stub_supported : 1;
807 unsigned int m_flag_gnu_ifunc : 1;
808 unsigned int m_flag_fixed_instance : 1;
809 unsigned int m_flag_objfile_owned : 1;
811
812 /* * True if this type was declared with "class" rather than
813 "struct". */
814
815 unsigned int m_flag_declared_class : 1;
816
817 /* * True if this is an enum type with disjoint values. This
818 affects how the enum is printed. */
819
820 unsigned int m_flag_flag_enum : 1;
821
822 /* * For TYPE_CODE_ARRAY, this is true if this type is part of a
823 multi-dimensional array. Multi-dimensional arrays are
824 represented internally as arrays of arrays, and this flag lets
825 gdb distinguish between multiple dimensions and an ordinary array
826 of arrays. The flag is set on each inner dimension, but not the
827 outermost dimension. */
828
829 unsigned int m_multi_dimensional : 1;
830
831 /* * A discriminant telling us which field of the type_specific
832 union is being used for this type, if any. */
833
835
836 /* * Number of fields described for this type. This field appears
837 at this location because it packs nicely here. */
838
839 short nfields;
840
841 /* * Name of this type, or NULL if none.
842
843 This is used for printing only. For looking up a name, look for
844 a symbol in the VAR_DOMAIN. This is generally allocated in the
845 objfile's obstack. However coffread.c uses malloc. */
846
847 const char *name;
848
849 /* * Every type is now associated with a particular objfile, and the
850 type is allocated on the objfile_obstack for that objfile. One
851 problem however, is that there are times when gdb allocates new
852 types while it is not in the process of reading symbols from a
853 particular objfile. Fortunately, these happen when the type
854 being created is a derived type of an existing type, such as in
855 lookup_pointer_type(). So we can just allocate the new type
856 using the same objfile as the existing type, but to do this we
857 need a backpointer to the objfile from the existing type. Yes
858 this is somewhat ugly, but without major overhaul of the internal
859 type system, it can't be avoided for now. */
860
862
863 /* * For a pointer type, describes the type of object pointed to.
864 - For an array type, describes the type of the elements.
865 - For a function or method type, describes the type of the return value.
866 - For a range type, describes the type of the full range.
867 - For a complex type, describes the type of each coordinate.
868 - For a special record or union type encoding a dynamic-sized type
869 in GNAT, a memoized pointer to a corresponding static version of
870 the type.
871 - Unused otherwise. */
872
874
875 /* * For structure and union types, a description of each field.
876 For set and pascal array types, there is one "field",
877 whose type is the domain type of the set or array.
878 For range types, there are two "fields",
879 the minimum and maximum values (both inclusive).
880 For enum types, each possible value is described by one "field".
881 For a function or method type, a "field" for each parameter.
882 For C++ classes, there is one field for each base class (if it is
883 a derived class) plus one field for each class data member. Member
884 functions are recorded elsewhere.
885
886 Using a pointer to a separate array of fields
887 allows all types to have the same size, which is useful
888 because we can allocate the space for a type before
889 we know what to put in it. */
890
891 union
892 {
893 struct field *fields;
894
895 /* * Union member used for range types. */
896
898
899 /* If this is a scalar type, then this is its corresponding
900 complex type. */
902
904
905 /* * Slot to point to additional language-specific fields of this
906 type. */
907
909
910 /* * Contains all dynamic type properties. */
912};
913
914/* * Number of bits allocated for alignment. */
915
916#define TYPE_ALIGN_BITS 8
917
918/* * A ``struct type'' describes a particular instance of a type, with
919 some particular qualification. */
920
921struct type
922{
923 /* Get the type code of this type.
924
925 Note that the code can be TYPE_CODE_TYPEDEF, so if you want the real
926 type, you need to do `check_typedef (type)->code ()`. */
928 {
929 return this->main_type->code;
930 }
931
932 /* Set the type code of this type. */
934 {
935 this->main_type->code = code;
936 }
937
938 /* Get the name of this type. */
939 const char *name () const
940 {
941 return this->main_type->name;
942 }
943
944 /* Set the name of this type. */
945 void set_name (const char *name)
946 {
947 this->main_type->name = name;
948 }
949
950 /* Note that if thistype is a TYPEDEF type, you have to call check_typedef.
951 But check_typedef does set the TYPE_LENGTH of the TYPEDEF type,
952 so you only have to call check_typedef once. Since allocate_value
953 calls check_typedef, VALUE_TYPE (X)->length () is safe. */
954 ULONGEST length () const
955 {
956 return this->m_length;
957 }
958
959 void set_length (ULONGEST length)
960 {
961 this->m_length = length;
962 }
963
964 /* Get the number of fields of this type. */
965 int num_fields () const
966 {
967 return this->main_type->nfields;
968 }
969
970 /* Set the number of fields of this type. */
972 {
974 }
975
976 /* Get the fields array of this type. */
977 struct field *fields () const
978 {
979 return this->main_type->flds_bnds.fields;
980 }
981
982 /* Get the field at index IDX. */
983 struct field &field (int idx) const
984 {
985 gdb_assert (idx >= 0 && idx < num_fields ());
986 return this->fields ()[idx];
987 }
988
989 /* Set the fields array of this type. */
990 void set_fields (struct field *fields)
991 {
993 }
994
995 type *index_type () const
996 {
997 return this->field (0).type ();
998 }
999
1000 struct type *target_type () const
1001 {
1002 return this->main_type->m_target_type;
1003 }
1004
1006 {
1008 }
1009
1011 {
1012 this->field (0).set_type (index_type);
1013 }
1014
1015 /* Return the instance flags converted to the correct type. */
1016 const type_instance_flags instance_flags () const
1017 {
1018 return (enum type_instance_flag_value) this->m_instance_flags;
1019 }
1020
1021 /* Set the instance flags. */
1022 void set_instance_flags (type_instance_flags flags)
1023 {
1024 this->m_instance_flags = flags;
1025 }
1026
1027 /* Get the bounds bounds of this type. The type must be a range type. */
1029 {
1030 switch (this->code ())
1031 {
1032 case TYPE_CODE_RANGE:
1033 return this->main_type->flds_bnds.bounds;
1034
1035 case TYPE_CODE_ARRAY:
1036 case TYPE_CODE_STRING:
1037 return this->index_type ()->bounds ();
1038
1039 default:
1040 gdb_assert_not_reached
1041 ("type::bounds called on type with invalid code");
1042 }
1043 }
1044
1045 /* Set the bounds of this type. The type must be a range type. */
1047 {
1048 gdb_assert (this->code () == TYPE_CODE_RANGE);
1049
1051 }
1052
1053 ULONGEST bit_stride () const
1054 {
1055 if (this->code () == TYPE_CODE_ARRAY && this->field (0).bitsize != 0)
1056 return this->field (0).bitsize;
1057 return this->bounds ()->bit_stride ();
1058 }
1059
1060 /* Unsigned integer type. If this is not set for a TYPE_CODE_INT,
1061 the type is signed (unless TYPE_NOSIGN is set). */
1062
1063 bool is_unsigned () const
1064 {
1065 return this->main_type->m_flag_unsigned;
1066 }
1067
1069 {
1071 }
1072
1073 /* No sign for this type. In C++, "char", "signed char", and
1074 "unsigned char" are distinct types; so we need an extra flag to
1075 indicate the absence of a sign! */
1076
1077 bool has_no_signedness () const
1078 {
1079 return this->main_type->m_flag_nosign;
1080 }
1081
1083 {
1085 }
1086
1087 /* This appears in a type's flags word if it is a stub type (e.g.,
1088 if someone referenced a type that wasn't defined in a source file
1089 via (struct sir_not_appearing_in_this_film *)). */
1090
1091 bool is_stub () const
1092 {
1093 return this->main_type->m_flag_stub;
1094 }
1095
1097 {
1098 this->main_type->m_flag_stub = is_stub;
1099 }
1100
1101 /* The target type of this type is a stub type, and this type needs
1102 to be updated if it gets un-stubbed in check_typedef. Used for
1103 arrays and ranges, in which TYPE_LENGTH of the array/range gets set
1104 based on the TYPE_LENGTH of the target type. Also, set for
1105 TYPE_CODE_TYPEDEF. */
1106
1107 bool target_is_stub () const
1108 {
1109 return this->main_type->m_flag_target_stub;
1110 }
1111
1113 {
1115 }
1116
1117 /* This is a function type which appears to have a prototype. We
1118 need this for function calls in order to tell us if it's necessary
1119 to coerce the args, or to just do the standard conversions. This
1120 is used with a short field. */
1121
1122 bool is_prototyped () const
1123 {
1124 return this->main_type->m_flag_prototyped;
1125 }
1126
1128 {
1130 }
1131
1132 /* FIXME drow/2002-06-03: Only used for methods, but applies as well
1133 to functions. */
1134
1135 bool has_varargs () const
1136 {
1137 return this->main_type->m_flag_varargs;
1138 }
1139
1141 {
1143 }
1144
1145 /* Identify a vector type. Gcc is handling this by adding an extra
1146 attribute to the array type. We slurp that in as a new flag of a
1147 type. This is used only in dwarf2read.c. */
1148
1149 bool is_vector () const
1150 {
1151 return this->main_type->m_flag_vector;
1152 }
1153
1155 {
1157 }
1158
1159 /* This debug target supports TYPE_STUB(t). In the unsupported case
1160 we have to rely on NFIELDS to be zero etc., see TYPE_IS_OPAQUE().
1161 TYPE_STUB(t) with !TYPE_STUB_SUPPORTED(t) may exist if we only
1162 guessed the TYPE_STUB(t) value (see dwarfread.c). */
1163
1164 bool stub_is_supported () const
1165 {
1166 return this->main_type->m_flag_stub_supported;
1167 }
1168
1170 {
1172 }
1173
1174 /* Used only for TYPE_CODE_FUNC where it specifies the real function
1175 address is returned by this function call. The target_type method
1176 determines the final returned function type to be presented to
1177 user. */
1178
1179 bool is_gnu_ifunc () const
1180 {
1181 return this->main_type->m_flag_gnu_ifunc;
1182 }
1183
1185 {
1187 }
1188
1189 /* The debugging formats (especially STABS) do not contain enough
1190 information to represent all Ada types---especially those whose
1191 size depends on dynamic quantities. Therefore, the GNAT Ada
1192 compiler includes extra information in the form of additional type
1193 definitions connected by naming conventions. This flag indicates
1194 that the type is an ordinary (unencoded) GDB type that has been
1195 created from the necessary run-time information, and does not need
1196 further interpretation. Optionally marks ordinary, fixed-size GDB
1197 type. */
1198
1199 bool is_fixed_instance () const
1200 {
1201 return this->main_type->m_flag_fixed_instance;
1202 }
1203
1205 {
1207 }
1208
1209 /* A compiler may supply dwarf instrumentation that indicates the desired
1210 endian interpretation of the variable differs from the native endian
1211 representation. */
1212
1214 {
1216 }
1217
1219 {
1221 }
1222
1223
1224 /* True if this type was declared using the "class" keyword. This is
1225 only valid for C++ structure and enum types. If false, a structure
1226 was declared as a "struct"; if true it was declared "class". For
1227 enum types, this is true when "enum class" or "enum struct" was
1228 used to declare the type. */
1229
1230 bool is_declared_class () const
1231 {
1232 return this->main_type->m_flag_declared_class;
1233 }
1234
1236 {
1238 }
1239
1240 /* True if this type is a "flag" enum. A flag enum is one where all
1241 the values are pairwise disjoint when "and"ed together. This
1242 affects how enum values are printed. */
1243
1244 bool is_flag_enum () const
1245 {
1246 return this->main_type->m_flag_flag_enum;
1247 }
1248
1250 {
1252 }
1253
1254 /* True if this array type is part of a multi-dimensional array. */
1255
1257 {
1258 return this->main_type->m_multi_dimensional;
1259 }
1260
1262 {
1263 this->main_type->m_multi_dimensional = value;
1264 }
1265
1266 /* * Assuming that THIS is a TYPE_CODE_FIXED_POINT, return a reference
1267 to this type's fixed_point_info. */
1268
1270 {
1271 gdb_assert (this->code () == TYPE_CODE_FIXED_POINT);
1272 gdb_assert (this->main_type->type_specific.fixed_point_info != nullptr);
1273
1275 }
1276
1277 /* * Assuming that THIS is a TYPE_CODE_FIXED_POINT, set this type's
1278 fixed_point_info to INFO. */
1279
1281 {
1282 gdb_assert (this->code () == TYPE_CODE_FIXED_POINT);
1283
1285 }
1286
1287 /* * Assuming that THIS is a TYPE_CODE_FIXED_POINT, return its base type.
1288
1289 In other words, this returns the type after having peeled all
1290 intermediate type layers (such as TYPE_CODE_RANGE, for instance).
1291 The TYPE_CODE of the type returned is guaranteed to be
1292 a TYPE_CODE_FIXED_POINT. */
1293
1295
1296 /* * Assuming that THIS is a TYPE_CODE_FIXED_POINT, return its scaling
1297 factor. */
1298
1300
1301 /* * Return the dynamic property of the requested KIND from this type's
1302 list of dynamic properties. */
1304
1305 /* * Given a dynamic property PROP of a given KIND, add this dynamic
1306 property to this type.
1307
1308 This function assumes that this type is objfile-owned. */
1310
1311 /* * Remove dynamic property of kind KIND from this type, if it exists. */
1313
1314 /* Return true if this type is owned by an objfile. Return false if it is
1315 owned by an architecture. */
1316 bool is_objfile_owned () const
1317 {
1318 return this->main_type->m_flag_objfile_owned;
1319 }
1320
1321 /* Set the owner of the type to be OBJFILE. */
1322 void set_owner (objfile *objfile)
1323 {
1324 gdb_assert (objfile != nullptr);
1325
1326 this->main_type->m_owner.objfile = objfile;
1327 this->main_type->m_flag_objfile_owned = true;
1328 }
1329
1330 /* Set the owner of the type to be ARCH. */
1331 void set_owner (gdbarch *arch)
1332 {
1333 gdb_assert (arch != nullptr);
1334
1335 this->main_type->m_owner.gdbarch = arch;
1336 this->main_type->m_flag_objfile_owned = false;
1337 }
1338
1339 /* Return the objfile owner of this type.
1340
1341 Return nullptr if this type is not objfile-owned. */
1342 struct objfile *objfile_owner () const
1343 {
1344 if (!this->is_objfile_owned ())
1345 return nullptr;
1346
1347 return this->main_type->m_owner.objfile;
1348 }
1349
1350 /* Return the gdbarch owner of this type.
1351
1352 Return nullptr if this type is not gdbarch-owned. */
1353 gdbarch *arch_owner () const
1354 {
1355 if (this->is_objfile_owned ())
1356 return nullptr;
1357
1358 return this->main_type->m_owner.gdbarch;
1359 }
1360
1361 /* Return the type's architecture. For types owned by an
1362 architecture, that architecture is returned. For types owned by an
1363 objfile, that objfile's architecture is returned.
1364
1365 The return value is always non-nullptr. */
1366 gdbarch *arch () const;
1367
1368 /* * Return true if this is an integer type whose logical (bit) size
1369 differs from its storage size; false otherwise. Always return
1370 false for non-integer (i.e., non-TYPE_SPECIFIC_INT) types. */
1372 {
1375 }
1376
1377 /* * Return the logical (bit) size for this integer type. Only
1378 valid for integer (TYPE_SPECIFIC_INT) types. */
1379 unsigned short bit_size () const
1380 {
1383 }
1384
1385 /* * Return the bit offset for this integer type. Only valid for
1386 integer (TYPE_SPECIFIC_INT) types. */
1387 unsigned short bit_offset () const
1388 {
1391 }
1392
1393 /* Return true if this is a pointer or reference type. */
1395 {
1396 return this->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (this);
1397 }
1398
1399 /* * Type that is a pointer to this type.
1400 NULL if no such pointer-to type is known yet.
1401 The debugger may add the address of such a type
1402 if it has to construct one later. */
1403
1405
1406 /* * C++: also need a reference type. */
1407
1409
1410 /* * A C++ rvalue reference type added in C++11. */
1411
1413
1414 /* * Variant chain. This points to a type that differs from this
1415 one only in qualifiers and length. Currently, the possible
1416 qualifiers are const, volatile, code-space, data-space, and
1417 address class. The length may differ only when one of the
1418 address class flags are set. The variants are linked in a
1419 circular ring and share MAIN_TYPE. */
1420
1421 struct type *chain;
1422
1423 /* * The alignment for this type. Zero means that the alignment was
1424 not specified in the debug info. Note that this is stored in a
1425 funny way: as the log base 2 (plus 1) of the alignment; so a
1426 value of 1 means the alignment is 1, and a value of 9 means the
1427 alignment is 256. */
1428
1430
1431 /* * Flags specific to this instance of the type, indicating where
1432 on the ring we are.
1433
1434 For TYPE_CODE_TYPEDEF the flags of the typedef type should be
1435 binary or-ed with the target type, with a special case for
1436 address class and space class. For example if this typedef does
1437 not specify any new qualifiers, TYPE_INSTANCE_FLAGS is 0 and the
1438 instance flags are completely inherited from the target type. No
1439 qualifiers can be cleared by the typedef. See also
1440 check_typedef. */
1441 unsigned m_instance_flags : 9;
1442
1443 /* * Length of storage for a value of this type. The value is the
1444 expression in host bytes of what sizeof(type) would return. This
1445 size includes padding. For example, an i386 extended-precision
1446 floating point value really only occupies ten bytes, but most
1447 ABI's declare its size to be 12 bytes, to preserve alignment.
1448 A `struct type' representing such a floating-point type would
1449 have a `length' value of 12, even though the last two bytes are
1450 unused.
1451
1452 Since this field is expressed in host bytes, its value is appropriate
1453 to pass to memcpy and such (it is assumed that GDB itself always runs
1454 on an 8-bits addressable architecture). However, when using it for
1455 target address arithmetic (e.g. adding it to a target address), the
1456 type_length_units function should be used in order to get the length
1457 expressed in target addressable memory units. */
1458
1459 ULONGEST m_length;
1460
1461 /* * Core type, shared by a group of qualified types. */
1462
1464};
1465
1467{
1468
1469 /* * The overloaded name.
1470 This is generally allocated in the objfile's obstack.
1471 However stabsread.c sometimes uses malloc. */
1472
1473 const char *name;
1474
1475 /* * The number of methods with this name. */
1476
1478
1479 /* * The list of methods. */
1480
1482};
1483
1484
1485
1487{
1488 /* * If is_stub is clear, this is the mangled name which we can look
1489 up to find the address of the method (FIXME: it would be cleaner
1490 to have a pointer to the struct symbol here instead).
1491
1492 If is_stub is set, this is the portion of the mangled name which
1493 specifies the arguments. For example, "ii", if there are two int
1494 arguments, or "" if there are no arguments. See gdb_mangle_name
1495 for the conversion from this format to the one used if is_stub is
1496 clear. */
1497
1498 const char *physname;
1499
1500 /* * The function type for the method.
1501
1502 (This comment used to say "The return value of the method", but
1503 that's wrong. The function type is expected here, i.e. something
1504 with TYPE_CODE_METHOD, and *not* the return-value type). */
1505
1506 struct type *type;
1507
1508 /* * For virtual functions. First baseclass that defines this
1509 virtual function. */
1510
1512
1513 /* Attributes. */
1514
1515 unsigned int is_const:1;
1516 unsigned int is_volatile:1;
1517 unsigned int is_private:1;
1518 unsigned int is_protected:1;
1519 unsigned int is_artificial:1;
1520
1521 /* * A stub method only has some fields valid (but they are enough
1522 to reconstruct the rest of the fields). */
1523
1524 unsigned int is_stub:1;
1525
1526 /* * True if this function is a constructor, false otherwise. */
1527
1528 unsigned int is_constructor : 1;
1529
1530 /* * True if this function is deleted, false otherwise. */
1531
1532 unsigned int is_deleted : 1;
1533
1534 /* * DW_AT_defaulted attribute for this function. The value is one
1535 of the DW_DEFAULTED constants. */
1536
1537 ENUM_BITFIELD (dwarf_defaulted_attribute) defaulted : 2;
1538
1539 /* * Unused. */
1540
1541 unsigned int dummy:6;
1542
1543 /* * Index into that baseclass's virtual function table, minus 2;
1544 else if static: VOFFSET_STATIC; else: 0. */
1545
1546 unsigned int voffset:16;
1547
1548#define VOFFSET_STATIC 1
1549
1550};
1551
1553{
1554 /* * Unqualified name to be prefixed by owning class qualified
1555 name. */
1556
1557 const char *name;
1558
1559 /* * Type this typedef named NAME represents. */
1560
1561 struct type *type;
1562
1563 /* * True if this field was declared protected, false otherwise. */
1564 unsigned int is_protected : 1;
1565
1566 /* * True if this field was declared private, false otherwise. */
1567 unsigned int is_private : 1;
1568};
1569
1570/* * C++ language-specific information for TYPE_CODE_STRUCT and
1571 TYPE_CODE_UNION nodes. */
1572
1574 {
1575 /* * Number of base classes this type derives from. The
1576 baseclasses are stored in the first N_BASECLASSES fields
1577 (i.e. the `fields' field of the struct type). The only fields
1578 of struct field that are used are: type, name, loc.bitpos. */
1579
1581
1582 /* * Field number of the virtual function table pointer in VPTR_BASETYPE.
1583 All access to this field must be through TYPE_VPTR_FIELDNO as one
1584 thing it does is check whether the field has been initialized.
1585 Initially TYPE_RAW_CPLUS_SPECIFIC has the value of cplus_struct_default,
1586 which for portability reasons doesn't initialize this field.
1587 TYPE_VPTR_FIELDNO returns -1 for this case.
1588
1589 If -1, we were unable to find the virtual function table pointer in
1590 initial symbol reading, and get_vptr_fieldno should be called to find
1591 it if possible. get_vptr_fieldno will update this field if possible.
1592 Otherwise the value is left at -1.
1593
1594 Unused if this type does not have virtual functions. */
1595
1597
1598 /* * Number of methods with unique names. All overloaded methods
1599 with the same name count only once. */
1600
1602
1603 /* * Number of template arguments. */
1604
1605 unsigned short n_template_arguments;
1606
1607 /* * One if this struct is a dynamic class, as defined by the
1608 Itanium C++ ABI: if it requires a virtual table pointer,
1609 because it or any of its base classes have one or more virtual
1610 member functions or virtual base classes. Minus one if not
1611 dynamic. Zero if not yet computed. */
1612
1613 int is_dynamic : 2;
1614
1615 /* * The calling convention for this type, fetched from the
1616 DW_AT_calling_convention attribute. The value is one of the
1617 DW_CC constants. */
1618
1619 ENUM_BITFIELD (dwarf_calling_convention) calling_convention : 8;
1620
1621 /* * The base class which defined the virtual function table pointer. */
1622
1624
1625 /* * For derived classes, the number of base classes is given by
1626 n_baseclasses and virtual_field_bits is a bit vector containing
1627 one bit per base class. If the base class is virtual, the
1628 corresponding bit will be set.
1629 I.E, given:
1630
1631 class A{};
1632 class B{};
1633 class C : public B, public virtual A {};
1634
1635 B is a baseclass of C; A is a virtual baseclass for C.
1636 This is a C++ 2.0 language feature. */
1637
1639
1640 /* * For classes with private fields, the number of fields is
1641 given by nfields and private_field_bits is a bit vector
1642 containing one bit per field.
1643
1644 If the field is private, the corresponding bit will be set. */
1645
1647
1648 /* * For classes with protected fields, the number of fields is
1649 given by nfields and protected_field_bits is a bit vector
1650 containing one bit per field.
1651
1652 If the field is private, the corresponding bit will be set. */
1653
1655
1656 /* * For classes with fields to be ignored, either this is
1657 optimized out or this field has length 0. */
1658
1660
1661 /* * For classes, structures, and unions, a description of each
1662 field, which consists of an overloaded name, followed by the
1663 types of arguments that the method expects, and then the name
1664 after it has been renamed to make it distinct.
1665
1666 fn_fieldlists points to an array of nfn_fields of these. */
1667
1669
1670 /* * typedefs defined inside this class. typedef_field points to
1671 an array of typedef_field_count elements. */
1672
1674
1676
1677 /* * The nested types defined by this type. nested_types points to
1678 an array of nested_types_count elements. */
1679
1681
1683
1684 /* * The template arguments. This is an array with
1685 N_TEMPLATE_ARGUMENTS elements. This is NULL for non-template
1686 classes. */
1687
1688 struct symbol **template_arguments;
1689 };
1690
1691/* * Struct used to store conversion rankings. */
1692
1693struct rank
1694 {
1695 short rank;
1696
1697 /* * When two conversions are of the same type and therefore have
1698 the same rank, subrank is used to differentiate the two.
1699
1700 Eg: Two derived-class-pointer to base-class-pointer conversions
1701 would both have base pointer conversion rank, but the
1702 conversion with the shorter distance to the ancestor is
1703 preferable. 'subrank' would be used to reflect that. */
1704
1705 short subrank;
1706 };
1707
1708/* * Used for ranking a function for overload resolution. */
1709
1710typedef std::vector<rank> badness_vector;
1711
1712/* * GNAT Ada-specific information for various Ada types. */
1713
1715 {
1716 /* * Parallel type used to encode information about dynamic types
1717 used in Ada (such as variant records, variable-size array,
1718 etc). */
1720 };
1721
1722/* * For TYPE_CODE_FUNC and TYPE_CODE_METHOD types. */
1723
1725 {
1726 /* * The calling convention for targets supporting multiple ABIs.
1727 Right now this is only fetched from the Dwarf-2
1728 DW_AT_calling_convention attribute. The value is one of the
1729 DW_CC constants. */
1730
1731 ENUM_BITFIELD (dwarf_calling_convention) calling_convention : 8;
1732
1733 /* * Whether this function normally returns to its caller. It is
1734 set from the DW_AT_noreturn attribute if set on the
1735 DW_TAG_subprogram. */
1736
1737 unsigned int is_noreturn : 1;
1738
1739 /* * Only those DW_TAG_call_site's in this function that have
1740 DW_AT_call_tail_call set are linked in this list. Function
1741 without its tail call list complete
1742 (DW_AT_call_all_tail_calls or its superset
1743 DW_AT_call_all_calls) has TAIL_CALL_LIST NULL, even if some
1744 DW_TAG_call_site's exist in such function. */
1745
1747
1748 /* * For method types (TYPE_CODE_METHOD), the aggregate type that
1749 contains the method. */
1750
1752 };
1753
1754/* struct call_site_parameter can be referenced in callees by several ways. */
1755
1757{
1758 /* * Use field call_site_parameter.u.dwarf_reg. */
1760
1761 /* * Use field call_site_parameter.u.fb_offset. */
1763
1764 /* * Use field call_site_parameter.u.param_offset. */
1767
1769{
1770 /* The kind of location held by this call site target. */
1771 enum kind
1772 {
1773 /* An address. */
1775 /* A name. */
1777 /* A DWARF block. */
1779 /* An array of addresses. */
1781 };
1782
1784 {
1785 m_loc_kind = PHYSADDR;
1786 m_loc.physaddr = physaddr;
1787 }
1788
1789 void set_loc_physname (const char *physname)
1790 {
1791 m_loc_kind = PHYSNAME;
1792 m_loc.physname = physname;
1793 }
1794
1795 void set_loc_dwarf_block (dwarf2_locexpr_baton *dwarf_block)
1796 {
1797 m_loc_kind = DWARF_BLOCK;
1798 m_loc.dwarf_block = dwarf_block;
1799 }
1800
1801 void set_loc_array (unsigned length, const CORE_ADDR *data)
1802 {
1803 m_loc_kind = ADDRESSES;
1804 m_loc.addresses.length = length;
1805 m_loc.addresses.values = data;
1806 }
1807
1808 /* Callback type for iterate_over_addresses. */
1809
1810 using iterate_ftype = gdb::function_view<void (CORE_ADDR)>;
1811
1812 /* Call CALLBACK for each DW_TAG_call_site's DW_AT_call_target
1813 address. CALLER_FRAME (for registers) can be NULL if it is not
1814 known. This function always may throw NO_ENTRY_VALUE_ERROR. */
1815
1816 void iterate_over_addresses (struct gdbarch *call_site_gdbarch,
1817 const struct call_site *call_site,
1818 frame_info_ptr caller_frame,
1819 iterate_ftype callback) const;
1820
1821private:
1822
1823 union
1824 {
1825 /* Address. */
1826 CORE_ADDR physaddr;
1827 /* Mangled name. */
1828 const char *physname;
1829 /* DWARF block. */
1830 struct dwarf2_locexpr_baton *dwarf_block;
1831 /* Array of addresses. */
1832 struct
1833 {
1834 unsigned length;
1835 const CORE_ADDR *values;
1837 } m_loc;
1838
1839 /* * Discriminant for union field_location. */
1840 enum kind m_loc_kind;
1841};
1842
1844{
1845 /* * DW_TAG_formal_parameter's DW_AT_location's DW_OP_regX
1846 as DWARF register number, for register passed
1847 parameters. */
1848
1850
1851 /* * Offset from the callee's frame base, for stack passed
1852 parameters. This equals offset from the caller's stack
1853 pointer. */
1854
1855 CORE_ADDR fb_offset;
1856
1857 /* * Offset relative to the start of this PER_CU to
1858 DW_TAG_formal_parameter which is referenced by both
1859 caller and the callee. */
1860
1861 cu_offset param_cu_off;
1862};
1863
1865{
1866 ENUM_BITFIELD (call_site_parameter_kind) kind : 2;
1867
1869
1870 /* * DW_TAG_formal_parameter's DW_AT_call_value. It is never NULL. */
1871
1872 const gdb_byte *value;
1874
1875 /* * DW_TAG_formal_parameter's DW_AT_call_data_value.
1876 It may be NULL if not provided by DWARF. */
1877
1878 const gdb_byte *data_value;
1880};
1881
1882/* * A place where a function gets called from, represented by
1883 DW_TAG_call_site. It can be looked up from symtab->call_site_htab. */
1884
1886 {
1887 call_site (CORE_ADDR pc, dwarf2_per_cu_data *per_cu,
1888 dwarf2_per_objfile *per_objfile)
1889 : per_cu (per_cu), per_objfile (per_objfile), m_unrelocated_pc (pc)
1890 {}
1891
1892 static int
1893 eq (const call_site *a, const call_site *b)
1894 {
1895 return a->m_unrelocated_pc == b->m_unrelocated_pc;
1896 }
1897
1898 static hashval_t
1899 hash (const call_site *a)
1900 {
1901 return a->m_unrelocated_pc;
1902 }
1903
1904 static int
1905 eq (const void *a, const void *b)
1906 {
1907 return eq ((const call_site *)a, (const call_site *)b);
1908 }
1909
1910 static hashval_t
1911 hash (const void *a)
1912 {
1913 return hash ((const call_site *)a);
1914 }
1915
1916 /* Return the address of the first instruction after this call. */
1917
1918 CORE_ADDR pc () const;
1919
1920 /* Call CALLBACK for each target address. CALLER_FRAME (for
1921 registers) can be NULL if it is not known. This function may
1922 throw NO_ENTRY_VALUE_ERROR. */
1923
1924 void iterate_over_addresses (struct gdbarch *call_site_gdbarch,
1925 frame_info_ptr caller_frame,
1927 const
1928 {
1929 return target.iterate_over_addresses (call_site_gdbarch, this,
1930 caller_frame, callback);
1931 }
1932
1933 /* * List successor with head in FUNC_TYPE.TAIL_CALL_LIST. */
1934
1935 struct call_site *tail_call_next = nullptr;
1936
1937 /* * Describe DW_AT_call_target. Missing attribute uses
1938 FIELD_LOC_KIND_DWARF_BLOCK with FIELD_DWARF_BLOCK == NULL. */
1939
1941
1942 /* * Size of the PARAMETER array. */
1943
1944 unsigned parameter_count = 0;
1945
1946 /* * CU of the function where the call is located. It gets used
1947 for DWARF blocks execution in the parameter array below. */
1948
1949 dwarf2_per_cu_data *const per_cu = nullptr;
1950
1951 /* objfile of the function where the call is located. */
1952
1953 dwarf2_per_objfile *const per_objfile = nullptr;
1954
1955 private:
1956 /* Unrelocated address of the first instruction after this call. */
1957 const CORE_ADDR m_unrelocated_pc;
1958
1959 public:
1960 /* * Describe DW_TAG_call_site's DW_TAG_formal_parameter. */
1961
1963 };
1964
1965/* The type-specific info for TYPE_CODE_FIXED_POINT types. */
1966
1968{
1969 /* The fixed point type's scaling factor. */
1971};
1972
1973/* * The default value of TYPE_CPLUS_SPECIFIC(T) points to this shared
1974 static structure. */
1975
1976extern const struct cplus_struct_type cplus_struct_default;
1977
1978extern void allocate_cplus_struct_type (struct type *);
1979
1980#define INIT_CPLUS_SPECIFIC(type) \
1981 (TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_CPLUS_STUFF, \
1982 TYPE_RAW_CPLUS_SPECIFIC (type) = (struct cplus_struct_type*) \
1983 &cplus_struct_default)
1984
1985#define ALLOCATE_CPLUS_STRUCT_TYPE(type) allocate_cplus_struct_type (type)
1986
1987#define HAVE_CPLUS_STRUCT(type) \
1988 (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_CPLUS_STUFF \
1989 && TYPE_RAW_CPLUS_SPECIFIC (type) != &cplus_struct_default)
1990
1991#define INIT_NONE_SPECIFIC(type) \
1992 (TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_NONE, \
1993 TYPE_MAIN_TYPE (type)->type_specific = {})
1994
1995extern const struct gnat_aux_type gnat_aux_default;
1996
1997extern void allocate_gnat_aux_type (struct type *);
1998
1999#define INIT_GNAT_SPECIFIC(type) \
2000 (TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_GNAT_STUFF, \
2001 TYPE_GNAT_SPECIFIC (type) = (struct gnat_aux_type *) &gnat_aux_default)
2002#define ALLOCATE_GNAT_AUX_TYPE(type) allocate_gnat_aux_type (type)
2003/* * A macro that returns non-zero if the type-specific data should be
2004 read as "gnat-stuff". */
2005#define HAVE_GNAT_AUX_INFO(type) \
2006 (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_GNAT_STUFF)
2007
2008/* * True if TYPE is known to be an Ada type of some kind. */
2009#define ADA_TYPE_P(type) \
2010 (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_GNAT_STUFF \
2011 || (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_NONE \
2012 && (type)->is_fixed_instance ()))
2013
2014#define INIT_FUNC_SPECIFIC(type) \
2015 (TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FUNC, \
2016 TYPE_MAIN_TYPE (type)->type_specific.func_stuff = (struct func_type *) \
2017 TYPE_ZALLOC (type, \
2018 sizeof (*TYPE_MAIN_TYPE (type)->type_specific.func_stuff)))
2019
2020/* "struct fixed_point_type_info" has a field that has a destructor.
2021 See allocate_fixed_point_type_info to understand how this is
2022 handled. */
2023#define INIT_FIXED_POINT_SPECIFIC(type) \
2024 (TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FIXED_POINT, \
2025 allocate_fixed_point_type_info (type))
2026
2027#define TYPE_MAIN_TYPE(thistype) (thistype)->main_type
2028#define TYPE_POINTER_TYPE(thistype) (thistype)->pointer_type
2029#define TYPE_REFERENCE_TYPE(thistype) (thistype)->reference_type
2030#define TYPE_RVALUE_REFERENCE_TYPE(thistype) (thistype)->rvalue_reference_type
2031#define TYPE_CHAIN(thistype) (thistype)->chain
2032
2033/* * Return the alignment of the type in target addressable memory
2034 units, or 0 if no alignment was specified. */
2035#define TYPE_RAW_ALIGN(thistype) type_raw_align (thistype)
2036
2037/* * Return the alignment of the type in target addressable memory
2038 units, or 0 if no alignment was specified. */
2039extern unsigned type_raw_align (struct type *);
2040
2041/* * Return the alignment of the type in target addressable memory
2042 units. Return 0 if the alignment cannot be determined; but note
2043 that this makes an effort to compute the alignment even it it was
2044 not specified in the debug info. */
2045extern unsigned type_align (struct type *);
2046
2047/* * Set the alignment of the type. The alignment must be a power of
2048 2. Returns false if the given value does not fit in the available
2049 space in struct type. */
2050extern bool set_type_align (struct type *, ULONGEST);
2051
2052/* Property accessors for the type data location. */
2053#define TYPE_DATA_LOCATION(thistype) \
2054 ((thistype)->dyn_prop (DYN_PROP_DATA_LOCATION))
2055#define TYPE_DATA_LOCATION_BATON(thistype) \
2056 TYPE_DATA_LOCATION (thistype)->data.baton
2057#define TYPE_DATA_LOCATION_ADDR(thistype) \
2058 (TYPE_DATA_LOCATION (thistype)->const_val ())
2059#define TYPE_DATA_LOCATION_KIND(thistype) \
2060 (TYPE_DATA_LOCATION (thistype)->kind ())
2061#define TYPE_DYNAMIC_LENGTH(thistype) \
2062 ((thistype)->dyn_prop (DYN_PROP_BYTE_SIZE))
2063
2064/* Property accessors for the type allocated/associated. */
2065#define TYPE_ALLOCATED_PROP(thistype) \
2066 ((thistype)->dyn_prop (DYN_PROP_ALLOCATED))
2067#define TYPE_ASSOCIATED_PROP(thistype) \
2068 ((thistype)->dyn_prop (DYN_PROP_ASSOCIATED))
2069#define TYPE_RANK_PROP(thistype) \
2070 ((thistype)->dyn_prop (DYN_PROP_RANK))
2071
2072/* C++ */
2073
2074#define TYPE_SELF_TYPE(thistype) internal_type_self_type (thistype)
2075/* Do not call this, use TYPE_SELF_TYPE. */
2076extern struct type *internal_type_self_type (struct type *);
2077extern void set_type_self_type (struct type *, struct type *);
2078
2079extern int internal_type_vptr_fieldno (struct type *);
2080extern void set_type_vptr_fieldno (struct type *, int);
2081extern struct type *internal_type_vptr_basetype (struct type *);
2082extern void set_type_vptr_basetype (struct type *, struct type *);
2083#define TYPE_VPTR_FIELDNO(thistype) internal_type_vptr_fieldno (thistype)
2084#define TYPE_VPTR_BASETYPE(thistype) internal_type_vptr_basetype (thistype)
2085
2086#define TYPE_NFN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields
2087#define TYPE_SPECIFIC_FIELD(thistype) \
2088 TYPE_MAIN_TYPE(thistype)->type_specific_field
2089/* We need this tap-dance with the TYPE_RAW_SPECIFIC because of the case
2090 where we're trying to print an Ada array using the C language.
2091 In that case, there is no "cplus_stuff", but the C language assumes
2092 that there is. What we do, in that case, is pretend that there is
2093 an implicit one which is the default cplus stuff. */
2094#define TYPE_CPLUS_SPECIFIC(thistype) \
2095 (!HAVE_CPLUS_STRUCT(thistype) \
2096 ? (struct cplus_struct_type*)&cplus_struct_default \
2097 : TYPE_RAW_CPLUS_SPECIFIC(thistype))
2098#define TYPE_RAW_CPLUS_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff
2099#define TYPE_CPLUS_CALLING_CONVENTION(thistype) \
2100 TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff->calling_convention
2101#define TYPE_FLOATFORMAT(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.floatformat
2102#define TYPE_GNAT_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.gnat_stuff
2103#define TYPE_DESCRIPTIVE_TYPE(thistype) TYPE_GNAT_SPECIFIC(thistype)->descriptive_type
2104#define TYPE_CALLING_CONVENTION(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.func_stuff->calling_convention
2105#define TYPE_NO_RETURN(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.func_stuff->is_noreturn
2106#define TYPE_TAIL_CALL_LIST(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.func_stuff->tail_call_list
2107#define TYPE_BASECLASS(thistype,index) ((thistype)->field (index).type ())
2108#define TYPE_N_BASECLASSES(thistype) TYPE_CPLUS_SPECIFIC(thistype)->n_baseclasses
2109#define TYPE_BASECLASS_NAME(thistype,index) (thistype->field (index).name ())
2110#define TYPE_BASECLASS_BITPOS(thistype,index) (thistype->field (index).loc_bitpos ())
2111#define BASETYPE_VIA_PUBLIC(thistype, index) \
2112 ((!TYPE_FIELD_PRIVATE(thistype, index)) && (!TYPE_FIELD_PROTECTED(thistype, index)))
2113#define TYPE_CPLUS_DYNAMIC(thistype) TYPE_CPLUS_SPECIFIC (thistype)->is_dynamic
2114
2115#define BASETYPE_VIA_VIRTUAL(thistype, index) \
2116 (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits == NULL ? 0 \
2117 : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (index)))
2118
2119#define FIELD_ARTIFICIAL(thisfld) ((thisfld).artificial)
2120#define FIELD_BITSIZE(thisfld) ((thisfld).bitsize)
2121
2122#define TYPE_FIELD_ARTIFICIAL(thistype, n) FIELD_ARTIFICIAL((thistype)->field (n))
2123#define TYPE_FIELD_BITSIZE(thistype, n) FIELD_BITSIZE((thistype)->field (n))
2124#define TYPE_FIELD_PACKED(thistype, n) (FIELD_BITSIZE((thistype)->field (n))!=0)
2125
2126#define TYPE_FIELD_PRIVATE_BITS(thistype) \
2127 TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits
2128#define TYPE_FIELD_PROTECTED_BITS(thistype) \
2129 TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits
2130#define TYPE_FIELD_IGNORE_BITS(thistype) \
2131 TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits
2132#define TYPE_FIELD_VIRTUAL_BITS(thistype) \
2133 TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits
2134#define SET_TYPE_FIELD_PRIVATE(thistype, n) \
2135 B_SET (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n))
2136#define SET_TYPE_FIELD_PROTECTED(thistype, n) \
2137 B_SET (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n))
2138#define SET_TYPE_FIELD_IGNORE(thistype, n) \
2139 B_SET (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n))
2140#define SET_TYPE_FIELD_VIRTUAL(thistype, n) \
2141 B_SET (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n))
2142#define TYPE_FIELD_PRIVATE(thistype, n) \
2143 (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits == NULL ? 0 \
2144 : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n)))
2145#define TYPE_FIELD_PROTECTED(thistype, n) \
2146 (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits == NULL ? 0 \
2147 : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n)))
2148#define TYPE_FIELD_IGNORE(thistype, n) \
2149 (TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits == NULL ? 0 \
2150 : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->ignore_field_bits, (n)))
2151#define TYPE_FIELD_VIRTUAL(thistype, n) \
2152 (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits == NULL ? 0 \
2153 : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n)))
2154
2155#define TYPE_FN_FIELDLISTS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists
2156#define TYPE_FN_FIELDLIST(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n]
2157#define TYPE_FN_FIELDLIST1(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].fn_fields
2158#define TYPE_FN_FIELDLIST_NAME(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].name
2159#define TYPE_FN_FIELDLIST_LENGTH(thistype, n) TYPE_CPLUS_SPECIFIC(thistype)->fn_fieldlists[n].length
2160
2161#define TYPE_N_TEMPLATE_ARGUMENTS(thistype) \
2162 TYPE_CPLUS_SPECIFIC (thistype)->n_template_arguments
2163#define TYPE_TEMPLATE_ARGUMENTS(thistype) \
2164 TYPE_CPLUS_SPECIFIC (thistype)->template_arguments
2165#define TYPE_TEMPLATE_ARGUMENT(thistype, n) \
2166 TYPE_CPLUS_SPECIFIC (thistype)->template_arguments[n]
2167
2168#define TYPE_FN_FIELD(thisfn, n) (thisfn)[n]
2169#define TYPE_FN_FIELD_PHYSNAME(thisfn, n) (thisfn)[n].physname
2170#define TYPE_FN_FIELD_TYPE(thisfn, n) (thisfn)[n].type
2171#define TYPE_FN_FIELD_ARGS(thisfn, n) (((thisfn)[n].type)->fields ())
2172#define TYPE_FN_FIELD_CONST(thisfn, n) ((thisfn)[n].is_const)
2173#define TYPE_FN_FIELD_VOLATILE(thisfn, n) ((thisfn)[n].is_volatile)
2174#define TYPE_FN_FIELD_PRIVATE(thisfn, n) ((thisfn)[n].is_private)
2175#define TYPE_FN_FIELD_PROTECTED(thisfn, n) ((thisfn)[n].is_protected)
2176#define TYPE_FN_FIELD_ARTIFICIAL(thisfn, n) ((thisfn)[n].is_artificial)
2177#define TYPE_FN_FIELD_STUB(thisfn, n) ((thisfn)[n].is_stub)
2178#define TYPE_FN_FIELD_CONSTRUCTOR(thisfn, n) ((thisfn)[n].is_constructor)
2179#define TYPE_FN_FIELD_FCONTEXT(thisfn, n) ((thisfn)[n].fcontext)
2180#define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2)
2181#define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n) ((thisfn)[n].voffset > 1)
2182#define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC)
2183#define TYPE_FN_FIELD_DEFAULTED(thisfn, n) ((thisfn)[n].defaulted)
2184#define TYPE_FN_FIELD_DELETED(thisfn, n) ((thisfn)[n].is_deleted)
2185
2186/* Accessors for typedefs defined by a class. */
2187#define TYPE_TYPEDEF_FIELD_ARRAY(thistype) \
2188 TYPE_CPLUS_SPECIFIC (thistype)->typedef_field
2189#define TYPE_TYPEDEF_FIELD(thistype, n) \
2190 TYPE_CPLUS_SPECIFIC (thistype)->typedef_field[n]
2191#define TYPE_TYPEDEF_FIELD_NAME(thistype, n) \
2192 TYPE_TYPEDEF_FIELD (thistype, n).name
2193#define TYPE_TYPEDEF_FIELD_TYPE(thistype, n) \
2194 TYPE_TYPEDEF_FIELD (thistype, n).type
2195#define TYPE_TYPEDEF_FIELD_COUNT(thistype) \
2196 TYPE_CPLUS_SPECIFIC (thistype)->typedef_field_count
2197#define TYPE_TYPEDEF_FIELD_PROTECTED(thistype, n) \
2198 TYPE_TYPEDEF_FIELD (thistype, n).is_protected
2199#define TYPE_TYPEDEF_FIELD_PRIVATE(thistype, n) \
2200 TYPE_TYPEDEF_FIELD (thistype, n).is_private
2201
2202#define TYPE_NESTED_TYPES_ARRAY(thistype) \
2203 TYPE_CPLUS_SPECIFIC (thistype)->nested_types
2204#define TYPE_NESTED_TYPES_FIELD(thistype, n) \
2205 TYPE_CPLUS_SPECIFIC (thistype)->nested_types[n]
2206#define TYPE_NESTED_TYPES_FIELD_NAME(thistype, n) \
2207 TYPE_NESTED_TYPES_FIELD (thistype, n).name
2208#define TYPE_NESTED_TYPES_FIELD_TYPE(thistype, n) \
2209 TYPE_NESTED_TYPES_FIELD (thistype, n).type
2210#define TYPE_NESTED_TYPES_COUNT(thistype) \
2211 TYPE_CPLUS_SPECIFIC (thistype)->nested_types_count
2212#define TYPE_NESTED_TYPES_FIELD_PROTECTED(thistype, n) \
2213 TYPE_NESTED_TYPES_FIELD (thistype, n).is_protected
2214#define TYPE_NESTED_TYPES_FIELD_PRIVATE(thistype, n) \
2215 TYPE_NESTED_TYPES_FIELD (thistype, n).is_private
2216
2217#define TYPE_IS_OPAQUE(thistype) \
2218 ((((thistype)->code () == TYPE_CODE_STRUCT) \
2219 || ((thistype)->code () == TYPE_CODE_UNION)) \
2220 && ((thistype)->num_fields () == 0) \
2221 && (!HAVE_CPLUS_STRUCT (thistype) \
2222 || TYPE_NFN_FIELDS (thistype) == 0) \
2223 && ((thistype)->is_stub () || !(thistype)->stub_is_supported ()))
2224
2225/* * A helper macro that returns the name of a type or "unnamed type"
2226 if the type has no name. */
2227
2228#define TYPE_SAFE_NAME(type) \
2229 (type->name () != nullptr ? type->name () : _("<unnamed type>"))
2230
2231/* * A helper macro that returns the name of an error type. If the
2232 type has a name, it is used; otherwise, a default is used. */
2233
2234#define TYPE_ERROR_NAME(type) \
2235 (type->name () ? type->name () : _("<error type>"))
2236
2237/* Given TYPE, return its floatformat. */
2238const struct floatformat *floatformat_from_type (const struct type *type);
2239
2241{
2242 /* Integral types. */
2243
2244 /* Implicit size/sign (based on the architecture's ABI). */
2245 struct type *builtin_void = nullptr;
2246 struct type *builtin_char = nullptr;
2247 struct type *builtin_short = nullptr;
2248 struct type *builtin_int = nullptr;
2249 struct type *builtin_long = nullptr;
2250 struct type *builtin_signed_char = nullptr;
2251 struct type *builtin_unsigned_char = nullptr;
2252 struct type *builtin_unsigned_short = nullptr;
2253 struct type *builtin_unsigned_int = nullptr;
2254 struct type *builtin_unsigned_long = nullptr;
2255 struct type *builtin_bfloat16 = nullptr;
2256 struct type *builtin_half = nullptr;
2257 struct type *builtin_float = nullptr;
2258 struct type *builtin_double = nullptr;
2259 struct type *builtin_long_double = nullptr;
2260 struct type *builtin_complex = nullptr;
2261 struct type *builtin_double_complex = nullptr;
2262 struct type *builtin_string = nullptr;
2263 struct type *builtin_bool = nullptr;
2264 struct type *builtin_long_long = nullptr;
2266 struct type *builtin_decfloat = nullptr;
2267 struct type *builtin_decdouble = nullptr;
2268 struct type *builtin_declong = nullptr;
2269
2270 /* "True" character types.
2271 We use these for the '/c' print format, because c_char is just a
2272 one-byte integral type, which languages less laid back than C
2273 will print as ... well, a one-byte integral type. */
2274 struct type *builtin_true_char = nullptr;
2276
2277 /* Explicit sizes - see C9X <intypes.h> for naming scheme. The "int0"
2278 is for when an architecture needs to describe a register that has
2279 no size. */
2280 struct type *builtin_int0 = nullptr;
2281 struct type *builtin_int8 = nullptr;
2282 struct type *builtin_uint8 = nullptr;
2283 struct type *builtin_int16 = nullptr;
2284 struct type *builtin_uint16 = nullptr;
2285 struct type *builtin_int24 = nullptr;
2286 struct type *builtin_uint24 = nullptr;
2287 struct type *builtin_int32 = nullptr;
2288 struct type *builtin_uint32 = nullptr;
2289 struct type *builtin_int64 = nullptr;
2290 struct type *builtin_uint64 = nullptr;
2291 struct type *builtin_int128 = nullptr;
2292 struct type *builtin_uint128 = nullptr;
2293
2294 /* Wide character types. */
2295 struct type *builtin_char16 = nullptr;
2296 struct type *builtin_char32 = nullptr;
2297 struct type *builtin_wchar = nullptr;
2298
2299 /* Pointer types. */
2300
2301 /* * `pointer to data' type. Some target platforms use an implicitly
2302 {sign,zero} -extended 32-bit ABI pointer on a 64-bit ISA. */
2303 struct type *builtin_data_ptr = nullptr;
2304
2305 /* * `pointer to function (returning void)' type. Harvard
2306 architectures mean that ABI function and code pointers are not
2307 interconvertible. Similarly, since ANSI, C standards have
2308 explicitly said that pointers to functions and pointers to data
2309 are not interconvertible --- that is, you can't cast a function
2310 pointer to void * and back, and expect to get the same value.
2311 However, all function pointer types are interconvertible, so void
2312 (*) () can server as a generic function pointer. */
2313
2314 struct type *builtin_func_ptr = nullptr;
2315
2316 /* * `function returning pointer to function (returning void)' type.
2317 The final void return type is not significant for it. */
2318
2319 struct type *builtin_func_func = nullptr;
2320
2321 /* Special-purpose types. */
2322
2323 /* * This type is used to represent a GDB internal function. */
2324
2325 struct type *internal_fn = nullptr;
2326
2327 /* * This type is used to represent an xmethod. */
2328 struct type *xmethod = nullptr;
2329};
2330
2331/* * Return the type table for the specified architecture. */
2332
2333extern const struct builtin_type *builtin_type (struct gdbarch *gdbarch);
2334
2335/* * Per-objfile types used by symbol readers. */
2336
2338{
2339 /* Basic types based on the objfile architecture. */
2356
2357 /* * This type is used to represent symbol addresses. */
2359
2360 /* * This type represents a type that was unrecognized in symbol
2361 read-in. */
2363
2364 /* * Types used for symbols with no debug information. */
2371};
2372
2373/* * Return the type table for the specified objfile. */
2374
2375extern const struct objfile_type *objfile_type (struct objfile *objfile);
2376
2377/* Explicit floating-point formats. See "floatformat.h". */
2378extern const struct floatformat *floatformats_ieee_half[BFD_ENDIAN_UNKNOWN];
2379extern const struct floatformat *floatformats_ieee_single[BFD_ENDIAN_UNKNOWN];
2380extern const struct floatformat *floatformats_ieee_double[BFD_ENDIAN_UNKNOWN];
2381extern const struct floatformat *floatformats_ieee_quad[BFD_ENDIAN_UNKNOWN];
2382extern const struct floatformat *floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN];
2383extern const struct floatformat *floatformats_i387_ext[BFD_ENDIAN_UNKNOWN];
2384extern const struct floatformat *floatformats_m68881_ext[BFD_ENDIAN_UNKNOWN];
2385extern const struct floatformat *floatformats_arm_ext[BFD_ENDIAN_UNKNOWN];
2386extern const struct floatformat *floatformats_ia64_spill[BFD_ENDIAN_UNKNOWN];
2387extern const struct floatformat *floatformats_vax_f[BFD_ENDIAN_UNKNOWN];
2388extern const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN];
2389extern const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN];
2390extern const struct floatformat *floatformats_bfloat16[BFD_ENDIAN_UNKNOWN];
2391
2392/* Allocate space for storing data associated with a particular
2393 type. We ensure that the space is allocated using the same
2394 mechanism that was used to allocate the space for the type
2395 structure itself. I.e. if the type is on an objfile's
2396 objfile_obstack, then the space for data associated with that type
2397 will also be allocated on the objfile_obstack. If the type is
2398 associated with a gdbarch, then the space for data associated with that
2399 type will also be allocated on the gdbarch_obstack.
2400
2401 If a type is not associated with neither an objfile or a gdbarch then
2402 you should not use this macro to allocate space for data, instead you
2403 should call xmalloc directly, and ensure the memory is correctly freed
2404 when it is no longer needed. */
2405
2406#define TYPE_ALLOC(t,size) \
2407 (obstack_alloc (((t)->is_objfile_owned () \
2408 ? &((t)->objfile_owner ()->objfile_obstack) \
2409 : gdbarch_obstack ((t)->arch_owner ())), \
2410 size))
2411
2412
2413/* See comment on TYPE_ALLOC. */
2414
2415#define TYPE_ZALLOC(t,size) (memset (TYPE_ALLOC (t, size), 0, size))
2416
2417/* Use alloc_type to allocate a type owned by an objfile. Use
2418 alloc_type_arch to allocate a type owned by an architecture. Use
2419 alloc_type_copy to allocate a type with the same owner as a
2420 pre-existing template type, no matter whether objfile or
2421 gdbarch. */
2422extern struct type *alloc_type (struct objfile *);
2423extern struct type *alloc_type_arch (struct gdbarch *);
2424extern struct type *alloc_type_copy (const struct type *);
2425
2426/* * This returns the target type (or NULL) of TYPE, also skipping
2427 past typedefs. */
2428
2429extern struct type *get_target_type (struct type *type);
2430
2431/* Return the equivalent of TYPE_LENGTH, but in number of target
2432 addressable memory units of the associated gdbarch instead of bytes. */
2433
2434extern unsigned int type_length_units (struct type *type);
2435
2436/* * Helper function to construct objfile-owned types. */
2437
2438extern struct type *init_type (struct objfile *, enum type_code, int,
2439 const char *);
2440extern struct type *init_integer_type (struct objfile *, int, int,
2441 const char *);
2442extern struct type *init_character_type (struct objfile *, int, int,
2443 const char *);
2444extern struct type *init_boolean_type (struct objfile *, int, int,
2445 const char *);
2446extern struct type *init_float_type (struct objfile *, int, const char *,
2447 const struct floatformat **,
2448 enum bfd_endian = BFD_ENDIAN_UNKNOWN);
2449extern struct type *init_decfloat_type (struct objfile *, int, const char *);
2450extern bool can_create_complex_type (struct type *);
2451extern struct type *init_complex_type (const char *, struct type *);
2452extern struct type *init_pointer_type (struct objfile *, int, const char *,
2453 struct type *);
2454extern struct type *init_fixed_point_type (struct objfile *, int, int,
2455 const char *);
2456
2457/* Helper functions to construct architecture-owned types. */
2458extern struct type *arch_type (struct gdbarch *, enum type_code, int,
2459 const char *);
2460extern struct type *arch_integer_type (struct gdbarch *, int, int,
2461 const char *);
2462extern struct type *arch_character_type (struct gdbarch *, int, int,
2463 const char *);
2464extern struct type *arch_boolean_type (struct gdbarch *, int, int,
2465 const char *);
2466extern struct type *arch_float_type (struct gdbarch *, int, const char *,
2467 const struct floatformat **);
2468extern struct type *arch_decfloat_type (struct gdbarch *, int, const char *);
2469extern struct type *arch_pointer_type (struct gdbarch *, int, const char *,
2470 struct type *);
2471
2472/* Helper functions to construct a struct or record type. An
2473 initially empty type is created using arch_composite_type().
2474 Fields are then added using append_composite_type_field*(). A union
2475 type has its size set to the largest field. A struct type has each
2476 field packed against the previous. */
2477
2478extern struct type *arch_composite_type (struct gdbarch *gdbarch,
2479 const char *name, enum type_code code);
2480extern void append_composite_type_field (struct type *t, const char *name,
2481 struct type *field);
2483 const char *name,
2484 struct type *field,
2485 int alignment);
2486struct field *append_composite_type_field_raw (struct type *t, const char *name,
2487 struct type *field);
2488
2489/* Helper functions to construct a bit flags type. An initially empty
2490 type is created using arch_flag_type(). Flags are then added using
2491 append_flag_type_field() and append_flag_type_flag(). */
2492extern struct type *arch_flags_type (struct gdbarch *gdbarch,
2493 const char *name, int bit);
2494extern void append_flags_type_field (struct type *type,
2495 int start_bitpos, int nr_bits,
2496 struct type *field_type, const char *name);
2497extern void append_flags_type_flag (struct type *type, int bitpos,
2498 const char *name);
2499
2500extern void make_vector_type (struct type *array_type);
2501extern struct type *init_vector_type (struct type *elt_type, int n);
2502
2503extern struct type *lookup_reference_type (struct type *, enum type_code);
2504extern struct type *lookup_lvalue_reference_type (struct type *);
2505extern struct type *lookup_rvalue_reference_type (struct type *);
2506
2507
2508extern struct type *make_reference_type (struct type *, struct type **,
2509 enum type_code);
2510
2511extern struct type *make_cv_type (int, int, struct type *, struct type **);
2512
2513extern struct type *make_restrict_type (struct type *);
2514
2515extern struct type *make_unqualified_type (struct type *);
2516
2517extern struct type *make_atomic_type (struct type *);
2518
2519extern void replace_type (struct type *, struct type *);
2520
2522 (struct gdbarch *, const char *);
2523
2525 (struct gdbarch *, type_instance_flags);
2526
2528 (struct type *type, type_instance_flags space_identifier);
2529
2530extern struct type *lookup_memberptr_type (struct type *, struct type *);
2531
2532extern struct type *lookup_methodptr_type (struct type *);
2533
2534extern void smash_to_method_type (struct type *type, struct type *self_type,
2535 struct type *to_type, struct field *args,
2536 int nargs, int varargs);
2537
2538extern void smash_to_memberptr_type (struct type *, struct type *,
2539 struct type *);
2540
2541extern void smash_to_methodptr_type (struct type *, struct type *);
2542
2543extern struct type *allocate_stub_method (struct type *);
2544
2545extern const char *type_name_or_error (struct type *type);
2546
2548{
2549 /* The field of the element, or NULL if no element was found. */
2550 struct field *field;
2551
2552 /* The bit offset of the element in the parent structure. */
2553 LONGEST offset;
2554};
2555
2556/* Given a type TYPE, lookup the field and offset of the component named
2557 NAME.
2558
2559 TYPE can be either a struct or union, or a pointer or reference to
2560 a struct or union. If it is a pointer or reference, its target
2561 type is automatically used. Thus '.' and '->' are interchangable,
2562 as specified for the definitions of the expression element types
2563 STRUCTOP_STRUCT and STRUCTOP_PTR.
2564
2565 If NOERR is nonzero, the returned structure will have field set to
2566 NULL if there is no component named NAME.
2567
2568 If the component NAME is a field in an anonymous substructure of
2569 TYPE, the returned offset is a "global" offset relative to TYPE
2570 rather than an offset within the substructure. */
2571
2572extern struct_elt lookup_struct_elt (struct type *, const char *, int);
2573
2574/* Given a type TYPE, lookup the type of the component named NAME.
2575
2576 TYPE can be either a struct or union, or a pointer or reference to
2577 a struct or union. If it is a pointer or reference, its target
2578 type is automatically used. Thus '.' and '->' are interchangable,
2579 as specified for the definitions of the expression element types
2580 STRUCTOP_STRUCT and STRUCTOP_PTR.
2581
2582 If NOERR is nonzero, return NULL if there is no component named
2583 NAME. */
2584
2585extern struct type *lookup_struct_elt_type (struct type *, const char *, int);
2586
2587extern struct type *make_pointer_type (struct type *, struct type **);
2588
2589extern struct type *lookup_pointer_type (struct type *);
2590
2591extern struct type *make_function_type (struct type *, struct type **);
2592
2593extern struct type *lookup_function_type (struct type *);
2594
2596 int,
2597 struct type **);
2598
2599extern struct type *create_static_range_type (struct type *, struct type *,
2600 LONGEST, LONGEST);
2601
2602
2604 (struct type *, struct type *, struct type *,
2605 struct dynamic_prop *, unsigned int);
2606
2607extern struct type *create_range_type (struct type *, struct type *,
2608 const struct dynamic_prop *,
2609 const struct dynamic_prop *,
2610 LONGEST);
2611
2612/* Like CREATE_RANGE_TYPE but also sets up a stride. When BYTE_STRIDE_P
2613 is true the value in STRIDE is a byte stride, otherwise STRIDE is a bit
2614 stride. */
2615
2617 (struct type *result_type, struct type *index_type,
2618 const struct dynamic_prop *low_bound,
2619 const struct dynamic_prop *high_bound, LONGEST bias,
2620 const struct dynamic_prop *stride, bool byte_stride_p);
2621
2622extern struct type *create_array_type (struct type *, struct type *,
2623 struct type *);
2624
2625extern struct type *lookup_array_range_type (struct type *, LONGEST, LONGEST);
2626
2627extern struct type *create_string_type (struct type *, struct type *,
2628 struct type *);
2629extern struct type *lookup_string_range_type (struct type *, LONGEST, LONGEST);
2630
2631extern struct type *create_set_type (struct type *, struct type *);
2632
2633extern struct type *lookup_unsigned_typename (const struct language_defn *,
2634 const char *);
2635
2636extern struct type *lookup_signed_typename (const struct language_defn *,
2637 const char *);
2638
2639extern ULONGEST get_unsigned_type_max (struct type *);
2640
2641extern void get_signed_type_minmax (struct type *, LONGEST *, LONGEST *);
2642
2643extern CORE_ADDR get_pointer_type_max (struct type *);
2644
2645/* * Resolve all dynamic values of a type e.g. array bounds to static values.
2646 ADDR specifies the location of the variable the type is bound to.
2647 If TYPE has no dynamic properties return TYPE; otherwise a new type with
2648 static properties is returned.
2649
2650 For an array type, if the element type is dynamic, then that will
2651 not be resolved. This is done because each individual element may
2652 have a different type when resolved (depending on the contents of
2653 memory). In this situation, 'is_dynamic_type' will still return
2654 true for the return value of this function. */
2656 (struct type *type, gdb::array_view<const gdb_byte> valaddr,
2657 CORE_ADDR addr);
2658
2659/* * Predicate if the type has dynamic values, which are not resolved yet.
2660 See the caveat in 'resolve_dynamic_type' to understand a scenario
2661 where an apparently-resolved type may still be considered
2662 "dynamic". */
2663extern int is_dynamic_type (struct type *type);
2664
2665extern struct type *check_typedef (struct type *);
2666
2667extern void check_stub_method_group (struct type *, int);
2668
2669extern char *gdb_mangle_name (struct type *, int, int);
2670
2671extern struct type *lookup_typename (const struct language_defn *,
2672 const char *, const struct block *, int);
2673
2674extern struct type *lookup_template_type (const char *, struct type *,
2675 const struct block *);
2676
2677extern int get_vptr_fieldno (struct type *, struct type **);
2678
2679/* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
2680 TYPE.
2681
2682 Return true if the two bounds are available, false otherwise. */
2683
2684extern bool get_discrete_bounds (struct type *type, LONGEST *lowp,
2685 LONGEST *highp);
2686
2687/* If TYPE's low bound is a known constant, return it, else return nullopt. */
2688
2689extern gdb::optional<LONGEST> get_discrete_low_bound (struct type *type);
2690
2691/* If TYPE's high bound is a known constant, return it, else return nullopt. */
2692
2693extern gdb::optional<LONGEST> get_discrete_high_bound (struct type *type);
2694
2695/* Assuming TYPE is a simple, non-empty array type, compute its upper
2696 and lower bound. Save the low bound into LOW_BOUND if not NULL.
2697 Save the high bound into HIGH_BOUND if not NULL.
2698
2699 Return true if the operation was successful. Return false otherwise,
2700 in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified. */
2701
2702extern bool get_array_bounds (struct type *type, LONGEST *low_bound,
2703 LONGEST *high_bound);
2704
2705extern gdb::optional<LONGEST> discrete_position (struct type *type,
2706 LONGEST val);
2707
2708extern int class_types_same_p (const struct type *, const struct type *);
2709
2710extern int is_ancestor (struct type *, struct type *);
2711
2712extern int is_public_ancestor (struct type *, struct type *);
2713
2714extern int is_unique_ancestor (struct type *, struct value *);
2715
2716/* Overload resolution */
2717
2718/* * Badness if parameter list length doesn't match arg list length. */
2719extern const struct rank LENGTH_MISMATCH_BADNESS;
2720
2721/* * Dummy badness value for nonexistent parameter positions. */
2722extern const struct rank TOO_FEW_PARAMS_BADNESS;
2723/* * Badness if no conversion among types. */
2724extern const struct rank INCOMPATIBLE_TYPE_BADNESS;
2725
2726/* * Badness of an exact match. */
2727extern const struct rank EXACT_MATCH_BADNESS;
2728
2729/* * Badness of integral promotion. */
2730extern const struct rank INTEGER_PROMOTION_BADNESS;
2731/* * Badness of floating promotion. */
2732extern const struct rank FLOAT_PROMOTION_BADNESS;
2733/* * Badness of converting a derived class pointer
2734 to a base class pointer. */
2735extern const struct rank BASE_PTR_CONVERSION_BADNESS;
2736/* * Badness of integral conversion. */
2737extern const struct rank INTEGER_CONVERSION_BADNESS;
2738/* * Badness of floating conversion. */
2739extern const struct rank FLOAT_CONVERSION_BADNESS;
2740/* * Badness of integer<->floating conversions. */
2741extern const struct rank INT_FLOAT_CONVERSION_BADNESS;
2742/* * Badness of conversion of pointer to void pointer. */
2743extern const struct rank VOID_PTR_CONVERSION_BADNESS;
2744/* * Badness of conversion to boolean. */
2745extern const struct rank BOOL_CONVERSION_BADNESS;
2746/* * Badness of converting derived to base class. */
2747extern const struct rank BASE_CONVERSION_BADNESS;
2748/* * Badness of converting from non-reference to reference. Subrank
2749 is the type of reference conversion being done. */
2750extern const struct rank REFERENCE_CONVERSION_BADNESS;
2751extern const struct rank REFERENCE_SEE_THROUGH_BADNESS;
2752/* * Conversion to rvalue reference. */
2753#define REFERENCE_CONVERSION_RVALUE 1
2754/* * Conversion to const lvalue reference. */
2755#define REFERENCE_CONVERSION_CONST_LVALUE 2
2756
2757/* * Badness of converting integer 0 to NULL pointer. */
2758extern const struct rank NULL_POINTER_CONVERSION;
2759/* * Badness of cv-conversion. Subrank is a flag describing the conversions
2760 being done. */
2761extern const struct rank CV_CONVERSION_BADNESS;
2762#define CV_CONVERSION_CONST 1
2763#define CV_CONVERSION_VOLATILE 2
2764
2765/* Non-standard conversions allowed by the debugger */
2766
2767/* * Converting a pointer to an int is usually OK. */
2768extern const struct rank NS_POINTER_CONVERSION_BADNESS;
2769
2770/* * Badness of converting a (non-zero) integer constant
2771 to a pointer. */
2773
2774extern struct rank sum_ranks (struct rank a, struct rank b);
2775extern int compare_ranks (struct rank a, struct rank b);
2776
2778 const badness_vector &);
2779
2780extern badness_vector rank_function (gdb::array_view<type *> parms,
2781 gdb::array_view<value *> args);
2782
2783extern struct rank rank_one_type (struct type *, struct type *,
2784 struct value *);
2785
2786extern void recursive_dump_type (struct type *, int);
2787
2788extern int field_is_static (struct field *);
2789
2790/* printcmd.c */
2791
2792extern void print_scalar_formatted (const gdb_byte *, struct type *,
2793 const struct value_print_options *,
2794 int, struct ui_file *);
2795
2796extern int can_dereference (struct type *);
2797
2798extern int is_integral_type (struct type *);
2799
2800extern int is_floating_type (struct type *);
2801
2802extern int is_scalar_type (struct type *type);
2803
2804extern int is_scalar_type_recursive (struct type *);
2805
2806extern int class_or_union_p (const struct type *);
2807
2808extern void maintenance_print_type (const char *, int);
2809
2811
2812extern struct type *copy_type_recursive (struct type *type,
2813 htab_t copied_types);
2814
2815extern struct type *copy_type (const struct type *type);
2816
2817extern bool types_equal (struct type *, struct type *);
2818
2819extern bool types_deeply_equal (struct type *, struct type *);
2820
2821extern int type_not_allocated (const struct type *type);
2822
2823extern int type_not_associated (const struct type *type);
2824
2825/* Return True if TYPE is a TYPE_CODE_FIXED_POINT or if TYPE is
2826 a range type whose base type is a TYPE_CODE_FIXED_POINT. */
2827extern bool is_fixed_point_type (struct type *type);
2828
2829/* Allocate a fixed-point type info for TYPE. This should only be
2830 called by INIT_FIXED_POINT_SPECIFIC. */
2832
2833/* * When the type includes explicit byte ordering, return that.
2834 Otherwise, the byte ordering from gdbarch_byte_order for
2835 the type's arch is returned. */
2836
2837extern enum bfd_endian type_byte_order (const struct type *type);
2838
2839/* A flag to enable printing of debugging information of C++
2840 overloading. */
2841
2842extern unsigned int overload_debug;
2843
2844/* Return whether the function type represented by TYPE is marked as unsafe
2845 to call by the debugger.
2846
2847 This usually indicates that the function does not follow the target's
2848 standard calling convention. */
2849
2850extern bool is_nocall_function (const struct type *type);
2851
2852#endif /* GDBTYPES_H */
type_specific_kind
Definition: gdbtypes.h:512
@ TYPE_SPECIFIC_FLOATFORMAT
Definition: gdbtypes.h:516
@ TYPE_SPECIFIC_FIXED_POINT
Definition: gdbtypes.h:521
@ TYPE_SPECIFIC_GNAT_STUFF
Definition: gdbtypes.h:515
@ TYPE_SPECIFIC_SELF_TYPE
Definition: gdbtypes.h:519
@ TYPE_SPECIFIC_INT
Definition: gdbtypes.h:520
@ TYPE_SPECIFIC_NONE
Definition: gdbtypes.h:513
@ TYPE_SPECIFIC_FUNC
Definition: gdbtypes.h:518
@ TYPE_SPECIFIC_CPLUS_STUFF
Definition: gdbtypes.h:514
struct type * arch_boolean_type(struct gdbarch *, int, int, const char *)
struct type * init_type(struct objfile *, enum type_code, int, const char *)
void recursive_dump_type(struct type *, int)
struct type * copy_type_recursive(struct type *type, htab_t copied_types)
struct type * check_typedef(struct type *)
const struct rank INTEGER_PROMOTION_BADNESS
int can_dereference(struct type *)
struct type * resolve_dynamic_type(struct type *type, gdb::array_view< const gdb_byte > valaddr, CORE_ADDR addr)
struct type * init_boolean_type(struct objfile *, int, int, const char *)
struct type * arch_pointer_type(struct gdbarch *, int, const char *, struct type *)
struct type * get_target_type(struct type *type)
struct type * make_function_type(struct type *, struct type **)
void smash_to_memberptr_type(struct type *, struct type *, struct type *)
enum bfd_endian type_byte_order(const struct type *type)
void allocate_gnat_aux_type(struct type *)
dynamic_prop_kind
Definition: gdbtypes.h:291
@ PROP_ADDR_OFFSET
Definition: gdbtypes.h:294
@ PROP_VARIABLE_NAME
Definition: gdbtypes.h:299
@ PROP_CONST
Definition: gdbtypes.h:293
@ PROP_UNDEFINED
Definition: gdbtypes.h:292
@ PROP_VARIANT_PARTS
Definition: gdbtypes.h:297
@ PROP_TYPE
Definition: gdbtypes.h:298
@ PROP_LOCEXPR
Definition: gdbtypes.h:295
@ PROP_LOCLIST
Definition: gdbtypes.h:296
struct type * make_cv_type(int, int, struct type *, struct type **)
const struct floatformat * floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN]
const struct rank BASE_PTR_CONVERSION_BADNESS
bool set_type_align(struct type *, ULONGEST)
void append_flags_type_flag(struct type *type, int bitpos, const char *name)
const struct rank LENGTH_MISMATCH_BADNESS
bool operator==(const dynamic_prop &l, const dynamic_prop &r)
DEFINE_OFFSET_TYPE(cu_offset, unsigned int)
bool types_equal(struct type *, struct type *)
htab_up create_copied_types_hash()
const struct rank BOOL_CONVERSION_BADNESS
void maintenance_print_type(const char *, int)
const struct rank NS_POINTER_CONVERSION_BADNESS
const struct rank FLOAT_PROMOTION_BADNESS
const struct floatformat * floatformats_m68881_ext[BFD_ENDIAN_UNKNOWN]
struct type * make_reference_type(struct type *, struct type **, enum type_code)
#define TYPE_IS_REFERENCE(t)
Definition: gdbtypes.h:156
const struct rank TOO_FEW_PARAMS_BADNESS
struct type * make_type_with_address_space(struct type *type, type_instance_flags space_identifier)
struct type * arch_composite_type(struct gdbarch *gdbarch, const char *name, enum type_code code)
int is_scalar_type(struct type *type)
struct type * lookup_reference_type(struct type *, enum type_code)
const struct rank NS_INTEGER_POINTER_CONVERSION_BADNESS
field_loc_kind
Definition: gdbtypes.h:492
@ FIELD_LOC_KIND_BITPOS
Definition: gdbtypes.h:493
@ FIELD_LOC_KIND_PHYSNAME
Definition: gdbtypes.h:496
@ FIELD_LOC_KIND_ENUMVAL
Definition: gdbtypes.h:494
@ FIELD_LOC_KIND_PHYSADDR
Definition: gdbtypes.h:495
@ FIELD_LOC_KIND_DWARF_BLOCK
Definition: gdbtypes.h:497
CORE_ADDR get_pointer_type_max(struct type *)
struct type * lookup_unsigned_typename(const struct language_defn *, const char *)
struct type * internal_type_self_type(struct type *)
struct type * create_array_type(struct type *, struct type *, struct type *)
int is_dynamic_type(struct type *type)
#define B_TYPE
Definition: gdbtypes.h:91
struct type * make_restrict_type(struct type *)
struct type * lookup_signed_typename(const struct language_defn *, const char *)
const struct rank INCOMPATIBLE_TYPE_BADNESS
void allocate_fixed_point_type_info(struct type *type)
const struct floatformat * floatformat_from_type(const struct type *type)
struct type * init_character_type(struct objfile *, int, int, const char *)
struct type * alloc_type(struct objfile *)
const struct floatformat * floatformats_ieee_quad[BFD_ENDIAN_UNKNOWN]
struct type * alloc_type_arch(struct gdbarch *)
const struct rank REFERENCE_SEE_THROUGH_BADNESS
type_instance_flag_value
Definition: gdbtypes.h:112
@ TYPE_INSTANCE_FLAG_CODE_SPACE
Definition: gdbtypes.h:115
@ TYPE_INSTANCE_FLAG_CONST
Definition: gdbtypes.h:113
@ TYPE_INSTANCE_FLAG_VOLATILE
Definition: gdbtypes.h:114
@ TYPE_INSTANCE_FLAG_ATOMIC
Definition: gdbtypes.h:121
@ TYPE_INSTANCE_FLAG_DATA_SPACE
Definition: gdbtypes.h:116
@ TYPE_INSTANCE_FLAG_RESTRICT
Definition: gdbtypes.h:120
@ TYPE_INSTANCE_FLAG_ADDRESS_CLASS_2
Definition: gdbtypes.h:118
@ TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
Definition: gdbtypes.h:117
@ TYPE_INSTANCE_FLAG_NOTTEXT
Definition: gdbtypes.h:119
bool get_discrete_bounds(struct type *type, LONGEST *lowp, LONGEST *highp)
void replace_type(struct type *, struct type *)
DEF_ENUM_FLAGS_TYPE(enum type_instance_flag_value, type_instance_flags)
const struct floatformat * floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN]
const struct rank INT_FLOAT_CONVERSION_BADNESS
int is_public_ancestor(struct type *, struct type *)
gdb::optional< LONGEST > get_discrete_high_bound(struct type *type)
struct type * lookup_array_range_type(struct type *, LONGEST, LONGEST)
struct type * lookup_struct_elt_type(struct type *, const char *, int)
struct type * lookup_string_range_type(struct type *, LONGEST, LONGEST)
void get_signed_type_minmax(struct type *, LONGEST *, LONGEST *)
void allocate_cplus_struct_type(struct type *)
struct type * lookup_rvalue_reference_type(struct type *)
#define TYPE_ALIGN_BITS
Definition: gdbtypes.h:916
const struct rank BASE_CONVERSION_BADNESS
void set_type_vptr_basetype(struct type *, struct type *)
struct type * lookup_typename(const struct language_defn *, const char *, const struct block *, int)
struct type * arch_flags_type(struct gdbarch *gdbarch, const char *name, int bit)
badness_vector rank_function(gdb::array_view< type * > parms, gdb::array_view< value * > args)
struct type * lookup_function_type_with_arguments(struct type *, int, struct type **)
void print_scalar_formatted(const gdb_byte *, struct type *, const struct value_print_options *, int, struct ui_file *)
struct type * init_vector_type(struct type *elt_type, int n)
int is_floating_type(struct type *)
struct type * make_pointer_type(struct type *, struct type **)
struct type * arch_integer_type(struct gdbarch *, int, int, const char *)
gdb::optional< LONGEST > get_discrete_low_bound(struct type *type)
struct type * lookup_memberptr_type(struct type *, struct type *)
void append_flags_type_field(struct type *type, int start_bitpos, int nr_bits, struct type *field_type, const char *name)
struct type * init_complex_type(const char *, struct type *)
bool is_nocall_function(const struct type *type)
struct rank rank_one_type(struct type *, struct type *, struct value *)
int class_types_same_p(const struct type *, const struct type *)
struct type * internal_type_vptr_basetype(struct type *)
const struct floatformat * floatformats_bfloat16[BFD_ENDIAN_UNKNOWN]
const struct rank CV_CONVERSION_BADNESS
char * gdb_mangle_name(struct type *, int, int)
int compare_ranks(struct rank a, struct rank b)
struct type * create_range_type(struct type *, struct type *, const struct dynamic_prop *, const struct dynamic_prop *, LONGEST)
int is_scalar_type_recursive(struct type *)
int internal_type_vptr_fieldno(struct type *)
struct type * allocate_stub_method(struct type *)
struct type * lookup_template_type(const char *, struct type *, const struct block *)
void smash_to_method_type(struct type *type, struct type *self_type, struct type *to_type, struct field *args, int nargs, int varargs)
unsigned type_raw_align(struct type *)
const struct floatformat * floatformats_ieee_single[BFD_ENDIAN_UNKNOWN]
const struct rank REFERENCE_CONVERSION_BADNESS
int class_or_union_p(const struct type *)
type_code
Definition: gdbtypes.h:99
@ TYPE_CODE_UNDEF
Definition: gdbtypes.h:100
struct type * init_pointer_type(struct objfile *, int, const char *, struct type *)
void append_composite_type_field_aligned(struct type *t, const char *name, struct type *field, int alignment)
void set_type_vptr_fieldno(struct type *, int)
struct type * make_unqualified_type(struct type *)
struct type * lookup_function_type(struct type *)
struct type * lookup_methodptr_type(struct type *)
int is_integral_type(struct type *)
gdb::optional< LONGEST > discrete_position(struct type *type, LONGEST val)
int compare_badness(const badness_vector &, const badness_vector &)
struct type * make_atomic_type(struct type *)
struct type * lookup_lvalue_reference_type(struct type *)
bool get_array_bounds(struct type *type, LONGEST *low_bound, LONGEST *high_bound)
unsigned int overload_debug
const struct floatformat * floatformats_ia64_spill[BFD_ENDIAN_UNKNOWN]
struct type * lookup_pointer_type(struct type *)
const struct floatformat * floatformats_arm_ext[BFD_ENDIAN_UNKNOWN]
void check_stub_method_group(struct type *, int)
struct_elt lookup_struct_elt(struct type *, const char *, int)
struct type * arch_type(struct gdbarch *, enum type_code, int, const char *)
int type_not_associated(const struct type *type)
unsigned type_align(struct type *)
struct type * init_integer_type(struct objfile *, int, int, const char *)
unsigned int type_length_units(struct type *type)
struct type * create_range_type_with_stride(struct type *result_type, struct type *index_type, const struct dynamic_prop *low_bound, const struct dynamic_prop *high_bound, LONGEST bias, const struct dynamic_prop *stride, bool byte_stride_p)
void set_type_self_type(struct type *, struct type *)
bool can_create_complex_type(struct type *)
void smash_to_methodptr_type(struct type *, struct type *)
call_site_parameter_kind
Definition: gdbtypes.h:1757
@ CALL_SITE_PARAMETER_FB_OFFSET
Definition: gdbtypes.h:1762
@ CALL_SITE_PARAMETER_DWARF_REG
Definition: gdbtypes.h:1759
@ CALL_SITE_PARAMETER_PARAM_OFFSET
Definition: gdbtypes.h:1765
const struct rank INTEGER_CONVERSION_BADNESS
const char * address_space_type_instance_flags_to_name(struct gdbarch *, type_instance_flags)
struct field * append_composite_type_field_raw(struct type *t, const char *name, struct type *field)
const struct cplus_struct_type cplus_struct_default
const struct floatformat * floatformats_ieee_half[BFD_ENDIAN_UNKNOWN]
ULONGEST get_unsigned_type_max(struct type *)
const struct floatformat * floatformats_ieee_double[BFD_ENDIAN_UNKNOWN]
const struct gnat_aux_type gnat_aux_default
int is_ancestor(struct type *, struct type *)
struct type * arch_character_type(struct gdbarch *, int, int, const char *)
const struct rank NULL_POINTER_CONVERSION
void append_composite_type_field(struct type *t, const char *name, struct type *field)
int is_unique_ancestor(struct type *, struct value *)
const struct rank EXACT_MATCH_BADNESS
struct type * create_static_range_type(struct type *, struct type *, LONGEST, LONGEST)
int field_is_static(struct field *)
struct type * alloc_type_copy(const struct type *)
struct type * create_string_type(struct type *, struct type *, struct type *)
struct type * create_array_type_with_stride(struct type *, struct type *, struct type *, struct dynamic_prop *, unsigned int)
bool is_fixed_point_type(struct type *type)
dynamic_prop_node_kind
Definition: gdbtypes.h:448
@ DYN_PROP_VARIANT_PARTS
Definition: gdbtypes.h:465
@ DYN_PROP_ASSOCIATED
Definition: gdbtypes.h:459
@ DYN_PROP_RANK
Definition: gdbtypes.h:469
@ DYN_PROP_BYTE_SIZE
Definition: gdbtypes.h:472
@ DYN_PROP_DATA_LOCATION
Definition: gdbtypes.h:451
@ DYN_PROP_ALLOCATED
Definition: gdbtypes.h:455
@ DYN_PROP_BYTE_STRIDE
Definition: gdbtypes.h:462
std::vector< rank > badness_vector
Definition: gdbtypes.h:1710
struct type * arch_float_type(struct gdbarch *, int, const char *, const struct floatformat **)
int get_vptr_fieldno(struct type *, struct type **)
struct type * init_float_type(struct objfile *, int, const char *, const struct floatformat **, enum bfd_endian=BFD_ENDIAN_UNKNOWN)
const struct rank FLOAT_CONVERSION_BADNESS
struct type * create_set_type(struct type *, struct type *)
const struct floatformat * floatformats_vax_d[BFD_ENDIAN_UNKNOWN]
struct type * init_decfloat_type(struct objfile *, int, const char *)
int type_not_allocated(const struct type *type)
const struct rank VOID_PTR_CONVERSION_BADNESS
struct type * init_fixed_point_type(struct objfile *, int, int, const char *)
const struct floatformat * floatformats_i387_ext[BFD_ENDIAN_UNKNOWN]
type_instance_flags address_space_name_to_type_instance_flags(struct gdbarch *, const char *)
struct type * copy_type(const struct type *type)
const char * type_name_or_error(struct type *type)
void make_vector_type(struct type *array_type)
struct rank sum_ranks(struct rank a, struct rank b)
const struct floatformat * floatformats_vax_f[BFD_ENDIAN_UNKNOWN]
struct type * arch_decfloat_type(struct gdbarch *, int, const char *)
bool types_deeply_equal(struct type *, struct type *)
struct type * builtin_signed_char
Definition: gdbtypes.h:2250
struct type * builtin_declong
Definition: gdbtypes.h:2268
struct type * builtin_long_long
Definition: gdbtypes.h:2264
struct type * builtin_int0
Definition: gdbtypes.h:2280
struct type * internal_fn
Definition: gdbtypes.h:2325
struct type * builtin_uint16
Definition: gdbtypes.h:2284
struct type * builtin_int24
Definition: gdbtypes.h:2285
struct type * builtin_double
Definition: gdbtypes.h:2258
struct type * builtin_string
Definition: gdbtypes.h:2262
struct type * builtin_int8
Definition: gdbtypes.h:2281
struct type * builtin_func_ptr
Definition: gdbtypes.h:2314
struct type * builtin_uint128
Definition: gdbtypes.h:2292
struct type * builtin_long
Definition: gdbtypes.h:2249
struct type * builtin_data_ptr
Definition: gdbtypes.h:2303
struct type * builtin_bool
Definition: gdbtypes.h:2263
struct type * builtin_true_unsigned_char
Definition: gdbtypes.h:2275
struct type * builtin_unsigned_char
Definition: gdbtypes.h:2251
struct type * builtin_complex
Definition: gdbtypes.h:2260
struct type * builtin_long_double
Definition: gdbtypes.h:2259
struct type * builtin_unsigned_long_long
Definition: gdbtypes.h:2265
struct type * builtin_uint32
Definition: gdbtypes.h:2288
struct type * builtin_uint64
Definition: gdbtypes.h:2290
struct type * builtin_char16
Definition: gdbtypes.h:2295
struct type * xmethod
Definition: gdbtypes.h:2328
struct type * builtin_short
Definition: gdbtypes.h:2247
struct type * builtin_double_complex
Definition: gdbtypes.h:2261
struct type * builtin_int64
Definition: gdbtypes.h:2289
struct type * builtin_uint24
Definition: gdbtypes.h:2286
struct type * builtin_char
Definition: gdbtypes.h:2246
struct type * builtin_int
Definition: gdbtypes.h:2248
struct type * builtin_decfloat
Definition: gdbtypes.h:2266
struct type * builtin_int32
Definition: gdbtypes.h:2287
struct type * builtin_unsigned_short
Definition: gdbtypes.h:2252
struct type * builtin_wchar
Definition: gdbtypes.h:2297
struct type * builtin_unsigned_int
Definition: gdbtypes.h:2253
struct type * builtin_decdouble
Definition: gdbtypes.h:2267
struct type * builtin_char32
Definition: gdbtypes.h:2296
struct type * builtin_uint8
Definition: gdbtypes.h:2282
struct type * builtin_half
Definition: gdbtypes.h:2256
struct type * builtin_bfloat16
Definition: gdbtypes.h:2255
struct type * builtin_int128
Definition: gdbtypes.h:2291
struct type * builtin_unsigned_long
Definition: gdbtypes.h:2254
struct type * builtin_int16
Definition: gdbtypes.h:2283
struct type * builtin_void
Definition: gdbtypes.h:2245
struct type * builtin_float
Definition: gdbtypes.h:2257
struct type * builtin_func_func
Definition: gdbtypes.h:2319
struct type * builtin_true_char
Definition: gdbtypes.h:2274
__extension__ enum call_site_parameter_kind kind
Definition: gdbtypes.h:1866
const gdb_byte * value
Definition: gdbtypes.h:1872
size_t data_value_size
Definition: gdbtypes.h:1879
union call_site_parameter_u u
Definition: gdbtypes.h:1868
const gdb_byte * data_value
Definition: gdbtypes.h:1878
struct dwarf2_locexpr_baton * dwarf_block
Definition: gdbtypes.h:1830
void set_loc_physaddr(CORE_ADDR physaddr)
Definition: gdbtypes.h:1783
struct call_site_target::@2::@3 addresses
void iterate_over_addresses(struct gdbarch *call_site_gdbarch, const struct call_site *call_site, frame_info_ptr caller_frame, iterate_ftype callback) const
void set_loc_dwarf_block(dwarf2_locexpr_baton *dwarf_block)
Definition: gdbtypes.h:1795
void set_loc_physname(const char *physname)
Definition: gdbtypes.h:1789
const char * physname
Definition: gdbtypes.h:1828
void set_loc_array(unsigned length, const CORE_ADDR *data)
Definition: gdbtypes.h:1801
unsigned length
Definition: gdbtypes.h:1834
gdb::function_view< void(CORE_ADDR)> iterate_ftype
Definition: gdbtypes.h:1810
CORE_ADDR physaddr
Definition: gdbtypes.h:1826
const CORE_ADDR * values
Definition: gdbtypes.h:1835
unsigned parameter_count
Definition: gdbtypes.h:1944
static hashval_t hash(const call_site *a)
Definition: gdbtypes.h:1899
static int eq(const void *a, const void *b)
Definition: gdbtypes.h:1905
struct call_site_parameter parameter[]
Definition: gdbtypes.h:1962
call_site(CORE_ADDR pc, dwarf2_per_cu_data *per_cu, dwarf2_per_objfile *per_objfile)
Definition: gdbtypes.h:1887
CORE_ADDR pc() const
void iterate_over_addresses(struct gdbarch *call_site_gdbarch, frame_info_ptr caller_frame, call_site_target::iterate_ftype callback) const
Definition: gdbtypes.h:1924
static int eq(const call_site *a, const call_site *b)
Definition: gdbtypes.h:1893
static hashval_t hash(const void *a)
Definition: gdbtypes.h:1911
struct call_site * tail_call_next
Definition: gdbtypes.h:1935
dwarf2_per_cu_data *const per_cu
Definition: gdbtypes.h:1949
dwarf2_per_objfile *const per_objfile
Definition: gdbtypes.h:1953
struct fn_fieldlist * fn_fieldlists
Definition: gdbtypes.h:1668
struct type * vptr_basetype
Definition: gdbtypes.h:1623
unsigned typedef_field_count
Definition: gdbtypes.h:1675
struct decl_field * nested_types
Definition: gdbtypes.h:1680
B_TYPE * virtual_field_bits
Definition: gdbtypes.h:1638
unsigned nested_types_count
Definition: gdbtypes.h:1682
__extension__ enum dwarf_calling_convention calling_convention
Definition: gdbtypes.h:1619
B_TYPE * private_field_bits
Definition: gdbtypes.h:1646
unsigned short n_template_arguments
Definition: gdbtypes.h:1605
struct symbol ** template_arguments
Definition: gdbtypes.h:1688
B_TYPE * protected_field_bits
Definition: gdbtypes.h:1654
struct decl_field * typedef_field
Definition: gdbtypes.h:1673
B_TYPE * ignore_field_bits
Definition: gdbtypes.h:1659
const char * name
Definition: gdbtypes.h:1557
unsigned int is_private
Definition: gdbtypes.h:1567
struct type * type
Definition: gdbtypes.h:1561
unsigned int is_protected
Definition: gdbtypes.h:1564
bool contains(ULONGEST value, bool is_unsigned) const
Definition: gdbtypes.h:223
struct dynamic_prop_list * next
Definition: gdbtypes.h:485
enum dynamic_prop_node_kind prop_kind
Definition: gdbtypes.h:479
struct dynamic_prop prop
Definition: gdbtypes.h:482
const char * variable_name() const
Definition: gdbtypes.h:415
LONGEST const_val() const
Definition: gdbtypes.h:347
dynamic_prop_kind kind() const
Definition: gdbtypes.h:337
void set_loclist(void *baton)
Definition: gdbtypes.h:375
union dynamic_prop_data m_data
Definition: gdbtypes.h:433
void set_original_type(struct type *original_type)
Definition: gdbtypes.h:407
struct type * original_type() const
Definition: gdbtypes.h:400
enum dynamic_prop_kind m_kind
Definition: gdbtypes.h:430
const gdb::array_view< variant_part > * variant_parts() const
Definition: gdbtypes.h:387
void set_variable_name(const char *name)
Definition: gdbtypes.h:423
void set_undefined()
Definition: gdbtypes.h:342
void * baton() const
Definition: gdbtypes.h:360
void set_addr_offset(void *baton)
Definition: gdbtypes.h:381
void set_locexpr(void *baton)
Definition: gdbtypes.h:369
void set_variant_parts(gdb::array_view< variant_part > *variant_parts)
Definition: gdbtypes.h:394
void set_const_val(LONGEST const_val)
Definition: gdbtypes.h:354
void set_type(struct type *type)
Definition: gdbtypes.h:564
void set_loc_bitpos(LONGEST bitpos)
Definition: gdbtypes.h:592
CORE_ADDR loc_physaddr() const
Definition: gdbtypes.h:610
LONGEST loc_bitpos() const
Definition: gdbtypes.h:586
void set_loc_physaddr(CORE_ADDR physaddr)
Definition: gdbtypes.h:616
const char * loc_physname() const
Definition: gdbtypes.h:622
union field_location m_loc
Definition: gdbtypes.h:646
void set_loc_dwarf_block(dwarf2_locexpr_baton *dwarf_block)
Definition: gdbtypes.h:640
void set_loc_physname(const char *physname)
Definition: gdbtypes.h:628
__extension__ enum field_loc_kind m_loc_kind
Definition: gdbtypes.h:657
unsigned int artificial
Definition: gdbtypes.h:653
field_loc_kind loc_kind() const
Definition: gdbtypes.h:581
LONGEST loc_enumval() const
Definition: gdbtypes.h:598
dwarf2_locexpr_baton * loc_dwarf_block() const
Definition: gdbtypes.h:634
void set_loc_enumval(LONGEST enumval)
Definition: gdbtypes.h:604
struct type * m_type
Definition: gdbtypes.h:671
void set_name(const char *name)
Definition: gdbtypes.h:574
unsigned int bitsize
Definition: gdbtypes.h:665
const char * name() const
Definition: gdbtypes.h:569
struct type * type() const
Definition: gdbtypes.h:559
const char * m_name
Definition: gdbtypes.h:677
unsigned int is_private
Definition: gdbtypes.h:1517
unsigned int is_artificial
Definition: gdbtypes.h:1519
__extension__ enum dwarf_defaulted_attribute defaulted
Definition: gdbtypes.h:1537
struct type * type
Definition: gdbtypes.h:1506
const char * physname
Definition: gdbtypes.h:1498
unsigned int voffset
Definition: gdbtypes.h:1546
struct type * fcontext
Definition: gdbtypes.h:1511
unsigned int is_volatile
Definition: gdbtypes.h:1516
unsigned int is_stub
Definition: gdbtypes.h:1524
unsigned int is_constructor
Definition: gdbtypes.h:1528
unsigned int dummy
Definition: gdbtypes.h:1541
unsigned int is_const
Definition: gdbtypes.h:1515
unsigned int is_protected
Definition: gdbtypes.h:1518
unsigned int is_deleted
Definition: gdbtypes.h:1532
struct fn_field * fn_fields
Definition: gdbtypes.h:1481
const char * name
Definition: gdbtypes.h:1473
struct type * self_type
Definition: gdbtypes.h:1751
__extension__ enum dwarf_calling_convention calling_convention
Definition: gdbtypes.h:1731
struct call_site * tail_call_list
Definition: gdbtypes.h:1746
unsigned int is_noreturn
Definition: gdbtypes.h:1737
struct type * descriptive_type
Definition: gdbtypes.h:1719
unsigned int m_flag_prototyped
Definition: gdbtypes.h:803
unsigned int m_flag_flag_enum
Definition: gdbtypes.h:820
unsigned int m_flag_fixed_instance
Definition: gdbtypes.h:808
unsigned int m_multi_dimensional
Definition: gdbtypes.h:829
unsigned int m_flag_vector
Definition: gdbtypes.h:805
struct range_bounds * bounds
Definition: gdbtypes.h:897
unsigned int m_flag_stub_supported
Definition: gdbtypes.h:806
unsigned int m_flag_endianity_not_default
Definition: gdbtypes.h:810
struct field * fields
Definition: gdbtypes.h:893
unsigned int m_flag_stub
Definition: gdbtypes.h:801
struct type * complex_type
Definition: gdbtypes.h:901
unsigned int m_flag_target_stub
Definition: gdbtypes.h:802
unsigned int m_flag_varargs
Definition: gdbtypes.h:804
__extension__ enum type_specific_kind type_specific_field
Definition: gdbtypes.h:834
struct type * m_target_type
Definition: gdbtypes.h:873
const char * name
Definition: gdbtypes.h:847
unsigned int m_flag_unsigned
Definition: gdbtypes.h:799
__extension__ enum type_code code
Definition: gdbtypes.h:793
unsigned int m_flag_nosign
Definition: gdbtypes.h:800
union type_specific type_specific
Definition: gdbtypes.h:908
union type_owner m_owner
Definition: gdbtypes.h:861
unsigned int m_flag_declared_class
Definition: gdbtypes.h:815
union main_type::@1 flds_bnds
unsigned int m_flag_objfile_owned
Definition: gdbtypes.h:809
short nfields
Definition: gdbtypes.h:839
unsigned int m_flag_gnu_ifunc
Definition: gdbtypes.h:807
struct dynamic_prop_list * dyn_prop_list
Definition: gdbtypes.h:911
struct type * nodebug_unknown_symbol
Definition: gdbtypes.h:2369
struct type * nodebug_tls_symbol
Definition: gdbtypes.h:2370
struct type * nodebug_got_plt_symbol
Definition: gdbtypes.h:2367
struct type * builtin_error
Definition: gdbtypes.h:2362
struct type * builtin_half
Definition: gdbtypes.h:2352
struct type * builtin_unsigned_int
Definition: gdbtypes.h:2349
struct type * builtin_int
Definition: gdbtypes.h:2343
struct type * builtin_long
Definition: gdbtypes.h:2344
struct type * builtin_unsigned_long
Definition: gdbtypes.h:2350
struct type * builtin_void
Definition: gdbtypes.h:2340
struct type * builtin_char
Definition: gdbtypes.h:2341
struct type * builtin_long_long
Definition: gdbtypes.h:2345
struct type * builtin_long_double
Definition: gdbtypes.h:2355
struct type * builtin_float
Definition: gdbtypes.h:2353
struct type * builtin_short
Definition: gdbtypes.h:2342
struct type * builtin_unsigned_char
Definition: gdbtypes.h:2347
struct type * builtin_signed_char
Definition: gdbtypes.h:2346
struct type * nodebug_text_gnu_ifunc_symbol
Definition: gdbtypes.h:2366
struct type * builtin_core_addr
Definition: gdbtypes.h:2358
struct type * builtin_unsigned_short
Definition: gdbtypes.h:2348
struct type * nodebug_text_symbol
Definition: gdbtypes.h:2365
struct type * builtin_double
Definition: gdbtypes.h:2354
struct type * nodebug_data_symbol
Definition: gdbtypes.h:2368
struct type * builtin_unsigned_long_long
Definition: gdbtypes.h:2351
struct dynamic_prop high
Definition: gdbtypes.h:696
struct dynamic_prop stride
Definition: gdbtypes.h:703
unsigned int flag_upper_bound_is_count
Definition: gdbtypes.h:713
ULONGEST bit_stride() const
Definition: gdbtypes.h:682
unsigned int flag_is_byte_stride
Definition: gdbtypes.h:722
struct dynamic_prop low
Definition: gdbtypes.h:692
LONGEST bias
Definition: gdbtypes.h:708
unsigned int flag_bound_evaluated
Definition: gdbtypes.h:718
short subrank
Definition: gdbtypes.h:1705
short rank
Definition: gdbtypes.h:1695
LONGEST offset
Definition: gdbtypes.h:2553
struct field * field
Definition: gdbtypes.h:2550
Definition: gdbtypes.h:922
struct type * target_type() const
Definition: gdbtypes.h:1000
dynamic_prop * dyn_prop(dynamic_prop_node_kind kind) const
type_code code() const
Definition: gdbtypes.h:927
void set_is_prototyped(bool is_prototyped)
Definition: gdbtypes.h:1127
void set_code(type_code code)
Definition: gdbtypes.h:933
void remove_dyn_prop(dynamic_prop_node_kind kind)
ULONGEST length() const
Definition: gdbtypes.h:954
void set_is_multi_dimensional(bool value)
Definition: gdbtypes.h:1261
bool is_fixed_instance() const
Definition: gdbtypes.h:1199
bool has_varargs() const
Definition: gdbtypes.h:1135
void set_endianity_is_not_default(bool endianity_is_not_default)
Definition: gdbtypes.h:1218
struct field & field(int idx) const
Definition: gdbtypes.h:983
void set_has_no_signedness(bool has_no_signedness)
Definition: gdbtypes.h:1082
void set_instance_flags(type_instance_flags flags)
Definition: gdbtypes.h:1022
void set_index_type(type *index_type)
Definition: gdbtypes.h:1010
void set_target_type(struct type *target_type)
Definition: gdbtypes.h:1005
bool is_unsigned() const
Definition: gdbtypes.h:1063
struct main_type * main_type
Definition: gdbtypes.h:1463
void set_is_unsigned(bool is_unsigned)
Definition: gdbtypes.h:1068
void set_is_stub(bool is_stub)
Definition: gdbtypes.h:1096
void set_is_declared_class(bool is_declared_class) const
Definition: gdbtypes.h:1235
struct type * rvalue_reference_type
Definition: gdbtypes.h:1412
gdbarch * arch_owner() const
Definition: gdbtypes.h:1353
void set_has_varargs(bool has_varargs)
Definition: gdbtypes.h:1140
void set_owner(objfile *objfile)
Definition: gdbtypes.h:1322
bool target_is_stub() const
Definition: gdbtypes.h:1107
bool endianity_is_not_default() const
Definition: gdbtypes.h:1213
bool is_gnu_ifunc() const
Definition: gdbtypes.h:1179
bool is_vector() const
Definition: gdbtypes.h:1149
void set_fixed_point_info(struct fixed_point_type_info *info) const
Definition: gdbtypes.h:1280
unsigned align_log2
Definition: gdbtypes.h:1429
void set_is_flag_enum(bool is_flag_enum)
Definition: gdbtypes.h:1249
struct type * pointer_type
Definition: gdbtypes.h:1404
void set_bounds(range_bounds *bounds)
Definition: gdbtypes.h:1046
void set_num_fields(int num_fields)
Definition: gdbtypes.h:971
bool is_declared_class() const
Definition: gdbtypes.h:1230
int num_fields() const
Definition: gdbtypes.h:965
struct type * chain
Definition: gdbtypes.h:1421
bool is_stub() const
Definition: gdbtypes.h:1091
bool has_no_signedness() const
Definition: gdbtypes.h:1077
struct objfile * objfile_owner() const
Definition: gdbtypes.h:1342
void add_dyn_prop(dynamic_prop_node_kind kind, dynamic_prop prop)
void set_name(const char *name)
Definition: gdbtypes.h:945
gdbarch * arch() const
void set_is_vector(bool is_vector)
Definition: gdbtypes.h:1154
bool stub_is_supported() const
Definition: gdbtypes.h:1164
struct fixed_point_type_info & fixed_point_info() const
Definition: gdbtypes.h:1269
void set_is_gnu_ifunc(bool is_gnu_ifunc)
Definition: gdbtypes.h:1184
bool bit_size_differs_p() const
Definition: gdbtypes.h:1371
void set_owner(gdbarch *arch)
Definition: gdbtypes.h:1331
ULONGEST bit_stride() const
Definition: gdbtypes.h:1053
void set_length(ULONGEST length)
Definition: gdbtypes.h:959
bool is_multi_dimensional() const
Definition: gdbtypes.h:1256
const gdb_mpq & fixed_point_scaling_factor()
struct field * fields() const
Definition: gdbtypes.h:977
struct type * reference_type
Definition: gdbtypes.h:1408
bool is_pointer_or_reference() const
Definition: gdbtypes.h:1394
range_bounds * bounds() const
Definition: gdbtypes.h:1028
ULONGEST m_length
Definition: gdbtypes.h:1459
void set_is_fixed_instance(bool is_fixed_instance)
Definition: gdbtypes.h:1204
const char * name() const
Definition: gdbtypes.h:939
type * index_type() const
Definition: gdbtypes.h:995
struct type * fixed_point_type_base_type()
bool is_flag_enum() const
Definition: gdbtypes.h:1244
bool is_prototyped() const
Definition: gdbtypes.h:1122
void set_stub_is_supported(bool stub_is_supported)
Definition: gdbtypes.h:1169
const type_instance_flags instance_flags() const
Definition: gdbtypes.h:1016
unsigned m_instance_flags
Definition: gdbtypes.h:1441
unsigned short bit_offset() const
Definition: gdbtypes.h:1387
void set_fields(struct field *fields)
Definition: gdbtypes.h:990
void set_target_is_stub(bool target_is_stub)
Definition: gdbtypes.h:1112
bool is_objfile_owned() const
Definition: gdbtypes.h:1316
unsigned short bit_size() const
Definition: gdbtypes.h:1379
int discriminant_index
Definition: gdbtypes.h:278
gdb::array_view< variant > variants
Definition: gdbtypes.h:286
bool is_unsigned
Definition: gdbtypes.h:282
int last_field
Definition: gdbtypes.h:250
bool matches(ULONGEST value, bool is_unsigned) const
gdb::array_view< variant_part > parts
Definition: gdbtypes.h:253
int first_field
Definition: gdbtypes.h:249
bool is_default() const
Definition: gdbtypes.h:258
gdb::array_view< discriminant_range > discriminants
Definition: gdbtypes.h:243
cu_offset param_cu_off
Definition: gdbtypes.h:1861
LONGEST const_val
Definition: gdbtypes.h:306
struct type * original_type
Definition: gdbtypes.h:325
const char * variable_name
Definition: gdbtypes.h:330
const gdb::array_view< variant_part > * variant_parts
Definition: gdbtypes.h:319
struct dwarf2_locexpr_baton * dwarf_block
Definition: gdbtypes.h:554
LONGEST bitpos
Definition: gdbtypes.h:537
CORE_ADDR physaddr
Definition: gdbtypes.h:547
const char * physname
Definition: gdbtypes.h:548
LONGEST enumval
Definition: gdbtypes.h:540
struct objfile * objfile
Definition: gdbtypes.h:526
struct gdbarch * gdbarch
Definition: gdbtypes.h:527
struct gnat_aux_type * gnat_stuff
Definition: gdbtypes.h:746
struct fixed_point_type_info * fixed_point_info
Definition: gdbtypes.h:766
const struct floatformat * floatformat
Definition: gdbtypes.h:752
unsigned short bit_offset
Definition: gdbtypes.h:780
struct type * self_type
Definition: gdbtypes.h:762
struct cplus_struct_type * cplus_stuff
Definition: gdbtypes.h:741
struct func_type * func_stuff
Definition: gdbtypes.h:756
struct type_specific::@0 int_stuff
unsigned short bit_size
Definition: gdbtypes.h:776