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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
|
/* Interface between GCC C FE and GDB -*- c -*-
Copyright (C) 2014-2016 Free Software Foundation, Inc.
This file is part of GCC.
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/>. */
/* Create a new "decl" in GCC. A decl is a declaration, basically a
kind of symbol.
NAME is the name of the new symbol. SYM_KIND is the kind of
symbol being requested. SYM_TYPE is the new symbol's C type;
except for labels, where this is not meaningful and should be
zero. If SUBSTITUTION_NAME is not NULL, then a reference to this
decl in the source will later be substituted with a dereference
of a variable of the given name. Otherwise, for symbols having
an address (e.g., functions), ADDRESS is the address. FILENAME
and LINE_NUMBER refer to the symbol's source location. If this
is not known, FILENAME can be NULL and LINE_NUMBER can be 0.
This function returns the new decl. */
GCC_METHOD7 (gcc_decl, build_decl,
const char *, /* Argument NAME. */
enum gcc_c_symbol_kind, /* Argument SYM_KIND. */
gcc_type, /* Argument SYM_TYPE. */
const char *, /* Argument SUBSTITUTION_NAME. */
gcc_address, /* Argument ADDRESS. */
const char *, /* Argument FILENAME. */
unsigned int) /* Argument LINE_NUMBER. */
/* Insert a GCC decl into the symbol table. DECL is the decl to
insert. IS_GLOBAL is true if this is an outermost binding, and
false if it is a possibly-shadowing binding. */
GCC_METHOD2 (int /* bool */, bind,
gcc_decl, /* Argument DECL. */
int /* bool */) /* Argument IS_GLOBAL. */
/* Insert a tagged type into the symbol table. NAME is the tag name
of the type and TAGGED_TYPE is the type itself. TAGGED_TYPE must
be either a struct, union, or enum type, as these are the only
types that have tags. FILENAME and LINE_NUMBER refer to the type's
source location. If this is not known, FILENAME can be NULL and
LINE_NUMBER can be 0. */
GCC_METHOD4 (int /* bool */, tagbind,
const char *, /* Argument NAME. */
gcc_type, /* Argument TAGGED_TYPE. */
const char *, /* Argument FILENAME. */
unsigned int) /* Argument LINE_NUMBER. */
/* Return the type of a pointer to a given base type. */
GCC_METHOD1 (gcc_type, build_pointer_type,
gcc_type) /* Argument BASE_TYPE. */
/* Create a new 'struct' type. Initially it has no fields. */
GCC_METHOD0 (gcc_type, build_record_type)
/* Create a new 'union' type. Initially it has no fields. */
GCC_METHOD0 (gcc_type, build_union_type)
/* Add a field to a struct or union type. FIELD_NAME is the field's
name. FIELD_TYPE is the type of the field. BITSIZE and BITPOS
indicate where in the struct the field occurs. */
GCC_METHOD5 (int /* bool */, build_add_field,
gcc_type, /* Argument RECORD_OR_UNION_TYPE. */
const char *, /* Argument FIELD_NAME. */
gcc_type, /* Argument FIELD_TYPE. */
unsigned long, /* Argument BITSIZE. */
unsigned long) /* Argument BITPOS. */
/* After all the fields have been added to a struct or union, the
struct or union type must be "finished". This does some final
cleanups in GCC. */
GCC_METHOD2 (int /* bool */, finish_record_or_union,
gcc_type, /* Argument RECORD_OR_UNION_TYPE. */
unsigned long) /* Argument SIZE_IN_BYTES. */
/* Create a new 'enum' type. The new type initially has no
associated constants. */
GCC_METHOD1 (gcc_type, build_enum_type,
gcc_type) /* Argument UNDERLYING_INT_TYPE. */
/* Add a new constant to an enum type. NAME is the constant's
name and VALUE is its value. */
GCC_METHOD3 (int /* bool */, build_add_enum_constant,
gcc_type, /* Argument ENUM_TYPE. */
const char *, /* Argument NAME. */
unsigned long) /* Argument VALUE. */
/* After all the constants have been added to an enum, the type must
be "finished". This does some final cleanups in GCC. */
GCC_METHOD1 (int /* bool */, finish_enum_type,
gcc_type) /* Argument ENUM_TYPE. */
/* Create a new function type. RETURN_TYPE is the type returned by
the function, and ARGUMENT_TYPES is a vector, of length NARGS, of
the argument types. IS_VARARGS is true if the function is
varargs. */
GCC_METHOD3 (gcc_type, build_function_type,
gcc_type, /* Argument RETURN_TYPE. */
const struct gcc_type_array *, /* Argument ARGUMENT_TYPES. */
int /* bool */) /* Argument IS_VARARGS. */
/* Return an integer type with the given properties. */
GCC_METHOD2 (gcc_type, int_type,
int /* bool */, /* Argument IS_UNSIGNED. */
unsigned long) /* Argument SIZE_IN_BYTES. */
/* Return a floating point type with the given properties. */
GCC_METHOD1 (gcc_type, float_type,
unsigned long) /* Argument SIZE_IN_BYTES. */
/* Return the 'void' type. */
GCC_METHOD0 (gcc_type, void_type)
/* Return the 'bool' type. */
GCC_METHOD0 (gcc_type, bool_type)
/* Create a new array type. If NUM_ELEMENTS is -1, then the array
is assumed to have an unknown length. */
GCC_METHOD2 (gcc_type, build_array_type,
gcc_type, /* Argument ELEMENT_TYPE. */
int) /* Argument NUM_ELEMENTS. */
/* Create a new variably-sized array type. UPPER_BOUND_NAME is the
name of a local variable that holds the upper bound of the array;
it is one less than the array size. */
GCC_METHOD2 (gcc_type, build_vla_array_type,
gcc_type, /* Argument ELEMENT_TYPE. */
const char *) /* Argument UPPER_BOUND_NAME. */
/* Return a qualified variant of a given base type. QUALIFIERS says
which qualifiers to use; it is composed of or'd together
constants from 'enum gcc_qualifiers'. */
GCC_METHOD2 (gcc_type, build_qualified_type,
gcc_type, /* Argument UNQUALIFIED_TYPE. */
enum gcc_qualifiers) /* Argument QUALIFIERS. */
/* Build a complex type given its element type. */
GCC_METHOD1 (gcc_type, build_complex_type,
gcc_type) /* Argument ELEMENT_TYPE. */
/* Build a vector type given its element type and number of
elements. */
GCC_METHOD2 (gcc_type, build_vector_type,
gcc_type, /* Argument ELEMENT_TYPE. */
int) /* Argument NUM_ELEMENTS. */
/* Build a constant. NAME is the constant's name and VALUE is its
value. FILENAME and LINE_NUMBER refer to the type's source
location. If this is not known, FILENAME can be NULL and
LINE_NUMBER can be 0. */
GCC_METHOD5 (int /* bool */, build_constant,
gcc_type, /* Argument TYPE. */
const char *, /* Argument NAME. */
unsigned long, /* Argument VALUE. */
const char *, /* Argument FILENAME. */
unsigned int) /* Argument LINE_NUMBER. */
/* Emit an error and return an error type object. */
GCC_METHOD1 (gcc_type, error,
const char *) /* Argument MESSAGE. */
|
