1 /* Python interface to types.
3 Copyright (C) 2008-2019 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 "python-internal.h"
25 #include "cp-support.h"
30 #include "typeprint.h"
33 typedef struct pyty_type_object
38 /* If a Type object is associated with an objfile, it is kept on a
39 doubly-linked list, rooted in the objfile. This lets us copy the
40 underlying struct type when the objfile is deleted. */
41 struct pyty_type_object
*prev
;
42 struct pyty_type_object
*next
;
45 extern PyTypeObject type_object_type
46 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("type_object");
49 typedef struct pyty_field_object
53 /* Dictionary holding our attributes. */
57 extern PyTypeObject field_object_type
58 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("field_object");
60 /* A type iterator object. */
63 /* The current field index. */
66 enum gdbpy_iter_kind kind
;
67 /* Pointer back to the original source type object. */
68 struct pyty_type_object
*source
;
69 } typy_iterator_object
;
71 extern PyTypeObject type_iterator_object_type
72 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("typy_iterator_object");
74 /* This is used to initialize various gdb.TYPE_ constants. */
83 /* Forward declarations. */
84 static PyObject
*typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
);
86 #define ENTRY(X) { X, #X }
88 static struct pyty_code pyty_codes
[] =
90 ENTRY (TYPE_CODE_BITSTRING
),
91 ENTRY (TYPE_CODE_PTR
),
92 ENTRY (TYPE_CODE_ARRAY
),
93 ENTRY (TYPE_CODE_STRUCT
),
94 ENTRY (TYPE_CODE_UNION
),
95 ENTRY (TYPE_CODE_ENUM
),
96 ENTRY (TYPE_CODE_FLAGS
),
97 ENTRY (TYPE_CODE_FUNC
),
98 ENTRY (TYPE_CODE_INT
),
99 ENTRY (TYPE_CODE_FLT
),
100 ENTRY (TYPE_CODE_VOID
),
101 ENTRY (TYPE_CODE_SET
),
102 ENTRY (TYPE_CODE_RANGE
),
103 ENTRY (TYPE_CODE_STRING
),
104 ENTRY (TYPE_CODE_ERROR
),
105 ENTRY (TYPE_CODE_METHOD
),
106 ENTRY (TYPE_CODE_METHODPTR
),
107 ENTRY (TYPE_CODE_MEMBERPTR
),
108 ENTRY (TYPE_CODE_REF
),
109 ENTRY (TYPE_CODE_RVALUE_REF
),
110 ENTRY (TYPE_CODE_CHAR
),
111 ENTRY (TYPE_CODE_BOOL
),
112 ENTRY (TYPE_CODE_COMPLEX
),
113 ENTRY (TYPE_CODE_TYPEDEF
),
114 ENTRY (TYPE_CODE_NAMESPACE
),
115 ENTRY (TYPE_CODE_DECFLOAT
),
116 ENTRY (TYPE_CODE_INTERNAL_FUNCTION
),
117 { TYPE_CODE_UNDEF
, NULL
}
123 field_dealloc (PyObject
*obj
)
125 field_object
*f
= (field_object
*) obj
;
127 Py_XDECREF (f
->dict
);
128 Py_TYPE (obj
)->tp_free (obj
);
134 gdbpy_ref
<field_object
> result (PyObject_New (field_object
,
135 &field_object_type
));
139 result
->dict
= PyDict_New ();
143 return (PyObject
*) result
.release ();
148 /* Return true if OBJ is of type gdb.Field, false otherwise. */
151 gdbpy_is_field (PyObject
*obj
)
153 return PyObject_TypeCheck (obj
, &field_object_type
);
156 /* Return the code for this type. */
158 typy_get_code (PyObject
*self
, void *closure
)
160 struct type
*type
= ((type_object
*) self
)->type
;
162 return PyInt_FromLong (TYPE_CODE (type
));
165 /* Helper function for typy_fields which converts a single field to a
166 gdb.Field object. Returns NULL on error. */
169 convert_field (struct type
*type
, int field
)
171 gdbpy_ref
<> result (field_new ());
176 gdbpy_ref
<> arg (type_to_type_object (type
));
179 if (PyObject_SetAttrString (result
.get (), "parent_type", arg
.get ()) < 0)
182 if (!field_is_static (&TYPE_FIELD (type
, field
)))
184 const char *attrstring
;
186 if (TYPE_CODE (type
) == TYPE_CODE_ENUM
)
188 arg
.reset (gdb_py_long_from_longest (TYPE_FIELD_ENUMVAL (type
,
190 attrstring
= "enumval";
194 arg
.reset (gdb_py_long_from_longest (TYPE_FIELD_BITPOS (type
,
196 attrstring
= "bitpos";
202 /* At least python-2.4 had the second parameter non-const. */
203 if (PyObject_SetAttrString (result
.get (), (char *) attrstring
,
209 if (TYPE_FIELD_NAME (type
, field
))
211 const char *field_name
= TYPE_FIELD_NAME (type
, field
);
213 if (field_name
[0] != '\0')
215 arg
.reset (PyString_FromString (TYPE_FIELD_NAME (type
, field
)));
221 arg
= gdbpy_ref
<>::new_reference (Py_None
);
223 if (PyObject_SetAttrString (result
.get (), "name", arg
.get ()) < 0)
226 arg
= gdbpy_ref
<>::new_reference (TYPE_FIELD_ARTIFICIAL (type
, field
)
227 ? Py_True
: Py_False
);
228 if (PyObject_SetAttrString (result
.get (), "artificial", arg
.get ()) < 0)
231 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
232 arg
= gdbpy_ref
<>::new_reference (field
< TYPE_N_BASECLASSES (type
)
233 ? Py_True
: Py_False
);
235 arg
= gdbpy_ref
<>::new_reference (Py_False
);
236 if (PyObject_SetAttrString (result
.get (), "is_base_class", arg
.get ()) < 0)
239 arg
.reset (PyLong_FromLong (TYPE_FIELD_BITSIZE (type
, field
)));
242 if (PyObject_SetAttrString (result
.get (), "bitsize", arg
.get ()) < 0)
245 /* A field can have a NULL type in some situations. */
246 if (TYPE_FIELD_TYPE (type
, field
) == NULL
)
247 arg
= gdbpy_ref
<>::new_reference (Py_None
);
249 arg
.reset (type_to_type_object (TYPE_FIELD_TYPE (type
, field
)));
252 if (PyObject_SetAttrString (result
.get (), "type", arg
.get ()) < 0)
258 /* Helper function to return the name of a field, as a gdb.Field object.
259 If the field doesn't have a name, None is returned. */
262 field_name (struct type
*type
, int field
)
266 if (TYPE_FIELD_NAME (type
, field
))
267 result
.reset (PyString_FromString (TYPE_FIELD_NAME (type
, field
)));
269 result
= gdbpy_ref
<>::new_reference (Py_None
);
274 /* Helper function for Type standard mapping methods. Returns a
275 Python object for field i of the type. "kind" specifies what to
276 return: the name of the field, a gdb.Field object corresponding to
277 the field, or a tuple consisting of field name and gdb.Field
281 make_fielditem (struct type
*type
, int i
, enum gdbpy_iter_kind kind
)
287 gdbpy_ref
<> key (field_name (type
, i
));
290 gdbpy_ref
<> value
= convert_field (type
, i
);
293 gdbpy_ref
<> item (PyTuple_New (2));
296 PyTuple_SET_ITEM (item
.get (), 0, key
.release ());
297 PyTuple_SET_ITEM (item
.get (), 1, value
.release ());
301 return field_name (type
, i
);
303 return convert_field (type
, i
);
305 gdb_assert_not_reached ("invalid gdbpy_iter_kind");
308 /* Return a sequence of all field names, fields, or (name, field) pairs.
309 Each field is a gdb.Field object. */
312 typy_fields_items (PyObject
*self
, enum gdbpy_iter_kind kind
)
314 PyObject
*py_type
= self
;
315 struct type
*type
= ((type_object
*) py_type
)->type
;
316 struct type
*checked_type
= type
;
320 checked_type
= check_typedef (checked_type
);
322 CATCH (except
, RETURN_MASK_ALL
)
324 GDB_PY_HANDLE_EXCEPTION (except
);
328 gdbpy_ref
<> type_holder
;
329 if (checked_type
!= type
)
331 type_holder
.reset (type_to_type_object (checked_type
));
332 if (type_holder
== nullptr)
334 py_type
= type_holder
.get ();
336 gdbpy_ref
<> iter (typy_make_iter (py_type
, kind
));
340 return PySequence_List (iter
.get ());
343 /* Return a sequence of all fields. Each field is a gdb.Field object. */
346 typy_values (PyObject
*self
, PyObject
*args
)
348 return typy_fields_items (self
, iter_values
);
351 /* Return a sequence of all fields. Each field is a gdb.Field object.
352 This method is similar to typy_values, except where the supplied
353 gdb.Type is an array, in which case it returns a list of one entry
354 which is a gdb.Field object for a range (the array bounds). */
357 typy_fields (PyObject
*self
, PyObject
*args
)
359 struct type
*type
= ((type_object
*) self
)->type
;
361 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
362 return typy_fields_items (self
, iter_values
);
364 /* Array type. Handle this as a special case because the common
365 machinery wants struct or union or enum types. Build a list of
366 one entry which is the range for the array. */
367 gdbpy_ref
<> r
= convert_field (type
, 0);
371 return Py_BuildValue ("[O]", r
.get ());
374 /* Return a sequence of all field names. Each field is a gdb.Field object. */
377 typy_field_names (PyObject
*self
, PyObject
*args
)
379 return typy_fields_items (self
, iter_keys
);
382 /* Return a sequence of all (name, fields) pairs. Each field is a
386 typy_items (PyObject
*self
, PyObject
*args
)
388 return typy_fields_items (self
, iter_items
);
391 /* Return the type's name, or None. */
394 typy_get_name (PyObject
*self
, void *closure
)
396 struct type
*type
= ((type_object
*) self
)->type
;
398 if (TYPE_NAME (type
) == NULL
)
400 return PyString_FromString (TYPE_NAME (type
));
403 /* Return the type's tag, or None. */
405 typy_get_tag (PyObject
*self
, void *closure
)
407 struct type
*type
= ((type_object
*) self
)->type
;
408 const char *tagname
= nullptr;
410 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
411 || TYPE_CODE (type
) == TYPE_CODE_UNION
412 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
413 tagname
= TYPE_NAME (type
);
415 if (tagname
== nullptr)
417 return PyString_FromString (tagname
);
420 /* Return the type, stripped of typedefs. */
422 typy_strip_typedefs (PyObject
*self
, PyObject
*args
)
424 struct type
*type
= ((type_object
*) self
)->type
;
428 type
= check_typedef (type
);
430 CATCH (except
, RETURN_MASK_ALL
)
432 GDB_PY_HANDLE_EXCEPTION (except
);
436 return type_to_type_object (type
);
439 /* Strip typedefs and pointers/reference from a type. Then check that
440 it is a struct, union, or enum type. If not, raise TypeError. */
443 typy_get_composite (struct type
*type
)
450 type
= check_typedef (type
);
452 CATCH (except
, RETURN_MASK_ALL
)
454 GDB_PY_HANDLE_EXCEPTION (except
);
458 if (TYPE_CODE (type
) != TYPE_CODE_PTR
&& !TYPE_IS_REFERENCE (type
))
460 type
= TYPE_TARGET_TYPE (type
);
463 /* If this is not a struct, union, or enum type, raise TypeError
465 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
466 && TYPE_CODE (type
) != TYPE_CODE_UNION
467 && TYPE_CODE (type
) != TYPE_CODE_ENUM
468 && TYPE_CODE (type
) != TYPE_CODE_FUNC
)
470 PyErr_SetString (PyExc_TypeError
,
471 "Type is not a structure, union, enum, or function type.");
478 /* Helper for typy_array and typy_vector. */
481 typy_array_1 (PyObject
*self
, PyObject
*args
, int is_vector
)
484 PyObject
*n2_obj
= NULL
;
485 struct type
*array
= NULL
;
486 struct type
*type
= ((type_object
*) self
)->type
;
488 if (! PyArg_ParseTuple (args
, "l|O", &n1
, &n2_obj
))
493 if (!PyInt_Check (n2_obj
))
495 PyErr_SetString (PyExc_RuntimeError
,
496 _("Array bound must be an integer"));
500 if (! gdb_py_int_as_long (n2_obj
, &n2
))
509 if (n2
< n1
- 1) /* Note: An empty array has n2 == n1 - 1. */
511 PyErr_SetString (PyExc_ValueError
,
512 _("Array length must not be negative"));
518 array
= lookup_array_range_type (type
, n1
, n2
);
520 make_vector_type (array
);
522 CATCH (except
, RETURN_MASK_ALL
)
524 GDB_PY_HANDLE_EXCEPTION (except
);
528 return type_to_type_object (array
);
531 /* Return an array type. */
534 typy_array (PyObject
*self
, PyObject
*args
)
536 return typy_array_1 (self
, args
, 0);
539 /* Return a vector type. */
542 typy_vector (PyObject
*self
, PyObject
*args
)
544 return typy_array_1 (self
, args
, 1);
547 /* Return a Type object which represents a pointer to SELF. */
549 typy_pointer (PyObject
*self
, PyObject
*args
)
551 struct type
*type
= ((type_object
*) self
)->type
;
555 type
= lookup_pointer_type (type
);
557 CATCH (except
, RETURN_MASK_ALL
)
559 GDB_PY_HANDLE_EXCEPTION (except
);
563 return type_to_type_object (type
);
566 /* Return the range of a type represented by SELF. The return type is
567 a tuple. The first element of the tuple contains the low bound,
568 while the second element of the tuple contains the high bound. */
570 typy_range (PyObject
*self
, PyObject
*args
)
572 struct type
*type
= ((type_object
*) self
)->type
;
573 /* Initialize these to appease GCC warnings. */
574 LONGEST low
= 0, high
= 0;
576 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
577 && TYPE_CODE (type
) != TYPE_CODE_STRING
578 && TYPE_CODE (type
) != TYPE_CODE_RANGE
)
580 PyErr_SetString (PyExc_RuntimeError
,
581 _("This type does not have a range."));
585 switch (TYPE_CODE (type
))
587 case TYPE_CODE_ARRAY
:
588 case TYPE_CODE_STRING
:
589 low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
590 high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
));
592 case TYPE_CODE_RANGE
:
593 low
= TYPE_LOW_BOUND (type
);
594 high
= TYPE_HIGH_BOUND (type
);
598 gdbpy_ref
<> low_bound (PyLong_FromLong (low
));
599 if (low_bound
== NULL
)
602 gdbpy_ref
<> high_bound (PyLong_FromLong (high
));
603 if (high_bound
== NULL
)
606 gdbpy_ref
<> result (PyTuple_New (2));
610 if (PyTuple_SetItem (result
.get (), 0, low_bound
.release ()) != 0
611 || PyTuple_SetItem (result
.get (), 1, high_bound
.release ()) != 0)
613 return result
.release ();
616 /* Return a Type object which represents a reference to SELF. */
618 typy_reference (PyObject
*self
, PyObject
*args
)
620 struct type
*type
= ((type_object
*) self
)->type
;
624 type
= lookup_lvalue_reference_type (type
);
626 CATCH (except
, RETURN_MASK_ALL
)
628 GDB_PY_HANDLE_EXCEPTION (except
);
632 return type_to_type_object (type
);
635 /* Return a Type object which represents the target type of SELF. */
637 typy_target (PyObject
*self
, PyObject
*args
)
639 struct type
*type
= ((type_object
*) self
)->type
;
641 if (!TYPE_TARGET_TYPE (type
))
643 PyErr_SetString (PyExc_RuntimeError
,
644 _("Type does not have a target."));
648 return type_to_type_object (TYPE_TARGET_TYPE (type
));
651 /* Return a const-qualified type variant. */
653 typy_const (PyObject
*self
, PyObject
*args
)
655 struct type
*type
= ((type_object
*) self
)->type
;
659 type
= make_cv_type (1, 0, type
, NULL
);
661 CATCH (except
, RETURN_MASK_ALL
)
663 GDB_PY_HANDLE_EXCEPTION (except
);
667 return type_to_type_object (type
);
670 /* Return a volatile-qualified type variant. */
672 typy_volatile (PyObject
*self
, PyObject
*args
)
674 struct type
*type
= ((type_object
*) self
)->type
;
678 type
= make_cv_type (0, 1, type
, NULL
);
680 CATCH (except
, RETURN_MASK_ALL
)
682 GDB_PY_HANDLE_EXCEPTION (except
);
686 return type_to_type_object (type
);
689 /* Return an unqualified type variant. */
691 typy_unqualified (PyObject
*self
, PyObject
*args
)
693 struct type
*type
= ((type_object
*) self
)->type
;
697 type
= make_cv_type (0, 0, type
, NULL
);
699 CATCH (except
, RETURN_MASK_ALL
)
701 GDB_PY_HANDLE_EXCEPTION (except
);
705 return type_to_type_object (type
);
708 /* Return the size of the type represented by SELF, in bytes. */
710 typy_get_sizeof (PyObject
*self
, void *closure
)
712 struct type
*type
= ((type_object
*) self
)->type
;
716 check_typedef (type
);
718 CATCH (except
, RETURN_MASK_ALL
)
723 /* Ignore exceptions. */
725 return gdb_py_long_from_longest (TYPE_LENGTH (type
));
728 /* Return the alignment of the type represented by SELF, in bytes. */
730 typy_get_alignof (PyObject
*self
, void *closure
)
732 struct type
*type
= ((type_object
*) self
)->type
;
737 align
= type_align (type
);
739 CATCH (except
, RETURN_MASK_ALL
)
745 /* Ignore exceptions. */
747 return gdb_py_object_from_ulongest (align
).release ();
751 typy_lookup_typename (const char *type_name
, const struct block
*block
)
753 struct type
*type
= NULL
;
757 if (startswith (type_name
, "struct "))
758 type
= lookup_struct (type_name
+ 7, NULL
);
759 else if (startswith (type_name
, "union "))
760 type
= lookup_union (type_name
+ 6, NULL
);
761 else if (startswith (type_name
, "enum "))
762 type
= lookup_enum (type_name
+ 5, NULL
);
764 type
= lookup_typename (python_language
, python_gdbarch
,
765 type_name
, block
, 0);
767 CATCH (except
, RETURN_MASK_ALL
)
769 GDB_PY_HANDLE_EXCEPTION (except
);
777 typy_lookup_type (struct demangle_component
*demangled
,
778 const struct block
*block
)
780 struct type
*type
, *rtype
= NULL
;
781 enum demangle_component_type demangled_type
;
783 /* Save the type: typy_lookup_type() may (indirectly) overwrite
784 memory pointed by demangled. */
785 demangled_type
= demangled
->type
;
787 if (demangled_type
== DEMANGLE_COMPONENT_POINTER
788 || demangled_type
== DEMANGLE_COMPONENT_REFERENCE
789 || demangled_type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE
790 || demangled_type
== DEMANGLE_COMPONENT_CONST
791 || demangled_type
== DEMANGLE_COMPONENT_VOLATILE
)
793 type
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
799 /* If the demangled_type matches with one of the types
800 below, run the corresponding function and save the type
801 to return later. We cannot just return here as we are in
802 an exception handler. */
803 switch (demangled_type
)
805 case DEMANGLE_COMPONENT_REFERENCE
:
806 rtype
= lookup_lvalue_reference_type (type
);
808 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
809 rtype
= lookup_rvalue_reference_type (type
);
811 case DEMANGLE_COMPONENT_POINTER
:
812 rtype
= lookup_pointer_type (type
);
814 case DEMANGLE_COMPONENT_CONST
:
815 rtype
= make_cv_type (1, 0, type
, NULL
);
817 case DEMANGLE_COMPONENT_VOLATILE
:
818 rtype
= make_cv_type (0, 1, type
, NULL
);
822 CATCH (except
, RETURN_MASK_ALL
)
824 GDB_PY_HANDLE_EXCEPTION (except
);
829 /* If we have a type from the switch statement above, just return
834 /* We don't have a type, so lookup the type. */
835 gdb::unique_xmalloc_ptr
<char> type_name
= cp_comp_to_string (demangled
, 10);
836 return typy_lookup_typename (type_name
.get (), block
);
839 /* This is a helper function for typy_template_argument that is used
840 when the type does not have template symbols attached. It works by
841 parsing the type name. This happens with compilers, like older
842 versions of GCC, that do not emit DW_TAG_template_*. */
845 typy_legacy_template_argument (struct type
*type
, const struct block
*block
,
849 struct demangle_component
*demangled
;
850 std::unique_ptr
<demangle_parse_info
> info
;
852 struct type
*argtype
;
854 if (TYPE_NAME (type
) == NULL
)
856 PyErr_SetString (PyExc_RuntimeError
, _("Null type name."));
862 /* Note -- this is not thread-safe. */
863 info
= cp_demangled_name_to_comp (TYPE_NAME (type
), &err
);
865 CATCH (except
, RETURN_MASK_ALL
)
867 GDB_PY_HANDLE_EXCEPTION (except
);
873 PyErr_SetString (PyExc_RuntimeError
, err
.c_str ());
876 demangled
= info
->tree
;
878 /* Strip off component names. */
879 while (demangled
->type
== DEMANGLE_COMPONENT_QUAL_NAME
880 || demangled
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
881 demangled
= demangled
->u
.s_binary
.right
;
883 if (demangled
->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
885 PyErr_SetString (PyExc_RuntimeError
, _("Type is not a template."));
889 /* Skip from the template to the arguments. */
890 demangled
= demangled
->u
.s_binary
.right
;
892 for (i
= 0; demangled
&& i
< argno
; ++i
)
893 demangled
= demangled
->u
.s_binary
.right
;
897 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
902 argtype
= typy_lookup_type (demangled
->u
.s_binary
.left
, block
);
906 return type_to_type_object (argtype
);
910 typy_template_argument (PyObject
*self
, PyObject
*args
)
913 struct type
*type
= ((type_object
*) self
)->type
;
914 const struct block
*block
= NULL
;
915 PyObject
*block_obj
= NULL
;
917 struct value
*val
= NULL
;
919 if (! PyArg_ParseTuple (args
, "i|O", &argno
, &block_obj
))
924 PyErr_SetString (PyExc_RuntimeError
,
925 _("Template argument number must be non-negative"));
931 block
= block_object_to_block (block_obj
);
934 PyErr_SetString (PyExc_RuntimeError
,
935 _("Second argument must be block."));
942 type
= check_typedef (type
);
943 if (TYPE_IS_REFERENCE (type
))
944 type
= check_typedef (TYPE_TARGET_TYPE (type
));
946 CATCH (except
, RETURN_MASK_ALL
)
948 GDB_PY_HANDLE_EXCEPTION (except
);
952 /* We might not have DW_TAG_template_*, so try to parse the type's
953 name. This is inefficient if we do not have a template type --
954 but that is going to wind up as an error anyhow. */
955 if (! TYPE_N_TEMPLATE_ARGUMENTS (type
))
956 return typy_legacy_template_argument (type
, block
, argno
);
958 if (argno
>= TYPE_N_TEMPLATE_ARGUMENTS (type
))
960 PyErr_Format (PyExc_RuntimeError
, _("No argument %d in template."),
965 sym
= TYPE_TEMPLATE_ARGUMENT (type
, argno
);
966 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
)
967 return type_to_type_object (SYMBOL_TYPE (sym
));
968 else if (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
)
970 PyErr_Format (PyExc_RuntimeError
,
971 _("Template argument is optimized out"));
977 val
= value_of_variable (sym
, block
);
979 CATCH (except
, RETURN_MASK_ALL
)
981 GDB_PY_HANDLE_EXCEPTION (except
);
985 return value_to_value_object (val
);
989 typy_str (PyObject
*self
)
995 LA_PRINT_TYPE (type_object_to_type (self
), "", &thetype
, -1, 0,
996 &type_print_raw_options
);
998 CATCH (except
, RETURN_MASK_ALL
)
1000 GDB_PY_HANDLE_EXCEPTION (except
);
1004 return PyUnicode_Decode (thetype
.c_str (), thetype
.size (),
1005 host_charset (), NULL
);
1008 /* Implement the richcompare method. */
1011 typy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1013 bool result
= false;
1014 struct type
*type1
= type_object_to_type (self
);
1015 struct type
*type2
= type_object_to_type (other
);
1017 /* We can only compare ourselves to another Type object, and only
1018 for equality or inequality. */
1019 if (type2
== NULL
|| (op
!= Py_EQ
&& op
!= Py_NE
))
1021 Py_INCREF (Py_NotImplemented
);
1022 return Py_NotImplemented
;
1031 result
= types_deeply_equal (type1
, type2
);
1033 CATCH (except
, RETURN_MASK_ALL
)
1035 /* If there is a GDB exception, a comparison is not capable
1036 (or trusted), so exit. */
1037 GDB_PY_HANDLE_EXCEPTION (except
);
1042 if (op
== (result
? Py_EQ
: Py_NE
))
1049 static const struct objfile_data
*typy_objfile_data_key
;
1052 save_objfile_types (struct objfile
*objfile
, void *datum
)
1054 type_object
*obj
= (type_object
*) datum
;
1055 htab_t copied_types
;
1057 if (!gdb_python_initialized
)
1060 /* This prevents another thread from freeing the objects we're
1062 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1064 copied_types
= create_copied_types_hash (objfile
);
1068 type_object
*next
= obj
->next
;
1070 htab_empty (copied_types
);
1072 obj
->type
= copy_type_recursive (objfile
, obj
->type
, copied_types
);
1080 htab_delete (copied_types
);
1084 set_type (type_object
*obj
, struct type
*type
)
1088 if (type
&& TYPE_OBJFILE (type
))
1090 struct objfile
*objfile
= TYPE_OBJFILE (type
);
1092 obj
->next
= ((struct pyty_type_object
*)
1093 objfile_data (objfile
, typy_objfile_data_key
));
1095 obj
->next
->prev
= obj
;
1096 set_objfile_data (objfile
, typy_objfile_data_key
, obj
);
1103 typy_dealloc (PyObject
*obj
)
1105 type_object
*type
= (type_object
*) obj
;
1108 type
->prev
->next
= type
->next
;
1109 else if (type
->type
&& TYPE_OBJFILE (type
->type
))
1111 /* Must reset head of list. */
1112 struct objfile
*objfile
= TYPE_OBJFILE (type
->type
);
1115 set_objfile_data (objfile
, typy_objfile_data_key
, type
->next
);
1118 type
->next
->prev
= type
->prev
;
1120 Py_TYPE (type
)->tp_free (type
);
1123 /* Return number of fields ("length" of the field dictionary). */
1126 typy_length (PyObject
*self
)
1128 struct type
*type
= ((type_object
*) self
)->type
;
1130 type
= typy_get_composite (type
);
1134 return TYPE_NFIELDS (type
);
1137 /* Implements boolean evaluation of gdb.Type. Handle this like other
1138 Python objects that don't have a meaningful truth value -- all
1142 typy_nonzero (PyObject
*self
)
1147 /* Return optimized out value of this type. */
1150 typy_optimized_out (PyObject
*self
, PyObject
*args
)
1152 struct type
*type
= ((type_object
*) self
)->type
;
1154 return value_to_value_object (allocate_optimized_out_value (type
));
1157 /* Return a gdb.Field object for the field named by the argument. */
1160 typy_getitem (PyObject
*self
, PyObject
*key
)
1162 struct type
*type
= ((type_object
*) self
)->type
;
1165 gdb::unique_xmalloc_ptr
<char> field
= python_string_to_host_string (key
);
1169 /* We want just fields of this type, not of base types, so instead of
1170 using lookup_struct_elt_type, portions of that function are
1173 type
= typy_get_composite (type
);
1177 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1179 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1181 if (t_field_name
&& (strcmp_iw (t_field_name
, field
.get ()) == 0))
1182 return convert_field (type
, i
).release ();
1184 PyErr_SetObject (PyExc_KeyError
, key
);
1188 /* Implement the "get" method on the type object. This is the
1189 same as getitem if the key is present, but returns the supplied
1190 default value or None if the key is not found. */
1193 typy_get (PyObject
*self
, PyObject
*args
)
1195 PyObject
*key
, *defval
= Py_None
, *result
;
1197 if (!PyArg_UnpackTuple (args
, "get", 1, 2, &key
, &defval
))
1200 result
= typy_getitem (self
, key
);
1204 /* typy_getitem returned error status. If the exception is
1205 KeyError, clear the exception status and return the defval
1206 instead. Otherwise return the exception unchanged. */
1207 if (!PyErr_ExceptionMatches (PyExc_KeyError
))
1215 /* Implement the "has_key" method on the type object. */
1218 typy_has_key (PyObject
*self
, PyObject
*args
)
1220 struct type
*type
= ((type_object
*) self
)->type
;
1224 if (!PyArg_ParseTuple (args
, "s", &field
))
1227 /* We want just fields of this type, not of base types, so instead of
1228 using lookup_struct_elt_type, portions of that function are
1231 type
= typy_get_composite (type
);
1235 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1237 const char *t_field_name
= TYPE_FIELD_NAME (type
, i
);
1239 if (t_field_name
&& (strcmp_iw (t_field_name
, field
) == 0))
1245 /* Make an iterator object to iterate over keys, values, or items. */
1248 typy_make_iter (PyObject
*self
, enum gdbpy_iter_kind kind
)
1250 typy_iterator_object
*typy_iter_obj
;
1252 /* Check that "self" is a structure or union type. */
1253 if (typy_get_composite (((type_object
*) self
)->type
) == NULL
)
1256 typy_iter_obj
= PyObject_New (typy_iterator_object
,
1257 &type_iterator_object_type
);
1258 if (typy_iter_obj
== NULL
)
1261 typy_iter_obj
->field
= 0;
1262 typy_iter_obj
->kind
= kind
;
1264 typy_iter_obj
->source
= (type_object
*) self
;
1266 return (PyObject
*) typy_iter_obj
;
1269 /* iteritems() method. */
1272 typy_iteritems (PyObject
*self
, PyObject
*args
)
1274 return typy_make_iter (self
, iter_items
);
1277 /* iterkeys() method. */
1280 typy_iterkeys (PyObject
*self
, PyObject
*args
)
1282 return typy_make_iter (self
, iter_keys
);
1285 /* Iterating over the class, same as iterkeys except for the function
1289 typy_iter (PyObject
*self
)
1291 return typy_make_iter (self
, iter_keys
);
1294 /* itervalues() method. */
1297 typy_itervalues (PyObject
*self
, PyObject
*args
)
1299 return typy_make_iter (self
, iter_values
);
1302 /* Return a reference to the type iterator. */
1305 typy_iterator_iter (PyObject
*self
)
1311 /* Return the next field in the iteration through the list of fields
1315 typy_iterator_iternext (PyObject
*self
)
1317 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) self
;
1318 struct type
*type
= iter_obj
->source
->type
;
1320 if (iter_obj
->field
< TYPE_NFIELDS (type
))
1322 gdbpy_ref
<> result
= make_fielditem (type
, iter_obj
->field
,
1326 return result
.release ();
1333 typy_iterator_dealloc (PyObject
*obj
)
1335 typy_iterator_object
*iter_obj
= (typy_iterator_object
*) obj
;
1337 Py_DECREF (iter_obj
->source
);
1340 /* Create a new Type referring to TYPE. */
1342 type_to_type_object (struct type
*type
)
1344 type_object
*type_obj
;
1346 type_obj
= PyObject_New (type_object
, &type_object_type
);
1348 set_type (type_obj
, type
);
1350 return (PyObject
*) type_obj
;
1354 type_object_to_type (PyObject
*obj
)
1356 if (! PyObject_TypeCheck (obj
, &type_object_type
))
1358 return ((type_object
*) obj
)->type
;
1363 /* Implementation of gdb.lookup_type. */
1365 gdbpy_lookup_type (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1367 static const char *keywords
[] = { "name", "block", NULL
};
1368 const char *type_name
= NULL
;
1369 struct type
*type
= NULL
;
1370 PyObject
*block_obj
= NULL
;
1371 const struct block
*block
= NULL
;
1373 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O", keywords
,
1374 &type_name
, &block_obj
))
1379 block
= block_object_to_block (block_obj
);
1382 PyErr_SetString (PyExc_RuntimeError
,
1383 _("'block' argument must be a Block."));
1388 type
= typy_lookup_typename (type_name
, block
);
1392 return type_to_type_object (type
);
1396 gdbpy_initialize_types (void)
1400 typy_objfile_data_key
1401 = register_objfile_data_with_cleanup (save_objfile_types
, NULL
);
1403 if (PyType_Ready (&type_object_type
) < 0)
1405 if (PyType_Ready (&field_object_type
) < 0)
1407 if (PyType_Ready (&type_iterator_object_type
) < 0)
1410 for (i
= 0; pyty_codes
[i
].name
; ++i
)
1412 if (PyModule_AddIntConstant (gdb_module
,
1413 /* Cast needed for Python 2.4. */
1414 (char *) pyty_codes
[i
].name
,
1415 pyty_codes
[i
].code
) < 0)
1419 if (gdb_pymodule_addobject (gdb_module
, "Type",
1420 (PyObject
*) &type_object_type
) < 0)
1423 if (gdb_pymodule_addobject (gdb_module
, "TypeIterator",
1424 (PyObject
*) &type_iterator_object_type
) < 0)
1427 return gdb_pymodule_addobject (gdb_module
, "Field",
1428 (PyObject
*) &field_object_type
);
1433 static gdb_PyGetSetDef type_object_getset
[] =
1435 { "alignof", typy_get_alignof
, NULL
,
1436 "The alignment of this type, in bytes.", NULL
},
1437 { "code", typy_get_code
, NULL
,
1438 "The code for this type.", NULL
},
1439 { "name", typy_get_name
, NULL
,
1440 "The name for this type, or None.", NULL
},
1441 { "sizeof", typy_get_sizeof
, NULL
,
1442 "The size of this type, in bytes.", NULL
},
1443 { "tag", typy_get_tag
, NULL
,
1444 "The tag name for this type, or None.", NULL
},
1448 static PyMethodDef type_object_methods
[] =
1450 { "array", typy_array
, METH_VARARGS
,
1451 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1452 Return a type which represents an array of objects of this type.\n\
1453 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1454 If LOW_BOUND is omitted, a value of zero is used." },
1455 { "vector", typy_vector
, METH_VARARGS
,
1456 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1457 Return a type which represents a vector of objects of this type.\n\
1458 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1459 If LOW_BOUND is omitted, a value of zero is used.\n\
1460 Vectors differ from arrays in that if the current language has C-style\n\
1461 arrays, vectors don't decay to a pointer to the first element.\n\
1462 They are first class values." },
1463 { "__contains__", typy_has_key
, METH_VARARGS
,
1464 "T.__contains__(k) -> True if T has a field named k, else False" },
1465 { "const", typy_const
, METH_NOARGS
,
1466 "const () -> Type\n\
1467 Return a const variant of this type." },
1468 { "optimized_out", typy_optimized_out
, METH_NOARGS
,
1469 "optimized_out() -> Value\n\
1470 Return optimized out value of this type." },
1471 { "fields", typy_fields
, METH_NOARGS
,
1472 "fields () -> list\n\
1473 Return a list holding all the fields of this type.\n\
1474 Each field is a gdb.Field object." },
1475 { "get", typy_get
, METH_VARARGS
,
1476 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1477 otherwise returns default, if supplied, or None if not." },
1478 { "has_key", typy_has_key
, METH_VARARGS
,
1479 "T.has_key(k) -> True if T has a field named k, else False" },
1480 { "items", typy_items
, METH_NOARGS
,
1481 "items () -> list\n\
1482 Return a list of (name, field) pairs of this type.\n\
1483 Each field is a gdb.Field object." },
1484 { "iteritems", typy_iteritems
, METH_NOARGS
,
1485 "iteritems () -> an iterator over the (name, field)\n\
1486 pairs of this type. Each field is a gdb.Field object." },
1487 { "iterkeys", typy_iterkeys
, METH_NOARGS
,
1488 "iterkeys () -> an iterator over the field names of this type." },
1489 { "itervalues", typy_itervalues
, METH_NOARGS
,
1490 "itervalues () -> an iterator over the fields of this type.\n\
1491 Each field is a gdb.Field object." },
1492 { "keys", typy_field_names
, METH_NOARGS
,
1494 Return a list holding all the fields names of this type." },
1495 { "pointer", typy_pointer
, METH_NOARGS
,
1496 "pointer () -> Type\n\
1497 Return a type of pointer to this type." },
1498 { "range", typy_range
, METH_NOARGS
,
1499 "range () -> tuple\n\
1500 Return a tuple containing the lower and upper range for this type."},
1501 { "reference", typy_reference
, METH_NOARGS
,
1502 "reference () -> Type\n\
1503 Return a type of reference to this type." },
1504 { "strip_typedefs", typy_strip_typedefs
, METH_NOARGS
,
1505 "strip_typedefs () -> Type\n\
1506 Return a type formed by stripping this type of all typedefs."},
1507 { "target", typy_target
, METH_NOARGS
,
1508 "target () -> Type\n\
1509 Return the target type of this type." },
1510 { "template_argument", typy_template_argument
, METH_VARARGS
,
1511 "template_argument (arg, [block]) -> Type\n\
1512 Return the type of a template argument." },
1513 { "unqualified", typy_unqualified
, METH_NOARGS
,
1514 "unqualified () -> Type\n\
1515 Return a variant of this type without const or volatile attributes." },
1516 { "values", typy_values
, METH_NOARGS
,
1517 "values () -> list\n\
1518 Return a list holding all the fields of this type.\n\
1519 Each field is a gdb.Field object." },
1520 { "volatile", typy_volatile
, METH_NOARGS
,
1521 "volatile () -> Type\n\
1522 Return a volatile variant of this type" },
1526 static PyNumberMethods type_object_as_number
= {
1528 NULL
, /* nb_subtract */
1529 NULL
, /* nb_multiply */
1531 NULL
, /* nb_divide */
1533 NULL
, /* nb_remainder */
1534 NULL
, /* nb_divmod */
1535 NULL
, /* nb_power */
1536 NULL
, /* nb_negative */
1537 NULL
, /* nb_positive */
1538 NULL
, /* nb_absolute */
1539 typy_nonzero
, /* nb_nonzero */
1540 NULL
, /* nb_invert */
1541 NULL
, /* nb_lshift */
1542 NULL
, /* nb_rshift */
1548 NULL
, /* reserved */
1550 NULL
, /* nb_coerce */
1554 NULL
, /* nb_float */
1561 static PyMappingMethods typy_mapping
= {
1564 NULL
/* no "set" method */
1567 PyTypeObject type_object_type
=
1569 PyVarObject_HEAD_INIT (NULL
, 0)
1570 "gdb.Type", /*tp_name*/
1571 sizeof (type_object
), /*tp_basicsize*/
1573 typy_dealloc
, /*tp_dealloc*/
1579 &type_object_as_number
, /*tp_as_number*/
1580 0, /*tp_as_sequence*/
1581 &typy_mapping
, /*tp_as_mapping*/
1584 typy_str
, /*tp_str*/
1588 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1589 "GDB type object", /* tp_doc */
1590 0, /* tp_traverse */
1592 typy_richcompare
, /* tp_richcompare */
1593 0, /* tp_weaklistoffset */
1594 typy_iter
, /* tp_iter */
1595 0, /* tp_iternext */
1596 type_object_methods
, /* tp_methods */
1598 type_object_getset
, /* tp_getset */
1601 0, /* tp_descr_get */
1602 0, /* tp_descr_set */
1603 0, /* tp_dictoffset */
1609 static gdb_PyGetSetDef field_object_getset
[] =
1611 { "__dict__", gdb_py_generic_dict
, NULL
,
1612 "The __dict__ for this field.", &field_object_type
},
1616 PyTypeObject field_object_type
=
1618 PyVarObject_HEAD_INIT (NULL
, 0)
1619 "gdb.Field", /*tp_name*/
1620 sizeof (field_object
), /*tp_basicsize*/
1622 field_dealloc
, /*tp_dealloc*/
1629 0, /*tp_as_sequence*/
1630 0, /*tp_as_mapping*/
1637 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1638 "GDB field object", /* tp_doc */
1639 0, /* tp_traverse */
1641 0, /* tp_richcompare */
1642 0, /* tp_weaklistoffset */
1644 0, /* tp_iternext */
1647 field_object_getset
, /* tp_getset */
1650 0, /* tp_descr_get */
1651 0, /* tp_descr_set */
1652 offsetof (field_object
, dict
), /* tp_dictoffset */
1658 PyTypeObject type_iterator_object_type
= {
1659 PyVarObject_HEAD_INIT (NULL
, 0)
1660 "gdb.TypeIterator", /*tp_name*/
1661 sizeof (typy_iterator_object
), /*tp_basicsize*/
1663 typy_iterator_dealloc
, /*tp_dealloc*/
1670 0, /*tp_as_sequence*/
1671 0, /*tp_as_mapping*/
1678 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /*tp_flags*/
1679 "GDB type iterator object", /*tp_doc */
1682 0, /*tp_richcompare */
1683 0, /*tp_weaklistoffset */
1684 typy_iterator_iter
, /*tp_iter */
1685 typy_iterator_iternext
, /*tp_iternext */