1 /* Python interface to values.
3 Copyright (C) 2008-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "gdb_assert.h"
24 #include "exceptions.h"
29 #include "expression.h"
33 #include "python-internal.h"
35 /* Even though Python scalar types directly map to host types, we use
36 target types here to remain consistent with the values system in
37 GDB (which uses target arithmetic). */
39 /* Python's integer type corresponds to C's long type. */
40 #define builtin_type_pyint builtin_type (python_gdbarch)->builtin_long
42 /* Python's float type corresponds to C's double type. */
43 #define builtin_type_pyfloat builtin_type (python_gdbarch)->builtin_double
45 /* Python's long type corresponds to C's long long type. */
46 #define builtin_type_pylong builtin_type (python_gdbarch)->builtin_long_long
48 /* Python's long type corresponds to C's long long type. Unsigned version. */
49 #define builtin_type_upylong builtin_type \
50 (python_gdbarch)->builtin_unsigned_long_long
52 #define builtin_type_pybool \
53 language_bool_type (python_language, python_gdbarch)
55 #define builtin_type_pychar \
56 language_string_char_type (python_language, python_gdbarch)
58 typedef struct value_object
{
60 struct value_object
*next
;
61 struct value_object
*prev
;
65 PyObject
*dynamic_type
;
68 /* List of all values which are currently exposed to Python. It is
69 maintained so that when an objfile is discarded, preserve_values
70 can copy the values' types if needed. */
71 /* This variable is unnecessarily initialized to NULL in order to
72 work around a linker bug on MacOS. */
73 static value_object
*values_in_python
= NULL
;
75 /* Called by the Python interpreter when deallocating a value object. */
77 valpy_dealloc (PyObject
*obj
)
79 value_object
*self
= (value_object
*) obj
;
81 /* Remove SELF from the global list. */
83 self
->prev
->next
= self
->next
;
86 gdb_assert (values_in_python
== self
);
87 values_in_python
= self
->next
;
90 self
->next
->prev
= self
->prev
;
92 value_free (self
->value
);
95 /* Use braces to appease gcc warning. *sigh* */
97 Py_DECREF (self
->address
);
102 Py_DECREF (self
->type
);
105 Py_XDECREF (self
->dynamic_type
);
107 Py_TYPE (self
)->tp_free (self
);
110 /* Helper to push a Value object on the global list. */
112 note_value (value_object
*value_obj
)
114 value_obj
->next
= values_in_python
;
116 value_obj
->next
->prev
= value_obj
;
117 value_obj
->prev
= NULL
;
118 values_in_python
= value_obj
;
121 /* Called when a new gdb.Value object needs to be allocated. Returns NULL on
122 error, with a python exception set. */
124 valpy_new (PyTypeObject
*subtype
, PyObject
*args
, PyObject
*keywords
)
126 struct value
*value
= NULL
; /* Initialize to appease gcc warning. */
127 value_object
*value_obj
;
129 if (PyTuple_Size (args
) != 1)
131 PyErr_SetString (PyExc_TypeError
, _("Value object creation takes only "
136 value_obj
= (value_object
*) subtype
->tp_alloc (subtype
, 1);
137 if (value_obj
== NULL
)
139 PyErr_SetString (PyExc_MemoryError
, _("Could not allocate memory to "
140 "create Value object."));
144 value
= convert_value_from_python (PyTuple_GetItem (args
, 0));
147 subtype
->tp_free (value_obj
);
151 value_obj
->value
= value
;
152 release_value_or_incref (value
);
153 value_obj
->address
= NULL
;
154 value_obj
->type
= NULL
;
155 value_obj
->dynamic_type
= NULL
;
156 note_value (value_obj
);
158 return (PyObject
*) value_obj
;
161 /* Iterate over all the Value objects, calling preserve_one_value on
164 gdbpy_preserve_values (const struct extension_language_defn
*extlang
,
165 struct objfile
*objfile
, htab_t copied_types
)
169 for (iter
= values_in_python
; iter
; iter
= iter
->next
)
170 preserve_one_value (iter
->value
, objfile
, copied_types
);
173 /* Given a value of a pointer type, apply the C unary * operator to it. */
175 valpy_dereference (PyObject
*self
, PyObject
*args
)
177 volatile struct gdb_exception except
;
178 PyObject
*result
= NULL
;
180 TRY_CATCH (except
, RETURN_MASK_ALL
)
182 struct value
*res_val
;
183 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
185 res_val
= value_ind (((value_object
*) self
)->value
);
186 result
= value_to_value_object (res_val
);
187 do_cleanups (cleanup
);
189 GDB_PY_HANDLE_EXCEPTION (except
);
194 /* Given a value of a pointer type or a reference type, return the value
195 referenced. The difference between this function and valpy_dereference is
196 that the latter applies * unary operator to a value, which need not always
197 result in the value referenced. For example, for a value which is a reference
198 to an 'int' pointer ('int *'), valpy_dereference will result in a value of
199 type 'int' while valpy_referenced_value will result in a value of type
203 valpy_referenced_value (PyObject
*self
, PyObject
*args
)
205 volatile struct gdb_exception except
;
206 PyObject
*result
= NULL
;
208 TRY_CATCH (except
, RETURN_MASK_ALL
)
210 struct value
*self_val
, *res_val
;
211 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
213 self_val
= ((value_object
*) self
)->value
;
214 switch (TYPE_CODE (check_typedef (value_type (self_val
))))
217 res_val
= value_ind (self_val
);
220 res_val
= coerce_ref (self_val
);
223 error(_("Trying to get the referenced value from a value which is "
224 "neither a pointer nor a reference."));
227 result
= value_to_value_object (res_val
);
228 do_cleanups (cleanup
);
230 GDB_PY_HANDLE_EXCEPTION (except
);
235 /* Return "&value". */
237 valpy_get_address (PyObject
*self
, void *closure
)
239 value_object
*val_obj
= (value_object
*) self
;
240 volatile struct gdb_exception except
;
242 if (!val_obj
->address
)
244 TRY_CATCH (except
, RETURN_MASK_ALL
)
246 struct value
*res_val
;
247 struct cleanup
*cleanup
248 = make_cleanup_value_free_to_mark (value_mark ());
250 res_val
= value_addr (val_obj
->value
);
251 val_obj
->address
= value_to_value_object (res_val
);
252 do_cleanups (cleanup
);
254 if (except
.reason
< 0)
256 val_obj
->address
= Py_None
;
261 Py_XINCREF (val_obj
->address
);
263 return val_obj
->address
;
266 /* Return type of the value. */
268 valpy_get_type (PyObject
*self
, void *closure
)
270 value_object
*obj
= (value_object
*) self
;
274 obj
->type
= type_to_type_object (value_type (obj
->value
));
278 Py_INCREF (obj
->type
);
282 /* Return dynamic type of the value. */
285 valpy_get_dynamic_type (PyObject
*self
, void *closure
)
287 value_object
*obj
= (value_object
*) self
;
288 volatile struct gdb_exception except
;
289 struct type
*type
= NULL
;
291 if (obj
->dynamic_type
!= NULL
)
293 Py_INCREF (obj
->dynamic_type
);
294 return obj
->dynamic_type
;
297 TRY_CATCH (except
, RETURN_MASK_ALL
)
299 struct value
*val
= obj
->value
;
300 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
302 type
= value_type (val
);
303 CHECK_TYPEDEF (type
);
305 if (((TYPE_CODE (type
) == TYPE_CODE_PTR
)
306 || (TYPE_CODE (type
) == TYPE_CODE_REF
))
307 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
309 struct value
*target
;
310 int was_pointer
= TYPE_CODE (type
) == TYPE_CODE_PTR
;
313 target
= value_ind (val
);
315 target
= coerce_ref (val
);
316 type
= value_rtti_type (target
, NULL
, NULL
, NULL
);
321 type
= lookup_pointer_type (type
);
323 type
= lookup_reference_type (type
);
326 else if (TYPE_CODE (type
) == TYPE_CODE_CLASS
)
327 type
= value_rtti_type (val
, NULL
, NULL
, NULL
);
330 /* Re-use object's static type. */
334 do_cleanups (cleanup
);
336 GDB_PY_HANDLE_EXCEPTION (except
);
339 obj
->dynamic_type
= valpy_get_type (self
, NULL
);
341 obj
->dynamic_type
= type_to_type_object (type
);
343 Py_XINCREF (obj
->dynamic_type
);
344 return obj
->dynamic_type
;
347 /* Implementation of gdb.Value.lazy_string ([encoding] [, length]) ->
348 string. Return a PyObject representing a lazy_string_object type.
349 A lazy string is a pointer to a string with an optional encoding and
350 length. If ENCODING is not given, encoding is set to None. If an
351 ENCODING is provided the encoding parameter is set to ENCODING, but
352 the string is not encoded. If LENGTH is provided then the length
353 parameter is set to LENGTH, otherwise length will be set to -1 (first
354 null of appropriate with). */
356 valpy_lazy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
358 gdb_py_longest length
= -1;
359 struct value
*value
= ((value_object
*) self
)->value
;
360 const char *user_encoding
= NULL
;
361 static char *keywords
[] = { "encoding", "length", NULL
};
362 PyObject
*str_obj
= NULL
;
363 volatile struct gdb_exception except
;
365 if (!PyArg_ParseTupleAndKeywords (args
, kw
, "|s" GDB_PY_LL_ARG
, keywords
,
366 &user_encoding
, &length
))
369 TRY_CATCH (except
, RETURN_MASK_ALL
)
371 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
373 if (TYPE_CODE (value_type (value
)) == TYPE_CODE_PTR
)
374 value
= value_ind (value
);
376 str_obj
= gdbpy_create_lazy_string_object (value_address (value
), length
,
380 do_cleanups (cleanup
);
382 GDB_PY_HANDLE_EXCEPTION (except
);
387 /* Implementation of gdb.Value.string ([encoding] [, errors]
388 [, length]) -> string. Return Unicode string with value contents.
389 If ENCODING is not given, the string is assumed to be encoded in
390 the target's charset. If LENGTH is provided, only fetch string to
391 the length provided. */
394 valpy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
398 struct value
*value
= ((value_object
*) self
)->value
;
399 volatile struct gdb_exception except
;
401 const char *encoding
= NULL
;
402 const char *errors
= NULL
;
403 const char *user_encoding
= NULL
;
404 const char *la_encoding
= NULL
;
405 struct type
*char_type
;
406 static char *keywords
[] = { "encoding", "errors", "length", NULL
};
408 if (!PyArg_ParseTupleAndKeywords (args
, kw
, "|ssi", keywords
,
409 &user_encoding
, &errors
, &length
))
412 TRY_CATCH (except
, RETURN_MASK_ALL
)
414 LA_GET_STRING (value
, &buffer
, &length
, &char_type
, &la_encoding
);
416 GDB_PY_HANDLE_EXCEPTION (except
);
418 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: la_encoding
;
419 unicode
= PyUnicode_Decode ((const char *) buffer
,
420 length
* TYPE_LENGTH (char_type
),
427 /* A helper function that implements the various cast operators. */
430 valpy_do_cast (PyObject
*self
, PyObject
*args
, enum exp_opcode op
)
432 PyObject
*type_obj
, *result
= NULL
;
434 volatile struct gdb_exception except
;
436 if (! PyArg_ParseTuple (args
, "O", &type_obj
))
439 type
= type_object_to_type (type_obj
);
442 PyErr_SetString (PyExc_RuntimeError
,
443 _("Argument must be a type."));
447 TRY_CATCH (except
, RETURN_MASK_ALL
)
449 struct value
*val
= ((value_object
*) self
)->value
;
450 struct value
*res_val
;
451 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
453 if (op
== UNOP_DYNAMIC_CAST
)
454 res_val
= value_dynamic_cast (type
, val
);
455 else if (op
== UNOP_REINTERPRET_CAST
)
456 res_val
= value_reinterpret_cast (type
, val
);
459 gdb_assert (op
== UNOP_CAST
);
460 res_val
= value_cast (type
, val
);
463 result
= value_to_value_object (res_val
);
464 do_cleanups (cleanup
);
466 GDB_PY_HANDLE_EXCEPTION (except
);
471 /* Implementation of the "cast" method. */
474 valpy_cast (PyObject
*self
, PyObject
*args
)
476 return valpy_do_cast (self
, args
, UNOP_CAST
);
479 /* Implementation of the "dynamic_cast" method. */
482 valpy_dynamic_cast (PyObject
*self
, PyObject
*args
)
484 return valpy_do_cast (self
, args
, UNOP_DYNAMIC_CAST
);
487 /* Implementation of the "reinterpret_cast" method. */
490 valpy_reinterpret_cast (PyObject
*self
, PyObject
*args
)
492 return valpy_do_cast (self
, args
, UNOP_REINTERPRET_CAST
);
496 valpy_length (PyObject
*self
)
498 /* We don't support getting the number of elements in a struct / class. */
499 PyErr_SetString (PyExc_NotImplementedError
,
500 _("Invalid operation on gdb.Value."));
504 /* Return 1 if the gdb.Field object FIELD is present in the value V.
505 Returns 0 otherwise. If any Python error occurs, -1 is returned. */
508 value_has_field (struct value
*v
, PyObject
*field
)
510 struct type
*parent_type
, *val_type
;
511 enum type_code type_code
;
512 PyObject
*type_object
= PyObject_GetAttrString (field
, "parent_type");
513 volatile struct gdb_exception except
;
516 if (type_object
== NULL
)
519 parent_type
= type_object_to_type (type_object
);
520 Py_DECREF (type_object
);
521 if (parent_type
== NULL
)
523 PyErr_SetString (PyExc_TypeError
,
524 _("'parent_type' attribute of gdb.Field object is not a"
525 "gdb.Type object."));
529 TRY_CATCH (except
, RETURN_MASK_ALL
)
531 val_type
= value_type (v
);
532 val_type
= check_typedef (val_type
);
533 if (TYPE_CODE (val_type
) == TYPE_CODE_REF
534 || TYPE_CODE (val_type
) == TYPE_CODE_PTR
)
535 val_type
= check_typedef (TYPE_TARGET_TYPE (val_type
));
537 type_code
= TYPE_CODE (val_type
);
538 if ((type_code
== TYPE_CODE_STRUCT
|| type_code
== TYPE_CODE_UNION
)
539 && types_equal (val_type
, parent_type
))
544 GDB_PY_SET_HANDLE_EXCEPTION (except
);
549 /* Return the value of a flag FLAG_NAME in a gdb.Field object FIELD.
550 Returns 1 if the flag value is true, 0 if it is false, and -1 if
551 a Python error occurs. */
554 get_field_flag (PyObject
*field
, const char *flag_name
)
557 PyObject
*flag_object
= PyObject_GetAttrString (field
, flag_name
);
559 if (flag_object
== NULL
)
562 flag_value
= PyObject_IsTrue (flag_object
);
563 Py_DECREF (flag_object
);
568 /* Return the "type" attribute of a gdb.Field object.
569 Returns NULL on error, with a Python exception set. */
572 get_field_type (PyObject
*field
)
574 PyObject
*ftype_obj
= PyObject_GetAttrString (field
, "type");
577 if (ftype_obj
== NULL
)
579 ftype
= type_object_to_type (ftype_obj
);
580 Py_DECREF (ftype_obj
);
582 PyErr_SetString (PyExc_TypeError
,
583 _("'type' attribute of gdb.Field object is not a "
584 "gdb.Type object."));
589 /* Given string name or a gdb.Field object corresponding to an element inside
590 a structure, return its value object. Returns NULL on error, with a python
594 valpy_getitem (PyObject
*self
, PyObject
*key
)
596 value_object
*self_value
= (value_object
*) self
;
598 struct type
*base_class_type
= NULL
, *field_type
= NULL
;
600 volatile struct gdb_exception except
;
601 PyObject
*result
= NULL
;
603 if (gdbpy_is_string (key
))
605 field
= python_string_to_host_string (key
);
609 else if (gdbpy_is_field (key
))
611 int is_base_class
, valid_field
;
613 valid_field
= value_has_field (self_value
->value
, key
);
616 else if (valid_field
== 0)
618 PyErr_SetString (PyExc_TypeError
,
619 _("Invalid lookup for a field not contained in "
625 is_base_class
= get_field_flag (key
, "is_base_class");
626 if (is_base_class
< 0)
628 else if (is_base_class
> 0)
630 base_class_type
= get_field_type (key
);
631 if (base_class_type
== NULL
)
636 PyObject
*name_obj
= PyObject_GetAttrString (key
, "name");
638 if (name_obj
== NULL
)
641 if (name_obj
!= Py_None
)
643 field
= python_string_to_host_string (name_obj
);
644 Py_DECREF (name_obj
);
650 PyObject
*bitpos_obj
;
653 Py_DECREF (name_obj
);
655 if (!PyObject_HasAttrString (key
, "bitpos"))
657 PyErr_SetString (PyExc_AttributeError
,
658 _("gdb.Field object has no name and no "
659 "'bitpos' attribute."));
663 bitpos_obj
= PyObject_GetAttrString (key
, "bitpos");
664 if (bitpos_obj
== NULL
)
666 valid
= gdb_py_int_as_long (bitpos_obj
, &bitpos
);
667 Py_DECREF (bitpos_obj
);
671 field_type
= get_field_type (key
);
672 if (field_type
== NULL
)
678 TRY_CATCH (except
, RETURN_MASK_ALL
)
680 struct value
*tmp
= self_value
->value
;
681 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
682 struct value
*res_val
= NULL
;
685 res_val
= value_struct_elt (&tmp
, NULL
, field
, 0, NULL
);
686 else if (bitpos
>= 0)
687 res_val
= value_struct_elt_bitpos (&tmp
, bitpos
, field_type
,
688 "struct/class/union");
689 else if (base_class_type
!= NULL
)
691 struct type
*val_type
;
693 val_type
= check_typedef (value_type (tmp
));
694 if (TYPE_CODE (val_type
) == TYPE_CODE_PTR
)
695 res_val
= value_cast (lookup_pointer_type (base_class_type
), tmp
);
696 else if (TYPE_CODE (val_type
) == TYPE_CODE_REF
)
697 res_val
= value_cast (lookup_reference_type (base_class_type
), tmp
);
699 res_val
= value_cast (base_class_type
, tmp
);
703 /* Assume we are attempting an array access, and let the
704 value code throw an exception if the index has an invalid
706 struct value
*idx
= convert_value_from_python (key
);
710 /* Check the value's type is something that can be accessed via
714 tmp
= coerce_ref (tmp
);
715 type
= check_typedef (value_type (tmp
));
716 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
717 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
718 error (_("Cannot subscript requested type."));
720 res_val
= value_subscript (tmp
, value_as_long (idx
));
725 result
= value_to_value_object (res_val
);
726 do_cleanups (cleanup
);
730 GDB_PY_HANDLE_EXCEPTION (except
);
736 valpy_setitem (PyObject
*self
, PyObject
*key
, PyObject
*value
)
738 PyErr_Format (PyExc_NotImplementedError
,
739 _("Setting of struct elements is not currently supported."));
743 /* Called by the Python interpreter to perform an inferior function
744 call on the value. Returns NULL on error, with a python exception set. */
746 valpy_call (PyObject
*self
, PyObject
*args
, PyObject
*keywords
)
748 Py_ssize_t args_count
;
749 volatile struct gdb_exception except
;
750 struct value
*function
= ((value_object
*) self
)->value
;
751 struct value
**vargs
= NULL
;
752 struct type
*ftype
= NULL
;
753 struct value
*mark
= value_mark ();
754 PyObject
*result
= NULL
;
756 TRY_CATCH (except
, RETURN_MASK_ALL
)
758 ftype
= check_typedef (value_type (function
));
760 GDB_PY_HANDLE_EXCEPTION (except
);
762 if (TYPE_CODE (ftype
) != TYPE_CODE_FUNC
)
764 PyErr_SetString (PyExc_RuntimeError
,
765 _("Value is not callable (not TYPE_CODE_FUNC)."));
769 if (! PyTuple_Check (args
))
771 PyErr_SetString (PyExc_TypeError
,
772 _("Inferior arguments must be provided in a tuple."));
776 args_count
= PyTuple_Size (args
);
781 vargs
= alloca (sizeof (struct value
*) * args_count
);
782 for (i
= 0; i
< args_count
; i
++)
784 PyObject
*item
= PyTuple_GetItem (args
, i
);
789 vargs
[i
] = convert_value_from_python (item
);
790 if (vargs
[i
] == NULL
)
795 TRY_CATCH (except
, RETURN_MASK_ALL
)
797 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (mark
);
798 struct value
*return_value
;
800 return_value
= call_function_by_hand (function
, args_count
, vargs
);
801 result
= value_to_value_object (return_value
);
802 do_cleanups (cleanup
);
804 GDB_PY_HANDLE_EXCEPTION (except
);
809 /* Called by the Python interpreter to obtain string representation
812 valpy_str (PyObject
*self
)
816 struct value_print_options opts
;
817 volatile struct gdb_exception except
;
819 get_user_print_options (&opts
);
822 TRY_CATCH (except
, RETURN_MASK_ALL
)
824 struct ui_file
*stb
= mem_fileopen ();
825 struct cleanup
*old_chain
= make_cleanup_ui_file_delete (stb
);
827 common_val_print (((value_object
*) self
)->value
, stb
, 0,
828 &opts
, python_language
);
829 s
= ui_file_xstrdup (stb
, NULL
);
831 do_cleanups (old_chain
);
833 GDB_PY_HANDLE_EXCEPTION (except
);
835 result
= PyUnicode_Decode (s
, strlen (s
), host_charset (), NULL
);
841 /* Implements gdb.Value.is_optimized_out. */
843 valpy_get_is_optimized_out (PyObject
*self
, void *closure
)
845 struct value
*value
= ((value_object
*) self
)->value
;
847 volatile struct gdb_exception except
;
849 TRY_CATCH (except
, RETURN_MASK_ALL
)
851 opt
= value_optimized_out (value
);
853 GDB_PY_HANDLE_EXCEPTION (except
);
861 /* Implements gdb.Value.is_lazy. */
863 valpy_get_is_lazy (PyObject
*self
, void *closure
)
865 struct value
*value
= ((value_object
*) self
)->value
;
867 volatile struct gdb_exception except
;
869 TRY_CATCH (except
, RETURN_MASK_ALL
)
871 opt
= value_lazy (value
);
873 GDB_PY_HANDLE_EXCEPTION (except
);
881 /* Implements gdb.Value.fetch_lazy (). */
883 valpy_fetch_lazy (PyObject
*self
, PyObject
*args
)
885 struct value
*value
= ((value_object
*) self
)->value
;
886 volatile struct gdb_exception except
;
888 TRY_CATCH (except
, RETURN_MASK_ALL
)
890 if (value_lazy (value
))
891 value_fetch_lazy (value
);
893 GDB_PY_HANDLE_EXCEPTION (except
);
898 /* Calculate and return the address of the PyObject as the value of
899 the builtin __hash__ call. */
901 valpy_hash (PyObject
*self
)
903 return (long) (intptr_t) self
;
921 /* If TYPE is a reference, return the target; otherwise return TYPE. */
922 #define STRIP_REFERENCE(TYPE) \
923 ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
925 /* Returns a value object which is the result of applying the operation
926 specified by OPCODE to the given arguments. Returns NULL on error, with
927 a python exception set. */
929 valpy_binop (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
931 volatile struct gdb_exception except
;
932 PyObject
*result
= NULL
;
934 TRY_CATCH (except
, RETURN_MASK_ALL
)
936 struct value
*arg1
, *arg2
;
937 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
938 struct value
*res_val
= NULL
;
939 enum exp_opcode op
= OP_NULL
;
942 /* If the gdb.Value object is the second operand, then it will be passed
943 to us as the OTHER argument, and SELF will be an entirely different
944 kind of object, altogether. Because of this, we can't assume self is
945 a gdb.Value object and need to convert it from python as well. */
946 arg1
= convert_value_from_python (self
);
949 do_cleanups (cleanup
);
953 arg2
= convert_value_from_python (other
);
956 do_cleanups (cleanup
);
964 struct type
*ltype
= value_type (arg1
);
965 struct type
*rtype
= value_type (arg2
);
967 CHECK_TYPEDEF (ltype
);
968 ltype
= STRIP_REFERENCE (ltype
);
969 CHECK_TYPEDEF (rtype
);
970 rtype
= STRIP_REFERENCE (rtype
);
973 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
974 && is_integral_type (rtype
))
975 res_val
= value_ptradd (arg1
, value_as_long (arg2
));
976 else if (TYPE_CODE (rtype
) == TYPE_CODE_PTR
977 && is_integral_type (ltype
))
978 res_val
= value_ptradd (arg2
, value_as_long (arg1
));
988 struct type
*ltype
= value_type (arg1
);
989 struct type
*rtype
= value_type (arg2
);
991 CHECK_TYPEDEF (ltype
);
992 ltype
= STRIP_REFERENCE (ltype
);
993 CHECK_TYPEDEF (rtype
);
994 rtype
= STRIP_REFERENCE (rtype
);
997 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
998 && TYPE_CODE (rtype
) == TYPE_CODE_PTR
)
999 /* A ptrdiff_t for the target would be preferable here. */
1000 res_val
= value_from_longest (builtin_type_pyint
,
1001 value_ptrdiff (arg1
, arg2
));
1002 else if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
1003 && is_integral_type (rtype
))
1004 res_val
= value_ptradd (arg1
, - value_as_long (arg2
));
1031 op
= BINOP_BITWISE_AND
;
1034 op
= BINOP_BITWISE_IOR
;
1037 op
= BINOP_BITWISE_XOR
;
1043 if (binop_user_defined_p (op
, arg1
, arg2
))
1044 res_val
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, EVAL_NORMAL
);
1046 res_val
= value_binop (arg1
, arg2
, op
);
1050 result
= value_to_value_object (res_val
);
1052 do_cleanups (cleanup
);
1054 GDB_PY_HANDLE_EXCEPTION (except
);
1060 valpy_add (PyObject
*self
, PyObject
*other
)
1062 return valpy_binop (VALPY_ADD
, self
, other
);
1066 valpy_subtract (PyObject
*self
, PyObject
*other
)
1068 return valpy_binop (VALPY_SUB
, self
, other
);
1072 valpy_multiply (PyObject
*self
, PyObject
*other
)
1074 return valpy_binop (VALPY_MUL
, self
, other
);
1078 valpy_divide (PyObject
*self
, PyObject
*other
)
1080 return valpy_binop (VALPY_DIV
, self
, other
);
1084 valpy_remainder (PyObject
*self
, PyObject
*other
)
1086 return valpy_binop (VALPY_REM
, self
, other
);
1090 valpy_power (PyObject
*self
, PyObject
*other
, PyObject
*unused
)
1092 /* We don't support the ternary form of pow. I don't know how to express
1093 that, so let's just throw NotImplementedError to at least do something
1095 if (unused
!= Py_None
)
1097 PyErr_SetString (PyExc_NotImplementedError
,
1098 "Invalid operation on gdb.Value.");
1102 return valpy_binop (VALPY_POW
, self
, other
);
1106 valpy_negative (PyObject
*self
)
1108 volatile struct gdb_exception except
;
1109 PyObject
*result
= NULL
;
1111 TRY_CATCH (except
, RETURN_MASK_ALL
)
1113 /* Perhaps overkill, but consistency has some virtue. */
1114 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
1117 val
= value_neg (((value_object
*) self
)->value
);
1118 result
= value_to_value_object (val
);
1119 do_cleanups (cleanup
);
1121 GDB_PY_HANDLE_EXCEPTION (except
);
1127 valpy_positive (PyObject
*self
)
1129 return value_to_value_object (((value_object
*) self
)->value
);
1133 valpy_absolute (PyObject
*self
)
1135 struct value
*value
= ((value_object
*) self
)->value
;
1136 volatile struct gdb_exception except
;
1139 TRY_CATCH (except
, RETURN_MASK_ALL
)
1141 struct cleanup
*cleanup
= make_cleanup_value_free_to_mark (value_mark ());
1143 if (value_less (value
, value_zero (value_type (value
), not_lval
)))
1146 do_cleanups (cleanup
);
1148 GDB_PY_HANDLE_EXCEPTION (except
);
1151 return valpy_positive (self
);
1153 return valpy_negative (self
);
1156 /* Implements boolean evaluation of gdb.Value. */
1158 valpy_nonzero (PyObject
*self
)
1160 volatile struct gdb_exception except
;
1161 value_object
*self_value
= (value_object
*) self
;
1163 int nonzero
= 0; /* Appease GCC warning. */
1165 TRY_CATCH (except
, RETURN_MASK_ALL
)
1167 type
= check_typedef (value_type (self_value
->value
));
1169 if (is_integral_type (type
) || TYPE_CODE (type
) == TYPE_CODE_PTR
)
1170 nonzero
= !!value_as_long (self_value
->value
);
1171 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1172 nonzero
= value_as_double (self_value
->value
) != 0;
1173 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1174 nonzero
= !decimal_is_zero (value_contents (self_value
->value
),
1176 gdbarch_byte_order (get_type_arch (type
)));
1178 /* All other values are True. */
1181 /* This is not documented in the Python documentation, but if this
1182 function fails, return -1 as slot_nb_nonzero does (the default
1183 Python nonzero function). */
1184 GDB_PY_SET_HANDLE_EXCEPTION (except
);
1189 /* Implements ~ for value objects. */
1191 valpy_invert (PyObject
*self
)
1193 struct value
*val
= NULL
;
1194 volatile struct gdb_exception except
;
1196 TRY_CATCH (except
, RETURN_MASK_ALL
)
1198 val
= value_complement (((value_object
*) self
)->value
);
1200 GDB_PY_HANDLE_EXCEPTION (except
);
1202 return value_to_value_object (val
);
1205 /* Implements left shift for value objects. */
1207 valpy_lsh (PyObject
*self
, PyObject
*other
)
1209 return valpy_binop (VALPY_LSH
, self
, other
);
1212 /* Implements right shift for value objects. */
1214 valpy_rsh (PyObject
*self
, PyObject
*other
)
1216 return valpy_binop (VALPY_RSH
, self
, other
);
1219 /* Implements bitwise and for value objects. */
1221 valpy_and (PyObject
*self
, PyObject
*other
)
1223 return valpy_binop (VALPY_BITAND
, self
, other
);
1226 /* Implements bitwise or for value objects. */
1228 valpy_or (PyObject
*self
, PyObject
*other
)
1230 return valpy_binop (VALPY_BITOR
, self
, other
);
1233 /* Implements bitwise xor for value objects. */
1235 valpy_xor (PyObject
*self
, PyObject
*other
)
1237 return valpy_binop (VALPY_BITXOR
, self
, other
);
1240 /* Implements comparison operations for value objects. Returns NULL on error,
1241 with a python exception set. */
1243 valpy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1246 volatile struct gdb_exception except
;
1248 if (other
== Py_None
)
1249 /* Comparing with None is special. From what I can tell, in Python
1250 None is smaller than anything else. */
1262 PyErr_SetString (PyExc_NotImplementedError
,
1263 _("Invalid operation on gdb.Value."));
1267 TRY_CATCH (except
, RETURN_MASK_ALL
)
1269 struct value
*value_other
, *mark
= value_mark ();
1270 struct cleanup
*cleanup
;
1272 value_other
= convert_value_from_python (other
);
1273 if (value_other
== NULL
)
1279 cleanup
= make_cleanup_value_free_to_mark (mark
);
1283 result
= value_less (((value_object
*) self
)->value
, value_other
);
1286 result
= value_less (((value_object
*) self
)->value
, value_other
)
1287 || value_equal (((value_object
*) self
)->value
, value_other
);
1290 result
= value_equal (((value_object
*) self
)->value
, value_other
);
1293 result
= !value_equal (((value_object
*) self
)->value
, value_other
);
1296 result
= value_less (value_other
, ((value_object
*) self
)->value
);
1299 result
= value_less (value_other
, ((value_object
*) self
)->value
)
1300 || value_equal (((value_object
*) self
)->value
, value_other
);
1304 PyErr_SetString (PyExc_NotImplementedError
,
1305 _("Invalid operation on gdb.Value."));
1310 do_cleanups (cleanup
);
1312 GDB_PY_HANDLE_EXCEPTION (except
);
1314 /* In this case, the Python exception has already been set. */
1325 /* Implements conversion to int. */
1327 valpy_int (PyObject
*self
)
1329 struct value
*value
= ((value_object
*) self
)->value
;
1330 struct type
*type
= value_type (value
);
1332 volatile struct gdb_exception except
;
1334 TRY_CATCH (except
, RETURN_MASK_ALL
)
1336 if (!is_integral_type (type
))
1337 error (_("Cannot convert value to int."));
1339 l
= value_as_long (value
);
1341 GDB_PY_HANDLE_EXCEPTION (except
);
1343 return gdb_py_object_from_longest (l
);
1347 /* Implements conversion to long. */
1349 valpy_long (PyObject
*self
)
1351 struct value
*value
= ((value_object
*) self
)->value
;
1352 struct type
*type
= value_type (value
);
1354 volatile struct gdb_exception except
;
1356 TRY_CATCH (except
, RETURN_MASK_ALL
)
1358 CHECK_TYPEDEF (type
);
1360 if (!is_integral_type (type
)
1361 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1362 error (_("Cannot convert value to long."));
1364 l
= value_as_long (value
);
1366 GDB_PY_HANDLE_EXCEPTION (except
);
1368 return gdb_py_long_from_longest (l
);
1371 /* Implements conversion to float. */
1373 valpy_float (PyObject
*self
)
1375 struct value
*value
= ((value_object
*) self
)->value
;
1376 struct type
*type
= value_type (value
);
1378 volatile struct gdb_exception except
;
1380 TRY_CATCH (except
, RETURN_MASK_ALL
)
1382 CHECK_TYPEDEF (type
);
1384 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
1385 error (_("Cannot convert value to float."));
1387 d
= value_as_double (value
);
1389 GDB_PY_HANDLE_EXCEPTION (except
);
1391 return PyFloat_FromDouble (d
);
1394 /* Returns an object for a value which is released from the all_values chain,
1395 so its lifetime is not bound to the execution of a command. */
1397 value_to_value_object (struct value
*val
)
1399 value_object
*val_obj
;
1401 val_obj
= PyObject_New (value_object
, &value_object_type
);
1402 if (val_obj
!= NULL
)
1404 val_obj
->value
= val
;
1405 release_value_or_incref (val
);
1406 val_obj
->address
= NULL
;
1407 val_obj
->type
= NULL
;
1408 val_obj
->dynamic_type
= NULL
;
1409 note_value (val_obj
);
1412 return (PyObject
*) val_obj
;
1415 /* Returns a borrowed reference to the struct value corresponding to
1416 the given value object. */
1418 value_object_to_value (PyObject
*self
)
1422 if (! PyObject_TypeCheck (self
, &value_object_type
))
1424 real
= (value_object
*) self
;
1428 /* Try to convert a Python value to a gdb value. If the value cannot
1429 be converted, set a Python exception and return NULL. Returns a
1430 reference to a new value on the all_values chain. */
1433 convert_value_from_python (PyObject
*obj
)
1435 struct value
*value
= NULL
; /* -Wall */
1436 volatile struct gdb_exception except
;
1439 gdb_assert (obj
!= NULL
);
1441 TRY_CATCH (except
, RETURN_MASK_ALL
)
1443 if (PyBool_Check (obj
))
1445 cmp
= PyObject_IsTrue (obj
);
1447 value
= value_from_longest (builtin_type_pybool
, cmp
);
1449 /* Make a long logic check first. In Python 3.x, internally,
1450 all integers are represented as longs. In Python 2.x, there
1451 is still a differentiation internally between a PyInt and a
1452 PyLong. Explicitly do this long check conversion first. In
1453 GDB, for Python 3.x, we #ifdef PyInt = PyLong. This check has
1454 to be done first to ensure we do not lose information in the
1455 conversion process. */
1456 else if (PyLong_Check (obj
))
1458 LONGEST l
= PyLong_AsLongLong (obj
);
1460 if (PyErr_Occurred ())
1462 /* If the error was an overflow, we can try converting to
1463 ULONGEST instead. */
1464 if (PyErr_ExceptionMatches (PyExc_OverflowError
))
1466 PyObject
*etype
, *evalue
, *etraceback
, *zero
;
1468 PyErr_Fetch (&etype
, &evalue
, &etraceback
);
1469 zero
= PyInt_FromLong (0);
1471 /* Check whether obj is positive. */
1472 if (PyObject_RichCompareBool (obj
, zero
, Py_GT
) > 0)
1476 ul
= PyLong_AsUnsignedLongLong (obj
);
1477 if (! PyErr_Occurred ())
1478 value
= value_from_ulongest (builtin_type_upylong
, ul
);
1481 /* There's nothing we can do. */
1482 PyErr_Restore (etype
, evalue
, etraceback
);
1488 value
= value_from_longest (builtin_type_pylong
, l
);
1490 else if (PyInt_Check (obj
))
1492 long l
= PyInt_AsLong (obj
);
1494 if (! PyErr_Occurred ())
1495 value
= value_from_longest (builtin_type_pyint
, l
);
1497 else if (PyFloat_Check (obj
))
1499 double d
= PyFloat_AsDouble (obj
);
1501 if (! PyErr_Occurred ())
1502 value
= value_from_double (builtin_type_pyfloat
, d
);
1504 else if (gdbpy_is_string (obj
))
1508 s
= python_string_to_target_string (obj
);
1511 struct cleanup
*old
;
1513 old
= make_cleanup (xfree
, s
);
1514 value
= value_cstring (s
, strlen (s
), builtin_type_pychar
);
1518 else if (PyObject_TypeCheck (obj
, &value_object_type
))
1519 value
= value_copy (((value_object
*) obj
)->value
);
1520 else if (gdbpy_is_lazy_string (obj
))
1524 result
= PyObject_CallMethodObjArgs (obj
, gdbpy_value_cst
, NULL
);
1525 value
= value_copy (((value_object
*) result
)->value
);
1529 PyErr_Format (PyExc_TypeError
,
1530 _("Could not convert Python object: %S."), obj
);
1532 PyErr_Format (PyExc_TypeError
,
1533 _("Could not convert Python object: %s."),
1534 PyString_AsString (PyObject_Str (obj
)));
1537 if (except
.reason
< 0)
1539 PyErr_Format (except
.reason
== RETURN_QUIT
1540 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
1541 "%s", except
.message
);
1548 /* Returns value object in the ARGth position in GDB's history. */
1550 gdbpy_history (PyObject
*self
, PyObject
*args
)
1553 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
1554 volatile struct gdb_exception except
;
1556 if (!PyArg_ParseTuple (args
, "i", &i
))
1559 TRY_CATCH (except
, RETURN_MASK_ALL
)
1561 res_val
= access_value_history (i
);
1563 GDB_PY_HANDLE_EXCEPTION (except
);
1565 return value_to_value_object (res_val
);
1568 /* Returns 1 in OBJ is a gdb.Value object, 0 otherwise. */
1571 gdbpy_is_value_object (PyObject
*obj
)
1573 return PyObject_TypeCheck (obj
, &value_object_type
);
1577 gdbpy_initialize_values (void)
1579 if (PyType_Ready (&value_object_type
) < 0)
1582 return gdb_pymodule_addobject (gdb_module
, "Value",
1583 (PyObject
*) &value_object_type
);
1588 static PyGetSetDef value_object_getset
[] = {
1589 { "address", valpy_get_address
, NULL
, "The address of the value.",
1591 { "is_optimized_out", valpy_get_is_optimized_out
, NULL
,
1592 "Boolean telling whether the value is optimized "
1593 "out (i.e., not available).",
1595 { "type", valpy_get_type
, NULL
, "Type of the value.", NULL
},
1596 { "dynamic_type", valpy_get_dynamic_type
, NULL
,
1597 "Dynamic type of the value.", NULL
},
1598 { "is_lazy", valpy_get_is_lazy
, NULL
,
1599 "Boolean telling whether the value is lazy (not fetched yet\n\
1600 from the inferior). A lazy value is fetched when needed, or when\n\
1601 the \"fetch_lazy()\" method is called.", NULL
},
1602 {NULL
} /* Sentinel */
1605 static PyMethodDef value_object_methods
[] = {
1606 { "cast", valpy_cast
, METH_VARARGS
, "Cast the value to the supplied type." },
1607 { "dynamic_cast", valpy_dynamic_cast
, METH_VARARGS
,
1608 "dynamic_cast (gdb.Type) -> gdb.Value\n\
1609 Cast the value to the supplied type, as if by the C++ dynamic_cast operator."
1611 { "reinterpret_cast", valpy_reinterpret_cast
, METH_VARARGS
,
1612 "reinterpret_cast (gdb.Type) -> gdb.Value\n\
1613 Cast the value to the supplied type, as if by the C++\n\
1614 reinterpret_cast operator."
1616 { "dereference", valpy_dereference
, METH_NOARGS
, "Dereferences the value." },
1617 { "referenced_value", valpy_referenced_value
, METH_NOARGS
,
1618 "Return the value referenced by a TYPE_CODE_REF or TYPE_CODE_PTR value." },
1619 { "lazy_string", (PyCFunction
) valpy_lazy_string
,
1620 METH_VARARGS
| METH_KEYWORDS
,
1621 "lazy_string ([encoding] [, length]) -> lazy_string\n\
1622 Return a lazy string representation of the value." },
1623 { "string", (PyCFunction
) valpy_string
, METH_VARARGS
| METH_KEYWORDS
,
1624 "string ([encoding] [, errors] [, length]) -> string\n\
1625 Return Unicode string representation of the value." },
1626 { "fetch_lazy", valpy_fetch_lazy
, METH_NOARGS
,
1627 "Fetches the value from the inferior, if it was lazy." },
1628 {NULL
} /* Sentinel */
1631 static PyNumberMethods value_object_as_number
= {
1639 NULL
, /* nb_divmod */
1640 valpy_power
, /* nb_power */
1641 valpy_negative
, /* nb_negative */
1642 valpy_positive
, /* nb_positive */
1643 valpy_absolute
, /* nb_absolute */
1644 valpy_nonzero
, /* nb_nonzero */
1645 valpy_invert
, /* nb_invert */
1646 valpy_lsh
, /* nb_lshift */
1647 valpy_rsh
, /* nb_rshift */
1648 valpy_and
, /* nb_and */
1649 valpy_xor
, /* nb_xor */
1650 valpy_or
, /* nb_or */
1652 valpy_long
, /* nb_int */
1653 NULL
, /* reserved */
1655 NULL
, /* nb_coerce */
1656 valpy_int
, /* nb_int */
1657 valpy_long
, /* nb_long */
1659 valpy_float
, /* nb_float */
1664 NULL
, /* nb_inplace_add */
1665 NULL
, /* nb_inplace_subtract */
1666 NULL
, /* nb_inplace_multiply */
1667 NULL
, /* nb_inplace_remainder */
1668 NULL
, /* nb_inplace_power */
1669 NULL
, /* nb_inplace_lshift */
1670 NULL
, /* nb_inplace_rshift */
1671 NULL
, /* nb_inplace_and */
1672 NULL
, /* nb_inplace_xor */
1673 NULL
, /* nb_inplace_or */
1674 NULL
, /* nb_floor_divide */
1675 valpy_divide
/* nb_true_divide */
1678 static PyMappingMethods value_object_as_mapping
= {
1684 PyTypeObject value_object_type
= {
1685 PyVarObject_HEAD_INIT (NULL
, 0)
1686 "gdb.Value", /*tp_name*/
1687 sizeof (value_object
), /*tp_basicsize*/
1689 valpy_dealloc
, /*tp_dealloc*/
1695 &value_object_as_number
, /*tp_as_number*/
1696 0, /*tp_as_sequence*/
1697 &value_object_as_mapping
, /*tp_as_mapping*/
1698 valpy_hash
, /*tp_hash*/
1699 valpy_call
, /*tp_call*/
1700 valpy_str
, /*tp_str*/
1704 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
1705 | Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1706 "GDB value object", /* tp_doc */
1707 0, /* tp_traverse */
1709 valpy_richcompare
, /* tp_richcompare */
1710 0, /* tp_weaklistoffset */
1712 0, /* tp_iternext */
1713 value_object_methods
, /* tp_methods */
1715 value_object_getset
, /* tp_getset */
1718 0, /* tp_descr_get */
1719 0, /* tp_descr_set */
1720 0, /* tp_dictoffset */
1723 valpy_new
/* tp_new */