1 /* Python interface to types.
3 Copyright (C) 2008-2019 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 "common/vec.h"
30 #include "typeprint.h"
32 typedef struct pyty_type_object
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 pyty_type_object
*prev
;
41 struct pyty_type_object
*next
;
44 extern PyTypeObject type_object_type
45 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("type_object");
48 typedef struct pyty_field_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. */
62 /* The current field index. */
65 enum gdbpy_iter_kind kind
;
66 /* Pointer back to the original source type object. */
67 struct pyty_type_object
*source
;
68 } typy_iterator_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 PyInt_FromLong (TYPE_CODE (type
));
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 (type
, field
)))
183 const char *attrstring
;
185 if (TYPE_CODE (type
) == TYPE_CODE_ENUM
)
187 arg
.reset (gdb_py_long_from_longest (TYPE_FIELD_ENUMVAL (type
,
189 attrstring
= "enumval";
193 arg
.reset (gdb_py_long_from_longest (TYPE_FIELD_BITPOS (type
,
195 attrstring
= "bitpos";
201 if (PyObject_SetAttrString (result
.get (), attrstring
, arg
.get ()) < 0)
206 if (TYPE_FIELD_NAME (type
, field
))
208 const char *field_name
= TYPE_FIELD_NAME (type
, field
);
210 if (field_name
[0] != '\0')
212 arg
.reset (PyString_FromString (TYPE_FIELD_NAME (type
, field
)));
218 arg
= gdbpy_ref
<>::new_reference (Py_None
);
220 if (PyObject_SetAttrString (result
.get (), "name", arg
.get ()) < 0)
223 arg
= gdbpy_ref
<>::new_reference (TYPE_FIELD_ARTIFICIAL (type
, field
)
224 ? Py_True
: Py_False
);
225 if (PyObject_SetAttrString (result
.get (), "artificial", arg
.get ()) < 0)
228 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
229 arg
= gdbpy_ref
<>::new_reference (field
< TYPE_N_BASECLASSES (type
)
230 ? Py_True
: Py_False
);
232 arg
= gdbpy_ref
<>::new_reference (Py_False
);
233 if (PyObject_SetAttrString (result
.get (), "is_base_class", arg
.get ()) < 0)
236 arg
.reset (PyLong_FromLong (TYPE_FIELD_BITSIZE (type
, field
)));
239 if (PyObject_SetAttrString (result
.get (), "bitsize", arg
.get ()) < 0)
242 /* A field can have a NULL type in some situations. */
243 if (TYPE_FIELD_TYPE (type
, field
) == NULL
)
244 arg
= gdbpy_ref
<>::new_reference (Py_None
);
246 arg
.reset (type_to_type_object (TYPE_FIELD_TYPE (type
, field
)));
249 if (PyObject_SetAttrString (result
.get (), "type", arg
.get ()) < 0)
255 /* Helper function to return the name of a field, as a gdb.Field object.
256 If the field doesn't have a name, None is returned. */
259 field_name (struct type
*type
, int field
)
263 if (TYPE_FIELD_NAME (type
, field
))
264 result
.reset (PyString_FromString (TYPE_FIELD_NAME (type
, field
)));
266 result
= gdbpy_ref
<>::new_reference (Py_None
);
271 /* Helper function for Type standard mapping methods. Returns a
272 Python object for field i of the type. "kind" specifies what to
273 return: the name of the field, a gdb.Field object corresponding to
274 the field, or a tuple consisting of field name and gdb.Field
278 make_fielditem (struct type
*type
, int i
, enum gdbpy_iter_kind kind
)
284 gdbpy_ref
<> key (field_name (type
, i
));
287 gdbpy_ref
<> value
= convert_field (type
, i
);
290 gdbpy_ref
<> item (PyTuple_New (2));
293 PyTuple_SET_ITEM (item
.get (), 0, key
.release ());
294 PyTuple_SET_ITEM (item
.get (), 1, value
.release ());
298 return field_name (type
, i
);
300 return convert_field (type
, i
);
302 gdb_assert_not_reached ("invalid gdbpy_iter_kind");
305 /* Return a sequence of all field names, fields, or (name, field) pairs.
306 Each field is a gdb.Field object. */
309 typy_fields_items (PyObject
*self
, enum gdbpy_iter_kind kind
)
311 PyObject
*py_type
= self
;
312 struct type
*type
= ((type_object
*) py_type
)->type
;
313 struct type
*checked_type
= type
;
317 checked_type
= check_typedef (checked_type
);
319 catch (const gdb_exception
&except
)
321 GDB_PY_HANDLE_EXCEPTION (except
);
324 gdbpy_ref
<> type_holder
;
325 if (checked_type
!= type
)
327 type_holder
.reset (type_to_type_object (checked_type
));
328 if (type_holder
== nullptr)
330 py_type
= type_holder
.get ();
332 gdbpy_ref
<> iter (typy_make_iter (py_type
, kind
));
336 return PySequence_List (iter
.get ());
339 /* Return a sequence of all fields. Each field is a gdb.Field object. */
342 typy_values (PyObject
*self
, PyObject
*args
)
344 return typy_fields_items (self
, iter_values
);
347 /* Return a sequence of all fields. Each field is a gdb.Field object.
348 This method is similar to typy_values, except where the supplied
349 gdb.Type is an array, in which case it returns a list of one entry
350 which is a gdb.Field object for a range (the array bounds). */
353 typy_fields (PyObject
*self
, PyObject
*args
)
355 struct type
*type
= ((type_object
*) self
)->type
;
357 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
358 return typy_fields_items (self
, iter_values
);
360 /* Array type. Handle this as a special case because the common
361 machinery wants struct or union or enum types. Build a list of
362 one entry which is the range for the array. */
363 gdbpy_ref
<> r
= convert_field (type
, 0);
367 return Py_BuildValue ("[O]", r
.get ());
370 /* Return a sequence of all field names. Each field is a gdb.Field object. */
373 typy_field_names (PyObject
*self
, PyObject
*args
)
375 return typy_fields_items (self
, iter_keys
);
378 /* Return a sequence of all (name, fields) pairs. Each field is a
382 typy_items (PyObject
*self
, PyObject
*args
)
384 return typy_fields_items (self
, iter_items
);
387 /* Return the type's name, or None. */
390 typy_get_name (PyObject
*self
, void *closure
)
392 struct type
*type
= ((type_object
*) self
)->type
;
394 if (TYPE_NAME (type
) == NULL
)
396 return PyString_FromString (TYPE_NAME (type
));
399 /* Return the type's tag, or None. */
401 typy_get_tag (PyObject
*self
, void *closure
)
403 struct type
*type
= ((type_object
*) self
)->type
;
404 const char *tagname
= nullptr;
406 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
407 || TYPE_CODE (type
) == TYPE_CODE_UNION
408 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
409 tagname
= TYPE_NAME (type
);
411 if (tagname
== nullptr)
413 return PyString_FromString (tagname
);
416 /* Return the type's objfile, or None. */
418 typy_get_objfile (PyObject
*self
, void *closure
)
420 struct type
*type
= ((type_object
*) self
)->type
;
421 struct objfile
*objfile
= TYPE_OBJFILE (type
);
423 if (objfile
== nullptr)
425 return objfile_to_objfile_object (objfile
).release ();
428 /* Return the type, stripped of typedefs. */
430 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
432 struct type
*type
= ((type_object
*) self
)->type
;
436 type
= check_typedef (type
);
438 catch (const gdb_exception
&except
)
440 GDB_PY_HANDLE_EXCEPTION (except
);
443 return type_to_type_object (type
);
446 /* Strip typedefs and pointers/reference from a type. Then check that
447 it is a struct, union, or enum type. If not, raise TypeError. */
450 typy_get_composite (struct type
*type
)
457 type
= check_typedef (type
);
459 catch (const gdb_exception
&except
)
461 GDB_PY_HANDLE_EXCEPTION (except
);
464 if (TYPE_CODE (type
) != TYPE_CODE_PTR
&& !TYPE_IS_REFERENCE (type
))
466 type
= TYPE_TARGET_TYPE (type
);
469 /* If this is not a struct, union, or enum type, raise TypeError
471 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
472 && TYPE_CODE (type
) != TYPE_CODE_UNION
473 && TYPE_CODE (type
) != TYPE_CODE_ENUM
474 && TYPE_CODE (type
) != TYPE_CODE_FUNC
)
476 PyErr_SetString (PyExc_TypeError
,
477 "Type is not a structure, union, enum, or function type.");
484 /* Helper for typy_array and typy_vector. */
487 typy_array_1 (PyObject
*self
, PyObject
*args
, int is_vector
)
490 PyObject
*n2_obj
= NULL
;
491 struct type
*array
= NULL
;
492 struct type
*type
= ((type_object
*) self
)->type
;
494 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
499 if (!PyInt_Check (n2_obj
))
501 PyErr_SetString (PyExc_RuntimeError
,
502 _("Array bound must be an integer"));
506 if (! gdb_py_int_as_long (n2_obj
, &n2
))
515 if (n2
< n1
- 1) /* Note: An empty array has n2 == n1 - 1. */
517 PyErr_SetString (PyExc_ValueError
,
518 _("Array length must not be negative"));
524 array
= lookup_array_range_type (type
, n1
, n2
);
526 make_vector_type (array
);
528 catch (const gdb_exception
&except
)
530 GDB_PY_HANDLE_EXCEPTION (except
);
533 return type_to_type_object (array
);
536 /* Return an array type. */
539 typy_array (PyObject
*self
, PyObject
*args
)
541 return typy_array_1 (self
, args
, 0);
544 /* Return a vector type. */
547 typy_vector (PyObject
*self
, PyObject
*args
)
549 return typy_array_1 (self
, args
, 1);
552 /* Return a Type object which represents a pointer to SELF. */
554 typy_pointer (PyObject
*self
, PyObject
*args
)
556 struct type
*type
= ((type_object
*) self
)->type
;
560 type
= lookup_pointer_type (type
);
562 catch (const gdb_exception
&except
)
564 GDB_PY_HANDLE_EXCEPTION (except
);
567 return type_to_type_object (type
);
570 /* Return the range of a type represented by SELF. The return type is
571 a tuple. The first element of the tuple contains the low bound,
572 while the second element of the tuple contains the high bound. */
574 typy_range (PyObject
*self
, PyObject
*args
)
576 struct type
*type
= ((type_object
*) self
)->type
;
577 /* Initialize these to appease GCC warnings. */
578 LONGEST low
= 0, high
= 0;
580 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
581 && TYPE_CODE (type
) != TYPE_CODE_STRING
582 && TYPE_CODE (type
) != TYPE_CODE_RANGE
)
584 PyErr_SetString (PyExc_RuntimeError
,
585 _("This type does not have a range."));
589 switch (TYPE_CODE (type
))
591 case TYPE_CODE_ARRAY
:
592 case TYPE_CODE_STRING
:
593 low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
594 high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
));
596 case TYPE_CODE_RANGE
:
597 low
= TYPE_LOW_BOUND (type
);
598 high
= TYPE_HIGH_BOUND (type
);
602 gdbpy_ref
<> low_bound (PyLong_FromLong (low
));
603 if (low_bound
== NULL
)
606 gdbpy_ref
<> high_bound (PyLong_FromLong (high
));
607 if (high_bound
== NULL
)
610 gdbpy_ref
<> result (PyTuple_New (2));
614 if (PyTuple_SetItem (result
.get (), 0, low_bound
.release ()) != 0
615 || PyTuple_SetItem (result
.get (), 1, high_bound
.release ()) != 0)
617 return result
.release ();
620 /* Return a Type object which represents a reference to SELF. */
622 typy_reference (PyObject
*self
, PyObject
*args
)
624 struct type
*type
= ((type_object
*) self
)->type
;
628 type
= lookup_lvalue_reference_type (type
);
630 catch (const gdb_exception
&except
)
632 GDB_PY_HANDLE_EXCEPTION (except
);
635 return type_to_type_object (type
);
638 /* Return a Type object which represents the target type of SELF. */
640 typy_target (PyObject
*self
, PyObject
*args
)
642 struct type
*type
= ((type_object
*) self
)->type
;
644 if (!TYPE_TARGET_TYPE (type
))
646 PyErr_SetString (PyExc_RuntimeError
,
647 _("Type does not have a target."));
651 return type_to_type_object (TYPE_TARGET_TYPE (type
));
654 /* Return a const-qualified type variant. */
656 typy_const (PyObject
*self
, PyObject
*args
)
658 struct type
*type
= ((type_object
*) self
)->type
;
662 type
= make_cv_type (1, 0, type
, NULL
);
664 catch (const gdb_exception
&except
)
666 GDB_PY_HANDLE_EXCEPTION (except
);
669 return type_to_type_object (type
);
672 /* Return a volatile-qualified type variant. */
674 typy_volatile (PyObject
*self
, PyObject
*args
)
676 struct type
*type
= ((type_object
*) self
)->type
;
680 type
= make_cv_type (0, 1, type
, NULL
);
682 catch (const gdb_exception
&except
)
684 GDB_PY_HANDLE_EXCEPTION (except
);
687 return type_to_type_object (type
);
690 /* Return an unqualified type variant. */
692 typy_unqualified (PyObject
*self
, PyObject
*args
)
694 struct type
*type
= ((type_object
*) self
)->type
;
698 type
= make_cv_type (0, 0, type
, NULL
);
700 catch (const gdb_exception
&except
)
702 GDB_PY_HANDLE_EXCEPTION (except
);
705 return type_to_type_object (type
);
708 /* Return the size of the type represented by SELF, in bytes. */
710 typy_get_sizeof (PyObject
*self
, void *closure
)
712 struct type
*type
= ((type_object
*) self
)->type
;
716 check_typedef (type
);
718 catch (const gdb_exception
&except
)
722 /* Ignore exceptions. */
724 return gdb_py_long_from_longest (TYPE_LENGTH (type
));
727 /* Return the alignment of the type represented by SELF, in bytes. */
729 typy_get_alignof (PyObject
*self
, void *closure
)
731 struct type
*type
= ((type_object
*) self
)->type
;
736 align
= type_align (type
);
738 catch (const gdb_exception
&except
)
743 /* Ignore exceptions. */
745 return gdb_py_object_from_ulongest (align
).release ();
749 typy_lookup_typename (const char *type_name
, const struct block
*block
)
751 struct type
*type
= NULL
;
755 if (startswith (type_name
, "struct "))
756 type
= lookup_struct (type_name
+ 7, NULL
);
757 else if (startswith (type_name
, "union "))
758 type
= lookup_union (type_name
+ 6, NULL
);
759 else if (startswith (type_name
, "enum "))
760 type
= lookup_enum (type_name
+ 5, NULL
);
762 type
= lookup_typename (python_language
, python_gdbarch
,
763 type_name
, block
, 0);
765 catch (const gdb_exception
&except
)
767 GDB_PY_HANDLE_EXCEPTION (except
);
774 typy_lookup_type (struct demangle_component
*demangled
,
775 const struct block
*block
)
777 struct type
*type
, *rtype
= NULL
;
778 enum demangle_component_type demangled_type
;
780 /* Save the type: typy_lookup_type() may (indirectly) overwrite
781 memory pointed by demangled. */
782 demangled_type
= demangled
->type
;
784 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
785 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
786 || demangled_type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE
787 || demangled_type
== DEMANGLE_COMPONENT_CONST
788 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
790 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
796 /* If the demangled_type matches with one of the types
797 below, run the corresponding function and save the type
798 to return later. We cannot just return here as we are in
799 an exception handler. */
800 switch (demangled_type
)
802 case DEMANGLE_COMPONENT_REFERENCE
:
803 rtype
= lookup_lvalue_reference_type (type
);
805 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
806 rtype
= lookup_rvalue_reference_type (type
);
808 case DEMANGLE_COMPONENT_POINTER
:
809 rtype
= lookup_pointer_type (type
);
811 case DEMANGLE_COMPONENT_CONST
:
812 rtype
= make_cv_type (1, 0, type
, NULL
);
814 case DEMANGLE_COMPONENT_VOLATILE
:
815 rtype
= make_cv_type (0, 1, type
, NULL
);
819 catch (const gdb_exception
&except
)
821 GDB_PY_HANDLE_EXCEPTION (except
);
825 /* If we have a type from the switch statement above, just return
830 /* We don't have a type, so lookup the type. */
831 gdb::unique_xmalloc_ptr
<char> type_name
= cp_comp_to_string (demangled
, 10);
832 return typy_lookup_typename (type_name
.get (), block
);
835 /* This is a helper function for typy_template_argument that is used
836 when the type does not have template symbols attached. It works by
837 parsing the type name. This happens with compilers, like older
838 versions of GCC, that do not emit DW_TAG_template_*. */
841 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
845 struct demangle_component
*demangled
;
846 std::unique_ptr
<demangle_parse_info
> info
;
848 struct type
*argtype
;
850 if (TYPE_NAME (type
) == NULL
)
852 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
858 /* Note -- this is not thread-safe. */
859 info
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
861 catch (const gdb_exception
&except
)
863 GDB_PY_HANDLE_EXCEPTION (except
);
868 PyErr_SetString (PyExc_RuntimeError
, err
.c_str ());
871 demangled
= info
->tree
;
873 /* Strip off component names. */
874 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
875 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
876 demangled
= demangled
->u
.s_binary
.right
;
878 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
880 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
884 /* Skip from the template to the arguments. */
885 demangled
= demangled
->u
.s_binary
.right
;
887 for (i
= 0; demangled
&& i
< argno
; ++i
)
888 demangled
= demangled
->u
.s_binary
.right
;
892 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
897 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
901 return type_to_type_object (argtype
);
905 typy_template_argument (PyObject
*self
, PyObject
*args
)
908 struct type
*type
= ((type_object
*) self
)->type
;
909 const struct block
*block
= NULL
;
910 PyObject
*block_obj
= NULL
;
912 struct value
*val
= NULL
;
914 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
919 PyErr_SetString (PyExc_RuntimeError
,
920 _("Template argument number must be non-negative"));
926 block
= block_object_to_block (block_obj
);
929 PyErr_SetString (PyExc_RuntimeError
,
930 _("Second argument must be block."));
937 type
= check_typedef (type
);
938 if (TYPE_IS_REFERENCE (type
))
939 type
= check_typedef (TYPE_TARGET_TYPE (type
));
941 catch (const gdb_exception
&except
)
943 GDB_PY_HANDLE_EXCEPTION (except
);
946 /* We might not have DW_TAG_template_*, so try to parse the type's
947 name. This is inefficient if we do not have a template type --
948 but that is going to wind up as an error anyhow. */
949 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
950 return typy_legacy_template_argument (type
, block
, argno
);
952 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
954 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
959 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
960 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
961 return type_to_type_object (SYMBOL_TYPE (sym
));
962 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
964 PyErr_Format (PyExc_RuntimeError
,
965 _("Template argument is optimized out"));
971 val
= value_of_variable (sym
, block
);
973 catch (const gdb_exception
&except
)
975 GDB_PY_HANDLE_EXCEPTION (except
);
978 return value_to_value_object (val
);
982 typy_str (PyObject
*self
)
988 LA_PRINT_TYPE (type_object_to_type (self
), "", &thetype
, -1, 0,
989 &type_print_raw_options
);
991 catch (const gdb_exception
&except
)
993 GDB_PY_HANDLE_EXCEPTION (except
);
996 return PyUnicode_Decode (thetype
.c_str (), thetype
.size (),
997 host_charset (), NULL
);
1000 /* Implement the richcompare method. */
1003 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1005 bool result
= false;
1006 struct type
*type1
= type_object_to_type (self
);
1007 struct type
*type2
= type_object_to_type (other
);
1009 /* We can only compare ourselves to another Type object, and only
1010 for equality or inequality. */
1011 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
1013 Py_INCREF (Py_NotImplemented
);
1014 return Py_NotImplemented
;
1023 result
= types_deeply_equal (type1
, type2
);
1025 catch (const gdb_exception
&except
)
1027 /* If there is a GDB exception, a comparison is not capable
1028 (or trusted), so exit. */
1029 GDB_PY_HANDLE_EXCEPTION (except
);
1033 if (op
== (result
? Py_EQ
: Py_NE
))
1040 static const struct objfile_data
*typy_objfile_data_key
;
1043 save_objfile_types (struct objfile
*objfile
, void *datum
)
1045 type_object
*obj
= (type_object
*) datum
;
1046 htab_t copied_types
;
1048 if (!gdb_python_initialized
)
1051 /* This prevents another thread from freeing the objects we're
1053 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1055 copied_types
= create_copied_types_hash (objfile
);
1059 type_object
*next
= obj
->next
;
1061 htab_empty (copied_types
);
1063 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1071 htab_delete (copied_types
);
1075 set_type (type_object
*obj
, struct type
*type
)
1079 if (type
&& TYPE_OBJFILE (type
))
1081 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1083 obj
->next
= ((struct pyty_type_object
*)
1084 objfile_data (objfile
, typy_objfile_data_key
));
1086 obj
->next
->prev
= obj
;
1087 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1094 typy_dealloc (PyObject
*obj
)
1096 type_object
*type
= (type_object
*) obj
;
1099 type
->prev
->next
= type
->next
;
1100 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1102 /* Must reset head of list. */
1103 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1106 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1109 type
->next
->prev
= type
->prev
;
1111 Py_TYPE (type
)->tp_free (type
);
1114 /* Return number of fields ("length" of the field dictionary). */
1117 typy_length (PyObject
*self
)
1119 struct type
*type
= ((type_object
*) self
)->type
;
1121 type
= typy_get_composite (type
);
1125 return TYPE_NFIELDS (type
);
1128 /* Implements boolean evaluation of gdb.Type. Handle this like other
1129 Python objects that don't have a meaningful truth value -- all
1133 typy_nonzero (PyObject
*self
)
1138 /* Return optimized out value of this type. */
1141 typy_optimized_out (PyObject
*self
, PyObject
*args
)
1143 struct type
*type
= ((type_object
*) self
)->type
;
1145 return value_to_value_object (allocate_optimized_out_value (type
));
1148 /* Return a gdb.Field object for the field named by the argument. */
1151 typy_getitem (PyObject
*self
, PyObject
*key
)
1153 struct type
*type
= ((type_object
*) self
)->type
;
1156 gdb::unique_xmalloc_ptr
<char> field
= python_string_to_host_string (key
);
1160 /* We want just fields of this type, not of base types, so instead of
1161 using lookup_struct_elt_type, portions of that function are
1164 type
= typy_get_composite (type
);
1168 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1170 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1172 if (t_field_name
&& (strcmp_iw (t_field_name
, field
.get ()) == 0))
1173 return convert_field (type
, i
).release ();
1175 PyErr_SetObject (PyExc_KeyError
, key
);
1179 /* Implement the "get" method on the type object. This is the
1180 same as getitem if the key is present, but returns the supplied
1181 default value or None if the key is not found. */
1184 typy_get (PyObject
*self
, PyObject
*args
)
1186 PyObject
*key
, *defval
= Py_None
, *result
;
1188 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1191 result
= typy_getitem (self
, key
);
1195 /* typy_getitem returned error status. If the exception is
1196 KeyError, clear the exception status and return the defval
1197 instead. Otherwise return the exception unchanged. */
1198 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1206 /* Implement the "has_key" method on the type object. */
1209 typy_has_key (PyObject
*self
, PyObject
*args
)
1211 struct type
*type
= ((type_object
*) self
)->type
;
1215 if (!PyArg_ParseTuple (args
, "s", &field
))
1218 /* We want just fields of this type, not of base types, so instead of
1219 using lookup_struct_elt_type, portions of that function are
1222 type
= typy_get_composite (type
);
1226 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1228 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1230 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1236 /* Make an iterator object to iterate over keys, values, or items. */
1239 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1241 typy_iterator_object
*typy_iter_obj
;
1243 /* Check that "self" is a structure or union type. */
1244 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1247 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1248 &type_iterator_object_type
);
1249 if (typy_iter_obj
== NULL
)
1252 typy_iter_obj
->field
= 0;
1253 typy_iter_obj
->kind
= kind
;
1255 typy_iter_obj
->source
= (type_object
*) self
;
1257 return (PyObject
*) typy_iter_obj
;
1260 /* iteritems() method. */
1263 typy_iteritems (PyObject
*self
, PyObject
*args
)
1265 return typy_make_iter (self
, iter_items
);
1268 /* iterkeys() method. */
1271 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1273 return typy_make_iter (self
, iter_keys
);
1276 /* Iterating over the class, same as iterkeys except for the function
1280 typy_iter (PyObject
*self
)
1282 return typy_make_iter (self
, iter_keys
);
1285 /* itervalues() method. */
1288 typy_itervalues (PyObject
*self
, PyObject
*args
)
1290 return typy_make_iter (self
, iter_values
);
1293 /* Return a reference to the type iterator. */
1296 typy_iterator_iter (PyObject
*self
)
1302 /* Return the next field in the iteration through the list of fields
1306 typy_iterator_iternext (PyObject
*self
)
1308 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1309 struct type
*type
= iter_obj
->source
->type
;
1311 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1313 gdbpy_ref
<> result
= make_fielditem (type
, iter_obj
->field
,
1317 return result
.release ();
1324 typy_iterator_dealloc (PyObject
*obj
)
1326 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1328 Py_DECREF (iter_obj
->source
);
1331 /* Create a new Type referring to TYPE. */
1333 type_to_type_object (struct type
*type
)
1335 type_object
*type_obj
;
1337 type_obj
= PyObject_New (type_object
, &type_object_type
);
1339 set_type (type_obj
, type
);
1341 return (PyObject
*) type_obj
;
1345 type_object_to_type (PyObject
*obj
)
1347 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1349 return ((type_object
*) obj
)->type
;
1354 /* Implementation of gdb.lookup_type. */
1356 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1358 static const char *keywords
[] = { "name", "block", NULL
};
1359 const char *type_name
= NULL
;
1360 struct type
*type
= NULL
;
1361 PyObject
*block_obj
= NULL
;
1362 const struct block
*block
= NULL
;
1364 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1365 &type_name
, &block_obj
))
1370 block
= block_object_to_block (block_obj
);
1373 PyErr_SetString (PyExc_RuntimeError
,
1374 _("'block' argument must be a Block."));
1379 type
= typy_lookup_typename (type_name
, block
);
1383 return type_to_type_object (type
);
1387 gdbpy_initialize_types (void)
1391 typy_objfile_data_key
1392 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1394 if (PyType_Ready (&type_object_type
) < 0)
1396 if (PyType_Ready (&field_object_type
) < 0)
1398 if (PyType_Ready (&type_iterator_object_type
) < 0)
1401 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1403 if (PyModule_AddIntConstant (gdb_module
, pyty_codes
[i
].name
,
1404 pyty_codes
[i
].code
) < 0)
1408 if (gdb_pymodule_addobject (gdb_module
, "Type",
1409 (PyObject
*) &type_object_type
) < 0)
1412 if (gdb_pymodule_addobject (gdb_module
, "TypeIterator",
1413 (PyObject
*) &type_iterator_object_type
) < 0)
1416 return gdb_pymodule_addobject (gdb_module
, "Field",
1417 (PyObject
*) &field_object_type
);
1422 static gdb_PyGetSetDef type_object_getset
[] =
1424 { "alignof", typy_get_alignof
, NULL
,
1425 "The alignment of this type, in bytes.", NULL
},
1426 { "code", typy_get_code
, NULL
,
1427 "The code for this type.", NULL
},
1428 { "name", typy_get_name
, NULL
,
1429 "The name for this type, or None.", NULL
},
1430 { "sizeof", typy_get_sizeof
, NULL
,
1431 "The size of this type, in bytes.", NULL
},
1432 { "tag", typy_get_tag
, NULL
,
1433 "The tag name for this type, or None.", NULL
},
1434 { "objfile", typy_get_objfile
, NULL
,
1435 "The objfile this type was defined in, or None.", NULL
},
1439 static PyMethodDef type_object_methods
[] =
1441 { "array", typy_array
, METH_VARARGS
,
1442 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1443 Return a type which represents an array of objects of this type.\n\
1444 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1445 If LOW_BOUND is omitted, a value of zero is used." },
1446 { "vector", typy_vector
, METH_VARARGS
,
1447 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1448 Return a type which represents a vector of objects of this type.\n\
1449 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1450 If LOW_BOUND is omitted, a value of zero is used.\n\
1451 Vectors differ from arrays in that if the current language has C-style\n\
1452 arrays, vectors don't decay to a pointer to the first element.\n\
1453 They are first class values." },
1454 { "__contains__", typy_has_key
, METH_VARARGS
,
1455 "T.__contains__(k) -> True if T has a field named k, else False" },
1456 { "const", typy_const
, METH_NOARGS
,
1457 "const () -> Type\n\
1458 Return a const variant of this type." },
1459 { "optimized_out", typy_optimized_out
, METH_NOARGS
,
1460 "optimized_out() -> Value\n\
1461 Return optimized out value of this type." },
1462 { "fields", typy_fields
, METH_NOARGS
,
1463 "fields () -> list\n\
1464 Return a list holding all the fields of this type.\n\
1465 Each field is a gdb.Field object." },
1466 { "get", typy_get
, METH_VARARGS
,
1467 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1468 otherwise returns default, if supplied, or None if not." },
1469 { "has_key", typy_has_key
, METH_VARARGS
,
1470 "T.has_key(k) -> True if T has a field named k, else False" },
1471 { "items", typy_items
, METH_NOARGS
,
1472 "items () -> list\n\
1473 Return a list of (name, field) pairs of this type.\n\
1474 Each field is a gdb.Field object." },
1475 { "iteritems", typy_iteritems
, METH_NOARGS
,
1476 "iteritems () -> an iterator over the (name, field)\n\
1477 pairs of this type. Each field is a gdb.Field object." },
1478 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1479 "iterkeys () -> an iterator over the field names of this type." },
1480 { "itervalues", typy_itervalues
, METH_NOARGS
,
1481 "itervalues () -> an iterator over the fields of this type.\n\
1482 Each field is a gdb.Field object." },
1483 { "keys", typy_field_names
, METH_NOARGS
,
1485 Return a list holding all the fields names of this type." },
1486 { "pointer", typy_pointer
, METH_NOARGS
,
1487 "pointer () -> Type\n\
1488 Return a type of pointer to this type." },
1489 { "range", typy_range
, METH_NOARGS
,
1490 "range () -> tuple\n\
1491 Return a tuple containing the lower and upper range for this type."},
1492 { "reference", typy_reference
, METH_NOARGS
,
1493 "reference () -> Type\n\
1494 Return a type of reference to this type." },
1495 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1496 "strip_typedefs () -> Type\n\
1497 Return a type formed by stripping this type of all typedefs."},
1498 { "target", typy_target
, METH_NOARGS
,
1499 "target () -> Type\n\
1500 Return the target type of this type." },
1501 { "template_argument", typy_template_argument
, METH_VARARGS
,
1502 "template_argument (arg, [block]) -> Type\n\
1503 Return the type of a template argument." },
1504 { "unqualified", typy_unqualified
, METH_NOARGS
,
1505 "unqualified () -> Type\n\
1506 Return a variant of this type without const or volatile attributes." },
1507 { "values", typy_values
, METH_NOARGS
,
1508 "values () -> list\n\
1509 Return a list holding all the fields of this type.\n\
1510 Each field is a gdb.Field object." },
1511 { "volatile", typy_volatile
, METH_NOARGS
,
1512 "volatile () -> Type\n\
1513 Return a volatile variant of this type" },
1517 static PyNumberMethods type_object_as_number
= {
1519 NULL
, /* nb_subtract */
1520 NULL
, /* nb_multiply */
1522 NULL
, /* nb_divide */
1524 NULL
, /* nb_remainder */
1525 NULL
, /* nb_divmod */
1526 NULL
, /* nb_power */
1527 NULL
, /* nb_negative */
1528 NULL
, /* nb_positive */
1529 NULL
, /* nb_absolute */
1530 typy_nonzero
, /* nb_nonzero */
1531 NULL
, /* nb_invert */
1532 NULL
, /* nb_lshift */
1533 NULL
, /* nb_rshift */
1539 NULL
, /* reserved */
1541 NULL
, /* nb_coerce */
1545 NULL
, /* nb_float */
1552 static PyMappingMethods typy_mapping
= {
1555 NULL
/* no "set" method */
1558 PyTypeObject type_object_type
=
1560 PyVarObject_HEAD_INIT (NULL
, 0)
1561 "gdb.Type", /*tp_name*/
1562 sizeof (type_object
), /*tp_basicsize*/
1564 typy_dealloc
, /*tp_dealloc*/
1570 &type_object_as_number
, /*tp_as_number*/
1571 0, /*tp_as_sequence*/
1572 &typy_mapping
, /*tp_as_mapping*/
1575 typy_str
, /*tp_str*/
1579 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1580 "GDB type object", /* tp_doc */
1581 0, /* tp_traverse */
1583 typy_richcompare
, /* tp_richcompare */
1584 0, /* tp_weaklistoffset */
1585 typy_iter
, /* tp_iter */
1586 0, /* tp_iternext */
1587 type_object_methods
, /* tp_methods */
1589 type_object_getset
, /* tp_getset */
1592 0, /* tp_descr_get */
1593 0, /* tp_descr_set */
1594 0, /* tp_dictoffset */
1600 static gdb_PyGetSetDef field_object_getset
[] =
1602 { "__dict__", gdb_py_generic_dict
, NULL
,
1603 "The __dict__ for this field.", &field_object_type
},
1607 PyTypeObject field_object_type
=
1609 PyVarObject_HEAD_INIT (NULL
, 0)
1610 "gdb.Field", /*tp_name*/
1611 sizeof (field_object
), /*tp_basicsize*/
1613 field_dealloc
, /*tp_dealloc*/
1620 0, /*tp_as_sequence*/
1621 0, /*tp_as_mapping*/
1628 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1629 "GDB field object", /* tp_doc */
1630 0, /* tp_traverse */
1632 0, /* tp_richcompare */
1633 0, /* tp_weaklistoffset */
1635 0, /* tp_iternext */
1638 field_object_getset
, /* tp_getset */
1641 0, /* tp_descr_get */
1642 0, /* tp_descr_set */
1643 offsetof (field_object
, dict
), /* tp_dictoffset */
1649 PyTypeObject type_iterator_object_type
= {
1650 PyVarObject_HEAD_INIT (NULL
, 0)
1651 "gdb.TypeIterator", /*tp_name*/
1652 sizeof (typy_iterator_object
), /*tp_basicsize*/
1654 typy_iterator_dealloc
, /*tp_dealloc*/
1661 0, /*tp_as_sequence*/
1662 0, /*tp_as_mapping*/
1669 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1670 "GDB type iterator object", /*tp_doc */
1673 0, /*tp_richcompare */
1674 0, /*tp_weaklistoffset */
1675 typy_iterator_iter
, /*tp_iter */
1676 typy_iterator_iternext
, /*tp_iternext */