Debian Codegraph @

libdrgn/python/type.c

raw
1 // Copyright (c) Meta Platforms, Inc. and affiliates.
2 // SPDX-License-Identifier: LGPL-2.1-or-later
3
4 #include <stdarg.h>
5
6 #include "drgnpy.h"
7 #include "../lazy_object.h"
8 #include "../platform.h"
9 #include "../program.h"
10 #include "../type.h"
11 #include "../util.h"
12
13 /* Sentinel values for LazyObject::lazy_obj. */
14 static const union drgn_lazy_object drgnpy_lazy_object_evaluated;
15 #define DRGNPY_LAZY_OBJECT_EVALUATED ((union drgn_lazy_object *)&drgnpy_lazy_object_evaluated)
16 static const union drgn_lazy_object drgnpy_lazy_object_callable;
17 #define DRGNPY_LAZY_OBJECT_CALLABLE ((union drgn_lazy_object *)&drgnpy_lazy_object_callable)
18
19 static const char *drgn_type_kind_str(struct drgn_type *type)
20 {
21 return drgn_type_kind_spelling[drgn_type_kind(type)];
22 }
23
24 DRGNPY_PUBLIC PyObject *DrgnType_wrap(struct drgn_qualified_type qualified_type)
25 {
26 _cleanup_pydecref_ DrgnType *type_obj = call_tp_alloc(DrgnType);
27 if (!type_obj)
28 return NULL;
29 type_obj->type = qualified_type.type;
30 type_obj->qualifiers = qualified_type.qualifiers;
31 Py_INCREF(DrgnType_prog(type_obj));
32 type_obj->attr_cache = PyDict_New();
33 if (!type_obj->attr_cache)
34 return NULL;
35 return (PyObject *)no_cleanup_ptr(type_obj);
36 }
37
38 static inline struct drgn_qualified_type DrgnType_unwrap(DrgnType *type)
39 {
40 return (struct drgn_qualified_type){
41 .type = type->type,
42 .qualifiers = type->qualifiers,
43 };
44 }
45
46 static PyObject *DrgnType_get_ptr(DrgnType *self, void *arg)
47 {
48 return PyLong_FromVoidPtr(self->type);
49 }
50
51 static Program *DrgnType_get_prog(DrgnType *self, void *arg)
52 {
53 Py_INCREF(DrgnType_prog(self));
54 return DrgnType_prog(self);
55 }
56
57 static PyObject *DrgnType_get_kind(DrgnType *self)
58 {
59 return PyObject_CallFunction(TypeKind_class, "k",
60 (unsigned long)drgn_type_kind(self->type));
61 }
62
63 static PyObject *DrgnType_get_primitive(DrgnType *self)
64 {
65 if (drgn_type_primitive(self->type) == DRGN_NOT_PRIMITIVE_TYPE)
66 Py_RETURN_NONE;
67 return PyObject_CallFunction(PrimitiveType_class, "k",
68 (unsigned long)drgn_type_primitive(self->type));
69 }
70
71 static PyObject *DrgnType_get_qualifiers(DrgnType *self)
72 {
73 return PyObject_CallFunction(Qualifiers_class, "k",
74 (unsigned long)self->qualifiers);
75 }
76
77 static PyObject *DrgnType_get_language(DrgnType *self, void *arg)
78 {
79 return Language_wrap(drgn_type_language(self->type));
80 }
81
82 static PyObject *DrgnType_get_name(DrgnType *self)
83 {
84 if (!drgn_type_has_name(self->type)) {
85 return PyErr_Format(PyExc_AttributeError,
86 "%s type does not have a name",
87 drgn_type_kind_str(self->type));
88 }
89 return PyUnicode_FromString(drgn_type_name(self->type));
90 }
91
92 static PyObject *DrgnType_get_tag(DrgnType *self)
93 {
94 const char *tag;
95
96 if (!drgn_type_has_tag(self->type)) {
97 return PyErr_Format(PyExc_AttributeError,
98 "%s type does not have a tag",
99 drgn_type_kind_str(self->type));
100 }
101
102 tag = drgn_type_tag(self->type);
103 if (tag)
104 return PyUnicode_FromString(tag);
105 else
106 Py_RETURN_NONE;
107 }
108
109 static PyObject *DrgnType_get_size(DrgnType *self)
110 {
111 if (!drgn_type_has_size(self->type)) {
112 return PyErr_Format(PyExc_AttributeError,
113 "%s type does not have a size",
114 drgn_type_kind_str(self->type));
115 }
116 if (!drgn_type_is_complete(self->type))
117 Py_RETURN_NONE;
118 return PyLong_FromUInt64(drgn_type_size(self->type));
119 }
120
121 static PyObject *DrgnType_get_length(DrgnType *self)
122 {
123 if (!drgn_type_has_length(self->type)) {
124 return PyErr_Format(PyExc_AttributeError,
125 "%s type does not have a length",
126 drgn_type_kind_str(self->type));
127 }
128 if (drgn_type_is_complete(self->type))
129 return PyLong_FromUInt64(drgn_type_length(self->type));
130 else
131 Py_RETURN_NONE;
132 }
133
134 static PyObject *DrgnType_get_is_signed(DrgnType *self)
135 {
136 if (!drgn_type_has_is_signed(self->type)) {
137 return PyErr_Format(PyExc_AttributeError,
138 "%s type does not have a signedness",
139 drgn_type_kind_str(self->type));
140 }
141 Py_RETURN_BOOL(drgn_type_is_signed(self->type));
142 }
143
144 /*
145 * This returns one of two static strings, so it doesn't need the attribute
146 * cache.
147 */
148 static PyObject *DrgnType_get_byteorder(DrgnType *self, void *arg)
149 {
150 if (!drgn_type_has_little_endian(self->type)) {
151 return PyErr_Format(PyExc_AttributeError,
152 "%s type does not have a byte order",
153 drgn_type_kind_str(self->type));
154 }
155 _Py_IDENTIFIER(little);
156 _Py_IDENTIFIER(big);
157 PyObject *ret =
158 _PyUnicode_FromId(drgn_type_little_endian(self->type) ?
159 &PyId_little : &PyId_big);
160 Py_XINCREF(ret);
161 return ret;
162 }
163
164 static PyObject *DrgnType_get_type(DrgnType *self)
165 {
166 if (!drgn_type_has_type(self->type)) {
167 return PyErr_Format(PyExc_AttributeError,
168 "%s type does not have an underlying type",
169 drgn_type_kind_str(self->type));
170 }
171 if (drgn_type_kind(self->type) == DRGN_TYPE_ENUM &&
172 !drgn_type_is_complete(self->type))
173 Py_RETURN_NONE;
174 else
175 return DrgnType_wrap(drgn_type_type(self->type));
176 }
177
178 static TypeMember *TypeMember_wrap(PyObject *parent,
179 struct drgn_type_member *member,
180 uint64_t bit_offset)
181 {
182 _cleanup_pydecref_ TypeMember *py_member = call_tp_alloc(TypeMember);
183 if (!py_member)
184 return NULL;
185
186 Py_INCREF(parent);
187 py_member->lazy_obj.obj = parent;
188 py_member->lazy_obj.lazy_obj = &member->object;
189 if (member->name) {
190 py_member->name = PyUnicode_FromString(member->name);
191 if (!py_member->name)
192 return NULL;
193 } else {
194 Py_INCREF(Py_None);
195 py_member->name = Py_None;
196 }
197 py_member->bit_offset = PyLong_FromUInt64(bit_offset);
198 if (!py_member->bit_offset)
199 return NULL;
200 return_ptr(py_member);
201 }
202
203 static PyObject *DrgnType_get_members(DrgnType *self)
204 {
205 if (!drgn_type_has_members(self->type)) {
206 return PyErr_Format(PyExc_AttributeError,
207 "%s type does not have members",
208 drgn_type_kind_str(self->type));
209 }
210
211 if (!drgn_type_is_complete(self->type))
212 Py_RETURN_NONE;
213
214 struct drgn_type_member *members = drgn_type_members(self->type);
215 size_t num_members = drgn_type_num_members(self->type);
216
217 _cleanup_pydecref_ PyObject *members_obj = PyTuple_New(num_members);
218 if (!members_obj)
219 return NULL;
220
221 for (size_t i = 0; i < num_members; i++) {
222 TypeMember *item = TypeMember_wrap((PyObject *)self,
223 &members[i],
224 members[i].bit_offset);
225 if (!item)
226 return NULL;
227 PyTuple_SET_ITEM(members_obj, i, (PyObject *)item);
228 }
229 return_ptr(members_obj);
230 }
231
232 static PyObject *DrgnType_get_enumerators(DrgnType *self)
233 {
234 if (!drgn_type_has_enumerators(self->type)) {
235 return PyErr_Format(PyExc_AttributeError,
236 "%s type does not have enumerators",
237 drgn_type_kind_str(self->type));
238 }
239
240 if (!drgn_type_is_complete(self->type))
241 Py_RETURN_NONE;
242
243 const struct drgn_type_enumerator *enumerators =
244 drgn_type_enumerators(self->type);
245 size_t num_enumerators = drgn_type_num_enumerators(self->type);
246 bool is_signed = drgn_enum_type_is_signed(self->type);
247
248 _cleanup_pydecref_ PyObject *enumerators_obj = PyTuple_New(num_enumerators);
249 if (!enumerators_obj)
250 return NULL;
251
252 for (size_t i = 0; i < num_enumerators; i++) {
253 PyObject *item;
254
255 if (is_signed) {
256 item = PyObject_CallFunction((PyObject *)&TypeEnumerator_type,
257 "sL", enumerators[i].name,
258 (long long)enumerators[i].svalue);
259 } else {
260 item = PyObject_CallFunction((PyObject *)&TypeEnumerator_type,
261 "sK", enumerators[i].name,
262 (unsigned long long)enumerators[i].uvalue);
263 }
264 if (!item)
265 return NULL;
266 PyTuple_SET_ITEM(enumerators_obj, i, item);
267 }
268
269 return_ptr(enumerators_obj);
270 }
271
272 static PyObject *DrgnType_get_parameters(DrgnType *self)
273 {
274 if (!drgn_type_has_parameters(self->type)) {
275 return PyErr_Format(PyExc_AttributeError,
276 "%s type does not have parameters",
277 drgn_type_kind_str(self->type));
278 }
279
280 struct drgn_type_parameter *parameters =
281 drgn_type_parameters(self->type);
282 size_t num_parameters = drgn_type_num_parameters(self->type);
283
284 _cleanup_pydecref_ PyObject *parameters_obj =
285 PyTuple_New(num_parameters);
286 if (!parameters_obj)
287 return NULL;
288
289 for (size_t i = 0; i < num_parameters; i++) {
290 struct drgn_type_parameter *parameter = &parameters[i];
291 TypeParameter *item = call_tp_alloc(TypeParameter);
292 if (!item)
293 return NULL;
294 PyTuple_SET_ITEM(parameters_obj, i, (PyObject *)item);
295 Py_INCREF(self);
296 item->lazy_obj.obj = (PyObject *)self;
297 item->lazy_obj.lazy_obj = &parameter->default_argument;
298 if (parameter->name) {
299 item->name = PyUnicode_FromString(parameter->name);
300 if (!item->name)
301 return NULL;
302 } else {
303 Py_INCREF(Py_None);
304 item->name = Py_None;
305 }
306 }
307 return_ptr(parameters_obj);
308 }
309
310 static PyObject *DrgnType_get_is_variadic(DrgnType *self)
311 {
312 if (!drgn_type_has_is_variadic(self->type)) {
313 return PyErr_Format(PyExc_AttributeError,
314 "%s type cannot be variadic",
315 drgn_type_kind_str(self->type));
316 }
317 Py_RETURN_BOOL(drgn_type_is_variadic(self->type));
318 }
319
320 static PyObject *DrgnType_get_template_parameters(DrgnType *self)
321 {
322 if (!drgn_type_has_template_parameters(self->type)) {
323 return PyErr_Format(PyExc_AttributeError,
324 "%s type does not have template parameters",
325 drgn_type_kind_str(self->type));
326 }
327
328 struct drgn_type_template_parameter *template_parameters =
329 drgn_type_template_parameters(self->type);
330 size_t num_template_parameters =
331 drgn_type_num_template_parameters(self->type);
332
333 _cleanup_pydecref_ PyObject *template_parameters_obj =
334 PyTuple_New(num_template_parameters);
335 if (!template_parameters_obj)
336 return NULL;
337
338 for (size_t i = 0; i < num_template_parameters; i++) {
339 struct drgn_type_template_parameter *template_parameter =
340 &template_parameters[i];
341
342 TypeTemplateParameter *item =
343 call_tp_alloc(TypeTemplateParameter);
344 if (!item)
345 return NULL;
346 PyTuple_SET_ITEM(template_parameters_obj, i, (PyObject *)item);
347 Py_INCREF(self);
348 item->lazy_obj.obj = (PyObject *)self;
349 item->lazy_obj.lazy_obj = &template_parameter->argument;
350 if (template_parameter->name) {
351 item->name = PyUnicode_FromString(template_parameter->name);
352 if (!item->name)
353 return NULL;
354 } else {
355 Py_INCREF(Py_None);
356 item->name = Py_None;
357 }
358 item->is_default =
359 PyBool_FromLong(template_parameter->is_default);
360 }
361 return_ptr(template_parameters_obj);
362 }
363
364 struct DrgnType_Attr {
365 _Py_Identifier id;
366 PyObject *(*getter)(DrgnType *);
367 };
368
369 #define DrgnType_ATTR(name) \
370 static struct DrgnType_Attr DrgnType_attr_##name = { \
371 .id = _Py_static_string_init(#name), \
372 .getter = DrgnType_get_##name, \
373 }
374
375 DrgnType_ATTR(kind);
376 DrgnType_ATTR(primitive);
377 DrgnType_ATTR(qualifiers);
378 DrgnType_ATTR(name);
379 DrgnType_ATTR(tag);
380 DrgnType_ATTR(size);
381 DrgnType_ATTR(length);
382 DrgnType_ATTR(is_signed);
383 DrgnType_ATTR(type);
384 DrgnType_ATTR(members);
385 DrgnType_ATTR(enumerators);
386 DrgnType_ATTR(parameters);
387 DrgnType_ATTR(is_variadic);
388 DrgnType_ATTR(template_parameters);
389
390 static int DrgnType_cache_attr(DrgnType *self, struct DrgnType_Attr *attr,
391 PyObject *value)
392 {
393 PyObject *key = _PyUnicode_FromId(&attr->id);
394 if (!key)
395 return -1;
396 return PyDict_SetItem(self->attr_cache, key, value);
397 }
398
399 static PyObject *DrgnType_getter(DrgnType *self, struct DrgnType_Attr *attr)
400 {
401 PyObject *key = _PyUnicode_FromId(&attr->id);
402 if (!key)
403 return NULL;
404 PyObject *value = PyDict_GetItemWithError(self->attr_cache, key);
405 if (value) {
406 Py_INCREF(value);
407 return value;
408 }
409 if (PyErr_Occurred())
410 return NULL;
411
412 value = attr->getter(self);
413 if (!value)
414 return NULL;
415
416 if (PyDict_SetItem(self->attr_cache, key, value) == -1) {
417 Py_DECREF(value);
418 return NULL;
419 }
420 return value;
421 }
422
423 static PyGetSetDef DrgnType_getset[] = {
424 {"_ptr", (getter)DrgnType_get_ptr, NULL,
425 "Address of underlying ``struct drgn_type``.\n"
426 "\n"
427 "This is used for testing.\n"
428 "\n"
429 ":vartype: int"},
430 {"prog", (getter)DrgnType_get_prog, NULL, drgn_Type_prog_DOC},
431 {"kind", (getter)DrgnType_getter, NULL,
432 drgn_Type_kind_DOC, &DrgnType_attr_kind},
433 {"primitive", (getter)DrgnType_getter, NULL, drgn_Type_primitive_DOC,
434 &DrgnType_attr_primitive},
435 {"qualifiers", (getter)DrgnType_getter, NULL, drgn_Type_qualifiers_DOC,
436 &DrgnType_attr_qualifiers},
437 {"language", (getter)DrgnType_get_language, NULL,
438 drgn_Type_language_DOC},
439 {"name", (getter)DrgnType_getter, NULL, drgn_Type_name_DOC,
440 &DrgnType_attr_name},
441 {"tag", (getter)DrgnType_getter, NULL, drgn_Type_tag_DOC,
442 &DrgnType_attr_tag},
443 {"size", (getter)DrgnType_getter, NULL, drgn_Type_size_DOC,
444 &DrgnType_attr_size},
445 {"length", (getter)DrgnType_getter, NULL, drgn_Type_length_DOC,
446 &DrgnType_attr_length},
447 {"is_signed", (getter)DrgnType_getter, NULL, drgn_Type_is_signed_DOC,
448 &DrgnType_attr_is_signed},
449 {"byteorder", (getter)DrgnType_get_byteorder, NULL,
450 drgn_Type_byteorder_DOC},
451 {"type", (getter)DrgnType_getter, NULL, drgn_Type_type_DOC,
452 &DrgnType_attr_type},
453 {"members", (getter)DrgnType_getter, NULL, drgn_Type_members_DOC,
454 &DrgnType_attr_members},
455 {"enumerators", (getter)DrgnType_getter, NULL,
456 drgn_Type_enumerators_DOC, &DrgnType_attr_enumerators},
457 {"parameters", (getter)DrgnType_getter, NULL, drgn_Type_parameters_DOC,
458 &DrgnType_attr_parameters},
459 {"is_variadic", (getter)DrgnType_getter, NULL,
460 drgn_Type_is_variadic_DOC, &DrgnType_attr_is_variadic},
461 {"template_parameters", (getter)DrgnType_getter, NULL,
462 drgn_Type_template_parameters_DOC, &DrgnType_attr_template_parameters},
463 {},
464 };
465
466 static void DrgnType_dealloc(DrgnType *self)
467 {
468 PyObject_GC_UnTrack(self);
469 Py_XDECREF(self->attr_cache);
470 if (self->type)
471 Py_DECREF(DrgnType_prog(self));
472 Py_TYPE(self)->tp_free((PyObject *)self);
473 }
474
475 static int DrgnType_traverse(DrgnType *self, visitproc visit, void *arg)
476 {
477 Py_VISIT(self->attr_cache);
478 if (self->type)
479 Py_VISIT(DrgnType_prog(self));
480 return 0;
481 }
482
483 static int DrgnType_clear(DrgnType *self)
484 {
485 Py_CLEAR(self->attr_cache);
486 if (self->type) {
487 Py_DECREF(DrgnType_prog(self));
488 self->type = NULL;
489 }
490 return 0;
491 }
492
493 static int append_field(PyObject *parts, bool *first, const char *format, ...)
494 {
495 if (!*first && append_string(parts, ", ") == -1)
496 return -1;
497 *first = false;
498
499 va_list ap;
500 va_start(ap, format);
501 _cleanup_pydecref_ PyObject *str = PyUnicode_FromFormatV(format, ap);
502 va_end(ap);
503 if (!str)
504 return -1;
505 return PyList_Append(parts, str);
506 }
507
508 #define append_member(parts, type_obj, first, member) ({ \
509 int _ret = 0; \
510 if (drgn_type_has_##member((type_obj)->type)) { \
511 _cleanup_pydecref_ PyObject *_obj = \
512 DrgnType_getter((type_obj), &DrgnType_attr_##member); \
513 if (_obj) { \
514 _ret = append_field((parts), (first), #member"=%R", \
515 _obj); \
516 } else { \
517 _ret = -1; \
518 } \
519 } \
520 _ret; \
521 })
522
523 static PyObject *DrgnType_repr(DrgnType *self)
524 {
525 _cleanup_pydecref_ PyObject *parts = PyList_New(0);
526 if (!parts)
527 return NULL;
528
529 bool first = true;
530 if (append_format(parts, "prog.%s_type(",
531 drgn_type_kind_str(self->type)) == -1)
532 return NULL;
533 if (append_member(parts, self, &first, name) == -1)
534 return NULL;
535 if (append_member(parts, self, &first, tag) == -1)
536 return NULL;
537
538 if (drgn_type_kind(self->type) != DRGN_TYPE_POINTER &&
539 append_member(parts, self, &first, size) == -1)
540 return NULL;
541 if (append_member(parts, self, &first, is_signed) == -1)
542 return NULL;
543 if (append_member(parts, self, &first, type) == -1)
544 return NULL;
545 if (drgn_type_kind(self->type) == DRGN_TYPE_POINTER &&
546 (!drgn_type_program(self->type)->has_platform ||
547 drgn_type_size(self->type) !=
548 drgn_platform_address_size(&drgn_type_program(self->type)->platform)) &&
549 append_member(parts, self, &first, size) == -1)
550 return NULL;
551 if (drgn_type_has_little_endian(self->type) &&
552 (!drgn_type_program(self->type)->has_platform ||
553 drgn_type_little_endian(self->type) !=
554 drgn_platform_is_little_endian(&drgn_type_program(self->type)->platform))) {
555 _cleanup_pydecref_ PyObject *obj =
556 DrgnType_get_byteorder(self, NULL);
557 if (!obj
558 || append_field(parts, &first, "byteorder=%R", obj) == -1)
559 return NULL;
560 }
561 if (append_member(parts, self, &first, length) == -1)
562 return NULL;
563 if (append_member(parts, self, &first, members) == -1)
564 return NULL;
565 if (append_member(parts, self, &first, enumerators) == -1)
566 return NULL;
567 if (append_member(parts, self, &first, parameters) == -1)
568 return NULL;
569 if (append_member(parts, self, &first, is_variadic) == -1)
570 return NULL;
571 if (drgn_type_has_template_parameters(self->type) &&
572 drgn_type_num_template_parameters(self->type) > 0 &&
573 append_member(parts, self, &first, template_parameters) == -1)
574 return NULL;
575 if (self->qualifiers) {
576 _cleanup_pydecref_ PyObject *obj =
577 DrgnType_getter(self, &DrgnType_attr_qualifiers);
578 if (!obj
579 || append_field(parts, &first, "qualifiers=%R", obj) == -1)
580 return NULL;
581 }
582 if (drgn_type_language(self->type) !=
583 drgn_program_language(drgn_type_program(self->type))) {
584 _cleanup_pydecref_ PyObject *obj = DrgnType_get_language(self, NULL);
585 if (!obj
586 || append_field(parts, &first, "language=%R", obj) == -1)
587 return NULL;
588 }
589 if (append_string(parts, ")") == -1)
590 return NULL;
591
592 return join_strings(parts);
593 }
594
595 static PyObject *DrgnType_str(DrgnType *self)
596 {
597 _cleanup_free_ char *str = NULL;
598 struct drgn_error *err = drgn_format_type(DrgnType_unwrap(self), &str);
599 if (err)
600 return set_drgn_error(err);
601 return PyUnicode_FromString(str);
602 }
603
604 static PyObject *DrgnType_type_name(DrgnType *self)
605 {
606 _cleanup_free_ char *str = NULL;
607 struct drgn_error *err = drgn_format_type_name(DrgnType_unwrap(self),
608 &str);
609 if (err)
610 return set_drgn_error(err);
611 return PyUnicode_FromString(str);
612 }
613
614 static PyObject *DrgnType_variable_declaration(DrgnType *self, PyObject *args,
615 PyObject *kwds)
616 {
617 static char *keywords[] = {"name", NULL};
618 const char *name;
619 if (!PyArg_ParseTupleAndKeywords(args, kwds, "s:variable_declaration",
620 keywords, &name))
621 return NULL;
622
623 _cleanup_free_ char *str = NULL;
624 struct drgn_error *err =
625 drgn_format_variable_declaration(DrgnType_unwrap(self), name,
626 &str);
627 if (err)
628 return set_drgn_error(err);
629 return PyUnicode_FromString(str);
630 }
631
632 static PyObject *DrgnType_is_complete(DrgnType *self)
633 {
634 Py_RETURN_BOOL(drgn_type_is_complete(self->type));
635 }
636
637 static int qualifiers_converter(PyObject *o, void *p)
638 {
639 struct enum_arg arg = {
640 .type = Qualifiers_class,
641 .value = 0,
642 };
643 if (!enum_converter(o, &arg))
644 return 0;
645 *(enum drgn_qualifiers *)p = arg.value;
646 return 1;
647 }
648
649 static PyObject *DrgnType_qualified(DrgnType *self, PyObject *args,
650 PyObject *kwds)
651 {
652 static char *keywords[] = { "qualifiers", NULL, };
653 enum drgn_qualifiers qualifiers;
654 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&:qualified", keywords,
655 qualifiers_converter, &qualifiers))
656 return NULL;
657
658 struct drgn_qualified_type qualified_type = {
659 .type = self->type,
660 .qualifiers = qualifiers,
661 };
662 return DrgnType_wrap(qualified_type);
663 }
664
665 static PyObject *DrgnType_unqualified(DrgnType *self)
666 {
667 struct drgn_qualified_type qualified_type = { .type = self->type };
668 return DrgnType_wrap(qualified_type);
669 }
670
671 static PyObject *DrgnType_unaliased(DrgnType *self)
672 {
673 return DrgnType_wrap(drgn_qualified_type_unaliased(DrgnType_unwrap(self)));
674 }
675
676 static PyObject *DrgnType_unaliased_kind(DrgnType *self)
677 {
678 unsigned long kind = drgn_type_kind(drgn_underlying_type(self->type));
679 return PyObject_CallFunction(TypeKind_class, "k", kind);
680 }
681
682 static TypeMember *DrgnType_member(DrgnType *self, PyObject *args,
683 PyObject *kwds)
684 {
685 struct drgn_error *err;
686
687 static char *keywords[] = {"name", NULL};
688 const char *name;
689 Py_ssize_t name_len;
690 if (!PyArg_ParseTupleAndKeywords(args, kwds, "s#:member", keywords,
691 &name, &name_len))
692 return NULL;
693
694 struct drgn_type_member *member;
695 uint64_t bit_offset;
696 err = drgn_type_find_member_len(self->type, name, name_len, &member,
697 &bit_offset);
698 if (err)
699 return set_drgn_error(err);
700 return TypeMember_wrap((PyObject *)self, member, bit_offset);
701 }
702
703 static PyObject *DrgnType_has_member(DrgnType *self, PyObject *args,
704 PyObject *kwds)
705 {
706 struct drgn_error *err;
707
708 static char *keywords[] = {"name", NULL};
709 const char *name;
710 Py_ssize_t name_len;
711 if (!PyArg_ParseTupleAndKeywords(args, kwds, "s#:has_member", keywords,
712 &name, &name_len))
713 return NULL;
714
715 bool has_member;
716 err = drgn_type_has_member_len(self->type, name, name_len, &has_member);
717 if (err)
718 return set_drgn_error(err);
719 Py_RETURN_BOOL(has_member);
720 }
721
722 static PyMethodDef DrgnType_methods[] = {
723 {"type_name", (PyCFunction)DrgnType_type_name, METH_NOARGS,
724 drgn_Type_type_name_DOC},
725 {"variable_declaration", (PyCFunction)DrgnType_variable_declaration,
726 METH_VARARGS | METH_KEYWORDS, drgn_Type_variable_declaration_DOC},
727 {"is_complete", (PyCFunction)DrgnType_is_complete, METH_NOARGS,
728 drgn_Type_is_complete_DOC},
729 {"qualified", (PyCFunction)DrgnType_qualified,
730 METH_VARARGS | METH_KEYWORDS, drgn_Type_qualified_DOC},
731 {"unqualified", (PyCFunction)DrgnType_unqualified, METH_NOARGS,
732 drgn_Type_unqualified_DOC},
733 {"unaliased", (PyCFunction)DrgnType_unaliased, METH_NOARGS,
734 drgn_Type_unaliased_DOC},
735 {"unaliased_kind", (PyCFunction)DrgnType_unaliased_kind, METH_NOARGS,
736 drgn_Type_unaliased_kind_DOC},
737 {"member", (PyCFunction)DrgnType_member, METH_VARARGS | METH_KEYWORDS,
738 drgn_Type_member_DOC},
739 {"has_member", (PyCFunction)DrgnType_has_member,
740 METH_VARARGS | METH_KEYWORDS, drgn_Type_has_member_DOC},
741 {"_repr_pretty_", (PyCFunction)repr_pretty_from_str,
742 METH_VARARGS | METH_KEYWORDS},
743 {},
744 };
745
746 PyTypeObject DrgnType_type = {
747 PyVarObject_HEAD_INIT(NULL, 0)
748 .tp_name = "_drgn.Type",
749 .tp_basicsize = sizeof(DrgnType),
750 .tp_dealloc = (destructor)DrgnType_dealloc,
751 .tp_repr = (reprfunc)DrgnType_repr,
752 .tp_str = (reprfunc)DrgnType_str,
753 .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
754 .tp_doc = drgn_Type_DOC,
755 .tp_traverse = (traverseproc)DrgnType_traverse,
756 .tp_clear = (inquiry)DrgnType_clear,
757 .tp_methods = DrgnType_methods,
758 .tp_getset = DrgnType_getset,
759 };
760
761 static TypeEnumerator *TypeEnumerator_new(PyTypeObject *subtype, PyObject *args,
762 PyObject *kwds)
763 {
764 static char *keywords[] = {"name", "value", NULL};
765 PyObject *name, *value;
766 TypeEnumerator *enumerator;
767
768 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O!:TypeEnumerator",
769 keywords, &PyUnicode_Type, &name,
770 &PyLong_Type, &value))
771 return NULL;
772
773 enumerator = (TypeEnumerator *)subtype->tp_alloc(subtype, 0);
774 if (enumerator) {
775 Py_INCREF(name);
776 enumerator->name = name;
777 Py_INCREF(value);
778 enumerator->value = value;
779 }
780 return enumerator;
781 }
782
783 static void TypeEnumerator_dealloc(TypeEnumerator *self)
784 {
785 PyObject_GC_UnTrack(self);
786 Py_XDECREF(self->value);
787 Py_XDECREF(self->name);
788 Py_TYPE(self)->tp_free((PyObject *)self);
789 }
790
791 static PyObject *TypeEnumerator_repr(TypeEnumerator *self)
792 {
793 return PyUnicode_FromFormat("TypeEnumerator(%R, %R)", self->name,
794 self->value);
795 }
796
797 static Py_ssize_t TypeEnumerator_length(PyObject *self)
798 {
799 return 2;
800 }
801
802 static PyObject *TypeEnumerator_item(TypeEnumerator *self, Py_ssize_t i)
803 {
804 switch (i) {
805 case 0:
806 Py_INCREF(self->name);
807 return self->name;
808 case 1:
809 Py_INCREF(self->value);
810 return self->value;
811 default:
812 PyErr_SetString(PyExc_IndexError,
813 "TypeEnumerator index out of range");
814 return NULL;
815 }
816 }
817
818 static PyObject *TypeEnumerator_richcompare(TypeEnumerator *self,
819 TypeEnumerator *other,
820 int op)
821 {
822 int ret;
823
824 if ((op != Py_EQ && op != Py_NE) ||
825 !PyObject_TypeCheck((PyObject *)other, &TypeEnumerator_type))
826 Py_RETURN_NOTIMPLEMENTED;
827
828 ret = PyUnicode_Compare(self->name, other->name);
829 if (ret == -1 && PyErr_Occurred())
830 return NULL;
831 if (ret != 0)
832 Py_RETURN_RICHCOMPARE(ret, 0, op);
833 return PyObject_RichCompare(self->value, other->value, op);
834 }
835
836 static PySequenceMethods TypeEnumerator_as_sequence = {
837 .sq_length = TypeEnumerator_length,
838 .sq_item = (ssizeargfunc)TypeEnumerator_item,
839 };
840
841 static PyMemberDef TypeEnumerator_members[] = {
842 {"name", T_OBJECT, offsetof(TypeEnumerator, name), READONLY,
843 drgn_TypeEnumerator_name_DOC},
844 {"value", T_OBJECT, offsetof(TypeEnumerator, value), READONLY,
845 drgn_TypeEnumerator_value_DOC},
846 {},
847 };
848
849 static int LazyObject_traverse(LazyObject *self, visitproc visit, void *arg)
850 {
851 Py_VISIT(self->obj);
852 return 0;
853 }
854
855 PyTypeObject TypeEnumerator_type = {
856 PyVarObject_HEAD_INIT(NULL, 0)
857 .tp_name = "_drgn.TypeEnumerator",
858 .tp_basicsize = sizeof(TypeEnumerator),
859 .tp_dealloc = (destructor)TypeEnumerator_dealloc,
860 .tp_repr = (reprfunc)TypeEnumerator_repr,
861 .tp_as_sequence = &TypeEnumerator_as_sequence,
862 .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
863 .tp_traverse = (traverseproc)LazyObject_traverse,
864 .tp_doc = drgn_TypeEnumerator_DOC,
865 .tp_richcompare = (richcmpfunc)TypeEnumerator_richcompare,
866 .tp_members = TypeEnumerator_members,
867 .tp_new = (newfunc)TypeEnumerator_new,
868 };
869
870 static DrgnObject *DrgnType_to_absent_DrgnObject(DrgnType *type)
871 {
872 _cleanup_pydecref_ DrgnObject *obj = DrgnObject_alloc(DrgnType_prog(type));
873 if (!obj)
874 return NULL;
875 struct drgn_error *err =
876 drgn_object_set_absent(&obj->obj, DrgnType_unwrap(type),
877 DRGN_ABSENCE_REASON_OTHER, 0);
878 if (err)
879 return set_drgn_error(err);
880 return_ptr(obj);
881 }
882
883 static const char *PyType_name(PyTypeObject *type)
884 {
885 const char *name = type->tp_name;
886 const char *dot = strrchr(name, '.');
887 return dot ? dot + 1 : name;
888 }
889
890 static DrgnObject *LazyObject_get_borrowed(LazyObject *self)
891 {
892 if (unlikely(self->lazy_obj != DRGNPY_LAZY_OBJECT_EVALUATED)) {
893 DrgnObject *obj;
894 if (self->lazy_obj == DRGNPY_LAZY_OBJECT_CALLABLE) {
895 PyObject *ret = PyObject_CallObject(self->obj, NULL);
896 if (!ret)
897 return NULL;
898 if (PyObject_TypeCheck(ret, &DrgnObject_type)) {
899 obj = (DrgnObject *)ret;
900 if (Py_TYPE(self) ==
901 &TypeTemplateParameter_type &&
902 obj->obj.kind == DRGN_OBJECT_ABSENT) {
903 Py_DECREF(ret);
904 PyErr_Format(PyExc_ValueError,
905 "%s() callable must not return absent Object",
906 PyType_name(Py_TYPE(self)));
907 return NULL;
908 }
909 } else if (PyObject_TypeCheck(ret, &DrgnType_type)) {
910 obj = DrgnType_to_absent_DrgnObject((DrgnType *)ret);
911 Py_DECREF(ret);
912 if (!obj)
913 return NULL;
914 } else {
915 Py_DECREF(ret);
916 PyErr_Format(PyExc_TypeError,
917 "%s() callable must return Object or Type",
918 PyType_name(Py_TYPE(self)));
919 return NULL;
920 }
921 } else {
922 bool clear = false;
923 /* Avoid the thread state overhead if we can. */
924 if (!drgn_lazy_object_is_evaluated(self->lazy_obj))
925 clear = set_drgn_in_python();
926 struct drgn_error *err =
927 drgn_lazy_object_evaluate(self->lazy_obj);
928 if (clear)
929 clear_drgn_in_python();
930 if (err)
931 return set_drgn_error(err);
932 obj = DrgnObject_alloc(container_of(drgn_object_program(&self->lazy_obj->obj),
933 Program, prog));
934 if (!obj)
935 return NULL;
936 err = drgn_object_copy(&obj->obj, &self->lazy_obj->obj);
937 if (err) {
938 Py_DECREF(obj);
939 return set_drgn_error(err);
940 }
941 }
942 Py_DECREF(self->obj);
943 self->obj = (PyObject *)obj;
944 self->lazy_obj = DRGNPY_LAZY_OBJECT_EVALUATED;
945 }
946 return (DrgnObject *)self->obj;
947 }
948
949 static DrgnObject *LazyObject_get(LazyObject *self, void *arg)
950 {
951 DrgnObject *ret = LazyObject_get_borrowed(self);
952 Py_XINCREF(ret);
953 return ret;
954 }
955
956 static PyObject *LazyObject_get_type(LazyObject *self, void *arg)
957 {
958 DrgnObject *obj = LazyObject_get_borrowed(self);
959 if (!obj)
960 return NULL;
961 return DrgnType_wrap(drgn_object_qualified_type(&obj->obj));
962 }
963
964 static void LazyObject_dealloc(LazyObject *self)
965 {
966 Py_XDECREF(self->obj);
967 Py_TYPE(self)->tp_free((PyObject *)self);
968 }
969
970 static int append_lazy_object_repr(PyObject *parts, LazyObject *self)
971 {
972 struct drgn_error *err;
973
974 DrgnObject *object = LazyObject_get_borrowed(self);
975 if (!object)
976 return -1;
977 if (object->obj.kind == DRGN_OBJECT_ABSENT &&
978 !object->obj.is_bit_field) {
979 _cleanup_free_ char *type_name = NULL;
980 err = drgn_format_type_name(drgn_object_qualified_type(&object->obj),
981 &type_name);
982 if (err) {
983 set_drgn_error(err);
984 return -1;
985 }
986 _cleanup_pydecref_ PyObject *tmp = PyUnicode_FromString(type_name);
987 if (!tmp)
988 return -1;
989 return append_format(parts, "prog.type(%R)", tmp);
990 } else {
991 return append_format(parts, "%R", object);
992 }
993 }
994
995 static int LazyObject_arg(PyObject *arg, const char *function_name,
996 bool can_be_absent, PyObject **obj_ret,
997 union drgn_lazy_object **state_ret)
998 {
999 if (PyCallable_Check(arg)) {
1000 Py_INCREF(arg);
1001 *obj_ret = arg;
1002 *state_ret = DRGNPY_LAZY_OBJECT_CALLABLE;
1003 } else if (PyObject_TypeCheck(arg, &DrgnObject_type)) {
1004 if (!can_be_absent &&
1005 ((DrgnObject *)arg)->obj.kind == DRGN_OBJECT_ABSENT) {
1006 PyErr_Format(PyExc_ValueError,
1007 "%s() first argument must not be absent Object",
1008 function_name);
1009 return -1;
1010 }
1011 Py_INCREF(arg);
1012 *obj_ret = arg;
1013 *state_ret = DRGNPY_LAZY_OBJECT_EVALUATED;
1014 } else if (PyObject_TypeCheck(arg, &DrgnType_type)) {
1015 DrgnObject *obj =
1016 DrgnType_to_absent_DrgnObject((DrgnType *)arg);
1017 if (!obj)
1018 return -1;
1019 *obj_ret = (PyObject *)obj;
1020 *state_ret = DRGNPY_LAZY_OBJECT_EVALUATED;
1021 } else {
1022 PyErr_Format(PyExc_TypeError,
1023 "%s() first argument must be Object, Type, or callable returning Object or Type",
1024 function_name);
1025 return -1;
1026 }
1027 return 0;
1028 }
1029
1030 static TypeMember *TypeMember_new(PyTypeObject *subtype, PyObject *args,
1031 PyObject *kwds)
1032 {
1033 static char *keywords[] = {"object_or_type", "name", "bit_offset", NULL};
1034 PyObject *object, *name = Py_None, *bit_offset = NULL;
1035 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OO!:TypeMember",
1036 keywords, &object, &name,
1037 &PyLong_Type, &bit_offset))
1038 return NULL;
1039
1040 if (name != Py_None && !PyUnicode_Check(name)) {
1041 PyErr_SetString(PyExc_TypeError,
1042 "TypeMember name must be str or None");
1043 return NULL;
1044 }
1045
1046 PyObject *obj;
1047 union drgn_lazy_object *state;
1048 if (LazyObject_arg(object, "TypeMember", true, &obj, &state))
1049 return NULL;
1050
1051 _cleanup_pydecref_ TypeMember *member =
1052 (TypeMember *)subtype->tp_alloc(subtype, 0);
1053 if (!member) {
1054 Py_DECREF(obj);
1055 return NULL;
1056 }
1057 member->lazy_obj.obj = obj;
1058 member->lazy_obj.lazy_obj = state;
1059 Py_INCREF(name);
1060 member->name = name;
1061 if (bit_offset) {
1062 Py_INCREF(bit_offset);
1063 } else {
1064 bit_offset = PyLong_FromLong(0);
1065 if (!bit_offset)
1066 return NULL;
1067 }
1068 member->bit_offset = bit_offset;
1069 return_ptr(member);
1070 }
1071
1072 static void TypeMember_dealloc(TypeMember *self)
1073 {
1074 PyObject_GC_UnTrack(self);
1075 Py_XDECREF(self->bit_offset);
1076 Py_XDECREF(self->name);
1077 LazyObject_dealloc((LazyObject *)self);
1078 }
1079
1080 static PyObject *TypeMember_get_offset(TypeMember *self, void *arg)
1081 {
1082 uint64_t bit_offset;
1083 if (PyLong_AsUInt64(self->bit_offset, &bit_offset))
1084 return NULL;
1085 if (bit_offset % 8) {
1086 PyErr_SetString(PyExc_ValueError,
1087 "member is not byte-aligned");
1088 return NULL;
1089 }
1090 return PyLong_FromUInt64(bit_offset / 8);
1091 }
1092
1093 static PyObject *TypeMember_get_bit_field_size(TypeMember *self, void *arg)
1094 {
1095 DrgnObject *object = LazyObject_get_borrowed((LazyObject *)self);
1096 if (!object)
1097 return NULL;
1098 if (object->obj.is_bit_field)
1099 return PyLong_FromUInt64(object->obj.bit_size);
1100 else
1101 Py_RETURN_NONE;
1102 }
1103
1104 static PyObject *TypeMember_repr(TypeMember *self)
1105 {
1106 _cleanup_pydecref_ PyObject *parts = PyList_New(0);
1107 if (!parts)
1108 return NULL;
1109 if (append_format(parts, "TypeMember(") < 0 ||
1110 append_lazy_object_repr(parts, (LazyObject *)self) < 0)
1111 return NULL;
1112 if (self->name != Py_None &&
1113 append_format(parts, ", name=%R", self->name) < 0)
1114 return NULL;
1115 /* Include the bit offset even if it is the default of 0 for clarity. */
1116 if (append_format(parts, ", bit_offset=%R)", self->bit_offset) < 0)
1117 return NULL;
1118 return join_strings(parts);
1119 }
1120
1121 static PyMemberDef TypeMember_members[] = {
1122 {"name", T_OBJECT, offsetof(TypeMember, name), READONLY,
1123 drgn_TypeMember_name_DOC},
1124 {"bit_offset", T_OBJECT, offsetof(TypeMember, bit_offset), READONLY,
1125 drgn_TypeMember_bit_offset_DOC},
1126 {},
1127 };
1128
1129 static PyGetSetDef TypeMember_getset[] = {
1130 {"object", (getter)LazyObject_get, NULL, drgn_TypeMember_object_DOC,
1131 NULL},
1132 {"type", (getter)LazyObject_get_type, NULL, drgn_TypeMember_type_DOC,
1133 NULL},
1134 {"offset", (getter)TypeMember_get_offset, NULL,
1135 drgn_TypeMember_offset_DOC, NULL},
1136 {"bit_field_size", (getter)TypeMember_get_bit_field_size, NULL,
1137 drgn_TypeMember_bit_field_size_DOC, NULL},
1138 {},
1139 };
1140
1141 PyTypeObject TypeMember_type = {
1142 PyVarObject_HEAD_INIT(NULL, 0)
1143 .tp_name = "_drgn.TypeMember",
1144 .tp_basicsize = sizeof(TypeMember),
1145 .tp_dealloc = (destructor)TypeMember_dealloc,
1146 .tp_repr = (reprfunc)TypeMember_repr,
1147 .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
1148 .tp_traverse = (traverseproc)LazyObject_traverse,
1149 .tp_doc = drgn_TypeMember_DOC,
1150 .tp_members = TypeMember_members,
1151 .tp_getset = TypeMember_getset,
1152 .tp_new = (newfunc)TypeMember_new,
1153 };
1154
1155 static TypeParameter *TypeParameter_new(PyTypeObject *subtype, PyObject *args,
1156 PyObject *kwds)
1157 {
1158 static char *keywords[] = {"default_argument_or_type", "name", NULL};
1159 PyObject *object, *name = Py_None;
1160 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:TypeParameter",
1161 keywords, &object, &name))
1162 return NULL;
1163
1164 if (name != Py_None && !PyUnicode_Check(name)) {
1165 PyErr_SetString(PyExc_TypeError,
1166 "TypeParameter name must be str or None");
1167 return NULL;
1168 }
1169
1170 PyObject *obj;
1171 union drgn_lazy_object *state;
1172 if (LazyObject_arg(object, "TypeParameter", true, &obj, &state))
1173 return NULL;
1174
1175 TypeParameter *parameter = (TypeParameter *)subtype->tp_alloc(subtype,
1176 0);
1177 if (!parameter) {
1178 Py_DECREF(obj);
1179 return NULL;
1180 }
1181
1182 parameter->lazy_obj.obj = obj;
1183 parameter->lazy_obj.lazy_obj = state;
1184 Py_INCREF(name);
1185 parameter->name = name;
1186 return parameter;
1187 }
1188
1189 static void TypeParameter_dealloc(TypeParameter *self)
1190 {
1191 PyObject_GC_UnTrack(self);
1192 Py_XDECREF(self->name);
1193 LazyObject_dealloc((LazyObject *)self);
1194 }
1195
1196 static PyObject *TypeParameter_repr(TypeParameter *self)
1197 {
1198 _cleanup_pydecref_ PyObject *parts = PyList_New(0);
1199 if (!parts)
1200 return NULL;
1201 if (append_format(parts, "TypeParameter(") < 0 ||
1202 append_lazy_object_repr(parts, (LazyObject *)self) < 0)
1203 return NULL;
1204 if (self->name != Py_None &&
1205 append_format(parts, ", name=%R", self->name) < 0)
1206 return NULL;
1207 if (append_string(parts, ")") < 0)
1208 return NULL;
1209 return join_strings(parts);
1210 }
1211
1212 static PyMemberDef TypeParameter_members[] = {
1213 {"name", T_OBJECT, offsetof(TypeParameter, name), READONLY,
1214 drgn_TypeParameter_name_DOC},
1215 {},
1216 };
1217
1218 static PyGetSetDef TypeParameter_getset[] = {
1219 {"default_argument", (getter)LazyObject_get, NULL,
1220 drgn_TypeParameter_default_argument_DOC, NULL},
1221 {"type", (getter)LazyObject_get_type, NULL, drgn_TypeParameter_type_DOC,
1222 NULL},
1223 {},
1224 };
1225
1226 PyTypeObject TypeParameter_type = {
1227 PyVarObject_HEAD_INIT(NULL, 0)
1228 .tp_name = "_drgn.TypeParameter",
1229 .tp_basicsize = sizeof(TypeParameter),
1230 .tp_dealloc = (destructor)TypeParameter_dealloc,
1231 .tp_repr = (reprfunc)TypeParameter_repr,
1232 .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
1233 .tp_traverse = (traverseproc)LazyObject_traverse,
1234 .tp_doc = drgn_TypeParameter_DOC,
1235 .tp_members = TypeParameter_members,
1236 .tp_getset = TypeParameter_getset,
1237 .tp_new = (newfunc)TypeParameter_new,
1238 };
1239
1240 static TypeTemplateParameter *TypeTemplateParameter_new(PyTypeObject *subtype,
1241 PyObject *args,
1242 PyObject *kwds)
1243 {
1244 static char *keywords[] = {"argument", "name", "is_default", NULL};
1245 PyObject *object, *name = Py_None, *is_default = Py_False;
1246 if (!PyArg_ParseTupleAndKeywords(args, kwds,
1247 "O|OO!:TypeTemplateParameter",
1248 keywords, &object, &name, &PyBool_Type,
1249 &is_default))
1250 return NULL;
1251
1252 if (name != Py_None && !PyUnicode_Check(name)) {
1253 PyErr_SetString(PyExc_TypeError,
1254 "TypeTemplateParameter name must be str or None");
1255 return NULL;
1256 }
1257
1258 PyObject *obj;
1259 union drgn_lazy_object *state;
1260 if (LazyObject_arg(object, "TypeTemplateParameter", false, &obj, &state))
1261 return NULL;
1262
1263 TypeTemplateParameter *parameter =
1264 (TypeTemplateParameter *)subtype->tp_alloc(subtype, 0);
1265 if (!parameter) {
1266 Py_DECREF(obj);
1267 return NULL;
1268 }
1269
1270 parameter->lazy_obj.obj = obj;
1271 parameter->lazy_obj.lazy_obj = state;
1272 Py_INCREF(name);
1273 parameter->name = name;
1274 Py_INCREF(is_default);
1275 parameter->is_default = is_default;
1276 return parameter;
1277 }
1278
1279 static void TypeTemplateParameter_dealloc(TypeTemplateParameter *self)
1280 {
1281 PyObject_GC_UnTrack(self);
1282 Py_XDECREF(self->is_default);
1283 Py_XDECREF(self->name);
1284 LazyObject_dealloc((LazyObject *)self);
1285 }
1286
1287 static PyObject *TypeTemplateParameter_repr(TypeTemplateParameter *self)
1288 {
1289 _cleanup_pydecref_ PyObject *parts = PyList_New(0);
1290 if (!parts)
1291 return NULL;
1292 if (append_format(parts, "TypeTemplateParameter(") < 0 ||
1293 append_lazy_object_repr(parts, (LazyObject *)self) < 0)
1294 return NULL;
1295 if (self->name != Py_None &&
1296 append_format(parts, ", name=%R", self->name) < 0)
1297 return NULL;
1298 if (self->is_default == Py_True &&
1299 append_string(parts, ", is_default=True") < 0)
1300 return NULL;
1301 if (append_string(parts, ")") < 0)
1302 return NULL;
1303 return join_strings(parts);
1304 }
1305
1306 static PyObject *TypeTemplateParameter_get_argument(TypeTemplateParameter *self,
1307 void *arg)
1308 {
1309 DrgnObject *object = LazyObject_get_borrowed((LazyObject *)self);
1310 if (!object)
1311 return NULL;
1312 if (object->obj.kind == DRGN_OBJECT_ABSENT) {
1313 return DrgnType_wrap(drgn_object_qualified_type(&object->obj));
1314 } else {
1315 Py_INCREF(object);
1316 return (PyObject *)object;
1317 }
1318 }
1319
1320 static PyMemberDef TypeTemplateParameter_members[] = {
1321 {"name", T_OBJECT, offsetof(TypeTemplateParameter, name), READONLY,
1322 drgn_TypeTemplateParameter_name_DOC},
1323 {"is_default", T_OBJECT, offsetof(TypeTemplateParameter, is_default),
1324 READONLY, drgn_TypeTemplateParameter_is_default_DOC},
1325 {},
1326 };
1327
1328 static PyGetSetDef TypeTemplateParameter_getset[] = {
1329 {"argument", (getter)TypeTemplateParameter_get_argument, NULL,
1330 drgn_TypeTemplateParameter_argument_DOC, NULL},
1331 {},
1332 };
1333
1334 PyTypeObject TypeTemplateParameter_type = {
1335 PyVarObject_HEAD_INIT(NULL, 0)
1336 .tp_name = "_drgn.TypeTemplateParameter",
1337 .tp_basicsize = sizeof(TypeTemplateParameter),
1338 .tp_dealloc = (destructor)TypeTemplateParameter_dealloc,
1339 .tp_repr = (reprfunc)TypeTemplateParameter_repr,
1340 .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
1341 .tp_traverse = (traverseproc)LazyObject_traverse,
1342 .tp_doc = drgn_TypeTemplateParameter_DOC,
1343 .tp_members = TypeTemplateParameter_members,
1344 .tp_getset = TypeTemplateParameter_getset,
1345 .tp_new = (newfunc)TypeTemplateParameter_new,
1346 };
1347
1348 DrgnType *Program_void_type(Program *self, PyObject *args, PyObject *kwds)
1349 {
1350 static char *keywords[] = { "qualifiers", "language", NULL };
1351 enum drgn_qualifiers qualifiers = 0;
1352 const struct drgn_language *language = NULL;
1353 if (!PyArg_ParseTupleAndKeywords(args, kwds, "|$O&O&:void_type",
1354 keywords, qualifiers_converter,
1355 &qualifiers, language_converter,
1356 &language))
1357 return NULL;
1358
1359 struct drgn_qualified_type qualified_type = {
1360 .type = drgn_void_type(&self->prog, language),
1361 .qualifiers = qualifiers,
1362 };
1363 return (DrgnType *)DrgnType_wrap(qualified_type);
1364 }
1365
1366 struct byteorder_arg {
1367 bool allow_none;
1368 bool is_none;
1369 enum drgn_byte_order value;
1370 };
1371
1372 static int byteorder_converter(PyObject *o, void *p)
1373 {
1374 struct byteorder_arg *arg = p;
1375
1376 arg->is_none = o == Py_None;
1377 if (arg->allow_none && o == Py_None)
1378 return 1;
1379
1380 if (PyUnicode_Check(o)) {
1381 const char *s = PyUnicode_AsUTF8(o);
1382 if (strcmp(s, "little") == 0) {
1383 arg->value = DRGN_LITTLE_ENDIAN;
1384 return 1;
1385 } else if (strcmp(s, "big") == 0) {
1386 arg->value = DRGN_BIG_ENDIAN;
1387 return 1;
1388 }
1389 }
1390 PyErr_Format(PyExc_ValueError,
1391 "expected 'little'%s 'big'%s for byteorder",
1392 arg->allow_none ? "," : " or",
1393 arg->allow_none ? ", or None" : "");
1394 return 0;
1395 }
1396
1397 DrgnType *Program_int_type(Program *self, PyObject *args, PyObject *kwds)
1398 {
1399 static char *keywords[] = {
1400 "name", "size", "is_signed", "byteorder", "qualifiers",
1401 "language", NULL
1402 };
1403 PyObject *name_obj;
1404 struct index_arg size = {};
1405 int is_signed;
1406 struct byteorder_arg byteorder = {
1407 .allow_none = true,
1408 .is_none = true,
1409 .value = DRGN_PROGRAM_ENDIAN,
1410 };
1411 enum drgn_qualifiers qualifiers = 0;
1412 const struct drgn_language *language = NULL;
1413 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O&p|O&$O&O&:int_type",
1414 keywords, &PyUnicode_Type, &name_obj,
1415 index_converter, &size, &is_signed,
1416 byteorder_converter, &byteorder,
1417 qualifiers_converter, &qualifiers,
1418 language_converter, &language))
1419 return NULL;
1420
1421 const char *name = PyUnicode_AsUTF8(name_obj);
1422 if (!name)
1423 return NULL;
1424
1425 if (!Program_hold_reserve(self, 1))
1426 return NULL;
1427
1428 struct drgn_qualified_type qualified_type;
1429 struct drgn_error *err = drgn_int_type_create(&self->prog, name,
1430 size.uvalue, is_signed,
1431 byteorder.value, language,
1432 &qualified_type.type);
1433 if (err)
1434 return set_drgn_error(err);
1435
1436 if (drgn_type_name(qualified_type.type) == name)
1437 Program_hold_object(self, name_obj);
1438
1439 qualified_type.qualifiers = qualifiers;
1440 _cleanup_pydecref_ DrgnType *type_obj =
1441 (DrgnType *)DrgnType_wrap(qualified_type);
1442 if (!type_obj)
1443 return NULL;
1444
1445 if (drgn_type_name(qualified_type.type) == name
1446 && DrgnType_cache_attr(type_obj, &DrgnType_attr_name, name_obj))
1447 return NULL;
1448
1449 return_ptr(type_obj);
1450 }
1451
1452 DrgnType *Program_bool_type(Program *self, PyObject *args, PyObject *kwds)
1453 {
1454 static char *keywords[] = {
1455 "name", "size", "byteorder", "qualifiers", "language", NULL
1456 };
1457 PyObject *name_obj;
1458 struct index_arg size = {};
1459 struct byteorder_arg byteorder = {
1460 .allow_none = true,
1461 .is_none = true,
1462 .value = DRGN_PROGRAM_ENDIAN,
1463 };
1464 enum drgn_qualifiers qualifiers = 0;
1465 const struct drgn_language *language = NULL;
1466 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O&|O&$O&O&:bool_type",
1467 keywords, &PyUnicode_Type, &name_obj,
1468 index_converter, &size,
1469 byteorder_converter, &byteorder,
1470 qualifiers_converter, &qualifiers,
1471 language_converter, &language))
1472 return NULL;
1473
1474 const char *name = PyUnicode_AsUTF8(name_obj);
1475 if (!name)
1476 return NULL;
1477
1478 if (!Program_hold_reserve(self, 1))
1479 return NULL;
1480
1481 struct drgn_qualified_type qualified_type;
1482 struct drgn_error *err = drgn_bool_type_create(&self->prog, name,
1483 size.uvalue,
1484 byteorder.value,
1485 language,
1486 &qualified_type.type);
1487 if (err)
1488 return set_drgn_error(err);
1489
1490 if (drgn_type_name(qualified_type.type) == name)
1491 Program_hold_object(self, name_obj);
1492
1493 qualified_type.qualifiers = qualifiers;
1494 _cleanup_pydecref_ DrgnType *type_obj =
1495 (DrgnType *)DrgnType_wrap(qualified_type);
1496 if (!type_obj)
1497 return NULL;
1498
1499 if (drgn_type_name(qualified_type.type) == name
1500 && DrgnType_cache_attr(type_obj, &DrgnType_attr_name, name_obj))
1501 return NULL;
1502
1503 return_ptr(type_obj);
1504 }
1505
1506 DrgnType *Program_float_type(Program *self, PyObject *args, PyObject *kwds)
1507 {
1508 static char *keywords[] = {
1509 "name", "size", "byteorder", "qualifiers", "language", NULL
1510 };
1511 PyObject *name_obj;
1512 struct index_arg size = {};
1513 struct byteorder_arg byteorder = {
1514 .allow_none = true,
1515 .is_none = true,
1516 .value = DRGN_PROGRAM_ENDIAN,
1517 };
1518 enum drgn_qualifiers qualifiers = 0;
1519 const struct drgn_language *language = NULL;
1520
1521 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O&|O&$O&O&:float_type",
1522 keywords, &PyUnicode_Type, &name_obj,
1523 index_converter, &size,
1524 byteorder_converter, &byteorder,
1525 qualifiers_converter, &qualifiers,
1526 language_converter, &language))
1527 return NULL;
1528
1529 const char *name = PyUnicode_AsUTF8(name_obj);
1530 if (!name)
1531 return NULL;
1532
1533 if (!Program_hold_reserve(self, 1))
1534 return NULL;
1535
1536 struct drgn_qualified_type qualified_type;
1537 struct drgn_error *err = drgn_float_type_create(&self->prog, name,
1538 size.uvalue,
1539 byteorder.value,
1540 language,
1541 &qualified_type.type);
1542 if (err)
1543 return set_drgn_error(err);
1544
1545 if (drgn_type_name(qualified_type.type) == name)
1546 Program_hold_object(self, name_obj);
1547
1548 qualified_type.qualifiers = qualifiers;
1549 _cleanup_pydecref_ DrgnType *type_obj =
1550 (DrgnType *)DrgnType_wrap(qualified_type);
1551 if (!type_obj)
1552 return NULL;
1553
1554 if (drgn_type_name(qualified_type.type) == name
1555 && DrgnType_cache_attr(type_obj, &DrgnType_attr_name, name_obj))
1556 return NULL;
1557
1558 return_ptr(type_obj);
1559 }
1560
1561 static struct drgn_error *py_lazy_object_thunk_fn(struct drgn_object *res,
1562 void *arg)
1563 {
1564 if (!res)
1565 return NULL; /* Nothing to free. */
1566 PyGILState_guard();
1567 DrgnObject *obj = LazyObject_get_borrowed(arg);
1568 if (obj)
1569 return drgn_object_copy(res, &obj->obj);
1570 else
1571 return drgn_error_from_python();
1572 }
1573
1574 static int lazy_object_from_py(union drgn_lazy_object *lazy_obj,
1575 LazyObject *py_lazy_obj,
1576 struct drgn_program *prog, bool *can_cache)
1577 {
1578 if (py_lazy_obj->lazy_obj == DRGNPY_LAZY_OBJECT_EVALUATED) {
1579 struct drgn_object *obj = &((DrgnObject *)py_lazy_obj->obj)->obj;
1580 drgn_object_init(&lazy_obj->obj, drgn_object_program(obj));
1581 struct drgn_error *err = drgn_object_copy(&lazy_obj->obj, obj);
1582 if (err) {
1583 set_drgn_error(err);
1584 drgn_object_deinit(&lazy_obj->obj);
1585 return -1;
1586 }
1587 } else {
1588 drgn_lazy_object_init_thunk(lazy_obj, prog,
1589 py_lazy_object_thunk_fn,
1590 py_lazy_obj);
1591 /*
1592 * We created a new thunk, so we can't reuse the passed
1593 * LazyObject. Don't cache the container so we create a new one
1594 * when it's accessed.
1595 */
1596 *can_cache = false;
1597 }
1598 return 0;
1599 }
1600
1601 static int unpack_member(struct drgn_compound_type_builder *builder,
1602 PyObject *item, bool *can_cache)
1603 {
1604 if (!PyObject_TypeCheck((PyObject *)item, &TypeMember_type)) {
1605 PyErr_SetString(PyExc_TypeError, "member must be TypeMember");
1606 return -1;
1607 }
1608 TypeMember *member = (TypeMember *)item;
1609
1610 const char *name;
1611 if (member->name == Py_None) {
1612 name = NULL;
1613 } else {
1614 name = PyUnicode_AsUTF8(member->name);
1615 if (!name)
1616 return -1;
1617 }
1618
1619 uint64_t bit_offset;
1620 if (PyLong_AsUInt64(member->bit_offset, &bit_offset))
1621 return -1;
1622
1623 union drgn_lazy_object object;
1624 if (lazy_object_from_py(&object, (LazyObject *)member,
1625 builder->template_builder.prog,
1626 can_cache) == -1)
1627 return -1;
1628 struct drgn_error *err =
1629 drgn_compound_type_builder_add_member(builder, &object, name,
1630 bit_offset);
1631 if (err) {
1632 drgn_lazy_object_deinit(&object);
1633 set_drgn_error(err);
1634 return -1;
1635 }
1636 return 0;
1637 }
1638
1639 static int
1640 unpack_template_parameter(struct drgn_template_parameters_builder *builder,
1641 PyObject *item, bool *can_cache)
1642 {
1643 if (!PyObject_TypeCheck((PyObject *)item,
1644 &TypeTemplateParameter_type)) {
1645 PyErr_SetString(PyExc_TypeError,
1646 "template parameter must be TypeTemplateParameter");
1647 return -1;
1648 }
1649 TypeTemplateParameter *parameter = (TypeTemplateParameter *)item;
1650
1651 const char *name;
1652 if (parameter->name == Py_None) {
1653 name = NULL;
1654 } else {
1655 name = PyUnicode_AsUTF8(parameter->name);
1656 if (!name)
1657 return -1;
1658 }
1659 /* parameter->is_default is always a PyBool, so we can use ==. */
1660 bool is_default = parameter->is_default == Py_True;
1661
1662 union drgn_lazy_object object;
1663 if (lazy_object_from_py(&object, (LazyObject *)parameter, builder->prog,
1664 can_cache) == -1)
1665 return -1;
1666 struct drgn_error *err =
1667 drgn_template_parameters_builder_add(builder, &object, name,
1668 is_default);
1669 if (err) {
1670 drgn_lazy_object_deinit(&object);
1671 set_drgn_error(err);
1672 return -1;
1673 }
1674 return 0;
1675 }
1676
1677 #define compound_type_arg_format "O|O&O$OO&O&"
1678
1679 static DrgnType *Program_compound_type(Program *self, PyObject *args,
1680 PyObject *kwds, const char *arg_format,
1681 enum drgn_type_kind kind)
1682 {
1683 static char *keywords[] = {
1684 "tag", "size", "members", "template_parameters", "qualifiers",
1685 "language", NULL,
1686 };
1687 PyObject *tag_obj;
1688 struct index_arg size = { .allow_none = true, .is_none = true };
1689 PyObject *members_obj = Py_None;
1690 PyObject *template_parameters_obj = NULL;
1691 enum drgn_qualifiers qualifiers = 0;
1692 const struct drgn_language *language = NULL;
1693 if (!PyArg_ParseTupleAndKeywords(args, kwds, arg_format, keywords,
1694 &tag_obj, index_converter, &size,
1695 &members_obj, &template_parameters_obj,
1696 qualifiers_converter, &qualifiers,
1697 language_converter, &language))
1698 return NULL;
1699
1700 const char *tag;
1701 if (tag_obj == Py_None) {
1702 tag = NULL;
1703 } else if (PyUnicode_Check(tag_obj)) {
1704 tag = PyUnicode_AsUTF8(tag_obj);
1705 if (!tag)
1706 return NULL;
1707 } else {
1708 PyErr_Format(PyExc_TypeError,
1709 "%s_type() tag must be str or None",
1710 drgn_type_kind_spelling[kind]);
1711 return NULL;
1712 }
1713
1714 _cleanup_pydecref_ PyObject *cached_members = NULL;
1715 size_t num_members;
1716 if (members_obj == Py_None) {
1717 if (!size.is_none) {
1718 PyErr_Format(PyExc_ValueError,
1719 "incomplete %s type must not have size",
1720 drgn_type_kind_spelling[kind]);
1721 return NULL;
1722 }
1723 num_members = 0;
1724 } else {
1725 if (size.is_none) {
1726 PyErr_Format(PyExc_ValueError, "%s type must have size",
1727 drgn_type_kind_spelling[kind]);
1728 return NULL;
1729 }
1730 if (!PySequence_Check(members_obj)) {
1731 PyErr_SetString(PyExc_TypeError,
1732 "members must be sequence or None");
1733 return NULL;
1734 }
1735 cached_members = PySequence_Tuple(members_obj);
1736 if (!cached_members)
1737 return NULL;
1738 num_members = PyTuple_GET_SIZE(cached_members);
1739 }
1740 bool can_cache_members = true;
1741
1742 _cleanup_pydecref_ PyObject *cached_template_parameters;
1743 if (template_parameters_obj) {
1744 cached_template_parameters =
1745 PySequence_Tuple(template_parameters_obj);
1746 } else {
1747 cached_template_parameters = PyTuple_New(0);
1748 }
1749 if (!cached_template_parameters)
1750 return NULL;
1751 size_t num_template_parameters =
1752 PyTuple_GET_SIZE(cached_template_parameters);
1753 bool can_cache_template_parameters = true;
1754
1755 struct drgn_compound_type_builder builder;
1756 drgn_compound_type_builder_init(&builder, &self->prog, kind);
1757 for (size_t i = 0; i < num_members; i++) {
1758 if (unpack_member(&builder, PyTuple_GET_ITEM(cached_members, i),
1759 &can_cache_members) == -1)
1760 goto err_builder;
1761 }
1762 for (size_t i = 0; i < num_template_parameters; i++) {
1763 if (unpack_template_parameter(&builder.template_builder,
1764 PyTuple_GET_ITEM(cached_template_parameters, i),
1765 &can_cache_template_parameters) == -1)
1766 goto err_builder;
1767 }
1768
1769 if (!Program_hold_reserve(self,
1770 (tag_obj != Py_None) +
1771 (num_members > 0) +
1772 (num_template_parameters > 0)))
1773 goto err_builder;
1774
1775 struct drgn_qualified_type qualified_type;
1776 struct drgn_error *err = drgn_compound_type_create(&builder, tag,
1777 size.uvalue,
1778 members_obj != Py_None,
1779 language,
1780 &qualified_type.type);
1781 if (err) {
1782 set_drgn_error(err);
1783 err_builder:
1784 drgn_compound_type_builder_deinit(&builder);
1785 return NULL;
1786 }
1787
1788 if (tag_obj != Py_None && drgn_type_tag(qualified_type.type) == tag)
1789 Program_hold_object(self, tag_obj);
1790 if (num_members > 0)
1791 Program_hold_object(self, cached_members);
1792 if (num_template_parameters > 0)
1793 Program_hold_object(self, cached_template_parameters);
1794
1795 qualified_type.qualifiers = qualifiers;
1796 _cleanup_pydecref_ DrgnType *type_obj =
1797 (DrgnType *)DrgnType_wrap(qualified_type);
1798 if (!type_obj)
1799 return NULL;
1800
1801 if (DrgnType_cache_attr(type_obj, &DrgnType_attr_tag, tag_obj)
1802 || (can_cache_members
1803 && DrgnType_cache_attr(type_obj, &DrgnType_attr_members,
1804 cached_members
1805 ? cached_members : Py_None))
1806 || (can_cache_template_parameters
1807 && DrgnType_cache_attr(type_obj,
1808 &DrgnType_attr_template_parameters,
1809 cached_template_parameters)))
1810 return NULL;
1811
1812 return_ptr(type_obj);
1813 }
1814
1815 DrgnType *Program_struct_type(Program *self, PyObject *args, PyObject *kwds)
1816 {
1817 return Program_compound_type(self, args, kwds,
1818 compound_type_arg_format ":struct_type",
1819 DRGN_TYPE_STRUCT);
1820 }
1821
1822 DrgnType *Program_union_type(Program *self, PyObject *args, PyObject *kwds)
1823 {
1824 return Program_compound_type(self, args, kwds,
1825 compound_type_arg_format ":union_type",
1826 DRGN_TYPE_UNION);
1827 }
1828
1829 DrgnType *Program_class_type(Program *self, PyObject *args, PyObject *kwds)
1830 {
1831 return Program_compound_type(self, args, kwds,
1832 compound_type_arg_format ":class_type",
1833 DRGN_TYPE_CLASS);
1834 }
1835
1836 static int unpack_enumerator(struct drgn_enum_type_builder *builder,
1837 PyObject *item, bool is_signed)
1838 {
1839 if (!PyObject_TypeCheck(item, &TypeEnumerator_type)) {
1840 PyErr_SetString(PyExc_TypeError,
1841 "enumerator must be TypeEnumerator");
1842 return -1;
1843 }
1844 TypeEnumerator *enumerator = (TypeEnumerator *)item;
1845
1846 const char *name = PyUnicode_AsUTF8(enumerator->name);
1847 if (!name)
1848 return -1;
1849
1850 struct drgn_error *err;
1851 if (is_signed) {
1852 int64_t svalue;
1853 if (PyLong_AsInt64(enumerator->value, &svalue))
1854 return -1;
1855 err = drgn_enum_type_builder_add_signed(builder, name, svalue);
1856 } else {
1857 uint64_t uvalue;
1858 if (PyLong_AsUInt64(enumerator->value, &uvalue))
1859 return -1;
1860 err = drgn_enum_type_builder_add_unsigned(builder, name,
1861 uvalue);
1862 }
1863 if (err) {
1864 set_drgn_error(err);
1865 return -1;
1866 }
1867 return 0;
1868 }
1869
1870 DrgnType *Program_enum_type(Program *self, PyObject *args, PyObject *kwds)
1871 {
1872 static char *keywords[] = {
1873 "tag", "type", "enumerators", "qualifiers", "language", NULL
1874 };
1875 PyObject *tag_obj;
1876 PyObject *compatible_type_obj = Py_None;
1877 PyObject *enumerators_obj = Py_None;
1878 enum drgn_qualifiers qualifiers = 0;
1879 const struct drgn_language *language = NULL;
1880 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OO$O&O&:enum_type",
1881 keywords, &tag_obj,
1882 &compatible_type_obj, &enumerators_obj,
1883 qualifiers_converter, &qualifiers,
1884 language_converter, &language))
1885 return NULL;
1886
1887 const char *tag;
1888 if (tag_obj == Py_None) {
1889 tag = NULL;
1890 } else if (PyUnicode_Check(tag_obj)) {
1891 tag = PyUnicode_AsUTF8(tag_obj);
1892 if (!tag)
1893 return NULL;
1894 } else {
1895 PyErr_SetString(PyExc_TypeError,
1896 "enum_type() tag must be str or None");
1897 return NULL;
1898 }
1899
1900 if (compatible_type_obj != Py_None &&
1901 !PyObject_TypeCheck(compatible_type_obj, &DrgnType_type)) {
1902 PyErr_SetString(PyExc_TypeError,
1903 "enum_type() compatible type must be Type or None");
1904 return NULL;
1905 }
1906
1907 _cleanup_pydecref_ PyObject *cached_enumerators = NULL;
1908 struct drgn_qualified_type qualified_type;
1909 struct drgn_error *err;
1910 if (enumerators_obj == Py_None) {
1911 if (compatible_type_obj != Py_None) {
1912 PyErr_SetString(PyExc_ValueError,
1913 "incomplete enum type must not have compatible type");
1914 return NULL;
1915 }
1916
1917 if (!Program_hold_reserve(self, tag_obj != Py_None))
1918 return NULL;
1919
1920 err = drgn_incomplete_enum_type_create(&self->prog, tag,
1921 language,
1922 &qualified_type.type);
1923 if (err)
1924 return set_drgn_error(err);
1925 } else {
1926 if (compatible_type_obj == Py_None) {
1927 PyErr_SetString(PyExc_ValueError,
1928 "enum type must have compatible type");
1929 return NULL;
1930 }
1931 struct drgn_type *compatible_type =
1932 ((DrgnType *)compatible_type_obj)->type;
1933 if (drgn_type_kind(compatible_type) != DRGN_TYPE_INT) {
1934 PyErr_SetString(PyExc_ValueError,
1935 "enum_type() compatible type must be integer type");
1936 return NULL;
1937 }
1938 if (((DrgnType *)compatible_type_obj)->qualifiers) {
1939 PyErr_SetString(PyExc_ValueError,
1940 "enum_type() compatible type must be unqualified");
1941 return NULL;
1942 }
1943
1944 if (!PySequence_Check(enumerators_obj)) {
1945 PyErr_SetString(PyExc_TypeError,
1946 "enumerators must be sequence or None");
1947 return NULL;
1948 }
1949 cached_enumerators = PySequence_Tuple(enumerators_obj);
1950 if (!cached_enumerators)
1951 return NULL;
1952 size_t num_enumerators = PyTuple_GET_SIZE(cached_enumerators);
1953
1954 struct drgn_enum_type_builder builder;
1955 drgn_enum_type_builder_init(&builder, &self->prog);
1956 bool is_signed = drgn_type_is_signed(compatible_type);
1957 for (size_t i = 0; i < num_enumerators; i++) {
1958 if (unpack_enumerator(&builder,
1959 PyTuple_GET_ITEM(cached_enumerators, i),
1960 is_signed) == -1)
1961 return NULL;
1962 }
1963
1964 if (!Program_hold_reserve(self, 1 + (tag_obj != Py_None)))
1965 goto err_builder;
1966
1967 err = drgn_enum_type_create(&builder, tag, compatible_type,
1968 language, &qualified_type.type);
1969 if (err) {
1970 set_drgn_error(err);
1971 err_builder:
1972 drgn_enum_type_builder_deinit(&builder);
1973 return NULL;
1974 }
1975
1976 Program_hold_object(self, cached_enumerators);
1977 }
1978
1979 if (tag_obj != Py_None && drgn_type_tag(qualified_type.type) == tag)
1980 Program_hold_object(self, tag_obj);
1981
1982 qualified_type.qualifiers = qualifiers;
1983 _cleanup_pydecref_ DrgnType *type_obj =
1984 (DrgnType *)DrgnType_wrap(qualified_type);
1985 if (!type_obj)
1986 return NULL;
1987
1988 if (DrgnType_cache_attr(type_obj, &DrgnType_attr_tag, tag_obj)
1989 || DrgnType_cache_attr(type_obj, &DrgnType_attr_type,
1990 compatible_type_obj)
1991 || DrgnType_cache_attr(type_obj, &DrgnType_attr_enumerators,
1992 cached_enumerators
1993 ? cached_enumerators : Py_None))
1994 return NULL;
1995
1996 return_ptr(type_obj);
1997 }
1998
1999 DrgnType *Program_typedef_type(Program *self, PyObject *args, PyObject *kwds)
2000 {
2001 static char *keywords[] = {
2002 "name", "type", "qualifiers", "language", NULL
2003 };
2004 PyObject *name_obj;
2005 DrgnType *aliased_type_obj;
2006 enum drgn_qualifiers qualifiers = 0;
2007 const struct drgn_language *language = NULL;
2008
2009 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O!|$O&O&:typedef_type",
2010 keywords, &PyUnicode_Type, &name_obj,
2011 &DrgnType_type, &aliased_type_obj,
2012 qualifiers_converter, &qualifiers,
2013 language_converter, &language))
2014 return NULL;
2015
2016 const char *name = PyUnicode_AsUTF8(name_obj);
2017 if (!name)
2018 return NULL;
2019
2020 if (!Program_hold_reserve(self, 1))
2021 return NULL;
2022
2023 struct drgn_qualified_type qualified_type;
2024 struct drgn_error *err = drgn_typedef_type_create(&self->prog, name,
2025 DrgnType_unwrap(aliased_type_obj),
2026 language,
2027 &qualified_type.type);
2028 if (err)
2029 return set_drgn_error(err);
2030
2031 if (drgn_type_name(qualified_type.type) == name)
2032 Program_hold_object(self, name_obj);
2033
2034 qualified_type.qualifiers = qualifiers;
2035 _cleanup_pydecref_ DrgnType *type_obj =
2036 (DrgnType *)DrgnType_wrap(qualified_type);
2037 if (!type_obj)
2038 return NULL;
2039
2040 if (DrgnType_cache_attr(type_obj, &DrgnType_attr_type,
2041 (PyObject *)aliased_type_obj)
2042 || DrgnType_cache_attr(type_obj, &DrgnType_attr_name, name_obj))
2043 return NULL;
2044
2045 return_ptr(type_obj);
2046 }
2047
2048 DrgnType *Program_pointer_type(Program *self, PyObject *args, PyObject *kwds)
2049 {
2050 static char *keywords[] = {
2051 "type", "size", "byteorder", "qualifiers", "language", NULL
2052 };
2053 DrgnType *referenced_type_obj;
2054 struct index_arg size = { .allow_none = true, .is_none = true };
2055 struct byteorder_arg byteorder = {
2056 .allow_none = true,
2057 .is_none = true,
2058 .value = DRGN_PROGRAM_ENDIAN,
2059 };
2060 enum drgn_qualifiers qualifiers = 0;
2061 const struct drgn_language *language = NULL;
2062 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|O&O&$O&O&:pointer_type",
2063 keywords, &DrgnType_type,
2064 &referenced_type_obj, index_converter,
2065 &size, byteorder_converter, &byteorder,
2066 qualifiers_converter, &qualifiers,
2067 language_converter, &language))
2068 return NULL;
2069
2070 if (size.is_none) {
2071 uint64_t address_size;
2072 struct drgn_error *err =
2073 drgn_program_address_size(&self->prog, &address_size);
2074 if (err)
2075 return set_drgn_error(err);
2076 size.uvalue = address_size;
2077 }
2078
2079 struct drgn_qualified_type qualified_type;
2080 struct drgn_error *err = drgn_pointer_type_create(&self->prog,
2081 DrgnType_unwrap(referenced_type_obj),
2082 size.uvalue,
2083 byteorder.value,
2084 language,
2085 &qualified_type.type);
2086 if (err)
2087 return set_drgn_error(err);
2088 qualified_type.qualifiers = qualifiers;
2089 _cleanup_pydecref_ DrgnType *type_obj =
2090 (DrgnType *)DrgnType_wrap(qualified_type);
2091 if (!type_obj)
2092 return NULL;
2093
2094 if (DrgnType_cache_attr(type_obj, &DrgnType_attr_type,
2095 (PyObject *)referenced_type_obj))
2096 return NULL;
2097
2098 return_ptr(type_obj);
2099 }
2100
2101 DrgnType *Program_array_type(Program *self, PyObject *args, PyObject *kwds)
2102 {
2103 static char *keywords[] = {
2104 "type", "length", "qualifiers", "language", NULL
2105 };
2106 DrgnType *element_type_obj;
2107 struct index_arg length = { .allow_none = true, .is_none = true };
2108 enum drgn_qualifiers qualifiers = 0;
2109 const struct drgn_language *language = NULL;
2110 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|O&$O&O&:array_type",
2111 keywords, &DrgnType_type,
2112 &element_type_obj, index_converter,
2113 &length, qualifiers_converter,
2114 &qualifiers, language_converter,
2115 &language))
2116 return NULL;
2117
2118 struct drgn_qualified_type qualified_type;
2119 struct drgn_error *err;
2120 if (length.is_none) {
2121 err = drgn_incomplete_array_type_create(&self->prog,
2122 DrgnType_unwrap(element_type_obj),
2123 language,
2124 &qualified_type.type);
2125 } else {
2126 err = drgn_array_type_create(&self->prog,
2127 DrgnType_unwrap(element_type_obj),
2128 length.uvalue, language,
2129 &qualified_type.type);
2130 }
2131 if (err)
2132 return set_drgn_error(err);
2133 qualified_type.qualifiers = qualifiers;
2134 _cleanup_pydecref_ DrgnType *type_obj =
2135 (DrgnType *)DrgnType_wrap(qualified_type);
2136 if (!type_obj)
2137 return NULL;
2138
2139 if (DrgnType_cache_attr(type_obj, &DrgnType_attr_type,
2140 (PyObject *)element_type_obj))
2141 return NULL;
2142
2143 return_ptr(type_obj);
2144 }
2145
2146 static int unpack_parameter(struct drgn_function_type_builder *builder,
2147 PyObject *item, bool *can_cache)
2148 {
2149 if (!PyObject_TypeCheck(item, &TypeParameter_type)) {
2150 PyErr_SetString(PyExc_TypeError,
2151 "parameter must be TypeParameter");
2152 return -1;
2153 }
2154 TypeParameter *parameter = (TypeParameter *)item;
2155
2156 const char *name;
2157 if (parameter->name == Py_None) {
2158 name = NULL;
2159 } else {
2160 name = PyUnicode_AsUTF8(parameter->name);
2161 if (!name)
2162 return -1;
2163 }
2164
2165 union drgn_lazy_object default_argument;
2166 if (lazy_object_from_py(&default_argument, (LazyObject *)parameter,
2167 builder->template_builder.prog,
2168 can_cache) == -1)
2169 return -1;
2170 struct drgn_error *err =
2171 drgn_function_type_builder_add_parameter(builder,
2172 &default_argument,
2173 name);
2174 if (err) {
2175 drgn_lazy_object_deinit(&default_argument);
2176 set_drgn_error(err);
2177 return -1;
2178 }
2179 return 0;
2180 }
2181
2182 DrgnType *Program_function_type(Program *self, PyObject *args, PyObject *kwds)
2183 {
2184 static char *keywords[] = {
2185 "type", "parameters", "is_variadic", "template_parameters",
2186 "qualifiers", "language", NULL,
2187 };
2188 DrgnType *return_type_obj;
2189 PyObject *parameters_obj;
2190 int is_variadic = 0;
2191 PyObject *template_parameters_obj = NULL;
2192 enum drgn_qualifiers qualifiers = 0;
2193 const struct drgn_language *language = NULL;
2194 if (!PyArg_ParseTupleAndKeywords(args, kwds,
2195 "O!O|p$OO&O&:function_type", keywords,
2196 &DrgnType_type, &return_type_obj,
2197 &parameters_obj, &is_variadic,
2198 &template_parameters_obj,
2199 qualifiers_converter, &qualifiers,
2200 language_converter, &language))
2201 return NULL;
2202
2203 if (!PySequence_Check(parameters_obj)) {
2204 PyErr_SetString(PyExc_TypeError, "parameters must be sequence");
2205 return NULL;
2206 }
2207
2208 _cleanup_pydecref_ PyObject *cached_parameters =
2209 PySequence_Tuple(parameters_obj);
2210 if (!cached_parameters)
2211 return NULL;
2212 size_t num_parameters = PyTuple_GET_SIZE(cached_parameters);
2213 bool can_cache_parameters = true;
2214
2215 _cleanup_pydecref_ PyObject *cached_template_parameters;
2216 if (template_parameters_obj) {
2217 cached_template_parameters =
2218 PySequence_Tuple(template_parameters_obj);
2219 } else {
2220 cached_template_parameters = PyTuple_New(0);
2221 }
2222 if (!cached_template_parameters)
2223 return NULL;
2224 size_t num_template_parameters =
2225 PyTuple_GET_SIZE(cached_template_parameters);
2226 bool can_cache_template_parameters = true;
2227
2228 struct drgn_function_type_builder builder;
2229 drgn_function_type_builder_init(&builder, &self->prog);
2230 for (size_t i = 0; i < num_parameters; i++) {
2231 if (unpack_parameter(&builder,
2232 PyTuple_GET_ITEM(cached_parameters, i),
2233 &can_cache_parameters) == -1)
2234 goto err_builder;
2235 }
2236 for (size_t i = 0; i < num_template_parameters; i++) {
2237 if (unpack_template_parameter(&builder.template_builder,
2238 PyTuple_GET_ITEM(cached_template_parameters, i),
2239 &can_cache_template_parameters) == -1)
2240 goto err_builder;
2241 }
2242
2243 if (!Program_hold_reserve(self,
2244 (num_parameters > 0) +
2245 (num_template_parameters > 0)))
2246 goto err_builder;
2247
2248 struct drgn_qualified_type qualified_type;
2249 struct drgn_error *err = drgn_function_type_create(&builder,
2250 DrgnType_unwrap(return_type_obj),
2251 is_variadic,
2252 language,
2253 &qualified_type.type);
2254 if (err) {
2255 set_drgn_error(err);
2256 err_builder:
2257 drgn_function_type_builder_deinit(&builder);
2258 return NULL;
2259 }
2260
2261 if (num_parameters > 0)
2262 Program_hold_object(self, cached_parameters);
2263 if (num_template_parameters > 0)
2264 Program_hold_object(self, cached_template_parameters);
2265
2266 qualified_type.qualifiers = qualifiers;
2267 _cleanup_pydecref_ DrgnType *type_obj =
2268 (DrgnType *)DrgnType_wrap(qualified_type);
2269 if (!type_obj)
2270 return NULL;
2271
2272 if (DrgnType_cache_attr(type_obj, &DrgnType_attr_type,
2273 (PyObject *)return_type_obj)
2274 || (can_cache_parameters
2275 && DrgnType_cache_attr(type_obj, &DrgnType_attr_parameters,
2276 cached_parameters))
2277 || (can_cache_template_parameters
2278 && DrgnType_cache_attr(type_obj,
2279 &DrgnType_attr_template_parameters,
2280 cached_template_parameters)))
2281 return NULL;
2282
2283 return_ptr(type_obj);
2284 }