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_BITSTRING
),
89 ENTRY (TYPE_CODE_PTR
),
90 ENTRY (TYPE_CODE_ARRAY
),
91 ENTRY (TYPE_CODE_STRUCT
),
92 ENTRY (TYPE_CODE_UNION
),
93 ENTRY (TYPE_CODE_ENUM
),
94 ENTRY (TYPE_CODE_FLAGS
),
95 ENTRY (TYPE_CODE_FUNC
),
96 ENTRY (TYPE_CODE_INT
),
97 ENTRY (TYPE_CODE_FLT
),
98 ENTRY (TYPE_CODE_VOID
),
99 ENTRY (TYPE_CODE_SET
),
100 ENTRY (TYPE_CODE_RANGE
),
101 ENTRY (TYPE_CODE_STRING
),
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 const char *attrstring
;
172 if (TYPE_CODE (type
) == TYPE_CODE_ENUM
)
174 arg
= gdb_py_long_from_longest (TYPE_FIELD_ENUMVAL (type
, field
));
175 attrstring
= "enumval";
179 arg
= gdb_py_long_from_longest (TYPE_FIELD_BITPOS (type
, field
));
180 attrstring
= "bitpos";
186 /* At least python-2.4 had the second parameter non-const. */
187 if (PyObject_SetAttrString (result
, (char *) attrstring
, arg
) < 0)
192 if (TYPE_FIELD_NAME (type
, field
))
193 arg
= PyString_FromString (TYPE_FIELD_NAME (type
, field
));
201 if (PyObject_SetAttrString (result
, "name", arg
) < 0)
205 arg
= TYPE_FIELD_ARTIFICIAL (type
, field
) ? Py_True
: Py_False
;
207 if (PyObject_SetAttrString (result
, "artificial", arg
) < 0)
211 if (TYPE_CODE (type
) == TYPE_CODE_CLASS
)
212 arg
= field
< TYPE_N_BASECLASSES (type
) ? Py_True
: Py_False
;
216 if (PyObject_SetAttrString (result
, "is_base_class", arg
) < 0)
220 arg
= PyLong_FromLong (TYPE_FIELD_BITSIZE (type
, field
));
223 if (PyObject_SetAttrString (result
, "bitsize", arg
) < 0)
227 /* A field can have a NULL type in some situations. */
228 if (TYPE_FIELD_TYPE (type
, field
) == NULL
)
234 arg
= type_to_type_object (TYPE_FIELD_TYPE (type
, field
));
237 if (PyObject_SetAttrString (result
, "type", arg
) < 0)
250 /* Helper function to return the name of a field, as a gdb.Field object.
251 If the field doesn't have a name, None is returned. */
254 field_name (struct type
*type
, int field
)
258 if (TYPE_FIELD_NAME (type
, field
))
259 result
= PyString_FromString (TYPE_FIELD_NAME (type
, field
));
268 /* Helper function for Type standard mapping methods. Returns a
269 Python object for field i of the type. "kind" specifies what to
270 return: the name of the field, a gdb.Field object corresponding to
271 the field, or a tuple consisting of field name and gdb.Field
275 make_fielditem (struct type
*type
, int i
, enum gdbpy_iter_kind kind
)
277 PyObject
*item
= NULL
, *key
= NULL
, *value
= NULL
;
282 key
= field_name (type
, i
);
285 value
= convert_field (type
, i
);
288 item
= PyTuple_New (2);
291 PyTuple_SET_ITEM (item
, 0, key
);
292 PyTuple_SET_ITEM (item
, 1, value
);
295 item
= field_name (type
, i
);
298 item
= convert_field (type
, i
);
310 /* Return a sequence of all field names, fields, or (name, field) pairs.
311 Each field is a gdb.Field object. */
314 typy_fields_items (PyObject
*self
, enum gdbpy_iter_kind kind
)
316 PyObject
*py_type
= self
;
317 PyObject
*result
= NULL
, *iter
= NULL
;
318 volatile struct gdb_exception except
;
319 struct type
*type
= ((type_object
*) py_type
)->type
;
320 struct type
*checked_type
= type
;
322 TRY_CATCH (except
, RETURN_MASK_ALL
)
324 CHECK_TYPEDEF (checked_type
);
326 GDB_PY_HANDLE_EXCEPTION (except
);
328 if (checked_type
!= type
)
329 py_type
= type_to_type_object (checked_type
);
330 iter
= typy_make_iter (py_type
, kind
);
331 if (checked_type
!= type
)
333 /* Need to wrap this in braces because Py_DECREF isn't wrapped
334 in a do{}while(0). */
339 result
= PySequence_List (iter
);
346 /* Return a sequence of all fields. Each field is a gdb.Field object. */
349 typy_values (PyObject
*self
, PyObject
*args
)
351 return typy_fields_items (self
, iter_values
);
354 /* Return a sequence of all fields. Each field is a gdb.Field object.
355 This method is similar to typy_values, except where the supplied
356 gdb.Type is an array, in which case it returns a list of one entry
357 which is a gdb.Field object for a range (the array bounds). */
360 typy_fields (PyObject
*self
, PyObject
*args
)
362 struct type
*type
= ((type_object
*) self
)->type
;
365 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
366 return typy_fields_items (self
, iter_values
);
368 /* Array type. Handle this as a special case because the common
369 machinery wants struct or union or enum types. Build a list of
370 one entry which is the range for the array. */
371 r
= convert_field (type
, 0);
375 rl
= Py_BuildValue ("[O]", r
);
384 /* Return a sequence of all field names. Each field is a gdb.Field object. */
387 typy_field_names (PyObject
*self
, PyObject
*args
)
389 return typy_fields_items (self
, iter_keys
);
392 /* Return a sequence of all (name, fields) pairs. Each field is a
396 typy_items (PyObject
*self
, PyObject
*args
)
398 return typy_fields_items (self
, iter_items
);
401 /* Return the type's tag, or None. */
403 typy_get_tag (PyObject
*self
, void *closure
)
405 struct type
*type
= ((type_object
*) self
)->type
;
407 if (!TYPE_TAG_NAME (type
))
409 return PyString_FromString (TYPE_TAG_NAME (type
));
412 /* Return the type, stripped of typedefs. */
414 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
416 struct type
*type
= ((type_object
*) self
)->type
;
417 volatile struct gdb_exception except
;
419 TRY_CATCH (except
, RETURN_MASK_ALL
)
421 type
= check_typedef (type
);
423 GDB_PY_HANDLE_EXCEPTION (except
);
425 return type_to_type_object (check_typedef (type
));
428 /* Strip typedefs and pointers/reference from a type. Then check that
429 it is a struct, union, or enum type. If not, raise TypeError. */
432 typy_get_composite (struct type
*type
)
434 volatile struct gdb_exception except
;
438 TRY_CATCH (except
, RETURN_MASK_ALL
)
440 CHECK_TYPEDEF (type
);
442 /* Don't use GDB_PY_HANDLE_EXCEPTION here because that returns
443 a (NULL) pointer of the wrong type. */
444 if (except
.reason
< 0)
446 gdbpy_convert_exception (except
);
450 if (TYPE_CODE (type
) != TYPE_CODE_PTR
451 && TYPE_CODE (type
) != TYPE_CODE_REF
)
453 type
= TYPE_TARGET_TYPE (type
);
456 /* If this is not a struct, union, or enum type, raise TypeError
458 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
459 && TYPE_CODE (type
) != TYPE_CODE_UNION
460 && TYPE_CODE (type
) != TYPE_CODE_ENUM
)
462 PyErr_SetString (PyExc_TypeError
,
463 "Type is not a structure, union, or enum type.");
470 /* Helper for typy_array and typy_vector. */
473 typy_array_1 (PyObject
*self
, PyObject
*args
, int is_vector
)
476 PyObject
*n2_obj
= NULL
;
477 struct type
*array
= NULL
;
478 struct type
*type
= ((type_object
*) self
)->type
;
479 volatile struct gdb_exception except
;
481 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
486 if (!PyInt_Check (n2_obj
))
488 PyErr_SetString (PyExc_RuntimeError
,
489 _("Array bound must be an integer"));
493 if (! gdb_py_int_as_long (n2_obj
, &n2
))
504 PyErr_SetString (PyExc_ValueError
,
505 _("Array length must not be negative"));
509 TRY_CATCH (except
, RETURN_MASK_ALL
)
511 array
= lookup_array_range_type (type
, n1
, n2
);
513 make_vector_type (array
);
515 GDB_PY_HANDLE_EXCEPTION (except
);
517 return type_to_type_object (array
);
520 /* Return an array type. */
523 typy_array (PyObject
*self
, PyObject
*args
)
525 return typy_array_1 (self
, args
, 0);
528 /* Return a vector type. */
531 typy_vector (PyObject
*self
, PyObject
*args
)
533 return typy_array_1 (self
, args
, 1);
536 /* Return a Type object which represents a pointer to SELF. */
538 typy_pointer (PyObject
*self
, PyObject
*args
)
540 struct type
*type
= ((type_object
*) self
)->type
;
541 volatile struct gdb_exception except
;
543 TRY_CATCH (except
, RETURN_MASK_ALL
)
545 type
= lookup_pointer_type (type
);
547 GDB_PY_HANDLE_EXCEPTION (except
);
549 return type_to_type_object (type
);
552 /* Return the range of a type represented by SELF. The return type is
553 a tuple. The first element of the tuple contains the low bound,
554 while the second element of the tuple contains the high bound. */
556 typy_range (PyObject
*self
, PyObject
*args
)
558 struct type
*type
= ((type_object
*) self
)->type
;
560 PyObject
*low_bound
= NULL
, *high_bound
= NULL
;
561 /* Initialize these to appease GCC warnings. */
562 LONGEST low
= 0, high
= 0;
564 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
565 && TYPE_CODE (type
) != TYPE_CODE_STRING
566 && TYPE_CODE (type
) != TYPE_CODE_RANGE
)
568 PyErr_SetString (PyExc_RuntimeError
,
569 _("This type does not have a range."));
573 switch (TYPE_CODE (type
))
575 case TYPE_CODE_ARRAY
:
576 case TYPE_CODE_STRING
:
577 low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
578 high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
));
580 case TYPE_CODE_RANGE
:
581 low
= TYPE_LOW_BOUND (type
);
582 high
= TYPE_HIGH_BOUND (type
);
586 low_bound
= PyLong_FromLong (low
);
590 high_bound
= PyLong_FromLong (high
);
594 result
= PyTuple_New (2);
598 if (PyTuple_SetItem (result
, 0, low_bound
) != 0)
603 if (PyTuple_SetItem (result
, 1, high_bound
) != 0)
605 Py_DECREF (high_bound
);
612 Py_XDECREF (high_bound
);
613 Py_XDECREF (low_bound
);
617 /* Return a Type object which represents a reference to SELF. */
619 typy_reference (PyObject
*self
, PyObject
*args
)
621 struct type
*type
= ((type_object
*) self
)->type
;
622 volatile struct gdb_exception except
;
624 TRY_CATCH (except
, RETURN_MASK_ALL
)
626 type
= lookup_reference_type (type
);
628 GDB_PY_HANDLE_EXCEPTION (except
);
630 return type_to_type_object (type
);
633 /* Return a Type object which represents the target type of SELF. */
635 typy_target (PyObject
*self
, PyObject
*args
)
637 struct type
*type
= ((type_object
*) self
)->type
;
639 if (!TYPE_TARGET_TYPE (type
))
641 PyErr_SetString (PyExc_RuntimeError
,
642 _("Type does not have a target."));
646 return type_to_type_object (TYPE_TARGET_TYPE (type
));
649 /* Return a const-qualified type variant. */
651 typy_const (PyObject
*self
, PyObject
*args
)
653 struct type
*type
= ((type_object
*) self
)->type
;
654 volatile struct gdb_exception except
;
656 TRY_CATCH (except
, RETURN_MASK_ALL
)
658 type
= make_cv_type (1, 0, type
, NULL
);
660 GDB_PY_HANDLE_EXCEPTION (except
);
662 return type_to_type_object (type
);
665 /* Return a volatile-qualified type variant. */
667 typy_volatile (PyObject
*self
, PyObject
*args
)
669 struct type
*type
= ((type_object
*) self
)->type
;
670 volatile struct gdb_exception except
;
672 TRY_CATCH (except
, RETURN_MASK_ALL
)
674 type
= make_cv_type (0, 1, type
, NULL
);
676 GDB_PY_HANDLE_EXCEPTION (except
);
678 return type_to_type_object (type
);
681 /* Return an unqualified type variant. */
683 typy_unqualified (PyObject
*self
, PyObject
*args
)
685 struct type
*type
= ((type_object
*) self
)->type
;
686 volatile struct gdb_exception except
;
688 TRY_CATCH (except
, RETURN_MASK_ALL
)
690 type
= make_cv_type (0, 0, type
, NULL
);
692 GDB_PY_HANDLE_EXCEPTION (except
);
694 return type_to_type_object (type
);
697 /* Return the size of the type represented by SELF, in bytes. */
699 typy_get_sizeof (PyObject
*self
, void *closure
)
701 struct type
*type
= ((type_object
*) self
)->type
;
702 volatile struct gdb_exception except
;
704 TRY_CATCH (except
, RETURN_MASK_ALL
)
706 check_typedef (type
);
708 /* Ignore exceptions. */
710 return gdb_py_long_from_longest (TYPE_LENGTH (type
));
714 typy_lookup_typename (const char *type_name
, const struct block
*block
)
716 struct type
*type
= NULL
;
717 volatile struct gdb_exception except
;
719 TRY_CATCH (except
, RETURN_MASK_ALL
)
721 if (!strncmp (type_name
, "struct ", 7))
722 type
= lookup_struct (type_name
+ 7, NULL
);
723 else if (!strncmp (type_name
, "union ", 6))
724 type
= lookup_union (type_name
+ 6, NULL
);
725 else if (!strncmp (type_name
, "enum ", 5))
726 type
= lookup_enum (type_name
+ 5, NULL
);
728 type
= lookup_typename (python_language
, python_gdbarch
,
729 type_name
, block
, 0);
731 if (except
.reason
< 0)
733 gdbpy_convert_exception (except
);
741 typy_lookup_type (struct demangle_component
*demangled
,
742 const struct block
*block
)
744 struct type
*type
, *rtype
= NULL
;
745 char *type_name
= NULL
;
746 enum demangle_component_type demangled_type
;
747 volatile struct gdb_exception except
;
749 /* Save the type: typy_lookup_type() may (indirectly) overwrite
750 memory pointed by demangled. */
751 demangled_type
= demangled
->type
;
753 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
754 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
755 || demangled_type
== DEMANGLE_COMPONENT_CONST
756 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
758 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
762 TRY_CATCH (except
, RETURN_MASK_ALL
)
764 /* If the demangled_type matches with one of the types
765 below, run the corresponding function and save the type
766 to return later. We cannot just return here as we are in
767 an exception handler. */
768 switch (demangled_type
)
770 case DEMANGLE_COMPONENT_REFERENCE
:
771 rtype
= lookup_reference_type (type
);
773 case DEMANGLE_COMPONENT_POINTER
:
774 rtype
= lookup_pointer_type (type
);
776 case DEMANGLE_COMPONENT_CONST
:
777 rtype
= make_cv_type (1, 0, type
, NULL
);
779 case DEMANGLE_COMPONENT_VOLATILE
:
780 rtype
= make_cv_type (0, 1, type
, NULL
);
784 if (except
.reason
< 0)
786 gdbpy_convert_exception (except
);
791 /* If we have a type from the switch statement above, just return
796 /* We don't have a type, so lookup the type. */
797 type_name
= cp_comp_to_string (demangled
, 10);
798 type
= typy_lookup_typename (type_name
, block
);
804 /* This is a helper function for typy_template_argument that is used
805 when the type does not have template symbols attached. It works by
806 parsing the type name. This happens with compilers, like older
807 versions of GCC, that do not emit DW_TAG_template_*. */
810 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
814 struct demangle_component
*demangled
;
815 struct demangle_parse_info
*info
= NULL
;
817 struct type
*argtype
;
818 struct cleanup
*cleanup
;
819 volatile struct gdb_exception except
;
821 if (TYPE_NAME (type
) == NULL
)
823 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
827 TRY_CATCH (except
, RETURN_MASK_ALL
)
829 /* Note -- this is not thread-safe. */
830 info
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
832 GDB_PY_HANDLE_EXCEPTION (except
);
836 PyErr_SetString (PyExc_RuntimeError
, err
);
839 demangled
= info
->tree
;
840 cleanup
= make_cleanup_cp_demangled_name_parse_free (info
);
842 /* Strip off component names. */
843 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
844 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
845 demangled
= demangled
->u
.s_binary
.right
;
847 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
849 do_cleanups (cleanup
);
850 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
854 /* Skip from the template to the arguments. */
855 demangled
= demangled
->u
.s_binary
.right
;
857 for (i
= 0; demangled
&& i
< argno
; ++i
)
858 demangled
= demangled
->u
.s_binary
.right
;
862 do_cleanups (cleanup
);
863 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
868 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
869 do_cleanups (cleanup
);
873 return type_to_type_object (argtype
);
877 typy_template_argument (PyObject
*self
, PyObject
*args
)
880 struct type
*type
= ((type_object
*) self
)->type
;
881 const struct block
*block
= NULL
;
882 PyObject
*block_obj
= NULL
;
884 struct value
*val
= NULL
;
885 volatile struct gdb_exception except
;
887 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
892 block
= block_object_to_block (block_obj
);
895 PyErr_SetString (PyExc_RuntimeError
,
896 _("Second argument must be block."));
901 TRY_CATCH (except
, RETURN_MASK_ALL
)
903 type
= check_typedef (type
);
904 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
905 type
= check_typedef (TYPE_TARGET_TYPE (type
));
907 GDB_PY_HANDLE_EXCEPTION (except
);
909 /* We might not have DW_TAG_template_*, so try to parse the type's
910 name. This is inefficient if we do not have a template type --
911 but that is going to wind up as an error anyhow. */
912 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
913 return typy_legacy_template_argument (type
, block
, argno
);
915 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
917 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
922 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
923 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
924 return type_to_type_object (SYMBOL_TYPE (sym
));
925 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
927 PyErr_Format (PyExc_RuntimeError
,
928 _("Template argument is optimized out"));
932 TRY_CATCH (except
, RETURN_MASK_ALL
)
934 val
= value_of_variable (sym
, block
);
936 GDB_PY_HANDLE_EXCEPTION (except
);
938 return value_to_value_object (val
);
942 typy_str (PyObject
*self
)
944 volatile struct gdb_exception except
;
945 char *thetype
= NULL
;
949 TRY_CATCH (except
, RETURN_MASK_ALL
)
951 struct cleanup
*old_chain
;
954 stb
= mem_fileopen ();
955 old_chain
= make_cleanup_ui_file_delete (stb
);
957 type_print (type_object_to_type (self
), "", stb
, -1);
959 thetype
= ui_file_xstrdup (stb
, &length
);
960 do_cleanups (old_chain
);
962 if (except
.reason
< 0)
965 GDB_PY_HANDLE_EXCEPTION (except
);
968 result
= PyUnicode_Decode (thetype
, length
, host_charset (), NULL
);
974 /* An entry in the type-equality bcache. */
976 typedef struct type_equality_entry
978 struct type
*type1
, *type2
;
979 } type_equality_entry_d
;
981 DEF_VEC_O (type_equality_entry_d
);
983 /* A helper function to compare two strings. Returns 1 if they are
984 the same, 0 otherwise. Handles NULLs properly. */
987 compare_maybe_null_strings (const char *s
, const char *t
)
989 if (s
== NULL
&& t
!= NULL
)
991 else if (s
!= NULL
&& t
== NULL
)
993 else if (s
== NULL
&& t
== NULL
)
995 return strcmp (s
, t
) == 0;
998 /* A helper function for typy_richcompare that checks two types for
999 "deep" equality. Returns Py_EQ if the types are considered the
1000 same, Py_NE otherwise. */
1003 check_types_equal (struct type
*type1
, struct type
*type2
,
1004 VEC (type_equality_entry_d
) **worklist
)
1006 CHECK_TYPEDEF (type1
);
1007 CHECK_TYPEDEF (type2
);
1012 if (TYPE_CODE (type1
) != TYPE_CODE (type2
)
1013 || TYPE_LENGTH (type1
) != TYPE_LENGTH (type2
)
1014 || TYPE_UNSIGNED (type1
) != TYPE_UNSIGNED (type2
)
1015 || TYPE_NOSIGN (type1
) != TYPE_NOSIGN (type2
)
1016 || TYPE_VARARGS (type1
) != TYPE_VARARGS (type2
)
1017 || TYPE_VECTOR (type1
) != TYPE_VECTOR (type2
)
1018 || TYPE_NOTTEXT (type1
) != TYPE_NOTTEXT (type2
)
1019 || TYPE_INSTANCE_FLAGS (type1
) != TYPE_INSTANCE_FLAGS (type2
)
1020 || TYPE_NFIELDS (type1
) != TYPE_NFIELDS (type2
))
1023 if (!compare_maybe_null_strings (TYPE_TAG_NAME (type1
),
1024 TYPE_TAG_NAME (type2
)))
1026 if (!compare_maybe_null_strings (TYPE_NAME (type1
), TYPE_NAME (type2
)))
1029 if (TYPE_CODE (type1
) == TYPE_CODE_RANGE
)
1031 if (memcmp (TYPE_RANGE_DATA (type1
), TYPE_RANGE_DATA (type2
),
1032 sizeof (*TYPE_RANGE_DATA (type1
))) != 0)
1039 for (i
= 0; i
< TYPE_NFIELDS (type1
); ++i
)
1041 const struct field
*field1
= &TYPE_FIELD (type1
, i
);
1042 const struct field
*field2
= &TYPE_FIELD (type2
, i
);
1043 struct type_equality_entry entry
;
1045 if (FIELD_ARTIFICIAL (*field1
) != FIELD_ARTIFICIAL (*field2
)
1046 || FIELD_BITSIZE (*field1
) != FIELD_BITSIZE (*field2
)
1047 || FIELD_LOC_KIND (*field1
) != FIELD_LOC_KIND (*field2
))
1049 if (!compare_maybe_null_strings (FIELD_NAME (*field1
),
1050 FIELD_NAME (*field2
)))
1052 switch (FIELD_LOC_KIND (*field1
))
1054 case FIELD_LOC_KIND_BITPOS
:
1055 if (FIELD_BITPOS (*field1
) != FIELD_BITPOS (*field2
))
1058 case FIELD_LOC_KIND_ENUMVAL
:
1059 if (FIELD_ENUMVAL (*field1
) != FIELD_ENUMVAL (*field2
))
1062 case FIELD_LOC_KIND_PHYSADDR
:
1063 if (FIELD_STATIC_PHYSADDR (*field1
)
1064 != FIELD_STATIC_PHYSADDR (*field2
))
1067 case FIELD_LOC_KIND_PHYSNAME
:
1068 if (!compare_maybe_null_strings (FIELD_STATIC_PHYSNAME (*field1
),
1069 FIELD_STATIC_PHYSNAME (*field2
)))
1072 case FIELD_LOC_KIND_DWARF_BLOCK
:
1074 struct dwarf2_locexpr_baton
*block1
, *block2
;
1076 block1
= FIELD_DWARF_BLOCK (*field1
);
1077 block2
= FIELD_DWARF_BLOCK (*field2
);
1078 if (block1
->per_cu
!= block2
->per_cu
1079 || block1
->size
!= block2
->size
1080 || memcmp (block1
->data
, block2
->data
, block1
->size
) != 0)
1085 internal_error (__FILE__
, __LINE__
, _("Unsupported field kind "
1086 "%d by check_types_equal"),
1087 FIELD_LOC_KIND (*field1
));
1090 entry
.type1
= FIELD_TYPE (*field1
);
1091 entry
.type2
= FIELD_TYPE (*field2
);
1092 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
1096 if (TYPE_TARGET_TYPE (type1
) != NULL
)
1098 struct type_equality_entry entry
;
1100 if (TYPE_TARGET_TYPE (type2
) == NULL
)
1103 entry
.type1
= TYPE_TARGET_TYPE (type1
);
1104 entry
.type2
= TYPE_TARGET_TYPE (type2
);
1105 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
1107 else if (TYPE_TARGET_TYPE (type2
) != NULL
)
1113 /* Check types on a worklist for equality. Returns Py_NE if any pair
1114 is not equal, Py_EQ if they are all considered equal. */
1117 check_types_worklist (VEC (type_equality_entry_d
) **worklist
,
1118 struct bcache
*cache
)
1120 while (!VEC_empty (type_equality_entry_d
, *worklist
))
1122 struct type_equality_entry entry
;
1125 entry
= *VEC_last (type_equality_entry_d
, *worklist
);
1126 VEC_pop (type_equality_entry_d
, *worklist
);
1128 /* If the type pair has already been visited, we know it is
1130 bcache_full (&entry
, sizeof (entry
), cache
, &added
);
1134 if (check_types_equal (entry
.type1
, entry
.type2
, worklist
) == Py_NE
)
1141 /* Implement the richcompare method. */
1144 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1147 struct type
*type1
= type_object_to_type (self
);
1148 struct type
*type2
= type_object_to_type (other
);
1149 volatile struct gdb_exception except
;
1151 /* We can only compare ourselves to another Type object, and only
1152 for equality or inequality. */
1153 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
1155 Py_INCREF (Py_NotImplemented
);
1156 return Py_NotImplemented
;
1163 struct bcache
*cache
;
1164 VEC (type_equality_entry_d
) *worklist
= NULL
;
1165 struct type_equality_entry entry
;
1167 cache
= bcache_xmalloc (NULL
, NULL
);
1169 entry
.type1
= type1
;
1170 entry
.type2
= type2
;
1171 VEC_safe_push (type_equality_entry_d
, worklist
, &entry
);
1173 TRY_CATCH (except
, RETURN_MASK_ALL
)
1175 result
= check_types_worklist (&worklist
, cache
);
1177 /* check_types_worklist calls several nested Python helper
1178 functions, some of which can raise a GDB Exception, so we
1179 just check and convert here. If there is a GDB exception, a
1180 comparison is not capable (or trusted), so exit. */
1181 bcache_xfree (cache
);
1182 VEC_free (type_equality_entry_d
, worklist
);
1183 GDB_PY_HANDLE_EXCEPTION (except
);
1193 static const struct objfile_data
*typy_objfile_data_key
;
1196 save_objfile_types (struct objfile
*objfile
, void *datum
)
1198 type_object
*obj
= datum
;
1199 htab_t copied_types
;
1200 struct cleanup
*cleanup
;
1202 /* This prevents another thread from freeing the objects we're
1204 cleanup
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1206 copied_types
= create_copied_types_hash (objfile
);
1210 type_object
*next
= obj
->next
;
1212 htab_empty (copied_types
);
1214 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1222 htab_delete (copied_types
);
1224 do_cleanups (cleanup
);
1228 set_type (type_object
*obj
, struct type
*type
)
1232 if (type
&& TYPE_OBJFILE (type
))
1234 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1236 obj
->next
= objfile_data (objfile
, typy_objfile_data_key
);
1238 obj
->next
->prev
= obj
;
1239 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1246 typy_dealloc (PyObject
*obj
)
1248 type_object
*type
= (type_object
*) obj
;
1251 type
->prev
->next
= type
->next
;
1252 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1254 /* Must reset head of list. */
1255 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1258 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1261 type
->next
->prev
= type
->prev
;
1263 type
->ob_type
->tp_free (type
);
1266 /* Return number of fields ("length" of the field dictionary). */
1269 typy_length (PyObject
*self
)
1271 struct type
*type
= ((type_object
*) self
)->type
;
1273 type
= typy_get_composite (type
);
1277 return TYPE_NFIELDS (type
);
1280 /* Implements boolean evaluation of gdb.Type. Handle this like other
1281 Python objects that don't have a meaningful truth value -- all
1285 typy_nonzero (PyObject
*self
)
1290 /* Return a gdb.Field object for the field named by the argument. */
1293 typy_getitem (PyObject
*self
, PyObject
*key
)
1295 struct type
*type
= ((type_object
*) self
)->type
;
1299 field
= python_string_to_host_string (key
);
1303 /* We want just fields of this type, not of base types, so instead of
1304 using lookup_struct_elt_type, portions of that function are
1307 type
= typy_get_composite (type
);
1311 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1313 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1315 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1317 return convert_field (type
, i
);
1320 PyErr_SetObject (PyExc_KeyError
, key
);
1324 /* Implement the "get" method on the type object. This is the
1325 same as getitem if the key is present, but returns the supplied
1326 default value or None if the key is not found. */
1329 typy_get (PyObject
*self
, PyObject
*args
)
1331 PyObject
*key
, *defval
= Py_None
, *result
;
1333 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1336 result
= typy_getitem (self
, key
);
1340 /* typy_getitem returned error status. If the exception is
1341 KeyError, clear the exception status and return the defval
1342 instead. Otherwise return the exception unchanged. */
1343 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1351 /* Implement the "has_key" method on the type object. */
1354 typy_has_key (PyObject
*self
, PyObject
*args
)
1356 struct type
*type
= ((type_object
*) self
)->type
;
1360 if (!PyArg_ParseTuple (args
, "s", &field
))
1363 /* We want just fields of this type, not of base types, so instead of
1364 using lookup_struct_elt_type, portions of that function are
1367 type
= typy_get_composite (type
);
1371 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1373 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1375 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1381 /* Make an iterator object to iterate over keys, values, or items. */
1384 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1386 typy_iterator_object
*typy_iter_obj
;
1388 /* Check that "self" is a structure or union type. */
1389 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1392 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1393 &type_iterator_object_type
);
1394 if (typy_iter_obj
== NULL
)
1397 typy_iter_obj
->field
= 0;
1398 typy_iter_obj
->kind
= kind
;
1400 typy_iter_obj
->source
= (type_object
*) self
;
1402 return (PyObject
*) typy_iter_obj
;
1405 /* iteritems() method. */
1408 typy_iteritems (PyObject
*self
, PyObject
*args
)
1410 return typy_make_iter (self
, iter_items
);
1413 /* iterkeys() method. */
1416 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1418 return typy_make_iter (self
, iter_keys
);
1421 /* Iterating over the class, same as iterkeys except for the function
1425 typy_iter (PyObject
*self
)
1427 return typy_make_iter (self
, iter_keys
);
1430 /* itervalues() method. */
1433 typy_itervalues (PyObject
*self
, PyObject
*args
)
1435 return typy_make_iter (self
, iter_values
);
1438 /* Return a reference to the type iterator. */
1441 typy_iterator_iter (PyObject
*self
)
1447 /* Return the next field in the iteration through the list of fields
1451 typy_iterator_iternext (PyObject
*self
)
1453 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1454 struct type
*type
= iter_obj
->source
->type
;
1457 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1459 result
= make_fielditem (type
, iter_obj
->field
, iter_obj
->kind
);
1469 typy_iterator_dealloc (PyObject
*obj
)
1471 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1473 Py_DECREF (iter_obj
->source
);
1476 /* Create a new Type referring to TYPE. */
1478 type_to_type_object (struct type
*type
)
1480 type_object
*type_obj
;
1482 type_obj
= PyObject_New (type_object
, &type_object_type
);
1484 set_type (type_obj
, type
);
1486 return (PyObject
*) type_obj
;
1490 type_object_to_type (PyObject
*obj
)
1492 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1494 return ((type_object
*) obj
)->type
;
1499 /* Implementation of gdb.lookup_type. */
1501 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1503 static char *keywords
[] = { "name", "block", NULL
};
1504 const char *type_name
= NULL
;
1505 struct type
*type
= NULL
;
1506 PyObject
*block_obj
= NULL
;
1507 const struct block
*block
= NULL
;
1509 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1510 &type_name
, &block_obj
))
1515 block
= block_object_to_block (block_obj
);
1518 PyErr_SetString (PyExc_RuntimeError
,
1519 _("'block' argument must be a Block."));
1524 type
= typy_lookup_typename (type_name
, block
);
1528 return (PyObject
*) type_to_type_object (type
);
1532 gdbpy_initialize_types (void)
1536 typy_objfile_data_key
1537 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1539 if (PyType_Ready (&type_object_type
) < 0)
1541 if (PyType_Ready (&field_object_type
) < 0)
1543 if (PyType_Ready (&type_iterator_object_type
) < 0)
1546 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1548 if (PyModule_AddIntConstant (gdb_module
,
1549 /* Cast needed for Python 2.4. */
1550 (char *) pyty_codes
[i
].name
,
1551 pyty_codes
[i
].code
) < 0)
1555 Py_INCREF (&type_object_type
);
1556 PyModule_AddObject (gdb_module
, "Type", (PyObject
*) &type_object_type
);
1558 Py_INCREF (&type_iterator_object_type
);
1559 PyModule_AddObject (gdb_module
, "TypeIterator",
1560 (PyObject
*) &type_iterator_object_type
);
1562 Py_INCREF (&field_object_type
);
1563 PyModule_AddObject (gdb_module
, "Field", (PyObject
*) &field_object_type
);
1568 static PyGetSetDef type_object_getset
[] =
1570 { "code", typy_get_code
, NULL
,
1571 "The code for this type.", NULL
},
1572 { "sizeof", typy_get_sizeof
, NULL
,
1573 "The size of this type, in bytes.", NULL
},
1574 { "tag", typy_get_tag
, NULL
,
1575 "The tag name for this type, or None.", NULL
},
1579 static PyMethodDef type_object_methods
[] =
1581 { "array", typy_array
, METH_VARARGS
,
1582 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1583 Return a type which represents an array of objects of this type.\n\
1584 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1585 If LOW_BOUND is omitted, a value of zero is used." },
1586 { "vector", typy_vector
, METH_VARARGS
,
1587 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1588 Return a type which represents a vector of objects of this type.\n\
1589 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1590 If LOW_BOUND is omitted, a value of zero is used.\n\
1591 Vectors differ from arrays in that if the current language has C-style\n\
1592 arrays, vectors don't decay to a pointer to the first element.\n\
1593 They are first class values." },
1594 { "__contains__", typy_has_key
, METH_VARARGS
,
1595 "T.__contains__(k) -> True if T has a field named k, else False" },
1596 { "const", typy_const
, METH_NOARGS
,
1597 "const () -> Type\n\
1598 Return a const variant of this type." },
1599 { "fields", typy_fields
, METH_NOARGS
,
1600 "fields () -> list\n\
1601 Return a list holding all the fields of this type.\n\
1602 Each field is a gdb.Field object." },
1603 { "get", typy_get
, METH_VARARGS
,
1604 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1605 otherwise returns default, if supplied, or None if not." },
1606 { "has_key", typy_has_key
, METH_VARARGS
,
1607 "T.has_key(k) -> True if T has a field named k, else False" },
1608 { "items", typy_items
, METH_NOARGS
,
1609 "items () -> list\n\
1610 Return a list of (name, field) pairs of this type.\n\
1611 Each field is a gdb.Field object." },
1612 { "iteritems", typy_iteritems
, METH_NOARGS
,
1613 "iteritems () -> an iterator over the (name, field)\n\
1614 pairs of this type. Each field is a gdb.Field object." },
1615 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1616 "iterkeys () -> an iterator over the field names of this type." },
1617 { "itervalues", typy_itervalues
, METH_NOARGS
,
1618 "itervalues () -> an iterator over the fields of this type.\n\
1619 Each field is a gdb.Field object." },
1620 { "keys", typy_field_names
, METH_NOARGS
,
1622 Return a list holding all the fields names of this type." },
1623 { "pointer", typy_pointer
, METH_NOARGS
,
1624 "pointer () -> Type\n\
1625 Return a type of pointer to this type." },
1626 { "range", typy_range
, METH_NOARGS
,
1627 "range () -> tuple\n\
1628 Return a tuple containing the lower and upper range for this type."},
1629 { "reference", typy_reference
, METH_NOARGS
,
1630 "reference () -> Type\n\
1631 Return a type of reference to this type." },
1632 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1633 "strip_typedefs () -> Type\n\
1634 Return a type formed by stripping this type of all typedefs."},
1635 { "target", typy_target
, METH_NOARGS
,
1636 "target () -> Type\n\
1637 Return the target type of this type." },
1638 { "template_argument", typy_template_argument
, METH_VARARGS
,
1639 "template_argument (arg, [block]) -> Type\n\
1640 Return the type of a template argument." },
1641 { "unqualified", typy_unqualified
, METH_NOARGS
,
1642 "unqualified () -> Type\n\
1643 Return a variant of this type without const or volatile attributes." },
1644 { "values", typy_values
, METH_NOARGS
,
1645 "values () -> list\n\
1646 Return a list holding all the fields of this type.\n\
1647 Each field is a gdb.Field object." },
1648 { "volatile", typy_volatile
, METH_NOARGS
,
1649 "volatile () -> Type\n\
1650 Return a volatile variant of this type" },
1654 static PyNumberMethods type_object_as_number
= {
1656 NULL
, /* nb_subtract */
1657 NULL
, /* nb_multiply */
1658 NULL
, /* nb_divide */
1659 NULL
, /* nb_remainder */
1660 NULL
, /* nb_divmod */
1661 NULL
, /* nb_power */
1662 NULL
, /* nb_negative */
1663 NULL
, /* nb_positive */
1664 NULL
, /* nb_absolute */
1665 typy_nonzero
, /* nb_nonzero */
1666 NULL
, /* nb_invert */
1667 NULL
, /* nb_lshift */
1668 NULL
, /* nb_rshift */
1672 NULL
, /* nb_coerce */
1675 NULL
, /* nb_float */
1680 static PyMappingMethods typy_mapping
= {
1683 NULL
/* no "set" method */
1686 static PyTypeObject type_object_type
=
1688 PyObject_HEAD_INIT (NULL
)
1690 "gdb.Type", /*tp_name*/
1691 sizeof (type_object
), /*tp_basicsize*/
1693 typy_dealloc
, /*tp_dealloc*/
1699 &type_object_as_number
, /*tp_as_number*/
1700 0, /*tp_as_sequence*/
1701 &typy_mapping
, /*tp_as_mapping*/
1704 typy_str
, /*tp_str*/
1708 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1709 "GDB type object", /* tp_doc */
1710 0, /* tp_traverse */
1712 typy_richcompare
, /* tp_richcompare */
1713 0, /* tp_weaklistoffset */
1714 typy_iter
, /* tp_iter */
1715 0, /* tp_iternext */
1716 type_object_methods
, /* tp_methods */
1718 type_object_getset
, /* tp_getset */
1721 0, /* tp_descr_get */
1722 0, /* tp_descr_set */
1723 0, /* tp_dictoffset */
1729 static PyGetSetDef field_object_getset
[] =
1731 { "__dict__", gdb_py_generic_dict
, NULL
,
1732 "The __dict__ for this field.", &field_object_type
},
1736 static PyTypeObject field_object_type
=
1738 PyObject_HEAD_INIT (NULL
)
1740 "gdb.Field", /*tp_name*/
1741 sizeof (field_object
), /*tp_basicsize*/
1743 field_dealloc
, /*tp_dealloc*/
1750 0, /*tp_as_sequence*/
1751 0, /*tp_as_mapping*/
1758 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1759 "GDB field object", /* tp_doc */
1760 0, /* tp_traverse */
1762 0, /* tp_richcompare */
1763 0, /* tp_weaklistoffset */
1765 0, /* tp_iternext */
1768 field_object_getset
, /* tp_getset */
1771 0, /* tp_descr_get */
1772 0, /* tp_descr_set */
1773 offsetof (field_object
, dict
), /* tp_dictoffset */
1779 static PyTypeObject type_iterator_object_type
= {
1780 PyObject_HEAD_INIT (NULL
)
1782 "gdb.TypeIterator", /*tp_name*/
1783 sizeof (typy_iterator_object
), /*tp_basicsize*/
1785 typy_iterator_dealloc
, /*tp_dealloc*/
1792 0, /*tp_as_sequence*/
1793 0, /*tp_as_mapping*/
1800 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1801 "GDB type iterator object", /*tp_doc */
1804 0, /*tp_richcompare */
1805 0, /*tp_weaklistoffset */
1806 typy_iterator_iter
, /*tp_iter */
1807 typy_iterator_iternext
, /*tp_iternext */