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