1 /* Python interface to types.
3 Copyright (C) 2008-2018 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"
30 #include "typeprint.h"
33 typedef struct pyty_type_object
38 /* If a Type object is associated with an objfile, it is kept on a
39 doubly-linked list, rooted in the objfile. This lets us copy the
40 underlying struct type when the objfile is deleted. */
41 struct pyty_type_object
*prev
;
42 struct pyty_type_object
*next
;
45 extern PyTypeObject type_object_type
46 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("type_object");
49 typedef struct pyty_field_object
53 /* Dictionary holding our attributes. */
57 extern PyTypeObject field_object_type
58 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("field_object");
60 /* A type iterator object. */
63 /* The current field index. */
66 enum gdbpy_iter_kind kind
;
67 /* Pointer back to the original source type object. */
68 struct pyty_type_object
*source
;
69 } typy_iterator_object
;
71 extern PyTypeObject type_iterator_object_type
72 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("typy_iterator_object");
74 /* This is used to initialize various gdb.TYPE_ constants. */
83 /* Forward declarations. */
84 static PyObject
*typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
);
86 #define ENTRY(X) { X, #X }
88 static struct pyty_code pyty_codes
[] =
90 ENTRY (TYPE_CODE_BITSTRING
),
91 ENTRY (TYPE_CODE_PTR
),
92 ENTRY (TYPE_CODE_ARRAY
),
93 ENTRY (TYPE_CODE_STRUCT
),
94 ENTRY (TYPE_CODE_UNION
),
95 ENTRY (TYPE_CODE_ENUM
),
96 ENTRY (TYPE_CODE_FLAGS
),
97 ENTRY (TYPE_CODE_FUNC
),
98 ENTRY (TYPE_CODE_INT
),
99 ENTRY (TYPE_CODE_FLT
),
100 ENTRY (TYPE_CODE_VOID
),
101 ENTRY (TYPE_CODE_SET
),
102 ENTRY (TYPE_CODE_RANGE
),
103 ENTRY (TYPE_CODE_STRING
),
104 ENTRY (TYPE_CODE_ERROR
),
105 ENTRY (TYPE_CODE_METHOD
),
106 ENTRY (TYPE_CODE_METHODPTR
),
107 ENTRY (TYPE_CODE_MEMBERPTR
),
108 ENTRY (TYPE_CODE_REF
),
109 ENTRY (TYPE_CODE_RVALUE_REF
),
110 ENTRY (TYPE_CODE_CHAR
),
111 ENTRY (TYPE_CODE_BOOL
),
112 ENTRY (TYPE_CODE_COMPLEX
),
113 ENTRY (TYPE_CODE_TYPEDEF
),
114 ENTRY (TYPE_CODE_NAMESPACE
),
115 ENTRY (TYPE_CODE_DECFLOAT
),
116 ENTRY (TYPE_CODE_INTERNAL_FUNCTION
),
117 { TYPE_CODE_UNDEF
, NULL
}
123 field_dealloc (PyObject
*obj
)
125 field_object
*f
= (field_object
*) obj
;
127 Py_XDECREF (f
->dict
);
128 Py_TYPE (obj
)->tp_free (obj
);
134 gdbpy_ref
<field_object
> result (PyObject_New (field_object
,
135 &field_object_type
));
139 result
->dict
= PyDict_New ();
143 return (PyObject
*) result
.release ();
148 /* Return true if OBJ is of type gdb.Field, false otherwise. */
151 gdbpy_is_field (PyObject
*obj
)
153 return PyObject_TypeCheck (obj
, &field_object_type
);
156 /* Return the code for this type. */
158 typy_get_code (PyObject
*self
, void *closure
)
160 struct type
*type
= ((type_object
*) self
)->type
;
162 return PyInt_FromLong (TYPE_CODE (type
));
165 /* Helper function for typy_fields which converts a single field to a
166 gdb.Field object. Returns NULL on error. */
169 convert_field (struct type
*type
, int field
)
171 gdbpy_ref
<> result (field_new ());
176 gdbpy_ref
<> arg (type_to_type_object (type
));
179 if (PyObject_SetAttrString (result
.get (), "parent_type", arg
.get ()) < 0)
182 if (!field_is_static (&TYPE_FIELD (type
, field
)))
184 const char *attrstring
;
186 if (TYPE_CODE (type
) == TYPE_CODE_ENUM
)
188 arg
.reset (gdb_py_long_from_longest (TYPE_FIELD_ENUMVAL (type
,
190 attrstring
= "enumval";
194 arg
.reset (gdb_py_long_from_longest (TYPE_FIELD_BITPOS (type
,
196 attrstring
= "bitpos";
202 /* At least python-2.4 had the second parameter non-const. */
203 if (PyObject_SetAttrString (result
.get (), (char *) attrstring
,
209 if (TYPE_FIELD_NAME (type
, field
))
211 const char *field_name
= TYPE_FIELD_NAME (type
, field
);
213 if (field_name
[0] != '\0')
215 arg
.reset (PyString_FromString (TYPE_FIELD_NAME (type
, field
)));
223 Py_INCREF (arg
.get ());
225 if (PyObject_SetAttrString (result
.get (), "name", arg
.get ()) < 0)
228 arg
.reset (TYPE_FIELD_ARTIFICIAL (type
, field
) ? Py_True
: Py_False
);
229 Py_INCREF (arg
.get ());
230 if (PyObject_SetAttrString (result
.get (), "artificial", arg
.get ()) < 0)
233 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
234 arg
.reset (field
< TYPE_N_BASECLASSES (type
) ? Py_True
: Py_False
);
236 arg
.reset (Py_False
);
237 Py_INCREF (arg
.get ());
238 if (PyObject_SetAttrString (result
.get (), "is_base_class", arg
.get ()) < 0)
241 arg
.reset (PyLong_FromLong (TYPE_FIELD_BITSIZE (type
, field
)));
244 if (PyObject_SetAttrString (result
.get (), "bitsize", arg
.get ()) < 0)
247 /* A field can have a NULL type in some situations. */
248 if (TYPE_FIELD_TYPE (type
, field
) == NULL
)
251 Py_INCREF (arg
.get ());
254 arg
.reset (type_to_type_object (TYPE_FIELD_TYPE (type
, field
)));
257 if (PyObject_SetAttrString (result
.get (), "type", arg
.get ()) < 0)
260 return result
.release ();
263 /* Helper function to return the name of a field, as a gdb.Field object.
264 If the field doesn't have a name, None is returned. */
267 field_name (struct type
*type
, int field
)
271 if (TYPE_FIELD_NAME (type
, field
))
272 result
= PyString_FromString (TYPE_FIELD_NAME (type
, field
));
281 /* Helper function for Type standard mapping methods. Returns a
282 Python object for field i of the type. "kind" specifies what to
283 return: the name of the field, a gdb.Field object corresponding to
284 the field, or a tuple consisting of field name and gdb.Field
288 make_fielditem (struct type
*type
, int i
, enum gdbpy_iter_kind kind
)
294 gdbpy_ref
<> key (field_name (type
, i
));
297 gdbpy_ref
<> value (convert_field (type
, i
));
300 gdbpy_ref
<> item (PyTuple_New (2));
303 PyTuple_SET_ITEM (item
.get (), 0, key
.release ());
304 PyTuple_SET_ITEM (item
.get (), 1, value
.release ());
305 return item
.release ();
308 return field_name (type
, i
);
310 return convert_field (type
, i
);
312 gdb_assert_not_reached ("invalid gdbpy_iter_kind");
315 /* Return a sequence of all field names, fields, or (name, field) pairs.
316 Each field is a gdb.Field object. */
319 typy_fields_items (PyObject
*self
, enum gdbpy_iter_kind kind
)
321 PyObject
*py_type
= self
;
322 PyObject
*result
= NULL
, *iter
= NULL
;
323 struct type
*type
= ((type_object
*) py_type
)->type
;
324 struct type
*checked_type
= type
;
328 checked_type
= check_typedef (checked_type
);
330 CATCH (except
, RETURN_MASK_ALL
)
332 GDB_PY_HANDLE_EXCEPTION (except
);
336 if (checked_type
!= type
)
337 py_type
= type_to_type_object (checked_type
);
338 iter
= typy_make_iter (py_type
, kind
);
339 if (checked_type
!= type
)
341 /* Need to wrap this in braces because Py_DECREF isn't wrapped
342 in a do{}while(0). */
347 result
= PySequence_List (iter
);
354 /* Return a sequence of all fields. Each field is a gdb.Field object. */
357 typy_values (PyObject
*self
, PyObject
*args
)
359 return typy_fields_items (self
, iter_values
);
362 /* Return a sequence of all fields. Each field is a gdb.Field object.
363 This method is similar to typy_values, except where the supplied
364 gdb.Type is an array, in which case it returns a list of one entry
365 which is a gdb.Field object for a range (the array bounds). */
368 typy_fields (PyObject
*self
, PyObject
*args
)
370 struct type
*type
= ((type_object
*) self
)->type
;
372 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
373 return typy_fields_items (self
, iter_values
);
375 /* Array type. Handle this as a special case because the common
376 machinery wants struct or union or enum types. Build a list of
377 one entry which is the range for the array. */
378 gdbpy_ref
<> r (convert_field (type
, 0));
382 return Py_BuildValue ("[O]", r
.get ());
385 /* Return a sequence of all field names. Each field is a gdb.Field object. */
388 typy_field_names (PyObject
*self
, PyObject
*args
)
390 return typy_fields_items (self
, iter_keys
);
393 /* Return a sequence of all (name, fields) pairs. Each field is a
397 typy_items (PyObject
*self
, PyObject
*args
)
399 return typy_fields_items (self
, iter_items
);
402 /* Return the type's name, or None. */
405 typy_get_name (PyObject
*self
, void *closure
)
407 struct type
*type
= ((type_object
*) self
)->type
;
409 if (TYPE_NAME (type
) == NULL
)
411 return PyString_FromString (TYPE_NAME (type
));
414 /* Return the type's tag, or None. */
416 typy_get_tag (PyObject
*self
, void *closure
)
418 struct type
*type
= ((type_object
*) self
)->type
;
420 if (!TYPE_TAG_NAME (type
))
422 return PyString_FromString (TYPE_TAG_NAME (type
));
425 /* Return the type, stripped of typedefs. */
427 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
429 struct type
*type
= ((type_object
*) self
)->type
;
433 type
= check_typedef (type
);
435 CATCH (except
, RETURN_MASK_ALL
)
437 GDB_PY_HANDLE_EXCEPTION (except
);
441 return type_to_type_object (type
);
444 /* Strip typedefs and pointers/reference from a type. Then check that
445 it is a struct, union, or enum type. If not, raise TypeError. */
448 typy_get_composite (struct type
*type
)
455 type
= check_typedef (type
);
457 CATCH (except
, RETURN_MASK_ALL
)
459 GDB_PY_HANDLE_EXCEPTION (except
);
463 if (TYPE_CODE (type
) != TYPE_CODE_PTR
&& !TYPE_IS_REFERENCE (type
))
465 type
= TYPE_TARGET_TYPE (type
);
468 /* If this is not a struct, union, or enum type, raise TypeError
470 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
471 && TYPE_CODE (type
) != TYPE_CODE_UNION
472 && TYPE_CODE (type
) != TYPE_CODE_ENUM
473 && TYPE_CODE (type
) != TYPE_CODE_FUNC
)
475 PyErr_SetString (PyExc_TypeError
,
476 "Type is not a structure, union, enum, or function type.");
483 /* Helper for typy_array and typy_vector. */
486 typy_array_1 (PyObject
*self
, PyObject
*args
, int is_vector
)
489 PyObject
*n2_obj
= NULL
;
490 struct type
*array
= NULL
;
491 struct type
*type
= ((type_object
*) self
)->type
;
493 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
498 if (!PyInt_Check (n2_obj
))
500 PyErr_SetString (PyExc_RuntimeError
,
501 _("Array bound must be an integer"));
505 if (! gdb_py_int_as_long (n2_obj
, &n2
))
514 if (n2
< n1
- 1) /* Note: An empty array has n2 == n1 - 1. */
516 PyErr_SetString (PyExc_ValueError
,
517 _("Array length must not be negative"));
523 array
= lookup_array_range_type (type
, n1
, n2
);
525 make_vector_type (array
);
527 CATCH (except
, RETURN_MASK_ALL
)
529 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 (except
, RETURN_MASK_ALL
)
564 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
) != TYPE_CODE_ARRAY
582 && TYPE_CODE (type
) != TYPE_CODE_STRING
583 && TYPE_CODE (type
) != TYPE_CODE_RANGE
)
585 PyErr_SetString (PyExc_RuntimeError
,
586 _("This type does not have a range."));
590 switch (TYPE_CODE (type
))
592 case TYPE_CODE_ARRAY
:
593 case TYPE_CODE_STRING
:
594 low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
595 high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
));
597 case TYPE_CODE_RANGE
:
598 low
= TYPE_LOW_BOUND (type
);
599 high
= TYPE_HIGH_BOUND (type
);
603 gdbpy_ref
<> low_bound (PyLong_FromLong (low
));
604 if (low_bound
== NULL
)
607 gdbpy_ref
<> high_bound (PyLong_FromLong (high
));
608 if (high_bound
== NULL
)
611 gdbpy_ref
<> result (PyTuple_New (2));
615 if (PyTuple_SetItem (result
.get (), 0, low_bound
.release ()) != 0
616 || PyTuple_SetItem (result
.get (), 1, high_bound
.release ()) != 0)
618 return result
.release ();
621 /* Return a Type object which represents a reference to SELF. */
623 typy_reference (PyObject
*self
, PyObject
*args
)
625 struct type
*type
= ((type_object
*) self
)->type
;
629 type
= lookup_lvalue_reference_type (type
);
631 CATCH (except
, RETURN_MASK_ALL
)
633 GDB_PY_HANDLE_EXCEPTION (except
);
637 return type_to_type_object (type
);
640 /* Return a Type object which represents the target type of SELF. */
642 typy_target (PyObject
*self
, PyObject
*args
)
644 struct type
*type
= ((type_object
*) self
)->type
;
646 if (!TYPE_TARGET_TYPE (type
))
648 PyErr_SetString (PyExc_RuntimeError
,
649 _("Type does not have a target."));
653 return type_to_type_object (TYPE_TARGET_TYPE (type
));
656 /* Return a const-qualified type variant. */
658 typy_const (PyObject
*self
, PyObject
*args
)
660 struct type
*type
= ((type_object
*) self
)->type
;
664 type
= make_cv_type (1, 0, type
, NULL
);
666 CATCH (except
, RETURN_MASK_ALL
)
668 GDB_PY_HANDLE_EXCEPTION (except
);
672 return type_to_type_object (type
);
675 /* Return a volatile-qualified type variant. */
677 typy_volatile (PyObject
*self
, PyObject
*args
)
679 struct type
*type
= ((type_object
*) self
)->type
;
683 type
= make_cv_type (0, 1, type
, NULL
);
685 CATCH (except
, RETURN_MASK_ALL
)
687 GDB_PY_HANDLE_EXCEPTION (except
);
691 return type_to_type_object (type
);
694 /* Return an unqualified type variant. */
696 typy_unqualified (PyObject
*self
, PyObject
*args
)
698 struct type
*type
= ((type_object
*) self
)->type
;
702 type
= make_cv_type (0, 0, type
, NULL
);
704 CATCH (except
, RETURN_MASK_ALL
)
706 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
;
721 check_typedef (type
);
723 CATCH (except
, RETURN_MASK_ALL
)
728 /* Ignore exceptions. */
730 return gdb_py_long_from_longest (TYPE_LENGTH (type
));
733 /* Return the alignment of the type represented by SELF, in bytes. */
735 typy_get_alignof (PyObject
*self
, void *closure
)
737 struct type
*type
= ((type_object
*) self
)->type
;
742 align
= type_align (type
);
744 CATCH (except
, RETURN_MASK_ALL
)
750 /* Ignore exceptions. */
752 return gdb_py_object_from_ulongest (align
);
756 typy_lookup_typename (const char *type_name
, const struct block
*block
)
758 struct type
*type
= NULL
;
762 if (startswith (type_name
, "struct "))
763 type
= lookup_struct (type_name
+ 7, NULL
);
764 else if (startswith (type_name
, "union "))
765 type
= lookup_union (type_name
+ 6, NULL
);
766 else if (startswith (type_name
, "enum "))
767 type
= lookup_enum (type_name
+ 5, NULL
);
769 type
= lookup_typename (python_language
, python_gdbarch
,
770 type_name
, block
, 0);
772 CATCH (except
, RETURN_MASK_ALL
)
774 GDB_PY_HANDLE_EXCEPTION (except
);
782 typy_lookup_type (struct demangle_component
*demangled
,
783 const struct block
*block
)
785 struct type
*type
, *rtype
= NULL
;
786 enum demangle_component_type demangled_type
;
788 /* Save the type: typy_lookup_type() may (indirectly) overwrite
789 memory pointed by demangled. */
790 demangled_type
= demangled
->type
;
792 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
793 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
794 || demangled_type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE
795 || demangled_type
== DEMANGLE_COMPONENT_CONST
796 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
798 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
804 /* If the demangled_type matches with one of the types
805 below, run the corresponding function and save the type
806 to return later. We cannot just return here as we are in
807 an exception handler. */
808 switch (demangled_type
)
810 case DEMANGLE_COMPONENT_REFERENCE
:
811 rtype
= lookup_lvalue_reference_type (type
);
813 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
814 rtype
= lookup_rvalue_reference_type (type
);
816 case DEMANGLE_COMPONENT_POINTER
:
817 rtype
= lookup_pointer_type (type
);
819 case DEMANGLE_COMPONENT_CONST
:
820 rtype
= make_cv_type (1, 0, type
, NULL
);
822 case DEMANGLE_COMPONENT_VOLATILE
:
823 rtype
= make_cv_type (0, 1, type
, NULL
);
827 CATCH (except
, RETURN_MASK_ALL
)
829 GDB_PY_HANDLE_EXCEPTION (except
);
834 /* If we have a type from the switch statement above, just return
839 /* We don't have a type, so lookup the type. */
840 gdb::unique_xmalloc_ptr
<char> type_name
= cp_comp_to_string (demangled
, 10);
841 return typy_lookup_typename (type_name
.get (), block
);
844 /* This is a helper function for typy_template_argument that is used
845 when the type does not have template symbols attached. It works by
846 parsing the type name. This happens with compilers, like older
847 versions of GCC, that do not emit DW_TAG_template_*. */
850 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
854 struct demangle_component
*demangled
;
855 std::unique_ptr
<demangle_parse_info
> info
;
857 struct type
*argtype
;
859 if (TYPE_NAME (type
) == NULL
)
861 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
867 /* Note -- this is not thread-safe. */
868 info
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
870 CATCH (except
, RETURN_MASK_ALL
)
872 GDB_PY_HANDLE_EXCEPTION (except
);
878 PyErr_SetString (PyExc_RuntimeError
, err
);
881 demangled
= info
->tree
;
883 /* Strip off component names. */
884 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
885 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
886 demangled
= demangled
->u
.s_binary
.right
;
888 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
890 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
894 /* Skip from the template to the arguments. */
895 demangled
= demangled
->u
.s_binary
.right
;
897 for (i
= 0; demangled
&& i
< argno
; ++i
)
898 demangled
= demangled
->u
.s_binary
.right
;
902 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
907 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
911 return type_to_type_object (argtype
);
915 typy_template_argument (PyObject
*self
, PyObject
*args
)
918 struct type
*type
= ((type_object
*) self
)->type
;
919 const struct block
*block
= NULL
;
920 PyObject
*block_obj
= NULL
;
922 struct value
*val
= NULL
;
924 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
929 block
= block_object_to_block (block_obj
);
932 PyErr_SetString (PyExc_RuntimeError
,
933 _("Second argument must be block."));
940 type
= check_typedef (type
);
941 if (TYPE_IS_REFERENCE (type
))
942 type
= check_typedef (TYPE_TARGET_TYPE (type
));
944 CATCH (except
, RETURN_MASK_ALL
)
946 GDB_PY_HANDLE_EXCEPTION (except
);
950 /* We might not have DW_TAG_template_*, so try to parse the type's
951 name. This is inefficient if we do not have a template type --
952 but that is going to wind up as an error anyhow. */
953 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
954 return typy_legacy_template_argument (type
, block
, argno
);
956 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
958 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
963 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
964 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
965 return type_to_type_object (SYMBOL_TYPE (sym
));
966 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
968 PyErr_Format (PyExc_RuntimeError
,
969 _("Template argument is optimized out"));
975 val
= value_of_variable (sym
, block
);
977 CATCH (except
, RETURN_MASK_ALL
)
979 GDB_PY_HANDLE_EXCEPTION (except
);
983 return value_to_value_object (val
);
987 typy_str (PyObject
*self
)
993 LA_PRINT_TYPE (type_object_to_type (self
), "", &thetype
, -1, 0,
994 &type_print_raw_options
);
996 CATCH (except
, RETURN_MASK_ALL
)
998 GDB_PY_HANDLE_EXCEPTION (except
);
1002 return PyUnicode_Decode (thetype
.c_str (), thetype
.size (),
1003 host_charset (), NULL
);
1006 /* Implement the richcompare method. */
1009 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1011 bool result
= false;
1012 struct type
*type1
= type_object_to_type (self
);
1013 struct type
*type2
= type_object_to_type (other
);
1015 /* We can only compare ourselves to another Type object, and only
1016 for equality or inequality. */
1017 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
1019 Py_INCREF (Py_NotImplemented
);
1020 return Py_NotImplemented
;
1029 result
= types_deeply_equal (type1
, type2
);
1031 CATCH (except
, RETURN_MASK_ALL
)
1033 /* If there is a GDB exception, a comparison is not capable
1034 (or trusted), so exit. */
1035 GDB_PY_HANDLE_EXCEPTION (except
);
1040 if (op
== (result
? Py_EQ
: Py_NE
))
1047 static const struct objfile_data
*typy_objfile_data_key
;
1050 save_objfile_types (struct objfile
*objfile
, void *datum
)
1052 type_object
*obj
= (type_object
*) datum
;
1053 htab_t copied_types
;
1055 if (!gdb_python_initialized
)
1058 /* This prevents another thread from freeing the objects we're
1060 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1062 copied_types
= create_copied_types_hash (objfile
);
1066 type_object
*next
= obj
->next
;
1068 htab_empty (copied_types
);
1070 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1078 htab_delete (copied_types
);
1082 set_type (type_object
*obj
, struct type
*type
)
1086 if (type
&& TYPE_OBJFILE (type
))
1088 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1090 obj
->next
= ((struct pyty_type_object
*)
1091 objfile_data (objfile
, typy_objfile_data_key
));
1093 obj
->next
->prev
= obj
;
1094 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1101 typy_dealloc (PyObject
*obj
)
1103 type_object
*type
= (type_object
*) obj
;
1106 type
->prev
->next
= type
->next
;
1107 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1109 /* Must reset head of list. */
1110 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1113 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1116 type
->next
->prev
= type
->prev
;
1118 Py_TYPE (type
)->tp_free (type
);
1121 /* Return number of fields ("length" of the field dictionary). */
1124 typy_length (PyObject
*self
)
1126 struct type
*type
= ((type_object
*) self
)->type
;
1128 type
= typy_get_composite (type
);
1132 return TYPE_NFIELDS (type
);
1135 /* Implements boolean evaluation of gdb.Type. Handle this like other
1136 Python objects that don't have a meaningful truth value -- all
1140 typy_nonzero (PyObject
*self
)
1145 /* Return optimized out value of this type. */
1148 typy_optimized_out (PyObject
*self
, PyObject
*args
)
1150 struct type
*type
= ((type_object
*) self
)->type
;
1152 return value_to_value_object (allocate_optimized_out_value (type
));
1155 /* Return a gdb.Field object for the field named by the argument. */
1158 typy_getitem (PyObject
*self
, PyObject
*key
)
1160 struct type
*type
= ((type_object
*) self
)->type
;
1163 gdb::unique_xmalloc_ptr
<char> field
= python_string_to_host_string (key
);
1167 /* We want just fields of this type, not of base types, so instead of
1168 using lookup_struct_elt_type, portions of that function are
1171 type
= typy_get_composite (type
);
1175 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1177 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1179 if (t_field_name
&& (strcmp_iw (t_field_name
, field
.get ()) == 0))
1181 return convert_field (type
, i
);
1184 PyErr_SetObject (PyExc_KeyError
, key
);
1188 /* Implement the "get" method on the type object. This is the
1189 same as getitem if the key is present, but returns the supplied
1190 default value or None if the key is not found. */
1193 typy_get (PyObject
*self
, PyObject
*args
)
1195 PyObject
*key
, *defval
= Py_None
, *result
;
1197 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1200 result
= typy_getitem (self
, key
);
1204 /* typy_getitem returned error status. If the exception is
1205 KeyError, clear the exception status and return the defval
1206 instead. Otherwise return the exception unchanged. */
1207 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1215 /* Implement the "has_key" method on the type object. */
1218 typy_has_key (PyObject
*self
, PyObject
*args
)
1220 struct type
*type
= ((type_object
*) self
)->type
;
1224 if (!PyArg_ParseTuple (args
, "s", &field
))
1227 /* We want just fields of this type, not of base types, so instead of
1228 using lookup_struct_elt_type, portions of that function are
1231 type
= typy_get_composite (type
);
1235 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1237 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1239 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1245 /* Make an iterator object to iterate over keys, values, or items. */
1248 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1250 typy_iterator_object
*typy_iter_obj
;
1252 /* Check that "self" is a structure or union type. */
1253 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1256 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1257 &type_iterator_object_type
);
1258 if (typy_iter_obj
== NULL
)
1261 typy_iter_obj
->field
= 0;
1262 typy_iter_obj
->kind
= kind
;
1264 typy_iter_obj
->source
= (type_object
*) self
;
1266 return (PyObject
*) typy_iter_obj
;
1269 /* iteritems() method. */
1272 typy_iteritems (PyObject
*self
, PyObject
*args
)
1274 return typy_make_iter (self
, iter_items
);
1277 /* iterkeys() method. */
1280 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1282 return typy_make_iter (self
, iter_keys
);
1285 /* Iterating over the class, same as iterkeys except for the function
1289 typy_iter (PyObject
*self
)
1291 return typy_make_iter (self
, iter_keys
);
1294 /* itervalues() method. */
1297 typy_itervalues (PyObject
*self
, PyObject
*args
)
1299 return typy_make_iter (self
, iter_values
);
1302 /* Return a reference to the type iterator. */
1305 typy_iterator_iter (PyObject
*self
)
1311 /* Return the next field in the iteration through the list of fields
1315 typy_iterator_iternext (PyObject
*self
)
1317 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1318 struct type
*type
= iter_obj
->source
->type
;
1321 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1323 result
= make_fielditem (type
, iter_obj
->field
, iter_obj
->kind
);
1333 typy_iterator_dealloc (PyObject
*obj
)
1335 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1337 Py_DECREF (iter_obj
->source
);
1340 /* Create a new Type referring to TYPE. */
1342 type_to_type_object (struct type
*type
)
1344 type_object
*type_obj
;
1346 type_obj
= PyObject_New (type_object
, &type_object_type
);
1348 set_type (type_obj
, type
);
1350 return (PyObject
*) type_obj
;
1354 type_object_to_type (PyObject
*obj
)
1356 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1358 return ((type_object
*) obj
)->type
;
1363 /* Implementation of gdb.lookup_type. */
1365 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1367 static const char *keywords
[] = { "name", "block", NULL
};
1368 const char *type_name
= NULL
;
1369 struct type
*type
= NULL
;
1370 PyObject
*block_obj
= NULL
;
1371 const struct block
*block
= NULL
;
1373 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1374 &type_name
, &block_obj
))
1379 block
= block_object_to_block (block_obj
);
1382 PyErr_SetString (PyExc_RuntimeError
,
1383 _("'block' argument must be a Block."));
1388 type
= typy_lookup_typename (type_name
, block
);
1392 return (PyObject
*) type_to_type_object (type
);
1396 gdbpy_initialize_types (void)
1400 typy_objfile_data_key
1401 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1403 if (PyType_Ready (&type_object_type
) < 0)
1405 if (PyType_Ready (&field_object_type
) < 0)
1407 if (PyType_Ready (&type_iterator_object_type
) < 0)
1410 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1412 if (PyModule_AddIntConstant (gdb_module
,
1413 /* Cast needed for Python 2.4. */
1414 (char *) pyty_codes
[i
].name
,
1415 pyty_codes
[i
].code
) < 0)
1419 if (gdb_pymodule_addobject (gdb_module
, "Type",
1420 (PyObject
*) &type_object_type
) < 0)
1423 if (gdb_pymodule_addobject (gdb_module
, "TypeIterator",
1424 (PyObject
*) &type_iterator_object_type
) < 0)
1427 return gdb_pymodule_addobject (gdb_module
, "Field",
1428 (PyObject
*) &field_object_type
);
1433 static gdb_PyGetSetDef type_object_getset
[] =
1435 { "alignof", typy_get_alignof
, NULL
,
1436 "The alignment of this type, in bytes.", NULL
},
1437 { "code", typy_get_code
, NULL
,
1438 "The code for this type.", NULL
},
1439 { "name", typy_get_name
, NULL
,
1440 "The name for this type, or None.", NULL
},
1441 { "sizeof", typy_get_sizeof
, NULL
,
1442 "The size of this type, in bytes.", NULL
},
1443 { "tag", typy_get_tag
, NULL
,
1444 "The tag name for this type, or None.", NULL
},
1448 static PyMethodDef type_object_methods
[] =
1450 { "array", typy_array
, METH_VARARGS
,
1451 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1452 Return a type which represents an array 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." },
1455 { "vector", typy_vector
, METH_VARARGS
,
1456 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1457 Return a type which represents a vector of objects of this type.\n\
1458 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1459 If LOW_BOUND is omitted, a value of zero is used.\n\
1460 Vectors differ from arrays in that if the current language has C-style\n\
1461 arrays, vectors don't decay to a pointer to the first element.\n\
1462 They are first class values." },
1463 { "__contains__", typy_has_key
, METH_VARARGS
,
1464 "T.__contains__(k) -> True if T has a field named k, else False" },
1465 { "const", typy_const
, METH_NOARGS
,
1466 "const () -> Type\n\
1467 Return a const variant of this type." },
1468 { "optimized_out", typy_optimized_out
, METH_NOARGS
,
1469 "optimized_out() -> Value\n\
1470 Return optimized out value of this type." },
1471 { "fields", typy_fields
, METH_NOARGS
,
1472 "fields () -> list\n\
1473 Return a list holding all the fields of this type.\n\
1474 Each field is a gdb.Field object." },
1475 { "get", typy_get
, METH_VARARGS
,
1476 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1477 otherwise returns default, if supplied, or None if not." },
1478 { "has_key", typy_has_key
, METH_VARARGS
,
1479 "T.has_key(k) -> True if T has a field named k, else False" },
1480 { "items", typy_items
, METH_NOARGS
,
1481 "items () -> list\n\
1482 Return a list of (name, field) pairs of this type.\n\
1483 Each field is a gdb.Field object." },
1484 { "iteritems", typy_iteritems
, METH_NOARGS
,
1485 "iteritems () -> an iterator over the (name, field)\n\
1486 pairs of this type. Each field is a gdb.Field object." },
1487 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1488 "iterkeys () -> an iterator over the field names of this type." },
1489 { "itervalues", typy_itervalues
, METH_NOARGS
,
1490 "itervalues () -> an iterator over the fields of this type.\n\
1491 Each field is a gdb.Field object." },
1492 { "keys", typy_field_names
, METH_NOARGS
,
1494 Return a list holding all the fields names of this type." },
1495 { "pointer", typy_pointer
, METH_NOARGS
,
1496 "pointer () -> Type\n\
1497 Return a type of pointer to this type." },
1498 { "range", typy_range
, METH_NOARGS
,
1499 "range () -> tuple\n\
1500 Return a tuple containing the lower and upper range for this type."},
1501 { "reference", typy_reference
, METH_NOARGS
,
1502 "reference () -> Type\n\
1503 Return a type of reference to this type." },
1504 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1505 "strip_typedefs () -> Type\n\
1506 Return a type formed by stripping this type of all typedefs."},
1507 { "target", typy_target
, METH_NOARGS
,
1508 "target () -> Type\n\
1509 Return the target type of this type." },
1510 { "template_argument", typy_template_argument
, METH_VARARGS
,
1511 "template_argument (arg, [block]) -> Type\n\
1512 Return the type of a template argument." },
1513 { "unqualified", typy_unqualified
, METH_NOARGS
,
1514 "unqualified () -> Type\n\
1515 Return a variant of this type without const or volatile attributes." },
1516 { "values", typy_values
, METH_NOARGS
,
1517 "values () -> list\n\
1518 Return a list holding all the fields of this type.\n\
1519 Each field is a gdb.Field object." },
1520 { "volatile", typy_volatile
, METH_NOARGS
,
1521 "volatile () -> Type\n\
1522 Return a volatile variant of this type" },
1526 static PyNumberMethods type_object_as_number
= {
1528 NULL
, /* nb_subtract */
1529 NULL
, /* nb_multiply */
1531 NULL
, /* nb_divide */
1533 NULL
, /* nb_remainder */
1534 NULL
, /* nb_divmod */
1535 NULL
, /* nb_power */
1536 NULL
, /* nb_negative */
1537 NULL
, /* nb_positive */
1538 NULL
, /* nb_absolute */
1539 typy_nonzero
, /* nb_nonzero */
1540 NULL
, /* nb_invert */
1541 NULL
, /* nb_lshift */
1542 NULL
, /* nb_rshift */
1548 NULL
, /* reserved */
1550 NULL
, /* nb_coerce */
1554 NULL
, /* nb_float */
1561 static PyMappingMethods typy_mapping
= {
1564 NULL
/* no "set" method */
1567 PyTypeObject type_object_type
=
1569 PyVarObject_HEAD_INIT (NULL
, 0)
1570 "gdb.Type", /*tp_name*/
1571 sizeof (type_object
), /*tp_basicsize*/
1573 typy_dealloc
, /*tp_dealloc*/
1579 &type_object_as_number
, /*tp_as_number*/
1580 0, /*tp_as_sequence*/
1581 &typy_mapping
, /*tp_as_mapping*/
1584 typy_str
, /*tp_str*/
1588 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1589 "GDB type object", /* tp_doc */
1590 0, /* tp_traverse */
1592 typy_richcompare
, /* tp_richcompare */
1593 0, /* tp_weaklistoffset */
1594 typy_iter
, /* tp_iter */
1595 0, /* tp_iternext */
1596 type_object_methods
, /* tp_methods */
1598 type_object_getset
, /* tp_getset */
1601 0, /* tp_descr_get */
1602 0, /* tp_descr_set */
1603 0, /* tp_dictoffset */
1609 static gdb_PyGetSetDef field_object_getset
[] =
1611 { "__dict__", gdb_py_generic_dict
, NULL
,
1612 "The __dict__ for this field.", &field_object_type
},
1616 PyTypeObject field_object_type
=
1618 PyVarObject_HEAD_INIT (NULL
, 0)
1619 "gdb.Field", /*tp_name*/
1620 sizeof (field_object
), /*tp_basicsize*/
1622 field_dealloc
, /*tp_dealloc*/
1629 0, /*tp_as_sequence*/
1630 0, /*tp_as_mapping*/
1637 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1638 "GDB field object", /* tp_doc */
1639 0, /* tp_traverse */
1641 0, /* tp_richcompare */
1642 0, /* tp_weaklistoffset */
1644 0, /* tp_iternext */
1647 field_object_getset
, /* tp_getset */
1650 0, /* tp_descr_get */
1651 0, /* tp_descr_set */
1652 offsetof (field_object
, dict
), /* tp_dictoffset */
1658 PyTypeObject type_iterator_object_type
= {
1659 PyVarObject_HEAD_INIT (NULL
, 0)
1660 "gdb.TypeIterator", /*tp_name*/
1661 sizeof (typy_iterator_object
), /*tp_basicsize*/
1663 typy_iterator_dealloc
, /*tp_dealloc*/
1670 0, /*tp_as_sequence*/
1671 0, /*tp_as_mapping*/
1678 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1679 "GDB type iterator object", /*tp_doc */
1682 0, /*tp_richcompare */
1683 0, /*tp_weaklistoffset */
1684 typy_iterator_iter
, /*tp_iter */
1685 typy_iterator_iternext
, /*tp_iternext */