1 /* Python interface to values.
3 Copyright (C) 2008-2022 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"
33 /* Even though Python scalar types directly map to host types, we use
34 target types here to remain consistent with the values system in
35 GDB (which uses target arithmetic). */
37 /* Python's integer type corresponds to C's long type. */
38 #define builtin_type_pyint \
39 builtin_type (gdbpy_enter::get_gdbarch ())->builtin_long
41 /* Python's float type corresponds to C's double type. */
42 #define builtin_type_pyfloat \
43 builtin_type (gdbpy_enter::get_gdbarch ())->builtin_double
45 /* Python's long type corresponds to C's long long type. */
46 #define builtin_type_pylong \
47 builtin_type (gdbpy_enter::get_gdbarch ())->builtin_long_long
49 /* Python's long type corresponds to C's long long type. Unsigned version. */
50 #define builtin_type_upylong builtin_type \
51 (gdbpy_enter::get_gdbarch ())->builtin_unsigned_long_long
53 #define builtin_type_pybool \
54 language_bool_type (current_language, gdbpy_enter::get_gdbarch ())
56 #define builtin_type_pychar \
57 language_string_char_type (current_language, gdbpy_enter::get_gdbarch ())
61 struct value_object
*next
;
62 struct value_object
*prev
;
66 PyObject
*dynamic_type
;
69 /* List of all values which are currently exposed to Python. It is
70 maintained so that when an objfile is discarded, preserve_values
71 can copy the values' types if needed. */
72 /* This variable is unnecessarily initialized to NULL in order to
73 work around a linker bug on MacOS. */
74 static value_object
*values_in_python
= NULL
;
76 /* Clear out an old GDB value stored within SELF, and reset the fields to
77 nullptr. This should be called when a gdb.Value is deallocated, and
78 also if a gdb.Value is reinitialized with a new value. */
81 valpy_clear_value (value_object
*self
)
83 /* Indicate we are no longer interested in the value object. */
84 value_decref (self
->value
);
85 self
->value
= nullptr;
87 Py_CLEAR (self
->address
);
88 Py_CLEAR (self
->type
);
89 Py_CLEAR (self
->dynamic_type
);
92 /* Called by the Python interpreter when deallocating a value object. */
94 valpy_dealloc (PyObject
*obj
)
96 value_object
*self
= (value_object
*) obj
;
98 /* If SELF failed to initialize correctly then it may not have a value
99 contained within it. */
100 if (self
->value
!= nullptr)
102 /* Remove SELF from the global list of values. */
103 if (self
->prev
!= nullptr)
104 self
->prev
->next
= self
->next
;
107 gdb_assert (values_in_python
== self
);
108 values_in_python
= self
->next
;
110 if (self
->next
!= nullptr)
111 self
->next
->prev
= self
->prev
;
113 /* Release the value object and any cached Python objects. */
114 valpy_clear_value (self
);
117 Py_TYPE (self
)->tp_free (self
);
120 /* Helper to push a gdb.Value object on to the global list of values. If
121 VALUE_OBJ is already on the lit then this does nothing. */
124 note_value (value_object
*value_obj
)
126 if (value_obj
->next
== nullptr)
128 gdb_assert (value_obj
->prev
== nullptr);
129 value_obj
->next
= values_in_python
;
130 if (value_obj
->next
!= nullptr)
131 value_obj
->next
->prev
= value_obj
;
132 values_in_python
= value_obj
;
136 /* Convert a python object OBJ with type TYPE to a gdb value. The
137 python object in question must conform to the python buffer
138 protocol. On success, return the converted value, otherwise
141 static struct value
*
142 convert_buffer_and_type_to_value (PyObject
*obj
, struct type
*type
)
144 Py_buffer_up buffer_up
;
147 if (PyObject_CheckBuffer (obj
)
148 && PyObject_GetBuffer (obj
, &py_buf
, PyBUF_SIMPLE
) == 0)
150 /* Got a buffer, py_buf, out of obj. Cause it to be released
151 when it goes out of scope. */
152 buffer_up
.reset (&py_buf
);
156 PyErr_SetString (PyExc_TypeError
,
157 _("Object must support the python buffer protocol."));
161 if (TYPE_LENGTH (type
) > py_buf
.len
)
163 PyErr_SetString (PyExc_ValueError
,
164 _("Size of type is larger than that of buffer object."));
168 return value_from_contents (type
, (const gdb_byte
*) py_buf
.buf
);
171 /* Implement gdb.Value.__init__. */
174 valpy_init (PyObject
*self
, PyObject
*args
, PyObject
*kwds
)
176 static const char *keywords
[] = { "val", "type", NULL
};
177 PyObject
*val_obj
= nullptr;
178 PyObject
*type_obj
= nullptr;
180 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kwds
, "O|O", keywords
,
181 &val_obj
, &type_obj
))
184 struct type
*type
= nullptr;
185 if (type_obj
!= nullptr && type_obj
!= Py_None
)
187 type
= type_object_to_type (type_obj
);
190 PyErr_SetString (PyExc_TypeError
,
191 _("type argument must be a gdb.Type."));
198 value
= convert_value_from_python (val_obj
);
200 value
= convert_buffer_and_type_to_value (val_obj
, type
);
201 if (value
== nullptr)
203 gdb_assert (PyErr_Occurred ());
207 /* There might be a previous value here. */
208 value_object
*value_obj
= (value_object
*) self
;
209 if (value_obj
->value
!= nullptr)
210 valpy_clear_value (value_obj
);
212 /* Store the value into this Python object. */
213 value_obj
->value
= release_value (value
).release ();
215 /* Ensure that this gdb.Value is in the set of all gdb.Value objects. If
216 we are already in the set then this is call does nothing. */
217 note_value (value_obj
);
222 /* Iterate over all the Value objects, calling preserve_one_value on
225 gdbpy_preserve_values (const struct extension_language_defn
*extlang
,
226 struct objfile
*objfile
, htab_t copied_types
)
230 for (iter
= values_in_python
; iter
; iter
= iter
->next
)
231 preserve_one_value (iter
->value
, objfile
, copied_types
);
234 /* Given a value of a pointer type, apply the C unary * operator to it. */
236 valpy_dereference (PyObject
*self
, PyObject
*args
)
238 PyObject
*result
= NULL
;
242 struct value
*res_val
;
243 scoped_value_mark free_values
;
245 res_val
= value_ind (((value_object
*) self
)->value
);
246 result
= value_to_value_object (res_val
);
248 catch (const gdb_exception
&except
)
250 GDB_PY_HANDLE_EXCEPTION (except
);
256 /* Given a value of a pointer type or a reference type, return the value
257 referenced. The difference between this function and valpy_dereference is
258 that the latter applies * unary operator to a value, which need not always
259 result in the value referenced. For example, for a value which is a reference
260 to an 'int' pointer ('int *'), valpy_dereference will result in a value of
261 type 'int' while valpy_referenced_value will result in a value of type
265 valpy_referenced_value (PyObject
*self
, PyObject
*args
)
267 PyObject
*result
= NULL
;
271 struct value
*self_val
, *res_val
;
272 scoped_value_mark free_values
;
274 self_val
= ((value_object
*) self
)->value
;
275 switch (check_typedef (value_type (self_val
))->code ())
278 res_val
= value_ind (self_val
);
281 case TYPE_CODE_RVALUE_REF
:
282 res_val
= coerce_ref (self_val
);
285 error(_("Trying to get the referenced value from a value which is "
286 "neither a pointer nor a reference."));
289 result
= value_to_value_object (res_val
);
291 catch (const gdb_exception
&except
)
293 GDB_PY_HANDLE_EXCEPTION (except
);
299 /* Return a value which is a reference to the value. */
302 valpy_reference_value (PyObject
*self
, PyObject
*args
, enum type_code refcode
)
304 PyObject
*result
= NULL
;
308 struct value
*self_val
;
309 scoped_value_mark free_values
;
311 self_val
= ((value_object
*) self
)->value
;
312 result
= value_to_value_object (value_ref (self_val
, refcode
));
314 catch (const gdb_exception
&except
)
316 GDB_PY_HANDLE_EXCEPTION (except
);
323 valpy_lvalue_reference_value (PyObject
*self
, PyObject
*args
)
325 return valpy_reference_value (self
, args
, TYPE_CODE_REF
);
329 valpy_rvalue_reference_value (PyObject
*self
, PyObject
*args
)
331 return valpy_reference_value (self
, args
, TYPE_CODE_RVALUE_REF
);
334 /* Return a "const" qualified version of the value. */
337 valpy_const_value (PyObject
*self
, PyObject
*args
)
339 PyObject
*result
= NULL
;
343 struct value
*self_val
, *res_val
;
344 scoped_value_mark free_values
;
346 self_val
= ((value_object
*) self
)->value
;
347 res_val
= make_cv_value (1, 0, self_val
);
348 result
= value_to_value_object (res_val
);
350 catch (const gdb_exception
&except
)
352 GDB_PY_HANDLE_EXCEPTION (except
);
358 /* Return "&value". */
360 valpy_get_address (PyObject
*self
, void *closure
)
362 value_object
*val_obj
= (value_object
*) self
;
364 if (!val_obj
->address
)
368 struct value
*res_val
;
369 scoped_value_mark free_values
;
371 res_val
= value_addr (val_obj
->value
);
372 val_obj
->address
= value_to_value_object (res_val
);
374 catch (const gdb_exception
&except
)
376 val_obj
->address
= Py_None
;
381 Py_XINCREF (val_obj
->address
);
383 return val_obj
->address
;
386 /* Return type of the value. */
388 valpy_get_type (PyObject
*self
, void *closure
)
390 value_object
*obj
= (value_object
*) self
;
394 obj
->type
= type_to_type_object (value_type (obj
->value
));
398 Py_INCREF (obj
->type
);
402 /* Return dynamic type of the value. */
405 valpy_get_dynamic_type (PyObject
*self
, void *closure
)
407 value_object
*obj
= (value_object
*) self
;
408 struct type
*type
= NULL
;
410 if (obj
->dynamic_type
!= NULL
)
412 Py_INCREF (obj
->dynamic_type
);
413 return obj
->dynamic_type
;
418 struct value
*val
= obj
->value
;
419 scoped_value_mark free_values
;
421 type
= value_type (val
);
422 type
= check_typedef (type
);
424 if (type
->is_pointer_or_reference ()
425 && (TYPE_TARGET_TYPE (type
)->code () == TYPE_CODE_STRUCT
))
427 struct value
*target
;
428 int was_pointer
= type
->code () == TYPE_CODE_PTR
;
431 target
= value_ind (val
);
433 target
= coerce_ref (val
);
434 type
= value_rtti_type (target
, NULL
, NULL
, NULL
);
439 type
= lookup_pointer_type (type
);
441 type
= lookup_lvalue_reference_type (type
);
444 else if (type
->code () == TYPE_CODE_STRUCT
)
445 type
= value_rtti_type (val
, NULL
, NULL
, NULL
);
448 /* Re-use object's static type. */
452 catch (const gdb_exception
&except
)
454 GDB_PY_HANDLE_EXCEPTION (except
);
458 obj
->dynamic_type
= valpy_get_type (self
, NULL
);
460 obj
->dynamic_type
= type_to_type_object (type
);
462 Py_XINCREF (obj
->dynamic_type
);
463 return obj
->dynamic_type
;
466 /* Implementation of gdb.Value.lazy_string ([encoding] [, length]) ->
467 string. Return a PyObject representing a lazy_string_object type.
468 A lazy string is a pointer to a string with an optional encoding and
469 length. If ENCODING is not given, encoding is set to None. If an
470 ENCODING is provided the encoding parameter is set to ENCODING, but
471 the string is not encoded.
472 If LENGTH is provided then the length parameter is set to LENGTH.
473 Otherwise if the value is an array of known length then the array's length
474 is used. Otherwise the length will be set to -1 (meaning first null of
477 Note: In order to not break any existing uses this allows creating
478 lazy strings from anything. PR 20769. E.g.,
479 gdb.parse_and_eval("my_int_variable").lazy_string().
480 "It's easier to relax restrictions than it is to impose them after the
481 fact." So we should be flagging any unintended uses as errors, but it's
482 perhaps too late for that. */
485 valpy_lazy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
487 gdb_py_longest length
= -1;
488 struct value
*value
= ((value_object
*) self
)->value
;
489 const char *user_encoding
= NULL
;
490 static const char *keywords
[] = { "encoding", "length", NULL
};
491 PyObject
*str_obj
= NULL
;
493 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|s" GDB_PY_LL_ARG
,
494 keywords
, &user_encoding
, &length
))
499 PyErr_SetString (PyExc_ValueError
, _("Invalid length."));
505 scoped_value_mark free_values
;
506 struct type
*type
, *realtype
;
509 type
= value_type (value
);
510 realtype
= check_typedef (type
);
512 switch (realtype
->code ())
514 case TYPE_CODE_ARRAY
:
516 LONGEST array_length
= -1;
517 LONGEST low_bound
, high_bound
;
519 /* PR 20786: There's no way to specify an array of length zero.
520 Record a length of [0,-1] which is how Ada does it. Anything
521 we do is broken, but this one possible solution. */
522 if (get_array_bounds (realtype
, &low_bound
, &high_bound
))
523 array_length
= high_bound
- low_bound
+ 1;
525 length
= array_length
;
526 else if (array_length
== -1)
528 type
= lookup_array_range_type (TYPE_TARGET_TYPE (realtype
),
531 else if (length
!= array_length
)
533 /* We need to create a new array type with the
535 if (length
> array_length
)
536 error (_("Length is larger than array size."));
537 type
= lookup_array_range_type (TYPE_TARGET_TYPE (realtype
),
539 low_bound
+ length
- 1);
541 addr
= value_address (value
);
545 /* If a length is specified we defer creating an array of the
546 specified width until we need to. */
547 addr
= value_as_address (value
);
550 /* Should flag an error here. PR 20769. */
551 addr
= value_address (value
);
555 str_obj
= gdbpy_create_lazy_string_object (addr
, length
, user_encoding
,
558 catch (const gdb_exception
&except
)
560 GDB_PY_HANDLE_EXCEPTION (except
);
566 /* Implementation of gdb.Value.string ([encoding] [, errors]
567 [, length]) -> string. Return Unicode string with value contents.
568 If ENCODING is not given, the string is assumed to be encoded in
569 the target's charset. If LENGTH is provided, only fetch string to
570 the length provided. */
573 valpy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
576 gdb::unique_xmalloc_ptr
<gdb_byte
> buffer
;
577 struct value
*value
= ((value_object
*) self
)->value
;
578 const char *encoding
= NULL
;
579 const char *errors
= NULL
;
580 const char *user_encoding
= NULL
;
581 const char *la_encoding
= NULL
;
582 struct type
*char_type
;
583 static const char *keywords
[] = { "encoding", "errors", "length", NULL
};
585 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|ssi", keywords
,
586 &user_encoding
, &errors
, &length
))
591 c_get_string (value
, &buffer
, &length
, &char_type
, &la_encoding
);
593 catch (const gdb_exception
&except
)
595 GDB_PY_HANDLE_EXCEPTION (except
);
598 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: la_encoding
;
599 return PyUnicode_Decode ((const char *) buffer
.get (),
600 length
* TYPE_LENGTH (char_type
),
604 /* Given a Python object, copy its truth value to a C bool (the value
606 If src_obj is NULL, then *dest is not modified.
608 Return true in case of success (including src_obj being NULL), false
612 copy_py_bool_obj (bool *dest
, PyObject
*src_obj
)
616 int cmp
= PyObject_IsTrue (src_obj
);
625 /* Implementation of gdb.Value.format_string (...) -> string.
626 Return Unicode string with value contents formatted using the
627 keyword-only arguments. */
630 valpy_format_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
632 static const char *keywords
[] =
634 /* Basic C/C++ options. */
635 "raw", /* See the /r option to print. */
636 "pretty_arrays", /* See set print array on|off. */
637 "pretty_structs", /* See set print pretty on|off. */
638 "array_indexes", /* See set print array-indexes on|off. */
639 "symbols", /* See set print symbol on|off. */
640 "unions", /* See set print union on|off. */
641 "address", /* See set print address on|off. */
642 "styling", /* Should we apply styling. */
643 "nibbles", /* See set print nibbles on|off. */
645 "deref_refs", /* No corresponding setting. */
646 "actual_objects", /* See set print object on|off. */
647 "static_members", /* See set print static-members on|off. */
648 /* C non-bool options. */
649 "max_elements", /* See set print elements N. */
650 "max_depth", /* See set print max-depth N. */
651 "repeat_threshold", /* See set print repeats. */
652 "format", /* The format passed to the print command. */
656 /* This function has too many arguments to be useful as positionals, so
657 the user should specify them all as keyword arguments.
658 Python 3.3 and later have a way to specify it (both in C and Python
659 itself), but we could be compiled with older versions, so we just
660 check that the args tuple is empty. */
661 Py_ssize_t positional_count
= PyObject_Length (args
);
662 if (positional_count
< 0)
664 else if (positional_count
> 0)
666 /* This matches the error message that Python 3.3 raises when
667 passing positionals to functions expecting keyword-only
669 PyErr_Format (PyExc_TypeError
,
670 "format_string() takes 0 positional arguments but %zu were given",
675 struct value_print_options opts
;
676 gdbpy_get_print_options (&opts
);
679 /* We need objects for booleans as the "p" flag for bools is new in
681 PyObject
*raw_obj
= NULL
;
682 PyObject
*pretty_arrays_obj
= NULL
;
683 PyObject
*pretty_structs_obj
= NULL
;
684 PyObject
*array_indexes_obj
= NULL
;
685 PyObject
*symbols_obj
= NULL
;
686 PyObject
*unions_obj
= NULL
;
687 PyObject
*address_obj
= NULL
;
688 PyObject
*styling_obj
= Py_False
;
689 PyObject
*nibbles_obj
= NULL
;
690 PyObject
*deref_refs_obj
= NULL
;
691 PyObject
*actual_objects_obj
= NULL
;
692 PyObject
*static_members_obj
= NULL
;
694 if (!gdb_PyArg_ParseTupleAndKeywords (args
,
696 "|O!O!O!O!O!O!O!O!O!O!O!O!IIIs",
698 &PyBool_Type
, &raw_obj
,
699 &PyBool_Type
, &pretty_arrays_obj
,
700 &PyBool_Type
, &pretty_structs_obj
,
701 &PyBool_Type
, &array_indexes_obj
,
702 &PyBool_Type
, &symbols_obj
,
703 &PyBool_Type
, &unions_obj
,
704 &PyBool_Type
, &address_obj
,
705 &PyBool_Type
, &styling_obj
,
706 &PyBool_Type
, &nibbles_obj
,
707 &PyBool_Type
, &deref_refs_obj
,
708 &PyBool_Type
, &actual_objects_obj
,
709 &PyBool_Type
, &static_members_obj
,
712 &opts
.repeat_count_threshold
,
716 /* Set boolean arguments. */
717 if (!copy_py_bool_obj (&opts
.raw
, raw_obj
))
719 if (!copy_py_bool_obj (&opts
.prettyformat_arrays
, pretty_arrays_obj
))
721 if (!copy_py_bool_obj (&opts
.prettyformat_structs
, pretty_structs_obj
))
723 if (!copy_py_bool_obj (&opts
.print_array_indexes
, array_indexes_obj
))
725 if (!copy_py_bool_obj (&opts
.symbol_print
, symbols_obj
))
727 if (!copy_py_bool_obj (&opts
.unionprint
, unions_obj
))
729 if (!copy_py_bool_obj (&opts
.addressprint
, address_obj
))
731 if (!copy_py_bool_obj (&opts
.nibblesprint
, nibbles_obj
))
733 if (!copy_py_bool_obj (&opts
.deref_ref
, deref_refs_obj
))
735 if (!copy_py_bool_obj (&opts
.objectprint
, actual_objects_obj
))
737 if (!copy_py_bool_obj (&opts
.static_field_print
, static_members_obj
))
740 /* Numeric arguments for which 0 means unlimited (which we represent as
741 UINT_MAX). Note that the max-depth numeric argument uses -1 as
742 unlimited, and 0 is a valid choice. */
743 if (opts
.print_max
== 0)
744 opts
.print_max
= UINT_MAX
;
745 if (opts
.repeat_count_threshold
== 0)
746 opts
.repeat_count_threshold
= UINT_MAX
;
748 /* Other arguments. */
751 if (strlen (format
) == 1)
752 opts
.format
= format
[0];
755 /* Mimic the message on standard Python ones for similar
757 PyErr_SetString (PyExc_ValueError
,
758 "a single character is required");
763 string_file
stb (PyObject_IsTrue (styling_obj
));
767 common_val_print (((value_object
*) self
)->value
, &stb
, 0,
768 &opts
, current_language
);
770 catch (const gdb_exception
&except
)
772 GDB_PY_HANDLE_EXCEPTION (except
);
775 return PyUnicode_Decode (stb
.c_str (), stb
.size (), host_charset (), NULL
);
778 /* A helper function that implements the various cast operators. */
781 valpy_do_cast (PyObject
*self
, PyObject
*args
, enum exp_opcode op
)
783 PyObject
*type_obj
, *result
= NULL
;
786 if (! PyArg_ParseTuple (args
, "O", &type_obj
))
789 type
= type_object_to_type (type_obj
);
792 PyErr_SetString (PyExc_RuntimeError
,
793 _("Argument must be a type."));
799 struct value
*val
= ((value_object
*) self
)->value
;
800 struct value
*res_val
;
801 scoped_value_mark free_values
;
803 if (op
== UNOP_DYNAMIC_CAST
)
804 res_val
= value_dynamic_cast (type
, val
);
805 else if (op
== UNOP_REINTERPRET_CAST
)
806 res_val
= value_reinterpret_cast (type
, val
);
809 gdb_assert (op
== UNOP_CAST
);
810 res_val
= value_cast (type
, val
);
813 result
= value_to_value_object (res_val
);
815 catch (const gdb_exception
&except
)
817 GDB_PY_HANDLE_EXCEPTION (except
);
823 /* Implementation of the "cast" method. */
826 valpy_cast (PyObject
*self
, PyObject
*args
)
828 return valpy_do_cast (self
, args
, UNOP_CAST
);
831 /* Implementation of the "dynamic_cast" method. */
834 valpy_dynamic_cast (PyObject
*self
, PyObject
*args
)
836 return valpy_do_cast (self
, args
, UNOP_DYNAMIC_CAST
);
839 /* Implementation of the "reinterpret_cast" method. */
842 valpy_reinterpret_cast (PyObject
*self
, PyObject
*args
)
844 return valpy_do_cast (self
, args
, UNOP_REINTERPRET_CAST
);
848 valpy_length (PyObject
*self
)
850 /* We don't support getting the number of elements in a struct / class. */
851 PyErr_SetString (PyExc_NotImplementedError
,
852 _("Invalid operation on gdb.Value."));
856 /* Return 1 if the gdb.Field object FIELD is present in the value V.
857 Returns 0 otherwise. If any Python error occurs, -1 is returned. */
860 value_has_field (struct value
*v
, PyObject
*field
)
862 struct type
*parent_type
, *val_type
;
863 enum type_code type_code
;
864 gdbpy_ref
<> type_object (PyObject_GetAttrString (field
, "parent_type"));
867 if (type_object
== NULL
)
870 parent_type
= type_object_to_type (type_object
.get ());
871 if (parent_type
== NULL
)
873 PyErr_SetString (PyExc_TypeError
,
874 _("'parent_type' attribute of gdb.Field object is not a"
875 "gdb.Type object."));
881 val_type
= value_type (v
);
882 val_type
= check_typedef (val_type
);
883 if (val_type
->is_pointer_or_reference ())
884 val_type
= check_typedef (TYPE_TARGET_TYPE (val_type
));
886 type_code
= val_type
->code ();
887 if ((type_code
== TYPE_CODE_STRUCT
|| type_code
== TYPE_CODE_UNION
)
888 && types_equal (val_type
, parent_type
))
893 catch (const gdb_exception
&except
)
895 GDB_PY_SET_HANDLE_EXCEPTION (except
);
901 /* Return the value of a flag FLAG_NAME in a gdb.Field object FIELD.
902 Returns 1 if the flag value is true, 0 if it is false, and -1 if
903 a Python error occurs. */
906 get_field_flag (PyObject
*field
, const char *flag_name
)
908 gdbpy_ref
<> flag_object (PyObject_GetAttrString (field
, flag_name
));
910 if (flag_object
== NULL
)
913 return PyObject_IsTrue (flag_object
.get ());
916 /* Return the "type" attribute of a gdb.Field object.
917 Returns NULL on error, with a Python exception set. */
920 get_field_type (PyObject
*field
)
922 gdbpy_ref
<> ftype_obj (PyObject_GetAttrString (field
, "type"));
925 if (ftype_obj
== NULL
)
927 ftype
= type_object_to_type (ftype_obj
.get ());
929 PyErr_SetString (PyExc_TypeError
,
930 _("'type' attribute of gdb.Field object is not a "
931 "gdb.Type object."));
936 /* Given string name or a gdb.Field object corresponding to an element inside
937 a structure, return its value object. Returns NULL on error, with a python
941 valpy_getitem (PyObject
*self
, PyObject
*key
)
943 struct gdb_exception except
;
944 value_object
*self_value
= (value_object
*) self
;
945 gdb::unique_xmalloc_ptr
<char> field
;
946 struct type
*base_class_type
= NULL
, *field_type
= NULL
;
948 PyObject
*result
= NULL
;
950 if (gdbpy_is_string (key
))
952 field
= python_string_to_host_string (key
);
956 else if (gdbpy_is_field (key
))
958 int is_base_class
, valid_field
;
960 valid_field
= value_has_field (self_value
->value
, key
);
963 else if (valid_field
== 0)
965 PyErr_SetString (PyExc_TypeError
,
966 _("Invalid lookup for a field not contained in "
972 is_base_class
= get_field_flag (key
, "is_base_class");
973 if (is_base_class
< 0)
975 else if (is_base_class
> 0)
977 base_class_type
= get_field_type (key
);
978 if (base_class_type
== NULL
)
983 gdbpy_ref
<> name_obj (PyObject_GetAttrString (key
, "name"));
985 if (name_obj
== NULL
)
988 if (name_obj
!= Py_None
)
990 field
= python_string_to_host_string (name_obj
.get ());
996 if (!PyObject_HasAttrString (key
, "bitpos"))
998 PyErr_SetString (PyExc_AttributeError
,
999 _("gdb.Field object has no name and no "
1000 "'bitpos' attribute."));
1004 gdbpy_ref
<> bitpos_obj (PyObject_GetAttrString (key
, "bitpos"));
1005 if (bitpos_obj
== NULL
)
1007 if (!gdb_py_int_as_long (bitpos_obj
.get (), &bitpos
))
1010 field_type
= get_field_type (key
);
1011 if (field_type
== NULL
)
1019 struct value
*tmp
= self_value
->value
;
1020 struct value
*res_val
= NULL
;
1021 scoped_value_mark free_values
;
1024 res_val
= value_struct_elt (&tmp
, {}, field
.get (), NULL
,
1025 "struct/class/union");
1026 else if (bitpos
>= 0)
1027 res_val
= value_struct_elt_bitpos (&tmp
, bitpos
, field_type
,
1028 "struct/class/union");
1029 else if (base_class_type
!= NULL
)
1031 struct type
*val_type
;
1033 val_type
= check_typedef (value_type (tmp
));
1034 if (val_type
->code () == TYPE_CODE_PTR
)
1035 res_val
= value_cast (lookup_pointer_type (base_class_type
), tmp
);
1036 else if (val_type
->code () == TYPE_CODE_REF
)
1037 res_val
= value_cast (lookup_lvalue_reference_type (base_class_type
),
1039 else if (val_type
->code () == TYPE_CODE_RVALUE_REF
)
1040 res_val
= value_cast (lookup_rvalue_reference_type (base_class_type
),
1043 res_val
= value_cast (base_class_type
, tmp
);
1047 /* Assume we are attempting an array access, and let the
1048 value code throw an exception if the index has an invalid
1050 struct value
*idx
= convert_value_from_python (key
);
1054 /* Check the value's type is something that can be accessed via
1058 tmp
= coerce_ref (tmp
);
1059 type
= check_typedef (value_type (tmp
));
1060 if (type
->code () != TYPE_CODE_ARRAY
1061 && type
->code () != TYPE_CODE_PTR
)
1062 error (_("Cannot subscript requested type."));
1064 res_val
= value_subscript (tmp
, value_as_long (idx
));
1069 result
= value_to_value_object (res_val
);
1071 catch (gdb_exception
&ex
)
1073 except
= std::move (ex
);
1076 GDB_PY_HANDLE_EXCEPTION (except
);
1082 valpy_setitem (PyObject
*self
, PyObject
*key
, PyObject
*value
)
1084 PyErr_Format (PyExc_NotImplementedError
,
1085 _("Setting of struct elements is not currently supported."));
1089 /* Called by the Python interpreter to perform an inferior function
1090 call on the value. Returns NULL on error, with a python exception set. */
1092 valpy_call (PyObject
*self
, PyObject
*args
, PyObject
*keywords
)
1094 Py_ssize_t args_count
;
1095 struct value
*function
= ((value_object
*) self
)->value
;
1096 struct value
**vargs
= NULL
;
1097 struct type
*ftype
= NULL
;
1098 PyObject
*result
= NULL
;
1102 ftype
= check_typedef (value_type (function
));
1104 catch (const gdb_exception
&except
)
1106 GDB_PY_HANDLE_EXCEPTION (except
);
1109 if (ftype
->code () != TYPE_CODE_FUNC
)
1111 PyErr_SetString (PyExc_RuntimeError
,
1112 _("Value is not callable (not TYPE_CODE_FUNC)."));
1116 if (! PyTuple_Check (args
))
1118 PyErr_SetString (PyExc_TypeError
,
1119 _("Inferior arguments must be provided in a tuple."));
1123 args_count
= PyTuple_Size (args
);
1128 vargs
= XALLOCAVEC (struct value
*, args_count
);
1129 for (i
= 0; i
< args_count
; i
++)
1131 PyObject
*item
= PyTuple_GetItem (args
, i
);
1136 vargs
[i
] = convert_value_from_python (item
);
1137 if (vargs
[i
] == NULL
)
1144 scoped_value_mark free_values
;
1147 = call_function_by_hand (function
, NULL
,
1148 gdb::make_array_view (vargs
, args_count
));
1149 result
= value_to_value_object (return_value
);
1151 catch (const gdb_exception
&except
)
1153 GDB_PY_HANDLE_EXCEPTION (except
);
1159 /* Called by the Python interpreter to obtain string representation
1162 valpy_str (PyObject
*self
)
1164 struct value_print_options opts
;
1166 gdbpy_get_print_options (&opts
);
1173 common_val_print (((value_object
*) self
)->value
, &stb
, 0,
1174 &opts
, current_language
);
1176 catch (const gdb_exception
&except
)
1178 GDB_PY_HANDLE_EXCEPTION (except
);
1181 return PyUnicode_Decode (stb
.c_str (), stb
.size (), host_charset (), NULL
);
1184 /* Implements gdb.Value.is_optimized_out. */
1186 valpy_get_is_optimized_out (PyObject
*self
, void *closure
)
1188 struct value
*value
= ((value_object
*) self
)->value
;
1193 opt
= value_optimized_out (value
);
1195 catch (const gdb_exception
&except
)
1197 GDB_PY_HANDLE_EXCEPTION (except
);
1206 /* Implements gdb.Value.is_lazy. */
1208 valpy_get_is_lazy (PyObject
*self
, void *closure
)
1210 struct value
*value
= ((value_object
*) self
)->value
;
1215 opt
= value_lazy (value
);
1217 catch (const gdb_exception
&except
)
1219 GDB_PY_HANDLE_EXCEPTION (except
);
1228 /* Implements gdb.Value.fetch_lazy (). */
1230 valpy_fetch_lazy (PyObject
*self
, PyObject
*args
)
1232 struct value
*value
= ((value_object
*) self
)->value
;
1236 if (value_lazy (value
))
1237 value_fetch_lazy (value
);
1239 catch (const gdb_exception
&except
)
1241 GDB_PY_HANDLE_EXCEPTION (except
);
1247 /* Calculate and return the address of the PyObject as the value of
1248 the builtin __hash__ call. */
1250 valpy_hash (PyObject
*self
)
1252 return (intptr_t) self
;
1270 /* If TYPE is a reference, return the target; otherwise return TYPE. */
1271 #define STRIP_REFERENCE(TYPE) \
1272 (TYPE_IS_REFERENCE (TYPE) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
1274 /* Helper for valpy_binop. Returns a value object which is the result
1275 of applying the operation specified by OPCODE to the given
1276 arguments. Throws a GDB exception on error. */
1279 valpy_binop_throw (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
1281 PyObject
*result
= NULL
;
1283 struct value
*arg1
, *arg2
;
1284 struct value
*res_val
= NULL
;
1285 enum exp_opcode op
= OP_NULL
;
1288 scoped_value_mark free_values
;
1290 /* If the gdb.Value object is the second operand, then it will be
1291 passed to us as the OTHER argument, and SELF will be an entirely
1292 different kind of object, altogether. Because of this, we can't
1293 assume self is a gdb.Value object and need to convert it from
1295 arg1
= convert_value_from_python (self
);
1299 arg2
= convert_value_from_python (other
);
1307 struct type
*ltype
= value_type (arg1
);
1308 struct type
*rtype
= value_type (arg2
);
1310 ltype
= check_typedef (ltype
);
1311 ltype
= STRIP_REFERENCE (ltype
);
1312 rtype
= check_typedef (rtype
);
1313 rtype
= STRIP_REFERENCE (rtype
);
1316 if (ltype
->code () == TYPE_CODE_PTR
1317 && is_integral_type (rtype
))
1318 res_val
= value_ptradd (arg1
, value_as_long (arg2
));
1319 else if (rtype
->code () == TYPE_CODE_PTR
1320 && is_integral_type (ltype
))
1321 res_val
= value_ptradd (arg2
, value_as_long (arg1
));
1331 struct type
*ltype
= value_type (arg1
);
1332 struct type
*rtype
= value_type (arg2
);
1334 ltype
= check_typedef (ltype
);
1335 ltype
= STRIP_REFERENCE (ltype
);
1336 rtype
= check_typedef (rtype
);
1337 rtype
= STRIP_REFERENCE (rtype
);
1340 if (ltype
->code () == TYPE_CODE_PTR
1341 && rtype
->code () == TYPE_CODE_PTR
)
1342 /* A ptrdiff_t for the target would be preferable here. */
1343 res_val
= value_from_longest (builtin_type_pyint
,
1344 value_ptrdiff (arg1
, arg2
));
1345 else if (ltype
->code () == TYPE_CODE_PTR
1346 && is_integral_type (rtype
))
1347 res_val
= value_ptradd (arg1
, - value_as_long (arg2
));
1374 op
= BINOP_BITWISE_AND
;
1377 op
= BINOP_BITWISE_IOR
;
1380 op
= BINOP_BITWISE_XOR
;
1386 if (binop_user_defined_p (op
, arg1
, arg2
))
1387 res_val
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, EVAL_NORMAL
);
1389 res_val
= value_binop (arg1
, arg2
, op
);
1393 result
= value_to_value_object (res_val
);
1398 /* Returns a value object which is the result of applying the operation
1399 specified by OPCODE to the given arguments. Returns NULL on error, with
1400 a python exception set. */
1402 valpy_binop (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
1404 PyObject
*result
= NULL
;
1408 result
= valpy_binop_throw (opcode
, self
, other
);
1410 catch (const gdb_exception
&except
)
1412 GDB_PY_HANDLE_EXCEPTION (except
);
1419 valpy_add (PyObject
*self
, PyObject
*other
)
1421 return valpy_binop (VALPY_ADD
, self
, other
);
1425 valpy_subtract (PyObject
*self
, PyObject
*other
)
1427 return valpy_binop (VALPY_SUB
, self
, other
);
1431 valpy_multiply (PyObject
*self
, PyObject
*other
)
1433 return valpy_binop (VALPY_MUL
, self
, other
);
1437 valpy_divide (PyObject
*self
, PyObject
*other
)
1439 return valpy_binop (VALPY_DIV
, self
, other
);
1443 valpy_remainder (PyObject
*self
, PyObject
*other
)
1445 return valpy_binop (VALPY_REM
, self
, other
);
1449 valpy_power (PyObject
*self
, PyObject
*other
, PyObject
*unused
)
1451 /* We don't support the ternary form of pow. I don't know how to express
1452 that, so let's just throw NotImplementedError to at least do something
1454 if (unused
!= Py_None
)
1456 PyErr_SetString (PyExc_NotImplementedError
,
1457 "Invalid operation on gdb.Value.");
1461 return valpy_binop (VALPY_POW
, self
, other
);
1465 valpy_negative (PyObject
*self
)
1467 PyObject
*result
= NULL
;
1471 /* Perhaps overkill, but consistency has some virtue. */
1472 scoped_value_mark free_values
;
1475 val
= value_neg (((value_object
*) self
)->value
);
1476 result
= value_to_value_object (val
);
1478 catch (const gdb_exception
&except
)
1480 GDB_PY_HANDLE_EXCEPTION (except
);
1487 valpy_positive (PyObject
*self
)
1489 return value_to_value_object (((value_object
*) self
)->value
);
1493 valpy_absolute (PyObject
*self
)
1495 struct value
*value
= ((value_object
*) self
)->value
;
1500 scoped_value_mark free_values
;
1502 if (value_less (value
, value_zero (value_type (value
), not_lval
)))
1505 catch (const gdb_exception
&except
)
1507 GDB_PY_HANDLE_EXCEPTION (except
);
1511 return valpy_positive (self
);
1513 return valpy_negative (self
);
1516 /* Implements boolean evaluation of gdb.Value. */
1518 valpy_nonzero (PyObject
*self
)
1520 struct gdb_exception except
;
1521 value_object
*self_value
= (value_object
*) self
;
1523 int nonzero
= 0; /* Appease GCC warning. */
1527 type
= check_typedef (value_type (self_value
->value
));
1529 if (is_integral_type (type
) || type
->code () == TYPE_CODE_PTR
)
1530 nonzero
= !!value_as_long (self_value
->value
);
1531 else if (is_floating_value (self_value
->value
))
1532 nonzero
= !target_float_is_zero
1533 (value_contents (self_value
->value
).data (), type
);
1535 /* All other values are True. */
1538 catch (gdb_exception
&ex
)
1540 except
= std::move (ex
);
1543 /* This is not documented in the Python documentation, but if this
1544 function fails, return -1 as slot_nb_nonzero does (the default
1545 Python nonzero function). */
1546 GDB_PY_SET_HANDLE_EXCEPTION (except
);
1551 /* Implements ~ for value objects. */
1553 valpy_invert (PyObject
*self
)
1555 struct value
*val
= NULL
;
1559 val
= value_complement (((value_object
*) self
)->value
);
1561 catch (const gdb_exception
&except
)
1563 GDB_PY_HANDLE_EXCEPTION (except
);
1566 return value_to_value_object (val
);
1569 /* Implements left shift for value objects. */
1571 valpy_lsh (PyObject
*self
, PyObject
*other
)
1573 return valpy_binop (VALPY_LSH
, self
, other
);
1576 /* Implements right shift for value objects. */
1578 valpy_rsh (PyObject
*self
, PyObject
*other
)
1580 return valpy_binop (VALPY_RSH
, self
, other
);
1583 /* Implements bitwise and for value objects. */
1585 valpy_and (PyObject
*self
, PyObject
*other
)
1587 return valpy_binop (VALPY_BITAND
, self
, other
);
1590 /* Implements bitwise or for value objects. */
1592 valpy_or (PyObject
*self
, PyObject
*other
)
1594 return valpy_binop (VALPY_BITOR
, self
, other
);
1597 /* Implements bitwise xor for value objects. */
1599 valpy_xor (PyObject
*self
, PyObject
*other
)
1601 return valpy_binop (VALPY_BITXOR
, self
, other
);
1604 /* Helper for valpy_richcompare. Implements comparison operations for
1605 value objects. Returns true/false on success. Returns -1 with a
1606 Python exception set if a Python error is detected. Throws a GDB
1607 exception on other errors (memory error, etc.). */
1610 valpy_richcompare_throw (PyObject
*self
, PyObject
*other
, int op
)
1613 struct value
*value_other
;
1614 struct value
*value_self
;
1616 scoped_value_mark free_values
;
1618 value_other
= convert_value_from_python (other
);
1619 if (value_other
== NULL
)
1622 value_self
= ((value_object
*) self
)->value
;
1627 result
= value_less (value_self
, value_other
);
1630 result
= value_less (value_self
, value_other
)
1631 || value_equal (value_self
, value_other
);
1634 result
= value_equal (value_self
, value_other
);
1637 result
= !value_equal (value_self
, value_other
);
1640 result
= value_less (value_other
, value_self
);
1643 result
= (value_less (value_other
, value_self
)
1644 || value_equal (value_self
, value_other
));
1648 PyErr_SetString (PyExc_NotImplementedError
,
1649 _("Invalid operation on gdb.Value."));
1658 /* Implements comparison operations for value objects. Returns NULL on error,
1659 with a python exception set. */
1661 valpy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1665 if (other
== Py_None
)
1666 /* Comparing with None is special. From what I can tell, in Python
1667 None is smaller than anything else. */
1679 PyErr_SetString (PyExc_NotImplementedError
,
1680 _("Invalid operation on gdb.Value."));
1686 result
= valpy_richcompare_throw (self
, other
, op
);
1688 catch (const gdb_exception
&except
)
1690 GDB_PY_HANDLE_EXCEPTION (except
);
1693 /* In this case, the Python exception has already been set. */
1703 /* Implements conversion to long. */
1705 valpy_long (PyObject
*self
)
1707 struct value
*value
= ((value_object
*) self
)->value
;
1708 struct type
*type
= value_type (value
);
1713 if (is_floating_value (value
))
1715 type
= builtin_type_pylong
;
1716 value
= value_cast (type
, value
);
1719 type
= check_typedef (type
);
1721 if (!is_integral_type (type
)
1722 && type
->code () != TYPE_CODE_PTR
)
1723 error (_("Cannot convert value to long."));
1725 l
= value_as_long (value
);
1727 catch (const gdb_exception
&except
)
1729 GDB_PY_HANDLE_EXCEPTION (except
);
1732 if (type
->is_unsigned ())
1733 return gdb_py_object_from_ulongest (l
).release ();
1735 return gdb_py_object_from_longest (l
).release ();
1738 /* Implements conversion to float. */
1740 valpy_float (PyObject
*self
)
1742 struct value
*value
= ((value_object
*) self
)->value
;
1743 struct type
*type
= value_type (value
);
1748 type
= check_typedef (type
);
1750 if (type
->code () == TYPE_CODE_FLT
&& is_floating_value (value
))
1751 d
= target_float_to_host_double (value_contents (value
).data (), type
);
1752 else if (type
->code () == TYPE_CODE_INT
)
1754 /* Note that valpy_long accepts TYPE_CODE_PTR and some
1755 others here here -- but casting a pointer or bool to a
1756 float seems wrong. */
1757 d
= value_as_long (value
);
1760 error (_("Cannot convert value to float."));
1762 catch (const gdb_exception
&except
)
1764 GDB_PY_HANDLE_EXCEPTION (except
);
1767 return PyFloat_FromDouble (d
);
1770 /* Returns an object for a value which is released from the all_values chain,
1771 so its lifetime is not bound to the execution of a command. */
1773 value_to_value_object (struct value
*val
)
1775 value_object
*val_obj
;
1777 val_obj
= PyObject_New (value_object
, &value_object_type
);
1778 if (val_obj
!= NULL
)
1780 val_obj
->value
= release_value (val
).release ();
1781 val_obj
->next
= nullptr;
1782 val_obj
->prev
= nullptr;
1783 val_obj
->address
= NULL
;
1784 val_obj
->type
= NULL
;
1785 val_obj
->dynamic_type
= NULL
;
1786 note_value (val_obj
);
1789 return (PyObject
*) val_obj
;
1792 /* Returns an object for a value, but without releasing it from the
1793 all_values chain. */
1795 value_to_value_object_no_release (struct value
*val
)
1797 value_object
*val_obj
;
1799 val_obj
= PyObject_New (value_object
, &value_object_type
);
1800 if (val_obj
!= NULL
)
1803 val_obj
->value
= val
;
1804 val_obj
->next
= nullptr;
1805 val_obj
->prev
= nullptr;
1806 val_obj
->address
= NULL
;
1807 val_obj
->type
= NULL
;
1808 val_obj
->dynamic_type
= NULL
;
1809 note_value (val_obj
);
1812 return (PyObject
*) val_obj
;
1815 /* Returns a borrowed reference to the struct value corresponding to
1816 the given value object. */
1818 value_object_to_value (PyObject
*self
)
1822 if (! PyObject_TypeCheck (self
, &value_object_type
))
1824 real
= (value_object
*) self
;
1828 /* Try to convert a Python value to a gdb value. If the value cannot
1829 be converted, set a Python exception and return NULL. Returns a
1830 reference to a new value on the all_values chain. */
1833 convert_value_from_python (PyObject
*obj
)
1835 struct value
*value
= NULL
; /* -Wall */
1838 gdb_assert (obj
!= NULL
);
1842 if (PyBool_Check (obj
))
1844 cmp
= PyObject_IsTrue (obj
);
1846 value
= value_from_longest (builtin_type_pybool
, cmp
);
1848 else if (PyLong_Check (obj
))
1850 LONGEST l
= PyLong_AsLongLong (obj
);
1852 if (PyErr_Occurred ())
1854 /* If the error was an overflow, we can try converting to
1855 ULONGEST instead. */
1856 if (PyErr_ExceptionMatches (PyExc_OverflowError
))
1858 gdbpy_err_fetch fetched_error
;
1859 gdbpy_ref
<> zero
= gdb_py_object_from_longest (0);
1861 /* Check whether obj is positive. */
1862 if (PyObject_RichCompareBool (obj
, zero
.get (), Py_GT
) > 0)
1866 ul
= PyLong_AsUnsignedLongLong (obj
);
1867 if (! PyErr_Occurred ())
1868 value
= value_from_ulongest (builtin_type_upylong
, ul
);
1872 /* There's nothing we can do. */
1873 fetched_error
.restore ();
1878 value
= value_from_longest (builtin_type_pylong
, l
);
1880 else if (PyFloat_Check (obj
))
1882 double d
= PyFloat_AsDouble (obj
);
1884 if (! PyErr_Occurred ())
1885 value
= value_from_host_double (builtin_type_pyfloat
, d
);
1887 else if (gdbpy_is_string (obj
))
1889 gdb::unique_xmalloc_ptr
<char> s
1890 = python_string_to_target_string (obj
);
1892 value
= value_cstring (s
.get (), strlen (s
.get ()),
1893 builtin_type_pychar
);
1895 else if (PyObject_TypeCheck (obj
, &value_object_type
))
1896 value
= value_copy (((value_object
*) obj
)->value
);
1897 else if (gdbpy_is_lazy_string (obj
))
1901 result
= PyObject_CallMethodObjArgs (obj
, gdbpy_value_cst
, NULL
);
1902 value
= value_copy (((value_object
*) result
)->value
);
1905 PyErr_Format (PyExc_TypeError
,
1906 _("Could not convert Python object: %S."), obj
);
1908 catch (const gdb_exception
&except
)
1910 gdbpy_convert_exception (except
);
1917 /* Returns value object in the ARGth position in GDB's history. */
1919 gdbpy_history (PyObject
*self
, PyObject
*args
)
1922 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
1924 if (!PyArg_ParseTuple (args
, "i", &i
))
1929 res_val
= access_value_history (i
);
1931 catch (const gdb_exception
&except
)
1933 GDB_PY_HANDLE_EXCEPTION (except
);
1936 return value_to_value_object (res_val
);
1939 /* Add a gdb.Value into GDB's history, and return (as an integer) the
1940 position of the newly added value. */
1942 gdbpy_add_history (PyObject
*self
, PyObject
*args
)
1944 PyObject
*value_obj
;
1946 if (!PyArg_ParseTuple (args
, "O", &value_obj
))
1949 struct value
*value
= convert_value_from_python (value_obj
);
1950 if (value
== nullptr)
1955 int idx
= record_latest_value (value
);
1956 return gdb_py_object_from_longest (idx
).release ();
1958 catch (const gdb_exception
&except
)
1960 GDB_PY_HANDLE_EXCEPTION (except
);
1966 /* Return an integer, the number of items in GDB's history. */
1969 gdbpy_history_count (PyObject
*self
, PyObject
*args
)
1971 return gdb_py_object_from_ulongest (value_history_count ()).release ();
1974 /* Return the value of a convenience variable. */
1976 gdbpy_convenience_variable (PyObject
*self
, PyObject
*args
)
1978 const char *varname
;
1979 struct value
*res_val
= NULL
;
1981 if (!PyArg_ParseTuple (args
, "s", &varname
))
1986 struct internalvar
*var
= lookup_only_internalvar (varname
);
1990 res_val
= value_of_internalvar (gdbpy_enter::get_gdbarch (), var
);
1991 if (value_type (res_val
)->code () == TYPE_CODE_VOID
)
1995 catch (const gdb_exception
&except
)
1997 GDB_PY_HANDLE_EXCEPTION (except
);
2000 if (res_val
== NULL
)
2003 return value_to_value_object (res_val
);
2006 /* Set the value of a convenience variable. */
2008 gdbpy_set_convenience_variable (PyObject
*self
, PyObject
*args
)
2010 const char *varname
;
2011 PyObject
*value_obj
;
2012 struct value
*value
= NULL
;
2014 if (!PyArg_ParseTuple (args
, "sO", &varname
, &value_obj
))
2017 /* None means to clear the variable. */
2018 if (value_obj
!= Py_None
)
2020 value
= convert_value_from_python (value_obj
);
2029 struct internalvar
*var
= lookup_only_internalvar (varname
);
2032 clear_internalvar (var
);
2036 struct internalvar
*var
= lookup_internalvar (varname
);
2038 set_internalvar (var
, value
);
2041 catch (const gdb_exception
&except
)
2043 GDB_PY_HANDLE_EXCEPTION (except
);
2049 /* Returns 1 in OBJ is a gdb.Value object, 0 otherwise. */
2052 gdbpy_is_value_object (PyObject
*obj
)
2054 return PyObject_TypeCheck (obj
, &value_object_type
);
2058 gdbpy_initialize_values (void)
2060 if (PyType_Ready (&value_object_type
) < 0)
2063 return gdb_pymodule_addobject (gdb_module
, "Value",
2064 (PyObject
*) &value_object_type
);
2069 static gdb_PyGetSetDef value_object_getset
[] = {
2070 { "address", valpy_get_address
, NULL
, "The address of the value.",
2072 { "is_optimized_out", valpy_get_is_optimized_out
, NULL
,
2073 "Boolean telling whether the value is optimized "
2074 "out (i.e., not available).",
2076 { "type", valpy_get_type
, NULL
, "Type of the value.", NULL
},
2077 { "dynamic_type", valpy_get_dynamic_type
, NULL
,
2078 "Dynamic type of the value.", NULL
},
2079 { "is_lazy", valpy_get_is_lazy
, NULL
,
2080 "Boolean telling whether the value is lazy (not fetched yet\n\
2081 from the inferior). A lazy value is fetched when needed, or when\n\
2082 the \"fetch_lazy()\" method is called.", NULL
},
2083 {NULL
} /* Sentinel */
2086 static PyMethodDef value_object_methods
[] = {
2087 { "cast", valpy_cast
, METH_VARARGS
, "Cast the value to the supplied type." },
2088 { "dynamic_cast", valpy_dynamic_cast
, METH_VARARGS
,
2089 "dynamic_cast (gdb.Type) -> gdb.Value\n\
2090 Cast the value to the supplied type, as if by the C++ dynamic_cast operator."
2092 { "reinterpret_cast", valpy_reinterpret_cast
, METH_VARARGS
,
2093 "reinterpret_cast (gdb.Type) -> gdb.Value\n\
2094 Cast the value to the supplied type, as if by the C++\n\
2095 reinterpret_cast operator."
2097 { "dereference", valpy_dereference
, METH_NOARGS
, "Dereferences the value." },
2098 { "referenced_value", valpy_referenced_value
, METH_NOARGS
,
2099 "Return the value referenced by a TYPE_CODE_REF or TYPE_CODE_PTR value." },
2100 { "reference_value", valpy_lvalue_reference_value
, METH_NOARGS
,
2101 "Return a value of type TYPE_CODE_REF referencing this value." },
2102 { "rvalue_reference_value", valpy_rvalue_reference_value
, METH_NOARGS
,
2103 "Return a value of type TYPE_CODE_RVALUE_REF referencing this value." },
2104 { "const_value", valpy_const_value
, METH_NOARGS
,
2105 "Return a 'const' qualied version of the same value." },
2106 { "lazy_string", (PyCFunction
) valpy_lazy_string
,
2107 METH_VARARGS
| METH_KEYWORDS
,
2108 "lazy_string ([encoding] [, length]) -> lazy_string\n\
2109 Return a lazy string representation of the value." },
2110 { "string", (PyCFunction
) valpy_string
, METH_VARARGS
| METH_KEYWORDS
,
2111 "string ([encoding] [, errors] [, length]) -> string\n\
2112 Return Unicode string representation of the value." },
2113 { "fetch_lazy", valpy_fetch_lazy
, METH_NOARGS
,
2114 "Fetches the value from the inferior, if it was lazy." },
2115 { "format_string", (PyCFunction
) valpy_format_string
,
2116 METH_VARARGS
| METH_KEYWORDS
,
2117 "format_string (...) -> string\n\
2118 Return a string representation of the value using the specified\n\
2119 formatting options" },
2120 {NULL
} /* Sentinel */
2123 static PyNumberMethods value_object_as_number
= {
2128 NULL
, /* nb_divmod */
2129 valpy_power
, /* nb_power */
2130 valpy_negative
, /* nb_negative */
2131 valpy_positive
, /* nb_positive */
2132 valpy_absolute
, /* nb_absolute */
2133 valpy_nonzero
, /* nb_nonzero */
2134 valpy_invert
, /* nb_invert */
2135 valpy_lsh
, /* nb_lshift */
2136 valpy_rsh
, /* nb_rshift */
2137 valpy_and
, /* nb_and */
2138 valpy_xor
, /* nb_xor */
2139 valpy_or
, /* nb_or */
2140 valpy_long
, /* nb_int */
2141 NULL
, /* reserved */
2142 valpy_float
, /* nb_float */
2143 NULL
, /* nb_inplace_add */
2144 NULL
, /* nb_inplace_subtract */
2145 NULL
, /* nb_inplace_multiply */
2146 NULL
, /* nb_inplace_remainder */
2147 NULL
, /* nb_inplace_power */
2148 NULL
, /* nb_inplace_lshift */
2149 NULL
, /* nb_inplace_rshift */
2150 NULL
, /* nb_inplace_and */
2151 NULL
, /* nb_inplace_xor */
2152 NULL
, /* nb_inplace_or */
2153 NULL
, /* nb_floor_divide */
2154 valpy_divide
, /* nb_true_divide */
2155 NULL
, /* nb_inplace_floor_divide */
2156 NULL
, /* nb_inplace_true_divide */
2157 valpy_long
, /* nb_index */
2160 static PyMappingMethods value_object_as_mapping
= {
2166 PyTypeObject value_object_type
= {
2167 PyVarObject_HEAD_INIT (NULL
, 0)
2168 "gdb.Value", /*tp_name*/
2169 sizeof (value_object
), /*tp_basicsize*/
2171 valpy_dealloc
, /*tp_dealloc*/
2177 &value_object_as_number
, /*tp_as_number*/
2178 0, /*tp_as_sequence*/
2179 &value_object_as_mapping
, /*tp_as_mapping*/
2180 valpy_hash
, /*tp_hash*/
2181 valpy_call
, /*tp_call*/
2182 valpy_str
, /*tp_str*/
2186 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
2187 | Py_TPFLAGS_BASETYPE
, /*tp_flags*/
2188 "GDB value object", /* tp_doc */
2189 0, /* tp_traverse */
2191 valpy_richcompare
, /* tp_richcompare */
2192 0, /* tp_weaklistoffset */
2194 0, /* tp_iternext */
2195 value_object_methods
, /* tp_methods */
2197 value_object_getset
, /* tp_getset */
2200 0, /* tp_descr_get */
2201 0, /* tp_descr_set */
2202 0, /* tp_dictoffset */
2203 valpy_init
, /* tp_init */
2205 PyType_GenericNew
, /* tp_new */