1 /* Python interface to values.
3 Copyright (C) 2008-2017 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/>. */
27 #include "expression.h"
31 #include "python-internal.h"
34 /* Even though Python scalar types directly map to host types, we use
35 target types here to remain consistent with the values system in
36 GDB (which uses target arithmetic). */
38 /* Python's integer type corresponds to C's long type. */
39 #define builtin_type_pyint builtin_type (python_gdbarch)->builtin_long
41 /* Python's float type corresponds to C's double type. */
42 #define builtin_type_pyfloat builtin_type (python_gdbarch)->builtin_double
44 /* Python's long type corresponds to C's long long type. */
45 #define builtin_type_pylong builtin_type (python_gdbarch)->builtin_long_long
47 /* Python's long type corresponds to C's long long type. Unsigned version. */
48 #define builtin_type_upylong builtin_type \
49 (python_gdbarch)->builtin_unsigned_long_long
51 #define builtin_type_pybool \
52 language_bool_type (python_language, python_gdbarch)
54 #define builtin_type_pychar \
55 language_string_char_type (python_language, python_gdbarch)
57 typedef struct value_object
{
59 struct value_object
*next
;
60 struct value_object
*prev
;
64 PyObject
*dynamic_type
;
67 /* List of all values which are currently exposed to Python. It is
68 maintained so that when an objfile is discarded, preserve_values
69 can copy the values' types if needed. */
70 /* This variable is unnecessarily initialized to NULL in order to
71 work around a linker bug on MacOS. */
72 static value_object
*values_in_python
= NULL
;
74 /* Called by the Python interpreter when deallocating a value object. */
76 valpy_dealloc (PyObject
*obj
)
78 value_object
*self
= (value_object
*) obj
;
80 /* Remove SELF from the global list. */
82 self
->prev
->next
= self
->next
;
85 gdb_assert (values_in_python
== self
);
86 values_in_python
= self
->next
;
89 self
->next
->prev
= self
->prev
;
91 value_free (self
->value
);
94 /* Use braces to appease gcc warning. *sigh* */
96 Py_DECREF (self
->address
);
101 Py_DECREF (self
->type
);
104 Py_XDECREF (self
->dynamic_type
);
106 Py_TYPE (self
)->tp_free (self
);
109 /* Helper to push a Value object on the global list. */
111 note_value (value_object
*value_obj
)
113 value_obj
->next
= values_in_python
;
115 value_obj
->next
->prev
= value_obj
;
116 value_obj
->prev
= NULL
;
117 values_in_python
= value_obj
;
120 /* Called when a new gdb.Value object needs to be allocated. Returns NULL on
121 error, with a python exception set. */
123 valpy_new (PyTypeObject
*subtype
, PyObject
*args
, PyObject
*keywords
)
125 struct value
*value
= NULL
; /* Initialize to appease gcc warning. */
126 value_object
*value_obj
;
128 if (PyTuple_Size (args
) != 1)
130 PyErr_SetString (PyExc_TypeError
, _("Value object creation takes only "
135 value_obj
= (value_object
*) subtype
->tp_alloc (subtype
, 1);
136 if (value_obj
== NULL
)
138 PyErr_SetString (PyExc_MemoryError
, _("Could not allocate memory to "
139 "create Value object."));
143 value
= convert_value_from_python (PyTuple_GetItem (args
, 0));
146 subtype
->tp_free (value_obj
);
150 value_obj
->value
= value
;
151 release_value_or_incref (value
);
152 value_obj
->address
= NULL
;
153 value_obj
->type
= NULL
;
154 value_obj
->dynamic_type
= NULL
;
155 note_value (value_obj
);
157 return (PyObject
*) value_obj
;
160 /* Iterate over all the Value objects, calling preserve_one_value on
163 gdbpy_preserve_values (const struct extension_language_defn
*extlang
,
164 struct objfile
*objfile
, htab_t copied_types
)
168 for (iter
= values_in_python
; iter
; iter
= iter
->next
)
169 preserve_one_value (iter
->value
, objfile
, copied_types
);
172 /* Given a value of a pointer type, apply the C unary * operator to it. */
174 valpy_dereference (PyObject
*self
, PyObject
*args
)
176 PyObject
*result
= NULL
;
180 struct value
*res_val
;
181 scoped_value_mark free_values
;
183 res_val
= value_ind (((value_object
*) self
)->value
);
184 result
= value_to_value_object (res_val
);
186 CATCH (except
, RETURN_MASK_ALL
)
188 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 PyObject
*result
= NULL
;
210 struct value
*self_val
, *res_val
;
211 scoped_value_mark free_values
;
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
);
229 CATCH (except
, RETURN_MASK_ALL
)
231 GDB_PY_HANDLE_EXCEPTION (except
);
238 /* Return a value which is a reference to the value. */
241 valpy_reference_value (PyObject
*self
, PyObject
*args
)
243 PyObject
*result
= NULL
;
247 struct value
*self_val
;
248 scoped_value_mark free_values
;
250 self_val
= ((value_object
*) self
)->value
;
251 result
= value_to_value_object (value_ref (self_val
));
253 CATCH (except
, RETURN_MASK_ALL
)
255 GDB_PY_HANDLE_EXCEPTION (except
);
262 /* Return a "const" qualified version of the value. */
265 valpy_const_value (PyObject
*self
, PyObject
*args
)
267 PyObject
*result
= NULL
;
271 struct value
*self_val
, *res_val
;
272 scoped_value_mark free_values
;
274 self_val
= ((value_object
*) self
)->value
;
275 res_val
= make_cv_value (1, 0, self_val
);
276 result
= value_to_value_object (res_val
);
278 CATCH (except
, RETURN_MASK_ALL
)
280 GDB_PY_HANDLE_EXCEPTION (except
);
287 /* Return "&value". */
289 valpy_get_address (PyObject
*self
, void *closure
)
291 value_object
*val_obj
= (value_object
*) self
;
293 if (!val_obj
->address
)
297 struct value
*res_val
;
298 scoped_value_mark free_values
;
300 res_val
= value_addr (val_obj
->value
);
301 val_obj
->address
= value_to_value_object (res_val
);
303 CATCH (except
, RETURN_MASK_ALL
)
305 val_obj
->address
= Py_None
;
311 Py_XINCREF (val_obj
->address
);
313 return val_obj
->address
;
316 /* Return type of the value. */
318 valpy_get_type (PyObject
*self
, void *closure
)
320 value_object
*obj
= (value_object
*) self
;
324 obj
->type
= type_to_type_object (value_type (obj
->value
));
328 Py_INCREF (obj
->type
);
332 /* Return dynamic type of the value. */
335 valpy_get_dynamic_type (PyObject
*self
, void *closure
)
337 value_object
*obj
= (value_object
*) self
;
338 struct type
*type
= NULL
;
340 if (obj
->dynamic_type
!= NULL
)
342 Py_INCREF (obj
->dynamic_type
);
343 return obj
->dynamic_type
;
348 struct value
*val
= obj
->value
;
349 scoped_value_mark free_values
;
351 type
= value_type (val
);
352 type
= check_typedef (type
);
354 if (((TYPE_CODE (type
) == TYPE_CODE_PTR
)
355 || (TYPE_CODE (type
) == TYPE_CODE_REF
))
356 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
))
358 struct value
*target
;
359 int was_pointer
= TYPE_CODE (type
) == TYPE_CODE_PTR
;
362 target
= value_ind (val
);
364 target
= coerce_ref (val
);
365 type
= value_rtti_type (target
, NULL
, NULL
, NULL
);
370 type
= lookup_pointer_type (type
);
372 type
= lookup_reference_type (type
);
375 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
376 type
= value_rtti_type (val
, NULL
, NULL
, NULL
);
379 /* Re-use object's static type. */
383 CATCH (except
, RETURN_MASK_ALL
)
385 GDB_PY_HANDLE_EXCEPTION (except
);
390 obj
->dynamic_type
= valpy_get_type (self
, NULL
);
392 obj
->dynamic_type
= type_to_type_object (type
);
394 Py_XINCREF (obj
->dynamic_type
);
395 return obj
->dynamic_type
;
398 /* Implementation of gdb.Value.lazy_string ([encoding] [, length]) ->
399 string. Return a PyObject representing a lazy_string_object type.
400 A lazy string is a pointer to a string with an optional encoding and
401 length. If ENCODING is not given, encoding is set to None. If an
402 ENCODING is provided the encoding parameter is set to ENCODING, but
403 the string is not encoded. If LENGTH is provided then the length
404 parameter is set to LENGTH, otherwise length will be set to -1 (first
405 null of appropriate with). */
407 valpy_lazy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
409 gdb_py_longest length
= -1;
410 struct value
*value
= ((value_object
*) self
)->value
;
411 const char *user_encoding
= NULL
;
412 static char *keywords
[] = { "encoding", "length", NULL
};
413 PyObject
*str_obj
= NULL
;
415 if (!PyArg_ParseTupleAndKeywords (args
, kw
, "|s" GDB_PY_LL_ARG
, keywords
,
416 &user_encoding
, &length
))
421 scoped_value_mark free_values
;
423 if (TYPE_CODE (value_type (value
)) == TYPE_CODE_PTR
)
424 value
= value_ind (value
);
426 str_obj
= gdbpy_create_lazy_string_object (value_address (value
), length
,
430 CATCH (except
, RETURN_MASK_ALL
)
432 GDB_PY_HANDLE_EXCEPTION (except
);
439 /* Implementation of gdb.Value.string ([encoding] [, errors]
440 [, length]) -> string. Return Unicode string with value contents.
441 If ENCODING is not given, the string is assumed to be encoded in
442 the target's charset. If LENGTH is provided, only fetch string to
443 the length provided. */
446 valpy_string (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
450 struct value
*value
= ((value_object
*) self
)->value
;
452 const char *encoding
= NULL
;
453 const char *errors
= NULL
;
454 const char *user_encoding
= NULL
;
455 const char *la_encoding
= NULL
;
456 struct type
*char_type
;
457 static char *keywords
[] = { "encoding", "errors", "length", NULL
};
459 if (!PyArg_ParseTupleAndKeywords (args
, kw
, "|ssi", keywords
,
460 &user_encoding
, &errors
, &length
))
465 LA_GET_STRING (value
, &buffer
, &length
, &char_type
, &la_encoding
);
467 CATCH (except
, RETURN_MASK_ALL
)
469 GDB_PY_HANDLE_EXCEPTION (except
);
473 encoding
= (user_encoding
&& *user_encoding
) ? user_encoding
: la_encoding
;
474 unicode
= PyUnicode_Decode ((const char *) buffer
,
475 length
* TYPE_LENGTH (char_type
),
482 /* A helper function that implements the various cast operators. */
485 valpy_do_cast (PyObject
*self
, PyObject
*args
, enum exp_opcode op
)
487 PyObject
*type_obj
, *result
= NULL
;
490 if (! PyArg_ParseTuple (args
, "O", &type_obj
))
493 type
= type_object_to_type (type_obj
);
496 PyErr_SetString (PyExc_RuntimeError
,
497 _("Argument must be a type."));
503 struct value
*val
= ((value_object
*) self
)->value
;
504 struct value
*res_val
;
505 scoped_value_mark free_values
;
507 if (op
== UNOP_DYNAMIC_CAST
)
508 res_val
= value_dynamic_cast (type
, val
);
509 else if (op
== UNOP_REINTERPRET_CAST
)
510 res_val
= value_reinterpret_cast (type
, val
);
513 gdb_assert (op
== UNOP_CAST
);
514 res_val
= value_cast (type
, val
);
517 result
= value_to_value_object (res_val
);
519 CATCH (except
, RETURN_MASK_ALL
)
521 GDB_PY_HANDLE_EXCEPTION (except
);
528 /* Implementation of the "cast" method. */
531 valpy_cast (PyObject
*self
, PyObject
*args
)
533 return valpy_do_cast (self
, args
, UNOP_CAST
);
536 /* Implementation of the "dynamic_cast" method. */
539 valpy_dynamic_cast (PyObject
*self
, PyObject
*args
)
541 return valpy_do_cast (self
, args
, UNOP_DYNAMIC_CAST
);
544 /* Implementation of the "reinterpret_cast" method. */
547 valpy_reinterpret_cast (PyObject
*self
, PyObject
*args
)
549 return valpy_do_cast (self
, args
, UNOP_REINTERPRET_CAST
);
553 valpy_length (PyObject
*self
)
555 /* We don't support getting the number of elements in a struct / class. */
556 PyErr_SetString (PyExc_NotImplementedError
,
557 _("Invalid operation on gdb.Value."));
561 /* Return 1 if the gdb.Field object FIELD is present in the value V.
562 Returns 0 otherwise. If any Python error occurs, -1 is returned. */
565 value_has_field (struct value
*v
, PyObject
*field
)
567 struct type
*parent_type
, *val_type
;
568 enum type_code type_code
;
569 gdbpy_ref
type_object (PyObject_GetAttrString (field
, "parent_type"));
572 if (type_object
== NULL
)
575 parent_type
= type_object_to_type (type_object
.get ());
576 if (parent_type
== NULL
)
578 PyErr_SetString (PyExc_TypeError
,
579 _("'parent_type' attribute of gdb.Field object is not a"
580 "gdb.Type object."));
586 val_type
= value_type (v
);
587 val_type
= check_typedef (val_type
);
588 if (TYPE_CODE (val_type
) == TYPE_CODE_REF
589 || TYPE_CODE (val_type
) == TYPE_CODE_PTR
)
590 val_type
= check_typedef (TYPE_TARGET_TYPE (val_type
));
592 type_code
= TYPE_CODE (val_type
);
593 if ((type_code
== TYPE_CODE_STRUCT
|| type_code
== TYPE_CODE_UNION
)
594 && types_equal (val_type
, parent_type
))
599 CATCH (except
, RETURN_MASK_ALL
)
601 GDB_PY_SET_HANDLE_EXCEPTION (except
);
608 /* Return the value of a flag FLAG_NAME in a gdb.Field object FIELD.
609 Returns 1 if the flag value is true, 0 if it is false, and -1 if
610 a Python error occurs. */
613 get_field_flag (PyObject
*field
, const char *flag_name
)
615 gdbpy_ref
flag_object (PyObject_GetAttrString (field
, flag_name
));
617 if (flag_object
== NULL
)
620 return PyObject_IsTrue (flag_object
.get ());
623 /* Return the "type" attribute of a gdb.Field object.
624 Returns NULL on error, with a Python exception set. */
627 get_field_type (PyObject
*field
)
629 gdbpy_ref
ftype_obj (PyObject_GetAttrString (field
, "type"));
632 if (ftype_obj
== NULL
)
634 ftype
= type_object_to_type (ftype_obj
.get ());
636 PyErr_SetString (PyExc_TypeError
,
637 _("'type' attribute of gdb.Field object is not a "
638 "gdb.Type object."));
643 /* Given string name or a gdb.Field object corresponding to an element inside
644 a structure, return its value object. Returns NULL on error, with a python
648 valpy_getitem (PyObject
*self
, PyObject
*key
)
650 struct gdb_exception except
= exception_none
;
651 value_object
*self_value
= (value_object
*) self
;
652 gdb::unique_xmalloc_ptr
<char> field
;
653 struct type
*base_class_type
= NULL
, *field_type
= NULL
;
655 PyObject
*result
= NULL
;
657 if (gdbpy_is_string (key
))
659 field
= python_string_to_host_string (key
);
663 else if (gdbpy_is_field (key
))
665 int is_base_class
, valid_field
;
667 valid_field
= value_has_field (self_value
->value
, key
);
670 else if (valid_field
== 0)
672 PyErr_SetString (PyExc_TypeError
,
673 _("Invalid lookup for a field not contained in "
679 is_base_class
= get_field_flag (key
, "is_base_class");
680 if (is_base_class
< 0)
682 else if (is_base_class
> 0)
684 base_class_type
= get_field_type (key
);
685 if (base_class_type
== NULL
)
690 gdbpy_ref
name_obj (PyObject_GetAttrString (key
, "name"));
692 if (name_obj
== NULL
)
695 if (name_obj
!= Py_None
)
697 field
= python_string_to_host_string (name_obj
.get ());
703 if (!PyObject_HasAttrString (key
, "bitpos"))
705 PyErr_SetString (PyExc_AttributeError
,
706 _("gdb.Field object has no name and no "
707 "'bitpos' attribute."));
711 gdbpy_ref
bitpos_obj (PyObject_GetAttrString (key
, "bitpos"));
712 if (bitpos_obj
== NULL
)
714 if (!gdb_py_int_as_long (bitpos_obj
.get (), &bitpos
))
717 field_type
= get_field_type (key
);
718 if (field_type
== NULL
)
726 struct value
*tmp
= self_value
->value
;
727 struct value
*res_val
= NULL
;
728 scoped_value_mark free_values
;
731 res_val
= value_struct_elt (&tmp
, NULL
, field
.get (), NULL
,
732 "struct/class/union");
733 else if (bitpos
>= 0)
734 res_val
= value_struct_elt_bitpos (&tmp
, bitpos
, field_type
,
735 "struct/class/union");
736 else if (base_class_type
!= NULL
)
738 struct type
*val_type
;
740 val_type
= check_typedef (value_type (tmp
));
741 if (TYPE_CODE (val_type
) == TYPE_CODE_PTR
)
742 res_val
= value_cast (lookup_pointer_type (base_class_type
), tmp
);
743 else if (TYPE_CODE (val_type
) == TYPE_CODE_REF
)
744 res_val
= value_cast (lookup_reference_type (base_class_type
), tmp
);
746 res_val
= value_cast (base_class_type
, tmp
);
750 /* Assume we are attempting an array access, and let the
751 value code throw an exception if the index has an invalid
753 struct value
*idx
= convert_value_from_python (key
);
757 /* Check the value's type is something that can be accessed via
761 tmp
= coerce_ref (tmp
);
762 type
= check_typedef (value_type (tmp
));
763 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
764 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
765 error (_("Cannot subscript requested type."));
767 res_val
= value_subscript (tmp
, value_as_long (idx
));
772 result
= value_to_value_object (res_val
);
774 CATCH (ex
, RETURN_MASK_ALL
)
780 GDB_PY_HANDLE_EXCEPTION (except
);
786 valpy_setitem (PyObject
*self
, PyObject
*key
, PyObject
*value
)
788 PyErr_Format (PyExc_NotImplementedError
,
789 _("Setting of struct elements is not currently supported."));
793 /* Called by the Python interpreter to perform an inferior function
794 call on the value. Returns NULL on error, with a python exception set. */
796 valpy_call (PyObject
*self
, PyObject
*args
, PyObject
*keywords
)
798 Py_ssize_t args_count
;
799 struct value
*function
= ((value_object
*) self
)->value
;
800 struct value
**vargs
= NULL
;
801 struct type
*ftype
= NULL
;
802 struct value
*mark
= value_mark ();
803 PyObject
*result
= NULL
;
807 ftype
= check_typedef (value_type (function
));
809 CATCH (except
, RETURN_MASK_ALL
)
811 GDB_PY_HANDLE_EXCEPTION (except
);
815 if (TYPE_CODE (ftype
) != TYPE_CODE_FUNC
)
817 PyErr_SetString (PyExc_RuntimeError
,
818 _("Value is not callable (not TYPE_CODE_FUNC)."));
822 if (! PyTuple_Check (args
))
824 PyErr_SetString (PyExc_TypeError
,
825 _("Inferior arguments must be provided in a tuple."));
829 args_count
= PyTuple_Size (args
);
834 vargs
= XALLOCAVEC (struct value
*, args_count
);
835 for (i
= 0; i
< args_count
; i
++)
837 PyObject
*item
= PyTuple_GetItem (args
, i
);
842 vargs
[i
] = convert_value_from_python (item
);
843 if (vargs
[i
] == NULL
)
850 scoped_value_mark free_values
;
851 struct value
*return_value
;
853 return_value
= call_function_by_hand (function
, args_count
, vargs
);
854 result
= value_to_value_object (return_value
);
856 CATCH (except
, RETURN_MASK_ALL
)
858 GDB_PY_HANDLE_EXCEPTION (except
);
865 /* Called by the Python interpreter to obtain string representation
868 valpy_str (PyObject
*self
)
872 struct value_print_options opts
;
874 get_user_print_options (&opts
);
879 struct ui_file
*stb
= mem_fileopen ();
880 struct cleanup
*old_chain
= make_cleanup_ui_file_delete (stb
);
882 common_val_print (((value_object
*) self
)->value
, stb
, 0,
883 &opts
, python_language
);
884 s
= ui_file_as_string (stb
);
886 do_cleanups (old_chain
);
888 CATCH (except
, RETURN_MASK_ALL
)
890 GDB_PY_HANDLE_EXCEPTION (except
);
894 result
= PyUnicode_Decode (s
.c_str (), s
.length (), host_charset (), NULL
);
899 /* Implements gdb.Value.is_optimized_out. */
901 valpy_get_is_optimized_out (PyObject
*self
, void *closure
)
903 struct value
*value
= ((value_object
*) self
)->value
;
908 opt
= value_optimized_out (value
);
910 CATCH (except
, RETURN_MASK_ALL
)
912 GDB_PY_HANDLE_EXCEPTION (except
);
922 /* Implements gdb.Value.is_lazy. */
924 valpy_get_is_lazy (PyObject
*self
, void *closure
)
926 struct value
*value
= ((value_object
*) self
)->value
;
931 opt
= value_lazy (value
);
933 CATCH (except
, RETURN_MASK_ALL
)
935 GDB_PY_HANDLE_EXCEPTION (except
);
945 /* Implements gdb.Value.fetch_lazy (). */
947 valpy_fetch_lazy (PyObject
*self
, PyObject
*args
)
949 struct value
*value
= ((value_object
*) self
)->value
;
953 if (value_lazy (value
))
954 value_fetch_lazy (value
);
956 CATCH (except
, RETURN_MASK_ALL
)
958 GDB_PY_HANDLE_EXCEPTION (except
);
965 /* Calculate and return the address of the PyObject as the value of
966 the builtin __hash__ call. */
968 valpy_hash (PyObject
*self
)
970 return (intptr_t) self
;
988 /* If TYPE is a reference, return the target; otherwise return TYPE. */
989 #define STRIP_REFERENCE(TYPE) \
990 ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
992 /* Helper for valpy_binop. Returns a value object which is the result
993 of applying the operation specified by OPCODE to the given
994 arguments. Throws a GDB exception on error. */
997 valpy_binop_throw (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
999 PyObject
*result
= NULL
;
1001 struct value
*arg1
, *arg2
;
1002 struct value
*res_val
= NULL
;
1003 enum exp_opcode op
= OP_NULL
;
1006 scoped_value_mark free_values
;
1008 /* If the gdb.Value object is the second operand, then it will be
1009 passed to us as the OTHER argument, and SELF will be an entirely
1010 different kind of object, altogether. Because of this, we can't
1011 assume self is a gdb.Value object and need to convert it from
1013 arg1
= convert_value_from_python (self
);
1017 arg2
= convert_value_from_python (other
);
1025 struct type
*ltype
= value_type (arg1
);
1026 struct type
*rtype
= value_type (arg2
);
1028 ltype
= check_typedef (ltype
);
1029 ltype
= STRIP_REFERENCE (ltype
);
1030 rtype
= check_typedef (rtype
);
1031 rtype
= STRIP_REFERENCE (rtype
);
1034 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
1035 && is_integral_type (rtype
))
1036 res_val
= value_ptradd (arg1
, value_as_long (arg2
));
1037 else if (TYPE_CODE (rtype
) == TYPE_CODE_PTR
1038 && is_integral_type (ltype
))
1039 res_val
= value_ptradd (arg2
, value_as_long (arg1
));
1049 struct type
*ltype
= value_type (arg1
);
1050 struct type
*rtype
= value_type (arg2
);
1052 ltype
= check_typedef (ltype
);
1053 ltype
= STRIP_REFERENCE (ltype
);
1054 rtype
= check_typedef (rtype
);
1055 rtype
= STRIP_REFERENCE (rtype
);
1058 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
1059 && TYPE_CODE (rtype
) == TYPE_CODE_PTR
)
1060 /* A ptrdiff_t for the target would be preferable here. */
1061 res_val
= value_from_longest (builtin_type_pyint
,
1062 value_ptrdiff (arg1
, arg2
));
1063 else if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
1064 && is_integral_type (rtype
))
1065 res_val
= value_ptradd (arg1
, - value_as_long (arg2
));
1092 op
= BINOP_BITWISE_AND
;
1095 op
= BINOP_BITWISE_IOR
;
1098 op
= BINOP_BITWISE_XOR
;
1104 if (binop_user_defined_p (op
, arg1
, arg2
))
1105 res_val
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, EVAL_NORMAL
);
1107 res_val
= value_binop (arg1
, arg2
, op
);
1111 result
= value_to_value_object (res_val
);
1116 /* Returns a value object which is the result of applying the operation
1117 specified by OPCODE to the given arguments. Returns NULL on error, with
1118 a python exception set. */
1120 valpy_binop (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
1122 PyObject
*result
= NULL
;
1126 result
= valpy_binop_throw (opcode
, self
, other
);
1128 CATCH (except
, RETURN_MASK_ALL
)
1130 GDB_PY_HANDLE_EXCEPTION (except
);
1138 valpy_add (PyObject
*self
, PyObject
*other
)
1140 return valpy_binop (VALPY_ADD
, self
, other
);
1144 valpy_subtract (PyObject
*self
, PyObject
*other
)
1146 return valpy_binop (VALPY_SUB
, self
, other
);
1150 valpy_multiply (PyObject
*self
, PyObject
*other
)
1152 return valpy_binop (VALPY_MUL
, self
, other
);
1156 valpy_divide (PyObject
*self
, PyObject
*other
)
1158 return valpy_binop (VALPY_DIV
, self
, other
);
1162 valpy_remainder (PyObject
*self
, PyObject
*other
)
1164 return valpy_binop (VALPY_REM
, self
, other
);
1168 valpy_power (PyObject
*self
, PyObject
*other
, PyObject
*unused
)
1170 /* We don't support the ternary form of pow. I don't know how to express
1171 that, so let's just throw NotImplementedError to at least do something
1173 if (unused
!= Py_None
)
1175 PyErr_SetString (PyExc_NotImplementedError
,
1176 "Invalid operation on gdb.Value.");
1180 return valpy_binop (VALPY_POW
, self
, other
);
1184 valpy_negative (PyObject
*self
)
1186 PyObject
*result
= NULL
;
1190 /* Perhaps overkill, but consistency has some virtue. */
1191 scoped_value_mark free_values
;
1194 val
= value_neg (((value_object
*) self
)->value
);
1195 result
= value_to_value_object (val
);
1197 CATCH (except
, RETURN_MASK_ALL
)
1199 GDB_PY_HANDLE_EXCEPTION (except
);
1207 valpy_positive (PyObject
*self
)
1209 return value_to_value_object (((value_object
*) self
)->value
);
1213 valpy_absolute (PyObject
*self
)
1215 struct value
*value
= ((value_object
*) self
)->value
;
1220 scoped_value_mark free_values
;
1222 if (value_less (value
, value_zero (value_type (value
), not_lval
)))
1225 CATCH (except
, RETURN_MASK_ALL
)
1227 GDB_PY_HANDLE_EXCEPTION (except
);
1232 return valpy_positive (self
);
1234 return valpy_negative (self
);
1237 /* Implements boolean evaluation of gdb.Value. */
1239 valpy_nonzero (PyObject
*self
)
1241 struct gdb_exception except
= exception_none
;
1242 value_object
*self_value
= (value_object
*) self
;
1244 int nonzero
= 0; /* Appease GCC warning. */
1248 type
= check_typedef (value_type (self_value
->value
));
1250 if (is_integral_type (type
) || TYPE_CODE (type
) == TYPE_CODE_PTR
)
1251 nonzero
= !!value_as_long (self_value
->value
);
1252 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1253 nonzero
= value_as_double (self_value
->value
) != 0;
1254 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1255 nonzero
= !decimal_is_zero (value_contents (self_value
->value
),
1257 gdbarch_byte_order (get_type_arch (type
)));
1259 /* All other values are True. */
1262 CATCH (ex
, RETURN_MASK_ALL
)
1268 /* This is not documented in the Python documentation, but if this
1269 function fails, return -1 as slot_nb_nonzero does (the default
1270 Python nonzero function). */
1271 GDB_PY_SET_HANDLE_EXCEPTION (except
);
1276 /* Implements ~ for value objects. */
1278 valpy_invert (PyObject
*self
)
1280 struct value
*val
= NULL
;
1284 val
= value_complement (((value_object
*) self
)->value
);
1286 CATCH (except
, RETURN_MASK_ALL
)
1288 GDB_PY_HANDLE_EXCEPTION (except
);
1292 return value_to_value_object (val
);
1295 /* Implements left shift for value objects. */
1297 valpy_lsh (PyObject
*self
, PyObject
*other
)
1299 return valpy_binop (VALPY_LSH
, self
, other
);
1302 /* Implements right shift for value objects. */
1304 valpy_rsh (PyObject
*self
, PyObject
*other
)
1306 return valpy_binop (VALPY_RSH
, self
, other
);
1309 /* Implements bitwise and for value objects. */
1311 valpy_and (PyObject
*self
, PyObject
*other
)
1313 return valpy_binop (VALPY_BITAND
, self
, other
);
1316 /* Implements bitwise or for value objects. */
1318 valpy_or (PyObject
*self
, PyObject
*other
)
1320 return valpy_binop (VALPY_BITOR
, self
, other
);
1323 /* Implements bitwise xor for value objects. */
1325 valpy_xor (PyObject
*self
, PyObject
*other
)
1327 return valpy_binop (VALPY_BITXOR
, self
, other
);
1330 /* Helper for valpy_richcompare. Implements comparison operations for
1331 value objects. Returns true/false on success. Returns -1 with a
1332 Python exception set if a Python error is detected. Throws a GDB
1333 exception on other errors (memory error, etc.). */
1336 valpy_richcompare_throw (PyObject
*self
, PyObject
*other
, int op
)
1339 struct value
*value_other
;
1340 struct value
*value_self
;
1341 struct cleanup
*cleanup
;
1343 scoped_value_mark free_values
;
1345 value_other
= convert_value_from_python (other
);
1346 if (value_other
== NULL
)
1349 value_self
= ((value_object
*) self
)->value
;
1354 result
= value_less (value_self
, value_other
);
1357 result
= value_less (value_self
, value_other
)
1358 || value_equal (value_self
, value_other
);
1361 result
= value_equal (value_self
, value_other
);
1364 result
= !value_equal (value_self
, value_other
);
1367 result
= value_less (value_other
, value_self
);
1370 result
= (value_less (value_other
, value_self
)
1371 || value_equal (value_self
, value_other
));
1375 PyErr_SetString (PyExc_NotImplementedError
,
1376 _("Invalid operation on gdb.Value."));
1385 /* Implements comparison operations for value objects. Returns NULL on error,
1386 with a python exception set. */
1388 valpy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1392 if (other
== Py_None
)
1393 /* Comparing with None is special. From what I can tell, in Python
1394 None is smaller than anything else. */
1406 PyErr_SetString (PyExc_NotImplementedError
,
1407 _("Invalid operation on gdb.Value."));
1413 result
= valpy_richcompare_throw (self
, other
, op
);
1415 CATCH (except
, RETURN_MASK_ALL
)
1417 GDB_PY_HANDLE_EXCEPTION (except
);
1421 /* In this case, the Python exception has already been set. */
1432 /* Implements conversion to int. */
1434 valpy_int (PyObject
*self
)
1436 struct value
*value
= ((value_object
*) self
)->value
;
1437 struct type
*type
= value_type (value
);
1442 if (!is_integral_type (type
))
1443 error (_("Cannot convert value to int."));
1445 l
= value_as_long (value
);
1447 CATCH (except
, RETURN_MASK_ALL
)
1449 GDB_PY_HANDLE_EXCEPTION (except
);
1453 return gdb_py_object_from_longest (l
);
1457 /* Implements conversion to long. */
1459 valpy_long (PyObject
*self
)
1461 struct value
*value
= ((value_object
*) self
)->value
;
1462 struct type
*type
= value_type (value
);
1467 type
= check_typedef (type
);
1469 if (!is_integral_type (type
)
1470 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1471 error (_("Cannot convert value to long."));
1473 l
= value_as_long (value
);
1475 CATCH (except
, RETURN_MASK_ALL
)
1477 GDB_PY_HANDLE_EXCEPTION (except
);
1481 if (TYPE_UNSIGNED (type
))
1482 return gdb_py_long_from_ulongest (l
);
1484 return gdb_py_long_from_longest (l
);
1487 /* Implements conversion to float. */
1489 valpy_float (PyObject
*self
)
1491 struct value
*value
= ((value_object
*) self
)->value
;
1492 struct type
*type
= value_type (value
);
1497 type
= check_typedef (type
);
1499 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
1500 error (_("Cannot convert value to float."));
1502 d
= value_as_double (value
);
1504 CATCH (except
, RETURN_MASK_ALL
)
1506 GDB_PY_HANDLE_EXCEPTION (except
);
1510 return PyFloat_FromDouble (d
);
1513 /* Returns an object for a value which is released from the all_values chain,
1514 so its lifetime is not bound to the execution of a command. */
1516 value_to_value_object (struct value
*val
)
1518 value_object
*val_obj
;
1520 val_obj
= PyObject_New (value_object
, &value_object_type
);
1521 if (val_obj
!= NULL
)
1523 val_obj
->value
= val
;
1524 release_value_or_incref (val
);
1525 val_obj
->address
= NULL
;
1526 val_obj
->type
= NULL
;
1527 val_obj
->dynamic_type
= NULL
;
1528 note_value (val_obj
);
1531 return (PyObject
*) val_obj
;
1534 /* Returns a borrowed reference to the struct value corresponding to
1535 the given value object. */
1537 value_object_to_value (PyObject
*self
)
1541 if (! PyObject_TypeCheck (self
, &value_object_type
))
1543 real
= (value_object
*) self
;
1547 /* Try to convert a Python value to a gdb value. If the value cannot
1548 be converted, set a Python exception and return NULL. Returns a
1549 reference to a new value on the all_values chain. */
1552 convert_value_from_python (PyObject
*obj
)
1554 struct value
*value
= NULL
; /* -Wall */
1557 gdb_assert (obj
!= NULL
);
1561 if (PyBool_Check (obj
))
1563 cmp
= PyObject_IsTrue (obj
);
1565 value
= value_from_longest (builtin_type_pybool
, cmp
);
1567 /* Make a long logic check first. In Python 3.x, internally,
1568 all integers are represented as longs. In Python 2.x, there
1569 is still a differentiation internally between a PyInt and a
1570 PyLong. Explicitly do this long check conversion first. In
1571 GDB, for Python 3.x, we #ifdef PyInt = PyLong. This check has
1572 to be done first to ensure we do not lose information in the
1573 conversion process. */
1574 else if (PyLong_Check (obj
))
1576 LONGEST l
= PyLong_AsLongLong (obj
);
1578 if (PyErr_Occurred ())
1580 /* If the error was an overflow, we can try converting to
1581 ULONGEST instead. */
1582 if (PyErr_ExceptionMatches (PyExc_OverflowError
))
1584 PyObject
*etype
, *evalue
, *etraceback
;
1586 PyErr_Fetch (&etype
, &evalue
, &etraceback
);
1587 gdbpy_ref
zero (PyInt_FromLong (0));
1589 /* Check whether obj is positive. */
1590 if (PyObject_RichCompareBool (obj
, zero
.get (), Py_GT
) > 0)
1594 ul
= PyLong_AsUnsignedLongLong (obj
);
1595 if (! PyErr_Occurred ())
1596 value
= value_from_ulongest (builtin_type_upylong
, ul
);
1599 /* There's nothing we can do. */
1600 PyErr_Restore (etype
, evalue
, etraceback
);
1604 value
= value_from_longest (builtin_type_pylong
, l
);
1606 #if PY_MAJOR_VERSION == 2
1607 else if (PyInt_Check (obj
))
1609 long l
= PyInt_AsLong (obj
);
1611 if (! PyErr_Occurred ())
1612 value
= value_from_longest (builtin_type_pyint
, l
);
1615 else if (PyFloat_Check (obj
))
1617 double d
= PyFloat_AsDouble (obj
);
1619 if (! PyErr_Occurred ())
1620 value
= value_from_double (builtin_type_pyfloat
, d
);
1622 else if (gdbpy_is_string (obj
))
1624 gdb::unique_xmalloc_ptr
<char> s
1625 = python_string_to_target_string (obj
);
1627 value
= value_cstring (s
.get (), strlen (s
.get ()),
1628 builtin_type_pychar
);
1630 else if (PyObject_TypeCheck (obj
, &value_object_type
))
1631 value
= value_copy (((value_object
*) obj
)->value
);
1632 else if (gdbpy_is_lazy_string (obj
))
1636 result
= PyObject_CallMethodObjArgs (obj
, gdbpy_value_cst
, NULL
);
1637 value
= value_copy (((value_object
*) result
)->value
);
1641 PyErr_Format (PyExc_TypeError
,
1642 _("Could not convert Python object: %S."), obj
);
1644 PyErr_Format (PyExc_TypeError
,
1645 _("Could not convert Python object: %s."),
1646 PyString_AsString (PyObject_Str (obj
)));
1649 CATCH (except
, RETURN_MASK_ALL
)
1651 PyErr_Format (except
.reason
== RETURN_QUIT
1652 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
1653 "%s", except
.message
);
1661 /* Returns value object in the ARGth position in GDB's history. */
1663 gdbpy_history (PyObject
*self
, PyObject
*args
)
1666 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
1668 if (!PyArg_ParseTuple (args
, "i", &i
))
1673 res_val
= access_value_history (i
);
1675 CATCH (except
, RETURN_MASK_ALL
)
1677 GDB_PY_HANDLE_EXCEPTION (except
);
1681 return value_to_value_object (res_val
);
1684 /* Returns 1 in OBJ is a gdb.Value object, 0 otherwise. */
1687 gdbpy_is_value_object (PyObject
*obj
)
1689 return PyObject_TypeCheck (obj
, &value_object_type
);
1693 gdbpy_initialize_values (void)
1695 if (PyType_Ready (&value_object_type
) < 0)
1698 return gdb_pymodule_addobject (gdb_module
, "Value",
1699 (PyObject
*) &value_object_type
);
1704 static PyGetSetDef value_object_getset
[] = {
1705 { "address", valpy_get_address
, NULL
, "The address of the value.",
1707 { "is_optimized_out", valpy_get_is_optimized_out
, NULL
,
1708 "Boolean telling whether the value is optimized "
1709 "out (i.e., not available).",
1711 { "type", valpy_get_type
, NULL
, "Type of the value.", NULL
},
1712 { "dynamic_type", valpy_get_dynamic_type
, NULL
,
1713 "Dynamic type of the value.", NULL
},
1714 { "is_lazy", valpy_get_is_lazy
, NULL
,
1715 "Boolean telling whether the value is lazy (not fetched yet\n\
1716 from the inferior). A lazy value is fetched when needed, or when\n\
1717 the \"fetch_lazy()\" method is called.", NULL
},
1718 {NULL
} /* Sentinel */
1721 static PyMethodDef value_object_methods
[] = {
1722 { "cast", valpy_cast
, METH_VARARGS
, "Cast the value to the supplied type." },
1723 { "dynamic_cast", valpy_dynamic_cast
, METH_VARARGS
,
1724 "dynamic_cast (gdb.Type) -> gdb.Value\n\
1725 Cast the value to the supplied type, as if by the C++ dynamic_cast operator."
1727 { "reinterpret_cast", valpy_reinterpret_cast
, METH_VARARGS
,
1728 "reinterpret_cast (gdb.Type) -> gdb.Value\n\
1729 Cast the value to the supplied type, as if by the C++\n\
1730 reinterpret_cast operator."
1732 { "dereference", valpy_dereference
, METH_NOARGS
, "Dereferences the value." },
1733 { "referenced_value", valpy_referenced_value
, METH_NOARGS
,
1734 "Return the value referenced by a TYPE_CODE_REF or TYPE_CODE_PTR value." },
1735 { "reference_value", valpy_reference_value
, METH_NOARGS
,
1736 "Return a value of type TYPE_CODE_REF referencing this value." },
1737 { "const_value", valpy_const_value
, METH_NOARGS
,
1738 "Return a 'const' qualied version of the same value." },
1739 { "lazy_string", (PyCFunction
) valpy_lazy_string
,
1740 METH_VARARGS
| METH_KEYWORDS
,
1741 "lazy_string ([encoding] [, length]) -> lazy_string\n\
1742 Return a lazy string representation of the value." },
1743 { "string", (PyCFunction
) valpy_string
, METH_VARARGS
| METH_KEYWORDS
,
1744 "string ([encoding] [, errors] [, length]) -> string\n\
1745 Return Unicode string representation of the value." },
1746 { "fetch_lazy", valpy_fetch_lazy
, METH_NOARGS
,
1747 "Fetches the value from the inferior, if it was lazy." },
1748 {NULL
} /* Sentinel */
1751 static PyNumberMethods value_object_as_number
= {
1759 NULL
, /* nb_divmod */
1760 valpy_power
, /* nb_power */
1761 valpy_negative
, /* nb_negative */
1762 valpy_positive
, /* nb_positive */
1763 valpy_absolute
, /* nb_absolute */
1764 valpy_nonzero
, /* nb_nonzero */
1765 valpy_invert
, /* nb_invert */
1766 valpy_lsh
, /* nb_lshift */
1767 valpy_rsh
, /* nb_rshift */
1768 valpy_and
, /* nb_and */
1769 valpy_xor
, /* nb_xor */
1770 valpy_or
, /* nb_or */
1772 valpy_long
, /* nb_int */
1773 NULL
, /* reserved */
1775 NULL
, /* nb_coerce */
1776 valpy_int
, /* nb_int */
1777 valpy_long
, /* nb_long */
1779 valpy_float
, /* nb_float */
1784 NULL
, /* nb_inplace_add */
1785 NULL
, /* nb_inplace_subtract */
1786 NULL
, /* nb_inplace_multiply */
1788 NULL
, /* nb_inplace_divide */
1790 NULL
, /* nb_inplace_remainder */
1791 NULL
, /* nb_inplace_power */
1792 NULL
, /* nb_inplace_lshift */
1793 NULL
, /* nb_inplace_rshift */
1794 NULL
, /* nb_inplace_and */
1795 NULL
, /* nb_inplace_xor */
1796 NULL
, /* nb_inplace_or */
1797 NULL
, /* nb_floor_divide */
1798 valpy_divide
, /* nb_true_divide */
1799 NULL
, /* nb_inplace_floor_divide */
1800 NULL
, /* nb_inplace_true_divide */
1801 #ifndef HAVE_LIBPYTHON2_4
1802 /* This was added in Python 2.5. */
1803 valpy_long
, /* nb_index */
1804 #endif /* HAVE_LIBPYTHON2_4 */
1807 static PyMappingMethods value_object_as_mapping
= {
1813 PyTypeObject value_object_type
= {
1814 PyVarObject_HEAD_INIT (NULL
, 0)
1815 "gdb.Value", /*tp_name*/
1816 sizeof (value_object
), /*tp_basicsize*/
1818 valpy_dealloc
, /*tp_dealloc*/
1824 &value_object_as_number
, /*tp_as_number*/
1825 0, /*tp_as_sequence*/
1826 &value_object_as_mapping
, /*tp_as_mapping*/
1827 valpy_hash
, /*tp_hash*/
1828 valpy_call
, /*tp_call*/
1829 valpy_str
, /*tp_str*/
1833 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
1834 | Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1835 "GDB value object", /* tp_doc */
1836 0, /* tp_traverse */
1838 valpy_richcompare
, /* tp_richcompare */
1839 0, /* tp_weaklistoffset */
1841 0, /* tp_iternext */
1842 value_object_methods
, /* tp_methods */
1844 value_object_getset
, /* tp_getset */
1847 0, /* tp_descr_get */
1848 0, /* tp_descr_set */
1849 0, /* tp_dictoffset */
1852 valpy_new
/* tp_new */