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_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 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)
191 if (TYPE_FIELD_NAME (type
, field
))
192 arg
= PyString_FromString (TYPE_FIELD_NAME (type
, field
));
200 if (PyObject_SetAttrString (result
, "name", arg
) < 0)
203 arg
= TYPE_FIELD_ARTIFICIAL (type
, field
) ? Py_True
: Py_False
;
205 if (PyObject_SetAttrString (result
, "artificial", arg
) < 0)
208 if (TYPE_CODE (type
) == TYPE_CODE_CLASS
)
209 arg
= field
< TYPE_N_BASECLASSES (type
) ? Py_True
: Py_False
;
213 if (PyObject_SetAttrString (result
, "is_base_class", arg
) < 0)
216 arg
= PyLong_FromLong (TYPE_FIELD_BITSIZE (type
, field
));
219 if (PyObject_SetAttrString (result
, "bitsize", arg
) < 0)
222 /* A field can have a NULL type in some situations. */
223 if (TYPE_FIELD_TYPE (type
, field
) == NULL
)
229 arg
= type_to_type_object (TYPE_FIELD_TYPE (type
, field
));
232 if (PyObject_SetAttrString (result
, "type", arg
) < 0)
244 /* Helper function to return the name of a field, as a gdb.Field object.
245 If the field doesn't have a name, None is returned. */
248 field_name (struct type
*type
, int field
)
252 if (TYPE_FIELD_NAME (type
, field
))
253 result
= PyString_FromString (TYPE_FIELD_NAME (type
, field
));
262 /* Helper function for Type standard mapping methods. Returns a
263 Python object for field i of the type. "kind" specifies what to
264 return: the name of the field, a gdb.Field object corresponding to
265 the field, or a tuple consisting of field name and gdb.Field
269 make_fielditem (struct type
*type
, int i
, enum gdbpy_iter_kind kind
)
271 PyObject
*item
= NULL
, *key
= NULL
, *value
= NULL
;
276 key
= field_name (type
, i
);
279 value
= convert_field (type
, i
);
282 item
= PyTuple_New (2);
285 PyTuple_SET_ITEM (item
, 0, key
);
286 PyTuple_SET_ITEM (item
, 1, value
);
289 item
= field_name (type
, i
);
292 item
= convert_field (type
, i
);
304 /* Return a sequence of all field names, fields, or (name, field) pairs.
305 Each field is a gdb.Field object. */
308 typy_fields_items (PyObject
*self
, enum gdbpy_iter_kind kind
)
310 PyObject
*py_type
= self
;
311 PyObject
*result
= NULL
, *iter
= NULL
;
312 volatile struct gdb_exception except
;
313 struct type
*type
= ((type_object
*) py_type
)->type
;
314 struct type
*checked_type
= type
;
316 TRY_CATCH (except
, RETURN_MASK_ALL
)
318 CHECK_TYPEDEF (checked_type
);
320 GDB_PY_HANDLE_EXCEPTION (except
);
322 if (checked_type
!= type
)
323 py_type
= type_to_type_object (checked_type
);
324 iter
= typy_make_iter (py_type
, kind
);
325 if (checked_type
!= type
)
327 /* Need to wrap this in braces because Py_DECREF isn't wrapped
328 in a do{}while(0). */
333 result
= PySequence_List (iter
);
340 /* Return a sequence of all fields. Each field is a gdb.Field object. */
343 typy_values (PyObject
*self
, PyObject
*args
)
345 return typy_fields_items (self
, iter_values
);
348 /* Return a sequence of all fields. Each field is a gdb.Field object.
349 This method is similar to typy_values, except where the supplied
350 gdb.Type is an array, in which case it returns a list of one entry
351 which is a gdb.Field object for a range (the array bounds). */
354 typy_fields (PyObject
*self
, PyObject
*args
)
356 struct type
*type
= ((type_object
*) self
)->type
;
359 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
360 return typy_fields_items (self
, iter_values
);
362 /* Array type. Handle this as a special case because the common
363 machinery wants struct or union or enum types. Build a list of
364 one entry which is the range for the array. */
365 r
= convert_field (type
, 0);
369 rl
= Py_BuildValue ("[O]", r
);
378 /* Return a sequence of all field names. Each field is a gdb.Field object. */
381 typy_field_names (PyObject
*self
, PyObject
*args
)
383 return typy_fields_items (self
, iter_keys
);
386 /* Return a sequence of all (name, fields) pairs. Each field is a
390 typy_items (PyObject
*self
, PyObject
*args
)
392 return typy_fields_items (self
, iter_items
);
395 /* Return the type's tag, or None. */
397 typy_get_tag (PyObject
*self
, void *closure
)
399 struct type
*type
= ((type_object
*) self
)->type
;
401 if (!TYPE_TAG_NAME (type
))
403 return PyString_FromString (TYPE_TAG_NAME (type
));
406 /* Return the type, stripped of typedefs. */
408 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
410 struct type
*type
= ((type_object
*) self
)->type
;
411 volatile struct gdb_exception except
;
413 TRY_CATCH (except
, RETURN_MASK_ALL
)
415 type
= check_typedef (type
);
417 GDB_PY_HANDLE_EXCEPTION (except
);
419 return type_to_type_object (check_typedef (type
));
422 /* Strip typedefs and pointers/reference from a type. Then check that
423 it is a struct, union, or enum type. If not, raise TypeError. */
426 typy_get_composite (struct type
*type
)
428 volatile struct gdb_exception except
;
432 TRY_CATCH (except
, RETURN_MASK_ALL
)
434 CHECK_TYPEDEF (type
);
436 /* Don't use GDB_PY_HANDLE_EXCEPTION here because that returns
437 a (NULL) pointer of the wrong type. */
438 if (except
.reason
< 0)
440 gdbpy_convert_exception (except
);
444 if (TYPE_CODE (type
) != TYPE_CODE_PTR
445 && TYPE_CODE (type
) != TYPE_CODE_REF
)
447 type
= TYPE_TARGET_TYPE (type
);
450 /* If this is not a struct, union, or enum type, raise TypeError
452 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
453 && TYPE_CODE (type
) != TYPE_CODE_UNION
454 && TYPE_CODE (type
) != TYPE_CODE_ENUM
)
456 PyErr_SetString (PyExc_TypeError
,
457 "Type is not a structure, union, or enum type.");
464 /* Helper for typy_array and typy_vector. */
467 typy_array_1 (PyObject
*self
, PyObject
*args
, int is_vector
)
470 PyObject
*n2_obj
= NULL
;
471 struct type
*array
= NULL
;
472 struct type
*type
= ((type_object
*) self
)->type
;
473 volatile struct gdb_exception except
;
475 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
480 if (!PyInt_Check (n2_obj
))
482 PyErr_SetString (PyExc_RuntimeError
,
483 _("Array bound must be an integer"));
487 if (! gdb_py_int_as_long (n2_obj
, &n2
))
498 PyErr_SetString (PyExc_ValueError
,
499 _("Array length must not be negative"));
503 TRY_CATCH (except
, RETURN_MASK_ALL
)
505 array
= lookup_array_range_type (type
, n1
, n2
);
507 make_vector_type (array
);
509 GDB_PY_HANDLE_EXCEPTION (except
);
511 return type_to_type_object (array
);
514 /* Return an array type. */
517 typy_array (PyObject
*self
, PyObject
*args
)
519 return typy_array_1 (self
, args
, 0);
522 /* Return a vector type. */
525 typy_vector (PyObject
*self
, PyObject
*args
)
527 return typy_array_1 (self
, args
, 1);
530 /* Return a Type object which represents a pointer to SELF. */
532 typy_pointer (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
= lookup_pointer_type (type
);
541 GDB_PY_HANDLE_EXCEPTION (except
);
543 return type_to_type_object (type
);
546 /* Return the range of a type represented by SELF. The return type is
547 a tuple. The first element of the tuple contains the low bound,
548 while the second element of the tuple contains the high bound. */
550 typy_range (PyObject
*self
, PyObject
*args
)
552 struct type
*type
= ((type_object
*) self
)->type
;
554 PyObject
*low_bound
= NULL
, *high_bound
= NULL
;
555 /* Initialize these to appease GCC warnings. */
556 LONGEST low
= 0, high
= 0;
558 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
559 && TYPE_CODE (type
) != TYPE_CODE_STRING
560 && TYPE_CODE (type
) != TYPE_CODE_RANGE
)
562 PyErr_SetString (PyExc_RuntimeError
,
563 _("This type does not have a range."));
567 switch (TYPE_CODE (type
))
569 case TYPE_CODE_ARRAY
:
570 case TYPE_CODE_STRING
:
571 low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
572 high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
));
574 case TYPE_CODE_RANGE
:
575 low
= TYPE_LOW_BOUND (type
);
576 high
= TYPE_HIGH_BOUND (type
);
580 low_bound
= PyLong_FromLong (low
);
584 high_bound
= PyLong_FromLong (high
);
588 result
= PyTuple_New (2);
592 if (PyTuple_SetItem (result
, 0, low_bound
) != 0)
597 if (PyTuple_SetItem (result
, 1, high_bound
) != 0)
599 Py_DECREF (high_bound
);
606 Py_XDECREF (high_bound
);
607 Py_XDECREF (low_bound
);
611 /* Return a Type object which represents a reference to SELF. */
613 typy_reference (PyObject
*self
, PyObject
*args
)
615 struct type
*type
= ((type_object
*) self
)->type
;
616 volatile struct gdb_exception except
;
618 TRY_CATCH (except
, RETURN_MASK_ALL
)
620 type
= lookup_reference_type (type
);
622 GDB_PY_HANDLE_EXCEPTION (except
);
624 return type_to_type_object (type
);
627 /* Return a Type object which represents the target type of SELF. */
629 typy_target (PyObject
*self
, PyObject
*args
)
631 struct type
*type
= ((type_object
*) self
)->type
;
633 if (!TYPE_TARGET_TYPE (type
))
635 PyErr_SetString (PyExc_RuntimeError
,
636 _("Type does not have a target."));
640 return type_to_type_object (TYPE_TARGET_TYPE (type
));
643 /* Return a const-qualified type variant. */
645 typy_const (PyObject
*self
, PyObject
*args
)
647 struct type
*type
= ((type_object
*) self
)->type
;
648 volatile struct gdb_exception except
;
650 TRY_CATCH (except
, RETURN_MASK_ALL
)
652 type
= make_cv_type (1, 0, type
, NULL
);
654 GDB_PY_HANDLE_EXCEPTION (except
);
656 return type_to_type_object (type
);
659 /* Return a volatile-qualified type variant. */
661 typy_volatile (PyObject
*self
, PyObject
*args
)
663 struct type
*type
= ((type_object
*) self
)->type
;
664 volatile struct gdb_exception except
;
666 TRY_CATCH (except
, RETURN_MASK_ALL
)
668 type
= make_cv_type (0, 1, type
, NULL
);
670 GDB_PY_HANDLE_EXCEPTION (except
);
672 return type_to_type_object (type
);
675 /* Return an unqualified type variant. */
677 typy_unqualified (PyObject
*self
, PyObject
*args
)
679 struct type
*type
= ((type_object
*) self
)->type
;
680 volatile struct gdb_exception except
;
682 TRY_CATCH (except
, RETURN_MASK_ALL
)
684 type
= make_cv_type (0, 0, type
, NULL
);
686 GDB_PY_HANDLE_EXCEPTION (except
);
688 return type_to_type_object (type
);
691 /* Return the size of the type represented by SELF, in bytes. */
693 typy_get_sizeof (PyObject
*self
, void *closure
)
695 struct type
*type
= ((type_object
*) self
)->type
;
696 volatile struct gdb_exception except
;
698 TRY_CATCH (except
, RETURN_MASK_ALL
)
700 check_typedef (type
);
702 /* Ignore exceptions. */
704 return gdb_py_long_from_longest (TYPE_LENGTH (type
));
708 typy_lookup_typename (const char *type_name
, const struct block
*block
)
710 struct type
*type
= NULL
;
711 volatile struct gdb_exception except
;
713 TRY_CATCH (except
, RETURN_MASK_ALL
)
715 if (!strncmp (type_name
, "struct ", 7))
716 type
= lookup_struct (type_name
+ 7, NULL
);
717 else if (!strncmp (type_name
, "union ", 6))
718 type
= lookup_union (type_name
+ 6, NULL
);
719 else if (!strncmp (type_name
, "enum ", 5))
720 type
= lookup_enum (type_name
+ 5, NULL
);
722 type
= lookup_typename (python_language
, python_gdbarch
,
723 type_name
, block
, 0);
725 if (except
.reason
< 0)
727 gdbpy_convert_exception (except
);
735 typy_lookup_type (struct demangle_component
*demangled
,
736 const struct block
*block
)
738 struct type
*type
, *rtype
= NULL
;
739 char *type_name
= NULL
;
740 enum demangle_component_type demangled_type
;
741 volatile struct gdb_exception except
;
743 /* Save the type: typy_lookup_type() may (indirectly) overwrite
744 memory pointed by demangled. */
745 demangled_type
= demangled
->type
;
747 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
748 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
749 || demangled_type
== DEMANGLE_COMPONENT_CONST
750 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
752 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
756 TRY_CATCH (except
, RETURN_MASK_ALL
)
758 /* If the demangled_type matches with one of the types
759 below, run the corresponding function and save the type
760 to return later. We cannot just return here as we are in
761 an exception handler. */
762 switch (demangled_type
)
764 case DEMANGLE_COMPONENT_REFERENCE
:
765 rtype
= lookup_reference_type (type
);
767 case DEMANGLE_COMPONENT_POINTER
:
768 rtype
= lookup_pointer_type (type
);
770 case DEMANGLE_COMPONENT_CONST
:
771 rtype
= make_cv_type (1, 0, type
, NULL
);
773 case DEMANGLE_COMPONENT_VOLATILE
:
774 rtype
= make_cv_type (0, 1, type
, NULL
);
778 if (except
.reason
< 0)
780 gdbpy_convert_exception (except
);
785 /* If we have a type from the switch statement above, just return
790 /* We don't have a type, so lookup the type. */
791 type_name
= cp_comp_to_string (demangled
, 10);
792 type
= typy_lookup_typename (type_name
, block
);
798 /* This is a helper function for typy_template_argument that is used
799 when the type does not have template symbols attached. It works by
800 parsing the type name. This happens with compilers, like older
801 versions of GCC, that do not emit DW_TAG_template_*. */
804 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
808 struct demangle_component
*demangled
;
809 struct demangle_parse_info
*info
= NULL
;
811 struct type
*argtype
;
812 struct cleanup
*cleanup
;
813 volatile struct gdb_exception except
;
815 if (TYPE_NAME (type
) == NULL
)
817 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
821 TRY_CATCH (except
, RETURN_MASK_ALL
)
823 /* Note -- this is not thread-safe. */
824 info
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
826 GDB_PY_HANDLE_EXCEPTION (except
);
830 PyErr_SetString (PyExc_RuntimeError
, err
);
833 demangled
= info
->tree
;
834 cleanup
= make_cleanup_cp_demangled_name_parse_free (info
);
836 /* Strip off component names. */
837 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
838 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
839 demangled
= demangled
->u
.s_binary
.right
;
841 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
843 do_cleanups (cleanup
);
844 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
848 /* Skip from the template to the arguments. */
849 demangled
= demangled
->u
.s_binary
.right
;
851 for (i
= 0; demangled
&& i
< argno
; ++i
)
852 demangled
= demangled
->u
.s_binary
.right
;
856 do_cleanups (cleanup
);
857 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
862 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
863 do_cleanups (cleanup
);
867 return type_to_type_object (argtype
);
871 typy_template_argument (PyObject
*self
, PyObject
*args
)
874 struct type
*type
= ((type_object
*) self
)->type
;
875 const struct block
*block
= NULL
;
876 PyObject
*block_obj
= NULL
;
878 struct value
*val
= NULL
;
879 volatile struct gdb_exception except
;
881 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
886 block
= block_object_to_block (block_obj
);
889 PyErr_SetString (PyExc_RuntimeError
,
890 _("Second argument must be block."));
895 TRY_CATCH (except
, RETURN_MASK_ALL
)
897 type
= check_typedef (type
);
898 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
899 type
= check_typedef (TYPE_TARGET_TYPE (type
));
901 GDB_PY_HANDLE_EXCEPTION (except
);
903 /* We might not have DW_TAG_template_*, so try to parse the type's
904 name. This is inefficient if we do not have a template type --
905 but that is going to wind up as an error anyhow. */
906 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
907 return typy_legacy_template_argument (type
, block
, argno
);
909 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
911 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
916 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
917 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
918 return type_to_type_object (SYMBOL_TYPE (sym
));
919 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
921 PyErr_Format (PyExc_RuntimeError
,
922 _("Template argument is optimized out"));
926 TRY_CATCH (except
, RETURN_MASK_ALL
)
928 val
= value_of_variable (sym
, block
);
930 GDB_PY_HANDLE_EXCEPTION (except
);
932 return value_to_value_object (val
);
936 typy_str (PyObject
*self
)
938 volatile struct gdb_exception except
;
939 char *thetype
= NULL
;
943 TRY_CATCH (except
, RETURN_MASK_ALL
)
945 struct cleanup
*old_chain
;
948 stb
= mem_fileopen ();
949 old_chain
= make_cleanup_ui_file_delete (stb
);
951 type_print (type_object_to_type (self
), "", stb
, -1);
953 thetype
= ui_file_xstrdup (stb
, &length
);
954 do_cleanups (old_chain
);
956 if (except
.reason
< 0)
959 GDB_PY_HANDLE_EXCEPTION (except
);
962 result
= PyUnicode_Decode (thetype
, length
, host_charset (), NULL
);
968 /* An entry in the type-equality bcache. */
970 typedef struct type_equality_entry
972 struct type
*type1
, *type2
;
973 } type_equality_entry_d
;
975 DEF_VEC_O (type_equality_entry_d
);
977 /* A helper function to compare two strings. Returns 1 if they are
978 the same, 0 otherwise. Handles NULLs properly. */
981 compare_maybe_null_strings (const char *s
, const char *t
)
983 if (s
== NULL
&& t
!= NULL
)
985 else if (s
!= NULL
&& t
== NULL
)
987 else if (s
== NULL
&& t
== NULL
)
989 return strcmp (s
, t
) == 0;
992 /* A helper function for typy_richcompare that checks two types for
993 "deep" equality. Returns Py_EQ if the types are considered the
994 same, Py_NE otherwise. */
997 check_types_equal (struct type
*type1
, struct type
*type2
,
998 VEC (type_equality_entry_d
) **worklist
)
1000 CHECK_TYPEDEF (type1
);
1001 CHECK_TYPEDEF (type2
);
1006 if (TYPE_CODE (type1
) != TYPE_CODE (type2
)
1007 || TYPE_LENGTH (type1
) != TYPE_LENGTH (type2
)
1008 || TYPE_UNSIGNED (type1
) != TYPE_UNSIGNED (type2
)
1009 || TYPE_NOSIGN (type1
) != TYPE_NOSIGN (type2
)
1010 || TYPE_VARARGS (type1
) != TYPE_VARARGS (type2
)
1011 || TYPE_VECTOR (type1
) != TYPE_VECTOR (type2
)
1012 || TYPE_NOTTEXT (type1
) != TYPE_NOTTEXT (type2
)
1013 || TYPE_INSTANCE_FLAGS (type1
) != TYPE_INSTANCE_FLAGS (type2
)
1014 || TYPE_NFIELDS (type1
) != TYPE_NFIELDS (type2
))
1017 if (!compare_maybe_null_strings (TYPE_TAG_NAME (type1
),
1018 TYPE_TAG_NAME (type2
)))
1020 if (!compare_maybe_null_strings (TYPE_NAME (type1
), TYPE_NAME (type2
)))
1023 if (TYPE_CODE (type1
) == TYPE_CODE_RANGE
)
1025 if (memcmp (TYPE_RANGE_DATA (type1
), TYPE_RANGE_DATA (type2
),
1026 sizeof (*TYPE_RANGE_DATA (type1
))) != 0)
1033 for (i
= 0; i
< TYPE_NFIELDS (type1
); ++i
)
1035 const struct field
*field1
= &TYPE_FIELD (type1
, i
);
1036 const struct field
*field2
= &TYPE_FIELD (type2
, i
);
1037 struct type_equality_entry entry
;
1039 if (FIELD_ARTIFICIAL (*field1
) != FIELD_ARTIFICIAL (*field2
)
1040 || FIELD_BITSIZE (*field1
) != FIELD_BITSIZE (*field2
)
1041 || FIELD_LOC_KIND (*field1
) != FIELD_LOC_KIND (*field2
))
1043 if (!compare_maybe_null_strings (FIELD_NAME (*field1
),
1044 FIELD_NAME (*field2
)))
1046 switch (FIELD_LOC_KIND (*field1
))
1048 case FIELD_LOC_KIND_BITPOS
:
1049 if (FIELD_BITPOS (*field1
) != FIELD_BITPOS (*field2
))
1052 case FIELD_LOC_KIND_ENUMVAL
:
1053 if (FIELD_ENUMVAL (*field1
) != FIELD_ENUMVAL (*field2
))
1056 case FIELD_LOC_KIND_PHYSADDR
:
1057 if (FIELD_STATIC_PHYSADDR (*field1
)
1058 != FIELD_STATIC_PHYSADDR (*field2
))
1061 case FIELD_LOC_KIND_PHYSNAME
:
1062 if (!compare_maybe_null_strings (FIELD_STATIC_PHYSNAME (*field1
),
1063 FIELD_STATIC_PHYSNAME (*field2
)))
1066 case FIELD_LOC_KIND_DWARF_BLOCK
:
1068 struct dwarf2_locexpr_baton
*block1
, *block2
;
1070 block1
= FIELD_DWARF_BLOCK (*field1
);
1071 block2
= FIELD_DWARF_BLOCK (*field2
);
1072 if (block1
->per_cu
!= block2
->per_cu
1073 || block1
->size
!= block2
->size
1074 || memcmp (block1
->data
, block2
->data
, block1
->size
) != 0)
1079 internal_error (__FILE__
, __LINE__
, _("Unsupported field kind "
1080 "%d by check_types_equal"),
1081 FIELD_LOC_KIND (*field1
));
1084 entry
.type1
= FIELD_TYPE (*field1
);
1085 entry
.type2
= FIELD_TYPE (*field2
);
1086 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
1090 if (TYPE_TARGET_TYPE (type1
) != NULL
)
1092 struct type_equality_entry entry
;
1094 if (TYPE_TARGET_TYPE (type2
) == NULL
)
1097 entry
.type1
= TYPE_TARGET_TYPE (type1
);
1098 entry
.type2
= TYPE_TARGET_TYPE (type2
);
1099 VEC_safe_push (type_equality_entry_d
, *worklist
, &entry
);
1101 else if (TYPE_TARGET_TYPE (type2
) != NULL
)
1107 /* Check types on a worklist for equality. Returns Py_NE if any pair
1108 is not equal, Py_EQ if they are all considered equal. */
1111 check_types_worklist (VEC (type_equality_entry_d
) **worklist
,
1112 struct bcache
*cache
)
1114 while (!VEC_empty (type_equality_entry_d
, *worklist
))
1116 struct type_equality_entry entry
;
1119 entry
= *VEC_last (type_equality_entry_d
, *worklist
);
1120 VEC_pop (type_equality_entry_d
, *worklist
);
1122 /* If the type pair has already been visited, we know it is
1124 bcache_full (&entry
, sizeof (entry
), cache
, &added
);
1128 if (check_types_equal (entry
.type1
, entry
.type2
, worklist
) == Py_NE
)
1135 /* Implement the richcompare method. */
1138 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1141 struct type
*type1
= type_object_to_type (self
);
1142 struct type
*type2
= type_object_to_type (other
);
1143 volatile struct gdb_exception except
;
1145 /* We can only compare ourselves to another Type object, and only
1146 for equality or inequality. */
1147 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
1149 Py_INCREF (Py_NotImplemented
);
1150 return Py_NotImplemented
;
1157 struct bcache
*cache
;
1158 VEC (type_equality_entry_d
) *worklist
= NULL
;
1159 struct type_equality_entry entry
;
1161 cache
= bcache_xmalloc (NULL
, NULL
);
1163 entry
.type1
= type1
;
1164 entry
.type2
= type2
;
1165 VEC_safe_push (type_equality_entry_d
, worklist
, &entry
);
1167 TRY_CATCH (except
, RETURN_MASK_ALL
)
1169 result
= check_types_worklist (&worklist
, cache
);
1171 /* check_types_worklist calls several nested Python helper
1172 functions, some of which can raise a GDB Exception, so we
1173 just check and convert here. If there is a GDB exception, a
1174 comparison is not capable (or trusted), so exit. */
1175 bcache_xfree (cache
);
1176 VEC_free (type_equality_entry_d
, worklist
);
1177 GDB_PY_HANDLE_EXCEPTION (except
);
1187 static const struct objfile_data
*typy_objfile_data_key
;
1190 save_objfile_types (struct objfile
*objfile
, void *datum
)
1192 type_object
*obj
= datum
;
1193 htab_t copied_types
;
1194 struct cleanup
*cleanup
;
1196 /* This prevents another thread from freeing the objects we're
1198 cleanup
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1200 copied_types
= create_copied_types_hash (objfile
);
1204 type_object
*next
= obj
->next
;
1206 htab_empty (copied_types
);
1208 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1216 htab_delete (copied_types
);
1218 do_cleanups (cleanup
);
1222 set_type (type_object
*obj
, struct type
*type
)
1226 if (type
&& TYPE_OBJFILE (type
))
1228 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1230 obj
->next
= objfile_data (objfile
, typy_objfile_data_key
);
1232 obj
->next
->prev
= obj
;
1233 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1240 typy_dealloc (PyObject
*obj
)
1242 type_object
*type
= (type_object
*) obj
;
1245 type
->prev
->next
= type
->next
;
1246 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1248 /* Must reset head of list. */
1249 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1252 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1255 type
->next
->prev
= type
->prev
;
1257 type
->ob_type
->tp_free (type
);
1260 /* Return number of fields ("length" of the field dictionary). */
1263 typy_length (PyObject
*self
)
1265 struct type
*type
= ((type_object
*) self
)->type
;
1267 type
= typy_get_composite (type
);
1271 return TYPE_NFIELDS (type
);
1274 /* Implements boolean evaluation of gdb.Type. Handle this like other
1275 Python objects that don't have a meaningful truth value -- all
1279 typy_nonzero (PyObject
*self
)
1284 /* Return a gdb.Field object for the field named by the argument. */
1287 typy_getitem (PyObject
*self
, PyObject
*key
)
1289 struct type
*type
= ((type_object
*) self
)->type
;
1293 field
= python_string_to_host_string (key
);
1297 /* We want just fields of this type, not of base types, so instead of
1298 using lookup_struct_elt_type, portions of that function are
1301 type
= typy_get_composite (type
);
1305 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1307 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1309 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1311 return convert_field (type
, i
);
1314 PyErr_SetObject (PyExc_KeyError
, key
);
1318 /* Implement the "get" method on the type object. This is the
1319 same as getitem if the key is present, but returns the supplied
1320 default value or None if the key is not found. */
1323 typy_get (PyObject
*self
, PyObject
*args
)
1325 PyObject
*key
, *defval
= Py_None
, *result
;
1327 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1330 result
= typy_getitem (self
, key
);
1334 /* typy_getitem returned error status. If the exception is
1335 KeyError, clear the exception status and return the defval
1336 instead. Otherwise return the exception unchanged. */
1337 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1345 /* Implement the "has_key" method on the type object. */
1348 typy_has_key (PyObject
*self
, PyObject
*args
)
1350 struct type
*type
= ((type_object
*) self
)->type
;
1354 if (!PyArg_ParseTuple (args
, "s", &field
))
1357 /* We want just fields of this type, not of base types, so instead of
1358 using lookup_struct_elt_type, portions of that function are
1361 type
= typy_get_composite (type
);
1365 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1367 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1369 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1375 /* Make an iterator object to iterate over keys, values, or items. */
1378 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1380 typy_iterator_object
*typy_iter_obj
;
1382 /* Check that "self" is a structure or union type. */
1383 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1386 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1387 &type_iterator_object_type
);
1388 if (typy_iter_obj
== NULL
)
1391 typy_iter_obj
->field
= 0;
1392 typy_iter_obj
->kind
= kind
;
1394 typy_iter_obj
->source
= (type_object
*) self
;
1396 return (PyObject
*) typy_iter_obj
;
1399 /* iteritems() method. */
1402 typy_iteritems (PyObject
*self
, PyObject
*args
)
1404 return typy_make_iter (self
, iter_items
);
1407 /* iterkeys() method. */
1410 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1412 return typy_make_iter (self
, iter_keys
);
1415 /* Iterating over the class, same as iterkeys except for the function
1419 typy_iter (PyObject
*self
)
1421 return typy_make_iter (self
, iter_keys
);
1424 /* itervalues() method. */
1427 typy_itervalues (PyObject
*self
, PyObject
*args
)
1429 return typy_make_iter (self
, iter_values
);
1432 /* Return a reference to the type iterator. */
1435 typy_iterator_iter (PyObject
*self
)
1441 /* Return the next field in the iteration through the list of fields
1445 typy_iterator_iternext (PyObject
*self
)
1447 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1448 struct type
*type
= iter_obj
->source
->type
;
1451 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1453 result
= make_fielditem (type
, iter_obj
->field
, iter_obj
->kind
);
1463 typy_iterator_dealloc (PyObject
*obj
)
1465 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1467 Py_DECREF (iter_obj
->source
);
1470 /* Create a new Type referring to TYPE. */
1472 type_to_type_object (struct type
*type
)
1474 type_object
*type_obj
;
1476 type_obj
= PyObject_New (type_object
, &type_object_type
);
1478 set_type (type_obj
, type
);
1480 return (PyObject
*) type_obj
;
1484 type_object_to_type (PyObject
*obj
)
1486 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1488 return ((type_object
*) obj
)->type
;
1493 /* Implementation of gdb.lookup_type. */
1495 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1497 static char *keywords
[] = { "name", "block", NULL
};
1498 const char *type_name
= NULL
;
1499 struct type
*type
= NULL
;
1500 PyObject
*block_obj
= NULL
;
1501 const struct block
*block
= NULL
;
1503 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1504 &type_name
, &block_obj
))
1509 block
= block_object_to_block (block_obj
);
1512 PyErr_SetString (PyExc_RuntimeError
,
1513 _("'block' argument must be a Block."));
1518 type
= typy_lookup_typename (type_name
, block
);
1522 return (PyObject
*) type_to_type_object (type
);
1526 gdbpy_initialize_types (void)
1530 typy_objfile_data_key
1531 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1533 if (PyType_Ready (&type_object_type
) < 0)
1535 if (PyType_Ready (&field_object_type
) < 0)
1537 if (PyType_Ready (&type_iterator_object_type
) < 0)
1540 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1542 if (PyModule_AddIntConstant (gdb_module
,
1543 /* Cast needed for Python 2.4. */
1544 (char *) pyty_codes
[i
].name
,
1545 pyty_codes
[i
].code
) < 0)
1549 Py_INCREF (&type_object_type
);
1550 PyModule_AddObject (gdb_module
, "Type", (PyObject
*) &type_object_type
);
1552 Py_INCREF (&type_iterator_object_type
);
1553 PyModule_AddObject (gdb_module
, "TypeIterator",
1554 (PyObject
*) &type_iterator_object_type
);
1556 Py_INCREF (&field_object_type
);
1557 PyModule_AddObject (gdb_module
, "Field", (PyObject
*) &field_object_type
);
1562 static PyGetSetDef type_object_getset
[] =
1564 { "code", typy_get_code
, NULL
,
1565 "The code for this type.", NULL
},
1566 { "sizeof", typy_get_sizeof
, NULL
,
1567 "The size of this type, in bytes.", NULL
},
1568 { "tag", typy_get_tag
, NULL
,
1569 "The tag name for this type, or None.", NULL
},
1573 static PyMethodDef type_object_methods
[] =
1575 { "array", typy_array
, METH_VARARGS
,
1576 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1577 Return a type which represents an array of objects of this type.\n\
1578 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1579 If LOW_BOUND is omitted, a value of zero is used." },
1580 { "vector", typy_vector
, METH_VARARGS
,
1581 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1582 Return a type which represents a vector of objects of this type.\n\
1583 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1584 If LOW_BOUND is omitted, a value of zero is used.\n\
1585 Vectors differ from arrays in that if the current language has C-style\n\
1586 arrays, vectors don't decay to a pointer to the first element.\n\
1587 They are first class values." },
1588 { "__contains__", typy_has_key
, METH_VARARGS
,
1589 "T.__contains__(k) -> True if T has a field named k, else False" },
1590 { "const", typy_const
, METH_NOARGS
,
1591 "const () -> Type\n\
1592 Return a const variant of this type." },
1593 { "fields", typy_fields
, METH_NOARGS
,
1594 "fields () -> list\n\
1595 Return a list holding all the fields of this type.\n\
1596 Each field is a gdb.Field object." },
1597 { "get", typy_get
, METH_VARARGS
,
1598 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1599 otherwise returns default, if supplied, or None if not." },
1600 { "has_key", typy_has_key
, METH_VARARGS
,
1601 "T.has_key(k) -> True if T has a field named k, else False" },
1602 { "items", typy_items
, METH_NOARGS
,
1603 "items () -> list\n\
1604 Return a list of (name, field) pairs of this type.\n\
1605 Each field is a gdb.Field object." },
1606 { "iteritems", typy_iteritems
, METH_NOARGS
,
1607 "iteritems () -> an iterator over the (name, field)\n\
1608 pairs of this type. Each field is a gdb.Field object." },
1609 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1610 "iterkeys () -> an iterator over the field names of this type." },
1611 { "itervalues", typy_itervalues
, METH_NOARGS
,
1612 "itervalues () -> an iterator over the fields of this type.\n\
1613 Each field is a gdb.Field object." },
1614 { "keys", typy_field_names
, METH_NOARGS
,
1616 Return a list holding all the fields names of this type." },
1617 { "pointer", typy_pointer
, METH_NOARGS
,
1618 "pointer () -> Type\n\
1619 Return a type of pointer to this type." },
1620 { "range", typy_range
, METH_NOARGS
,
1621 "range () -> tuple\n\
1622 Return a tuple containing the lower and upper range for this type."},
1623 { "reference", typy_reference
, METH_NOARGS
,
1624 "reference () -> Type\n\
1625 Return a type of reference to this type." },
1626 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1627 "strip_typedefs () -> Type\n\
1628 Return a type formed by stripping this type of all typedefs."},
1629 { "target", typy_target
, METH_NOARGS
,
1630 "target () -> Type\n\
1631 Return the target type of this type." },
1632 { "template_argument", typy_template_argument
, METH_VARARGS
,
1633 "template_argument (arg, [block]) -> Type\n\
1634 Return the type of a template argument." },
1635 { "unqualified", typy_unqualified
, METH_NOARGS
,
1636 "unqualified () -> Type\n\
1637 Return a variant of this type without const or volatile attributes." },
1638 { "values", typy_values
, METH_NOARGS
,
1639 "values () -> list\n\
1640 Return a list holding all the fields of this type.\n\
1641 Each field is a gdb.Field object." },
1642 { "volatile", typy_volatile
, METH_NOARGS
,
1643 "volatile () -> Type\n\
1644 Return a volatile variant of this type" },
1648 static PyNumberMethods type_object_as_number
= {
1650 NULL
, /* nb_subtract */
1651 NULL
, /* nb_multiply */
1652 NULL
, /* nb_divide */
1653 NULL
, /* nb_remainder */
1654 NULL
, /* nb_divmod */
1655 NULL
, /* nb_power */
1656 NULL
, /* nb_negative */
1657 NULL
, /* nb_positive */
1658 NULL
, /* nb_absolute */
1659 typy_nonzero
, /* nb_nonzero */
1660 NULL
, /* nb_invert */
1661 NULL
, /* nb_lshift */
1662 NULL
, /* nb_rshift */
1666 NULL
, /* nb_coerce */
1669 NULL
, /* nb_float */
1674 static PyMappingMethods typy_mapping
= {
1677 NULL
/* no "set" method */
1680 static PyTypeObject type_object_type
=
1682 PyObject_HEAD_INIT (NULL
)
1684 "gdb.Type", /*tp_name*/
1685 sizeof (type_object
), /*tp_basicsize*/
1687 typy_dealloc
, /*tp_dealloc*/
1693 &type_object_as_number
, /*tp_as_number*/
1694 0, /*tp_as_sequence*/
1695 &typy_mapping
, /*tp_as_mapping*/
1698 typy_str
, /*tp_str*/
1702 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1703 "GDB type object", /* tp_doc */
1704 0, /* tp_traverse */
1706 typy_richcompare
, /* tp_richcompare */
1707 0, /* tp_weaklistoffset */
1708 typy_iter
, /* tp_iter */
1709 0, /* tp_iternext */
1710 type_object_methods
, /* tp_methods */
1712 type_object_getset
, /* tp_getset */
1715 0, /* tp_descr_get */
1716 0, /* tp_descr_set */
1717 0, /* tp_dictoffset */
1723 static PyGetSetDef field_object_getset
[] =
1725 { "__dict__", gdb_py_generic_dict
, NULL
,
1726 "The __dict__ for this field.", &field_object_type
},
1730 static PyTypeObject field_object_type
=
1732 PyObject_HEAD_INIT (NULL
)
1734 "gdb.Field", /*tp_name*/
1735 sizeof (field_object
), /*tp_basicsize*/
1737 field_dealloc
, /*tp_dealloc*/
1744 0, /*tp_as_sequence*/
1745 0, /*tp_as_mapping*/
1752 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1753 "GDB field object", /* tp_doc */
1754 0, /* tp_traverse */
1756 0, /* tp_richcompare */
1757 0, /* tp_weaklistoffset */
1759 0, /* tp_iternext */
1762 field_object_getset
, /* tp_getset */
1765 0, /* tp_descr_get */
1766 0, /* tp_descr_set */
1767 offsetof (field_object
, dict
), /* tp_dictoffset */
1773 static PyTypeObject type_iterator_object_type
= {
1774 PyObject_HEAD_INIT (NULL
)
1776 "gdb.TypeIterator", /*tp_name*/
1777 sizeof (typy_iterator_object
), /*tp_basicsize*/
1779 typy_iterator_dealloc
, /*tp_dealloc*/
1786 0, /*tp_as_sequence*/
1787 0, /*tp_as_mapping*/
1794 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1795 "GDB type iterator object", /*tp_doc */
1798 0, /*tp_richcompare */
1799 0, /*tp_weaklistoffset */
1800 typy_iterator_iter
, /*tp_iter */
1801 typy_iterator_iternext
, /*tp_iternext */