1 /* Python interface to values.
3 Copyright (C) 2008-2013 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"
35 #include "python-internal.h"
37 /* Even though Python scalar types directly map to host types, we use
38 target types here to remain consistent with the values system in
39 GDB (which uses target arithmetic). */
41 /* Python's integer type corresponds to C's long type. */
42 #define builtin_type_pyint builtin_type (python_gdbarch)->builtin_long
44 /* Python's float type corresponds to C's double type. */
45 #define builtin_type_pyfloat builtin_type (python_gdbarch)->builtin_double
47 /* Python's long type corresponds to C's long long type. */
48 #define builtin_type_pylong builtin_type (python_gdbarch)->builtin_long_long
50 /* Python's long type corresponds to C's long long type. Unsigned version. */
51 #define builtin_type_upylong builtin_type \
52 (python_gdbarch)->builtin_unsigned_long_long
54 #define builtin_type_pybool \
55 language_bool_type (python_language, python_gdbarch)
57 #define builtin_type_pychar \
58 language_string_char_type (python_language, python_gdbarch)
60 typedef struct value_object
{
62 struct value_object
*next
;
63 struct value_object
*prev
;
67 PyObject
*dynamic_type
;
70 /* List of all values which are currently exposed to Python. It is
71 maintained so that when an objfile is discarded, preserve_values
72 can copy the values' types if needed. */
73 /* This variable is unnecessarily initialized to NULL in order to
74 work around a linker bug on MacOS. */
75 static value_object
*values_in_python
= NULL
;
77 /* Called by the Python interpreter when deallocating a value object. */
79 valpy_dealloc (PyObject
*obj
)
81 value_object
*self
= (value_object
*) obj
;
83 /* Remove SELF from the global list. */
85 self
->prev
->next
= self
->next
;
88 gdb_assert (values_in_python
== self
);
89 values_in_python
= self
->next
;
92 self
->next
->prev
= self
->prev
;
94 value_free (self
->value
);
97 /* Use braces to appease gcc warning. *sigh* */
99 Py_DECREF (self
->address
);
104 Py_DECREF (self
->type
);
107 Py_XDECREF (self
->dynamic_type
);
109 Py_TYPE (self
)->tp_free (self
);
112 /* Helper to push a Value object on the global list. */
114 note_value (value_object
*value_obj
)
116 value_obj
->next
= values_in_python
;
118 value_obj
->next
->prev
= value_obj
;
119 value_obj
->prev
= NULL
;
120 values_in_python
= value_obj
;
123 /* Called when a new gdb.Value object needs to be allocated. Returns NULL on
124 error, with a python exception set. */
126 valpy_new (PyTypeObject
*subtype
, PyObject
*args
, PyObject
*keywords
)
128 struct value
*value
= NULL
; /* Initialize to appease gcc warning. */
129 value_object
*value_obj
;
131 if (PyTuple_Size (args
) != 1)
133 PyErr_SetString (PyExc_TypeError
, _("Value object creation takes only "
138 value_obj
= (value_object
*) subtype
->tp_alloc (subtype
, 1);
139 if (value_obj
== NULL
)
141 PyErr_SetString (PyExc_MemoryError
, _("Could not allocate memory to "
142 "create Value object."));
146 value
= convert_value_from_python (PyTuple_GetItem (args
, 0));
149 subtype
->tp_free (value_obj
);
153 value_obj
->value
= value
;
154 release_value_or_incref (value
);
155 value_obj
->address
= NULL
;
156 value_obj
->type
= NULL
;
157 value_obj
->dynamic_type
= NULL
;
158 note_value (value_obj
);
160 return (PyObject
*) value_obj
;
163 /* Iterate over all the Value objects, calling preserve_one_value on
166 preserve_python_values (struct objfile
*objfile
, htab_t copied_types
)
170 for (iter
= values_in_python
; iter
; iter
= iter
->next
)
171 preserve_one_value (iter
->value
, objfile
, copied_types
);
174 /* Given a value of a pointer type, apply the C unary * operator to it. */
176 valpy_dereference (PyObject
*self
, PyObject
*args
)
178 volatile struct gdb_exception except
;
179 PyObject
*result
= NULL
;
181 TRY_CATCH (except
, RETURN_MASK_ALL
)
183 struct value
*res_val
;
184 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
186 res_val
= value_ind (((value_object
*) self
)->value
);
187 result
= value_to_value_object (res_val
);
188 do_cleanups (cleanup
);
190 GDB_PY_HANDLE_EXCEPTION (except
);
195 /* Given a value of a pointer type or a reference type, return the value
196 referenced. The difference between this function and valpy_dereference is
197 that the latter applies * unary operator to a value, which need not always
198 result in the value referenced. For example, for a value which is a reference
199 to an 'int' pointer ('int *'), valpy_dereference will result in a value of
200 type 'int' while valpy_referenced_value will result in a value of type
204 valpy_referenced_value (PyObject
*self
, PyObject
*args
)
206 volatile struct gdb_exception except
;
207 PyObject
*result
= NULL
;
209 TRY_CATCH (except
, RETURN_MASK_ALL
)
211 struct value
*self_val
, *res_val
;
212 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
214 self_val
= ((value_object
*) self
)->value
;
215 switch (TYPE_CODE (check_typedef (value_type (self_val
))))
218 res_val
= value_ind (self_val
);
221 res_val
= coerce_ref (self_val
);
224 error(_("Trying to get the referenced value from a value which is "
225 "neither a pointer nor a reference."));
228 result
= value_to_value_object (res_val
);
229 do_cleanups (cleanup
);
231 GDB_PY_HANDLE_EXCEPTION (except
);
236 /* Return "&value". */
238 valpy_get_address (PyObject
*self
, void *closure
)
240 value_object
*val_obj
= (value_object
*) self
;
241 volatile struct gdb_exception except
;
243 if (!val_obj
->address
)
245 TRY_CATCH (except
, RETURN_MASK_ALL
)
247 struct value
*res_val
;
248 struct cleanup
*cleanup
249 = make_cleanup_value_free_to_mark (value_mark ());
251 res_val
= value_addr (val_obj
->value
);
252 val_obj
->address
= value_to_value_object (res_val
);
253 do_cleanups (cleanup
);
255 if (except
.reason
< 0)
257 val_obj
->address
= Py_None
;
262 Py_XINCREF (val_obj
->address
);
264 return val_obj
->address
;
267 /* Return type of the value. */
269 valpy_get_type (PyObject
*self
, void *closure
)
271 value_object
*obj
= (value_object
*) self
;
275 obj
->type
= type_to_type_object (value_type (obj
->value
));
279 Py_INCREF (obj
->type
);
283 /* Return dynamic type of the value. */
286 valpy_get_dynamic_type (PyObject
*self
, void *closure
)
288 value_object
*obj
= (value_object
*) self
;
289 volatile struct gdb_exception except
;
290 struct type
*type
= NULL
;
292 if (obj
->dynamic_type
!= NULL
)
294 Py_INCREF (obj
->dynamic_type
);
295 return obj
->dynamic_type
;
298 TRY_CATCH (except
, RETURN_MASK_ALL
)
300 struct value
*val
= obj
->value
;
301 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
303 type
= value_type (val
);
304 CHECK_TYPEDEF (type
);
306 if (((TYPE_CODE (type
) == TYPE_CODE_PTR
)
307 || (TYPE_CODE (type
) == TYPE_CODE_REF
))
308 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
310 struct value
*target
;
311 int was_pointer
= TYPE_CODE (type
) == TYPE_CODE_PTR
;
313 target
= value_ind (val
);
314 type
= value_rtti_type (target
, NULL
, NULL
, NULL
);
319 type
= lookup_pointer_type (type
);
321 type
= lookup_reference_type (type
);
324 else if (TYPE_CODE (type
) == TYPE_CODE_CLASS
)
325 type
= value_rtti_type (val
, NULL
, NULL
, NULL
);
328 /* Re-use object's static type. */
332 do_cleanups (cleanup
);
334 GDB_PY_HANDLE_EXCEPTION (except
);
338 /* Ensure that the TYPE field is ready. */
339 if (!valpy_get_type (self
, NULL
))
341 /* We don't need to incref here, because valpy_get_type already
343 obj
->dynamic_type
= obj
->type
;
346 obj
->dynamic_type
= type_to_type_object (type
);
348 Py_INCREF (obj
->dynamic_type
);
349 return obj
->dynamic_type
;
352 /* Implementation of gdb.Value.lazy_string ([encoding] [, length]) ->
353 string. Return a PyObject representing a lazy_string_object type.
354 A lazy string is a pointer to a string with an optional encoding and
355 length. If ENCODING is not given, encoding is set to None. If an
356 ENCODING is provided the encoding parameter is set to ENCODING, but
357 the string is not encoded. If LENGTH is provided then the length
358 parameter is set to LENGTH, otherwise length will be set to -1 (first
359 null of appropriate with). */
361 valpy_lazy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
363 gdb_py_longest length
= -1;
364 struct value
*value
= ((value_object
*) self
)->value
;
365 const char *user_encoding
= NULL
;
366 static char *keywords
[] = { "encoding", "length", NULL
};
367 PyObject
*str_obj
= NULL
;
368 volatile struct gdb_exception except
;
370 if (!PyArg_ParseTupleAndKeywords (args
, kw
, "|s" GDB_PY_LL_ARG
, keywords
,
371 &user_encoding
, &length
))
374 TRY_CATCH (except
, RETURN_MASK_ALL
)
376 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
378 if (TYPE_CODE (value_type (value
)) == TYPE_CODE_PTR
)
379 value
= value_ind (value
);
381 str_obj
= gdbpy_create_lazy_string_object (value_address (value
), length
,
385 do_cleanups (cleanup
);
387 GDB_PY_HANDLE_EXCEPTION (except
);
392 /* Implementation of gdb.Value.string ([encoding] [, errors]
393 [, length]) -> string. Return Unicode string with value contents.
394 If ENCODING is not given, the string is assumed to be encoded in
395 the target's charset. If LENGTH is provided, only fetch string to
396 the length provided. */
399 valpy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
403 struct value
*value
= ((value_object
*) self
)->value
;
404 volatile struct gdb_exception except
;
406 const char *encoding
= NULL
;
407 const char *errors
= NULL
;
408 const char *user_encoding
= NULL
;
409 const char *la_encoding
= NULL
;
410 struct type
*char_type
;
411 static char *keywords
[] = { "encoding", "errors", "length", NULL
};
413 if (!PyArg_ParseTupleAndKeywords (args
, kw
, "|ssi", keywords
,
414 &user_encoding
, &errors
, &length
))
417 TRY_CATCH (except
, RETURN_MASK_ALL
)
419 LA_GET_STRING (value
, &buffer
, &length
, &char_type
, &la_encoding
);
421 GDB_PY_HANDLE_EXCEPTION (except
);
423 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: la_encoding
;
424 unicode
= PyUnicode_Decode ((const char *) buffer
,
425 length
* TYPE_LENGTH (char_type
),
432 /* A helper function that implements the various cast operators. */
435 valpy_do_cast (PyObject
*self
, PyObject
*args
, enum exp_opcode op
)
437 PyObject
*type_obj
, *result
= NULL
;
439 volatile struct gdb_exception except
;
441 if (! PyArg_ParseTuple (args
, "O", &type_obj
))
444 type
= type_object_to_type (type_obj
);
447 PyErr_SetString (PyExc_RuntimeError
,
448 _("Argument must be a type."));
452 TRY_CATCH (except
, RETURN_MASK_ALL
)
454 struct value
*val
= ((value_object
*) self
)->value
;
455 struct value
*res_val
;
456 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
458 if (op
== UNOP_DYNAMIC_CAST
)
459 res_val
= value_dynamic_cast (type
, val
);
460 else if (op
== UNOP_REINTERPRET_CAST
)
461 res_val
= value_reinterpret_cast (type
, val
);
464 gdb_assert (op
== UNOP_CAST
);
465 res_val
= value_cast (type
, val
);
468 result
= value_to_value_object (res_val
);
469 do_cleanups (cleanup
);
471 GDB_PY_HANDLE_EXCEPTION (except
);
476 /* Implementation of the "cast" method. */
479 valpy_cast (PyObject
*self
, PyObject
*args
)
481 return valpy_do_cast (self
, args
, UNOP_CAST
);
484 /* Implementation of the "dynamic_cast" method. */
487 valpy_dynamic_cast (PyObject
*self
, PyObject
*args
)
489 return valpy_do_cast (self
, args
, UNOP_DYNAMIC_CAST
);
492 /* Implementation of the "reinterpret_cast" method. */
495 valpy_reinterpret_cast (PyObject
*self
, PyObject
*args
)
497 return valpy_do_cast (self
, args
, UNOP_REINTERPRET_CAST
);
501 valpy_length (PyObject
*self
)
503 /* We don't support getting the number of elements in a struct / class. */
504 PyErr_SetString (PyExc_NotImplementedError
,
505 _("Invalid operation on gdb.Value."));
509 /* Given string name of an element inside structure, return its value
510 object. Returns NULL on error, with a python exception set. */
512 valpy_getitem (PyObject
*self
, PyObject
*key
)
514 value_object
*self_value
= (value_object
*) self
;
516 volatile struct gdb_exception except
;
517 PyObject
*result
= NULL
;
519 if (gdbpy_is_string (key
))
521 field
= python_string_to_host_string (key
);
526 TRY_CATCH (except
, RETURN_MASK_ALL
)
528 struct value
*tmp
= self_value
->value
;
529 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
530 struct value
*res_val
= NULL
;
533 res_val
= value_struct_elt (&tmp
, NULL
, field
, 0, NULL
);
536 /* Assume we are attempting an array access, and let the
537 value code throw an exception if the index has an invalid
539 struct value
*idx
= convert_value_from_python (key
);
543 /* Check the value's type is something that can be accessed via
547 tmp
= coerce_ref (tmp
);
548 type
= check_typedef (value_type (tmp
));
549 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
550 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
551 error (_("Cannot subscript requested type."));
553 res_val
= value_subscript (tmp
, value_as_long (idx
));
558 result
= value_to_value_object (res_val
);
559 do_cleanups (cleanup
);
563 GDB_PY_HANDLE_EXCEPTION (except
);
569 valpy_setitem (PyObject
*self
, PyObject
*key
, PyObject
*value
)
571 PyErr_Format (PyExc_NotImplementedError
,
572 _("Setting of struct elements is not currently supported."));
576 /* Called by the Python interpreter to perform an inferior function
577 call on the value. Returns NULL on error, with a python exception set. */
579 valpy_call (PyObject
*self
, PyObject
*args
, PyObject
*keywords
)
581 Py_ssize_t args_count
;
582 volatile struct gdb_exception except
;
583 struct value
*function
= ((value_object
*) self
)->value
;
584 struct value
**vargs
= NULL
;
585 struct type
*ftype
= NULL
;
586 struct value
*mark
= value_mark ();
587 PyObject
*result
= NULL
;
589 TRY_CATCH (except
, RETURN_MASK_ALL
)
591 ftype
= check_typedef (value_type (function
));
593 GDB_PY_HANDLE_EXCEPTION (except
);
595 if (TYPE_CODE (ftype
) != TYPE_CODE_FUNC
)
597 PyErr_SetString (PyExc_RuntimeError
,
598 _("Value is not callable (not TYPE_CODE_FUNC)."));
602 if (! PyTuple_Check (args
))
604 PyErr_SetString (PyExc_TypeError
,
605 _("Inferior arguments must be provided in a tuple."));
609 args_count
= PyTuple_Size (args
);
614 vargs
= alloca (sizeof (struct value
*) * args_count
);
615 for (i
= 0; i
< args_count
; i
++)
617 PyObject
*item
= PyTuple_GetItem (args
, i
);
622 vargs
[i
] = convert_value_from_python (item
);
623 if (vargs
[i
] == NULL
)
628 TRY_CATCH (except
, RETURN_MASK_ALL
)
630 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (mark
);
631 struct value
*return_value
;
633 return_value
= call_function_by_hand (function
, args_count
, vargs
);
634 result
= value_to_value_object (return_value
);
635 do_cleanups (cleanup
);
637 GDB_PY_HANDLE_EXCEPTION (except
);
642 /* Called by the Python interpreter to obtain string representation
645 valpy_str (PyObject
*self
)
649 struct value_print_options opts
;
650 volatile struct gdb_exception except
;
652 get_user_print_options (&opts
);
655 TRY_CATCH (except
, RETURN_MASK_ALL
)
657 struct ui_file
*stb
= mem_fileopen ();
658 struct cleanup
*old_chain
= make_cleanup_ui_file_delete (stb
);
660 common_val_print (((value_object
*) self
)->value
, stb
, 0,
661 &opts
, python_language
);
662 s
= ui_file_xstrdup (stb
, NULL
);
664 do_cleanups (old_chain
);
666 GDB_PY_HANDLE_EXCEPTION (except
);
668 result
= PyUnicode_Decode (s
, strlen (s
), host_charset (), NULL
);
674 /* Implements gdb.Value.is_optimized_out. */
676 valpy_get_is_optimized_out (PyObject
*self
, void *closure
)
678 struct value
*value
= ((value_object
*) self
)->value
;
680 volatile struct gdb_exception except
;
682 TRY_CATCH (except
, RETURN_MASK_ALL
)
684 opt
= value_optimized_out (value
);
686 GDB_PY_HANDLE_EXCEPTION (except
);
694 /* Implements gdb.Value.is_lazy. */
696 valpy_get_is_lazy (PyObject
*self
, void *closure
)
698 struct value
*value
= ((value_object
*) self
)->value
;
700 volatile struct gdb_exception except
;
702 TRY_CATCH (except
, RETURN_MASK_ALL
)
704 opt
= value_lazy (value
);
706 GDB_PY_HANDLE_EXCEPTION (except
);
714 /* Implements gdb.Value.fetch_lazy (). */
716 valpy_fetch_lazy (PyObject
*self
, PyObject
*args
)
718 struct value
*value
= ((value_object
*) self
)->value
;
719 volatile struct gdb_exception except
;
721 TRY_CATCH (except
, RETURN_MASK_ALL
)
723 if (value_lazy (value
))
724 value_fetch_lazy (value
);
726 GDB_PY_HANDLE_EXCEPTION (except
);
731 /* Calculate and return the address of the PyObject as the value of
732 the builtin __hash__ call. */
734 valpy_hash (PyObject
*self
)
736 return (long) (intptr_t) self
;
754 /* If TYPE is a reference, return the target; otherwise return TYPE. */
755 #define STRIP_REFERENCE(TYPE) \
756 ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
758 /* Returns a value object which is the result of applying the operation
759 specified by OPCODE to the given arguments. Returns NULL on error, with
760 a python exception set. */
762 valpy_binop (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
764 volatile struct gdb_exception except
;
765 PyObject
*result
= NULL
;
767 TRY_CATCH (except
, RETURN_MASK_ALL
)
769 struct value
*arg1
, *arg2
;
770 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
771 struct value
*res_val
= NULL
;
773 /* If the gdb.Value object is the second operand, then it will be passed
774 to us as the OTHER argument, and SELF will be an entirely different
775 kind of object, altogether. Because of this, we can't assume self is
776 a gdb.Value object and need to convert it from python as well. */
777 arg1
= convert_value_from_python (self
);
781 arg2
= convert_value_from_python (other
);
789 struct type
*ltype
= value_type (arg1
);
790 struct type
*rtype
= value_type (arg2
);
792 CHECK_TYPEDEF (ltype
);
793 ltype
= STRIP_REFERENCE (ltype
);
794 CHECK_TYPEDEF (rtype
);
795 rtype
= STRIP_REFERENCE (rtype
);
797 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
798 && is_integral_type (rtype
))
799 res_val
= value_ptradd (arg1
, value_as_long (arg2
));
800 else if (TYPE_CODE (rtype
) == TYPE_CODE_PTR
801 && is_integral_type (ltype
))
802 res_val
= value_ptradd (arg2
, value_as_long (arg1
));
804 res_val
= value_binop (arg1
, arg2
, BINOP_ADD
);
809 struct type
*ltype
= value_type (arg1
);
810 struct type
*rtype
= value_type (arg2
);
812 CHECK_TYPEDEF (ltype
);
813 ltype
= STRIP_REFERENCE (ltype
);
814 CHECK_TYPEDEF (rtype
);
815 rtype
= STRIP_REFERENCE (rtype
);
817 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
818 && TYPE_CODE (rtype
) == TYPE_CODE_PTR
)
819 /* A ptrdiff_t for the target would be preferable here. */
820 res_val
= value_from_longest (builtin_type_pyint
,
821 value_ptrdiff (arg1
, arg2
));
822 else if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
823 && is_integral_type (rtype
))
824 res_val
= value_ptradd (arg1
, - value_as_long (arg2
));
826 res_val
= value_binop (arg1
, arg2
, BINOP_SUB
);
830 res_val
= value_binop (arg1
, arg2
, BINOP_MUL
);
833 res_val
= value_binop (arg1
, arg2
, BINOP_DIV
);
836 res_val
= value_binop (arg1
, arg2
, BINOP_REM
);
839 res_val
= value_binop (arg1
, arg2
, BINOP_EXP
);
842 res_val
= value_binop (arg1
, arg2
, BINOP_LSH
);
845 res_val
= value_binop (arg1
, arg2
, BINOP_RSH
);
848 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_AND
);
851 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_IOR
);
854 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_XOR
);
859 result
= value_to_value_object (res_val
);
861 do_cleanups (cleanup
);
863 GDB_PY_HANDLE_EXCEPTION (except
);
869 valpy_add (PyObject
*self
, PyObject
*other
)
871 return valpy_binop (VALPY_ADD
, self
, other
);
875 valpy_subtract (PyObject
*self
, PyObject
*other
)
877 return valpy_binop (VALPY_SUB
, self
, other
);
881 valpy_multiply (PyObject
*self
, PyObject
*other
)
883 return valpy_binop (VALPY_MUL
, self
, other
);
887 valpy_divide (PyObject
*self
, PyObject
*other
)
889 return valpy_binop (VALPY_DIV
, self
, other
);
893 valpy_remainder (PyObject
*self
, PyObject
*other
)
895 return valpy_binop (VALPY_REM
, self
, other
);
899 valpy_power (PyObject
*self
, PyObject
*other
, PyObject
*unused
)
901 /* We don't support the ternary form of pow. I don't know how to express
902 that, so let's just throw NotImplementedError to at least do something
904 if (unused
!= Py_None
)
906 PyErr_SetString (PyExc_NotImplementedError
,
907 "Invalid operation on gdb.Value.");
911 return valpy_binop (VALPY_POW
, self
, other
);
915 valpy_negative (PyObject
*self
)
917 volatile struct gdb_exception except
;
918 PyObject
*result
= NULL
;
920 TRY_CATCH (except
, RETURN_MASK_ALL
)
922 /* Perhaps overkill, but consistency has some virtue. */
923 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
926 val
= value_neg (((value_object
*) self
)->value
);
927 result
= value_to_value_object (val
);
928 do_cleanups (cleanup
);
930 GDB_PY_HANDLE_EXCEPTION (except
);
936 valpy_positive (PyObject
*self
)
938 return value_to_value_object (((value_object
*) self
)->value
);
942 valpy_absolute (PyObject
*self
)
944 struct value
*value
= ((value_object
*) self
)->value
;
945 volatile struct gdb_exception except
;
948 TRY_CATCH (except
, RETURN_MASK_ALL
)
950 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
952 if (value_less (value
, value_zero (value_type (value
), not_lval
)))
955 do_cleanups (cleanup
);
957 GDB_PY_HANDLE_EXCEPTION (except
);
960 return valpy_positive (self
);
962 return valpy_negative (self
);
965 /* Implements boolean evaluation of gdb.Value. */
967 valpy_nonzero (PyObject
*self
)
969 volatile struct gdb_exception except
;
970 value_object
*self_value
= (value_object
*) self
;
972 int nonzero
= 0; /* Appease GCC warning. */
974 TRY_CATCH (except
, RETURN_MASK_ALL
)
976 type
= check_typedef (value_type (self_value
->value
));
978 if (is_integral_type (type
) || TYPE_CODE (type
) == TYPE_CODE_PTR
)
979 nonzero
= !!value_as_long (self_value
->value
);
980 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
981 nonzero
= value_as_double (self_value
->value
) != 0;
982 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
983 nonzero
= !decimal_is_zero (value_contents (self_value
->value
),
985 gdbarch_byte_order (get_type_arch (type
)));
987 /* All other values are True. */
990 /* This is not documented in the Python documentation, but if this
991 function fails, return -1 as slot_nb_nonzero does (the default
992 Python nonzero function). */
993 GDB_PY_SET_HANDLE_EXCEPTION (except
);
998 /* Implements ~ for value objects. */
1000 valpy_invert (PyObject
*self
)
1002 struct value
*val
= NULL
;
1003 volatile struct gdb_exception except
;
1005 TRY_CATCH (except
, RETURN_MASK_ALL
)
1007 val
= value_complement (((value_object
*) self
)->value
);
1009 GDB_PY_HANDLE_EXCEPTION (except
);
1011 return value_to_value_object (val
);
1014 /* Implements left shift for value objects. */
1016 valpy_lsh (PyObject
*self
, PyObject
*other
)
1018 return valpy_binop (VALPY_LSH
, self
, other
);
1021 /* Implements right shift for value objects. */
1023 valpy_rsh (PyObject
*self
, PyObject
*other
)
1025 return valpy_binop (VALPY_RSH
, self
, other
);
1028 /* Implements bitwise and for value objects. */
1030 valpy_and (PyObject
*self
, PyObject
*other
)
1032 return valpy_binop (VALPY_BITAND
, self
, other
);
1035 /* Implements bitwise or for value objects. */
1037 valpy_or (PyObject
*self
, PyObject
*other
)
1039 return valpy_binop (VALPY_BITOR
, self
, other
);
1042 /* Implements bitwise xor for value objects. */
1044 valpy_xor (PyObject
*self
, PyObject
*other
)
1046 return valpy_binop (VALPY_BITXOR
, self
, other
);
1049 /* Implements comparison operations for value objects. Returns NULL on error,
1050 with a python exception set. */
1052 valpy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1055 volatile struct gdb_exception except
;
1057 if (other
== Py_None
)
1058 /* Comparing with None is special. From what I can tell, in Python
1059 None is smaller than anything else. */
1071 PyErr_SetString (PyExc_NotImplementedError
,
1072 _("Invalid operation on gdb.Value."));
1076 TRY_CATCH (except
, RETURN_MASK_ALL
)
1078 struct value
*value_other
, *mark
= value_mark ();
1079 struct cleanup
*cleanup
;
1081 value_other
= convert_value_from_python (other
);
1082 if (value_other
== NULL
)
1088 cleanup
= make_cleanup_value_free_to_mark (mark
);
1092 result
= value_less (((value_object
*) self
)->value
, value_other
);
1095 result
= value_less (((value_object
*) self
)->value
, value_other
)
1096 || value_equal (((value_object
*) self
)->value
, value_other
);
1099 result
= value_equal (((value_object
*) self
)->value
, value_other
);
1102 result
= !value_equal (((value_object
*) self
)->value
, value_other
);
1105 result
= value_less (value_other
, ((value_object
*) self
)->value
);
1108 result
= value_less (value_other
, ((value_object
*) self
)->value
)
1109 || value_equal (((value_object
*) self
)->value
, value_other
);
1113 PyErr_SetString (PyExc_NotImplementedError
,
1114 _("Invalid operation on gdb.Value."));
1119 do_cleanups (cleanup
);
1121 GDB_PY_HANDLE_EXCEPTION (except
);
1123 /* In this case, the Python exception has already been set. */
1133 /* Helper function to determine if a type is "int-like". */
1135 is_intlike (struct type
*type
, int ptr_ok
)
1137 return (TYPE_CODE (type
) == TYPE_CODE_INT
1138 || TYPE_CODE (type
) == TYPE_CODE_ENUM
1139 || TYPE_CODE (type
) == TYPE_CODE_BOOL
1140 || TYPE_CODE (type
) == TYPE_CODE_CHAR
1141 || (ptr_ok
&& TYPE_CODE (type
) == TYPE_CODE_PTR
));
1145 /* Implements conversion to int. */
1147 valpy_int (PyObject
*self
)
1149 struct value
*value
= ((value_object
*) self
)->value
;
1150 struct type
*type
= value_type (value
);
1152 volatile struct gdb_exception except
;
1154 TRY_CATCH (except
, RETURN_MASK_ALL
)
1156 CHECK_TYPEDEF (type
);
1157 if (!is_intlike (type
, 0))
1158 error (_("Cannot convert value to int."));
1160 l
= value_as_long (value
);
1162 GDB_PY_HANDLE_EXCEPTION (except
);
1164 return gdb_py_object_from_longest (l
);
1168 /* Implements conversion to long. */
1170 valpy_long (PyObject
*self
)
1172 struct value
*value
= ((value_object
*) self
)->value
;
1173 struct type
*type
= value_type (value
);
1175 volatile struct gdb_exception except
;
1177 TRY_CATCH (except
, RETURN_MASK_ALL
)
1179 CHECK_TYPEDEF (type
);
1181 if (!is_intlike (type
, 1))
1182 error (_("Cannot convert value to long."));
1184 l
= value_as_long (value
);
1186 GDB_PY_HANDLE_EXCEPTION (except
);
1188 return gdb_py_long_from_longest (l
);
1191 /* Implements conversion to float. */
1193 valpy_float (PyObject
*self
)
1195 struct value
*value
= ((value_object
*) self
)->value
;
1196 struct type
*type
= value_type (value
);
1198 volatile struct gdb_exception except
;
1200 TRY_CATCH (except
, RETURN_MASK_ALL
)
1202 CHECK_TYPEDEF (type
);
1204 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
1205 error (_("Cannot convert value to float."));
1207 d
= value_as_double (value
);
1209 GDB_PY_HANDLE_EXCEPTION (except
);
1211 return PyFloat_FromDouble (d
);
1214 /* Returns an object for a value which is released from the all_values chain,
1215 so its lifetime is not bound to the execution of a command. */
1217 value_to_value_object (struct value
*val
)
1219 value_object
*val_obj
;
1221 val_obj
= PyObject_New (value_object
, &value_object_type
);
1222 if (val_obj
!= NULL
)
1224 val_obj
->value
= val
;
1225 release_value_or_incref (val
);
1226 val_obj
->address
= NULL
;
1227 val_obj
->type
= NULL
;
1228 val_obj
->dynamic_type
= NULL
;
1229 note_value (val_obj
);
1232 return (PyObject
*) val_obj
;
1235 /* Returns a borrowed reference to the struct value corresponding to
1236 the given value object. */
1238 value_object_to_value (PyObject
*self
)
1242 if (! PyObject_TypeCheck (self
, &value_object_type
))
1244 real
= (value_object
*) self
;
1248 /* Try to convert a Python value to a gdb value. If the value cannot
1249 be converted, set a Python exception and return NULL. Returns a
1250 reference to a new value on the all_values chain. */
1253 convert_value_from_python (PyObject
*obj
)
1255 struct value
*value
= NULL
; /* -Wall */
1256 volatile struct gdb_exception except
;
1259 gdb_assert (obj
!= NULL
);
1261 TRY_CATCH (except
, RETURN_MASK_ALL
)
1263 if (PyBool_Check (obj
))
1265 cmp
= PyObject_IsTrue (obj
);
1267 value
= value_from_longest (builtin_type_pybool
, cmp
);
1269 else if (PyInt_Check (obj
))
1271 long l
= PyInt_AsLong (obj
);
1273 if (! PyErr_Occurred ())
1274 value
= value_from_longest (builtin_type_pyint
, l
);
1276 else if (PyLong_Check (obj
))
1278 LONGEST l
= PyLong_AsLongLong (obj
);
1280 if (PyErr_Occurred ())
1282 /* If the error was an overflow, we can try converting to
1283 ULONGEST instead. */
1284 if (PyErr_ExceptionMatches (PyExc_OverflowError
))
1286 PyObject
*etype
, *evalue
, *etraceback
, *zero
;
1288 PyErr_Fetch (&etype
, &evalue
, &etraceback
);
1289 zero
= PyInt_FromLong (0);
1291 /* Check whether obj is positive. */
1292 if (PyObject_RichCompareBool (obj
, zero
, Py_GT
) > 0)
1296 ul
= PyLong_AsUnsignedLongLong (obj
);
1297 if (! PyErr_Occurred ())
1298 value
= value_from_ulongest (builtin_type_upylong
, ul
);
1301 /* There's nothing we can do. */
1302 PyErr_Restore (etype
, evalue
, etraceback
);
1308 value
= value_from_longest (builtin_type_pylong
, l
);
1310 else if (PyFloat_Check (obj
))
1312 double d
= PyFloat_AsDouble (obj
);
1314 if (! PyErr_Occurred ())
1315 value
= value_from_double (builtin_type_pyfloat
, d
);
1317 else if (gdbpy_is_string (obj
))
1321 s
= python_string_to_target_string (obj
);
1324 struct cleanup
*old
;
1326 old
= make_cleanup (xfree
, s
);
1327 value
= value_cstring (s
, strlen (s
), builtin_type_pychar
);
1331 else if (PyObject_TypeCheck (obj
, &value_object_type
))
1332 value
= value_copy (((value_object
*) obj
)->value
);
1333 else if (gdbpy_is_lazy_string (obj
))
1337 result
= PyObject_CallMethodObjArgs (obj
, gdbpy_value_cst
, NULL
);
1338 value
= value_copy (((value_object
*) result
)->value
);
1342 PyErr_Format (PyExc_TypeError
,
1343 _("Could not convert Python object: %S."), obj
);
1345 PyErr_Format (PyExc_TypeError
,
1346 _("Could not convert Python object: %s."),
1347 PyString_AsString (PyObject_Str (obj
)));
1350 if (except
.reason
< 0)
1352 PyErr_Format (except
.reason
== RETURN_QUIT
1353 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
1354 "%s", except
.message
);
1361 /* Returns value object in the ARGth position in GDB's history. */
1363 gdbpy_history (PyObject
*self
, PyObject
*args
)
1366 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
1367 volatile struct gdb_exception except
;
1369 if (!PyArg_ParseTuple (args
, "i", &i
))
1372 TRY_CATCH (except
, RETURN_MASK_ALL
)
1374 res_val
= access_value_history (i
);
1376 GDB_PY_HANDLE_EXCEPTION (except
);
1378 return value_to_value_object (res_val
);
1381 /* Returns 1 in OBJ is a gdb.Value object, 0 otherwise. */
1384 gdbpy_is_value_object (PyObject
*obj
)
1386 return PyObject_TypeCheck (obj
, &value_object_type
);
1390 gdbpy_initialize_values (void)
1392 if (PyType_Ready (&value_object_type
) < 0)
1395 Py_INCREF (&value_object_type
);
1396 return PyModule_AddObject (gdb_module
, "Value",
1397 (PyObject
*) &value_object_type
);
1402 static PyGetSetDef value_object_getset
[] = {
1403 { "address", valpy_get_address
, NULL
, "The address of the value.",
1405 { "is_optimized_out", valpy_get_is_optimized_out
, NULL
,
1406 "Boolean telling whether the value is optimized "
1407 "out (i.e., not available).",
1409 { "type", valpy_get_type
, NULL
, "Type of the value.", NULL
},
1410 { "dynamic_type", valpy_get_dynamic_type
, NULL
,
1411 "Dynamic type of the value.", NULL
},
1412 { "is_lazy", valpy_get_is_lazy
, NULL
,
1413 "Boolean telling whether the value is lazy (not fetched yet\n\
1414 from the inferior). A lazy value is fetched when needed, or when\n\
1415 the \"fetch_lazy()\" method is called.", NULL
},
1416 {NULL
} /* Sentinel */
1419 static PyMethodDef value_object_methods
[] = {
1420 { "cast", valpy_cast
, METH_VARARGS
, "Cast the value to the supplied type." },
1421 { "dynamic_cast", valpy_dynamic_cast
, METH_VARARGS
,
1422 "dynamic_cast (gdb.Type) -> gdb.Value\n\
1423 Cast the value to the supplied type, as if by the C++ dynamic_cast operator."
1425 { "reinterpret_cast", valpy_reinterpret_cast
, METH_VARARGS
,
1426 "reinterpret_cast (gdb.Type) -> gdb.Value\n\
1427 Cast the value to the supplied type, as if by the C++\n\
1428 reinterpret_cast operator."
1430 { "dereference", valpy_dereference
, METH_NOARGS
, "Dereferences the value." },
1431 { "referenced_value", valpy_referenced_value
, METH_NOARGS
,
1432 "Return the value referenced by a TYPE_CODE_REF or TYPE_CODE_PTR value." },
1433 { "lazy_string", (PyCFunction
) valpy_lazy_string
,
1434 METH_VARARGS
| METH_KEYWORDS
,
1435 "lazy_string ([encoding] [, length]) -> lazy_string\n\
1436 Return a lazy string representation of the value." },
1437 { "string", (PyCFunction
) valpy_string
, METH_VARARGS
| METH_KEYWORDS
,
1438 "string ([encoding] [, errors] [, length]) -> string\n\
1439 Return Unicode string representation of the value." },
1440 { "fetch_lazy", valpy_fetch_lazy
, METH_NOARGS
,
1441 "Fetches the value from the inferior, if it was lazy." },
1442 {NULL
} /* Sentinel */
1445 static PyNumberMethods value_object_as_number
= {
1453 NULL
, /* nb_divmod */
1454 valpy_power
, /* nb_power */
1455 valpy_negative
, /* nb_negative */
1456 valpy_positive
, /* nb_positive */
1457 valpy_absolute
, /* nb_absolute */
1458 valpy_nonzero
, /* nb_nonzero */
1459 valpy_invert
, /* nb_invert */
1460 valpy_lsh
, /* nb_lshift */
1461 valpy_rsh
, /* nb_rshift */
1462 valpy_and
, /* nb_and */
1463 valpy_xor
, /* nb_xor */
1464 valpy_or
, /* nb_or */
1466 valpy_long
, /* nb_int */
1467 NULL
, /* reserved */
1469 NULL
, /* nb_coerce */
1470 valpy_int
, /* nb_int */
1471 valpy_long
, /* nb_long */
1473 valpy_float
, /* nb_float */
1478 NULL
, /* nb_inplace_add */
1479 NULL
, /* nb_inplace_subtract */
1480 NULL
, /* nb_inplace_multiply */
1481 NULL
, /* nb_inplace_remainder */
1482 NULL
, /* nb_inplace_power */
1483 NULL
, /* nb_inplace_lshift */
1484 NULL
, /* nb_inplace_rshift */
1485 NULL
, /* nb_inplace_and */
1486 NULL
, /* nb_inplace_xor */
1487 NULL
, /* nb_inplace_or */
1488 NULL
, /* nb_floor_divide */
1489 valpy_divide
/* nb_true_divide */
1492 static PyMappingMethods value_object_as_mapping
= {
1498 PyTypeObject value_object_type
= {
1499 PyVarObject_HEAD_INIT (NULL
, 0)
1500 "gdb.Value", /*tp_name*/
1501 sizeof (value_object
), /*tp_basicsize*/
1503 valpy_dealloc
, /*tp_dealloc*/
1509 &value_object_as_number
, /*tp_as_number*/
1510 0, /*tp_as_sequence*/
1511 &value_object_as_mapping
, /*tp_as_mapping*/
1512 valpy_hash
, /*tp_hash*/
1513 valpy_call
, /*tp_call*/
1514 valpy_str
, /*tp_str*/
1518 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
1519 | Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1520 "GDB value object", /* tp_doc */
1521 0, /* tp_traverse */
1523 valpy_richcompare
, /* tp_richcompare */
1524 0, /* tp_weaklistoffset */
1526 0, /* tp_iternext */
1527 value_object_methods
, /* tp_methods */
1529 value_object_getset
, /* tp_getset */
1532 0, /* tp_descr_get */
1533 0, /* tp_descr_set */
1534 0, /* tp_dictoffset */
1537 valpy_new
/* tp_new */
1543 preserve_python_values (struct objfile
*objfile
, htab_t copied_types
)
1548 #endif /* HAVE_PYTHON */