1 /* Python interface to types.
3 Copyright (C) 2008-2021 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"
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 type_object
*prev
;
40 struct type_object
*next
;
43 extern PyTypeObject type_object_type
44 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("type_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. */
59 struct typy_iterator_object
{
61 /* The current field index. */
64 enum gdbpy_iter_kind kind
;
65 /* Pointer back to the original source type 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 gdb_py_object_from_longest (type
->code ()).release ();
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
= gdb_py_object_from_longest (TYPE_FIELD_ENUMVAL (type
, field
));
187 attrstring
= "enumval";
191 if (TYPE_FIELD_LOC_KIND (type
, field
) == FIELD_LOC_KIND_DWARF_BLOCK
)
192 arg
= gdbpy_ref
<>::new_reference (Py_None
);
194 arg
= gdb_py_object_from_longest (TYPE_FIELD_BITPOS (type
, field
));
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_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
= gdb_py_object_from_longest (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 (field
).type () == NULL
)
244 arg
= gdbpy_ref
<>::new_reference (Py_None
);
246 arg
.reset (type_to_type_object (type
->field (field
).type ()));
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_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 () == NULL
)
396 return PyString_FromString (type
->name ());
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_CODE_STRUCT
407 || type
->code () == TYPE_CODE_UNION
408 || type
->code () == TYPE_CODE_ENUM
)
409 tagname
= type
->name ();
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_owner ();
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_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_CODE_STRUCT
472 && type
->code () != TYPE_CODE_UNION
473 && type
->code () != TYPE_CODE_ENUM
474 && type
->code () != TYPE_CODE_METHOD
475 && type
->code () != TYPE_CODE_FUNC
)
477 PyErr_SetString (PyExc_TypeError
,
478 "Type is not a structure, union, enum, or function type.");
485 /* Helper for typy_array and typy_vector. */
488 typy_array_1 (PyObject
*self
, PyObject
*args
, int is_vector
)
491 PyObject
*n2_obj
= NULL
;
492 struct type
*array
= NULL
;
493 struct type
*type
= ((type_object
*) self
)->type
;
495 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
500 if (!PyInt_Check (n2_obj
))
502 PyErr_SetString (PyExc_RuntimeError
,
503 _("Array bound must be an integer"));
507 if (! gdb_py_int_as_long (n2_obj
, &n2
))
516 if (n2
< n1
- 1) /* Note: An empty array has n2 == n1 - 1. */
518 PyErr_SetString (PyExc_ValueError
,
519 _("Array length must not be negative"));
525 array
= lookup_array_range_type (type
, n1
, n2
);
527 make_vector_type (array
);
529 catch (const gdb_exception
&except
)
531 GDB_PY_HANDLE_EXCEPTION (except
);
534 return type_to_type_object (array
);
537 /* Return an array type. */
540 typy_array (PyObject
*self
, PyObject
*args
)
542 return typy_array_1 (self
, args
, 0);
545 /* Return a vector type. */
548 typy_vector (PyObject
*self
, PyObject
*args
)
550 return typy_array_1 (self
, args
, 1);
553 /* Return a Type object which represents a pointer to SELF. */
555 typy_pointer (PyObject
*self
, PyObject
*args
)
557 struct type
*type
= ((type_object
*) self
)->type
;
561 type
= lookup_pointer_type (type
);
563 catch (const gdb_exception
&except
)
565 GDB_PY_HANDLE_EXCEPTION (except
);
568 return type_to_type_object (type
);
571 /* Return the range of a type represented by SELF. The return type is
572 a tuple. The first element of the tuple contains the low bound,
573 while the second element of the tuple contains the high bound. */
575 typy_range (PyObject
*self
, PyObject
*args
)
577 struct type
*type
= ((type_object
*) self
)->type
;
578 /* Initialize these to appease GCC warnings. */
579 LONGEST low
= 0, high
= 0;
581 if (type
->code () != TYPE_CODE_ARRAY
582 && type
->code () != TYPE_CODE_STRING
583 && type
->code () != TYPE_CODE_RANGE
)
585 PyErr_SetString (PyExc_RuntimeError
,
586 _("This type does not have a range."));
590 switch (type
->code ())
592 case TYPE_CODE_ARRAY
:
593 case TYPE_CODE_STRING
:
594 case TYPE_CODE_RANGE
:
595 if (type
->bounds ()->low
.kind () == PROP_CONST
)
596 low
= type
->bounds ()->low
.const_val ();
600 if (type
->bounds ()->high
.kind () == PROP_CONST
)
601 high
= type
->bounds ()->high
.const_val ();
607 gdbpy_ref
<> low_bound
= gdb_py_object_from_longest (low
);
608 if (low_bound
== NULL
)
611 gdbpy_ref
<> high_bound
= gdb_py_object_from_longest (high
);
612 if (high_bound
== NULL
)
615 gdbpy_ref
<> result (PyTuple_New (2));
619 if (PyTuple_SetItem (result
.get (), 0, low_bound
.release ()) != 0
620 || PyTuple_SetItem (result
.get (), 1, high_bound
.release ()) != 0)
622 return result
.release ();
625 /* Return a Type object which represents a reference to SELF. */
627 typy_reference (PyObject
*self
, PyObject
*args
)
629 struct type
*type
= ((type_object
*) self
)->type
;
633 type
= lookup_lvalue_reference_type (type
);
635 catch (const gdb_exception
&except
)
637 GDB_PY_HANDLE_EXCEPTION (except
);
640 return type_to_type_object (type
);
643 /* Return a Type object which represents the target type of SELF. */
645 typy_target (PyObject
*self
, PyObject
*args
)
647 struct type
*type
= ((type_object
*) self
)->type
;
649 if (!TYPE_TARGET_TYPE (type
))
651 PyErr_SetString (PyExc_RuntimeError
,
652 _("Type does not have a target."));
656 return type_to_type_object (TYPE_TARGET_TYPE (type
));
659 /* Return a const-qualified type variant. */
661 typy_const (PyObject
*self
, PyObject
*args
)
663 struct type
*type
= ((type_object
*) self
)->type
;
667 type
= make_cv_type (1, 0, type
, NULL
);
669 catch (const gdb_exception
&except
)
671 GDB_PY_HANDLE_EXCEPTION (except
);
674 return type_to_type_object (type
);
677 /* Return a volatile-qualified type variant. */
679 typy_volatile (PyObject
*self
, PyObject
*args
)
681 struct type
*type
= ((type_object
*) self
)->type
;
685 type
= make_cv_type (0, 1, type
, NULL
);
687 catch (const gdb_exception
&except
)
689 GDB_PY_HANDLE_EXCEPTION (except
);
692 return type_to_type_object (type
);
695 /* Return an unqualified type variant. */
697 typy_unqualified (PyObject
*self
, PyObject
*args
)
699 struct type
*type
= ((type_object
*) self
)->type
;
703 type
= make_cv_type (0, 0, type
, NULL
);
705 catch (const gdb_exception
&except
)
707 GDB_PY_HANDLE_EXCEPTION (except
);
710 return type_to_type_object (type
);
713 /* Return the size of the type represented by SELF, in bytes. */
715 typy_get_sizeof (PyObject
*self
, void *closure
)
717 struct type
*type
= ((type_object
*) self
)->type
;
719 bool size_varies
= false;
722 check_typedef (type
);
724 size_varies
= TYPE_HAS_DYNAMIC_LENGTH (type
);
726 catch (const gdb_exception
&except
)
730 /* Ignore exceptions. */
734 return gdb_py_object_from_longest (TYPE_LENGTH (type
)).release ();
737 /* Return the alignment of the type represented by SELF, in bytes. */
739 typy_get_alignof (PyObject
*self
, void *closure
)
741 struct type
*type
= ((type_object
*) self
)->type
;
746 align
= type_align (type
);
748 catch (const gdb_exception
&except
)
753 /* Ignore exceptions. */
755 return gdb_py_object_from_ulongest (align
).release ();
758 /* Return whether or not the type is dynamic. */
760 typy_get_dynamic (PyObject
*self
, void *closure
)
762 struct type
*type
= ((type_object
*) self
)->type
;
767 result
= is_dynamic_type (type
);
769 catch (const gdb_exception
&except
)
771 /* Ignore exceptions. */
780 typy_lookup_typename (const char *type_name
, const struct block
*block
)
782 struct type
*type
= NULL
;
786 if (startswith (type_name
, "struct "))
787 type
= lookup_struct (type_name
+ 7, NULL
);
788 else if (startswith (type_name
, "union "))
789 type
= lookup_union (type_name
+ 6, NULL
);
790 else if (startswith (type_name
, "enum "))
791 type
= lookup_enum (type_name
+ 5, NULL
);
793 type
= lookup_typename (python_language
,
794 type_name
, block
, 0);
796 catch (const gdb_exception
&except
)
798 GDB_PY_HANDLE_EXCEPTION (except
);
805 typy_lookup_type (struct demangle_component
*demangled
,
806 const struct block
*block
)
808 struct type
*type
, *rtype
= NULL
;
809 enum demangle_component_type demangled_type
;
811 /* Save the type: typy_lookup_type() may (indirectly) overwrite
812 memory pointed by demangled. */
813 demangled_type
= demangled
->type
;
815 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
816 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
817 || demangled_type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE
818 || demangled_type
== DEMANGLE_COMPONENT_CONST
819 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
821 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
827 /* If the demangled_type matches with one of the types
828 below, run the corresponding function and save the type
829 to return later. We cannot just return here as we are in
830 an exception handler. */
831 switch (demangled_type
)
833 case DEMANGLE_COMPONENT_REFERENCE
:
834 rtype
= lookup_lvalue_reference_type (type
);
836 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
837 rtype
= lookup_rvalue_reference_type (type
);
839 case DEMANGLE_COMPONENT_POINTER
:
840 rtype
= lookup_pointer_type (type
);
842 case DEMANGLE_COMPONENT_CONST
:
843 rtype
= make_cv_type (1, 0, type
, NULL
);
845 case DEMANGLE_COMPONENT_VOLATILE
:
846 rtype
= make_cv_type (0, 1, type
, NULL
);
850 catch (const gdb_exception
&except
)
852 GDB_PY_HANDLE_EXCEPTION (except
);
856 /* If we have a type from the switch statement above, just return
861 /* We don't have a type, so lookup the type. */
862 gdb::unique_xmalloc_ptr
<char> type_name
= cp_comp_to_string (demangled
, 10);
863 return typy_lookup_typename (type_name
.get (), block
);
866 /* This is a helper function for typy_template_argument that is used
867 when the type does not have template symbols attached. It works by
868 parsing the type name. This happens with compilers, like older
869 versions of GCC, that do not emit DW_TAG_template_*. */
872 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
876 struct demangle_component
*demangled
;
877 std::unique_ptr
<demangle_parse_info
> info
;
879 struct type
*argtype
;
881 if (type
->name () == NULL
)
883 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
889 /* Note -- this is not thread-safe. */
890 info
= cp_demangled_name_to_comp (type
->name (), &err
);
892 catch (const gdb_exception
&except
)
894 GDB_PY_HANDLE_EXCEPTION (except
);
899 PyErr_SetString (PyExc_RuntimeError
, err
.c_str ());
902 demangled
= info
->tree
;
904 /* Strip off component names. */
905 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
906 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
907 demangled
= demangled
->u
.s_binary
.right
;
909 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
911 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
915 /* Skip from the template to the arguments. */
916 demangled
= demangled
->u
.s_binary
.right
;
918 for (i
= 0; demangled
&& i
< argno
; ++i
)
919 demangled
= demangled
->u
.s_binary
.right
;
923 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
928 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
932 return type_to_type_object (argtype
);
936 typy_template_argument (PyObject
*self
, PyObject
*args
)
939 struct type
*type
= ((type_object
*) self
)->type
;
940 const struct block
*block
= NULL
;
941 PyObject
*block_obj
= NULL
;
943 struct value
*val
= NULL
;
945 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
950 PyErr_SetString (PyExc_RuntimeError
,
951 _("Template argument number must be non-negative"));
957 block
= block_object_to_block (block_obj
);
960 PyErr_SetString (PyExc_RuntimeError
,
961 _("Second argument must be block."));
968 type
= check_typedef (type
);
969 if (TYPE_IS_REFERENCE (type
))
970 type
= check_typedef (TYPE_TARGET_TYPE (type
));
972 catch (const gdb_exception
&except
)
974 GDB_PY_HANDLE_EXCEPTION (except
);
977 /* We might not have DW_TAG_template_*, so try to parse the type's
978 name. This is inefficient if we do not have a template type --
979 but that is going to wind up as an error anyhow. */
980 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
981 return typy_legacy_template_argument (type
, block
, argno
);
983 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
985 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
990 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
991 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
992 return type_to_type_object (SYMBOL_TYPE (sym
));
993 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
995 PyErr_Format (PyExc_RuntimeError
,
996 _("Template argument is optimized out"));
1002 val
= value_of_variable (sym
, block
);
1004 catch (const gdb_exception
&except
)
1006 GDB_PY_HANDLE_EXCEPTION (except
);
1009 return value_to_value_object (val
);
1013 typy_str (PyObject
*self
)
1015 string_file thetype
;
1019 LA_PRINT_TYPE (type_object_to_type (self
), "", &thetype
, -1, 0,
1020 &type_print_raw_options
);
1022 catch (const gdb_exception
&except
)
1024 GDB_PY_HANDLE_EXCEPTION (except
);
1027 return PyUnicode_Decode (thetype
.c_str (), thetype
.size (),
1028 host_charset (), NULL
);
1031 /* Implement the richcompare method. */
1034 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1036 bool result
= false;
1037 struct type
*type1
= type_object_to_type (self
);
1038 struct type
*type2
= type_object_to_type (other
);
1040 /* We can only compare ourselves to another Type object, and only
1041 for equality or inequality. */
1042 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
1044 Py_INCREF (Py_NotImplemented
);
1045 return Py_NotImplemented
;
1054 result
= types_deeply_equal (type1
, type2
);
1056 catch (const gdb_exception
&except
)
1058 /* If there is a GDB exception, a comparison is not capable
1059 (or trusted), so exit. */
1060 GDB_PY_HANDLE_EXCEPTION (except
);
1064 if (op
== (result
? Py_EQ
: Py_NE
))
1071 static const struct objfile_data
*typy_objfile_data_key
;
1074 save_objfile_types (struct objfile
*objfile
, void *datum
)
1076 type_object
*obj
= (type_object
*) datum
;
1078 if (!gdb_python_initialized
)
1081 /* This prevents another thread from freeing the objects we're
1083 gdbpy_enter
enter_py (objfile
->arch (), current_language
);
1085 htab_up copied_types
= create_copied_types_hash (objfile
);
1089 type_object
*next
= obj
->next
;
1091 htab_empty (copied_types
.get ());
1093 obj
->type
= copy_type_recursive (objfile
, obj
->type
,
1094 copied_types
.get ());
1104 set_type (type_object
*obj
, struct type
*type
)
1108 if (type
!= nullptr && type
->objfile_owner () != nullptr)
1110 struct objfile
*objfile
= type
->objfile_owner ();
1112 obj
->next
= ((type_object
*)
1113 objfile_data (objfile
, typy_objfile_data_key
));
1115 obj
->next
->prev
= obj
;
1116 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1123 typy_dealloc (PyObject
*obj
)
1125 type_object
*type
= (type_object
*) obj
;
1128 type
->prev
->next
= type
->next
;
1129 else if (type
->type
!= nullptr && type
->type
->objfile_owner () != nullptr)
1131 /* Must reset head of list. */
1132 struct objfile
*objfile
= type
->type
->objfile_owner ();
1135 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1138 type
->next
->prev
= type
->prev
;
1140 Py_TYPE (type
)->tp_free (type
);
1143 /* Return number of fields ("length" of the field dictionary). */
1146 typy_length (PyObject
*self
)
1148 struct type
*type
= ((type_object
*) self
)->type
;
1150 type
= typy_get_composite (type
);
1154 return type
->num_fields ();
1157 /* Implements boolean evaluation of gdb.Type. Handle this like other
1158 Python objects that don't have a meaningful truth value -- all
1162 typy_nonzero (PyObject
*self
)
1167 /* Return optimized out value of this type. */
1170 typy_optimized_out (PyObject
*self
, PyObject
*args
)
1172 struct type
*type
= ((type_object
*) self
)->type
;
1174 return value_to_value_object (allocate_optimized_out_value (type
));
1177 /* Return a gdb.Field object for the field named by the argument. */
1180 typy_getitem (PyObject
*self
, PyObject
*key
)
1182 struct type
*type
= ((type_object
*) self
)->type
;
1185 gdb::unique_xmalloc_ptr
<char> field
= python_string_to_host_string (key
);
1189 /* We want just fields of this type, not of base types, so instead of
1190 using lookup_struct_elt_type, portions of that function are
1193 type
= typy_get_composite (type
);
1197 for (i
= 0; i
< type
->num_fields (); i
++)
1199 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1201 if (t_field_name
&& (strcmp_iw (t_field_name
, field
.get ()) == 0))
1202 return convert_field (type
, i
).release ();
1204 PyErr_SetObject (PyExc_KeyError
, key
);
1208 /* Implement the "get" method on the type object. This is the
1209 same as getitem if the key is present, but returns the supplied
1210 default value or None if the key is not found. */
1213 typy_get (PyObject
*self
, PyObject
*args
)
1215 PyObject
*key
, *defval
= Py_None
, *result
;
1217 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1220 result
= typy_getitem (self
, key
);
1224 /* typy_getitem returned error status. If the exception is
1225 KeyError, clear the exception status and return the defval
1226 instead. Otherwise return the exception unchanged. */
1227 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1235 /* Implement the "has_key" method on the type object. */
1238 typy_has_key (PyObject
*self
, PyObject
*args
)
1240 struct type
*type
= ((type_object
*) self
)->type
;
1244 if (!PyArg_ParseTuple (args
, "s", &field
))
1247 /* We want just fields of this type, not of base types, so instead of
1248 using lookup_struct_elt_type, portions of that function are
1251 type
= typy_get_composite (type
);
1255 for (i
= 0; i
< type
->num_fields (); i
++)
1257 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1259 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1265 /* Make an iterator object to iterate over keys, values, or items. */
1268 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1270 typy_iterator_object
*typy_iter_obj
;
1272 /* Check that "self" is a structure or union type. */
1273 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1276 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1277 &type_iterator_object_type
);
1278 if (typy_iter_obj
== NULL
)
1281 typy_iter_obj
->field
= 0;
1282 typy_iter_obj
->kind
= kind
;
1284 typy_iter_obj
->source
= (type_object
*) self
;
1286 return (PyObject
*) typy_iter_obj
;
1289 /* iteritems() method. */
1292 typy_iteritems (PyObject
*self
, PyObject
*args
)
1294 return typy_make_iter (self
, iter_items
);
1297 /* iterkeys() method. */
1300 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1302 return typy_make_iter (self
, iter_keys
);
1305 /* Iterating over the class, same as iterkeys except for the function
1309 typy_iter (PyObject
*self
)
1311 return typy_make_iter (self
, iter_keys
);
1314 /* itervalues() method. */
1317 typy_itervalues (PyObject
*self
, PyObject
*args
)
1319 return typy_make_iter (self
, iter_values
);
1322 /* Return a reference to the type iterator. */
1325 typy_iterator_iter (PyObject
*self
)
1331 /* Return the next field in the iteration through the list of fields
1335 typy_iterator_iternext (PyObject
*self
)
1337 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1338 struct type
*type
= iter_obj
->source
->type
;
1340 if (iter_obj
->field
< type
->num_fields ())
1342 gdbpy_ref
<> result
= make_fielditem (type
, iter_obj
->field
,
1346 return result
.release ();
1353 typy_iterator_dealloc (PyObject
*obj
)
1355 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1357 Py_DECREF (iter_obj
->source
);
1358 Py_TYPE (obj
)->tp_free (obj
);
1361 /* Create a new Type referring to TYPE. */
1363 type_to_type_object (struct type
*type
)
1365 type_object
*type_obj
;
1369 /* Try not to let stub types leak out to Python. */
1370 if (type
->is_stub ())
1371 type
= check_typedef (type
);
1375 /* Just ignore failures in check_typedef. */
1378 type_obj
= PyObject_New (type_object
, &type_object_type
);
1380 set_type (type_obj
, type
);
1382 return (PyObject
*) type_obj
;
1386 type_object_to_type (PyObject
*obj
)
1388 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1390 return ((type_object
*) obj
)->type
;
1395 /* Implementation of gdb.lookup_type. */
1397 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1399 static const char *keywords
[] = { "name", "block", NULL
};
1400 const char *type_name
= NULL
;
1401 struct type
*type
= NULL
;
1402 PyObject
*block_obj
= NULL
;
1403 const struct block
*block
= NULL
;
1405 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1406 &type_name
, &block_obj
))
1411 block
= block_object_to_block (block_obj
);
1414 PyErr_SetString (PyExc_RuntimeError
,
1415 _("'block' argument must be a Block."));
1420 type
= typy_lookup_typename (type_name
, block
);
1424 return type_to_type_object (type
);
1428 gdbpy_initialize_types (void)
1432 typy_objfile_data_key
1433 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1435 if (PyType_Ready (&type_object_type
) < 0)
1437 if (PyType_Ready (&field_object_type
) < 0)
1439 if (PyType_Ready (&type_iterator_object_type
) < 0)
1442 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1444 if (PyModule_AddIntConstant (gdb_module
, pyty_codes
[i
].name
,
1445 pyty_codes
[i
].code
) < 0)
1449 if (gdb_pymodule_addobject (gdb_module
, "Type",
1450 (PyObject
*) &type_object_type
) < 0)
1453 if (gdb_pymodule_addobject (gdb_module
, "TypeIterator",
1454 (PyObject
*) &type_iterator_object_type
) < 0)
1457 return gdb_pymodule_addobject (gdb_module
, "Field",
1458 (PyObject
*) &field_object_type
);
1463 static gdb_PyGetSetDef type_object_getset
[] =
1465 { "alignof", typy_get_alignof
, NULL
,
1466 "The alignment of this type, in bytes.", NULL
},
1467 { "code", typy_get_code
, NULL
,
1468 "The code for this type.", NULL
},
1469 { "dynamic", typy_get_dynamic
, NULL
,
1470 "Whether this type is dynamic.", NULL
},
1471 { "name", typy_get_name
, NULL
,
1472 "The name for this type, or None.", NULL
},
1473 { "sizeof", typy_get_sizeof
, NULL
,
1474 "The size of this type, in bytes.", NULL
},
1475 { "tag", typy_get_tag
, NULL
,
1476 "The tag name for this type, or None.", NULL
},
1477 { "objfile", typy_get_objfile
, NULL
,
1478 "The objfile this type was defined in, or None.", NULL
},
1482 static PyMethodDef type_object_methods
[] =
1484 { "array", typy_array
, METH_VARARGS
,
1485 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1486 Return a type which represents an array of objects of this type.\n\
1487 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1488 If LOW_BOUND is omitted, a value of zero is used." },
1489 { "vector", typy_vector
, METH_VARARGS
,
1490 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1491 Return a type which represents a vector of objects of this type.\n\
1492 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1493 If LOW_BOUND is omitted, a value of zero is used.\n\
1494 Vectors differ from arrays in that if the current language has C-style\n\
1495 arrays, vectors don't decay to a pointer to the first element.\n\
1496 They are first class values." },
1497 { "__contains__", typy_has_key
, METH_VARARGS
,
1498 "T.__contains__(k) -> True if T has a field named k, else False" },
1499 { "const", typy_const
, METH_NOARGS
,
1500 "const () -> Type\n\
1501 Return a const variant of this type." },
1502 { "optimized_out", typy_optimized_out
, METH_NOARGS
,
1503 "optimized_out() -> Value\n\
1504 Return optimized out value of this type." },
1505 { "fields", typy_fields
, METH_NOARGS
,
1506 "fields () -> list\n\
1507 Return a list holding all the fields of this type.\n\
1508 Each field is a gdb.Field object." },
1509 { "get", typy_get
, METH_VARARGS
,
1510 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1511 otherwise returns default, if supplied, or None if not." },
1512 { "has_key", typy_has_key
, METH_VARARGS
,
1513 "T.has_key(k) -> True if T has a field named k, else False" },
1514 { "items", typy_items
, METH_NOARGS
,
1515 "items () -> list\n\
1516 Return a list of (name, field) pairs of this type.\n\
1517 Each field is a gdb.Field object." },
1518 { "iteritems", typy_iteritems
, METH_NOARGS
,
1519 "iteritems () -> an iterator over the (name, field)\n\
1520 pairs of this type. Each field is a gdb.Field object." },
1521 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1522 "iterkeys () -> an iterator over the field names of this type." },
1523 { "itervalues", typy_itervalues
, METH_NOARGS
,
1524 "itervalues () -> an iterator over the fields of this type.\n\
1525 Each field is a gdb.Field object." },
1526 { "keys", typy_field_names
, METH_NOARGS
,
1528 Return a list holding all the fields names of this type." },
1529 { "pointer", typy_pointer
, METH_NOARGS
,
1530 "pointer () -> Type\n\
1531 Return a type of pointer to this type." },
1532 { "range", typy_range
, METH_NOARGS
,
1533 "range () -> tuple\n\
1534 Return a tuple containing the lower and upper range for this type."},
1535 { "reference", typy_reference
, METH_NOARGS
,
1536 "reference () -> Type\n\
1537 Return a type of reference to this type." },
1538 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1539 "strip_typedefs () -> Type\n\
1540 Return a type formed by stripping this type of all typedefs."},
1541 { "target", typy_target
, METH_NOARGS
,
1542 "target () -> Type\n\
1543 Return the target type of this type." },
1544 { "template_argument", typy_template_argument
, METH_VARARGS
,
1545 "template_argument (arg, [block]) -> Type\n\
1546 Return the type of a template argument." },
1547 { "unqualified", typy_unqualified
, METH_NOARGS
,
1548 "unqualified () -> Type\n\
1549 Return a variant of this type without const or volatile attributes." },
1550 { "values", typy_values
, METH_NOARGS
,
1551 "values () -> list\n\
1552 Return a list holding all the fields of this type.\n\
1553 Each field is a gdb.Field object." },
1554 { "volatile", typy_volatile
, METH_NOARGS
,
1555 "volatile () -> Type\n\
1556 Return a volatile variant of this type" },
1560 static PyNumberMethods type_object_as_number
= {
1562 NULL
, /* nb_subtract */
1563 NULL
, /* nb_multiply */
1565 NULL
, /* nb_divide */
1567 NULL
, /* nb_remainder */
1568 NULL
, /* nb_divmod */
1569 NULL
, /* nb_power */
1570 NULL
, /* nb_negative */
1571 NULL
, /* nb_positive */
1572 NULL
, /* nb_absolute */
1573 typy_nonzero
, /* nb_nonzero */
1574 NULL
, /* nb_invert */
1575 NULL
, /* nb_lshift */
1576 NULL
, /* nb_rshift */
1582 NULL
, /* reserved */
1584 NULL
, /* nb_coerce */
1588 NULL
, /* nb_float */
1595 static PyMappingMethods typy_mapping
= {
1598 NULL
/* no "set" method */
1601 PyTypeObject type_object_type
=
1603 PyVarObject_HEAD_INIT (NULL
, 0)
1604 "gdb.Type", /*tp_name*/
1605 sizeof (type_object
), /*tp_basicsize*/
1607 typy_dealloc
, /*tp_dealloc*/
1613 &type_object_as_number
, /*tp_as_number*/
1614 0, /*tp_as_sequence*/
1615 &typy_mapping
, /*tp_as_mapping*/
1618 typy_str
, /*tp_str*/
1622 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1623 "GDB type object", /* tp_doc */
1624 0, /* tp_traverse */
1626 typy_richcompare
, /* tp_richcompare */
1627 0, /* tp_weaklistoffset */
1628 typy_iter
, /* tp_iter */
1629 0, /* tp_iternext */
1630 type_object_methods
, /* tp_methods */
1632 type_object_getset
, /* tp_getset */
1635 0, /* tp_descr_get */
1636 0, /* tp_descr_set */
1637 0, /* tp_dictoffset */
1643 static gdb_PyGetSetDef field_object_getset
[] =
1645 { "__dict__", gdb_py_generic_dict
, NULL
,
1646 "The __dict__ for this field.", &field_object_type
},
1650 PyTypeObject field_object_type
=
1652 PyVarObject_HEAD_INIT (NULL
, 0)
1653 "gdb.Field", /*tp_name*/
1654 sizeof (field_object
), /*tp_basicsize*/
1656 field_dealloc
, /*tp_dealloc*/
1663 0, /*tp_as_sequence*/
1664 0, /*tp_as_mapping*/
1671 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1672 "GDB field object", /* tp_doc */
1673 0, /* tp_traverse */
1675 0, /* tp_richcompare */
1676 0, /* tp_weaklistoffset */
1678 0, /* tp_iternext */
1681 field_object_getset
, /* tp_getset */
1684 0, /* tp_descr_get */
1685 0, /* tp_descr_set */
1686 offsetof (field_object
, dict
), /* tp_dictoffset */
1692 PyTypeObject type_iterator_object_type
= {
1693 PyVarObject_HEAD_INIT (NULL
, 0)
1694 "gdb.TypeIterator", /*tp_name*/
1695 sizeof (typy_iterator_object
), /*tp_basicsize*/
1697 typy_iterator_dealloc
, /*tp_dealloc*/
1704 0, /*tp_as_sequence*/
1705 0, /*tp_as_mapping*/
1712 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1713 "GDB type iterator object", /*tp_doc */
1716 0, /*tp_richcompare */
1717 0, /*tp_weaklistoffset */
1718 typy_iterator_iter
, /*tp_iter */
1719 typy_iterator_iternext
, /*tp_iternext */