1 /* Python interface to types.
3 Copyright (C) 2008-2020 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"
31 typedef struct pyty_type_object
36 /* If a Type object is associated with an objfile, it is kept on a
37 doubly-linked list, rooted in the objfile. This lets us copy the
38 underlying struct type when the objfile is deleted. */
39 struct pyty_type_object
*prev
;
40 struct pyty_type_object
*next
;
43 extern PyTypeObject type_object_type
44 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("type_object");
47 typedef struct pyty_field_object
51 /* Dictionary holding our attributes. */
55 extern PyTypeObject field_object_type
56 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("field_object");
58 /* A type iterator object. */
61 /* The current field index. */
64 enum gdbpy_iter_kind kind
;
65 /* Pointer back to the original source type object. */
66 struct pyty_type_object
*source
;
67 } typy_iterator_object
;
69 extern PyTypeObject type_iterator_object_type
70 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("typy_iterator_object");
72 /* This is used to initialize various gdb.TYPE_ constants. */
81 /* Forward declarations. */
82 static PyObject
*typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
);
84 #define ENTRY(X) { X, #X }
86 static struct pyty_code pyty_codes
[] =
88 ENTRY (TYPE_CODE_BITSTRING
),
89 ENTRY (TYPE_CODE_PTR
),
90 ENTRY (TYPE_CODE_ARRAY
),
91 ENTRY (TYPE_CODE_STRUCT
),
92 ENTRY (TYPE_CODE_UNION
),
93 ENTRY (TYPE_CODE_ENUM
),
94 ENTRY (TYPE_CODE_FLAGS
),
95 ENTRY (TYPE_CODE_FUNC
),
96 ENTRY (TYPE_CODE_INT
),
97 ENTRY (TYPE_CODE_FLT
),
98 ENTRY (TYPE_CODE_VOID
),
99 ENTRY (TYPE_CODE_SET
),
100 ENTRY (TYPE_CODE_RANGE
),
101 ENTRY (TYPE_CODE_STRING
),
102 ENTRY (TYPE_CODE_ERROR
),
103 ENTRY (TYPE_CODE_METHOD
),
104 ENTRY (TYPE_CODE_METHODPTR
),
105 ENTRY (TYPE_CODE_MEMBERPTR
),
106 ENTRY (TYPE_CODE_REF
),
107 ENTRY (TYPE_CODE_RVALUE_REF
),
108 ENTRY (TYPE_CODE_CHAR
),
109 ENTRY (TYPE_CODE_BOOL
),
110 ENTRY (TYPE_CODE_COMPLEX
),
111 ENTRY (TYPE_CODE_TYPEDEF
),
112 ENTRY (TYPE_CODE_NAMESPACE
),
113 ENTRY (TYPE_CODE_DECFLOAT
),
114 ENTRY (TYPE_CODE_INTERNAL_FUNCTION
),
115 { TYPE_CODE_UNDEF
, NULL
}
121 field_dealloc (PyObject
*obj
)
123 field_object
*f
= (field_object
*) obj
;
125 Py_XDECREF (f
->dict
);
126 Py_TYPE (obj
)->tp_free (obj
);
132 gdbpy_ref
<field_object
> result (PyObject_New (field_object
,
133 &field_object_type
));
137 result
->dict
= PyDict_New ();
141 return (PyObject
*) result
.release ();
146 /* Return true if OBJ is of type gdb.Field, false otherwise. */
149 gdbpy_is_field (PyObject
*obj
)
151 return PyObject_TypeCheck (obj
, &field_object_type
);
154 /* Return the code for this type. */
156 typy_get_code (PyObject
*self
, void *closure
)
158 struct type
*type
= ((type_object
*) self
)->type
;
160 return PyInt_FromLong (type
->code ());
163 /* Helper function for typy_fields which converts a single field to a
164 gdb.Field object. Returns NULL on error. */
167 convert_field (struct type
*type
, int field
)
169 gdbpy_ref
<> result (field_new ());
174 gdbpy_ref
<> arg (type_to_type_object (type
));
177 if (PyObject_SetAttrString (result
.get (), "parent_type", arg
.get ()) < 0)
180 if (!field_is_static (&TYPE_FIELD (type
, field
)))
182 const char *attrstring
;
184 if (type
->code () == TYPE_CODE_ENUM
)
186 arg
.reset (gdb_py_long_from_longest (TYPE_FIELD_ENUMVAL (type
,
188 attrstring
= "enumval";
192 if (TYPE_FIELD_LOC_KIND (type
, field
) == FIELD_LOC_KIND_DWARF_BLOCK
)
193 arg
= gdbpy_ref
<>::new_reference (Py_None
);
195 arg
.reset (gdb_py_long_from_longest (TYPE_FIELD_BITPOS (type
,
197 attrstring
= "bitpos";
203 if (PyObject_SetAttrString (result
.get (), attrstring
, arg
.get ()) < 0)
208 if (TYPE_FIELD_NAME (type
, field
))
210 const char *field_name
= TYPE_FIELD_NAME (type
, field
);
212 if (field_name
[0] != '\0')
214 arg
.reset (PyString_FromString (TYPE_FIELD_NAME (type
, field
)));
220 arg
= gdbpy_ref
<>::new_reference (Py_None
);
222 if (PyObject_SetAttrString (result
.get (), "name", arg
.get ()) < 0)
225 arg
= gdbpy_ref
<>::new_reference (TYPE_FIELD_ARTIFICIAL (type
, field
)
226 ? Py_True
: Py_False
);
227 if (PyObject_SetAttrString (result
.get (), "artificial", arg
.get ()) < 0)
230 if (type
->code () == TYPE_CODE_STRUCT
)
231 arg
= gdbpy_ref
<>::new_reference (field
< TYPE_N_BASECLASSES (type
)
232 ? Py_True
: Py_False
);
234 arg
= gdbpy_ref
<>::new_reference (Py_False
);
235 if (PyObject_SetAttrString (result
.get (), "is_base_class", arg
.get ()) < 0)
238 arg
.reset (PyLong_FromLong (TYPE_FIELD_BITSIZE (type
, field
)));
241 if (PyObject_SetAttrString (result
.get (), "bitsize", arg
.get ()) < 0)
244 /* A field can have a NULL type in some situations. */
245 if (TYPE_FIELD_TYPE (type
, field
) == NULL
)
246 arg
= gdbpy_ref
<>::new_reference (Py_None
);
248 arg
.reset (type_to_type_object (TYPE_FIELD_TYPE (type
, field
)));
251 if (PyObject_SetAttrString (result
.get (), "type", arg
.get ()) < 0)
257 /* Helper function to return the name of a field, as a gdb.Field object.
258 If the field doesn't have a name, None is returned. */
261 field_name (struct type
*type
, int field
)
265 if (TYPE_FIELD_NAME (type
, field
))
266 result
.reset (PyString_FromString (TYPE_FIELD_NAME (type
, field
)));
268 result
= gdbpy_ref
<>::new_reference (Py_None
);
273 /* Helper function for Type standard mapping methods. Returns a
274 Python object for field i of the type. "kind" specifies what to
275 return: the name of the field, a gdb.Field object corresponding to
276 the field, or a tuple consisting of field name and gdb.Field
280 make_fielditem (struct type
*type
, int i
, enum gdbpy_iter_kind kind
)
286 gdbpy_ref
<> key (field_name (type
, i
));
289 gdbpy_ref
<> value
= convert_field (type
, i
);
292 gdbpy_ref
<> item (PyTuple_New (2));
295 PyTuple_SET_ITEM (item
.get (), 0, key
.release ());
296 PyTuple_SET_ITEM (item
.get (), 1, value
.release ());
300 return field_name (type
, i
);
302 return convert_field (type
, i
);
304 gdb_assert_not_reached ("invalid gdbpy_iter_kind");
307 /* Return a sequence of all field names, fields, or (name, field) pairs.
308 Each field is a gdb.Field object. */
311 typy_fields_items (PyObject
*self
, enum gdbpy_iter_kind kind
)
313 PyObject
*py_type
= self
;
314 struct type
*type
= ((type_object
*) py_type
)->type
;
315 struct type
*checked_type
= type
;
319 checked_type
= check_typedef (checked_type
);
321 catch (const gdb_exception
&except
)
323 GDB_PY_HANDLE_EXCEPTION (except
);
326 gdbpy_ref
<> type_holder
;
327 if (checked_type
!= type
)
329 type_holder
.reset (type_to_type_object (checked_type
));
330 if (type_holder
== nullptr)
332 py_type
= type_holder
.get ();
334 gdbpy_ref
<> iter (typy_make_iter (py_type
, kind
));
338 return PySequence_List (iter
.get ());
341 /* Return a sequence of all fields. Each field is a gdb.Field object. */
344 typy_values (PyObject
*self
, PyObject
*args
)
346 return typy_fields_items (self
, iter_values
);
349 /* Return a sequence of all fields. Each field is a gdb.Field object.
350 This method is similar to typy_values, except where the supplied
351 gdb.Type is an array, in which case it returns a list of one entry
352 which is a gdb.Field object for a range (the array bounds). */
355 typy_fields (PyObject
*self
, PyObject
*args
)
357 struct type
*type
= ((type_object
*) self
)->type
;
359 if (type
->code () != TYPE_CODE_ARRAY
)
360 return typy_fields_items (self
, iter_values
);
362 /* Array type. Handle this as a special case because the common
363 machinery wants struct or union or enum types. Build a list of
364 one entry which is the range for the array. */
365 gdbpy_ref
<> r
= convert_field (type
, 0);
369 return Py_BuildValue ("[O]", r
.get ());
372 /* Return a sequence of all field names. Each field is a gdb.Field object. */
375 typy_field_names (PyObject
*self
, PyObject
*args
)
377 return typy_fields_items (self
, iter_keys
);
380 /* Return a sequence of all (name, fields) pairs. Each field is a
384 typy_items (PyObject
*self
, PyObject
*args
)
386 return typy_fields_items (self
, iter_items
);
389 /* Return the type's name, or None. */
392 typy_get_name (PyObject
*self
, void *closure
)
394 struct type
*type
= ((type_object
*) self
)->type
;
396 if (TYPE_NAME (type
) == NULL
)
398 return PyString_FromString (TYPE_NAME (type
));
401 /* Return the type's tag, or None. */
403 typy_get_tag (PyObject
*self
, void *closure
)
405 struct type
*type
= ((type_object
*) self
)->type
;
406 const char *tagname
= nullptr;
408 if (type
->code () == TYPE_CODE_STRUCT
409 || type
->code () == TYPE_CODE_UNION
410 || type
->code () == TYPE_CODE_ENUM
)
411 tagname
= TYPE_NAME (type
);
413 if (tagname
== nullptr)
415 return PyString_FromString (tagname
);
418 /* Return the type's objfile, or None. */
420 typy_get_objfile (PyObject
*self
, void *closure
)
422 struct type
*type
= ((type_object
*) self
)->type
;
423 struct objfile
*objfile
= TYPE_OBJFILE (type
);
425 if (objfile
== nullptr)
427 return objfile_to_objfile_object (objfile
).release ();
430 /* Return the type, stripped of typedefs. */
432 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
434 struct type
*type
= ((type_object
*) self
)->type
;
438 type
= check_typedef (type
);
440 catch (const gdb_exception
&except
)
442 GDB_PY_HANDLE_EXCEPTION (except
);
445 return type_to_type_object (type
);
448 /* Strip typedefs and pointers/reference from a type. Then check that
449 it is a struct, union, or enum type. If not, raise TypeError. */
452 typy_get_composite (struct type
*type
)
459 type
= check_typedef (type
);
461 catch (const gdb_exception
&except
)
463 GDB_PY_HANDLE_EXCEPTION (except
);
466 if (type
->code () != TYPE_CODE_PTR
&& !TYPE_IS_REFERENCE (type
))
468 type
= TYPE_TARGET_TYPE (type
);
471 /* If this is not a struct, union, or enum type, raise TypeError
473 if (type
->code () != TYPE_CODE_STRUCT
474 && type
->code () != TYPE_CODE_UNION
475 && type
->code () != TYPE_CODE_ENUM
476 && type
->code () != TYPE_CODE_FUNC
)
478 PyErr_SetString (PyExc_TypeError
,
479 "Type is not a structure, union, enum, or function type.");
486 /* Helper for typy_array and typy_vector. */
489 typy_array_1 (PyObject
*self
, PyObject
*args
, int is_vector
)
492 PyObject
*n2_obj
= NULL
;
493 struct type
*array
= NULL
;
494 struct type
*type
= ((type_object
*) self
)->type
;
496 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
501 if (!PyInt_Check (n2_obj
))
503 PyErr_SetString (PyExc_RuntimeError
,
504 _("Array bound must be an integer"));
508 if (! gdb_py_int_as_long (n2_obj
, &n2
))
517 if (n2
< n1
- 1) /* Note: An empty array has n2 == n1 - 1. */
519 PyErr_SetString (PyExc_ValueError
,
520 _("Array length must not be negative"));
526 array
= lookup_array_range_type (type
, n1
, n2
);
528 make_vector_type (array
);
530 catch (const gdb_exception
&except
)
532 GDB_PY_HANDLE_EXCEPTION (except
);
535 return type_to_type_object (array
);
538 /* Return an array type. */
541 typy_array (PyObject
*self
, PyObject
*args
)
543 return typy_array_1 (self
, args
, 0);
546 /* Return a vector type. */
549 typy_vector (PyObject
*self
, PyObject
*args
)
551 return typy_array_1 (self
, args
, 1);
554 /* Return a Type object which represents a pointer to SELF. */
556 typy_pointer (PyObject
*self
, PyObject
*args
)
558 struct type
*type
= ((type_object
*) self
)->type
;
562 type
= lookup_pointer_type (type
);
564 catch (const gdb_exception
&except
)
566 GDB_PY_HANDLE_EXCEPTION (except
);
569 return type_to_type_object (type
);
572 /* Return the range of a type represented by SELF. The return type is
573 a tuple. The first element of the tuple contains the low bound,
574 while the second element of the tuple contains the high bound. */
576 typy_range (PyObject
*self
, PyObject
*args
)
578 struct type
*type
= ((type_object
*) self
)->type
;
579 /* Initialize these to appease GCC warnings. */
580 LONGEST low
= 0, high
= 0;
582 if (type
->code () != TYPE_CODE_ARRAY
583 && type
->code () != TYPE_CODE_STRING
584 && type
->code () != TYPE_CODE_RANGE
)
586 PyErr_SetString (PyExc_RuntimeError
,
587 _("This type does not have a range."));
591 switch (type
->code ())
593 case TYPE_CODE_ARRAY
:
594 case TYPE_CODE_STRING
:
595 low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
596 high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
));
598 case TYPE_CODE_RANGE
:
599 low
= TYPE_LOW_BOUND (type
);
600 high
= TYPE_HIGH_BOUND (type
);
604 gdbpy_ref
<> low_bound (PyLong_FromLong (low
));
605 if (low_bound
== NULL
)
608 gdbpy_ref
<> high_bound (PyLong_FromLong (high
));
609 if (high_bound
== NULL
)
612 gdbpy_ref
<> result (PyTuple_New (2));
616 if (PyTuple_SetItem (result
.get (), 0, low_bound
.release ()) != 0
617 || PyTuple_SetItem (result
.get (), 1, high_bound
.release ()) != 0)
619 return result
.release ();
622 /* Return a Type object which represents a reference to SELF. */
624 typy_reference (PyObject
*self
, PyObject
*args
)
626 struct type
*type
= ((type_object
*) self
)->type
;
630 type
= lookup_lvalue_reference_type (type
);
632 catch (const gdb_exception
&except
)
634 GDB_PY_HANDLE_EXCEPTION (except
);
637 return type_to_type_object (type
);
640 /* Return a Type object which represents the target type of SELF. */
642 typy_target (PyObject
*self
, PyObject
*args
)
644 struct type
*type
= ((type_object
*) self
)->type
;
646 if (!TYPE_TARGET_TYPE (type
))
648 PyErr_SetString (PyExc_RuntimeError
,
649 _("Type does not have a target."));
653 return type_to_type_object (TYPE_TARGET_TYPE (type
));
656 /* Return a const-qualified type variant. */
658 typy_const (PyObject
*self
, PyObject
*args
)
660 struct type
*type
= ((type_object
*) self
)->type
;
664 type
= make_cv_type (1, 0, type
, NULL
);
666 catch (const gdb_exception
&except
)
668 GDB_PY_HANDLE_EXCEPTION (except
);
671 return type_to_type_object (type
);
674 /* Return a volatile-qualified type variant. */
676 typy_volatile (PyObject
*self
, PyObject
*args
)
678 struct type
*type
= ((type_object
*) self
)->type
;
682 type
= make_cv_type (0, 1, type
, NULL
);
684 catch (const gdb_exception
&except
)
686 GDB_PY_HANDLE_EXCEPTION (except
);
689 return type_to_type_object (type
);
692 /* Return an unqualified type variant. */
694 typy_unqualified (PyObject
*self
, PyObject
*args
)
696 struct type
*type
= ((type_object
*) self
)->type
;
700 type
= make_cv_type (0, 0, type
, NULL
);
702 catch (const gdb_exception
&except
)
704 GDB_PY_HANDLE_EXCEPTION (except
);
707 return type_to_type_object (type
);
710 /* Return the size of the type represented by SELF, in bytes. */
712 typy_get_sizeof (PyObject
*self
, void *closure
)
714 struct type
*type
= ((type_object
*) self
)->type
;
716 bool size_varies
= false;
719 check_typedef (type
);
721 size_varies
= TYPE_HAS_DYNAMIC_LENGTH (type
);
723 catch (const gdb_exception
&except
)
727 /* Ignore exceptions. */
731 return gdb_py_long_from_longest (TYPE_LENGTH (type
));
734 /* Return the alignment of the type represented by SELF, in bytes. */
736 typy_get_alignof (PyObject
*self
, void *closure
)
738 struct type
*type
= ((type_object
*) self
)->type
;
743 align
= type_align (type
);
745 catch (const gdb_exception
&except
)
750 /* Ignore exceptions. */
752 return gdb_py_object_from_ulongest (align
).release ();
755 /* Return whether or not the type is dynamic. */
757 typy_get_dynamic (PyObject
*self
, void *closure
)
759 struct type
*type
= ((type_object
*) self
)->type
;
764 result
= is_dynamic_type (type
);
766 catch (const gdb_exception
&except
)
768 /* Ignore exceptions. */
777 typy_lookup_typename (const char *type_name
, const struct block
*block
)
779 struct type
*type
= NULL
;
783 if (startswith (type_name
, "struct "))
784 type
= lookup_struct (type_name
+ 7, NULL
);
785 else if (startswith (type_name
, "union "))
786 type
= lookup_union (type_name
+ 6, NULL
);
787 else if (startswith (type_name
, "enum "))
788 type
= lookup_enum (type_name
+ 5, NULL
);
790 type
= lookup_typename (python_language
,
791 type_name
, block
, 0);
793 catch (const gdb_exception
&except
)
795 GDB_PY_HANDLE_EXCEPTION (except
);
802 typy_lookup_type (struct demangle_component
*demangled
,
803 const struct block
*block
)
805 struct type
*type
, *rtype
= NULL
;
806 enum demangle_component_type demangled_type
;
808 /* Save the type: typy_lookup_type() may (indirectly) overwrite
809 memory pointed by demangled. */
810 demangled_type
= demangled
->type
;
812 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
813 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
814 || demangled_type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE
815 || demangled_type
== DEMANGLE_COMPONENT_CONST
816 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
818 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
824 /* If the demangled_type matches with one of the types
825 below, run the corresponding function and save the type
826 to return later. We cannot just return here as we are in
827 an exception handler. */
828 switch (demangled_type
)
830 case DEMANGLE_COMPONENT_REFERENCE
:
831 rtype
= lookup_lvalue_reference_type (type
);
833 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
834 rtype
= lookup_rvalue_reference_type (type
);
836 case DEMANGLE_COMPONENT_POINTER
:
837 rtype
= lookup_pointer_type (type
);
839 case DEMANGLE_COMPONENT_CONST
:
840 rtype
= make_cv_type (1, 0, type
, NULL
);
842 case DEMANGLE_COMPONENT_VOLATILE
:
843 rtype
= make_cv_type (0, 1, type
, NULL
);
847 catch (const gdb_exception
&except
)
849 GDB_PY_HANDLE_EXCEPTION (except
);
853 /* If we have a type from the switch statement above, just return
858 /* We don't have a type, so lookup the type. */
859 gdb::unique_xmalloc_ptr
<char> type_name
= cp_comp_to_string (demangled
, 10);
860 return typy_lookup_typename (type_name
.get (), block
);
863 /* This is a helper function for typy_template_argument that is used
864 when the type does not have template symbols attached. It works by
865 parsing the type name. This happens with compilers, like older
866 versions of GCC, that do not emit DW_TAG_template_*. */
869 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
873 struct demangle_component
*demangled
;
874 std::unique_ptr
<demangle_parse_info
> info
;
876 struct type
*argtype
;
878 if (TYPE_NAME (type
) == NULL
)
880 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
886 /* Note -- this is not thread-safe. */
887 info
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
889 catch (const gdb_exception
&except
)
891 GDB_PY_HANDLE_EXCEPTION (except
);
896 PyErr_SetString (PyExc_RuntimeError
, err
.c_str ());
899 demangled
= info
->tree
;
901 /* Strip off component names. */
902 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
903 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
904 demangled
= demangled
->u
.s_binary
.right
;
906 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
908 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
912 /* Skip from the template to the arguments. */
913 demangled
= demangled
->u
.s_binary
.right
;
915 for (i
= 0; demangled
&& i
< argno
; ++i
)
916 demangled
= demangled
->u
.s_binary
.right
;
920 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
925 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
929 return type_to_type_object (argtype
);
933 typy_template_argument (PyObject
*self
, PyObject
*args
)
936 struct type
*type
= ((type_object
*) self
)->type
;
937 const struct block
*block
= NULL
;
938 PyObject
*block_obj
= NULL
;
940 struct value
*val
= NULL
;
942 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
947 PyErr_SetString (PyExc_RuntimeError
,
948 _("Template argument number must be non-negative"));
954 block
= block_object_to_block (block_obj
);
957 PyErr_SetString (PyExc_RuntimeError
,
958 _("Second argument must be block."));
965 type
= check_typedef (type
);
966 if (TYPE_IS_REFERENCE (type
))
967 type
= check_typedef (TYPE_TARGET_TYPE (type
));
969 catch (const gdb_exception
&except
)
971 GDB_PY_HANDLE_EXCEPTION (except
);
974 /* We might not have DW_TAG_template_*, so try to parse the type's
975 name. This is inefficient if we do not have a template type --
976 but that is going to wind up as an error anyhow. */
977 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
978 return typy_legacy_template_argument (type
, block
, argno
);
980 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
982 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
987 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
988 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
989 return type_to_type_object (SYMBOL_TYPE (sym
));
990 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
992 PyErr_Format (PyExc_RuntimeError
,
993 _("Template argument is optimized out"));
999 val
= value_of_variable (sym
, block
);
1001 catch (const gdb_exception
&except
)
1003 GDB_PY_HANDLE_EXCEPTION (except
);
1006 return value_to_value_object (val
);
1010 typy_str (PyObject
*self
)
1012 string_file thetype
;
1016 LA_PRINT_TYPE (type_object_to_type (self
), "", &thetype
, -1, 0,
1017 &type_print_raw_options
);
1019 catch (const gdb_exception
&except
)
1021 GDB_PY_HANDLE_EXCEPTION (except
);
1024 return PyUnicode_Decode (thetype
.c_str (), thetype
.size (),
1025 host_charset (), NULL
);
1028 /* Implement the richcompare method. */
1031 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1033 bool result
= false;
1034 struct type
*type1
= type_object_to_type (self
);
1035 struct type
*type2
= type_object_to_type (other
);
1037 /* We can only compare ourselves to another Type object, and only
1038 for equality or inequality. */
1039 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
1041 Py_INCREF (Py_NotImplemented
);
1042 return Py_NotImplemented
;
1051 result
= types_deeply_equal (type1
, type2
);
1053 catch (const gdb_exception
&except
)
1055 /* If there is a GDB exception, a comparison is not capable
1056 (or trusted), so exit. */
1057 GDB_PY_HANDLE_EXCEPTION (except
);
1061 if (op
== (result
? Py_EQ
: Py_NE
))
1068 static const struct objfile_data
*typy_objfile_data_key
;
1071 save_objfile_types (struct objfile
*objfile
, void *datum
)
1073 type_object
*obj
= (type_object
*) datum
;
1074 htab_t copied_types
;
1076 if (!gdb_python_initialized
)
1079 /* This prevents another thread from freeing the objects we're
1081 gdbpy_enter
enter_py (objfile
->arch (), current_language
);
1083 copied_types
= create_copied_types_hash (objfile
);
1087 type_object
*next
= obj
->next
;
1089 htab_empty (copied_types
);
1091 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1099 htab_delete (copied_types
);
1103 set_type (type_object
*obj
, struct type
*type
)
1107 if (type
&& TYPE_OBJFILE (type
))
1109 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1111 obj
->next
= ((struct pyty_type_object
*)
1112 objfile_data (objfile
, typy_objfile_data_key
));
1114 obj
->next
->prev
= obj
;
1115 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1122 typy_dealloc (PyObject
*obj
)
1124 type_object
*type
= (type_object
*) obj
;
1127 type
->prev
->next
= type
->next
;
1128 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1130 /* Must reset head of list. */
1131 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1134 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1137 type
->next
->prev
= type
->prev
;
1139 Py_TYPE (type
)->tp_free (type
);
1142 /* Return number of fields ("length" of the field dictionary). */
1145 typy_length (PyObject
*self
)
1147 struct type
*type
= ((type_object
*) self
)->type
;
1149 type
= typy_get_composite (type
);
1153 return TYPE_NFIELDS (type
);
1156 /* Implements boolean evaluation of gdb.Type. Handle this like other
1157 Python objects that don't have a meaningful truth value -- all
1161 typy_nonzero (PyObject
*self
)
1166 /* Return optimized out value of this type. */
1169 typy_optimized_out (PyObject
*self
, PyObject
*args
)
1171 struct type
*type
= ((type_object
*) self
)->type
;
1173 return value_to_value_object (allocate_optimized_out_value (type
));
1176 /* Return a gdb.Field object for the field named by the argument. */
1179 typy_getitem (PyObject
*self
, PyObject
*key
)
1181 struct type
*type
= ((type_object
*) self
)->type
;
1184 gdb::unique_xmalloc_ptr
<char> field
= python_string_to_host_string (key
);
1188 /* We want just fields of this type, not of base types, so instead of
1189 using lookup_struct_elt_type, portions of that function are
1192 type
= typy_get_composite (type
);
1196 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1198 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1200 if (t_field_name
&& (strcmp_iw (t_field_name
, field
.get ()) == 0))
1201 return convert_field (type
, i
).release ();
1203 PyErr_SetObject (PyExc_KeyError
, key
);
1207 /* Implement the "get" method on the type object. This is the
1208 same as getitem if the key is present, but returns the supplied
1209 default value or None if the key is not found. */
1212 typy_get (PyObject
*self
, PyObject
*args
)
1214 PyObject
*key
, *defval
= Py_None
, *result
;
1216 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1219 result
= typy_getitem (self
, key
);
1223 /* typy_getitem returned error status. If the exception is
1224 KeyError, clear the exception status and return the defval
1225 instead. Otherwise return the exception unchanged. */
1226 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1234 /* Implement the "has_key" method on the type object. */
1237 typy_has_key (PyObject
*self
, PyObject
*args
)
1239 struct type
*type
= ((type_object
*) self
)->type
;
1243 if (!PyArg_ParseTuple (args
, "s", &field
))
1246 /* We want just fields of this type, not of base types, so instead of
1247 using lookup_struct_elt_type, portions of that function are
1250 type
= typy_get_composite (type
);
1254 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1256 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1258 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1264 /* Make an iterator object to iterate over keys, values, or items. */
1267 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1269 typy_iterator_object
*typy_iter_obj
;
1271 /* Check that "self" is a structure or union type. */
1272 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1275 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1276 &type_iterator_object_type
);
1277 if (typy_iter_obj
== NULL
)
1280 typy_iter_obj
->field
= 0;
1281 typy_iter_obj
->kind
= kind
;
1283 typy_iter_obj
->source
= (type_object
*) self
;
1285 return (PyObject
*) typy_iter_obj
;
1288 /* iteritems() method. */
1291 typy_iteritems (PyObject
*self
, PyObject
*args
)
1293 return typy_make_iter (self
, iter_items
);
1296 /* iterkeys() method. */
1299 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1301 return typy_make_iter (self
, iter_keys
);
1304 /* Iterating over the class, same as iterkeys except for the function
1308 typy_iter (PyObject
*self
)
1310 return typy_make_iter (self
, iter_keys
);
1313 /* itervalues() method. */
1316 typy_itervalues (PyObject
*self
, PyObject
*args
)
1318 return typy_make_iter (self
, iter_values
);
1321 /* Return a reference to the type iterator. */
1324 typy_iterator_iter (PyObject
*self
)
1330 /* Return the next field in the iteration through the list of fields
1334 typy_iterator_iternext (PyObject
*self
)
1336 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1337 struct type
*type
= iter_obj
->source
->type
;
1339 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1341 gdbpy_ref
<> result
= make_fielditem (type
, iter_obj
->field
,
1345 return result
.release ();
1352 typy_iterator_dealloc (PyObject
*obj
)
1354 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1356 Py_DECREF (iter_obj
->source
);
1357 Py_TYPE (obj
)->tp_free (obj
);
1360 /* Create a new Type referring to TYPE. */
1362 type_to_type_object (struct type
*type
)
1364 type_object
*type_obj
;
1368 /* Try not to let stub types leak out to Python. */
1369 if (TYPE_STUB (type
))
1370 type
= check_typedef (type
);
1374 /* Just ignore failures in check_typedef. */
1377 type_obj
= PyObject_New (type_object
, &type_object_type
);
1379 set_type (type_obj
, type
);
1381 return (PyObject
*) type_obj
;
1385 type_object_to_type (PyObject
*obj
)
1387 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1389 return ((type_object
*) obj
)->type
;
1394 /* Implementation of gdb.lookup_type. */
1396 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1398 static const char *keywords
[] = { "name", "block", NULL
};
1399 const char *type_name
= NULL
;
1400 struct type
*type
= NULL
;
1401 PyObject
*block_obj
= NULL
;
1402 const struct block
*block
= NULL
;
1404 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1405 &type_name
, &block_obj
))
1410 block
= block_object_to_block (block_obj
);
1413 PyErr_SetString (PyExc_RuntimeError
,
1414 _("'block' argument must be a Block."));
1419 type
= typy_lookup_typename (type_name
, block
);
1423 return type_to_type_object (type
);
1427 gdbpy_initialize_types (void)
1431 typy_objfile_data_key
1432 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1434 if (PyType_Ready (&type_object_type
) < 0)
1436 if (PyType_Ready (&field_object_type
) < 0)
1438 if (PyType_Ready (&type_iterator_object_type
) < 0)
1441 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1443 if (PyModule_AddIntConstant (gdb_module
, pyty_codes
[i
].name
,
1444 pyty_codes
[i
].code
) < 0)
1448 if (gdb_pymodule_addobject (gdb_module
, "Type",
1449 (PyObject
*) &type_object_type
) < 0)
1452 if (gdb_pymodule_addobject (gdb_module
, "TypeIterator",
1453 (PyObject
*) &type_iterator_object_type
) < 0)
1456 return gdb_pymodule_addobject (gdb_module
, "Field",
1457 (PyObject
*) &field_object_type
);
1462 static gdb_PyGetSetDef type_object_getset
[] =
1464 { "alignof", typy_get_alignof
, NULL
,
1465 "The alignment of this type, in bytes.", NULL
},
1466 { "code", typy_get_code
, NULL
,
1467 "The code for this type.", NULL
},
1468 { "dynamic", typy_get_dynamic
, NULL
,
1469 "Whether this type is dynamic.", NULL
},
1470 { "name", typy_get_name
, NULL
,
1471 "The name for this type, or None.", NULL
},
1472 { "sizeof", typy_get_sizeof
, NULL
,
1473 "The size of this type, in bytes.", NULL
},
1474 { "tag", typy_get_tag
, NULL
,
1475 "The tag name for this type, or None.", NULL
},
1476 { "objfile", typy_get_objfile
, NULL
,
1477 "The objfile this type was defined in, or None.", NULL
},
1481 static PyMethodDef type_object_methods
[] =
1483 { "array", typy_array
, METH_VARARGS
,
1484 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1485 Return a type which represents an array of objects of this type.\n\
1486 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1487 If LOW_BOUND is omitted, a value of zero is used." },
1488 { "vector", typy_vector
, METH_VARARGS
,
1489 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1490 Return a type which represents a vector of objects of this type.\n\
1491 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1492 If LOW_BOUND is omitted, a value of zero is used.\n\
1493 Vectors differ from arrays in that if the current language has C-style\n\
1494 arrays, vectors don't decay to a pointer to the first element.\n\
1495 They are first class values." },
1496 { "__contains__", typy_has_key
, METH_VARARGS
,
1497 "T.__contains__(k) -> True if T has a field named k, else False" },
1498 { "const", typy_const
, METH_NOARGS
,
1499 "const () -> Type\n\
1500 Return a const variant of this type." },
1501 { "optimized_out", typy_optimized_out
, METH_NOARGS
,
1502 "optimized_out() -> Value\n\
1503 Return optimized out value of this type." },
1504 { "fields", typy_fields
, METH_NOARGS
,
1505 "fields () -> list\n\
1506 Return a list holding all the fields of this type.\n\
1507 Each field is a gdb.Field object." },
1508 { "get", typy_get
, METH_VARARGS
,
1509 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1510 otherwise returns default, if supplied, or None if not." },
1511 { "has_key", typy_has_key
, METH_VARARGS
,
1512 "T.has_key(k) -> True if T has a field named k, else False" },
1513 { "items", typy_items
, METH_NOARGS
,
1514 "items () -> list\n\
1515 Return a list of (name, field) pairs of this type.\n\
1516 Each field is a gdb.Field object." },
1517 { "iteritems", typy_iteritems
, METH_NOARGS
,
1518 "iteritems () -> an iterator over the (name, field)\n\
1519 pairs of this type. Each field is a gdb.Field object." },
1520 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1521 "iterkeys () -> an iterator over the field names of this type." },
1522 { "itervalues", typy_itervalues
, METH_NOARGS
,
1523 "itervalues () -> an iterator over the fields of this type.\n\
1524 Each field is a gdb.Field object." },
1525 { "keys", typy_field_names
, METH_NOARGS
,
1527 Return a list holding all the fields names of this type." },
1528 { "pointer", typy_pointer
, METH_NOARGS
,
1529 "pointer () -> Type\n\
1530 Return a type of pointer to this type." },
1531 { "range", typy_range
, METH_NOARGS
,
1532 "range () -> tuple\n\
1533 Return a tuple containing the lower and upper range for this type."},
1534 { "reference", typy_reference
, METH_NOARGS
,
1535 "reference () -> Type\n\
1536 Return a type of reference to this type." },
1537 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1538 "strip_typedefs () -> Type\n\
1539 Return a type formed by stripping this type of all typedefs."},
1540 { "target", typy_target
, METH_NOARGS
,
1541 "target () -> Type\n\
1542 Return the target type of this type." },
1543 { "template_argument", typy_template_argument
, METH_VARARGS
,
1544 "template_argument (arg, [block]) -> Type\n\
1545 Return the type of a template argument." },
1546 { "unqualified", typy_unqualified
, METH_NOARGS
,
1547 "unqualified () -> Type\n\
1548 Return a variant of this type without const or volatile attributes." },
1549 { "values", typy_values
, METH_NOARGS
,
1550 "values () -> list\n\
1551 Return a list holding all the fields of this type.\n\
1552 Each field is a gdb.Field object." },
1553 { "volatile", typy_volatile
, METH_NOARGS
,
1554 "volatile () -> Type\n\
1555 Return a volatile variant of this type" },
1559 static PyNumberMethods type_object_as_number
= {
1561 NULL
, /* nb_subtract */
1562 NULL
, /* nb_multiply */
1564 NULL
, /* nb_divide */
1566 NULL
, /* nb_remainder */
1567 NULL
, /* nb_divmod */
1568 NULL
, /* nb_power */
1569 NULL
, /* nb_negative */
1570 NULL
, /* nb_positive */
1571 NULL
, /* nb_absolute */
1572 typy_nonzero
, /* nb_nonzero */
1573 NULL
, /* nb_invert */
1574 NULL
, /* nb_lshift */
1575 NULL
, /* nb_rshift */
1581 NULL
, /* reserved */
1583 NULL
, /* nb_coerce */
1587 NULL
, /* nb_float */
1594 static PyMappingMethods typy_mapping
= {
1597 NULL
/* no "set" method */
1600 PyTypeObject type_object_type
=
1602 PyVarObject_HEAD_INIT (NULL
, 0)
1603 "gdb.Type", /*tp_name*/
1604 sizeof (type_object
), /*tp_basicsize*/
1606 typy_dealloc
, /*tp_dealloc*/
1612 &type_object_as_number
, /*tp_as_number*/
1613 0, /*tp_as_sequence*/
1614 &typy_mapping
, /*tp_as_mapping*/
1617 typy_str
, /*tp_str*/
1621 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1622 "GDB type object", /* tp_doc */
1623 0, /* tp_traverse */
1625 typy_richcompare
, /* tp_richcompare */
1626 0, /* tp_weaklistoffset */
1627 typy_iter
, /* tp_iter */
1628 0, /* tp_iternext */
1629 type_object_methods
, /* tp_methods */
1631 type_object_getset
, /* tp_getset */
1634 0, /* tp_descr_get */
1635 0, /* tp_descr_set */
1636 0, /* tp_dictoffset */
1642 static gdb_PyGetSetDef field_object_getset
[] =
1644 { "__dict__", gdb_py_generic_dict
, NULL
,
1645 "The __dict__ for this field.", &field_object_type
},
1649 PyTypeObject field_object_type
=
1651 PyVarObject_HEAD_INIT (NULL
, 0)
1652 "gdb.Field", /*tp_name*/
1653 sizeof (field_object
), /*tp_basicsize*/
1655 field_dealloc
, /*tp_dealloc*/
1662 0, /*tp_as_sequence*/
1663 0, /*tp_as_mapping*/
1670 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1671 "GDB field object", /* tp_doc */
1672 0, /* tp_traverse */
1674 0, /* tp_richcompare */
1675 0, /* tp_weaklistoffset */
1677 0, /* tp_iternext */
1680 field_object_getset
, /* tp_getset */
1683 0, /* tp_descr_get */
1684 0, /* tp_descr_set */
1685 offsetof (field_object
, dict
), /* tp_dictoffset */
1691 PyTypeObject type_iterator_object_type
= {
1692 PyVarObject_HEAD_INIT (NULL
, 0)
1693 "gdb.TypeIterator", /*tp_name*/
1694 sizeof (typy_iterator_object
), /*tp_basicsize*/
1696 typy_iterator_dealloc
, /*tp_dealloc*/
1703 0, /*tp_as_sequence*/
1704 0, /*tp_as_mapping*/
1711 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1712 "GDB type iterator object", /*tp_doc */
1715 0, /*tp_richcompare */
1716 0, /*tp_weaklistoffset */
1717 typy_iterator_iter
, /*tp_iter */
1718 typy_iterator_iternext
, /*tp_iternext */