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