1 /* Python interface to values.
3 Copyright (C) 2008-2023 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 () > 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 ()->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 (realtype
->target_type (),
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 (realtype
->target_type (),
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
* char_type
->length (),
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. */
644 "summary", /* Summary mode for non-scalars. */
646 "deref_refs", /* No corresponding setting. */
647 "actual_objects", /* See set print object on|off. */
648 "static_members", /* See set print static-members on|off. */
649 /* C non-bool options. */
650 "max_elements", /* See set print elements N. */
651 "max_depth", /* See set print max-depth N. */
652 "repeat_threshold", /* See set print repeats. */
653 "format", /* The format passed to the print command. */
657 /* This function has too many arguments to be useful as positionals, so
658 the user should specify them all as keyword arguments.
659 Python 3.3 and later have a way to specify it (both in C and Python
660 itself), but we could be compiled with older versions, so we just
661 check that the args tuple is empty. */
662 Py_ssize_t positional_count
= PyObject_Length (args
);
663 if (positional_count
< 0)
665 else if (positional_count
> 0)
667 /* This matches the error message that Python 3.3 raises when
668 passing positionals to functions expecting keyword-only
670 PyErr_Format (PyExc_TypeError
,
671 "format_string() takes 0 positional arguments but %zu were given",
676 struct value_print_options opts
;
677 gdbpy_get_print_options (&opts
);
678 opts
.deref_ref
= false;
680 /* We need objects for booleans as the "p" flag for bools is new in
682 PyObject
*raw_obj
= NULL
;
683 PyObject
*pretty_arrays_obj
= NULL
;
684 PyObject
*pretty_structs_obj
= NULL
;
685 PyObject
*array_indexes_obj
= NULL
;
686 PyObject
*symbols_obj
= NULL
;
687 PyObject
*unions_obj
= NULL
;
688 PyObject
*address_obj
= NULL
;
689 PyObject
*styling_obj
= Py_False
;
690 PyObject
*nibbles_obj
= NULL
;
691 PyObject
*deref_refs_obj
= NULL
;
692 PyObject
*actual_objects_obj
= NULL
;
693 PyObject
*static_members_obj
= NULL
;
694 PyObject
*summary_obj
= NULL
;
696 if (!gdb_PyArg_ParseTupleAndKeywords (args
,
698 "|O!O!O!O!O!O!O!O!O!O!O!O!O!IIIs",
700 &PyBool_Type
, &raw_obj
,
701 &PyBool_Type
, &pretty_arrays_obj
,
702 &PyBool_Type
, &pretty_structs_obj
,
703 &PyBool_Type
, &array_indexes_obj
,
704 &PyBool_Type
, &symbols_obj
,
705 &PyBool_Type
, &unions_obj
,
706 &PyBool_Type
, &address_obj
,
707 &PyBool_Type
, &styling_obj
,
708 &PyBool_Type
, &nibbles_obj
,
709 &PyBool_Type
, &summary_obj
,
710 &PyBool_Type
, &deref_refs_obj
,
711 &PyBool_Type
, &actual_objects_obj
,
712 &PyBool_Type
, &static_members_obj
,
715 &opts
.repeat_count_threshold
,
719 /* Set boolean arguments. */
720 if (!copy_py_bool_obj (&opts
.raw
, raw_obj
))
722 if (!copy_py_bool_obj (&opts
.prettyformat_arrays
, pretty_arrays_obj
))
724 if (!copy_py_bool_obj (&opts
.prettyformat_structs
, pretty_structs_obj
))
726 if (!copy_py_bool_obj (&opts
.print_array_indexes
, array_indexes_obj
))
728 if (!copy_py_bool_obj (&opts
.symbol_print
, symbols_obj
))
730 if (!copy_py_bool_obj (&opts
.unionprint
, unions_obj
))
732 if (!copy_py_bool_obj (&opts
.addressprint
, address_obj
))
734 if (!copy_py_bool_obj (&opts
.nibblesprint
, nibbles_obj
))
736 if (!copy_py_bool_obj (&opts
.deref_ref
, deref_refs_obj
))
738 if (!copy_py_bool_obj (&opts
.objectprint
, actual_objects_obj
))
740 if (!copy_py_bool_obj (&opts
.static_field_print
, static_members_obj
))
742 if (!copy_py_bool_obj (&opts
.summary
, summary_obj
))
745 /* Numeric arguments for which 0 means unlimited (which we represent as
746 UINT_MAX). Note that the max-depth numeric argument uses -1 as
747 unlimited, and 0 is a valid choice. */
748 if (opts
.print_max
== 0)
749 opts
.print_max
= UINT_MAX
;
750 if (opts
.repeat_count_threshold
== 0)
751 opts
.repeat_count_threshold
= UINT_MAX
;
753 /* Other arguments. */
756 if (strlen (format
) == 1)
757 opts
.format
= format
[0];
760 /* Mimic the message on standard Python ones for similar
762 PyErr_SetString (PyExc_ValueError
,
763 "a single character is required");
768 string_file
stb (PyObject_IsTrue (styling_obj
));
772 common_val_print (((value_object
*) self
)->value
, &stb
, 0,
773 &opts
, current_language
);
775 catch (const gdb_exception
&except
)
777 GDB_PY_HANDLE_EXCEPTION (except
);
780 return PyUnicode_Decode (stb
.c_str (), stb
.size (), host_charset (), NULL
);
783 /* A helper function that implements the various cast operators. */
786 valpy_do_cast (PyObject
*self
, PyObject
*args
, enum exp_opcode op
)
788 PyObject
*type_obj
, *result
= NULL
;
791 if (! PyArg_ParseTuple (args
, "O", &type_obj
))
794 type
= type_object_to_type (type_obj
);
797 PyErr_SetString (PyExc_RuntimeError
,
798 _("Argument must be a type."));
804 struct value
*val
= ((value_object
*) self
)->value
;
805 struct value
*res_val
;
806 scoped_value_mark free_values
;
808 if (op
== UNOP_DYNAMIC_CAST
)
809 res_val
= value_dynamic_cast (type
, val
);
810 else if (op
== UNOP_REINTERPRET_CAST
)
811 res_val
= value_reinterpret_cast (type
, val
);
814 gdb_assert (op
== UNOP_CAST
);
815 res_val
= value_cast (type
, val
);
818 result
= value_to_value_object (res_val
);
820 catch (const gdb_exception
&except
)
822 GDB_PY_HANDLE_EXCEPTION (except
);
828 /* Implementation of the "cast" method. */
831 valpy_cast (PyObject
*self
, PyObject
*args
)
833 return valpy_do_cast (self
, args
, UNOP_CAST
);
836 /* Implementation of the "dynamic_cast" method. */
839 valpy_dynamic_cast (PyObject
*self
, PyObject
*args
)
841 return valpy_do_cast (self
, args
, UNOP_DYNAMIC_CAST
);
844 /* Implementation of the "reinterpret_cast" method. */
847 valpy_reinterpret_cast (PyObject
*self
, PyObject
*args
)
849 return valpy_do_cast (self
, args
, UNOP_REINTERPRET_CAST
);
853 valpy_length (PyObject
*self
)
855 /* We don't support getting the number of elements in a struct / class. */
856 PyErr_SetString (PyExc_NotImplementedError
,
857 _("Invalid operation on gdb.Value."));
861 /* Return 1 if the gdb.Field object FIELD is present in the value V.
862 Returns 0 otherwise. If any Python error occurs, -1 is returned. */
865 value_has_field (struct value
*v
, PyObject
*field
)
867 struct type
*parent_type
, *val_type
;
868 enum type_code type_code
;
869 gdbpy_ref
<> type_object (PyObject_GetAttrString (field
, "parent_type"));
872 if (type_object
== NULL
)
875 parent_type
= type_object_to_type (type_object
.get ());
876 if (parent_type
== NULL
)
878 PyErr_SetString (PyExc_TypeError
,
879 _("'parent_type' attribute of gdb.Field object is not a"
880 "gdb.Type object."));
886 val_type
= value_type (v
);
887 val_type
= check_typedef (val_type
);
888 if (val_type
->is_pointer_or_reference ())
889 val_type
= check_typedef (val_type
->target_type ());
891 type_code
= val_type
->code ();
892 if ((type_code
== TYPE_CODE_STRUCT
|| type_code
== TYPE_CODE_UNION
)
893 && types_equal (val_type
, parent_type
))
898 catch (const gdb_exception
&except
)
900 GDB_PY_SET_HANDLE_EXCEPTION (except
);
906 /* Return the value of a flag FLAG_NAME in a gdb.Field object FIELD.
907 Returns 1 if the flag value is true, 0 if it is false, and -1 if
908 a Python error occurs. */
911 get_field_flag (PyObject
*field
, const char *flag_name
)
913 gdbpy_ref
<> flag_object (PyObject_GetAttrString (field
, flag_name
));
915 if (flag_object
== NULL
)
918 return PyObject_IsTrue (flag_object
.get ());
921 /* Return the "type" attribute of a gdb.Field object.
922 Returns NULL on error, with a Python exception set. */
925 get_field_type (PyObject
*field
)
927 gdbpy_ref
<> ftype_obj (PyObject_GetAttrString (field
, "type"));
930 if (ftype_obj
== NULL
)
932 ftype
= type_object_to_type (ftype_obj
.get ());
934 PyErr_SetString (PyExc_TypeError
,
935 _("'type' attribute of gdb.Field object is not a "
936 "gdb.Type object."));
941 /* Given string name or a gdb.Field object corresponding to an element inside
942 a structure, return its value object. Returns NULL on error, with a python
946 valpy_getitem (PyObject
*self
, PyObject
*key
)
948 struct gdb_exception except
;
949 value_object
*self_value
= (value_object
*) self
;
950 gdb::unique_xmalloc_ptr
<char> field
;
951 struct type
*base_class_type
= NULL
, *field_type
= NULL
;
953 PyObject
*result
= NULL
;
955 if (gdbpy_is_string (key
))
957 field
= python_string_to_host_string (key
);
961 else if (gdbpy_is_field (key
))
963 int is_base_class
, valid_field
;
965 valid_field
= value_has_field (self_value
->value
, key
);
968 else if (valid_field
== 0)
970 PyErr_SetString (PyExc_TypeError
,
971 _("Invalid lookup for a field not contained in "
977 is_base_class
= get_field_flag (key
, "is_base_class");
978 if (is_base_class
< 0)
980 else if (is_base_class
> 0)
982 base_class_type
= get_field_type (key
);
983 if (base_class_type
== NULL
)
988 gdbpy_ref
<> name_obj (PyObject_GetAttrString (key
, "name"));
990 if (name_obj
== NULL
)
993 if (name_obj
!= Py_None
)
995 field
= python_string_to_host_string (name_obj
.get ());
1001 if (!PyObject_HasAttrString (key
, "bitpos"))
1003 PyErr_SetString (PyExc_AttributeError
,
1004 _("gdb.Field object has no name and no "
1005 "'bitpos' attribute."));
1009 gdbpy_ref
<> bitpos_obj (PyObject_GetAttrString (key
, "bitpos"));
1010 if (bitpos_obj
== NULL
)
1012 if (!gdb_py_int_as_long (bitpos_obj
.get (), &bitpos
))
1015 field_type
= get_field_type (key
);
1016 if (field_type
== NULL
)
1024 struct value
*tmp
= self_value
->value
;
1025 struct value
*res_val
= NULL
;
1026 scoped_value_mark free_values
;
1029 res_val
= value_struct_elt (&tmp
, {}, field
.get (), NULL
,
1030 "struct/class/union");
1031 else if (bitpos
>= 0)
1032 res_val
= value_struct_elt_bitpos (&tmp
, bitpos
, field_type
,
1033 "struct/class/union");
1034 else if (base_class_type
!= NULL
)
1036 struct type
*val_type
;
1038 val_type
= check_typedef (value_type (tmp
));
1039 if (val_type
->code () == TYPE_CODE_PTR
)
1040 res_val
= value_cast (lookup_pointer_type (base_class_type
), tmp
);
1041 else if (val_type
->code () == TYPE_CODE_REF
)
1042 res_val
= value_cast (lookup_lvalue_reference_type (base_class_type
),
1044 else if (val_type
->code () == TYPE_CODE_RVALUE_REF
)
1045 res_val
= value_cast (lookup_rvalue_reference_type (base_class_type
),
1048 res_val
= value_cast (base_class_type
, tmp
);
1052 /* Assume we are attempting an array access, and let the
1053 value code throw an exception if the index has an invalid
1055 struct value
*idx
= convert_value_from_python (key
);
1059 /* Check the value's type is something that can be accessed via
1063 tmp
= coerce_ref (tmp
);
1064 type
= check_typedef (value_type (tmp
));
1065 if (type
->code () != TYPE_CODE_ARRAY
1066 && type
->code () != TYPE_CODE_PTR
)
1067 error (_("Cannot subscript requested type."));
1069 res_val
= value_subscript (tmp
, value_as_long (idx
));
1074 result
= value_to_value_object (res_val
);
1076 catch (gdb_exception
&ex
)
1078 except
= std::move (ex
);
1081 GDB_PY_HANDLE_EXCEPTION (except
);
1087 valpy_setitem (PyObject
*self
, PyObject
*key
, PyObject
*value
)
1089 PyErr_Format (PyExc_NotImplementedError
,
1090 _("Setting of struct elements is not currently supported."));
1094 /* Called by the Python interpreter to perform an inferior function
1095 call on the value. Returns NULL on error, with a python exception set. */
1097 valpy_call (PyObject
*self
, PyObject
*args
, PyObject
*keywords
)
1099 Py_ssize_t args_count
;
1100 struct value
*function
= ((value_object
*) self
)->value
;
1101 struct value
**vargs
= NULL
;
1102 struct type
*ftype
= NULL
;
1103 PyObject
*result
= NULL
;
1107 ftype
= check_typedef (value_type (function
));
1109 catch (const gdb_exception
&except
)
1111 GDB_PY_HANDLE_EXCEPTION (except
);
1114 if (ftype
->code () != TYPE_CODE_FUNC
)
1116 PyErr_SetString (PyExc_RuntimeError
,
1117 _("Value is not callable (not TYPE_CODE_FUNC)."));
1121 if (! PyTuple_Check (args
))
1123 PyErr_SetString (PyExc_TypeError
,
1124 _("Inferior arguments must be provided in a tuple."));
1128 args_count
= PyTuple_Size (args
);
1133 vargs
= XALLOCAVEC (struct value
*, args_count
);
1134 for (i
= 0; i
< args_count
; i
++)
1136 PyObject
*item
= PyTuple_GetItem (args
, i
);
1141 vargs
[i
] = convert_value_from_python (item
);
1142 if (vargs
[i
] == NULL
)
1149 scoped_value_mark free_values
;
1152 = call_function_by_hand (function
, NULL
,
1153 gdb::make_array_view (vargs
, args_count
));
1154 result
= value_to_value_object (return_value
);
1156 catch (const gdb_exception
&except
)
1158 GDB_PY_HANDLE_EXCEPTION (except
);
1164 /* Called by the Python interpreter to obtain string representation
1167 valpy_str (PyObject
*self
)
1169 struct value_print_options opts
;
1171 gdbpy_get_print_options (&opts
);
1172 opts
.deref_ref
= false;
1178 common_val_print (((value_object
*) self
)->value
, &stb
, 0,
1179 &opts
, current_language
);
1181 catch (const gdb_exception
&except
)
1183 GDB_PY_HANDLE_EXCEPTION (except
);
1186 return PyUnicode_Decode (stb
.c_str (), stb
.size (), host_charset (), NULL
);
1189 /* Implements gdb.Value.is_optimized_out. */
1191 valpy_get_is_optimized_out (PyObject
*self
, void *closure
)
1193 struct value
*value
= ((value_object
*) self
)->value
;
1198 opt
= value_optimized_out (value
);
1200 catch (const gdb_exception
&except
)
1202 GDB_PY_HANDLE_EXCEPTION (except
);
1211 /* Implements gdb.Value.is_lazy. */
1213 valpy_get_is_lazy (PyObject
*self
, void *closure
)
1215 struct value
*value
= ((value_object
*) self
)->value
;
1220 opt
= value_lazy (value
);
1222 catch (const gdb_exception
&except
)
1224 GDB_PY_HANDLE_EXCEPTION (except
);
1233 /* Implements gdb.Value.fetch_lazy (). */
1235 valpy_fetch_lazy (PyObject
*self
, PyObject
*args
)
1237 struct value
*value
= ((value_object
*) self
)->value
;
1241 if (value_lazy (value
))
1242 value_fetch_lazy (value
);
1244 catch (const gdb_exception
&except
)
1246 GDB_PY_HANDLE_EXCEPTION (except
);
1252 /* Calculate and return the address of the PyObject as the value of
1253 the builtin __hash__ call. */
1255 valpy_hash (PyObject
*self
)
1257 return (intptr_t) self
;
1275 /* If TYPE is a reference, return the target; otherwise return TYPE. */
1276 #define STRIP_REFERENCE(TYPE) \
1277 (TYPE_IS_REFERENCE (TYPE) ? ((TYPE)->target_type ()) : (TYPE))
1279 /* Helper for valpy_binop. Returns a value object which is the result
1280 of applying the operation specified by OPCODE to the given
1281 arguments. Throws a GDB exception on error. */
1284 valpy_binop_throw (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
1286 PyObject
*result
= NULL
;
1288 struct value
*arg1
, *arg2
;
1289 struct value
*res_val
= NULL
;
1290 enum exp_opcode op
= OP_NULL
;
1293 scoped_value_mark free_values
;
1295 /* If the gdb.Value object is the second operand, then it will be
1296 passed to us as the OTHER argument, and SELF will be an entirely
1297 different kind of object, altogether. Because of this, we can't
1298 assume self is a gdb.Value object and need to convert it from
1300 arg1
= convert_value_from_python (self
);
1304 arg2
= convert_value_from_python (other
);
1312 struct type
*ltype
= value_type (arg1
);
1313 struct type
*rtype
= value_type (arg2
);
1315 ltype
= check_typedef (ltype
);
1316 ltype
= STRIP_REFERENCE (ltype
);
1317 rtype
= check_typedef (rtype
);
1318 rtype
= STRIP_REFERENCE (rtype
);
1321 if (ltype
->code () == TYPE_CODE_PTR
1322 && is_integral_type (rtype
))
1323 res_val
= value_ptradd (arg1
, value_as_long (arg2
));
1324 else if (rtype
->code () == TYPE_CODE_PTR
1325 && is_integral_type (ltype
))
1326 res_val
= value_ptradd (arg2
, value_as_long (arg1
));
1336 struct type
*ltype
= value_type (arg1
);
1337 struct type
*rtype
= value_type (arg2
);
1339 ltype
= check_typedef (ltype
);
1340 ltype
= STRIP_REFERENCE (ltype
);
1341 rtype
= check_typedef (rtype
);
1342 rtype
= STRIP_REFERENCE (rtype
);
1345 if (ltype
->code () == TYPE_CODE_PTR
1346 && rtype
->code () == TYPE_CODE_PTR
)
1347 /* A ptrdiff_t for the target would be preferable here. */
1348 res_val
= value_from_longest (builtin_type_pyint
,
1349 value_ptrdiff (arg1
, arg2
));
1350 else if (ltype
->code () == TYPE_CODE_PTR
1351 && is_integral_type (rtype
))
1352 res_val
= value_ptradd (arg1
, - value_as_long (arg2
));
1379 op
= BINOP_BITWISE_AND
;
1382 op
= BINOP_BITWISE_IOR
;
1385 op
= BINOP_BITWISE_XOR
;
1391 if (binop_user_defined_p (op
, arg1
, arg2
))
1392 res_val
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, EVAL_NORMAL
);
1394 res_val
= value_binop (arg1
, arg2
, op
);
1398 result
= value_to_value_object (res_val
);
1403 /* Returns a value object which is the result of applying the operation
1404 specified by OPCODE to the given arguments. Returns NULL on error, with
1405 a python exception set. */
1407 valpy_binop (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
1409 PyObject
*result
= NULL
;
1413 result
= valpy_binop_throw (opcode
, self
, other
);
1415 catch (const gdb_exception
&except
)
1417 GDB_PY_HANDLE_EXCEPTION (except
);
1424 valpy_add (PyObject
*self
, PyObject
*other
)
1426 return valpy_binop (VALPY_ADD
, self
, other
);
1430 valpy_subtract (PyObject
*self
, PyObject
*other
)
1432 return valpy_binop (VALPY_SUB
, self
, other
);
1436 valpy_multiply (PyObject
*self
, PyObject
*other
)
1438 return valpy_binop (VALPY_MUL
, self
, other
);
1442 valpy_divide (PyObject
*self
, PyObject
*other
)
1444 return valpy_binop (VALPY_DIV
, self
, other
);
1448 valpy_remainder (PyObject
*self
, PyObject
*other
)
1450 return valpy_binop (VALPY_REM
, self
, other
);
1454 valpy_power (PyObject
*self
, PyObject
*other
, PyObject
*unused
)
1456 /* We don't support the ternary form of pow. I don't know how to express
1457 that, so let's just throw NotImplementedError to at least do something
1459 if (unused
!= Py_None
)
1461 PyErr_SetString (PyExc_NotImplementedError
,
1462 "Invalid operation on gdb.Value.");
1466 return valpy_binop (VALPY_POW
, self
, other
);
1470 valpy_negative (PyObject
*self
)
1472 PyObject
*result
= NULL
;
1476 /* Perhaps overkill, but consistency has some virtue. */
1477 scoped_value_mark free_values
;
1480 val
= value_neg (((value_object
*) self
)->value
);
1481 result
= value_to_value_object (val
);
1483 catch (const gdb_exception
&except
)
1485 GDB_PY_HANDLE_EXCEPTION (except
);
1492 valpy_positive (PyObject
*self
)
1494 return value_to_value_object (((value_object
*) self
)->value
);
1498 valpy_absolute (PyObject
*self
)
1500 struct value
*value
= ((value_object
*) self
)->value
;
1505 scoped_value_mark free_values
;
1507 if (value_less (value
, value_zero (value_type (value
), not_lval
)))
1510 catch (const gdb_exception
&except
)
1512 GDB_PY_HANDLE_EXCEPTION (except
);
1516 return valpy_positive (self
);
1518 return valpy_negative (self
);
1521 /* Implements boolean evaluation of gdb.Value. */
1523 valpy_nonzero (PyObject
*self
)
1525 struct gdb_exception except
;
1526 value_object
*self_value
= (value_object
*) self
;
1528 int nonzero
= 0; /* Appease GCC warning. */
1532 type
= check_typedef (value_type (self_value
->value
));
1534 if (is_integral_type (type
) || type
->code () == TYPE_CODE_PTR
)
1535 nonzero
= !!value_as_long (self_value
->value
);
1536 else if (is_floating_value (self_value
->value
))
1537 nonzero
= !target_float_is_zero
1538 (value_contents (self_value
->value
).data (), type
);
1540 /* All other values are True. */
1543 catch (gdb_exception
&ex
)
1545 except
= std::move (ex
);
1548 /* This is not documented in the Python documentation, but if this
1549 function fails, return -1 as slot_nb_nonzero does (the default
1550 Python nonzero function). */
1551 GDB_PY_SET_HANDLE_EXCEPTION (except
);
1556 /* Implements ~ for value objects. */
1558 valpy_invert (PyObject
*self
)
1560 struct value
*val
= NULL
;
1564 val
= value_complement (((value_object
*) self
)->value
);
1566 catch (const gdb_exception
&except
)
1568 GDB_PY_HANDLE_EXCEPTION (except
);
1571 return value_to_value_object (val
);
1574 /* Implements left shift for value objects. */
1576 valpy_lsh (PyObject
*self
, PyObject
*other
)
1578 return valpy_binop (VALPY_LSH
, self
, other
);
1581 /* Implements right shift for value objects. */
1583 valpy_rsh (PyObject
*self
, PyObject
*other
)
1585 return valpy_binop (VALPY_RSH
, self
, other
);
1588 /* Implements bitwise and for value objects. */
1590 valpy_and (PyObject
*self
, PyObject
*other
)
1592 return valpy_binop (VALPY_BITAND
, self
, other
);
1595 /* Implements bitwise or for value objects. */
1597 valpy_or (PyObject
*self
, PyObject
*other
)
1599 return valpy_binop (VALPY_BITOR
, self
, other
);
1602 /* Implements bitwise xor for value objects. */
1604 valpy_xor (PyObject
*self
, PyObject
*other
)
1606 return valpy_binop (VALPY_BITXOR
, self
, other
);
1609 /* Helper for valpy_richcompare. Implements comparison operations for
1610 value objects. Returns true/false on success. Returns -1 with a
1611 Python exception set if a Python error is detected. Throws a GDB
1612 exception on other errors (memory error, etc.). */
1615 valpy_richcompare_throw (PyObject
*self
, PyObject
*other
, int op
)
1618 struct value
*value_other
;
1619 struct value
*value_self
;
1621 scoped_value_mark free_values
;
1623 value_other
= convert_value_from_python (other
);
1624 if (value_other
== NULL
)
1627 value_self
= ((value_object
*) self
)->value
;
1632 result
= value_less (value_self
, value_other
);
1635 result
= value_less (value_self
, value_other
)
1636 || value_equal (value_self
, value_other
);
1639 result
= value_equal (value_self
, value_other
);
1642 result
= !value_equal (value_self
, value_other
);
1645 result
= value_less (value_other
, value_self
);
1648 result
= (value_less (value_other
, value_self
)
1649 || value_equal (value_self
, value_other
));
1653 PyErr_SetString (PyExc_NotImplementedError
,
1654 _("Invalid operation on gdb.Value."));
1663 /* Implements comparison operations for value objects. Returns NULL on error,
1664 with a python exception set. */
1666 valpy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1670 if (other
== Py_None
)
1671 /* Comparing with None is special. From what I can tell, in Python
1672 None is smaller than anything else. */
1684 PyErr_SetString (PyExc_NotImplementedError
,
1685 _("Invalid operation on gdb.Value."));
1691 result
= valpy_richcompare_throw (self
, other
, op
);
1693 catch (const gdb_exception
&except
)
1695 GDB_PY_HANDLE_EXCEPTION (except
);
1698 /* In this case, the Python exception has already been set. */
1708 /* Implements conversion to long. */
1710 valpy_long (PyObject
*self
)
1712 struct value
*value
= ((value_object
*) self
)->value
;
1713 struct type
*type
= value_type (value
);
1718 if (is_floating_value (value
))
1720 type
= builtin_type_pylong
;
1721 value
= value_cast (type
, value
);
1724 type
= check_typedef (type
);
1726 if (!is_integral_type (type
)
1727 && type
->code () != TYPE_CODE_PTR
)
1728 error (_("Cannot convert value to long."));
1730 l
= value_as_long (value
);
1732 catch (const gdb_exception
&except
)
1734 GDB_PY_HANDLE_EXCEPTION (except
);
1737 if (type
->is_unsigned ())
1738 return gdb_py_object_from_ulongest (l
).release ();
1740 return gdb_py_object_from_longest (l
).release ();
1743 /* Implements conversion to float. */
1745 valpy_float (PyObject
*self
)
1747 struct value
*value
= ((value_object
*) self
)->value
;
1748 struct type
*type
= value_type (value
);
1753 type
= check_typedef (type
);
1755 if (type
->code () == TYPE_CODE_FLT
&& is_floating_value (value
))
1756 d
= target_float_to_host_double (value_contents (value
).data (), type
);
1757 else if (type
->code () == TYPE_CODE_INT
)
1759 /* Note that valpy_long accepts TYPE_CODE_PTR and some
1760 others here here -- but casting a pointer or bool to a
1761 float seems wrong. */
1762 d
= value_as_long (value
);
1765 error (_("Cannot convert value to float."));
1767 catch (const gdb_exception
&except
)
1769 GDB_PY_HANDLE_EXCEPTION (except
);
1772 return PyFloat_FromDouble (d
);
1775 /* Returns an object for a value which is released from the all_values chain,
1776 so its lifetime is not bound to the execution of a command. */
1778 value_to_value_object (struct value
*val
)
1780 value_object
*val_obj
;
1782 val_obj
= PyObject_New (value_object
, &value_object_type
);
1783 if (val_obj
!= NULL
)
1785 val_obj
->value
= release_value (val
).release ();
1786 val_obj
->next
= nullptr;
1787 val_obj
->prev
= nullptr;
1788 val_obj
->address
= NULL
;
1789 val_obj
->type
= NULL
;
1790 val_obj
->dynamic_type
= NULL
;
1791 note_value (val_obj
);
1794 return (PyObject
*) val_obj
;
1797 /* Returns an object for a value, but without releasing it from the
1798 all_values chain. */
1800 value_to_value_object_no_release (struct value
*val
)
1802 value_object
*val_obj
;
1804 val_obj
= PyObject_New (value_object
, &value_object_type
);
1805 if (val_obj
!= NULL
)
1808 val_obj
->value
= val
;
1809 val_obj
->next
= nullptr;
1810 val_obj
->prev
= nullptr;
1811 val_obj
->address
= NULL
;
1812 val_obj
->type
= NULL
;
1813 val_obj
->dynamic_type
= NULL
;
1814 note_value (val_obj
);
1817 return (PyObject
*) val_obj
;
1820 /* Returns a borrowed reference to the struct value corresponding to
1821 the given value object. */
1823 value_object_to_value (PyObject
*self
)
1827 if (! PyObject_TypeCheck (self
, &value_object_type
))
1829 real
= (value_object
*) self
;
1833 /* Try to convert a Python value to a gdb value. If the value cannot
1834 be converted, set a Python exception and return NULL. Returns a
1835 reference to a new value on the all_values chain. */
1838 convert_value_from_python (PyObject
*obj
)
1840 struct value
*value
= NULL
; /* -Wall */
1843 gdb_assert (obj
!= NULL
);
1847 if (PyBool_Check (obj
))
1849 cmp
= PyObject_IsTrue (obj
);
1851 value
= value_from_longest (builtin_type_pybool
, cmp
);
1853 else if (PyLong_Check (obj
))
1855 LONGEST l
= PyLong_AsLongLong (obj
);
1857 if (PyErr_Occurred ())
1859 /* If the error was an overflow, we can try converting to
1860 ULONGEST instead. */
1861 if (PyErr_ExceptionMatches (PyExc_OverflowError
))
1863 gdbpy_err_fetch fetched_error
;
1864 gdbpy_ref
<> zero
= gdb_py_object_from_longest (0);
1866 /* Check whether obj is positive. */
1867 if (PyObject_RichCompareBool (obj
, zero
.get (), Py_GT
) > 0)
1871 ul
= PyLong_AsUnsignedLongLong (obj
);
1872 if (! PyErr_Occurred ())
1873 value
= value_from_ulongest (builtin_type_upylong
, ul
);
1877 /* There's nothing we can do. */
1878 fetched_error
.restore ();
1883 value
= value_from_longest (builtin_type_pylong
, l
);
1885 else if (PyFloat_Check (obj
))
1887 double d
= PyFloat_AsDouble (obj
);
1889 if (! PyErr_Occurred ())
1890 value
= value_from_host_double (builtin_type_pyfloat
, d
);
1892 else if (gdbpy_is_string (obj
))
1894 gdb::unique_xmalloc_ptr
<char> s
1895 = python_string_to_target_string (obj
);
1897 value
= value_cstring (s
.get (), strlen (s
.get ()),
1898 builtin_type_pychar
);
1900 else if (PyObject_TypeCheck (obj
, &value_object_type
))
1901 value
= value_copy (((value_object
*) obj
)->value
);
1902 else if (gdbpy_is_lazy_string (obj
))
1906 result
= PyObject_CallMethodObjArgs (obj
, gdbpy_value_cst
, NULL
);
1907 value
= value_copy (((value_object
*) result
)->value
);
1910 PyErr_Format (PyExc_TypeError
,
1911 _("Could not convert Python object: %S."), obj
);
1913 catch (const gdb_exception
&except
)
1915 gdbpy_convert_exception (except
);
1922 /* Returns value object in the ARGth position in GDB's history. */
1924 gdbpy_history (PyObject
*self
, PyObject
*args
)
1927 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
1929 if (!PyArg_ParseTuple (args
, "i", &i
))
1934 res_val
= access_value_history (i
);
1936 catch (const gdb_exception
&except
)
1938 GDB_PY_HANDLE_EXCEPTION (except
);
1941 return value_to_value_object (res_val
);
1944 /* Add a gdb.Value into GDB's history, and return (as an integer) the
1945 position of the newly added value. */
1947 gdbpy_add_history (PyObject
*self
, PyObject
*args
)
1949 PyObject
*value_obj
;
1951 if (!PyArg_ParseTuple (args
, "O", &value_obj
))
1954 struct value
*value
= convert_value_from_python (value_obj
);
1955 if (value
== nullptr)
1960 int idx
= record_latest_value (value
);
1961 return gdb_py_object_from_longest (idx
).release ();
1963 catch (const gdb_exception
&except
)
1965 GDB_PY_HANDLE_EXCEPTION (except
);
1971 /* Return an integer, the number of items in GDB's history. */
1974 gdbpy_history_count (PyObject
*self
, PyObject
*args
)
1976 return gdb_py_object_from_ulongest (value_history_count ()).release ();
1979 /* Return the value of a convenience variable. */
1981 gdbpy_convenience_variable (PyObject
*self
, PyObject
*args
)
1983 const char *varname
;
1984 struct value
*res_val
= NULL
;
1986 if (!PyArg_ParseTuple (args
, "s", &varname
))
1991 struct internalvar
*var
= lookup_only_internalvar (varname
);
1995 res_val
= value_of_internalvar (gdbpy_enter::get_gdbarch (), var
);
1996 if (value_type (res_val
)->code () == TYPE_CODE_VOID
)
2000 catch (const gdb_exception
&except
)
2002 GDB_PY_HANDLE_EXCEPTION (except
);
2005 if (res_val
== NULL
)
2008 return value_to_value_object (res_val
);
2011 /* Set the value of a convenience variable. */
2013 gdbpy_set_convenience_variable (PyObject
*self
, PyObject
*args
)
2015 const char *varname
;
2016 PyObject
*value_obj
;
2017 struct value
*value
= NULL
;
2019 if (!PyArg_ParseTuple (args
, "sO", &varname
, &value_obj
))
2022 /* None means to clear the variable. */
2023 if (value_obj
!= Py_None
)
2025 value
= convert_value_from_python (value_obj
);
2034 struct internalvar
*var
= lookup_only_internalvar (varname
);
2037 clear_internalvar (var
);
2041 struct internalvar
*var
= lookup_internalvar (varname
);
2043 set_internalvar (var
, value
);
2046 catch (const gdb_exception
&except
)
2048 GDB_PY_HANDLE_EXCEPTION (except
);
2054 /* Returns 1 in OBJ is a gdb.Value object, 0 otherwise. */
2057 gdbpy_is_value_object (PyObject
*obj
)
2059 return PyObject_TypeCheck (obj
, &value_object_type
);
2063 gdbpy_initialize_values (void)
2065 if (PyType_Ready (&value_object_type
) < 0)
2068 return gdb_pymodule_addobject (gdb_module
, "Value",
2069 (PyObject
*) &value_object_type
);
2074 static gdb_PyGetSetDef value_object_getset
[] = {
2075 { "address", valpy_get_address
, NULL
, "The address of the value.",
2077 { "is_optimized_out", valpy_get_is_optimized_out
, NULL
,
2078 "Boolean telling whether the value is optimized "
2079 "out (i.e., not available).",
2081 { "type", valpy_get_type
, NULL
, "Type of the value.", NULL
},
2082 { "dynamic_type", valpy_get_dynamic_type
, NULL
,
2083 "Dynamic type of the value.", NULL
},
2084 { "is_lazy", valpy_get_is_lazy
, NULL
,
2085 "Boolean telling whether the value is lazy (not fetched yet\n\
2086 from the inferior). A lazy value is fetched when needed, or when\n\
2087 the \"fetch_lazy()\" method is called.", NULL
},
2088 {NULL
} /* Sentinel */
2091 static PyMethodDef value_object_methods
[] = {
2092 { "cast", valpy_cast
, METH_VARARGS
, "Cast the value to the supplied type." },
2093 { "dynamic_cast", valpy_dynamic_cast
, METH_VARARGS
,
2094 "dynamic_cast (gdb.Type) -> gdb.Value\n\
2095 Cast the value to the supplied type, as if by the C++ dynamic_cast operator."
2097 { "reinterpret_cast", valpy_reinterpret_cast
, METH_VARARGS
,
2098 "reinterpret_cast (gdb.Type) -> gdb.Value\n\
2099 Cast the value to the supplied type, as if by the C++\n\
2100 reinterpret_cast operator."
2102 { "dereference", valpy_dereference
, METH_NOARGS
, "Dereferences the value." },
2103 { "referenced_value", valpy_referenced_value
, METH_NOARGS
,
2104 "Return the value referenced by a TYPE_CODE_REF or TYPE_CODE_PTR value." },
2105 { "reference_value", valpy_lvalue_reference_value
, METH_NOARGS
,
2106 "Return a value of type TYPE_CODE_REF referencing this value." },
2107 { "rvalue_reference_value", valpy_rvalue_reference_value
, METH_NOARGS
,
2108 "Return a value of type TYPE_CODE_RVALUE_REF referencing this value." },
2109 { "const_value", valpy_const_value
, METH_NOARGS
,
2110 "Return a 'const' qualied version of the same value." },
2111 { "lazy_string", (PyCFunction
) valpy_lazy_string
,
2112 METH_VARARGS
| METH_KEYWORDS
,
2113 "lazy_string ([encoding] [, length]) -> lazy_string\n\
2114 Return a lazy string representation of the value." },
2115 { "string", (PyCFunction
) valpy_string
, METH_VARARGS
| METH_KEYWORDS
,
2116 "string ([encoding] [, errors] [, length]) -> string\n\
2117 Return Unicode string representation of the value." },
2118 { "fetch_lazy", valpy_fetch_lazy
, METH_NOARGS
,
2119 "Fetches the value from the inferior, if it was lazy." },
2120 { "format_string", (PyCFunction
) valpy_format_string
,
2121 METH_VARARGS
| METH_KEYWORDS
,
2122 "format_string (...) -> string\n\
2123 Return a string representation of the value using the specified\n\
2124 formatting options" },
2125 {NULL
} /* Sentinel */
2128 static PyNumberMethods value_object_as_number
= {
2133 NULL
, /* nb_divmod */
2134 valpy_power
, /* nb_power */
2135 valpy_negative
, /* nb_negative */
2136 valpy_positive
, /* nb_positive */
2137 valpy_absolute
, /* nb_absolute */
2138 valpy_nonzero
, /* nb_nonzero */
2139 valpy_invert
, /* nb_invert */
2140 valpy_lsh
, /* nb_lshift */
2141 valpy_rsh
, /* nb_rshift */
2142 valpy_and
, /* nb_and */
2143 valpy_xor
, /* nb_xor */
2144 valpy_or
, /* nb_or */
2145 valpy_long
, /* nb_int */
2146 NULL
, /* reserved */
2147 valpy_float
, /* nb_float */
2148 NULL
, /* nb_inplace_add */
2149 NULL
, /* nb_inplace_subtract */
2150 NULL
, /* nb_inplace_multiply */
2151 NULL
, /* nb_inplace_remainder */
2152 NULL
, /* nb_inplace_power */
2153 NULL
, /* nb_inplace_lshift */
2154 NULL
, /* nb_inplace_rshift */
2155 NULL
, /* nb_inplace_and */
2156 NULL
, /* nb_inplace_xor */
2157 NULL
, /* nb_inplace_or */
2158 NULL
, /* nb_floor_divide */
2159 valpy_divide
, /* nb_true_divide */
2160 NULL
, /* nb_inplace_floor_divide */
2161 NULL
, /* nb_inplace_true_divide */
2162 valpy_long
, /* nb_index */
2165 static PyMappingMethods value_object_as_mapping
= {
2171 PyTypeObject value_object_type
= {
2172 PyVarObject_HEAD_INIT (NULL
, 0)
2173 "gdb.Value", /*tp_name*/
2174 sizeof (value_object
), /*tp_basicsize*/
2176 valpy_dealloc
, /*tp_dealloc*/
2182 &value_object_as_number
, /*tp_as_number*/
2183 0, /*tp_as_sequence*/
2184 &value_object_as_mapping
, /*tp_as_mapping*/
2185 valpy_hash
, /*tp_hash*/
2186 valpy_call
, /*tp_call*/
2187 valpy_str
, /*tp_str*/
2191 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
2192 | Py_TPFLAGS_BASETYPE
, /*tp_flags*/
2193 "GDB value object", /* tp_doc */
2194 0, /* tp_traverse */
2196 valpy_richcompare
, /* tp_richcompare */
2197 0, /* tp_weaklistoffset */
2199 0, /* tp_iternext */
2200 value_object_methods
, /* tp_methods */
2202 value_object_getset
, /* tp_getset */
2205 0, /* tp_descr_get */
2206 0, /* tp_descr_set */
2207 0, /* tp_dictoffset */
2208 valpy_init
, /* tp_init */
2210 PyType_GenericNew
, /* tp_new */