1 /* Python interface to types.
3 Copyright (C) 2008-2013 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 "exceptions.h"
23 #include "python-internal.h"
26 #include "cp-support.h"
32 #include "dwarf2loc.h"
33 #include "typeprint.h"
35 typedef struct pyty_type_object
40 /* If a Type object is associated with an objfile, it is kept on a
41 doubly-linked list, rooted in the objfile. This lets us copy the
42 underlying struct type when the objfile is deleted. */
43 struct pyty_type_object
*prev
;
44 struct pyty_type_object
*next
;
47 static PyTypeObject type_object_type
48 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("type_object");
51 typedef struct pyty_field_object
55 /* Dictionary holding our attributes. */
59 static PyTypeObject field_object_type
60 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("field_object");
62 /* A type iterator object. */
65 /* The current field index. */
68 enum gdbpy_iter_kind kind
;
69 /* Pointer back to the original source type object. */
70 struct pyty_type_object
*source
;
71 } typy_iterator_object
;
73 static PyTypeObject type_iterator_object_type
74 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("typy_iterator_object");
76 /* This is used to initialize various gdb.TYPE_ constants. */
85 /* Forward declarations. */
86 static PyObject
*typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
);
88 #define ENTRY(X) { X, #X }
90 static struct pyty_code pyty_codes
[] =
92 ENTRY (TYPE_CODE_BITSTRING
),
93 ENTRY (TYPE_CODE_PTR
),
94 ENTRY (TYPE_CODE_ARRAY
),
95 ENTRY (TYPE_CODE_STRUCT
),
96 ENTRY (TYPE_CODE_UNION
),
97 ENTRY (TYPE_CODE_ENUM
),
98 ENTRY (TYPE_CODE_FLAGS
),
99 ENTRY (TYPE_CODE_FUNC
),
100 ENTRY (TYPE_CODE_INT
),
101 ENTRY (TYPE_CODE_FLT
),
102 ENTRY (TYPE_CODE_VOID
),
103 ENTRY (TYPE_CODE_SET
),
104 ENTRY (TYPE_CODE_RANGE
),
105 ENTRY (TYPE_CODE_STRING
),
106 ENTRY (TYPE_CODE_ERROR
),
107 ENTRY (TYPE_CODE_METHOD
),
108 ENTRY (TYPE_CODE_METHODPTR
),
109 ENTRY (TYPE_CODE_MEMBERPTR
),
110 ENTRY (TYPE_CODE_REF
),
111 ENTRY (TYPE_CODE_CHAR
),
112 ENTRY (TYPE_CODE_BOOL
),
113 ENTRY (TYPE_CODE_COMPLEX
),
114 ENTRY (TYPE_CODE_TYPEDEF
),
115 ENTRY (TYPE_CODE_NAMESPACE
),
116 ENTRY (TYPE_CODE_DECFLOAT
),
117 ENTRY (TYPE_CODE_INTERNAL_FUNCTION
),
118 { TYPE_CODE_UNDEF
, NULL
}
124 field_dealloc (PyObject
*obj
)
126 field_object
*f
= (field_object
*) obj
;
128 Py_XDECREF (f
->dict
);
129 Py_TYPE (obj
)->tp_free (obj
);
135 field_object
*result
= PyObject_New (field_object
, &field_object_type
);
139 result
->dict
= PyDict_New ();
146 return (PyObject
*) result
;
151 /* Return the code for this type. */
153 typy_get_code (PyObject
*self
, void *closure
)
155 struct type
*type
= ((type_object
*) self
)->type
;
157 return PyInt_FromLong (TYPE_CODE (type
));
160 /* Helper function for typy_fields which converts a single field to a
161 gdb.Field object. Returns NULL on error. */
164 convert_field (struct type
*type
, int field
)
166 PyObject
*result
= field_new ();
172 if (!field_is_static (&TYPE_FIELD (type
, field
)))
174 const char *attrstring
;
176 if (TYPE_CODE (type
) == TYPE_CODE_ENUM
)
178 arg
= gdb_py_long_from_longest (TYPE_FIELD_ENUMVAL (type
, field
));
179 attrstring
= "enumval";
183 arg
= gdb_py_long_from_longest (TYPE_FIELD_BITPOS (type
, field
));
184 attrstring
= "bitpos";
190 /* At least python-2.4 had the second parameter non-const. */
191 if (PyObject_SetAttrString (result
, (char *) attrstring
, arg
) < 0)
196 if (TYPE_FIELD_NAME (type
, field
))
197 arg
= PyString_FromString (TYPE_FIELD_NAME (type
, field
));
205 if (PyObject_SetAttrString (result
, "name", arg
) < 0)
209 arg
= TYPE_FIELD_ARTIFICIAL (type
, field
) ? Py_True
: Py_False
;
211 if (PyObject_SetAttrString (result
, "artificial", arg
) < 0)
215 if (TYPE_CODE (type
) == TYPE_CODE_CLASS
)
216 arg
= field
< TYPE_N_BASECLASSES (type
) ? Py_True
: Py_False
;
220 if (PyObject_SetAttrString (result
, "is_base_class", arg
) < 0)
224 arg
= PyLong_FromLong (TYPE_FIELD_BITSIZE (type
, field
));
227 if (PyObject_SetAttrString (result
, "bitsize", arg
) < 0)
231 /* A field can have a NULL type in some situations. */
232 if (TYPE_FIELD_TYPE (type
, field
) == NULL
)
238 arg
= type_to_type_object (TYPE_FIELD_TYPE (type
, field
));
241 if (PyObject_SetAttrString (result
, "type", arg
) < 0)
254 /* Helper function to return the name of a field, as a gdb.Field object.
255 If the field doesn't have a name, None is returned. */
258 field_name (struct type
*type
, int field
)
262 if (TYPE_FIELD_NAME (type
, field
))
263 result
= PyString_FromString (TYPE_FIELD_NAME (type
, field
));
272 /* Helper function for Type standard mapping methods. Returns a
273 Python object for field i of the type. "kind" specifies what to
274 return: the name of the field, a gdb.Field object corresponding to
275 the field, or a tuple consisting of field name and gdb.Field
279 make_fielditem (struct type
*type
, int i
, enum gdbpy_iter_kind kind
)
281 PyObject
*item
= NULL
, *key
= NULL
, *value
= NULL
;
286 key
= field_name (type
, i
);
289 value
= convert_field (type
, i
);
292 item
= PyTuple_New (2);
295 PyTuple_SET_ITEM (item
, 0, key
);
296 PyTuple_SET_ITEM (item
, 1, value
);
299 item
= field_name (type
, i
);
302 item
= convert_field (type
, i
);
305 gdb_assert_not_reached ("invalid gdbpy_iter_kind");
316 /* Return a sequence of all field names, fields, or (name, field) pairs.
317 Each field is a gdb.Field object. */
320 typy_fields_items (PyObject
*self
, enum gdbpy_iter_kind kind
)
322 PyObject
*py_type
= self
;
323 PyObject
*result
= NULL
, *iter
= NULL
;
324 volatile struct gdb_exception except
;
325 struct type
*type
= ((type_object
*) py_type
)->type
;
326 struct type
*checked_type
= type
;
328 TRY_CATCH (except
, RETURN_MASK_ALL
)
330 CHECK_TYPEDEF (checked_type
);
332 GDB_PY_HANDLE_EXCEPTION (except
);
334 if (checked_type
!= type
)
335 py_type
= type_to_type_object (checked_type
);
336 iter
= typy_make_iter (py_type
, kind
);
337 if (checked_type
!= type
)
339 /* Need to wrap this in braces because Py_DECREF isn't wrapped
340 in a do{}while(0). */
345 result
= PySequence_List (iter
);
352 /* Return a sequence of all fields. Each field is a gdb.Field object. */
355 typy_values (PyObject
*self
, PyObject
*args
)
357 return typy_fields_items (self
, iter_values
);
360 /* Return a sequence of all fields. Each field is a gdb.Field object.
361 This method is similar to typy_values, except where the supplied
362 gdb.Type is an array, in which case it returns a list of one entry
363 which is a gdb.Field object for a range (the array bounds). */
366 typy_fields (PyObject
*self
, PyObject
*args
)
368 struct type
*type
= ((type_object
*) self
)->type
;
371 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
372 return typy_fields_items (self
, iter_values
);
374 /* Array type. Handle this as a special case because the common
375 machinery wants struct or union or enum types. Build a list of
376 one entry which is the range for the array. */
377 r
= convert_field (type
, 0);
381 rl
= Py_BuildValue ("[O]", r
);
390 /* Return a sequence of all field names. Each field is a gdb.Field object. */
393 typy_field_names (PyObject
*self
, PyObject
*args
)
395 return typy_fields_items (self
, iter_keys
);
398 /* Return a sequence of all (name, fields) pairs. Each field is a
402 typy_items (PyObject
*self
, PyObject
*args
)
404 return typy_fields_items (self
, iter_items
);
407 /* Return the type's tag, or None. */
409 typy_get_tag (PyObject
*self
, void *closure
)
411 struct type
*type
= ((type_object
*) self
)->type
;
413 if (!TYPE_TAG_NAME (type
))
415 return PyString_FromString (TYPE_TAG_NAME (type
));
418 /* Return the type, stripped of typedefs. */
420 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
422 struct type
*type
= ((type_object
*) self
)->type
;
423 volatile struct gdb_exception except
;
425 TRY_CATCH (except
, RETURN_MASK_ALL
)
427 type
= check_typedef (type
);
429 GDB_PY_HANDLE_EXCEPTION (except
);
431 return type_to_type_object (type
);
434 /* Strip typedefs and pointers/reference from a type. Then check that
435 it is a struct, union, or enum type. If not, raise TypeError. */
438 typy_get_composite (struct type
*type
)
440 volatile struct gdb_exception except
;
444 TRY_CATCH (except
, RETURN_MASK_ALL
)
446 CHECK_TYPEDEF (type
);
448 GDB_PY_HANDLE_EXCEPTION (except
);
450 if (TYPE_CODE (type
) != TYPE_CODE_PTR
451 && TYPE_CODE (type
) != TYPE_CODE_REF
)
453 type
= TYPE_TARGET_TYPE (type
);
456 /* If this is not a struct, union, or enum type, raise TypeError
458 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
459 && TYPE_CODE (type
) != TYPE_CODE_UNION
460 && TYPE_CODE (type
) != TYPE_CODE_ENUM
)
462 PyErr_SetString (PyExc_TypeError
,
463 "Type is not a structure, union, or enum type.");
470 /* Helper for typy_array and typy_vector. */
473 typy_array_1 (PyObject
*self
, PyObject
*args
, int is_vector
)
476 PyObject
*n2_obj
= NULL
;
477 struct type
*array
= NULL
;
478 struct type
*type
= ((type_object
*) self
)->type
;
479 volatile struct gdb_exception except
;
481 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
486 if (!PyInt_Check (n2_obj
))
488 PyErr_SetString (PyExc_RuntimeError
,
489 _("Array bound must be an integer"));
493 if (! gdb_py_int_as_long (n2_obj
, &n2
))
504 PyErr_SetString (PyExc_ValueError
,
505 _("Array length must not be negative"));
509 TRY_CATCH (except
, RETURN_MASK_ALL
)
511 array
= lookup_array_range_type (type
, n1
, n2
);
513 make_vector_type (array
);
515 GDB_PY_HANDLE_EXCEPTION (except
);
517 return type_to_type_object (array
);
520 /* Return an array type. */
523 typy_array (PyObject
*self
, PyObject
*args
)
525 return typy_array_1 (self
, args
, 0);
528 /* Return a vector type. */
531 typy_vector (PyObject
*self
, PyObject
*args
)
533 return typy_array_1 (self
, args
, 1);
536 /* Return a Type object which represents a pointer to SELF. */
538 typy_pointer (PyObject
*self
, PyObject
*args
)
540 struct type
*type
= ((type_object
*) self
)->type
;
541 volatile struct gdb_exception except
;
543 TRY_CATCH (except
, RETURN_MASK_ALL
)
545 type
= lookup_pointer_type (type
);
547 GDB_PY_HANDLE_EXCEPTION (except
);
549 return type_to_type_object (type
);
552 /* Return the range of a type represented by SELF. The return type is
553 a tuple. The first element of the tuple contains the low bound,
554 while the second element of the tuple contains the high bound. */
556 typy_range (PyObject
*self
, PyObject
*args
)
558 struct type
*type
= ((type_object
*) self
)->type
;
560 PyObject
*low_bound
= NULL
, *high_bound
= NULL
;
561 /* Initialize these to appease GCC warnings. */
562 LONGEST low
= 0, high
= 0;
564 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
565 && TYPE_CODE (type
) != TYPE_CODE_STRING
566 && TYPE_CODE (type
) != TYPE_CODE_RANGE
)
568 PyErr_SetString (PyExc_RuntimeError
,
569 _("This type does not have a range."));
573 switch (TYPE_CODE (type
))
575 case TYPE_CODE_ARRAY
:
576 case TYPE_CODE_STRING
:
577 low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
578 high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
));
580 case TYPE_CODE_RANGE
:
581 low
= TYPE_LOW_BOUND (type
);
582 high
= TYPE_HIGH_BOUND (type
);
586 low_bound
= PyLong_FromLong (low
);
590 high_bound
= PyLong_FromLong (high
);
594 result
= PyTuple_New (2);
598 if (PyTuple_SetItem (result
, 0, low_bound
) != 0)
603 if (PyTuple_SetItem (result
, 1, high_bound
) != 0)
605 Py_DECREF (high_bound
);
612 Py_XDECREF (high_bound
);
613 Py_XDECREF (low_bound
);
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
;
622 volatile struct gdb_exception except
;
624 TRY_CATCH (except
, RETURN_MASK_ALL
)
626 type
= lookup_reference_type (type
);
628 GDB_PY_HANDLE_EXCEPTION (except
);
630 return type_to_type_object (type
);
633 /* Return a Type object which represents the target type of SELF. */
635 typy_target (PyObject
*self
, PyObject
*args
)
637 struct type
*type
= ((type_object
*) self
)->type
;
639 if (!TYPE_TARGET_TYPE (type
))
641 PyErr_SetString (PyExc_RuntimeError
,
642 _("Type does not have a target."));
646 return type_to_type_object (TYPE_TARGET_TYPE (type
));
649 /* Return a const-qualified type variant. */
651 typy_const (PyObject
*self
, PyObject
*args
)
653 struct type
*type
= ((type_object
*) self
)->type
;
654 volatile struct gdb_exception except
;
656 TRY_CATCH (except
, RETURN_MASK_ALL
)
658 type
= make_cv_type (1, 0, type
, NULL
);
660 GDB_PY_HANDLE_EXCEPTION (except
);
662 return type_to_type_object (type
);
665 /* Return a volatile-qualified type variant. */
667 typy_volatile (PyObject
*self
, PyObject
*args
)
669 struct type
*type
= ((type_object
*) self
)->type
;
670 volatile struct gdb_exception except
;
672 TRY_CATCH (except
, RETURN_MASK_ALL
)
674 type
= make_cv_type (0, 1, type
, NULL
);
676 GDB_PY_HANDLE_EXCEPTION (except
);
678 return type_to_type_object (type
);
681 /* Return an unqualified type variant. */
683 typy_unqualified (PyObject
*self
, PyObject
*args
)
685 struct type
*type
= ((type_object
*) self
)->type
;
686 volatile struct gdb_exception except
;
688 TRY_CATCH (except
, RETURN_MASK_ALL
)
690 type
= make_cv_type (0, 0, type
, NULL
);
692 GDB_PY_HANDLE_EXCEPTION (except
);
694 return type_to_type_object (type
);
697 /* Return the size of the type represented by SELF, in bytes. */
699 typy_get_sizeof (PyObject
*self
, void *closure
)
701 struct type
*type
= ((type_object
*) self
)->type
;
702 volatile struct gdb_exception except
;
704 TRY_CATCH (except
, RETURN_MASK_ALL
)
706 check_typedef (type
);
708 /* Ignore exceptions. */
710 return gdb_py_long_from_longest (TYPE_LENGTH (type
));
714 typy_lookup_typename (const char *type_name
, const struct block
*block
)
716 struct type
*type
= NULL
;
717 volatile struct gdb_exception except
;
719 TRY_CATCH (except
, RETURN_MASK_ALL
)
721 if (!strncmp (type_name
, "struct ", 7))
722 type
= lookup_struct (type_name
+ 7, NULL
);
723 else if (!strncmp (type_name
, "union ", 6))
724 type
= lookup_union (type_name
+ 6, NULL
);
725 else if (!strncmp (type_name
, "enum ", 5))
726 type
= lookup_enum (type_name
+ 5, NULL
);
728 type
= lookup_typename (python_language
, python_gdbarch
,
729 type_name
, block
, 0);
731 GDB_PY_HANDLE_EXCEPTION (except
);
737 typy_lookup_type (struct demangle_component
*demangled
,
738 const struct block
*block
)
740 struct type
*type
, *rtype
= NULL
;
741 char *type_name
= NULL
;
742 enum demangle_component_type demangled_type
;
743 volatile struct gdb_exception except
;
745 /* Save the type: typy_lookup_type() may (indirectly) overwrite
746 memory pointed by demangled. */
747 demangled_type
= demangled
->type
;
749 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
750 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
751 || demangled_type
== DEMANGLE_COMPONENT_CONST
752 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
754 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
758 TRY_CATCH (except
, RETURN_MASK_ALL
)
760 /* If the demangled_type matches with one of the types
761 below, run the corresponding function and save the type
762 to return later. We cannot just return here as we are in
763 an exception handler. */
764 switch (demangled_type
)
766 case DEMANGLE_COMPONENT_REFERENCE
:
767 rtype
= lookup_reference_type (type
);
769 case DEMANGLE_COMPONENT_POINTER
:
770 rtype
= lookup_pointer_type (type
);
772 case DEMANGLE_COMPONENT_CONST
:
773 rtype
= make_cv_type (1, 0, type
, NULL
);
775 case DEMANGLE_COMPONENT_VOLATILE
:
776 rtype
= make_cv_type (0, 1, type
, NULL
);
780 GDB_PY_HANDLE_EXCEPTION (except
);
783 /* If we have a type from the switch statement above, just return
788 /* We don't have a type, so lookup the type. */
789 type_name
= cp_comp_to_string (demangled
, 10);
790 type
= typy_lookup_typename (type_name
, block
);
796 /* This is a helper function for typy_template_argument that is used
797 when the type does not have template symbols attached. It works by
798 parsing the type name. This happens with compilers, like older
799 versions of GCC, that do not emit DW_TAG_template_*. */
802 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
806 struct demangle_component
*demangled
;
807 struct demangle_parse_info
*info
= NULL
;
809 struct type
*argtype
;
810 struct cleanup
*cleanup
;
811 volatile struct gdb_exception except
;
813 if (TYPE_NAME (type
) == NULL
)
815 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
819 TRY_CATCH (except
, RETURN_MASK_ALL
)
821 /* Note -- this is not thread-safe. */
822 info
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
824 GDB_PY_HANDLE_EXCEPTION (except
);
828 PyErr_SetString (PyExc_RuntimeError
, err
);
831 demangled
= info
->tree
;
832 cleanup
= make_cleanup_cp_demangled_name_parse_free (info
);
834 /* Strip off component names. */
835 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
836 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
837 demangled
= demangled
->u
.s_binary
.right
;
839 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
841 do_cleanups (cleanup
);
842 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
846 /* Skip from the template to the arguments. */
847 demangled
= demangled
->u
.s_binary
.right
;
849 for (i
= 0; demangled
&& i
< argno
; ++i
)
850 demangled
= demangled
->u
.s_binary
.right
;
854 do_cleanups (cleanup
);
855 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
860 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
861 do_cleanups (cleanup
);
865 return type_to_type_object (argtype
);
869 typy_template_argument (PyObject
*self
, PyObject
*args
)
872 struct type
*type
= ((type_object
*) self
)->type
;
873 const struct block
*block
= NULL
;
874 PyObject
*block_obj
= NULL
;
876 struct value
*val
= NULL
;
877 volatile struct gdb_exception except
;
879 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
884 block
= block_object_to_block (block_obj
);
887 PyErr_SetString (PyExc_RuntimeError
,
888 _("Second argument must be block."));
893 TRY_CATCH (except
, RETURN_MASK_ALL
)
895 type
= check_typedef (type
);
896 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
897 type
= check_typedef (TYPE_TARGET_TYPE (type
));
899 GDB_PY_HANDLE_EXCEPTION (except
);
901 /* We might not have DW_TAG_template_*, so try to parse the type's
902 name. This is inefficient if we do not have a template type --
903 but that is going to wind up as an error anyhow. */
904 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
905 return typy_legacy_template_argument (type
, block
, argno
);
907 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
909 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
914 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
915 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
916 return type_to_type_object (SYMBOL_TYPE (sym
));
917 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
919 PyErr_Format (PyExc_RuntimeError
,
920 _("Template argument is optimized out"));
924 TRY_CATCH (except
, RETURN_MASK_ALL
)
926 val
= value_of_variable (sym
, block
);
928 GDB_PY_HANDLE_EXCEPTION (except
);
930 return value_to_value_object (val
);
934 typy_str (PyObject
*self
)
936 volatile struct gdb_exception except
;
937 char *thetype
= NULL
;
941 TRY_CATCH (except
, RETURN_MASK_ALL
)
943 struct cleanup
*old_chain
;
946 stb
= mem_fileopen ();
947 old_chain
= make_cleanup_ui_file_delete (stb
);
949 LA_PRINT_TYPE (type_object_to_type (self
), "", stb
, -1, 0,
950 &type_print_raw_options
);
952 thetype
= ui_file_xstrdup (stb
, &length
);
953 do_cleanups (old_chain
);
955 if (except
.reason
< 0)
958 GDB_PY_HANDLE_EXCEPTION (except
);
961 result
= PyUnicode_Decode (thetype
, length
, host_charset (), NULL
);
967 /* An entry in the type-equality bcache. */
969 typedef struct type_equality_entry
971 struct type
*type1
, *type2
;
972 } type_equality_entry_d
;
974 DEF_VEC_O (type_equality_entry_d
);
976 /* A helper function to compare two strings. Returns 1 if they are
977 the same, 0 otherwise. Handles NULLs properly. */
980 compare_maybe_null_strings (const char *s
, const char *t
)
982 if (s
== NULL
&& t
!= NULL
)
984 else if (s
!= NULL
&& t
== NULL
)
986 else if (s
== NULL
&& t
== NULL
)
988 return strcmp (s
, t
) == 0;
991 /* A helper function for typy_richcompare that checks two types for
992 "deep" equality. Returns Py_EQ if the types are considered the
993 same, Py_NE otherwise. */
996 check_types_equal (struct type
*type1
, struct type
*type2
,
997 VEC (type_equality_entry_d
) **worklist
)
999 CHECK_TYPEDEF (type1
);
1000 CHECK_TYPEDEF (type2
);
1005 if (TYPE_CODE (type1
) != TYPE_CODE (type2
)
1006 || TYPE_LENGTH (type1
) != TYPE_LENGTH (type2
)
1007 || TYPE_UNSIGNED (type1
) != TYPE_UNSIGNED (type2
)
1008 || TYPE_NOSIGN (type1
) != TYPE_NOSIGN (type2
)
1009 || TYPE_VARARGS (type1
) != TYPE_VARARGS (type2
)
1010 || TYPE_VECTOR (type1
) != TYPE_VECTOR (type2
)
1011 || TYPE_NOTTEXT (type1
) != TYPE_NOTTEXT (type2
)
1012 || TYPE_INSTANCE_FLAGS (type1
) != TYPE_INSTANCE_FLAGS (type2
)
1013 || TYPE_NFIELDS (type1
) != TYPE_NFIELDS (type2
))
1016 if (!compare_maybe_null_strings (TYPE_TAG_NAME (type1
),
1017 TYPE_TAG_NAME (type2
)))
1019 if (!compare_maybe_null_strings (TYPE_NAME (type1
), TYPE_NAME (type2
)))
1022 if (TYPE_CODE (type1
) == TYPE_CODE_RANGE
)
1024 if (memcmp (TYPE_RANGE_DATA (type1
), TYPE_RANGE_DATA (type2
),
1025 sizeof (*TYPE_RANGE_DATA (type1
))) != 0)
1032 for (i
= 0; i
< TYPE_NFIELDS (type1
); ++i
)
1034 const struct field
*field1
= &TYPE_FIELD (type1
, i
);
1035 const struct field
*field2
= &TYPE_FIELD (type2
, i
);
1036 struct type_equality_entry entry
;
1038 if (FIELD_ARTIFICIAL (*field1
) != FIELD_ARTIFICIAL (*field2
)
1039 || FIELD_BITSIZE (*field1
) != FIELD_BITSIZE (*field2
)
1040 || FIELD_LOC_KIND (*field1
) != FIELD_LOC_KIND (*field2
))
1042 if (!compare_maybe_null_strings (FIELD_NAME (*field1
),
1043 FIELD_NAME (*field2
)))
1045 switch (FIELD_LOC_KIND (*field1
))
1047 case FIELD_LOC_KIND_BITPOS
:
1048 if (FIELD_BITPOS (*field1
) != FIELD_BITPOS (*field2
))
1051 case FIELD_LOC_KIND_ENUMVAL
:
1052 if (FIELD_ENUMVAL (*field1
) != FIELD_ENUMVAL (*field2
))
1055 case FIELD_LOC_KIND_PHYSADDR
:
1056 if (FIELD_STATIC_PHYSADDR (*field1
)
1057 != FIELD_STATIC_PHYSADDR (*field2
))
1060 case FIELD_LOC_KIND_PHYSNAME
:
1061 if (!compare_maybe_null_strings (FIELD_STATIC_PHYSNAME (*field1
),
1062 FIELD_STATIC_PHYSNAME (*field2
)))
1065 case FIELD_LOC_KIND_DWARF_BLOCK
:
1067 struct dwarf2_locexpr_baton
*block1
, *block2
;
1069 block1
= FIELD_DWARF_BLOCK (*field1
);
1070 block2
= FIELD_DWARF_BLOCK (*field2
);
1071 if (block1
->per_cu
!= block2
->per_cu
1072 || block1
->size
!= block2
->size
1073 || memcmp (block1
->data
, block2
->data
, block1
->size
) != 0)
1078 internal_error (__FILE__
, __LINE__
, _("Unsupported field kind "
1079 "%d by check_types_equal"),
1080 FIELD_LOC_KIND (*field1
));
1083 entry
.type1
= FIELD_TYPE (*field1
);
1084 entry
.type2
= FIELD_TYPE (*field2
);
1085 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
1089 if (TYPE_TARGET_TYPE (type1
) != NULL
)
1091 struct type_equality_entry entry
;
1093 if (TYPE_TARGET_TYPE (type2
) == NULL
)
1096 entry
.type1
= TYPE_TARGET_TYPE (type1
);
1097 entry
.type2
= TYPE_TARGET_TYPE (type2
);
1098 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
1100 else if (TYPE_TARGET_TYPE (type2
) != NULL
)
1106 /* Check types on a worklist for equality. Returns Py_NE if any pair
1107 is not equal, Py_EQ if they are all considered equal. */
1110 check_types_worklist (VEC (type_equality_entry_d
) **worklist
,
1111 struct bcache
*cache
)
1113 while (!VEC_empty (type_equality_entry_d
, *worklist
))
1115 struct type_equality_entry entry
;
1118 entry
= *VEC_last (type_equality_entry_d
, *worklist
);
1119 VEC_pop (type_equality_entry_d
, *worklist
);
1121 /* If the type pair has already been visited, we know it is
1123 bcache_full (&entry
, sizeof (entry
), cache
, &added
);
1127 if (check_types_equal (entry
.type1
, entry
.type2
, worklist
) == Py_NE
)
1134 /* Implement the richcompare method. */
1137 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1140 struct type
*type1
= type_object_to_type (self
);
1141 struct type
*type2
= type_object_to_type (other
);
1142 volatile struct gdb_exception except
;
1144 /* We can only compare ourselves to another Type object, and only
1145 for equality or inequality. */
1146 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
1148 Py_INCREF (Py_NotImplemented
);
1149 return Py_NotImplemented
;
1156 struct bcache
*cache
;
1157 VEC (type_equality_entry_d
) *worklist
= NULL
;
1158 struct type_equality_entry entry
;
1160 cache
= bcache_xmalloc (NULL
, NULL
);
1162 entry
.type1
= type1
;
1163 entry
.type2
= type2
;
1164 VEC_safe_push (type_equality_entry_d
, worklist
, &entry
);
1166 TRY_CATCH (except
, RETURN_MASK_ALL
)
1168 result
= check_types_worklist (&worklist
, cache
);
1170 /* check_types_worklist calls several nested Python helper
1171 functions, some of which can raise a GDB Exception, so we
1172 just check and convert here. If there is a GDB exception, a
1173 comparison is not capable (or trusted), so exit. */
1174 bcache_xfree (cache
);
1175 VEC_free (type_equality_entry_d
, worklist
);
1176 GDB_PY_HANDLE_EXCEPTION (except
);
1186 static const struct objfile_data
*typy_objfile_data_key
;
1189 save_objfile_types (struct objfile
*objfile
, void *datum
)
1191 type_object
*obj
= datum
;
1192 htab_t copied_types
;
1193 struct cleanup
*cleanup
;
1195 if (!gdb_python_initialized
)
1198 /* This prevents another thread from freeing the objects we're
1200 cleanup
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1202 copied_types
= create_copied_types_hash (objfile
);
1206 type_object
*next
= obj
->next
;
1208 htab_empty (copied_types
);
1210 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1218 htab_delete (copied_types
);
1220 do_cleanups (cleanup
);
1224 set_type (type_object
*obj
, struct type
*type
)
1228 if (type
&& TYPE_OBJFILE (type
))
1230 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1232 obj
->next
= objfile_data (objfile
, typy_objfile_data_key
);
1234 obj
->next
->prev
= obj
;
1235 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1242 typy_dealloc (PyObject
*obj
)
1244 type_object
*type
= (type_object
*) obj
;
1247 type
->prev
->next
= type
->next
;
1248 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1250 /* Must reset head of list. */
1251 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1254 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1257 type
->next
->prev
= type
->prev
;
1259 Py_TYPE (type
)->tp_free (type
);
1262 /* Return number of fields ("length" of the field dictionary). */
1265 typy_length (PyObject
*self
)
1267 struct type
*type
= ((type_object
*) self
)->type
;
1269 type
= typy_get_composite (type
);
1273 return TYPE_NFIELDS (type
);
1276 /* Implements boolean evaluation of gdb.Type. Handle this like other
1277 Python objects that don't have a meaningful truth value -- all
1281 typy_nonzero (PyObject
*self
)
1286 /* Return a gdb.Field object for the field named by the argument. */
1289 typy_getitem (PyObject
*self
, PyObject
*key
)
1291 struct type
*type
= ((type_object
*) self
)->type
;
1295 field
= python_string_to_host_string (key
);
1299 /* We want just fields of this type, not of base types, so instead of
1300 using lookup_struct_elt_type, portions of that function are
1303 type
= typy_get_composite (type
);
1307 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1309 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1311 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1313 return convert_field (type
, i
);
1316 PyErr_SetObject (PyExc_KeyError
, key
);
1320 /* Implement the "get" method on the type object. This is the
1321 same as getitem if the key is present, but returns the supplied
1322 default value or None if the key is not found. */
1325 typy_get (PyObject
*self
, PyObject
*args
)
1327 PyObject
*key
, *defval
= Py_None
, *result
;
1329 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1332 result
= typy_getitem (self
, key
);
1336 /* typy_getitem returned error status. If the exception is
1337 KeyError, clear the exception status and return the defval
1338 instead. Otherwise return the exception unchanged. */
1339 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1347 /* Implement the "has_key" method on the type object. */
1350 typy_has_key (PyObject
*self
, PyObject
*args
)
1352 struct type
*type
= ((type_object
*) self
)->type
;
1356 if (!PyArg_ParseTuple (args
, "s", &field
))
1359 /* We want just fields of this type, not of base types, so instead of
1360 using lookup_struct_elt_type, portions of that function are
1363 type
= typy_get_composite (type
);
1367 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1369 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1371 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1377 /* Make an iterator object to iterate over keys, values, or items. */
1380 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1382 typy_iterator_object
*typy_iter_obj
;
1384 /* Check that "self" is a structure or union type. */
1385 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1388 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1389 &type_iterator_object_type
);
1390 if (typy_iter_obj
== NULL
)
1393 typy_iter_obj
->field
= 0;
1394 typy_iter_obj
->kind
= kind
;
1396 typy_iter_obj
->source
= (type_object
*) self
;
1398 return (PyObject
*) typy_iter_obj
;
1401 /* iteritems() method. */
1404 typy_iteritems (PyObject
*self
, PyObject
*args
)
1406 return typy_make_iter (self
, iter_items
);
1409 /* iterkeys() method. */
1412 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1414 return typy_make_iter (self
, iter_keys
);
1417 /* Iterating over the class, same as iterkeys except for the function
1421 typy_iter (PyObject
*self
)
1423 return typy_make_iter (self
, iter_keys
);
1426 /* itervalues() method. */
1429 typy_itervalues (PyObject
*self
, PyObject
*args
)
1431 return typy_make_iter (self
, iter_values
);
1434 /* Return a reference to the type iterator. */
1437 typy_iterator_iter (PyObject
*self
)
1443 /* Return the next field in the iteration through the list of fields
1447 typy_iterator_iternext (PyObject
*self
)
1449 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1450 struct type
*type
= iter_obj
->source
->type
;
1453 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1455 result
= make_fielditem (type
, iter_obj
->field
, iter_obj
->kind
);
1465 typy_iterator_dealloc (PyObject
*obj
)
1467 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1469 Py_DECREF (iter_obj
->source
);
1472 /* Create a new Type referring to TYPE. */
1474 type_to_type_object (struct type
*type
)
1476 type_object
*type_obj
;
1478 type_obj
= PyObject_New (type_object
, &type_object_type
);
1480 set_type (type_obj
, type
);
1482 return (PyObject
*) type_obj
;
1486 type_object_to_type (PyObject
*obj
)
1488 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1490 return ((type_object
*) obj
)->type
;
1495 /* Implementation of gdb.lookup_type. */
1497 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1499 static char *keywords
[] = { "name", "block", NULL
};
1500 const char *type_name
= NULL
;
1501 struct type
*type
= NULL
;
1502 PyObject
*block_obj
= NULL
;
1503 const struct block
*block
= NULL
;
1505 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1506 &type_name
, &block_obj
))
1511 block
= block_object_to_block (block_obj
);
1514 PyErr_SetString (PyExc_RuntimeError
,
1515 _("'block' argument must be a Block."));
1520 type
= typy_lookup_typename (type_name
, block
);
1524 return (PyObject
*) type_to_type_object (type
);
1528 gdbpy_initialize_types (void)
1532 typy_objfile_data_key
1533 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1535 if (PyType_Ready (&type_object_type
) < 0)
1537 if (PyType_Ready (&field_object_type
) < 0)
1539 if (PyType_Ready (&type_iterator_object_type
) < 0)
1542 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1544 if (PyModule_AddIntConstant (gdb_module
,
1545 /* Cast needed for Python 2.4. */
1546 (char *) pyty_codes
[i
].name
,
1547 pyty_codes
[i
].code
) < 0)
1551 if (gdb_pymodule_addobject (gdb_module
, "Type",
1552 (PyObject
*) &type_object_type
) < 0)
1555 if (gdb_pymodule_addobject (gdb_module
, "TypeIterator",
1556 (PyObject
*) &type_iterator_object_type
) < 0)
1559 return gdb_pymodule_addobject (gdb_module
, "Field",
1560 (PyObject
*) &field_object_type
);
1565 static PyGetSetDef type_object_getset
[] =
1567 { "code", typy_get_code
, NULL
,
1568 "The code for this type.", NULL
},
1569 { "sizeof", typy_get_sizeof
, NULL
,
1570 "The size of this type, in bytes.", NULL
},
1571 { "tag", typy_get_tag
, NULL
,
1572 "The tag name for this type, or None.", NULL
},
1576 static PyMethodDef type_object_methods
[] =
1578 { "array", typy_array
, METH_VARARGS
,
1579 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1580 Return a type which represents an array of objects of this type.\n\
1581 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1582 If LOW_BOUND is omitted, a value of zero is used." },
1583 { "vector", typy_vector
, METH_VARARGS
,
1584 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1585 Return a type which represents a vector of objects of this type.\n\
1586 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1587 If LOW_BOUND is omitted, a value of zero is used.\n\
1588 Vectors differ from arrays in that if the current language has C-style\n\
1589 arrays, vectors don't decay to a pointer to the first element.\n\
1590 They are first class values." },
1591 { "__contains__", typy_has_key
, METH_VARARGS
,
1592 "T.__contains__(k) -> True if T has a field named k, else False" },
1593 { "const", typy_const
, METH_NOARGS
,
1594 "const () -> Type\n\
1595 Return a const variant of this type." },
1596 { "fields", typy_fields
, METH_NOARGS
,
1597 "fields () -> list\n\
1598 Return a list holding all the fields of this type.\n\
1599 Each field is a gdb.Field object." },
1600 { "get", typy_get
, METH_VARARGS
,
1601 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1602 otherwise returns default, if supplied, or None if not." },
1603 { "has_key", typy_has_key
, METH_VARARGS
,
1604 "T.has_key(k) -> True if T has a field named k, else False" },
1605 { "items", typy_items
, METH_NOARGS
,
1606 "items () -> list\n\
1607 Return a list of (name, field) pairs of this type.\n\
1608 Each field is a gdb.Field object." },
1609 { "iteritems", typy_iteritems
, METH_NOARGS
,
1610 "iteritems () -> an iterator over the (name, field)\n\
1611 pairs of this type. Each field is a gdb.Field object." },
1612 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1613 "iterkeys () -> an iterator over the field names of this type." },
1614 { "itervalues", typy_itervalues
, METH_NOARGS
,
1615 "itervalues () -> an iterator over the fields of this type.\n\
1616 Each field is a gdb.Field object." },
1617 { "keys", typy_field_names
, METH_NOARGS
,
1619 Return a list holding all the fields names of this type." },
1620 { "pointer", typy_pointer
, METH_NOARGS
,
1621 "pointer () -> Type\n\
1622 Return a type of pointer to this type." },
1623 { "range", typy_range
, METH_NOARGS
,
1624 "range () -> tuple\n\
1625 Return a tuple containing the lower and upper range for this type."},
1626 { "reference", typy_reference
, METH_NOARGS
,
1627 "reference () -> Type\n\
1628 Return a type of reference to this type." },
1629 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1630 "strip_typedefs () -> Type\n\
1631 Return a type formed by stripping this type of all typedefs."},
1632 { "target", typy_target
, METH_NOARGS
,
1633 "target () -> Type\n\
1634 Return the target type of this type." },
1635 { "template_argument", typy_template_argument
, METH_VARARGS
,
1636 "template_argument (arg, [block]) -> Type\n\
1637 Return the type of a template argument." },
1638 { "unqualified", typy_unqualified
, METH_NOARGS
,
1639 "unqualified () -> Type\n\
1640 Return a variant of this type without const or volatile attributes." },
1641 { "values", typy_values
, METH_NOARGS
,
1642 "values () -> list\n\
1643 Return a list holding all the fields of this type.\n\
1644 Each field is a gdb.Field object." },
1645 { "volatile", typy_volatile
, METH_NOARGS
,
1646 "volatile () -> Type\n\
1647 Return a volatile variant of this type" },
1651 static PyNumberMethods type_object_as_number
= {
1653 NULL
, /* nb_subtract */
1654 NULL
, /* nb_multiply */
1656 NULL
, /* nb_divide */
1658 NULL
, /* nb_remainder */
1659 NULL
, /* nb_divmod */
1660 NULL
, /* nb_power */
1661 NULL
, /* nb_negative */
1662 NULL
, /* nb_positive */
1663 NULL
, /* nb_absolute */
1664 typy_nonzero
, /* nb_nonzero */
1665 NULL
, /* nb_invert */
1666 NULL
, /* nb_lshift */
1667 NULL
, /* nb_rshift */
1673 NULL
, /* reserved */
1675 NULL
, /* nb_coerce */
1679 NULL
, /* nb_float */
1686 static PyMappingMethods typy_mapping
= {
1689 NULL
/* no "set" method */
1692 static PyTypeObject type_object_type
=
1694 PyVarObject_HEAD_INIT (NULL
, 0)
1695 "gdb.Type", /*tp_name*/
1696 sizeof (type_object
), /*tp_basicsize*/
1698 typy_dealloc
, /*tp_dealloc*/
1704 &type_object_as_number
, /*tp_as_number*/
1705 0, /*tp_as_sequence*/
1706 &typy_mapping
, /*tp_as_mapping*/
1709 typy_str
, /*tp_str*/
1713 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1714 "GDB type object", /* tp_doc */
1715 0, /* tp_traverse */
1717 typy_richcompare
, /* tp_richcompare */
1718 0, /* tp_weaklistoffset */
1719 typy_iter
, /* tp_iter */
1720 0, /* tp_iternext */
1721 type_object_methods
, /* tp_methods */
1723 type_object_getset
, /* tp_getset */
1726 0, /* tp_descr_get */
1727 0, /* tp_descr_set */
1728 0, /* tp_dictoffset */
1734 static PyGetSetDef field_object_getset
[] =
1736 { "__dict__", gdb_py_generic_dict
, NULL
,
1737 "The __dict__ for this field.", &field_object_type
},
1741 static PyTypeObject field_object_type
=
1743 PyVarObject_HEAD_INIT (NULL
, 0)
1744 "gdb.Field", /*tp_name*/
1745 sizeof (field_object
), /*tp_basicsize*/
1747 field_dealloc
, /*tp_dealloc*/
1754 0, /*tp_as_sequence*/
1755 0, /*tp_as_mapping*/
1762 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1763 "GDB field object", /* tp_doc */
1764 0, /* tp_traverse */
1766 0, /* tp_richcompare */
1767 0, /* tp_weaklistoffset */
1769 0, /* tp_iternext */
1772 field_object_getset
, /* tp_getset */
1775 0, /* tp_descr_get */
1776 0, /* tp_descr_set */
1777 offsetof (field_object
, dict
), /* tp_dictoffset */
1783 static PyTypeObject type_iterator_object_type
= {
1784 PyVarObject_HEAD_INIT (NULL
, 0)
1785 "gdb.TypeIterator", /*tp_name*/
1786 sizeof (typy_iterator_object
), /*tp_basicsize*/
1788 typy_iterator_dealloc
, /*tp_dealloc*/
1795 0, /*tp_as_sequence*/
1796 0, /*tp_as_mapping*/
1803 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1804 "GDB type iterator object", /*tp_doc */
1807 0, /*tp_richcompare */
1808 0, /*tp_weaklistoffset */
1809 typy_iterator_iter
, /*tp_iter */
1810 typy_iterator_iternext
, /*tp_iternext */