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
;
399 return type_to_type_object (check_typedef (type
));
402 /* Strip typedefs and pointers/reference from a type. Then check that
403 it is a struct, union, or enum type. If not, raise TypeError. */
406 typy_get_composite (struct type
*type
)
408 volatile struct gdb_exception except
;
412 TRY_CATCH (except
, RETURN_MASK_ALL
)
414 CHECK_TYPEDEF (type
);
416 /* Don't use GDB_PY_HANDLE_EXCEPTION here because that returns
417 a (NULL) pointer of the wrong type. */
418 if (except
.reason
< 0)
420 gdbpy_convert_exception (except
);
424 if (TYPE_CODE (type
) != TYPE_CODE_PTR
425 && TYPE_CODE (type
) != TYPE_CODE_REF
)
427 type
= TYPE_TARGET_TYPE (type
);
430 /* If this is not a struct, union, or enum type, raise TypeError
432 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
433 && TYPE_CODE (type
) != TYPE_CODE_UNION
434 && TYPE_CODE (type
) != TYPE_CODE_ENUM
)
436 PyErr_SetString (PyExc_TypeError
,
437 "Type is not a structure, union, or enum type.");
444 /* Return an array type. */
447 typy_array (PyObject
*self
, PyObject
*args
)
450 PyObject
*n2_obj
= NULL
;
451 struct type
*array
= NULL
;
452 struct type
*type
= ((type_object
*) self
)->type
;
453 volatile struct gdb_exception except
;
455 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
460 if (!PyInt_Check (n2_obj
))
462 PyErr_SetString (PyExc_RuntimeError
,
463 _("Array bound must be an integer"));
467 if (! gdb_py_int_as_long (n2_obj
, &n2
))
478 PyErr_SetString (PyExc_ValueError
,
479 _("Array length must not be negative"));
483 TRY_CATCH (except
, RETURN_MASK_ALL
)
485 array
= lookup_array_range_type (type
, n1
, n2
);
487 GDB_PY_HANDLE_EXCEPTION (except
);
489 return type_to_type_object (array
);
492 /* Return a Type object which represents a pointer to SELF. */
494 typy_pointer (PyObject
*self
, PyObject
*args
)
496 struct type
*type
= ((type_object
*) self
)->type
;
497 volatile struct gdb_exception except
;
499 TRY_CATCH (except
, RETURN_MASK_ALL
)
501 type
= lookup_pointer_type (type
);
503 GDB_PY_HANDLE_EXCEPTION (except
);
505 return type_to_type_object (type
);
508 /* Return the range of a type represented by SELF. The return type is
509 a tuple. The first element of the tuple contains the low bound,
510 while the second element of the tuple contains the high bound. */
512 typy_range (PyObject
*self
, PyObject
*args
)
514 struct type
*type
= ((type_object
*) self
)->type
;
516 PyObject
*low_bound
= NULL
, *high_bound
= NULL
;
517 /* Initialize these to appease GCC warnings. */
518 LONGEST low
= 0, high
= 0;
520 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
521 && TYPE_CODE (type
) != TYPE_CODE_STRING
522 && TYPE_CODE (type
) != TYPE_CODE_RANGE
)
524 PyErr_SetString (PyExc_RuntimeError
,
525 _("This type does not have a range."));
529 switch (TYPE_CODE (type
))
531 case TYPE_CODE_ARRAY
:
532 case TYPE_CODE_STRING
:
533 low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
534 high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
));
536 case TYPE_CODE_RANGE
:
537 low
= TYPE_LOW_BOUND (type
);
538 high
= TYPE_HIGH_BOUND (type
);
542 low_bound
= PyLong_FromLong (low
);
546 high_bound
= PyLong_FromLong (high
);
550 result
= PyTuple_New (2);
554 if (PyTuple_SetItem (result
, 0, low_bound
) != 0)
559 if (PyTuple_SetItem (result
, 1, high_bound
) != 0)
561 Py_DECREF (high_bound
);
568 Py_XDECREF (high_bound
);
569 Py_XDECREF (low_bound
);
573 /* Return a Type object which represents a reference to SELF. */
575 typy_reference (PyObject
*self
, PyObject
*args
)
577 struct type
*type
= ((type_object
*) self
)->type
;
578 volatile struct gdb_exception except
;
580 TRY_CATCH (except
, RETURN_MASK_ALL
)
582 type
= lookup_reference_type (type
);
584 GDB_PY_HANDLE_EXCEPTION (except
);
586 return type_to_type_object (type
);
589 /* Return a Type object which represents the target type of SELF. */
591 typy_target (PyObject
*self
, PyObject
*args
)
593 struct type
*type
= ((type_object
*) self
)->type
;
595 if (!TYPE_TARGET_TYPE (type
))
597 PyErr_SetString (PyExc_RuntimeError
,
598 _("Type does not have a target."));
602 return type_to_type_object (TYPE_TARGET_TYPE (type
));
605 /* Return a const-qualified type variant. */
607 typy_const (PyObject
*self
, PyObject
*args
)
609 struct type
*type
= ((type_object
*) self
)->type
;
610 volatile struct gdb_exception except
;
612 TRY_CATCH (except
, RETURN_MASK_ALL
)
614 type
= make_cv_type (1, 0, type
, NULL
);
616 GDB_PY_HANDLE_EXCEPTION (except
);
618 return type_to_type_object (type
);
621 /* Return a volatile-qualified type variant. */
623 typy_volatile (PyObject
*self
, PyObject
*args
)
625 struct type
*type
= ((type_object
*) self
)->type
;
626 volatile struct gdb_exception except
;
628 TRY_CATCH (except
, RETURN_MASK_ALL
)
630 type
= make_cv_type (0, 1, type
, NULL
);
632 GDB_PY_HANDLE_EXCEPTION (except
);
634 return type_to_type_object (type
);
637 /* Return an unqualified type variant. */
639 typy_unqualified (PyObject
*self
, PyObject
*args
)
641 struct type
*type
= ((type_object
*) self
)->type
;
642 volatile struct gdb_exception except
;
644 TRY_CATCH (except
, RETURN_MASK_ALL
)
646 type
= make_cv_type (0, 0, type
, NULL
);
648 GDB_PY_HANDLE_EXCEPTION (except
);
650 return type_to_type_object (type
);
653 /* Return the size of the type represented by SELF, in bytes. */
655 typy_get_sizeof (PyObject
*self
, void *closure
)
657 struct type
*type
= ((type_object
*) self
)->type
;
658 volatile struct gdb_exception except
;
660 TRY_CATCH (except
, RETURN_MASK_ALL
)
662 check_typedef (type
);
664 /* Ignore exceptions. */
666 return PyLong_FromLong (TYPE_LENGTH (type
));
670 typy_lookup_typename (const char *type_name
, const struct block
*block
)
672 struct type
*type
= NULL
;
673 volatile struct gdb_exception except
;
675 TRY_CATCH (except
, RETURN_MASK_ALL
)
677 if (!strncmp (type_name
, "struct ", 7))
678 type
= lookup_struct (type_name
+ 7, NULL
);
679 else if (!strncmp (type_name
, "union ", 6))
680 type
= lookup_union (type_name
+ 6, NULL
);
681 else if (!strncmp (type_name
, "enum ", 5))
682 type
= lookup_enum (type_name
+ 5, NULL
);
684 type
= lookup_typename (python_language
, python_gdbarch
,
685 type_name
, block
, 0);
687 if (except
.reason
< 0)
689 gdbpy_convert_exception (except
);
697 typy_lookup_type (struct demangle_component
*demangled
,
698 const struct block
*block
)
700 struct type
*type
, *rtype
= NULL
;
701 char *type_name
= NULL
;
702 enum demangle_component_type demangled_type
;
703 volatile struct gdb_exception except
;
705 /* Save the type: typy_lookup_type() may (indirectly) overwrite
706 memory pointed by demangled. */
707 demangled_type
= demangled
->type
;
709 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
710 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
711 || demangled_type
== DEMANGLE_COMPONENT_CONST
712 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
714 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
718 TRY_CATCH (except
, RETURN_MASK_ALL
)
720 /* If the demangled_type matches with one of the types
721 below, run the corresponding function and save the type
722 to return later. We cannot just return here as we are in
723 an exception handler. */
724 switch (demangled_type
)
726 case DEMANGLE_COMPONENT_REFERENCE
:
727 rtype
= lookup_reference_type (type
);
729 case DEMANGLE_COMPONENT_POINTER
:
730 rtype
= lookup_pointer_type (type
);
732 case DEMANGLE_COMPONENT_CONST
:
733 rtype
= make_cv_type (1, 0, type
, NULL
);
735 case DEMANGLE_COMPONENT_VOLATILE
:
736 rtype
= make_cv_type (0, 1, type
, NULL
);
740 if (except
.reason
< 0)
742 gdbpy_convert_exception (except
);
747 /* If we have a type from the switch statement above, just return
752 /* We don't have a type, so lookup the type. */
753 type_name
= cp_comp_to_string (demangled
, 10);
754 type
= typy_lookup_typename (type_name
, block
);
760 /* This is a helper function for typy_template_argument that is used
761 when the type does not have template symbols attached. It works by
762 parsing the type name. This happens with compilers, like older
763 versions of GCC, that do not emit DW_TAG_template_*. */
766 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
770 struct demangle_component
*demangled
;
771 struct demangle_parse_info
*info
;
773 struct type
*argtype
;
774 struct cleanup
*cleanup
;
776 if (TYPE_NAME (type
) == NULL
)
778 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
782 /* Note -- this is not thread-safe. */
783 info
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
786 PyErr_SetString (PyExc_RuntimeError
, err
);
789 demangled
= info
->tree
;
790 cleanup
= make_cleanup_cp_demangled_name_parse_free (info
);
792 /* Strip off component names. */
793 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
794 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
795 demangled
= demangled
->u
.s_binary
.right
;
797 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
799 do_cleanups (cleanup
);
800 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
804 /* Skip from the template to the arguments. */
805 demangled
= demangled
->u
.s_binary
.right
;
807 for (i
= 0; demangled
&& i
< argno
; ++i
)
808 demangled
= demangled
->u
.s_binary
.right
;
812 do_cleanups (cleanup
);
813 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
818 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
819 do_cleanups (cleanup
);
823 return type_to_type_object (argtype
);
827 typy_template_argument (PyObject
*self
, PyObject
*args
)
830 struct type
*type
= ((type_object
*) self
)->type
;
831 const struct block
*block
= NULL
;
832 PyObject
*block_obj
= NULL
;
834 struct value
*val
= NULL
;
835 volatile struct gdb_exception except
;
837 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
842 block
= block_object_to_block (block_obj
);
845 PyErr_SetString (PyExc_RuntimeError
,
846 _("Second argument must be block."));
851 TRY_CATCH (except
, RETURN_MASK_ALL
)
853 type
= check_typedef (type
);
854 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
855 type
= check_typedef (TYPE_TARGET_TYPE (type
));
857 GDB_PY_HANDLE_EXCEPTION (except
);
859 /* We might not have DW_TAG_template_*, so try to parse the type's
860 name. This is inefficient if we do not have a template type --
861 but that is going to wind up as an error anyhow. */
862 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
863 return typy_legacy_template_argument (type
, block
, argno
);
865 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
867 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
872 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
873 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
874 return type_to_type_object (SYMBOL_TYPE (sym
));
875 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
877 PyErr_Format (PyExc_RuntimeError
,
878 _("Template argument is optimized out"));
882 TRY_CATCH (except
, RETURN_MASK_ALL
)
884 val
= value_of_variable (sym
, block
);
886 GDB_PY_HANDLE_EXCEPTION (except
);
888 return value_to_value_object (val
);
892 typy_str (PyObject
*self
)
894 volatile struct gdb_exception except
;
895 char *thetype
= NULL
;
899 TRY_CATCH (except
, RETURN_MASK_ALL
)
901 struct cleanup
*old_chain
;
904 stb
= mem_fileopen ();
905 old_chain
= make_cleanup_ui_file_delete (stb
);
907 type_print (type_object_to_type (self
), "", stb
, -1);
909 thetype
= ui_file_xstrdup (stb
, &length
);
910 do_cleanups (old_chain
);
912 if (except
.reason
< 0)
915 GDB_PY_HANDLE_EXCEPTION (except
);
918 result
= PyUnicode_Decode (thetype
, length
, host_charset (), NULL
);
924 /* An entry in the type-equality bcache. */
926 typedef struct type_equality_entry
928 struct type
*type1
, *type2
;
929 } type_equality_entry_d
;
931 DEF_VEC_O (type_equality_entry_d
);
933 /* A helper function to compare two strings. Returns 1 if they are
934 the same, 0 otherwise. Handles NULLs properly. */
937 compare_strings (const char *s
, const char *t
)
939 if (s
== NULL
&& t
!= NULL
)
941 else if (s
!= NULL
&& t
== NULL
)
943 else if (s
== NULL
&& t
== NULL
)
945 return strcmp (s
, t
) == 0;
948 /* A helper function for typy_richcompare that checks two types for
949 "deep" equality. Returns Py_EQ if the types are considered the
950 same, Py_NE otherwise. */
953 check_types_equal (struct type
*type1
, struct type
*type2
,
954 VEC (type_equality_entry_d
) **worklist
)
956 CHECK_TYPEDEF (type1
);
957 CHECK_TYPEDEF (type2
);
962 if (TYPE_CODE (type1
) != TYPE_CODE (type2
)
963 || TYPE_LENGTH (type1
) != TYPE_LENGTH (type2
)
964 || TYPE_UNSIGNED (type1
) != TYPE_UNSIGNED (type2
)
965 || TYPE_NOSIGN (type1
) != TYPE_NOSIGN (type2
)
966 || TYPE_VARARGS (type1
) != TYPE_VARARGS (type2
)
967 || TYPE_VECTOR (type1
) != TYPE_VECTOR (type2
)
968 || TYPE_NOTTEXT (type1
) != TYPE_NOTTEXT (type2
)
969 || TYPE_INSTANCE_FLAGS (type1
) != TYPE_INSTANCE_FLAGS (type2
)
970 || TYPE_NFIELDS (type1
) != TYPE_NFIELDS (type2
))
973 if (!compare_strings (TYPE_TAG_NAME (type1
), TYPE_TAG_NAME (type2
)))
975 if (!compare_strings (TYPE_NAME (type1
), TYPE_NAME (type2
)))
978 if (TYPE_CODE (type1
) == TYPE_CODE_RANGE
)
980 if (memcmp (TYPE_RANGE_DATA (type1
), TYPE_RANGE_DATA (type2
),
981 sizeof (*TYPE_RANGE_DATA (type1
))) != 0)
988 for (i
= 0; i
< TYPE_NFIELDS (type1
); ++i
)
990 const struct field
*field1
= &TYPE_FIELD (type1
, i
);
991 const struct field
*field2
= &TYPE_FIELD (type2
, i
);
992 struct type_equality_entry entry
;
994 if (FIELD_ARTIFICIAL (*field1
) != FIELD_ARTIFICIAL (*field2
)
995 || FIELD_BITSIZE (*field1
) != FIELD_BITSIZE (*field2
)
996 || FIELD_LOC_KIND (*field1
) != FIELD_LOC_KIND (*field2
))
998 if (!compare_strings (FIELD_NAME (*field1
), FIELD_NAME (*field2
)))
1000 switch (FIELD_LOC_KIND (*field1
))
1002 case FIELD_LOC_KIND_BITPOS
:
1003 if (FIELD_BITPOS (*field1
) != FIELD_BITPOS (*field2
))
1006 case FIELD_LOC_KIND_PHYSADDR
:
1007 if (FIELD_STATIC_PHYSADDR (*field1
)
1008 != FIELD_STATIC_PHYSADDR (*field2
))
1011 case FIELD_LOC_KIND_PHYSNAME
:
1012 if (!compare_strings (FIELD_STATIC_PHYSNAME (*field1
),
1013 FIELD_STATIC_PHYSNAME (*field2
)))
1016 case FIELD_LOC_KIND_DWARF_BLOCK
:
1018 struct dwarf2_locexpr_baton
*block1
, *block2
;
1020 block1
= FIELD_DWARF_BLOCK (*field1
);
1021 block2
= FIELD_DWARF_BLOCK (*field2
);
1022 if (block1
->per_cu
!= block2
->per_cu
1023 || block1
->size
!= block2
->size
1024 || memcmp (block1
->data
, block2
->data
, block1
->size
) != 0)
1029 internal_error (__FILE__
, __LINE__
, _("Unsupported field kind "
1030 "%d by check_types_equal"),
1031 FIELD_LOC_KIND (*field1
));
1034 entry
.type1
= FIELD_TYPE (*field1
);
1035 entry
.type2
= FIELD_TYPE (*field2
);
1036 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
1040 if (TYPE_TARGET_TYPE (type1
) != NULL
)
1042 struct type_equality_entry entry
;
1045 if (TYPE_TARGET_TYPE (type2
) == NULL
)
1048 entry
.type1
= TYPE_TARGET_TYPE (type1
);
1049 entry
.type2
= TYPE_TARGET_TYPE (type2
);
1050 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
1052 else if (TYPE_TARGET_TYPE (type2
) != NULL
)
1058 /* Check types on a worklist for equality. Returns Py_NE if any pair
1059 is not equal, Py_EQ if they are all considered equal. */
1062 check_types_worklist (VEC (type_equality_entry_d
) **worklist
,
1063 struct bcache
*cache
)
1065 while (!VEC_empty (type_equality_entry_d
, *worklist
))
1067 struct type_equality_entry entry
;
1070 entry
= *VEC_last (type_equality_entry_d
, *worklist
);
1071 VEC_pop (type_equality_entry_d
, *worklist
);
1073 /* If the type pair has already been visited, we know it is
1075 bcache_full (&entry
, sizeof (entry
), cache
, &added
);
1079 if (check_types_equal (entry
.type1
, entry
.type2
, worklist
) == Py_NE
)
1086 /* Implement the richcompare method. */
1089 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1092 struct type
*type1
= type_object_to_type (self
);
1093 struct type
*type2
= type_object_to_type (other
);
1094 volatile struct gdb_exception except
;
1096 /* We can only compare ourselves to another Type object, and only
1097 for equality or inequality. */
1098 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
1100 Py_INCREF (Py_NotImplemented
);
1101 return Py_NotImplemented
;
1108 struct bcache
*cache
;
1109 VEC (type_equality_entry_d
) *worklist
= NULL
;
1110 struct type_equality_entry entry
;
1112 cache
= bcache_xmalloc (NULL
, NULL
);
1114 entry
.type1
= type1
;
1115 entry
.type2
= type2
;
1116 VEC_safe_push (type_equality_entry_d
, worklist
, &entry
);
1118 TRY_CATCH (except
, RETURN_MASK_ALL
)
1120 result
= check_types_worklist (&worklist
, cache
);
1122 /* check_types_worklist calls several nested Python helper
1123 functions, some of which can raise a GDB Exception, so we
1124 just check and convert here. If there is a GDB exception, a
1125 comparison is not capable (or trusted), so exit. */
1126 bcache_xfree (cache
);
1127 VEC_free (type_equality_entry_d
, worklist
);
1128 GDB_PY_HANDLE_EXCEPTION (except
);
1138 static const struct objfile_data
*typy_objfile_data_key
;
1141 save_objfile_types (struct objfile
*objfile
, void *datum
)
1143 type_object
*obj
= datum
;
1144 htab_t copied_types
;
1145 struct cleanup
*cleanup
;
1147 /* This prevents another thread from freeing the objects we're
1149 cleanup
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1151 copied_types
= create_copied_types_hash (objfile
);
1155 type_object
*next
= obj
->next
;
1157 htab_empty (copied_types
);
1159 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1167 htab_delete (copied_types
);
1169 do_cleanups (cleanup
);
1173 set_type (type_object
*obj
, struct type
*type
)
1177 if (type
&& TYPE_OBJFILE (type
))
1179 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1181 obj
->next
= objfile_data (objfile
, typy_objfile_data_key
);
1183 obj
->next
->prev
= obj
;
1184 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1191 typy_dealloc (PyObject
*obj
)
1193 type_object
*type
= (type_object
*) obj
;
1196 type
->prev
->next
= type
->next
;
1197 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1199 /* Must reset head of list. */
1200 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1203 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1206 type
->next
->prev
= type
->prev
;
1208 type
->ob_type
->tp_free (type
);
1211 /* Return number of fields ("length" of the field dictionary). */
1214 typy_length (PyObject
*self
)
1216 struct type
*type
= ((type_object
*) self
)->type
;
1218 type
= typy_get_composite (type
);
1222 return TYPE_NFIELDS (type
);
1225 /* Implements boolean evaluation of gdb.Type. Handle this like other
1226 Python objects that don't have a meaningful truth value -- all
1230 typy_nonzero (PyObject
*self
)
1235 /* Return a gdb.Field object for the field named by the argument. */
1238 typy_getitem (PyObject
*self
, PyObject
*key
)
1240 struct type
*type
= ((type_object
*) self
)->type
;
1243 volatile struct gdb_exception except
;
1245 field
= python_string_to_host_string (key
);
1249 /* We want just fields of this type, not of base types, so instead of
1250 using lookup_struct_elt_type, portions of that function are
1253 type
= typy_get_composite (type
);
1257 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1259 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1261 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1263 return convert_field (type
, i
);
1266 PyErr_SetObject (PyExc_KeyError
, key
);
1270 /* Implement the "get" method on the type object. This is the
1271 same as getitem if the key is present, but returns the supplied
1272 default value or None if the key is not found. */
1275 typy_get (PyObject
*self
, PyObject
*args
)
1277 PyObject
*key
, *defval
= Py_None
, *result
;
1279 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1282 result
= typy_getitem (self
, key
);
1286 /* typy_getitem returned error status. If the exception is
1287 KeyError, clear the exception status and return the defval
1288 instead. Otherwise return the exception unchanged. */
1289 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1297 /* Implement the "has_key" method on the type object. */
1300 typy_has_key (PyObject
*self
, PyObject
*args
)
1302 struct type
*type
= ((type_object
*) self
)->type
;
1305 volatile struct gdb_exception except
;
1307 if (!PyArg_ParseTuple (args
, "s", &field
))
1310 /* We want just fields of this type, not of base types, so instead of
1311 using lookup_struct_elt_type, portions of that function are
1314 type
= typy_get_composite (type
);
1318 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1320 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1322 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1328 /* Make an iterator object to iterate over keys, values, or items. */
1331 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1333 typy_iterator_object
*typy_iter_obj
;
1335 /* Check that "self" is a structure or union type. */
1336 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1339 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1340 &type_iterator_object_type
);
1341 if (typy_iter_obj
== NULL
)
1344 typy_iter_obj
->field
= 0;
1345 typy_iter_obj
->kind
= kind
;
1347 typy_iter_obj
->source
= (type_object
*) self
;
1349 return (PyObject
*) typy_iter_obj
;
1352 /* iteritems() method. */
1355 typy_iteritems (PyObject
*self
, PyObject
*args
)
1357 return typy_make_iter (self
, iter_items
);
1360 /* iterkeys() method. */
1363 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1365 return typy_make_iter (self
, iter_keys
);
1368 /* Iterating over the class, same as iterkeys except for the function
1372 typy_iter (PyObject
*self
)
1374 return typy_make_iter (self
, iter_keys
);
1377 /* itervalues() method. */
1380 typy_itervalues (PyObject
*self
, PyObject
*args
)
1382 return typy_make_iter (self
, iter_values
);
1385 /* Return a reference to the type iterator. */
1388 typy_iterator_iter (PyObject
*self
)
1394 /* Return the next field in the iteration through the list of fields
1398 typy_iterator_iternext (PyObject
*self
)
1400 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1401 struct type
*type
= iter_obj
->source
->type
;
1405 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1407 result
= make_fielditem (type
, iter_obj
->field
, iter_obj
->kind
);
1417 typy_iterator_dealloc (PyObject
*obj
)
1419 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1421 Py_DECREF (iter_obj
->source
);
1424 /* Create a new Type referring to TYPE. */
1426 type_to_type_object (struct type
*type
)
1428 type_object
*type_obj
;
1430 type_obj
= PyObject_New (type_object
, &type_object_type
);
1432 set_type (type_obj
, type
);
1434 return (PyObject
*) type_obj
;
1438 type_object_to_type (PyObject
*obj
)
1440 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1442 return ((type_object
*) obj
)->type
;
1447 /* Implementation of gdb.lookup_type. */
1449 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1451 static char *keywords
[] = { "name", "block", NULL
};
1452 const char *type_name
= NULL
;
1453 struct type
*type
= NULL
;
1454 PyObject
*block_obj
= NULL
;
1455 const struct block
*block
= NULL
;
1457 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1458 &type_name
, &block_obj
))
1463 block
= block_object_to_block (block_obj
);
1466 PyErr_SetString (PyExc_RuntimeError
,
1467 _("'block' argument must be a Block."));
1472 type
= typy_lookup_typename (type_name
, block
);
1476 return (PyObject
*) type_to_type_object (type
);
1480 gdbpy_initialize_types (void)
1484 typy_objfile_data_key
1485 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1487 if (PyType_Ready (&type_object_type
) < 0)
1489 if (PyType_Ready (&field_object_type
) < 0)
1491 if (PyType_Ready (&type_iterator_object_type
) < 0)
1494 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1496 if (PyModule_AddIntConstant (gdb_module
,
1497 /* Cast needed for Python 2.4. */
1498 (char *) pyty_codes
[i
].name
,
1499 pyty_codes
[i
].code
) < 0)
1503 Py_INCREF (&type_object_type
);
1504 PyModule_AddObject (gdb_module
, "Type", (PyObject
*) &type_object_type
);
1506 Py_INCREF (&type_iterator_object_type
);
1507 PyModule_AddObject (gdb_module
, "TypeIterator",
1508 (PyObject
*) &type_iterator_object_type
);
1510 Py_INCREF (&field_object_type
);
1511 PyModule_AddObject (gdb_module
, "Field", (PyObject
*) &field_object_type
);
1516 static PyGetSetDef type_object_getset
[] =
1518 { "code", typy_get_code
, NULL
,
1519 "The code for this type.", NULL
},
1520 { "sizeof", typy_get_sizeof
, NULL
,
1521 "The size of this type, in bytes.", NULL
},
1522 { "tag", typy_get_tag
, NULL
,
1523 "The tag name for this type, or None.", NULL
},
1527 static PyMethodDef type_object_methods
[] =
1529 { "array", typy_array
, METH_VARARGS
,
1530 "array (N) -> Type\n\
1531 Return a type which represents an array of N objects of this type." },
1532 { "__contains__", typy_has_key
, METH_VARARGS
,
1533 "T.__contains__(k) -> True if T has a field named k, else False" },
1534 { "const", typy_const
, METH_NOARGS
,
1535 "const () -> Type\n\
1536 Return a const variant of this type." },
1537 { "fields", typy_fields
, METH_NOARGS
,
1538 "fields () -> list\n\
1539 Return a list holding all the fields of this type.\n\
1540 Each field is a gdb.Field object." },
1541 { "get", typy_get
, METH_VARARGS
,
1542 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1543 otherwise returns default, if supplied, or None if not." },
1544 { "has_key", typy_has_key
, METH_VARARGS
,
1545 "T.has_key(k) -> True if T has a field named k, else False" },
1546 { "items", typy_items
, METH_NOARGS
,
1547 "items () -> list\n\
1548 Return a list of (name, field) pairs of this type.\n\
1549 Each field is a gdb.Field object." },
1550 { "iteritems", typy_iteritems
, METH_NOARGS
,
1551 "iteritems () -> an iterator over the (name, field)\n\
1552 pairs of this type. Each field is a gdb.Field object." },
1553 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1554 "iterkeys () -> an iterator over the field names of this type." },
1555 { "itervalues", typy_itervalues
, METH_NOARGS
,
1556 "itervalues () -> an iterator over the fields of this type.\n\
1557 Each field is a gdb.Field object." },
1558 { "keys", typy_field_names
, METH_NOARGS
,
1560 Return a list holding all the fields names of this type." },
1561 { "pointer", typy_pointer
, METH_NOARGS
,
1562 "pointer () -> Type\n\
1563 Return a type of pointer to this type." },
1564 { "range", typy_range
, METH_NOARGS
,
1565 "range () -> tuple\n\
1566 Return a tuple containing the lower and upper range for this type."},
1567 { "reference", typy_reference
, METH_NOARGS
,
1568 "reference () -> Type\n\
1569 Return a type of reference to this type." },
1570 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1571 "strip_typedefs () -> Type\n\
1572 Return a type formed by stripping this type of all typedefs."},
1573 { "target", typy_target
, METH_NOARGS
,
1574 "target () -> Type\n\
1575 Return the target type of this type." },
1576 { "template_argument", typy_template_argument
, METH_VARARGS
,
1577 "template_argument (arg, [block]) -> Type\n\
1578 Return the type of a template argument." },
1579 { "unqualified", typy_unqualified
, METH_NOARGS
,
1580 "unqualified () -> Type\n\
1581 Return a variant of this type without const or volatile attributes." },
1582 { "values", typy_values
, METH_NOARGS
,
1583 "values () -> list\n\
1584 Return a list holding all the fields of this type.\n\
1585 Each field is a gdb.Field object." },
1586 { "volatile", typy_volatile
, METH_NOARGS
,
1587 "volatile () -> Type\n\
1588 Return a volatile variant of this type" },
1592 static PyNumberMethods type_object_as_number
= {
1594 NULL
, /* nb_subtract */
1595 NULL
, /* nb_multiply */
1596 NULL
, /* nb_divide */
1597 NULL
, /* nb_remainder */
1598 NULL
, /* nb_divmod */
1599 NULL
, /* nb_power */
1600 NULL
, /* nb_negative */
1601 NULL
, /* nb_positive */
1602 NULL
, /* nb_absolute */
1603 typy_nonzero
, /* nb_nonzero */
1604 NULL
, /* nb_invert */
1605 NULL
, /* nb_lshift */
1606 NULL
, /* nb_rshift */
1610 NULL
, /* nb_coerce */
1613 NULL
, /* nb_float */
1618 static PyMappingMethods typy_mapping
= {
1621 NULL
/* no "set" method */
1624 static PyTypeObject type_object_type
=
1626 PyObject_HEAD_INIT (NULL
)
1628 "gdb.Type", /*tp_name*/
1629 sizeof (type_object
), /*tp_basicsize*/
1631 typy_dealloc
, /*tp_dealloc*/
1637 &type_object_as_number
, /*tp_as_number*/
1638 0, /*tp_as_sequence*/
1639 &typy_mapping
, /*tp_as_mapping*/
1642 typy_str
, /*tp_str*/
1646 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1647 "GDB type object", /* tp_doc */
1648 0, /* tp_traverse */
1650 typy_richcompare
, /* tp_richcompare */
1651 0, /* tp_weaklistoffset */
1652 typy_iter
, /* tp_iter */
1653 0, /* tp_iternext */
1654 type_object_methods
, /* tp_methods */
1656 type_object_getset
, /* tp_getset */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1667 static PyTypeObject field_object_type
=
1669 PyObject_HEAD_INIT (NULL
)
1671 "gdb.Field", /*tp_name*/
1672 sizeof (field_object
), /*tp_basicsize*/
1674 field_dealloc
, /*tp_dealloc*/
1681 0, /*tp_as_sequence*/
1682 0, /*tp_as_mapping*/
1689 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1690 "GDB field object", /* tp_doc */
1691 0, /* tp_traverse */
1693 0, /* tp_richcompare */
1694 0, /* tp_weaklistoffset */
1696 0, /* tp_iternext */
1702 0, /* tp_descr_get */
1703 0, /* tp_descr_set */
1704 offsetof (field_object
, dict
), /* tp_dictoffset */
1710 static PyTypeObject type_iterator_object_type
= {
1711 PyObject_HEAD_INIT (NULL
)
1713 "gdb.TypeIterator", /*tp_name*/
1714 sizeof (typy_iterator_object
), /*tp_basicsize*/
1716 typy_iterator_dealloc
, /*tp_dealloc*/
1723 0, /*tp_as_sequence*/
1724 0, /*tp_as_mapping*/
1731 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1732 "GDB type iterator object", /*tp_doc */
1735 0, /*tp_richcompare */
1736 0, /*tp_weaklistoffset */
1737 typy_iterator_iter
, /*tp_iter */
1738 typy_iterator_iternext
, /*tp_iternext */