1 /* Python interface to values.
3 Copyright (C) 2008-2014 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/>. */
21 #include "gdb_assert.h"
24 #include "exceptions.h"
29 #include "expression.h"
33 #include "python-internal.h"
35 /* Even though Python scalar types directly map to host types, we use
36 target types here to remain consistent with the values system in
37 GDB (which uses target arithmetic). */
39 /* Python's integer type corresponds to C's long type. */
40 #define builtin_type_pyint builtin_type (python_gdbarch)->builtin_long
42 /* Python's float type corresponds to C's double type. */
43 #define builtin_type_pyfloat builtin_type (python_gdbarch)->builtin_double
45 /* Python's long type corresponds to C's long long type. */
46 #define builtin_type_pylong builtin_type (python_gdbarch)->builtin_long_long
48 /* Python's long type corresponds to C's long long type. Unsigned version. */
49 #define builtin_type_upylong builtin_type \
50 (python_gdbarch)->builtin_unsigned_long_long
52 #define builtin_type_pybool \
53 language_bool_type (python_language, python_gdbarch)
55 #define builtin_type_pychar \
56 language_string_char_type (python_language, python_gdbarch)
58 typedef struct value_object
{
60 struct value_object
*next
;
61 struct value_object
*prev
;
65 PyObject
*dynamic_type
;
68 /* List of all values which are currently exposed to Python. It is
69 maintained so that when an objfile is discarded, preserve_values
70 can copy the values' types if needed. */
71 /* This variable is unnecessarily initialized to NULL in order to
72 work around a linker bug on MacOS. */
73 static value_object
*values_in_python
= NULL
;
75 /* Called by the Python interpreter when deallocating a value object. */
77 valpy_dealloc (PyObject
*obj
)
79 value_object
*self
= (value_object
*) obj
;
81 /* Remove SELF from the global list. */
83 self
->prev
->next
= self
->next
;
86 gdb_assert (values_in_python
== self
);
87 values_in_python
= self
->next
;
90 self
->next
->prev
= self
->prev
;
92 value_free (self
->value
);
95 /* Use braces to appease gcc warning. *sigh* */
97 Py_DECREF (self
->address
);
102 Py_DECREF (self
->type
);
105 Py_XDECREF (self
->dynamic_type
);
107 Py_TYPE (self
)->tp_free (self
);
110 /* Helper to push a Value object on the global list. */
112 note_value (value_object
*value_obj
)
114 value_obj
->next
= values_in_python
;
116 value_obj
->next
->prev
= value_obj
;
117 value_obj
->prev
= NULL
;
118 values_in_python
= value_obj
;
121 /* Called when a new gdb.Value object needs to be allocated. Returns NULL on
122 error, with a python exception set. */
124 valpy_new (PyTypeObject
*subtype
, PyObject
*args
, PyObject
*keywords
)
126 struct value
*value
= NULL
; /* Initialize to appease gcc warning. */
127 value_object
*value_obj
;
129 if (PyTuple_Size (args
) != 1)
131 PyErr_SetString (PyExc_TypeError
, _("Value object creation takes only "
136 value_obj
= (value_object
*) subtype
->tp_alloc (subtype
, 1);
137 if (value_obj
== NULL
)
139 PyErr_SetString (PyExc_MemoryError
, _("Could not allocate memory to "
140 "create Value object."));
144 value
= convert_value_from_python (PyTuple_GetItem (args
, 0));
147 subtype
->tp_free (value_obj
);
151 value_obj
->value
= value
;
152 release_value_or_incref (value
);
153 value_obj
->address
= NULL
;
154 value_obj
->type
= NULL
;
155 value_obj
->dynamic_type
= NULL
;
156 note_value (value_obj
);
158 return (PyObject
*) value_obj
;
161 /* Iterate over all the Value objects, calling preserve_one_value on
164 gdbpy_preserve_values (const struct extension_language_defn
*extlang
,
165 struct objfile
*objfile
, htab_t copied_types
)
169 for (iter
= values_in_python
; iter
; iter
= iter
->next
)
170 preserve_one_value (iter
->value
, objfile
, copied_types
);
173 /* Given a value of a pointer type, apply the C unary * operator to it. */
175 valpy_dereference (PyObject
*self
, PyObject
*args
)
177 volatile struct gdb_exception except
;
178 PyObject
*result
= NULL
;
180 TRY_CATCH (except
, RETURN_MASK_ALL
)
182 struct value
*res_val
;
183 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
185 res_val
= value_ind (((value_object
*) self
)->value
);
186 result
= value_to_value_object (res_val
);
187 do_cleanups (cleanup
);
189 GDB_PY_HANDLE_EXCEPTION (except
);
194 /* Given a value of a pointer type or a reference type, return the value
195 referenced. The difference between this function and valpy_dereference is
196 that the latter applies * unary operator to a value, which need not always
197 result in the value referenced. For example, for a value which is a reference
198 to an 'int' pointer ('int *'), valpy_dereference will result in a value of
199 type 'int' while valpy_referenced_value will result in a value of type
203 valpy_referenced_value (PyObject
*self
, PyObject
*args
)
205 volatile struct gdb_exception except
;
206 PyObject
*result
= NULL
;
208 TRY_CATCH (except
, RETURN_MASK_ALL
)
210 struct value
*self_val
, *res_val
;
211 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
213 self_val
= ((value_object
*) self
)->value
;
214 switch (TYPE_CODE (check_typedef (value_type (self_val
))))
217 res_val
= value_ind (self_val
);
220 res_val
= coerce_ref (self_val
);
223 error(_("Trying to get the referenced value from a value which is "
224 "neither a pointer nor a reference."));
227 result
= value_to_value_object (res_val
);
228 do_cleanups (cleanup
);
230 GDB_PY_HANDLE_EXCEPTION (except
);
235 /* Return "&value". */
237 valpy_get_address (PyObject
*self
, void *closure
)
239 value_object
*val_obj
= (value_object
*) self
;
240 volatile struct gdb_exception except
;
242 if (!val_obj
->address
)
244 TRY_CATCH (except
, RETURN_MASK_ALL
)
246 struct value
*res_val
;
247 struct cleanup
*cleanup
248 = make_cleanup_value_free_to_mark (value_mark ());
250 res_val
= value_addr (val_obj
->value
);
251 val_obj
->address
= value_to_value_object (res_val
);
252 do_cleanups (cleanup
);
254 if (except
.reason
< 0)
256 val_obj
->address
= Py_None
;
261 Py_XINCREF (val_obj
->address
);
263 return val_obj
->address
;
266 /* Return type of the value. */
268 valpy_get_type (PyObject
*self
, void *closure
)
270 value_object
*obj
= (value_object
*) self
;
274 obj
->type
= type_to_type_object (value_type (obj
->value
));
278 Py_INCREF (obj
->type
);
282 /* Return dynamic type of the value. */
285 valpy_get_dynamic_type (PyObject
*self
, void *closure
)
287 value_object
*obj
= (value_object
*) self
;
288 volatile struct gdb_exception except
;
289 struct type
*type
= NULL
;
291 if (obj
->dynamic_type
!= NULL
)
293 Py_INCREF (obj
->dynamic_type
);
294 return obj
->dynamic_type
;
297 TRY_CATCH (except
, RETURN_MASK_ALL
)
299 struct value
*val
= obj
->value
;
300 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
302 type
= value_type (val
);
303 CHECK_TYPEDEF (type
);
305 if (((TYPE_CODE (type
) == TYPE_CODE_PTR
)
306 || (TYPE_CODE (type
) == TYPE_CODE_REF
))
307 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
309 struct value
*target
;
310 int was_pointer
= TYPE_CODE (type
) == TYPE_CODE_PTR
;
313 target
= value_ind (val
);
315 target
= coerce_ref (val
);
316 type
= value_rtti_type (target
, NULL
, NULL
, NULL
);
321 type
= lookup_pointer_type (type
);
323 type
= lookup_reference_type (type
);
326 else if (TYPE_CODE (type
) == TYPE_CODE_CLASS
)
327 type
= value_rtti_type (val
, NULL
, NULL
, NULL
);
330 /* Re-use object's static type. */
334 do_cleanups (cleanup
);
336 GDB_PY_HANDLE_EXCEPTION (except
);
339 obj
->dynamic_type
= valpy_get_type (self
, NULL
);
341 obj
->dynamic_type
= type_to_type_object (type
);
343 Py_XINCREF (obj
->dynamic_type
);
344 return obj
->dynamic_type
;
347 /* Implementation of gdb.Value.lazy_string ([encoding] [, length]) ->
348 string. Return a PyObject representing a lazy_string_object type.
349 A lazy string is a pointer to a string with an optional encoding and
350 length. If ENCODING is not given, encoding is set to None. If an
351 ENCODING is provided the encoding parameter is set to ENCODING, but
352 the string is not encoded. If LENGTH is provided then the length
353 parameter is set to LENGTH, otherwise length will be set to -1 (first
354 null of appropriate with). */
356 valpy_lazy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
358 gdb_py_longest length
= -1;
359 struct value
*value
= ((value_object
*) self
)->value
;
360 const char *user_encoding
= NULL
;
361 static char *keywords
[] = { "encoding", "length", NULL
};
362 PyObject
*str_obj
= NULL
;
363 volatile struct gdb_exception except
;
365 if (!PyArg_ParseTupleAndKeywords (args
, kw
, "|s" GDB_PY_LL_ARG
, keywords
,
366 &user_encoding
, &length
))
369 TRY_CATCH (except
, RETURN_MASK_ALL
)
371 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
373 if (TYPE_CODE (value_type (value
)) == TYPE_CODE_PTR
)
374 value
= value_ind (value
);
376 str_obj
= gdbpy_create_lazy_string_object (value_address (value
), length
,
380 do_cleanups (cleanup
);
382 GDB_PY_HANDLE_EXCEPTION (except
);
387 /* Implementation of gdb.Value.string ([encoding] [, errors]
388 [, length]) -> string. Return Unicode string with value contents.
389 If ENCODING is not given, the string is assumed to be encoded in
390 the target's charset. If LENGTH is provided, only fetch string to
391 the length provided. */
394 valpy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
398 struct value
*value
= ((value_object
*) self
)->value
;
399 volatile struct gdb_exception except
;
401 const char *encoding
= NULL
;
402 const char *errors
= NULL
;
403 const char *user_encoding
= NULL
;
404 const char *la_encoding
= NULL
;
405 struct type
*char_type
;
406 static char *keywords
[] = { "encoding", "errors", "length", NULL
};
408 if (!PyArg_ParseTupleAndKeywords (args
, kw
, "|ssi", keywords
,
409 &user_encoding
, &errors
, &length
))
412 TRY_CATCH (except
, RETURN_MASK_ALL
)
414 LA_GET_STRING (value
, &buffer
, &length
, &char_type
, &la_encoding
);
416 GDB_PY_HANDLE_EXCEPTION (except
);
418 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: la_encoding
;
419 unicode
= PyUnicode_Decode ((const char *) buffer
,
420 length
* TYPE_LENGTH (char_type
),
427 /* A helper function that implements the various cast operators. */
430 valpy_do_cast (PyObject
*self
, PyObject
*args
, enum exp_opcode op
)
432 PyObject
*type_obj
, *result
= NULL
;
434 volatile struct gdb_exception except
;
436 if (! PyArg_ParseTuple (args
, "O", &type_obj
))
439 type
= type_object_to_type (type_obj
);
442 PyErr_SetString (PyExc_RuntimeError
,
443 _("Argument must be a type."));
447 TRY_CATCH (except
, RETURN_MASK_ALL
)
449 struct value
*val
= ((value_object
*) self
)->value
;
450 struct value
*res_val
;
451 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
453 if (op
== UNOP_DYNAMIC_CAST
)
454 res_val
= value_dynamic_cast (type
, val
);
455 else if (op
== UNOP_REINTERPRET_CAST
)
456 res_val
= value_reinterpret_cast (type
, val
);
459 gdb_assert (op
== UNOP_CAST
);
460 res_val
= value_cast (type
, val
);
463 result
= value_to_value_object (res_val
);
464 do_cleanups (cleanup
);
466 GDB_PY_HANDLE_EXCEPTION (except
);
471 /* Implementation of the "cast" method. */
474 valpy_cast (PyObject
*self
, PyObject
*args
)
476 return valpy_do_cast (self
, args
, UNOP_CAST
);
479 /* Implementation of the "dynamic_cast" method. */
482 valpy_dynamic_cast (PyObject
*self
, PyObject
*args
)
484 return valpy_do_cast (self
, args
, UNOP_DYNAMIC_CAST
);
487 /* Implementation of the "reinterpret_cast" method. */
490 valpy_reinterpret_cast (PyObject
*self
, PyObject
*args
)
492 return valpy_do_cast (self
, args
, UNOP_REINTERPRET_CAST
);
496 valpy_length (PyObject
*self
)
498 /* We don't support getting the number of elements in a struct / class. */
499 PyErr_SetString (PyExc_NotImplementedError
,
500 _("Invalid operation on gdb.Value."));
504 /* Return 1 if the gdb.Field object FIELD is present in the value V.
505 Returns 0 otherwise. If any Python error occurs, -1 is returned. */
508 value_has_field (struct value
*v
, PyObject
*field
)
510 struct type
*parent_type
, *val_type
;
511 enum type_code type_code
;
512 PyObject
*type_object
= PyObject_GetAttrString (field
, "parent_type");
513 volatile struct gdb_exception except
;
516 if (type_object
== NULL
)
519 parent_type
= type_object_to_type (type_object
);
520 Py_DECREF (type_object
);
521 if (parent_type
== NULL
)
523 PyErr_SetString (PyExc_TypeError
,
524 _("'parent_type' attribute of gdb.Field object is not a"
525 "gdb.Type object."));
529 TRY_CATCH (except
, RETURN_MASK_ALL
)
531 val_type
= value_type (v
);
532 val_type
= check_typedef (val_type
);
533 if (TYPE_CODE (val_type
) == TYPE_CODE_REF
534 || TYPE_CODE (val_type
) == TYPE_CODE_PTR
)
535 val_type
= check_typedef (TYPE_TARGET_TYPE (val_type
));
537 type_code
= TYPE_CODE (val_type
);
538 if ((type_code
== TYPE_CODE_STRUCT
|| type_code
== TYPE_CODE_UNION
)
539 && types_equal (val_type
, parent_type
))
544 GDB_PY_SET_HANDLE_EXCEPTION (except
);
549 /* Return the value of a flag FLAG_NAME in a gdb.Field object FIELD.
550 Returns 1 if the flag value is true, 0 if it is false, and -1 if
551 a Python error occurs. */
554 get_field_flag (PyObject
*field
, const char *flag_name
)
557 /* Python 2.4 did not have a 'const' here. */
558 PyObject
*flag_object
= PyObject_GetAttrString (field
, (char *) flag_name
);
560 if (flag_object
== NULL
)
563 flag_value
= PyObject_IsTrue (flag_object
);
564 Py_DECREF (flag_object
);
569 /* Return the "type" attribute of a gdb.Field object.
570 Returns NULL on error, with a Python exception set. */
573 get_field_type (PyObject
*field
)
575 PyObject
*ftype_obj
= PyObject_GetAttrString (field
, "type");
578 if (ftype_obj
== NULL
)
580 ftype
= type_object_to_type (ftype_obj
);
581 Py_DECREF (ftype_obj
);
583 PyErr_SetString (PyExc_TypeError
,
584 _("'type' attribute of gdb.Field object is not a "
585 "gdb.Type object."));
590 /* Given string name or a gdb.Field object corresponding to an element inside
591 a structure, return its value object. Returns NULL on error, with a python
595 valpy_getitem (PyObject
*self
, PyObject
*key
)
597 value_object
*self_value
= (value_object
*) self
;
599 struct type
*base_class_type
= NULL
, *field_type
= NULL
;
601 volatile struct gdb_exception except
;
602 PyObject
*result
= NULL
;
604 if (gdbpy_is_string (key
))
606 field
= python_string_to_host_string (key
);
610 else if (gdbpy_is_field (key
))
612 int is_base_class
, valid_field
;
614 valid_field
= value_has_field (self_value
->value
, key
);
617 else if (valid_field
== 0)
619 PyErr_SetString (PyExc_TypeError
,
620 _("Invalid lookup for a field not contained in "
626 is_base_class
= get_field_flag (key
, "is_base_class");
627 if (is_base_class
< 0)
629 else if (is_base_class
> 0)
631 base_class_type
= get_field_type (key
);
632 if (base_class_type
== NULL
)
637 PyObject
*name_obj
= PyObject_GetAttrString (key
, "name");
639 if (name_obj
== NULL
)
642 if (name_obj
!= Py_None
)
644 field
= python_string_to_host_string (name_obj
);
645 Py_DECREF (name_obj
);
651 PyObject
*bitpos_obj
;
654 Py_DECREF (name_obj
);
656 if (!PyObject_HasAttrString (key
, "bitpos"))
658 PyErr_SetString (PyExc_AttributeError
,
659 _("gdb.Field object has no name and no "
660 "'bitpos' attribute."));
664 bitpos_obj
= PyObject_GetAttrString (key
, "bitpos");
665 if (bitpos_obj
== NULL
)
667 valid
= gdb_py_int_as_long (bitpos_obj
, &bitpos
);
668 Py_DECREF (bitpos_obj
);
672 field_type
= get_field_type (key
);
673 if (field_type
== NULL
)
679 TRY_CATCH (except
, RETURN_MASK_ALL
)
681 struct value
*tmp
= self_value
->value
;
682 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
683 struct value
*res_val
= NULL
;
686 res_val
= value_struct_elt (&tmp
, NULL
, field
, 0, NULL
);
687 else if (bitpos
>= 0)
688 res_val
= value_struct_elt_bitpos (&tmp
, bitpos
, field_type
,
689 "struct/class/union");
690 else if (base_class_type
!= NULL
)
692 struct type
*val_type
;
694 val_type
= check_typedef (value_type (tmp
));
695 if (TYPE_CODE (val_type
) == TYPE_CODE_PTR
)
696 res_val
= value_cast (lookup_pointer_type (base_class_type
), tmp
);
697 else if (TYPE_CODE (val_type
) == TYPE_CODE_REF
)
698 res_val
= value_cast (lookup_reference_type (base_class_type
), tmp
);
700 res_val
= value_cast (base_class_type
, tmp
);
704 /* Assume we are attempting an array access, and let the
705 value code throw an exception if the index has an invalid
707 struct value
*idx
= convert_value_from_python (key
);
711 /* Check the value's type is something that can be accessed via
715 tmp
= coerce_ref (tmp
);
716 type
= check_typedef (value_type (tmp
));
717 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
718 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
719 error (_("Cannot subscript requested type."));
721 res_val
= value_subscript (tmp
, value_as_long (idx
));
726 result
= value_to_value_object (res_val
);
727 do_cleanups (cleanup
);
731 GDB_PY_HANDLE_EXCEPTION (except
);
737 valpy_setitem (PyObject
*self
, PyObject
*key
, PyObject
*value
)
739 PyErr_Format (PyExc_NotImplementedError
,
740 _("Setting of struct elements is not currently supported."));
744 /* Called by the Python interpreter to perform an inferior function
745 call on the value. Returns NULL on error, with a python exception set. */
747 valpy_call (PyObject
*self
, PyObject
*args
, PyObject
*keywords
)
749 Py_ssize_t args_count
;
750 volatile struct gdb_exception except
;
751 struct value
*function
= ((value_object
*) self
)->value
;
752 struct value
**vargs
= NULL
;
753 struct type
*ftype
= NULL
;
754 struct value
*mark
= value_mark ();
755 PyObject
*result
= NULL
;
757 TRY_CATCH (except
, RETURN_MASK_ALL
)
759 ftype
= check_typedef (value_type (function
));
761 GDB_PY_HANDLE_EXCEPTION (except
);
763 if (TYPE_CODE (ftype
) != TYPE_CODE_FUNC
)
765 PyErr_SetString (PyExc_RuntimeError
,
766 _("Value is not callable (not TYPE_CODE_FUNC)."));
770 if (! PyTuple_Check (args
))
772 PyErr_SetString (PyExc_TypeError
,
773 _("Inferior arguments must be provided in a tuple."));
777 args_count
= PyTuple_Size (args
);
782 vargs
= alloca (sizeof (struct value
*) * args_count
);
783 for (i
= 0; i
< args_count
; i
++)
785 PyObject
*item
= PyTuple_GetItem (args
, i
);
790 vargs
[i
] = convert_value_from_python (item
);
791 if (vargs
[i
] == NULL
)
796 TRY_CATCH (except
, RETURN_MASK_ALL
)
798 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (mark
);
799 struct value
*return_value
;
801 return_value
= call_function_by_hand (function
, args_count
, vargs
);
802 result
= value_to_value_object (return_value
);
803 do_cleanups (cleanup
);
805 GDB_PY_HANDLE_EXCEPTION (except
);
810 /* Called by the Python interpreter to obtain string representation
813 valpy_str (PyObject
*self
)
817 struct value_print_options opts
;
818 volatile struct gdb_exception except
;
820 get_user_print_options (&opts
);
823 TRY_CATCH (except
, RETURN_MASK_ALL
)
825 struct ui_file
*stb
= mem_fileopen ();
826 struct cleanup
*old_chain
= make_cleanup_ui_file_delete (stb
);
828 common_val_print (((value_object
*) self
)->value
, stb
, 0,
829 &opts
, python_language
);
830 s
= ui_file_xstrdup (stb
, NULL
);
832 do_cleanups (old_chain
);
834 GDB_PY_HANDLE_EXCEPTION (except
);
836 result
= PyUnicode_Decode (s
, strlen (s
), host_charset (), NULL
);
842 /* Implements gdb.Value.is_optimized_out. */
844 valpy_get_is_optimized_out (PyObject
*self
, void *closure
)
846 struct value
*value
= ((value_object
*) self
)->value
;
848 volatile struct gdb_exception except
;
850 TRY_CATCH (except
, RETURN_MASK_ALL
)
852 opt
= value_optimized_out (value
);
854 GDB_PY_HANDLE_EXCEPTION (except
);
862 /* Implements gdb.Value.is_lazy. */
864 valpy_get_is_lazy (PyObject
*self
, void *closure
)
866 struct value
*value
= ((value_object
*) self
)->value
;
868 volatile struct gdb_exception except
;
870 TRY_CATCH (except
, RETURN_MASK_ALL
)
872 opt
= value_lazy (value
);
874 GDB_PY_HANDLE_EXCEPTION (except
);
882 /* Implements gdb.Value.fetch_lazy (). */
884 valpy_fetch_lazy (PyObject
*self
, PyObject
*args
)
886 struct value
*value
= ((value_object
*) self
)->value
;
887 volatile struct gdb_exception except
;
889 TRY_CATCH (except
, RETURN_MASK_ALL
)
891 if (value_lazy (value
))
892 value_fetch_lazy (value
);
894 GDB_PY_HANDLE_EXCEPTION (except
);
899 /* Calculate and return the address of the PyObject as the value of
900 the builtin __hash__ call. */
902 valpy_hash (PyObject
*self
)
904 return (long) (intptr_t) self
;
922 /* If TYPE is a reference, return the target; otherwise return TYPE. */
923 #define STRIP_REFERENCE(TYPE) \
924 ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
926 /* Returns a value object which is the result of applying the operation
927 specified by OPCODE to the given arguments. Returns NULL on error, with
928 a python exception set. */
930 valpy_binop (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
932 volatile struct gdb_exception except
;
933 PyObject
*result
= NULL
;
935 TRY_CATCH (except
, RETURN_MASK_ALL
)
937 struct value
*arg1
, *arg2
;
938 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
939 struct value
*res_val
= NULL
;
940 enum exp_opcode op
= OP_NULL
;
943 /* If the gdb.Value object is the second operand, then it will be passed
944 to us as the OTHER argument, and SELF will be an entirely different
945 kind of object, altogether. Because of this, we can't assume self is
946 a gdb.Value object and need to convert it from python as well. */
947 arg1
= convert_value_from_python (self
);
950 do_cleanups (cleanup
);
954 arg2
= convert_value_from_python (other
);
957 do_cleanups (cleanup
);
965 struct type
*ltype
= value_type (arg1
);
966 struct type
*rtype
= value_type (arg2
);
968 CHECK_TYPEDEF (ltype
);
969 ltype
= STRIP_REFERENCE (ltype
);
970 CHECK_TYPEDEF (rtype
);
971 rtype
= STRIP_REFERENCE (rtype
);
974 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
975 && is_integral_type (rtype
))
976 res_val
= value_ptradd (arg1
, value_as_long (arg2
));
977 else if (TYPE_CODE (rtype
) == TYPE_CODE_PTR
978 && is_integral_type (ltype
))
979 res_val
= value_ptradd (arg2
, value_as_long (arg1
));
989 struct type
*ltype
= value_type (arg1
);
990 struct type
*rtype
= value_type (arg2
);
992 CHECK_TYPEDEF (ltype
);
993 ltype
= STRIP_REFERENCE (ltype
);
994 CHECK_TYPEDEF (rtype
);
995 rtype
= STRIP_REFERENCE (rtype
);
998 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
999 && TYPE_CODE (rtype
) == TYPE_CODE_PTR
)
1000 /* A ptrdiff_t for the target would be preferable here. */
1001 res_val
= value_from_longest (builtin_type_pyint
,
1002 value_ptrdiff (arg1
, arg2
));
1003 else if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
1004 && is_integral_type (rtype
))
1005 res_val
= value_ptradd (arg1
, - value_as_long (arg2
));
1032 op
= BINOP_BITWISE_AND
;
1035 op
= BINOP_BITWISE_IOR
;
1038 op
= BINOP_BITWISE_XOR
;
1044 if (binop_user_defined_p (op
, arg1
, arg2
))
1045 res_val
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, EVAL_NORMAL
);
1047 res_val
= value_binop (arg1
, arg2
, op
);
1051 result
= value_to_value_object (res_val
);
1053 do_cleanups (cleanup
);
1055 GDB_PY_HANDLE_EXCEPTION (except
);
1061 valpy_add (PyObject
*self
, PyObject
*other
)
1063 return valpy_binop (VALPY_ADD
, self
, other
);
1067 valpy_subtract (PyObject
*self
, PyObject
*other
)
1069 return valpy_binop (VALPY_SUB
, self
, other
);
1073 valpy_multiply (PyObject
*self
, PyObject
*other
)
1075 return valpy_binop (VALPY_MUL
, self
, other
);
1079 valpy_divide (PyObject
*self
, PyObject
*other
)
1081 return valpy_binop (VALPY_DIV
, self
, other
);
1085 valpy_remainder (PyObject
*self
, PyObject
*other
)
1087 return valpy_binop (VALPY_REM
, self
, other
);
1091 valpy_power (PyObject
*self
, PyObject
*other
, PyObject
*unused
)
1093 /* We don't support the ternary form of pow. I don't know how to express
1094 that, so let's just throw NotImplementedError to at least do something
1096 if (unused
!= Py_None
)
1098 PyErr_SetString (PyExc_NotImplementedError
,
1099 "Invalid operation on gdb.Value.");
1103 return valpy_binop (VALPY_POW
, self
, other
);
1107 valpy_negative (PyObject
*self
)
1109 volatile struct gdb_exception except
;
1110 PyObject
*result
= NULL
;
1112 TRY_CATCH (except
, RETURN_MASK_ALL
)
1114 /* Perhaps overkill, but consistency has some virtue. */
1115 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
1118 val
= value_neg (((value_object
*) self
)->value
);
1119 result
= value_to_value_object (val
);
1120 do_cleanups (cleanup
);
1122 GDB_PY_HANDLE_EXCEPTION (except
);
1128 valpy_positive (PyObject
*self
)
1130 return value_to_value_object (((value_object
*) self
)->value
);
1134 valpy_absolute (PyObject
*self
)
1136 struct value
*value
= ((value_object
*) self
)->value
;
1137 volatile struct gdb_exception except
;
1140 TRY_CATCH (except
, RETURN_MASK_ALL
)
1142 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
1144 if (value_less (value
, value_zero (value_type (value
), not_lval
)))
1147 do_cleanups (cleanup
);
1149 GDB_PY_HANDLE_EXCEPTION (except
);
1152 return valpy_positive (self
);
1154 return valpy_negative (self
);
1157 /* Implements boolean evaluation of gdb.Value. */
1159 valpy_nonzero (PyObject
*self
)
1161 volatile struct gdb_exception except
;
1162 value_object
*self_value
= (value_object
*) self
;
1164 int nonzero
= 0; /* Appease GCC warning. */
1166 TRY_CATCH (except
, RETURN_MASK_ALL
)
1168 type
= check_typedef (value_type (self_value
->value
));
1170 if (is_integral_type (type
) || TYPE_CODE (type
) == TYPE_CODE_PTR
)
1171 nonzero
= !!value_as_long (self_value
->value
);
1172 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1173 nonzero
= value_as_double (self_value
->value
) != 0;
1174 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1175 nonzero
= !decimal_is_zero (value_contents (self_value
->value
),
1177 gdbarch_byte_order (get_type_arch (type
)));
1179 /* All other values are True. */
1182 /* This is not documented in the Python documentation, but if this
1183 function fails, return -1 as slot_nb_nonzero does (the default
1184 Python nonzero function). */
1185 GDB_PY_SET_HANDLE_EXCEPTION (except
);
1190 /* Implements ~ for value objects. */
1192 valpy_invert (PyObject
*self
)
1194 struct value
*val
= NULL
;
1195 volatile struct gdb_exception except
;
1197 TRY_CATCH (except
, RETURN_MASK_ALL
)
1199 val
= value_complement (((value_object
*) self
)->value
);
1201 GDB_PY_HANDLE_EXCEPTION (except
);
1203 return value_to_value_object (val
);
1206 /* Implements left shift for value objects. */
1208 valpy_lsh (PyObject
*self
, PyObject
*other
)
1210 return valpy_binop (VALPY_LSH
, self
, other
);
1213 /* Implements right shift for value objects. */
1215 valpy_rsh (PyObject
*self
, PyObject
*other
)
1217 return valpy_binop (VALPY_RSH
, self
, other
);
1220 /* Implements bitwise and for value objects. */
1222 valpy_and (PyObject
*self
, PyObject
*other
)
1224 return valpy_binop (VALPY_BITAND
, self
, other
);
1227 /* Implements bitwise or for value objects. */
1229 valpy_or (PyObject
*self
, PyObject
*other
)
1231 return valpy_binop (VALPY_BITOR
, self
, other
);
1234 /* Implements bitwise xor for value objects. */
1236 valpy_xor (PyObject
*self
, PyObject
*other
)
1238 return valpy_binop (VALPY_BITXOR
, self
, other
);
1241 /* Implements comparison operations for value objects. Returns NULL on error,
1242 with a python exception set. */
1244 valpy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1247 volatile struct gdb_exception except
;
1249 if (other
== Py_None
)
1250 /* Comparing with None is special. From what I can tell, in Python
1251 None is smaller than anything else. */
1263 PyErr_SetString (PyExc_NotImplementedError
,
1264 _("Invalid operation on gdb.Value."));
1268 TRY_CATCH (except
, RETURN_MASK_ALL
)
1270 struct value
*value_other
, *mark
= value_mark ();
1271 struct cleanup
*cleanup
;
1273 value_other
= convert_value_from_python (other
);
1274 if (value_other
== NULL
)
1280 cleanup
= make_cleanup_value_free_to_mark (mark
);
1284 result
= value_less (((value_object
*) self
)->value
, value_other
);
1287 result
= value_less (((value_object
*) self
)->value
, value_other
)
1288 || value_equal (((value_object
*) self
)->value
, value_other
);
1291 result
= value_equal (((value_object
*) self
)->value
, value_other
);
1294 result
= !value_equal (((value_object
*) self
)->value
, value_other
);
1297 result
= value_less (value_other
, ((value_object
*) self
)->value
);
1300 result
= value_less (value_other
, ((value_object
*) self
)->value
)
1301 || value_equal (((value_object
*) self
)->value
, value_other
);
1305 PyErr_SetString (PyExc_NotImplementedError
,
1306 _("Invalid operation on gdb.Value."));
1311 do_cleanups (cleanup
);
1313 GDB_PY_HANDLE_EXCEPTION (except
);
1315 /* In this case, the Python exception has already been set. */
1326 /* Implements conversion to int. */
1328 valpy_int (PyObject
*self
)
1330 struct value
*value
= ((value_object
*) self
)->value
;
1331 struct type
*type
= value_type (value
);
1333 volatile struct gdb_exception except
;
1335 TRY_CATCH (except
, RETURN_MASK_ALL
)
1337 if (!is_integral_type (type
))
1338 error (_("Cannot convert value to int."));
1340 l
= value_as_long (value
);
1342 GDB_PY_HANDLE_EXCEPTION (except
);
1344 return gdb_py_object_from_longest (l
);
1348 /* Implements conversion to long. */
1350 valpy_long (PyObject
*self
)
1352 struct value
*value
= ((value_object
*) self
)->value
;
1353 struct type
*type
= value_type (value
);
1355 volatile struct gdb_exception except
;
1357 TRY_CATCH (except
, RETURN_MASK_ALL
)
1359 CHECK_TYPEDEF (type
);
1361 if (!is_integral_type (type
)
1362 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1363 error (_("Cannot convert value to long."));
1365 l
= value_as_long (value
);
1367 GDB_PY_HANDLE_EXCEPTION (except
);
1369 return gdb_py_long_from_longest (l
);
1372 /* Implements conversion to float. */
1374 valpy_float (PyObject
*self
)
1376 struct value
*value
= ((value_object
*) self
)->value
;
1377 struct type
*type
= value_type (value
);
1379 volatile struct gdb_exception except
;
1381 TRY_CATCH (except
, RETURN_MASK_ALL
)
1383 CHECK_TYPEDEF (type
);
1385 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
1386 error (_("Cannot convert value to float."));
1388 d
= value_as_double (value
);
1390 GDB_PY_HANDLE_EXCEPTION (except
);
1392 return PyFloat_FromDouble (d
);
1395 /* Returns an object for a value which is released from the all_values chain,
1396 so its lifetime is not bound to the execution of a command. */
1398 value_to_value_object (struct value
*val
)
1400 value_object
*val_obj
;
1402 val_obj
= PyObject_New (value_object
, &value_object_type
);
1403 if (val_obj
!= NULL
)
1405 val_obj
->value
= val
;
1406 release_value_or_incref (val
);
1407 val_obj
->address
= NULL
;
1408 val_obj
->type
= NULL
;
1409 val_obj
->dynamic_type
= NULL
;
1410 note_value (val_obj
);
1413 return (PyObject
*) val_obj
;
1416 /* Returns a borrowed reference to the struct value corresponding to
1417 the given value object. */
1419 value_object_to_value (PyObject
*self
)
1423 if (! PyObject_TypeCheck (self
, &value_object_type
))
1425 real
= (value_object
*) self
;
1429 /* Try to convert a Python value to a gdb value. If the value cannot
1430 be converted, set a Python exception and return NULL. Returns a
1431 reference to a new value on the all_values chain. */
1434 convert_value_from_python (PyObject
*obj
)
1436 struct value
*value
= NULL
; /* -Wall */
1437 volatile struct gdb_exception except
;
1440 gdb_assert (obj
!= NULL
);
1442 TRY_CATCH (except
, RETURN_MASK_ALL
)
1444 if (PyBool_Check (obj
))
1446 cmp
= PyObject_IsTrue (obj
);
1448 value
= value_from_longest (builtin_type_pybool
, cmp
);
1450 /* Make a long logic check first. In Python 3.x, internally,
1451 all integers are represented as longs. In Python 2.x, there
1452 is still a differentiation internally between a PyInt and a
1453 PyLong. Explicitly do this long check conversion first. In
1454 GDB, for Python 3.x, we #ifdef PyInt = PyLong. This check has
1455 to be done first to ensure we do not lose information in the
1456 conversion process. */
1457 else if (PyLong_Check (obj
))
1459 LONGEST l
= PyLong_AsLongLong (obj
);
1461 if (PyErr_Occurred ())
1463 /* If the error was an overflow, we can try converting to
1464 ULONGEST instead. */
1465 if (PyErr_ExceptionMatches (PyExc_OverflowError
))
1467 PyObject
*etype
, *evalue
, *etraceback
, *zero
;
1469 PyErr_Fetch (&etype
, &evalue
, &etraceback
);
1470 zero
= PyInt_FromLong (0);
1472 /* Check whether obj is positive. */
1473 if (PyObject_RichCompareBool (obj
, zero
, Py_GT
) > 0)
1477 ul
= PyLong_AsUnsignedLongLong (obj
);
1478 if (! PyErr_Occurred ())
1479 value
= value_from_ulongest (builtin_type_upylong
, ul
);
1482 /* There's nothing we can do. */
1483 PyErr_Restore (etype
, evalue
, etraceback
);
1489 value
= value_from_longest (builtin_type_pylong
, l
);
1491 else if (PyInt_Check (obj
))
1493 long l
= PyInt_AsLong (obj
);
1495 if (! PyErr_Occurred ())
1496 value
= value_from_longest (builtin_type_pyint
, l
);
1498 else if (PyFloat_Check (obj
))
1500 double d
= PyFloat_AsDouble (obj
);
1502 if (! PyErr_Occurred ())
1503 value
= value_from_double (builtin_type_pyfloat
, d
);
1505 else if (gdbpy_is_string (obj
))
1509 s
= python_string_to_target_string (obj
);
1512 struct cleanup
*old
;
1514 old
= make_cleanup (xfree
, s
);
1515 value
= value_cstring (s
, strlen (s
), builtin_type_pychar
);
1519 else if (PyObject_TypeCheck (obj
, &value_object_type
))
1520 value
= value_copy (((value_object
*) obj
)->value
);
1521 else if (gdbpy_is_lazy_string (obj
))
1525 result
= PyObject_CallMethodObjArgs (obj
, gdbpy_value_cst
, NULL
);
1526 value
= value_copy (((value_object
*) result
)->value
);
1530 PyErr_Format (PyExc_TypeError
,
1531 _("Could not convert Python object: %S."), obj
);
1533 PyErr_Format (PyExc_TypeError
,
1534 _("Could not convert Python object: %s."),
1535 PyString_AsString (PyObject_Str (obj
)));
1538 if (except
.reason
< 0)
1540 PyErr_Format (except
.reason
== RETURN_QUIT
1541 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
1542 "%s", except
.message
);
1549 /* Returns value object in the ARGth position in GDB's history. */
1551 gdbpy_history (PyObject
*self
, PyObject
*args
)
1554 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
1555 volatile struct gdb_exception except
;
1557 if (!PyArg_ParseTuple (args
, "i", &i
))
1560 TRY_CATCH (except
, RETURN_MASK_ALL
)
1562 res_val
= access_value_history (i
);
1564 GDB_PY_HANDLE_EXCEPTION (except
);
1566 return value_to_value_object (res_val
);
1569 /* Returns 1 in OBJ is a gdb.Value object, 0 otherwise. */
1572 gdbpy_is_value_object (PyObject
*obj
)
1574 return PyObject_TypeCheck (obj
, &value_object_type
);
1578 gdbpy_initialize_values (void)
1580 if (PyType_Ready (&value_object_type
) < 0)
1583 return gdb_pymodule_addobject (gdb_module
, "Value",
1584 (PyObject
*) &value_object_type
);
1589 static PyGetSetDef value_object_getset
[] = {
1590 { "address", valpy_get_address
, NULL
, "The address of the value.",
1592 { "is_optimized_out", valpy_get_is_optimized_out
, NULL
,
1593 "Boolean telling whether the value is optimized "
1594 "out (i.e., not available).",
1596 { "type", valpy_get_type
, NULL
, "Type of the value.", NULL
},
1597 { "dynamic_type", valpy_get_dynamic_type
, NULL
,
1598 "Dynamic type of the value.", NULL
},
1599 { "is_lazy", valpy_get_is_lazy
, NULL
,
1600 "Boolean telling whether the value is lazy (not fetched yet\n\
1601 from the inferior). A lazy value is fetched when needed, or when\n\
1602 the \"fetch_lazy()\" method is called.", NULL
},
1603 {NULL
} /* Sentinel */
1606 static PyMethodDef value_object_methods
[] = {
1607 { "cast", valpy_cast
, METH_VARARGS
, "Cast the value to the supplied type." },
1608 { "dynamic_cast", valpy_dynamic_cast
, METH_VARARGS
,
1609 "dynamic_cast (gdb.Type) -> gdb.Value\n\
1610 Cast the value to the supplied type, as if by the C++ dynamic_cast operator."
1612 { "reinterpret_cast", valpy_reinterpret_cast
, METH_VARARGS
,
1613 "reinterpret_cast (gdb.Type) -> gdb.Value\n\
1614 Cast the value to the supplied type, as if by the C++\n\
1615 reinterpret_cast operator."
1617 { "dereference", valpy_dereference
, METH_NOARGS
, "Dereferences the value." },
1618 { "referenced_value", valpy_referenced_value
, METH_NOARGS
,
1619 "Return the value referenced by a TYPE_CODE_REF or TYPE_CODE_PTR value." },
1620 { "lazy_string", (PyCFunction
) valpy_lazy_string
,
1621 METH_VARARGS
| METH_KEYWORDS
,
1622 "lazy_string ([encoding] [, length]) -> lazy_string\n\
1623 Return a lazy string representation of the value." },
1624 { "string", (PyCFunction
) valpy_string
, METH_VARARGS
| METH_KEYWORDS
,
1625 "string ([encoding] [, errors] [, length]) -> string\n\
1626 Return Unicode string representation of the value." },
1627 { "fetch_lazy", valpy_fetch_lazy
, METH_NOARGS
,
1628 "Fetches the value from the inferior, if it was lazy." },
1629 {NULL
} /* Sentinel */
1632 static PyNumberMethods value_object_as_number
= {
1640 NULL
, /* nb_divmod */
1641 valpy_power
, /* nb_power */
1642 valpy_negative
, /* nb_negative */
1643 valpy_positive
, /* nb_positive */
1644 valpy_absolute
, /* nb_absolute */
1645 valpy_nonzero
, /* nb_nonzero */
1646 valpy_invert
, /* nb_invert */
1647 valpy_lsh
, /* nb_lshift */
1648 valpy_rsh
, /* nb_rshift */
1649 valpy_and
, /* nb_and */
1650 valpy_xor
, /* nb_xor */
1651 valpy_or
, /* nb_or */
1653 valpy_long
, /* nb_int */
1654 NULL
, /* reserved */
1656 NULL
, /* nb_coerce */
1657 valpy_int
, /* nb_int */
1658 valpy_long
, /* nb_long */
1660 valpy_float
, /* nb_float */
1665 NULL
, /* nb_inplace_add */
1666 NULL
, /* nb_inplace_subtract */
1667 NULL
, /* nb_inplace_multiply */
1668 NULL
, /* nb_inplace_remainder */
1669 NULL
, /* nb_inplace_power */
1670 NULL
, /* nb_inplace_lshift */
1671 NULL
, /* nb_inplace_rshift */
1672 NULL
, /* nb_inplace_and */
1673 NULL
, /* nb_inplace_xor */
1674 NULL
, /* nb_inplace_or */
1675 NULL
, /* nb_floor_divide */
1676 valpy_divide
/* nb_true_divide */
1679 static PyMappingMethods value_object_as_mapping
= {
1685 PyTypeObject value_object_type
= {
1686 PyVarObject_HEAD_INIT (NULL
, 0)
1687 "gdb.Value", /*tp_name*/
1688 sizeof (value_object
), /*tp_basicsize*/
1690 valpy_dealloc
, /*tp_dealloc*/
1696 &value_object_as_number
, /*tp_as_number*/
1697 0, /*tp_as_sequence*/
1698 &value_object_as_mapping
, /*tp_as_mapping*/
1699 valpy_hash
, /*tp_hash*/
1700 valpy_call
, /*tp_call*/
1701 valpy_str
, /*tp_str*/
1705 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
1706 | Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1707 "GDB value object", /* tp_doc */
1708 0, /* tp_traverse */
1710 valpy_richcompare
, /* tp_richcompare */
1711 0, /* tp_weaklistoffset */
1713 0, /* tp_iternext */
1714 value_object_methods
, /* tp_methods */
1716 value_object_getset
, /* tp_getset */
1719 0, /* tp_descr_get */
1720 0, /* tp_descr_set */
1721 0, /* tp_dictoffset */
1724 valpy_new
/* tp_new */