gdb/compile/compile-c-types.c

   1 /* Convert types from GDB to GCC
   2
   3    Copyright (C) 2014-2017 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 "objfiles.h"
  25
  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
  36   gcc_type gcc_type_handle;
  37 };
  38
  39 /* Hash a type_map_instance.  */
  40
  41 static hashval_t
  42 hash_type_map_instance (const void *p)
  43 {
  44   const struct type_map_instance *inst = (const struct type_map_instance *) p;
  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 {
  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;
  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;
  77   inst.gcc_type_handle = gcc_type;
  78   slot = htab_find_slot (context->type_map, &inst, INSERT);
  79
  80   add = (struct type_map_instance *) *slot;
  81   /* The type might have already been inserted in order to handle
  82      recursive types.  */
  83   if (add != NULL && add->gcc_type_handle != gcc_type)
  84     error (_("Unexpected type id from GCC, check you use recent enough GCC."));
  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;
 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
 134       std::string upper_bound
 135         = c_get_range_decl_name (&TYPE_RANGE_DATA (range)->high);
 136       result = C_CTX (context)->c_ops->build_vla_array_type (C_CTX (context),
 137                                                              element_type,
 138                                                              upper_bound.c_str ());
 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_v0 (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
 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
 254   /* This approach means we can't make self-referential function
 255      types.  Those are impossible in C, though.  */
 256   return_type = convert_type (context, target_type);
 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_v0 (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_v0 (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;
 313   gcc_qualifiers_flags quals = 0;
 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     case TYPE_CODE_ERROR:
 388       {
 389         /* Ideally, if we get here due to a cast expression, we'd use
 390            the cast-to type as the variable's type, like GDB's
 391            built-in parser does.  For now, assume "int" like GDB's
 392            built-in parser used to do, but at least warn.  */
 393         struct type *fallback;
 394         if (TYPE_OBJFILE_OWNED (type))
 395           fallback = objfile_type (TYPE_OWNER (type).objfile)->builtin_int;
 396         else
 397           fallback = builtin_type (TYPE_OWNER (type).gdbarch)->builtin_int;
 398         warning (_("variable has unknown type; assuming int"));
 399         return convert_int (context, fallback);
 400       }
 401     }
 402
 403   return C_CTX (context)->c_ops->error (C_CTX (context),
 404                                         _("cannot convert gdb type "
 405                                           "to gcc type"));
 406 }
 407
 408 /* See compile-internal.h.  */
 409
 410 gcc_type
 411 convert_type (struct compile_c_instance *context, struct type *type)
 412 {
 413   struct type_map_instance inst, *found;
 414   gcc_type result;
 415
 416   /* We don't ever have to deal with typedefs in this code, because
 417      those are only needed as symbols by the C compiler.  */
 418   type = check_typedef (type);
 419
 420   inst.type = type;
 421   found = (struct type_map_instance *) htab_find (context->type_map, &inst);
 422   if (found != NULL)
 423     return found->gcc_type_handle;
 424
 425   result = convert_type_basic (context, type);
 426   insert_type (context, type, result);
 427   return result;
 428 }
 429
 430 \f
 431
 432 /* Delete the compiler instance C.  */
 433
 434 static void
 435 delete_instance (struct compile_instance *c)
 436 {
 437   struct compile_c_instance *context = (struct compile_c_instance *) c;
 438
 439   context->base.fe->ops->destroy (context->base.fe);
 440   htab_delete (context->type_map);
 441   if (context->symbol_err_map != NULL)
 442     htab_delete (context->symbol_err_map);
 443   xfree (context);
 444 }
 445
 446 /* See compile-internal.h.  */
 447
 448 struct compile_instance *
 449 new_compile_instance (struct gcc_c_context *fe)
 450 {
 451   struct compile_c_instance *result = XCNEW (struct compile_c_instance);
 452
 453   result->base.fe = &fe->base;
 454   result->base.destroy = delete_instance;
 455   result->base.gcc_target_options = ("-std=gnu11"
 456                                      /* Otherwise the .o file may need
 457                                         "_Unwind_Resume" and
 458                                         "__gcc_personality_v0".  */
 459                                      " -fno-exceptions");
 460
 461   result->type_map = htab_create_alloc (10, hash_type_map_instance,
 462                                         eq_type_map_instance,
 463                                         xfree, xcalloc, xfree);
 464
 465   fe->c_ops->set_callbacks (fe, gcc_convert_symbol,
 466                             gcc_symbol_address, result);
 467
 468   return &result->base;
 469 }