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"
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 /* Return 1 if the gdb.Field object FIELD is present in the value V.
503 Returns 0 otherwise. If any Python error occurs, -1 is returned. */
506 value_has_field (struct value
*v
, PyObject
*field
)
508 struct type
*parent_type
, *val_type
;
509 enum type_code type_code
;
510 PyObject
*type_object
= PyObject_GetAttrString (field
, "parent_type");
511 volatile struct gdb_exception except
;
514 if (type_object
== NULL
)
517 parent_type
= type_object_to_type (type_object
);
518 Py_DECREF (type_object
);
519 if (parent_type
== NULL
)
521 PyErr_SetString (PyExc_TypeError
,
522 _("'parent_type' attribute of gdb.Field object is not a"
523 "gdb.Type object."));
527 TRY_CATCH (except
, RETURN_MASK_ALL
)
529 val_type
= value_type (v
);
530 val_type
= check_typedef (val_type
);
531 if (TYPE_CODE (val_type
) == TYPE_CODE_REF
532 || TYPE_CODE (val_type
) == TYPE_CODE_PTR
)
533 val_type
= check_typedef (TYPE_TARGET_TYPE (val_type
));
535 type_code
= TYPE_CODE (val_type
);
536 if ((type_code
== TYPE_CODE_STRUCT
|| type_code
== TYPE_CODE_UNION
)
537 && types_equal (val_type
, parent_type
))
542 GDB_PY_SET_HANDLE_EXCEPTION (except
);
547 /* Return the value of a flag FLAG_NAME in a gdb.Field object FIELD.
548 Returns 1 if the flag value is true, 0 if it is false, and -1 if
549 a Python error occurs. */
552 get_field_flag (PyObject
*field
, const char *flag_name
)
555 PyObject
*flag_object
= PyObject_GetAttrString (field
, flag_name
);
557 if (flag_object
== NULL
)
560 flag_value
= PyObject_IsTrue (flag_object
);
561 Py_DECREF (flag_object
);
566 /* Return the "type" attribute of a gdb.Field object.
567 Returns NULL on error, with a Python exception set. */
570 get_field_type (PyObject
*field
)
572 PyObject
*ftype_obj
= PyObject_GetAttrString (field
, "type");
575 if (ftype_obj
== NULL
)
577 ftype
= type_object_to_type (ftype_obj
);
578 Py_DECREF (ftype_obj
);
580 PyErr_SetString (PyExc_TypeError
,
581 _("'type' attribute of gdb.Field object is not a "
582 "gdb.Type object."));
587 /* Given string name or a gdb.Field object corresponding to an element inside
588 a structure, return its value object. Returns NULL on error, with a python
592 valpy_getitem (PyObject
*self
, PyObject
*key
)
594 value_object
*self_value
= (value_object
*) self
;
596 struct type
*base_class_type
= NULL
, *field_type
= NULL
;
598 volatile struct gdb_exception except
;
599 PyObject
*result
= NULL
;
601 if (gdbpy_is_string (key
))
603 field
= python_string_to_host_string (key
);
607 else if (gdbpy_is_field (key
))
609 int is_base_class
, valid_field
;
611 valid_field
= value_has_field (self_value
->value
, key
);
614 else if (valid_field
== 0)
616 PyErr_SetString (PyExc_TypeError
,
617 _("Invalid lookup for a field not contained in "
623 is_base_class
= get_field_flag (key
, "is_base_class");
624 if (is_base_class
< 0)
626 else if (is_base_class
> 0)
628 base_class_type
= get_field_type (key
);
629 if (base_class_type
== NULL
)
634 PyObject
*name_obj
= PyObject_GetAttrString (key
, "name");
636 if (name_obj
== NULL
)
639 if (name_obj
!= Py_None
)
641 field
= python_string_to_host_string (name_obj
);
642 Py_DECREF (name_obj
);
648 PyObject
*bitpos_obj
;
651 Py_DECREF (name_obj
);
653 if (!PyObject_HasAttrString (key
, "bitpos"))
655 PyErr_SetString (PyExc_AttributeError
,
656 _("gdb.Field object has no name and no "
657 "'bitpos' attribute."));
661 bitpos_obj
= PyObject_GetAttrString (key
, "bitpos");
662 if (bitpos_obj
== NULL
)
664 valid
= gdb_py_int_as_long (bitpos_obj
, &bitpos
);
665 Py_DECREF (bitpos_obj
);
669 field_type
= get_field_type (key
);
670 if (field_type
== NULL
)
676 TRY_CATCH (except
, RETURN_MASK_ALL
)
678 struct value
*tmp
= self_value
->value
;
679 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
680 struct value
*res_val
= NULL
;
683 res_val
= value_struct_elt (&tmp
, NULL
, field
, 0, NULL
);
684 else if (bitpos
>= 0)
685 res_val
= value_struct_elt_bitpos (&tmp
, bitpos
, field_type
,
686 "struct/class/union");
687 else if (base_class_type
!= NULL
)
689 struct type
*val_type
;
691 val_type
= check_typedef (value_type (tmp
));
692 if (TYPE_CODE (val_type
) == TYPE_CODE_PTR
)
693 res_val
= value_cast (lookup_pointer_type (base_class_type
), tmp
);
694 else if (TYPE_CODE (val_type
) == TYPE_CODE_REF
)
695 res_val
= value_cast (lookup_reference_type (base_class_type
), tmp
);
697 res_val
= value_cast (base_class_type
, tmp
);
701 /* Assume we are attempting an array access, and let the
702 value code throw an exception if the index has an invalid
704 struct value
*idx
= convert_value_from_python (key
);
708 /* Check the value's type is something that can be accessed via
712 tmp
= coerce_ref (tmp
);
713 type
= check_typedef (value_type (tmp
));
714 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
715 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
716 error (_("Cannot subscript requested type."));
718 res_val
= value_subscript (tmp
, value_as_long (idx
));
723 result
= value_to_value_object (res_val
);
724 do_cleanups (cleanup
);
728 GDB_PY_HANDLE_EXCEPTION (except
);
734 valpy_setitem (PyObject
*self
, PyObject
*key
, PyObject
*value
)
736 PyErr_Format (PyExc_NotImplementedError
,
737 _("Setting of struct elements is not currently supported."));
741 /* Called by the Python interpreter to perform an inferior function
742 call on the value. Returns NULL on error, with a python exception set. */
744 valpy_call (PyObject
*self
, PyObject
*args
, PyObject
*keywords
)
746 Py_ssize_t args_count
;
747 volatile struct gdb_exception except
;
748 struct value
*function
= ((value_object
*) self
)->value
;
749 struct value
**vargs
= NULL
;
750 struct type
*ftype
= NULL
;
751 struct value
*mark
= value_mark ();
752 PyObject
*result
= NULL
;
754 TRY_CATCH (except
, RETURN_MASK_ALL
)
756 ftype
= check_typedef (value_type (function
));
758 GDB_PY_HANDLE_EXCEPTION (except
);
760 if (TYPE_CODE (ftype
) != TYPE_CODE_FUNC
)
762 PyErr_SetString (PyExc_RuntimeError
,
763 _("Value is not callable (not TYPE_CODE_FUNC)."));
767 if (! PyTuple_Check (args
))
769 PyErr_SetString (PyExc_TypeError
,
770 _("Inferior arguments must be provided in a tuple."));
774 args_count
= PyTuple_Size (args
);
779 vargs
= alloca (sizeof (struct value
*) * args_count
);
780 for (i
= 0; i
< args_count
; i
++)
782 PyObject
*item
= PyTuple_GetItem (args
, i
);
787 vargs
[i
] = convert_value_from_python (item
);
788 if (vargs
[i
] == NULL
)
793 TRY_CATCH (except
, RETURN_MASK_ALL
)
795 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (mark
);
796 struct value
*return_value
;
798 return_value
= call_function_by_hand (function
, args_count
, vargs
);
799 result
= value_to_value_object (return_value
);
800 do_cleanups (cleanup
);
802 GDB_PY_HANDLE_EXCEPTION (except
);
807 /* Called by the Python interpreter to obtain string representation
810 valpy_str (PyObject
*self
)
814 struct value_print_options opts
;
815 volatile struct gdb_exception except
;
817 get_user_print_options (&opts
);
820 TRY_CATCH (except
, RETURN_MASK_ALL
)
822 struct ui_file
*stb
= mem_fileopen ();
823 struct cleanup
*old_chain
= make_cleanup_ui_file_delete (stb
);
825 common_val_print (((value_object
*) self
)->value
, stb
, 0,
826 &opts
, python_language
);
827 s
= ui_file_xstrdup (stb
, NULL
);
829 do_cleanups (old_chain
);
831 GDB_PY_HANDLE_EXCEPTION (except
);
833 result
= PyUnicode_Decode (s
, strlen (s
), host_charset (), NULL
);
839 /* Implements gdb.Value.is_optimized_out. */
841 valpy_get_is_optimized_out (PyObject
*self
, void *closure
)
843 struct value
*value
= ((value_object
*) self
)->value
;
845 volatile struct gdb_exception except
;
847 TRY_CATCH (except
, RETURN_MASK_ALL
)
849 opt
= value_optimized_out (value
);
851 GDB_PY_HANDLE_EXCEPTION (except
);
859 /* Implements gdb.Value.is_lazy. */
861 valpy_get_is_lazy (PyObject
*self
, void *closure
)
863 struct value
*value
= ((value_object
*) self
)->value
;
865 volatile struct gdb_exception except
;
867 TRY_CATCH (except
, RETURN_MASK_ALL
)
869 opt
= value_lazy (value
);
871 GDB_PY_HANDLE_EXCEPTION (except
);
879 /* Implements gdb.Value.fetch_lazy (). */
881 valpy_fetch_lazy (PyObject
*self
, PyObject
*args
)
883 struct value
*value
= ((value_object
*) self
)->value
;
884 volatile struct gdb_exception except
;
886 TRY_CATCH (except
, RETURN_MASK_ALL
)
888 if (value_lazy (value
))
889 value_fetch_lazy (value
);
891 GDB_PY_HANDLE_EXCEPTION (except
);
896 /* Calculate and return the address of the PyObject as the value of
897 the builtin __hash__ call. */
899 valpy_hash (PyObject
*self
)
901 return (long) (intptr_t) self
;
919 /* If TYPE is a reference, return the target; otherwise return TYPE. */
920 #define STRIP_REFERENCE(TYPE) \
921 ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
923 /* Returns a value object which is the result of applying the operation
924 specified by OPCODE to the given arguments. Returns NULL on error, with
925 a python exception set. */
927 valpy_binop (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
929 volatile struct gdb_exception except
;
930 PyObject
*result
= NULL
;
932 TRY_CATCH (except
, RETURN_MASK_ALL
)
934 struct value
*arg1
, *arg2
;
935 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
936 struct value
*res_val
= NULL
;
938 /* If the gdb.Value object is the second operand, then it will be passed
939 to us as the OTHER argument, and SELF will be an entirely different
940 kind of object, altogether. Because of this, we can't assume self is
941 a gdb.Value object and need to convert it from python as well. */
942 arg1
= convert_value_from_python (self
);
945 do_cleanups (cleanup
);
949 arg2
= convert_value_from_python (other
);
952 do_cleanups (cleanup
);
960 struct type
*ltype
= value_type (arg1
);
961 struct type
*rtype
= value_type (arg2
);
963 CHECK_TYPEDEF (ltype
);
964 ltype
= STRIP_REFERENCE (ltype
);
965 CHECK_TYPEDEF (rtype
);
966 rtype
= STRIP_REFERENCE (rtype
);
968 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
969 && is_integral_type (rtype
))
970 res_val
= value_ptradd (arg1
, value_as_long (arg2
));
971 else if (TYPE_CODE (rtype
) == TYPE_CODE_PTR
972 && is_integral_type (ltype
))
973 res_val
= value_ptradd (arg2
, value_as_long (arg1
));
975 res_val
= value_binop (arg1
, arg2
, BINOP_ADD
);
980 struct type
*ltype
= value_type (arg1
);
981 struct type
*rtype
= value_type (arg2
);
983 CHECK_TYPEDEF (ltype
);
984 ltype
= STRIP_REFERENCE (ltype
);
985 CHECK_TYPEDEF (rtype
);
986 rtype
= STRIP_REFERENCE (rtype
);
988 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
989 && TYPE_CODE (rtype
) == TYPE_CODE_PTR
)
990 /* A ptrdiff_t for the target would be preferable here. */
991 res_val
= value_from_longest (builtin_type_pyint
,
992 value_ptrdiff (arg1
, arg2
));
993 else if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
994 && is_integral_type (rtype
))
995 res_val
= value_ptradd (arg1
, - value_as_long (arg2
));
997 res_val
= value_binop (arg1
, arg2
, BINOP_SUB
);
1001 res_val
= value_binop (arg1
, arg2
, BINOP_MUL
);
1004 res_val
= value_binop (arg1
, arg2
, BINOP_DIV
);
1007 res_val
= value_binop (arg1
, arg2
, BINOP_REM
);
1010 res_val
= value_binop (arg1
, arg2
, BINOP_EXP
);
1013 res_val
= value_binop (arg1
, arg2
, BINOP_LSH
);
1016 res_val
= value_binop (arg1
, arg2
, BINOP_RSH
);
1019 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_AND
);
1022 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_IOR
);
1025 res_val
= value_binop (arg1
, arg2
, BINOP_BITWISE_XOR
);
1030 result
= value_to_value_object (res_val
);
1032 do_cleanups (cleanup
);
1034 GDB_PY_HANDLE_EXCEPTION (except
);
1040 valpy_add (PyObject
*self
, PyObject
*other
)
1042 return valpy_binop (VALPY_ADD
, self
, other
);
1046 valpy_subtract (PyObject
*self
, PyObject
*other
)
1048 return valpy_binop (VALPY_SUB
, self
, other
);
1052 valpy_multiply (PyObject
*self
, PyObject
*other
)
1054 return valpy_binop (VALPY_MUL
, self
, other
);
1058 valpy_divide (PyObject
*self
, PyObject
*other
)
1060 return valpy_binop (VALPY_DIV
, self
, other
);
1064 valpy_remainder (PyObject
*self
, PyObject
*other
)
1066 return valpy_binop (VALPY_REM
, self
, other
);
1070 valpy_power (PyObject
*self
, PyObject
*other
, PyObject
*unused
)
1072 /* We don't support the ternary form of pow. I don't know how to express
1073 that, so let's just throw NotImplementedError to at least do something
1075 if (unused
!= Py_None
)
1077 PyErr_SetString (PyExc_NotImplementedError
,
1078 "Invalid operation on gdb.Value.");
1082 return valpy_binop (VALPY_POW
, self
, other
);
1086 valpy_negative (PyObject
*self
)
1088 volatile struct gdb_exception except
;
1089 PyObject
*result
= NULL
;
1091 TRY_CATCH (except
, RETURN_MASK_ALL
)
1093 /* Perhaps overkill, but consistency has some virtue. */
1094 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
1097 val
= value_neg (((value_object
*) self
)->value
);
1098 result
= value_to_value_object (val
);
1099 do_cleanups (cleanup
);
1101 GDB_PY_HANDLE_EXCEPTION (except
);
1107 valpy_positive (PyObject
*self
)
1109 return value_to_value_object (((value_object
*) self
)->value
);
1113 valpy_absolute (PyObject
*self
)
1115 struct value
*value
= ((value_object
*) self
)->value
;
1116 volatile struct gdb_exception except
;
1119 TRY_CATCH (except
, RETURN_MASK_ALL
)
1121 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
1123 if (value_less (value
, value_zero (value_type (value
), not_lval
)))
1126 do_cleanups (cleanup
);
1128 GDB_PY_HANDLE_EXCEPTION (except
);
1131 return valpy_positive (self
);
1133 return valpy_negative (self
);
1136 /* Implements boolean evaluation of gdb.Value. */
1138 valpy_nonzero (PyObject
*self
)
1140 volatile struct gdb_exception except
;
1141 value_object
*self_value
= (value_object
*) self
;
1143 int nonzero
= 0; /* Appease GCC warning. */
1145 TRY_CATCH (except
, RETURN_MASK_ALL
)
1147 type
= check_typedef (value_type (self_value
->value
));
1149 if (is_integral_type (type
) || TYPE_CODE (type
) == TYPE_CODE_PTR
)
1150 nonzero
= !!value_as_long (self_value
->value
);
1151 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1152 nonzero
= value_as_double (self_value
->value
) != 0;
1153 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1154 nonzero
= !decimal_is_zero (value_contents (self_value
->value
),
1156 gdbarch_byte_order (get_type_arch (type
)));
1158 /* All other values are True. */
1161 /* This is not documented in the Python documentation, but if this
1162 function fails, return -1 as slot_nb_nonzero does (the default
1163 Python nonzero function). */
1164 GDB_PY_SET_HANDLE_EXCEPTION (except
);
1169 /* Implements ~ for value objects. */
1171 valpy_invert (PyObject
*self
)
1173 struct value
*val
= NULL
;
1174 volatile struct gdb_exception except
;
1176 TRY_CATCH (except
, RETURN_MASK_ALL
)
1178 val
= value_complement (((value_object
*) self
)->value
);
1180 GDB_PY_HANDLE_EXCEPTION (except
);
1182 return value_to_value_object (val
);
1185 /* Implements left shift for value objects. */
1187 valpy_lsh (PyObject
*self
, PyObject
*other
)
1189 return valpy_binop (VALPY_LSH
, self
, other
);
1192 /* Implements right shift for value objects. */
1194 valpy_rsh (PyObject
*self
, PyObject
*other
)
1196 return valpy_binop (VALPY_RSH
, self
, other
);
1199 /* Implements bitwise and for value objects. */
1201 valpy_and (PyObject
*self
, PyObject
*other
)
1203 return valpy_binop (VALPY_BITAND
, self
, other
);
1206 /* Implements bitwise or for value objects. */
1208 valpy_or (PyObject
*self
, PyObject
*other
)
1210 return valpy_binop (VALPY_BITOR
, self
, other
);
1213 /* Implements bitwise xor for value objects. */
1215 valpy_xor (PyObject
*self
, PyObject
*other
)
1217 return valpy_binop (VALPY_BITXOR
, self
, other
);
1220 /* Implements comparison operations for value objects. Returns NULL on error,
1221 with a python exception set. */
1223 valpy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1226 volatile struct gdb_exception except
;
1228 if (other
== Py_None
)
1229 /* Comparing with None is special. From what I can tell, in Python
1230 None is smaller than anything else. */
1242 PyErr_SetString (PyExc_NotImplementedError
,
1243 _("Invalid operation on gdb.Value."));
1247 TRY_CATCH (except
, RETURN_MASK_ALL
)
1249 struct value
*value_other
, *mark
= value_mark ();
1250 struct cleanup
*cleanup
;
1252 value_other
= convert_value_from_python (other
);
1253 if (value_other
== NULL
)
1259 cleanup
= make_cleanup_value_free_to_mark (mark
);
1263 result
= value_less (((value_object
*) self
)->value
, value_other
);
1266 result
= value_less (((value_object
*) self
)->value
, value_other
)
1267 || value_equal (((value_object
*) self
)->value
, value_other
);
1270 result
= value_equal (((value_object
*) self
)->value
, value_other
);
1273 result
= !value_equal (((value_object
*) self
)->value
, value_other
);
1276 result
= value_less (value_other
, ((value_object
*) self
)->value
);
1279 result
= value_less (value_other
, ((value_object
*) self
)->value
)
1280 || value_equal (((value_object
*) self
)->value
, value_other
);
1284 PyErr_SetString (PyExc_NotImplementedError
,
1285 _("Invalid operation on gdb.Value."));
1290 do_cleanups (cleanup
);
1292 GDB_PY_HANDLE_EXCEPTION (except
);
1294 /* In this case, the Python exception has already been set. */
1305 /* Implements conversion to int. */
1307 valpy_int (PyObject
*self
)
1309 struct value
*value
= ((value_object
*) self
)->value
;
1310 struct type
*type
= value_type (value
);
1312 volatile struct gdb_exception except
;
1314 TRY_CATCH (except
, RETURN_MASK_ALL
)
1316 if (!is_integral_type (type
))
1317 error (_("Cannot convert value to int."));
1319 l
= value_as_long (value
);
1321 GDB_PY_HANDLE_EXCEPTION (except
);
1323 return gdb_py_object_from_longest (l
);
1327 /* Implements conversion to long. */
1329 valpy_long (PyObject
*self
)
1331 struct value
*value
= ((value_object
*) self
)->value
;
1332 struct type
*type
= value_type (value
);
1334 volatile struct gdb_exception except
;
1336 TRY_CATCH (except
, RETURN_MASK_ALL
)
1338 CHECK_TYPEDEF (type
);
1340 if (!is_integral_type (type
)
1341 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1342 error (_("Cannot convert value to long."));
1344 l
= value_as_long (value
);
1346 GDB_PY_HANDLE_EXCEPTION (except
);
1348 return gdb_py_long_from_longest (l
);
1351 /* Implements conversion to float. */
1353 valpy_float (PyObject
*self
)
1355 struct value
*value
= ((value_object
*) self
)->value
;
1356 struct type
*type
= value_type (value
);
1358 volatile struct gdb_exception except
;
1360 TRY_CATCH (except
, RETURN_MASK_ALL
)
1362 CHECK_TYPEDEF (type
);
1364 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
1365 error (_("Cannot convert value to float."));
1367 d
= value_as_double (value
);
1369 GDB_PY_HANDLE_EXCEPTION (except
);
1371 return PyFloat_FromDouble (d
);
1374 /* Returns an object for a value which is released from the all_values chain,
1375 so its lifetime is not bound to the execution of a command. */
1377 value_to_value_object (struct value
*val
)
1379 value_object
*val_obj
;
1381 val_obj
= PyObject_New (value_object
, &value_object_type
);
1382 if (val_obj
!= NULL
)
1384 val_obj
->value
= val
;
1385 release_value_or_incref (val
);
1386 val_obj
->address
= NULL
;
1387 val_obj
->type
= NULL
;
1388 val_obj
->dynamic_type
= NULL
;
1389 note_value (val_obj
);
1392 return (PyObject
*) val_obj
;
1395 /* Returns a borrowed reference to the struct value corresponding to
1396 the given value object. */
1398 value_object_to_value (PyObject
*self
)
1402 if (! PyObject_TypeCheck (self
, &value_object_type
))
1404 real
= (value_object
*) self
;
1408 /* Try to convert a Python value to a gdb value. If the value cannot
1409 be converted, set a Python exception and return NULL. Returns a
1410 reference to a new value on the all_values chain. */
1413 convert_value_from_python (PyObject
*obj
)
1415 struct value
*value
= NULL
; /* -Wall */
1416 volatile struct gdb_exception except
;
1419 gdb_assert (obj
!= NULL
);
1421 TRY_CATCH (except
, RETURN_MASK_ALL
)
1423 if (PyBool_Check (obj
))
1425 cmp
= PyObject_IsTrue (obj
);
1427 value
= value_from_longest (builtin_type_pybool
, cmp
);
1429 /* Make a long logic check first. In Python 3.x, internally,
1430 all integers are represented as longs. In Python 2.x, there
1431 is still a differentiation internally between a PyInt and a
1432 PyLong. Explicitly do this long check conversion first. In
1433 GDB, for Python 3.x, we #ifdef PyInt = PyLong. This check has
1434 to be done first to ensure we do not lose information in the
1435 conversion process. */
1436 else if (PyLong_Check (obj
))
1438 LONGEST l
= PyLong_AsLongLong (obj
);
1440 if (PyErr_Occurred ())
1442 /* If the error was an overflow, we can try converting to
1443 ULONGEST instead. */
1444 if (PyErr_ExceptionMatches (PyExc_OverflowError
))
1446 PyObject
*etype
, *evalue
, *etraceback
, *zero
;
1448 PyErr_Fetch (&etype
, &evalue
, &etraceback
);
1449 zero
= PyInt_FromLong (0);
1451 /* Check whether obj is positive. */
1452 if (PyObject_RichCompareBool (obj
, zero
, Py_GT
) > 0)
1456 ul
= PyLong_AsUnsignedLongLong (obj
);
1457 if (! PyErr_Occurred ())
1458 value
= value_from_ulongest (builtin_type_upylong
, ul
);
1461 /* There's nothing we can do. */
1462 PyErr_Restore (etype
, evalue
, etraceback
);
1468 value
= value_from_longest (builtin_type_pylong
, l
);
1470 else if (PyInt_Check (obj
))
1472 long l
= PyInt_AsLong (obj
);
1474 if (! PyErr_Occurred ())
1475 value
= value_from_longest (builtin_type_pyint
, l
);
1477 else if (PyFloat_Check (obj
))
1479 double d
= PyFloat_AsDouble (obj
);
1481 if (! PyErr_Occurred ())
1482 value
= value_from_double (builtin_type_pyfloat
, d
);
1484 else if (gdbpy_is_string (obj
))
1488 s
= python_string_to_target_string (obj
);
1491 struct cleanup
*old
;
1493 old
= make_cleanup (xfree
, s
);
1494 value
= value_cstring (s
, strlen (s
), builtin_type_pychar
);
1498 else if (PyObject_TypeCheck (obj
, &value_object_type
))
1499 value
= value_copy (((value_object
*) obj
)->value
);
1500 else if (gdbpy_is_lazy_string (obj
))
1504 result
= PyObject_CallMethodObjArgs (obj
, gdbpy_value_cst
, NULL
);
1505 value
= value_copy (((value_object
*) result
)->value
);
1509 PyErr_Format (PyExc_TypeError
,
1510 _("Could not convert Python object: %S."), obj
);
1512 PyErr_Format (PyExc_TypeError
,
1513 _("Could not convert Python object: %s."),
1514 PyString_AsString (PyObject_Str (obj
)));
1517 if (except
.reason
< 0)
1519 PyErr_Format (except
.reason
== RETURN_QUIT
1520 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
1521 "%s", except
.message
);
1528 /* Returns value object in the ARGth position in GDB's history. */
1530 gdbpy_history (PyObject
*self
, PyObject
*args
)
1533 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
1534 volatile struct gdb_exception except
;
1536 if (!PyArg_ParseTuple (args
, "i", &i
))
1539 TRY_CATCH (except
, RETURN_MASK_ALL
)
1541 res_val
= access_value_history (i
);
1543 GDB_PY_HANDLE_EXCEPTION (except
);
1545 return value_to_value_object (res_val
);
1548 /* Returns 1 in OBJ is a gdb.Value object, 0 otherwise. */
1551 gdbpy_is_value_object (PyObject
*obj
)
1553 return PyObject_TypeCheck (obj
, &value_object_type
);
1557 gdbpy_initialize_values (void)
1559 if (PyType_Ready (&value_object_type
) < 0)
1562 return gdb_pymodule_addobject (gdb_module
, "Value",
1563 (PyObject
*) &value_object_type
);
1568 static PyGetSetDef value_object_getset
[] = {
1569 { "address", valpy_get_address
, NULL
, "The address of the value.",
1571 { "is_optimized_out", valpy_get_is_optimized_out
, NULL
,
1572 "Boolean telling whether the value is optimized "
1573 "out (i.e., not available).",
1575 { "type", valpy_get_type
, NULL
, "Type of the value.", NULL
},
1576 { "dynamic_type", valpy_get_dynamic_type
, NULL
,
1577 "Dynamic type of the value.", NULL
},
1578 { "is_lazy", valpy_get_is_lazy
, NULL
,
1579 "Boolean telling whether the value is lazy (not fetched yet\n\
1580 from the inferior). A lazy value is fetched when needed, or when\n\
1581 the \"fetch_lazy()\" method is called.", NULL
},
1582 {NULL
} /* Sentinel */
1585 static PyMethodDef value_object_methods
[] = {
1586 { "cast", valpy_cast
, METH_VARARGS
, "Cast the value to the supplied type." },
1587 { "dynamic_cast", valpy_dynamic_cast
, METH_VARARGS
,
1588 "dynamic_cast (gdb.Type) -> gdb.Value\n\
1589 Cast the value to the supplied type, as if by the C++ dynamic_cast operator."
1591 { "reinterpret_cast", valpy_reinterpret_cast
, METH_VARARGS
,
1592 "reinterpret_cast (gdb.Type) -> gdb.Value\n\
1593 Cast the value to the supplied type, as if by the C++\n\
1594 reinterpret_cast operator."
1596 { "dereference", valpy_dereference
, METH_NOARGS
, "Dereferences the value." },
1597 { "referenced_value", valpy_referenced_value
, METH_NOARGS
,
1598 "Return the value referenced by a TYPE_CODE_REF or TYPE_CODE_PTR value." },
1599 { "lazy_string", (PyCFunction
) valpy_lazy_string
,
1600 METH_VARARGS
| METH_KEYWORDS
,
1601 "lazy_string ([encoding] [, length]) -> lazy_string\n\
1602 Return a lazy string representation of the value." },
1603 { "string", (PyCFunction
) valpy_string
, METH_VARARGS
| METH_KEYWORDS
,
1604 "string ([encoding] [, errors] [, length]) -> string\n\
1605 Return Unicode string representation of the value." },
1606 { "fetch_lazy", valpy_fetch_lazy
, METH_NOARGS
,
1607 "Fetches the value from the inferior, if it was lazy." },
1608 {NULL
} /* Sentinel */
1611 static PyNumberMethods value_object_as_number
= {
1619 NULL
, /* nb_divmod */
1620 valpy_power
, /* nb_power */
1621 valpy_negative
, /* nb_negative */
1622 valpy_positive
, /* nb_positive */
1623 valpy_absolute
, /* nb_absolute */
1624 valpy_nonzero
, /* nb_nonzero */
1625 valpy_invert
, /* nb_invert */
1626 valpy_lsh
, /* nb_lshift */
1627 valpy_rsh
, /* nb_rshift */
1628 valpy_and
, /* nb_and */
1629 valpy_xor
, /* nb_xor */
1630 valpy_or
, /* nb_or */
1632 valpy_long
, /* nb_int */
1633 NULL
, /* reserved */
1635 NULL
, /* nb_coerce */
1636 valpy_int
, /* nb_int */
1637 valpy_long
, /* nb_long */
1639 valpy_float
, /* nb_float */
1644 NULL
, /* nb_inplace_add */
1645 NULL
, /* nb_inplace_subtract */
1646 NULL
, /* nb_inplace_multiply */
1647 NULL
, /* nb_inplace_remainder */
1648 NULL
, /* nb_inplace_power */
1649 NULL
, /* nb_inplace_lshift */
1650 NULL
, /* nb_inplace_rshift */
1651 NULL
, /* nb_inplace_and */
1652 NULL
, /* nb_inplace_xor */
1653 NULL
, /* nb_inplace_or */
1654 NULL
, /* nb_floor_divide */
1655 valpy_divide
/* nb_true_divide */
1658 static PyMappingMethods value_object_as_mapping
= {
1664 PyTypeObject value_object_type
= {
1665 PyVarObject_HEAD_INIT (NULL
, 0)
1666 "gdb.Value", /*tp_name*/
1667 sizeof (value_object
), /*tp_basicsize*/
1669 valpy_dealloc
, /*tp_dealloc*/
1675 &value_object_as_number
, /*tp_as_number*/
1676 0, /*tp_as_sequence*/
1677 &value_object_as_mapping
, /*tp_as_mapping*/
1678 valpy_hash
, /*tp_hash*/
1679 valpy_call
, /*tp_call*/
1680 valpy_str
, /*tp_str*/
1684 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
1685 | Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1686 "GDB value object", /* tp_doc */
1687 0, /* tp_traverse */
1689 valpy_richcompare
, /* tp_richcompare */
1690 0, /* tp_weaklistoffset */
1692 0, /* tp_iternext */
1693 value_object_methods
, /* tp_methods */
1695 value_object_getset
, /* tp_getset */
1698 0, /* tp_descr_get */
1699 0, /* tp_descr_set */
1700 0, /* tp_dictoffset */
1703 valpy_new
/* tp_new */
1709 preserve_python_values (struct objfile
*objfile
, htab_t copied_types
)
1714 #endif /* HAVE_PYTHON */