1 /* Python interface to values.
3 Copyright (C) 2008-2018 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/>. */
24 #include "target-float.h"
27 #include "expression.h"
31 #include "python-internal.h"
34 /* Even though Python scalar types directly map to host types, we use
35 target types here to remain consistent with the values system in
36 GDB (which uses target arithmetic). */
38 /* Python's integer type corresponds to C's long type. */
39 #define builtin_type_pyint builtin_type (python_gdbarch)->builtin_long
41 /* Python's float type corresponds to C's double type. */
42 #define builtin_type_pyfloat builtin_type (python_gdbarch)->builtin_double
44 /* Python's long type corresponds to C's long long type. */
45 #define builtin_type_pylong builtin_type (python_gdbarch)->builtin_long_long
47 /* Python's long type corresponds to C's long long type. Unsigned version. */
48 #define builtin_type_upylong builtin_type \
49 (python_gdbarch)->builtin_unsigned_long_long
51 #define builtin_type_pybool \
52 language_bool_type (python_language, python_gdbarch)
54 #define builtin_type_pychar \
55 language_string_char_type (python_language, python_gdbarch)
57 typedef struct value_object
{
59 struct value_object
*next
;
60 struct value_object
*prev
;
64 PyObject
*dynamic_type
;
67 /* List of all values which are currently exposed to Python. It is
68 maintained so that when an objfile is discarded, preserve_values
69 can copy the values' types if needed. */
70 /* This variable is unnecessarily initialized to NULL in order to
71 work around a linker bug on MacOS. */
72 static value_object
*values_in_python
= NULL
;
74 /* Called by the Python interpreter when deallocating a value object. */
76 valpy_dealloc (PyObject
*obj
)
78 value_object
*self
= (value_object
*) obj
;
80 /* Remove SELF from the global list. */
82 self
->prev
->next
= self
->next
;
85 gdb_assert (values_in_python
== self
);
86 values_in_python
= self
->next
;
89 self
->next
->prev
= self
->prev
;
91 value_decref (self
->value
);
94 /* Use braces to appease gcc warning. *sigh* */
96 Py_DECREF (self
->address
);
101 Py_DECREF (self
->type
);
104 Py_XDECREF (self
->dynamic_type
);
106 Py_TYPE (self
)->tp_free (self
);
109 /* Helper to push a Value object on the global list. */
111 note_value (value_object
*value_obj
)
113 value_obj
->next
= values_in_python
;
115 value_obj
->next
->prev
= value_obj
;
116 value_obj
->prev
= NULL
;
117 values_in_python
= value_obj
;
120 /* Called when a new gdb.Value object needs to be allocated. Returns NULL on
121 error, with a python exception set. */
123 valpy_new (PyTypeObject
*subtype
, PyObject
*args
, PyObject
*keywords
)
125 struct value
*value
= NULL
; /* Initialize to appease gcc warning. */
126 value_object
*value_obj
;
128 if (PyTuple_Size (args
) != 1)
130 PyErr_SetString (PyExc_TypeError
, _("Value object creation takes only "
135 value_obj
= (value_object
*) subtype
->tp_alloc (subtype
, 1);
136 if (value_obj
== NULL
)
138 PyErr_SetString (PyExc_MemoryError
, _("Could not allocate memory to "
139 "create Value object."));
143 value
= convert_value_from_python (PyTuple_GetItem (args
, 0));
146 subtype
->tp_free (value_obj
);
150 value_obj
->value
= release_value (value
).release ();
151 value_obj
->address
= NULL
;
152 value_obj
->type
= NULL
;
153 value_obj
->dynamic_type
= NULL
;
154 note_value (value_obj
);
156 return (PyObject
*) value_obj
;
159 /* Iterate over all the Value objects, calling preserve_one_value on
162 gdbpy_preserve_values (const struct extension_language_defn
*extlang
,
163 struct objfile
*objfile
, htab_t copied_types
)
167 for (iter
= values_in_python
; iter
; iter
= iter
->next
)
168 preserve_one_value (iter
->value
, objfile
, copied_types
);
171 /* Given a value of a pointer type, apply the C unary * operator to it. */
173 valpy_dereference (PyObject
*self
, PyObject
*args
)
175 PyObject
*result
= NULL
;
179 struct value
*res_val
;
180 scoped_value_mark free_values
;
182 res_val
= value_ind (((value_object
*) self
)->value
);
183 result
= value_to_value_object (res_val
);
185 CATCH (except
, RETURN_MASK_ALL
)
187 GDB_PY_HANDLE_EXCEPTION (except
);
194 /* Given a value of a pointer type or a reference type, return the value
195 referenced. The difference between this function and valpy_dereference is
196 that the latter applies * unary operator to a value, which need not always
197 result in the value referenced. For example, for a value which is a reference
198 to an 'int' pointer ('int *'), valpy_dereference will result in a value of
199 type 'int' while valpy_referenced_value will result in a value of type
203 valpy_referenced_value (PyObject
*self
, PyObject
*args
)
205 PyObject
*result
= NULL
;
209 struct value
*self_val
, *res_val
;
210 scoped_value_mark free_values
;
212 self_val
= ((value_object
*) self
)->value
;
213 switch (TYPE_CODE (check_typedef (value_type (self_val
))))
216 res_val
= value_ind (self_val
);
219 case TYPE_CODE_RVALUE_REF
:
220 res_val
= coerce_ref (self_val
);
223 error(_("Trying to get the referenced value from a value which is "
224 "neither a pointer nor a reference."));
227 result
= value_to_value_object (res_val
);
229 CATCH (except
, RETURN_MASK_ALL
)
231 GDB_PY_HANDLE_EXCEPTION (except
);
238 /* Return a value which is a reference to the value. */
241 valpy_reference_value (PyObject
*self
, PyObject
*args
, enum type_code refcode
)
243 PyObject
*result
= NULL
;
247 struct value
*self_val
;
248 scoped_value_mark free_values
;
250 self_val
= ((value_object
*) self
)->value
;
251 result
= value_to_value_object (value_ref (self_val
, refcode
));
253 CATCH (except
, RETURN_MASK_ALL
)
255 GDB_PY_HANDLE_EXCEPTION (except
);
263 valpy_lvalue_reference_value (PyObject
*self
, PyObject
*args
)
265 return valpy_reference_value (self
, args
, TYPE_CODE_REF
);
269 valpy_rvalue_reference_value (PyObject
*self
, PyObject
*args
)
271 return valpy_reference_value (self
, args
, TYPE_CODE_RVALUE_REF
);
274 /* Return a "const" qualified version of the value. */
277 valpy_const_value (PyObject
*self
, PyObject
*args
)
279 PyObject
*result
= NULL
;
283 struct value
*self_val
, *res_val
;
284 scoped_value_mark free_values
;
286 self_val
= ((value_object
*) self
)->value
;
287 res_val
= make_cv_value (1, 0, self_val
);
288 result
= value_to_value_object (res_val
);
290 CATCH (except
, RETURN_MASK_ALL
)
292 GDB_PY_HANDLE_EXCEPTION (except
);
299 /* Return "&value". */
301 valpy_get_address (PyObject
*self
, void *closure
)
303 value_object
*val_obj
= (value_object
*) self
;
305 if (!val_obj
->address
)
309 struct value
*res_val
;
310 scoped_value_mark free_values
;
312 res_val
= value_addr (val_obj
->value
);
313 val_obj
->address
= value_to_value_object (res_val
);
315 CATCH (except
, RETURN_MASK_ALL
)
317 val_obj
->address
= Py_None
;
323 Py_XINCREF (val_obj
->address
);
325 return val_obj
->address
;
328 /* Return type of the value. */
330 valpy_get_type (PyObject
*self
, void *closure
)
332 value_object
*obj
= (value_object
*) self
;
336 obj
->type
= type_to_type_object (value_type (obj
->value
));
340 Py_INCREF (obj
->type
);
344 /* Return dynamic type of the value. */
347 valpy_get_dynamic_type (PyObject
*self
, void *closure
)
349 value_object
*obj
= (value_object
*) self
;
350 struct type
*type
= NULL
;
352 if (obj
->dynamic_type
!= NULL
)
354 Py_INCREF (obj
->dynamic_type
);
355 return obj
->dynamic_type
;
360 struct value
*val
= obj
->value
;
361 scoped_value_mark free_values
;
363 type
= value_type (val
);
364 type
= check_typedef (type
);
366 if (((TYPE_CODE (type
) == TYPE_CODE_PTR
) || TYPE_IS_REFERENCE (type
))
367 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
))
369 struct value
*target
;
370 int was_pointer
= TYPE_CODE (type
) == TYPE_CODE_PTR
;
373 target
= value_ind (val
);
375 target
= coerce_ref (val
);
376 type
= value_rtti_type (target
, NULL
, NULL
, NULL
);
381 type
= lookup_pointer_type (type
);
383 type
= lookup_lvalue_reference_type (type
);
386 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
387 type
= value_rtti_type (val
, NULL
, NULL
, NULL
);
390 /* Re-use object's static type. */
394 CATCH (except
, RETURN_MASK_ALL
)
396 GDB_PY_HANDLE_EXCEPTION (except
);
401 obj
->dynamic_type
= valpy_get_type (self
, NULL
);
403 obj
->dynamic_type
= type_to_type_object (type
);
405 Py_XINCREF (obj
->dynamic_type
);
406 return obj
->dynamic_type
;
409 /* Implementation of gdb.Value.lazy_string ([encoding] [, length]) ->
410 string. Return a PyObject representing a lazy_string_object type.
411 A lazy string is a pointer to a string with an optional encoding and
412 length. If ENCODING is not given, encoding is set to None. If an
413 ENCODING is provided the encoding parameter is set to ENCODING, but
414 the string is not encoded.
415 If LENGTH is provided then the length parameter is set to LENGTH.
416 Otherwise if the value is an array of known length then the array's length
417 is used. Otherwise the length will be set to -1 (meaning first null of
420 Note: In order to not break any existing uses this allows creating
421 lazy strings from anything. PR 20769. E.g.,
422 gdb.parse_and_eval("my_int_variable").lazy_string().
423 "It's easier to relax restrictions than it is to impose them after the
424 fact." So we should be flagging any unintended uses as errors, but it's
425 perhaps too late for that. */
428 valpy_lazy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
430 gdb_py_longest length
= -1;
431 struct value
*value
= ((value_object
*) self
)->value
;
432 const char *user_encoding
= NULL
;
433 static const char *keywords
[] = { "encoding", "length", NULL
};
434 PyObject
*str_obj
= NULL
;
436 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|s" GDB_PY_LL_ARG
,
437 keywords
, &user_encoding
, &length
))
442 PyErr_SetString (PyExc_ValueError
, _("Invalid length."));
448 scoped_value_mark free_values
;
449 struct type
*type
, *realtype
;
452 type
= value_type (value
);
453 realtype
= check_typedef (type
);
455 switch (TYPE_CODE (realtype
))
457 case TYPE_CODE_ARRAY
:
459 LONGEST array_length
= -1;
460 LONGEST low_bound
, high_bound
;
462 /* PR 20786: There's no way to specify an array of length zero.
463 Record a length of [0,-1] which is how Ada does it. Anything
464 we do is broken, but this one possible solution. */
465 if (get_array_bounds (realtype
, &low_bound
, &high_bound
))
466 array_length
= high_bound
- low_bound
+ 1;
468 length
= array_length
;
469 else if (array_length
== -1)
471 type
= lookup_array_range_type (TYPE_TARGET_TYPE (realtype
),
474 else if (length
!= array_length
)
476 /* We need to create a new array type with the
478 if (length
> array_length
)
479 error (_("Length is larger than array size."));
480 type
= lookup_array_range_type (TYPE_TARGET_TYPE (realtype
),
482 low_bound
+ length
- 1);
484 addr
= value_address (value
);
488 /* If a length is specified we defer creating an array of the
489 specified width until we need to. */
490 addr
= value_as_address (value
);
493 /* Should flag an error here. PR 20769. */
494 addr
= value_address (value
);
498 str_obj
= gdbpy_create_lazy_string_object (addr
, length
, user_encoding
,
501 CATCH (except
, RETURN_MASK_ALL
)
503 GDB_PY_HANDLE_EXCEPTION (except
);
510 /* Implementation of gdb.Value.string ([encoding] [, errors]
511 [, length]) -> string. Return Unicode string with value contents.
512 If ENCODING is not given, the string is assumed to be encoded in
513 the target's charset. If LENGTH is provided, only fetch string to
514 the length provided. */
517 valpy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
521 struct value
*value
= ((value_object
*) self
)->value
;
523 const char *encoding
= NULL
;
524 const char *errors
= NULL
;
525 const char *user_encoding
= NULL
;
526 const char *la_encoding
= NULL
;
527 struct type
*char_type
;
528 static const char *keywords
[] = { "encoding", "errors", "length", NULL
};
530 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|ssi", keywords
,
531 &user_encoding
, &errors
, &length
))
536 LA_GET_STRING (value
, &buffer
, &length
, &char_type
, &la_encoding
);
538 CATCH (except
, RETURN_MASK_ALL
)
540 GDB_PY_HANDLE_EXCEPTION (except
);
544 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: la_encoding
;
545 unicode
= PyUnicode_Decode ((const char *) buffer
,
546 length
* TYPE_LENGTH (char_type
),
553 /* A helper function that implements the various cast operators. */
556 valpy_do_cast (PyObject
*self
, PyObject
*args
, enum exp_opcode op
)
558 PyObject
*type_obj
, *result
= NULL
;
561 if (! PyArg_ParseTuple (args
, "O", &type_obj
))
564 type
= type_object_to_type (type_obj
);
567 PyErr_SetString (PyExc_RuntimeError
,
568 _("Argument must be a type."));
574 struct value
*val
= ((value_object
*) self
)->value
;
575 struct value
*res_val
;
576 scoped_value_mark free_values
;
578 if (op
== UNOP_DYNAMIC_CAST
)
579 res_val
= value_dynamic_cast (type
, val
);
580 else if (op
== UNOP_REINTERPRET_CAST
)
581 res_val
= value_reinterpret_cast (type
, val
);
584 gdb_assert (op
== UNOP_CAST
);
585 res_val
= value_cast (type
, val
);
588 result
= value_to_value_object (res_val
);
590 CATCH (except
, RETURN_MASK_ALL
)
592 GDB_PY_HANDLE_EXCEPTION (except
);
599 /* Implementation of the "cast" method. */
602 valpy_cast (PyObject
*self
, PyObject
*args
)
604 return valpy_do_cast (self
, args
, UNOP_CAST
);
607 /* Implementation of the "dynamic_cast" method. */
610 valpy_dynamic_cast (PyObject
*self
, PyObject
*args
)
612 return valpy_do_cast (self
, args
, UNOP_DYNAMIC_CAST
);
615 /* Implementation of the "reinterpret_cast" method. */
618 valpy_reinterpret_cast (PyObject
*self
, PyObject
*args
)
620 return valpy_do_cast (self
, args
, UNOP_REINTERPRET_CAST
);
624 valpy_length (PyObject
*self
)
626 /* We don't support getting the number of elements in a struct / class. */
627 PyErr_SetString (PyExc_NotImplementedError
,
628 _("Invalid operation on gdb.Value."));
632 /* Return 1 if the gdb.Field object FIELD is present in the value V.
633 Returns 0 otherwise. If any Python error occurs, -1 is returned. */
636 value_has_field (struct value
*v
, PyObject
*field
)
638 struct type
*parent_type
, *val_type
;
639 enum type_code type_code
;
640 gdbpy_ref
<> type_object (PyObject_GetAttrString (field
, "parent_type"));
643 if (type_object
== NULL
)
646 parent_type
= type_object_to_type (type_object
.get ());
647 if (parent_type
== NULL
)
649 PyErr_SetString (PyExc_TypeError
,
650 _("'parent_type' attribute of gdb.Field object is not a"
651 "gdb.Type object."));
657 val_type
= value_type (v
);
658 val_type
= check_typedef (val_type
);
659 if (TYPE_IS_REFERENCE (val_type
) || TYPE_CODE (val_type
) == TYPE_CODE_PTR
)
660 val_type
= check_typedef (TYPE_TARGET_TYPE (val_type
));
662 type_code
= TYPE_CODE (val_type
);
663 if ((type_code
== TYPE_CODE_STRUCT
|| type_code
== TYPE_CODE_UNION
)
664 && types_equal (val_type
, parent_type
))
669 CATCH (except
, RETURN_MASK_ALL
)
671 GDB_PY_SET_HANDLE_EXCEPTION (except
);
678 /* Return the value of a flag FLAG_NAME in a gdb.Field object FIELD.
679 Returns 1 if the flag value is true, 0 if it is false, and -1 if
680 a Python error occurs. */
683 get_field_flag (PyObject
*field
, const char *flag_name
)
685 gdbpy_ref
<> flag_object (PyObject_GetAttrString (field
, flag_name
));
687 if (flag_object
== NULL
)
690 return PyObject_IsTrue (flag_object
.get ());
693 /* Return the "type" attribute of a gdb.Field object.
694 Returns NULL on error, with a Python exception set. */
697 get_field_type (PyObject
*field
)
699 gdbpy_ref
<> ftype_obj (PyObject_GetAttrString (field
, "type"));
702 if (ftype_obj
== NULL
)
704 ftype
= type_object_to_type (ftype_obj
.get ());
706 PyErr_SetString (PyExc_TypeError
,
707 _("'type' attribute of gdb.Field object is not a "
708 "gdb.Type object."));
713 /* Given string name or a gdb.Field object corresponding to an element inside
714 a structure, return its value object. Returns NULL on error, with a python
718 valpy_getitem (PyObject
*self
, PyObject
*key
)
720 struct gdb_exception except
= exception_none
;
721 value_object
*self_value
= (value_object
*) self
;
722 gdb::unique_xmalloc_ptr
<char> field
;
723 struct type
*base_class_type
= NULL
, *field_type
= NULL
;
725 PyObject
*result
= NULL
;
727 if (gdbpy_is_string (key
))
729 field
= python_string_to_host_string (key
);
733 else if (gdbpy_is_field (key
))
735 int is_base_class
, valid_field
;
737 valid_field
= value_has_field (self_value
->value
, key
);
740 else if (valid_field
== 0)
742 PyErr_SetString (PyExc_TypeError
,
743 _("Invalid lookup for a field not contained in "
749 is_base_class
= get_field_flag (key
, "is_base_class");
750 if (is_base_class
< 0)
752 else if (is_base_class
> 0)
754 base_class_type
= get_field_type (key
);
755 if (base_class_type
== NULL
)
760 gdbpy_ref
<> name_obj (PyObject_GetAttrString (key
, "name"));
762 if (name_obj
== NULL
)
765 if (name_obj
!= Py_None
)
767 field
= python_string_to_host_string (name_obj
.get ());
773 if (!PyObject_HasAttrString (key
, "bitpos"))
775 PyErr_SetString (PyExc_AttributeError
,
776 _("gdb.Field object has no name and no "
777 "'bitpos' attribute."));
781 gdbpy_ref
<> bitpos_obj (PyObject_GetAttrString (key
, "bitpos"));
782 if (bitpos_obj
== NULL
)
784 if (!gdb_py_int_as_long (bitpos_obj
.get (), &bitpos
))
787 field_type
= get_field_type (key
);
788 if (field_type
== NULL
)
796 struct value
*tmp
= self_value
->value
;
797 struct value
*res_val
= NULL
;
798 scoped_value_mark free_values
;
801 res_val
= value_struct_elt (&tmp
, NULL
, field
.get (), NULL
,
802 "struct/class/union");
803 else if (bitpos
>= 0)
804 res_val
= value_struct_elt_bitpos (&tmp
, bitpos
, field_type
,
805 "struct/class/union");
806 else if (base_class_type
!= NULL
)
808 struct type
*val_type
;
810 val_type
= check_typedef (value_type (tmp
));
811 if (TYPE_CODE (val_type
) == TYPE_CODE_PTR
)
812 res_val
= value_cast (lookup_pointer_type (base_class_type
), tmp
);
813 else if (TYPE_CODE (val_type
) == TYPE_CODE_REF
)
814 res_val
= value_cast (lookup_lvalue_reference_type (base_class_type
),
816 else if (TYPE_CODE (val_type
) == TYPE_CODE_RVALUE_REF
)
817 res_val
= value_cast (lookup_rvalue_reference_type (base_class_type
),
820 res_val
= value_cast (base_class_type
, tmp
);
824 /* Assume we are attempting an array access, and let the
825 value code throw an exception if the index has an invalid
827 struct value
*idx
= convert_value_from_python (key
);
831 /* Check the value's type is something that can be accessed via
835 tmp
= coerce_ref (tmp
);
836 type
= check_typedef (value_type (tmp
));
837 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
838 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
839 error (_("Cannot subscript requested type."));
841 res_val
= value_subscript (tmp
, value_as_long (idx
));
846 result
= value_to_value_object (res_val
);
848 CATCH (ex
, RETURN_MASK_ALL
)
854 GDB_PY_HANDLE_EXCEPTION (except
);
860 valpy_setitem (PyObject
*self
, PyObject
*key
, PyObject
*value
)
862 PyErr_Format (PyExc_NotImplementedError
,
863 _("Setting of struct elements is not currently supported."));
867 /* Called by the Python interpreter to perform an inferior function
868 call on the value. Returns NULL on error, with a python exception set. */
870 valpy_call (PyObject
*self
, PyObject
*args
, PyObject
*keywords
)
872 Py_ssize_t args_count
;
873 struct value
*function
= ((value_object
*) self
)->value
;
874 struct value
**vargs
= NULL
;
875 struct type
*ftype
= NULL
;
876 PyObject
*result
= NULL
;
880 ftype
= check_typedef (value_type (function
));
882 CATCH (except
, RETURN_MASK_ALL
)
884 GDB_PY_HANDLE_EXCEPTION (except
);
888 if (TYPE_CODE (ftype
) != TYPE_CODE_FUNC
)
890 PyErr_SetString (PyExc_RuntimeError
,
891 _("Value is not callable (not TYPE_CODE_FUNC)."));
895 if (! PyTuple_Check (args
))
897 PyErr_SetString (PyExc_TypeError
,
898 _("Inferior arguments must be provided in a tuple."));
902 args_count
= PyTuple_Size (args
);
907 vargs
= XALLOCAVEC (struct value
*, args_count
);
908 for (i
= 0; i
< args_count
; i
++)
910 PyObject
*item
= PyTuple_GetItem (args
, i
);
915 vargs
[i
] = convert_value_from_python (item
);
916 if (vargs
[i
] == NULL
)
923 scoped_value_mark free_values
;
924 struct value
*return_value
;
926 return_value
= call_function_by_hand (function
, NULL
,
928 result
= value_to_value_object (return_value
);
930 CATCH (except
, RETURN_MASK_ALL
)
932 GDB_PY_HANDLE_EXCEPTION (except
);
939 /* Called by the Python interpreter to obtain string representation
942 valpy_str (PyObject
*self
)
944 struct value_print_options opts
;
946 get_user_print_options (&opts
);
953 common_val_print (((value_object
*) self
)->value
, &stb
, 0,
954 &opts
, python_language
);
956 CATCH (except
, RETURN_MASK_ALL
)
958 GDB_PY_HANDLE_EXCEPTION (except
);
962 return PyUnicode_Decode (stb
.c_str (), stb
.size (), host_charset (), NULL
);
965 /* Implements gdb.Value.is_optimized_out. */
967 valpy_get_is_optimized_out (PyObject
*self
, void *closure
)
969 struct value
*value
= ((value_object
*) self
)->value
;
974 opt
= value_optimized_out (value
);
976 CATCH (except
, RETURN_MASK_ALL
)
978 GDB_PY_HANDLE_EXCEPTION (except
);
988 /* Implements gdb.Value.is_lazy. */
990 valpy_get_is_lazy (PyObject
*self
, void *closure
)
992 struct value
*value
= ((value_object
*) self
)->value
;
997 opt
= value_lazy (value
);
999 CATCH (except
, RETURN_MASK_ALL
)
1001 GDB_PY_HANDLE_EXCEPTION (except
);
1011 /* Implements gdb.Value.fetch_lazy (). */
1013 valpy_fetch_lazy (PyObject
*self
, PyObject
*args
)
1015 struct value
*value
= ((value_object
*) self
)->value
;
1019 if (value_lazy (value
))
1020 value_fetch_lazy (value
);
1022 CATCH (except
, RETURN_MASK_ALL
)
1024 GDB_PY_HANDLE_EXCEPTION (except
);
1031 /* Calculate and return the address of the PyObject as the value of
1032 the builtin __hash__ call. */
1034 valpy_hash (PyObject
*self
)
1036 return (intptr_t) self
;
1054 /* If TYPE is a reference, return the target; otherwise return TYPE. */
1055 #define STRIP_REFERENCE(TYPE) \
1056 (TYPE_IS_REFERENCE (TYPE) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
1058 /* Helper for valpy_binop. Returns a value object which is the result
1059 of applying the operation specified by OPCODE to the given
1060 arguments. Throws a GDB exception on error. */
1063 valpy_binop_throw (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
1065 PyObject
*result
= NULL
;
1067 struct value
*arg1
, *arg2
;
1068 struct value
*res_val
= NULL
;
1069 enum exp_opcode op
= OP_NULL
;
1072 scoped_value_mark free_values
;
1074 /* If the gdb.Value object is the second operand, then it will be
1075 passed to us as the OTHER argument, and SELF will be an entirely
1076 different kind of object, altogether. Because of this, we can't
1077 assume self is a gdb.Value object and need to convert it from
1079 arg1
= convert_value_from_python (self
);
1083 arg2
= convert_value_from_python (other
);
1091 struct type
*ltype
= value_type (arg1
);
1092 struct type
*rtype
= value_type (arg2
);
1094 ltype
= check_typedef (ltype
);
1095 ltype
= STRIP_REFERENCE (ltype
);
1096 rtype
= check_typedef (rtype
);
1097 rtype
= STRIP_REFERENCE (rtype
);
1100 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
1101 && is_integral_type (rtype
))
1102 res_val
= value_ptradd (arg1
, value_as_long (arg2
));
1103 else if (TYPE_CODE (rtype
) == TYPE_CODE_PTR
1104 && is_integral_type (ltype
))
1105 res_val
= value_ptradd (arg2
, value_as_long (arg1
));
1115 struct type
*ltype
= value_type (arg1
);
1116 struct type
*rtype
= value_type (arg2
);
1118 ltype
= check_typedef (ltype
);
1119 ltype
= STRIP_REFERENCE (ltype
);
1120 rtype
= check_typedef (rtype
);
1121 rtype
= STRIP_REFERENCE (rtype
);
1124 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
1125 && TYPE_CODE (rtype
) == TYPE_CODE_PTR
)
1126 /* A ptrdiff_t for the target would be preferable here. */
1127 res_val
= value_from_longest (builtin_type_pyint
,
1128 value_ptrdiff (arg1
, arg2
));
1129 else if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
1130 && is_integral_type (rtype
))
1131 res_val
= value_ptradd (arg1
, - value_as_long (arg2
));
1158 op
= BINOP_BITWISE_AND
;
1161 op
= BINOP_BITWISE_IOR
;
1164 op
= BINOP_BITWISE_XOR
;
1170 if (binop_user_defined_p (op
, arg1
, arg2
))
1171 res_val
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, EVAL_NORMAL
);
1173 res_val
= value_binop (arg1
, arg2
, op
);
1177 result
= value_to_value_object (res_val
);
1182 /* Returns a value object which is the result of applying the operation
1183 specified by OPCODE to the given arguments. Returns NULL on error, with
1184 a python exception set. */
1186 valpy_binop (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
1188 PyObject
*result
= NULL
;
1192 result
= valpy_binop_throw (opcode
, self
, other
);
1194 CATCH (except
, RETURN_MASK_ALL
)
1196 GDB_PY_HANDLE_EXCEPTION (except
);
1204 valpy_add (PyObject
*self
, PyObject
*other
)
1206 return valpy_binop (VALPY_ADD
, self
, other
);
1210 valpy_subtract (PyObject
*self
, PyObject
*other
)
1212 return valpy_binop (VALPY_SUB
, self
, other
);
1216 valpy_multiply (PyObject
*self
, PyObject
*other
)
1218 return valpy_binop (VALPY_MUL
, self
, other
);
1222 valpy_divide (PyObject
*self
, PyObject
*other
)
1224 return valpy_binop (VALPY_DIV
, self
, other
);
1228 valpy_remainder (PyObject
*self
, PyObject
*other
)
1230 return valpy_binop (VALPY_REM
, self
, other
);
1234 valpy_power (PyObject
*self
, PyObject
*other
, PyObject
*unused
)
1236 /* We don't support the ternary form of pow. I don't know how to express
1237 that, so let's just throw NotImplementedError to at least do something
1239 if (unused
!= Py_None
)
1241 PyErr_SetString (PyExc_NotImplementedError
,
1242 "Invalid operation on gdb.Value.");
1246 return valpy_binop (VALPY_POW
, self
, other
);
1250 valpy_negative (PyObject
*self
)
1252 PyObject
*result
= NULL
;
1256 /* Perhaps overkill, but consistency has some virtue. */
1257 scoped_value_mark free_values
;
1260 val
= value_neg (((value_object
*) self
)->value
);
1261 result
= value_to_value_object (val
);
1263 CATCH (except
, RETURN_MASK_ALL
)
1265 GDB_PY_HANDLE_EXCEPTION (except
);
1273 valpy_positive (PyObject
*self
)
1275 return value_to_value_object (((value_object
*) self
)->value
);
1279 valpy_absolute (PyObject
*self
)
1281 struct value
*value
= ((value_object
*) self
)->value
;
1286 scoped_value_mark free_values
;
1288 if (value_less (value
, value_zero (value_type (value
), not_lval
)))
1291 CATCH (except
, RETURN_MASK_ALL
)
1293 GDB_PY_HANDLE_EXCEPTION (except
);
1298 return valpy_positive (self
);
1300 return valpy_negative (self
);
1303 /* Implements boolean evaluation of gdb.Value. */
1305 valpy_nonzero (PyObject
*self
)
1307 struct gdb_exception except
= exception_none
;
1308 value_object
*self_value
= (value_object
*) self
;
1310 int nonzero
= 0; /* Appease GCC warning. */
1314 type
= check_typedef (value_type (self_value
->value
));
1316 if (is_integral_type (type
) || TYPE_CODE (type
) == TYPE_CODE_PTR
)
1317 nonzero
= !!value_as_long (self_value
->value
);
1318 else if (is_floating_value (self_value
->value
))
1319 nonzero
= !target_float_is_zero (value_contents (self_value
->value
),
1322 /* All other values are True. */
1325 CATCH (ex
, RETURN_MASK_ALL
)
1331 /* This is not documented in the Python documentation, but if this
1332 function fails, return -1 as slot_nb_nonzero does (the default
1333 Python nonzero function). */
1334 GDB_PY_SET_HANDLE_EXCEPTION (except
);
1339 /* Implements ~ for value objects. */
1341 valpy_invert (PyObject
*self
)
1343 struct value
*val
= NULL
;
1347 val
= value_complement (((value_object
*) self
)->value
);
1349 CATCH (except
, RETURN_MASK_ALL
)
1351 GDB_PY_HANDLE_EXCEPTION (except
);
1355 return value_to_value_object (val
);
1358 /* Implements left shift for value objects. */
1360 valpy_lsh (PyObject
*self
, PyObject
*other
)
1362 return valpy_binop (VALPY_LSH
, self
, other
);
1365 /* Implements right shift for value objects. */
1367 valpy_rsh (PyObject
*self
, PyObject
*other
)
1369 return valpy_binop (VALPY_RSH
, self
, other
);
1372 /* Implements bitwise and for value objects. */
1374 valpy_and (PyObject
*self
, PyObject
*other
)
1376 return valpy_binop (VALPY_BITAND
, self
, other
);
1379 /* Implements bitwise or for value objects. */
1381 valpy_or (PyObject
*self
, PyObject
*other
)
1383 return valpy_binop (VALPY_BITOR
, self
, other
);
1386 /* Implements bitwise xor for value objects. */
1388 valpy_xor (PyObject
*self
, PyObject
*other
)
1390 return valpy_binop (VALPY_BITXOR
, self
, other
);
1393 /* Helper for valpy_richcompare. Implements comparison operations for
1394 value objects. Returns true/false on success. Returns -1 with a
1395 Python exception set if a Python error is detected. Throws a GDB
1396 exception on other errors (memory error, etc.). */
1399 valpy_richcompare_throw (PyObject
*self
, PyObject
*other
, int op
)
1402 struct value
*value_other
;
1403 struct value
*value_self
;
1405 scoped_value_mark free_values
;
1407 value_other
= convert_value_from_python (other
);
1408 if (value_other
== NULL
)
1411 value_self
= ((value_object
*) self
)->value
;
1416 result
= value_less (value_self
, value_other
);
1419 result
= value_less (value_self
, value_other
)
1420 || value_equal (value_self
, value_other
);
1423 result
= value_equal (value_self
, value_other
);
1426 result
= !value_equal (value_self
, value_other
);
1429 result
= value_less (value_other
, value_self
);
1432 result
= (value_less (value_other
, value_self
)
1433 || value_equal (value_self
, value_other
));
1437 PyErr_SetString (PyExc_NotImplementedError
,
1438 _("Invalid operation on gdb.Value."));
1447 /* Implements comparison operations for value objects. Returns NULL on error,
1448 with a python exception set. */
1450 valpy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1454 if (other
== Py_None
)
1455 /* Comparing with None is special. From what I can tell, in Python
1456 None is smaller than anything else. */
1468 PyErr_SetString (PyExc_NotImplementedError
,
1469 _("Invalid operation on gdb.Value."));
1475 result
= valpy_richcompare_throw (self
, other
, op
);
1477 CATCH (except
, RETURN_MASK_ALL
)
1479 GDB_PY_HANDLE_EXCEPTION (except
);
1483 /* In this case, the Python exception has already been set. */
1494 /* Implements conversion to int. */
1496 valpy_int (PyObject
*self
)
1498 struct value
*value
= ((value_object
*) self
)->value
;
1499 struct type
*type
= value_type (value
);
1504 if (!is_integral_type (type
))
1505 error (_("Cannot convert value to int."));
1507 l
= value_as_long (value
);
1509 CATCH (except
, RETURN_MASK_ALL
)
1511 GDB_PY_HANDLE_EXCEPTION (except
);
1515 return gdb_py_object_from_longest (l
);
1519 /* Implements conversion to long. */
1521 valpy_long (PyObject
*self
)
1523 struct value
*value
= ((value_object
*) self
)->value
;
1524 struct type
*type
= value_type (value
);
1529 type
= check_typedef (type
);
1531 if (!is_integral_type (type
)
1532 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1533 error (_("Cannot convert value to long."));
1535 l
= value_as_long (value
);
1537 CATCH (except
, RETURN_MASK_ALL
)
1539 GDB_PY_HANDLE_EXCEPTION (except
);
1543 if (TYPE_UNSIGNED (type
))
1544 return gdb_py_long_from_ulongest (l
);
1546 return gdb_py_long_from_longest (l
);
1549 /* Implements conversion to float. */
1551 valpy_float (PyObject
*self
)
1553 struct value
*value
= ((value_object
*) self
)->value
;
1554 struct type
*type
= value_type (value
);
1559 type
= check_typedef (type
);
1561 if (TYPE_CODE (type
) != TYPE_CODE_FLT
|| !is_floating_value (value
))
1562 error (_("Cannot convert value to float."));
1564 d
= target_float_to_host_double (value_contents (value
), type
);
1566 CATCH (except
, RETURN_MASK_ALL
)
1568 GDB_PY_HANDLE_EXCEPTION (except
);
1572 return PyFloat_FromDouble (d
);
1575 /* Returns an object for a value which is released from the all_values chain,
1576 so its lifetime is not bound to the execution of a command. */
1578 value_to_value_object (struct value
*val
)
1580 value_object
*val_obj
;
1582 val_obj
= PyObject_New (value_object
, &value_object_type
);
1583 if (val_obj
!= NULL
)
1585 val_obj
->value
= release_value (val
).release ();
1586 val_obj
->address
= NULL
;
1587 val_obj
->type
= NULL
;
1588 val_obj
->dynamic_type
= NULL
;
1589 note_value (val_obj
);
1592 return (PyObject
*) val_obj
;
1595 /* Returns a borrowed reference to the struct value corresponding to
1596 the given value object. */
1598 value_object_to_value (PyObject
*self
)
1602 if (! PyObject_TypeCheck (self
, &value_object_type
))
1604 real
= (value_object
*) self
;
1608 /* Try to convert a Python value to a gdb value. If the value cannot
1609 be converted, set a Python exception and return NULL. Returns a
1610 reference to a new value on the all_values chain. */
1613 convert_value_from_python (PyObject
*obj
)
1615 struct value
*value
= NULL
; /* -Wall */
1618 gdb_assert (obj
!= NULL
);
1622 if (PyBool_Check (obj
))
1624 cmp
= PyObject_IsTrue (obj
);
1626 value
= value_from_longest (builtin_type_pybool
, cmp
);
1628 /* Make a long logic check first. In Python 3.x, internally,
1629 all integers are represented as longs. In Python 2.x, there
1630 is still a differentiation internally between a PyInt and a
1631 PyLong. Explicitly do this long check conversion first. In
1632 GDB, for Python 3.x, we #ifdef PyInt = PyLong. This check has
1633 to be done first to ensure we do not lose information in the
1634 conversion process. */
1635 else if (PyLong_Check (obj
))
1637 LONGEST l
= PyLong_AsLongLong (obj
);
1639 if (PyErr_Occurred ())
1641 /* If the error was an overflow, we can try converting to
1642 ULONGEST instead. */
1643 if (PyErr_ExceptionMatches (PyExc_OverflowError
))
1645 PyObject
*etype
, *evalue
, *etraceback
;
1647 PyErr_Fetch (&etype
, &evalue
, &etraceback
);
1648 gdbpy_ref
<> zero (PyInt_FromLong (0));
1650 /* Check whether obj is positive. */
1651 if (PyObject_RichCompareBool (obj
, zero
.get (), Py_GT
) > 0)
1655 ul
= PyLong_AsUnsignedLongLong (obj
);
1656 if (! PyErr_Occurred ())
1657 value
= value_from_ulongest (builtin_type_upylong
, ul
);
1660 /* There's nothing we can do. */
1661 PyErr_Restore (etype
, evalue
, etraceback
);
1665 value
= value_from_longest (builtin_type_pylong
, l
);
1667 #if PY_MAJOR_VERSION == 2
1668 else if (PyInt_Check (obj
))
1670 long l
= PyInt_AsLong (obj
);
1672 if (! PyErr_Occurred ())
1673 value
= value_from_longest (builtin_type_pyint
, l
);
1676 else if (PyFloat_Check (obj
))
1678 double d
= PyFloat_AsDouble (obj
);
1680 if (! PyErr_Occurred ())
1682 value
= allocate_value (builtin_type_pyfloat
);
1683 target_float_from_host_double (value_contents_raw (value
),
1684 value_type (value
), d
);
1687 else if (gdbpy_is_string (obj
))
1689 gdb::unique_xmalloc_ptr
<char> s
1690 = python_string_to_target_string (obj
);
1692 value
= value_cstring (s
.get (), strlen (s
.get ()),
1693 builtin_type_pychar
);
1695 else if (PyObject_TypeCheck (obj
, &value_object_type
))
1696 value
= value_copy (((value_object
*) obj
)->value
);
1697 else if (gdbpy_is_lazy_string (obj
))
1701 result
= PyObject_CallMethodObjArgs (obj
, gdbpy_value_cst
, NULL
);
1702 value
= value_copy (((value_object
*) result
)->value
);
1706 PyErr_Format (PyExc_TypeError
,
1707 _("Could not convert Python object: %S."), obj
);
1709 PyErr_Format (PyExc_TypeError
,
1710 _("Could not convert Python object: %s."),
1711 PyString_AsString (PyObject_Str (obj
)));
1714 CATCH (except
, RETURN_MASK_ALL
)
1716 PyErr_Format (except
.reason
== RETURN_QUIT
1717 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
1718 "%s", except
.message
);
1726 /* Returns value object in the ARGth position in GDB's history. */
1728 gdbpy_history (PyObject
*self
, PyObject
*args
)
1731 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
1733 if (!PyArg_ParseTuple (args
, "i", &i
))
1738 res_val
= access_value_history (i
);
1740 CATCH (except
, RETURN_MASK_ALL
)
1742 GDB_PY_HANDLE_EXCEPTION (except
);
1746 return value_to_value_object (res_val
);
1749 /* Returns 1 in OBJ is a gdb.Value object, 0 otherwise. */
1752 gdbpy_is_value_object (PyObject
*obj
)
1754 return PyObject_TypeCheck (obj
, &value_object_type
);
1758 gdbpy_initialize_values (void)
1760 if (PyType_Ready (&value_object_type
) < 0)
1763 return gdb_pymodule_addobject (gdb_module
, "Value",
1764 (PyObject
*) &value_object_type
);
1769 static gdb_PyGetSetDef value_object_getset
[] = {
1770 { "address", valpy_get_address
, NULL
, "The address of the value.",
1772 { "is_optimized_out", valpy_get_is_optimized_out
, NULL
,
1773 "Boolean telling whether the value is optimized "
1774 "out (i.e., not available).",
1776 { "type", valpy_get_type
, NULL
, "Type of the value.", NULL
},
1777 { "dynamic_type", valpy_get_dynamic_type
, NULL
,
1778 "Dynamic type of the value.", NULL
},
1779 { "is_lazy", valpy_get_is_lazy
, NULL
,
1780 "Boolean telling whether the value is lazy (not fetched yet\n\
1781 from the inferior). A lazy value is fetched when needed, or when\n\
1782 the \"fetch_lazy()\" method is called.", NULL
},
1783 {NULL
} /* Sentinel */
1786 static PyMethodDef value_object_methods
[] = {
1787 { "cast", valpy_cast
, METH_VARARGS
, "Cast the value to the supplied type." },
1788 { "dynamic_cast", valpy_dynamic_cast
, METH_VARARGS
,
1789 "dynamic_cast (gdb.Type) -> gdb.Value\n\
1790 Cast the value to the supplied type, as if by the C++ dynamic_cast operator."
1792 { "reinterpret_cast", valpy_reinterpret_cast
, METH_VARARGS
,
1793 "reinterpret_cast (gdb.Type) -> gdb.Value\n\
1794 Cast the value to the supplied type, as if by the C++\n\
1795 reinterpret_cast operator."
1797 { "dereference", valpy_dereference
, METH_NOARGS
, "Dereferences the value." },
1798 { "referenced_value", valpy_referenced_value
, METH_NOARGS
,
1799 "Return the value referenced by a TYPE_CODE_REF or TYPE_CODE_PTR value." },
1800 { "reference_value", valpy_lvalue_reference_value
, METH_NOARGS
,
1801 "Return a value of type TYPE_CODE_REF referencing this value." },
1802 { "rvalue_reference_value", valpy_rvalue_reference_value
, METH_NOARGS
,
1803 "Return a value of type TYPE_CODE_RVALUE_REF referencing this value." },
1804 { "const_value", valpy_const_value
, METH_NOARGS
,
1805 "Return a 'const' qualied version of the same value." },
1806 { "lazy_string", (PyCFunction
) valpy_lazy_string
,
1807 METH_VARARGS
| METH_KEYWORDS
,
1808 "lazy_string ([encoding] [, length]) -> lazy_string\n\
1809 Return a lazy string representation of the value." },
1810 { "string", (PyCFunction
) valpy_string
, METH_VARARGS
| METH_KEYWORDS
,
1811 "string ([encoding] [, errors] [, length]) -> string\n\
1812 Return Unicode string representation of the value." },
1813 { "fetch_lazy", valpy_fetch_lazy
, METH_NOARGS
,
1814 "Fetches the value from the inferior, if it was lazy." },
1815 {NULL
} /* Sentinel */
1818 static PyNumberMethods value_object_as_number
= {
1826 NULL
, /* nb_divmod */
1827 valpy_power
, /* nb_power */
1828 valpy_negative
, /* nb_negative */
1829 valpy_positive
, /* nb_positive */
1830 valpy_absolute
, /* nb_absolute */
1831 valpy_nonzero
, /* nb_nonzero */
1832 valpy_invert
, /* nb_invert */
1833 valpy_lsh
, /* nb_lshift */
1834 valpy_rsh
, /* nb_rshift */
1835 valpy_and
, /* nb_and */
1836 valpy_xor
, /* nb_xor */
1837 valpy_or
, /* nb_or */
1839 valpy_long
, /* nb_int */
1840 NULL
, /* reserved */
1842 NULL
, /* nb_coerce */
1843 valpy_int
, /* nb_int */
1844 valpy_long
, /* nb_long */
1846 valpy_float
, /* nb_float */
1851 NULL
, /* nb_inplace_add */
1852 NULL
, /* nb_inplace_subtract */
1853 NULL
, /* nb_inplace_multiply */
1855 NULL
, /* nb_inplace_divide */
1857 NULL
, /* nb_inplace_remainder */
1858 NULL
, /* nb_inplace_power */
1859 NULL
, /* nb_inplace_lshift */
1860 NULL
, /* nb_inplace_rshift */
1861 NULL
, /* nb_inplace_and */
1862 NULL
, /* nb_inplace_xor */
1863 NULL
, /* nb_inplace_or */
1864 NULL
, /* nb_floor_divide */
1865 valpy_divide
, /* nb_true_divide */
1866 NULL
, /* nb_inplace_floor_divide */
1867 NULL
, /* nb_inplace_true_divide */
1868 #ifndef HAVE_LIBPYTHON2_4
1869 /* This was added in Python 2.5. */
1870 valpy_long
, /* nb_index */
1871 #endif /* HAVE_LIBPYTHON2_4 */
1874 static PyMappingMethods value_object_as_mapping
= {
1880 PyTypeObject value_object_type
= {
1881 PyVarObject_HEAD_INIT (NULL
, 0)
1882 "gdb.Value", /*tp_name*/
1883 sizeof (value_object
), /*tp_basicsize*/
1885 valpy_dealloc
, /*tp_dealloc*/
1891 &value_object_as_number
, /*tp_as_number*/
1892 0, /*tp_as_sequence*/
1893 &value_object_as_mapping
, /*tp_as_mapping*/
1894 valpy_hash
, /*tp_hash*/
1895 valpy_call
, /*tp_call*/
1896 valpy_str
, /*tp_str*/
1900 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
1901 | Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1902 "GDB value object", /* tp_doc */
1903 0, /* tp_traverse */
1905 valpy_richcompare
, /* tp_richcompare */
1906 0, /* tp_weaklistoffset */
1908 0, /* tp_iternext */
1909 value_object_methods
, /* tp_methods */
1911 value_object_getset
, /* tp_getset */
1914 0, /* tp_descr_get */
1915 0, /* tp_descr_set */
1916 0, /* tp_dictoffset */
1919 valpy_new
/* tp_new */