Commit | Line | Data |
---|---|---|
bb2ec1b3 TT |
1 | /* Convert types from GDB to GCC |
2 | ||
61baf725 | 3 | Copyright (C) 2014-2017 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" | |
7022349d PA |
24 | #include "objfiles.h" |
25 | ||
bb2ec1b3 TT |
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 | ||
e3bdafe2 | 36 | gcc_type gcc_type_handle; |
bb2ec1b3 TT |
37 | }; |
38 | ||
39 | /* Hash a type_map_instance. */ | |
40 | ||
41 | static hashval_t | |
42 | hash_type_map_instance (const void *p) | |
43 | { | |
9a3c8263 | 44 | const struct type_map_instance *inst = (const struct type_map_instance *) p; |
bb2ec1b3 TT |
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 | { | |
9a3c8263 SM |
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; | |
bb2ec1b3 TT |
56 | |
57 | return insta->type == instb->type; | |
58 | } | |
59 | ||
60 | \f | |
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; | |
e3bdafe2 | 77 | inst.gcc_type_handle = gcc_type; |
bb2ec1b3 TT |
78 | slot = htab_find_slot (context->type_map, &inst, INSERT); |
79 | ||
9a3c8263 | 80 | add = (struct type_map_instance *) *slot; |
bb2ec1b3 TT |
81 | /* The type might have already been inserted in order to handle |
82 | recursive types. */ | |
e3bdafe2 | 83 | if (add != NULL && add->gcc_type_handle != gcc_type) |
08464196 | 84 | error (_("Unexpected type id from GCC, check you use recent enough GCC.")); |
bb2ec1b3 TT |
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; | |
bb2ec1b3 TT |
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 | ||
8f84fb0e TT |
134 | std::string upper_bound |
135 | = c_get_range_decl_name (&TYPE_RANGE_DATA (range)->high); | |
bb2ec1b3 TT |
136 | result = C_CTX (context)->c_ops->build_vla_array_type (C_CTX (context), |
137 | element_type, | |
8f84fb0e | 138 | upper_bound.c_str ()); |
bb2ec1b3 TT |
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 (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 | ||
7022349d PA |
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 | ||
bb2ec1b3 TT |
254 | /* This approach means we can't make self-referential function |
255 | types. Those are impossible in C, though. */ | |
7022349d | 256 | return_type = convert_type (context, target_type); |
bb2ec1b3 TT |
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 (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 (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; | |
8d297bbf | 313 | gcc_qualifiers_flags quals = 0; |
bb2ec1b3 TT |
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 | ||
388 | return C_CTX (context)->c_ops->error (C_CTX (context), | |
389 | _("cannot convert gdb type " | |
390 | "to gcc type")); | |
391 | } | |
392 | ||
393 | /* See compile-internal.h. */ | |
394 | ||
395 | gcc_type | |
396 | convert_type (struct compile_c_instance *context, struct type *type) | |
397 | { | |
398 | struct type_map_instance inst, *found; | |
399 | gcc_type result; | |
400 | ||
401 | /* We don't ever have to deal with typedefs in this code, because | |
402 | those are only needed as symbols by the C compiler. */ | |
f168693b | 403 | type = check_typedef (type); |
bb2ec1b3 TT |
404 | |
405 | inst.type = type; | |
9a3c8263 | 406 | found = (struct type_map_instance *) htab_find (context->type_map, &inst); |
bb2ec1b3 | 407 | if (found != NULL) |
e3bdafe2 | 408 | return found->gcc_type_handle; |
bb2ec1b3 TT |
409 | |
410 | result = convert_type_basic (context, type); | |
411 | insert_type (context, type, result); | |
412 | return result; | |
413 | } | |
414 | ||
415 | \f | |
416 | ||
417 | /* Delete the compiler instance C. */ | |
418 | ||
419 | static void | |
420 | delete_instance (struct compile_instance *c) | |
421 | { | |
422 | struct compile_c_instance *context = (struct compile_c_instance *) c; | |
423 | ||
424 | context->base.fe->ops->destroy (context->base.fe); | |
425 | htab_delete (context->type_map); | |
426 | if (context->symbol_err_map != NULL) | |
427 | htab_delete (context->symbol_err_map); | |
428 | xfree (context); | |
429 | } | |
430 | ||
431 | /* See compile-internal.h. */ | |
432 | ||
433 | struct compile_instance * | |
434 | new_compile_instance (struct gcc_c_context *fe) | |
435 | { | |
436 | struct compile_c_instance *result = XCNEW (struct compile_c_instance); | |
437 | ||
438 | result->base.fe = &fe->base; | |
439 | result->base.destroy = delete_instance; | |
440 | result->base.gcc_target_options = ("-std=gnu11" | |
441 | /* Otherwise the .o file may need | |
442 | "_Unwind_Resume" and | |
443 | "__gcc_personality_v0". */ | |
444 | " -fno-exceptions"); | |
445 | ||
446 | result->type_map = htab_create_alloc (10, hash_type_map_instance, | |
447 | eq_type_map_instance, | |
448 | xfree, xcalloc, xfree); | |
449 | ||
450 | fe->c_ops->set_callbacks (fe, gcc_convert_symbol, | |
451 | gcc_symbol_address, result); | |
452 | ||
453 | return &result->base; | |
454 | } |