gdb/compile/compile-c-types.c

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