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
);
337 obj
->dynamic_type
= valpy_get_type (self
, NULL
);
339 obj
->dynamic_type
= type_to_type_object (type
);
341 Py_XINCREF (obj
->dynamic_type
);
342 return obj
->dynamic_type
;
345 /* Implementation of gdb.Value.lazy_string ([encoding] [, length]) ->
346 string. Return a PyObject representing a lazy_string_object type.
347 A lazy string is a pointer to a string with an optional encoding and
348 length. If ENCODING is not given, encoding is set to None. If an
349 ENCODING is provided the encoding parameter is set to ENCODING, but
350 the string is not encoded. If LENGTH is provided then the length
351 parameter is set to LENGTH, otherwise length will be set to -1 (first
352 null of appropriate with). */
354 valpy_lazy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
356 gdb_py_longest length
= -1;
357 struct value
*value
= ((value_object
*) self
)->value
;
358 const char *user_encoding
= NULL
;
359 static char *keywords
[] = { "encoding", "length", NULL
};
360 PyObject
*str_obj
= NULL
;
361 volatile struct gdb_exception except
;
363 if (!PyArg_ParseTupleAndKeywords (args
, kw
, "|s" GDB_PY_LL_ARG
, keywords
,
364 &user_encoding
, &length
))
367 TRY_CATCH (except
, RETURN_MASK_ALL
)
369 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
371 if (TYPE_CODE (value_type (value
)) == TYPE_CODE_PTR
)
372 value
= value_ind (value
);
374 str_obj
= gdbpy_create_lazy_string_object (value_address (value
), length
,
378 do_cleanups (cleanup
);
380 GDB_PY_HANDLE_EXCEPTION (except
);
385 /* Implementation of gdb.Value.string ([encoding] [, errors]
386 [, length]) -> string. Return Unicode string with value contents.
387 If ENCODING is not given, the string is assumed to be encoded in
388 the target's charset. If LENGTH is provided, only fetch string to
389 the length provided. */
392 valpy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
396 struct value
*value
= ((value_object
*) self
)->value
;
397 volatile struct gdb_exception except
;
399 const char *encoding
= NULL
;
400 const char *errors
= NULL
;
401 const char *user_encoding
= NULL
;
402 const char *la_encoding
= NULL
;
403 struct type
*char_type
;
404 static char *keywords
[] = { "encoding", "errors", "length", NULL
};
406 if (!PyArg_ParseTupleAndKeywords (args
, kw
, "|ssi", keywords
,
407 &user_encoding
, &errors
, &length
))
410 TRY_CATCH (except
, RETURN_MASK_ALL
)
412 LA_GET_STRING (value
, &buffer
, &length
, &char_type
, &la_encoding
);
414 GDB_PY_HANDLE_EXCEPTION (except
);
416 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: la_encoding
;
417 unicode
= PyUnicode_Decode ((const char *) buffer
,
418 length
* TYPE_LENGTH (char_type
),
425 /* A helper function that implements the various cast operators. */
428 valpy_do_cast (PyObject
*self
, PyObject
*args
, enum exp_opcode op
)
430 PyObject
*type_obj
, *result
= NULL
;
432 volatile struct gdb_exception except
;
434 if (! PyArg_ParseTuple (args
, "O", &type_obj
))
437 type
= type_object_to_type (type_obj
);
440 PyErr_SetString (PyExc_RuntimeError
,
441 _("Argument must be a type."));
445 TRY_CATCH (except
, RETURN_MASK_ALL
)
447 struct value
*val
= ((value_object
*) self
)->value
;
448 struct value
*res_val
;
449 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
451 if (op
== UNOP_DYNAMIC_CAST
)
452 res_val
= value_dynamic_cast (type
, val
);
453 else if (op
== UNOP_REINTERPRET_CAST
)
454 res_val
= value_reinterpret_cast (type
, val
);
457 gdb_assert (op
== UNOP_CAST
);
458 res_val
= value_cast (type
, val
);
461 result
= value_to_value_object (res_val
);
462 do_cleanups (cleanup
);
464 GDB_PY_HANDLE_EXCEPTION (except
);
469 /* Implementation of the "cast" method. */
472 valpy_cast (PyObject
*self
, PyObject
*args
)
474 return valpy_do_cast (self
, args
, UNOP_CAST
);
477 /* Implementation of the "dynamic_cast" method. */
480 valpy_dynamic_cast (PyObject
*self
, PyObject
*args
)
482 return valpy_do_cast (self
, args
, UNOP_DYNAMIC_CAST
);
485 /* Implementation of the "reinterpret_cast" method. */
488 valpy_reinterpret_cast (PyObject
*self
, PyObject
*args
)
490 return valpy_do_cast (self
, args
, UNOP_REINTERPRET_CAST
);
494 valpy_length (PyObject
*self
)
496 /* We don't support getting the number of elements in a struct / class. */
497 PyErr_SetString (PyExc_NotImplementedError
,
498 _("Invalid operation on gdb.Value."));
502 /* Given string name of an element inside structure, return its value
503 object. Returns NULL on error, with a python exception set. */
505 valpy_getitem (PyObject
*self
, PyObject
*key
)
507 value_object
*self_value
= (value_object
*) self
;
509 volatile struct gdb_exception except
;
510 PyObject
*result
= NULL
;
512 if (gdbpy_is_string (key
))
514 field
= python_string_to_host_string (key
);
519 TRY_CATCH (except
, RETURN_MASK_ALL
)
521 struct value
*tmp
= self_value
->value
;
522 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
523 struct value
*res_val
= NULL
;
526 res_val
= value_struct_elt (&tmp
, NULL
, field
, 0, NULL
);
529 /* Assume we are attempting an array access, and let the
530 value code throw an exception if the index has an invalid
532 struct value
*idx
= convert_value_from_python (key
);
536 /* Check the value's type is something that can be accessed via
540 tmp
= coerce_ref (tmp
);
541 type
= check_typedef (value_type (tmp
));
542 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
543 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
544 error (_("Cannot subscript requested type."));
546 res_val
= value_subscript (tmp
, value_as_long (idx
));
551 result
= value_to_value_object (res_val
);
552 do_cleanups (cleanup
);
556 GDB_PY_HANDLE_EXCEPTION (except
);
562 valpy_setitem (PyObject
*self
, PyObject
*key
, PyObject
*value
)
564 PyErr_Format (PyExc_NotImplementedError
,
565 _("Setting of struct elements is not currently supported."));
569 /* Called by the Python interpreter to perform an inferior function
570 call on the value. Returns NULL on error, with a python exception set. */
572 valpy_call (PyObject
*self
, PyObject
*args
, PyObject
*keywords
)
574 Py_ssize_t args_count
;
575 volatile struct gdb_exception except
;
576 struct value
*function
= ((value_object
*) self
)->value
;
577 struct value
**vargs
= NULL
;
578 struct type
*ftype
= NULL
;
579 struct value
*mark
= value_mark ();
580 PyObject
*result
= NULL
;
582 TRY_CATCH (except
, RETURN_MASK_ALL
)
584 ftype
= check_typedef (value_type (function
));
586 GDB_PY_HANDLE_EXCEPTION (except
);
588 if (TYPE_CODE (ftype
) != TYPE_CODE_FUNC
)
590 PyErr_SetString (PyExc_RuntimeError
,
591 _("Value is not callable (not TYPE_CODE_FUNC)."));
595 if (! PyTuple_Check (args
))
597 PyErr_SetString (PyExc_TypeError
,
598 _("Inferior arguments must be provided in a tuple."));
602 args_count
= PyTuple_Size (args
);
607 vargs
= alloca (sizeof (struct value
*) * args_count
);
608 for (i
= 0; i
< args_count
; i
++)
610 PyObject
*item
= PyTuple_GetItem (args
, i
);
615 vargs
[i
] = convert_value_from_python (item
);
616 if (vargs
[i
] == NULL
)
621 TRY_CATCH (except
, RETURN_MASK_ALL
)
623 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (mark
);
624 struct value
*return_value
;
626 return_value
= call_function_by_hand (function
, args_count
, vargs
);
627 result
= value_to_value_object (return_value
);
628 do_cleanups (cleanup
);
630 GDB_PY_HANDLE_EXCEPTION (except
);
635 /* Called by the Python interpreter to obtain string representation
638 valpy_str (PyObject
*self
)
642 struct value_print_options opts
;
643 volatile struct gdb_exception except
;
645 get_user_print_options (&opts
);
648 TRY_CATCH (except
, RETURN_MASK_ALL
)
650 struct ui_file
*stb
= mem_fileopen ();
651 struct cleanup
*old_chain
= make_cleanup_ui_file_delete (stb
);
653 common_val_print (((value_object
*) self
)->value
, stb
, 0,
654 &opts
, python_language
);
655 s
= ui_file_xstrdup (stb
, NULL
);
657 do_cleanups (old_chain
);
659 GDB_PY_HANDLE_EXCEPTION (except
);
661 result
= PyUnicode_Decode (s
, strlen (s
), host_charset (), NULL
);
667 /* Implements gdb.Value.is_optimized_out. */
669 valpy_get_is_optimized_out (PyObject
*self
, void *closure
)
671 struct value
*value
= ((value_object
*) self
)->value
;
673 volatile struct gdb_exception except
;
675 TRY_CATCH (except
, RETURN_MASK_ALL
)
677 opt
= value_optimized_out (value
);
679 GDB_PY_HANDLE_EXCEPTION (except
);
687 /* Implements gdb.Value.is_lazy. */
689 valpy_get_is_lazy (PyObject
*self
, void *closure
)
691 struct value
*value
= ((value_object
*) self
)->value
;
693 volatile struct gdb_exception except
;
695 TRY_CATCH (except
, RETURN_MASK_ALL
)
697 opt
= value_lazy (value
);
699 GDB_PY_HANDLE_EXCEPTION (except
);
707 /* Implements gdb.Value.fetch_lazy (). */
709 valpy_fetch_lazy (PyObject
*self
, PyObject
*args
)
711 struct value
*value
= ((value_object
*) self
)->value
;
712 volatile struct gdb_exception except
;
714 TRY_CATCH (except
, RETURN_MASK_ALL
)
716 if (value_lazy (value
))
717 value_fetch_lazy (value
);
719 GDB_PY_HANDLE_EXCEPTION (except
);
724 /* Calculate and return the address of the PyObject as the value of
725 the builtin __hash__ call. */
727 valpy_hash (PyObject
*self
)
729 return (long) (intptr_t) self
;
747 /* If TYPE is a reference, return the target; otherwise return TYPE. */
748 #define STRIP_REFERENCE(TYPE) \
749 ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
751 /* Returns a value object which is the result of applying the operation
752 specified by OPCODE to the given arguments. Returns NULL on error, with
753 a python exception set. */
755 valpy_binop (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
757 volatile struct gdb_exception except
;
758 PyObject
*result
= NULL
;
760 TRY_CATCH (except
, RETURN_MASK_ALL
)
762 struct value
*arg1
, *arg2
;
763 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
764 struct value
*res_val
= NULL
;
766 /* If the gdb.Value object is the second operand, then it will be passed
767 to us as the OTHER argument, and SELF will be an entirely different
768 kind of object, altogether. Because of this, we can't assume self is
769 a gdb.Value object and need to convert it from python as well. */
770 arg1
= convert_value_from_python (self
);
773 do_cleanups (cleanup
);
777 arg2
= convert_value_from_python (other
);
780 do_cleanups (cleanup
);
788 struct type
*ltype
= value_type (arg1
);
789 struct type
*rtype
= value_type (arg2
);
791 CHECK_TYPEDEF (ltype
);
792 ltype
= STRIP_REFERENCE (ltype
);
793 CHECK_TYPEDEF (rtype
);
794 rtype
= STRIP_REFERENCE (rtype
);
796 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
797 && is_integral_type (rtype
))
798 res_val
= value_ptradd (arg1
, value_as_long (arg2
));
799 else if (TYPE_CODE (rtype
) == TYPE_CODE_PTR
800 && is_integral_type (ltype
))
801 res_val
= value_ptradd (arg2
, value_as_long (arg1
));
803 res_val
= value_binop (arg1
, arg2
, BINOP_ADD
);
808 struct type
*ltype
= value_type (arg1
);
809 struct type
*rtype
= value_type (arg2
);
811 CHECK_TYPEDEF (ltype
);
812 ltype
= STRIP_REFERENCE (ltype
);
813 CHECK_TYPEDEF (rtype
);
814 rtype
= STRIP_REFERENCE (rtype
);
816 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
817 && TYPE_CODE (rtype
) == TYPE_CODE_PTR
)
818 /* A ptrdiff_t for the target would be preferable here. */
819 res_val
= value_from_longest (builtin_type_pyint
,
820 value_ptrdiff (arg1
, arg2
));
821 else if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
822 && is_integral_type (rtype
))
823 res_val
= value_ptradd (arg1
, - value_as_long (arg2
));
825 res_val
= value_binop (arg1
, arg2
, BINOP_SUB
);
829 res_val
= value_binop (arg1
, arg2
, BINOP_MUL
);
832 res_val
= value_binop (arg1
, arg2
, BINOP_DIV
);
835 res_val
= value_binop (arg1
, arg2
, BINOP_REM
);
838 res_val
= value_binop (arg1
, arg2
, BINOP_EXP
);
841 res_val
= value_binop (arg1
, arg2
, BINOP_LSH
);
844 res_val
= value_binop (arg1
, arg2
, BINOP_RSH
);
847 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_AND
);
850 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_IOR
);
853 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_XOR
);
858 result
= value_to_value_object (res_val
);
860 do_cleanups (cleanup
);
862 GDB_PY_HANDLE_EXCEPTION (except
);
868 valpy_add (PyObject
*self
, PyObject
*other
)
870 return valpy_binop (VALPY_ADD
, self
, other
);
874 valpy_subtract (PyObject
*self
, PyObject
*other
)
876 return valpy_binop (VALPY_SUB
, self
, other
);
880 valpy_multiply (PyObject
*self
, PyObject
*other
)
882 return valpy_binop (VALPY_MUL
, self
, other
);
886 valpy_divide (PyObject
*self
, PyObject
*other
)
888 return valpy_binop (VALPY_DIV
, self
, other
);
892 valpy_remainder (PyObject
*self
, PyObject
*other
)
894 return valpy_binop (VALPY_REM
, self
, other
);
898 valpy_power (PyObject
*self
, PyObject
*other
, PyObject
*unused
)
900 /* We don't support the ternary form of pow. I don't know how to express
901 that, so let's just throw NotImplementedError to at least do something
903 if (unused
!= Py_None
)
905 PyErr_SetString (PyExc_NotImplementedError
,
906 "Invalid operation on gdb.Value.");
910 return valpy_binop (VALPY_POW
, self
, other
);
914 valpy_negative (PyObject
*self
)
916 volatile struct gdb_exception except
;
917 PyObject
*result
= NULL
;
919 TRY_CATCH (except
, RETURN_MASK_ALL
)
921 /* Perhaps overkill, but consistency has some virtue. */
922 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
925 val
= value_neg (((value_object
*) self
)->value
);
926 result
= value_to_value_object (val
);
927 do_cleanups (cleanup
);
929 GDB_PY_HANDLE_EXCEPTION (except
);
935 valpy_positive (PyObject
*self
)
937 return value_to_value_object (((value_object
*) self
)->value
);
941 valpy_absolute (PyObject
*self
)
943 struct value
*value
= ((value_object
*) self
)->value
;
944 volatile struct gdb_exception except
;
947 TRY_CATCH (except
, RETURN_MASK_ALL
)
949 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
951 if (value_less (value
, value_zero (value_type (value
), not_lval
)))
954 do_cleanups (cleanup
);
956 GDB_PY_HANDLE_EXCEPTION (except
);
959 return valpy_positive (self
);
961 return valpy_negative (self
);
964 /* Implements boolean evaluation of gdb.Value. */
966 valpy_nonzero (PyObject
*self
)
968 volatile struct gdb_exception except
;
969 value_object
*self_value
= (value_object
*) self
;
971 int nonzero
= 0; /* Appease GCC warning. */
973 TRY_CATCH (except
, RETURN_MASK_ALL
)
975 type
= check_typedef (value_type (self_value
->value
));
977 if (is_integral_type (type
) || TYPE_CODE (type
) == TYPE_CODE_PTR
)
978 nonzero
= !!value_as_long (self_value
->value
);
979 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
980 nonzero
= value_as_double (self_value
->value
) != 0;
981 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
982 nonzero
= !decimal_is_zero (value_contents (self_value
->value
),
984 gdbarch_byte_order (get_type_arch (type
)));
986 /* All other values are True. */
989 /* This is not documented in the Python documentation, but if this
990 function fails, return -1 as slot_nb_nonzero does (the default
991 Python nonzero function). */
992 GDB_PY_SET_HANDLE_EXCEPTION (except
);
997 /* Implements ~ for value objects. */
999 valpy_invert (PyObject
*self
)
1001 struct value
*val
= NULL
;
1002 volatile struct gdb_exception except
;
1004 TRY_CATCH (except
, RETURN_MASK_ALL
)
1006 val
= value_complement (((value_object
*) self
)->value
);
1008 GDB_PY_HANDLE_EXCEPTION (except
);
1010 return value_to_value_object (val
);
1013 /* Implements left shift for value objects. */
1015 valpy_lsh (PyObject
*self
, PyObject
*other
)
1017 return valpy_binop (VALPY_LSH
, self
, other
);
1020 /* Implements right shift for value objects. */
1022 valpy_rsh (PyObject
*self
, PyObject
*other
)
1024 return valpy_binop (VALPY_RSH
, self
, other
);
1027 /* Implements bitwise and for value objects. */
1029 valpy_and (PyObject
*self
, PyObject
*other
)
1031 return valpy_binop (VALPY_BITAND
, self
, other
);
1034 /* Implements bitwise or for value objects. */
1036 valpy_or (PyObject
*self
, PyObject
*other
)
1038 return valpy_binop (VALPY_BITOR
, self
, other
);
1041 /* Implements bitwise xor for value objects. */
1043 valpy_xor (PyObject
*self
, PyObject
*other
)
1045 return valpy_binop (VALPY_BITXOR
, self
, other
);
1048 /* Implements comparison operations for value objects. Returns NULL on error,
1049 with a python exception set. */
1051 valpy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1054 volatile struct gdb_exception except
;
1056 if (other
== Py_None
)
1057 /* Comparing with None is special. From what I can tell, in Python
1058 None is smaller than anything else. */
1070 PyErr_SetString (PyExc_NotImplementedError
,
1071 _("Invalid operation on gdb.Value."));
1075 TRY_CATCH (except
, RETURN_MASK_ALL
)
1077 struct value
*value_other
, *mark
= value_mark ();
1078 struct cleanup
*cleanup
;
1080 value_other
= convert_value_from_python (other
);
1081 if (value_other
== NULL
)
1087 cleanup
= make_cleanup_value_free_to_mark (mark
);
1091 result
= value_less (((value_object
*) self
)->value
, value_other
);
1094 result
= value_less (((value_object
*) self
)->value
, value_other
)
1095 || value_equal (((value_object
*) self
)->value
, value_other
);
1098 result
= value_equal (((value_object
*) self
)->value
, value_other
);
1101 result
= !value_equal (((value_object
*) self
)->value
, value_other
);
1104 result
= value_less (value_other
, ((value_object
*) self
)->value
);
1107 result
= value_less (value_other
, ((value_object
*) self
)->value
)
1108 || value_equal (((value_object
*) self
)->value
, value_other
);
1112 PyErr_SetString (PyExc_NotImplementedError
,
1113 _("Invalid operation on gdb.Value."));
1118 do_cleanups (cleanup
);
1120 GDB_PY_HANDLE_EXCEPTION (except
);
1122 /* In this case, the Python exception has already been set. */
1133 /* Implements conversion to int. */
1135 valpy_int (PyObject
*self
)
1137 struct value
*value
= ((value_object
*) self
)->value
;
1138 struct type
*type
= value_type (value
);
1140 volatile struct gdb_exception except
;
1142 TRY_CATCH (except
, RETURN_MASK_ALL
)
1144 if (!is_integral_type (type
))
1145 error (_("Cannot convert value to int."));
1147 l
= value_as_long (value
);
1149 GDB_PY_HANDLE_EXCEPTION (except
);
1151 return gdb_py_object_from_longest (l
);
1155 /* Implements conversion to long. */
1157 valpy_long (PyObject
*self
)
1159 struct value
*value
= ((value_object
*) self
)->value
;
1160 struct type
*type
= value_type (value
);
1162 volatile struct gdb_exception except
;
1164 TRY_CATCH (except
, RETURN_MASK_ALL
)
1166 CHECK_TYPEDEF (type
);
1168 if (!is_integral_type (type
)
1169 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1170 error (_("Cannot convert value to long."));
1172 l
= value_as_long (value
);
1174 GDB_PY_HANDLE_EXCEPTION (except
);
1176 return gdb_py_long_from_longest (l
);
1179 /* Implements conversion to float. */
1181 valpy_float (PyObject
*self
)
1183 struct value
*value
= ((value_object
*) self
)->value
;
1184 struct type
*type
= value_type (value
);
1186 volatile struct gdb_exception except
;
1188 TRY_CATCH (except
, RETURN_MASK_ALL
)
1190 CHECK_TYPEDEF (type
);
1192 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
1193 error (_("Cannot convert value to float."));
1195 d
= value_as_double (value
);
1197 GDB_PY_HANDLE_EXCEPTION (except
);
1199 return PyFloat_FromDouble (d
);
1202 /* Returns an object for a value which is released from the all_values chain,
1203 so its lifetime is not bound to the execution of a command. */
1205 value_to_value_object (struct value
*val
)
1207 value_object
*val_obj
;
1209 val_obj
= PyObject_New (value_object
, &value_object_type
);
1210 if (val_obj
!= NULL
)
1212 val_obj
->value
= val
;
1213 release_value_or_incref (val
);
1214 val_obj
->address
= NULL
;
1215 val_obj
->type
= NULL
;
1216 val_obj
->dynamic_type
= NULL
;
1217 note_value (val_obj
);
1220 return (PyObject
*) val_obj
;
1223 /* Returns a borrowed reference to the struct value corresponding to
1224 the given value object. */
1226 value_object_to_value (PyObject
*self
)
1230 if (! PyObject_TypeCheck (self
, &value_object_type
))
1232 real
= (value_object
*) self
;
1236 /* Try to convert a Python value to a gdb value. If the value cannot
1237 be converted, set a Python exception and return NULL. Returns a
1238 reference to a new value on the all_values chain. */
1241 convert_value_from_python (PyObject
*obj
)
1243 struct value
*value
= NULL
; /* -Wall */
1244 volatile struct gdb_exception except
;
1247 gdb_assert (obj
!= NULL
);
1249 TRY_CATCH (except
, RETURN_MASK_ALL
)
1251 if (PyBool_Check (obj
))
1253 cmp
= PyObject_IsTrue (obj
);
1255 value
= value_from_longest (builtin_type_pybool
, cmp
);
1257 /* Make a long logic check first. In Python 3.x, internally,
1258 all integers are represented as longs. In Python 2.x, there
1259 is still a differentiation internally between a PyInt and a
1260 PyLong. Explicitly do this long check conversion first. In
1261 GDB, for Python 3.x, we #ifdef PyInt = PyLong. This check has
1262 to be done first to ensure we do not lose information in the
1263 conversion process. */
1264 else if (PyLong_Check (obj
))
1266 LONGEST l
= PyLong_AsLongLong (obj
);
1268 if (PyErr_Occurred ())
1270 /* If the error was an overflow, we can try converting to
1271 ULONGEST instead. */
1272 if (PyErr_ExceptionMatches (PyExc_OverflowError
))
1274 PyObject
*etype
, *evalue
, *etraceback
, *zero
;
1276 PyErr_Fetch (&etype
, &evalue
, &etraceback
);
1277 zero
= PyInt_FromLong (0);
1279 /* Check whether obj is positive. */
1280 if (PyObject_RichCompareBool (obj
, zero
, Py_GT
) > 0)
1284 ul
= PyLong_AsUnsignedLongLong (obj
);
1285 if (! PyErr_Occurred ())
1286 value
= value_from_ulongest (builtin_type_upylong
, ul
);
1289 /* There's nothing we can do. */
1290 PyErr_Restore (etype
, evalue
, etraceback
);
1296 value
= value_from_longest (builtin_type_pylong
, l
);
1298 else if (PyInt_Check (obj
))
1300 long l
= PyInt_AsLong (obj
);
1302 if (! PyErr_Occurred ())
1303 value
= value_from_longest (builtin_type_pyint
, l
);
1305 else if (PyFloat_Check (obj
))
1307 double d
= PyFloat_AsDouble (obj
);
1309 if (! PyErr_Occurred ())
1310 value
= value_from_double (builtin_type_pyfloat
, d
);
1312 else if (gdbpy_is_string (obj
))
1316 s
= python_string_to_target_string (obj
);
1319 struct cleanup
*old
;
1321 old
= make_cleanup (xfree
, s
);
1322 value
= value_cstring (s
, strlen (s
), builtin_type_pychar
);
1326 else if (PyObject_TypeCheck (obj
, &value_object_type
))
1327 value
= value_copy (((value_object
*) obj
)->value
);
1328 else if (gdbpy_is_lazy_string (obj
))
1332 result
= PyObject_CallMethodObjArgs (obj
, gdbpy_value_cst
, NULL
);
1333 value
= value_copy (((value_object
*) result
)->value
);
1337 PyErr_Format (PyExc_TypeError
,
1338 _("Could not convert Python object: %S."), obj
);
1340 PyErr_Format (PyExc_TypeError
,
1341 _("Could not convert Python object: %s."),
1342 PyString_AsString (PyObject_Str (obj
)));
1345 if (except
.reason
< 0)
1347 PyErr_Format (except
.reason
== RETURN_QUIT
1348 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
1349 "%s", except
.message
);
1356 /* Returns value object in the ARGth position in GDB's history. */
1358 gdbpy_history (PyObject
*self
, PyObject
*args
)
1361 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
1362 volatile struct gdb_exception except
;
1364 if (!PyArg_ParseTuple (args
, "i", &i
))
1367 TRY_CATCH (except
, RETURN_MASK_ALL
)
1369 res_val
= access_value_history (i
);
1371 GDB_PY_HANDLE_EXCEPTION (except
);
1373 return value_to_value_object (res_val
);
1376 /* Returns 1 in OBJ is a gdb.Value object, 0 otherwise. */
1379 gdbpy_is_value_object (PyObject
*obj
)
1381 return PyObject_TypeCheck (obj
, &value_object_type
);
1385 gdbpy_initialize_values (void)
1387 if (PyType_Ready (&value_object_type
) < 0)
1390 return gdb_pymodule_addobject (gdb_module
, "Value",
1391 (PyObject
*) &value_object_type
);
1396 static PyGetSetDef value_object_getset
[] = {
1397 { "address", valpy_get_address
, NULL
, "The address of the value.",
1399 { "is_optimized_out", valpy_get_is_optimized_out
, NULL
,
1400 "Boolean telling whether the value is optimized "
1401 "out (i.e., not available).",
1403 { "type", valpy_get_type
, NULL
, "Type of the value.", NULL
},
1404 { "dynamic_type", valpy_get_dynamic_type
, NULL
,
1405 "Dynamic type of the value.", NULL
},
1406 { "is_lazy", valpy_get_is_lazy
, NULL
,
1407 "Boolean telling whether the value is lazy (not fetched yet\n\
1408 from the inferior). A lazy value is fetched when needed, or when\n\
1409 the \"fetch_lazy()\" method is called.", NULL
},
1410 {NULL
} /* Sentinel */
1413 static PyMethodDef value_object_methods
[] = {
1414 { "cast", valpy_cast
, METH_VARARGS
, "Cast the value to the supplied type." },
1415 { "dynamic_cast", valpy_dynamic_cast
, METH_VARARGS
,
1416 "dynamic_cast (gdb.Type) -> gdb.Value\n\
1417 Cast the value to the supplied type, as if by the C++ dynamic_cast operator."
1419 { "reinterpret_cast", valpy_reinterpret_cast
, METH_VARARGS
,
1420 "reinterpret_cast (gdb.Type) -> gdb.Value\n\
1421 Cast the value to the supplied type, as if by the C++\n\
1422 reinterpret_cast operator."
1424 { "dereference", valpy_dereference
, METH_NOARGS
, "Dereferences the value." },
1425 { "referenced_value", valpy_referenced_value
, METH_NOARGS
,
1426 "Return the value referenced by a TYPE_CODE_REF or TYPE_CODE_PTR value." },
1427 { "lazy_string", (PyCFunction
) valpy_lazy_string
,
1428 METH_VARARGS
| METH_KEYWORDS
,
1429 "lazy_string ([encoding] [, length]) -> lazy_string\n\
1430 Return a lazy string representation of the value." },
1431 { "string", (PyCFunction
) valpy_string
, METH_VARARGS
| METH_KEYWORDS
,
1432 "string ([encoding] [, errors] [, length]) -> string\n\
1433 Return Unicode string representation of the value." },
1434 { "fetch_lazy", valpy_fetch_lazy
, METH_NOARGS
,
1435 "Fetches the value from the inferior, if it was lazy." },
1436 {NULL
} /* Sentinel */
1439 static PyNumberMethods value_object_as_number
= {
1447 NULL
, /* nb_divmod */
1448 valpy_power
, /* nb_power */
1449 valpy_negative
, /* nb_negative */
1450 valpy_positive
, /* nb_positive */
1451 valpy_absolute
, /* nb_absolute */
1452 valpy_nonzero
, /* nb_nonzero */
1453 valpy_invert
, /* nb_invert */
1454 valpy_lsh
, /* nb_lshift */
1455 valpy_rsh
, /* nb_rshift */
1456 valpy_and
, /* nb_and */
1457 valpy_xor
, /* nb_xor */
1458 valpy_or
, /* nb_or */
1460 valpy_long
, /* nb_int */
1461 NULL
, /* reserved */
1463 NULL
, /* nb_coerce */
1464 valpy_int
, /* nb_int */
1465 valpy_long
, /* nb_long */
1467 valpy_float
, /* nb_float */
1472 NULL
, /* nb_inplace_add */
1473 NULL
, /* nb_inplace_subtract */
1474 NULL
, /* nb_inplace_multiply */
1475 NULL
, /* nb_inplace_remainder */
1476 NULL
, /* nb_inplace_power */
1477 NULL
, /* nb_inplace_lshift */
1478 NULL
, /* nb_inplace_rshift */
1479 NULL
, /* nb_inplace_and */
1480 NULL
, /* nb_inplace_xor */
1481 NULL
, /* nb_inplace_or */
1482 NULL
, /* nb_floor_divide */
1483 valpy_divide
/* nb_true_divide */
1486 static PyMappingMethods value_object_as_mapping
= {
1492 PyTypeObject value_object_type
= {
1493 PyVarObject_HEAD_INIT (NULL
, 0)
1494 "gdb.Value", /*tp_name*/
1495 sizeof (value_object
), /*tp_basicsize*/
1497 valpy_dealloc
, /*tp_dealloc*/
1503 &value_object_as_number
, /*tp_as_number*/
1504 0, /*tp_as_sequence*/
1505 &value_object_as_mapping
, /*tp_as_mapping*/
1506 valpy_hash
, /*tp_hash*/
1507 valpy_call
, /*tp_call*/
1508 valpy_str
, /*tp_str*/
1512 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
1513 | Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1514 "GDB value object", /* tp_doc */
1515 0, /* tp_traverse */
1517 valpy_richcompare
, /* tp_richcompare */
1518 0, /* tp_weaklistoffset */
1520 0, /* tp_iternext */
1521 value_object_methods
, /* tp_methods */
1523 value_object_getset
, /* tp_getset */
1526 0, /* tp_descr_get */
1527 0, /* tp_descr_set */
1528 0, /* tp_dictoffset */
1531 valpy_new
/* tp_new */
1537 preserve_python_values (struct objfile
*objfile
, htab_t copied_types
)
1542 #endif /* HAVE_PYTHON */