1 /* Python interface to types.
3 Copyright (C) 2008-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "python-internal.h"
25 #include "cp-support.h"
29 #include "common/vec.h"
30 #include "typeprint.h"
32 typedef struct pyty_type_object
37 /* If a Type object is associated with an objfile, it is kept on a
38 doubly-linked list, rooted in the objfile. This lets us copy the
39 underlying struct type when the objfile is deleted. */
40 struct pyty_type_object
*prev
;
41 struct pyty_type_object
*next
;
44 extern PyTypeObject type_object_type
45 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("type_object");
48 typedef struct pyty_field_object
52 /* Dictionary holding our attributes. */
56 extern PyTypeObject field_object_type
57 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("field_object");
59 /* A type iterator object. */
62 /* The current field index. */
65 enum gdbpy_iter_kind kind
;
66 /* Pointer back to the original source type object. */
67 struct pyty_type_object
*source
;
68 } typy_iterator_object
;
70 extern PyTypeObject type_iterator_object_type
71 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("typy_iterator_object");
73 /* This is used to initialize various gdb.TYPE_ constants. */
82 /* Forward declarations. */
83 static PyObject
*typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
);
85 #define ENTRY(X) { X, #X }
87 static struct pyty_code pyty_codes
[] =
89 ENTRY (TYPE_CODE_BITSTRING
),
90 ENTRY (TYPE_CODE_PTR
),
91 ENTRY (TYPE_CODE_ARRAY
),
92 ENTRY (TYPE_CODE_STRUCT
),
93 ENTRY (TYPE_CODE_UNION
),
94 ENTRY (TYPE_CODE_ENUM
),
95 ENTRY (TYPE_CODE_FLAGS
),
96 ENTRY (TYPE_CODE_FUNC
),
97 ENTRY (TYPE_CODE_INT
),
98 ENTRY (TYPE_CODE_FLT
),
99 ENTRY (TYPE_CODE_VOID
),
100 ENTRY (TYPE_CODE_SET
),
101 ENTRY (TYPE_CODE_RANGE
),
102 ENTRY (TYPE_CODE_STRING
),
103 ENTRY (TYPE_CODE_ERROR
),
104 ENTRY (TYPE_CODE_METHOD
),
105 ENTRY (TYPE_CODE_METHODPTR
),
106 ENTRY (TYPE_CODE_MEMBERPTR
),
107 ENTRY (TYPE_CODE_REF
),
108 ENTRY (TYPE_CODE_RVALUE_REF
),
109 ENTRY (TYPE_CODE_CHAR
),
110 ENTRY (TYPE_CODE_BOOL
),
111 ENTRY (TYPE_CODE_COMPLEX
),
112 ENTRY (TYPE_CODE_TYPEDEF
),
113 ENTRY (TYPE_CODE_NAMESPACE
),
114 ENTRY (TYPE_CODE_DECFLOAT
),
115 ENTRY (TYPE_CODE_INTERNAL_FUNCTION
),
116 { TYPE_CODE_UNDEF
, NULL
}
122 field_dealloc (PyObject
*obj
)
124 field_object
*f
= (field_object
*) obj
;
126 Py_XDECREF (f
->dict
);
127 Py_TYPE (obj
)->tp_free (obj
);
133 gdbpy_ref
<field_object
> result (PyObject_New (field_object
,
134 &field_object_type
));
138 result
->dict
= PyDict_New ();
142 return (PyObject
*) result
.release ();
147 /* Return true if OBJ is of type gdb.Field, false otherwise. */
150 gdbpy_is_field (PyObject
*obj
)
152 return PyObject_TypeCheck (obj
, &field_object_type
);
155 /* Return the code for this type. */
157 typy_get_code (PyObject
*self
, void *closure
)
159 struct type
*type
= ((type_object
*) self
)->type
;
161 return PyInt_FromLong (TYPE_CODE (type
));
164 /* Helper function for typy_fields which converts a single field to a
165 gdb.Field object. Returns NULL on error. */
168 convert_field (struct type
*type
, int field
)
170 gdbpy_ref
<> result (field_new ());
175 gdbpy_ref
<> arg (type_to_type_object (type
));
178 if (PyObject_SetAttrString (result
.get (), "parent_type", arg
.get ()) < 0)
181 if (!field_is_static (&TYPE_FIELD (type
, field
)))
183 const char *attrstring
;
185 if (TYPE_CODE (type
) == TYPE_CODE_ENUM
)
187 arg
.reset (gdb_py_long_from_longest (TYPE_FIELD_ENUMVAL (type
,
189 attrstring
= "enumval";
193 arg
.reset (gdb_py_long_from_longest (TYPE_FIELD_BITPOS (type
,
195 attrstring
= "bitpos";
201 if (PyObject_SetAttrString (result
.get (), attrstring
, arg
.get ()) < 0)
206 if (TYPE_FIELD_NAME (type
, field
))
208 const char *field_name
= TYPE_FIELD_NAME (type
, field
);
210 if (field_name
[0] != '\0')
212 arg
.reset (PyString_FromString (TYPE_FIELD_NAME (type
, field
)));
218 arg
= gdbpy_ref
<>::new_reference (Py_None
);
220 if (PyObject_SetAttrString (result
.get (), "name", arg
.get ()) < 0)
223 arg
= gdbpy_ref
<>::new_reference (TYPE_FIELD_ARTIFICIAL (type
, field
)
224 ? Py_True
: Py_False
);
225 if (PyObject_SetAttrString (result
.get (), "artificial", arg
.get ()) < 0)
228 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
229 arg
= gdbpy_ref
<>::new_reference (field
< TYPE_N_BASECLASSES (type
)
230 ? Py_True
: Py_False
);
232 arg
= gdbpy_ref
<>::new_reference (Py_False
);
233 if (PyObject_SetAttrString (result
.get (), "is_base_class", arg
.get ()) < 0)
236 arg
.reset (PyLong_FromLong (TYPE_FIELD_BITSIZE (type
, field
)));
239 if (PyObject_SetAttrString (result
.get (), "bitsize", arg
.get ()) < 0)
242 /* A field can have a NULL type in some situations. */
243 if (TYPE_FIELD_TYPE (type
, field
) == NULL
)
244 arg
= gdbpy_ref
<>::new_reference (Py_None
);
246 arg
.reset (type_to_type_object (TYPE_FIELD_TYPE (type
, field
)));
249 if (PyObject_SetAttrString (result
.get (), "type", arg
.get ()) < 0)
255 /* Helper function to return the name of a field, as a gdb.Field object.
256 If the field doesn't have a name, None is returned. */
259 field_name (struct type
*type
, int field
)
263 if (TYPE_FIELD_NAME (type
, field
))
264 result
.reset (PyString_FromString (TYPE_FIELD_NAME (type
, field
)));
266 result
= gdbpy_ref
<>::new_reference (Py_None
);
271 /* Helper function for Type standard mapping methods. Returns a
272 Python object for field i of the type. "kind" specifies what to
273 return: the name of the field, a gdb.Field object corresponding to
274 the field, or a tuple consisting of field name and gdb.Field
278 make_fielditem (struct type
*type
, int i
, enum gdbpy_iter_kind kind
)
284 gdbpy_ref
<> key (field_name (type
, i
));
287 gdbpy_ref
<> value
= convert_field (type
, i
);
290 gdbpy_ref
<> item (PyTuple_New (2));
293 PyTuple_SET_ITEM (item
.get (), 0, key
.release ());
294 PyTuple_SET_ITEM (item
.get (), 1, value
.release ());
298 return field_name (type
, i
);
300 return convert_field (type
, i
);
302 gdb_assert_not_reached ("invalid gdbpy_iter_kind");
305 /* Return a sequence of all field names, fields, or (name, field) pairs.
306 Each field is a gdb.Field object. */
309 typy_fields_items (PyObject
*self
, enum gdbpy_iter_kind kind
)
311 PyObject
*py_type
= self
;
312 struct type
*type
= ((type_object
*) py_type
)->type
;
313 struct type
*checked_type
= type
;
317 checked_type
= check_typedef (checked_type
);
319 CATCH (except
, RETURN_MASK_ALL
)
321 GDB_PY_HANDLE_EXCEPTION (except
);
325 gdbpy_ref
<> type_holder
;
326 if (checked_type
!= type
)
328 type_holder
.reset (type_to_type_object (checked_type
));
329 if (type_holder
== nullptr)
331 py_type
= type_holder
.get ();
333 gdbpy_ref
<> iter (typy_make_iter (py_type
, kind
));
337 return PySequence_List (iter
.get ());
340 /* Return a sequence of all fields. Each field is a gdb.Field object. */
343 typy_values (PyObject
*self
, PyObject
*args
)
345 return typy_fields_items (self
, iter_values
);
348 /* Return a sequence of all fields. Each field is a gdb.Field object.
349 This method is similar to typy_values, except where the supplied
350 gdb.Type is an array, in which case it returns a list of one entry
351 which is a gdb.Field object for a range (the array bounds). */
354 typy_fields (PyObject
*self
, PyObject
*args
)
356 struct type
*type
= ((type_object
*) self
)->type
;
358 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
359 return typy_fields_items (self
, iter_values
);
361 /* Array type. Handle this as a special case because the common
362 machinery wants struct or union or enum types. Build a list of
363 one entry which is the range for the array. */
364 gdbpy_ref
<> r
= convert_field (type
, 0);
368 return Py_BuildValue ("[O]", r
.get ());
371 /* Return a sequence of all field names. Each field is a gdb.Field object. */
374 typy_field_names (PyObject
*self
, PyObject
*args
)
376 return typy_fields_items (self
, iter_keys
);
379 /* Return a sequence of all (name, fields) pairs. Each field is a
383 typy_items (PyObject
*self
, PyObject
*args
)
385 return typy_fields_items (self
, iter_items
);
388 /* Return the type's name, or None. */
391 typy_get_name (PyObject
*self
, void *closure
)
393 struct type
*type
= ((type_object
*) self
)->type
;
395 if (TYPE_NAME (type
) == NULL
)
397 return PyString_FromString (TYPE_NAME (type
));
400 /* Return the type's tag, or None. */
402 typy_get_tag (PyObject
*self
, void *closure
)
404 struct type
*type
= ((type_object
*) self
)->type
;
405 const char *tagname
= nullptr;
407 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
408 || TYPE_CODE (type
) == TYPE_CODE_UNION
409 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
410 tagname
= TYPE_NAME (type
);
412 if (tagname
== nullptr)
414 return PyString_FromString (tagname
);
417 /* Return the type, stripped of typedefs. */
419 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
421 struct type
*type
= ((type_object
*) self
)->type
;
425 type
= check_typedef (type
);
427 CATCH (except
, RETURN_MASK_ALL
)
429 GDB_PY_HANDLE_EXCEPTION (except
);
433 return type_to_type_object (type
);
436 /* Strip typedefs and pointers/reference from a type. Then check that
437 it is a struct, union, or enum type. If not, raise TypeError. */
440 typy_get_composite (struct type
*type
)
447 type
= check_typedef (type
);
449 CATCH (except
, RETURN_MASK_ALL
)
451 GDB_PY_HANDLE_EXCEPTION (except
);
455 if (TYPE_CODE (type
) != TYPE_CODE_PTR
&& !TYPE_IS_REFERENCE (type
))
457 type
= TYPE_TARGET_TYPE (type
);
460 /* If this is not a struct, union, or enum type, raise TypeError
462 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
463 && TYPE_CODE (type
) != TYPE_CODE_UNION
464 && TYPE_CODE (type
) != TYPE_CODE_ENUM
465 && TYPE_CODE (type
) != TYPE_CODE_FUNC
)
467 PyErr_SetString (PyExc_TypeError
,
468 "Type is not a structure, union, enum, or function type.");
475 /* Helper for typy_array and typy_vector. */
478 typy_array_1 (PyObject
*self
, PyObject
*args
, int is_vector
)
481 PyObject
*n2_obj
= NULL
;
482 struct type
*array
= NULL
;
483 struct type
*type
= ((type_object
*) self
)->type
;
485 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
490 if (!PyInt_Check (n2_obj
))
492 PyErr_SetString (PyExc_RuntimeError
,
493 _("Array bound must be an integer"));
497 if (! gdb_py_int_as_long (n2_obj
, &n2
))
506 if (n2
< n1
- 1) /* Note: An empty array has n2 == n1 - 1. */
508 PyErr_SetString (PyExc_ValueError
,
509 _("Array length must not be negative"));
515 array
= lookup_array_range_type (type
, n1
, n2
);
517 make_vector_type (array
);
519 CATCH (except
, RETURN_MASK_ALL
)
521 GDB_PY_HANDLE_EXCEPTION (except
);
525 return type_to_type_object (array
);
528 /* Return an array type. */
531 typy_array (PyObject
*self
, PyObject
*args
)
533 return typy_array_1 (self
, args
, 0);
536 /* Return a vector type. */
539 typy_vector (PyObject
*self
, PyObject
*args
)
541 return typy_array_1 (self
, args
, 1);
544 /* Return a Type object which represents a pointer to SELF. */
546 typy_pointer (PyObject
*self
, PyObject
*args
)
548 struct type
*type
= ((type_object
*) self
)->type
;
552 type
= lookup_pointer_type (type
);
554 CATCH (except
, RETURN_MASK_ALL
)
556 GDB_PY_HANDLE_EXCEPTION (except
);
560 return type_to_type_object (type
);
563 /* Return the range of a type represented by SELF. The return type is
564 a tuple. The first element of the tuple contains the low bound,
565 while the second element of the tuple contains the high bound. */
567 typy_range (PyObject
*self
, PyObject
*args
)
569 struct type
*type
= ((type_object
*) self
)->type
;
570 /* Initialize these to appease GCC warnings. */
571 LONGEST low
= 0, high
= 0;
573 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
574 && TYPE_CODE (type
) != TYPE_CODE_STRING
575 && TYPE_CODE (type
) != TYPE_CODE_RANGE
)
577 PyErr_SetString (PyExc_RuntimeError
,
578 _("This type does not have a range."));
582 switch (TYPE_CODE (type
))
584 case TYPE_CODE_ARRAY
:
585 case TYPE_CODE_STRING
:
586 low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
587 high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
));
589 case TYPE_CODE_RANGE
:
590 low
= TYPE_LOW_BOUND (type
);
591 high
= TYPE_HIGH_BOUND (type
);
595 gdbpy_ref
<> low_bound (PyLong_FromLong (low
));
596 if (low_bound
== NULL
)
599 gdbpy_ref
<> high_bound (PyLong_FromLong (high
));
600 if (high_bound
== NULL
)
603 gdbpy_ref
<> result (PyTuple_New (2));
607 if (PyTuple_SetItem (result
.get (), 0, low_bound
.release ()) != 0
608 || PyTuple_SetItem (result
.get (), 1, high_bound
.release ()) != 0)
610 return result
.release ();
613 /* Return a Type object which represents a reference to SELF. */
615 typy_reference (PyObject
*self
, PyObject
*args
)
617 struct type
*type
= ((type_object
*) self
)->type
;
621 type
= lookup_lvalue_reference_type (type
);
623 CATCH (except
, RETURN_MASK_ALL
)
625 GDB_PY_HANDLE_EXCEPTION (except
);
629 return type_to_type_object (type
);
632 /* Return a Type object which represents the target type of SELF. */
634 typy_target (PyObject
*self
, PyObject
*args
)
636 struct type
*type
= ((type_object
*) self
)->type
;
638 if (!TYPE_TARGET_TYPE (type
))
640 PyErr_SetString (PyExc_RuntimeError
,
641 _("Type does not have a target."));
645 return type_to_type_object (TYPE_TARGET_TYPE (type
));
648 /* Return a const-qualified type variant. */
650 typy_const (PyObject
*self
, PyObject
*args
)
652 struct type
*type
= ((type_object
*) self
)->type
;
656 type
= make_cv_type (1, 0, type
, NULL
);
658 CATCH (except
, RETURN_MASK_ALL
)
660 GDB_PY_HANDLE_EXCEPTION (except
);
664 return type_to_type_object (type
);
667 /* Return a volatile-qualified type variant. */
669 typy_volatile (PyObject
*self
, PyObject
*args
)
671 struct type
*type
= ((type_object
*) self
)->type
;
675 type
= make_cv_type (0, 1, type
, NULL
);
677 CATCH (except
, RETURN_MASK_ALL
)
679 GDB_PY_HANDLE_EXCEPTION (except
);
683 return type_to_type_object (type
);
686 /* Return an unqualified type variant. */
688 typy_unqualified (PyObject
*self
, PyObject
*args
)
690 struct type
*type
= ((type_object
*) self
)->type
;
694 type
= make_cv_type (0, 0, type
, NULL
);
696 CATCH (except
, RETURN_MASK_ALL
)
698 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
;
713 check_typedef (type
);
715 CATCH (except
, RETURN_MASK_ALL
)
720 /* Ignore exceptions. */
722 return gdb_py_long_from_longest (TYPE_LENGTH (type
));
725 /* Return the alignment of the type represented by SELF, in bytes. */
727 typy_get_alignof (PyObject
*self
, void *closure
)
729 struct type
*type
= ((type_object
*) self
)->type
;
734 align
= type_align (type
);
736 CATCH (except
, RETURN_MASK_ALL
)
742 /* Ignore exceptions. */
744 return gdb_py_object_from_ulongest (align
).release ();
748 typy_lookup_typename (const char *type_name
, const struct block
*block
)
750 struct type
*type
= NULL
;
754 if (startswith (type_name
, "struct "))
755 type
= lookup_struct (type_name
+ 7, NULL
);
756 else if (startswith (type_name
, "union "))
757 type
= lookup_union (type_name
+ 6, NULL
);
758 else if (startswith (type_name
, "enum "))
759 type
= lookup_enum (type_name
+ 5, NULL
);
761 type
= lookup_typename (python_language
, python_gdbarch
,
762 type_name
, block
, 0);
764 CATCH (except
, RETURN_MASK_ALL
)
766 GDB_PY_HANDLE_EXCEPTION (except
);
774 typy_lookup_type (struct demangle_component
*demangled
,
775 const struct block
*block
)
777 struct type
*type
, *rtype
= NULL
;
778 enum demangle_component_type demangled_type
;
780 /* Save the type: typy_lookup_type() may (indirectly) overwrite
781 memory pointed by demangled. */
782 demangled_type
= demangled
->type
;
784 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
785 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
786 || demangled_type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE
787 || demangled_type
== DEMANGLE_COMPONENT_CONST
788 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
790 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
796 /* If the demangled_type matches with one of the types
797 below, run the corresponding function and save the type
798 to return later. We cannot just return here as we are in
799 an exception handler. */
800 switch (demangled_type
)
802 case DEMANGLE_COMPONENT_REFERENCE
:
803 rtype
= lookup_lvalue_reference_type (type
);
805 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
806 rtype
= lookup_rvalue_reference_type (type
);
808 case DEMANGLE_COMPONENT_POINTER
:
809 rtype
= lookup_pointer_type (type
);
811 case DEMANGLE_COMPONENT_CONST
:
812 rtype
= make_cv_type (1, 0, type
, NULL
);
814 case DEMANGLE_COMPONENT_VOLATILE
:
815 rtype
= make_cv_type (0, 1, type
, NULL
);
819 CATCH (except
, RETURN_MASK_ALL
)
821 GDB_PY_HANDLE_EXCEPTION (except
);
826 /* If we have a type from the switch statement above, just return
831 /* We don't have a type, so lookup the type. */
832 gdb::unique_xmalloc_ptr
<char> type_name
= cp_comp_to_string (demangled
, 10);
833 return typy_lookup_typename (type_name
.get (), block
);
836 /* This is a helper function for typy_template_argument that is used
837 when the type does not have template symbols attached. It works by
838 parsing the type name. This happens with compilers, like older
839 versions of GCC, that do not emit DW_TAG_template_*. */
842 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
846 struct demangle_component
*demangled
;
847 std::unique_ptr
<demangle_parse_info
> info
;
849 struct type
*argtype
;
851 if (TYPE_NAME (type
) == NULL
)
853 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
859 /* Note -- this is not thread-safe. */
860 info
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
862 CATCH (except
, RETURN_MASK_ALL
)
864 GDB_PY_HANDLE_EXCEPTION (except
);
870 PyErr_SetString (PyExc_RuntimeError
, err
.c_str ());
873 demangled
= info
->tree
;
875 /* Strip off component names. */
876 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
877 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
878 demangled
= demangled
->u
.s_binary
.right
;
880 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
882 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
886 /* Skip from the template to the arguments. */
887 demangled
= demangled
->u
.s_binary
.right
;
889 for (i
= 0; demangled
&& i
< argno
; ++i
)
890 demangled
= demangled
->u
.s_binary
.right
;
894 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
899 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
903 return type_to_type_object (argtype
);
907 typy_template_argument (PyObject
*self
, PyObject
*args
)
910 struct type
*type
= ((type_object
*) self
)->type
;
911 const struct block
*block
= NULL
;
912 PyObject
*block_obj
= NULL
;
914 struct value
*val
= NULL
;
916 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
921 PyErr_SetString (PyExc_RuntimeError
,
922 _("Template argument number must be non-negative"));
928 block
= block_object_to_block (block_obj
);
931 PyErr_SetString (PyExc_RuntimeError
,
932 _("Second argument must be block."));
939 type
= check_typedef (type
);
940 if (TYPE_IS_REFERENCE (type
))
941 type
= check_typedef (TYPE_TARGET_TYPE (type
));
943 CATCH (except
, RETURN_MASK_ALL
)
945 GDB_PY_HANDLE_EXCEPTION (except
);
949 /* We might not have DW_TAG_template_*, so try to parse the type's
950 name. This is inefficient if we do not have a template type --
951 but that is going to wind up as an error anyhow. */
952 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
953 return typy_legacy_template_argument (type
, block
, argno
);
955 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
957 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
962 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
963 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
964 return type_to_type_object (SYMBOL_TYPE (sym
));
965 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
967 PyErr_Format (PyExc_RuntimeError
,
968 _("Template argument is optimized out"));
974 val
= value_of_variable (sym
, block
);
976 CATCH (except
, RETURN_MASK_ALL
)
978 GDB_PY_HANDLE_EXCEPTION (except
);
982 return value_to_value_object (val
);
986 typy_str (PyObject
*self
)
992 LA_PRINT_TYPE (type_object_to_type (self
), "", &thetype
, -1, 0,
993 &type_print_raw_options
);
995 CATCH (except
, RETURN_MASK_ALL
)
997 GDB_PY_HANDLE_EXCEPTION (except
);
1001 return PyUnicode_Decode (thetype
.c_str (), thetype
.size (),
1002 host_charset (), NULL
);
1005 /* Implement the richcompare method. */
1008 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1010 bool result
= false;
1011 struct type
*type1
= type_object_to_type (self
);
1012 struct type
*type2
= type_object_to_type (other
);
1014 /* We can only compare ourselves to another Type object, and only
1015 for equality or inequality. */
1016 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
1018 Py_INCREF (Py_NotImplemented
);
1019 return Py_NotImplemented
;
1028 result
= types_deeply_equal (type1
, type2
);
1030 CATCH (except
, RETURN_MASK_ALL
)
1032 /* If there is a GDB exception, a comparison is not capable
1033 (or trusted), so exit. */
1034 GDB_PY_HANDLE_EXCEPTION (except
);
1039 if (op
== (result
? Py_EQ
: Py_NE
))
1046 static const struct objfile_data
*typy_objfile_data_key
;
1049 save_objfile_types (struct objfile
*objfile
, void *datum
)
1051 type_object
*obj
= (type_object
*) datum
;
1052 htab_t copied_types
;
1054 if (!gdb_python_initialized
)
1057 /* This prevents another thread from freeing the objects we're
1059 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1061 copied_types
= create_copied_types_hash (objfile
);
1065 type_object
*next
= obj
->next
;
1067 htab_empty (copied_types
);
1069 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1077 htab_delete (copied_types
);
1081 set_type (type_object
*obj
, struct type
*type
)
1085 if (type
&& TYPE_OBJFILE (type
))
1087 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1089 obj
->next
= ((struct pyty_type_object
*)
1090 objfile_data (objfile
, typy_objfile_data_key
));
1092 obj
->next
->prev
= obj
;
1093 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1100 typy_dealloc (PyObject
*obj
)
1102 type_object
*type
= (type_object
*) obj
;
1105 type
->prev
->next
= type
->next
;
1106 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1108 /* Must reset head of list. */
1109 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1112 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1115 type
->next
->prev
= type
->prev
;
1117 Py_TYPE (type
)->tp_free (type
);
1120 /* Return number of fields ("length" of the field dictionary). */
1123 typy_length (PyObject
*self
)
1125 struct type
*type
= ((type_object
*) self
)->type
;
1127 type
= typy_get_composite (type
);
1131 return TYPE_NFIELDS (type
);
1134 /* Implements boolean evaluation of gdb.Type. Handle this like other
1135 Python objects that don't have a meaningful truth value -- all
1139 typy_nonzero (PyObject
*self
)
1144 /* Return optimized out value of this type. */
1147 typy_optimized_out (PyObject
*self
, PyObject
*args
)
1149 struct type
*type
= ((type_object
*) self
)->type
;
1151 return value_to_value_object (allocate_optimized_out_value (type
));
1154 /* Return a gdb.Field object for the field named by the argument. */
1157 typy_getitem (PyObject
*self
, PyObject
*key
)
1159 struct type
*type
= ((type_object
*) self
)->type
;
1162 gdb::unique_xmalloc_ptr
<char> field
= python_string_to_host_string (key
);
1166 /* We want just fields of this type, not of base types, so instead of
1167 using lookup_struct_elt_type, portions of that function are
1170 type
= typy_get_composite (type
);
1174 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1176 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1178 if (t_field_name
&& (strcmp_iw (t_field_name
, field
.get ()) == 0))
1179 return convert_field (type
, i
).release ();
1181 PyErr_SetObject (PyExc_KeyError
, key
);
1185 /* Implement the "get" method on the type object. This is the
1186 same as getitem if the key is present, but returns the supplied
1187 default value or None if the key is not found. */
1190 typy_get (PyObject
*self
, PyObject
*args
)
1192 PyObject
*key
, *defval
= Py_None
, *result
;
1194 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1197 result
= typy_getitem (self
, key
);
1201 /* typy_getitem returned error status. If the exception is
1202 KeyError, clear the exception status and return the defval
1203 instead. Otherwise return the exception unchanged. */
1204 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1212 /* Implement the "has_key" method on the type object. */
1215 typy_has_key (PyObject
*self
, PyObject
*args
)
1217 struct type
*type
= ((type_object
*) self
)->type
;
1221 if (!PyArg_ParseTuple (args
, "s", &field
))
1224 /* We want just fields of this type, not of base types, so instead of
1225 using lookup_struct_elt_type, portions of that function are
1228 type
= typy_get_composite (type
);
1232 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1234 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1236 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1242 /* Make an iterator object to iterate over keys, values, or items. */
1245 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1247 typy_iterator_object
*typy_iter_obj
;
1249 /* Check that "self" is a structure or union type. */
1250 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1253 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1254 &type_iterator_object_type
);
1255 if (typy_iter_obj
== NULL
)
1258 typy_iter_obj
->field
= 0;
1259 typy_iter_obj
->kind
= kind
;
1261 typy_iter_obj
->source
= (type_object
*) self
;
1263 return (PyObject
*) typy_iter_obj
;
1266 /* iteritems() method. */
1269 typy_iteritems (PyObject
*self
, PyObject
*args
)
1271 return typy_make_iter (self
, iter_items
);
1274 /* iterkeys() method. */
1277 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1279 return typy_make_iter (self
, iter_keys
);
1282 /* Iterating over the class, same as iterkeys except for the function
1286 typy_iter (PyObject
*self
)
1288 return typy_make_iter (self
, iter_keys
);
1291 /* itervalues() method. */
1294 typy_itervalues (PyObject
*self
, PyObject
*args
)
1296 return typy_make_iter (self
, iter_values
);
1299 /* Return a reference to the type iterator. */
1302 typy_iterator_iter (PyObject
*self
)
1308 /* Return the next field in the iteration through the list of fields
1312 typy_iterator_iternext (PyObject
*self
)
1314 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1315 struct type
*type
= iter_obj
->source
->type
;
1317 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1319 gdbpy_ref
<> result
= make_fielditem (type
, iter_obj
->field
,
1323 return result
.release ();
1330 typy_iterator_dealloc (PyObject
*obj
)
1332 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1334 Py_DECREF (iter_obj
->source
);
1337 /* Create a new Type referring to TYPE. */
1339 type_to_type_object (struct type
*type
)
1341 type_object
*type_obj
;
1343 type_obj
= PyObject_New (type_object
, &type_object_type
);
1345 set_type (type_obj
, type
);
1347 return (PyObject
*) type_obj
;
1351 type_object_to_type (PyObject
*obj
)
1353 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1355 return ((type_object
*) obj
)->type
;
1360 /* Implementation of gdb.lookup_type. */
1362 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1364 static const char *keywords
[] = { "name", "block", NULL
};
1365 const char *type_name
= NULL
;
1366 struct type
*type
= NULL
;
1367 PyObject
*block_obj
= NULL
;
1368 const struct block
*block
= NULL
;
1370 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1371 &type_name
, &block_obj
))
1376 block
= block_object_to_block (block_obj
);
1379 PyErr_SetString (PyExc_RuntimeError
,
1380 _("'block' argument must be a Block."));
1385 type
= typy_lookup_typename (type_name
, block
);
1389 return type_to_type_object (type
);
1393 gdbpy_initialize_types (void)
1397 typy_objfile_data_key
1398 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1400 if (PyType_Ready (&type_object_type
) < 0)
1402 if (PyType_Ready (&field_object_type
) < 0)
1404 if (PyType_Ready (&type_iterator_object_type
) < 0)
1407 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1409 if (PyModule_AddIntConstant (gdb_module
, pyty_codes
[i
].name
,
1410 pyty_codes
[i
].code
) < 0)
1414 if (gdb_pymodule_addobject (gdb_module
, "Type",
1415 (PyObject
*) &type_object_type
) < 0)
1418 if (gdb_pymodule_addobject (gdb_module
, "TypeIterator",
1419 (PyObject
*) &type_iterator_object_type
) < 0)
1422 return gdb_pymodule_addobject (gdb_module
, "Field",
1423 (PyObject
*) &field_object_type
);
1428 static gdb_PyGetSetDef type_object_getset
[] =
1430 { "alignof", typy_get_alignof
, NULL
,
1431 "The alignment of this type, in bytes.", NULL
},
1432 { "code", typy_get_code
, NULL
,
1433 "The code for this type.", NULL
},
1434 { "name", typy_get_name
, NULL
,
1435 "The name for this type, or None.", NULL
},
1436 { "sizeof", typy_get_sizeof
, NULL
,
1437 "The size of this type, in bytes.", NULL
},
1438 { "tag", typy_get_tag
, NULL
,
1439 "The tag name for this type, or None.", NULL
},
1443 static PyMethodDef type_object_methods
[] =
1445 { "array", typy_array
, METH_VARARGS
,
1446 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1447 Return a type which represents an array of objects of this type.\n\
1448 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1449 If LOW_BOUND is omitted, a value of zero is used." },
1450 { "vector", typy_vector
, METH_VARARGS
,
1451 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1452 Return a type which represents a vector of objects of this type.\n\
1453 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1454 If LOW_BOUND is omitted, a value of zero is used.\n\
1455 Vectors differ from arrays in that if the current language has C-style\n\
1456 arrays, vectors don't decay to a pointer to the first element.\n\
1457 They are first class values." },
1458 { "__contains__", typy_has_key
, METH_VARARGS
,
1459 "T.__contains__(k) -> True if T has a field named k, else False" },
1460 { "const", typy_const
, METH_NOARGS
,
1461 "const () -> Type\n\
1462 Return a const variant of this type." },
1463 { "optimized_out", typy_optimized_out
, METH_NOARGS
,
1464 "optimized_out() -> Value\n\
1465 Return optimized out value of this type." },
1466 { "fields", typy_fields
, METH_NOARGS
,
1467 "fields () -> list\n\
1468 Return a list holding all the fields of this type.\n\
1469 Each field is a gdb.Field object." },
1470 { "get", typy_get
, METH_VARARGS
,
1471 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1472 otherwise returns default, if supplied, or None if not." },
1473 { "has_key", typy_has_key
, METH_VARARGS
,
1474 "T.has_key(k) -> True if T has a field named k, else False" },
1475 { "items", typy_items
, METH_NOARGS
,
1476 "items () -> list\n\
1477 Return a list of (name, field) pairs of this type.\n\
1478 Each field is a gdb.Field object." },
1479 { "iteritems", typy_iteritems
, METH_NOARGS
,
1480 "iteritems () -> an iterator over the (name, field)\n\
1481 pairs of this type. Each field is a gdb.Field object." },
1482 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1483 "iterkeys () -> an iterator over the field names of this type." },
1484 { "itervalues", typy_itervalues
, METH_NOARGS
,
1485 "itervalues () -> an iterator over the fields of this type.\n\
1486 Each field is a gdb.Field object." },
1487 { "keys", typy_field_names
, METH_NOARGS
,
1489 Return a list holding all the fields names of this type." },
1490 { "pointer", typy_pointer
, METH_NOARGS
,
1491 "pointer () -> Type\n\
1492 Return a type of pointer to this type." },
1493 { "range", typy_range
, METH_NOARGS
,
1494 "range () -> tuple\n\
1495 Return a tuple containing the lower and upper range for this type."},
1496 { "reference", typy_reference
, METH_NOARGS
,
1497 "reference () -> Type\n\
1498 Return a type of reference to this type." },
1499 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1500 "strip_typedefs () -> Type\n\
1501 Return a type formed by stripping this type of all typedefs."},
1502 { "target", typy_target
, METH_NOARGS
,
1503 "target () -> Type\n\
1504 Return the target type of this type." },
1505 { "template_argument", typy_template_argument
, METH_VARARGS
,
1506 "template_argument (arg, [block]) -> Type\n\
1507 Return the type of a template argument." },
1508 { "unqualified", typy_unqualified
, METH_NOARGS
,
1509 "unqualified () -> Type\n\
1510 Return a variant of this type without const or volatile attributes." },
1511 { "values", typy_values
, METH_NOARGS
,
1512 "values () -> list\n\
1513 Return a list holding all the fields of this type.\n\
1514 Each field is a gdb.Field object." },
1515 { "volatile", typy_volatile
, METH_NOARGS
,
1516 "volatile () -> Type\n\
1517 Return a volatile variant of this type" },
1521 static PyNumberMethods type_object_as_number
= {
1523 NULL
, /* nb_subtract */
1524 NULL
, /* nb_multiply */
1526 NULL
, /* nb_divide */
1528 NULL
, /* nb_remainder */
1529 NULL
, /* nb_divmod */
1530 NULL
, /* nb_power */
1531 NULL
, /* nb_negative */
1532 NULL
, /* nb_positive */
1533 NULL
, /* nb_absolute */
1534 typy_nonzero
, /* nb_nonzero */
1535 NULL
, /* nb_invert */
1536 NULL
, /* nb_lshift */
1537 NULL
, /* nb_rshift */
1543 NULL
, /* reserved */
1545 NULL
, /* nb_coerce */
1549 NULL
, /* nb_float */
1556 static PyMappingMethods typy_mapping
= {
1559 NULL
/* no "set" method */
1562 PyTypeObject type_object_type
=
1564 PyVarObject_HEAD_INIT (NULL
, 0)
1565 "gdb.Type", /*tp_name*/
1566 sizeof (type_object
), /*tp_basicsize*/
1568 typy_dealloc
, /*tp_dealloc*/
1574 &type_object_as_number
, /*tp_as_number*/
1575 0, /*tp_as_sequence*/
1576 &typy_mapping
, /*tp_as_mapping*/
1579 typy_str
, /*tp_str*/
1583 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1584 "GDB type object", /* tp_doc */
1585 0, /* tp_traverse */
1587 typy_richcompare
, /* tp_richcompare */
1588 0, /* tp_weaklistoffset */
1589 typy_iter
, /* tp_iter */
1590 0, /* tp_iternext */
1591 type_object_methods
, /* tp_methods */
1593 type_object_getset
, /* tp_getset */
1596 0, /* tp_descr_get */
1597 0, /* tp_descr_set */
1598 0, /* tp_dictoffset */
1604 static gdb_PyGetSetDef field_object_getset
[] =
1606 { "__dict__", gdb_py_generic_dict
, NULL
,
1607 "The __dict__ for this field.", &field_object_type
},
1611 PyTypeObject field_object_type
=
1613 PyVarObject_HEAD_INIT (NULL
, 0)
1614 "gdb.Field", /*tp_name*/
1615 sizeof (field_object
), /*tp_basicsize*/
1617 field_dealloc
, /*tp_dealloc*/
1624 0, /*tp_as_sequence*/
1625 0, /*tp_as_mapping*/
1632 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1633 "GDB field object", /* tp_doc */
1634 0, /* tp_traverse */
1636 0, /* tp_richcompare */
1637 0, /* tp_weaklistoffset */
1639 0, /* tp_iternext */
1642 field_object_getset
, /* tp_getset */
1645 0, /* tp_descr_get */
1646 0, /* tp_descr_set */
1647 offsetof (field_object
, dict
), /* tp_dictoffset */
1653 PyTypeObject type_iterator_object_type
= {
1654 PyVarObject_HEAD_INIT (NULL
, 0)
1655 "gdb.TypeIterator", /*tp_name*/
1656 sizeof (typy_iterator_object
), /*tp_basicsize*/
1658 typy_iterator_dealloc
, /*tp_dealloc*/
1665 0, /*tp_as_sequence*/
1666 0, /*tp_as_mapping*/
1673 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1674 "GDB type iterator object", /*tp_doc */
1677 0, /*tp_richcompare */
1678 0, /*tp_weaklistoffset */
1679 typy_iterator_iter
, /*tp_iter */
1680 typy_iterator_iternext
, /*tp_iternext */