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
)
870 struct value_print_options opts
;
872 get_user_print_options (&opts
);
879 common_val_print (((value_object
*) self
)->value
, &stb
, 0,
880 &opts
, python_language
);
882 CATCH (except
, RETURN_MASK_ALL
)
884 GDB_PY_HANDLE_EXCEPTION (except
);
888 return PyUnicode_Decode (stb
.c_str (), stb
.size (), host_charset (), NULL
);
891 /* Implements gdb.Value.is_optimized_out. */
893 valpy_get_is_optimized_out (PyObject
*self
, void *closure
)
895 struct value
*value
= ((value_object
*) self
)->value
;
900 opt
= value_optimized_out (value
);
902 CATCH (except
, RETURN_MASK_ALL
)
904 GDB_PY_HANDLE_EXCEPTION (except
);
914 /* Implements gdb.Value.is_lazy. */
916 valpy_get_is_lazy (PyObject
*self
, void *closure
)
918 struct value
*value
= ((value_object
*) self
)->value
;
923 opt
= value_lazy (value
);
925 CATCH (except
, RETURN_MASK_ALL
)
927 GDB_PY_HANDLE_EXCEPTION (except
);
937 /* Implements gdb.Value.fetch_lazy (). */
939 valpy_fetch_lazy (PyObject
*self
, PyObject
*args
)
941 struct value
*value
= ((value_object
*) self
)->value
;
945 if (value_lazy (value
))
946 value_fetch_lazy (value
);
948 CATCH (except
, RETURN_MASK_ALL
)
950 GDB_PY_HANDLE_EXCEPTION (except
);
957 /* Calculate and return the address of the PyObject as the value of
958 the builtin __hash__ call. */
960 valpy_hash (PyObject
*self
)
962 return (intptr_t) self
;
980 /* If TYPE is a reference, return the target; otherwise return TYPE. */
981 #define STRIP_REFERENCE(TYPE) \
982 ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
984 /* Helper for valpy_binop. Returns a value object which is the result
985 of applying the operation specified by OPCODE to the given
986 arguments. Throws a GDB exception on error. */
989 valpy_binop_throw (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
991 PyObject
*result
= NULL
;
993 struct value
*arg1
, *arg2
;
994 struct value
*res_val
= NULL
;
995 enum exp_opcode op
= OP_NULL
;
998 scoped_value_mark free_values
;
1000 /* If the gdb.Value object is the second operand, then it will be
1001 passed to us as the OTHER argument, and SELF will be an entirely
1002 different kind of object, altogether. Because of this, we can't
1003 assume self is a gdb.Value object and need to convert it from
1005 arg1
= convert_value_from_python (self
);
1009 arg2
= convert_value_from_python (other
);
1017 struct type
*ltype
= value_type (arg1
);
1018 struct type
*rtype
= value_type (arg2
);
1020 ltype
= check_typedef (ltype
);
1021 ltype
= STRIP_REFERENCE (ltype
);
1022 rtype
= check_typedef (rtype
);
1023 rtype
= STRIP_REFERENCE (rtype
);
1026 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
1027 && is_integral_type (rtype
))
1028 res_val
= value_ptradd (arg1
, value_as_long (arg2
));
1029 else if (TYPE_CODE (rtype
) == TYPE_CODE_PTR
1030 && is_integral_type (ltype
))
1031 res_val
= value_ptradd (arg2
, value_as_long (arg1
));
1041 struct type
*ltype
= value_type (arg1
);
1042 struct type
*rtype
= value_type (arg2
);
1044 ltype
= check_typedef (ltype
);
1045 ltype
= STRIP_REFERENCE (ltype
);
1046 rtype
= check_typedef (rtype
);
1047 rtype
= STRIP_REFERENCE (rtype
);
1050 if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
1051 && TYPE_CODE (rtype
) == TYPE_CODE_PTR
)
1052 /* A ptrdiff_t for the target would be preferable here. */
1053 res_val
= value_from_longest (builtin_type_pyint
,
1054 value_ptrdiff (arg1
, arg2
));
1055 else if (TYPE_CODE (ltype
) == TYPE_CODE_PTR
1056 && is_integral_type (rtype
))
1057 res_val
= value_ptradd (arg1
, - value_as_long (arg2
));
1084 op
= BINOP_BITWISE_AND
;
1087 op
= BINOP_BITWISE_IOR
;
1090 op
= BINOP_BITWISE_XOR
;
1096 if (binop_user_defined_p (op
, arg1
, arg2
))
1097 res_val
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, EVAL_NORMAL
);
1099 res_val
= value_binop (arg1
, arg2
, op
);
1103 result
= value_to_value_object (res_val
);
1108 /* Returns a value object which is the result of applying the operation
1109 specified by OPCODE to the given arguments. Returns NULL on error, with
1110 a python exception set. */
1112 valpy_binop (enum valpy_opcode opcode
, PyObject
*self
, PyObject
*other
)
1114 PyObject
*result
= NULL
;
1118 result
= valpy_binop_throw (opcode
, self
, other
);
1120 CATCH (except
, RETURN_MASK_ALL
)
1122 GDB_PY_HANDLE_EXCEPTION (except
);
1130 valpy_add (PyObject
*self
, PyObject
*other
)
1132 return valpy_binop (VALPY_ADD
, self
, other
);
1136 valpy_subtract (PyObject
*self
, PyObject
*other
)
1138 return valpy_binop (VALPY_SUB
, self
, other
);
1142 valpy_multiply (PyObject
*self
, PyObject
*other
)
1144 return valpy_binop (VALPY_MUL
, self
, other
);
1148 valpy_divide (PyObject
*self
, PyObject
*other
)
1150 return valpy_binop (VALPY_DIV
, self
, other
);
1154 valpy_remainder (PyObject
*self
, PyObject
*other
)
1156 return valpy_binop (VALPY_REM
, self
, other
);
1160 valpy_power (PyObject
*self
, PyObject
*other
, PyObject
*unused
)
1162 /* We don't support the ternary form of pow. I don't know how to express
1163 that, so let's just throw NotImplementedError to at least do something
1165 if (unused
!= Py_None
)
1167 PyErr_SetString (PyExc_NotImplementedError
,
1168 "Invalid operation on gdb.Value.");
1172 return valpy_binop (VALPY_POW
, self
, other
);
1176 valpy_negative (PyObject
*self
)
1178 PyObject
*result
= NULL
;
1182 /* Perhaps overkill, but consistency has some virtue. */
1183 scoped_value_mark free_values
;
1186 val
= value_neg (((value_object
*) self
)->value
);
1187 result
= value_to_value_object (val
);
1189 CATCH (except
, RETURN_MASK_ALL
)
1191 GDB_PY_HANDLE_EXCEPTION (except
);
1199 valpy_positive (PyObject
*self
)
1201 return value_to_value_object (((value_object
*) self
)->value
);
1205 valpy_absolute (PyObject
*self
)
1207 struct value
*value
= ((value_object
*) self
)->value
;
1212 scoped_value_mark free_values
;
1214 if (value_less (value
, value_zero (value_type (value
), not_lval
)))
1217 CATCH (except
, RETURN_MASK_ALL
)
1219 GDB_PY_HANDLE_EXCEPTION (except
);
1224 return valpy_positive (self
);
1226 return valpy_negative (self
);
1229 /* Implements boolean evaluation of gdb.Value. */
1231 valpy_nonzero (PyObject
*self
)
1233 struct gdb_exception except
= exception_none
;
1234 value_object
*self_value
= (value_object
*) self
;
1236 int nonzero
= 0; /* Appease GCC warning. */
1240 type
= check_typedef (value_type (self_value
->value
));
1242 if (is_integral_type (type
) || TYPE_CODE (type
) == TYPE_CODE_PTR
)
1243 nonzero
= !!value_as_long (self_value
->value
);
1244 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1245 nonzero
= value_as_double (self_value
->value
) != 0;
1246 else if (TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1247 nonzero
= !decimal_is_zero (value_contents (self_value
->value
),
1249 gdbarch_byte_order (get_type_arch (type
)));
1251 /* All other values are True. */
1254 CATCH (ex
, RETURN_MASK_ALL
)
1260 /* This is not documented in the Python documentation, but if this
1261 function fails, return -1 as slot_nb_nonzero does (the default
1262 Python nonzero function). */
1263 GDB_PY_SET_HANDLE_EXCEPTION (except
);
1268 /* Implements ~ for value objects. */
1270 valpy_invert (PyObject
*self
)
1272 struct value
*val
= NULL
;
1276 val
= value_complement (((value_object
*) self
)->value
);
1278 CATCH (except
, RETURN_MASK_ALL
)
1280 GDB_PY_HANDLE_EXCEPTION (except
);
1284 return value_to_value_object (val
);
1287 /* Implements left shift for value objects. */
1289 valpy_lsh (PyObject
*self
, PyObject
*other
)
1291 return valpy_binop (VALPY_LSH
, self
, other
);
1294 /* Implements right shift for value objects. */
1296 valpy_rsh (PyObject
*self
, PyObject
*other
)
1298 return valpy_binop (VALPY_RSH
, self
, other
);
1301 /* Implements bitwise and for value objects. */
1303 valpy_and (PyObject
*self
, PyObject
*other
)
1305 return valpy_binop (VALPY_BITAND
, self
, other
);
1308 /* Implements bitwise or for value objects. */
1310 valpy_or (PyObject
*self
, PyObject
*other
)
1312 return valpy_binop (VALPY_BITOR
, self
, other
);
1315 /* Implements bitwise xor for value objects. */
1317 valpy_xor (PyObject
*self
, PyObject
*other
)
1319 return valpy_binop (VALPY_BITXOR
, self
, other
);
1322 /* Helper for valpy_richcompare. Implements comparison operations for
1323 value objects. Returns true/false on success. Returns -1 with a
1324 Python exception set if a Python error is detected. Throws a GDB
1325 exception on other errors (memory error, etc.). */
1328 valpy_richcompare_throw (PyObject
*self
, PyObject
*other
, int op
)
1331 struct value
*value_other
;
1332 struct value
*value_self
;
1334 scoped_value_mark free_values
;
1336 value_other
= convert_value_from_python (other
);
1337 if (value_other
== NULL
)
1340 value_self
= ((value_object
*) self
)->value
;
1345 result
= value_less (value_self
, value_other
);
1348 result
= value_less (value_self
, value_other
)
1349 || value_equal (value_self
, value_other
);
1352 result
= value_equal (value_self
, value_other
);
1355 result
= !value_equal (value_self
, value_other
);
1358 result
= value_less (value_other
, value_self
);
1361 result
= (value_less (value_other
, value_self
)
1362 || value_equal (value_self
, value_other
));
1366 PyErr_SetString (PyExc_NotImplementedError
,
1367 _("Invalid operation on gdb.Value."));
1376 /* Implements comparison operations for value objects. Returns NULL on error,
1377 with a python exception set. */
1379 valpy_richcompare (PyObject
*self
, PyObject
*other
, int op
)
1383 if (other
== Py_None
)
1384 /* Comparing with None is special. From what I can tell, in Python
1385 None is smaller than anything else. */
1397 PyErr_SetString (PyExc_NotImplementedError
,
1398 _("Invalid operation on gdb.Value."));
1404 result
= valpy_richcompare_throw (self
, other
, op
);
1406 CATCH (except
, RETURN_MASK_ALL
)
1408 GDB_PY_HANDLE_EXCEPTION (except
);
1412 /* In this case, the Python exception has already been set. */
1423 /* Implements conversion to int. */
1425 valpy_int (PyObject
*self
)
1427 struct value
*value
= ((value_object
*) self
)->value
;
1428 struct type
*type
= value_type (value
);
1433 if (!is_integral_type (type
))
1434 error (_("Cannot convert value to int."));
1436 l
= value_as_long (value
);
1438 CATCH (except
, RETURN_MASK_ALL
)
1440 GDB_PY_HANDLE_EXCEPTION (except
);
1444 return gdb_py_object_from_longest (l
);
1448 /* Implements conversion to long. */
1450 valpy_long (PyObject
*self
)
1452 struct value
*value
= ((value_object
*) self
)->value
;
1453 struct type
*type
= value_type (value
);
1458 type
= check_typedef (type
);
1460 if (!is_integral_type (type
)
1461 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1462 error (_("Cannot convert value to long."));
1464 l
= value_as_long (value
);
1466 CATCH (except
, RETURN_MASK_ALL
)
1468 GDB_PY_HANDLE_EXCEPTION (except
);
1472 if (TYPE_UNSIGNED (type
))
1473 return gdb_py_long_from_ulongest (l
);
1475 return gdb_py_long_from_longest (l
);
1478 /* Implements conversion to float. */
1480 valpy_float (PyObject
*self
)
1482 struct value
*value
= ((value_object
*) self
)->value
;
1483 struct type
*type
= value_type (value
);
1488 type
= check_typedef (type
);
1490 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
1491 error (_("Cannot convert value to float."));
1493 d
= value_as_double (value
);
1495 CATCH (except
, RETURN_MASK_ALL
)
1497 GDB_PY_HANDLE_EXCEPTION (except
);
1501 return PyFloat_FromDouble (d
);
1504 /* Returns an object for a value which is released from the all_values chain,
1505 so its lifetime is not bound to the execution of a command. */
1507 value_to_value_object (struct value
*val
)
1509 value_object
*val_obj
;
1511 val_obj
= PyObject_New (value_object
, &value_object_type
);
1512 if (val_obj
!= NULL
)
1514 val_obj
->value
= val
;
1515 release_value_or_incref (val
);
1516 val_obj
->address
= NULL
;
1517 val_obj
->type
= NULL
;
1518 val_obj
->dynamic_type
= NULL
;
1519 note_value (val_obj
);
1522 return (PyObject
*) val_obj
;
1525 /* Returns a borrowed reference to the struct value corresponding to
1526 the given value object. */
1528 value_object_to_value (PyObject
*self
)
1532 if (! PyObject_TypeCheck (self
, &value_object_type
))
1534 real
= (value_object
*) self
;
1538 /* Try to convert a Python value to a gdb value. If the value cannot
1539 be converted, set a Python exception and return NULL. Returns a
1540 reference to a new value on the all_values chain. */
1543 convert_value_from_python (PyObject
*obj
)
1545 struct value
*value
= NULL
; /* -Wall */
1548 gdb_assert (obj
!= NULL
);
1552 if (PyBool_Check (obj
))
1554 cmp
= PyObject_IsTrue (obj
);
1556 value
= value_from_longest (builtin_type_pybool
, cmp
);
1558 /* Make a long logic check first. In Python 3.x, internally,
1559 all integers are represented as longs. In Python 2.x, there
1560 is still a differentiation internally between a PyInt and a
1561 PyLong. Explicitly do this long check conversion first. In
1562 GDB, for Python 3.x, we #ifdef PyInt = PyLong. This check has
1563 to be done first to ensure we do not lose information in the
1564 conversion process. */
1565 else if (PyLong_Check (obj
))
1567 LONGEST l
= PyLong_AsLongLong (obj
);
1569 if (PyErr_Occurred ())
1571 /* If the error was an overflow, we can try converting to
1572 ULONGEST instead. */
1573 if (PyErr_ExceptionMatches (PyExc_OverflowError
))
1575 PyObject
*etype
, *evalue
, *etraceback
;
1577 PyErr_Fetch (&etype
, &evalue
, &etraceback
);
1578 gdbpy_ref
<> zero (PyInt_FromLong (0));
1580 /* Check whether obj is positive. */
1581 if (PyObject_RichCompareBool (obj
, zero
.get (), Py_GT
) > 0)
1585 ul
= PyLong_AsUnsignedLongLong (obj
);
1586 if (! PyErr_Occurred ())
1587 value
= value_from_ulongest (builtin_type_upylong
, ul
);
1590 /* There's nothing we can do. */
1591 PyErr_Restore (etype
, evalue
, etraceback
);
1595 value
= value_from_longest (builtin_type_pylong
, l
);
1597 #if PY_MAJOR_VERSION == 2
1598 else if (PyInt_Check (obj
))
1600 long l
= PyInt_AsLong (obj
);
1602 if (! PyErr_Occurred ())
1603 value
= value_from_longest (builtin_type_pyint
, l
);
1606 else if (PyFloat_Check (obj
))
1608 double d
= PyFloat_AsDouble (obj
);
1610 if (! PyErr_Occurred ())
1611 value
= value_from_double (builtin_type_pyfloat
, d
);
1613 else if (gdbpy_is_string (obj
))
1615 gdb::unique_xmalloc_ptr
<char> s
1616 = python_string_to_target_string (obj
);
1618 value
= value_cstring (s
.get (), strlen (s
.get ()),
1619 builtin_type_pychar
);
1621 else if (PyObject_TypeCheck (obj
, &value_object_type
))
1622 value
= value_copy (((value_object
*) obj
)->value
);
1623 else if (gdbpy_is_lazy_string (obj
))
1627 result
= PyObject_CallMethodObjArgs (obj
, gdbpy_value_cst
, NULL
);
1628 value
= value_copy (((value_object
*) result
)->value
);
1632 PyErr_Format (PyExc_TypeError
,
1633 _("Could not convert Python object: %S."), obj
);
1635 PyErr_Format (PyExc_TypeError
,
1636 _("Could not convert Python object: %s."),
1637 PyString_AsString (PyObject_Str (obj
)));
1640 CATCH (except
, RETURN_MASK_ALL
)
1642 PyErr_Format (except
.reason
== RETURN_QUIT
1643 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
1644 "%s", except
.message
);
1652 /* Returns value object in the ARGth position in GDB's history. */
1654 gdbpy_history (PyObject
*self
, PyObject
*args
)
1657 struct value
*res_val
= NULL
; /* Initialize to appease gcc warning. */
1659 if (!PyArg_ParseTuple (args
, "i", &i
))
1664 res_val
= access_value_history (i
);
1666 CATCH (except
, RETURN_MASK_ALL
)
1668 GDB_PY_HANDLE_EXCEPTION (except
);
1672 return value_to_value_object (res_val
);
1675 /* Returns 1 in OBJ is a gdb.Value object, 0 otherwise. */
1678 gdbpy_is_value_object (PyObject
*obj
)
1680 return PyObject_TypeCheck (obj
, &value_object_type
);
1684 gdbpy_initialize_values (void)
1686 if (PyType_Ready (&value_object_type
) < 0)
1689 return gdb_pymodule_addobject (gdb_module
, "Value",
1690 (PyObject
*) &value_object_type
);
1695 static PyGetSetDef value_object_getset
[] = {
1696 { "address", valpy_get_address
, NULL
, "The address of the value.",
1698 { "is_optimized_out", valpy_get_is_optimized_out
, NULL
,
1699 "Boolean telling whether the value is optimized "
1700 "out (i.e., not available).",
1702 { "type", valpy_get_type
, NULL
, "Type of the value.", NULL
},
1703 { "dynamic_type", valpy_get_dynamic_type
, NULL
,
1704 "Dynamic type of the value.", NULL
},
1705 { "is_lazy", valpy_get_is_lazy
, NULL
,
1706 "Boolean telling whether the value is lazy (not fetched yet\n\
1707 from the inferior). A lazy value is fetched when needed, or when\n\
1708 the \"fetch_lazy()\" method is called.", NULL
},
1709 {NULL
} /* Sentinel */
1712 static PyMethodDef value_object_methods
[] = {
1713 { "cast", valpy_cast
, METH_VARARGS
, "Cast the value to the supplied type." },
1714 { "dynamic_cast", valpy_dynamic_cast
, METH_VARARGS
,
1715 "dynamic_cast (gdb.Type) -> gdb.Value\n\
1716 Cast the value to the supplied type, as if by the C++ dynamic_cast operator."
1718 { "reinterpret_cast", valpy_reinterpret_cast
, METH_VARARGS
,
1719 "reinterpret_cast (gdb.Type) -> gdb.Value\n\
1720 Cast the value to the supplied type, as if by the C++\n\
1721 reinterpret_cast operator."
1723 { "dereference", valpy_dereference
, METH_NOARGS
, "Dereferences the value." },
1724 { "referenced_value", valpy_referenced_value
, METH_NOARGS
,
1725 "Return the value referenced by a TYPE_CODE_REF or TYPE_CODE_PTR value." },
1726 { "reference_value", valpy_reference_value
, METH_NOARGS
,
1727 "Return a value of type TYPE_CODE_REF referencing this value." },
1728 { "const_value", valpy_const_value
, METH_NOARGS
,
1729 "Return a 'const' qualied version of the same value." },
1730 { "lazy_string", (PyCFunction
) valpy_lazy_string
,
1731 METH_VARARGS
| METH_KEYWORDS
,
1732 "lazy_string ([encoding] [, length]) -> lazy_string\n\
1733 Return a lazy string representation of the value." },
1734 { "string", (PyCFunction
) valpy_string
, METH_VARARGS
| METH_KEYWORDS
,
1735 "string ([encoding] [, errors] [, length]) -> string\n\
1736 Return Unicode string representation of the value." },
1737 { "fetch_lazy", valpy_fetch_lazy
, METH_NOARGS
,
1738 "Fetches the value from the inferior, if it was lazy." },
1739 {NULL
} /* Sentinel */
1742 static PyNumberMethods value_object_as_number
= {
1750 NULL
, /* nb_divmod */
1751 valpy_power
, /* nb_power */
1752 valpy_negative
, /* nb_negative */
1753 valpy_positive
, /* nb_positive */
1754 valpy_absolute
, /* nb_absolute */
1755 valpy_nonzero
, /* nb_nonzero */
1756 valpy_invert
, /* nb_invert */
1757 valpy_lsh
, /* nb_lshift */
1758 valpy_rsh
, /* nb_rshift */
1759 valpy_and
, /* nb_and */
1760 valpy_xor
, /* nb_xor */
1761 valpy_or
, /* nb_or */
1763 valpy_long
, /* nb_int */
1764 NULL
, /* reserved */
1766 NULL
, /* nb_coerce */
1767 valpy_int
, /* nb_int */
1768 valpy_long
, /* nb_long */
1770 valpy_float
, /* nb_float */
1775 NULL
, /* nb_inplace_add */
1776 NULL
, /* nb_inplace_subtract */
1777 NULL
, /* nb_inplace_multiply */
1779 NULL
, /* nb_inplace_divide */
1781 NULL
, /* nb_inplace_remainder */
1782 NULL
, /* nb_inplace_power */
1783 NULL
, /* nb_inplace_lshift */
1784 NULL
, /* nb_inplace_rshift */
1785 NULL
, /* nb_inplace_and */
1786 NULL
, /* nb_inplace_xor */
1787 NULL
, /* nb_inplace_or */
1788 NULL
, /* nb_floor_divide */
1789 valpy_divide
, /* nb_true_divide */
1790 NULL
, /* nb_inplace_floor_divide */
1791 NULL
, /* nb_inplace_true_divide */
1792 #ifndef HAVE_LIBPYTHON2_4
1793 /* This was added in Python 2.5. */
1794 valpy_long
, /* nb_index */
1795 #endif /* HAVE_LIBPYTHON2_4 */
1798 static PyMappingMethods value_object_as_mapping
= {
1804 PyTypeObject value_object_type
= {
1805 PyVarObject_HEAD_INIT (NULL
, 0)
1806 "gdb.Value", /*tp_name*/
1807 sizeof (value_object
), /*tp_basicsize*/
1809 valpy_dealloc
, /*tp_dealloc*/
1815 &value_object_as_number
, /*tp_as_number*/
1816 0, /*tp_as_sequence*/
1817 &value_object_as_mapping
, /*tp_as_mapping*/
1818 valpy_hash
, /*tp_hash*/
1819 valpy_call
, /*tp_call*/
1820 valpy_str
, /*tp_str*/
1824 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_CHECKTYPES
1825 | Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1826 "GDB value object", /* tp_doc */
1827 0, /* tp_traverse */
1829 valpy_richcompare
, /* tp_richcompare */
1830 0, /* tp_weaklistoffset */
1832 0, /* tp_iternext */
1833 value_object_methods
, /* tp_methods */
1835 value_object_getset
, /* tp_getset */
1838 0, /* tp_descr_get */
1839 0, /* tp_descr_set */
1840 0, /* tp_dictoffset */
1843 valpy_new
/* tp_new */