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
*result
= NULL
, *iter
= NULL
;
299 iter
= typy_make_iter (self
, kind
);
303 result
= PySequence_List (iter
);
308 /* Return a sequence of all fields. Each field is a gdb.Field object. */
311 typy_fields (PyObject
*self
, PyObject
*args
)
313 return typy_fields_items (self
, iter_values
);
316 /* Return a sequence of all field names. Each field is a gdb.Field object. */
319 typy_field_names (PyObject
*self
, PyObject
*args
)
321 return typy_fields_items (self
, iter_keys
);
324 /* Return a sequence of all (name, fields) pairs. Each field is a
328 typy_items (PyObject
*self
, PyObject
*args
)
330 return typy_fields_items (self
, iter_items
);
333 /* Return the type's tag, or None. */
335 typy_get_tag (PyObject
*self
, void *closure
)
337 struct type
*type
= ((type_object
*) self
)->type
;
339 if (!TYPE_TAG_NAME (type
))
341 return PyString_FromString (TYPE_TAG_NAME (type
));
344 /* Return the type, stripped of typedefs. */
346 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
348 struct type
*type
= ((type_object
*) self
)->type
;
350 return type_to_type_object (check_typedef (type
));
353 /* Return an array type. */
356 typy_array (PyObject
*self
, PyObject
*args
)
359 PyObject
*n2_obj
= NULL
;
360 struct type
*array
= NULL
;
361 struct type
*type
= ((type_object
*) self
)->type
;
362 volatile struct gdb_exception except
;
364 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
369 if (!PyInt_Check (n2_obj
))
371 PyErr_SetString (PyExc_RuntimeError
,
372 _("Array bound must be an integer"));
376 if (! gdb_py_int_as_long (n2_obj
, &n2
))
387 PyErr_SetString (PyExc_ValueError
,
388 _("Array length must not be negative"));
392 TRY_CATCH (except
, RETURN_MASK_ALL
)
394 array
= lookup_array_range_type (type
, n1
, n2
);
396 GDB_PY_HANDLE_EXCEPTION (except
);
398 return type_to_type_object (array
);
401 /* Return a Type object which represents a pointer to SELF. */
403 typy_pointer (PyObject
*self
, PyObject
*args
)
405 struct type
*type
= ((type_object
*) self
)->type
;
406 volatile struct gdb_exception except
;
408 TRY_CATCH (except
, RETURN_MASK_ALL
)
410 type
= lookup_pointer_type (type
);
412 GDB_PY_HANDLE_EXCEPTION (except
);
414 return type_to_type_object (type
);
417 /* Return the range of a type represented by SELF. The return type is
418 a tuple. The first element of the tuple contains the low bound,
419 while the second element of the tuple contains the high bound. */
421 typy_range (PyObject
*self
, PyObject
*args
)
423 struct type
*type
= ((type_object
*) self
)->type
;
425 PyObject
*low_bound
= NULL
, *high_bound
= NULL
;
426 /* Initialize these to appease GCC warnings. */
427 LONGEST low
= 0, high
= 0;
429 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
430 && TYPE_CODE (type
) != TYPE_CODE_STRING
431 && TYPE_CODE (type
) != TYPE_CODE_RANGE
)
433 PyErr_SetString (PyExc_RuntimeError
,
434 _("This type does not have a range."));
438 switch (TYPE_CODE (type
))
440 case TYPE_CODE_ARRAY
:
441 case TYPE_CODE_STRING
:
442 low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
443 high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
));
445 case TYPE_CODE_RANGE
:
446 low
= TYPE_LOW_BOUND (type
);
447 high
= TYPE_HIGH_BOUND (type
);
451 low_bound
= PyLong_FromLong (low
);
455 high_bound
= PyLong_FromLong (high
);
459 result
= PyTuple_New (2);
463 if (PyTuple_SetItem (result
, 0, low_bound
) != 0)
468 if (PyTuple_SetItem (result
, 1, high_bound
) != 0)
470 Py_DECREF (high_bound
);
477 Py_XDECREF (high_bound
);
478 Py_XDECREF (low_bound
);
482 /* Return a Type object which represents a reference to SELF. */
484 typy_reference (PyObject
*self
, PyObject
*args
)
486 struct type
*type
= ((type_object
*) self
)->type
;
487 volatile struct gdb_exception except
;
489 TRY_CATCH (except
, RETURN_MASK_ALL
)
491 type
= lookup_reference_type (type
);
493 GDB_PY_HANDLE_EXCEPTION (except
);
495 return type_to_type_object (type
);
498 /* Return a Type object which represents the target type of SELF. */
500 typy_target (PyObject
*self
, PyObject
*args
)
502 struct type
*type
= ((type_object
*) self
)->type
;
504 if (!TYPE_TARGET_TYPE (type
))
506 PyErr_SetString (PyExc_RuntimeError
,
507 _("Type does not have a target."));
511 return type_to_type_object (TYPE_TARGET_TYPE (type
));
514 /* Return a const-qualified type variant. */
516 typy_const (PyObject
*self
, PyObject
*args
)
518 struct type
*type
= ((type_object
*) self
)->type
;
519 volatile struct gdb_exception except
;
521 TRY_CATCH (except
, RETURN_MASK_ALL
)
523 type
= make_cv_type (1, 0, type
, NULL
);
525 GDB_PY_HANDLE_EXCEPTION (except
);
527 return type_to_type_object (type
);
530 /* Return a volatile-qualified type variant. */
532 typy_volatile (PyObject
*self
, PyObject
*args
)
534 struct type
*type
= ((type_object
*) self
)->type
;
535 volatile struct gdb_exception except
;
537 TRY_CATCH (except
, RETURN_MASK_ALL
)
539 type
= make_cv_type (0, 1, type
, NULL
);
541 GDB_PY_HANDLE_EXCEPTION (except
);
543 return type_to_type_object (type
);
546 /* Return an unqualified type variant. */
548 typy_unqualified (PyObject
*self
, PyObject
*args
)
550 struct type
*type
= ((type_object
*) self
)->type
;
551 volatile struct gdb_exception except
;
553 TRY_CATCH (except
, RETURN_MASK_ALL
)
555 type
= make_cv_type (0, 0, type
, NULL
);
557 GDB_PY_HANDLE_EXCEPTION (except
);
559 return type_to_type_object (type
);
562 /* Return the size of the type represented by SELF, in bytes. */
564 typy_get_sizeof (PyObject
*self
, void *closure
)
566 struct type
*type
= ((type_object
*) self
)->type
;
567 volatile struct gdb_exception except
;
569 TRY_CATCH (except
, RETURN_MASK_ALL
)
571 check_typedef (type
);
573 /* Ignore exceptions. */
575 return PyLong_FromLong (TYPE_LENGTH (type
));
579 typy_lookup_typename (const char *type_name
, const struct block
*block
)
581 struct type
*type
= NULL
;
582 volatile struct gdb_exception except
;
584 TRY_CATCH (except
, RETURN_MASK_ALL
)
586 if (!strncmp (type_name
, "struct ", 7))
587 type
= lookup_struct (type_name
+ 7, NULL
);
588 else if (!strncmp (type_name
, "union ", 6))
589 type
= lookup_union (type_name
+ 6, NULL
);
590 else if (!strncmp (type_name
, "enum ", 5))
591 type
= lookup_enum (type_name
+ 5, NULL
);
593 type
= lookup_typename (python_language
, python_gdbarch
,
594 type_name
, block
, 0);
596 if (except
.reason
< 0)
598 PyErr_Format (except
.reason
== RETURN_QUIT
599 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
600 "%s", except
.message
);
608 typy_lookup_type (struct demangle_component
*demangled
,
609 const struct block
*block
)
613 enum demangle_component_type demangled_type
;
615 /* Save the type: typy_lookup_type() may (indirectly) overwrite
616 memory pointed by demangled. */
617 demangled_type
= demangled
->type
;
619 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
620 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
621 || demangled_type
== DEMANGLE_COMPONENT_CONST
622 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
624 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
628 switch (demangled_type
)
630 case DEMANGLE_COMPONENT_REFERENCE
:
631 return lookup_reference_type (type
);
632 case DEMANGLE_COMPONENT_POINTER
:
633 return lookup_pointer_type (type
);
634 case DEMANGLE_COMPONENT_CONST
:
635 return make_cv_type (1, 0, type
, NULL
);
636 case DEMANGLE_COMPONENT_VOLATILE
:
637 return make_cv_type (0, 1, type
, NULL
);
641 type_name
= cp_comp_to_string (demangled
, 10);
642 type
= typy_lookup_typename (type_name
, block
);
648 /* This is a helper function for typy_template_argument that is used
649 when the type does not have template symbols attached. It works by
650 parsing the type name. This happens with compilers, like older
651 versions of GCC, that do not emit DW_TAG_template_*. */
654 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
658 struct demangle_component
*demangled
;
659 struct demangle_parse_info
*info
;
661 struct type
*argtype
;
662 struct cleanup
*cleanup
;
664 if (TYPE_NAME (type
) == NULL
)
666 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
670 /* Note -- this is not thread-safe. */
671 info
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
674 PyErr_SetString (PyExc_RuntimeError
, err
);
677 demangled
= info
->tree
;
678 cleanup
= make_cleanup_cp_demangled_name_parse_free (info
);
680 /* Strip off component names. */
681 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
682 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
683 demangled
= demangled
->u
.s_binary
.right
;
685 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
687 do_cleanups (cleanup
);
688 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
692 /* Skip from the template to the arguments. */
693 demangled
= demangled
->u
.s_binary
.right
;
695 for (i
= 0; demangled
&& i
< argno
; ++i
)
696 demangled
= demangled
->u
.s_binary
.right
;
700 do_cleanups (cleanup
);
701 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
706 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
707 do_cleanups (cleanup
);
711 return type_to_type_object (argtype
);
715 typy_template_argument (PyObject
*self
, PyObject
*args
)
718 struct type
*type
= ((type_object
*) self
)->type
;
719 const struct block
*block
= NULL
;
720 PyObject
*block_obj
= NULL
;
722 struct value
*val
= NULL
;
723 volatile struct gdb_exception except
;
725 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
730 block
= block_object_to_block (block_obj
);
733 PyErr_SetString (PyExc_RuntimeError
,
734 _("Second argument must be block."));
739 TRY_CATCH (except
, RETURN_MASK_ALL
)
741 type
= check_typedef (type
);
742 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
743 type
= check_typedef (TYPE_TARGET_TYPE (type
));
745 GDB_PY_HANDLE_EXCEPTION (except
);
747 /* We might not have DW_TAG_template_*, so try to parse the type's
748 name. This is inefficient if we do not have a template type --
749 but that is going to wind up as an error anyhow. */
750 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
751 return typy_legacy_template_argument (type
, block
, argno
);
753 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
755 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
760 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
761 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
762 return type_to_type_object (SYMBOL_TYPE (sym
));
763 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
765 PyErr_Format (PyExc_RuntimeError
,
766 _("Template argument is optimized out"));
770 TRY_CATCH (except
, RETURN_MASK_ALL
)
772 val
= value_of_variable (sym
, block
);
774 GDB_PY_HANDLE_EXCEPTION (except
);
776 return value_to_value_object (val
);
780 typy_str (PyObject
*self
)
782 volatile struct gdb_exception except
;
783 char *thetype
= NULL
;
787 TRY_CATCH (except
, RETURN_MASK_ALL
)
789 struct cleanup
*old_chain
;
792 stb
= mem_fileopen ();
793 old_chain
= make_cleanup_ui_file_delete (stb
);
795 type_print (type_object_to_type (self
), "", stb
, -1);
797 thetype
= ui_file_xstrdup (stb
, &length
);
798 do_cleanups (old_chain
);
800 if (except
.reason
< 0)
803 GDB_PY_HANDLE_EXCEPTION (except
);
806 result
= PyUnicode_Decode (thetype
, length
, host_charset (), NULL
);
812 /* An entry in the type-equality bcache. */
814 typedef struct type_equality_entry
816 struct type
*type1
, *type2
;
817 } type_equality_entry_d
;
819 DEF_VEC_O (type_equality_entry_d
);
821 /* A helper function to compare two strings. Returns 1 if they are
822 the same, 0 otherwise. Handles NULLs properly. */
825 compare_strings (const char *s
, const char *t
)
827 if (s
== NULL
&& t
!= NULL
)
829 else if (s
!= NULL
&& t
== NULL
)
831 else if (s
== NULL
&& t
== NULL
)
833 return strcmp (s
, t
) == 0;
836 /* A helper function for typy_richcompare that checks two types for
837 "deep" equality. Returns Py_EQ if the types are considered the
838 same, Py_NE otherwise. */
841 check_types_equal (struct type
*type1
, struct type
*type2
,
842 VEC (type_equality_entry_d
) **worklist
)
844 CHECK_TYPEDEF (type1
);
845 CHECK_TYPEDEF (type2
);
850 if (TYPE_CODE (type1
) != TYPE_CODE (type2
)
851 || TYPE_LENGTH (type1
) != TYPE_LENGTH (type2
)
852 || TYPE_UNSIGNED (type1
) != TYPE_UNSIGNED (type2
)
853 || TYPE_NOSIGN (type1
) != TYPE_NOSIGN (type2
)
854 || TYPE_VARARGS (type1
) != TYPE_VARARGS (type2
)
855 || TYPE_VECTOR (type1
) != TYPE_VECTOR (type2
)
856 || TYPE_NOTTEXT (type1
) != TYPE_NOTTEXT (type2
)
857 || TYPE_INSTANCE_FLAGS (type1
) != TYPE_INSTANCE_FLAGS (type2
)
858 || TYPE_NFIELDS (type1
) != TYPE_NFIELDS (type2
))
861 if (!compare_strings (TYPE_TAG_NAME (type1
), TYPE_TAG_NAME (type2
)))
863 if (!compare_strings (TYPE_NAME (type1
), TYPE_NAME (type2
)))
866 if (TYPE_CODE (type1
) == TYPE_CODE_RANGE
)
868 if (memcmp (TYPE_RANGE_DATA (type1
), TYPE_RANGE_DATA (type2
),
869 sizeof (*TYPE_RANGE_DATA (type1
))) != 0)
876 for (i
= 0; i
< TYPE_NFIELDS (type1
); ++i
)
878 const struct field
*field1
= &TYPE_FIELD (type1
, i
);
879 const struct field
*field2
= &TYPE_FIELD (type2
, i
);
880 struct type_equality_entry entry
;
882 if (FIELD_ARTIFICIAL (*field1
) != FIELD_ARTIFICIAL (*field2
)
883 || FIELD_BITSIZE (*field1
) != FIELD_BITSIZE (*field2
)
884 || FIELD_LOC_KIND (*field1
) != FIELD_LOC_KIND (*field2
))
886 if (!compare_strings (FIELD_NAME (*field1
), FIELD_NAME (*field2
)))
888 switch (FIELD_LOC_KIND (*field1
))
890 case FIELD_LOC_KIND_BITPOS
:
891 if (FIELD_BITPOS (*field1
) != FIELD_BITPOS (*field2
))
894 case FIELD_LOC_KIND_PHYSADDR
:
895 if (FIELD_STATIC_PHYSADDR (*field1
)
896 != FIELD_STATIC_PHYSADDR (*field2
))
899 case FIELD_LOC_KIND_PHYSNAME
:
900 if (!compare_strings (FIELD_STATIC_PHYSNAME (*field1
),
901 FIELD_STATIC_PHYSNAME (*field2
)))
904 case FIELD_LOC_KIND_DWARF_BLOCK
:
906 struct dwarf2_locexpr_baton
*block1
, *block2
;
908 block1
= FIELD_DWARF_BLOCK (*field1
);
909 block2
= FIELD_DWARF_BLOCK (*field2
);
910 if (block1
->per_cu
!= block2
->per_cu
911 || block1
->size
!= block2
->size
912 || memcmp (block1
->data
, block2
->data
, block1
->size
) != 0)
917 internal_error (__FILE__
, __LINE__
, _("Unsupported field kind "
918 "%d by check_types_equal"),
919 FIELD_LOC_KIND (*field1
));
922 entry
.type1
= FIELD_TYPE (*field1
);
923 entry
.type2
= FIELD_TYPE (*field2
);
924 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
928 if (TYPE_TARGET_TYPE (type1
) != NULL
)
930 struct type_equality_entry entry
;
933 if (TYPE_TARGET_TYPE (type2
) == NULL
)
936 entry
.type1
= TYPE_TARGET_TYPE (type1
);
937 entry
.type2
= TYPE_TARGET_TYPE (type2
);
938 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
940 else if (TYPE_TARGET_TYPE (type2
) != NULL
)
946 /* Check types on a worklist for equality. Returns Py_NE if any pair
947 is not equal, Py_EQ if they are all considered equal. */
950 check_types_worklist (VEC (type_equality_entry_d
) **worklist
,
951 struct bcache
*cache
)
953 while (!VEC_empty (type_equality_entry_d
, *worklist
))
955 struct type_equality_entry entry
;
958 entry
= *VEC_last (type_equality_entry_d
, *worklist
);
959 VEC_pop (type_equality_entry_d
, *worklist
);
961 /* If the type pair has already been visited, we know it is
963 bcache_full (&entry
, sizeof (entry
), cache
, &added
);
967 if (check_types_equal (entry
.type1
, entry
.type2
, worklist
) == Py_NE
)
974 /* Implement the richcompare method. */
977 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
980 struct type
*type1
= type_object_to_type (self
);
981 struct type
*type2
= type_object_to_type (other
);
982 volatile struct gdb_exception except
;
984 /* We can only compare ourselves to another Type object, and only
985 for equality or inequality. */
986 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
988 Py_INCREF (Py_NotImplemented
);
989 return Py_NotImplemented
;
996 struct bcache
*cache
;
997 VEC (type_equality_entry_d
) *worklist
= NULL
;
998 struct type_equality_entry entry
;
1000 cache
= bcache_xmalloc (NULL
, NULL
);
1002 entry
.type1
= type1
;
1003 entry
.type2
= type2
;
1004 VEC_safe_push (type_equality_entry_d
, worklist
, &entry
);
1006 TRY_CATCH (except
, RETURN_MASK_ALL
)
1008 result
= check_types_worklist (&worklist
, cache
);
1010 if (except
.reason
< 0)
1013 bcache_xfree (cache
);
1014 VEC_free (type_equality_entry_d
, worklist
);
1024 static const struct objfile_data
*typy_objfile_data_key
;
1027 save_objfile_types (struct objfile
*objfile
, void *datum
)
1029 type_object
*obj
= datum
;
1030 htab_t copied_types
;
1031 struct cleanup
*cleanup
;
1033 /* This prevents another thread from freeing the objects we're
1035 cleanup
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1037 copied_types
= create_copied_types_hash (objfile
);
1041 type_object
*next
= obj
->next
;
1043 htab_empty (copied_types
);
1045 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1053 htab_delete (copied_types
);
1055 do_cleanups (cleanup
);
1059 set_type (type_object
*obj
, struct type
*type
)
1063 if (type
&& TYPE_OBJFILE (type
))
1065 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1067 obj
->next
= objfile_data (objfile
, typy_objfile_data_key
);
1069 obj
->next
->prev
= obj
;
1070 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1077 typy_dealloc (PyObject
*obj
)
1079 type_object
*type
= (type_object
*) obj
;
1082 type
->prev
->next
= type
->next
;
1083 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1085 /* Must reset head of list. */
1086 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1089 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1092 type
->next
->prev
= type
->prev
;
1094 type
->ob_type
->tp_free (type
);
1097 /* Return number of fields ("length" of the field dictionary). */
1100 typy_length (PyObject
*self
)
1102 struct type
*type
= ((type_object
*) self
)->type
;
1104 return TYPE_NFIELDS (type
);
1107 /* Return a gdb.Field object for the field named by the argument. */
1110 typy_getitem (PyObject
*self
, PyObject
*key
)
1112 struct type
*type
= ((type_object
*) self
)->type
;
1116 field
= python_string_to_host_string (key
);
1120 /* We want just fields of this type, not of base types, so instead of
1121 using lookup_struct_elt_type, portions of that function are
1126 CHECK_TYPEDEF (type
);
1127 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1128 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1130 type
= TYPE_TARGET_TYPE (type
);
1133 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1135 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1137 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1139 return convert_field (type
, i
);
1142 PyErr_SetObject (PyExc_KeyError
, key
);
1146 /* Implement the "get" method on the type object. This is the
1147 same as getitem if the key is present, but returns the supplied
1148 default value or None if the key is not found. */
1151 typy_get (PyObject
*self
, PyObject
*args
)
1153 PyObject
*key
, *defval
= Py_None
, *result
;
1155 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1158 result
= typy_getitem (self
, key
);
1162 /* typy_getitem returned error status. If the exception is
1163 KeyError, clear the exception status and return the defval
1164 instead. Otherwise return the exception unchanged. */
1165 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1173 /* Implement the "has_key" method on the type object. */
1176 typy_has_key (PyObject
*self
, PyObject
*args
)
1178 struct type
*type
= ((type_object
*) self
)->type
;
1182 if (!PyArg_ParseTuple (args
, "s", &field
))
1185 /* We want just fields of this type, not of base types, so instead of
1186 using lookup_struct_elt_type, portions of that function are
1191 CHECK_TYPEDEF (type
);
1192 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1193 && TYPE_CODE (type
) != TYPE_CODE_REF
)
1195 type
= TYPE_TARGET_TYPE (type
);
1198 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1200 char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1202 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1208 /* Make an iterator object to iterate over keys, values, or items. */
1211 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1213 typy_iterator_object
*typy_iter_obj
;
1215 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1216 &type_iterator_object_type
);
1217 if (typy_iter_obj
== NULL
)
1220 typy_iter_obj
->field
= 0;
1221 typy_iter_obj
->kind
= kind
;
1223 typy_iter_obj
->source
= (type_object
*) self
;
1225 return (PyObject
*) typy_iter_obj
;
1228 /* iteritems() method. */
1231 typy_iteritems (PyObject
*self
, PyObject
*args
)
1233 return typy_make_iter (self
, iter_items
);
1236 /* iterkeys() method. */
1239 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1241 return typy_make_iter (self
, iter_keys
);
1244 /* Iterating over the class, same as iterkeys except for the function
1248 typy_iter (PyObject
*self
)
1250 return typy_make_iter (self
, iter_keys
);
1253 /* itervalues() method. */
1256 typy_itervalues (PyObject
*self
, PyObject
*args
)
1258 return typy_make_iter (self
, iter_values
);
1261 /* Return a reference to the type iterator. */
1264 typy_iterator_iter (PyObject
*self
)
1270 /* Return the next field in the iteration through the list of fields
1274 typy_iterator_iternext (PyObject
*self
)
1276 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1277 struct type
*type
= iter_obj
->source
->type
;
1281 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1283 result
= make_fielditem (type
, iter_obj
->field
, iter_obj
->kind
);
1293 typy_iterator_dealloc (PyObject
*obj
)
1295 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1297 Py_DECREF (iter_obj
->source
);
1300 /* Create a new Type referring to TYPE. */
1302 type_to_type_object (struct type
*type
)
1304 type_object
*type_obj
;
1306 type_obj
= PyObject_New (type_object
, &type_object_type
);
1308 set_type (type_obj
, type
);
1310 return (PyObject
*) type_obj
;
1314 type_object_to_type (PyObject
*obj
)
1316 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1318 return ((type_object
*) obj
)->type
;
1323 /* Implementation of gdb.lookup_type. */
1325 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1327 static char *keywords
[] = { "name", "block", NULL
};
1328 const char *type_name
= NULL
;
1329 struct type
*type
= NULL
;
1330 PyObject
*block_obj
= NULL
;
1331 const struct block
*block
= NULL
;
1333 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1334 &type_name
, &block_obj
))
1339 block
= block_object_to_block (block_obj
);
1342 PyErr_SetString (PyExc_RuntimeError
,
1343 _("'block' argument must be a Block."));
1348 type
= typy_lookup_typename (type_name
, block
);
1352 return (PyObject
*) type_to_type_object (type
);
1356 gdbpy_initialize_types (void)
1360 typy_objfile_data_key
1361 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1363 if (PyType_Ready (&type_object_type
) < 0)
1365 if (PyType_Ready (&field_object_type
) < 0)
1367 if (PyType_Ready (&type_iterator_object_type
) < 0)
1370 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1372 if (PyModule_AddIntConstant (gdb_module
,
1373 /* Cast needed for Python 2.4. */
1374 (char *) pyty_codes
[i
].name
,
1375 pyty_codes
[i
].code
) < 0)
1379 Py_INCREF (&type_object_type
);
1380 PyModule_AddObject (gdb_module
, "Type", (PyObject
*) &type_object_type
);
1382 Py_INCREF (&type_iterator_object_type
);
1383 PyModule_AddObject (gdb_module
, "TypeIterator",
1384 (PyObject
*) &type_iterator_object_type
);
1386 Py_INCREF (&field_object_type
);
1387 PyModule_AddObject (gdb_module
, "Field", (PyObject
*) &field_object_type
);
1392 static PyGetSetDef type_object_getset
[] =
1394 { "code", typy_get_code
, NULL
,
1395 "The code for this type.", NULL
},
1396 { "sizeof", typy_get_sizeof
, NULL
,
1397 "The size of this type, in bytes.", NULL
},
1398 { "tag", typy_get_tag
, NULL
,
1399 "The tag name for this type, or None.", NULL
},
1403 static PyMethodDef type_object_methods
[] =
1405 { "array", typy_array
, METH_VARARGS
,
1406 "array (N) -> Type\n\
1407 Return a type which represents an array of N objects of this type." },
1408 { "__contains__", typy_has_key
, METH_VARARGS
,
1409 "T.__contains__(k) -> True if T has a field named k, else False" },
1410 { "const", typy_const
, METH_NOARGS
,
1411 "const () -> Type\n\
1412 Return a const variant of this type." },
1413 { "fields", typy_fields
, METH_NOARGS
,
1414 "fields () -> list\n\
1415 Return a list holding all the fields of this type.\n\
1416 Each field is a gdb.Field object." },
1417 { "get", typy_get
, METH_VARARGS
,
1418 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1419 otherwise returns default, if supplied, or None if not." },
1420 { "has_key", typy_has_key
, METH_VARARGS
,
1421 "T.has_key(k) -> True if T has a field named k, else False" },
1422 { "items", typy_items
, METH_NOARGS
,
1423 "items () -> list\n\
1424 Return a list of (name, field) pairs of this type.\n\
1425 Each field is a gdb.Field object." },
1426 { "iteritems", typy_iteritems
, METH_NOARGS
,
1427 "iteritems () -> an iterator over the (name, field)\n\
1428 pairs of this type. Each field is a gdb.Field object." },
1429 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1430 "iterkeys () -> an iterator over the field names of this type." },
1431 { "itervalues", typy_itervalues
, METH_NOARGS
,
1432 "itervalues () -> an iterator over the fields of this type.\n\
1433 Each field is a gdb.Field object." },
1434 { "keys", typy_field_names
, METH_NOARGS
,
1436 Return a list holding all the fields names of this type." },
1437 { "pointer", typy_pointer
, METH_NOARGS
,
1438 "pointer () -> Type\n\
1439 Return a type of pointer to this type." },
1440 { "range", typy_range
, METH_NOARGS
,
1441 "range () -> tuple\n\
1442 Return a tuple containing the lower and upper range for this type."},
1443 { "reference", typy_reference
, METH_NOARGS
,
1444 "reference () -> Type\n\
1445 Return a type of reference to this type." },
1446 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1447 "strip_typedefs () -> Type\n\
1448 Return a type formed by stripping this type of all typedefs."},
1449 { "target", typy_target
, METH_NOARGS
,
1450 "target () -> Type\n\
1451 Return the target type of this type." },
1452 { "template_argument", typy_template_argument
, METH_VARARGS
,
1453 "template_argument (arg, [block]) -> Type\n\
1454 Return the type of a template argument." },
1455 { "unqualified", typy_unqualified
, METH_NOARGS
,
1456 "unqualified () -> Type\n\
1457 Return a variant of this type without const or volatile attributes." },
1458 { "values", typy_fields
, METH_NOARGS
,
1459 "values () -> list\n\
1460 Return a list holding all the fields of this type.\n\
1461 Each field is a gdb.Field object." },
1462 { "volatile", typy_volatile
, METH_NOARGS
,
1463 "volatile () -> Type\n\
1464 Return a volatile variant of this type" },
1468 static PyMappingMethods typy_mapping
= {
1471 NULL
/* no "set" method */
1474 static PyTypeObject type_object_type
=
1476 PyObject_HEAD_INIT (NULL
)
1478 "gdb.Type", /*tp_name*/
1479 sizeof (type_object
), /*tp_basicsize*/
1481 typy_dealloc
, /*tp_dealloc*/
1488 0, /*tp_as_sequence*/
1489 &typy_mapping
, /*tp_as_mapping*/
1492 typy_str
, /*tp_str*/
1496 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1497 "GDB type object", /* tp_doc */
1498 0, /* tp_traverse */
1500 typy_richcompare
, /* tp_richcompare */
1501 0, /* tp_weaklistoffset */
1502 typy_iter
, /* tp_iter */
1503 0, /* tp_iternext */
1504 type_object_methods
, /* tp_methods */
1506 type_object_getset
, /* tp_getset */
1509 0, /* tp_descr_get */
1510 0, /* tp_descr_set */
1511 0, /* tp_dictoffset */
1517 static PyTypeObject field_object_type
=
1519 PyObject_HEAD_INIT (NULL
)
1521 "gdb.Field", /*tp_name*/
1522 sizeof (field_object
), /*tp_basicsize*/
1524 field_dealloc
, /*tp_dealloc*/
1531 0, /*tp_as_sequence*/
1532 0, /*tp_as_mapping*/
1539 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1540 "GDB field object", /* tp_doc */
1541 0, /* tp_traverse */
1543 0, /* tp_richcompare */
1544 0, /* tp_weaklistoffset */
1546 0, /* tp_iternext */
1552 0, /* tp_descr_get */
1553 0, /* tp_descr_set */
1554 offsetof (field_object
, dict
), /* tp_dictoffset */
1560 static PyTypeObject type_iterator_object_type
= {
1561 PyObject_HEAD_INIT (NULL
)
1563 "gdb.TypeIterator", /*tp_name*/
1564 sizeof (typy_iterator_object
), /*tp_basicsize*/
1566 typy_iterator_dealloc
, /*tp_dealloc*/
1573 0, /*tp_as_sequence*/
1574 0, /*tp_as_mapping*/
1581 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1582 "GDB type iterator object", /*tp_doc */
1585 0, /*tp_richcompare */
1586 0, /*tp_weaklistoffset */
1587 typy_iterator_iter
, /*tp_iter */
1588 typy_iterator_iternext
, /*tp_iternext */