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 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 (type
);
423 if (objfile
== nullptr)
425 return objfile_to_objfile_object (objfile
).release ();
428 /* Return the type, stripped of typedefs. */
430 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
432 struct type
*type
= ((type_object
*) self
)->type
;
436 type
= check_typedef (type
);
438 catch (const gdb_exception
&except
)
440 GDB_PY_HANDLE_EXCEPTION (except
);
443 return type_to_type_object (type
);
446 /* Strip typedefs and pointers/reference from a type. Then check that
447 it is a struct, union, or enum type. If not, raise TypeError. */
450 typy_get_composite (struct type
*type
)
457 type
= check_typedef (type
);
459 catch (const gdb_exception
&except
)
461 GDB_PY_HANDLE_EXCEPTION (except
);
464 if (type
->code () != TYPE_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_FUNC
)
476 PyErr_SetString (PyExc_TypeError
,
477 "Type is not a structure, union, enum, or function type.");
484 /* Helper for typy_array and typy_vector. */
487 typy_array_1 (PyObject
*self
, PyObject
*args
, int is_vector
)
490 PyObject
*n2_obj
= NULL
;
491 struct type
*array
= NULL
;
492 struct type
*type
= ((type_object
*) self
)->type
;
494 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
499 if (!PyInt_Check (n2_obj
))
501 PyErr_SetString (PyExc_RuntimeError
,
502 _("Array bound must be an integer"));
506 if (! gdb_py_int_as_long (n2_obj
, &n2
))
515 if (n2
< n1
- 1) /* Note: An empty array has n2 == n1 - 1. */
517 PyErr_SetString (PyExc_ValueError
,
518 _("Array length must not be negative"));
524 array
= lookup_array_range_type (type
, n1
, n2
);
526 make_vector_type (array
);
528 catch (const gdb_exception
&except
)
530 GDB_PY_HANDLE_EXCEPTION (except
);
533 return type_to_type_object (array
);
536 /* Return an array type. */
539 typy_array (PyObject
*self
, PyObject
*args
)
541 return typy_array_1 (self
, args
, 0);
544 /* Return a vector type. */
547 typy_vector (PyObject
*self
, PyObject
*args
)
549 return typy_array_1 (self
, args
, 1);
552 /* Return a Type object which represents a pointer to SELF. */
554 typy_pointer (PyObject
*self
, PyObject
*args
)
556 struct type
*type
= ((type_object
*) self
)->type
;
560 type
= lookup_pointer_type (type
);
562 catch (const gdb_exception
&except
)
564 GDB_PY_HANDLE_EXCEPTION (except
);
567 return type_to_type_object (type
);
570 /* Return the range of a type represented by SELF. The return type is
571 a tuple. The first element of the tuple contains the low bound,
572 while the second element of the tuple contains the high bound. */
574 typy_range (PyObject
*self
, PyObject
*args
)
576 struct type
*type
= ((type_object
*) self
)->type
;
577 /* Initialize these to appease GCC warnings. */
578 LONGEST low
= 0, high
= 0;
580 if (type
->code () != TYPE_CODE_ARRAY
581 && type
->code () != TYPE_CODE_STRING
582 && type
->code () != TYPE_CODE_RANGE
)
584 PyErr_SetString (PyExc_RuntimeError
,
585 _("This type does not have a range."));
589 switch (type
->code ())
591 case TYPE_CODE_ARRAY
:
592 case TYPE_CODE_STRING
:
593 case TYPE_CODE_RANGE
:
594 low
= type
->bounds ()->low
.const_val ();
595 high
= type
->bounds ()->high
.const_val ();;
599 gdbpy_ref
<> low_bound
= gdb_py_object_from_longest (low
);
600 if (low_bound
== NULL
)
603 gdbpy_ref
<> high_bound
= gdb_py_object_from_longest (high
);
604 if (high_bound
== NULL
)
607 gdbpy_ref
<> result (PyTuple_New (2));
611 if (PyTuple_SetItem (result
.get (), 0, low_bound
.release ()) != 0
612 || PyTuple_SetItem (result
.get (), 1, high_bound
.release ()) != 0)
614 return result
.release ();
617 /* Return a Type object which represents a reference to SELF. */
619 typy_reference (PyObject
*self
, PyObject
*args
)
621 struct type
*type
= ((type_object
*) self
)->type
;
625 type
= lookup_lvalue_reference_type (type
);
627 catch (const gdb_exception
&except
)
629 GDB_PY_HANDLE_EXCEPTION (except
);
632 return type_to_type_object (type
);
635 /* Return a Type object which represents the target type of SELF. */
637 typy_target (PyObject
*self
, PyObject
*args
)
639 struct type
*type
= ((type_object
*) self
)->type
;
641 if (!TYPE_TARGET_TYPE (type
))
643 PyErr_SetString (PyExc_RuntimeError
,
644 _("Type does not have a target."));
648 return type_to_type_object (TYPE_TARGET_TYPE (type
));
651 /* Return a const-qualified type variant. */
653 typy_const (PyObject
*self
, PyObject
*args
)
655 struct type
*type
= ((type_object
*) self
)->type
;
659 type
= make_cv_type (1, 0, type
, NULL
);
661 catch (const gdb_exception
&except
)
663 GDB_PY_HANDLE_EXCEPTION (except
);
666 return type_to_type_object (type
);
669 /* Return a volatile-qualified type variant. */
671 typy_volatile (PyObject
*self
, PyObject
*args
)
673 struct type
*type
= ((type_object
*) self
)->type
;
677 type
= make_cv_type (0, 1, type
, NULL
);
679 catch (const gdb_exception
&except
)
681 GDB_PY_HANDLE_EXCEPTION (except
);
684 return type_to_type_object (type
);
687 /* Return an unqualified type variant. */
689 typy_unqualified (PyObject
*self
, PyObject
*args
)
691 struct type
*type
= ((type_object
*) self
)->type
;
695 type
= make_cv_type (0, 0, type
, NULL
);
697 catch (const gdb_exception
&except
)
699 GDB_PY_HANDLE_EXCEPTION (except
);
702 return type_to_type_object (type
);
705 /* Return the size of the type represented by SELF, in bytes. */
707 typy_get_sizeof (PyObject
*self
, void *closure
)
709 struct type
*type
= ((type_object
*) self
)->type
;
711 bool size_varies
= false;
714 check_typedef (type
);
716 size_varies
= TYPE_HAS_DYNAMIC_LENGTH (type
);
718 catch (const gdb_exception
&except
)
722 /* Ignore exceptions. */
726 return gdb_py_object_from_longest (TYPE_LENGTH (type
)).release ();
729 /* Return the alignment of the type represented by SELF, in bytes. */
731 typy_get_alignof (PyObject
*self
, void *closure
)
733 struct type
*type
= ((type_object
*) self
)->type
;
738 align
= type_align (type
);
740 catch (const gdb_exception
&except
)
745 /* Ignore exceptions. */
747 return gdb_py_object_from_ulongest (align
).release ();
750 /* Return whether or not the type is dynamic. */
752 typy_get_dynamic (PyObject
*self
, void *closure
)
754 struct type
*type
= ((type_object
*) self
)->type
;
759 result
= is_dynamic_type (type
);
761 catch (const gdb_exception
&except
)
763 /* Ignore exceptions. */
772 typy_lookup_typename (const char *type_name
, const struct block
*block
)
774 struct type
*type
= NULL
;
778 if (startswith (type_name
, "struct "))
779 type
= lookup_struct (type_name
+ 7, NULL
);
780 else if (startswith (type_name
, "union "))
781 type
= lookup_union (type_name
+ 6, NULL
);
782 else if (startswith (type_name
, "enum "))
783 type
= lookup_enum (type_name
+ 5, NULL
);
785 type
= lookup_typename (python_language
,
786 type_name
, block
, 0);
788 catch (const gdb_exception
&except
)
790 GDB_PY_HANDLE_EXCEPTION (except
);
797 typy_lookup_type (struct demangle_component
*demangled
,
798 const struct block
*block
)
800 struct type
*type
, *rtype
= NULL
;
801 enum demangle_component_type demangled_type
;
803 /* Save the type: typy_lookup_type() may (indirectly) overwrite
804 memory pointed by demangled. */
805 demangled_type
= demangled
->type
;
807 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
808 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
809 || demangled_type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE
810 || demangled_type
== DEMANGLE_COMPONENT_CONST
811 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
813 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
819 /* If the demangled_type matches with one of the types
820 below, run the corresponding function and save the type
821 to return later. We cannot just return here as we are in
822 an exception handler. */
823 switch (demangled_type
)
825 case DEMANGLE_COMPONENT_REFERENCE
:
826 rtype
= lookup_lvalue_reference_type (type
);
828 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
829 rtype
= lookup_rvalue_reference_type (type
);
831 case DEMANGLE_COMPONENT_POINTER
:
832 rtype
= lookup_pointer_type (type
);
834 case DEMANGLE_COMPONENT_CONST
:
835 rtype
= make_cv_type (1, 0, type
, NULL
);
837 case DEMANGLE_COMPONENT_VOLATILE
:
838 rtype
= make_cv_type (0, 1, type
, NULL
);
842 catch (const gdb_exception
&except
)
844 GDB_PY_HANDLE_EXCEPTION (except
);
848 /* If we have a type from the switch statement above, just return
853 /* We don't have a type, so lookup the type. */
854 gdb::unique_xmalloc_ptr
<char> type_name
= cp_comp_to_string (demangled
, 10);
855 return typy_lookup_typename (type_name
.get (), block
);
858 /* This is a helper function for typy_template_argument that is used
859 when the type does not have template symbols attached. It works by
860 parsing the type name. This happens with compilers, like older
861 versions of GCC, that do not emit DW_TAG_template_*. */
864 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
868 struct demangle_component
*demangled
;
869 std::unique_ptr
<demangle_parse_info
> info
;
871 struct type
*argtype
;
873 if (type
->name () == NULL
)
875 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
881 /* Note -- this is not thread-safe. */
882 info
= cp_demangled_name_to_comp (type
->name (), &err
);
884 catch (const gdb_exception
&except
)
886 GDB_PY_HANDLE_EXCEPTION (except
);
891 PyErr_SetString (PyExc_RuntimeError
, err
.c_str ());
894 demangled
= info
->tree
;
896 /* Strip off component names. */
897 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
898 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
899 demangled
= demangled
->u
.s_binary
.right
;
901 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
903 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
907 /* Skip from the template to the arguments. */
908 demangled
= demangled
->u
.s_binary
.right
;
910 for (i
= 0; demangled
&& i
< argno
; ++i
)
911 demangled
= demangled
->u
.s_binary
.right
;
915 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
920 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
924 return type_to_type_object (argtype
);
928 typy_template_argument (PyObject
*self
, PyObject
*args
)
931 struct type
*type
= ((type_object
*) self
)->type
;
932 const struct block
*block
= NULL
;
933 PyObject
*block_obj
= NULL
;
935 struct value
*val
= NULL
;
937 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
942 PyErr_SetString (PyExc_RuntimeError
,
943 _("Template argument number must be non-negative"));
949 block
= block_object_to_block (block_obj
);
952 PyErr_SetString (PyExc_RuntimeError
,
953 _("Second argument must be block."));
960 type
= check_typedef (type
);
961 if (TYPE_IS_REFERENCE (type
))
962 type
= check_typedef (TYPE_TARGET_TYPE (type
));
964 catch (const gdb_exception
&except
)
966 GDB_PY_HANDLE_EXCEPTION (except
);
969 /* We might not have DW_TAG_template_*, so try to parse the type's
970 name. This is inefficient if we do not have a template type --
971 but that is going to wind up as an error anyhow. */
972 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
973 return typy_legacy_template_argument (type
, block
, argno
);
975 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
977 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
982 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
983 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
984 return type_to_type_object (SYMBOL_TYPE (sym
));
985 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
987 PyErr_Format (PyExc_RuntimeError
,
988 _("Template argument is optimized out"));
994 val
= value_of_variable (sym
, block
);
996 catch (const gdb_exception
&except
)
998 GDB_PY_HANDLE_EXCEPTION (except
);
1001 return value_to_value_object (val
);
1005 typy_str (PyObject
*self
)
1007 string_file thetype
;
1011 LA_PRINT_TYPE (type_object_to_type (self
), "", &thetype
, -1, 0,
1012 &type_print_raw_options
);
1014 catch (const gdb_exception
&except
)
1016 GDB_PY_HANDLE_EXCEPTION (except
);
1019 return PyUnicode_Decode (thetype
.c_str (), thetype
.size (),
1020 host_charset (), NULL
);
1023 /* Implement the richcompare method. */
1026 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1028 bool result
= false;
1029 struct type
*type1
= type_object_to_type (self
);
1030 struct type
*type2
= type_object_to_type (other
);
1032 /* We can only compare ourselves to another Type object, and only
1033 for equality or inequality. */
1034 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
1036 Py_INCREF (Py_NotImplemented
);
1037 return Py_NotImplemented
;
1046 result
= types_deeply_equal (type1
, type2
);
1048 catch (const gdb_exception
&except
)
1050 /* If there is a GDB exception, a comparison is not capable
1051 (or trusted), so exit. */
1052 GDB_PY_HANDLE_EXCEPTION (except
);
1056 if (op
== (result
? Py_EQ
: Py_NE
))
1063 static const struct objfile_data
*typy_objfile_data_key
;
1066 save_objfile_types (struct objfile
*objfile
, void *datum
)
1068 type_object
*obj
= (type_object
*) datum
;
1069 htab_t copied_types
;
1071 if (!gdb_python_initialized
)
1074 /* This prevents another thread from freeing the objects we're
1076 gdbpy_enter
enter_py (objfile
->arch (), current_language
);
1078 copied_types
= create_copied_types_hash (objfile
);
1082 type_object
*next
= obj
->next
;
1084 htab_empty (copied_types
);
1086 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1094 htab_delete (copied_types
);
1098 set_type (type_object
*obj
, struct type
*type
)
1102 if (type
&& TYPE_OBJFILE (type
))
1104 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1106 obj
->next
= ((struct pyty_type_object
*)
1107 objfile_data (objfile
, typy_objfile_data_key
));
1109 obj
->next
->prev
= obj
;
1110 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1117 typy_dealloc (PyObject
*obj
)
1119 type_object
*type
= (type_object
*) obj
;
1122 type
->prev
->next
= type
->next
;
1123 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1125 /* Must reset head of list. */
1126 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1129 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1132 type
->next
->prev
= type
->prev
;
1134 Py_TYPE (type
)->tp_free (type
);
1137 /* Return number of fields ("length" of the field dictionary). */
1140 typy_length (PyObject
*self
)
1142 struct type
*type
= ((type_object
*) self
)->type
;
1144 type
= typy_get_composite (type
);
1148 return type
->num_fields ();
1151 /* Implements boolean evaluation of gdb.Type. Handle this like other
1152 Python objects that don't have a meaningful truth value -- all
1156 typy_nonzero (PyObject
*self
)
1161 /* Return optimized out value of this type. */
1164 typy_optimized_out (PyObject
*self
, PyObject
*args
)
1166 struct type
*type
= ((type_object
*) self
)->type
;
1168 return value_to_value_object (allocate_optimized_out_value (type
));
1171 /* Return a gdb.Field object for the field named by the argument. */
1174 typy_getitem (PyObject
*self
, PyObject
*key
)
1176 struct type
*type
= ((type_object
*) self
)->type
;
1179 gdb::unique_xmalloc_ptr
<char> field
= python_string_to_host_string (key
);
1183 /* We want just fields of this type, not of base types, so instead of
1184 using lookup_struct_elt_type, portions of that function are
1187 type
= typy_get_composite (type
);
1191 for (i
= 0; i
< type
->num_fields (); i
++)
1193 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1195 if (t_field_name
&& (strcmp_iw (t_field_name
, field
.get ()) == 0))
1196 return convert_field (type
, i
).release ();
1198 PyErr_SetObject (PyExc_KeyError
, key
);
1202 /* Implement the "get" method on the type object. This is the
1203 same as getitem if the key is present, but returns the supplied
1204 default value or None if the key is not found. */
1207 typy_get (PyObject
*self
, PyObject
*args
)
1209 PyObject
*key
, *defval
= Py_None
, *result
;
1211 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1214 result
= typy_getitem (self
, key
);
1218 /* typy_getitem returned error status. If the exception is
1219 KeyError, clear the exception status and return the defval
1220 instead. Otherwise return the exception unchanged. */
1221 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1229 /* Implement the "has_key" method on the type object. */
1232 typy_has_key (PyObject
*self
, PyObject
*args
)
1234 struct type
*type
= ((type_object
*) self
)->type
;
1238 if (!PyArg_ParseTuple (args
, "s", &field
))
1241 /* We want just fields of this type, not of base types, so instead of
1242 using lookup_struct_elt_type, portions of that function are
1245 type
= typy_get_composite (type
);
1249 for (i
= 0; i
< type
->num_fields (); i
++)
1251 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1253 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1259 /* Make an iterator object to iterate over keys, values, or items. */
1262 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1264 typy_iterator_object
*typy_iter_obj
;
1266 /* Check that "self" is a structure or union type. */
1267 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1270 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1271 &type_iterator_object_type
);
1272 if (typy_iter_obj
== NULL
)
1275 typy_iter_obj
->field
= 0;
1276 typy_iter_obj
->kind
= kind
;
1278 typy_iter_obj
->source
= (type_object
*) self
;
1280 return (PyObject
*) typy_iter_obj
;
1283 /* iteritems() method. */
1286 typy_iteritems (PyObject
*self
, PyObject
*args
)
1288 return typy_make_iter (self
, iter_items
);
1291 /* iterkeys() method. */
1294 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1296 return typy_make_iter (self
, iter_keys
);
1299 /* Iterating over the class, same as iterkeys except for the function
1303 typy_iter (PyObject
*self
)
1305 return typy_make_iter (self
, iter_keys
);
1308 /* itervalues() method. */
1311 typy_itervalues (PyObject
*self
, PyObject
*args
)
1313 return typy_make_iter (self
, iter_values
);
1316 /* Return a reference to the type iterator. */
1319 typy_iterator_iter (PyObject
*self
)
1325 /* Return the next field in the iteration through the list of fields
1329 typy_iterator_iternext (PyObject
*self
)
1331 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1332 struct type
*type
= iter_obj
->source
->type
;
1334 if (iter_obj
->field
< type
->num_fields ())
1336 gdbpy_ref
<> result
= make_fielditem (type
, iter_obj
->field
,
1340 return result
.release ();
1347 typy_iterator_dealloc (PyObject
*obj
)
1349 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1351 Py_DECREF (iter_obj
->source
);
1352 Py_TYPE (obj
)->tp_free (obj
);
1355 /* Create a new Type referring to TYPE. */
1357 type_to_type_object (struct type
*type
)
1359 type_object
*type_obj
;
1363 /* Try not to let stub types leak out to Python. */
1364 if (type
->is_stub ())
1365 type
= check_typedef (type
);
1369 /* Just ignore failures in check_typedef. */
1372 type_obj
= PyObject_New (type_object
, &type_object_type
);
1374 set_type (type_obj
, type
);
1376 return (PyObject
*) type_obj
;
1380 type_object_to_type (PyObject
*obj
)
1382 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1384 return ((type_object
*) obj
)->type
;
1389 /* Implementation of gdb.lookup_type. */
1391 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1393 static const char *keywords
[] = { "name", "block", NULL
};
1394 const char *type_name
= NULL
;
1395 struct type
*type
= NULL
;
1396 PyObject
*block_obj
= NULL
;
1397 const struct block
*block
= NULL
;
1399 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1400 &type_name
, &block_obj
))
1405 block
= block_object_to_block (block_obj
);
1408 PyErr_SetString (PyExc_RuntimeError
,
1409 _("'block' argument must be a Block."));
1414 type
= typy_lookup_typename (type_name
, block
);
1418 return type_to_type_object (type
);
1422 gdbpy_initialize_types (void)
1426 typy_objfile_data_key
1427 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1429 if (PyType_Ready (&type_object_type
) < 0)
1431 if (PyType_Ready (&field_object_type
) < 0)
1433 if (PyType_Ready (&type_iterator_object_type
) < 0)
1436 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1438 if (PyModule_AddIntConstant (gdb_module
, pyty_codes
[i
].name
,
1439 pyty_codes
[i
].code
) < 0)
1443 if (gdb_pymodule_addobject (gdb_module
, "Type",
1444 (PyObject
*) &type_object_type
) < 0)
1447 if (gdb_pymodule_addobject (gdb_module
, "TypeIterator",
1448 (PyObject
*) &type_iterator_object_type
) < 0)
1451 return gdb_pymodule_addobject (gdb_module
, "Field",
1452 (PyObject
*) &field_object_type
);
1457 static gdb_PyGetSetDef type_object_getset
[] =
1459 { "alignof", typy_get_alignof
, NULL
,
1460 "The alignment of this type, in bytes.", NULL
},
1461 { "code", typy_get_code
, NULL
,
1462 "The code for this type.", NULL
},
1463 { "dynamic", typy_get_dynamic
, NULL
,
1464 "Whether this type is dynamic.", NULL
},
1465 { "name", typy_get_name
, NULL
,
1466 "The name for this type, or None.", NULL
},
1467 { "sizeof", typy_get_sizeof
, NULL
,
1468 "The size of this type, in bytes.", NULL
},
1469 { "tag", typy_get_tag
, NULL
,
1470 "The tag name for this type, or None.", NULL
},
1471 { "objfile", typy_get_objfile
, NULL
,
1472 "The objfile this type was defined in, or None.", NULL
},
1476 static PyMethodDef type_object_methods
[] =
1478 { "array", typy_array
, METH_VARARGS
,
1479 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1480 Return a type which represents an array of objects of this type.\n\
1481 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1482 If LOW_BOUND is omitted, a value of zero is used." },
1483 { "vector", typy_vector
, METH_VARARGS
,
1484 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1485 Return a type which represents a vector 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.\n\
1488 Vectors differ from arrays in that if the current language has C-style\n\
1489 arrays, vectors don't decay to a pointer to the first element.\n\
1490 They are first class values." },
1491 { "__contains__", typy_has_key
, METH_VARARGS
,
1492 "T.__contains__(k) -> True if T has a field named k, else False" },
1493 { "const", typy_const
, METH_NOARGS
,
1494 "const () -> Type\n\
1495 Return a const variant of this type." },
1496 { "optimized_out", typy_optimized_out
, METH_NOARGS
,
1497 "optimized_out() -> Value\n\
1498 Return optimized out value of this type." },
1499 { "fields", typy_fields
, METH_NOARGS
,
1500 "fields () -> list\n\
1501 Return a list holding all the fields of this type.\n\
1502 Each field is a gdb.Field object." },
1503 { "get", typy_get
, METH_VARARGS
,
1504 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1505 otherwise returns default, if supplied, or None if not." },
1506 { "has_key", typy_has_key
, METH_VARARGS
,
1507 "T.has_key(k) -> True if T has a field named k, else False" },
1508 { "items", typy_items
, METH_NOARGS
,
1509 "items () -> list\n\
1510 Return a list of (name, field) pairs of this type.\n\
1511 Each field is a gdb.Field object." },
1512 { "iteritems", typy_iteritems
, METH_NOARGS
,
1513 "iteritems () -> an iterator over the (name, field)\n\
1514 pairs of this type. Each field is a gdb.Field object." },
1515 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1516 "iterkeys () -> an iterator over the field names of this type." },
1517 { "itervalues", typy_itervalues
, METH_NOARGS
,
1518 "itervalues () -> an iterator over the fields of this type.\n\
1519 Each field is a gdb.Field object." },
1520 { "keys", typy_field_names
, METH_NOARGS
,
1522 Return a list holding all the fields names of this type." },
1523 { "pointer", typy_pointer
, METH_NOARGS
,
1524 "pointer () -> Type\n\
1525 Return a type of pointer to this type." },
1526 { "range", typy_range
, METH_NOARGS
,
1527 "range () -> tuple\n\
1528 Return a tuple containing the lower and upper range for this type."},
1529 { "reference", typy_reference
, METH_NOARGS
,
1530 "reference () -> Type\n\
1531 Return a type of reference to this type." },
1532 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1533 "strip_typedefs () -> Type\n\
1534 Return a type formed by stripping this type of all typedefs."},
1535 { "target", typy_target
, METH_NOARGS
,
1536 "target () -> Type\n\
1537 Return the target type of this type." },
1538 { "template_argument", typy_template_argument
, METH_VARARGS
,
1539 "template_argument (arg, [block]) -> Type\n\
1540 Return the type of a template argument." },
1541 { "unqualified", typy_unqualified
, METH_NOARGS
,
1542 "unqualified () -> Type\n\
1543 Return a variant of this type without const or volatile attributes." },
1544 { "values", typy_values
, METH_NOARGS
,
1545 "values () -> list\n\
1546 Return a list holding all the fields of this type.\n\
1547 Each field is a gdb.Field object." },
1548 { "volatile", typy_volatile
, METH_NOARGS
,
1549 "volatile () -> Type\n\
1550 Return a volatile variant of this type" },
1554 static PyNumberMethods type_object_as_number
= {
1556 NULL
, /* nb_subtract */
1557 NULL
, /* nb_multiply */
1559 NULL
, /* nb_divide */
1561 NULL
, /* nb_remainder */
1562 NULL
, /* nb_divmod */
1563 NULL
, /* nb_power */
1564 NULL
, /* nb_negative */
1565 NULL
, /* nb_positive */
1566 NULL
, /* nb_absolute */
1567 typy_nonzero
, /* nb_nonzero */
1568 NULL
, /* nb_invert */
1569 NULL
, /* nb_lshift */
1570 NULL
, /* nb_rshift */
1576 NULL
, /* reserved */
1578 NULL
, /* nb_coerce */
1582 NULL
, /* nb_float */
1589 static PyMappingMethods typy_mapping
= {
1592 NULL
/* no "set" method */
1595 PyTypeObject type_object_type
=
1597 PyVarObject_HEAD_INIT (NULL
, 0)
1598 "gdb.Type", /*tp_name*/
1599 sizeof (type_object
), /*tp_basicsize*/
1601 typy_dealloc
, /*tp_dealloc*/
1607 &type_object_as_number
, /*tp_as_number*/
1608 0, /*tp_as_sequence*/
1609 &typy_mapping
, /*tp_as_mapping*/
1612 typy_str
, /*tp_str*/
1616 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1617 "GDB type object", /* tp_doc */
1618 0, /* tp_traverse */
1620 typy_richcompare
, /* tp_richcompare */
1621 0, /* tp_weaklistoffset */
1622 typy_iter
, /* tp_iter */
1623 0, /* tp_iternext */
1624 type_object_methods
, /* tp_methods */
1626 type_object_getset
, /* tp_getset */
1629 0, /* tp_descr_get */
1630 0, /* tp_descr_set */
1631 0, /* tp_dictoffset */
1637 static gdb_PyGetSetDef field_object_getset
[] =
1639 { "__dict__", gdb_py_generic_dict
, NULL
,
1640 "The __dict__ for this field.", &field_object_type
},
1644 PyTypeObject field_object_type
=
1646 PyVarObject_HEAD_INIT (NULL
, 0)
1647 "gdb.Field", /*tp_name*/
1648 sizeof (field_object
), /*tp_basicsize*/
1650 field_dealloc
, /*tp_dealloc*/
1657 0, /*tp_as_sequence*/
1658 0, /*tp_as_mapping*/
1665 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1666 "GDB field object", /* tp_doc */
1667 0, /* tp_traverse */
1669 0, /* tp_richcompare */
1670 0, /* tp_weaklistoffset */
1672 0, /* tp_iternext */
1675 field_object_getset
, /* tp_getset */
1678 0, /* tp_descr_get */
1679 0, /* tp_descr_set */
1680 offsetof (field_object
, dict
), /* tp_dictoffset */
1686 PyTypeObject type_iterator_object_type
= {
1687 PyVarObject_HEAD_INIT (NULL
, 0)
1688 "gdb.TypeIterator", /*tp_name*/
1689 sizeof (typy_iterator_object
), /*tp_basicsize*/
1691 typy_iterator_dealloc
, /*tp_dealloc*/
1698 0, /*tp_as_sequence*/
1699 0, /*tp_as_mapping*/
1706 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1707 "GDB type iterator object", /*tp_doc */
1710 0, /*tp_richcompare */
1711 0, /*tp_weaklistoffset */
1712 typy_iterator_iter
, /*tp_iter */
1713 typy_iterator_iternext
, /*tp_iternext */