GDB (xrefs)
Loading...
Searching...
No Matches
compile-c-types.c
Go to the documentation of this file.
1/* Convert types from GDB to GCC
2
3 Copyright (C) 2014-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20
21#include "defs.h"
22#include "gdbtypes.h"
23#include "compile-internal.h"
24#include "compile-c.h"
25#include "objfiles.h"
26
27/* Convert a pointer type to its gcc representation. */
28
29static gcc_type
31{
32 gcc_type target = context->convert_type (type->target_type ());
33
34 return context->plugin ().build_pointer_type (target);
35}
36
37/* Convert an array type to its gcc representation. */
38
39static gcc_type
41{
42 gcc_type element_type;
43 struct type *range = type->index_type ();
44
45 element_type = context->convert_type (type->target_type ());
46
47 if (range->bounds ()->low.kind () != PROP_CONST)
48 return context->plugin ().error (_("array type with non-constant"
49 " lower bound is not supported"));
50 if (range->bounds ()->low.const_val () != 0)
51 return context->plugin ().error (_("cannot convert array type with "
52 "non-zero lower bound to C"));
53
54 if (range->bounds ()->high.kind () == PROP_LOCEXPR
55 || range->bounds ()->high.kind () == PROP_LOCLIST)
56 {
57 gcc_type result;
58
59 if (type->is_vector ())
60 return context->plugin ().error (_("variably-sized vector type"
61 " is not supported"));
62
63 std::string upper_bound
64 = c_get_range_decl_name (&range->bounds ()->high);
65 result = context->plugin ().build_vla_array_type (element_type,
66 upper_bound.c_str ());
67 return result;
68 }
69 else
70 {
71 LONGEST low_bound, high_bound, count;
72
73 if (!get_array_bounds (type, &low_bound, &high_bound))
74 count = -1;
75 else
76 {
77 gdb_assert (low_bound == 0); /* Ensured above. */
78 count = high_bound + 1;
79 }
80
81 if (type->is_vector ())
82 return context->plugin ().build_vector_type (element_type, count);
83 return context->plugin ().build_array_type (element_type, count);
84 }
85}
86
87/* Convert a struct or union type to its gcc representation. */
88
89static gcc_type
91{
92 int i;
93 gcc_type result;
94
95 /* First we create the resulting type and enter it into our hash
96 table. This lets recursive types work. */
97 if (type->code () == TYPE_CODE_STRUCT)
98 result = context->plugin ().build_record_type ();
99 else
100 {
101 gdb_assert (type->code () == TYPE_CODE_UNION);
102 result = context->plugin ().build_union_type ();
103 }
104 context->insert_type (type, result);
105
106 for (i = 0; i < type->num_fields (); ++i)
107 {
108 gcc_type field_type;
109 unsigned long bitsize = TYPE_FIELD_BITSIZE (type, i);
110
111 field_type = context->convert_type (type->field (i).type ());
112 if (bitsize == 0)
113 bitsize = 8 * type->field (i).type ()->length ();
114 context->plugin ().build_add_field (result,
115 type->field (i).name (),
116 field_type,
117 bitsize,
118 type->field (i).loc_bitpos ());
119 }
120
121 context->plugin ().finish_record_or_union (result, type->length ());
122 return result;
123}
124
125/* Convert an enum type to its gcc representation. */
126
127static gcc_type
129{
130 gcc_type int_type, result;
131 int i;
132
133 int_type = context->plugin ().int_type_v0 (type->is_unsigned (),
134 type->length ());
135
136 result = context->plugin ().build_enum_type (int_type);
137 for (i = 0; i < type->num_fields (); ++i)
138 {
139 context->plugin ().build_add_enum_constant
140 (result, type->field (i).name (), type->field (i).loc_enumval ());
141 }
142
143 context->plugin ().finish_enum_type (result);
144
145 return result;
146}
147
148/* Convert a function type to its gcc representation. */
149
150static gcc_type
152{
153 int i;
154 gcc_type result, return_type;
155 struct gcc_type_array array;
156 int is_varargs = type->has_varargs () || !type->is_prototyped ();
157
158 struct type *target_type = type->target_type ();
159
160 /* Functions with no debug info have no return type. Ideally we'd
161 want to fallback to the type of the cast just before the
162 function, like GDB's built-in expression parser, but we don't
163 have access to that type here. For now, fallback to int, like
164 GDB's parser used to do. */
165 if (target_type == NULL)
166 {
167 if (type->is_objfile_owned ())
169 else
171 warning (_("function has unknown return type; assuming int"));
172 }
173
174 /* This approach means we can't make self-referential function
175 types. Those are impossible in C, though. */
176 return_type = context->convert_type (target_type);
177
178 array.n_elements = type->num_fields ();
179 std::vector<gcc_type> elements (array.n_elements);
180 array.elements = elements.data ();
181 for (i = 0; i < type->num_fields (); ++i)
182 array.elements[i] = context->convert_type (type->field (i).type ());
183
184 result = context->plugin ().build_function_type (return_type,
185 &array, is_varargs);
186
187 return result;
188}
189
190/* Convert an integer type to its gcc representation. */
191
192static gcc_type
194{
195 if (context->plugin ().version () >= GCC_C_FE_VERSION_1)
196 {
197 if (type->has_no_signedness ())
198 {
199 gdb_assert (type->length () == 1);
200 return context->plugin ().char_type ();
201 }
202 return context->plugin ().int_type (type->is_unsigned (),
203 type->length (),
204 type->name ());
205 }
206 else
207 return context->plugin ().int_type_v0 (type->is_unsigned (),
208 type->length ());
209}
210
211/* Convert a floating-point type to its gcc representation. */
212
213static gcc_type
215{
216 if (context->plugin ().version () >= GCC_C_FE_VERSION_1)
217 return context->plugin ().float_type (type->length (),
218 type->name ());
219 else
220 return context->plugin ().float_type_v0 (type->length ());
221}
222
223/* Convert the 'void' type to its gcc representation. */
224
225static gcc_type
227{
228 return context->plugin ().void_type ();
229}
230
231/* Convert a boolean type to its gcc representation. */
232
233static gcc_type
235{
236 return context->plugin ().bool_type ();
237}
238
239/* Convert a qualified type to its gcc representation. */
240
241static gcc_type
243{
244 struct type *unqual = make_unqualified_type (type);
245 gcc_type unqual_converted;
246 gcc_qualifiers_flags quals = 0;
247
248 unqual_converted = context->convert_type (unqual);
249
250 if (TYPE_CONST (type))
251 quals |= GCC_QUALIFIER_CONST;
252 if (TYPE_VOLATILE (type))
253 quals |= GCC_QUALIFIER_VOLATILE;
254 if (TYPE_RESTRICT (type))
255 quals |= GCC_QUALIFIER_RESTRICT;
256
257 return context->plugin ().build_qualified_type (unqual_converted,
258 quals.raw ());
259}
260
261/* Convert a complex type to its gcc representation. */
262
263static gcc_type
265{
266 gcc_type base = context->convert_type (type->target_type ());
267
268 return context->plugin ().build_complex_type (base);
269}
270
271/* A helper function which knows how to convert most types from their
272 gdb representation to the corresponding gcc form. This examines
273 the TYPE and dispatches to the appropriate conversion function. It
274 returns the gcc type. */
275
276static gcc_type
278{
279 /* If we are converting a qualified type, first convert the
280 unqualified type and then apply the qualifiers. */
284 return convert_qualified (context, type);
285
286 switch (type->code ())
287 {
288 case TYPE_CODE_PTR:
289 return convert_pointer (context, type);
290
291 case TYPE_CODE_ARRAY:
292 return convert_array (context, type);
293
294 case TYPE_CODE_STRUCT:
295 case TYPE_CODE_UNION:
296 return convert_struct_or_union (context, type);
297
298 case TYPE_CODE_ENUM:
299 return convert_enum (context, type);
300
301 case TYPE_CODE_FUNC:
302 return convert_func (context, type);
303
304 case TYPE_CODE_INT:
305 return convert_int (context, type);
306
307 case TYPE_CODE_FLT:
308 return convert_float (context, type);
309
310 case TYPE_CODE_VOID:
311 return convert_void (context, type);
312
313 case TYPE_CODE_BOOL:
314 return convert_bool (context, type);
315
316 case TYPE_CODE_COMPLEX:
317 return convert_complex (context, type);
318
319 case TYPE_CODE_ERROR:
320 {
321 /* Ideally, if we get here due to a cast expression, we'd use
322 the cast-to type as the variable's type, like GDB's
323 built-in parser does. For now, assume "int" like GDB's
324 built-in parser used to do, but at least warn. */
325 struct type *fallback;
326 if (type->is_objfile_owned ())
327 fallback = objfile_type (type->objfile_owner ())->builtin_int;
328 else
329 fallback = builtin_type (type->arch_owner ())->builtin_int;
330 warning (_("variable has unknown type; assuming int"));
331 return convert_int (context, fallback);
332 }
333 }
334
335 return context->plugin ().error (_("cannot convert gdb type to gcc type"));
336}
337
338/* Default compile flags for C. */
339
340const char *compile_c_instance::m_default_cflags = "-std=gnu11"
341 /* Otherwise the .o file may need
342 "_Unwind_Resume" and
343 "__gcc_personality_v0". */
344 " -fno-exceptions"
345 " -Wno-implicit-function-declaration";
346
347/* See compile-c.h. */
348
349gcc_type
351{
352 /* We don't ever have to deal with typedefs in this code, because
353 those are only needed as symbols by the C compiler. */
355
356 gcc_type result;
357 if (get_cached_type (type, &result))
358 return result;
359
360 result = convert_type_basic (this, type);
361 insert_type (type, result);
362 return result;
363}
364
365
366
367/* C plug-in wrapper. */
368
369#define FORWARD(OP,...) m_context->c_ops->OP(m_context, ##__VA_ARGS__)
370#define GCC_METHOD0(R, N) \
371 R gcc_c_plugin::N () const \
372 { return FORWARD (N); }
373#define GCC_METHOD1(R, N, A) \
374 R gcc_c_plugin::N (A a) const \
375 { return FORWARD (N, a); }
376#define GCC_METHOD2(R, N, A, B) \
377 R gcc_c_plugin::N (A a, B b) const \
378 { return FORWARD (N, a, b); }
379#define GCC_METHOD3(R, N, A, B, C) \
380 R gcc_c_plugin::N (A a, B b, C c) const \
381 { return FORWARD (N, a, b, c); }
382#define GCC_METHOD4(R, N, A, B, C, D) \
383 R gcc_c_plugin::N (A a, B b, C c, D d) const \
384 { return FORWARD (N, a, b, c, d); }
385#define GCC_METHOD5(R, N, A, B, C, D, E) \
386 R gcc_c_plugin::N (A a, B b, C c, D d, E e) const \
387 { return FORWARD (N, a, b, c, d, e); }
388#define GCC_METHOD7(R, N, A, B, C, D, E, F, G) \
389 R gcc_c_plugin::N (A a, B b, C c, D d, E e, F f, G g) const \
390 { return FORWARD (N, a, b, c, d, e, f, g); }
391
392#include "gcc-c-fe.def"
393
394#undef GCC_METHOD0
395#undef GCC_METHOD1
396#undef GCC_METHOD2
397#undef GCC_METHOD3
398#undef GCC_METHOD4
399#undef GCC_METHOD5
400#undef GCC_METHOD7
401#undef FORWARD
gcc_c_plugin & plugin()
Definition compile-c.h:54
gcc_type convert_type(struct type *type)
static const char * m_default_cflags
Definition compile-c.h:58
bool get_cached_type(struct type *type, gcc_type *ret) const
Definition compile.c:147
void insert_type(struct type *type, gcc_type gcc_type)
Definition compile.c:165
int version() const
std::string c_get_range_decl_name(const struct dynamic_prop *prop)
static gcc_type convert_complex(compile_c_instance *context, struct type *type)
static gcc_type convert_func(compile_c_instance *context, struct type *type)
static gcc_type convert_qualified(compile_c_instance *context, struct type *type)
static gcc_type convert_array(compile_c_instance *context, struct type *type)
static gcc_type convert_type_basic(compile_c_instance *context, struct type *type)
static gcc_type convert_enum(compile_c_instance *context, struct type *type)
static gcc_type convert_pointer(compile_c_instance *context, struct type *type)
static gcc_type convert_bool(compile_c_instance *context, struct type *type)
static gcc_type convert_float(compile_c_instance *context, struct type *type)
static gcc_type convert_void(compile_c_instance *context, struct type *type)
static gcc_type convert_int(compile_c_instance *context, struct type *type)
static gcc_type convert_struct_or_union(compile_c_instance *context, struct type *type)
struct type * make_unqualified_type(struct type *type)
Definition gdbtypes.c:770
bool get_array_bounds(struct type *type, LONGEST *low_bound, LONGEST *high_bound)
Definition gdbtypes.c:1220
struct type * check_typedef(struct type *type)
Definition gdbtypes.c:3010
@ PROP_CONST
Definition gdbtypes.h:293
@ PROP_LOCEXPR
Definition gdbtypes.h:295
@ PROP_LOCLIST
Definition gdbtypes.h:296
#define TYPE_RESTRICT(t)
Definition gdbtypes.h:145
@ TYPE_INSTANCE_FLAG_CONST
Definition gdbtypes.h:113
@ TYPE_INSTANCE_FLAG_VOLATILE
Definition gdbtypes.h:114
@ TYPE_INSTANCE_FLAG_RESTRICT
Definition gdbtypes.h:120
#define TYPE_CONST(t)
Definition gdbtypes.h:134
#define TYPE_VOLATILE(t)
Definition gdbtypes.h:139
#define TYPE_FIELD_BITSIZE(thistype, n)
Definition gdbtypes.h:2123
struct type * builtin_int
Definition gdbtypes.h:2248
LONGEST loc_bitpos() const
Definition gdbtypes.h:586
LONGEST loc_enumval() const
Definition gdbtypes.h:598
const char * name() const
Definition gdbtypes.h:569
struct type * type() const
Definition gdbtypes.h:559
struct type * builtin_int
Definition gdbtypes.h:2343
Definition value.c:72
struct type * target_type() const
Definition gdbtypes.h:1000
type_code code() const
Definition gdbtypes.h:927
ULONGEST length() const
Definition gdbtypes.h:954
bool has_varargs() const
Definition gdbtypes.h:1135
struct field & field(int idx) const
Definition gdbtypes.h:983
bool is_unsigned() const
Definition gdbtypes.h:1063
gdbarch * arch_owner() const
Definition gdbtypes.h:1353
bool is_vector() const
Definition gdbtypes.h:1149
int num_fields() const
Definition gdbtypes.h:965
bool has_no_signedness() const
Definition gdbtypes.h:1077
struct objfile * objfile_owner() const
Definition gdbtypes.h:1342
const char * name() const
Definition gdbtypes.h:939
type * index_type() const
Definition gdbtypes.h:995
bool is_prototyped() const
Definition gdbtypes.h:1122
const type_instance_flags instance_flags() const
Definition gdbtypes.h:1016
bool is_objfile_owned() const
Definition gdbtypes.h:1316