1 /* Python interface to types.
3 Copyright (C) 2008-2022 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "python-internal.h"
25 #include "cp-support.h"
29 #include "typeprint.h"
37 /* If a Type object is associated with an objfile, it is kept on a
38 doubly-linked list, rooted in the objfile. This lets us copy the
39 underlying struct type when the objfile is deleted. */
40 struct type_object
*prev
;
41 struct type_object
*next
;
44 extern PyTypeObject type_object_type
45 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("type_object");
52 /* Dictionary holding our attributes. */
56 extern PyTypeObject field_object_type
57 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("field_object");
59 /* A type iterator object. */
60 struct typy_iterator_object
{
62 /* The current field index. */
65 enum gdbpy_iter_kind kind
;
66 /* Pointer back to the original source type object. */
70 extern PyTypeObject type_iterator_object_type
71 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("typy_iterator_object");
73 /* This is used to initialize various gdb.TYPE_ constants. */
82 /* Forward declarations. */
83 static PyObject
*typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
);
85 #define ENTRY(X) { X, #X }
87 static struct pyty_code pyty_codes
[] =
89 ENTRY (TYPE_CODE_BITSTRING
),
90 ENTRY (TYPE_CODE_PTR
),
91 ENTRY (TYPE_CODE_ARRAY
),
92 ENTRY (TYPE_CODE_STRUCT
),
93 ENTRY (TYPE_CODE_UNION
),
94 ENTRY (TYPE_CODE_ENUM
),
95 ENTRY (TYPE_CODE_FLAGS
),
96 ENTRY (TYPE_CODE_FUNC
),
97 ENTRY (TYPE_CODE_INT
),
98 ENTRY (TYPE_CODE_FLT
),
99 ENTRY (TYPE_CODE_VOID
),
100 ENTRY (TYPE_CODE_SET
),
101 ENTRY (TYPE_CODE_RANGE
),
102 ENTRY (TYPE_CODE_STRING
),
103 ENTRY (TYPE_CODE_ERROR
),
104 ENTRY (TYPE_CODE_METHOD
),
105 ENTRY (TYPE_CODE_METHODPTR
),
106 ENTRY (TYPE_CODE_MEMBERPTR
),
107 ENTRY (TYPE_CODE_REF
),
108 ENTRY (TYPE_CODE_RVALUE_REF
),
109 ENTRY (TYPE_CODE_CHAR
),
110 ENTRY (TYPE_CODE_BOOL
),
111 ENTRY (TYPE_CODE_COMPLEX
),
112 ENTRY (TYPE_CODE_TYPEDEF
),
113 ENTRY (TYPE_CODE_NAMESPACE
),
114 ENTRY (TYPE_CODE_DECFLOAT
),
115 ENTRY (TYPE_CODE_INTERNAL_FUNCTION
),
116 { TYPE_CODE_UNDEF
, NULL
}
122 field_dealloc (PyObject
*obj
)
124 field_object
*f
= (field_object
*) obj
;
126 Py_XDECREF (f
->dict
);
127 Py_TYPE (obj
)->tp_free (obj
);
133 gdbpy_ref
<field_object
> result (PyObject_New (field_object
,
134 &field_object_type
));
138 result
->dict
= PyDict_New ();
142 return (PyObject
*) result
.release ();
147 /* Return true if OBJ is of type gdb.Field, false otherwise. */
150 gdbpy_is_field (PyObject
*obj
)
152 return PyObject_TypeCheck (obj
, &field_object_type
);
155 /* Return the code for this type. */
157 typy_get_code (PyObject
*self
, void *closure
)
159 struct type
*type
= ((type_object
*) self
)->type
;
161 return gdb_py_object_from_longest (type
->code ()).release ();
164 /* Helper function for typy_fields which converts a single field to a
165 gdb.Field object. Returns NULL on error. */
168 convert_field (struct type
*type
, int field
)
170 gdbpy_ref
<> result (field_new ());
175 gdbpy_ref
<> arg (type_to_type_object (type
));
178 if (PyObject_SetAttrString (result
.get (), "parent_type", arg
.get ()) < 0)
181 if (!field_is_static (&type
->field (field
)))
183 const char *attrstring
;
185 if (type
->code () == TYPE_CODE_ENUM
)
187 arg
= gdb_py_object_from_longest (type
->field (field
).loc_enumval ());
188 attrstring
= "enumval";
192 if (type
->field (field
).loc_kind () == FIELD_LOC_KIND_DWARF_BLOCK
)
193 arg
= gdbpy_ref
<>::new_reference (Py_None
);
195 arg
= gdb_py_object_from_longest (type
->field (field
).loc_bitpos ());
196 attrstring
= "bitpos";
202 if (PyObject_SetAttrString (result
.get (), attrstring
, arg
.get ()) < 0)
207 if (type
->field (field
).name ())
209 const char *field_name
= type
->field (field
).name ();
211 if (field_name
[0] != '\0')
213 arg
.reset (PyString_FromString (type
->field (field
).name ()));
219 arg
= gdbpy_ref
<>::new_reference (Py_None
);
221 if (PyObject_SetAttrString (result
.get (), "name", arg
.get ()) < 0)
224 arg
= gdbpy_ref
<>::new_reference (TYPE_FIELD_ARTIFICIAL (type
, field
)
225 ? Py_True
: Py_False
);
226 if (PyObject_SetAttrString (result
.get (), "artificial", arg
.get ()) < 0)
229 if (type
->code () == TYPE_CODE_STRUCT
)
230 arg
= gdbpy_ref
<>::new_reference (field
< TYPE_N_BASECLASSES (type
)
231 ? Py_True
: Py_False
);
233 arg
= gdbpy_ref
<>::new_reference (Py_False
);
234 if (PyObject_SetAttrString (result
.get (), "is_base_class", arg
.get ()) < 0)
237 arg
= gdb_py_object_from_longest (TYPE_FIELD_BITSIZE (type
, field
));
240 if (PyObject_SetAttrString (result
.get (), "bitsize", arg
.get ()) < 0)
243 /* A field can have a NULL type in some situations. */
244 if (type
->field (field
).type () == NULL
)
245 arg
= gdbpy_ref
<>::new_reference (Py_None
);
247 arg
.reset (type_to_type_object (type
->field (field
).type ()));
250 if (PyObject_SetAttrString (result
.get (), "type", arg
.get ()) < 0)
256 /* Helper function to return the name of a field, as a gdb.Field object.
257 If the field doesn't have a name, None is returned. */
260 field_name (struct type
*type
, int field
)
264 if (type
->field (field
).name ())
265 result
.reset (PyString_FromString (type
->field (field
).name ()));
267 result
= gdbpy_ref
<>::new_reference (Py_None
);
272 /* Helper function for Type standard mapping methods. Returns a
273 Python object for field i of the type. "kind" specifies what to
274 return: the name of the field, a gdb.Field object corresponding to
275 the field, or a tuple consisting of field name and gdb.Field
279 make_fielditem (struct type
*type
, int i
, enum gdbpy_iter_kind kind
)
285 gdbpy_ref
<> key (field_name (type
, i
));
288 gdbpy_ref
<> value
= convert_field (type
, i
);
291 gdbpy_ref
<> item (PyTuple_New (2));
294 PyTuple_SET_ITEM (item
.get (), 0, key
.release ());
295 PyTuple_SET_ITEM (item
.get (), 1, value
.release ());
299 return field_name (type
, i
);
301 return convert_field (type
, i
);
303 gdb_assert_not_reached ("invalid gdbpy_iter_kind");
306 /* Return a sequence of all field names, fields, or (name, field) pairs.
307 Each field is a gdb.Field object. */
310 typy_fields_items (PyObject
*self
, enum gdbpy_iter_kind kind
)
312 PyObject
*py_type
= self
;
313 struct type
*type
= ((type_object
*) py_type
)->type
;
314 struct type
*checked_type
= type
;
318 checked_type
= check_typedef (checked_type
);
320 catch (const gdb_exception
&except
)
322 GDB_PY_HANDLE_EXCEPTION (except
);
325 gdbpy_ref
<> type_holder
;
326 if (checked_type
!= type
)
328 type_holder
.reset (type_to_type_object (checked_type
));
329 if (type_holder
== nullptr)
331 py_type
= type_holder
.get ();
333 gdbpy_ref
<> iter (typy_make_iter (py_type
, kind
));
337 return PySequence_List (iter
.get ());
340 /* Return a sequence of all fields. Each field is a gdb.Field object. */
343 typy_values (PyObject
*self
, PyObject
*args
)
345 return typy_fields_items (self
, iter_values
);
348 /* Return a sequence of all fields. Each field is a gdb.Field object.
349 This method is similar to typy_values, except where the supplied
350 gdb.Type is an array, in which case it returns a list of one entry
351 which is a gdb.Field object for a range (the array bounds). */
354 typy_fields (PyObject
*self
, PyObject
*args
)
356 struct type
*type
= ((type_object
*) self
)->type
;
358 if (type
->code () != TYPE_CODE_ARRAY
)
359 return typy_fields_items (self
, iter_values
);
361 /* Array type. Handle this as a special case because the common
362 machinery wants struct or union or enum types. Build a list of
363 one entry which is the range for the array. */
364 gdbpy_ref
<> r
= convert_field (type
, 0);
368 return Py_BuildValue ("[O]", r
.get ());
371 /* Return a sequence of all field names. Each field is a gdb.Field object. */
374 typy_field_names (PyObject
*self
, PyObject
*args
)
376 return typy_fields_items (self
, iter_keys
);
379 /* Return a sequence of all (name, fields) pairs. Each field is a
383 typy_items (PyObject
*self
, PyObject
*args
)
385 return typy_fields_items (self
, iter_items
);
388 /* Return the type's name, or None. */
391 typy_get_name (PyObject
*self
, void *closure
)
393 struct type
*type
= ((type_object
*) self
)->type
;
395 if (type
->name () == NULL
)
397 /* Ada type names are encoded, but it is better for users to see the
399 if (ADA_TYPE_P (type
))
401 std::string name
= ada_decode (type
->name (), false);
403 return PyString_FromString (name
.c_str ());
405 return PyString_FromString (type
->name ());
408 /* Return the type's tag, or None. */
410 typy_get_tag (PyObject
*self
, void *closure
)
412 struct type
*type
= ((type_object
*) self
)->type
;
413 const char *tagname
= nullptr;
415 if (type
->code () == TYPE_CODE_STRUCT
416 || type
->code () == TYPE_CODE_UNION
417 || type
->code () == TYPE_CODE_ENUM
)
418 tagname
= type
->name ();
420 if (tagname
== nullptr)
422 return PyString_FromString (tagname
);
425 /* Return the type's objfile, or None. */
427 typy_get_objfile (PyObject
*self
, void *closure
)
429 struct type
*type
= ((type_object
*) self
)->type
;
430 struct objfile
*objfile
= type
->objfile_owner ();
432 if (objfile
== nullptr)
434 return objfile_to_objfile_object (objfile
).release ();
437 /* Return the type, stripped of typedefs. */
439 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
441 struct type
*type
= ((type_object
*) self
)->type
;
445 type
= check_typedef (type
);
447 catch (const gdb_exception
&except
)
449 GDB_PY_HANDLE_EXCEPTION (except
);
452 return type_to_type_object (type
);
455 /* Strip typedefs and pointers/reference from a type. Then check that
456 it is a struct, union, or enum type. If not, raise TypeError. */
459 typy_get_composite (struct type
*type
)
466 type
= check_typedef (type
);
468 catch (const gdb_exception
&except
)
470 GDB_PY_HANDLE_EXCEPTION (except
);
473 if (!type
->is_pointer_or_reference ())
475 type
= TYPE_TARGET_TYPE (type
);
478 /* If this is not a struct, union, or enum type, raise TypeError
480 if (type
->code () != TYPE_CODE_STRUCT
481 && type
->code () != TYPE_CODE_UNION
482 && type
->code () != TYPE_CODE_ENUM
483 && type
->code () != TYPE_CODE_METHOD
484 && type
->code () != TYPE_CODE_FUNC
)
486 PyErr_SetString (PyExc_TypeError
,
487 "Type is not a structure, union, enum, or function type.");
494 /* Helper for typy_array and typy_vector. */
497 typy_array_1 (PyObject
*self
, PyObject
*args
, int is_vector
)
500 PyObject
*n2_obj
= NULL
;
501 struct type
*array
= NULL
;
502 struct type
*type
= ((type_object
*) self
)->type
;
504 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
509 if (!PyInt_Check (n2_obj
))
511 PyErr_SetString (PyExc_RuntimeError
,
512 _("Array bound must be an integer"));
516 if (! gdb_py_int_as_long (n2_obj
, &n2
))
525 if (n2
< n1
- 1) /* Note: An empty array has n2 == n1 - 1. */
527 PyErr_SetString (PyExc_ValueError
,
528 _("Array length must not be negative"));
534 array
= lookup_array_range_type (type
, n1
, n2
);
536 make_vector_type (array
);
538 catch (const gdb_exception
&except
)
540 GDB_PY_HANDLE_EXCEPTION (except
);
543 return type_to_type_object (array
);
546 /* Return an array type. */
549 typy_array (PyObject
*self
, PyObject
*args
)
551 return typy_array_1 (self
, args
, 0);
554 /* Return a vector type. */
557 typy_vector (PyObject
*self
, PyObject
*args
)
559 return typy_array_1 (self
, args
, 1);
562 /* Return a Type object which represents a pointer to SELF. */
564 typy_pointer (PyObject
*self
, PyObject
*args
)
566 struct type
*type
= ((type_object
*) self
)->type
;
570 type
= lookup_pointer_type (type
);
572 catch (const gdb_exception
&except
)
574 GDB_PY_HANDLE_EXCEPTION (except
);
577 return type_to_type_object (type
);
580 /* Return the range of a type represented by SELF. The return type is
581 a tuple. The first element of the tuple contains the low bound,
582 while the second element of the tuple contains the high bound. */
584 typy_range (PyObject
*self
, PyObject
*args
)
586 struct type
*type
= ((type_object
*) self
)->type
;
587 /* Initialize these to appease GCC warnings. */
588 LONGEST low
= 0, high
= 0;
590 if (type
->code () != TYPE_CODE_ARRAY
591 && type
->code () != TYPE_CODE_STRING
592 && type
->code () != TYPE_CODE_RANGE
)
594 PyErr_SetString (PyExc_RuntimeError
,
595 _("This type does not have a range."));
599 switch (type
->code ())
601 case TYPE_CODE_ARRAY
:
602 case TYPE_CODE_STRING
:
603 case TYPE_CODE_RANGE
:
604 if (type
->bounds ()->low
.kind () == PROP_CONST
)
605 low
= type
->bounds ()->low
.const_val ();
609 if (type
->bounds ()->high
.kind () == PROP_CONST
)
610 high
= type
->bounds ()->high
.const_val ();
616 gdbpy_ref
<> low_bound
= gdb_py_object_from_longest (low
);
617 if (low_bound
== NULL
)
620 gdbpy_ref
<> high_bound
= gdb_py_object_from_longest (high
);
621 if (high_bound
== NULL
)
624 gdbpy_ref
<> result (PyTuple_New (2));
628 if (PyTuple_SetItem (result
.get (), 0, low_bound
.release ()) != 0
629 || PyTuple_SetItem (result
.get (), 1, high_bound
.release ()) != 0)
631 return result
.release ();
634 /* Return a Type object which represents a reference to SELF. */
636 typy_reference (PyObject
*self
, PyObject
*args
)
638 struct type
*type
= ((type_object
*) self
)->type
;
642 type
= lookup_lvalue_reference_type (type
);
644 catch (const gdb_exception
&except
)
646 GDB_PY_HANDLE_EXCEPTION (except
);
649 return type_to_type_object (type
);
652 /* Return a Type object which represents the target type of SELF. */
654 typy_target (PyObject
*self
, PyObject
*args
)
656 struct type
*type
= ((type_object
*) self
)->type
;
658 if (!TYPE_TARGET_TYPE (type
))
660 PyErr_SetString (PyExc_RuntimeError
,
661 _("Type does not have a target."));
665 return type_to_type_object (TYPE_TARGET_TYPE (type
));
668 /* Return a const-qualified type variant. */
670 typy_const (PyObject
*self
, PyObject
*args
)
672 struct type
*type
= ((type_object
*) self
)->type
;
676 type
= make_cv_type (1, 0, type
, NULL
);
678 catch (const gdb_exception
&except
)
680 GDB_PY_HANDLE_EXCEPTION (except
);
683 return type_to_type_object (type
);
686 /* Return a volatile-qualified type variant. */
688 typy_volatile (PyObject
*self
, PyObject
*args
)
690 struct type
*type
= ((type_object
*) self
)->type
;
694 type
= make_cv_type (0, 1, type
, NULL
);
696 catch (const gdb_exception
&except
)
698 GDB_PY_HANDLE_EXCEPTION (except
);
701 return type_to_type_object (type
);
704 /* Return an unqualified type variant. */
706 typy_unqualified (PyObject
*self
, PyObject
*args
)
708 struct type
*type
= ((type_object
*) self
)->type
;
712 type
= make_cv_type (0, 0, type
, NULL
);
714 catch (const gdb_exception
&except
)
716 GDB_PY_HANDLE_EXCEPTION (except
);
719 return type_to_type_object (type
);
722 /* Return the size of the type represented by SELF, in bytes. */
724 typy_get_sizeof (PyObject
*self
, void *closure
)
726 struct type
*type
= ((type_object
*) self
)->type
;
728 bool size_varies
= false;
731 check_typedef (type
);
733 size_varies
= TYPE_HAS_DYNAMIC_LENGTH (type
);
735 catch (const gdb_exception
&except
)
739 /* Ignore exceptions. */
743 return gdb_py_object_from_longest (TYPE_LENGTH (type
)).release ();
746 /* Return the alignment of the type represented by SELF, in bytes. */
748 typy_get_alignof (PyObject
*self
, void *closure
)
750 struct type
*type
= ((type_object
*) self
)->type
;
755 align
= type_align (type
);
757 catch (const gdb_exception
&except
)
762 /* Ignore exceptions. */
764 return gdb_py_object_from_ulongest (align
).release ();
767 /* Return whether or not the type is dynamic. */
769 typy_get_dynamic (PyObject
*self
, void *closure
)
771 struct type
*type
= ((type_object
*) self
)->type
;
776 result
= is_dynamic_type (type
);
778 catch (const gdb_exception
&except
)
780 /* Ignore exceptions. */
789 typy_lookup_typename (const char *type_name
, const struct block
*block
)
791 struct type
*type
= NULL
;
795 if (startswith (type_name
, "struct "))
796 type
= lookup_struct (type_name
+ 7, NULL
);
797 else if (startswith (type_name
, "union "))
798 type
= lookup_union (type_name
+ 6, NULL
);
799 else if (startswith (type_name
, "enum "))
800 type
= lookup_enum (type_name
+ 5, NULL
);
802 type
= lookup_typename (python_language
,
803 type_name
, block
, 0);
805 catch (const gdb_exception
&except
)
807 GDB_PY_HANDLE_EXCEPTION (except
);
814 typy_lookup_type (struct demangle_component
*demangled
,
815 const struct block
*block
)
817 struct type
*type
, *rtype
= NULL
;
818 enum demangle_component_type demangled_type
;
820 /* Save the type: typy_lookup_type() may (indirectly) overwrite
821 memory pointed by demangled. */
822 demangled_type
= demangled
->type
;
824 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
825 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
826 || demangled_type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE
827 || demangled_type
== DEMANGLE_COMPONENT_CONST
828 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
830 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
836 /* If the demangled_type matches with one of the types
837 below, run the corresponding function and save the type
838 to return later. We cannot just return here as we are in
839 an exception handler. */
840 switch (demangled_type
)
842 case DEMANGLE_COMPONENT_REFERENCE
:
843 rtype
= lookup_lvalue_reference_type (type
);
845 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
846 rtype
= lookup_rvalue_reference_type (type
);
848 case DEMANGLE_COMPONENT_POINTER
:
849 rtype
= lookup_pointer_type (type
);
851 case DEMANGLE_COMPONENT_CONST
:
852 rtype
= make_cv_type (1, 0, type
, NULL
);
854 case DEMANGLE_COMPONENT_VOLATILE
:
855 rtype
= make_cv_type (0, 1, type
, NULL
);
859 catch (const gdb_exception
&except
)
861 GDB_PY_HANDLE_EXCEPTION (except
);
865 /* If we have a type from the switch statement above, just return
870 /* We don't have a type, so lookup the type. */
871 gdb::unique_xmalloc_ptr
<char> type_name
= cp_comp_to_string (demangled
, 10);
872 return typy_lookup_typename (type_name
.get (), block
);
875 /* This is a helper function for typy_template_argument that is used
876 when the type does not have template symbols attached. It works by
877 parsing the type name. This happens with compilers, like older
878 versions of GCC, that do not emit DW_TAG_template_*. */
881 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
885 struct demangle_component
*demangled
;
886 std::unique_ptr
<demangle_parse_info
> info
;
888 struct type
*argtype
;
890 if (type
->name () == NULL
)
892 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
898 /* Note -- this is not thread-safe. */
899 info
= cp_demangled_name_to_comp (type
->name (), &err
);
901 catch (const gdb_exception
&except
)
903 GDB_PY_HANDLE_EXCEPTION (except
);
908 PyErr_SetString (PyExc_RuntimeError
, err
.c_str ());
911 demangled
= info
->tree
;
913 /* Strip off component names. */
914 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
915 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
916 demangled
= demangled
->u
.s_binary
.right
;
918 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
920 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
924 /* Skip from the template to the arguments. */
925 demangled
= demangled
->u
.s_binary
.right
;
927 for (i
= 0; demangled
&& i
< argno
; ++i
)
928 demangled
= demangled
->u
.s_binary
.right
;
932 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
937 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
941 return type_to_type_object (argtype
);
945 typy_template_argument (PyObject
*self
, PyObject
*args
)
948 struct type
*type
= ((type_object
*) self
)->type
;
949 const struct block
*block
= NULL
;
950 PyObject
*block_obj
= NULL
;
952 struct value
*val
= NULL
;
954 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
959 PyErr_SetString (PyExc_RuntimeError
,
960 _("Template argument number must be non-negative"));
966 block
= block_object_to_block (block_obj
);
969 PyErr_SetString (PyExc_RuntimeError
,
970 _("Second argument must be block."));
977 type
= check_typedef (type
);
978 if (TYPE_IS_REFERENCE (type
))
979 type
= check_typedef (TYPE_TARGET_TYPE (type
));
981 catch (const gdb_exception
&except
)
983 GDB_PY_HANDLE_EXCEPTION (except
);
986 /* We might not have DW_TAG_template_*, so try to parse the type's
987 name. This is inefficient if we do not have a template type --
988 but that is going to wind up as an error anyhow. */
989 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
990 return typy_legacy_template_argument (type
, block
, argno
);
992 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
994 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
999 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
1000 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
1001 return type_to_type_object (SYMBOL_TYPE (sym
));
1002 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
1004 PyErr_Format (PyExc_RuntimeError
,
1005 _("Template argument is optimized out"));
1011 val
= value_of_variable (sym
, block
);
1013 catch (const gdb_exception
&except
)
1015 GDB_PY_HANDLE_EXCEPTION (except
);
1018 return value_to_value_object (val
);
1022 typy_str (PyObject
*self
)
1024 string_file thetype
;
1028 LA_PRINT_TYPE (type_object_to_type (self
), "", &thetype
, -1, 0,
1029 &type_print_raw_options
);
1031 catch (const gdb_exception
&except
)
1033 GDB_PY_HANDLE_EXCEPTION (except
);
1036 return PyUnicode_Decode (thetype
.c_str (), thetype
.size (),
1037 host_charset (), NULL
);
1040 /* Implement the richcompare method. */
1043 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1045 bool result
= false;
1046 struct type
*type1
= type_object_to_type (self
);
1047 struct type
*type2
= type_object_to_type (other
);
1049 /* We can only compare ourselves to another Type object, and only
1050 for equality or inequality. */
1051 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
1053 Py_INCREF (Py_NotImplemented
);
1054 return Py_NotImplemented
;
1063 result
= types_deeply_equal (type1
, type2
);
1065 catch (const gdb_exception
&except
)
1067 /* If there is a GDB exception, a comparison is not capable
1068 (or trusted), so exit. */
1069 GDB_PY_HANDLE_EXCEPTION (except
);
1073 if (op
== (result
? Py_EQ
: Py_NE
))
1080 static const struct objfile_data
*typy_objfile_data_key
;
1083 save_objfile_types (struct objfile
*objfile
, void *datum
)
1085 type_object
*obj
= (type_object
*) datum
;
1087 if (!gdb_python_initialized
)
1090 /* This prevents another thread from freeing the objects we're
1092 gdbpy_enter
enter_py (objfile
->arch (), current_language
);
1094 htab_up copied_types
= create_copied_types_hash (objfile
);
1098 type_object
*next
= obj
->next
;
1100 htab_empty (copied_types
.get ());
1102 obj
->type
= copy_type_recursive (objfile
, obj
->type
,
1103 copied_types
.get ());
1113 set_type (type_object
*obj
, struct type
*type
)
1117 if (type
!= nullptr && type
->objfile_owner () != nullptr)
1119 struct objfile
*objfile
= type
->objfile_owner ();
1121 obj
->next
= ((type_object
*)
1122 objfile_data (objfile
, typy_objfile_data_key
));
1124 obj
->next
->prev
= obj
;
1125 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1132 typy_dealloc (PyObject
*obj
)
1134 type_object
*type
= (type_object
*) obj
;
1137 type
->prev
->next
= type
->next
;
1138 else if (type
->type
!= nullptr && type
->type
->objfile_owner () != nullptr)
1140 /* Must reset head of list. */
1141 struct objfile
*objfile
= type
->type
->objfile_owner ();
1144 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1147 type
->next
->prev
= type
->prev
;
1149 Py_TYPE (type
)->tp_free (type
);
1152 /* Return number of fields ("length" of the field dictionary). */
1155 typy_length (PyObject
*self
)
1157 struct type
*type
= ((type_object
*) self
)->type
;
1159 type
= typy_get_composite (type
);
1163 return type
->num_fields ();
1166 /* Implements boolean evaluation of gdb.Type. Handle this like other
1167 Python objects that don't have a meaningful truth value -- all
1171 typy_nonzero (PyObject
*self
)
1176 /* Return optimized out value of this type. */
1179 typy_optimized_out (PyObject
*self
, PyObject
*args
)
1181 struct type
*type
= ((type_object
*) self
)->type
;
1183 return value_to_value_object (allocate_optimized_out_value (type
));
1186 /* Return a gdb.Field object for the field named by the argument. */
1189 typy_getitem (PyObject
*self
, PyObject
*key
)
1191 struct type
*type
= ((type_object
*) self
)->type
;
1194 gdb::unique_xmalloc_ptr
<char> field
= python_string_to_host_string (key
);
1198 /* We want just fields of this type, not of base types, so instead of
1199 using lookup_struct_elt_type, portions of that function are
1202 type
= typy_get_composite (type
);
1206 for (i
= 0; i
< type
->num_fields (); i
++)
1208 const char *t_field_name
= type
->field (i
).name ();
1210 if (t_field_name
&& (strcmp_iw (t_field_name
, field
.get ()) == 0))
1211 return convert_field (type
, i
).release ();
1213 PyErr_SetObject (PyExc_KeyError
, key
);
1217 /* Implement the "get" method on the type object. This is the
1218 same as getitem if the key is present, but returns the supplied
1219 default value or None if the key is not found. */
1222 typy_get (PyObject
*self
, PyObject
*args
)
1224 PyObject
*key
, *defval
= Py_None
, *result
;
1226 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1229 result
= typy_getitem (self
, key
);
1233 /* typy_getitem returned error status. If the exception is
1234 KeyError, clear the exception status and return the defval
1235 instead. Otherwise return the exception unchanged. */
1236 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1244 /* Implement the "has_key" method on the type object. */
1247 typy_has_key (PyObject
*self
, PyObject
*args
)
1249 struct type
*type
= ((type_object
*) self
)->type
;
1253 if (!PyArg_ParseTuple (args
, "s", &field
))
1256 /* We want just fields of this type, not of base types, so instead of
1257 using lookup_struct_elt_type, portions of that function are
1260 type
= typy_get_composite (type
);
1264 for (i
= 0; i
< type
->num_fields (); i
++)
1266 const char *t_field_name
= type
->field (i
).name ();
1268 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1274 /* Make an iterator object to iterate over keys, values, or items. */
1277 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1279 typy_iterator_object
*typy_iter_obj
;
1281 /* Check that "self" is a structure or union type. */
1282 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1285 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1286 &type_iterator_object_type
);
1287 if (typy_iter_obj
== NULL
)
1290 typy_iter_obj
->field
= 0;
1291 typy_iter_obj
->kind
= kind
;
1293 typy_iter_obj
->source
= (type_object
*) self
;
1295 return (PyObject
*) typy_iter_obj
;
1298 /* iteritems() method. */
1301 typy_iteritems (PyObject
*self
, PyObject
*args
)
1303 return typy_make_iter (self
, iter_items
);
1306 /* iterkeys() method. */
1309 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1311 return typy_make_iter (self
, iter_keys
);
1314 /* Iterating over the class, same as iterkeys except for the function
1318 typy_iter (PyObject
*self
)
1320 return typy_make_iter (self
, iter_keys
);
1323 /* itervalues() method. */
1326 typy_itervalues (PyObject
*self
, PyObject
*args
)
1328 return typy_make_iter (self
, iter_values
);
1331 /* Return a reference to the type iterator. */
1334 typy_iterator_iter (PyObject
*self
)
1340 /* Return the next field in the iteration through the list of fields
1344 typy_iterator_iternext (PyObject
*self
)
1346 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1347 struct type
*type
= iter_obj
->source
->type
;
1349 if (iter_obj
->field
< type
->num_fields ())
1351 gdbpy_ref
<> result
= make_fielditem (type
, iter_obj
->field
,
1355 return result
.release ();
1362 typy_iterator_dealloc (PyObject
*obj
)
1364 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1366 Py_DECREF (iter_obj
->source
);
1367 Py_TYPE (obj
)->tp_free (obj
);
1370 /* Create a new Type referring to TYPE. */
1372 type_to_type_object (struct type
*type
)
1374 type_object
*type_obj
;
1378 /* Try not to let stub types leak out to Python. */
1379 if (type
->is_stub ())
1380 type
= check_typedef (type
);
1384 /* Just ignore failures in check_typedef. */
1387 type_obj
= PyObject_New (type_object
, &type_object_type
);
1389 set_type (type_obj
, type
);
1391 return (PyObject
*) type_obj
;
1395 type_object_to_type (PyObject
*obj
)
1397 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1399 return ((type_object
*) obj
)->type
;
1404 /* Implementation of gdb.lookup_type. */
1406 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1408 static const char *keywords
[] = { "name", "block", NULL
};
1409 const char *type_name
= NULL
;
1410 struct type
*type
= NULL
;
1411 PyObject
*block_obj
= NULL
;
1412 const struct block
*block
= NULL
;
1414 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1415 &type_name
, &block_obj
))
1420 block
= block_object_to_block (block_obj
);
1423 PyErr_SetString (PyExc_RuntimeError
,
1424 _("'block' argument must be a Block."));
1429 type
= typy_lookup_typename (type_name
, block
);
1433 return type_to_type_object (type
);
1436 void _initialize_py_type ();
1438 _initialize_py_type ()
1440 typy_objfile_data_key
1441 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1445 gdbpy_initialize_types (void)
1449 if (PyType_Ready (&type_object_type
) < 0)
1451 if (PyType_Ready (&field_object_type
) < 0)
1453 if (PyType_Ready (&type_iterator_object_type
) < 0)
1456 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1458 if (PyModule_AddIntConstant (gdb_module
, pyty_codes
[i
].name
,
1459 pyty_codes
[i
].code
) < 0)
1463 if (gdb_pymodule_addobject (gdb_module
, "Type",
1464 (PyObject
*) &type_object_type
) < 0)
1467 if (gdb_pymodule_addobject (gdb_module
, "TypeIterator",
1468 (PyObject
*) &type_iterator_object_type
) < 0)
1471 return gdb_pymodule_addobject (gdb_module
, "Field",
1472 (PyObject
*) &field_object_type
);
1477 static gdb_PyGetSetDef type_object_getset
[] =
1479 { "alignof", typy_get_alignof
, NULL
,
1480 "The alignment of this type, in bytes.", NULL
},
1481 { "code", typy_get_code
, NULL
,
1482 "The code for this type.", NULL
},
1483 { "dynamic", typy_get_dynamic
, NULL
,
1484 "Whether this type is dynamic.", NULL
},
1485 { "name", typy_get_name
, NULL
,
1486 "The name for this type, or None.", NULL
},
1487 { "sizeof", typy_get_sizeof
, NULL
,
1488 "The size of this type, in bytes.", NULL
},
1489 { "tag", typy_get_tag
, NULL
,
1490 "The tag name for this type, or None.", NULL
},
1491 { "objfile", typy_get_objfile
, NULL
,
1492 "The objfile this type was defined in, or None.", NULL
},
1496 static PyMethodDef type_object_methods
[] =
1498 { "array", typy_array
, METH_VARARGS
,
1499 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1500 Return a type which represents an array of objects of this type.\n\
1501 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1502 If LOW_BOUND is omitted, a value of zero is used." },
1503 { "vector", typy_vector
, METH_VARARGS
,
1504 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1505 Return a type which represents a vector of objects of this type.\n\
1506 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1507 If LOW_BOUND is omitted, a value of zero is used.\n\
1508 Vectors differ from arrays in that if the current language has C-style\n\
1509 arrays, vectors don't decay to a pointer to the first element.\n\
1510 They are first class values." },
1511 { "__contains__", typy_has_key
, METH_VARARGS
,
1512 "T.__contains__(k) -> True if T has a field named k, else False" },
1513 { "const", typy_const
, METH_NOARGS
,
1514 "const () -> Type\n\
1515 Return a const variant of this type." },
1516 { "optimized_out", typy_optimized_out
, METH_NOARGS
,
1517 "optimized_out() -> Value\n\
1518 Return optimized out value of this type." },
1519 { "fields", typy_fields
, METH_NOARGS
,
1520 "fields () -> list\n\
1521 Return a list holding all the fields of this type.\n\
1522 Each field is a gdb.Field object." },
1523 { "get", typy_get
, METH_VARARGS
,
1524 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1525 otherwise returns default, if supplied, or None if not." },
1526 { "has_key", typy_has_key
, METH_VARARGS
,
1527 "T.has_key(k) -> True if T has a field named k, else False" },
1528 { "items", typy_items
, METH_NOARGS
,
1529 "items () -> list\n\
1530 Return a list of (name, field) pairs of this type.\n\
1531 Each field is a gdb.Field object." },
1532 { "iteritems", typy_iteritems
, METH_NOARGS
,
1533 "iteritems () -> an iterator over the (name, field)\n\
1534 pairs of this type. Each field is a gdb.Field object." },
1535 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1536 "iterkeys () -> an iterator over the field names of this type." },
1537 { "itervalues", typy_itervalues
, METH_NOARGS
,
1538 "itervalues () -> an iterator over the fields of this type.\n\
1539 Each field is a gdb.Field object." },
1540 { "keys", typy_field_names
, METH_NOARGS
,
1542 Return a list holding all the fields names of this type." },
1543 { "pointer", typy_pointer
, METH_NOARGS
,
1544 "pointer () -> Type\n\
1545 Return a type of pointer to this type." },
1546 { "range", typy_range
, METH_NOARGS
,
1547 "range () -> tuple\n\
1548 Return a tuple containing the lower and upper range for this type."},
1549 { "reference", typy_reference
, METH_NOARGS
,
1550 "reference () -> Type\n\
1551 Return a type of reference to this type." },
1552 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1553 "strip_typedefs () -> Type\n\
1554 Return a type formed by stripping this type of all typedefs."},
1555 { "target", typy_target
, METH_NOARGS
,
1556 "target () -> Type\n\
1557 Return the target type of this type." },
1558 { "template_argument", typy_template_argument
, METH_VARARGS
,
1559 "template_argument (arg, [block]) -> Type\n\
1560 Return the type of a template argument." },
1561 { "unqualified", typy_unqualified
, METH_NOARGS
,
1562 "unqualified () -> Type\n\
1563 Return a variant of this type without const or volatile attributes." },
1564 { "values", typy_values
, METH_NOARGS
,
1565 "values () -> list\n\
1566 Return a list holding all the fields of this type.\n\
1567 Each field is a gdb.Field object." },
1568 { "volatile", typy_volatile
, METH_NOARGS
,
1569 "volatile () -> Type\n\
1570 Return a volatile variant of this type" },
1574 static PyNumberMethods type_object_as_number
= {
1576 NULL
, /* nb_subtract */
1577 NULL
, /* nb_multiply */
1579 NULL
, /* nb_divide */
1581 NULL
, /* nb_remainder */
1582 NULL
, /* nb_divmod */
1583 NULL
, /* nb_power */
1584 NULL
, /* nb_negative */
1585 NULL
, /* nb_positive */
1586 NULL
, /* nb_absolute */
1587 typy_nonzero
, /* nb_nonzero */
1588 NULL
, /* nb_invert */
1589 NULL
, /* nb_lshift */
1590 NULL
, /* nb_rshift */
1596 NULL
, /* reserved */
1598 NULL
, /* nb_coerce */
1602 NULL
, /* nb_float */
1609 static PyMappingMethods typy_mapping
= {
1612 NULL
/* no "set" method */
1615 PyTypeObject type_object_type
=
1617 PyVarObject_HEAD_INIT (NULL
, 0)
1618 "gdb.Type", /*tp_name*/
1619 sizeof (type_object
), /*tp_basicsize*/
1621 typy_dealloc
, /*tp_dealloc*/
1627 &type_object_as_number
, /*tp_as_number*/
1628 0, /*tp_as_sequence*/
1629 &typy_mapping
, /*tp_as_mapping*/
1632 typy_str
, /*tp_str*/
1636 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
1637 "GDB type object", /* tp_doc */
1638 0, /* tp_traverse */
1640 typy_richcompare
, /* tp_richcompare */
1641 0, /* tp_weaklistoffset */
1642 typy_iter
, /* tp_iter */
1643 0, /* tp_iternext */
1644 type_object_methods
, /* tp_methods */
1646 type_object_getset
, /* tp_getset */
1649 0, /* tp_descr_get */
1650 0, /* tp_descr_set */
1651 0, /* tp_dictoffset */
1657 static gdb_PyGetSetDef field_object_getset
[] =
1659 { "__dict__", gdb_py_generic_dict
, NULL
,
1660 "The __dict__ for this field.", &field_object_type
},
1664 PyTypeObject field_object_type
=
1666 PyVarObject_HEAD_INIT (NULL
, 0)
1667 "gdb.Field", /*tp_name*/
1668 sizeof (field_object
), /*tp_basicsize*/
1670 field_dealloc
, /*tp_dealloc*/
1677 0, /*tp_as_sequence*/
1678 0, /*tp_as_mapping*/
1685 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
1686 "GDB field object", /* tp_doc */
1687 0, /* tp_traverse */
1689 0, /* tp_richcompare */
1690 0, /* tp_weaklistoffset */
1692 0, /* tp_iternext */
1695 field_object_getset
, /* tp_getset */
1698 0, /* tp_descr_get */
1699 0, /* tp_descr_set */
1700 offsetof (field_object
, dict
), /* tp_dictoffset */
1706 PyTypeObject type_iterator_object_type
= {
1707 PyVarObject_HEAD_INIT (NULL
, 0)
1708 "gdb.TypeIterator", /*tp_name*/
1709 sizeof (typy_iterator_object
), /*tp_basicsize*/
1711 typy_iterator_dealloc
, /*tp_dealloc*/
1718 0, /*tp_as_sequence*/
1719 0, /*tp_as_mapping*/
1726 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
1727 "GDB type iterator object", /*tp_doc */
1730 0, /*tp_richcompare */
1731 0, /*tp_weaklistoffset */
1732 typy_iterator_iter
, /*tp_iter */
1733 typy_iterator_iternext
, /*tp_iternext */