1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
/* Type codes for GDB.
Copyright (C) 1992-2023 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
OP (TYPE_CODE_PTR) /**< Pointer type */
/* * Array type with lower & upper bounds.
Regardless of the language, GDB represents multidimensional
array types the way C does: as arrays of arrays. So an
instance of a GDB array type T can always be seen as a series
of instances of T->target_type () laid out sequentially in
memory.
Row-major languages like C lay out multi-dimensional arrays so
that incrementing the rightmost index in a subscripting
expression results in the smallest change in the address of the
element referred to. Column-major languages like Fortran lay
them out so that incrementing the leftmost index results in the
smallest change.
This means that, in column-major languages, working our way
from type to target type corresponds to working through indices
from right to left, not left to right. */
OP (TYPE_CODE_ARRAY)
OP (TYPE_CODE_STRUCT) /**< C struct or Pascal record */
OP (TYPE_CODE_UNION) /**< C union or Pascal variant part */
OP (TYPE_CODE_ENUM) /**< Enumeration type */
OP (TYPE_CODE_FLAGS) /**< Bit flags type */
OP (TYPE_CODE_FUNC) /**< Function type */
OP (TYPE_CODE_INT) /**< Integer type */
/* * Floating type. This is *NOT* a complex type. */
OP (TYPE_CODE_FLT)
/* * Void type. The length field specifies the length (probably
always one) which is used in pointer arithmetic involving
pointers to this type, but actually dereferencing such a
pointer is invalid; a void type has no length and no actual
representation in memory or registers. A pointer to a void
type is a generic pointer. */
OP (TYPE_CODE_VOID)
OP (TYPE_CODE_SET) /**< Pascal sets */
OP (TYPE_CODE_RANGE) /**< Range (integers within spec'd bounds). */
/* * A string type which is like an array of character but prints
differently. It does not contain a length field as Pascal
strings (for many Pascals, anyway) do; if we want to deal with
such strings, we should use a new type code. */
OP (TYPE_CODE_STRING)
/* * Unknown type. The length field is valid if we were able to
deduce that much about the type, or 0 if we don't even know
that. */
OP (TYPE_CODE_ERROR)
/* C++ */
OP (TYPE_CODE_METHOD) /**< Method type */
/* * Pointer-to-member-function type. This describes how to access a
particular member function of a class (possibly a virtual
member function). The representation may vary between different
C++ ABIs. */
OP (TYPE_CODE_METHODPTR)
/* * Pointer-to-member type. This is the offset within a class to
some particular data member. The only currently supported
representation uses an unbiased offset, with -1 representing
NULL; this is used by the Itanium C++ ABI (used by GCC on all
platforms). */
OP (TYPE_CODE_MEMBERPTR)
OP (TYPE_CODE_REF) /**< C++ Reference types */
OP (TYPE_CODE_RVALUE_REF) /**< C++ rvalue reference types */
OP (TYPE_CODE_CHAR) /**< *real* character type */
/* * Boolean type. 0 is false, 1 is true, and other values are
non-boolean (e.g. FORTRAN "logical" used as unsigned int). */
OP (TYPE_CODE_BOOL)
/* Fortran */
OP (TYPE_CODE_COMPLEX) /**< Complex float */
OP (TYPE_CODE_TYPEDEF)
OP (TYPE_CODE_NAMESPACE) /**< C++ namespace. */
OP (TYPE_CODE_DECFLOAT) /**< Decimal floating point. */
OP (TYPE_CODE_MODULE) /**< Fortran module. */
/* * Internal function type. */
OP (TYPE_CODE_INTERNAL_FUNCTION)
/* * Methods implemented in extension languages. */
OP (TYPE_CODE_XMETHOD)
/* * Fixed Point type. */
OP (TYPE_CODE_FIXED_POINT)
/* * Fortran namelist is a group of variables or arrays that can be
read or written.
Namelist syntax: NAMELIST / groupname / namelist_items ...
NAMELIST statement assign a group name to a collection of variables
called as namelist items. The namelist items can be of any data type
and can be variables or arrays.
Compiler emit DW_TAG_namelist for group name and DW_TAG_namelist_item
for each of the namelist items. GDB process these namelist dies
and print namelist variables during print and ptype commands. */
OP (TYPE_CODE_NAMELIST)
|
