GDB (xrefs)

compile-c-types.c
Go to the documentation of this file.
1 /* Convert types from GDB to GCC
2
3 Copyright (C) 2014-2018 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 "objfiles.h"
25
26 /* An object that maps a gdb type to a gcc type. */
27
28 struct type_map_instance
29 {
30 /* The gdb type. */
31
32 struct type *type;
33
34 /* The corresponding gcc type handle. */
35
36 gcc_type gcc_type_handle;
37 };
38
39 /* Hash a type_map_instance. */
40
41 static hashval_t
42 hash_type_map_instance (const void *p)
43 {
44 const struct type_map_instance *inst = (const struct type_map_instance *) p;
45
46 return htab_hash_pointer (inst->type);
47 }
48
49 /* Check two type_map_instance objects for equality. */
50
51 static int
52 eq_type_map_instance (const void *a, const void *b)
53 {
54 const struct type_map_instance *insta = (const struct type_map_instance *) a;
55 const struct type_map_instance *instb = (const struct type_map_instance *) b;
56
57 return insta->type == instb->type;
58 }
59
60
61
62 /* Insert an entry into the type map associated with CONTEXT that maps
63 from the gdb type TYPE to the gcc type GCC_TYPE. It is ok for a
64 given type to be inserted more than once, provided that the exact
65 same association is made each time. This simplifies how type
66 caching works elsewhere in this file -- see how struct type caching
67 is handled. */
68
69 static void
70 insert_type (struct compile_c_instance *context, struct type *type,
71 gcc_type gcc_type)
72 {
73 struct type_map_instance inst, *add;
74 void **slot;
75
76 inst.type = type;
77 inst.gcc_type_handle = gcc_type;
78 slot = htab_find_slot (context->type_map, &inst, INSERT);
79
80 add = (struct type_map_instance *) *slot;
81 /* The type might have already been inserted in order to handle
82 recursive types. */
83 if (add != NULL && add->gcc_type_handle != gcc_type)
84 error (_("Unexpected type id from GCC, check you use recent enough GCC."));
85
86 if (add == NULL)
87 {
88 add = XNEW (struct type_map_instance);
89 *add = inst;
90 *slot = add;
91 }
92 }
93
94 /* Convert a pointer type to its gcc representation. */
95
96 static gcc_type
97 convert_pointer (struct compile_c_instance *context, struct type *type)
98 {
99 gcc_type target = convert_type (context, TYPE_TARGET_TYPE (type));
100
101 return C_CTX (context)->c_ops->build_pointer_type (C_CTX (context),
102 target);
103 }
104
105 /* Convert an array type to its gcc representation. */
106
107 static gcc_type
108 convert_array (struct compile_c_instance *context, struct type *type)
109 {
110 gcc_type element_type;
111 struct type *range = TYPE_INDEX_TYPE (type);
112
113 element_type = convert_type (context, TYPE_TARGET_TYPE (type));
114
115 if (TYPE_LOW_BOUND_KIND (range) != PROP_CONST)
116 return C_CTX (context)->c_ops->error (C_CTX (context),
117 _("array type with non-constant"
118 " lower bound is not supported"));
119 if (TYPE_LOW_BOUND (range) != 0)
120 return C_CTX (context)->c_ops->error (C_CTX (context),
121 _("cannot convert array type with "
122 "non-zero lower bound to C"));
123
124 if (TYPE_HIGH_BOUND_KIND (range) == PROP_LOCEXPR
125 || TYPE_HIGH_BOUND_KIND (range) == PROP_LOCLIST)
126 {
127 gcc_type result;
128
129 if (TYPE_VECTOR (type))
130 return C_CTX (context)->c_ops->error (C_CTX (context),
131 _("variably-sized vector type"
132 " is not supported"));
133
134 std::string upper_bound
135 = c_get_range_decl_name (&TYPE_RANGE_DATA (range)->high);
136 result = C_CTX (context)->c_ops->build_vla_array_type (C_CTX (context),
137 element_type,
138 upper_bound.c_str ());
139 return result;
140 }
141 else
142 {
143 LONGEST low_bound, high_bound, count;
144
145 if (get_array_bounds (type, &low_bound, &high_bound) == 0)
146 count = -1;
147 else
148 {
149 gdb_assert (low_bound == 0); /* Ensured above. */
150 count = high_bound + 1;
151 }
152
153 if (TYPE_VECTOR (type))
154 return C_CTX (context)->c_ops->build_vector_type (C_CTX (context),
155 element_type,
156 count);
157 return C_CTX (context)->c_ops->build_array_type (C_CTX (context),
158 element_type, count);
159 }
160 }
161
162 /* Convert a struct or union type to its gcc representation. */
163
164 static gcc_type
165 convert_struct_or_union (struct compile_c_instance *context, struct type *type)
166 {
167 int i;
168 gcc_type result;
169
170 /* First we create the resulting type and enter it into our hash
171 table. This lets recursive types work. */
172 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
173 result = C_CTX (context)->c_ops->build_record_type (C_CTX (context));
174 else
175 {
176 gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
177 result = C_CTX (context)->c_ops->build_union_type (C_CTX (context));
178 }
179 insert_type (context, type, result);
180
181 for (i = 0; i < TYPE_NFIELDS (type); ++i)
182 {
183 gcc_type field_type;
184 unsigned long bitsize = TYPE_FIELD_BITSIZE (type, i);
185
186 field_type = convert_type (context, TYPE_FIELD_TYPE (type, i));
187 if (bitsize == 0)
188 bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (type, i));
189 C_CTX (context)->c_ops->build_add_field (C_CTX (context), result,
190 TYPE_FIELD_NAME (type, i),
191 field_type,
192 bitsize,
193 TYPE_FIELD_BITPOS (type, i));
194 }
195
196 C_CTX (context)->c_ops->finish_record_or_union (C_CTX (context), result,
197 TYPE_LENGTH (type));
198 return result;
199 }
200
201 /* Convert an enum type to its gcc representation. */
202
203 static gcc_type
204 convert_enum (struct compile_c_instance *context, struct type *type)
205 {
206 gcc_type int_type, result;
207 int i;
208 struct gcc_c_context *ctx = C_CTX (context);
209
210 int_type = ctx->c_ops->int_type_v0 (ctx,
211 TYPE_UNSIGNED (type),
212 TYPE_LENGTH (type));
213
214 result = ctx->c_ops->build_enum_type (ctx, int_type);
215 for (i = 0; i < TYPE_NFIELDS (type); ++i)
216 {
217 ctx->c_ops->build_add_enum_constant (ctx,
218 result,
219 TYPE_FIELD_NAME (type, i),
220 TYPE_FIELD_ENUMVAL (type, i));
221 }
222
223 ctx->c_ops->finish_enum_type (ctx, result);
224
225 return result;
226 }
227
228 /* Convert a function type to its gcc representation. */
229
230 static gcc_type
231 convert_func (struct compile_c_instance *context, struct type *type)
232 {
233 int i;
234 gcc_type result, return_type;
235 struct gcc_type_array array;
236 int is_varargs = TYPE_VARARGS (type) || !TYPE_PROTOTYPED (type);
237
238 struct type *target_type = TYPE_TARGET_TYPE (type);
239
240 /* Functions with no debug info have no return type. Ideally we'd
241 want to fallback to the type of the cast just before the
242 function, like GDB's built-in expression parser, but we don't
243 have access to that type here. For now, fallback to int, like
244 GDB's parser used to do. */
245 if (target_type == NULL)
246 {
247 if (TYPE_OBJFILE_OWNED (type))
248 target_type = objfile_type (TYPE_OWNER (type).objfile)->builtin_int;
249 else
250 target_type = builtin_type (TYPE_OWNER (type).gdbarch)->builtin_int;
251 warning (_("function has unknown return type; assuming int"));
252 }
253
254 /* This approach means we can't make self-referential function
255 types. Those are impossible in C, though. */
256 return_type = convert_type (context, target_type);
257
258 array.n_elements = TYPE_NFIELDS (type);
259 array.elements = XNEWVEC (gcc_type, TYPE_NFIELDS (type));
260 for (i = 0; i < TYPE_NFIELDS (type); ++i)
261 array.elements[i] = convert_type (context, TYPE_FIELD_TYPE (type, i));
262
263 result = C_CTX (context)->c_ops->build_function_type (C_CTX (context),
264 return_type,
265 &array, is_varargs);
266 xfree (array.elements);
267
268 return result;
269 }
270
271 /* Convert an integer type to its gcc representation. */
272
273 static gcc_type
274 convert_int (struct compile_c_instance *context, struct type *type)
275 {
276 return C_CTX (context)->c_ops->int_type_v0 (C_CTX (context),
277 TYPE_UNSIGNED (type),
278 TYPE_LENGTH (type));
279 }
280
281 /* Convert a floating-point type to its gcc representation. */
282
283 static gcc_type
284 convert_float (struct compile_c_instance *context, struct type *type)
285 {
286 return C_CTX (context)->c_ops->float_type_v0 (C_CTX (context),
287 TYPE_LENGTH (type));
288 }
289
290 /* Convert the 'void' type to its gcc representation. */
291
292 static gcc_type
293 convert_void (struct compile_c_instance *context, struct type *type)
294 {
295 return C_CTX (context)->c_ops->void_type (C_CTX (context));
296 }
297
298 /* Convert a boolean type to its gcc representation. */
299
300 static gcc_type
301 convert_bool (struct compile_c_instance *context, struct type *type)
302 {
303 return C_CTX (context)->c_ops->bool_type (C_CTX (context));
304 }
305
306 /* Convert a qualified type to its gcc representation. */
307
308 static gcc_type
309 convert_qualified (struct compile_c_instance *context, struct type *type)
310 {
311 struct type *unqual = make_unqualified_type (type);
312 gcc_type unqual_converted;
313 gcc_qualifiers_flags quals = 0;
314
315 unqual_converted = convert_type (context, unqual);
316
317 if (TYPE_CONST (type))
318 quals |= GCC_QUALIFIER_CONST;
319 if (TYPE_VOLATILE (type))
320 quals |= GCC_QUALIFIER_VOLATILE;
321 if (TYPE_RESTRICT (type))
322 quals |= GCC_QUALIFIER_RESTRICT;
323
324 return C_CTX (context)->c_ops->build_qualified_type (C_CTX (context),
325 unqual_converted,
326 quals);
327 }
328
329 /* Convert a complex type to its gcc representation. */
330
331 static gcc_type
332 convert_complex (struct compile_c_instance *context, struct type *type)
333 {
334 gcc_type base = convert_type (context, TYPE_TARGET_TYPE (type));
335
336 return C_CTX (context)->c_ops->build_complex_type (C_CTX (context), base);
337 }
338
339 /* A helper function which knows how to convert most types from their
340 gdb representation to the corresponding gcc form. This examines
341 the TYPE and dispatches to the appropriate conversion function. It
342 returns the gcc type. */
343
344 static gcc_type
345 convert_type_basic (struct compile_c_instance *context, struct type *type)
346 {
347 /* If we are converting a qualified type, first convert the
348 unqualified type and then apply the qualifiers. */
349 if ((TYPE_INSTANCE_FLAGS (type) & (TYPE_INSTANCE_FLAG_CONST
350 | TYPE_INSTANCE_FLAG_VOLATILE
351 | TYPE_INSTANCE_FLAG_RESTRICT)) != 0)
352 return convert_qualified (context, type);
353
354 switch (TYPE_CODE (type))
355 {
356 case TYPE_CODE_PTR:
357 return convert_pointer (context, type);
358
359 case TYPE_CODE_ARRAY:
360 return convert_array (context, type);
361
362 case TYPE_CODE_STRUCT:
363 case TYPE_CODE_UNION:
364 return convert_struct_or_union (context, type);
365
366 case TYPE_CODE_ENUM:
367 return convert_enum (context, type);
368
369 case TYPE_CODE_FUNC:
370 return convert_func (context, type);
371
372 case TYPE_CODE_INT:
373 return convert_int (context, type);
374
375 case TYPE_CODE_FLT:
376 return convert_float (context, type);
377
378 case TYPE_CODE_VOID:
379 return convert_void (context, type);
380
381 case TYPE_CODE_BOOL:
382 return convert_bool (context, type);
383
384 case TYPE_CODE_COMPLEX:
385 return convert_complex (context, type);
386
387 case TYPE_CODE_ERROR:
388 {
389 /* Ideally, if we get here due to a cast expression, we'd use
390 the cast-to type as the variable's type, like GDB's
391 built-in parser does. For now, assume "int" like GDB's
392 built-in parser used to do, but at least warn. */
393 struct type *fallback;
394 if (TYPE_OBJFILE_OWNED (type))
395 fallback = objfile_type (TYPE_OWNER (type).objfile)->builtin_int;
396 else
397 fallback = builtin_type (TYPE_OWNER (type).gdbarch)->builtin_int;
398 warning (_("variable has unknown type; assuming int"));
399 return convert_int (context, fallback);
400 }
401 }
402
403 return C_CTX (context)->c_ops->error (C_CTX (context),
404 _("cannot convert gdb type "
405 "to gcc type"));
406 }
407
408 /* See compile-internal.h. */
409
410 gcc_type
411 convert_type (struct compile_c_instance *context, struct type *type)
412 {
413 struct type_map_instance inst, *found;
414 gcc_type result;
415
416 /* We don't ever have to deal with typedefs in this code, because
417 those are only needed as symbols by the C compiler. */
418 type = check_typedef (type);
419
420 inst.type = type;
421 found = (struct type_map_instance *) htab_find (context->type_map, &inst);
422 if (found != NULL)
423 return found->gcc_type_handle;
424
425 result = convert_type_basic (context, type);
426 insert_type (context, type, result);
427 return result;
428 }
429
430
431
432 /* Delete the compiler instance C. */
433
434 static void
435 delete_instance (struct compile_instance *c)
436 {
437 struct compile_c_instance *context = (struct compile_c_instance *) c;
438
439 context->base.fe->ops->destroy (context->base.fe);
440 htab_delete (context->type_map);
441 if (context->symbol_err_map != NULL)
442 htab_delete (context->symbol_err_map);
443 xfree (context);
444 }
445
446 /* See compile-internal.h. */
447
448 struct compile_instance *
449 new_compile_instance (struct gcc_c_context *fe)
450 {
451 struct compile_c_instance *result = XCNEW (struct compile_c_instance);
452
453 result->base.fe = &fe->base;
454 result->base.destroy = delete_instance;
455 result->base.gcc_target_options = ("-std=gnu11"
456 /* Otherwise the .o file may need
457 "_Unwind_Resume" and
458 "__gcc_personality_v0". */
459 " -fno-exceptions");
460
461 result->type_map = htab_create_alloc (10, hash_type_map_instance,
462 eq_type_map_instance,
463 xfree, xcalloc, xfree);
464
465 fe->c_ops->set_callbacks (fe, gcc_convert_symbol,
466 gcc_symbol_address, result);
467
468 return &result->base;
469 }
c_get_range_decl_name
std::string c_get_range_decl_name(const struct dynamic_prop *prop)
Definition: compile-c-support.c:62
TYPE_HIGH_BOUND_KIND
#define TYPE_HIGH_BOUND_KIND(range_type)
Definition: gdbtypes.h:1252
gdbarch
Definition: gdbarch.c:127
string
const char * string
Definition: signals.c:50
TYPE_CODE_BOOL
Definition: gdbtypes.h:164
compile_c_instance
Definition: compile-internal.h:62
TYPE_CODE_ARRAY
Definition: gdbtypes.h:104
convert_array
static gcc_type convert_array(struct compile_c_instance *context, struct type *type)
Definition: compile-c-types.c:108
TYPE_RANGE_DATA
#define TYPE_RANGE_DATA(thistype)
Definition: gdbtypes.h:1243
TYPE_OBJFILE_OWNED
#define TYPE_OBJFILE_OWNED(t)
Definition: gdbtypes.h:289
TYPE_CODE_ENUM
Definition: gdbtypes.h:108
TYPE_FIELD_NAME
#define TYPE_FIELD_NAME(thistype, n)
Definition: gdbtypes.h:1372
compile_instance::gcc_target_options
const char * gcc_target_options
Definition: compile-internal.h:53
xfree
void xfree(void *)
TYPE_LOW_BOUND
#define TYPE_LOW_BOUND(range_type)
Definition: gdbtypes.h:1244
make_unqualified_type
struct type * make_unqualified_type(struct type *type)
Definition: gdbtypes.c:747
compile_c_instance::base
struct compile_instance base
Definition: compile-internal.h:67
warning
void warning(const char *fmt,...)
Definition: errors.c:26
TYPE_INSTANCE_FLAG_CONST
Definition: gdbtypes.h:189
convert_struct_or_union
static gcc_type convert_struct_or_union(struct compile_c_instance *context, struct type *type)
Definition: compile-c-types.c:165
TYPE_VOLATILE
#define TYPE_VOLATILE(t)
Definition: gdbtypes.h:315
builtin_type
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:5217
objfile_type
const struct objfile_type * objfile_type(struct objfile *objfile)
Definition: gdbtypes.c:5363
TYPE_CODE_INT
Definition: gdbtypes.h:111
type_map_instance::gcc_type_handle
gcc_type gcc_type_handle
Definition: compile-c-types.c:36
compile_c_instance::symbol_err_map
htab_t symbol_err_map
Definition: compile-internal.h:75
convert_enum
static gcc_type convert_enum(struct compile_c_instance *context, struct type *type)
Definition: compile-c-types.c:204
convert_qualified
static gcc_type convert_qualified(struct compile_c_instance *context, struct type *type)
Definition: compile-c-types.c:309
insert_type
static void insert_type(struct compile_c_instance *context, struct type *type, gcc_type gcc_type)
Definition: compile-c-types.c:70
_
#define _(String)
Definition: gdb_locale.h:35
defs.h
TYPE_OWNER
#define TYPE_OWNER(t)
Definition: gdbtypes.h:290
compile_c_instance::type_map
htab_t type_map
Definition: compile-internal.h:71
TYPE_PROTOTYPED
#define TYPE_PROTOTYPED(t)
Definition: gdbtypes.h:232
TYPE_FIELD_ENUMVAL
#define TYPE_FIELD_ENUMVAL(thistype, n)
Definition: gdbtypes.h:1375
TYPE_FIELD_TYPE
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1371
objfiles.h
XNEW
#define XNEW(T)
Definition: poison.h:109
TYPE_CODE_VOID
Definition: gdbtypes.h:124
gcc_symbol_address
gcc_c_symbol_address_function gcc_symbol_address
TYPE_INSTANCE_FLAGS
#define TYPE_INSTANCE_FLAGS(thistype)
Definition: gdbtypes.h:1222
C_CTX
#define C_CTX(I)
Definition: compile-internal.h:81
check_typedef
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2421
PROP_LOCEXPR
Definition: gdbtypes.h:381
convert_void
static gcc_type convert_void(struct compile_c_instance *context, struct type *type)
Definition: compile-c-types.c:293
eq_type_map_instance
static int eq_type_map_instance(const void *a, const void *b)
Definition: compile-c-types.c:52
convert_func
static gcc_type convert_func(struct compile_c_instance *context, struct type *type)
Definition: compile-c-types.c:231
PROP_CONST
Definition: gdbtypes.h:379
convert_complex
static gcc_type convert_complex(struct compile_c_instance *context, struct type *type)
Definition: compile-c-types.c:332
TYPE_VECTOR
#define TYPE_VECTOR(t)
Definition: gdbtypes.h:252
type_map_instance::type
struct type * type
Definition: compile-c-types.c:32
TYPE_CODE_FLT
Definition: gdbtypes.h:116
convert_int
static gcc_type convert_int(struct compile_c_instance *context, struct type *type)
Definition: compile-c-types.c:274
TYPE_CODE_UNION
Definition: gdbtypes.h:107
type
Definition: gdbtypes.h:749
delete_instance
static void delete_instance(struct compile_instance *c)
Definition: compile-c-types.c:435
type
static const char * type
Definition: language.c:113
gcc_convert_symbol
gcc_c_oracle_function gcc_convert_symbol
range
Definition: value.c:62
TYPE_CODE_STRUCT
Definition: gdbtypes.h:106
TYPE_FIELD_BITSIZE
#define TYPE_FIELD_BITSIZE(thistype, n)
Definition: gdbtypes.h:1380
TYPE_CODE_ERROR
Definition: gdbtypes.h:138
TYPE_CODE_FUNC
Definition: gdbtypes.h:110
TYPE_FIELD_BITPOS
#define TYPE_FIELD_BITPOS(thistype, n)
Definition: gdbtypes.h:1374
TYPE_UNSIGNED
#define TYPE_UNSIGNED(t)
Definition: gdbtypes.h:205
compile_instance
Definition: compile-internal.h:36
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
type_map_instance
Definition: compile-c-types.c:28
objfile_type::builtin_int
struct type * builtin_int
Definition: gdbtypes.h:1594
compile_instance::destroy
void(* destroy)(struct compile_instance *)
Definition: compile-internal.h:57
objfile
Definition: objfiles.h:286
TYPE_CODE_PTR
Definition: gdbtypes.h:84
convert_pointer
static gcc_type convert_pointer(struct compile_c_instance *context, struct type *type)
Definition: compile-c-types.c:97
XNEWVEC
#define XNEWVEC(T, N)
Definition: poison.h:145
TYPE_VARARGS
#define TYPE_VARARGS(t)
Definition: gdbtypes.h:247
convert_bool
static gcc_type convert_bool(struct compile_c_instance *context, struct type *type)
Definition: compile-c-types.c:301
TYPE_TARGET_TYPE
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1226
PROP_LOCLIST
Definition: gdbtypes.h:382
TYPE_RESTRICT
#define TYPE_RESTRICT(t)
Definition: gdbtypes.h:321
XCNEW
#define XCNEW(T)
Definition: poison.h:121
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
TYPE_INDEX_TYPE
#define TYPE_INDEX_TYPE(type)
Definition: gdbtypes.h:1242
compile_instance::fe
struct gcc_base_context * fe
Definition: compile-internal.h:40
compile-internal.h
hash_type_map_instance
static hashval_t hash_type_map_instance(const void *p)
Definition: compile-c-types.c:42
TYPE_LOW_BOUND_KIND
#define TYPE_LOW_BOUND_KIND(range_type)
Definition: gdbtypes.h:1254
TYPE_NFIELDS
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1239
TYPE_INSTANCE_FLAG_RESTRICT
Definition: gdbtypes.h:196
convert_type_basic
static gcc_type convert_type_basic(struct compile_c_instance *context, struct type *type)
Definition: compile-c-types.c:345
gdbtypes.h
new_compile_instance
struct compile_instance * new_compile_instance(struct gcc_c_context *fe)
Definition: compile-c-types.c:449
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
TYPE_INSTANCE_FLAG_VOLATILE
Definition: gdbtypes.h:190
convert_type
gcc_type convert_type(struct compile_c_instance *context, struct type *type)
Definition: compile-c-types.c:411
xcalloc
PTR xcalloc(size_t number, size_t size)
Definition: common-utils.c:72
get_array_bounds
int get_array_bounds(struct type *type, LONGEST *low_bound, LONGEST *high_bound)
Definition: gdbtypes.c:1056
TYPE_CONST
#define TYPE_CONST(t)
Definition: gdbtypes.h:310
error
void error(const char *fmt,...)
Definition: errors.c:38
convert_float
static gcc_type convert_float(struct compile_c_instance *context, struct type *type)
Definition: compile-c-types.c:284
LONGEST
long long LONGEST
Definition: common-types.h:52
TYPE_CODE_COMPLEX
Definition: gdbtypes.h:167
builtin_type::builtin_int
struct type * builtin_int
Definition: gdbtypes.h:1503