1/* Convert types from GDB to GCC
2
3   Copyright (C) 2014-2020 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
30convert_pointer (compile_c_instance *context, struct type *type)
31{
32  gcc_type target = context->convert_type (TYPE_TARGET_TYPE (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
40convert_array (compile_c_instance *context, struct type *type)
41{
42  gcc_type element_type;
43  struct type *range = type->index_type ();
44
45  element_type = context->convert_type (TYPE_TARGET_TYPE (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_VECTOR (type))
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) == 0)
74	count = -1;
75      else
76	{
77	  gdb_assert (low_bound == 0); /* Ensured above.  */
78	  count = high_bound + 1;
79	}
80
81      if (TYPE_VECTOR (type))
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
90convert_struct_or_union (compile_c_instance *context, struct type *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_LENGTH (type->field (i).type ());
114      context->plugin ().build_add_field (result,
115					  TYPE_FIELD_NAME (type, i),
116					  field_type,
117					  bitsize,
118					  TYPE_FIELD_BITPOS (type, i));
119    }
120
121  context->plugin ().finish_record_or_union (result, TYPE_LENGTH (type));
122  return result;
123}
124
125/* Convert an enum type to its gcc representation.  */
126
127static gcc_type
128convert_enum (compile_c_instance *context, struct type *type)
129{
130  gcc_type int_type, result;
131  int i;
132
133  int_type = context->plugin ().int_type_v0 (TYPE_UNSIGNED (type),
134					     TYPE_LENGTH (type));
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_NAME (type, i), TYPE_FIELD_ENUMVAL (type, i));
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
151convert_func (compile_c_instance *context, struct type *type)
152{
153  int i;
154  gcc_type result, return_type;
155  struct gcc_type_array array;
156  int is_varargs = TYPE_VARARGS (type) || !TYPE_PROTOTYPED (type);
157
158  struct type *target_type = TYPE_TARGET_TYPE (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_OBJFILE_OWNED (type))
168	target_type = objfile_type (TYPE_OWNER (type).objfile)->builtin_int;
169      else
170	target_type = builtin_type (TYPE_OWNER (type).gdbarch)->builtin_int;
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  array.elements = XNEWVEC (gcc_type, type->num_fields ());
180  for (i = 0; i < type->num_fields (); ++i)
181    array.elements[i] = context->convert_type (type->field (i).type ());
182
183  result = context->plugin ().build_function_type (return_type,
184						   &array, is_varargs);
185  xfree (array.elements);
186
187  return result;
188}
189
190/* Convert an integer type to its gcc representation.  */
191
192static gcc_type
193convert_int (compile_c_instance *context, struct type *type)
194{
195  if (context->plugin ().version () >= GCC_C_FE_VERSION_1)
196    {
197      if (TYPE_NOSIGN (type))
198	{
199	  gdb_assert (TYPE_LENGTH (type) == 1);
200	  return context->plugin ().char_type ();
201	}
202      return context->plugin ().int_type (TYPE_UNSIGNED (type),
203					  TYPE_LENGTH (type),
204					  type->name ());
205    }
206  else
207    return context->plugin ().int_type_v0 (TYPE_UNSIGNED (type),
208					   TYPE_LENGTH (type));
209}
210
211/* Convert a floating-point type to its gcc representation.  */
212
213static gcc_type
214convert_float (compile_c_instance *context, struct type *type)
215{
216  if (context->plugin ().version () >= GCC_C_FE_VERSION_1)
217    return context->plugin ().float_type (TYPE_LENGTH (type),
218					  type->name ());
219  else
220    return context->plugin ().float_type_v0 (TYPE_LENGTH (type));
221}
222
223/* Convert the 'void' type to its gcc representation.  */
224
225static gcc_type
226convert_void (compile_c_instance *context, struct type *type)
227{
228  return context->plugin ().void_type ();
229}
230
231/* Convert a boolean type to its gcc representation.  */
232
233static gcc_type
234convert_bool (compile_c_instance *context, struct type *type)
235{
236  return context->plugin ().bool_type ();
237}
238
239/* Convert a qualified type to its gcc representation.  */
240
241static gcc_type
242convert_qualified (compile_c_instance *context, struct type *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, quals);
258}
259
260/* Convert a complex type to its gcc representation.  */
261
262static gcc_type
263convert_complex (compile_c_instance *context, struct type *type)
264{
265  gcc_type base = context->convert_type (TYPE_TARGET_TYPE (type));
266
267  return context->plugin ().build_complex_type (base);
268}
269
270/* A helper function which knows how to convert most types from their
271   gdb representation to the corresponding gcc form.  This examines
272   the TYPE and dispatches to the appropriate conversion function.  It
273   returns the gcc type.  */
274
275static gcc_type
276convert_type_basic (compile_c_instance *context, struct type *type)
277{
278  /* If we are converting a qualified type, first convert the
279     unqualified type and then apply the qualifiers.  */
280  if ((TYPE_INSTANCE_FLAGS (type) & (TYPE_INSTANCE_FLAG_CONST
281				     | TYPE_INSTANCE_FLAG_VOLATILE
282				     | TYPE_INSTANCE_FLAG_RESTRICT)) != 0)
283    return convert_qualified (context, type);
284
285  switch (type->code ())
286    {
287    case TYPE_CODE_PTR:
288      return convert_pointer (context, type);
289
290    case TYPE_CODE_ARRAY:
291      return convert_array (context, type);
292
293    case TYPE_CODE_STRUCT:
294    case TYPE_CODE_UNION:
295      return convert_struct_or_union (context, type);
296
297    case TYPE_CODE_ENUM:
298      return convert_enum (context, type);
299
300    case TYPE_CODE_FUNC:
301      return convert_func (context, type);
302
303    case TYPE_CODE_INT:
304      return convert_int (context, type);
305
306    case TYPE_CODE_FLT:
307      return convert_float (context, type);
308
309    case TYPE_CODE_VOID:
310      return convert_void (context, type);
311
312    case TYPE_CODE_BOOL:
313      return convert_bool (context, type);
314
315    case TYPE_CODE_COMPLEX:
316      return convert_complex (context, type);
317
318    case TYPE_CODE_ERROR:
319      {
320	/* Ideally, if we get here due to a cast expression, we'd use
321	   the cast-to type as the variable's type, like GDB's
322	   built-in parser does.  For now, assume "int" like GDB's
323	   built-in parser used to do, but at least warn.  */
324	struct type *fallback;
325	if (TYPE_OBJFILE_OWNED (type))
326	  fallback = objfile_type (TYPE_OWNER (type).objfile)->builtin_int;
327	else
328	  fallback = builtin_type (TYPE_OWNER (type).gdbarch)->builtin_int;
329	warning (_("variable has unknown type; assuming int"));
330	return convert_int (context, fallback);
331      }
332    }
333
334  return context->plugin ().error (_("cannot convert gdb type to gcc type"));
335}
336
337/* Default compile flags for C.  */
338
339const char *compile_c_instance::m_default_cflags = "-std=gnu11"
340  /* Otherwise the .o file may need
341     "_Unwind_Resume" and
342     "__gcc_personality_v0".  */
343  " -fno-exceptions"
344  " -Wno-implicit-function-declaration";
345
346/* See compile-c.h.  */
347
348gcc_type
349compile_c_instance::convert_type (struct type *type)
350{
351  /* We don't ever have to deal with typedefs in this code, because
352     those are only needed as symbols by the C compiler.  */
353  type = check_typedef (type);
354
355  gcc_type result;
356  if (get_cached_type (type, &result))
357    return result;
358
359  result = convert_type_basic (this, type);
360  insert_type (type, result);
361  return result;
362}
363
364
365
366/* C plug-in wrapper.  */
367
368#define FORWARD(OP,...) m_context->c_ops->OP(m_context, ##__VA_ARGS__)
369#define GCC_METHOD0(R, N) \
370  R gcc_c_plugin::N () const \
371  { return FORWARD (N); }
372#define GCC_METHOD1(R, N, A) \
373  R gcc_c_plugin::N (A a) const \
374  { return FORWARD (N, a); }
375#define GCC_METHOD2(R, N, A, B) \
376  R gcc_c_plugin::N (A a, B b) const \
377  { return FORWARD (N, a, b); }
378#define GCC_METHOD3(R, N, A, B, C) \
379  R gcc_c_plugin::N (A a, B b, C c)  const \
380  { return FORWARD (N, a, b, c); }
381#define GCC_METHOD4(R, N, A, B, C, D) \
382  R gcc_c_plugin::N (A a, B b, C c, D d) const \
383  { return FORWARD (N, a, b, c, d); }
384#define GCC_METHOD5(R, N, A, B, C, D, E) \
385  R gcc_c_plugin::N (A a, B b, C c, D d, E e) const \
386  { return FORWARD (N, a, b, c, d, e); }
387#define GCC_METHOD7(R, N, A, B, C, D, E, F, G) \
388  R gcc_c_plugin::N (A a, B b, C c, D d, E e, F f, G g) const \
389  { return FORWARD (N, a, b, c, d, e, f, g); }
390
391#include "gcc-c-fe.def"
392
393#undef GCC_METHOD0
394#undef GCC_METHOD1
395#undef GCC_METHOD2
396#undef GCC_METHOD3
397#undef GCC_METHOD4
398#undef GCC_METHOD5
399#undef GCC_METHOD7
400#undef FORWARD
401