1 /* Python interface to types.
3 Copyright (C) 2008-2013 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"
33 #include "typeprint.h"
35 typedef struct pyty_type_object
40 /* If a Type object is associated with an objfile, it is kept on a
41 doubly-linked list, rooted in the objfile. This lets us copy the
42 underlying struct type when the objfile is deleted. */
43 struct pyty_type_object
*prev
;
44 struct pyty_type_object
*next
;
47 static PyTypeObject type_object_type
48 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("type_object");
51 typedef struct pyty_field_object
55 /* Dictionary holding our attributes. */
59 static PyTypeObject field_object_type
60 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("field_object");
62 /* A type iterator object. */
65 /* The current field index. */
68 enum gdbpy_iter_kind kind
;
69 /* Pointer back to the original source type object. */
70 struct pyty_type_object
*source
;
71 } typy_iterator_object
;
73 static PyTypeObject type_iterator_object_type
74 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("typy_iterator_object");
76 /* This is used to initialize various gdb.TYPE_ constants. */
85 /* Forward declarations. */
86 static PyObject
*typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
);
88 #define ENTRY(X) { X, #X }
90 static struct pyty_code pyty_codes
[] =
92 ENTRY (TYPE_CODE_BITSTRING
),
93 ENTRY (TYPE_CODE_PTR
),
94 ENTRY (TYPE_CODE_ARRAY
),
95 ENTRY (TYPE_CODE_STRUCT
),
96 ENTRY (TYPE_CODE_UNION
),
97 ENTRY (TYPE_CODE_ENUM
),
98 ENTRY (TYPE_CODE_FLAGS
),
99 ENTRY (TYPE_CODE_FUNC
),
100 ENTRY (TYPE_CODE_INT
),
101 ENTRY (TYPE_CODE_FLT
),
102 ENTRY (TYPE_CODE_VOID
),
103 ENTRY (TYPE_CODE_SET
),
104 ENTRY (TYPE_CODE_RANGE
),
105 ENTRY (TYPE_CODE_STRING
),
106 ENTRY (TYPE_CODE_ERROR
),
107 ENTRY (TYPE_CODE_METHOD
),
108 ENTRY (TYPE_CODE_METHODPTR
),
109 ENTRY (TYPE_CODE_MEMBERPTR
),
110 ENTRY (TYPE_CODE_REF
),
111 ENTRY (TYPE_CODE_CHAR
),
112 ENTRY (TYPE_CODE_BOOL
),
113 ENTRY (TYPE_CODE_COMPLEX
),
114 ENTRY (TYPE_CODE_TYPEDEF
),
115 ENTRY (TYPE_CODE_NAMESPACE
),
116 ENTRY (TYPE_CODE_DECFLOAT
),
117 ENTRY (TYPE_CODE_INTERNAL_FUNCTION
),
118 { TYPE_CODE_UNDEF
, NULL
}
124 field_dealloc (PyObject
*obj
)
126 field_object
*f
= (field_object
*) obj
;
128 Py_XDECREF (f
->dict
);
129 Py_TYPE (obj
)->tp_free (obj
);
135 field_object
*result
= PyObject_New (field_object
, &field_object_type
);
139 result
->dict
= PyDict_New ();
146 return (PyObject
*) result
;
151 /* Return the code for this type. */
153 typy_get_code (PyObject
*self
, void *closure
)
155 struct type
*type
= ((type_object
*) self
)->type
;
157 return PyInt_FromLong (TYPE_CODE (type
));
160 /* Helper function for typy_fields which converts a single field to a
161 gdb.Field object. Returns NULL on error. */
164 convert_field (struct type
*type
, int field
)
166 PyObject
*result
= field_new ();
172 if (!field_is_static (&TYPE_FIELD (type
, field
)))
174 const char *attrstring
;
176 if (TYPE_CODE (type
) == TYPE_CODE_ENUM
)
178 arg
= gdb_py_long_from_longest (TYPE_FIELD_ENUMVAL (type
, field
));
179 attrstring
= "enumval";
183 arg
= gdb_py_long_from_longest (TYPE_FIELD_BITPOS (type
, field
));
184 attrstring
= "bitpos";
190 /* At least python-2.4 had the second parameter non-const. */
191 if (PyObject_SetAttrString (result
, (char *) attrstring
, arg
) < 0)
196 if (TYPE_FIELD_NAME (type
, field
))
197 arg
= PyString_FromString (TYPE_FIELD_NAME (type
, field
));
205 if (PyObject_SetAttrString (result
, "name", arg
) < 0)
209 arg
= TYPE_FIELD_ARTIFICIAL (type
, field
) ? Py_True
: Py_False
;
211 if (PyObject_SetAttrString (result
, "artificial", arg
) < 0)
215 if (TYPE_CODE (type
) == TYPE_CODE_CLASS
)
216 arg
= field
< TYPE_N_BASECLASSES (type
) ? Py_True
: Py_False
;
220 if (PyObject_SetAttrString (result
, "is_base_class", arg
) < 0)
224 arg
= PyLong_FromLong (TYPE_FIELD_BITSIZE (type
, field
));
227 if (PyObject_SetAttrString (result
, "bitsize", arg
) < 0)
231 /* A field can have a NULL type in some situations. */
232 if (TYPE_FIELD_TYPE (type
, field
) == NULL
)
238 arg
= type_to_type_object (TYPE_FIELD_TYPE (type
, field
));
241 if (PyObject_SetAttrString (result
, "type", arg
) < 0)
254 /* Helper function to return the name of a field, as a gdb.Field object.
255 If the field doesn't have a name, None is returned. */
258 field_name (struct type
*type
, int field
)
262 if (TYPE_FIELD_NAME (type
, field
))
263 result
= PyString_FromString (TYPE_FIELD_NAME (type
, field
));
272 /* Helper function for Type standard mapping methods. Returns a
273 Python object for field i of the type. "kind" specifies what to
274 return: the name of the field, a gdb.Field object corresponding to
275 the field, or a tuple consisting of field name and gdb.Field
279 make_fielditem (struct type
*type
, int i
, enum gdbpy_iter_kind kind
)
281 PyObject
*item
= NULL
, *key
= NULL
, *value
= NULL
;
286 key
= field_name (type
, i
);
289 value
= convert_field (type
, i
);
292 item
= PyTuple_New (2);
295 PyTuple_SET_ITEM (item
, 0, key
);
296 PyTuple_SET_ITEM (item
, 1, value
);
299 item
= field_name (type
, i
);
302 item
= convert_field (type
, i
);
314 /* Return a sequence of all field names, fields, or (name, field) pairs.
315 Each field is a gdb.Field object. */
318 typy_fields_items (PyObject
*self
, enum gdbpy_iter_kind kind
)
320 PyObject
*py_type
= self
;
321 PyObject
*result
= NULL
, *iter
= NULL
;
322 volatile struct gdb_exception except
;
323 struct type
*type
= ((type_object
*) py_type
)->type
;
324 struct type
*checked_type
= type
;
326 TRY_CATCH (except
, RETURN_MASK_ALL
)
328 CHECK_TYPEDEF (checked_type
);
330 GDB_PY_HANDLE_EXCEPTION (except
);
332 if (checked_type
!= type
)
333 py_type
= type_to_type_object (checked_type
);
334 iter
= typy_make_iter (py_type
, kind
);
335 if (checked_type
!= type
)
337 /* Need to wrap this in braces because Py_DECREF isn't wrapped
338 in a do{}while(0). */
343 result
= PySequence_List (iter
);
350 /* Return a sequence of all fields. Each field is a gdb.Field object. */
353 typy_values (PyObject
*self
, PyObject
*args
)
355 return typy_fields_items (self
, iter_values
);
358 /* Return a sequence of all fields. Each field is a gdb.Field object.
359 This method is similar to typy_values, except where the supplied
360 gdb.Type is an array, in which case it returns a list of one entry
361 which is a gdb.Field object for a range (the array bounds). */
364 typy_fields (PyObject
*self
, PyObject
*args
)
366 struct type
*type
= ((type_object
*) self
)->type
;
369 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
370 return typy_fields_items (self
, iter_values
);
372 /* Array type. Handle this as a special case because the common
373 machinery wants struct or union or enum types. Build a list of
374 one entry which is the range for the array. */
375 r
= convert_field (type
, 0);
379 rl
= Py_BuildValue ("[O]", r
);
388 /* Return a sequence of all field names. Each field is a gdb.Field object. */
391 typy_field_names (PyObject
*self
, PyObject
*args
)
393 return typy_fields_items (self
, iter_keys
);
396 /* Return a sequence of all (name, fields) pairs. Each field is a
400 typy_items (PyObject
*self
, PyObject
*args
)
402 return typy_fields_items (self
, iter_items
);
405 /* Return the type's tag, or None. */
407 typy_get_tag (PyObject
*self
, void *closure
)
409 struct type
*type
= ((type_object
*) self
)->type
;
411 if (!TYPE_TAG_NAME (type
))
413 return PyString_FromString (TYPE_TAG_NAME (type
));
416 /* Return the type, stripped of typedefs. */
418 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
420 struct type
*type
= ((type_object
*) self
)->type
;
421 volatile struct gdb_exception except
;
423 TRY_CATCH (except
, RETURN_MASK_ALL
)
425 type
= check_typedef (type
);
427 GDB_PY_HANDLE_EXCEPTION (except
);
429 return type_to_type_object (type
);
432 /* Strip typedefs and pointers/reference from a type. Then check that
433 it is a struct, union, or enum type. If not, raise TypeError. */
436 typy_get_composite (struct type
*type
)
438 volatile struct gdb_exception except
;
442 TRY_CATCH (except
, RETURN_MASK_ALL
)
444 CHECK_TYPEDEF (type
);
446 /* Don't use GDB_PY_HANDLE_EXCEPTION here because that returns
447 a (NULL) pointer of the wrong type. */
448 if (except
.reason
< 0)
450 gdbpy_convert_exception (except
);
454 if (TYPE_CODE (type
) != TYPE_CODE_PTR
455 && TYPE_CODE (type
) != TYPE_CODE_REF
)
457 type
= TYPE_TARGET_TYPE (type
);
460 /* If this is not a struct, union, or enum type, raise TypeError
462 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
463 && TYPE_CODE (type
) != TYPE_CODE_UNION
464 && TYPE_CODE (type
) != TYPE_CODE_ENUM
)
466 PyErr_SetString (PyExc_TypeError
,
467 "Type is not a structure, union, or enum type.");
474 /* Helper for typy_array and typy_vector. */
477 typy_array_1 (PyObject
*self
, PyObject
*args
, int is_vector
)
480 PyObject
*n2_obj
= NULL
;
481 struct type
*array
= NULL
;
482 struct type
*type
= ((type_object
*) self
)->type
;
483 volatile struct gdb_exception except
;
485 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
490 if (!PyInt_Check (n2_obj
))
492 PyErr_SetString (PyExc_RuntimeError
,
493 _("Array bound must be an integer"));
497 if (! gdb_py_int_as_long (n2_obj
, &n2
))
508 PyErr_SetString (PyExc_ValueError
,
509 _("Array length must not be negative"));
513 TRY_CATCH (except
, RETURN_MASK_ALL
)
515 array
= lookup_array_range_type (type
, n1
, n2
);
517 make_vector_type (array
);
519 GDB_PY_HANDLE_EXCEPTION (except
);
521 return type_to_type_object (array
);
524 /* Return an array type. */
527 typy_array (PyObject
*self
, PyObject
*args
)
529 return typy_array_1 (self
, args
, 0);
532 /* Return a vector type. */
535 typy_vector (PyObject
*self
, PyObject
*args
)
537 return typy_array_1 (self
, args
, 1);
540 /* Return a Type object which represents a pointer to SELF. */
542 typy_pointer (PyObject
*self
, PyObject
*args
)
544 struct type
*type
= ((type_object
*) self
)->type
;
545 volatile struct gdb_exception except
;
547 TRY_CATCH (except
, RETURN_MASK_ALL
)
549 type
= lookup_pointer_type (type
);
551 GDB_PY_HANDLE_EXCEPTION (except
);
553 return type_to_type_object (type
);
556 /* Return the range of a type represented by SELF. The return type is
557 a tuple. The first element of the tuple contains the low bound,
558 while the second element of the tuple contains the high bound. */
560 typy_range (PyObject
*self
, PyObject
*args
)
562 struct type
*type
= ((type_object
*) self
)->type
;
564 PyObject
*low_bound
= NULL
, *high_bound
= NULL
;
565 /* Initialize these to appease GCC warnings. */
566 LONGEST low
= 0, high
= 0;
568 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
569 && TYPE_CODE (type
) != TYPE_CODE_STRING
570 && TYPE_CODE (type
) != TYPE_CODE_RANGE
)
572 PyErr_SetString (PyExc_RuntimeError
,
573 _("This type does not have a range."));
577 switch (TYPE_CODE (type
))
579 case TYPE_CODE_ARRAY
:
580 case TYPE_CODE_STRING
:
581 low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
582 high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
));
584 case TYPE_CODE_RANGE
:
585 low
= TYPE_LOW_BOUND (type
);
586 high
= TYPE_HIGH_BOUND (type
);
590 low_bound
= PyLong_FromLong (low
);
594 high_bound
= PyLong_FromLong (high
);
598 result
= PyTuple_New (2);
602 if (PyTuple_SetItem (result
, 0, low_bound
) != 0)
607 if (PyTuple_SetItem (result
, 1, high_bound
) != 0)
609 Py_DECREF (high_bound
);
616 Py_XDECREF (high_bound
);
617 Py_XDECREF (low_bound
);
621 /* Return a Type object which represents a reference to SELF. */
623 typy_reference (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
= lookup_reference_type (type
);
632 GDB_PY_HANDLE_EXCEPTION (except
);
634 return type_to_type_object (type
);
637 /* Return a Type object which represents the target type of SELF. */
639 typy_target (PyObject
*self
, PyObject
*args
)
641 struct type
*type
= ((type_object
*) self
)->type
;
643 if (!TYPE_TARGET_TYPE (type
))
645 PyErr_SetString (PyExc_RuntimeError
,
646 _("Type does not have a target."));
650 return type_to_type_object (TYPE_TARGET_TYPE (type
));
653 /* Return a const-qualified type variant. */
655 typy_const (PyObject
*self
, PyObject
*args
)
657 struct type
*type
= ((type_object
*) self
)->type
;
658 volatile struct gdb_exception except
;
660 TRY_CATCH (except
, RETURN_MASK_ALL
)
662 type
= make_cv_type (1, 0, type
, NULL
);
664 GDB_PY_HANDLE_EXCEPTION (except
);
666 return type_to_type_object (type
);
669 /* Return a volatile-qualified type variant. */
671 typy_volatile (PyObject
*self
, PyObject
*args
)
673 struct type
*type
= ((type_object
*) self
)->type
;
674 volatile struct gdb_exception except
;
676 TRY_CATCH (except
, RETURN_MASK_ALL
)
678 type
= make_cv_type (0, 1, type
, NULL
);
680 GDB_PY_HANDLE_EXCEPTION (except
);
682 return type_to_type_object (type
);
685 /* Return an unqualified type variant. */
687 typy_unqualified (PyObject
*self
, PyObject
*args
)
689 struct type
*type
= ((type_object
*) self
)->type
;
690 volatile struct gdb_exception except
;
692 TRY_CATCH (except
, RETURN_MASK_ALL
)
694 type
= make_cv_type (0, 0, type
, NULL
);
696 GDB_PY_HANDLE_EXCEPTION (except
);
698 return type_to_type_object (type
);
701 /* Return the size of the type represented by SELF, in bytes. */
703 typy_get_sizeof (PyObject
*self
, void *closure
)
705 struct type
*type
= ((type_object
*) self
)->type
;
706 volatile struct gdb_exception except
;
708 TRY_CATCH (except
, RETURN_MASK_ALL
)
710 check_typedef (type
);
712 /* Ignore exceptions. */
714 return gdb_py_long_from_longest (TYPE_LENGTH (type
));
718 typy_lookup_typename (const char *type_name
, const struct block
*block
)
720 struct type
*type
= NULL
;
721 volatile struct gdb_exception except
;
723 TRY_CATCH (except
, RETURN_MASK_ALL
)
725 if (!strncmp (type_name
, "struct ", 7))
726 type
= lookup_struct (type_name
+ 7, NULL
);
727 else if (!strncmp (type_name
, "union ", 6))
728 type
= lookup_union (type_name
+ 6, NULL
);
729 else if (!strncmp (type_name
, "enum ", 5))
730 type
= lookup_enum (type_name
+ 5, NULL
);
732 type
= lookup_typename (python_language
, python_gdbarch
,
733 type_name
, block
, 0);
735 if (except
.reason
< 0)
737 gdbpy_convert_exception (except
);
745 typy_lookup_type (struct demangle_component
*demangled
,
746 const struct block
*block
)
748 struct type
*type
, *rtype
= NULL
;
749 char *type_name
= NULL
;
750 enum demangle_component_type demangled_type
;
751 volatile struct gdb_exception except
;
753 /* Save the type: typy_lookup_type() may (indirectly) overwrite
754 memory pointed by demangled. */
755 demangled_type
= demangled
->type
;
757 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
758 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
759 || demangled_type
== DEMANGLE_COMPONENT_CONST
760 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
762 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
766 TRY_CATCH (except
, RETURN_MASK_ALL
)
768 /* If the demangled_type matches with one of the types
769 below, run the corresponding function and save the type
770 to return later. We cannot just return here as we are in
771 an exception handler. */
772 switch (demangled_type
)
774 case DEMANGLE_COMPONENT_REFERENCE
:
775 rtype
= lookup_reference_type (type
);
777 case DEMANGLE_COMPONENT_POINTER
:
778 rtype
= lookup_pointer_type (type
);
780 case DEMANGLE_COMPONENT_CONST
:
781 rtype
= make_cv_type (1, 0, type
, NULL
);
783 case DEMANGLE_COMPONENT_VOLATILE
:
784 rtype
= make_cv_type (0, 1, type
, NULL
);
788 if (except
.reason
< 0)
790 gdbpy_convert_exception (except
);
795 /* If we have a type from the switch statement above, just return
800 /* We don't have a type, so lookup the type. */
801 type_name
= cp_comp_to_string (demangled
, 10);
802 type
= typy_lookup_typename (type_name
, block
);
808 /* This is a helper function for typy_template_argument that is used
809 when the type does not have template symbols attached. It works by
810 parsing the type name. This happens with compilers, like older
811 versions of GCC, that do not emit DW_TAG_template_*. */
814 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
818 struct demangle_component
*demangled
;
819 struct demangle_parse_info
*info
= NULL
;
821 struct type
*argtype
;
822 struct cleanup
*cleanup
;
823 volatile struct gdb_exception except
;
825 if (TYPE_NAME (type
) == NULL
)
827 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
831 TRY_CATCH (except
, RETURN_MASK_ALL
)
833 /* Note -- this is not thread-safe. */
834 info
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
836 GDB_PY_HANDLE_EXCEPTION (except
);
840 PyErr_SetString (PyExc_RuntimeError
, err
);
843 demangled
= info
->tree
;
844 cleanup
= make_cleanup_cp_demangled_name_parse_free (info
);
846 /* Strip off component names. */
847 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
848 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
849 demangled
= demangled
->u
.s_binary
.right
;
851 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
853 do_cleanups (cleanup
);
854 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
858 /* Skip from the template to the arguments. */
859 demangled
= demangled
->u
.s_binary
.right
;
861 for (i
= 0; demangled
&& i
< argno
; ++i
)
862 demangled
= demangled
->u
.s_binary
.right
;
866 do_cleanups (cleanup
);
867 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
872 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
873 do_cleanups (cleanup
);
877 return type_to_type_object (argtype
);
881 typy_template_argument (PyObject
*self
, PyObject
*args
)
884 struct type
*type
= ((type_object
*) self
)->type
;
885 const struct block
*block
= NULL
;
886 PyObject
*block_obj
= NULL
;
888 struct value
*val
= NULL
;
889 volatile struct gdb_exception except
;
891 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
896 block
= block_object_to_block (block_obj
);
899 PyErr_SetString (PyExc_RuntimeError
,
900 _("Second argument must be block."));
905 TRY_CATCH (except
, RETURN_MASK_ALL
)
907 type
= check_typedef (type
);
908 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
909 type
= check_typedef (TYPE_TARGET_TYPE (type
));
911 GDB_PY_HANDLE_EXCEPTION (except
);
913 /* We might not have DW_TAG_template_*, so try to parse the type's
914 name. This is inefficient if we do not have a template type --
915 but that is going to wind up as an error anyhow. */
916 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
917 return typy_legacy_template_argument (type
, block
, argno
);
919 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
921 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
926 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
927 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
928 return type_to_type_object (SYMBOL_TYPE (sym
));
929 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
931 PyErr_Format (PyExc_RuntimeError
,
932 _("Template argument is optimized out"));
936 TRY_CATCH (except
, RETURN_MASK_ALL
)
938 val
= value_of_variable (sym
, block
);
940 GDB_PY_HANDLE_EXCEPTION (except
);
942 return value_to_value_object (val
);
946 typy_str (PyObject
*self
)
948 volatile struct gdb_exception except
;
949 char *thetype
= NULL
;
953 TRY_CATCH (except
, RETURN_MASK_ALL
)
955 struct cleanup
*old_chain
;
958 stb
= mem_fileopen ();
959 old_chain
= make_cleanup_ui_file_delete (stb
);
961 LA_PRINT_TYPE (type_object_to_type (self
), "", stb
, -1, 0,
962 &type_print_raw_options
);
964 thetype
= ui_file_xstrdup (stb
, &length
);
965 do_cleanups (old_chain
);
967 if (except
.reason
< 0)
970 GDB_PY_HANDLE_EXCEPTION (except
);
973 result
= PyUnicode_Decode (thetype
, length
, host_charset (), NULL
);
979 /* An entry in the type-equality bcache. */
981 typedef struct type_equality_entry
983 struct type
*type1
, *type2
;
984 } type_equality_entry_d
;
986 DEF_VEC_O (type_equality_entry_d
);
988 /* A helper function to compare two strings. Returns 1 if they are
989 the same, 0 otherwise. Handles NULLs properly. */
992 compare_maybe_null_strings (const char *s
, const char *t
)
994 if (s
== NULL
&& t
!= NULL
)
996 else if (s
!= NULL
&& t
== NULL
)
998 else if (s
== NULL
&& t
== NULL
)
1000 return strcmp (s
, t
) == 0;
1003 /* A helper function for typy_richcompare that checks two types for
1004 "deep" equality. Returns Py_EQ if the types are considered the
1005 same, Py_NE otherwise. */
1008 check_types_equal (struct type
*type1
, struct type
*type2
,
1009 VEC (type_equality_entry_d
) **worklist
)
1011 CHECK_TYPEDEF (type1
);
1012 CHECK_TYPEDEF (type2
);
1017 if (TYPE_CODE (type1
) != TYPE_CODE (type2
)
1018 || TYPE_LENGTH (type1
) != TYPE_LENGTH (type2
)
1019 || TYPE_UNSIGNED (type1
) != TYPE_UNSIGNED (type2
)
1020 || TYPE_NOSIGN (type1
) != TYPE_NOSIGN (type2
)
1021 || TYPE_VARARGS (type1
) != TYPE_VARARGS (type2
)
1022 || TYPE_VECTOR (type1
) != TYPE_VECTOR (type2
)
1023 || TYPE_NOTTEXT (type1
) != TYPE_NOTTEXT (type2
)
1024 || TYPE_INSTANCE_FLAGS (type1
) != TYPE_INSTANCE_FLAGS (type2
)
1025 || TYPE_NFIELDS (type1
) != TYPE_NFIELDS (type2
))
1028 if (!compare_maybe_null_strings (TYPE_TAG_NAME (type1
),
1029 TYPE_TAG_NAME (type2
)))
1031 if (!compare_maybe_null_strings (TYPE_NAME (type1
), TYPE_NAME (type2
)))
1034 if (TYPE_CODE (type1
) == TYPE_CODE_RANGE
)
1036 if (memcmp (TYPE_RANGE_DATA (type1
), TYPE_RANGE_DATA (type2
),
1037 sizeof (*TYPE_RANGE_DATA (type1
))) != 0)
1044 for (i
= 0; i
< TYPE_NFIELDS (type1
); ++i
)
1046 const struct field
*field1
= &TYPE_FIELD (type1
, i
);
1047 const struct field
*field2
= &TYPE_FIELD (type2
, i
);
1048 struct type_equality_entry entry
;
1050 if (FIELD_ARTIFICIAL (*field1
) != FIELD_ARTIFICIAL (*field2
)
1051 || FIELD_BITSIZE (*field1
) != FIELD_BITSIZE (*field2
)
1052 || FIELD_LOC_KIND (*field1
) != FIELD_LOC_KIND (*field2
))
1054 if (!compare_maybe_null_strings (FIELD_NAME (*field1
),
1055 FIELD_NAME (*field2
)))
1057 switch (FIELD_LOC_KIND (*field1
))
1059 case FIELD_LOC_KIND_BITPOS
:
1060 if (FIELD_BITPOS (*field1
) != FIELD_BITPOS (*field2
))
1063 case FIELD_LOC_KIND_ENUMVAL
:
1064 if (FIELD_ENUMVAL (*field1
) != FIELD_ENUMVAL (*field2
))
1067 case FIELD_LOC_KIND_PHYSADDR
:
1068 if (FIELD_STATIC_PHYSADDR (*field1
)
1069 != FIELD_STATIC_PHYSADDR (*field2
))
1072 case FIELD_LOC_KIND_PHYSNAME
:
1073 if (!compare_maybe_null_strings (FIELD_STATIC_PHYSNAME (*field1
),
1074 FIELD_STATIC_PHYSNAME (*field2
)))
1077 case FIELD_LOC_KIND_DWARF_BLOCK
:
1079 struct dwarf2_locexpr_baton
*block1
, *block2
;
1081 block1
= FIELD_DWARF_BLOCK (*field1
);
1082 block2
= FIELD_DWARF_BLOCK (*field2
);
1083 if (block1
->per_cu
!= block2
->per_cu
1084 || block1
->size
!= block2
->size
1085 || memcmp (block1
->data
, block2
->data
, block1
->size
) != 0)
1090 internal_error (__FILE__
, __LINE__
, _("Unsupported field kind "
1091 "%d by check_types_equal"),
1092 FIELD_LOC_KIND (*field1
));
1095 entry
.type1
= FIELD_TYPE (*field1
);
1096 entry
.type2
= FIELD_TYPE (*field2
);
1097 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
1101 if (TYPE_TARGET_TYPE (type1
) != NULL
)
1103 struct type_equality_entry entry
;
1105 if (TYPE_TARGET_TYPE (type2
) == NULL
)
1108 entry
.type1
= TYPE_TARGET_TYPE (type1
);
1109 entry
.type2
= TYPE_TARGET_TYPE (type2
);
1110 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
1112 else if (TYPE_TARGET_TYPE (type2
) != NULL
)
1118 /* Check types on a worklist for equality. Returns Py_NE if any pair
1119 is not equal, Py_EQ if they are all considered equal. */
1122 check_types_worklist (VEC (type_equality_entry_d
) **worklist
,
1123 struct bcache
*cache
)
1125 while (!VEC_empty (type_equality_entry_d
, *worklist
))
1127 struct type_equality_entry entry
;
1130 entry
= *VEC_last (type_equality_entry_d
, *worklist
);
1131 VEC_pop (type_equality_entry_d
, *worklist
);
1133 /* If the type pair has already been visited, we know it is
1135 bcache_full (&entry
, sizeof (entry
), cache
, &added
);
1139 if (check_types_equal (entry
.type1
, entry
.type2
, worklist
) == Py_NE
)
1146 /* Implement the richcompare method. */
1149 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1152 struct type
*type1
= type_object_to_type (self
);
1153 struct type
*type2
= type_object_to_type (other
);
1154 volatile struct gdb_exception except
;
1156 /* We can only compare ourselves to another Type object, and only
1157 for equality or inequality. */
1158 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
1160 Py_INCREF (Py_NotImplemented
);
1161 return Py_NotImplemented
;
1168 struct bcache
*cache
;
1169 VEC (type_equality_entry_d
) *worklist
= NULL
;
1170 struct type_equality_entry entry
;
1172 cache
= bcache_xmalloc (NULL
, NULL
);
1174 entry
.type1
= type1
;
1175 entry
.type2
= type2
;
1176 VEC_safe_push (type_equality_entry_d
, worklist
, &entry
);
1178 TRY_CATCH (except
, RETURN_MASK_ALL
)
1180 result
= check_types_worklist (&worklist
, cache
);
1182 /* check_types_worklist calls several nested Python helper
1183 functions, some of which can raise a GDB Exception, so we
1184 just check and convert here. If there is a GDB exception, a
1185 comparison is not capable (or trusted), so exit. */
1186 bcache_xfree (cache
);
1187 VEC_free (type_equality_entry_d
, worklist
);
1188 GDB_PY_HANDLE_EXCEPTION (except
);
1198 static const struct objfile_data
*typy_objfile_data_key
;
1201 save_objfile_types (struct objfile
*objfile
, void *datum
)
1203 type_object
*obj
= datum
;
1204 htab_t copied_types
;
1205 struct cleanup
*cleanup
;
1207 /* This prevents another thread from freeing the objects we're
1209 cleanup
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1211 copied_types
= create_copied_types_hash (objfile
);
1215 type_object
*next
= obj
->next
;
1217 htab_empty (copied_types
);
1219 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1227 htab_delete (copied_types
);
1229 do_cleanups (cleanup
);
1233 set_type (type_object
*obj
, struct type
*type
)
1237 if (type
&& TYPE_OBJFILE (type
))
1239 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1241 obj
->next
= objfile_data (objfile
, typy_objfile_data_key
);
1243 obj
->next
->prev
= obj
;
1244 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1251 typy_dealloc (PyObject
*obj
)
1253 type_object
*type
= (type_object
*) obj
;
1256 type
->prev
->next
= type
->next
;
1257 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1259 /* Must reset head of list. */
1260 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1263 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1266 type
->next
->prev
= type
->prev
;
1268 Py_TYPE (type
)->tp_free (type
);
1271 /* Return number of fields ("length" of the field dictionary). */
1274 typy_length (PyObject
*self
)
1276 struct type
*type
= ((type_object
*) self
)->type
;
1278 type
= typy_get_composite (type
);
1282 return TYPE_NFIELDS (type
);
1285 /* Implements boolean evaluation of gdb.Type. Handle this like other
1286 Python objects that don't have a meaningful truth value -- all
1290 typy_nonzero (PyObject
*self
)
1295 /* Return a gdb.Field object for the field named by the argument. */
1298 typy_getitem (PyObject
*self
, PyObject
*key
)
1300 struct type
*type
= ((type_object
*) self
)->type
;
1304 field
= python_string_to_host_string (key
);
1308 /* We want just fields of this type, not of base types, so instead of
1309 using lookup_struct_elt_type, portions of that function are
1312 type
= typy_get_composite (type
);
1316 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1318 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1320 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1322 return convert_field (type
, i
);
1325 PyErr_SetObject (PyExc_KeyError
, key
);
1329 /* Implement the "get" method on the type object. This is the
1330 same as getitem if the key is present, but returns the supplied
1331 default value or None if the key is not found. */
1334 typy_get (PyObject
*self
, PyObject
*args
)
1336 PyObject
*key
, *defval
= Py_None
, *result
;
1338 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1341 result
= typy_getitem (self
, key
);
1345 /* typy_getitem returned error status. If the exception is
1346 KeyError, clear the exception status and return the defval
1347 instead. Otherwise return the exception unchanged. */
1348 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1356 /* Implement the "has_key" method on the type object. */
1359 typy_has_key (PyObject
*self
, PyObject
*args
)
1361 struct type
*type
= ((type_object
*) self
)->type
;
1365 if (!PyArg_ParseTuple (args
, "s", &field
))
1368 /* We want just fields of this type, not of base types, so instead of
1369 using lookup_struct_elt_type, portions of that function are
1372 type
= typy_get_composite (type
);
1376 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1378 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1380 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1386 /* Make an iterator object to iterate over keys, values, or items. */
1389 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1391 typy_iterator_object
*typy_iter_obj
;
1393 /* Check that "self" is a structure or union type. */
1394 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1397 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1398 &type_iterator_object_type
);
1399 if (typy_iter_obj
== NULL
)
1402 typy_iter_obj
->field
= 0;
1403 typy_iter_obj
->kind
= kind
;
1405 typy_iter_obj
->source
= (type_object
*) self
;
1407 return (PyObject
*) typy_iter_obj
;
1410 /* iteritems() method. */
1413 typy_iteritems (PyObject
*self
, PyObject
*args
)
1415 return typy_make_iter (self
, iter_items
);
1418 /* iterkeys() method. */
1421 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1423 return typy_make_iter (self
, iter_keys
);
1426 /* Iterating over the class, same as iterkeys except for the function
1430 typy_iter (PyObject
*self
)
1432 return typy_make_iter (self
, iter_keys
);
1435 /* itervalues() method. */
1438 typy_itervalues (PyObject
*self
, PyObject
*args
)
1440 return typy_make_iter (self
, iter_values
);
1443 /* Return a reference to the type iterator. */
1446 typy_iterator_iter (PyObject
*self
)
1452 /* Return the next field in the iteration through the list of fields
1456 typy_iterator_iternext (PyObject
*self
)
1458 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1459 struct type
*type
= iter_obj
->source
->type
;
1462 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1464 result
= make_fielditem (type
, iter_obj
->field
, iter_obj
->kind
);
1474 typy_iterator_dealloc (PyObject
*obj
)
1476 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1478 Py_DECREF (iter_obj
->source
);
1481 /* Create a new Type referring to TYPE. */
1483 type_to_type_object (struct type
*type
)
1485 type_object
*type_obj
;
1487 type_obj
= PyObject_New (type_object
, &type_object_type
);
1489 set_type (type_obj
, type
);
1491 return (PyObject
*) type_obj
;
1495 type_object_to_type (PyObject
*obj
)
1497 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1499 return ((type_object
*) obj
)->type
;
1504 /* Implementation of gdb.lookup_type. */
1506 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1508 static char *keywords
[] = { "name", "block", NULL
};
1509 const char *type_name
= NULL
;
1510 struct type
*type
= NULL
;
1511 PyObject
*block_obj
= NULL
;
1512 const struct block
*block
= NULL
;
1514 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1515 &type_name
, &block_obj
))
1520 block
= block_object_to_block (block_obj
);
1523 PyErr_SetString (PyExc_RuntimeError
,
1524 _("'block' argument must be a Block."));
1529 type
= typy_lookup_typename (type_name
, block
);
1533 return (PyObject
*) type_to_type_object (type
);
1537 gdbpy_initialize_types (void)
1541 typy_objfile_data_key
1542 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1544 if (PyType_Ready (&type_object_type
) < 0)
1546 if (PyType_Ready (&field_object_type
) < 0)
1548 if (PyType_Ready (&type_iterator_object_type
) < 0)
1551 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1553 if (PyModule_AddIntConstant (gdb_module
,
1554 /* Cast needed for Python 2.4. */
1555 (char *) pyty_codes
[i
].name
,
1556 pyty_codes
[i
].code
) < 0)
1560 Py_INCREF (&type_object_type
);
1561 PyModule_AddObject (gdb_module
, "Type", (PyObject
*) &type_object_type
);
1563 Py_INCREF (&type_iterator_object_type
);
1564 PyModule_AddObject (gdb_module
, "TypeIterator",
1565 (PyObject
*) &type_iterator_object_type
);
1567 Py_INCREF (&field_object_type
);
1568 PyModule_AddObject (gdb_module
, "Field", (PyObject
*) &field_object_type
);
1573 static PyGetSetDef type_object_getset
[] =
1575 { "code", typy_get_code
, NULL
,
1576 "The code for this type.", NULL
},
1577 { "sizeof", typy_get_sizeof
, NULL
,
1578 "The size of this type, in bytes.", NULL
},
1579 { "tag", typy_get_tag
, NULL
,
1580 "The tag name for this type, or None.", NULL
},
1584 static PyMethodDef type_object_methods
[] =
1586 { "array", typy_array
, METH_VARARGS
,
1587 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1588 Return a type which represents an array 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." },
1591 { "vector", typy_vector
, METH_VARARGS
,
1592 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1593 Return a type which represents a vector of objects of this type.\n\
1594 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1595 If LOW_BOUND is omitted, a value of zero is used.\n\
1596 Vectors differ from arrays in that if the current language has C-style\n\
1597 arrays, vectors don't decay to a pointer to the first element.\n\
1598 They are first class values." },
1599 { "__contains__", typy_has_key
, METH_VARARGS
,
1600 "T.__contains__(k) -> True if T has a field named k, else False" },
1601 { "const", typy_const
, METH_NOARGS
,
1602 "const () -> Type\n\
1603 Return a const variant of this type." },
1604 { "fields", typy_fields
, METH_NOARGS
,
1605 "fields () -> list\n\
1606 Return a list holding all the fields of this type.\n\
1607 Each field is a gdb.Field object." },
1608 { "get", typy_get
, METH_VARARGS
,
1609 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1610 otherwise returns default, if supplied, or None if not." },
1611 { "has_key", typy_has_key
, METH_VARARGS
,
1612 "T.has_key(k) -> True if T has a field named k, else False" },
1613 { "items", typy_items
, METH_NOARGS
,
1614 "items () -> list\n\
1615 Return a list of (name, field) pairs of this type.\n\
1616 Each field is a gdb.Field object." },
1617 { "iteritems", typy_iteritems
, METH_NOARGS
,
1618 "iteritems () -> an iterator over the (name, field)\n\
1619 pairs of this type. Each field is a gdb.Field object." },
1620 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1621 "iterkeys () -> an iterator over the field names of this type." },
1622 { "itervalues", typy_itervalues
, METH_NOARGS
,
1623 "itervalues () -> an iterator over the fields of this type.\n\
1624 Each field is a gdb.Field object." },
1625 { "keys", typy_field_names
, METH_NOARGS
,
1627 Return a list holding all the fields names of this type." },
1628 { "pointer", typy_pointer
, METH_NOARGS
,
1629 "pointer () -> Type\n\
1630 Return a type of pointer to this type." },
1631 { "range", typy_range
, METH_NOARGS
,
1632 "range () -> tuple\n\
1633 Return a tuple containing the lower and upper range for this type."},
1634 { "reference", typy_reference
, METH_NOARGS
,
1635 "reference () -> Type\n\
1636 Return a type of reference to this type." },
1637 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1638 "strip_typedefs () -> Type\n\
1639 Return a type formed by stripping this type of all typedefs."},
1640 { "target", typy_target
, METH_NOARGS
,
1641 "target () -> Type\n\
1642 Return the target type of this type." },
1643 { "template_argument", typy_template_argument
, METH_VARARGS
,
1644 "template_argument (arg, [block]) -> Type\n\
1645 Return the type of a template argument." },
1646 { "unqualified", typy_unqualified
, METH_NOARGS
,
1647 "unqualified () -> Type\n\
1648 Return a variant of this type without const or volatile attributes." },
1649 { "values", typy_values
, METH_NOARGS
,
1650 "values () -> list\n\
1651 Return a list holding all the fields of this type.\n\
1652 Each field is a gdb.Field object." },
1653 { "volatile", typy_volatile
, METH_NOARGS
,
1654 "volatile () -> Type\n\
1655 Return a volatile variant of this type" },
1659 static PyNumberMethods type_object_as_number
= {
1661 NULL
, /* nb_subtract */
1662 NULL
, /* nb_multiply */
1664 NULL
, /* nb_divide */
1666 NULL
, /* nb_remainder */
1667 NULL
, /* nb_divmod */
1668 NULL
, /* nb_power */
1669 NULL
, /* nb_negative */
1670 NULL
, /* nb_positive */
1671 NULL
, /* nb_absolute */
1672 typy_nonzero
, /* nb_nonzero */
1673 NULL
, /* nb_invert */
1674 NULL
, /* nb_lshift */
1675 NULL
, /* nb_rshift */
1681 NULL
, /* reserved */
1683 NULL
, /* nb_coerce */
1687 NULL
, /* nb_float */
1694 static PyMappingMethods typy_mapping
= {
1697 NULL
/* no "set" method */
1700 static PyTypeObject type_object_type
=
1702 PyVarObject_HEAD_INIT (NULL
, 0)
1703 "gdb.Type", /*tp_name*/
1704 sizeof (type_object
), /*tp_basicsize*/
1706 typy_dealloc
, /*tp_dealloc*/
1712 &type_object_as_number
, /*tp_as_number*/
1713 0, /*tp_as_sequence*/
1714 &typy_mapping
, /*tp_as_mapping*/
1717 typy_str
, /*tp_str*/
1721 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1722 "GDB type object", /* tp_doc */
1723 0, /* tp_traverse */
1725 typy_richcompare
, /* tp_richcompare */
1726 0, /* tp_weaklistoffset */
1727 typy_iter
, /* tp_iter */
1728 0, /* tp_iternext */
1729 type_object_methods
, /* tp_methods */
1731 type_object_getset
, /* tp_getset */
1734 0, /* tp_descr_get */
1735 0, /* tp_descr_set */
1736 0, /* tp_dictoffset */
1742 static PyGetSetDef field_object_getset
[] =
1744 { "__dict__", gdb_py_generic_dict
, NULL
,
1745 "The __dict__ for this field.", &field_object_type
},
1749 static PyTypeObject field_object_type
=
1751 PyVarObject_HEAD_INIT (NULL
, 0)
1752 "gdb.Field", /*tp_name*/
1753 sizeof (field_object
), /*tp_basicsize*/
1755 field_dealloc
, /*tp_dealloc*/
1762 0, /*tp_as_sequence*/
1763 0, /*tp_as_mapping*/
1770 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1771 "GDB field object", /* tp_doc */
1772 0, /* tp_traverse */
1774 0, /* tp_richcompare */
1775 0, /* tp_weaklistoffset */
1777 0, /* tp_iternext */
1780 field_object_getset
, /* tp_getset */
1783 0, /* tp_descr_get */
1784 0, /* tp_descr_set */
1785 offsetof (field_object
, dict
), /* tp_dictoffset */
1791 static PyTypeObject type_iterator_object_type
= {
1792 PyVarObject_HEAD_INIT (NULL
, 0)
1793 "gdb.TypeIterator", /*tp_name*/
1794 sizeof (typy_iterator_object
), /*tp_basicsize*/
1796 typy_iterator_dealloc
, /*tp_dealloc*/
1803 0, /*tp_as_sequence*/
1804 0, /*tp_as_mapping*/
1811 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1812 "GDB type iterator object", /*tp_doc */
1815 0, /*tp_richcompare */
1816 0, /*tp_weaklistoffset */
1817 typy_iterator_iter
, /*tp_iter */
1818 typy_iterator_iternext
, /*tp_iternext */