Debian Codegraph @

libdrgn/type.c

raw
1 // Copyright (c) Meta Platforms, Inc. and affiliates.
2 // SPDX-License-Identifier: LGPL-2.1-or-later
3
4 #include <limits.h>
5 #include <stdlib.h>
6 #include <string.h>
7
8 #include "array.h"
9 #include "bitops.h"
10 #include "cleanup.h"
11 #include "error.h"
12 #include "hash_table.h"
13 #include "language.h"
14 #include "lazy_object.h"
15 #include "program.h"
16 #include "type.h"
17 #include "util.h"
18
19 LIBDRGN_PUBLIC struct drgn_qualified_type
20 drgn_qualified_type_unaliased(struct drgn_qualified_type qualified_type)
21 {
22 while (drgn_type_kind(qualified_type.type) == DRGN_TYPE_TYPEDEF) {
23 struct drgn_qualified_type tmp =
24 drgn_type_type(qualified_type.type);
25 qualified_type.qualifiers |= tmp.qualifiers;
26 qualified_type.type = tmp.type;
27 }
28 return qualified_type;
29 }
30
31 const char * const drgn_type_kind_spelling[] = {
32 [DRGN_TYPE_VOID] = "void",
33 [DRGN_TYPE_INT] = "int",
34 [DRGN_TYPE_BOOL] = "bool",
35 [DRGN_TYPE_FLOAT] = "float",
36 [DRGN_TYPE_STRUCT] = "struct",
37 [DRGN_TYPE_UNION] = "union",
38 [DRGN_TYPE_CLASS] = "class",
39 [DRGN_TYPE_ENUM] = "enum",
40 [DRGN_TYPE_TYPEDEF] = "typedef",
41 [DRGN_TYPE_POINTER] = "pointer",
42 [DRGN_TYPE_ARRAY] = "array",
43 [DRGN_TYPE_FUNCTION] = "function",
44 };
45
46 /**
47 * Names of primitive types.
48 *
49 * In some languages, like C, the same primitive type can be spelled in multiple
50 * ways. For example, "int" can also be spelled "signed int" or "int signed".
51 *
52 * This maps each @ref drgn_primitive_type to a ``NULL``-terminated array of the
53 * different ways to spell that type. The spelling at index zero is the
54 * preferred spelling.
55 */
56 static const char * const * const
57 drgn_primitive_type_spellings[DRGN_PRIMITIVE_TYPE_NUM] = {
58 [DRGN_C_TYPE_VOID] = (const char * []){ "void", NULL, },
59 [DRGN_C_TYPE_CHAR] = (const char * []){ "char", NULL, },
60 [DRGN_C_TYPE_SIGNED_CHAR] = (const char * []){
61 "signed char", "char signed", NULL,
62 },
63 [DRGN_C_TYPE_UNSIGNED_CHAR] = (const char * []){
64 "unsigned char", "char unsigned", NULL,
65 },
66 [DRGN_C_TYPE_SHORT] = (const char * []){
67 "short", "signed short", "short signed", "short int",
68 "int short", "signed short int", "signed int short",
69 "short signed int", "short int signed", "int signed short",
70 "int short signed", NULL,
71 },
72 [DRGN_C_TYPE_UNSIGNED_SHORT] = (const char * []){
73 "unsigned short", "short unsigned", "unsigned short int",
74 "unsigned int short", "short unsigned int",
75 "short int unsigned", "int unsigned short",
76 "int short unsigned", NULL,
77 },
78 [DRGN_C_TYPE_INT] = (const char * []){
79 "int", "signed", "signed int", "int signed", NULL,
80 },
81 [DRGN_C_TYPE_UNSIGNED_INT] = (const char * []){
82 "unsigned int", "int unsigned", "unsigned", NULL,
83 },
84 [DRGN_C_TYPE_LONG] = (const char * []){
85 "long", "signed long", "long signed", "long int", "int long",
86 "signed long int", "signed int long", "long signed int",
87 "long int signed", "int signed long", "int long signed", NULL,
88 },
89 [DRGN_C_TYPE_UNSIGNED_LONG] = (const char * []){
90 "unsigned long", "long unsigned", "unsigned long int",
91 "unsigned int long", "long unsigned int", "long int unsigned",
92 "int unsigned long", "int long unsigned", NULL,
93 },
94 [DRGN_C_TYPE_LONG_LONG] = (const char * []){
95 "long long", "signed long long", "long signed long",
96 "long long signed", "long long int", "long int long",
97 "int long long", "signed long long int", "signed long int long",
98 "signed int long long", "long signed long int",
99 "long signed int long", "long long signed int",
100 "long long int signed", "long int signed long",
101 "long int long signed", "int signed long long",
102 "int long signed long", "int long long signed", NULL,
103 },
104 [DRGN_C_TYPE_UNSIGNED_LONG_LONG] = (const char * []){
105 "unsigned long long", "long unsigned long",
106 "long long unsigned", "unsigned long long int",
107 "unsigned long int long", "unsigned int long long",
108 "long unsigned long int", "long unsigned int long",
109 "long long unsigned int", "long long int unsigned",
110 "long int unsigned long", "long int long unsigned",
111 "int unsigned long long", "int long unsigned long",
112 "int long long unsigned", NULL,
113 },
114 [DRGN_C_TYPE_BOOL] = (const char * []){ "_Bool", NULL, },
115 [DRGN_C_TYPE_FLOAT] = (const char * []){ "float", NULL, },
116 [DRGN_C_TYPE_DOUBLE] = (const char * []){ "double", NULL, },
117 [DRGN_C_TYPE_LONG_DOUBLE] = (const char * []){
118 "long double", "double long", NULL,
119 },
120 [DRGN_C_TYPE_SIZE_T] = (const char * []){ "size_t", NULL, },
121 [DRGN_C_TYPE_PTRDIFF_T] = (const char * []){ "ptrdiff_t", NULL, },
122 };
123
124 /**
125 * Mapping from a @ref drgn_type_primitive to the corresponding @ref
126 * drgn_type_kind.
127 */
128 static const enum drgn_type_kind
129 drgn_primitive_type_kind[DRGN_PRIMITIVE_TYPE_NUM + 1] = {
130 [DRGN_C_TYPE_CHAR] = DRGN_TYPE_INT,
131 [DRGN_C_TYPE_SIGNED_CHAR] = DRGN_TYPE_INT,
132 [DRGN_C_TYPE_UNSIGNED_CHAR] = DRGN_TYPE_INT,
133 [DRGN_C_TYPE_SHORT] = DRGN_TYPE_INT,
134 [DRGN_C_TYPE_UNSIGNED_SHORT] = DRGN_TYPE_INT,
135 [DRGN_C_TYPE_INT] = DRGN_TYPE_INT,
136 [DRGN_C_TYPE_UNSIGNED_INT] = DRGN_TYPE_INT,
137 [DRGN_C_TYPE_LONG] = DRGN_TYPE_INT,
138 [DRGN_C_TYPE_UNSIGNED_LONG] = DRGN_TYPE_INT,
139 [DRGN_C_TYPE_LONG_LONG] = DRGN_TYPE_INT,
140 [DRGN_C_TYPE_UNSIGNED_LONG_LONG] = DRGN_TYPE_INT,
141 [DRGN_C_TYPE_BOOL] = DRGN_TYPE_BOOL,
142 [DRGN_C_TYPE_FLOAT] = DRGN_TYPE_FLOAT,
143 [DRGN_C_TYPE_DOUBLE] = DRGN_TYPE_FLOAT,
144 [DRGN_C_TYPE_LONG_DOUBLE] = DRGN_TYPE_FLOAT,
145 [DRGN_C_TYPE_SIZE_T] = DRGN_TYPE_TYPEDEF,
146 [DRGN_C_TYPE_PTRDIFF_T] = DRGN_TYPE_TYPEDEF,
147 [DRGN_C_TYPE_VOID] = DRGN_TYPE_VOID,
148 [DRGN_NOT_PRIMITIVE_TYPE] = -1,
149 };
150
151 /** Return whether a primitive type is always a signed integer type. */
152 static inline bool
153 drgn_primitive_type_is_signed(enum drgn_primitive_type primitive)
154 {
155 switch (primitive) {
156 case DRGN_C_TYPE_SIGNED_CHAR:
157 case DRGN_C_TYPE_SHORT:
158 case DRGN_C_TYPE_INT:
159 case DRGN_C_TYPE_LONG:
160 case DRGN_C_TYPE_LONG_LONG:
161 case DRGN_C_TYPE_PTRDIFF_T:
162 return true;
163 default:
164 return false;
165 }
166 }
167
168 static struct hash_pair
169 drgn_member_key_hash_pair(const struct drgn_member_key *key)
170 {
171 size_t hash;
172 if (key->name)
173 hash = hash_bytes(key->name, key->name_len);
174 else
175 hash = 0;
176 hash = hash_combine((uintptr_t)key->type, hash);
177 return hash_pair_from_avalanching_hash(hash);
178 }
179
180 static bool drgn_member_key_eq(const struct drgn_member_key *a,
181 const struct drgn_member_key *b)
182 {
183 return (a->type == b->type && a->name_len == b->name_len &&
184 (!a->name_len || memcmp(a->name, b->name, a->name_len) == 0));
185 }
186
187 DEFINE_HASH_MAP_FUNCTIONS(drgn_member_map, drgn_member_key_hash_pair,
188 drgn_member_key_eq);
189
190 DEFINE_HASH_SET_FUNCTIONS(drgn_type_set, ptr_key_hash_pair, scalar_key_eq);
191
192 LIBDRGN_PUBLIC struct drgn_error *
193 drgn_member_object(struct drgn_type_member *member,
194 const struct drgn_object **ret)
195 {
196 struct drgn_error *err = drgn_lazy_object_evaluate(&member->object);
197 if (!err)
198 *ret = &member->object.obj;
199 return err;
200 }
201
202 LIBDRGN_PUBLIC struct drgn_error *
203 drgn_member_type(struct drgn_type_member *member,
204 struct drgn_qualified_type *type_ret,
205 uint64_t *bit_field_size_ret)
206 {
207 struct drgn_error *err = drgn_lazy_object_evaluate(&member->object);
208 if (err)
209 return err;
210 *type_ret = drgn_object_qualified_type(&member->object.obj);
211 if (bit_field_size_ret) {
212 if (member->object.obj.is_bit_field)
213 *bit_field_size_ret = member->object.obj.bit_size;
214 else
215 *bit_field_size_ret = 0;
216 }
217 return NULL;
218 }
219
220 LIBDRGN_PUBLIC struct drgn_error *
221 drgn_parameter_default_argument(struct drgn_type_parameter *parameter,
222 const struct drgn_object **ret)
223 {
224 struct drgn_error *err =
225 drgn_lazy_object_evaluate(&parameter->default_argument);
226 if (!err)
227 *ret = &parameter->default_argument.obj;
228 return err;
229 }
230
231 LIBDRGN_PUBLIC struct drgn_error *
232 drgn_parameter_type(struct drgn_type_parameter *parameter,
233 struct drgn_qualified_type *ret)
234 {
235 struct drgn_error *err =
236 drgn_lazy_object_evaluate(&parameter->default_argument);
237 if (!err)
238 *ret = drgn_object_qualified_type(&parameter->default_argument.obj);
239 return err;
240 }
241
242 LIBDRGN_PUBLIC struct drgn_error *
243 drgn_template_parameter_type(struct drgn_type_template_parameter *parameter,
244 struct drgn_qualified_type *ret)
245 {
246 struct drgn_error *err =
247 drgn_lazy_object_evaluate(&parameter->argument);
248 if (!err)
249 *ret = drgn_object_qualified_type(&parameter->argument.obj);
250 return err;
251 }
252
253 LIBDRGN_PUBLIC struct drgn_error *
254 drgn_template_parameter_object(struct drgn_type_template_parameter *parameter,
255 const struct drgn_object **ret)
256 {
257 struct drgn_error *err =
258 drgn_lazy_object_evaluate(&parameter->argument);
259 if (err)
260 return err;
261 if (parameter->argument.obj.kind == DRGN_OBJECT_ABSENT)
262 *ret = NULL;
263 else
264 *ret = &parameter->argument.obj;
265 return NULL;
266 }
267
268 static struct hash_pair
269 drgn_type_dedupe_hash_pair(struct drgn_type * const *entry)
270 {
271 struct drgn_type *type = *entry;
272 size_t hash = hash_combine(drgn_type_kind(type),
273 drgn_type_is_complete(type));
274 hash = hash_combine(hash, (uintptr_t)drgn_type_language(type));
275 if (drgn_type_has_name(type))
276 hash = hash_combine(hash, hash_c_string(drgn_type_name(type)));
277 if (drgn_type_has_size(type))
278 hash = hash_combine(hash, drgn_type_size(type));
279 if (drgn_type_has_is_signed(type))
280 hash = hash_combine(hash, drgn_type_is_signed(type));
281 if (drgn_type_has_little_endian(type))
282 hash = hash_combine(hash, drgn_type_little_endian(type));
283 if (drgn_type_has_type(type)) {
284 struct drgn_qualified_type qualified_type =
285 drgn_type_type(type);
286 hash = hash_combine(hash, (uintptr_t)qualified_type.type);
287 hash = hash_combine(hash, qualified_type.qualifiers);
288 }
289 if (drgn_type_has_length(type))
290 hash = hash_combine(hash, drgn_type_length(type));
291 return hash_pair_from_avalanching_hash(hash);
292 }
293
294 static bool drgn_type_dedupe_eq(struct drgn_type * const *entry_a,
295 struct drgn_type * const *entry_b)
296 {
297 struct drgn_type *a = *entry_a;
298 struct drgn_type *b = *entry_b;
299
300 if (drgn_type_kind(a) != drgn_type_kind(b) ||
301 drgn_type_is_complete(a) != drgn_type_is_complete(b) ||
302 drgn_type_language(a) != drgn_type_language(b))
303 return false;
304 if (drgn_type_has_name(a) &&
305 strcmp(drgn_type_name(a), drgn_type_name(b)) != 0)
306 return false;
307 if (drgn_type_has_size(a) && drgn_type_size(a) != drgn_type_size(b))
308 return false;
309 if (drgn_type_has_is_signed(a) &&
310 drgn_type_is_signed(a) != drgn_type_is_signed(b))
311 return false;
312 if (drgn_type_has_little_endian(a) &&
313 drgn_type_little_endian(a) != drgn_type_little_endian(b))
314 return false;
315 if (drgn_type_has_type(a)) {
316 struct drgn_qualified_type type_a = drgn_type_type(a);
317 struct drgn_qualified_type type_b = drgn_type_type(b);
318 if (type_a.type != type_b.type ||
319 type_a.qualifiers != type_b.qualifiers)
320 return false;
321 }
322 if (drgn_type_has_length(a) &&
323 drgn_type_length(a) != drgn_type_length(b))
324 return false;
325 return true;
326 }
327
328 // We don't deduplicate struct, union, class, enum, or function types, so the
329 // hash and comparison functions ignore attributes exclusive to those types.
330 DEFINE_HASH_SET_FUNCTIONS(drgn_dedupe_type_set, drgn_type_dedupe_hash_pair,
331 drgn_type_dedupe_eq);
332
333 DEFINE_VECTOR_FUNCTIONS(drgn_typep_vector);
334
335 static struct drgn_error *find_or_create_type(struct drgn_type *key,
336 struct drgn_type **ret)
337 {
338 struct drgn_program *prog = key->_program;
339 struct hash_pair hp = drgn_dedupe_type_set_hash(&key);
340 struct drgn_dedupe_type_set_iterator it =
341 drgn_dedupe_type_set_search_hashed(&prog->dedupe_types, &key,
342 hp);
343 if (it.entry) {
344 *ret = *it.entry;
345 return NULL;
346 }
347
348 _cleanup_free_ struct drgn_type *type = malloc(sizeof(*type));
349 if (!type)
350 return &drgn_enomem;
351
352 *type = *key;
353 if (drgn_dedupe_type_set_insert_searched(&prog->dedupe_types, &type, hp,
354 NULL) < 0)
355 return &drgn_enomem;
356 *ret = no_cleanup_ptr(type);
357 return NULL;
358 }
359
360 struct drgn_type *drgn_void_type(struct drgn_program *prog,
361 const struct drgn_language *lang)
362 {
363 if (!lang)
364 lang = drgn_program_language(prog);
365 return &prog->void_types[lang->number];
366 }
367
368 static struct drgn_error *
369 drgn_type_init_byte_order(struct drgn_type *type,
370 enum drgn_byte_order byte_order)
371 {
372 struct drgn_error *err;
373 bool little_endian;
374 SWITCH_ENUM(byte_order) {
375 case DRGN_BIG_ENDIAN:
376 return NULL;
377 case DRGN_PROGRAM_ENDIAN:
378 err = drgn_program_is_little_endian(type->_program,
379 &little_endian);
380 if (err || !little_endian)
381 return err;
382 fallthrough;
383 case DRGN_LITTLE_ENDIAN:
384 type->_flags |= DRGN_TYPE_FLAG_LITTLE_ENDIAN;
385 return NULL;
386 default:
387 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
388 "invalid byte order");
389 }
390 }
391
392 struct drgn_error *drgn_int_type_create(struct drgn_program *prog,
393 const char *name, uint64_t size,
394 bool is_signed,
395 enum drgn_byte_order byte_order,
396 const struct drgn_language *lang,
397 struct drgn_type **ret)
398 {
399 struct drgn_error *err;
400
401 enum drgn_primitive_type primitive = c_parse_specifier_list(name);
402 if (drgn_primitive_type_kind[primitive] == DRGN_TYPE_INT &&
403 (primitive == DRGN_C_TYPE_CHAR ||
404 is_signed == drgn_primitive_type_is_signed(primitive)))
405 name = drgn_primitive_type_spellings[primitive][0];
406 else
407 primitive = DRGN_NOT_PRIMITIVE_TYPE;
408
409 struct drgn_type key = {
410 ._kind = DRGN_TYPE_INT,
411 ._primitive = primitive,
412 ._flags = (DRGN_TYPE_FLAG_IS_COMPLETE
413 | (is_signed ? DRGN_TYPE_FLAG_IS_SIGNED : 0)),
414 ._name = name,
415 ._size = size,
416 ._program = prog,
417 ._language = lang ? lang : drgn_program_language(prog),
418 };
419 err = drgn_type_init_byte_order(&key, byte_order);
420 if (err)
421 return err;
422 return find_or_create_type(&key, ret);
423 }
424
425 struct drgn_error *drgn_bool_type_create(struct drgn_program *prog,
426 const char *name, uint64_t size,
427 enum drgn_byte_order byte_order,
428 const struct drgn_language *lang,
429 struct drgn_type **ret)
430 {
431 struct drgn_error *err;
432
433 enum drgn_primitive_type primitive = c_parse_specifier_list(name);
434 if (primitive == DRGN_C_TYPE_BOOL)
435 name = drgn_primitive_type_spellings[DRGN_C_TYPE_BOOL][0];
436 else
437 primitive = DRGN_NOT_PRIMITIVE_TYPE;
438
439 struct drgn_type key = {
440 ._kind = DRGN_TYPE_BOOL,
441 ._primitive = primitive,
442 ._flags = DRGN_TYPE_FLAG_IS_COMPLETE,
443 ._name = name,
444 ._size = size,
445 ._program = prog,
446 ._language = lang ? lang : drgn_program_language(prog),
447 };
448 err = drgn_type_init_byte_order(&key, byte_order);
449 if (err)
450 return err;
451 return find_or_create_type(&key, ret);
452 }
453
454 struct drgn_error *drgn_float_type_create(struct drgn_program *prog,
455 const char *name, uint64_t size,
456 enum drgn_byte_order byte_order,
457 const struct drgn_language *lang,
458 struct drgn_type **ret)
459 {
460 struct drgn_error *err;
461
462 enum drgn_primitive_type primitive = c_parse_specifier_list(name);
463 if (drgn_primitive_type_kind[primitive] == DRGN_TYPE_FLOAT)
464 name = drgn_primitive_type_spellings[primitive][0];
465 else
466 primitive = DRGN_NOT_PRIMITIVE_TYPE;
467
468 struct drgn_type key = {
469 ._kind = DRGN_TYPE_FLOAT,
470 ._primitive = primitive,
471 ._flags = DRGN_TYPE_FLAG_IS_COMPLETE,
472 ._name = name,
473 ._size = size,
474 ._program = prog,
475 ._language = lang ? lang : drgn_program_language(prog),
476 };
477 err = drgn_type_init_byte_order(&key, byte_order);
478 if (err)
479 return err;
480 return find_or_create_type(&key, ret);
481 }
482
483 DEFINE_VECTOR_FUNCTIONS(drgn_type_template_parameter_vector);
484
485 static void
486 drgn_template_parameters_builder_init(struct drgn_template_parameters_builder *builder,
487 struct drgn_program *prog)
488 {
489 builder->prog = prog;
490 drgn_type_template_parameter_vector_init(&builder->parameters);
491 }
492
493 static void
494 drgn_template_parameters_builder_deinit(struct drgn_template_parameters_builder *builder)
495 {
496 vector_for_each(drgn_type_template_parameter_vector, parameter,
497 &builder->parameters)
498 drgn_lazy_object_deinit(&parameter->argument);
499 drgn_type_template_parameter_vector_deinit(&builder->parameters);
500 }
501
502 struct drgn_error *
503 drgn_template_parameters_builder_add(struct drgn_template_parameters_builder *builder,
504 const union drgn_lazy_object *argument,
505 const char *name, bool is_default)
506 {
507 struct drgn_error *err = drgn_lazy_object_check_prog(argument,
508 builder->prog);
509 if (err)
510 return err;
511 struct drgn_type_template_parameter *parameter =
512 drgn_type_template_parameter_vector_append_entry(&builder->parameters);
513 if (!parameter)
514 return &drgn_enomem;
515 parameter->argument = *argument;
516 parameter->name = name;
517 parameter->is_default = is_default;
518 return NULL;
519 }
520
521 DEFINE_VECTOR_FUNCTIONS(drgn_type_member_vector);
522
523 void drgn_compound_type_builder_init(struct drgn_compound_type_builder *builder,
524 struct drgn_program *prog,
525 enum drgn_type_kind kind)
526 {
527 assert(kind == DRGN_TYPE_STRUCT ||
528 kind == DRGN_TYPE_UNION ||
529 kind == DRGN_TYPE_CLASS);
530 drgn_template_parameters_builder_init(&builder->template_builder, prog);
531 builder->kind = kind;
532 drgn_type_member_vector_init(&builder->members);
533 }
534
535 void
536 drgn_compound_type_builder_deinit(struct drgn_compound_type_builder *builder)
537 {
538 vector_for_each(drgn_type_member_vector, member, &builder->members)
539 drgn_lazy_object_deinit(&member->object);
540 drgn_type_member_vector_deinit(&builder->members);
541 drgn_template_parameters_builder_deinit(&builder->template_builder);
542 }
543
544 struct drgn_error *
545 drgn_compound_type_builder_add_member(struct drgn_compound_type_builder *builder,
546 const union drgn_lazy_object *object,
547 const char *name, uint64_t bit_offset)
548 {
549 struct drgn_error *err =
550 drgn_lazy_object_check_prog(object,
551 builder->template_builder.prog);
552 if (err)
553 return err;
554 struct drgn_type_member *member =
555 drgn_type_member_vector_append_entry(&builder->members);
556 if (!member)
557 return &drgn_enomem;
558 member->object = *object;
559 member->name = name;
560 member->bit_offset = bit_offset;
561 return NULL;
562 }
563
564 struct drgn_error *
565 drgn_compound_type_create(struct drgn_compound_type_builder *builder,
566 const char *tag, uint64_t size, bool is_complete,
567 const struct drgn_language *lang,
568 struct drgn_type **ret)
569 {
570 struct drgn_program *prog = builder->template_builder.prog;
571
572 if (!is_complete) {
573 if (!drgn_type_member_vector_empty(&builder->members)) {
574 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
575 "incomplete type must not have members");
576 }
577 if (size != 0) {
578 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
579 "size of incomplete type must be zero");
580 }
581 }
582
583 drgn_type_member_vector_shrink_to_fit(&builder->members);
584 drgn_type_template_parameter_vector_shrink_to_fit(&builder->template_builder.parameters);
585
586 _cleanup_free_ struct drgn_compound_type *type = malloc(sizeof(*type));
587 if (!type || !drgn_typep_vector_append(&prog->created_types,
588 (struct drgn_type **)&type))
589 return &drgn_enomem;
590 *type = (struct drgn_compound_type){
591 .templated = {
592 .extended = {
593 .type = {
594 ._kind = builder->kind,
595 ._primitive = DRGN_NOT_PRIMITIVE_TYPE,
596 ._flags = is_complete ? DRGN_TYPE_FLAG_IS_COMPLETE : 0,
597 ._tag = tag,
598 ._size = size,
599 ._program = prog,
600 ._language = lang ? lang : drgn_program_language(prog),
601 },
602 },
603 },
604 };
605 drgn_type_member_vector_steal(&builder->members,
606 &type->templated.extended.type._members,
607 &type->_num_members);
608 drgn_type_template_parameter_vector_steal(&builder->template_builder.parameters,
609 &type->templated._template_parameters,
610 &type->templated._num_template_parameters);
611 *ret = &no_cleanup_ptr(type)->templated.extended.type;
612 return NULL;
613 }
614
615 DEFINE_VECTOR_FUNCTIONS(drgn_type_enumerator_vector);
616
617 void drgn_enum_type_builder_init(struct drgn_enum_type_builder *builder,
618 struct drgn_program *prog)
619 {
620 builder->prog = prog;
621 drgn_type_enumerator_vector_init(&builder->enumerators);
622 }
623
624 void drgn_enum_type_builder_deinit(struct drgn_enum_type_builder *builder)
625 {
626 drgn_type_enumerator_vector_deinit(&builder->enumerators);
627 }
628
629 struct drgn_error *
630 drgn_enum_type_builder_add_signed(struct drgn_enum_type_builder *builder,
631 const char *name, int64_t svalue)
632 {
633 struct drgn_type_enumerator *enumerator =
634 drgn_type_enumerator_vector_append_entry(&builder->enumerators);
635 if (!enumerator)
636 return &drgn_enomem;
637 enumerator->name = name;
638 enumerator->svalue = svalue;
639 return NULL;
640 }
641
642 struct drgn_error *
643 drgn_enum_type_builder_add_unsigned(struct drgn_enum_type_builder *builder,
644 const char *name, uint64_t uvalue)
645 {
646 struct drgn_type_enumerator *enumerator =
647 drgn_type_enumerator_vector_append_entry(&builder->enumerators);
648 if (!enumerator)
649 return &drgn_enomem;
650 enumerator->name = name;
651 enumerator->uvalue = uvalue;
652 return NULL;
653 }
654
655 struct drgn_error *drgn_enum_type_create(struct drgn_enum_type_builder *builder,
656 const char *tag,
657 struct drgn_type *compatible_type,
658 const struct drgn_language *lang,
659 struct drgn_type **ret)
660 {
661 if (drgn_type_program(compatible_type) != builder->prog) {
662 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
663 "type is from different program");
664 }
665 if (drgn_type_kind(compatible_type) != DRGN_TYPE_INT) {
666 return drgn_error_create(DRGN_ERROR_TYPE,
667 "compatible type of enum type must be integer type");
668 }
669
670 drgn_type_enumerator_vector_shrink_to_fit(&builder->enumerators);
671
672 _cleanup_free_ struct drgn_enum_type *type = malloc(sizeof(*type));
673 if (!type || !drgn_typep_vector_append(&builder->prog->created_types,
674 (struct drgn_type **)&type))
675 return &drgn_enomem;
676 *type = (struct drgn_enum_type){
677 .extended = {
678 .type = {
679 ._kind = DRGN_TYPE_ENUM,
680 ._primitive = DRGN_NOT_PRIMITIVE_TYPE,
681 ._flags = DRGN_TYPE_FLAG_IS_COMPLETE,
682 ._tag = tag,
683 ._type = compatible_type,
684 ._qualifiers = 0,
685 ._program = builder->prog,
686 ._language = lang ? lang : drgn_program_language(builder->prog),
687 },
688 },
689 };
690 drgn_type_enumerator_vector_steal(&builder->enumerators,
691 &type->extended.type._enumerators,
692 &type->_num_enumerators);
693 *ret = &no_cleanup_ptr(type)->extended.type;
694 return NULL;
695 }
696
697 struct drgn_error *
698 drgn_incomplete_enum_type_create(struct drgn_program *prog, const char *tag,
699 const struct drgn_language *lang,
700 struct drgn_type **ret)
701 {
702 _cleanup_free_ struct drgn_enum_type *type = malloc(sizeof(*type));
703 if (!type || !drgn_typep_vector_append(&prog->created_types,
704 (struct drgn_type **)&type))
705 return &drgn_enomem;
706 *type = (struct drgn_enum_type){
707 .extended = {
708 .type = {
709 ._kind = DRGN_TYPE_ENUM,
710 ._primitive = DRGN_NOT_PRIMITIVE_TYPE,
711 ._tag = tag,
712 ._program = prog,
713 ._language = lang ? lang : drgn_program_language(prog),
714 },
715 },
716 };
717 *ret = &no_cleanup_ptr(type)->extended.type;
718 return NULL;
719 }
720
721 struct drgn_error *
722 drgn_typedef_type_create(struct drgn_program *prog, const char *name,
723 struct drgn_qualified_type aliased_type,
724 const struct drgn_language *lang,
725 struct drgn_type **ret)
726 {
727 if (drgn_type_program(aliased_type.type) != prog) {
728 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
729 "type is from different program");
730 }
731
732 enum drgn_primitive_type primitive;
733 if (strcmp(name, "size_t") == 0)
734 primitive = DRGN_C_TYPE_SIZE_T;
735 else if (strcmp(name, "ptrdiff_t") == 0)
736 primitive = DRGN_C_TYPE_PTRDIFF_T;
737 else
738 primitive = DRGN_NOT_PRIMITIVE_TYPE;
739
740 struct drgn_type key = {
741 ._kind = DRGN_TYPE_TYPEDEF,
742 ._primitive = primitive,
743 ._flags = aliased_type.type->_flags & DRGN_TYPE_FLAG_IS_COMPLETE,
744 ._name = name,
745 ._type = aliased_type.type,
746 ._qualifiers = aliased_type.qualifiers,
747 ._program = prog,
748 ._language = lang ? lang : drgn_program_language(prog),
749 };
750 return find_or_create_type(&key, ret);
751 }
752
753 struct drgn_error *
754 drgn_pointer_type_create(struct drgn_program *prog,
755 struct drgn_qualified_type referenced_type,
756 uint64_t size, enum drgn_byte_order byte_order,
757 const struct drgn_language *lang,
758 struct drgn_type **ret)
759 {
760 struct drgn_error *err;
761
762 if (drgn_type_program(referenced_type.type) != prog) {
763 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
764 "type is from different program");
765 }
766
767 struct drgn_type key = {
768 ._kind = DRGN_TYPE_POINTER,
769 ._primitive = DRGN_NOT_PRIMITIVE_TYPE,
770 ._flags = DRGN_TYPE_FLAG_IS_COMPLETE,
771 ._size = size,
772 ._type = referenced_type.type,
773 ._qualifiers = referenced_type.qualifiers,
774 ._program = prog,
775 ._language = lang ? lang : drgn_program_language(prog),
776 };
777 err = drgn_type_init_byte_order(&key, byte_order);
778 if (err)
779 return err;
780 return find_or_create_type(&key, ret);
781 }
782
783 struct drgn_error *
784 drgn_array_type_create(struct drgn_program *prog,
785 struct drgn_qualified_type element_type,
786 uint64_t length, const struct drgn_language *lang,
787 struct drgn_type **ret)
788 {
789 if (drgn_type_program(element_type.type) != prog) {
790 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
791 "type is from different program");
792 }
793
794 struct drgn_type key = {
795 ._kind = DRGN_TYPE_ARRAY,
796 ._primitive = DRGN_NOT_PRIMITIVE_TYPE,
797 ._flags = DRGN_TYPE_FLAG_IS_COMPLETE,
798 ._length = length,
799 ._type = element_type.type,
800 ._qualifiers = element_type.qualifiers,
801 ._program = prog,
802 ._language = lang ? lang : drgn_program_language(prog),
803 };
804 return find_or_create_type(&key, ret);
805 }
806
807 struct drgn_error *
808 drgn_incomplete_array_type_create(struct drgn_program *prog,
809 struct drgn_qualified_type element_type,
810 const struct drgn_language *lang,
811 struct drgn_type **ret)
812 {
813 if (drgn_type_program(element_type.type) != prog) {
814 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
815 "type is from different program");
816 }
817
818 struct drgn_type key = {
819 ._kind = DRGN_TYPE_ARRAY,
820 ._primitive = DRGN_NOT_PRIMITIVE_TYPE,
821 ._type = element_type.type,
822 ._qualifiers = element_type.qualifiers,
823 ._program = prog,
824 ._language = lang ? lang : drgn_program_language(prog),
825 };
826 return find_or_create_type(&key, ret);
827 }
828
829 DEFINE_VECTOR_FUNCTIONS(drgn_type_parameter_vector);
830
831 void drgn_function_type_builder_init(struct drgn_function_type_builder *builder,
832 struct drgn_program *prog)
833 {
834 drgn_template_parameters_builder_init(&builder->template_builder, prog);
835 drgn_type_parameter_vector_init(&builder->parameters);
836 }
837
838 void
839 drgn_function_type_builder_deinit(struct drgn_function_type_builder *builder)
840 {
841 vector_for_each(drgn_type_parameter_vector, parameter,
842 &builder->parameters)
843 drgn_lazy_object_deinit(&parameter->default_argument);
844 drgn_type_parameter_vector_deinit(&builder->parameters);
845 drgn_template_parameters_builder_deinit(&builder->template_builder);
846 }
847
848 struct drgn_error *
849 drgn_function_type_builder_add_parameter(struct drgn_function_type_builder *builder,
850 const union drgn_lazy_object *default_argument,
851 const char *name)
852 {
853 struct drgn_error *err =
854 drgn_lazy_object_check_prog(default_argument,
855 builder->template_builder.prog);
856 if (err)
857 return err;
858 struct drgn_type_parameter *parameter =
859 drgn_type_parameter_vector_append_entry(&builder->parameters);
860 if (!parameter)
861 return &drgn_enomem;
862 parameter->default_argument = *default_argument;
863 parameter->name = name;
864 return NULL;
865 }
866
867 struct drgn_error *
868 drgn_function_type_create(struct drgn_function_type_builder *builder,
869 struct drgn_qualified_type return_type,
870 bool is_variadic, const struct drgn_language *lang,
871 struct drgn_type **ret)
872 {
873 struct drgn_program *prog = builder->template_builder.prog;
874
875 if (drgn_type_program(return_type.type) != prog) {
876 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
877 "type is from different program");
878 }
879
880 drgn_type_parameter_vector_shrink_to_fit(&builder->parameters);
881 drgn_type_template_parameter_vector_shrink_to_fit(&builder->template_builder.parameters);
882
883 _cleanup_free_ struct drgn_templated_type *type = malloc(sizeof(*type));
884 if (!type ||!drgn_typep_vector_append(&prog->created_types,
885 (struct drgn_type **)&type))
886 return &drgn_enomem;
887 *type = (struct drgn_templated_type){
888 .extended = {
889 .type = {
890 ._kind = DRGN_TYPE_FUNCTION,
891 ._primitive = DRGN_NOT_PRIMITIVE_TYPE,
892 ._flags = (DRGN_TYPE_FLAG_IS_COMPLETE
893 | (is_variadic ? DRGN_TYPE_FLAG_IS_VARIADIC : 0)),
894 ._type = return_type.type,
895 ._qualifiers = return_type.qualifiers,
896 ._program = prog,
897 ._language = lang ? lang : drgn_program_language(prog),
898 },
899 },
900 };
901 drgn_type_parameter_vector_steal(&builder->parameters,
902 &type->extended.type._parameters,
903 &type->extended.type._num_parameters);
904 drgn_type_template_parameter_vector_steal(&builder->template_builder.parameters,
905 &type->_template_parameters,
906 &type->_num_template_parameters);
907 *ret = &no_cleanup_ptr(type)->extended.type;
908 return NULL;
909 }
910
911 static struct drgn_error *
912 drgn_type_with_byte_order_impl(struct drgn_type **type,
913 struct drgn_type **underlying_type,
914 enum drgn_byte_order byte_order)
915 {
916 struct drgn_error *err;
917 switch (drgn_type_kind(*type)) {
918 case DRGN_TYPE_INT:
919 err = drgn_int_type_create(drgn_type_program(*type),
920 drgn_type_name(*type),
921 drgn_type_size(*type),
922 drgn_type_is_signed(*type),
923 byte_order,
924 drgn_type_language(*type), type);
925 if (!err)
926 *underlying_type = *type;
927 return err;
928 case DRGN_TYPE_BOOL:
929 err = drgn_bool_type_create(drgn_type_program(*type),
930 drgn_type_name(*type),
931 drgn_type_size(*type), byte_order,
932 drgn_type_language(*type), type);
933 if (!err)
934 *underlying_type = *type;
935 return err;
936 case DRGN_TYPE_FLOAT:
937 err = drgn_float_type_create(drgn_type_program(*type),
938 drgn_type_name(*type),
939 drgn_type_size(*type), byte_order,
940 drgn_type_language(*type), type);
941 if (!err)
942 *underlying_type = *type;
943 return err;
944 case DRGN_TYPE_POINTER:
945 err = drgn_pointer_type_create(drgn_type_program(*type),
946 drgn_type_type(*type),
947 drgn_type_size(*type),
948 byte_order,
949 drgn_type_language(*type), type);
950 if (!err)
951 *underlying_type = *type;
952 return err;
953 case DRGN_TYPE_TYPEDEF: {
954 struct drgn_qualified_type aliased_type = drgn_type_type(*type);
955 err = drgn_type_with_byte_order_impl(&aliased_type.type,
956 underlying_type,
957 byte_order);
958 if (err)
959 return err;
960 return drgn_typedef_type_create(drgn_type_program(*type),
961 drgn_type_name(*type),
962 aliased_type,
963 drgn_type_language(*type),
964 type);
965 }
966 case DRGN_TYPE_ENUM: {
967 assert(drgn_type_is_complete(*type));
968 struct drgn_type *compatible_type = drgn_type_type(*type).type;
969 struct drgn_type *unused;
970 err = drgn_type_with_byte_order_impl(&compatible_type, &unused,
971 byte_order);
972 if (err)
973 return err;
974 struct drgn_enum_type_builder builder;
975 drgn_enum_type_builder_init(&builder,
976 drgn_type_program(*type));
977 size_t num_enumerators =
978 drgn_type_num_enumerators(*type);
979 if (num_enumerators) {
980 if (!drgn_type_enumerator_vector_resize(&builder.enumerators,
981 num_enumerators)) {
982 drgn_enum_type_builder_deinit(&builder);
983 return &drgn_enomem;
984 }
985 memcpy(drgn_type_enumerator_vector_begin(&builder.enumerators),
986 drgn_type_enumerators(*type),
987 num_enumerators * sizeof(struct drgn_type_enumerator));
988 }
989 err = drgn_enum_type_create(&builder, drgn_type_tag(*type),
990 compatible_type,
991 drgn_type_language(*type), type);
992 if (err) {
993 drgn_enum_type_builder_deinit(&builder);
994 return err;
995 }
996 *underlying_type = *type;
997 return err;
998 }
999 default:
1000 return NULL;
1001 }
1002 }
1003
1004 struct drgn_error *
1005 drgn_type_with_byte_order(struct drgn_type **type,
1006 struct drgn_type **underlying_type,
1007 enum drgn_byte_order byte_order)
1008 {
1009 struct drgn_error *err;
1010 bool type_little_endian;
1011 if (drgn_type_has_little_endian(*underlying_type)) {
1012 type_little_endian =
1013 drgn_type_little_endian(*underlying_type);
1014 } else if (drgn_type_kind(*underlying_type) == DRGN_TYPE_ENUM &&
1015 drgn_type_is_complete(*underlying_type)) {
1016 type_little_endian =
1017 drgn_type_little_endian(drgn_type_type(*underlying_type).type);
1018 } else {
1019 return NULL;
1020 }
1021 bool little_endian;
1022 SWITCH_ENUM(byte_order) {
1023 case DRGN_BIG_ENDIAN:
1024 little_endian = false;
1025 break;
1026 case DRGN_LITTLE_ENDIAN:
1027 little_endian = true;
1028 break;
1029 case DRGN_PROGRAM_ENDIAN:
1030 err = drgn_program_is_little_endian(drgn_type_program(*underlying_type),
1031 &little_endian);
1032 if (err)
1033 return err;
1034 break;
1035 default:
1036 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
1037 "invalid byte order");
1038 }
1039 if (type_little_endian == little_endian)
1040 return NULL;
1041 return drgn_type_with_byte_order_impl(type, underlying_type,
1042 drgn_byte_order_from_little_endian(little_endian));
1043 }
1044
1045 LIBDRGN_PUBLIC struct drgn_error *
1046 drgn_format_type_name(struct drgn_qualified_type qualified_type, char **ret)
1047 {
1048 const struct drgn_language *lang = drgn_type_language(qualified_type.type);
1049 return lang->format_type_name(qualified_type, ret);
1050 }
1051
1052 LIBDRGN_PUBLIC struct drgn_error *
1053 drgn_format_type(struct drgn_qualified_type qualified_type, char **ret)
1054 {
1055 const struct drgn_language *lang = drgn_type_language(qualified_type.type);
1056 return lang->format_type(qualified_type, ret);
1057 }
1058
1059 LIBDRGN_PUBLIC struct drgn_error *
1060 drgn_format_variable_declaration(struct drgn_qualified_type qualified_type,
1061 const char *name, char **ret)
1062 {
1063 const struct drgn_language *lang = drgn_type_language(qualified_type.type);
1064 return lang->format_variable_declaration(qualified_type, name, ret);
1065 }
1066
1067 bool drgn_type_is_integer(struct drgn_type *type)
1068 {
1069 switch (drgn_type_kind(type)) {
1070 case DRGN_TYPE_INT:
1071 case DRGN_TYPE_BOOL:
1072 case DRGN_TYPE_ENUM:
1073 return true;
1074 case DRGN_TYPE_TYPEDEF:
1075 return drgn_type_is_integer(drgn_type_type(type).type);
1076 default:
1077 return false;
1078 }
1079 }
1080
1081 bool drgn_type_is_arithmetic(struct drgn_type *type)
1082 {
1083 switch (drgn_type_kind(type)) {
1084 case DRGN_TYPE_INT:
1085 case DRGN_TYPE_BOOL:
1086 case DRGN_TYPE_FLOAT:
1087 case DRGN_TYPE_ENUM:
1088 return true;
1089 case DRGN_TYPE_TYPEDEF:
1090 return drgn_type_is_arithmetic(drgn_type_type(type).type);
1091 default:
1092 return false;
1093 }
1094 }
1095
1096 bool drgn_type_is_scalar(struct drgn_type *type)
1097 {
1098 switch (drgn_type_kind(type)) {
1099 case DRGN_TYPE_INT:
1100 case DRGN_TYPE_BOOL:
1101 case DRGN_TYPE_FLOAT:
1102 case DRGN_TYPE_ENUM:
1103 case DRGN_TYPE_POINTER:
1104 return true;
1105 case DRGN_TYPE_TYPEDEF:
1106 return drgn_type_is_scalar(drgn_type_type(type).type);
1107 default:
1108 return false;
1109 }
1110 }
1111
1112 LIBDRGN_PUBLIC struct drgn_error *drgn_type_sizeof(struct drgn_type *type,
1113 uint64_t *ret)
1114 {
1115 struct drgn_error *err;
1116 enum drgn_type_kind kind = drgn_type_kind(type);
1117
1118 if (!drgn_type_is_complete(type)) {
1119 return drgn_error_format(DRGN_ERROR_TYPE,
1120 "cannot get size of incomplete %s type",
1121 drgn_type_kind_spelling[kind]);
1122 }
1123 SWITCH_ENUM(kind) {
1124 case DRGN_TYPE_INT:
1125 case DRGN_TYPE_BOOL:
1126 case DRGN_TYPE_FLOAT:
1127 case DRGN_TYPE_POINTER:
1128 *ret = drgn_type_size(type);
1129 return NULL;
1130 case DRGN_TYPE_STRUCT:
1131 case DRGN_TYPE_UNION:
1132 case DRGN_TYPE_CLASS:
1133 *ret = drgn_type_size(type);
1134 return NULL;
1135 case DRGN_TYPE_ENUM:
1136 case DRGN_TYPE_TYPEDEF:
1137 return drgn_type_sizeof(drgn_type_type(type).type, ret);
1138 case DRGN_TYPE_ARRAY:
1139 err = drgn_type_sizeof(drgn_type_type(type).type, ret);
1140 if (err)
1141 return err;
1142 if (__builtin_mul_overflow(*ret, drgn_type_length(type), ret)) {
1143 return drgn_error_create(DRGN_ERROR_OVERFLOW,
1144 "type size is too large");
1145 }
1146 return NULL;
1147 case DRGN_TYPE_VOID:
1148 return drgn_error_create(DRGN_ERROR_TYPE,
1149 "cannot get size of void type");
1150 case DRGN_TYPE_FUNCTION:
1151 return drgn_error_create(DRGN_ERROR_TYPE,
1152 "cannot get size of function type");
1153 default:
1154 UNREACHABLE();
1155 }
1156 }
1157
1158 struct drgn_error *drgn_type_bit_size(struct drgn_type *type, uint64_t *ret)
1159 {
1160 struct drgn_error *err;
1161
1162 err = drgn_type_sizeof(type, ret);
1163 if (err)
1164 return err;
1165 if (__builtin_mul_overflow(*ret, 8U, ret)) {
1166 return drgn_error_create(DRGN_ERROR_OVERFLOW,
1167 "type bit size is too large");
1168 }
1169 return NULL;
1170 }
1171
1172 LIBDRGN_PUBLIC
1173 struct drgn_error *drgn_type_alignof(struct drgn_qualified_type qualified_type,
1174 uint64_t *ret)
1175 {
1176
1177 struct drgn_error *err;
1178
1179 drgn_recursion_guard(1000, "maximum type depth exceeded in alignof()");
1180
1181 // The C standard says that "the size, representation, and alignment of
1182 // an atomic type need not be the same as those of the corresponding
1183 // unqualified type", so we take the qualified type to be future-proof.
1184 struct drgn_type *type = qualified_type.type;
1185 if (!drgn_type_is_complete(type)) {
1186 return drgn_error_incomplete_type("cannot get alignment of %s type",
1187 type);
1188 }
1189
1190 // Check if the type has explicit alignment.
1191 if (drgn_type_has_die_addr(type)) {
1192 err = drgn_dwarf_type_alignment(type, ret);
1193 if (err != &drgn_not_found)
1194 return err;
1195 }
1196
1197 SWITCH_ENUM(drgn_type_kind(type)) {
1198 case DRGN_TYPE_INT:
1199 case DRGN_TYPE_BOOL:
1200 case DRGN_TYPE_FLOAT:
1201 case DRGN_TYPE_POINTER: {
1202 struct drgn_program *prog = drgn_type_program(type);
1203 if (!prog->has_platform) {
1204 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
1205 "program alignment requirements are not known");
1206 }
1207 const struct drgn_architecture_info *arch = prog->platform.arch;
1208 uint64_t size = drgn_type_size(type);
1209 int i;
1210 if (size == 0)
1211 i = 0;
1212 else if (size >= (1 << array_size(arch->scalar_alignment)))
1213 i = array_size(arch->scalar_alignment) - 1;
1214 else
1215 i = ilog2(size);
1216 if (arch->scalar_alignment[i] == 0) {
1217 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
1218 "program alignment requirements are not known");
1219 }
1220 *ret = arch->scalar_alignment[i];
1221 return NULL;
1222 }
1223 case DRGN_TYPE_STRUCT:
1224 case DRGN_TYPE_UNION:
1225 case DRGN_TYPE_CLASS: {
1226 uint64_t alignment = 1;
1227 struct drgn_type_member *members = drgn_type_members(type);
1228 size_t num_members = drgn_type_num_members(type);
1229 for (size_t i = 0; i < num_members; i++) {
1230 struct drgn_qualified_type member_type;
1231 err = drgn_member_type(&members[i], &member_type, NULL);
1232 if (err)
1233 return err;
1234 uint64_t member_alignment;
1235 err = drgn_type_alignof(member_type, &member_alignment);
1236 if (err)
1237 return err;
1238 if (member_alignment > alignment)
1239 alignment = member_alignment;
1240 }
1241 *ret = alignment;
1242 return NULL;
1243 }
1244 case DRGN_TYPE_ENUM:
1245 case DRGN_TYPE_TYPEDEF:
1246 case DRGN_TYPE_ARRAY:
1247 return drgn_type_alignof(drgn_type_type(type), ret);
1248 case DRGN_TYPE_FUNCTION:
1249 return drgn_error_create(DRGN_ERROR_TYPE,
1250 "cannot get alignment of function type");
1251 // void is handled by the drgn_type_is_complete() check.
1252 case DRGN_TYPE_VOID:
1253 default:
1254 UNREACHABLE();
1255 }
1256 }
1257
1258 struct drgn_error *drgn_type_error(const char *format, struct drgn_type *type)
1259 {
1260 struct drgn_qualified_type qualified_type = { type };
1261
1262 return drgn_qualified_type_error(format, qualified_type);
1263 }
1264
1265 struct drgn_error *
1266 drgn_qualified_type_error(const char *format,
1267 struct drgn_qualified_type qualified_type)
1268 {
1269 struct drgn_error *err;
1270 _cleanup_free_ char *name = NULL;
1271 err = drgn_format_type_name(qualified_type, &name);
1272 if (err)
1273 return err;
1274 return drgn_error_format(DRGN_ERROR_TYPE, format, name);
1275 }
1276
1277 struct drgn_error *
1278 drgn_2_qualified_types_error(const char *format,
1279 struct drgn_qualified_type qualified_type1,
1280 struct drgn_qualified_type qualified_type2)
1281 {
1282 struct drgn_error *err;
1283 _cleanup_free_ char *name1 = NULL;
1284 err = drgn_format_type_name(qualified_type1, &name1);
1285 if (err)
1286 return err;
1287 _cleanup_free_ char *name2 = NULL;
1288 err = drgn_format_type_name(qualified_type2, &name2);
1289 if (err)
1290 return err;
1291 return drgn_error_format(DRGN_ERROR_TYPE, format, name1, name2);
1292 }
1293
1294 struct drgn_error *drgn_error_incomplete_type(const char *format,
1295 struct drgn_type *type)
1296 {
1297 switch (drgn_type_kind(drgn_underlying_type(type))) {
1298 case DRGN_TYPE_STRUCT:
1299 return drgn_error_format(DRGN_ERROR_TYPE, format,
1300 "incomplete structure");
1301 case DRGN_TYPE_UNION:
1302 return drgn_error_format(DRGN_ERROR_TYPE, format,
1303 "incomplete union");
1304 case DRGN_TYPE_CLASS:
1305 return drgn_error_format(DRGN_ERROR_TYPE, format,
1306 "incomplete class");
1307 case DRGN_TYPE_ENUM:
1308 return drgn_error_format(DRGN_ERROR_TYPE, format,
1309 "incomplete enumerated");
1310 case DRGN_TYPE_ARRAY:
1311 return drgn_error_format(DRGN_ERROR_TYPE, format,
1312 "incomplete array");
1313 case DRGN_TYPE_FUNCTION:
1314 return drgn_error_format(DRGN_ERROR_TYPE, format, "function");
1315 case DRGN_TYPE_VOID:
1316 return drgn_error_format(DRGN_ERROR_TYPE, format, "void");
1317 default:
1318 UNREACHABLE();
1319 }
1320 }
1321
1322 void drgn_program_init_types(struct drgn_program *prog)
1323 {
1324 for (size_t i = 0; i < array_size(prog->void_types); i++) {
1325 struct drgn_type *type = &prog->void_types[i];
1326 type->_kind = DRGN_TYPE_VOID;
1327 type->_primitive = DRGN_C_TYPE_VOID;
1328 type->_flags = 0;
1329 type->_program = prog;
1330 type->_language = drgn_languages[i];
1331 }
1332 drgn_dedupe_type_set_init(&prog->dedupe_types);
1333 drgn_typep_vector_init(&prog->created_types);
1334 drgn_member_map_init(&prog->members);
1335 drgn_type_set_init(&prog->members_cached);
1336 }
1337
1338 void drgn_program_deinit_types(struct drgn_program *prog)
1339 {
1340 drgn_member_map_deinit(&prog->members);
1341 drgn_type_set_deinit(&prog->members_cached);
1342
1343 vector_for_each(drgn_typep_vector, typep, &prog->created_types) {
1344 struct drgn_type *type = *typep;
1345 if (drgn_type_has_members(type)) {
1346 struct drgn_type_member *members =
1347 drgn_type_members(type);
1348 size_t num_members = drgn_type_num_members(type);
1349 for (size_t j = 0; j < num_members; j++)
1350 drgn_lazy_object_deinit(&members[j].object);
1351 free(members);
1352 }
1353 if (drgn_type_has_enumerators(type))
1354 free(drgn_type_enumerators(type));
1355 if (drgn_type_has_parameters(type)) {
1356 struct drgn_type_parameter *parameters =
1357 drgn_type_parameters(type);
1358 size_t num_parameters = drgn_type_num_parameters(type);
1359 for (size_t j = 0; j < num_parameters; j++)
1360 drgn_lazy_object_deinit(&parameters[j].default_argument);
1361 free(parameters);
1362 }
1363 if (drgn_type_has_template_parameters(type)) {
1364 struct drgn_type_template_parameter *template_parameters =
1365 drgn_type_template_parameters(type);
1366 size_t num_template_parameters =
1367 drgn_type_num_template_parameters(type);
1368 for (size_t j = 0; j < num_template_parameters; j++)
1369 drgn_lazy_object_deinit(&template_parameters[j].argument);
1370 free(template_parameters);
1371 }
1372 free(type);
1373 }
1374 drgn_typep_vector_deinit(&prog->created_types);
1375
1376 hash_table_for_each(drgn_dedupe_type_set, it, &prog->dedupe_types)
1377 free(*it.entry);
1378 drgn_dedupe_type_set_deinit(&prog->dedupe_types);
1379
1380 drgn_handler_list_deinit(struct drgn_type_finder, finder,
1381 &prog->type_finders,
1382 if (finder->ops.destroy)
1383 finder->ops.destroy(finder->arg);
1384 );
1385 }
1386
1387 struct drgn_error *drgn_program_find_type_impl(struct drgn_program *prog,
1388 uint64_t kinds, const char *name,
1389 size_t name_len,
1390 const char *filename,
1391 struct drgn_qualified_type *ret)
1392 {
1393 drgn_handler_list_for_each_enabled(struct drgn_type_finder, finder,
1394 &prog->type_finders) {
1395 struct drgn_error *err =
1396 finder->ops.find(kinds, name, name_len, filename,
1397 finder->arg, ret);
1398 if (!err) {
1399 if (drgn_type_program(ret->type) != prog) {
1400 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
1401 "type find callback returned type from wrong program");
1402 }
1403 if (!(kinds & (UINT64_C(1) << drgn_type_kind(ret->type)))) {
1404 return drgn_error_create(DRGN_ERROR_TYPE,
1405 "type find callback returned wrong kind of type");
1406 }
1407 return NULL;
1408 }
1409 if (err != &drgn_not_found)
1410 return err;
1411 }
1412 return &drgn_not_found;
1413 }
1414
1415 LIBDRGN_PUBLIC struct drgn_error *
1416 drgn_program_find_type(struct drgn_program *prog, const char *name,
1417 const char *filename, struct drgn_qualified_type *ret)
1418 {
1419 struct drgn_error *err;
1420 const struct drgn_language *lang = drgn_program_language(prog);
1421 err = lang->find_type(lang, prog, name, filename, ret);
1422 if (err != &drgn_not_found)
1423 return err;
1424
1425 if (filename) {
1426 return drgn_error_format(DRGN_ERROR_LOOKUP,
1427 "could not find '%s' in '%s'", name,
1428 filename);
1429 } else {
1430 return drgn_error_format(DRGN_ERROR_LOOKUP,
1431 "could not find '%s'", name);
1432 }
1433 }
1434
1435 /*
1436 * size_t and ptrdiff_t default to typedefs of whatever integer type matches the
1437 * word size.
1438 */
1439 static struct drgn_error *
1440 default_size_t_or_ptrdiff_t(struct drgn_program *prog,
1441 enum drgn_primitive_type type,
1442 struct drgn_type **ret)
1443 {
1444 static const enum drgn_primitive_type integer_types[2][3] = {
1445 {
1446 DRGN_C_TYPE_UNSIGNED_LONG,
1447 DRGN_C_TYPE_UNSIGNED_LONG_LONG,
1448 DRGN_C_TYPE_UNSIGNED_INT,
1449 },
1450 {
1451 DRGN_C_TYPE_LONG,
1452 DRGN_C_TYPE_LONG_LONG,
1453 DRGN_C_TYPE_INT,
1454 },
1455 };
1456 struct drgn_error *err;
1457 uint64_t address_size;
1458 err = drgn_program_address_size(prog, &address_size);
1459 if (err)
1460 return err;
1461 array_for_each(integer_type,
1462 integer_types[type == DRGN_C_TYPE_PTRDIFF_T]) {
1463 struct drgn_qualified_type qualified_type;
1464 err = drgn_program_find_primitive_type(prog, *integer_type,
1465 &qualified_type.type);
1466 if (err)
1467 return err;
1468 if (drgn_type_size(qualified_type.type) == address_size) {
1469 qualified_type.qualifiers = 0;
1470 return drgn_typedef_type_create(prog,
1471 drgn_primitive_type_spellings[type][0],
1472 qualified_type,
1473 &drgn_language_c, ret);
1474 }
1475 }
1476 return drgn_error_format(DRGN_ERROR_INVALID_ARGUMENT,
1477 "no suitable integer type for %s",
1478 drgn_primitive_type_spellings[type][0]);
1479 }
1480
1481 struct drgn_error *
1482 drgn_program_find_primitive_type(struct drgn_program *prog,
1483 enum drgn_primitive_type type,
1484 struct drgn_type **ret)
1485 {
1486 struct drgn_error *err;
1487 struct drgn_qualified_type qualified_type;
1488 enum drgn_type_kind kind;
1489 const char * const *spellings;
1490 size_t i;
1491
1492 if (prog->primitive_types[type]) {
1493 *ret = prog->primitive_types[type];
1494 return NULL;
1495 }
1496
1497 kind = drgn_primitive_type_kind[type];
1498 if (kind == DRGN_TYPE_VOID) {
1499 *ret = drgn_void_type(prog, &drgn_language_c);
1500 goto out;
1501 }
1502
1503 spellings = drgn_primitive_type_spellings[type];
1504 for (i = 0; spellings[i]; i++) {
1505 err = drgn_program_find_type_impl(prog, UINT64_C(1) << kind,
1506 spellings[i],
1507 strlen(spellings[i]), NULL,
1508 &qualified_type);
1509 if (!err && drgn_type_primitive(qualified_type.type) == type) {
1510 *ret = qualified_type.type;
1511 goto out;
1512 } else if (err && err != &drgn_not_found) {
1513 return err;
1514 }
1515 }
1516
1517 switch (type) {
1518 case DRGN_C_TYPE_CHAR:
1519 case DRGN_C_TYPE_SIGNED_CHAR:
1520 err = drgn_int_type_create(prog, spellings[0], 1, true,
1521 DRGN_PROGRAM_ENDIAN,
1522 &drgn_language_c, ret);
1523 break;
1524 case DRGN_C_TYPE_UNSIGNED_CHAR:
1525 err = drgn_int_type_create(prog, spellings[0], 1, false,
1526 DRGN_PROGRAM_ENDIAN,
1527 &drgn_language_c, ret);
1528 break;
1529 case DRGN_C_TYPE_SHORT:
1530 err = drgn_int_type_create(prog, spellings[0], 2, true,
1531 DRGN_PROGRAM_ENDIAN,
1532 &drgn_language_c, ret);
1533 break;
1534 case DRGN_C_TYPE_UNSIGNED_SHORT:
1535 err = drgn_int_type_create(prog, spellings[0], 2, false,
1536 DRGN_PROGRAM_ENDIAN,
1537 &drgn_language_c, ret);
1538 break;
1539 case DRGN_C_TYPE_INT:
1540 err = drgn_int_type_create(prog, spellings[0], 4, true,
1541 DRGN_PROGRAM_ENDIAN,
1542 &drgn_language_c, ret);
1543 break;
1544 case DRGN_C_TYPE_UNSIGNED_INT:
1545 err = drgn_int_type_create(prog, spellings[0], 4, false,
1546 DRGN_PROGRAM_ENDIAN,
1547 &drgn_language_c, ret);
1548 break;
1549 /* long and unsigned long default to the word size. */
1550 case DRGN_C_TYPE_LONG:
1551 case DRGN_C_TYPE_UNSIGNED_LONG: {
1552 uint64_t address_size;
1553 err = drgn_program_address_size(prog, &address_size);
1554 if (err)
1555 break;
1556 err = drgn_int_type_create(prog, spellings[0], address_size,
1557 type == DRGN_C_TYPE_LONG,
1558 DRGN_PROGRAM_ENDIAN,
1559 &drgn_language_c, ret);
1560 break;
1561 }
1562 case DRGN_C_TYPE_LONG_LONG:
1563 err = drgn_int_type_create(prog, spellings[0], 8, true,
1564 DRGN_PROGRAM_ENDIAN,
1565 &drgn_language_c, ret);
1566 break;
1567 case DRGN_C_TYPE_UNSIGNED_LONG_LONG:
1568 err = drgn_int_type_create(prog, spellings[0], 8, false,
1569 DRGN_PROGRAM_ENDIAN,
1570 &drgn_language_c, ret);
1571 break;
1572 case DRGN_C_TYPE_BOOL:
1573 err = drgn_bool_type_create(prog, spellings[0], 1,
1574 DRGN_PROGRAM_ENDIAN,
1575 &drgn_language_c, ret);
1576 break;
1577 case DRGN_C_TYPE_FLOAT:
1578 err = drgn_float_type_create(prog, spellings[0], 4,
1579 DRGN_PROGRAM_ENDIAN,
1580 &drgn_language_c, ret);
1581 break;
1582 case DRGN_C_TYPE_DOUBLE:
1583 err = drgn_float_type_create(prog, spellings[0], 8,
1584 DRGN_PROGRAM_ENDIAN,
1585 &drgn_language_c, ret);
1586 break;
1587 case DRGN_C_TYPE_LONG_DOUBLE:
1588 err = drgn_float_type_create(prog, spellings[0], 16,
1589 DRGN_PROGRAM_ENDIAN,
1590 &drgn_language_c, ret);
1591 break;
1592 case DRGN_C_TYPE_SIZE_T:
1593 case DRGN_C_TYPE_PTRDIFF_T:
1594 err = default_size_t_or_ptrdiff_t(prog, type, ret);
1595 break;
1596 default:
1597 UNREACHABLE();
1598 }
1599 if (err)
1600 return err;
1601 assert(drgn_type_primitive(*ret) == type);
1602
1603 out:
1604 prog->primitive_types[type] = *ret;
1605 return NULL;
1606 }
1607
1608 static struct drgn_error *
1609 drgn_type_cache_members(struct drgn_type *outer_type,
1610 struct drgn_type *type, uint64_t bit_offset)
1611 {
1612 struct drgn_program *prog = drgn_type_program(outer_type);
1613
1614 if (!drgn_type_has_members(type))
1615 return NULL;
1616
1617 struct drgn_type_member *members = drgn_type_members(type);
1618 size_t num_members = drgn_type_num_members(type);
1619 for (size_t i = 0; i < num_members; i++) {
1620 struct drgn_type_member *member = &members[i];
1621 if (member->name) {
1622 struct drgn_member_map_entry entry = {
1623 .key = {
1624 .type = outer_type,
1625 .name = member->name,
1626 .name_len = strlen(member->name),
1627 },
1628 .value = {
1629 .member = member,
1630 .bit_offset =
1631 bit_offset + member->bit_offset,
1632 },
1633 };
1634 if (drgn_member_map_insert(&prog->members, &entry,
1635 NULL) == -1)
1636 return &drgn_enomem;
1637 } else {
1638 struct drgn_qualified_type member_type;
1639 struct drgn_error *err = drgn_member_type(member,
1640 &member_type,
1641 NULL);
1642 if (err)
1643 return err;
1644 err = drgn_type_cache_members(outer_type,
1645 member_type.type,
1646 bit_offset +
1647 member->bit_offset);
1648 if (err)
1649 return err;
1650 }
1651 }
1652 return NULL;
1653 }
1654
1655 LIBDRGN_PUBLIC struct drgn_error *
1656 drgn_type_offsetof(struct drgn_type *type, const char *member_designator,
1657 uint64_t *ret)
1658 {
1659
1660 struct drgn_error *err;
1661 const struct drgn_language *lang = drgn_type_language(type);
1662 uint64_t bit_offset;
1663 err = lang->type_subobject(type, member_designator, true, NULL,
1664 &bit_offset, NULL);
1665 if (err)
1666 return err;
1667 if (bit_offset % 8) {
1668 return drgn_error_format(DRGN_ERROR_INVALID_ARGUMENT,
1669 "member is not byte-aligned");
1670 }
1671 *ret = bit_offset / 8;
1672 return NULL;
1673 }
1674
1675 static struct drgn_error *
1676 drgn_type_find_member_impl(struct drgn_type *type, const char *member_name,
1677 size_t member_name_len,
1678 struct drgn_member_value **ret)
1679 {
1680 struct drgn_program *prog = drgn_type_program(type);
1681 const struct drgn_member_key key = {
1682 .type = drgn_underlying_type(type),
1683 .name = member_name,
1684 .name_len = member_name_len,
1685 };
1686 struct hash_pair hp = drgn_member_map_hash(&key);
1687 struct drgn_member_map_iterator it =
1688 drgn_member_map_search_hashed(&prog->members, &key, hp);
1689 if (it.entry) {
1690 *ret = &it.entry->value;
1691 return NULL;
1692 }
1693
1694 /*
1695 * Cache miss. One of the following is true:
1696 *
1697 * 1. The type isn't a structure, union, or class, which is a type
1698 * error.
1699 * 2. The type hasn't been cached, which means we need to cache it and
1700 * check again.
1701 * 3. The type has already been cached, which means the member doesn't
1702 * exist.
1703 */
1704 if (!drgn_type_has_members(key.type)) {
1705 return drgn_type_error("'%s' is not a structure, union, or class",
1706 type);
1707 }
1708 struct hash_pair cached_hp = drgn_type_set_hash(&key.type);
1709 if (drgn_type_set_search_hashed(&prog->members_cached, &key.type,
1710 cached_hp).entry) {
1711 *ret = NULL;
1712 return NULL;
1713 }
1714
1715 struct drgn_error *err = drgn_type_cache_members(key.type, key.type, 0);
1716 if (err)
1717 return err;
1718
1719 if (drgn_type_set_insert_searched(&prog->members_cached, &key.type,
1720 cached_hp, NULL) == -1)
1721 return &drgn_enomem;
1722
1723 it = drgn_member_map_search_hashed(&prog->members, &key, hp);
1724 if (it.entry) {
1725 *ret = &it.entry->value;
1726 return NULL;
1727 }
1728
1729 *ret = NULL;
1730 return NULL;
1731 }
1732
1733 LIBDRGN_PUBLIC struct drgn_error *
1734 drgn_type_find_member_len(struct drgn_type *type, const char *member_name,
1735 size_t member_name_len,
1736 struct drgn_type_member **member_ret,
1737 uint64_t *bit_offset_ret)
1738 {
1739 struct drgn_error *err;
1740 struct drgn_member_value *member;
1741 err = drgn_type_find_member_impl(type, member_name, member_name_len,
1742 &member);
1743 if (err)
1744 return err;
1745 if (!member) {
1746 struct drgn_qualified_type qualified_type = { type };
1747 _cleanup_free_ char *type_name = NULL;
1748 err = drgn_format_type_name(qualified_type, &type_name);
1749 if (err)
1750 return err;
1751 return drgn_error_format(DRGN_ERROR_LOOKUP,
1752 "'%s' has no member '%.*s'",
1753 type_name,
1754 member_name_len > INT_MAX ?
1755 INT_MAX : (int)member_name_len,
1756 member_name);
1757 }
1758 *member_ret = member->member;
1759 *bit_offset_ret = member->bit_offset;
1760 return NULL;
1761 }
1762
1763 LIBDRGN_PUBLIC struct drgn_error *
1764 drgn_type_has_member_len(struct drgn_type *type, const char *member_name,
1765 size_t member_name_len, bool *ret)
1766 {
1767 struct drgn_error *err;
1768 struct drgn_member_value *member;
1769 err = drgn_type_find_member_impl(type, member_name, member_name_len,
1770 &member);
1771 if (err)
1772 return err;
1773 *ret = member != NULL;
1774 return NULL;
1775 }