1 /* Python interface to types.
3 Copyright (C) 2008, 2009, 2010, 2011 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_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_strings (TYPE_TAG_NAME (type1
), TYPE_TAG_NAME (type2
)))
988 if (!compare_strings (TYPE_NAME (type1
), TYPE_NAME (type2
)))
991 if (TYPE_CODE (type1
) == TYPE_CODE_RANGE
)
993 if (memcmp (TYPE_RANGE_DATA (type1
), TYPE_RANGE_DATA (type2
),
994 sizeof (*TYPE_RANGE_DATA (type1
))) != 0)
1001 for (i
= 0; i
< TYPE_NFIELDS (type1
); ++i
)
1003 const struct field
*field1
= &TYPE_FIELD (type1
, i
);
1004 const struct field
*field2
= &TYPE_FIELD (type2
, i
);
1005 struct type_equality_entry entry
;
1007 if (FIELD_ARTIFICIAL (*field1
) != FIELD_ARTIFICIAL (*field2
)
1008 || FIELD_BITSIZE (*field1
) != FIELD_BITSIZE (*field2
)
1009 || FIELD_LOC_KIND (*field1
) != FIELD_LOC_KIND (*field2
))
1011 if (!compare_strings (FIELD_NAME (*field1
), FIELD_NAME (*field2
)))
1013 switch (FIELD_LOC_KIND (*field1
))
1015 case FIELD_LOC_KIND_BITPOS
:
1016 if (FIELD_BITPOS (*field1
) != FIELD_BITPOS (*field2
))
1019 case FIELD_LOC_KIND_PHYSADDR
:
1020 if (FIELD_STATIC_PHYSADDR (*field1
)
1021 != FIELD_STATIC_PHYSADDR (*field2
))
1024 case FIELD_LOC_KIND_PHYSNAME
:
1025 if (!compare_strings (FIELD_STATIC_PHYSNAME (*field1
),
1026 FIELD_STATIC_PHYSNAME (*field2
)))
1029 case FIELD_LOC_KIND_DWARF_BLOCK
:
1031 struct dwarf2_locexpr_baton
*block1
, *block2
;
1033 block1
= FIELD_DWARF_BLOCK (*field1
);
1034 block2
= FIELD_DWARF_BLOCK (*field2
);
1035 if (block1
->per_cu
!= block2
->per_cu
1036 || block1
->size
!= block2
->size
1037 || memcmp (block1
->data
, block2
->data
, block1
->size
) != 0)
1042 internal_error (__FILE__
, __LINE__
, _("Unsupported field kind "
1043 "%d by check_types_equal"),
1044 FIELD_LOC_KIND (*field1
));
1047 entry
.type1
= FIELD_TYPE (*field1
);
1048 entry
.type2
= FIELD_TYPE (*field2
);
1049 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
1053 if (TYPE_TARGET_TYPE (type1
) != NULL
)
1055 struct type_equality_entry entry
;
1058 if (TYPE_TARGET_TYPE (type2
) == NULL
)
1061 entry
.type1
= TYPE_TARGET_TYPE (type1
);
1062 entry
.type2
= TYPE_TARGET_TYPE (type2
);
1063 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
1065 else if (TYPE_TARGET_TYPE (type2
) != NULL
)
1071 /* Check types on a worklist for equality. Returns Py_NE if any pair
1072 is not equal, Py_EQ if they are all considered equal. */
1075 check_types_worklist (VEC (type_equality_entry_d
) **worklist
,
1076 struct bcache
*cache
)
1078 while (!VEC_empty (type_equality_entry_d
, *worklist
))
1080 struct type_equality_entry entry
;
1083 entry
= *VEC_last (type_equality_entry_d
, *worklist
);
1084 VEC_pop (type_equality_entry_d
, *worklist
);
1086 /* If the type pair has already been visited, we know it is
1088 bcache_full (&entry
, sizeof (entry
), cache
, &added
);
1092 if (check_types_equal (entry
.type1
, entry
.type2
, worklist
) == Py_NE
)
1099 /* Implement the richcompare method. */
1102 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1105 struct type
*type1
= type_object_to_type (self
);
1106 struct type
*type2
= type_object_to_type (other
);
1107 volatile struct gdb_exception except
;
1109 /* We can only compare ourselves to another Type object, and only
1110 for equality or inequality. */
1111 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
1113 Py_INCREF (Py_NotImplemented
);
1114 return Py_NotImplemented
;
1121 struct bcache
*cache
;
1122 VEC (type_equality_entry_d
) *worklist
= NULL
;
1123 struct type_equality_entry entry
;
1125 cache
= bcache_xmalloc (NULL
, NULL
);
1127 entry
.type1
= type1
;
1128 entry
.type2
= type2
;
1129 VEC_safe_push (type_equality_entry_d
, worklist
, &entry
);
1131 TRY_CATCH (except
, RETURN_MASK_ALL
)
1133 result
= check_types_worklist (&worklist
, cache
);
1135 /* check_types_worklist calls several nested Python helper
1136 functions, some of which can raise a GDB Exception, so we
1137 just check and convert here. If there is a GDB exception, a
1138 comparison is not capable (or trusted), so exit. */
1139 bcache_xfree (cache
);
1140 VEC_free (type_equality_entry_d
, worklist
);
1141 GDB_PY_HANDLE_EXCEPTION (except
);
1151 static const struct objfile_data
*typy_objfile_data_key
;
1154 save_objfile_types (struct objfile
*objfile
, void *datum
)
1156 type_object
*obj
= datum
;
1157 htab_t copied_types
;
1158 struct cleanup
*cleanup
;
1160 /* This prevents another thread from freeing the objects we're
1162 cleanup
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1164 copied_types
= create_copied_types_hash (objfile
);
1168 type_object
*next
= obj
->next
;
1170 htab_empty (copied_types
);
1172 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1180 htab_delete (copied_types
);
1182 do_cleanups (cleanup
);
1186 set_type (type_object
*obj
, struct type
*type
)
1190 if (type
&& TYPE_OBJFILE (type
))
1192 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1194 obj
->next
= objfile_data (objfile
, typy_objfile_data_key
);
1196 obj
->next
->prev
= obj
;
1197 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1204 typy_dealloc (PyObject
*obj
)
1206 type_object
*type
= (type_object
*) obj
;
1209 type
->prev
->next
= type
->next
;
1210 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1212 /* Must reset head of list. */
1213 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1216 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1219 type
->next
->prev
= type
->prev
;
1221 type
->ob_type
->tp_free (type
);
1224 /* Return number of fields ("length" of the field dictionary). */
1227 typy_length (PyObject
*self
)
1229 struct type
*type
= ((type_object
*) self
)->type
;
1231 type
= typy_get_composite (type
);
1235 return TYPE_NFIELDS (type
);
1238 /* Implements boolean evaluation of gdb.Type. Handle this like other
1239 Python objects that don't have a meaningful truth value -- all
1243 typy_nonzero (PyObject
*self
)
1248 /* Return a gdb.Field object for the field named by the argument. */
1251 typy_getitem (PyObject
*self
, PyObject
*key
)
1253 struct type
*type
= ((type_object
*) self
)->type
;
1256 volatile struct gdb_exception except
;
1258 field
= python_string_to_host_string (key
);
1262 /* We want just fields of this type, not of base types, so instead of
1263 using lookup_struct_elt_type, portions of that function are
1266 type
= typy_get_composite (type
);
1270 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1272 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1274 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1276 return convert_field (type
, i
);
1279 PyErr_SetObject (PyExc_KeyError
, key
);
1283 /* Implement the "get" method on the type object. This is the
1284 same as getitem if the key is present, but returns the supplied
1285 default value or None if the key is not found. */
1288 typy_get (PyObject
*self
, PyObject
*args
)
1290 PyObject
*key
, *defval
= Py_None
, *result
;
1292 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1295 result
= typy_getitem (self
, key
);
1299 /* typy_getitem returned error status. If the exception is
1300 KeyError, clear the exception status and return the defval
1301 instead. Otherwise return the exception unchanged. */
1302 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1310 /* Implement the "has_key" method on the type object. */
1313 typy_has_key (PyObject
*self
, PyObject
*args
)
1315 struct type
*type
= ((type_object
*) self
)->type
;
1318 volatile struct gdb_exception except
;
1320 if (!PyArg_ParseTuple (args
, "s", &field
))
1323 /* We want just fields of this type, not of base types, so instead of
1324 using lookup_struct_elt_type, portions of that function are
1327 type
= typy_get_composite (type
);
1331 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1333 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1335 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1341 /* Make an iterator object to iterate over keys, values, or items. */
1344 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1346 typy_iterator_object
*typy_iter_obj
;
1348 /* Check that "self" is a structure or union type. */
1349 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1352 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1353 &type_iterator_object_type
);
1354 if (typy_iter_obj
== NULL
)
1357 typy_iter_obj
->field
= 0;
1358 typy_iter_obj
->kind
= kind
;
1360 typy_iter_obj
->source
= (type_object
*) self
;
1362 return (PyObject
*) typy_iter_obj
;
1365 /* iteritems() method. */
1368 typy_iteritems (PyObject
*self
, PyObject
*args
)
1370 return typy_make_iter (self
, iter_items
);
1373 /* iterkeys() method. */
1376 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1378 return typy_make_iter (self
, iter_keys
);
1381 /* Iterating over the class, same as iterkeys except for the function
1385 typy_iter (PyObject
*self
)
1387 return typy_make_iter (self
, iter_keys
);
1390 /* itervalues() method. */
1393 typy_itervalues (PyObject
*self
, PyObject
*args
)
1395 return typy_make_iter (self
, iter_values
);
1398 /* Return a reference to the type iterator. */
1401 typy_iterator_iter (PyObject
*self
)
1407 /* Return the next field in the iteration through the list of fields
1411 typy_iterator_iternext (PyObject
*self
)
1413 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1414 struct type
*type
= iter_obj
->source
->type
;
1418 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1420 result
= make_fielditem (type
, iter_obj
->field
, iter_obj
->kind
);
1430 typy_iterator_dealloc (PyObject
*obj
)
1432 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1434 Py_DECREF (iter_obj
->source
);
1437 /* Create a new Type referring to TYPE. */
1439 type_to_type_object (struct type
*type
)
1441 type_object
*type_obj
;
1443 type_obj
= PyObject_New (type_object
, &type_object_type
);
1445 set_type (type_obj
, type
);
1447 return (PyObject
*) type_obj
;
1451 type_object_to_type (PyObject
*obj
)
1453 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1455 return ((type_object
*) obj
)->type
;
1460 /* Implementation of gdb.lookup_type. */
1462 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1464 static char *keywords
[] = { "name", "block", NULL
};
1465 const char *type_name
= NULL
;
1466 struct type
*type
= NULL
;
1467 PyObject
*block_obj
= NULL
;
1468 const struct block
*block
= NULL
;
1470 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1471 &type_name
, &block_obj
))
1476 block
= block_object_to_block (block_obj
);
1479 PyErr_SetString (PyExc_RuntimeError
,
1480 _("'block' argument must be a Block."));
1485 type
= typy_lookup_typename (type_name
, block
);
1489 return (PyObject
*) type_to_type_object (type
);
1493 gdbpy_initialize_types (void)
1497 typy_objfile_data_key
1498 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1500 if (PyType_Ready (&type_object_type
) < 0)
1502 if (PyType_Ready (&field_object_type
) < 0)
1504 if (PyType_Ready (&type_iterator_object_type
) < 0)
1507 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1509 if (PyModule_AddIntConstant (gdb_module
,
1510 /* Cast needed for Python 2.4. */
1511 (char *) pyty_codes
[i
].name
,
1512 pyty_codes
[i
].code
) < 0)
1516 Py_INCREF (&type_object_type
);
1517 PyModule_AddObject (gdb_module
, "Type", (PyObject
*) &type_object_type
);
1519 Py_INCREF (&type_iterator_object_type
);
1520 PyModule_AddObject (gdb_module
, "TypeIterator",
1521 (PyObject
*) &type_iterator_object_type
);
1523 Py_INCREF (&field_object_type
);
1524 PyModule_AddObject (gdb_module
, "Field", (PyObject
*) &field_object_type
);
1529 static PyGetSetDef type_object_getset
[] =
1531 { "code", typy_get_code
, NULL
,
1532 "The code for this type.", NULL
},
1533 { "sizeof", typy_get_sizeof
, NULL
,
1534 "The size of this type, in bytes.", NULL
},
1535 { "tag", typy_get_tag
, NULL
,
1536 "The tag name for this type, or None.", NULL
},
1540 static PyMethodDef type_object_methods
[] =
1542 { "array", typy_array
, METH_VARARGS
,
1543 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1544 Return a type which represents an array of objects of this type.\n\
1545 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1546 If LOW_BOUND is omitted, a value of zero is used." },
1547 { "__contains__", typy_has_key
, METH_VARARGS
,
1548 "T.__contains__(k) -> True if T has a field named k, else False" },
1549 { "const", typy_const
, METH_NOARGS
,
1550 "const () -> Type\n\
1551 Return a const variant of this type." },
1552 { "fields", typy_fields
, METH_NOARGS
,
1553 "fields () -> list\n\
1554 Return a list holding all the fields of this type.\n\
1555 Each field is a gdb.Field object." },
1556 { "get", typy_get
, METH_VARARGS
,
1557 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1558 otherwise returns default, if supplied, or None if not." },
1559 { "has_key", typy_has_key
, METH_VARARGS
,
1560 "T.has_key(k) -> True if T has a field named k, else False" },
1561 { "items", typy_items
, METH_NOARGS
,
1562 "items () -> list\n\
1563 Return a list of (name, field) pairs of this type.\n\
1564 Each field is a gdb.Field object." },
1565 { "iteritems", typy_iteritems
, METH_NOARGS
,
1566 "iteritems () -> an iterator over the (name, field)\n\
1567 pairs of this type. Each field is a gdb.Field object." },
1568 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1569 "iterkeys () -> an iterator over the field names of this type." },
1570 { "itervalues", typy_itervalues
, METH_NOARGS
,
1571 "itervalues () -> an iterator over the fields of this type.\n\
1572 Each field is a gdb.Field object." },
1573 { "keys", typy_field_names
, METH_NOARGS
,
1575 Return a list holding all the fields names of this type." },
1576 { "pointer", typy_pointer
, METH_NOARGS
,
1577 "pointer () -> Type\n\
1578 Return a type of pointer to this type." },
1579 { "range", typy_range
, METH_NOARGS
,
1580 "range () -> tuple\n\
1581 Return a tuple containing the lower and upper range for this type."},
1582 { "reference", typy_reference
, METH_NOARGS
,
1583 "reference () -> Type\n\
1584 Return a type of reference to this type." },
1585 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1586 "strip_typedefs () -> Type\n\
1587 Return a type formed by stripping this type of all typedefs."},
1588 { "target", typy_target
, METH_NOARGS
,
1589 "target () -> Type\n\
1590 Return the target type of this type." },
1591 { "template_argument", typy_template_argument
, METH_VARARGS
,
1592 "template_argument (arg, [block]) -> Type\n\
1593 Return the type of a template argument." },
1594 { "unqualified", typy_unqualified
, METH_NOARGS
,
1595 "unqualified () -> Type\n\
1596 Return a variant of this type without const or volatile attributes." },
1597 { "values", typy_values
, METH_NOARGS
,
1598 "values () -> list\n\
1599 Return a list holding all the fields of this type.\n\
1600 Each field is a gdb.Field object." },
1601 { "volatile", typy_volatile
, METH_NOARGS
,
1602 "volatile () -> Type\n\
1603 Return a volatile variant of this type" },
1607 static PyNumberMethods type_object_as_number
= {
1609 NULL
, /* nb_subtract */
1610 NULL
, /* nb_multiply */
1611 NULL
, /* nb_divide */
1612 NULL
, /* nb_remainder */
1613 NULL
, /* nb_divmod */
1614 NULL
, /* nb_power */
1615 NULL
, /* nb_negative */
1616 NULL
, /* nb_positive */
1617 NULL
, /* nb_absolute */
1618 typy_nonzero
, /* nb_nonzero */
1619 NULL
, /* nb_invert */
1620 NULL
, /* nb_lshift */
1621 NULL
, /* nb_rshift */
1625 NULL
, /* nb_coerce */
1628 NULL
, /* nb_float */
1633 static PyMappingMethods typy_mapping
= {
1636 NULL
/* no "set" method */
1639 static PyTypeObject type_object_type
=
1641 PyObject_HEAD_INIT (NULL
)
1643 "gdb.Type", /*tp_name*/
1644 sizeof (type_object
), /*tp_basicsize*/
1646 typy_dealloc
, /*tp_dealloc*/
1652 &type_object_as_number
, /*tp_as_number*/
1653 0, /*tp_as_sequence*/
1654 &typy_mapping
, /*tp_as_mapping*/
1657 typy_str
, /*tp_str*/
1661 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1662 "GDB type object", /* tp_doc */
1663 0, /* tp_traverse */
1665 typy_richcompare
, /* tp_richcompare */
1666 0, /* tp_weaklistoffset */
1667 typy_iter
, /* tp_iter */
1668 0, /* tp_iternext */
1669 type_object_methods
, /* tp_methods */
1671 type_object_getset
, /* tp_getset */
1674 0, /* tp_descr_get */
1675 0, /* tp_descr_set */
1676 0, /* tp_dictoffset */
1682 static PyTypeObject field_object_type
=
1684 PyObject_HEAD_INIT (NULL
)
1686 "gdb.Field", /*tp_name*/
1687 sizeof (field_object
), /*tp_basicsize*/
1689 field_dealloc
, /*tp_dealloc*/
1696 0, /*tp_as_sequence*/
1697 0, /*tp_as_mapping*/
1704 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1705 "GDB field object", /* tp_doc */
1706 0, /* tp_traverse */
1708 0, /* tp_richcompare */
1709 0, /* tp_weaklistoffset */
1711 0, /* tp_iternext */
1717 0, /* tp_descr_get */
1718 0, /* tp_descr_set */
1719 offsetof (field_object
, dict
), /* tp_dictoffset */
1725 static PyTypeObject type_iterator_object_type
= {
1726 PyObject_HEAD_INIT (NULL
)
1728 "gdb.TypeIterator", /*tp_name*/
1729 sizeof (typy_iterator_object
), /*tp_basicsize*/
1731 typy_iterator_dealloc
, /*tp_dealloc*/
1738 0, /*tp_as_sequence*/
1739 0, /*tp_as_mapping*/
1746 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1747 "GDB type iterator object", /*tp_doc */
1750 0, /*tp_richcompare */
1751 0, /*tp_weaklistoffset */
1752 typy_iterator_iter
, /*tp_iter */
1753 typy_iterator_iternext
, /*tp_iternext */