1 /* Python interface to types.
3 Copyright (C) 2008-2012 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"
34 typedef struct pyty_type_object
39 /* If a Type object is associated with an objfile, it is kept on a
40 doubly-linked list, rooted in the objfile. This lets us copy the
41 underlying struct type when the objfile is deleted. */
42 struct pyty_type_object
*prev
;
43 struct pyty_type_object
*next
;
46 static PyTypeObject type_object_type
;
49 typedef struct pyty_field_object
53 /* Dictionary holding our attributes. */
57 static PyTypeObject field_object_type
;
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 static PyTypeObject type_iterator_object_type
;
72 /* This is used to initialize various gdb.TYPE_ constants. */
81 /* Forward declarations. */
82 static PyObject
*typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
);
84 #define ENTRY(X) { X, #X }
86 static struct pyty_code pyty_codes
[] =
88 ENTRY (TYPE_CODE_PTR
),
89 ENTRY (TYPE_CODE_ARRAY
),
90 ENTRY (TYPE_CODE_STRUCT
),
91 ENTRY (TYPE_CODE_UNION
),
92 ENTRY (TYPE_CODE_ENUM
),
93 ENTRY (TYPE_CODE_FLAGS
),
94 ENTRY (TYPE_CODE_FUNC
),
95 ENTRY (TYPE_CODE_INT
),
96 ENTRY (TYPE_CODE_FLT
),
97 ENTRY (TYPE_CODE_VOID
),
98 ENTRY (TYPE_CODE_SET
),
99 ENTRY (TYPE_CODE_RANGE
),
100 ENTRY (TYPE_CODE_STRING
),
101 ENTRY (TYPE_CODE_BITSTRING
),
102 ENTRY (TYPE_CODE_ERROR
),
103 ENTRY (TYPE_CODE_METHOD
),
104 ENTRY (TYPE_CODE_METHODPTR
),
105 ENTRY (TYPE_CODE_MEMBERPTR
),
106 ENTRY (TYPE_CODE_REF
),
107 ENTRY (TYPE_CODE_CHAR
),
108 ENTRY (TYPE_CODE_BOOL
),
109 ENTRY (TYPE_CODE_COMPLEX
),
110 ENTRY (TYPE_CODE_TYPEDEF
),
111 ENTRY (TYPE_CODE_NAMESPACE
),
112 ENTRY (TYPE_CODE_DECFLOAT
),
113 ENTRY (TYPE_CODE_INTERNAL_FUNCTION
),
114 { TYPE_CODE_UNDEF
, NULL
}
120 field_dealloc (PyObject
*obj
)
122 field_object
*f
= (field_object
*) obj
;
124 Py_XDECREF (f
->dict
);
125 f
->ob_type
->tp_free (obj
);
131 field_object
*result
= PyObject_New (field_object
, &field_object_type
);
135 result
->dict
= PyDict_New ();
142 return (PyObject
*) result
;
147 /* Return the code for this type. */
149 typy_get_code (PyObject
*self
, void *closure
)
151 struct type
*type
= ((type_object
*) self
)->type
;
153 return PyInt_FromLong (TYPE_CODE (type
));
156 /* Helper function for typy_fields which converts a single field to a
157 gdb.Field object. Returns NULL on error. */
160 convert_field (struct type
*type
, int field
)
162 PyObject
*result
= field_new ();
168 if (!field_is_static (&TYPE_FIELD (type
, field
)))
170 arg
= PyLong_FromLong (TYPE_FIELD_BITPOS (type
, field
));
174 if (PyObject_SetAttrString (result
, "bitpos", arg
) < 0)
178 if (TYPE_FIELD_NAME (type
, field
))
179 arg
= PyString_FromString (TYPE_FIELD_NAME (type
, field
));
187 if (PyObject_SetAttrString (result
, "name", arg
) < 0)
190 arg
= TYPE_FIELD_ARTIFICIAL (type
, field
) ? Py_True
: Py_False
;
192 if (PyObject_SetAttrString (result
, "artificial", arg
) < 0)
195 if (TYPE_CODE (type
) == TYPE_CODE_CLASS
)
196 arg
= field
< TYPE_N_BASECLASSES (type
) ? Py_True
: Py_False
;
200 if (PyObject_SetAttrString (result
, "is_base_class", arg
) < 0)
203 arg
= PyLong_FromLong (TYPE_FIELD_BITSIZE (type
, field
));
206 if (PyObject_SetAttrString (result
, "bitsize", arg
) < 0)
209 /* A field can have a NULL type in some situations. */
210 if (TYPE_FIELD_TYPE (type
, field
) == NULL
)
216 arg
= type_to_type_object (TYPE_FIELD_TYPE (type
, field
));
219 if (PyObject_SetAttrString (result
, "type", arg
) < 0)
231 /* Helper function to return the name of a field, as a gdb.Field object.
232 If the field doesn't have a name, None is returned. */
235 field_name (struct type
*type
, int field
)
239 if (TYPE_FIELD_NAME (type
, field
))
240 result
= PyString_FromString (TYPE_FIELD_NAME (type
, field
));
249 /* Helper function for Type standard mapping methods. Returns a
250 Python object for field i of the type. "kind" specifies what to
251 return: the name of the field, a gdb.Field object corresponding to
252 the field, or a tuple consisting of field name and gdb.Field
256 make_fielditem (struct type
*type
, int i
, enum gdbpy_iter_kind kind
)
258 PyObject
*item
= NULL
, *key
= NULL
, *value
= NULL
;
263 key
= field_name (type
, i
);
266 value
= convert_field (type
, i
);
269 item
= PyTuple_New (2);
272 PyTuple_SET_ITEM (item
, 0, key
);
273 PyTuple_SET_ITEM (item
, 1, value
);
276 item
= field_name (type
, i
);
279 item
= convert_field (type
, i
);
291 /* Return a sequence of all field names, fields, or (name, field) pairs.
292 Each field is a gdb.Field object. */
295 typy_fields_items (PyObject
*self
, enum gdbpy_iter_kind kind
)
297 PyObject
*py_type
= self
;
298 PyObject
*result
= NULL
, *iter
= NULL
;
299 volatile struct gdb_exception except
;
300 struct type
*type
= ((type_object
*) py_type
)->type
;
301 struct type
*checked_type
= type
;
303 TRY_CATCH (except
, RETURN_MASK_ALL
)
305 CHECK_TYPEDEF (checked_type
);
307 GDB_PY_HANDLE_EXCEPTION (except
);
309 if (checked_type
!= type
)
310 py_type
= type_to_type_object (checked_type
);
311 iter
= typy_make_iter (py_type
, kind
);
312 if (checked_type
!= type
)
314 /* Need to wrap this in braces because Py_DECREF isn't wrapped
315 in a do{}while(0). */
320 result
= PySequence_List (iter
);
327 /* Return a sequence of all fields. Each field is a gdb.Field object. */
330 typy_values (PyObject
*self
, PyObject
*args
)
332 return typy_fields_items (self
, iter_values
);
335 /* Return a sequence of all fields. Each field is a gdb.Field object.
336 This method is similar to typy_values, except where the supplied
337 gdb.Type is an array, in which case it returns a list of one entry
338 which is a gdb.Field object for a range (the array bounds). */
341 typy_fields (PyObject
*self
, PyObject
*args
)
343 struct type
*type
= ((type_object
*) self
)->type
;
346 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
347 return typy_fields_items (self
, iter_values
);
349 /* Array type. Handle this as a special case because the common
350 machinery wants struct or union or enum types. Build a list of
351 one entry which is the range for the array. */
352 r
= convert_field (type
, 0);
356 rl
= Py_BuildValue ("[O]", r
);
365 /* Return a sequence of all field names. Each field is a gdb.Field object. */
368 typy_field_names (PyObject
*self
, PyObject
*args
)
370 return typy_fields_items (self
, iter_keys
);
373 /* Return a sequence of all (name, fields) pairs. Each field is a
377 typy_items (PyObject
*self
, PyObject
*args
)
379 return typy_fields_items (self
, iter_items
);
382 /* Return the type's tag, or None. */
384 typy_get_tag (PyObject
*self
, void *closure
)
386 struct type
*type
= ((type_object
*) self
)->type
;
388 if (!TYPE_TAG_NAME (type
))
390 return PyString_FromString (TYPE_TAG_NAME (type
));
393 /* Return the type, stripped of typedefs. */
395 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
397 struct type
*type
= ((type_object
*) self
)->type
;
398 volatile struct gdb_exception except
;
400 TRY_CATCH (except
, RETURN_MASK_ALL
)
402 type
= check_typedef (type
);
404 GDB_PY_HANDLE_EXCEPTION (except
);
406 return type_to_type_object (check_typedef (type
));
409 /* Strip typedefs and pointers/reference from a type. Then check that
410 it is a struct, union, or enum type. If not, raise TypeError. */
413 typy_get_composite (struct type
*type
)
415 volatile struct gdb_exception except
;
419 TRY_CATCH (except
, RETURN_MASK_ALL
)
421 CHECK_TYPEDEF (type
);
423 /* Don't use GDB_PY_HANDLE_EXCEPTION here because that returns
424 a (NULL) pointer of the wrong type. */
425 if (except
.reason
< 0)
427 gdbpy_convert_exception (except
);
431 if (TYPE_CODE (type
) != TYPE_CODE_PTR
432 && TYPE_CODE (type
) != TYPE_CODE_REF
)
434 type
= TYPE_TARGET_TYPE (type
);
437 /* If this is not a struct, union, or enum type, raise TypeError
439 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
440 && TYPE_CODE (type
) != TYPE_CODE_UNION
441 && TYPE_CODE (type
) != TYPE_CODE_ENUM
)
443 PyErr_SetString (PyExc_TypeError
,
444 "Type is not a structure, union, or enum type.");
451 /* Return an array type. */
454 typy_array (PyObject
*self
, PyObject
*args
)
457 PyObject
*n2_obj
= NULL
;
458 struct type
*array
= NULL
;
459 struct type
*type
= ((type_object
*) self
)->type
;
460 volatile struct gdb_exception except
;
462 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
467 if (!PyInt_Check (n2_obj
))
469 PyErr_SetString (PyExc_RuntimeError
,
470 _("Array bound must be an integer"));
474 if (! gdb_py_int_as_long (n2_obj
, &n2
))
485 PyErr_SetString (PyExc_ValueError
,
486 _("Array length must not be negative"));
490 TRY_CATCH (except
, RETURN_MASK_ALL
)
492 array
= lookup_array_range_type (type
, n1
, n2
);
494 GDB_PY_HANDLE_EXCEPTION (except
);
496 return type_to_type_object (array
);
499 /* Return a Type object which represents a pointer to SELF. */
501 typy_pointer (PyObject
*self
, PyObject
*args
)
503 struct type
*type
= ((type_object
*) self
)->type
;
504 volatile struct gdb_exception except
;
506 TRY_CATCH (except
, RETURN_MASK_ALL
)
508 type
= lookup_pointer_type (type
);
510 GDB_PY_HANDLE_EXCEPTION (except
);
512 return type_to_type_object (type
);
515 /* Return the range of a type represented by SELF. The return type is
516 a tuple. The first element of the tuple contains the low bound,
517 while the second element of the tuple contains the high bound. */
519 typy_range (PyObject
*self
, PyObject
*args
)
521 struct type
*type
= ((type_object
*) self
)->type
;
523 PyObject
*low_bound
= NULL
, *high_bound
= NULL
;
524 /* Initialize these to appease GCC warnings. */
525 LONGEST low
= 0, high
= 0;
527 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
528 && TYPE_CODE (type
) != TYPE_CODE_STRING
529 && TYPE_CODE (type
) != TYPE_CODE_RANGE
)
531 PyErr_SetString (PyExc_RuntimeError
,
532 _("This type does not have a range."));
536 switch (TYPE_CODE (type
))
538 case TYPE_CODE_ARRAY
:
539 case TYPE_CODE_STRING
:
540 low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
541 high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
));
543 case TYPE_CODE_RANGE
:
544 low
= TYPE_LOW_BOUND (type
);
545 high
= TYPE_HIGH_BOUND (type
);
549 low_bound
= PyLong_FromLong (low
);
553 high_bound
= PyLong_FromLong (high
);
557 result
= PyTuple_New (2);
561 if (PyTuple_SetItem (result
, 0, low_bound
) != 0)
566 if (PyTuple_SetItem (result
, 1, high_bound
) != 0)
568 Py_DECREF (high_bound
);
575 Py_XDECREF (high_bound
);
576 Py_XDECREF (low_bound
);
580 /* Return a Type object which represents a reference to SELF. */
582 typy_reference (PyObject
*self
, PyObject
*args
)
584 struct type
*type
= ((type_object
*) self
)->type
;
585 volatile struct gdb_exception except
;
587 TRY_CATCH (except
, RETURN_MASK_ALL
)
589 type
= lookup_reference_type (type
);
591 GDB_PY_HANDLE_EXCEPTION (except
);
593 return type_to_type_object (type
);
596 /* Return a Type object which represents the target type of SELF. */
598 typy_target (PyObject
*self
, PyObject
*args
)
600 struct type
*type
= ((type_object
*) self
)->type
;
602 if (!TYPE_TARGET_TYPE (type
))
604 PyErr_SetString (PyExc_RuntimeError
,
605 _("Type does not have a target."));
609 return type_to_type_object (TYPE_TARGET_TYPE (type
));
612 /* Return a const-qualified type variant. */
614 typy_const (PyObject
*self
, PyObject
*args
)
616 struct type
*type
= ((type_object
*) self
)->type
;
617 volatile struct gdb_exception except
;
619 TRY_CATCH (except
, RETURN_MASK_ALL
)
621 type
= make_cv_type (1, 0, type
, NULL
);
623 GDB_PY_HANDLE_EXCEPTION (except
);
625 return type_to_type_object (type
);
628 /* Return a volatile-qualified type variant. */
630 typy_volatile (PyObject
*self
, PyObject
*args
)
632 struct type
*type
= ((type_object
*) self
)->type
;
633 volatile struct gdb_exception except
;
635 TRY_CATCH (except
, RETURN_MASK_ALL
)
637 type
= make_cv_type (0, 1, type
, NULL
);
639 GDB_PY_HANDLE_EXCEPTION (except
);
641 return type_to_type_object (type
);
644 /* Return an unqualified type variant. */
646 typy_unqualified (PyObject
*self
, PyObject
*args
)
648 struct type
*type
= ((type_object
*) self
)->type
;
649 volatile struct gdb_exception except
;
651 TRY_CATCH (except
, RETURN_MASK_ALL
)
653 type
= make_cv_type (0, 0, type
, NULL
);
655 GDB_PY_HANDLE_EXCEPTION (except
);
657 return type_to_type_object (type
);
660 /* Return the size of the type represented by SELF, in bytes. */
662 typy_get_sizeof (PyObject
*self
, void *closure
)
664 struct type
*type
= ((type_object
*) self
)->type
;
665 volatile struct gdb_exception except
;
667 TRY_CATCH (except
, RETURN_MASK_ALL
)
669 check_typedef (type
);
671 /* Ignore exceptions. */
673 return PyLong_FromLong (TYPE_LENGTH (type
));
677 typy_lookup_typename (const char *type_name
, const struct block
*block
)
679 struct type
*type
= NULL
;
680 volatile struct gdb_exception except
;
682 TRY_CATCH (except
, RETURN_MASK_ALL
)
684 if (!strncmp (type_name
, "struct ", 7))
685 type
= lookup_struct (type_name
+ 7, NULL
);
686 else if (!strncmp (type_name
, "union ", 6))
687 type
= lookup_union (type_name
+ 6, NULL
);
688 else if (!strncmp (type_name
, "enum ", 5))
689 type
= lookup_enum (type_name
+ 5, NULL
);
691 type
= lookup_typename (python_language
, python_gdbarch
,
692 type_name
, block
, 0);
694 if (except
.reason
< 0)
696 gdbpy_convert_exception (except
);
704 typy_lookup_type (struct demangle_component
*demangled
,
705 const struct block
*block
)
707 struct type
*type
, *rtype
= NULL
;
708 char *type_name
= NULL
;
709 enum demangle_component_type demangled_type
;
710 volatile struct gdb_exception except
;
712 /* Save the type: typy_lookup_type() may (indirectly) overwrite
713 memory pointed by demangled. */
714 demangled_type
= demangled
->type
;
716 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
717 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
718 || demangled_type
== DEMANGLE_COMPONENT_CONST
719 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
721 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
725 TRY_CATCH (except
, RETURN_MASK_ALL
)
727 /* If the demangled_type matches with one of the types
728 below, run the corresponding function and save the type
729 to return later. We cannot just return here as we are in
730 an exception handler. */
731 switch (demangled_type
)
733 case DEMANGLE_COMPONENT_REFERENCE
:
734 rtype
= lookup_reference_type (type
);
736 case DEMANGLE_COMPONENT_POINTER
:
737 rtype
= lookup_pointer_type (type
);
739 case DEMANGLE_COMPONENT_CONST
:
740 rtype
= make_cv_type (1, 0, type
, NULL
);
742 case DEMANGLE_COMPONENT_VOLATILE
:
743 rtype
= make_cv_type (0, 1, type
, NULL
);
747 if (except
.reason
< 0)
749 gdbpy_convert_exception (except
);
754 /* If we have a type from the switch statement above, just return
759 /* We don't have a type, so lookup the type. */
760 type_name
= cp_comp_to_string (demangled
, 10);
761 type
= typy_lookup_typename (type_name
, block
);
767 /* This is a helper function for typy_template_argument that is used
768 when the type does not have template symbols attached. It works by
769 parsing the type name. This happens with compilers, like older
770 versions of GCC, that do not emit DW_TAG_template_*. */
773 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
777 struct demangle_component
*demangled
;
778 struct demangle_parse_info
*info
= NULL
;
780 struct type
*argtype
;
781 struct cleanup
*cleanup
;
782 volatile struct gdb_exception except
;
784 if (TYPE_NAME (type
) == NULL
)
786 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
790 TRY_CATCH (except
, RETURN_MASK_ALL
)
792 /* Note -- this is not thread-safe. */
793 info
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
795 GDB_PY_HANDLE_EXCEPTION (except
);
799 PyErr_SetString (PyExc_RuntimeError
, err
);
802 demangled
= info
->tree
;
803 cleanup
= make_cleanup_cp_demangled_name_parse_free (info
);
805 /* Strip off component names. */
806 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
807 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
808 demangled
= demangled
->u
.s_binary
.right
;
810 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
812 do_cleanups (cleanup
);
813 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
817 /* Skip from the template to the arguments. */
818 demangled
= demangled
->u
.s_binary
.right
;
820 for (i
= 0; demangled
&& i
< argno
; ++i
)
821 demangled
= demangled
->u
.s_binary
.right
;
825 do_cleanups (cleanup
);
826 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
831 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
832 do_cleanups (cleanup
);
836 return type_to_type_object (argtype
);
840 typy_template_argument (PyObject
*self
, PyObject
*args
)
843 struct type
*type
= ((type_object
*) self
)->type
;
844 const struct block
*block
= NULL
;
845 PyObject
*block_obj
= NULL
;
847 struct value
*val
= NULL
;
848 volatile struct gdb_exception except
;
850 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
855 block
= block_object_to_block (block_obj
);
858 PyErr_SetString (PyExc_RuntimeError
,
859 _("Second argument must be block."));
864 TRY_CATCH (except
, RETURN_MASK_ALL
)
866 type
= check_typedef (type
);
867 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
868 type
= check_typedef (TYPE_TARGET_TYPE (type
));
870 GDB_PY_HANDLE_EXCEPTION (except
);
872 /* We might not have DW_TAG_template_*, so try to parse the type's
873 name. This is inefficient if we do not have a template type --
874 but that is going to wind up as an error anyhow. */
875 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
876 return typy_legacy_template_argument (type
, block
, argno
);
878 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
880 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
885 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
886 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
887 return type_to_type_object (SYMBOL_TYPE (sym
));
888 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
890 PyErr_Format (PyExc_RuntimeError
,
891 _("Template argument is optimized out"));
895 TRY_CATCH (except
, RETURN_MASK_ALL
)
897 val
= value_of_variable (sym
, block
);
899 GDB_PY_HANDLE_EXCEPTION (except
);
901 return value_to_value_object (val
);
905 typy_str (PyObject
*self
)
907 volatile struct gdb_exception except
;
908 char *thetype
= NULL
;
912 TRY_CATCH (except
, RETURN_MASK_ALL
)
914 struct cleanup
*old_chain
;
917 stb
= mem_fileopen ();
918 old_chain
= make_cleanup_ui_file_delete (stb
);
920 type_print (type_object_to_type (self
), "", stb
, -1);
922 thetype
= ui_file_xstrdup (stb
, &length
);
923 do_cleanups (old_chain
);
925 if (except
.reason
< 0)
928 GDB_PY_HANDLE_EXCEPTION (except
);
931 result
= PyUnicode_Decode (thetype
, length
, host_charset (), NULL
);
937 /* An entry in the type-equality bcache. */
939 typedef struct type_equality_entry
941 struct type
*type1
, *type2
;
942 } type_equality_entry_d
;
944 DEF_VEC_O (type_equality_entry_d
);
946 /* A helper function to compare two strings. Returns 1 if they are
947 the same, 0 otherwise. Handles NULLs properly. */
950 compare_maybe_null_strings (const char *s
, const char *t
)
952 if (s
== NULL
&& t
!= NULL
)
954 else if (s
!= NULL
&& t
== NULL
)
956 else if (s
== NULL
&& t
== NULL
)
958 return strcmp (s
, t
) == 0;
961 /* A helper function for typy_richcompare that checks two types for
962 "deep" equality. Returns Py_EQ if the types are considered the
963 same, Py_NE otherwise. */
966 check_types_equal (struct type
*type1
, struct type
*type2
,
967 VEC (type_equality_entry_d
) **worklist
)
969 CHECK_TYPEDEF (type1
);
970 CHECK_TYPEDEF (type2
);
975 if (TYPE_CODE (type1
) != TYPE_CODE (type2
)
976 || TYPE_LENGTH (type1
) != TYPE_LENGTH (type2
)
977 || TYPE_UNSIGNED (type1
) != TYPE_UNSIGNED (type2
)
978 || TYPE_NOSIGN (type1
) != TYPE_NOSIGN (type2
)
979 || TYPE_VARARGS (type1
) != TYPE_VARARGS (type2
)
980 || TYPE_VECTOR (type1
) != TYPE_VECTOR (type2
)
981 || TYPE_NOTTEXT (type1
) != TYPE_NOTTEXT (type2
)
982 || TYPE_INSTANCE_FLAGS (type1
) != TYPE_INSTANCE_FLAGS (type2
)
983 || TYPE_NFIELDS (type1
) != TYPE_NFIELDS (type2
))
986 if (!compare_maybe_null_strings (TYPE_TAG_NAME (type1
),
987 TYPE_TAG_NAME (type2
)))
989 if (!compare_maybe_null_strings (TYPE_NAME (type1
), TYPE_NAME (type2
)))
992 if (TYPE_CODE (type1
) == TYPE_CODE_RANGE
)
994 if (memcmp (TYPE_RANGE_DATA (type1
), TYPE_RANGE_DATA (type2
),
995 sizeof (*TYPE_RANGE_DATA (type1
))) != 0)
1002 for (i
= 0; i
< TYPE_NFIELDS (type1
); ++i
)
1004 const struct field
*field1
= &TYPE_FIELD (type1
, i
);
1005 const struct field
*field2
= &TYPE_FIELD (type2
, i
);
1006 struct type_equality_entry entry
;
1008 if (FIELD_ARTIFICIAL (*field1
) != FIELD_ARTIFICIAL (*field2
)
1009 || FIELD_BITSIZE (*field1
) != FIELD_BITSIZE (*field2
)
1010 || FIELD_LOC_KIND (*field1
) != FIELD_LOC_KIND (*field2
))
1012 if (!compare_maybe_null_strings (FIELD_NAME (*field1
),
1013 FIELD_NAME (*field2
)))
1015 switch (FIELD_LOC_KIND (*field1
))
1017 case FIELD_LOC_KIND_BITPOS
:
1018 if (FIELD_BITPOS (*field1
) != FIELD_BITPOS (*field2
))
1021 case FIELD_LOC_KIND_PHYSADDR
:
1022 if (FIELD_STATIC_PHYSADDR (*field1
)
1023 != FIELD_STATIC_PHYSADDR (*field2
))
1026 case FIELD_LOC_KIND_PHYSNAME
:
1027 if (!compare_maybe_null_strings (FIELD_STATIC_PHYSNAME (*field1
),
1028 FIELD_STATIC_PHYSNAME (*field2
)))
1031 case FIELD_LOC_KIND_DWARF_BLOCK
:
1033 struct dwarf2_locexpr_baton
*block1
, *block2
;
1035 block1
= FIELD_DWARF_BLOCK (*field1
);
1036 block2
= FIELD_DWARF_BLOCK (*field2
);
1037 if (block1
->per_cu
!= block2
->per_cu
1038 || block1
->size
!= block2
->size
1039 || memcmp (block1
->data
, block2
->data
, block1
->size
) != 0)
1044 internal_error (__FILE__
, __LINE__
, _("Unsupported field kind "
1045 "%d by check_types_equal"),
1046 FIELD_LOC_KIND (*field1
));
1049 entry
.type1
= FIELD_TYPE (*field1
);
1050 entry
.type2
= FIELD_TYPE (*field2
);
1051 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
1055 if (TYPE_TARGET_TYPE (type1
) != NULL
)
1057 struct type_equality_entry entry
;
1060 if (TYPE_TARGET_TYPE (type2
) == NULL
)
1063 entry
.type1
= TYPE_TARGET_TYPE (type1
);
1064 entry
.type2
= TYPE_TARGET_TYPE (type2
);
1065 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
1067 else if (TYPE_TARGET_TYPE (type2
) != NULL
)
1073 /* Check types on a worklist for equality. Returns Py_NE if any pair
1074 is not equal, Py_EQ if they are all considered equal. */
1077 check_types_worklist (VEC (type_equality_entry_d
) **worklist
,
1078 struct bcache
*cache
)
1080 while (!VEC_empty (type_equality_entry_d
, *worklist
))
1082 struct type_equality_entry entry
;
1085 entry
= *VEC_last (type_equality_entry_d
, *worklist
);
1086 VEC_pop (type_equality_entry_d
, *worklist
);
1088 /* If the type pair has already been visited, we know it is
1090 bcache_full (&entry
, sizeof (entry
), cache
, &added
);
1094 if (check_types_equal (entry
.type1
, entry
.type2
, worklist
) == Py_NE
)
1101 /* Implement the richcompare method. */
1104 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1107 struct type
*type1
= type_object_to_type (self
);
1108 struct type
*type2
= type_object_to_type (other
);
1109 volatile struct gdb_exception except
;
1111 /* We can only compare ourselves to another Type object, and only
1112 for equality or inequality. */
1113 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
1115 Py_INCREF (Py_NotImplemented
);
1116 return Py_NotImplemented
;
1123 struct bcache
*cache
;
1124 VEC (type_equality_entry_d
) *worklist
= NULL
;
1125 struct type_equality_entry entry
;
1127 cache
= bcache_xmalloc (NULL
, NULL
);
1129 entry
.type1
= type1
;
1130 entry
.type2
= type2
;
1131 VEC_safe_push (type_equality_entry_d
, worklist
, &entry
);
1133 TRY_CATCH (except
, RETURN_MASK_ALL
)
1135 result
= check_types_worklist (&worklist
, cache
);
1137 /* check_types_worklist calls several nested Python helper
1138 functions, some of which can raise a GDB Exception, so we
1139 just check and convert here. If there is a GDB exception, a
1140 comparison is not capable (or trusted), so exit. */
1141 bcache_xfree (cache
);
1142 VEC_free (type_equality_entry_d
, worklist
);
1143 GDB_PY_HANDLE_EXCEPTION (except
);
1153 static const struct objfile_data
*typy_objfile_data_key
;
1156 save_objfile_types (struct objfile
*objfile
, void *datum
)
1158 type_object
*obj
= datum
;
1159 htab_t copied_types
;
1160 struct cleanup
*cleanup
;
1162 /* This prevents another thread from freeing the objects we're
1164 cleanup
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1166 copied_types
= create_copied_types_hash (objfile
);
1170 type_object
*next
= obj
->next
;
1172 htab_empty (copied_types
);
1174 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1182 htab_delete (copied_types
);
1184 do_cleanups (cleanup
);
1188 set_type (type_object
*obj
, struct type
*type
)
1192 if (type
&& TYPE_OBJFILE (type
))
1194 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1196 obj
->next
= objfile_data (objfile
, typy_objfile_data_key
);
1198 obj
->next
->prev
= obj
;
1199 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1206 typy_dealloc (PyObject
*obj
)
1208 type_object
*type
= (type_object
*) obj
;
1211 type
->prev
->next
= type
->next
;
1212 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1214 /* Must reset head of list. */
1215 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1218 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1221 type
->next
->prev
= type
->prev
;
1223 type
->ob_type
->tp_free (type
);
1226 /* Return number of fields ("length" of the field dictionary). */
1229 typy_length (PyObject
*self
)
1231 struct type
*type
= ((type_object
*) self
)->type
;
1233 type
= typy_get_composite (type
);
1237 return TYPE_NFIELDS (type
);
1240 /* Implements boolean evaluation of gdb.Type. Handle this like other
1241 Python objects that don't have a meaningful truth value -- all
1245 typy_nonzero (PyObject
*self
)
1250 /* Return a gdb.Field object for the field named by the argument. */
1253 typy_getitem (PyObject
*self
, PyObject
*key
)
1255 struct type
*type
= ((type_object
*) self
)->type
;
1258 volatile struct gdb_exception except
;
1260 field
= python_string_to_host_string (key
);
1264 /* We want just fields of this type, not of base types, so instead of
1265 using lookup_struct_elt_type, portions of that function are
1268 type
= typy_get_composite (type
);
1272 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1274 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1276 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1278 return convert_field (type
, i
);
1281 PyErr_SetObject (PyExc_KeyError
, key
);
1285 /* Implement the "get" method on the type object. This is the
1286 same as getitem if the key is present, but returns the supplied
1287 default value or None if the key is not found. */
1290 typy_get (PyObject
*self
, PyObject
*args
)
1292 PyObject
*key
, *defval
= Py_None
, *result
;
1294 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1297 result
= typy_getitem (self
, key
);
1301 /* typy_getitem returned error status. If the exception is
1302 KeyError, clear the exception status and return the defval
1303 instead. Otherwise return the exception unchanged. */
1304 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1312 /* Implement the "has_key" method on the type object. */
1315 typy_has_key (PyObject
*self
, PyObject
*args
)
1317 struct type
*type
= ((type_object
*) self
)->type
;
1320 volatile struct gdb_exception except
;
1322 if (!PyArg_ParseTuple (args
, "s", &field
))
1325 /* We want just fields of this type, not of base types, so instead of
1326 using lookup_struct_elt_type, portions of that function are
1329 type
= typy_get_composite (type
);
1333 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1335 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1337 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1343 /* Make an iterator object to iterate over keys, values, or items. */
1346 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1348 typy_iterator_object
*typy_iter_obj
;
1350 /* Check that "self" is a structure or union type. */
1351 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1354 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1355 &type_iterator_object_type
);
1356 if (typy_iter_obj
== NULL
)
1359 typy_iter_obj
->field
= 0;
1360 typy_iter_obj
->kind
= kind
;
1362 typy_iter_obj
->source
= (type_object
*) self
;
1364 return (PyObject
*) typy_iter_obj
;
1367 /* iteritems() method. */
1370 typy_iteritems (PyObject
*self
, PyObject
*args
)
1372 return typy_make_iter (self
, iter_items
);
1375 /* iterkeys() method. */
1378 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1380 return typy_make_iter (self
, iter_keys
);
1383 /* Iterating over the class, same as iterkeys except for the function
1387 typy_iter (PyObject
*self
)
1389 return typy_make_iter (self
, iter_keys
);
1392 /* itervalues() method. */
1395 typy_itervalues (PyObject
*self
, PyObject
*args
)
1397 return typy_make_iter (self
, iter_values
);
1400 /* Return a reference to the type iterator. */
1403 typy_iterator_iter (PyObject
*self
)
1409 /* Return the next field in the iteration through the list of fields
1413 typy_iterator_iternext (PyObject
*self
)
1415 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1416 struct type
*type
= iter_obj
->source
->type
;
1420 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1422 result
= make_fielditem (type
, iter_obj
->field
, iter_obj
->kind
);
1432 typy_iterator_dealloc (PyObject
*obj
)
1434 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1436 Py_DECREF (iter_obj
->source
);
1439 /* Create a new Type referring to TYPE. */
1441 type_to_type_object (struct type
*type
)
1443 type_object
*type_obj
;
1445 type_obj
= PyObject_New (type_object
, &type_object_type
);
1447 set_type (type_obj
, type
);
1449 return (PyObject
*) type_obj
;
1453 type_object_to_type (PyObject
*obj
)
1455 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1457 return ((type_object
*) obj
)->type
;
1462 /* Implementation of gdb.lookup_type. */
1464 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1466 static char *keywords
[] = { "name", "block", NULL
};
1467 const char *type_name
= NULL
;
1468 struct type
*type
= NULL
;
1469 PyObject
*block_obj
= NULL
;
1470 const struct block
*block
= NULL
;
1472 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1473 &type_name
, &block_obj
))
1478 block
= block_object_to_block (block_obj
);
1481 PyErr_SetString (PyExc_RuntimeError
,
1482 _("'block' argument must be a Block."));
1487 type
= typy_lookup_typename (type_name
, block
);
1491 return (PyObject
*) type_to_type_object (type
);
1495 gdbpy_initialize_types (void)
1499 typy_objfile_data_key
1500 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1502 if (PyType_Ready (&type_object_type
) < 0)
1504 if (PyType_Ready (&field_object_type
) < 0)
1506 if (PyType_Ready (&type_iterator_object_type
) < 0)
1509 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1511 if (PyModule_AddIntConstant (gdb_module
,
1512 /* Cast needed for Python 2.4. */
1513 (char *) pyty_codes
[i
].name
,
1514 pyty_codes
[i
].code
) < 0)
1518 Py_INCREF (&type_object_type
);
1519 PyModule_AddObject (gdb_module
, "Type", (PyObject
*) &type_object_type
);
1521 Py_INCREF (&type_iterator_object_type
);
1522 PyModule_AddObject (gdb_module
, "TypeIterator",
1523 (PyObject
*) &type_iterator_object_type
);
1525 Py_INCREF (&field_object_type
);
1526 PyModule_AddObject (gdb_module
, "Field", (PyObject
*) &field_object_type
);
1531 static PyGetSetDef type_object_getset
[] =
1533 { "code", typy_get_code
, NULL
,
1534 "The code for this type.", NULL
},
1535 { "sizeof", typy_get_sizeof
, NULL
,
1536 "The size of this type, in bytes.", NULL
},
1537 { "tag", typy_get_tag
, NULL
,
1538 "The tag name for this type, or None.", NULL
},
1542 static PyMethodDef type_object_methods
[] =
1544 { "array", typy_array
, METH_VARARGS
,
1545 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1546 Return a type which represents an array of objects of this type.\n\
1547 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1548 If LOW_BOUND is omitted, a value of zero is used." },
1549 { "__contains__", typy_has_key
, METH_VARARGS
,
1550 "T.__contains__(k) -> True if T has a field named k, else False" },
1551 { "const", typy_const
, METH_NOARGS
,
1552 "const () -> Type\n\
1553 Return a const variant of this type." },
1554 { "fields", typy_fields
, METH_NOARGS
,
1555 "fields () -> list\n\
1556 Return a list holding all the fields of this type.\n\
1557 Each field is a gdb.Field object." },
1558 { "get", typy_get
, METH_VARARGS
,
1559 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1560 otherwise returns default, if supplied, or None if not." },
1561 { "has_key", typy_has_key
, METH_VARARGS
,
1562 "T.has_key(k) -> True if T has a field named k, else False" },
1563 { "items", typy_items
, METH_NOARGS
,
1564 "items () -> list\n\
1565 Return a list of (name, field) pairs of this type.\n\
1566 Each field is a gdb.Field object." },
1567 { "iteritems", typy_iteritems
, METH_NOARGS
,
1568 "iteritems () -> an iterator over the (name, field)\n\
1569 pairs of this type. Each field is a gdb.Field object." },
1570 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1571 "iterkeys () -> an iterator over the field names of this type." },
1572 { "itervalues", typy_itervalues
, METH_NOARGS
,
1573 "itervalues () -> an iterator over the fields of this type.\n\
1574 Each field is a gdb.Field object." },
1575 { "keys", typy_field_names
, METH_NOARGS
,
1577 Return a list holding all the fields names of this type." },
1578 { "pointer", typy_pointer
, METH_NOARGS
,
1579 "pointer () -> Type\n\
1580 Return a type of pointer to this type." },
1581 { "range", typy_range
, METH_NOARGS
,
1582 "range () -> tuple\n\
1583 Return a tuple containing the lower and upper range for this type."},
1584 { "reference", typy_reference
, METH_NOARGS
,
1585 "reference () -> Type\n\
1586 Return a type of reference to this type." },
1587 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1588 "strip_typedefs () -> Type\n\
1589 Return a type formed by stripping this type of all typedefs."},
1590 { "target", typy_target
, METH_NOARGS
,
1591 "target () -> Type\n\
1592 Return the target type of this type." },
1593 { "template_argument", typy_template_argument
, METH_VARARGS
,
1594 "template_argument (arg, [block]) -> Type\n\
1595 Return the type of a template argument." },
1596 { "unqualified", typy_unqualified
, METH_NOARGS
,
1597 "unqualified () -> Type\n\
1598 Return a variant of this type without const or volatile attributes." },
1599 { "values", typy_values
, METH_NOARGS
,
1600 "values () -> list\n\
1601 Return a list holding all the fields of this type.\n\
1602 Each field is a gdb.Field object." },
1603 { "volatile", typy_volatile
, METH_NOARGS
,
1604 "volatile () -> Type\n\
1605 Return a volatile variant of this type" },
1609 static PyNumberMethods type_object_as_number
= {
1611 NULL
, /* nb_subtract */
1612 NULL
, /* nb_multiply */
1613 NULL
, /* nb_divide */
1614 NULL
, /* nb_remainder */
1615 NULL
, /* nb_divmod */
1616 NULL
, /* nb_power */
1617 NULL
, /* nb_negative */
1618 NULL
, /* nb_positive */
1619 NULL
, /* nb_absolute */
1620 typy_nonzero
, /* nb_nonzero */
1621 NULL
, /* nb_invert */
1622 NULL
, /* nb_lshift */
1623 NULL
, /* nb_rshift */
1627 NULL
, /* nb_coerce */
1630 NULL
, /* nb_float */
1635 static PyMappingMethods typy_mapping
= {
1638 NULL
/* no "set" method */
1641 static PyTypeObject type_object_type
=
1643 PyObject_HEAD_INIT (NULL
)
1645 "gdb.Type", /*tp_name*/
1646 sizeof (type_object
), /*tp_basicsize*/
1648 typy_dealloc
, /*tp_dealloc*/
1654 &type_object_as_number
, /*tp_as_number*/
1655 0, /*tp_as_sequence*/
1656 &typy_mapping
, /*tp_as_mapping*/
1659 typy_str
, /*tp_str*/
1663 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1664 "GDB type object", /* tp_doc */
1665 0, /* tp_traverse */
1667 typy_richcompare
, /* tp_richcompare */
1668 0, /* tp_weaklistoffset */
1669 typy_iter
, /* tp_iter */
1670 0, /* tp_iternext */
1671 type_object_methods
, /* tp_methods */
1673 type_object_getset
, /* tp_getset */
1676 0, /* tp_descr_get */
1677 0, /* tp_descr_set */
1678 0, /* tp_dictoffset */
1684 static PyTypeObject field_object_type
=
1686 PyObject_HEAD_INIT (NULL
)
1688 "gdb.Field", /*tp_name*/
1689 sizeof (field_object
), /*tp_basicsize*/
1691 field_dealloc
, /*tp_dealloc*/
1698 0, /*tp_as_sequence*/
1699 0, /*tp_as_mapping*/
1706 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1707 "GDB field object", /* tp_doc */
1708 0, /* tp_traverse */
1710 0, /* tp_richcompare */
1711 0, /* tp_weaklistoffset */
1713 0, /* tp_iternext */
1719 0, /* tp_descr_get */
1720 0, /* tp_descr_set */
1721 offsetof (field_object
, dict
), /* tp_dictoffset */
1727 static PyTypeObject type_iterator_object_type
= {
1728 PyObject_HEAD_INIT (NULL
)
1730 "gdb.TypeIterator", /*tp_name*/
1731 sizeof (typy_iterator_object
), /*tp_basicsize*/
1733 typy_iterator_dealloc
, /*tp_dealloc*/
1740 0, /*tp_as_sequence*/
1741 0, /*tp_as_mapping*/
1748 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1749 "GDB type iterator object", /*tp_doc */
1752 0, /*tp_richcompare */
1753 0, /*tp_weaklistoffset */
1754 typy_iterator_iter
, /*tp_iter */
1755 typy_iterator_iternext
, /*tp_iternext */