1 /* Convert types from GDB to GCC
3 Copyright (C) 2014-2015 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
23 #include "compile-internal.h"
24 #include "gdb_assert.h"
26 /* An object that maps a gdb type to a gcc type. */
28 struct type_map_instance
34 /* The corresponding gcc type handle. */
39 /* Hash a type_map_instance. */
42 hash_type_map_instance (const void *p
)
44 const struct type_map_instance
*inst
= p
;
46 return htab_hash_pointer (inst
->type
);
49 /* Check two type_map_instance objects for equality. */
52 eq_type_map_instance (const void *a
, const void *b
)
54 const struct type_map_instance
*insta
= a
;
55 const struct type_map_instance
*instb
= b
;
57 return insta
->type
== instb
->type
;
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
70 insert_type (struct compile_c_instance
*context
, struct type
*type
,
73 struct type_map_instance inst
, *add
;
77 inst
.gcc_type
= gcc_type
;
78 slot
= htab_find_slot (context
->type_map
, &inst
, INSERT
);
81 /* The type might have already been inserted in order to handle
83 gdb_assert (add
== NULL
|| add
->gcc_type
== gcc_type
);
87 add
= XNEW (struct type_map_instance
);
93 /* Convert a pointer type to its gcc representation. */
96 convert_pointer (struct compile_c_instance
*context
, struct type
*type
)
98 gcc_type target
= convert_type (context
, TYPE_TARGET_TYPE (type
));
100 return C_CTX (context
)->c_ops
->build_pointer_type (C_CTX (context
),
104 /* Convert an array type to its gcc representation. */
107 convert_array (struct compile_c_instance
*context
, struct type
*type
)
109 gcc_type element_type
;
110 struct type
*range
= TYPE_INDEX_TYPE (type
);
112 element_type
= convert_type (context
, TYPE_TARGET_TYPE (type
));
114 if (TYPE_LOW_BOUND_KIND (range
) != PROP_CONST
)
115 return C_CTX (context
)->c_ops
->error (C_CTX (context
),
116 _("array type with non-constant"
117 " lower bound is not supported"));
118 if (TYPE_LOW_BOUND (range
) != 0)
119 return C_CTX (context
)->c_ops
->error (C_CTX (context
),
120 _("cannot convert array type with "
121 "non-zero lower bound to C"));
123 if (TYPE_HIGH_BOUND_KIND (range
) == PROP_LOCEXPR
124 || TYPE_HIGH_BOUND_KIND (range
) == PROP_LOCLIST
)
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"));
134 upper_bound
= c_get_range_decl_name (&TYPE_RANGE_DATA (range
)->high
);
135 result
= C_CTX (context
)->c_ops
->build_vla_array_type (C_CTX (context
),
143 LONGEST low_bound
, high_bound
, count
;
145 if (get_array_bounds (type
, &low_bound
, &high_bound
) == 0)
149 gdb_assert (low_bound
== 0); /* Ensured above. */
150 count
= high_bound
+ 1;
153 if (TYPE_VECTOR (type
))
154 return C_CTX (context
)->c_ops
->build_vector_type (C_CTX (context
),
157 return C_CTX (context
)->c_ops
->build_array_type (C_CTX (context
),
158 element_type
, count
);
162 /* Convert a struct or union type to its gcc representation. */
165 convert_struct_or_union (struct compile_c_instance
*context
, struct type
*type
)
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
));
176 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_UNION
);
177 result
= C_CTX (context
)->c_ops
->build_union_type (C_CTX (context
));
179 insert_type (context
, type
, result
);
181 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
184 unsigned long bitsize
= TYPE_FIELD_BITSIZE (type
, i
);
186 field_type
= convert_type (context
, TYPE_FIELD_TYPE (type
, i
));
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
),
193 TYPE_FIELD_BITPOS (type
, i
));
196 C_CTX (context
)->c_ops
->finish_record_or_union (C_CTX (context
), result
,
201 /* Convert an enum type to its gcc representation. */
204 convert_enum (struct compile_c_instance
*context
, struct type
*type
)
206 gcc_type int_type
, result
;
208 struct gcc_c_context
*ctx
= C_CTX (context
);
210 int_type
= ctx
->c_ops
->int_type (ctx
,
211 TYPE_UNSIGNED (type
),
214 result
= ctx
->c_ops
->build_enum_type (ctx
, int_type
);
215 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
217 ctx
->c_ops
->build_add_enum_constant (ctx
,
219 TYPE_FIELD_NAME (type
, i
),
220 TYPE_FIELD_ENUMVAL (type
, i
));
223 ctx
->c_ops
->finish_enum_type (ctx
, result
);
228 /* Convert a function type to its gcc representation. */
231 convert_func (struct compile_c_instance
*context
, struct type
*type
)
234 gcc_type result
, return_type
;
235 struct gcc_type_array array
;
236 int is_varargs
= TYPE_VARARGS (type
) || !TYPE_PROTOTYPED (type
);
238 /* This approach means we can't make self-referential function
239 types. Those are impossible in C, though. */
240 return_type
= convert_type (context
, TYPE_TARGET_TYPE (type
));
242 array
.n_elements
= TYPE_NFIELDS (type
);
243 array
.elements
= XNEWVEC (gcc_type
, TYPE_NFIELDS (type
));
244 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
245 array
.elements
[i
] = convert_type (context
, TYPE_FIELD_TYPE (type
, i
));
247 result
= C_CTX (context
)->c_ops
->build_function_type (C_CTX (context
),
250 xfree (array
.elements
);
255 /* Convert an integer type to its gcc representation. */
258 convert_int (struct compile_c_instance
*context
, struct type
*type
)
260 return C_CTX (context
)->c_ops
->int_type (C_CTX (context
),
261 TYPE_UNSIGNED (type
),
265 /* Convert a floating-point type to its gcc representation. */
268 convert_float (struct compile_c_instance
*context
, struct type
*type
)
270 return C_CTX (context
)->c_ops
->float_type (C_CTX (context
),
274 /* Convert the 'void' type to its gcc representation. */
277 convert_void (struct compile_c_instance
*context
, struct type
*type
)
279 return C_CTX (context
)->c_ops
->void_type (C_CTX (context
));
282 /* Convert a boolean type to its gcc representation. */
285 convert_bool (struct compile_c_instance
*context
, struct type
*type
)
287 return C_CTX (context
)->c_ops
->bool_type (C_CTX (context
));
290 /* Convert a qualified type to its gcc representation. */
293 convert_qualified (struct compile_c_instance
*context
, struct type
*type
)
295 struct type
*unqual
= make_unqualified_type (type
);
296 gcc_type unqual_converted
;
299 unqual_converted
= convert_type (context
, unqual
);
301 if (TYPE_CONST (type
))
302 quals
|= GCC_QUALIFIER_CONST
;
303 if (TYPE_VOLATILE (type
))
304 quals
|= GCC_QUALIFIER_VOLATILE
;
305 if (TYPE_RESTRICT (type
))
306 quals
|= GCC_QUALIFIER_RESTRICT
;
308 return C_CTX (context
)->c_ops
->build_qualified_type (C_CTX (context
),
313 /* Convert a complex type to its gcc representation. */
316 convert_complex (struct compile_c_instance
*context
, struct type
*type
)
318 gcc_type base
= convert_type (context
, TYPE_TARGET_TYPE (type
));
320 return C_CTX (context
)->c_ops
->build_complex_type (C_CTX (context
), base
);
323 /* A helper function which knows how to convert most types from their
324 gdb representation to the corresponding gcc form. This examines
325 the TYPE and dispatches to the appropriate conversion function. It
326 returns the gcc type. */
329 convert_type_basic (struct compile_c_instance
*context
, struct type
*type
)
331 /* If we are converting a qualified type, first convert the
332 unqualified type and then apply the qualifiers. */
333 if ((TYPE_INSTANCE_FLAGS (type
) & (TYPE_INSTANCE_FLAG_CONST
334 | TYPE_INSTANCE_FLAG_VOLATILE
335 | TYPE_INSTANCE_FLAG_RESTRICT
)) != 0)
336 return convert_qualified (context
, type
);
338 switch (TYPE_CODE (type
))
341 return convert_pointer (context
, type
);
343 case TYPE_CODE_ARRAY
:
344 return convert_array (context
, type
);
346 case TYPE_CODE_STRUCT
:
347 case TYPE_CODE_UNION
:
348 return convert_struct_or_union (context
, type
);
351 return convert_enum (context
, type
);
354 return convert_func (context
, type
);
357 return convert_int (context
, type
);
360 return convert_float (context
, type
);
363 return convert_void (context
, type
);
366 return convert_bool (context
, type
);
368 case TYPE_CODE_COMPLEX
:
369 return convert_complex (context
, type
);
372 return C_CTX (context
)->c_ops
->error (C_CTX (context
),
373 _("cannot convert gdb type "
377 /* See compile-internal.h. */
380 convert_type (struct compile_c_instance
*context
, struct type
*type
)
382 struct type_map_instance inst
, *found
;
385 /* We don't ever have to deal with typedefs in this code, because
386 those are only needed as symbols by the C compiler. */
387 CHECK_TYPEDEF (type
);
390 found
= htab_find (context
->type_map
, &inst
);
392 return found
->gcc_type
;
394 result
= convert_type_basic (context
, type
);
395 insert_type (context
, type
, result
);
401 /* Delete the compiler instance C. */
404 delete_instance (struct compile_instance
*c
)
406 struct compile_c_instance
*context
= (struct compile_c_instance
*) c
;
408 context
->base
.fe
->ops
->destroy (context
->base
.fe
);
409 htab_delete (context
->type_map
);
410 if (context
->symbol_err_map
!= NULL
)
411 htab_delete (context
->symbol_err_map
);
415 /* See compile-internal.h. */
417 struct compile_instance
*
418 new_compile_instance (struct gcc_c_context
*fe
)
420 struct compile_c_instance
*result
= XCNEW (struct compile_c_instance
);
422 result
->base
.fe
= &fe
->base
;
423 result
->base
.destroy
= delete_instance
;
424 result
->base
.gcc_target_options
= ("-std=gnu11"
425 /* Otherwise the .o file may need
427 "__gcc_personality_v0". */
430 result
->type_map
= htab_create_alloc (10, hash_type_map_instance
,
431 eq_type_map_instance
,
432 xfree
, xcalloc
, xfree
);
434 fe
->c_ops
->set_callbacks (fe
, gcc_convert_symbol
,
435 gcc_symbol_address
, result
);
437 return &result
->base
;