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 (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 (field
).type () == NULL
)
246 arg
= gdbpy_ref
<>::new_reference (Py_None
);
248 arg
.reset (type_to_type_object (type
->field (field
).type ()));
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 () == NULL
)
398 return PyString_FromString (type
->name ());
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 ();
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 case TYPE_CODE_RANGE
:
596 low
= type
->bounds ()->low
.const_val ();
597 high
= type
->bounds ()->high
.const_val ();;
601 gdbpy_ref
<> low_bound (PyLong_FromLong (low
));
602 if (low_bound
== NULL
)
605 gdbpy_ref
<> high_bound (PyLong_FromLong (high
));
606 if (high_bound
== NULL
)
609 gdbpy_ref
<> result (PyTuple_New (2));
613 if (PyTuple_SetItem (result
.get (), 0, low_bound
.release ()) != 0
614 || PyTuple_SetItem (result
.get (), 1, high_bound
.release ()) != 0)
616 return result
.release ();
619 /* Return a Type object which represents a reference to SELF. */
621 typy_reference (PyObject
*self
, PyObject
*args
)
623 struct type
*type
= ((type_object
*) self
)->type
;
627 type
= lookup_lvalue_reference_type (type
);
629 catch (const gdb_exception
&except
)
631 GDB_PY_HANDLE_EXCEPTION (except
);
634 return type_to_type_object (type
);
637 /* Return a Type object which represents the target type of SELF. */
639 typy_target (PyObject
*self
, PyObject
*args
)
641 struct type
*type
= ((type_object
*) self
)->type
;
643 if (!TYPE_TARGET_TYPE (type
))
645 PyErr_SetString (PyExc_RuntimeError
,
646 _("Type does not have a target."));
650 return type_to_type_object (TYPE_TARGET_TYPE (type
));
653 /* Return a const-qualified type variant. */
655 typy_const (PyObject
*self
, PyObject
*args
)
657 struct type
*type
= ((type_object
*) self
)->type
;
661 type
= make_cv_type (1, 0, type
, NULL
);
663 catch (const gdb_exception
&except
)
665 GDB_PY_HANDLE_EXCEPTION (except
);
668 return type_to_type_object (type
);
671 /* Return a volatile-qualified type variant. */
673 typy_volatile (PyObject
*self
, PyObject
*args
)
675 struct type
*type
= ((type_object
*) self
)->type
;
679 type
= make_cv_type (0, 1, type
, NULL
);
681 catch (const gdb_exception
&except
)
683 GDB_PY_HANDLE_EXCEPTION (except
);
686 return type_to_type_object (type
);
689 /* Return an unqualified type variant. */
691 typy_unqualified (PyObject
*self
, PyObject
*args
)
693 struct type
*type
= ((type_object
*) self
)->type
;
697 type
= make_cv_type (0, 0, type
, NULL
);
699 catch (const gdb_exception
&except
)
701 GDB_PY_HANDLE_EXCEPTION (except
);
704 return type_to_type_object (type
);
707 /* Return the size of the type represented by SELF, in bytes. */
709 typy_get_sizeof (PyObject
*self
, void *closure
)
711 struct type
*type
= ((type_object
*) self
)->type
;
713 bool size_varies
= false;
716 check_typedef (type
);
718 size_varies
= TYPE_HAS_DYNAMIC_LENGTH (type
);
720 catch (const gdb_exception
&except
)
724 /* Ignore exceptions. */
728 return gdb_py_long_from_longest (TYPE_LENGTH (type
));
731 /* Return the alignment of the type represented by SELF, in bytes. */
733 typy_get_alignof (PyObject
*self
, void *closure
)
735 struct type
*type
= ((type_object
*) self
)->type
;
740 align
= type_align (type
);
742 catch (const gdb_exception
&except
)
747 /* Ignore exceptions. */
749 return gdb_py_object_from_ulongest (align
).release ();
752 /* Return whether or not the type is dynamic. */
754 typy_get_dynamic (PyObject
*self
, void *closure
)
756 struct type
*type
= ((type_object
*) self
)->type
;
761 result
= is_dynamic_type (type
);
763 catch (const gdb_exception
&except
)
765 /* Ignore exceptions. */
774 typy_lookup_typename (const char *type_name
, const struct block
*block
)
776 struct type
*type
= NULL
;
780 if (startswith (type_name
, "struct "))
781 type
= lookup_struct (type_name
+ 7, NULL
);
782 else if (startswith (type_name
, "union "))
783 type
= lookup_union (type_name
+ 6, NULL
);
784 else if (startswith (type_name
, "enum "))
785 type
= lookup_enum (type_name
+ 5, NULL
);
787 type
= lookup_typename (python_language
,
788 type_name
, block
, 0);
790 catch (const gdb_exception
&except
)
792 GDB_PY_HANDLE_EXCEPTION (except
);
799 typy_lookup_type (struct demangle_component
*demangled
,
800 const struct block
*block
)
802 struct type
*type
, *rtype
= NULL
;
803 enum demangle_component_type demangled_type
;
805 /* Save the type: typy_lookup_type() may (indirectly) overwrite
806 memory pointed by demangled. */
807 demangled_type
= demangled
->type
;
809 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
810 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
811 || demangled_type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE
812 || demangled_type
== DEMANGLE_COMPONENT_CONST
813 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
815 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
821 /* If the demangled_type matches with one of the types
822 below, run the corresponding function and save the type
823 to return later. We cannot just return here as we are in
824 an exception handler. */
825 switch (demangled_type
)
827 case DEMANGLE_COMPONENT_REFERENCE
:
828 rtype
= lookup_lvalue_reference_type (type
);
830 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
831 rtype
= lookup_rvalue_reference_type (type
);
833 case DEMANGLE_COMPONENT_POINTER
:
834 rtype
= lookup_pointer_type (type
);
836 case DEMANGLE_COMPONENT_CONST
:
837 rtype
= make_cv_type (1, 0, type
, NULL
);
839 case DEMANGLE_COMPONENT_VOLATILE
:
840 rtype
= make_cv_type (0, 1, type
, NULL
);
844 catch (const gdb_exception
&except
)
846 GDB_PY_HANDLE_EXCEPTION (except
);
850 /* If we have a type from the switch statement above, just return
855 /* We don't have a type, so lookup the type. */
856 gdb::unique_xmalloc_ptr
<char> type_name
= cp_comp_to_string (demangled
, 10);
857 return typy_lookup_typename (type_name
.get (), block
);
860 /* This is a helper function for typy_template_argument that is used
861 when the type does not have template symbols attached. It works by
862 parsing the type name. This happens with compilers, like older
863 versions of GCC, that do not emit DW_TAG_template_*. */
866 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
870 struct demangle_component
*demangled
;
871 std::unique_ptr
<demangle_parse_info
> info
;
873 struct type
*argtype
;
875 if (type
->name () == NULL
)
877 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
883 /* Note -- this is not thread-safe. */
884 info
= cp_demangled_name_to_comp (type
->name (), &err
);
886 catch (const gdb_exception
&except
)
888 GDB_PY_HANDLE_EXCEPTION (except
);
893 PyErr_SetString (PyExc_RuntimeError
, err
.c_str ());
896 demangled
= info
->tree
;
898 /* Strip off component names. */
899 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
900 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
901 demangled
= demangled
->u
.s_binary
.right
;
903 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
905 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
909 /* Skip from the template to the arguments. */
910 demangled
= demangled
->u
.s_binary
.right
;
912 for (i
= 0; demangled
&& i
< argno
; ++i
)
913 demangled
= demangled
->u
.s_binary
.right
;
917 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
922 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
926 return type_to_type_object (argtype
);
930 typy_template_argument (PyObject
*self
, PyObject
*args
)
933 struct type
*type
= ((type_object
*) self
)->type
;
934 const struct block
*block
= NULL
;
935 PyObject
*block_obj
= NULL
;
937 struct value
*val
= NULL
;
939 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
944 PyErr_SetString (PyExc_RuntimeError
,
945 _("Template argument number must be non-negative"));
951 block
= block_object_to_block (block_obj
);
954 PyErr_SetString (PyExc_RuntimeError
,
955 _("Second argument must be block."));
962 type
= check_typedef (type
);
963 if (TYPE_IS_REFERENCE (type
))
964 type
= check_typedef (TYPE_TARGET_TYPE (type
));
966 catch (const gdb_exception
&except
)
968 GDB_PY_HANDLE_EXCEPTION (except
);
971 /* We might not have DW_TAG_template_*, so try to parse the type's
972 name. This is inefficient if we do not have a template type --
973 but that is going to wind up as an error anyhow. */
974 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
975 return typy_legacy_template_argument (type
, block
, argno
);
977 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
979 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
984 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
985 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
986 return type_to_type_object (SYMBOL_TYPE (sym
));
987 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
989 PyErr_Format (PyExc_RuntimeError
,
990 _("Template argument is optimized out"));
996 val
= value_of_variable (sym
, block
);
998 catch (const gdb_exception
&except
)
1000 GDB_PY_HANDLE_EXCEPTION (except
);
1003 return value_to_value_object (val
);
1007 typy_str (PyObject
*self
)
1009 string_file thetype
;
1013 LA_PRINT_TYPE (type_object_to_type (self
), "", &thetype
, -1, 0,
1014 &type_print_raw_options
);
1016 catch (const gdb_exception
&except
)
1018 GDB_PY_HANDLE_EXCEPTION (except
);
1021 return PyUnicode_Decode (thetype
.c_str (), thetype
.size (),
1022 host_charset (), NULL
);
1025 /* Implement the richcompare method. */
1028 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1030 bool result
= false;
1031 struct type
*type1
= type_object_to_type (self
);
1032 struct type
*type2
= type_object_to_type (other
);
1034 /* We can only compare ourselves to another Type object, and only
1035 for equality or inequality. */
1036 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
1038 Py_INCREF (Py_NotImplemented
);
1039 return Py_NotImplemented
;
1048 result
= types_deeply_equal (type1
, type2
);
1050 catch (const gdb_exception
&except
)
1052 /* If there is a GDB exception, a comparison is not capable
1053 (or trusted), so exit. */
1054 GDB_PY_HANDLE_EXCEPTION (except
);
1058 if (op
== (result
? Py_EQ
: Py_NE
))
1065 static const struct objfile_data
*typy_objfile_data_key
;
1068 save_objfile_types (struct objfile
*objfile
, void *datum
)
1070 type_object
*obj
= (type_object
*) datum
;
1071 htab_t copied_types
;
1073 if (!gdb_python_initialized
)
1076 /* This prevents another thread from freeing the objects we're
1078 gdbpy_enter
enter_py (objfile
->arch (), current_language
);
1080 copied_types
= create_copied_types_hash (objfile
);
1084 type_object
*next
= obj
->next
;
1086 htab_empty (copied_types
);
1088 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1096 htab_delete (copied_types
);
1100 set_type (type_object
*obj
, struct type
*type
)
1104 if (type
&& TYPE_OBJFILE (type
))
1106 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1108 obj
->next
= ((struct pyty_type_object
*)
1109 objfile_data (objfile
, typy_objfile_data_key
));
1111 obj
->next
->prev
= obj
;
1112 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1119 typy_dealloc (PyObject
*obj
)
1121 type_object
*type
= (type_object
*) obj
;
1124 type
->prev
->next
= type
->next
;
1125 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1127 /* Must reset head of list. */
1128 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1131 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1134 type
->next
->prev
= type
->prev
;
1136 Py_TYPE (type
)->tp_free (type
);
1139 /* Return number of fields ("length" of the field dictionary). */
1142 typy_length (PyObject
*self
)
1144 struct type
*type
= ((type_object
*) self
)->type
;
1146 type
= typy_get_composite (type
);
1150 return type
->num_fields ();
1153 /* Implements boolean evaluation of gdb.Type. Handle this like other
1154 Python objects that don't have a meaningful truth value -- all
1158 typy_nonzero (PyObject
*self
)
1163 /* Return optimized out value of this type. */
1166 typy_optimized_out (PyObject
*self
, PyObject
*args
)
1168 struct type
*type
= ((type_object
*) self
)->type
;
1170 return value_to_value_object (allocate_optimized_out_value (type
));
1173 /* Return a gdb.Field object for the field named by the argument. */
1176 typy_getitem (PyObject
*self
, PyObject
*key
)
1178 struct type
*type
= ((type_object
*) self
)->type
;
1181 gdb::unique_xmalloc_ptr
<char> field
= python_string_to_host_string (key
);
1185 /* We want just fields of this type, not of base types, so instead of
1186 using lookup_struct_elt_type, portions of that function are
1189 type
= typy_get_composite (type
);
1193 for (i
= 0; i
< type
->num_fields (); i
++)
1195 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1197 if (t_field_name
&& (strcmp_iw (t_field_name
, field
.get ()) == 0))
1198 return convert_field (type
, i
).release ();
1200 PyErr_SetObject (PyExc_KeyError
, key
);
1204 /* Implement the "get" method on the type object. This is the
1205 same as getitem if the key is present, but returns the supplied
1206 default value or None if the key is not found. */
1209 typy_get (PyObject
*self
, PyObject
*args
)
1211 PyObject
*key
, *defval
= Py_None
, *result
;
1213 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1216 result
= typy_getitem (self
, key
);
1220 /* typy_getitem returned error status. If the exception is
1221 KeyError, clear the exception status and return the defval
1222 instead. Otherwise return the exception unchanged. */
1223 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1231 /* Implement the "has_key" method on the type object. */
1234 typy_has_key (PyObject
*self
, PyObject
*args
)
1236 struct type
*type
= ((type_object
*) self
)->type
;
1240 if (!PyArg_ParseTuple (args
, "s", &field
))
1243 /* We want just fields of this type, not of base types, so instead of
1244 using lookup_struct_elt_type, portions of that function are
1247 type
= typy_get_composite (type
);
1251 for (i
= 0; i
< type
->num_fields (); i
++)
1253 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1255 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1261 /* Make an iterator object to iterate over keys, values, or items. */
1264 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1266 typy_iterator_object
*typy_iter_obj
;
1268 /* Check that "self" is a structure or union type. */
1269 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1272 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1273 &type_iterator_object_type
);
1274 if (typy_iter_obj
== NULL
)
1277 typy_iter_obj
->field
= 0;
1278 typy_iter_obj
->kind
= kind
;
1280 typy_iter_obj
->source
= (type_object
*) self
;
1282 return (PyObject
*) typy_iter_obj
;
1285 /* iteritems() method. */
1288 typy_iteritems (PyObject
*self
, PyObject
*args
)
1290 return typy_make_iter (self
, iter_items
);
1293 /* iterkeys() method. */
1296 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1298 return typy_make_iter (self
, iter_keys
);
1301 /* Iterating over the class, same as iterkeys except for the function
1305 typy_iter (PyObject
*self
)
1307 return typy_make_iter (self
, iter_keys
);
1310 /* itervalues() method. */
1313 typy_itervalues (PyObject
*self
, PyObject
*args
)
1315 return typy_make_iter (self
, iter_values
);
1318 /* Return a reference to the type iterator. */
1321 typy_iterator_iter (PyObject
*self
)
1327 /* Return the next field in the iteration through the list of fields
1331 typy_iterator_iternext (PyObject
*self
)
1333 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1334 struct type
*type
= iter_obj
->source
->type
;
1336 if (iter_obj
->field
< type
->num_fields ())
1338 gdbpy_ref
<> result
= make_fielditem (type
, iter_obj
->field
,
1342 return result
.release ();
1349 typy_iterator_dealloc (PyObject
*obj
)
1351 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1353 Py_DECREF (iter_obj
->source
);
1354 Py_TYPE (obj
)->tp_free (obj
);
1357 /* Create a new Type referring to TYPE. */
1359 type_to_type_object (struct type
*type
)
1361 type_object
*type_obj
;
1365 /* Try not to let stub types leak out to Python. */
1366 if (TYPE_STUB (type
))
1367 type
= check_typedef (type
);
1371 /* Just ignore failures in check_typedef. */
1374 type_obj
= PyObject_New (type_object
, &type_object_type
);
1376 set_type (type_obj
, type
);
1378 return (PyObject
*) type_obj
;
1382 type_object_to_type (PyObject
*obj
)
1384 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1386 return ((type_object
*) obj
)->type
;
1391 /* Implementation of gdb.lookup_type. */
1393 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1395 static const char *keywords
[] = { "name", "block", NULL
};
1396 const char *type_name
= NULL
;
1397 struct type
*type
= NULL
;
1398 PyObject
*block_obj
= NULL
;
1399 const struct block
*block
= NULL
;
1401 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1402 &type_name
, &block_obj
))
1407 block
= block_object_to_block (block_obj
);
1410 PyErr_SetString (PyExc_RuntimeError
,
1411 _("'block' argument must be a Block."));
1416 type
= typy_lookup_typename (type_name
, block
);
1420 return type_to_type_object (type
);
1424 gdbpy_initialize_types (void)
1428 typy_objfile_data_key
1429 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1431 if (PyType_Ready (&type_object_type
) < 0)
1433 if (PyType_Ready (&field_object_type
) < 0)
1435 if (PyType_Ready (&type_iterator_object_type
) < 0)
1438 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1440 if (PyModule_AddIntConstant (gdb_module
, pyty_codes
[i
].name
,
1441 pyty_codes
[i
].code
) < 0)
1445 if (gdb_pymodule_addobject (gdb_module
, "Type",
1446 (PyObject
*) &type_object_type
) < 0)
1449 if (gdb_pymodule_addobject (gdb_module
, "TypeIterator",
1450 (PyObject
*) &type_iterator_object_type
) < 0)
1453 return gdb_pymodule_addobject (gdb_module
, "Field",
1454 (PyObject
*) &field_object_type
);
1459 static gdb_PyGetSetDef type_object_getset
[] =
1461 { "alignof", typy_get_alignof
, NULL
,
1462 "The alignment of this type, in bytes.", NULL
},
1463 { "code", typy_get_code
, NULL
,
1464 "The code for this type.", NULL
},
1465 { "dynamic", typy_get_dynamic
, NULL
,
1466 "Whether this type is dynamic.", NULL
},
1467 { "name", typy_get_name
, NULL
,
1468 "The name for this type, or None.", NULL
},
1469 { "sizeof", typy_get_sizeof
, NULL
,
1470 "The size of this type, in bytes.", NULL
},
1471 { "tag", typy_get_tag
, NULL
,
1472 "The tag name for this type, or None.", NULL
},
1473 { "objfile", typy_get_objfile
, NULL
,
1474 "The objfile this type was defined in, or None.", NULL
},
1478 static PyMethodDef type_object_methods
[] =
1480 { "array", typy_array
, METH_VARARGS
,
1481 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1482 Return a type which represents an array of objects of this type.\n\
1483 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1484 If LOW_BOUND is omitted, a value of zero is used." },
1485 { "vector", typy_vector
, METH_VARARGS
,
1486 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1487 Return a type which represents a vector of objects of this type.\n\
1488 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1489 If LOW_BOUND is omitted, a value of zero is used.\n\
1490 Vectors differ from arrays in that if the current language has C-style\n\
1491 arrays, vectors don't decay to a pointer to the first element.\n\
1492 They are first class values." },
1493 { "__contains__", typy_has_key
, METH_VARARGS
,
1494 "T.__contains__(k) -> True if T has a field named k, else False" },
1495 { "const", typy_const
, METH_NOARGS
,
1496 "const () -> Type\n\
1497 Return a const variant of this type." },
1498 { "optimized_out", typy_optimized_out
, METH_NOARGS
,
1499 "optimized_out() -> Value\n\
1500 Return optimized out value of this type." },
1501 { "fields", typy_fields
, METH_NOARGS
,
1502 "fields () -> list\n\
1503 Return a list holding all the fields of this type.\n\
1504 Each field is a gdb.Field object." },
1505 { "get", typy_get
, METH_VARARGS
,
1506 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1507 otherwise returns default, if supplied, or None if not." },
1508 { "has_key", typy_has_key
, METH_VARARGS
,
1509 "T.has_key(k) -> True if T has a field named k, else False" },
1510 { "items", typy_items
, METH_NOARGS
,
1511 "items () -> list\n\
1512 Return a list of (name, field) pairs of this type.\n\
1513 Each field is a gdb.Field object." },
1514 { "iteritems", typy_iteritems
, METH_NOARGS
,
1515 "iteritems () -> an iterator over the (name, field)\n\
1516 pairs of this type. Each field is a gdb.Field object." },
1517 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1518 "iterkeys () -> an iterator over the field names of this type." },
1519 { "itervalues", typy_itervalues
, METH_NOARGS
,
1520 "itervalues () -> an iterator over the fields of this type.\n\
1521 Each field is a gdb.Field object." },
1522 { "keys", typy_field_names
, METH_NOARGS
,
1524 Return a list holding all the fields names of this type." },
1525 { "pointer", typy_pointer
, METH_NOARGS
,
1526 "pointer () -> Type\n\
1527 Return a type of pointer to this type." },
1528 { "range", typy_range
, METH_NOARGS
,
1529 "range () -> tuple\n\
1530 Return a tuple containing the lower and upper range for this type."},
1531 { "reference", typy_reference
, METH_NOARGS
,
1532 "reference () -> Type\n\
1533 Return a type of reference to this type." },
1534 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1535 "strip_typedefs () -> Type\n\
1536 Return a type formed by stripping this type of all typedefs."},
1537 { "target", typy_target
, METH_NOARGS
,
1538 "target () -> Type\n\
1539 Return the target type of this type." },
1540 { "template_argument", typy_template_argument
, METH_VARARGS
,
1541 "template_argument (arg, [block]) -> Type\n\
1542 Return the type of a template argument." },
1543 { "unqualified", typy_unqualified
, METH_NOARGS
,
1544 "unqualified () -> Type\n\
1545 Return a variant of this type without const or volatile attributes." },
1546 { "values", typy_values
, METH_NOARGS
,
1547 "values () -> list\n\
1548 Return a list holding all the fields of this type.\n\
1549 Each field is a gdb.Field object." },
1550 { "volatile", typy_volatile
, METH_NOARGS
,
1551 "volatile () -> Type\n\
1552 Return a volatile variant of this type" },
1556 static PyNumberMethods type_object_as_number
= {
1558 NULL
, /* nb_subtract */
1559 NULL
, /* nb_multiply */
1561 NULL
, /* nb_divide */
1563 NULL
, /* nb_remainder */
1564 NULL
, /* nb_divmod */
1565 NULL
, /* nb_power */
1566 NULL
, /* nb_negative */
1567 NULL
, /* nb_positive */
1568 NULL
, /* nb_absolute */
1569 typy_nonzero
, /* nb_nonzero */
1570 NULL
, /* nb_invert */
1571 NULL
, /* nb_lshift */
1572 NULL
, /* nb_rshift */
1578 NULL
, /* reserved */
1580 NULL
, /* nb_coerce */
1584 NULL
, /* nb_float */
1591 static PyMappingMethods typy_mapping
= {
1594 NULL
/* no "set" method */
1597 PyTypeObject type_object_type
=
1599 PyVarObject_HEAD_INIT (NULL
, 0)
1600 "gdb.Type", /*tp_name*/
1601 sizeof (type_object
), /*tp_basicsize*/
1603 typy_dealloc
, /*tp_dealloc*/
1609 &type_object_as_number
, /*tp_as_number*/
1610 0, /*tp_as_sequence*/
1611 &typy_mapping
, /*tp_as_mapping*/
1614 typy_str
, /*tp_str*/
1618 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1619 "GDB type object", /* tp_doc */
1620 0, /* tp_traverse */
1622 typy_richcompare
, /* tp_richcompare */
1623 0, /* tp_weaklistoffset */
1624 typy_iter
, /* tp_iter */
1625 0, /* tp_iternext */
1626 type_object_methods
, /* tp_methods */
1628 type_object_getset
, /* tp_getset */
1631 0, /* tp_descr_get */
1632 0, /* tp_descr_set */
1633 0, /* tp_dictoffset */
1639 static gdb_PyGetSetDef field_object_getset
[] =
1641 { "__dict__", gdb_py_generic_dict
, NULL
,
1642 "The __dict__ for this field.", &field_object_type
},
1646 PyTypeObject field_object_type
=
1648 PyVarObject_HEAD_INIT (NULL
, 0)
1649 "gdb.Field", /*tp_name*/
1650 sizeof (field_object
), /*tp_basicsize*/
1652 field_dealloc
, /*tp_dealloc*/
1659 0, /*tp_as_sequence*/
1660 0, /*tp_as_mapping*/
1667 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1668 "GDB field object", /* tp_doc */
1669 0, /* tp_traverse */
1671 0, /* tp_richcompare */
1672 0, /* tp_weaklistoffset */
1674 0, /* tp_iternext */
1677 field_object_getset
, /* tp_getset */
1680 0, /* tp_descr_get */
1681 0, /* tp_descr_set */
1682 offsetof (field_object
, dict
), /* tp_dictoffset */
1688 PyTypeObject type_iterator_object_type
= {
1689 PyVarObject_HEAD_INIT (NULL
, 0)
1690 "gdb.TypeIterator", /*tp_name*/
1691 sizeof (typy_iterator_object
), /*tp_basicsize*/
1693 typy_iterator_dealloc
, /*tp_dealloc*/
1700 0, /*tp_as_sequence*/
1701 0, /*tp_as_mapping*/
1708 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1709 "GDB type iterator object", /*tp_doc */
1712 0, /*tp_richcompare */
1713 0, /*tp_weaklistoffset */
1714 typy_iterator_iter
, /*tp_iter */
1715 typy_iterator_iternext
, /*tp_iternext */