GDB (xrefs)
Loading...
Searching...
No Matches
py-value.c
Go to the documentation of this file.
1/* Python interface to values.
2
3 Copyright (C) 2008-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#include "defs.h"
21#include "charset.h"
22#include "value.h"
23#include "language.h"
24#include "target-float.h"
25#include "valprint.h"
26#include "infcall.h"
27#include "expression.h"
28#include "cp-abi.h"
29#include "python.h"
30
31#include "python-internal.h"
32
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). */
36
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
40
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
44
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
48
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
52
53#define builtin_type_pybool \
54 language_bool_type (current_language, gdbpy_enter::get_gdbarch ())
55
56#define builtin_type_pychar \
57 language_string_char_type (current_language, gdbpy_enter::get_gdbarch ())
58
60 PyObject_HEAD
63 struct value *value;
64 PyObject *address;
65 PyObject *type;
66 PyObject *dynamic_type;
67};
68
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. */
75
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. */
79
80static void
82{
83 /* Indicate we are no longer interested in the value object. */
84 value_decref (self->value);
85 self->value = nullptr;
86
87 Py_CLEAR (self->address);
88 Py_CLEAR (self->type);
89 Py_CLEAR (self->dynamic_type);
90}
91
92/* Called by the Python interpreter when deallocating a value object. */
93static void
94valpy_dealloc (PyObject *obj)
95{
96 value_object *self = (value_object *) obj;
97
98 /* If SELF failed to initialize correctly then it may not have a value
99 contained within it. */
100 if (self->value != nullptr)
101 {
102 /* Remove SELF from the global list of values. */
103 if (self->prev != nullptr)
104 self->prev->next = self->next;
105 else
106 {
107 gdb_assert (values_in_python == self);
108 values_in_python = self->next;
109 }
110 if (self->next != nullptr)
111 self->next->prev = self->prev;
112
113 /* Release the value object and any cached Python objects. */
114 valpy_clear_value (self);
115 }
116
117 Py_TYPE (self)->tp_free (self);
118}
119
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. */
122
123static void
125{
126 if (value_obj->next == nullptr)
127 {
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;
133 }
134}
135
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
139 nullptr. */
140
141static struct value *
143{
144 Py_buffer_up buffer_up;
145 Py_buffer py_buf;
146
147 if (PyObject_CheckBuffer (obj)
148 && PyObject_GetBuffer (obj, &py_buf, PyBUF_SIMPLE) == 0)
149 {
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);
153 }
154 else
155 {
156 PyErr_SetString (PyExc_TypeError,
157 _("Object must support the python buffer protocol."));
158 return nullptr;
159 }
160
161 if (type->length () > py_buf.len)
162 {
163 PyErr_SetString (PyExc_ValueError,
164 _("Size of type is larger than that of buffer object."));
165 return nullptr;
166 }
167
168 return value_from_contents (type, (const gdb_byte *) py_buf.buf);
169}
170
171/* Implement gdb.Value.__init__. */
172
173static int
174valpy_init (PyObject *self, PyObject *args, PyObject *kwds)
175{
176 static const char *keywords[] = { "val", "type", NULL };
177 PyObject *val_obj = nullptr;
178 PyObject *type_obj = nullptr;
179
180 if (!gdb_PyArg_ParseTupleAndKeywords (args, kwds, "O|O", keywords,
181 &val_obj, &type_obj))
182 return -1;
183
184 struct type *type = nullptr;
185 if (type_obj != nullptr && type_obj != Py_None)
186 {
187 type = type_object_to_type (type_obj);
188 if (type == nullptr)
189 {
190 PyErr_SetString (PyExc_TypeError,
191 _("type argument must be a gdb.Type."));
192 return -1;
193 }
194 }
195
196 struct value *value;
197 if (type == nullptr)
199 else
201 if (value == nullptr)
202 {
203 gdb_assert (PyErr_Occurred ());
204 return -1;
205 }
206
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);
211
212 /* Store the value into this Python object. */
213 value_obj->value = release_value (value).release ();
214
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);
218
219 return 0;
220}
221
222/* Iterate over all the Value objects, calling preserve_one_value on
223 each. */
224void
226 struct objfile *objfile, htab_t copied_types)
227{
228 value_object *iter;
229
230 for (iter = values_in_python; iter; iter = iter->next)
231 preserve_one_value (iter->value, objfile, copied_types);
232}
233
234/* Given a value of a pointer type, apply the C unary * operator to it. */
235static PyObject *
236valpy_dereference (PyObject *self, PyObject *args)
237{
238 PyObject *result = NULL;
239
240 try
241 {
242 struct value *res_val;
243 scoped_value_mark free_values;
244
245 res_val = value_ind (((value_object *) self)->value);
246 result = value_to_value_object (res_val);
247 }
248 catch (const gdb_exception &except)
249 {
251 }
252
253 return result;
254}
255
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
262 'int *'. */
263
264static PyObject *
265valpy_referenced_value (PyObject *self, PyObject *args)
266{
267 PyObject *result = NULL;
268
269 try
270 {
271 struct value *self_val, *res_val;
272 scoped_value_mark free_values;
273
274 self_val = ((value_object *) self)->value;
275 switch (check_typedef (value_type (self_val))->code ())
276 {
277 case TYPE_CODE_PTR:
278 res_val = value_ind (self_val);
279 break;
280 case TYPE_CODE_REF:
281 case TYPE_CODE_RVALUE_REF:
282 res_val = coerce_ref (self_val);
283 break;
284 default:
285 error(_("Trying to get the referenced value from a value which is "
286 "neither a pointer nor a reference."));
287 }
288
289 result = value_to_value_object (res_val);
290 }
291 catch (const gdb_exception &except)
292 {
294 }
295
296 return result;
297}
298
299/* Return a value which is a reference to the value. */
300
301static PyObject *
302valpy_reference_value (PyObject *self, PyObject *args, enum type_code refcode)
303{
304 PyObject *result = NULL;
305
306 try
307 {
308 struct value *self_val;
309 scoped_value_mark free_values;
310
311 self_val = ((value_object *) self)->value;
312 result = value_to_value_object (value_ref (self_val, refcode));
313 }
314 catch (const gdb_exception &except)
315 {
317 }
318
319 return result;
320}
321
322static PyObject *
323valpy_lvalue_reference_value (PyObject *self, PyObject *args)
324{
325 return valpy_reference_value (self, args, TYPE_CODE_REF);
326}
327
328static PyObject *
329valpy_rvalue_reference_value (PyObject *self, PyObject *args)
330{
331 return valpy_reference_value (self, args, TYPE_CODE_RVALUE_REF);
332}
333
334/* Return a "const" qualified version of the value. */
335
336static PyObject *
337valpy_const_value (PyObject *self, PyObject *args)
338{
339 PyObject *result = NULL;
340
341 try
342 {
343 struct value *self_val, *res_val;
344 scoped_value_mark free_values;
345
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);
349 }
350 catch (const gdb_exception &except)
351 {
353 }
354
355 return result;
356}
357
358/* Return "&value". */
359static PyObject *
360valpy_get_address (PyObject *self, void *closure)
361{
362 value_object *val_obj = (value_object *) self;
363
364 if (!val_obj->address)
365 {
366 try
367 {
368 struct value *res_val;
369 scoped_value_mark free_values;
370
371 res_val = value_addr (val_obj->value);
372 val_obj->address = value_to_value_object (res_val);
373 }
374 catch (const gdb_exception &except)
375 {
376 val_obj->address = Py_None;
377 Py_INCREF (Py_None);
378 }
379 }
380
381 Py_XINCREF (val_obj->address);
382
383 return val_obj->address;
384}
385
386/* Return type of the value. */
387static PyObject *
388valpy_get_type (PyObject *self, void *closure)
389{
390 value_object *obj = (value_object *) self;
391
392 if (!obj->type)
393 {
395 if (!obj->type)
396 return NULL;
397 }
398 Py_INCREF (obj->type);
399 return obj->type;
400}
401
402/* Return dynamic type of the value. */
403
404static PyObject *
405valpy_get_dynamic_type (PyObject *self, void *closure)
406{
407 value_object *obj = (value_object *) self;
408 struct type *type = NULL;
409
410 if (obj->dynamic_type != NULL)
411 {
412 Py_INCREF (obj->dynamic_type);
413 return obj->dynamic_type;
414 }
415
416 try
417 {
418 struct value *val = obj->value;
419 scoped_value_mark free_values;
420
421 type = value_type (val);
423
425 && (type->target_type ()->code () == TYPE_CODE_STRUCT))
426 {
427 struct value *target;
428 int was_pointer = type->code () == TYPE_CODE_PTR;
429
430 if (was_pointer)
431 target = value_ind (val);
432 else
433 target = coerce_ref (val);
434 type = value_rtti_type (target, NULL, NULL, NULL);
435
436 if (type)
437 {
438 if (was_pointer)
440 else
442 }
443 }
444 else if (type->code () == TYPE_CODE_STRUCT)
445 type = value_rtti_type (val, NULL, NULL, NULL);
446 else
447 {
448 /* Re-use object's static type. */
449 type = NULL;
450 }
451 }
452 catch (const gdb_exception &except)
453 {
455 }
456
457 if (type == NULL)
458 obj->dynamic_type = valpy_get_type (self, NULL);
459 else
461
462 Py_XINCREF (obj->dynamic_type);
463 return obj->dynamic_type;
464}
465
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
475 appropriate with).
476
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. */
483
484static PyObject *
485valpy_lazy_string (PyObject *self, PyObject *args, PyObject *kw)
486{
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;
492
494 keywords, &user_encoding, &length))
495 return NULL;
496
497 if (length < -1)
498 {
499 PyErr_SetString (PyExc_ValueError, _("Invalid length."));
500 return NULL;
501 }
502
503 try
504 {
505 scoped_value_mark free_values;
506 struct type *type, *realtype;
507 CORE_ADDR addr;
508
510 realtype = check_typedef (type);
511
512 switch (realtype->code ())
513 {
514 case TYPE_CODE_ARRAY:
515 {
516 LONGEST array_length = -1;
517 LONGEST low_bound, high_bound;
518
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;
524 if (length == -1)
525 length = array_length;
526 else if (array_length == -1)
527 {
529 0, length - 1);
530 }
531 else if (length != array_length)
532 {
533 /* We need to create a new array type with the
534 specified length. */
535 if (length > array_length)
536 error (_("Length is larger than array size."));
538 low_bound,
539 low_bound + length - 1);
540 }
541 addr = value_address (value);
542 break;
543 }
544 case TYPE_CODE_PTR:
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);
548 break;
549 default:
550 /* Should flag an error here. PR 20769. */
551 addr = value_address (value);
552 break;
553 }
554
555 str_obj = gdbpy_create_lazy_string_object (addr, length, user_encoding,
556 type);
557 }
558 catch (const gdb_exception &except)
559 {
561 }
562
563 return str_obj;
564}
565
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. */
571
572static PyObject *
573valpy_string (PyObject *self, PyObject *args, PyObject *kw)
574{
575 int length = -1;
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 };
584
585 if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "|ssi", keywords,
586 &user_encoding, &errors, &length))
587 return NULL;
588
589 try
590 {
591 c_get_string (value, &buffer, &length, &char_type, &la_encoding);
592 }
593 catch (const gdb_exception &except)
594 {
596 }
597
598 encoding = (user_encoding && *user_encoding) ? user_encoding : la_encoding;
599 return PyUnicode_Decode ((const char *) buffer.get (),
600 length * char_type->length (),
601 encoding, errors);
602}
603
604/* Given a Python object, copy its truth value to a C bool (the value
605 pointed by dest).
606 If src_obj is NULL, then *dest is not modified.
607
608 Return true in case of success (including src_obj being NULL), false
609 in case of error. */
610
611static bool
612copy_py_bool_obj (bool *dest, PyObject *src_obj)
613{
614 if (src_obj)
615 {
616 int cmp = PyObject_IsTrue (src_obj);
617 if (cmp < 0)
618 return false;
619 *dest = cmp;
620 }
621
622 return true;
623}
624
625/* Implementation of gdb.Value.format_string (...) -> string.
626 Return Unicode string with value contents formatted using the
627 keyword-only arguments. */
628
629static PyObject *
630valpy_format_string (PyObject *self, PyObject *args, PyObject *kw)
631{
632 static const char *keywords[] =
633 {
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. */
645 /* C++ options. */
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. */
654 NULL
655 };
656
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)
664 return NULL;
665 else if (positional_count > 0)
666 {
667 /* This matches the error message that Python 3.3 raises when
668 passing positionals to functions expecting keyword-only
669 arguments. */
670 PyErr_Format (PyExc_TypeError,
671 "format_string() takes 0 positional arguments but %zu were given",
672 positional_count);
673 return NULL;
674 }
675
676 struct value_print_options opts;
678 opts.deref_ref = 0;
679
680 /* We need objects for booleans as the "p" flag for bools is new in
681 Python 3.3. */
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;
695 char *format = NULL;
697 kw,
698 "|O!O!O!O!O!O!O!O!O!O!O!O!O!IIIs",
699 keywords,
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,
713 &opts.print_max,
714 &opts.max_depth,
715 &opts.repeat_count_threshold,
716 &format))
717 return NULL;
718
719 /* Set boolean arguments. */
720 if (!copy_py_bool_obj (&opts.raw, raw_obj))
721 return NULL;
722 if (!copy_py_bool_obj (&opts.prettyformat_arrays, pretty_arrays_obj))
723 return NULL;
724 if (!copy_py_bool_obj (&opts.prettyformat_structs, pretty_structs_obj))
725 return NULL;
726 if (!copy_py_bool_obj (&opts.print_array_indexes, array_indexes_obj))
727 return NULL;
728 if (!copy_py_bool_obj (&opts.symbol_print, symbols_obj))
729 return NULL;
730 if (!copy_py_bool_obj (&opts.unionprint, unions_obj))
731 return NULL;
732 if (!copy_py_bool_obj (&opts.addressprint, address_obj))
733 return NULL;
734 if (!copy_py_bool_obj (&opts.nibblesprint, nibbles_obj))
735 return NULL;
736 if (!copy_py_bool_obj (&opts.deref_ref, deref_refs_obj))
737 return NULL;
738 if (!copy_py_bool_obj (&opts.objectprint, actual_objects_obj))
739 return NULL;
740 if (!copy_py_bool_obj (&opts.static_field_print, static_members_obj))
741 return NULL;
742 if (!copy_py_bool_obj (&opts.summary, summary_obj))
743 return nullptr;
744
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;
752
753 /* Other arguments. */
754 if (format != NULL)
755 {
756 if (strlen (format) == 1)
757 opts.format = format[0];
758 else
759 {
760 /* Mimic the message on standard Python ones for similar
761 errors. */
762 PyErr_SetString (PyExc_ValueError,
763 "a single character is required");
764 return NULL;
765 }
766 }
767
768 string_file stb (PyObject_IsTrue (styling_obj));
769
770 try
771 {
772 common_val_print (((value_object *) self)->value, &stb, 0,
773 &opts, current_language);
774 }
775 catch (const gdb_exception &except)
776 {
778 }
779
780 return PyUnicode_Decode (stb.c_str (), stb.size (), host_charset (), NULL);
781}
782
783/* A helper function that implements the various cast operators. */
784
785static PyObject *
786valpy_do_cast (PyObject *self, PyObject *args, enum exp_opcode op)
787{
788 PyObject *type_obj, *result = NULL;
789 struct type *type;
790
791 if (! PyArg_ParseTuple (args, "O", &type_obj))
792 return NULL;
793
794 type = type_object_to_type (type_obj);
795 if (! type)
796 {
797 PyErr_SetString (PyExc_RuntimeError,
798 _("Argument must be a type."));
799 return NULL;
800 }
801
802 try
803 {
804 struct value *val = ((value_object *) self)->value;
805 struct value *res_val;
806 scoped_value_mark free_values;
807
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);
812 else
813 {
814 gdb_assert (op == UNOP_CAST);
815 res_val = value_cast (type, val);
816 }
817
818 result = value_to_value_object (res_val);
819 }
820 catch (const gdb_exception &except)
821 {
823 }
824
825 return result;
826}
827
828/* Implementation of the "cast" method. */
829
830static PyObject *
831valpy_cast (PyObject *self, PyObject *args)
832{
833 return valpy_do_cast (self, args, UNOP_CAST);
834}
835
836/* Implementation of the "dynamic_cast" method. */
837
838static PyObject *
839valpy_dynamic_cast (PyObject *self, PyObject *args)
840{
841 return valpy_do_cast (self, args, UNOP_DYNAMIC_CAST);
842}
843
844/* Implementation of the "reinterpret_cast" method. */
845
846static PyObject *
847valpy_reinterpret_cast (PyObject *self, PyObject *args)
848{
849 return valpy_do_cast (self, args, UNOP_REINTERPRET_CAST);
850}
851
852static Py_ssize_t
853valpy_length (PyObject *self)
854{
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."));
858 return -1;
859}
860
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. */
863
864static int
865value_has_field (struct value *v, PyObject *field)
866{
867 struct type *parent_type, *val_type;
868 enum type_code type_code;
869 gdbpy_ref<> type_object (PyObject_GetAttrString (field, "parent_type"));
870 int has_field = 0;
871
872 if (type_object == NULL)
873 return -1;
874
875 parent_type = type_object_to_type (type_object.get ());
876 if (parent_type == NULL)
877 {
878 PyErr_SetString (PyExc_TypeError,
879 _("'parent_type' attribute of gdb.Field object is not a"
880 "gdb.Type object."));
881 return -1;
882 }
883
884 try
885 {
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 ());
890
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))
894 has_field = 1;
895 else
896 has_field = 0;
897 }
898 catch (const gdb_exception &except)
899 {
901 }
902
903 return has_field;
904}
905
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. */
909
910static int
911get_field_flag (PyObject *field, const char *flag_name)
912{
913 gdbpy_ref<> flag_object (PyObject_GetAttrString (field, flag_name));
914
915 if (flag_object == NULL)
916 return -1;
917
918 return PyObject_IsTrue (flag_object.get ());
919}
920
921/* Return the "type" attribute of a gdb.Field object.
922 Returns NULL on error, with a Python exception set. */
923
924static struct type *
926{
927 gdbpy_ref<> ftype_obj (PyObject_GetAttrString (field, "type"));
928 struct type *ftype;
929
930 if (ftype_obj == NULL)
931 return NULL;
932 ftype = type_object_to_type (ftype_obj.get ());
933 if (ftype == NULL)
934 PyErr_SetString (PyExc_TypeError,
935 _("'type' attribute of gdb.Field object is not a "
936 "gdb.Type object."));
937
938 return ftype;
939}
940
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
943 exception set. */
944
945static PyObject *
946valpy_getitem (PyObject *self, PyObject *key)
947{
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;
952 long bitpos = -1;
953 PyObject *result = NULL;
954
955 if (gdbpy_is_string (key))
956 {
958 if (field == NULL)
959 return NULL;
960 }
961 else if (gdbpy_is_field (key))
962 {
963 int is_base_class, valid_field;
964
965 valid_field = value_has_field (self_value->value, key);
966 if (valid_field < 0)
967 return NULL;
968 else if (valid_field == 0)
969 {
970 PyErr_SetString (PyExc_TypeError,
971 _("Invalid lookup for a field not contained in "
972 "the value."));
973
974 return NULL;
975 }
976
977 is_base_class = get_field_flag (key, "is_base_class");
978 if (is_base_class < 0)
979 return NULL;
980 else if (is_base_class > 0)
981 {
982 base_class_type = get_field_type (key);
983 if (base_class_type == NULL)
984 return NULL;
985 }
986 else
987 {
988 gdbpy_ref<> name_obj (PyObject_GetAttrString (key, "name"));
989
990 if (name_obj == NULL)
991 return NULL;
992
993 if (name_obj != Py_None)
994 {
995 field = python_string_to_host_string (name_obj.get ());
996 if (field == NULL)
997 return NULL;
998 }
999 else
1000 {
1001 if (!PyObject_HasAttrString (key, "bitpos"))
1002 {
1003 PyErr_SetString (PyExc_AttributeError,
1004 _("gdb.Field object has no name and no "
1005 "'bitpos' attribute."));
1006
1007 return NULL;
1008 }
1009 gdbpy_ref<> bitpos_obj (PyObject_GetAttrString (key, "bitpos"));
1010 if (bitpos_obj == NULL)
1011 return NULL;
1012 if (!gdb_py_int_as_long (bitpos_obj.get (), &bitpos))
1013 return NULL;
1014
1015 field_type = get_field_type (key);
1016 if (field_type == NULL)
1017 return NULL;
1018 }
1019 }
1020 }
1021
1022 try
1023 {
1024 struct value *tmp = self_value->value;
1025 struct value *res_val = NULL;
1026 scoped_value_mark free_values;
1027
1028 if (field)
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)
1035 {
1036 struct type *val_type;
1037
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),
1043 tmp);
1044 else if (val_type->code () == TYPE_CODE_RVALUE_REF)
1045 res_val = value_cast (lookup_rvalue_reference_type (base_class_type),
1046 tmp);
1047 else
1048 res_val = value_cast (base_class_type, tmp);
1049 }
1050 else
1051 {
1052 /* Assume we are attempting an array access, and let the
1053 value code throw an exception if the index has an invalid
1054 type. */
1055 struct value *idx = convert_value_from_python (key);
1056
1057 if (idx != NULL)
1058 {
1059 /* Check the value's type is something that can be accessed via
1060 a subscript. */
1061 struct type *type;
1062
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."));
1068 else
1069 res_val = value_subscript (tmp, value_as_long (idx));
1070 }
1071 }
1072
1073 if (res_val)
1074 result = value_to_value_object (res_val);
1075 }
1076 catch (gdb_exception &ex)
1077 {
1078 except = std::move (ex);
1079 }
1080
1081 GDB_PY_HANDLE_EXCEPTION (except);
1082
1083 return result;
1084}
1085
1086static int
1087valpy_setitem (PyObject *self, PyObject *key, PyObject *value)
1088{
1089 PyErr_Format (PyExc_NotImplementedError,
1090 _("Setting of struct elements is not currently supported."));
1091 return -1;
1092}
1093
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. */
1096static PyObject *
1097valpy_call (PyObject *self, PyObject *args, PyObject *keywords)
1098{
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;
1104
1105 try
1106 {
1107 ftype = check_typedef (value_type (function));
1108 }
1109 catch (const gdb_exception &except)
1110 {
1111 GDB_PY_HANDLE_EXCEPTION (except);
1112 }
1113
1114 if (ftype->code () != TYPE_CODE_FUNC)
1115 {
1116 PyErr_SetString (PyExc_RuntimeError,
1117 _("Value is not callable (not TYPE_CODE_FUNC)."));
1118 return NULL;
1119 }
1120
1121 if (! PyTuple_Check (args))
1122 {
1123 PyErr_SetString (PyExc_TypeError,
1124 _("Inferior arguments must be provided in a tuple."));
1125 return NULL;
1126 }
1127
1128 args_count = PyTuple_Size (args);
1129 if (args_count > 0)
1130 {
1131 int i;
1132
1133 vargs = XALLOCAVEC (struct value *, args_count);
1134 for (i = 0; i < args_count; i++)
1135 {
1136 PyObject *item = PyTuple_GetItem (args, i);
1137
1138 if (item == NULL)
1139 return NULL;
1140
1141 vargs[i] = convert_value_from_python (item);
1142 if (vargs[i] == NULL)
1143 return NULL;
1144 }
1145 }
1146
1147 try
1148 {
1149 scoped_value_mark free_values;
1150
1151 value *return_value
1152 = call_function_by_hand (function, NULL,
1153 gdb::make_array_view (vargs, args_count));
1154 result = value_to_value_object (return_value);
1155 }
1156 catch (const gdb_exception &except)
1157 {
1158 GDB_PY_HANDLE_EXCEPTION (except);
1159 }
1160
1161 return result;
1162}
1163
1164/* Called by the Python interpreter to obtain string representation
1165 of the object. */
1166static PyObject *
1167valpy_str (PyObject *self)
1168{
1169 struct value_print_options opts;
1170
1172 opts.deref_ref = 0;
1173
1174 string_file stb;
1175
1176 try
1177 {
1178 common_val_print (((value_object *) self)->value, &stb, 0,
1179 &opts, current_language);
1180 }
1181 catch (const gdb_exception &except)
1182 {
1183 GDB_PY_HANDLE_EXCEPTION (except);
1184 }
1185
1186 return PyUnicode_Decode (stb.c_str (), stb.size (), host_charset (), NULL);
1187}
1188
1189/* Implements gdb.Value.is_optimized_out. */
1190static PyObject *
1191valpy_get_is_optimized_out (PyObject *self, void *closure)
1192{
1193 struct value *value = ((value_object *) self)->value;
1194 int opt = 0;
1195
1196 try
1197 {
1198 opt = value_optimized_out (value);
1199 }
1200 catch (const gdb_exception &except)
1201 {
1202 GDB_PY_HANDLE_EXCEPTION (except);
1203 }
1204
1205 if (opt)
1206 Py_RETURN_TRUE;
1207
1208 Py_RETURN_FALSE;
1209}
1210
1211/* Implements gdb.Value.is_lazy. */
1212static PyObject *
1213valpy_get_is_lazy (PyObject *self, void *closure)
1214{
1215 struct value *value = ((value_object *) self)->value;
1216 int opt = 0;
1217
1218 try
1219 {
1220 opt = value_lazy (value);
1221 }
1222 catch (const gdb_exception &except)
1223 {
1224 GDB_PY_HANDLE_EXCEPTION (except);
1225 }
1226
1227 if (opt)
1228 Py_RETURN_TRUE;
1229
1230 Py_RETURN_FALSE;
1231}
1232
1233/* Implements gdb.Value.fetch_lazy (). */
1234static PyObject *
1235valpy_fetch_lazy (PyObject *self, PyObject *args)
1236{
1237 struct value *value = ((value_object *) self)->value;
1238
1239 try
1240 {
1241 if (value_lazy (value))
1243 }
1244 catch (const gdb_exception &except)
1245 {
1246 GDB_PY_HANDLE_EXCEPTION (except);
1247 }
1248
1249 Py_RETURN_NONE;
1250}
1251
1252/* Calculate and return the address of the PyObject as the value of
1253 the builtin __hash__ call. */
1254static Py_hash_t
1255valpy_hash (PyObject *self)
1256{
1257 return (intptr_t) self;
1258}
1259
1261{
1274
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))
1278
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. */
1282
1283static PyObject *
1284valpy_binop_throw (enum valpy_opcode opcode, PyObject *self, PyObject *other)
1285{
1286 PyObject *result = NULL;
1287
1288 struct value *arg1, *arg2;
1289 struct value *res_val = NULL;
1290 enum exp_opcode op = OP_NULL;
1291 int handled = 0;
1292
1293 scoped_value_mark free_values;
1294
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
1299 python as well. */
1300 arg1 = convert_value_from_python (self);
1301 if (arg1 == NULL)
1302 return NULL;
1303
1304 arg2 = convert_value_from_python (other);
1305 if (arg2 == NULL)
1306 return NULL;
1307
1308 switch (opcode)
1309 {
1310 case VALPY_ADD:
1311 {
1312 struct type *ltype = value_type (arg1);
1313 struct type *rtype = value_type (arg2);
1314
1315 ltype = check_typedef (ltype);
1316 ltype = STRIP_REFERENCE (ltype);
1317 rtype = check_typedef (rtype);
1318 rtype = STRIP_REFERENCE (rtype);
1319
1320 handled = 1;
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));
1327 else
1328 {
1329 handled = 0;
1330 op = BINOP_ADD;
1331 }
1332 }
1333 break;
1334 case VALPY_SUB:
1335 {
1336 struct type *ltype = value_type (arg1);
1337 struct type *rtype = value_type (arg2);
1338
1339 ltype = check_typedef (ltype);
1340 ltype = STRIP_REFERENCE (ltype);
1341 rtype = check_typedef (rtype);
1342 rtype = STRIP_REFERENCE (rtype);
1343
1344 handled = 1;
1345 if (ltype->code () == TYPE_CODE_PTR
1346 && rtype->code () == TYPE_CODE_PTR)
1347 /* A ptrdiff_t for the target would be preferable here. */
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));
1353 else
1354 {
1355 handled = 0;
1356 op = BINOP_SUB;
1357 }
1358 }
1359 break;
1360 case VALPY_MUL:
1361 op = BINOP_MUL;
1362 break;
1363 case VALPY_DIV:
1364 op = BINOP_DIV;
1365 break;
1366 case VALPY_REM:
1367 op = BINOP_REM;
1368 break;
1369 case VALPY_POW:
1370 op = BINOP_EXP;
1371 break;
1372 case VALPY_LSH:
1373 op = BINOP_LSH;
1374 break;
1375 case VALPY_RSH:
1376 op = BINOP_RSH;
1377 break;
1378 case VALPY_BITAND:
1379 op = BINOP_BITWISE_AND;
1380 break;
1381 case VALPY_BITOR:
1382 op = BINOP_BITWISE_IOR;
1383 break;
1384 case VALPY_BITXOR:
1385 op = BINOP_BITWISE_XOR;
1386 break;
1387 }
1388
1389 if (!handled)
1390 {
1391 if (binop_user_defined_p (op, arg1, arg2))
1392 res_val = value_x_binop (arg1, arg2, op, OP_NULL, EVAL_NORMAL);
1393 else
1394 res_val = value_binop (arg1, arg2, op);
1395 }
1396
1397 if (res_val)
1398 result = value_to_value_object (res_val);
1399
1400 return result;
1401}
1402
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. */
1406static PyObject *
1407valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other)
1408{
1409 PyObject *result = NULL;
1410
1411 try
1412 {
1413 result = valpy_binop_throw (opcode, self, other);
1414 }
1415 catch (const gdb_exception &except)
1416 {
1417 GDB_PY_HANDLE_EXCEPTION (except);
1418 }
1419
1420 return result;
1421}
1422
1423static PyObject *
1424valpy_add (PyObject *self, PyObject *other)
1425{
1426 return valpy_binop (VALPY_ADD, self, other);
1427}
1428
1429static PyObject *
1430valpy_subtract (PyObject *self, PyObject *other)
1431{
1432 return valpy_binop (VALPY_SUB, self, other);
1433}
1434
1435static PyObject *
1436valpy_multiply (PyObject *self, PyObject *other)
1437{
1438 return valpy_binop (VALPY_MUL, self, other);
1439}
1440
1441static PyObject *
1442valpy_divide (PyObject *self, PyObject *other)
1443{
1444 return valpy_binop (VALPY_DIV, self, other);
1445}
1446
1447static PyObject *
1448valpy_remainder (PyObject *self, PyObject *other)
1449{
1450 return valpy_binop (VALPY_REM, self, other);
1451}
1452
1453static PyObject *
1454valpy_power (PyObject *self, PyObject *other, PyObject *unused)
1455{
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
1458 about it. */
1459 if (unused != Py_None)
1460 {
1461 PyErr_SetString (PyExc_NotImplementedError,
1462 "Invalid operation on gdb.Value.");
1463 return NULL;
1464 }
1465
1466 return valpy_binop (VALPY_POW, self, other);
1467}
1468
1469static PyObject *
1470valpy_negative (PyObject *self)
1471{
1472 PyObject *result = NULL;
1473
1474 try
1475 {
1476 /* Perhaps overkill, but consistency has some virtue. */
1477 scoped_value_mark free_values;
1478 struct value *val;
1479
1480 val = value_neg (((value_object *) self)->value);
1481 result = value_to_value_object (val);
1482 }
1483 catch (const gdb_exception &except)
1484 {
1485 GDB_PY_HANDLE_EXCEPTION (except);
1486 }
1487
1488 return result;
1489}
1490
1491static PyObject *
1492valpy_positive (PyObject *self)
1493{
1494 return value_to_value_object (((value_object *) self)->value);
1495}
1496
1497static PyObject *
1498valpy_absolute (PyObject *self)
1499{
1500 struct value *value = ((value_object *) self)->value;
1501 int isabs = 1;
1502
1503 try
1504 {
1505 scoped_value_mark free_values;
1506
1508 isabs = 0;
1509 }
1510 catch (const gdb_exception &except)
1511 {
1512 GDB_PY_HANDLE_EXCEPTION (except);
1513 }
1514
1515 if (isabs)
1516 return valpy_positive (self);
1517 else
1518 return valpy_negative (self);
1519}
1520
1521/* Implements boolean evaluation of gdb.Value. */
1522static int
1523valpy_nonzero (PyObject *self)
1524{
1525 struct gdb_exception except;
1526 value_object *self_value = (value_object *) self;
1527 struct type *type;
1528 int nonzero = 0; /* Appease GCC warning. */
1529
1530 try
1531 {
1532 type = check_typedef (value_type (self_value->value));
1533
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);
1539 else
1540 /* All other values are True. */
1541 nonzero = 1;
1542 }
1543 catch (gdb_exception &ex)
1544 {
1545 except = std::move (ex);
1546 }
1547
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). */
1552
1553 return nonzero;
1554}
1555
1556/* Implements ~ for value objects. */
1557static PyObject *
1558valpy_invert (PyObject *self)
1559{
1560 struct value *val = NULL;
1561
1562 try
1563 {
1564 val = value_complement (((value_object *) self)->value);
1565 }
1566 catch (const gdb_exception &except)
1567 {
1568 GDB_PY_HANDLE_EXCEPTION (except);
1569 }
1570
1571 return value_to_value_object (val);
1572}
1573
1574/* Implements left shift for value objects. */
1575static PyObject *
1576valpy_lsh (PyObject *self, PyObject *other)
1577{
1578 return valpy_binop (VALPY_LSH, self, other);
1579}
1580
1581/* Implements right shift for value objects. */
1582static PyObject *
1583valpy_rsh (PyObject *self, PyObject *other)
1584{
1585 return valpy_binop (VALPY_RSH, self, other);
1586}
1587
1588/* Implements bitwise and for value objects. */
1589static PyObject *
1590valpy_and (PyObject *self, PyObject *other)
1591{
1592 return valpy_binop (VALPY_BITAND, self, other);
1593}
1594
1595/* Implements bitwise or for value objects. */
1596static PyObject *
1597valpy_or (PyObject *self, PyObject *other)
1598{
1599 return valpy_binop (VALPY_BITOR, self, other);
1600}
1601
1602/* Implements bitwise xor for value objects. */
1603static PyObject *
1604valpy_xor (PyObject *self, PyObject *other)
1605{
1606 return valpy_binop (VALPY_BITXOR, self, other);
1607}
1608
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.). */
1613
1614static int
1615valpy_richcompare_throw (PyObject *self, PyObject *other, int op)
1616{
1617 int result;
1618 struct value *value_other;
1619 struct value *value_self;
1620
1621 scoped_value_mark free_values;
1622
1623 value_other = convert_value_from_python (other);
1624 if (value_other == NULL)
1625 return -1;
1626
1627 value_self = ((value_object *) self)->value;
1628
1629 switch (op)
1630 {
1631 case Py_LT:
1632 result = value_less (value_self, value_other);
1633 break;
1634 case Py_LE:
1635 result = value_less (value_self, value_other)
1636 || value_equal (value_self, value_other);
1637 break;
1638 case Py_EQ:
1639 result = value_equal (value_self, value_other);
1640 break;
1641 case Py_NE:
1642 result = !value_equal (value_self, value_other);
1643 break;
1644 case Py_GT:
1645 result = value_less (value_other, value_self);
1646 break;
1647 case Py_GE:
1648 result = (value_less (value_other, value_self)
1649 || value_equal (value_self, value_other));
1650 break;
1651 default:
1652 /* Can't happen. */
1653 PyErr_SetString (PyExc_NotImplementedError,
1654 _("Invalid operation on gdb.Value."));
1655 result = -1;
1656 break;
1657 }
1658
1659 return result;
1660}
1661
1662
1663/* Implements comparison operations for value objects. Returns NULL on error,
1664 with a python exception set. */
1665static PyObject *
1666valpy_richcompare (PyObject *self, PyObject *other, int op)
1667{
1668 int result = 0;
1669
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. */
1673 switch (op) {
1674 case Py_LT:
1675 case Py_LE:
1676 case Py_EQ:
1677 Py_RETURN_FALSE;
1678 case Py_NE:
1679 case Py_GT:
1680 case Py_GE:
1681 Py_RETURN_TRUE;
1682 default:
1683 /* Can't happen. */
1684 PyErr_SetString (PyExc_NotImplementedError,
1685 _("Invalid operation on gdb.Value."));
1686 return NULL;
1687 }
1688
1689 try
1690 {
1691 result = valpy_richcompare_throw (self, other, op);
1692 }
1693 catch (const gdb_exception &except)
1694 {
1695 GDB_PY_HANDLE_EXCEPTION (except);
1696 }
1697
1698 /* In this case, the Python exception has already been set. */
1699 if (result < 0)
1700 return NULL;
1701
1702 if (result == 1)
1703 Py_RETURN_TRUE;
1704
1705 Py_RETURN_FALSE;
1706}
1707
1708/* Implements conversion to long. */
1709static PyObject *
1710valpy_long (PyObject *self)
1711{
1712 struct value *value = ((value_object *) self)->value;
1713 struct type *type = value_type (value);
1714 LONGEST l = 0;
1715
1716 try
1717 {
1719 {
1722 }
1723
1725
1726 if (!is_integral_type (type)
1727 && type->code () != TYPE_CODE_PTR)
1728 error (_("Cannot convert value to long."));
1729
1730 l = value_as_long (value);
1731 }
1732 catch (const gdb_exception &except)
1733 {
1734 GDB_PY_HANDLE_EXCEPTION (except);
1735 }
1736
1737 if (type->is_unsigned ())
1738 return gdb_py_object_from_ulongest (l).release ();
1739 else
1740 return gdb_py_object_from_longest (l).release ();
1741}
1742
1743/* Implements conversion to float. */
1744static PyObject *
1745valpy_float (PyObject *self)
1746{
1747 struct value *value = ((value_object *) self)->value;
1748 struct type *type = value_type (value);
1749 double d = 0;
1750
1751 try
1752 {
1754
1755 if (type->code () == TYPE_CODE_FLT && is_floating_value (value))
1757 else if (type->code () == TYPE_CODE_INT)
1758 {
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);
1763 }
1764 else
1765 error (_("Cannot convert value to float."));
1766 }
1767 catch (const gdb_exception &except)
1768 {
1769 GDB_PY_HANDLE_EXCEPTION (except);
1770 }
1771
1772 return PyFloat_FromDouble (d);
1773}
1774
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. */
1777PyObject *
1779{
1780 value_object *val_obj;
1781
1782 val_obj = PyObject_New (value_object, &value_object_type);
1783 if (val_obj != NULL)
1784 {
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);
1792 }
1793
1794 return (PyObject *) val_obj;
1795}
1796
1797/* Returns an object for a value, but without releasing it from the
1798 all_values chain. */
1799PyObject *
1801{
1802 value_object *val_obj;
1803
1804 val_obj = PyObject_New (value_object, &value_object_type);
1805 if (val_obj != NULL)
1806 {
1807 value_incref (val);
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);
1815 }
1816
1817 return (PyObject *) val_obj;
1818}
1819
1820/* Returns a borrowed reference to the struct value corresponding to
1821 the given value object. */
1822struct value *
1824{
1825 value_object *real;
1826
1827 if (! PyObject_TypeCheck (self, &value_object_type))
1828 return NULL;
1829 real = (value_object *) self;
1830 return real->value;
1831}
1832
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. */
1836
1837struct value *
1839{
1840 struct value *value = NULL; /* -Wall */
1841 int cmp;
1842
1843 gdb_assert (obj != NULL);
1844
1845 try
1846 {
1847 if (PyBool_Check (obj))
1848 {
1849 cmp = PyObject_IsTrue (obj);
1850 if (cmp >= 0)
1852 }
1853 else if (PyLong_Check (obj))
1854 {
1855 LONGEST l = PyLong_AsLongLong (obj);
1856
1857 if (PyErr_Occurred ())
1858 {
1859 /* If the error was an overflow, we can try converting to
1860 ULONGEST instead. */
1861 if (PyErr_ExceptionMatches (PyExc_OverflowError))
1862 {
1863 gdbpy_err_fetch fetched_error;
1865
1866 /* Check whether obj is positive. */
1867 if (PyObject_RichCompareBool (obj, zero.get (), Py_GT) > 0)
1868 {
1869 ULONGEST ul;
1870
1871 ul = PyLong_AsUnsignedLongLong (obj);
1872 if (! PyErr_Occurred ())
1874 }
1875 else
1876 {
1877 /* There's nothing we can do. */
1878 fetched_error.restore ();
1879 }
1880 }
1881 }
1882 else
1884 }
1885 else if (PyFloat_Check (obj))
1886 {
1887 double d = PyFloat_AsDouble (obj);
1888
1889 if (! PyErr_Occurred ())
1891 }
1892 else if (gdbpy_is_string (obj))
1893 {
1894 gdb::unique_xmalloc_ptr<char> s
1896 if (s != NULL)
1897 value = value_cstring (s.get (), strlen (s.get ()),
1899 }
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))
1903 {
1904 PyObject *result;
1905
1906 result = PyObject_CallMethodObjArgs (obj, gdbpy_value_cst, NULL);
1907 value = value_copy (((value_object *) result)->value);
1908 }
1909 else
1910 PyErr_Format (PyExc_TypeError,
1911 _("Could not convert Python object: %S."), obj);
1912 }
1913 catch (const gdb_exception &except)
1914 {
1915 gdbpy_convert_exception (except);
1916 return NULL;
1917 }
1918
1919 return value;
1920}
1921
1922/* Returns value object in the ARGth position in GDB's history. */
1923PyObject *
1924gdbpy_history (PyObject *self, PyObject *args)
1925{
1926 int i;
1927 struct value *res_val = NULL; /* Initialize to appease gcc warning. */
1928
1929 if (!PyArg_ParseTuple (args, "i", &i))
1930 return NULL;
1931
1932 try
1933 {
1934 res_val = access_value_history (i);
1935 }
1936 catch (const gdb_exception &except)
1937 {
1938 GDB_PY_HANDLE_EXCEPTION (except);
1939 }
1940
1941 return value_to_value_object (res_val);
1942}
1943
1944/* Add a gdb.Value into GDB's history, and return (as an integer) the
1945 position of the newly added value. */
1946PyObject *
1947gdbpy_add_history (PyObject *self, PyObject *args)
1948{
1949 PyObject *value_obj;
1950
1951 if (!PyArg_ParseTuple (args, "O", &value_obj))
1952 return nullptr;
1953
1954 struct value *value = convert_value_from_python (value_obj);
1955 if (value == nullptr)
1956 return nullptr;
1957
1958 try
1959 {
1960 int idx = record_latest_value (value);
1961 return gdb_py_object_from_longest (idx).release ();
1962 }
1963 catch (const gdb_exception &except)
1964 {
1965 GDB_PY_HANDLE_EXCEPTION (except);
1966 }
1967
1968 return nullptr;
1969}
1970
1971/* Return an integer, the number of items in GDB's history. */
1972
1973PyObject *
1974gdbpy_history_count (PyObject *self, PyObject *args)
1975{
1976 return gdb_py_object_from_ulongest (value_history_count ()).release ();
1977}
1978
1979/* Return the value of a convenience variable. */
1980PyObject *
1981gdbpy_convenience_variable (PyObject *self, PyObject *args)
1982{
1983 const char *varname;
1984 struct value *res_val = NULL;
1985
1986 if (!PyArg_ParseTuple (args, "s", &varname))
1987 return NULL;
1988
1989 try
1990 {
1991 struct internalvar *var = lookup_only_internalvar (varname);
1992
1993 if (var != NULL)
1994 {
1996 if (value_type (res_val)->code () == TYPE_CODE_VOID)
1997 res_val = NULL;
1998 }
1999 }
2000 catch (const gdb_exception &except)
2001 {
2002 GDB_PY_HANDLE_EXCEPTION (except);
2003 }
2004
2005 if (res_val == NULL)
2006 Py_RETURN_NONE;
2007
2008 return value_to_value_object (res_val);
2009}
2010
2011/* Set the value of a convenience variable. */
2012PyObject *
2013gdbpy_set_convenience_variable (PyObject *self, PyObject *args)
2014{
2015 const char *varname;
2016 PyObject *value_obj;
2017 struct value *value = NULL;
2018
2019 if (!PyArg_ParseTuple (args, "sO", &varname, &value_obj))
2020 return NULL;
2021
2022 /* None means to clear the variable. */
2023 if (value_obj != Py_None)
2024 {
2025 value = convert_value_from_python (value_obj);
2026 if (value == NULL)
2027 return NULL;
2028 }
2029
2030 try
2031 {
2032 if (value == NULL)
2033 {
2034 struct internalvar *var = lookup_only_internalvar (varname);
2035
2036 if (var != NULL)
2037 clear_internalvar (var);
2038 }
2039 else
2040 {
2041 struct internalvar *var = lookup_internalvar (varname);
2042
2043 set_internalvar (var, value);
2044 }
2045 }
2046 catch (const gdb_exception &except)
2047 {
2048 GDB_PY_HANDLE_EXCEPTION (except);
2049 }
2050
2051 Py_RETURN_NONE;
2052}
2053
2054/* Returns 1 in OBJ is a gdb.Value object, 0 otherwise. */
2055
2056int
2058{
2059 return PyObject_TypeCheck (obj, &value_object_type);
2060}
2061
2062int
2064{
2065 if (PyType_Ready (&value_object_type) < 0)
2066 return -1;
2067
2068 return gdb_pymodule_addobject (gdb_module, "Value",
2069 (PyObject *) &value_object_type);
2070}
2071
2072
2073
2075 { "address", valpy_get_address, NULL, "The address of the value.",
2076 NULL },
2077 { "is_optimized_out", valpy_get_is_optimized_out, NULL,
2078 "Boolean telling whether the value is optimized "
2079 "out (i.e., not available).",
2080 NULL },
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\
2086from the inferior). A lazy value is fetched when needed, or when\n\
2087the \"fetch_lazy()\" method is called.", NULL },
2088 {NULL} /* Sentinel */
2089};
2090
2091static 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\
2095Cast the value to the supplied type, as if by the C++ dynamic_cast operator."
2096 },
2097 { "reinterpret_cast", valpy_reinterpret_cast, METH_VARARGS,
2098 "reinterpret_cast (gdb.Type) -> gdb.Value\n\
2099Cast the value to the supplied type, as if by the C++\n\
2100reinterpret_cast operator."
2101 },
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\
2114Return a lazy string representation of the value." },
2115 { "string", (PyCFunction) valpy_string, METH_VARARGS | METH_KEYWORDS,
2116 "string ([encoding] [, errors] [, length]) -> string\n\
2117Return 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\
2123Return a string representation of the value using the specified\n\
2124formatting options" },
2125 {NULL} /* Sentinel */
2126};
2127
2128static PyNumberMethods value_object_as_number = {
2129 valpy_add,
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 */
2163};
2164
2165static PyMappingMethods value_object_as_mapping = {
2169};
2170
2171PyTypeObject value_object_type = {
2172 PyVarObject_HEAD_INIT (NULL, 0)
2173 "gdb.Value", /*tp_name*/
2174 sizeof (value_object), /*tp_basicsize*/
2175 0, /*tp_itemsize*/
2176 valpy_dealloc, /*tp_dealloc*/
2177 0, /*tp_print*/
2178 0, /*tp_getattr*/
2179 0, /*tp_setattr*/
2180 0, /*tp_compare*/
2181 0, /*tp_repr*/
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*/
2188 0, /*tp_getattro*/
2189 0, /*tp_setattro*/
2190 0, /*tp_as_buffer*/
2191 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES
2192 | Py_TPFLAGS_BASETYPE, /*tp_flags*/
2193 "GDB value object", /* tp_doc */
2194 0, /* tp_traverse */
2195 0, /* tp_clear */
2196 valpy_richcompare, /* tp_richcompare */
2197 0, /* tp_weaklistoffset */
2198 0, /* tp_iter */
2199 0, /* tp_iternext */
2200 value_object_methods, /* tp_methods */
2201 0, /* tp_members */
2202 value_object_getset, /* tp_getset */
2203 0, /* tp_base */
2204 0, /* tp_dict */
2205 0, /* tp_descr_get */
2206 0, /* tp_descr_set */
2207 0, /* tp_dictoffset */
2208 valpy_init, /* tp_init */
2209 0, /* tp_alloc */
2210 PyType_GenericNew, /* tp_new */
2211};
int code
Definition: ada-lex.l:688
void c_get_string(struct value *value, gdb::unique_xmalloc_ptr< gdb_byte > *buffer, int *length, struct type **char_type, const char **charset)
Definition: c-lang.c:243
const char * host_charset(void)
Definition: charset.c:416
static struct gdbarch * get_gdbarch()
Definition: python.c:245
size_t size() const
Definition: ui-file.h:219
const char * c_str() const
Definition: ui-file.h:218
struct type * value_rtti_type(struct value *v, int *full, LONGEST *top, int *using_enc)
Definition: cp-abi.c:107
@ not_lval
Definition: defs.h:362
#define UINT_MAX
Definition: defs.h:453
exp_opcode
Definition: expression.h:44
@ EVAL_NORMAL
Definition: expression.h:56
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:402
struct type * lookup_lvalue_reference_type(struct type *type)
Definition: gdbtypes.c:490
int is_integral_type(struct type *t)
Definition: gdbtypes.c:3772
struct type * lookup_array_range_type(struct type *element_type, LONGEST low_bound, LONGEST high_bound)
Definition: gdbtypes.c:1431
struct type * lookup_rvalue_reference_type(struct type *type)
Definition: gdbtypes.c:498
bool get_array_bounds(struct type *type, LONGEST *low_bound, LONGEST *high_bound)
Definition: gdbtypes.c:1220
bool types_equal(struct type *a, struct type *b)
Definition: gdbtypes.c:4232
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:3010
type_code
Definition: gdbtypes.h:99
struct value * call_function_by_hand(struct value *function, type *default_return_type, gdb::array_view< value * > args)
Definition: infcall.c:781
const struct language_defn * current_language
Definition: language.c:83
int gdbpy_is_lazy_string(PyObject *result)
PyObject * gdbpy_create_lazy_string_object(CORE_ADDR address, long length, const char *encoding, struct type *type)
void gdbpy_get_print_options(value_print_options *opts)
gdb::ref_ptr< T, gdbpy_ref_policy< T > > gdbpy_ref
Definition: py-ref.h:43
PyObject * type_to_type_object(struct type *type)
Definition: py-type.c:1381
int gdbpy_is_field(PyObject *obj)
Definition: py-type.c:126
struct type * type_object_to_type(PyObject *obj)
Definition: py-type.c:1404
gdb::unique_xmalloc_ptr< char > python_string_to_target_string(PyObject *obj)
Definition: py-utils.c:113
gdbpy_ref gdb_py_object_from_longest(LONGEST l)
Definition: py-utils.c:279
void gdbpy_convert_exception(const struct gdb_exception &exception)
Definition: py-utils.c:216
int gdb_py_int_as_long(PyObject *obj, long *result)
Definition: py-utils.c:301
int gdb_pymodule_addobject(PyObject *module, const char *name, PyObject *object)
Definition: py-utils.c:331
gdb::unique_xmalloc_ptr< char > python_string_to_host_string(PyObject *obj)
Definition: py-utils.c:141
int gdbpy_is_string(PyObject *obj)
Definition: py-utils.c:163
gdbpy_ref gdb_py_object_from_ulongest(ULONGEST l)
Definition: py-utils.c:290
static int get_field_flag(PyObject *field, const char *flag_name)
Definition: py-value.c:911
static int valpy_richcompare_throw(PyObject *self, PyObject *other, int op)
Definition: py-value.c:1615
struct value * convert_value_from_python(PyObject *obj)
Definition: py-value.c:1838
static PyObject * valpy_divide(PyObject *self, PyObject *other)
Definition: py-value.c:1442
static void valpy_clear_value(value_object *self)
Definition: py-value.c:81
#define builtin_type_pylong
Definition: py-value.c:46
static PyObject * valpy_string(PyObject *self, PyObject *args, PyObject *kw)
Definition: py-value.c:573
static PyObject * valpy_richcompare(PyObject *self, PyObject *other, int op)
Definition: py-value.c:1666
static int valpy_nonzero(PyObject *self)
Definition: py-value.c:1523
valpy_opcode
Definition: py-value.c:1261
@ VALPY_ADD
Definition: py-value.c:1262
@ VALPY_SUB
Definition: py-value.c:1263
@ VALPY_BITOR
Definition: py-value.c:1271
@ VALPY_BITXOR
Definition: py-value.c:1272
@ VALPY_POW
Definition: py-value.c:1267
@ VALPY_BITAND
Definition: py-value.c:1270
@ VALPY_DIV
Definition: py-value.c:1265
@ VALPY_LSH
Definition: py-value.c:1268
@ VALPY_MUL
Definition: py-value.c:1264
@ VALPY_RSH
Definition: py-value.c:1269
@ VALPY_REM
Definition: py-value.c:1266
#define builtin_type_pybool
Definition: py-value.c:53
static PyObject * valpy_lsh(PyObject *self, PyObject *other)
Definition: py-value.c:1576
static PyObject * valpy_reference_value(PyObject *self, PyObject *args, enum type_code refcode)
Definition: py-value.c:302
int gdbpy_is_value_object(PyObject *obj)
Definition: py-value.c:2057
static PyObject * valpy_do_cast(PyObject *self, PyObject *args, enum exp_opcode op)
Definition: py-value.c:786
static PyObject * valpy_add(PyObject *self, PyObject *other)
Definition: py-value.c:1424
PyObject * value_to_value_object_no_release(struct value *val)
Definition: py-value.c:1800
static int valpy_init(PyObject *self, PyObject *args, PyObject *kwds)
Definition: py-value.c:174
static int value_has_field(struct value *v, PyObject *field)
Definition: py-value.c:865
static Py_ssize_t valpy_length(PyObject *self)
Definition: py-value.c:853
static PyObject * valpy_rsh(PyObject *self, PyObject *other)
Definition: py-value.c:1583
static struct type * get_field_type(PyObject *field)
Definition: py-value.c:925
static PyObject * valpy_lazy_string(PyObject *self, PyObject *args, PyObject *kw)
Definition: py-value.c:485
static PyObject * valpy_get_dynamic_type(PyObject *self, void *closure)
Definition: py-value.c:405
static PyMethodDef value_object_methods[]
Definition: py-value.c:2091
PyObject * value_to_value_object(struct value *val)
Definition: py-value.c:1778
struct value * value_object_to_value(PyObject *self)
Definition: py-value.c:1823
static PyObject * valpy_invert(PyObject *self)
Definition: py-value.c:1558
static PyObject * valpy_xor(PyObject *self, PyObject *other)
Definition: py-value.c:1604
PyObject * gdbpy_add_history(PyObject *self, PyObject *args)
Definition: py-value.c:1947
static PyObject * valpy_call(PyObject *self, PyObject *args, PyObject *keywords)
Definition: py-value.c:1097
static PyObject * valpy_binop_throw(enum valpy_opcode opcode, PyObject *self, PyObject *other)
Definition: py-value.c:1284
static PyObject * valpy_long(PyObject *self)
Definition: py-value.c:1710
#define builtin_type_pychar
Definition: py-value.c:56
static PyObject * valpy_format_string(PyObject *self, PyObject *args, PyObject *kw)
Definition: py-value.c:630
static PyObject * valpy_get_address(PyObject *self, void *closure)
Definition: py-value.c:360
PyObject * gdbpy_history_count(PyObject *self, PyObject *args)
Definition: py-value.c:1974
static void valpy_dealloc(PyObject *obj)
Definition: py-value.c:94
static PyObject * valpy_reinterpret_cast(PyObject *self, PyObject *args)
Definition: py-value.c:847
static int valpy_setitem(PyObject *self, PyObject *key, PyObject *value)
Definition: py-value.c:1087
int gdbpy_initialize_values(void)
Definition: py-value.c:2063
static PyObject * valpy_positive(PyObject *self)
Definition: py-value.c:1492
static PyMappingMethods value_object_as_mapping
Definition: py-value.c:2165
PyTypeObject value_object_type
Definition: py-value.c:2171
static gdb_PyGetSetDef value_object_getset[]
Definition: py-value.c:2074
PyObject * gdbpy_history(PyObject *self, PyObject *args)
Definition: py-value.c:1924
static PyObject * valpy_rvalue_reference_value(PyObject *self, PyObject *args)
Definition: py-value.c:329
PyObject * gdbpy_set_convenience_variable(PyObject *self, PyObject *args)
Definition: py-value.c:2013
static bool copy_py_bool_obj(bool *dest, PyObject *src_obj)
Definition: py-value.c:612
static PyObject * valpy_float(PyObject *self)
Definition: py-value.c:1745
static PyObject * valpy_subtract(PyObject *self, PyObject *other)
Definition: py-value.c:1430
static PyObject * valpy_or(PyObject *self, PyObject *other)
Definition: py-value.c:1597
static PyObject * valpy_fetch_lazy(PyObject *self, PyObject *args)
Definition: py-value.c:1235
static PyObject * valpy_binop(enum valpy_opcode opcode, PyObject *self, PyObject *other)
Definition: py-value.c:1407
static PyObject * valpy_negative(PyObject *self)
Definition: py-value.c:1470
#define STRIP_REFERENCE(TYPE)
Definition: py-value.c:1276
static PyObject * valpy_power(PyObject *self, PyObject *other, PyObject *unused)
Definition: py-value.c:1454
static PyObject * valpy_absolute(PyObject *self)
Definition: py-value.c:1498
static PyObject * valpy_lvalue_reference_value(PyObject *self, PyObject *args)
Definition: py-value.c:323
#define builtin_type_pyint
Definition: py-value.c:38
static PyObject * valpy_dynamic_cast(PyObject *self, PyObject *args)
Definition: py-value.c:839
void gdbpy_preserve_values(const struct extension_language_defn *extlang, struct objfile *objfile, htab_t copied_types)
Definition: py-value.c:225
static PyObject * valpy_const_value(PyObject *self, PyObject *args)
Definition: py-value.c:337
static PyObject * valpy_remainder(PyObject *self, PyObject *other)
Definition: py-value.c:1448
static PyObject * valpy_cast(PyObject *self, PyObject *args)
Definition: py-value.c:831
static PyNumberMethods value_object_as_number
Definition: py-value.c:2128
static PyObject * valpy_get_type(PyObject *self, void *closure)
Definition: py-value.c:388
static PyObject * valpy_multiply(PyObject *self, PyObject *other)
Definition: py-value.c:1436
static struct value * convert_buffer_and_type_to_value(PyObject *obj, struct type *type)
Definition: py-value.c:142
static PyObject * valpy_get_is_lazy(PyObject *self, void *closure)
Definition: py-value.c:1213
PyObject * gdbpy_convenience_variable(PyObject *self, PyObject *args)
Definition: py-value.c:1981
static PyObject * valpy_get_is_optimized_out(PyObject *self, void *closure)
Definition: py-value.c:1191
static PyObject * valpy_dereference(PyObject *self, PyObject *args)
Definition: py-value.c:236
static Py_hash_t valpy_hash(PyObject *self)
Definition: py-value.c:1255
static PyObject * valpy_referenced_value(PyObject *self, PyObject *args)
Definition: py-value.c:265
static PyObject * valpy_str(PyObject *self)
Definition: py-value.c:1167
static PyObject * valpy_and(PyObject *self, PyObject *other)
Definition: py-value.c:1590
#define builtin_type_pyfloat
Definition: py-value.c:42
static PyObject * valpy_getitem(PyObject *self, PyObject *key)
Definition: py-value.c:946
static value_object * values_in_python
Definition: py-value.c:74
static void note_value(value_object *value_obj)
Definition: py-value.c:124
#define builtin_type_upylong
Definition: py-value.c:50
std::unique_ptr< Py_buffer, Py_buffer_deleter > Py_buffer_up
PyObject * gdb_module
Definition: python.c:84
long gdb_py_longest
#define GDB_PY_LL_ARG
#define Py_TPFLAGS_CHECKTYPES
#define GDB_PY_SET_HANDLE_EXCEPTION(Exception)
long Py_hash_t
PyObject * gdbpy_value_cst
Definition: python.c:93
#define GDB_PY_HANDLE_EXCEPTION(Exception)
static int gdb_PyArg_ParseTupleAndKeywords(PyObject *args, PyObject *kw, const char *format, const char **keywords,...)
Definition: gdbtypes.h:922
struct type * target_type() const
Definition: gdbtypes.h:1000
type_code code() const
Definition: gdbtypes.h:927
ULONGEST length() const
Definition: gdbtypes.h:954
bool is_unsigned() const
Definition: gdbtypes.h:1063
bool is_pointer_or_reference() const
Definition: gdbtypes.h:1394
PyObject * type
Definition: py-value.c:65
struct value * value
Definition: py-value.c:63
PyObject * dynamic_type
Definition: py-value.c:66
PyObject * address
Definition: py-value.c:64
struct value_object * prev
Definition: py-value.c:62
PyObject_HEAD struct value_object * next
Definition: py-value.c:61
Definition: value.c:181
void * closure
Definition: value.c:274
LONGEST bitpos
Definition: value.c:289
value(struct type *type_)
Definition: value.c:182
bool target_float_is_zero(const gdb_byte *addr, const struct type *type)
double target_float_to_host_double(const gdb_byte *addr, const struct type *type)
struct value * value_subscript(struct value *array, LONGEST index)
Definition: valarith.c:146
struct value * value_x_binop(struct value *arg1, struct value *arg2, enum exp_opcode op, enum exp_opcode otherop, enum noside noside)
Definition: valarith.c:369
struct value * value_neg(struct value *arg1)
Definition: valarith.c:1891
struct value * value_complement(struct value *arg1)
Definition: valarith.c:1937
int binop_user_defined_p(enum exp_opcode op, struct value *arg1, struct value *arg2)
Definition: valarith.c:277
int value_equal(struct value *arg1, struct value *arg2)
Definition: valarith.c:1728
int value_less(struct value *arg1, struct value *arg2)
Definition: valarith.c:1818
struct value * value_ptradd(struct value *arg1, LONGEST arg2)
Definition: valarith.c:84
LONGEST value_ptrdiff(struct value *arg1, struct value *arg2)
Definition: valarith.c:105
struct value * value_binop(struct value *arg1, struct value *arg2, enum exp_opcode op)
Definition: valarith.c:1633
struct value * value_cstring(const char *ptr, ssize_t len, struct type *char_type)
Definition: valops.c:1736
struct value * value_struct_elt(struct value **argp, gdb::optional< gdb::array_view< value * > > args, const char *name, int *static_memfuncp, const char *err)
Definition: valops.c:2335
struct value * value_addr(struct value *arg1)
Definition: valops.c:1543
struct value * value_cast(struct type *type, struct value *arg2)
Definition: valops.c:408
struct value * value_ind(struct value *arg1)
Definition: valops.c:1623
struct value * value_struct_elt_bitpos(struct value **argp, int bitpos, struct type *ftype, const char *err)
Definition: valops.c:2434
struct value * value_ref(struct value *arg1, enum type_code refcode)
Definition: valops.c:1602
struct value * value_dynamic_cast(struct type *type, struct value *arg)
Definition: valops.c:817
struct value * value_reinterpret_cast(struct type *type, struct value *arg)
Definition: valops.c:670
void common_val_print(struct value *value, struct ui_file *stream, int recurse, const struct value_print_options *options, const struct language_defn *language)
Definition: valprint.c:1014
struct type * value_type(const struct value *value)
Definition: value.c:1109
struct value * value_zero(struct type *type, enum lval_type lv)
Definition: value.c:3613
struct value * value_of_internalvar(struct gdbarch *gdbarch, struct internalvar *var)
Definition: value.c:2250
bool is_floating_value(struct value *val)
Definition: value.c:3020
int value_lazy(const struct value *value)
Definition: value.c:1440
void clear_internalvar(struct internalvar *var)
Definition: value.c:2498
CORE_ADDR value_as_address(struct value *val)
Definition: value.c:2804
void value_fetch_lazy(struct value *val)
Definition: value.c:4162
struct value * value_from_ulongest(struct type *type, ULONGEST num)
Definition: value.c:3637
void preserve_one_value(struct value *value, struct objfile *objfile, htab_t copied_types)
Definition: value.c:2618
struct internalvar * lookup_only_internalvar(const char *name)
Definition: value.c:2150
ULONGEST value_history_count()
Definition: value.c:1974
CORE_ADDR value_address(const struct value *value)
Definition: value.c:1607
int record_latest_value(struct value *val)
Definition: value.c:1926
struct value * value_from_longest(struct type *type, LONGEST num)
Definition: value.c:3625
struct value * coerce_ref(struct value *arg)
Definition: value.c:3902
struct value * value_from_contents(struct type *type, const gdb_byte *contents)
Definition: value.c:3730
void set_internalvar(struct internalvar *var, struct value *val)
Definition: value.c:2404
gdb::array_view< const gdb_byte > value_contents(struct value *value)
Definition: value.c:1464
void value_incref(struct value *val)
Definition: value.c:1677
struct internalvar * lookup_internalvar(const char *name)
Definition: value.c:2235
LONGEST value_as_long(struct value *val)
Definition: value.c:2791
struct value * make_cv_value(int cnst, int voltl, struct value *v)
Definition: value.c:1812
struct value * value_copy(const value *arg)
Definition: value.c:1760
int value_optimized_out(struct value *value)
Definition: value.c:1481
struct value * value_from_host_double(struct type *type, double d)
Definition: value.c:3665
struct value * access_value_history(int num)
Definition: value.c:1947
value_ref_ptr release_value(struct value *val)
Definition: value.c:1714
void value_decref(struct value *val)
Definition: value.c:1687